uasm 1.0.9+2.57

/****************************************************************************
*
* Description:  table of instructions. Other reserved words see special.hf
*
****************************************************************************/

/* The order of items for an opcode (ins + insn) is IMPORTANT!
 * And op1 has a higher precedence than op2.
 * operands with type OP_A should be before OP_Rx & OP_R
 * operands with type OP_M should follow OP_Mx
 * operands with type OP_R should follow OP_Rx
 * operands with type OP_I should follow OP_Ix
 */

/* v1.96: the table needn't be sorted anymore, but
 * "additional" (=insn) entries must still be located after the
 * main (=ins) entry. These entries must have a <suffix> so that <tok> +
 * <suffix> gives a unique identifier.
 */

/* branch instructions */
/* there are some macros in codegen.h which rely on the order of the
 * branch tokens. To satisfy those make sure:
 * - the branch instructions are in order CALL, JMP, Jcc, JeCXZ, LOOPcc
 * - no other instruction between these
 */

/*   tok   (suffix)             op1-3                      b1_inf op_dir rm_inf opcode   rm_byte       cpu      prefix */

ins (CALL, call,                OpCls( I16,  NONE,  NONE  ), 0,      0,  no_RM,  0xE8,     0x00,       P_86,        AP_BND)
insn(CALL, 1,                   OpCls( I32,  NONE,  NONE  ), 0,      0,  no_RM,  0xE8,     0x00,       P_386,       AP_BND)
insn(CALL, 2,                   OpCls( RGT8, NONE,  NONE  ), 0,      0,  no_WDS, 0xFF,     0x10,       P_86,        AP_BND)
insn(CALL, 3,                   OpCls( M32,  NONE,  NONE  ), F_32,   0,  no_WDS, 0xFF,     0x10,       P_386,       AP_BND)
insn(CALL, 4,                   OpCls( M16,  NONE,  NONE  ), F_16,   0,  no_WDS, 0xFF,     0x10,       P_86,        AP_BND)
/* start entries for FAR call */
insm(CALL, 6,                   OpCls( I32,  NONE,  NONE  ), F_16,   0,  no_RM,  0x9A,     0x00,       P_86,        AP_BND)
insn(CALL, 7,                   OpCls( I48,  NONE,  NONE  ), F_32,   0,  no_RM,  0x9A,     0x00,       P_386,       AP_BND)
insn(CALL, 8,                   OpCls( M32,  NONE,  NONE  ), F_16,   0,  no_WDS, 0xFF,     0x18,       P_86,        AP_BND)
insn(CALL, 9,                   OpCls( M48,  NONE,  NONE  ), F_32,   0,  no_WDS, 0xFF,     0x18,       P_386,       AP_BND)
ins (JMP, jmp,                  OpCls( I8,   NONE,  NONE  ), 0,      0,  no_RM,  0xEB,     0x00,       P_86,        AP_BND)
insn(JMP, 1,                    OpCls( I16,  NONE,  NONE  ), 0,      0,  no_RM,  0xE9,     0x00,       P_86,        AP_BND)
insn(JMP, 2,                    OpCls( I32,  NONE,  NONE  ), 0,      0,  no_RM,  0xE9,     0x00,       P_386,       AP_BND)
insn(JMP, 3,                    OpCls( RGT8, NONE,  NONE  ), 0,      0,  no_WDS, 0xFF,     0x20,       P_86,        AP_BND)
insn(JMP, 4,                    OpCls( M32,  NONE,  NONE  ), F_32,   0,  no_WDS, 0xFF,     0x20,       P_386,       AP_BND)
insn(JMP, 5,                    OpCls( M16,  NONE,  NONE  ), F_16,   0,  no_WDS, 0xFF,     0x20,       P_86,        AP_BND)
/* entries for FAR jmp */
insm(JMP, 7,                    OpCls( I32,  NONE,  NONE  ), F_16,   0,  no_RM,  0xEA,     0x00,       P_86,        AP_BND)
insn(JMP, 8,                    OpCls( I48,  NONE,  NONE  ), F_32,   0,  no_RM,  0xEA,     0x00,       P_386,       AP_BND)
insn(JMP, 9,                    OpCls( M32,  NONE,  NONE  ), F_16,   0,  no_WDS, 0xFF,     0x28,       P_86,        AP_BND)
insn(JMP, 10,                   OpCls( M48,  NONE,  NONE  ), F_32,   0,  no_WDS, 0xFF,     0x28,       P_386,       AP_BND)

// for conditional jumps, the SHORT version must always be first!
#define jcc( cond, code, condlc )      \
ins (J##cond, j##condlc,        OpCls( I8,   NONE,  NONE  ), 0,      0,  no_RM, 0x70+code, 0x00,       P_86,        AP_BND) \
insn(J##cond, 1,                OpCls( I,    NONE,  NONE  ), F_0F,   0,  no_RM, 0x80+code, 0x00,       P_386,       AP_BND)

jcc( A,   0x7,   a )
jcc( AE,  0x3,  ae )
jcc( B,   0x2,   b )
jcc( BE,  0x6,  be )
jcc( C,   0x2,   c )
jcc( E,   0x4,   e )
jcc( G,   0xf,   g )
jcc( GE,  0xd,  ge )
jcc( L,   0xc,   l )
jcc( LE,  0xe,  le )
jcc( NA,  0x6,  na )
jcc( NAE, 0x2, nae )
jcc( NB,  0x3,  nb )
jcc( NBE, 0x7, nbe )
jcc( NC,  0x3,  nc )
jcc( NE,  0x5,  ne )
jcc( NG,  0xe,  ng )
jcc( NGE, 0xc, nge )
jcc( NL,  0xd,  nl )
jcc( NLE, 0xf, nle )
jcc( NO,  0x1,  no )
jcc( NP,  0xb,  np )
jcc( NS,  0x9,  ns )
jcc( NZ,  0x5,  nz )
jcc( O,   0x0,   o )
jcc( P,   0xa,   p )
jcc( PE,  0xa,  pe )
jcc( PO,  0xb,  po )
jcc( S,   0x8,   s )
jcc( Z,   0x4,   z )

#undef jcc

insx(JCXZ,   jcxz,              OpCls( I8,   NONE,  NONE  ), F_16A,  0,  no_RM,  0xE3,     0x00,       P_86,        0, RWF_IA32)
ins (JECXZ,  jecxz,             OpCls( I8,   NONE,  NONE  ), F_32A,  0,  no_RM,  0xE3,     0x00,       P_386,       0)
#if AMD64_SUPPORT
insx(JRCXZ,  jrcxz,             OpCls( I8,   NONE,  NONE  ), 0,      0,  no_RM,  0xE3,     0x00,       P_64,        0, RWF_X64)
#endif
ins (LOOP,   loop,              OpCls( I8,   NONE,  NONE  ), 0,      0,  no_RM,  0xE2,     0x00,       P_86,        0)
ins (LOOPE,  loope,             OpCls( I8,   NONE,  NONE  ), 0,      0,  no_RM,  0xE1,     0x00,       P_86,        0)
ins (LOOPZ,  loopz,             OpCls( I8,   NONE,  NONE  ), 0,      0,  no_RM,  0xE1,     0x00,       P_86,        0)
ins (LOOPNE, loopne,            OpCls( I8,   NONE,  NONE  ), 0,      0,  no_RM,  0xE0,     0x00,       P_86,        0)
ins (LOOPNZ, loopnz,            OpCls( I8,   NONE,  NONE  ), 0,      0,  no_RM,  0xE0,     0x00,       P_86,        0)
ins (LOOPD,  loopd,             OpCls( I8,   NONE,  NONE  ), F_32A,  0,  no_RM,  0xE2,     0x00,       P_386,       0)
ins (LOOPED, looped,            OpCls( I8,   NONE,  NONE  ), F_32A,  0,  no_RM,  0xE1,     0x00,       P_386,       0)
ins (LOOPZD, loopzd,            OpCls( I8,   NONE,  NONE  ), F_32A,  0,  no_RM,  0xE1,     0x00,       P_386,       0)
ins (LOOPNED,loopned,           OpCls( I8,   NONE,  NONE  ), F_32A,  0,  no_RM,  0xE0,     0x00,       P_386,       0)
ins (LOOPNZD,loopnzd,           OpCls( I8,   NONE,  NONE  ), F_32A,  0,  no_RM,  0xE0,     0x00,       P_386,       0)
insx(LOOPW,  loopw,             OpCls( I8,   NONE,  NONE  ), F_16A,  0,  no_RM,  0xE2,     0x00,       P_86,        0, RWF_IA32)
insx(LOOPEW, loopew,            OpCls( I8,   NONE,  NONE  ), F_16A,  0,  no_RM,  0xE1,     0x00,       P_86,        0, RWF_IA32)
insx(LOOPZW, loopzw,            OpCls( I8,   NONE,  NONE  ), F_16A,  0,  no_RM,  0xE1,     0x00,       P_86,        0, RWF_IA32)
insx(LOOPNEW,loopnew,           OpCls( I8,   NONE,  NONE  ), F_16A,  0,  no_RM,  0xE0,     0x00,       P_86,        0, RWF_IA32)
insx(LOOPNZW,loopnzw,           OpCls( I8,   NONE,  NONE  ), F_16A,  0,  no_RM,  0xE0,     0x00,       P_86,        0, RWF_IA32)

/* arith instructions. Masm v6 encodes operand types R,R differently
 * (direction bit is NOT set). Uasm does like Masm v8+.
 */

#define ari( name, namelc, code, lock )      \
ins (name, namelc,              OpCls( RGT8, I8,    NONE  ), 0,      0,  no_WDS, 0x83,     code,       P_86,        0) \
insn(name, 1,                   OpCls( R,    R_MS,  NONE  ), 0,      1,  0,      code+2,   0x00,       P_86,        0) \
insn(name, 3,                   OpCls( A,    I,     NONE  ), 0,      0,  no_RM,  code+4,   0x00,       P_86,        0) \
insn(name, 4,                   OpCls( R,    I,     NONE  ), 0,      0,  0,      0x80,     code,       P_86,        0) \
insn(name, 6,                   OpCls( MGT8, I8,    NONE  ), 0,      0,  no_WDS, 0x83,     code,       P_86,        lock) \
insn(name, 7,                   OpCls( MS,   R,     NONE  ), 0,      0,  0,      code,     0x00,       P_86,        lock) \
insn(name, 8,                   OpCls( MS,   I,     NONE  ), 0,      0,  0,      0x80,     code,       P_86,        lock)

/* v2.02: entries 5+6 replaced by 6 */
/* v2.06: entries 1+2 replaced by 1 */
/* v2.11: added AP_LOCK argument, because CMP isn't supposed to accept this prefix */

ari( ADD, add, 0x00, AP_LOCK )
ari(  OR,  or, 0x08, AP_LOCK )
ari( ADC, adc, 0x10, AP_LOCK )
ari( SBB, sbb, 0x18, AP_LOCK )
ari( AND, and, 0x20, AP_LOCK )
ari( SUB, sub, 0x28, AP_LOCK )
ari( XOR, xor, 0x30, AP_LOCK )
ari( CMP, cmp, 0x38, 0 )

#undef ari

/* std bitshift instructions */
#define bsi( name, namelc, code )      \
ins (name, namelc,              OpCls( R_MS,  CL_ONLY,    NONE  ), 0,      0,  0,      0xD2,     code,       P_86,        0) \
insn(name, 1,                   OpCls( R_MS,  I_1,        NONE  ), 0,      0,  0,      0xD0,     code,       P_86,        0) \
insn(name, 2,                   OpCls( R_MS,  I8_U,       NONE  ), 0,      0,  0,      0xC0,     code,       P_186,       0)

bsi( RCL, rcl, 0x10 )
bsi( RCR, rcr, 0x18 )
bsi( ROL, rol, 0x00 )
bsi( ROR, ror, 0x08 )
bsi( SAL, sal, 0x20 )
bsi( SAR, sar, 0x38 )
bsi( SHL, shl, 0x20 )
bsi( SHR, shr, 0x28 )

#undef bsi

/* string instructions */

ins (CMPS,  cmps,               OpCls( MS,       MS,         NONE ), 0,      0,  no_RM,  0xA6,     0x00,       P_86,        AP_REPxx)
ins (CMPSB, cmpsb,              OpCls( NONE,     NONE,       NONE ), 0,      0,  no_RM,  0xA6,     0x00,       P_86,        AP_REPxx)
insn(CMPSB, 1,                  OpCls( M08,      M08,        NONE ), 0,      0,  no_RM,  0xA6,     0x00,       P_86,        AP_REPxx)
ins (CMPSW, cmpsw,              OpCls( NONE,     NONE,       NONE ), F_16,   0,  no_RM,  0xA7,     0x00,       P_86,        AP_REPxx)
insn(CMPSW, 1,                  OpCls( M16,      M16,        NONE ), F_16,   0,  no_RM,  0xA7,     0x00,       P_86,        AP_REPxx)
ins (CMPSD, cmpsd,              OpCls( NONE,     NONE,       NONE ), F_32,   0,  no_RM,  0xA7,     0x00,       P_386,       AP_REPxx)
insn(CMPSD, 1,                  OpCls( M32,      M32,        NONE ), F_32,   0,  no_RM,  0xA7,     0x00,       P_386,       AP_REPxx)
insn(CMPSD, 2,                  OpCls( XMM,      XMM_M64,    I8_U ), F_F20F, 1,  no_WDS, 0xC2,     0x00,       P_686|P_SSE2,W1|QSIZE|T1S)
ins (INS,   ins,                OpCls( MS,       DX_ONLY,    NONE ), 0,      0,  no_RM,  0x6C,     0x00,       P_186,       AP_REP)
ins (INSB,  insb,               OpCls( NONE,     NONE,       NONE ), 0,      0,  no_RM,  0x6C,     0x00,       P_186,       AP_REP)
insn(INSB,  1,                  OpCls( M08,      DX_ONLY,    NONE ), 0,      0,  no_RM,  0x6C,     0x00,       P_186,       AP_REP)
ins (INSW,  insw,               OpCls( NONE,     NONE,       NONE ), F_16,   0,  no_RM,  0x6D,     0x00,       P_186,       AP_REP)
insn(INSW,  1,                  OpCls( M16,      DX_ONLY,    NONE ), F_16,   0,  no_RM,  0x6D,     0x00,       P_186,       AP_REP)
ins (INSD,  insd,               OpCls( NONE,     NONE,       NONE ), F_32,   0,  no_RM,  0x6D,     0x00,       P_386,       AP_REP)
insn(INSD,  1,                  OpCls( M32,      DX_ONLY,    NONE ), F_32,   0,  no_RM,  0x6D,     0x00,       P_386,       AP_REP)
ins (LODS,  lods,               OpCls( MS,       NONE,       NONE ), 0,      0,  no_RM,  0xAC,     0x00,       P_86,        AP_REP)
ins (LODSB, lodsb,              OpCls( NONE,     NONE,       NONE ), 0,      0,  no_RM,  0xAC,     0x00,       P_86,        AP_REP)
insn(LODSB, 1,                  OpCls( M08,      NONE,       NONE ), 0,      0,  no_RM,  0xAC,     0x00,       P_86,        AP_REP)
ins (LODSW, lodsw,              OpCls( NONE,     NONE,       NONE ), F_16,   0,  no_RM,  0xAD,     0x00,       P_86,        AP_REP)
insn(LODSW, 1,                  OpCls( M16,      NONE,       NONE ), F_16,   0,  no_RM,  0xAD,     0x00,       P_86,        AP_REP)
ins (LODSD, lodsd,              OpCls( NONE,     NONE,       NONE ), F_32,   0,  no_RM,  0xAD,     0x00,       P_386,       AP_REP)
insn(LODSD, 1,                  OpCls( M32,      NONE,       NONE ), F_32,   0,  no_RM,  0xAD,     0x00,       P_386,       AP_REP)
ins (MOVS,  movs,               OpCls( MS,       MS,         NONE ), 0,      0,  no_RM,  0xA4,     0x00,       P_86,        AP_REP)
ins (MOVSB, movsb,              OpCls( NONE,     NONE,       NONE ), 0,      0,  no_RM,  0xA4,     0x00,       P_86,        AP_REP)
insn(MOVSB, 1,                  OpCls( M08,      M08,        NONE ), 0,      0,  no_RM,  0xA4,     0x00,       P_86,        AP_REP)
ins (MOVSW, movsw,              OpCls( NONE,     NONE,       NONE ), F_16,   0,  no_RM,  0xA5,     0x00,       P_86,        AP_REP)
insn(MOVSW, 1,                  OpCls( M16,      M16,        NONE ), F_16,   0,  no_RM,  0xA5,     0x00,       P_86,        AP_REP)
ins (MOVSD, movsd,              OpCls( XMM,      XMM_M64,    NONE ), F_F20F, 1,  no_WDS, 0x10,     0x00,       P_686|P_SSE2,W1|QSIZE|T1S)
insn(MOVSD, 1,                  OpCls( M64,      XMM,        NONE ), F_F20F, 0,  no_WDS, 0x11,     0x00,       P_686|P_SSE2,W1|QSIZE|T1S)
insn(MOVSD, 2,                  OpCls( NONE,     NONE,       NONE ), F_32,   0,  no_RM,  0xA5,     0x00,       P_386,       AP_REP)
insn(MOVSD, 3,                  OpCls( M32,      M32,        NONE ), F_32,   0,  no_RM,  0xA5,     0x00,       P_386,       AP_REP)
ins (OUTS,  outs,               OpCls( DX_ONLY,  MS,         NONE ), 0,      0,  no_RM,  0x6E,     0x00,       P_186,       AP_REP)
ins (OUTSB, outsb,              OpCls( NONE,     NONE,       NONE ), 0,      0,  no_RM,  0x6E,     0x00,       P_186,       AP_REP)
insn(OUTSB, 1,                  OpCls( DX_ONLY,  M08,        NONE ), 0,      0,  no_RM,  0x6E,     0x00,       P_186,       AP_REP)
ins (OUTSW, outsw,              OpCls( NONE,     NONE,       NONE ), F_16,   0,  no_RM,  0x6F,     0x00,       P_186,       AP_REP)
insn(OUTSW, 1,                  OpCls( DX_ONLY,  M16,        NONE ), F_16,   0,  no_RM,  0x6F,     0x00,       P_186,       AP_REP)
ins (OUTSD, outsd,              OpCls( NONE,     NONE,       NONE ), F_32,   0,  no_RM,  0x6F,     0x00,       P_386,       AP_REP)
insn(OUTSD, 1,                  OpCls( DX_ONLY,  M32,        NONE ), F_32,   0,  no_RM,  0x6F,     0x00,       P_386,       AP_REP)
ins (SCAS,  scas,               OpCls( MS,       NONE,       NONE ), 0,      0,  no_RM,  0xAE,     0x00,       P_86,        AP_REPxx)
ins (SCASB, scasb,              OpCls( NONE,     NONE,       NONE ), 0,      0,  no_RM,  0xAE,     0x00,       P_86,        AP_REPxx)
insn(SCASB, 1,                  OpCls( M08,      NONE,       NONE ), 0,      0,  no_RM,  0xAE,     0x00,       P_86,        AP_REPxx)
ins (SCASW, scasw,              OpCls( NONE,     NONE,       NONE ), F_16,   0,  no_RM,  0xAF,     0x00,       P_86,        AP_REPxx)
insn(SCASW, 1,                  OpCls( M16,      NONE,       NONE ), F_16,   0,  no_RM,  0xAF,     0x00,       P_86,        AP_REPxx)
ins (SCASD, scasd,              OpCls( NONE,     NONE,       NONE ), F_32,   0,  no_RM,  0xAF,     0x00,       P_386,       AP_REPxx)
insn(SCASD, 1,                  OpCls( M32,      NONE,       NONE ), F_32,   0,  no_RM,  0xAF,     0x00,       P_386,       AP_REPxx)
ins (STOS,  stos,               OpCls( MS,       NONE,       NONE ), 0,      0,  no_RM,  0xAA,     0x00,       P_86,        AP_REP)
ins (STOSB, stosb,              OpCls( NONE,     NONE,       NONE ), 0,      0,  no_RM,  0xAA,     0x00,       P_86,        AP_REP)
insn(STOSB, 1,                  OpCls( M08,      NONE,       NONE ), 0,      0,  no_RM,  0xAA,     0x00,       P_86,        AP_REP)
ins (STOSW, stosw,              OpCls( NONE,     NONE,       NONE ), F_16,   0,  no_RM,  0xAB,     0x00,       P_86,        AP_REP)
insn(STOSW, 1,                  OpCls( M16,      NONE,       NONE ), F_16,   0,  no_RM,  0xAB,     0x00,       P_86,        AP_REP)
ins (STOSD, stosd,              OpCls( NONE,     NONE,       NONE ), F_32,   0,  no_RM,  0xAB,     0x00,       P_386,       AP_REP)
insn(STOSD, 1,                  OpCls( M32,      NONE,       NONE ), F_32,   0,  no_RM,  0xAB,     0x00,       P_386,       AP_REP)

/* instructions invalid for IA32+ */

insx(AAA, aaa,                  OpCls( NONE,     NONE,       NONE ), 0,      0,  no_RM,  0x37,     0x00,       P_86,        0, RWF_IA32 )
insx(AAD, aad,                  OpCls( NONE,     NONE,       NONE ), 0,      0,  0,      0xD5,     0x0A,       P_86,        0, RWF_IA32 )
insn(AAD, 1,                    OpCls( I8,       NONE,       NONE ), 0,      1,  no_RM,  0xD5,     0x00,       P_86,        RWF_IA32 ) /*UASM 2.57*/
insx(AAM, aam,                  OpCls( NONE,     NONE,       NONE ), 0,      0,  0,      0xD4,     0x0A,       P_86,        0, RWF_IA32 )
insn(AAM, 1,                    OpCls( I8,       NONE,       NONE ), 0,      1,  no_RM,  0xD4,     0x00,       P_86,        RWF_IA32 ) /*UASM 2.57*/
insx(AAS, aas,                  OpCls( NONE,     NONE,       NONE ), 0,      0,  no_RM,  0x3F,     0x00,       P_86,        0, RWF_IA32 )
insx(DAA, daa,                  OpCls( NONE,     NONE,       NONE ), 0,      0,  no_RM,  0x27,     0x00,       P_86,        0, RWF_IA32 )
insx(DAS, das,                  OpCls( NONE,     NONE,       NONE ), 0,      0,  no_RM,  0x2F,     0x00,       P_86,        0, RWF_IA32 )
insx(LDS, lds,                  OpCls( RGT8,     MFPTR,      NONE ), 0,      1,  no_WDS, 0xC5,     0x00,       P_86,        0, RWF_IA32 )
insx(LES, les,                  OpCls( RGT8,     MFPTR,      NONE ), 0,      1,  no_WDS, 0xC4,     0x00,       P_86,        0, RWF_IA32 )
insx(POPA,  popa,               OpCls( NONE,     NONE,       NONE ), 0,      0,  no_RM,  0x61,     0x00,       P_186,       0, RWF_IA32 )
insx(POPAD, popad,              OpCls( NONE,     NONE,       NONE ), F_32,   0,  no_RM,  0x61,     0x00,       P_386,       0, RWF_IA32 )
insx(POPAW, popaw,              OpCls( NONE,     NONE,       NONE ), F_16,   0,  no_RM,  0x61,     0x00,       P_186,       0, RWF_IA32 )
insx(POPFD, popfd,              OpCls( NONE,     NONE,       NONE ), F_32,   0,  no_RM,  0x9D,     0x00,       P_386,       0, RWF_IA32 )
insx(PUSHA,  pusha,             OpCls( NONE,     NONE,       NONE ), 0,      0,  no_RM,  0x60,     0x00,       P_186,       0, RWF_IA32 )
insx(PUSHAD, pushad,            OpCls( NONE,     NONE,       NONE ), F_32,   0,  no_RM,  0x60,     0x00,       P_386,       0, RWF_IA32 )
insx(PUSHAW, pushaw,            OpCls( NONE,     NONE,       NONE ), F_16,   0,  no_RM,  0x60,     0x00,       P_186,       0, RWF_IA32 )
insx(PUSHFD, pushfd,            OpCls( NONE,     NONE,       NONE ), F_32,   0,  no_RM,  0x9C,     0x00,       P_386,       0, RWF_IA32 )
insx(PUSHD,  pushd,             OpCls( I8,       NONE,       NONE ), F_32,   0,  no_RM,  0x6A,     0x00,       P_386,       0, RWF_IA32 )
insn(PUSHD,  1,                 OpCls( I32,      NONE,       NONE ), F_32,   0,  no_RM,  0x68,     0x00,       P_386,       0)
insn(PUSHD,  2,                 OpCls( R32,      NONE,       NONE ), 0,      0,  R_in_OP,0x50,     0x00,       P_386,       0)
insn(PUSHD,  3,                 OpCls( SR86,     NONE,       NONE ), 0,      1,  R_in_OP,0x06,     0x00,       P_86,        0)
insn(PUSHD,  4,                 OpCls( SR,       NONE,       NONE ), F_0F,   1,  R_in_OP,0x80,     0x00,       P_386,       0)
insn(PUSHD,  5,                 OpCls( M32,      NONE,       NONE ), 0,      0,  0,      0xFF,     0x30,       P_386,       0)
/* unlike their names suggest, RETD/RETW will always create a 32-/16-bit far ret */
insx(RETD, retd,                OpCls( I16,      NONE,       NONE ), F_32,   0,  no_RM,  0xCA,     0x00,       P_386,       0, RWF_IA32 )
insn(RETD, 1,                   OpCls( NONE,     NONE,       NONE ), F_32,   0,  no_RM,  0xCB,     0x00,       P_386,       0)
insx(RETW, retw,                OpCls( I16,      NONE,       NONE ), F_16,   0,  no_RM,  0xCA,     0x00,       P_86,        0, RWF_IA32 )
insn(RETW, 1,                   OpCls( NONE,     NONE,       NONE ), F_16,   0,  no_RM,  0xCB,     0x00,       P_86,        0)

/* protected-mode instructions */
/* some (i.e. SMSW) also work with 32bit register as first operand, but Masm won't accept.
 * to make Uasm accept, change OP_R16 to OP_RGT8
 */

ins (ARPL, arpl,                OpCls( R16_M16,  R16,      NONE ), 0,       0,  no_WDS, 0x63,     0x00,       P_286,       0)
ins (LLDT, lldt,                OpCls( R16_M16,  NONE,     NONE ), F_0FNO66,0,  no_WDS, 0x00,     0x10,       P_286p,      0)
ins (LMSW, lmsw,                OpCls( R16_M16,  NONE,     NONE ), F_0FNO66,0,  no_WDS, 0x01,     0x30,       P_286p,      0)
ins (LTR,  ltr,                 OpCls( R16_M16,  NONE,     NONE ), F_0FNO66,0,  no_WDS, 0x00,     0x18,       P_286p,      0)
ins (SLDT, sldt,                OpCls( R16_M16,  NONE,     NONE ), F_0FNO66,0,  no_WDS, 0x00,     0x00,       P_286,       0)
ins (SMSW, smsw,                OpCls( R16_M16,  NONE,     NONE ), F_0FNO66,0,  no_WDS, 0x01,     0x20,       P_286,       0)
ins (STR,  str,                 OpCls( R16_M16,  NONE,     NONE ), F_0FNO66,0,  no_WDS, 0x00,     0x08,       P_286,       0)
ins (VERR, verr,                OpCls( R16_M16,  NONE,     NONE ), F_0FNO66,0,  no_WDS, 0x00,     0x20,       P_286,       0)
ins (VERW, verw,                OpCls( R16_M16,  NONE,     NONE ), F_0FNO66,0,  no_WDS, 0x00,     0x28,       P_286,       0)
/* v2.06: obsolete */
//insn(ARPL, 1,                   OP_M16,      OP_R16,       OP_NONE, 0,       0,  no_WDS, 0x63,     0x00,       P_286,       0)
//insn(LLDT, 1,                   OP_M16,      OP_NONE,      OP_NONE, F_0FNO66,0,  no_WDS, 0x00,     0x10,       P_286p,      0)
//insn(LMSW, 1,                   OP_M16,      OP_NONE,      OP_NONE, F_0FNO66,0,  no_WDS, 0x01,     0x30,       P_286p,      0)
//insn(LTR,  1,                   OP_M16,      OP_NONE,      OP_NONE, F_0FNO66,0,  no_WDS, 0x00,     0x18,       P_286p,      0)
//insn(SLDT, 1,                   OP_M16,      OP_NONE,      OP_NONE, F_0FNO66,0,  no_WDS, 0x00,     0x00,       P_286,       0)
//insn(SMSW, 1,                   OP_M16,      OP_NONE,      OP_NONE, F_0FNO66,0,  no_WDS, 0x01,     0x20,       P_286,       0)
//insn(STR,  1,                   OP_M16,      OP_NONE,      OP_NONE, F_0FNO66,0,  no_WDS, 0x00,     0x08,       P_286,       0)
//insn(VERR, 1,                   OP_M16,      OP_NONE,      OP_NONE, F_0FNO66,0,  no_WDS, 0x00,     0x20,       P_286,       0)
//insn(VERW, 1,                   OP_M16,      OP_NONE,      OP_NONE, F_0FNO66,0,  no_WDS, 0x00,     0x28,       P_286,       0)

/* one-operand register/memory instructions */

ins (DIV, div,                  OpCls( R,        NONE,       NONE ), 0,      0,  0,      0xF6,     0x30,       P_86,        0)
insn(DIV, 1,                    OpCls( M08,      NONE,       NONE ), 0,      0,  0,      0xF6,     0x30,       P_86,        0)
insn(DIV, 2,                    OpCls( MGT8,     NONE,       NONE ), 0,      0,  0,      0xF7,     0x30,       P_86,        0)
ins (IDIV, idiv,                OpCls( R,        NONE,       NONE ), 0,      0,  0,      0xF6,     0x38,       P_86,        0)
insn(IDIV, 1,                   OpCls( M08,      NONE,       NONE ), 0,      0,  0,      0xF6,     0x38,       P_86,        0)
insn(IDIV, 2,                   OpCls( MGT8,     NONE,       NONE ), 0,      0,  0,      0xF7,     0x38,       P_86,        0)
ins (MUL, mul,                  OpCls( R,        NONE,       NONE ), 0,      0,  0,      0xF6,     0x20,       P_86,        0)
insn(MUL, 1,                    OpCls( M08,      NONE,       NONE ), 0,      0,  0,      0xF6,     0x20,       P_86,        0)
insn(MUL, 2,                    OpCls( MGT8,     NONE,       NONE ), 0,      0,  0,      0xF7,     0x20,       P_86,        0)
ins (NEG, neg,                  OpCls( R,        NONE,       NONE ), 0,      0,  0,      0xF6,     0x18,       P_86,        0)
insn(NEG, 1,                    OpCls( M08,      NONE,       NONE ), 0,      0,  0,      0xF6,     0x18,       P_86,        AP_LOCK)
insn(NEG, 2,                    OpCls( MGT8,     NONE,       NONE ), 0,      0,  0,      0xF7,     0x18,       P_86,        AP_LOCK)
ins (NOT, not,                  OpCls( R,        NONE,       NONE ), 0,      0,  0,      0xF6,     0x10,       P_86,        0)
insn(NOT, 1,                    OpCls( M08,      NONE,       NONE ), 0,      0,  0,      0xF6,     0x10,       P_86,        AP_LOCK)
insn(NOT, 2,                    OpCls( MGT8,     NONE,       NONE ), 0,      0,  0,      0xF7,     0x10,       P_86,        AP_LOCK)

/* prefixes. must start with LOCK, end with REPZ and be consecutive */
ins (LOCK,  lock,               OpCls( NONE,     NONE,       NONE ), 0,      0,  no_RM,  0xF0,     0,          P_86,        AP_LOCK)
ins (REP,   rep,                OpCls( NONE,     NONE,       NONE ), 0,      0,  no_RM,  0xF3,     0,          P_86,        AP_REP)
ins (REPE,  repe,               OpCls( NONE,     NONE,       NONE ), 0,      0,  no_RM,  0xF3,     0,          P_86,        AP_REPxx)
ins (REPNE, repne,              OpCls( NONE,     NONE,       NONE ), 0,      0,  no_RM,  0xF2,     0,          P_86,        AP_REPxx)
ins (BND,   bnd,                OpCls( NONE,     NONE,       NONE ), 0,      0,  no_RM,  0xF2,     0,          P_686,       AP_BND)
ins (REPNZ, repnz,              OpCls( NONE,     NONE,       NONE ), 0,      0,  no_RM,  0xF2,     0,          P_86,        AP_REPxx)
ins (REPZ,  repz,               OpCls( NONE,     NONE,       NONE ), 0,      0,  no_RM,  0xF3,     0,          P_86,        AP_REPxx)

/* BTx */

ins (BT, bt,                    OpCls( RGT8,     RGT8,       NONE ), F_0F,   0,  no_WDS, 0xA3,     0x00,       P_386,       0)
insn(BT,   1,                   OpCls( RGT8,     I8_U,       NONE ), F_0F,   0,  no_WDS, 0xBA,     0x20,       P_386,       0)
insn(BT,   2,                   OpCls( MGT8,     RGT8,       NONE ), F_0F,   0,  no_WDS, 0xA3,     0x00,       P_386,       0)
insn(BT,   3,                   OpCls( MGT8,     I8_U,       NONE ), F_0F,   0,  no_WDS, 0xBA,     0x20,       P_386,       0)
ins (BTC, btc,                  OpCls( RGT8,     RGT8,       NONE ), F_0F,   0,  no_WDS, 0xBB,     0x00,       P_386,       0)
insn(BTC,  1,                   OpCls( RGT8,     I8_U,       NONE ), F_0F,   0,  no_WDS, 0xBA,     0x38,       P_386,       0)
insn(BTC,  2,                   OpCls( MGT8,     RGT8,       NONE ), F_0F,   0,  no_WDS, 0xBB,     0x00,       P_386,       AP_LOCK)
insn(BTC,  3,                   OpCls( MGT8,     I8_U,       NONE ), F_0F,   0,  no_WDS, 0xBA,     0x38,       P_386,       AP_LOCK)
ins (BTR, btr,                  OpCls( RGT8,     RGT8,       NONE ), F_0F,   0,  no_WDS, 0xB3,     0x00,       P_386,       0)
insn(BTR,  1,                   OpCls( RGT8,     I8_U,       NONE ), F_0F,   0,  no_WDS, 0xBA,     0x30,       P_386,       0)
insn(BTR,  2,                   OpCls( MGT8,     RGT8,       NONE ), F_0F,   0,  no_WDS, 0xB3,     0x00,       P_386,       AP_LOCK)
insn(BTR,  3,                   OpCls( MGT8,     I8_U,       NONE ), F_0F,   0,  no_WDS, 0xBA,     0x30,       P_386,       AP_LOCK)
ins (BTS, bts,                  OpCls( RGT8,     RGT8,       NONE ), F_0F,   0,  no_WDS, 0xAB,     0x00,       P_386,       0)
insn(BTS,  1,                   OpCls( RGT8,     I8_U,       NONE ), F_0F,   0,  no_WDS, 0xBA,     0x28,       P_386,       0)
insn(BTS,  2,                   OpCls( MGT8,     RGT8,       NONE ), F_0F,   0,  no_WDS, 0xAB,     0x00,       P_386,       AP_LOCK)
insn(BTS,  3,                   OpCls( MGT8,     I8_U,       NONE ), F_0F,   0,  no_WDS, 0xBA,     0x28,       P_386,       AP_LOCK)

/* set/reset flags */

ins (CMC, cmc,                  OpCls( NONE,     NONE,       NONE ), 0,      0,  no_RM,  0xF5,     0x00,       P_86,        0)
ins (CLC, clc,                  OpCls( NONE,     NONE,       NONE ), 0,      0,  no_RM,  0xF8,     0x00,       P_86,        0)
ins (STC, stc,                  OpCls( NONE,     NONE,       NONE ), 0,      0,  no_RM,  0xF9,     0x00,       P_86,        0)
ins (CLI, cli,                  OpCls( NONE,     NONE,       NONE ), 0,      0,  no_RM,  0xFA,     0x00,       P_86,        0)
ins (STI, sti,                  OpCls( NONE,     NONE,       NONE ), 0,      0,  no_RM,  0xFB,     0x00,       P_86,        0)
ins (CLD, cld,                  OpCls( NONE,     NONE,       NONE ), 0,      0,  no_RM,  0xFC,     0x00,       P_86,        0)
ins (STD, std,                  OpCls( NONE,     NONE,       NONE ), 0,      0,  no_RM,  0xFD,     0x00,       P_86,        0)
ins (CLAC, clac,                OpCls( NONE,     NONE,       NONE ), F_0F,   0,  no_RM,  0xCA,     0x00,       P_686,       0)

/* INC/DEC. (hack for 64-bit in reswords.c!) */

ins (INC, inc,                  OpCls( RGT8,     NONE,       NONE ), 0,      0,  R_in_OP,0x40,     0x00,       P_86,        0)
insn(INC, 1,                    OpCls( R,        NONE,       NONE ), 0,      0,  0,      0xFE,     0x00,       P_86,        0)
insn(INC, 2,                    OpCls( M08,      NONE,       NONE ), 0,      0,  0,      0xFE,     0x00,       P_86,        AP_LOCK)
insn(INC, 3,                    OpCls( MGT8,     NONE,       NONE ), 0,      0,  0,      0xFF,     0x00,       P_86,        AP_LOCK)
ins (DEC, dec,                  OpCls( RGT8,     NONE,       NONE ), 0,      0,  R_in_OP,0x48,     0x00,       P_86,        0)
insn(DEC, 1,                    OpCls( R,        NONE,       NONE ), 0,      0,  0,      0xFE,     0x08,       P_86,        0)
insn(DEC, 2,                    OpCls( M08,      NONE,       NONE ), 0,      0,  0,      0xFE,     0x08,       P_86,        AP_LOCK)
insn(DEC, 3,                    OpCls( MGT8,     NONE,       NONE ), 0,      0,  0,      0xFF,     0x08,       P_86,        AP_LOCK)

/* PUSH/POP (16- and 32-bit only) */

ins (PUSH,  push,               OpCls( R16_R32,  NONE,       NONE ), 0,     0,  R_in_OP,0x50,     0x00,       P_86,        0)
insn(PUSH, 1,                   OpCls( I8,       NONE,       NONE ), 0,     0,  no_RM,  0x6A,     0x00,       P_186,       0)
insn(PUSH, 2,                   OpCls( I,        NONE,       NONE ), 0,     0,  no_RM,  0x68,     0x00,       P_186,       0)
insn(PUSH, 3,                   OpCls( SR86,     NONE,       NONE ), 0,     1,  R_in_OP,0x06,     0x00,       P_86,        0)
insn(PUSH, 4,                   OpCls( SR,       NONE,       NONE ), F_0F,  1,  R_in_OP,0x80,     0x00,       P_386,       0)
insn(PUSH, 5,                   OpCls( M16_M32,  NONE,       NONE ), 0,     0,  0,      0xFF,     0x30,       P_86,        0)
ins (POP, pop,                  OpCls( R16_R32,  NONE,       NONE ), 0,     0,  R_in_OP,0x58,     0x00,       P_86,        0)
insn(POP, 1,                    OpCls( SR86,     NONE,       NONE ), 0,     1,  R_in_OP,0x07,     0x00,       P_86,        0)
insn(POP, 2,                    OpCls( SR,       NONE,       NONE ), F_0F,  1,  R_in_OP,0x81,     0x00,       P_386,       0)
insn(POP, 3,                    OpCls( M16_M32,  NONE,       NONE ), 0,     0,  0,      0x8F,     0x00,       P_86,        0)
ins (PUSHW,  pushw,             OpCls( I8,       NONE,       NONE ), F_16,  0,  no_RM,  0x6A,     0x00,       P_186,       0)
insn(PUSHW,  1,                 OpCls( I16,      NONE,       NONE ), F_16,  0,  no_RM,  0x68,     0x00,       P_186,       0)
ins (PUSHF,  pushf,             OpCls( NONE,     NONE,       NONE ), F_16,  0,  no_RM,  0x9C,     0x00,       P_86,        0)
ins (POPF,  popf,               OpCls( NONE,     NONE,       NONE ), F_16,  0,  no_RM,  0x9D,     0x00,       P_86,        0)

/* UASM 2.48 Legacy CodeGen detection of MOVABS pseudo-instruction */
ins (MOVABS, movabs,             OpCls(A,         MS,         NONE), 0,      1,  no_RM,  0xA0,     0x00,       P_86,        0)
insn(MOVABS, 1,                  OpCls(MS,        A,          NONE), 0,      0,  no_RM,  0xA2,     0x00,       P_86,        0)

/* MOV */

ins (MOV, mov,                  OpCls( A,        MS,         NONE ), 0,      1,  no_RM,  0xA0,     0x00,       P_86,        0)
insn(MOV, 1,                    OpCls( R,        R_MS,       NONE ), 0,      1,  0,      0x8A,     0x00,       P_86,        0)
insn(MOV, 2,                    OpCls( R8,       I,          NONE ), 0,      0,  R_in_OP,0xB0,     0x00,       P_86,        0)
insn(MOV, 3,                    OpCls( R16_R32,  I,          NONE ), 0,      0,  R_in_OP,0xB8,     0x00,       P_86,        0)
#if AMD64_SUPPORT
insn(MOV, 4,                    OpCls( R64,      I,          NONE ), 0,      0,  0,      0xC6,     0x00,       P_64,        0)
insn(MOV, 5,                    OpCls( R64,      I64,        NONE ), 0,      0,  R_in_OP,0xB8,     0x00,       P_64,        0)
#endif
insn(MOV, 6,                    OpCls( RGT8,     SR,         NONE ), 0,      0,  no_WDS, 0x8C,     0xC0,       P_86,        0)
insn(MOV, 7,                    OpCls( SR,       RGT8,       NONE ), 0,      1,  no_WDS, 0x8E,     0xC0,       P_86,        0)
insn(MOV, 8,                    OpCls( SR,       MS,         NONE ), 0,      1,  no_WDS, 0x8E,     0x00,       P_86,        0)
insn(MOV, 9,                    OpCls( MS,       A,          NONE ), 0,      0,  no_RM,  0xA2,     0x00,       P_86,        0)
insn(MOV, 10,                   OpCls( MS,       R,          NONE ), 0,      0,  0,      0x88,     0x00,       P_86,        0)
insn(MOV, 11,                   OpCls( MS,       I,          NONE ), 0,      0,  0,      0xC6,     0x00,       P_86,        0)
insn(MOV, 12,                   OpCls( MS,       SR,         NONE ), 0,      0,  no_WDS, 0x8C,     0x00,       P_86,        0)
insn(MOV, 13,                   OpCls( RGT16,    RSPEC,      NONE ), F_0FNO66,0, no_WDS, 0x20,     0xC0,       P_386,       0)
insn(MOV, 14,                   OpCls( RSPEC,    RGT16,      NONE ), F_0FNO66,1, no_WDS, 0x22,     0xC0,       P_386,       0)
ins (MOVBE, movbe,              OpCls( RGT8,     MGT8,       NONE ), F_0F38,  1, no_WDS, 0xF0,     0x00,       P_486,       0)
insn(MOVBE, 1,                  OpCls( MGT8,     RGT8,       NONE ), F_0F38,  0, no_WDS, 0xF1,     0x00,       P_486,       0)

/* rest */

ins (BOUND_, bound,             OpCls( RGT8,     MS,         NONE ), 0,      1,  no_WDS, 0x62,     0x00,       P_186,       0)
ins (BSF, bsf,                  OpCls( RGT8,     RGT8_MS,    NONE ), F_0F,   1,  no_WDS, 0xBC,     0x00,       P_386,       0)
ins (BSR, bsr,                  OpCls( RGT8,     RGT8_MS,    NONE ), F_0F,   1,  no_WDS, 0xBD,     0x00,       P_386,       0)
ins (BSWAP, bswap,              OpCls( RGT16,    NONE,       NONE ), F_0F,   0,  R_in_OP,0xC8,     0x00,       P_486,       0)
ins (CBW, cbw,                  OpCls( NONE,     NONE,       NONE ), F_16,   0,  no_RM,  0x98,     0x00,       P_86,        0)
ins (CDQ, cdq,                  OpCls( NONE,     NONE,       NONE ), F_32,   0,  no_RM,  0x99,     0x00,       P_386,       0)
ins (CWD, cwd,                  OpCls( NONE,     NONE,       NONE ), F_16,   0,  no_RM,  0x99,     0x00,       P_86,        0)
ins (CWDE, cwde,                OpCls( NONE,     NONE,       NONE ), F_32,   0,  no_RM,  0x98,     0x00,       P_386,       0)
ins (CLTS, clts,                OpCls( NONE,     NONE,       NONE ), 0,      0,  0,      0x0F,     0x06,       P_286p,      0)
ins (CMPXCHG, cmpxchg,          OpCls( R,        R,          NONE ), F_0F,   0,  0,      0xB0,     0x00,       P_486,       0)
insn(CMPXCHG, 1,                OpCls( MS,       R,          NONE ), F_0F,   0,  0,      0xB0,     0x00,       P_486,       AP_LOCK)
ins (CMPXCHG8B, cmpxchg8b,      OpCls( M64,      NONE,       NONE ), F_0F,   0,  0,      0xC7,     0x08,       P_586,       AP_LOCK)
ins (CPUID, cpuid,              OpCls( NONE,     NONE,       NONE ), 0,      0,  0,      0x0F,     0xA2,       P_586,       0)
ins (ENTER, enter,              OpCls( I16,      I8_U,       NONE ), 0,      0,  no_RM,  0xC8,     0x00,       P_186,       0)
ins (HLT, hlt,                  OpCls( NONE,     NONE,       NONE ), 0,      0,  no_RM,  0xF4,     0x00,       P_86,        0)
ins (IMUL, imul,                OpCls( R,        NONE,       NONE ), 0,      0,  0,      0xF6,     0x28,       P_86,        0)
insn(IMUL, 2,                   OpCls( M08,      NONE,       NONE ), 0,      0,  0,      0xF6,     0x28,       P_86,        0)
insn(IMUL, 3,                   OpCls( MGT8,     NONE,       NONE ), 0,      0,  0,      0xF7,     0x28,       P_86,        0)
insn(IMUL, 4,                   OpCls( RGT8,     R_MS,       NONE ), F_0F,   1,  no_WDS, 0xAF,     0x00,       P_386,       0)
insn(IMUL, 6,                   OpCls( RGT8,     I8,         NONE ), 0,      1,  no_WDS, 0x6B,     0x00,       P_186,       0)
insn(IMUL, 7,                   OpCls( RGT8,     I,          NONE ), 0,      1,  no_WDS, 0x69,     0x00,       P_186,       0)
insn(IMUL, 8,                   OpCls( RGT8,     R_MS,       I8_U ), 0,      1,  no_WDS, 0x6B,     0x00,       P_186,       0)
insn(IMUL, 9,                   OpCls( RGT8,     R_MS,       I    ), 0,      1,  no_WDS, 0x69,     0x00,       P_186,       0)
ins (IN, in,                    OpCls( A,        DX_ONLY,    NONE ), 0,      0,  no_RM,  0xEC,     0x00,       P_86,        0)
insn(IN, 1,                     OpCls( A,        I8_U,       NONE ), 0,      0,  no_RM,  0xE4,     0x00,       P_86,        0)
ins (INT, int,                  OpCls( I_3,      NONE,       NONE ), 0,      0,  no_RM,  0xCC,     0x00,       P_86,        0)
insn(INT, 1,                    OpCls( I8_U,     NONE,       NONE ), 0,      0,  no_RM,  0xCD,     0x00,       P_86,        0)
ins (INTO, into,                OpCls( NONE,     NONE,       NONE ), 0,      0,  no_RM,  0xCE,     0x00,       P_86,        0)
ins (INVD, invd,                OpCls( NONE,     NONE,       NONE ), F_0F,   0,  no_RM,  0x08,     0x00,       P_486,       0)
ins (INVLPG, invlpg,            OpCls( M_ANY,    NONE,       NONE ), F_0F,   0,  no_WDS, 0x01,     0x38,       P_486,       0)
ins (IRET, iret,                OpCls( NONE,     NONE,       NONE ), F_16,   0,  no_RM,  0xCF,     0x00,       P_86,        0)
ins (IRETD, iretd,              OpCls( NONE,     NONE,       NONE ), F_32,   0,  no_RM,  0xCF,     0x00,       P_386,       0)
/* the F-suffix variants of IRET/IRETD are just aliases and pretty useless.
 * In Masm v8+, IRETF has disappeared, but IRETDF is still there.
 */
ins (IRETF, iretf,              OpCls( NONE,     NONE,       NONE ), F_16,   0,  no_RM,  0xCF,     0x00,       P_86,        0)
ins (IRETDF, iretdf,            OpCls( NONE,     NONE,       NONE ), F_32,   0,  no_RM,  0xCF,     0x00,       P_386,       0)
ins (LAHF, lahf,                OpCls( NONE,     NONE,       NONE ), 0,      0,  no_RM,  0x9F,     0x00,       P_86,        0)
ins (LAR, lar,                  OpCls( RGT8,     RGT8_MS,    NONE ), F_0F,   1,  no_WDS, 0x02,     0x00,       P_286,       0)
ins (LSL, lsl,                  OpCls( RGT8,     RGT8_MS,    NONE ), F_0F,   1,  no_WDS, 0x03,     0x00,       P_286,       0)
ins (LEA, lea,                  OpCls( RGT8,     MS,         NONE ), 0,      1,  no_WDS, 0x8D,     0x00,       P_86,        0)
ins (LEAVE, leave,              OpCls( NONE,     NONE,       NONE ), 0,      0,  no_RM,  0xC9,     0x00,       P_186,       0)
ins (LFS, lfs,                  OpCls( RGT8,     MFPTR,      NONE ), F_0F,   1,  no_WDS, 0xB4,     0x00,       P_386,       0)
ins (LGS, lgs,                  OpCls( RGT8,     MFPTR,      NONE ), F_0F,   1,  no_WDS, 0xB5,     0x00,       P_386,       0)
ins (LSS, lss,                  OpCls( RGT8,     MFPTR,      NONE ), F_0F,   1,  no_WDS, 0xB2,     0x00,       P_386,       0)
ins (LGDT, lgdt,                OpCls( M48,      NONE,       NONE ), F_0F,   0,  no_WDS, 0x01,     0x10,       P_286p,      0)
ins (LIDT, lidt,                OpCls( M48,      NONE,       NONE ), F_0F,   0,  no_WDS, 0x01,     0x18,       P_286p,      0)
ins (MOVSX, movsx,              OpCls( RGT8,     R_MS,       NONE ), F_0F,   1,  0,      0xBE,     0x00,       P_386,       0)
ins (MOVZX, movzx,              OpCls( RGT8,     R_MS,       NONE ), F_0F,   1,  0,      0xB6,     0x00,       P_386,       0)
ins (NOP, nop,                  OpCls( NONE,     NONE,       NONE ), 0,      0,  no_RM,  0x90,     0x00,       P_86,        0)
ins (OUT, out,                  OpCls( DX_ONLY,  A,          NONE ), 0,      0,  no_RM,  0xEE,     0x00,       P_86,        0)
insn(OUT, 1,                    OpCls( I8_U,     A,          NONE ), 0,      0,  no_RM,  0xE6,     0x00,       P_86,        0)

ins (RDMSR, rdmsr,              OpCls( NONE,     NONE,       NONE ), F_0F,   0,  no_RM,  0x32,     0x00,       P_586,       0)
/* v2.11: RDPMC is accepted with .586 ( was: .686 ) */
ins (RDPMC, rdpmc,              OpCls( NONE,     NONE,       NONE ), F_0F,   0,  no_RM,  0x33,     0x00,       P_586,       0)
ins (RDTSC, rdtsc,              OpCls( NONE,     NONE,       NONE ), F_0F,   0,  no_RM,  0x31,     0x00,       P_586,       0)
ins (RDTSCP, rdtscp,            OpCls( NONE,     NONE,       NONE ), F_0F,   0,  no_WDS, 0x01,     0xF9,       P_686,       0)
ins (RET,  ret,                 OpCls( I16,      NONE,       NONE ), 0,      0,  no_RM,  0xC2,     0x00,       P_86,        AP_BND)
insn(RET,  1,                   OpCls( NONE,     NONE,       NONE ), 0,      0,  no_RM,  0xC3,     0x00,       P_86,        AP_BND)
ins (RETN, retn,                OpCls( I16,      NONE,       NONE ), 0,      0,  no_RM,  0xC2,     0x00,       P_86,        AP_BND)
insn(RETN, 1,                   OpCls( NONE,     NONE,       NONE ), 0,      0,  no_RM,  0xC3,     0x00,       P_86,        AP_BND)
ins (RETF, retf,                OpCls( I16,      NONE,       NONE ), 0,      0,  no_RM,  0xCA,     0x00,       P_86,        0)
insn(RETF, 1,                   OpCls( NONE,     NONE,       NONE ), 0,      0,  no_RM,  0xCB,     0x00,       P_86,        0)
ins (RSM, rsm,                  OpCls( NONE,     NONE,       NONE ), F_0F,   0,  no_RM,  0xAA,     0x00,       P_586,       0)
ins (SAHF, sahf,                OpCls( NONE,     NONE,       NONE ), 0,      0,  no_RM,  0x9E,     0x00,       P_86,        0)
ins (SGDT, sgdt,                OpCls( M_ANY,    NONE,       NONE ), F_0F,   0,  no_WDS, 0x01,     0x00,       P_286,       0)
ins (SIDT, sidt,                OpCls( M_ANY,    NONE,       NONE ), F_0F,   0,  no_WDS, 0x01,     0x08,       P_286,       0)
ins (SHLD, shld,                OpCls( RGT8_MGT8,RGT8,       CL   ), F_0F,   0,  no_WDS, 0xA5,     0x00,       P_386,       0)
insn(SHLD, 1,                   OpCls( RGT8_MGT8,RGT8,       I8_U ), F_0F,   0,  no_WDS, 0xA4,     0x00,       P_386,       0)
ins (SHRD, shrd,                OpCls( RGT8_MGT8,RGT8,       CL   ), F_0F,   0,  no_WDS, 0xAD,     0x00,       P_386,       0)
insn(SHRD, 1,                   OpCls( RGT8_MGT8,RGT8,       I8_U ), F_0F,   0,  no_WDS, 0xAC,     0x00,       P_386,       0)
ins (SYSENTER, sysenter,        OpCls( NONE,     NONE,       NONE ), F_0F,   0,  no_RM,  0x34,     0x00,       P_686,       0)
ins (SYSEXIT, sysexit,          OpCls( NONE,     NONE,       NONE ), F_0F,   0,  no_RM,  0x35,     0x00,       P_686p,      0)
ins (TEST, test,                OpCls( A,        I,          NONE ), 0,      0,  no_RM,  0xA8,     0x00,       P_86,        0)
insn(TEST, 1,                   OpCls( R,        R_MS,       NONE ), 0,      1,  0,      0x84,     0x00,       P_86,        0)
insn(TEST, 3,                   OpCls( R_MS,     I,          NONE ), 0,      0,  0,      0xF6,     0x00,       P_86,        0)
insn(TEST, 4,                   OpCls( MS,       R,          NONE ), 0,      0,  0,      0x84,     0x00,       P_86,        0)
ins (UD2, ud2,                  OpCls( NONE,     NONE,       NONE ), F_0F,   0,  no_RM,  0x0B,     0x00,       P_686,       0)
ins (WAIT, wait,                OpCls( NONE,     NONE,       NONE ), 0,      0,  no_RM,  0x9B,     0x00,       P_86,        0)
ins (WBINVD, wbinvd,            OpCls( NONE,     NONE,       NONE ), F_0F,   0,  no_RM,  0x09,     0x00,       P_486,       0)
ins (WRMSR, wrmsr,              OpCls( NONE,     NONE,       NONE ), F_0F,   0,  no_RM,  0x30,     0x00,       P_586,       0)
ins (XADD, xadd,                OpCls( R,        R,          NONE ), F_0F,   0,  0,      0xC0,     0x00,       P_486,       0)
insn(XADD, 1,                   OpCls( MS,       R,          NONE ), F_0F,   0,  0,      0xC0,     0x00,       P_486,       AP_LOCK)
ins (XCHG, xchg,                OpCls( A,        RGT8,       NONE ), 0,      0,  R_in_OP,0x90,     0x00,       P_86,        0)
insn(XCHG, 1,                   OpCls( RGT8,     A,          NONE ), 0,      0,  R_in_OP,0x90,     0x00,       P_86,        0)
insn(XCHG, 2,                   OpCls( R,        R,          NONE ), 0,      1,  0,      0x86,     0x00,       P_86,        0)
insn(XCHG, 3,                   OpCls( R,        MS,         NONE ), 0,      1,  0,      0x86,     0x00,       P_86,        AP_LOCK)
insn(XCHG, 4,                   OpCls( MS,       R,          NONE ), 0,      0,  0,      0x86,     0x00,       P_86,        AP_LOCK)
ins (XLAT, xlat,                OpCls( NONE,     NONE,       NONE ), 0,      0,  no_RM,  0xD7,     0x00,       P_86,        0)
insn(XLAT, 1,                   OpCls( M08,      NONE,       NONE ), 0,      0,  no_RM,  0xD7,     0x00,       P_86,        0)
ins (XLATB, xlatb,              OpCls( NONE,     NONE,       NONE ), 0,      0,  no_RM,  0xD7,     0x00,       P_86,        0)
insn(XLATB, 1,                  OpCls( M08,      NONE,       NONE ), 0,      0,  no_RM,  0xD7,     0x00,       P_86,        0)

ins (SETA,  seta,               OpCls( R8_M08,   NONE,       NONE ), F_0F,   0,  no_WDS, 0x97,     0x00,       P_386,       0)
ins (SETAE, setae,              OpCls( R8_M08,   NONE,       NONE ), F_0F,   0,  no_WDS, 0x93,     0x00,       P_386,       0)
ins (SETB,  setb,               OpCls( R8_M08,   NONE,       NONE ), F_0F,   0,  no_WDS, 0x92,     0x00,       P_386,       0)
ins (SETBE, setbe,              OpCls( R8_M08,   NONE,       NONE ), F_0F,   0,  no_WDS, 0x96,     0x00,       P_386,       0)
ins (SETC,  setc,               OpCls( R8_M08,   NONE,       NONE ), F_0F,   0,  no_WDS, 0x92,     0x00,       P_386,       0)
ins (SETE,  sete,               OpCls( R8_M08,   NONE,       NONE ), F_0F,   0,  no_WDS, 0x94,     0x00,       P_386,       0)
ins (SETG,  setg,               OpCls( R8_M08,   NONE,       NONE ), F_0F,   0,  no_WDS, 0x9F,     0x00,       P_386,       0)
ins (SETGE, setge,              OpCls( R8_M08,   NONE,       NONE ), F_0F,   0,  no_WDS, 0x9D,     0x00,       P_386,       0)
ins (SETL,  setl,               OpCls( R8_M08,   NONE,       NONE ), F_0F,   0,  no_WDS, 0x9C,     0x00,       P_386,       0)
ins (SETLE, setle,              OpCls( R8_M08,   NONE,       NONE ), F_0F,   0,  no_WDS, 0x9E,     0x00,       P_386,       0)
ins (SETNA, setna,              OpCls( R8_M08,   NONE,       NONE ), F_0F,   0,  no_WDS, 0x96,     0x00,       P_386,       0)
ins (SETNAE,setnae,             OpCls( R8_M08,   NONE,       NONE ), F_0F,   0,  no_WDS, 0x92,     0x00,       P_386,       0)
ins (SETNB, setnb,              OpCls( R8_M08,   NONE,       NONE ), F_0F,   0,  no_WDS, 0x93,     0x00,       P_386,       0)
ins (SETNBE,setnbe,             OpCls( R8_M08,   NONE,       NONE ), F_0F,   0,  no_WDS, 0x97,     0x00,       P_386,       0)
ins (SETNC, setnc,              OpCls( R8_M08,   NONE,       NONE ), F_0F,   0,  no_WDS, 0x93,     0x00,       P_386,       0)
ins (SETNE, setne,              OpCls( R8_M08,   NONE,       NONE ), F_0F,   0,  no_WDS, 0x95,     0x00,       P_386,       0)
ins (SETNG, setng,              OpCls( R8_M08,   NONE,       NONE ), F_0F,   0,  no_WDS, 0x9E,     0x00,       P_386,       0)
ins (SETNGE,setnge,             OpCls( R8_M08,   NONE,       NONE ), F_0F,   0,  no_WDS, 0x9C,     0x00,       P_386,       0)
ins (SETNL, setnl,              OpCls( R8_M08,   NONE,       NONE ), F_0F,   0,  no_WDS, 0x9D,     0x00,       P_386,       0)
ins (SETNLE,setnle,             OpCls( R8_M08,   NONE,       NONE ), F_0F,   0,  no_WDS, 0x9F,     0x00,       P_386,       0)
ins (SETNO, setno,              OpCls( R8_M08,   NONE,       NONE ), F_0F,   0,  no_WDS, 0x91,     0x00,       P_386,       0)
ins (SETNP, setnp,              OpCls( R8_M08,   NONE,       NONE ), F_0F,   0,  no_WDS, 0x9B,     0x00,       P_386,       0)
ins (SETNS, setns,              OpCls( R8_M08,   NONE,       NONE ), F_0F,   0,  no_WDS, 0x99,     0x00,       P_386,       0)
ins (SETNZ, setnz,              OpCls( R8_M08,   NONE,       NONE ), F_0F,   0,  no_WDS, 0x95,     0x00,       P_386,       0)
ins (SETO,  seto,               OpCls( R8_M08,   NONE,       NONE ), F_0F,   0,  no_WDS, 0x90,     0x00,       P_386,       0)
ins (SETP,  setp,               OpCls( R8_M08,   NONE,       NONE ), F_0F,   0,  no_WDS, 0x9A,     0x00,       P_386,       0)
ins (SETPE, setpe,              OpCls( R8_M08,   NONE,       NONE ), F_0F,   0,  no_WDS, 0x9A,     0x00,       P_386,       0)
ins (SETPO, setpo,              OpCls( R8_M08,   NONE,       NONE ), F_0F,   0,  no_WDS, 0x9B,     0x00,       P_386,       0)
ins (SETS,  sets,               OpCls( R8_M08,   NONE,       NONE ), F_0F,   0,  no_WDS, 0x98,     0x00,       P_386,       0)
ins (SETZ,  setz,               OpCls( R8_M08,   NONE,       NONE ), F_0F,   0,  no_WDS, 0x94,     0x00,       P_386,       0)

#define cmov( cond, code, condlc )      \
ins (CMOV##cond, cmov##condlc,           OpCls( RGT8,     R_MS,    NONE ), F_0F,   1,  no_WDS, 0x40+code,0x00,   P_686,   0)

cmov( A,   0x7,   a )
cmov( AE,  0x3,  ae )
cmov( B,   0x2,   b )
cmov( BE,  0x6,  be )
cmov( C,   0x2,   c )
cmov( E,   0x4,   e )
cmov( G,   0xf,   g )
cmov( GE,  0xd,  ge )
cmov( L,   0xc,   l )
cmov( LE,  0xe,  le )
cmov( NA,  0x6,  na )
cmov( NAE, 0x2, nae )
cmov( NB,  0x3,  nb )
cmov( NBE, 0x7, nbe )
cmov( NC,  0x3,  nc )
cmov( NE,  0x5,  ne )
cmov( NG,  0xe,  ng )
cmov( NGE, 0xc, nge )
cmov( NL,  0xd,  nl )
cmov( NLE, 0xf, nle )
cmov( NO,  0x1,  no )
cmov( NP,  0xb,  np )
cmov( NS,  0x9,  ns )
cmov( NZ,  0x5,  nz )
cmov( O,   0x0,   o )
cmov( P,   0xa,   p )
cmov( PE,  0xa,  pe )
cmov( PO,  0xb,  po )
cmov( S,   0x8,   s )
cmov( Z,   0x4,   z )

#undef cmov

/* FPU opcodes */

ins (FCMOVB, fcmovb,            OpCls( ST,       STI,        NONE ), 0,      0,  0,      0xDA,     0xC0,       P_686,       0)
ins (FCMOVBE, fcmovbe,          OpCls( ST,       STI,        NONE ), 0,      0,  0,      0xDA,     0xD0,       P_686,       0)
ins (FCMOVE, fcmove,            OpCls( ST,       STI,        NONE ), 0,      0,  0,      0xDA,     0xC8,       P_686,       0)
ins (FCMOVNB, fcmovnb,          OpCls( ST,       STI,        NONE ), 0,      0,  0,      0xDB,     0xC0,       P_686,       0)
ins (FCMOVNBE, fcmovnbe,        OpCls( ST,       STI,        NONE ), 0,      0,  0,      0xDB,     0xD0,       P_686,       0)
ins (FCMOVNE, fcmovne,          OpCls( ST,       STI,        NONE ), 0,      0,  0,      0xDB,     0xC8,       P_686,       0)
ins (FCMOVNU, fcmovnu,          OpCls( ST,       STI,        NONE ), 0,      0,  0,      0xDB,     0xD8,       P_686,       0)
ins (FCMOVU, fcmovu,            OpCls( ST,       STI,        NONE ), 0,      0,  0,      0xDA,     0xD8,       P_686,       0)

ins (FCOM, fcom,                OpCls( STI,      NONE,       NONE ), 0,      0,  0,      0xD8,     0xD0,       P_87,        0)
insn(FCOM, 1,                   OpCls( M32,      NONE,       NONE ), 0,      0,  0,      0xD8,     0x10,       P_87,        0)
insn(FCOM, 2,                   OpCls( M64,      NONE,       NONE ), 0,      0,  0,      0xDC,     0x10,       P_87,        0)
insn(FCOM, 3,                   OpCls( NONE,     NONE,       NONE ), 0,      0,  0,      0xD8,     0xD1,       P_87,        0)
ins (FCOMP, fcomp,              OpCls( STI,      NONE,       NONE ), 0,      0,  0,      0xD8,     0xD8,       P_87,        0)
insn(FCOMP, 1,                  OpCls( M32,      NONE,       NONE ), 0,      0,  0,      0xD8,     0x18,       P_87,        0)
insn(FCOMP, 2,                  OpCls( M64,      NONE,       NONE ), 0,      0,  0,      0xDC,     0x18,       P_87,        0)
insn(FCOMP, 3,                  OpCls( NONE,     NONE,       NONE ), 0,      0,  0,      0xD8,     0xD9,       P_87,        0)
ins (FCOMPP, fcompp,            OpCls( NONE,     NONE,       NONE ), 0,      0,  0,      0xDE,     0xD9,       P_87,        0)

ins (FUCOM, fucom,              OpCls( STI,      NONE,       NONE ), 0,      0,  0,      0xDD,     0xE0,       P_387,       0)
insn(FUCOM, 1,                  OpCls( NONE,     NONE,       NONE ), 0,      0,  0,      0xDD,     0xE1,       P_387,       0)
ins (FUCOMP, fucomp,            OpCls( STI,      NONE,       NONE ), 0,      0,  0,      0xDD,     0xE8,       P_387,       0)
insn(FUCOMP, 1,                 OpCls( NONE,     NONE,       NONE ), 0,      0,  0,      0xDD,     0xE9,       P_387,       0)
ins (FUCOMPP, fucompp,          OpCls( NONE,     NONE,       NONE ), 0,      0,  0,      0xDA,     0xE9,       P_387,       0)
ins (FCOMI, fcomi,              OpCls( ST,       STI,        NONE ), 0,      0,  0,      0xDB,     0xF0,       P_686,       0)
ins (FCOMIP, fcomip,            OpCls( ST,       STI,        NONE ), 0,      0,  0,      0xDF,     0xF0,       P_686,       0)
ins (FUCOMI, fucomi,            OpCls( ST,       STI,        NONE ), 0,      0,  0,      0xDB,     0xE8,       P_686,       0)
ins (FUCOMIP, fucomip,          OpCls( ST,       STI,        NONE ), 0,      0,  0,      0xDF,     0xE8,       P_686,       0)

/* v2.11: first 2 variants of FADD, FMUL, FDIV, FDIVP, FSUP and FSUBR exchanged */
ins (FADD, fadd,                OpCls( ST,       STI,        NONE ), 0,      0,  0,      0xD8,     0xC0,       P_87,        0)
insn(FADD, 1,                   OpCls( STI,      ST,         NONE ), 0,      0,  0,      0xDC,     0xC0,       P_87,        0)
insn(FADD, 2,                   OpCls( M32,      NONE,       NONE ), 0,      0,  0,      0xD8,     0x00,       P_87,        0)
insn(FADD, 3,                   OpCls( M64,      NONE,       NONE ), 0,      0,  0,      0xDC,     0x00,       P_87,        0)
insn(FADD, 4,                   OpCls( NONE,     NONE,       NONE ), 0,      0,  0,      0xDE,     0xC1,       P_87,        0)
ins (FADDP, faddp,              OpCls( STI,      ST,         NONE ), 0,      0,  0,      0xDE,     0xC0,       P_87,        0)
insn(FADDP, 1,                  OpCls( NONE,     NONE,       NONE ), 0,      0,  0,      0xDE,     0xC1,       P_87,        0)
ins (FMUL, fmul,                OpCls( ST,       STI,        NONE ), 0,      0,  0,      0xD8,     0xC8,       P_87,        0)
insn(FMUL, 1,                   OpCls( STI,      ST,         NONE ), 0,      0,  0,      0xDC,     0xC8,       P_87,        0)
insn(FMUL, 2,                   OpCls( M32,      NONE,       NONE ), 0,      0,  0,      0xD8,     0x08,       P_87,        0)
insn(FMUL, 3,                   OpCls( M64,      NONE,       NONE ), 0,      0,  0,      0xDC,     0x08,       P_87,        0)
insn(FMUL, 4,                   OpCls( NONE,     NONE,       NONE ), 0,      0,  0,      0xDE,     0xC9,       P_87,        0)
ins (FMULP, fmulp,              OpCls( STI,      ST,         NONE ), 0,      0,  0,      0xDE,     0xC8,       P_87,        0)
insn(FMULP, 1,                  OpCls( NONE,     NONE,       NONE ), 0,      0,  0,      0xDE,     0xC9,       P_87,        0)

ins (FDIV, fdiv,                OpCls( ST,       STI,        NONE ), 0,      0,  0,      0xD8,     0xF0,       P_87,        0)
insn(FDIV, 1,                   OpCls( STI,      ST,         NONE ), 0,      0,  0,      0xDC,     0xF8,       P_87,        0)
insn(FDIV, 2,                   OpCls( M32,      NONE,       NONE ), 0,      0,  0,      0xD8,     0x30,       P_87,        0)
insn(FDIV, 3,                   OpCls( M64,      NONE,       NONE ), 0,      0,  0,      0xDC,     0x30,       P_87,        0)
insn(FDIV, 4,                   OpCls( NONE,     NONE,       NONE ), 0,      0,  0,      0xDE,     0xF9,       P_87,        0)
ins (FDIVP, fdivp,              OpCls( STI,      ST,         NONE ), 0,      0,  0,      0xDE,     0xF8,       P_87,        0)
insn(FDIVP, 1,                  OpCls( NONE,     NONE,       NONE ), 0,      0,  0,      0xDE,     0xF9,       P_87,        0)
ins (FDIVR, fdivr,              OpCls( ST,       STI,        NONE ), 0,      0,  0,      0xD8,     0xF8,       P_87,        0)
insn(FDIVR, 1,                  OpCls( STI,      ST,         NONE ), 0,      0,  0,      0xDC,     0xF0,       P_87,        0)
insn(FDIVR, 2,                  OpCls( M32,      NONE,       NONE ), 0,      0,  0,      0xD8,     0x38,       P_87,        0)
insn(FDIVR, 3,                  OpCls( M64,      NONE,       NONE ), 0,      0,  0,      0xDC,     0x38,       P_87,        0)
insn(FDIVR, 4,                  OpCls( NONE,     NONE,       NONE ), 0,      0,  0,      0xDE,     0xF1,       P_87,        0)
ins (FDIVRP, fdivrp,            OpCls( STI,      ST,         NONE ), 0,      0,  0,      0xDE,     0xF0,       P_87,        0)
insn(FDIVRP, 1,                 OpCls( NONE,     NONE,       NONE ), 0,      0,  0,      0xDE,     0xF1,       P_87,        0)
ins (FSUB, fsub,                OpCls( ST,       STI,        NONE ), 0,      0,  0,      0xD8,     0xE0,       P_87,        0)
insn(FSUB, 1,                   OpCls( STI,      ST,         NONE ), 0,      0,  0,      0xDC,     0xE8,       P_87,        0)
insn(FSUB, 2,                   OpCls( M32,      NONE,       NONE ), 0,      0,  0,      0xD8,     0x20,       P_87,        0)
insn(FSUB, 3,                   OpCls( M64,      NONE,       NONE ), 0,      0,  0,      0xDC,     0x20,       P_87,        0)
insn(FSUB, 4,                   OpCls( NONE,     NONE,       NONE ), 0,      0,  0,      0xDE,     0xE9,       P_87,        0)
ins (FSUBP, fsubp,              OpCls( STI,      ST,         NONE ), 0,      0,  0,      0xDE,     0xE8,       P_87,        0)
insn(FSUBP, 1,                  OpCls( NONE,     NONE,       NONE ), 0,      0,  0,      0xDE,     0xE9,       P_87,        0)
ins (FSUBR, fsubr,              OpCls( ST,       STI,        NONE ), 0,      0,  0,      0xD8,     0xE8,       P_87,        0)
insn(FSUBR, 1,                  OpCls( STI,      ST,         NONE ), 0,      0,  0,      0xDC,     0xE0,       P_87,        0)
insn(FSUBR, 2,                  OpCls( M32,      NONE,       NONE ), 0,      0,  0,      0xD8,     0x28,       P_87,        0)
insn(FSUBR, 3,                  OpCls( M64,      NONE,       NONE ), 0,      0,  0,      0xDC,     0x28,       P_87,        0)
insn(FSUBR, 4,                  OpCls( NONE,     NONE,       NONE ), 0,      0,  0,      0xDE,     0xE1,       P_87,        0)
ins (FSUBRP, fsubrp,            OpCls( STI,      ST,         NONE ), 0,      0,  0,      0xDE,     0xE0,       P_87,        0)
insn(FSUBRP, 1,                 OpCls( NONE,     NONE,       NONE ), 0,      0,  0,      0xDE,     0xE1,       P_87,        0)

ins (FIADD, fiadd,              OpCls( M32,      NONE,       NONE ), 0,      0,  0,      0xDA,     0x00,       P_87,        0)
insn(FIADD, 1,                  OpCls( M16,      NONE,       NONE ), 0,      0,  0,      0xDE,     0x00,       P_87,        0)
ins (FICOM, ficom,              OpCls( M32,      NONE,       NONE ), 0,      0,  0,      0xDA,     0x10,       P_87,        0)
insn(FICOM, 1,                  OpCls( M16,      NONE,       NONE ), 0,      0,  0,      0xDE,     0x10,       P_87,        0)
ins (FICOMP, ficomp,            OpCls( M32,      NONE,       NONE ), 0,      0,  0,      0xDA,     0x18,       P_87,        0)
insn(FICOMP, 1,                 OpCls( M16,      NONE,       NONE ), 0,      0,  0,      0xDE,     0x18,       P_87,        0)
ins (FIDIV, fidiv,              OpCls( M32,      NONE,       NONE ), 0,      0,  0,      0xDA,     0x30,       P_87,        0)
insn(FIDIV, 1,                  OpCls( M16,      NONE,       NONE ), 0,      0,  0,      0xDE,     0x30,       P_87,        0)
ins (FIDIVR, fidivr,            OpCls( M32,      NONE,       NONE ), 0,      0,  0,      0xDA,     0x38,       P_87,        0)
insn(FIDIVR, 1,                 OpCls( M16,      NONE,       NONE ), 0,      0,  0,      0xDE,     0x38,       P_87,        0)
ins (FIMUL, fimul,              OpCls( M32,      NONE,       NONE ), 0,      0,  0,      0xDA,     0x08,       P_87,        0)
insn(FIMUL, 1,                  OpCls( M16,      NONE,       NONE ), 0,      0,  0,      0xDE,     0x08,       P_87,        0)
ins (FISUB, fisub,              OpCls( M32,      NONE,       NONE ), 0,      0,  0,      0xDA,     0x20,       P_87,        0)
insn(FISUB, 1,                  OpCls( M16,      NONE,       NONE ), 0,      0,  0,      0xDE,     0x20,       P_87,        0)
ins (FISUBR, fisubr,            OpCls( M32,      NONE,       NONE ), 0,      0,  0,      0xDA,     0x28,       P_87,        0)
insn(FISUBR, 1,                 OpCls( M16,      NONE,       NONE ), 0,      0,  0,      0xDE,     0x28,       P_87,        0)

ins (FILD, fild,                OpCls( M32,      NONE,       NONE ), 0,      0,  0,      0xDB,     0x00,       P_87,        0)
insn(FILD, 1,                   OpCls( M64,      NONE,       NONE ), 0,      0,  0,      0xDF,     0x28,       P_87,        0)
insn(FILD, 2,                   OpCls( M16,      NONE,       NONE ), 0,      0,  0,      0xDF,     0x00,       P_87,        0)
ins (FISTP, fistp,              OpCls( M32,      NONE,       NONE ), 0,      0,  0,      0xDB,     0x18,       P_87,        0)
insn(FISTP, 1,                  OpCls( M64,      NONE,       NONE ), 0,      0,  0,      0xDF,     0x38,       P_87,        0)
insn(FISTP, 2,                  OpCls( M16,      NONE,       NONE ), 0,      0,  0,      0xDF,     0x18,       P_87,        0)
ins (FIST, fist,                OpCls( M32,      NONE,       NONE ), 0,      0,  0,      0xDB,     0x10,       P_87,        0)
insn(FIST, 1,                   OpCls( M16,      NONE,       NONE ), 0,      0,  0,      0xDF,     0x10,       P_87,        0)

ins (FLD, fld,                  OpCls( STI,      NONE,       NONE ), 0,      0,  0,      0xD9,     0xC0,       P_87,        0)
insn(FLD, 1,                    OpCls( M32,      NONE,       NONE ), 0,      0,  0,      0xD9,     0x00,       P_87,        0)
insn(FLD, 2,                    OpCls( M64,      NONE,       NONE ), 0,      0,  0,      0xDD,     0x00,       P_87,        0)
insn(FLD, 3,                    OpCls( M80,      NONE,       NONE ), 0,      0,  0,      0xDB,     0x28,       P_87,        0)
ins (FSTP, fstp,                OpCls( STI,      NONE,       NONE ), 0,      0,  0,      0xDD,     0xD8,       P_87,        0)
insn(FSTP, 1,                   OpCls( M32,      NONE,       NONE ), 0,      0,  0,      0xD9,     0x18,       P_87,        0)
insn(FSTP, 2,                   OpCls( M64,      NONE,       NONE ), 0,      0,  0,      0xDD,     0x18,       P_87,        0)
insn(FSTP, 3,                   OpCls( M80,      NONE,       NONE ), 0,      0,  0,      0xDB,     0x38,       P_87,        0)
ins (FST, fst,                  OpCls( STI,      NONE,       NONE ), 0,      0,  0,      0xDD,     0xD0,       P_87,        0)
insn(FST, 1,                    OpCls( M32,      NONE,       NONE ), 0,      0,  0,      0xD9,     0x10,       P_87,        0)
insn(FST, 2,                    OpCls( M64,      NONE,       NONE ), 0,      0,  0,      0xDD,     0x10,       P_87,        0)

ins (FLDENV, fldenv,            OpCls( M_ANY,    NONE,       NONE ), 0,      0,  0,      0xD9,     0x20,       P_87,        0)
ins (FLDENVD, fldenvd,          OpCls( M_ANY,    NONE,       NONE ), F_32,   0,  0,      0xD9,     0x20,       P_387,       0)
ins (FLDENVW, fldenvw,          OpCls( M_ANY,    NONE,       NONE ), F_16,   0,  0,      0xD9,     0x20,       P_87,        0)
ins (FNSAVE, fnsave,            OpCls( M_ANY,    NONE,       NONE ), 0,      0,  0,      0xDD,     0x30,       P_87,        AP_NO_FWAIT)
ins (FNSAVED, fnsaved,          OpCls( M_ANY,    NONE,       NONE ), F_32,   0,  0,      0xDD,     0x30,       P_387,       AP_NO_FWAIT)
ins (FNSAVEW, fnsavew,          OpCls( M_ANY,    NONE,       NONE ), F_16,   0,  0,      0xDD,     0x30,       P_87,        AP_NO_FWAIT)
ins (FNSTENV, fnstenv,          OpCls( M_ANY,    NONE,       NONE ), 0,      0,  0,      0xD9,     0x30,       P_87,        AP_NO_FWAIT)
ins (FNSTENVD, fnstenvd,        OpCls( M_ANY,    NONE,       NONE ), F_32,   0,  0,      0xD9,     0x30,       P_387,       AP_NO_FWAIT)
ins (FNSTENVW, fnstenvw,        OpCls( M_ANY,    NONE,       NONE ), F_16,   0,  0,      0xD9,     0x30,       P_87,        AP_NO_FWAIT)
ins (FRSTOR, frstor,            OpCls( M_ANY,    NONE,       NONE ), 0,      0,  0,      0xDD,     0x20,       P_87,        0)
ins (FRSTORD, frstord,          OpCls( M_ANY,    NONE,       NONE ), F_32,   0,  0,      0xDD,     0x20,       P_387,       0)
ins (FRSTORW, frstorw,          OpCls( M_ANY,    NONE,       NONE ), F_16,   0,  0,      0xDD,     0x20,       P_87,        0)
ins (FSAVE, fsave,              OpCls( M_ANY,    NONE,       NONE ), 0,      0,  0,      0xDD,     0x30,       P_87,        AP_FWAIT)
ins (FSAVED, fsaved,            OpCls( M_ANY,    NONE,       NONE ), F_32,   0,  0,      0xDD,     0x30,       P_387,       AP_FWAIT)
ins (FSAVEW, fsavew,            OpCls( M_ANY,    NONE,       NONE ), F_16,   0,  0,      0xDD,     0x30,       P_87,        AP_FWAIT)
ins (FSTENV, fstenv,            OpCls( M_ANY,    NONE,       NONE ), 0,      0,  0,      0xD9,     0x30,       P_87,        AP_FWAIT)
ins (FSTENVD, fstenvd,          OpCls( M_ANY,    NONE,       NONE ), F_32,   0,  0,      0xD9,     0x30,       P_387,       AP_FWAIT)
ins (FSTENVW, fstenvw,          OpCls( M_ANY,    NONE,       NONE ), F_16,   0,  0,      0xD9,     0x30,       P_87,        AP_FWAIT)

ins (FLDCW, fldcw,              OpCls( M16,      NONE,       NONE ), 0,      0,  0,      0xD9,     0x28,       P_87,        0)
ins (FNSTCW, fnstcw,            OpCls( M16,      NONE,       NONE ), 0,      0,  0,      0xD9,     0x38,       P_87,        AP_NO_FWAIT)
ins (FNSTSW, fnstsw,            OpCls( AX,       NONE,       NONE ), 0,      0,  no_WDS, 0xDF,     0xE0,       P_287,       AP_NO_FWAIT)
insn(FNSTSW, 1,                 OpCls( M16,      NONE,       NONE ), 0,      0,  0,      0xDD,     0x38,       P_87,        AP_NO_FWAIT)
ins (FSTCW, fstcw,              OpCls( M16,      NONE,       NONE ), 0,      0,  0,      0xD9,     0x38,       P_87,        AP_FWAIT)
ins (FSTSW, fstsw,              OpCls( AX,       NONE,       NONE ), 0,      0,  no_WDS, 0xDF,     0xE0,       P_287,       AP_FWAIT)
insn(FSTSW, 1,                  OpCls( M16,      NONE,       NONE ), 0,      0,  0,      0xDD,     0x38,       P_87,        AP_FWAIT)

ins (FCOS, fcos,                OpCls( NONE,     NONE,       NONE ), 0,      0,  0,      0xD9,     0xFF,       P_387,       0)
ins (FPATAN, fpatan,            OpCls( NONE,     NONE,       NONE ), 0,      0,  0,      0xD9,     0xF3,       P_87,        0)
ins (FPTAN, fptan,              OpCls( NONE,     NONE,       NONE ), 0,      0,  0,      0xD9,     0xF2,       P_87,        0)
ins (FSIN, fsin,                OpCls( NONE,     NONE,       NONE ), 0,      0,  0,      0xD9,     0xFE,       P_387,       0)
ins (FSINCOS, fsincos,          OpCls( NONE,     NONE,       NONE ), 0,      0,  0,      0xD9,     0xFB,       P_387,       0)

ins (FINIT, finit,              OpCls( NONE,     NONE,       NONE ), 0,      0,  0,      0xDB,     0xE3,       P_87,        AP_FWAIT)
ins (FNINIT, fninit,            OpCls( NONE,     NONE,       NONE ), 0,      0,  0,      0xDB,     0xE3,       P_87,        AP_NO_FWAIT)
ins (FDISI, fdisi,              OpCls( NONE,     NONE,       NONE ), 0,      0,  0,      0xDB,     0xE1,       P_87,        AP_FWAIT)
ins (FNDISI, fndisi,            OpCls( NONE,     NONE,       NONE ), 0,      0,  0,      0xDB,     0xE1,       P_87,        AP_NO_FWAIT)
ins (FENI, feni,                OpCls( NONE,     NONE,       NONE ), 0,      0,  0,      0xDB,     0xE0,       P_87,        AP_FWAIT)
ins (FNENI, fneni,              OpCls( NONE,     NONE,       NONE ), 0,      0,  0,      0xDB,     0xE0,       P_87,        AP_NO_FWAIT)
ins (FCLEX, fclex,              OpCls( NONE,     NONE,       NONE ), 0,      0,  0,      0xDB,     0xE2,       P_87,        AP_FWAIT)
ins (FNCLEX, fnclex,            OpCls( NONE,     NONE,       NONE ), 0,      0,  0,      0xDB,     0xE2,       P_87,        AP_NO_FWAIT)

ins (F2XM1, f2xm1,              OpCls( NONE,     NONE,       NONE ), 0,      0,  0,      0xD9,     0xF0,       P_87,        0)
ins (FABS, fabs,                OpCls( NONE,     NONE,       NONE ), 0,      0,  0,      0xD9,     0xE1,       P_87,        0)
ins (FBLD, fbld,                OpCls( M80,      NONE,       NONE ), 0,      0,  0,      0xDF,     0x20,       P_87,        0)
ins (FBSTP, fbstp,              OpCls( M80,      NONE,       NONE ), 0,      0,  0,      0xDF,     0x30,       P_87,        0)
ins (FCHS, fchs,                OpCls( NONE,     NONE,       NONE ), 0,      0,  0,      0xD9,     0xE0,       P_87,        0)
ins (FLD1, fld1,                OpCls( NONE,     NONE,       NONE ), 0,      0,  0,      0xD9,     0xE8,       P_87,        0)
ins (FLDL2E, fldl2e,            OpCls( NONE,     NONE,       NONE ), 0,      0,  0,      0xD9,     0xEA,       P_87,        0)
ins (FLDL2T, fldl2t,            OpCls( NONE,     NONE,       NONE ), 0,      0,  0,      0xD9,     0xE9,       P_87,        0)
ins (FLDLG2, fldlg2,            OpCls( NONE,     NONE,       NONE ), 0,      0,  0,      0xD9,     0xEC,       P_87,        0)
ins (FLDLN2, fldln2,            OpCls( NONE,     NONE,       NONE ), 0,      0,  0,      0xD9,     0xED,       P_87,        0)
ins (FLDPI, fldpi,              OpCls( NONE,     NONE,       NONE ), 0,      0,  0,      0xD9,     0xEB,       P_87,        0)
ins (FLDZ, fldz,                OpCls( NONE,     NONE,       NONE ), 0,      0,  0,      0xD9,     0xEE,       P_87,        0)
ins (FDECSTP, fdecstp,          OpCls( NONE,     NONE,       NONE ), 0,      0,  0,      0xD9,     0xF6,       P_87,        0)
ins (FINCSTP, fincstp,          OpCls( NONE,     NONE,       NONE ), 0,      0,  0,      0xD9,     0xF7,       P_87,        0)
ins (FFREE, ffree,              OpCls( STI,      NONE,       NONE ), 0,      0,  0,      0xDD,     0xC0,       P_87,        0)
/* FFREEP is undocumented (same as FFREE + POP) */
ins (FFREEP, ffreep,            OpCls( STI,      NONE,       NONE ), 0,      0,  0,      0xDF,     0xC0,       P_87,        0)
ins (FNOP, fnop,                OpCls( NONE,     NONE,       NONE ), 0,      0,  0,      0xD9,     0xD0,       P_87,        0)
ins (FPREM, fprem,              OpCls( NONE,     NONE,       NONE ), 0,      0,  0,      0xD9,     0xF8,       P_87,        0)
ins (FPREM1, fprem1,            OpCls( NONE,     NONE,       NONE ), 0,      0,  0,      0xD9,     0xF5,       P_387,       0)
ins (FRNDINT, frndint,          OpCls( NONE,     NONE,       NONE ), 0,      0,  0,      0xD9,     0xFC,       P_87,        0)
ins (FSCALE, fscale,            OpCls( NONE,     NONE,       NONE ), 0,      0,  0,      0xD9,     0xFD,       P_87,        0)
ins (FSETPM, fsetpm,            OpCls( NONE,     NONE,       NONE ), 0,      0,  0,      0xDB,     0xE4,       P_287,       0)
ins (FSQRT, fsqrt,              OpCls( NONE,     NONE,       NONE ), 0,      0,  0,      0xD9,     0xFA,       P_87,        0)
ins (FTST, ftst,                OpCls( NONE,     NONE,       NONE ), 0,      0,  0,      0xD9,     0xE4,       P_87,        0)
ins (FWAIT, fwait,              OpCls( NONE,     NONE,       NONE ), 0,      0,  no_RM,  0x9B,     0x00,       P_87,        0)
ins (FXAM, fxam,                OpCls( NONE,     NONE,       NONE ), 0,      0,  0,      0xD9,     0xE5,       P_87,        0)
ins (FXCH, fxch,                OpCls( STI,      NONE,       NONE ), 0,      0,  0,      0xD9,     0xC8,       P_87,        0)
insn(FXCH, 1,                   OpCls( NONE,     NONE,       NONE ), 0,      0,  0,      0xD9,     0xC9,       P_87,        0)
ins (FXRSTOR, fxrstor,          OpCls( M_ANY,    NONE,       NONE ), F_0F,   0,  no_WDS, 0xAE,     0x08,       P_686|P_SSE1,0)
ins (FXSAVE, fxsave,            OpCls( M_ANY,    NONE,       NONE ), F_0F,   0,  no_WDS, 0xAE,     0x00,       P_686|P_SSE1,0)
ins (FXTRACT, fxtract,          OpCls( NONE,     NONE,       NONE ), 0,      0,  0,      0xD9,     0xF4,       P_87,        0)
ins (FYL2X, fyl2x,              OpCls( NONE,     NONE,       NONE ), 0,      0,  0,      0xD9,     0xF1,       P_87,        0)
ins (FYL2XP1, fyl2xp1,          OpCls( NONE,     NONE,       NONE ), 0,      0,  0,      0xD9,     0xF9,       P_87,        0)

/* MMX/SSE related opcodes (except SSE instructions CMPSD and MOVSD) */

ins (EMMS, emms,                OpCls( NONE,     NONE,       NONE ), F_0F,   0,  no_RM,  0x77,     0x00,       P_586|P_MMX, 0)
ins (CLFLUSH, clflush,          OpCls( M_ANY,    NONE,       NONE ), F_0F,   0,  no_WDS, 0xAE,     0x38,       P_686|P_SSE2,0)
ins (CLFLUSHOPT, clflushopt,    OpCls( M_ANY,    NONE,       NONE ), F_660F, 0,  no_WDS, 0xAE,     0x38,       P_686|P_SSE2,0)
ins (LDMXCSR, ldmxcsr,          OpCls( M32,      NONE,       NONE ), F_0F,   0,  no_WDS, 0xAE,     0x10,       P_686|P_SSE1,0)
ins (STMXCSR, stmxcsr,          OpCls( M32,      NONE,       NONE ), F_0F,   0,  no_WDS, 0xAE,     0x18,       P_686|P_SSE1,0)
ins (LFENCE, lfence,            OpCls( NONE,     NONE,       NONE ), F_0F,   0,  no_WDS, 0xAE,     0xE8,       P_686|P_SSE2,0)
ins (MFENCE, mfence,            OpCls( NONE,     NONE,       NONE ), F_0F,   0,  no_WDS, 0xAE,     0xF0,       P_686|P_SSE2,0)
ins (SFENCE, sfence,            OpCls( NONE,     NONE,       NONE ), F_0F,   0,  no_WDS, 0xAE,     0xF8,       P_686|P_SSE1,0)
ins (PREFETCHNTA,prefetchnta,   OpCls( M_ANY,    NONE,       NONE ), F_0F,   0,  no_WDS, 0x18,     0x00,       P_686|P_SSE1,0)
ins (PREFETCHT0, prefetcht0,    OpCls( M_ANY,    NONE,       NONE ), F_0F,   0,  no_WDS, 0x18,     0x08,       P_686|P_SSE1,0)
ins (PREFETCHT1, prefetcht1,    OpCls( M_ANY,    NONE,       NONE ), F_0F,   0,  no_WDS, 0x18,     0x10,       P_686|P_SSE1,0)
ins (PREFETCHT2, prefetcht2,    OpCls( M_ANY,    NONE,       NONE ), F_0F,   0,  no_WDS, 0x18,     0x18,       P_686|P_SSE1,0)
ins (PAUSE, pause,              OpCls( NONE,     NONE,       NONE ), F_F3,   0,  no_RM,  0x90,     0x00,       P_686|P_SSE2,0)
/* define ADDPD, ADDPS, ADDSD, ADDSS, DIVPD, DIVPS, DIVSD, DIVSS, ... */
#define arfl( prefix, prefixlc, opc )      \
ins (prefix ## PD, prefixlc ## pd,       OpCls( XMM,  XMM_M128,NONE ), F_660F, 1,  no_WDS, opc,   0x00,   P_686|P_SSE2,W1|QSIZE|FV) \
ins (prefix ## PS, prefixlc ## ps,       OpCls( XMM,  XMM_M128,NONE ), F_0F,   1,  0, opc,   0x00,   P_686|P_SSE1,DSIZE|FV) \
ins (prefix ## SD, prefixlc ## sd,       OpCls( XMM,  XMM_M64, NONE ), F_F20F, 1,  no_WDS, opc,   0x00,   P_686|P_SSE2,W1|QSIZE|T1S) \
ins (prefix ## SS, prefixlc ## ss,       OpCls( XMM,  XMM_M32, NONE ), F_F30F, 1,  0, opc,   0x00,   P_686|P_SSE1,DSIZE|T1S)

arfl( ADD,  add,  0x58 )
arfl( DIV,  div,  0x5E )
arfl( MAX,  max,  0x5F )
arfl( MIN,  min,  0x5D )
arfl( MUL,  mul,  0x59 )
arfl( SQRT, sqrt, 0x51 )
arfl( SUB,  sub,  0x5C )

/* CMP can't be added because CMPSD is special */
ins (CMPPD, cmppd,              OpCls( XMM,      XMM_M128, I8_U ), F_660F, 1,  no_WDS, 0xC2,     0x00,       P_686|P_SSE2,W1|QSIZE|FV)
ins (CMPPS, cmpps,              OpCls( XMM,      XMM_M128, I8_U ), F_0F,   1,       0, 0xC2,     0x00,       P_686|P_SSE1,DSIZE|FV)
//ins (CMPSD, cmpsd,              OpCls( XMM,      XMM_M64, I8_U ), F_F20F, 1,  no_WDS, 0xC2,     0x00,       P_686|P_SSE2,MT_QWORD)
ins (CMPSS, cmpss,              OpCls( XMM,      XMM_M32,  I8_U ), F_F30F, 1,       0, 0xC2,     0x00,       P_686|P_SSE1,DSIZE|T1S)

#undef arfl

#define cmpxx( suffix, suffixlc, byte1, memop, ssever, sprefix )      \
ins (CMP ## EQ       ## suffix, cmp ##  eq       ## suffixlc,    OpCls( XMM, XMM_ ## memop, HID ),byte1, 1, no_WDS, 0xC2, 0x00, P_686|ssever, sprefix)\
ins (CMP ## LT       ## suffix, cmp ##  lt       ## suffixlc,    OpCls( XMM, XMM_ ## memop, HID ),byte1, 1, no_WDS, 0xC2, 0x00, P_686|ssever, sprefix)\
ins (CMP ## LE       ## suffix, cmp ##  le       ## suffixlc,    OpCls( XMM, XMM_ ## memop, HID ),byte1, 1, no_WDS, 0xC2, 0x00, P_686|ssever, sprefix)\
ins (CMP ## UNORD    ## suffix, cmp ##  unord    ## suffixlc,    OpCls( XMM, XMM_ ## memop, HID ),byte1, 1, no_WDS, 0xC2, 0x00, P_686|ssever, sprefix)\
ins (CMP ## NEQ      ## suffix, cmp ##  neq      ## suffixlc,    OpCls( XMM, XMM_ ## memop, HID ),byte1, 1, no_WDS, 0xC2, 0x00, P_686|ssever, sprefix)\
ins (CMP ## NLT      ## suffix, cmp ##  nlt      ## suffixlc,    OpCls( XMM, XMM_ ## memop, HID ),byte1, 1, no_WDS, 0xC2, 0x00, P_686|ssever, sprefix)\
ins (CMP ## NLE      ## suffix, cmp ##  nle      ## suffixlc,    OpCls( XMM, XMM_ ## memop, HID ),byte1, 1, no_WDS, 0xC2, 0x00, P_686|ssever, sprefix)\
ins (CMP ## ORD      ## suffix, cmp ##  ord      ## suffixlc,    OpCls( XMM, XMM_ ## memop, HID ),byte1, 1, no_WDS, 0xC2, 0x00, P_686|ssever, sprefix)\
ins (CMP ## EQ_UQ    ## suffix, cmp ##  eq_uq    ## suffixlc,    OpCls( XMM, XMM_ ## memop, HID ),byte1, 1, no_WDS, 0xC2, 0x00, P_686|ssever, sprefix)\
ins (CMP ## NGE      ## suffix, cmp ##  nge      ## suffixlc,    OpCls( XMM, XMM_ ## memop, HID ),byte1, 1, no_WDS, 0xC2, 0x00, P_686|ssever, sprefix)\
ins (CMP ## NGT      ## suffix, cmp ##  ngt      ## suffixlc,    OpCls( XMM, XMM_ ## memop, HID ),byte1, 1, no_WDS, 0xC2, 0x00, P_686|ssever, sprefix)\
ins (CMP ## FALSE    ## suffix, cmp ##  false    ## suffixlc,    OpCls( XMM, XMM_ ## memop, HID ),byte1, 1, no_WDS, 0xC2, 0x00, P_686|ssever, sprefix)\
ins (CMP ## NEQ_OQ   ## suffix, cmp ##  neq_oq   ## suffixlc,    OpCls( XMM, XMM_ ## memop, HID ),byte1, 1, no_WDS, 0xC2, 0x00, P_686|ssever, sprefix)\
ins (CMP ## GE       ## suffix, cmp ##  ge       ## suffixlc,    OpCls( XMM, XMM_ ## memop, HID ),byte1, 1, no_WDS, 0xC2, 0x00, P_686|ssever, sprefix)\
ins (CMP ## GT       ## suffix, cmp ##  gt       ## suffixlc,    OpCls( XMM, XMM_ ## memop, HID ),byte1, 1, no_WDS, 0xC2, 0x00, P_686|ssever, sprefix)\
ins (CMP ## TRUE     ## suffix, cmp ##  true     ## suffixlc,    OpCls( XMM, XMM_ ## memop, HID ),byte1, 1, no_WDS, 0xC2, 0x00, P_686|ssever, sprefix)\
ins (CMP ## EQ_OS    ## suffix, cmp ##  eq_os    ## suffixlc,    OpCls( XMM, XMM_ ## memop, HID ),byte1, 1, no_WDS, 0xC2, 0x00, P_686|ssever, sprefix)\
ins (CMP ## LT_OQ    ## suffix, cmp ##  lt_oq    ## suffixlc,    OpCls( XMM, XMM_ ## memop, HID ),byte1, 1, no_WDS, 0xC2, 0x00, P_686|ssever, sprefix)\
ins (CMP ## LE_OQ    ## suffix, cmp ##  le_oq    ## suffixlc,    OpCls( XMM, XMM_ ## memop, HID ),byte1, 1, no_WDS, 0xC2, 0x00, P_686|ssever, sprefix)\
ins (CMP ## UNORD_S  ## suffix, cmp ##  unord_s  ## suffixlc,    OpCls( XMM, XMM_ ## memop, HID ),byte1, 1, no_WDS, 0xC2, 0x00, P_686|ssever, sprefix)\
ins (CMP ## NEQ_US   ## suffix, cmp ##  neq_us   ## suffixlc,    OpCls( XMM, XMM_ ## memop, HID ),byte1, 1, no_WDS, 0xC2, 0x00, P_686|ssever, sprefix)\
ins (CMP ## NLT_UQ   ## suffix, cmp ##  nlt_uq   ## suffixlc,    OpCls( XMM, XMM_ ## memop, HID ),byte1, 1, no_WDS, 0xC2, 0x00, P_686|ssever, sprefix)\
ins (CMP ## NLE_UQ   ## suffix, cmp ##  nle_uq   ## suffixlc,    OpCls( XMM, XMM_ ## memop, HID ),byte1, 1, no_WDS, 0xC2, 0x00, P_686|ssever, sprefix)\
ins (CMP ## ORD_S    ## suffix, cmp ##  ord_s    ## suffixlc,    OpCls( XMM, XMM_ ## memop, HID ),byte1, 1, no_WDS, 0xC2, 0x00, P_686|ssever, sprefix)\
ins (CMP ## EQ_US    ## suffix, cmp ##  eq_us    ## suffixlc,    OpCls( XMM, XMM_ ## memop, HID ),byte1, 1, no_WDS, 0xC2, 0x00, P_686|ssever, sprefix)\
ins (CMP ## NGE_UQ   ## suffix, cmp ##  nge_uq   ## suffixlc,    OpCls( XMM, XMM_ ## memop, HID ),byte1, 1, no_WDS, 0xC2, 0x00, P_686|ssever, sprefix)\
ins (CMP ## NGT_UQ   ## suffix, cmp ##  ngt_uq   ## suffixlc,    OpCls( XMM, XMM_ ## memop, HID ),byte1, 1, no_WDS, 0xC2, 0x00, P_686|ssever, sprefix)\
ins (CMP ## FALSE_OS ## suffix, cmp ##  false_os ## suffixlc,    OpCls( XMM, XMM_ ## memop, HID ),byte1, 1, no_WDS, 0xC2, 0x00, P_686|ssever, sprefix)\
ins (CMP ## NEQ_OS   ## suffix, cmp ##  neq_os   ## suffixlc,    OpCls( XMM, XMM_ ## memop, HID ),byte1, 1, no_WDS, 0xC2, 0x00, P_686|ssever, sprefix)\
ins (CMP ## GE_OQ    ## suffix, cmp ##  ge_oq    ## suffixlc,    OpCls( XMM, XMM_ ## memop, HID ),byte1, 1, no_WDS, 0xC2, 0x00, P_686|ssever, sprefix)\
ins (CMP ## GT_OQ    ## suffix, cmp ##  gt_oq    ## suffixlc,    OpCls( XMM, XMM_ ## memop, HID ),byte1, 1, no_WDS, 0xC2, 0x00, P_686|ssever, sprefix)\
ins (CMP ## TRUE_US  ## suffix, cmp ##  true_us  ## suffixlc,    OpCls( XMM, XMM_ ## memop, HID ),byte1, 1, no_WDS, 0xC2, 0x00, P_686|ssever, sprefix)

cmpxx( PD, pd, F_660F, M128, P_SSE2, W1|QSIZE| FV )
cmpxx( PS, ps, F_0F,   M128, P_SSE1, DSIZE| FV )
cmpxx( SD, sd, F_F20F, M64,  P_SSE2, W1|QSIZE|T1S )
cmpxx( SS, ss, F_F30F, M32,  P_SSE1, DSIZE|T1S )

#undef cmpxx

ins (ANDNPD, andnpd,            OpCls( XMM,      XMM_M128, NONE ), F_660F, 1,  no_WDS, 0x55,     0x00,       P_686|P_SSE2,W1|QSIZE|FV)
ins (ANDNPS, andnps,            OpCls( XMM,      XMM_M128, NONE ), F_0F,   1,  no_WDS, 0x55,     0x00,       P_686|P_SSE1,DSIZE|FV)
ins (ANDPD, andpd,              OpCls( XMM,      XMM_M128, NONE ), F_660F, 1,  no_WDS, 0x54,     0x00,       P_686|P_SSE2,W1|QSIZE|FV)
ins (ANDPS, andps,              OpCls( XMM,      XMM_M128, NONE ), F_0F,   1,  no_WDS, 0x54,     0x00,       P_686|P_SSE1,DSIZE|FV)
ins (ORPD, orpd,                OpCls( XMM,      XMM_M128, NONE ), F_660F, 1,  no_WDS, 0x56,     0x00,       P_686|P_SSE2,W1|QSIZE|FV)
ins (ORPS, orps,                OpCls( XMM,      XMM_M128, NONE ), F_0F,   1,  no_WDS, 0x56,     0x00,       P_686|P_SSE1,DSIZE|FV)
ins (COMISD, comisd,            OpCls( XMM,      XMM_M64,  NONE ), F_660F, 1,  no_WDS, 0x2F,     0x00,       P_686|P_SSE2,W1|QSIZE|T1S)
ins (COMISS, comiss,            OpCls( XMM,      XMM_M32,  NONE ), F_0F,   1,  no_WDS, 0x2F,     0x00,       P_686|P_SSE1,DSIZE|T1S)
ins (XORPD, xorpd,              OpCls( XMM,      XMM_M128, NONE ), F_660F, 1,  no_WDS, 0x57,     0x00,       P_686|P_SSE2,W1|QSIZE|FV)
ins (XORPS, xorps,              OpCls( XMM,      XMM_M128, NONE ), F_0F,   1,  no_WDS, 0x57,     0x00,       P_686|P_SSE1,DSIZE|FV)

ins (CVTPD2PI, cvtpd2pi,        OpCls( MMX,      XMM_M128, NONE ), F_660F, 1,  no_WDS, 0x2D,     0x00,       P_686|P_SSE2,QSIZE)
ins (CVTPS2PI, cvtps2pi,        OpCls( MMX,      XMM_M64,  NONE ), F_0F,   1,  no_WDS, 0x2D,     0x00,       P_686|P_SSE1,DSIZE)
ins (CVTSD2SI, cvtsd2si,        OpCls( RGT16,    XMM_M64,  NONE ), F_F20F, 1,  no_WDS, 0x2D,     0x00,       P_686|P_SSE2,QSIZE|T1S)
ins (CVTSS2SI, cvtss2si,        OpCls( RGT16,    XMM_M32,  NONE ), F_F30F, 1,  no_WDS, 0x2D,     0x00,       P_686|P_SSE1,DSIZE|T1S)
ins (CVTPI2PD, cvtpi2pd,        OpCls( XMM,      MMX_M64,  NONE ), F_660F, 1,  no_WDS, 0x2A,     0x00,       P_686|P_SSE2,QSIZE)
ins (CVTPI2PS, cvtpi2ps,        OpCls( XMM,      MMX_M64,  NONE ), F_0F,   1,  no_WDS, 0x2A,     0x00,       P_686|P_SSE1,DSIZE)
ins (CVTSI2SD, cvtsi2sd,        OpCls( XMM,      RMGT16,   NONE ), F_F20F, 1,  no_WDS, 0x2A,     0x00,       P_686|P_SSE2,W1|QSIZE|T1S)
ins(CVTSI2SS, cvtsi2ss, OpCls(NONE, NONE, NONE), 0, 0, 0, 0, 0, 0, 0)
//ins (CVTSI2SS, cvtsi2ss,        OpCls( XMM,      RMGT16,   NONE ), F_F30F, 1,  no_WDS, 0x2A,     0x00,       P_686|P_SSE1,DSIZE|T1S)
ins (CVTTPD2PI, cvttpd2pi,      OpCls( MMX,      XMM_M128, NONE ), F_660F, 1,  no_WDS, 0x2C,     0x00,       P_686|P_SSE2,QSIZE)
ins (CVTTPS2PI, cvttps2pi,      OpCls( MMX,      XMM_M64,  NONE ), F_0F,   1,  no_WDS, 0x2C,     0x00,       P_686|P_SSE1,DSIZE)
ins (CVTTSD2SI, cvttsd2si,      OpCls( RGT16,    XMM_M64,  NONE ), F_F20F, 1,  no_WDS, 0x2C,     0x00,       P_686|P_SSE2,W1|QSIZE|T1S)
ins (CVTTSS2SI, cvttss2si,      OpCls( RGT16,    XMM_M32,  NONE ), F_F30F, 1,  no_WDS, 0x2C,     0x00,       P_686|P_SSE1,DSIZE|T1S)

ins (CVTDQ2PS, cvtdq2ps,        OpCls( XMM,      XMM_M128, NONE ), F_0F,   1,  no_WDS, 0x5B,     0x00,       P_686|P_SSE2,DSIZE|FV)
ins (CVTPS2DQ, cvtps2dq,        OpCls( XMM,      XMM_M128, NONE ), F_660F, 1,  no_WDS, 0x5B,     0x00,       P_686|P_SSE2, DSIZE|FV)
ins (CVTTPS2DQ, cvttps2dq,      OpCls( XMM,      XMM_M128, NONE ), F_F30F, 1,  no_WDS, 0x5B,     0x00,       P_686|P_SSE2, DSIZE|FV)

ins (CVTPD2DQ, cvtpd2dq,        OpCls( XMM,      XMM_M128, NONE ), F_F20F, 1,  no_WDS, 0xE6,     0x00,       P_686|P_SSE2,W1|QSIZE|FV)
ins (CVTDQ2PD, cvtdq2pd,        OpCls( XMM,      XMM_M64,  NONE ), F_F30F, 1,  no_WDS, 0xE6,     0x00,       P_686|P_SSE2, QSIZE|HV)
ins (CVTTPD2DQ, cvttpd2dq,      OpCls( XMM,      XMM_M128, NONE ), F_660F, 1,  no_WDS, 0xE6,     0x00,       P_686|P_SSE2,W1|QSIZE|FV)

ins (CVTPD2PS, cvtpd2ps,        OpCls( XMM,      XMM_M128, NONE ), F_660F, 1,  no_WDS, 0x5A,     0x00,       P_686|P_SSE2,W1|QSIZE|FV)
ins (CVTPS2PD, cvtps2pd,        OpCls( XMM,      XMM_M64,  NONE ), F_0F,   1,  no_WDS, 0x5A,     0x00,       P_686|P_SSE2,DSIZE|HV)
ins (CVTSD2SS, cvtsd2ss,        OpCls( XMM,      XMM_M64,  NONE ), F_F20F, 1,  no_WDS, 0x5A,     0x00,       P_686|P_SSE2,W1|QSIZE|T1S)
ins (CVTSS2SD, cvtss2sd,        OpCls( XMM,      XMM_M32,  NONE ), F_F30F, 1,  no_WDS, 0x5A,     0x00,       P_686|P_SSE2,DSIZE|T1S)

ins (MASKMOVDQU, maskmovdqu,    OpCls( XMM,      XMM,      NONE ), F_660F, 1,  no_WDS, 0xF7,     0x00,       P_686|P_SSE2,QSIZE)
ins (MASKMOVQ, maskmovq,        OpCls( MMX,      MMX,      NONE ), F_0F,   1,  no_WDS, 0xF7,     0x00,       P_686|P_SSE1,DSIZE)

/* Masm (ML64) uses MOVD if a 64-bit register is src/dst. Intel docs prefer MOVQ */
ins (MOVD, movd,                OpCls( MMX,      RMGT16,   NONE ), F_0F,   1,  no_WDS, 0x6E,     0x00,       P_586|P_MMX, DSIZE)
insn(MOVD, 1,                   OpCls( XMM,      RMGT16,   NONE ), F_660F, 1,  no_WDS, 0x6E,     0x00,       P_686|P_SSE2,DSIZE|T1S)
#if INTELMOVQ
insn(MOVD, 2,                   OpCls( R32_M32,  MMX,      NONE ), F_0F,   0,  no_WDS, 0x7E,     0x00,       P_586|P_MMX, DSIZE)
insn(MOVD, 3,                   OpCls( R32_M32,  XMM,      NONE ), F_660F, 0,  no_WDS, 0x7E,     0x00,       P_686|P_SSE2,DSIZE|T1S)
#else
insn(MOVD, 2,                   OpCls( RMGT16,   XMM,      NONE ), F_660F, 0,  no_WDS, 0x7E,     0x00,       P_686|P_SSE2,DSIZE|T1S)
insn(MOVD, 3,                   OpCls( RMGT16,   MMX,      NONE ), F_0F,   0,  no_WDS, 0x7E,     0x00,       P_586|P_MMX, DSIZE)
#endif 
ins(MOVQ, movq,                 OpCls( MMX,      MMX_M64,  NONE ), F_0F,   1,  no_WDS, 0x6F,     0x00,       P_586|P_MMX, QSIZE)
insn(MOVQ, 1,                   OpCls( XMM,      RMGT16,   NONE ), F_660F, 1,  no_WDS, 0x6E,     0x00,       P_686|P_SSE2,W1|QSIZE|T1S)
#if INTELMOVQ
insn(MOVQ, 2,                   OpCls( R64_M64,  MMX,      NONE ), F_0F,   0,  no_WDS, 0x7F,     0x00,       P_586|P_MMX, QSIZE)
insn(MOVQ, 3,                   OpCls( R64_M64,  XMM,      NONE ), F_660F, 0,  no_WDS, 0xD6,     0x00,       P_686|P_SSE2,W1|QSIZE|T1S)
#else   
insn(MOVQ, 2,                   OpCls( RMGT16,   XMM,      NONE ), F_660F, 0,  no_WDS, 0x7E,     0x00,       P_686|P_SSE2,W1|QSIZE|T1S)
insn(MOVQ, 3,                   OpCls( M64,      XMM,      NONE ), F_660F, 0,  no_WDS, 0xD6,     0x00,       P_686|P_SSE2,W1|QSIZE|T1S)
insn(MOVQ, 4,                   OpCls( MMX,      MMX_M64,  NONE ), F_0F,   1,  no_WDS, 0x6F,     0x00,       P_586|P_MMX, QSIZE)
insn(MOVQ, 5,                   OpCls( XMM,      XMM_M64,  NONE ), F_F30F, 1,  no_WDS, 0x7E,     0x00,       P_686|P_SSE2,W1|QSIZE|T1S)
insn(MOVQ, 6,                   OpCls( M64,      MMX,      NONE ), F_0F,   0,  no_WDS, 0x7F,     0x00,       P_586|P_MMX, QSIZE)
insn(MOVQ, 7,                   OpCls( M64,      MMX,      NONE ), F_0F,   1,  no_WDS, 0x7F,     0x00,       P_686|P_MMX, W1|QSIZE|T1S)
insn(MOVQ, 8,                   OpCls( MMX,      R64_M64,  NONE ), F_0F,   1,  no_WDS, 0x6E,     0x00,       P_686|P_MMX, W1|QSIZE|T1S)
insn(MOVQ, 9,                   OpCls( R64,      MMX,      NONE ), F_0F,   1,  no_WDS, 0x7E,     0x00,       P_686|P_MMX, W1|QSIZE|T1S)
#endif

ins (MOVAPD, movapd,            OpCls( XMM,      XMM_M128, NONE ), F_660F, 1,  no_WDS, 0x28,     0x00,       P_686|P_SSE2,W1|QSIZE|FVM)
insn(MOVAPD, 1,                 OpCls( M128,     XMM,      NONE ), F_660F, 0,  no_WDS, 0x29,     0x00,       P_686|P_SSE2,W1|QSIZE|FVM)
ins (MOVAPS, movaps,            OpCls( XMM,      XMM_M128, NONE ), F_0F,   1,  no_WDS, 0x28,     0x00,       P_686|P_SSE1,DSIZE|FVM)
insn(MOVAPS, 1,                 OpCls( M128,     XMM,      NONE ), F_0F,   0,  no_WDS, 0x29,     0x00,       P_686|P_SSE1,DSIZE|FVM)
ins (MOVDQA, movdqa,            OpCls( XMM,      XMM_M128, NONE ), F_660F, 1,  no_WDS, 0x6F,     0x00,       P_686|P_SSE2,QSIZE)
insn(MOVDQA, 1,                 OpCls( M128,     XMM,      NONE ), F_660F, 0,  no_WDS, 0x7F,     0x00,       P_686|P_SSE2,QSIZE)
ins (MOVDQU, movdqu,            OpCls( XMM,      XMM_M128, NONE ), F_F30F, 1,  no_WDS, 0x6F,     0x00,       P_686|P_SSE2,QSIZE)
insn(MOVDQU, 1,                 OpCls( M128,     XMM,      NONE ), F_F30F, 0,  no_WDS, 0x7F,     0x00,       P_686|P_SSE2,QSIZE)
ins (MOVUPD, movupd,            OpCls( XMM,      XMM_M128, NONE ), F_660F, 1,  no_WDS, 0x10,     0x00,       P_686|P_SSE2,W1|QSIZE|FVM)
insn(MOVUPD, 1,                 OpCls( M128,     XMM,      NONE ), F_660F, 0,  no_WDS, 0x11,     0x00,       P_686|P_SSE2,W1|QSIZE|FVM)
ins (MOVUPS, movups,            OpCls( XMM,      XMM_M128, NONE ), F_0F,   1,  no_WDS, 0x10,     0x00,       P_686|P_SSE1,DSIZE|FVM)
insn(MOVUPS, 1,                 OpCls( M128,     XMM,      NONE ), F_0F,   0,  no_WDS, 0x11,     0x00,       P_686|P_SSE1,DSIZE|FVM)

ins (MOVHPD, movhpd,            OpCls( XMM,      M64,      NONE ), F_660F, 1,  no_WDS, 0x16,     0x00,       P_686|P_SSE2,W1|QSIZE|T1S)
insn(MOVHPD, 1,                 OpCls( M64,      XMM,      NONE ), F_660F, 0,  no_WDS, 0x17,     0x00,       P_686|P_SSE2,W1|QSIZE|T1S)
ins (MOVHPS, movhps,            OpCls( XMM,      M64,      NONE ), F_0F,   1,  no_WDS, 0x16,     0x00,       P_686|P_SSE1,DSIZE|T2)
insn(MOVHPS, 1,                 OpCls( M64,      XMM,      NONE ), F_0F,   0,  no_WDS, 0x17,     0x00,       P_686|P_SSE1,DSIZE|T2)
ins (MOVLPD, movlpd,            OpCls( XMM,      M64,      NONE ), F_660F, 1,  no_WDS, 0x12,     0x00,       P_686|P_SSE2,W1|QSIZE|T1S)
insn(MOVLPD, 1,                 OpCls( M64,      XMM,      NONE ), F_660F, 0,  no_WDS, 0x13,     0x00,       P_686|P_SSE2,W1|QSIZE|T1S)
ins (MOVLPS, movlps,            OpCls( XMM,      M64,      NONE ), F_0F,   1,  no_WDS, 0x12,     0x00,       P_686|P_SSE1,DSIZE|T2)
insn(MOVLPS, 1,                 OpCls( M64,      XMM,      NONE ), F_0F,   0,  no_WDS, 0x13,     0x00,       P_686|P_SSE1,DSIZE|T2)

ins (MOVHLPS, movhlps,          OpCls( XMM,      XMM,      NONE ), F_0F,   1,  no_WDS, 0x12,     0x00,       P_686|P_SSE1,DSIZE)
ins (MOVLHPS, movlhps,          OpCls( XMM,      XMM,      NONE ), F_0F,   1,  no_WDS, 0x16,     0x00,       P_686|P_SSE1,DSIZE)
ins (MOVDQ2Q, movdq2q,          OpCls( MMX,      XMM,      NONE ), F_F20F, 1,  no_WDS, 0xD6,     0x00,       P_686|P_SSE2,W1|QSIZE)
ins (MOVQ2DQ, movq2dq,          OpCls( XMM,      MMX,      NONE ), F_F30F, 1,  no_WDS, 0xD6,     0x00,       P_686|P_SSE2,W1|QSIZE)

ins (MOVMSKPD, movmskpd,        OpCls( RGT16,    XMM,      NONE ), F_660F, 1,  no_WDS, 0x50,     0x00,       P_686|P_SSE2,0)
ins (MOVMSKPS, movmskps,        OpCls( RGT16,    XMM,      NONE ), F_0F,   1,  no_WDS, 0x50,     0x00,       P_686|P_SSE1,0)
ins (MOVNTDQ, movntdq,          OpCls( M128,     XMM,      NONE ), F_660F, 0,  no_WDS, 0xE7,     0x00,       P_686|P_SSE2,DSIZE|FVM)
ins (MOVNTI, movnti,            OpCls( MGT16,    RGT16,    NONE ), F_0F,   0,  no_WDS, 0xC3,     0x00,       P_686|P_SSE2,W1|QSIZE|FVM)
ins (MOVNTPD, movntpd,          OpCls( M128,     XMM,      NONE ), F_660F, 0,  no_WDS, 0x2B,     0x00,       P_686|P_SSE2,W1|QSIZE|FVM)
ins (MOVNTPS, movntps,          OpCls( M128,     XMM,      NONE ), F_0F,   0,  no_WDS, 0x2B,     0x00,       P_686|P_SSE1,DSIZE|FVM)
ins (MOVNTQ, movntq,            OpCls( M64,      MMX,      NONE ), F_0F,   0,  no_WDS, 0xE7,     0x00,       P_686|P_SSE1,DSIZE|FVM)
//ins (MOVSD, movsd,              OpCls( XMM,      XMM_M64,  NONE ), F_F20F, 1,  no_WDS, 0x10,     0x00,       P_686|P_SSE2,W1|QSIZE|)
//insn(MOVSD, 1                   OpCls( M64,      XMM,      NONE ), F_F20F, 0,  no_WDS, 0x11,     0x00,       P_686|P_SSE2,W1|QSIZE|)
ins (MOVSS, movss,              OpCls( XMM,      XMM_M32,  NONE ), F_F30F, 1,  no_WDS, 0x10,     0x00,       P_686|P_SSE1,DSIZE|T1S)
insn(MOVSS, 1,                  OpCls( M32,      XMM,      NONE ), F_F30F, 0,  no_WDS, 0x11,     0x00,       P_686|P_SSE1,DSIZE|T1S)

ins (PACKSSDW, packssdw,        OpCls( MMX,      MMX_M64,  NONE ), F_0F,   1,  no_WDS, 0x6B,     0x00,       P_586|P_MMX, DSIZE)
insn(PACKSSDW, 1,               OpCls( XMM,      XMM_M128, NONE ), F_660F, 1,  no_WDS, 0x6B,     0x00,       P_686|P_SSE2,DSIZE|FV)
ins (PACKSSWB, packsswb,        OpCls( MMX,      MMX_M64,  NONE ), F_0F,   1,  no_WDS, 0x63,     0x00,       P_586|P_MMX, DSIZE)
insn(PACKSSWB, 1,               OpCls( XMM,      XMM_M128, NONE ), F_660F, 1,  no_WDS, 0x63,     0x00,       P_686|P_SSE2,DSIZE|FVM)
ins (PACKUSWB, packuswb,        OpCls( MMX,      MMX_M64,  NONE ), F_0F,   1,  no_WDS, 0x67,     0x00,       P_586|P_MMX, QSIZE)
insn(PACKUSWB, 1,               OpCls( XMM,      XMM_M128, NONE ), F_660F, 1,  no_WDS, 0x67,     0x00,       P_686|P_SSE2,WSIZE|FVM)
ins (PADDB, paddb,              OpCls( MMX,    MMX_M64_08, NONE ), F_0F,   1,  no_WDS, 0xFC,     0x00,       P_586|P_MMX, QSIZE)
insn(PADDB, 1,                  OpCls( XMM,    XMM_M128_08,NONE ), F_660F, 1,  no_WDS, 0xFC,     0x00,       P_686|P_SSE2,BSIZE|FVM)
ins (PADDW, paddw,              OpCls( MMX,    MMX_M64_16, NONE ), F_0F,   1,  no_WDS, 0xFD,     0x00,       P_586|P_MMX, QSIZE)
insn(PADDW, 1,                  OpCls( XMM,    XMM_M128_16,NONE ), F_660F, 1,  no_WDS, 0xFD,     0x00,       P_686|P_SSE2,WSIZE|FVM)
ins (PADDD, paddd,              OpCls( MMX,    MMX_M64_32, NONE ), F_0F,   1,  no_WDS, 0xFE,     0x00,       P_586|P_MMX, DSIZE)
insn(PADDD, 1,                  OpCls( XMM,    XMM_M128_32,NONE ), F_660F, 1,  no_WDS, 0xFE,     0x00,       P_686|P_SSE2,DSIZE|FV)
//insn(PADDD, 2,                  OpCls( YMM,    YMM_M256_32,NONE ), F_660F, 1,  no_WDS, 0xFE,     0x00,       P_686|P_SSE2,DSIZE|FV)
//insn(PADDD, 3,                  OpCls( ZMM,    ZMM_M512_32,NONE ), F_0F,   1,  no_WDS, 0xFE,     0x00,       P_686|P_SSE2,DSIZE|FV)
ins (PADDQ, paddq,              OpCls( MMX,    MMX_M64,    NONE ), F_0F,   1,  no_WDS, 0xD4,     0x00,       P_686|P_SSE2,W1|QSIZE|FV)
insn(PADDQ, 1,                  OpCls( XMM,    XMM_M128_64,NONE ), F_660F, 1,  no_WDS, 0xD4,     0x00,       P_686|P_SSE2,W1|QSIZE|FV)
ins (PADDSB, paddsb,            OpCls( MMX,    MMX_M64_08, NONE ), F_0F,   1,  no_WDS, 0xEC,     0x00,       P_586|P_MMX, QSIZE)
insn(PADDSB, 1,                 OpCls( XMM,    XMM_M128_08,NONE ), F_660F, 1,  no_WDS, 0xEC,     0x00,       P_686|P_SSE2,BSIZE|FVM)
ins (PADDSW, paddsw,            OpCls( MMX,    MMX_M64_16, NONE ), F_0F,   1,  no_WDS, 0xED,     0x00,       P_586|P_MMX, QSIZE)
insn(PADDSW, 1,                 OpCls( XMM,    XMM_M128_16,NONE ), F_660F, 1,  no_WDS, 0xED,     0x00,       P_686|P_SSE2,WSIZE|FVM)
ins (PADDUSB, paddusb,          OpCls( MMX,    MMX_M64_08, NONE ), F_0F,   1,  no_WDS, 0xDC,     0x00,       P_586|P_MMX, QSIZE)
insn(PADDUSB, 1,                OpCls( XMM,    XMM_M128_08,NONE ), F_660F, 1,  no_WDS, 0xDC,     0x00,       P_686|P_SSE2,BSIZE|FVM)
ins (PADDUSW, paddusw,          OpCls( MMX,    MMX_M64_16, NONE ), F_0F,   1,  no_WDS, 0xDD,     0x00,       P_586|P_MMX, QSIZE)
insn(PADDUSW, 1,                OpCls( XMM,    XMM_M128_16,NONE ), F_660F, 1,  no_WDS, 0xDD,     0x00,       P_686|P_SSE2,WSIZE|FVM)
ins (PAND, pand,                OpCls( MMX,      MMX_M64,  NONE ), F_0F,   1,  no_WDS, 0xDB,     0x00,       P_586|P_MMX, QSIZE)
insn(PAND, 1,                   OpCls( XMM,      XMM_M128, NONE ), F_660F, 1,  no_WDS, 0xDB,     0x00,       P_686|P_SSE2,QSIZE|FV)
ins (PANDN, pandn,              OpCls( MMX,      MMX_M64,  NONE ), F_0F,   1,  no_WDS, 0xDF,     0x00,       P_586|P_MMX, QSIZE)
insn(PANDN, 1,                  OpCls( XMM,      XMM_M128, NONE ), F_660F, 1,  no_WDS, 0xDF,     0x00,       P_686|P_SSE2,W1|QSIZE|FV)
ins (PAVGB, pavgb,              OpCls( MMX,      MMX_M64,  NONE ), F_0F,   1,  no_WDS, 0xE0,     0x00,       P_686|P_SSE1,DSIZE|FVM)
insn(PAVGB, 1,                  OpCls( XMM,      XMM_M128, NONE ), F_660F, 1,  no_WDS, 0xE0,     0x00,       P_686|P_SSE2,BSIZE|FVM)
ins (PAVGW, pavgw,              OpCls( MMX,      MMX_M64,  NONE ), F_0F,   1,  no_WDS, 0xE3,     0x00,       P_686|P_SSE1,DSIZE|FVM)
insn(PAVGW, 1,                  OpCls( XMM,      XMM_M128, NONE ), F_660F, 1,  no_WDS, 0xE3,     0x00,       P_686|P_SSE2,WSIZE|FVM)
ins (PCMPEQB, pcmpeqb,          OpCls( MMX,      MMX_M64,  NONE ), F_0F,   1,  no_WDS, 0x74,     0x00,       P_586|P_MMX, QSIZE)
insn(PCMPEQB, 1,                OpCls( XMM,      XMM_M128, NONE ), F_660F, 1,  no_WDS, 0x74,     0x00,       P_686|P_SSE2,BSIZE|FVM)
ins (PCMPEQW, pcmpeqw,          OpCls( MMX,      MMX_M64,  NONE ), F_0F,   1,  no_WDS, 0x75,     0x00,       P_586|P_MMX, QSIZE)
insn(PCMPEQW, 1,                OpCls( XMM,      XMM_M128, NONE ), F_660F, 1,  no_WDS, 0x75,     0x00,       P_686|P_SSE2,WSIZE|FVM)
ins (PCMPEQD, pcmpeqd,          OpCls( MMX,      MMX_M64,  NONE ), F_0F,   1,  no_WDS, 0x76,     0x00,       P_586|P_MMX, QSIZE)
insn(PCMPEQD, 1,                OpCls( XMM,      XMM_M128, NONE ), F_660F, 1,  no_WDS, 0x76,     0x00,       P_686|P_SSE2,DSIZE|FV)
ins (PCMPGTB, pcmpgtb,          OpCls( MMX,      MMX_M64,  NONE ), F_0F,   1,  no_WDS, 0x64,     0x00,       P_586|P_MMX, QSIZE)
insn(PCMPGTB, 1,                OpCls( XMM,      XMM_M128, NONE ), F_660F, 1,  no_WDS, 0x64,     0x00,       P_686|P_SSE2,BSIZE|FVM)
ins (PCMPGTW, pcmpgtw,          OpCls( MMX,      MMX_M64,  NONE ), F_0F,   1,  no_WDS, 0x65,     0x00,       P_586|P_MMX, QSIZE)
insn(PCMPGTW, 1,                OpCls( XMM,      XMM_M128, NONE ), F_660F, 1,  no_WDS, 0x65,     0x00,       P_686|P_SSE2,WSIZE|FVM)
ins (PCMPGTD, pcmpgtd,          OpCls( MMX,      MMX_M64,  NONE ), F_0F,   1,  no_WDS, 0x66,     0x00,       P_586|P_MMX, W1|QSIZE|FV)
insn(PCMPGTD, 1,                OpCls( XMM,      XMM_M128, NONE ), F_660F, 1,  no_WDS, 0x66,     0x00,       P_686|P_SSE2,DSIZE|FV)
ins (PEXTRW, pextrw,            OpCls( RGT16,    MMX,      I8_U ), F_0F,   1,  no_WDS, 0xC5,     0x00,       P_686|P_SSE2,WSIZE|T1S)
insn(PEXTRW, 1,                 OpCls( RGT16,    XMM,      I8_U ), F_660F, 1,  no_WDS, 0xC5,     0x00,       P_686|P_SSE1,WSIZE|T1S)
#if SSE4SUPP /* SSE 4.1 */
insn(PEXTRW, 2,                 OpCls( M16,      XMM,      I8_U ), F_660F3A, 0,no_WDS, 0x15,     0x00,       P_686|P_SSE4,WSIZE|T1S)
ins (PEXTRQ, pextrq,            OpCls( R64_M64,  XMM,      I8_U ), F_660F3A, 0,no_WDS, 0x16,     0x00,       P_686|P_SSE4,W1|QSIZE|T1S)
#endif
/* v2.06: define it like PINSRB/PINSRD */
//ins (PINSRW, pinsrw,            OpCls( MMX,      R32,      I8_U ), F_0F,   1,  no_WDS, 0xC4,     0x00,       P_686|P_SSE1,DSIZE|)
//insn(PINSRW, 1,                 OpCls( MMX,      M16,      I8_U ), F_0F,   1,  no_WDS, 0xC4,     0x00,       P_686|P_SSE1,DSIZE|)
//insn(PINSRW, 2,                 OpCls( XMM,      R32,      I8_U ), F_660F, 1,  no_WDS, 0xC4,     0x00,       P_686|P_SSE1,DSIZE|)
//insn(PINSRW, 3,                 OpCls( XMM,      M16,      I8_U ), F_660F, 1,  no_WDS, 0xC4,     0x00,       P_686|P_SSE1,DSIZE|)
ins (PINSRW, pinsrw,            OpCls( MMX,      R32_M16,  I8_U ), F_0F,   1,  no_WDS, 0xC4,     0x00,       P_686|P_SSE1,QSIZE)
insn(PINSRW, 1,                 OpCls( XMM,      R32_M16,  I8_U ), F_660F, 1,  no_WDS, 0xC4,     0x00,       P_686|P_SSE1,WSIZE|T1S)
ins (PMADDWD, pmaddwd,          OpCls( MMX,      MMX_M64,  NONE ), F_0F,   1,  no_WDS, 0xF5,     0x00,       P_586|P_MMX, QSIZE)
insn(PMADDWD, 1,                OpCls( XMM,      XMM_M128, NONE ), F_660F, 1,  no_WDS, 0xF5,     0x00,       P_686|P_SSE2,WSIZE|FVM)
ins (PMAXSW, pmaxsw,            OpCls( MMX,      MMX_M64,  NONE ), F_0F,   1,  no_WDS, 0xEE,     0x00,       P_686|P_SSE1,WSIZE|FVM)
insn(PMAXSW, 1,                 OpCls( XMM,      XMM_M128, NONE ), F_660F, 1,  no_WDS, 0xEE,     0x00,       P_686|P_SSE2,WSIZE|FVM)
ins (PMAXUB, pmaxub,            OpCls( MMX,      MMX_M64,  NONE ), F_0F,   1,  no_WDS, 0xDE,     0x00,       P_686|P_SSE1,BSIZE|FVM)
insn(PMAXUB, 1,                 OpCls( XMM,      XMM_M128, NONE ), F_660F, 1,  no_WDS, 0xDE,     0x00,       P_686|P_SSE2,BSIZE|FVM)
ins (PMINSW, pminsw,            OpCls( MMX,      MMX_M64,  NONE ), F_0F,   1,  no_WDS, 0xEA,     0x00,       P_686|P_SSE1,WSIZE|FVM)
insn(PMINSW, 1,                 OpCls( XMM,      XMM_M128, NONE ), F_660F, 1,  no_WDS, 0xEA,     0x00,       P_686|P_SSE2,WSIZE|FVM)
ins (PMINUB, pminub,            OpCls( MMX,      MMX_M64,  NONE ), F_0F,   1,  no_WDS, 0xDA,     0x00,       P_686|P_SSE1,BSIZE|FVM)
insn(PMINUB, 1,                 OpCls( XMM,      XMM_M128, NONE ), F_660F, 1,  no_WDS, 0xDA,     0x00,       P_686|P_SSE2,BSIZE|FVM)
ins (PMOVMSKB, pmovmskb,        OpCls( RGT16,    MMX,      NONE ), F_0F,   1,  no_WDS, 0xD7,     0x00,       P_686|P_SSE1,BSIZE)
insn(PMOVMSKB, 1,               OpCls( RGT16,    XMM,      NONE ), F_660F, 1,  no_WDS, 0xD7,     0x00,       P_686|P_SSE2,BSIZE)
insn(PMOVMSKB, 2,               OpCls( RGT16,    YMM,      NONE ), F_660F, 1,  no_WDS, 0xD7,     0x00,       P_686|P_SSE2,BSIZE)
ins (PMULHUW, pmulhuw,          OpCls( MMX,      MMX_M64,  NONE ), F_0F,   1,  no_WDS, 0xE4,     0x00,       P_586|P_SSE1,WSIZE|FVM)
insn(PMULHUW, 1,                OpCls( XMM,      XMM_M128, NONE ), F_660F, 1,  no_WDS, 0xE4,     0x00,       P_686|P_SSE2,WSIZE|FVM)
ins (PMULHW, pmulhw,            OpCls( MMX,      MMX_M64,  NONE ), F_0F,   1,  no_WDS, 0xE5,     0x00,       P_586|P_MMX, WSIZE)
insn(PMULHW, 1,                 OpCls( XMM,      XMM_M128, NONE ), F_660F, 1,  no_WDS, 0xE5,     0x00,       P_686|P_SSE2,WSIZE|FVM)
ins (PMULLW, pmullw,            OpCls( MMX,      MMX_M64,  NONE ), F_0F,   1,  no_WDS, 0xD5,     0x00,       P_586|P_MMX, WSIZE)
insn(PMULLW, 1,                 OpCls( XMM,      XMM_M128, NONE ), F_660F, 1,  no_WDS, 0xD5,     0x00,       P_686|P_SSE2,WSIZE|FVM)
ins (PMULUDQ, pmuludq,          OpCls( MMX,      XMM_M64,  NONE ), F_0F,   1,  no_WDS, 0xF4,     0x00,       P_686|P_SSE2,QSIZE|FV)
insn(PMULUDQ, 1,                OpCls( XMM,      XMM_M64,  NONE ), F_660F, 1,  no_WDS, 0xF4,     0x00,       P_686|P_SSE2,W1|QSIZE|FV)
insn(PMULUDQ, 2,                OpCls( XMM,      XMM_M128, NONE ), F_660F, 1,  no_WDS, 0xF4,     0x00,       P_686|P_SSE2,XSIZE|FV)
ins (POR, por,                  OpCls( MMX,      MMX_M64,  NONE ), F_0F,   1,  no_WDS, 0xEB,     0x00,       P_586|P_MMX, QSIZE)
insn(POR,  1,                   OpCls( XMM,      XMM_M128, NONE ), F_660F, 1,  no_WDS, 0xEB,     0x00,       P_686|P_SSE2,XSIZE)
ins (PSADBW, psadbw,            OpCls( MMX,      MMX_M64,  NONE ), F_0F,   1,  no_WDS, 0xF6,     0x00,       P_686|P_SSE1,WSIZE|FVM)
insn(PSADBW, 1,                 OpCls( XMM,      XMM_M128, NONE ), F_660F, 1,  no_WDS, 0xF6,     0x00,       P_686|P_SSE2,WSIZE|FVM)
ins (PSHUFD, pshufd,            OpCls( XMM,      XMM_M128, I8_U ), F_660F, 1,  no_WDS, 0x70,     0x00,       P_686|P_SSE2,DSIZE|FV)
//insn (PSHUFD, 1,                OpCls( YMM,      YMM_M256, I8_U ), F_660F, 1,  no_WDS, 0x70,     0x00,       P_686|P_SSE2,DSIZE|FV)
//insn (PSHUFD, 2,                OpCls( ZMM,      ZMM_M512, I8_U ), F_660F, 1,  no_WDS, 0x70,     0x00,       P_686|P_SSE2,DSIZE|FV)
ins (PSHUFW, pshufw,            OpCls( MMX,      MMX_M64,  I8_U ), F_0F,   1,  no_WDS, 0x70,     0x00,       P_686|P_SSE1,WSIZE)
//insn (PSHUFW, 1,                OpCls( XMM,      XMM_M128, I8_U ), F_0F,   1,  no_WDS, 0x70,     0x00,       P_686|P_SSE1,WSIZE)
//insn (PSHUFW, 2,                OpCls( YMM,      YMM_M256, I8_U ), F_0F,   1,  no_WDS, 0x70,     0x00,       P_686|P_SSE1,WSIZE)
ins (PSHUFHW, pshufhw,          OpCls( XMM,      XMM_M128, I8_U ), F_F30F, 1,  no_WDS, 0x70,     0x00,       P_686|P_SSE2,WSIZE|FVM)
//insn (PSHUFHW, 1,               OpCls( YMM,      YMM_M256, I8_U ), F_F30F, 1,  no_WDS, 0x70,     0x00,       P_686|P_SSE2,WSIZE|FVM)
ins (PSHUFLW, pshuflw,          OpCls( XMM,      XMM_M128, I8_U ), F_F20F, 1,  no_WDS, 0x70,     0x00,       P_686|P_SSE2,WSIZE|FVM)
//insn (PSHUFLW, 1,               OpCls( YMM,      YMM_M256, I8_U ), F_F20F, 1,  no_WDS, 0x70,     0x00,       P_686|P_SSE2,WSIZE|FVM)
ins (PSLLW, psllw,			        OpCls( MMX,      MMX_M64,  NONE ), F_0F,   1,  no_WDS, 0xF1,     0x00,		   P_586 | P_MMX, WSIZE | FVM)
insn(PSLLW, 1,				          OpCls( MMX,      I8_U,     NONE ), F_0F,   0,  no_WDS, 0x71,     0x30,		   P_586 | P_MMX, WSIZE | FVM)
insn(PSLLW, 2,				          OpCls( XMM,      I8_U,     NONE ), F_660F, 0,  no_WDS, 0x71,     0x30,		   P_686 | P_SSE2, WSIZE | T128)
insn(PSLLW, 3,				          OpCls( XMM,      XMM_M128, NONE ), F_660F, 1,  no_WDS, 0xF1,     0x00,		   P_686 | P_SSE2, WSIZE | FVM)
ins (PSLLD, pslld,			        OpCls( MMX,      MMX_M64,  NONE ), F_0F,   1,  no_WDS, 0xF2,     0x00,		   P_586 | P_MMX, QSIZE)
insn(PSLLD, 1,				          OpCls( MMX,      I8_U,     NONE ), F_0F,   0,  no_WDS, 0x72,     0x30,		   P_586 | P_MMX, QSIZE)
insn(PSLLD, 2,				          OpCls( XMM,      I8_U,     NONE ), F_660F, 0,  no_WDS, 0x72,     0x30,		   P_686 | P_SSE2, DSIZE | FV)
insn(PSLLD, 3,				          OpCls( XMM,      XMM_M128, NONE ), F_660F, 1,  no_WDS, 0xF2,     0x00,		   P_686 | P_SSE2, DSIZE | T128)
ins (PSLLQ, psllq,			        OpCls( MMX,      MMX_M64,  NONE ), F_0F,   1,  no_WDS, 0xF3,     0x00,		   P_586 | P_MMX, QSIZE)
insn(PSLLQ, 1,					        OpCls( MMX,      I8_U,     NONE ), F_0F,   0,  no_WDS, 0x73,     0x30,		   P_586 | P_MMX, QSIZE)
insn(PSLLQ, 2,                  OpCls( XMM,      I8_U,     NONE ), F_660F, 0,  no_WDS, 0x73,     0x30,		   P_686 | P_SSE2, W1|QSIZE | FV)
insn(PSLLQ, 3,				          OpCls( XMM,      XMM_M128, NONE ), F_660F, 1,  no_WDS, 0xF3,     0x00,		   P_686 | P_SSE2, W1|QSIZE | T128 )
ins (PSRAW, psraw,              OpCls( MMX,      MMX_M64,  NONE ), F_0F,   1,  no_WDS, 0xE1,     0x00,       P_586|P_MMX, QSIZE)
insn(PSRAW, 1,                  OpCls( MMX,      I8_U,     NONE ), F_0F,   0,  no_WDS, 0x71,     0x20,       P_586|P_MMX, QSIZE)
insn(PSRAW, 2,                  OpCls( XMM,      I8_U,     NONE ), F_660F, 0,  no_WDS, 0x71,     0x20,       P_686|P_SSE2,WSIZE|FVM)
insn(PSRAW, 3,                  OpCls( XMM,      XMM_M128, NONE ), F_660F, 1,  no_WDS, 0xE1,     0x00,       P_586|P_SSE2,WSIZE|T128)
ins (PSRAD, psrad,              OpCls( MMX,      MMX_M64,  NONE ), F_0F,   1,  no_WDS, 0xE2,     0x00,       P_586|P_MMX, QSIZE)
insn(PSRAD, 1,                  OpCls( MMX,      I8_U,     NONE ), F_0F,   0,  no_WDS, 0x72,     0x20,       P_586|P_MMX, QSIZE)
insn(PSRAD, 2,                  OpCls( XMM,      I8_U,     NONE ), F_660F, 0,  no_WDS, 0x72,     0x20,       P_686|P_SSE2,DSIZE|FV)
insn(PSRAD, 3,                  OpCls( XMM,      XMM_M128, NONE ), F_660F, 1,  no_WDS, 0xE2,     0x00,       P_686|P_SSE2,DSIZE|T128)
/* PSRAQ moved here for easyer handling, Uasm 2.16 */
//EVEX.NDD.128.66.0F.W1 72 /4 ib FVI VPSRAQ xmm1 {k1}{z}, xmm2/m128/m64bcst, imm8
ins(PSRAQ, psraq,               OpCls( XMM,      I8_U,     NONE ), F_660F, 0,  no_WDS, 0x72,     0x20,       P_686|P_AVX,W1|IZSZ|QSIZE|FV)
insn(PSRAQ, 1,                  OpCls( XMM,      XMM_M128, NONE ), F_660F, 1,  no_WDS, 0xE2,     0x00,       P_686|P_AVX,W1|QSIZE|T128)

ins (PSRLW, psrlw,              OpCls( MMX,      MMX_M64,  NONE ), F_0F,   1,  no_WDS, 0xD1,     0x00,       P_586|P_MMX, QSIZE)
insn(PSRLW, 1,                  OpCls( MMX,      I8_U,     NONE ), F_0F,   0,  no_WDS, 0x71,     0x10,       P_586|P_MMX, QSIZE)
insn(PSRLW, 2,                  OpCls( XMM,      I8_U,     NONE ), F_660F, 0,  no_WDS, 0x71,     0x10,       P_686|P_SSE2,WSIZE|FVM)
insn(PSRLW, 3,                  OpCls( XMM,      XMM_M128, NONE ), F_660F, 1,  no_WDS, 0xD1,     0x00,       P_686|P_SSE2,WSIZE|T128)
ins (PSRLD, psrld,              OpCls( MMX,      MMX_M64,  NONE ), F_0F,   1,  no_WDS, 0xD2,     0x00,       P_586|P_MMX, QSIZE)
insn(PSRLD, 1,                  OpCls( MMX,      I8_U,     NONE ), F_0F,   0,  no_WDS, 0x72,     0x10,       P_586|P_MMX, QSIZE)
insn(PSRLD, 2,                  OpCls( XMM,      I8_U,     NONE ), F_660F, 0,  no_WDS, 0x72,     0x10,       P_686|P_SSE2,DSIZE|FV)
insn(PSRLD, 3,                  OpCls( XMM,      XMM_M128, NONE ), F_660F, 1,  no_WDS, 0xD2,     0x00,       P_686|P_SSE2,DSIZE|T128)
ins (PSRLQ, psrlq,              OpCls( MMX,      MMX_M64,  NONE ), F_0F,   1,  no_WDS, 0xD3,     0x00,       P_586|P_MMX, QSIZE)
insn(PSRLQ, 1,                  OpCls( MMX,      I8_U,     NONE ), F_0F,   0,  no_WDS, 0x73,     0x10,       P_586|P_MMX, QSIZE)
insn(PSRLQ, 2,                  OpCls( XMM,      I8_U,     NONE ), F_660F, 0,  no_WDS, 0x73,     0x10,       P_686|P_SSE2,W1|QSIZE|FV)
insn(PSRLQ, 3,                  OpCls( XMM,      XMM_M128, NONE ), F_660F, 1,  no_WDS, 0xD3,     0x00,       P_686|P_SSE2,W1|QSIZE|T128)

ins (PSLLDQ, pslldq,            OpCls( XMM,      I8_U,     NONE ), F_660F, 0,  no_WDS, 0x73,     0x38,       P_686|P_SSE2,QSIZE|FV)
ins (PSRLDQ, psrldq,            OpCls( XMM,      I8_U,     NONE ), F_660F, 0,  no_WDS, 0x73,     0x18,       P_686|P_SSE2,QSIZE|FV)

ins (PSUBB, psubb,              OpCls( MMX,      MMX_M64,  NONE ), F_0F,   1,  no_WDS, 0xF8,     0x00,       P_586|P_MMX, QSIZE)
insn(PSUBB, 1,                  OpCls( XMM,      XMM_M128, NONE ), F_660F, 1,  no_WDS, 0xF8,     0x00,       P_686|P_SSE2,BSIZE|FVM)
ins (PSUBW, psubw,              OpCls( MMX,      MMX_M64,  NONE ), F_0F,   1,  no_WDS, 0xF9,     0x00,       P_586|P_MMX, QSIZE)
insn(PSUBW, 1,                  OpCls( XMM,      XMM_M128, NONE ), F_660F, 1,  no_WDS, 0xF9,     0x00,       P_686|P_SSE2,WSIZE|FVM)
ins (PSUBD, psubd,              OpCls( MMX,      MMX_M64,  NONE ), F_0F,   1,  no_WDS, 0xFA,     0x00,       P_586|P_MMX, QSIZE)
insn(PSUBD, 1,                  OpCls( XMM,      XMM_M128, NONE ), F_660F, 1,  no_WDS, 0xFA,     0x00,       P_686|P_SSE2,DSIZE|FV)
ins (PSUBQ, psubq,              OpCls( MMX,      MMX_M64,  NONE ), F_0F,   1,  no_WDS, 0xFB,     0x00,       P_686|P_SSE2,QSIZE)
insn(PSUBQ, 1,                  OpCls( XMM,      XMM_M128, NONE ), F_660F, 1,  no_WDS, 0xFB,     0x00,       P_686|P_SSE2,W1|QSIZE|FV)
ins (PSUBSB, psubsb,            OpCls( MMX,      MMX_M64,  NONE ), F_0F,   1,  no_WDS, 0xE8,     0x00,       P_586|P_MMX, QSIZE)
insn(PSUBSB, 1,                 OpCls( XMM,      XMM_M128, NONE ), F_660F, 1,  no_WDS, 0xE8,     0x00,       P_686|P_SSE2,BSIZE|FVM)
ins (PSUBSW, psubsw,            OpCls( MMX,      MMX_M64,  NONE ), F_0F,   1,  no_WDS, 0xE9,     0x00,       P_586|P_MMX, QSIZE)
insn(PSUBSW, 1,                 OpCls( XMM,      XMM_M128, NONE ), F_660F, 1,  no_WDS, 0xE9,     0x00,       P_686|P_SSE2,WSIZE|FVM)
ins (PSUBUSB, psubusb,          OpCls( MMX,      MMX_M64,  NONE ), F_0F,   1,  no_WDS, 0xD8,     0x00,       P_586|P_MMX, QSIZE)
insn(PSUBUSB, 1,                OpCls( XMM,      XMM_M128, NONE ), F_660F, 1,  no_WDS, 0xD8,     0x00,       P_686|P_SSE2,BSIZE|FVM)
ins (PSUBUSW, psubusw,          OpCls( MMX,      MMX_M64,  NONE ), F_0F,   1,  no_WDS, 0xD9,     0x00,       P_586|P_MMX, QSIZE)
insn(PSUBUSW, 1,                OpCls( XMM,      XMM_M128, NONE ), F_660F, 1,  no_WDS, 0xD9,     0x00,       P_686|P_SSE2,WSIZE|FVM)
ins (PXOR, pxor,                OpCls( MMX,      MMX_M64,  NONE ), F_0F,   1,  no_WDS, 0xEF,     0x00,       P_586|P_MMX, QSIZE)
insn(PXOR, 1,                   OpCls( XMM,      XMM_M128, NONE ), F_660F, 1,  no_WDS, 0xEF,     0x00,       P_686|P_SSE2,XSIZE)
ins (PUNPCKHBW, punpckhbw,      OpCls( MMX,      MMX_M64,  NONE ), F_0F,   1,  no_WDS, 0x68,     0x00,       P_586|P_MMX, QSIZE)
insn(PUNPCKHBW, 1,              OpCls( XMM,      XMM_M128, NONE ), F_660F, 1,  no_WDS, 0x68,     0x00,       P_686|P_SSE2,BSIZE|FVM)
ins (PUNPCKHWD, punpckhwd,      OpCls( MMX,      MMX_M64,  NONE ), F_0F,   1,  no_WDS, 0x69,     0x00,       P_586|P_MMX, QSIZE)
insn(PUNPCKHWD, 1,              OpCls( XMM,      XMM_M128, NONE ), F_660F, 1,  no_WDS, 0x69,     0x00,       P_686|P_SSE2,WSIZE|FVM)
ins (PUNPCKHDQ, punpckhdq,      OpCls( MMX,      MMX_M64,  NONE ), F_0F,   1,  no_WDS, 0x6A,     0x00,       P_586|P_MMX, QSIZE)
insn(PUNPCKHDQ, 1,              OpCls( XMM,      XMM_M128, NONE ), F_660F, 1,  no_WDS, 0x6A,     0x00,       P_686|P_SSE2,DSIZE|FV)
ins (PUNPCKLBW, punpcklbw,      OpCls( MMX,      MMX_M64,  NONE ), F_0F,   1,  no_WDS, 0x60,     0x00,       P_586|P_MMX, QSIZE)
insn(PUNPCKLBW, 1,              OpCls( XMM,      XMM_M128, NONE ), F_660F, 1,  no_WDS, 0x60,     0x00,       P_686|P_SSE2,BSIZE|FVM)
ins (PUNPCKLWD, punpcklwd,      OpCls( MMX,      MMX_M64,  NONE ), F_0F,   1,  no_WDS, 0x61,     0x00,       P_586|P_MMX, QSIZE)
insn(PUNPCKLWD, 1,              OpCls( XMM,      XMM_M128, NONE ), F_660F, 1,  no_WDS, 0x61,     0x00,       P_686|P_SSE2,WSIZE|FVM)
ins (PUNPCKLDQ, punpckldq,      OpCls( MMX,      MMX_M64,  NONE ), F_0F,   1,  no_WDS, 0x62,     0x00,       P_586|P_MMX, QSIZE)
insn(PUNPCKLDQ, 1,              OpCls( XMM,      XMM_M128, NONE ), F_660F, 1,  no_WDS, 0x62,     0x00,       P_686|P_SSE2,DSIZE|FV)
ins (PUNPCKHQDQ, punpckhqdq,    OpCls( XMM,      XMM_M128, NONE ), F_660F, 1,  no_WDS, 0x6D,     0x00,       P_686|P_SSE2,W1|QSIZE|FV)
ins (PUNPCKLQDQ, punpcklqdq,    OpCls( XMM,      XMM_M128, NONE ), F_660F, 1,  no_WDS, 0x6C,     0x00,       P_686|P_SSE2,W1|QSIZE|FV)

ins (RCPPS, rcpps,              OpCls( XMM,      XMM_M128, NONE ), F_0F,   1,  no_WDS, 0x53,     0x00,       P_686|P_SSE1,DSIZE)
ins (RCPSS, rcpss,              OpCls( XMM,      XMM_M32,  NONE ), F_F30F, 1,  no_WDS, 0x53,     0x00,       P_686|P_SSE1,DSIZE)
ins (RSQRTPS, rsqrtps,          OpCls( XMM,      XMM_M128, NONE ), F_0F,   1,  no_WDS, 0x52,     0x00,       P_686|P_SSE1,DSIZE)
ins (RSQRTSS, rsqrtss,          OpCls( XMM,      XMM_M32,  NONE ), F_F30F, 1,  no_WDS, 0x52,     0x00,       P_686|P_SSE1,DSIZE)
ins (SHUFPD, shufpd,            OpCls( XMM,      XMM_M128, I8_U ), F_660F, 1,  no_WDS, 0xC6,     0x00,       P_686|P_SSE2,W1|QSIZE|FV)
ins (SHUFPS, shufps,            OpCls( XMM,      XMM_M128, I8_U ), F_0F,   1,  no_WDS, 0xC6,     0x00,       P_686|P_SSE1,DSIZE|FV)
ins (UCOMISD, ucomisd,          OpCls( XMM,      XMM_M64,  NONE ), F_660F, 1,  no_WDS, 0x2E,     0x00,       P_686|P_SSE2,W1|QSIZE|T1S)
ins (UCOMISS, ucomiss,          OpCls( XMM,      XMM_M32,  NONE ), F_0F,   1,  no_WDS, 0x2E,     0x00,       P_686|P_SSE1,DSIZE|T1S)
ins (UNPCKHPD, unpckhpd,        OpCls( XMM,      XMM_M128, NONE ), F_660F, 1,  no_WDS, 0x15,     0x00,       P_686|P_SSE2,W1|QSIZE|FV)
ins (UNPCKHPS, unpckhps,        OpCls( XMM,      XMM_M128, NONE ), F_0F,   1,  no_WDS, 0x15,     0x00,       P_686|P_SSE1,DSIZE|FV)
ins (UNPCKLPD, unpcklpd,        OpCls( XMM,      XMM_M128, NONE ), F_660F, 1,  no_WDS, 0x14,     0x00,       P_686|P_SSE2,W1|QSIZE|FV)
ins (UNPCKLPS, unpcklps,        OpCls( XMM,      XMM_M128, NONE ), F_0F,   1,  no_WDS, 0x14,     0x00,       P_686|P_SSE1,DSIZE|FV)

/* K3D instructions */
#if K3DSUPP
ins (FEMMS, femms,              OpCls( NONE,     NONE,     NONE ), F_0F,   0,  no_RM,  0x0E,     0x00,       P_586|P_K3D, 0)
ins (PREFETCH, prefetch,        OpCls( M_ANY,    NONE,     NONE ), F_0F,   0,  no_WDS, 0x0D,     0x00,       P_586|P_K3D, 0)
ins (PREFETCHW, prefetchw,      OpCls( M_ANY,    NONE,     NONE ), F_0F,   0,  no_WDS, 0x0D,     0x08,       P_586|P_K3D, 0)
ins (PREFETCHWT1, prefetchwt1,  OpCls( M_ANY,    NONE,     NONE ), F_0F,   0,  no_WDS, 0x0D,     0x10,       P_586|P_K3D, 0)
ins (PAVGUSB, pavgusb,          OpCls( MMX,      MMX_M64,  NONE ), F_0F0F, 1,  no_WDS, 0xBF,     0x00,       P_586|P_K3D, 0)
ins (PF2ID, pf2id,              OpCls( MMX,      MMX_M64,  NONE ), F_0F0F, 1,  no_WDS, 0x1D,     0x00,       P_586|P_K3D, 0)
ins (PF2IW, pf2iw,              OpCls( MMX,      MMX_M64,  NONE ), F_0F0F, 1,  no_WDS, 0x1C,     0x00,       P_586|P_K3D, 0)
ins (PFACC, pfacc,              OpCls( MMX,      MMX_M64,  NONE ), F_0F0F, 1,  no_WDS, 0xAE,     0x00,       P_586|P_K3D, 0)
ins (PFADD, pfadd,              OpCls( MMX,      MMX_M64,  NONE ), F_0F0F, 1,  no_WDS, 0x9E,     0x00,       P_586|P_K3D, 0)
ins (PFCMPEQ, pfcmpeq,          OpCls( MMX,      MMX_M64,  NONE ), F_0F0F, 1,  no_WDS, 0xB0,     0x00,       P_586|P_K3D, 0)
ins (PFCMPGE, pfcmpge,          OpCls( MMX,      MMX_M64,  NONE ), F_0F0F, 1,  no_WDS, 0x90,     0x00,       P_586|P_K3D, 0)
ins (PFCMPGT, pfcmpgt,          OpCls( MMX,      MMX_M64,  NONE ), F_0F0F, 1,  no_WDS, 0xA0,     0x00,       P_586|P_K3D, 0)
ins (PFMAX, pfmax,              OpCls( MMX,      MMX_M64,  NONE ), F_0F0F, 1,  no_WDS, 0xA4,     0x00,       P_586|P_K3D, 0)
ins (PFMIN, pfmin,              OpCls( MMX,      MMX_M64,  NONE ), F_0F0F, 1,  no_WDS, 0x94,     0x00,       P_586|P_K3D, 0)
ins (PFMUL, pfmul,              OpCls( MMX,      MMX_M64,  NONE ), F_0F0F, 1,  no_WDS, 0xB4,     0x00,       P_586|P_K3D, 0)
ins (PFNACC, pfnacc,            OpCls( MMX,      MMX_M64,  NONE ), F_0F0F, 1,  no_WDS, 0x8A,     0x00,       P_586|P_K3D, 0)
ins (PFPNACC, pfpnacc,          OpCls( MMX,      MMX_M64,  NONE ), F_0F0F, 1,  no_WDS, 0x8E,     0x00,       P_586|P_K3D, 0)
ins (PFRCP, pfrcp,              OpCls( MMX,      MMX_M64,  NONE ), F_0F0F, 1,  no_WDS, 0x96,     0x00,       P_586|P_K3D, 0)
ins (PFRCPIT1, pfrcpit1,        OpCls( MMX,      MMX_M64,  NONE ), F_0F0F, 1,  no_WDS, 0xA6,     0x00,       P_586|P_K3D, 0)
ins (PFRCPIT2, pfrcpit2,        OpCls( MMX,      MMX_M64,  NONE ), F_0F0F, 1,  no_WDS, 0xB6,     0x00,       P_586|P_K3D, 0)
ins (PFRSQIT1, pfrsqit1,        OpCls( MMX,      MMX_M64,  NONE ), F_0F0F, 1,  no_WDS, 0xA7,     0x00,       P_586|P_K3D, 0)
ins (PFRSQRT, pfrsqrt,          OpCls( MMX,      MMX_M64,  NONE ), F_0F0F, 1,  no_WDS, 0x97,     0x00,       P_586|P_K3D, 0)
ins (PFSUB, pfsub,              OpCls( MMX,      MMX_M64,  NONE ), F_0F0F, 1,  no_WDS, 0x9A,     0x00,       P_586|P_K3D, 0)
ins (PFSUBR, pfsubr,            OpCls( MMX,      MMX_M64,  NONE ), F_0F0F, 1,  no_WDS, 0xAA,     0x00,       P_586|P_K3D, 0)
ins (PI2FD, pi2fd,              OpCls( MMX,      MMX_M64,  NONE ), F_0F0F, 1,  no_WDS, 0x0D,     0x00,       P_586|P_K3D, 0)
ins (PI2FW, pi2fw,              OpCls( MMX,      MMX_M64,  NONE ), F_0F0F, 1,  no_WDS, 0x0C,     0x00,       P_586|P_K3D, 0)
ins (PMULHRW, pmulhrw,          OpCls( MMX,      MMX_M64,  NONE ), F_0F0F, 1,  no_WDS, 0xB7,     0x00,       P_586|P_K3D, 0)
ins (PSWAPD, pswapd,            OpCls( MMX,      MMX_M64,  NONE ), F_0F0F, 1,  no_WDS, 0xBB,     0x00,       P_586|P_K3D, 0)
#endif

#if SSE3SUPP
ins (ADDSUBPD, addsubpd,        OpCls( XMM,      XMM_M128, NONE ), F_660F, 1,  no_WDS, 0xD0,     0x00,       P_686|P_SSE3,0)
ins (ADDSUBPS, addsubps,        OpCls( XMM,      XMM_M128, NONE ), F_F20F, 1,  no_WDS, 0xD0,     0x00,       P_686|P_SSE3,0)
ins (FISTTP, fisttp,            OpCls( M32,      NONE,     NONE ), 0,      0,  no_WDS, 0xDB,     0x08,       P_686|P_SSE3,0)
insn(FISTTP, 1,                 OpCls( M64,      NONE,     NONE ), 0,      0,  no_WDS, 0xDD,     0x08,       P_686|P_SSE3,0)
insn(FISTTP, 2,                 OpCls( M16,      NONE,     NONE ), 0,      0,  no_WDS, 0xDF,     0x08,       P_686|P_SSE3,0)
ins (HADDPD, haddpd,            OpCls( XMM,      XMM_M128, NONE ), F_660F, 1,  no_WDS, 0x7C,     0x00,       P_686|P_SSE3,0)
ins (HADDPS, haddps,            OpCls( XMM,      XMM_M128, NONE ), F_F20F, 1,  no_WDS, 0x7C,     0x00,       P_686|P_SSE3,0)
ins (HSUBPD, hsubpd,            OpCls( XMM,      XMM_M128, NONE ), F_660F, 1,  no_WDS, 0x7D,     0x00,       P_686|P_SSE3,0)
ins (HSUBPS, hsubps,            OpCls( XMM,      XMM_M128, NONE ), F_F20F, 1,  no_WDS, 0x7D,     0x00,       P_686|P_SSE3,0)
ins (LDDQU, lddqu,              OpCls( XMM,      M128,     NONE ), F_F20F, 1,  no_WDS, 0xF0,     0x00,       P_686|P_SSE3,0)
ins (MONITOR, monitor,          OpCls( NONE,     NONE,     NONE ), F_0F,   0,  0,      0x01,     0xC8,       P_686|P_SSE3,0)
ins (MOVDDUP, movddup,          OpCls( XMM,      XMM_M64,  NONE ), F_F20F, 1,  no_WDS, 0x12,     0x00,       P_686|P_SSE3,W1|QSIZE|DUP)
ins (MOVSHDUP, movshdup,        OpCls( XMM,      XMM_M128, NONE ), F_F30F, 1,  no_WDS, 0x16,     0x00,       P_686|P_SSE3,DSIZE|FVM)
ins (MOVSLDUP, movsldup,        OpCls( XMM,      XMM_M128, NONE ), F_F30F, 1,  no_WDS, 0x12,     0x00,       P_686|P_SSE3,DSIZE|FVM)
ins (MWAIT, mwait,              OpCls( NONE,     NONE,     NONE ), F_0F,   0,  0,      0x01,     0xC9,       P_686|P_SSE3,0)
#endif

#if SSSE3SUPP
ins (PABSB, pabsb,              OpCls( MMX,      MMX_M64,  NONE ), F_0F38,  1,  no_WDS, 0x1C,     0x00,       P_686|P_SSSE3, 0)
insn(PABSB, 1,                  OpCls( XMM,      XMM_M128, NONE ), F_660F38,1,  no_WDS, 0x1C,     0x00,       P_686|P_SSSE3, BSIZE|FVM)
ins (PABSD, pabsd,              OpCls( MMX,      MMX_M64,  NONE ), F_0F38,  1,  no_WDS, 0x1E,     0x00,       P_686|P_SSSE3, 0)
insn(PABSD, 1,                  OpCls( XMM,      XMM_M128, NONE ), F_660F38,1,  no_WDS, 0x1E,     0x00,       P_686|P_SSSE3, DSIZE|FV)
ins (PABSW, pabsw,              OpCls( MMX,      MMX_M64,  NONE ), F_0F38,  1,  no_WDS, 0x1D,     0x00,       P_686|P_SSSE3, 0)
insn(PABSW, 1,                  OpCls( XMM,      XMM_M128, NONE ), F_660F38,1,  no_WDS, 0x1D,     0x00,       P_686|P_SSSE3, WSIZE|FVM)
ins (PALIGNR, palignr,          OpCls( MMX,      MMX_M64,  I8_U ), F_0F3A,  1,  no_WDS, 0x0F,     0x00,       P_686|P_SSSE3, 0)
insn(PALIGNR, 1,                OpCls( XMM,      XMM_M128, I8_U ), F_660F3A,1,  no_WDS, 0x0F,     0x00,       P_686|P_SSSE3, XSIZE|FVM)
//insn(PALIGNR, 2,                OpCls( YMM,      YMM_M256, I8_U ), F_660F3A,1,  no_WDS, 0x0F,     0x00,       P_686|P_SSSE3, XSIZE|FVM)
ins (PHADDD, phaddd,            OpCls( MMX,      MMX_M64,  NONE ), F_0F38,  1,  no_WDS, 0x02,     0x00,       P_686|P_SSSE3, 0)
insn(PHADDD, 1,                 OpCls( XMM,      XMM_M128, NONE ), F_660F38,1,  no_WDS, 0x02,     0x00,       P_686|P_SSSE3, 0)
ins (PHADDSW, phaddsw,          OpCls( MMX,      MMX_M64,  NONE ), F_0F38,  1,  no_WDS, 0x03,     0x00,       P_686|P_SSSE3, 0)
insn(PHADDSW, 1,                OpCls( XMM,      XMM_M128, NONE ), F_660F38,1,  no_WDS, 0x03,     0x00,       P_686|P_SSSE3, 0)
ins (PHADDW, phaddw,            OpCls( MMX,      MMX_M64,  NONE ), F_0F38,  1,  no_WDS, 0x01,     0x00,       P_686|P_SSSE3, 0)
insn(PHADDW, 1,                 OpCls( XMM,      XMM_M128, NONE ), F_660F38,1,  no_WDS, 0x01,     0x00,       P_686|P_SSSE3, 0)
ins (PHSUBD, phsubd,            OpCls( MMX,      MMX_M64,  NONE ), F_0F38,  1,  no_WDS, 0x06,     0x00,       P_686|P_SSSE3, 0)
insn(PHSUBD, 1,                 OpCls( XMM,      XMM_M128, NONE ), F_660F38,1,  no_WDS, 0x06,     0x00,       P_686|P_SSSE3, 0)
ins (PHSUBSW, phsubsw,          OpCls( MMX,      MMX_M64,  NONE ), F_0F38,  1,  no_WDS, 0x07,     0x00,       P_686|P_SSSE3, 0)
insn(PHSUBSW, 1,                OpCls( XMM,      XMM_M128, NONE ), F_660F38,1,  no_WDS, 0x07,     0x00,       P_686|P_SSSE3, 0)
ins (PHSUBW, phsubw,            OpCls( MMX,      MMX_M64,  NONE ), F_0F38,  1,  no_WDS, 0x05,     0x00,       P_686|P_SSSE3, 0)
insn(PHSUBW, 1,                 OpCls( XMM,      XMM_M128, NONE ), F_660F38,1,  no_WDS, 0x05,     0x00,       P_686|P_SSSE3, 0)
ins (PMADDUBSW, pmaddubsw,      OpCls( MMX,      MMX_M64,  NONE ), F_0F38,  1,  no_WDS, 0x04,     0x00,       P_686|P_SSSE3, 0)
insn(PMADDUBSW, 1,              OpCls( XMM,      XMM_M128, NONE ), F_660F38,1,  no_WDS, 0x04,     0x00,       P_686|P_SSSE3, BSIZE|FVM)
ins (PMULHRSW, pmulhrsw,        OpCls( MMX,      MMX_M64,  NONE ), F_0F38,  1,  no_WDS, 0x0B,     0x00,       P_686|P_SSSE3, 0)
insn(PMULHRSW, 1,               OpCls( XMM,      XMM_M128, NONE ), F_660F38,1,  no_WDS, 0x0B,     0x00,       P_686|P_SSSE3, WSIZE|FVM)
ins (PSHUFB, pshufb,            OpCls( MMX,      MMX_M64,  NONE ), F_0F38,  1,  no_WDS, 0x00,     0x00,       P_686|P_SSSE3, 0)
insn(PSHUFB, 1,                 OpCls( XMM,      XMM_M128, NONE ), F_660F38,1,  no_WDS, 0x00,     0x00,       P_686|P_SSSE3, BSIZE|FVM)
ins (PSIGNB, psignb,            OpCls( MMX,      MMX_M64,  NONE ), F_0F38,  1,  no_WDS, 0x08,     0x00,       P_686|P_SSSE3, 0)
insn(PSIGNB, 1,                 OpCls( XMM,      XMM_M128, NONE ), F_660F38,1,  no_WDS, 0x08,     0x00,       P_686|P_SSSE3, 0)
ins (PSIGND, psignd,            OpCls( MMX,      MMX_M64,  NONE ), F_0F38,  1,  no_WDS, 0x0A,     0x00,       P_686|P_SSSE3, 0)
insn(PSIGND, 1,                 OpCls( XMM,      XMM_M128, NONE ), F_660F38,1,  no_WDS, 0x0A,     0x00,       P_686|P_SSSE3, 0)
ins (PSIGNW, psignw,            OpCls( MMX,      MMX_M64,  NONE ), F_0F38,  1,  no_WDS, 0x09,     0x00,       P_686|P_SSSE3, 0)
insn(PSIGNW, 1,                 OpCls( XMM,      XMM_M128, NONE ), F_660F38,1,  no_WDS, 0x09,     0x00,       P_686|P_SSSE3, 0)
ins(PCLMULQDQ, pclmulqdq,       OpCls( XMM,      XMM_M128, I8_U ), F_660F3A,1,  no_WDS, 0x44,     0x00,       P_686|P_SSSE3, 0)
ins(PCLMULLQLQDQ, pclmullqlqdq, OpCls( XMM,      XMM_M128, HID  ), F_660F3A,1,  no_WDS, 0x44,     0x00,       P_686|P_SSSE3, 0)
ins(PCLMULHQLQDQ, pclmulhqlqdq, OpCls( XMM,      XMM_M128, HID  ), F_660F3A,1,  no_WDS, 0x44,     0x00,       P_686|P_SSSE3, 0)
ins(PCLMULLQHQDQ, pclmullqhqdq, OpCls( XMM,      XMM_M128, HID  ), F_660F3A,1,  no_WDS, 0x44,     0x00,       P_686|P_SSSE3, 0)
ins(PCLMULHQHQDQ, pclmulhqhqdq, OpCls( XMM,      XMM_M128, HID  ), F_660F3A,1,  no_WDS, 0x44,     0x00,       P_686|P_SSSE3, 0)
ins(AESDECLAST, aesdeclast,     OpCls( XMM,      XMM_M128, NONE ), F_660F38,1,  no_WDS, 0xDF,     0x00,       P_686|P_SSSE3, 0)
ins(AESDEC, aesdec,             OpCls( XMM,      XMM_M128, NONE ), F_660F38,1,  no_WDS, 0xDE,     0x00,       P_686|P_SSSE3, 0)
ins(AESENC, aesenc,             OpCls( XMM,      XMM_M128, NONE ), F_660F38,1,  no_WDS, 0xDC,     0x00,       P_686|P_SSSE3, 0)
ins(AESENCLAST, aesenclast,     OpCls( XMM,      XMM_M128, NONE ), F_660F38,1,  no_WDS, 0xDD,     0x00,       P_686|P_SSSE3, 0)
ins(AESIMC, aesimc,             OpCls( XMM,      XMM_M128, NONE ), F_660F38,1,  no_WDS, 0xDB,     0x00,       P_686|P_SSSE3, 0)
ins(AESKEYGENASSIST,aeskeygenassist,OpCls( XMM,  XMM_M128, I8_U ), F_660F3A,1,  no_WDS, 0xDF,     0x00,       P_686|P_SSSE3, 0)
ins (ADCX,    adcx,             OpCls( R32,      R32_M32,  NONE ), F_660F38,1,  no_WDS, 0xF6,     0x00,       P_686|P_SSSE3, 0)
insn(ADCX,    1,                OpCls( R64,      R64_M64,  NONE ), F_660F38,1,  no_WDS, 0xF6,     0x00,       P_686|P_SSSE3, 0)
/* SHA instructons */
ins(SHA1RNDS4, sha1rnds4,       OpCls( XMM,      XMM_M128, I8_U ),  F_0F3A, 1,  no_WDS, 0xCC,     0x00,       P_686|P_SSSE3, 0)
ins(SHA1NEXTE, sha1nexte,       OpCls( XMM,      XMM_M128, NONE  ), F_0F38, 1,  no_WDS, 0xC8,     0x00,       P_686|P_SSSE3, 0)
ins(SHA1MSG1,  sha1msg1,        OpCls( XMM,      XMM_M128, NONE  ), F_0F38, 1,  no_WDS, 0xC9,     0x00,       P_686|P_SSSE3, 0)
ins(SHA1MSG2,  sha1msg2,        OpCls( XMM,      XMM_M128, NONE  ), F_0F38, 1,  no_WDS, 0xCA,     0x00,       P_686|P_SSSE3, 0)
ins(SHA256RNDS2, sha256rnds2,   OpCls( XMM,      XMM_M128, NONE  ), F_0F38, 1,  no_WDS, 0xCB,     0x00,       P_686|P_SSSE3, 0)
ins(SHA256MSG1,  sha256msg1,    OpCls( XMM,      XMM_M128, NONE  ), F_0F38, 1,  no_WDS, 0xCC,     0x00,       P_686|P_SSSE3, 0)
ins(SHA256MSG2,  sha256msg2,    OpCls( XMM,      XMM_M128, NONE  ), F_0F38, 1,  no_WDS, 0xCD,     0x00,       P_686|P_SSSE3, 0)

//SHA1RNDS4 xmm1,xmm2/m128, imm8   NP 0F 3A CC /r ib
//SHA1NEXTE xmm1,xmm2/m128         NP 0F 38 C8 /r
//SHA1MSG1 xmm1,xmm2/m128          NP 0F 38 C9 /r
//SHA1MSG2 xmm1,xmm2/m128          NP 0F 38 CA /r
//SHA256RNDS2 xmm1,xmm2/m128,<XMM0>NP 0F 38 CB /r
//SHA256MSG1 xmm1,xmm2/m128        NP 0F 38 CC /r
//SHA256MSG2 xmm1,xmm2/m128        NP 0F 38 CD /r


#endif
#if AMD64_SUPPORT
/* CDQE must be first in this group, see reswords.c */
insx(CDQE, cdqe,                OpCls( NONE,     NONE,       NONE ), F_48,   0,  no_RM,  0x98,     0x00,       P_64,       0,        RWF_X64)
insx(CQO, cqo,                  OpCls( NONE,     NONE,       NONE ), F_48,   0,  no_RM,  0x99,     0x00,       P_64,       0,        RWF_X64)
insx(PUSHFQ,pushfq,             OpCls( NONE,     NONE,       NONE ), 0,      0,  no_RM,  0x9C,     0x00,       P_64,       0,        RWF_X64)
insx(POPFQ, popfq,              OpCls( NONE,     NONE,       NONE ), 0,      0,  no_RM,  0x9D,     0x00,       P_64,       0,        RWF_X64)
insx(IRETQ, iretq,              OpCls( NONE,     NONE,       NONE ), F_48,   0,  no_RM,  0xCF,     0x00,       P_64,       0,        RWF_X64)
insx(CMPXCHG16B, cmpxchg16b,    OpCls( M128,     NONE,       NONE ), F_480F, 0,  0,      0xC7,     0x08,       P_64,       AP_LOCK,  RWF_X64)
insx(MOVSXD,movsxd,             OpCls( R64,      R32_M32,    NONE ), 0,      1,  0,      0x63,     0x00,       P_64,       0,        RWF_X64)

insx(CMPSQ, cmpsq,              OpCls( NONE,     NONE,       NONE ), F_48,   0,  no_RM,  0xA7,     0x00,       P_64,       AP_REPxx, RWF_X64)
insn(CMPSQ, 1,                  OpCls( M64,      M64,        NONE ), F_48,   0,  no_RM,  0xA7,     0x00,       P_64,       AP_REPxx)
insx(LODSQ, lodsq,              OpCls( NONE,     NONE,       NONE ), F_48,   0,  no_RM,  0xAD,     0x00,       P_64,       AP_REP,   RWF_X64)
insn(LODSQ, 1,                  OpCls( M64,      NONE,       NONE ), F_48,   0,  no_RM,  0xAD,     0x00,       P_64,       AP_REP  )
insx(MOVSQ, movsq,              OpCls( NONE,     NONE,       NONE ), F_48,   0,  no_RM,  0xA5,     0x00,       P_64,       AP_REP,   RWF_X64)
insn(MOVSQ, 1,                  OpCls( M64,      M64,        NONE ), F_48,   0,  no_RM,  0xA5,     0x00,       P_64,       AP_REP  )
insx(SCASQ, scasq,              OpCls( NONE,     NONE,       NONE ), F_48,   0,  no_RM,  0xAF,     0x00,       P_64,       AP_REPxx, RWF_X64)
insn(SCASQ, 1,                  OpCls( M64,      NONE,       NONE ), F_48,   0,  no_RM,  0xAF,     0x00,       P_64,       AP_REPxx)
insx(STOSQ, stosq,              OpCls( NONE,     NONE,       NONE ), F_48,   0,  no_RM,  0xAB,     0x00,       P_64,       AP_REP,   RWF_X64)
insn(STOSQ, 1,                  OpCls( M64,      NONE,       NONE ), F_48,   0,  no_RM,  0xAB,     0x00,       P_64,       AP_REP  )
#if SSE4SUPP
/* PEXTRQ/PINSRQ need a REX.W prefix if M64 is dst/src! */                                                     
//insx(PEXTRQ, pextrq,            OpCls( R64_M64,  XMM,        I8_U ), F_660F3A,0, no_WDS, 0x16,     0x00,       P_64|P_SSE4,0,        RWF_X64)
insx(PINSRQ, pinsrq,            OpCls( XMM,      R64_M64,    I8_U ), F_660F3A,1, no_WDS, 0x22,     0x00,       P_64|P_SSE4,0,        RWF_X64)
#endif
insx(SWAPGS, swapgs,            OpCls( NONE,     NONE,       NONE ), F_0F,   0,  0,      0x01,     0xF8,       P_64,       0,        RWF_X64)
insx(SYSCALL_, syscall,         OpCls( NONE,     NONE,       NONE ), F_0F,   0,  no_RM,  0x05,     0x00,       P_64,       0,        RWF_X64)
insx(SYSRET, sysret,            OpCls( NONE,     NONE,       NONE ), F_0F,   0,  no_RM,  0x07,     0x00,       P_64,       0,        RWF_X64)

/* #if 0 /* v2.09: added, inactive ( not supported by ML64 v8,9,10 ) */
insx(FXRSTOR64, fxrstor64,      OpCls( M_ANY,    NONE,       NONE ), F_480F, 0,  no_WDS, 0xAE,     0x08,       P_64,       0,        RWF_X64)
insx(FXSAVE64, fxsave64,        OpCls( M_ANY,    NONE,       NONE ), F_480F, 0,  no_WDS, 0xAE,     0x00,       P_64,       0,        RWF_X64)
#if SSE4SUPP
insx(XRSTOR64, xrstor64,        OpCls( M_ANY,    NONE,       NONE ), F_480F, 0,  no_WDS, 0xAE,     0x28,       P_64|P_SSE4,0,        RWF_X64)
insx(XSAVE64, xsave64,          OpCls( M_ANY,    NONE,       NONE ), F_480F, 0,  no_WDS, 0xAE,     0x20,       P_64|P_SSE4,0,        RWF_X64)
insx(XSAVEOPT64, xsaveopt64,    OpCls( M_ANY,    NONE,       NONE ), F_480F, 0,  no_WDS, 0xAE,     0x30,       P_64|P_SSE4,0,        RWF_X64)
#endif
/*#endif*/
#endif

#if SSE4SUPP
/* SSE4.1 */
ins (BLENDPD, blendpd,          OpCls( XMM,      XMM_M128, I8_U ), F_660F3A, 1,  no_WDS, 0x0D,     0x00,       P_686|P_SSE4, 0)//NOT AVX512
ins (BLENDPS, blendps,          OpCls( XMM,      XMM_M128, I8_U ), F_660F3A, 1,  no_WDS, 0x0C,     0x00,       P_686|P_SSE4, 0)//NOT AVX512
ins (BLENDVPD, blendvpd,        OpCls( XMM,      XMM_M128, XMM0 ), F_660F38, 1,  no_WDS, 0x15,     0x00,       P_686|P_SSE4, 0)//NOT AVX512
ins (BLENDVPS, blendvps,        OpCls( XMM,      XMM_M128, XMM0 ), F_660F38, 1,  no_WDS, 0x14,     0x00,       P_686|P_SSE4, 0)//NOT AVX512
ins (DPPD, dppd,                OpCls( XMM,      XMM_M128, I8_U ), F_660F3A, 1,  no_WDS, 0x41,     0x00,       P_686|P_SSE4, 0)//NOT AVX512
ins (DPPS, dpps,                OpCls( XMM,      XMM_M128, I8_U ), F_660F3A, 1,  no_WDS, 0x40,     0x00,       P_686|P_SSE4, 0)//NOT AVX512
ins (EXTRACTPS, extractps,      OpCls( RGT16,    XMM,      I8_U ), F_660F3A, 0,  no_WDS, 0x17,     0x00,       P_686|P_SSE4, DSIZE|T1S)
insn(EXTRACTPS, 1,              OpCls( M32,      XMM,      I8_U ), F_660F3A, 0,  no_WDS, 0x17,     0x00,       P_686|P_SSE4, DSIZE|T1S)
ins (INSERTPS, insertps,        OpCls( XMM,      XMM_M32,  I8_U ), F_660F3A, 1,  no_WDS, 0x21,     0x00,       P_686|P_SSE4, DSIZE|T1S)
ins (MOVNTDQA, movntdqa,        OpCls( XMM,      M128,     NONE ), F_660F38, 1,  no_WDS, 0x2A,     0x00,       P_686|P_SSE4, FVM)
ins (MPSADBW, mpsadbw,          OpCls( XMM,      XMM_M128, I8_U ), F_660F3A, 1,  no_WDS, 0x42,     0x00,       P_686|P_SSE4, 0)//NOT AVX512
ins (PACKUSDW, packusdw,        OpCls( XMM,      XMM_M128, NONE ), F_660F38, 1,  no_WDS, 0x2B,     0x00,       P_686|P_SSE4, DSIZE|FV)
ins (PBLENDVB, pblendvb,        OpCls( XMM,      XMM_M128, XMM0 ), F_660F38, 1,  no_WDS, 0x10,     0x00,       P_686|P_SSE4, 0)//NOT AVX512
ins (PBLENDW, pblendw,          OpCls( XMM,      XMM_M128, I8_U ), F_660F3A, 1,  no_WDS, 0x0E,     0x00,       P_686|P_SSE4, 0)//NOT AVX512
ins (PCMPEQQ, pcmpeqq,          OpCls( XMM,      XMM_M128, NONE ), F_660F38, 1,  no_WDS, 0x29,     0x00,       P_686|P_SSE4, W1|QSIZE|FV)
ins (PEXTRB, pextrb,            OpCls( RGT16_M08,XMM,      I8_U ), F_660F3A, 0,  no_WDS, 0x14,     0x00,       P_686|P_SSE4, BSIZE|T1S)
ins (PEXTRD, pextrd,            OpCls( R32_M32,  XMM,      I8_U ), F_660F3A, 0,  no_WDS, 0x16,     0x00,       P_686|P_SSE4, DSIZE|T1S)
ins (PHMINPOSUW, phminposuw,    OpCls( XMM,      XMM_M128, NONE ), F_660F38, 1,  no_WDS, 0x41,     0x00,       P_686|P_SSE4, 0)//NOT AVX512
ins (PINSRB, pinsrb,            OpCls( XMM,      R32_M08,  I8_U ), F_660F3A, 1,  no_WDS, 0x20,     0x00,       P_686|P_SSE4, BSIZE|T1S)
ins (PINSRD, pinsrd,            OpCls( XMM,      R32_M32,  I8_U ), F_660F3A, 1,  no_WDS, 0x22,     0x00,       P_686|P_SSE4, DSIZE|T1S)
ins (PMAXSB, pmaxsb,            OpCls( XMM,      XMM_M128, NONE ), F_660F38, 1,  no_WDS, 0x3C,     0x00,       P_686|P_SSE4, BSIZE|FVM)
ins (PMAXSD, pmaxsd,            OpCls( XMM,      XMM_M128, NONE ), F_660F38, 1,  no_WDS, 0x3D,     0x00,       P_686|P_SSE4, DSIZE|FV)
ins (PMAXUW, pmaxuw,            OpCls( XMM,      XMM_M128, NONE ), F_660F38, 1,  no_WDS, 0x3E,     0x00,       P_686|P_SSE4, WSIZE|FVM)
ins (PMAXUD, pmaxud,            OpCls( XMM,      XMM_M128, NONE ), F_660F38, 1,  no_WDS, 0x3F,     0x00,       P_686|P_SSE4, DSIZE|FV)
ins (PMINSB, pminsb,            OpCls( XMM,      XMM_M128, NONE ), F_660F38, 1,  no_WDS, 0x38,     0x00,       P_686|P_SSE4, BSIZE|FVM)
ins (PMINSD, pminsd,            OpCls( XMM,      XMM_M128, NONE ), F_660F38, 1,  no_WDS, 0x39,     0x00,       P_686|P_SSE4, DSIZE|FV)
ins (PMINUW, pminuw,            OpCls( XMM,      XMM_M128, NONE ), F_660F38, 1,  no_WDS, 0x3A,     0x00,       P_686|P_SSE4, WSIZE|FVM)
ins (PMINUD, pminud,            OpCls( XMM,      XMM_M128, NONE ), F_660F38, 1,  no_WDS, 0x3B,     0x00,       P_686|P_SSE4, DSIZE|FV)
ins (PMOVSXBW, pmovsxbw,        OpCls( XMM,      XMM_M64,  NONE ), F_660F38, 1,  no_WDS, 0x20,     0x00,       P_686|P_SSE4, BSIZE|HVM)
insn(PMOVSXBW,        1,        OpCls( YMM,      XMM_M128, NONE ), F_660F38, 1,  no_WDS, 0x20,     0x00,       P_686|P_SSE4, BSIZE|HVM)
ins (PMOVSXBD, pmovsxbd,        OpCls( XMM,      XMM_M32,  NONE ), F_660F38, 1,  no_WDS, 0x21,     0x00,       P_686|P_SSE4, BSIZE|QVM)
insn (PMOVSXBD, 1,              OpCls( YMM,      XMM_M64,  NONE ), F_660F38, 1,  no_WDS, 0x21,     0x00,       P_686|P_SSE4, BSIZE|QVM)
ins (PMOVSXBQ, pmovsxbq,        OpCls( XMM,      XMM_M16,  NONE ), F_660F38, 1,  no_WDS, 0x22,     0x00,       P_686|P_SSE4, BSIZE|OVM)
insn (PMOVSXBQ, 1,              OpCls( YMM,      XMM_M32,  NONE ), F_660F38, 1,  no_WDS, 0x22,     0x00,       P_686|P_SSE4, BSIZE|OVM)
ins (PMOVSXWD, pmovsxwd,        OpCls( XMM,      XMM_M64,  NONE ), F_660F38, 1,  no_WDS, 0x23,     0x00,       P_686|P_SSE4, WSIZE|HVM)
insn (PMOVSXWD, 1,              OpCls( YMM,      XMM_M128, NONE ), F_660F38, 1,  no_WDS, 0x23,     0x00,       P_686|P_SSE4, WSIZE|HVM)
ins (PMOVSXWQ, pmovsxwq,        OpCls( XMM,      XMM_M32,  NONE ), F_660F38, 1,  no_WDS, 0x24,     0x00,       P_686|P_SSE4, WSIZE|QVM)
insn (PMOVSXWQ, 1,              OpCls( YMM,      XMM_M64,  NONE ), F_660F38, 1,  no_WDS, 0x24,     0x00,       P_686|P_SSE4, WSIZE|QVM)
ins (PMOVSXDQ, pmovsxdq,        OpCls( XMM,      XMM_M64,  NONE ), F_660F38, 1,  no_WDS, 0x25,     0x00,       P_686|P_SSE4, DSIZE|HVM)
insn (PMOVSXDQ, 1,              OpCls( YMM,      XMM_M128, NONE ), F_660F38, 1,  no_WDS, 0x25,     0x00,       P_686|P_SSE4, DSIZE|HVM)
ins (PMOVZXBW, pmovzxbw,        OpCls( XMM,      XMM_M64,  NONE ), F_660F38, 1,  no_WDS, 0x30,     0x00,       P_686|P_SSE4, BSIZE|HVM)
insn (PMOVZXBW, 1,              OpCls( YMM,      XMM_M128, NONE ), F_660F38, 1,  no_WDS, 0x30,     0x00,       P_686|P_SSE4, BSIZE|HVM)
ins (PMOVZXBD, pmovzxbd,        OpCls( XMM,      XMM_M32,  NONE ), F_660F38, 1,  no_WDS, 0x31,     0x00,       P_686|P_SSE4, BSIZE|QVM)
insn (PMOVZXBD, 1,              OpCls( YMM,      XMM_M64,  NONE ), F_660F38, 1,  no_WDS, 0x31,     0x00,       P_686|P_SSE4, BSIZE|QVM)
ins (PMOVZXBQ, pmovzxbq,        OpCls( XMM,      XMM_M16,  NONE ), F_660F38, 1,  no_WDS, 0x32,     0x00,       P_686|P_SSE4, BSIZE|OVM)
insn (PMOVZXBQ, 1,              OpCls( YMM,      XMM_M32,  NONE ), F_660F38, 1,  no_WDS, 0x32,     0x00,       P_686|P_SSE4, BSIZE|OVM)
ins (PMOVZXWD, pmovzxwd,        OpCls( XMM,      XMM_M64,  NONE ), F_660F38, 1,  no_WDS, 0x33,     0x00,       P_686|P_SSE4, WSIZE|HVM)
insn (PMOVZXWD, 1,              OpCls( YMM,      XMM_M128, NONE ), F_660F38, 1,  no_WDS, 0x33,     0x00,       P_686|P_SSE4, WSIZE|HVM)
ins (PMOVZXWQ, pmovzxwq,        OpCls( XMM,      XMM_M32,  NONE ), F_660F38, 1,  no_WDS, 0x34,     0x00,       P_686|P_SSE4, WSIZE|QVM)
insn (PMOVZXWQ, 1,              OpCls( YMM,      XMM_M64,  NONE ), F_660F38, 1,  no_WDS, 0x34,     0x00,       P_686|P_SSE4, WSIZE|QVM)
ins (PMOVZXDQ, pmovzxdq,        OpCls( XMM,      XMM_M64,  NONE ), F_660F38, 1,  no_WDS, 0x35,     0x00,       P_686|P_SSE4, DSIZE|HVM)
insn (PMOVZXDQ, 1,              OpCls( YMM,      XMM_M128, NONE ), F_660F38, 1,  no_WDS, 0x35,     0x00,       P_686|P_SSE4, DSIZE|HVM)
ins (PMULDQ, pmuldq,            OpCls( XMM,      XMM_M128, NONE ), F_660F38, 1,  no_WDS, 0x28,     0x00,       P_686|P_SSE4, W1|QSIZE|FV)
ins (PMULLD, pmulld,            OpCls( XMM,      XMM_M128, NONE ), F_660F38, 1,  no_WDS, 0x40,     0x00,       P_686|P_SSE4, DSIZE|FV)
ins (PTEST, ptest,              OpCls( XMM,      XMM_M128, NONE ), F_660F38, 1,  no_WDS, 0x17,     0x00,       P_686|P_SSE4, 0)
ins (ROUNDPS, roundps,          OpCls( XMM,      XMM_M128, I8_U ), F_660F3A, 1,  no_WDS, 0x08,     0x00,       P_686|P_SSE4, 0)
ins (ROUNDPD, roundpd,          OpCls( XMM,      XMM_M128, I8_U ), F_660F3A, 1,  no_WDS, 0x09,     0x00,       P_686|P_SSE4, 0)
ins (ROUNDSS, roundss,          OpCls( XMM,      XMM_M32 , I8_U ), F_660F3A, 1,  no_WDS, 0x0A,     0x00,       P_686|P_SSE4, 0)
ins (ROUNDSD, roundsd,          OpCls( XMM,      XMM_M64 , I8_U ), F_660F3A, 1,  no_WDS, 0x0B,     0x00,       P_686|P_SSE4, 0)

/* SSE4.2 */
ins (CRC32, crc32,              OpCls( RGT16,    R8_M08,   NONE ), F_F20F38, 1,  no_WDS, 0xF0,     0x00,       P_686|P_SSE4, 0)
insn(CRC32, 1,                  OpCls( RGT16,    RGT8_MS,  NONE ), F_F20F38, 1,  no_WDS, 0xF1,     0x00,       P_686|P_SSE4, 0)
ins (PCMPESTRM, pcmpestrm,      OpCls( XMM,      XMM_M128, I8_U ), F_660F3A, 1,  no_WDS, 0x60,     0x00,       P_686|P_SSE4, 0)
ins (PCMPESTRI, pcmpestri,      OpCls( XMM,      XMM_M128, I8_U ), F_660F3A, 1,  no_WDS, 0x61,     0x00,       P_686|P_SSE4, 0)
ins (PCMPISTRM, pcmpistrm,      OpCls( XMM,      XMM_M128, I8_U ), F_660F3A, 1,  no_WDS, 0x62,     0x00,       P_686|P_SSE4, 0)
ins (PCMPISTRI, pcmpistri,      OpCls( XMM,      XMM_M128, I8_U ), F_660F3A, 1,  no_WDS, 0x63,     0x00,       P_686|P_SSE4, 0)
ins (PCMPGTQ, pcmpgtq,          OpCls( XMM,      XMM_M128, NONE ), F_660F38, 1,  no_WDS, 0x37,     0x00,       P_686|P_SSE4, W1|QSIZE|FV)
ins (POPCNT, popcnt,            OpCls( RGT8,     RGT8_MS,  NONE ), F_F30F,   1,  no_WDS ,0xB8,     0x00,       P_686|P_SSE4, 0)
ins (RDRAND, rdrand,            OpCls( R,        NONE,     NONE ), F_0F,     0,  no_WDS, 0xC7,     0x30,       P_686|P_SSE4, 0)
ins (RDSEED, rdseed,            OpCls( R,        NONE,     NONE ), F_0F,     0,  no_WDS, 0xC7,     0x38,       P_686|P_SSE4, 0)
ins (LZCNT, lzcnt,              OpCls( RGT8,     RGT8_MS,  NONE ), F_F30F,   1,  no_WDS ,0xBD,     0x00,       P_686|P_SSE4, 0)
ins (TZCNT, tzcnt,              OpCls( RGT8,     RGT8_MS,  NONE ), F_F30F,   1,  no_WDS ,0xBC,     0x00,       P_686|P_SSE4, 0)
ins(INVPCID, invpcid,           OpCls( RGT8,     MS,       NONE ), F_660F38, 1,  no_WDS, 0x82,     0x00,       P_686|P_SSE4, 0)
ins(BNDMK, bndmk,               OpCls( BND,      MS,       NONE ), F_F30F,   1,  no_WDS, 0x1B,     0x00,       P_686|P_SSE4, 0)
ins(BNDCL, bndcl,               OpCls( BND,      R_MS,     NONE ), F_F30F,   1,  no_WDS, 0x1A,     0x00,       P_686|P_SSE4, 0)
ins(BNDCU, bndcu,               OpCls( BND,      R_MS,     NONE ), F_F20F,   1,  no_WDS, 0x1A,     0x00,       P_686|P_SSE4, 0)
ins(BNDCN, bndcn,               OpCls( BND,      R_MS,     NONE ), F_F20F,   1,  no_WDS, 0x1B,     0x00,       P_686|P_SSE4, 0)
ins(BNDMOV, bndmov,             OpCls( BND,      BND_MS,   NONE ), F_660F,   1,  no_WDS, 0x1A,     0x00,       P_686|P_SSE4, 0)
insn(BNDMOV, 1,                 OpCls( BND,      BND_M128, NONE ), F_660F,   1,  no_WDS, 0x1A,     0x00,       P_686|P_SSE4, 0)
insn(BNDMOV, 2,                 OpCls( BND_MS,   BND,      NONE ), F_660F,   0,  no_WDS, 0x1B,     0x00,       P_686|P_SSE4, 0)
insn(BNDMOV, 3,                 OpCls( BND_M128, BND,      NONE ), F_660F,   0,  no_WDS, 0x1B,     0x00,       P_686|P_SSE4, 0)
ins(BNDLDX, bndldx,             OpCls( BND,      MS,       NONE ), F_0F,     1,  no_WDS, 0x1A,     0x00,       P_686|P_SSE4, 0)
ins(BNDSTX, bndstx,             OpCls( MS,       BND,      NONE ), F_0F,     0,  no_WDS, 0x1B,     0x00,       P_686|P_SSE4, 0)
ins(RDPID, rdpid,               OpCls( R32,      NONE,     NONE ), F_F30F,   0,  0,      0xC7,     0x00,       P_686       , 0)
insn(RDPID, 1,                  OpCls( R64,      NONE,     NONE ), F_F30F,   0,  0,      0xC7,     0x00,       P_686       , 0)
ins(ADOX,   adox,               OpCls( R32,      R32,      NONE ), F_F30F,   1,  0,      0x38,     0x00,       P_686       , 0)
insn(ADOX,  1,                  OpCls( R64,      R64,      NONE ), F_F30F,   1,  0,      0x38,     0x00,       P_64        , 0)
insn(ADOX,  2,                  OpCls( R32,      M32,      NONE ), F_F30F,   1,  0,      0x38,     0x00,       P_686       , 0)
insn(ADOX,  3,                  OpCls( R64,      M64,      NONE ), F_F30F,   1,  0,      0x38,     0x00,       P_64        , 0)
insn(ADOX,  4,                  OpCls( R32,      M64,      NONE ), F_F30F,   1,  0,      0x38,     0x00,       P_64        , 0)
#if 0
/* SSE4A (AMD only). */
/* disabled because INSERTQ needs 4 arguments, which Uasm cannot support currently */
ins (EXTRQ, extrq,              OpCls( XMM,      I8_U,     I8_U ), F_660F, 0,  no_WDS ,0x78,     0x00,       P_686|P_SSE4, 0)
ins (INSERTQ, insertq,          OpCls( XMM,      XMM,      I8_U ), F_F20F, 0,  no_WDS ,0x78,     0x00,       P_686|P_SSE4, 0)
ins (LZCNT, lzcnt,              OpCls( RGT8,     RGT8_MS,  NONE ), F_F30F, 1,  no_WDS ,0xBD,     0x00,       P_686|P_SSE4, 0)
ins (MOVNTSD, movntsd,          OpCls( M64,      XMM,      NONE ), F_F20F, 0,  no_WDS ,0x2B,     0x00,       P_686|P_SSE4, 0)
ins (MOVNTSS, movntss,          OpCls( M32,      XMM,      NONE ), F_F30F, 0,  no_WDS ,0x2B,     0x00,       P_686|P_SSE4, 0)
#endif
/* v2.06: added xrstor, xsave, xgetbv, xsetbv */
ins (XRSTOR, xrstor,            OpCls( M_ANY,    NONE,       NONE ), F_0F,   0,  no_WDS, 0xAE,     0x28,     P_686|P_SSE4,0)
ins (XSAVE, xsave,              OpCls( M_ANY,    NONE,       NONE ), F_0F,   0,  no_WDS, 0xAE,     0x20,     P_686|P_SSE4,0)
ins (XSAVEOPT, xsaveopt,        OpCls( M_ANY,    NONE,       NONE ), F_0F,   0,  no_WDS, 0xAE,     0x30,     P_686|P_SSE4,0)
ins (XGETBV, xgetbv,            OpCls( NONE,     NONE,       NONE ), F_0F,   0,  no_WDS, 0x01,     0xD0,     P_686|P_SSE4,0)
ins (XSETBV, xsetbv,            OpCls( NONE,     NONE,       NONE ), F_0F,   0,  no_WDS, 0x01,     0xD1,     P_686p|P_SSE4,0)
#endif
#if VMXSUPP
/* v2.09: added */
ins (VMCALL,  vmcall,           OpCls( NONE,     NONE,       NONE ), F_0F,   0,  0,      0x01,     0xC1,     P_686, 0)
ins (VMLAUNCH,vmlaunch,         OpCls( NONE,     NONE,       NONE ), F_0F,   0,  0,      0x01,     0xC2,     P_686p,0)
ins (VMRESUME,vmresume,         OpCls( NONE,     NONE,       NONE ), F_0F,   0,  0,      0x01,     0xC3,     P_686p,0)
ins (VMXOFF,  vmxoff,           OpCls( NONE,     NONE,       NONE ), F_0F,   0,  0,      0x01,     0xC4,     P_686p,0)
ins (VMPTRLD, vmptrld,          OpCls( M64,      NONE,       NONE ), F_0F,   0,  no_WDS, 0xC7,     0x30,     P_686p,0)
ins (VMPTRST, vmptrst,          OpCls( M64,      NONE,       NONE ), F_0F,   0,  no_WDS, 0xC7,     0x38,     P_686p,0)
ins (VMCLEAR, vmclear,          OpCls( M64,      NONE,       NONE ), F_660F, 0,  no_WDS, 0xC7,     0x30,     P_686p,0)
ins (VMXON,   vmxon,            OpCls( M64,      NONE,       NONE ), F_F30F, 0,  no_WDS, 0xC7,     0x30,     P_686p,0)
ins (VMREAD,  vmread,           OpCls( R32_M32,  R32,        NONE ), F_0F,   0,  no_WDS, 0x78,     0x00,     P_686p,0)
ins (VMWRITE, vmwrite,          OpCls( R32,      R32_M32,    NONE ), F_0F,   1,  no_WDS, 0x79,     0x00,     P_686p,0)
ins (INVEPT,  invept,           OpCls( RGT16,    M128,       NONE ), F_660F38,1, no_WDS, 0x80,     0x00,     P_686p,0)
ins (INVVPID, invvpid,          OpCls( RGT16,    M128,       NONE ), F_660F38,1, no_WDS, 0x81,     0x00,     P_686p,0)
//ins (ADCX,    adcx,             OpCls( R32,      R32_M32,    NONE ), F_660F38,1, no_WDS, 0xF6,     0x00,     P_686p,0)
//insn(ADCX,    1,                OpCls( R64,      R64_M64,    NONE ), F_660F38,1, 0,      0xF6,     0x00,     P_686p,0)
#endif
#if SVMSUPP
/* v2.09: added, but inactive */
ins (VMRUN,   vmrun,            OpCls( A,        NONE,       NONE ), F_0F,   0,  no_WDS, 0x01,     0xD8,     P_686p,0)
ins (VMMCALL, vmmcall,          OpCls( NONE,     NONE,       NONE ), F_0F,   0,  0,      0x01,     0xD9,     P_686, 0)
ins (VMLOAD,  vmload,           OpCls( A,        NONE,       NONE ), F_0F,   0,  no_WDS, 0x01,     0xDA,     P_686p,0)
ins (VMSAVE,  vmsave,           OpCls( A,        NONE,       NONE ), F_0F,   0,  no_WDS, 0x01,     0xDB,     P_686p,0)
ins (STGI,    stgi,             OpCls( NONE,     NONE,       NONE ), F_0F,   0,  0,      0x01,     0xDC,     P_686p,0)
ins (CLGI,    clgi,             OpCls( NONE,     NONE,       NONE ), F_0F,   0,  0,      0x01,     0xDD,     P_686p,0)
ins (SKINIT,  skinit,           OpCls( A,        NONE,       NONE ), F_0F,   0,  no_WDS, 0x01,     0xDE,     P_686p,0)
ins (INVLPGA, invlpga,          OpCls( A,        R32,        NONE ), F_0F,   0,  no_WDS, 0x01,     0xDF,     P_686p,0)
#endif
#if AVXSUPP
/* VBROADCASTSS is first VEX encoded instruction (VEX_START in parser.h).
 * Important: currently vex_flags[] in reswords.c must match the order here!
 * (this is to be improved).
 * Most AVX instructions that also have a "legacy" encoding are not listed
 * here but are contained in instravx.h!. Exceptions:
 * - VBLENDVPD, VBLENDVPS, VPBLENDVB ( they use a different opcode in VEX )
 * - VCVT[T]PD* ( they expect a mix of xmm and ymm/m256 arguments )
 */


//   token,          string,                         opcls,               byte1_info,op_dir, rm_info,opcode,rm_byte,     cpu,        prefix,flgs ) T_ ## token ,
insx(VBROADCASTSS, vbroadcastss,       OpCls( XMM,      XMM_M32,    NONE ), F_660F38,1,  no_WDS, 0x18,     0x00,     P_686|P_AVX, DSIZE|T1S, RWF_VEX )
insn(VBROADCASTSS, 1,                  OpCls( YMM,      XMM_M32,    NONE ), F_660F38,1,  no_WDS, 0x18,     0x00,     P_686|P_AVX, DSIZE|T1S)
insn(VBROADCASTSS, 2,                  OpCls( ZMM,      XMM_M32,    NONE ), F_660F38,1,  no_WDS, 0x18,     0x00,     P_686|P_AVX, DSIZE|T1S)
insx(VBROADCASTSD, vbroadcastsd,       OpCls( YMM,      XMM_M64,    NONE ), F_660F38,1,  no_WDS, 0x19,     0x00,     P_686|P_AVX, QSIZE|T1S, RWF_VEX )
insn(VBROADCASTSD, 1,                  OpCls( ZMM,      XMM_M64,    NONE ), F_660F38,1,  no_WDS, 0x19,     0x00,     P_686|P_AVX, W1|QSIZE|T1S)
insx(VBROADCASTF128, vbroadcastf128,   OpCls( YMM,      M128,       NONE ), F_660F38,1,  no_WDS, 0x1A,     0x00,     P_686|P_AVX, 0, RWF_VEX )
insx(VBROADCASTI128, vbroadcasti128,   OpCls( YMM,      M128,       NONE ), F_660F38,1,  no_WDS, 0x5A,     0x00,     P_686|P_AVX, 0, RWF_VEX )
insx(VPBROADCASTB, vpbroadcastb,       OpCls( XMM,      R8,         NONE ), F_660F38,1,  no_WDS, 0x7A,     0x00,     P_686|P_AVX ,IZSZ|BSIZE|T1S,RWF_EVEX|RWF_VEX )
insn(VPBROADCASTB, 1,                  OpCls( XMM,      XMM_M08,    NONE ), F_660F38,1,  no_WDS, 0x78,     0x00,     P_686|P_AVX ,BSIZE|T1S)
insx(VPBROADCASTW, vpbroadcastw,       OpCls( XMM,      R16,        NONE ), F_660F38,1,  no_WDS, 0x7B,     0x00,     P_686|P_AVX ,IZSZ|WSIZE|T1S, RWF_EVEX|RWF_VEX )
insn(VPBROADCASTW, 1,                  OpCls( XMM,      XMM_M16,    NONE ), F_660F38,1,  no_WDS, 0x79,     0x00,     P_686|P_AVX ,WSIZE|T1S)
insx(VPBROADCASTD, vpbroadcastd,       OpCls( XMM,      R32,        NONE ), F_660F38,1,  no_WDS, 0x7C,     0x00,     P_686|P_AVX ,DSIZE|T1S, RWF_EVEX|RWF_VEX )
insn(VPBROADCASTD, 1,                  OpCls( XMM,      XMM_M32,    NONE ), F_660F38,1,  no_WDS, 0x58,     0x00,     P_686|P_AVX ,DSIZE|T1S)
insx(VPBROADCASTQ, vpbroadcastq,       OpCls( XMM,      R64,        NONE ), F_660F38,1,  no_WDS, 0x7C,     0x00,     P_686|P_AVX ,QSIZE|T1S, RWF_EVEX|RWF_VEX )
insn(VPBROADCASTQ, 1,                  OpCls( XMM,      XMM_M64,    NONE ), F_660F38,1,  no_WDS, 0x59,     0x00,     P_686|P_AVX ,QSIZE|T1S)
insx(VBROADCASTI32x2, vbroadcasti32x2, OpCls( XMM,      XMM_M64,    NONE ), F_660F38,1,  no_WDS, 0x59,     0x00,     P_686|P_AVX ,IZSZ|QSIZE|T2, RWF_VEX )
insn(VBROADCASTI32x2, 1,               OpCls( YMM,      XMM_M64,    NONE ), F_660F38,1,  no_WDS, 0x59,     0x00,     P_686|P_AVX ,IZSZ|QSIZE|T2)
insn(VBROADCASTI32x2, 2,               OpCls( ZMM,      XMM_M64,    NONE ), F_660F38,1,  no_WDS, 0x59,     0x00,     P_686|P_AVX ,IZSZ|QSIZE|T2)
insx(VBROADCASTF32x2, vbroadcastf32x2, OpCls( YMM,      XMM_M64,    NONE ), F_660F38,1,  no_WDS, 0x19,     0x00,     P_686|P_AVX ,IZSZ|QSIZE|T2, RWF_EVEX|RWF_VEX )
insn(VBROADCASTF32x2, 1,               OpCls( ZMM,      XMM_M64,    NONE ), F_660F38,1,  no_WDS, 0x19,     0x00,     P_686|P_AVX ,IZSZ|QSIZE|T2)
insx(VBROADCASTI32x4, vbroadcasti32x4, OpCls( YMM,      M128,       NONE ), F_660F38,1,  no_WDS, 0x5A,     0x00,     P_686|P_AVX ,IZSZ|DSIZE|T4, RWF_EVEX|RWF_VEX )
insn(VBROADCASTI32x4, 1,               OpCls( ZMM,      M128,       NONE ), F_660F38,1,  no_WDS, 0x5A,     0x00,     P_686|P_AVX ,IZSZ|DSIZE|T4 )
insx(VBROADCASTI64x2, vbroadcasti64x2, OpCls( YMM,      M128,       NONE ), F_660F38,1,  no_WDS, 0x5A,     0x00,     P_686|P_AVX ,W1|IZSZ|QSIZE|T8, RWF_EVEX|RWF_VEX )
insn(VBROADCASTI64x2, 1,               OpCls( ZMM,      M128,       NONE ), F_660F38,1,  no_WDS, 0x5A,     0x00,     P_686|P_AVX ,W1|IZSZ|QSIZE|T8)
insx(VBROADCASTI32x8, vbroadcasti32x8, OpCls( ZMM,      M256,       NONE ), F_660F38,1,  no_WDS, 0x5B,     0x00,     P_686|P_AVX ,IZSZ|DSIZE|T2, RWF_EVEX|RWF_VEX )
insx(VBROADCASTI64x4, vbroadcasti64x4, OpCls( ZMM,      M256,       NONE ), F_660F38,1,  no_WDS, 0x5B,     0x00,     P_686|P_AVX ,W1|IZSZ|QSIZE|T4, RWF_EVEX|RWF_VEX )
insx(VBROADCASTF32x4, vbroadcastf32x4, OpCls( YMM,      M128,       NONE ), F_660F38,1,  no_WDS, 0x1A,     0x00,     P_686|P_AVX ,IZSZ|DSIZE|T4, RWF_EVEX|RWF_VEX )
insn(VBROADCASTF32x4, 1,               OpCls( ZMM,      M128,       NONE ), F_660F38,1,  no_WDS, 0x1A,     0x00,     P_686|P_AVX ,IZSZ|DSIZE|T4 )
insx(VBROADCASTF64x2, vbroadcastf64x2, OpCls( YMM,      M128,       NONE ), F_660F38,1,  no_WDS, 0x1A,     0x00,     P_686|P_AVX ,W1|IZSZ|QSIZE|T2, RWF_EVEX|RWF_VEX )
insn(VBROADCASTF64x2, 1,               OpCls( ZMM,      M128,       NONE ), F_660F38,1,  no_WDS, 0x1A,     0x00,     P_686|P_AVX ,W1|IZSZ|QSIZE|T2)
insx(VBROADCASTF32x8, vbroadcastf32x8, OpCls( ZMM,      M256,       NONE ), F_660F38,1,  no_WDS, 0x1B,     0x00,     P_686|P_AVX ,IZSZ|DSIZE|T8, RWF_EVEX|RWF_VEX )
insx(VBROADCASTF64x4, vbroadcastf64x4, OpCls( ZMM,      M256,       NONE ), F_660F38,1,  no_WDS, 0x1B,     0x00,     P_686|P_AVX ,W1|IZSZ|QSIZE|T4, RWF_EVEX|RWF_VEX )
//VPBROADCASTMB2Q xmm1, k1  EVEX.128.F3.0F38.W1 2A /r RM
//VPBROADCASTMW2D xmm1, k1  EVEX.128.F3.0F38.W0 3A /r RM
insx(VPBROADCASTMB2Q, vpbroadcastmb2q, OpCls( XMM,      R8,         NONE ), F_F30F38,1,  no_WDS, 0x2A,     0x00,     P_686|P_AVX ,W1|IZSZ|BSIZE,RWF_EVEX|RWF_VEX )
insx(VPBROADCASTMW2D, vpbroadcastmw2d, OpCls( XMM,      R16,        NONE ), F_F30F38,1,  no_WDS, 0x3A,     0x00,     P_686|P_AVX ,IZSZ|WSIZE,RWF_EVEX|RWF_VEX )
insx(VBLENDVPD, vblendvpd,             OpCls( XMM,      XMM_M128,   XMM  ), F_660F3A,1,  no_WDS, 0x4B,     0x00,     P_686|P_AVX, 0, RWF_VEX )
insx(VBLENDVPS, vblendvps,             OpCls( XMM,      XMM_M128,   XMM  ), F_660F3A,1,  no_WDS, 0x4A,     0x00,     P_686|P_AVX, 0, RWF_VEX )
insx(VEXTRACTF128, vextractf128,       OpCls( XMM_M128, YMM,        I8_U ), F_660F3A,0,  no_WDS, 0x19,     0x00,     P_686|P_AVX, 0, RWF_VEX )
//VEXTRACTF32x4,VEXTRACTF64x2,VEXTRACTF32x8,VEXTRACTF64x4,VEXTRACTI32x4,VEXTRACTI64x2,VEXTRACTI32x8,VEXTRACTI64x4
insx(VEXTRACTF32x4, vextractf32x4,     OpCls( XMM,      YMM,        I8_U ), F_660F3A,0,  no_WDS, 0x19,     0x00,     P_686|P_AVX, IZSZ|DSIZE|T4, RWF_EVEX|RWF_VEX )
insn(VEXTRACTF32x4, 1,                 OpCls( M128,     YMM,        I8_U ), F_660F3A,0,  no_WDS, 0x19,     0x00,     P_686|P_AVX, IZSZ|DSIZE|T4)
insn(VEXTRACTF32x4, 2,                 OpCls( XMM,      ZMM,        I8_U ), F_660F3A,0,  no_WDS, 0x19,     0x00,     P_686|P_AVX, IZSZ|DSIZE|T4)
insn(VEXTRACTF32x4, 3,                 OpCls( M128,     ZMM,        I8_U ), F_660F3A,0,  no_WDS, 0x19,     0x00,     P_686|P_AVX, IZSZ|DSIZE|T4)

insx(VEXTRACTF64x2, vextractf64x2,     OpCls( XMM,      YMM,        I8_U ), F_660F3A,0,  no_WDS, 0x19,     0x00,     P_686|P_AVX, W1|IZSZ|QSIZE|T2, RWF_EVEX|RWF_VEX )
insn(VEXTRACTF64x2, 1,                 OpCls( M128,     YMM,        I8_U ), F_660F3A,0,  no_WDS, 0x19,     0x00,     P_686|P_AVX, W1|IZSZ|QSIZE|T2)
insn(VEXTRACTF64x2, 2,                 OpCls( XMM,      ZMM,        I8_U ), F_660F3A,0,  no_WDS, 0x19,     0x00,     P_686|P_AVX, W1|IZSZ|QSIZE|T2)
insn(VEXTRACTF64x2, 3,                 OpCls( M128,     ZMM,        I8_U ), F_660F3A,0,  no_WDS, 0x19,     0x00,     P_686|P_AVX, W1|IZSZ|QSIZE|T2)

insx(VEXTRACTF32x8, vextractf32x8,     OpCls( YMM,      ZMM,        I8_U ), F_660F3A,0,  no_WDS, 0x1B,     0x00,     P_686|P_AVX, IZSZ|DSIZE|T8, RWF_EVEX|RWF_VEX )
insn(VEXTRACTF32x8, 1,                 OpCls( M256,     ZMM,        I8_U ), F_660F3A,0,  no_WDS, 0x1B,     0x00,     P_686|P_AVX, IZSZ|DSIZE|T8)

insx(VEXTRACTF64x4, vextractf64x4,     OpCls( YMM,      ZMM,        I8_U ), F_660F3A,0,  no_WDS, 0x1B,     0x00,     P_686|P_AVX, W1|IZSZ|QSIZE|T4, RWF_EVEX|RWF_VEX )
insn(VEXTRACTF64x4, 1,                 OpCls( M256,     ZMM,        I8_U ), F_660F3A,0,  no_WDS, 0x1B,     0x00,     P_686|P_AVX, W1|IZSZ|QSIZE|T4)

insx(VEXTRACTI128, vextracti128,       OpCls( XMM,      YMM,        I8_U ), F_660F3A,0,  no_WDS, 0x39,     0x00,     P_686|P_AVX, 0, RWF_EVEX|RWF_VEX )
insn(VEXTRACTI128, 1,                  OpCls( M128,     YMM,        I8_U ), F_660F3A,0,  no_WDS, 0x39,     0x00,     P_686|P_AVX, 0)
insx(VEXTRACTI32x4, vextracti32x4,     OpCls( XMM,      YMM,        I8_U ), F_660F3A,0,  no_WDS, 0x39,     0x00,     P_686|P_AVX, IZSZ|DSIZE|T4, RWF_EVEX|RWF_VEX )
insn(VEXTRACTI32x4, 1,                 OpCls( M128,     YMM,        I8_U ), F_660F3A,0,  no_WDS, 0x39,     0x00,     P_686|P_AVX, IZSZ|DSIZE|T4)
insn(VEXTRACTI32x4, 2,                 OpCls( XMM,      ZMM,        I8_U ), F_660F3A,0,  no_WDS, 0x39,     0x00,     P_686|P_AVX, IZSZ|DSIZE|T4)
insn(VEXTRACTI32x4, 3,                 OpCls( M128,     ZMM,        I8_U ), F_660F3A,0,  no_WDS, 0x39,     0x00,     P_686|P_AVX, IZSZ|DSIZE|T4)

insx(VEXTRACTI64x2, vextracti64x2,     OpCls( XMM,      YMM,        I8_U ), F_660F3A,0,  no_WDS, 0x39,     0x00,     P_686|P_AVX, W1|IZSZ|QSIZE|T2, RWF_EVEX|RWF_VEX )
insn(VEXTRACTI64x2, 1,                 OpCls( M128,     YMM,        I8_U ), F_660F3A,0,  no_WDS, 0x39,     0x00,     P_686|P_AVX, W1|IZSZ|QSIZE|T2)
insn(VEXTRACTI64x2, 2,                 OpCls( XMM,      ZMM,        I8_U ), F_660F3A,0,  no_WDS, 0x39,     0x00,     P_686|P_AVX, W1|IZSZ|QSIZE|T2)
insn(VEXTRACTI64x2, 3,                 OpCls( M128,     ZMM,        I8_U ), F_660F3A,0,  no_WDS, 0x39,     0x00,     P_686|P_AVX, W1|IZSZ|QSIZE|T2)

insx(VEXTRACTI32x8, vextracti32x8,     OpCls( YMM,      ZMM,        I8_U ), F_660F3A,0,  no_WDS, 0x3B,     0x00,     P_686|P_AVX, IZSZ|DSIZE|T8, RWF_EVEX|RWF_VEX )
insn(VEXTRACTI32x8, 1,                 OpCls( M256,     ZMM,        I8_U ), F_660F3A,0,  no_WDS, 0x3B,     0x00,     P_686|P_AVX, IZSZ|DSIZE|T8)

insx(VEXTRACTI64x4, vextracti64x4,     OpCls( YMM,      ZMM,        I8_U ), F_660F3A,0,  no_WDS, 0x3B,     0x00,     P_686|P_AVX, W1|IZSZ|QSIZE|T4, RWF_EVEX|RWF_VEX )
insn(VEXTRACTI64x4, 1,                 OpCls( M256,     ZMM,        I8_U ), F_660F3A,0,  no_WDS, 0x3B,     0x00,     P_686|P_AVX, W1|IZSZ|QSIZE|T4)

insx(VMASKMOVPS, vmaskmovps,           OpCls( XMM,      XMM_M128,   NONE ), F_660F38,1,  no_WDS, 0x2C,     0x00,     P_686|P_AVX, 0, RWF_VEX )
insn(VMASKMOVPS, 1,                    OpCls( M128,     XMM,        NONE ), F_660F38,0,  no_WDS, 0x2E,     0x00,     P_686|P_AVX, 0)
insx(VMASKMOVPD, vmaskmovpd,           OpCls( XMM,      XMM_M128,   NONE ), F_660F38,1,  no_WDS, 0x2D,     0x00,     P_686|P_AVX, 0, RWF_VEX )
insn(VMASKMOVPD, 1,                    OpCls( M128,     XMM,        NONE ), F_660F38,0,  no_WDS, 0x2F,     0x00,     P_686|P_AVX, 0)
insx(VPBLENDVB, vpblendvb,             OpCls( XMM,      XMM_M128,   XMM  ), F_660F3A,1,  no_WDS, 0x4C,     0x00,     P_686|P_AVX, 0, RWF_VEX )
insx(VPERMILPD, vpermilpd,             OpCls( XMM,      XMM_M128,   NONE ), F_660F38,1,  no_WDS, 0x0D,     0x00,     P_686|P_AVX, W1|QSIZE|FV, RWF_VEX )
insn(VPERMILPD, 1,                     OpCls( XMM,      XMM_M128,   I8_U ), F_660F3A,1,  no_WDS, 0x05,     0x00,     P_686|P_AVX, W1|QSIZE|FV)
insx(VPERMILPS, vpermilps,             OpCls( XMM,      XMM_M128,   NONE ), F_660F38,1,  no_WDS, 0x0C,     0x00,     P_686|P_AVX, DSIZE|FV, RWF_VEX )
insn(VPERMILPS, 1,                     OpCls( XMM,      XMM_M128,   I8_U ), F_660F3A,1,  no_WDS, 0x04,     0x00,     P_686|P_AVX, DSIZE|FV)
insx(VPERMPD, vpermpd,                 OpCls( XMM,      XMM_M128,   NONE ), F_660F38,1,  no_WDS, 0x16,     0x00,     P_686|P_AVX, W1|QSIZE|FV, RWF_VEX )
insn(VPERMPD, 1,                       OpCls( XMM,      XMM_M128,   I8_U ), F_660F3A,1,  no_WDS, 0x01,     0x00,     P_686|P_AVX, W1|QSIZE|FV)
insx(VPERMPS, vpermps,                 OpCls( XMM,      XMM_M128,   NONE ), F_660F38,1,  no_WDS, 0x16,     0x00,     P_686|P_AVX, DSIZE|FV, RWF_VEX )
insx(VPERMQ, vpermq,                   OpCls( XMM,      XMM_M128,   NONE ), F_660F38,1,  no_WDS, 0x36,     0x00,     P_686|P_AVX, W1|QSIZE|FV, RWF_VEX )
insn(VPERMQ, 1,                        OpCls( XMM,      XMM_M128,   I8_U ), F_660F3A,1,  no_WDS, 0x00,     0x00,     P_686|P_AVX, W1|QSIZE|FV)

/* the VPERMIL2xx instructions were dropped */
//insx(VPERMIL2PD, vpermil2pd,           OpCls( XMM,      XMM_M128,   XMM  ), F_660F3A,1,  no_WDS, 0x49,     0x00,     P_686|P_AVX, 0, RWF_VEX )
//insx(VPERMIL2PS, vpermil2ps,           OpCls( XMM,      XMM_M128,   XMM  ), F_660F3A,1,  no_WDS, 0x48,     0x00,     P_686|P_AVX, 0, RWF_VEX )
insx(VPERM2F128, vperm2f128,           OpCls( YMM,      YMM_M256,   I8_U ), F_660F3A,1,  no_WDS, 0x06,     0x00,     P_686|P_AVX, 0, RWF_VEX )
insx(VTESTPS, vtestps,                 OpCls( XMM,      XMM_M128,   NONE ), F_660F38,1,  no_WDS, 0x0E,     0x00,     P_686|P_AVX, 0, RWF_VEX )
insx(VTESTPD, vtestpd,                 OpCls( XMM,      XMM_M128,   NONE ), F_660F38,1,  no_WDS, 0x0F,     0x00,     P_686|P_AVX, 0, RWF_VEX )
insx(VZEROALL, vzeroall,               OpCls( NONE,     NONE,       NONE ), F_0F,    0,  no_RM,  0x77,     0x00,     P_686|P_AVX, 0, RWF_VEX )
insx(VZEROUPPER, vzeroupper,           OpCls( NONE,     NONE,       NONE ), F_0F,    0,  no_RM,  0x77,     0x00,     P_686|P_AVX, 0, RWF_VEX )
insx(VCVTPD2DQ, vcvtpd2dq,             OpCls( XMM,      XMM_M128,   NONE ), F_F20F,  1,  no_WDS, 0xE6,     0x00,     P_686|P_AVX, W1|QSIZE|FV, RWF_EVEX|RWF_VEX )
insx(VCVTPD2UDQ, vcvtpd2udq,           OpCls( XMM,      XMM_M128,   NONE ), F_0F,    1,  no_WDS, 0x79,     0x00,     P_686|P_AVX, W1|IZSZ|QSIZE|FV, RWF_EVEX|RWF_VEX )
insx(VCVTPS2UDQ, vcvtps2udq,           OpCls( XMM,      XMM_M128,   NONE ), F_0F,    1,  no_WDS, 0x79,     0x00,     P_686|P_AVX, IZSZ|DSIZE|FV, RWF_EVEX|RWF_VEX )
insx(VCVTTPD2DQ, vcvttpd2dq,           OpCls( XMM,      XMM_M128,   NONE ), F_660F,  1,  no_WDS, 0xE6,     0x00,     P_686|P_AVX, W1|QSIZE|FV, RWF_EVEX|RWF_VEX )
insx(VCVTPD2QQ, vcvtpd2qq,             OpCls( XMM,      XMM_M128,   NONE ), F_660F,  1,  no_WDS, 0x7B,     0x00,     P_686|P_AVX, W1|IZSZ|QSIZE|FV, RWF_EVEX|RWF_VEX )
insx(VCVTPD2UQQ, vcvtpd2uqq,           OpCls( XMM,      XMM_M128,   NONE ), F_660F,  1,  no_WDS, 0x79,     0x00,     P_686|P_AVX, W1|IZSZ|QSIZE|FV, RWF_EVEX|RWF_VEX )
insx(VCVTQQ2PD, vcvtqq2pd,             OpCls( XMM,      XMM_M128,   NONE ), F_F30F,  1,  no_WDS, 0xE6,     0x00,     P_686|P_AVX, W1|IZSZ|QSIZE|FV, RWF_EVEX|RWF_VEX )
insx(VCVTQQ2PS, vcvtqq2ps,             OpCls( XMM,      XMM_M128,   NONE ), F_0F,    1,  no_WDS, 0x5B,     0x00,     P_686|P_AVX, W1|IZSZ|QSIZE|FV, RWF_EVEX|RWF_VEX )
insx(VCVTPS2QQ, vcvtps2qq,             OpCls( XMM,      XMM_M128,   NONE ), F_660F,  1,  no_WDS, 0x7B,     0x00,     P_686|P_AVX, IZSZ|QSIZE|HV, RWF_EVEX|RWF_VEX )
insx(VCVTPS2UQQ, vcvtps2uqq,           OpCls( XMM,      XMM_M128,   NONE ), F_660F,  1,  no_WDS, 0x79,     0x00,     P_686|P_AVX, IZSZ|QSIZE|HV, RWF_EVEX|RWF_VEX )
insx(VCVTTPS2QQ, vcvttps2qq,           OpCls( XMM,      XMM_M128,   NONE ), F_660F,  1,  no_WDS, 0x7A,     0x00,     P_686|P_AVX, IZSZ|QSIZE|HV, RWF_EVEX|RWF_VEX )
insx(VCVTUQQ2PS, vcvtuqq2ps,           OpCls( XMM,      XMM_M128,   NONE ), F_F20F,  1,  no_WDS, 0x7A,     0x00,     P_686|P_AVX, W1|IZSZ|QSIZE|HV, RWF_EVEX|RWF_VEX )
insx(VCVTUQQ2PD, vcvtuqq2pd,           OpCls( XMM,      XMM_M128,   NONE ), F_F30F,  1,  no_WDS, 0x7A,     0x00,     P_686|P_AVX, W1|IZSZ|QSIZE|HV, RWF_EVEX|RWF_VEX )
insx(VCVTTPD2QQ, vcvttpd2qq,           OpCls( XMM,      XMM_M128,   NONE ), F_660F,  1,  no_WDS, 0x7A,     0x00,     P_686|P_AVX, W1|IZSZ|QSIZE|HV, RWF_EVEX|RWF_VEX )

insx(VCVTPD2PS, vcvtpd2ps,             OpCls( XMM,      XMM_M128,   NONE ), F_660F,  1,  no_WDS, 0x5A,     0x00,     P_686|P_AVX, W1|QSIZE|FV, RWF_EVEX|RWF_VEX )
insx(VMOVDDUP, vmovddup,               OpCls( XMM,      XMM_M64,    NONE ), F_F20F,  1,  no_WDS, 0x12,     0x00,     P_686|P_AVX, W1|QSIZE|DUP, RWF_EVEX|RWF_VEX )
/* v2.13: added here  */
//VPGATHERDD,VPGATHERDQ,VPGATHERQD,VPGATHERQQ,VGATHERDPS,VGATHERDPD,VGATHERQPS,VGATHERQPD
//VGETEXPPD,VGETEXPPS,VGETEXPSD,VGETEXPSS,VGETMANTPD,VGETMANTPS,VGETMANTSD,VGETMANTSS

insx(VPGATHERDD, vpgatherdd,         OpCls( XMM, XMM_M32,    NONE ), F_660F38,1,  no_WDS,0x90, 0x00,     P_686|P_AVX, IXSZ|DSIZE|T1S, RWF_EVEX|RWF_VEX )
insn(VPGATHERDD, 1,                  OpCls( XMM, XMM_M32,    XMM  ), F_660F38,1,  no_WDS,0x90, 0x00,     P_686|P_AVX, IXSZ|DSIZE|T1S )
insx(VPGATHERQD, vpgatherqd,         OpCls( XMM, XMM_M32,    NONE ), F_660F38,1,  no_WDS,0x91, 0x00,     P_686|P_AVX, IXSZ|DSIZE|T1S, RWF_EVEX|RWF_VEX )
insn(VPGATHERQD, 1,                  OpCls( XMM, XMM_M32,    XMM  ), F_660F38,1,  no_WDS,0x91, 0x00,     P_686|P_AVX, IXSZ|DSIZE|T1S )
insx(VPGATHERDQ, vpgatherdq,         OpCls( XMM, XMM_M64,    NONE ), F_660F38,1,  no_WDS,0x90, 0x00,     P_686|P_AVX, IXSZ|DSIZE|T1S, RWF_EVEX|RWF_VEX )
insn(VPGATHERDQ, 1,                  OpCls( XMM, XMM_M64,    XMM  ), F_660F38,1,  no_WDS,0x90, 0x00,     P_686|P_AVX, IXSZ|DSIZE|T1S )
insx(VPGATHERQQ, vpgatherqq,         OpCls( XMM, XMM_M64,    NONE ), F_660F38,1,  no_WDS,0x91, 0x00,     P_686|P_AVX, W1|IXSZ|QSIZE|T1S, RWF_EVEX|RWF_VEX )
insn(VPGATHERQQ, 1,                  OpCls( XMM, XMM_M64,    XMM  ), F_660F38,1,  no_WDS,0x91, 0x00,     P_686|P_AVX, W1|IXSZ|QSIZE|T1S )
insx(VGATHERDPD, vgatherdpd,         OpCls( ZMM, XMM_M32,    NONE ), F_660F38,1,  no_WDS,0x92, 0x00,     P_686|P_AVX, W1|IXSZ|QSIZE|T1S, RWF_EVEX|RWF_VEX ) 
insn(VGATHERDPD, 1,                  OpCls( XMM, XMM_M32,    XMM  ), F_660F38,1,  no_WDS,0x92, 0x00,     P_686|P_AVX, W1|IXSZ|QSIZE|T1S ) 
insx(VGATHERQPD, vgatherqpd,         OpCls( XMM, XMM_M64,    NONE ), F_660F38,1,  no_WDS,0x93, 0x00,     P_686|P_AVX, W1|IXSZ|T1S, RWF_EVEX|RWF_VEX ) 
insn(VGATHERQPD, 1,                  OpCls( XMM, XMM_M64,    XMM  ), F_660F38,1,  no_WDS,0x93, 0x00,     P_686|P_AVX, W1|IXSZ|T1S ) 
insx(VGATHERDPS, vgatherdps,         OpCls( XMM, XMM_M32,    NONE ), F_660F38,1,  no_WDS,0x92, 0x00,     P_686|P_AVX, IXSZ|DSIZE|T1S, RWF_EVEX|RWF_VEX ) 
insn(VGATHERDPS, 1,                  OpCls( XMM, XMM_M32,    XMM  ), F_660F38,1,  no_WDS,0x92, 0x00,     P_686|P_AVX, IXSZ|DSIZE|T1S ) 
insx(VGATHERQPS, vgatherqps,         OpCls( XMM, XMM_M32,    NONE ), F_660F38,1,  no_WDS,0x93, 0x00,     P_686|P_AVX, IXSZ|DSIZE|T1S, RWF_EVEX|RWF_VEX ) 
insn(VGATHERQPS, 1,                  OpCls( XMM, XMM_M32,    XMM  ), F_660F38,1,  no_WDS,0x93, 0x00,     P_686|P_AVX, IXSZ|DSIZE|T1S ) 
insx(VGATHERPF0DPS, vgatherpf0dps,   OpCls(ZMM_M32, NONE,     NONE ), F_660F38,0,  no_WDS,0xC6, 0x08,     P_686|P_AVX, IZSZ|DSIZE|T1S, RWF_EVEX|RWF_VEX )
insx(VGATHERPF0QPS, vgatherpf0qps,   OpCls(ZMM_M64, NONE,     NONE ), F_660F38,0,  no_WDS,0xC7, 0x08,     P_686|P_AVX, IZSZ|QSIZE|T1S, RWF_EVEX|RWF_VEX )
insx(VGATHERPF0DPD, vgatherpf0dpd,   OpCls(YMM_M32, NONE,     NONE ), F_660F38,0,  no_WDS,0xC6, 0x08,     P_686|P_AVX, W1|IZSZ|DSIZE|T1S, RWF_EVEX|RWF_VEX )
insx(VGATHERPF0QPD, vgatherpf0qpd,   OpCls(ZMM_M64, NONE,     NONE ), F_660F38,0,  no_WDS,0xC7, 0x08,     P_686|P_AVX, W1|IZSZ|QSIZE|T1S, RWF_EVEX|RWF_VEX )
insx(VGATHERPF1DPS, vgatherpf1dps,   OpCls(ZMM_M32, NONE,     NONE ), F_660F38,0,  no_WDS,0xC6, 0x10,     P_686|P_AVX, IZSZ|DSIZE|T1S, RWF_EVEX|RWF_VEX )
insx(VGATHERPF1QPS, vgatherpf1qps,   OpCls(ZMM_M64, NONE,     NONE ), F_660F38,0,  no_WDS,0xC7, 0x10,     P_686|P_AVX, IZSZ|QSIZE|T1S, RWF_EVEX|RWF_VEX )
insx(VGATHERPF1DPD, vgatherpf1dpd,   OpCls(YMM_M32, NONE,     NONE ), F_660F38,0,  no_WDS,0xC6, 0x10,     P_686|P_AVX, W1|IZSZ|DSIZE|T1S, RWF_EVEX|RWF_VEX )
insx(VGATHERPF1QPD, vgatherpf1qpd,   OpCls(ZMM_M64, NONE,     NONE ), F_660F38,0,  no_WDS,0xC7, 0x10,     P_686|P_AVX, W1|IZSZ|QSIZE|T1S, RWF_EVEX|RWF_VEX )
insx(VSCATTERPF0DPS, vscatterpf0dps, OpCls(ZMM_M32, NONE,     NONE ), F_660F38,0,  no_WDS,0xC6, 0x28,     P_686|P_AVX, IZSZ|DSIZE|T1S, RWF_EVEX|RWF_VEX )
insx(VSCATTERPF0QPS, vscatterpf0qps, OpCls(ZMM_M64, NONE,     NONE ), F_660F38,0,  no_WDS,0xC7, 0x28,     P_686|P_AVX, IZSZ|QSIZE|T1S, RWF_EVEX|RWF_VEX )
insx(VSCATTERPF0DPD, vscatterpf0dpd, OpCls(YMM_M32, NONE,     NONE ), F_660F38,0,  no_WDS,0xC6, 0x28,     P_686|P_AVX, W1|IZSZ|DSIZE|T1S, RWF_EVEX|RWF_VEX )
insx(VSCATTERPF0QPD, vscatterpf0qpd, OpCls(ZMM_M64, NONE,     NONE ), F_660F38,0,  no_WDS,0xC7, 0x28,     P_686|P_AVX, W1|IZSZ|QSIZE|T1S, RWF_EVEX|RWF_VEX )
insx(VSCATTERPF1DPS, vscatterpf1dps, OpCls(ZMM_M32, NONE,     NONE ), F_660F38,0,  no_WDS,0xC6, 0x30,     P_686|P_AVX, IZSZ|DSIZE|T1S, RWF_EVEX|RWF_VEX )
insx(VSCATTERPF1QPS, vscatterpf1qps, OpCls(ZMM_M64, NONE,     NONE ), F_660F38,0,  no_WDS,0xC7, 0x30,     P_686|P_AVX, IZSZ|QSIZE|T1S, RWF_EVEX|RWF_VEX )
insx(VSCATTERPF1DPD, vscatterpf1dpd, OpCls(YMM_M32, NONE,     NONE ), F_660F38,0,  no_WDS,0xC6, 0x30,     P_686|P_AVX, W1|IZSZ|DSIZE|T1S, RWF_EVEX|RWF_VEX )
insx(VSCATTERPF1QPD, vscatterpf1qpd, OpCls(ZMM_M64, NONE,     NONE ), F_660F38,0,  no_WDS,0xC7, 0x30,     P_686|P_AVX, W1|IZSZ|QSIZE|T1S, RWF_EVEX|RWF_VEX )

//VPSCATTERDD,VPSCATTERDQ,VPSCATTERQD,VPSCATTERQQ
//VSCATTERDPS/VSCATTERDPD/VSCATTERQPS/VSCATTERQPD
insx(VPSCATTERDD, vpscatterdd,       OpCls( XMM_M32, XMM,    NONE ), F_660F38,0,  no_WDS,0xA0, 0x00,     P_686|P_AVX, IZSZ|DSIZE|T1S, RWF_EVEX|RWF_VEX )
insx(VPSCATTERDQ, vpscatterdq,       OpCls( XMM_M32, XMM,    NONE ), F_660F38,0,  no_WDS,0xA0, 0x00,     P_686|P_AVX, W1|IZSZ|DSIZE|T1S, RWF_EVEX|RWF_VEX )
insx(VPSCATTERQD, vpscatterqd,       OpCls( XMM_M32, XMM,    NONE ), F_660F38,0,  no_WDS,0xA1, 0x00,     P_686|P_AVX, IZSZ|QSIZE|T1S, RWF_EVEX|RWF_VEX )
insx(VPSCATTERQQ, vpscatterqq,       OpCls( XMM_M32, XMM,    NONE ), F_660F38,0,  no_WDS,0xA1, 0x00,     P_686|P_AVX, W1|IZSZ|QSIZE|T1S, RWF_EVEX|RWF_VEX )
insx(VSCATTERDPS, vscatterdps,       OpCls( XMM_M32, XMM,    NONE ), F_660F38,0,  no_WDS,0xA2, 0x00,     P_686|P_AVX, IZSZ|DSIZE|T1S, RWF_EVEX|RWF_VEX )
insx(VSCATTERDPD, vscatterdpd,       OpCls( XMM_M32, XMM,    NONE ), F_660F38,0,  no_WDS,0xA2, 0x00,     P_686|P_AVX, IZSZ|DSIZE|T1S, RWF_EVEX|RWF_VEX )
insx(VSCATTERQPS, vscatterqps,       OpCls( XMM_M32, XMM,    NONE ), F_660F38,0,  no_WDS,0xA3, 0x00,     P_686|P_AVX, IZSZ|QSIZE|T1S, RWF_EVEX|RWF_VEX )
insx(VSCATTERQPD, vscatterqpd,       OpCls( XMM_M32, XMM,    NONE ), F_660F38,0,  no_WDS,0xA3, 0x00,     P_686|P_AVX, W1|IZSZ|QSIZE|T1S, RWF_EVEX|RWF_VEX )

insx(VPABSQ, vpabsq,                 OpCls( XMM,   XMM_M128, NONE ), F_660F38,1,  no_WDS,0x1F, 0x00,     P_686|P_AVX, W1|QSIZE|FV, RWF_VEX)
insx(VPANDD, vpandd,                 OpCls( XMM,   XMM_M128, NONE ), F_660F,  1,  no_WDS,0xDB, 0x00,     P_686|P_AVX ,DSIZE|FV,RWF_VEX )
insx(VPANDQ, vpandq,                 OpCls( XMM,   XMM_M128, NONE ), F_660F,  1,  no_WDS,0xDB, 0x00,     P_686|P_AVX ,W1|IZSZ|QSIZE|FV,RWF_VEX )
insx(VPANDND, vpandnd,               OpCls( XMM,   XMM_M128, NONE ), F_660F,  1,  no_WDS,0xDF, 0x00,     P_686|P_AVX ,IZSZ|DSIZE|FV,RWF_VEX )
insx(VPANDNQ, vpandnq,               OpCls( XMM,   XMM_M128, NONE ), F_660F,  1,  no_WDS,0xDF, 0x00,     P_686|P_AVX ,W1|IZSZ|QSIZE|FV,RWF_VEX )
insx(VPBLENDMB, vpblendmb,           OpCls( XMM,   XMM_M128, NONE ), F_660F38,1,  no_WDS,0x66, 0x00,     P_686|P_AVX ,IZSZ|BSIZE|FV,RWF_VEX )
insx(VPBLENDMW, vpblendmw,           OpCls( XMM,   XMM_M128, NONE ), F_660F38,1,  no_WDS,0x66, 0x00,     P_686|P_AVX ,W1|IZSZ|WSIZE|FV,RWF_VEX )
insx(VPBLENDMD, vpblendmd,           OpCls( XMM,   XMM_M128, NONE ), F_660F38,1,  no_WDS,0x64, 0x00,     P_686|P_AVX ,IZSZ|DSIZE|FV,RWF_VEX )
insx(VPBLENDMQ, vpblendmq,           OpCls( XMM,   XMM_M128, NONE ), F_660F38,1,  no_WDS,0x64, 0x00,     P_686|P_AVX ,W1|IZSZ|QSIZE|FV,RWF_VEX )
insx(VFMADD132PD, vfmadd132pd,       OpCls( XMM,   XMM_M128, NONE ), F_660F38,1,  no_WDS,0x98, 0x00,     P_686|P_AVX ,W1|QSIZE|FV ,RWF_VEX )
insx(VFMADD213PD, vfmadd213pd,       OpCls( XMM,   XMM_M128, NONE ), F_660F38,1,  no_WDS,0xA8, 0x00,     P_686|P_AVX ,W1|QSIZE|FV ,RWF_VEX )
insx(VFMADD231PD, vfmadd231pd,       OpCls( XMM,   XMM_M128, NONE ), F_660F38,1,  no_WDS,0xB8, 0x00,     P_686|P_AVX ,W1|QSIZE|FV ,RWF_VEX )
insx(VFMADD132PS, vfmadd132ps,       OpCls( XMM,   XMM_M128, NONE ), F_660F38,1,  no_WDS,0x98, 0x00,     P_686|P_AVX ,DSIZE|FV ,RWF_VEX )
insx(VFMADD213PS, vfmadd213ps,       OpCls( XMM,   XMM_M128, NONE ), F_660F38,1,  no_WDS,0xA8, 0x00,     P_686|P_AVX ,DSIZE|FV ,RWF_VEX )
insx(VFMADD231PS, vfmadd231ps,       OpCls( XMM,   XMM_M128, NONE ), F_660F38,1,  no_WDS,0xB8, 0x00,     P_686|P_AVX ,DSIZE|FV ,RWF_VEX )
insx(VFMADD132SD, vfmadd132sd,       OpCls( XMM,   XMM_M64,  NONE ), F_660F38,1,  no_WDS,0x99, 0x00,     P_686|P_AVX ,W1|QSIZE|T1S ,RWF_VEX )
insx(VFMADD213SD, vfmadd213sd,       OpCls( XMM,   XMM_M64,  NONE ), F_660F38,1,  no_WDS,0xA9, 0x00,     P_686|P_AVX ,W1|QSIZE|T1S ,RWF_VEX )
insx(VFMADD231SD, vfmadd231sd,       OpCls( XMM,   XMM_M64,  NONE ), F_660F38,1,  no_WDS,0xB9, 0x00,     P_686|P_AVX ,W1|QSIZE|T1S ,RWF_VEX )

insx(VFMADD132SS, vfmadd132ss,       OpCls( XMM,   XMM_M32, NONE  ), F_660F38, 1, no_WDS,0x99, 0x00,     P_686|P_AVX ,DSIZE|T1S ,RWF_VEX )
insx(VFMADD213SS, vfmadd213ss,       OpCls( XMM,   XMM_M32, NONE  ), F_660F38, 1, no_WDS,0xA9, 0x00,     P_686|P_AVX ,DSIZE|T1S ,RWF_VEX )
insx(VFMADD231SS, vfmadd231ss,       OpCls( XMM,   XMM_M32, NONE  ), F_660F38, 1, no_WDS,0xB9, 0x00,     P_686|P_AVX ,DSIZE|T1S ,RWF_VEX )

insx(VFMADDSUB132PD, vfmaddsub132pd, OpCls( XMM,   XMM_M128, NONE ), F_660F38, 1, no_WDS,0x96, 0x00,     P_686|P_AVX ,W1|QSIZE|FV ,RWF_VEX )
insx(VFMADDSUB213PD, vfmaddsub213pd, OpCls( XMM,   XMM_M128, NONE ), F_660F38, 1, no_WDS,0xA6, 0x00,     P_686|P_AVX ,W1|QSIZE|FV ,RWF_VEX )
insx(VFMADDSUB231PD, vfmaddsub231pd, OpCls( XMM,   XMM_M128, NONE ), F_660F38, 1, no_WDS,0xB6, 0x00,     P_686|P_AVX ,W1|QSIZE|FV ,RWF_VEX )
insx(VFMADDSUB132PS, vfmaddsub132ps, OpCls( XMM,   XMM_M128, NONE ), F_660F38, 1, no_WDS,0x96, 0x00,     P_686|P_AVX ,DSIZE|FV ,RWF_VEX )
insx(VFMADDSUB213PS, vfmaddsub213ps, OpCls( XMM,   XMM_M128, NONE ), F_660F38, 1, no_WDS,0xA6, 0x00,     P_686|P_AVX ,DSIZE|FV ,RWF_VEX )
insx(VFMADDSUB231PS, vfmaddsub231ps, OpCls( XMM,   XMM_M128, NONE ), F_660F38, 1, no_WDS,0xB6, 0x00,     P_686|P_AVX ,DSIZE|FV ,RWF_VEX )
insx(VFMSUB132PD,    vfmsub132pd,    OpCls( XMM,   XMM_M128, NONE ), F_660F38, 1, no_WDS,0x9A, 0x00,     P_686|P_AVX ,W1|QSIZE|FV ,RWF_VEX )
insx(VFMSUB213PD,    vfmsub213pd,    OpCls( XMM,   XMM_M128, NONE ), F_660F38, 1, no_WDS,0xAA, 0x00,     P_686|P_AVX ,W1|QSIZE|FV ,RWF_VEX )
insx(VFMSUB231PD,    vfmsub231pd,    OpCls( XMM,   XMM_M128, NONE ), F_660F38, 1, no_WDS,0xBA, 0x00,     P_686|P_AVX ,W1|QSIZE|FV ,RWF_VEX )
insx(VFMSUB132PS,    vfmsub132ps,    OpCls( XMM,   XMM_M128, NONE ), F_660F38, 1, no_WDS,0x9A, 0x00,     P_686|P_AVX ,DSIZE|FV ,RWF_VEX )
insx(VFMSUB213PS,    vfmsub213ps,    OpCls( XMM,   XMM_M128, NONE ), F_660F38, 1, no_WDS,0xAA, 0x00,     P_686|P_AVX ,DSIZE|FV ,RWF_VEX )
insx(VFMSUB231PS,    vfmsub231ps,    OpCls( XMM,   XMM_M128, NONE ), F_660F38, 1, no_WDS,0xBA, 0x00,     P_686|P_AVX ,DSIZE|FV ,RWF_VEX )
insx(VFMSUB132SD,    vfmsub132sd,    OpCls( XMM,   XMM_M64,  NONE ), F_660F38, 1, no_WDS,0x9B, 0x00,     P_686|P_AVX ,W1|QSIZE|T1S ,RWF_VEX )
insx(VFMSUB213SD,    vfmsub213sd,    OpCls( XMM,   XMM_M64,  NONE ), F_660F38, 1, no_WDS,0xAB, 0x00,     P_686|P_AVX ,W1|QSIZE|T1S ,RWF_VEX )
insx(VFMSUB231SD,    vfmsub231sd,    OpCls( XMM,   XMM_M64,  NONE ), F_660F38, 1, no_WDS,0xBB, 0x00,     P_686|P_AVX ,W1|QSIZE|T1S ,RWF_VEX )

insx(VFMSUB132SS,    vfmsub132ss,    OpCls( XMM,   XMM_M32,  NONE ), F_660F38, 1, no_WDS,0x9B, 0x00,     P_686|P_AVX ,DSIZE|T1S ,RWF_VEX )
insx(VFMSUB213SS,    vfmsub213ss,    OpCls( XMM,   XMM_M32,  NONE ), F_660F38, 1, no_WDS,0xAB, 0x00,     P_686|P_AVX ,DSIZE|T1S ,RWF_VEX )
insx(VFMSUB231SS,    vfmsub231ss,    OpCls( XMM,   XMM_M32,  NONE ), F_660F38, 1, no_WDS,0xBB, 0x00,     P_686|P_AVX ,DSIZE|T1S ,RWF_VEX )

insx(VFMSUBADD132PD, vfmsubadd132pd, OpCls( XMM,   XMM_M128, NONE ), F_660F38, 1, no_WDS,0x97, 0x00,     P_686|P_AVX ,W1|QSIZE|FV ,RWF_VEX )
insx(VFMSUBADD213PD, vfmsubadd213pd, OpCls( XMM,   XMM_M128, NONE ), F_660F38, 1, no_WDS,0xA7, 0x00,     P_686|P_AVX ,W1|QSIZE|FV ,RWF_VEX )
insx(VFMSUBADD231PD, vfmsubadd231pd, OpCls( XMM,   XMM_M128, NONE ), F_660F38, 1, no_WDS,0xB7, 0x00,     P_686|P_AVX ,W1|QSIZE|FV ,RWF_VEX )
insx(VFMSUBADD132PS, vfmsubadd132ps, OpCls( XMM,   XMM_M128, NONE ), F_660F38, 1, no_WDS,0x97, 0x00,     P_686|P_AVX ,DSIZE|FV ,RWF_VEX )
insx(VFMSUBADD213PS, vfmsubadd213ps, OpCls( XMM,   XMM_M128, NONE ), F_660F38, 1, no_WDS,0xA7, 0x00,     P_686|P_AVX ,DSIZE|FV ,RWF_VEX )
insx(VFMSUBADD231PS, vfmsubadd231ps, OpCls( XMM,   XMM_M128, NONE ), F_660F38, 1, no_WDS,0xB7, 0x00,     P_686|P_AVX ,DSIZE|FV ,RWF_VEX )
insx(VFNMADD132PD,   vfnmadd132pd,   OpCls( XMM,   XMM_M128, NONE ), F_660F38, 1, no_WDS,0x9C, 0x00,     P_686|P_AVX ,W1|QSIZE|FV ,RWF_VEX )
insx(VFNMADD213PD,   vfnmadd213pd,   OpCls( XMM,   XMM_M128, NONE ), F_660F38, 1, no_WDS,0xAC, 0x00,     P_686|P_AVX ,W1|QSIZE|FV ,RWF_VEX )
insx(VFNMADD231PD,   vfnmadd231pd,   OpCls( XMM,   XMM_M128, NONE ), F_660F38, 1, no_WDS,0xBC, 0x00,     P_686|P_AVX ,W1|QSIZE|FV ,RWF_VEX )
insx(VFNMADD132PS,   vfnmadd132ps,   OpCls( XMM,   XMM_M128, NONE ), F_660F38, 1, no_WDS,0x9C, 0x00,     P_686|P_AVX ,DSIZE|FV ,RWF_VEX )                                                                                                                              
insx(VFNMADD213PS,   vfnmadd213ps,   OpCls( XMM,   XMM_M128, NONE ), F_660F38, 1, no_WDS,0xAC, 0x00,     P_686|P_AVX ,DSIZE|FV ,RWF_VEX )                                                                                                                              
insx(VFNMADD231PS,   vfnmadd231ps,   OpCls( XMM,   XMM_M128, NONE ), F_660F38, 1, no_WDS,0xBC, 0x00,     P_686|P_AVX ,DSIZE|FV ,RWF_VEX )
insx(VFNMADD132SD,   vfnmadd132sd,   OpCls( XMM,   XMM_M64,  NONE ), F_660F38, 1, no_WDS,0x9D, 0x00,     P_686|P_AVX ,W1|QSIZE|T1S ,RWF_VEX )
insx(VFNMADD213SD,   vfnmadd213sd,   OpCls( XMM,   XMM_M64,  NONE ), F_660F38, 1, no_WDS,0xAD, 0x00,     P_686|P_AVX ,W1|QSIZE|T1S ,RWF_VEX )
insx(VFNMADD231SD,   vfnmadd231sd,   OpCls( XMM,   XMM_M64,  NONE ), F_660F38, 1, no_WDS,0xBD, 0x00,     P_686|P_AVX ,W1|QSIZE|T1S ,RWF_VEX )

insx(VFNMADD132SS,   vfnmadd132ss,   OpCls( XMM,   XMM_M32,  NONE ), F_660F38, 1, no_WDS,0x9D, 0x00,     P_686|P_AVX ,DSIZE|T1S ,RWF_VEX )
insx(VFNMADD213SS,   vfnmadd213ss,   OpCls( XMM,   XMM_M32,  NONE ), F_660F38, 1, no_WDS,0xAD, 0x00,     P_686|P_AVX ,DSIZE|T1S ,RWF_VEX )
insx(VFNMADD231SS,   vfnmadd231ss,   OpCls( XMM,   XMM_M32,  NONE ), F_660F38, 1, no_WDS,0xBD, 0x00,     P_686|P_AVX ,DSIZE|T1S ,RWF_VEX )

insx(VFNMSUB132PD,   vfnmsub132pd,   OpCls( XMM,   XMM_M128, NONE ), F_660F38, 1, no_WDS,0x9E, 0x00,     P_686|P_AVX ,W1|QSIZE|FV ,RWF_VEX )
insx(VFNMSUB213PD,   vfnmsub213pd,   OpCls( XMM,   XMM_M128, NONE ), F_660F38, 1, no_WDS,0xAE, 0x00,     P_686|P_AVX ,W1|QSIZE|FV ,RWF_VEX )
insx(VFNMSUB231PD,   vfnmsub231pd,   OpCls( XMM,   XMM_M128, NONE ), F_660F38, 1, no_WDS,0xBE, 0x00,     P_686|P_AVX ,W1|QSIZE|FV ,RWF_VEX )
insx(VFNMSUB132PS,   vfnmsub132ps,   OpCls( XMM,   XMM_M128, NONE ), F_660F38, 1, no_WDS,0x9E, 0x00,     P_686|P_AVX ,DSIZE|FV ,RWF_VEX )                                                                                                                              
insx(VFNMSUB213PS,   vfnmsub213ps,   OpCls( XMM,   XMM_M128, NONE ), F_660F38, 1, no_WDS,0xAE, 0x00,     P_686|P_AVX ,DSIZE|FV ,RWF_VEX )
insx(VFNMSUB231PS,   vfnmsub231ps,   OpCls( XMM,   XMM_M128, NONE ), F_660F38, 1, no_WDS,0xBE, 0x00,     P_686|P_AVX ,DSIZE|FV ,RWF_VEX )
insx(VFNMSUB132SD,   vfnmsub132sd,   OpCls( XMM,   XMM_M64,  NONE ), F_660F38, 1, no_WDS,0x9F, 0x00,     P_686|P_AVX ,W1|QSIZE|T1S ,RWF_VEX )
insx(VFNMSUB213SD,   vfnmsub213sd,   OpCls( XMM,   XMM_M64,  NONE ), F_660F38, 1, no_WDS,0xAF, 0x00,     P_686|P_AVX ,W1|QSIZE|T1S ,RWF_VEX )
insx(VFNMSUB231SD,   vfnmsub231sd,   OpCls( XMM,   XMM_M64,  NONE ), F_660F38, 1, no_WDS,0xBF, 0x00,     P_686|P_AVX ,W1|QSIZE|T1S ,RWF_VEX )

insx(VFNMSUB132SS, vfnmsub132ss,   OpCls( XMM, XMM_M32, NONE  ), F_660F38, 1,  no_WDS,0x9F,     0x00,     P_686|P_AVX ,DSIZE|T1S ,RWF_VEX )
insx(VFNMSUB213SS, vfnmsub213ss,   OpCls( XMM, XMM_M32, NONE  ), F_660F38, 1,  no_WDS,0xAF,     0x00,     P_686|P_AVX ,DSIZE|T1S ,RWF_VEX )
insx(VFNMSUB231SS, vfnmsub231ss,   OpCls( XMM, XMM_M32, NONE  ), F_660F38, 1,  no_WDS,0xBF,     0x00,     P_686|P_AVX ,DSIZE|T1S ,RWF_VEX )

insx(VGETEXPPD, vgetexppd,         OpCls( XMM, XMM_M128_M64, NONE ), F_660F38, 1,no_WDS,0x42,  0x00,     P_686|P_AVX ,W1|IZSZ|QSIZE|FV ,RWF_VEX)
insx(VGETEXPPS, vgetexpps,         OpCls( XMM, XMM_M128_M32, NONE ), F_660F38, 1,no_WDS,0x42,  0x00,     P_686|P_AVX ,IZSZ|DSIZE|FV ,RWF_VEX)
insx(VGETEXPSD, vgetexpsd,         OpCls( XMM, XMM_M64, NONE ), F_660F38, 1,  no_WDS,0x43,     0x00,     P_686|P_AVX ,W1|QSIZE|T1S ,RWF_VEX)
insx(VGETEXPSS, vgetexpss,         OpCls( XMM, XMM_M32, NONE ), F_660F38, 1,  no_WDS,0x43,     0x00,     P_686|P_AVX ,IZSZ|DSIZE|T1S ,RWF_VEX)
insx(VCVTPH2PS, vcvtph2ps,         OpCls( XMM, XMM_M64, NONE ), F_660F38, 1,  no_WDS, 0x13,    0x00,     P_686|P_AVX,  DSIZE|HVM, RWF_EVEX|RWF_VEX )
insx(VCVTPS2PH, vcvtps2ph,         OpCls(XMM,  XMM_M128, I8_U), F_660F3A, 0,  no_WDS, 0x1D,    0x00,     P_686|P_AVX, DSIZE|HVM, RWF_EVEX|RWF_VEX )
//insn(VCVTPS2PH, 1,                 OpCls( XMM_M128,XMM,  I8_U), F_660F3A, 0,  no_WDS, 0x1D,    0x00,     P_686|P_AVX, DSIZE|HVM)
//insn(VCVTPS2PH, 2,                 OpCls( XMM_M128,YMM,  I8_U), F_660F3A, 0,  no_WDS, 0x1D,    0x00,     P_686|P_AVX, DSIZE|HVM)
//insn(VCVTPS2PH, 3,                 OpCls( XMM_M256,ZMM,  I8_U), F_660F3A, 0,  no_WDS, 0x1D,    0x00,     P_686|P_AVX, DSIZE|HVM)

insx(VGETMANTPD, vgetmantpd,       OpCls( XMM,  XMM_M128, I8_U), F_660F3A, 1,  no_WDS,0x26,     0x00,     P_686|P_AVX ,W1|IZSZ|QSIZE|FV,RWF_EVEX|RWF_VEX)
insx(VGETMANTPS, vgetmantps,       OpCls( XMM,  XMM_M128, I8_U), F_660F3A, 1,  no_WDS,0x26,     0x00,     P_686|P_AVX ,IZSZ|DSIZE|FV,RWF_EVEX|RWF_VEX)
insx(VGETMANTSD, vgetmantsd,       OpCls( XMM,  XMM_M64,  I8_U), F_660F3A, 1,  no_WDS,0x27,     0x00,     P_686|P_AVX ,W1|IZSZ|QSIZE|T1S,RWF_EVEX|RWF_VEX)
insx(VGETMANTSS, vgetmantss,       OpCls( XMM,  XMM_M32,  I8_U), F_660F3A, 1,  no_WDS,0x27,     0x00,     P_686|P_AVX ,IZSZ|DSIZE|T1S,RWF_EVEX|RWF_VEX)
insx(VALIGND,    valignd,          OpCls( XMM,  XMM_M128, I8_U), F_660F3A, 1,  no_WDS,0x03,     0x00,     P_686|P_AVX ,IZSZ|DSIZE|FV,RWF_EVEX|RWF_VEX)
insx(VALIGNQ,    valignq,          OpCls( XMM,  XMM_M128, I8_U), F_660F3A, 1,  no_WDS,0x03,     0x00,     P_686|P_AVX ,W1|IZSZ|QSIZE|FV,RWF_EVEX|RWF_VEX)
insx(VBLENDMPD, vblendmpd,         OpCls( XMM,  XMM_M128, I8_U),  F_660F38, 1,  no_WDS,0x65,     0x00,     P_686|P_AVX ,W1|IZSZ|QSIZE|FV,RWF_EVEX|RWF_VEX)
insx(VBLENDMPS, vblendmps,         OpCls( XMM,  XMM, XMM_M128),  F_660F38, 1,  no_WDS,0x65,     0x00,     P_686|P_AVX ,IZSZ|DSIZE|FV,RWF_EVEX|RWF_VEX)
insx(VCOMPRESSPD, vcompresspd,     OpCls( XMM_M128, XMM, NONE ), F_660F38, 0,  no_WDS,0x8A,     0x00,     P_686|P_AVX, W1|IZSZ|QSIZE|T1S, RWF_EVEX|RWF_VEX )
insx(VCOMPRESSPS, vcompressps,     OpCls( XMM_M128, XMM, NONE ), F_660F38, 0,  no_WDS,0x8A,     0x00,     P_686|P_AVX, IZSZ|DSIZE|T1S, RWF_EVEX|RWF_VEX )
insx(VPCOMPRESSD, vpcompressd,     OpCls( XMM_M128, XMM, NONE ), F_660F38, 0,  no_WDS,0x8B,     0x00,     P_686|P_AVX, IZSZ|DSIZE|T1S, RWF_EVEX|RWF_VEX )
insx(VPCOMPRESSQ, vpcompressq,     OpCls( XMM_M128, XMM, NONE ), F_660F38, 0,  no_WDS,0x8B,     0x00,     P_686|P_AVX, W1|IZSZ|QSIZE|T1S, RWF_EVEX|RWF_VEX )
//VCVTPD2QQ,VCVTPD2UDQ,VCVTPD2UQQ,VCVTPS2UDQ,VCVTPS2QQ,VCVTPS2UQQ,VCVTQQ2PD,VCVTQQ2PS,VCVTSD2USI,VCVTSS2USI
//VCVTTPD2QQ,VCVTTPD2UDQ,VCVTTPD2UQQ,VCVTTPS2UDQ,VCVTTPS2QQ,VCVTTPS2UQQ,VCVTTSD2USI,VCVTTSS2USI
//VCVTUDQ2PD,VCVTUDQ2PS,VCVTUQQ2PD,VCVTUQQ2PS,VCVTUSI2SD,VCVTUSI2SS
//VPCMPB,VPCMPUB,VPCMPD,VPCMPUD,VPCMPQ,VPCMPUQ,VPCMPW,VPCMPUW
insx(VCVTSI2SD, vcvtsi2sd,         OpCls( XMM,      R32, NONE ), F_F20F,   1,  no_WDS,0x2A,     0x00,     P_686|P_SSE2,DSIZE|T1S, RWF_VEX )
insn(VCVTSI2SD, 1,                 OpCls( XMM,      R64, NONE ), F_F20F,   1,  no_WDS,0x2A,     0x00,     P_686|P_SSE2,W1|QSIZE|T1S)
insx(VCVTUDQ2PD, vcvtudq2pd,       OpCls( XMM, XMM_M64,  NONE ), F_F30F,   1,  no_WDS,0x7A,     0x00,     P_686|P_AVX, IZSZ|DSIZE|HV, RWF_EVEX|RWF_VEX )
insx(VCVTUDQ2PS, vcvtudq2ps,       OpCls( XMM, XMM_M128, NONE ), F_F20F,   1,  no_WDS,0x7A,     0x00,     P_686|P_AVX, IZSZ|DSIZE|FV, RWF_EVEX|RWF_VEX )
insx(VEXPANDPD, vexpandpd,         OpCls( XMM, XMM_M128, NONE ), F_660F38, 1,  no_WDS,0x88,     0x00,     P_686|P_AVX, W1|IZSZ|QSIZE|T1S,RWF_EVEX|RWF_VEX )
insx(VEXPANDPS, vexpandps,         OpCls( XMM, XMM_M128, NONE ), F_660F38, 1,  no_WDS,0x88,     0x00,     P_686|P_AVX, IZSZ|DSIZE|T1S, RWF_EVEX|RWF_VEX )
insx(VPCMPD, vpcmpd,               OpCls( XMM,  XMM_M128, I8_U ),F_660F3A, 1,  no_WDS,0x1F,     0x00,     P_686|P_AVX,IZSZ|DSIZE|FV, RWF_EVEX|RWF_VEX )                                                                                                                       
insx(VPCMPUD, vpcmpud,             OpCls( XMM,  XMM_M128, I8_U ),F_660F3A, 1,  no_WDS,0x1E,     0x00,     P_686|P_AVX,IZSZ|DSIZE|FV, RWF_EVEX|RWF_VEX )
insx(VPCMPQ, vpcmpq,               OpCls( XMM,  XMM_M128, I8_U ),F_660F3A, 1,  no_WDS,0x1F,     0x00,     P_686|P_AVX,W1|IZSZ|QSIZE|FV, RWF_EVEX|RWF_VEX )                                                                                                                       
insx(VPCMPUQ, vpcmpuq,             OpCls( XMM,  XMM_M128, I8_U ),F_660F3A, 1,  no_WDS,0x1E,     0x00,     P_686|P_AVX,W1|IZSZ|QSIZE|FV, RWF_EVEX|RWF_VEX )
insx(VPCMPW, vpcmpw,               OpCls( XMM,  XMM_M128, I8_U ),F_660F3A, 1,  no_WDS,0x3F,     0x00,     P_686|P_AVX,W1|IZSZ|WSIZE|FVM, RWF_EVEX|RWF_VEX )                                                                                                                       
insx(VPCMPUW, vpcmpuw,             OpCls( XMM,  XMM_M128, I8_U ),F_660F3A, 1,  no_WDS,0x3E,     0x00,     P_686|P_AVX,W1|IZSZ|WSIZE|FVM, RWF_EVEX|RWF_VEX )
insx(VPCMPB, vpcmpb,               OpCls( XMM,  XMM_M128, I8_U ),F_660F3A, 1,  no_WDS,0x3F,     0x00,     P_686|P_AVX,IZSZ|BSIZE|FVM, RWF_EVEX|RWF_VEX )                                                                                                                       
insx(VPCMPUB, vpcmpub,             OpCls( XMM,  XMM_M128, I8_U ),F_660F3A, 1,  no_WDS,0x3E,     0x00,     P_686|P_AVX,IZSZ|BSIZE|FVM, RWF_EVEX|RWF_VEX )

//insx(VPCMPEQD,   vpcmpeqd,        OpCls( XMM,     XMM_M128, NONE), F_660F,   1,  no_WDS, 0x76,     0x00,       P_686|P_AVX,DSIZE|FV, RWF_VEX )
insx(VPCMPLTD,   vpcmpltd,        OpCls( XMM,     XMM_M128, NONE), F_660F3A, 1,  no_WDS, 0x1F,     0x00,       P_686|P_AVX,DSIZE|FV, RWF_VEX )
insx(VPCMPLED,   vpcmpled,        OpCls( XMM,     XMM_M128, NONE), F_660F3A, 1,  no_WDS, 0x1F,     0x00,       P_686|P_AVX,DSIZE|FV, RWF_VEX )
insx(VPCMPFALSED,vpcmpfalsed,     OpCls( XMM,     XMM_M128, NONE), F_660F3A, 1,  no_WDS, 0x1F,     0x00,       P_686|P_AVX,DSIZE|FV, RWF_VEX )
insx(VPCMPNEQD,  vpcmpneqd,       OpCls( XMM,     XMM_M128, NONE), F_660F3A, 1,  no_WDS, 0x1F,     0x00,       P_686|P_AVX,DSIZE|FV, RWF_VEX )
insx(VPCMPNLTD,  vpcmpnltd,       OpCls( XMM,     XMM_M128, NONE), F_660F3A, 1,  no_WDS, 0x1F,     0x00,       P_686|P_AVX,DSIZE|FV, RWF_VEX )
insx(VPCMPNLED,  vpcmpnled,       OpCls( XMM,     XMM_M128, NONE), F_660F3A, 1,  no_WDS, 0x1F,     0x00,       P_686|P_AVX,DSIZE|FV, RWF_VEX )
insx(VPCMPTRUED, vpcmptrued,      OpCls( XMM,     XMM_M128, NONE), F_660F3A, 1,  no_WDS, 0x1F,     0x00,       P_686|P_AVX,DSIZE|FV, RWF_VEX )

insx(VPCMPEQUD,   vpcmpequd,      OpCls( XMM,     XMM_M128, HID ), F_660F3A, 1,  no_WDS, 0x1E,     0x00,       P_686|P_AVX,DSIZE|FV, RWF_VEX )
insx(VPCMPLTUD,   vpcmpltud,      OpCls( XMM,     XMM_M128, HID ), F_660F3A, 1,  no_WDS, 0x1E,     0x00,       P_686|P_AVX,DSIZE|FV, RWF_VEX )
insx(VPCMPLEUD,   vpcmpleud,      OpCls( XMM,     XMM_M128, HID ), F_660F3A, 1,  no_WDS, 0x1E,     0x00,       P_686|P_AVX,DSIZE|FV, RWF_VEX )
insx(VPCMPFALSEUD,vpcmpfalseud,   OpCls( XMM,     XMM_M128, HID ), F_660F3A, 1,  no_WDS, 0x1E,     0x00,       P_686|P_AVX,DSIZE|FV, RWF_VEX )
insx(VPCMPNEQUD,  vpcmpnequd,     OpCls( XMM,     XMM_M128, HID ), F_660F3A, 1,  no_WDS, 0x1E,     0x00,       P_686|P_AVX,DSIZE|FV, RWF_VEX )
insx(VPCMPNLTUD,  vpcmpnltud,     OpCls( XMM,     XMM_M128, HID ), F_660F3A, 1,  no_WDS, 0x1E,     0x00,       P_686|P_AVX,DSIZE|FV, RWF_VEX )
insx(VPCMPNLEUD,  vpcmpnleud,     OpCls( XMM,     XMM_M128, HID ), F_660F3A, 1,  no_WDS, 0x1E,     0x00,       P_686|P_AVX,DSIZE|FV, RWF_VEX )
insx(VPCMPTRUEUD, vpcmptrueud,    OpCls( XMM,     XMM_M128, HID ), F_660F3A, 1,  no_WDS, 0x1E,     0x00,       P_686|P_AVX,DSIZE|FV, RWF_VEX )
//ins (PCMPEQQ, pcmpeqq,          OpCls( XMM,      XMM_M128, NONE ), F_660F38, 1,  no_WDS, 0x29,     0x00,       P_686|P_SSE4, 0)
//insx(VPCMPEQQ,    vpcmpeqq,       OpCls( XMM,     XMM_M128, NONE), F_660F38, 1,  no_WDS, 0x29,     0x00,       P_686|P_AVX,W1|QSIZE|FV, RWF_VEX )
insx(VPCMPLTQ,    vpcmpltq,       OpCls( XMM,     XMM_M128, NONE), F_660F3A, 1,  no_WDS, 0x1F,     0x00,       P_686|P_AVX,W1|QSIZE|FV, RWF_VEX )
insx(VPCMPLEQ,    vpcmpleq,       OpCls( XMM,     XMM_M128, NONE), F_660F3A, 1,  no_WDS, 0x1F,     0x00,       P_686|P_AVX,W1|QSIZE|FV, RWF_VEX )
insx(VPCMPFALSEQ, vpcmpfalseq,    OpCls( XMM,     XMM_M128, NONE), F_660F3A, 1,  no_WDS, 0x1F,     0x00,       P_686|P_AVX,W1|QSIZE|FV, RWF_VEX )
insx(VPCMPNEQQ,   vpcmpneqq,      OpCls( XMM,     XMM_M128, NONE), F_660F3A, 1,  no_WDS, 0x1F,     0x00,       P_686|P_AVX,W1|QSIZE|FV, RWF_VEX )
insx(VPCMPNLTQ,   vpcmpnltq,      OpCls( XMM,     XMM_M128, NONE), F_660F3A, 1,  no_WDS, 0x1F,     0x00,       P_686|P_AVX,W1|QSIZE|FV, RWF_VEX )
insx(VPCMPNLEQ,   vpcmpnleq,      OpCls( XMM,     XMM_M128, NONE), F_660F3A, 1,  no_WDS, 0x1F,     0x00,       P_686|P_AVX,W1|QSIZE|FV, RWF_VEX )
insx(VPCMPTRUEQ,  vpcmptrueq,     OpCls( XMM,     XMM_M128, NONE), F_660F3A, 1,  no_WDS, 0x1F,     0x00,       P_686|P_AVX,W1|QSIZE|FV, RWF_VEX )

insx(VPCMPEQUQ,   vpcmpequq,      OpCls( XMM,     XMM_M128, NONE), F_660F3A, 1,  no_WDS, 0x1E,     0x00,       P_686|P_AVX,W1|QSIZE|FV, RWF_VEX )
insx(VPCMPLTUQ,   vpcmpltuq,      OpCls( XMM,     XMM_M128, NONE), F_660F3A, 1,  no_WDS, 0x1E,     0x00,       P_686|P_AVX,W1|QSIZE|FV, RWF_VEX )
insx(VPCMPLEUQ,   vpcmpleuq,      OpCls( XMM,     XMM_M128, NONE), F_660F3A, 1,  no_WDS, 0x1E,     0x00,       P_686|P_AVX,W1|QSIZE|FV, RWF_VEX )
insx(VPCMPFALSEUQ,vpcmpfalseuq,   OpCls( XMM,     XMM_M128, NONE), F_660F3A, 1,  no_WDS, 0x1E,     0x00,       P_686|P_AVX,W1|QSIZE|FV, RWF_VEX )
insx(VPCMPNEQUQ,  vpcmpnequq,     OpCls( XMM,     XMM_M128, NONE), F_660F3A, 1,  no_WDS, 0x1E,     0x00,       P_686|P_AVX,W1|QSIZE|FV, RWF_VEX )
insx(VPCMPNLTUQ,  vpcmpnltuq,     OpCls( XMM,     XMM_M128, NONE), F_660F3A, 1,  no_WDS, 0x1E,     0x00,       P_686|P_AVX,W1|QSIZE|FV, RWF_VEX )
insx(VPCMPNLEUQ,  vpcmpnleuq,     OpCls( XMM,     XMM_M128, NONE), F_660F3A, 1,  no_WDS, 0x1E,     0x00,       P_686|P_AVX,W1|QSIZE|FV, RWF_VEX )
insx(VPCMPTRUEUQ, vpcmptrueuq,    OpCls( XMM,     XMM_M128, NONE), F_660F3A, 1,  no_WDS, 0x1E,     0x00,       P_686|P_AVX,W1|QSIZE|FV, RWF_VEX )

//insx(VPCMPEQW,    vpcmpeqw,       OpCls( XMM,     XMM_M128, NONE), F_660F3A, 1,  no_WDS, 0x3F,     0x00,       P_686|P_AVX,W1|QSIZE|FVM, RWF_VEX )
insx(VPCMPLTW,    vpcmpltw,       OpCls( XMM,     XMM_M128, NONE), F_660F3A, 1,  no_WDS, 0x3F,     0x00,       P_686|P_AVX,W1|QSIZE|FVM, RWF_VEX )
insx(VPCMPLEW,    vpcmplew,       OpCls( XMM,     XMM_M128, NONE), F_660F3A, 1,  no_WDS, 0x3F,     0x00,       P_686|P_AVX,W1|QSIZE|FVM, RWF_VEX )
insx(VPCMPFALSEW, vpcmpfalsew,    OpCls( XMM,     XMM_M128, NONE), F_660F3A, 1,  no_WDS, 0x3F,     0x00,       P_686|P_AVX,W1|QSIZE|FVM, RWF_VEX )
insx(VPCMPNEQW,   vpcmpneqw,      OpCls( XMM,     XMM_M128, NONE), F_660F3A, 1,  no_WDS, 0x3F,     0x00,       P_686|P_AVX,W1|QSIZE|FVM, RWF_VEX )
insx(VPCMPNLTW,   vpcmpnltw,      OpCls( XMM,     XMM_M128, NONE), F_660F3A, 1,  no_WDS, 0x3F,     0x00,       P_686|P_AVX,W1|QSIZE|FVM, RWF_VEX )
insx(VPCMPNLEW,   vpcmpnlew,      OpCls( XMM,     XMM_M128, NONE), F_660F3A, 1,  no_WDS, 0x3F,     0x00,       P_686|P_AVX,W1|QSIZE|FVM, RWF_VEX )
insx(VPCMPTRUEW,  vpcmptruew,     OpCls( XMM,     XMM_M128, NONE), F_660F3A, 1,  no_WDS, 0x3F,     0x00,       P_686|P_AVX,W1|QSIZE|FVM, RWF_VEX )

insx(VPCMPEQUW,   vpcmpequw,      OpCls( XMM,     XMM_M128, NONE), F_660F3A, 1,  no_WDS, 0x3E,     0x00,       P_686|P_AVX,W1|QSIZE|FVM, RWF_VEX )
insx(VPCMPLTUW,   vpcmpltuw,      OpCls( XMM,     XMM_M128, NONE), F_660F3A, 1,  no_WDS, 0x3E,     0x00,       P_686|P_AVX,W1|QSIZE|FVM, RWF_VEX )
insx(VPCMPLEUW,   vpcmpleuw,      OpCls( XMM,     XMM_M128, NONE), F_660F3A, 1,  no_WDS, 0x3E,     0x00,       P_686|P_AVX,W1|QSIZE|FVM, RWF_VEX )
insx(VPCMPFALSEUW,vpcmpfalseuw,   OpCls( XMM,     XMM_M128, NONE), F_660F3A, 1,  no_WDS, 0x3E,     0x00,       P_686|P_AVX,W1|QSIZE|FVM, RWF_VEX )
insx(VPCMPNEQUW,  vpcmpnequw,     OpCls( XMM,     XMM_M128, NONE), F_660F3A, 1,  no_WDS, 0x3E,     0x00,       P_686|P_AVX,W1|QSIZE|FVM, RWF_VEX )
insx(VPCMPNLTUW,  vpcmpnltuw,     OpCls( XMM,     XMM_M128, NONE), F_660F3A, 1,  no_WDS, 0x3E,     0x00,       P_686|P_AVX,W1|QSIZE|FVM, RWF_VEX )
insx(VPCMPNLEUW,  vpcmpnleuw,     OpCls( XMM,     XMM_M128, NONE), F_660F3A, 1,  no_WDS, 0x3E,     0x00,       P_686|P_AVX,W1|QSIZE|FVM, RWF_VEX )
insx(VPCMPTRUEUW, vpcmptrueuw,    OpCls( XMM,     XMM_M128, NONE), F_660F3A, 1,  no_WDS, 0x3E,     0x00,       P_686|P_AVX,W1|QSIZE|FVM, RWF_VEX )

//insx(VPCMPEQB,   vpcmpeqb,        OpCls( XMM,     XMM_M128, NONE), F_660F3A, 1,  no_WDS, 0x3F,     0x00,       P_686|P_AVX,BSIZE|FVM, RWF_VEX )
insx(VPCMPLTB,   vpcmpltb,        OpCls( XMM,     XMM_M128, NONE), F_660F3A, 1,  no_WDS, 0x3F,     0x00,       P_686|P_AVX,BSIZE|FVM, RWF_VEX )
insx(VPCMPLEB,   vpcmpleb,        OpCls( XMM,     XMM_M128, NONE), F_660F3A, 1,  no_WDS, 0x3F,     0x00,       P_686|P_AVX,BSIZE|FVM, RWF_VEX )
insx(VPCMPFALSEB,vpcmpfalseb,     OpCls( XMM,     XMM_M128, NONE), F_660F3A, 1,  no_WDS, 0x3F,     0x00,       P_686|P_AVX,BSIZE|FVM, RWF_VEX )
insx(VPCMPNEQB,  vpcmpneqb,       OpCls( XMM,     XMM_M128, NONE), F_660F3A, 1,  no_WDS, 0x3F,     0x00,       P_686|P_AVX,BSIZE|FVM, RWF_VEX )
insx(VPCMPNLTB,  vpcmpnltb,       OpCls( XMM,     XMM_M128, NONE), F_660F3A, 1,  no_WDS, 0x3F,     0x00,       P_686|P_AVX,BSIZE|FVM, RWF_VEX )
insx(VPCMPNLEB,  vpcmpnleb,       OpCls( XMM,     XMM_M128, NONE), F_660F3A, 1,  no_WDS, 0x3F,     0x00,       P_686|P_AVX,BSIZE|FVM, RWF_VEX )
insx(VPCMPTRUEB, vpcmptrueb,      OpCls( XMM,     XMM_M128, NONE), F_660F3A, 1,  no_WDS, 0x3F,     0x00,       P_686|P_AVX,BSIZE|FVM, RWF_VEX )

insx(VPCMPEQUB,   vpcmpequb,      OpCls( XMM,     XMM_M128, NONE), F_660F3A, 1,  no_WDS, 0x3E,     0x00,       P_686|P_AVX,BSIZE|FVM, RWF_VEX )
insx(VPCMPLTUB,   vpcmpltub,      OpCls( XMM,     XMM_M128, NONE), F_660F3A, 1,  no_WDS, 0x3E,     0x00,       P_686|P_AVX,BSIZE|FVM, RWF_VEX )
insx(VPCMPLEUB,   vpcmpleub,      OpCls( XMM,     XMM_M128, NONE), F_660F3A, 1,  no_WDS, 0x3E,     0x00,       P_686|P_AVX,BSIZE|FVM, RWF_VEX )
insx(VPCMPFALSEUB,vpcmpfalseub,   OpCls( XMM,     XMM_M128, NONE), F_660F3A, 1,  no_WDS, 0x3E,     0x00,       P_686|P_AVX,BSIZE|FVM, RWF_VEX )
insx(VPCMPNEQUB,  vpcmpnequb,     OpCls( XMM,     XMM_M128, NONE), F_660F3A, 1,  no_WDS, 0x3E,     0x00,       P_686|P_AVX,BSIZE|FVM, RWF_VEX )
insx(VPCMPNLTUB,  vpcmpnltub,     OpCls( XMM,     XMM_M128, NONE), F_660F3A, 1,  no_WDS, 0x3E,     0x00,       P_686|P_AVX,BSIZE|FVM, RWF_VEX )
insx(VPCMPNLEUB,  vpcmpnleub,     OpCls( XMM,     XMM_M128, NONE), F_660F3A, 1,  no_WDS, 0x3E,     0x00,       P_686|P_AVX,BSIZE|FVM, RWF_VEX )
insx(VPCMPTRUEUB, vpcmptrueub,    OpCls( XMM,     XMM_M128, NONE), F_660F3A, 1,  no_WDS, 0x3E,     0x00,       P_686|P_AVX,BSIZE|FVM, RWF_VEX )
insx(VPERMD, vpermd,              OpCls( XMM,     XMM_M128, NONE), F_660F38, 1,  no_WDS, 0x36,     0x00,       P_686|P_AVX,DSIZE|FV,RWF_VEX )
insx(VPERMW, vpermw,              OpCls( XMM,     XMM_M128, NONE), F_660F38, 1,  no_WDS, 0x8D,     0x00,       P_686|P_AVX,W1|IZSZ|WSIZE|FV,RWF_EVEX|RWF_VEX )
insx(VPERMB, vpermb,              OpCls( XMM,     XMM_M128, NONE), F_660F38, 1,  no_WDS, 0x8D,     0x00,       P_686|P_AVX,IZSZ|BSIZE|FV,RWF_EVEX|RWF_VEX )

insx(VPEXPANDD, vpexpandd,        OpCls( XMM,     XMM_M128, NONE), F_660F38, 1,  no_WDS, 0x89,     0x00,       P_686|P_AVX,IZSZ|DSIZE|T1S,RWF_EVEX|RWF_VEX )
insx(VPEXPANDQ, vpexpandq,        OpCls( XMM,     XMM_M128, NONE), F_660F38, 1,  no_WDS, 0x89,     0x00,       P_686|P_AVX,IZSZ|QSIZE|T1S|W1,RWF_EVEX|RWF_VEX)
insx(VPMAXSQ, vpmaxsq,            OpCls( XMM,     XMM_M128, NONE), F_660F38, 1,  no_WDS, 0x3D,     0x00,       P_686|P_AVX,W1|IZSZ|QSIZE|FV,RWF_EVEX|RWF_VEX)
insx(VPMAXUQ, vpmaxuq,            OpCls( XMM,     XMM_M128, NONE), F_660F38, 1,  no_WDS, 0x3F,     0x00,       P_686|P_AVX,W1|IZSZ|QSIZE|FV,RWF_EVEX|RWF_VEX)
insx(VPMINSQ, vpminsq,            OpCls( XMM,     XMM_M128, NONE), F_660F38, 1,  no_WDS, 0x39,     0x00,       P_686|P_AVX,W1|IZSZ|QSIZE|FV,RWF_EVEX|RWF_VEX)
insx(VPMINUQ, vpminuq,            OpCls( XMM,     XMM_M128, NONE), F_660F38, 1,  no_WDS, 0x3B,     0x00,       P_686|P_AVX,W1|IZSZ|QSIZE|FV,RWF_EVEX|RWF_VEX)
insx(VPORD,   vpord,              OpCls( XMM,     XMM_M128, NONE), F_660F,   1,  no_WDS, 0xEB,     0x00,       P_686|P_AVX,IZSZ|DSIZE|FV,RWF_EVEX|RWF_VEX)
insx(VPORQ,   vporq,              OpCls( XMM,     XMM_M128, NONE), F_660F,   1,  no_WDS, 0xEB,     0x00,       P_686|P_AVX,W1|IZSZ|QSIZE|FV,RWF_EVEX|RWF_VEX)
insx(VPSLLVD, vpsllvd,            OpCls( XMM,     XMM_M128, NONE), F_660F38, 1,  no_WDS, 0x47,     0x00,       P_686|P_AVX,DSIZE|FV,RWF_EVEX|RWF_VEX)
insx(VPSLLVQ, vpsllvq,            OpCls( XMM,     XMM_M128, NONE), F_660F38, 1,  no_WDS, 0x47,     0x00,       P_686|P_AVX,W1|QSIZE|FV,RWF_EVEX|RWF_VEX)
insx(VPSLLVW, vpsllvw,            OpCls( XMM,     XMM_M128, NONE), F_660F38, 1,  no_WDS, 0x12,     0x00,       P_686|P_AVX,W1|WSIZE|FVM,RWF_EVEX|RWF_VEX)
//EVEX.NDD.128.66.0F.W0 72 /1 ib FV-VMI VPROLD xmm1 {k1}{z}, xmm2/m128/m32bcst, imm8

insx(VPROLD,  vprold,       OpCls( XMM,      I8_U,      NONE ), F_660F,   0,  no_WDS,0x72,     0x08,     P_686|P_AVX,IZSZ|DSIZE|FV,RWF_EVEX|RWF_VEX)
insx(VPROLVD, vprolvd,      OpCls( XMM,      XMM_M128,  NONE ), F_660F38, 1,  no_WDS,0x15,     0x00,     P_686|P_AVX,IZSZ|DSIZE|FV,RWF_EVEX|RWF_VEX)
insx(VPROLQ,  vprolq,       OpCls( XMM,      I8_U,      NONE ), F_660F,   0,  no_WDS,0x72,     0x08,     P_686|P_AVX,W1|IZSZ|QSIZE|FV,RWF_EVEX|RWF_VEX)
insx(VPROLVQ, vprolvq,      OpCls( XMM,      XMM_M128,  NONE ), F_660F38, 1,  no_WDS,0x15,     0x00,     P_686|P_AVX,W1|IZSZ|QSIZE|FV,RWF_EVEX|RWF_VEX)
insx(VPRORD,  vprord,       OpCls( XMM,      I8_U,      NONE ), F_660F,   0,  no_WDS,0x72,     0x00,     P_686|P_AVX,IZSZ|DSIZE|FV,RWF_EVEX|RWF_VEX)
insx(VPRORVD, vprorvd,      OpCls( XMM,      XMM_M128,  NONE ), F_660F38, 1,  no_WDS,0x14,     0x00,     P_686|P_AVX,IZSZ|DSIZE|FV,RWF_EVEX|RWF_VEX)
insx(VPRORQ,  vprorq,       OpCls( XMM,      I8_U,      NONE ), F_660F,   0,  no_WDS,0x72,     0x00,     P_686|P_AVX,W1|IZSZ|QSIZE|FV,RWF_EVEX|RWF_VEX)
insx(VPRORVQ, vprorvq,      OpCls( XMM,      XMM_M128,  NONE ), F_660F38, 1,  no_WDS,0x14,     0x00,     P_686|P_AVX,W1|IZSZ|QSIZE|FV,RWF_EVEX|RWF_VEX)
/* moved to line 1016 for easyer handling Uasm 2.16 */
//insx(VPSRAQ, vpsraq,        OpCls( XMM,      I8_U,      NONE ), F_660F,   0,  no_WDS,0x72,     0x20,     P_686|P_AVX,W1|QSIZE|FV,RWF_EVEX|RWF_VEX|VX_DST)
//insn(VPSRAQ, 1,             OpCls( XMM,      XMM_M128,  NONE ), F_660F,   1,  no_WDS,0xE2,     0x00,     P_686|P_AVX,W1|QSIZE|T128)
insx(VPSRAVD, vpsravd,      OpCls( XMM,      XMM_M128,  NONE ), F_660F38, 1,  no_WDS,0x46,     0x00,     P_686|P_AVX,DSIZE|FV,RWF_EVEX|RWF_VEX)
insx(VPSRAVQ, vpsravq,      OpCls( XMM,      XMM_M128,  NONE ), F_660F38, 1,  no_WDS,0x46,     0x00,     P_686|P_AVX,W1|IZSZ|QSIZE|FV,RWF_EVEX|RWF_VEX)
insx(VPSRAVW, vpsravw,      OpCls( XMM,      XMM_M128,  NONE ), F_660F38, 1,  no_WDS,0x11,     0x00,     P_686|P_AVX,W1|IZSZ|WSIZE|FVM,RWF_EVEX|RWF_VEX)
insx(VPSRLVD, vpsrlvd,      OpCls( XMM,      XMM_M128,  NONE ), F_660F38, 1,  no_WDS,0x45,     0x00,     P_686|P_AVX,DSIZE|FV,RWF_EVEX|RWF_VEX)
insx(VPSRLVQ, vpsrlvq,      OpCls( XMM,      XMM_M128,  NONE ), F_660F38, 1,  no_WDS,0x45,     0x00,     P_686|P_AVX,W1|IZSZ|QSIZE|FV,RWF_EVEX|RWF_VEX)
insx(VPSRLVW, vpsrlvw,      OpCls( XMM,      XMM_M128,  NONE ), F_660F38, 1,  no_WDS,0x10,     0x00,     P_686|P_AVX,W1|IZSZ|WSIZE|FVM,RWF_EVEX|RWF_VEX)
insx(VPTESTMB, vptestmb,    OpCls( XMM,      XMM_M128,  NONE ), F_660F38, 1,  no_WDS,0x26,     0x00,     P_686|P_AVX,IZSZ|BSIZE|FVM,RWF_EVEX|RWF_VEX)
insx(VPTESTMW, vptestmw,    OpCls( XMM,      XMM_M128,  NONE ), F_660F38, 1,  no_WDS,0x26,     0x00,     P_686|P_AVX,W1|IZSZ|WSIZE|FVM,RWF_EVEX|RWF_VEX)
insx(VPTESTMD, vptestmd,    OpCls( XMM,      XMM_M128,  NONE ), F_660F38, 1,  no_WDS,0x27,     0x00,     P_686|P_AVX,IZSZ|DSIZE|FV,RWF_EVEX|RWF_VEX)
insx(VPTESTMQ, vptestmq,    OpCls( XMM,      XMM_M128,  NONE ), F_660F38, 1,  no_WDS,0x27,     0x00,     P_686|P_AVX,W1|IZSZ|QSIZE|FV,RWF_EVEX|RWF_VEX)
insx(VPTESTNMB, vptestnmb,  OpCls( XMM,      XMM_M128,  NONE ), F_F30F38, 1,  no_WDS,0x26,     0x00,     P_686|P_AVX,IZSZ|BSIZE|FVM,RWF_EVEX|RWF_VEX)
insx(VPTESTNMW, vptestnmw,  OpCls( XMM,      XMM_M128,  NONE ), F_F30F38, 1,  no_WDS,0x26,     0x00,     P_686|P_AVX,W1|IZSZ|WSIZE|FVM,RWF_EVEX|RWF_VEX)
insx(VPTESTNMD, vptestnmd,  OpCls( XMM,      XMM_M128,  NONE ), F_F30F38, 1,  no_WDS,0x27,     0x00,     P_686|P_AVX,IZSZ|DSIZE|FV,RWF_EVEX|RWF_VEX)
insx(VPTESTNMQ, vptestnmq,  OpCls( XMM,      XMM_M128,  NONE ), F_F30F38, 1,  no_WDS,0x27,     0x00,     P_686|P_AVX,W1|IZSZ|QSIZE|FV,RWF_EVEX|RWF_VEX)
insx(VREDUCEPD, vreducepd,  OpCls( XMM,  XMM_M128, I8_U ),F_660F3A, 1,  no_WDS,0x56,     0x00,     P_686|P_AVX,W1|IZSZ|QSIZE|FV, RWF_EVEX|RWF_VEX )                                                                                                                       
insx(VREDUCESD, vreducesd,  OpCls( XMM,  XMM_M128, I8_U ),F_660F3A, 1,  no_WDS,0x57,     0x00,     P_686|P_AVX,W1|IZSZ|QSIZE|T1S, RWF_EVEX|RWF_VEX )
insx(VREDUCEPS, vreduceps,  OpCls( XMM,  XMM_M128, I8_U ),F_660F3A, 1,  no_WDS,0x56,     0x00,     P_686|P_AVX,IZSZ|DSIZE|FV, RWF_EVEX|RWF_VEX )                                                                                                                       
insx(VREDUCESS, vreducess,  OpCls( XMM,  XMM_M128, I8_U ),F_660F3A, 1,  no_WDS,0x57,     0x00,     P_686|P_AVX,IZSZ|DSIZE|T1S, RWF_EVEX|RWF_VEX )


insx(VPXORD, vpxord,        OpCls( XMM,      XMM_M128,  NONE ), F_660F,   1,  no_WDS,0xEF,     0x00,     P_686|P_AVX,IZSZ|DSIZE|FV,RWF_EVEX|RWF_VEX)
insx(VPXORQ, vpxorq,        OpCls( XMM,      XMM_M128,  NONE ), F_660F,   1,  no_WDS,0xEF,     0x00,     P_686|P_AVX,W1|IZSZ|QSIZE|FV,RWF_EVEX|RWF_VEX)
insx(VRCP14PD, vrcp14pd,    OpCls( XMM,      XMM_M128,  NONE ), F_660F38, 1,  no_WDS,0x4C,     0x00,     P_686|P_AVX,W1|IZSZ|QSIZE|FV,RWF_EVEX|RWF_VEX)
insx(VRCP14SD, vrcp14sd,    OpCls( XMM,      XMM_M128,  NONE ), F_660F38, 1,  no_WDS,0x4D,     0x00,     P_686|P_AVX,W1|IZSZ|QSIZE|T1S,RWF_EVEX|RWF_VEX)
insx(VRCP14PS, vrcp14ps,    OpCls( XMM,      XMM_M128,  NONE ), F_660F38, 1,  no_WDS,0x4C,     0x00,     P_686|P_AVX,IZSZ|DSIZE|FV,RWF_EVEX|RWF_VEX)
insx(VRCP14SS, vrcp14ss,    OpCls( XMM,      XMM_M128,  NONE ), F_660F38, 1,  no_WDS,0x4D,     0x00,     P_686|P_AVX,IZSZ|DSIZE|T1S,RWF_EVEX|RWF_VEX)

insx(VRSQRT14PD, vrsqrt14pd,    OpCls( XMM,      XMM_M128,  NONE ), F_660F38, 1,  no_WDS,0x4E,     0x00,     P_686|P_AVX,W1|IZSZ|QSIZE|FV,RWF_EVEX|RWF_VEX)
insx(VRSQRT14SD, vrsqrt14sd,    OpCls( XMM,      XMM_M128,  NONE ), F_660F38, 1,  no_WDS,0x4F,     0x00,     P_686|P_AVX,W1|IZSZ|QSIZE|T1S,RWF_EVEX|RWF_VEX)
insx(VRSQRT14PS, vrsqrt14ps,    OpCls( XMM,      XMM_M128,  NONE ), F_660F38, 1,  no_WDS,0x4E,     0x00,     P_686|P_AVX,IZSZ|DSIZE|FV,RWF_EVEX|RWF_VEX)
insx(VRSQRT14SS, vrsqrt14ss,    OpCls( XMM,      XMM_M128,  NONE ), F_660F38, 1,  no_WDS,0x4F,     0x00,     P_686|P_AVX,IZSZ|DSIZE|T1S,RWF_EVEX|RWF_VEX)
insx(VRCP28PD,   vrcp28pd,      OpCls( XMM,      XMM_M128,  NONE ), F_660F38, 1,  no_WDS,0xCA,     0x00,     P_686|P_AVX,W1|IZSZ|QSIZE|FV,RWF_EVEX|RWF_VEX)
insx(VRCP28PS,   vrcp28ps,      OpCls( XMM,      XMM_M128,  NONE ), F_660F38, 1,  no_WDS,0xCA,     0x00,     P_686|P_AVX,IZSZ|DSIZE|FV,RWF_EVEX|RWF_VEX)
insx(VRCP28SD,   vrcp28sd,      OpCls( XMM,      XMM_M128,  NONE ), F_660F38, 1,  no_WDS,0xCB,     0x00,     P_686|P_AVX,W1|IZSZ|QSIZE|T1S,RWF_EVEX|RWF_VEX)
insx(VRCP28SS,   vrcp28ss,      OpCls( XMM,      XMM_M128,  NONE ), F_660F38, 1,  no_WDS,0xCB,     0x00,     P_686|P_AVX,IZSZ|DSIZE|T1S,RWF_EVEX|RWF_VEX)
insx(VRSQRT28PD, vrsqrt28pd,    OpCls( XMM,      XMM_M128,  NONE ), F_660F38, 1,  no_WDS,0xCC,     0x00,     P_686|P_AVX,W1|IZSZ|QSIZE|FV,RWF_EVEX|RWF_VEX)
insx(VRSQRT28PS, vrsqrt28ps,    OpCls( XMM,      XMM_M128,  NONE ), F_660F38, 1,  no_WDS,0xCC,     0x00,     P_686|P_AVX,IZSZ|DSIZE|FV,RWF_EVEX|RWF_VEX)
insx(VRSQRT28SD, vrsqrt28sd,    OpCls( XMM,      XMM_M128,  NONE ), F_660F38, 1,  no_WDS,0xCD,     0x00,     P_686|P_AVX,W1|IZSZ|QSIZE|T1S,RWF_EVEX|RWF_VEX)
insx(VRSQRT28SS, vrsqrt28ss,    OpCls( XMM,      XMM_M128,  NONE ), F_660F38, 1,  no_WDS,0xCD,     0x00,     P_686|P_AVX,IZSZ|DSIZE|T1S,RWF_EVEX|RWF_VEX)
insx(VEXP2PD,    vexp2pd,       OpCls( XMM,      XMM_M128,  NONE ), F_660F38, 1,  no_WDS,0xC8,     0x00,     P_686|P_AVX,W1|IZSZ|QSIZE|FV,RWF_EVEX|RWF_VEX)
insx(VEXP2PS,    vexp2ps,       OpCls( XMM,      XMM_M128,  NONE ), F_660F38, 1,  no_WDS,0xC8,     0x00,     P_686|P_AVX,IZSZ|DSIZE|FV,RWF_EVEX|RWF_VEX)

insx(VPTERNLOGD, vpternlogd,    OpCls( XMM,      XMM_M128,  I8_U ), F_660F3A, 1,  no_WDS, 0x25,     0x00,    P_686|P_AVX,IZSZ|DSIZE|FV, RWF_EVEX|RWF_VEX )                                                                                                                       
insx(VPTERNLOGQ, vpternlogq,    OpCls( XMM,      XMM_M128,  I8_U ), F_660F3A, 1,  no_WDS, 0x25,     0x00,    P_686|P_AVX,W1|IZSZ|QSIZE|FV, RWF_EVEX|RWF_VEX )                                                                                                                       
//VPMOVQB,VPMOVSQB,VPMOVUSQB,VPMOVQW,VPMOVSQW,VPMOVUSQW,VPMOVQD,VPMOVSQD,VPMOVUSQD
//VPMOVDB,VPMOVSDB,VPMOVUSDB,VPMOVDW,VPMOVSDW,VPMOVUSDW,VPMOVWB,VPMOVSWB,VPMOVUSWB
insx(VPMOVQB, vpmovqb,          OpCls( XMM_M_ANY,     XMM,       NONE ), F_F30F38,   0,  no_WDS, 0x32,     0x00,    P_686|P_AVX,IZSZ|QSIZE|OVM,RWF_EVEX|RWF_VEX)
insx(VPMOVSQB, vpmovsqb,        OpCls( XMM_M_ANY,     XMM,       NONE ), F_F30F38,   0,  no_WDS, 0x22,     0x00,    P_686|P_AVX,IZSZ|QSIZE|OVM,RWF_EVEX|RWF_VEX)
insx(VPMOVUSQB, vpmovusqb,      OpCls( XMM_M_ANY,     XMM,       NONE ), F_F30F38,   0,  no_WDS, 0x12,     0x00,    P_686|P_AVX,IZSZ|QSIZE|OVM,RWF_EVEX|RWF_VEX)

insx(VPMOVQW, vpmovqw,          OpCls( XMM_M_ANY,     XMM,       NONE ), F_F30F38,   0,  no_WDS, 0x34,     0x00,    P_686|P_AVX,IZSZ|QSIZE|QVM,RWF_EVEX|RWF_VEX)
insx(VPMOVSQW, vpmovsqw,        OpCls( XMM_M_ANY,     XMM,       NONE ), F_F30F38,   0,  no_WDS, 0x24,     0x00,    P_686|P_AVX,IZSZ|QSIZE|QVM,RWF_EVEX|RWF_VEX)
insx(VPMOVUSQW, vpmovusqw,      OpCls( XMM_M_ANY,     XMM,       NONE ), F_F30F38,   0,  no_WDS, 0x14,     0x00,    P_686|P_AVX,IZSZ|QSIZE|QVM,RWF_EVEX|RWF_VEX)

insx(VPMOVQD, vpmovqd,          OpCls( XMM_M_ANY,     XMM,       NONE ), F_F30F38,   0,  no_WDS, 0x35,     0x00,    P_686|P_AVX,IZSZ|QSIZE|HVM,RWF_EVEX|RWF_VEX)
insx(VPMOVSQD, vpmovsqd,        OpCls( XMM_M_ANY,     XMM,       NONE ), F_F30F38,   0,  no_WDS, 0x25,     0x00,    P_686|P_AVX,IZSZ|QSIZE|HVM,RWF_EVEX|RWF_VEX)
insx(VPMOVUSQD, vpmovusqd,      OpCls( XMM_M_ANY,     XMM,       NONE ), F_F30F38,   0,  no_WDS, 0x15,     0x00,    P_686|P_AVX,IZSZ|QSIZE|HVM,RWF_EVEX|RWF_VEX)

insx(VPMOVDB, vpmovdb,          OpCls( XMM_M_ANY,     XMM,       NONE ), F_F30F38,   0,  no_WDS, 0x31,     0x00,    P_686|P_AVX,IZSZ|QSIZE|QVM,RWF_EVEX|RWF_VEX)
insx(VPMOVSDB, vpmovsdb,        OpCls( XMM_M_ANY,     XMM,       NONE ), F_F30F38,   0,  no_WDS, 0x21,     0x00,    P_686|P_AVX,IZSZ|QSIZE|QVM,RWF_EVEX|RWF_VEX)
insx(VPMOVUSDB, vpmovusdb,      OpCls( XMM_M_ANY,     XMM,       NONE ), F_F30F38,   0,  no_WDS, 0x11,     0x00,    P_686|P_AVX,IZSZ|QSIZE|QVM,RWF_EVEX|RWF_VEX)

insx(VPMOVDW, vpmovdw,          OpCls( XMM_M_ANY,     XMM,       NONE ), F_F30F38,   0,  no_WDS, 0x33,     0x00,    P_686|P_AVX,IZSZ|QSIZE|HVM,RWF_EVEX|RWF_VEX)
insx(VPMOVSDW, vpmovsdw,        OpCls( XMM_M_ANY,     XMM,       NONE ), F_F30F38,   0,  no_WDS, 0x23,     0x00,    P_686|P_AVX,IZSZ|QSIZE|HVM,RWF_EVEX|RWF_VEX)
insx(VPMOVUSDW, vpmovusdw,      OpCls( XMM_M_ANY,     XMM,       NONE ), F_F30F38,   0,  no_WDS, 0x13,     0x00,    P_686|P_AVX,IZSZ|QSIZE|HVM,RWF_EVEX|RWF_VEX)

insx(VPMOVWB, vpmovwb,          OpCls( XMM_M_ANY,     XMM,       NONE ), F_F30F38,   0,  no_WDS, 0x30,     0x00,    P_686|P_AVX,IZSZ|WSIZE|HVM,RWF_EVEX|RWF_VEX)
insx(VPMOVSWB, vpmovswb,        OpCls( XMM_M_ANY,     XMM,       NONE ), F_F30F38,   0,  no_WDS, 0x20,     0x00,    P_686|P_AVX,IZSZ|WSIZE|HVM,RWF_EVEX|RWF_VEX)
insx(VPMOVUSWB, vpmovuswb,      OpCls( XMM_M_ANY,     XMM,       NONE ), F_F30F38,   0,  no_WDS, 0x10,     0x00,    P_686|P_AVX,IZSZ|WSIZE|HVM,RWF_EVEX|RWF_VEX)


insx(VSHUFF32X4, vshuff32x4,    OpCls( XMM,      XMM_M128,  I8_U ), F_660F3A, 1,  no_WDS, 0x23,     0x00,    P_686|P_AVX,IZSZ|DSIZE|FV, RWF_EVEX|RWF_VEX )                                                                                                                       
insx(VSHUFF64X2, vshuff64x2,    OpCls( XMM,      XMM_M128,  I8_U ), F_660F3A, 1,  no_WDS, 0x23,     0x00,    P_686|P_AVX,W1|IZSZ|QSIZE|FV, RWF_EVEX|RWF_VEX )                                                                                                                       
insx(VSHUFI32X4, vshufi32x4,    OpCls( XMM,      XMM_M128,  I8_U ), F_660F3A, 1,  no_WDS, 0x43,     0x00,    P_686|P_AVX,IZSZ|DSIZE|FV, RWF_EVEX|RWF_VEX )                                                                                                                            
insx(VSHUFI64X2, vshufi64x2,    OpCls( XMM,      XMM_M128,  I8_U ), F_660F3A, 1,  no_WDS, 0x43,     0x00,    P_686|P_AVX,W1|IZSZ|QSIZE|FV, RWF_EVEX|RWF_VEX )                                                                                                                       
//VPERMW,VPERMB,VPERMI2B,VPERMI2W,VPERMI2D,VPERMI2Q,VPERMI2PS,VPERMI2PD
//VPERMT2B.VPERMT2W,VPERMT2D,VPERMT2Q,VPERMT2PS,VPERMT2PD,VPEXPANDD,VPEXPANDQ

insx(VPERMT2W, vpermt2w,        OpCls( XMM,    XMM_M128,  NONE ), F_660F38, 1,  no_WDS,0x7D,     0x00,     P_686|P_AVX,W1|IZSZ|WSIZE|FVM,RWF_EVEX|RWF_VEX)
insx(VPERMT2D, vpermt2d,        OpCls( XMM,    XMM_M128,  NONE ), F_660F38, 1,  no_WDS,0x7E,     0x00,     P_686|P_AVX,IZSZ|DSIZE|FV,RWF_EVEX|RWF_VEX)
insx(VPERMT2Q, vpermt2q,        OpCls( XMM,    XMM_M128,  NONE ), F_660F38, 1,  no_WDS,0x7E,     0x00,     P_686|P_AVX,W1|IZSZ|QSIZE|FV,RWF_EVEX|RWF_VEX)
insx(VPERMT2PS, vpermt2ps,      OpCls( XMM,    XMM_M128,  NONE ), F_660F38, 1,  no_WDS,0x7F,     0x00,     P_686|P_AVX,IZSZ|DSIZE|FV,RWF_EVEX|RWF_VEX)
insx(VPERMT2PD, vpermt2pd,      OpCls( XMM,    XMM_M128,  NONE ), F_660F38, 1,  no_WDS,0x7F,     0x00,     P_686|P_AVX,W1|IZSZ|QSIZE|FV,RWF_EVEX|RWF_VEX)

insx(VCVTSD2USI, vcvtsd2usi,    OpCls( R32,    XMM_M64,  NONE ), F_F20F, 1,  no_WDS, 0x79,     0x00,       P_686|P_AVX,IZSZ|QSIZE|T1F64,RWF_EVEX|RWF_VEX)
insn(VCVTSD2USI, 1,             OpCls( R64,    XMM_M64,  NONE ), F_F20F, 1,  no_WDS, 0x79,     0x00,       P_686|P_AVX,W1|QSIZE|T1F64)
insx(VCVTSS2USI, vcvtss2usi,    OpCls( R32,    XMM_M32,  NONE ), F_F30F, 1,  no_WDS, 0x79,     0x00,       P_686|P_AVX,IZSZ|DSIZE|T1F32,RWF_EVEX|RWF_VEX)
insn(VCVTSS2USI, 1,             OpCls( R64,    XMM_M32,  NONE ), F_F30F, 1,  no_WDS, 0x79,     0x00,       P_686|P_AVX,W1|DSIZE|T1F32)
insx(VCVTUSI2SD, vcvtusi2sd,    OpCls( XMM,    R32_M32,  NONE ), F_F20F, 1,  no_WDS, 0x7B,     0x00,       P_686|P_AVX,IZSZ|DSIZE|T1S,RWF_EVEX|RWF_VEX)
insn(VCVTUSI2SD, 1,             OpCls( XMM,    R64_M64,  NONE ), F_F20F, 1,  no_WDS, 0x7B,     0x00,       P_686|P_AVX,W1|QSIZE|T1S)
insx(VCVTUSI2SS, vcvtusi2ss,    OpCls( XMM,    R32_M32,  NONE ), F_F30F, 1,  no_WDS, 0x7B,     0x00,       P_686|P_AVX,IZSZ|DSIZE|T1S,RWF_EVEX|RWF_VEX)
insn(VCVTUSI2SS, 1,             OpCls( XMM,    R64_M64,  NONE ), F_F30F, 1,  no_WDS, 0x7B,     0x00,       P_686|P_AVX,W1|QSIZE|T1S)
insx(VSCALEFPD, vscalefpd,    OpCls( XMM,      XMM_M128, NONE ), F_660F38, 1,  no_WDS, 0x2C,     0x00,       P_686|P_AVX,W1|IZSZ|QSIZE|FV,RWF_EVEX|RWF_VEX)
insx(VSCALEFPS, vscalefps,    OpCls( XMM,      XMM_M128, NONE ), F_660F38, 1,  no_WDS, 0x2C,     0x00,       P_686|P_AVX,IZSZ|DSIZE|FV,RWF_EVEX|RWF_VEX)
insx(VSCALEFSD, vscalefsd,    OpCls( XMM,      XMM_M128, NONE ), F_660F38, 1,  no_WDS, 0x2D,     0x00,       P_686|P_AVX,W1|IZSZ|QSIZE|T1S,RWF_EVEX|RWF_VEX)
insx(VSCALEFSS, vscalefss,    OpCls( XMM,      XMM_M128, NONE ), F_660F38, 1,  no_WDS, 0x2D,     0x00,       P_686|P_AVX,IZSZ|DSIZE|T1S,RWF_EVEX|RWF_VEX)

insx(VFIXUPIMMPD, vfixupimmpd, OpCls( XMM,      XMM_M128,  I8_U ), F_660F3A, 1,  no_WDS, 0x54,     0x00,    P_686|P_AVX,W1|IZSZ|QSIZE|FV,RWF_EVEX|RWF_VEX)                                                                                                                      
insx(VFIXUPIMMPS, vfixupimmps, OpCls( XMM,      XMM_M128,  I8_U ), F_660F3A, 1,  no_WDS, 0x54,     0x00,    P_686|P_AVX,IZSZ|DSIZE|FV,RWF_EVEX|RWF_VEX)                                                                                                                      
insx(VFIXUPIMMSD, vfixupimmsd, OpCls( XMM,      XMM_M64,   I8_U ), F_660F3A, 1,  no_WDS, 0x55,     0x00,    P_686|P_AVX,W1|IZSZ|QSIZE|T1S,RWF_EVEX|RWF_VEX)
insx(VFIXUPIMMSS, vfixupimmss, OpCls( XMM,      XMM_M32,   I8_U ), F_660F3A, 1,  no_WDS, 0x55,     0x00,    P_686|P_AVX,IZSZ|DSIZE|T1S,RWF_EVEX|RWF_VEX)

insx(VRNDSCALEPD, vrndscalepd,OpCls( XMM,      XMM_M128,  I8_U ), F_660F3A, 1,  no_WDS,0x09,     0x00,     P_686|P_AVX,W1|IZSZ|QSIZE|FV,RWF_EVEX|RWF_VEX)
insx(VRNDSCALEPS, vrndscaleps,OpCls( XMM,      XMM_M128,  I8_U ), F_660F3A, 1,  no_WDS,0x08,     0x00,     P_686|P_AVX,IZSZ|DSIZE|FV,RWF_EVEX|RWF_VEX)
insx(VRNDSCALESD, vrndscalesd,OpCls( XMM,      XMM_M64,   I8_U ), F_660F3A, 1,  no_WDS,0x0B,     0x00,     P_686|P_AVX,W1|IZSZ|QSIZE|T1S,RWF_EVEX|RWF_VEX)
insx(VRNDSCALESS, vrndscaless,OpCls( XMM,      XMM_M32,   I8_U ), F_660F3A, 1,  no_WDS,0x0A,     0x00,     P_686|P_AVX,IZSZ|DSIZE|T1S,RWF_EVEX|RWF_VEX)

insx (VCVTTPD2UDQ, vcvttpd2udq,OpCls( XMM,     XMM_M128,  NONE ), F_0F,     1,  no_WDS, 0x78,    0x00,     P_686|P_AVX,W1|IZSZ|QSIZE|FV,RWF_EVEX|RWF_VEX)
insx (VCVTTPD2UQQ, vcvttpd2uqq,OpCls( XMM,     XMM_M128,  NONE ), F_660F,   1,  no_WDS, 0x78,    0x00,     P_686|P_AVX,W1|IZSZ|QSIZE|FV,RWF_EVEX|RWF_VEX)

insx (VCVTTPS2UDQ, vcvttps2udq,OpCls( XMM,     XMM_M128,  NONE ), F_0F,     1,  no_WDS, 0x78,    0x00,     P_686|P_AVX,IZSZ|DSIZE|FV,RWF_EVEX|RWF_VEX)
insx (VCVTTPS2UQQ, vcvttps2uqq,OpCls( XMM,     XMM_M128,  NONE ), F_660F,   1,  no_WDS, 0x78,    0x00,     P_686|P_AVX,IZSZ|DSIZE|FV,RWF_EVEX|RWF_VEX)

insx (VCVTTSD2USI, vcvttsd2usi,OpCls( R32,     XMM_M64,  NONE ), F_F20F,    1,  no_WDS, 0x78,    0x00,     P_686|P_AVX,W1|IZSZ|QSIZE|T1F64,RWF_EVEX|RWF_VEX)
insn (VCVTTSD2USI, 1,          OpCls( R64,     XMM_M64,  NONE ), F_F20F,    1,  no_WDS, 0x78,    0x00,     P_686|P_AVX,W1|IZSZ|QSIZE|T1F64)

insx (VCVTTSS2USI, vcvttss2usi,OpCls( R32,     XMM_M32,  NONE ), F_F30F,    1,  no_WDS, 0x78,    0x00,     P_686|P_AVX,IZSZ|DSIZE|T1F32,RWF_EVEX|RWF_VEX)
insn (VCVTTSS2USI, 1,          OpCls( R64,     XMM_M32,  NONE ), F_F30F,    1,  no_WDS, 0x78,    0x00,     P_686|P_AVX,IZSZ|DSIZE|T1F32)

insx(VPERMI2B, vpermi2b,               OpCls( XMM,      XMM_M128,   NONE ), F_660F38,1,  no_WDS, 0x75,     0x00,     P_686|P_AVX, IZSZ|BSIZE|FV, RWF_EVEX|RWF_VEX )
insx(VPERMI2W, vpermi2w,               OpCls( XMM,      XMM_M128,   NONE ), F_660F38,1,  no_WDS, 0x75,     0x00,     P_686|P_AVX, W1|IZSZ|WSIZE|FV, RWF_EVEX|RWF_VEX )
insx(VPERMI2D, vpermi2d,               OpCls( XMM,      XMM_M128,   NONE ), F_660F38,1,  no_WDS, 0x76,     0x00,     P_686|P_AVX, IZSZ|DSIZE|FV, RWF_EVEX|RWF_VEX )
insx(VPERMI2Q, vpermi2q,               OpCls( XMM,      XMM_M128,   NONE ), F_660F38,1,  no_WDS, 0x76,     0x00,     P_686|P_AVX, W1|IZSZ|QSIZE|FV, RWF_EVEX|RWF_VEX )
insx(VPERMI2PS, vpermi2ps,             OpCls( XMM,      XMM_M128,   NONE ), F_660F38,1,  no_WDS, 0x77,     0x00,     P_686|P_AVX, IZSZ|DSIZE|FV, RWF_EVEX|RWF_VEX )
insx(VPERMI2PD, vpermi2pd,             OpCls( XMM,      XMM_M128,   NONE ), F_660F38,1,  no_WDS, 0x77,     0x00,     P_686|P_AVX, W1|IZSZ|QSIZE|FV, RWF_EVEX|RWF_VEX )
insx(VPERM2I128, vperm2i128,           OpCls( YMM,      YMM_M256,   I8_U ), F_660F3A,1,  no_WDS, 0x46,     0x00,     P_686|P_AVX, 0, RWF_VEX )
insx(VINSERTF32x4, vinsertf32x4,       OpCls( XMM,      XMM_M128,   I8_U ), F_660F3A,1,  no_WDS, 0x18,     0x00,     P_686|P_AVX, IZSZ|DSIZE|T4, RWF_EVEX|RWF_VEX )
insx(VINSERTF64x2, vinsertf64x2,       OpCls( XMM,      XMM_M128,   I8_U ), F_660F3A,1,  no_WDS, 0x18,     0x00,     P_686|P_AVX, W1|IZSZ|QSIZE|T2, RWF_EVEX|RWF_VEX )                                                        
insx(VINSERTF32x8, vinsertf32x8,       OpCls( XMM,      XMM_M128,   I8_U ), F_660F3A,1,  no_WDS, 0x1A,     0x00,     P_686|P_AVX, IZSZ|DSIZE|T8, RWF_EVEX|RWF_VEX )
insx(VINSERTF64x4, vinsertf64x4,       OpCls( XMM,      XMM_M128,   I8_U ), F_660F3A,1,  no_WDS, 0x1A,     0x00,     P_686|P_AVX, W1|IZSZ|QSIZE|T4, RWF_EVEX|RWF_VEX )
insx(VINSERTI128,  vinserti128,        OpCls( XMM,      XMM_M128,   I8_U ), F_660F3A,1,  no_WDS, 0x38,     0x00,     P_686|P_AVX, 0, RWF_VEX )
insx(VINSERTF128,  vinsertf128,        OpCls( XMM,      XMM_M128,   I8_U ), F_660F3A,1,  no_WDS, 0x18,     0x00,     P_686|P_AVX, 0, RWF_VEX )
insx(VINSERTI32x4, vinserti32x4,       OpCls( XMM,      XMM_M128,   I8_U ), F_660F3A,1,  no_WDS, 0x38,     0x00,     P_686|P_AVX, IZSZ|DSIZE|T4, RWF_EVEX|RWF_VEX )
insx(VINSERTI64x2, vinserti64x2,       OpCls( XMM,      XMM_M128,   I8_U ), F_660F3A,1,  no_WDS, 0x38,     0x00,     P_686|P_AVX, W1|IZSZ|QSIZE|T2, RWF_EVEX|RWF_VEX )
insx(VINSERTI32x8, vinserti32x8,       OpCls( XMM,      XMM_M128,   I8_U ), F_660F3A,1,  no_WDS, 0x3A,     0x00,     P_686|P_AVX, IZSZ|DSIZE|T8, RWF_EVEX|RWF_VEX )
insx(VINSERTI64x4, vinserti64x4,       OpCls( XMM,      XMM_M128,   I8_U ), F_660F3A,1,  no_WDS, 0x3A,     0x00,     P_686|P_AVX, W1|IZSZ|QSIZE|T4, RWF_EVEX|RWF_VEX )
//EVEX.NDS.128.66.0F38.W1 83 /r FV VPMULTISHIFTQB xmm1{k1}{z},xmm2,xmm3/m128/m64bcst
//insx(VPMULTISHIFTQB, vpmultishiftqb,   OpCls( XMM,      XMM_M128,   NONE ), F_660F38,1,  no_WDS, 0x83,     0x00,     P_686|P_AVX, W1|IZSZ|QSIZE|FV, RWF_EVEX|RWF_VEX )


insx(VMOVDQU8, vmovdqu8,     OpCls( XMM,      XMM_M128, NONE ), F_F20F, 1,  no_WDS, 0x6F,     0x00,       P_686|P_AVX,IZSZ|BSIZE|FVM,RWF_EVEX|RWF_VEX)
insn(VMOVDQU8, 1,            OpCls( M128,     XMM,      NONE ), F_F20F, 0,  no_WDS, 0x7F,     0x00,       P_686|P_AVX,IZSZ|BSIZE|FVM)
insx(VMOVDQU16, vmovdqu16,   OpCls( XMM,      XMM_M128, NONE ), F_F20F, 1,  no_WDS, 0x6F,     0x00,       P_686|P_AVX,W1|IZSZ|WSIZE|FVM,RWF_EVEX|RWF_VEX)
insn(VMOVDQU16, 1,           OpCls( M128,     XMM,      NONE ), F_F20F, 0,  no_WDS, 0x7F,     0x00,       P_686|P_AVX,W1|IZSZ|WSIZE|FVM)


insx(VMOVDQA32, vmovdqa32,    OpCls( XMM,      XMM_M128, NONE ), F_660F, 1,  no_WDS, 0x6F,     0x00,      P_686|P_AVX,IZSZ|DSIZE|FVM,RWF_EVEX|RWF_VEX)
insn(VMOVDQA32, 1,            OpCls( M128,     XMM,      NONE ), F_660F, 0,  no_WDS, 0x7F,     0x00,      P_686|P_AVX,IZSZ|DSIZE|FVM)
insx(VMOVDQU32, vmovdqu32,    OpCls( XMM,      XMM_M128, NONE ), F_F30F, 1,  no_WDS, 0x6F,     0x00,      P_686|P_AVX,IZSZ|DSIZE|FVM,RWF_EVEX|RWF_VEX)
insn(VMOVDQU32, 1,            OpCls( M128,     XMM,      NONE ), F_F30F, 0,  no_WDS, 0x7F,     0x00,      P_686|P_AVX,IZSZ|DSIZE|FVM)

insx(VMOVDQA64, vmovdqa64,    OpCls( XMM,      XMM_M128, NONE ), F_660F, 1,  no_WDS, 0x6F,     0x00,      P_686|P_AVX,W1|IZSZ|QSIZE|FVM,RWF_EVEX|RWF_VEX)
insn(VMOVDQA64, 1,            OpCls( M128,     XMM,      NONE ), F_660F, 0,  no_WDS, 0x7F,     0x00,      P_686|P_AVX,W1|IZSZ|QSIZE|FVM)
insx(VMOVDQU64, vmovdqu64,    OpCls( XMM,      XMM_M128, NONE ), F_F30F, 1,  no_WDS, 0x6F,     0x00,      P_686|P_AVX,W1|IZSZ|QSIZE|FVM,RWF_EVEX|RWF_VEX)
insn(VMOVDQU64, 1,            OpCls( M128,     XMM,      NONE ), F_F30F, 0,  no_WDS, 0x7F,     0x00,      P_686|P_AVX,W1|IZSZ|QSIZE|FVM)
 
insx(VDBPSADBW, vdbpsadbw,    OpCls( XMM,      XMM_M128, I8_U ), F_660F3A, 1, no_WDS,0x42,     0x00,      P_686|P_AVX, IZSZ|DSIZE|FVM, RWF_EVEX|RWF_VEX )
insx(VFPCLASSPD, vfpclasspd,  OpCls( XMM,      XMM_M128, I8_U ), F_660F3A, 1, no_WDS,0x66,     0x00,      P_686|P_AVX,W1|IZSZ|QSIZE|FV, RWF_EVEX|RWF_VEX )                                                                                                                       
insx(VFPCLASSPS, vfpclassps,  OpCls( XMM,      XMM_M128, I8_U ), F_660F3A, 1, no_WDS,0x66,     0x00,      P_686|P_AVX,IZSZ|DSIZE|FV, RWF_EVEX|RWF_VEX )                                                                                                                       
insx(VFPCLASSSD, vfpclasssd,  OpCls( XMM,      XMM_M128, I8_U ), F_660F3A, 1, no_WDS,0x67,     0x00,      P_686|P_AVX,W1|IZSZ|QSIZE|T1S,RWF_EVEX|RWF_VEX )                                                                                                                       
insx(VFPCLASSSS, vfpclassss,  OpCls( XMM,      XMM_M128, I8_U ), F_660F3A, 1, no_WDS,0x67,     0x00,      P_686|P_AVX,IZSZ|DSIZE|T1S,RWF_EVEX|RWF_VEX )                                                                                                                       
insx(VPCONFLICTD, vpconflictd,OpCls( XMM,      XMM_M128, NONE ), F_660F38, 1, no_WDS,0xC4,     0x00,      P_686|P_AVX, IZSZ|DSIZE|FV, RWF_EVEX|RWF_VEX )
insx(VPCONFLICTQ, vpconflictq,OpCls( XMM,      XMM_M128, NONE ), F_660F38, 1, no_WDS,0xC4,     0x00,      P_686|P_AVX, W1|IZSZ|QSIZE|FV, RWF_EVEX|RWF_VEX )
insx(VPLZCNTD, vplzcntd,      OpCls( XMM,      XMM_M128, NONE ), F_660F38, 1, no_WDS,0x44,     0x00,      P_686|P_AVX, IZSZ|DSIZE|FV, RWF_EVEX|RWF_VEX )
insx(VPLZCNTQ, vplzcntq,      OpCls( XMM,      XMM_M128, NONE ), F_660F38, 1, no_WDS,0x44,     0x00,      P_686|P_AVX, W1|IZSZ|QSIZE|FV, RWF_EVEX|RWF_VEX )
insx(VPMADD52LUQ, vpmadd52luq,OpCls( XMM,      XMM_M128, NONE ), F_660F38, 1, no_WDS,0xB4,     0x00,      P_686|P_AVX, W1|IZSZ|QSIZE|FV, RWF_EVEX|RWF_VEX )
insx(VPMADD52HUQ, vpmadd52huq,OpCls( XMM,      XMM_M128, NONE ), F_660F38, 1, no_WDS,0xB5,     0x00,      P_686|P_AVX, W1|IZSZ|QSIZE|FV, RWF_EVEX|RWF_VEX )
insx(VPMOVM2B, vpmovm2b,      OpCls( XMM,      R8,       NONE ), F_F30F38, 1, no_WDS,0x28,     0x00,      P_686|P_AVX, IZSZ|BSIZE,RWF_EVEX|RWF_VEX )
insx(VPMOVM2W, vpmovm2w,      OpCls( XMM,      R16,      NONE ), F_F30F38, 1, no_WDS,0x28,     0x00,      P_686|P_AVX, W1|IZSZ|WSIZE,RWF_EVEX|RWF_VEX )
insx(VPMOVM2D, vpmovm2d,      OpCls( XMM,      R32,      NONE ), F_F30F38, 1, no_WDS,0x38,     0x00,      P_686|P_AVX, IZSZ|DSIZE,RWF_EVEX|RWF_VEX )
insx(VPMOVM2Q, vpmovm2q,      OpCls( XMM,      R64,      NONE ), F_F30F38, 1, no_WDS,0x38,     0x00,      P_686|P_AVX, W1|IZSZ|QSIZE,RWF_EVEX|RWF_VEX )
insx(VPMOVB2M, vpmovb2m,      OpCls(XMM,       XMM,      NONE ), F_F30F38, 1, no_WDS,0x29,     0x00,      P_686|P_AVX, IZSZ|BSIZE,RWF_EVEX|RWF_VEX )
insx(VPMOVW2M, vpmovw2m,      OpCls(XMM,       XMM,      NONE ), F_F30F38, 1, no_WDS,0x29,     0x00,      P_686|P_AVX, W1|IZSZ|WSIZE,RWF_EVEX|RWF_VEX )
insx(VPMOVD2M, vpmovd2m,      OpCls(XMM,       XMM,      NONE ), F_F30F38, 1, no_WDS,0x39,     0x00,      P_686|P_AVX, IZSZ|DSIZE,RWF_EVEX|RWF_VEX )
insx(VPMOVQ2M, vpmovq2m,      OpCls(XMM,       XMM,      NONE ), F_F30F38, 1, no_WDS,0x39,     0x00,      P_686|P_AVX, W1|IZSZ|QSIZE,RWF_EVEX|RWF_VEX )
insx(VPMULLQ,  vpmullq,       OpCls( XMM,      XMM_M128, NONE ), F_660F38, 1, no_WDS,0x40,     0x00,      P_686|P_AVX, W1|IZSZ|QSIZE|FV,RWF_EVEX|RWF_VEX )

insx(VRANGEPD, vrangepd,      OpCls( XMM,      XMM_M128, I8_U ), F_660F3A,1,  no_WDS, 0x50,    0x00,      P_686|P_AVX, W1|IZSZ|QSIZE|FV, RWF_EVEX|RWF_VEX )
insx(VRANGEPS, vrangeps,      OpCls( XMM,      XMM_M128, I8_U ), F_660F3A,1,  no_WDS, 0x50,    0x00,      P_686|P_AVX, IZSZ|DSIZE|FV, RWF_EVEX|RWF_VEX )
insx(VRANGESD, vrangesd,      OpCls( XMM,      XMM_M128, I8_U ), F_660F3A,1,  no_WDS, 0x51,    0x00,      P_686|P_AVX, W1|IZSZ|QSIZE|T1S, RWF_EVEX|RWF_VEX )
insx(VRANGESS, vrangess,      OpCls( XMM,      XMM_M128, I8_U ), F_660F3A,1,  no_WDS, 0x51,    0x00,      P_686|P_AVX, IZSZ|DSIZE|T1S, RWF_EVEX|RWF_VEX )
insx(VPBLENDD, vpblendd,      OpCls( XMM,      XMM_M128, I8_U ), F_660F3A,1,  no_WDS, 0x02,    0x00,      P_686|P_AVX, DSIZE, RWF_VEX )  //AVX2
insx(VPMASKMOVD,vpmaskmovd,   OpCls( XMM,      XMM_M128, NONE ), F_660F38,1,  no_WDS, 0x8C,    0x00,      P_686|P_AVX, DSIZE,RWF_VEX )   //AVX2
insn(VPMASKMOVD,1,            OpCls( XMM_M128, XMM,      NONE ), F_660F38,0,  no_WDS, 0x8E,    0x00,      P_686|P_AVX, DSIZE )           //AVX2
insx(VPMASKMOVQ,vpmaskmovq,   OpCls( XMM,      XMM_M128, NONE ), F_660F38,1,  no_WDS, 0x8C,    0x00,      P_686|P_AVX, W1|QSIZE,RWF_VEX )//AVX2
insn(VPMASKMOVQ,1,            OpCls( XMM_M128, XMM,      NONE ), F_660F38,0,  no_WDS, 0x8E,    0x00,      P_686|P_AVX, W1|QSIZE )
insx(VPMULTISHIFTQB, vpmultishiftqb,   OpCls( XMM,      XMM_M128,   NONE ), F_660F38,1,  no_WDS, 0x83,     0x00,     P_686|P_AVX, W1|IZSZ|QSIZE|FV, RWF_EVEX|RWF_VEX )

/* VEX-ENCODED GPR INSTRUCTIONS */
insx(ANDN,  andn,             OpCls( R,        R,        R_MS ), F_0F38,  1,  no_WDS, 0xF2,    0x00,      P_686|P_AVX, 0, RWF_VEX)
insx(MULX,  mulx,             OpCls( R,        R,        R_MS ), F_F20F38,1,  no_WDS, 0xF6,    0x00,      P_686|P_AVX, 0, RWF_VEX)
insx(BEXTR, bextr,            OpCls( R,        R_MS,        R ), F_0F38,  1,  0,      0xF7,    0x00,      P_686|P_AVX, 0, RWF_VEX)
insx(SARX, sarx,              OpCls( R,        R_MS,        R ), F_F30F38,1,  0,      0xF7,    0x00,      P_686|P_AVX, 0, RWF_VEX)
insx(SHLX, shlx,              OpCls( R,        R_MS,        R ), F_660F38,1,  0,      0xF7,    0x00,      P_686|P_AVX, 0, RWF_VEX)
insx(SHRX, shrx,              OpCls( R,        R_MS,        R ), F_F20F38,1,  0,      0xF7,    0x00,      P_686|P_AVX, 0, RWF_VEX)
insx(BLSI, blsi,              OpCls( RGT8,     RGT8_MS,  NONE ), F_0F38,  1,  no_WDS, 0xF3,    0x18,      P_686|P_AVX, 0, RWF_VEX)
insx(BLSMSK, blsmsk,          OpCls( RGT8,     RGT8_MS,  NONE ), F_0F38,  1,  no_WDS, 0xF3,    0x10,      P_686|P_AVX, 0, RWF_VEX)
insx(BLSR, blsr,              OpCls( RGT8,     RGT8_MS,  NONE ), F_0F38,  1,  no_WDS, 0xF3,    0x08,      P_686|P_AVX, 0, RWF_VEX)
insx(BZHI, bzhi,              OpCls( R,        R_MS,        R ), F_0F38,  1,  0,      0xF5,    0x00,      P_686|P_AVX, 0, RWF_VEX)
insx(PDEP,  pdep,             OpCls( R,        R,        R_MS ), F_F20F38,1,  no_WDS, 0xF5,    0x00,      P_686|P_AVX, 0, RWF_VEX)
insx(PEXT,  pext,             OpCls( R,        R,        R_MS ), F_F30F38,1,  no_WDS, 0xF5,    0x00,      P_686|P_AVX, 0, RWF_VEX)
insx(RORX, rorx,              OpCls( R,        R_MS,     I8_U ), F_F20F3A,1,  no_WDS, 0xF0,    0x00,      P_686|P_AVX, 0, RWF_VEX)

insx(VPDPBUSDS, vpdpbusds, OpCls(K, K, NONE), F_0F, 1, 0, 0x99, 0x00, P_686 | P_AVX, 2, RWF_VEX)
insx(VPDPBUSD, vpdpbusd, OpCls(K, K, NONE), F_0F, 1, 0, 0x99, 0x00, P_686 | P_AVX, 2, RWF_VEX)
insx(VPDPWSSDS, vpdpwssds, OpCls(K, K, NONE), F_0F, 1, 0, 0x99, 0x00, P_686 | P_AVX, 2, RWF_VEX)
insx(VPDPWSSD, vpdpwssd, OpCls(K, K, NONE), F_0F, 1, 0, 0x99, 0x00, P_686 | P_AVX, 2, RWF_VEX)

insx(VGF2P8MULB, vgf2p8mulb, OpCls(K, K, NONE), F_0F, 1, 0, 0x99, 0x00, P_686 | P_AVX, 2, RWF_VEX)
insx(VGF2P8AFFINEQB, vgf2p8affineqb, OpCls(K, K, NONE), F_0F, 1, 0, 0x99, 0x00, P_686 | P_AVX, 2, RWF_VEX)
insx(VGF2P8AFFINEINVQB, vgf2p8affineinvqb, OpCls(K, K, NONE), F_0F, 1, 0, 0x99, 0x00, P_686 | P_AVX, 2, RWF_VEX)

/* MASK INSTRUCTIONS */
insx(KADDB,     kaddb,    OpCls(K,         K,        K),     F_660F,      1,    no_WDS,     0x4A,      0x00,      P_686|P_AVX, 1, RWF_VEX)
insx(KADDW,     kaddw,    OpCls(K,         K,        K),     F_0F,        1,    no_WDS,     0x4A,      0x00,      P_686|P_AVX, 0, RWF_VEX)
insx(KANDB,     kandb,    OpCls(K,         K,        K),     F_660F,      1,    no_WDS,     0x41,      0x00,      P_686|P_AVX, 1, RWF_VEX)
insx(KANDW,     kandw,    OpCls(K,         K,        K),     F_0F,        1,    no_WDS,     0x41,      0x00,      P_686|P_AVX, 0, RWF_VEX)
insx(KANDNB,    kandnb,   OpCls(K,         K,        K),     F_660F,      1,    no_WDS,     0x42,      0x00,      P_686|P_AVX, 1, RWF_VEX)
insx(KANDNW,    kandnw,   OpCls(K,         K,        K),     F_0F,        1,    no_WDS,     0x42,      0x00,      P_686|P_AVX, 0, RWF_VEX)
insx(KORB,      korb,     OpCls(K,         K,        K),     F_660F,      1,    no_WDS,     0x45,      0x00,      P_686|P_AVX, 1, RWF_VEX)
insx(KORW,      korw,     OpCls(K,         K,        K),     F_0F,        1,    no_WDS,     0x45,      0x00,      P_686|P_AVX, 0, RWF_VEX)
insx(KXORB,     kxorb,    OpCls(K,         K,        K),     F_660F,      1,    no_WDS,     0x47,      0x00,      P_686|P_AVX, 1, RWF_VEX)
insx(KXORW,     kxorw,    OpCls(K,         K,        K),     F_0F,        1,    no_WDS,     0x47,      0x00,      P_686|P_AVX, 0, RWF_VEX)
insx(KXNORB,    kxnorb,   OpCls(K,         K,        K),     F_660F,      1,    no_WDS,     0x46,      0x00,      P_686|P_AVX, 1, RWF_VEX)
insx(KXNORW,    kxnorw,   OpCls(K,         K,        K),     F_0F,        1,    no_WDS,     0x46,      0x00,      P_686|P_AVX, 0, RWF_VEX)
insx(KUNPCKBW,  kunpckbw, OpCls(K,         K,        K),     F_660F,      1,    no_WDS,     0x4B,      0x00,      P_686|P_AVX, 0, RWF_VEX)
insx(KUNPCKWD,  kunpckwd, OpCls(K,         K,        K),     F_0F,        1,    no_WDS,     0x4B,      0x00,      P_686|P_AVX, 1, RWF_VEX)
insx(KADDD,     kaddd,    OpCls(K,         K,        K),     F_660F,      1,         0,     0x4A,      0x00,      P_686|P_AVX, 2, RWF_VEX)
insx(KADDQ,     kaddq,    OpCls(K,         K,        K),     F_0F,        1,         0,     0x4A,      0x00,      P_686|P_AVX, 2, RWF_VEX)
insx(KANDD,     kandd,    OpCls(K,         K,        K),     F_660F,      1,         0,     0x41,      0x00,      P_686|P_AVX, 2, RWF_VEX)
insx(KANDQ,     kandq,    OpCls(K,         K,        K),     F_0F,        1,         0,     0x41,      0x00,      P_686|P_AVX, 2, RWF_VEX)
insx(KANDND,    kandnd,   OpCls(K,         K,        K),     F_660F,      1,         0,     0x42,      0x00,      P_686|P_AVX, 2, RWF_VEX)
insx(KANDNQ,    kandnq,   OpCls(K,         K,        K),     F_0F,        1,         0,     0x42,      0x00,      P_686|P_AVX, 2, RWF_VEX)
insx(KORD,      kord,     OpCls(K,         K,        K),     F_660F,      1,         0,     0x45,      0x00,      P_686|P_AVX, 2, RWF_VEX)
insx(KORQ,      korq,     OpCls(K,         K,        K),     F_0F,        1,         0,     0x45,      0x00,      P_686|P_AVX, 2, RWF_VEX)
insx(KXORD,     kxord,    OpCls(K,         K,        K),     F_660F,      1,         0,     0x47,      0x00,      P_686|P_AVX, 2, RWF_VEX)
insx(KXORQ,     kxorq,    OpCls(K,         K,        K),     F_0F,        1,         0,     0x47,      0x00,      P_686|P_AVX, 2, RWF_VEX)
insx(KXNORD,    kxnord,   OpCls(K,         K,        K),     F_660F,      1,         0,     0x46,      0x00,      P_686|P_AVX, 2, RWF_VEX)
insx(KXNORQ,    kxnorq,   OpCls(K,         K,        K),     F_0F,        1,         0,     0x46,      0x00,      P_686|P_AVX, 2, RWF_VEX)
insx(KUNPCKDQ,  kunpckdq, OpCls(K,         K,        K),     F_0F,        1,         0,     0x4B,      0x00,      P_686|P_AVX, 2, RWF_VEX)
insx(KNOTB,     knotb,    OpCls(K,         K,     NONE),     F_660F,      1,    no_WDS,     0x44,      0x00,      P_686|P_AVX, 1, RWF_VEX)
insx(KNOTW,     knotw,    OpCls(K,         K,     NONE),     F_0F,        1,    no_WDS,     0x44,      0x00,      P_686|P_AVX, 0, RWF_VEX)
insx(KNOTD,     knotd,    OpCls(K,         K,     NONE),     F_660F,      1,         0,     0x44,      0x00,      P_686|P_AVX, 2, RWF_VEX)
insx(KNOTQ,     knotq,    OpCls(K,         K,     NONE),     F_0F,        1,         0,     0x44,      0x00,      P_686|P_AVX, 2, RWF_VEX)
insx(KORTESTB,  kortestb, OpCls(K,         K,     NONE),     F_660F,      1,    no_WDS,     0x98,      0x00,      P_686|P_AVX, 1, RWF_VEX)
insx(KORTESTW,  kortestw, OpCls(K,         K,     NONE),     F_0F,        1,    no_WDS,     0x98,      0x00,      P_686|P_AVX, 0, RWF_VEX)
insx(KORTESTD,  kortestd, OpCls(K,         K,     NONE),     F_660F,      1,         0,     0x98,      0x00,      P_686|P_AVX, 2, RWF_VEX)
insx(KORTESTQ,  kortestq, OpCls(K,         K,     NONE),     F_0F,        1,         0,     0x98,      0x00,      P_686|P_AVX, 2, RWF_VEX)
insx(KSHIFTLB,  kshiftlb, OpCls(K,         K,     I8_U),    F_660F3A,     1,         0,     0x32,      0x00,      P_686|P_AVX, 1, RWF_VEX)
insx(KSHIFTLW,  kshiftlw, OpCls(K,         K,     I8_U),    F_660F3A,     1,         0,     0x32,      0x00,      P_686|P_AVX, 1, RWF_VEX)
insx(KSHIFTLD,  kshiftld, OpCls(K,         K,     I8_U),    F_660F3A,     1,         0,     0x33,      0x00,      P_686|P_AVX, 1, RWF_VEX)
insx(KSHIFTLQ,  kshiftlq, OpCls(K,         K,     I8_U),    F_660F3A,     1,         0,     0x33,      0x00,      P_686|P_AVX, 1, RWF_VEX)
insx(KSHIFTRB,  kshiftrb, OpCls(K,         K,     I8_U),    F_660F3A,     1,         0,     0x30,      0x00,      P_686|P_AVX, 1, RWF_VEX)
insx(KSHIFTRW,  kshiftrw, OpCls(K,         K,     I8_U),    F_660F3A,     1,         0,     0x30,      0x00,      P_686|P_AVX, 1, RWF_VEX)
insx(KSHIFTRD,  kshiftrd, OpCls(K,         K,     I8_U),    F_660F3A,     1,         0,     0x31,      0x00,      P_686|P_AVX, 1, RWF_VEX)
insx(KSHIFTRQ,  kshiftrq, OpCls(K,         K,     I8_U),    F_660F3A,     1,         0,     0x31,      0x00,      P_686|P_AVX, 1, RWF_VEX)

insx(KMOVB,  kmovb,       OpCls(K,         K,     NONE),     F_660F,      1,    no_WDS,     0x90,      0x00,      P_686|P_AVX, 0, RWF_VEX)
insn(KMOVB,      1,       OpCls(K,       M08,     NONE),     F_660F,      1,    no_WDS,     0x90,      0x00,      P_686|P_AVX, 0)
insn(KMOVB,      2,       OpCls(M08,       K,     NONE),     F_660F,      0,    no_WDS,     0x91,      0x00,      P_686|P_AVX, 0)
insn(KMOVB,      3,       OpCls(K,       R32,     NONE),     F_660F,      1,    no_WDS,     0x92,      0x00,      P_686|P_AVX, 0)
insn(KMOVB,      4,       OpCls(R32,       K,     NONE),     F_660F,      1,    no_WDS,     0x93,      0x00,      P_686|P_AVX, 0)
insx(KMOVD,  kmovd,       OpCls(K,         K,     NONE),     F_660F,      1,         0,     0x90,      0x00,      P_686|P_AVX, 0, RWF_VEX)
insn(KMOVD,      1,       OpCls(K,       M32,     NONE),     F_660F,      1,         0,     0x90,      0x00,      P_686|P_AVX, 0)
insn(KMOVD,      2,       OpCls(M32,       K,     NONE),     F_660F,      0,         0,     0x91,      0x00,      P_686|P_AVX, 0)
insn(KMOVD,      3,       OpCls(K,       R32,     NONE),     F_F20F,      1,    no_WDS,     0x92,      0x00,      P_686|P_AVX, 0)
insn(KMOVD,      4,       OpCls(R32,       K,     NONE),     F_F20F,      1,    no_WDS,     0x93,      0x00,      P_686|P_AVX, 0)
insx(KMOVQ,  kmovq,       OpCls(K,         K,     NONE),     F_0F,        1,         0,     0x90,      0x00,      P_686|P_AVX, 0, RWF_VEX)
insn(KMOVQ,      1,       OpCls(K,       M64,     NONE),     F_0F,        1,         0,     0x90,      0x00,      P_686|P_AVX, 0)
insn(KMOVQ,      2,       OpCls(M64,       K,     NONE),     F_0F,        0,         0,     0x91,      0x00,      P_686|P_AVX, 0)
insn(KMOVQ,      3,       OpCls(K,       R64,     NONE),     F_F20F,      1,    no_WDS,     0x92,      0x00,      P_686|P_AVX, 0)
insn(KMOVQ,      4,       OpCls(R64,       K,     NONE),     F_F20F,      1,    no_WDS,     0x93,      0x00,      P_686|P_AVX, 0)
insx(KMOVW,  kmovw,       OpCls(K,         K,     NONE),     F_0F,        1,         0,     0x90,      0x00,      P_686|P_AVX, 0, RWF_VEX)
insn(KMOVW,      1,       OpCls(K,       M16,     NONE),     F_0F,        1,         0,     0x90,      0x00,      P_686|P_AVX, 0)
insn(KMOVW,      2,       OpCls(M16,       K,     NONE),     F_0F,        0,         0,     0x91,      0x00,      P_686|P_AVX, 0)
insn(KMOVW,      3,       OpCls(K,       R32,     NONE),     F_0F,        1,         0,     0x92,      0x00,      P_686|P_AVX, 0)
insn(KMOVW,      4,       OpCls(R32,       K,     NONE),     F_0F,        1,         0,     0x93,      0x00,      P_686|P_AVX, 0)

/* Don't forget to update parser line 3382 to evex exclusions */
insx(KTESTB, ktestb,      OpCls(K, K, NONE), F_660F, 1, 0, 0x99, 0x00, P_686 | P_AVX, 1, RWF_VEX)
insx(KTESTW, ktestw,      OpCls(K, K, NONE), F_0F, 1, 0, 0x99, 0x00, P_686 | P_AVX, 0, RWF_VEX)
insx(KTESTD, ktestd,      OpCls(K, K, NONE), F_660F, 1, 0, 0x99, 0x00, P_686 | P_AVX, 2, RWF_VEX)
insx(KTESTQ, ktestq,      OpCls(K, K, NONE), F_0F, 1, 0, 0x99, 0x00, P_686 | P_AVX, 2, RWF_VEX)

#endif