; INSTRUCT.INC--
;
; Copyright (c) The Asmc Contributors. All rights reserved.
; Consult your license regarding permissions and restrictions.
;
; Description: table of instructions. Other reserved words see special.h
;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;
; 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
;

insa(CALL, call, OpCls( I16, NONE, NONE  ), 0,      0, no_RM,  0xE8, 0x00, P_86,  0,0)
insn(CALL, 1,  OpCls( I32,  NONE,  NONE  ), 0,      0, no_RM,  0xE8, 0x00, P_386, 0,0)
insn(CALL, 2,  OpCls( RGT8, NONE,  NONE  ), 0,      0, no_WDS, 0xFF, 0x10, P_86,  0,0)
insn(CALL, 3,  OpCls( M32,  NONE,  NONE  ), F_32,   0, no_WDS, 0xFF, 0x10, P_386, 0,0)
insn(CALL, 4,  OpCls( M16,  NONE,  NONE  ), F_16,   0, no_WDS, 0xFF, 0x10, P_86,  0,0)

; start entries for FAR call

insm(CALL, 6,  OpCls( I32,  NONE,  NONE  ), F_16,   0, no_RM,  0x9A, 0x00, P_86,  0,0)
insn(CALL, 7,  OpCls( I48,  NONE,  NONE  ), F_32,   0, no_RM,  0x9A, 0x00, P_386, 0,0)
insn(CALL, 8,  OpCls( M32,  NONE,  NONE  ), F_16,   0, no_WDS, 0xFF, 0x18, P_86,  0,0)
insn(CALL, 9,  OpCls( M48,  NONE,  NONE  ), F_32,   0, no_WDS, 0xFF, 0x18, P_386, 0,0)
insa(JMP, jmp, OpCls( I8,   NONE,  NONE  ), 0,      0, no_RM,  0xEB, 0x00, P_86,  0,0)
insn(JMP, 1,   OpCls( I16,  NONE,  NONE  ), 0,      0, no_RM,  0xE9, 0x00, P_86,  0,0)
insn(JMP, 2,   OpCls( I32,  NONE,  NONE  ), 0,      0, no_RM,  0xE9, 0x00, P_386, 0,0)
insn(JMP, 3,   OpCls( RGT8, NONE,  NONE  ), 0,      0, no_WDS, 0xFF, 0x20, P_86,  0,0)
insn(JMP, 4,   OpCls( M32,  NONE,  NONE  ), F_32,   0, no_WDS, 0xFF, 0x20, P_386, 0,0)
insn(JMP, 5,   OpCls( M16,  NONE,  NONE  ), F_16,   0, no_WDS, 0xFF, 0x20, P_86,  0,0)

; entries for FAR jmp

insm(JMP, 7,   OpCls( I32,  NONE,  NONE  ), F_16,   0, no_RM,  0xEA, 0x00, P_86,  0,0)
insn(JMP, 8,   OpCls( I48,  NONE,  NONE  ), F_32,   0, no_RM,  0xEA, 0x00, P_386, 0,0)
insn(JMP, 9,   OpCls( M32,  NONE,  NONE  ), F_16,   0, no_WDS, 0xFF, 0x28, P_86,  0,0)
insn(JMP, 10,  OpCls( M48,  NONE,  NONE  ), F_32,   0, no_WDS, 0xFF, 0x28, P_386, 0,0)

; for conditional jumps, the SHORT version must always be first!

insa(JA,  ja,  OpCls( I8, NONE, NONE ), 0,    0, no_RM, 0x77, 0x00, P_86, 0,0)
insn(JA,  1,   OpCls( I,  NONE, NONE ), F_0F, 0, no_RM, 0x87, 0x00, P_386,0,0)
insa(JAE, jae, OpCls( I8, NONE, NONE ), 0,    0, no_RM, 0x73, 0x00, P_86, 0,0)
insn(JAE, 1,   OpCls( I,  NONE, NONE ), F_0F, 0, no_RM, 0x83, 0x00, P_386,0,0)
insa(JB,  jb,  OpCls( I8, NONE, NONE ), 0,    0, no_RM, 0x72, 0x00, P_86, 0,0)
insn(JB,  1,   OpCls( I,  NONE, NONE ), F_0F, 0, no_RM, 0x82, 0x00, P_386,0,0)
insa(JBE, jbe, OpCls( I8, NONE, NONE ), 0,    0, no_RM, 0x76, 0x00, P_86, 0,0)
insn(JBE, 1,   OpCls( I,  NONE, NONE ), F_0F, 0, no_RM, 0x86, 0x00, P_386,0,0)
insa(JC,  jc,  OpCls( I8, NONE, NONE ), 0,    0, no_RM, 0x72, 0x00, P_86, 0,0)
insn(JC,  1,   OpCls( I,  NONE, NONE ), F_0F, 0, no_RM, 0x82, 0x00, P_386,0,0)
insa(JE,  je,  OpCls( I8, NONE, NONE ), 0,    0, no_RM, 0x74, 0x00, P_86, 0,0)
insn(JE,  1,   OpCls( I,  NONE, NONE ), F_0F, 0, no_RM, 0x84, 0x00, P_386,0,0)
insa(JG,  jg,  OpCls( I8, NONE, NONE ), 0,    0, no_RM, 0x7F, 0x00, P_86, 0,0)
insn(JG,  1,   OpCls( I,  NONE, NONE ), F_0F, 0, no_RM, 0x8F, 0x00, P_386,0,0)
insa(JGE, jge, OpCls( I8, NONE, NONE ), 0,    0, no_RM, 0x7D, 0x00, P_86, 0,0)
insn(JGE, 1,   OpCls( I,  NONE, NONE ), F_0F, 0, no_RM, 0x8D, 0x00, P_386,0,0)
insa(JL,  jl,  OpCls( I8, NONE, NONE ), 0,    0, no_RM, 0x7C, 0x00, P_86, 0,0)
insn(JL,  1,   OpCls( I,  NONE, NONE ), F_0F, 0, no_RM, 0x8C, 0x00, P_386,0,0)
insa(JLE, jle, OpCls( I8, NONE, NONE ), 0,    0, no_RM, 0x7E, 0x00, P_86, 0,0)
insn(JLE, 1,   OpCls( I,  NONE, NONE ), F_0F, 0, no_RM, 0x8E, 0x00, P_386,0,0)
insa(JNA, jna, OpCls( I8, NONE, NONE ), 0,    0, no_RM, 0x76, 0x00, P_86, 0,0)
insn(JNA, 1,   OpCls( I,  NONE, NONE ), F_0F, 0, no_RM, 0x86, 0x00, P_386,0,0)
insa(JNAE,jnae,OpCls( I8, NONE, NONE ), 0,    0, no_RM, 0x72, 0x00, P_86, 0,0)
insn(JNAE,1,   OpCls( I,  NONE, NONE ), F_0F, 0, no_RM, 0x82, 0x00, P_386,0,0)
insa(JNB, jnb, OpCls( I8, NONE, NONE ), 0,    0, no_RM, 0x73, 0x00, P_86, 0,0)
insn(JNB, 1,   OpCls( I,  NONE, NONE ), F_0F, 0, no_RM, 0x83, 0x00, P_386,0,0)
insa(JNBE,jnbe,OpCls( I8, NONE, NONE ), 0,    0, no_RM, 0x77, 0x00, P_86, 0,0)
insn(JNBE,1,   OpCls( I,  NONE, NONE ), F_0F, 0, no_RM, 0x87, 0x00, P_386,0,0)
insa(JNC, jnc, OpCls( I8, NONE, NONE ), 0,    0, no_RM, 0x73, 0x00, P_86, 0,0)
insn(JNC, 1,   OpCls( I,  NONE, NONE ), F_0F, 0, no_RM, 0x83, 0x00, P_386,0,0)
insa(JNE, jne, OpCls( I8, NONE, NONE ), 0,    0, no_RM, 0x75, 0x00, P_86, 0,0)
insn(JNE, 1,   OpCls( I,  NONE, NONE ), F_0F, 0, no_RM, 0x85, 0x00, P_386,0,0)
insa(JNG, jng, OpCls( I8, NONE, NONE ), 0,    0, no_RM, 0x7E, 0x00, P_86, 0,0)
insn(JNG, 1,   OpCls( I,  NONE, NONE ), F_0F, 0, no_RM, 0x8E, 0x00, P_386,0,0)
insa(JNGE,jnge,OpCls( I8, NONE, NONE ), 0,    0, no_RM, 0x7C, 0x00, P_86, 0,0)
insn(JNGE,1,   OpCls( I,  NONE, NONE ), F_0F, 0, no_RM, 0x8C, 0x00, P_386,0,0)
insa(JNL, jnl, OpCls( I8, NONE, NONE ), 0,    0, no_RM, 0x7D, 0x00, P_86, 0,0)
insn(JNL, 1,   OpCls( I,  NONE, NONE ), F_0F, 0, no_RM, 0x8D, 0x00, P_386,0,0)
insa(JNLE,jnle,OpCls( I8, NONE, NONE ), 0,    0, no_RM, 0x7F, 0x00, P_86, 0,0)
insn(JNLE,1,   OpCls( I,  NONE, NONE ), F_0F, 0, no_RM, 0x8F, 0x00, P_386,0,0)
insa(JNO, jno, OpCls( I8, NONE, NONE ), 0,    0, no_RM, 0x71, 0x00, P_86, 0,0)
insn(JNO, 1,   OpCls( I,  NONE, NONE ), F_0F, 0, no_RM, 0x81, 0x00, P_386,0,0)
insa(JNP, jnp, OpCls( I8, NONE, NONE ), 0,    0, no_RM, 0x7B, 0x00, P_86, 0,0)
insn(JNP, 1,   OpCls( I,  NONE, NONE ), F_0F, 0, no_RM, 0x8B, 0x00, P_386,0,0)
insa(JNS, jns, OpCls( I8, NONE, NONE ), 0,    0, no_RM, 0x79, 0x00, P_86, 0,0)
insn(JNS, 1,   OpCls( I,  NONE, NONE ), F_0F, 0, no_RM, 0x89, 0x00, P_386,0,0)
insa(JNZ, jnz, OpCls( I8, NONE, NONE ), 0,    0, no_RM, 0x75, 0x00, P_86, 0,0)
insn(JNZ, 1,   OpCls( I,  NONE, NONE ), F_0F, 0, no_RM, 0x85, 0x00, P_386,0,0)
insa(JO,  jo,  OpCls( I8, NONE, NONE ), 0,    0, no_RM, 0x70, 0x00, P_86, 0,0)
insn(JO,  1,   OpCls( I,  NONE, NONE ), F_0F, 0, no_RM, 0x80, 0x00, P_386,0,0)
insa(JP,  jp,  OpCls( I8, NONE, NONE ), 0,    0, no_RM, 0x7A, 0x00, P_86, 0,0)
insn(JP,  1,   OpCls( I,  NONE, NONE ), F_0F, 0, no_RM, 0x8A, 0x00, P_386,0,0)
insa(JPE, jpe, OpCls( I8, NONE, NONE ), 0,    0, no_RM, 0x7A, 0x00, P_86, 0,0)
insn(JPE, 1,   OpCls( I,  NONE, NONE ), F_0F, 0, no_RM, 0x8A, 0x00, P_386,0,0)
insa(JPO, jpo, OpCls( I8, NONE, NONE ), 0,    0, no_RM, 0x7B, 0x00, P_86, 0,0)
insn(JPO, 1,   OpCls( I,  NONE, NONE ), F_0F, 0, no_RM, 0x8B, 0x00, P_386,0,0)
insa(JS,  js,  OpCls( I8, NONE, NONE ), 0,    0, no_RM, 0x78, 0x00, P_86, 0,0)
insn(JS,  1,   OpCls( I,  NONE, NONE ), F_0F, 0, no_RM, 0x88, 0x00, P_386,0,0)
insa(JZ,  jz,  OpCls( I8, NONE, NONE ), 0,    0, no_RM, 0x74, 0x00, P_86, 0,0)
insn(JZ,  1,   OpCls( I,  NONE, NONE ), F_0F, 0, no_RM, 0x84, 0x00, P_386,0,0)

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

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

insa(ADD, add,    OpCls(RGT8, I8,   NONE), 0, 0, no_WDS, 0x83, 0x00, P_86, 0,0)
insn(ADD, 1,      OpCls(R,    R_MS, NONE), 0, 1, 0,      0x02, 0x00, P_86, 0,0)
insn(ADD, 3,      OpCls(A,    I,    NONE), 0, 0, no_RM,  0x04, 0x00, P_86, 0,0)
insn(ADD, 4,      OpCls(R,    I,    NONE), 0, 0, 0,      0x80, 0x00, P_86, 0,0)
insn(ADD, 6,      OpCls(MGT8, I8,   NONE), 0, 0, no_WDS, 0x83, 0x00, P_86, AP_LOCK,0)
insn(ADD, 7,      OpCls(MS,   R,    NONE), 0, 0, 0,      0x00, 0x00, P_86, AP_LOCK,0)
insn(ADD, 8,      OpCls(MS,   I,    NONE), 0, 0, 0,      0x80, 0x00, P_86, AP_LOCK,0)
insa(OR,  or,     OpCls(RGT8, I8,   NONE), 0, 0, no_WDS, 0x83, 0x08, P_86, 0,0)
insn(OR,  1,      OpCls(R,    R_MS, NONE), 0, 1, 0,      0x0A, 0x00, P_86, 0,0)
insn(OR,  3,      OpCls(A,    I,    NONE), 0, 0, no_RM,  0x0C, 0x00, P_86, 0,0)
insn(OR,  4,      OpCls(R,    I,    NONE), 0, 0, 0,      0x80, 0x08, P_86, 0,0)
insn(OR,  6,      OpCls(MGT8, I8,   NONE), 0, 0, no_WDS, 0x83, 0x08, P_86, AP_LOCK,0)
insn(OR,  7,      OpCls(MS,   R,    NONE), 0, 0, 0,      0x08, 0x00, P_86, AP_LOCK,0)
insn(OR,  8,      OpCls(MS,   I,    NONE), 0, 0, 0,      0x80, 0x08, P_86, AP_LOCK,0)
insa(ADC, adc,    OpCls(RGT8, I8,   NONE), 0, 0, no_WDS, 0x83, 0x10, P_86, 0,0)
insn(ADC, 1,      OpCls(R,    R_MS, NONE), 0, 1, 0,      0x12, 0x00, P_86, 0,0)
insn(ADC, 3,      OpCls(A,    I,    NONE), 0, 0, no_RM,  0x14, 0x00, P_86, 0,0)
insn(ADC, 4,      OpCls(R,    I,    NONE), 0, 0, 0,      0x80, 0x10, P_86, 0,0)
insn(ADC, 6,      OpCls(MGT8, I8,   NONE), 0, 0, no_WDS, 0x83, 0x10, P_86, AP_LOCK,0)
insn(ADC, 7,      OpCls(MS,   R,    NONE), 0, 0, 0,      0x10, 0x00, P_86, AP_LOCK,0)
insn(ADC, 8,      OpCls(MS,   I,    NONE), 0, 0, 0,      0x80, 0x10, P_86, AP_LOCK,0)
insa(SBB, sbb,    OpCls(RGT8, I8,   NONE), 0, 0, no_WDS, 0x83, 0x18, P_86, 0,0)
insn(SBB, 1,      OpCls(R,    R_MS, NONE), 0, 1, 0,      0x1A, 0x00, P_86, 0,0)
insn(SBB, 3,      OpCls(A,    I,    NONE), 0, 0, no_RM,  0x1C, 0x00, P_86, 0,0)
insn(SBB, 4,      OpCls(R,    I,    NONE), 0, 0, 0,      0x80, 0x18, P_86, 0,0)
insn(SBB, 6,      OpCls(MGT8, I8,   NONE), 0, 0, no_WDS, 0x83, 0x18, P_86, AP_LOCK,0)
insn(SBB, 7,      OpCls(MS,   R,    NONE), 0, 0, 0,      0x18, 0x00, P_86, AP_LOCK,0)
insn(SBB, 8,      OpCls(MS,   I,    NONE), 0, 0, 0,      0x80, 0x18, P_86, AP_LOCK,0)
insa(AND, and,    OpCls(RGT8, I8,   NONE), 0, 0, no_WDS, 0x83, 0x20, P_86, 0,0)
insn(AND, 1,      OpCls(R,    R_MS, NONE), 0, 1, 0,      0x22, 0x00, P_86, 0,0)
insn(AND, 3,      OpCls(A,    I,    NONE), 0, 0, no_RM,  0x24, 0x00, P_86, 0,0)
insn(AND, 4,      OpCls(R,    I,    NONE), 0, 0, 0,      0x80, 0x20, P_86, 0,0)
insn(AND, 6,      OpCls(MGT8, I8,   NONE), 0, 0, no_WDS, 0x83, 0x20, P_86, AP_LOCK,0)
insn(AND, 7,      OpCls(MS,   R,    NONE), 0, 0, 0,      0x20, 0x00, P_86, AP_LOCK,0)
insn(AND, 8,      OpCls(MS,   I,    NONE), 0, 0, 0,      0x80, 0x20, P_86, AP_LOCK,0)
insa(SUB, sub,    OpCls(RGT8, I8,   NONE), 0, 0, no_WDS, 0x83, 0x28, P_86, 0,0)
insn(SUB, 1,      OpCls(R,    R_MS, NONE), 0, 1, 0,      0x2A, 0x00, P_86, 0,0)
insn(SUB, 3,      OpCls(A,    I,    NONE), 0, 0, no_RM,  0x2C, 0x00, P_86, 0,0)
insn(SUB, 4,      OpCls(R,    I,    NONE), 0, 0, 0,      0x80, 0x28, P_86, 0,0)
insn(SUB, 6,      OpCls(MGT8, I8,   NONE), 0, 0, no_WDS, 0x83, 0x28, P_86, AP_LOCK,0)
insn(SUB, 7,      OpCls(MS,   R,    NONE), 0, 0, 0,      0x28, 0x00, P_86, AP_LOCK,0)
insn(SUB, 8,      OpCls(MS,   I,    NONE), 0, 0, 0,      0x80, 0x28, P_86, AP_LOCK,0)
insa(XOR, xor,    OpCls(RGT8, I8,   NONE), 0, 0, no_WDS, 0x83, 0x30, P_86, 0,0)
insn(XOR, 1,      OpCls(R,    R_MS, NONE), 0, 1, 0,      0x32, 0x00, P_86, 0,0)
insn(XOR, 3,      OpCls(A,    I,    NONE), 0, 0, no_RM,  0x34, 0x00, P_86, 0,0)
insn(XOR, 4,      OpCls(R,    I,    NONE), 0, 0, 0,      0x80, 0x30, P_86, 0,0)
insn(XOR, 6,      OpCls(MGT8, I8,   NONE), 0, 0, no_WDS, 0x83, 0x30, P_86, AP_LOCK,0)
insn(XOR, 7,      OpCls(MS,   R,    NONE), 0, 0, 0,      0x30, 0x00, P_86, AP_LOCK,0)
insn(XOR, 8,      OpCls(MS,   I,    NONE), 0, 0, 0,      0x80, 0x30, P_86, AP_LOCK,0)

insa(CMP, cmp,    OpCls(RGT8, I8,   NONE), 0, 0, no_WDS, 0x83, 0x38, P_86, 0,0)
insn(CMP, 1,      OpCls(R,    R_MS, NONE), 0, 1, 0,      0x3A, 0x00, P_86, 0,0)
insn(CMP, 3,      OpCls(A,    I,    NONE), 0, 0, no_RM,  0x3C, 0x00, P_86, 0,0)
insn(CMP, 4,      OpCls(R,    I,    NONE), 0, 0, 0,      0x80, 0x38, P_86, 0,0)
insn(CMP, 6,      OpCls(MGT8, I8,   NONE), 0, 0, no_WDS, 0x83, 0x38, P_86, 0,0)
insn(CMP, 7,      OpCls(MS,   R,    NONE), 0, 0, 0,      0x38, 0x00, P_86, 0,0)
insn(CMP, 8,      OpCls(MS,   I,    NONE), 0, 0, 0,      0x80, 0x38, P_86, 0,0)

; std bitshift instructions

insa(RCL, rcl, OpCls( R_MS, CL_ONLY, NONE ), 0, 0, 0, 0xD2, 0x10, P_86,  0,0)
insn(RCL, 1,   OpCls( R_MS, I_1,     NONE ), 0, 0, 0, 0xD0, 0x10, P_86,  0,0)
insn(RCL, 2,   OpCls( R_MS, I8_U,    NONE ), 0, 0, 0, 0xC0, 0x10, P_186, 0,0)
insa(RCR, rcr, OpCls( R_MS, CL_ONLY, NONE ), 0, 0, 0, 0xD2, 0x18, P_86,  0,0)
insn(RCR, 1,   OpCls( R_MS, I_1,     NONE ), 0, 0, 0, 0xD0, 0x18, P_86,  0,0)
insn(RCR, 2,   OpCls( R_MS, I8_U,    NONE ), 0, 0, 0, 0xC0, 0x18, P_186, 0,0)
insa(ROL, rol, OpCls( R_MS, CL_ONLY, NONE ), 0, 0, 0, 0xD2, 0x00, P_86,  0,0)
insn(ROL, 1,   OpCls( R_MS, I_1,     NONE ), 0, 0, 0, 0xD0, 0x00, P_86,  0,0)
insn(ROL, 2,   OpCls( R_MS, I8_U,    NONE ), 0, 0, 0, 0xC0, 0x00, P_186, 0,0)
insa(ROR, ror, OpCls( R_MS, CL_ONLY, NONE ), 0, 0, 0, 0xD2, 0x08, P_86,  0,0)
insn(ROR, 1,   OpCls( R_MS, I_1,     NONE ), 0, 0, 0, 0xD0, 0x08, P_86,  0,0)
insn(ROR, 2,   OpCls( R_MS, I8_U,    NONE ), 0, 0, 0, 0xC0, 0x08, P_186, 0,0)
insa(SAL, sal, OpCls( R_MS, CL_ONLY, NONE ), 0, 0, 0, 0xD2, 0x20, P_86,  0,0)
insn(SAL, 1,   OpCls( R_MS, I_1,     NONE ), 0, 0, 0, 0xD0, 0x20, P_86,  0,0)
insn(SAL, 2,   OpCls( R_MS, I8_U,    NONE ), 0, 0, 0, 0xC0, 0x20, P_186, 0,0)
insa(SAR, sar, OpCls( R_MS, CL_ONLY, NONE ), 0, 0, 0, 0xD2, 0x38, P_86,  0,0)
insn(SAR, 1,   OpCls( R_MS, I_1,     NONE ), 0, 0, 0, 0xD0, 0x38, P_86,  0,0)
insn(SAR, 2,   OpCls( R_MS, I8_U,    NONE ), 0, 0, 0, 0xC0, 0x38, P_186, 0,0)
insa(SHL, shl, OpCls( R_MS, CL_ONLY, NONE ), 0, 0, 0, 0xD2, 0x20, P_86,  0,0)
insn(SHL, 1,   OpCls( R_MS, I_1,     NONE ), 0, 0, 0, 0xD0, 0x20, P_86,  0,0)
insn(SHL, 2,   OpCls( R_MS, I8_U,    NONE ), 0, 0, 0, 0xC0, 0x20, P_186, 0,0)
insa(SHR, shr, OpCls( R_MS, CL_ONLY, NONE ), 0, 0, 0, 0xD2, 0x28, P_86,  0,0)
insn(SHR, 1,   OpCls( R_MS, I_1,     NONE ), 0, 0, 0, 0xD0, 0x28, P_86,  0,0)
insn(SHR, 2,   OpCls( R_MS, I8_U,    NONE ), 0, 0, 0, 0xC0, 0x28, P_186, 0,0)

; string instructions

insa(CMPS,  cmps,     OpCls( MS,       MS,         NONE ), 0,      0,  no_RM,  0xA6, 0x00, P_86,        AP_REPxx,0)
insa(CMPSB, cmpsb,    OpCls( NONE,     NONE,       NONE ), 0,      0,  no_RM,  0xA6, 0x00, P_86,        AP_REPxx,0)
insn(CMPSB, 1,        OpCls( M08,      M08,        NONE ), 0,      0,  no_RM,  0xA6, 0x00, P_86,        AP_REPxx,0)
insa(CMPSW, cmpsw,    OpCls( NONE,     NONE,       NONE ), F_16,   0,  no_RM,  0xA7, 0x00, P_86,        AP_REPxx,0)
insn(CMPSW, 1,        OpCls( M16,      M16,        NONE ), F_16,   0,  no_RM,  0xA7, 0x00, P_86,        AP_REPxx,0)
insa(CMPSD, cmpsd,    OpCls( NONE,     NONE,       NONE ), F_32,   0,  no_RM,  0xA7, 0x00, P_386,       AP_REPxx,0)
insn(CMPSD, 1,        OpCls( M32,      M32,        NONE ), F_32,   0,  no_RM,  0xA7, 0x00, P_386,       AP_REPxx,0)
insn(CMPSD, 2,        OpCls( XMM,      XMM_M64,    I8_U ), F_F20F, 1,  no_WDS, 0xC2, 0x00, P_686 or P_SSE2,0,0)

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

; instructions invalid for IA32+

insx(AAA, aaa,        OpCls( NONE,     NONE,       NONE ), 0,      0,  no_RM,  0x37, 0x00, P_86,        0,0, RWF_IA32 )
insx(AAD, aad,        OpCls( NONE,     NONE,       NONE ), 0,      0,  0,      0xD5, 0x0A, P_86,        0,0, RWF_IA32 )
insn(AAD, 1,          OpCls( I8,       NONE,       NONE ), 0,      1,  no_RM,  0xD5, 0x00, P_86,        0,0 )
insx(AAM, aam,        OpCls( NONE,     NONE,       NONE ), 0,      0,  0,      0xD4, 0x0A, P_86,        0,0, RWF_IA32 )
insn(AAM, 1,          OpCls( I8,       NONE,       NONE ), 0,      1,  no_RM,  0xD4, 0x00, P_86,        0,0 )
insx(AAS, aas,        OpCls( NONE,     NONE,       NONE ), 0,      0,  no_RM,  0x3F, 0x00, P_86,        0,0, RWF_IA32 )
insx(DAA, daa,        OpCls( NONE,     NONE,       NONE ), 0,      0,  no_RM,  0x27, 0x00, P_86,        0,0, RWF_IA32 )
insx(DAS, das,        OpCls( NONE,     NONE,       NONE ), 0,      0,  no_RM,  0x2F, 0x00, P_86,        0,0, RWF_IA32 )
insx(LDS, lds,        OpCls( RGT8,     MFPTR,      NONE ), 0,      1,  no_WDS, 0xC5, 0x00, P_86,        0,0, RWF_IA32 )
insx(LES, les,        OpCls( RGT8,     MFPTR,      NONE ), 0,      1,  no_WDS, 0xC4, 0x00, P_86,        0,0, RWF_IA32 )
insx(POPA,  popa,     OpCls( NONE,     NONE,       NONE ), 0,      0,  no_RM,  0x61, 0x00, P_186,       0,0, RWF_IA32 )
insx(POPAD, popad,    OpCls( NONE,     NONE,       NONE ), F_32,   0,  no_RM,  0x61, 0x00, P_386,       0,0, RWF_IA32 )
insx(POPAW, popaw,    OpCls( NONE,     NONE,       NONE ), F_16,   0,  no_RM,  0x61, 0x00, P_186,       0,0, RWF_IA32 )
insx(POPFD, popfd,    OpCls( NONE,     NONE,       NONE ), F_32,   0,  no_RM,  0x9D, 0x00, P_386,       0,0, RWF_IA32 )
insx(PUSHA,  pusha,   OpCls( NONE,     NONE,       NONE ), 0,      0,  no_RM,  0x60, 0x00, P_186,       0,0, RWF_IA32 )
insx(PUSHAD, pushad,  OpCls( NONE,     NONE,       NONE ), F_32,   0,  no_RM,  0x60, 0x00, P_386,       0,0, RWF_IA32 )
insx(PUSHAW, pushaw,  OpCls( NONE,     NONE,       NONE ), F_16,   0,  no_RM,  0x60, 0x00, P_186,       0,0, RWF_IA32 )
insx(PUSHFD, pushfd,  OpCls( NONE,     NONE,       NONE ), F_32,   0,  no_RM,  0x9C, 0x00, P_386,       0,0, RWF_IA32 )
insx(PUSHD,  pushd,   OpCls( I8,       NONE,       NONE ), F_32,   0,  no_RM,  0x6A, 0x00, P_386,       0,0, RWF_IA32 )
insn(PUSHD,  1,       OpCls( I32,      NONE,       NONE ), F_32,   0,  no_RM,  0x68, 0x00, P_386,       0,0)
insn(PUSHD,  2,       OpCls( R32,      NONE,       NONE ), 0,      0,  R_in_OP,0x50, 0x00, P_386,       0,0)
insn(PUSHD,  3,       OpCls( SR86,     NONE,       NONE ), 0,      1,  R_in_OP,0x06, 0x00, P_86,        0,0)
insn(PUSHD,  4,       OpCls( SR,       NONE,       NONE ), F_0F,   1,  R_in_OP,0x80, 0x00, P_386,       0,0)
insn(PUSHD,  5,       OpCls( M32,      NONE,       NONE ), 0,      0,  0,      0xFF, 0x30, P_386,       0,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,0, RWF_IA32 )
insn(RETD, 1,         OpCls( NONE,     NONE,       NONE ), F_32,   0,  no_RM,  0xCB, 0x00, P_386,       0,0)
insx(RETW, retw,      OpCls( I16,      NONE,       NONE ), F_16,   0,  no_RM,  0xCA, 0x00, P_86,        0,0, RWF_IA32 )
insn(RETW, 1,         OpCls( NONE,     NONE,       NONE ), F_16,   0,  no_RM,  0xCB, 0x00, P_86,        0,0)

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

insa(ARPL, arpl,      OpCls( R16_M16,  R16,      NONE ), 0,       0,  no_WDS, 0x63, 0x00, P_286,       0,0)
insa(LLDT, lldt,      OpCls( R16_M16,  NONE,     NONE ), F_0FNO66,0,  no_WDS, 0x00, 0x10, P_286p,      0,0)
insa(LMSW, lmsw,      OpCls( R16_M16,  NONE,     NONE ), F_0FNO66,0,  no_WDS, 0x01, 0x30, P_286p,      0,0)
insa(LTR,  ltr,       OpCls( R16_M16,  NONE,     NONE ), F_0FNO66,0,  no_WDS, 0x00, 0x18, P_286p,      0,0)
insa(SLDT, sldt,      OpCls( R16_M16,  NONE,     NONE ), F_0FNO66,0,  no_WDS, 0x00, 0x00, P_286,       0,0)
insa(SMSW, smsw,      OpCls( R16_M16,  NONE,     NONE ), F_0FNO66,0,  no_WDS, 0x01, 0x20, P_286,       0,0)
insa(STR,  str,       OpCls( R16_M16,  NONE,     NONE ), F_0FNO66,0,  no_WDS, 0x00, 0x08, P_286,       0,0)
insa(VERR, verr,      OpCls( R16_M16,  NONE,     NONE ), F_0FNO66,0,  no_WDS, 0x00, 0x20, P_286,       0,0)
insa(VERW, verw,      OpCls( R16_M16,  NONE,     NONE ), F_0FNO66,0,  no_WDS, 0x00, 0x28, P_286,       0,0)

; one-operand register/memory instructions

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

; prefixes. must start with LOCK, end with REPZ and be consecutive

insa(LOCK,  lock,     OpCls( NONE,     NONE,       NONE ), 0,      0,  no_RM,  0xF0, 0,    P_86,        AP_LOCK,0)
insa(REP,   rep,      OpCls( NONE,     NONE,       NONE ), 0,      0,  no_RM,  0xF3, 0,    P_86,        AP_REP,0)
insa(REPE,  repe,     OpCls( NONE,     NONE,       NONE ), 0,      0,  no_RM,  0xF3, 0,    P_86,        AP_REPxx,0)
insa(REPNE, repne,    OpCls( NONE,     NONE,       NONE ), 0,      0,  no_RM,  0xF2, 0,    P_86,        AP_REPxx,0)
insa(REPNZ, repnz,    OpCls( NONE,     NONE,       NONE ), 0,      0,  no_RM,  0xF2, 0,    P_86,        AP_REPxx,0)
insa(REPZ,  repz,     OpCls( NONE,     NONE,       NONE ), 0,      0,  no_RM,  0xF3, 0,    P_86,        AP_REPxx,0)

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

; set/reset flags

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

; INC/DEC. (hack for 64-bit in reswords.asm!)

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

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

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

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

insa(MOVBE, movbe,    OpCls( RGT8,     MGT8,       NONE ), F_0F38,  1, no_WDS, 0xF0, 0x00, P_486,       0,0)
insn(MOVBE, 1,        OpCls( MGT8,     RGT8,       NONE ), F_0F38,  0, no_WDS, 0xF1, 0x00, P_486,       0,0)

insa(BOUND_, bound,   OpCls( RGT8,     MS,         NONE ), 0,      1,  no_WDS, 0x62, 0x00, P_186,       0,0)
insa(BSF, bsf,        OpCls( RGT8,     RGT8_MS,    NONE ), F_0F,   1,  no_WDS, 0xBC, 0x00, P_386,       0,0)
insa(BSR, bsr,        OpCls( RGT8,     RGT8_MS,    NONE ), F_0F,   1,  no_WDS, 0xBD, 0x00, P_386,       0,0)
insa(BSWAP, bswap,    OpCls( RGT16,    NONE,       NONE ), F_0F,   0,  R_in_OP,0xC8, 0x00, P_486,       0,0)
insa(CBW, cbw,        OpCls( NONE,     NONE,       NONE ), F_16,   0,  no_RM,  0x98, 0x00, P_86,        0,0)
insa(CDQ, cdq,        OpCls( NONE,     NONE,       NONE ), F_32,   0,  no_RM,  0x99, 0x00, P_386,       0,0)
insa(CWD, cwd,        OpCls( NONE,     NONE,       NONE ), F_16,   0,  no_RM,  0x99, 0x00, P_86,        0,0)
insa(CWDE, cwde,      OpCls( NONE,     NONE,       NONE ), F_32,   0,  no_RM,  0x98, 0x00, P_386,       0,0)
insa(CLTS, clts,      OpCls( NONE,     NONE,       NONE ), 0,      0,  0,      0x0F, 0x06, P_286p,      0,0)
insa(CMPXCHG, cmpxchg,OpCls( R,        R,          NONE ), F_0F,   0,  0,      0xB0, 0x00, P_486,       0,0)
insn(CMPXCHG, 1,      OpCls( MS,       R,          NONE ), F_0F,   0,  0,      0xB0, 0x00, P_486,       AP_LOCK,0)
insa(CMPXCHG8B, cmpxchg8b, OpCls( M64, NONE,       NONE ), F_0F,   0,  0,      0xC7, 0x08, P_586,       AP_LOCK,0)
insa(CPUID, cpuid,    OpCls( NONE,     NONE,       NONE ), 0,      0,  0,      0x0F, 0xA2, P_586,       0,0)
insa(ENTER, enter,    OpCls( I16,      I8_U,       NONE ), 0,      0,  no_RM,  0xC8, 0x00, P_186,       0,0)
insa(HLT, hlt,        OpCls( NONE,     NONE,       NONE ), 0,      0,  no_RM,  0xF4, 0x00, P_86,        0,0)
insa(IMUL, imul,      OpCls( R,        NONE,       NONE ), 0,      0,  0,      0xF6, 0x28, P_86,        0,0)
insn(IMUL, 2,         OpCls( M08,      NONE,       NONE ), 0,      0,  0,      0xF6, 0x28, P_86,        0,0)
insn(IMUL, 3,         OpCls( MGT8,     NONE,       NONE ), 0,      0,  0,      0xF7, 0x28, P_86,        0,0)
insn(IMUL, 4,         OpCls( RGT8,     R_MS,       NONE ), F_0F,   1,  no_WDS, 0xAF, 0x00, P_386,       0,0)
insn(IMUL, 6,         OpCls( RGT8,     I8,         NONE ), 0,      1,  no_WDS, 0x6B, 0x00, P_186,       0,0)
insn(IMUL, 7,         OpCls( RGT8,     I,          NONE ), 0,      1,  no_WDS, 0x69, 0x00, P_186,       0,0)
insn(IMUL, 8,         OpCls( RGT8,     R_MS,       I8_U ), 0,      1,  no_WDS, 0x6B, 0x00, P_186,       0,0)
insn(IMUL, 9,         OpCls( RGT8,     R_MS,       I    ), 0,      1,  no_WDS, 0x69, 0x00, P_186,       0,0)
insa(IN, in,          OpCls( A,        DX_ONLY,    NONE ), 0,      0,  no_RM,  0xEC, 0x00, P_86,        0,0)
insn(IN, 1,           OpCls( A,        I8_U,       NONE ), 0,      0,  no_RM,  0xE4, 0x00, P_86,        0,0)
insa(INT, int,        OpCls( I_3,      NONE,       NONE ), 0,      0,  no_RM,  0xCC, 0x00, P_86,        0,0)
insn(INT, 1,          OpCls( I8_U,     NONE,       NONE ), 0,      0,  no_RM,  0xCD, 0x00, P_86,        0,0)
insa(INTO, into,      OpCls( NONE,     NONE,       NONE ), 0,      0,  no_RM,  0xCE, 0x00, P_86,        0,0)
insa(INVD, invd,      OpCls( NONE,     NONE,       NONE ), F_0F,   0,  no_RM,  0x08, 0x00, P_486,       0,0)
insa(INVLPG, invlpg,  OpCls( M_ANY,    NONE,       NONE ), F_0F,   0,  no_WDS, 0x01, 0x38, P_486,       0,0)
insa(IRET, iret,      OpCls( NONE,     NONE,       NONE ), F_16,   0,  no_RM,  0xCF, 0x00, P_86,        0,0)
insa(IRETD, iretd,    OpCls( NONE,     NONE,       NONE ), F_32,   0,  no_RM,  0xCF, 0x00, P_386,       0,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.

insa(IRETF, iretf,    OpCls( NONE,     NONE,       NONE ), F_16,   0,  no_RM,  0xCF, 0x00, P_86,        0,0)
insa(IRETDF, iretdf,  OpCls( NONE,     NONE,       NONE ), F_32,   0,  no_RM,  0xCF, 0x00, P_386,       0,0)
insa(LAHF, lahf,      OpCls( NONE,     NONE,       NONE ), 0,      0,  no_RM,  0x9F, 0x00, P_86,        0,0)
insa(LAR, lar,        OpCls( RGT8,     RGT8_MS,    NONE ), F_0F,   1,  no_WDS, 0x02, 0x00, P_286,       0,0)
insa(LSL, lsl,        OpCls( RGT8,     RGT8_MS,    NONE ), F_0F,   1,  no_WDS, 0x03, 0x00, P_286,       0,0)
insa(LEA, lea,        OpCls( RGT8,     MS,         NONE ), 0,      1,  no_WDS, 0x8D, 0x00, P_86,        0,0)
insa(LEAVE, leave,    OpCls( NONE,     NONE,       NONE ), 0,      0,  no_RM,  0xC9, 0x00, P_186,       0,0)
insa(LFS, lfs,        OpCls( RGT8,     MFPTR,      NONE ), F_0F,   1,  no_WDS, 0xB4, 0x00, P_386,       0,0)
insa(LGS, lgs,        OpCls( RGT8,     MFPTR,      NONE ), F_0F,   1,  no_WDS, 0xB5, 0x00, P_386,       0,0)
insa(LSS, lss,        OpCls( RGT8,     MFPTR,      NONE ), F_0F,   1,  no_WDS, 0xB2, 0x00, P_386,       0,0)
insa(LGDT, lgdt,      OpCls( M48,      NONE,       NONE ), F_0F,   0,  no_WDS, 0x01, 0x10, P_286p,      0,0)
insa(LIDT, lidt,      OpCls( M48,      NONE,       NONE ), F_0F,   0,  no_WDS, 0x01, 0x18, P_286p,      0,0)
insa(MOVSX, movsx,    OpCls( RGT8,     R_MS,       NONE ), F_0F,   1,  0,      0xBE, 0x00, P_386,       0,0)
insa(MOVZX, movzx,    OpCls( RGT8,     R_MS,       NONE ), F_0F,   1,  0,      0xB6, 0x00, P_386,       0,0)
insa(NOP, nop,        OpCls( NONE,     NONE,       NONE ), 0,      0,  no_RM,  0x90, 0x00, P_86,        0,0)
insa(OUT, out,        OpCls( DX_ONLY,  A,          NONE ), 0,      0,  no_RM,  0xEE, 0x00, P_86,        0,0)
insn(OUT, 1,          OpCls( I8_U,     A,          NONE ), 0,      0,  no_RM,  0xE6, 0x00, P_86,        0,0)

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

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

insa(CMOVA,   cmova,   OpCls( RGT8, R_MS, NONE ), F_0F, 1, no_WDS, 0x47, 0x00, P_686, 0,0)
insa(CMOVAE,  cmovae,  OpCls( RGT8, R_MS, NONE ), F_0F, 1, no_WDS, 0x43, 0x00, P_686, 0,0)
insa(CMOVB,   cmovb,   OpCls( RGT8, R_MS, NONE ), F_0F, 1, no_WDS, 0x42, 0x00, P_686, 0,0)
insa(CMOVBE,  cmovbe,  OpCls( RGT8, R_MS, NONE ), F_0F, 1, no_WDS, 0x46, 0x00, P_686, 0,0)
insa(CMOVC,   cmovc,   OpCls( RGT8, R_MS, NONE ), F_0F, 1, no_WDS, 0x42, 0x00, P_686, 0,0)
insa(CMOVE,   cmove,   OpCls( RGT8, R_MS, NONE ), F_0F, 1, no_WDS, 0x44, 0x00, P_686, 0,0)
insa(CMOVG,   cmovg,   OpCls( RGT8, R_MS, NONE ), F_0F, 1, no_WDS, 0x4F, 0x00, P_686, 0,0)
insa(CMOVGE,  cmovge,  OpCls( RGT8, R_MS, NONE ), F_0F, 1, no_WDS, 0x4D, 0x00, P_686, 0,0)
insa(CMOVL,   cmovl,   OpCls( RGT8, R_MS, NONE ), F_0F, 1, no_WDS, 0x4C, 0x00, P_686, 0,0)
insa(CMOVLE,  cmovle,  OpCls( RGT8, R_MS, NONE ), F_0F, 1, no_WDS, 0x4E, 0x00, P_686, 0,0)
insa(CMOVNA,  cmovna,  OpCls( RGT8, R_MS, NONE ), F_0F, 1, no_WDS, 0x46, 0x00, P_686, 0,0)
insa(CMOVNAE, cmovnae, OpCls( RGT8, R_MS, NONE ), F_0F, 1, no_WDS, 0x42, 0x00, P_686, 0,0)
insa(CMOVNB,  cmovnb,  OpCls( RGT8, R_MS, NONE ), F_0F, 1, no_WDS, 0x43, 0x00, P_686, 0,0)
insa(CMOVNBE, cmovnbe, OpCls( RGT8, R_MS, NONE ), F_0F, 1, no_WDS, 0x47, 0x00, P_686, 0,0)
insa(CMOVNC,  cmovnc,  OpCls( RGT8, R_MS, NONE ), F_0F, 1, no_WDS, 0x43, 0x00, P_686, 0,0)
insa(CMOVNE,  cmovne,  OpCls( RGT8, R_MS, NONE ), F_0F, 1, no_WDS, 0x45, 0x00, P_686, 0,0)
insa(CMOVNG,  cmovng,  OpCls( RGT8, R_MS, NONE ), F_0F, 1, no_WDS, 0x4E, 0x00, P_686, 0,0)
insa(CMOVNGE, cmovnge, OpCls( RGT8, R_MS, NONE ), F_0F, 1, no_WDS, 0x4C, 0x00, P_686, 0,0)
insa(CMOVNL,  cmovnl,  OpCls( RGT8, R_MS, NONE ), F_0F, 1, no_WDS, 0x4D, 0x00, P_686, 0,0)
insa(CMOVNLE, cmovnle, OpCls( RGT8, R_MS, NONE ), F_0F, 1, no_WDS, 0x4F, 0x00, P_686, 0,0)
insa(CMOVNO,  cmovno,  OpCls( RGT8, R_MS, NONE ), F_0F, 1, no_WDS, 0x41, 0x00, P_686, 0,0)
insa(CMOVNP,  cmovnp,  OpCls( RGT8, R_MS, NONE ), F_0F, 1, no_WDS, 0x4B, 0x00, P_686, 0,0)
insa(CMOVNS,  cmovns,  OpCls( RGT8, R_MS, NONE ), F_0F, 1, no_WDS, 0x49, 0x00, P_686, 0,0)
insa(CMOVNZ,  cmovnz,  OpCls( RGT8, R_MS, NONE ), F_0F, 1, no_WDS, 0x45, 0x00, P_686, 0,0)
insa(CMOVO,   cmovo,   OpCls( RGT8, R_MS, NONE ), F_0F, 1, no_WDS, 0x40, 0x00, P_686, 0,0)
insa(CMOVP,   cmovp,   OpCls( RGT8, R_MS, NONE ), F_0F, 1, no_WDS, 0x4A, 0x00, P_686, 0,0)
insa(CMOVPE,  cmovpe,  OpCls( RGT8, R_MS, NONE ), F_0F, 1, no_WDS, 0x4A, 0x00, P_686, 0,0)
insa(CMOVPO,  cmovpo,  OpCls( RGT8, R_MS, NONE ), F_0F, 1, no_WDS, 0x4B, 0x00, P_686, 0,0)
insa(CMOVS,   cmovs,   OpCls( RGT8, R_MS, NONE ), F_0F, 1, no_WDS, 0x48, 0x00, P_686, 0,0)
insa(CMOVZ,   cmovz,   OpCls( RGT8, R_MS, NONE ), F_0F, 1, no_WDS, 0x44, 0x00, P_686, 0,0)

; FPU opcodes

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

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

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

insa(FADD, fadd,      OpCls( ST,       STI,        NONE ), 0,      0,  0,      0xD8, 0xC0, P_87,        0,0)
insn(FADD, 1,         OpCls( STI,      ST,         NONE ), 0,      0,  0,      0xDC, 0xC0, P_87,        0,0)
insn(FADD, 2,         OpCls( M32,      NONE,       NONE ), 0,      0,  0,      0xD8, 0x00, P_87,        0,0)
insn(FADD, 3,         OpCls( M64,      NONE,       NONE ), 0,      0,  0,      0xDC, 0x00, P_87,        0,0)
insn(FADD, 4,         OpCls( NONE,     NONE,       NONE ), 0,      0,  0,      0xDE, 0xC1, P_87,        0,0)
insa(FADDP, faddp,    OpCls( STI,      ST,         NONE ), 0,      0,  0,      0xDE, 0xC0, P_87,        0,0)
insn(FADDP, 1,        OpCls( NONE,     NONE,       NONE ), 0,      0,  0,      0xDE, 0xC1, P_87,        0,0)
insa(FMUL, fmul,      OpCls( ST,       STI,        NONE ), 0,      0,  0,      0xD8, 0xC8, P_87,        0,0)
insn(FMUL, 1,         OpCls( STI,      ST,         NONE ), 0,      0,  0,      0xDC, 0xC8, P_87,        0,0)
insn(FMUL, 2,         OpCls( M32,      NONE,       NONE ), 0,      0,  0,      0xD8, 0x08, P_87,        0,0)
insn(FMUL, 3,         OpCls( M64,      NONE,       NONE ), 0,      0,  0,      0xDC, 0x08, P_87,        0,0)
insn(FMUL, 4,         OpCls( NONE,     NONE,       NONE ), 0,      0,  0,      0xDE, 0xC9, P_87,        0,0)
insa(FMULP, fmulp,    OpCls( STI,      ST,         NONE ), 0,      0,  0,      0xDE, 0xC8, P_87,        0,0)
insn(FMULP, 1,        OpCls( NONE,     NONE,       NONE ), 0,      0,  0,      0xDE, 0xC9, P_87,        0,0)

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

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

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

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

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

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

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

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

insa(F2XM1, f2xm1,    OpCls( NONE,     NONE,       NONE ), 0,      0,  0,      0xD9, 0xF0, P_87,        0,0)
insa(FABS, fabs,      OpCls( NONE,     NONE,       NONE ), 0,      0,  0,      0xD9, 0xE1, P_87,        0,0)
insa(FBLD, fbld,      OpCls( M80,      NONE,       NONE ), 0,      0,  0,      0xDF, 0x20, P_87,        0,0)
insa(FBSTP, fbstp,    OpCls( M80,      NONE,       NONE ), 0,      0,  0,      0xDF, 0x30, P_87,        0,0)
insa(FCHS, fchs,      OpCls( NONE,     NONE,       NONE ), 0,      0,  0,      0xD9, 0xE0, P_87,        0,0)
insa(FLD1, fld1,      OpCls( NONE,     NONE,       NONE ), 0,      0,  0,      0xD9, 0xE8, P_87,        0,0)
insa(FLDL2E, fldl2e,  OpCls( NONE,     NONE,       NONE ), 0,      0,  0,      0xD9, 0xEA, P_87,        0,0)
insa(FLDL2T, fldl2t,  OpCls( NONE,     NONE,       NONE ), 0,      0,  0,      0xD9, 0xE9, P_87,        0,0)
insa(FLDLG2, fldlg2,  OpCls( NONE,     NONE,       NONE ), 0,      0,  0,      0xD9, 0xEC, P_87,        0,0)
insa(FLDLN2, fldln2,  OpCls( NONE,     NONE,       NONE ), 0,      0,  0,      0xD9, 0xED, P_87,        0,0)
insa(FLDPI, fldpi,    OpCls( NONE,     NONE,       NONE ), 0,      0,  0,      0xD9, 0xEB, P_87,        0,0)
insa(FLDZ, fldz,      OpCls( NONE,     NONE,       NONE ), 0,      0,  0,      0xD9, 0xEE, P_87,        0,0)
insa(FDECSTP, fdecstp,OpCls( NONE,     NONE,       NONE ), 0,      0,  0,      0xD9, 0xF6, P_87,        0,0)
insa(FINCSTP, fincstp,OpCls( NONE,     NONE,       NONE ), 0,      0,  0,      0xD9, 0xF7, P_87,        0,0)
insa(FFREE, ffree,    OpCls( STI,      NONE,       NONE ), 0,      0,  0,      0xDD, 0xC0, P_87,        0,0)

; FFREEP is undocumented (same as FFREE + POP)

insa(FFREEP, ffreep,  OpCls( STI,      NONE,       NONE ), 0,      0,  0,      0xDF, 0xC0, P_87,        0,0)
insa(FNOP, fnop,      OpCls( NONE,     NONE,       NONE ), 0,      0,  0,      0xD9, 0xD0, P_87,        0,0)
insa(FPREM, fprem,    OpCls( NONE,     NONE,       NONE ), 0,      0,  0,      0xD9, 0xF8, P_87,        0,0)
insa(FPREM1, fprem1,  OpCls( NONE,     NONE,       NONE ), 0,      0,  0,      0xD9, 0xF5, P_387,       0,0)
insa(FRNDINT, frndint,OpCls( NONE,     NONE,       NONE ), 0,      0,  0,      0xD9, 0xFC, P_87,        0,0)
insa(FSCALE, fscale,  OpCls( NONE,     NONE,       NONE ), 0,      0,  0,      0xD9, 0xFD, P_87,        0,0)
insa(FSETPM, fsetpm,  OpCls( NONE,     NONE,       NONE ), 0,      0,  0,      0xDB, 0xE4, P_287,       0,0)
insa(FSQRT, fsqrt,    OpCls( NONE,     NONE,       NONE ), 0,      0,  0,      0xD9, 0xFA, P_87,        0,0)
insa(FTST, ftst,      OpCls( NONE,     NONE,       NONE ), 0,      0,  0,      0xD9, 0xE4, P_87,        0,0)
insa(FWAIT, fwait,    OpCls( NONE,     NONE,       NONE ), 0,      0,  no_RM,  0x9B, 0x00, P_87,        0,0)
insa(FXAM, fxam,      OpCls( NONE,     NONE,       NONE ), 0,      0,  0,      0xD9, 0xE5, P_87,        0,0)
insa(FXCH, fxch,      OpCls( STI,      NONE,       NONE ), 0,      0,  0,      0xD9, 0xC8, P_87,        0,0)
insn(FXCH, 1,         OpCls( NONE,     NONE,       NONE ), 0,      0,  0,      0xD9, 0xC9, P_87,        0,0)
insa(FXRSTOR, fxrstor,OpCls( M_ANY,    NONE,       NONE ), F_0F,   0,  no_WDS, 0xAE, 0x08, P_686 or P_SSE1,0,0)
insa(FXSAVE, fxsave,  OpCls( M_ANY,    NONE,       NONE ), F_0F,   0,  no_WDS, 0xAE, 0x00, P_686 or P_SSE1,0,0)
insa(FXTRACT, fxtract,OpCls( NONE,     NONE,       NONE ), 0,      0,  0,      0xD9, 0xF4, P_87,        0,0)
insa(FYL2X, fyl2x,    OpCls( NONE,     NONE,       NONE ), 0,      0,  0,      0xD9, 0xF1, P_87,        0,0)
insa(FYL2XP1, fyl2xp1,OpCls( NONE,     NONE,       NONE ), 0,      0,  0,      0xD9, 0xF9, P_87,        0,0)

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

insa(EMMS, emms,      OpCls( NONE,     NONE,       NONE ), F_0F,   0,  no_RM,  0x77, 0x00, P_586 or P_MMX, 0,0)
insa(CLFLUSH, clflush,OpCls( M_ANY,    NONE,       NONE ), F_0F,   0,  no_WDS, 0xAE, 0x38, P_686 or P_SSE2,0,0)
insa(LDMXCSR, ldmxcsr,OpCls( M32,      NONE,       NONE ), F_0F,   0,  no_WDS, 0xAE, 0x10, P_686 or P_SSE1,0,0)
insa(STMXCSR, stmxcsr,OpCls( M32,      NONE,       NONE ), F_0F,   0,  no_WDS, 0xAE, 0x18, P_686 or P_SSE1,0,0)
insa(LFENCE, lfence,  OpCls( NONE,     NONE,       NONE ), F_0F,   0,  no_WDS, 0xAE, 0xE8, P_686 or P_SSE2,0,0)
insa(MFENCE, mfence,  OpCls( NONE,     NONE,       NONE ), F_0F,   0,  no_WDS, 0xAE, 0xF0, P_686 or P_SSE2,0,0)
insa(SFENCE, sfence,  OpCls( NONE,     NONE,       NONE ), F_0F,   0,  no_WDS, 0xAE, 0xF8, P_686 or P_SSE1,0,0)
insa(PREFETCHNTA,prefetchnta, OpCls( M_ANY, NONE,  NONE ), F_0F,   0,  no_WDS, 0x18, 0x00, P_686 or P_SSE1,0,0)
insa(PREFETCHT0, prefetcht0, OpCls( M_ANY, NONE,   NONE ), F_0F,   0,  no_WDS, 0x18, 0x08, P_686 or P_SSE1,0,0)
insa(PREFETCHT1, prefetcht1, OpCls( M_ANY, NONE,   NONE ), F_0F,   0,  no_WDS, 0x18, 0x10, P_686 or P_SSE1,0,0)
insa(PREFETCHT2, prefetcht2, OpCls( M_ANY, NONE,   NONE ), F_0F,   0,  no_WDS, 0x18, 0x18, P_686 or P_SSE1,0,0)
insa(PAUSE, pause,    OpCls( NONE,     NONE,       NONE ), F_F3,   0,  no_RM,  0x90, 0x00, P_686 or P_SSE2,0,0)

insa(ADDPD, addpd, OpCls( XMM, XMM_M128_M64, NONE ), F_660F, 1, no_WDS, 0x58, 0x00, P_686 or P_SSE2, 0, 0xE0)
insa(ADDPS, addps, OpCls( XMM, XMM_M128_M32, NONE ), F_0F,   1, no_WDS, 0x58, 0x00, P_686 or P_SSE1, 0, 0xE0)
insa(ADDSD, addsd, OpCls( XMM, XMM_M64,      NONE ), F_F20F, 1, no_WDS, 0x58, 0x00, P_686 or P_SSE2, 0, 0xE0)
insa(ADDSS, addss, OpCls( XMM, XMM_M32,      NONE ), F_F30F, 1, no_WDS, 0x58, 0x00, P_686 or P_SSE1, 0, 0xE0)
insa(DIVPD, divpd, OpCls( XMM, XMM_M128_M64, NONE ), F_660F, 1, no_WDS, 0x5E, 0x00, P_686 or P_SSE2, 0, 0xE0)
insa(DIVPS, divps, OpCls( XMM, XMM_M128_M32, NONE ), F_0F,   1, no_WDS, 0x5E, 0x00, P_686 or P_SSE1, 0, 0xE0)
insa(DIVSD, divsd, OpCls( XMM, XMM_M64,      NONE ), F_F20F, 1, no_WDS, 0x5E, 0x00, P_686 or P_SSE2, 0, 0xE0)
insa(DIVSS, divss, OpCls( XMM, XMM_M32,      NONE ), F_F30F, 1, no_WDS, 0x5E, 0x00, P_686 or P_SSE1, 0, 0xE0)
insa(MAXPD, maxpd, OpCls( XMM, XMM_M128_M64, NONE ), F_660F, 1, no_WDS, 0x5F, 0x00, P_686 or P_SSE2, 0, 0xE0)
insa(MAXPS, maxps, OpCls( XMM, XMM_M128_M32, NONE ), F_0F,   1, no_WDS, 0x5F, 0x00, P_686 or P_SSE1, 0, 0xE0)
insa(MAXSD, maxsd, OpCls( XMM, XMM_M64,      NONE ), F_F20F, 1, no_WDS, 0x5F, 0x00, P_686 or P_SSE2, 0, 0xE0)
insa(MAXSS, maxss, OpCls( XMM, XMM_M32,      NONE ), F_F30F, 1, no_WDS, 0x5F, 0x00, P_686 or P_SSE1, 0, 0xE0)
insa(MINPD, minpd, OpCls( XMM, XMM_M128_M64, NONE ), F_660F, 1, no_WDS, 0x5D, 0x00, P_686 or P_SSE2, 0, 0xE0)
insa(MINPS, minps, OpCls( XMM, XMM_M128_M32, NONE ), F_0F,   1, no_WDS, 0x5D, 0x00, P_686 or P_SSE1, 0, 0xE0)
insa(MINSD, minsd, OpCls( XMM, XMM_M64,      NONE ), F_F20F, 1, no_WDS, 0x5D, 0x00, P_686 or P_SSE2, 0, 0xE0)
insa(MINSS, minss, OpCls( XMM, XMM_M32,      NONE ), F_F30F, 1, no_WDS, 0x5D, 0x00, P_686 or P_SSE1, 0, 0xE0)
insa(MULPD, mulpd, OpCls( XMM, XMM_M128_M64, NONE ), F_660F, 1, no_WDS, 0x59, 0x00, P_686 or P_SSE2, 0, 0xE0)
insa(MULPS, mulps, OpCls( XMM, XMM_M128_M32, NONE ), F_0F,   1, no_WDS, 0x59, 0x00, P_686 or P_SSE1, 0, 0xE0)
insa(MULSD, mulsd, OpCls( XMM, XMM_M64,      NONE ), F_F20F, 1, no_WDS, 0x59, 0x00, P_686 or P_SSE2, 0, 0xE0)
insa(MULSS, mulss, OpCls( XMM, XMM_M32,      NONE ), F_F30F, 1, no_WDS, 0x59, 0x00, P_686 or P_SSE1, 0, 0xE0)
insa(SQRTPD,sqrtpd,OpCls( XMM, XMM_M128_M64, NONE ), F_660F, 1, no_WDS, 0x51, 0x00, P_686 or P_SSE2, 0, 0xF0)
insa(SQRTPS,sqrtps,OpCls( XMM, XMM_M128_M32, NONE ), F_0F,   1, no_WDS, 0x51, 0x00, P_686 or P_SSE1, 0, 0xF0)
insa(SQRTSD,sqrtsd,OpCls( XMM, XMM_M64,      NONE ), F_F20F, 1, no_WDS, 0x51, 0x00, P_686 or P_SSE2, 0, 0xF0)
insa(SQRTSS,sqrtss,OpCls( XMM, XMM_M32,      NONE ), F_F30F, 1, no_WDS, 0x51, 0x00, P_686 or P_SSE1, 0, 0xF0)
insa(SUBPD, subpd, OpCls( XMM, XMM_M128_M64, NONE ), F_660F, 1, no_WDS, 0x5C, 0x00, P_686 or P_SSE2, 0, 0xE0)
insa(SUBPS, subps, OpCls( XMM, XMM_M128_M32, NONE ), F_0F,   1, no_WDS, 0x5C, 0x00, P_686 or P_SSE1, 0, 0xE0)
insa(SUBSD, subsd, OpCls( XMM, XMM_M64,      NONE ), F_F20F, 1, no_WDS, 0x5C, 0x00, P_686 or P_SSE2, 0, 0xE0)
insa(SUBSS, subss, OpCls( XMM, XMM_M32,      NONE ), F_F30F, 1, no_WDS, 0x5C, 0x00, P_686 or P_SSE1, 0, 0xE0)

insa(CMPPD, cmppd, OpCls( XMM, XMM_M128,     I8_U ), F_660F, 1, no_WDS, 0xC2, 0x00, P_686 or P_SSE2,0,0)
insa(CMPPS, cmpps, OpCls( XMM, XMM_M128,     I8_U ), F_0F,   1, no_WDS, 0xC2, 0x00, P_686 or P_SSE1,0,0)
insa(CMPSS, cmpss, OpCls( XMM, XMM_M32,      I8_U ), F_F30F, 1, no_WDS, 0xC2, 0x00, P_686 or P_SSE1,0,0)

insa(CMPEQPD,    cmpeqpd,    OpCls( XMM, XMM_M128, HID ), F_660F, 1, no_WDS, 0xC2, 0x00, P_686 or P_SSE2, 0, 0 )
insa(CMPLTPD,    cmpltpd,    OpCls( XMM, XMM_M128, HID ), F_660F, 1, no_WDS, 0xC2, 0x00, P_686 or P_SSE2, 0, 0 )
insa(CMPLEPD,    cmplepd,    OpCls( XMM, XMM_M128, HID ), F_660F, 1, no_WDS, 0xC2, 0x00, P_686 or P_SSE2, 0, 0 )
insa(CMPUNORDPD, cmpunordpd, OpCls( XMM, XMM_M128, HID ), F_660F, 1, no_WDS, 0xC2, 0x00, P_686 or P_SSE2, 0, 0 )
insa(CMPNEQPD,   cmpneqpd,   OpCls( XMM, XMM_M128, HID ), F_660F, 1, no_WDS, 0xC2, 0x00, P_686 or P_SSE2, 0, 0 )
insa(CMPNLTPD,   cmpnltpd,   OpCls( XMM, XMM_M128, HID ), F_660F, 1, no_WDS, 0xC2, 0x00, P_686 or P_SSE2, 0, 0 )
insa(CMPNLEPD,   cmpnlepd,   OpCls( XMM, XMM_M128, HID ), F_660F, 1, no_WDS, 0xC2, 0x00, P_686 or P_SSE2, 0, 0 )
insa(CMPORDPD,   cmpordpd,   OpCls( XMM, XMM_M128, HID ), F_660F, 1, no_WDS, 0xC2, 0x00, P_686 or P_SSE2, 0, 0 )

insa(CMPEQPS,    cmpeqps,    OpCls( XMM, XMM_M128, HID ), F_0F,   1, no_WDS, 0xC2, 0x00, P_686 or P_SSE1, 0, 0 )
insa(CMPLTPS,    cmpltps,    OpCls( XMM, XMM_M128, HID ), F_0F,   1, no_WDS, 0xC2, 0x00, P_686 or P_SSE1, 0, 0 )
insa(CMPLEPS,    cmpleps,    OpCls( XMM, XMM_M128, HID ), F_0F,   1, no_WDS, 0xC2, 0x00, P_686 or P_SSE1, 0, 0 )
insa(CMPUNORDPS, cmpunordps, OpCls( XMM, XMM_M128, HID ), F_0F,   1, no_WDS, 0xC2, 0x00, P_686 or P_SSE1, 0, 0 )
insa(CMPNEQPS,   cmpneqps,   OpCls( XMM, XMM_M128, HID ), F_0F,   1, no_WDS, 0xC2, 0x00, P_686 or P_SSE1, 0, 0 )
insa(CMPNLTPS,   cmpnltps,   OpCls( XMM, XMM_M128, HID ), F_0F,   1, no_WDS, 0xC2, 0x00, P_686 or P_SSE1, 0, 0 )
insa(CMPNLEPS,   cmpnleps,   OpCls( XMM, XMM_M128, HID ), F_0F,   1, no_WDS, 0xC2, 0x00, P_686 or P_SSE1, 0, 0 )
insa(CMPORDPS,   cmpordps,   OpCls( XMM, XMM_M128, HID ), F_0F,   1, no_WDS, 0xC2, 0x00, P_686 or P_SSE1, 0, 0 )

insa(CMPEQSD,    cmpeqsd,    OpCls( XMM, XMM_M64,  HID ), F_F20F, 1, no_WDS, 0xC2, 0x00, P_686 or P_SSE2, 0, 0 )
insa(CMPLTSD,    cmpltsd,    OpCls( XMM, XMM_M64,  HID ), F_F20F, 1, no_WDS, 0xC2, 0x00, P_686 or P_SSE2, 0, 0 )
insa(CMPLESD,    cmplesd,    OpCls( XMM, XMM_M64,  HID ), F_F20F, 1, no_WDS, 0xC2, 0x00, P_686 or P_SSE2, 0, 0 )
insa(CMPUNORDSD, cmpunordsd, OpCls( XMM, XMM_M64,  HID ), F_F20F, 1, no_WDS, 0xC2, 0x00, P_686 or P_SSE2, 0, 0 )
insa(CMPNEQSD,   cmpneqsd,   OpCls( XMM, XMM_M64,  HID ), F_F20F, 1, no_WDS, 0xC2, 0x00, P_686 or P_SSE2, 0, 0 )
insa(CMPNLTSD,   cmpnltsd,   OpCls( XMM, XMM_M64,  HID ), F_F20F, 1, no_WDS, 0xC2, 0x00, P_686 or P_SSE2, 0, 0 )
insa(CMPNLESD,   cmpnlesd,   OpCls( XMM, XMM_M64,  HID ), F_F20F, 1, no_WDS, 0xC2, 0x00, P_686 or P_SSE2, 0, 0 )
insa(CMPORDSD,   cmpordsd,   OpCls( XMM, XMM_M64,  HID ), F_F20F, 1, no_WDS, 0xC2, 0x00, P_686 or P_SSE2, 0, 0 )

insa(CMPEQSS,    cmpeqss,    OpCls( XMM, XMM_M32,  HID ), F_F30F, 1, no_WDS, 0xC2, 0x00, P_686 or P_SSE1, 0, 0 )
insa(CMPLTSS,    cmpltss,    OpCls( XMM, XMM_M32,  HID ), F_F30F, 1, no_WDS, 0xC2, 0x00, P_686 or P_SSE1, 0, 0 )
insa(CMPLESS,    cmpless,    OpCls( XMM, XMM_M32,  HID ), F_F30F, 1, no_WDS, 0xC2, 0x00, P_686 or P_SSE1, 0, 0 )
insa(CMPUNORDSS, cmpunordss, OpCls( XMM, XMM_M32,  HID ), F_F30F, 1, no_WDS, 0xC2, 0x00, P_686 or P_SSE1, 0, 0 )
insa(CMPNEQSS,   cmpneqss,   OpCls( XMM, XMM_M32,  HID ), F_F30F, 1, no_WDS, 0xC2, 0x00, P_686 or P_SSE1, 0, 0 )
insa(CMPNLTSS,   cmpnltss,   OpCls( XMM, XMM_M32,  HID ), F_F30F, 1, no_WDS, 0xC2, 0x00, P_686 or P_SSE1, 0, 0 )
insa(CMPNLESS,   cmpnless,   OpCls( XMM, XMM_M32,  HID ), F_F30F, 1, no_WDS, 0xC2, 0x00, P_686 or P_SSE1, 0, 0 )
insa(CMPORDSS,   cmpordss,   OpCls( XMM, XMM_M32,  HID ), F_F30F, 1, no_WDS, 0xC2, 0x00, P_686 or P_SSE1, 0, 0 )

insa(ANDNPD, andnpd,  OpCls( XMM, XMM_M128_M64, NONE ), F_660F, 1,  no_WDS, 0x55, 0x00, P_686 or P_SSE2,0,0xE0)
insa(ANDNPS, andnps,  OpCls( XMM, XMM_M128, NONE ), F_0F,   1,  no_WDS, 0x55, 0x00, P_686 or P_SSE1,0,0xE0)
insa(ANDPD, andpd,    OpCls( XMM, XMM_M128_M64, NONE ), F_660F, 1,  no_WDS, 0x54, 0x00, P_686 or P_SSE2,0,0xE0)
insa(ANDPS, andps,    OpCls( XMM, XMM_M128, NONE ), F_0F,   1,  no_WDS, 0x54, 0x00, P_686 or P_SSE1,0,0xE0)
insa(ORPD, orpd,      OpCls( XMM, XMM_M128_M64, NONE ), F_660F, 1,  no_WDS, 0x56, 0x00, P_686 or P_SSE2,0,0xF0)
insa(ORPS, orps,      OpCls( XMM, XMM_M128, NONE ), F_0F,   1,  no_WDS, 0x56, 0x00, P_686 or P_SSE1,0,0xF0)
insa(COMISD, comisd,  OpCls( XMM, XMM_M64,  NONE ), F_660F, 1,  no_WDS, 0x2F, 0x00, P_686 or P_SSE2,0,0xB0)
insa(COMISS, comiss,  OpCls( XMM, XMM_M32,  NONE ), F_0F,   1,  no_WDS, 0x2F, 0x00, P_686 or P_SSE1,0,0xE0)
insa(XORPD, xorpd,    OpCls( XMM, XMM_M128_M64, NONE ), F_660F, 1,  no_WDS, 0x57, 0x00, P_686 or P_SSE2,0,0xE0)
insa(XORPS, xorps,    OpCls( XMM, XMM_M128, NONE ), F_0F,   1,  no_WDS, 0x57, 0x00, P_686 or P_SSE1,0,0xE0)

insa(CVTPD2PI, cvtpd2pi,   OpCls( MMX,      XMM_M128, NONE ), F_660F, 1, no_WDS, 0x2D, 0x00, P_686 or P_SSE2,0,0)
insa(CVTPS2PI, cvtps2pi,   OpCls( MMX,      XMM_M64,  NONE ), F_0F,   1, no_WDS, 0x2D, 0x00, P_686 or P_SSE1,0,0)
insa(CVTSD2SI, cvtsd2si,   OpCls( R32_M32,  XMM_M64,  NONE ), F_F20F, 1, no_WDS, 0x2D, 0x00, P_686 or P_SSE2,0,0xB0)
insn(CVTSD2SI, 1,          OpCls( R64_M64,  XMM_M64,  NONE ), F_F20F, 1, no_WDS, 0x2D, 0x00, P_686 or P_SSE2,0,0xB2)
insa(CVTSS2SI, cvtss2si,   OpCls( R32_M32,  XMM_M32,  NONE ), F_F30F, 1, no_WDS, 0x2D, 0x00, P_686 or P_SSE1,0,0xB0)
insn(CVTSS2SI, 1,          OpCls( R64_M64,  XMM_M32,  NONE ), F_F30F, 1, no_WDS, 0x2D, 0x00, P_686 or P_SSE1,0,0xB2)
insa(CVTPI2PD, cvtpi2pd,   OpCls( XMM,      MMX_M64,  NONE ), F_660F, 1, no_WDS, 0x2A, 0x00, P_686 or P_SSE2,0,0)
insa(CVTPI2PS, cvtpi2ps,   OpCls( XMM,      MMX_M64,  NONE ), F_0F,   1, no_WDS, 0x2A, 0x00, P_686 or P_SSE1,0,0)
insa(CVTSI2SD, cvtsi2sd,   OpCls( XMM,      R32_M32,  NONE ), F_F20F, 1, no_WDS, 0x2A, 0x00, P_686 or P_SSE2,0,0xE0)
insn(CVTSI2SD, 1,          OpCls( XMM,      R64_M64,  NONE ), F_F20F, 1, no_WDS, 0x2A, 0x00, P_686 or P_SSE2,0,0xE2)
insa(CVTSI2SS, cvtsi2ss,   OpCls( XMM,      R32_M32,  NONE ), F_F30F, 1, no_WDS, 0x2A, 0x00, P_686 or P_SSE1,0,0xE0)
insn(CVTSI2SS, 1,          OpCls( XMM,      R64_M64,  NONE ), F_F30F, 1, no_WDS, 0x2A, 0x00, P_686 or P_SSE1,0,0xE2)
insa(CVTTPD2PI, cvttpd2pi, OpCls( MMX,      XMM_M128, NONE ), F_660F, 1, no_WDS, 0x2C, 0x00, P_686 or P_SSE2,0,0)
insa(CVTTPS2PI, cvttps2pi, OpCls( MMX,      XMM_M64,  NONE ), F_0F,   1, no_WDS, 0x2C, 0x00, P_686 or P_SSE1,0,0)
insa(CVTTSD2SI, cvttsd2si, OpCls( R32_M32,  XMM_M64,  NONE ), F_F20F, 1, no_WDS, 0x2C, 0x00, P_686 or P_SSE2,0,0xB0)
insn(CVTTSD2SI, 1,         OpCls( R64_M64,  XMM_M64,  NONE ), F_F20F, 1, no_WDS, 0x2C, 0x00, P_686 or P_SSE2,0,0xB2)
insa(CVTTSS2SI, cvttss2si, OpCls( R32_M32,  XMM_M32,  NONE ), F_F30F, 1, no_WDS, 0x2C, 0x00, P_686 or P_SSE1,0,0xB0)
insn(CVTTSS2SI, 1,         OpCls( R64_M64,  XMM_M32,  NONE ), F_F30F, 1, no_WDS, 0x2C, 0x00, P_686 or P_SSE1,0,0xB2)

insa(CVTDQ2PS, cvtdq2ps,   OpCls( XMM,  XMM_M128_M32, NONE ), F_0F,   1, no_WDS, 0x5B, 0x00, P_686 or P_SSE2,0,0xE0)
insa(CVTPS2DQ, cvtps2dq,   OpCls( XMM,  XMM_M128_M32, NONE ), F_660F, 1, no_WDS, 0x5B, 0x00, P_686 or P_SSE2,0,0xE0)
insa(CVTTPS2DQ, cvttps2dq, OpCls( XMM,  XMM_M128_M32, NONE ), F_F30F, 1, no_WDS, 0x5B, 0x00, P_686 or P_SSE2,0,0xE0)
insa(CVTPD2DQ, cvtpd2dq,   OpCls( XMM,      XMM_M128, NONE ), F_F20F, 1, no_WDS, 0xE6, 0x00, P_686 or P_SSE2,0,0xE0)
insn(CVTPD2DQ, 1,          OpCls( XMM,  YMM_M256_M64, NONE ), F_F20F, 1, no_WDS, 0xE6, 0x00, P_686 or P_AVX, 0,0xE0)
insa(CVTDQ2PD, cvtdq2pd,   OpCls( XMM,      XMM_M64,  NONE ), F_F30F, 1, no_WDS, 0xE6, 0x00, P_686 or P_SSE2,0,0xE0)
insn(CVTDQ2PD, 1,          OpCls( YMM,  XMM_M128_M32, NONE ), F_F30F, 1, no_WDS, 0xE6, 0x00, P_686 or P_AVX, 0,0xE0)
insa(CVTTPD2DQ, cvttpd2dq, OpCls( XMM,      XMM_M128, NONE ), F_660F, 1, no_WDS, 0xE6, 0x00, P_686 or P_SSE2,0,0xE0)
insn(CVTTPD2DQ, 1,         OpCls( XMM,  YMM_M256_M64, NONE ), F_660F, 1, no_WDS, 0xE6, 0x00, P_686 or P_AVX, 0,0xE0)
insa(CVTPD2PS, cvtpd2ps,   OpCls( XMM,      XMM_M128, NONE ), F_660F, 1, no_WDS, 0x5A, 0x00, P_686 or P_SSE2,0,0xE0)
insn(CVTPD2PS, 1,          OpCls( XMM,  YMM_M256_M64, NONE ), F_660F, 1, no_WDS, 0x5A, 0x00, P_686 or P_AVX, 0,0xE0)
insa(CVTPS2PD, cvtps2pd,   OpCls( XMM,      XMM_M64,  NONE ), F_0F,   1, no_WDS, 0x5A, 0x00, P_686 or P_SSE2,0,0xE0)
insn(CVTPS2PD, 1,          OpCls( XMM,  XMM_M128_M32, NONE ), F_0F,   1, no_WDS, 0x5A, 0x00, P_686 or P_SSE2,0,0xE0)
insa(CVTSD2SS, cvtsd2ss,   OpCls( XMM,      XMM_M64,  NONE ), F_F20F, 1, no_WDS, 0x5A, 0x00, P_686 or P_SSE2,0,0xE0)
insa(CVTSS2SD, cvtss2sd,   OpCls( XMM,      XMM_M32,  NONE ), F_F30F, 1, no_WDS, 0x5A, 0x00, P_686 or P_SSE2,0,0xE0)
insa(MASKMOVDQU, maskmovdqu, OpCls( XMM,    XMM,      NONE ), F_660F, 1, no_WDS, 0xF7, 0x00, P_686 or P_SSE2,0,0)
insa(MASKMOVQ, maskmovq,   OpCls( MMX,      MMX,      NONE ), F_0F,   1, no_WDS, 0xF7, 0x00, P_686 or P_SSE1,0,0)

; Masm (ML64) uses MOVD if a 64-bit register is src,dst. Intel docs prefer MOVQ

insa(MOVD, movd,      OpCls( MMX,      RMGT16,   NONE ), F_0F,   1,  no_WDS, 0x6E, 0x00, P_586 or P_MMX, 0,0xE0)
insn(MOVD, 1,         OpCls( XMM,      RMGT16,   NONE ), F_660F, 1,  no_WDS, 0x6E, 0x00, P_686 or P_SSE2,0,0xE0)
insn(MOVD, 2,         OpCls( RMGT16,   MMX,      NONE ), F_0F,   0,  no_WDS, 0x7E, 0x00, P_586 or P_MMX, 0,0xE0)
insn(MOVD, 3,         OpCls( RMGT16,   XMM,      NONE ), F_660F, 0,  no_WDS, 0x7E, 0x00, P_686 or P_SSE2,0,0xE0)

insa(MOVQ, movq,      OpCls( MMX,      MMX_M64,  NONE ), F_0F,   1,  no_WDS, 0x6F, 0x00, P_586 or P_MMX, 0,0xE0)
insn(MOVQ, 1,         OpCls( M64,      MMX,      NONE ), F_0F,   0,  no_WDS, 0x7F, 0x00, P_586 or P_MMX, 0,0xE0)
insn(MOVQ, 2,         OpCls( M64,      XMM,      NONE ), F_660F, 0,  no_WDS, 0xD6, 0x00, P_686 or P_SSE2,0,0x20)
insn(MOVQ, 3,         OpCls( XMM,      XMM_M64,  NONE ), F_F30F, 1,  no_WDS, 0x7E, 0x00, P_686 or P_SSE2,0,0x20)
insn(MOVQ, 4,         OpCls( XMM,      RMGT16,   NONE ), F_660F, 1,  no_WDS, 0x6E, 0x00, P_686 or P_SSE2,0,0xE0)
insn(MOVQ, 5,         OpCls( RMGT16,   XMM,      NONE ), F_660F, 0,  no_WDS, 0x7E, 0x00, P_686 or P_SSE2,0,0xE0)

insa(MOVAPD, movapd,  OpCls( XMM,      XMM_M128, NONE ), F_660F, 1,  no_WDS, 0x28, 0x00, P_686 or P_SSE2,0,0xE0)
insn(MOVAPD, 1,       OpCls( M128,     XMM,      NONE ), F_660F, 0,  no_WDS, 0x29, 0x00, P_686 or P_SSE2,0,0xE0)
insa(MOVAPS, movaps,  OpCls( XMM,      XMM_M128, NONE ), F_0F,   1,  no_WDS, 0x28, 0x00, P_686 or P_SSE1,0,0xE0)
insn(MOVAPS, 1,       OpCls( M128,     XMM,      NONE ), F_0F,   0,  no_WDS, 0x29, 0x00, P_686 or P_SSE1,0,0xE0)
insa(MOVDQA, movdqa,  OpCls( XMM,      XMM_M128, NONE ), F_660F, 1,  no_WDS, 0x6F, 0x00, P_686 or P_SSE2,0,0)
insn(MOVDQA, 1,       OpCls( M128,     XMM,      NONE ), F_660F, 0,  no_WDS, 0x7F, 0x00, P_686 or P_SSE2,0,0)
insa(MOVDQU, movdqu,  OpCls( XMM,      XMM_M128, NONE ), F_F30F, 1,  no_WDS, 0x6F, 0x00, P_686 or P_SSE2,0,0)
insn(MOVDQU, 1,       OpCls( M128,     XMM,      NONE ), F_F30F, 0,  no_WDS, 0x7F, 0x00, P_686 or P_SSE2,0,0)
insa(MOVUPD, movupd,  OpCls( XMM,      XMM_M128, NONE ), F_660F, 1,  no_WDS, 0x10, 0x00, P_686 or P_SSE2,0,0xE0)
insn(MOVUPD, 1,       OpCls( M128,     XMM,      NONE ), F_660F, 0,  no_WDS, 0x11, 0x00, P_686 or P_SSE2,0,0xE0)
insa(MOVUPS, movups,  OpCls( XMM,      XMM_M128, NONE ), F_0F,   1,  no_WDS, 0x10, 0x00, P_686 or P_SSE1,0,0xE0)
insn(MOVUPS, 1,       OpCls( M128,     XMM,      NONE ), F_0F,   0,  no_WDS, 0x11, 0x00, P_686 or P_SSE1,0,0xE0)
insa(MOVHPD, movhpd,  OpCls( XMM,      M64,      NONE ), F_660F, 1,  no_WDS, 0x16, 0x00, P_686 or P_SSE2,0,0xE0)
insn(MOVHPD, 1,       OpCls( M64,      XMM,      NONE ), F_660F, 0,  no_WDS, 0x17, 0x00, P_686 or P_SSE2,0,0xE0)
insa(MOVHPS, movhps,  OpCls( XMM,      M64,      NONE ), F_0F,   1,  no_WDS, 0x16, 0x00, P_686 or P_SSE1,0,0xE0)
insn(MOVHPS, 1,       OpCls( M64,      XMM,      NONE ), F_0F,   0,  no_WDS, 0x17, 0x00, P_686 or P_SSE1,0,0xE0)
insa(MOVLPD, movlpd,  OpCls( XMM,      M64,      NONE ), F_660F, 1,  no_WDS, 0x12, 0x00, P_686 or P_SSE2,0,0xE0)
insn(MOVLPD, 1,       OpCls( M64,      XMM,      NONE ), F_660F, 0,  no_WDS, 0x13, 0x00, P_686 or P_SSE2,0,0xE0)
insa(MOVLPS, movlps,  OpCls( XMM,      M64,      NONE ), F_0F,   1,  no_WDS, 0x12, 0x00, P_686 or P_SSE1,0,0xE0)
insn(MOVLPS, 1,       OpCls( M64,      XMM,      NONE ), F_0F,   0,  no_WDS, 0x13, 0x00, P_686 or P_SSE1,0,0xE0)
insa(MOVHLPS, movhlps, OpCls( XMM,     XMM,      NONE ), F_0F,   1,  no_WDS, 0x12, 0x00, P_686 or P_SSE1,0,0xE0)
insa(MOVLHPS, movlhps, OpCls( XMM,     XMM,      NONE ), F_0F,   1,  no_WDS, 0x16, 0x00, P_686 or P_SSE1,0,0xE0)
insa(MOVDQ2Q, movdq2q, OpCls( MMX,     XMM,      NONE ), F_F20F, 1,  no_WDS, 0xD6, 0x00, P_686 or P_SSE2,0,0)
insa(MOVQ2DQ, movq2dq, OpCls( XMM,     MMX,      NONE ), F_F30F, 1,  no_WDS, 0xD6, 0x00, P_686 or P_SSE2,0,0)
insa(MOVMSKPD, movmskpd, OpCls( RGT16, XMM,      NONE ), F_660F, 1,  no_WDS, 0x50, 0x00, P_686 or P_SSE2,0,0)
insn(MOVMSKPD, 1,     OpCls( RGT16,    YMM,      NONE ), F_660F, 1,  no_WDS, 0x50, 0x00, P_686 or P_AVX, 0,0)
insa(MOVMSKPS, movmskps, OpCls( RGT16, XMM,      NONE ), F_0F,   1,  no_WDS, 0x50, 0x00, P_686 or P_SSE1,0,0)
insn(MOVMSKPS, 1,     OpCls( RGT16,    YMM,      NONE ), F_0F,   1,  no_WDS, 0x50, 0x00, P_686 or P_AVX, 0,0)
insa(MOVNTDQ, movntdq,OpCls( M128,     XMM,      NONE ), F_660F, 0,  no_WDS, 0xE7, 0x00, P_686 or P_SSE2,0,0xE0)
insa(MOVNTI, movnti,  OpCls( MGT16,    RGT16,    NONE ), F_0F,   0,  no_WDS, 0xC3, 0x00, P_686 or P_SSE2,0,0)
insa(MOVNTPD, movntpd,OpCls( M128,     XMM,      NONE ), F_660F, 0,  no_WDS, 0x2B, 0x00, P_686 or P_SSE2,0,0xE0)
insa(MOVNTPS, movntps,OpCls( M128,     XMM,      NONE ), F_0F,   0,  no_WDS, 0x2B, 0x00, P_686 or P_SSE1,0,0xE0)
insa(MOVNTQ, movntq,  OpCls( M64,      MMX,      NONE ), F_0F,   0,  no_WDS, 0xE7, 0x00, P_686 or P_SSE1,0,0)
insa(MOVSS, movss,    OpCls( XMM,      XMM_M32,  NONE ), F_F30F, 1,  no_WDS, 0x10, 0x00, P_686 or P_SSE1,0,0xE0)
insn(MOVSS, 1,        OpCls( M32,      XMM,      NONE ), F_F30F, 0,  no_WDS, 0x11, 0x00, P_686 or P_SSE1,0,0xE0)

insa(PACKSSDW, packssdw,OpCls( MMX,  MMX_M64,    NONE ), F_0F,   1,  no_WDS, 0x6B, 0x00, P_586 or P_MMX, 0,0xF0)
insn(PACKSSDW, 1,     OpCls( XMM,    XMM_M128,   NONE ), F_660F, 1,  no_WDS, 0x6B, 0x00, P_686 or P_SSE2,0,0xF0)
insa(PACKSSWB, packsswb,OpCls( MMX,  MMX_M64,    NONE ), F_0F,   1,  no_WDS, 0x63, 0x00, P_586 or P_MMX, 0,0xF0)
insn(PACKSSWB, 1,     OpCls( XMM,    XMM_M128,   NONE ), F_660F, 1,  no_WDS, 0x63, 0x00, P_686 or P_SSE2,0,0xF0)
insa(PACKUSWB, packuswb,OpCls( MMX,  MMX_M64,    NONE ), F_0F,   1,  no_WDS, 0x67, 0x00, P_586 or P_MMX, 0,0xF0)
insn(PACKUSWB, 1,     OpCls( XMM,    XMM_M128,   NONE ), F_660F, 1,  no_WDS, 0x67, 0x00, P_686 or P_SSE2,0,0xF0)
insa(PADDB, paddb,    OpCls( MMX,    MMX_M64_08, NONE ), F_0F,   1,  no_WDS, 0xFC, 0x00, P_586 or P_MMX, 0,0xE0)
insn(PADDB, 1,        OpCls( XMM,    XMM_M128_08,NONE ), F_660F, 1,  no_WDS, 0xFC, 0x00, P_686 or P_SSE2,0,0xE0)
insn(PADDB, 2,        OpCls( YMM,    YMM_M256_08,NONE ), F_660F, 1,  no_WDS, 0xFC, 0x00, P_686 or P_SSE2,0,0xE0)
insa(PADDW, paddw,    OpCls( MMX,    MMX_M64_16, NONE ), F_0F,   1,  no_WDS, 0xFD, 0x00, P_586 or P_MMX, 0,0xE0)
insn(PADDW, 1,        OpCls( XMM,    XMM_M128_16,NONE ), F_660F, 1,  no_WDS, 0xFD, 0x00, P_686 or P_SSE2,0,0xE0)
insn(PADDW, 2,        OpCls( YMM,    YMM_M256,   NONE ), F_660F, 1,  no_WDS, 0xFD, 0x00, P_686 or P_SSE2,0,0xE0)
insa(PADDD, paddd,    OpCls( MMX,    MMX_M64_32, NONE ), F_0F,   1,  no_WDS, 0xFE, 0x00, P_586 or P_MMX, 0,0)
insn(PADDD, 1,        OpCls( XMM,    XMM_M128_32,NONE ), F_660F, 1,  no_WDS, 0xFE, 0x00, P_686 or P_SSE2,0,0xE0)
insn(PADDD, 2,        OpCls( YMM,    YMM_M256,   NONE ), F_660F, 1,  no_WDS, 0xFE, 0x00, P_686 or P_SSE2,0,0xE0)
insa(PADDQ, paddq,    OpCls( MMX,    MMX_M64,    NONE ), F_0F,   1,  no_WDS, 0xD4, 0x00, P_686 or P_SSE2,0,0xE0)
insn(PADDQ, 1,        OpCls( XMM,    XMM_M128_64,NONE ), F_660F, 1,  no_WDS, 0xD4, 0x00, P_686 or P_SSE2,0,0xE0)
insn(PADDQ, 2,        OpCls( YMM,    YMM_M256,   NONE ), F_660F, 1,  no_WDS, 0xD4, 0x00, P_686 or P_SSE2,0,0xE0)
insa(PADDSB, paddsb,  OpCls( MMX,    MMX_M64_08, NONE ), F_0F,   1,  no_WDS, 0xEC, 0x00, P_586 or P_MMX, 0,0xE0)
insn(PADDSB, 1,       OpCls( XMM,    XMM_M128_08,NONE ), F_660F, 1,  no_WDS, 0xEC, 0x00, P_686 or P_SSE2,0,0xE0)
insn(PADDSB, 2,       OpCls( YMM,    YMM_M256,   NONE ), F_660F, 1,  no_WDS, 0xEC, 0x00, P_686 or P_SSE2,0,0xE0)
insa(PADDSW, paddsw,  OpCls( MMX,    MMX_M64_16, NONE ), F_0F,   1,  no_WDS, 0xED, 0x00, P_586 or P_MMX, 0,0xE0)
insn(PADDSW, 1,       OpCls( XMM,    XMM_M128_16,NONE ), F_660F, 1,  no_WDS, 0xED, 0x00, P_686 or P_SSE2,0,0xE0)
insn(PADDSW, 2,       OpCls( YMM,    YMM_M256,   NONE ), F_660F, 1,  no_WDS, 0xED, 0x00, P_686 or P_SSE2,0,0xE0)
insa(PADDUSB, paddusb,OpCls( MMX,    MMX_M64_08, NONE ), F_0F,   1,  no_WDS, 0xDC, 0x00, P_586 or P_MMX, 0,0xE0)
insn(PADDUSB, 1,      OpCls( XMM,    XMM_M128_08,NONE ), F_660F, 1,  no_WDS, 0xDC, 0x00, P_686 or P_SSE2,0,0xE0)
insn(PADDUSB, 2,      OpCls( YMM,    YMM_M256,   NONE ), F_660F, 1,  no_WDS, 0xDC, 0x00, P_686 or P_SSE2,0,0xE0)
insa(PADDUSW, paddusw,OpCls( MMX,    MMX_M64_16, NONE ), F_0F,   1,  no_WDS, 0xDD, 0x00, P_586 or P_MMX, 0,0xE0)
insn(PADDUSW, 1,      OpCls( XMM,    XMM_M128_16,NONE ), F_660F, 1,  no_WDS, 0xDD, 0x00, P_686 or P_SSE2,0,0xE0)
insn(PADDUSW, 2,      OpCls( YMM,    YMM_M256,   NONE ), F_660F, 1,  no_WDS, 0xDD, 0x00, P_686 or P_SSE2,0,0xE0)
insa(PAND, pand,      OpCls( MMX,    MMX_M64,    NONE ), F_0F,   1,  no_WDS, 0xDB, 0x00, P_586 or P_MMX, 0,0)
insn(PAND, 1,         OpCls( XMM,    XMM_M128,   NONE ), F_660F, 1,  no_WDS, 0xDB, 0x00, P_686 or P_SSE2,0,0)
insa(PANDN, pandn,    OpCls( MMX,    MMX_M64,    NONE ), F_0F,   1,  no_WDS, 0xDF, 0x00, P_586 or P_MMX, 0,0)
insn(PANDN, 1,        OpCls( XMM,    XMM_M128,   NONE ), F_660F, 1,  no_WDS, 0xDF, 0x00, P_686 or P_SSE2,0,0)
insa(PAVGB, pavgb,    OpCls( MMX,    MMX_M64,    NONE ), F_0F,   1,  no_WDS, 0xE0, 0x00, P_686 or P_SSE1,0,0xE0)
insn(PAVGB, 1,        OpCls( XMM,    XMM_M128, NONE ), F_660F, 1,  no_WDS, 0xE0, 0x00, P_686 or P_SSE2,0,0xE0)
insn(PAVGB, 2,        OpCls( YMM,    YMM_M256, NONE ), F_660F, 1,  no_WDS, 0xE0, 0x00, P_686 or P_SSE2,0,0xE0)
insa(PAVGW, pavgw,    OpCls( MMX,    MMX_M64,  NONE ), F_0F,   1,  no_WDS, 0xE3, 0x00, P_686 or P_SSE1,0,0xE0)
insn(PAVGW, 1,        OpCls( XMM,    XMM_M128, NONE ), F_660F, 1,  no_WDS, 0xE3, 0x00, P_686 or P_SSE2,0,0xE0)
insn(PAVGW, 2,        OpCls( YMM,    YMM_M256, NONE ), F_660F, 1,  no_WDS, 0xE3, 0x00, P_686 or P_SSE2,0,0xE0)
insa(PCMPEQB, pcmpeqb,OpCls( MMX,    MMX_M64,  NONE ), F_0F,   1,  no_WDS, 0x74, 0x00, P_586 or P_MMX, 0,0xF0)
insn(PCMPEQB, 1,      OpCls( XMM,    XMM_M128, NONE ), F_660F, 1,  no_WDS, 0x74, 0x00, P_686 or P_SSE2,0,0xF0)
insn(PCMPEQB, 2,      OpCls( K,      XMM_M128, NONE ), F_660F, 1,  no_WDS, 0x74, 0x00, P_686 or P_SSE2,0,0xF0)
insa(PCMPEQW, pcmpeqw,OpCls( MMX,    MMX_M64,  NONE ), F_0F,   1,  no_WDS, 0x75, 0x00, P_586 or P_MMX, 0,0xF0)
insn(PCMPEQW, 1,      OpCls( XMM,    XMM_M128, NONE ), F_660F, 1,  no_WDS, 0x75, 0x00, P_686 or P_SSE2,0,0xF0)
insn(PCMPEQW, 2,      OpCls( K,      XMM_M128, NONE ), F_660F, 1,  no_WDS, 0x75, 0x00, P_686 or P_SSE2,0,0xF0)
insa(PCMPEQD, pcmpeqd,OpCls( MMX,    MMX_M64,  NONE ), F_0F,   1,  no_WDS, 0x76, 0x00, P_586 or P_MMX, 0,0xF0)
insn(PCMPEQD, 1,      OpCls( XMM,    XMM_M128, NONE ), F_660F, 1,  no_WDS, 0x76, 0x00, P_686 or P_SSE2,0,0xF0)
insn(PCMPEQD, 2,      OpCls( K,  XMM_M128_M32, NONE ), F_660F, 1,  no_WDS, 0x76, 0x00, P_686 or P_SSE2,0,0xF0)
insa(PCMPGTB, pcmpgtb,OpCls( MMX,    MMX_M64,  NONE ), F_0F,   1,  no_WDS, 0x64, 0x00, P_586 or P_MMX, 0,0xF0)
insn(PCMPGTB, 1,      OpCls( XMM,    XMM_M128, NONE ), F_660F, 1,  no_WDS, 0x64, 0x00, P_686 or P_SSE2,0,0xF0)
insn(PCMPGTB, 2,      OpCls( K,      XMM_M128, NONE ), F_660F, 1,  no_WDS, 0x64, 0x00, P_686 or P_SSE2,0,0xF0)
insa(PCMPGTW, pcmpgtw,OpCls( MMX,    MMX_M64,  NONE ), F_0F,   1,  no_WDS, 0x65, 0x00, P_586 or P_MMX, 0,0xF0)
insn(PCMPGTW, 1,      OpCls( XMM,    XMM_M128, NONE ), F_660F, 1,  no_WDS, 0x65, 0x00, P_686 or P_SSE2,0,0xF0)
insn(PCMPGTW, 2,      OpCls( K,      XMM_M128, NONE ), F_660F, 1,  no_WDS, 0x65, 0x00, P_686 or P_SSE2,0,0xF0)
insa(PCMPGTD, pcmpgtd,OpCls( MMX,    MMX_M64,  NONE ), F_0F,   1,  no_WDS, 0x66, 0x00, P_586 or P_MMX, 0,0xF0)
insn(PCMPGTD, 1,      OpCls( XMM,    XMM_M128, NONE ), F_660F, 1,  no_WDS, 0x66, 0x00, P_686 or P_SSE2,0,0xF0)
insn(PCMPGTD, 2,      OpCls( K,  XMM_M128_M32, NONE ), F_660F, 1,  no_WDS, 0x66, 0x00, P_686 or P_SSE2,0,0xF0)

insa(PEXTRW, pextrw,  OpCls( RGT16,  MMX,      I8_U ), F_0F,   1,  no_WDS, 0xC5, 0x00, P_686 or P_SSE1,0,0xE0)
insn(PEXTRW, 1,       OpCls( RGT16,  XMM,      I8_U ), F_660F, 1,  no_WDS, 0xC5, 0x00, P_686 or P_SSE1,0,0x30)
insn(PEXTRW, 2,       OpCls( M16,    XMM,      I8_U ), F_660F3A, 0,no_WDS, 0x15, 0x00, P_686 or P_SSE4,0,0xE0)
insa(PINSRW, pinsrw,  OpCls( MMX,      R32_M16,  I8_U ), F_0F,   1,  no_WDS, 0xC4, 0x00, P_686 or P_SSE1,0,0xE0)
insn(PINSRW, 1,       OpCls( XMM,      R32_M16,  I8_U ), F_660F, 1,  no_WDS, 0xC4, 0x00, P_686 or P_SSE1,0,0xE0)
insa(PMADDWD, pmaddwd,OpCls( MMX,      MMX_M64,  NONE ), F_0F,   1,  no_WDS, 0xF5, 0x00, P_586 or P_MMX, 0,0xE0)
insn(PMADDWD, 1,      OpCls( XMM,      XMM_M128, NONE ), F_660F, 1,  no_WDS, 0xF5, 0x00, P_686 or P_SSE2,0,0xE0)
insa(PMAXSW, pmaxsw,  OpCls( MMX,      MMX_M64,  NONE ), F_0F,   1,  no_WDS, 0xEE, 0x00, P_686 or P_SSE1,0,0xE0)
insn(PMAXSW, 1,       OpCls( XMM,      XMM_M128, NONE ), F_660F, 1,  no_WDS, 0xEE, 0x00, P_686 or P_SSE2,0,0xE0)
insa(PMAXUB, pmaxub,  OpCls( MMX,      MMX_M64,  NONE ), F_0F,   1,  no_WDS, 0xDE, 0x00, P_686 or P_SSE1,0,0xE0)
insn(PMAXUB, 1,       OpCls( XMM,      XMM_M128, NONE ), F_660F, 1,  no_WDS, 0xDE, 0x00, P_686 or P_SSE2,0,0xE0)
insa(PMINSW, pminsw,  OpCls( MMX,      MMX_M64,  NONE ), F_0F,   1,  no_WDS, 0xEA, 0x00, P_686 or P_SSE1,0,0xE0)
insn(PMINSW, 1,       OpCls( XMM,      XMM_M128, NONE ), F_660F, 1,  no_WDS, 0xEA, 0x00, P_686 or P_SSE2,0,0xE0)
insa(PMINUB, pminub,  OpCls( MMX,      MMX_M64,  NONE ), F_0F,   1,  no_WDS, 0xDA, 0x00, P_686 or P_SSE1,0,0xE0)
insn(PMINUB, 1,       OpCls( XMM,      XMM_M128, NONE ), F_660F, 1,  no_WDS, 0xDA, 0x00, P_686 or P_SSE2,0,0xE0)
insa(PMOVMSKB, pmovmskb, OpCls( RGT16, MMX,      NONE ), F_0F,   1,  no_WDS, 0xD7, 0x00, P_686 or P_SSE1,0,0)
insn(PMOVMSKB, 1,     OpCls( RGT16,    XMM,      NONE ), F_660F, 1,  no_WDS, 0xD7, 0x00, P_686 or P_SSE2,0,0)
insn(PMOVMSKB, 2,     OpCls( RGT16,    YMM,      NONE ), F_660F, 1,  no_WDS, 0xD7, 0x00, P_686 or P_SSE2,0,0)

insa(PMULHUW, pmulhuw,OpCls( MMX,      MMX_M64,  NONE ), F_0F,   1,  no_WDS, 0xE4, 0x00, P_586 or P_SSE1,0,0)
insn(PMULHUW, 1,      OpCls( XMM,      XMM_M128, NONE ), F_660F, 1,  no_WDS, 0xE4, 0x00, P_686 or P_SSE2,0,0)
insa(PMULHW, pmulhw,  OpCls( MMX,      MMX_M64,  NONE ), F_0F,   1,  no_WDS, 0xE5, 0x00, P_586 or P_MMX, 0,0xE0)
insn(PMULHW, 1,       OpCls( XMM,      XMM_M128, NONE ), F_660F, 1,  no_WDS, 0xE5, 0x00, P_686 or P_SSE2,0,0xE0)
insa(PMULLW, pmullw,  OpCls( MMX,      MMX_M64,  NONE ), F_0F,   1,  no_WDS, 0xD5, 0x00, P_586 or P_MMX, 0,0xE0)
insn(PMULLW, 1,       OpCls( XMM,      XMM_M128, NONE ), F_660F, 1,  no_WDS, 0xD5, 0x00, P_686 or P_SSE2,0,0xE0)
insa(PMULUDQ, pmuludq,OpCls( MMX,      MMX_M64,  NONE ), F_0F,   1,  no_WDS, 0xF4, 0x00, P_686 or P_SSE2,0,0xE2)
insn(PMULUDQ, 1,      OpCls( XMM,  XMM_M128_M64, NONE ), F_660F, 1,  no_WDS, 0xF4, 0x00, P_686 or P_SSE2,0,0xE2)
insa(POR, por,        OpCls( MMX,      MMX_M64,  NONE ), F_0F,   1,  no_WDS, 0xEB, 0x00, P_586 or P_MMX, 0,0)
insn(POR,  1,         OpCls( XMM,      XMM_M128, NONE ), F_660F, 1,  no_WDS, 0xEB, 0x00, P_686 or P_SSE2,0,0xE0)
insa(PSADBW, psadbw,  OpCls( MMX,      MMX_M64,  NONE ), F_0F,   1,  no_WDS, 0xF6, 0x00, P_686 or P_SSE1,0,0xE0)
insn(PSADBW, 1,       OpCls( XMM,      XMM_M128, NONE ), F_660F, 1,  no_WDS, 0xF6, 0x00, P_686 or P_SSE2,0,0xE0)
insa(PSHUFD, pshufd,  OpCls( XMM,  XMM_M128_M32, I8_U ), F_660F, 1,  no_WDS, 0x70, 0x00, P_686 or P_SSE2,0,0x80)
insa(PSHUFW, pshufw,  OpCls( MMX,      MMX_M64,  I8_U ), F_0F,   1,  no_WDS, 0x70, 0x00, P_686 or P_SSE1,0,0xE0)
insa(PSHUFHW, pshufhw,OpCls( XMM,      XMM_M128, I8_U ), F_F30F, 1,  no_WDS, 0x70, 0x00, P_686 or P_SSE2,0,0xE0)
insa(PSHUFLW, pshuflw,OpCls( XMM,      XMM_M128, I8_U ), F_F20F, 1,  no_WDS, 0x70, 0x00, P_686 or P_SSE2,0,0xE0)

insa(PSLLW, psllw, OpCls( MMX, MMX_M64,  NONE ), F_0F,   1, no_WDS, 0xF1, 0x00, P_586 or P_MMX, 0,0xE4)
insn(PSLLW, 1,     OpCls( MMX, I8_U,     NONE ), F_0F,   0, no_WDS, 0x71, 0x30, P_586 or P_MMX, 0,0xE4)
insn(PSLLW, 2,     OpCls( XMM, XMM_M128, NONE ), F_660F, 1, no_WDS, 0xF1, 0x00, P_686 or P_SSE2,0,0xE4)
insn(PSLLW, 3,     OpCls( XMM, I8_U,     NONE ), F_660F, 0, no_WDS, 0x71, 0x30, P_686 or P_SSE2,0,0xE4)
insn(PSLLW, 4,     OpCls( XMM, XMM_M128, I8_U ), F_660F, 0, no_WDS, 0x71, 0x30, P_686 or P_SSE2,0,0xE4)
insa(PSLLD, pslld, OpCls( MMX, MMX_M64,  NONE ), F_0F,   1, no_WDS, 0xF2, 0x00, P_586 or P_MMX, 0,0xE0)
insn(PSLLD, 1,     OpCls( MMX, I8_U,     NONE ), F_0F,   0, no_WDS, 0x72, 0x30, P_586 or P_MMX, 0,0xE0)
insn(PSLLD, 2,     OpCls( XMM, XMM_M128, NONE ), F_660F, 1, no_WDS, 0xF2, 0x00, P_686 or P_SSE2,0,0xE0)
insn(PSLLD, 3,     OpCls( XMM, I8_U,     NONE ), F_660F, 0, no_WDS, 0x72, 0x30, P_686 or P_SSE2,0,0x80)
insn(PSLLD, 4,     OpCls(XMM,XMM_M128_M32,I8_U), F_660F, 1, no_WDS, 0x72, 0x30, P_686 or P_AVX, 0,0x10)
insa(PSLLQ, psllq, OpCls( MMX, MMX_M64,  NONE ), F_0F,   1, no_WDS, 0xF3, 0x00, P_586 or P_MMX, 0,0xE0)
insn(PSLLQ, 1,     OpCls( MMX, I8_U,     NONE ), F_0F,   0, no_WDS, 0x73, 0x30, P_586 or P_MMX, 0,0xE0)
insn(PSLLQ, 2,     OpCls( XMM, XMM_M128, NONE ), F_660F, 1, no_WDS, 0xF3, 0x00, P_686 or P_SSE2,0,0xE0)
insn(PSLLQ, 3,     OpCls( XMM, I8_U,     NONE ), F_660F, 0, no_WDS, 0x73, 0x30, P_686 or P_SSE2,0,0x80)
insn(PSLLQ, 4,     OpCls(XMM,XMM_M128_M64,I8_U), F_660F, 1, no_WDS, 0x73, 0x30, P_686 or P_AVX, 0,0x10)

insa(PSRAW, psraw, OpCls( MMX, MMX_M64,  NONE ), F_0F,   1,  no_WDS, 0xE1, 0x00, P_586 or P_MMX, 0,0xE0)
insn(PSRAW, 1,     OpCls( MMX, I8_U,     NONE ), F_0F,   0,  no_WDS, 0x71, 0x20, P_586 or P_MMX, 0,0xE0)
insn(PSRAW, 2,     OpCls( XMM, XMM_M128, NONE ), F_660F, 1,  no_WDS, 0xE1, 0x00, P_586 or P_SSE2,0,0xE0)
insn(PSRAW, 3,     OpCls( XMM, I8_U,     NONE ), F_660F, 0,  no_WDS, 0x71, 0x20, P_686 or P_SSE2,0,0xE0)
insa(PSRAD, psrad, OpCls( MMX, MMX_M64,  NONE ), F_0F,   1,  no_WDS, 0xE2, 0x00, P_586 or P_MMX, 0,0xE0)
insn(PSRAD, 1,     OpCls( MMX, I8_U,     NONE ), F_0F,   0,  no_WDS, 0x72, 0x20, P_586 or P_MMX, 0,0xE0)
insn(PSRAD, 2,     OpCls( XMM, XMM_M128, NONE ), F_660F, 1,  no_WDS, 0xE2, 0x00, P_686 or P_SSE2,0,0xE0)
insn(PSRAD, 3,     OpCls( XMM, I8_U,     NONE ), F_660F, 0,  no_WDS, 0x72, 0x20, P_686 or P_SSE2,0,0x80)
insn(PSRAD, 4,     OpCls(XMM,XMM_M128_M32,I8_U), F_660F, 1,  no_WDS, 0x72, 0x20, P_686 or P_AVX, 0,0x10)

insa(PSRLW, psrlw, OpCls( MMX, MMX_M64,  NONE ), F_0F,   1,  no_WDS, 0xD1, 0x00, P_586 or P_MMX, 0,0xE0)
insn(PSRLW, 1,     OpCls( MMX, I8_U,     NONE ), F_0F,   0,  no_WDS, 0x71, 0x10, P_586 or P_MMX, 0,0xE0)
insn(PSRLW, 2,     OpCls( XMM, XMM_M128, NONE ), F_660F, 1,  no_WDS, 0xD1, 0x00, P_686 or P_SSE2,0,0xE0)
insn(PSRLW, 3,     OpCls( XMM, I8_U,     NONE ), F_660F, 0,  no_WDS, 0x71, 0x10, P_686 or P_SSE2,0,0xE0)

insa(PSRLD, psrld, OpCls( MMX, MMX_M64,  NONE ), F_0F,   1,  no_WDS, 0xD2, 0x00, P_586 or P_MMX, 0,0x90)
insn(PSRLD, 1,     OpCls( MMX, I8_U,     NONE ), F_0F,   0,  no_WDS, 0x72, 0x10, P_586 or P_MMX, 0,0x90)
insn(PSRLD, 2,     OpCls( XMM, XMM_M128, NONE ), F_660F, 1,  no_WDS, 0xD2, 0x00, P_686 or P_SSE2,0,0x40)
insn(PSRLD, 3,     OpCls( XMM, I8_U,     NONE ), F_660F, 0,  no_WDS, 0x72, 0x10, P_686 or P_SSE2,0,0x80)
insn(PSRLD, 4, OpCls( XMM, XMM_M128_M32, I8_U ), F_660F, 1,  no_WDS, 0x72, 0x10, P_686 or P_AVX, 0,0x10)

insa(PSRLQ, psrlq, OpCls( MMX, MMX_M64,  NONE ), F_0F,   1,  no_WDS, 0xD3, 0x00, P_586 or P_MMX, 0,0x90)
insn(PSRLQ, 1,     OpCls( MMX, I8_U,     NONE ), F_0F,   0,  no_WDS, 0x73, 0x10, P_586 or P_MMX, 0,0x90)
insn(PSRLQ, 2,     OpCls( XMM, XMM_M128, NONE ), F_660F, 1,  no_WDS, 0xD3, 0x00, P_686 or P_SSE2,0,0x40)
insn(PSRLQ, 3,     OpCls( XMM, I8_U,     NONE ), F_660F, 0,  no_WDS, 0x73, 0x10, P_686 or P_SSE2,0,0x80)
insn(PSRLQ, 4, OpCls( XMM, XMM_M128_M64, I8_U ), F_660F, 1,  no_WDS, 0x73, 0x10, P_686 or P_AVX, 0,0x10)

insa(PSLLDQ, pslldq, OpCls( XMM, I8_U,   NONE ), F_660F, 0,  no_WDS, 0x73, 0x38, P_686 or P_SSE2,0,0xF0)
insn(PSLLDQ, 1,    OpCls( XMM, XMM_M128, I8_U ), F_660F, 0,  no_WDS, 0x73, 0x38, P_686 or P_SSE2,0,0xF0)
insa(PSRLDQ, psrldq, OpCls( XMM, I8_U,   NONE ), F_660F, 0,  no_WDS, 0x73, 0x18, P_686 or P_SSE2,0,0x90)

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

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

; K3D instructions

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

insa(ADDSUBPD, addsubpd,OpCls( XMM,      XMM_M128, NONE ), F_660F, 1,  no_WDS, 0xD0, 0x00, P_686 or P_SSE3,0,0)
insa(ADDSUBPS, addsubps,OpCls( XMM,      XMM_M128, NONE ), F_F20F, 1,  no_WDS, 0xD0, 0x00, P_686 or P_SSE3,0,0)
insa(FISTTP, fisttp,    OpCls( M32,      NONE,     NONE ), 0,      0,  no_WDS, 0xDB, 0x08, P_686 or P_SSE3,0,0)
insn(FISTTP, 1,         OpCls( M64,      NONE,     NONE ), 0,      0,  no_WDS, 0xDD, 0x08, P_686 or P_SSE3,0,0)
insn(FISTTP, 2,         OpCls( M16,      NONE,     NONE ), 0,      0,  no_WDS, 0xDF, 0x08, P_686 or P_SSE3,0,0)
insa(HADDPD, haddpd,    OpCls( XMM,      XMM_M128, NONE ), F_660F, 1,  no_WDS, 0x7C, 0x00, P_686 or P_SSE3,0,0)
insa(HADDPS, haddps,    OpCls( XMM,      XMM_M128, NONE ), F_F20F, 1,  no_WDS, 0x7C, 0x00, P_686 or P_SSE3,0,0)
insa(HSUBPD, hsubpd,    OpCls( XMM,      XMM_M128, NONE ), F_660F, 1,  no_WDS, 0x7D, 0x00, P_686 or P_SSE3,0,0)
insa(HSUBPS, hsubps,    OpCls( XMM,      XMM_M128, NONE ), F_F20F, 1,  no_WDS, 0x7D, 0x00, P_686 or P_SSE3,0,0)
insa(LDDQU, lddqu,      OpCls( XMM,      M128,     NONE ), F_F20F, 1,  no_WDS, 0xF0, 0x00, P_686 or P_SSE3,0,0)
insa(MONITOR, monitor,  OpCls( NONE,     NONE,     NONE ), F_0F,   0,  0,      0x01, 0xC8, P_686 or P_SSE3,0,0)
insa(MOVDDUP, movddup,  OpCls( XMM,      XMM_M64,  NONE ), F_F20F, 1,  no_WDS, 0x12, 0x00, P_686 or P_SSE3,0,0xE0)
insn(MOVDDUP, 1,        OpCls( YMM,      YMM_M256, NONE ), F_F20F, 1,  no_WDS, 0x12, 0x00, P_686 or P_AVX, 0,0xE0)

insa(MOVSHDUP, movshdup,OpCls( XMM,      XMM_M128, NONE ), F_F30F, 1,  no_WDS, 0x16, 0x00, P_686 or P_SSE3,0,0xF0)
insa(MOVSLDUP, movsldup,OpCls( XMM,      XMM_M128, NONE ), F_F30F, 1,  no_WDS, 0x12, 0x00, P_686 or P_SSE3,0,0xF0)
insa(MWAIT, mwait,      OpCls( NONE,     NONE,     NONE ), F_0F,   0,  0,      0x01, 0xC9, P_686 or P_SSE3,0,0)

insa(PABSB, pabsb,      OpCls( MMX,  MMX_M64,  NONE ), F_0F38,  1,  no_WDS, 0x1C, 0x00, P_686 or P_SSSE3, 0,0xF0)
insn(PABSB, 1,          OpCls( XMM,  XMM_M128, NONE ), F_660F38,1,  no_WDS, 0x1C, 0x00, P_686 or P_SSSE3, 0,0xF0)
insa(PABSD, pabsd,      OpCls( MMX,  MMX_M64,  NONE ), F_0F38,  1,  no_WDS, 0x1E, 0x00, P_686 or P_SSSE3, 0,0xF0)
insn(PABSD, 1,          OpCls( XMM,  XMM_M128_M32, NONE ), F_660F38,1,  no_WDS, 0x1E, 0x00, P_686 or P_SSSE3, 0,0xF0)
insa(PABSW, pabsw,      OpCls( MMX,  MMX_M64,  NONE ), F_0F38,  1,  no_WDS, 0x1D, 0x00, P_686 or P_SSSE3, 0,0xF0)
insn(PABSW, 1,          OpCls( XMM,  XMM_M128, NONE ), F_660F38,1,  no_WDS, 0x1D, 0x00, P_686 or P_SSSE3, 0,0xF0)
insa(PALIGNR, palignr,  OpCls( MMX,  MMX_M64,  I8_U ), F_0F3A,  1,  no_WDS, 0x0F, 0x00, P_686 or P_SSSE3, 0,0xF0)
insn(PALIGNR, 1,        OpCls( XMM,  XMM_M128, I8_U ), F_660F3A,1,  no_WDS, 0x0F, 0x00, P_686 or P_SSSE3, 0,0xF0)
insa(PHADDD, phaddd,    OpCls( MMX,  MMX_M64,  NONE ), F_0F38,  1,  no_WDS, 0x02, 0x00, P_686 or P_SSSE3, 0,0)
insn(PHADDD, 1,         OpCls( XMM,  XMM_M128, NONE ), F_660F38,1,  no_WDS, 0x02, 0x00, P_686 or P_SSSE3, 0,0)
insa(PHADDSW, phaddsw,  OpCls( MMX,  MMX_M64,  NONE ), F_0F38,  1,  no_WDS, 0x03, 0x00, P_686 or P_SSSE3, 0,0)
insn(PHADDSW, 1,        OpCls( XMM,  XMM_M128, NONE ), F_660F38,1,  no_WDS, 0x03, 0x00, P_686 or P_SSSE3, 0,0)
insa(PHADDW, phaddw,    OpCls( MMX,  MMX_M64,  NONE ), F_0F38,  1,  no_WDS, 0x01, 0x00, P_686 or P_SSSE3, 0,0)
insn(PHADDW, 1,         OpCls( XMM,  XMM_M128, NONE ), F_660F38,1,  no_WDS, 0x01, 0x00, P_686 or P_SSSE3, 0,0)
insa(PHSUBD, phsubd,    OpCls( MMX,  MMX_M64,  NONE ), F_0F38,  1,  no_WDS, 0x06, 0x00, P_686 or P_SSSE3, 0,0)
insn(PHSUBD, 1,         OpCls( XMM,  XMM_M128, NONE ), F_660F38,1,  no_WDS, 0x06, 0x00, P_686 or P_SSSE3, 0,0)
insa(PHSUBSW, phsubsw,  OpCls( MMX,  MMX_M64,  NONE ), F_0F38,  1,  no_WDS, 0x07, 0x00, P_686 or P_SSSE3, 0,0)
insn(PHSUBSW, 1,        OpCls( XMM,  XMM_M128, NONE ), F_660F38,1,  no_WDS, 0x07, 0x00, P_686 or P_SSSE3, 0,0)
insa(PHSUBW, phsubw,    OpCls( MMX,  MMX_M64,  NONE ), F_0F38,  1,  no_WDS, 0x05, 0x00, P_686 or P_SSSE3, 0,0)
insn(PHSUBW, 1,         OpCls( XMM,  XMM_M128, NONE ), F_660F38,1,  no_WDS, 0x05, 0x00, P_686 or P_SSSE3, 0,0)
insa(PMADDUBSW, pmaddubsw, OpCls( MMX, MMX_M64,NONE ), F_0F38,  1, no_WDS, 0x04, 0x00, P_686 or P_SSSE3,  0,0xF0)
insn(PMADDUBSW, 1,      OpCls( XMM,  XMM_M128, NONE ), F_660F38,1,  no_WDS, 0x04, 0x00, P_686 or P_SSSE3, 0,0xF0)
insa(PMULHRSW, pmulhrsw,OpCls( MMX,  MMX_M64,  NONE ), F_0F38,  1,  no_WDS, 0x0B, 0x00, P_686 or P_SSSE3, 0,0xF0)
insn(PMULHRSW, 1,       OpCls( XMM,  XMM_M128, NONE ), F_660F38,1,  no_WDS, 0x0B, 0x00, P_686 or P_SSSE3, 0,0xF0)
insa(PSHUFB, pshufb,    OpCls( MMX,  MMX_M64,  NONE ), F_0F38,  1,  no_WDS, 0x00, 0x00, P_686 or P_SSSE3, 0,0xF0)
insn(PSHUFB, 1,         OpCls( XMM,  XMM_M128, NONE ), F_660F38,1,  no_WDS, 0x00, 0x00, P_686 or P_SSSE3, 0,0xF0)
insa(PSIGNB, psignb,    OpCls( MMX,  MMX_M64,  NONE ), F_0F38,  1,  no_WDS, 0x08, 0x00, P_686 or P_SSSE3, 0,0)
insn(PSIGNB, 1,         OpCls( XMM,  XMM_M128, NONE ), F_660F38,1,  no_WDS, 0x08, 0x00, P_686 or P_SSSE3, 0,0)
insa(PSIGND, psignd,    OpCls( MMX,  MMX_M64,  NONE ), F_0F38,  1,  no_WDS, 0x0A, 0x00, P_686 or P_SSSE3, 0,0)
insn(PSIGND, 1,         OpCls( XMM,  XMM_M128, NONE ), F_660F38,1,  no_WDS, 0x0A, 0x00, P_686 or P_SSSE3, 0,0)
insa(PSIGNW, psignw,    OpCls( MMX,  MMX_M64,  NONE ), F_0F38,  1,  no_WDS, 0x09, 0x00, P_686 or P_SSSE3, 0,0)
insn(PSIGNW, 1,         OpCls( XMM,  XMM_M128, NONE ), F_660F38,1,  no_WDS, 0x09, 0x00, P_686 or P_SSSE3, 0,0)

insa(PCLMULQDQ,pclmulqdq,OpCls( XMM, XMM_M128, I8_U ), F_660F3A,1,  no_WDS, 0x44, 0x00, P_686 or P_SSSE3, 0,0)
insa(AESDECLAST,aesdeclast,OpCls(XMM,XMM_M128, NONE ), F_660F38,1,  no_WDS, 0xDF, 0x00, P_686 or P_SSSE3, 0,0)
insa(AESDEC, aesdec,    OpCls( XMM,  XMM_M128, NONE ), F_660F38,1,  no_WDS, 0xDE, 0x00, P_686 or P_SSSE3, 0,0)
insa(AESENC, aesenc,    OpCls( XMM,  XMM_M128, NONE ), F_660F38,1,  no_WDS, 0xDC, 0x00, P_686 or P_SSSE3, 0,0)
insa(AESENCLAST,aesenclast,OpCls(XMM,XMM_M128, NONE ), F_660F38,1,  no_WDS, 0xDD, 0x00, P_686 or P_SSSE3, 0,0)
insa(AESIMC, aesimc,    OpCls( XMM,  XMM_M128, NONE ), F_660F38,1,  no_WDS, 0xDB, 0x00, P_686 or P_SSSE3, 0,0)
insa(AESKEYGENASSIST,aeskeygenassist,OpCls(XMM,XMM_M128,I8_U),F_660F3A,1,no_WDS,0xDF,0x00,P_686 or P_SSSE3,0,0)
insa(ADCX, adcx,        OpCls( R32,  R32_M32,  NONE ), F_660F38,1,  no_WDS, 0xF6, 0x00, P_686 or P_SSSE3, 0,0)
insn(ADCX, 1,           OpCls( R64,  R64_M64,  NONE ), F_660F38,1,  no_WDS, 0xF6, 0x00, P_686 or P_SSSE3, 0,0)

; added v2.34.59

; NP 0F 01 EE RDPKRU  ZO  V/V
; NP 0F 01 EF WRPKRU  ZO  V/V

insa(RDPKRU,  rdpkru,   OpCls( NONE,     NONE,       NONE ), F_0F,    0, 0,      0x01, 0xEE, P_686,    0,0)
insa(WRPKRU,  wrpkru,   OpCls( NONE,     NONE,       NONE ), F_0F,    0, 0,      0x01, 0xEF, P_686,    0,0)

; F3 0F 01 EF STUI ZO V/V
; F3 0F 3A F0 C0 /ib HRESET imm8, <EAX> V/V


insa(STUI,    stui,     OpCls( NONE,     NONE,       NONE ), F_F30F,  0, 0,      0x01, 0xEF, P_586,    0,0)
insa(HRESET,  hreset,   OpCls( I8_U,     EAX,        NONE ), F_F30F3A,0, no_WDS, 0xF0, 0xC0, P_586,    0,0)

; CDQE must be first in this group, see reswords.asm

insx(CDQE, cdqe,        OpCls( NONE,     NONE,       NONE ), F_48,   0,  no_RM,  0x98, 0x00, P_64,     0,0,      RWF_X64)
insx(CQO, cqo,          OpCls( NONE,     NONE,       NONE ), F_48,   0,  no_RM,  0x99, 0x00, P_64,     0,0,      RWF_X64)
insx(PUSHFQ, pushfq,    OpCls( NONE,     NONE,       NONE ), 0,      0,  no_RM,  0x9C, 0x00, P_64,     0,0,      RWF_X64)
insx(POPFQ, popfq,      OpCls( NONE,     NONE,       NONE ), 0,      0,  no_RM,  0x9D, 0x00, P_64,     0,0,      RWF_X64)
insx(IRETQ, iretq,      OpCls( NONE,     NONE,       NONE ), F_48,   0,  no_RM,  0xCF, 0x00, P_64,     0,0,      RWF_X64)
insx(CMPXCHG16B, cmpxchg16b, OpCls( M128, NONE,      NONE ), F_480F, 0,  0,      0xC7, 0x08, P_64,     AP_LOCK,0, RWF_X64)
insx(MOVSXD,movsxd,     OpCls( R64,      R32_M32,    NONE ), 0,      1,  0,      0x63, 0x00, P_64,     0,0,      RWF_X64)
insx(CMPSQ, cmpsq,      OpCls( NONE,     NONE,       NONE ), F_48,   0,  no_RM,  0xA7, 0x00, P_64,     AP_REPxx,0, RWF_X64)
insn(CMPSQ, 1,          OpCls( M64,      M64,        NONE ), F_48,   0,  no_RM,  0xA7, 0x00, P_64,     AP_REPxx,0)
insx(LODSQ, lodsq,      OpCls( NONE,     NONE,       NONE ), F_48,   0,  no_RM,  0xAD, 0x00, P_64,     AP_REP,0,   RWF_X64)
insn(LODSQ, 1,          OpCls( M64,      NONE,       NONE ), F_48,   0,  no_RM,  0xAD, 0x00, P_64,     AP_REP,0)
insx(MOVSQ, movsq,      OpCls( NONE,     NONE,       NONE ), F_48,   0,  no_RM,  0xA5, 0x00, P_64,     AP_REP,0,   RWF_X64)
insn(MOVSQ, 1,          OpCls( M64,      M64,        NONE ), F_48,   0,  no_RM,  0xA5, 0x00, P_64,     AP_REP,0)
insx(SCASQ, scasq,      OpCls( NONE,     NONE,       NONE ), F_48,   0,  no_RM,  0xAF, 0x00, P_64,     AP_REPxx,0, RWF_X64)
insn(SCASQ, 1,          OpCls( M64,      NONE,       NONE ), F_48,   0,  no_RM,  0xAF, 0x00, P_64,     AP_REPxx,0)
insx(STOSQ, stosq,      OpCls( NONE,     NONE,       NONE ), F_48,   0,  no_RM,  0xAB, 0x00, P_64,     AP_REP,0,   RWF_X64)
insn(STOSQ, 1,          OpCls( M64,      NONE,       NONE ), F_48,   0,  no_RM,  0xAB, 0x00, P_64,     AP_REP,0)

; 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 or P_SSE4,0, 0xE0, RWF_X64)
insx(PINSRQ, pinsrq,    OpCls( XMM,      R64_M64,    I8_U ), F_660F3A,1, no_WDS, 0x22, 0x00, P_64 or P_SSE4,0, 0xE0, RWF_X64)
insx(SWAPGS, swapgs,    OpCls( NONE,     NONE,       NONE ), F_0F,   0,  0,      0x01, 0xF8, P_64,     0,0, RWF_X64)
insx(SYSCALL_, syscall_,OpCls( NONE,     NONE,       NONE ), F_0F,   0,  no_RM,  0x05, 0x00, P_64,     0,0, RWF_X64)
insx(SYSRET, sysret,    OpCls( NONE,     NONE,       NONE ), F_0F,   0,  no_RM,  0x07, 0x00, P_64,     0,0, RWF_X64)

; F3 0F 01 EE CLUI ZO V/I
; F3 0F C7 /6 SENDUIPI reg V/I -- RDPID/RDRAND
; F3 0F 01 ED TESTUI  ZO  V/I
; F3 0F 01 EC UIRET   ZO  V/I

insx(CLUI,    clui,     OpCls( NONE,     NONE,       NONE ), F_F30F,  0, 0,      0x01, 0xEE, P_64,     0,0, RWF_X64)
insx(SENDUIPI,senduipi, OpCls( R64,      NONE,       NONE ), F_F30F,  0, 0,      0xC7, 0x30, P_64,     0,0, RWF_X64)
insx(TESTUI,  testui,   OpCls( NONE,     NONE,       NONE ), F_F30F,  0, 0,      0x01, 0xED, P_64,     0,0, RWF_X64)
insx(UIRET,   uiret,    OpCls( NONE,     NONE,       NONE ), F_F30F,  0, 0,      0x01, 0xEC, P_64,     0,0, RWF_X64)

; Terminate an Indirect Branch in 64-bit Mode

insx(ENDBR64, endbr64,  OpCls( NONE,     NONE,       NONE ), F_F30F, 0,  0,      0x1E, 0xFA, P_64,     0,0, RWF_X64)
insa(ENDBR32, endbr32,  OpCls( NONE,     NONE,       NONE ), F_F30F, 0,  0,      0x1E, 0xFB, P_686,    0,0)

; SSE4.1

insa(BLENDPD, blendpd,  OpCls( XMM,      XMM_M128, I8_U ), F_660F3A, 1,  no_WDS, 0x0D, 0x00, P_686 or P_SSE4, 0,0)
insa(BLENDPS, blendps,  OpCls( XMM,      XMM_M128, I8_U ), F_660F3A, 1,  no_WDS, 0x0C, 0x00, P_686 or P_SSE4, 0,0)
insa(BLENDVPD, blendvpd,OpCls( XMM,      XMM_M128, XMM0 ), F_660F38, 1,  no_WDS, 0x15, 0x00, P_686 or P_SSE4, 0,0)
insa(BLENDVPS, blendvps,OpCls( XMM,      XMM_M128, XMM0 ), F_660F38, 1,  no_WDS, 0x14, 0x00, P_686 or P_SSE4, 0,0)
insa(DPPD, dppd,        OpCls( XMM,      XMM_M128, I8_U ), F_660F3A, 1,  no_WDS, 0x41, 0x00, P_686 or P_SSE4, 0,0)
insa(DPPS, dpps,        OpCls( XMM,      XMM_M128, I8_U ), F_660F3A, 1,  no_WDS, 0x40, 0x00, P_686 or P_SSE4, 0,0)
insa(EXTRACTPS, extractps,OpCls( RGT16,  XMM,      I8_U ), F_660F3A, 0,  no_WDS, 0x17, 0x00, P_686 or P_SSE4, 0,0x80)
insn(EXTRACTPS, 1,      OpCls( M32,      XMM,      I8_U ), F_660F3A, 0,  no_WDS, 0x17, 0x00, P_686 or P_SSE4, 0,0xE0)
insa(INSERTPS, insertps,OpCls( XMM,      XMM_M32,  I8_U ), F_660F3A, 1,  no_WDS, 0x21, 0x00, P_686 or P_SSE4, 0,0xE0)
insa(MOVNTDQA, movntdqa,OpCls( XMM,      M128,     NONE ), F_660F38, 1,  no_WDS, 0x2A, 0x00, P_686 or P_SSE4, 0,0xF0)
insn(MOVNTDQA, 1,       OpCls( YMM,      YMM_M256, NONE ), F_660F38, 1,  no_WDS, 0x2A, 0x00, P_686 or P_SSE4, 0,0xE0)

insa(MPSADBW, mpsadbw,  OpCls( XMM,      XMM_M128, I8_U ), F_660F3A, 1,  no_WDS, 0x42, 0x00, P_686 or P_SSE4, 0,0)
insa(PACKUSDW, packusdw,OpCls( XMM,      XMM_M128, NONE ), F_660F38, 1,  no_WDS, 0x2B, 0x00, P_686 or P_SSE4, 0,0xF0)
insa(PBLENDVB, pblendvb,OpCls( XMM,      XMM_M128, XMM0 ), F_660F38, 1,  no_WDS, 0x10, 0x00, P_686 or P_SSE4, 0,0)
insa(PBLENDW, pblendw,  OpCls( XMM,      XMM_M128, I8_U ), F_660F3A, 1,  no_WDS, 0x0E, 0x00, P_686 or P_SSE4, 0,0)
insa(PCMPEQQ, pcmpeqq,  OpCls( XMM,      XMM_M128, NONE ), F_660F38, 1,  no_WDS, 0x29, 0x00, P_686 or P_SSE4, 0,0xF2)
insn(PCMPEQQ, 1,        OpCls( K,    XMM_M128_M64, NONE ), F_660F38, 1,  no_WDS, 0x29, 0x00, P_686 or P_SSE4, 0,0xF2)

insa(PEXTRB, pextrb,    OpCls( RGT16_M08,XMM,      I8_U ), F_660F3A, 0,  no_WDS, 0x14, 0x00, P_686 or P_SSE4, 0,0xE0)
insa(PEXTRD, pextrd,    OpCls( R32_M32,  XMM,      I8_U ), F_660F3A, 0,  no_WDS, 0x16, 0x00, P_686 or P_SSE4, 0,0xE0)
insa(PHMINPOSUW, phminposuw,OpCls( XMM,  XMM_M128, NONE ), F_660F38, 1,  no_WDS, 0x41, 0x00, P_686 or P_SSE4, 0,0)
insa(PINSRB, pinsrb,    OpCls( XMM,      R32_M08,  I8_U ), F_660F3A, 1,  no_WDS, 0x20, 0x00, P_686 or P_SSE4, 0,0xF0)
insa(PINSRD, pinsrd,    OpCls( XMM,      R32_M32,  I8_U ), F_660F3A, 1,  no_WDS, 0x22, 0x00, P_686 or P_SSE4, 0,0xF0)
insa(PMAXSB, pmaxsb,    OpCls( XMM,      XMM_M128, NONE ), F_660F38, 1,  no_WDS, 0x3C, 0x00, P_686 or P_SSE4, 0,0xF0)
insa(PMAXSD, pmaxsd,    OpCls( XMM,  XMM_M128_M32, NONE ), F_660F38, 1,  no_WDS, 0x3D, 0x00, P_686 or P_SSE4, 0,0xF0)
insa(PMAXUW, pmaxuw,    OpCls( XMM,      XMM_M128, NONE ), F_660F38, 1,  no_WDS, 0x3E, 0x00, P_686 or P_SSE4, 0,0xF0)
insa(PMAXUD, pmaxud,    OpCls( XMM,  XMM_M128_M32, NONE ), F_660F38, 1,  no_WDS, 0x3F, 0x00, P_686 or P_SSE4, 0,0xF0)
insa(PMINSB, pminsb,    OpCls( XMM,      XMM_M128, NONE ), F_660F38, 1,  no_WDS, 0x38, 0x00, P_686 or P_SSE4, 0,0xF0)
insa(PMINSD, pminsd,    OpCls( XMM,  XMM_M128_M32, NONE ), F_660F38, 1,  no_WDS, 0x39, 0x00, P_686 or P_SSE4, 0,0xF0)
insa(PMINUW, pminuw,    OpCls( XMM,      XMM_M128, NONE ), F_660F38, 1,  no_WDS, 0x3A, 0x00, P_686 or P_SSE4, 0,0xF0)
insa(PMINUD, pminud,    OpCls( XMM,  XMM_M128_M32, NONE ), F_660F38, 1,  no_WDS, 0x3B, 0x00, P_686 or P_SSE4, 0,0xF0)
insa(PMOVSXBW, pmovsxbw,OpCls( XMM,      XMM_M64,  NONE ), F_660F38, 1,  no_WDS, 0x20, 0x00, P_686 or P_SSE4, 0,0xF0)
insn(PMOVSXBW, 1,       OpCls( YMM,      XMM_M128, NONE ), F_660F38, 1,  no_WDS, 0x20, 0x00, P_686 or P_SSE4, 0,0xF0)
insa(PMOVSXBD, pmovsxbd,OpCls( XMM,      XMM_M32,  NONE ), F_660F38, 1,  no_WDS, 0x21, 0x00, P_686 or P_SSE4, 0,0xF0)
insn(PMOVSXBD, 1,       OpCls( YMM,      XMM_M64,  NONE ), F_660F38, 1,  no_WDS, 0x21, 0x00, P_686 or P_SSE4, 0,0xF0)

insa(PMOVSXBQ, pmovsxbq, OpCls( XMM, XMM_MXQDW,    NONE ), F_660F38, 1,  no_WDS, 0x22, 0x00, P_686 or P_SSE4, 0,0xF0)
insa(PMOVZXDQ, pmovzxdq, OpCls( XMM, XMM_MXQDW,    NONE ), F_660F38, 1,  no_WDS, 0x35, 0x00, P_686 or P_SSE4, 0,0xF0)
insa(PMOVZXBQ, pmovzxbq, OpCls( XMM, XMM_MXQDW,    NONE ), F_660F38, 1,  no_WDS, 0x32, 0x00, P_686 or P_SSE4, 0,0xF0)

insa(PMOVSXWD, pmovsxwd,OpCls( XMM,      XMM_M64,  NONE ), F_660F38, 1,  no_WDS, 0x23, 0x00, P_686 or P_SSE4, 0,0xF0)
insn(PMOVSXWD, 1,       OpCls( YMM,      XMM_M128, NONE ), F_660F38, 1,  no_WDS, 0x23, 0x00, P_686 or P_SSE4, 0,0xF0)
insa(PMOVSXWQ, pmovsxwq,OpCls( XMM,      XMM_M32,  NONE ), F_660F38, 1,  no_WDS, 0x24, 0x00, P_686 or P_SSE4, 0,0xF0)
insn(PMOVSXWQ, 1,       OpCls( YMM,      XMM_M64,  NONE ), F_660F38, 1,  no_WDS, 0x24, 0x00, P_686 or P_SSE4, 0,0xF0)
insa(PMOVSXDQ, pmovsxdq,OpCls( XMM,      XMM_M64,  NONE ), F_660F38, 1,  no_WDS, 0x25, 0x00, P_686 or P_SSE4, 0,0xF0)
insn(PMOVSXDQ, 1,       OpCls( YMM,  XMM_M128_M64, NONE ), F_660F38, 1,  no_WDS, 0x25, 0x00, P_686 or P_SSE4, 0,0xF0)
insa(PMOVZXBW, pmovzxbw,OpCls( XMM,      XMM_M64,  NONE ), F_660F38, 1,  no_WDS, 0x30, 0x00, P_686 or P_SSE4, 0,0xF0)
insn(PMOVZXBW, 1,       OpCls( YMM,      XMM_M128, NONE ), F_660F38, 1,  no_WDS, 0x30, 0x00, P_686 or P_SSE4, 0,0xF0)
insa(PMOVZXBD, pmovzxbd,OpCls( XMM,      XMM_M32,  NONE ), F_660F38, 1,  no_WDS, 0x31, 0x00, P_686 or P_SSE4, 0,0xF0)
insn(PMOVZXBD, 1,       OpCls( YMM,      XMM_M64,  NONE ), F_660F38, 1,  no_WDS, 0x31, 0x00, P_686 or P_SSE4, 0,0xF0)
insa(PMOVZXWD, pmovzxwd,OpCls( XMM,      XMM_M64,  NONE ), F_660F38, 1,  no_WDS, 0x33, 0x00, P_686 or P_SSE4, 0,0xF0)
insn(PMOVZXWD, 1,       OpCls( YMM,      XMM_M128, NONE ), F_660F38, 1,  no_WDS, 0x33, 0x00, P_686 or P_SSE4, 0,0xF0)
insa(PMOVZXWQ, pmovzxwq,OpCls( XMM,      XMM_M32,  NONE ), F_660F38, 1,  no_WDS, 0x34, 0x00, P_686 or P_SSE4, 0,0xF0)
insn(PMOVZXWQ, 1,       OpCls( YMM,      XMM_M64,  NONE ), F_660F38, 1,  no_WDS, 0x34, 0x00, P_686 or P_SSE4, 0,0xF0)
insa(PMULDQ, pmuldq,    OpCls( XMM,  XMM_M128_M64, NONE ), F_660F38, 1,  no_WDS, 0x28, 0x00, P_686 or P_SSE4, 0,0xF2)
insa(PMULLD, pmulld,    OpCls( XMM,  XMM_M128_M32, NONE ), F_660F38, 1,  no_WDS, 0x40, 0x00, P_686 or P_SSE4, 0,0xF0)
insa(PTEST, ptest,      OpCls( XMM,      XMM_M128, NONE ), F_660F38, 1,  no_WDS, 0x17, 0x00, P_686 or P_SSE4, 0,0)
insa(ROUNDPS, roundps,  OpCls( XMM,      XMM_M128, I8_U ), F_660F3A, 1,  no_WDS, 0x08, 0x00, P_686 or P_SSE4, 0,0)
insa(ROUNDPD, roundpd,  OpCls( XMM,      XMM_M128, I8_U ), F_660F3A, 1,  no_WDS, 0x09, 0x00, P_686 or P_SSE4, 0,0)
insa(ROUNDSS, roundss,  OpCls( XMM,      XMM_M32 , I8_U ), F_660F3A, 1,  no_WDS, 0x0A, 0x00, P_686 or P_SSE4, 0,0)
insa(ROUNDSD, roundsd,  OpCls( XMM,      XMM_M64 , I8_U ), F_660F3A, 1,  no_WDS, 0x0B, 0x00, P_686 or P_SSE4, 0,0)

; SSE4.2

insa(CRC32, crc32,      OpCls( RGT16,    R8_M08,   NONE ), F_F20F38, 1, no_WDS, 0xF0, 0x00, P_686 or P_SSE4, 0,0)
insn(CRC32, 1,          OpCls( RGT16,    RGT8_MS,  NONE ), F_F20F38, 1, no_WDS, 0xF1, 0x00, P_686 or P_SSE4, 0,0)
insa(PCMPESTRM, pcmpestrm,OpCls( XMM,    XMM_M128, I8_U ), F_660F3A, 1, no_WDS, 0x60, 0x00, P_686 or P_SSE4, 0,0)
insa(PCMPESTRI, pcmpestri,OpCls( XMM,    XMM_M128, I8_U ), F_660F3A, 1, no_WDS, 0x61, 0x00, P_686 or P_SSE4, 0,0)
insa(PCMPISTRM, pcmpistrm,OpCls( XMM,    XMM_M128, I8_U ), F_660F3A, 1, no_WDS, 0x62, 0x00, P_686 or P_SSE4, 0,0)
insa(PCMPISTRI, pcmpistri,OpCls( XMM,    XMM_M128, I8_U ), F_660F3A, 1, no_WDS, 0x63, 0x00, P_686 or P_SSE4, 0,0)
insa(PCMPGTQ, pcmpgtq,  OpCls( XMM,      XMM_M128, NONE ), F_660F38, 1, no_WDS, 0x37, 0x00, P_686 or P_SSE4, 0,0x96)
insn(PCMPGTQ, 1,        OpCls( K,    XMM_M128_M64, NONE ), F_660F38, 1, no_WDS, 0x37, 0x00, P_686 or P_SSE4, 0,0x96)
insa(POPCNT, popcnt,    OpCls( RGT8,     RGT8_MS,  NONE ), F_F30F,   1, no_WDS, 0xB8, 0x00, P_686 or P_SSE4, 0,0)
insa(RDRAND, rdrand,    OpCls( R,        NONE,     NONE ), F_0F,     0, no_WDS, 0xC7, 0x30, P_686 or P_SSE4, 0,0)
insa(RDSEED, rdseed,    OpCls( R,        NONE,     NONE ), F_0F,     0, no_WDS, 0xC7, 0x38, P_686 or P_SSE4, 0,0)
insa(LZCNT, lzcnt,      OpCls( RGT8,     RGT8_MS,  NONE ), F_F30F,   1, no_WDS, 0xBD, 0x00, P_686 or P_SSE4, 0,0)
insa(TZCNT, tzcnt,      OpCls( RGT8,     RGT8_MS,  NONE ), F_F30F,   1, no_WDS, 0xBC, 0x00, P_686 or P_SSE4, 0,0)
insa(INVPCID, invpcid,  OpCls( RGT8,     MS,       NONE ), F_660F38, 1, no_WDS, 0x82, 0x00, P_686 or P_SSE4, 0,0)
insa(RDPID, rdpid,      OpCls( RGT8,     NONE,     NONE ), F_F30F,   0, 0,      0xC7, 0x00, P_686,           0,0)
insa(ADOX, adox,        OpCls( RGT8,     RGT8_MS,  NONE ), F_F30F,   1, no_WDS, 0x38, 0x00, P_686,           0,0)

insa(RDFSBASE, rdfsbase,OpCls( RGT8,     NONE,     NONE ), F_F30F,   0, no_WDS, 0xAE, 0x00, P_686,           0,0)
insa(RDGSBASE, rdgsbase,OpCls( RGT8,     NONE,     NONE ), F_F30F,   0, no_WDS, 0xAE, 0x08, P_686,           0,0)
insa(WRFSBASE, wrfsbase,OpCls( RGT8,     NONE,     NONE ), F_F30F,   0, no_WDS, 0xAE, 0x10, P_686,           0,0)
insa(WRGSBASE, wrgsbase,OpCls( RGT8,     NONE,     NONE ), F_F30F,   0, no_WDS, 0xAE, 0x18, P_686,           0,0)

insa(XRSTOR, xrstor,    OpCls( M_ANY,    NONE,     NONE ), F_0F,   0,  no_WDS, 0xAE, 0x28, P_686 or P_SSE4,0,0)
insa(XSAVE, xsave,      OpCls( M_ANY,    NONE,     NONE ), F_0F,   0,  no_WDS, 0xAE, 0x20, P_686 or P_SSE4,0,0)
insa(XSAVEOPT, xsaveopt,OpCls( M_ANY,    NONE,     NONE ), F_0F,   0,  no_WDS, 0xAE, 0x30, P_686 or P_SSE4,0,0)
insa(XGETBV, xgetbv,    OpCls( NONE,     NONE,     NONE ), F_0F,   0,  no_WDS, 0x01, 0xD0, P_686 or P_SSE4,0,0)
insa(XSETBV, xsetbv,    OpCls( NONE,     NONE,     NONE ), F_0F,   0,  no_WDS, 0x01, 0xD1, P_686p or P_SSE4,0,0)

insa(VMCALL,  vmcall,   OpCls( NONE,    NONE,      NONE ), F_0F,    0, 0,      0x01, 0xC1, P_686, 0,0)
insa(VMLAUNCH,vmlaunch, OpCls( NONE,    NONE,      NONE ), F_0F,    0, 0,      0x01, 0xC2, P_686p,0,0)
insa(VMRESUME,vmresume, OpCls( NONE,    NONE,      NONE ), F_0F,    0, 0,      0x01, 0xC3, P_686p,0,0)
insa(VMXOFF,  vmxoff,   OpCls( NONE,    NONE,      NONE ), F_0F,    0, 0,      0x01, 0xC4, P_686p,0,0)
insa(VMPTRLD, vmptrld,  OpCls( M64,     NONE,      NONE ), F_0F,    0, no_WDS, 0xC7, 0x30, P_686p,0,0)
insa(VMPTRST, vmptrst,  OpCls( M64,     NONE,      NONE ), F_0F,    0, no_WDS, 0xC7, 0x38, P_686p,0,0)
insa(VMCLEAR, vmclear,  OpCls( M64,     NONE,      NONE ), F_660F,  0, no_WDS, 0xC7, 0x30, P_686p,0,0)
insa(VMXON,   vmxon,    OpCls( M64,     NONE,      NONE ), F_F30F,  0, no_WDS, 0xC7, 0x30, P_686p,0,0)
insa(VMREAD,  vmread,   OpCls( R32_M32, R32,       NONE ), F_0F,    0, no_WDS, 0x78, 0x00, P_686p,0,0)
insa(VMWRITE, vmwrite,  OpCls( R32,     R32_M32,   NONE ), F_0F,    1, no_WDS, 0x79, 0x00, P_686p,0,0)
insa(INVEPT,  invept,   OpCls( RGT16,   M128,      NONE ), F_660F38,1, no_WDS, 0x80, 0x00, P_686p,0,0)
insa(INVVPID, invvpid,  OpCls( RGT16,   M128,      NONE ), F_660F38,1, no_WDS, 0x81, 0x00, P_686p,0,0)

; VBROADCASTSS is first VEX encoded instruction (VEX_START in parser.inc).

insv(VBROADCASTSS, vbroadcastss, OpCls( XMM,  XMM_M32,    NONE ), F_660F38, 1, no_WDS, 0x18, 0x00, P_686 or P_AVX, 0,0xE0, RWF_VEX or RWF_T1S, VX_NND or VX_RW0 )
insn(VBROADCASTSS, 1,           OpCls( YMM,   XMM_M32,    NONE ), F_660F38, 1, no_WDS, 0x18, 0x00, P_686 or P_AVX, 0,0xE0)
insn(VBROADCASTSS, 2,           OpCls( ZMM,   XMM_M32,    NONE ), F_660F38, 1, no_WDS, 0x18, 0x00, P_686 or P_AVX, 0,0xE0)
insv(VBROADCASTSD, vbroadcastsd, OpCls( YMM,  XMM_M64,    NONE ), F_660F38, 1, no_WDS, 0x19, 0x00, P_686 or P_AVX, 0,0xE2, RWF_VEX or RWF_T1S, VX_NND )
insn(VBROADCASTSD, 1,           OpCls( ZMM, XMM_M128_M64, NONE ), F_660F38, 1, no_WDS, 0x19, 0x00, P_686 or P_AVX, 0,0xE2)
insv(VBROADCASTF128, vbroadcastf128, OpCls( YMM, M128,    NONE ), F_660F38, 1, no_WDS, 0x1A, 0x00, P_686 or P_AVX, 0,0, RWF_VEX, VX_NND )
insv(VBLENDVPD, vblendvpd,      OpCls( XMM,   XMM_M128,   XMM  ), F_660F3A, 1, no_WDS, 0x4B, 0x00, P_686 or P_AVX, 0,0, RWF_VEX, VX_L )
insv(VBLENDVPS, vblendvps,      OpCls( XMM,   XMM_M128,   XMM  ), F_660F3A, 1, no_WDS, 0x4A, 0x00, P_686 or P_AVX, 0,0, RWF_VEX, VX_L or VX_RW0 )

insv(VINSERTF128, vinsertf128, OpCls( YMM,    XMM_M128,   I8_U ), F_660F3A,1, no_WDS, 0x18, 0x00, P_686 or P_AVX, 0,0, RWF_VEX, 0 )
insv(VEXTRACTF128, vextractf128, OpCls( XMM,  YMM,        I8_U ), F_660F3A,0, no_WDS, 0x19, 0x00, P_686 or P_AVX, 0,0, RWF_VEX, VX_NND )
insn(VEXTRACTF128, 1,        OpCls( M128,     YMM,        I8_U ), F_660F3A,0, no_WDS, 0x19, 0x00, P_686 or P_AVX, 0,0)
insv(VMASKMOVPS, vmaskmovps, OpCls( XMM,      XMM_M128,   NONE ), F_660F38,1, no_WDS, 0x2C, 0x00, P_686 or P_AVX, 0,0, RWF_VEX, VX_L or VX_RW0 )
insn(VMASKMOVPS, 1,          OpCls( M128,     XMM,        NONE ), F_660F38,0, no_WDS, 0x2E, 0x00, P_686 or P_AVX, 0,0)
insv(VMASKMOVPD, vmaskmovpd, OpCls( XMM,      XMM_M128,   NONE ), F_660F38,1, no_WDS, 0x2D, 0x00, P_686 or P_AVX, 0,0, RWF_VEX, VX_L )
insn(VMASKMOVPD, 1,          OpCls( M128,     XMM,        NONE ), F_660F38,0, no_WDS, 0x2F, 0x00, P_686 or P_AVX, 0,0)
insv(VPBLENDVB, vpblendvb,   OpCls( XMM,      XMM_M128,   XMM  ), F_660F3A,1, no_WDS, 0x4C, 0x00, P_686 or P_AVX, 0,0, RWF_VEX, VX_L )
insv(VPERMILPD, vpermilpd,   OpCls( XMM,  XMM_M128_M64,   NONE ), F_660F38,1, no_WDS, 0x0D, 0x00, P_686 or P_AVX, 0,0xE2, RWF_VEX, VX_L or VX_IMM )
; bug v2.17 vpermilpd: Selection by immediate byte operand: C4 RXB.00011 0.1111.1.01 05 /r ib
insn(VPERMILPD, 1,           OpCls( XMM,  XMM_M128_M64,   I8_U ), F_660F3A,1, no_WDS, 0x05, 0x00, P_686 or P_AVX, 0,0x82)
insv(VPERMILPS, vpermilps,   OpCls( XMM,  XMM_M128_M32,   NONE ), F_660F38,1, no_WDS, 0x0C, 0x00, P_686 or P_AVX, 0,0x80, RWF_VEX, VX_L or VX_IMM or VX_RW0 )
; bug v2.17 vpermilps: Selection by immediate byte operand: C4 RXB.00011 0.1111.1.01 04 /r ib
insn(VPERMILPS, 1,           OpCls( XMM,  XMM_M128_M32,   I8_U ), F_660F3A,1, no_WDS, 0x04, 0x00, P_686 or P_AVX, 0,0x80)
insv(VPERM2F128, vperm2f128, OpCls( YMM,      YMM_M256,   I8_U ), F_660F3A,1, no_WDS, 0x06, 0x00, P_686 or P_AVX, 0,0, RWF_VEX, 0 )
insv(VTESTPS, vtestps,       OpCls( XMM,      XMM_M128,   NONE ), F_660F38,1, no_WDS, 0x0E, 0x00, P_686 or P_AVX, 0,0, RWF_VEX, VX_L or VX_NND )
insv(VTESTPD, vtestpd,       OpCls( XMM,      XMM_M128,   NONE ), F_660F38,1, no_WDS, 0x0F, 0x00, P_686 or P_AVX, 0,0, RWF_VEX, VX_L or VX_NND )
insv(VZEROALL, vzeroall,     OpCls( NONE,     NONE,       NONE ), F_0F,    0, no_RM,  0x77, 0x00, P_686 or P_AVX, 0,0, RWF_VEX, VX_L )
insv(VZEROUPPER, vzeroupper, OpCls( NONE,     NONE,       NONE ), F_0F,    0, no_RM,  0x77, 0x00, P_686 or P_AVX, 0,0, RWF_VEX, 0 )

insv(VCMPPD, vcmppd,         OpCls( XMM,      XMM_M128,   I8_U ), F_660F,  1, no_WDS, 0xC2, 0x00, P_686 or P_SSE2, 0,0xF0, RWF_VEX, VX_L or VX_HALF or VX_RW1 )
insn(VCMPPD, 1,              OpCls( K,    XMM_M128_M64,   I8_U ), F_660F,  1, no_WDS, 0xC2, 0x00, P_686 or P_SSE2, 0,0xF0)
insv(VCMPPS, vcmpps,         OpCls( XMM,      XMM_M128,   I8_U ), F_0F,    1, no_WDS, 0xC2, 0x00, P_686 or P_SSE2, 0,0xF0, RWF_VEX, VX_L or VX_HALF or VX_RW0 )
insn(VCMPPS, 1,              OpCls( K,    XMM_M128_M32,   I8_U ), F_0F,    1, no_WDS, 0xC2, 0x00, P_686 or P_SSE2, 0,0xF0)
insv(VCMPSS, vcmpss,         OpCls( XMM,      XMM_M32,    I8_U ), F_F30F,  1, no_WDS, 0xC2, 0x00, P_686 or P_SSE2, 0,0xF0, RWF_VEX, VX_RW0 )
insn(VCMPSS, 1,              OpCls( K,    XMM_M128_M32,   I8_U ), F_F30F,  1, no_WDS, 0xC2, 0x00, P_686 or P_SSE2, 0,0xF0)
insv(VCMPSD, vcmpsd,         OpCls( XMM,  XMM_M128_M64,   I8_U ), F_F20F,  1, no_WDS, 0xC2, 0x00, P_686 or P_SSE2, 0,0xF2, RWF_VEX or RWF_T1S, VX_RW1 )
insn(VCMPSD, 1,              OpCls( K,    XMM_M128_M64,   I8_U ), F_F20F,  1, no_WDS, 0xC2, 0x00, P_686 or P_SSE1, 0,0xF2)

avxins(CVTDQ2PD, VCVTDQ2PD, vcvtdq2pd,     0, VX_L or VX_NND or VX_HALF or VX_RW0 )
avxins(CVTPD2DQ, VCVTPD2DQ, vcvtpd2dq,     0, VX_L or VX_NND or VX_RW1 )
avxins(CVTTPD2DQ,VCVTTPD2DQ, vcvttpd2dq,   0, VX_L or VX_NND or VX_RW1 )
avxins(CVTPD2PS, VCVTPD2PS, vcvtpd2ps,     0, VX_L or VX_NND or VX_RW1 )
avxins(MOVDDUP,  VMOVDDUP, vmovddup,       0, VX_L or VX_NND or VX_RW1 )

avxins(ADDPD,    VADDPD,    vaddpd,        0, VX_L or VX_RW1 )
avxins(ADDPS,    VADDPS,    vaddps,        0, VX_L or VX_RW0 )
avxins(ADDSD,    VADDSD,    vaddsd,        RWF_T1S, VX_RW1 )
avxins(ADDSS,    VADDSS,    vaddss,        RWF_T1S, VX_RW0 )
avxins(DIVPD,    VDIVPD,    vdivpd,        0, VX_L or VX_RW1 )
avxins(DIVPS,    VDIVPS,    vdivps,        0, VX_L or VX_RW0 )
avxins(DIVSD,    VDIVSD,    vdivsd,        0, VX_RW1 )
avxins(DIVSS,    VDIVSS,    vdivss,        0, VX_RW0 )
avxins(MAXPD,    VMAXPD,    vmaxpd,        0, VX_L or VX_RW1 )
avxins(MAXPS,    VMAXPS,    vmaxps,        0, VX_L or VX_RW0 )
avxins(MAXSD,    VMAXSD,    vmaxsd,        0, 0 )
avxins(MAXSS,    VMAXSS,    vmaxss,        0, VX_RW0 )
avxins(MINPD,    VMINPD,    vminpd,        0, VX_L or VX_RW1 )
avxins(MINPS,    VMINPS,    vminps,        0, VX_L or VX_RW0 )
avxins(MINSD,    VMINSD,    vminsd,        0, 0 )
avxins(MINSS,    VMINSS,    vminss,        0, VX_RW0 )
avxins(MULPD,    VMULPD,    vmulpd,        0, VX_L or VX_RW1 )
avxins(MULPS,    VMULPS,    vmulps,        0, VX_L or VX_RW0 )
avxins(MULSD,    VMULSD,    vmulsd,        0, 0 )
avxins(MULSS,    VMULSS,    vmulss,        0, VX_RW0 )
avxins(SQRTPD,   VSQRTPD,   vsqrtpd,       0, VX_L or VX_RW1 or VX_NND )
avxins(SQRTPS,   VSQRTPS,   vsqrtps,       0, VX_L or VX_NND or VX_RW0 )
avxins(SQRTSD,   VSQRTSD,   vsqrtsd,       0, 0 )
avxins(SQRTSS,   VSQRTSS,   vsqrtss,       0, VX_RW0 )
avxins(SUBPD,    VSUBPD,    vsubpd,        0, VX_L or VX_RW1 )
avxins(SUBPS,    VSUBPS,    vsubps,        0, VX_L or VX_RW0 )
avxins(SUBSD,    VSUBSD,    vsubsd,        0, 0 )
avxins(SUBSS,    VSUBSS,    vsubss,        0, VX_RW0 )
avxins(ANDPD,    VANDPD,    vandpd,        0, VX_L or VX_RW1 )
avxins(ANDPS,    VANDPS,    vandps,        0, VX_L or VX_RW0 )
avxins(ANDNPD,   VANDNPD,   vandnpd,       0, VX_L or VX_RW1 )
avxins(ANDNPS,   VANDNPS,   vandnps,       0, VX_L or VX_RW0 )
avxins(ORPD,     VORPD,     vorpd,         0, VX_L )
avxins(ORPS,     VORPS,     vorps,         0, VX_L or VX_RW0 )
avxins(COMISD,   VCOMISD,   vcomisd,       0, VX_NND or VX_RW1 )
avxins(COMISS,   VCOMISS,   vcomiss,       RWF_T1S, VX_NND or VX_RW0 )
avxins(XORPD,    VXORPD,    vxorpd,        0, VX_L or VX_RW1 )
avxins(XORPS,    VXORPS,    vxorps,        0, VX_L or VX_RW0 )

avxins(CVTDQ2PS, VCVTDQ2PS, vcvtdq2ps,     0, VX_L or VX_NND or VX_HALF or VX_RW0 )
avxins(CVTPS2DQ, VCVTPS2DQ, vcvtps2dq,     0, VX_L or VX_NND or VX_RW0 )
avxins(CVTTPS2DQ,VCVTTPS2DQ,vcvttps2dq,    0, VX_L or VX_NND or VX_RW0 )
avxins(CVTPS2PD, VCVTPS2PD, vcvtps2pd,     0, VX_L or VX_NND or VX_HALF or VX_RW0 )
avxins(CVTSD2SI, VCVTSD2SI, vcvtsd2si,     0, VX_NND or VX_RW1 or VX_RW0 )
avxins(CVTTSD2SI,VCVTTSD2SI,vcvttsd2si,    0, VX_NND or VX_RW0 )
avxins(CVTSD2SS, VCVTSD2SS, vcvtsd2ss,     RWF_T1S, VX_RW1 )
avxins(CVTSI2SD, VCVTSI2SD, vcvtsi2sd,     0, VX_RW1 or VX_RW0 )
avxins(CVTSI2SS, VCVTSI2SS, vcvtsi2ss,     RWF_T1S, VX_RW0 )
avxins(CVTSS2SD, VCVTSS2SD, vcvtss2sd,     0, VX_RW0 )
avxins(CVTSS2SI, VCVTSS2SI, vcvtss2si,     0, VX_NND or VX_RW0 )
avxins(CVTTSS2SI,VCVTTSS2SI,vcvttss2si,    0, VX_NND or VX_RW0 )

avxins(ADDSUBPD, VADDSUBPD, vaddsubpd,     0, VX_L )
avxins(ADDSUBPS, VADDSUBPS, vaddsubps,     0, VX_L )
avxins(BLENDPD , VBLENDPD , vblendpd ,     0, VX_L )
avxins(BLENDPS , VBLENDPS , vblendps ,     0, VX_L )
avxins(DPPD    , VDPPD    , vdppd    ,     0, 0 )
avxins(DPPS    , VDPPS    , vdpps    ,     0, VX_L )
avxins(EXTRACTPS,VEXTRACTPS,vextractps,    RWF_T1S, VX_NND or VX_RW0 )
avxins(HADDPD  , VHADDPD  , vhaddpd  ,     0, VX_L )
avxins(HADDPS  , VHADDPS  , vhaddps  ,     0, VX_L )
avxins(HSUBPD  , VHSUBPD  , vhsubpd  ,     0, VX_L )
avxins(HSUBPS  , VHSUBPS  , vhsubps  ,     0, VX_L )
avxins(INSERTPS, VINSERTPS, vinsertps,     0, VX_RW0 )
avxins(LDDQU   , VLDDQU   , vlddqu   ,     0, VX_L or VX_NND )
avxins(LDMXCSR , VLDMXCSR , vldmxcsr ,     0, 0 )
avxins(STMXCSR , VSTMXCSR , vstmxcsr ,     0, 0 )

avxins(MASKMOVDQU,VMASKMOVDQU,vmaskmovdqu,  0, VX_NND )
avxins(MOVAPD  , VMOVAPD  , vmovapd  ,     0, VX_L or VX_NND or VX_RW1 )
avxins(MOVAPS  , VMOVAPS  , vmovaps  ,     0, VX_L or VX_NND or VX_RW0 )
avxins(MOVD    , VMOVD    , vmovd    ,     0, VX_NND or VX_RW0 )

avxins(MOVQ    , VMOVQ    , vmovq    ,     RWF_T1S, VX_NND or VX_RW1 )

avxins(MOVDQA  , VMOVDQA  , vmovdqa  ,     0, VX_L or VX_NND )
avxins(MOVDQU  , VMOVDQU  , vmovdqu  ,     0, VX_L or VX_NND )
avxins(MOVHLPS , VMOVHLPS , vmovhlps ,     0, VX_RW0 )
avxins(MOVLHPS , VMOVLHPS , vmovlhps ,     0, VX_RW0 )
avxins(MOVHPD  , VMOVHPD  , vmovhpd  ,     0, VX_NMEM or VX_RW1 )
avxins(MOVHPS  , VMOVHPS  , vmovhps  ,     0, VX_NMEM or VX_RW0 )
avxins(MOVLPD  , VMOVLPD  , vmovlpd  ,     0, VX_NMEM or VX_RW1 )
avxins(MOVLPS  , VMOVLPS  , vmovlps  ,     0, VX_NMEM or VX_RW0 )
avxins(MOVSD   , VMOVSD   , vmovsd   ,     0, VX_NMEM or VX_RW1 )
avxins(MOVSS   , VMOVSS   , vmovss   ,     0, VX_NMEM or VX_RW0 )
avxins(MOVNTDQ , VMOVNTDQ , vmovntdq ,     0, VX_L or VX_NND or VX_RW0 )
avxins(MOVNTDQA, VMOVNTDQA, vmovntdqa,     0, VX_L or VX_NND or VX_RW0 )
avxins(MOVNTPD , VMOVNTPD , vmovntpd ,     0, VX_L or VX_NND or VX_RW1 )
avxins(MOVNTPS , VMOVNTPS , vmovntps ,     0, VX_L or VX_NND or VX_RW0 )
avxins(MOVSHDUP, VMOVSHDUP, vmovshdup,     0, VX_L or VX_NND or VX_RW0 )
avxins(MOVSLDUP, VMOVSLDUP, vmovsldup,     0, VX_L or VX_NND or VX_RW0 )
avxins(MOVUPD  , VMOVUPD  , vmovupd  ,     0, VX_L or VX_NND or VX_RW1 )
avxins(MOVUPS  , VMOVUPS  , vmovups  ,     0, VX_L or VX_NND or VX_RW0 )

avxins(MPSADBW , VMPSADBW , vmpsadbw ,     0, VX_L )

avxins(PABSB   , VPABSB   , vpabsb   ,     0, VX_L or VX_NND or VX_RW0 )
avxins(PABSW   , VPABSW   , vpabsw   ,     0, VX_L or VX_NND or VX_RW0 )
avxins(PABSD   , VPABSD   , vpabsd   ,     0, VX_L or VX_NND or VX_RW0 )

avxins(PACKSSWB, VPACKSSWB, vpacksswb,     0, VX_L or VX_RW0 )
avxins(PACKSSDW, VPACKSSDW, vpackssdw,     0, VX_L or VX_RW0 )
avxins(PACKUSWB, VPACKUSWB, vpackuswb,     0, VX_L or VX_RW0 )
avxins(PACKUSDW, VPACKUSDW, vpackusdw,     0, VX_L or VX_RW0 )
avxins(PADDB   , VPADDB   , vpaddb   ,     0, VX_RW0 )
avxins(PADDW   , VPADDW   , vpaddw   ,     0, VX_L or VX_RW0 )
avxins(PADDD   , VPADDD   , vpaddd   ,     0, VX_L or VX_RW0 )
avxins(PADDQ   , VPADDQ   , vpaddq   ,     0, VX_L or VX_RW1 )
avxins(PADDSB  , VPADDSB  , vpaddsb  ,     0, VX_L or VX_RW0 )
avxins(PADDSW  , VPADDSW  , vpaddsw  ,     0, VX_L or VX_RW0 )
avxins(PADDUSB , VPADDUSB , vpaddusb ,     0, VX_RW0 )
avxins(PADDUSW , VPADDUSW , vpaddusw ,     0, VX_L or VX_RW0 )
avxins(PALIGNR , VPALIGNR , vpalignr ,     0, VX_L or VX_RW0  )
avxins(PAND    , VPAND    , vpand    ,     0, VX_L )
avxins(PANDN   , VPANDN   , vpandn   ,     0, VX_L )
avxins(PAVGB   , VPAVGB   , vpavgb   ,     0, VX_L or VX_RW0 )
avxins(PAVGW   , VPAVGW   , vpavgw   ,     0, VX_L or VX_RW0 )
avxins(PBLENDW , VPBLENDW , vpblendw ,     0, VX_L )
avxins(PCMPESTRI,VPCMPESTRI,vpcmpestri,    0, VX_NND )
avxins(PCMPESTRM,VPCMPESTRM,vpcmpestrm,    0, VX_NND )
avxins(PCMPISTRI,VPCMPISTRI,vpcmpistri,    0, VX_NND )
avxins(PCMPISTRM,VPCMPISTRM,vpcmpistrm,    0, VX_NND )
avxins(PCMPEQB  ,VPCMPEQB  ,vpcmpeqb  ,    0, VX_L or VX_RW0 )
avxins(PCMPEQW  ,VPCMPEQW  ,vpcmpeqw  ,    0, VX_L or VX_RW0 )
avxins(PCMPEQD  ,VPCMPEQD  ,vpcmpeqd  ,    0, VX_L or VX_RW0 )
avxins(PCMPEQQ  ,VPCMPEQQ  ,vpcmpeqq  ,    0, VX_L)
avxins(PCMPGTB  ,VPCMPGTB  ,vpcmpgtb  ,    0, VX_L or VX_RW0 )
avxins(PCMPGTW  ,VPCMPGTW  ,vpcmpgtw  ,    0, VX_L or VX_RW0 )
avxins(PCMPGTD  ,VPCMPGTD  ,vpcmpgtd  ,    0, VX_L or VX_RW0 )
avxins(PCMPGTQ  ,VPCMPGTQ  ,vpcmpgtq  ,    0, VX_L )
avxins(PEXTRB   ,VPEXTRB   ,vpextrb   ,    0, VX_L or VX_NND or VX_RW0 )
avxins(PEXTRW   ,VPEXTRW   ,vpextrw   ,    0, VX_L or VX_NND or VX_RW0 )
avxins(PEXTRD   ,VPEXTRD   ,vpextrd   ,    0, VX_L or VX_NND or VX_RW0 )
avxins(PINSRB   ,VPINSRB   ,vpinsrb   ,    0, VX_L or VX_RW0 )
avxins(PINSRW   ,VPINSRW   ,vpinsrw   ,    0, VX_L or VX_RW0 )
avxins(PINSRD   ,VPINSRD   ,vpinsrd   ,    0, VX_L or VX_RW0 )

avxins(PCLMULQDQ,VPCLMULQDQ,vpclmulqdq,    0, VX_RW0 )
avxins(AESDECLAST,VAESDECLAST,vaesdeclast,  0, VX_RW0 )
avxins(AESDEC   ,VAESDEC   ,vaesdec   ,    0, VX_RW0 )
avxins(AESENC   ,VAESENC   ,vaesenc   ,    0, VX_RW0 )
avxins(AESENCLAST,VAESENCLAST,vaesenclast,  0, VX_RW0 )
avxins(AESIMC   ,VAESIMC   ,vaesimc   ,    0, VX_NND or VX_RW0 )
avxins(AESKEYGENASSIST,VAESKEYGENASSIST,vaeskeygenassist, 0, VX_NND or VX_RW0 )

avxins(PEXTRQ   ,VPEXTRQ   ,vpextrq   ,    0, VX_NND or VX_RW1 )
avxins(PINSRQ   ,VPINSRQ   ,vpinsrq   ,    0, VX_RW1 )

avxins(PHADDW   ,VPHADDW   ,vphaddw   ,    0, VX_L )
avxins(PHADDD   ,VPHADDD   ,vphaddd   ,    0, VX_L )
avxins(PHADDSW  ,VPHADDSW  ,vphaddsw  ,    0, VX_L )
avxins(PHMINPOSUW,VPHMINPOSUW,vphminposuw,  0, VX_NND )
avxins(PHSUBW   ,VPHSUBW   ,vphsubw   ,    0, VX_L )
avxins(PHSUBD   ,VPHSUBD   ,vphsubd   ,    0, VX_L )
avxins(PHSUBSW  ,VPHSUBSW  ,vphsubsw  ,    0, VX_L )
avxins(PMADDWD  ,VPMADDWD  ,vpmaddwd  ,    0, VX_L or VX_RW0 )
avxins(PMADDUBSW,VPMADDUBSW,vpmaddubsw,    0, VX_L or VX_RW0 )
avxins(PMAXSB   ,VPMAXSB   ,vpmaxsb   ,    0, VX_L or VX_RW0 )
avxins(PMAXSW   ,VPMAXSW   ,vpmaxsw   ,    0, VX_L or VX_RW0 )
avxins(PMAXSD   ,VPMAXSD   ,vpmaxsd   ,    0, VX_L or VX_RW0 )
avxins(PMAXUB   ,VPMAXUB   ,vpmaxub   ,    0, VX_L or VX_RW0 )
avxins(PMAXUW   ,VPMAXUW   ,vpmaxuw   ,    0, VX_L or VX_RW0 )
avxins(PMAXUD   ,VPMAXUD   ,vpmaxud   ,    0, VX_L or VX_RW0 )
avxins(PMINSB   ,VPMINSB   ,vpminsb   ,    0, VX_L or VX_RW0 )
avxins(PMINSW   ,VPMINSW   ,vpminsw   ,    0, VX_L or VX_RW0 )
avxins(PMINSD   ,VPMINSD   ,vpminsd   ,    0, VX_L or VX_RW0 )
avxins(PMINUB   ,VPMINUB   ,vpminub   ,    0, VX_L or VX_RW0 )
avxins(PMINUW   ,VPMINUW   ,vpminuw   ,    0, VX_L or VX_RW0 )
avxins(PMINUD   ,VPMINUD   ,vpminud   ,    0, VX_L or VX_RW0 )
avxins(PMOVMSKB ,VPMOVMSKB ,vpmovmskb ,    0, VX_L or VX_NND )
avxins(PMOVSXBW ,VPMOVSXBW ,vpmovsxbw ,    0, VX_L or VX_NND or VX_HALF or VX_RW0 )
avxins(PMOVSXBD ,VPMOVSXBD ,vpmovsxbd ,    0, VX_L or VX_NND or VX_HALF or VX_RW0 )
avxins(PMOVSXBQ ,VPMOVSXBQ ,vpmovsxbq ,    0, VX_L or VX_NND or VX_HALF or VX_RW0 )
avxins(PMOVSXWD ,VPMOVSXWD ,vpmovsxwd ,    0, VX_L or VX_NND or VX_HALF or VX_RW0 )
avxins(PMOVSXWQ ,VPMOVSXWQ ,vpmovsxwq ,    0, VX_L or VX_NND or VX_HALF or VX_RW0 )
avxins(PMOVSXDQ ,VPMOVSXDQ ,vpmovsxdq ,    0, VX_L or VX_NND or VX_HALF or VX_RW0 )
avxins(PMOVZXBW ,VPMOVZXBW ,vpmovzxbw ,    0, VX_L or VX_NND or VX_HALF or VX_RW0 )
avxins(PMOVZXBD ,VPMOVZXBD ,vpmovzxbd ,    0, VX_L or VX_NND or VX_HALF or VX_RW0 )
avxins(PMOVZXBQ ,VPMOVZXBQ ,vpmovzxbq ,    0, VX_L or VX_NND or VX_HALF or VX_RW0 )
avxins(PMOVZXWD ,VPMOVZXWD ,vpmovzxwd ,    0, VX_L or VX_NND or VX_HALF or VX_RW0 )
avxins(PMOVZXWQ ,VPMOVZXWQ ,vpmovzxwq ,    0, VX_L or VX_NND or VX_HALF or VX_RW0 )
avxins(PMOVZXDQ ,VPMOVZXDQ ,vpmovzxdq ,    0, VX_L or VX_NND or VX_HALF or VX_RW0 )
avxins(PMULHUW  ,VPMULHUW  ,vpmulhuw  ,    0, VX_L )
avxins(PMULHRSW ,VPMULHRSW ,vpmulhrsw ,    0, VX_L or VX_RW0 )
avxins(PMULHW   ,VPMULHW   ,vpmulhw   ,    0, VX_L or VX_RW0 )
avxins(PMULLW   ,VPMULLW   ,vpmullw   ,    0, VX_L or VX_RW0 )
avxins(PMULLD   ,VPMULLD   ,vpmulld   ,    0, VX_L or VX_RW0 )
avxins(PMULUDQ  ,VPMULUDQ  ,vpmuludq  ,    0, VX_L )
avxins(PMULDQ   ,VPMULDQ   ,vpmuldq   ,    0, VX_L )
avxins(POR      ,VPOR      ,vpor      ,    0, VX_L )
avxins(PSADBW   ,VPSADBW   ,vpsadbw   ,    0, VX_L or VX_RW0 )
avxins(PSHUFB   ,VPSHUFB   ,vpshufb   ,    0, VX_L or VX_RW0 )
avxins(PSHUFD   ,VPSHUFD   ,vpshufd   ,    0, VX_L or VX_NND or VX_RW0 )
avxins(PSHUFHW  ,VPSHUFHW  ,vpshufhw  ,    0, VX_L or VX_NND or VX_RW0 )
avxins(PSHUFLW  ,VPSHUFLW  ,vpshuflw  ,    0, VX_L or VX_NND or VX_RW0 )
avxins(PSIGNB   ,VPSIGNB   ,vpsignb   ,    0, VX_L )
avxins(PSIGNW   ,VPSIGNW   ,vpsignw   ,    0, VX_L )
avxins(PSIGND   ,VPSIGND   ,vpsignd   ,    0, VX_L )
avxins(PSLLDQ   ,VPSLLDQ   ,vpslldq   ,    0, VX_L or VX_HALF or VX_DST or VX_RW0 )
avxins(PSRLDQ   ,VPSRLDQ   ,vpsrldq   ,    0, VX_L or VX_HALF or VX_DST or VX_RW0 )
avxins(PSLLW    ,VPSLLW    ,vpsllw    ,    RWF_M128, VX_L or VX_HALF or VX_DST or VX_RW0 )
avxins(PSLLD    ,VPSLLD    ,vpslld    ,    RWF_M128, VX_L or VX_HALF or VX_DST or VX_RW0 )
avxins(PSLLQ    ,VPSLLQ    ,vpsllq    ,    RWF_M128, VX_L or VX_HALF or VX_DST or VX_RW1 )
avxins(PSRAW    ,VPSRAW    ,vpsraw    ,    RWF_M128, VX_L or VX_HALF or VX_DST or VX_RW0 )
avxins(PSRAD    ,VPSRAD    ,vpsrad    ,    RWF_M128, VX_L or VX_HALF or VX_DST or VX_RW0 )
avxins(PSRLW    ,VPSRLW    ,vpsrlw    ,    RWF_M128, VX_L or VX_HALF or VX_DST or VX_RW0 )
avxins(PSRLD    ,VPSRLD    ,vpsrld    ,    RWF_M128, VX_L or VX_HALF or VX_DST or VX_RW0 )
avxins(PSRLQ    ,VPSRLQ    ,vpsrlq    ,    RWF_M128, VX_L or VX_HALF or VX_DST or VX_RW1 )
avxins(PTEST    ,VPTEST    ,vptest    ,    0, VX_L or VX_NND )
avxins(PSUBB    ,VPSUBB    ,vpsubb    ,    0, VX_L or VX_RW0  or VX_RW1 )
avxins(PSUBW    ,VPSUBW    ,vpsubw    ,    0, VX_L or VX_RW0  or VX_RW1 )
avxins(PSUBD    ,VPSUBD    ,vpsubd    ,    0, VX_L or VX_RW0 )
avxins(PSUBQ    ,VPSUBQ    ,vpsubq    ,    0, VX_L or VX_RW1 )
avxins(PSUBSB   ,VPSUBSB   ,vpsubsb   ,    0, VX_L or VX_RW0 or VX_RW1 )
avxins(PSUBSW   ,VPSUBSW   ,vpsubsw   ,    0, VX_L or VX_RW0 or VX_RW1 )
avxins(PSUBUSB  ,VPSUBUSB  ,vpsubusb  ,    0, VX_L or VX_RW0 or VX_RW1 )
avxins(PSUBUSW  ,VPSUBUSW  ,vpsubusw  ,    0, VX_L or VX_RW0 or VX_RW1 )
avxins(PUNPCKHBW ,VPUNPCKHBW ,vpunpckhbw,   0, VX_L or VX_RW0 or VX_RW1 )
avxins(PUNPCKHWD ,VPUNPCKHWD ,vpunpckhwd,   0, VX_L or VX_RW0 or VX_RW1 )
avxins(PUNPCKHDQ ,VPUNPCKHDQ ,vpunpckhdq,   0, VX_L or VX_RW0 )
avxins(PUNPCKHQDQ,VPUNPCKHQDQ,vpunpckhqdq,  0, VX_L or VX_RW1 )
avxins(PUNPCKLBW ,VPUNPCKLBW ,vpunpcklbw,   0, VX_L or VX_RW0  or VX_RW1 )
avxins(PUNPCKLWD ,VPUNPCKLWD ,vpunpcklwd,   0, VX_L or VX_RW0  or VX_RW1 )
avxins(PUNPCKLDQ ,VPUNPCKLDQ ,vpunpckldq,   0, VX_L or VX_RW0 )
avxins(PUNPCKLQDQ,VPUNPCKLQDQ,vpunpcklqdq,  0, VX_L or VX_RW1 )
avxins(PXOR     ,VPXOR     ,vpxor     ,    0, VX_L )

avxins(RCPPS    ,VRCPPS    ,vrcpps    ,    0, VX_L or VX_NND )
avxins(RCPSS    ,VRCPSS    ,vrcpss    ,    0, 0 )
avxins(RSQRTPS  ,VRSQRTPS  ,vrsqrtps  ,    0, VX_L or VX_NND )
avxins(RSQRTSS  ,VRSQRTSS  ,vrsqrtss  ,    0, 0 )
avxins(ROUNDPD  ,VROUNDPD  ,vroundpd  ,    0, VX_L or VX_NND )
avxins(ROUNDPS  ,VROUNDPS  ,vroundps  ,    0, VX_L or VX_NND )
avxins(ROUNDSD  ,VROUNDSD  ,vroundsd  ,    0, 0 )
avxins(ROUNDSS  ,VROUNDSS  ,vroundss  ,    0, 0 )
avxins(SHUFPD   ,VSHUFPD   ,vshufpd   ,    0, VX_L or VX_RW1 )
avxins(SHUFPS   ,VSHUFPS   ,vshufps   ,    0, VX_L or VX_RW0 )
avxins(UCOMISD  ,VUCOMISD  ,vucomisd  ,    0, VX_NND or VX_RW1 )
avxins(UCOMISS  ,VUCOMISS  ,vucomiss  ,    0, VX_NND or VX_RW0 )
avxins(UNPCKHPD ,VUNPCKHPD ,vunpckhpd ,    0, VX_L or VX_RW1 )
avxins(UNPCKHPS ,VUNPCKHPS ,vunpckhps ,    0, VX_L or VX_RW0 )
avxins(UNPCKLPD ,VUNPCKLPD ,vunpcklpd ,    0, VX_L or VX_RW1 )
avxins(UNPCKLPS ,VUNPCKLPS ,vunpcklps ,    0, VX_L or VX_RW0 )

; AVX-2 - v2.26

avxins(MOVMSKPD, VMOVMSKPD, vmovmskpd,  0, VX_L or VX_NND )
avxins(MOVMSKPS, VMOVMSKPS, vmovmskps,  0, VX_L or VX_NND )

insv(VPMASKMOVD, vpmaskmovd, OpCls( XMM,      XMM_M128,   NONE ), F_660F38, 1, no_WDS, 0x8C, 0x00, P_686 or P_AVX, 0,0, RWF_VEX, VX_L )
insn(VPMASKMOVD, 1,          OpCls( XMM_M128, XMM,        NONE ), F_660F38, 0, no_WDS, 0x8E, 0x00, P_686 or P_AVX, 0,0)
insv(VPMASKMOVQ, vpmaskmovq, OpCls( XMM,      XMM_M128,   NONE ), F_660F38, 1, no_WDS, 0x8C, 0x00, P_686 or P_AVX, 0,0, RWF_VEX, VX_L or VX_RW1 )
insn(VPMASKMOVQ, 1,          OpCls( XMM_M128, XMM,        NONE ), F_660F38, 0, no_WDS, 0x8E, 0x00, P_686 or P_AVX, 0,0)
insv(VPERMPD, vpermpd,       OpCls( YMM,  YMM_M256_M64,   NONE ), F_660F38, 1, no_WDS, 0x16, 0x00, P_686 or P_AVX, 0,0x80, RWF_VEX, VX_L or VX_IMM or VX_RW1 )
insn(VPERMPD, 1,             OpCls( YMM,  YMM_M256_M64,   I8_U ), F_660F3A, 1, no_WDS, 0x01, 0x00, P_686 or P_AVX, 0,0x80)
insv(VPERMB, vpermb,         OpCls( XMM,      XMM_M128,   NONE ), F_660F38, 1, no_WDS, 0x8D, 0x00, P_686 or P_AVX, 0,0, RWF_VEX, VX_L )
insv(VPERMD, vpermd,         OpCls( XMM,  XMM_M128_M32,   NONE ), F_660F38, 1, no_WDS, 0x36, 0x00, P_686 or P_AVX, 0,0x80, RWF_VEX, VX_L or VX_RW0 )
insv(VPERMQ, vpermq,         OpCls( YMM,  YMM_M256_M64,   NONE ), F_660F38, 1, no_WDS, 0x36, 0x00, P_686 or P_AVX, 0,0x80, RWF_VEX, VX_L or VX_IMM or VX_RW1 )
insn(VPERMQ, 1,              OpCls( YMM,  YMM_M256_M64,   I8_U ), F_660F3A, 1, no_WDS, 0x00, 0x00, P_686 or P_AVX, 0,0x80)
insv(VPERMPS, vpermps,       OpCls( YMM,  YMM_M256_M32,   NONE ), F_660F38, 1, no_WDS, 0x16, 0x00, P_686 or P_AVX, 0,0x80, RWF_VEX, VX_L or VX_RW0 )
insv(VPSLLVW, vpsllvw,       OpCls( XMM,      XMM_M128,   NONE ), F_660F38, 1, no_WDS, 0x12, 0x00, P_686 or P_AVX, 0,0, RWF_VEX, VX_L or VX_RW0 )
insv(VPSLLVD, vpsllvd,       OpCls( XMM,  XMM_M128_M32,   NONE ), F_660F38, 1, no_WDS, 0x47, 0x00, P_686 or P_AVX, 0,0x80, RWF_VEX, VX_L or VX_RW0 )
insv(VPSLLVQ, vpsllvq,       OpCls( XMM,  XMM_M128_M64,   NONE ), F_660F38, 1, no_WDS, 0x47, 0x00, P_686 or P_AVX, 0,0x80, RWF_VEX, VX_L or VX_RW1 )
insv(VPSRAVD, vpsravd,       OpCls( XMM,  XMM_M128_M32,   NONE ), F_660F38, 1, no_WDS, 0x46, 0x00, P_686 or P_AVX, 0,0xE0, RWF_VEX, VX_L or VX_RW0 )
insv(VPSRLVD, vpsrlvd,       OpCls( XMM,  XMM_M128_M32,   NONE ), F_660F38, 1, no_WDS, 0x45, 0x00, P_686 or P_AVX, 0,0xE0, RWF_VEX, VX_L or VX_RW0 )
insv(VPSRLVQ, vpsrlvq,       OpCls( XMM,  XMM_M128_M64,   NONE ), F_660F38, 1, no_WDS, 0x45, 0x00, P_686 or P_AVX, 0,0xE0, RWF_VEX, VX_L or VX_RW1 )
insv(VPBLENDD, vpblendd,     OpCls( XMM,      XMM_M128,   I8_U ), F_660F3A, 1, no_WDS, 0x02, 0x00, P_686 or P_AVX, 0,0, RWF_VEX, VX_L )
insv(VPERM2I128, vperm2i128, OpCls( YMM,      YMM_M256,   I8_U ), F_660F3A, 1, no_WDS, 0x46, 0x00, P_686 or P_AVX, 0,0, RWF_VEX, VX_L )
insv(VINSERTI128, vinserti128, OpCls(YMM,     XMM_M128,   I8_U ), F_660F3A, 1, no_WDS, 0x38, 0x00, P_686 or P_AVX, 0,0, RWF_VEX, VX_L or VX_HALF )
insv(VBROADCASTI128, vbroadcasti128,OpCls(YMM,M128,       NONE ), F_660F38, 1, no_WDS, 0x5A, 0x00, P_686 or P_AVX, 0,0, RWF_VEX, VX_L or VX_NND )
insv(VEXTRACTI128, vextracti128, OpCls( XMM,  YMM,        I8_U ), F_660F3A, 0, no_WDS, 0x39, 0x00, P_686 or P_AVX, 0,0, RWF_VEX, VX_L or VX_NND )
insn(VEXTRACTI128, 1,       OpCls( M128,      YMM,        I8_U ), F_660F3A, 0, no_WDS, 0x39, 0x00, P_686 or P_AVX, 0,0)
insv(VPBROADCASTQ, vpbroadcastq, OpCls( XMM,  R64,        NONE ), F_660F38, 1, no_WDS, 0x7C, 0x00, P_686 or P_AVX, 0,0xE0, RWF_VEX, VX_L or VX_NND or VX_HALF )
insn(VPBROADCASTQ, 1,           OpCls( XMM,   XMM_M64,    NONE ), F_660F38, 1, no_WDS, 0x59, 0x00, P_686 or P_AVX, 0,0xE0)
insv(VPBROADCASTD, vpbroadcastd, OpCls( XMM,  R32,        NONE ), F_660F38, 1, no_WDS, 0x7C, 0x00, P_686 or P_AVX, 0,0xE0, RWF_VEX or RWF_T1S, VX_L or VX_NND or VX_HALF or VX_RW0 )
insn(VPBROADCASTD, 1,           OpCls( XMM,   XMM_M32,    NONE ), F_660F38, 1, no_WDS, 0x58, 0x00, P_686 or P_AVX, 0,0xE0)
insv(VPBROADCASTW, vpbroadcastw, OpCls( XMM,  R16,        NONE ), F_660F38, 1, no_WDS, 0x7B, 0x00, P_686 or P_AVX, 0,0, RWF_VEX, VX_L or VX_NND or VX_HALF )
insn(VPBROADCASTW, 1,           OpCls( XMM,   XMM_M16,    NONE ), F_660F38, 1, no_WDS, 0x79, 0x00, P_686 or P_AVX, 0,0)
insv(VPBROADCASTB, vpbroadcastb, OpCls( XMM,  R8,         NONE ), F_660F38, 1, no_WDS, 0x7A, 0x00, P_686 or P_AVX, 0,0, RWF_VEX, VX_L or VX_NND or VX_HALF )
insn(VPBROADCASTB, 1,       OpCls( XMM,       XMM_M08,    NONE ), F_660F38, 1, no_WDS, 0x78, 0x00, P_686 or P_AVX, 0,0)

; GPR instructions v2.28

insv(ANDN,      andn,        OpCls( RGT16,    RGT16,      R_MS ), F_0F38,   1, no_WDS, 0xF2, 0x00, P_686 or P_AVX, 0,0, RWF_VEX, VX_L )
insv(MULX,      mulx,        OpCls( RGT16,    RGT16,      R_MS ), F_F20F38, 1, no_WDS, 0xF6, 0x00, P_686 or P_AVX, 0,0, RWF_VEX, VX_L )
insv(BEXTR,     bextr,       OpCls( RGT16,    R_MS,       RGT16), F_0F38,   1, 0,      0xF7, 0x00, P_686 or P_AVX, 0,0x08, RWF_VEX, VX_L or VX_NND )
insv(SARX,      sarx,        OpCls( RGT16,    R_MS,       RGT16), F_F30F38, 1, 0,      0xF7, 0x00, P_686 or P_AVX, 0,0x08, RWF_VEX, VX_L or VX_NND )
insv(SHLX,      shlx,        OpCls( RGT16,    R_MS,       RGT16), F_660F38, 1, 0,      0xF7, 0x00, P_686 or P_AVX, 0,0x08, RWF_VEX, VX_L or VX_NND )
insv(SHRX,      shrx,        OpCls( RGT16,    R_MS,       RGT16), F_F20F38, 1, 0,      0xF7, 0x00, P_686 or P_AVX, 0,0x08, RWF_VEX, VX_L or VX_NND )
insv(BZHI,      bzhi,        OpCls( RGT16,    R_MS,       RGT16), F_0F38,   1, 0,      0xF5, 0x00, P_686 or P_AVX, 0,0x08, RWF_VEX, VX_L or VX_NND )
insv(PDEP,      pdep,        OpCls( RGT16,    RGT16,      R_MS ), F_F20F38, 1, no_WDS, 0xF5, 0x00, P_686 or P_AVX, 0,0, RWF_VEX, VX_L )
insv(PEXT,      pext,        OpCls( RGT16,    RGT16,      R_MS ), F_F30F38, 1, no_WDS, 0xF5, 0x00, P_686 or P_AVX, 0,0, RWF_VEX, VX_L )
insv(RORX,      rorx,        OpCls( RGT16,    RGT16,      I8_U ), F_F20F3A, 1, no_WDS, 0xF0, 0x00, P_686 or P_AVX, 0,0, RWF_VEX, VX_L )
insv(BLSI,      blsi,        OpCls( RGT8,     RGT8_MS,    NONE ), F_0F38,   1, no_WDS, 0xF3, 0x18, P_686 or P_AVX, 0,0x09, RWF_VEX, VX_L )
insv(BLSMSK,    blsmsk,      OpCls( RGT8,     RGT8_MS,    NONE ), F_0F38,   1, no_WDS, 0xF3, 0x10, P_686 or P_AVX, 0,0x09, RWF_VEX, VX_L )
insv(BLSR,      blsr,        OpCls( RGT8,     RGT8_MS,    NONE ), F_0F38,   1, no_WDS, 0xF3, 0x08, P_686 or P_AVX, 0,0x09, RWF_VEX, VX_L )

;  AVX-512 - v2.26

insv(VPERMW,  vpermw,        OpCls( XMM, XMM_M128,        NONE ), F_660F38, 1, no_WDS, 0x8D, 0x00, P_686 or P_AVX, 0,0xF0, RWF_VEX or RWF_EVEX, VX_L or VX_RW1 )
insv(VPSRAVW, vpsravw,       OpCls( XMM, XMM_M128,        NONE ), F_660F38, 1, no_WDS, 0x11, 0x00, P_686 or P_AVX, 0,0xF0, RWF_VEX or RWF_EVEX, VX_L or VX_RW1)
insv(VPSRAVQ, vpsravq,       OpCls( XMM, XMM_M128_M64,    NONE ), F_660F38, 1, no_WDS, 0x46, 0x00, P_686 or P_AVX, 0,0xF0, RWF_VEX or RWF_EVEX, VX_L or VX_RW1 )
insv(VPSRLVW, vpsrlvw,       OpCls( XMM, XMM_M128,        NONE ), F_660F38, 1, no_WDS, 0x10, 0x00, P_686 or P_AVX, 0,0xF0, RWF_VEX or RWF_EVEX, VX_L or VX_RW1 )
insv(VPANDD,  vpandd,        OpCls( XMM, XMM_M128_M32,    NONE ), F_660F,   1, no_WDS, 0xDB, 0x00, P_686 or P_AVX, 0,0xE0, RWF_VEX or RWF_EVEX, VX_L or VX_RW0 )
insv(VPANDQ,  vpandq,        OpCls( XMM, XMM_M128_M64,    NONE ), F_660F,   1, no_WDS, 0xDB, 0x00, P_686 or P_AVX, 0,0xE0, RWF_VEX or RWF_EVEX, VX_L or VX_RW1 )
insv(VPANDND, vpandnd,       OpCls( XMM, XMM_M128_M32,    NONE ), F_660F,   1, no_WDS, 0xDF, 0x00, P_686 or P_AVX, 0,0xE0, RWF_VEX or RWF_EVEX, VX_L or VX_RW0 )
insv(VPANDNQ, vpandnq,       OpCls( XMM, XMM_M128_M64,    NONE ), F_660F,   1, no_WDS, 0xDF, 0x00, P_686 or P_AVX, 0,0xE0, RWF_VEX or RWF_EVEX, VX_L or VX_RW1 )
insv(VPXORD,  vpxord,        OpCls( XMM, XMM_M128_M32,    NONE ), F_660F,   1, no_WDS, 0xEF, 0x00, P_686 or P_AVX, 0,0xE0, RWF_VEX or RWF_EVEX, VX_L or VX_RW0 )
insv(VPXORQ,  vpxorq,        OpCls( XMM, XMM_M128_M64,    NONE ), F_660F,   1, no_WDS, 0xEF, 0x00, P_686 or P_AVX, 0,0xE0, RWF_VEX or RWF_EVEX, VX_L or VX_RW1 )
insv(VPSRAQ,  vpsraq,        OpCls( XMM, XMM_M128,        NONE ), F_660F,   1, no_WDS, 0xE2, 0x00, P_686 or P_AVX, 0,0xE0, RWF_VEX or RWF_EVEX or RWF_M128, VX_L or VX_HALF or VX_DST or VX_RW1 )
insn(VPSRAQ,  1,             OpCls( XMM, I8_U,            NONE ), F_660F,   0, no_WDS, 0x72, 0x20, P_686 or P_AVX, 0,0x80)
insn(VPSRAQ,  2,             OpCls( XMM, XMM_M128_M64,    I8_U ), F_660F,   1, no_WDS, 0x72, 0x20, P_686 or P_AVX, 0,0x10)
insv(VPROLVD, vprolvd,       OpCls( XMM, XMM_M128_M32,    NONE ), F_660F38, 1, no_WDS, 0x15, 0x00, P_686 or P_AVX, 0,0x80, RWF_VEX or RWF_EVEX, VX_L or VX_RW0 )
insn(VPROLVD, 1,             OpCls( XMM, XMM_M128_M32,    I8_U ), F_660F38, 1, no_WDS, 0x72, 0x00, P_686 or P_AVX, 0,0x80)
insv(VPROLVQ, vprolvq,       OpCls( XMM, XMM_M128_M64,    NONE ), F_660F38, 1, no_WDS, 0x15, 0x00, P_686 or P_AVX, 0,0x80, RWF_VEX or RWF_EVEX, VX_L or VX_RW1 )
insn(VPROLVQ, 1,             OpCls( XMM, XMM_M128_M64,    I8_U ), F_660F38, 1, no_WDS, 0x72, 0x00, P_686 or P_AVX, 0,0x80)
insv(VPROLD,  vprold,        OpCls( XMM, I8_U,            NONE ), F_660F,   0, no_WDS, 0x72, 0x08, P_686 or P_AVX, 0,0x10, RWF_VEX or RWF_EVEX, VX_L or VX_HALF or VX_DST or VX_RW0 )
insn(VPROLD,  1,             OpCls( XMM, XMM_M128_M32,    I8_U ), F_660F,   1, no_WDS, 0x72, 0x08, P_686 or P_AVX, 0,0x10 )
insv(VPROLQ,  vprolq,        OpCls( XMM, I8_U,            NONE ), F_660F,   0, no_WDS, 0x72, 0x08, P_686 or P_AVX, 0,0x10, RWF_VEX or RWF_EVEX, VX_L or VX_HALF or VX_DST or VX_RW1 )
insn(VPROLQ,  1,             OpCls( XMM, XMM_M128_M64,    I8_U ), F_660F,   1, no_WDS, 0x72, 0x08, P_686 or P_AVX, 0,0x10 )
insv(VPRORVD, vprorvd,       OpCls( XMM, XMM_M128_M32,    NONE ), F_660F38, 1, no_WDS, 0x14, 0x00, P_686 or P_AVX, 0,0xE0, RWF_VEX or RWF_EVEX, VX_L or VX_HALF or VX_DST or VX_RW0 )
insv(VPRORVQ, vprorvq,       OpCls( XMM, XMM_M128_M64,    NONE ), F_660F38, 1, no_WDS, 0x14, 0x00, P_686 or P_AVX, 0,0xE0, RWF_VEX or RWF_EVEX, VX_L or VX_HALF or VX_DST or VX_RW1 )
insv(VPRORD, vprord,         OpCls( XMM, I8_U,            NONE ), F_660F,   0, no_WDS, 0x72, 0x01, P_686 or P_AVX, 0,0x10, RWF_VEX or RWF_EVEX, VX_L or VX_HALF or VX_DST or VX_RW0 )
insn(VPRORD, 1,              OpCls( XMM, XMM_M128_M32,    I8_U ), F_660F,   1, no_WDS, 0x72, 0x00, P_686 or P_AVX, 0,0x10 )
insv(VPRORQ, vprorq,         OpCls( XMM, I8_U,            NONE ), F_660F,   0, no_WDS, 0x72, 0x01, P_686 or P_AVX, 0,0x10, RWF_VEX or RWF_EVEX, VX_L or VX_HALF or VX_DST or VX_RW1 )
insn(VPRORQ, 1,              OpCls( XMM, XMM_M128_M64,    I8_U ), F_660F,   1, no_WDS, 0x72, 0x00, P_686 or P_AVX, 0,0x10 )

insv(VPCONFLICTD, vpconflictd, OpCls( XMM,    XMM_M32,    NONE ), F_660F38, 1, no_WDS, 0xC4, 0x00, P_686 or P_AVX, 0,0x90, RWF_VEX or RWF_EVEX, VX_L or VX_NND or VX_HALF or VX_RW0 )
insn(VPCONFLICTD, 1,         OpCls( XMM,      XMM_M128,   NONE ), F_660F38, 1, no_WDS, 0xC4, 0x00, P_686 or P_AVX, 0,0x90)
insv(VPCONFLICTQ, vpconflictq, OpCls( XMM,    XMM_M64,    NONE ), F_660F38, 1, no_WDS, 0xC4, 0x00, P_686 or P_AVX, 0,0x60, RWF_VEX or RWF_EVEX, VX_L or VX_NND or VX_HALF or VX_RW1 )
insn(VPCONFLICTQ, 1,         OpCls( XMM,      XMM_M128,   NONE ), F_660F38, 1, no_WDS, 0xC4, 0x00, P_686 or P_AVX, 0,0x60)
insv(VPLZCNTD, vplzcntd,     OpCls( XMM,      XMM_M32,    NONE ), F_660F38, 1, no_WDS, 0x44, 0x00, P_686 or P_AVX, 0,0x60, RWF_VEX or RWF_EVEX, VX_L or VX_NND or VX_HALF or VX_RW0 )
insn(VPLZCNTD, 1,            OpCls( XMM,      XMM_M128,   NONE ), F_660F38, 1, no_WDS, 0x44, 0x00, P_686 or P_AVX, 0,0x60)
insv(VPLZCNTQ, vplzcntq,     OpCls( XMM,      XMM_M64,    NONE ), F_660F38, 1, no_WDS, 0x44, 0x00, P_686 or P_AVX, 0,0x60, RWF_VEX or RWF_EVEX, VX_L or VX_NND or VX_HALF or VX_RW1 )
insn(VPLZCNTQ, 1,            OpCls( XMM,      XMM_M128,   NONE ), F_660F38, 1, no_WDS, 0x44, 0x00, P_686 or P_AVX, 0,0x60)
insv(VPTESTNMB, vptestnmb,   OpCls( K,        XMM_M128,   NONE ), F_F30F38, 1, no_WDS, 0x26, 0x00, P_686 or P_AVX, 0,0xE0, RWF_VEX or RWF_EVEX, VX_L or VX_HALF or VX_RW0 )
insv(VPTESTNMW, vptestnmw,   OpCls( K,        XMM_M128,   NONE ), F_F30F38, 1, no_WDS, 0x26, 0x00, P_686 or P_AVX, 0,0xE0, RWF_VEX or RWF_EVEX, VX_L or VX_HALF or VX_RW1 )
insv(VPTESTNMD, vptestnmd,   OpCls( K,        XMM_M32,    NONE ), F_F30F38, 1, no_WDS, 0x27, 0x00, P_686 or P_AVX, 0,0x94, RWF_VEX or RWF_EVEX, VX_L or VX_HALF or VX_RW0 )
insn(VPTESTNMD, 1,           OpCls( K,        XMM_M128,   NONE ), F_F30F38, 1, no_WDS, 0x27, 0x00, P_686 or P_AVX, 0,0x94)
insv(VPTESTNMQ, vptestnmq,   OpCls( K,        XMM_M64,    NONE ), F_F30F38, 1, no_WDS, 0x27, 0x00, P_686 or P_AVX, 0,0x94, RWF_VEX or RWF_EVEX, VX_L or VX_HALF or VX_RW1 )
insn(VPTESTNMQ, 1,           OpCls( K,        XMM_M128,   NONE ), F_F30F38, 1, no_WDS, 0x27, 0x00, P_686 or P_AVX, 0,0x94)
insv(VPBROADCASTMW2D, vpbroadcastmw2d, OpCls( XMM, K,     NONE ), F_F30F38, 1, no_WDS, 0x3A, 0x00, P_686 or P_AVX, 0,0xE0, RWF_VEX or RWF_EVEX, VX_L or VX_NND or VX_HALF or VX_RW0 )
insv(VPBROADCASTMB2Q, vpbroadcastmb2q, OpCls( XMM, K,     NONE ), F_F30F38, 1, no_WDS, 0x2A, 0x00, P_686 or P_AVX, 0,0xE0, RWF_VEX or RWF_EVEX, VX_L or VX_NND or VX_HALF or VX_RW1 )

insv(KADDB,     kaddb,       OpCls( K,        K,          NONE ), F_C5LP0,  1, no_WDS, 0x4A, 0x00, P_686 or P_AVX, 0,0, RWF_VEX, VX_L )
insv(KADDW,     kaddw,       OpCls( K,        K,          NONE ), F_C5L,    1, no_WDS, 0x4A, 0x00, P_686 or P_AVX, 0,0, RWF_VEX, VX_L )
insv(KANDB,     kandb,       OpCls( K,        K,          NONE ), F_C5LP0,  1, no_WDS, 0x41, 0x00, P_686 or P_AVX, 0,0, RWF_VEX, VX_L )
insv(KANDW,     kandw,       OpCls( K,        K,          NONE ), F_C5L,    1, no_WDS, 0x41, 0x00, P_686 or P_AVX, 0,0, RWF_VEX, VX_L )
insv(KANDNB,    kandnb,      OpCls( K,        K,          NONE ), F_C5LP0,  1, no_WDS, 0x42, 0x00, P_686 or P_AVX, 0,0, RWF_VEX, VX_L )
insv(KANDNW,    kandnw,      OpCls( K,        K,          NONE ), F_C5L,    1, no_WDS, 0x42, 0x00, P_686 or P_AVX, 0,0, RWF_VEX, VX_L )
insv(KORB,      korb,        OpCls( K,        K,          NONE ), F_C5LP0,  1, no_WDS, 0x45, 0x00, P_686 or P_AVX, 0,0, RWF_VEX, VX_L )
insv(KORW,      korw,        OpCls( K,        K,          NONE ), F_C5L,    1, no_WDS, 0x45, 0x00, P_686 or P_AVX, 0,0, RWF_VEX, VX_L )
insv(KXORB,     kxorb,       OpCls( K,        K,          NONE ), F_C5LP0,  1, no_WDS, 0x47, 0x00, P_686 or P_AVX, 0,0, RWF_VEX, VX_L )
insv(KXORW,     kxorw,       OpCls( K,        K,          NONE ), F_C5L,    1, no_WDS, 0x47, 0x00, P_686 or P_AVX, 0,0, RWF_VEX, VX_L )
insv(KXNORB,    kxnorb,      OpCls( K,        K,          NONE ), F_C5LP0,  1, no_WDS, 0x46, 0x00, P_686 or P_AVX, 0,0, RWF_VEX, VX_L )
insv(KXNORW,    kxnorw,      OpCls( K,        K,          NONE ), F_C5L,    1, no_WDS, 0x46, 0x00, P_686 or P_AVX, 0,0, RWF_VEX, VX_L )
insv(KUNPCKBW,  kunpckbw,    OpCls( K,        K,          NONE ), F_C5LP0,  1, no_WDS, 0x4B, 0x00, P_686 or P_AVX, 0,0, RWF_VEX, VX_L )
insv(KUNPCKWD,  kunpckwd,    OpCls( K,        K,          NONE ), F_C5L,    1, no_WDS, 0x4B, 0x00, P_686 or P_AVX, 0,0, RWF_VEX, VX_L )

insv(KADDD,     kaddd,       OpCls( K,        K,          NONE ), F_C4M0P0L,1, no_WDS, 0x4A, 0x00, P_686 or P_AVX, 0,0, RWF_VEX, VX_L or VX_RW1 )
insv(KADDQ,     kaddq,       OpCls( K,        K,          NONE ), F_C4M0L,  1, no_WDS, 0x4A, 0x00, P_686 or P_AVX, 0,0, RWF_VEX, VX_L or VX_RW1 )
insv(KANDD,     kandd,       OpCls( K,        K,          NONE ), F_C4M0P0L,1, no_WDS, 0x41, 0x00, P_686 or P_AVX, 0,0, RWF_VEX, VX_L or VX_RW1 )
insv(KANDQ,     kandq,       OpCls( K,        K,          NONE ), F_C4M0L,  1, no_WDS, 0x41, 0x00, P_686 or P_AVX, 0,0, RWF_VEX, VX_L or VX_RW1 )
insv(KANDND,    kandnd,      OpCls( K,        K,          NONE ), F_C4M0P0L,1, no_WDS, 0x42, 0x00, P_686 or P_AVX, 0,0, RWF_VEX, VX_L or VX_RW1 )
insv(KANDNQ,    kandnq,      OpCls( K,        K,          NONE ), F_C4M0L,  1, no_WDS, 0x42, 0x00, P_686 or P_AVX, 0,0, RWF_VEX, VX_L or VX_RW1 )
insv(KORD,      kord,        OpCls( K,        K,          NONE ), F_C4M0P0L,1, no_WDS, 0x45, 0x00, P_686 or P_AVX, 0,0, RWF_VEX, VX_L or VX_RW1 )
insv(KORQ,      korq,        OpCls( K,        K,          NONE ), F_C4M0L,  1, no_WDS, 0x45, 0x00, P_686 or P_AVX, 0,0, RWF_VEX, VX_L or VX_RW1 )
insv(KXORD,     kxord,       OpCls( K,        K,          NONE ), F_C4M0P0L,1, no_WDS, 0x47, 0x00, P_686 or P_AVX, 0,0, RWF_VEX, VX_L or VX_RW1 )
insv(KXORQ,     kxorq,       OpCls( K,        K,          NONE ), F_C4M0L,  1, no_WDS, 0x47, 0x00, P_686 or P_AVX, 0,0, RWF_VEX, VX_L or VX_RW1 )
insv(KXNORD,    kxnord,      OpCls( K,        K,          NONE ), F_C4M0P0L,1, no_WDS, 0x46, 0x00, P_686 or P_AVX, 0,0, RWF_VEX, VX_L or VX_RW1 )
insv(KXNORQ,    kxnorq,      OpCls( K,        K,          NONE ), F_C4M0L,  1, no_WDS, 0x46, 0x00, P_686 or P_AVX, 0,0, RWF_VEX, VX_L or VX_RW1 )
insv(KUNPCKDQ,  kunpckdq,    OpCls( K,        K,          NONE ), F_C4M0L,  1, no_WDS, 0x4B, 0x00, P_686 or P_AVX, 0,0, RWF_VEX, VX_L or VX_RW1 )

insv(KNOTB,     knotb,       OpCls( K,        K,          NONE ), F_660F,   1, no_WDS, 0x44, 0x00, P_686 or P_AVX, 0,0, RWF_VEX, VX_L or VX_NND )
insv(KNOTW,     knotw,       OpCls( K,        K,          NONE ), F_0F,     1, no_WDS, 0x44, 0x00, P_686 or P_AVX, 0,0, RWF_VEX, VX_L or VX_NND )
insv(KNOTD,     knotd,       OpCls( K,        K,          NONE ), F_C4M0P0, 1, no_WDS, 0x44, 0x00, P_686 or P_AVX, 0,0, RWF_VEX, VX_L or VX_NND or VX_RW1 )
insv(KNOTQ,     knotq,       OpCls( K,        K,          NONE ), F_C4M0,   1, no_WDS, 0x44, 0x00, P_686 or P_AVX, 0,0, RWF_VEX, VX_L or VX_NND or VX_RW1 )
insv(KORTESTB,  kortestb,    OpCls( K,        K,          NONE ), F_660F,   1, no_WDS, 0x98, 0x00, P_686 or P_AVX, 0,0, RWF_VEX, VX_L or VX_NND )
insv(KORTESTW,  kortestw,    OpCls( K,        K,          NONE ), F_0F,     1, no_WDS, 0x98, 0x00, P_686 or P_AVX, 0,0, RWF_VEX, VX_L or VX_NND )
insv(KORTESTD,  kortestd,    OpCls( K,        K,          NONE ), F_C4M0P0, 1, no_WDS, 0x98, 0x00, P_686 or P_AVX, 0,0, RWF_VEX, VX_L or VX_NND or VX_RW1 )
insv(KORTESTQ,  kortestq,    OpCls( K,        K,          NONE ), F_C4M0,   1, no_WDS, 0x98, 0x00, P_686 or P_AVX, 0,0, RWF_VEX, VX_L or VX_NND or VX_RW1 )
insv(KSHIFTLB,  kshiftlb,    OpCls( K,        K,          I8_U ), F_660F3A, 1, no_WDS, 0x32, 0x00, P_686 or P_AVX, 0,0, RWF_VEX, VX_L or VX_NND )
insv(KSHIFTLW,  kshiftlw,    OpCls( K,        K,          I8_U ), F_660F3A, 1, no_WDS, 0x32, 0x00, P_686 or P_AVX, 0,0, RWF_VEX, VX_L or VX_NND or VX_RW1 )
insv(KSHIFTLD,  kshiftld,    OpCls( K,        K,          I8_U ), F_660F3A, 1, no_WDS, 0x33, 0x00, P_686 or P_AVX, 0,0, RWF_VEX, VX_L or VX_NND )
insv(KSHIFTLQ,  kshiftlq,    OpCls( K,        K,          I8_U ), F_660F3A, 1, no_WDS, 0x33, 0x00, P_686 or P_AVX, 0,0, RWF_VEX, VX_L or VX_NND or VX_RW1 )
insv(KSHIFTRB,  kshiftrb,    OpCls( K,        K,          I8_U ), F_660F3A, 1, no_WDS, 0x30, 0x00, P_686 or P_AVX, 0,0, RWF_VEX, VX_L or VX_NND )
insv(KSHIFTRW,  kshiftrw,    OpCls( K,        K,          I8_U ), F_660F3A, 1, no_WDS, 0x30, 0x00, P_686 or P_AVX, 0,0, RWF_VEX, VX_L or VX_NND or VX_RW1 )
insv(KSHIFTRD,  kshiftrd,    OpCls( K,        K,          I8_U ), F_660F3A, 1, no_WDS, 0x31, 0x00, P_686 or P_AVX, 0,0, RWF_VEX, VX_L or VX_NND )
insv(KSHIFTRQ,  kshiftrq,    OpCls( K,        K,          I8_U ), F_660F3A, 1, no_WDS, 0x31, 0x00, P_686 or P_AVX, 0,0, RWF_VEX, VX_L or VX_NND or VX_RW1 )

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

insv(VEXP2PS, vexp2ps,       OpCls( ZMM, ZMM_M512_M32,    NONE ), F_660F38, 1, no_WDS, 0xC8, 0x00, P_686 or P_AVX, 0,0x60, RWF_VEX or RWF_EVEX, VX_L or VX_NND or VX_HALF or VX_RW0 )
insv(VEXP2PD, vexp2pd,       OpCls( ZMM, ZMM_M512_M64,    NONE ), F_660F38, 1, no_WDS, 0xC8, 0x00, P_686 or P_AVX, 0,0x60, RWF_VEX or RWF_EVEX, VX_L or VX_NND or VX_HALF or VX_RW1 )
insv(VRCP28PS, vrcp28ps,     OpCls( ZMM, ZMM_M512_M32,    NONE ), F_660F38, 1, no_WDS, 0xCA, 0x00, P_686 or P_AVX, 0,0x60, RWF_VEX or RWF_EVEX, VX_L or VX_NND or VX_HALF or VX_RW0 )
insv(VRCP28PD, vrcp28pd,     OpCls( ZMM, ZMM_M512_M64,    NONE ), F_660F38, 1, no_WDS, 0xCA, 0x00, P_686 or P_AVX, 0,0x60, RWF_VEX or RWF_EVEX, VX_L or VX_NND or VX_HALF or VX_RW1 )
insv(VRCP28SS, vrcp28ss,     OpCls( XMM, XMM_M128_M32,    NONE ), F_660F38, 1, no_WDS, 0xCB, 0x00, P_686 or P_AVX, 0,0x60, RWF_VEX or RWF_EVEX or RWF_T1S, VX_L or VX_RW0 )
insv(VRCP28SD, vrcp28sd,     OpCls( XMM, XMM_M128_M64,    NONE ), F_660F38, 1, no_WDS, 0xCB, 0x00, P_686 or P_AVX, 0,0x60, RWF_VEX or RWF_EVEX or RWF_T1S, VX_L or VX_RW1 )
insv(VMOVDQA32, vmovdqa32,   OpCls( XMM,      XMM_M128,   NONE ), F_660F,   1, no_WDS, 0x6F, 0x00, P_686 or P_AVX, 0,0xF0, RWF_VEX or RWF_EVEX, VX_L or VX_NND or VX_RW0 )
insn(VMOVDQA32, 1,           OpCls( M128,     XMM,        NONE ), F_660F,   0, no_WDS, 0x7F, 0x00, P_686 or P_AVX, 0,0x80)
insv(VMOVDQU8,  vmovdqu8,    OpCls( XMM,      XMM_M128,   NONE ), F_F20F,   1, no_WDS, 0x6F, 0x00, P_686 or P_AVX, 0,0x60, RWF_VEX or RWF_EVEX, VX_L or VX_NND or VX_RW0 )
insn(VMOVDQU8,  1,           OpCls( M128,     XMM,        NONE ), F_F20F,   0, no_WDS, 0x7F, 0x00, P_686 or P_AVX, 0,0x60)
insv(VMOVDQU32, vmovdqu32,   OpCls( XMM,      XMM_M128,   NONE ), F_F30F,   1, no_WDS, 0x6F, 0x00, P_686 or P_AVX, 0,0x60, RWF_VEX or RWF_EVEX, VX_L or VX_NND or VX_RW0 )
insn(VMOVDQU32, 1,           OpCls( M128,     XMM,        NONE ), F_F30F,   0, no_WDS, 0x7F, 0x00, P_686 or P_AVX, 0,0x60 )
insv(VBROADCASTF32X2, vbroadcastf32x2, OpCls(XMM, XMM_M64, NONE), F_660F38, 1, no_WDS, 0x19, 0x00, P_686 or P_AVX, 0,0xF0, RWF_VEX or RWF_EVEX or RWF_T2, VX_L or VX_NND or VX_HALF or VX_RW0 )
insv(VBROADCASTF32X4, vbroadcastf32x4, OpCls(XMM, XMM_M128,NONE), F_660F38, 1, no_WDS, 0x1A, 0x00, P_686 or P_AVX, 0,0xF0, RWF_VEX or RWF_EVEX or RWF_T4, VX_L or VX_NND or VX_HALF or VX_RW0 )
insv(VBROADCASTF32X8, vbroadcastf32x8, OpCls(ZMM,M256_M128,NONE), F_660F38, 1, no_WDS, 0x1B, 0x00, P_686 or P_AVX, 0,0xF0, RWF_VEX or RWF_EVEX, VX_L or VX_NND or VX_HALF or VX_RW0 )
insv(VBROADCASTF64X4, vbroadcastf64x4, OpCls(XMM, XMM_M128,NONE), F_660F38, 1, no_WDS, 0x1B, 0x00, P_686 or P_AVX, 0,0xF0, RWF_VEX or RWF_EVEX or RWF_T4, VX_L or VX_NND or VX_HALF or VX_RW1 )
insv(VBROADCASTI32x2, vbroadcasti32x2, OpCls(XMM, XMM_M128_M64, NONE ), F_660F38, 1, no_WDS, 0x59, 0x00, P_686 or P_AVX, 0,0xF0, RWF_VEX or RWF_EVEX or RWF_T2, VX_L or VX_NND or VX_HALF or VX_RW0 )
insv(VBROADCASTI32X4, vbroadcasti32x4, OpCls(XMM, XMM_M128_M64, NONE ), F_660F38, 1, no_WDS, 0x5A, 0x00, P_686 or P_AVX, 0,0xF0, RWF_VEX or RWF_EVEX or RWF_T4, VX_L or VX_NND or VX_HALF or VX_RW0 )
insv(VBROADCASTI32X8, vbroadcasti32x8, OpCls(XMM, XMM_M128_M64, NONE ), F_660F38, 1, no_WDS, 0x5B, 0x00, P_686 or P_AVX, 0,0xF0, RWF_VEX or RWF_EVEX, VX_L or VX_NND or VX_HALF or VX_RW0 )
insv(VCOMPRESSPD, vcompresspd, OpCls( XMM_M128, XMM,      NONE ), F_660F38, 0, no_WDS, 0x8A, 0x00, P_686 or P_AVX, 0,0xF0, RWF_VEX or RWF_EVEX or RWF_T1S, VX_L or VX_HALF or VX_RW1 )
insv(VPCOMPRESSD, vpcompressd, OpCls( XMM_M128, XMM,      NONE ), F_660F38, 0, no_WDS, 0x8B, 0x00, P_686 or P_AVX, 0,0xF0, RWF_VEX or RWF_EVEX or RWF_T1S, VX_L or VX_HALF or VX_RW0 )
insv(VCVTPD2QQ, vcvtpd2qq,   OpCls( XMM, XMM_M128_M64,    NONE ), F_660F,   1, no_WDS, 0x7B, 0x00, P_686 or P_AVX, 0,0xE0, RWF_VEX or RWF_EVEX, VX_L or VX_NND or VX_RW1 )
insv(VCVTPD2UDQ, vcvtpd2udq, OpCls( XMM, XMM_MXMM,        NONE ), F_0F,     1, no_WDS, 0x79, 0x00, P_686 or P_AVX, 0,0xF0, RWF_VEX or RWF_EVEX, VX_L or VX_NND or VX_HALF or VX_RW1 )
insv(VCVTPD2UQQ, vcvtpd2uqq, OpCls( XMM, XMM_M128_M64,    NONE ), F_660F,   1, no_WDS, 0x79, 0x00, P_686 or P_AVX, 0,0x60, RWF_VEX or RWF_EVEX, VX_L or VX_NND or VX_RW1 )
insv(VCVTPH2PS, vcvtph2ps,   OpCls( XMM, XMM_M128_M64,    NONE ), F_660F38, 1, no_WDS, 0x13, 0x00, P_686 or P_AVX, 0,0xF0, RWF_VEX or RWF_HVM, VX_L or VX_NND or VX_HALF or VX_RW0 )
insv(VCVTPS2PH, vcvtps2ph,   OpCls( XMM_M128_M64, XMM_YMM,I8_U ), F_660F3A, 0, no_WDS, 0x1D, 0x00, P_686 or P_AVX, 0,0x80, RWF_VEX or RWF_HVM, VX_L or VX_NND or VX_HALF  or VX_RW0 )
insv(VCVTQQ2PD, vcvtqq2pd,   OpCls( XMM, XMM_M128_M64,    NONE ), F_F30F,   1, no_WDS, 0xE6, 0x00, P_686 or P_AVX, 0,0xF0, RWF_VEX or RWF_EVEX, VX_L or VX_NND or VX_HALF or VX_RW1 )
insv(VCVTQQ2PS, vcvtqq2ps,   OpCls( XMM, XMM_MXMM,        NONE ), F_0F,     1, no_WDS, 0x5B, 0x00, P_686 or P_AVX, 0,0xF0, RWF_VEX or RWF_EVEX, VX_L or VX_NND or VX_HALF or VX_RW1 )
insv(VCVTTPD2QQ, vcvttpd2qq, OpCls( XMM, XMM_M128_M64,    NONE ), F_660F,   1, no_WDS, 0x7A, 0x00, P_686 or P_AVX, 0,0xF0, RWF_VEX or RWF_EVEX, VX_L or VX_NND or VX_RW1 )
insv(VCVTTPD2UDQ, vcvttpd2udq,OpCls(XMM, XMM_MXMM,        NONE ), F_0F,     1, no_WDS, 0x78, 0x00, P_686 or P_AVX, 0,0xF0, RWF_VEX or RWF_EVEX, VX_L or VX_NND or VX_HALF or VX_RW1 )
insv(VCVTTPD2UQQ, vcvttpd2uqq,OpCls(XMM, XMM_M128_M64,    NONE ), F_660F,   1, no_WDS, 0x78, 0x00, P_686 or P_AVX, 0,0xF0, RWF_VEX or RWF_EVEX, VX_L or VX_NND or VX_RW1 )
insv(VCVTUDQ2PD, vcvtudq2pd, OpCls( XMM, XMM_M128_M32,    NONE ), F_F30F,   1, no_WDS, 0x7A, 0x00, P_686 or P_AVX, 0,0xF0, RWF_VEX or RWF_EVEX, VX_L or VX_NND or VX_HALF or VX_RW0 )
insv(VCVTUQQ2PS, vcvtuqq2ps, OpCls( XMM, XMM_MXMM,        NONE ), F_F20F,   1, no_WDS, 0x7A, 0x00, P_686 or P_AVX, 0,0x60, RWF_VEX or RWF_EVEX, VX_L or VX_NND or VX_HALF or VX_RW1 )
insv(VEXPANDPD, vexpandpd,   OpCls( XMM, XMM_M128,        NONE ), F_660F38, 1, no_WDS, 0x88, 0x00, P_686 or P_AVX, 0,0xF0, RWF_VEX or RWF_EVEX or RWF_T1S, VX_L or VX_NND or VX_RW1 )
insv(VEXTRACTF32x4, vextractf32x4, OpCls(XMM_M128,YMM_ZMM,I8_U ), F_660F3A, 0, no_WDS, 0x19, 0x00, P_686 or P_AVX, 0,0x80, RWF_VEX or RWF_EVEX, VX_L or VX_HALF or VX_NND or VX_RW0 )
insv(VEXTRACTF32X8, vextractf32x8, OpCls(YMM_M256,ZMM,    I8_U ), F_660F3A, 0, no_WDS, 0x1B, 0x00, P_686 or P_AVX, 0,0x80, RWF_VEX or RWF_EVEX, VX_L or VX_NND or VX_RW0 )
insv(VEXTRACTI32x4, vextracti32x4, OpCls(XMM_M128,YMM_ZMM,I8_U ), F_660F3A, 0, no_WDS, 0x39, 0x00, P_686 or P_AVX, 0,0x80, RWF_VEX or RWF_EVEX, VX_L or VX_NND or VX_RW0 )
insv(VEXTRACTI32X8, vextracti32x8, OpCls(YMM_M256,ZMM,    I8_U ), F_660F3A, 0, no_WDS, 0x3B, 0x00, P_686 or P_AVX, 0,0x80, RWF_VEX or RWF_EVEX, VX_L or VX_NND or VX_RW0 )
insv(VFPCLASSPD, vfpclasspd, OpCls( K,        XMM_M128,   I8_U ), F_660F3A, 1, no_WDS, 0x66, 0x00, P_686 or P_AVX, 0,0xF0, RWF_VEX or RWF_EVEX, VX_L or VX_NND or VX_HALF or VX_RW1 )
insv(VGATHERDPS, vgatherdps, OpCls( XMM,      XMM_M32,    NONE ), F_660F38, 1, no_WDS, 0x92, 0x00, P_686 or P_AVX, 0,0x08, RWF_VEX or RWF_T1S, VX_L or VX_NND or VX_HALF or VX_RW0 )
insn(VGATHERDPS, 1,          OpCls( XMM,      M32_M64,    XMM  ), F_660F38, 1, no_WDS, 0x92, 0x00, P_686 or P_AVX, 0,0xD8 )
insv(VGATHERQPS, vgatherqps, OpCls( XMM,      XMM_M64,    NONE ), F_660F38, 1, no_WDS, 0x93, 0x00, P_686 or P_AVX, 0,0x08, RWF_VEX or RWF_T1S, VX_L or VX_NND or VX_RW0 )
insn(VGATHERQPS, 1,          OpCls( XMM,      M32_M64,    XMM  ), F_660F38, 1, no_WDS, 0x93, 0x00, P_686 or P_AVX, 0,0x98 )
insv(VPGATHERDD, vpgatherdd, OpCls( XMM,      M32_M64,    XMM  ), F_660F38, 1, no_WDS, 0x90, 0x00, P_686 or P_AVX, 0,0x08, RWF_VEX or RWF_T1S, VX_L or VX_NND or VX_RW0 )
insn(VPGATHERDD, 1,          OpCls( XMM,      XMM_M32,    NONE ), F_660F38, 1, no_WDS, 0x90, 0x00, P_686 or P_AVX, 0,0x08 )
insv(VPGATHERQD, vpgatherqd, OpCls( XMM,      M32_M64,    XMM  ), F_660F38, 1, no_WDS, 0x91, 0x00, P_686 or P_AVX, 0,0x08, RWF_VEX or RWF_T1S, VX_L or VX_NND or VX_RW0 )
insn(VPGATHERQD, 1,          OpCls( XMM,      XMM_M64,    NONE ), F_660F38, 1, no_WDS, 0x91, 0x00, P_686 or P_AVX, 0,0x08 )
insv(VGATHERPF0DPS, vgatherpf0dps, OpCls( M32_M512, NONE, NONE ), F_660F38, 0, no_WDS, 0xC6, 0x08, P_686 or P_AVX, 0,0x98, RWF_VEX or RWF_EVEX or RWF_T1S, VX_L or VX_NND or VX_RW0 )
insv(VGATHERPF0QPS, vgatherpf0qps, OpCls( M64_M512, NONE, NONE ), F_660F38, 0, no_WDS, 0xC7, 0x08, P_686 or P_AVX, 0,0x98, RWF_VEX or RWF_EVEX or RWF_T1S, VX_L or VX_NND or VX_RW0 )
insv(VGATHERPF0DPD, vgatherpf0dpd, OpCls( M32_M256, NONE, NONE ), F_660F38, 0, no_WDS, 0xC6, 0x08, P_686 or P_AVX, 0,0x98, RWF_VEX or RWF_EVEX or RWF_T1S, VX_L or VX_NND or VX_RW1 )
insv(VGATHERPF0QPD, vgatherpf0qpd, OpCls( M64_M256, NONE, NONE ), F_660F38, 0, no_WDS, 0xC7, 0x08, P_686 or P_AVX, 0,0x98, RWF_VEX or RWF_EVEX or RWF_T1S, VX_L or VX_NND or VX_RW1 )
insv(VGATHERPF1DPS, vgatherpf1dps, OpCls( M32_M512, NONE, NONE ), F_660F38, 0, no_WDS, 0xC6, 0x10, P_686 or P_AVX, 0,0x98, RWF_VEX or RWF_EVEX or RWF_T1S, VX_L or VX_NND or VX_RW0 )
insv(VGATHERPF1QPS, vgatherpf1qps, OpCls( M64_M512, NONE, NONE ), F_660F38, 0, no_WDS, 0xC7, 0x10, P_686 or P_AVX, 0,0x98, RWF_VEX or RWF_EVEX or RWF_T1S, VX_L or VX_NND or VX_RW0 )
insv(VGATHERPF1DPD, vgatherpf1dpd, OpCls( M32_M256, NONE, NONE ), F_660F38, 0, no_WDS, 0xC6, 0x10, P_686 or P_AVX, 0,0x98, RWF_VEX or RWF_EVEX or RWF_T1S, VX_L or VX_NND or VX_RW1 )
insv(VGATHERPF1QPD, vgatherpf1qpd, OpCls( M64_M512, NONE, NONE ), F_660F38, 0, no_WDS, 0xC7, 0x10, P_686 or P_AVX, 0,0x98, RWF_VEX or RWF_EVEX or RWF_T1S, VX_L or VX_NND or VX_RW1 )
insv(VSCATTERDPS,   vscatterdps,   OpCls( M32_M64, XMM,   NONE ), F_660F38, 0, no_WDS, 0xA2, 0x00, P_686 or P_AVX, 0,0x08, RWF_VEX or RWF_EVEX or RWF_T1S, VX_L or VX_NND or VX_RW0 )
insv(VSCATTERQPS,   vscatterqps,   OpCls( M32_M64, XMM,   NONE ), F_660F38, 0, no_WDS, 0xA3, 0x00, P_686 or P_AVX, 0,0x08, RWF_VEX or RWF_EVEX or RWF_T1S, VX_L or VX_NND or VX_RW0 )
insv(VPSCATTERDD, vpscatterdd,     OpCls( M32_M64, XMM,   NONE ), F_660F38, 0, no_WDS, 0xA0, 0x00, P_686 or P_AVX, 0,0x08, RWF_VEX or RWF_EVEX or RWF_T1S, VX_L or VX_NND or VX_RW0 )
insv(VPSCATTERQD, vpscatterqd,     OpCls( M32_M64, XMM,   NONE ), F_660F38, 0, no_WDS, 0xA1, 0x00, P_686 or P_AVX, 0,0x08, RWF_VEX or RWF_EVEX or RWF_T1S, VX_L or VX_NND or VX_RW0 )
insv(VSCATTERPF0DPS, vscatterpf0dps, OpCls(M32_M512,NONE, NONE ), F_660F38, 0, no_WDS, 0xC6, 0x28, P_686 or P_AVX, 0,0x98, RWF_VEX or RWF_EVEX or RWF_T1S, VX_L or VX_NND or VX_RW0 )
insv(VSCATTERPF0QPS, vscatterpf0qps, OpCls(M64_M512,NONE, NONE ), F_660F38, 0, no_WDS, 0xC7, 0x28, P_686 or P_AVX, 0,0x98, RWF_VEX or RWF_EVEX or RWF_T1S, VX_L or VX_NND or VX_RW0 )
insv(VSCATTERPF0DPD, vscatterpf0dpd, OpCls(M32_M256,NONE, NONE ), F_660F38, 0, no_WDS, 0xC6, 0x28, P_686 or P_AVX, 0,0x98, RWF_VEX or RWF_EVEX or RWF_T1S, VX_L or VX_NND or VX_RW1 )
insv(VSCATTERPF0QPD, vscatterpf0qpd, OpCls(M64_M256,NONE, NONE ), F_660F38, 0, no_WDS, 0xC7, 0x28, P_686 or P_AVX, 0,0x98, RWF_VEX or RWF_EVEX or RWF_T1S, VX_L or VX_NND or VX_RW1 )
insv(VSCATTERPF1DPS, vscatterpf1dps, OpCls(M32_M512,NONE, NONE ), F_660F38, 0, no_WDS, 0xC6, 0x30, P_686 or P_AVX, 0,0x98, RWF_VEX or RWF_EVEX or RWF_T1S, VX_L or VX_NND or VX_RW0 )
insv(VSCATTERPF1QPS, vscatterpf1qps, OpCls(M64_M512,NONE, NONE ), F_660F38, 0, no_WDS, 0xC7, 0x30, P_686 or P_AVX, 0,0x98, RWF_VEX or RWF_EVEX or RWF_T1S, VX_L or VX_NND or VX_RW0 )
insv(VSCATTERPF1DPD, vscatterpf1dpd, OpCls(M32_M256,NONE, NONE ), F_660F38, 0, no_WDS, 0xC6, 0x30, P_686 or P_AVX, 0,0x98, RWF_VEX or RWF_EVEX or RWF_T1S, VX_L or VX_NND or VX_RW1 )
insv(VSCATTERPF1QPD, vscatterpf1qpd, OpCls(M64_M512,NONE, NONE ), F_660F38, 0, no_WDS, 0xC7, 0x30, P_686 or P_AVX, 0,0x98, RWF_VEX or RWF_EVEX or RWF_T1S, VX_L or VX_NND or VX_RW1 )
insv(VGETEXPPD, vgetexppd,   OpCls( XMM,    XMM_M128_M64, NONE ), F_660F38, 1, no_WDS, 0x42, 0x00, P_686 or P_AVX, 0,0x60, RWF_VEX or RWF_EVEX, VX_L or VX_NND or VX_RW1 )
insv(VGETEXPPS, vgetexpps,   OpCls( XMM,    XMM_M128_M32, NONE ), F_660F38, 1, no_WDS, 0x42, 0x00, P_686 or P_AVX, 0,0x60, RWF_VEX or RWF_EVEX, VX_L or VX_NND or VX_RW0 )
insv(VGETEXPSD, vgetexpsd,   OpCls( XMM,    XMM_M128_M64, NONE ), F_660F38, 1, no_WDS, 0x43, 0x00, P_686 or P_AVX, 0,0x60, RWF_VEX or RWF_EVEX or RWF_T1S, VX_L or VX_RW1 )
insv(VGETEXPSS, vgetexpss,   OpCls( XMM,    XMM_M128_M32, NONE ), F_660F38, 1, no_WDS, 0x43, 0x00, P_686 or P_AVX, 0,0x60, RWF_VEX or RWF_EVEX or RWF_T1S, VX_L or VX_RW0 )
insv(VRSQRT14PD, vrsqrt14pd, OpCls( XMM,    XMM_M128_M64, NONE ), F_660F38, 1, no_WDS, 0x4E, 0x00, P_686 or P_AVX, 0,0x60, RWF_VEX or RWF_EVEX, VX_L or VX_NND or VX_HALF or VX_RW1 )
insv(VRSQRT14PS, vrsqrt14ps, OpCls( XMM,    XMM_M128_M32, NONE ), F_660F38, 1, no_WDS, 0x4E, 0x00, P_686 or P_AVX, 0,0xF0, RWF_VEX or RWF_EVEX, VX_L or VX_NND or VX_HALF or VX_RW0 )
insv(VRSQRT14SD, vrsqrt14sd, OpCls( XMM,    XMM_M128_M64, NONE ), F_660F38, 1, no_WDS, 0x4F, 0x00, P_686 or P_AVX, 0,0x60, RWF_VEX or RWF_EVEX or RWF_T1S, VX_L or VX_RW1 )
insv(VRSQRT14SS, vrsqrt14ss, OpCls( XMM,    XMM_M128_M32, NONE ), F_660F38, 1, no_WDS, 0x4F, 0x00, P_686 or P_AVX, 0,0x60, RWF_VEX or RWF_EVEX or RWF_T1S, VX_L or VX_RW0 )
insv(VRSQRT28PD, vrsqrt28pd, OpCls( ZMM,    ZMM_M512_M64, NONE ), F_660F38, 1, no_WDS, 0xCC, 0x00, P_686 or P_AVX, 0,0x60, RWF_VEX or RWF_EVEX, VX_L or VX_NND or VX_HALF or VX_RW1 )
insv(VRSQRT28PS, vrsqrt28ps, OpCls( ZMM,    ZMM_M512_M32, NONE ), F_660F38, 1, no_WDS, 0xCC, 0x00, P_686 or P_AVX, 0,0x60, RWF_VEX or RWF_EVEX, VX_L or VX_NND or VX_HALF or VX_RW0 )
insv(VRSQRT28SD, vrsqrt28sd, OpCls( XMM,    XMM_M128_M64, NONE ), F_660F38, 1, no_WDS, 0xCD, 0x00, P_686 or P_AVX, 0,0x60, RWF_VEX or RWF_EVEX or RWF_T1S, VX_L or VX_RW1 )
insv(VRSQRT28SS, vrsqrt28ss, OpCls( XMM,    XMM_M128_M32, NONE ), F_660F38, 1, no_WDS, 0xCD, 0x00, P_686 or P_AVX, 0,0x60, RWF_VEX or RWF_EVEX or RWF_T1S, VX_L or VX_RW0 )
insv(VGETMANTPD, vgetmantpd, OpCls( XMM,    XMM_M128_M64, I8_U ), F_660F3A, 1, no_WDS, 0x26, 0x00, P_686 or P_AVX, 0,0xA0, RWF_VEX or RWF_EVEX, VX_L or VX_NND or VX_RW1 )
insv(VGETMANTPS, vgetmantps, OpCls( XMM,    XMM_M128_M32, I8_U ), F_660F3A, 1, no_WDS, 0x26, 0x00, P_686 or P_AVX, 0,0xA0, RWF_VEX or RWF_EVEX, VX_L or VX_NND or VX_RW0 )
insv(VGETMANTSD, vgetmantsd, OpCls( XMM,    XMM_M128_M64, I8_U ), F_660F3A, 1, no_WDS, 0x27, 0x00, P_686 or P_AVX, 0,0x60, RWF_VEX or RWF_EVEX or RWF_T1S, VX_L or VX_RW1 )
insv(VGETMANTSS, vgetmantss, OpCls( XMM,    XMM_M128_M32, I8_U ), F_660F3A, 1, no_WDS, 0x27, 0x00, P_686 or P_AVX, 0,0x60, RWF_VEX or RWF_EVEX or RWF_T1S, VX_L or VX_RW0 )
insv(VPEXPANDD, vpexpandd,   OpCls( XMM,    XMM_M128,     NONE ), F_660F38, 1, no_WDS, 0x89, 0x00, P_686 or P_AVX, 0,0x60, RWF_VEX or RWF_EVEX or RWF_T1S, VX_L or VX_NND or VX_RW0 )
insv(VRCP14PD, vrcp14pd,     OpCls( XMM,    XMM_M128_M64, NONE ), F_660F38, 1, no_WDS, 0x4C, 0x00, P_686 or P_AVX, 0,0x60, RWF_VEX or RWF_EVEX, VX_L or VX_NND or VX_RW1 )
insv(VRCP14PS, vrcp14ps,     OpCls( XMM,    XMM_M128_M32, NONE ), F_660F38, 1, no_WDS, 0x4C, 0x00, P_686 or P_AVX, 0,0x60, RWF_VEX or RWF_EVEX, VX_L or VX_NND or VX_RW0 )
insv(VRCP14SD, vrcp14sd,     OpCls( XMM,    XMM_M128_M64, NONE ), F_660F38, 1, no_WDS, 0x4D, 0x00, P_686 or P_AVX, 0,0x60, RWF_VEX or RWF_EVEX or RWF_T1S, VX_L or VX_RW1 )
insv(VRCP14SS, vrcp14ss,     OpCls( XMM,    XMM_M128_M32, NONE ), F_660F38, 1, no_WDS, 0x4D, 0x00, P_686 or P_AVX, 0,0x60, RWF_VEX or RWF_EVEX or RWF_T1S, VX_L or VX_RW0 )
insv(VREDUCEPD, vreducepd,   OpCls( XMM,    XMM_M128_M64, I8_U ), F_660F3A, 1, no_WDS, 0x56, 0x00, P_686 or P_AVX, 0,0xF0, RWF_VEX or RWF_EVEX, VX_L or VX_NND or VX_RW1 )
insv(VREDUCEPS, vreduceps,   OpCls( XMM,    XMM_M128_M32, I8_U ), F_660F3A, 1, no_WDS, 0x56, 0x00, P_686 or P_AVX, 0,0xF0, RWF_VEX or RWF_EVEX, VX_L or VX_NND or VX_RW0 )
insv(VREDUCESD, vreducesd,   OpCls( XMM,    XMM_M128_M64, I8_U ), F_660F3A, 1, no_WDS, 0x57, 0x00, P_686 or P_AVX, 0,0xF0, RWF_VEX or RWF_EVEX or RWF_T1S, VX_L or VX_RW1 )
insv(VREDUCESS, vreducess,   OpCls( XMM,    XMM_M128_M32, I8_U ), F_660F3A, 1, no_WDS, 0x57, 0x00, P_686 or P_AVX, 0,0xF0, RWF_VEX or RWF_EVEX or RWF_T1S, VX_L or VX_RW0 )
insv(VRNDSCALEPD, vrndscalepd, OpCls(XMM,   XMM_M128_M64, I8_U ), F_660F3A, 1, no_WDS, 0x09, 0x00, P_686 or P_AVX, 0,0x80, RWF_VEX or RWF_EVEX, VX_L or VX_NND or VX_RW1 )
insv(VRNDSCALEPS, vrndscaleps, OpCls(XMM,   XMM_M128_M32, I8_U ), F_660F3A, 1, no_WDS, 0x08, 0x00, P_686 or P_AVX, 0,0x80, RWF_VEX or RWF_EVEX, VX_L or VX_NND or VX_RW0 )
insv(VRNDSCALESD, vrndscalesd, OpCls(XMM,   XMM_M128_M64, I8_U ), F_660F3A, 1, no_WDS, 0x0B, 0x00, P_686 or P_AVX, 0,0xF0, RWF_VEX or RWF_EVEX or RWF_T1S, VX_L or VX_RW1 )
insv(VRNDSCALESS, vrndscaless, OpCls(XMM,   XMM_M128_M32, I8_U ), F_660F3A, 1, no_WDS, 0x0A, 0x00, P_686 or P_AVX, 0,0xF0, RWF_VEX or RWF_EVEX or RWF_T1S, VX_L or VX_RW0 )
insv(VPMOVB2M, vpmovb2m,     OpCls( K,      XMM,          NONE ), F_F30F38, 1, no_WDS, 0x29, 0x00, P_686 or P_AVX, 0,0xF0, RWF_VEX or RWF_EVEX, VX_L or VX_HALF or VX_RW0 )
insv(VPMOVD2M, vpmovd2m,     OpCls( K,      XMM,          NONE ), F_F30F38, 1, no_WDS, 0x39, 0x00, P_686 or P_AVX, 0,0xF0, RWF_VEX or RWF_EVEX, VX_L or VX_HALF or VX_RW0 )
insv(VPMOVM2B, vpmovm2b,     OpCls( XMM,    K,            NONE ), F_F30F38, 1, no_WDS, 0x28, 0x00, P_686 or P_AVX, 0,0xF0, RWF_VEX or RWF_EVEX, VX_L or VX_HALF or VX_RW0 )
insv(VPMOVM2D, vpmovm2d,     OpCls( XMM,    K,            NONE ), F_F30F38, 1, no_WDS, 0x38, 0x00, P_686 or P_AVX, 0,0xF0, RWF_VEX or RWF_EVEX, VX_L or VX_HALF or VX_RW0 )
insv(VPMOVDB, vpmovdb,       OpCls( XMM_MXQD,  XYZMM,     NONE ), F_F30F38, 0, no_WDS, 0x31, 0x00, P_686 or P_AVX, 0,0x80, RWF_VEX or RWF_EVEX or RWF_QVM, VX_L or VX_NND or VX_RW0 )
insv(VPMOVDW, vpmovdw,       OpCls( XMM_MXQ,   XYZMM,     NONE ), F_F30F38, 0, no_WDS, 0x33, 0x00, P_686 or P_AVX, 0,0x80, RWF_VEX or RWF_EVEX or RWF_QVM, VX_L or VX_NND or VX_RW0 )
insv(VPMOVQB, vpmovqb,       OpCls( XMM_MXQDW, XYZMM,     NONE ), F_F30F38, 0, no_WDS, 0x32, 0x00, P_686 or P_AVX, 0,0x80, RWF_VEX or RWF_EVEX or RWF_QVM, VX_L or VX_NND or VX_RW0 )
insv(VPMOVQD, vpmovqd,       OpCls( XMM_MXQD,  XYZMM,     NONE ), F_F30F38, 0, no_WDS, 0x35, 0x00, P_686 or P_AVX, 0,0x80, RWF_VEX or RWF_EVEX or RWF_QVM, VX_L or VX_NND or VX_RW0 )
insv(VPMOVQW, vpmovqw,       OpCls( XMM_MXQD,  XYZMM,     NONE ), F_F30F38, 0, no_WDS, 0x34, 0x00, P_686 or P_AVX, 0,0x80, RWF_VEX or RWF_EVEX or RWF_QVM, VX_L or VX_NND or VX_RW0 )
insv(VPMOVWB, vpmovwb,       OpCls( XMM_MXQ,   XYZMM,     NONE ), F_F30F38, 0, no_WDS, 0x30, 0x00, P_686 or P_AVX, 0,0x80, RWF_VEX or RWF_EVEX or RWF_QVM, VX_L or VX_NND or VX_RW0 )
insv(VPMOVSDB, vpmovsdb,     OpCls( XMM_MXQD,  XYZMM,     NONE ), F_F30F38, 0, no_WDS, 0x21, 0x00, P_686 or P_AVX, 0,0x60, RWF_VEX or RWF_EVEX or RWF_QVM, VX_L or VX_NND or VX_RW0 )
insv(VPMOVSDW, vpmovsdw,     OpCls( XMM_MXQ,   XYZMM,     NONE ), F_F30F38, 0, no_WDS, 0x23, 0x00, P_686 or P_AVX, 0,0x60, RWF_VEX or RWF_EVEX or RWF_QVM, VX_L or VX_NND or VX_RW0 )
insv(VPMOVSQB, vpmovsqb,     OpCls( XMM_MXQDW, XYZMM,     NONE ), F_F30F38, 0, no_WDS, 0x22, 0x00, P_686 or P_AVX, 0,0x60, RWF_VEX or RWF_EVEX or RWF_QVM, VX_L or VX_NND or VX_RW0 )
insv(VPMOVSQD, vpmovsqd,     OpCls( XMM_MXQD,  XYZMM,     NONE ), F_F30F38, 0, no_WDS, 0x25, 0x00, P_686 or P_AVX, 0,0x60, RWF_VEX or RWF_EVEX or RWF_QVM, VX_L or VX_NND or VX_RW0 )
insv(VPMOVSQW, vpmovsqw,     OpCls( XMM_MXQD,  XYZMM,     NONE ), F_F30F38, 0, no_WDS, 0x24, 0x00, P_686 or P_AVX, 0,0x60, RWF_VEX or RWF_EVEX or RWF_QVM, VX_L or VX_NND or VX_RW0 )
insv(VPMOVSWB, vpmovswb,     OpCls( XMM_MXQ,   XYZMM,     NONE ), F_F30F38, 0, no_WDS, 0x20, 0x00, P_686 or P_AVX, 0,0xF0, RWF_VEX or RWF_EVEX or RWF_QVM, VX_L or VX_NND or VX_RW0 )
insv(VPMOVUSDB, vpmovusdb,   OpCls( XMM_MXQD,  XYZMM,     NONE ), F_F30F38, 0, no_WDS, 0x11, 0x00, P_686 or P_AVX, 0,0x60, RWF_VEX or RWF_EVEX or RWF_QVM, VX_L or VX_NND or VX_RW0 )
insv(VPMOVUSDW, vpmovusdw,   OpCls( XMM_MXQ,   XYZMM,     NONE ), F_F30F38, 0, no_WDS, 0x13, 0x00, P_686 or P_AVX, 0,0x60, RWF_VEX or RWF_EVEX or RWF_QVM, VX_L or VX_NND or VX_RW0 )
insv(VPMOVUSQB, vpmovusqb,   OpCls( XMM_MXQDW, XYZMM,     NONE ), F_F30F38, 0, no_WDS, 0x12, 0x00, P_686 or P_AVX, 0,0x60, RWF_VEX or RWF_EVEX or RWF_QVM, VX_L or VX_NND or VX_RW0 )
insv(VPMOVUSQD, vpmovusqd,   OpCls( XMM_MXQD,  XYZMM,     NONE ), F_F30F38, 0, no_WDS, 0x15, 0x00, P_686 or P_AVX, 0,0x60, RWF_VEX or RWF_EVEX or RWF_QVM, VX_L or VX_NND or VX_RW0 )
insv(VPMOVUSQW, vpmovusqw,   OpCls( XMM_MXQD,  XYZMM,     NONE ), F_F30F38, 0, no_WDS, 0x14, 0x00, P_686 or P_AVX, 0,0x60, RWF_VEX or RWF_EVEX or RWF_QVM, VX_L or VX_NND or VX_RW0 )
insv(VPMOVUSWB, vpmovuswb,   OpCls( XMM_MXQ,   XYZMM,     NONE ), F_F30F38, 0, no_WDS, 0x10, 0x00, P_686 or P_AVX, 0,0xF0, RWF_VEX or RWF_EVEX or RWF_QVM, VX_L or VX_NND or VX_RW0 )
insv(VALIGND, valignd,       OpCls( XMM,    XMM_M128_M32, I8_U ), F_660F3A, 1, no_WDS, 0x03, 0x00, P_686 or P_AVX, 0,0xF0, RWF_VEX or RWF_EVEX, VX_L or VX_RW0 )
insv(VALIGNQ, valignq,       OpCls( XMM,    XMM_M128_M64, I8_U ), F_660F3A, 1, no_WDS, 0x03, 0x00, P_686 or P_AVX, 0,0xF0, RWF_VEX or RWF_EVEX, VX_L or VX_RW1 )
insv(VBLENDMPD, vblendmpd,   OpCls( XMM,    XMM_M128_M64, NONE ), F_660F38, 1, no_WDS, 0x65, 0x00, P_686 or P_AVX, 0,0xF0, RWF_VEX or RWF_EVEX, VX_L or VX_RW1 )
insv(VBLENDMPS, vblendmps,   OpCls( XMM,    XMM_M128_M32, NONE ), F_660F38, 1, no_WDS, 0x65, 0x00, P_686 or P_AVX, 0,0xF0, RWF_VEX or RWF_EVEX, VX_L or VX_RW0 )

insv(VFMADD132PD, vfmadd132pd, OpCls( XMM, XMM_M128_M64,  NONE ), F_660F38, 1, no_WDS, 0x98, 0x00, P_686 or P_AVX, 0,0xF0, RWF_VEX, VX_L or VX_RW1 )
insv(VFMADD213PD, vfmadd213pd, OpCls( XMM, XMM_M128_M64,  NONE ), F_660F38, 1, no_WDS, 0xA8, 0x00, P_686 or P_AVX, 0,0xF0, RWF_VEX, VX_L or VX_RW1 )
insv(VFMADD231PD, vfmadd231pd, OpCls( XMM, XMM_M128_M64,  NONE ), F_660F38, 1, no_WDS, 0xB8, 0x00, P_686 or P_AVX, 0,0xF0, RWF_VEX, VX_L or VX_RW1 )
insv(VFMADD132PS, vfmadd132ps, OpCls( XMM, XMM_M128_M32,  NONE ), F_660F38, 1, no_WDS, 0x98, 0x00, P_686 or P_AVX, 0,0xF0, RWF_VEX, VX_L or VX_RW0 )
insv(VFMADD213PS, vfmadd213ps, OpCls( XMM, XMM_M128_M32,  NONE ), F_660F38, 1, no_WDS, 0xA8, 0x00, P_686 or P_AVX, 0,0xF0, RWF_VEX, VX_L or VX_RW0 )
insv(VFMADD231PS, vfmadd231ps, OpCls( XMM, XMM_M128_M32,  NONE ), F_660F38, 1, no_WDS, 0xB8, 0x00, P_686 or P_AVX, 0,0xF0, RWF_VEX, VX_L or VX_RW0 )
insv(VFMADD132SD, vfmadd132sd, OpCls( XMM, XMM_M64,       NONE ), F_660F38, 1, no_WDS, 0x99, 0x00, P_686 or P_AVX, 0,0xF0, RWF_VEX or RWF_T1S, VX_L or VX_RW1 )
insv(VFMADD213SD, vfmadd213sd, OpCls( XMM, XMM_M64,       NONE ), F_660F38, 1, no_WDS, 0xA9, 0x00, P_686 or P_AVX, 0,0xF0, RWF_VEX or RWF_T1S, VX_L or VX_RW1 )
insv(VFMADD231SD, vfmadd231sd, OpCls( XMM, XMM_M64,       NONE ), F_660F38, 1, no_WDS, 0xB9, 0x00, P_686 or P_AVX, 0,0xF0, RWF_VEX or RWF_T1S, VX_L or VX_RW1 )
insv(VFMADD132SS, vfmadd132ss, OpCls( XMM, XMM_M128_M32,  NONE ), F_660F38, 1, no_WDS, 0x99, 0x00, P_686 or P_AVX, 0,0xF0, RWF_VEX, VX_L or VX_RW0 )
insv(VFMADD213SS, vfmadd213ss, OpCls( XMM, XMM_M128_M32,  NONE ), F_660F38, 1, no_WDS, 0xA9, 0x00, P_686 or P_AVX, 0,0xF0, RWF_VEX, VX_L or VX_RW0 )
insv(VFMADD231SS, vfmadd231ss, OpCls( XMM, XMM_M128_M32,  NONE ), F_660F38, 1, no_WDS, 0xB9, 0x00, P_686 or P_AVX, 0,0xF0, RWF_VEX, VX_L or VX_RW0 )

insv(VFMSUB132PD, vfmsub132pd, OpCls( XMM, XMM_M128_M64,  NONE ), F_660F38, 1, no_WDS, 0x9A, 0x00, P_686 or P_AVX, 0,0xF0, RWF_VEX, VX_L or VX_RW1 )
insv(VFMSUB213PD, vfmsub213pd, OpCls( XMM, XMM_M128_M64,  NONE ), F_660F38, 1, no_WDS, 0xAA, 0x00, P_686 or P_AVX, 0,0xF0, RWF_VEX, VX_L or VX_RW1 )
insv(VFMSUB231PD, vfmsub231pd, OpCls( XMM, XMM_M128_M64,  NONE ), F_660F38, 1, no_WDS, 0xBA, 0x00, P_686 or P_AVX, 0,0xF0, RWF_VEX, VX_L or VX_RW1 )
insv(VFMSUB132PS, vfmsub132ps, OpCls( XMM, XMM_M128_M32,  NONE ), F_660F38, 1, no_WDS, 0x9A, 0x00, P_686 or P_AVX, 0,0xF0, RWF_VEX, VX_L or VX_RW0 )
insv(VFMSUB213PS, vfmsub213ps, OpCls( XMM, XMM_M128_M32,  NONE ), F_660F38, 1, no_WDS, 0xAA, 0x00, P_686 or P_AVX, 0,0xF0, RWF_VEX, VX_L or VX_RW0 )
insv(VFMSUB231PS, vfmsub231ps, OpCls( XMM, XMM_M128_M32,  NONE ), F_660F38, 1, no_WDS, 0xBA, 0x00, P_686 or P_AVX, 0,0xF0, RWF_VEX, VX_L or VX_RW0 )

insv(VFMSUB132SD, vfmsub132sd, OpCls( XMM, XMM_M64,       NONE ), F_660F38, 1, no_WDS, 0x9B, 0x00, P_686 or P_AVX, 0,0x80, RWF_VEX or RWF_T1S, VX_L or VX_RW1 )
insv(VFMSUB213SD, vfmsub213sd, OpCls( XMM, XMM_M64,       NONE ), F_660F38, 1, no_WDS, 0xAB, 0x00, P_686 or P_AVX, 0,0x80, RWF_VEX or RWF_T1S, VX_L or VX_RW1 )
insv(VFMSUB231SD, vfmsub231sd, OpCls( XMM, XMM_M64,       NONE ), F_660F38, 1, no_WDS, 0xBB, 0x00, P_686 or P_AVX, 0,0x80, RWF_VEX or RWF_T1S, VX_L or VX_RW1 )
insv(VFMSUB132SS, vfmsub132ss, OpCls( XMM, XMM_M128_M32,  NONE ), F_660F38, 1, no_WDS, 0x9B, 0x00, P_686 or P_AVX, 0,0x80, RWF_VEX, VX_L or VX_RW0 )
insv(VFMSUB213SS, vfmsub213ss, OpCls( XMM, XMM_M128_M32,  NONE ), F_660F38, 1, no_WDS, 0xAB, 0x00, P_686 or P_AVX, 0,0x80, RWF_VEX, VX_L or VX_RW0 )
insv(VFMSUB231SS, vfmsub231ss, OpCls( XMM, XMM_M128_M32,  NONE ), F_660F38, 1, no_WDS, 0xBB, 0x00, P_686 or P_AVX, 0,0x80, RWF_VEX, VX_L or VX_RW0 )

insv(VFMADDSUB132PD, vfmaddsub132pd, OpCls( XMM, XMM_M128_M64,  NONE ), F_660F38, 1, no_WDS, 0x96, 0x00, P_686 or P_AVX, 0,0xF0, RWF_VEX, VX_L or VX_RW1 )
insv(VFMADDSUB213PD, vfmaddsub213pd, OpCls( XMM, XMM_M128_M64,  NONE ), F_660F38, 1, no_WDS, 0xA6, 0x00, P_686 or P_AVX, 0,0xF0, RWF_VEX, VX_L or VX_RW1 )
insv(VFMADDSUB231PD, vfmaddsub231pd, OpCls( XMM, XMM_M128_M64,  NONE ), F_660F38, 1, no_WDS, 0xB6, 0x00, P_686 or P_AVX, 0,0xF0, RWF_VEX, VX_L or VX_RW1 )
insv(VFMADDSUB132PS, vfmaddsub132ps, OpCls( XMM, XMM_M128_M32,  NONE ), F_660F38, 1, no_WDS, 0x96, 0x00, P_686 or P_AVX, 0,0xF0, RWF_VEX, VX_L or VX_RW0 )
insv(VFMADDSUB213PS, vfmaddsub213ps, OpCls( XMM, XMM_M128_M32,  NONE ), F_660F38, 1, no_WDS, 0xA6, 0x00, P_686 or P_AVX, 0,0xF0, RWF_VEX, VX_L or VX_RW0 )
insv(VFMADDSUB231PS, vfmaddsub231ps, OpCls( XMM, XMM_M128_M32,  NONE ), F_660F38, 1, no_WDS, 0xB6, 0x00, P_686 or P_AVX, 0,0xF0, RWF_VEX, VX_L or VX_RW0 )

insv(VFMSUBADD132PD, vfmsubadd132pd, OpCls( XMM, XMM_M128_M64,  NONE ), F_660F38, 1, no_WDS, 0x97, 0x00, P_686 or P_AVX, 0,0xF0, RWF_VEX, VX_L or VX_RW1 )
insv(VFMSUBADD213PD, vfmsubadd213pd, OpCls( XMM, XMM_M128_M64,  NONE ), F_660F38, 1, no_WDS, 0xA7, 0x00, P_686 or P_AVX, 0,0xF0, RWF_VEX, VX_L or VX_RW1 )
insv(VFMSUBADD231PD, vfmsubadd231pd, OpCls( XMM, XMM_M128_M64,  NONE ), F_660F38, 1, no_WDS, 0xB7, 0x00, P_686 or P_AVX, 0,0xF0, RWF_VEX, VX_L or VX_RW1 )
insv(VFMSUBADD132PS, vfmsubadd132ps, OpCls( XMM, XMM_M128_M32,  NONE ), F_660F38, 1, no_WDS, 0x97, 0x00, P_686 or P_AVX, 0,0xF0, RWF_VEX, VX_L or VX_RW0 )
insv(VFMSUBADD213PS, vfmsubadd213ps, OpCls( XMM, XMM_M128_M32,  NONE ), F_660F38, 1, no_WDS, 0xA7, 0x00, P_686 or P_AVX, 0,0xF0, RWF_VEX, VX_L or VX_RW0 )
insv(VFMSUBADD231PS, vfmsubadd231ps, OpCls( XMM, XMM_M128_M32,  NONE ), F_660F38, 1, no_WDS, 0xB7, 0x00, P_686 or P_AVX, 0,0xF0, RWF_VEX, VX_L or VX_RW0 )

insv(VFNMADD132PD, vfnmadd132pd, OpCls( XMM, XMM_M128_M64,  NONE ), F_660F38, 1, no_WDS, 0x9C, 0x00, P_686 or P_AVX, 0,0xF0, RWF_VEX, VX_L or VX_RW1 )
insv(VFNMADD213PD, vfnmadd213pd, OpCls( XMM, XMM_M128_M64,  NONE ), F_660F38, 1, no_WDS, 0xAC, 0x00, P_686 or P_AVX, 0,0xF0, RWF_VEX, VX_L or VX_RW1 )
insv(VFNMADD231PD, vfnmadd231pd, OpCls( XMM, XMM_M128_M64,  NONE ), F_660F38, 1, no_WDS, 0xBC, 0x00, P_686 or P_AVX, 0,0xF0, RWF_VEX, VX_L or VX_RW1 )
insv(VFNMADD132PS, vfnmadd132ps, OpCls( XMM, XMM_M128_M32,  NONE ), F_660F38, 1, no_WDS, 0x9C, 0x00, P_686 or P_AVX, 0,0xF0, RWF_VEX, VX_L or VX_RW0 )
insv(VFNMADD213PS, vfnmadd213ps, OpCls( XMM, XMM_M128_M32,  NONE ), F_660F38, 1, no_WDS, 0xAC, 0x00, P_686 or P_AVX, 0,0xF0, RWF_VEX, VX_L or VX_RW0 )
insv(VFNMADD231PS, vfnmadd231ps, OpCls( XMM, XMM_M128_M32,  NONE ), F_660F38, 1, no_WDS, 0xBC, 0x00, P_686 or P_AVX, 0,0xF0, RWF_VEX, VX_L or VX_RW0 )

insv(VFNMADD132SD, vfnmadd132sd, OpCls( XMM, XMM_M64,       NONE ), F_660F38, 1, no_WDS, 0x9D, 0x00, P_686 or P_AVX, 0,0xF0, RWF_VEX or RWF_T1S, VX_L or VX_RW1 )
insv(VFNMADD213SD, vfnmadd213sd, OpCls( XMM, XMM_M64,       NONE ), F_660F38, 1, no_WDS, 0xAD, 0x00, P_686 or P_AVX, 0,0xF0, RWF_VEX or RWF_T1S, VX_L or VX_RW1 )
insv(VFNMADD231SD, vfnmadd231sd, OpCls( XMM, XMM_M64,       NONE ), F_660F38, 1, no_WDS, 0xBD, 0x00, P_686 or P_AVX, 0,0xF0, RWF_VEX or RWF_T1S, VX_L or VX_RW1 )
insv(VFNMADD132SS, vfnmadd132ss, OpCls( XMM, XMM_M128_M32,  NONE ), F_660F38, 1, no_WDS, 0x9D, 0x00, P_686 or P_AVX, 0,0xF0, RWF_VEX, VX_L or VX_RW0 )
insv(VFNMADD213SS, vfnmadd213ss, OpCls( XMM, XMM_M128_M32,  NONE ), F_660F38, 1, no_WDS, 0xAD, 0x00, P_686 or P_AVX, 0,0xF0, RWF_VEX, VX_L or VX_RW0 )
insv(VFNMADD231SS, vfnmadd231ss, OpCls( XMM, XMM_M128_M32,  NONE ), F_660F38, 1, no_WDS, 0xBD, 0x00, P_686 or P_AVX, 0,0xF0, RWF_VEX, VX_L or VX_RW0 )

insv(VFNMSUB132PD, vfnmsub132pd, OpCls( XMM, XMM_M128_M64,  NONE ), F_660F38, 1, no_WDS, 0x9E, 0x00, P_686 or P_AVX, 0,0xF0, RWF_VEX, VX_L or VX_RW1 )
insv(VFNMSUB213PD, vfnmsub213pd, OpCls( XMM, XMM_M128_M64,  NONE ), F_660F38, 1, no_WDS, 0xAE, 0x00, P_686 or P_AVX, 0,0xF0, RWF_VEX, VX_L or VX_RW1 )
insv(VFNMSUB231PD, vfnmsub231pd, OpCls( XMM, XMM_M128_M64,  NONE ), F_660F38, 1, no_WDS, 0xBE, 0x00, P_686 or P_AVX, 0,0xF0, RWF_VEX, VX_L or VX_RW1 )
insv(VFNMSUB132PS, vfnmsub132ps, OpCls( XMM, XMM_M128_M32,  NONE ), F_660F38, 1, no_WDS, 0x9E, 0x00, P_686 or P_AVX, 0,0xF0, RWF_VEX, VX_L or VX_RW0 )
insv(VFNMSUB213PS, vfnmsub213ps, OpCls( XMM, XMM_M128_M32,  NONE ), F_660F38, 1, no_WDS, 0xAE, 0x00, P_686 or P_AVX, 0,0xF0, RWF_VEX, VX_L or VX_RW0 )
insv(VFNMSUB231PS, vfnmsub231ps, OpCls( XMM, XMM_M128_M32,  NONE ), F_660F38, 1, no_WDS, 0xBE, 0x00, P_686 or P_AVX, 0,0xF0, RWF_VEX, VX_L or VX_RW0 )

insv(VFNMSUB132SD, vfnmsub132sd, OpCls( XMM, XMM_M64,       NONE ), F_660F38, 1, no_WDS, 0x9F, 0x00, P_686 or P_AVX, 0,0xF0, RWF_VEX or RWF_T1S, VX_L or VX_RW1 )
insv(VFNMSUB213SD, vfnmsub213sd, OpCls( XMM, XMM_M64,       NONE ), F_660F38, 1, no_WDS, 0xAF, 0x00, P_686 or P_AVX, 0,0xF0, RWF_VEX or RWF_T1S, VX_L or VX_RW1 )
insv(VFNMSUB231SD, vfnmsub231sd, OpCls( XMM, XMM_M64,       NONE ), F_660F38, 1, no_WDS, 0xBF, 0x00, P_686 or P_AVX, 0,0xF0, RWF_VEX or RWF_T1S, VX_L or VX_RW1 )
insv(VFNMSUB132SS, vfnmsub132ss, OpCls( XMM, XMM_M128_M32,  NONE ), F_660F38, 1, no_WDS, 0x9F, 0x00, P_686 or P_AVX, 0,0xF0, RWF_VEX, VX_L or VX_RW0 )
insv(VFNMSUB213SS, vfnmsub213ss, OpCls( XMM, XMM_M128_M32,  NONE ), F_660F38, 1, no_WDS, 0xAF, 0x00, P_686 or P_AVX, 0,0xF0, RWF_VEX, VX_L or VX_RW0 )
insv(VFNMSUB231SS, vfnmsub231ss, OpCls( XMM, XMM_M128_M32,  NONE ), F_660F38, 1, no_WDS, 0xBF, 0x00, P_686 or P_AVX, 0,0xF0, RWF_VEX, VX_L or VX_RW0 )

insv(VINSERTF32X4, vinsertf32x4, OpCls( YMM, XMM_M128,      I8_U ), F_660F3A, 1, no_WDS, 0x18, 0x00, P_686 or P_AVX, 0,0xF0, RWF_VEX or RWF_EVEX, VX_L or VX_HALF or VX_RW0 )
insv(VINSERTF64x2, vinsertf64x2, OpCls( YMM, XMM_M128,      I8_U ), F_660F3A, 1, no_WDS, 0x18, 0x00, P_686 or P_AVX, 0,0xF0, RWF_VEX or RWF_EVEX, VX_L or VX_RW1 )
insv(VINSERTF32x8, vinsertf32x8, OpCls( YMM, XMM_M128,      I8_U ), F_660F3A, 1, no_WDS, 0x1A, 0x00, P_686 or P_AVX, 0,0xF0, RWF_VEX or RWF_EVEX, VX_L or VX_RW0 )
insv(VINSERTF64x4, vinsertf64x4, OpCls( YMM, XMM_M128,      I8_U ), F_660F3A, 1, no_WDS, 0x1A, 0x00, P_686 or P_AVX, 0,0xF0, RWF_VEX or RWF_EVEX, VX_L or VX_RW1 )
insv(VINSERTI32x4, vinserti32x4, OpCls( YMM, XMM_M128,      I8_U ), F_660F3A, 1, no_WDS, 0x38, 0x00, P_686 or P_AVX, 0,0xF0, RWF_VEX or RWF_EVEX, VX_L or VX_HALF or VX_RW0 )
insv(VINSERTI64x2, vinserti64x2, OpCls( YMM, XMM_M128,      I8_U ), F_660F3A, 1, no_WDS, 0x38, 0x00, P_686 or P_AVX, 0,0xF0, RWF_VEX or RWF_EVEX, VX_L or VX_RW1 )
insv(VINSERTI32x8, vinserti32x8, OpCls( YMM, XMM_M128,      I8_U ), F_660F3A, 1, no_WDS, 0x3A, 0x00, P_686 or P_AVX, 0,0xF0, RWF_VEX or RWF_EVEX, VX_L or VX_RW0 )
insv(VINSERTI64x4, vinserti64x4, OpCls( YMM, XMM_M128,      I8_U ), F_660F3A, 1, no_WDS, 0x3A, 0x00, P_686 or P_AVX, 0,0xF0, RWF_VEX or RWF_EVEX, VX_L or VX_RW1 )

insv(VPABSQ, vpabsq,             OpCls( XMM,  XMM_M128_M64, NONE ), F_660F38, 1, no_WDS, 0x1F, 0x00, P_686 or P_AVX, 0,0xF0, RWF_VEX or RWF_EVEX, VX_L or VX_NND or VX_RW1 )
insv(VPCMPB, vpcmpb,             OpCls( K,    XMM_M128_M32, I8_U ), F_660F3A, 1, no_WDS, 0x3F, 0x00, P_686 or P_AVX, 0,0xF0, RWF_VEX or RWF_EVEX, VX_L or VX_RW0 )
insv(VPCMPD, vpcmpd,             OpCls( K,    XMM_M128_M32, I8_U ), F_660F3A, 1, no_WDS, 0x1F, 0x00, P_686 or P_AVX, 0,0xF0, RWF_VEX or RWF_EVEX, VX_L or VX_RW0 )
insv(VPCMPQ, vpcmpq,             OpCls( K,    XMM_M128_M64, I8_U ), F_660F3A, 1, no_WDS, 0x1F, 0x00, P_686 or P_AVX, 0,0xF0, RWF_VEX or RWF_EVEX, VX_L or VX_RW1 )
insv(VPCMPUB, vpcmpub,           OpCls( K,    XMM_M128_M32, I8_U ), F_660F3A, 1, no_WDS, 0x3E, 0x00, P_686 or P_AVX, 0,0xF0, RWF_VEX or RWF_EVEX, VX_L or VX_RW0 )
insv(VPCMPUD, vpcmpud,           OpCls( K,    XMM_M128_M32, I8_U ), F_660F3A, 1, no_WDS, 0x1E, 0x00, P_686 or P_AVX, 0,0xF0, RWF_VEX or RWF_EVEX, VX_L or VX_RW0 )
insv(VPCMPUQ, vpcmpuq,           OpCls( K,    XMM_M128_M64, I8_U ), F_660F3A, 1, no_WDS, 0x1E, 0x00, P_686 or P_AVX, 0,0xF0, RWF_VEX or RWF_EVEX, VX_L or VX_RW1 )
insv(VPBLENDMD, vpblendmd,       OpCls( XMM,  XMM_M128_M32, NONE ), F_660F38, 1, no_WDS, 0x64, 0x00, P_686 or P_AVX, 0,0xF0, RWF_VEX or RWF_EVEX, VX_L or VX_RW0 )
insv(VPBLENDMQ, vpblendmq,       OpCls( XMM,  XMM_M128_M64, NONE ), F_660F38, 1, no_WDS, 0x64, 0x00, P_686 or P_AVX, 0,0xF0, RWF_VEX or RWF_EVEX, VX_L or VX_RW1 )
insv(VPMAXSQ, vpmaxsq,           OpCls( XMM,  XMM_M128_M64, NONE ), F_660F38, 1, no_WDS, 0x3D, 0x00, P_686 or P_AVX, 0,0xF0, RWF_VEX or RWF_EVEX, VX_L or VX_RW1 )
insv(VPMAXUQ, vpmaxuq,           OpCls( XMM,  XMM_M128_M64, NONE ), F_660F38, 1, no_WDS, 0x3F, 0x00, P_686 or P_AVX, 0,0xF0, RWF_VEX or RWF_EVEX, VX_L or VX_RW1 )
insv(VPMINSQ, vpminsq,           OpCls( XMM,  XMM_M128_M64, NONE ), F_660F38, 1, no_WDS, 0x39, 0x00, P_686 or P_AVX, 0,0xF0, RWF_VEX or RWF_EVEX, VX_L or VX_RW1 )
insv(VPMINUQ, vpminuq,           OpCls( XMM,  XMM_M128_M64, NONE ), F_660F38, 1, no_WDS, 0x3B, 0x00, P_686 or P_AVX, 0,0xF0, RWF_VEX or RWF_EVEX, VX_L or VX_RW1 )
insv(VPORD, vpord,               OpCls( XMM,  XMM_M128_M32, NONE ), F_660F,   1, no_WDS, 0xEB, 0x00, P_686 or P_AVX, 0,0xF0, RWF_VEX or RWF_EVEX, VX_L or VX_RW0 )
insv(VPORQ, vporq,               OpCls( XMM,  XMM_M128_M64, NONE ), F_660F,   1, no_WDS, 0xEB, 0x00, P_686 or P_AVX, 0,0xF0, RWF_VEX or RWF_EVEX, VX_L or VX_RW1 )

insv(VPTESTMB, vptestmb,         OpCls( K,    XMM_M128_M64, NONE ), F_660F38, 1, no_WDS, 0x26, 0x00, P_686 or P_AVX, 0,0xF0, RWF_VEX or RWF_EVEX, VX_L or VX_RW0 )
insv(VPTESTMW, vptestmw,         OpCls( K,    XMM_M128_M64, NONE ), F_660F38, 1, no_WDS, 0x26, 0x00, P_686 or P_AVX, 0,0xF0, RWF_VEX or RWF_EVEX, VX_L or VX_RW1 )
insv(VPTESTMD, vptestmd,         OpCls( K,    XMM_M128_M32, NONE ), F_660F38, 1, no_WDS, 0x27, 0x00, P_686 or P_AVX, 0,0xF0, RWF_VEX or RWF_EVEX, VX_L or VX_RW0 )
insv(VPTESTMQ, vptestmq,         OpCls( K,    XMM_M128_M64, NONE ), F_660F38, 1, no_WDS, 0x27, 0x00, P_686 or P_AVX, 0,0xF0, RWF_VEX or RWF_EVEX, VX_L or VX_RW1 )
insv(VPTERNLOGD, vpternlogd,     OpCls( XMM,  XMM_M128_M32, I8_U ), F_660F3A, 1, no_WDS, 0x25, 0x00, P_686 or P_AVX, 0,0xF0, RWF_VEX or RWF_EVEX, VX_L or VX_RW0 )
insv(VPTERNLOGQ, vpternlogq,     OpCls( XMM,  XMM_M128_M64, I8_U ), F_660F3A, 1, no_WDS, 0x25, 0x00, P_686 or P_AVX, 0,0xF0, RWF_VEX or RWF_EVEX, VX_L or VX_RW1 )
insv(VSHUFF32X4, vshuff32x4,     OpCls( YMM,  YMM_M256_M32, I8_U ), F_660F3A, 1, no_WDS, 0x23, 0x00, P_686 or P_AVX, 0,0xF0, RWF_VEX or RWF_EVEX, VX_L or VX_RW0 )
insv(VSHUFF64X2, vshuff64x2,     OpCls( YMM,  YMM_M256_M64, I8_U ), F_660F3A, 1, no_WDS, 0x23, 0x00, P_686 or P_AVX, 0,0xF0, RWF_VEX or RWF_EVEX, VX_L or VX_RW1 )
insv(VSHUFI32X4, vshufi32x4,     OpCls( YMM,  YMM_M256_M32, I8_U ), F_660F3A, 1, no_WDS, 0x43, 0x00, P_686 or P_AVX, 0,0xF0, RWF_VEX or RWF_EVEX, VX_L or VX_RW0 )
insv(VSHUFI64X2, vshufi64x2,     OpCls( YMM,  YMM_M256_M64, I8_U ), F_660F3A, 1, no_WDS, 0x43, 0x00, P_686 or P_AVX, 0,0xF0, RWF_VEX or RWF_EVEX, VX_L or VX_RW1 )
insv(VCVTSD2USI, vcvtsd2usi,     OpCls( R32_M32, XMM_M64,   NONE ), F_F20F,   1, no_WDS, 0x79, 0x00, P_686 or P_AVX, 0,0xF0, RWF_VEX or RWF_EVEX, VX_L or VX_RW0 )
insn(VCVTSD2USI, 1,              OpCls( R64_M64, XMM_M64,   NONE ), F_F20F,   1, no_WDS, 0x79, 0x00, P_686 or P_AVX, 0,0xF2 )
insv(VCVTSS2USI, vcvtss2usi,     OpCls( R32_M32, XMM_M32,   NONE ), F_F30F,   1, no_WDS, 0x79, 0x00, P_686 or P_AVX, 0,0xF0, RWF_VEX or RWF_EVEX, VX_L or VX_RW0 )
insn(VCVTSS2USI, 1,              OpCls( R64_M64, XMM_M32,   NONE ), F_F30F,   1, no_WDS, 0x79, 0x00, P_686 or P_AVX, 0,0xF2 )
insv(VCVTUSI2SD, vcvtusi2sd,     OpCls( XMM,  R32_M32,      NONE ), F_F20F,   1, no_WDS, 0x7B, 0x00, P_686 or P_AVX, 0,0xF0, RWF_VEX or RWF_EVEX or RWF_T1S, VX_L or VX_RW0 )
insn(VCVTUSI2SD, 1,              OpCls( XMM,  R64_M64,      NONE ), F_F20F,   1, no_WDS, 0x7B, 0x00, P_686 or P_AVX, 0,0xF2 )
insv(VCVTUSI2SS, vcvtusi2ss,     OpCls( XMM,  R32_M32,      NONE ), F_F30F,   1, no_WDS, 0x7B, 0x00, P_686 or P_AVX, 0,0xF0, RWF_VEX or RWF_EVEX or RWF_T1S, VX_L or VX_RW0 )
insn(VCVTUSI2SS, 1,              OpCls( XMM,  R64_M64,      NONE ), F_F30F,   1, no_WDS, 0x7B, 0x00, P_686 or P_AVX, 0,0xF2 )
insv(VCVTTSD2USI, vcvttsd2usi,   OpCls( R32_M32, XMM_M64,   NONE ), F_F20F,   1, no_WDS, 0x78, 0x00, P_686 or P_AVX, 0,0xF0, RWF_VEX or RWF_EVEX, VX_L or VX_RW0 )
insn(VCVTTSD2USI, 1,             OpCls( R64_M64, XMM_M64,   NONE ), F_F20F,   1, no_WDS, 0x78, 0x00, P_686 or P_AVX, 0,0xF2 )
insv(VCVTTSS2USI, vcvttss2usi,   OpCls( R32_M32, XMM_M32,   NONE ), F_F30F,   1, no_WDS, 0x78, 0x00, P_686 or P_AVX, 0,0xF0, RWF_VEX or RWF_EVEX, VX_L or VX_RW0 )
insn(VCVTTSS2USI, 1,             OpCls( R64_M64, XMM_M32,   NONE ), F_F30F,   1, no_WDS, 0x78, 0x00, P_686 or P_AVX, 0,0xF2 )
insv(VSCALEFPD, vscalefpd,       OpCls( XMM,  XMM_M128_M64, NONE ), F_660F38, 1, no_WDS, 0x2C, 0x00, P_686 or P_AVX, 0,0xF0, RWF_VEX or RWF_EVEX, VX_L or VX_RW1 )
insv(VSCALEFPS, vscalefps,       OpCls( XMM,  XMM_M128_M32, NONE ), F_660F38, 1, no_WDS, 0x2C, 0x00, P_686 or P_AVX, 0,0xF0, RWF_VEX or RWF_EVEX, VX_L or VX_RW0 )
insv(VSCALEFSD, vscalefsd,       OpCls( XMM,  XMM_M128_M64, NONE ), F_660F38, 1, no_WDS, 0x2D, 0x00, P_686 or P_AVX, 0,0xF0, RWF_VEX or RWF_EVEX or RWF_T1S, VX_L or VX_RW1 )
insv(VSCALEFSS, vscalefss,       OpCls( XMM,  XMM_M128_M32, NONE ), F_660F38, 1, no_WDS, 0x2D, 0x00, P_686 or P_AVX, 0,0xF0, RWF_VEX or RWF_EVEX or RWF_T1S, VX_L or VX_RW0 )
insv(VFIXUPIMMPD, vfixupimmpd,   OpCls( XMM,  XMM_M128_M64, I8_U ), F_660F3A, 1, no_WDS, 0x54, 0x00, P_686 or P_AVX, 0,0xF0, RWF_VEX or RWF_EVEX, VX_L or VX_RW1 )
insv(VFIXUPIMMPS, vfixupimmps,   OpCls( XMM,  XMM_M128_M32, I8_U ), F_660F3A, 1, no_WDS, 0x54, 0x00, P_686 or P_AVX, 0,0xF0, RWF_VEX or RWF_EVEX, VX_L or VX_RW0 )
insv(VFIXUPIMMSD, vfixupimmsd,   OpCls( XMM,  XMM_M128_M64, I8_U ), F_660F3A, 1, no_WDS, 0x55, 0x00, P_686 or P_AVX, 0,0xF0, RWF_VEX or RWF_EVEX or RWF_T1S, VX_L or VX_RW1 )
insv(VFIXUPIMMSS, vfixupimmss,   OpCls( XMM,  XMM_M128_M32, I8_U ), F_660F3A, 1, no_WDS, 0x55, 0x00, P_686 or P_AVX, 0,0xF0, RWF_VEX or RWF_EVEX or RWF_T1S, VX_L or VX_RW0 )
insv(VPERMI2D, vpermi2d,         OpCls( XMM,  XMM_M128_M32, NONE ), F_660F38, 1, no_WDS, 0x76, 0x00, P_686 or P_AVX, 0,0xF0, RWF_VEX or RWF_EVEX, VX_L or VX_RW0 )
insv(VPERMI2Q, vpermi2q,         OpCls( XMM,  XMM_M128_M64, NONE ), F_660F38, 1, no_WDS, 0x76, 0x00, P_686 or P_AVX, 0,0xF0, RWF_VEX or RWF_EVEX, VX_L or VX_RW1 )
insv(VPERMI2PS, vpermi2ps,       OpCls( XMM,  XMM_M128_M32, NONE ), F_660F38, 1, no_WDS, 0x77, 0x00, P_686 or P_AVX, 0,0xF0, RWF_VEX or RWF_EVEX, VX_L or VX_RW0 )
insv(VPERMI2PD, vpermi2pd,       OpCls( XMM,  XMM_M128_M64, NONE ), F_660F38, 1, no_WDS, 0x77, 0x00, P_686 or P_AVX, 0,0xF0, RWF_VEX or RWF_EVEX, VX_L or VX_RW1 )

avxins(VMOVDQA32,       VMOVDQA64,      vmovdqa64,      RWF_EVEX, VX_L or VX_NND or VX_RW1 )
avxins(VMOVDQU8,        VMOVDQU16,      vmovdqu16,      RWF_EVEX, VX_L or VX_NND or VX_RW1 )
avxins(VMOVDQU32,       VMOVDQU64,      vmovdqu64,      RWF_EVEX, VX_L or VX_NND or VX_RW1 )
avxins(VCOMPRESSPD,     VCOMPRESSPS,    vcompressps,    RWF_EVEX or RWF_T1S, VX_L or VX_NND or VX_HALF or VX_RW0 )
avxins(VPCOMPRESSD,     VPCOMPRESSQ,    vpcompressq,    RWF_EVEX or RWF_T1S, VX_L or VX_HALF or VX_RW1 )
avxins(VBROADCASTF32X4, VBROADCASTF64X2,vbroadcastf64x2,RWF_EVEX or RWF_T2, VX_L or VX_NND or VX_HALF or VX_RW1 )
avxins(VBROADCASTI32X4, VBROADCASTI64X2,vbroadcasti64x2,RWF_EVEX or RWF_T2, VX_L or VX_NND or VX_HALF or VX_RW1 )
avxins(VBROADCASTI32X8, VBROADCASTI64X4,vbroadcasti64x4,RWF_EVEX or RWF_T4, VX_L or VX_NND or VX_HALF or VX_RW1 )
avxins(VCVTPD2QQ,       VCVTPS2QQ,      vcvtps2qq,      RWF_EVEX, VX_L or VX_NND or VX_HALF or VX_RW0 )
avxins(VCVTPD2UDQ,      VCVTPS2UDQ,     vcvtps2udq,     RWF_EVEX, VX_L or VX_NND or VX_RW0 )
avxins(VCVTPD2UQQ,      VCVTPS2UQQ,     vcvtps2uqq,     RWF_EVEX, VX_L or VX_NND or VX_HALF or VX_RW0 )
avxins(VCVTTPD2QQ,      VCVTTPS2QQ,     vcvttps2qq,     RWF_EVEX, VX_L or VX_NND or VX_HALF or VX_RW0 )
avxins(VCVTTPD2UDQ,     VCVTTPS2UDQ,    vcvttps2udq,    RWF_EVEX, VX_L or VX_NND or VX_RW0 )
avxins(VCVTTPD2UQQ,     VCVTTPS2UQQ,    vcvttps2uqq,    RWF_EVEX, VX_L or VX_NND or VX_HALF or VX_RW0 )
avxins(VCVTUDQ2PD,      VCVTUQQ2PD,     vcvtuqq2pd,     RWF_EVEX, VX_L or VX_NND or VX_RW1 )
avxins(VCVTUQQ2PS,      VCVTUDQ2PS,     vcvtudq2ps,     RWF_EVEX, VX_L or VX_NND or VX_RW0 )
avxins(VEXPANDPD,       VEXPANDPS,      vexpandps,      RWF_EVEX or RWF_T1S, VX_L or VX_NND or VX_RW0 )
avxins(VEXTRACTF32x4,   VEXTRACTF64X2,  vextractf64x2,  RWF_EVEX, VX_L or VX_NND or VX_RW1 )
avxins(VEXTRACTF32X8,   VEXTRACTF64x4,  vextractf64x4,  RWF_EVEX, VX_L or VX_NND or VX_RW1 )
avxins(VEXTRACTI32x4,   VEXTRACTI64X2,  vextracti64x2,  RWF_EVEX, VX_L or VX_NND or VX_RW1 )
avxins(VEXTRACTI32X8,   VEXTRACTI64x4,  vextracti64x4,  RWF_EVEX, VX_L or VX_NND or VX_RW1 )
avxins(VFPCLASSPD,      VFPCLASSPS,     vfpclassps,     RWF_EVEX, VX_L or VX_NND or VX_HALF or VX_RW0 )
avxins(VGATHERDPS,      VGATHERDPD,     vgatherdpd,     RWF_T1S,  VX_L or VX_NND or VX_RW1 )
avxins(VGATHERQPS,      VGATHERQPD,     vgatherqpd,     RWF_T1S,  VX_L or VX_NND or VX_RW1 )
avxins(VPGATHERDD,      VPGATHERDQ,     vpgatherdq,     RWF_T1S, VX_L or VX_NND or VX_RW1 )
avxins(VPGATHERQD,      VPGATHERQQ,     vpgatherqq,     RWF_T1S, VX_L or VX_NND or VX_RW1 )
avxins(VSCATTERDPS,     VSCATTERDPD,    vscatterdpd,    RWF_EVEX or RWF_T1S, VX_L or VX_NND or VX_RW1 )
avxins(VSCATTERQPS,     VSCATTERQPD,    vscatterqpd,    RWF_EVEX or RWF_T1S, VX_L or VX_NND or VX_RW1 )
avxins(VPSCATTERDD,     VPSCATTERDQ,    vpscatterdq,    RWF_EVEX or RWF_T1S, VX_L or VX_NND or VX_RW1 )
avxins(VPSCATTERQD,     VPSCATTERQQ,    vpscatterqq,    RWF_EVEX or RWF_T1S, VX_L or VX_NND or VX_RW1 )
avxins(VPEXPANDD,       VPEXPANDQ,      vpexpandq,      RWF_EVEX or RWF_T1S, VX_L or VX_NND or VX_RW1 )
avxins(VPMOVB2M,        VPMOVW2M,       vpmovw2m,       RWF_EVEX, VX_L or VX_HALF or VX_RW1 )
avxins(VPMOVD2M,        VPMOVQ2M,       vpmovq2m,       RWF_EVEX, VX_L or VX_HALF or VX_RW1 )
avxins(VPMOVM2D,        VPMOVM2Q,       vpmovm2q,       RWF_EVEX, VX_L or VX_HALF or VX_RW1 )
avxins(VPMOVM2B,        VPMOVM2W,       vpmovm2w,       RWF_EVEX, VX_L or VX_HALF or VX_RW1 )

; added v2.34.59

; VEX.128.66.0F38.W0 50 /r VPDPBUSD xmm1, xmm2, xmm3/m128
; VEX.128.66.0F38.W0 51 /r VPDPBUSDS xmm1, xmm2, xmm3/m128
; VEX.128.66.0F38.W0 52 /r VPDPWSSD xmm1, xmm2, xmm3/m128
; VEX.128.66.0F38.W0 53 /r VPDPWSSDS xmm1, xmm2, xmm3/m128

; EVEX.128.66.0F38.W0 53 /r VPDPWSSDS xmm1{k1}{z}, xmm2, xmm3/m128/m32bcst

insv(PDPBUSD,   0pdpbusd, OpCls( XMM, XMM_M128_M32, NONE ), F_660F38, 1, 0, 0x50, 0x00, P_686 or P_AVX, 0,0x80, RWF_VEX or RWF_T1S, VX_NND or VX_RW0 )
insn(PDPBUSD,   1,        OpCls( YMM, YMM_M256_M32, NONE ), F_660F38, 1, 0, 0x50, 0x00, P_686 or P_AVX, 0,0x80)
insn(PDPBUSD,   2,        OpCls( ZMM, ZMM_M512_M32, NONE ), F_660F38, 1, 0, 0x50, 0x00, P_686 or P_AVX, 0,0x80)
insv(PDPBUSDS,  0pdpbusds,OpCls( XMM, XMM_M128_M32, NONE ), F_660F38, 1, 0, 0x51, 0x00, P_686 or P_AVX, 0,0x80, RWF_VEX or RWF_T1S, VX_NND or VX_RW0 )
insn(PDPBUSDS,  1,        OpCls( YMM, YMM_M256_M32, NONE ), F_660F38, 1, 0, 0x51, 0x00, P_686 or P_AVX, 0,0x80)
insn(PDPBUSDS,  2,        OpCls( ZMM, ZMM_M512_M32, NONE ), F_660F38, 1, 0, 0x51, 0x00, P_686 or P_AVX, 0,0x80)
insv(PDPWSSD,   0pdpwssd, OpCls( XMM, XMM_M128_M32, NONE ), F_660F38, 1, 0, 0x52, 0x00, P_686 or P_AVX, 0,0x80, RWF_VEX or RWF_T1S, VX_NND or VX_RW0 )
insn(PDPWSSD,   1,        OpCls( YMM, YMM_M256_M32, NONE ), F_660F38, 1, 0, 0x52, 0x00, P_686 or P_AVX, 0,0x80)
insn(PDPWSSD,   2,        OpCls( ZMM, ZMM_M512_M32, NONE ), F_660F38, 1, 0, 0x52, 0x00, P_686 or P_AVX, 0,0x80)
insv(PDPWSSDS,  0pdpwssds,OpCls( XMM, XMM_M128_M32, NONE ), F_660F38, 1, 0, 0x53, 0x00, P_686 or P_AVX, 0,0x80, RWF_VEX or RWF_T1S, VX_NND or VX_RW0 )
insn(PDPWSSDS,  1,        OpCls( YMM, YMM_M256_M32, NONE ), F_660F38, 1, 0, 0x53, 0x00, P_686 or P_AVX, 0,0x80)
insn(PDPWSSDS,  2,        OpCls( ZMM, ZMM_M512_M32, NONE ), F_660F38, 1, 0, 0x53, 0x00, P_686 or P_AVX, 0,0x80)

avxins(PDPBUSD,  VPDPBUSD,  vpdpbusd,  RWF_EVEX, VX_RW0 )
avxins(PDPBUSDS, VPDPBUSDS, vpdpbusds, RWF_EVEX, VX_RW0 )
avxins(PDPWSSD,  VPDPWSSD,  vpdpwssd,  RWF_EVEX, VX_RW0 )
avxins(PDPWSSDS, VPDPWSSDS, vpdpwssds, RWF_EVEX, VX_RW0 )


