diff options
Diffstat (limited to 'capstone/arch/X86/X86GenDisassemblerTables_reduce.inc')
| -rw-r--r-- | capstone/arch/X86/X86GenDisassemblerTables_reduce.inc | 28047 |
1 files changed, 28047 insertions, 0 deletions
diff --git a/capstone/arch/X86/X86GenDisassemblerTables_reduce.inc b/capstone/arch/X86/X86GenDisassemblerTables_reduce.inc new file mode 100644 index 000000000..4663fbeba --- /dev/null +++ b/capstone/arch/X86/X86GenDisassemblerTables_reduce.inc @@ -0,0 +1,28047 @@ +/* Capstone Disassembly Engine, http://www.capstone-engine.org */ +/* By Nguyen Anh Quynh <aquynh@gmail.com>, 2013-2019 */ + +/*===- TableGen'erated file -------------------------------------*- C++ -*-===*\ +|* *| +|* * X86 Disassembler *| +|* *| +|* Automatically generated file, do not edit! *| +|* *| +\*===----------------------------------------------------------------------===*/ + +static const struct OperandSpecifier x86OperandSets[][6] = { + { /* 0 */ + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + }, + { /* 1 */ + { ENCODING_IB, TYPE_IMM }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + }, + { /* 2 */ + { ENCODING_Iv, TYPE_IMM }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + }, + { /* 3 */ + { ENCODING_RM, TYPE_M }, + { ENCODING_Iv, TYPE_IMM }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + }, + { /* 4 */ + { ENCODING_RM, TYPE_M }, + { ENCODING_IB, TYPE_IMM }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + }, + { /* 5 */ + { ENCODING_RM, TYPE_M }, + { ENCODING_REG, TYPE_Rv }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + }, + { /* 6 */ + { ENCODING_DUP, TYPE_DUP1 }, + { ENCODING_RM, TYPE_Rv }, + { ENCODING_Iv, TYPE_IMM }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + }, + { /* 7 */ + { ENCODING_DUP, TYPE_DUP1 }, + { ENCODING_RM, TYPE_Rv }, + { ENCODING_IB, TYPE_IMM }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + }, + { /* 8 */ + { ENCODING_DUP, TYPE_DUP1 }, + { ENCODING_REG, TYPE_Rv }, + { ENCODING_RM, TYPE_M }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + }, + { /* 9 */ + { ENCODING_DUP, TYPE_DUP1 }, + { ENCODING_RM, TYPE_Rv }, + { ENCODING_REG, TYPE_Rv }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + }, + { /* 10 */ + { ENCODING_DUP, TYPE_DUP1 }, + { ENCODING_REG, TYPE_Rv }, + { ENCODING_RM, TYPE_Rv }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + }, + { /* 11 */ + { ENCODING_ID, TYPE_IMM }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + }, + { /* 12 */ + { ENCODING_RM, TYPE_M }, + { ENCODING_ID, TYPE_IMM }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + }, + { /* 13 */ + { ENCODING_RM, TYPE_M }, + { ENCODING_REG, TYPE_R64 }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + }, + { /* 14 */ + { ENCODING_DUP, TYPE_DUP1 }, + { ENCODING_RM, TYPE_R64 }, + { ENCODING_ID, TYPE_IMM }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + }, + { /* 15 */ + { ENCODING_DUP, TYPE_DUP1 }, + { ENCODING_RM, TYPE_R64 }, + { ENCODING_IB, TYPE_IMM }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + }, + { /* 16 */ + { ENCODING_DUP, TYPE_DUP1 }, + { ENCODING_REG, TYPE_R64 }, + { ENCODING_RM, TYPE_M }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + }, + { /* 17 */ + { ENCODING_DUP, TYPE_DUP1 }, + { ENCODING_RM, TYPE_R64 }, + { ENCODING_REG, TYPE_R64 }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + }, + { /* 18 */ + { ENCODING_DUP, TYPE_DUP1 }, + { ENCODING_REG, TYPE_R64 }, + { ENCODING_RM, TYPE_R64 }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + }, + { /* 19 */ + { ENCODING_RM, TYPE_M }, + { ENCODING_REG, TYPE_R8 }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + }, + { /* 20 */ + { ENCODING_DUP, TYPE_DUP1 }, + { ENCODING_RM, TYPE_R8 }, + { ENCODING_IB, TYPE_IMM }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + }, + { /* 21 */ + { ENCODING_DUP, TYPE_DUP1 }, + { ENCODING_REG, TYPE_R8 }, + { ENCODING_RM, TYPE_M }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + }, + { /* 22 */ + { ENCODING_DUP, TYPE_DUP1 }, + { ENCODING_RM, TYPE_R8 }, + { ENCODING_REG, TYPE_R8 }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + }, + { /* 23 */ + { ENCODING_DUP, TYPE_DUP1 }, + { ENCODING_REG, TYPE_R8 }, + { ENCODING_RM, TYPE_R8 }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + }, + { /* 24 */ + { ENCODING_DUP, TYPE_DUP1 }, + { ENCODING_REG, TYPE_R32 }, + { ENCODING_RM, TYPE_M }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + }, + { /* 25 */ + { ENCODING_DUP, TYPE_DUP1 }, + { ENCODING_REG, TYPE_R32 }, + { ENCODING_RM, TYPE_R32 }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + }, + { /* 26 */ + { ENCODING_REG, TYPE_R32 }, + { ENCODING_VVVV, TYPE_R32 }, + { ENCODING_RM, TYPE_M }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + }, + { /* 27 */ + { ENCODING_REG, TYPE_R32 }, + { ENCODING_VVVV, TYPE_R32 }, + { ENCODING_RM, TYPE_R32 }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + }, + { /* 28 */ + { ENCODING_REG, TYPE_R64 }, + { ENCODING_VVVV, TYPE_R64 }, + { ENCODING_RM, TYPE_M }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + }, + { /* 29 */ + { ENCODING_REG, TYPE_R64 }, + { ENCODING_VVVV, TYPE_R64 }, + { ENCODING_RM, TYPE_R64 }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + }, + { /* 30 */ + { ENCODING_RM, TYPE_M }, + { ENCODING_REG, TYPE_R16 }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + }, + { /* 31 */ + { ENCODING_RM, TYPE_R16 }, + { ENCODING_REG, TYPE_R16 }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + }, + { /* 32 */ + { ENCODING_REG, TYPE_R32 }, + { ENCODING_RM, TYPE_M }, + { ENCODING_VVVV, TYPE_R32 }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + }, + { /* 33 */ + { ENCODING_REG, TYPE_R32 }, + { ENCODING_RM, TYPE_R32 }, + { ENCODING_VVVV, TYPE_R32 }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + }, + { /* 34 */ + { ENCODING_REG, TYPE_R64 }, + { ENCODING_RM, TYPE_M }, + { ENCODING_VVVV, TYPE_R64 }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + }, + { /* 35 */ + { ENCODING_REG, TYPE_R64 }, + { ENCODING_RM, TYPE_R64 }, + { ENCODING_VVVV, TYPE_R64 }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + }, + { /* 36 */ + { ENCODING_REG, TYPE_R32 }, + { ENCODING_RM, TYPE_M }, + { ENCODING_Iv, TYPE_IMM }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + }, + { /* 37 */ + { ENCODING_REG, TYPE_R32 }, + { ENCODING_RM, TYPE_R32 }, + { ENCODING_Iv, TYPE_IMM }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + }, + { /* 38 */ + { ENCODING_REG, TYPE_R64 }, + { ENCODING_RM, TYPE_M }, + { ENCODING_ID, TYPE_IMM }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + }, + { /* 39 */ + { ENCODING_REG, TYPE_R64 }, + { ENCODING_RM, TYPE_R64 }, + { ENCODING_ID, TYPE_IMM }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + }, + { /* 40 */ + { ENCODING_VVVV, TYPE_R32 }, + { ENCODING_RM, TYPE_M }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + }, + { /* 41 */ + { ENCODING_VVVV, TYPE_R32 }, + { ENCODING_RM, TYPE_R32 }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + }, + { /* 42 */ + { ENCODING_VVVV, TYPE_R64 }, + { ENCODING_RM, TYPE_M }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + }, + { /* 43 */ + { ENCODING_VVVV, TYPE_R64 }, + { ENCODING_RM, TYPE_R64 }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + }, + { /* 44 */ + { ENCODING_REG, TYPE_Rv }, + { ENCODING_RM, TYPE_M }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + }, + { /* 45 */ + { ENCODING_REG, TYPE_Rv }, + { ENCODING_RM, TYPE_Rv }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + }, + { /* 46 */ + { ENCODING_REG, TYPE_R64 }, + { ENCODING_RM, TYPE_M }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + }, + { /* 47 */ + { ENCODING_REG, TYPE_R64 }, + { ENCODING_RM, TYPE_R64 }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + }, + { /* 48 */ + { ENCODING_DUP, TYPE_DUP1 }, + { ENCODING_Rv, TYPE_Rv }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + }, + { /* 49 */ + { ENCODING_DUP, TYPE_DUP1 }, + { ENCODING_RO, TYPE_R64 }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + }, + { /* 50 */ + { ENCODING_RM, TYPE_Rv }, + { ENCODING_IB, TYPE_IMM }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + }, + { /* 51 */ + { ENCODING_RM, TYPE_Rv }, + { ENCODING_REG, TYPE_Rv }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + }, + { /* 52 */ + { ENCODING_RM, TYPE_R64 }, + { ENCODING_IB, TYPE_IMM }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + }, + { /* 53 */ + { ENCODING_RM, TYPE_R64 }, + { ENCODING_REG, TYPE_R64 }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + }, + { /* 54 */ + { ENCODING_RM, TYPE_M }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + }, + { /* 55 */ + { ENCODING_RM, TYPE_Rv }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + }, + { /* 56 */ + { ENCODING_ID, TYPE_REL }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + }, + { /* 57 */ + { ENCODING_RM, TYPE_R64 }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + }, + { /* 58 */ + { ENCODING_IW, TYPE_REL }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + }, + { /* 59 */ + { ENCODING_RM, TYPE_Rv }, + { ENCODING_Iv, TYPE_IMM }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + }, + { /* 60 */ + { ENCODING_RM, TYPE_R64 }, + { ENCODING_ID, TYPE_IMM }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + }, + { /* 61 */ + { ENCODING_RM, TYPE_R8 }, + { ENCODING_IB, TYPE_IMM }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + }, + { /* 62 */ + { ENCODING_REG, TYPE_R8 }, + { ENCODING_RM, TYPE_M }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + }, + { /* 63 */ + { ENCODING_RM, TYPE_R8 }, + { ENCODING_REG, TYPE_R8 }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + }, + { /* 64 */ + { ENCODING_REG, TYPE_R8 }, + { ENCODING_RM, TYPE_R8 }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + }, + { /* 65 */ + { ENCODING_DI, TYPE_DSTIDX }, + { ENCODING_SI, TYPE_SRCIDX }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + }, + { /* 66 */ + { ENCODING_DUP, TYPE_DUP1 }, + { ENCODING_RM, TYPE_Rv }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + }, + { /* 67 */ + { ENCODING_DUP, TYPE_DUP1 }, + { ENCODING_RM, TYPE_R64 }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + }, + { /* 68 */ + { ENCODING_DUP, TYPE_DUP1 }, + { ENCODING_RM, TYPE_R8 }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + }, + { /* 69 */ + { ENCODING_RM, TYPE_R8 }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + }, + { /* 70 */ + { ENCODING_IW, TYPE_IMM }, + { ENCODING_IB, TYPE_IMM }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + }, + { /* 71 */ + { ENCODING_Iv, TYPE_IMM }, + { ENCODING_Iv, TYPE_IMM }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + }, + { /* 72 */ + { ENCODING_Iv, TYPE_IMM }, + { ENCODING_IW, TYPE_IMM }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + }, + { /* 73 */ + { ENCODING_REG, TYPE_Rv }, + { ENCODING_RM, TYPE_M }, + { ENCODING_Iv, TYPE_IMM }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + }, + { /* 74 */ + { ENCODING_REG, TYPE_Rv }, + { ENCODING_RM, TYPE_M }, + { ENCODING_IB, TYPE_IMM }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + }, + { /* 75 */ + { ENCODING_REG, TYPE_Rv }, + { ENCODING_RM, TYPE_Rv }, + { ENCODING_Iv, TYPE_IMM }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + }, + { /* 76 */ + { ENCODING_REG, TYPE_Rv }, + { ENCODING_RM, TYPE_Rv }, + { ENCODING_IB, TYPE_IMM }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + }, + { /* 77 */ + { ENCODING_REG, TYPE_R64 }, + { ENCODING_RM, TYPE_M }, + { ENCODING_IB, TYPE_IMM }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + }, + { /* 78 */ + { ENCODING_REG, TYPE_R64 }, + { ENCODING_RM, TYPE_R64 }, + { ENCODING_IB, TYPE_IMM }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + }, + { /* 79 */ + { ENCODING_IB, TYPE_UIMM8 }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + }, + { /* 80 */ + { ENCODING_RM, TYPE_R32 }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + }, + { /* 81 */ + { ENCODING_DI, TYPE_DSTIDX }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + }, + { /* 82 */ + { ENCODING_REG, TYPE_R32 }, + { ENCODING_RM, TYPE_M }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + }, + { /* 83 */ + { ENCODING_IB, TYPE_REL }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + }, + { /* 84 */ + { ENCODING_Iv, TYPE_REL }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + }, + { /* 85 */ + { ENCODING_REG, TYPE_R64 }, + { ENCODING_RM, TYPE_R32 }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + }, + { /* 86 */ + { ENCODING_RM, TYPE_R16 }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + }, + { /* 87 */ + { ENCODING_SI, TYPE_SRCIDX }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + }, + { /* 88 */ + { ENCODING_IW, TYPE_IMM }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + }, + { /* 89 */ + { ENCODING_VVVV, TYPE_R32 }, + { ENCODING_RM, TYPE_M }, + { ENCODING_Iv, TYPE_IMM }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + }, + { /* 90 */ + { ENCODING_VVVV, TYPE_R32 }, + { ENCODING_RM, TYPE_R32 }, + { ENCODING_Iv, TYPE_IMM }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + }, + { /* 91 */ + { ENCODING_VVVV, TYPE_R64 }, + { ENCODING_RM, TYPE_M }, + { ENCODING_Iv, TYPE_IMM }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + }, + { /* 92 */ + { ENCODING_VVVV, TYPE_R64 }, + { ENCODING_RM, TYPE_R32 }, + { ENCODING_Iv, TYPE_IMM }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + }, + { /* 93 */ + { ENCODING_Ia, TYPE_MOFFS }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + }, + { /* 94 */ + { ENCODING_RM, TYPE_M }, + { ENCODING_REG, TYPE_SEGMENTREG }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + }, + { /* 95 */ + { ENCODING_Rv, TYPE_Rv }, + { ENCODING_Iv, TYPE_IMM }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + }, + { /* 96 */ + { ENCODING_RM, TYPE_Rv }, + { ENCODING_REG, TYPE_SEGMENTREG }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + }, + { /* 97 */ + { ENCODING_REG, TYPE_SEGMENTREG }, + { ENCODING_RM, TYPE_M }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + }, + { /* 98 */ + { ENCODING_REG, TYPE_SEGMENTREG }, + { ENCODING_RM, TYPE_Rv }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + }, + { /* 99 */ + { ENCODING_REG, TYPE_CONTROLREG }, + { ENCODING_RM, TYPE_R32 }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + }, + { /* 100 */ + { ENCODING_REG, TYPE_DEBUGREG }, + { ENCODING_RM, TYPE_R32 }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + }, + { /* 101 */ + { ENCODING_RM, TYPE_R32 }, + { ENCODING_REG, TYPE_CONTROLREG }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + }, + { /* 102 */ + { ENCODING_RM, TYPE_R32 }, + { ENCODING_REG, TYPE_DEBUGREG }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + }, + { /* 103 */ + { ENCODING_REG, TYPE_CONTROLREG }, + { ENCODING_RM, TYPE_R64 }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + }, + { /* 104 */ + { ENCODING_REG, TYPE_DEBUGREG }, + { ENCODING_RM, TYPE_R64 }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + }, + { /* 105 */ + { ENCODING_RM, TYPE_R64 }, + { ENCODING_REG, TYPE_CONTROLREG }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + }, + { /* 106 */ + { ENCODING_RM, TYPE_R64 }, + { ENCODING_REG, TYPE_DEBUGREG }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + }, + { /* 107 */ + { ENCODING_RO, TYPE_R64 }, + { ENCODING_IO, TYPE_IMM }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + }, + { /* 108 */ + { ENCODING_RM, TYPE_R64 }, + { ENCODING_REG, TYPE_SEGMENTREG }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + }, + { /* 109 */ + { ENCODING_REG, TYPE_SEGMENTREG }, + { ENCODING_RM, TYPE_R64 }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + }, + { /* 110 */ + { ENCODING_RB, TYPE_R8 }, + { ENCODING_IB, TYPE_IMM }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + }, + { /* 111 */ + { ENCODING_REG, TYPE_R16 }, + { ENCODING_RM, TYPE_M }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + }, + { /* 112 */ + { ENCODING_RM, TYPE_M }, + { ENCODING_REG, TYPE_R32 }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + }, + { /* 113 */ + { ENCODING_REG, TYPE_Rv }, + { ENCODING_RM, TYPE_R8 }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + }, + { /* 114 */ + { ENCODING_REG, TYPE_Rv }, + { ENCODING_RM, TYPE_R16 }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + }, + { /* 115 */ + { ENCODING_REG, TYPE_R64 }, + { ENCODING_RM, TYPE_R16 }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + }, + { /* 116 */ + { ENCODING_REG, TYPE_R64 }, + { ENCODING_RM, TYPE_R8 }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + }, + { /* 117 */ + { ENCODING_Rv, TYPE_Rv }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + }, + { /* 118 */ + { ENCODING_RO, TYPE_R64 }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + }, + { /* 119 */ + { ENCODING_RM, TYPE_M }, + { ENCODING_IB, TYPE_UIMM8 }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + }, + { /* 120 */ + { ENCODING_DUP, TYPE_DUP1 }, + { ENCODING_RM, TYPE_Rv }, + { ENCODING_IB, TYPE_UIMM8 }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + }, + { /* 121 */ + { ENCODING_DUP, TYPE_DUP1 }, + { ENCODING_RM, TYPE_R64 }, + { ENCODING_IB, TYPE_UIMM8 }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + }, + { /* 122 */ + { ENCODING_DUP, TYPE_DUP1 }, + { ENCODING_RM, TYPE_R8 }, + { ENCODING_IB, TYPE_UIMM8 }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + }, + { /* 123 */ + { ENCODING_DUP, TYPE_DUP1 }, + { ENCODING_RM, TYPE_R32 }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + }, + { /* 124 */ + { ENCODING_REG, TYPE_R32 }, + { ENCODING_RM, TYPE_M }, + { ENCODING_IB, TYPE_UIMM8 }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + }, + { /* 125 */ + { ENCODING_REG, TYPE_R32 }, + { ENCODING_RM, TYPE_R32 }, + { ENCODING_IB, TYPE_UIMM8 }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + }, + { /* 126 */ + { ENCODING_REG, TYPE_R64 }, + { ENCODING_RM, TYPE_M }, + { ENCODING_IB, TYPE_UIMM8 }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + }, + { /* 127 */ + { ENCODING_REG, TYPE_R64 }, + { ENCODING_RM, TYPE_R64 }, + { ENCODING_IB, TYPE_UIMM8 }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + }, + { /* 128 */ + { ENCODING_RM, TYPE_M }, + { ENCODING_REG, TYPE_Rv }, + { ENCODING_IB, TYPE_UIMM8 }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + }, + { /* 129 */ + { ENCODING_DUP, TYPE_DUP1 }, + { ENCODING_RM, TYPE_Rv }, + { ENCODING_REG, TYPE_Rv }, + { ENCODING_IB, TYPE_UIMM8 }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + }, + { /* 130 */ + { ENCODING_RM, TYPE_M }, + { ENCODING_REG, TYPE_R64 }, + { ENCODING_IB, TYPE_UIMM8 }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + }, + { /* 131 */ + { ENCODING_DUP, TYPE_DUP1 }, + { ENCODING_RM, TYPE_R64 }, + { ENCODING_REG, TYPE_R64 }, + { ENCODING_IB, TYPE_UIMM8 }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + }, + { /* 132 */ + { ENCODING_RM, TYPE_R32 }, + { ENCODING_REG, TYPE_R32 }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + }, + { /* 133 */ + { ENCODING_REG, TYPE_R32 }, + { ENCODING_RM, TYPE_R32 }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + }, + { /* 134 */ + { ENCODING_DUP, TYPE_DUP2 }, + { ENCODING_DUP, TYPE_DUP3 }, + { ENCODING_RM, TYPE_Rv }, + { ENCODING_REG, TYPE_Rv }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + }, + { /* 135 */ + { ENCODING_DUP, TYPE_DUP2 }, + { ENCODING_DUP, TYPE_DUP3 }, + { ENCODING_RM, TYPE_R64 }, + { ENCODING_REG, TYPE_R64 }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + }, + { /* 136 */ + { ENCODING_DUP, TYPE_DUP2 }, + { ENCODING_DUP, TYPE_DUP3 }, + { ENCODING_RM, TYPE_R8 }, + { ENCODING_REG, TYPE_R8 }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + }, + { /* 137 */ + { ENCODING_DUP, TYPE_DUP2 }, + { ENCODING_DUP, TYPE_DUP3 }, + { ENCODING_REG, TYPE_Rv }, + { ENCODING_RM, TYPE_Rv }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + }, + { /* 138 */ + { ENCODING_DUP, TYPE_DUP2 }, + { ENCODING_DUP, TYPE_DUP3 }, + { ENCODING_REG, TYPE_R64 }, + { ENCODING_RM, TYPE_R64 }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + }, + { /* 139 */ + { ENCODING_DUP, TYPE_DUP2 }, + { ENCODING_DUP, TYPE_DUP3 }, + { ENCODING_REG, TYPE_R8 }, + { ENCODING_RM, TYPE_R8 }, + { ENCODING_NONE, TYPE_NONE }, + { ENCODING_NONE, TYPE_NONE }, + }, +}; + +static const struct InstructionSpecifier x86DisassemblerInstrSpecifiers[1671] = { + { /* 0 */ + 0, + /* */ + }, + { /* 1 */ + 0, + /* */ + }, + { /* 2 */ + 0, + /* */ + }, + { /* 3 */ + 0, + /* */ + }, + { /* 4 */ + 0, + /* */ + }, + { /* 5 */ + 0, + /* */ + }, + { /* 6 */ + 0, + /* */ + }, + { /* 7 */ + 0, + /* */ + }, + { /* 8 */ + 0, + /* */ + }, + { /* 9 */ + 0, + /* */ + }, + { /* 10 */ + 0, + /* */ + }, + { /* 11 */ + 0, + /* */ + }, + { /* 12 */ + 0, + /* */ + }, + { /* 13 */ + 0, + /* */ + }, + { /* 14 */ + 0, + /* */ + }, + { /* 15 */ + 0, + /* */ + }, + { /* 16 */ + 0, + /* */ + }, + { /* 17 */ + 0, + /* */ + }, + { /* 18 */ + 0, + /* */ + }, + { /* 19 */ + 0, + /* */ + }, + { /* 20 */ + 0, + /* */ + }, + { /* 21 */ + 0, + /* */ + }, + { /* 22 */ + 0, + /* */ + }, + { /* 23 */ + 0, + /* */ + }, + { /* 24 */ + 0, + /* */ + }, + { /* 25 */ + 0, + /* */ + }, + { /* 26 */ + 0, + /* */ + }, + { /* 27 */ + 0, + /* */ + }, + { /* 28 */ + 0, + /* */ + }, + { /* 29 */ + 0, + /* */ + }, + { /* 30 */ + 0, + /* */ + }, + { /* 31 */ + 0, + /* */ + }, + { /* 32 */ + 0, + /* */ + }, + { /* 33 */ + 0, + /* */ + }, + { /* 34 */ + 0, + /* */ + }, + { /* 35 */ + 0, + /* */ + }, + { /* 36 */ + 0, + /* */ + }, + { /* 37 */ + 0, + /* */ + }, + { /* 38 */ + 0, + /* */ + }, + { /* 39 */ + 0, + /* */ + }, + { /* 40 */ + 0, + /* */ + }, + { /* 41 */ + 0, + /* */ + }, + { /* 42 */ + 0, + /* */ + }, + { /* 43 */ + 0, + /* */ + }, + { /* 44 */ + 0, + /* */ + }, + { /* 45 */ + 0, + /* */ + }, + { /* 46 */ + 0, + /* */ + }, + { /* 47 */ + 0, + /* */ + }, + { /* 48 */ + 0, + /* */ + }, + { /* 49 */ + 0, + /* */ + }, + { /* 50 */ + 0, + /* */ + }, + { /* 51 */ + 0, + /* */ + }, + { /* 52 */ + 0, + /* */ + }, + { /* 53 */ + 0, + /* */ + }, + { /* 54 */ + 0, + /* */ + }, + { /* 55 */ + 0, + /* */ + }, + { /* 56 */ + 0, + /* */ + }, + { /* 57 */ + 0, + /* */ + }, + { /* 58 */ + 0, + /* */ + }, + { /* 59 */ + 0, + /* */ + }, + { /* 60 */ + 0, + /* */ + }, + { /* 61 */ + 0, + /* */ + }, + { /* 62 */ + 0, + /* */ + }, + { /* 63 */ + 0, + /* */ + }, + { /* 64 */ + 0, + /* */ + }, + { /* 65 */ + 0, + /* */ + }, + { /* 66 */ + 0, + /* */ + }, + { /* 67 */ + 0, + /* */ + }, + { /* 68 */ + 0, + /* */ + }, + { /* 69 */ + 0, + /* */ + }, + { /* 70 */ + 0, + /* */ + }, + { /* 71 */ + 0, + /* */ + }, + { /* 72 */ + 0, + /* */ + }, + { /* 73 */ + 0, + /* */ + }, + { /* 74 */ + 0, + /* */ + }, + { /* 75 */ + 0, + /* */ + }, + { /* 76 */ + 0, + /* */ + }, + { /* 77 */ + 0, + /* */ + }, + { /* 78 */ + 0, + /* */ + }, + { /* 79 */ + 0, + /* */ + }, + { /* 80 */ + 0, + /* */ + }, + { /* 81 */ + 0, + /* */ + }, + { /* 82 */ + 0, + /* */ + }, + { /* 83 */ + 0, + /* */ + }, + { /* 84 */ + 0, + /* */ + }, + { /* 85 */ + 0, + /* */ + }, + { /* 86 */ + 0, + /* */ + }, + { /* 87 */ + 0, + /* */ + }, + { /* 88 */ + 0, + /* */ + }, + { /* 89 */ + 0, + /* */ + }, + { /* 90 */ + 0, + /* */ + }, + { /* 91 */ + 0, + /* */ + }, + { /* 92 */ + 0, + /* */ + }, + { /* 93 */ + 0, + /* */ + }, + { /* 94 */ + 0, + /* */ + }, + { /* 95 */ + 0, + /* */ + }, + { /* 96 */ + 0, + /* */ + }, + { /* 97 */ + 0, + /* */ + }, + { /* 98 */ + 0, + /* */ + }, + { /* 99 */ + 0, + /* */ + }, + { /* 100 */ + 0, + /* */ + }, + { /* 101 */ + 0, + /* */ + }, + { /* 102 */ + 0, + /* */ + }, + { /* 103 */ + 0, + /* */ + }, + { /* 104 */ + 0, + /* */ + }, + { /* 105 */ + 0, + /* */ + }, + { /* 106 */ + 0, + /* */ + }, + { /* 107 */ + 0, + /* */ + }, + { /* 108 */ + 0, + /* */ + }, + { /* 109 */ + 0, + /* */ + }, + { /* 110 */ + 0, + /* */ + }, + { /* 111 */ + 0, + /* */ + }, + { /* 112 */ + 0, + /* */ + }, + { /* 113 */ + 0, + /* */ + }, + { /* 114 */ + 0, + /* */ + }, + { /* 115 */ + 0, + /* */ + }, + { /* 116 */ + 0, + /* */ + }, + { /* 117 */ + 0, + /* */ + }, + { /* 118 */ + 0, + /* */ + }, + { /* 119 */ + 0, + /* */ + }, + { /* 120 */ + 0, + /* */ + }, + { /* 121 */ + 0, + /* */ + }, + { /* 122 */ + 0, + /* */ + }, + { /* 123 */ + 0, + /* */ + }, + { /* 124 */ + 0, + /* */ + }, + { /* 125 */ + 0, + /* */ + }, + { /* 126 */ + 0, + /* AAA */ + }, + { /* 127 */ + 1, + /* AAD8i8 */ + }, + { /* 128 */ + 1, + /* AAM8i8 */ + }, + { /* 129 */ + 0, + /* AAS */ + }, + { /* 130 */ + 2, + /* ADC16i16 */ + }, + { /* 131 */ + 3, + /* ADC16mi */ + }, + { /* 132 */ + 4, + /* ADC16mi8 */ + }, + { /* 133 */ + 5, + /* ADC16mr */ + }, + { /* 134 */ + 6, + /* ADC16ri */ + }, + { /* 135 */ + 7, + /* ADC16ri8 */ + }, + { /* 136 */ + 8, + /* ADC16rm */ + }, + { /* 137 */ + 9, + /* ADC16rr */ + }, + { /* 138 */ + 10, + /* ADC16rr_REV */ + }, + { /* 139 */ + 2, + /* ADC32i32 */ + }, + { /* 140 */ + 3, + /* ADC32mi */ + }, + { /* 141 */ + 4, + /* ADC32mi8 */ + }, + { /* 142 */ + 5, + /* ADC32mr */ + }, + { /* 143 */ + 6, + /* ADC32ri */ + }, + { /* 144 */ + 7, + /* ADC32ri8 */ + }, + { /* 145 */ + 8, + /* ADC32rm */ + }, + { /* 146 */ + 9, + /* ADC32rr */ + }, + { /* 147 */ + 10, + /* ADC32rr_REV */ + }, + { /* 148 */ + 11, + /* ADC64i32 */ + }, + { /* 149 */ + 12, + /* ADC64mi32 */ + }, + { /* 150 */ + 4, + /* ADC64mi8 */ + }, + { /* 151 */ + 13, + /* ADC64mr */ + }, + { /* 152 */ + 14, + /* ADC64ri32 */ + }, + { /* 153 */ + 15, + /* ADC64ri8 */ + }, + { /* 154 */ + 16, + /* ADC64rm */ + }, + { /* 155 */ + 17, + /* ADC64rr */ + }, + { /* 156 */ + 18, + /* ADC64rr_REV */ + }, + { /* 157 */ + 1, + /* ADC8i8 */ + }, + { /* 158 */ + 4, + /* ADC8mi */ + }, + { /* 159 */ + 4, + /* ADC8mi8 */ + }, + { /* 160 */ + 19, + /* ADC8mr */ + }, + { /* 161 */ + 20, + /* ADC8ri */ + }, + { /* 162 */ + 20, + /* ADC8ri8 */ + }, + { /* 163 */ + 21, + /* ADC8rm */ + }, + { /* 164 */ + 22, + /* ADC8rr */ + }, + { /* 165 */ + 23, + /* ADC8rr_REV */ + }, + { /* 166 */ + 24, + /* ADCX32rm */ + }, + { /* 167 */ + 25, + /* ADCX32rr */ + }, + { /* 168 */ + 16, + /* ADCX64rm */ + }, + { /* 169 */ + 18, + /* ADCX64rr */ + }, + { /* 170 */ + 2, + /* ADD16i16 */ + }, + { /* 171 */ + 3, + /* ADD16mi */ + }, + { /* 172 */ + 4, + /* ADD16mi8 */ + }, + { /* 173 */ + 5, + /* ADD16mr */ + }, + { /* 174 */ + 6, + /* ADD16ri */ + }, + { /* 175 */ + 7, + /* ADD16ri8 */ + }, + { /* 176 */ + 8, + /* ADD16rm */ + }, + { /* 177 */ + 9, + /* ADD16rr */ + }, + { /* 178 */ + 10, + /* ADD16rr_REV */ + }, + { /* 179 */ + 2, + /* ADD32i32 */ + }, + { /* 180 */ + 3, + /* ADD32mi */ + }, + { /* 181 */ + 4, + /* ADD32mi8 */ + }, + { /* 182 */ + 5, + /* ADD32mr */ + }, + { /* 183 */ + 6, + /* ADD32ri */ + }, + { /* 184 */ + 7, + /* ADD32ri8 */ + }, + { /* 185 */ + 8, + /* ADD32rm */ + }, + { /* 186 */ + 9, + /* ADD32rr */ + }, + { /* 187 */ + 10, + /* ADD32rr_REV */ + }, + { /* 188 */ + 11, + /* ADD64i32 */ + }, + { /* 189 */ + 12, + /* ADD64mi32 */ + }, + { /* 190 */ + 4, + /* ADD64mi8 */ + }, + { /* 191 */ + 13, + /* ADD64mr */ + }, + { /* 192 */ + 14, + /* ADD64ri32 */ + }, + { /* 193 */ + 15, + /* ADD64ri8 */ + }, + { /* 194 */ + 16, + /* ADD64rm */ + }, + { /* 195 */ + 17, + /* ADD64rr */ + }, + { /* 196 */ + 18, + /* ADD64rr_REV */ + }, + { /* 197 */ + 1, + /* ADD8i8 */ + }, + { /* 198 */ + 4, + /* ADD8mi */ + }, + { /* 199 */ + 4, + /* ADD8mi8 */ + }, + { /* 200 */ + 19, + /* ADD8mr */ + }, + { /* 201 */ + 20, + /* ADD8ri */ + }, + { /* 202 */ + 20, + /* ADD8ri8 */ + }, + { /* 203 */ + 21, + /* ADD8rm */ + }, + { /* 204 */ + 22, + /* ADD8rr */ + }, + { /* 205 */ + 23, + /* ADD8rr_REV */ + }, + { /* 206 */ + 24, + /* ADOX32rm */ + }, + { /* 207 */ + 25, + /* ADOX32rr */ + }, + { /* 208 */ + 16, + /* ADOX64rm */ + }, + { /* 209 */ + 18, + /* ADOX64rr */ + }, + { /* 210 */ + 2, + /* AND16i16 */ + }, + { /* 211 */ + 3, + /* AND16mi */ + }, + { /* 212 */ + 4, + /* AND16mi8 */ + }, + { /* 213 */ + 5, + /* AND16mr */ + }, + { /* 214 */ + 6, + /* AND16ri */ + }, + { /* 215 */ + 7, + /* AND16ri8 */ + }, + { /* 216 */ + 8, + /* AND16rm */ + }, + { /* 217 */ + 9, + /* AND16rr */ + }, + { /* 218 */ + 10, + /* AND16rr_REV */ + }, + { /* 219 */ + 2, + /* AND32i32 */ + }, + { /* 220 */ + 3, + /* AND32mi */ + }, + { /* 221 */ + 4, + /* AND32mi8 */ + }, + { /* 222 */ + 5, + /* AND32mr */ + }, + { /* 223 */ + 6, + /* AND32ri */ + }, + { /* 224 */ + 7, + /* AND32ri8 */ + }, + { /* 225 */ + 8, + /* AND32rm */ + }, + { /* 226 */ + 9, + /* AND32rr */ + }, + { /* 227 */ + 10, + /* AND32rr_REV */ + }, + { /* 228 */ + 11, + /* AND64i32 */ + }, + { /* 229 */ + 12, + /* AND64mi32 */ + }, + { /* 230 */ + 4, + /* AND64mi8 */ + }, + { /* 231 */ + 13, + /* AND64mr */ + }, + { /* 232 */ + 14, + /* AND64ri32 */ + }, + { /* 233 */ + 15, + /* AND64ri8 */ + }, + { /* 234 */ + 16, + /* AND64rm */ + }, + { /* 235 */ + 17, + /* AND64rr */ + }, + { /* 236 */ + 18, + /* AND64rr_REV */ + }, + { /* 237 */ + 1, + /* AND8i8 */ + }, + { /* 238 */ + 4, + /* AND8mi */ + }, + { /* 239 */ + 4, + /* AND8mi8 */ + }, + { /* 240 */ + 19, + /* AND8mr */ + }, + { /* 241 */ + 20, + /* AND8ri */ + }, + { /* 242 */ + 20, + /* AND8ri8 */ + }, + { /* 243 */ + 21, + /* AND8rm */ + }, + { /* 244 */ + 22, + /* AND8rr */ + }, + { /* 245 */ + 23, + /* AND8rr_REV */ + }, + { /* 246 */ + 26, + /* ANDN32rm */ + }, + { /* 247 */ + 27, + /* ANDN32rr */ + }, + { /* 248 */ + 28, + /* ANDN64rm */ + }, + { /* 249 */ + 29, + /* ANDN64rr */ + }, + { /* 250 */ + 30, + /* ARPL16mr */ + }, + { /* 251 */ + 31, + /* ARPL16rr */ + }, + { /* 252 */ + 32, + /* BEXTR32rm */ + }, + { /* 253 */ + 33, + /* BEXTR32rr */ + }, + { /* 254 */ + 34, + /* BEXTR64rm */ + }, + { /* 255 */ + 35, + /* BEXTR64rr */ + }, + { /* 256 */ + 36, + /* BEXTRI32mi */ + }, + { /* 257 */ + 37, + /* BEXTRI32ri */ + }, + { /* 258 */ + 38, + /* BEXTRI64mi */ + }, + { /* 259 */ + 39, + /* BEXTRI64ri */ + }, + { /* 260 */ + 40, + /* BLCFILL32rm */ + }, + { /* 261 */ + 41, + /* BLCFILL32rr */ + }, + { /* 262 */ + 42, + /* BLCFILL64rm */ + }, + { /* 263 */ + 43, + /* BLCFILL64rr */ + }, + { /* 264 */ + 40, + /* BLCI32rm */ + }, + { /* 265 */ + 41, + /* BLCI32rr */ + }, + { /* 266 */ + 42, + /* BLCI64rm */ + }, + { /* 267 */ + 43, + /* BLCI64rr */ + }, + { /* 268 */ + 40, + /* BLCIC32rm */ + }, + { /* 269 */ + 41, + /* BLCIC32rr */ + }, + { /* 270 */ + 42, + /* BLCIC64rm */ + }, + { /* 271 */ + 43, + /* BLCIC64rr */ + }, + { /* 272 */ + 40, + /* BLCMSK32rm */ + }, + { /* 273 */ + 41, + /* BLCMSK32rr */ + }, + { /* 274 */ + 42, + /* BLCMSK64rm */ + }, + { /* 275 */ + 43, + /* BLCMSK64rr */ + }, + { /* 276 */ + 40, + /* BLCS32rm */ + }, + { /* 277 */ + 41, + /* BLCS32rr */ + }, + { /* 278 */ + 42, + /* BLCS64rm */ + }, + { /* 279 */ + 43, + /* BLCS64rr */ + }, + { /* 280 */ + 40, + /* BLSFILL32rm */ + }, + { /* 281 */ + 41, + /* BLSFILL32rr */ + }, + { /* 282 */ + 42, + /* BLSFILL64rm */ + }, + { /* 283 */ + 43, + /* BLSFILL64rr */ + }, + { /* 284 */ + 40, + /* BLSI32rm */ + }, + { /* 285 */ + 41, + /* BLSI32rr */ + }, + { /* 286 */ + 42, + /* BLSI64rm */ + }, + { /* 287 */ + 43, + /* BLSI64rr */ + }, + { /* 288 */ + 40, + /* BLSIC32rm */ + }, + { /* 289 */ + 41, + /* BLSIC32rr */ + }, + { /* 290 */ + 42, + /* BLSIC64rm */ + }, + { /* 291 */ + 43, + /* BLSIC64rr */ + }, + { /* 292 */ + 40, + /* BLSMSK32rm */ + }, + { /* 293 */ + 41, + /* BLSMSK32rr */ + }, + { /* 294 */ + 42, + /* BLSMSK64rm */ + }, + { /* 295 */ + 43, + /* BLSMSK64rr */ + }, + { /* 296 */ + 40, + /* BLSR32rm */ + }, + { /* 297 */ + 41, + /* BLSR32rr */ + }, + { /* 298 */ + 42, + /* BLSR64rm */ + }, + { /* 299 */ + 43, + /* BLSR64rr */ + }, + { /* 300 */ + 44, + /* BOUNDS16rm */ + }, + { /* 301 */ + 44, + /* BOUNDS32rm */ + }, + { /* 302 */ + 44, + /* BSF16rm */ + }, + { /* 303 */ + 45, + /* BSF16rr */ + }, + { /* 304 */ + 44, + /* BSF32rm */ + }, + { /* 305 */ + 45, + /* BSF32rr */ + }, + { /* 306 */ + 46, + /* BSF64rm */ + }, + { /* 307 */ + 47, + /* BSF64rr */ + }, + { /* 308 */ + 44, + /* BSR16rm */ + }, + { /* 309 */ + 45, + /* BSR16rr */ + }, + { /* 310 */ + 44, + /* BSR32rm */ + }, + { /* 311 */ + 45, + /* BSR32rr */ + }, + { /* 312 */ + 46, + /* BSR64rm */ + }, + { /* 313 */ + 47, + /* BSR64rr */ + }, + { /* 314 */ + 48, + /* BSWAP16r_BAD */ + }, + { /* 315 */ + 48, + /* BSWAP32r */ + }, + { /* 316 */ + 49, + /* BSWAP64r */ + }, + { /* 317 */ + 4, + /* BT16mi8 */ + }, + { /* 318 */ + 5, + /* BT16mr */ + }, + { /* 319 */ + 50, + /* BT16ri8 */ + }, + { /* 320 */ + 51, + /* BT16rr */ + }, + { /* 321 */ + 4, + /* BT32mi8 */ + }, + { /* 322 */ + 5, + /* BT32mr */ + }, + { /* 323 */ + 50, + /* BT32ri8 */ + }, + { /* 324 */ + 51, + /* BT32rr */ + }, + { /* 325 */ + 4, + /* BT64mi8 */ + }, + { /* 326 */ + 13, + /* BT64mr */ + }, + { /* 327 */ + 52, + /* BT64ri8 */ + }, + { /* 328 */ + 53, + /* BT64rr */ + }, + { /* 329 */ + 4, + /* BTC16mi8 */ + }, + { /* 330 */ + 5, + /* BTC16mr */ + }, + { /* 331 */ + 7, + /* BTC16ri8 */ + }, + { /* 332 */ + 9, + /* BTC16rr */ + }, + { /* 333 */ + 4, + /* BTC32mi8 */ + }, + { /* 334 */ + 5, + /* BTC32mr */ + }, + { /* 335 */ + 7, + /* BTC32ri8 */ + }, + { /* 336 */ + 9, + /* BTC32rr */ + }, + { /* 337 */ + 4, + /* BTC64mi8 */ + }, + { /* 338 */ + 13, + /* BTC64mr */ + }, + { /* 339 */ + 15, + /* BTC64ri8 */ + }, + { /* 340 */ + 17, + /* BTC64rr */ + }, + { /* 341 */ + 4, + /* BTR16mi8 */ + }, + { /* 342 */ + 5, + /* BTR16mr */ + }, + { /* 343 */ + 7, + /* BTR16ri8 */ + }, + { /* 344 */ + 9, + /* BTR16rr */ + }, + { /* 345 */ + 4, + /* BTR32mi8 */ + }, + { /* 346 */ + 5, + /* BTR32mr */ + }, + { /* 347 */ + 7, + /* BTR32ri8 */ + }, + { /* 348 */ + 9, + /* BTR32rr */ + }, + { /* 349 */ + 4, + /* BTR64mi8 */ + }, + { /* 350 */ + 13, + /* BTR64mr */ + }, + { /* 351 */ + 15, + /* BTR64ri8 */ + }, + { /* 352 */ + 17, + /* BTR64rr */ + }, + { /* 353 */ + 4, + /* BTS16mi8 */ + }, + { /* 354 */ + 5, + /* BTS16mr */ + }, + { /* 355 */ + 7, + /* BTS16ri8 */ + }, + { /* 356 */ + 9, + /* BTS16rr */ + }, + { /* 357 */ + 4, + /* BTS32mi8 */ + }, + { /* 358 */ + 5, + /* BTS32mr */ + }, + { /* 359 */ + 7, + /* BTS32ri8 */ + }, + { /* 360 */ + 9, + /* BTS32rr */ + }, + { /* 361 */ + 4, + /* BTS64mi8 */ + }, + { /* 362 */ + 13, + /* BTS64mr */ + }, + { /* 363 */ + 15, + /* BTS64ri8 */ + }, + { /* 364 */ + 17, + /* BTS64rr */ + }, + { /* 365 */ + 32, + /* BZHI32rm */ + }, + { /* 366 */ + 33, + /* BZHI32rr */ + }, + { /* 367 */ + 34, + /* BZHI64rm */ + }, + { /* 368 */ + 35, + /* BZHI64rr */ + }, + { /* 369 */ + 54, + /* CALL16m */ + }, + { /* 370 */ + 0, + /* */ + }, + { /* 371 */ + 55, + /* CALL16r */ + }, + { /* 372 */ + 0, + /* */ + }, + { /* 373 */ + 54, + /* CALL32m */ + }, + { /* 374 */ + 0, + /* */ + }, + { /* 375 */ + 55, + /* CALL32r */ + }, + { /* 376 */ + 0, + /* */ + }, + { /* 377 */ + 54, + /* CALL64m */ + }, + { /* 378 */ + 0, + /* */ + }, + { /* 379 */ + 56, + /* CALL64pcrel32 */ + }, + { /* 380 */ + 57, + /* CALL64r */ + }, + { /* 381 */ + 0, + /* */ + }, + { /* 382 */ + 58, + /* CALLpcrel16 */ + }, + { /* 383 */ + 56, + /* CALLpcrel32 */ + }, + { /* 384 */ + 0, + /* CBW */ + }, + { /* 385 */ + 0, + /* CDQ */ + }, + { /* 386 */ + 0, + /* CDQE */ + }, + { /* 387 */ + 0, + /* CLAC */ + }, + { /* 388 */ + 0, + /* CLC */ + }, + { /* 389 */ + 0, + /* CLD */ + }, + { /* 390 */ + 54, + /* CLDEMOTE */ + }, + { /* 391 */ + 54, + /* CLFLUSHOPT */ + }, + { /* 392 */ + 0, + /* CLGI */ + }, + { /* 393 */ + 0, + /* CLI */ + }, + { /* 394 */ + 54, + /* CLRSSBSY */ + }, + { /* 395 */ + 0, + /* CLTS */ + }, + { /* 396 */ + 54, + /* CLWB */ + }, + { /* 397 */ + 0, + /* CLZEROr */ + }, + { /* 398 */ + 0, + /* CMC */ + }, + { /* 399 */ + 8, + /* CMOVA16rm */ + }, + { /* 400 */ + 10, + /* CMOVA16rr */ + }, + { /* 401 */ + 8, + /* CMOVA32rm */ + }, + { /* 402 */ + 10, + /* CMOVA32rr */ + }, + { /* 403 */ + 16, + /* CMOVA64rm */ + }, + { /* 404 */ + 18, + /* CMOVA64rr */ + }, + { /* 405 */ + 8, + /* CMOVAE16rm */ + }, + { /* 406 */ + 10, + /* CMOVAE16rr */ + }, + { /* 407 */ + 8, + /* CMOVAE32rm */ + }, + { /* 408 */ + 10, + /* CMOVAE32rr */ + }, + { /* 409 */ + 16, + /* CMOVAE64rm */ + }, + { /* 410 */ + 18, + /* CMOVAE64rr */ + }, + { /* 411 */ + 8, + /* CMOVB16rm */ + }, + { /* 412 */ + 10, + /* CMOVB16rr */ + }, + { /* 413 */ + 8, + /* CMOVB32rm */ + }, + { /* 414 */ + 10, + /* CMOVB32rr */ + }, + { /* 415 */ + 16, + /* CMOVB64rm */ + }, + { /* 416 */ + 18, + /* CMOVB64rr */ + }, + { /* 417 */ + 8, + /* CMOVBE16rm */ + }, + { /* 418 */ + 10, + /* CMOVBE16rr */ + }, + { /* 419 */ + 8, + /* CMOVBE32rm */ + }, + { /* 420 */ + 10, + /* CMOVBE32rr */ + }, + { /* 421 */ + 16, + /* CMOVBE64rm */ + }, + { /* 422 */ + 18, + /* CMOVBE64rr */ + }, + { /* 423 */ + 8, + /* CMOVE16rm */ + }, + { /* 424 */ + 10, + /* CMOVE16rr */ + }, + { /* 425 */ + 8, + /* CMOVE32rm */ + }, + { /* 426 */ + 10, + /* CMOVE32rr */ + }, + { /* 427 */ + 16, + /* CMOVE64rm */ + }, + { /* 428 */ + 18, + /* CMOVE64rr */ + }, + { /* 429 */ + 8, + /* CMOVG16rm */ + }, + { /* 430 */ + 10, + /* CMOVG16rr */ + }, + { /* 431 */ + 8, + /* CMOVG32rm */ + }, + { /* 432 */ + 10, + /* CMOVG32rr */ + }, + { /* 433 */ + 16, + /* CMOVG64rm */ + }, + { /* 434 */ + 18, + /* CMOVG64rr */ + }, + { /* 435 */ + 8, + /* CMOVGE16rm */ + }, + { /* 436 */ + 10, + /* CMOVGE16rr */ + }, + { /* 437 */ + 8, + /* CMOVGE32rm */ + }, + { /* 438 */ + 10, + /* CMOVGE32rr */ + }, + { /* 439 */ + 16, + /* CMOVGE64rm */ + }, + { /* 440 */ + 18, + /* CMOVGE64rr */ + }, + { /* 441 */ + 8, + /* CMOVL16rm */ + }, + { /* 442 */ + 10, + /* CMOVL16rr */ + }, + { /* 443 */ + 8, + /* CMOVL32rm */ + }, + { /* 444 */ + 10, + /* CMOVL32rr */ + }, + { /* 445 */ + 16, + /* CMOVL64rm */ + }, + { /* 446 */ + 18, + /* CMOVL64rr */ + }, + { /* 447 */ + 8, + /* CMOVLE16rm */ + }, + { /* 448 */ + 10, + /* CMOVLE16rr */ + }, + { /* 449 */ + 8, + /* CMOVLE32rm */ + }, + { /* 450 */ + 10, + /* CMOVLE32rr */ + }, + { /* 451 */ + 16, + /* CMOVLE64rm */ + }, + { /* 452 */ + 18, + /* CMOVLE64rr */ + }, + { /* 453 */ + 8, + /* CMOVNE16rm */ + }, + { /* 454 */ + 10, + /* CMOVNE16rr */ + }, + { /* 455 */ + 8, + /* CMOVNE32rm */ + }, + { /* 456 */ + 10, + /* CMOVNE32rr */ + }, + { /* 457 */ + 16, + /* CMOVNE64rm */ + }, + { /* 458 */ + 18, + /* CMOVNE64rr */ + }, + { /* 459 */ + 8, + /* CMOVNO16rm */ + }, + { /* 460 */ + 10, + /* CMOVNO16rr */ + }, + { /* 461 */ + 8, + /* CMOVNO32rm */ + }, + { /* 462 */ + 10, + /* CMOVNO32rr */ + }, + { /* 463 */ + 16, + /* CMOVNO64rm */ + }, + { /* 464 */ + 18, + /* CMOVNO64rr */ + }, + { /* 465 */ + 8, + /* CMOVNP16rm */ + }, + { /* 466 */ + 10, + /* CMOVNP16rr */ + }, + { /* 467 */ + 8, + /* CMOVNP32rm */ + }, + { /* 468 */ + 10, + /* CMOVNP32rr */ + }, + { /* 469 */ + 16, + /* CMOVNP64rm */ + }, + { /* 470 */ + 18, + /* CMOVNP64rr */ + }, + { /* 471 */ + 8, + /* CMOVNS16rm */ + }, + { /* 472 */ + 10, + /* CMOVNS16rr */ + }, + { /* 473 */ + 8, + /* CMOVNS32rm */ + }, + { /* 474 */ + 10, + /* CMOVNS32rr */ + }, + { /* 475 */ + 16, + /* CMOVNS64rm */ + }, + { /* 476 */ + 18, + /* CMOVNS64rr */ + }, + { /* 477 */ + 8, + /* CMOVO16rm */ + }, + { /* 478 */ + 10, + /* CMOVO16rr */ + }, + { /* 479 */ + 8, + /* CMOVO32rm */ + }, + { /* 480 */ + 10, + /* CMOVO32rr */ + }, + { /* 481 */ + 16, + /* CMOVO64rm */ + }, + { /* 482 */ + 18, + /* CMOVO64rr */ + }, + { /* 483 */ + 8, + /* CMOVP16rm */ + }, + { /* 484 */ + 10, + /* CMOVP16rr */ + }, + { /* 485 */ + 8, + /* CMOVP32rm */ + }, + { /* 486 */ + 10, + /* CMOVP32rr */ + }, + { /* 487 */ + 16, + /* CMOVP64rm */ + }, + { /* 488 */ + 18, + /* CMOVP64rr */ + }, + { /* 489 */ + 8, + /* CMOVS16rm */ + }, + { /* 490 */ + 10, + /* CMOVS16rr */ + }, + { /* 491 */ + 8, + /* CMOVS32rm */ + }, + { /* 492 */ + 10, + /* CMOVS32rr */ + }, + { /* 493 */ + 16, + /* CMOVS64rm */ + }, + { /* 494 */ + 18, + /* CMOVS64rr */ + }, + { /* 495 */ + 2, + /* CMP16i16 */ + }, + { /* 496 */ + 3, + /* CMP16mi */ + }, + { /* 497 */ + 4, + /* CMP16mi8 */ + }, + { /* 498 */ + 5, + /* CMP16mr */ + }, + { /* 499 */ + 59, + /* CMP16ri */ + }, + { /* 500 */ + 50, + /* CMP16ri8 */ + }, + { /* 501 */ + 44, + /* CMP16rm */ + }, + { /* 502 */ + 51, + /* CMP16rr */ + }, + { /* 503 */ + 45, + /* CMP16rr_REV */ + }, + { /* 504 */ + 2, + /* CMP32i32 */ + }, + { /* 505 */ + 3, + /* CMP32mi */ + }, + { /* 506 */ + 4, + /* CMP32mi8 */ + }, + { /* 507 */ + 5, + /* CMP32mr */ + }, + { /* 508 */ + 59, + /* CMP32ri */ + }, + { /* 509 */ + 50, + /* CMP32ri8 */ + }, + { /* 510 */ + 44, + /* CMP32rm */ + }, + { /* 511 */ + 51, + /* CMP32rr */ + }, + { /* 512 */ + 45, + /* CMP32rr_REV */ + }, + { /* 513 */ + 11, + /* CMP64i32 */ + }, + { /* 514 */ + 12, + /* CMP64mi32 */ + }, + { /* 515 */ + 4, + /* CMP64mi8 */ + }, + { /* 516 */ + 13, + /* CMP64mr */ + }, + { /* 517 */ + 60, + /* CMP64ri32 */ + }, + { /* 518 */ + 52, + /* CMP64ri8 */ + }, + { /* 519 */ + 46, + /* CMP64rm */ + }, + { /* 520 */ + 53, + /* CMP64rr */ + }, + { /* 521 */ + 47, + /* CMP64rr_REV */ + }, + { /* 522 */ + 1, + /* CMP8i8 */ + }, + { /* 523 */ + 4, + /* CMP8mi */ + }, + { /* 524 */ + 4, + /* CMP8mi8 */ + }, + { /* 525 */ + 19, + /* CMP8mr */ + }, + { /* 526 */ + 61, + /* CMP8ri */ + }, + { /* 527 */ + 61, + /* CMP8ri8 */ + }, + { /* 528 */ + 62, + /* CMP8rm */ + }, + { /* 529 */ + 63, + /* CMP8rr */ + }, + { /* 530 */ + 64, + /* CMP8rr_REV */ + }, + { /* 531 */ + 65, + /* CMPSB */ + }, + { /* 532 */ + 65, + /* CMPSL */ + }, + { /* 533 */ + 65, + /* CMPSQ */ + }, + { /* 534 */ + 65, + /* CMPSW */ + }, + { /* 535 */ + 54, + /* CMPXCHG16B */ + }, + { /* 536 */ + 5, + /* CMPXCHG16rm */ + }, + { /* 537 */ + 51, + /* CMPXCHG16rr */ + }, + { /* 538 */ + 5, + /* CMPXCHG32rm */ + }, + { /* 539 */ + 51, + /* CMPXCHG32rr */ + }, + { /* 540 */ + 13, + /* CMPXCHG64rm */ + }, + { /* 541 */ + 53, + /* CMPXCHG64rr */ + }, + { /* 542 */ + 54, + /* CMPXCHG8B */ + }, + { /* 543 */ + 19, + /* CMPXCHG8rm */ + }, + { /* 544 */ + 63, + /* CMPXCHG8rr */ + }, + { /* 545 */ + 0, + /* CPUID */ + }, + { /* 546 */ + 0, + /* CQO */ + }, + { /* 547 */ + 0, + /* CWD */ + }, + { /* 548 */ + 0, + /* CWDE */ + }, + { /* 549 */ + 0, + /* DAA */ + }, + { /* 550 */ + 0, + /* DAS */ + }, + { /* 551 */ + 0, + /* DATA16_PREFIX */ + }, + { /* 552 */ + 54, + /* DEC16m */ + }, + { /* 553 */ + 66, + /* DEC16r */ + }, + { /* 554 */ + 48, + /* DEC16r_alt */ + }, + { /* 555 */ + 54, + /* DEC32m */ + }, + { /* 556 */ + 66, + /* DEC32r */ + }, + { /* 557 */ + 48, + /* DEC32r_alt */ + }, + { /* 558 */ + 54, + /* DEC64m */ + }, + { /* 559 */ + 67, + /* DEC64r */ + }, + { /* 560 */ + 54, + /* DEC8m */ + }, + { /* 561 */ + 68, + /* DEC8r */ + }, + { /* 562 */ + 54, + /* DIV16m */ + }, + { /* 563 */ + 55, + /* DIV16r */ + }, + { /* 564 */ + 54, + /* DIV32m */ + }, + { /* 565 */ + 55, + /* DIV32r */ + }, + { /* 566 */ + 54, + /* DIV64m */ + }, + { /* 567 */ + 57, + /* DIV64r */ + }, + { /* 568 */ + 54, + /* DIV8m */ + }, + { /* 569 */ + 69, + /* DIV8r */ + }, + { /* 570 */ + 0, + /* ENDBR32 */ + }, + { /* 571 */ + 0, + /* ENDBR64 */ + }, + { /* 572 */ + 70, + /* ENTER */ + }, + { /* 573 */ + 71, + /* FARCALL16i */ + }, + { /* 574 */ + 54, + /* FARCALL16m */ + }, + { /* 575 */ + 72, + /* FARCALL32i */ + }, + { /* 576 */ + 54, + /* FARCALL32m */ + }, + { /* 577 */ + 54, + /* FARCALL64 */ + }, + { /* 578 */ + 71, + /* FARJMP16i */ + }, + { /* 579 */ + 54, + /* FARJMP16m */ + }, + { /* 580 */ + 72, + /* FARJMP32i */ + }, + { /* 581 */ + 54, + /* FARJMP32m */ + }, + { /* 582 */ + 54, + /* FARJMP64 */ + }, + { /* 583 */ + 0, + /* FSETPM */ + }, + { /* 584 */ + 0, + /* GETSEC */ + }, + { /* 585 */ + 0, + /* HLT */ + }, + { /* 586 */ + 54, + /* IDIV16m */ + }, + { /* 587 */ + 55, + /* IDIV16r */ + }, + { /* 588 */ + 54, + /* IDIV32m */ + }, + { /* 589 */ + 55, + /* IDIV32r */ + }, + { /* 590 */ + 54, + /* IDIV64m */ + }, + { /* 591 */ + 57, + /* IDIV64r */ + }, + { /* 592 */ + 54, + /* IDIV8m */ + }, + { /* 593 */ + 69, + /* IDIV8r */ + }, + { /* 594 */ + 54, + /* IMUL16m */ + }, + { /* 595 */ + 55, + /* IMUL16r */ + }, + { /* 596 */ + 8, + /* IMUL16rm */ + }, + { /* 597 */ + 73, + /* IMUL16rmi */ + }, + { /* 598 */ + 74, + /* IMUL16rmi8 */ + }, + { /* 599 */ + 10, + /* IMUL16rr */ + }, + { /* 600 */ + 75, + /* IMUL16rri */ + }, + { /* 601 */ + 76, + /* IMUL16rri8 */ + }, + { /* 602 */ + 54, + /* IMUL32m */ + }, + { /* 603 */ + 55, + /* IMUL32r */ + }, + { /* 604 */ + 8, + /* IMUL32rm */ + }, + { /* 605 */ + 73, + /* IMUL32rmi */ + }, + { /* 606 */ + 74, + /* IMUL32rmi8 */ + }, + { /* 607 */ + 10, + /* IMUL32rr */ + }, + { /* 608 */ + 75, + /* IMUL32rri */ + }, + { /* 609 */ + 76, + /* IMUL32rri8 */ + }, + { /* 610 */ + 54, + /* IMUL64m */ + }, + { /* 611 */ + 57, + /* IMUL64r */ + }, + { /* 612 */ + 16, + /* IMUL64rm */ + }, + { /* 613 */ + 38, + /* IMUL64rmi32 */ + }, + { /* 614 */ + 77, + /* IMUL64rmi8 */ + }, + { /* 615 */ + 18, + /* IMUL64rr */ + }, + { /* 616 */ + 39, + /* IMUL64rri32 */ + }, + { /* 617 */ + 78, + /* IMUL64rri8 */ + }, + { /* 618 */ + 54, + /* IMUL8m */ + }, + { /* 619 */ + 69, + /* IMUL8r */ + }, + { /* 620 */ + 79, + /* IN16ri */ + }, + { /* 621 */ + 0, + /* IN16rr */ + }, + { /* 622 */ + 79, + /* IN32ri */ + }, + { /* 623 */ + 0, + /* IN32rr */ + }, + { /* 624 */ + 79, + /* IN8ri */ + }, + { /* 625 */ + 0, + /* IN8rr */ + }, + { /* 626 */ + 54, + /* INC16m */ + }, + { /* 627 */ + 66, + /* INC16r */ + }, + { /* 628 */ + 48, + /* INC16r_alt */ + }, + { /* 629 */ + 54, + /* INC32m */ + }, + { /* 630 */ + 66, + /* INC32r */ + }, + { /* 631 */ + 48, + /* INC32r_alt */ + }, + { /* 632 */ + 54, + /* INC64m */ + }, + { /* 633 */ + 67, + /* INC64r */ + }, + { /* 634 */ + 54, + /* INC8m */ + }, + { /* 635 */ + 68, + /* INC8r */ + }, + { /* 636 */ + 80, + /* INCSSPD */ + }, + { /* 637 */ + 57, + /* INCSSPQ */ + }, + { /* 638 */ + 81, + /* INSB */ + }, + { /* 639 */ + 81, + /* INSL */ + }, + { /* 640 */ + 81, + /* INSW */ + }, + { /* 641 */ + 79, + /* INT */ + }, + { /* 642 */ + 0, + /* INT1 */ + }, + { /* 643 */ + 0, + /* INT3 */ + }, + { /* 644 */ + 0, + /* INTO */ + }, + { /* 645 */ + 0, + /* INVD */ + }, + { /* 646 */ + 82, + /* INVEPT32 */ + }, + { /* 647 */ + 46, + /* INVEPT64 */ + }, + { /* 648 */ + 54, + /* INVLPG */ + }, + { /* 649 */ + 0, + /* INVLPGA32 */ + }, + { /* 650 */ + 0, + /* INVLPGA64 */ + }, + { /* 651 */ + 82, + /* INVPCID32 */ + }, + { /* 652 */ + 46, + /* INVPCID64 */ + }, + { /* 653 */ + 82, + /* INVVPID32 */ + }, + { /* 654 */ + 46, + /* INVVPID64 */ + }, + { /* 655 */ + 0, + /* IRET16 */ + }, + { /* 656 */ + 0, + /* IRET32 */ + }, + { /* 657 */ + 0, + /* IRET64 */ + }, + { /* 658 */ + 83, + /* JAE_1 */ + }, + { /* 659 */ + 84, + /* JAE_2 */ + }, + { /* 660 */ + 84, + /* JAE_4 */ + }, + { /* 661 */ + 83, + /* JA_1 */ + }, + { /* 662 */ + 84, + /* JA_2 */ + }, + { /* 663 */ + 84, + /* JA_4 */ + }, + { /* 664 */ + 83, + /* JBE_1 */ + }, + { /* 665 */ + 84, + /* JBE_2 */ + }, + { /* 666 */ + 84, + /* JBE_4 */ + }, + { /* 667 */ + 83, + /* JB_1 */ + }, + { /* 668 */ + 84, + /* JB_2 */ + }, + { /* 669 */ + 84, + /* JB_4 */ + }, + { /* 670 */ + 83, + /* JCXZ */ + }, + { /* 671 */ + 83, + /* JECXZ */ + }, + { /* 672 */ + 83, + /* JE_1 */ + }, + { /* 673 */ + 84, + /* JE_2 */ + }, + { /* 674 */ + 84, + /* JE_4 */ + }, + { /* 675 */ + 83, + /* JGE_1 */ + }, + { /* 676 */ + 84, + /* JGE_2 */ + }, + { /* 677 */ + 84, + /* JGE_4 */ + }, + { /* 678 */ + 83, + /* JG_1 */ + }, + { /* 679 */ + 84, + /* JG_2 */ + }, + { /* 680 */ + 84, + /* JG_4 */ + }, + { /* 681 */ + 83, + /* JLE_1 */ + }, + { /* 682 */ + 84, + /* JLE_2 */ + }, + { /* 683 */ + 84, + /* JLE_4 */ + }, + { /* 684 */ + 83, + /* JL_1 */ + }, + { /* 685 */ + 84, + /* JL_2 */ + }, + { /* 686 */ + 84, + /* JL_4 */ + }, + { /* 687 */ + 54, + /* JMP16m */ + }, + { /* 688 */ + 0, + /* */ + }, + { /* 689 */ + 55, + /* JMP16r */ + }, + { /* 690 */ + 0, + /* */ + }, + { /* 691 */ + 54, + /* JMP32m */ + }, + { /* 692 */ + 0, + /* */ + }, + { /* 693 */ + 55, + /* JMP32r */ + }, + { /* 694 */ + 0, + /* */ + }, + { /* 695 */ + 54, + /* JMP64m */ + }, + { /* 696 */ + 0, + /* */ + }, + { /* 697 */ + 57, + /* JMP64r */ + }, + { /* 698 */ + 0, + /* */ + }, + { /* 699 */ + 83, + /* JMP_1 */ + }, + { /* 700 */ + 84, + /* JMP_2 */ + }, + { /* 701 */ + 84, + /* JMP_4 */ + }, + { /* 702 */ + 83, + /* JNE_1 */ + }, + { /* 703 */ + 84, + /* JNE_2 */ + }, + { /* 704 */ + 84, + /* JNE_4 */ + }, + { /* 705 */ + 83, + /* JNO_1 */ + }, + { /* 706 */ + 84, + /* JNO_2 */ + }, + { /* 707 */ + 84, + /* JNO_4 */ + }, + { /* 708 */ + 83, + /* JNP_1 */ + }, + { /* 709 */ + 84, + /* JNP_2 */ + }, + { /* 710 */ + 84, + /* JNP_4 */ + }, + { /* 711 */ + 83, + /* JNS_1 */ + }, + { /* 712 */ + 84, + /* JNS_2 */ + }, + { /* 713 */ + 84, + /* JNS_4 */ + }, + { /* 714 */ + 83, + /* JO_1 */ + }, + { /* 715 */ + 84, + /* JO_2 */ + }, + { /* 716 */ + 84, + /* JO_4 */ + }, + { /* 717 */ + 83, + /* JP_1 */ + }, + { /* 718 */ + 84, + /* JP_2 */ + }, + { /* 719 */ + 84, + /* JP_4 */ + }, + { /* 720 */ + 83, + /* JRCXZ */ + }, + { /* 721 */ + 83, + /* JS_1 */ + }, + { /* 722 */ + 84, + /* JS_2 */ + }, + { /* 723 */ + 84, + /* JS_4 */ + }, + { /* 724 */ + 0, + /* LAHF */ + }, + { /* 725 */ + 44, + /* LAR16rm */ + }, + { /* 726 */ + 45, + /* LAR16rr */ + }, + { /* 727 */ + 44, + /* LAR32rm */ + }, + { /* 728 */ + 45, + /* LAR32rr */ + }, + { /* 729 */ + 46, + /* LAR64rm */ + }, + { /* 730 */ + 85, + /* LAR64rr */ + }, + { /* 731 */ + 44, + /* LDS16rm */ + }, + { /* 732 */ + 44, + /* LDS32rm */ + }, + { /* 733 */ + 44, + /* LEA16r */ + }, + { /* 734 */ + 44, + /* LEA32r */ + }, + { /* 735 */ + 44, + /* LEA64_32r */ + }, + { /* 736 */ + 46, + /* LEA64r */ + }, + { /* 737 */ + 0, + /* LEAVE */ + }, + { /* 738 */ + 0, + /* LEAVE64 */ + }, + { /* 739 */ + 44, + /* LES16rm */ + }, + { /* 740 */ + 44, + /* LES32rm */ + }, + { /* 741 */ + 44, + /* LFS16rm */ + }, + { /* 742 */ + 44, + /* LFS32rm */ + }, + { /* 743 */ + 46, + /* LFS64rm */ + }, + { /* 744 */ + 54, + /* LGDT16m */ + }, + { /* 745 */ + 54, + /* LGDT32m */ + }, + { /* 746 */ + 54, + /* LGDT64m */ + }, + { /* 747 */ + 44, + /* LGS16rm */ + }, + { /* 748 */ + 44, + /* LGS32rm */ + }, + { /* 749 */ + 46, + /* LGS64rm */ + }, + { /* 750 */ + 54, + /* LIDT16m */ + }, + { /* 751 */ + 54, + /* LIDT32m */ + }, + { /* 752 */ + 54, + /* LIDT64m */ + }, + { /* 753 */ + 54, + /* LLDT16m */ + }, + { /* 754 */ + 86, + /* LLDT16r */ + }, + { /* 755 */ + 80, + /* LLWPCB */ + }, + { /* 756 */ + 57, + /* LLWPCB64 */ + }, + { /* 757 */ + 54, + /* LMSW16m */ + }, + { /* 758 */ + 86, + /* LMSW16r */ + }, + { /* 759 */ + 0, + /* LOCK_PREFIX */ + }, + { /* 760 */ + 87, + /* LODSB */ + }, + { /* 761 */ + 87, + /* LODSL */ + }, + { /* 762 */ + 87, + /* LODSQ */ + }, + { /* 763 */ + 87, + /* LODSW */ + }, + { /* 764 */ + 83, + /* LOOP */ + }, + { /* 765 */ + 83, + /* LOOPE */ + }, + { /* 766 */ + 83, + /* LOOPNE */ + }, + { /* 767 */ + 88, + /* LRETIL */ + }, + { /* 768 */ + 88, + /* LRETIQ */ + }, + { /* 769 */ + 2, + /* LRETIW */ + }, + { /* 770 */ + 0, + /* LRETL */ + }, + { /* 771 */ + 0, + /* LRETQ */ + }, + { /* 772 */ + 0, + /* LRETW */ + }, + { /* 773 */ + 44, + /* LSL16rm */ + }, + { /* 774 */ + 45, + /* LSL16rr */ + }, + { /* 775 */ + 44, + /* LSL32rm */ + }, + { /* 776 */ + 45, + /* LSL32rr */ + }, + { /* 777 */ + 46, + /* LSL64rm */ + }, + { /* 778 */ + 85, + /* LSL64rr */ + }, + { /* 779 */ + 44, + /* LSS16rm */ + }, + { /* 780 */ + 44, + /* LSS32rm */ + }, + { /* 781 */ + 46, + /* LSS64rm */ + }, + { /* 782 */ + 54, + /* LTRm */ + }, + { /* 783 */ + 86, + /* LTRr */ + }, + { /* 784 */ + 89, + /* LWPINS32rmi */ + }, + { /* 785 */ + 90, + /* LWPINS32rri */ + }, + { /* 786 */ + 91, + /* LWPINS64rmi */ + }, + { /* 787 */ + 92, + /* LWPINS64rri */ + }, + { /* 788 */ + 89, + /* LWPVAL32rmi */ + }, + { /* 789 */ + 90, + /* LWPVAL32rri */ + }, + { /* 790 */ + 91, + /* LWPVAL64rmi */ + }, + { /* 791 */ + 92, + /* LWPVAL64rri */ + }, + { /* 792 */ + 44, + /* LZCNT16rm */ + }, + { /* 793 */ + 45, + /* LZCNT16rr */ + }, + { /* 794 */ + 44, + /* LZCNT32rm */ + }, + { /* 795 */ + 45, + /* LZCNT32rr */ + }, + { /* 796 */ + 46, + /* LZCNT64rm */ + }, + { /* 797 */ + 47, + /* LZCNT64rr */ + }, + { /* 798 */ + 0, + /* MONITORXrrr */ + }, + { /* 799 */ + 0, + /* MONTMUL */ + }, + { /* 800 */ + 93, + /* MOV16ao16 */ + }, + { /* 801 */ + 93, + /* MOV16ao32 */ + }, + { /* 802 */ + 93, + /* MOV16ao64 */ + }, + { /* 803 */ + 3, + /* MOV16mi */ + }, + { /* 804 */ + 5, + /* MOV16mr */ + }, + { /* 805 */ + 94, + /* MOV16ms */ + }, + { /* 806 */ + 93, + /* MOV16o16a */ + }, + { /* 807 */ + 93, + /* MOV16o32a */ + }, + { /* 808 */ + 93, + /* MOV16o64a */ + }, + { /* 809 */ + 95, + /* MOV16ri */ + }, + { /* 810 */ + 59, + /* MOV16ri_alt */ + }, + { /* 811 */ + 44, + /* MOV16rm */ + }, + { /* 812 */ + 51, + /* MOV16rr */ + }, + { /* 813 */ + 45, + /* MOV16rr_REV */ + }, + { /* 814 */ + 96, + /* MOV16rs */ + }, + { /* 815 */ + 97, + /* MOV16sm */ + }, + { /* 816 */ + 98, + /* MOV16sr */ + }, + { /* 817 */ + 93, + /* MOV32ao16 */ + }, + { /* 818 */ + 93, + /* MOV32ao32 */ + }, + { /* 819 */ + 93, + /* MOV32ao64 */ + }, + { /* 820 */ + 99, + /* MOV32cr */ + }, + { /* 821 */ + 100, + /* MOV32dr */ + }, + { /* 822 */ + 3, + /* MOV32mi */ + }, + { /* 823 */ + 5, + /* MOV32mr */ + }, + { /* 824 */ + 93, + /* MOV32o16a */ + }, + { /* 825 */ + 93, + /* MOV32o32a */ + }, + { /* 826 */ + 93, + /* MOV32o64a */ + }, + { /* 827 */ + 101, + /* MOV32rc */ + }, + { /* 828 */ + 102, + /* MOV32rd */ + }, + { /* 829 */ + 95, + /* MOV32ri */ + }, + { /* 830 */ + 59, + /* MOV32ri_alt */ + }, + { /* 831 */ + 44, + /* MOV32rm */ + }, + { /* 832 */ + 51, + /* MOV32rr */ + }, + { /* 833 */ + 45, + /* MOV32rr_REV */ + }, + { /* 834 */ + 96, + /* MOV32rs */ + }, + { /* 835 */ + 98, + /* MOV32sr */ + }, + { /* 836 */ + 93, + /* MOV64ao32 */ + }, + { /* 837 */ + 93, + /* MOV64ao64 */ + }, + { /* 838 */ + 103, + /* MOV64cr */ + }, + { /* 839 */ + 104, + /* MOV64dr */ + }, + { /* 840 */ + 12, + /* MOV64mi32 */ + }, + { /* 841 */ + 13, + /* MOV64mr */ + }, + { /* 842 */ + 93, + /* MOV64o32a */ + }, + { /* 843 */ + 93, + /* MOV64o64a */ + }, + { /* 844 */ + 105, + /* MOV64rc */ + }, + { /* 845 */ + 106, + /* MOV64rd */ + }, + { /* 846 */ + 107, + /* MOV64ri */ + }, + { /* 847 */ + 60, + /* MOV64ri32 */ + }, + { /* 848 */ + 46, + /* MOV64rm */ + }, + { /* 849 */ + 53, + /* MOV64rr */ + }, + { /* 850 */ + 47, + /* MOV64rr_REV */ + }, + { /* 851 */ + 108, + /* MOV64rs */ + }, + { /* 852 */ + 109, + /* MOV64sr */ + }, + { /* 853 */ + 93, + /* MOV8ao16 */ + }, + { /* 854 */ + 93, + /* MOV8ao32 */ + }, + { /* 855 */ + 93, + /* MOV8ao64 */ + }, + { /* 856 */ + 4, + /* MOV8mi */ + }, + { /* 857 */ + 19, + /* MOV8mr */ + }, + { /* 858 */ + 0, + /* */ + }, + { /* 859 */ + 93, + /* MOV8o16a */ + }, + { /* 860 */ + 93, + /* MOV8o32a */ + }, + { /* 861 */ + 93, + /* MOV8o64a */ + }, + { /* 862 */ + 110, + /* MOV8ri */ + }, + { /* 863 */ + 61, + /* MOV8ri_alt */ + }, + { /* 864 */ + 62, + /* MOV8rm */ + }, + { /* 865 */ + 0, + /* */ + }, + { /* 866 */ + 63, + /* MOV8rr */ + }, + { /* 867 */ + 0, + /* */ + }, + { /* 868 */ + 64, + /* MOV8rr_REV */ + }, + { /* 869 */ + 5, + /* MOVBE16mr */ + }, + { /* 870 */ + 44, + /* MOVBE16rm */ + }, + { /* 871 */ + 5, + /* MOVBE32mr */ + }, + { /* 872 */ + 44, + /* MOVBE32rm */ + }, + { /* 873 */ + 13, + /* MOVBE64mr */ + }, + { /* 874 */ + 46, + /* MOVBE64rm */ + }, + { /* 875 */ + 111, + /* MOVDIR64B16 */ + }, + { /* 876 */ + 82, + /* MOVDIR64B32 */ + }, + { /* 877 */ + 46, + /* MOVDIR64B64 */ + }, + { /* 878 */ + 112, + /* MOVDIRI32 */ + }, + { /* 879 */ + 13, + /* MOVDIRI64 */ + }, + { /* 880 */ + 65, + /* MOVSB */ + }, + { /* 881 */ + 65, + /* MOVSL */ + }, + { /* 882 */ + 65, + /* MOVSQ */ + }, + { /* 883 */ + 65, + /* MOVSW */ + }, + { /* 884 */ + 44, + /* MOVSX16rm16 */ + }, + { /* 885 */ + 44, + /* MOVSX16rm8 */ + }, + { /* 886 */ + 45, + /* MOVSX16rr16 */ + }, + { /* 887 */ + 113, + /* MOVSX16rr8 */ + }, + { /* 888 */ + 44, + /* MOVSX32rm16 */ + }, + { /* 889 */ + 44, + /* MOVSX32rm8 */ + }, + { /* 890 */ + 0, + /* */ + }, + { /* 891 */ + 114, + /* MOVSX32rr16 */ + }, + { /* 892 */ + 113, + /* MOVSX32rr8 */ + }, + { /* 893 */ + 0, + /* */ + }, + { /* 894 */ + 46, + /* MOVSX64rm16 */ + }, + { /* 895 */ + 46, + /* MOVSX64rm32 */ + }, + { /* 896 */ + 46, + /* MOVSX64rm8 */ + }, + { /* 897 */ + 115, + /* MOVSX64rr16 */ + }, + { /* 898 */ + 85, + /* MOVSX64rr32 */ + }, + { /* 899 */ + 116, + /* MOVSX64rr8 */ + }, + { /* 900 */ + 44, + /* MOVZX16rm16 */ + }, + { /* 901 */ + 44, + /* MOVZX16rm8 */ + }, + { /* 902 */ + 45, + /* MOVZX16rr16 */ + }, + { /* 903 */ + 113, + /* MOVZX16rr8 */ + }, + { /* 904 */ + 44, + /* MOVZX32rm16 */ + }, + { /* 905 */ + 44, + /* MOVZX32rm8 */ + }, + { /* 906 */ + 0, + /* */ + }, + { /* 907 */ + 114, + /* MOVZX32rr16 */ + }, + { /* 908 */ + 113, + /* MOVZX32rr8 */ + }, + { /* 909 */ + 0, + /* */ + }, + { /* 910 */ + 46, + /* MOVZX64rm16 */ + }, + { /* 911 */ + 46, + /* MOVZX64rm8 */ + }, + { /* 912 */ + 115, + /* MOVZX64rr16 */ + }, + { /* 913 */ + 116, + /* MOVZX64rr8 */ + }, + { /* 914 */ + 54, + /* MUL16m */ + }, + { /* 915 */ + 55, + /* MUL16r */ + }, + { /* 916 */ + 54, + /* MUL32m */ + }, + { /* 917 */ + 55, + /* MUL32r */ + }, + { /* 918 */ + 54, + /* MUL64m */ + }, + { /* 919 */ + 57, + /* MUL64r */ + }, + { /* 920 */ + 54, + /* MUL8m */ + }, + { /* 921 */ + 69, + /* MUL8r */ + }, + { /* 922 */ + 26, + /* MULX32rm */ + }, + { /* 923 */ + 27, + /* MULX32rr */ + }, + { /* 924 */ + 28, + /* MULX64rm */ + }, + { /* 925 */ + 29, + /* MULX64rr */ + }, + { /* 926 */ + 0, + /* MWAITXrrr */ + }, + { /* 927 */ + 54, + /* NEG16m */ + }, + { /* 928 */ + 66, + /* NEG16r */ + }, + { /* 929 */ + 54, + /* NEG32m */ + }, + { /* 930 */ + 66, + /* NEG32r */ + }, + { /* 931 */ + 54, + /* NEG64m */ + }, + { /* 932 */ + 67, + /* NEG64r */ + }, + { /* 933 */ + 54, + /* NEG8m */ + }, + { /* 934 */ + 68, + /* NEG8r */ + }, + { /* 935 */ + 0, + /* NOOP */ + }, + { /* 936 */ + 54, + /* NOOP18_16m4 */ + }, + { /* 937 */ + 54, + /* NOOP18_16m5 */ + }, + { /* 938 */ + 54, + /* NOOP18_16m6 */ + }, + { /* 939 */ + 54, + /* NOOP18_16m7 */ + }, + { /* 940 */ + 55, + /* NOOP18_16r4 */ + }, + { /* 941 */ + 55, + /* NOOP18_16r5 */ + }, + { /* 942 */ + 55, + /* NOOP18_16r6 */ + }, + { /* 943 */ + 55, + /* NOOP18_16r7 */ + }, + { /* 944 */ + 54, + /* NOOP18_m4 */ + }, + { /* 945 */ + 54, + /* NOOP18_m5 */ + }, + { /* 946 */ + 54, + /* NOOP18_m6 */ + }, + { /* 947 */ + 54, + /* NOOP18_m7 */ + }, + { /* 948 */ + 55, + /* NOOP18_r4 */ + }, + { /* 949 */ + 55, + /* NOOP18_r5 */ + }, + { /* 950 */ + 55, + /* NOOP18_r6 */ + }, + { /* 951 */ + 55, + /* NOOP18_r7 */ + }, + { /* 952 */ + 45, + /* NOOP19rr */ + }, + { /* 953 */ + 54, + /* NOOPL */ + }, + { /* 954 */ + 54, + /* NOOPL_19 */ + }, + { /* 955 */ + 54, + /* NOOPL_1d */ + }, + { /* 956 */ + 54, + /* NOOPL_1e */ + }, + { /* 957 */ + 55, + /* NOOPLr */ + }, + { /* 958 */ + 54, + /* NOOPQ */ + }, + { /* 959 */ + 57, + /* NOOPQr */ + }, + { /* 960 */ + 54, + /* NOOPW */ + }, + { /* 961 */ + 54, + /* NOOPW_19 */ + }, + { /* 962 */ + 54, + /* NOOPW_1c */ + }, + { /* 963 */ + 54, + /* NOOPW_1d */ + }, + { /* 964 */ + 54, + /* NOOPW_1e */ + }, + { /* 965 */ + 55, + /* NOOPWr */ + }, + { /* 966 */ + 54, + /* NOT16m */ + }, + { /* 967 */ + 66, + /* NOT16r */ + }, + { /* 968 */ + 54, + /* NOT32m */ + }, + { /* 969 */ + 66, + /* NOT32r */ + }, + { /* 970 */ + 54, + /* NOT64m */ + }, + { /* 971 */ + 67, + /* NOT64r */ + }, + { /* 972 */ + 54, + /* NOT8m */ + }, + { /* 973 */ + 68, + /* NOT8r */ + }, + { /* 974 */ + 2, + /* OR16i16 */ + }, + { /* 975 */ + 3, + /* OR16mi */ + }, + { /* 976 */ + 4, + /* OR16mi8 */ + }, + { /* 977 */ + 5, + /* OR16mr */ + }, + { /* 978 */ + 6, + /* OR16ri */ + }, + { /* 979 */ + 7, + /* OR16ri8 */ + }, + { /* 980 */ + 8, + /* OR16rm */ + }, + { /* 981 */ + 9, + /* OR16rr */ + }, + { /* 982 */ + 10, + /* OR16rr_REV */ + }, + { /* 983 */ + 2, + /* OR32i32 */ + }, + { /* 984 */ + 3, + /* OR32mi */ + }, + { /* 985 */ + 4, + /* OR32mi8 */ + }, + { /* 986 */ + 5, + /* OR32mr */ + }, + { /* 987 */ + 6, + /* OR32ri */ + }, + { /* 988 */ + 7, + /* OR32ri8 */ + }, + { /* 989 */ + 8, + /* OR32rm */ + }, + { /* 990 */ + 9, + /* OR32rr */ + }, + { /* 991 */ + 10, + /* OR32rr_REV */ + }, + { /* 992 */ + 11, + /* OR64i32 */ + }, + { /* 993 */ + 12, + /* OR64mi32 */ + }, + { /* 994 */ + 4, + /* OR64mi8 */ + }, + { /* 995 */ + 13, + /* OR64mr */ + }, + { /* 996 */ + 14, + /* OR64ri32 */ + }, + { /* 997 */ + 15, + /* OR64ri8 */ + }, + { /* 998 */ + 16, + /* OR64rm */ + }, + { /* 999 */ + 17, + /* OR64rr */ + }, + { /* 1000 */ + 18, + /* OR64rr_REV */ + }, + { /* 1001 */ + 1, + /* OR8i8 */ + }, + { /* 1002 */ + 4, + /* OR8mi */ + }, + { /* 1003 */ + 4, + /* OR8mi8 */ + }, + { /* 1004 */ + 19, + /* OR8mr */ + }, + { /* 1005 */ + 20, + /* OR8ri */ + }, + { /* 1006 */ + 20, + /* OR8ri8 */ + }, + { /* 1007 */ + 21, + /* OR8rm */ + }, + { /* 1008 */ + 22, + /* OR8rr */ + }, + { /* 1009 */ + 23, + /* OR8rr_REV */ + }, + { /* 1010 */ + 79, + /* OUT16ir */ + }, + { /* 1011 */ + 0, + /* OUT16rr */ + }, + { /* 1012 */ + 79, + /* OUT32ir */ + }, + { /* 1013 */ + 0, + /* OUT32rr */ + }, + { /* 1014 */ + 79, + /* OUT8ir */ + }, + { /* 1015 */ + 0, + /* OUT8rr */ + }, + { /* 1016 */ + 87, + /* OUTSB */ + }, + { /* 1017 */ + 87, + /* OUTSL */ + }, + { /* 1018 */ + 87, + /* OUTSW */ + }, + { /* 1019 */ + 0, + /* PCONFIG */ + }, + { /* 1020 */ + 26, + /* PDEP32rm */ + }, + { /* 1021 */ + 27, + /* PDEP32rr */ + }, + { /* 1022 */ + 28, + /* PDEP64rm */ + }, + { /* 1023 */ + 29, + /* PDEP64rr */ + }, + { /* 1024 */ + 26, + /* PEXT32rm */ + }, + { /* 1025 */ + 27, + /* PEXT32rr */ + }, + { /* 1026 */ + 28, + /* PEXT64rm */ + }, + { /* 1027 */ + 29, + /* PEXT64rr */ + }, + { /* 1028 */ + 117, + /* POP16r */ + }, + { /* 1029 */ + 54, + /* POP16rmm */ + }, + { /* 1030 */ + 55, + /* POP16rmr */ + }, + { /* 1031 */ + 117, + /* POP32r */ + }, + { /* 1032 */ + 54, + /* POP32rmm */ + }, + { /* 1033 */ + 55, + /* POP32rmr */ + }, + { /* 1034 */ + 118, + /* POP64r */ + }, + { /* 1035 */ + 54, + /* POP64rmm */ + }, + { /* 1036 */ + 57, + /* POP64rmr */ + }, + { /* 1037 */ + 0, + /* POPA16 */ + }, + { /* 1038 */ + 0, + /* POPA32 */ + }, + { /* 1039 */ + 0, + /* POPDS16 */ + }, + { /* 1040 */ + 0, + /* POPDS32 */ + }, + { /* 1041 */ + 0, + /* POPES16 */ + }, + { /* 1042 */ + 0, + /* POPES32 */ + }, + { /* 1043 */ + 0, + /* POPF16 */ + }, + { /* 1044 */ + 0, + /* POPF32 */ + }, + { /* 1045 */ + 0, + /* POPF64 */ + }, + { /* 1046 */ + 0, + /* POPFS16 */ + }, + { /* 1047 */ + 0, + /* POPFS32 */ + }, + { /* 1048 */ + 0, + /* POPFS64 */ + }, + { /* 1049 */ + 0, + /* POPGS16 */ + }, + { /* 1050 */ + 0, + /* POPGS32 */ + }, + { /* 1051 */ + 0, + /* POPGS64 */ + }, + { /* 1052 */ + 0, + /* POPSS16 */ + }, + { /* 1053 */ + 0, + /* POPSS32 */ + }, + { /* 1054 */ + 54, + /* PTWRITE64m */ + }, + { /* 1055 */ + 57, + /* PTWRITE64r */ + }, + { /* 1056 */ + 54, + /* PTWRITEm */ + }, + { /* 1057 */ + 80, + /* PTWRITEr */ + }, + { /* 1058 */ + 1, + /* PUSH16i8 */ + }, + { /* 1059 */ + 117, + /* PUSH16r */ + }, + { /* 1060 */ + 54, + /* PUSH16rmm */ + }, + { /* 1061 */ + 55, + /* PUSH16rmr */ + }, + { /* 1062 */ + 1, + /* PUSH32i8 */ + }, + { /* 1063 */ + 117, + /* PUSH32r */ + }, + { /* 1064 */ + 54, + /* PUSH32rmm */ + }, + { /* 1065 */ + 55, + /* PUSH32rmr */ + }, + { /* 1066 */ + 11, + /* PUSH64i32 */ + }, + { /* 1067 */ + 1, + /* PUSH64i8 */ + }, + { /* 1068 */ + 118, + /* PUSH64r */ + }, + { /* 1069 */ + 54, + /* PUSH64rmm */ + }, + { /* 1070 */ + 57, + /* PUSH64rmr */ + }, + { /* 1071 */ + 0, + /* PUSHA16 */ + }, + { /* 1072 */ + 0, + /* PUSHA32 */ + }, + { /* 1073 */ + 0, + /* PUSHCS16 */ + }, + { /* 1074 */ + 0, + /* PUSHCS32 */ + }, + { /* 1075 */ + 0, + /* PUSHDS16 */ + }, + { /* 1076 */ + 0, + /* PUSHDS32 */ + }, + { /* 1077 */ + 0, + /* PUSHES16 */ + }, + { /* 1078 */ + 0, + /* PUSHES32 */ + }, + { /* 1079 */ + 0, + /* PUSHF16 */ + }, + { /* 1080 */ + 0, + /* PUSHF32 */ + }, + { /* 1081 */ + 0, + /* PUSHF64 */ + }, + { /* 1082 */ + 0, + /* PUSHFS16 */ + }, + { /* 1083 */ + 0, + /* PUSHFS32 */ + }, + { /* 1084 */ + 0, + /* PUSHFS64 */ + }, + { /* 1085 */ + 0, + /* PUSHGS16 */ + }, + { /* 1086 */ + 0, + /* PUSHGS32 */ + }, + { /* 1087 */ + 0, + /* PUSHGS64 */ + }, + { /* 1088 */ + 0, + /* PUSHSS16 */ + }, + { /* 1089 */ + 0, + /* PUSHSS32 */ + }, + { /* 1090 */ + 2, + /* PUSHi16 */ + }, + { /* 1091 */ + 2, + /* PUSHi32 */ + }, + { /* 1092 */ + 54, + /* RCL16m1 */ + }, + { /* 1093 */ + 54, + /* RCL16mCL */ + }, + { /* 1094 */ + 119, + /* RCL16mi */ + }, + { /* 1095 */ + 66, + /* RCL16r1 */ + }, + { /* 1096 */ + 66, + /* RCL16rCL */ + }, + { /* 1097 */ + 120, + /* RCL16ri */ + }, + { /* 1098 */ + 54, + /* RCL32m1 */ + }, + { /* 1099 */ + 54, + /* RCL32mCL */ + }, + { /* 1100 */ + 119, + /* RCL32mi */ + }, + { /* 1101 */ + 66, + /* RCL32r1 */ + }, + { /* 1102 */ + 66, + /* RCL32rCL */ + }, + { /* 1103 */ + 120, + /* RCL32ri */ + }, + { /* 1104 */ + 54, + /* RCL64m1 */ + }, + { /* 1105 */ + 54, + /* RCL64mCL */ + }, + { /* 1106 */ + 119, + /* RCL64mi */ + }, + { /* 1107 */ + 67, + /* RCL64r1 */ + }, + { /* 1108 */ + 67, + /* RCL64rCL */ + }, + { /* 1109 */ + 121, + /* RCL64ri */ + }, + { /* 1110 */ + 54, + /* RCL8m1 */ + }, + { /* 1111 */ + 54, + /* RCL8mCL */ + }, + { /* 1112 */ + 119, + /* RCL8mi */ + }, + { /* 1113 */ + 68, + /* RCL8r1 */ + }, + { /* 1114 */ + 68, + /* RCL8rCL */ + }, + { /* 1115 */ + 122, + /* RCL8ri */ + }, + { /* 1116 */ + 54, + /* RCR16m1 */ + }, + { /* 1117 */ + 54, + /* RCR16mCL */ + }, + { /* 1118 */ + 119, + /* RCR16mi */ + }, + { /* 1119 */ + 66, + /* RCR16r1 */ + }, + { /* 1120 */ + 66, + /* RCR16rCL */ + }, + { /* 1121 */ + 120, + /* RCR16ri */ + }, + { /* 1122 */ + 54, + /* RCR32m1 */ + }, + { /* 1123 */ + 54, + /* RCR32mCL */ + }, + { /* 1124 */ + 119, + /* RCR32mi */ + }, + { /* 1125 */ + 66, + /* RCR32r1 */ + }, + { /* 1126 */ + 66, + /* RCR32rCL */ + }, + { /* 1127 */ + 120, + /* RCR32ri */ + }, + { /* 1128 */ + 54, + /* RCR64m1 */ + }, + { /* 1129 */ + 54, + /* RCR64mCL */ + }, + { /* 1130 */ + 119, + /* RCR64mi */ + }, + { /* 1131 */ + 67, + /* RCR64r1 */ + }, + { /* 1132 */ + 67, + /* RCR64rCL */ + }, + { /* 1133 */ + 121, + /* RCR64ri */ + }, + { /* 1134 */ + 54, + /* RCR8m1 */ + }, + { /* 1135 */ + 54, + /* RCR8mCL */ + }, + { /* 1136 */ + 119, + /* RCR8mi */ + }, + { /* 1137 */ + 68, + /* RCR8r1 */ + }, + { /* 1138 */ + 68, + /* RCR8rCL */ + }, + { /* 1139 */ + 122, + /* RCR8ri */ + }, + { /* 1140 */ + 80, + /* RDFSBASE */ + }, + { /* 1141 */ + 57, + /* RDFSBASE64 */ + }, + { /* 1142 */ + 80, + /* RDGSBASE */ + }, + { /* 1143 */ + 57, + /* RDGSBASE64 */ + }, + { /* 1144 */ + 0, + /* RDMSR */ + }, + { /* 1145 */ + 80, + /* RDPID32 */ + }, + { /* 1146 */ + 57, + /* RDPID64 */ + }, + { /* 1147 */ + 0, + /* RDPKRUr */ + }, + { /* 1148 */ + 0, + /* RDPMC */ + }, + { /* 1149 */ + 55, + /* RDRAND16r */ + }, + { /* 1150 */ + 55, + /* RDRAND32r */ + }, + { /* 1151 */ + 57, + /* RDRAND64r */ + }, + { /* 1152 */ + 55, + /* RDSEED16r */ + }, + { /* 1153 */ + 55, + /* RDSEED32r */ + }, + { /* 1154 */ + 57, + /* RDSEED64r */ + }, + { /* 1155 */ + 123, + /* RDSSPD */ + }, + { /* 1156 */ + 67, + /* RDSSPQ */ + }, + { /* 1157 */ + 0, + /* RDTSC */ + }, + { /* 1158 */ + 0, + /* RDTSCP */ + }, + { /* 1159 */ + 0, + /* REPNE_PREFIX */ + }, + { /* 1160 */ + 0, + /* REP_PREFIX */ + }, + { /* 1161 */ + 88, + /* RETIL */ + }, + { /* 1162 */ + 88, + /* RETIQ */ + }, + { /* 1163 */ + 2, + /* RETIW */ + }, + { /* 1164 */ + 0, + /* RETL */ + }, + { /* 1165 */ + 0, + /* RETQ */ + }, + { /* 1166 */ + 0, + /* RETW */ + }, + { /* 1167 */ + 0, + /* REX64_PREFIX */ + }, + { /* 1168 */ + 54, + /* ROL16m1 */ + }, + { /* 1169 */ + 54, + /* ROL16mCL */ + }, + { /* 1170 */ + 119, + /* ROL16mi */ + }, + { /* 1171 */ + 66, + /* ROL16r1 */ + }, + { /* 1172 */ + 66, + /* ROL16rCL */ + }, + { /* 1173 */ + 120, + /* ROL16ri */ + }, + { /* 1174 */ + 54, + /* ROL32m1 */ + }, + { /* 1175 */ + 54, + /* ROL32mCL */ + }, + { /* 1176 */ + 119, + /* ROL32mi */ + }, + { /* 1177 */ + 66, + /* ROL32r1 */ + }, + { /* 1178 */ + 66, + /* ROL32rCL */ + }, + { /* 1179 */ + 120, + /* ROL32ri */ + }, + { /* 1180 */ + 54, + /* ROL64m1 */ + }, + { /* 1181 */ + 54, + /* ROL64mCL */ + }, + { /* 1182 */ + 119, + /* ROL64mi */ + }, + { /* 1183 */ + 67, + /* ROL64r1 */ + }, + { /* 1184 */ + 67, + /* ROL64rCL */ + }, + { /* 1185 */ + 121, + /* ROL64ri */ + }, + { /* 1186 */ + 54, + /* ROL8m1 */ + }, + { /* 1187 */ + 54, + /* ROL8mCL */ + }, + { /* 1188 */ + 119, + /* ROL8mi */ + }, + { /* 1189 */ + 68, + /* ROL8r1 */ + }, + { /* 1190 */ + 68, + /* ROL8rCL */ + }, + { /* 1191 */ + 122, + /* ROL8ri */ + }, + { /* 1192 */ + 54, + /* ROR16m1 */ + }, + { /* 1193 */ + 54, + /* ROR16mCL */ + }, + { /* 1194 */ + 119, + /* ROR16mi */ + }, + { /* 1195 */ + 66, + /* ROR16r1 */ + }, + { /* 1196 */ + 66, + /* ROR16rCL */ + }, + { /* 1197 */ + 120, + /* ROR16ri */ + }, + { /* 1198 */ + 54, + /* ROR32m1 */ + }, + { /* 1199 */ + 54, + /* ROR32mCL */ + }, + { /* 1200 */ + 119, + /* ROR32mi */ + }, + { /* 1201 */ + 66, + /* ROR32r1 */ + }, + { /* 1202 */ + 66, + /* ROR32rCL */ + }, + { /* 1203 */ + 120, + /* ROR32ri */ + }, + { /* 1204 */ + 54, + /* ROR64m1 */ + }, + { /* 1205 */ + 54, + /* ROR64mCL */ + }, + { /* 1206 */ + 119, + /* ROR64mi */ + }, + { /* 1207 */ + 67, + /* ROR64r1 */ + }, + { /* 1208 */ + 67, + /* ROR64rCL */ + }, + { /* 1209 */ + 121, + /* ROR64ri */ + }, + { /* 1210 */ + 54, + /* ROR8m1 */ + }, + { /* 1211 */ + 54, + /* ROR8mCL */ + }, + { /* 1212 */ + 119, + /* ROR8mi */ + }, + { /* 1213 */ + 68, + /* ROR8r1 */ + }, + { /* 1214 */ + 68, + /* ROR8rCL */ + }, + { /* 1215 */ + 122, + /* ROR8ri */ + }, + { /* 1216 */ + 124, + /* RORX32mi */ + }, + { /* 1217 */ + 125, + /* RORX32ri */ + }, + { /* 1218 */ + 126, + /* RORX64mi */ + }, + { /* 1219 */ + 127, + /* RORX64ri */ + }, + { /* 1220 */ + 0, + /* RSM */ + }, + { /* 1221 */ + 54, + /* RSTORSSP */ + }, + { /* 1222 */ + 0, + /* SAHF */ + }, + { /* 1223 */ + 54, + /* SAL16m1 */ + }, + { /* 1224 */ + 54, + /* SAL16mCL */ + }, + { /* 1225 */ + 4, + /* SAL16mi */ + }, + { /* 1226 */ + 66, + /* SAL16r1 */ + }, + { /* 1227 */ + 66, + /* SAL16rCL */ + }, + { /* 1228 */ + 7, + /* SAL16ri */ + }, + { /* 1229 */ + 54, + /* SAL32m1 */ + }, + { /* 1230 */ + 54, + /* SAL32mCL */ + }, + { /* 1231 */ + 4, + /* SAL32mi */ + }, + { /* 1232 */ + 66, + /* SAL32r1 */ + }, + { /* 1233 */ + 66, + /* SAL32rCL */ + }, + { /* 1234 */ + 7, + /* SAL32ri */ + }, + { /* 1235 */ + 54, + /* SAL64m1 */ + }, + { /* 1236 */ + 54, + /* SAL64mCL */ + }, + { /* 1237 */ + 4, + /* SAL64mi */ + }, + { /* 1238 */ + 67, + /* SAL64r1 */ + }, + { /* 1239 */ + 67, + /* SAL64rCL */ + }, + { /* 1240 */ + 15, + /* SAL64ri */ + }, + { /* 1241 */ + 54, + /* SAL8m1 */ + }, + { /* 1242 */ + 54, + /* SAL8mCL */ + }, + { /* 1243 */ + 4, + /* SAL8mi */ + }, + { /* 1244 */ + 68, + /* SAL8r1 */ + }, + { /* 1245 */ + 68, + /* SAL8rCL */ + }, + { /* 1246 */ + 20, + /* SAL8ri */ + }, + { /* 1247 */ + 0, + /* SALC */ + }, + { /* 1248 */ + 54, + /* SAR16m1 */ + }, + { /* 1249 */ + 54, + /* SAR16mCL */ + }, + { /* 1250 */ + 119, + /* SAR16mi */ + }, + { /* 1251 */ + 66, + /* SAR16r1 */ + }, + { /* 1252 */ + 66, + /* SAR16rCL */ + }, + { /* 1253 */ + 120, + /* SAR16ri */ + }, + { /* 1254 */ + 54, + /* SAR32m1 */ + }, + { /* 1255 */ + 54, + /* SAR32mCL */ + }, + { /* 1256 */ + 119, + /* SAR32mi */ + }, + { /* 1257 */ + 66, + /* SAR32r1 */ + }, + { /* 1258 */ + 66, + /* SAR32rCL */ + }, + { /* 1259 */ + 120, + /* SAR32ri */ + }, + { /* 1260 */ + 54, + /* SAR64m1 */ + }, + { /* 1261 */ + 54, + /* SAR64mCL */ + }, + { /* 1262 */ + 119, + /* SAR64mi */ + }, + { /* 1263 */ + 67, + /* SAR64r1 */ + }, + { /* 1264 */ + 67, + /* SAR64rCL */ + }, + { /* 1265 */ + 121, + /* SAR64ri */ + }, + { /* 1266 */ + 54, + /* SAR8m1 */ + }, + { /* 1267 */ + 54, + /* SAR8mCL */ + }, + { /* 1268 */ + 119, + /* SAR8mi */ + }, + { /* 1269 */ + 68, + /* SAR8r1 */ + }, + { /* 1270 */ + 68, + /* SAR8rCL */ + }, + { /* 1271 */ + 122, + /* SAR8ri */ + }, + { /* 1272 */ + 32, + /* SARX32rm */ + }, + { /* 1273 */ + 33, + /* SARX32rr */ + }, + { /* 1274 */ + 34, + /* SARX64rm */ + }, + { /* 1275 */ + 35, + /* SARX64rr */ + }, + { /* 1276 */ + 0, + /* SAVEPREVSSP */ + }, + { /* 1277 */ + 2, + /* SBB16i16 */ + }, + { /* 1278 */ + 3, + /* SBB16mi */ + }, + { /* 1279 */ + 4, + /* SBB16mi8 */ + }, + { /* 1280 */ + 5, + /* SBB16mr */ + }, + { /* 1281 */ + 6, + /* SBB16ri */ + }, + { /* 1282 */ + 7, + /* SBB16ri8 */ + }, + { /* 1283 */ + 8, + /* SBB16rm */ + }, + { /* 1284 */ + 9, + /* SBB16rr */ + }, + { /* 1285 */ + 10, + /* SBB16rr_REV */ + }, + { /* 1286 */ + 2, + /* SBB32i32 */ + }, + { /* 1287 */ + 3, + /* SBB32mi */ + }, + { /* 1288 */ + 4, + /* SBB32mi8 */ + }, + { /* 1289 */ + 5, + /* SBB32mr */ + }, + { /* 1290 */ + 6, + /* SBB32ri */ + }, + { /* 1291 */ + 7, + /* SBB32ri8 */ + }, + { /* 1292 */ + 8, + /* SBB32rm */ + }, + { /* 1293 */ + 9, + /* SBB32rr */ + }, + { /* 1294 */ + 10, + /* SBB32rr_REV */ + }, + { /* 1295 */ + 11, + /* SBB64i32 */ + }, + { /* 1296 */ + 12, + /* SBB64mi32 */ + }, + { /* 1297 */ + 4, + /* SBB64mi8 */ + }, + { /* 1298 */ + 13, + /* SBB64mr */ + }, + { /* 1299 */ + 14, + /* SBB64ri32 */ + }, + { /* 1300 */ + 15, + /* SBB64ri8 */ + }, + { /* 1301 */ + 16, + /* SBB64rm */ + }, + { /* 1302 */ + 17, + /* SBB64rr */ + }, + { /* 1303 */ + 18, + /* SBB64rr_REV */ + }, + { /* 1304 */ + 1, + /* SBB8i8 */ + }, + { /* 1305 */ + 4, + /* SBB8mi */ + }, + { /* 1306 */ + 4, + /* SBB8mi8 */ + }, + { /* 1307 */ + 19, + /* SBB8mr */ + }, + { /* 1308 */ + 20, + /* SBB8ri */ + }, + { /* 1309 */ + 20, + /* SBB8ri8 */ + }, + { /* 1310 */ + 21, + /* SBB8rm */ + }, + { /* 1311 */ + 22, + /* SBB8rr */ + }, + { /* 1312 */ + 23, + /* SBB8rr_REV */ + }, + { /* 1313 */ + 81, + /* SCASB */ + }, + { /* 1314 */ + 81, + /* SCASL */ + }, + { /* 1315 */ + 81, + /* SCASQ */ + }, + { /* 1316 */ + 81, + /* SCASW */ + }, + { /* 1317 */ + 54, + /* SETAEm */ + }, + { /* 1318 */ + 69, + /* SETAEr */ + }, + { /* 1319 */ + 54, + /* SETAm */ + }, + { /* 1320 */ + 69, + /* SETAr */ + }, + { /* 1321 */ + 54, + /* SETBEm */ + }, + { /* 1322 */ + 69, + /* SETBEr */ + }, + { /* 1323 */ + 54, + /* SETBm */ + }, + { /* 1324 */ + 69, + /* SETBr */ + }, + { /* 1325 */ + 54, + /* SETEm */ + }, + { /* 1326 */ + 69, + /* SETEr */ + }, + { /* 1327 */ + 54, + /* SETGEm */ + }, + { /* 1328 */ + 69, + /* SETGEr */ + }, + { /* 1329 */ + 54, + /* SETGm */ + }, + { /* 1330 */ + 69, + /* SETGr */ + }, + { /* 1331 */ + 54, + /* SETLEm */ + }, + { /* 1332 */ + 69, + /* SETLEr */ + }, + { /* 1333 */ + 54, + /* SETLm */ + }, + { /* 1334 */ + 69, + /* SETLr */ + }, + { /* 1335 */ + 54, + /* SETNEm */ + }, + { /* 1336 */ + 69, + /* SETNEr */ + }, + { /* 1337 */ + 54, + /* SETNOm */ + }, + { /* 1338 */ + 69, + /* SETNOr */ + }, + { /* 1339 */ + 54, + /* SETNPm */ + }, + { /* 1340 */ + 69, + /* SETNPr */ + }, + { /* 1341 */ + 54, + /* SETNSm */ + }, + { /* 1342 */ + 69, + /* SETNSr */ + }, + { /* 1343 */ + 54, + /* SETOm */ + }, + { /* 1344 */ + 69, + /* SETOr */ + }, + { /* 1345 */ + 54, + /* SETPm */ + }, + { /* 1346 */ + 69, + /* SETPr */ + }, + { /* 1347 */ + 0, + /* SETSSBSY */ + }, + { /* 1348 */ + 54, + /* SETSm */ + }, + { /* 1349 */ + 69, + /* SETSr */ + }, + { /* 1350 */ + 54, + /* SGDT16m */ + }, + { /* 1351 */ + 54, + /* SGDT32m */ + }, + { /* 1352 */ + 54, + /* SGDT64m */ + }, + { /* 1353 */ + 54, + /* SHL16m1 */ + }, + { /* 1354 */ + 54, + /* SHL16mCL */ + }, + { /* 1355 */ + 119, + /* SHL16mi */ + }, + { /* 1356 */ + 66, + /* SHL16r1 */ + }, + { /* 1357 */ + 66, + /* SHL16rCL */ + }, + { /* 1358 */ + 120, + /* SHL16ri */ + }, + { /* 1359 */ + 54, + /* SHL32m1 */ + }, + { /* 1360 */ + 54, + /* SHL32mCL */ + }, + { /* 1361 */ + 119, + /* SHL32mi */ + }, + { /* 1362 */ + 66, + /* SHL32r1 */ + }, + { /* 1363 */ + 66, + /* SHL32rCL */ + }, + { /* 1364 */ + 120, + /* SHL32ri */ + }, + { /* 1365 */ + 54, + /* SHL64m1 */ + }, + { /* 1366 */ + 54, + /* SHL64mCL */ + }, + { /* 1367 */ + 119, + /* SHL64mi */ + }, + { /* 1368 */ + 67, + /* SHL64r1 */ + }, + { /* 1369 */ + 67, + /* SHL64rCL */ + }, + { /* 1370 */ + 121, + /* SHL64ri */ + }, + { /* 1371 */ + 54, + /* SHL8m1 */ + }, + { /* 1372 */ + 54, + /* SHL8mCL */ + }, + { /* 1373 */ + 119, + /* SHL8mi */ + }, + { /* 1374 */ + 68, + /* SHL8r1 */ + }, + { /* 1375 */ + 68, + /* SHL8rCL */ + }, + { /* 1376 */ + 122, + /* SHL8ri */ + }, + { /* 1377 */ + 5, + /* SHLD16mrCL */ + }, + { /* 1378 */ + 128, + /* SHLD16mri8 */ + }, + { /* 1379 */ + 9, + /* SHLD16rrCL */ + }, + { /* 1380 */ + 129, + /* SHLD16rri8 */ + }, + { /* 1381 */ + 5, + /* SHLD32mrCL */ + }, + { /* 1382 */ + 128, + /* SHLD32mri8 */ + }, + { /* 1383 */ + 9, + /* SHLD32rrCL */ + }, + { /* 1384 */ + 129, + /* SHLD32rri8 */ + }, + { /* 1385 */ + 13, + /* SHLD64mrCL */ + }, + { /* 1386 */ + 130, + /* SHLD64mri8 */ + }, + { /* 1387 */ + 17, + /* SHLD64rrCL */ + }, + { /* 1388 */ + 131, + /* SHLD64rri8 */ + }, + { /* 1389 */ + 32, + /* SHLX32rm */ + }, + { /* 1390 */ + 33, + /* SHLX32rr */ + }, + { /* 1391 */ + 34, + /* SHLX64rm */ + }, + { /* 1392 */ + 35, + /* SHLX64rr */ + }, + { /* 1393 */ + 54, + /* SHR16m1 */ + }, + { /* 1394 */ + 54, + /* SHR16mCL */ + }, + { /* 1395 */ + 119, + /* SHR16mi */ + }, + { /* 1396 */ + 66, + /* SHR16r1 */ + }, + { /* 1397 */ + 66, + /* SHR16rCL */ + }, + { /* 1398 */ + 120, + /* SHR16ri */ + }, + { /* 1399 */ + 54, + /* SHR32m1 */ + }, + { /* 1400 */ + 54, + /* SHR32mCL */ + }, + { /* 1401 */ + 119, + /* SHR32mi */ + }, + { /* 1402 */ + 66, + /* SHR32r1 */ + }, + { /* 1403 */ + 66, + /* SHR32rCL */ + }, + { /* 1404 */ + 120, + /* SHR32ri */ + }, + { /* 1405 */ + 54, + /* SHR64m1 */ + }, + { /* 1406 */ + 54, + /* SHR64mCL */ + }, + { /* 1407 */ + 119, + /* SHR64mi */ + }, + { /* 1408 */ + 67, + /* SHR64r1 */ + }, + { /* 1409 */ + 67, + /* SHR64rCL */ + }, + { /* 1410 */ + 121, + /* SHR64ri */ + }, + { /* 1411 */ + 54, + /* SHR8m1 */ + }, + { /* 1412 */ + 54, + /* SHR8mCL */ + }, + { /* 1413 */ + 119, + /* SHR8mi */ + }, + { /* 1414 */ + 68, + /* SHR8r1 */ + }, + { /* 1415 */ + 68, + /* SHR8rCL */ + }, + { /* 1416 */ + 122, + /* SHR8ri */ + }, + { /* 1417 */ + 5, + /* SHRD16mrCL */ + }, + { /* 1418 */ + 128, + /* SHRD16mri8 */ + }, + { /* 1419 */ + 9, + /* SHRD16rrCL */ + }, + { /* 1420 */ + 129, + /* SHRD16rri8 */ + }, + { /* 1421 */ + 5, + /* SHRD32mrCL */ + }, + { /* 1422 */ + 128, + /* SHRD32mri8 */ + }, + { /* 1423 */ + 9, + /* SHRD32rrCL */ + }, + { /* 1424 */ + 129, + /* SHRD32rri8 */ + }, + { /* 1425 */ + 13, + /* SHRD64mrCL */ + }, + { /* 1426 */ + 130, + /* SHRD64mri8 */ + }, + { /* 1427 */ + 17, + /* SHRD64rrCL */ + }, + { /* 1428 */ + 131, + /* SHRD64rri8 */ + }, + { /* 1429 */ + 32, + /* SHRX32rm */ + }, + { /* 1430 */ + 33, + /* SHRX32rr */ + }, + { /* 1431 */ + 34, + /* SHRX64rm */ + }, + { /* 1432 */ + 35, + /* SHRX64rr */ + }, + { /* 1433 */ + 54, + /* SIDT16m */ + }, + { /* 1434 */ + 54, + /* SIDT32m */ + }, + { /* 1435 */ + 54, + /* SIDT64m */ + }, + { /* 1436 */ + 0, + /* SKINIT */ + }, + { /* 1437 */ + 54, + /* SLDT16m */ + }, + { /* 1438 */ + 55, + /* SLDT16r */ + }, + { /* 1439 */ + 55, + /* SLDT32r */ + }, + { /* 1440 */ + 57, + /* SLDT64r */ + }, + { /* 1441 */ + 80, + /* SLWPCB */ + }, + { /* 1442 */ + 57, + /* SLWPCB64 */ + }, + { /* 1443 */ + 54, + /* SMSW16m */ + }, + { /* 1444 */ + 55, + /* SMSW16r */ + }, + { /* 1445 */ + 55, + /* SMSW32r */ + }, + { /* 1446 */ + 57, + /* SMSW64r */ + }, + { /* 1447 */ + 0, + /* STAC */ + }, + { /* 1448 */ + 0, + /* STC */ + }, + { /* 1449 */ + 0, + /* STD */ + }, + { /* 1450 */ + 0, + /* STGI */ + }, + { /* 1451 */ + 0, + /* STI */ + }, + { /* 1452 */ + 81, + /* STOSB */ + }, + { /* 1453 */ + 81, + /* STOSL */ + }, + { /* 1454 */ + 81, + /* STOSQ */ + }, + { /* 1455 */ + 81, + /* STOSW */ + }, + { /* 1456 */ + 55, + /* STR16r */ + }, + { /* 1457 */ + 55, + /* STR32r */ + }, + { /* 1458 */ + 57, + /* STR64r */ + }, + { /* 1459 */ + 54, + /* STRm */ + }, + { /* 1460 */ + 2, + /* SUB16i16 */ + }, + { /* 1461 */ + 3, + /* SUB16mi */ + }, + { /* 1462 */ + 4, + /* SUB16mi8 */ + }, + { /* 1463 */ + 5, + /* SUB16mr */ + }, + { /* 1464 */ + 6, + /* SUB16ri */ + }, + { /* 1465 */ + 7, + /* SUB16ri8 */ + }, + { /* 1466 */ + 8, + /* SUB16rm */ + }, + { /* 1467 */ + 9, + /* SUB16rr */ + }, + { /* 1468 */ + 10, + /* SUB16rr_REV */ + }, + { /* 1469 */ + 2, + /* SUB32i32 */ + }, + { /* 1470 */ + 3, + /* SUB32mi */ + }, + { /* 1471 */ + 4, + /* SUB32mi8 */ + }, + { /* 1472 */ + 5, + /* SUB32mr */ + }, + { /* 1473 */ + 6, + /* SUB32ri */ + }, + { /* 1474 */ + 7, + /* SUB32ri8 */ + }, + { /* 1475 */ + 8, + /* SUB32rm */ + }, + { /* 1476 */ + 9, + /* SUB32rr */ + }, + { /* 1477 */ + 10, + /* SUB32rr_REV */ + }, + { /* 1478 */ + 11, + /* SUB64i32 */ + }, + { /* 1479 */ + 12, + /* SUB64mi32 */ + }, + { /* 1480 */ + 4, + /* SUB64mi8 */ + }, + { /* 1481 */ + 13, + /* SUB64mr */ + }, + { /* 1482 */ + 14, + /* SUB64ri32 */ + }, + { /* 1483 */ + 15, + /* SUB64ri8 */ + }, + { /* 1484 */ + 16, + /* SUB64rm */ + }, + { /* 1485 */ + 17, + /* SUB64rr */ + }, + { /* 1486 */ + 18, + /* SUB64rr_REV */ + }, + { /* 1487 */ + 1, + /* SUB8i8 */ + }, + { /* 1488 */ + 4, + /* SUB8mi */ + }, + { /* 1489 */ + 4, + /* SUB8mi8 */ + }, + { /* 1490 */ + 19, + /* SUB8mr */ + }, + { /* 1491 */ + 20, + /* SUB8ri */ + }, + { /* 1492 */ + 20, + /* SUB8ri8 */ + }, + { /* 1493 */ + 21, + /* SUB8rm */ + }, + { /* 1494 */ + 22, + /* SUB8rr */ + }, + { /* 1495 */ + 23, + /* SUB8rr_REV */ + }, + { /* 1496 */ + 0, + /* SWAPGS */ + }, + { /* 1497 */ + 0, + /* SYSCALL */ + }, + { /* 1498 */ + 0, + /* SYSENTER */ + }, + { /* 1499 */ + 0, + /* SYSEXIT */ + }, + { /* 1500 */ + 0, + /* SYSEXIT64 */ + }, + { /* 1501 */ + 0, + /* SYSRET */ + }, + { /* 1502 */ + 0, + /* SYSRET64 */ + }, + { /* 1503 */ + 40, + /* T1MSKC32rm */ + }, + { /* 1504 */ + 41, + /* T1MSKC32rr */ + }, + { /* 1505 */ + 42, + /* T1MSKC64rm */ + }, + { /* 1506 */ + 43, + /* T1MSKC64rr */ + }, + { /* 1507 */ + 2, + /* TEST16i16 */ + }, + { /* 1508 */ + 3, + /* TEST16mi */ + }, + { /* 1509 */ + 3, + /* TEST16mi_alt */ + }, + { /* 1510 */ + 5, + /* TEST16mr */ + }, + { /* 1511 */ + 59, + /* TEST16ri */ + }, + { /* 1512 */ + 59, + /* TEST16ri_alt */ + }, + { /* 1513 */ + 51, + /* TEST16rr */ + }, + { /* 1514 */ + 2, + /* TEST32i32 */ + }, + { /* 1515 */ + 3, + /* TEST32mi */ + }, + { /* 1516 */ + 3, + /* TEST32mi_alt */ + }, + { /* 1517 */ + 5, + /* TEST32mr */ + }, + { /* 1518 */ + 59, + /* TEST32ri */ + }, + { /* 1519 */ + 59, + /* TEST32ri_alt */ + }, + { /* 1520 */ + 51, + /* TEST32rr */ + }, + { /* 1521 */ + 11, + /* TEST64i32 */ + }, + { /* 1522 */ + 12, + /* TEST64mi32 */ + }, + { /* 1523 */ + 12, + /* TEST64mi32_alt */ + }, + { /* 1524 */ + 13, + /* TEST64mr */ + }, + { /* 1525 */ + 60, + /* TEST64ri32 */ + }, + { /* 1526 */ + 60, + /* TEST64ri32_alt */ + }, + { /* 1527 */ + 53, + /* TEST64rr */ + }, + { /* 1528 */ + 1, + /* TEST8i8 */ + }, + { /* 1529 */ + 4, + /* TEST8mi */ + }, + { /* 1530 */ + 4, + /* TEST8mi_alt */ + }, + { /* 1531 */ + 19, + /* TEST8mr */ + }, + { /* 1532 */ + 61, + /* TEST8ri */ + }, + { /* 1533 */ + 61, + /* TEST8ri_alt */ + }, + { /* 1534 */ + 63, + /* TEST8rr */ + }, + { /* 1535 */ + 80, + /* TPAUSE */ + }, + { /* 1536 */ + 44, + /* TZCNT16rm */ + }, + { /* 1537 */ + 45, + /* TZCNT16rr */ + }, + { /* 1538 */ + 44, + /* TZCNT32rm */ + }, + { /* 1539 */ + 45, + /* TZCNT32rr */ + }, + { /* 1540 */ + 46, + /* TZCNT64rm */ + }, + { /* 1541 */ + 47, + /* TZCNT64rr */ + }, + { /* 1542 */ + 40, + /* TZMSK32rm */ + }, + { /* 1543 */ + 41, + /* TZMSK32rr */ + }, + { /* 1544 */ + 42, + /* TZMSK64rm */ + }, + { /* 1545 */ + 43, + /* TZMSK64rr */ + }, + { /* 1546 */ + 0, + /* UD0 */ + }, + { /* 1547 */ + 0, + /* UD1 */ + }, + { /* 1548 */ + 0, + /* UD2 */ + }, + { /* 1549 */ + 86, + /* UMONITOR16 */ + }, + { /* 1550 */ + 80, + /* UMONITOR32 */ + }, + { /* 1551 */ + 57, + /* UMONITOR64 */ + }, + { /* 1552 */ + 80, + /* UMWAIT */ + }, + { /* 1553 */ + 54, + /* VERRm */ + }, + { /* 1554 */ + 86, + /* VERRr */ + }, + { /* 1555 */ + 54, + /* VERWm */ + }, + { /* 1556 */ + 86, + /* VERWr */ + }, + { /* 1557 */ + 0, + /* VMCALL */ + }, + { /* 1558 */ + 54, + /* VMCLEARm */ + }, + { /* 1559 */ + 0, + /* VMFUNC */ + }, + { /* 1560 */ + 0, + /* VMLAUNCH */ + }, + { /* 1561 */ + 0, + /* VMLOAD32 */ + }, + { /* 1562 */ + 0, + /* VMLOAD64 */ + }, + { /* 1563 */ + 0, + /* VMMCALL */ + }, + { /* 1564 */ + 54, + /* VMPTRLDm */ + }, + { /* 1565 */ + 54, + /* VMPTRSTm */ + }, + { /* 1566 */ + 112, + /* VMREAD32mr */ + }, + { /* 1567 */ + 132, + /* VMREAD32rr */ + }, + { /* 1568 */ + 13, + /* VMREAD64mr */ + }, + { /* 1569 */ + 53, + /* VMREAD64rr */ + }, + { /* 1570 */ + 0, + /* VMRESUME */ + }, + { /* 1571 */ + 0, + /* VMRUN32 */ + }, + { /* 1572 */ + 0, + /* VMRUN64 */ + }, + { /* 1573 */ + 0, + /* VMSAVE32 */ + }, + { /* 1574 */ + 0, + /* VMSAVE64 */ + }, + { /* 1575 */ + 82, + /* VMWRITE32rm */ + }, + { /* 1576 */ + 133, + /* VMWRITE32rr */ + }, + { /* 1577 */ + 46, + /* VMWRITE64rm */ + }, + { /* 1578 */ + 47, + /* VMWRITE64rr */ + }, + { /* 1579 */ + 0, + /* VMXOFF */ + }, + { /* 1580 */ + 54, + /* VMXON */ + }, + { /* 1581 */ + 0, + /* WBINVD */ + }, + { /* 1582 */ + 0, + /* WBNOINVD */ + }, + { /* 1583 */ + 80, + /* WRFSBASE */ + }, + { /* 1584 */ + 57, + /* WRFSBASE64 */ + }, + { /* 1585 */ + 80, + /* WRGSBASE */ + }, + { /* 1586 */ + 57, + /* WRGSBASE64 */ + }, + { /* 1587 */ + 0, + /* WRMSR */ + }, + { /* 1588 */ + 0, + /* WRPKRUr */ + }, + { /* 1589 */ + 112, + /* WRSSD */ + }, + { /* 1590 */ + 13, + /* WRSSQ */ + }, + { /* 1591 */ + 112, + /* WRUSSD */ + }, + { /* 1592 */ + 13, + /* WRUSSQ */ + }, + { /* 1593 */ + 8, + /* XADD16rm */ + }, + { /* 1594 */ + 134, + /* XADD16rr */ + }, + { /* 1595 */ + 8, + /* XADD32rm */ + }, + { /* 1596 */ + 134, + /* XADD32rr */ + }, + { /* 1597 */ + 16, + /* XADD64rm */ + }, + { /* 1598 */ + 135, + /* XADD64rr */ + }, + { /* 1599 */ + 21, + /* XADD8rm */ + }, + { /* 1600 */ + 136, + /* XADD8rr */ + }, + { /* 1601 */ + 48, + /* XCHG16ar */ + }, + { /* 1602 */ + 8, + /* XCHG16rm */ + }, + { /* 1603 */ + 137, + /* XCHG16rr */ + }, + { /* 1604 */ + 48, + /* XCHG32ar */ + }, + { /* 1605 */ + 8, + /* XCHG32rm */ + }, + { /* 1606 */ + 137, + /* XCHG32rr */ + }, + { /* 1607 */ + 49, + /* XCHG64ar */ + }, + { /* 1608 */ + 16, + /* XCHG64rm */ + }, + { /* 1609 */ + 138, + /* XCHG64rr */ + }, + { /* 1610 */ + 21, + /* XCHG8rm */ + }, + { /* 1611 */ + 139, + /* XCHG8rr */ + }, + { /* 1612 */ + 0, + /* XCRYPTCBC */ + }, + { /* 1613 */ + 0, + /* XCRYPTCFB */ + }, + { /* 1614 */ + 0, + /* XCRYPTCTR */ + }, + { /* 1615 */ + 0, + /* XCRYPTECB */ + }, + { /* 1616 */ + 0, + /* XCRYPTOFB */ + }, + { /* 1617 */ + 0, + /* XGETBV */ + }, + { /* 1618 */ + 0, + /* XLAT */ + }, + { /* 1619 */ + 2, + /* XOR16i16 */ + }, + { /* 1620 */ + 3, + /* XOR16mi */ + }, + { /* 1621 */ + 4, + /* XOR16mi8 */ + }, + { /* 1622 */ + 5, + /* XOR16mr */ + }, + { /* 1623 */ + 6, + /* XOR16ri */ + }, + { /* 1624 */ + 7, + /* XOR16ri8 */ + }, + { /* 1625 */ + 8, + /* XOR16rm */ + }, + { /* 1626 */ + 9, + /* XOR16rr */ + }, + { /* 1627 */ + 10, + /* XOR16rr_REV */ + }, + { /* 1628 */ + 2, + /* XOR32i32 */ + }, + { /* 1629 */ + 3, + /* XOR32mi */ + }, + { /* 1630 */ + 4, + /* XOR32mi8 */ + }, + { /* 1631 */ + 5, + /* XOR32mr */ + }, + { /* 1632 */ + 6, + /* XOR32ri */ + }, + { /* 1633 */ + 7, + /* XOR32ri8 */ + }, + { /* 1634 */ + 8, + /* XOR32rm */ + }, + { /* 1635 */ + 9, + /* XOR32rr */ + }, + { /* 1636 */ + 10, + /* XOR32rr_REV */ + }, + { /* 1637 */ + 11, + /* XOR64i32 */ + }, + { /* 1638 */ + 12, + /* XOR64mi32 */ + }, + { /* 1639 */ + 4, + /* XOR64mi8 */ + }, + { /* 1640 */ + 13, + /* XOR64mr */ + }, + { /* 1641 */ + 14, + /* XOR64ri32 */ + }, + { /* 1642 */ + 15, + /* XOR64ri8 */ + }, + { /* 1643 */ + 16, + /* XOR64rm */ + }, + { /* 1644 */ + 17, + /* XOR64rr */ + }, + { /* 1645 */ + 18, + /* XOR64rr_REV */ + }, + { /* 1646 */ + 1, + /* XOR8i8 */ + }, + { /* 1647 */ + 4, + /* XOR8mi */ + }, + { /* 1648 */ + 4, + /* XOR8mi8 */ + }, + { /* 1649 */ + 19, + /* XOR8mr */ + }, + { /* 1650 */ + 20, + /* XOR8ri */ + }, + { /* 1651 */ + 20, + /* XOR8ri8 */ + }, + { /* 1652 */ + 21, + /* XOR8rm */ + }, + { /* 1653 */ + 22, + /* XOR8rr */ + }, + { /* 1654 */ + 23, + /* XOR8rr_REV */ + }, + { /* 1655 */ + 54, + /* XRSTOR */ + }, + { /* 1656 */ + 54, + /* XRSTOR64 */ + }, + { /* 1657 */ + 54, + /* XRSTORS */ + }, + { /* 1658 */ + 54, + /* XRSTORS64 */ + }, + { /* 1659 */ + 54, + /* XSAVE */ + }, + { /* 1660 */ + 54, + /* XSAVE64 */ + }, + { /* 1661 */ + 54, + /* XSAVEC */ + }, + { /* 1662 */ + 54, + /* XSAVEC64 */ + }, + { /* 1663 */ + 54, + /* XSAVEOPT */ + }, + { /* 1664 */ + 54, + /* XSAVEOPT64 */ + }, + { /* 1665 */ + 54, + /* XSAVES */ + }, + { /* 1666 */ + 54, + /* XSAVES64 */ + }, + { /* 1667 */ + 0, + /* XSETBV */ + }, + { /* 1668 */ + 0, + /* XSHA1 */ + }, + { /* 1669 */ + 0, + /* XSHA256 */ + }, + { /* 1670 */ + 0, + /* XSTORE */ + }, +}; + +static const uint8_t x86DisassemblerContexts[16384] = { + IC, /* 0 */ + IC_64BIT, /* 1 */ + IC_XS, /* 2 */ + IC_64BIT_XS, /* 3 */ + IC_XD, /* 4 */ + IC_64BIT_XD, /* 5 */ + IC_XS, /* 6 */ + IC_64BIT_XS, /* 7 */ + IC, /* 8 */ + IC_64BIT_REXW, /* 9 */ + IC_XS, /* 10 */ + IC_64BIT_REXW_XS, /* 11 */ + IC_XD, /* 12 */ + IC_64BIT_REXW_XD, /* 13 */ + IC_XS, /* 14 */ + IC_64BIT_REXW_XS, /* 15 */ + IC_OPSIZE, /* 16 */ + IC_64BIT_OPSIZE, /* 17 */ + IC_XS_OPSIZE, /* 18 */ + IC_64BIT_XS_OPSIZE, /* 19 */ + IC_XD_OPSIZE, /* 20 */ + IC_64BIT_XD_OPSIZE, /* 21 */ + IC_XS_OPSIZE, /* 22 */ + IC_64BIT_XD_OPSIZE, /* 23 */ + IC_OPSIZE, /* 24 */ + IC_64BIT_REXW_OPSIZE, /* 25 */ + IC_XS_OPSIZE, /* 26 */ + IC_64BIT_REXW_XS, /* 27 */ + IC_XD_OPSIZE, /* 28 */ + IC_64BIT_REXW_XD, /* 29 */ + IC_XS_OPSIZE, /* 30 */ + IC_64BIT_REXW_XS, /* 31 */ + IC_ADSIZE, /* 32 */ + IC_64BIT_ADSIZE, /* 33 */ + IC_XS_ADSIZE, /* 34 */ + IC_64BIT_XS_ADSIZE, /* 35 */ + IC_XD_ADSIZE, /* 36 */ + IC_64BIT_XD_ADSIZE, /* 37 */ + IC_XS_ADSIZE, /* 38 */ + IC_64BIT_XD_ADSIZE, /* 39 */ + IC_ADSIZE, /* 40 */ + IC_64BIT_REXW_ADSIZE, /* 41 */ + IC_XS_ADSIZE, /* 42 */ + IC_64BIT_REXW_XS, /* 43 */ + IC_XD_ADSIZE, /* 44 */ + IC_64BIT_REXW_XD, /* 45 */ + IC_XS_ADSIZE, /* 46 */ + IC_64BIT_REXW_XS, /* 47 */ + IC_OPSIZE_ADSIZE, /* 48 */ + IC_64BIT_OPSIZE_ADSIZE, /* 49 */ + IC_XS_OPSIZE, /* 50 */ + IC_64BIT_XS_OPSIZE, /* 51 */ + IC_XD_OPSIZE, /* 52 */ + IC_64BIT_XD_OPSIZE, /* 53 */ + IC_XS_OPSIZE, /* 54 */ + IC_64BIT_XD_OPSIZE, /* 55 */ + IC_OPSIZE_ADSIZE, /* 56 */ + IC_64BIT_REXW_OPSIZE, /* 57 */ + IC_XS_OPSIZE, /* 58 */ + IC_64BIT_REXW_XS, /* 59 */ + IC_XD_OPSIZE, /* 60 */ + IC_64BIT_REXW_XD, /* 61 */ + IC_XS_OPSIZE, /* 62 */ + IC_64BIT_REXW_XS, /* 63 */ + IC_VEX, /* 64 */ + IC_VEX, /* 65 */ + IC_VEX_XS, /* 66 */ + IC_VEX_XS, /* 67 */ + IC_VEX_XD, /* 68 */ + IC_VEX_XD, /* 69 */ + IC_VEX_XD, /* 70 */ + IC_VEX_XD, /* 71 */ + IC_VEX_W, /* 72 */ + IC_VEX_W, /* 73 */ + IC_VEX_W_XS, /* 74 */ + IC_VEX_W_XS, /* 75 */ + IC_VEX_W_XD, /* 76 */ + IC_VEX_W_XD, /* 77 */ + IC_VEX_W_XD, /* 78 */ + IC_VEX_W_XD, /* 79 */ + IC_VEX_OPSIZE, /* 80 */ + IC_VEX_OPSIZE, /* 81 */ + IC_VEX_OPSIZE, /* 82 */ + IC_VEX_OPSIZE, /* 83 */ + IC_VEX_OPSIZE, /* 84 */ + IC_VEX_OPSIZE, /* 85 */ + IC_VEX_OPSIZE, /* 86 */ + IC_VEX_OPSIZE, /* 87 */ + IC_VEX_W_OPSIZE, /* 88 */ + IC_VEX_W_OPSIZE, /* 89 */ + IC_VEX_W_OPSIZE, /* 90 */ + IC_VEX_W_OPSIZE, /* 91 */ + IC_VEX_W_OPSIZE, /* 92 */ + IC_VEX_W_OPSIZE, /* 93 */ + IC_VEX_W_OPSIZE, /* 94 */ + IC_VEX_W_OPSIZE, /* 95 */ + IC_VEX, /* 96 */ + IC_VEX, /* 97 */ + IC_VEX_XS, /* 98 */ + IC_VEX_XS, /* 99 */ + IC_VEX_XD, /* 100 */ + IC_VEX_XD, /* 101 */ + IC_VEX_XD, /* 102 */ + IC_VEX_XD, /* 103 */ + IC_VEX_W, /* 104 */ + IC_VEX_W, /* 105 */ + IC_VEX_W_XS, /* 106 */ + IC_VEX_W_XS, /* 107 */ + IC_VEX_W_XD, /* 108 */ + IC_VEX_W_XD, /* 109 */ + IC_VEX_W_XD, /* 110 */ + IC_VEX_W_XD, /* 111 */ + IC_VEX_OPSIZE, /* 112 */ + IC_VEX_OPSIZE, /* 113 */ + IC_VEX_OPSIZE, /* 114 */ + IC_VEX_OPSIZE, /* 115 */ + IC_VEX_OPSIZE, /* 116 */ + IC_VEX_OPSIZE, /* 117 */ + IC_VEX_OPSIZE, /* 118 */ + IC_VEX_OPSIZE, /* 119 */ + IC_VEX_W_OPSIZE, /* 120 */ + IC_VEX_W_OPSIZE, /* 121 */ + IC_VEX_W_OPSIZE, /* 122 */ + IC_VEX_W_OPSIZE, /* 123 */ + IC_VEX_W_OPSIZE, /* 124 */ + IC_VEX_W_OPSIZE, /* 125 */ + IC_VEX_W_OPSIZE, /* 126 */ + IC_VEX_W_OPSIZE, /* 127 */ + IC_VEX_L, /* 128 */ + IC_VEX_L, /* 129 */ + IC_VEX_L_XS, /* 130 */ + IC_VEX_L_XS, /* 131 */ + IC_VEX_L_XD, /* 132 */ + IC_VEX_L_XD, /* 133 */ + IC_VEX_L_XD, /* 134 */ + IC_VEX_L_XD, /* 135 */ + IC_VEX_L_W, /* 136 */ + IC_VEX_L_W, /* 137 */ + IC_VEX_L_W_XS, /* 138 */ + IC_VEX_L_W_XS, /* 139 */ + IC_VEX_L_W_XD, /* 140 */ + IC_VEX_L_W_XD, /* 141 */ + IC_VEX_L_W_XD, /* 142 */ + IC_VEX_L_W_XD, /* 143 */ + IC_VEX_L_OPSIZE, /* 144 */ + IC_VEX_L_OPSIZE, /* 145 */ + IC_VEX_L_OPSIZE, /* 146 */ + IC_VEX_L_OPSIZE, /* 147 */ + IC_VEX_L_OPSIZE, /* 148 */ + IC_VEX_L_OPSIZE, /* 149 */ + IC_VEX_L_OPSIZE, /* 150 */ + IC_VEX_L_OPSIZE, /* 151 */ + IC_VEX_L_W_OPSIZE, /* 152 */ + IC_VEX_L_W_OPSIZE, /* 153 */ + IC_VEX_L_W_OPSIZE, /* 154 */ + IC_VEX_L_W_OPSIZE, /* 155 */ + IC_VEX_L_W_OPSIZE, /* 156 */ + IC_VEX_L_W_OPSIZE, /* 157 */ + IC_VEX_L_W_OPSIZE, /* 158 */ + IC_VEX_L_W_OPSIZE, /* 159 */ + IC_VEX_L, /* 160 */ + IC_VEX_L, /* 161 */ + IC_VEX_L_XS, /* 162 */ + IC_VEX_L_XS, /* 163 */ + IC_VEX_L_XD, /* 164 */ + IC_VEX_L_XD, /* 165 */ + IC_VEX_L_XD, /* 166 */ + IC_VEX_L_XD, /* 167 */ + IC_VEX_L_W, /* 168 */ + IC_VEX_L_W, /* 169 */ + IC_VEX_L_W_XS, /* 170 */ + IC_VEX_L_W_XS, /* 171 */ + IC_VEX_L_W_XD, /* 172 */ + IC_VEX_L_W_XD, /* 173 */ + IC_VEX_L_W_XD, /* 174 */ + IC_VEX_L_W_XD, /* 175 */ + IC_VEX_L_OPSIZE, /* 176 */ + IC_VEX_L_OPSIZE, /* 177 */ + IC_VEX_L_OPSIZE, /* 178 */ + IC_VEX_L_OPSIZE, /* 179 */ + IC_VEX_L_OPSIZE, /* 180 */ + IC_VEX_L_OPSIZE, /* 181 */ + IC_VEX_L_OPSIZE, /* 182 */ + IC_VEX_L_OPSIZE, /* 183 */ + IC_VEX_L_W_OPSIZE, /* 184 */ + IC_VEX_L_W_OPSIZE, /* 185 */ + IC_VEX_L_W_OPSIZE, /* 186 */ + IC_VEX_L_W_OPSIZE, /* 187 */ + IC_VEX_L_W_OPSIZE, /* 188 */ + IC_VEX_L_W_OPSIZE, /* 189 */ + IC_VEX_L_W_OPSIZE, /* 190 */ + IC_VEX_L_W_OPSIZE, /* 191 */ + IC_VEX_L, /* 192 */ + IC_VEX_L, /* 193 */ + IC_VEX_L_XS, /* 194 */ + IC_VEX_L_XS, /* 195 */ + IC_VEX_L_XD, /* 196 */ + IC_VEX_L_XD, /* 197 */ + IC_VEX_L_XD, /* 198 */ + IC_VEX_L_XD, /* 199 */ + IC_VEX_L_W, /* 200 */ + IC_VEX_L_W, /* 201 */ + IC_VEX_L_W_XS, /* 202 */ + IC_VEX_L_W_XS, /* 203 */ + IC_VEX_L_W_XD, /* 204 */ + IC_VEX_L_W_XD, /* 205 */ + IC_VEX_L_W_XD, /* 206 */ + IC_VEX_L_W_XD, /* 207 */ + IC_VEX_L_OPSIZE, /* 208 */ + IC_VEX_L_OPSIZE, /* 209 */ + IC_VEX_L_OPSIZE, /* 210 */ + IC_VEX_L_OPSIZE, /* 211 */ + IC_VEX_L_OPSIZE, /* 212 */ + IC_VEX_L_OPSIZE, /* 213 */ + IC_VEX_L_OPSIZE, /* 214 */ + IC_VEX_L_OPSIZE, /* 215 */ + IC_VEX_L_W_OPSIZE, /* 216 */ + IC_VEX_L_W_OPSIZE, /* 217 */ + IC_VEX_L_W_OPSIZE, /* 218 */ + IC_VEX_L_W_OPSIZE, /* 219 */ + IC_VEX_L_W_OPSIZE, /* 220 */ + IC_VEX_L_W_OPSIZE, /* 221 */ + IC_VEX_L_W_OPSIZE, /* 222 */ + IC_VEX_L_W_OPSIZE, /* 223 */ + IC_VEX_L, /* 224 */ + IC_VEX_L, /* 225 */ + IC_VEX_L_XS, /* 226 */ + IC_VEX_L_XS, /* 227 */ + IC_VEX_L_XD, /* 228 */ + IC_VEX_L_XD, /* 229 */ + IC_VEX_L_XD, /* 230 */ + IC_VEX_L_XD, /* 231 */ + IC_VEX_L_W, /* 232 */ + IC_VEX_L_W, /* 233 */ + IC_VEX_L_W_XS, /* 234 */ + IC_VEX_L_W_XS, /* 235 */ + IC_VEX_L_W_XD, /* 236 */ + IC_VEX_L_W_XD, /* 237 */ + IC_VEX_L_W_XD, /* 238 */ + IC_VEX_L_W_XD, /* 239 */ + IC_VEX_L_OPSIZE, /* 240 */ + IC_VEX_L_OPSIZE, /* 241 */ + IC_VEX_L_OPSIZE, /* 242 */ + IC_VEX_L_OPSIZE, /* 243 */ + IC_VEX_L_OPSIZE, /* 244 */ + IC_VEX_L_OPSIZE, /* 245 */ + IC_VEX_L_OPSIZE, /* 246 */ + IC_VEX_L_OPSIZE, /* 247 */ + IC_VEX_L_W_OPSIZE, /* 248 */ + IC_VEX_L_W_OPSIZE, /* 249 */ + IC_VEX_L_W_OPSIZE, /* 250 */ + IC_VEX_L_W_OPSIZE, /* 251 */ + IC_VEX_L_W_OPSIZE, /* 252 */ + IC_VEX_L_W_OPSIZE, /* 253 */ + IC_VEX_L_W_OPSIZE, /* 254 */ + IC_VEX_L_W_OPSIZE, /* 255 */ + IC_EVEX, /* 256 */ + IC_EVEX, /* 257 */ + IC_EVEX_XS, /* 258 */ + IC_EVEX_XS, /* 259 */ + IC_EVEX_XD, /* 260 */ + IC_EVEX_XD, /* 261 */ + IC_EVEX_XD, /* 262 */ + IC_EVEX_XD, /* 263 */ + IC_EVEX_W, /* 264 */ + IC_EVEX_W, /* 265 */ + IC_EVEX_W_XS, /* 266 */ + IC_EVEX_W_XS, /* 267 */ + IC_EVEX_W_XD, /* 268 */ + IC_EVEX_W_XD, /* 269 */ + IC_EVEX_W_XD, /* 270 */ + IC_EVEX_W_XD, /* 271 */ + IC_EVEX_OPSIZE, /* 272 */ + IC_EVEX_OPSIZE, /* 273 */ + IC_EVEX_OPSIZE, /* 274 */ + IC_EVEX_OPSIZE, /* 275 */ + IC_EVEX_OPSIZE, /* 276 */ + IC_EVEX_OPSIZE, /* 277 */ + IC_EVEX_OPSIZE, /* 278 */ + IC_EVEX_OPSIZE, /* 279 */ + IC_EVEX_W_OPSIZE, /* 280 */ + IC_EVEX_W_OPSIZE, /* 281 */ + IC_EVEX_W_OPSIZE, /* 282 */ + IC_EVEX_W_OPSIZE, /* 283 */ + IC_EVEX_W_OPSIZE, /* 284 */ + IC_EVEX_W_OPSIZE, /* 285 */ + IC_EVEX_W_OPSIZE, /* 286 */ + IC_EVEX_W_OPSIZE, /* 287 */ + IC_EVEX, /* 288 */ + IC_EVEX, /* 289 */ + IC_EVEX_XS, /* 290 */ + IC_EVEX_XS, /* 291 */ + IC_EVEX_XD, /* 292 */ + IC_EVEX_XD, /* 293 */ + IC_EVEX_XD, /* 294 */ + IC_EVEX_XD, /* 295 */ + IC_EVEX_W, /* 296 */ + IC_EVEX_W, /* 297 */ + IC_EVEX_W_XS, /* 298 */ + IC_EVEX_W_XS, /* 299 */ + IC_EVEX_W_XD, /* 300 */ + IC_EVEX_W_XD, /* 301 */ + IC_EVEX_W_XD, /* 302 */ + IC_EVEX_W_XD, /* 303 */ + IC_EVEX_OPSIZE, /* 304 */ + IC_EVEX_OPSIZE, /* 305 */ + IC_EVEX_OPSIZE, /* 306 */ + IC_EVEX_OPSIZE, /* 307 */ + IC_EVEX_OPSIZE, /* 308 */ + IC_EVEX_OPSIZE, /* 309 */ + IC_EVEX_OPSIZE, /* 310 */ + IC_EVEX_OPSIZE, /* 311 */ + IC_EVEX_W_OPSIZE, /* 312 */ + IC_EVEX_W_OPSIZE, /* 313 */ + IC_EVEX_W_OPSIZE, /* 314 */ + IC_EVEX_W_OPSIZE, /* 315 */ + IC_EVEX_W_OPSIZE, /* 316 */ + IC_EVEX_W_OPSIZE, /* 317 */ + IC_EVEX_W_OPSIZE, /* 318 */ + IC_EVEX_W_OPSIZE, /* 319 */ + IC_EVEX, /* 320 */ + IC_EVEX, /* 321 */ + IC_EVEX_XS, /* 322 */ + IC_EVEX_XS, /* 323 */ + IC_EVEX_XD, /* 324 */ + IC_EVEX_XD, /* 325 */ + IC_EVEX_XD, /* 326 */ + IC_EVEX_XD, /* 327 */ + IC_EVEX_W, /* 328 */ + IC_EVEX_W, /* 329 */ + IC_EVEX_W_XS, /* 330 */ + IC_EVEX_W_XS, /* 331 */ + IC_EVEX_W_XD, /* 332 */ + IC_EVEX_W_XD, /* 333 */ + IC_EVEX_W_XD, /* 334 */ + IC_EVEX_W_XD, /* 335 */ + IC_EVEX_OPSIZE, /* 336 */ + IC_EVEX_OPSIZE, /* 337 */ + IC_EVEX_OPSIZE, /* 338 */ + IC_EVEX_OPSIZE, /* 339 */ + IC_EVEX_OPSIZE, /* 340 */ + IC_EVEX_OPSIZE, /* 341 */ + IC_EVEX_OPSIZE, /* 342 */ + IC_EVEX_OPSIZE, /* 343 */ + IC_EVEX_W_OPSIZE, /* 344 */ + IC_EVEX_W_OPSIZE, /* 345 */ + IC_EVEX_W_OPSIZE, /* 346 */ + IC_EVEX_W_OPSIZE, /* 347 */ + IC_EVEX_W_OPSIZE, /* 348 */ + IC_EVEX_W_OPSIZE, /* 349 */ + IC_EVEX_W_OPSIZE, /* 350 */ + IC_EVEX_W_OPSIZE, /* 351 */ + IC_EVEX, /* 352 */ + IC_EVEX, /* 353 */ + IC_EVEX_XS, /* 354 */ + IC_EVEX_XS, /* 355 */ + IC_EVEX_XD, /* 356 */ + IC_EVEX_XD, /* 357 */ + IC_EVEX_XD, /* 358 */ + IC_EVEX_XD, /* 359 */ + IC_EVEX_W, /* 360 */ + IC_EVEX_W, /* 361 */ + IC_EVEX_W_XS, /* 362 */ + IC_EVEX_W_XS, /* 363 */ + IC_EVEX_W_XD, /* 364 */ + IC_EVEX_W_XD, /* 365 */ + IC_EVEX_W_XD, /* 366 */ + IC_EVEX_W_XD, /* 367 */ + IC_EVEX_OPSIZE, /* 368 */ + IC_EVEX_OPSIZE, /* 369 */ + IC_EVEX_OPSIZE, /* 370 */ + IC_EVEX_OPSIZE, /* 371 */ + IC_EVEX_OPSIZE, /* 372 */ + IC_EVEX_OPSIZE, /* 373 */ + IC_EVEX_OPSIZE, /* 374 */ + IC_EVEX_OPSIZE, /* 375 */ + IC_EVEX_W_OPSIZE, /* 376 */ + IC_EVEX_W_OPSIZE, /* 377 */ + IC_EVEX_W_OPSIZE, /* 378 */ + IC_EVEX_W_OPSIZE, /* 379 */ + IC_EVEX_W_OPSIZE, /* 380 */ + IC_EVEX_W_OPSIZE, /* 381 */ + IC_EVEX_W_OPSIZE, /* 382 */ + IC_EVEX_W_OPSIZE, /* 383 */ + IC_EVEX, /* 384 */ + IC_EVEX, /* 385 */ + IC_EVEX_XS, /* 386 */ + IC_EVEX_XS, /* 387 */ + IC_EVEX_XD, /* 388 */ + IC_EVEX_XD, /* 389 */ + IC_EVEX_XD, /* 390 */ + IC_EVEX_XD, /* 391 */ + IC_EVEX_W, /* 392 */ + IC_EVEX_W, /* 393 */ + IC_EVEX_W_XS, /* 394 */ + IC_EVEX_W_XS, /* 395 */ + IC_EVEX_W_XD, /* 396 */ + IC_EVEX_W_XD, /* 397 */ + IC_EVEX_W_XD, /* 398 */ + IC_EVEX_W_XD, /* 399 */ + IC_EVEX_OPSIZE, /* 400 */ + IC_EVEX_OPSIZE, /* 401 */ + IC_EVEX_OPSIZE, /* 402 */ + IC_EVEX_OPSIZE, /* 403 */ + IC_EVEX_OPSIZE, /* 404 */ + IC_EVEX_OPSIZE, /* 405 */ + IC_EVEX_OPSIZE, /* 406 */ + IC_EVEX_OPSIZE, /* 407 */ + IC_EVEX_W_OPSIZE, /* 408 */ + IC_EVEX_W_OPSIZE, /* 409 */ + IC_EVEX_W_OPSIZE, /* 410 */ + IC_EVEX_W_OPSIZE, /* 411 */ + IC_EVEX_W_OPSIZE, /* 412 */ + IC_EVEX_W_OPSIZE, /* 413 */ + IC_EVEX_W_OPSIZE, /* 414 */ + IC_EVEX_W_OPSIZE, /* 415 */ + IC_EVEX, /* 416 */ + IC_EVEX, /* 417 */ + IC_EVEX_XS, /* 418 */ + IC_EVEX_XS, /* 419 */ + IC_EVEX_XD, /* 420 */ + IC_EVEX_XD, /* 421 */ + IC_EVEX_XD, /* 422 */ + IC_EVEX_XD, /* 423 */ + IC_EVEX_W, /* 424 */ + IC_EVEX_W, /* 425 */ + IC_EVEX_W_XS, /* 426 */ + IC_EVEX_W_XS, /* 427 */ + IC_EVEX_W_XD, /* 428 */ + IC_EVEX_W_XD, /* 429 */ + IC_EVEX_W_XD, /* 430 */ + IC_EVEX_W_XD, /* 431 */ + IC_EVEX_OPSIZE, /* 432 */ + IC_EVEX_OPSIZE, /* 433 */ + IC_EVEX_OPSIZE, /* 434 */ + IC_EVEX_OPSIZE, /* 435 */ + IC_EVEX_OPSIZE, /* 436 */ + IC_EVEX_OPSIZE, /* 437 */ + IC_EVEX_OPSIZE, /* 438 */ + IC_EVEX_OPSIZE, /* 439 */ + IC_EVEX_W_OPSIZE, /* 440 */ + IC_EVEX_W_OPSIZE, /* 441 */ + IC_EVEX_W_OPSIZE, /* 442 */ + IC_EVEX_W_OPSIZE, /* 443 */ + IC_EVEX_W_OPSIZE, /* 444 */ + IC_EVEX_W_OPSIZE, /* 445 */ + IC_EVEX_W_OPSIZE, /* 446 */ + IC_EVEX_W_OPSIZE, /* 447 */ + IC_EVEX, /* 448 */ + IC_EVEX, /* 449 */ + IC_EVEX_XS, /* 450 */ + IC_EVEX_XS, /* 451 */ + IC_EVEX_XD, /* 452 */ + IC_EVEX_XD, /* 453 */ + IC_EVEX_XD, /* 454 */ + IC_EVEX_XD, /* 455 */ + IC_EVEX_W, /* 456 */ + IC_EVEX_W, /* 457 */ + IC_EVEX_W_XS, /* 458 */ + IC_EVEX_W_XS, /* 459 */ + IC_EVEX_W_XD, /* 460 */ + IC_EVEX_W_XD, /* 461 */ + IC_EVEX_W_XD, /* 462 */ + IC_EVEX_W_XD, /* 463 */ + IC_EVEX_OPSIZE, /* 464 */ + IC_EVEX_OPSIZE, /* 465 */ + IC_EVEX_OPSIZE, /* 466 */ + IC_EVEX_OPSIZE, /* 467 */ + IC_EVEX_OPSIZE, /* 468 */ + IC_EVEX_OPSIZE, /* 469 */ + IC_EVEX_OPSIZE, /* 470 */ + IC_EVEX_OPSIZE, /* 471 */ + IC_EVEX_W_OPSIZE, /* 472 */ + IC_EVEX_W_OPSIZE, /* 473 */ + IC_EVEX_W_OPSIZE, /* 474 */ + IC_EVEX_W_OPSIZE, /* 475 */ + IC_EVEX_W_OPSIZE, /* 476 */ + IC_EVEX_W_OPSIZE, /* 477 */ + IC_EVEX_W_OPSIZE, /* 478 */ + IC_EVEX_W_OPSIZE, /* 479 */ + IC_EVEX, /* 480 */ + IC_EVEX, /* 481 */ + IC_EVEX_XS, /* 482 */ + IC_EVEX_XS, /* 483 */ + IC_EVEX_XD, /* 484 */ + IC_EVEX_XD, /* 485 */ + IC_EVEX_XD, /* 486 */ + IC_EVEX_XD, /* 487 */ + IC_EVEX_W, /* 488 */ + IC_EVEX_W, /* 489 */ + IC_EVEX_W_XS, /* 490 */ + IC_EVEX_W_XS, /* 491 */ + IC_EVEX_W_XD, /* 492 */ + IC_EVEX_W_XD, /* 493 */ + IC_EVEX_W_XD, /* 494 */ + IC_EVEX_W_XD, /* 495 */ + IC_EVEX_OPSIZE, /* 496 */ + IC_EVEX_OPSIZE, /* 497 */ + IC_EVEX_OPSIZE, /* 498 */ + IC_EVEX_OPSIZE, /* 499 */ + IC_EVEX_OPSIZE, /* 500 */ + IC_EVEX_OPSIZE, /* 501 */ + IC_EVEX_OPSIZE, /* 502 */ + IC_EVEX_OPSIZE, /* 503 */ + IC_EVEX_W_OPSIZE, /* 504 */ + IC_EVEX_W_OPSIZE, /* 505 */ + IC_EVEX_W_OPSIZE, /* 506 */ + IC_EVEX_W_OPSIZE, /* 507 */ + IC_EVEX_W_OPSIZE, /* 508 */ + IC_EVEX_W_OPSIZE, /* 509 */ + IC_EVEX_W_OPSIZE, /* 510 */ + IC_EVEX_W_OPSIZE, /* 511 */ + IC, /* 512 */ + IC_64BIT, /* 513 */ + IC_XS, /* 514 */ + IC_64BIT_XS, /* 515 */ + IC_XD, /* 516 */ + IC_64BIT_XD, /* 517 */ + IC_XS, /* 518 */ + IC_64BIT_XS, /* 519 */ + IC, /* 520 */ + IC_64BIT_REXW, /* 521 */ + IC_XS, /* 522 */ + IC_64BIT_REXW_XS, /* 523 */ + IC_XD, /* 524 */ + IC_64BIT_REXW_XD, /* 525 */ + IC_XS, /* 526 */ + IC_64BIT_REXW_XS, /* 527 */ + IC_OPSIZE, /* 528 */ + IC_64BIT_OPSIZE, /* 529 */ + IC_XS_OPSIZE, /* 530 */ + IC_64BIT_XS_OPSIZE, /* 531 */ + IC_XD_OPSIZE, /* 532 */ + IC_64BIT_XD_OPSIZE, /* 533 */ + IC_XS_OPSIZE, /* 534 */ + IC_64BIT_XD_OPSIZE, /* 535 */ + IC_OPSIZE, /* 536 */ + IC_64BIT_REXW_OPSIZE, /* 537 */ + IC_XS_OPSIZE, /* 538 */ + IC_64BIT_REXW_XS, /* 539 */ + IC_XD_OPSIZE, /* 540 */ + IC_64BIT_REXW_XD, /* 541 */ + IC_XS_OPSIZE, /* 542 */ + IC_64BIT_REXW_XS, /* 543 */ + IC_ADSIZE, /* 544 */ + IC_64BIT_ADSIZE, /* 545 */ + IC_XS_ADSIZE, /* 546 */ + IC_64BIT_XS_ADSIZE, /* 547 */ + IC_XD_ADSIZE, /* 548 */ + IC_64BIT_XD_ADSIZE, /* 549 */ + IC_XS_ADSIZE, /* 550 */ + IC_64BIT_XD_ADSIZE, /* 551 */ + IC_ADSIZE, /* 552 */ + IC_64BIT_REXW_ADSIZE, /* 553 */ + IC_XS_ADSIZE, /* 554 */ + IC_64BIT_REXW_XS, /* 555 */ + IC_XD_ADSIZE, /* 556 */ + IC_64BIT_REXW_XD, /* 557 */ + IC_XS_ADSIZE, /* 558 */ + IC_64BIT_REXW_XS, /* 559 */ + IC_OPSIZE_ADSIZE, /* 560 */ + IC_64BIT_OPSIZE_ADSIZE, /* 561 */ + IC_XS_OPSIZE, /* 562 */ + IC_64BIT_XS_OPSIZE, /* 563 */ + IC_XD_OPSIZE, /* 564 */ + IC_64BIT_XD_OPSIZE, /* 565 */ + IC_XS_OPSIZE, /* 566 */ + IC_64BIT_XD_OPSIZE, /* 567 */ + IC_OPSIZE_ADSIZE, /* 568 */ + IC_64BIT_REXW_OPSIZE, /* 569 */ + IC_XS_OPSIZE, /* 570 */ + IC_64BIT_REXW_XS, /* 571 */ + IC_XD_OPSIZE, /* 572 */ + IC_64BIT_REXW_XD, /* 573 */ + IC_XS_OPSIZE, /* 574 */ + IC_64BIT_REXW_XS, /* 575 */ + IC_VEX, /* 576 */ + IC_VEX, /* 577 */ + IC_VEX_XS, /* 578 */ + IC_VEX_XS, /* 579 */ + IC_VEX_XD, /* 580 */ + IC_VEX_XD, /* 581 */ + IC_VEX_XD, /* 582 */ + IC_VEX_XD, /* 583 */ + IC_VEX_W, /* 584 */ + IC_VEX_W, /* 585 */ + IC_VEX_W_XS, /* 586 */ + IC_VEX_W_XS, /* 587 */ + IC_VEX_W_XD, /* 588 */ + IC_VEX_W_XD, /* 589 */ + IC_VEX_W_XD, /* 590 */ + IC_VEX_W_XD, /* 591 */ + IC_VEX_OPSIZE, /* 592 */ + IC_VEX_OPSIZE, /* 593 */ + IC_VEX_OPSIZE, /* 594 */ + IC_VEX_OPSIZE, /* 595 */ + IC_VEX_OPSIZE, /* 596 */ + IC_VEX_OPSIZE, /* 597 */ + IC_VEX_OPSIZE, /* 598 */ + IC_VEX_OPSIZE, /* 599 */ + IC_VEX_W_OPSIZE, /* 600 */ + IC_VEX_W_OPSIZE, /* 601 */ + IC_VEX_W_OPSIZE, /* 602 */ + IC_VEX_W_OPSIZE, /* 603 */ + IC_VEX_W_OPSIZE, /* 604 */ + IC_VEX_W_OPSIZE, /* 605 */ + IC_VEX_W_OPSIZE, /* 606 */ + IC_VEX_W_OPSIZE, /* 607 */ + IC_VEX, /* 608 */ + IC_VEX, /* 609 */ + IC_VEX_XS, /* 610 */ + IC_VEX_XS, /* 611 */ + IC_VEX_XD, /* 612 */ + IC_VEX_XD, /* 613 */ + IC_VEX_XD, /* 614 */ + IC_VEX_XD, /* 615 */ + IC_VEX_W, /* 616 */ + IC_VEX_W, /* 617 */ + IC_VEX_W_XS, /* 618 */ + IC_VEX_W_XS, /* 619 */ + IC_VEX_W_XD, /* 620 */ + IC_VEX_W_XD, /* 621 */ + IC_VEX_W_XD, /* 622 */ + IC_VEX_W_XD, /* 623 */ + IC_VEX_OPSIZE, /* 624 */ + IC_VEX_OPSIZE, /* 625 */ + IC_VEX_OPSIZE, /* 626 */ + IC_VEX_OPSIZE, /* 627 */ + IC_VEX_OPSIZE, /* 628 */ + IC_VEX_OPSIZE, /* 629 */ + IC_VEX_OPSIZE, /* 630 */ + IC_VEX_OPSIZE, /* 631 */ + IC_VEX_W_OPSIZE, /* 632 */ + IC_VEX_W_OPSIZE, /* 633 */ + IC_VEX_W_OPSIZE, /* 634 */ + IC_VEX_W_OPSIZE, /* 635 */ + IC_VEX_W_OPSIZE, /* 636 */ + IC_VEX_W_OPSIZE, /* 637 */ + IC_VEX_W_OPSIZE, /* 638 */ + IC_VEX_W_OPSIZE, /* 639 */ + IC_VEX_L, /* 640 */ + IC_VEX_L, /* 641 */ + IC_VEX_L_XS, /* 642 */ + IC_VEX_L_XS, /* 643 */ + IC_VEX_L_XD, /* 644 */ + IC_VEX_L_XD, /* 645 */ + IC_VEX_L_XD, /* 646 */ + IC_VEX_L_XD, /* 647 */ + IC_VEX_L_W, /* 648 */ + IC_VEX_L_W, /* 649 */ + IC_VEX_L_W_XS, /* 650 */ + IC_VEX_L_W_XS, /* 651 */ + IC_VEX_L_W_XD, /* 652 */ + IC_VEX_L_W_XD, /* 653 */ + IC_VEX_L_W_XD, /* 654 */ + IC_VEX_L_W_XD, /* 655 */ + IC_VEX_L_OPSIZE, /* 656 */ + IC_VEX_L_OPSIZE, /* 657 */ + IC_VEX_L_OPSIZE, /* 658 */ + IC_VEX_L_OPSIZE, /* 659 */ + IC_VEX_L_OPSIZE, /* 660 */ + IC_VEX_L_OPSIZE, /* 661 */ + IC_VEX_L_OPSIZE, /* 662 */ + IC_VEX_L_OPSIZE, /* 663 */ + IC_VEX_L_W_OPSIZE, /* 664 */ + IC_VEX_L_W_OPSIZE, /* 665 */ + IC_VEX_L_W_OPSIZE, /* 666 */ + IC_VEX_L_W_OPSIZE, /* 667 */ + IC_VEX_L_W_OPSIZE, /* 668 */ + IC_VEX_L_W_OPSIZE, /* 669 */ + IC_VEX_L_W_OPSIZE, /* 670 */ + IC_VEX_L_W_OPSIZE, /* 671 */ + IC_VEX_L, /* 672 */ + IC_VEX_L, /* 673 */ + IC_VEX_L_XS, /* 674 */ + IC_VEX_L_XS, /* 675 */ + IC_VEX_L_XD, /* 676 */ + IC_VEX_L_XD, /* 677 */ + IC_VEX_L_XD, /* 678 */ + IC_VEX_L_XD, /* 679 */ + IC_VEX_L_W, /* 680 */ + IC_VEX_L_W, /* 681 */ + IC_VEX_L_W_XS, /* 682 */ + IC_VEX_L_W_XS, /* 683 */ + IC_VEX_L_W_XD, /* 684 */ + IC_VEX_L_W_XD, /* 685 */ + IC_VEX_L_W_XD, /* 686 */ + IC_VEX_L_W_XD, /* 687 */ + IC_VEX_L_OPSIZE, /* 688 */ + IC_VEX_L_OPSIZE, /* 689 */ + IC_VEX_L_OPSIZE, /* 690 */ + IC_VEX_L_OPSIZE, /* 691 */ + IC_VEX_L_OPSIZE, /* 692 */ + IC_VEX_L_OPSIZE, /* 693 */ + IC_VEX_L_OPSIZE, /* 694 */ + IC_VEX_L_OPSIZE, /* 695 */ + IC_VEX_L_W_OPSIZE, /* 696 */ + IC_VEX_L_W_OPSIZE, /* 697 */ + IC_VEX_L_W_OPSIZE, /* 698 */ + IC_VEX_L_W_OPSIZE, /* 699 */ + IC_VEX_L_W_OPSIZE, /* 700 */ + IC_VEX_L_W_OPSIZE, /* 701 */ + IC_VEX_L_W_OPSIZE, /* 702 */ + IC_VEX_L_W_OPSIZE, /* 703 */ + IC_VEX_L, /* 704 */ + IC_VEX_L, /* 705 */ + IC_VEX_L_XS, /* 706 */ + IC_VEX_L_XS, /* 707 */ + IC_VEX_L_XD, /* 708 */ + IC_VEX_L_XD, /* 709 */ + IC_VEX_L_XD, /* 710 */ + IC_VEX_L_XD, /* 711 */ + IC_VEX_L_W, /* 712 */ + IC_VEX_L_W, /* 713 */ + IC_VEX_L_W_XS, /* 714 */ + IC_VEX_L_W_XS, /* 715 */ + IC_VEX_L_W_XD, /* 716 */ + IC_VEX_L_W_XD, /* 717 */ + IC_VEX_L_W_XD, /* 718 */ + IC_VEX_L_W_XD, /* 719 */ + IC_VEX_L_OPSIZE, /* 720 */ + IC_VEX_L_OPSIZE, /* 721 */ + IC_VEX_L_OPSIZE, /* 722 */ + IC_VEX_L_OPSIZE, /* 723 */ + IC_VEX_L_OPSIZE, /* 724 */ + IC_VEX_L_OPSIZE, /* 725 */ + IC_VEX_L_OPSIZE, /* 726 */ + IC_VEX_L_OPSIZE, /* 727 */ + IC_VEX_L_W_OPSIZE, /* 728 */ + IC_VEX_L_W_OPSIZE, /* 729 */ + IC_VEX_L_W_OPSIZE, /* 730 */ + IC_VEX_L_W_OPSIZE, /* 731 */ + IC_VEX_L_W_OPSIZE, /* 732 */ + IC_VEX_L_W_OPSIZE, /* 733 */ + IC_VEX_L_W_OPSIZE, /* 734 */ + IC_VEX_L_W_OPSIZE, /* 735 */ + IC_VEX_L, /* 736 */ + IC_VEX_L, /* 737 */ + IC_VEX_L_XS, /* 738 */ + IC_VEX_L_XS, /* 739 */ + IC_VEX_L_XD, /* 740 */ + IC_VEX_L_XD, /* 741 */ + IC_VEX_L_XD, /* 742 */ + IC_VEX_L_XD, /* 743 */ + IC_VEX_L_W, /* 744 */ + IC_VEX_L_W, /* 745 */ + IC_VEX_L_W_XS, /* 746 */ + IC_VEX_L_W_XS, /* 747 */ + IC_VEX_L_W_XD, /* 748 */ + IC_VEX_L_W_XD, /* 749 */ + IC_VEX_L_W_XD, /* 750 */ + IC_VEX_L_W_XD, /* 751 */ + IC_VEX_L_OPSIZE, /* 752 */ + IC_VEX_L_OPSIZE, /* 753 */ + IC_VEX_L_OPSIZE, /* 754 */ + IC_VEX_L_OPSIZE, /* 755 */ + IC_VEX_L_OPSIZE, /* 756 */ + IC_VEX_L_OPSIZE, /* 757 */ + IC_VEX_L_OPSIZE, /* 758 */ + IC_VEX_L_OPSIZE, /* 759 */ + IC_VEX_L_W_OPSIZE, /* 760 */ + IC_VEX_L_W_OPSIZE, /* 761 */ + IC_VEX_L_W_OPSIZE, /* 762 */ + IC_VEX_L_W_OPSIZE, /* 763 */ + IC_VEX_L_W_OPSIZE, /* 764 */ + IC_VEX_L_W_OPSIZE, /* 765 */ + IC_VEX_L_W_OPSIZE, /* 766 */ + IC_VEX_L_W_OPSIZE, /* 767 */ + IC_EVEX_L, /* 768 */ + IC_EVEX_L, /* 769 */ + IC_EVEX_L_XS, /* 770 */ + IC_EVEX_L_XS, /* 771 */ + IC_EVEX_L_XD, /* 772 */ + IC_EVEX_L_XD, /* 773 */ + IC_EVEX_L_XD, /* 774 */ + IC_EVEX_L_XD, /* 775 */ + IC_EVEX_L_W, /* 776 */ + IC_EVEX_L_W, /* 777 */ + IC_EVEX_L_W_XS, /* 778 */ + IC_EVEX_L_W_XS, /* 779 */ + IC_EVEX_L_W_XD, /* 780 */ + IC_EVEX_L_W_XD, /* 781 */ + IC_EVEX_L_W_XD, /* 782 */ + IC_EVEX_L_W_XD, /* 783 */ + IC_EVEX_L_OPSIZE, /* 784 */ + IC_EVEX_L_OPSIZE, /* 785 */ + IC_EVEX_L_OPSIZE, /* 786 */ + IC_EVEX_L_OPSIZE, /* 787 */ + IC_EVEX_L_OPSIZE, /* 788 */ + IC_EVEX_L_OPSIZE, /* 789 */ + IC_EVEX_L_OPSIZE, /* 790 */ + IC_EVEX_L_OPSIZE, /* 791 */ + IC_EVEX_L_W_OPSIZE, /* 792 */ + IC_EVEX_L_W_OPSIZE, /* 793 */ + IC_EVEX_L_W_OPSIZE, /* 794 */ + IC_EVEX_L_W_OPSIZE, /* 795 */ + IC_EVEX_L_W_OPSIZE, /* 796 */ + IC_EVEX_L_W_OPSIZE, /* 797 */ + IC_EVEX_L_W_OPSIZE, /* 798 */ + IC_EVEX_L_W_OPSIZE, /* 799 */ + IC_EVEX_L, /* 800 */ + IC_EVEX_L, /* 801 */ + IC_EVEX_L_XS, /* 802 */ + IC_EVEX_L_XS, /* 803 */ + IC_EVEX_L_XD, /* 804 */ + IC_EVEX_L_XD, /* 805 */ + IC_EVEX_L_XD, /* 806 */ + IC_EVEX_L_XD, /* 807 */ + IC_EVEX_L_W, /* 808 */ + IC_EVEX_L_W, /* 809 */ + IC_EVEX_L_W_XS, /* 810 */ + IC_EVEX_L_W_XS, /* 811 */ + IC_EVEX_L_W_XD, /* 812 */ + IC_EVEX_L_W_XD, /* 813 */ + IC_EVEX_L_W_XD, /* 814 */ + IC_EVEX_L_W_XD, /* 815 */ + IC_EVEX_L_OPSIZE, /* 816 */ + IC_EVEX_L_OPSIZE, /* 817 */ + IC_EVEX_L_OPSIZE, /* 818 */ + IC_EVEX_L_OPSIZE, /* 819 */ + IC_EVEX_L_OPSIZE, /* 820 */ + IC_EVEX_L_OPSIZE, /* 821 */ + IC_EVEX_L_OPSIZE, /* 822 */ + IC_EVEX_L_OPSIZE, /* 823 */ + IC_EVEX_L_W_OPSIZE, /* 824 */ + IC_EVEX_L_W_OPSIZE, /* 825 */ + IC_EVEX_L_W_OPSIZE, /* 826 */ + IC_EVEX_L_W_OPSIZE, /* 827 */ + IC_EVEX_L_W_OPSIZE, /* 828 */ + IC_EVEX_L_W_OPSIZE, /* 829 */ + IC_EVEX_L_W_OPSIZE, /* 830 */ + IC_EVEX_L_W_OPSIZE, /* 831 */ + IC_EVEX_L, /* 832 */ + IC_EVEX_L, /* 833 */ + IC_EVEX_L_XS, /* 834 */ + IC_EVEX_L_XS, /* 835 */ + IC_EVEX_L_XD, /* 836 */ + IC_EVEX_L_XD, /* 837 */ + IC_EVEX_L_XD, /* 838 */ + IC_EVEX_L_XD, /* 839 */ + IC_EVEX_L_W, /* 840 */ + IC_EVEX_L_W, /* 841 */ + IC_EVEX_L_W_XS, /* 842 */ + IC_EVEX_L_W_XS, /* 843 */ + IC_EVEX_L_W_XD, /* 844 */ + IC_EVEX_L_W_XD, /* 845 */ + IC_EVEX_L_W_XD, /* 846 */ + IC_EVEX_L_W_XD, /* 847 */ + IC_EVEX_L_OPSIZE, /* 848 */ + IC_EVEX_L_OPSIZE, /* 849 */ + IC_EVEX_L_OPSIZE, /* 850 */ + IC_EVEX_L_OPSIZE, /* 851 */ + IC_EVEX_L_OPSIZE, /* 852 */ + IC_EVEX_L_OPSIZE, /* 853 */ + IC_EVEX_L_OPSIZE, /* 854 */ + IC_EVEX_L_OPSIZE, /* 855 */ + IC_EVEX_L_W_OPSIZE, /* 856 */ + IC_EVEX_L_W_OPSIZE, /* 857 */ + IC_EVEX_L_W_OPSIZE, /* 858 */ + IC_EVEX_L_W_OPSIZE, /* 859 */ + IC_EVEX_L_W_OPSIZE, /* 860 */ + IC_EVEX_L_W_OPSIZE, /* 861 */ + IC_EVEX_L_W_OPSIZE, /* 862 */ + IC_EVEX_L_W_OPSIZE, /* 863 */ + IC_EVEX_L, /* 864 */ + IC_EVEX_L, /* 865 */ + IC_EVEX_L_XS, /* 866 */ + IC_EVEX_L_XS, /* 867 */ + IC_EVEX_L_XD, /* 868 */ + IC_EVEX_L_XD, /* 869 */ + IC_EVEX_L_XD, /* 870 */ + IC_EVEX_L_XD, /* 871 */ + IC_EVEX_L_W, /* 872 */ + IC_EVEX_L_W, /* 873 */ + IC_EVEX_L_W_XS, /* 874 */ + IC_EVEX_L_W_XS, /* 875 */ + IC_EVEX_L_W_XD, /* 876 */ + IC_EVEX_L_W_XD, /* 877 */ + IC_EVEX_L_W_XD, /* 878 */ + IC_EVEX_L_W_XD, /* 879 */ + IC_EVEX_L_OPSIZE, /* 880 */ + IC_EVEX_L_OPSIZE, /* 881 */ + IC_EVEX_L_OPSIZE, /* 882 */ + IC_EVEX_L_OPSIZE, /* 883 */ + IC_EVEX_L_OPSIZE, /* 884 */ + IC_EVEX_L_OPSIZE, /* 885 */ + IC_EVEX_L_OPSIZE, /* 886 */ + IC_EVEX_L_OPSIZE, /* 887 */ + IC_EVEX_L_W_OPSIZE, /* 888 */ + IC_EVEX_L_W_OPSIZE, /* 889 */ + IC_EVEX_L_W_OPSIZE, /* 890 */ + IC_EVEX_L_W_OPSIZE, /* 891 */ + IC_EVEX_L_W_OPSIZE, /* 892 */ + IC_EVEX_L_W_OPSIZE, /* 893 */ + IC_EVEX_L_W_OPSIZE, /* 894 */ + IC_EVEX_L_W_OPSIZE, /* 895 */ + IC_EVEX_L, /* 896 */ + IC_EVEX_L, /* 897 */ + IC_EVEX_L_XS, /* 898 */ + IC_EVEX_L_XS, /* 899 */ + IC_EVEX_L_XD, /* 900 */ + IC_EVEX_L_XD, /* 901 */ + IC_EVEX_L_XD, /* 902 */ + IC_EVEX_L_XD, /* 903 */ + IC_EVEX_L_W, /* 904 */ + IC_EVEX_L_W, /* 905 */ + IC_EVEX_L_W_XS, /* 906 */ + IC_EVEX_L_W_XS, /* 907 */ + IC_EVEX_L_W_XD, /* 908 */ + IC_EVEX_L_W_XD, /* 909 */ + IC_EVEX_L_W_XD, /* 910 */ + IC_EVEX_L_W_XD, /* 911 */ + IC_EVEX_L_OPSIZE, /* 912 */ + IC_EVEX_L_OPSIZE, /* 913 */ + IC_EVEX_L_OPSIZE, /* 914 */ + IC_EVEX_L_OPSIZE, /* 915 */ + IC_EVEX_L_OPSIZE, /* 916 */ + IC_EVEX_L_OPSIZE, /* 917 */ + IC_EVEX_L_OPSIZE, /* 918 */ + IC_EVEX_L_OPSIZE, /* 919 */ + IC_EVEX_L_W_OPSIZE, /* 920 */ + IC_EVEX_L_W_OPSIZE, /* 921 */ + IC_EVEX_L_W_OPSIZE, /* 922 */ + IC_EVEX_L_W_OPSIZE, /* 923 */ + IC_EVEX_L_W_OPSIZE, /* 924 */ + IC_EVEX_L_W_OPSIZE, /* 925 */ + IC_EVEX_L_W_OPSIZE, /* 926 */ + IC_EVEX_L_W_OPSIZE, /* 927 */ + IC_EVEX_L, /* 928 */ + IC_EVEX_L, /* 929 */ + IC_EVEX_L_XS, /* 930 */ + IC_EVEX_L_XS, /* 931 */ + IC_EVEX_L_XD, /* 932 */ + IC_EVEX_L_XD, /* 933 */ + IC_EVEX_L_XD, /* 934 */ + IC_EVEX_L_XD, /* 935 */ + IC_EVEX_L_W, /* 936 */ + IC_EVEX_L_W, /* 937 */ + IC_EVEX_L_W_XS, /* 938 */ + IC_EVEX_L_W_XS, /* 939 */ + IC_EVEX_L_W_XD, /* 940 */ + IC_EVEX_L_W_XD, /* 941 */ + IC_EVEX_L_W_XD, /* 942 */ + IC_EVEX_L_W_XD, /* 943 */ + IC_EVEX_L_OPSIZE, /* 944 */ + IC_EVEX_L_OPSIZE, /* 945 */ + IC_EVEX_L_OPSIZE, /* 946 */ + IC_EVEX_L_OPSIZE, /* 947 */ + IC_EVEX_L_OPSIZE, /* 948 */ + IC_EVEX_L_OPSIZE, /* 949 */ + IC_EVEX_L_OPSIZE, /* 950 */ + IC_EVEX_L_OPSIZE, /* 951 */ + IC_EVEX_L_W_OPSIZE, /* 952 */ + IC_EVEX_L_W_OPSIZE, /* 953 */ + IC_EVEX_L_W_OPSIZE, /* 954 */ + IC_EVEX_L_W_OPSIZE, /* 955 */ + IC_EVEX_L_W_OPSIZE, /* 956 */ + IC_EVEX_L_W_OPSIZE, /* 957 */ + IC_EVEX_L_W_OPSIZE, /* 958 */ + IC_EVEX_L_W_OPSIZE, /* 959 */ + IC_EVEX_L, /* 960 */ + IC_EVEX_L, /* 961 */ + IC_EVEX_L_XS, /* 962 */ + IC_EVEX_L_XS, /* 963 */ + IC_EVEX_L_XD, /* 964 */ + IC_EVEX_L_XD, /* 965 */ + IC_EVEX_L_XD, /* 966 */ + IC_EVEX_L_XD, /* 967 */ + IC_EVEX_L_W, /* 968 */ + IC_EVEX_L_W, /* 969 */ + IC_EVEX_L_W_XS, /* 970 */ + IC_EVEX_L_W_XS, /* 971 */ + IC_EVEX_L_W_XD, /* 972 */ + IC_EVEX_L_W_XD, /* 973 */ + IC_EVEX_L_W_XD, /* 974 */ + IC_EVEX_L_W_XD, /* 975 */ + IC_EVEX_L_OPSIZE, /* 976 */ + IC_EVEX_L_OPSIZE, /* 977 */ + IC_EVEX_L_OPSIZE, /* 978 */ + IC_EVEX_L_OPSIZE, /* 979 */ + IC_EVEX_L_OPSIZE, /* 980 */ + IC_EVEX_L_OPSIZE, /* 981 */ + IC_EVEX_L_OPSIZE, /* 982 */ + IC_EVEX_L_OPSIZE, /* 983 */ + IC_EVEX_L_W_OPSIZE, /* 984 */ + IC_EVEX_L_W_OPSIZE, /* 985 */ + IC_EVEX_L_W_OPSIZE, /* 986 */ + IC_EVEX_L_W_OPSIZE, /* 987 */ + IC_EVEX_L_W_OPSIZE, /* 988 */ + IC_EVEX_L_W_OPSIZE, /* 989 */ + IC_EVEX_L_W_OPSIZE, /* 990 */ + IC_EVEX_L_W_OPSIZE, /* 991 */ + IC_EVEX_L, /* 992 */ + IC_EVEX_L, /* 993 */ + IC_EVEX_L_XS, /* 994 */ + IC_EVEX_L_XS, /* 995 */ + IC_EVEX_L_XD, /* 996 */ + IC_EVEX_L_XD, /* 997 */ + IC_EVEX_L_XD, /* 998 */ + IC_EVEX_L_XD, /* 999 */ + IC_EVEX_L_W, /* 1000 */ + IC_EVEX_L_W, /* 1001 */ + IC_EVEX_L_W_XS, /* 1002 */ + IC_EVEX_L_W_XS, /* 1003 */ + IC_EVEX_L_W_XD, /* 1004 */ + IC_EVEX_L_W_XD, /* 1005 */ + IC_EVEX_L_W_XD, /* 1006 */ + IC_EVEX_L_W_XD, /* 1007 */ + IC_EVEX_L_OPSIZE, /* 1008 */ + IC_EVEX_L_OPSIZE, /* 1009 */ + IC_EVEX_L_OPSIZE, /* 1010 */ + IC_EVEX_L_OPSIZE, /* 1011 */ + IC_EVEX_L_OPSIZE, /* 1012 */ + IC_EVEX_L_OPSIZE, /* 1013 */ + IC_EVEX_L_OPSIZE, /* 1014 */ + IC_EVEX_L_OPSIZE, /* 1015 */ + IC_EVEX_L_W_OPSIZE, /* 1016 */ + IC_EVEX_L_W_OPSIZE, /* 1017 */ + IC_EVEX_L_W_OPSIZE, /* 1018 */ + IC_EVEX_L_W_OPSIZE, /* 1019 */ + IC_EVEX_L_W_OPSIZE, /* 1020 */ + IC_EVEX_L_W_OPSIZE, /* 1021 */ + IC_EVEX_L_W_OPSIZE, /* 1022 */ + IC_EVEX_L_W_OPSIZE, /* 1023 */ + IC, /* 1024 */ + IC_64BIT, /* 1025 */ + IC_XS, /* 1026 */ + IC_64BIT_XS, /* 1027 */ + IC_XD, /* 1028 */ + IC_64BIT_XD, /* 1029 */ + IC_XS, /* 1030 */ + IC_64BIT_XS, /* 1031 */ + IC, /* 1032 */ + IC_64BIT_REXW, /* 1033 */ + IC_XS, /* 1034 */ + IC_64BIT_REXW_XS, /* 1035 */ + IC_XD, /* 1036 */ + IC_64BIT_REXW_XD, /* 1037 */ + IC_XS, /* 1038 */ + IC_64BIT_REXW_XS, /* 1039 */ + IC_OPSIZE, /* 1040 */ + IC_64BIT_OPSIZE, /* 1041 */ + IC_XS_OPSIZE, /* 1042 */ + IC_64BIT_XS_OPSIZE, /* 1043 */ + IC_XD_OPSIZE, /* 1044 */ + IC_64BIT_XD_OPSIZE, /* 1045 */ + IC_XS_OPSIZE, /* 1046 */ + IC_64BIT_XD_OPSIZE, /* 1047 */ + IC_OPSIZE, /* 1048 */ + IC_64BIT_REXW_OPSIZE, /* 1049 */ + IC_XS_OPSIZE, /* 1050 */ + IC_64BIT_REXW_XS, /* 1051 */ + IC_XD_OPSIZE, /* 1052 */ + IC_64BIT_REXW_XD, /* 1053 */ + IC_XS_OPSIZE, /* 1054 */ + IC_64BIT_REXW_XS, /* 1055 */ + IC_ADSIZE, /* 1056 */ + IC_64BIT_ADSIZE, /* 1057 */ + IC_XS_ADSIZE, /* 1058 */ + IC_64BIT_XS_ADSIZE, /* 1059 */ + IC_XD_ADSIZE, /* 1060 */ + IC_64BIT_XD_ADSIZE, /* 1061 */ + IC_XS_ADSIZE, /* 1062 */ + IC_64BIT_XD_ADSIZE, /* 1063 */ + IC_ADSIZE, /* 1064 */ + IC_64BIT_REXW_ADSIZE, /* 1065 */ + IC_XS_ADSIZE, /* 1066 */ + IC_64BIT_REXW_XS, /* 1067 */ + IC_XD_ADSIZE, /* 1068 */ + IC_64BIT_REXW_XD, /* 1069 */ + IC_XS_ADSIZE, /* 1070 */ + IC_64BIT_REXW_XS, /* 1071 */ + IC_OPSIZE_ADSIZE, /* 1072 */ + IC_64BIT_OPSIZE_ADSIZE, /* 1073 */ + IC_XS_OPSIZE, /* 1074 */ + IC_64BIT_XS_OPSIZE, /* 1075 */ + IC_XD_OPSIZE, /* 1076 */ + IC_64BIT_XD_OPSIZE, /* 1077 */ + IC_XS_OPSIZE, /* 1078 */ + IC_64BIT_XD_OPSIZE, /* 1079 */ + IC_OPSIZE_ADSIZE, /* 1080 */ + IC_64BIT_REXW_OPSIZE, /* 1081 */ + IC_XS_OPSIZE, /* 1082 */ + IC_64BIT_REXW_XS, /* 1083 */ + IC_XD_OPSIZE, /* 1084 */ + IC_64BIT_REXW_XD, /* 1085 */ + IC_XS_OPSIZE, /* 1086 */ + IC_64BIT_REXW_XS, /* 1087 */ + IC_VEX, /* 1088 */ + IC_VEX, /* 1089 */ + IC_VEX_XS, /* 1090 */ + IC_VEX_XS, /* 1091 */ + IC_VEX_XD, /* 1092 */ + IC_VEX_XD, /* 1093 */ + IC_VEX_XD, /* 1094 */ + IC_VEX_XD, /* 1095 */ + IC_VEX_W, /* 1096 */ + IC_VEX_W, /* 1097 */ + IC_VEX_W_XS, /* 1098 */ + IC_VEX_W_XS, /* 1099 */ + IC_VEX_W_XD, /* 1100 */ + IC_VEX_W_XD, /* 1101 */ + IC_VEX_W_XD, /* 1102 */ + IC_VEX_W_XD, /* 1103 */ + IC_VEX_OPSIZE, /* 1104 */ + IC_VEX_OPSIZE, /* 1105 */ + IC_VEX_OPSIZE, /* 1106 */ + IC_VEX_OPSIZE, /* 1107 */ + IC_VEX_OPSIZE, /* 1108 */ + IC_VEX_OPSIZE, /* 1109 */ + IC_VEX_OPSIZE, /* 1110 */ + IC_VEX_OPSIZE, /* 1111 */ + IC_VEX_W_OPSIZE, /* 1112 */ + IC_VEX_W_OPSIZE, /* 1113 */ + IC_VEX_W_OPSIZE, /* 1114 */ + IC_VEX_W_OPSIZE, /* 1115 */ + IC_VEX_W_OPSIZE, /* 1116 */ + IC_VEX_W_OPSIZE, /* 1117 */ + IC_VEX_W_OPSIZE, /* 1118 */ + IC_VEX_W_OPSIZE, /* 1119 */ + IC_VEX, /* 1120 */ + IC_VEX, /* 1121 */ + IC_VEX_XS, /* 1122 */ + IC_VEX_XS, /* 1123 */ + IC_VEX_XD, /* 1124 */ + IC_VEX_XD, /* 1125 */ + IC_VEX_XD, /* 1126 */ + IC_VEX_XD, /* 1127 */ + IC_VEX_W, /* 1128 */ + IC_VEX_W, /* 1129 */ + IC_VEX_W_XS, /* 1130 */ + IC_VEX_W_XS, /* 1131 */ + IC_VEX_W_XD, /* 1132 */ + IC_VEX_W_XD, /* 1133 */ + IC_VEX_W_XD, /* 1134 */ + IC_VEX_W_XD, /* 1135 */ + IC_VEX_OPSIZE, /* 1136 */ + IC_VEX_OPSIZE, /* 1137 */ + IC_VEX_OPSIZE, /* 1138 */ + IC_VEX_OPSIZE, /* 1139 */ + IC_VEX_OPSIZE, /* 1140 */ + IC_VEX_OPSIZE, /* 1141 */ + IC_VEX_OPSIZE, /* 1142 */ + IC_VEX_OPSIZE, /* 1143 */ + IC_VEX_W_OPSIZE, /* 1144 */ + IC_VEX_W_OPSIZE, /* 1145 */ + IC_VEX_W_OPSIZE, /* 1146 */ + IC_VEX_W_OPSIZE, /* 1147 */ + IC_VEX_W_OPSIZE, /* 1148 */ + IC_VEX_W_OPSIZE, /* 1149 */ + IC_VEX_W_OPSIZE, /* 1150 */ + IC_VEX_W_OPSIZE, /* 1151 */ + IC_VEX_L, /* 1152 */ + IC_VEX_L, /* 1153 */ + IC_VEX_L_XS, /* 1154 */ + IC_VEX_L_XS, /* 1155 */ + IC_VEX_L_XD, /* 1156 */ + IC_VEX_L_XD, /* 1157 */ + IC_VEX_L_XD, /* 1158 */ + IC_VEX_L_XD, /* 1159 */ + IC_VEX_L_W, /* 1160 */ + IC_VEX_L_W, /* 1161 */ + IC_VEX_L_W_XS, /* 1162 */ + IC_VEX_L_W_XS, /* 1163 */ + IC_VEX_L_W_XD, /* 1164 */ + IC_VEX_L_W_XD, /* 1165 */ + IC_VEX_L_W_XD, /* 1166 */ + IC_VEX_L_W_XD, /* 1167 */ + IC_VEX_L_OPSIZE, /* 1168 */ + IC_VEX_L_OPSIZE, /* 1169 */ + IC_VEX_L_OPSIZE, /* 1170 */ + IC_VEX_L_OPSIZE, /* 1171 */ + IC_VEX_L_OPSIZE, /* 1172 */ + IC_VEX_L_OPSIZE, /* 1173 */ + IC_VEX_L_OPSIZE, /* 1174 */ + IC_VEX_L_OPSIZE, /* 1175 */ + IC_VEX_L_W_OPSIZE, /* 1176 */ + IC_VEX_L_W_OPSIZE, /* 1177 */ + IC_VEX_L_W_OPSIZE, /* 1178 */ + IC_VEX_L_W_OPSIZE, /* 1179 */ + IC_VEX_L_W_OPSIZE, /* 1180 */ + IC_VEX_L_W_OPSIZE, /* 1181 */ + IC_VEX_L_W_OPSIZE, /* 1182 */ + IC_VEX_L_W_OPSIZE, /* 1183 */ + IC_VEX_L, /* 1184 */ + IC_VEX_L, /* 1185 */ + IC_VEX_L_XS, /* 1186 */ + IC_VEX_L_XS, /* 1187 */ + IC_VEX_L_XD, /* 1188 */ + IC_VEX_L_XD, /* 1189 */ + IC_VEX_L_XD, /* 1190 */ + IC_VEX_L_XD, /* 1191 */ + IC_VEX_L_W, /* 1192 */ + IC_VEX_L_W, /* 1193 */ + IC_VEX_L_W_XS, /* 1194 */ + IC_VEX_L_W_XS, /* 1195 */ + IC_VEX_L_W_XD, /* 1196 */ + IC_VEX_L_W_XD, /* 1197 */ + IC_VEX_L_W_XD, /* 1198 */ + IC_VEX_L_W_XD, /* 1199 */ + IC_VEX_L_OPSIZE, /* 1200 */ + IC_VEX_L_OPSIZE, /* 1201 */ + IC_VEX_L_OPSIZE, /* 1202 */ + IC_VEX_L_OPSIZE, /* 1203 */ + IC_VEX_L_OPSIZE, /* 1204 */ + IC_VEX_L_OPSIZE, /* 1205 */ + IC_VEX_L_OPSIZE, /* 1206 */ + IC_VEX_L_OPSIZE, /* 1207 */ + IC_VEX_L_W_OPSIZE, /* 1208 */ + IC_VEX_L_W_OPSIZE, /* 1209 */ + IC_VEX_L_W_OPSIZE, /* 1210 */ + IC_VEX_L_W_OPSIZE, /* 1211 */ + IC_VEX_L_W_OPSIZE, /* 1212 */ + IC_VEX_L_W_OPSIZE, /* 1213 */ + IC_VEX_L_W_OPSIZE, /* 1214 */ + IC_VEX_L_W_OPSIZE, /* 1215 */ + IC_VEX_L, /* 1216 */ + IC_VEX_L, /* 1217 */ + IC_VEX_L_XS, /* 1218 */ + IC_VEX_L_XS, /* 1219 */ + IC_VEX_L_XD, /* 1220 */ + IC_VEX_L_XD, /* 1221 */ + IC_VEX_L_XD, /* 1222 */ + IC_VEX_L_XD, /* 1223 */ + IC_VEX_L_W, /* 1224 */ + IC_VEX_L_W, /* 1225 */ + IC_VEX_L_W_XS, /* 1226 */ + IC_VEX_L_W_XS, /* 1227 */ + IC_VEX_L_W_XD, /* 1228 */ + IC_VEX_L_W_XD, /* 1229 */ + IC_VEX_L_W_XD, /* 1230 */ + IC_VEX_L_W_XD, /* 1231 */ + IC_VEX_L_OPSIZE, /* 1232 */ + IC_VEX_L_OPSIZE, /* 1233 */ + IC_VEX_L_OPSIZE, /* 1234 */ + IC_VEX_L_OPSIZE, /* 1235 */ + IC_VEX_L_OPSIZE, /* 1236 */ + IC_VEX_L_OPSIZE, /* 1237 */ + IC_VEX_L_OPSIZE, /* 1238 */ + IC_VEX_L_OPSIZE, /* 1239 */ + IC_VEX_L_W_OPSIZE, /* 1240 */ + IC_VEX_L_W_OPSIZE, /* 1241 */ + IC_VEX_L_W_OPSIZE, /* 1242 */ + IC_VEX_L_W_OPSIZE, /* 1243 */ + IC_VEX_L_W_OPSIZE, /* 1244 */ + IC_VEX_L_W_OPSIZE, /* 1245 */ + IC_VEX_L_W_OPSIZE, /* 1246 */ + IC_VEX_L_W_OPSIZE, /* 1247 */ + IC_VEX_L, /* 1248 */ + IC_VEX_L, /* 1249 */ + IC_VEX_L_XS, /* 1250 */ + IC_VEX_L_XS, /* 1251 */ + IC_VEX_L_XD, /* 1252 */ + IC_VEX_L_XD, /* 1253 */ + IC_VEX_L_XD, /* 1254 */ + IC_VEX_L_XD, /* 1255 */ + IC_VEX_L_W, /* 1256 */ + IC_VEX_L_W, /* 1257 */ + IC_VEX_L_W_XS, /* 1258 */ + IC_VEX_L_W_XS, /* 1259 */ + IC_VEX_L_W_XD, /* 1260 */ + IC_VEX_L_W_XD, /* 1261 */ + IC_VEX_L_W_XD, /* 1262 */ + IC_VEX_L_W_XD, /* 1263 */ + IC_VEX_L_OPSIZE, /* 1264 */ + IC_VEX_L_OPSIZE, /* 1265 */ + IC_VEX_L_OPSIZE, /* 1266 */ + IC_VEX_L_OPSIZE, /* 1267 */ + IC_VEX_L_OPSIZE, /* 1268 */ + IC_VEX_L_OPSIZE, /* 1269 */ + IC_VEX_L_OPSIZE, /* 1270 */ + IC_VEX_L_OPSIZE, /* 1271 */ + IC_VEX_L_W_OPSIZE, /* 1272 */ + IC_VEX_L_W_OPSIZE, /* 1273 */ + IC_VEX_L_W_OPSIZE, /* 1274 */ + IC_VEX_L_W_OPSIZE, /* 1275 */ + IC_VEX_L_W_OPSIZE, /* 1276 */ + IC_VEX_L_W_OPSIZE, /* 1277 */ + IC_VEX_L_W_OPSIZE, /* 1278 */ + IC_VEX_L_W_OPSIZE, /* 1279 */ + IC_EVEX_L2, /* 1280 */ + IC_EVEX_L2, /* 1281 */ + IC_EVEX_L2_XS, /* 1282 */ + IC_EVEX_L2_XS, /* 1283 */ + IC_EVEX_L2_XD, /* 1284 */ + IC_EVEX_L2_XD, /* 1285 */ + IC_EVEX_L2_XD, /* 1286 */ + IC_EVEX_L2_XD, /* 1287 */ + IC_EVEX_L2_W, /* 1288 */ + IC_EVEX_L2_W, /* 1289 */ + IC_EVEX_L2_W_XS, /* 1290 */ + IC_EVEX_L2_W_XS, /* 1291 */ + IC_EVEX_L2_W_XD, /* 1292 */ + IC_EVEX_L2_W_XD, /* 1293 */ + IC_EVEX_L2_W_XD, /* 1294 */ + IC_EVEX_L2_W_XD, /* 1295 */ + IC_EVEX_L2_OPSIZE, /* 1296 */ + IC_EVEX_L2_OPSIZE, /* 1297 */ + IC_EVEX_L2_OPSIZE, /* 1298 */ + IC_EVEX_L2_OPSIZE, /* 1299 */ + IC_EVEX_L2_OPSIZE, /* 1300 */ + IC_EVEX_L2_OPSIZE, /* 1301 */ + IC_EVEX_L2_OPSIZE, /* 1302 */ + IC_EVEX_L2_OPSIZE, /* 1303 */ + IC_EVEX_L2_W_OPSIZE, /* 1304 */ + IC_EVEX_L2_W_OPSIZE, /* 1305 */ + IC_EVEX_L2_W_OPSIZE, /* 1306 */ + IC_EVEX_L2_W_OPSIZE, /* 1307 */ + IC_EVEX_L2_W_OPSIZE, /* 1308 */ + IC_EVEX_L2_W_OPSIZE, /* 1309 */ + IC_EVEX_L2_W_OPSIZE, /* 1310 */ + IC_EVEX_L2_W_OPSIZE, /* 1311 */ + IC_EVEX_L2, /* 1312 */ + IC_EVEX_L2, /* 1313 */ + IC_EVEX_L2_XS, /* 1314 */ + IC_EVEX_L2_XS, /* 1315 */ + IC_EVEX_L2_XD, /* 1316 */ + IC_EVEX_L2_XD, /* 1317 */ + IC_EVEX_L2_XD, /* 1318 */ + IC_EVEX_L2_XD, /* 1319 */ + IC_EVEX_L2_W, /* 1320 */ + IC_EVEX_L2_W, /* 1321 */ + IC_EVEX_L2_W_XS, /* 1322 */ + IC_EVEX_L2_W_XS, /* 1323 */ + IC_EVEX_L2_W_XD, /* 1324 */ + IC_EVEX_L2_W_XD, /* 1325 */ + IC_EVEX_L2_W_XD, /* 1326 */ + IC_EVEX_L2_W_XD, /* 1327 */ + IC_EVEX_L2_OPSIZE, /* 1328 */ + IC_EVEX_L2_OPSIZE, /* 1329 */ + IC_EVEX_L2_OPSIZE, /* 1330 */ + IC_EVEX_L2_OPSIZE, /* 1331 */ + IC_EVEX_L2_OPSIZE, /* 1332 */ + IC_EVEX_L2_OPSIZE, /* 1333 */ + IC_EVEX_L2_OPSIZE, /* 1334 */ + IC_EVEX_L2_OPSIZE, /* 1335 */ + IC_EVEX_L2_W_OPSIZE, /* 1336 */ + IC_EVEX_L2_W_OPSIZE, /* 1337 */ + IC_EVEX_L2_W_OPSIZE, /* 1338 */ + IC_EVEX_L2_W_OPSIZE, /* 1339 */ + IC_EVEX_L2_W_OPSIZE, /* 1340 */ + IC_EVEX_L2_W_OPSIZE, /* 1341 */ + IC_EVEX_L2_W_OPSIZE, /* 1342 */ + IC_EVEX_L2_W_OPSIZE, /* 1343 */ + IC_EVEX_L2, /* 1344 */ + IC_EVEX_L2, /* 1345 */ + IC_EVEX_L2_XS, /* 1346 */ + IC_EVEX_L2_XS, /* 1347 */ + IC_EVEX_L2_XD, /* 1348 */ + IC_EVEX_L2_XD, /* 1349 */ + IC_EVEX_L2_XD, /* 1350 */ + IC_EVEX_L2_XD, /* 1351 */ + IC_EVEX_L2_W, /* 1352 */ + IC_EVEX_L2_W, /* 1353 */ + IC_EVEX_L2_W_XS, /* 1354 */ + IC_EVEX_L2_W_XS, /* 1355 */ + IC_EVEX_L2_W_XD, /* 1356 */ + IC_EVEX_L2_W_XD, /* 1357 */ + IC_EVEX_L2_W_XD, /* 1358 */ + IC_EVEX_L2_W_XD, /* 1359 */ + IC_EVEX_L2_OPSIZE, /* 1360 */ + IC_EVEX_L2_OPSIZE, /* 1361 */ + IC_EVEX_L2_OPSIZE, /* 1362 */ + IC_EVEX_L2_OPSIZE, /* 1363 */ + IC_EVEX_L2_OPSIZE, /* 1364 */ + IC_EVEX_L2_OPSIZE, /* 1365 */ + IC_EVEX_L2_OPSIZE, /* 1366 */ + IC_EVEX_L2_OPSIZE, /* 1367 */ + IC_EVEX_L2_W_OPSIZE, /* 1368 */ + IC_EVEX_L2_W_OPSIZE, /* 1369 */ + IC_EVEX_L2_W_OPSIZE, /* 1370 */ + IC_EVEX_L2_W_OPSIZE, /* 1371 */ + IC_EVEX_L2_W_OPSIZE, /* 1372 */ + IC_EVEX_L2_W_OPSIZE, /* 1373 */ + IC_EVEX_L2_W_OPSIZE, /* 1374 */ + IC_EVEX_L2_W_OPSIZE, /* 1375 */ + IC_EVEX_L2, /* 1376 */ + IC_EVEX_L2, /* 1377 */ + IC_EVEX_L2_XS, /* 1378 */ + IC_EVEX_L2_XS, /* 1379 */ + IC_EVEX_L2_XD, /* 1380 */ + IC_EVEX_L2_XD, /* 1381 */ + IC_EVEX_L2_XD, /* 1382 */ + IC_EVEX_L2_XD, /* 1383 */ + IC_EVEX_L2_W, /* 1384 */ + IC_EVEX_L2_W, /* 1385 */ + IC_EVEX_L2_W_XS, /* 1386 */ + IC_EVEX_L2_W_XS, /* 1387 */ + IC_EVEX_L2_W_XD, /* 1388 */ + IC_EVEX_L2_W_XD, /* 1389 */ + IC_EVEX_L2_W_XD, /* 1390 */ + IC_EVEX_L2_W_XD, /* 1391 */ + IC_EVEX_L2_OPSIZE, /* 1392 */ + IC_EVEX_L2_OPSIZE, /* 1393 */ + IC_EVEX_L2_OPSIZE, /* 1394 */ + IC_EVEX_L2_OPSIZE, /* 1395 */ + IC_EVEX_L2_OPSIZE, /* 1396 */ + IC_EVEX_L2_OPSIZE, /* 1397 */ + IC_EVEX_L2_OPSIZE, /* 1398 */ + IC_EVEX_L2_OPSIZE, /* 1399 */ + IC_EVEX_L2_W_OPSIZE, /* 1400 */ + IC_EVEX_L2_W_OPSIZE, /* 1401 */ + IC_EVEX_L2_W_OPSIZE, /* 1402 */ + IC_EVEX_L2_W_OPSIZE, /* 1403 */ + IC_EVEX_L2_W_OPSIZE, /* 1404 */ + IC_EVEX_L2_W_OPSIZE, /* 1405 */ + IC_EVEX_L2_W_OPSIZE, /* 1406 */ + IC_EVEX_L2_W_OPSIZE, /* 1407 */ + IC_EVEX_L2, /* 1408 */ + IC_EVEX_L2, /* 1409 */ + IC_EVEX_L2_XS, /* 1410 */ + IC_EVEX_L2_XS, /* 1411 */ + IC_EVEX_L2_XD, /* 1412 */ + IC_EVEX_L2_XD, /* 1413 */ + IC_EVEX_L2_XD, /* 1414 */ + IC_EVEX_L2_XD, /* 1415 */ + IC_EVEX_L2_W, /* 1416 */ + IC_EVEX_L2_W, /* 1417 */ + IC_EVEX_L2_W_XS, /* 1418 */ + IC_EVEX_L2_W_XS, /* 1419 */ + IC_EVEX_L2_W_XD, /* 1420 */ + IC_EVEX_L2_W_XD, /* 1421 */ + IC_EVEX_L2_W_XD, /* 1422 */ + IC_EVEX_L2_W_XD, /* 1423 */ + IC_EVEX_L2_OPSIZE, /* 1424 */ + IC_EVEX_L2_OPSIZE, /* 1425 */ + IC_EVEX_L2_OPSIZE, /* 1426 */ + IC_EVEX_L2_OPSIZE, /* 1427 */ + IC_EVEX_L2_OPSIZE, /* 1428 */ + IC_EVEX_L2_OPSIZE, /* 1429 */ + IC_EVEX_L2_OPSIZE, /* 1430 */ + IC_EVEX_L2_OPSIZE, /* 1431 */ + IC_EVEX_L2_W_OPSIZE, /* 1432 */ + IC_EVEX_L2_W_OPSIZE, /* 1433 */ + IC_EVEX_L2_W_OPSIZE, /* 1434 */ + IC_EVEX_L2_W_OPSIZE, /* 1435 */ + IC_EVEX_L2_W_OPSIZE, /* 1436 */ + IC_EVEX_L2_W_OPSIZE, /* 1437 */ + IC_EVEX_L2_W_OPSIZE, /* 1438 */ + IC_EVEX_L2_W_OPSIZE, /* 1439 */ + IC_EVEX_L2, /* 1440 */ + IC_EVEX_L2, /* 1441 */ + IC_EVEX_L2_XS, /* 1442 */ + IC_EVEX_L2_XS, /* 1443 */ + IC_EVEX_L2_XD, /* 1444 */ + IC_EVEX_L2_XD, /* 1445 */ + IC_EVEX_L2_XD, /* 1446 */ + IC_EVEX_L2_XD, /* 1447 */ + IC_EVEX_L2_W, /* 1448 */ + IC_EVEX_L2_W, /* 1449 */ + IC_EVEX_L2_W_XS, /* 1450 */ + IC_EVEX_L2_W_XS, /* 1451 */ + IC_EVEX_L2_W_XD, /* 1452 */ + IC_EVEX_L2_W_XD, /* 1453 */ + IC_EVEX_L2_W_XD, /* 1454 */ + IC_EVEX_L2_W_XD, /* 1455 */ + IC_EVEX_L2_OPSIZE, /* 1456 */ + IC_EVEX_L2_OPSIZE, /* 1457 */ + IC_EVEX_L2_OPSIZE, /* 1458 */ + IC_EVEX_L2_OPSIZE, /* 1459 */ + IC_EVEX_L2_OPSIZE, /* 1460 */ + IC_EVEX_L2_OPSIZE, /* 1461 */ + IC_EVEX_L2_OPSIZE, /* 1462 */ + IC_EVEX_L2_OPSIZE, /* 1463 */ + IC_EVEX_L2_W_OPSIZE, /* 1464 */ + IC_EVEX_L2_W_OPSIZE, /* 1465 */ + IC_EVEX_L2_W_OPSIZE, /* 1466 */ + IC_EVEX_L2_W_OPSIZE, /* 1467 */ + IC_EVEX_L2_W_OPSIZE, /* 1468 */ + IC_EVEX_L2_W_OPSIZE, /* 1469 */ + IC_EVEX_L2_W_OPSIZE, /* 1470 */ + IC_EVEX_L2_W_OPSIZE, /* 1471 */ + IC_EVEX_L2, /* 1472 */ + IC_EVEX_L2, /* 1473 */ + IC_EVEX_L2_XS, /* 1474 */ + IC_EVEX_L2_XS, /* 1475 */ + IC_EVEX_L2_XD, /* 1476 */ + IC_EVEX_L2_XD, /* 1477 */ + IC_EVEX_L2_XD, /* 1478 */ + IC_EVEX_L2_XD, /* 1479 */ + IC_EVEX_L2_W, /* 1480 */ + IC_EVEX_L2_W, /* 1481 */ + IC_EVEX_L2_W_XS, /* 1482 */ + IC_EVEX_L2_W_XS, /* 1483 */ + IC_EVEX_L2_W_XD, /* 1484 */ + IC_EVEX_L2_W_XD, /* 1485 */ + IC_EVEX_L2_W_XD, /* 1486 */ + IC_EVEX_L2_W_XD, /* 1487 */ + IC_EVEX_L2_OPSIZE, /* 1488 */ + IC_EVEX_L2_OPSIZE, /* 1489 */ + IC_EVEX_L2_OPSIZE, /* 1490 */ + IC_EVEX_L2_OPSIZE, /* 1491 */ + IC_EVEX_L2_OPSIZE, /* 1492 */ + IC_EVEX_L2_OPSIZE, /* 1493 */ + IC_EVEX_L2_OPSIZE, /* 1494 */ + IC_EVEX_L2_OPSIZE, /* 1495 */ + IC_EVEX_L2_W_OPSIZE, /* 1496 */ + IC_EVEX_L2_W_OPSIZE, /* 1497 */ + IC_EVEX_L2_W_OPSIZE, /* 1498 */ + IC_EVEX_L2_W_OPSIZE, /* 1499 */ + IC_EVEX_L2_W_OPSIZE, /* 1500 */ + IC_EVEX_L2_W_OPSIZE, /* 1501 */ + IC_EVEX_L2_W_OPSIZE, /* 1502 */ + IC_EVEX_L2_W_OPSIZE, /* 1503 */ + IC_EVEX_L2, /* 1504 */ + IC_EVEX_L2, /* 1505 */ + IC_EVEX_L2_XS, /* 1506 */ + IC_EVEX_L2_XS, /* 1507 */ + IC_EVEX_L2_XD, /* 1508 */ + IC_EVEX_L2_XD, /* 1509 */ + IC_EVEX_L2_XD, /* 1510 */ + IC_EVEX_L2_XD, /* 1511 */ + IC_EVEX_L2_W, /* 1512 */ + IC_EVEX_L2_W, /* 1513 */ + IC_EVEX_L2_W_XS, /* 1514 */ + IC_EVEX_L2_W_XS, /* 1515 */ + IC_EVEX_L2_W_XD, /* 1516 */ + IC_EVEX_L2_W_XD, /* 1517 */ + IC_EVEX_L2_W_XD, /* 1518 */ + IC_EVEX_L2_W_XD, /* 1519 */ + IC_EVEX_L2_OPSIZE, /* 1520 */ + IC_EVEX_L2_OPSIZE, /* 1521 */ + IC_EVEX_L2_OPSIZE, /* 1522 */ + IC_EVEX_L2_OPSIZE, /* 1523 */ + IC_EVEX_L2_OPSIZE, /* 1524 */ + IC_EVEX_L2_OPSIZE, /* 1525 */ + IC_EVEX_L2_OPSIZE, /* 1526 */ + IC_EVEX_L2_OPSIZE, /* 1527 */ + IC_EVEX_L2_W_OPSIZE, /* 1528 */ + IC_EVEX_L2_W_OPSIZE, /* 1529 */ + IC_EVEX_L2_W_OPSIZE, /* 1530 */ + IC_EVEX_L2_W_OPSIZE, /* 1531 */ + IC_EVEX_L2_W_OPSIZE, /* 1532 */ + IC_EVEX_L2_W_OPSIZE, /* 1533 */ + IC_EVEX_L2_W_OPSIZE, /* 1534 */ + IC_EVEX_L2_W_OPSIZE, /* 1535 */ + IC, /* 1536 */ + IC_64BIT, /* 1537 */ + IC_XS, /* 1538 */ + IC_64BIT_XS, /* 1539 */ + IC_XD, /* 1540 */ + IC_64BIT_XD, /* 1541 */ + IC_XS, /* 1542 */ + IC_64BIT_XS, /* 1543 */ + IC, /* 1544 */ + IC_64BIT_REXW, /* 1545 */ + IC_XS, /* 1546 */ + IC_64BIT_REXW_XS, /* 1547 */ + IC_XD, /* 1548 */ + IC_64BIT_REXW_XD, /* 1549 */ + IC_XS, /* 1550 */ + IC_64BIT_REXW_XS, /* 1551 */ + IC_OPSIZE, /* 1552 */ + IC_64BIT_OPSIZE, /* 1553 */ + IC_XS_OPSIZE, /* 1554 */ + IC_64BIT_XS_OPSIZE, /* 1555 */ + IC_XD_OPSIZE, /* 1556 */ + IC_64BIT_XD_OPSIZE, /* 1557 */ + IC_XS_OPSIZE, /* 1558 */ + IC_64BIT_XD_OPSIZE, /* 1559 */ + IC_OPSIZE, /* 1560 */ + IC_64BIT_REXW_OPSIZE, /* 1561 */ + IC_XS_OPSIZE, /* 1562 */ + IC_64BIT_REXW_XS, /* 1563 */ + IC_XD_OPSIZE, /* 1564 */ + IC_64BIT_REXW_XD, /* 1565 */ + IC_XS_OPSIZE, /* 1566 */ + IC_64BIT_REXW_XS, /* 1567 */ + IC_ADSIZE, /* 1568 */ + IC_64BIT_ADSIZE, /* 1569 */ + IC_XS_ADSIZE, /* 1570 */ + IC_64BIT_XS_ADSIZE, /* 1571 */ + IC_XD_ADSIZE, /* 1572 */ + IC_64BIT_XD_ADSIZE, /* 1573 */ + IC_XS_ADSIZE, /* 1574 */ + IC_64BIT_XD_ADSIZE, /* 1575 */ + IC_ADSIZE, /* 1576 */ + IC_64BIT_REXW_ADSIZE, /* 1577 */ + IC_XS_ADSIZE, /* 1578 */ + IC_64BIT_REXW_XS, /* 1579 */ + IC_XD_ADSIZE, /* 1580 */ + IC_64BIT_REXW_XD, /* 1581 */ + IC_XS_ADSIZE, /* 1582 */ + IC_64BIT_REXW_XS, /* 1583 */ + IC_OPSIZE_ADSIZE, /* 1584 */ + IC_64BIT_OPSIZE_ADSIZE, /* 1585 */ + IC_XS_OPSIZE, /* 1586 */ + IC_64BIT_XS_OPSIZE, /* 1587 */ + IC_XD_OPSIZE, /* 1588 */ + IC_64BIT_XD_OPSIZE, /* 1589 */ + IC_XS_OPSIZE, /* 1590 */ + IC_64BIT_XD_OPSIZE, /* 1591 */ + IC_OPSIZE_ADSIZE, /* 1592 */ + IC_64BIT_REXW_OPSIZE, /* 1593 */ + IC_XS_OPSIZE, /* 1594 */ + IC_64BIT_REXW_XS, /* 1595 */ + IC_XD_OPSIZE, /* 1596 */ + IC_64BIT_REXW_XD, /* 1597 */ + IC_XS_OPSIZE, /* 1598 */ + IC_64BIT_REXW_XS, /* 1599 */ + IC_VEX, /* 1600 */ + IC_VEX, /* 1601 */ + IC_VEX_XS, /* 1602 */ + IC_VEX_XS, /* 1603 */ + IC_VEX_XD, /* 1604 */ + IC_VEX_XD, /* 1605 */ + IC_VEX_XD, /* 1606 */ + IC_VEX_XD, /* 1607 */ + IC_VEX_W, /* 1608 */ + IC_VEX_W, /* 1609 */ + IC_VEX_W_XS, /* 1610 */ + IC_VEX_W_XS, /* 1611 */ + IC_VEX_W_XD, /* 1612 */ + IC_VEX_W_XD, /* 1613 */ + IC_VEX_W_XD, /* 1614 */ + IC_VEX_W_XD, /* 1615 */ + IC_VEX_OPSIZE, /* 1616 */ + IC_VEX_OPSIZE, /* 1617 */ + IC_VEX_OPSIZE, /* 1618 */ + IC_VEX_OPSIZE, /* 1619 */ + IC_VEX_OPSIZE, /* 1620 */ + IC_VEX_OPSIZE, /* 1621 */ + IC_VEX_OPSIZE, /* 1622 */ + IC_VEX_OPSIZE, /* 1623 */ + IC_VEX_W_OPSIZE, /* 1624 */ + IC_VEX_W_OPSIZE, /* 1625 */ + IC_VEX_W_OPSIZE, /* 1626 */ + IC_VEX_W_OPSIZE, /* 1627 */ + IC_VEX_W_OPSIZE, /* 1628 */ + IC_VEX_W_OPSIZE, /* 1629 */ + IC_VEX_W_OPSIZE, /* 1630 */ + IC_VEX_W_OPSIZE, /* 1631 */ + IC_VEX, /* 1632 */ + IC_VEX, /* 1633 */ + IC_VEX_XS, /* 1634 */ + IC_VEX_XS, /* 1635 */ + IC_VEX_XD, /* 1636 */ + IC_VEX_XD, /* 1637 */ + IC_VEX_XD, /* 1638 */ + IC_VEX_XD, /* 1639 */ + IC_VEX_W, /* 1640 */ + IC_VEX_W, /* 1641 */ + IC_VEX_W_XS, /* 1642 */ + IC_VEX_W_XS, /* 1643 */ + IC_VEX_W_XD, /* 1644 */ + IC_VEX_W_XD, /* 1645 */ + IC_VEX_W_XD, /* 1646 */ + IC_VEX_W_XD, /* 1647 */ + IC_VEX_OPSIZE, /* 1648 */ + IC_VEX_OPSIZE, /* 1649 */ + IC_VEX_OPSIZE, /* 1650 */ + IC_VEX_OPSIZE, /* 1651 */ + IC_VEX_OPSIZE, /* 1652 */ + IC_VEX_OPSIZE, /* 1653 */ + IC_VEX_OPSIZE, /* 1654 */ + IC_VEX_OPSIZE, /* 1655 */ + IC_VEX_W_OPSIZE, /* 1656 */ + IC_VEX_W_OPSIZE, /* 1657 */ + IC_VEX_W_OPSIZE, /* 1658 */ + IC_VEX_W_OPSIZE, /* 1659 */ + IC_VEX_W_OPSIZE, /* 1660 */ + IC_VEX_W_OPSIZE, /* 1661 */ + IC_VEX_W_OPSIZE, /* 1662 */ + IC_VEX_W_OPSIZE, /* 1663 */ + IC_VEX_L, /* 1664 */ + IC_VEX_L, /* 1665 */ + IC_VEX_L_XS, /* 1666 */ + IC_VEX_L_XS, /* 1667 */ + IC_VEX_L_XD, /* 1668 */ + IC_VEX_L_XD, /* 1669 */ + IC_VEX_L_XD, /* 1670 */ + IC_VEX_L_XD, /* 1671 */ + IC_VEX_L_W, /* 1672 */ + IC_VEX_L_W, /* 1673 */ + IC_VEX_L_W_XS, /* 1674 */ + IC_VEX_L_W_XS, /* 1675 */ + IC_VEX_L_W_XD, /* 1676 */ + IC_VEX_L_W_XD, /* 1677 */ + IC_VEX_L_W_XD, /* 1678 */ + IC_VEX_L_W_XD, /* 1679 */ + IC_VEX_L_OPSIZE, /* 1680 */ + IC_VEX_L_OPSIZE, /* 1681 */ + IC_VEX_L_OPSIZE, /* 1682 */ + IC_VEX_L_OPSIZE, /* 1683 */ + IC_VEX_L_OPSIZE, /* 1684 */ + IC_VEX_L_OPSIZE, /* 1685 */ + IC_VEX_L_OPSIZE, /* 1686 */ + IC_VEX_L_OPSIZE, /* 1687 */ + IC_VEX_L_W_OPSIZE, /* 1688 */ + IC_VEX_L_W_OPSIZE, /* 1689 */ + IC_VEX_L_W_OPSIZE, /* 1690 */ + IC_VEX_L_W_OPSIZE, /* 1691 */ + IC_VEX_L_W_OPSIZE, /* 1692 */ + IC_VEX_L_W_OPSIZE, /* 1693 */ + IC_VEX_L_W_OPSIZE, /* 1694 */ + IC_VEX_L_W_OPSIZE, /* 1695 */ + IC_VEX_L, /* 1696 */ + IC_VEX_L, /* 1697 */ + IC_VEX_L_XS, /* 1698 */ + IC_VEX_L_XS, /* 1699 */ + IC_VEX_L_XD, /* 1700 */ + IC_VEX_L_XD, /* 1701 */ + IC_VEX_L_XD, /* 1702 */ + IC_VEX_L_XD, /* 1703 */ + IC_VEX_L_W, /* 1704 */ + IC_VEX_L_W, /* 1705 */ + IC_VEX_L_W_XS, /* 1706 */ + IC_VEX_L_W_XS, /* 1707 */ + IC_VEX_L_W_XD, /* 1708 */ + IC_VEX_L_W_XD, /* 1709 */ + IC_VEX_L_W_XD, /* 1710 */ + IC_VEX_L_W_XD, /* 1711 */ + IC_VEX_L_OPSIZE, /* 1712 */ + IC_VEX_L_OPSIZE, /* 1713 */ + IC_VEX_L_OPSIZE, /* 1714 */ + IC_VEX_L_OPSIZE, /* 1715 */ + IC_VEX_L_OPSIZE, /* 1716 */ + IC_VEX_L_OPSIZE, /* 1717 */ + IC_VEX_L_OPSIZE, /* 1718 */ + IC_VEX_L_OPSIZE, /* 1719 */ + IC_VEX_L_W_OPSIZE, /* 1720 */ + IC_VEX_L_W_OPSIZE, /* 1721 */ + IC_VEX_L_W_OPSIZE, /* 1722 */ + IC_VEX_L_W_OPSIZE, /* 1723 */ + IC_VEX_L_W_OPSIZE, /* 1724 */ + IC_VEX_L_W_OPSIZE, /* 1725 */ + IC_VEX_L_W_OPSIZE, /* 1726 */ + IC_VEX_L_W_OPSIZE, /* 1727 */ + IC_VEX_L, /* 1728 */ + IC_VEX_L, /* 1729 */ + IC_VEX_L_XS, /* 1730 */ + IC_VEX_L_XS, /* 1731 */ + IC_VEX_L_XD, /* 1732 */ + IC_VEX_L_XD, /* 1733 */ + IC_VEX_L_XD, /* 1734 */ + IC_VEX_L_XD, /* 1735 */ + IC_VEX_L_W, /* 1736 */ + IC_VEX_L_W, /* 1737 */ + IC_VEX_L_W_XS, /* 1738 */ + IC_VEX_L_W_XS, /* 1739 */ + IC_VEX_L_W_XD, /* 1740 */ + IC_VEX_L_W_XD, /* 1741 */ + IC_VEX_L_W_XD, /* 1742 */ + IC_VEX_L_W_XD, /* 1743 */ + IC_VEX_L_OPSIZE, /* 1744 */ + IC_VEX_L_OPSIZE, /* 1745 */ + IC_VEX_L_OPSIZE, /* 1746 */ + IC_VEX_L_OPSIZE, /* 1747 */ + IC_VEX_L_OPSIZE, /* 1748 */ + IC_VEX_L_OPSIZE, /* 1749 */ + IC_VEX_L_OPSIZE, /* 1750 */ + IC_VEX_L_OPSIZE, /* 1751 */ + IC_VEX_L_W_OPSIZE, /* 1752 */ + IC_VEX_L_W_OPSIZE, /* 1753 */ + IC_VEX_L_W_OPSIZE, /* 1754 */ + IC_VEX_L_W_OPSIZE, /* 1755 */ + IC_VEX_L_W_OPSIZE, /* 1756 */ + IC_VEX_L_W_OPSIZE, /* 1757 */ + IC_VEX_L_W_OPSIZE, /* 1758 */ + IC_VEX_L_W_OPSIZE, /* 1759 */ + IC_VEX_L, /* 1760 */ + IC_VEX_L, /* 1761 */ + IC_VEX_L_XS, /* 1762 */ + IC_VEX_L_XS, /* 1763 */ + IC_VEX_L_XD, /* 1764 */ + IC_VEX_L_XD, /* 1765 */ + IC_VEX_L_XD, /* 1766 */ + IC_VEX_L_XD, /* 1767 */ + IC_VEX_L_W, /* 1768 */ + IC_VEX_L_W, /* 1769 */ + IC_VEX_L_W_XS, /* 1770 */ + IC_VEX_L_W_XS, /* 1771 */ + IC_VEX_L_W_XD, /* 1772 */ + IC_VEX_L_W_XD, /* 1773 */ + IC_VEX_L_W_XD, /* 1774 */ + IC_VEX_L_W_XD, /* 1775 */ + IC_VEX_L_OPSIZE, /* 1776 */ + IC_VEX_L_OPSIZE, /* 1777 */ + IC_VEX_L_OPSIZE, /* 1778 */ + IC_VEX_L_OPSIZE, /* 1779 */ + IC_VEX_L_OPSIZE, /* 1780 */ + IC_VEX_L_OPSIZE, /* 1781 */ + IC_VEX_L_OPSIZE, /* 1782 */ + IC_VEX_L_OPSIZE, /* 1783 */ + IC_VEX_L_W_OPSIZE, /* 1784 */ + IC_VEX_L_W_OPSIZE, /* 1785 */ + IC_VEX_L_W_OPSIZE, /* 1786 */ + IC_VEX_L_W_OPSIZE, /* 1787 */ + IC_VEX_L_W_OPSIZE, /* 1788 */ + IC_VEX_L_W_OPSIZE, /* 1789 */ + IC_VEX_L_W_OPSIZE, /* 1790 */ + IC_VEX_L_W_OPSIZE, /* 1791 */ + IC_EVEX_L2, /* 1792 */ + IC_EVEX_L2, /* 1793 */ + IC_EVEX_L2_XS, /* 1794 */ + IC_EVEX_L2_XS, /* 1795 */ + IC_EVEX_L2_XD, /* 1796 */ + IC_EVEX_L2_XD, /* 1797 */ + IC_EVEX_L2_XD, /* 1798 */ + IC_EVEX_L2_XD, /* 1799 */ + IC_EVEX_L2_W, /* 1800 */ + IC_EVEX_L2_W, /* 1801 */ + IC_EVEX_L2_W_XS, /* 1802 */ + IC_EVEX_L2_W_XS, /* 1803 */ + IC_EVEX_L2_W_XD, /* 1804 */ + IC_EVEX_L2_W_XD, /* 1805 */ + IC_EVEX_L2_W_XD, /* 1806 */ + IC_EVEX_L2_W_XD, /* 1807 */ + IC_EVEX_L2_OPSIZE, /* 1808 */ + IC_EVEX_L2_OPSIZE, /* 1809 */ + IC_EVEX_L2_OPSIZE, /* 1810 */ + IC_EVEX_L2_OPSIZE, /* 1811 */ + IC_EVEX_L2_OPSIZE, /* 1812 */ + IC_EVEX_L2_OPSIZE, /* 1813 */ + IC_EVEX_L2_OPSIZE, /* 1814 */ + IC_EVEX_L2_OPSIZE, /* 1815 */ + IC_EVEX_L2_W_OPSIZE, /* 1816 */ + IC_EVEX_L2_W_OPSIZE, /* 1817 */ + IC_EVEX_L2_W_OPSIZE, /* 1818 */ + IC_EVEX_L2_W_OPSIZE, /* 1819 */ + IC_EVEX_L2_W_OPSIZE, /* 1820 */ + IC_EVEX_L2_W_OPSIZE, /* 1821 */ + IC_EVEX_L2_W_OPSIZE, /* 1822 */ + IC_EVEX_L2_W_OPSIZE, /* 1823 */ + IC_EVEX_L2, /* 1824 */ + IC_EVEX_L2, /* 1825 */ + IC_EVEX_L2_XS, /* 1826 */ + IC_EVEX_L2_XS, /* 1827 */ + IC_EVEX_L2_XD, /* 1828 */ + IC_EVEX_L2_XD, /* 1829 */ + IC_EVEX_L2_XD, /* 1830 */ + IC_EVEX_L2_XD, /* 1831 */ + IC_EVEX_L2_W, /* 1832 */ + IC_EVEX_L2_W, /* 1833 */ + IC_EVEX_L2_W_XS, /* 1834 */ + IC_EVEX_L2_W_XS, /* 1835 */ + IC_EVEX_L2_W_XD, /* 1836 */ + IC_EVEX_L2_W_XD, /* 1837 */ + IC_EVEX_L2_W_XD, /* 1838 */ + IC_EVEX_L2_W_XD, /* 1839 */ + IC_EVEX_L2_OPSIZE, /* 1840 */ + IC_EVEX_L2_OPSIZE, /* 1841 */ + IC_EVEX_L2_OPSIZE, /* 1842 */ + IC_EVEX_L2_OPSIZE, /* 1843 */ + IC_EVEX_L2_OPSIZE, /* 1844 */ + IC_EVEX_L2_OPSIZE, /* 1845 */ + IC_EVEX_L2_OPSIZE, /* 1846 */ + IC_EVEX_L2_OPSIZE, /* 1847 */ + IC_EVEX_L2_W_OPSIZE, /* 1848 */ + IC_EVEX_L2_W_OPSIZE, /* 1849 */ + IC_EVEX_L2_W_OPSIZE, /* 1850 */ + IC_EVEX_L2_W_OPSIZE, /* 1851 */ + IC_EVEX_L2_W_OPSIZE, /* 1852 */ + IC_EVEX_L2_W_OPSIZE, /* 1853 */ + IC_EVEX_L2_W_OPSIZE, /* 1854 */ + IC_EVEX_L2_W_OPSIZE, /* 1855 */ + IC_EVEX_L2, /* 1856 */ + IC_EVEX_L2, /* 1857 */ + IC_EVEX_L2_XS, /* 1858 */ + IC_EVEX_L2_XS, /* 1859 */ + IC_EVEX_L2_XD, /* 1860 */ + IC_EVEX_L2_XD, /* 1861 */ + IC_EVEX_L2_XD, /* 1862 */ + IC_EVEX_L2_XD, /* 1863 */ + IC_EVEX_L2_W, /* 1864 */ + IC_EVEX_L2_W, /* 1865 */ + IC_EVEX_L2_W_XS, /* 1866 */ + IC_EVEX_L2_W_XS, /* 1867 */ + IC_EVEX_L2_W_XD, /* 1868 */ + IC_EVEX_L2_W_XD, /* 1869 */ + IC_EVEX_L2_W_XD, /* 1870 */ + IC_EVEX_L2_W_XD, /* 1871 */ + IC_EVEX_L2_OPSIZE, /* 1872 */ + IC_EVEX_L2_OPSIZE, /* 1873 */ + IC_EVEX_L2_OPSIZE, /* 1874 */ + IC_EVEX_L2_OPSIZE, /* 1875 */ + IC_EVEX_L2_OPSIZE, /* 1876 */ + IC_EVEX_L2_OPSIZE, /* 1877 */ + IC_EVEX_L2_OPSIZE, /* 1878 */ + IC_EVEX_L2_OPSIZE, /* 1879 */ + IC_EVEX_L2_W_OPSIZE, /* 1880 */ + IC_EVEX_L2_W_OPSIZE, /* 1881 */ + IC_EVEX_L2_W_OPSIZE, /* 1882 */ + IC_EVEX_L2_W_OPSIZE, /* 1883 */ + IC_EVEX_L2_W_OPSIZE, /* 1884 */ + IC_EVEX_L2_W_OPSIZE, /* 1885 */ + IC_EVEX_L2_W_OPSIZE, /* 1886 */ + IC_EVEX_L2_W_OPSIZE, /* 1887 */ + IC_EVEX_L2, /* 1888 */ + IC_EVEX_L2, /* 1889 */ + IC_EVEX_L2_XS, /* 1890 */ + IC_EVEX_L2_XS, /* 1891 */ + IC_EVEX_L2_XD, /* 1892 */ + IC_EVEX_L2_XD, /* 1893 */ + IC_EVEX_L2_XD, /* 1894 */ + IC_EVEX_L2_XD, /* 1895 */ + IC_EVEX_L2_W, /* 1896 */ + IC_EVEX_L2_W, /* 1897 */ + IC_EVEX_L2_W_XS, /* 1898 */ + IC_EVEX_L2_W_XS, /* 1899 */ + IC_EVEX_L2_W_XD, /* 1900 */ + IC_EVEX_L2_W_XD, /* 1901 */ + IC_EVEX_L2_W_XD, /* 1902 */ + IC_EVEX_L2_W_XD, /* 1903 */ + IC_EVEX_L2_OPSIZE, /* 1904 */ + IC_EVEX_L2_OPSIZE, /* 1905 */ + IC_EVEX_L2_OPSIZE, /* 1906 */ + IC_EVEX_L2_OPSIZE, /* 1907 */ + IC_EVEX_L2_OPSIZE, /* 1908 */ + IC_EVEX_L2_OPSIZE, /* 1909 */ + IC_EVEX_L2_OPSIZE, /* 1910 */ + IC_EVEX_L2_OPSIZE, /* 1911 */ + IC_EVEX_L2_W_OPSIZE, /* 1912 */ + IC_EVEX_L2_W_OPSIZE, /* 1913 */ + IC_EVEX_L2_W_OPSIZE, /* 1914 */ + IC_EVEX_L2_W_OPSIZE, /* 1915 */ + IC_EVEX_L2_W_OPSIZE, /* 1916 */ + IC_EVEX_L2_W_OPSIZE, /* 1917 */ + IC_EVEX_L2_W_OPSIZE, /* 1918 */ + IC_EVEX_L2_W_OPSIZE, /* 1919 */ + IC_EVEX_L2, /* 1920 */ + IC_EVEX_L2, /* 1921 */ + IC_EVEX_L2_XS, /* 1922 */ + IC_EVEX_L2_XS, /* 1923 */ + IC_EVEX_L2_XD, /* 1924 */ + IC_EVEX_L2_XD, /* 1925 */ + IC_EVEX_L2_XD, /* 1926 */ + IC_EVEX_L2_XD, /* 1927 */ + IC_EVEX_L2_W, /* 1928 */ + IC_EVEX_L2_W, /* 1929 */ + IC_EVEX_L2_W_XS, /* 1930 */ + IC_EVEX_L2_W_XS, /* 1931 */ + IC_EVEX_L2_W_XD, /* 1932 */ + IC_EVEX_L2_W_XD, /* 1933 */ + IC_EVEX_L2_W_XD, /* 1934 */ + IC_EVEX_L2_W_XD, /* 1935 */ + IC_EVEX_L2_OPSIZE, /* 1936 */ + IC_EVEX_L2_OPSIZE, /* 1937 */ + IC_EVEX_L2_OPSIZE, /* 1938 */ + IC_EVEX_L2_OPSIZE, /* 1939 */ + IC_EVEX_L2_OPSIZE, /* 1940 */ + IC_EVEX_L2_OPSIZE, /* 1941 */ + IC_EVEX_L2_OPSIZE, /* 1942 */ + IC_EVEX_L2_OPSIZE, /* 1943 */ + IC_EVEX_L2_W_OPSIZE, /* 1944 */ + IC_EVEX_L2_W_OPSIZE, /* 1945 */ + IC_EVEX_L2_W_OPSIZE, /* 1946 */ + IC_EVEX_L2_W_OPSIZE, /* 1947 */ + IC_EVEX_L2_W_OPSIZE, /* 1948 */ + IC_EVEX_L2_W_OPSIZE, /* 1949 */ + IC_EVEX_L2_W_OPSIZE, /* 1950 */ + IC_EVEX_L2_W_OPSIZE, /* 1951 */ + IC_EVEX_L2, /* 1952 */ + IC_EVEX_L2, /* 1953 */ + IC_EVEX_L2_XS, /* 1954 */ + IC_EVEX_L2_XS, /* 1955 */ + IC_EVEX_L2_XD, /* 1956 */ + IC_EVEX_L2_XD, /* 1957 */ + IC_EVEX_L2_XD, /* 1958 */ + IC_EVEX_L2_XD, /* 1959 */ + IC_EVEX_L2_W, /* 1960 */ + IC_EVEX_L2_W, /* 1961 */ + IC_EVEX_L2_W_XS, /* 1962 */ + IC_EVEX_L2_W_XS, /* 1963 */ + IC_EVEX_L2_W_XD, /* 1964 */ + IC_EVEX_L2_W_XD, /* 1965 */ + IC_EVEX_L2_W_XD, /* 1966 */ + IC_EVEX_L2_W_XD, /* 1967 */ + IC_EVEX_L2_OPSIZE, /* 1968 */ + IC_EVEX_L2_OPSIZE, /* 1969 */ + IC_EVEX_L2_OPSIZE, /* 1970 */ + IC_EVEX_L2_OPSIZE, /* 1971 */ + IC_EVEX_L2_OPSIZE, /* 1972 */ + IC_EVEX_L2_OPSIZE, /* 1973 */ + IC_EVEX_L2_OPSIZE, /* 1974 */ + IC_EVEX_L2_OPSIZE, /* 1975 */ + IC_EVEX_L2_W_OPSIZE, /* 1976 */ + IC_EVEX_L2_W_OPSIZE, /* 1977 */ + IC_EVEX_L2_W_OPSIZE, /* 1978 */ + IC_EVEX_L2_W_OPSIZE, /* 1979 */ + IC_EVEX_L2_W_OPSIZE, /* 1980 */ + IC_EVEX_L2_W_OPSIZE, /* 1981 */ + IC_EVEX_L2_W_OPSIZE, /* 1982 */ + IC_EVEX_L2_W_OPSIZE, /* 1983 */ + IC_EVEX_L2, /* 1984 */ + IC_EVEX_L2, /* 1985 */ + IC_EVEX_L2_XS, /* 1986 */ + IC_EVEX_L2_XS, /* 1987 */ + IC_EVEX_L2_XD, /* 1988 */ + IC_EVEX_L2_XD, /* 1989 */ + IC_EVEX_L2_XD, /* 1990 */ + IC_EVEX_L2_XD, /* 1991 */ + IC_EVEX_L2_W, /* 1992 */ + IC_EVEX_L2_W, /* 1993 */ + IC_EVEX_L2_W_XS, /* 1994 */ + IC_EVEX_L2_W_XS, /* 1995 */ + IC_EVEX_L2_W_XD, /* 1996 */ + IC_EVEX_L2_W_XD, /* 1997 */ + IC_EVEX_L2_W_XD, /* 1998 */ + IC_EVEX_L2_W_XD, /* 1999 */ + IC_EVEX_L2_OPSIZE, /* 2000 */ + IC_EVEX_L2_OPSIZE, /* 2001 */ + IC_EVEX_L2_OPSIZE, /* 2002 */ + IC_EVEX_L2_OPSIZE, /* 2003 */ + IC_EVEX_L2_OPSIZE, /* 2004 */ + IC_EVEX_L2_OPSIZE, /* 2005 */ + IC_EVEX_L2_OPSIZE, /* 2006 */ + IC_EVEX_L2_OPSIZE, /* 2007 */ + IC_EVEX_L2_W_OPSIZE, /* 2008 */ + IC_EVEX_L2_W_OPSIZE, /* 2009 */ + IC_EVEX_L2_W_OPSIZE, /* 2010 */ + IC_EVEX_L2_W_OPSIZE, /* 2011 */ + IC_EVEX_L2_W_OPSIZE, /* 2012 */ + IC_EVEX_L2_W_OPSIZE, /* 2013 */ + IC_EVEX_L2_W_OPSIZE, /* 2014 */ + IC_EVEX_L2_W_OPSIZE, /* 2015 */ + IC_EVEX_L2, /* 2016 */ + IC_EVEX_L2, /* 2017 */ + IC_EVEX_L2_XS, /* 2018 */ + IC_EVEX_L2_XS, /* 2019 */ + IC_EVEX_L2_XD, /* 2020 */ + IC_EVEX_L2_XD, /* 2021 */ + IC_EVEX_L2_XD, /* 2022 */ + IC_EVEX_L2_XD, /* 2023 */ + IC_EVEX_L2_W, /* 2024 */ + IC_EVEX_L2_W, /* 2025 */ + IC_EVEX_L2_W_XS, /* 2026 */ + IC_EVEX_L2_W_XS, /* 2027 */ + IC_EVEX_L2_W_XD, /* 2028 */ + IC_EVEX_L2_W_XD, /* 2029 */ + IC_EVEX_L2_W_XD, /* 2030 */ + IC_EVEX_L2_W_XD, /* 2031 */ + IC_EVEX_L2_OPSIZE, /* 2032 */ + IC_EVEX_L2_OPSIZE, /* 2033 */ + IC_EVEX_L2_OPSIZE, /* 2034 */ + IC_EVEX_L2_OPSIZE, /* 2035 */ + IC_EVEX_L2_OPSIZE, /* 2036 */ + IC_EVEX_L2_OPSIZE, /* 2037 */ + IC_EVEX_L2_OPSIZE, /* 2038 */ + IC_EVEX_L2_OPSIZE, /* 2039 */ + IC_EVEX_L2_W_OPSIZE, /* 2040 */ + IC_EVEX_L2_W_OPSIZE, /* 2041 */ + IC_EVEX_L2_W_OPSIZE, /* 2042 */ + IC_EVEX_L2_W_OPSIZE, /* 2043 */ + IC_EVEX_L2_W_OPSIZE, /* 2044 */ + IC_EVEX_L2_W_OPSIZE, /* 2045 */ + IC_EVEX_L2_W_OPSIZE, /* 2046 */ + IC_EVEX_L2_W_OPSIZE, /* 2047 */ + IC, /* 2048 */ + IC_64BIT, /* 2049 */ + IC_XS, /* 2050 */ + IC_64BIT_XS, /* 2051 */ + IC_XD, /* 2052 */ + IC_64BIT_XD, /* 2053 */ + IC_XS, /* 2054 */ + IC_64BIT_XS, /* 2055 */ + IC, /* 2056 */ + IC_64BIT_REXW, /* 2057 */ + IC_XS, /* 2058 */ + IC_64BIT_REXW_XS, /* 2059 */ + IC_XD, /* 2060 */ + IC_64BIT_REXW_XD, /* 2061 */ + IC_XS, /* 2062 */ + IC_64BIT_REXW_XS, /* 2063 */ + IC_OPSIZE, /* 2064 */ + IC_64BIT_OPSIZE, /* 2065 */ + IC_XS_OPSIZE, /* 2066 */ + IC_64BIT_XS_OPSIZE, /* 2067 */ + IC_XD_OPSIZE, /* 2068 */ + IC_64BIT_XD_OPSIZE, /* 2069 */ + IC_XS_OPSIZE, /* 2070 */ + IC_64BIT_XD_OPSIZE, /* 2071 */ + IC_OPSIZE, /* 2072 */ + IC_64BIT_REXW_OPSIZE, /* 2073 */ + IC_XS_OPSIZE, /* 2074 */ + IC_64BIT_REXW_XS, /* 2075 */ + IC_XD_OPSIZE, /* 2076 */ + IC_64BIT_REXW_XD, /* 2077 */ + IC_XS_OPSIZE, /* 2078 */ + IC_64BIT_REXW_XS, /* 2079 */ + IC_ADSIZE, /* 2080 */ + IC_64BIT_ADSIZE, /* 2081 */ + IC_XS_ADSIZE, /* 2082 */ + IC_64BIT_XS_ADSIZE, /* 2083 */ + IC_XD_ADSIZE, /* 2084 */ + IC_64BIT_XD_ADSIZE, /* 2085 */ + IC_XS_ADSIZE, /* 2086 */ + IC_64BIT_XD_ADSIZE, /* 2087 */ + IC_ADSIZE, /* 2088 */ + IC_64BIT_REXW_ADSIZE, /* 2089 */ + IC_XS_ADSIZE, /* 2090 */ + IC_64BIT_REXW_XS, /* 2091 */ + IC_XD_ADSIZE, /* 2092 */ + IC_64BIT_REXW_XD, /* 2093 */ + IC_XS_ADSIZE, /* 2094 */ + IC_64BIT_REXW_XS, /* 2095 */ + IC_OPSIZE_ADSIZE, /* 2096 */ + IC_64BIT_OPSIZE_ADSIZE, /* 2097 */ + IC_XS_OPSIZE, /* 2098 */ + IC_64BIT_XS_OPSIZE, /* 2099 */ + IC_XD_OPSIZE, /* 2100 */ + IC_64BIT_XD_OPSIZE, /* 2101 */ + IC_XS_OPSIZE, /* 2102 */ + IC_64BIT_XD_OPSIZE, /* 2103 */ + IC_OPSIZE_ADSIZE, /* 2104 */ + IC_64BIT_REXW_OPSIZE, /* 2105 */ + IC_XS_OPSIZE, /* 2106 */ + IC_64BIT_REXW_XS, /* 2107 */ + IC_XD_OPSIZE, /* 2108 */ + IC_64BIT_REXW_XD, /* 2109 */ + IC_XS_OPSIZE, /* 2110 */ + IC_64BIT_REXW_XS, /* 2111 */ + IC_VEX, /* 2112 */ + IC_VEX, /* 2113 */ + IC_VEX_XS, /* 2114 */ + IC_VEX_XS, /* 2115 */ + IC_VEX_XD, /* 2116 */ + IC_VEX_XD, /* 2117 */ + IC_VEX_XD, /* 2118 */ + IC_VEX_XD, /* 2119 */ + IC_VEX_W, /* 2120 */ + IC_VEX_W, /* 2121 */ + IC_VEX_W_XS, /* 2122 */ + IC_VEX_W_XS, /* 2123 */ + IC_VEX_W_XD, /* 2124 */ + IC_VEX_W_XD, /* 2125 */ + IC_VEX_W_XD, /* 2126 */ + IC_VEX_W_XD, /* 2127 */ + IC_VEX_OPSIZE, /* 2128 */ + IC_VEX_OPSIZE, /* 2129 */ + IC_VEX_OPSIZE, /* 2130 */ + IC_VEX_OPSIZE, /* 2131 */ + IC_VEX_OPSIZE, /* 2132 */ + IC_VEX_OPSIZE, /* 2133 */ + IC_VEX_OPSIZE, /* 2134 */ + IC_VEX_OPSIZE, /* 2135 */ + IC_VEX_W_OPSIZE, /* 2136 */ + IC_VEX_W_OPSIZE, /* 2137 */ + IC_VEX_W_OPSIZE, /* 2138 */ + IC_VEX_W_OPSIZE, /* 2139 */ + IC_VEX_W_OPSIZE, /* 2140 */ + IC_VEX_W_OPSIZE, /* 2141 */ + IC_VEX_W_OPSIZE, /* 2142 */ + IC_VEX_W_OPSIZE, /* 2143 */ + IC_VEX, /* 2144 */ + IC_VEX, /* 2145 */ + IC_VEX_XS, /* 2146 */ + IC_VEX_XS, /* 2147 */ + IC_VEX_XD, /* 2148 */ + IC_VEX_XD, /* 2149 */ + IC_VEX_XD, /* 2150 */ + IC_VEX_XD, /* 2151 */ + IC_VEX_W, /* 2152 */ + IC_VEX_W, /* 2153 */ + IC_VEX_W_XS, /* 2154 */ + IC_VEX_W_XS, /* 2155 */ + IC_VEX_W_XD, /* 2156 */ + IC_VEX_W_XD, /* 2157 */ + IC_VEX_W_XD, /* 2158 */ + IC_VEX_W_XD, /* 2159 */ + IC_VEX_OPSIZE, /* 2160 */ + IC_VEX_OPSIZE, /* 2161 */ + IC_VEX_OPSIZE, /* 2162 */ + IC_VEX_OPSIZE, /* 2163 */ + IC_VEX_OPSIZE, /* 2164 */ + IC_VEX_OPSIZE, /* 2165 */ + IC_VEX_OPSIZE, /* 2166 */ + IC_VEX_OPSIZE, /* 2167 */ + IC_VEX_W_OPSIZE, /* 2168 */ + IC_VEX_W_OPSIZE, /* 2169 */ + IC_VEX_W_OPSIZE, /* 2170 */ + IC_VEX_W_OPSIZE, /* 2171 */ + IC_VEX_W_OPSIZE, /* 2172 */ + IC_VEX_W_OPSIZE, /* 2173 */ + IC_VEX_W_OPSIZE, /* 2174 */ + IC_VEX_W_OPSIZE, /* 2175 */ + IC_VEX_L, /* 2176 */ + IC_VEX_L, /* 2177 */ + IC_VEX_L_XS, /* 2178 */ + IC_VEX_L_XS, /* 2179 */ + IC_VEX_L_XD, /* 2180 */ + IC_VEX_L_XD, /* 2181 */ + IC_VEX_L_XD, /* 2182 */ + IC_VEX_L_XD, /* 2183 */ + IC_VEX_L_W, /* 2184 */ + IC_VEX_L_W, /* 2185 */ + IC_VEX_L_W_XS, /* 2186 */ + IC_VEX_L_W_XS, /* 2187 */ + IC_VEX_L_W_XD, /* 2188 */ + IC_VEX_L_W_XD, /* 2189 */ + IC_VEX_L_W_XD, /* 2190 */ + IC_VEX_L_W_XD, /* 2191 */ + IC_VEX_L_OPSIZE, /* 2192 */ + IC_VEX_L_OPSIZE, /* 2193 */ + IC_VEX_L_OPSIZE, /* 2194 */ + IC_VEX_L_OPSIZE, /* 2195 */ + IC_VEX_L_OPSIZE, /* 2196 */ + IC_VEX_L_OPSIZE, /* 2197 */ + IC_VEX_L_OPSIZE, /* 2198 */ + IC_VEX_L_OPSIZE, /* 2199 */ + IC_VEX_L_W_OPSIZE, /* 2200 */ + IC_VEX_L_W_OPSIZE, /* 2201 */ + IC_VEX_L_W_OPSIZE, /* 2202 */ + IC_VEX_L_W_OPSIZE, /* 2203 */ + IC_VEX_L_W_OPSIZE, /* 2204 */ + IC_VEX_L_W_OPSIZE, /* 2205 */ + IC_VEX_L_W_OPSIZE, /* 2206 */ + IC_VEX_L_W_OPSIZE, /* 2207 */ + IC_VEX_L, /* 2208 */ + IC_VEX_L, /* 2209 */ + IC_VEX_L_XS, /* 2210 */ + IC_VEX_L_XS, /* 2211 */ + IC_VEX_L_XD, /* 2212 */ + IC_VEX_L_XD, /* 2213 */ + IC_VEX_L_XD, /* 2214 */ + IC_VEX_L_XD, /* 2215 */ + IC_VEX_L_W, /* 2216 */ + IC_VEX_L_W, /* 2217 */ + IC_VEX_L_W_XS, /* 2218 */ + IC_VEX_L_W_XS, /* 2219 */ + IC_VEX_L_W_XD, /* 2220 */ + IC_VEX_L_W_XD, /* 2221 */ + IC_VEX_L_W_XD, /* 2222 */ + IC_VEX_L_W_XD, /* 2223 */ + IC_VEX_L_OPSIZE, /* 2224 */ + IC_VEX_L_OPSIZE, /* 2225 */ + IC_VEX_L_OPSIZE, /* 2226 */ + IC_VEX_L_OPSIZE, /* 2227 */ + IC_VEX_L_OPSIZE, /* 2228 */ + IC_VEX_L_OPSIZE, /* 2229 */ + IC_VEX_L_OPSIZE, /* 2230 */ + IC_VEX_L_OPSIZE, /* 2231 */ + IC_VEX_L_W_OPSIZE, /* 2232 */ + IC_VEX_L_W_OPSIZE, /* 2233 */ + IC_VEX_L_W_OPSIZE, /* 2234 */ + IC_VEX_L_W_OPSIZE, /* 2235 */ + IC_VEX_L_W_OPSIZE, /* 2236 */ + IC_VEX_L_W_OPSIZE, /* 2237 */ + IC_VEX_L_W_OPSIZE, /* 2238 */ + IC_VEX_L_W_OPSIZE, /* 2239 */ + IC_VEX_L, /* 2240 */ + IC_VEX_L, /* 2241 */ + IC_VEX_L_XS, /* 2242 */ + IC_VEX_L_XS, /* 2243 */ + IC_VEX_L_XD, /* 2244 */ + IC_VEX_L_XD, /* 2245 */ + IC_VEX_L_XD, /* 2246 */ + IC_VEX_L_XD, /* 2247 */ + IC_VEX_L_W, /* 2248 */ + IC_VEX_L_W, /* 2249 */ + IC_VEX_L_W_XS, /* 2250 */ + IC_VEX_L_W_XS, /* 2251 */ + IC_VEX_L_W_XD, /* 2252 */ + IC_VEX_L_W_XD, /* 2253 */ + IC_VEX_L_W_XD, /* 2254 */ + IC_VEX_L_W_XD, /* 2255 */ + IC_VEX_L_OPSIZE, /* 2256 */ + IC_VEX_L_OPSIZE, /* 2257 */ + IC_VEX_L_OPSIZE, /* 2258 */ + IC_VEX_L_OPSIZE, /* 2259 */ + IC_VEX_L_OPSIZE, /* 2260 */ + IC_VEX_L_OPSIZE, /* 2261 */ + IC_VEX_L_OPSIZE, /* 2262 */ + IC_VEX_L_OPSIZE, /* 2263 */ + IC_VEX_L_W_OPSIZE, /* 2264 */ + IC_VEX_L_W_OPSIZE, /* 2265 */ + IC_VEX_L_W_OPSIZE, /* 2266 */ + IC_VEX_L_W_OPSIZE, /* 2267 */ + IC_VEX_L_W_OPSIZE, /* 2268 */ + IC_VEX_L_W_OPSIZE, /* 2269 */ + IC_VEX_L_W_OPSIZE, /* 2270 */ + IC_VEX_L_W_OPSIZE, /* 2271 */ + IC_VEX_L, /* 2272 */ + IC_VEX_L, /* 2273 */ + IC_VEX_L_XS, /* 2274 */ + IC_VEX_L_XS, /* 2275 */ + IC_VEX_L_XD, /* 2276 */ + IC_VEX_L_XD, /* 2277 */ + IC_VEX_L_XD, /* 2278 */ + IC_VEX_L_XD, /* 2279 */ + IC_VEX_L_W, /* 2280 */ + IC_VEX_L_W, /* 2281 */ + IC_VEX_L_W_XS, /* 2282 */ + IC_VEX_L_W_XS, /* 2283 */ + IC_VEX_L_W_XD, /* 2284 */ + IC_VEX_L_W_XD, /* 2285 */ + IC_VEX_L_W_XD, /* 2286 */ + IC_VEX_L_W_XD, /* 2287 */ + IC_VEX_L_OPSIZE, /* 2288 */ + IC_VEX_L_OPSIZE, /* 2289 */ + IC_VEX_L_OPSIZE, /* 2290 */ + IC_VEX_L_OPSIZE, /* 2291 */ + IC_VEX_L_OPSIZE, /* 2292 */ + IC_VEX_L_OPSIZE, /* 2293 */ + IC_VEX_L_OPSIZE, /* 2294 */ + IC_VEX_L_OPSIZE, /* 2295 */ + IC_VEX_L_W_OPSIZE, /* 2296 */ + IC_VEX_L_W_OPSIZE, /* 2297 */ + IC_VEX_L_W_OPSIZE, /* 2298 */ + IC_VEX_L_W_OPSIZE, /* 2299 */ + IC_VEX_L_W_OPSIZE, /* 2300 */ + IC_VEX_L_W_OPSIZE, /* 2301 */ + IC_VEX_L_W_OPSIZE, /* 2302 */ + IC_VEX_L_W_OPSIZE, /* 2303 */ + IC_EVEX_K, /* 2304 */ + IC_EVEX_K, /* 2305 */ + IC_EVEX_XS_K, /* 2306 */ + IC_EVEX_XS_K, /* 2307 */ + IC_EVEX_XD_K, /* 2308 */ + IC_EVEX_XD_K, /* 2309 */ + IC_EVEX_XD_K, /* 2310 */ + IC_EVEX_XD_K, /* 2311 */ + IC_EVEX_W_K, /* 2312 */ + IC_EVEX_W_K, /* 2313 */ + IC_EVEX_W_XS_K, /* 2314 */ + IC_EVEX_W_XS_K, /* 2315 */ + IC_EVEX_W_XD_K, /* 2316 */ + IC_EVEX_W_XD_K, /* 2317 */ + IC_EVEX_W_XD_K, /* 2318 */ + IC_EVEX_W_XD_K, /* 2319 */ + IC_EVEX_OPSIZE_K, /* 2320 */ + IC_EVEX_OPSIZE_K, /* 2321 */ + IC_EVEX_OPSIZE_K, /* 2322 */ + IC_EVEX_OPSIZE_K, /* 2323 */ + IC_EVEX_OPSIZE_K, /* 2324 */ + IC_EVEX_OPSIZE_K, /* 2325 */ + IC_EVEX_OPSIZE_K, /* 2326 */ + IC_EVEX_OPSIZE_K, /* 2327 */ + IC_EVEX_W_OPSIZE_K, /* 2328 */ + IC_EVEX_W_OPSIZE_K, /* 2329 */ + IC_EVEX_W_OPSIZE_K, /* 2330 */ + IC_EVEX_W_OPSIZE_K, /* 2331 */ + IC_EVEX_W_OPSIZE_K, /* 2332 */ + IC_EVEX_W_OPSIZE_K, /* 2333 */ + IC_EVEX_W_OPSIZE_K, /* 2334 */ + IC_EVEX_W_OPSIZE_K, /* 2335 */ + IC_EVEX_K, /* 2336 */ + IC_EVEX_K, /* 2337 */ + IC_EVEX_XS_K, /* 2338 */ + IC_EVEX_XS_K, /* 2339 */ + IC_EVEX_XD_K, /* 2340 */ + IC_EVEX_XD_K, /* 2341 */ + IC_EVEX_XD_K, /* 2342 */ + IC_EVEX_XD_K, /* 2343 */ + IC_EVEX_W_K, /* 2344 */ + IC_EVEX_W_K, /* 2345 */ + IC_EVEX_W_XS_K, /* 2346 */ + IC_EVEX_W_XS_K, /* 2347 */ + IC_EVEX_W_XD_K, /* 2348 */ + IC_EVEX_W_XD_K, /* 2349 */ + IC_EVEX_W_XD_K, /* 2350 */ + IC_EVEX_W_XD_K, /* 2351 */ + IC_EVEX_OPSIZE_K, /* 2352 */ + IC_EVEX_OPSIZE_K, /* 2353 */ + IC_EVEX_OPSIZE_K, /* 2354 */ + IC_EVEX_OPSIZE_K, /* 2355 */ + IC_EVEX_OPSIZE_K, /* 2356 */ + IC_EVEX_OPSIZE_K, /* 2357 */ + IC_EVEX_OPSIZE_K, /* 2358 */ + IC_EVEX_OPSIZE_K, /* 2359 */ + IC_EVEX_W_OPSIZE_K, /* 2360 */ + IC_EVEX_W_OPSIZE_K, /* 2361 */ + IC_EVEX_W_OPSIZE_K, /* 2362 */ + IC_EVEX_W_OPSIZE_K, /* 2363 */ + IC_EVEX_W_OPSIZE_K, /* 2364 */ + IC_EVEX_W_OPSIZE_K, /* 2365 */ + IC_EVEX_W_OPSIZE_K, /* 2366 */ + IC_EVEX_W_OPSIZE_K, /* 2367 */ + IC_EVEX_K, /* 2368 */ + IC_EVEX_K, /* 2369 */ + IC_EVEX_XS_K, /* 2370 */ + IC_EVEX_XS_K, /* 2371 */ + IC_EVEX_XD_K, /* 2372 */ + IC_EVEX_XD_K, /* 2373 */ + IC_EVEX_XD_K, /* 2374 */ + IC_EVEX_XD_K, /* 2375 */ + IC_EVEX_W_K, /* 2376 */ + IC_EVEX_W_K, /* 2377 */ + IC_EVEX_W_XS_K, /* 2378 */ + IC_EVEX_W_XS_K, /* 2379 */ + IC_EVEX_W_XD_K, /* 2380 */ + IC_EVEX_W_XD_K, /* 2381 */ + IC_EVEX_W_XD_K, /* 2382 */ + IC_EVEX_W_XD_K, /* 2383 */ + IC_EVEX_OPSIZE_K, /* 2384 */ + IC_EVEX_OPSIZE_K, /* 2385 */ + IC_EVEX_OPSIZE_K, /* 2386 */ + IC_EVEX_OPSIZE_K, /* 2387 */ + IC_EVEX_OPSIZE_K, /* 2388 */ + IC_EVEX_OPSIZE_K, /* 2389 */ + IC_EVEX_OPSIZE_K, /* 2390 */ + IC_EVEX_OPSIZE_K, /* 2391 */ + IC_EVEX_W_OPSIZE_K, /* 2392 */ + IC_EVEX_W_OPSIZE_K, /* 2393 */ + IC_EVEX_W_OPSIZE_K, /* 2394 */ + IC_EVEX_W_OPSIZE_K, /* 2395 */ + IC_EVEX_W_OPSIZE_K, /* 2396 */ + IC_EVEX_W_OPSIZE_K, /* 2397 */ + IC_EVEX_W_OPSIZE_K, /* 2398 */ + IC_EVEX_W_OPSIZE_K, /* 2399 */ + IC_EVEX_K, /* 2400 */ + IC_EVEX_K, /* 2401 */ + IC_EVEX_XS_K, /* 2402 */ + IC_EVEX_XS_K, /* 2403 */ + IC_EVEX_XD_K, /* 2404 */ + IC_EVEX_XD_K, /* 2405 */ + IC_EVEX_XD_K, /* 2406 */ + IC_EVEX_XD_K, /* 2407 */ + IC_EVEX_W_K, /* 2408 */ + IC_EVEX_W_K, /* 2409 */ + IC_EVEX_W_XS_K, /* 2410 */ + IC_EVEX_W_XS_K, /* 2411 */ + IC_EVEX_W_XD_K, /* 2412 */ + IC_EVEX_W_XD_K, /* 2413 */ + IC_EVEX_W_XD_K, /* 2414 */ + IC_EVEX_W_XD_K, /* 2415 */ + IC_EVEX_OPSIZE_K, /* 2416 */ + IC_EVEX_OPSIZE_K, /* 2417 */ + IC_EVEX_OPSIZE_K, /* 2418 */ + IC_EVEX_OPSIZE_K, /* 2419 */ + IC_EVEX_OPSIZE_K, /* 2420 */ + IC_EVEX_OPSIZE_K, /* 2421 */ + IC_EVEX_OPSIZE_K, /* 2422 */ + IC_EVEX_OPSIZE_K, /* 2423 */ + IC_EVEX_W_OPSIZE_K, /* 2424 */ + IC_EVEX_W_OPSIZE_K, /* 2425 */ + IC_EVEX_W_OPSIZE_K, /* 2426 */ + IC_EVEX_W_OPSIZE_K, /* 2427 */ + IC_EVEX_W_OPSIZE_K, /* 2428 */ + IC_EVEX_W_OPSIZE_K, /* 2429 */ + IC_EVEX_W_OPSIZE_K, /* 2430 */ + IC_EVEX_W_OPSIZE_K, /* 2431 */ + IC_EVEX_K, /* 2432 */ + IC_EVEX_K, /* 2433 */ + IC_EVEX_XS_K, /* 2434 */ + IC_EVEX_XS_K, /* 2435 */ + IC_EVEX_XD_K, /* 2436 */ + IC_EVEX_XD_K, /* 2437 */ + IC_EVEX_XD_K, /* 2438 */ + IC_EVEX_XD_K, /* 2439 */ + IC_EVEX_W_K, /* 2440 */ + IC_EVEX_W_K, /* 2441 */ + IC_EVEX_W_XS_K, /* 2442 */ + IC_EVEX_W_XS_K, /* 2443 */ + IC_EVEX_W_XD_K, /* 2444 */ + IC_EVEX_W_XD_K, /* 2445 */ + IC_EVEX_W_XD_K, /* 2446 */ + IC_EVEX_W_XD_K, /* 2447 */ + IC_EVEX_OPSIZE_K, /* 2448 */ + IC_EVEX_OPSIZE_K, /* 2449 */ + IC_EVEX_OPSIZE_K, /* 2450 */ + IC_EVEX_OPSIZE_K, /* 2451 */ + IC_EVEX_OPSIZE_K, /* 2452 */ + IC_EVEX_OPSIZE_K, /* 2453 */ + IC_EVEX_OPSIZE_K, /* 2454 */ + IC_EVEX_OPSIZE_K, /* 2455 */ + IC_EVEX_W_OPSIZE_K, /* 2456 */ + IC_EVEX_W_OPSIZE_K, /* 2457 */ + IC_EVEX_W_OPSIZE_K, /* 2458 */ + IC_EVEX_W_OPSIZE_K, /* 2459 */ + IC_EVEX_W_OPSIZE_K, /* 2460 */ + IC_EVEX_W_OPSIZE_K, /* 2461 */ + IC_EVEX_W_OPSIZE_K, /* 2462 */ + IC_EVEX_W_OPSIZE_K, /* 2463 */ + IC_EVEX_K, /* 2464 */ + IC_EVEX_K, /* 2465 */ + IC_EVEX_XS_K, /* 2466 */ + IC_EVEX_XS_K, /* 2467 */ + IC_EVEX_XD_K, /* 2468 */ + IC_EVEX_XD_K, /* 2469 */ + IC_EVEX_XD_K, /* 2470 */ + IC_EVEX_XD_K, /* 2471 */ + IC_EVEX_W_K, /* 2472 */ + IC_EVEX_W_K, /* 2473 */ + IC_EVEX_W_XS_K, /* 2474 */ + IC_EVEX_W_XS_K, /* 2475 */ + IC_EVEX_W_XD_K, /* 2476 */ + IC_EVEX_W_XD_K, /* 2477 */ + IC_EVEX_W_XD_K, /* 2478 */ + IC_EVEX_W_XD_K, /* 2479 */ + IC_EVEX_OPSIZE_K, /* 2480 */ + IC_EVEX_OPSIZE_K, /* 2481 */ + IC_EVEX_OPSIZE_K, /* 2482 */ + IC_EVEX_OPSIZE_K, /* 2483 */ + IC_EVEX_OPSIZE_K, /* 2484 */ + IC_EVEX_OPSIZE_K, /* 2485 */ + IC_EVEX_OPSIZE_K, /* 2486 */ + IC_EVEX_OPSIZE_K, /* 2487 */ + IC_EVEX_W_OPSIZE_K, /* 2488 */ + IC_EVEX_W_OPSIZE_K, /* 2489 */ + IC_EVEX_W_OPSIZE_K, /* 2490 */ + IC_EVEX_W_OPSIZE_K, /* 2491 */ + IC_EVEX_W_OPSIZE_K, /* 2492 */ + IC_EVEX_W_OPSIZE_K, /* 2493 */ + IC_EVEX_W_OPSIZE_K, /* 2494 */ + IC_EVEX_W_OPSIZE_K, /* 2495 */ + IC_EVEX_K, /* 2496 */ + IC_EVEX_K, /* 2497 */ + IC_EVEX_XS_K, /* 2498 */ + IC_EVEX_XS_K, /* 2499 */ + IC_EVEX_XD_K, /* 2500 */ + IC_EVEX_XD_K, /* 2501 */ + IC_EVEX_XD_K, /* 2502 */ + IC_EVEX_XD_K, /* 2503 */ + IC_EVEX_W_K, /* 2504 */ + IC_EVEX_W_K, /* 2505 */ + IC_EVEX_W_XS_K, /* 2506 */ + IC_EVEX_W_XS_K, /* 2507 */ + IC_EVEX_W_XD_K, /* 2508 */ + IC_EVEX_W_XD_K, /* 2509 */ + IC_EVEX_W_XD_K, /* 2510 */ + IC_EVEX_W_XD_K, /* 2511 */ + IC_EVEX_OPSIZE_K, /* 2512 */ + IC_EVEX_OPSIZE_K, /* 2513 */ + IC_EVEX_OPSIZE_K, /* 2514 */ + IC_EVEX_OPSIZE_K, /* 2515 */ + IC_EVEX_OPSIZE_K, /* 2516 */ + IC_EVEX_OPSIZE_K, /* 2517 */ + IC_EVEX_OPSIZE_K, /* 2518 */ + IC_EVEX_OPSIZE_K, /* 2519 */ + IC_EVEX_W_OPSIZE_K, /* 2520 */ + IC_EVEX_W_OPSIZE_K, /* 2521 */ + IC_EVEX_W_OPSIZE_K, /* 2522 */ + IC_EVEX_W_OPSIZE_K, /* 2523 */ + IC_EVEX_W_OPSIZE_K, /* 2524 */ + IC_EVEX_W_OPSIZE_K, /* 2525 */ + IC_EVEX_W_OPSIZE_K, /* 2526 */ + IC_EVEX_W_OPSIZE_K, /* 2527 */ + IC_EVEX_K, /* 2528 */ + IC_EVEX_K, /* 2529 */ + IC_EVEX_XS_K, /* 2530 */ + IC_EVEX_XS_K, /* 2531 */ + IC_EVEX_XD_K, /* 2532 */ + IC_EVEX_XD_K, /* 2533 */ + IC_EVEX_XD_K, /* 2534 */ + IC_EVEX_XD_K, /* 2535 */ + IC_EVEX_W_K, /* 2536 */ + IC_EVEX_W_K, /* 2537 */ + IC_EVEX_W_XS_K, /* 2538 */ + IC_EVEX_W_XS_K, /* 2539 */ + IC_EVEX_W_XD_K, /* 2540 */ + IC_EVEX_W_XD_K, /* 2541 */ + IC_EVEX_W_XD_K, /* 2542 */ + IC_EVEX_W_XD_K, /* 2543 */ + IC_EVEX_OPSIZE_K, /* 2544 */ + IC_EVEX_OPSIZE_K, /* 2545 */ + IC_EVEX_OPSIZE_K, /* 2546 */ + IC_EVEX_OPSIZE_K, /* 2547 */ + IC_EVEX_OPSIZE_K, /* 2548 */ + IC_EVEX_OPSIZE_K, /* 2549 */ + IC_EVEX_OPSIZE_K, /* 2550 */ + IC_EVEX_OPSIZE_K, /* 2551 */ + IC_EVEX_W_OPSIZE_K, /* 2552 */ + IC_EVEX_W_OPSIZE_K, /* 2553 */ + IC_EVEX_W_OPSIZE_K, /* 2554 */ + IC_EVEX_W_OPSIZE_K, /* 2555 */ + IC_EVEX_W_OPSIZE_K, /* 2556 */ + IC_EVEX_W_OPSIZE_K, /* 2557 */ + IC_EVEX_W_OPSIZE_K, /* 2558 */ + IC_EVEX_W_OPSIZE_K, /* 2559 */ + IC, /* 2560 */ + IC_64BIT, /* 2561 */ + IC_XS, /* 2562 */ + IC_64BIT_XS, /* 2563 */ + IC_XD, /* 2564 */ + IC_64BIT_XD, /* 2565 */ + IC_XS, /* 2566 */ + IC_64BIT_XS, /* 2567 */ + IC, /* 2568 */ + IC_64BIT_REXW, /* 2569 */ + IC_XS, /* 2570 */ + IC_64BIT_REXW_XS, /* 2571 */ + IC_XD, /* 2572 */ + IC_64BIT_REXW_XD, /* 2573 */ + IC_XS, /* 2574 */ + IC_64BIT_REXW_XS, /* 2575 */ + IC_OPSIZE, /* 2576 */ + IC_64BIT_OPSIZE, /* 2577 */ + IC_XS_OPSIZE, /* 2578 */ + IC_64BIT_XS_OPSIZE, /* 2579 */ + IC_XD_OPSIZE, /* 2580 */ + IC_64BIT_XD_OPSIZE, /* 2581 */ + IC_XS_OPSIZE, /* 2582 */ + IC_64BIT_XD_OPSIZE, /* 2583 */ + IC_OPSIZE, /* 2584 */ + IC_64BIT_REXW_OPSIZE, /* 2585 */ + IC_XS_OPSIZE, /* 2586 */ + IC_64BIT_REXW_XS, /* 2587 */ + IC_XD_OPSIZE, /* 2588 */ + IC_64BIT_REXW_XD, /* 2589 */ + IC_XS_OPSIZE, /* 2590 */ + IC_64BIT_REXW_XS, /* 2591 */ + IC_ADSIZE, /* 2592 */ + IC_64BIT_ADSIZE, /* 2593 */ + IC_XS_ADSIZE, /* 2594 */ + IC_64BIT_XS_ADSIZE, /* 2595 */ + IC_XD_ADSIZE, /* 2596 */ + IC_64BIT_XD_ADSIZE, /* 2597 */ + IC_XS_ADSIZE, /* 2598 */ + IC_64BIT_XD_ADSIZE, /* 2599 */ + IC_ADSIZE, /* 2600 */ + IC_64BIT_REXW_ADSIZE, /* 2601 */ + IC_XS_ADSIZE, /* 2602 */ + IC_64BIT_REXW_XS, /* 2603 */ + IC_XD_ADSIZE, /* 2604 */ + IC_64BIT_REXW_XD, /* 2605 */ + IC_XS_ADSIZE, /* 2606 */ + IC_64BIT_REXW_XS, /* 2607 */ + IC_OPSIZE_ADSIZE, /* 2608 */ + IC_64BIT_OPSIZE_ADSIZE, /* 2609 */ + IC_XS_OPSIZE, /* 2610 */ + IC_64BIT_XS_OPSIZE, /* 2611 */ + IC_XD_OPSIZE, /* 2612 */ + IC_64BIT_XD_OPSIZE, /* 2613 */ + IC_XS_OPSIZE, /* 2614 */ + IC_64BIT_XD_OPSIZE, /* 2615 */ + IC_OPSIZE_ADSIZE, /* 2616 */ + IC_64BIT_REXW_OPSIZE, /* 2617 */ + IC_XS_OPSIZE, /* 2618 */ + IC_64BIT_REXW_XS, /* 2619 */ + IC_XD_OPSIZE, /* 2620 */ + IC_64BIT_REXW_XD, /* 2621 */ + IC_XS_OPSIZE, /* 2622 */ + IC_64BIT_REXW_XS, /* 2623 */ + IC_VEX, /* 2624 */ + IC_VEX, /* 2625 */ + IC_VEX_XS, /* 2626 */ + IC_VEX_XS, /* 2627 */ + IC_VEX_XD, /* 2628 */ + IC_VEX_XD, /* 2629 */ + IC_VEX_XD, /* 2630 */ + IC_VEX_XD, /* 2631 */ + IC_VEX_W, /* 2632 */ + IC_VEX_W, /* 2633 */ + IC_VEX_W_XS, /* 2634 */ + IC_VEX_W_XS, /* 2635 */ + IC_VEX_W_XD, /* 2636 */ + IC_VEX_W_XD, /* 2637 */ + IC_VEX_W_XD, /* 2638 */ + IC_VEX_W_XD, /* 2639 */ + IC_VEX_OPSIZE, /* 2640 */ + IC_VEX_OPSIZE, /* 2641 */ + IC_VEX_OPSIZE, /* 2642 */ + IC_VEX_OPSIZE, /* 2643 */ + IC_VEX_OPSIZE, /* 2644 */ + IC_VEX_OPSIZE, /* 2645 */ + IC_VEX_OPSIZE, /* 2646 */ + IC_VEX_OPSIZE, /* 2647 */ + IC_VEX_W_OPSIZE, /* 2648 */ + IC_VEX_W_OPSIZE, /* 2649 */ + IC_VEX_W_OPSIZE, /* 2650 */ + IC_VEX_W_OPSIZE, /* 2651 */ + IC_VEX_W_OPSIZE, /* 2652 */ + IC_VEX_W_OPSIZE, /* 2653 */ + IC_VEX_W_OPSIZE, /* 2654 */ + IC_VEX_W_OPSIZE, /* 2655 */ + IC_VEX, /* 2656 */ + IC_VEX, /* 2657 */ + IC_VEX_XS, /* 2658 */ + IC_VEX_XS, /* 2659 */ + IC_VEX_XD, /* 2660 */ + IC_VEX_XD, /* 2661 */ + IC_VEX_XD, /* 2662 */ + IC_VEX_XD, /* 2663 */ + IC_VEX_W, /* 2664 */ + IC_VEX_W, /* 2665 */ + IC_VEX_W_XS, /* 2666 */ + IC_VEX_W_XS, /* 2667 */ + IC_VEX_W_XD, /* 2668 */ + IC_VEX_W_XD, /* 2669 */ + IC_VEX_W_XD, /* 2670 */ + IC_VEX_W_XD, /* 2671 */ + IC_VEX_OPSIZE, /* 2672 */ + IC_VEX_OPSIZE, /* 2673 */ + IC_VEX_OPSIZE, /* 2674 */ + IC_VEX_OPSIZE, /* 2675 */ + IC_VEX_OPSIZE, /* 2676 */ + IC_VEX_OPSIZE, /* 2677 */ + IC_VEX_OPSIZE, /* 2678 */ + IC_VEX_OPSIZE, /* 2679 */ + IC_VEX_W_OPSIZE, /* 2680 */ + IC_VEX_W_OPSIZE, /* 2681 */ + IC_VEX_W_OPSIZE, /* 2682 */ + IC_VEX_W_OPSIZE, /* 2683 */ + IC_VEX_W_OPSIZE, /* 2684 */ + IC_VEX_W_OPSIZE, /* 2685 */ + IC_VEX_W_OPSIZE, /* 2686 */ + IC_VEX_W_OPSIZE, /* 2687 */ + IC_VEX_L, /* 2688 */ + IC_VEX_L, /* 2689 */ + IC_VEX_L_XS, /* 2690 */ + IC_VEX_L_XS, /* 2691 */ + IC_VEX_L_XD, /* 2692 */ + IC_VEX_L_XD, /* 2693 */ + IC_VEX_L_XD, /* 2694 */ + IC_VEX_L_XD, /* 2695 */ + IC_VEX_L_W, /* 2696 */ + IC_VEX_L_W, /* 2697 */ + IC_VEX_L_W_XS, /* 2698 */ + IC_VEX_L_W_XS, /* 2699 */ + IC_VEX_L_W_XD, /* 2700 */ + IC_VEX_L_W_XD, /* 2701 */ + IC_VEX_L_W_XD, /* 2702 */ + IC_VEX_L_W_XD, /* 2703 */ + IC_VEX_L_OPSIZE, /* 2704 */ + IC_VEX_L_OPSIZE, /* 2705 */ + IC_VEX_L_OPSIZE, /* 2706 */ + IC_VEX_L_OPSIZE, /* 2707 */ + IC_VEX_L_OPSIZE, /* 2708 */ + IC_VEX_L_OPSIZE, /* 2709 */ + IC_VEX_L_OPSIZE, /* 2710 */ + IC_VEX_L_OPSIZE, /* 2711 */ + IC_VEX_L_W_OPSIZE, /* 2712 */ + IC_VEX_L_W_OPSIZE, /* 2713 */ + IC_VEX_L_W_OPSIZE, /* 2714 */ + IC_VEX_L_W_OPSIZE, /* 2715 */ + IC_VEX_L_W_OPSIZE, /* 2716 */ + IC_VEX_L_W_OPSIZE, /* 2717 */ + IC_VEX_L_W_OPSIZE, /* 2718 */ + IC_VEX_L_W_OPSIZE, /* 2719 */ + IC_VEX_L, /* 2720 */ + IC_VEX_L, /* 2721 */ + IC_VEX_L_XS, /* 2722 */ + IC_VEX_L_XS, /* 2723 */ + IC_VEX_L_XD, /* 2724 */ + IC_VEX_L_XD, /* 2725 */ + IC_VEX_L_XD, /* 2726 */ + IC_VEX_L_XD, /* 2727 */ + IC_VEX_L_W, /* 2728 */ + IC_VEX_L_W, /* 2729 */ + IC_VEX_L_W_XS, /* 2730 */ + IC_VEX_L_W_XS, /* 2731 */ + IC_VEX_L_W_XD, /* 2732 */ + IC_VEX_L_W_XD, /* 2733 */ + IC_VEX_L_W_XD, /* 2734 */ + IC_VEX_L_W_XD, /* 2735 */ + IC_VEX_L_OPSIZE, /* 2736 */ + IC_VEX_L_OPSIZE, /* 2737 */ + IC_VEX_L_OPSIZE, /* 2738 */ + IC_VEX_L_OPSIZE, /* 2739 */ + IC_VEX_L_OPSIZE, /* 2740 */ + IC_VEX_L_OPSIZE, /* 2741 */ + IC_VEX_L_OPSIZE, /* 2742 */ + IC_VEX_L_OPSIZE, /* 2743 */ + IC_VEX_L_W_OPSIZE, /* 2744 */ + IC_VEX_L_W_OPSIZE, /* 2745 */ + IC_VEX_L_W_OPSIZE, /* 2746 */ + IC_VEX_L_W_OPSIZE, /* 2747 */ + IC_VEX_L_W_OPSIZE, /* 2748 */ + IC_VEX_L_W_OPSIZE, /* 2749 */ + IC_VEX_L_W_OPSIZE, /* 2750 */ + IC_VEX_L_W_OPSIZE, /* 2751 */ + IC_VEX_L, /* 2752 */ + IC_VEX_L, /* 2753 */ + IC_VEX_L_XS, /* 2754 */ + IC_VEX_L_XS, /* 2755 */ + IC_VEX_L_XD, /* 2756 */ + IC_VEX_L_XD, /* 2757 */ + IC_VEX_L_XD, /* 2758 */ + IC_VEX_L_XD, /* 2759 */ + IC_VEX_L_W, /* 2760 */ + IC_VEX_L_W, /* 2761 */ + IC_VEX_L_W_XS, /* 2762 */ + IC_VEX_L_W_XS, /* 2763 */ + IC_VEX_L_W_XD, /* 2764 */ + IC_VEX_L_W_XD, /* 2765 */ + IC_VEX_L_W_XD, /* 2766 */ + IC_VEX_L_W_XD, /* 2767 */ + IC_VEX_L_OPSIZE, /* 2768 */ + IC_VEX_L_OPSIZE, /* 2769 */ + IC_VEX_L_OPSIZE, /* 2770 */ + IC_VEX_L_OPSIZE, /* 2771 */ + IC_VEX_L_OPSIZE, /* 2772 */ + IC_VEX_L_OPSIZE, /* 2773 */ + IC_VEX_L_OPSIZE, /* 2774 */ + IC_VEX_L_OPSIZE, /* 2775 */ + IC_VEX_L_W_OPSIZE, /* 2776 */ + IC_VEX_L_W_OPSIZE, /* 2777 */ + IC_VEX_L_W_OPSIZE, /* 2778 */ + IC_VEX_L_W_OPSIZE, /* 2779 */ + IC_VEX_L_W_OPSIZE, /* 2780 */ + IC_VEX_L_W_OPSIZE, /* 2781 */ + IC_VEX_L_W_OPSIZE, /* 2782 */ + IC_VEX_L_W_OPSIZE, /* 2783 */ + IC_VEX_L, /* 2784 */ + IC_VEX_L, /* 2785 */ + IC_VEX_L_XS, /* 2786 */ + IC_VEX_L_XS, /* 2787 */ + IC_VEX_L_XD, /* 2788 */ + IC_VEX_L_XD, /* 2789 */ + IC_VEX_L_XD, /* 2790 */ + IC_VEX_L_XD, /* 2791 */ + IC_VEX_L_W, /* 2792 */ + IC_VEX_L_W, /* 2793 */ + IC_VEX_L_W_XS, /* 2794 */ + IC_VEX_L_W_XS, /* 2795 */ + IC_VEX_L_W_XD, /* 2796 */ + IC_VEX_L_W_XD, /* 2797 */ + IC_VEX_L_W_XD, /* 2798 */ + IC_VEX_L_W_XD, /* 2799 */ + IC_VEX_L_OPSIZE, /* 2800 */ + IC_VEX_L_OPSIZE, /* 2801 */ + IC_VEX_L_OPSIZE, /* 2802 */ + IC_VEX_L_OPSIZE, /* 2803 */ + IC_VEX_L_OPSIZE, /* 2804 */ + IC_VEX_L_OPSIZE, /* 2805 */ + IC_VEX_L_OPSIZE, /* 2806 */ + IC_VEX_L_OPSIZE, /* 2807 */ + IC_VEX_L_W_OPSIZE, /* 2808 */ + IC_VEX_L_W_OPSIZE, /* 2809 */ + IC_VEX_L_W_OPSIZE, /* 2810 */ + IC_VEX_L_W_OPSIZE, /* 2811 */ + IC_VEX_L_W_OPSIZE, /* 2812 */ + IC_VEX_L_W_OPSIZE, /* 2813 */ + IC_VEX_L_W_OPSIZE, /* 2814 */ + IC_VEX_L_W_OPSIZE, /* 2815 */ + IC_EVEX_L_K, /* 2816 */ + IC_EVEX_L_K, /* 2817 */ + IC_EVEX_L_XS_K, /* 2818 */ + IC_EVEX_L_XS_K, /* 2819 */ + IC_EVEX_L_XD_K, /* 2820 */ + IC_EVEX_L_XD_K, /* 2821 */ + IC_EVEX_L_XD_K, /* 2822 */ + IC_EVEX_L_XD_K, /* 2823 */ + IC_EVEX_L_W_K, /* 2824 */ + IC_EVEX_L_W_K, /* 2825 */ + IC_EVEX_L_W_XS_K, /* 2826 */ + IC_EVEX_L_W_XS_K, /* 2827 */ + IC_EVEX_L_W_XD_K, /* 2828 */ + IC_EVEX_L_W_XD_K, /* 2829 */ + IC_EVEX_L_W_XD_K, /* 2830 */ + IC_EVEX_L_W_XD_K, /* 2831 */ + IC_EVEX_L_OPSIZE_K, /* 2832 */ + IC_EVEX_L_OPSIZE_K, /* 2833 */ + IC_EVEX_L_OPSIZE_K, /* 2834 */ + IC_EVEX_L_OPSIZE_K, /* 2835 */ + IC_EVEX_L_OPSIZE_K, /* 2836 */ + IC_EVEX_L_OPSIZE_K, /* 2837 */ + IC_EVEX_L_OPSIZE_K, /* 2838 */ + IC_EVEX_L_OPSIZE_K, /* 2839 */ + IC_EVEX_L_W_OPSIZE_K, /* 2840 */ + IC_EVEX_L_W_OPSIZE_K, /* 2841 */ + IC_EVEX_L_W_OPSIZE_K, /* 2842 */ + IC_EVEX_L_W_OPSIZE_K, /* 2843 */ + IC_EVEX_L_W_OPSIZE_K, /* 2844 */ + IC_EVEX_L_W_OPSIZE_K, /* 2845 */ + IC_EVEX_L_W_OPSIZE_K, /* 2846 */ + IC_EVEX_L_W_OPSIZE_K, /* 2847 */ + IC_EVEX_L_K, /* 2848 */ + IC_EVEX_L_K, /* 2849 */ + IC_EVEX_L_XS_K, /* 2850 */ + IC_EVEX_L_XS_K, /* 2851 */ + IC_EVEX_L_XD_K, /* 2852 */ + IC_EVEX_L_XD_K, /* 2853 */ + IC_EVEX_L_XD_K, /* 2854 */ + IC_EVEX_L_XD_K, /* 2855 */ + IC_EVEX_L_W_K, /* 2856 */ + IC_EVEX_L_W_K, /* 2857 */ + IC_EVEX_L_W_XS_K, /* 2858 */ + IC_EVEX_L_W_XS_K, /* 2859 */ + IC_EVEX_L_W_XD_K, /* 2860 */ + IC_EVEX_L_W_XD_K, /* 2861 */ + IC_EVEX_L_W_XD_K, /* 2862 */ + IC_EVEX_L_W_XD_K, /* 2863 */ + IC_EVEX_L_OPSIZE_K, /* 2864 */ + IC_EVEX_L_OPSIZE_K, /* 2865 */ + IC_EVEX_L_OPSIZE_K, /* 2866 */ + IC_EVEX_L_OPSIZE_K, /* 2867 */ + IC_EVEX_L_OPSIZE_K, /* 2868 */ + IC_EVEX_L_OPSIZE_K, /* 2869 */ + IC_EVEX_L_OPSIZE_K, /* 2870 */ + IC_EVEX_L_OPSIZE_K, /* 2871 */ + IC_EVEX_L_W_OPSIZE_K, /* 2872 */ + IC_EVEX_L_W_OPSIZE_K, /* 2873 */ + IC_EVEX_L_W_OPSIZE_K, /* 2874 */ + IC_EVEX_L_W_OPSIZE_K, /* 2875 */ + IC_EVEX_L_W_OPSIZE_K, /* 2876 */ + IC_EVEX_L_W_OPSIZE_K, /* 2877 */ + IC_EVEX_L_W_OPSIZE_K, /* 2878 */ + IC_EVEX_L_W_OPSIZE_K, /* 2879 */ + IC_EVEX_L_K, /* 2880 */ + IC_EVEX_L_K, /* 2881 */ + IC_EVEX_L_XS_K, /* 2882 */ + IC_EVEX_L_XS_K, /* 2883 */ + IC_EVEX_L_XD_K, /* 2884 */ + IC_EVEX_L_XD_K, /* 2885 */ + IC_EVEX_L_XD_K, /* 2886 */ + IC_EVEX_L_XD_K, /* 2887 */ + IC_EVEX_L_W_K, /* 2888 */ + IC_EVEX_L_W_K, /* 2889 */ + IC_EVEX_L_W_XS_K, /* 2890 */ + IC_EVEX_L_W_XS_K, /* 2891 */ + IC_EVEX_L_W_XD_K, /* 2892 */ + IC_EVEX_L_W_XD_K, /* 2893 */ + IC_EVEX_L_W_XD_K, /* 2894 */ + IC_EVEX_L_W_XD_K, /* 2895 */ + IC_EVEX_L_OPSIZE_K, /* 2896 */ + IC_EVEX_L_OPSIZE_K, /* 2897 */ + IC_EVEX_L_OPSIZE_K, /* 2898 */ + IC_EVEX_L_OPSIZE_K, /* 2899 */ + IC_EVEX_L_OPSIZE_K, /* 2900 */ + IC_EVEX_L_OPSIZE_K, /* 2901 */ + IC_EVEX_L_OPSIZE_K, /* 2902 */ + IC_EVEX_L_OPSIZE_K, /* 2903 */ + IC_EVEX_L_W_OPSIZE_K, /* 2904 */ + IC_EVEX_L_W_OPSIZE_K, /* 2905 */ + IC_EVEX_L_W_OPSIZE_K, /* 2906 */ + IC_EVEX_L_W_OPSIZE_K, /* 2907 */ + IC_EVEX_L_W_OPSIZE_K, /* 2908 */ + IC_EVEX_L_W_OPSIZE_K, /* 2909 */ + IC_EVEX_L_W_OPSIZE_K, /* 2910 */ + IC_EVEX_L_W_OPSIZE_K, /* 2911 */ + IC_EVEX_L_K, /* 2912 */ + IC_EVEX_L_K, /* 2913 */ + IC_EVEX_L_XS_K, /* 2914 */ + IC_EVEX_L_XS_K, /* 2915 */ + IC_EVEX_L_XD_K, /* 2916 */ + IC_EVEX_L_XD_K, /* 2917 */ + IC_EVEX_L_XD_K, /* 2918 */ + IC_EVEX_L_XD_K, /* 2919 */ + IC_EVEX_L_W_K, /* 2920 */ + IC_EVEX_L_W_K, /* 2921 */ + IC_EVEX_L_W_XS_K, /* 2922 */ + IC_EVEX_L_W_XS_K, /* 2923 */ + IC_EVEX_L_W_XD_K, /* 2924 */ + IC_EVEX_L_W_XD_K, /* 2925 */ + IC_EVEX_L_W_XD_K, /* 2926 */ + IC_EVEX_L_W_XD_K, /* 2927 */ + IC_EVEX_L_OPSIZE_K, /* 2928 */ + IC_EVEX_L_OPSIZE_K, /* 2929 */ + IC_EVEX_L_OPSIZE_K, /* 2930 */ + IC_EVEX_L_OPSIZE_K, /* 2931 */ + IC_EVEX_L_OPSIZE_K, /* 2932 */ + IC_EVEX_L_OPSIZE_K, /* 2933 */ + IC_EVEX_L_OPSIZE_K, /* 2934 */ + IC_EVEX_L_OPSIZE_K, /* 2935 */ + IC_EVEX_L_W_OPSIZE_K, /* 2936 */ + IC_EVEX_L_W_OPSIZE_K, /* 2937 */ + IC_EVEX_L_W_OPSIZE_K, /* 2938 */ + IC_EVEX_L_W_OPSIZE_K, /* 2939 */ + IC_EVEX_L_W_OPSIZE_K, /* 2940 */ + IC_EVEX_L_W_OPSIZE_K, /* 2941 */ + IC_EVEX_L_W_OPSIZE_K, /* 2942 */ + IC_EVEX_L_W_OPSIZE_K, /* 2943 */ + IC_EVEX_L_K, /* 2944 */ + IC_EVEX_L_K, /* 2945 */ + IC_EVEX_L_XS_K, /* 2946 */ + IC_EVEX_L_XS_K, /* 2947 */ + IC_EVEX_L_XD_K, /* 2948 */ + IC_EVEX_L_XD_K, /* 2949 */ + IC_EVEX_L_XD_K, /* 2950 */ + IC_EVEX_L_XD_K, /* 2951 */ + IC_EVEX_L_W_K, /* 2952 */ + IC_EVEX_L_W_K, /* 2953 */ + IC_EVEX_L_W_XS_K, /* 2954 */ + IC_EVEX_L_W_XS_K, /* 2955 */ + IC_EVEX_L_W_XD_K, /* 2956 */ + IC_EVEX_L_W_XD_K, /* 2957 */ + IC_EVEX_L_W_XD_K, /* 2958 */ + IC_EVEX_L_W_XD_K, /* 2959 */ + IC_EVEX_L_OPSIZE_K, /* 2960 */ + IC_EVEX_L_OPSIZE_K, /* 2961 */ + IC_EVEX_L_OPSIZE_K, /* 2962 */ + IC_EVEX_L_OPSIZE_K, /* 2963 */ + IC_EVEX_L_OPSIZE_K, /* 2964 */ + IC_EVEX_L_OPSIZE_K, /* 2965 */ + IC_EVEX_L_OPSIZE_K, /* 2966 */ + IC_EVEX_L_OPSIZE_K, /* 2967 */ + IC_EVEX_L_W_OPSIZE_K, /* 2968 */ + IC_EVEX_L_W_OPSIZE_K, /* 2969 */ + IC_EVEX_L_W_OPSIZE_K, /* 2970 */ + IC_EVEX_L_W_OPSIZE_K, /* 2971 */ + IC_EVEX_L_W_OPSIZE_K, /* 2972 */ + IC_EVEX_L_W_OPSIZE_K, /* 2973 */ + IC_EVEX_L_W_OPSIZE_K, /* 2974 */ + IC_EVEX_L_W_OPSIZE_K, /* 2975 */ + IC_EVEX_L_K, /* 2976 */ + IC_EVEX_L_K, /* 2977 */ + IC_EVEX_L_XS_K, /* 2978 */ + IC_EVEX_L_XS_K, /* 2979 */ + IC_EVEX_L_XD_K, /* 2980 */ + IC_EVEX_L_XD_K, /* 2981 */ + IC_EVEX_L_XD_K, /* 2982 */ + IC_EVEX_L_XD_K, /* 2983 */ + IC_EVEX_L_W_K, /* 2984 */ + IC_EVEX_L_W_K, /* 2985 */ + IC_EVEX_L_W_XS_K, /* 2986 */ + IC_EVEX_L_W_XS_K, /* 2987 */ + IC_EVEX_L_W_XD_K, /* 2988 */ + IC_EVEX_L_W_XD_K, /* 2989 */ + IC_EVEX_L_W_XD_K, /* 2990 */ + IC_EVEX_L_W_XD_K, /* 2991 */ + IC_EVEX_L_OPSIZE_K, /* 2992 */ + IC_EVEX_L_OPSIZE_K, /* 2993 */ + IC_EVEX_L_OPSIZE_K, /* 2994 */ + IC_EVEX_L_OPSIZE_K, /* 2995 */ + IC_EVEX_L_OPSIZE_K, /* 2996 */ + IC_EVEX_L_OPSIZE_K, /* 2997 */ + IC_EVEX_L_OPSIZE_K, /* 2998 */ + IC_EVEX_L_OPSIZE_K, /* 2999 */ + IC_EVEX_L_W_OPSIZE_K, /* 3000 */ + IC_EVEX_L_W_OPSIZE_K, /* 3001 */ + IC_EVEX_L_W_OPSIZE_K, /* 3002 */ + IC_EVEX_L_W_OPSIZE_K, /* 3003 */ + IC_EVEX_L_W_OPSIZE_K, /* 3004 */ + IC_EVEX_L_W_OPSIZE_K, /* 3005 */ + IC_EVEX_L_W_OPSIZE_K, /* 3006 */ + IC_EVEX_L_W_OPSIZE_K, /* 3007 */ + IC_EVEX_L_K, /* 3008 */ + IC_EVEX_L_K, /* 3009 */ + IC_EVEX_L_XS_K, /* 3010 */ + IC_EVEX_L_XS_K, /* 3011 */ + IC_EVEX_L_XD_K, /* 3012 */ + IC_EVEX_L_XD_K, /* 3013 */ + IC_EVEX_L_XD_K, /* 3014 */ + IC_EVEX_L_XD_K, /* 3015 */ + IC_EVEX_L_W_K, /* 3016 */ + IC_EVEX_L_W_K, /* 3017 */ + IC_EVEX_L_W_XS_K, /* 3018 */ + IC_EVEX_L_W_XS_K, /* 3019 */ + IC_EVEX_L_W_XD_K, /* 3020 */ + IC_EVEX_L_W_XD_K, /* 3021 */ + IC_EVEX_L_W_XD_K, /* 3022 */ + IC_EVEX_L_W_XD_K, /* 3023 */ + IC_EVEX_L_OPSIZE_K, /* 3024 */ + IC_EVEX_L_OPSIZE_K, /* 3025 */ + IC_EVEX_L_OPSIZE_K, /* 3026 */ + IC_EVEX_L_OPSIZE_K, /* 3027 */ + IC_EVEX_L_OPSIZE_K, /* 3028 */ + IC_EVEX_L_OPSIZE_K, /* 3029 */ + IC_EVEX_L_OPSIZE_K, /* 3030 */ + IC_EVEX_L_OPSIZE_K, /* 3031 */ + IC_EVEX_L_W_OPSIZE_K, /* 3032 */ + IC_EVEX_L_W_OPSIZE_K, /* 3033 */ + IC_EVEX_L_W_OPSIZE_K, /* 3034 */ + IC_EVEX_L_W_OPSIZE_K, /* 3035 */ + IC_EVEX_L_W_OPSIZE_K, /* 3036 */ + IC_EVEX_L_W_OPSIZE_K, /* 3037 */ + IC_EVEX_L_W_OPSIZE_K, /* 3038 */ + IC_EVEX_L_W_OPSIZE_K, /* 3039 */ + IC_EVEX_L_K, /* 3040 */ + IC_EVEX_L_K, /* 3041 */ + IC_EVEX_L_XS_K, /* 3042 */ + IC_EVEX_L_XS_K, /* 3043 */ + IC_EVEX_L_XD_K, /* 3044 */ + IC_EVEX_L_XD_K, /* 3045 */ + IC_EVEX_L_XD_K, /* 3046 */ + IC_EVEX_L_XD_K, /* 3047 */ + IC_EVEX_L_W_K, /* 3048 */ + IC_EVEX_L_W_K, /* 3049 */ + IC_EVEX_L_W_XS_K, /* 3050 */ + IC_EVEX_L_W_XS_K, /* 3051 */ + IC_EVEX_L_W_XD_K, /* 3052 */ + IC_EVEX_L_W_XD_K, /* 3053 */ + IC_EVEX_L_W_XD_K, /* 3054 */ + IC_EVEX_L_W_XD_K, /* 3055 */ + IC_EVEX_L_OPSIZE_K, /* 3056 */ + IC_EVEX_L_OPSIZE_K, /* 3057 */ + IC_EVEX_L_OPSIZE_K, /* 3058 */ + IC_EVEX_L_OPSIZE_K, /* 3059 */ + IC_EVEX_L_OPSIZE_K, /* 3060 */ + IC_EVEX_L_OPSIZE_K, /* 3061 */ + IC_EVEX_L_OPSIZE_K, /* 3062 */ + IC_EVEX_L_OPSIZE_K, /* 3063 */ + IC_EVEX_L_W_OPSIZE_K, /* 3064 */ + IC_EVEX_L_W_OPSIZE_K, /* 3065 */ + IC_EVEX_L_W_OPSIZE_K, /* 3066 */ + IC_EVEX_L_W_OPSIZE_K, /* 3067 */ + IC_EVEX_L_W_OPSIZE_K, /* 3068 */ + IC_EVEX_L_W_OPSIZE_K, /* 3069 */ + IC_EVEX_L_W_OPSIZE_K, /* 3070 */ + IC_EVEX_L_W_OPSIZE_K, /* 3071 */ + IC, /* 3072 */ + IC_64BIT, /* 3073 */ + IC_XS, /* 3074 */ + IC_64BIT_XS, /* 3075 */ + IC_XD, /* 3076 */ + IC_64BIT_XD, /* 3077 */ + IC_XS, /* 3078 */ + IC_64BIT_XS, /* 3079 */ + IC, /* 3080 */ + IC_64BIT_REXW, /* 3081 */ + IC_XS, /* 3082 */ + IC_64BIT_REXW_XS, /* 3083 */ + IC_XD, /* 3084 */ + IC_64BIT_REXW_XD, /* 3085 */ + IC_XS, /* 3086 */ + IC_64BIT_REXW_XS, /* 3087 */ + IC_OPSIZE, /* 3088 */ + IC_64BIT_OPSIZE, /* 3089 */ + IC_XS_OPSIZE, /* 3090 */ + IC_64BIT_XS_OPSIZE, /* 3091 */ + IC_XD_OPSIZE, /* 3092 */ + IC_64BIT_XD_OPSIZE, /* 3093 */ + IC_XS_OPSIZE, /* 3094 */ + IC_64BIT_XD_OPSIZE, /* 3095 */ + IC_OPSIZE, /* 3096 */ + IC_64BIT_REXW_OPSIZE, /* 3097 */ + IC_XS_OPSIZE, /* 3098 */ + IC_64BIT_REXW_XS, /* 3099 */ + IC_XD_OPSIZE, /* 3100 */ + IC_64BIT_REXW_XD, /* 3101 */ + IC_XS_OPSIZE, /* 3102 */ + IC_64BIT_REXW_XS, /* 3103 */ + IC_ADSIZE, /* 3104 */ + IC_64BIT_ADSIZE, /* 3105 */ + IC_XS_ADSIZE, /* 3106 */ + IC_64BIT_XS_ADSIZE, /* 3107 */ + IC_XD_ADSIZE, /* 3108 */ + IC_64BIT_XD_ADSIZE, /* 3109 */ + IC_XS_ADSIZE, /* 3110 */ + IC_64BIT_XD_ADSIZE, /* 3111 */ + IC_ADSIZE, /* 3112 */ + IC_64BIT_REXW_ADSIZE, /* 3113 */ + IC_XS_ADSIZE, /* 3114 */ + IC_64BIT_REXW_XS, /* 3115 */ + IC_XD_ADSIZE, /* 3116 */ + IC_64BIT_REXW_XD, /* 3117 */ + IC_XS_ADSIZE, /* 3118 */ + IC_64BIT_REXW_XS, /* 3119 */ + IC_OPSIZE_ADSIZE, /* 3120 */ + IC_64BIT_OPSIZE_ADSIZE, /* 3121 */ + IC_XS_OPSIZE, /* 3122 */ + IC_64BIT_XS_OPSIZE, /* 3123 */ + IC_XD_OPSIZE, /* 3124 */ + IC_64BIT_XD_OPSIZE, /* 3125 */ + IC_XS_OPSIZE, /* 3126 */ + IC_64BIT_XD_OPSIZE, /* 3127 */ + IC_OPSIZE_ADSIZE, /* 3128 */ + IC_64BIT_REXW_OPSIZE, /* 3129 */ + IC_XS_OPSIZE, /* 3130 */ + IC_64BIT_REXW_XS, /* 3131 */ + IC_XD_OPSIZE, /* 3132 */ + IC_64BIT_REXW_XD, /* 3133 */ + IC_XS_OPSIZE, /* 3134 */ + IC_64BIT_REXW_XS, /* 3135 */ + IC_VEX, /* 3136 */ + IC_VEX, /* 3137 */ + IC_VEX_XS, /* 3138 */ + IC_VEX_XS, /* 3139 */ + IC_VEX_XD, /* 3140 */ + IC_VEX_XD, /* 3141 */ + IC_VEX_XD, /* 3142 */ + IC_VEX_XD, /* 3143 */ + IC_VEX_W, /* 3144 */ + IC_VEX_W, /* 3145 */ + IC_VEX_W_XS, /* 3146 */ + IC_VEX_W_XS, /* 3147 */ + IC_VEX_W_XD, /* 3148 */ + IC_VEX_W_XD, /* 3149 */ + IC_VEX_W_XD, /* 3150 */ + IC_VEX_W_XD, /* 3151 */ + IC_VEX_OPSIZE, /* 3152 */ + IC_VEX_OPSIZE, /* 3153 */ + IC_VEX_OPSIZE, /* 3154 */ + IC_VEX_OPSIZE, /* 3155 */ + IC_VEX_OPSIZE, /* 3156 */ + IC_VEX_OPSIZE, /* 3157 */ + IC_VEX_OPSIZE, /* 3158 */ + IC_VEX_OPSIZE, /* 3159 */ + IC_VEX_W_OPSIZE, /* 3160 */ + IC_VEX_W_OPSIZE, /* 3161 */ + IC_VEX_W_OPSIZE, /* 3162 */ + IC_VEX_W_OPSIZE, /* 3163 */ + IC_VEX_W_OPSIZE, /* 3164 */ + IC_VEX_W_OPSIZE, /* 3165 */ + IC_VEX_W_OPSIZE, /* 3166 */ + IC_VEX_W_OPSIZE, /* 3167 */ + IC_VEX, /* 3168 */ + IC_VEX, /* 3169 */ + IC_VEX_XS, /* 3170 */ + IC_VEX_XS, /* 3171 */ + IC_VEX_XD, /* 3172 */ + IC_VEX_XD, /* 3173 */ + IC_VEX_XD, /* 3174 */ + IC_VEX_XD, /* 3175 */ + IC_VEX_W, /* 3176 */ + IC_VEX_W, /* 3177 */ + IC_VEX_W_XS, /* 3178 */ + IC_VEX_W_XS, /* 3179 */ + IC_VEX_W_XD, /* 3180 */ + IC_VEX_W_XD, /* 3181 */ + IC_VEX_W_XD, /* 3182 */ + IC_VEX_W_XD, /* 3183 */ + IC_VEX_OPSIZE, /* 3184 */ + IC_VEX_OPSIZE, /* 3185 */ + IC_VEX_OPSIZE, /* 3186 */ + IC_VEX_OPSIZE, /* 3187 */ + IC_VEX_OPSIZE, /* 3188 */ + IC_VEX_OPSIZE, /* 3189 */ + IC_VEX_OPSIZE, /* 3190 */ + IC_VEX_OPSIZE, /* 3191 */ + IC_VEX_W_OPSIZE, /* 3192 */ + IC_VEX_W_OPSIZE, /* 3193 */ + IC_VEX_W_OPSIZE, /* 3194 */ + IC_VEX_W_OPSIZE, /* 3195 */ + IC_VEX_W_OPSIZE, /* 3196 */ + IC_VEX_W_OPSIZE, /* 3197 */ + IC_VEX_W_OPSIZE, /* 3198 */ + IC_VEX_W_OPSIZE, /* 3199 */ + IC_VEX_L, /* 3200 */ + IC_VEX_L, /* 3201 */ + IC_VEX_L_XS, /* 3202 */ + IC_VEX_L_XS, /* 3203 */ + IC_VEX_L_XD, /* 3204 */ + IC_VEX_L_XD, /* 3205 */ + IC_VEX_L_XD, /* 3206 */ + IC_VEX_L_XD, /* 3207 */ + IC_VEX_L_W, /* 3208 */ + IC_VEX_L_W, /* 3209 */ + IC_VEX_L_W_XS, /* 3210 */ + IC_VEX_L_W_XS, /* 3211 */ + IC_VEX_L_W_XD, /* 3212 */ + IC_VEX_L_W_XD, /* 3213 */ + IC_VEX_L_W_XD, /* 3214 */ + IC_VEX_L_W_XD, /* 3215 */ + IC_VEX_L_OPSIZE, /* 3216 */ + IC_VEX_L_OPSIZE, /* 3217 */ + IC_VEX_L_OPSIZE, /* 3218 */ + IC_VEX_L_OPSIZE, /* 3219 */ + IC_VEX_L_OPSIZE, /* 3220 */ + IC_VEX_L_OPSIZE, /* 3221 */ + IC_VEX_L_OPSIZE, /* 3222 */ + IC_VEX_L_OPSIZE, /* 3223 */ + IC_VEX_L_W_OPSIZE, /* 3224 */ + IC_VEX_L_W_OPSIZE, /* 3225 */ + IC_VEX_L_W_OPSIZE, /* 3226 */ + IC_VEX_L_W_OPSIZE, /* 3227 */ + IC_VEX_L_W_OPSIZE, /* 3228 */ + IC_VEX_L_W_OPSIZE, /* 3229 */ + IC_VEX_L_W_OPSIZE, /* 3230 */ + IC_VEX_L_W_OPSIZE, /* 3231 */ + IC_VEX_L, /* 3232 */ + IC_VEX_L, /* 3233 */ + IC_VEX_L_XS, /* 3234 */ + IC_VEX_L_XS, /* 3235 */ + IC_VEX_L_XD, /* 3236 */ + IC_VEX_L_XD, /* 3237 */ + IC_VEX_L_XD, /* 3238 */ + IC_VEX_L_XD, /* 3239 */ + IC_VEX_L_W, /* 3240 */ + IC_VEX_L_W, /* 3241 */ + IC_VEX_L_W_XS, /* 3242 */ + IC_VEX_L_W_XS, /* 3243 */ + IC_VEX_L_W_XD, /* 3244 */ + IC_VEX_L_W_XD, /* 3245 */ + IC_VEX_L_W_XD, /* 3246 */ + IC_VEX_L_W_XD, /* 3247 */ + IC_VEX_L_OPSIZE, /* 3248 */ + IC_VEX_L_OPSIZE, /* 3249 */ + IC_VEX_L_OPSIZE, /* 3250 */ + IC_VEX_L_OPSIZE, /* 3251 */ + IC_VEX_L_OPSIZE, /* 3252 */ + IC_VEX_L_OPSIZE, /* 3253 */ + IC_VEX_L_OPSIZE, /* 3254 */ + IC_VEX_L_OPSIZE, /* 3255 */ + IC_VEX_L_W_OPSIZE, /* 3256 */ + IC_VEX_L_W_OPSIZE, /* 3257 */ + IC_VEX_L_W_OPSIZE, /* 3258 */ + IC_VEX_L_W_OPSIZE, /* 3259 */ + IC_VEX_L_W_OPSIZE, /* 3260 */ + IC_VEX_L_W_OPSIZE, /* 3261 */ + IC_VEX_L_W_OPSIZE, /* 3262 */ + IC_VEX_L_W_OPSIZE, /* 3263 */ + IC_VEX_L, /* 3264 */ + IC_VEX_L, /* 3265 */ + IC_VEX_L_XS, /* 3266 */ + IC_VEX_L_XS, /* 3267 */ + IC_VEX_L_XD, /* 3268 */ + IC_VEX_L_XD, /* 3269 */ + IC_VEX_L_XD, /* 3270 */ + IC_VEX_L_XD, /* 3271 */ + IC_VEX_L_W, /* 3272 */ + IC_VEX_L_W, /* 3273 */ + IC_VEX_L_W_XS, /* 3274 */ + IC_VEX_L_W_XS, /* 3275 */ + IC_VEX_L_W_XD, /* 3276 */ + IC_VEX_L_W_XD, /* 3277 */ + IC_VEX_L_W_XD, /* 3278 */ + IC_VEX_L_W_XD, /* 3279 */ + IC_VEX_L_OPSIZE, /* 3280 */ + IC_VEX_L_OPSIZE, /* 3281 */ + IC_VEX_L_OPSIZE, /* 3282 */ + IC_VEX_L_OPSIZE, /* 3283 */ + IC_VEX_L_OPSIZE, /* 3284 */ + IC_VEX_L_OPSIZE, /* 3285 */ + IC_VEX_L_OPSIZE, /* 3286 */ + IC_VEX_L_OPSIZE, /* 3287 */ + IC_VEX_L_W_OPSIZE, /* 3288 */ + IC_VEX_L_W_OPSIZE, /* 3289 */ + IC_VEX_L_W_OPSIZE, /* 3290 */ + IC_VEX_L_W_OPSIZE, /* 3291 */ + IC_VEX_L_W_OPSIZE, /* 3292 */ + IC_VEX_L_W_OPSIZE, /* 3293 */ + IC_VEX_L_W_OPSIZE, /* 3294 */ + IC_VEX_L_W_OPSIZE, /* 3295 */ + IC_VEX_L, /* 3296 */ + IC_VEX_L, /* 3297 */ + IC_VEX_L_XS, /* 3298 */ + IC_VEX_L_XS, /* 3299 */ + IC_VEX_L_XD, /* 3300 */ + IC_VEX_L_XD, /* 3301 */ + IC_VEX_L_XD, /* 3302 */ + IC_VEX_L_XD, /* 3303 */ + IC_VEX_L_W, /* 3304 */ + IC_VEX_L_W, /* 3305 */ + IC_VEX_L_W_XS, /* 3306 */ + IC_VEX_L_W_XS, /* 3307 */ + IC_VEX_L_W_XD, /* 3308 */ + IC_VEX_L_W_XD, /* 3309 */ + IC_VEX_L_W_XD, /* 3310 */ + IC_VEX_L_W_XD, /* 3311 */ + IC_VEX_L_OPSIZE, /* 3312 */ + IC_VEX_L_OPSIZE, /* 3313 */ + IC_VEX_L_OPSIZE, /* 3314 */ + IC_VEX_L_OPSIZE, /* 3315 */ + IC_VEX_L_OPSIZE, /* 3316 */ + IC_VEX_L_OPSIZE, /* 3317 */ + IC_VEX_L_OPSIZE, /* 3318 */ + IC_VEX_L_OPSIZE, /* 3319 */ + IC_VEX_L_W_OPSIZE, /* 3320 */ + IC_VEX_L_W_OPSIZE, /* 3321 */ + IC_VEX_L_W_OPSIZE, /* 3322 */ + IC_VEX_L_W_OPSIZE, /* 3323 */ + IC_VEX_L_W_OPSIZE, /* 3324 */ + IC_VEX_L_W_OPSIZE, /* 3325 */ + IC_VEX_L_W_OPSIZE, /* 3326 */ + IC_VEX_L_W_OPSIZE, /* 3327 */ + IC_EVEX_L2_K, /* 3328 */ + IC_EVEX_L2_K, /* 3329 */ + IC_EVEX_L2_XS_K, /* 3330 */ + IC_EVEX_L2_XS_K, /* 3331 */ + IC_EVEX_L2_XD_K, /* 3332 */ + IC_EVEX_L2_XD_K, /* 3333 */ + IC_EVEX_L2_XD_K, /* 3334 */ + IC_EVEX_L2_XD_K, /* 3335 */ + IC_EVEX_L2_W_K, /* 3336 */ + IC_EVEX_L2_W_K, /* 3337 */ + IC_EVEX_L2_W_XS_K, /* 3338 */ + IC_EVEX_L2_W_XS_K, /* 3339 */ + IC_EVEX_L2_W_XD_K, /* 3340 */ + IC_EVEX_L2_W_XD_K, /* 3341 */ + IC_EVEX_L2_W_XD_K, /* 3342 */ + IC_EVEX_L2_W_XD_K, /* 3343 */ + IC_EVEX_L2_OPSIZE_K, /* 3344 */ + IC_EVEX_L2_OPSIZE_K, /* 3345 */ + IC_EVEX_L2_OPSIZE_K, /* 3346 */ + IC_EVEX_L2_OPSIZE_K, /* 3347 */ + IC_EVEX_L2_OPSIZE_K, /* 3348 */ + IC_EVEX_L2_OPSIZE_K, /* 3349 */ + IC_EVEX_L2_OPSIZE_K, /* 3350 */ + IC_EVEX_L2_OPSIZE_K, /* 3351 */ + IC_EVEX_L2_W_OPSIZE_K, /* 3352 */ + IC_EVEX_L2_W_OPSIZE_K, /* 3353 */ + IC_EVEX_L2_W_OPSIZE_K, /* 3354 */ + IC_EVEX_L2_W_OPSIZE_K, /* 3355 */ + IC_EVEX_L2_W_OPSIZE_K, /* 3356 */ + IC_EVEX_L2_W_OPSIZE_K, /* 3357 */ + IC_EVEX_L2_W_OPSIZE_K, /* 3358 */ + IC_EVEX_L2_W_OPSIZE_K, /* 3359 */ + IC_EVEX_L2_K, /* 3360 */ + IC_EVEX_L2_K, /* 3361 */ + IC_EVEX_L2_XS_K, /* 3362 */ + IC_EVEX_L2_XS_K, /* 3363 */ + IC_EVEX_L2_XD_K, /* 3364 */ + IC_EVEX_L2_XD_K, /* 3365 */ + IC_EVEX_L2_XD_K, /* 3366 */ + IC_EVEX_L2_XD_K, /* 3367 */ + IC_EVEX_L2_W_K, /* 3368 */ + IC_EVEX_L2_W_K, /* 3369 */ + IC_EVEX_L2_W_XS_K, /* 3370 */ + IC_EVEX_L2_W_XS_K, /* 3371 */ + IC_EVEX_L2_W_XD_K, /* 3372 */ + IC_EVEX_L2_W_XD_K, /* 3373 */ + IC_EVEX_L2_W_XD_K, /* 3374 */ + IC_EVEX_L2_W_XD_K, /* 3375 */ + IC_EVEX_L2_OPSIZE_K, /* 3376 */ + IC_EVEX_L2_OPSIZE_K, /* 3377 */ + IC_EVEX_L2_OPSIZE_K, /* 3378 */ + IC_EVEX_L2_OPSIZE_K, /* 3379 */ + IC_EVEX_L2_OPSIZE_K, /* 3380 */ + IC_EVEX_L2_OPSIZE_K, /* 3381 */ + IC_EVEX_L2_OPSIZE_K, /* 3382 */ + IC_EVEX_L2_OPSIZE_K, /* 3383 */ + IC_EVEX_L2_W_OPSIZE_K, /* 3384 */ + IC_EVEX_L2_W_OPSIZE_K, /* 3385 */ + IC_EVEX_L2_W_OPSIZE_K, /* 3386 */ + IC_EVEX_L2_W_OPSIZE_K, /* 3387 */ + IC_EVEX_L2_W_OPSIZE_K, /* 3388 */ + IC_EVEX_L2_W_OPSIZE_K, /* 3389 */ + IC_EVEX_L2_W_OPSIZE_K, /* 3390 */ + IC_EVEX_L2_W_OPSIZE_K, /* 3391 */ + IC_EVEX_L2_K, /* 3392 */ + IC_EVEX_L2_K, /* 3393 */ + IC_EVEX_L2_XS_K, /* 3394 */ + IC_EVEX_L2_XS_K, /* 3395 */ + IC_EVEX_L2_XD_K, /* 3396 */ + IC_EVEX_L2_XD_K, /* 3397 */ + IC_EVEX_L2_XD_K, /* 3398 */ + IC_EVEX_L2_XD_K, /* 3399 */ + IC_EVEX_L2_W_K, /* 3400 */ + IC_EVEX_L2_W_K, /* 3401 */ + IC_EVEX_L2_W_XS_K, /* 3402 */ + IC_EVEX_L2_W_XS_K, /* 3403 */ + IC_EVEX_L2_W_XD_K, /* 3404 */ + IC_EVEX_L2_W_XD_K, /* 3405 */ + IC_EVEX_L2_W_XD_K, /* 3406 */ + IC_EVEX_L2_W_XD_K, /* 3407 */ + IC_EVEX_L2_OPSIZE_K, /* 3408 */ + IC_EVEX_L2_OPSIZE_K, /* 3409 */ + IC_EVEX_L2_OPSIZE_K, /* 3410 */ + IC_EVEX_L2_OPSIZE_K, /* 3411 */ + IC_EVEX_L2_OPSIZE_K, /* 3412 */ + IC_EVEX_L2_OPSIZE_K, /* 3413 */ + IC_EVEX_L2_OPSIZE_K, /* 3414 */ + IC_EVEX_L2_OPSIZE_K, /* 3415 */ + IC_EVEX_L2_W_OPSIZE_K, /* 3416 */ + IC_EVEX_L2_W_OPSIZE_K, /* 3417 */ + IC_EVEX_L2_W_OPSIZE_K, /* 3418 */ + IC_EVEX_L2_W_OPSIZE_K, /* 3419 */ + IC_EVEX_L2_W_OPSIZE_K, /* 3420 */ + IC_EVEX_L2_W_OPSIZE_K, /* 3421 */ + IC_EVEX_L2_W_OPSIZE_K, /* 3422 */ + IC_EVEX_L2_W_OPSIZE_K, /* 3423 */ + IC_EVEX_L2_K, /* 3424 */ + IC_EVEX_L2_K, /* 3425 */ + IC_EVEX_L2_XS_K, /* 3426 */ + IC_EVEX_L2_XS_K, /* 3427 */ + IC_EVEX_L2_XD_K, /* 3428 */ + IC_EVEX_L2_XD_K, /* 3429 */ + IC_EVEX_L2_XD_K, /* 3430 */ + IC_EVEX_L2_XD_K, /* 3431 */ + IC_EVEX_L2_W_K, /* 3432 */ + IC_EVEX_L2_W_K, /* 3433 */ + IC_EVEX_L2_W_XS_K, /* 3434 */ + IC_EVEX_L2_W_XS_K, /* 3435 */ + IC_EVEX_L2_W_XD_K, /* 3436 */ + IC_EVEX_L2_W_XD_K, /* 3437 */ + IC_EVEX_L2_W_XD_K, /* 3438 */ + IC_EVEX_L2_W_XD_K, /* 3439 */ + IC_EVEX_L2_OPSIZE_K, /* 3440 */ + IC_EVEX_L2_OPSIZE_K, /* 3441 */ + IC_EVEX_L2_OPSIZE_K, /* 3442 */ + IC_EVEX_L2_OPSIZE_K, /* 3443 */ + IC_EVEX_L2_OPSIZE_K, /* 3444 */ + IC_EVEX_L2_OPSIZE_K, /* 3445 */ + IC_EVEX_L2_OPSIZE_K, /* 3446 */ + IC_EVEX_L2_OPSIZE_K, /* 3447 */ + IC_EVEX_L2_W_OPSIZE_K, /* 3448 */ + IC_EVEX_L2_W_OPSIZE_K, /* 3449 */ + IC_EVEX_L2_W_OPSIZE_K, /* 3450 */ + IC_EVEX_L2_W_OPSIZE_K, /* 3451 */ + IC_EVEX_L2_W_OPSIZE_K, /* 3452 */ + IC_EVEX_L2_W_OPSIZE_K, /* 3453 */ + IC_EVEX_L2_W_OPSIZE_K, /* 3454 */ + IC_EVEX_L2_W_OPSIZE_K, /* 3455 */ + IC_EVEX_L2_K, /* 3456 */ + IC_EVEX_L2_K, /* 3457 */ + IC_EVEX_L2_XS_K, /* 3458 */ + IC_EVEX_L2_XS_K, /* 3459 */ + IC_EVEX_L2_XD_K, /* 3460 */ + IC_EVEX_L2_XD_K, /* 3461 */ + IC_EVEX_L2_XD_K, /* 3462 */ + IC_EVEX_L2_XD_K, /* 3463 */ + IC_EVEX_L2_W_K, /* 3464 */ + IC_EVEX_L2_W_K, /* 3465 */ + IC_EVEX_L2_W_XS_K, /* 3466 */ + IC_EVEX_L2_W_XS_K, /* 3467 */ + IC_EVEX_L2_W_XD_K, /* 3468 */ + IC_EVEX_L2_W_XD_K, /* 3469 */ + IC_EVEX_L2_W_XD_K, /* 3470 */ + IC_EVEX_L2_W_XD_K, /* 3471 */ + IC_EVEX_L2_OPSIZE_K, /* 3472 */ + IC_EVEX_L2_OPSIZE_K, /* 3473 */ + IC_EVEX_L2_OPSIZE_K, /* 3474 */ + IC_EVEX_L2_OPSIZE_K, /* 3475 */ + IC_EVEX_L2_OPSIZE_K, /* 3476 */ + IC_EVEX_L2_OPSIZE_K, /* 3477 */ + IC_EVEX_L2_OPSIZE_K, /* 3478 */ + IC_EVEX_L2_OPSIZE_K, /* 3479 */ + IC_EVEX_L2_W_OPSIZE_K, /* 3480 */ + IC_EVEX_L2_W_OPSIZE_K, /* 3481 */ + IC_EVEX_L2_W_OPSIZE_K, /* 3482 */ + IC_EVEX_L2_W_OPSIZE_K, /* 3483 */ + IC_EVEX_L2_W_OPSIZE_K, /* 3484 */ + IC_EVEX_L2_W_OPSIZE_K, /* 3485 */ + IC_EVEX_L2_W_OPSIZE_K, /* 3486 */ + IC_EVEX_L2_W_OPSIZE_K, /* 3487 */ + IC_EVEX_L2_K, /* 3488 */ + IC_EVEX_L2_K, /* 3489 */ + IC_EVEX_L2_XS_K, /* 3490 */ + IC_EVEX_L2_XS_K, /* 3491 */ + IC_EVEX_L2_XD_K, /* 3492 */ + IC_EVEX_L2_XD_K, /* 3493 */ + IC_EVEX_L2_XD_K, /* 3494 */ + IC_EVEX_L2_XD_K, /* 3495 */ + IC_EVEX_L2_W_K, /* 3496 */ + IC_EVEX_L2_W_K, /* 3497 */ + IC_EVEX_L2_W_XS_K, /* 3498 */ + IC_EVEX_L2_W_XS_K, /* 3499 */ + IC_EVEX_L2_W_XD_K, /* 3500 */ + IC_EVEX_L2_W_XD_K, /* 3501 */ + IC_EVEX_L2_W_XD_K, /* 3502 */ + IC_EVEX_L2_W_XD_K, /* 3503 */ + IC_EVEX_L2_OPSIZE_K, /* 3504 */ + IC_EVEX_L2_OPSIZE_K, /* 3505 */ + IC_EVEX_L2_OPSIZE_K, /* 3506 */ + IC_EVEX_L2_OPSIZE_K, /* 3507 */ + IC_EVEX_L2_OPSIZE_K, /* 3508 */ + IC_EVEX_L2_OPSIZE_K, /* 3509 */ + IC_EVEX_L2_OPSIZE_K, /* 3510 */ + IC_EVEX_L2_OPSIZE_K, /* 3511 */ + IC_EVEX_L2_W_OPSIZE_K, /* 3512 */ + IC_EVEX_L2_W_OPSIZE_K, /* 3513 */ + IC_EVEX_L2_W_OPSIZE_K, /* 3514 */ + IC_EVEX_L2_W_OPSIZE_K, /* 3515 */ + IC_EVEX_L2_W_OPSIZE_K, /* 3516 */ + IC_EVEX_L2_W_OPSIZE_K, /* 3517 */ + IC_EVEX_L2_W_OPSIZE_K, /* 3518 */ + IC_EVEX_L2_W_OPSIZE_K, /* 3519 */ + IC_EVEX_L2_K, /* 3520 */ + IC_EVEX_L2_K, /* 3521 */ + IC_EVEX_L2_XS_K, /* 3522 */ + IC_EVEX_L2_XS_K, /* 3523 */ + IC_EVEX_L2_XD_K, /* 3524 */ + IC_EVEX_L2_XD_K, /* 3525 */ + IC_EVEX_L2_XD_K, /* 3526 */ + IC_EVEX_L2_XD_K, /* 3527 */ + IC_EVEX_L2_W_K, /* 3528 */ + IC_EVEX_L2_W_K, /* 3529 */ + IC_EVEX_L2_W_XS_K, /* 3530 */ + IC_EVEX_L2_W_XS_K, /* 3531 */ + IC_EVEX_L2_W_XD_K, /* 3532 */ + IC_EVEX_L2_W_XD_K, /* 3533 */ + IC_EVEX_L2_W_XD_K, /* 3534 */ + IC_EVEX_L2_W_XD_K, /* 3535 */ + IC_EVEX_L2_OPSIZE_K, /* 3536 */ + IC_EVEX_L2_OPSIZE_K, /* 3537 */ + IC_EVEX_L2_OPSIZE_K, /* 3538 */ + IC_EVEX_L2_OPSIZE_K, /* 3539 */ + IC_EVEX_L2_OPSIZE_K, /* 3540 */ + IC_EVEX_L2_OPSIZE_K, /* 3541 */ + IC_EVEX_L2_OPSIZE_K, /* 3542 */ + IC_EVEX_L2_OPSIZE_K, /* 3543 */ + IC_EVEX_L2_W_OPSIZE_K, /* 3544 */ + IC_EVEX_L2_W_OPSIZE_K, /* 3545 */ + IC_EVEX_L2_W_OPSIZE_K, /* 3546 */ + IC_EVEX_L2_W_OPSIZE_K, /* 3547 */ + IC_EVEX_L2_W_OPSIZE_K, /* 3548 */ + IC_EVEX_L2_W_OPSIZE_K, /* 3549 */ + IC_EVEX_L2_W_OPSIZE_K, /* 3550 */ + IC_EVEX_L2_W_OPSIZE_K, /* 3551 */ + IC_EVEX_L2_K, /* 3552 */ + IC_EVEX_L2_K, /* 3553 */ + IC_EVEX_L2_XS_K, /* 3554 */ + IC_EVEX_L2_XS_K, /* 3555 */ + IC_EVEX_L2_XD_K, /* 3556 */ + IC_EVEX_L2_XD_K, /* 3557 */ + IC_EVEX_L2_XD_K, /* 3558 */ + IC_EVEX_L2_XD_K, /* 3559 */ + IC_EVEX_L2_W_K, /* 3560 */ + IC_EVEX_L2_W_K, /* 3561 */ + IC_EVEX_L2_W_XS_K, /* 3562 */ + IC_EVEX_L2_W_XS_K, /* 3563 */ + IC_EVEX_L2_W_XD_K, /* 3564 */ + IC_EVEX_L2_W_XD_K, /* 3565 */ + IC_EVEX_L2_W_XD_K, /* 3566 */ + IC_EVEX_L2_W_XD_K, /* 3567 */ + IC_EVEX_L2_OPSIZE_K, /* 3568 */ + IC_EVEX_L2_OPSIZE_K, /* 3569 */ + IC_EVEX_L2_OPSIZE_K, /* 3570 */ + IC_EVEX_L2_OPSIZE_K, /* 3571 */ + IC_EVEX_L2_OPSIZE_K, /* 3572 */ + IC_EVEX_L2_OPSIZE_K, /* 3573 */ + IC_EVEX_L2_OPSIZE_K, /* 3574 */ + IC_EVEX_L2_OPSIZE_K, /* 3575 */ + IC_EVEX_L2_W_OPSIZE_K, /* 3576 */ + IC_EVEX_L2_W_OPSIZE_K, /* 3577 */ + IC_EVEX_L2_W_OPSIZE_K, /* 3578 */ + IC_EVEX_L2_W_OPSIZE_K, /* 3579 */ + IC_EVEX_L2_W_OPSIZE_K, /* 3580 */ + IC_EVEX_L2_W_OPSIZE_K, /* 3581 */ + IC_EVEX_L2_W_OPSIZE_K, /* 3582 */ + IC_EVEX_L2_W_OPSIZE_K, /* 3583 */ + IC, /* 3584 */ + IC_64BIT, /* 3585 */ + IC_XS, /* 3586 */ + IC_64BIT_XS, /* 3587 */ + IC_XD, /* 3588 */ + IC_64BIT_XD, /* 3589 */ + IC_XS, /* 3590 */ + IC_64BIT_XS, /* 3591 */ + IC, /* 3592 */ + IC_64BIT_REXW, /* 3593 */ + IC_XS, /* 3594 */ + IC_64BIT_REXW_XS, /* 3595 */ + IC_XD, /* 3596 */ + IC_64BIT_REXW_XD, /* 3597 */ + IC_XS, /* 3598 */ + IC_64BIT_REXW_XS, /* 3599 */ + IC_OPSIZE, /* 3600 */ + IC_64BIT_OPSIZE, /* 3601 */ + IC_XS_OPSIZE, /* 3602 */ + IC_64BIT_XS_OPSIZE, /* 3603 */ + IC_XD_OPSIZE, /* 3604 */ + IC_64BIT_XD_OPSIZE, /* 3605 */ + IC_XS_OPSIZE, /* 3606 */ + IC_64BIT_XD_OPSIZE, /* 3607 */ + IC_OPSIZE, /* 3608 */ + IC_64BIT_REXW_OPSIZE, /* 3609 */ + IC_XS_OPSIZE, /* 3610 */ + IC_64BIT_REXW_XS, /* 3611 */ + IC_XD_OPSIZE, /* 3612 */ + IC_64BIT_REXW_XD, /* 3613 */ + IC_XS_OPSIZE, /* 3614 */ + IC_64BIT_REXW_XS, /* 3615 */ + IC_ADSIZE, /* 3616 */ + IC_64BIT_ADSIZE, /* 3617 */ + IC_XS_ADSIZE, /* 3618 */ + IC_64BIT_XS_ADSIZE, /* 3619 */ + IC_XD_ADSIZE, /* 3620 */ + IC_64BIT_XD_ADSIZE, /* 3621 */ + IC_XS_ADSIZE, /* 3622 */ + IC_64BIT_XD_ADSIZE, /* 3623 */ + IC_ADSIZE, /* 3624 */ + IC_64BIT_REXW_ADSIZE, /* 3625 */ + IC_XS_ADSIZE, /* 3626 */ + IC_64BIT_REXW_XS, /* 3627 */ + IC_XD_ADSIZE, /* 3628 */ + IC_64BIT_REXW_XD, /* 3629 */ + IC_XS_ADSIZE, /* 3630 */ + IC_64BIT_REXW_XS, /* 3631 */ + IC_OPSIZE_ADSIZE, /* 3632 */ + IC_64BIT_OPSIZE_ADSIZE, /* 3633 */ + IC_XS_OPSIZE, /* 3634 */ + IC_64BIT_XS_OPSIZE, /* 3635 */ + IC_XD_OPSIZE, /* 3636 */ + IC_64BIT_XD_OPSIZE, /* 3637 */ + IC_XS_OPSIZE, /* 3638 */ + IC_64BIT_XD_OPSIZE, /* 3639 */ + IC_OPSIZE_ADSIZE, /* 3640 */ + IC_64BIT_REXW_OPSIZE, /* 3641 */ + IC_XS_OPSIZE, /* 3642 */ + IC_64BIT_REXW_XS, /* 3643 */ + IC_XD_OPSIZE, /* 3644 */ + IC_64BIT_REXW_XD, /* 3645 */ + IC_XS_OPSIZE, /* 3646 */ + IC_64BIT_REXW_XS, /* 3647 */ + IC_VEX, /* 3648 */ + IC_VEX, /* 3649 */ + IC_VEX_XS, /* 3650 */ + IC_VEX_XS, /* 3651 */ + IC_VEX_XD, /* 3652 */ + IC_VEX_XD, /* 3653 */ + IC_VEX_XD, /* 3654 */ + IC_VEX_XD, /* 3655 */ + IC_VEX_W, /* 3656 */ + IC_VEX_W, /* 3657 */ + IC_VEX_W_XS, /* 3658 */ + IC_VEX_W_XS, /* 3659 */ + IC_VEX_W_XD, /* 3660 */ + IC_VEX_W_XD, /* 3661 */ + IC_VEX_W_XD, /* 3662 */ + IC_VEX_W_XD, /* 3663 */ + IC_VEX_OPSIZE, /* 3664 */ + IC_VEX_OPSIZE, /* 3665 */ + IC_VEX_OPSIZE, /* 3666 */ + IC_VEX_OPSIZE, /* 3667 */ + IC_VEX_OPSIZE, /* 3668 */ + IC_VEX_OPSIZE, /* 3669 */ + IC_VEX_OPSIZE, /* 3670 */ + IC_VEX_OPSIZE, /* 3671 */ + IC_VEX_W_OPSIZE, /* 3672 */ + IC_VEX_W_OPSIZE, /* 3673 */ + IC_VEX_W_OPSIZE, /* 3674 */ + IC_VEX_W_OPSIZE, /* 3675 */ + IC_VEX_W_OPSIZE, /* 3676 */ + IC_VEX_W_OPSIZE, /* 3677 */ + IC_VEX_W_OPSIZE, /* 3678 */ + IC_VEX_W_OPSIZE, /* 3679 */ + IC_VEX, /* 3680 */ + IC_VEX, /* 3681 */ + IC_VEX_XS, /* 3682 */ + IC_VEX_XS, /* 3683 */ + IC_VEX_XD, /* 3684 */ + IC_VEX_XD, /* 3685 */ + IC_VEX_XD, /* 3686 */ + IC_VEX_XD, /* 3687 */ + IC_VEX_W, /* 3688 */ + IC_VEX_W, /* 3689 */ + IC_VEX_W_XS, /* 3690 */ + IC_VEX_W_XS, /* 3691 */ + IC_VEX_W_XD, /* 3692 */ + IC_VEX_W_XD, /* 3693 */ + IC_VEX_W_XD, /* 3694 */ + IC_VEX_W_XD, /* 3695 */ + IC_VEX_OPSIZE, /* 3696 */ + IC_VEX_OPSIZE, /* 3697 */ + IC_VEX_OPSIZE, /* 3698 */ + IC_VEX_OPSIZE, /* 3699 */ + IC_VEX_OPSIZE, /* 3700 */ + IC_VEX_OPSIZE, /* 3701 */ + IC_VEX_OPSIZE, /* 3702 */ + IC_VEX_OPSIZE, /* 3703 */ + IC_VEX_W_OPSIZE, /* 3704 */ + IC_VEX_W_OPSIZE, /* 3705 */ + IC_VEX_W_OPSIZE, /* 3706 */ + IC_VEX_W_OPSIZE, /* 3707 */ + IC_VEX_W_OPSIZE, /* 3708 */ + IC_VEX_W_OPSIZE, /* 3709 */ + IC_VEX_W_OPSIZE, /* 3710 */ + IC_VEX_W_OPSIZE, /* 3711 */ + IC_VEX_L, /* 3712 */ + IC_VEX_L, /* 3713 */ + IC_VEX_L_XS, /* 3714 */ + IC_VEX_L_XS, /* 3715 */ + IC_VEX_L_XD, /* 3716 */ + IC_VEX_L_XD, /* 3717 */ + IC_VEX_L_XD, /* 3718 */ + IC_VEX_L_XD, /* 3719 */ + IC_VEX_L_W, /* 3720 */ + IC_VEX_L_W, /* 3721 */ + IC_VEX_L_W_XS, /* 3722 */ + IC_VEX_L_W_XS, /* 3723 */ + IC_VEX_L_W_XD, /* 3724 */ + IC_VEX_L_W_XD, /* 3725 */ + IC_VEX_L_W_XD, /* 3726 */ + IC_VEX_L_W_XD, /* 3727 */ + IC_VEX_L_OPSIZE, /* 3728 */ + IC_VEX_L_OPSIZE, /* 3729 */ + IC_VEX_L_OPSIZE, /* 3730 */ + IC_VEX_L_OPSIZE, /* 3731 */ + IC_VEX_L_OPSIZE, /* 3732 */ + IC_VEX_L_OPSIZE, /* 3733 */ + IC_VEX_L_OPSIZE, /* 3734 */ + IC_VEX_L_OPSIZE, /* 3735 */ + IC_VEX_L_W_OPSIZE, /* 3736 */ + IC_VEX_L_W_OPSIZE, /* 3737 */ + IC_VEX_L_W_OPSIZE, /* 3738 */ + IC_VEX_L_W_OPSIZE, /* 3739 */ + IC_VEX_L_W_OPSIZE, /* 3740 */ + IC_VEX_L_W_OPSIZE, /* 3741 */ + IC_VEX_L_W_OPSIZE, /* 3742 */ + IC_VEX_L_W_OPSIZE, /* 3743 */ + IC_VEX_L, /* 3744 */ + IC_VEX_L, /* 3745 */ + IC_VEX_L_XS, /* 3746 */ + IC_VEX_L_XS, /* 3747 */ + IC_VEX_L_XD, /* 3748 */ + IC_VEX_L_XD, /* 3749 */ + IC_VEX_L_XD, /* 3750 */ + IC_VEX_L_XD, /* 3751 */ + IC_VEX_L_W, /* 3752 */ + IC_VEX_L_W, /* 3753 */ + IC_VEX_L_W_XS, /* 3754 */ + IC_VEX_L_W_XS, /* 3755 */ + IC_VEX_L_W_XD, /* 3756 */ + IC_VEX_L_W_XD, /* 3757 */ + IC_VEX_L_W_XD, /* 3758 */ + IC_VEX_L_W_XD, /* 3759 */ + IC_VEX_L_OPSIZE, /* 3760 */ + IC_VEX_L_OPSIZE, /* 3761 */ + IC_VEX_L_OPSIZE, /* 3762 */ + IC_VEX_L_OPSIZE, /* 3763 */ + IC_VEX_L_OPSIZE, /* 3764 */ + IC_VEX_L_OPSIZE, /* 3765 */ + IC_VEX_L_OPSIZE, /* 3766 */ + IC_VEX_L_OPSIZE, /* 3767 */ + IC_VEX_L_W_OPSIZE, /* 3768 */ + IC_VEX_L_W_OPSIZE, /* 3769 */ + IC_VEX_L_W_OPSIZE, /* 3770 */ + IC_VEX_L_W_OPSIZE, /* 3771 */ + IC_VEX_L_W_OPSIZE, /* 3772 */ + IC_VEX_L_W_OPSIZE, /* 3773 */ + IC_VEX_L_W_OPSIZE, /* 3774 */ + IC_VEX_L_W_OPSIZE, /* 3775 */ + IC_VEX_L, /* 3776 */ + IC_VEX_L, /* 3777 */ + IC_VEX_L_XS, /* 3778 */ + IC_VEX_L_XS, /* 3779 */ + IC_VEX_L_XD, /* 3780 */ + IC_VEX_L_XD, /* 3781 */ + IC_VEX_L_XD, /* 3782 */ + IC_VEX_L_XD, /* 3783 */ + IC_VEX_L_W, /* 3784 */ + IC_VEX_L_W, /* 3785 */ + IC_VEX_L_W_XS, /* 3786 */ + IC_VEX_L_W_XS, /* 3787 */ + IC_VEX_L_W_XD, /* 3788 */ + IC_VEX_L_W_XD, /* 3789 */ + IC_VEX_L_W_XD, /* 3790 */ + IC_VEX_L_W_XD, /* 3791 */ + IC_VEX_L_OPSIZE, /* 3792 */ + IC_VEX_L_OPSIZE, /* 3793 */ + IC_VEX_L_OPSIZE, /* 3794 */ + IC_VEX_L_OPSIZE, /* 3795 */ + IC_VEX_L_OPSIZE, /* 3796 */ + IC_VEX_L_OPSIZE, /* 3797 */ + IC_VEX_L_OPSIZE, /* 3798 */ + IC_VEX_L_OPSIZE, /* 3799 */ + IC_VEX_L_W_OPSIZE, /* 3800 */ + IC_VEX_L_W_OPSIZE, /* 3801 */ + IC_VEX_L_W_OPSIZE, /* 3802 */ + IC_VEX_L_W_OPSIZE, /* 3803 */ + IC_VEX_L_W_OPSIZE, /* 3804 */ + IC_VEX_L_W_OPSIZE, /* 3805 */ + IC_VEX_L_W_OPSIZE, /* 3806 */ + IC_VEX_L_W_OPSIZE, /* 3807 */ + IC_VEX_L, /* 3808 */ + IC_VEX_L, /* 3809 */ + IC_VEX_L_XS, /* 3810 */ + IC_VEX_L_XS, /* 3811 */ + IC_VEX_L_XD, /* 3812 */ + IC_VEX_L_XD, /* 3813 */ + IC_VEX_L_XD, /* 3814 */ + IC_VEX_L_XD, /* 3815 */ + IC_VEX_L_W, /* 3816 */ + IC_VEX_L_W, /* 3817 */ + IC_VEX_L_W_XS, /* 3818 */ + IC_VEX_L_W_XS, /* 3819 */ + IC_VEX_L_W_XD, /* 3820 */ + IC_VEX_L_W_XD, /* 3821 */ + IC_VEX_L_W_XD, /* 3822 */ + IC_VEX_L_W_XD, /* 3823 */ + IC_VEX_L_OPSIZE, /* 3824 */ + IC_VEX_L_OPSIZE, /* 3825 */ + IC_VEX_L_OPSIZE, /* 3826 */ + IC_VEX_L_OPSIZE, /* 3827 */ + IC_VEX_L_OPSIZE, /* 3828 */ + IC_VEX_L_OPSIZE, /* 3829 */ + IC_VEX_L_OPSIZE, /* 3830 */ + IC_VEX_L_OPSIZE, /* 3831 */ + IC_VEX_L_W_OPSIZE, /* 3832 */ + IC_VEX_L_W_OPSIZE, /* 3833 */ + IC_VEX_L_W_OPSIZE, /* 3834 */ + IC_VEX_L_W_OPSIZE, /* 3835 */ + IC_VEX_L_W_OPSIZE, /* 3836 */ + IC_VEX_L_W_OPSIZE, /* 3837 */ + IC_VEX_L_W_OPSIZE, /* 3838 */ + IC_VEX_L_W_OPSIZE, /* 3839 */ + IC_EVEX_L2_K, /* 3840 */ + IC_EVEX_L2_K, /* 3841 */ + IC_EVEX_L2_XS_K, /* 3842 */ + IC_EVEX_L2_XS_K, /* 3843 */ + IC_EVEX_L2_XD_K, /* 3844 */ + IC_EVEX_L2_XD_K, /* 3845 */ + IC_EVEX_L2_XD_K, /* 3846 */ + IC_EVEX_L2_XD_K, /* 3847 */ + IC_EVEX_L2_W_K, /* 3848 */ + IC_EVEX_L2_W_K, /* 3849 */ + IC_EVEX_L2_W_XS_K, /* 3850 */ + IC_EVEX_L2_W_XS_K, /* 3851 */ + IC_EVEX_L2_W_XD_K, /* 3852 */ + IC_EVEX_L2_W_XD_K, /* 3853 */ + IC_EVEX_L2_W_XD_K, /* 3854 */ + IC_EVEX_L2_W_XD_K, /* 3855 */ + IC_EVEX_L2_OPSIZE_K, /* 3856 */ + IC_EVEX_L2_OPSIZE_K, /* 3857 */ + IC_EVEX_L2_OPSIZE_K, /* 3858 */ + IC_EVEX_L2_OPSIZE_K, /* 3859 */ + IC_EVEX_L2_OPSIZE_K, /* 3860 */ + IC_EVEX_L2_OPSIZE_K, /* 3861 */ + IC_EVEX_L2_OPSIZE_K, /* 3862 */ + IC_EVEX_L2_OPSIZE_K, /* 3863 */ + IC_EVEX_L2_W_OPSIZE_K, /* 3864 */ + IC_EVEX_L2_W_OPSIZE_K, /* 3865 */ + IC_EVEX_L2_W_OPSIZE_K, /* 3866 */ + IC_EVEX_L2_W_OPSIZE_K, /* 3867 */ + IC_EVEX_L2_W_OPSIZE_K, /* 3868 */ + IC_EVEX_L2_W_OPSIZE_K, /* 3869 */ + IC_EVEX_L2_W_OPSIZE_K, /* 3870 */ + IC_EVEX_L2_W_OPSIZE_K, /* 3871 */ + IC_EVEX_L2_K, /* 3872 */ + IC_EVEX_L2_K, /* 3873 */ + IC_EVEX_L2_XS_K, /* 3874 */ + IC_EVEX_L2_XS_K, /* 3875 */ + IC_EVEX_L2_XD_K, /* 3876 */ + IC_EVEX_L2_XD_K, /* 3877 */ + IC_EVEX_L2_XD_K, /* 3878 */ + IC_EVEX_L2_XD_K, /* 3879 */ + IC_EVEX_L2_W_K, /* 3880 */ + IC_EVEX_L2_W_K, /* 3881 */ + IC_EVEX_L2_W_XS_K, /* 3882 */ + IC_EVEX_L2_W_XS_K, /* 3883 */ + IC_EVEX_L2_W_XD_K, /* 3884 */ + IC_EVEX_L2_W_XD_K, /* 3885 */ + IC_EVEX_L2_W_XD_K, /* 3886 */ + IC_EVEX_L2_W_XD_K, /* 3887 */ + IC_EVEX_L2_OPSIZE_K, /* 3888 */ + IC_EVEX_L2_OPSIZE_K, /* 3889 */ + IC_EVEX_L2_OPSIZE_K, /* 3890 */ + IC_EVEX_L2_OPSIZE_K, /* 3891 */ + IC_EVEX_L2_OPSIZE_K, /* 3892 */ + IC_EVEX_L2_OPSIZE_K, /* 3893 */ + IC_EVEX_L2_OPSIZE_K, /* 3894 */ + IC_EVEX_L2_OPSIZE_K, /* 3895 */ + IC_EVEX_L2_W_OPSIZE_K, /* 3896 */ + IC_EVEX_L2_W_OPSIZE_K, /* 3897 */ + IC_EVEX_L2_W_OPSIZE_K, /* 3898 */ + IC_EVEX_L2_W_OPSIZE_K, /* 3899 */ + IC_EVEX_L2_W_OPSIZE_K, /* 3900 */ + IC_EVEX_L2_W_OPSIZE_K, /* 3901 */ + IC_EVEX_L2_W_OPSIZE_K, /* 3902 */ + IC_EVEX_L2_W_OPSIZE_K, /* 3903 */ + IC_EVEX_L2_K, /* 3904 */ + IC_EVEX_L2_K, /* 3905 */ + IC_EVEX_L2_XS_K, /* 3906 */ + IC_EVEX_L2_XS_K, /* 3907 */ + IC_EVEX_L2_XD_K, /* 3908 */ + IC_EVEX_L2_XD_K, /* 3909 */ + IC_EVEX_L2_XD_K, /* 3910 */ + IC_EVEX_L2_XD_K, /* 3911 */ + IC_EVEX_L2_W_K, /* 3912 */ + IC_EVEX_L2_W_K, /* 3913 */ + IC_EVEX_L2_W_XS_K, /* 3914 */ + IC_EVEX_L2_W_XS_K, /* 3915 */ + IC_EVEX_L2_W_XD_K, /* 3916 */ + IC_EVEX_L2_W_XD_K, /* 3917 */ + IC_EVEX_L2_W_XD_K, /* 3918 */ + IC_EVEX_L2_W_XD_K, /* 3919 */ + IC_EVEX_L2_OPSIZE_K, /* 3920 */ + IC_EVEX_L2_OPSIZE_K, /* 3921 */ + IC_EVEX_L2_OPSIZE_K, /* 3922 */ + IC_EVEX_L2_OPSIZE_K, /* 3923 */ + IC_EVEX_L2_OPSIZE_K, /* 3924 */ + IC_EVEX_L2_OPSIZE_K, /* 3925 */ + IC_EVEX_L2_OPSIZE_K, /* 3926 */ + IC_EVEX_L2_OPSIZE_K, /* 3927 */ + IC_EVEX_L2_W_OPSIZE_K, /* 3928 */ + IC_EVEX_L2_W_OPSIZE_K, /* 3929 */ + IC_EVEX_L2_W_OPSIZE_K, /* 3930 */ + IC_EVEX_L2_W_OPSIZE_K, /* 3931 */ + IC_EVEX_L2_W_OPSIZE_K, /* 3932 */ + IC_EVEX_L2_W_OPSIZE_K, /* 3933 */ + IC_EVEX_L2_W_OPSIZE_K, /* 3934 */ + IC_EVEX_L2_W_OPSIZE_K, /* 3935 */ + IC_EVEX_L2_K, /* 3936 */ + IC_EVEX_L2_K, /* 3937 */ + IC_EVEX_L2_XS_K, /* 3938 */ + IC_EVEX_L2_XS_K, /* 3939 */ + IC_EVEX_L2_XD_K, /* 3940 */ + IC_EVEX_L2_XD_K, /* 3941 */ + IC_EVEX_L2_XD_K, /* 3942 */ + IC_EVEX_L2_XD_K, /* 3943 */ + IC_EVEX_L2_W_K, /* 3944 */ + IC_EVEX_L2_W_K, /* 3945 */ + IC_EVEX_L2_W_XS_K, /* 3946 */ + IC_EVEX_L2_W_XS_K, /* 3947 */ + IC_EVEX_L2_W_XD_K, /* 3948 */ + IC_EVEX_L2_W_XD_K, /* 3949 */ + IC_EVEX_L2_W_XD_K, /* 3950 */ + IC_EVEX_L2_W_XD_K, /* 3951 */ + IC_EVEX_L2_OPSIZE_K, /* 3952 */ + IC_EVEX_L2_OPSIZE_K, /* 3953 */ + IC_EVEX_L2_OPSIZE_K, /* 3954 */ + IC_EVEX_L2_OPSIZE_K, /* 3955 */ + IC_EVEX_L2_OPSIZE_K, /* 3956 */ + IC_EVEX_L2_OPSIZE_K, /* 3957 */ + IC_EVEX_L2_OPSIZE_K, /* 3958 */ + IC_EVEX_L2_OPSIZE_K, /* 3959 */ + IC_EVEX_L2_W_OPSIZE_K, /* 3960 */ + IC_EVEX_L2_W_OPSIZE_K, /* 3961 */ + IC_EVEX_L2_W_OPSIZE_K, /* 3962 */ + IC_EVEX_L2_W_OPSIZE_K, /* 3963 */ + IC_EVEX_L2_W_OPSIZE_K, /* 3964 */ + IC_EVEX_L2_W_OPSIZE_K, /* 3965 */ + IC_EVEX_L2_W_OPSIZE_K, /* 3966 */ + IC_EVEX_L2_W_OPSIZE_K, /* 3967 */ + IC_EVEX_L2_K, /* 3968 */ + IC_EVEX_L2_K, /* 3969 */ + IC_EVEX_L2_XS_K, /* 3970 */ + IC_EVEX_L2_XS_K, /* 3971 */ + IC_EVEX_L2_XD_K, /* 3972 */ + IC_EVEX_L2_XD_K, /* 3973 */ + IC_EVEX_L2_XD_K, /* 3974 */ + IC_EVEX_L2_XD_K, /* 3975 */ + IC_EVEX_L2_W_K, /* 3976 */ + IC_EVEX_L2_W_K, /* 3977 */ + IC_EVEX_L2_W_XS_K, /* 3978 */ + IC_EVEX_L2_W_XS_K, /* 3979 */ + IC_EVEX_L2_W_XD_K, /* 3980 */ + IC_EVEX_L2_W_XD_K, /* 3981 */ + IC_EVEX_L2_W_XD_K, /* 3982 */ + IC_EVEX_L2_W_XD_K, /* 3983 */ + IC_EVEX_L2_OPSIZE_K, /* 3984 */ + IC_EVEX_L2_OPSIZE_K, /* 3985 */ + IC_EVEX_L2_OPSIZE_K, /* 3986 */ + IC_EVEX_L2_OPSIZE_K, /* 3987 */ + IC_EVEX_L2_OPSIZE_K, /* 3988 */ + IC_EVEX_L2_OPSIZE_K, /* 3989 */ + IC_EVEX_L2_OPSIZE_K, /* 3990 */ + IC_EVEX_L2_OPSIZE_K, /* 3991 */ + IC_EVEX_L2_W_OPSIZE_K, /* 3992 */ + IC_EVEX_L2_W_OPSIZE_K, /* 3993 */ + IC_EVEX_L2_W_OPSIZE_K, /* 3994 */ + IC_EVEX_L2_W_OPSIZE_K, /* 3995 */ + IC_EVEX_L2_W_OPSIZE_K, /* 3996 */ + IC_EVEX_L2_W_OPSIZE_K, /* 3997 */ + IC_EVEX_L2_W_OPSIZE_K, /* 3998 */ + IC_EVEX_L2_W_OPSIZE_K, /* 3999 */ + IC_EVEX_L2_K, /* 4000 */ + IC_EVEX_L2_K, /* 4001 */ + IC_EVEX_L2_XS_K, /* 4002 */ + IC_EVEX_L2_XS_K, /* 4003 */ + IC_EVEX_L2_XD_K, /* 4004 */ + IC_EVEX_L2_XD_K, /* 4005 */ + IC_EVEX_L2_XD_K, /* 4006 */ + IC_EVEX_L2_XD_K, /* 4007 */ + IC_EVEX_L2_W_K, /* 4008 */ + IC_EVEX_L2_W_K, /* 4009 */ + IC_EVEX_L2_W_XS_K, /* 4010 */ + IC_EVEX_L2_W_XS_K, /* 4011 */ + IC_EVEX_L2_W_XD_K, /* 4012 */ + IC_EVEX_L2_W_XD_K, /* 4013 */ + IC_EVEX_L2_W_XD_K, /* 4014 */ + IC_EVEX_L2_W_XD_K, /* 4015 */ + IC_EVEX_L2_OPSIZE_K, /* 4016 */ + IC_EVEX_L2_OPSIZE_K, /* 4017 */ + IC_EVEX_L2_OPSIZE_K, /* 4018 */ + IC_EVEX_L2_OPSIZE_K, /* 4019 */ + IC_EVEX_L2_OPSIZE_K, /* 4020 */ + IC_EVEX_L2_OPSIZE_K, /* 4021 */ + IC_EVEX_L2_OPSIZE_K, /* 4022 */ + IC_EVEX_L2_OPSIZE_K, /* 4023 */ + IC_EVEX_L2_W_OPSIZE_K, /* 4024 */ + IC_EVEX_L2_W_OPSIZE_K, /* 4025 */ + IC_EVEX_L2_W_OPSIZE_K, /* 4026 */ + IC_EVEX_L2_W_OPSIZE_K, /* 4027 */ + IC_EVEX_L2_W_OPSIZE_K, /* 4028 */ + IC_EVEX_L2_W_OPSIZE_K, /* 4029 */ + IC_EVEX_L2_W_OPSIZE_K, /* 4030 */ + IC_EVEX_L2_W_OPSIZE_K, /* 4031 */ + IC_EVEX_L2_K, /* 4032 */ + IC_EVEX_L2_K, /* 4033 */ + IC_EVEX_L2_XS_K, /* 4034 */ + IC_EVEX_L2_XS_K, /* 4035 */ + IC_EVEX_L2_XD_K, /* 4036 */ + IC_EVEX_L2_XD_K, /* 4037 */ + IC_EVEX_L2_XD_K, /* 4038 */ + IC_EVEX_L2_XD_K, /* 4039 */ + IC_EVEX_L2_W_K, /* 4040 */ + IC_EVEX_L2_W_K, /* 4041 */ + IC_EVEX_L2_W_XS_K, /* 4042 */ + IC_EVEX_L2_W_XS_K, /* 4043 */ + IC_EVEX_L2_W_XD_K, /* 4044 */ + IC_EVEX_L2_W_XD_K, /* 4045 */ + IC_EVEX_L2_W_XD_K, /* 4046 */ + IC_EVEX_L2_W_XD_K, /* 4047 */ + IC_EVEX_L2_OPSIZE_K, /* 4048 */ + IC_EVEX_L2_OPSIZE_K, /* 4049 */ + IC_EVEX_L2_OPSIZE_K, /* 4050 */ + IC_EVEX_L2_OPSIZE_K, /* 4051 */ + IC_EVEX_L2_OPSIZE_K, /* 4052 */ + IC_EVEX_L2_OPSIZE_K, /* 4053 */ + IC_EVEX_L2_OPSIZE_K, /* 4054 */ + IC_EVEX_L2_OPSIZE_K, /* 4055 */ + IC_EVEX_L2_W_OPSIZE_K, /* 4056 */ + IC_EVEX_L2_W_OPSIZE_K, /* 4057 */ + IC_EVEX_L2_W_OPSIZE_K, /* 4058 */ + IC_EVEX_L2_W_OPSIZE_K, /* 4059 */ + IC_EVEX_L2_W_OPSIZE_K, /* 4060 */ + IC_EVEX_L2_W_OPSIZE_K, /* 4061 */ + IC_EVEX_L2_W_OPSIZE_K, /* 4062 */ + IC_EVEX_L2_W_OPSIZE_K, /* 4063 */ + IC_EVEX_L2_K, /* 4064 */ + IC_EVEX_L2_K, /* 4065 */ + IC_EVEX_L2_XS_K, /* 4066 */ + IC_EVEX_L2_XS_K, /* 4067 */ + IC_EVEX_L2_XD_K, /* 4068 */ + IC_EVEX_L2_XD_K, /* 4069 */ + IC_EVEX_L2_XD_K, /* 4070 */ + IC_EVEX_L2_XD_K, /* 4071 */ + IC_EVEX_L2_W_K, /* 4072 */ + IC_EVEX_L2_W_K, /* 4073 */ + IC_EVEX_L2_W_XS_K, /* 4074 */ + IC_EVEX_L2_W_XS_K, /* 4075 */ + IC_EVEX_L2_W_XD_K, /* 4076 */ + IC_EVEX_L2_W_XD_K, /* 4077 */ + IC_EVEX_L2_W_XD_K, /* 4078 */ + IC_EVEX_L2_W_XD_K, /* 4079 */ + IC_EVEX_L2_OPSIZE_K, /* 4080 */ + IC_EVEX_L2_OPSIZE_K, /* 4081 */ + IC_EVEX_L2_OPSIZE_K, /* 4082 */ + IC_EVEX_L2_OPSIZE_K, /* 4083 */ + IC_EVEX_L2_OPSIZE_K, /* 4084 */ + IC_EVEX_L2_OPSIZE_K, /* 4085 */ + IC_EVEX_L2_OPSIZE_K, /* 4086 */ + IC_EVEX_L2_OPSIZE_K, /* 4087 */ + IC_EVEX_L2_W_OPSIZE_K, /* 4088 */ + IC_EVEX_L2_W_OPSIZE_K, /* 4089 */ + IC_EVEX_L2_W_OPSIZE_K, /* 4090 */ + IC_EVEX_L2_W_OPSIZE_K, /* 4091 */ + IC_EVEX_L2_W_OPSIZE_K, /* 4092 */ + IC_EVEX_L2_W_OPSIZE_K, /* 4093 */ + IC_EVEX_L2_W_OPSIZE_K, /* 4094 */ + IC_EVEX_L2_W_OPSIZE_K, /* 4095 */ + IC, /* 4096 */ + IC_64BIT, /* 4097 */ + IC_XS, /* 4098 */ + IC_64BIT_XS, /* 4099 */ + IC_XD, /* 4100 */ + IC_64BIT_XD, /* 4101 */ + IC_XS, /* 4102 */ + IC_64BIT_XS, /* 4103 */ + IC, /* 4104 */ + IC_64BIT_REXW, /* 4105 */ + IC_XS, /* 4106 */ + IC_64BIT_REXW_XS, /* 4107 */ + IC_XD, /* 4108 */ + IC_64BIT_REXW_XD, /* 4109 */ + IC_XS, /* 4110 */ + IC_64BIT_REXW_XS, /* 4111 */ + IC_OPSIZE, /* 4112 */ + IC_64BIT_OPSIZE, /* 4113 */ + IC_XS_OPSIZE, /* 4114 */ + IC_64BIT_XS_OPSIZE, /* 4115 */ + IC_XD_OPSIZE, /* 4116 */ + IC_64BIT_XD_OPSIZE, /* 4117 */ + IC_XS_OPSIZE, /* 4118 */ + IC_64BIT_XD_OPSIZE, /* 4119 */ + IC_OPSIZE, /* 4120 */ + IC_64BIT_REXW_OPSIZE, /* 4121 */ + IC_XS_OPSIZE, /* 4122 */ + IC_64BIT_REXW_XS, /* 4123 */ + IC_XD_OPSIZE, /* 4124 */ + IC_64BIT_REXW_XD, /* 4125 */ + IC_XS_OPSIZE, /* 4126 */ + IC_64BIT_REXW_XS, /* 4127 */ + IC_ADSIZE, /* 4128 */ + IC_64BIT_ADSIZE, /* 4129 */ + IC_XS_ADSIZE, /* 4130 */ + IC_64BIT_XS_ADSIZE, /* 4131 */ + IC_XD_ADSIZE, /* 4132 */ + IC_64BIT_XD_ADSIZE, /* 4133 */ + IC_XS_ADSIZE, /* 4134 */ + IC_64BIT_XD_ADSIZE, /* 4135 */ + IC_ADSIZE, /* 4136 */ + IC_64BIT_REXW_ADSIZE, /* 4137 */ + IC_XS_ADSIZE, /* 4138 */ + IC_64BIT_REXW_XS, /* 4139 */ + IC_XD_ADSIZE, /* 4140 */ + IC_64BIT_REXW_XD, /* 4141 */ + IC_XS_ADSIZE, /* 4142 */ + IC_64BIT_REXW_XS, /* 4143 */ + IC_OPSIZE_ADSIZE, /* 4144 */ + IC_64BIT_OPSIZE_ADSIZE, /* 4145 */ + IC_XS_OPSIZE, /* 4146 */ + IC_64BIT_XS_OPSIZE, /* 4147 */ + IC_XD_OPSIZE, /* 4148 */ + IC_64BIT_XD_OPSIZE, /* 4149 */ + IC_XS_OPSIZE, /* 4150 */ + IC_64BIT_XD_OPSIZE, /* 4151 */ + IC_OPSIZE_ADSIZE, /* 4152 */ + IC_64BIT_REXW_OPSIZE, /* 4153 */ + IC_XS_OPSIZE, /* 4154 */ + IC_64BIT_REXW_XS, /* 4155 */ + IC_XD_OPSIZE, /* 4156 */ + IC_64BIT_REXW_XD, /* 4157 */ + IC_XS_OPSIZE, /* 4158 */ + IC_64BIT_REXW_XS, /* 4159 */ + IC_VEX, /* 4160 */ + IC_VEX, /* 4161 */ + IC_VEX_XS, /* 4162 */ + IC_VEX_XS, /* 4163 */ + IC_VEX_XD, /* 4164 */ + IC_VEX_XD, /* 4165 */ + IC_VEX_XD, /* 4166 */ + IC_VEX_XD, /* 4167 */ + IC_VEX_W, /* 4168 */ + IC_VEX_W, /* 4169 */ + IC_VEX_W_XS, /* 4170 */ + IC_VEX_W_XS, /* 4171 */ + IC_VEX_W_XD, /* 4172 */ + IC_VEX_W_XD, /* 4173 */ + IC_VEX_W_XD, /* 4174 */ + IC_VEX_W_XD, /* 4175 */ + IC_VEX_OPSIZE, /* 4176 */ + IC_VEX_OPSIZE, /* 4177 */ + IC_VEX_OPSIZE, /* 4178 */ + IC_VEX_OPSIZE, /* 4179 */ + IC_VEX_OPSIZE, /* 4180 */ + IC_VEX_OPSIZE, /* 4181 */ + IC_VEX_OPSIZE, /* 4182 */ + IC_VEX_OPSIZE, /* 4183 */ + IC_VEX_W_OPSIZE, /* 4184 */ + IC_VEX_W_OPSIZE, /* 4185 */ + IC_VEX_W_OPSIZE, /* 4186 */ + IC_VEX_W_OPSIZE, /* 4187 */ + IC_VEX_W_OPSIZE, /* 4188 */ + IC_VEX_W_OPSIZE, /* 4189 */ + IC_VEX_W_OPSIZE, /* 4190 */ + IC_VEX_W_OPSIZE, /* 4191 */ + IC_VEX, /* 4192 */ + IC_VEX, /* 4193 */ + IC_VEX_XS, /* 4194 */ + IC_VEX_XS, /* 4195 */ + IC_VEX_XD, /* 4196 */ + IC_VEX_XD, /* 4197 */ + IC_VEX_XD, /* 4198 */ + IC_VEX_XD, /* 4199 */ + IC_VEX_W, /* 4200 */ + IC_VEX_W, /* 4201 */ + IC_VEX_W_XS, /* 4202 */ + IC_VEX_W_XS, /* 4203 */ + IC_VEX_W_XD, /* 4204 */ + IC_VEX_W_XD, /* 4205 */ + IC_VEX_W_XD, /* 4206 */ + IC_VEX_W_XD, /* 4207 */ + IC_VEX_OPSIZE, /* 4208 */ + IC_VEX_OPSIZE, /* 4209 */ + IC_VEX_OPSIZE, /* 4210 */ + IC_VEX_OPSIZE, /* 4211 */ + IC_VEX_OPSIZE, /* 4212 */ + IC_VEX_OPSIZE, /* 4213 */ + IC_VEX_OPSIZE, /* 4214 */ + IC_VEX_OPSIZE, /* 4215 */ + IC_VEX_W_OPSIZE, /* 4216 */ + IC_VEX_W_OPSIZE, /* 4217 */ + IC_VEX_W_OPSIZE, /* 4218 */ + IC_VEX_W_OPSIZE, /* 4219 */ + IC_VEX_W_OPSIZE, /* 4220 */ + IC_VEX_W_OPSIZE, /* 4221 */ + IC_VEX_W_OPSIZE, /* 4222 */ + IC_VEX_W_OPSIZE, /* 4223 */ + IC_VEX_L, /* 4224 */ + IC_VEX_L, /* 4225 */ + IC_VEX_L_XS, /* 4226 */ + IC_VEX_L_XS, /* 4227 */ + IC_VEX_L_XD, /* 4228 */ + IC_VEX_L_XD, /* 4229 */ + IC_VEX_L_XD, /* 4230 */ + IC_VEX_L_XD, /* 4231 */ + IC_VEX_L_W, /* 4232 */ + IC_VEX_L_W, /* 4233 */ + IC_VEX_L_W_XS, /* 4234 */ + IC_VEX_L_W_XS, /* 4235 */ + IC_VEX_L_W_XD, /* 4236 */ + IC_VEX_L_W_XD, /* 4237 */ + IC_VEX_L_W_XD, /* 4238 */ + IC_VEX_L_W_XD, /* 4239 */ + IC_VEX_L_OPSIZE, /* 4240 */ + IC_VEX_L_OPSIZE, /* 4241 */ + IC_VEX_L_OPSIZE, /* 4242 */ + IC_VEX_L_OPSIZE, /* 4243 */ + IC_VEX_L_OPSIZE, /* 4244 */ + IC_VEX_L_OPSIZE, /* 4245 */ + IC_VEX_L_OPSIZE, /* 4246 */ + IC_VEX_L_OPSIZE, /* 4247 */ + IC_VEX_L_W_OPSIZE, /* 4248 */ + IC_VEX_L_W_OPSIZE, /* 4249 */ + IC_VEX_L_W_OPSIZE, /* 4250 */ + IC_VEX_L_W_OPSIZE, /* 4251 */ + IC_VEX_L_W_OPSIZE, /* 4252 */ + IC_VEX_L_W_OPSIZE, /* 4253 */ + IC_VEX_L_W_OPSIZE, /* 4254 */ + IC_VEX_L_W_OPSIZE, /* 4255 */ + IC_VEX_L, /* 4256 */ + IC_VEX_L, /* 4257 */ + IC_VEX_L_XS, /* 4258 */ + IC_VEX_L_XS, /* 4259 */ + IC_VEX_L_XD, /* 4260 */ + IC_VEX_L_XD, /* 4261 */ + IC_VEX_L_XD, /* 4262 */ + IC_VEX_L_XD, /* 4263 */ + IC_VEX_L_W, /* 4264 */ + IC_VEX_L_W, /* 4265 */ + IC_VEX_L_W_XS, /* 4266 */ + IC_VEX_L_W_XS, /* 4267 */ + IC_VEX_L_W_XD, /* 4268 */ + IC_VEX_L_W_XD, /* 4269 */ + IC_VEX_L_W_XD, /* 4270 */ + IC_VEX_L_W_XD, /* 4271 */ + IC_VEX_L_OPSIZE, /* 4272 */ + IC_VEX_L_OPSIZE, /* 4273 */ + IC_VEX_L_OPSIZE, /* 4274 */ + IC_VEX_L_OPSIZE, /* 4275 */ + IC_VEX_L_OPSIZE, /* 4276 */ + IC_VEX_L_OPSIZE, /* 4277 */ + IC_VEX_L_OPSIZE, /* 4278 */ + IC_VEX_L_OPSIZE, /* 4279 */ + IC_VEX_L_W_OPSIZE, /* 4280 */ + IC_VEX_L_W_OPSIZE, /* 4281 */ + IC_VEX_L_W_OPSIZE, /* 4282 */ + IC_VEX_L_W_OPSIZE, /* 4283 */ + IC_VEX_L_W_OPSIZE, /* 4284 */ + IC_VEX_L_W_OPSIZE, /* 4285 */ + IC_VEX_L_W_OPSIZE, /* 4286 */ + IC_VEX_L_W_OPSIZE, /* 4287 */ + IC_VEX_L, /* 4288 */ + IC_VEX_L, /* 4289 */ + IC_VEX_L_XS, /* 4290 */ + IC_VEX_L_XS, /* 4291 */ + IC_VEX_L_XD, /* 4292 */ + IC_VEX_L_XD, /* 4293 */ + IC_VEX_L_XD, /* 4294 */ + IC_VEX_L_XD, /* 4295 */ + IC_VEX_L_W, /* 4296 */ + IC_VEX_L_W, /* 4297 */ + IC_VEX_L_W_XS, /* 4298 */ + IC_VEX_L_W_XS, /* 4299 */ + IC_VEX_L_W_XD, /* 4300 */ + IC_VEX_L_W_XD, /* 4301 */ + IC_VEX_L_W_XD, /* 4302 */ + IC_VEX_L_W_XD, /* 4303 */ + IC_VEX_L_OPSIZE, /* 4304 */ + IC_VEX_L_OPSIZE, /* 4305 */ + IC_VEX_L_OPSIZE, /* 4306 */ + IC_VEX_L_OPSIZE, /* 4307 */ + IC_VEX_L_OPSIZE, /* 4308 */ + IC_VEX_L_OPSIZE, /* 4309 */ + IC_VEX_L_OPSIZE, /* 4310 */ + IC_VEX_L_OPSIZE, /* 4311 */ + IC_VEX_L_W_OPSIZE, /* 4312 */ + IC_VEX_L_W_OPSIZE, /* 4313 */ + IC_VEX_L_W_OPSIZE, /* 4314 */ + IC_VEX_L_W_OPSIZE, /* 4315 */ + IC_VEX_L_W_OPSIZE, /* 4316 */ + IC_VEX_L_W_OPSIZE, /* 4317 */ + IC_VEX_L_W_OPSIZE, /* 4318 */ + IC_VEX_L_W_OPSIZE, /* 4319 */ + IC_VEX_L, /* 4320 */ + IC_VEX_L, /* 4321 */ + IC_VEX_L_XS, /* 4322 */ + IC_VEX_L_XS, /* 4323 */ + IC_VEX_L_XD, /* 4324 */ + IC_VEX_L_XD, /* 4325 */ + IC_VEX_L_XD, /* 4326 */ + IC_VEX_L_XD, /* 4327 */ + IC_VEX_L_W, /* 4328 */ + IC_VEX_L_W, /* 4329 */ + IC_VEX_L_W_XS, /* 4330 */ + IC_VEX_L_W_XS, /* 4331 */ + IC_VEX_L_W_XD, /* 4332 */ + IC_VEX_L_W_XD, /* 4333 */ + IC_VEX_L_W_XD, /* 4334 */ + IC_VEX_L_W_XD, /* 4335 */ + IC_VEX_L_OPSIZE, /* 4336 */ + IC_VEX_L_OPSIZE, /* 4337 */ + IC_VEX_L_OPSIZE, /* 4338 */ + IC_VEX_L_OPSIZE, /* 4339 */ + IC_VEX_L_OPSIZE, /* 4340 */ + IC_VEX_L_OPSIZE, /* 4341 */ + IC_VEX_L_OPSIZE, /* 4342 */ + IC_VEX_L_OPSIZE, /* 4343 */ + IC_VEX_L_W_OPSIZE, /* 4344 */ + IC_VEX_L_W_OPSIZE, /* 4345 */ + IC_VEX_L_W_OPSIZE, /* 4346 */ + IC_VEX_L_W_OPSIZE, /* 4347 */ + IC_VEX_L_W_OPSIZE, /* 4348 */ + IC_VEX_L_W_OPSIZE, /* 4349 */ + IC_VEX_L_W_OPSIZE, /* 4350 */ + IC_VEX_L_W_OPSIZE, /* 4351 */ + IC_EVEX_KZ, /* 4352 */ + IC_EVEX_KZ, /* 4353 */ + IC_EVEX_XS_KZ, /* 4354 */ + IC_EVEX_XS_KZ, /* 4355 */ + IC_EVEX_XD_KZ, /* 4356 */ + IC_EVEX_XD_KZ, /* 4357 */ + IC_EVEX_XD_KZ, /* 4358 */ + IC_EVEX_XD_KZ, /* 4359 */ + IC_EVEX_W_KZ, /* 4360 */ + IC_EVEX_W_KZ, /* 4361 */ + IC_EVEX_W_XS_KZ, /* 4362 */ + IC_EVEX_W_XS_KZ, /* 4363 */ + IC_EVEX_W_XD_KZ, /* 4364 */ + IC_EVEX_W_XD_KZ, /* 4365 */ + IC_EVEX_W_XD_KZ, /* 4366 */ + IC_EVEX_W_XD_KZ, /* 4367 */ + IC_EVEX_OPSIZE_KZ, /* 4368 */ + IC_EVEX_OPSIZE_KZ, /* 4369 */ + IC_EVEX_OPSIZE_KZ, /* 4370 */ + IC_EVEX_OPSIZE_KZ, /* 4371 */ + IC_EVEX_OPSIZE_KZ, /* 4372 */ + IC_EVEX_OPSIZE_KZ, /* 4373 */ + IC_EVEX_OPSIZE_KZ, /* 4374 */ + IC_EVEX_OPSIZE_KZ, /* 4375 */ + IC_EVEX_W_OPSIZE_KZ, /* 4376 */ + IC_EVEX_W_OPSIZE_KZ, /* 4377 */ + IC_EVEX_W_OPSIZE_KZ, /* 4378 */ + IC_EVEX_W_OPSIZE_KZ, /* 4379 */ + IC_EVEX_W_OPSIZE_KZ, /* 4380 */ + IC_EVEX_W_OPSIZE_KZ, /* 4381 */ + IC_EVEX_W_OPSIZE_KZ, /* 4382 */ + IC_EVEX_W_OPSIZE_KZ, /* 4383 */ + IC_EVEX_KZ, /* 4384 */ + IC_EVEX_KZ, /* 4385 */ + IC_EVEX_XS_KZ, /* 4386 */ + IC_EVEX_XS_KZ, /* 4387 */ + IC_EVEX_XD_KZ, /* 4388 */ + IC_EVEX_XD_KZ, /* 4389 */ + IC_EVEX_XD_KZ, /* 4390 */ + IC_EVEX_XD_KZ, /* 4391 */ + IC_EVEX_W_KZ, /* 4392 */ + IC_EVEX_W_KZ, /* 4393 */ + IC_EVEX_W_XS_KZ, /* 4394 */ + IC_EVEX_W_XS_KZ, /* 4395 */ + IC_EVEX_W_XD_KZ, /* 4396 */ + IC_EVEX_W_XD_KZ, /* 4397 */ + IC_EVEX_W_XD_KZ, /* 4398 */ + IC_EVEX_W_XD_KZ, /* 4399 */ + IC_EVEX_OPSIZE_KZ, /* 4400 */ + IC_EVEX_OPSIZE_KZ, /* 4401 */ + IC_EVEX_OPSIZE_KZ, /* 4402 */ + IC_EVEX_OPSIZE_KZ, /* 4403 */ + IC_EVEX_OPSIZE_KZ, /* 4404 */ + IC_EVEX_OPSIZE_KZ, /* 4405 */ + IC_EVEX_OPSIZE_KZ, /* 4406 */ + IC_EVEX_OPSIZE_KZ, /* 4407 */ + IC_EVEX_W_OPSIZE_KZ, /* 4408 */ + IC_EVEX_W_OPSIZE_KZ, /* 4409 */ + IC_EVEX_W_OPSIZE_KZ, /* 4410 */ + IC_EVEX_W_OPSIZE_KZ, /* 4411 */ + IC_EVEX_W_OPSIZE_KZ, /* 4412 */ + IC_EVEX_W_OPSIZE_KZ, /* 4413 */ + IC_EVEX_W_OPSIZE_KZ, /* 4414 */ + IC_EVEX_W_OPSIZE_KZ, /* 4415 */ + IC_EVEX_KZ, /* 4416 */ + IC_EVEX_KZ, /* 4417 */ + IC_EVEX_XS_KZ, /* 4418 */ + IC_EVEX_XS_KZ, /* 4419 */ + IC_EVEX_XD_KZ, /* 4420 */ + IC_EVEX_XD_KZ, /* 4421 */ + IC_EVEX_XD_KZ, /* 4422 */ + IC_EVEX_XD_KZ, /* 4423 */ + IC_EVEX_W_KZ, /* 4424 */ + IC_EVEX_W_KZ, /* 4425 */ + IC_EVEX_W_XS_KZ, /* 4426 */ + IC_EVEX_W_XS_KZ, /* 4427 */ + IC_EVEX_W_XD_KZ, /* 4428 */ + IC_EVEX_W_XD_KZ, /* 4429 */ + IC_EVEX_W_XD_KZ, /* 4430 */ + IC_EVEX_W_XD_KZ, /* 4431 */ + IC_EVEX_OPSIZE_KZ, /* 4432 */ + IC_EVEX_OPSIZE_KZ, /* 4433 */ + IC_EVEX_OPSIZE_KZ, /* 4434 */ + IC_EVEX_OPSIZE_KZ, /* 4435 */ + IC_EVEX_OPSIZE_KZ, /* 4436 */ + IC_EVEX_OPSIZE_KZ, /* 4437 */ + IC_EVEX_OPSIZE_KZ, /* 4438 */ + IC_EVEX_OPSIZE_KZ, /* 4439 */ + IC_EVEX_W_OPSIZE_KZ, /* 4440 */ + IC_EVEX_W_OPSIZE_KZ, /* 4441 */ + IC_EVEX_W_OPSIZE_KZ, /* 4442 */ + IC_EVEX_W_OPSIZE_KZ, /* 4443 */ + IC_EVEX_W_OPSIZE_KZ, /* 4444 */ + IC_EVEX_W_OPSIZE_KZ, /* 4445 */ + IC_EVEX_W_OPSIZE_KZ, /* 4446 */ + IC_EVEX_W_OPSIZE_KZ, /* 4447 */ + IC_EVEX_KZ, /* 4448 */ + IC_EVEX_KZ, /* 4449 */ + IC_EVEX_XS_KZ, /* 4450 */ + IC_EVEX_XS_KZ, /* 4451 */ + IC_EVEX_XD_KZ, /* 4452 */ + IC_EVEX_XD_KZ, /* 4453 */ + IC_EVEX_XD_KZ, /* 4454 */ + IC_EVEX_XD_KZ, /* 4455 */ + IC_EVEX_W_KZ, /* 4456 */ + IC_EVEX_W_KZ, /* 4457 */ + IC_EVEX_W_XS_KZ, /* 4458 */ + IC_EVEX_W_XS_KZ, /* 4459 */ + IC_EVEX_W_XD_KZ, /* 4460 */ + IC_EVEX_W_XD_KZ, /* 4461 */ + IC_EVEX_W_XD_KZ, /* 4462 */ + IC_EVEX_W_XD_KZ, /* 4463 */ + IC_EVEX_OPSIZE_KZ, /* 4464 */ + IC_EVEX_OPSIZE_KZ, /* 4465 */ + IC_EVEX_OPSIZE_KZ, /* 4466 */ + IC_EVEX_OPSIZE_KZ, /* 4467 */ + IC_EVEX_OPSIZE_KZ, /* 4468 */ + IC_EVEX_OPSIZE_KZ, /* 4469 */ + IC_EVEX_OPSIZE_KZ, /* 4470 */ + IC_EVEX_OPSIZE_KZ, /* 4471 */ + IC_EVEX_W_OPSIZE_KZ, /* 4472 */ + IC_EVEX_W_OPSIZE_KZ, /* 4473 */ + IC_EVEX_W_OPSIZE_KZ, /* 4474 */ + IC_EVEX_W_OPSIZE_KZ, /* 4475 */ + IC_EVEX_W_OPSIZE_KZ, /* 4476 */ + IC_EVEX_W_OPSIZE_KZ, /* 4477 */ + IC_EVEX_W_OPSIZE_KZ, /* 4478 */ + IC_EVEX_W_OPSIZE_KZ, /* 4479 */ + IC_EVEX_KZ, /* 4480 */ + IC_EVEX_KZ, /* 4481 */ + IC_EVEX_XS_KZ, /* 4482 */ + IC_EVEX_XS_KZ, /* 4483 */ + IC_EVEX_XD_KZ, /* 4484 */ + IC_EVEX_XD_KZ, /* 4485 */ + IC_EVEX_XD_KZ, /* 4486 */ + IC_EVEX_XD_KZ, /* 4487 */ + IC_EVEX_W_KZ, /* 4488 */ + IC_EVEX_W_KZ, /* 4489 */ + IC_EVEX_W_XS_KZ, /* 4490 */ + IC_EVEX_W_XS_KZ, /* 4491 */ + IC_EVEX_W_XD_KZ, /* 4492 */ + IC_EVEX_W_XD_KZ, /* 4493 */ + IC_EVEX_W_XD_KZ, /* 4494 */ + IC_EVEX_W_XD_KZ, /* 4495 */ + IC_EVEX_OPSIZE_KZ, /* 4496 */ + IC_EVEX_OPSIZE_KZ, /* 4497 */ + IC_EVEX_OPSIZE_KZ, /* 4498 */ + IC_EVEX_OPSIZE_KZ, /* 4499 */ + IC_EVEX_OPSIZE_KZ, /* 4500 */ + IC_EVEX_OPSIZE_KZ, /* 4501 */ + IC_EVEX_OPSIZE_KZ, /* 4502 */ + IC_EVEX_OPSIZE_KZ, /* 4503 */ + IC_EVEX_W_OPSIZE_KZ, /* 4504 */ + IC_EVEX_W_OPSIZE_KZ, /* 4505 */ + IC_EVEX_W_OPSIZE_KZ, /* 4506 */ + IC_EVEX_W_OPSIZE_KZ, /* 4507 */ + IC_EVEX_W_OPSIZE_KZ, /* 4508 */ + IC_EVEX_W_OPSIZE_KZ, /* 4509 */ + IC_EVEX_W_OPSIZE_KZ, /* 4510 */ + IC_EVEX_W_OPSIZE_KZ, /* 4511 */ + IC_EVEX_KZ, /* 4512 */ + IC_EVEX_KZ, /* 4513 */ + IC_EVEX_XS_KZ, /* 4514 */ + IC_EVEX_XS_KZ, /* 4515 */ + IC_EVEX_XD_KZ, /* 4516 */ + IC_EVEX_XD_KZ, /* 4517 */ + IC_EVEX_XD_KZ, /* 4518 */ + IC_EVEX_XD_KZ, /* 4519 */ + IC_EVEX_W_KZ, /* 4520 */ + IC_EVEX_W_KZ, /* 4521 */ + IC_EVEX_W_XS_KZ, /* 4522 */ + IC_EVEX_W_XS_KZ, /* 4523 */ + IC_EVEX_W_XD_KZ, /* 4524 */ + IC_EVEX_W_XD_KZ, /* 4525 */ + IC_EVEX_W_XD_KZ, /* 4526 */ + IC_EVEX_W_XD_KZ, /* 4527 */ + IC_EVEX_OPSIZE_KZ, /* 4528 */ + IC_EVEX_OPSIZE_KZ, /* 4529 */ + IC_EVEX_OPSIZE_KZ, /* 4530 */ + IC_EVEX_OPSIZE_KZ, /* 4531 */ + IC_EVEX_OPSIZE_KZ, /* 4532 */ + IC_EVEX_OPSIZE_KZ, /* 4533 */ + IC_EVEX_OPSIZE_KZ, /* 4534 */ + IC_EVEX_OPSIZE_KZ, /* 4535 */ + IC_EVEX_W_OPSIZE_KZ, /* 4536 */ + IC_EVEX_W_OPSIZE_KZ, /* 4537 */ + IC_EVEX_W_OPSIZE_KZ, /* 4538 */ + IC_EVEX_W_OPSIZE_KZ, /* 4539 */ + IC_EVEX_W_OPSIZE_KZ, /* 4540 */ + IC_EVEX_W_OPSIZE_KZ, /* 4541 */ + IC_EVEX_W_OPSIZE_KZ, /* 4542 */ + IC_EVEX_W_OPSIZE_KZ, /* 4543 */ + IC_EVEX_KZ, /* 4544 */ + IC_EVEX_KZ, /* 4545 */ + IC_EVEX_XS_KZ, /* 4546 */ + IC_EVEX_XS_KZ, /* 4547 */ + IC_EVEX_XD_KZ, /* 4548 */ + IC_EVEX_XD_KZ, /* 4549 */ + IC_EVEX_XD_KZ, /* 4550 */ + IC_EVEX_XD_KZ, /* 4551 */ + IC_EVEX_W_KZ, /* 4552 */ + IC_EVEX_W_KZ, /* 4553 */ + IC_EVEX_W_XS_KZ, /* 4554 */ + IC_EVEX_W_XS_KZ, /* 4555 */ + IC_EVEX_W_XD_KZ, /* 4556 */ + IC_EVEX_W_XD_KZ, /* 4557 */ + IC_EVEX_W_XD_KZ, /* 4558 */ + IC_EVEX_W_XD_KZ, /* 4559 */ + IC_EVEX_OPSIZE_KZ, /* 4560 */ + IC_EVEX_OPSIZE_KZ, /* 4561 */ + IC_EVEX_OPSIZE_KZ, /* 4562 */ + IC_EVEX_OPSIZE_KZ, /* 4563 */ + IC_EVEX_OPSIZE_KZ, /* 4564 */ + IC_EVEX_OPSIZE_KZ, /* 4565 */ + IC_EVEX_OPSIZE_KZ, /* 4566 */ + IC_EVEX_OPSIZE_KZ, /* 4567 */ + IC_EVEX_W_OPSIZE_KZ, /* 4568 */ + IC_EVEX_W_OPSIZE_KZ, /* 4569 */ + IC_EVEX_W_OPSIZE_KZ, /* 4570 */ + IC_EVEX_W_OPSIZE_KZ, /* 4571 */ + IC_EVEX_W_OPSIZE_KZ, /* 4572 */ + IC_EVEX_W_OPSIZE_KZ, /* 4573 */ + IC_EVEX_W_OPSIZE_KZ, /* 4574 */ + IC_EVEX_W_OPSIZE_KZ, /* 4575 */ + IC_EVEX_KZ, /* 4576 */ + IC_EVEX_KZ, /* 4577 */ + IC_EVEX_XS_KZ, /* 4578 */ + IC_EVEX_XS_KZ, /* 4579 */ + IC_EVEX_XD_KZ, /* 4580 */ + IC_EVEX_XD_KZ, /* 4581 */ + IC_EVEX_XD_KZ, /* 4582 */ + IC_EVEX_XD_KZ, /* 4583 */ + IC_EVEX_W_KZ, /* 4584 */ + IC_EVEX_W_KZ, /* 4585 */ + IC_EVEX_W_XS_KZ, /* 4586 */ + IC_EVEX_W_XS_KZ, /* 4587 */ + IC_EVEX_W_XD_KZ, /* 4588 */ + IC_EVEX_W_XD_KZ, /* 4589 */ + IC_EVEX_W_XD_KZ, /* 4590 */ + IC_EVEX_W_XD_KZ, /* 4591 */ + IC_EVEX_OPSIZE_KZ, /* 4592 */ + IC_EVEX_OPSIZE_KZ, /* 4593 */ + IC_EVEX_OPSIZE_KZ, /* 4594 */ + IC_EVEX_OPSIZE_KZ, /* 4595 */ + IC_EVEX_OPSIZE_KZ, /* 4596 */ + IC_EVEX_OPSIZE_KZ, /* 4597 */ + IC_EVEX_OPSIZE_KZ, /* 4598 */ + IC_EVEX_OPSIZE_KZ, /* 4599 */ + IC_EVEX_W_OPSIZE_KZ, /* 4600 */ + IC_EVEX_W_OPSIZE_KZ, /* 4601 */ + IC_EVEX_W_OPSIZE_KZ, /* 4602 */ + IC_EVEX_W_OPSIZE_KZ, /* 4603 */ + IC_EVEX_W_OPSIZE_KZ, /* 4604 */ + IC_EVEX_W_OPSIZE_KZ, /* 4605 */ + IC_EVEX_W_OPSIZE_KZ, /* 4606 */ + IC_EVEX_W_OPSIZE_KZ, /* 4607 */ + IC, /* 4608 */ + IC_64BIT, /* 4609 */ + IC_XS, /* 4610 */ + IC_64BIT_XS, /* 4611 */ + IC_XD, /* 4612 */ + IC_64BIT_XD, /* 4613 */ + IC_XS, /* 4614 */ + IC_64BIT_XS, /* 4615 */ + IC, /* 4616 */ + IC_64BIT_REXW, /* 4617 */ + IC_XS, /* 4618 */ + IC_64BIT_REXW_XS, /* 4619 */ + IC_XD, /* 4620 */ + IC_64BIT_REXW_XD, /* 4621 */ + IC_XS, /* 4622 */ + IC_64BIT_REXW_XS, /* 4623 */ + IC_OPSIZE, /* 4624 */ + IC_64BIT_OPSIZE, /* 4625 */ + IC_XS_OPSIZE, /* 4626 */ + IC_64BIT_XS_OPSIZE, /* 4627 */ + IC_XD_OPSIZE, /* 4628 */ + IC_64BIT_XD_OPSIZE, /* 4629 */ + IC_XS_OPSIZE, /* 4630 */ + IC_64BIT_XD_OPSIZE, /* 4631 */ + IC_OPSIZE, /* 4632 */ + IC_64BIT_REXW_OPSIZE, /* 4633 */ + IC_XS_OPSIZE, /* 4634 */ + IC_64BIT_REXW_XS, /* 4635 */ + IC_XD_OPSIZE, /* 4636 */ + IC_64BIT_REXW_XD, /* 4637 */ + IC_XS_OPSIZE, /* 4638 */ + IC_64BIT_REXW_XS, /* 4639 */ + IC_ADSIZE, /* 4640 */ + IC_64BIT_ADSIZE, /* 4641 */ + IC_XS_ADSIZE, /* 4642 */ + IC_64BIT_XS_ADSIZE, /* 4643 */ + IC_XD_ADSIZE, /* 4644 */ + IC_64BIT_XD_ADSIZE, /* 4645 */ + IC_XS_ADSIZE, /* 4646 */ + IC_64BIT_XD_ADSIZE, /* 4647 */ + IC_ADSIZE, /* 4648 */ + IC_64BIT_REXW_ADSIZE, /* 4649 */ + IC_XS_ADSIZE, /* 4650 */ + IC_64BIT_REXW_XS, /* 4651 */ + IC_XD_ADSIZE, /* 4652 */ + IC_64BIT_REXW_XD, /* 4653 */ + IC_XS_ADSIZE, /* 4654 */ + IC_64BIT_REXW_XS, /* 4655 */ + IC_OPSIZE_ADSIZE, /* 4656 */ + IC_64BIT_OPSIZE_ADSIZE, /* 4657 */ + IC_XS_OPSIZE, /* 4658 */ + IC_64BIT_XS_OPSIZE, /* 4659 */ + IC_XD_OPSIZE, /* 4660 */ + IC_64BIT_XD_OPSIZE, /* 4661 */ + IC_XS_OPSIZE, /* 4662 */ + IC_64BIT_XD_OPSIZE, /* 4663 */ + IC_OPSIZE_ADSIZE, /* 4664 */ + IC_64BIT_REXW_OPSIZE, /* 4665 */ + IC_XS_OPSIZE, /* 4666 */ + IC_64BIT_REXW_XS, /* 4667 */ + IC_XD_OPSIZE, /* 4668 */ + IC_64BIT_REXW_XD, /* 4669 */ + IC_XS_OPSIZE, /* 4670 */ + IC_64BIT_REXW_XS, /* 4671 */ + IC_VEX, /* 4672 */ + IC_VEX, /* 4673 */ + IC_VEX_XS, /* 4674 */ + IC_VEX_XS, /* 4675 */ + IC_VEX_XD, /* 4676 */ + IC_VEX_XD, /* 4677 */ + IC_VEX_XD, /* 4678 */ + IC_VEX_XD, /* 4679 */ + IC_VEX_W, /* 4680 */ + IC_VEX_W, /* 4681 */ + IC_VEX_W_XS, /* 4682 */ + IC_VEX_W_XS, /* 4683 */ + IC_VEX_W_XD, /* 4684 */ + IC_VEX_W_XD, /* 4685 */ + IC_VEX_W_XD, /* 4686 */ + IC_VEX_W_XD, /* 4687 */ + IC_VEX_OPSIZE, /* 4688 */ + IC_VEX_OPSIZE, /* 4689 */ + IC_VEX_OPSIZE, /* 4690 */ + IC_VEX_OPSIZE, /* 4691 */ + IC_VEX_OPSIZE, /* 4692 */ + IC_VEX_OPSIZE, /* 4693 */ + IC_VEX_OPSIZE, /* 4694 */ + IC_VEX_OPSIZE, /* 4695 */ + IC_VEX_W_OPSIZE, /* 4696 */ + IC_VEX_W_OPSIZE, /* 4697 */ + IC_VEX_W_OPSIZE, /* 4698 */ + IC_VEX_W_OPSIZE, /* 4699 */ + IC_VEX_W_OPSIZE, /* 4700 */ + IC_VEX_W_OPSIZE, /* 4701 */ + IC_VEX_W_OPSIZE, /* 4702 */ + IC_VEX_W_OPSIZE, /* 4703 */ + IC_VEX, /* 4704 */ + IC_VEX, /* 4705 */ + IC_VEX_XS, /* 4706 */ + IC_VEX_XS, /* 4707 */ + IC_VEX_XD, /* 4708 */ + IC_VEX_XD, /* 4709 */ + IC_VEX_XD, /* 4710 */ + IC_VEX_XD, /* 4711 */ + IC_VEX_W, /* 4712 */ + IC_VEX_W, /* 4713 */ + IC_VEX_W_XS, /* 4714 */ + IC_VEX_W_XS, /* 4715 */ + IC_VEX_W_XD, /* 4716 */ + IC_VEX_W_XD, /* 4717 */ + IC_VEX_W_XD, /* 4718 */ + IC_VEX_W_XD, /* 4719 */ + IC_VEX_OPSIZE, /* 4720 */ + IC_VEX_OPSIZE, /* 4721 */ + IC_VEX_OPSIZE, /* 4722 */ + IC_VEX_OPSIZE, /* 4723 */ + IC_VEX_OPSIZE, /* 4724 */ + IC_VEX_OPSIZE, /* 4725 */ + IC_VEX_OPSIZE, /* 4726 */ + IC_VEX_OPSIZE, /* 4727 */ + IC_VEX_W_OPSIZE, /* 4728 */ + IC_VEX_W_OPSIZE, /* 4729 */ + IC_VEX_W_OPSIZE, /* 4730 */ + IC_VEX_W_OPSIZE, /* 4731 */ + IC_VEX_W_OPSIZE, /* 4732 */ + IC_VEX_W_OPSIZE, /* 4733 */ + IC_VEX_W_OPSIZE, /* 4734 */ + IC_VEX_W_OPSIZE, /* 4735 */ + IC_VEX_L, /* 4736 */ + IC_VEX_L, /* 4737 */ + IC_VEX_L_XS, /* 4738 */ + IC_VEX_L_XS, /* 4739 */ + IC_VEX_L_XD, /* 4740 */ + IC_VEX_L_XD, /* 4741 */ + IC_VEX_L_XD, /* 4742 */ + IC_VEX_L_XD, /* 4743 */ + IC_VEX_L_W, /* 4744 */ + IC_VEX_L_W, /* 4745 */ + IC_VEX_L_W_XS, /* 4746 */ + IC_VEX_L_W_XS, /* 4747 */ + IC_VEX_L_W_XD, /* 4748 */ + IC_VEX_L_W_XD, /* 4749 */ + IC_VEX_L_W_XD, /* 4750 */ + IC_VEX_L_W_XD, /* 4751 */ + IC_VEX_L_OPSIZE, /* 4752 */ + IC_VEX_L_OPSIZE, /* 4753 */ + IC_VEX_L_OPSIZE, /* 4754 */ + IC_VEX_L_OPSIZE, /* 4755 */ + IC_VEX_L_OPSIZE, /* 4756 */ + IC_VEX_L_OPSIZE, /* 4757 */ + IC_VEX_L_OPSIZE, /* 4758 */ + IC_VEX_L_OPSIZE, /* 4759 */ + IC_VEX_L_W_OPSIZE, /* 4760 */ + IC_VEX_L_W_OPSIZE, /* 4761 */ + IC_VEX_L_W_OPSIZE, /* 4762 */ + IC_VEX_L_W_OPSIZE, /* 4763 */ + IC_VEX_L_W_OPSIZE, /* 4764 */ + IC_VEX_L_W_OPSIZE, /* 4765 */ + IC_VEX_L_W_OPSIZE, /* 4766 */ + IC_VEX_L_W_OPSIZE, /* 4767 */ + IC_VEX_L, /* 4768 */ + IC_VEX_L, /* 4769 */ + IC_VEX_L_XS, /* 4770 */ + IC_VEX_L_XS, /* 4771 */ + IC_VEX_L_XD, /* 4772 */ + IC_VEX_L_XD, /* 4773 */ + IC_VEX_L_XD, /* 4774 */ + IC_VEX_L_XD, /* 4775 */ + IC_VEX_L_W, /* 4776 */ + IC_VEX_L_W, /* 4777 */ + IC_VEX_L_W_XS, /* 4778 */ + IC_VEX_L_W_XS, /* 4779 */ + IC_VEX_L_W_XD, /* 4780 */ + IC_VEX_L_W_XD, /* 4781 */ + IC_VEX_L_W_XD, /* 4782 */ + IC_VEX_L_W_XD, /* 4783 */ + IC_VEX_L_OPSIZE, /* 4784 */ + IC_VEX_L_OPSIZE, /* 4785 */ + IC_VEX_L_OPSIZE, /* 4786 */ + IC_VEX_L_OPSIZE, /* 4787 */ + IC_VEX_L_OPSIZE, /* 4788 */ + IC_VEX_L_OPSIZE, /* 4789 */ + IC_VEX_L_OPSIZE, /* 4790 */ + IC_VEX_L_OPSIZE, /* 4791 */ + IC_VEX_L_W_OPSIZE, /* 4792 */ + IC_VEX_L_W_OPSIZE, /* 4793 */ + IC_VEX_L_W_OPSIZE, /* 4794 */ + IC_VEX_L_W_OPSIZE, /* 4795 */ + IC_VEX_L_W_OPSIZE, /* 4796 */ + IC_VEX_L_W_OPSIZE, /* 4797 */ + IC_VEX_L_W_OPSIZE, /* 4798 */ + IC_VEX_L_W_OPSIZE, /* 4799 */ + IC_VEX_L, /* 4800 */ + IC_VEX_L, /* 4801 */ + IC_VEX_L_XS, /* 4802 */ + IC_VEX_L_XS, /* 4803 */ + IC_VEX_L_XD, /* 4804 */ + IC_VEX_L_XD, /* 4805 */ + IC_VEX_L_XD, /* 4806 */ + IC_VEX_L_XD, /* 4807 */ + IC_VEX_L_W, /* 4808 */ + IC_VEX_L_W, /* 4809 */ + IC_VEX_L_W_XS, /* 4810 */ + IC_VEX_L_W_XS, /* 4811 */ + IC_VEX_L_W_XD, /* 4812 */ + IC_VEX_L_W_XD, /* 4813 */ + IC_VEX_L_W_XD, /* 4814 */ + IC_VEX_L_W_XD, /* 4815 */ + IC_VEX_L_OPSIZE, /* 4816 */ + IC_VEX_L_OPSIZE, /* 4817 */ + IC_VEX_L_OPSIZE, /* 4818 */ + IC_VEX_L_OPSIZE, /* 4819 */ + IC_VEX_L_OPSIZE, /* 4820 */ + IC_VEX_L_OPSIZE, /* 4821 */ + IC_VEX_L_OPSIZE, /* 4822 */ + IC_VEX_L_OPSIZE, /* 4823 */ + IC_VEX_L_W_OPSIZE, /* 4824 */ + IC_VEX_L_W_OPSIZE, /* 4825 */ + IC_VEX_L_W_OPSIZE, /* 4826 */ + IC_VEX_L_W_OPSIZE, /* 4827 */ + IC_VEX_L_W_OPSIZE, /* 4828 */ + IC_VEX_L_W_OPSIZE, /* 4829 */ + IC_VEX_L_W_OPSIZE, /* 4830 */ + IC_VEX_L_W_OPSIZE, /* 4831 */ + IC_VEX_L, /* 4832 */ + IC_VEX_L, /* 4833 */ + IC_VEX_L_XS, /* 4834 */ + IC_VEX_L_XS, /* 4835 */ + IC_VEX_L_XD, /* 4836 */ + IC_VEX_L_XD, /* 4837 */ + IC_VEX_L_XD, /* 4838 */ + IC_VEX_L_XD, /* 4839 */ + IC_VEX_L_W, /* 4840 */ + IC_VEX_L_W, /* 4841 */ + IC_VEX_L_W_XS, /* 4842 */ + IC_VEX_L_W_XS, /* 4843 */ + IC_VEX_L_W_XD, /* 4844 */ + IC_VEX_L_W_XD, /* 4845 */ + IC_VEX_L_W_XD, /* 4846 */ + IC_VEX_L_W_XD, /* 4847 */ + IC_VEX_L_OPSIZE, /* 4848 */ + IC_VEX_L_OPSIZE, /* 4849 */ + IC_VEX_L_OPSIZE, /* 4850 */ + IC_VEX_L_OPSIZE, /* 4851 */ + IC_VEX_L_OPSIZE, /* 4852 */ + IC_VEX_L_OPSIZE, /* 4853 */ + IC_VEX_L_OPSIZE, /* 4854 */ + IC_VEX_L_OPSIZE, /* 4855 */ + IC_VEX_L_W_OPSIZE, /* 4856 */ + IC_VEX_L_W_OPSIZE, /* 4857 */ + IC_VEX_L_W_OPSIZE, /* 4858 */ + IC_VEX_L_W_OPSIZE, /* 4859 */ + IC_VEX_L_W_OPSIZE, /* 4860 */ + IC_VEX_L_W_OPSIZE, /* 4861 */ + IC_VEX_L_W_OPSIZE, /* 4862 */ + IC_VEX_L_W_OPSIZE, /* 4863 */ + IC_EVEX_L_KZ, /* 4864 */ + IC_EVEX_L_KZ, /* 4865 */ + IC_EVEX_L_XS_KZ, /* 4866 */ + IC_EVEX_L_XS_KZ, /* 4867 */ + IC_EVEX_L_XD_KZ, /* 4868 */ + IC_EVEX_L_XD_KZ, /* 4869 */ + IC_EVEX_L_XD_KZ, /* 4870 */ + IC_EVEX_L_XD_KZ, /* 4871 */ + IC_EVEX_L_W_KZ, /* 4872 */ + IC_EVEX_L_W_KZ, /* 4873 */ + IC_EVEX_L_W_XS_KZ, /* 4874 */ + IC_EVEX_L_W_XS_KZ, /* 4875 */ + IC_EVEX_L_W_XD_KZ, /* 4876 */ + IC_EVEX_L_W_XD_KZ, /* 4877 */ + IC_EVEX_L_W_XD_KZ, /* 4878 */ + IC_EVEX_L_W_XD_KZ, /* 4879 */ + IC_EVEX_L_OPSIZE_KZ, /* 4880 */ + IC_EVEX_L_OPSIZE_KZ, /* 4881 */ + IC_EVEX_L_OPSIZE_KZ, /* 4882 */ + IC_EVEX_L_OPSIZE_KZ, /* 4883 */ + IC_EVEX_L_OPSIZE_KZ, /* 4884 */ + IC_EVEX_L_OPSIZE_KZ, /* 4885 */ + IC_EVEX_L_OPSIZE_KZ, /* 4886 */ + IC_EVEX_L_OPSIZE_KZ, /* 4887 */ + IC_EVEX_L_W_OPSIZE_KZ, /* 4888 */ + IC_EVEX_L_W_OPSIZE_KZ, /* 4889 */ + IC_EVEX_L_W_OPSIZE_KZ, /* 4890 */ + IC_EVEX_L_W_OPSIZE_KZ, /* 4891 */ + IC_EVEX_L_W_OPSIZE_KZ, /* 4892 */ + IC_EVEX_L_W_OPSIZE_KZ, /* 4893 */ + IC_EVEX_L_W_OPSIZE_KZ, /* 4894 */ + IC_EVEX_L_W_OPSIZE_KZ, /* 4895 */ + IC_EVEX_L_KZ, /* 4896 */ + IC_EVEX_L_KZ, /* 4897 */ + IC_EVEX_L_XS_KZ, /* 4898 */ + IC_EVEX_L_XS_KZ, /* 4899 */ + IC_EVEX_L_XD_KZ, /* 4900 */ + IC_EVEX_L_XD_KZ, /* 4901 */ + IC_EVEX_L_XD_KZ, /* 4902 */ + IC_EVEX_L_XD_KZ, /* 4903 */ + IC_EVEX_L_W_KZ, /* 4904 */ + IC_EVEX_L_W_KZ, /* 4905 */ + IC_EVEX_L_W_XS_KZ, /* 4906 */ + IC_EVEX_L_W_XS_KZ, /* 4907 */ + IC_EVEX_L_W_XD_KZ, /* 4908 */ + IC_EVEX_L_W_XD_KZ, /* 4909 */ + IC_EVEX_L_W_XD_KZ, /* 4910 */ + IC_EVEX_L_W_XD_KZ, /* 4911 */ + IC_EVEX_L_OPSIZE_KZ, /* 4912 */ + IC_EVEX_L_OPSIZE_KZ, /* 4913 */ + IC_EVEX_L_OPSIZE_KZ, /* 4914 */ + IC_EVEX_L_OPSIZE_KZ, /* 4915 */ + IC_EVEX_L_OPSIZE_KZ, /* 4916 */ + IC_EVEX_L_OPSIZE_KZ, /* 4917 */ + IC_EVEX_L_OPSIZE_KZ, /* 4918 */ + IC_EVEX_L_OPSIZE_KZ, /* 4919 */ + IC_EVEX_L_W_OPSIZE_KZ, /* 4920 */ + IC_EVEX_L_W_OPSIZE_KZ, /* 4921 */ + IC_EVEX_L_W_OPSIZE_KZ, /* 4922 */ + IC_EVEX_L_W_OPSIZE_KZ, /* 4923 */ + IC_EVEX_L_W_OPSIZE_KZ, /* 4924 */ + IC_EVEX_L_W_OPSIZE_KZ, /* 4925 */ + IC_EVEX_L_W_OPSIZE_KZ, /* 4926 */ + IC_EVEX_L_W_OPSIZE_KZ, /* 4927 */ + IC_EVEX_L_KZ, /* 4928 */ + IC_EVEX_L_KZ, /* 4929 */ + IC_EVEX_L_XS_KZ, /* 4930 */ + IC_EVEX_L_XS_KZ, /* 4931 */ + IC_EVEX_L_XD_KZ, /* 4932 */ + IC_EVEX_L_XD_KZ, /* 4933 */ + IC_EVEX_L_XD_KZ, /* 4934 */ + IC_EVEX_L_XD_KZ, /* 4935 */ + IC_EVEX_L_W_KZ, /* 4936 */ + IC_EVEX_L_W_KZ, /* 4937 */ + IC_EVEX_L_W_XS_KZ, /* 4938 */ + IC_EVEX_L_W_XS_KZ, /* 4939 */ + IC_EVEX_L_W_XD_KZ, /* 4940 */ + IC_EVEX_L_W_XD_KZ, /* 4941 */ + IC_EVEX_L_W_XD_KZ, /* 4942 */ + IC_EVEX_L_W_XD_KZ, /* 4943 */ + IC_EVEX_L_OPSIZE_KZ, /* 4944 */ + IC_EVEX_L_OPSIZE_KZ, /* 4945 */ + IC_EVEX_L_OPSIZE_KZ, /* 4946 */ + IC_EVEX_L_OPSIZE_KZ, /* 4947 */ + IC_EVEX_L_OPSIZE_KZ, /* 4948 */ + IC_EVEX_L_OPSIZE_KZ, /* 4949 */ + IC_EVEX_L_OPSIZE_KZ, /* 4950 */ + IC_EVEX_L_OPSIZE_KZ, /* 4951 */ + IC_EVEX_L_W_OPSIZE_KZ, /* 4952 */ + IC_EVEX_L_W_OPSIZE_KZ, /* 4953 */ + IC_EVEX_L_W_OPSIZE_KZ, /* 4954 */ + IC_EVEX_L_W_OPSIZE_KZ, /* 4955 */ + IC_EVEX_L_W_OPSIZE_KZ, /* 4956 */ + IC_EVEX_L_W_OPSIZE_KZ, /* 4957 */ + IC_EVEX_L_W_OPSIZE_KZ, /* 4958 */ + IC_EVEX_L_W_OPSIZE_KZ, /* 4959 */ + IC_EVEX_L_KZ, /* 4960 */ + IC_EVEX_L_KZ, /* 4961 */ + IC_EVEX_L_XS_KZ, /* 4962 */ + IC_EVEX_L_XS_KZ, /* 4963 */ + IC_EVEX_L_XD_KZ, /* 4964 */ + IC_EVEX_L_XD_KZ, /* 4965 */ + IC_EVEX_L_XD_KZ, /* 4966 */ + IC_EVEX_L_XD_KZ, /* 4967 */ + IC_EVEX_L_W_KZ, /* 4968 */ + IC_EVEX_L_W_KZ, /* 4969 */ + IC_EVEX_L_W_XS_KZ, /* 4970 */ + IC_EVEX_L_W_XS_KZ, /* 4971 */ + IC_EVEX_L_W_XD_KZ, /* 4972 */ + IC_EVEX_L_W_XD_KZ, /* 4973 */ + IC_EVEX_L_W_XD_KZ, /* 4974 */ + IC_EVEX_L_W_XD_KZ, /* 4975 */ + IC_EVEX_L_OPSIZE_KZ, /* 4976 */ + IC_EVEX_L_OPSIZE_KZ, /* 4977 */ + IC_EVEX_L_OPSIZE_KZ, /* 4978 */ + IC_EVEX_L_OPSIZE_KZ, /* 4979 */ + IC_EVEX_L_OPSIZE_KZ, /* 4980 */ + IC_EVEX_L_OPSIZE_KZ, /* 4981 */ + IC_EVEX_L_OPSIZE_KZ, /* 4982 */ + IC_EVEX_L_OPSIZE_KZ, /* 4983 */ + IC_EVEX_L_W_OPSIZE_KZ, /* 4984 */ + IC_EVEX_L_W_OPSIZE_KZ, /* 4985 */ + IC_EVEX_L_W_OPSIZE_KZ, /* 4986 */ + IC_EVEX_L_W_OPSIZE_KZ, /* 4987 */ + IC_EVEX_L_W_OPSIZE_KZ, /* 4988 */ + IC_EVEX_L_W_OPSIZE_KZ, /* 4989 */ + IC_EVEX_L_W_OPSIZE_KZ, /* 4990 */ + IC_EVEX_L_W_OPSIZE_KZ, /* 4991 */ + IC_EVEX_L_KZ, /* 4992 */ + IC_EVEX_L_KZ, /* 4993 */ + IC_EVEX_L_XS_KZ, /* 4994 */ + IC_EVEX_L_XS_KZ, /* 4995 */ + IC_EVEX_L_XD_KZ, /* 4996 */ + IC_EVEX_L_XD_KZ, /* 4997 */ + IC_EVEX_L_XD_KZ, /* 4998 */ + IC_EVEX_L_XD_KZ, /* 4999 */ + IC_EVEX_L_W_KZ, /* 5000 */ + IC_EVEX_L_W_KZ, /* 5001 */ + IC_EVEX_L_W_XS_KZ, /* 5002 */ + IC_EVEX_L_W_XS_KZ, /* 5003 */ + IC_EVEX_L_W_XD_KZ, /* 5004 */ + IC_EVEX_L_W_XD_KZ, /* 5005 */ + IC_EVEX_L_W_XD_KZ, /* 5006 */ + IC_EVEX_L_W_XD_KZ, /* 5007 */ + IC_EVEX_L_OPSIZE_KZ, /* 5008 */ + IC_EVEX_L_OPSIZE_KZ, /* 5009 */ + IC_EVEX_L_OPSIZE_KZ, /* 5010 */ + IC_EVEX_L_OPSIZE_KZ, /* 5011 */ + IC_EVEX_L_OPSIZE_KZ, /* 5012 */ + IC_EVEX_L_OPSIZE_KZ, /* 5013 */ + IC_EVEX_L_OPSIZE_KZ, /* 5014 */ + IC_EVEX_L_OPSIZE_KZ, /* 5015 */ + IC_EVEX_L_W_OPSIZE_KZ, /* 5016 */ + IC_EVEX_L_W_OPSIZE_KZ, /* 5017 */ + IC_EVEX_L_W_OPSIZE_KZ, /* 5018 */ + IC_EVEX_L_W_OPSIZE_KZ, /* 5019 */ + IC_EVEX_L_W_OPSIZE_KZ, /* 5020 */ + IC_EVEX_L_W_OPSIZE_KZ, /* 5021 */ + IC_EVEX_L_W_OPSIZE_KZ, /* 5022 */ + IC_EVEX_L_W_OPSIZE_KZ, /* 5023 */ + IC_EVEX_L_KZ, /* 5024 */ + IC_EVEX_L_KZ, /* 5025 */ + IC_EVEX_L_XS_KZ, /* 5026 */ + IC_EVEX_L_XS_KZ, /* 5027 */ + IC_EVEX_L_XD_KZ, /* 5028 */ + IC_EVEX_L_XD_KZ, /* 5029 */ + IC_EVEX_L_XD_KZ, /* 5030 */ + IC_EVEX_L_XD_KZ, /* 5031 */ + IC_EVEX_L_W_KZ, /* 5032 */ + IC_EVEX_L_W_KZ, /* 5033 */ + IC_EVEX_L_W_XS_KZ, /* 5034 */ + IC_EVEX_L_W_XS_KZ, /* 5035 */ + IC_EVEX_L_W_XD_KZ, /* 5036 */ + IC_EVEX_L_W_XD_KZ, /* 5037 */ + IC_EVEX_L_W_XD_KZ, /* 5038 */ + IC_EVEX_L_W_XD_KZ, /* 5039 */ + IC_EVEX_L_OPSIZE_KZ, /* 5040 */ + IC_EVEX_L_OPSIZE_KZ, /* 5041 */ + IC_EVEX_L_OPSIZE_KZ, /* 5042 */ + IC_EVEX_L_OPSIZE_KZ, /* 5043 */ + IC_EVEX_L_OPSIZE_KZ, /* 5044 */ + IC_EVEX_L_OPSIZE_KZ, /* 5045 */ + IC_EVEX_L_OPSIZE_KZ, /* 5046 */ + IC_EVEX_L_OPSIZE_KZ, /* 5047 */ + IC_EVEX_L_W_OPSIZE_KZ, /* 5048 */ + IC_EVEX_L_W_OPSIZE_KZ, /* 5049 */ + IC_EVEX_L_W_OPSIZE_KZ, /* 5050 */ + IC_EVEX_L_W_OPSIZE_KZ, /* 5051 */ + IC_EVEX_L_W_OPSIZE_KZ, /* 5052 */ + IC_EVEX_L_W_OPSIZE_KZ, /* 5053 */ + IC_EVEX_L_W_OPSIZE_KZ, /* 5054 */ + IC_EVEX_L_W_OPSIZE_KZ, /* 5055 */ + IC_EVEX_L_KZ, /* 5056 */ + IC_EVEX_L_KZ, /* 5057 */ + IC_EVEX_L_XS_KZ, /* 5058 */ + IC_EVEX_L_XS_KZ, /* 5059 */ + IC_EVEX_L_XD_KZ, /* 5060 */ + IC_EVEX_L_XD_KZ, /* 5061 */ + IC_EVEX_L_XD_KZ, /* 5062 */ + IC_EVEX_L_XD_KZ, /* 5063 */ + IC_EVEX_L_W_KZ, /* 5064 */ + IC_EVEX_L_W_KZ, /* 5065 */ + IC_EVEX_L_W_XS_KZ, /* 5066 */ + IC_EVEX_L_W_XS_KZ, /* 5067 */ + IC_EVEX_L_W_XD_KZ, /* 5068 */ + IC_EVEX_L_W_XD_KZ, /* 5069 */ + IC_EVEX_L_W_XD_KZ, /* 5070 */ + IC_EVEX_L_W_XD_KZ, /* 5071 */ + IC_EVEX_L_OPSIZE_KZ, /* 5072 */ + IC_EVEX_L_OPSIZE_KZ, /* 5073 */ + IC_EVEX_L_OPSIZE_KZ, /* 5074 */ + IC_EVEX_L_OPSIZE_KZ, /* 5075 */ + IC_EVEX_L_OPSIZE_KZ, /* 5076 */ + IC_EVEX_L_OPSIZE_KZ, /* 5077 */ + IC_EVEX_L_OPSIZE_KZ, /* 5078 */ + IC_EVEX_L_OPSIZE_KZ, /* 5079 */ + IC_EVEX_L_W_OPSIZE_KZ, /* 5080 */ + IC_EVEX_L_W_OPSIZE_KZ, /* 5081 */ + IC_EVEX_L_W_OPSIZE_KZ, /* 5082 */ + IC_EVEX_L_W_OPSIZE_KZ, /* 5083 */ + IC_EVEX_L_W_OPSIZE_KZ, /* 5084 */ + IC_EVEX_L_W_OPSIZE_KZ, /* 5085 */ + IC_EVEX_L_W_OPSIZE_KZ, /* 5086 */ + IC_EVEX_L_W_OPSIZE_KZ, /* 5087 */ + IC_EVEX_L_KZ, /* 5088 */ + IC_EVEX_L_KZ, /* 5089 */ + IC_EVEX_L_XS_KZ, /* 5090 */ + IC_EVEX_L_XS_KZ, /* 5091 */ + IC_EVEX_L_XD_KZ, /* 5092 */ + IC_EVEX_L_XD_KZ, /* 5093 */ + IC_EVEX_L_XD_KZ, /* 5094 */ + IC_EVEX_L_XD_KZ, /* 5095 */ + IC_EVEX_L_W_KZ, /* 5096 */ + IC_EVEX_L_W_KZ, /* 5097 */ + IC_EVEX_L_W_XS_KZ, /* 5098 */ + IC_EVEX_L_W_XS_KZ, /* 5099 */ + IC_EVEX_L_W_XD_KZ, /* 5100 */ + IC_EVEX_L_W_XD_KZ, /* 5101 */ + IC_EVEX_L_W_XD_KZ, /* 5102 */ + IC_EVEX_L_W_XD_KZ, /* 5103 */ + IC_EVEX_L_OPSIZE_KZ, /* 5104 */ + IC_EVEX_L_OPSIZE_KZ, /* 5105 */ + IC_EVEX_L_OPSIZE_KZ, /* 5106 */ + IC_EVEX_L_OPSIZE_KZ, /* 5107 */ + IC_EVEX_L_OPSIZE_KZ, /* 5108 */ + IC_EVEX_L_OPSIZE_KZ, /* 5109 */ + IC_EVEX_L_OPSIZE_KZ, /* 5110 */ + IC_EVEX_L_OPSIZE_KZ, /* 5111 */ + IC_EVEX_L_W_OPSIZE_KZ, /* 5112 */ + IC_EVEX_L_W_OPSIZE_KZ, /* 5113 */ + IC_EVEX_L_W_OPSIZE_KZ, /* 5114 */ + IC_EVEX_L_W_OPSIZE_KZ, /* 5115 */ + IC_EVEX_L_W_OPSIZE_KZ, /* 5116 */ + IC_EVEX_L_W_OPSIZE_KZ, /* 5117 */ + IC_EVEX_L_W_OPSIZE_KZ, /* 5118 */ + IC_EVEX_L_W_OPSIZE_KZ, /* 5119 */ + IC, /* 5120 */ + IC_64BIT, /* 5121 */ + IC_XS, /* 5122 */ + IC_64BIT_XS, /* 5123 */ + IC_XD, /* 5124 */ + IC_64BIT_XD, /* 5125 */ + IC_XS, /* 5126 */ + IC_64BIT_XS, /* 5127 */ + IC, /* 5128 */ + IC_64BIT_REXW, /* 5129 */ + IC_XS, /* 5130 */ + IC_64BIT_REXW_XS, /* 5131 */ + IC_XD, /* 5132 */ + IC_64BIT_REXW_XD, /* 5133 */ + IC_XS, /* 5134 */ + IC_64BIT_REXW_XS, /* 5135 */ + IC_OPSIZE, /* 5136 */ + IC_64BIT_OPSIZE, /* 5137 */ + IC_XS_OPSIZE, /* 5138 */ + IC_64BIT_XS_OPSIZE, /* 5139 */ + IC_XD_OPSIZE, /* 5140 */ + IC_64BIT_XD_OPSIZE, /* 5141 */ + IC_XS_OPSIZE, /* 5142 */ + IC_64BIT_XD_OPSIZE, /* 5143 */ + IC_OPSIZE, /* 5144 */ + IC_64BIT_REXW_OPSIZE, /* 5145 */ + IC_XS_OPSIZE, /* 5146 */ + IC_64BIT_REXW_XS, /* 5147 */ + IC_XD_OPSIZE, /* 5148 */ + IC_64BIT_REXW_XD, /* 5149 */ + IC_XS_OPSIZE, /* 5150 */ + IC_64BIT_REXW_XS, /* 5151 */ + IC_ADSIZE, /* 5152 */ + IC_64BIT_ADSIZE, /* 5153 */ + IC_XS_ADSIZE, /* 5154 */ + IC_64BIT_XS_ADSIZE, /* 5155 */ + IC_XD_ADSIZE, /* 5156 */ + IC_64BIT_XD_ADSIZE, /* 5157 */ + IC_XS_ADSIZE, /* 5158 */ + IC_64BIT_XD_ADSIZE, /* 5159 */ + IC_ADSIZE, /* 5160 */ + IC_64BIT_REXW_ADSIZE, /* 5161 */ + IC_XS_ADSIZE, /* 5162 */ + IC_64BIT_REXW_XS, /* 5163 */ + IC_XD_ADSIZE, /* 5164 */ + IC_64BIT_REXW_XD, /* 5165 */ + IC_XS_ADSIZE, /* 5166 */ + IC_64BIT_REXW_XS, /* 5167 */ + IC_OPSIZE_ADSIZE, /* 5168 */ + IC_64BIT_OPSIZE_ADSIZE, /* 5169 */ + IC_XS_OPSIZE, /* 5170 */ + IC_64BIT_XS_OPSIZE, /* 5171 */ + IC_XD_OPSIZE, /* 5172 */ + IC_64BIT_XD_OPSIZE, /* 5173 */ + IC_XS_OPSIZE, /* 5174 */ + IC_64BIT_XD_OPSIZE, /* 5175 */ + IC_OPSIZE_ADSIZE, /* 5176 */ + IC_64BIT_REXW_OPSIZE, /* 5177 */ + IC_XS_OPSIZE, /* 5178 */ + IC_64BIT_REXW_XS, /* 5179 */ + IC_XD_OPSIZE, /* 5180 */ + IC_64BIT_REXW_XD, /* 5181 */ + IC_XS_OPSIZE, /* 5182 */ + IC_64BIT_REXW_XS, /* 5183 */ + IC_VEX, /* 5184 */ + IC_VEX, /* 5185 */ + IC_VEX_XS, /* 5186 */ + IC_VEX_XS, /* 5187 */ + IC_VEX_XD, /* 5188 */ + IC_VEX_XD, /* 5189 */ + IC_VEX_XD, /* 5190 */ + IC_VEX_XD, /* 5191 */ + IC_VEX_W, /* 5192 */ + IC_VEX_W, /* 5193 */ + IC_VEX_W_XS, /* 5194 */ + IC_VEX_W_XS, /* 5195 */ + IC_VEX_W_XD, /* 5196 */ + IC_VEX_W_XD, /* 5197 */ + IC_VEX_W_XD, /* 5198 */ + IC_VEX_W_XD, /* 5199 */ + IC_VEX_OPSIZE, /* 5200 */ + IC_VEX_OPSIZE, /* 5201 */ + IC_VEX_OPSIZE, /* 5202 */ + IC_VEX_OPSIZE, /* 5203 */ + IC_VEX_OPSIZE, /* 5204 */ + IC_VEX_OPSIZE, /* 5205 */ + IC_VEX_OPSIZE, /* 5206 */ + IC_VEX_OPSIZE, /* 5207 */ + IC_VEX_W_OPSIZE, /* 5208 */ + IC_VEX_W_OPSIZE, /* 5209 */ + IC_VEX_W_OPSIZE, /* 5210 */ + IC_VEX_W_OPSIZE, /* 5211 */ + IC_VEX_W_OPSIZE, /* 5212 */ + IC_VEX_W_OPSIZE, /* 5213 */ + IC_VEX_W_OPSIZE, /* 5214 */ + IC_VEX_W_OPSIZE, /* 5215 */ + IC_VEX, /* 5216 */ + IC_VEX, /* 5217 */ + IC_VEX_XS, /* 5218 */ + IC_VEX_XS, /* 5219 */ + IC_VEX_XD, /* 5220 */ + IC_VEX_XD, /* 5221 */ + IC_VEX_XD, /* 5222 */ + IC_VEX_XD, /* 5223 */ + IC_VEX_W, /* 5224 */ + IC_VEX_W, /* 5225 */ + IC_VEX_W_XS, /* 5226 */ + IC_VEX_W_XS, /* 5227 */ + IC_VEX_W_XD, /* 5228 */ + IC_VEX_W_XD, /* 5229 */ + IC_VEX_W_XD, /* 5230 */ + IC_VEX_W_XD, /* 5231 */ + IC_VEX_OPSIZE, /* 5232 */ + IC_VEX_OPSIZE, /* 5233 */ + IC_VEX_OPSIZE, /* 5234 */ + IC_VEX_OPSIZE, /* 5235 */ + IC_VEX_OPSIZE, /* 5236 */ + IC_VEX_OPSIZE, /* 5237 */ + IC_VEX_OPSIZE, /* 5238 */ + IC_VEX_OPSIZE, /* 5239 */ + IC_VEX_W_OPSIZE, /* 5240 */ + IC_VEX_W_OPSIZE, /* 5241 */ + IC_VEX_W_OPSIZE, /* 5242 */ + IC_VEX_W_OPSIZE, /* 5243 */ + IC_VEX_W_OPSIZE, /* 5244 */ + IC_VEX_W_OPSIZE, /* 5245 */ + IC_VEX_W_OPSIZE, /* 5246 */ + IC_VEX_W_OPSIZE, /* 5247 */ + IC_VEX_L, /* 5248 */ + IC_VEX_L, /* 5249 */ + IC_VEX_L_XS, /* 5250 */ + IC_VEX_L_XS, /* 5251 */ + IC_VEX_L_XD, /* 5252 */ + IC_VEX_L_XD, /* 5253 */ + IC_VEX_L_XD, /* 5254 */ + IC_VEX_L_XD, /* 5255 */ + IC_VEX_L_W, /* 5256 */ + IC_VEX_L_W, /* 5257 */ + IC_VEX_L_W_XS, /* 5258 */ + IC_VEX_L_W_XS, /* 5259 */ + IC_VEX_L_W_XD, /* 5260 */ + IC_VEX_L_W_XD, /* 5261 */ + IC_VEX_L_W_XD, /* 5262 */ + IC_VEX_L_W_XD, /* 5263 */ + IC_VEX_L_OPSIZE, /* 5264 */ + IC_VEX_L_OPSIZE, /* 5265 */ + IC_VEX_L_OPSIZE, /* 5266 */ + IC_VEX_L_OPSIZE, /* 5267 */ + IC_VEX_L_OPSIZE, /* 5268 */ + IC_VEX_L_OPSIZE, /* 5269 */ + IC_VEX_L_OPSIZE, /* 5270 */ + IC_VEX_L_OPSIZE, /* 5271 */ + IC_VEX_L_W_OPSIZE, /* 5272 */ + IC_VEX_L_W_OPSIZE, /* 5273 */ + IC_VEX_L_W_OPSIZE, /* 5274 */ + IC_VEX_L_W_OPSIZE, /* 5275 */ + IC_VEX_L_W_OPSIZE, /* 5276 */ + IC_VEX_L_W_OPSIZE, /* 5277 */ + IC_VEX_L_W_OPSIZE, /* 5278 */ + IC_VEX_L_W_OPSIZE, /* 5279 */ + IC_VEX_L, /* 5280 */ + IC_VEX_L, /* 5281 */ + IC_VEX_L_XS, /* 5282 */ + IC_VEX_L_XS, /* 5283 */ + IC_VEX_L_XD, /* 5284 */ + IC_VEX_L_XD, /* 5285 */ + IC_VEX_L_XD, /* 5286 */ + IC_VEX_L_XD, /* 5287 */ + IC_VEX_L_W, /* 5288 */ + IC_VEX_L_W, /* 5289 */ + IC_VEX_L_W_XS, /* 5290 */ + IC_VEX_L_W_XS, /* 5291 */ + IC_VEX_L_W_XD, /* 5292 */ + IC_VEX_L_W_XD, /* 5293 */ + IC_VEX_L_W_XD, /* 5294 */ + IC_VEX_L_W_XD, /* 5295 */ + IC_VEX_L_OPSIZE, /* 5296 */ + IC_VEX_L_OPSIZE, /* 5297 */ + IC_VEX_L_OPSIZE, /* 5298 */ + IC_VEX_L_OPSIZE, /* 5299 */ + IC_VEX_L_OPSIZE, /* 5300 */ + IC_VEX_L_OPSIZE, /* 5301 */ + IC_VEX_L_OPSIZE, /* 5302 */ + IC_VEX_L_OPSIZE, /* 5303 */ + IC_VEX_L_W_OPSIZE, /* 5304 */ + IC_VEX_L_W_OPSIZE, /* 5305 */ + IC_VEX_L_W_OPSIZE, /* 5306 */ + IC_VEX_L_W_OPSIZE, /* 5307 */ + IC_VEX_L_W_OPSIZE, /* 5308 */ + IC_VEX_L_W_OPSIZE, /* 5309 */ + IC_VEX_L_W_OPSIZE, /* 5310 */ + IC_VEX_L_W_OPSIZE, /* 5311 */ + IC_VEX_L, /* 5312 */ + IC_VEX_L, /* 5313 */ + IC_VEX_L_XS, /* 5314 */ + IC_VEX_L_XS, /* 5315 */ + IC_VEX_L_XD, /* 5316 */ + IC_VEX_L_XD, /* 5317 */ + IC_VEX_L_XD, /* 5318 */ + IC_VEX_L_XD, /* 5319 */ + IC_VEX_L_W, /* 5320 */ + IC_VEX_L_W, /* 5321 */ + IC_VEX_L_W_XS, /* 5322 */ + IC_VEX_L_W_XS, /* 5323 */ + IC_VEX_L_W_XD, /* 5324 */ + IC_VEX_L_W_XD, /* 5325 */ + IC_VEX_L_W_XD, /* 5326 */ + IC_VEX_L_W_XD, /* 5327 */ + IC_VEX_L_OPSIZE, /* 5328 */ + IC_VEX_L_OPSIZE, /* 5329 */ + IC_VEX_L_OPSIZE, /* 5330 */ + IC_VEX_L_OPSIZE, /* 5331 */ + IC_VEX_L_OPSIZE, /* 5332 */ + IC_VEX_L_OPSIZE, /* 5333 */ + IC_VEX_L_OPSIZE, /* 5334 */ + IC_VEX_L_OPSIZE, /* 5335 */ + IC_VEX_L_W_OPSIZE, /* 5336 */ + IC_VEX_L_W_OPSIZE, /* 5337 */ + IC_VEX_L_W_OPSIZE, /* 5338 */ + IC_VEX_L_W_OPSIZE, /* 5339 */ + IC_VEX_L_W_OPSIZE, /* 5340 */ + IC_VEX_L_W_OPSIZE, /* 5341 */ + IC_VEX_L_W_OPSIZE, /* 5342 */ + IC_VEX_L_W_OPSIZE, /* 5343 */ + IC_VEX_L, /* 5344 */ + IC_VEX_L, /* 5345 */ + IC_VEX_L_XS, /* 5346 */ + IC_VEX_L_XS, /* 5347 */ + IC_VEX_L_XD, /* 5348 */ + IC_VEX_L_XD, /* 5349 */ + IC_VEX_L_XD, /* 5350 */ + IC_VEX_L_XD, /* 5351 */ + IC_VEX_L_W, /* 5352 */ + IC_VEX_L_W, /* 5353 */ + IC_VEX_L_W_XS, /* 5354 */ + IC_VEX_L_W_XS, /* 5355 */ + IC_VEX_L_W_XD, /* 5356 */ + IC_VEX_L_W_XD, /* 5357 */ + IC_VEX_L_W_XD, /* 5358 */ + IC_VEX_L_W_XD, /* 5359 */ + IC_VEX_L_OPSIZE, /* 5360 */ + IC_VEX_L_OPSIZE, /* 5361 */ + IC_VEX_L_OPSIZE, /* 5362 */ + IC_VEX_L_OPSIZE, /* 5363 */ + IC_VEX_L_OPSIZE, /* 5364 */ + IC_VEX_L_OPSIZE, /* 5365 */ + IC_VEX_L_OPSIZE, /* 5366 */ + IC_VEX_L_OPSIZE, /* 5367 */ + IC_VEX_L_W_OPSIZE, /* 5368 */ + IC_VEX_L_W_OPSIZE, /* 5369 */ + IC_VEX_L_W_OPSIZE, /* 5370 */ + IC_VEX_L_W_OPSIZE, /* 5371 */ + IC_VEX_L_W_OPSIZE, /* 5372 */ + IC_VEX_L_W_OPSIZE, /* 5373 */ + IC_VEX_L_W_OPSIZE, /* 5374 */ + IC_VEX_L_W_OPSIZE, /* 5375 */ + IC_EVEX_L2_KZ, /* 5376 */ + IC_EVEX_L2_KZ, /* 5377 */ + IC_EVEX_L2_XS_KZ, /* 5378 */ + IC_EVEX_L2_XS_KZ, /* 5379 */ + IC_EVEX_L2_XD_KZ, /* 5380 */ + IC_EVEX_L2_XD_KZ, /* 5381 */ + IC_EVEX_L2_XD_KZ, /* 5382 */ + IC_EVEX_L2_XD_KZ, /* 5383 */ + IC_EVEX_L2_W_KZ, /* 5384 */ + IC_EVEX_L2_W_KZ, /* 5385 */ + IC_EVEX_L2_W_XS_KZ, /* 5386 */ + IC_EVEX_L2_W_XS_KZ, /* 5387 */ + IC_EVEX_L2_W_XD_KZ, /* 5388 */ + IC_EVEX_L2_W_XD_KZ, /* 5389 */ + IC_EVEX_L2_W_XD_KZ, /* 5390 */ + IC_EVEX_L2_W_XD_KZ, /* 5391 */ + IC_EVEX_L2_OPSIZE_KZ, /* 5392 */ + IC_EVEX_L2_OPSIZE_KZ, /* 5393 */ + IC_EVEX_L2_OPSIZE_KZ, /* 5394 */ + IC_EVEX_L2_OPSIZE_KZ, /* 5395 */ + IC_EVEX_L2_OPSIZE_KZ, /* 5396 */ + IC_EVEX_L2_OPSIZE_KZ, /* 5397 */ + IC_EVEX_L2_OPSIZE_KZ, /* 5398 */ + IC_EVEX_L2_OPSIZE_KZ, /* 5399 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 5400 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 5401 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 5402 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 5403 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 5404 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 5405 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 5406 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 5407 */ + IC_EVEX_L2_KZ, /* 5408 */ + IC_EVEX_L2_KZ, /* 5409 */ + IC_EVEX_L2_XS_KZ, /* 5410 */ + IC_EVEX_L2_XS_KZ, /* 5411 */ + IC_EVEX_L2_XD_KZ, /* 5412 */ + IC_EVEX_L2_XD_KZ, /* 5413 */ + IC_EVEX_L2_XD_KZ, /* 5414 */ + IC_EVEX_L2_XD_KZ, /* 5415 */ + IC_EVEX_L2_W_KZ, /* 5416 */ + IC_EVEX_L2_W_KZ, /* 5417 */ + IC_EVEX_L2_W_XS_KZ, /* 5418 */ + IC_EVEX_L2_W_XS_KZ, /* 5419 */ + IC_EVEX_L2_W_XD_KZ, /* 5420 */ + IC_EVEX_L2_W_XD_KZ, /* 5421 */ + IC_EVEX_L2_W_XD_KZ, /* 5422 */ + IC_EVEX_L2_W_XD_KZ, /* 5423 */ + IC_EVEX_L2_OPSIZE_KZ, /* 5424 */ + IC_EVEX_L2_OPSIZE_KZ, /* 5425 */ + IC_EVEX_L2_OPSIZE_KZ, /* 5426 */ + IC_EVEX_L2_OPSIZE_KZ, /* 5427 */ + IC_EVEX_L2_OPSIZE_KZ, /* 5428 */ + IC_EVEX_L2_OPSIZE_KZ, /* 5429 */ + IC_EVEX_L2_OPSIZE_KZ, /* 5430 */ + IC_EVEX_L2_OPSIZE_KZ, /* 5431 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 5432 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 5433 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 5434 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 5435 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 5436 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 5437 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 5438 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 5439 */ + IC_EVEX_L2_KZ, /* 5440 */ + IC_EVEX_L2_KZ, /* 5441 */ + IC_EVEX_L2_XS_KZ, /* 5442 */ + IC_EVEX_L2_XS_KZ, /* 5443 */ + IC_EVEX_L2_XD_KZ, /* 5444 */ + IC_EVEX_L2_XD_KZ, /* 5445 */ + IC_EVEX_L2_XD_KZ, /* 5446 */ + IC_EVEX_L2_XD_KZ, /* 5447 */ + IC_EVEX_L2_W_KZ, /* 5448 */ + IC_EVEX_L2_W_KZ, /* 5449 */ + IC_EVEX_L2_W_XS_KZ, /* 5450 */ + IC_EVEX_L2_W_XS_KZ, /* 5451 */ + IC_EVEX_L2_W_XD_KZ, /* 5452 */ + IC_EVEX_L2_W_XD_KZ, /* 5453 */ + IC_EVEX_L2_W_XD_KZ, /* 5454 */ + IC_EVEX_L2_W_XD_KZ, /* 5455 */ + IC_EVEX_L2_OPSIZE_KZ, /* 5456 */ + IC_EVEX_L2_OPSIZE_KZ, /* 5457 */ + IC_EVEX_L2_OPSIZE_KZ, /* 5458 */ + IC_EVEX_L2_OPSIZE_KZ, /* 5459 */ + IC_EVEX_L2_OPSIZE_KZ, /* 5460 */ + IC_EVEX_L2_OPSIZE_KZ, /* 5461 */ + IC_EVEX_L2_OPSIZE_KZ, /* 5462 */ + IC_EVEX_L2_OPSIZE_KZ, /* 5463 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 5464 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 5465 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 5466 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 5467 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 5468 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 5469 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 5470 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 5471 */ + IC_EVEX_L2_KZ, /* 5472 */ + IC_EVEX_L2_KZ, /* 5473 */ + IC_EVEX_L2_XS_KZ, /* 5474 */ + IC_EVEX_L2_XS_KZ, /* 5475 */ + IC_EVEX_L2_XD_KZ, /* 5476 */ + IC_EVEX_L2_XD_KZ, /* 5477 */ + IC_EVEX_L2_XD_KZ, /* 5478 */ + IC_EVEX_L2_XD_KZ, /* 5479 */ + IC_EVEX_L2_W_KZ, /* 5480 */ + IC_EVEX_L2_W_KZ, /* 5481 */ + IC_EVEX_L2_W_XS_KZ, /* 5482 */ + IC_EVEX_L2_W_XS_KZ, /* 5483 */ + IC_EVEX_L2_W_XD_KZ, /* 5484 */ + IC_EVEX_L2_W_XD_KZ, /* 5485 */ + IC_EVEX_L2_W_XD_KZ, /* 5486 */ + IC_EVEX_L2_W_XD_KZ, /* 5487 */ + IC_EVEX_L2_OPSIZE_KZ, /* 5488 */ + IC_EVEX_L2_OPSIZE_KZ, /* 5489 */ + IC_EVEX_L2_OPSIZE_KZ, /* 5490 */ + IC_EVEX_L2_OPSIZE_KZ, /* 5491 */ + IC_EVEX_L2_OPSIZE_KZ, /* 5492 */ + IC_EVEX_L2_OPSIZE_KZ, /* 5493 */ + IC_EVEX_L2_OPSIZE_KZ, /* 5494 */ + IC_EVEX_L2_OPSIZE_KZ, /* 5495 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 5496 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 5497 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 5498 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 5499 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 5500 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 5501 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 5502 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 5503 */ + IC_EVEX_L2_KZ, /* 5504 */ + IC_EVEX_L2_KZ, /* 5505 */ + IC_EVEX_L2_XS_KZ, /* 5506 */ + IC_EVEX_L2_XS_KZ, /* 5507 */ + IC_EVEX_L2_XD_KZ, /* 5508 */ + IC_EVEX_L2_XD_KZ, /* 5509 */ + IC_EVEX_L2_XD_KZ, /* 5510 */ + IC_EVEX_L2_XD_KZ, /* 5511 */ + IC_EVEX_L2_W_KZ, /* 5512 */ + IC_EVEX_L2_W_KZ, /* 5513 */ + IC_EVEX_L2_W_XS_KZ, /* 5514 */ + IC_EVEX_L2_W_XS_KZ, /* 5515 */ + IC_EVEX_L2_W_XD_KZ, /* 5516 */ + IC_EVEX_L2_W_XD_KZ, /* 5517 */ + IC_EVEX_L2_W_XD_KZ, /* 5518 */ + IC_EVEX_L2_W_XD_KZ, /* 5519 */ + IC_EVEX_L2_OPSIZE_KZ, /* 5520 */ + IC_EVEX_L2_OPSIZE_KZ, /* 5521 */ + IC_EVEX_L2_OPSIZE_KZ, /* 5522 */ + IC_EVEX_L2_OPSIZE_KZ, /* 5523 */ + IC_EVEX_L2_OPSIZE_KZ, /* 5524 */ + IC_EVEX_L2_OPSIZE_KZ, /* 5525 */ + IC_EVEX_L2_OPSIZE_KZ, /* 5526 */ + IC_EVEX_L2_OPSIZE_KZ, /* 5527 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 5528 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 5529 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 5530 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 5531 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 5532 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 5533 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 5534 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 5535 */ + IC_EVEX_L2_KZ, /* 5536 */ + IC_EVEX_L2_KZ, /* 5537 */ + IC_EVEX_L2_XS_KZ, /* 5538 */ + IC_EVEX_L2_XS_KZ, /* 5539 */ + IC_EVEX_L2_XD_KZ, /* 5540 */ + IC_EVEX_L2_XD_KZ, /* 5541 */ + IC_EVEX_L2_XD_KZ, /* 5542 */ + IC_EVEX_L2_XD_KZ, /* 5543 */ + IC_EVEX_L2_W_KZ, /* 5544 */ + IC_EVEX_L2_W_KZ, /* 5545 */ + IC_EVEX_L2_W_XS_KZ, /* 5546 */ + IC_EVEX_L2_W_XS_KZ, /* 5547 */ + IC_EVEX_L2_W_XD_KZ, /* 5548 */ + IC_EVEX_L2_W_XD_KZ, /* 5549 */ + IC_EVEX_L2_W_XD_KZ, /* 5550 */ + IC_EVEX_L2_W_XD_KZ, /* 5551 */ + IC_EVEX_L2_OPSIZE_KZ, /* 5552 */ + IC_EVEX_L2_OPSIZE_KZ, /* 5553 */ + IC_EVEX_L2_OPSIZE_KZ, /* 5554 */ + IC_EVEX_L2_OPSIZE_KZ, /* 5555 */ + IC_EVEX_L2_OPSIZE_KZ, /* 5556 */ + IC_EVEX_L2_OPSIZE_KZ, /* 5557 */ + IC_EVEX_L2_OPSIZE_KZ, /* 5558 */ + IC_EVEX_L2_OPSIZE_KZ, /* 5559 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 5560 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 5561 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 5562 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 5563 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 5564 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 5565 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 5566 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 5567 */ + IC_EVEX_L2_KZ, /* 5568 */ + IC_EVEX_L2_KZ, /* 5569 */ + IC_EVEX_L2_XS_KZ, /* 5570 */ + IC_EVEX_L2_XS_KZ, /* 5571 */ + IC_EVEX_L2_XD_KZ, /* 5572 */ + IC_EVEX_L2_XD_KZ, /* 5573 */ + IC_EVEX_L2_XD_KZ, /* 5574 */ + IC_EVEX_L2_XD_KZ, /* 5575 */ + IC_EVEX_L2_W_KZ, /* 5576 */ + IC_EVEX_L2_W_KZ, /* 5577 */ + IC_EVEX_L2_W_XS_KZ, /* 5578 */ + IC_EVEX_L2_W_XS_KZ, /* 5579 */ + IC_EVEX_L2_W_XD_KZ, /* 5580 */ + IC_EVEX_L2_W_XD_KZ, /* 5581 */ + IC_EVEX_L2_W_XD_KZ, /* 5582 */ + IC_EVEX_L2_W_XD_KZ, /* 5583 */ + IC_EVEX_L2_OPSIZE_KZ, /* 5584 */ + IC_EVEX_L2_OPSIZE_KZ, /* 5585 */ + IC_EVEX_L2_OPSIZE_KZ, /* 5586 */ + IC_EVEX_L2_OPSIZE_KZ, /* 5587 */ + IC_EVEX_L2_OPSIZE_KZ, /* 5588 */ + IC_EVEX_L2_OPSIZE_KZ, /* 5589 */ + IC_EVEX_L2_OPSIZE_KZ, /* 5590 */ + IC_EVEX_L2_OPSIZE_KZ, /* 5591 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 5592 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 5593 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 5594 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 5595 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 5596 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 5597 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 5598 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 5599 */ + IC_EVEX_L2_KZ, /* 5600 */ + IC_EVEX_L2_KZ, /* 5601 */ + IC_EVEX_L2_XS_KZ, /* 5602 */ + IC_EVEX_L2_XS_KZ, /* 5603 */ + IC_EVEX_L2_XD_KZ, /* 5604 */ + IC_EVEX_L2_XD_KZ, /* 5605 */ + IC_EVEX_L2_XD_KZ, /* 5606 */ + IC_EVEX_L2_XD_KZ, /* 5607 */ + IC_EVEX_L2_W_KZ, /* 5608 */ + IC_EVEX_L2_W_KZ, /* 5609 */ + IC_EVEX_L2_W_XS_KZ, /* 5610 */ + IC_EVEX_L2_W_XS_KZ, /* 5611 */ + IC_EVEX_L2_W_XD_KZ, /* 5612 */ + IC_EVEX_L2_W_XD_KZ, /* 5613 */ + IC_EVEX_L2_W_XD_KZ, /* 5614 */ + IC_EVEX_L2_W_XD_KZ, /* 5615 */ + IC_EVEX_L2_OPSIZE_KZ, /* 5616 */ + IC_EVEX_L2_OPSIZE_KZ, /* 5617 */ + IC_EVEX_L2_OPSIZE_KZ, /* 5618 */ + IC_EVEX_L2_OPSIZE_KZ, /* 5619 */ + IC_EVEX_L2_OPSIZE_KZ, /* 5620 */ + IC_EVEX_L2_OPSIZE_KZ, /* 5621 */ + IC_EVEX_L2_OPSIZE_KZ, /* 5622 */ + IC_EVEX_L2_OPSIZE_KZ, /* 5623 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 5624 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 5625 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 5626 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 5627 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 5628 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 5629 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 5630 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 5631 */ + IC, /* 5632 */ + IC_64BIT, /* 5633 */ + IC_XS, /* 5634 */ + IC_64BIT_XS, /* 5635 */ + IC_XD, /* 5636 */ + IC_64BIT_XD, /* 5637 */ + IC_XS, /* 5638 */ + IC_64BIT_XS, /* 5639 */ + IC, /* 5640 */ + IC_64BIT_REXW, /* 5641 */ + IC_XS, /* 5642 */ + IC_64BIT_REXW_XS, /* 5643 */ + IC_XD, /* 5644 */ + IC_64BIT_REXW_XD, /* 5645 */ + IC_XS, /* 5646 */ + IC_64BIT_REXW_XS, /* 5647 */ + IC_OPSIZE, /* 5648 */ + IC_64BIT_OPSIZE, /* 5649 */ + IC_XS_OPSIZE, /* 5650 */ + IC_64BIT_XS_OPSIZE, /* 5651 */ + IC_XD_OPSIZE, /* 5652 */ + IC_64BIT_XD_OPSIZE, /* 5653 */ + IC_XS_OPSIZE, /* 5654 */ + IC_64BIT_XD_OPSIZE, /* 5655 */ + IC_OPSIZE, /* 5656 */ + IC_64BIT_REXW_OPSIZE, /* 5657 */ + IC_XS_OPSIZE, /* 5658 */ + IC_64BIT_REXW_XS, /* 5659 */ + IC_XD_OPSIZE, /* 5660 */ + IC_64BIT_REXW_XD, /* 5661 */ + IC_XS_OPSIZE, /* 5662 */ + IC_64BIT_REXW_XS, /* 5663 */ + IC_ADSIZE, /* 5664 */ + IC_64BIT_ADSIZE, /* 5665 */ + IC_XS_ADSIZE, /* 5666 */ + IC_64BIT_XS_ADSIZE, /* 5667 */ + IC_XD_ADSIZE, /* 5668 */ + IC_64BIT_XD_ADSIZE, /* 5669 */ + IC_XS_ADSIZE, /* 5670 */ + IC_64BIT_XD_ADSIZE, /* 5671 */ + IC_ADSIZE, /* 5672 */ + IC_64BIT_REXW_ADSIZE, /* 5673 */ + IC_XS_ADSIZE, /* 5674 */ + IC_64BIT_REXW_XS, /* 5675 */ + IC_XD_ADSIZE, /* 5676 */ + IC_64BIT_REXW_XD, /* 5677 */ + IC_XS_ADSIZE, /* 5678 */ + IC_64BIT_REXW_XS, /* 5679 */ + IC_OPSIZE_ADSIZE, /* 5680 */ + IC_64BIT_OPSIZE_ADSIZE, /* 5681 */ + IC_XS_OPSIZE, /* 5682 */ + IC_64BIT_XS_OPSIZE, /* 5683 */ + IC_XD_OPSIZE, /* 5684 */ + IC_64BIT_XD_OPSIZE, /* 5685 */ + IC_XS_OPSIZE, /* 5686 */ + IC_64BIT_XD_OPSIZE, /* 5687 */ + IC_OPSIZE_ADSIZE, /* 5688 */ + IC_64BIT_REXW_OPSIZE, /* 5689 */ + IC_XS_OPSIZE, /* 5690 */ + IC_64BIT_REXW_XS, /* 5691 */ + IC_XD_OPSIZE, /* 5692 */ + IC_64BIT_REXW_XD, /* 5693 */ + IC_XS_OPSIZE, /* 5694 */ + IC_64BIT_REXW_XS, /* 5695 */ + IC_VEX, /* 5696 */ + IC_VEX, /* 5697 */ + IC_VEX_XS, /* 5698 */ + IC_VEX_XS, /* 5699 */ + IC_VEX_XD, /* 5700 */ + IC_VEX_XD, /* 5701 */ + IC_VEX_XD, /* 5702 */ + IC_VEX_XD, /* 5703 */ + IC_VEX_W, /* 5704 */ + IC_VEX_W, /* 5705 */ + IC_VEX_W_XS, /* 5706 */ + IC_VEX_W_XS, /* 5707 */ + IC_VEX_W_XD, /* 5708 */ + IC_VEX_W_XD, /* 5709 */ + IC_VEX_W_XD, /* 5710 */ + IC_VEX_W_XD, /* 5711 */ + IC_VEX_OPSIZE, /* 5712 */ + IC_VEX_OPSIZE, /* 5713 */ + IC_VEX_OPSIZE, /* 5714 */ + IC_VEX_OPSIZE, /* 5715 */ + IC_VEX_OPSIZE, /* 5716 */ + IC_VEX_OPSIZE, /* 5717 */ + IC_VEX_OPSIZE, /* 5718 */ + IC_VEX_OPSIZE, /* 5719 */ + IC_VEX_W_OPSIZE, /* 5720 */ + IC_VEX_W_OPSIZE, /* 5721 */ + IC_VEX_W_OPSIZE, /* 5722 */ + IC_VEX_W_OPSIZE, /* 5723 */ + IC_VEX_W_OPSIZE, /* 5724 */ + IC_VEX_W_OPSIZE, /* 5725 */ + IC_VEX_W_OPSIZE, /* 5726 */ + IC_VEX_W_OPSIZE, /* 5727 */ + IC_VEX, /* 5728 */ + IC_VEX, /* 5729 */ + IC_VEX_XS, /* 5730 */ + IC_VEX_XS, /* 5731 */ + IC_VEX_XD, /* 5732 */ + IC_VEX_XD, /* 5733 */ + IC_VEX_XD, /* 5734 */ + IC_VEX_XD, /* 5735 */ + IC_VEX_W, /* 5736 */ + IC_VEX_W, /* 5737 */ + IC_VEX_W_XS, /* 5738 */ + IC_VEX_W_XS, /* 5739 */ + IC_VEX_W_XD, /* 5740 */ + IC_VEX_W_XD, /* 5741 */ + IC_VEX_W_XD, /* 5742 */ + IC_VEX_W_XD, /* 5743 */ + IC_VEX_OPSIZE, /* 5744 */ + IC_VEX_OPSIZE, /* 5745 */ + IC_VEX_OPSIZE, /* 5746 */ + IC_VEX_OPSIZE, /* 5747 */ + IC_VEX_OPSIZE, /* 5748 */ + IC_VEX_OPSIZE, /* 5749 */ + IC_VEX_OPSIZE, /* 5750 */ + IC_VEX_OPSIZE, /* 5751 */ + IC_VEX_W_OPSIZE, /* 5752 */ + IC_VEX_W_OPSIZE, /* 5753 */ + IC_VEX_W_OPSIZE, /* 5754 */ + IC_VEX_W_OPSIZE, /* 5755 */ + IC_VEX_W_OPSIZE, /* 5756 */ + IC_VEX_W_OPSIZE, /* 5757 */ + IC_VEX_W_OPSIZE, /* 5758 */ + IC_VEX_W_OPSIZE, /* 5759 */ + IC_VEX_L, /* 5760 */ + IC_VEX_L, /* 5761 */ + IC_VEX_L_XS, /* 5762 */ + IC_VEX_L_XS, /* 5763 */ + IC_VEX_L_XD, /* 5764 */ + IC_VEX_L_XD, /* 5765 */ + IC_VEX_L_XD, /* 5766 */ + IC_VEX_L_XD, /* 5767 */ + IC_VEX_L_W, /* 5768 */ + IC_VEX_L_W, /* 5769 */ + IC_VEX_L_W_XS, /* 5770 */ + IC_VEX_L_W_XS, /* 5771 */ + IC_VEX_L_W_XD, /* 5772 */ + IC_VEX_L_W_XD, /* 5773 */ + IC_VEX_L_W_XD, /* 5774 */ + IC_VEX_L_W_XD, /* 5775 */ + IC_VEX_L_OPSIZE, /* 5776 */ + IC_VEX_L_OPSIZE, /* 5777 */ + IC_VEX_L_OPSIZE, /* 5778 */ + IC_VEX_L_OPSIZE, /* 5779 */ + IC_VEX_L_OPSIZE, /* 5780 */ + IC_VEX_L_OPSIZE, /* 5781 */ + IC_VEX_L_OPSIZE, /* 5782 */ + IC_VEX_L_OPSIZE, /* 5783 */ + IC_VEX_L_W_OPSIZE, /* 5784 */ + IC_VEX_L_W_OPSIZE, /* 5785 */ + IC_VEX_L_W_OPSIZE, /* 5786 */ + IC_VEX_L_W_OPSIZE, /* 5787 */ + IC_VEX_L_W_OPSIZE, /* 5788 */ + IC_VEX_L_W_OPSIZE, /* 5789 */ + IC_VEX_L_W_OPSIZE, /* 5790 */ + IC_VEX_L_W_OPSIZE, /* 5791 */ + IC_VEX_L, /* 5792 */ + IC_VEX_L, /* 5793 */ + IC_VEX_L_XS, /* 5794 */ + IC_VEX_L_XS, /* 5795 */ + IC_VEX_L_XD, /* 5796 */ + IC_VEX_L_XD, /* 5797 */ + IC_VEX_L_XD, /* 5798 */ + IC_VEX_L_XD, /* 5799 */ + IC_VEX_L_W, /* 5800 */ + IC_VEX_L_W, /* 5801 */ + IC_VEX_L_W_XS, /* 5802 */ + IC_VEX_L_W_XS, /* 5803 */ + IC_VEX_L_W_XD, /* 5804 */ + IC_VEX_L_W_XD, /* 5805 */ + IC_VEX_L_W_XD, /* 5806 */ + IC_VEX_L_W_XD, /* 5807 */ + IC_VEX_L_OPSIZE, /* 5808 */ + IC_VEX_L_OPSIZE, /* 5809 */ + IC_VEX_L_OPSIZE, /* 5810 */ + IC_VEX_L_OPSIZE, /* 5811 */ + IC_VEX_L_OPSIZE, /* 5812 */ + IC_VEX_L_OPSIZE, /* 5813 */ + IC_VEX_L_OPSIZE, /* 5814 */ + IC_VEX_L_OPSIZE, /* 5815 */ + IC_VEX_L_W_OPSIZE, /* 5816 */ + IC_VEX_L_W_OPSIZE, /* 5817 */ + IC_VEX_L_W_OPSIZE, /* 5818 */ + IC_VEX_L_W_OPSIZE, /* 5819 */ + IC_VEX_L_W_OPSIZE, /* 5820 */ + IC_VEX_L_W_OPSIZE, /* 5821 */ + IC_VEX_L_W_OPSIZE, /* 5822 */ + IC_VEX_L_W_OPSIZE, /* 5823 */ + IC_VEX_L, /* 5824 */ + IC_VEX_L, /* 5825 */ + IC_VEX_L_XS, /* 5826 */ + IC_VEX_L_XS, /* 5827 */ + IC_VEX_L_XD, /* 5828 */ + IC_VEX_L_XD, /* 5829 */ + IC_VEX_L_XD, /* 5830 */ + IC_VEX_L_XD, /* 5831 */ + IC_VEX_L_W, /* 5832 */ + IC_VEX_L_W, /* 5833 */ + IC_VEX_L_W_XS, /* 5834 */ + IC_VEX_L_W_XS, /* 5835 */ + IC_VEX_L_W_XD, /* 5836 */ + IC_VEX_L_W_XD, /* 5837 */ + IC_VEX_L_W_XD, /* 5838 */ + IC_VEX_L_W_XD, /* 5839 */ + IC_VEX_L_OPSIZE, /* 5840 */ + IC_VEX_L_OPSIZE, /* 5841 */ + IC_VEX_L_OPSIZE, /* 5842 */ + IC_VEX_L_OPSIZE, /* 5843 */ + IC_VEX_L_OPSIZE, /* 5844 */ + IC_VEX_L_OPSIZE, /* 5845 */ + IC_VEX_L_OPSIZE, /* 5846 */ + IC_VEX_L_OPSIZE, /* 5847 */ + IC_VEX_L_W_OPSIZE, /* 5848 */ + IC_VEX_L_W_OPSIZE, /* 5849 */ + IC_VEX_L_W_OPSIZE, /* 5850 */ + IC_VEX_L_W_OPSIZE, /* 5851 */ + IC_VEX_L_W_OPSIZE, /* 5852 */ + IC_VEX_L_W_OPSIZE, /* 5853 */ + IC_VEX_L_W_OPSIZE, /* 5854 */ + IC_VEX_L_W_OPSIZE, /* 5855 */ + IC_VEX_L, /* 5856 */ + IC_VEX_L, /* 5857 */ + IC_VEX_L_XS, /* 5858 */ + IC_VEX_L_XS, /* 5859 */ + IC_VEX_L_XD, /* 5860 */ + IC_VEX_L_XD, /* 5861 */ + IC_VEX_L_XD, /* 5862 */ + IC_VEX_L_XD, /* 5863 */ + IC_VEX_L_W, /* 5864 */ + IC_VEX_L_W, /* 5865 */ + IC_VEX_L_W_XS, /* 5866 */ + IC_VEX_L_W_XS, /* 5867 */ + IC_VEX_L_W_XD, /* 5868 */ + IC_VEX_L_W_XD, /* 5869 */ + IC_VEX_L_W_XD, /* 5870 */ + IC_VEX_L_W_XD, /* 5871 */ + IC_VEX_L_OPSIZE, /* 5872 */ + IC_VEX_L_OPSIZE, /* 5873 */ + IC_VEX_L_OPSIZE, /* 5874 */ + IC_VEX_L_OPSIZE, /* 5875 */ + IC_VEX_L_OPSIZE, /* 5876 */ + IC_VEX_L_OPSIZE, /* 5877 */ + IC_VEX_L_OPSIZE, /* 5878 */ + IC_VEX_L_OPSIZE, /* 5879 */ + IC_VEX_L_W_OPSIZE, /* 5880 */ + IC_VEX_L_W_OPSIZE, /* 5881 */ + IC_VEX_L_W_OPSIZE, /* 5882 */ + IC_VEX_L_W_OPSIZE, /* 5883 */ + IC_VEX_L_W_OPSIZE, /* 5884 */ + IC_VEX_L_W_OPSIZE, /* 5885 */ + IC_VEX_L_W_OPSIZE, /* 5886 */ + IC_VEX_L_W_OPSIZE, /* 5887 */ + IC_EVEX_L2_KZ, /* 5888 */ + IC_EVEX_L2_KZ, /* 5889 */ + IC_EVEX_L2_XS_KZ, /* 5890 */ + IC_EVEX_L2_XS_KZ, /* 5891 */ + IC_EVEX_L2_XD_KZ, /* 5892 */ + IC_EVEX_L2_XD_KZ, /* 5893 */ + IC_EVEX_L2_XD_KZ, /* 5894 */ + IC_EVEX_L2_XD_KZ, /* 5895 */ + IC_EVEX_L2_W_KZ, /* 5896 */ + IC_EVEX_L2_W_KZ, /* 5897 */ + IC_EVEX_L2_W_XS_KZ, /* 5898 */ + IC_EVEX_L2_W_XS_KZ, /* 5899 */ + IC_EVEX_L2_W_XD_KZ, /* 5900 */ + IC_EVEX_L2_W_XD_KZ, /* 5901 */ + IC_EVEX_L2_W_XD_KZ, /* 5902 */ + IC_EVEX_L2_W_XD_KZ, /* 5903 */ + IC_EVEX_L2_OPSIZE_KZ, /* 5904 */ + IC_EVEX_L2_OPSIZE_KZ, /* 5905 */ + IC_EVEX_L2_OPSIZE_KZ, /* 5906 */ + IC_EVEX_L2_OPSIZE_KZ, /* 5907 */ + IC_EVEX_L2_OPSIZE_KZ, /* 5908 */ + IC_EVEX_L2_OPSIZE_KZ, /* 5909 */ + IC_EVEX_L2_OPSIZE_KZ, /* 5910 */ + IC_EVEX_L2_OPSIZE_KZ, /* 5911 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 5912 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 5913 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 5914 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 5915 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 5916 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 5917 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 5918 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 5919 */ + IC_EVEX_L2_KZ, /* 5920 */ + IC_EVEX_L2_KZ, /* 5921 */ + IC_EVEX_L2_XS_KZ, /* 5922 */ + IC_EVEX_L2_XS_KZ, /* 5923 */ + IC_EVEX_L2_XD_KZ, /* 5924 */ + IC_EVEX_L2_XD_KZ, /* 5925 */ + IC_EVEX_L2_XD_KZ, /* 5926 */ + IC_EVEX_L2_XD_KZ, /* 5927 */ + IC_EVEX_L2_W_KZ, /* 5928 */ + IC_EVEX_L2_W_KZ, /* 5929 */ + IC_EVEX_L2_W_XS_KZ, /* 5930 */ + IC_EVEX_L2_W_XS_KZ, /* 5931 */ + IC_EVEX_L2_W_XD_KZ, /* 5932 */ + IC_EVEX_L2_W_XD_KZ, /* 5933 */ + IC_EVEX_L2_W_XD_KZ, /* 5934 */ + IC_EVEX_L2_W_XD_KZ, /* 5935 */ + IC_EVEX_L2_OPSIZE_KZ, /* 5936 */ + IC_EVEX_L2_OPSIZE_KZ, /* 5937 */ + IC_EVEX_L2_OPSIZE_KZ, /* 5938 */ + IC_EVEX_L2_OPSIZE_KZ, /* 5939 */ + IC_EVEX_L2_OPSIZE_KZ, /* 5940 */ + IC_EVEX_L2_OPSIZE_KZ, /* 5941 */ + IC_EVEX_L2_OPSIZE_KZ, /* 5942 */ + IC_EVEX_L2_OPSIZE_KZ, /* 5943 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 5944 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 5945 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 5946 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 5947 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 5948 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 5949 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 5950 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 5951 */ + IC_EVEX_L2_KZ, /* 5952 */ + IC_EVEX_L2_KZ, /* 5953 */ + IC_EVEX_L2_XS_KZ, /* 5954 */ + IC_EVEX_L2_XS_KZ, /* 5955 */ + IC_EVEX_L2_XD_KZ, /* 5956 */ + IC_EVEX_L2_XD_KZ, /* 5957 */ + IC_EVEX_L2_XD_KZ, /* 5958 */ + IC_EVEX_L2_XD_KZ, /* 5959 */ + IC_EVEX_L2_W_KZ, /* 5960 */ + IC_EVEX_L2_W_KZ, /* 5961 */ + IC_EVEX_L2_W_XS_KZ, /* 5962 */ + IC_EVEX_L2_W_XS_KZ, /* 5963 */ + IC_EVEX_L2_W_XD_KZ, /* 5964 */ + IC_EVEX_L2_W_XD_KZ, /* 5965 */ + IC_EVEX_L2_W_XD_KZ, /* 5966 */ + IC_EVEX_L2_W_XD_KZ, /* 5967 */ + IC_EVEX_L2_OPSIZE_KZ, /* 5968 */ + IC_EVEX_L2_OPSIZE_KZ, /* 5969 */ + IC_EVEX_L2_OPSIZE_KZ, /* 5970 */ + IC_EVEX_L2_OPSIZE_KZ, /* 5971 */ + IC_EVEX_L2_OPSIZE_KZ, /* 5972 */ + IC_EVEX_L2_OPSIZE_KZ, /* 5973 */ + IC_EVEX_L2_OPSIZE_KZ, /* 5974 */ + IC_EVEX_L2_OPSIZE_KZ, /* 5975 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 5976 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 5977 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 5978 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 5979 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 5980 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 5981 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 5982 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 5983 */ + IC_EVEX_L2_KZ, /* 5984 */ + IC_EVEX_L2_KZ, /* 5985 */ + IC_EVEX_L2_XS_KZ, /* 5986 */ + IC_EVEX_L2_XS_KZ, /* 5987 */ + IC_EVEX_L2_XD_KZ, /* 5988 */ + IC_EVEX_L2_XD_KZ, /* 5989 */ + IC_EVEX_L2_XD_KZ, /* 5990 */ + IC_EVEX_L2_XD_KZ, /* 5991 */ + IC_EVEX_L2_W_KZ, /* 5992 */ + IC_EVEX_L2_W_KZ, /* 5993 */ + IC_EVEX_L2_W_XS_KZ, /* 5994 */ + IC_EVEX_L2_W_XS_KZ, /* 5995 */ + IC_EVEX_L2_W_XD_KZ, /* 5996 */ + IC_EVEX_L2_W_XD_KZ, /* 5997 */ + IC_EVEX_L2_W_XD_KZ, /* 5998 */ + IC_EVEX_L2_W_XD_KZ, /* 5999 */ + IC_EVEX_L2_OPSIZE_KZ, /* 6000 */ + IC_EVEX_L2_OPSIZE_KZ, /* 6001 */ + IC_EVEX_L2_OPSIZE_KZ, /* 6002 */ + IC_EVEX_L2_OPSIZE_KZ, /* 6003 */ + IC_EVEX_L2_OPSIZE_KZ, /* 6004 */ + IC_EVEX_L2_OPSIZE_KZ, /* 6005 */ + IC_EVEX_L2_OPSIZE_KZ, /* 6006 */ + IC_EVEX_L2_OPSIZE_KZ, /* 6007 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 6008 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 6009 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 6010 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 6011 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 6012 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 6013 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 6014 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 6015 */ + IC_EVEX_L2_KZ, /* 6016 */ + IC_EVEX_L2_KZ, /* 6017 */ + IC_EVEX_L2_XS_KZ, /* 6018 */ + IC_EVEX_L2_XS_KZ, /* 6019 */ + IC_EVEX_L2_XD_KZ, /* 6020 */ + IC_EVEX_L2_XD_KZ, /* 6021 */ + IC_EVEX_L2_XD_KZ, /* 6022 */ + IC_EVEX_L2_XD_KZ, /* 6023 */ + IC_EVEX_L2_W_KZ, /* 6024 */ + IC_EVEX_L2_W_KZ, /* 6025 */ + IC_EVEX_L2_W_XS_KZ, /* 6026 */ + IC_EVEX_L2_W_XS_KZ, /* 6027 */ + IC_EVEX_L2_W_XD_KZ, /* 6028 */ + IC_EVEX_L2_W_XD_KZ, /* 6029 */ + IC_EVEX_L2_W_XD_KZ, /* 6030 */ + IC_EVEX_L2_W_XD_KZ, /* 6031 */ + IC_EVEX_L2_OPSIZE_KZ, /* 6032 */ + IC_EVEX_L2_OPSIZE_KZ, /* 6033 */ + IC_EVEX_L2_OPSIZE_KZ, /* 6034 */ + IC_EVEX_L2_OPSIZE_KZ, /* 6035 */ + IC_EVEX_L2_OPSIZE_KZ, /* 6036 */ + IC_EVEX_L2_OPSIZE_KZ, /* 6037 */ + IC_EVEX_L2_OPSIZE_KZ, /* 6038 */ + IC_EVEX_L2_OPSIZE_KZ, /* 6039 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 6040 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 6041 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 6042 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 6043 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 6044 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 6045 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 6046 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 6047 */ + IC_EVEX_L2_KZ, /* 6048 */ + IC_EVEX_L2_KZ, /* 6049 */ + IC_EVEX_L2_XS_KZ, /* 6050 */ + IC_EVEX_L2_XS_KZ, /* 6051 */ + IC_EVEX_L2_XD_KZ, /* 6052 */ + IC_EVEX_L2_XD_KZ, /* 6053 */ + IC_EVEX_L2_XD_KZ, /* 6054 */ + IC_EVEX_L2_XD_KZ, /* 6055 */ + IC_EVEX_L2_W_KZ, /* 6056 */ + IC_EVEX_L2_W_KZ, /* 6057 */ + IC_EVEX_L2_W_XS_KZ, /* 6058 */ + IC_EVEX_L2_W_XS_KZ, /* 6059 */ + IC_EVEX_L2_W_XD_KZ, /* 6060 */ + IC_EVEX_L2_W_XD_KZ, /* 6061 */ + IC_EVEX_L2_W_XD_KZ, /* 6062 */ + IC_EVEX_L2_W_XD_KZ, /* 6063 */ + IC_EVEX_L2_OPSIZE_KZ, /* 6064 */ + IC_EVEX_L2_OPSIZE_KZ, /* 6065 */ + IC_EVEX_L2_OPSIZE_KZ, /* 6066 */ + IC_EVEX_L2_OPSIZE_KZ, /* 6067 */ + IC_EVEX_L2_OPSIZE_KZ, /* 6068 */ + IC_EVEX_L2_OPSIZE_KZ, /* 6069 */ + IC_EVEX_L2_OPSIZE_KZ, /* 6070 */ + IC_EVEX_L2_OPSIZE_KZ, /* 6071 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 6072 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 6073 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 6074 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 6075 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 6076 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 6077 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 6078 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 6079 */ + IC_EVEX_L2_KZ, /* 6080 */ + IC_EVEX_L2_KZ, /* 6081 */ + IC_EVEX_L2_XS_KZ, /* 6082 */ + IC_EVEX_L2_XS_KZ, /* 6083 */ + IC_EVEX_L2_XD_KZ, /* 6084 */ + IC_EVEX_L2_XD_KZ, /* 6085 */ + IC_EVEX_L2_XD_KZ, /* 6086 */ + IC_EVEX_L2_XD_KZ, /* 6087 */ + IC_EVEX_L2_W_KZ, /* 6088 */ + IC_EVEX_L2_W_KZ, /* 6089 */ + IC_EVEX_L2_W_XS_KZ, /* 6090 */ + IC_EVEX_L2_W_XS_KZ, /* 6091 */ + IC_EVEX_L2_W_XD_KZ, /* 6092 */ + IC_EVEX_L2_W_XD_KZ, /* 6093 */ + IC_EVEX_L2_W_XD_KZ, /* 6094 */ + IC_EVEX_L2_W_XD_KZ, /* 6095 */ + IC_EVEX_L2_OPSIZE_KZ, /* 6096 */ + IC_EVEX_L2_OPSIZE_KZ, /* 6097 */ + IC_EVEX_L2_OPSIZE_KZ, /* 6098 */ + IC_EVEX_L2_OPSIZE_KZ, /* 6099 */ + IC_EVEX_L2_OPSIZE_KZ, /* 6100 */ + IC_EVEX_L2_OPSIZE_KZ, /* 6101 */ + IC_EVEX_L2_OPSIZE_KZ, /* 6102 */ + IC_EVEX_L2_OPSIZE_KZ, /* 6103 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 6104 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 6105 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 6106 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 6107 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 6108 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 6109 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 6110 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 6111 */ + IC_EVEX_L2_KZ, /* 6112 */ + IC_EVEX_L2_KZ, /* 6113 */ + IC_EVEX_L2_XS_KZ, /* 6114 */ + IC_EVEX_L2_XS_KZ, /* 6115 */ + IC_EVEX_L2_XD_KZ, /* 6116 */ + IC_EVEX_L2_XD_KZ, /* 6117 */ + IC_EVEX_L2_XD_KZ, /* 6118 */ + IC_EVEX_L2_XD_KZ, /* 6119 */ + IC_EVEX_L2_W_KZ, /* 6120 */ + IC_EVEX_L2_W_KZ, /* 6121 */ + IC_EVEX_L2_W_XS_KZ, /* 6122 */ + IC_EVEX_L2_W_XS_KZ, /* 6123 */ + IC_EVEX_L2_W_XD_KZ, /* 6124 */ + IC_EVEX_L2_W_XD_KZ, /* 6125 */ + IC_EVEX_L2_W_XD_KZ, /* 6126 */ + IC_EVEX_L2_W_XD_KZ, /* 6127 */ + IC_EVEX_L2_OPSIZE_KZ, /* 6128 */ + IC_EVEX_L2_OPSIZE_KZ, /* 6129 */ + IC_EVEX_L2_OPSIZE_KZ, /* 6130 */ + IC_EVEX_L2_OPSIZE_KZ, /* 6131 */ + IC_EVEX_L2_OPSIZE_KZ, /* 6132 */ + IC_EVEX_L2_OPSIZE_KZ, /* 6133 */ + IC_EVEX_L2_OPSIZE_KZ, /* 6134 */ + IC_EVEX_L2_OPSIZE_KZ, /* 6135 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 6136 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 6137 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 6138 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 6139 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 6140 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 6141 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 6142 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 6143 */ + IC, /* 6144 */ + IC_64BIT, /* 6145 */ + IC_XS, /* 6146 */ + IC_64BIT_XS, /* 6147 */ + IC_XD, /* 6148 */ + IC_64BIT_XD, /* 6149 */ + IC_XS, /* 6150 */ + IC_64BIT_XS, /* 6151 */ + IC, /* 6152 */ + IC_64BIT_REXW, /* 6153 */ + IC_XS, /* 6154 */ + IC_64BIT_REXW_XS, /* 6155 */ + IC_XD, /* 6156 */ + IC_64BIT_REXW_XD, /* 6157 */ + IC_XS, /* 6158 */ + IC_64BIT_REXW_XS, /* 6159 */ + IC_OPSIZE, /* 6160 */ + IC_64BIT_OPSIZE, /* 6161 */ + IC_XS_OPSIZE, /* 6162 */ + IC_64BIT_XS_OPSIZE, /* 6163 */ + IC_XD_OPSIZE, /* 6164 */ + IC_64BIT_XD_OPSIZE, /* 6165 */ + IC_XS_OPSIZE, /* 6166 */ + IC_64BIT_XD_OPSIZE, /* 6167 */ + IC_OPSIZE, /* 6168 */ + IC_64BIT_REXW_OPSIZE, /* 6169 */ + IC_XS_OPSIZE, /* 6170 */ + IC_64BIT_REXW_XS, /* 6171 */ + IC_XD_OPSIZE, /* 6172 */ + IC_64BIT_REXW_XD, /* 6173 */ + IC_XS_OPSIZE, /* 6174 */ + IC_64BIT_REXW_XS, /* 6175 */ + IC_ADSIZE, /* 6176 */ + IC_64BIT_ADSIZE, /* 6177 */ + IC_XS_ADSIZE, /* 6178 */ + IC_64BIT_XS_ADSIZE, /* 6179 */ + IC_XD_ADSIZE, /* 6180 */ + IC_64BIT_XD_ADSIZE, /* 6181 */ + IC_XS_ADSIZE, /* 6182 */ + IC_64BIT_XD_ADSIZE, /* 6183 */ + IC_ADSIZE, /* 6184 */ + IC_64BIT_REXW_ADSIZE, /* 6185 */ + IC_XS_ADSIZE, /* 6186 */ + IC_64BIT_REXW_XS, /* 6187 */ + IC_XD_ADSIZE, /* 6188 */ + IC_64BIT_REXW_XD, /* 6189 */ + IC_XS_ADSIZE, /* 6190 */ + IC_64BIT_REXW_XS, /* 6191 */ + IC_OPSIZE_ADSIZE, /* 6192 */ + IC_64BIT_OPSIZE_ADSIZE, /* 6193 */ + IC_XS_OPSIZE, /* 6194 */ + IC_64BIT_XS_OPSIZE, /* 6195 */ + IC_XD_OPSIZE, /* 6196 */ + IC_64BIT_XD_OPSIZE, /* 6197 */ + IC_XS_OPSIZE, /* 6198 */ + IC_64BIT_XD_OPSIZE, /* 6199 */ + IC_OPSIZE_ADSIZE, /* 6200 */ + IC_64BIT_REXW_OPSIZE, /* 6201 */ + IC_XS_OPSIZE, /* 6202 */ + IC_64BIT_REXW_XS, /* 6203 */ + IC_XD_OPSIZE, /* 6204 */ + IC_64BIT_REXW_XD, /* 6205 */ + IC_XS_OPSIZE, /* 6206 */ + IC_64BIT_REXW_XS, /* 6207 */ + IC_VEX, /* 6208 */ + IC_VEX, /* 6209 */ + IC_VEX_XS, /* 6210 */ + IC_VEX_XS, /* 6211 */ + IC_VEX_XD, /* 6212 */ + IC_VEX_XD, /* 6213 */ + IC_VEX_XD, /* 6214 */ + IC_VEX_XD, /* 6215 */ + IC_VEX_W, /* 6216 */ + IC_VEX_W, /* 6217 */ + IC_VEX_W_XS, /* 6218 */ + IC_VEX_W_XS, /* 6219 */ + IC_VEX_W_XD, /* 6220 */ + IC_VEX_W_XD, /* 6221 */ + IC_VEX_W_XD, /* 6222 */ + IC_VEX_W_XD, /* 6223 */ + IC_VEX_OPSIZE, /* 6224 */ + IC_VEX_OPSIZE, /* 6225 */ + IC_VEX_OPSIZE, /* 6226 */ + IC_VEX_OPSIZE, /* 6227 */ + IC_VEX_OPSIZE, /* 6228 */ + IC_VEX_OPSIZE, /* 6229 */ + IC_VEX_OPSIZE, /* 6230 */ + IC_VEX_OPSIZE, /* 6231 */ + IC_VEX_W_OPSIZE, /* 6232 */ + IC_VEX_W_OPSIZE, /* 6233 */ + IC_VEX_W_OPSIZE, /* 6234 */ + IC_VEX_W_OPSIZE, /* 6235 */ + IC_VEX_W_OPSIZE, /* 6236 */ + IC_VEX_W_OPSIZE, /* 6237 */ + IC_VEX_W_OPSIZE, /* 6238 */ + IC_VEX_W_OPSIZE, /* 6239 */ + IC_VEX, /* 6240 */ + IC_VEX, /* 6241 */ + IC_VEX_XS, /* 6242 */ + IC_VEX_XS, /* 6243 */ + IC_VEX_XD, /* 6244 */ + IC_VEX_XD, /* 6245 */ + IC_VEX_XD, /* 6246 */ + IC_VEX_XD, /* 6247 */ + IC_VEX_W, /* 6248 */ + IC_VEX_W, /* 6249 */ + IC_VEX_W_XS, /* 6250 */ + IC_VEX_W_XS, /* 6251 */ + IC_VEX_W_XD, /* 6252 */ + IC_VEX_W_XD, /* 6253 */ + IC_VEX_W_XD, /* 6254 */ + IC_VEX_W_XD, /* 6255 */ + IC_VEX_OPSIZE, /* 6256 */ + IC_VEX_OPSIZE, /* 6257 */ + IC_VEX_OPSIZE, /* 6258 */ + IC_VEX_OPSIZE, /* 6259 */ + IC_VEX_OPSIZE, /* 6260 */ + IC_VEX_OPSIZE, /* 6261 */ + IC_VEX_OPSIZE, /* 6262 */ + IC_VEX_OPSIZE, /* 6263 */ + IC_VEX_W_OPSIZE, /* 6264 */ + IC_VEX_W_OPSIZE, /* 6265 */ + IC_VEX_W_OPSIZE, /* 6266 */ + IC_VEX_W_OPSIZE, /* 6267 */ + IC_VEX_W_OPSIZE, /* 6268 */ + IC_VEX_W_OPSIZE, /* 6269 */ + IC_VEX_W_OPSIZE, /* 6270 */ + IC_VEX_W_OPSIZE, /* 6271 */ + IC_VEX_L, /* 6272 */ + IC_VEX_L, /* 6273 */ + IC_VEX_L_XS, /* 6274 */ + IC_VEX_L_XS, /* 6275 */ + IC_VEX_L_XD, /* 6276 */ + IC_VEX_L_XD, /* 6277 */ + IC_VEX_L_XD, /* 6278 */ + IC_VEX_L_XD, /* 6279 */ + IC_VEX_L_W, /* 6280 */ + IC_VEX_L_W, /* 6281 */ + IC_VEX_L_W_XS, /* 6282 */ + IC_VEX_L_W_XS, /* 6283 */ + IC_VEX_L_W_XD, /* 6284 */ + IC_VEX_L_W_XD, /* 6285 */ + IC_VEX_L_W_XD, /* 6286 */ + IC_VEX_L_W_XD, /* 6287 */ + IC_VEX_L_OPSIZE, /* 6288 */ + IC_VEX_L_OPSIZE, /* 6289 */ + IC_VEX_L_OPSIZE, /* 6290 */ + IC_VEX_L_OPSIZE, /* 6291 */ + IC_VEX_L_OPSIZE, /* 6292 */ + IC_VEX_L_OPSIZE, /* 6293 */ + IC_VEX_L_OPSIZE, /* 6294 */ + IC_VEX_L_OPSIZE, /* 6295 */ + IC_VEX_L_W_OPSIZE, /* 6296 */ + IC_VEX_L_W_OPSIZE, /* 6297 */ + IC_VEX_L_W_OPSIZE, /* 6298 */ + IC_VEX_L_W_OPSIZE, /* 6299 */ + IC_VEX_L_W_OPSIZE, /* 6300 */ + IC_VEX_L_W_OPSIZE, /* 6301 */ + IC_VEX_L_W_OPSIZE, /* 6302 */ + IC_VEX_L_W_OPSIZE, /* 6303 */ + IC_VEX_L, /* 6304 */ + IC_VEX_L, /* 6305 */ + IC_VEX_L_XS, /* 6306 */ + IC_VEX_L_XS, /* 6307 */ + IC_VEX_L_XD, /* 6308 */ + IC_VEX_L_XD, /* 6309 */ + IC_VEX_L_XD, /* 6310 */ + IC_VEX_L_XD, /* 6311 */ + IC_VEX_L_W, /* 6312 */ + IC_VEX_L_W, /* 6313 */ + IC_VEX_L_W_XS, /* 6314 */ + IC_VEX_L_W_XS, /* 6315 */ + IC_VEX_L_W_XD, /* 6316 */ + IC_VEX_L_W_XD, /* 6317 */ + IC_VEX_L_W_XD, /* 6318 */ + IC_VEX_L_W_XD, /* 6319 */ + IC_VEX_L_OPSIZE, /* 6320 */ + IC_VEX_L_OPSIZE, /* 6321 */ + IC_VEX_L_OPSIZE, /* 6322 */ + IC_VEX_L_OPSIZE, /* 6323 */ + IC_VEX_L_OPSIZE, /* 6324 */ + IC_VEX_L_OPSIZE, /* 6325 */ + IC_VEX_L_OPSIZE, /* 6326 */ + IC_VEX_L_OPSIZE, /* 6327 */ + IC_VEX_L_W_OPSIZE, /* 6328 */ + IC_VEX_L_W_OPSIZE, /* 6329 */ + IC_VEX_L_W_OPSIZE, /* 6330 */ + IC_VEX_L_W_OPSIZE, /* 6331 */ + IC_VEX_L_W_OPSIZE, /* 6332 */ + IC_VEX_L_W_OPSIZE, /* 6333 */ + IC_VEX_L_W_OPSIZE, /* 6334 */ + IC_VEX_L_W_OPSIZE, /* 6335 */ + IC_VEX_L, /* 6336 */ + IC_VEX_L, /* 6337 */ + IC_VEX_L_XS, /* 6338 */ + IC_VEX_L_XS, /* 6339 */ + IC_VEX_L_XD, /* 6340 */ + IC_VEX_L_XD, /* 6341 */ + IC_VEX_L_XD, /* 6342 */ + IC_VEX_L_XD, /* 6343 */ + IC_VEX_L_W, /* 6344 */ + IC_VEX_L_W, /* 6345 */ + IC_VEX_L_W_XS, /* 6346 */ + IC_VEX_L_W_XS, /* 6347 */ + IC_VEX_L_W_XD, /* 6348 */ + IC_VEX_L_W_XD, /* 6349 */ + IC_VEX_L_W_XD, /* 6350 */ + IC_VEX_L_W_XD, /* 6351 */ + IC_VEX_L_OPSIZE, /* 6352 */ + IC_VEX_L_OPSIZE, /* 6353 */ + IC_VEX_L_OPSIZE, /* 6354 */ + IC_VEX_L_OPSIZE, /* 6355 */ + IC_VEX_L_OPSIZE, /* 6356 */ + IC_VEX_L_OPSIZE, /* 6357 */ + IC_VEX_L_OPSIZE, /* 6358 */ + IC_VEX_L_OPSIZE, /* 6359 */ + IC_VEX_L_W_OPSIZE, /* 6360 */ + IC_VEX_L_W_OPSIZE, /* 6361 */ + IC_VEX_L_W_OPSIZE, /* 6362 */ + IC_VEX_L_W_OPSIZE, /* 6363 */ + IC_VEX_L_W_OPSIZE, /* 6364 */ + IC_VEX_L_W_OPSIZE, /* 6365 */ + IC_VEX_L_W_OPSIZE, /* 6366 */ + IC_VEX_L_W_OPSIZE, /* 6367 */ + IC_VEX_L, /* 6368 */ + IC_VEX_L, /* 6369 */ + IC_VEX_L_XS, /* 6370 */ + IC_VEX_L_XS, /* 6371 */ + IC_VEX_L_XD, /* 6372 */ + IC_VEX_L_XD, /* 6373 */ + IC_VEX_L_XD, /* 6374 */ + IC_VEX_L_XD, /* 6375 */ + IC_VEX_L_W, /* 6376 */ + IC_VEX_L_W, /* 6377 */ + IC_VEX_L_W_XS, /* 6378 */ + IC_VEX_L_W_XS, /* 6379 */ + IC_VEX_L_W_XD, /* 6380 */ + IC_VEX_L_W_XD, /* 6381 */ + IC_VEX_L_W_XD, /* 6382 */ + IC_VEX_L_W_XD, /* 6383 */ + IC_VEX_L_OPSIZE, /* 6384 */ + IC_VEX_L_OPSIZE, /* 6385 */ + IC_VEX_L_OPSIZE, /* 6386 */ + IC_VEX_L_OPSIZE, /* 6387 */ + IC_VEX_L_OPSIZE, /* 6388 */ + IC_VEX_L_OPSIZE, /* 6389 */ + IC_VEX_L_OPSIZE, /* 6390 */ + IC_VEX_L_OPSIZE, /* 6391 */ + IC_VEX_L_W_OPSIZE, /* 6392 */ + IC_VEX_L_W_OPSIZE, /* 6393 */ + IC_VEX_L_W_OPSIZE, /* 6394 */ + IC_VEX_L_W_OPSIZE, /* 6395 */ + IC_VEX_L_W_OPSIZE, /* 6396 */ + IC_VEX_L_W_OPSIZE, /* 6397 */ + IC_VEX_L_W_OPSIZE, /* 6398 */ + IC_VEX_L_W_OPSIZE, /* 6399 */ + IC_EVEX_KZ, /* 6400 */ + IC_EVEX_KZ, /* 6401 */ + IC_EVEX_XS_KZ, /* 6402 */ + IC_EVEX_XS_KZ, /* 6403 */ + IC_EVEX_XD_KZ, /* 6404 */ + IC_EVEX_XD_KZ, /* 6405 */ + IC_EVEX_XD_KZ, /* 6406 */ + IC_EVEX_XD_KZ, /* 6407 */ + IC_EVEX_W_KZ, /* 6408 */ + IC_EVEX_W_KZ, /* 6409 */ + IC_EVEX_W_XS_KZ, /* 6410 */ + IC_EVEX_W_XS_KZ, /* 6411 */ + IC_EVEX_W_XD_KZ, /* 6412 */ + IC_EVEX_W_XD_KZ, /* 6413 */ + IC_EVEX_W_XD_KZ, /* 6414 */ + IC_EVEX_W_XD_KZ, /* 6415 */ + IC_EVEX_OPSIZE_KZ, /* 6416 */ + IC_EVEX_OPSIZE_KZ, /* 6417 */ + IC_EVEX_OPSIZE_KZ, /* 6418 */ + IC_EVEX_OPSIZE_KZ, /* 6419 */ + IC_EVEX_OPSIZE_KZ, /* 6420 */ + IC_EVEX_OPSIZE_KZ, /* 6421 */ + IC_EVEX_OPSIZE_KZ, /* 6422 */ + IC_EVEX_OPSIZE_KZ, /* 6423 */ + IC_EVEX_W_OPSIZE_KZ, /* 6424 */ + IC_EVEX_W_OPSIZE_KZ, /* 6425 */ + IC_EVEX_W_OPSIZE_KZ, /* 6426 */ + IC_EVEX_W_OPSIZE_KZ, /* 6427 */ + IC_EVEX_W_OPSIZE_KZ, /* 6428 */ + IC_EVEX_W_OPSIZE_KZ, /* 6429 */ + IC_EVEX_W_OPSIZE_KZ, /* 6430 */ + IC_EVEX_W_OPSIZE_KZ, /* 6431 */ + IC_EVEX_KZ, /* 6432 */ + IC_EVEX_KZ, /* 6433 */ + IC_EVEX_XS_KZ, /* 6434 */ + IC_EVEX_XS_KZ, /* 6435 */ + IC_EVEX_XD_KZ, /* 6436 */ + IC_EVEX_XD_KZ, /* 6437 */ + IC_EVEX_XD_KZ, /* 6438 */ + IC_EVEX_XD_KZ, /* 6439 */ + IC_EVEX_W_KZ, /* 6440 */ + IC_EVEX_W_KZ, /* 6441 */ + IC_EVEX_W_XS_KZ, /* 6442 */ + IC_EVEX_W_XS_KZ, /* 6443 */ + IC_EVEX_W_XD_KZ, /* 6444 */ + IC_EVEX_W_XD_KZ, /* 6445 */ + IC_EVEX_W_XD_KZ, /* 6446 */ + IC_EVEX_W_XD_KZ, /* 6447 */ + IC_EVEX_OPSIZE_KZ, /* 6448 */ + IC_EVEX_OPSIZE_KZ, /* 6449 */ + IC_EVEX_OPSIZE_KZ, /* 6450 */ + IC_EVEX_OPSIZE_KZ, /* 6451 */ + IC_EVEX_OPSIZE_KZ, /* 6452 */ + IC_EVEX_OPSIZE_KZ, /* 6453 */ + IC_EVEX_OPSIZE_KZ, /* 6454 */ + IC_EVEX_OPSIZE_KZ, /* 6455 */ + IC_EVEX_W_OPSIZE_KZ, /* 6456 */ + IC_EVEX_W_OPSIZE_KZ, /* 6457 */ + IC_EVEX_W_OPSIZE_KZ, /* 6458 */ + IC_EVEX_W_OPSIZE_KZ, /* 6459 */ + IC_EVEX_W_OPSIZE_KZ, /* 6460 */ + IC_EVEX_W_OPSIZE_KZ, /* 6461 */ + IC_EVEX_W_OPSIZE_KZ, /* 6462 */ + IC_EVEX_W_OPSIZE_KZ, /* 6463 */ + IC_EVEX_KZ, /* 6464 */ + IC_EVEX_KZ, /* 6465 */ + IC_EVEX_XS_KZ, /* 6466 */ + IC_EVEX_XS_KZ, /* 6467 */ + IC_EVEX_XD_KZ, /* 6468 */ + IC_EVEX_XD_KZ, /* 6469 */ + IC_EVEX_XD_KZ, /* 6470 */ + IC_EVEX_XD_KZ, /* 6471 */ + IC_EVEX_W_KZ, /* 6472 */ + IC_EVEX_W_KZ, /* 6473 */ + IC_EVEX_W_XS_KZ, /* 6474 */ + IC_EVEX_W_XS_KZ, /* 6475 */ + IC_EVEX_W_XD_KZ, /* 6476 */ + IC_EVEX_W_XD_KZ, /* 6477 */ + IC_EVEX_W_XD_KZ, /* 6478 */ + IC_EVEX_W_XD_KZ, /* 6479 */ + IC_EVEX_OPSIZE_KZ, /* 6480 */ + IC_EVEX_OPSIZE_KZ, /* 6481 */ + IC_EVEX_OPSIZE_KZ, /* 6482 */ + IC_EVEX_OPSIZE_KZ, /* 6483 */ + IC_EVEX_OPSIZE_KZ, /* 6484 */ + IC_EVEX_OPSIZE_KZ, /* 6485 */ + IC_EVEX_OPSIZE_KZ, /* 6486 */ + IC_EVEX_OPSIZE_KZ, /* 6487 */ + IC_EVEX_W_OPSIZE_KZ, /* 6488 */ + IC_EVEX_W_OPSIZE_KZ, /* 6489 */ + IC_EVEX_W_OPSIZE_KZ, /* 6490 */ + IC_EVEX_W_OPSIZE_KZ, /* 6491 */ + IC_EVEX_W_OPSIZE_KZ, /* 6492 */ + IC_EVEX_W_OPSIZE_KZ, /* 6493 */ + IC_EVEX_W_OPSIZE_KZ, /* 6494 */ + IC_EVEX_W_OPSIZE_KZ, /* 6495 */ + IC_EVEX_KZ, /* 6496 */ + IC_EVEX_KZ, /* 6497 */ + IC_EVEX_XS_KZ, /* 6498 */ + IC_EVEX_XS_KZ, /* 6499 */ + IC_EVEX_XD_KZ, /* 6500 */ + IC_EVEX_XD_KZ, /* 6501 */ + IC_EVEX_XD_KZ, /* 6502 */ + IC_EVEX_XD_KZ, /* 6503 */ + IC_EVEX_W_KZ, /* 6504 */ + IC_EVEX_W_KZ, /* 6505 */ + IC_EVEX_W_XS_KZ, /* 6506 */ + IC_EVEX_W_XS_KZ, /* 6507 */ + IC_EVEX_W_XD_KZ, /* 6508 */ + IC_EVEX_W_XD_KZ, /* 6509 */ + IC_EVEX_W_XD_KZ, /* 6510 */ + IC_EVEX_W_XD_KZ, /* 6511 */ + IC_EVEX_OPSIZE_KZ, /* 6512 */ + IC_EVEX_OPSIZE_KZ, /* 6513 */ + IC_EVEX_OPSIZE_KZ, /* 6514 */ + IC_EVEX_OPSIZE_KZ, /* 6515 */ + IC_EVEX_OPSIZE_KZ, /* 6516 */ + IC_EVEX_OPSIZE_KZ, /* 6517 */ + IC_EVEX_OPSIZE_KZ, /* 6518 */ + IC_EVEX_OPSIZE_KZ, /* 6519 */ + IC_EVEX_W_OPSIZE_KZ, /* 6520 */ + IC_EVEX_W_OPSIZE_KZ, /* 6521 */ + IC_EVEX_W_OPSIZE_KZ, /* 6522 */ + IC_EVEX_W_OPSIZE_KZ, /* 6523 */ + IC_EVEX_W_OPSIZE_KZ, /* 6524 */ + IC_EVEX_W_OPSIZE_KZ, /* 6525 */ + IC_EVEX_W_OPSIZE_KZ, /* 6526 */ + IC_EVEX_W_OPSIZE_KZ, /* 6527 */ + IC_EVEX_KZ, /* 6528 */ + IC_EVEX_KZ, /* 6529 */ + IC_EVEX_XS_KZ, /* 6530 */ + IC_EVEX_XS_KZ, /* 6531 */ + IC_EVEX_XD_KZ, /* 6532 */ + IC_EVEX_XD_KZ, /* 6533 */ + IC_EVEX_XD_KZ, /* 6534 */ + IC_EVEX_XD_KZ, /* 6535 */ + IC_EVEX_W_KZ, /* 6536 */ + IC_EVEX_W_KZ, /* 6537 */ + IC_EVEX_W_XS_KZ, /* 6538 */ + IC_EVEX_W_XS_KZ, /* 6539 */ + IC_EVEX_W_XD_KZ, /* 6540 */ + IC_EVEX_W_XD_KZ, /* 6541 */ + IC_EVEX_W_XD_KZ, /* 6542 */ + IC_EVEX_W_XD_KZ, /* 6543 */ + IC_EVEX_OPSIZE_KZ, /* 6544 */ + IC_EVEX_OPSIZE_KZ, /* 6545 */ + IC_EVEX_OPSIZE_KZ, /* 6546 */ + IC_EVEX_OPSIZE_KZ, /* 6547 */ + IC_EVEX_OPSIZE_KZ, /* 6548 */ + IC_EVEX_OPSIZE_KZ, /* 6549 */ + IC_EVEX_OPSIZE_KZ, /* 6550 */ + IC_EVEX_OPSIZE_KZ, /* 6551 */ + IC_EVEX_W_OPSIZE_KZ, /* 6552 */ + IC_EVEX_W_OPSIZE_KZ, /* 6553 */ + IC_EVEX_W_OPSIZE_KZ, /* 6554 */ + IC_EVEX_W_OPSIZE_KZ, /* 6555 */ + IC_EVEX_W_OPSIZE_KZ, /* 6556 */ + IC_EVEX_W_OPSIZE_KZ, /* 6557 */ + IC_EVEX_W_OPSIZE_KZ, /* 6558 */ + IC_EVEX_W_OPSIZE_KZ, /* 6559 */ + IC_EVEX_KZ, /* 6560 */ + IC_EVEX_KZ, /* 6561 */ + IC_EVEX_XS_KZ, /* 6562 */ + IC_EVEX_XS_KZ, /* 6563 */ + IC_EVEX_XD_KZ, /* 6564 */ + IC_EVEX_XD_KZ, /* 6565 */ + IC_EVEX_XD_KZ, /* 6566 */ + IC_EVEX_XD_KZ, /* 6567 */ + IC_EVEX_W_KZ, /* 6568 */ + IC_EVEX_W_KZ, /* 6569 */ + IC_EVEX_W_XS_KZ, /* 6570 */ + IC_EVEX_W_XS_KZ, /* 6571 */ + IC_EVEX_W_XD_KZ, /* 6572 */ + IC_EVEX_W_XD_KZ, /* 6573 */ + IC_EVEX_W_XD_KZ, /* 6574 */ + IC_EVEX_W_XD_KZ, /* 6575 */ + IC_EVEX_OPSIZE_KZ, /* 6576 */ + IC_EVEX_OPSIZE_KZ, /* 6577 */ + IC_EVEX_OPSIZE_KZ, /* 6578 */ + IC_EVEX_OPSIZE_KZ, /* 6579 */ + IC_EVEX_OPSIZE_KZ, /* 6580 */ + IC_EVEX_OPSIZE_KZ, /* 6581 */ + IC_EVEX_OPSIZE_KZ, /* 6582 */ + IC_EVEX_OPSIZE_KZ, /* 6583 */ + IC_EVEX_W_OPSIZE_KZ, /* 6584 */ + IC_EVEX_W_OPSIZE_KZ, /* 6585 */ + IC_EVEX_W_OPSIZE_KZ, /* 6586 */ + IC_EVEX_W_OPSIZE_KZ, /* 6587 */ + IC_EVEX_W_OPSIZE_KZ, /* 6588 */ + IC_EVEX_W_OPSIZE_KZ, /* 6589 */ + IC_EVEX_W_OPSIZE_KZ, /* 6590 */ + IC_EVEX_W_OPSIZE_KZ, /* 6591 */ + IC_EVEX_KZ, /* 6592 */ + IC_EVEX_KZ, /* 6593 */ + IC_EVEX_XS_KZ, /* 6594 */ + IC_EVEX_XS_KZ, /* 6595 */ + IC_EVEX_XD_KZ, /* 6596 */ + IC_EVEX_XD_KZ, /* 6597 */ + IC_EVEX_XD_KZ, /* 6598 */ + IC_EVEX_XD_KZ, /* 6599 */ + IC_EVEX_W_KZ, /* 6600 */ + IC_EVEX_W_KZ, /* 6601 */ + IC_EVEX_W_XS_KZ, /* 6602 */ + IC_EVEX_W_XS_KZ, /* 6603 */ + IC_EVEX_W_XD_KZ, /* 6604 */ + IC_EVEX_W_XD_KZ, /* 6605 */ + IC_EVEX_W_XD_KZ, /* 6606 */ + IC_EVEX_W_XD_KZ, /* 6607 */ + IC_EVEX_OPSIZE_KZ, /* 6608 */ + IC_EVEX_OPSIZE_KZ, /* 6609 */ + IC_EVEX_OPSIZE_KZ, /* 6610 */ + IC_EVEX_OPSIZE_KZ, /* 6611 */ + IC_EVEX_OPSIZE_KZ, /* 6612 */ + IC_EVEX_OPSIZE_KZ, /* 6613 */ + IC_EVEX_OPSIZE_KZ, /* 6614 */ + IC_EVEX_OPSIZE_KZ, /* 6615 */ + IC_EVEX_W_OPSIZE_KZ, /* 6616 */ + IC_EVEX_W_OPSIZE_KZ, /* 6617 */ + IC_EVEX_W_OPSIZE_KZ, /* 6618 */ + IC_EVEX_W_OPSIZE_KZ, /* 6619 */ + IC_EVEX_W_OPSIZE_KZ, /* 6620 */ + IC_EVEX_W_OPSIZE_KZ, /* 6621 */ + IC_EVEX_W_OPSIZE_KZ, /* 6622 */ + IC_EVEX_W_OPSIZE_KZ, /* 6623 */ + IC_EVEX_KZ, /* 6624 */ + IC_EVEX_KZ, /* 6625 */ + IC_EVEX_XS_KZ, /* 6626 */ + IC_EVEX_XS_KZ, /* 6627 */ + IC_EVEX_XD_KZ, /* 6628 */ + IC_EVEX_XD_KZ, /* 6629 */ + IC_EVEX_XD_KZ, /* 6630 */ + IC_EVEX_XD_KZ, /* 6631 */ + IC_EVEX_W_KZ, /* 6632 */ + IC_EVEX_W_KZ, /* 6633 */ + IC_EVEX_W_XS_KZ, /* 6634 */ + IC_EVEX_W_XS_KZ, /* 6635 */ + IC_EVEX_W_XD_KZ, /* 6636 */ + IC_EVEX_W_XD_KZ, /* 6637 */ + IC_EVEX_W_XD_KZ, /* 6638 */ + IC_EVEX_W_XD_KZ, /* 6639 */ + IC_EVEX_OPSIZE_KZ, /* 6640 */ + IC_EVEX_OPSIZE_KZ, /* 6641 */ + IC_EVEX_OPSIZE_KZ, /* 6642 */ + IC_EVEX_OPSIZE_KZ, /* 6643 */ + IC_EVEX_OPSIZE_KZ, /* 6644 */ + IC_EVEX_OPSIZE_KZ, /* 6645 */ + IC_EVEX_OPSIZE_KZ, /* 6646 */ + IC_EVEX_OPSIZE_KZ, /* 6647 */ + IC_EVEX_W_OPSIZE_KZ, /* 6648 */ + IC_EVEX_W_OPSIZE_KZ, /* 6649 */ + IC_EVEX_W_OPSIZE_KZ, /* 6650 */ + IC_EVEX_W_OPSIZE_KZ, /* 6651 */ + IC_EVEX_W_OPSIZE_KZ, /* 6652 */ + IC_EVEX_W_OPSIZE_KZ, /* 6653 */ + IC_EVEX_W_OPSIZE_KZ, /* 6654 */ + IC_EVEX_W_OPSIZE_KZ, /* 6655 */ + IC, /* 6656 */ + IC_64BIT, /* 6657 */ + IC_XS, /* 6658 */ + IC_64BIT_XS, /* 6659 */ + IC_XD, /* 6660 */ + IC_64BIT_XD, /* 6661 */ + IC_XS, /* 6662 */ + IC_64BIT_XS, /* 6663 */ + IC, /* 6664 */ + IC_64BIT_REXW, /* 6665 */ + IC_XS, /* 6666 */ + IC_64BIT_REXW_XS, /* 6667 */ + IC_XD, /* 6668 */ + IC_64BIT_REXW_XD, /* 6669 */ + IC_XS, /* 6670 */ + IC_64BIT_REXW_XS, /* 6671 */ + IC_OPSIZE, /* 6672 */ + IC_64BIT_OPSIZE, /* 6673 */ + IC_XS_OPSIZE, /* 6674 */ + IC_64BIT_XS_OPSIZE, /* 6675 */ + IC_XD_OPSIZE, /* 6676 */ + IC_64BIT_XD_OPSIZE, /* 6677 */ + IC_XS_OPSIZE, /* 6678 */ + IC_64BIT_XD_OPSIZE, /* 6679 */ + IC_OPSIZE, /* 6680 */ + IC_64BIT_REXW_OPSIZE, /* 6681 */ + IC_XS_OPSIZE, /* 6682 */ + IC_64BIT_REXW_XS, /* 6683 */ + IC_XD_OPSIZE, /* 6684 */ + IC_64BIT_REXW_XD, /* 6685 */ + IC_XS_OPSIZE, /* 6686 */ + IC_64BIT_REXW_XS, /* 6687 */ + IC_ADSIZE, /* 6688 */ + IC_64BIT_ADSIZE, /* 6689 */ + IC_XS_ADSIZE, /* 6690 */ + IC_64BIT_XS_ADSIZE, /* 6691 */ + IC_XD_ADSIZE, /* 6692 */ + IC_64BIT_XD_ADSIZE, /* 6693 */ + IC_XS_ADSIZE, /* 6694 */ + IC_64BIT_XD_ADSIZE, /* 6695 */ + IC_ADSIZE, /* 6696 */ + IC_64BIT_REXW_ADSIZE, /* 6697 */ + IC_XS_ADSIZE, /* 6698 */ + IC_64BIT_REXW_XS, /* 6699 */ + IC_XD_ADSIZE, /* 6700 */ + IC_64BIT_REXW_XD, /* 6701 */ + IC_XS_ADSIZE, /* 6702 */ + IC_64BIT_REXW_XS, /* 6703 */ + IC_OPSIZE_ADSIZE, /* 6704 */ + IC_64BIT_OPSIZE_ADSIZE, /* 6705 */ + IC_XS_OPSIZE, /* 6706 */ + IC_64BIT_XS_OPSIZE, /* 6707 */ + IC_XD_OPSIZE, /* 6708 */ + IC_64BIT_XD_OPSIZE, /* 6709 */ + IC_XS_OPSIZE, /* 6710 */ + IC_64BIT_XD_OPSIZE, /* 6711 */ + IC_OPSIZE_ADSIZE, /* 6712 */ + IC_64BIT_REXW_OPSIZE, /* 6713 */ + IC_XS_OPSIZE, /* 6714 */ + IC_64BIT_REXW_XS, /* 6715 */ + IC_XD_OPSIZE, /* 6716 */ + IC_64BIT_REXW_XD, /* 6717 */ + IC_XS_OPSIZE, /* 6718 */ + IC_64BIT_REXW_XS, /* 6719 */ + IC_VEX, /* 6720 */ + IC_VEX, /* 6721 */ + IC_VEX_XS, /* 6722 */ + IC_VEX_XS, /* 6723 */ + IC_VEX_XD, /* 6724 */ + IC_VEX_XD, /* 6725 */ + IC_VEX_XD, /* 6726 */ + IC_VEX_XD, /* 6727 */ + IC_VEX_W, /* 6728 */ + IC_VEX_W, /* 6729 */ + IC_VEX_W_XS, /* 6730 */ + IC_VEX_W_XS, /* 6731 */ + IC_VEX_W_XD, /* 6732 */ + IC_VEX_W_XD, /* 6733 */ + IC_VEX_W_XD, /* 6734 */ + IC_VEX_W_XD, /* 6735 */ + IC_VEX_OPSIZE, /* 6736 */ + IC_VEX_OPSIZE, /* 6737 */ + IC_VEX_OPSIZE, /* 6738 */ + IC_VEX_OPSIZE, /* 6739 */ + IC_VEX_OPSIZE, /* 6740 */ + IC_VEX_OPSIZE, /* 6741 */ + IC_VEX_OPSIZE, /* 6742 */ + IC_VEX_OPSIZE, /* 6743 */ + IC_VEX_W_OPSIZE, /* 6744 */ + IC_VEX_W_OPSIZE, /* 6745 */ + IC_VEX_W_OPSIZE, /* 6746 */ + IC_VEX_W_OPSIZE, /* 6747 */ + IC_VEX_W_OPSIZE, /* 6748 */ + IC_VEX_W_OPSIZE, /* 6749 */ + IC_VEX_W_OPSIZE, /* 6750 */ + IC_VEX_W_OPSIZE, /* 6751 */ + IC_VEX, /* 6752 */ + IC_VEX, /* 6753 */ + IC_VEX_XS, /* 6754 */ + IC_VEX_XS, /* 6755 */ + IC_VEX_XD, /* 6756 */ + IC_VEX_XD, /* 6757 */ + IC_VEX_XD, /* 6758 */ + IC_VEX_XD, /* 6759 */ + IC_VEX_W, /* 6760 */ + IC_VEX_W, /* 6761 */ + IC_VEX_W_XS, /* 6762 */ + IC_VEX_W_XS, /* 6763 */ + IC_VEX_W_XD, /* 6764 */ + IC_VEX_W_XD, /* 6765 */ + IC_VEX_W_XD, /* 6766 */ + IC_VEX_W_XD, /* 6767 */ + IC_VEX_OPSIZE, /* 6768 */ + IC_VEX_OPSIZE, /* 6769 */ + IC_VEX_OPSIZE, /* 6770 */ + IC_VEX_OPSIZE, /* 6771 */ + IC_VEX_OPSIZE, /* 6772 */ + IC_VEX_OPSIZE, /* 6773 */ + IC_VEX_OPSIZE, /* 6774 */ + IC_VEX_OPSIZE, /* 6775 */ + IC_VEX_W_OPSIZE, /* 6776 */ + IC_VEX_W_OPSIZE, /* 6777 */ + IC_VEX_W_OPSIZE, /* 6778 */ + IC_VEX_W_OPSIZE, /* 6779 */ + IC_VEX_W_OPSIZE, /* 6780 */ + IC_VEX_W_OPSIZE, /* 6781 */ + IC_VEX_W_OPSIZE, /* 6782 */ + IC_VEX_W_OPSIZE, /* 6783 */ + IC_VEX_L, /* 6784 */ + IC_VEX_L, /* 6785 */ + IC_VEX_L_XS, /* 6786 */ + IC_VEX_L_XS, /* 6787 */ + IC_VEX_L_XD, /* 6788 */ + IC_VEX_L_XD, /* 6789 */ + IC_VEX_L_XD, /* 6790 */ + IC_VEX_L_XD, /* 6791 */ + IC_VEX_L_W, /* 6792 */ + IC_VEX_L_W, /* 6793 */ + IC_VEX_L_W_XS, /* 6794 */ + IC_VEX_L_W_XS, /* 6795 */ + IC_VEX_L_W_XD, /* 6796 */ + IC_VEX_L_W_XD, /* 6797 */ + IC_VEX_L_W_XD, /* 6798 */ + IC_VEX_L_W_XD, /* 6799 */ + IC_VEX_L_OPSIZE, /* 6800 */ + IC_VEX_L_OPSIZE, /* 6801 */ + IC_VEX_L_OPSIZE, /* 6802 */ + IC_VEX_L_OPSIZE, /* 6803 */ + IC_VEX_L_OPSIZE, /* 6804 */ + IC_VEX_L_OPSIZE, /* 6805 */ + IC_VEX_L_OPSIZE, /* 6806 */ + IC_VEX_L_OPSIZE, /* 6807 */ + IC_VEX_L_W_OPSIZE, /* 6808 */ + IC_VEX_L_W_OPSIZE, /* 6809 */ + IC_VEX_L_W_OPSIZE, /* 6810 */ + IC_VEX_L_W_OPSIZE, /* 6811 */ + IC_VEX_L_W_OPSIZE, /* 6812 */ + IC_VEX_L_W_OPSIZE, /* 6813 */ + IC_VEX_L_W_OPSIZE, /* 6814 */ + IC_VEX_L_W_OPSIZE, /* 6815 */ + IC_VEX_L, /* 6816 */ + IC_VEX_L, /* 6817 */ + IC_VEX_L_XS, /* 6818 */ + IC_VEX_L_XS, /* 6819 */ + IC_VEX_L_XD, /* 6820 */ + IC_VEX_L_XD, /* 6821 */ + IC_VEX_L_XD, /* 6822 */ + IC_VEX_L_XD, /* 6823 */ + IC_VEX_L_W, /* 6824 */ + IC_VEX_L_W, /* 6825 */ + IC_VEX_L_W_XS, /* 6826 */ + IC_VEX_L_W_XS, /* 6827 */ + IC_VEX_L_W_XD, /* 6828 */ + IC_VEX_L_W_XD, /* 6829 */ + IC_VEX_L_W_XD, /* 6830 */ + IC_VEX_L_W_XD, /* 6831 */ + IC_VEX_L_OPSIZE, /* 6832 */ + IC_VEX_L_OPSIZE, /* 6833 */ + IC_VEX_L_OPSIZE, /* 6834 */ + IC_VEX_L_OPSIZE, /* 6835 */ + IC_VEX_L_OPSIZE, /* 6836 */ + IC_VEX_L_OPSIZE, /* 6837 */ + IC_VEX_L_OPSIZE, /* 6838 */ + IC_VEX_L_OPSIZE, /* 6839 */ + IC_VEX_L_W_OPSIZE, /* 6840 */ + IC_VEX_L_W_OPSIZE, /* 6841 */ + IC_VEX_L_W_OPSIZE, /* 6842 */ + IC_VEX_L_W_OPSIZE, /* 6843 */ + IC_VEX_L_W_OPSIZE, /* 6844 */ + IC_VEX_L_W_OPSIZE, /* 6845 */ + IC_VEX_L_W_OPSIZE, /* 6846 */ + IC_VEX_L_W_OPSIZE, /* 6847 */ + IC_VEX_L, /* 6848 */ + IC_VEX_L, /* 6849 */ + IC_VEX_L_XS, /* 6850 */ + IC_VEX_L_XS, /* 6851 */ + IC_VEX_L_XD, /* 6852 */ + IC_VEX_L_XD, /* 6853 */ + IC_VEX_L_XD, /* 6854 */ + IC_VEX_L_XD, /* 6855 */ + IC_VEX_L_W, /* 6856 */ + IC_VEX_L_W, /* 6857 */ + IC_VEX_L_W_XS, /* 6858 */ + IC_VEX_L_W_XS, /* 6859 */ + IC_VEX_L_W_XD, /* 6860 */ + IC_VEX_L_W_XD, /* 6861 */ + IC_VEX_L_W_XD, /* 6862 */ + IC_VEX_L_W_XD, /* 6863 */ + IC_VEX_L_OPSIZE, /* 6864 */ + IC_VEX_L_OPSIZE, /* 6865 */ + IC_VEX_L_OPSIZE, /* 6866 */ + IC_VEX_L_OPSIZE, /* 6867 */ + IC_VEX_L_OPSIZE, /* 6868 */ + IC_VEX_L_OPSIZE, /* 6869 */ + IC_VEX_L_OPSIZE, /* 6870 */ + IC_VEX_L_OPSIZE, /* 6871 */ + IC_VEX_L_W_OPSIZE, /* 6872 */ + IC_VEX_L_W_OPSIZE, /* 6873 */ + IC_VEX_L_W_OPSIZE, /* 6874 */ + IC_VEX_L_W_OPSIZE, /* 6875 */ + IC_VEX_L_W_OPSIZE, /* 6876 */ + IC_VEX_L_W_OPSIZE, /* 6877 */ + IC_VEX_L_W_OPSIZE, /* 6878 */ + IC_VEX_L_W_OPSIZE, /* 6879 */ + IC_VEX_L, /* 6880 */ + IC_VEX_L, /* 6881 */ + IC_VEX_L_XS, /* 6882 */ + IC_VEX_L_XS, /* 6883 */ + IC_VEX_L_XD, /* 6884 */ + IC_VEX_L_XD, /* 6885 */ + IC_VEX_L_XD, /* 6886 */ + IC_VEX_L_XD, /* 6887 */ + IC_VEX_L_W, /* 6888 */ + IC_VEX_L_W, /* 6889 */ + IC_VEX_L_W_XS, /* 6890 */ + IC_VEX_L_W_XS, /* 6891 */ + IC_VEX_L_W_XD, /* 6892 */ + IC_VEX_L_W_XD, /* 6893 */ + IC_VEX_L_W_XD, /* 6894 */ + IC_VEX_L_W_XD, /* 6895 */ + IC_VEX_L_OPSIZE, /* 6896 */ + IC_VEX_L_OPSIZE, /* 6897 */ + IC_VEX_L_OPSIZE, /* 6898 */ + IC_VEX_L_OPSIZE, /* 6899 */ + IC_VEX_L_OPSIZE, /* 6900 */ + IC_VEX_L_OPSIZE, /* 6901 */ + IC_VEX_L_OPSIZE, /* 6902 */ + IC_VEX_L_OPSIZE, /* 6903 */ + IC_VEX_L_W_OPSIZE, /* 6904 */ + IC_VEX_L_W_OPSIZE, /* 6905 */ + IC_VEX_L_W_OPSIZE, /* 6906 */ + IC_VEX_L_W_OPSIZE, /* 6907 */ + IC_VEX_L_W_OPSIZE, /* 6908 */ + IC_VEX_L_W_OPSIZE, /* 6909 */ + IC_VEX_L_W_OPSIZE, /* 6910 */ + IC_VEX_L_W_OPSIZE, /* 6911 */ + IC_EVEX_L_KZ, /* 6912 */ + IC_EVEX_L_KZ, /* 6913 */ + IC_EVEX_L_XS_KZ, /* 6914 */ + IC_EVEX_L_XS_KZ, /* 6915 */ + IC_EVEX_L_XD_KZ, /* 6916 */ + IC_EVEX_L_XD_KZ, /* 6917 */ + IC_EVEX_L_XD_KZ, /* 6918 */ + IC_EVEX_L_XD_KZ, /* 6919 */ + IC_EVEX_L_W_KZ, /* 6920 */ + IC_EVEX_L_W_KZ, /* 6921 */ + IC_EVEX_L_W_XS_KZ, /* 6922 */ + IC_EVEX_L_W_XS_KZ, /* 6923 */ + IC_EVEX_L_W_XD_KZ, /* 6924 */ + IC_EVEX_L_W_XD_KZ, /* 6925 */ + IC_EVEX_L_W_XD_KZ, /* 6926 */ + IC_EVEX_L_W_XD_KZ, /* 6927 */ + IC_EVEX_L_OPSIZE_KZ, /* 6928 */ + IC_EVEX_L_OPSIZE_KZ, /* 6929 */ + IC_EVEX_L_OPSIZE_KZ, /* 6930 */ + IC_EVEX_L_OPSIZE_KZ, /* 6931 */ + IC_EVEX_L_OPSIZE_KZ, /* 6932 */ + IC_EVEX_L_OPSIZE_KZ, /* 6933 */ + IC_EVEX_L_OPSIZE_KZ, /* 6934 */ + IC_EVEX_L_OPSIZE_KZ, /* 6935 */ + IC_EVEX_L_W_OPSIZE_KZ, /* 6936 */ + IC_EVEX_L_W_OPSIZE_KZ, /* 6937 */ + IC_EVEX_L_W_OPSIZE_KZ, /* 6938 */ + IC_EVEX_L_W_OPSIZE_KZ, /* 6939 */ + IC_EVEX_L_W_OPSIZE_KZ, /* 6940 */ + IC_EVEX_L_W_OPSIZE_KZ, /* 6941 */ + IC_EVEX_L_W_OPSIZE_KZ, /* 6942 */ + IC_EVEX_L_W_OPSIZE_KZ, /* 6943 */ + IC_EVEX_L_KZ, /* 6944 */ + IC_EVEX_L_KZ, /* 6945 */ + IC_EVEX_L_XS_KZ, /* 6946 */ + IC_EVEX_L_XS_KZ, /* 6947 */ + IC_EVEX_L_XD_KZ, /* 6948 */ + IC_EVEX_L_XD_KZ, /* 6949 */ + IC_EVEX_L_XD_KZ, /* 6950 */ + IC_EVEX_L_XD_KZ, /* 6951 */ + IC_EVEX_L_W_KZ, /* 6952 */ + IC_EVEX_L_W_KZ, /* 6953 */ + IC_EVEX_L_W_XS_KZ, /* 6954 */ + IC_EVEX_L_W_XS_KZ, /* 6955 */ + IC_EVEX_L_W_XD_KZ, /* 6956 */ + IC_EVEX_L_W_XD_KZ, /* 6957 */ + IC_EVEX_L_W_XD_KZ, /* 6958 */ + IC_EVEX_L_W_XD_KZ, /* 6959 */ + IC_EVEX_L_OPSIZE_KZ, /* 6960 */ + IC_EVEX_L_OPSIZE_KZ, /* 6961 */ + IC_EVEX_L_OPSIZE_KZ, /* 6962 */ + IC_EVEX_L_OPSIZE_KZ, /* 6963 */ + IC_EVEX_L_OPSIZE_KZ, /* 6964 */ + IC_EVEX_L_OPSIZE_KZ, /* 6965 */ + IC_EVEX_L_OPSIZE_KZ, /* 6966 */ + IC_EVEX_L_OPSIZE_KZ, /* 6967 */ + IC_EVEX_L_W_OPSIZE_KZ, /* 6968 */ + IC_EVEX_L_W_OPSIZE_KZ, /* 6969 */ + IC_EVEX_L_W_OPSIZE_KZ, /* 6970 */ + IC_EVEX_L_W_OPSIZE_KZ, /* 6971 */ + IC_EVEX_L_W_OPSIZE_KZ, /* 6972 */ + IC_EVEX_L_W_OPSIZE_KZ, /* 6973 */ + IC_EVEX_L_W_OPSIZE_KZ, /* 6974 */ + IC_EVEX_L_W_OPSIZE_KZ, /* 6975 */ + IC_EVEX_L_KZ, /* 6976 */ + IC_EVEX_L_KZ, /* 6977 */ + IC_EVEX_L_XS_KZ, /* 6978 */ + IC_EVEX_L_XS_KZ, /* 6979 */ + IC_EVEX_L_XD_KZ, /* 6980 */ + IC_EVEX_L_XD_KZ, /* 6981 */ + IC_EVEX_L_XD_KZ, /* 6982 */ + IC_EVEX_L_XD_KZ, /* 6983 */ + IC_EVEX_L_W_KZ, /* 6984 */ + IC_EVEX_L_W_KZ, /* 6985 */ + IC_EVEX_L_W_XS_KZ, /* 6986 */ + IC_EVEX_L_W_XS_KZ, /* 6987 */ + IC_EVEX_L_W_XD_KZ, /* 6988 */ + IC_EVEX_L_W_XD_KZ, /* 6989 */ + IC_EVEX_L_W_XD_KZ, /* 6990 */ + IC_EVEX_L_W_XD_KZ, /* 6991 */ + IC_EVEX_L_OPSIZE_KZ, /* 6992 */ + IC_EVEX_L_OPSIZE_KZ, /* 6993 */ + IC_EVEX_L_OPSIZE_KZ, /* 6994 */ + IC_EVEX_L_OPSIZE_KZ, /* 6995 */ + IC_EVEX_L_OPSIZE_KZ, /* 6996 */ + IC_EVEX_L_OPSIZE_KZ, /* 6997 */ + IC_EVEX_L_OPSIZE_KZ, /* 6998 */ + IC_EVEX_L_OPSIZE_KZ, /* 6999 */ + IC_EVEX_L_W_OPSIZE_KZ, /* 7000 */ + IC_EVEX_L_W_OPSIZE_KZ, /* 7001 */ + IC_EVEX_L_W_OPSIZE_KZ, /* 7002 */ + IC_EVEX_L_W_OPSIZE_KZ, /* 7003 */ + IC_EVEX_L_W_OPSIZE_KZ, /* 7004 */ + IC_EVEX_L_W_OPSIZE_KZ, /* 7005 */ + IC_EVEX_L_W_OPSIZE_KZ, /* 7006 */ + IC_EVEX_L_W_OPSIZE_KZ, /* 7007 */ + IC_EVEX_L_KZ, /* 7008 */ + IC_EVEX_L_KZ, /* 7009 */ + IC_EVEX_L_XS_KZ, /* 7010 */ + IC_EVEX_L_XS_KZ, /* 7011 */ + IC_EVEX_L_XD_KZ, /* 7012 */ + IC_EVEX_L_XD_KZ, /* 7013 */ + IC_EVEX_L_XD_KZ, /* 7014 */ + IC_EVEX_L_XD_KZ, /* 7015 */ + IC_EVEX_L_W_KZ, /* 7016 */ + IC_EVEX_L_W_KZ, /* 7017 */ + IC_EVEX_L_W_XS_KZ, /* 7018 */ + IC_EVEX_L_W_XS_KZ, /* 7019 */ + IC_EVEX_L_W_XD_KZ, /* 7020 */ + IC_EVEX_L_W_XD_KZ, /* 7021 */ + IC_EVEX_L_W_XD_KZ, /* 7022 */ + IC_EVEX_L_W_XD_KZ, /* 7023 */ + IC_EVEX_L_OPSIZE_KZ, /* 7024 */ + IC_EVEX_L_OPSIZE_KZ, /* 7025 */ + IC_EVEX_L_OPSIZE_KZ, /* 7026 */ + IC_EVEX_L_OPSIZE_KZ, /* 7027 */ + IC_EVEX_L_OPSIZE_KZ, /* 7028 */ + IC_EVEX_L_OPSIZE_KZ, /* 7029 */ + IC_EVEX_L_OPSIZE_KZ, /* 7030 */ + IC_EVEX_L_OPSIZE_KZ, /* 7031 */ + IC_EVEX_L_W_OPSIZE_KZ, /* 7032 */ + IC_EVEX_L_W_OPSIZE_KZ, /* 7033 */ + IC_EVEX_L_W_OPSIZE_KZ, /* 7034 */ + IC_EVEX_L_W_OPSIZE_KZ, /* 7035 */ + IC_EVEX_L_W_OPSIZE_KZ, /* 7036 */ + IC_EVEX_L_W_OPSIZE_KZ, /* 7037 */ + IC_EVEX_L_W_OPSIZE_KZ, /* 7038 */ + IC_EVEX_L_W_OPSIZE_KZ, /* 7039 */ + IC_EVEX_L_KZ, /* 7040 */ + IC_EVEX_L_KZ, /* 7041 */ + IC_EVEX_L_XS_KZ, /* 7042 */ + IC_EVEX_L_XS_KZ, /* 7043 */ + IC_EVEX_L_XD_KZ, /* 7044 */ + IC_EVEX_L_XD_KZ, /* 7045 */ + IC_EVEX_L_XD_KZ, /* 7046 */ + IC_EVEX_L_XD_KZ, /* 7047 */ + IC_EVEX_L_W_KZ, /* 7048 */ + IC_EVEX_L_W_KZ, /* 7049 */ + IC_EVEX_L_W_XS_KZ, /* 7050 */ + IC_EVEX_L_W_XS_KZ, /* 7051 */ + IC_EVEX_L_W_XD_KZ, /* 7052 */ + IC_EVEX_L_W_XD_KZ, /* 7053 */ + IC_EVEX_L_W_XD_KZ, /* 7054 */ + IC_EVEX_L_W_XD_KZ, /* 7055 */ + IC_EVEX_L_OPSIZE_KZ, /* 7056 */ + IC_EVEX_L_OPSIZE_KZ, /* 7057 */ + IC_EVEX_L_OPSIZE_KZ, /* 7058 */ + IC_EVEX_L_OPSIZE_KZ, /* 7059 */ + IC_EVEX_L_OPSIZE_KZ, /* 7060 */ + IC_EVEX_L_OPSIZE_KZ, /* 7061 */ + IC_EVEX_L_OPSIZE_KZ, /* 7062 */ + IC_EVEX_L_OPSIZE_KZ, /* 7063 */ + IC_EVEX_L_W_OPSIZE_KZ, /* 7064 */ + IC_EVEX_L_W_OPSIZE_KZ, /* 7065 */ + IC_EVEX_L_W_OPSIZE_KZ, /* 7066 */ + IC_EVEX_L_W_OPSIZE_KZ, /* 7067 */ + IC_EVEX_L_W_OPSIZE_KZ, /* 7068 */ + IC_EVEX_L_W_OPSIZE_KZ, /* 7069 */ + IC_EVEX_L_W_OPSIZE_KZ, /* 7070 */ + IC_EVEX_L_W_OPSIZE_KZ, /* 7071 */ + IC_EVEX_L_KZ, /* 7072 */ + IC_EVEX_L_KZ, /* 7073 */ + IC_EVEX_L_XS_KZ, /* 7074 */ + IC_EVEX_L_XS_KZ, /* 7075 */ + IC_EVEX_L_XD_KZ, /* 7076 */ + IC_EVEX_L_XD_KZ, /* 7077 */ + IC_EVEX_L_XD_KZ, /* 7078 */ + IC_EVEX_L_XD_KZ, /* 7079 */ + IC_EVEX_L_W_KZ, /* 7080 */ + IC_EVEX_L_W_KZ, /* 7081 */ + IC_EVEX_L_W_XS_KZ, /* 7082 */ + IC_EVEX_L_W_XS_KZ, /* 7083 */ + IC_EVEX_L_W_XD_KZ, /* 7084 */ + IC_EVEX_L_W_XD_KZ, /* 7085 */ + IC_EVEX_L_W_XD_KZ, /* 7086 */ + IC_EVEX_L_W_XD_KZ, /* 7087 */ + IC_EVEX_L_OPSIZE_KZ, /* 7088 */ + IC_EVEX_L_OPSIZE_KZ, /* 7089 */ + IC_EVEX_L_OPSIZE_KZ, /* 7090 */ + IC_EVEX_L_OPSIZE_KZ, /* 7091 */ + IC_EVEX_L_OPSIZE_KZ, /* 7092 */ + IC_EVEX_L_OPSIZE_KZ, /* 7093 */ + IC_EVEX_L_OPSIZE_KZ, /* 7094 */ + IC_EVEX_L_OPSIZE_KZ, /* 7095 */ + IC_EVEX_L_W_OPSIZE_KZ, /* 7096 */ + IC_EVEX_L_W_OPSIZE_KZ, /* 7097 */ + IC_EVEX_L_W_OPSIZE_KZ, /* 7098 */ + IC_EVEX_L_W_OPSIZE_KZ, /* 7099 */ + IC_EVEX_L_W_OPSIZE_KZ, /* 7100 */ + IC_EVEX_L_W_OPSIZE_KZ, /* 7101 */ + IC_EVEX_L_W_OPSIZE_KZ, /* 7102 */ + IC_EVEX_L_W_OPSIZE_KZ, /* 7103 */ + IC_EVEX_L_KZ, /* 7104 */ + IC_EVEX_L_KZ, /* 7105 */ + IC_EVEX_L_XS_KZ, /* 7106 */ + IC_EVEX_L_XS_KZ, /* 7107 */ + IC_EVEX_L_XD_KZ, /* 7108 */ + IC_EVEX_L_XD_KZ, /* 7109 */ + IC_EVEX_L_XD_KZ, /* 7110 */ + IC_EVEX_L_XD_KZ, /* 7111 */ + IC_EVEX_L_W_KZ, /* 7112 */ + IC_EVEX_L_W_KZ, /* 7113 */ + IC_EVEX_L_W_XS_KZ, /* 7114 */ + IC_EVEX_L_W_XS_KZ, /* 7115 */ + IC_EVEX_L_W_XD_KZ, /* 7116 */ + IC_EVEX_L_W_XD_KZ, /* 7117 */ + IC_EVEX_L_W_XD_KZ, /* 7118 */ + IC_EVEX_L_W_XD_KZ, /* 7119 */ + IC_EVEX_L_OPSIZE_KZ, /* 7120 */ + IC_EVEX_L_OPSIZE_KZ, /* 7121 */ + IC_EVEX_L_OPSIZE_KZ, /* 7122 */ + IC_EVEX_L_OPSIZE_KZ, /* 7123 */ + IC_EVEX_L_OPSIZE_KZ, /* 7124 */ + IC_EVEX_L_OPSIZE_KZ, /* 7125 */ + IC_EVEX_L_OPSIZE_KZ, /* 7126 */ + IC_EVEX_L_OPSIZE_KZ, /* 7127 */ + IC_EVEX_L_W_OPSIZE_KZ, /* 7128 */ + IC_EVEX_L_W_OPSIZE_KZ, /* 7129 */ + IC_EVEX_L_W_OPSIZE_KZ, /* 7130 */ + IC_EVEX_L_W_OPSIZE_KZ, /* 7131 */ + IC_EVEX_L_W_OPSIZE_KZ, /* 7132 */ + IC_EVEX_L_W_OPSIZE_KZ, /* 7133 */ + IC_EVEX_L_W_OPSIZE_KZ, /* 7134 */ + IC_EVEX_L_W_OPSIZE_KZ, /* 7135 */ + IC_EVEX_L_KZ, /* 7136 */ + IC_EVEX_L_KZ, /* 7137 */ + IC_EVEX_L_XS_KZ, /* 7138 */ + IC_EVEX_L_XS_KZ, /* 7139 */ + IC_EVEX_L_XD_KZ, /* 7140 */ + IC_EVEX_L_XD_KZ, /* 7141 */ + IC_EVEX_L_XD_KZ, /* 7142 */ + IC_EVEX_L_XD_KZ, /* 7143 */ + IC_EVEX_L_W_KZ, /* 7144 */ + IC_EVEX_L_W_KZ, /* 7145 */ + IC_EVEX_L_W_XS_KZ, /* 7146 */ + IC_EVEX_L_W_XS_KZ, /* 7147 */ + IC_EVEX_L_W_XD_KZ, /* 7148 */ + IC_EVEX_L_W_XD_KZ, /* 7149 */ + IC_EVEX_L_W_XD_KZ, /* 7150 */ + IC_EVEX_L_W_XD_KZ, /* 7151 */ + IC_EVEX_L_OPSIZE_KZ, /* 7152 */ + IC_EVEX_L_OPSIZE_KZ, /* 7153 */ + IC_EVEX_L_OPSIZE_KZ, /* 7154 */ + IC_EVEX_L_OPSIZE_KZ, /* 7155 */ + IC_EVEX_L_OPSIZE_KZ, /* 7156 */ + IC_EVEX_L_OPSIZE_KZ, /* 7157 */ + IC_EVEX_L_OPSIZE_KZ, /* 7158 */ + IC_EVEX_L_OPSIZE_KZ, /* 7159 */ + IC_EVEX_L_W_OPSIZE_KZ, /* 7160 */ + IC_EVEX_L_W_OPSIZE_KZ, /* 7161 */ + IC_EVEX_L_W_OPSIZE_KZ, /* 7162 */ + IC_EVEX_L_W_OPSIZE_KZ, /* 7163 */ + IC_EVEX_L_W_OPSIZE_KZ, /* 7164 */ + IC_EVEX_L_W_OPSIZE_KZ, /* 7165 */ + IC_EVEX_L_W_OPSIZE_KZ, /* 7166 */ + IC_EVEX_L_W_OPSIZE_KZ, /* 7167 */ + IC, /* 7168 */ + IC_64BIT, /* 7169 */ + IC_XS, /* 7170 */ + IC_64BIT_XS, /* 7171 */ + IC_XD, /* 7172 */ + IC_64BIT_XD, /* 7173 */ + IC_XS, /* 7174 */ + IC_64BIT_XS, /* 7175 */ + IC, /* 7176 */ + IC_64BIT_REXW, /* 7177 */ + IC_XS, /* 7178 */ + IC_64BIT_REXW_XS, /* 7179 */ + IC_XD, /* 7180 */ + IC_64BIT_REXW_XD, /* 7181 */ + IC_XS, /* 7182 */ + IC_64BIT_REXW_XS, /* 7183 */ + IC_OPSIZE, /* 7184 */ + IC_64BIT_OPSIZE, /* 7185 */ + IC_XS_OPSIZE, /* 7186 */ + IC_64BIT_XS_OPSIZE, /* 7187 */ + IC_XD_OPSIZE, /* 7188 */ + IC_64BIT_XD_OPSIZE, /* 7189 */ + IC_XS_OPSIZE, /* 7190 */ + IC_64BIT_XD_OPSIZE, /* 7191 */ + IC_OPSIZE, /* 7192 */ + IC_64BIT_REXW_OPSIZE, /* 7193 */ + IC_XS_OPSIZE, /* 7194 */ + IC_64BIT_REXW_XS, /* 7195 */ + IC_XD_OPSIZE, /* 7196 */ + IC_64BIT_REXW_XD, /* 7197 */ + IC_XS_OPSIZE, /* 7198 */ + IC_64BIT_REXW_XS, /* 7199 */ + IC_ADSIZE, /* 7200 */ + IC_64BIT_ADSIZE, /* 7201 */ + IC_XS_ADSIZE, /* 7202 */ + IC_64BIT_XS_ADSIZE, /* 7203 */ + IC_XD_ADSIZE, /* 7204 */ + IC_64BIT_XD_ADSIZE, /* 7205 */ + IC_XS_ADSIZE, /* 7206 */ + IC_64BIT_XD_ADSIZE, /* 7207 */ + IC_ADSIZE, /* 7208 */ + IC_64BIT_REXW_ADSIZE, /* 7209 */ + IC_XS_ADSIZE, /* 7210 */ + IC_64BIT_REXW_XS, /* 7211 */ + IC_XD_ADSIZE, /* 7212 */ + IC_64BIT_REXW_XD, /* 7213 */ + IC_XS_ADSIZE, /* 7214 */ + IC_64BIT_REXW_XS, /* 7215 */ + IC_OPSIZE_ADSIZE, /* 7216 */ + IC_64BIT_OPSIZE_ADSIZE, /* 7217 */ + IC_XS_OPSIZE, /* 7218 */ + IC_64BIT_XS_OPSIZE, /* 7219 */ + IC_XD_OPSIZE, /* 7220 */ + IC_64BIT_XD_OPSIZE, /* 7221 */ + IC_XS_OPSIZE, /* 7222 */ + IC_64BIT_XD_OPSIZE, /* 7223 */ + IC_OPSIZE_ADSIZE, /* 7224 */ + IC_64BIT_REXW_OPSIZE, /* 7225 */ + IC_XS_OPSIZE, /* 7226 */ + IC_64BIT_REXW_XS, /* 7227 */ + IC_XD_OPSIZE, /* 7228 */ + IC_64BIT_REXW_XD, /* 7229 */ + IC_XS_OPSIZE, /* 7230 */ + IC_64BIT_REXW_XS, /* 7231 */ + IC_VEX, /* 7232 */ + IC_VEX, /* 7233 */ + IC_VEX_XS, /* 7234 */ + IC_VEX_XS, /* 7235 */ + IC_VEX_XD, /* 7236 */ + IC_VEX_XD, /* 7237 */ + IC_VEX_XD, /* 7238 */ + IC_VEX_XD, /* 7239 */ + IC_VEX_W, /* 7240 */ + IC_VEX_W, /* 7241 */ + IC_VEX_W_XS, /* 7242 */ + IC_VEX_W_XS, /* 7243 */ + IC_VEX_W_XD, /* 7244 */ + IC_VEX_W_XD, /* 7245 */ + IC_VEX_W_XD, /* 7246 */ + IC_VEX_W_XD, /* 7247 */ + IC_VEX_OPSIZE, /* 7248 */ + IC_VEX_OPSIZE, /* 7249 */ + IC_VEX_OPSIZE, /* 7250 */ + IC_VEX_OPSIZE, /* 7251 */ + IC_VEX_OPSIZE, /* 7252 */ + IC_VEX_OPSIZE, /* 7253 */ + IC_VEX_OPSIZE, /* 7254 */ + IC_VEX_OPSIZE, /* 7255 */ + IC_VEX_W_OPSIZE, /* 7256 */ + IC_VEX_W_OPSIZE, /* 7257 */ + IC_VEX_W_OPSIZE, /* 7258 */ + IC_VEX_W_OPSIZE, /* 7259 */ + IC_VEX_W_OPSIZE, /* 7260 */ + IC_VEX_W_OPSIZE, /* 7261 */ + IC_VEX_W_OPSIZE, /* 7262 */ + IC_VEX_W_OPSIZE, /* 7263 */ + IC_VEX, /* 7264 */ + IC_VEX, /* 7265 */ + IC_VEX_XS, /* 7266 */ + IC_VEX_XS, /* 7267 */ + IC_VEX_XD, /* 7268 */ + IC_VEX_XD, /* 7269 */ + IC_VEX_XD, /* 7270 */ + IC_VEX_XD, /* 7271 */ + IC_VEX_W, /* 7272 */ + IC_VEX_W, /* 7273 */ + IC_VEX_W_XS, /* 7274 */ + IC_VEX_W_XS, /* 7275 */ + IC_VEX_W_XD, /* 7276 */ + IC_VEX_W_XD, /* 7277 */ + IC_VEX_W_XD, /* 7278 */ + IC_VEX_W_XD, /* 7279 */ + IC_VEX_OPSIZE, /* 7280 */ + IC_VEX_OPSIZE, /* 7281 */ + IC_VEX_OPSIZE, /* 7282 */ + IC_VEX_OPSIZE, /* 7283 */ + IC_VEX_OPSIZE, /* 7284 */ + IC_VEX_OPSIZE, /* 7285 */ + IC_VEX_OPSIZE, /* 7286 */ + IC_VEX_OPSIZE, /* 7287 */ + IC_VEX_W_OPSIZE, /* 7288 */ + IC_VEX_W_OPSIZE, /* 7289 */ + IC_VEX_W_OPSIZE, /* 7290 */ + IC_VEX_W_OPSIZE, /* 7291 */ + IC_VEX_W_OPSIZE, /* 7292 */ + IC_VEX_W_OPSIZE, /* 7293 */ + IC_VEX_W_OPSIZE, /* 7294 */ + IC_VEX_W_OPSIZE, /* 7295 */ + IC_VEX_L, /* 7296 */ + IC_VEX_L, /* 7297 */ + IC_VEX_L_XS, /* 7298 */ + IC_VEX_L_XS, /* 7299 */ + IC_VEX_L_XD, /* 7300 */ + IC_VEX_L_XD, /* 7301 */ + IC_VEX_L_XD, /* 7302 */ + IC_VEX_L_XD, /* 7303 */ + IC_VEX_L_W, /* 7304 */ + IC_VEX_L_W, /* 7305 */ + IC_VEX_L_W_XS, /* 7306 */ + IC_VEX_L_W_XS, /* 7307 */ + IC_VEX_L_W_XD, /* 7308 */ + IC_VEX_L_W_XD, /* 7309 */ + IC_VEX_L_W_XD, /* 7310 */ + IC_VEX_L_W_XD, /* 7311 */ + IC_VEX_L_OPSIZE, /* 7312 */ + IC_VEX_L_OPSIZE, /* 7313 */ + IC_VEX_L_OPSIZE, /* 7314 */ + IC_VEX_L_OPSIZE, /* 7315 */ + IC_VEX_L_OPSIZE, /* 7316 */ + IC_VEX_L_OPSIZE, /* 7317 */ + IC_VEX_L_OPSIZE, /* 7318 */ + IC_VEX_L_OPSIZE, /* 7319 */ + IC_VEX_L_W_OPSIZE, /* 7320 */ + IC_VEX_L_W_OPSIZE, /* 7321 */ + IC_VEX_L_W_OPSIZE, /* 7322 */ + IC_VEX_L_W_OPSIZE, /* 7323 */ + IC_VEX_L_W_OPSIZE, /* 7324 */ + IC_VEX_L_W_OPSIZE, /* 7325 */ + IC_VEX_L_W_OPSIZE, /* 7326 */ + IC_VEX_L_W_OPSIZE, /* 7327 */ + IC_VEX_L, /* 7328 */ + IC_VEX_L, /* 7329 */ + IC_VEX_L_XS, /* 7330 */ + IC_VEX_L_XS, /* 7331 */ + IC_VEX_L_XD, /* 7332 */ + IC_VEX_L_XD, /* 7333 */ + IC_VEX_L_XD, /* 7334 */ + IC_VEX_L_XD, /* 7335 */ + IC_VEX_L_W, /* 7336 */ + IC_VEX_L_W, /* 7337 */ + IC_VEX_L_W_XS, /* 7338 */ + IC_VEX_L_W_XS, /* 7339 */ + IC_VEX_L_W_XD, /* 7340 */ + IC_VEX_L_W_XD, /* 7341 */ + IC_VEX_L_W_XD, /* 7342 */ + IC_VEX_L_W_XD, /* 7343 */ + IC_VEX_L_OPSIZE, /* 7344 */ + IC_VEX_L_OPSIZE, /* 7345 */ + IC_VEX_L_OPSIZE, /* 7346 */ + IC_VEX_L_OPSIZE, /* 7347 */ + IC_VEX_L_OPSIZE, /* 7348 */ + IC_VEX_L_OPSIZE, /* 7349 */ + IC_VEX_L_OPSIZE, /* 7350 */ + IC_VEX_L_OPSIZE, /* 7351 */ + IC_VEX_L_W_OPSIZE, /* 7352 */ + IC_VEX_L_W_OPSIZE, /* 7353 */ + IC_VEX_L_W_OPSIZE, /* 7354 */ + IC_VEX_L_W_OPSIZE, /* 7355 */ + IC_VEX_L_W_OPSIZE, /* 7356 */ + IC_VEX_L_W_OPSIZE, /* 7357 */ + IC_VEX_L_W_OPSIZE, /* 7358 */ + IC_VEX_L_W_OPSIZE, /* 7359 */ + IC_VEX_L, /* 7360 */ + IC_VEX_L, /* 7361 */ + IC_VEX_L_XS, /* 7362 */ + IC_VEX_L_XS, /* 7363 */ + IC_VEX_L_XD, /* 7364 */ + IC_VEX_L_XD, /* 7365 */ + IC_VEX_L_XD, /* 7366 */ + IC_VEX_L_XD, /* 7367 */ + IC_VEX_L_W, /* 7368 */ + IC_VEX_L_W, /* 7369 */ + IC_VEX_L_W_XS, /* 7370 */ + IC_VEX_L_W_XS, /* 7371 */ + IC_VEX_L_W_XD, /* 7372 */ + IC_VEX_L_W_XD, /* 7373 */ + IC_VEX_L_W_XD, /* 7374 */ + IC_VEX_L_W_XD, /* 7375 */ + IC_VEX_L_OPSIZE, /* 7376 */ + IC_VEX_L_OPSIZE, /* 7377 */ + IC_VEX_L_OPSIZE, /* 7378 */ + IC_VEX_L_OPSIZE, /* 7379 */ + IC_VEX_L_OPSIZE, /* 7380 */ + IC_VEX_L_OPSIZE, /* 7381 */ + IC_VEX_L_OPSIZE, /* 7382 */ + IC_VEX_L_OPSIZE, /* 7383 */ + IC_VEX_L_W_OPSIZE, /* 7384 */ + IC_VEX_L_W_OPSIZE, /* 7385 */ + IC_VEX_L_W_OPSIZE, /* 7386 */ + IC_VEX_L_W_OPSIZE, /* 7387 */ + IC_VEX_L_W_OPSIZE, /* 7388 */ + IC_VEX_L_W_OPSIZE, /* 7389 */ + IC_VEX_L_W_OPSIZE, /* 7390 */ + IC_VEX_L_W_OPSIZE, /* 7391 */ + IC_VEX_L, /* 7392 */ + IC_VEX_L, /* 7393 */ + IC_VEX_L_XS, /* 7394 */ + IC_VEX_L_XS, /* 7395 */ + IC_VEX_L_XD, /* 7396 */ + IC_VEX_L_XD, /* 7397 */ + IC_VEX_L_XD, /* 7398 */ + IC_VEX_L_XD, /* 7399 */ + IC_VEX_L_W, /* 7400 */ + IC_VEX_L_W, /* 7401 */ + IC_VEX_L_W_XS, /* 7402 */ + IC_VEX_L_W_XS, /* 7403 */ + IC_VEX_L_W_XD, /* 7404 */ + IC_VEX_L_W_XD, /* 7405 */ + IC_VEX_L_W_XD, /* 7406 */ + IC_VEX_L_W_XD, /* 7407 */ + IC_VEX_L_OPSIZE, /* 7408 */ + IC_VEX_L_OPSIZE, /* 7409 */ + IC_VEX_L_OPSIZE, /* 7410 */ + IC_VEX_L_OPSIZE, /* 7411 */ + IC_VEX_L_OPSIZE, /* 7412 */ + IC_VEX_L_OPSIZE, /* 7413 */ + IC_VEX_L_OPSIZE, /* 7414 */ + IC_VEX_L_OPSIZE, /* 7415 */ + IC_VEX_L_W_OPSIZE, /* 7416 */ + IC_VEX_L_W_OPSIZE, /* 7417 */ + IC_VEX_L_W_OPSIZE, /* 7418 */ + IC_VEX_L_W_OPSIZE, /* 7419 */ + IC_VEX_L_W_OPSIZE, /* 7420 */ + IC_VEX_L_W_OPSIZE, /* 7421 */ + IC_VEX_L_W_OPSIZE, /* 7422 */ + IC_VEX_L_W_OPSIZE, /* 7423 */ + IC_EVEX_L2_KZ, /* 7424 */ + IC_EVEX_L2_KZ, /* 7425 */ + IC_EVEX_L2_XS_KZ, /* 7426 */ + IC_EVEX_L2_XS_KZ, /* 7427 */ + IC_EVEX_L2_XD_KZ, /* 7428 */ + IC_EVEX_L2_XD_KZ, /* 7429 */ + IC_EVEX_L2_XD_KZ, /* 7430 */ + IC_EVEX_L2_XD_KZ, /* 7431 */ + IC_EVEX_L2_W_KZ, /* 7432 */ + IC_EVEX_L2_W_KZ, /* 7433 */ + IC_EVEX_L2_W_XS_KZ, /* 7434 */ + IC_EVEX_L2_W_XS_KZ, /* 7435 */ + IC_EVEX_L2_W_XD_KZ, /* 7436 */ + IC_EVEX_L2_W_XD_KZ, /* 7437 */ + IC_EVEX_L2_W_XD_KZ, /* 7438 */ + IC_EVEX_L2_W_XD_KZ, /* 7439 */ + IC_EVEX_L2_OPSIZE_KZ, /* 7440 */ + IC_EVEX_L2_OPSIZE_KZ, /* 7441 */ + IC_EVEX_L2_OPSIZE_KZ, /* 7442 */ + IC_EVEX_L2_OPSIZE_KZ, /* 7443 */ + IC_EVEX_L2_OPSIZE_KZ, /* 7444 */ + IC_EVEX_L2_OPSIZE_KZ, /* 7445 */ + IC_EVEX_L2_OPSIZE_KZ, /* 7446 */ + IC_EVEX_L2_OPSIZE_KZ, /* 7447 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 7448 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 7449 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 7450 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 7451 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 7452 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 7453 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 7454 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 7455 */ + IC_EVEX_L2_KZ, /* 7456 */ + IC_EVEX_L2_KZ, /* 7457 */ + IC_EVEX_L2_XS_KZ, /* 7458 */ + IC_EVEX_L2_XS_KZ, /* 7459 */ + IC_EVEX_L2_XD_KZ, /* 7460 */ + IC_EVEX_L2_XD_KZ, /* 7461 */ + IC_EVEX_L2_XD_KZ, /* 7462 */ + IC_EVEX_L2_XD_KZ, /* 7463 */ + IC_EVEX_L2_W_KZ, /* 7464 */ + IC_EVEX_L2_W_KZ, /* 7465 */ + IC_EVEX_L2_W_XS_KZ, /* 7466 */ + IC_EVEX_L2_W_XS_KZ, /* 7467 */ + IC_EVEX_L2_W_XD_KZ, /* 7468 */ + IC_EVEX_L2_W_XD_KZ, /* 7469 */ + IC_EVEX_L2_W_XD_KZ, /* 7470 */ + IC_EVEX_L2_W_XD_KZ, /* 7471 */ + IC_EVEX_L2_OPSIZE_KZ, /* 7472 */ + IC_EVEX_L2_OPSIZE_KZ, /* 7473 */ + IC_EVEX_L2_OPSIZE_KZ, /* 7474 */ + IC_EVEX_L2_OPSIZE_KZ, /* 7475 */ + IC_EVEX_L2_OPSIZE_KZ, /* 7476 */ + IC_EVEX_L2_OPSIZE_KZ, /* 7477 */ + IC_EVEX_L2_OPSIZE_KZ, /* 7478 */ + IC_EVEX_L2_OPSIZE_KZ, /* 7479 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 7480 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 7481 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 7482 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 7483 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 7484 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 7485 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 7486 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 7487 */ + IC_EVEX_L2_KZ, /* 7488 */ + IC_EVEX_L2_KZ, /* 7489 */ + IC_EVEX_L2_XS_KZ, /* 7490 */ + IC_EVEX_L2_XS_KZ, /* 7491 */ + IC_EVEX_L2_XD_KZ, /* 7492 */ + IC_EVEX_L2_XD_KZ, /* 7493 */ + IC_EVEX_L2_XD_KZ, /* 7494 */ + IC_EVEX_L2_XD_KZ, /* 7495 */ + IC_EVEX_L2_W_KZ, /* 7496 */ + IC_EVEX_L2_W_KZ, /* 7497 */ + IC_EVEX_L2_W_XS_KZ, /* 7498 */ + IC_EVEX_L2_W_XS_KZ, /* 7499 */ + IC_EVEX_L2_W_XD_KZ, /* 7500 */ + IC_EVEX_L2_W_XD_KZ, /* 7501 */ + IC_EVEX_L2_W_XD_KZ, /* 7502 */ + IC_EVEX_L2_W_XD_KZ, /* 7503 */ + IC_EVEX_L2_OPSIZE_KZ, /* 7504 */ + IC_EVEX_L2_OPSIZE_KZ, /* 7505 */ + IC_EVEX_L2_OPSIZE_KZ, /* 7506 */ + IC_EVEX_L2_OPSIZE_KZ, /* 7507 */ + IC_EVEX_L2_OPSIZE_KZ, /* 7508 */ + IC_EVEX_L2_OPSIZE_KZ, /* 7509 */ + IC_EVEX_L2_OPSIZE_KZ, /* 7510 */ + IC_EVEX_L2_OPSIZE_KZ, /* 7511 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 7512 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 7513 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 7514 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 7515 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 7516 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 7517 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 7518 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 7519 */ + IC_EVEX_L2_KZ, /* 7520 */ + IC_EVEX_L2_KZ, /* 7521 */ + IC_EVEX_L2_XS_KZ, /* 7522 */ + IC_EVEX_L2_XS_KZ, /* 7523 */ + IC_EVEX_L2_XD_KZ, /* 7524 */ + IC_EVEX_L2_XD_KZ, /* 7525 */ + IC_EVEX_L2_XD_KZ, /* 7526 */ + IC_EVEX_L2_XD_KZ, /* 7527 */ + IC_EVEX_L2_W_KZ, /* 7528 */ + IC_EVEX_L2_W_KZ, /* 7529 */ + IC_EVEX_L2_W_XS_KZ, /* 7530 */ + IC_EVEX_L2_W_XS_KZ, /* 7531 */ + IC_EVEX_L2_W_XD_KZ, /* 7532 */ + IC_EVEX_L2_W_XD_KZ, /* 7533 */ + IC_EVEX_L2_W_XD_KZ, /* 7534 */ + IC_EVEX_L2_W_XD_KZ, /* 7535 */ + IC_EVEX_L2_OPSIZE_KZ, /* 7536 */ + IC_EVEX_L2_OPSIZE_KZ, /* 7537 */ + IC_EVEX_L2_OPSIZE_KZ, /* 7538 */ + IC_EVEX_L2_OPSIZE_KZ, /* 7539 */ + IC_EVEX_L2_OPSIZE_KZ, /* 7540 */ + IC_EVEX_L2_OPSIZE_KZ, /* 7541 */ + IC_EVEX_L2_OPSIZE_KZ, /* 7542 */ + IC_EVEX_L2_OPSIZE_KZ, /* 7543 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 7544 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 7545 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 7546 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 7547 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 7548 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 7549 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 7550 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 7551 */ + IC_EVEX_L2_KZ, /* 7552 */ + IC_EVEX_L2_KZ, /* 7553 */ + IC_EVEX_L2_XS_KZ, /* 7554 */ + IC_EVEX_L2_XS_KZ, /* 7555 */ + IC_EVEX_L2_XD_KZ, /* 7556 */ + IC_EVEX_L2_XD_KZ, /* 7557 */ + IC_EVEX_L2_XD_KZ, /* 7558 */ + IC_EVEX_L2_XD_KZ, /* 7559 */ + IC_EVEX_L2_W_KZ, /* 7560 */ + IC_EVEX_L2_W_KZ, /* 7561 */ + IC_EVEX_L2_W_XS_KZ, /* 7562 */ + IC_EVEX_L2_W_XS_KZ, /* 7563 */ + IC_EVEX_L2_W_XD_KZ, /* 7564 */ + IC_EVEX_L2_W_XD_KZ, /* 7565 */ + IC_EVEX_L2_W_XD_KZ, /* 7566 */ + IC_EVEX_L2_W_XD_KZ, /* 7567 */ + IC_EVEX_L2_OPSIZE_KZ, /* 7568 */ + IC_EVEX_L2_OPSIZE_KZ, /* 7569 */ + IC_EVEX_L2_OPSIZE_KZ, /* 7570 */ + IC_EVEX_L2_OPSIZE_KZ, /* 7571 */ + IC_EVEX_L2_OPSIZE_KZ, /* 7572 */ + IC_EVEX_L2_OPSIZE_KZ, /* 7573 */ + IC_EVEX_L2_OPSIZE_KZ, /* 7574 */ + IC_EVEX_L2_OPSIZE_KZ, /* 7575 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 7576 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 7577 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 7578 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 7579 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 7580 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 7581 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 7582 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 7583 */ + IC_EVEX_L2_KZ, /* 7584 */ + IC_EVEX_L2_KZ, /* 7585 */ + IC_EVEX_L2_XS_KZ, /* 7586 */ + IC_EVEX_L2_XS_KZ, /* 7587 */ + IC_EVEX_L2_XD_KZ, /* 7588 */ + IC_EVEX_L2_XD_KZ, /* 7589 */ + IC_EVEX_L2_XD_KZ, /* 7590 */ + IC_EVEX_L2_XD_KZ, /* 7591 */ + IC_EVEX_L2_W_KZ, /* 7592 */ + IC_EVEX_L2_W_KZ, /* 7593 */ + IC_EVEX_L2_W_XS_KZ, /* 7594 */ + IC_EVEX_L2_W_XS_KZ, /* 7595 */ + IC_EVEX_L2_W_XD_KZ, /* 7596 */ + IC_EVEX_L2_W_XD_KZ, /* 7597 */ + IC_EVEX_L2_W_XD_KZ, /* 7598 */ + IC_EVEX_L2_W_XD_KZ, /* 7599 */ + IC_EVEX_L2_OPSIZE_KZ, /* 7600 */ + IC_EVEX_L2_OPSIZE_KZ, /* 7601 */ + IC_EVEX_L2_OPSIZE_KZ, /* 7602 */ + IC_EVEX_L2_OPSIZE_KZ, /* 7603 */ + IC_EVEX_L2_OPSIZE_KZ, /* 7604 */ + IC_EVEX_L2_OPSIZE_KZ, /* 7605 */ + IC_EVEX_L2_OPSIZE_KZ, /* 7606 */ + IC_EVEX_L2_OPSIZE_KZ, /* 7607 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 7608 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 7609 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 7610 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 7611 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 7612 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 7613 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 7614 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 7615 */ + IC_EVEX_L2_KZ, /* 7616 */ + IC_EVEX_L2_KZ, /* 7617 */ + IC_EVEX_L2_XS_KZ, /* 7618 */ + IC_EVEX_L2_XS_KZ, /* 7619 */ + IC_EVEX_L2_XD_KZ, /* 7620 */ + IC_EVEX_L2_XD_KZ, /* 7621 */ + IC_EVEX_L2_XD_KZ, /* 7622 */ + IC_EVEX_L2_XD_KZ, /* 7623 */ + IC_EVEX_L2_W_KZ, /* 7624 */ + IC_EVEX_L2_W_KZ, /* 7625 */ + IC_EVEX_L2_W_XS_KZ, /* 7626 */ + IC_EVEX_L2_W_XS_KZ, /* 7627 */ + IC_EVEX_L2_W_XD_KZ, /* 7628 */ + IC_EVEX_L2_W_XD_KZ, /* 7629 */ + IC_EVEX_L2_W_XD_KZ, /* 7630 */ + IC_EVEX_L2_W_XD_KZ, /* 7631 */ + IC_EVEX_L2_OPSIZE_KZ, /* 7632 */ + IC_EVEX_L2_OPSIZE_KZ, /* 7633 */ + IC_EVEX_L2_OPSIZE_KZ, /* 7634 */ + IC_EVEX_L2_OPSIZE_KZ, /* 7635 */ + IC_EVEX_L2_OPSIZE_KZ, /* 7636 */ + IC_EVEX_L2_OPSIZE_KZ, /* 7637 */ + IC_EVEX_L2_OPSIZE_KZ, /* 7638 */ + IC_EVEX_L2_OPSIZE_KZ, /* 7639 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 7640 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 7641 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 7642 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 7643 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 7644 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 7645 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 7646 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 7647 */ + IC_EVEX_L2_KZ, /* 7648 */ + IC_EVEX_L2_KZ, /* 7649 */ + IC_EVEX_L2_XS_KZ, /* 7650 */ + IC_EVEX_L2_XS_KZ, /* 7651 */ + IC_EVEX_L2_XD_KZ, /* 7652 */ + IC_EVEX_L2_XD_KZ, /* 7653 */ + IC_EVEX_L2_XD_KZ, /* 7654 */ + IC_EVEX_L2_XD_KZ, /* 7655 */ + IC_EVEX_L2_W_KZ, /* 7656 */ + IC_EVEX_L2_W_KZ, /* 7657 */ + IC_EVEX_L2_W_XS_KZ, /* 7658 */ + IC_EVEX_L2_W_XS_KZ, /* 7659 */ + IC_EVEX_L2_W_XD_KZ, /* 7660 */ + IC_EVEX_L2_W_XD_KZ, /* 7661 */ + IC_EVEX_L2_W_XD_KZ, /* 7662 */ + IC_EVEX_L2_W_XD_KZ, /* 7663 */ + IC_EVEX_L2_OPSIZE_KZ, /* 7664 */ + IC_EVEX_L2_OPSIZE_KZ, /* 7665 */ + IC_EVEX_L2_OPSIZE_KZ, /* 7666 */ + IC_EVEX_L2_OPSIZE_KZ, /* 7667 */ + IC_EVEX_L2_OPSIZE_KZ, /* 7668 */ + IC_EVEX_L2_OPSIZE_KZ, /* 7669 */ + IC_EVEX_L2_OPSIZE_KZ, /* 7670 */ + IC_EVEX_L2_OPSIZE_KZ, /* 7671 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 7672 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 7673 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 7674 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 7675 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 7676 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 7677 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 7678 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 7679 */ + IC, /* 7680 */ + IC_64BIT, /* 7681 */ + IC_XS, /* 7682 */ + IC_64BIT_XS, /* 7683 */ + IC_XD, /* 7684 */ + IC_64BIT_XD, /* 7685 */ + IC_XS, /* 7686 */ + IC_64BIT_XS, /* 7687 */ + IC, /* 7688 */ + IC_64BIT_REXW, /* 7689 */ + IC_XS, /* 7690 */ + IC_64BIT_REXW_XS, /* 7691 */ + IC_XD, /* 7692 */ + IC_64BIT_REXW_XD, /* 7693 */ + IC_XS, /* 7694 */ + IC_64BIT_REXW_XS, /* 7695 */ + IC_OPSIZE, /* 7696 */ + IC_64BIT_OPSIZE, /* 7697 */ + IC_XS_OPSIZE, /* 7698 */ + IC_64BIT_XS_OPSIZE, /* 7699 */ + IC_XD_OPSIZE, /* 7700 */ + IC_64BIT_XD_OPSIZE, /* 7701 */ + IC_XS_OPSIZE, /* 7702 */ + IC_64BIT_XD_OPSIZE, /* 7703 */ + IC_OPSIZE, /* 7704 */ + IC_64BIT_REXW_OPSIZE, /* 7705 */ + IC_XS_OPSIZE, /* 7706 */ + IC_64BIT_REXW_XS, /* 7707 */ + IC_XD_OPSIZE, /* 7708 */ + IC_64BIT_REXW_XD, /* 7709 */ + IC_XS_OPSIZE, /* 7710 */ + IC_64BIT_REXW_XS, /* 7711 */ + IC_ADSIZE, /* 7712 */ + IC_64BIT_ADSIZE, /* 7713 */ + IC_XS_ADSIZE, /* 7714 */ + IC_64BIT_XS_ADSIZE, /* 7715 */ + IC_XD_ADSIZE, /* 7716 */ + IC_64BIT_XD_ADSIZE, /* 7717 */ + IC_XS_ADSIZE, /* 7718 */ + IC_64BIT_XD_ADSIZE, /* 7719 */ + IC_ADSIZE, /* 7720 */ + IC_64BIT_REXW_ADSIZE, /* 7721 */ + IC_XS_ADSIZE, /* 7722 */ + IC_64BIT_REXW_XS, /* 7723 */ + IC_XD_ADSIZE, /* 7724 */ + IC_64BIT_REXW_XD, /* 7725 */ + IC_XS_ADSIZE, /* 7726 */ + IC_64BIT_REXW_XS, /* 7727 */ + IC_OPSIZE_ADSIZE, /* 7728 */ + IC_64BIT_OPSIZE_ADSIZE, /* 7729 */ + IC_XS_OPSIZE, /* 7730 */ + IC_64BIT_XS_OPSIZE, /* 7731 */ + IC_XD_OPSIZE, /* 7732 */ + IC_64BIT_XD_OPSIZE, /* 7733 */ + IC_XS_OPSIZE, /* 7734 */ + IC_64BIT_XD_OPSIZE, /* 7735 */ + IC_OPSIZE_ADSIZE, /* 7736 */ + IC_64BIT_REXW_OPSIZE, /* 7737 */ + IC_XS_OPSIZE, /* 7738 */ + IC_64BIT_REXW_XS, /* 7739 */ + IC_XD_OPSIZE, /* 7740 */ + IC_64BIT_REXW_XD, /* 7741 */ + IC_XS_OPSIZE, /* 7742 */ + IC_64BIT_REXW_XS, /* 7743 */ + IC_VEX, /* 7744 */ + IC_VEX, /* 7745 */ + IC_VEX_XS, /* 7746 */ + IC_VEX_XS, /* 7747 */ + IC_VEX_XD, /* 7748 */ + IC_VEX_XD, /* 7749 */ + IC_VEX_XD, /* 7750 */ + IC_VEX_XD, /* 7751 */ + IC_VEX_W, /* 7752 */ + IC_VEX_W, /* 7753 */ + IC_VEX_W_XS, /* 7754 */ + IC_VEX_W_XS, /* 7755 */ + IC_VEX_W_XD, /* 7756 */ + IC_VEX_W_XD, /* 7757 */ + IC_VEX_W_XD, /* 7758 */ + IC_VEX_W_XD, /* 7759 */ + IC_VEX_OPSIZE, /* 7760 */ + IC_VEX_OPSIZE, /* 7761 */ + IC_VEX_OPSIZE, /* 7762 */ + IC_VEX_OPSIZE, /* 7763 */ + IC_VEX_OPSIZE, /* 7764 */ + IC_VEX_OPSIZE, /* 7765 */ + IC_VEX_OPSIZE, /* 7766 */ + IC_VEX_OPSIZE, /* 7767 */ + IC_VEX_W_OPSIZE, /* 7768 */ + IC_VEX_W_OPSIZE, /* 7769 */ + IC_VEX_W_OPSIZE, /* 7770 */ + IC_VEX_W_OPSIZE, /* 7771 */ + IC_VEX_W_OPSIZE, /* 7772 */ + IC_VEX_W_OPSIZE, /* 7773 */ + IC_VEX_W_OPSIZE, /* 7774 */ + IC_VEX_W_OPSIZE, /* 7775 */ + IC_VEX, /* 7776 */ + IC_VEX, /* 7777 */ + IC_VEX_XS, /* 7778 */ + IC_VEX_XS, /* 7779 */ + IC_VEX_XD, /* 7780 */ + IC_VEX_XD, /* 7781 */ + IC_VEX_XD, /* 7782 */ + IC_VEX_XD, /* 7783 */ + IC_VEX_W, /* 7784 */ + IC_VEX_W, /* 7785 */ + IC_VEX_W_XS, /* 7786 */ + IC_VEX_W_XS, /* 7787 */ + IC_VEX_W_XD, /* 7788 */ + IC_VEX_W_XD, /* 7789 */ + IC_VEX_W_XD, /* 7790 */ + IC_VEX_W_XD, /* 7791 */ + IC_VEX_OPSIZE, /* 7792 */ + IC_VEX_OPSIZE, /* 7793 */ + IC_VEX_OPSIZE, /* 7794 */ + IC_VEX_OPSIZE, /* 7795 */ + IC_VEX_OPSIZE, /* 7796 */ + IC_VEX_OPSIZE, /* 7797 */ + IC_VEX_OPSIZE, /* 7798 */ + IC_VEX_OPSIZE, /* 7799 */ + IC_VEX_W_OPSIZE, /* 7800 */ + IC_VEX_W_OPSIZE, /* 7801 */ + IC_VEX_W_OPSIZE, /* 7802 */ + IC_VEX_W_OPSIZE, /* 7803 */ + IC_VEX_W_OPSIZE, /* 7804 */ + IC_VEX_W_OPSIZE, /* 7805 */ + IC_VEX_W_OPSIZE, /* 7806 */ + IC_VEX_W_OPSIZE, /* 7807 */ + IC_VEX_L, /* 7808 */ + IC_VEX_L, /* 7809 */ + IC_VEX_L_XS, /* 7810 */ + IC_VEX_L_XS, /* 7811 */ + IC_VEX_L_XD, /* 7812 */ + IC_VEX_L_XD, /* 7813 */ + IC_VEX_L_XD, /* 7814 */ + IC_VEX_L_XD, /* 7815 */ + IC_VEX_L_W, /* 7816 */ + IC_VEX_L_W, /* 7817 */ + IC_VEX_L_W_XS, /* 7818 */ + IC_VEX_L_W_XS, /* 7819 */ + IC_VEX_L_W_XD, /* 7820 */ + IC_VEX_L_W_XD, /* 7821 */ + IC_VEX_L_W_XD, /* 7822 */ + IC_VEX_L_W_XD, /* 7823 */ + IC_VEX_L_OPSIZE, /* 7824 */ + IC_VEX_L_OPSIZE, /* 7825 */ + IC_VEX_L_OPSIZE, /* 7826 */ + IC_VEX_L_OPSIZE, /* 7827 */ + IC_VEX_L_OPSIZE, /* 7828 */ + IC_VEX_L_OPSIZE, /* 7829 */ + IC_VEX_L_OPSIZE, /* 7830 */ + IC_VEX_L_OPSIZE, /* 7831 */ + IC_VEX_L_W_OPSIZE, /* 7832 */ + IC_VEX_L_W_OPSIZE, /* 7833 */ + IC_VEX_L_W_OPSIZE, /* 7834 */ + IC_VEX_L_W_OPSIZE, /* 7835 */ + IC_VEX_L_W_OPSIZE, /* 7836 */ + IC_VEX_L_W_OPSIZE, /* 7837 */ + IC_VEX_L_W_OPSIZE, /* 7838 */ + IC_VEX_L_W_OPSIZE, /* 7839 */ + IC_VEX_L, /* 7840 */ + IC_VEX_L, /* 7841 */ + IC_VEX_L_XS, /* 7842 */ + IC_VEX_L_XS, /* 7843 */ + IC_VEX_L_XD, /* 7844 */ + IC_VEX_L_XD, /* 7845 */ + IC_VEX_L_XD, /* 7846 */ + IC_VEX_L_XD, /* 7847 */ + IC_VEX_L_W, /* 7848 */ + IC_VEX_L_W, /* 7849 */ + IC_VEX_L_W_XS, /* 7850 */ + IC_VEX_L_W_XS, /* 7851 */ + IC_VEX_L_W_XD, /* 7852 */ + IC_VEX_L_W_XD, /* 7853 */ + IC_VEX_L_W_XD, /* 7854 */ + IC_VEX_L_W_XD, /* 7855 */ + IC_VEX_L_OPSIZE, /* 7856 */ + IC_VEX_L_OPSIZE, /* 7857 */ + IC_VEX_L_OPSIZE, /* 7858 */ + IC_VEX_L_OPSIZE, /* 7859 */ + IC_VEX_L_OPSIZE, /* 7860 */ + IC_VEX_L_OPSIZE, /* 7861 */ + IC_VEX_L_OPSIZE, /* 7862 */ + IC_VEX_L_OPSIZE, /* 7863 */ + IC_VEX_L_W_OPSIZE, /* 7864 */ + IC_VEX_L_W_OPSIZE, /* 7865 */ + IC_VEX_L_W_OPSIZE, /* 7866 */ + IC_VEX_L_W_OPSIZE, /* 7867 */ + IC_VEX_L_W_OPSIZE, /* 7868 */ + IC_VEX_L_W_OPSIZE, /* 7869 */ + IC_VEX_L_W_OPSIZE, /* 7870 */ + IC_VEX_L_W_OPSIZE, /* 7871 */ + IC_VEX_L, /* 7872 */ + IC_VEX_L, /* 7873 */ + IC_VEX_L_XS, /* 7874 */ + IC_VEX_L_XS, /* 7875 */ + IC_VEX_L_XD, /* 7876 */ + IC_VEX_L_XD, /* 7877 */ + IC_VEX_L_XD, /* 7878 */ + IC_VEX_L_XD, /* 7879 */ + IC_VEX_L_W, /* 7880 */ + IC_VEX_L_W, /* 7881 */ + IC_VEX_L_W_XS, /* 7882 */ + IC_VEX_L_W_XS, /* 7883 */ + IC_VEX_L_W_XD, /* 7884 */ + IC_VEX_L_W_XD, /* 7885 */ + IC_VEX_L_W_XD, /* 7886 */ + IC_VEX_L_W_XD, /* 7887 */ + IC_VEX_L_OPSIZE, /* 7888 */ + IC_VEX_L_OPSIZE, /* 7889 */ + IC_VEX_L_OPSIZE, /* 7890 */ + IC_VEX_L_OPSIZE, /* 7891 */ + IC_VEX_L_OPSIZE, /* 7892 */ + IC_VEX_L_OPSIZE, /* 7893 */ + IC_VEX_L_OPSIZE, /* 7894 */ + IC_VEX_L_OPSIZE, /* 7895 */ + IC_VEX_L_W_OPSIZE, /* 7896 */ + IC_VEX_L_W_OPSIZE, /* 7897 */ + IC_VEX_L_W_OPSIZE, /* 7898 */ + IC_VEX_L_W_OPSIZE, /* 7899 */ + IC_VEX_L_W_OPSIZE, /* 7900 */ + IC_VEX_L_W_OPSIZE, /* 7901 */ + IC_VEX_L_W_OPSIZE, /* 7902 */ + IC_VEX_L_W_OPSIZE, /* 7903 */ + IC_VEX_L, /* 7904 */ + IC_VEX_L, /* 7905 */ + IC_VEX_L_XS, /* 7906 */ + IC_VEX_L_XS, /* 7907 */ + IC_VEX_L_XD, /* 7908 */ + IC_VEX_L_XD, /* 7909 */ + IC_VEX_L_XD, /* 7910 */ + IC_VEX_L_XD, /* 7911 */ + IC_VEX_L_W, /* 7912 */ + IC_VEX_L_W, /* 7913 */ + IC_VEX_L_W_XS, /* 7914 */ + IC_VEX_L_W_XS, /* 7915 */ + IC_VEX_L_W_XD, /* 7916 */ + IC_VEX_L_W_XD, /* 7917 */ + IC_VEX_L_W_XD, /* 7918 */ + IC_VEX_L_W_XD, /* 7919 */ + IC_VEX_L_OPSIZE, /* 7920 */ + IC_VEX_L_OPSIZE, /* 7921 */ + IC_VEX_L_OPSIZE, /* 7922 */ + IC_VEX_L_OPSIZE, /* 7923 */ + IC_VEX_L_OPSIZE, /* 7924 */ + IC_VEX_L_OPSIZE, /* 7925 */ + IC_VEX_L_OPSIZE, /* 7926 */ + IC_VEX_L_OPSIZE, /* 7927 */ + IC_VEX_L_W_OPSIZE, /* 7928 */ + IC_VEX_L_W_OPSIZE, /* 7929 */ + IC_VEX_L_W_OPSIZE, /* 7930 */ + IC_VEX_L_W_OPSIZE, /* 7931 */ + IC_VEX_L_W_OPSIZE, /* 7932 */ + IC_VEX_L_W_OPSIZE, /* 7933 */ + IC_VEX_L_W_OPSIZE, /* 7934 */ + IC_VEX_L_W_OPSIZE, /* 7935 */ + IC_EVEX_L2_KZ, /* 7936 */ + IC_EVEX_L2_KZ, /* 7937 */ + IC_EVEX_L2_XS_KZ, /* 7938 */ + IC_EVEX_L2_XS_KZ, /* 7939 */ + IC_EVEX_L2_XD_KZ, /* 7940 */ + IC_EVEX_L2_XD_KZ, /* 7941 */ + IC_EVEX_L2_XD_KZ, /* 7942 */ + IC_EVEX_L2_XD_KZ, /* 7943 */ + IC_EVEX_L2_W_KZ, /* 7944 */ + IC_EVEX_L2_W_KZ, /* 7945 */ + IC_EVEX_L2_W_XS_KZ, /* 7946 */ + IC_EVEX_L2_W_XS_KZ, /* 7947 */ + IC_EVEX_L2_W_XD_KZ, /* 7948 */ + IC_EVEX_L2_W_XD_KZ, /* 7949 */ + IC_EVEX_L2_W_XD_KZ, /* 7950 */ + IC_EVEX_L2_W_XD_KZ, /* 7951 */ + IC_EVEX_L2_OPSIZE_KZ, /* 7952 */ + IC_EVEX_L2_OPSIZE_KZ, /* 7953 */ + IC_EVEX_L2_OPSIZE_KZ, /* 7954 */ + IC_EVEX_L2_OPSIZE_KZ, /* 7955 */ + IC_EVEX_L2_OPSIZE_KZ, /* 7956 */ + IC_EVEX_L2_OPSIZE_KZ, /* 7957 */ + IC_EVEX_L2_OPSIZE_KZ, /* 7958 */ + IC_EVEX_L2_OPSIZE_KZ, /* 7959 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 7960 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 7961 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 7962 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 7963 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 7964 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 7965 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 7966 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 7967 */ + IC_EVEX_L2_KZ, /* 7968 */ + IC_EVEX_L2_KZ, /* 7969 */ + IC_EVEX_L2_XS_KZ, /* 7970 */ + IC_EVEX_L2_XS_KZ, /* 7971 */ + IC_EVEX_L2_XD_KZ, /* 7972 */ + IC_EVEX_L2_XD_KZ, /* 7973 */ + IC_EVEX_L2_XD_KZ, /* 7974 */ + IC_EVEX_L2_XD_KZ, /* 7975 */ + IC_EVEX_L2_W_KZ, /* 7976 */ + IC_EVEX_L2_W_KZ, /* 7977 */ + IC_EVEX_L2_W_XS_KZ, /* 7978 */ + IC_EVEX_L2_W_XS_KZ, /* 7979 */ + IC_EVEX_L2_W_XD_KZ, /* 7980 */ + IC_EVEX_L2_W_XD_KZ, /* 7981 */ + IC_EVEX_L2_W_XD_KZ, /* 7982 */ + IC_EVEX_L2_W_XD_KZ, /* 7983 */ + IC_EVEX_L2_OPSIZE_KZ, /* 7984 */ + IC_EVEX_L2_OPSIZE_KZ, /* 7985 */ + IC_EVEX_L2_OPSIZE_KZ, /* 7986 */ + IC_EVEX_L2_OPSIZE_KZ, /* 7987 */ + IC_EVEX_L2_OPSIZE_KZ, /* 7988 */ + IC_EVEX_L2_OPSIZE_KZ, /* 7989 */ + IC_EVEX_L2_OPSIZE_KZ, /* 7990 */ + IC_EVEX_L2_OPSIZE_KZ, /* 7991 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 7992 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 7993 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 7994 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 7995 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 7996 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 7997 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 7998 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 7999 */ + IC_EVEX_L2_KZ, /* 8000 */ + IC_EVEX_L2_KZ, /* 8001 */ + IC_EVEX_L2_XS_KZ, /* 8002 */ + IC_EVEX_L2_XS_KZ, /* 8003 */ + IC_EVEX_L2_XD_KZ, /* 8004 */ + IC_EVEX_L2_XD_KZ, /* 8005 */ + IC_EVEX_L2_XD_KZ, /* 8006 */ + IC_EVEX_L2_XD_KZ, /* 8007 */ + IC_EVEX_L2_W_KZ, /* 8008 */ + IC_EVEX_L2_W_KZ, /* 8009 */ + IC_EVEX_L2_W_XS_KZ, /* 8010 */ + IC_EVEX_L2_W_XS_KZ, /* 8011 */ + IC_EVEX_L2_W_XD_KZ, /* 8012 */ + IC_EVEX_L2_W_XD_KZ, /* 8013 */ + IC_EVEX_L2_W_XD_KZ, /* 8014 */ + IC_EVEX_L2_W_XD_KZ, /* 8015 */ + IC_EVEX_L2_OPSIZE_KZ, /* 8016 */ + IC_EVEX_L2_OPSIZE_KZ, /* 8017 */ + IC_EVEX_L2_OPSIZE_KZ, /* 8018 */ + IC_EVEX_L2_OPSIZE_KZ, /* 8019 */ + IC_EVEX_L2_OPSIZE_KZ, /* 8020 */ + IC_EVEX_L2_OPSIZE_KZ, /* 8021 */ + IC_EVEX_L2_OPSIZE_KZ, /* 8022 */ + IC_EVEX_L2_OPSIZE_KZ, /* 8023 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 8024 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 8025 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 8026 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 8027 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 8028 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 8029 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 8030 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 8031 */ + IC_EVEX_L2_KZ, /* 8032 */ + IC_EVEX_L2_KZ, /* 8033 */ + IC_EVEX_L2_XS_KZ, /* 8034 */ + IC_EVEX_L2_XS_KZ, /* 8035 */ + IC_EVEX_L2_XD_KZ, /* 8036 */ + IC_EVEX_L2_XD_KZ, /* 8037 */ + IC_EVEX_L2_XD_KZ, /* 8038 */ + IC_EVEX_L2_XD_KZ, /* 8039 */ + IC_EVEX_L2_W_KZ, /* 8040 */ + IC_EVEX_L2_W_KZ, /* 8041 */ + IC_EVEX_L2_W_XS_KZ, /* 8042 */ + IC_EVEX_L2_W_XS_KZ, /* 8043 */ + IC_EVEX_L2_W_XD_KZ, /* 8044 */ + IC_EVEX_L2_W_XD_KZ, /* 8045 */ + IC_EVEX_L2_W_XD_KZ, /* 8046 */ + IC_EVEX_L2_W_XD_KZ, /* 8047 */ + IC_EVEX_L2_OPSIZE_KZ, /* 8048 */ + IC_EVEX_L2_OPSIZE_KZ, /* 8049 */ + IC_EVEX_L2_OPSIZE_KZ, /* 8050 */ + IC_EVEX_L2_OPSIZE_KZ, /* 8051 */ + IC_EVEX_L2_OPSIZE_KZ, /* 8052 */ + IC_EVEX_L2_OPSIZE_KZ, /* 8053 */ + IC_EVEX_L2_OPSIZE_KZ, /* 8054 */ + IC_EVEX_L2_OPSIZE_KZ, /* 8055 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 8056 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 8057 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 8058 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 8059 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 8060 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 8061 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 8062 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 8063 */ + IC_EVEX_L2_KZ, /* 8064 */ + IC_EVEX_L2_KZ, /* 8065 */ + IC_EVEX_L2_XS_KZ, /* 8066 */ + IC_EVEX_L2_XS_KZ, /* 8067 */ + IC_EVEX_L2_XD_KZ, /* 8068 */ + IC_EVEX_L2_XD_KZ, /* 8069 */ + IC_EVEX_L2_XD_KZ, /* 8070 */ + IC_EVEX_L2_XD_KZ, /* 8071 */ + IC_EVEX_L2_W_KZ, /* 8072 */ + IC_EVEX_L2_W_KZ, /* 8073 */ + IC_EVEX_L2_W_XS_KZ, /* 8074 */ + IC_EVEX_L2_W_XS_KZ, /* 8075 */ + IC_EVEX_L2_W_XD_KZ, /* 8076 */ + IC_EVEX_L2_W_XD_KZ, /* 8077 */ + IC_EVEX_L2_W_XD_KZ, /* 8078 */ + IC_EVEX_L2_W_XD_KZ, /* 8079 */ + IC_EVEX_L2_OPSIZE_KZ, /* 8080 */ + IC_EVEX_L2_OPSIZE_KZ, /* 8081 */ + IC_EVEX_L2_OPSIZE_KZ, /* 8082 */ + IC_EVEX_L2_OPSIZE_KZ, /* 8083 */ + IC_EVEX_L2_OPSIZE_KZ, /* 8084 */ + IC_EVEX_L2_OPSIZE_KZ, /* 8085 */ + IC_EVEX_L2_OPSIZE_KZ, /* 8086 */ + IC_EVEX_L2_OPSIZE_KZ, /* 8087 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 8088 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 8089 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 8090 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 8091 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 8092 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 8093 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 8094 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 8095 */ + IC_EVEX_L2_KZ, /* 8096 */ + IC_EVEX_L2_KZ, /* 8097 */ + IC_EVEX_L2_XS_KZ, /* 8098 */ + IC_EVEX_L2_XS_KZ, /* 8099 */ + IC_EVEX_L2_XD_KZ, /* 8100 */ + IC_EVEX_L2_XD_KZ, /* 8101 */ + IC_EVEX_L2_XD_KZ, /* 8102 */ + IC_EVEX_L2_XD_KZ, /* 8103 */ + IC_EVEX_L2_W_KZ, /* 8104 */ + IC_EVEX_L2_W_KZ, /* 8105 */ + IC_EVEX_L2_W_XS_KZ, /* 8106 */ + IC_EVEX_L2_W_XS_KZ, /* 8107 */ + IC_EVEX_L2_W_XD_KZ, /* 8108 */ + IC_EVEX_L2_W_XD_KZ, /* 8109 */ + IC_EVEX_L2_W_XD_KZ, /* 8110 */ + IC_EVEX_L2_W_XD_KZ, /* 8111 */ + IC_EVEX_L2_OPSIZE_KZ, /* 8112 */ + IC_EVEX_L2_OPSIZE_KZ, /* 8113 */ + IC_EVEX_L2_OPSIZE_KZ, /* 8114 */ + IC_EVEX_L2_OPSIZE_KZ, /* 8115 */ + IC_EVEX_L2_OPSIZE_KZ, /* 8116 */ + IC_EVEX_L2_OPSIZE_KZ, /* 8117 */ + IC_EVEX_L2_OPSIZE_KZ, /* 8118 */ + IC_EVEX_L2_OPSIZE_KZ, /* 8119 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 8120 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 8121 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 8122 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 8123 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 8124 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 8125 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 8126 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 8127 */ + IC_EVEX_L2_KZ, /* 8128 */ + IC_EVEX_L2_KZ, /* 8129 */ + IC_EVEX_L2_XS_KZ, /* 8130 */ + IC_EVEX_L2_XS_KZ, /* 8131 */ + IC_EVEX_L2_XD_KZ, /* 8132 */ + IC_EVEX_L2_XD_KZ, /* 8133 */ + IC_EVEX_L2_XD_KZ, /* 8134 */ + IC_EVEX_L2_XD_KZ, /* 8135 */ + IC_EVEX_L2_W_KZ, /* 8136 */ + IC_EVEX_L2_W_KZ, /* 8137 */ + IC_EVEX_L2_W_XS_KZ, /* 8138 */ + IC_EVEX_L2_W_XS_KZ, /* 8139 */ + IC_EVEX_L2_W_XD_KZ, /* 8140 */ + IC_EVEX_L2_W_XD_KZ, /* 8141 */ + IC_EVEX_L2_W_XD_KZ, /* 8142 */ + IC_EVEX_L2_W_XD_KZ, /* 8143 */ + IC_EVEX_L2_OPSIZE_KZ, /* 8144 */ + IC_EVEX_L2_OPSIZE_KZ, /* 8145 */ + IC_EVEX_L2_OPSIZE_KZ, /* 8146 */ + IC_EVEX_L2_OPSIZE_KZ, /* 8147 */ + IC_EVEX_L2_OPSIZE_KZ, /* 8148 */ + IC_EVEX_L2_OPSIZE_KZ, /* 8149 */ + IC_EVEX_L2_OPSIZE_KZ, /* 8150 */ + IC_EVEX_L2_OPSIZE_KZ, /* 8151 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 8152 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 8153 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 8154 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 8155 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 8156 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 8157 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 8158 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 8159 */ + IC_EVEX_L2_KZ, /* 8160 */ + IC_EVEX_L2_KZ, /* 8161 */ + IC_EVEX_L2_XS_KZ, /* 8162 */ + IC_EVEX_L2_XS_KZ, /* 8163 */ + IC_EVEX_L2_XD_KZ, /* 8164 */ + IC_EVEX_L2_XD_KZ, /* 8165 */ + IC_EVEX_L2_XD_KZ, /* 8166 */ + IC_EVEX_L2_XD_KZ, /* 8167 */ + IC_EVEX_L2_W_KZ, /* 8168 */ + IC_EVEX_L2_W_KZ, /* 8169 */ + IC_EVEX_L2_W_XS_KZ, /* 8170 */ + IC_EVEX_L2_W_XS_KZ, /* 8171 */ + IC_EVEX_L2_W_XD_KZ, /* 8172 */ + IC_EVEX_L2_W_XD_KZ, /* 8173 */ + IC_EVEX_L2_W_XD_KZ, /* 8174 */ + IC_EVEX_L2_W_XD_KZ, /* 8175 */ + IC_EVEX_L2_OPSIZE_KZ, /* 8176 */ + IC_EVEX_L2_OPSIZE_KZ, /* 8177 */ + IC_EVEX_L2_OPSIZE_KZ, /* 8178 */ + IC_EVEX_L2_OPSIZE_KZ, /* 8179 */ + IC_EVEX_L2_OPSIZE_KZ, /* 8180 */ + IC_EVEX_L2_OPSIZE_KZ, /* 8181 */ + IC_EVEX_L2_OPSIZE_KZ, /* 8182 */ + IC_EVEX_L2_OPSIZE_KZ, /* 8183 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 8184 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 8185 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 8186 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 8187 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 8188 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 8189 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 8190 */ + IC_EVEX_L2_W_OPSIZE_KZ, /* 8191 */ + IC, /* 8192 */ + IC_64BIT, /* 8193 */ + IC_XS, /* 8194 */ + IC_64BIT_XS, /* 8195 */ + IC_XD, /* 8196 */ + IC_64BIT_XD, /* 8197 */ + IC_XS, /* 8198 */ + IC_64BIT_XS, /* 8199 */ + IC, /* 8200 */ + IC_64BIT_REXW, /* 8201 */ + IC_XS, /* 8202 */ + IC_64BIT_REXW_XS, /* 8203 */ + IC_XD, /* 8204 */ + IC_64BIT_REXW_XD, /* 8205 */ + IC_XS, /* 8206 */ + IC_64BIT_REXW_XS, /* 8207 */ + IC_OPSIZE, /* 8208 */ + IC_64BIT_OPSIZE, /* 8209 */ + IC_XS_OPSIZE, /* 8210 */ + IC_64BIT_XS_OPSIZE, /* 8211 */ + IC_XD_OPSIZE, /* 8212 */ + IC_64BIT_XD_OPSIZE, /* 8213 */ + IC_XS_OPSIZE, /* 8214 */ + IC_64BIT_XD_OPSIZE, /* 8215 */ + IC_OPSIZE, /* 8216 */ + IC_64BIT_REXW_OPSIZE, /* 8217 */ + IC_XS_OPSIZE, /* 8218 */ + IC_64BIT_REXW_XS, /* 8219 */ + IC_XD_OPSIZE, /* 8220 */ + IC_64BIT_REXW_XD, /* 8221 */ + IC_XS_OPSIZE, /* 8222 */ + IC_64BIT_REXW_XS, /* 8223 */ + IC_ADSIZE, /* 8224 */ + IC_64BIT_ADSIZE, /* 8225 */ + IC_XS_ADSIZE, /* 8226 */ + IC_64BIT_XS_ADSIZE, /* 8227 */ + IC_XD_ADSIZE, /* 8228 */ + IC_64BIT_XD_ADSIZE, /* 8229 */ + IC_XS_ADSIZE, /* 8230 */ + IC_64BIT_XD_ADSIZE, /* 8231 */ + IC_ADSIZE, /* 8232 */ + IC_64BIT_REXW_ADSIZE, /* 8233 */ + IC_XS_ADSIZE, /* 8234 */ + IC_64BIT_REXW_XS, /* 8235 */ + IC_XD_ADSIZE, /* 8236 */ + IC_64BIT_REXW_XD, /* 8237 */ + IC_XS_ADSIZE, /* 8238 */ + IC_64BIT_REXW_XS, /* 8239 */ + IC_OPSIZE_ADSIZE, /* 8240 */ + IC_64BIT_OPSIZE_ADSIZE, /* 8241 */ + IC_XS_OPSIZE, /* 8242 */ + IC_64BIT_XS_OPSIZE, /* 8243 */ + IC_XD_OPSIZE, /* 8244 */ + IC_64BIT_XD_OPSIZE, /* 8245 */ + IC_XS_OPSIZE, /* 8246 */ + IC_64BIT_XD_OPSIZE, /* 8247 */ + IC_OPSIZE_ADSIZE, /* 8248 */ + IC_64BIT_REXW_OPSIZE, /* 8249 */ + IC_XS_OPSIZE, /* 8250 */ + IC_64BIT_REXW_XS, /* 8251 */ + IC_XD_OPSIZE, /* 8252 */ + IC_64BIT_REXW_XD, /* 8253 */ + IC_XS_OPSIZE, /* 8254 */ + IC_64BIT_REXW_XS, /* 8255 */ + IC_VEX, /* 8256 */ + IC_VEX, /* 8257 */ + IC_VEX_XS, /* 8258 */ + IC_VEX_XS, /* 8259 */ + IC_VEX_XD, /* 8260 */ + IC_VEX_XD, /* 8261 */ + IC_VEX_XD, /* 8262 */ + IC_VEX_XD, /* 8263 */ + IC_VEX_W, /* 8264 */ + IC_VEX_W, /* 8265 */ + IC_VEX_W_XS, /* 8266 */ + IC_VEX_W_XS, /* 8267 */ + IC_VEX_W_XD, /* 8268 */ + IC_VEX_W_XD, /* 8269 */ + IC_VEX_W_XD, /* 8270 */ + IC_VEX_W_XD, /* 8271 */ + IC_VEX_OPSIZE, /* 8272 */ + IC_VEX_OPSIZE, /* 8273 */ + IC_VEX_OPSIZE, /* 8274 */ + IC_VEX_OPSIZE, /* 8275 */ + IC_VEX_OPSIZE, /* 8276 */ + IC_VEX_OPSIZE, /* 8277 */ + IC_VEX_OPSIZE, /* 8278 */ + IC_VEX_OPSIZE, /* 8279 */ + IC_VEX_W_OPSIZE, /* 8280 */ + IC_VEX_W_OPSIZE, /* 8281 */ + IC_VEX_W_OPSIZE, /* 8282 */ + IC_VEX_W_OPSIZE, /* 8283 */ + IC_VEX_W_OPSIZE, /* 8284 */ + IC_VEX_W_OPSIZE, /* 8285 */ + IC_VEX_W_OPSIZE, /* 8286 */ + IC_VEX_W_OPSIZE, /* 8287 */ + IC_VEX, /* 8288 */ + IC_VEX, /* 8289 */ + IC_VEX_XS, /* 8290 */ + IC_VEX_XS, /* 8291 */ + IC_VEX_XD, /* 8292 */ + IC_VEX_XD, /* 8293 */ + IC_VEX_XD, /* 8294 */ + IC_VEX_XD, /* 8295 */ + IC_VEX_W, /* 8296 */ + IC_VEX_W, /* 8297 */ + IC_VEX_W_XS, /* 8298 */ + IC_VEX_W_XS, /* 8299 */ + IC_VEX_W_XD, /* 8300 */ + IC_VEX_W_XD, /* 8301 */ + IC_VEX_W_XD, /* 8302 */ + IC_VEX_W_XD, /* 8303 */ + IC_VEX_OPSIZE, /* 8304 */ + IC_VEX_OPSIZE, /* 8305 */ + IC_VEX_OPSIZE, /* 8306 */ + IC_VEX_OPSIZE, /* 8307 */ + IC_VEX_OPSIZE, /* 8308 */ + IC_VEX_OPSIZE, /* 8309 */ + IC_VEX_OPSIZE, /* 8310 */ + IC_VEX_OPSIZE, /* 8311 */ + IC_VEX_W_OPSIZE, /* 8312 */ + IC_VEX_W_OPSIZE, /* 8313 */ + IC_VEX_W_OPSIZE, /* 8314 */ + IC_VEX_W_OPSIZE, /* 8315 */ + IC_VEX_W_OPSIZE, /* 8316 */ + IC_VEX_W_OPSIZE, /* 8317 */ + IC_VEX_W_OPSIZE, /* 8318 */ + IC_VEX_W_OPSIZE, /* 8319 */ + IC_VEX_L, /* 8320 */ + IC_VEX_L, /* 8321 */ + IC_VEX_L_XS, /* 8322 */ + IC_VEX_L_XS, /* 8323 */ + IC_VEX_L_XD, /* 8324 */ + IC_VEX_L_XD, /* 8325 */ + IC_VEX_L_XD, /* 8326 */ + IC_VEX_L_XD, /* 8327 */ + IC_VEX_L_W, /* 8328 */ + IC_VEX_L_W, /* 8329 */ + IC_VEX_L_W_XS, /* 8330 */ + IC_VEX_L_W_XS, /* 8331 */ + IC_VEX_L_W_XD, /* 8332 */ + IC_VEX_L_W_XD, /* 8333 */ + IC_VEX_L_W_XD, /* 8334 */ + IC_VEX_L_W_XD, /* 8335 */ + IC_VEX_L_OPSIZE, /* 8336 */ + IC_VEX_L_OPSIZE, /* 8337 */ + IC_VEX_L_OPSIZE, /* 8338 */ + IC_VEX_L_OPSIZE, /* 8339 */ + IC_VEX_L_OPSIZE, /* 8340 */ + IC_VEX_L_OPSIZE, /* 8341 */ + IC_VEX_L_OPSIZE, /* 8342 */ + IC_VEX_L_OPSIZE, /* 8343 */ + IC_VEX_L_W_OPSIZE, /* 8344 */ + IC_VEX_L_W_OPSIZE, /* 8345 */ + IC_VEX_L_W_OPSIZE, /* 8346 */ + IC_VEX_L_W_OPSIZE, /* 8347 */ + IC_VEX_L_W_OPSIZE, /* 8348 */ + IC_VEX_L_W_OPSIZE, /* 8349 */ + IC_VEX_L_W_OPSIZE, /* 8350 */ + IC_VEX_L_W_OPSIZE, /* 8351 */ + IC_VEX_L, /* 8352 */ + IC_VEX_L, /* 8353 */ + IC_VEX_L_XS, /* 8354 */ + IC_VEX_L_XS, /* 8355 */ + IC_VEX_L_XD, /* 8356 */ + IC_VEX_L_XD, /* 8357 */ + IC_VEX_L_XD, /* 8358 */ + IC_VEX_L_XD, /* 8359 */ + IC_VEX_L_W, /* 8360 */ + IC_VEX_L_W, /* 8361 */ + IC_VEX_L_W_XS, /* 8362 */ + IC_VEX_L_W_XS, /* 8363 */ + IC_VEX_L_W_XD, /* 8364 */ + IC_VEX_L_W_XD, /* 8365 */ + IC_VEX_L_W_XD, /* 8366 */ + IC_VEX_L_W_XD, /* 8367 */ + IC_VEX_L_OPSIZE, /* 8368 */ + IC_VEX_L_OPSIZE, /* 8369 */ + IC_VEX_L_OPSIZE, /* 8370 */ + IC_VEX_L_OPSIZE, /* 8371 */ + IC_VEX_L_OPSIZE, /* 8372 */ + IC_VEX_L_OPSIZE, /* 8373 */ + IC_VEX_L_OPSIZE, /* 8374 */ + IC_VEX_L_OPSIZE, /* 8375 */ + IC_VEX_L_W_OPSIZE, /* 8376 */ + IC_VEX_L_W_OPSIZE, /* 8377 */ + IC_VEX_L_W_OPSIZE, /* 8378 */ + IC_VEX_L_W_OPSIZE, /* 8379 */ + IC_VEX_L_W_OPSIZE, /* 8380 */ + IC_VEX_L_W_OPSIZE, /* 8381 */ + IC_VEX_L_W_OPSIZE, /* 8382 */ + IC_VEX_L_W_OPSIZE, /* 8383 */ + IC_VEX_L, /* 8384 */ + IC_VEX_L, /* 8385 */ + IC_VEX_L_XS, /* 8386 */ + IC_VEX_L_XS, /* 8387 */ + IC_VEX_L_XD, /* 8388 */ + IC_VEX_L_XD, /* 8389 */ + IC_VEX_L_XD, /* 8390 */ + IC_VEX_L_XD, /* 8391 */ + IC_VEX_L_W, /* 8392 */ + IC_VEX_L_W, /* 8393 */ + IC_VEX_L_W_XS, /* 8394 */ + IC_VEX_L_W_XS, /* 8395 */ + IC_VEX_L_W_XD, /* 8396 */ + IC_VEX_L_W_XD, /* 8397 */ + IC_VEX_L_W_XD, /* 8398 */ + IC_VEX_L_W_XD, /* 8399 */ + IC_VEX_L_OPSIZE, /* 8400 */ + IC_VEX_L_OPSIZE, /* 8401 */ + IC_VEX_L_OPSIZE, /* 8402 */ + IC_VEX_L_OPSIZE, /* 8403 */ + IC_VEX_L_OPSIZE, /* 8404 */ + IC_VEX_L_OPSIZE, /* 8405 */ + IC_VEX_L_OPSIZE, /* 8406 */ + IC_VEX_L_OPSIZE, /* 8407 */ + IC_VEX_L_W_OPSIZE, /* 8408 */ + IC_VEX_L_W_OPSIZE, /* 8409 */ + IC_VEX_L_W_OPSIZE, /* 8410 */ + IC_VEX_L_W_OPSIZE, /* 8411 */ + IC_VEX_L_W_OPSIZE, /* 8412 */ + IC_VEX_L_W_OPSIZE, /* 8413 */ + IC_VEX_L_W_OPSIZE, /* 8414 */ + IC_VEX_L_W_OPSIZE, /* 8415 */ + IC_VEX_L, /* 8416 */ + IC_VEX_L, /* 8417 */ + IC_VEX_L_XS, /* 8418 */ + IC_VEX_L_XS, /* 8419 */ + IC_VEX_L_XD, /* 8420 */ + IC_VEX_L_XD, /* 8421 */ + IC_VEX_L_XD, /* 8422 */ + IC_VEX_L_XD, /* 8423 */ + IC_VEX_L_W, /* 8424 */ + IC_VEX_L_W, /* 8425 */ + IC_VEX_L_W_XS, /* 8426 */ + IC_VEX_L_W_XS, /* 8427 */ + IC_VEX_L_W_XD, /* 8428 */ + IC_VEX_L_W_XD, /* 8429 */ + IC_VEX_L_W_XD, /* 8430 */ + IC_VEX_L_W_XD, /* 8431 */ + IC_VEX_L_OPSIZE, /* 8432 */ + IC_VEX_L_OPSIZE, /* 8433 */ + IC_VEX_L_OPSIZE, /* 8434 */ + IC_VEX_L_OPSIZE, /* 8435 */ + IC_VEX_L_OPSIZE, /* 8436 */ + IC_VEX_L_OPSIZE, /* 8437 */ + IC_VEX_L_OPSIZE, /* 8438 */ + IC_VEX_L_OPSIZE, /* 8439 */ + IC_VEX_L_W_OPSIZE, /* 8440 */ + IC_VEX_L_W_OPSIZE, /* 8441 */ + IC_VEX_L_W_OPSIZE, /* 8442 */ + IC_VEX_L_W_OPSIZE, /* 8443 */ + IC_VEX_L_W_OPSIZE, /* 8444 */ + IC_VEX_L_W_OPSIZE, /* 8445 */ + IC_VEX_L_W_OPSIZE, /* 8446 */ + IC_VEX_L_W_OPSIZE, /* 8447 */ + IC_EVEX_B, /* 8448 */ + IC_EVEX_B, /* 8449 */ + IC_EVEX_XS_B, /* 8450 */ + IC_EVEX_XS_B, /* 8451 */ + IC_EVEX_XD_B, /* 8452 */ + IC_EVEX_XD_B, /* 8453 */ + IC_EVEX_XD_B, /* 8454 */ + IC_EVEX_XD_B, /* 8455 */ + IC_EVEX_W_B, /* 8456 */ + IC_EVEX_W_B, /* 8457 */ + IC_EVEX_W_XS_B, /* 8458 */ + IC_EVEX_W_XS_B, /* 8459 */ + IC_EVEX_W_XD_B, /* 8460 */ + IC_EVEX_W_XD_B, /* 8461 */ + IC_EVEX_W_XD_B, /* 8462 */ + IC_EVEX_W_XD_B, /* 8463 */ + IC_EVEX_OPSIZE_B, /* 8464 */ + IC_EVEX_OPSIZE_B, /* 8465 */ + IC_EVEX_OPSIZE_B, /* 8466 */ + IC_EVEX_OPSIZE_B, /* 8467 */ + IC_EVEX_OPSIZE_B, /* 8468 */ + IC_EVEX_OPSIZE_B, /* 8469 */ + IC_EVEX_OPSIZE_B, /* 8470 */ + IC_EVEX_OPSIZE_B, /* 8471 */ + IC_EVEX_W_OPSIZE_B, /* 8472 */ + IC_EVEX_W_OPSIZE_B, /* 8473 */ + IC_EVEX_W_OPSIZE_B, /* 8474 */ + IC_EVEX_W_OPSIZE_B, /* 8475 */ + IC_EVEX_W_OPSIZE_B, /* 8476 */ + IC_EVEX_W_OPSIZE_B, /* 8477 */ + IC_EVEX_W_OPSIZE_B, /* 8478 */ + IC_EVEX_W_OPSIZE_B, /* 8479 */ + IC_EVEX_B, /* 8480 */ + IC_EVEX_B, /* 8481 */ + IC_EVEX_XS_B, /* 8482 */ + IC_EVEX_XS_B, /* 8483 */ + IC_EVEX_XD_B, /* 8484 */ + IC_EVEX_XD_B, /* 8485 */ + IC_EVEX_XD_B, /* 8486 */ + IC_EVEX_XD_B, /* 8487 */ + IC_EVEX_W_B, /* 8488 */ + IC_EVEX_W_B, /* 8489 */ + IC_EVEX_W_XS_B, /* 8490 */ + IC_EVEX_W_XS_B, /* 8491 */ + IC_EVEX_W_XD_B, /* 8492 */ + IC_EVEX_W_XD_B, /* 8493 */ + IC_EVEX_W_XD_B, /* 8494 */ + IC_EVEX_W_XD_B, /* 8495 */ + IC_EVEX_OPSIZE_B, /* 8496 */ + IC_EVEX_OPSIZE_B, /* 8497 */ + IC_EVEX_OPSIZE_B, /* 8498 */ + IC_EVEX_OPSIZE_B, /* 8499 */ + IC_EVEX_OPSIZE_B, /* 8500 */ + IC_EVEX_OPSIZE_B, /* 8501 */ + IC_EVEX_OPSIZE_B, /* 8502 */ + IC_EVEX_OPSIZE_B, /* 8503 */ + IC_EVEX_W_OPSIZE_B, /* 8504 */ + IC_EVEX_W_OPSIZE_B, /* 8505 */ + IC_EVEX_W_OPSIZE_B, /* 8506 */ + IC_EVEX_W_OPSIZE_B, /* 8507 */ + IC_EVEX_W_OPSIZE_B, /* 8508 */ + IC_EVEX_W_OPSIZE_B, /* 8509 */ + IC_EVEX_W_OPSIZE_B, /* 8510 */ + IC_EVEX_W_OPSIZE_B, /* 8511 */ + IC_EVEX_B, /* 8512 */ + IC_EVEX_B, /* 8513 */ + IC_EVEX_XS_B, /* 8514 */ + IC_EVEX_XS_B, /* 8515 */ + IC_EVEX_XD_B, /* 8516 */ + IC_EVEX_XD_B, /* 8517 */ + IC_EVEX_XD_B, /* 8518 */ + IC_EVEX_XD_B, /* 8519 */ + IC_EVEX_W_B, /* 8520 */ + IC_EVEX_W_B, /* 8521 */ + IC_EVEX_W_XS_B, /* 8522 */ + IC_EVEX_W_XS_B, /* 8523 */ + IC_EVEX_W_XD_B, /* 8524 */ + IC_EVEX_W_XD_B, /* 8525 */ + IC_EVEX_W_XD_B, /* 8526 */ + IC_EVEX_W_XD_B, /* 8527 */ + IC_EVEX_OPSIZE_B, /* 8528 */ + IC_EVEX_OPSIZE_B, /* 8529 */ + IC_EVEX_OPSIZE_B, /* 8530 */ + IC_EVEX_OPSIZE_B, /* 8531 */ + IC_EVEX_OPSIZE_B, /* 8532 */ + IC_EVEX_OPSIZE_B, /* 8533 */ + IC_EVEX_OPSIZE_B, /* 8534 */ + IC_EVEX_OPSIZE_B, /* 8535 */ + IC_EVEX_W_OPSIZE_B, /* 8536 */ + IC_EVEX_W_OPSIZE_B, /* 8537 */ + IC_EVEX_W_OPSIZE_B, /* 8538 */ + IC_EVEX_W_OPSIZE_B, /* 8539 */ + IC_EVEX_W_OPSIZE_B, /* 8540 */ + IC_EVEX_W_OPSIZE_B, /* 8541 */ + IC_EVEX_W_OPSIZE_B, /* 8542 */ + IC_EVEX_W_OPSIZE_B, /* 8543 */ + IC_EVEX_B, /* 8544 */ + IC_EVEX_B, /* 8545 */ + IC_EVEX_XS_B, /* 8546 */ + IC_EVEX_XS_B, /* 8547 */ + IC_EVEX_XD_B, /* 8548 */ + IC_EVEX_XD_B, /* 8549 */ + IC_EVEX_XD_B, /* 8550 */ + IC_EVEX_XD_B, /* 8551 */ + IC_EVEX_W_B, /* 8552 */ + IC_EVEX_W_B, /* 8553 */ + IC_EVEX_W_XS_B, /* 8554 */ + IC_EVEX_W_XS_B, /* 8555 */ + IC_EVEX_W_XD_B, /* 8556 */ + IC_EVEX_W_XD_B, /* 8557 */ + IC_EVEX_W_XD_B, /* 8558 */ + IC_EVEX_W_XD_B, /* 8559 */ + IC_EVEX_OPSIZE_B, /* 8560 */ + IC_EVEX_OPSIZE_B, /* 8561 */ + IC_EVEX_OPSIZE_B, /* 8562 */ + IC_EVEX_OPSIZE_B, /* 8563 */ + IC_EVEX_OPSIZE_B, /* 8564 */ + IC_EVEX_OPSIZE_B, /* 8565 */ + IC_EVEX_OPSIZE_B, /* 8566 */ + IC_EVEX_OPSIZE_B, /* 8567 */ + IC_EVEX_W_OPSIZE_B, /* 8568 */ + IC_EVEX_W_OPSIZE_B, /* 8569 */ + IC_EVEX_W_OPSIZE_B, /* 8570 */ + IC_EVEX_W_OPSIZE_B, /* 8571 */ + IC_EVEX_W_OPSIZE_B, /* 8572 */ + IC_EVEX_W_OPSIZE_B, /* 8573 */ + IC_EVEX_W_OPSIZE_B, /* 8574 */ + IC_EVEX_W_OPSIZE_B, /* 8575 */ + IC_EVEX_B, /* 8576 */ + IC_EVEX_B, /* 8577 */ + IC_EVEX_XS_B, /* 8578 */ + IC_EVEX_XS_B, /* 8579 */ + IC_EVEX_XD_B, /* 8580 */ + IC_EVEX_XD_B, /* 8581 */ + IC_EVEX_XD_B, /* 8582 */ + IC_EVEX_XD_B, /* 8583 */ + IC_EVEX_W_B, /* 8584 */ + IC_EVEX_W_B, /* 8585 */ + IC_EVEX_W_XS_B, /* 8586 */ + IC_EVEX_W_XS_B, /* 8587 */ + IC_EVEX_W_XD_B, /* 8588 */ + IC_EVEX_W_XD_B, /* 8589 */ + IC_EVEX_W_XD_B, /* 8590 */ + IC_EVEX_W_XD_B, /* 8591 */ + IC_EVEX_OPSIZE_B, /* 8592 */ + IC_EVEX_OPSIZE_B, /* 8593 */ + IC_EVEX_OPSIZE_B, /* 8594 */ + IC_EVEX_OPSIZE_B, /* 8595 */ + IC_EVEX_OPSIZE_B, /* 8596 */ + IC_EVEX_OPSIZE_B, /* 8597 */ + IC_EVEX_OPSIZE_B, /* 8598 */ + IC_EVEX_OPSIZE_B, /* 8599 */ + IC_EVEX_W_OPSIZE_B, /* 8600 */ + IC_EVEX_W_OPSIZE_B, /* 8601 */ + IC_EVEX_W_OPSIZE_B, /* 8602 */ + IC_EVEX_W_OPSIZE_B, /* 8603 */ + IC_EVEX_W_OPSIZE_B, /* 8604 */ + IC_EVEX_W_OPSIZE_B, /* 8605 */ + IC_EVEX_W_OPSIZE_B, /* 8606 */ + IC_EVEX_W_OPSIZE_B, /* 8607 */ + IC_EVEX_B, /* 8608 */ + IC_EVEX_B, /* 8609 */ + IC_EVEX_XS_B, /* 8610 */ + IC_EVEX_XS_B, /* 8611 */ + IC_EVEX_XD_B, /* 8612 */ + IC_EVEX_XD_B, /* 8613 */ + IC_EVEX_XD_B, /* 8614 */ + IC_EVEX_XD_B, /* 8615 */ + IC_EVEX_W_B, /* 8616 */ + IC_EVEX_W_B, /* 8617 */ + IC_EVEX_W_XS_B, /* 8618 */ + IC_EVEX_W_XS_B, /* 8619 */ + IC_EVEX_W_XD_B, /* 8620 */ + IC_EVEX_W_XD_B, /* 8621 */ + IC_EVEX_W_XD_B, /* 8622 */ + IC_EVEX_W_XD_B, /* 8623 */ + IC_EVEX_OPSIZE_B, /* 8624 */ + IC_EVEX_OPSIZE_B, /* 8625 */ + IC_EVEX_OPSIZE_B, /* 8626 */ + IC_EVEX_OPSIZE_B, /* 8627 */ + IC_EVEX_OPSIZE_B, /* 8628 */ + IC_EVEX_OPSIZE_B, /* 8629 */ + IC_EVEX_OPSIZE_B, /* 8630 */ + IC_EVEX_OPSIZE_B, /* 8631 */ + IC_EVEX_W_OPSIZE_B, /* 8632 */ + IC_EVEX_W_OPSIZE_B, /* 8633 */ + IC_EVEX_W_OPSIZE_B, /* 8634 */ + IC_EVEX_W_OPSIZE_B, /* 8635 */ + IC_EVEX_W_OPSIZE_B, /* 8636 */ + IC_EVEX_W_OPSIZE_B, /* 8637 */ + IC_EVEX_W_OPSIZE_B, /* 8638 */ + IC_EVEX_W_OPSIZE_B, /* 8639 */ + IC_EVEX_B, /* 8640 */ + IC_EVEX_B, /* 8641 */ + IC_EVEX_XS_B, /* 8642 */ + IC_EVEX_XS_B, /* 8643 */ + IC_EVEX_XD_B, /* 8644 */ + IC_EVEX_XD_B, /* 8645 */ + IC_EVEX_XD_B, /* 8646 */ + IC_EVEX_XD_B, /* 8647 */ + IC_EVEX_W_B, /* 8648 */ + IC_EVEX_W_B, /* 8649 */ + IC_EVEX_W_XS_B, /* 8650 */ + IC_EVEX_W_XS_B, /* 8651 */ + IC_EVEX_W_XD_B, /* 8652 */ + IC_EVEX_W_XD_B, /* 8653 */ + IC_EVEX_W_XD_B, /* 8654 */ + IC_EVEX_W_XD_B, /* 8655 */ + IC_EVEX_OPSIZE_B, /* 8656 */ + IC_EVEX_OPSIZE_B, /* 8657 */ + IC_EVEX_OPSIZE_B, /* 8658 */ + IC_EVEX_OPSIZE_B, /* 8659 */ + IC_EVEX_OPSIZE_B, /* 8660 */ + IC_EVEX_OPSIZE_B, /* 8661 */ + IC_EVEX_OPSIZE_B, /* 8662 */ + IC_EVEX_OPSIZE_B, /* 8663 */ + IC_EVEX_W_OPSIZE_B, /* 8664 */ + IC_EVEX_W_OPSIZE_B, /* 8665 */ + IC_EVEX_W_OPSIZE_B, /* 8666 */ + IC_EVEX_W_OPSIZE_B, /* 8667 */ + IC_EVEX_W_OPSIZE_B, /* 8668 */ + IC_EVEX_W_OPSIZE_B, /* 8669 */ + IC_EVEX_W_OPSIZE_B, /* 8670 */ + IC_EVEX_W_OPSIZE_B, /* 8671 */ + IC_EVEX_B, /* 8672 */ + IC_EVEX_B, /* 8673 */ + IC_EVEX_XS_B, /* 8674 */ + IC_EVEX_XS_B, /* 8675 */ + IC_EVEX_XD_B, /* 8676 */ + IC_EVEX_XD_B, /* 8677 */ + IC_EVEX_XD_B, /* 8678 */ + IC_EVEX_XD_B, /* 8679 */ + IC_EVEX_W_B, /* 8680 */ + IC_EVEX_W_B, /* 8681 */ + IC_EVEX_W_XS_B, /* 8682 */ + IC_EVEX_W_XS_B, /* 8683 */ + IC_EVEX_W_XD_B, /* 8684 */ + IC_EVEX_W_XD_B, /* 8685 */ + IC_EVEX_W_XD_B, /* 8686 */ + IC_EVEX_W_XD_B, /* 8687 */ + IC_EVEX_OPSIZE_B, /* 8688 */ + IC_EVEX_OPSIZE_B, /* 8689 */ + IC_EVEX_OPSIZE_B, /* 8690 */ + IC_EVEX_OPSIZE_B, /* 8691 */ + IC_EVEX_OPSIZE_B, /* 8692 */ + IC_EVEX_OPSIZE_B, /* 8693 */ + IC_EVEX_OPSIZE_B, /* 8694 */ + IC_EVEX_OPSIZE_B, /* 8695 */ + IC_EVEX_W_OPSIZE_B, /* 8696 */ + IC_EVEX_W_OPSIZE_B, /* 8697 */ + IC_EVEX_W_OPSIZE_B, /* 8698 */ + IC_EVEX_W_OPSIZE_B, /* 8699 */ + IC_EVEX_W_OPSIZE_B, /* 8700 */ + IC_EVEX_W_OPSIZE_B, /* 8701 */ + IC_EVEX_W_OPSIZE_B, /* 8702 */ + IC_EVEX_W_OPSIZE_B, /* 8703 */ + IC, /* 8704 */ + IC_64BIT, /* 8705 */ + IC_XS, /* 8706 */ + IC_64BIT_XS, /* 8707 */ + IC_XD, /* 8708 */ + IC_64BIT_XD, /* 8709 */ + IC_XS, /* 8710 */ + IC_64BIT_XS, /* 8711 */ + IC, /* 8712 */ + IC_64BIT_REXW, /* 8713 */ + IC_XS, /* 8714 */ + IC_64BIT_REXW_XS, /* 8715 */ + IC_XD, /* 8716 */ + IC_64BIT_REXW_XD, /* 8717 */ + IC_XS, /* 8718 */ + IC_64BIT_REXW_XS, /* 8719 */ + IC_OPSIZE, /* 8720 */ + IC_64BIT_OPSIZE, /* 8721 */ + IC_XS_OPSIZE, /* 8722 */ + IC_64BIT_XS_OPSIZE, /* 8723 */ + IC_XD_OPSIZE, /* 8724 */ + IC_64BIT_XD_OPSIZE, /* 8725 */ + IC_XS_OPSIZE, /* 8726 */ + IC_64BIT_XD_OPSIZE, /* 8727 */ + IC_OPSIZE, /* 8728 */ + IC_64BIT_REXW_OPSIZE, /* 8729 */ + IC_XS_OPSIZE, /* 8730 */ + IC_64BIT_REXW_XS, /* 8731 */ + IC_XD_OPSIZE, /* 8732 */ + IC_64BIT_REXW_XD, /* 8733 */ + IC_XS_OPSIZE, /* 8734 */ + IC_64BIT_REXW_XS, /* 8735 */ + IC_ADSIZE, /* 8736 */ + IC_64BIT_ADSIZE, /* 8737 */ + IC_XS_ADSIZE, /* 8738 */ + IC_64BIT_XS_ADSIZE, /* 8739 */ + IC_XD_ADSIZE, /* 8740 */ + IC_64BIT_XD_ADSIZE, /* 8741 */ + IC_XS_ADSIZE, /* 8742 */ + IC_64BIT_XD_ADSIZE, /* 8743 */ + IC_ADSIZE, /* 8744 */ + IC_64BIT_REXW_ADSIZE, /* 8745 */ + IC_XS_ADSIZE, /* 8746 */ + IC_64BIT_REXW_XS, /* 8747 */ + IC_XD_ADSIZE, /* 8748 */ + IC_64BIT_REXW_XD, /* 8749 */ + IC_XS_ADSIZE, /* 8750 */ + IC_64BIT_REXW_XS, /* 8751 */ + IC_OPSIZE_ADSIZE, /* 8752 */ + IC_64BIT_OPSIZE_ADSIZE, /* 8753 */ + IC_XS_OPSIZE, /* 8754 */ + IC_64BIT_XS_OPSIZE, /* 8755 */ + IC_XD_OPSIZE, /* 8756 */ + IC_64BIT_XD_OPSIZE, /* 8757 */ + IC_XS_OPSIZE, /* 8758 */ + IC_64BIT_XD_OPSIZE, /* 8759 */ + IC_OPSIZE_ADSIZE, /* 8760 */ + IC_64BIT_REXW_OPSIZE, /* 8761 */ + IC_XS_OPSIZE, /* 8762 */ + IC_64BIT_REXW_XS, /* 8763 */ + IC_XD_OPSIZE, /* 8764 */ + IC_64BIT_REXW_XD, /* 8765 */ + IC_XS_OPSIZE, /* 8766 */ + IC_64BIT_REXW_XS, /* 8767 */ + IC_VEX, /* 8768 */ + IC_VEX, /* 8769 */ + IC_VEX_XS, /* 8770 */ + IC_VEX_XS, /* 8771 */ + IC_VEX_XD, /* 8772 */ + IC_VEX_XD, /* 8773 */ + IC_VEX_XD, /* 8774 */ + IC_VEX_XD, /* 8775 */ + IC_VEX_W, /* 8776 */ + IC_VEX_W, /* 8777 */ + IC_VEX_W_XS, /* 8778 */ + IC_VEX_W_XS, /* 8779 */ + IC_VEX_W_XD, /* 8780 */ + IC_VEX_W_XD, /* 8781 */ + IC_VEX_W_XD, /* 8782 */ + IC_VEX_W_XD, /* 8783 */ + IC_VEX_OPSIZE, /* 8784 */ + IC_VEX_OPSIZE, /* 8785 */ + IC_VEX_OPSIZE, /* 8786 */ + IC_VEX_OPSIZE, /* 8787 */ + IC_VEX_OPSIZE, /* 8788 */ + IC_VEX_OPSIZE, /* 8789 */ + IC_VEX_OPSIZE, /* 8790 */ + IC_VEX_OPSIZE, /* 8791 */ + IC_VEX_W_OPSIZE, /* 8792 */ + IC_VEX_W_OPSIZE, /* 8793 */ + IC_VEX_W_OPSIZE, /* 8794 */ + IC_VEX_W_OPSIZE, /* 8795 */ + IC_VEX_W_OPSIZE, /* 8796 */ + IC_VEX_W_OPSIZE, /* 8797 */ + IC_VEX_W_OPSIZE, /* 8798 */ + IC_VEX_W_OPSIZE, /* 8799 */ + IC_VEX, /* 8800 */ + IC_VEX, /* 8801 */ + IC_VEX_XS, /* 8802 */ + IC_VEX_XS, /* 8803 */ + IC_VEX_XD, /* 8804 */ + IC_VEX_XD, /* 8805 */ + IC_VEX_XD, /* 8806 */ + IC_VEX_XD, /* 8807 */ + IC_VEX_W, /* 8808 */ + IC_VEX_W, /* 8809 */ + IC_VEX_W_XS, /* 8810 */ + IC_VEX_W_XS, /* 8811 */ + IC_VEX_W_XD, /* 8812 */ + IC_VEX_W_XD, /* 8813 */ + IC_VEX_W_XD, /* 8814 */ + IC_VEX_W_XD, /* 8815 */ + IC_VEX_OPSIZE, /* 8816 */ + IC_VEX_OPSIZE, /* 8817 */ + IC_VEX_OPSIZE, /* 8818 */ + IC_VEX_OPSIZE, /* 8819 */ + IC_VEX_OPSIZE, /* 8820 */ + IC_VEX_OPSIZE, /* 8821 */ + IC_VEX_OPSIZE, /* 8822 */ + IC_VEX_OPSIZE, /* 8823 */ + IC_VEX_W_OPSIZE, /* 8824 */ + IC_VEX_W_OPSIZE, /* 8825 */ + IC_VEX_W_OPSIZE, /* 8826 */ + IC_VEX_W_OPSIZE, /* 8827 */ + IC_VEX_W_OPSIZE, /* 8828 */ + IC_VEX_W_OPSIZE, /* 8829 */ + IC_VEX_W_OPSIZE, /* 8830 */ + IC_VEX_W_OPSIZE, /* 8831 */ + IC_VEX_L, /* 8832 */ + IC_VEX_L, /* 8833 */ + IC_VEX_L_XS, /* 8834 */ + IC_VEX_L_XS, /* 8835 */ + IC_VEX_L_XD, /* 8836 */ + IC_VEX_L_XD, /* 8837 */ + IC_VEX_L_XD, /* 8838 */ + IC_VEX_L_XD, /* 8839 */ + IC_VEX_L_W, /* 8840 */ + IC_VEX_L_W, /* 8841 */ + IC_VEX_L_W_XS, /* 8842 */ + IC_VEX_L_W_XS, /* 8843 */ + IC_VEX_L_W_XD, /* 8844 */ + IC_VEX_L_W_XD, /* 8845 */ + IC_VEX_L_W_XD, /* 8846 */ + IC_VEX_L_W_XD, /* 8847 */ + IC_VEX_L_OPSIZE, /* 8848 */ + IC_VEX_L_OPSIZE, /* 8849 */ + IC_VEX_L_OPSIZE, /* 8850 */ + IC_VEX_L_OPSIZE, /* 8851 */ + IC_VEX_L_OPSIZE, /* 8852 */ + IC_VEX_L_OPSIZE, /* 8853 */ + IC_VEX_L_OPSIZE, /* 8854 */ + IC_VEX_L_OPSIZE, /* 8855 */ + IC_VEX_L_W_OPSIZE, /* 8856 */ + IC_VEX_L_W_OPSIZE, /* 8857 */ + IC_VEX_L_W_OPSIZE, /* 8858 */ + IC_VEX_L_W_OPSIZE, /* 8859 */ + IC_VEX_L_W_OPSIZE, /* 8860 */ + IC_VEX_L_W_OPSIZE, /* 8861 */ + IC_VEX_L_W_OPSIZE, /* 8862 */ + IC_VEX_L_W_OPSIZE, /* 8863 */ + IC_VEX_L, /* 8864 */ + IC_VEX_L, /* 8865 */ + IC_VEX_L_XS, /* 8866 */ + IC_VEX_L_XS, /* 8867 */ + IC_VEX_L_XD, /* 8868 */ + IC_VEX_L_XD, /* 8869 */ + IC_VEX_L_XD, /* 8870 */ + IC_VEX_L_XD, /* 8871 */ + IC_VEX_L_W, /* 8872 */ + IC_VEX_L_W, /* 8873 */ + IC_VEX_L_W_XS, /* 8874 */ + IC_VEX_L_W_XS, /* 8875 */ + IC_VEX_L_W_XD, /* 8876 */ + IC_VEX_L_W_XD, /* 8877 */ + IC_VEX_L_W_XD, /* 8878 */ + IC_VEX_L_W_XD, /* 8879 */ + IC_VEX_L_OPSIZE, /* 8880 */ + IC_VEX_L_OPSIZE, /* 8881 */ + IC_VEX_L_OPSIZE, /* 8882 */ + IC_VEX_L_OPSIZE, /* 8883 */ + IC_VEX_L_OPSIZE, /* 8884 */ + IC_VEX_L_OPSIZE, /* 8885 */ + IC_VEX_L_OPSIZE, /* 8886 */ + IC_VEX_L_OPSIZE, /* 8887 */ + IC_VEX_L_W_OPSIZE, /* 8888 */ + IC_VEX_L_W_OPSIZE, /* 8889 */ + IC_VEX_L_W_OPSIZE, /* 8890 */ + IC_VEX_L_W_OPSIZE, /* 8891 */ + IC_VEX_L_W_OPSIZE, /* 8892 */ + IC_VEX_L_W_OPSIZE, /* 8893 */ + IC_VEX_L_W_OPSIZE, /* 8894 */ + IC_VEX_L_W_OPSIZE, /* 8895 */ + IC_VEX_L, /* 8896 */ + IC_VEX_L, /* 8897 */ + IC_VEX_L_XS, /* 8898 */ + IC_VEX_L_XS, /* 8899 */ + IC_VEX_L_XD, /* 8900 */ + IC_VEX_L_XD, /* 8901 */ + IC_VEX_L_XD, /* 8902 */ + IC_VEX_L_XD, /* 8903 */ + IC_VEX_L_W, /* 8904 */ + IC_VEX_L_W, /* 8905 */ + IC_VEX_L_W_XS, /* 8906 */ + IC_VEX_L_W_XS, /* 8907 */ + IC_VEX_L_W_XD, /* 8908 */ + IC_VEX_L_W_XD, /* 8909 */ + IC_VEX_L_W_XD, /* 8910 */ + IC_VEX_L_W_XD, /* 8911 */ + IC_VEX_L_OPSIZE, /* 8912 */ + IC_VEX_L_OPSIZE, /* 8913 */ + IC_VEX_L_OPSIZE, /* 8914 */ + IC_VEX_L_OPSIZE, /* 8915 */ + IC_VEX_L_OPSIZE, /* 8916 */ + IC_VEX_L_OPSIZE, /* 8917 */ + IC_VEX_L_OPSIZE, /* 8918 */ + IC_VEX_L_OPSIZE, /* 8919 */ + IC_VEX_L_W_OPSIZE, /* 8920 */ + IC_VEX_L_W_OPSIZE, /* 8921 */ + IC_VEX_L_W_OPSIZE, /* 8922 */ + IC_VEX_L_W_OPSIZE, /* 8923 */ + IC_VEX_L_W_OPSIZE, /* 8924 */ + IC_VEX_L_W_OPSIZE, /* 8925 */ + IC_VEX_L_W_OPSIZE, /* 8926 */ + IC_VEX_L_W_OPSIZE, /* 8927 */ + IC_VEX_L, /* 8928 */ + IC_VEX_L, /* 8929 */ + IC_VEX_L_XS, /* 8930 */ + IC_VEX_L_XS, /* 8931 */ + IC_VEX_L_XD, /* 8932 */ + IC_VEX_L_XD, /* 8933 */ + IC_VEX_L_XD, /* 8934 */ + IC_VEX_L_XD, /* 8935 */ + IC_VEX_L_W, /* 8936 */ + IC_VEX_L_W, /* 8937 */ + IC_VEX_L_W_XS, /* 8938 */ + IC_VEX_L_W_XS, /* 8939 */ + IC_VEX_L_W_XD, /* 8940 */ + IC_VEX_L_W_XD, /* 8941 */ + IC_VEX_L_W_XD, /* 8942 */ + IC_VEX_L_W_XD, /* 8943 */ + IC_VEX_L_OPSIZE, /* 8944 */ + IC_VEX_L_OPSIZE, /* 8945 */ + IC_VEX_L_OPSIZE, /* 8946 */ + IC_VEX_L_OPSIZE, /* 8947 */ + IC_VEX_L_OPSIZE, /* 8948 */ + IC_VEX_L_OPSIZE, /* 8949 */ + IC_VEX_L_OPSIZE, /* 8950 */ + IC_VEX_L_OPSIZE, /* 8951 */ + IC_VEX_L_W_OPSIZE, /* 8952 */ + IC_VEX_L_W_OPSIZE, /* 8953 */ + IC_VEX_L_W_OPSIZE, /* 8954 */ + IC_VEX_L_W_OPSIZE, /* 8955 */ + IC_VEX_L_W_OPSIZE, /* 8956 */ + IC_VEX_L_W_OPSIZE, /* 8957 */ + IC_VEX_L_W_OPSIZE, /* 8958 */ + IC_VEX_L_W_OPSIZE, /* 8959 */ + IC_EVEX_L_B, /* 8960 */ + IC_EVEX_L_B, /* 8961 */ + IC_EVEX_L_XS_B, /* 8962 */ + IC_EVEX_L_XS_B, /* 8963 */ + IC_EVEX_L_XD_B, /* 8964 */ + IC_EVEX_L_XD_B, /* 8965 */ + IC_EVEX_L_XD_B, /* 8966 */ + IC_EVEX_L_XD_B, /* 8967 */ + IC_EVEX_L_W_B, /* 8968 */ + IC_EVEX_L_W_B, /* 8969 */ + IC_EVEX_L_W_XS_B, /* 8970 */ + IC_EVEX_L_W_XS_B, /* 8971 */ + IC_EVEX_L_W_XD_B, /* 8972 */ + IC_EVEX_L_W_XD_B, /* 8973 */ + IC_EVEX_L_W_XD_B, /* 8974 */ + IC_EVEX_L_W_XD_B, /* 8975 */ + IC_EVEX_L_OPSIZE_B, /* 8976 */ + IC_EVEX_L_OPSIZE_B, /* 8977 */ + IC_EVEX_L_OPSIZE_B, /* 8978 */ + IC_EVEX_L_OPSIZE_B, /* 8979 */ + IC_EVEX_L_OPSIZE_B, /* 8980 */ + IC_EVEX_L_OPSIZE_B, /* 8981 */ + IC_EVEX_L_OPSIZE_B, /* 8982 */ + IC_EVEX_L_OPSIZE_B, /* 8983 */ + IC_EVEX_L_W_OPSIZE_B, /* 8984 */ + IC_EVEX_L_W_OPSIZE_B, /* 8985 */ + IC_EVEX_L_W_OPSIZE_B, /* 8986 */ + IC_EVEX_L_W_OPSIZE_B, /* 8987 */ + IC_EVEX_L_W_OPSIZE_B, /* 8988 */ + IC_EVEX_L_W_OPSIZE_B, /* 8989 */ + IC_EVEX_L_W_OPSIZE_B, /* 8990 */ + IC_EVEX_L_W_OPSIZE_B, /* 8991 */ + IC_EVEX_L_B, /* 8992 */ + IC_EVEX_L_B, /* 8993 */ + IC_EVEX_L_XS_B, /* 8994 */ + IC_EVEX_L_XS_B, /* 8995 */ + IC_EVEX_L_XD_B, /* 8996 */ + IC_EVEX_L_XD_B, /* 8997 */ + IC_EVEX_L_XD_B, /* 8998 */ + IC_EVEX_L_XD_B, /* 8999 */ + IC_EVEX_L_W_B, /* 9000 */ + IC_EVEX_L_W_B, /* 9001 */ + IC_EVEX_L_W_XS_B, /* 9002 */ + IC_EVEX_L_W_XS_B, /* 9003 */ + IC_EVEX_L_W_XD_B, /* 9004 */ + IC_EVEX_L_W_XD_B, /* 9005 */ + IC_EVEX_L_W_XD_B, /* 9006 */ + IC_EVEX_L_W_XD_B, /* 9007 */ + IC_EVEX_L_OPSIZE_B, /* 9008 */ + IC_EVEX_L_OPSIZE_B, /* 9009 */ + IC_EVEX_L_OPSIZE_B, /* 9010 */ + IC_EVEX_L_OPSIZE_B, /* 9011 */ + IC_EVEX_L_OPSIZE_B, /* 9012 */ + IC_EVEX_L_OPSIZE_B, /* 9013 */ + IC_EVEX_L_OPSIZE_B, /* 9014 */ + IC_EVEX_L_OPSIZE_B, /* 9015 */ + IC_EVEX_L_W_OPSIZE_B, /* 9016 */ + IC_EVEX_L_W_OPSIZE_B, /* 9017 */ + IC_EVEX_L_W_OPSIZE_B, /* 9018 */ + IC_EVEX_L_W_OPSIZE_B, /* 9019 */ + IC_EVEX_L_W_OPSIZE_B, /* 9020 */ + IC_EVEX_L_W_OPSIZE_B, /* 9021 */ + IC_EVEX_L_W_OPSIZE_B, /* 9022 */ + IC_EVEX_L_W_OPSIZE_B, /* 9023 */ + IC_EVEX_L_B, /* 9024 */ + IC_EVEX_L_B, /* 9025 */ + IC_EVEX_L_XS_B, /* 9026 */ + IC_EVEX_L_XS_B, /* 9027 */ + IC_EVEX_L_XD_B, /* 9028 */ + IC_EVEX_L_XD_B, /* 9029 */ + IC_EVEX_L_XD_B, /* 9030 */ + IC_EVEX_L_XD_B, /* 9031 */ + IC_EVEX_L_W_B, /* 9032 */ + IC_EVEX_L_W_B, /* 9033 */ + IC_EVEX_L_W_XS_B, /* 9034 */ + IC_EVEX_L_W_XS_B, /* 9035 */ + IC_EVEX_L_W_XD_B, /* 9036 */ + IC_EVEX_L_W_XD_B, /* 9037 */ + IC_EVEX_L_W_XD_B, /* 9038 */ + IC_EVEX_L_W_XD_B, /* 9039 */ + IC_EVEX_L_OPSIZE_B, /* 9040 */ + IC_EVEX_L_OPSIZE_B, /* 9041 */ + IC_EVEX_L_OPSIZE_B, /* 9042 */ + IC_EVEX_L_OPSIZE_B, /* 9043 */ + IC_EVEX_L_OPSIZE_B, /* 9044 */ + IC_EVEX_L_OPSIZE_B, /* 9045 */ + IC_EVEX_L_OPSIZE_B, /* 9046 */ + IC_EVEX_L_OPSIZE_B, /* 9047 */ + IC_EVEX_L_W_OPSIZE_B, /* 9048 */ + IC_EVEX_L_W_OPSIZE_B, /* 9049 */ + IC_EVEX_L_W_OPSIZE_B, /* 9050 */ + IC_EVEX_L_W_OPSIZE_B, /* 9051 */ + IC_EVEX_L_W_OPSIZE_B, /* 9052 */ + IC_EVEX_L_W_OPSIZE_B, /* 9053 */ + IC_EVEX_L_W_OPSIZE_B, /* 9054 */ + IC_EVEX_L_W_OPSIZE_B, /* 9055 */ + IC_EVEX_L_B, /* 9056 */ + IC_EVEX_L_B, /* 9057 */ + IC_EVEX_L_XS_B, /* 9058 */ + IC_EVEX_L_XS_B, /* 9059 */ + IC_EVEX_L_XD_B, /* 9060 */ + IC_EVEX_L_XD_B, /* 9061 */ + IC_EVEX_L_XD_B, /* 9062 */ + IC_EVEX_L_XD_B, /* 9063 */ + IC_EVEX_L_W_B, /* 9064 */ + IC_EVEX_L_W_B, /* 9065 */ + IC_EVEX_L_W_XS_B, /* 9066 */ + IC_EVEX_L_W_XS_B, /* 9067 */ + IC_EVEX_L_W_XD_B, /* 9068 */ + IC_EVEX_L_W_XD_B, /* 9069 */ + IC_EVEX_L_W_XD_B, /* 9070 */ + IC_EVEX_L_W_XD_B, /* 9071 */ + IC_EVEX_L_OPSIZE_B, /* 9072 */ + IC_EVEX_L_OPSIZE_B, /* 9073 */ + IC_EVEX_L_OPSIZE_B, /* 9074 */ + IC_EVEX_L_OPSIZE_B, /* 9075 */ + IC_EVEX_L_OPSIZE_B, /* 9076 */ + IC_EVEX_L_OPSIZE_B, /* 9077 */ + IC_EVEX_L_OPSIZE_B, /* 9078 */ + IC_EVEX_L_OPSIZE_B, /* 9079 */ + IC_EVEX_L_W_OPSIZE_B, /* 9080 */ + IC_EVEX_L_W_OPSIZE_B, /* 9081 */ + IC_EVEX_L_W_OPSIZE_B, /* 9082 */ + IC_EVEX_L_W_OPSIZE_B, /* 9083 */ + IC_EVEX_L_W_OPSIZE_B, /* 9084 */ + IC_EVEX_L_W_OPSIZE_B, /* 9085 */ + IC_EVEX_L_W_OPSIZE_B, /* 9086 */ + IC_EVEX_L_W_OPSIZE_B, /* 9087 */ + IC_EVEX_L_B, /* 9088 */ + IC_EVEX_L_B, /* 9089 */ + IC_EVEX_L_XS_B, /* 9090 */ + IC_EVEX_L_XS_B, /* 9091 */ + IC_EVEX_L_XD_B, /* 9092 */ + IC_EVEX_L_XD_B, /* 9093 */ + IC_EVEX_L_XD_B, /* 9094 */ + IC_EVEX_L_XD_B, /* 9095 */ + IC_EVEX_L_W_B, /* 9096 */ + IC_EVEX_L_W_B, /* 9097 */ + IC_EVEX_L_W_XS_B, /* 9098 */ + IC_EVEX_L_W_XS_B, /* 9099 */ + IC_EVEX_L_W_XD_B, /* 9100 */ + IC_EVEX_L_W_XD_B, /* 9101 */ + IC_EVEX_L_W_XD_B, /* 9102 */ + IC_EVEX_L_W_XD_B, /* 9103 */ + IC_EVEX_L_OPSIZE_B, /* 9104 */ + IC_EVEX_L_OPSIZE_B, /* 9105 */ + IC_EVEX_L_OPSIZE_B, /* 9106 */ + IC_EVEX_L_OPSIZE_B, /* 9107 */ + IC_EVEX_L_OPSIZE_B, /* 9108 */ + IC_EVEX_L_OPSIZE_B, /* 9109 */ + IC_EVEX_L_OPSIZE_B, /* 9110 */ + IC_EVEX_L_OPSIZE_B, /* 9111 */ + IC_EVEX_L_W_OPSIZE_B, /* 9112 */ + IC_EVEX_L_W_OPSIZE_B, /* 9113 */ + IC_EVEX_L_W_OPSIZE_B, /* 9114 */ + IC_EVEX_L_W_OPSIZE_B, /* 9115 */ + IC_EVEX_L_W_OPSIZE_B, /* 9116 */ + IC_EVEX_L_W_OPSIZE_B, /* 9117 */ + IC_EVEX_L_W_OPSIZE_B, /* 9118 */ + IC_EVEX_L_W_OPSIZE_B, /* 9119 */ + IC_EVEX_L_B, /* 9120 */ + IC_EVEX_L_B, /* 9121 */ + IC_EVEX_L_XS_B, /* 9122 */ + IC_EVEX_L_XS_B, /* 9123 */ + IC_EVEX_L_XD_B, /* 9124 */ + IC_EVEX_L_XD_B, /* 9125 */ + IC_EVEX_L_XD_B, /* 9126 */ + IC_EVEX_L_XD_B, /* 9127 */ + IC_EVEX_L_W_B, /* 9128 */ + IC_EVEX_L_W_B, /* 9129 */ + IC_EVEX_L_W_XS_B, /* 9130 */ + IC_EVEX_L_W_XS_B, /* 9131 */ + IC_EVEX_L_W_XD_B, /* 9132 */ + IC_EVEX_L_W_XD_B, /* 9133 */ + IC_EVEX_L_W_XD_B, /* 9134 */ + IC_EVEX_L_W_XD_B, /* 9135 */ + IC_EVEX_L_OPSIZE_B, /* 9136 */ + IC_EVEX_L_OPSIZE_B, /* 9137 */ + IC_EVEX_L_OPSIZE_B, /* 9138 */ + IC_EVEX_L_OPSIZE_B, /* 9139 */ + IC_EVEX_L_OPSIZE_B, /* 9140 */ + IC_EVEX_L_OPSIZE_B, /* 9141 */ + IC_EVEX_L_OPSIZE_B, /* 9142 */ + IC_EVEX_L_OPSIZE_B, /* 9143 */ + IC_EVEX_L_W_OPSIZE_B, /* 9144 */ + IC_EVEX_L_W_OPSIZE_B, /* 9145 */ + IC_EVEX_L_W_OPSIZE_B, /* 9146 */ + IC_EVEX_L_W_OPSIZE_B, /* 9147 */ + IC_EVEX_L_W_OPSIZE_B, /* 9148 */ + IC_EVEX_L_W_OPSIZE_B, /* 9149 */ + IC_EVEX_L_W_OPSIZE_B, /* 9150 */ + IC_EVEX_L_W_OPSIZE_B, /* 9151 */ + IC_EVEX_L_B, /* 9152 */ + IC_EVEX_L_B, /* 9153 */ + IC_EVEX_L_XS_B, /* 9154 */ + IC_EVEX_L_XS_B, /* 9155 */ + IC_EVEX_L_XD_B, /* 9156 */ + IC_EVEX_L_XD_B, /* 9157 */ + IC_EVEX_L_XD_B, /* 9158 */ + IC_EVEX_L_XD_B, /* 9159 */ + IC_EVEX_L_W_B, /* 9160 */ + IC_EVEX_L_W_B, /* 9161 */ + IC_EVEX_L_W_XS_B, /* 9162 */ + IC_EVEX_L_W_XS_B, /* 9163 */ + IC_EVEX_L_W_XD_B, /* 9164 */ + IC_EVEX_L_W_XD_B, /* 9165 */ + IC_EVEX_L_W_XD_B, /* 9166 */ + IC_EVEX_L_W_XD_B, /* 9167 */ + IC_EVEX_L_OPSIZE_B, /* 9168 */ + IC_EVEX_L_OPSIZE_B, /* 9169 */ + IC_EVEX_L_OPSIZE_B, /* 9170 */ + IC_EVEX_L_OPSIZE_B, /* 9171 */ + IC_EVEX_L_OPSIZE_B, /* 9172 */ + IC_EVEX_L_OPSIZE_B, /* 9173 */ + IC_EVEX_L_OPSIZE_B, /* 9174 */ + IC_EVEX_L_OPSIZE_B, /* 9175 */ + IC_EVEX_L_W_OPSIZE_B, /* 9176 */ + IC_EVEX_L_W_OPSIZE_B, /* 9177 */ + IC_EVEX_L_W_OPSIZE_B, /* 9178 */ + IC_EVEX_L_W_OPSIZE_B, /* 9179 */ + IC_EVEX_L_W_OPSIZE_B, /* 9180 */ + IC_EVEX_L_W_OPSIZE_B, /* 9181 */ + IC_EVEX_L_W_OPSIZE_B, /* 9182 */ + IC_EVEX_L_W_OPSIZE_B, /* 9183 */ + IC_EVEX_L_B, /* 9184 */ + IC_EVEX_L_B, /* 9185 */ + IC_EVEX_L_XS_B, /* 9186 */ + IC_EVEX_L_XS_B, /* 9187 */ + IC_EVEX_L_XD_B, /* 9188 */ + IC_EVEX_L_XD_B, /* 9189 */ + IC_EVEX_L_XD_B, /* 9190 */ + IC_EVEX_L_XD_B, /* 9191 */ + IC_EVEX_L_W_B, /* 9192 */ + IC_EVEX_L_W_B, /* 9193 */ + IC_EVEX_L_W_XS_B, /* 9194 */ + IC_EVEX_L_W_XS_B, /* 9195 */ + IC_EVEX_L_W_XD_B, /* 9196 */ + IC_EVEX_L_W_XD_B, /* 9197 */ + IC_EVEX_L_W_XD_B, /* 9198 */ + IC_EVEX_L_W_XD_B, /* 9199 */ + IC_EVEX_L_OPSIZE_B, /* 9200 */ + IC_EVEX_L_OPSIZE_B, /* 9201 */ + IC_EVEX_L_OPSIZE_B, /* 9202 */ + IC_EVEX_L_OPSIZE_B, /* 9203 */ + IC_EVEX_L_OPSIZE_B, /* 9204 */ + IC_EVEX_L_OPSIZE_B, /* 9205 */ + IC_EVEX_L_OPSIZE_B, /* 9206 */ + IC_EVEX_L_OPSIZE_B, /* 9207 */ + IC_EVEX_L_W_OPSIZE_B, /* 9208 */ + IC_EVEX_L_W_OPSIZE_B, /* 9209 */ + IC_EVEX_L_W_OPSIZE_B, /* 9210 */ + IC_EVEX_L_W_OPSIZE_B, /* 9211 */ + IC_EVEX_L_W_OPSIZE_B, /* 9212 */ + IC_EVEX_L_W_OPSIZE_B, /* 9213 */ + IC_EVEX_L_W_OPSIZE_B, /* 9214 */ + IC_EVEX_L_W_OPSIZE_B, /* 9215 */ + IC, /* 9216 */ + IC_64BIT, /* 9217 */ + IC_XS, /* 9218 */ + IC_64BIT_XS, /* 9219 */ + IC_XD, /* 9220 */ + IC_64BIT_XD, /* 9221 */ + IC_XS, /* 9222 */ + IC_64BIT_XS, /* 9223 */ + IC, /* 9224 */ + IC_64BIT_REXW, /* 9225 */ + IC_XS, /* 9226 */ + IC_64BIT_REXW_XS, /* 9227 */ + IC_XD, /* 9228 */ + IC_64BIT_REXW_XD, /* 9229 */ + IC_XS, /* 9230 */ + IC_64BIT_REXW_XS, /* 9231 */ + IC_OPSIZE, /* 9232 */ + IC_64BIT_OPSIZE, /* 9233 */ + IC_XS_OPSIZE, /* 9234 */ + IC_64BIT_XS_OPSIZE, /* 9235 */ + IC_XD_OPSIZE, /* 9236 */ + IC_64BIT_XD_OPSIZE, /* 9237 */ + IC_XS_OPSIZE, /* 9238 */ + IC_64BIT_XD_OPSIZE, /* 9239 */ + IC_OPSIZE, /* 9240 */ + IC_64BIT_REXW_OPSIZE, /* 9241 */ + IC_XS_OPSIZE, /* 9242 */ + IC_64BIT_REXW_XS, /* 9243 */ + IC_XD_OPSIZE, /* 9244 */ + IC_64BIT_REXW_XD, /* 9245 */ + IC_XS_OPSIZE, /* 9246 */ + IC_64BIT_REXW_XS, /* 9247 */ + IC_ADSIZE, /* 9248 */ + IC_64BIT_ADSIZE, /* 9249 */ + IC_XS_ADSIZE, /* 9250 */ + IC_64BIT_XS_ADSIZE, /* 9251 */ + IC_XD_ADSIZE, /* 9252 */ + IC_64BIT_XD_ADSIZE, /* 9253 */ + IC_XS_ADSIZE, /* 9254 */ + IC_64BIT_XD_ADSIZE, /* 9255 */ + IC_ADSIZE, /* 9256 */ + IC_64BIT_REXW_ADSIZE, /* 9257 */ + IC_XS_ADSIZE, /* 9258 */ + IC_64BIT_REXW_XS, /* 9259 */ + IC_XD_ADSIZE, /* 9260 */ + IC_64BIT_REXW_XD, /* 9261 */ + IC_XS_ADSIZE, /* 9262 */ + IC_64BIT_REXW_XS, /* 9263 */ + IC_OPSIZE_ADSIZE, /* 9264 */ + IC_64BIT_OPSIZE_ADSIZE, /* 9265 */ + IC_XS_OPSIZE, /* 9266 */ + IC_64BIT_XS_OPSIZE, /* 9267 */ + IC_XD_OPSIZE, /* 9268 */ + IC_64BIT_XD_OPSIZE, /* 9269 */ + IC_XS_OPSIZE, /* 9270 */ + IC_64BIT_XD_OPSIZE, /* 9271 */ + IC_OPSIZE_ADSIZE, /* 9272 */ + IC_64BIT_REXW_OPSIZE, /* 9273 */ + IC_XS_OPSIZE, /* 9274 */ + IC_64BIT_REXW_XS, /* 9275 */ + IC_XD_OPSIZE, /* 9276 */ + IC_64BIT_REXW_XD, /* 9277 */ + IC_XS_OPSIZE, /* 9278 */ + IC_64BIT_REXW_XS, /* 9279 */ + IC_VEX, /* 9280 */ + IC_VEX, /* 9281 */ + IC_VEX_XS, /* 9282 */ + IC_VEX_XS, /* 9283 */ + IC_VEX_XD, /* 9284 */ + IC_VEX_XD, /* 9285 */ + IC_VEX_XD, /* 9286 */ + IC_VEX_XD, /* 9287 */ + IC_VEX_W, /* 9288 */ + IC_VEX_W, /* 9289 */ + IC_VEX_W_XS, /* 9290 */ + IC_VEX_W_XS, /* 9291 */ + IC_VEX_W_XD, /* 9292 */ + IC_VEX_W_XD, /* 9293 */ + IC_VEX_W_XD, /* 9294 */ + IC_VEX_W_XD, /* 9295 */ + IC_VEX_OPSIZE, /* 9296 */ + IC_VEX_OPSIZE, /* 9297 */ + IC_VEX_OPSIZE, /* 9298 */ + IC_VEX_OPSIZE, /* 9299 */ + IC_VEX_OPSIZE, /* 9300 */ + IC_VEX_OPSIZE, /* 9301 */ + IC_VEX_OPSIZE, /* 9302 */ + IC_VEX_OPSIZE, /* 9303 */ + IC_VEX_W_OPSIZE, /* 9304 */ + IC_VEX_W_OPSIZE, /* 9305 */ + IC_VEX_W_OPSIZE, /* 9306 */ + IC_VEX_W_OPSIZE, /* 9307 */ + IC_VEX_W_OPSIZE, /* 9308 */ + IC_VEX_W_OPSIZE, /* 9309 */ + IC_VEX_W_OPSIZE, /* 9310 */ + IC_VEX_W_OPSIZE, /* 9311 */ + IC_VEX, /* 9312 */ + IC_VEX, /* 9313 */ + IC_VEX_XS, /* 9314 */ + IC_VEX_XS, /* 9315 */ + IC_VEX_XD, /* 9316 */ + IC_VEX_XD, /* 9317 */ + IC_VEX_XD, /* 9318 */ + IC_VEX_XD, /* 9319 */ + IC_VEX_W, /* 9320 */ + IC_VEX_W, /* 9321 */ + IC_VEX_W_XS, /* 9322 */ + IC_VEX_W_XS, /* 9323 */ + IC_VEX_W_XD, /* 9324 */ + IC_VEX_W_XD, /* 9325 */ + IC_VEX_W_XD, /* 9326 */ + IC_VEX_W_XD, /* 9327 */ + IC_VEX_OPSIZE, /* 9328 */ + IC_VEX_OPSIZE, /* 9329 */ + IC_VEX_OPSIZE, /* 9330 */ + IC_VEX_OPSIZE, /* 9331 */ + IC_VEX_OPSIZE, /* 9332 */ + IC_VEX_OPSIZE, /* 9333 */ + IC_VEX_OPSIZE, /* 9334 */ + IC_VEX_OPSIZE, /* 9335 */ + IC_VEX_W_OPSIZE, /* 9336 */ + IC_VEX_W_OPSIZE, /* 9337 */ + IC_VEX_W_OPSIZE, /* 9338 */ + IC_VEX_W_OPSIZE, /* 9339 */ + IC_VEX_W_OPSIZE, /* 9340 */ + IC_VEX_W_OPSIZE, /* 9341 */ + IC_VEX_W_OPSIZE, /* 9342 */ + IC_VEX_W_OPSIZE, /* 9343 */ + IC_VEX_L, /* 9344 */ + IC_VEX_L, /* 9345 */ + IC_VEX_L_XS, /* 9346 */ + IC_VEX_L_XS, /* 9347 */ + IC_VEX_L_XD, /* 9348 */ + IC_VEX_L_XD, /* 9349 */ + IC_VEX_L_XD, /* 9350 */ + IC_VEX_L_XD, /* 9351 */ + IC_VEX_L_W, /* 9352 */ + IC_VEX_L_W, /* 9353 */ + IC_VEX_L_W_XS, /* 9354 */ + IC_VEX_L_W_XS, /* 9355 */ + IC_VEX_L_W_XD, /* 9356 */ + IC_VEX_L_W_XD, /* 9357 */ + IC_VEX_L_W_XD, /* 9358 */ + IC_VEX_L_W_XD, /* 9359 */ + IC_VEX_L_OPSIZE, /* 9360 */ + IC_VEX_L_OPSIZE, /* 9361 */ + IC_VEX_L_OPSIZE, /* 9362 */ + IC_VEX_L_OPSIZE, /* 9363 */ + IC_VEX_L_OPSIZE, /* 9364 */ + IC_VEX_L_OPSIZE, /* 9365 */ + IC_VEX_L_OPSIZE, /* 9366 */ + IC_VEX_L_OPSIZE, /* 9367 */ + IC_VEX_L_W_OPSIZE, /* 9368 */ + IC_VEX_L_W_OPSIZE, /* 9369 */ + IC_VEX_L_W_OPSIZE, /* 9370 */ + IC_VEX_L_W_OPSIZE, /* 9371 */ + IC_VEX_L_W_OPSIZE, /* 9372 */ + IC_VEX_L_W_OPSIZE, /* 9373 */ + IC_VEX_L_W_OPSIZE, /* 9374 */ + IC_VEX_L_W_OPSIZE, /* 9375 */ + IC_VEX_L, /* 9376 */ + IC_VEX_L, /* 9377 */ + IC_VEX_L_XS, /* 9378 */ + IC_VEX_L_XS, /* 9379 */ + IC_VEX_L_XD, /* 9380 */ + IC_VEX_L_XD, /* 9381 */ + IC_VEX_L_XD, /* 9382 */ + IC_VEX_L_XD, /* 9383 */ + IC_VEX_L_W, /* 9384 */ + IC_VEX_L_W, /* 9385 */ + IC_VEX_L_W_XS, /* 9386 */ + IC_VEX_L_W_XS, /* 9387 */ + IC_VEX_L_W_XD, /* 9388 */ + IC_VEX_L_W_XD, /* 9389 */ + IC_VEX_L_W_XD, /* 9390 */ + IC_VEX_L_W_XD, /* 9391 */ + IC_VEX_L_OPSIZE, /* 9392 */ + IC_VEX_L_OPSIZE, /* 9393 */ + IC_VEX_L_OPSIZE, /* 9394 */ + IC_VEX_L_OPSIZE, /* 9395 */ + IC_VEX_L_OPSIZE, /* 9396 */ + IC_VEX_L_OPSIZE, /* 9397 */ + IC_VEX_L_OPSIZE, /* 9398 */ + IC_VEX_L_OPSIZE, /* 9399 */ + IC_VEX_L_W_OPSIZE, /* 9400 */ + IC_VEX_L_W_OPSIZE, /* 9401 */ + IC_VEX_L_W_OPSIZE, /* 9402 */ + IC_VEX_L_W_OPSIZE, /* 9403 */ + IC_VEX_L_W_OPSIZE, /* 9404 */ + IC_VEX_L_W_OPSIZE, /* 9405 */ + IC_VEX_L_W_OPSIZE, /* 9406 */ + IC_VEX_L_W_OPSIZE, /* 9407 */ + IC_VEX_L, /* 9408 */ + IC_VEX_L, /* 9409 */ + IC_VEX_L_XS, /* 9410 */ + IC_VEX_L_XS, /* 9411 */ + IC_VEX_L_XD, /* 9412 */ + IC_VEX_L_XD, /* 9413 */ + IC_VEX_L_XD, /* 9414 */ + IC_VEX_L_XD, /* 9415 */ + IC_VEX_L_W, /* 9416 */ + IC_VEX_L_W, /* 9417 */ + IC_VEX_L_W_XS, /* 9418 */ + IC_VEX_L_W_XS, /* 9419 */ + IC_VEX_L_W_XD, /* 9420 */ + IC_VEX_L_W_XD, /* 9421 */ + IC_VEX_L_W_XD, /* 9422 */ + IC_VEX_L_W_XD, /* 9423 */ + IC_VEX_L_OPSIZE, /* 9424 */ + IC_VEX_L_OPSIZE, /* 9425 */ + IC_VEX_L_OPSIZE, /* 9426 */ + IC_VEX_L_OPSIZE, /* 9427 */ + IC_VEX_L_OPSIZE, /* 9428 */ + IC_VEX_L_OPSIZE, /* 9429 */ + IC_VEX_L_OPSIZE, /* 9430 */ + IC_VEX_L_OPSIZE, /* 9431 */ + IC_VEX_L_W_OPSIZE, /* 9432 */ + IC_VEX_L_W_OPSIZE, /* 9433 */ + IC_VEX_L_W_OPSIZE, /* 9434 */ + IC_VEX_L_W_OPSIZE, /* 9435 */ + IC_VEX_L_W_OPSIZE, /* 9436 */ + IC_VEX_L_W_OPSIZE, /* 9437 */ + IC_VEX_L_W_OPSIZE, /* 9438 */ + IC_VEX_L_W_OPSIZE, /* 9439 */ + IC_VEX_L, /* 9440 */ + IC_VEX_L, /* 9441 */ + IC_VEX_L_XS, /* 9442 */ + IC_VEX_L_XS, /* 9443 */ + IC_VEX_L_XD, /* 9444 */ + IC_VEX_L_XD, /* 9445 */ + IC_VEX_L_XD, /* 9446 */ + IC_VEX_L_XD, /* 9447 */ + IC_VEX_L_W, /* 9448 */ + IC_VEX_L_W, /* 9449 */ + IC_VEX_L_W_XS, /* 9450 */ + IC_VEX_L_W_XS, /* 9451 */ + IC_VEX_L_W_XD, /* 9452 */ + IC_VEX_L_W_XD, /* 9453 */ + IC_VEX_L_W_XD, /* 9454 */ + IC_VEX_L_W_XD, /* 9455 */ + IC_VEX_L_OPSIZE, /* 9456 */ + IC_VEX_L_OPSIZE, /* 9457 */ + IC_VEX_L_OPSIZE, /* 9458 */ + IC_VEX_L_OPSIZE, /* 9459 */ + IC_VEX_L_OPSIZE, /* 9460 */ + IC_VEX_L_OPSIZE, /* 9461 */ + IC_VEX_L_OPSIZE, /* 9462 */ + IC_VEX_L_OPSIZE, /* 9463 */ + IC_VEX_L_W_OPSIZE, /* 9464 */ + IC_VEX_L_W_OPSIZE, /* 9465 */ + IC_VEX_L_W_OPSIZE, /* 9466 */ + IC_VEX_L_W_OPSIZE, /* 9467 */ + IC_VEX_L_W_OPSIZE, /* 9468 */ + IC_VEX_L_W_OPSIZE, /* 9469 */ + IC_VEX_L_W_OPSIZE, /* 9470 */ + IC_VEX_L_W_OPSIZE, /* 9471 */ + IC_EVEX_L2_B, /* 9472 */ + IC_EVEX_L2_B, /* 9473 */ + IC_EVEX_L2_XS_B, /* 9474 */ + IC_EVEX_L2_XS_B, /* 9475 */ + IC_EVEX_L2_XD_B, /* 9476 */ + IC_EVEX_L2_XD_B, /* 9477 */ + IC_EVEX_L2_XD_B, /* 9478 */ + IC_EVEX_L2_XD_B, /* 9479 */ + IC_EVEX_L2_W_B, /* 9480 */ + IC_EVEX_L2_W_B, /* 9481 */ + IC_EVEX_L2_W_XS_B, /* 9482 */ + IC_EVEX_L2_W_XS_B, /* 9483 */ + IC_EVEX_L2_W_XD_B, /* 9484 */ + IC_EVEX_L2_W_XD_B, /* 9485 */ + IC_EVEX_L2_W_XD_B, /* 9486 */ + IC_EVEX_L2_W_XD_B, /* 9487 */ + IC_EVEX_L2_OPSIZE_B, /* 9488 */ + IC_EVEX_L2_OPSIZE_B, /* 9489 */ + IC_EVEX_L2_OPSIZE_B, /* 9490 */ + IC_EVEX_L2_OPSIZE_B, /* 9491 */ + IC_EVEX_L2_OPSIZE_B, /* 9492 */ + IC_EVEX_L2_OPSIZE_B, /* 9493 */ + IC_EVEX_L2_OPSIZE_B, /* 9494 */ + IC_EVEX_L2_OPSIZE_B, /* 9495 */ + IC_EVEX_L2_W_OPSIZE_B, /* 9496 */ + IC_EVEX_L2_W_OPSIZE_B, /* 9497 */ + IC_EVEX_L2_W_OPSIZE_B, /* 9498 */ + IC_EVEX_L2_W_OPSIZE_B, /* 9499 */ + IC_EVEX_L2_W_OPSIZE_B, /* 9500 */ + IC_EVEX_L2_W_OPSIZE_B, /* 9501 */ + IC_EVEX_L2_W_OPSIZE_B, /* 9502 */ + IC_EVEX_L2_W_OPSIZE_B, /* 9503 */ + IC_EVEX_L2_B, /* 9504 */ + IC_EVEX_L2_B, /* 9505 */ + IC_EVEX_L2_XS_B, /* 9506 */ + IC_EVEX_L2_XS_B, /* 9507 */ + IC_EVEX_L2_XD_B, /* 9508 */ + IC_EVEX_L2_XD_B, /* 9509 */ + IC_EVEX_L2_XD_B, /* 9510 */ + IC_EVEX_L2_XD_B, /* 9511 */ + IC_EVEX_L2_W_B, /* 9512 */ + IC_EVEX_L2_W_B, /* 9513 */ + IC_EVEX_L2_W_XS_B, /* 9514 */ + IC_EVEX_L2_W_XS_B, /* 9515 */ + IC_EVEX_L2_W_XD_B, /* 9516 */ + IC_EVEX_L2_W_XD_B, /* 9517 */ + IC_EVEX_L2_W_XD_B, /* 9518 */ + IC_EVEX_L2_W_XD_B, /* 9519 */ + IC_EVEX_L2_OPSIZE_B, /* 9520 */ + IC_EVEX_L2_OPSIZE_B, /* 9521 */ + IC_EVEX_L2_OPSIZE_B, /* 9522 */ + IC_EVEX_L2_OPSIZE_B, /* 9523 */ + IC_EVEX_L2_OPSIZE_B, /* 9524 */ + IC_EVEX_L2_OPSIZE_B, /* 9525 */ + IC_EVEX_L2_OPSIZE_B, /* 9526 */ + IC_EVEX_L2_OPSIZE_B, /* 9527 */ + IC_EVEX_L2_W_OPSIZE_B, /* 9528 */ + IC_EVEX_L2_W_OPSIZE_B, /* 9529 */ + IC_EVEX_L2_W_OPSIZE_B, /* 9530 */ + IC_EVEX_L2_W_OPSIZE_B, /* 9531 */ + IC_EVEX_L2_W_OPSIZE_B, /* 9532 */ + IC_EVEX_L2_W_OPSIZE_B, /* 9533 */ + IC_EVEX_L2_W_OPSIZE_B, /* 9534 */ + IC_EVEX_L2_W_OPSIZE_B, /* 9535 */ + IC_EVEX_L2_B, /* 9536 */ + IC_EVEX_L2_B, /* 9537 */ + IC_EVEX_L2_XS_B, /* 9538 */ + IC_EVEX_L2_XS_B, /* 9539 */ + IC_EVEX_L2_XD_B, /* 9540 */ + IC_EVEX_L2_XD_B, /* 9541 */ + IC_EVEX_L2_XD_B, /* 9542 */ + IC_EVEX_L2_XD_B, /* 9543 */ + IC_EVEX_L2_W_B, /* 9544 */ + IC_EVEX_L2_W_B, /* 9545 */ + IC_EVEX_L2_W_XS_B, /* 9546 */ + IC_EVEX_L2_W_XS_B, /* 9547 */ + IC_EVEX_L2_W_XD_B, /* 9548 */ + IC_EVEX_L2_W_XD_B, /* 9549 */ + IC_EVEX_L2_W_XD_B, /* 9550 */ + IC_EVEX_L2_W_XD_B, /* 9551 */ + IC_EVEX_L2_OPSIZE_B, /* 9552 */ + IC_EVEX_L2_OPSIZE_B, /* 9553 */ + IC_EVEX_L2_OPSIZE_B, /* 9554 */ + IC_EVEX_L2_OPSIZE_B, /* 9555 */ + IC_EVEX_L2_OPSIZE_B, /* 9556 */ + IC_EVEX_L2_OPSIZE_B, /* 9557 */ + IC_EVEX_L2_OPSIZE_B, /* 9558 */ + IC_EVEX_L2_OPSIZE_B, /* 9559 */ + IC_EVEX_L2_W_OPSIZE_B, /* 9560 */ + IC_EVEX_L2_W_OPSIZE_B, /* 9561 */ + IC_EVEX_L2_W_OPSIZE_B, /* 9562 */ + IC_EVEX_L2_W_OPSIZE_B, /* 9563 */ + IC_EVEX_L2_W_OPSIZE_B, /* 9564 */ + IC_EVEX_L2_W_OPSIZE_B, /* 9565 */ + IC_EVEX_L2_W_OPSIZE_B, /* 9566 */ + IC_EVEX_L2_W_OPSIZE_B, /* 9567 */ + IC_EVEX_L2_B, /* 9568 */ + IC_EVEX_L2_B, /* 9569 */ + IC_EVEX_L2_XS_B, /* 9570 */ + IC_EVEX_L2_XS_B, /* 9571 */ + IC_EVEX_L2_XD_B, /* 9572 */ + IC_EVEX_L2_XD_B, /* 9573 */ + IC_EVEX_L2_XD_B, /* 9574 */ + IC_EVEX_L2_XD_B, /* 9575 */ + IC_EVEX_L2_W_B, /* 9576 */ + IC_EVEX_L2_W_B, /* 9577 */ + IC_EVEX_L2_W_XS_B, /* 9578 */ + IC_EVEX_L2_W_XS_B, /* 9579 */ + IC_EVEX_L2_W_XD_B, /* 9580 */ + IC_EVEX_L2_W_XD_B, /* 9581 */ + IC_EVEX_L2_W_XD_B, /* 9582 */ + IC_EVEX_L2_W_XD_B, /* 9583 */ + IC_EVEX_L2_OPSIZE_B, /* 9584 */ + IC_EVEX_L2_OPSIZE_B, /* 9585 */ + IC_EVEX_L2_OPSIZE_B, /* 9586 */ + IC_EVEX_L2_OPSIZE_B, /* 9587 */ + IC_EVEX_L2_OPSIZE_B, /* 9588 */ + IC_EVEX_L2_OPSIZE_B, /* 9589 */ + IC_EVEX_L2_OPSIZE_B, /* 9590 */ + IC_EVEX_L2_OPSIZE_B, /* 9591 */ + IC_EVEX_L2_W_OPSIZE_B, /* 9592 */ + IC_EVEX_L2_W_OPSIZE_B, /* 9593 */ + IC_EVEX_L2_W_OPSIZE_B, /* 9594 */ + IC_EVEX_L2_W_OPSIZE_B, /* 9595 */ + IC_EVEX_L2_W_OPSIZE_B, /* 9596 */ + IC_EVEX_L2_W_OPSIZE_B, /* 9597 */ + IC_EVEX_L2_W_OPSIZE_B, /* 9598 */ + IC_EVEX_L2_W_OPSIZE_B, /* 9599 */ + IC_EVEX_L2_B, /* 9600 */ + IC_EVEX_L2_B, /* 9601 */ + IC_EVEX_L2_XS_B, /* 9602 */ + IC_EVEX_L2_XS_B, /* 9603 */ + IC_EVEX_L2_XD_B, /* 9604 */ + IC_EVEX_L2_XD_B, /* 9605 */ + IC_EVEX_L2_XD_B, /* 9606 */ + IC_EVEX_L2_XD_B, /* 9607 */ + IC_EVEX_L2_W_B, /* 9608 */ + IC_EVEX_L2_W_B, /* 9609 */ + IC_EVEX_L2_W_XS_B, /* 9610 */ + IC_EVEX_L2_W_XS_B, /* 9611 */ + IC_EVEX_L2_W_XD_B, /* 9612 */ + IC_EVEX_L2_W_XD_B, /* 9613 */ + IC_EVEX_L2_W_XD_B, /* 9614 */ + IC_EVEX_L2_W_XD_B, /* 9615 */ + IC_EVEX_L2_OPSIZE_B, /* 9616 */ + IC_EVEX_L2_OPSIZE_B, /* 9617 */ + IC_EVEX_L2_OPSIZE_B, /* 9618 */ + IC_EVEX_L2_OPSIZE_B, /* 9619 */ + IC_EVEX_L2_OPSIZE_B, /* 9620 */ + IC_EVEX_L2_OPSIZE_B, /* 9621 */ + IC_EVEX_L2_OPSIZE_B, /* 9622 */ + IC_EVEX_L2_OPSIZE_B, /* 9623 */ + IC_EVEX_L2_W_OPSIZE_B, /* 9624 */ + IC_EVEX_L2_W_OPSIZE_B, /* 9625 */ + IC_EVEX_L2_W_OPSIZE_B, /* 9626 */ + IC_EVEX_L2_W_OPSIZE_B, /* 9627 */ + IC_EVEX_L2_W_OPSIZE_B, /* 9628 */ + IC_EVEX_L2_W_OPSIZE_B, /* 9629 */ + IC_EVEX_L2_W_OPSIZE_B, /* 9630 */ + IC_EVEX_L2_W_OPSIZE_B, /* 9631 */ + IC_EVEX_L2_B, /* 9632 */ + IC_EVEX_L2_B, /* 9633 */ + IC_EVEX_L2_XS_B, /* 9634 */ + IC_EVEX_L2_XS_B, /* 9635 */ + IC_EVEX_L2_XD_B, /* 9636 */ + IC_EVEX_L2_XD_B, /* 9637 */ + IC_EVEX_L2_XD_B, /* 9638 */ + IC_EVEX_L2_XD_B, /* 9639 */ + IC_EVEX_L2_W_B, /* 9640 */ + IC_EVEX_L2_W_B, /* 9641 */ + IC_EVEX_L2_W_XS_B, /* 9642 */ + IC_EVEX_L2_W_XS_B, /* 9643 */ + IC_EVEX_L2_W_XD_B, /* 9644 */ + IC_EVEX_L2_W_XD_B, /* 9645 */ + IC_EVEX_L2_W_XD_B, /* 9646 */ + IC_EVEX_L2_W_XD_B, /* 9647 */ + IC_EVEX_L2_OPSIZE_B, /* 9648 */ + IC_EVEX_L2_OPSIZE_B, /* 9649 */ + IC_EVEX_L2_OPSIZE_B, /* 9650 */ + IC_EVEX_L2_OPSIZE_B, /* 9651 */ + IC_EVEX_L2_OPSIZE_B, /* 9652 */ + IC_EVEX_L2_OPSIZE_B, /* 9653 */ + IC_EVEX_L2_OPSIZE_B, /* 9654 */ + IC_EVEX_L2_OPSIZE_B, /* 9655 */ + IC_EVEX_L2_W_OPSIZE_B, /* 9656 */ + IC_EVEX_L2_W_OPSIZE_B, /* 9657 */ + IC_EVEX_L2_W_OPSIZE_B, /* 9658 */ + IC_EVEX_L2_W_OPSIZE_B, /* 9659 */ + IC_EVEX_L2_W_OPSIZE_B, /* 9660 */ + IC_EVEX_L2_W_OPSIZE_B, /* 9661 */ + IC_EVEX_L2_W_OPSIZE_B, /* 9662 */ + IC_EVEX_L2_W_OPSIZE_B, /* 9663 */ + IC_EVEX_L2_B, /* 9664 */ + IC_EVEX_L2_B, /* 9665 */ + IC_EVEX_L2_XS_B, /* 9666 */ + IC_EVEX_L2_XS_B, /* 9667 */ + IC_EVEX_L2_XD_B, /* 9668 */ + IC_EVEX_L2_XD_B, /* 9669 */ + IC_EVEX_L2_XD_B, /* 9670 */ + IC_EVEX_L2_XD_B, /* 9671 */ + IC_EVEX_L2_W_B, /* 9672 */ + IC_EVEX_L2_W_B, /* 9673 */ + IC_EVEX_L2_W_XS_B, /* 9674 */ + IC_EVEX_L2_W_XS_B, /* 9675 */ + IC_EVEX_L2_W_XD_B, /* 9676 */ + IC_EVEX_L2_W_XD_B, /* 9677 */ + IC_EVEX_L2_W_XD_B, /* 9678 */ + IC_EVEX_L2_W_XD_B, /* 9679 */ + IC_EVEX_L2_OPSIZE_B, /* 9680 */ + IC_EVEX_L2_OPSIZE_B, /* 9681 */ + IC_EVEX_L2_OPSIZE_B, /* 9682 */ + IC_EVEX_L2_OPSIZE_B, /* 9683 */ + IC_EVEX_L2_OPSIZE_B, /* 9684 */ + IC_EVEX_L2_OPSIZE_B, /* 9685 */ + IC_EVEX_L2_OPSIZE_B, /* 9686 */ + IC_EVEX_L2_OPSIZE_B, /* 9687 */ + IC_EVEX_L2_W_OPSIZE_B, /* 9688 */ + IC_EVEX_L2_W_OPSIZE_B, /* 9689 */ + IC_EVEX_L2_W_OPSIZE_B, /* 9690 */ + IC_EVEX_L2_W_OPSIZE_B, /* 9691 */ + IC_EVEX_L2_W_OPSIZE_B, /* 9692 */ + IC_EVEX_L2_W_OPSIZE_B, /* 9693 */ + IC_EVEX_L2_W_OPSIZE_B, /* 9694 */ + IC_EVEX_L2_W_OPSIZE_B, /* 9695 */ + IC_EVEX_L2_B, /* 9696 */ + IC_EVEX_L2_B, /* 9697 */ + IC_EVEX_L2_XS_B, /* 9698 */ + IC_EVEX_L2_XS_B, /* 9699 */ + IC_EVEX_L2_XD_B, /* 9700 */ + IC_EVEX_L2_XD_B, /* 9701 */ + IC_EVEX_L2_XD_B, /* 9702 */ + IC_EVEX_L2_XD_B, /* 9703 */ + IC_EVEX_L2_W_B, /* 9704 */ + IC_EVEX_L2_W_B, /* 9705 */ + IC_EVEX_L2_W_XS_B, /* 9706 */ + IC_EVEX_L2_W_XS_B, /* 9707 */ + IC_EVEX_L2_W_XD_B, /* 9708 */ + IC_EVEX_L2_W_XD_B, /* 9709 */ + IC_EVEX_L2_W_XD_B, /* 9710 */ + IC_EVEX_L2_W_XD_B, /* 9711 */ + IC_EVEX_L2_OPSIZE_B, /* 9712 */ + IC_EVEX_L2_OPSIZE_B, /* 9713 */ + IC_EVEX_L2_OPSIZE_B, /* 9714 */ + IC_EVEX_L2_OPSIZE_B, /* 9715 */ + IC_EVEX_L2_OPSIZE_B, /* 9716 */ + IC_EVEX_L2_OPSIZE_B, /* 9717 */ + IC_EVEX_L2_OPSIZE_B, /* 9718 */ + IC_EVEX_L2_OPSIZE_B, /* 9719 */ + IC_EVEX_L2_W_OPSIZE_B, /* 9720 */ + IC_EVEX_L2_W_OPSIZE_B, /* 9721 */ + IC_EVEX_L2_W_OPSIZE_B, /* 9722 */ + IC_EVEX_L2_W_OPSIZE_B, /* 9723 */ + IC_EVEX_L2_W_OPSIZE_B, /* 9724 */ + IC_EVEX_L2_W_OPSIZE_B, /* 9725 */ + IC_EVEX_L2_W_OPSIZE_B, /* 9726 */ + IC_EVEX_L2_W_OPSIZE_B, /* 9727 */ + IC, /* 9728 */ + IC_64BIT, /* 9729 */ + IC_XS, /* 9730 */ + IC_64BIT_XS, /* 9731 */ + IC_XD, /* 9732 */ + IC_64BIT_XD, /* 9733 */ + IC_XS, /* 9734 */ + IC_64BIT_XS, /* 9735 */ + IC, /* 9736 */ + IC_64BIT_REXW, /* 9737 */ + IC_XS, /* 9738 */ + IC_64BIT_REXW_XS, /* 9739 */ + IC_XD, /* 9740 */ + IC_64BIT_REXW_XD, /* 9741 */ + IC_XS, /* 9742 */ + IC_64BIT_REXW_XS, /* 9743 */ + IC_OPSIZE, /* 9744 */ + IC_64BIT_OPSIZE, /* 9745 */ + IC_XS_OPSIZE, /* 9746 */ + IC_64BIT_XS_OPSIZE, /* 9747 */ + IC_XD_OPSIZE, /* 9748 */ + IC_64BIT_XD_OPSIZE, /* 9749 */ + IC_XS_OPSIZE, /* 9750 */ + IC_64BIT_XD_OPSIZE, /* 9751 */ + IC_OPSIZE, /* 9752 */ + IC_64BIT_REXW_OPSIZE, /* 9753 */ + IC_XS_OPSIZE, /* 9754 */ + IC_64BIT_REXW_XS, /* 9755 */ + IC_XD_OPSIZE, /* 9756 */ + IC_64BIT_REXW_XD, /* 9757 */ + IC_XS_OPSIZE, /* 9758 */ + IC_64BIT_REXW_XS, /* 9759 */ + IC_ADSIZE, /* 9760 */ + IC_64BIT_ADSIZE, /* 9761 */ + IC_XS_ADSIZE, /* 9762 */ + IC_64BIT_XS_ADSIZE, /* 9763 */ + IC_XD_ADSIZE, /* 9764 */ + IC_64BIT_XD_ADSIZE, /* 9765 */ + IC_XS_ADSIZE, /* 9766 */ + IC_64BIT_XD_ADSIZE, /* 9767 */ + IC_ADSIZE, /* 9768 */ + IC_64BIT_REXW_ADSIZE, /* 9769 */ + IC_XS_ADSIZE, /* 9770 */ + IC_64BIT_REXW_XS, /* 9771 */ + IC_XD_ADSIZE, /* 9772 */ + IC_64BIT_REXW_XD, /* 9773 */ + IC_XS_ADSIZE, /* 9774 */ + IC_64BIT_REXW_XS, /* 9775 */ + IC_OPSIZE_ADSIZE, /* 9776 */ + IC_64BIT_OPSIZE_ADSIZE, /* 9777 */ + IC_XS_OPSIZE, /* 9778 */ + IC_64BIT_XS_OPSIZE, /* 9779 */ + IC_XD_OPSIZE, /* 9780 */ + IC_64BIT_XD_OPSIZE, /* 9781 */ + IC_XS_OPSIZE, /* 9782 */ + IC_64BIT_XD_OPSIZE, /* 9783 */ + IC_OPSIZE_ADSIZE, /* 9784 */ + IC_64BIT_REXW_OPSIZE, /* 9785 */ + IC_XS_OPSIZE, /* 9786 */ + IC_64BIT_REXW_XS, /* 9787 */ + IC_XD_OPSIZE, /* 9788 */ + IC_64BIT_REXW_XD, /* 9789 */ + IC_XS_OPSIZE, /* 9790 */ + IC_64BIT_REXW_XS, /* 9791 */ + IC_VEX, /* 9792 */ + IC_VEX, /* 9793 */ + IC_VEX_XS, /* 9794 */ + IC_VEX_XS, /* 9795 */ + IC_VEX_XD, /* 9796 */ + IC_VEX_XD, /* 9797 */ + IC_VEX_XD, /* 9798 */ + IC_VEX_XD, /* 9799 */ + IC_VEX_W, /* 9800 */ + IC_VEX_W, /* 9801 */ + IC_VEX_W_XS, /* 9802 */ + IC_VEX_W_XS, /* 9803 */ + IC_VEX_W_XD, /* 9804 */ + IC_VEX_W_XD, /* 9805 */ + IC_VEX_W_XD, /* 9806 */ + IC_VEX_W_XD, /* 9807 */ + IC_VEX_OPSIZE, /* 9808 */ + IC_VEX_OPSIZE, /* 9809 */ + IC_VEX_OPSIZE, /* 9810 */ + IC_VEX_OPSIZE, /* 9811 */ + IC_VEX_OPSIZE, /* 9812 */ + IC_VEX_OPSIZE, /* 9813 */ + IC_VEX_OPSIZE, /* 9814 */ + IC_VEX_OPSIZE, /* 9815 */ + IC_VEX_W_OPSIZE, /* 9816 */ + IC_VEX_W_OPSIZE, /* 9817 */ + IC_VEX_W_OPSIZE, /* 9818 */ + IC_VEX_W_OPSIZE, /* 9819 */ + IC_VEX_W_OPSIZE, /* 9820 */ + IC_VEX_W_OPSIZE, /* 9821 */ + IC_VEX_W_OPSIZE, /* 9822 */ + IC_VEX_W_OPSIZE, /* 9823 */ + IC_VEX, /* 9824 */ + IC_VEX, /* 9825 */ + IC_VEX_XS, /* 9826 */ + IC_VEX_XS, /* 9827 */ + IC_VEX_XD, /* 9828 */ + IC_VEX_XD, /* 9829 */ + IC_VEX_XD, /* 9830 */ + IC_VEX_XD, /* 9831 */ + IC_VEX_W, /* 9832 */ + IC_VEX_W, /* 9833 */ + IC_VEX_W_XS, /* 9834 */ + IC_VEX_W_XS, /* 9835 */ + IC_VEX_W_XD, /* 9836 */ + IC_VEX_W_XD, /* 9837 */ + IC_VEX_W_XD, /* 9838 */ + IC_VEX_W_XD, /* 9839 */ + IC_VEX_OPSIZE, /* 9840 */ + IC_VEX_OPSIZE, /* 9841 */ + IC_VEX_OPSIZE, /* 9842 */ + IC_VEX_OPSIZE, /* 9843 */ + IC_VEX_OPSIZE, /* 9844 */ + IC_VEX_OPSIZE, /* 9845 */ + IC_VEX_OPSIZE, /* 9846 */ + IC_VEX_OPSIZE, /* 9847 */ + IC_VEX_W_OPSIZE, /* 9848 */ + IC_VEX_W_OPSIZE, /* 9849 */ + IC_VEX_W_OPSIZE, /* 9850 */ + IC_VEX_W_OPSIZE, /* 9851 */ + IC_VEX_W_OPSIZE, /* 9852 */ + IC_VEX_W_OPSIZE, /* 9853 */ + IC_VEX_W_OPSIZE, /* 9854 */ + IC_VEX_W_OPSIZE, /* 9855 */ + IC_VEX_L, /* 9856 */ + IC_VEX_L, /* 9857 */ + IC_VEX_L_XS, /* 9858 */ + IC_VEX_L_XS, /* 9859 */ + IC_VEX_L_XD, /* 9860 */ + IC_VEX_L_XD, /* 9861 */ + IC_VEX_L_XD, /* 9862 */ + IC_VEX_L_XD, /* 9863 */ + IC_VEX_L_W, /* 9864 */ + IC_VEX_L_W, /* 9865 */ + IC_VEX_L_W_XS, /* 9866 */ + IC_VEX_L_W_XS, /* 9867 */ + IC_VEX_L_W_XD, /* 9868 */ + IC_VEX_L_W_XD, /* 9869 */ + IC_VEX_L_W_XD, /* 9870 */ + IC_VEX_L_W_XD, /* 9871 */ + IC_VEX_L_OPSIZE, /* 9872 */ + IC_VEX_L_OPSIZE, /* 9873 */ + IC_VEX_L_OPSIZE, /* 9874 */ + IC_VEX_L_OPSIZE, /* 9875 */ + IC_VEX_L_OPSIZE, /* 9876 */ + IC_VEX_L_OPSIZE, /* 9877 */ + IC_VEX_L_OPSIZE, /* 9878 */ + IC_VEX_L_OPSIZE, /* 9879 */ + IC_VEX_L_W_OPSIZE, /* 9880 */ + IC_VEX_L_W_OPSIZE, /* 9881 */ + IC_VEX_L_W_OPSIZE, /* 9882 */ + IC_VEX_L_W_OPSIZE, /* 9883 */ + IC_VEX_L_W_OPSIZE, /* 9884 */ + IC_VEX_L_W_OPSIZE, /* 9885 */ + IC_VEX_L_W_OPSIZE, /* 9886 */ + IC_VEX_L_W_OPSIZE, /* 9887 */ + IC_VEX_L, /* 9888 */ + IC_VEX_L, /* 9889 */ + IC_VEX_L_XS, /* 9890 */ + IC_VEX_L_XS, /* 9891 */ + IC_VEX_L_XD, /* 9892 */ + IC_VEX_L_XD, /* 9893 */ + IC_VEX_L_XD, /* 9894 */ + IC_VEX_L_XD, /* 9895 */ + IC_VEX_L_W, /* 9896 */ + IC_VEX_L_W, /* 9897 */ + IC_VEX_L_W_XS, /* 9898 */ + IC_VEX_L_W_XS, /* 9899 */ + IC_VEX_L_W_XD, /* 9900 */ + IC_VEX_L_W_XD, /* 9901 */ + IC_VEX_L_W_XD, /* 9902 */ + IC_VEX_L_W_XD, /* 9903 */ + IC_VEX_L_OPSIZE, /* 9904 */ + IC_VEX_L_OPSIZE, /* 9905 */ + IC_VEX_L_OPSIZE, /* 9906 */ + IC_VEX_L_OPSIZE, /* 9907 */ + IC_VEX_L_OPSIZE, /* 9908 */ + IC_VEX_L_OPSIZE, /* 9909 */ + IC_VEX_L_OPSIZE, /* 9910 */ + IC_VEX_L_OPSIZE, /* 9911 */ + IC_VEX_L_W_OPSIZE, /* 9912 */ + IC_VEX_L_W_OPSIZE, /* 9913 */ + IC_VEX_L_W_OPSIZE, /* 9914 */ + IC_VEX_L_W_OPSIZE, /* 9915 */ + IC_VEX_L_W_OPSIZE, /* 9916 */ + IC_VEX_L_W_OPSIZE, /* 9917 */ + IC_VEX_L_W_OPSIZE, /* 9918 */ + IC_VEX_L_W_OPSIZE, /* 9919 */ + IC_VEX_L, /* 9920 */ + IC_VEX_L, /* 9921 */ + IC_VEX_L_XS, /* 9922 */ + IC_VEX_L_XS, /* 9923 */ + IC_VEX_L_XD, /* 9924 */ + IC_VEX_L_XD, /* 9925 */ + IC_VEX_L_XD, /* 9926 */ + IC_VEX_L_XD, /* 9927 */ + IC_VEX_L_W, /* 9928 */ + IC_VEX_L_W, /* 9929 */ + IC_VEX_L_W_XS, /* 9930 */ + IC_VEX_L_W_XS, /* 9931 */ + IC_VEX_L_W_XD, /* 9932 */ + IC_VEX_L_W_XD, /* 9933 */ + IC_VEX_L_W_XD, /* 9934 */ + IC_VEX_L_W_XD, /* 9935 */ + IC_VEX_L_OPSIZE, /* 9936 */ + IC_VEX_L_OPSIZE, /* 9937 */ + IC_VEX_L_OPSIZE, /* 9938 */ + IC_VEX_L_OPSIZE, /* 9939 */ + IC_VEX_L_OPSIZE, /* 9940 */ + IC_VEX_L_OPSIZE, /* 9941 */ + IC_VEX_L_OPSIZE, /* 9942 */ + IC_VEX_L_OPSIZE, /* 9943 */ + IC_VEX_L_W_OPSIZE, /* 9944 */ + IC_VEX_L_W_OPSIZE, /* 9945 */ + IC_VEX_L_W_OPSIZE, /* 9946 */ + IC_VEX_L_W_OPSIZE, /* 9947 */ + IC_VEX_L_W_OPSIZE, /* 9948 */ + IC_VEX_L_W_OPSIZE, /* 9949 */ + IC_VEX_L_W_OPSIZE, /* 9950 */ + IC_VEX_L_W_OPSIZE, /* 9951 */ + IC_VEX_L, /* 9952 */ + IC_VEX_L, /* 9953 */ + IC_VEX_L_XS, /* 9954 */ + IC_VEX_L_XS, /* 9955 */ + IC_VEX_L_XD, /* 9956 */ + IC_VEX_L_XD, /* 9957 */ + IC_VEX_L_XD, /* 9958 */ + IC_VEX_L_XD, /* 9959 */ + IC_VEX_L_W, /* 9960 */ + IC_VEX_L_W, /* 9961 */ + IC_VEX_L_W_XS, /* 9962 */ + IC_VEX_L_W_XS, /* 9963 */ + IC_VEX_L_W_XD, /* 9964 */ + IC_VEX_L_W_XD, /* 9965 */ + IC_VEX_L_W_XD, /* 9966 */ + IC_VEX_L_W_XD, /* 9967 */ + IC_VEX_L_OPSIZE, /* 9968 */ + IC_VEX_L_OPSIZE, /* 9969 */ + IC_VEX_L_OPSIZE, /* 9970 */ + IC_VEX_L_OPSIZE, /* 9971 */ + IC_VEX_L_OPSIZE, /* 9972 */ + IC_VEX_L_OPSIZE, /* 9973 */ + IC_VEX_L_OPSIZE, /* 9974 */ + IC_VEX_L_OPSIZE, /* 9975 */ + IC_VEX_L_W_OPSIZE, /* 9976 */ + IC_VEX_L_W_OPSIZE, /* 9977 */ + IC_VEX_L_W_OPSIZE, /* 9978 */ + IC_VEX_L_W_OPSIZE, /* 9979 */ + IC_VEX_L_W_OPSIZE, /* 9980 */ + IC_VEX_L_W_OPSIZE, /* 9981 */ + IC_VEX_L_W_OPSIZE, /* 9982 */ + IC_VEX_L_W_OPSIZE, /* 9983 */ + IC_EVEX_L2_B, /* 9984 */ + IC_EVEX_L2_B, /* 9985 */ + IC_EVEX_L2_XS_B, /* 9986 */ + IC_EVEX_L2_XS_B, /* 9987 */ + IC_EVEX_L2_XD_B, /* 9988 */ + IC_EVEX_L2_XD_B, /* 9989 */ + IC_EVEX_L2_XD_B, /* 9990 */ + IC_EVEX_L2_XD_B, /* 9991 */ + IC_EVEX_L2_W_B, /* 9992 */ + IC_EVEX_L2_W_B, /* 9993 */ + IC_EVEX_L2_W_XS_B, /* 9994 */ + IC_EVEX_L2_W_XS_B, /* 9995 */ + IC_EVEX_L2_W_XD_B, /* 9996 */ + IC_EVEX_L2_W_XD_B, /* 9997 */ + IC_EVEX_L2_W_XD_B, /* 9998 */ + IC_EVEX_L2_W_XD_B, /* 9999 */ + IC_EVEX_L2_OPSIZE_B, /* 10000 */ + IC_EVEX_L2_OPSIZE_B, /* 10001 */ + IC_EVEX_L2_OPSIZE_B, /* 10002 */ + IC_EVEX_L2_OPSIZE_B, /* 10003 */ + IC_EVEX_L2_OPSIZE_B, /* 10004 */ + IC_EVEX_L2_OPSIZE_B, /* 10005 */ + IC_EVEX_L2_OPSIZE_B, /* 10006 */ + IC_EVEX_L2_OPSIZE_B, /* 10007 */ + IC_EVEX_L2_W_OPSIZE_B, /* 10008 */ + IC_EVEX_L2_W_OPSIZE_B, /* 10009 */ + IC_EVEX_L2_W_OPSIZE_B, /* 10010 */ + IC_EVEX_L2_W_OPSIZE_B, /* 10011 */ + IC_EVEX_L2_W_OPSIZE_B, /* 10012 */ + IC_EVEX_L2_W_OPSIZE_B, /* 10013 */ + IC_EVEX_L2_W_OPSIZE_B, /* 10014 */ + IC_EVEX_L2_W_OPSIZE_B, /* 10015 */ + IC_EVEX_L2_B, /* 10016 */ + IC_EVEX_L2_B, /* 10017 */ + IC_EVEX_L2_XS_B, /* 10018 */ + IC_EVEX_L2_XS_B, /* 10019 */ + IC_EVEX_L2_XD_B, /* 10020 */ + IC_EVEX_L2_XD_B, /* 10021 */ + IC_EVEX_L2_XD_B, /* 10022 */ + IC_EVEX_L2_XD_B, /* 10023 */ + IC_EVEX_L2_W_B, /* 10024 */ + IC_EVEX_L2_W_B, /* 10025 */ + IC_EVEX_L2_W_XS_B, /* 10026 */ + IC_EVEX_L2_W_XS_B, /* 10027 */ + IC_EVEX_L2_W_XD_B, /* 10028 */ + IC_EVEX_L2_W_XD_B, /* 10029 */ + IC_EVEX_L2_W_XD_B, /* 10030 */ + IC_EVEX_L2_W_XD_B, /* 10031 */ + IC_EVEX_L2_OPSIZE_B, /* 10032 */ + IC_EVEX_L2_OPSIZE_B, /* 10033 */ + IC_EVEX_L2_OPSIZE_B, /* 10034 */ + IC_EVEX_L2_OPSIZE_B, /* 10035 */ + IC_EVEX_L2_OPSIZE_B, /* 10036 */ + IC_EVEX_L2_OPSIZE_B, /* 10037 */ + IC_EVEX_L2_OPSIZE_B, /* 10038 */ + IC_EVEX_L2_OPSIZE_B, /* 10039 */ + IC_EVEX_L2_W_OPSIZE_B, /* 10040 */ + IC_EVEX_L2_W_OPSIZE_B, /* 10041 */ + IC_EVEX_L2_W_OPSIZE_B, /* 10042 */ + IC_EVEX_L2_W_OPSIZE_B, /* 10043 */ + IC_EVEX_L2_W_OPSIZE_B, /* 10044 */ + IC_EVEX_L2_W_OPSIZE_B, /* 10045 */ + IC_EVEX_L2_W_OPSIZE_B, /* 10046 */ + IC_EVEX_L2_W_OPSIZE_B, /* 10047 */ + IC_EVEX_L2_B, /* 10048 */ + IC_EVEX_L2_B, /* 10049 */ + IC_EVEX_L2_XS_B, /* 10050 */ + IC_EVEX_L2_XS_B, /* 10051 */ + IC_EVEX_L2_XD_B, /* 10052 */ + IC_EVEX_L2_XD_B, /* 10053 */ + IC_EVEX_L2_XD_B, /* 10054 */ + IC_EVEX_L2_XD_B, /* 10055 */ + IC_EVEX_L2_W_B, /* 10056 */ + IC_EVEX_L2_W_B, /* 10057 */ + IC_EVEX_L2_W_XS_B, /* 10058 */ + IC_EVEX_L2_W_XS_B, /* 10059 */ + IC_EVEX_L2_W_XD_B, /* 10060 */ + IC_EVEX_L2_W_XD_B, /* 10061 */ + IC_EVEX_L2_W_XD_B, /* 10062 */ + IC_EVEX_L2_W_XD_B, /* 10063 */ + IC_EVEX_L2_OPSIZE_B, /* 10064 */ + IC_EVEX_L2_OPSIZE_B, /* 10065 */ + IC_EVEX_L2_OPSIZE_B, /* 10066 */ + IC_EVEX_L2_OPSIZE_B, /* 10067 */ + IC_EVEX_L2_OPSIZE_B, /* 10068 */ + IC_EVEX_L2_OPSIZE_B, /* 10069 */ + IC_EVEX_L2_OPSIZE_B, /* 10070 */ + IC_EVEX_L2_OPSIZE_B, /* 10071 */ + IC_EVEX_L2_W_OPSIZE_B, /* 10072 */ + IC_EVEX_L2_W_OPSIZE_B, /* 10073 */ + IC_EVEX_L2_W_OPSIZE_B, /* 10074 */ + IC_EVEX_L2_W_OPSIZE_B, /* 10075 */ + IC_EVEX_L2_W_OPSIZE_B, /* 10076 */ + IC_EVEX_L2_W_OPSIZE_B, /* 10077 */ + IC_EVEX_L2_W_OPSIZE_B, /* 10078 */ + IC_EVEX_L2_W_OPSIZE_B, /* 10079 */ + IC_EVEX_L2_B, /* 10080 */ + IC_EVEX_L2_B, /* 10081 */ + IC_EVEX_L2_XS_B, /* 10082 */ + IC_EVEX_L2_XS_B, /* 10083 */ + IC_EVEX_L2_XD_B, /* 10084 */ + IC_EVEX_L2_XD_B, /* 10085 */ + IC_EVEX_L2_XD_B, /* 10086 */ + IC_EVEX_L2_XD_B, /* 10087 */ + IC_EVEX_L2_W_B, /* 10088 */ + IC_EVEX_L2_W_B, /* 10089 */ + IC_EVEX_L2_W_XS_B, /* 10090 */ + IC_EVEX_L2_W_XS_B, /* 10091 */ + IC_EVEX_L2_W_XD_B, /* 10092 */ + IC_EVEX_L2_W_XD_B, /* 10093 */ + IC_EVEX_L2_W_XD_B, /* 10094 */ + IC_EVEX_L2_W_XD_B, /* 10095 */ + IC_EVEX_L2_OPSIZE_B, /* 10096 */ + IC_EVEX_L2_OPSIZE_B, /* 10097 */ + IC_EVEX_L2_OPSIZE_B, /* 10098 */ + IC_EVEX_L2_OPSIZE_B, /* 10099 */ + IC_EVEX_L2_OPSIZE_B, /* 10100 */ + IC_EVEX_L2_OPSIZE_B, /* 10101 */ + IC_EVEX_L2_OPSIZE_B, /* 10102 */ + IC_EVEX_L2_OPSIZE_B, /* 10103 */ + IC_EVEX_L2_W_OPSIZE_B, /* 10104 */ + IC_EVEX_L2_W_OPSIZE_B, /* 10105 */ + IC_EVEX_L2_W_OPSIZE_B, /* 10106 */ + IC_EVEX_L2_W_OPSIZE_B, /* 10107 */ + IC_EVEX_L2_W_OPSIZE_B, /* 10108 */ + IC_EVEX_L2_W_OPSIZE_B, /* 10109 */ + IC_EVEX_L2_W_OPSIZE_B, /* 10110 */ + IC_EVEX_L2_W_OPSIZE_B, /* 10111 */ + IC_EVEX_L2_B, /* 10112 */ + IC_EVEX_L2_B, /* 10113 */ + IC_EVEX_L2_XS_B, /* 10114 */ + IC_EVEX_L2_XS_B, /* 10115 */ + IC_EVEX_L2_XD_B, /* 10116 */ + IC_EVEX_L2_XD_B, /* 10117 */ + IC_EVEX_L2_XD_B, /* 10118 */ + IC_EVEX_L2_XD_B, /* 10119 */ + IC_EVEX_L2_W_B, /* 10120 */ + IC_EVEX_L2_W_B, /* 10121 */ + IC_EVEX_L2_W_XS_B, /* 10122 */ + IC_EVEX_L2_W_XS_B, /* 10123 */ + IC_EVEX_L2_W_XD_B, /* 10124 */ + IC_EVEX_L2_W_XD_B, /* 10125 */ + IC_EVEX_L2_W_XD_B, /* 10126 */ + IC_EVEX_L2_W_XD_B, /* 10127 */ + IC_EVEX_L2_OPSIZE_B, /* 10128 */ + IC_EVEX_L2_OPSIZE_B, /* 10129 */ + IC_EVEX_L2_OPSIZE_B, /* 10130 */ + IC_EVEX_L2_OPSIZE_B, /* 10131 */ + IC_EVEX_L2_OPSIZE_B, /* 10132 */ + IC_EVEX_L2_OPSIZE_B, /* 10133 */ + IC_EVEX_L2_OPSIZE_B, /* 10134 */ + IC_EVEX_L2_OPSIZE_B, /* 10135 */ + IC_EVEX_L2_W_OPSIZE_B, /* 10136 */ + IC_EVEX_L2_W_OPSIZE_B, /* 10137 */ + IC_EVEX_L2_W_OPSIZE_B, /* 10138 */ + IC_EVEX_L2_W_OPSIZE_B, /* 10139 */ + IC_EVEX_L2_W_OPSIZE_B, /* 10140 */ + IC_EVEX_L2_W_OPSIZE_B, /* 10141 */ + IC_EVEX_L2_W_OPSIZE_B, /* 10142 */ + IC_EVEX_L2_W_OPSIZE_B, /* 10143 */ + IC_EVEX_L2_B, /* 10144 */ + IC_EVEX_L2_B, /* 10145 */ + IC_EVEX_L2_XS_B, /* 10146 */ + IC_EVEX_L2_XS_B, /* 10147 */ + IC_EVEX_L2_XD_B, /* 10148 */ + IC_EVEX_L2_XD_B, /* 10149 */ + IC_EVEX_L2_XD_B, /* 10150 */ + IC_EVEX_L2_XD_B, /* 10151 */ + IC_EVEX_L2_W_B, /* 10152 */ + IC_EVEX_L2_W_B, /* 10153 */ + IC_EVEX_L2_W_XS_B, /* 10154 */ + IC_EVEX_L2_W_XS_B, /* 10155 */ + IC_EVEX_L2_W_XD_B, /* 10156 */ + IC_EVEX_L2_W_XD_B, /* 10157 */ + IC_EVEX_L2_W_XD_B, /* 10158 */ + IC_EVEX_L2_W_XD_B, /* 10159 */ + IC_EVEX_L2_OPSIZE_B, /* 10160 */ + IC_EVEX_L2_OPSIZE_B, /* 10161 */ + IC_EVEX_L2_OPSIZE_B, /* 10162 */ + IC_EVEX_L2_OPSIZE_B, /* 10163 */ + IC_EVEX_L2_OPSIZE_B, /* 10164 */ + IC_EVEX_L2_OPSIZE_B, /* 10165 */ + IC_EVEX_L2_OPSIZE_B, /* 10166 */ + IC_EVEX_L2_OPSIZE_B, /* 10167 */ + IC_EVEX_L2_W_OPSIZE_B, /* 10168 */ + IC_EVEX_L2_W_OPSIZE_B, /* 10169 */ + IC_EVEX_L2_W_OPSIZE_B, /* 10170 */ + IC_EVEX_L2_W_OPSIZE_B, /* 10171 */ + IC_EVEX_L2_W_OPSIZE_B, /* 10172 */ + IC_EVEX_L2_W_OPSIZE_B, /* 10173 */ + IC_EVEX_L2_W_OPSIZE_B, /* 10174 */ + IC_EVEX_L2_W_OPSIZE_B, /* 10175 */ + IC_EVEX_L2_B, /* 10176 */ + IC_EVEX_L2_B, /* 10177 */ + IC_EVEX_L2_XS_B, /* 10178 */ + IC_EVEX_L2_XS_B, /* 10179 */ + IC_EVEX_L2_XD_B, /* 10180 */ + IC_EVEX_L2_XD_B, /* 10181 */ + IC_EVEX_L2_XD_B, /* 10182 */ + IC_EVEX_L2_XD_B, /* 10183 */ + IC_EVEX_L2_W_B, /* 10184 */ + IC_EVEX_L2_W_B, /* 10185 */ + IC_EVEX_L2_W_XS_B, /* 10186 */ + IC_EVEX_L2_W_XS_B, /* 10187 */ + IC_EVEX_L2_W_XD_B, /* 10188 */ + IC_EVEX_L2_W_XD_B, /* 10189 */ + IC_EVEX_L2_W_XD_B, /* 10190 */ + IC_EVEX_L2_W_XD_B, /* 10191 */ + IC_EVEX_L2_OPSIZE_B, /* 10192 */ + IC_EVEX_L2_OPSIZE_B, /* 10193 */ + IC_EVEX_L2_OPSIZE_B, /* 10194 */ + IC_EVEX_L2_OPSIZE_B, /* 10195 */ + IC_EVEX_L2_OPSIZE_B, /* 10196 */ + IC_EVEX_L2_OPSIZE_B, /* 10197 */ + IC_EVEX_L2_OPSIZE_B, /* 10198 */ + IC_EVEX_L2_OPSIZE_B, /* 10199 */ + IC_EVEX_L2_W_OPSIZE_B, /* 10200 */ + IC_EVEX_L2_W_OPSIZE_B, /* 10201 */ + IC_EVEX_L2_W_OPSIZE_B, /* 10202 */ + IC_EVEX_L2_W_OPSIZE_B, /* 10203 */ + IC_EVEX_L2_W_OPSIZE_B, /* 10204 */ + IC_EVEX_L2_W_OPSIZE_B, /* 10205 */ + IC_EVEX_L2_W_OPSIZE_B, /* 10206 */ + IC_EVEX_L2_W_OPSIZE_B, /* 10207 */ + IC_EVEX_L2_B, /* 10208 */ + IC_EVEX_L2_B, /* 10209 */ + IC_EVEX_L2_XS_B, /* 10210 */ + IC_EVEX_L2_XS_B, /* 10211 */ + IC_EVEX_L2_XD_B, /* 10212 */ + IC_EVEX_L2_XD_B, /* 10213 */ + IC_EVEX_L2_XD_B, /* 10214 */ + IC_EVEX_L2_XD_B, /* 10215 */ + IC_EVEX_L2_W_B, /* 10216 */ + IC_EVEX_L2_W_B, /* 10217 */ + IC_EVEX_L2_W_XS_B, /* 10218 */ + IC_EVEX_L2_W_XS_B, /* 10219 */ + IC_EVEX_L2_W_XD_B, /* 10220 */ + IC_EVEX_L2_W_XD_B, /* 10221 */ + IC_EVEX_L2_W_XD_B, /* 10222 */ + IC_EVEX_L2_W_XD_B, /* 10223 */ + IC_EVEX_L2_OPSIZE_B, /* 10224 */ + IC_EVEX_L2_OPSIZE_B, /* 10225 */ + IC_EVEX_L2_OPSIZE_B, /* 10226 */ + IC_EVEX_L2_OPSIZE_B, /* 10227 */ + IC_EVEX_L2_OPSIZE_B, /* 10228 */ + IC_EVEX_L2_OPSIZE_B, /* 10229 */ + IC_EVEX_L2_OPSIZE_B, /* 10230 */ + IC_EVEX_L2_OPSIZE_B, /* 10231 */ + IC_EVEX_L2_W_OPSIZE_B, /* 10232 */ + IC_EVEX_L2_W_OPSIZE_B, /* 10233 */ + IC_EVEX_L2_W_OPSIZE_B, /* 10234 */ + IC_EVEX_L2_W_OPSIZE_B, /* 10235 */ + IC_EVEX_L2_W_OPSIZE_B, /* 10236 */ + IC_EVEX_L2_W_OPSIZE_B, /* 10237 */ + IC_EVEX_L2_W_OPSIZE_B, /* 10238 */ + IC_EVEX_L2_W_OPSIZE_B, /* 10239 */ + IC, /* 10240 */ + IC_64BIT, /* 10241 */ + IC_XS, /* 10242 */ + IC_64BIT_XS, /* 10243 */ + IC_XD, /* 10244 */ + IC_64BIT_XD, /* 10245 */ + IC_XS, /* 10246 */ + IC_64BIT_XS, /* 10247 */ + IC, /* 10248 */ + IC_64BIT_REXW, /* 10249 */ + IC_XS, /* 10250 */ + IC_64BIT_REXW_XS, /* 10251 */ + IC_XD, /* 10252 */ + IC_64BIT_REXW_XD, /* 10253 */ + IC_XS, /* 10254 */ + IC_64BIT_REXW_XS, /* 10255 */ + IC_OPSIZE, /* 10256 */ + IC_64BIT_OPSIZE, /* 10257 */ + IC_XS_OPSIZE, /* 10258 */ + IC_64BIT_XS_OPSIZE, /* 10259 */ + IC_XD_OPSIZE, /* 10260 */ + IC_64BIT_XD_OPSIZE, /* 10261 */ + IC_XS_OPSIZE, /* 10262 */ + IC_64BIT_XD_OPSIZE, /* 10263 */ + IC_OPSIZE, /* 10264 */ + IC_64BIT_REXW_OPSIZE, /* 10265 */ + IC_XS_OPSIZE, /* 10266 */ + IC_64BIT_REXW_XS, /* 10267 */ + IC_XD_OPSIZE, /* 10268 */ + IC_64BIT_REXW_XD, /* 10269 */ + IC_XS_OPSIZE, /* 10270 */ + IC_64BIT_REXW_XS, /* 10271 */ + IC_ADSIZE, /* 10272 */ + IC_64BIT_ADSIZE, /* 10273 */ + IC_XS_ADSIZE, /* 10274 */ + IC_64BIT_XS_ADSIZE, /* 10275 */ + IC_XD_ADSIZE, /* 10276 */ + IC_64BIT_XD_ADSIZE, /* 10277 */ + IC_XS_ADSIZE, /* 10278 */ + IC_64BIT_XD_ADSIZE, /* 10279 */ + IC_ADSIZE, /* 10280 */ + IC_64BIT_REXW_ADSIZE, /* 10281 */ + IC_XS_ADSIZE, /* 10282 */ + IC_64BIT_REXW_XS, /* 10283 */ + IC_XD_ADSIZE, /* 10284 */ + IC_64BIT_REXW_XD, /* 10285 */ + IC_XS_ADSIZE, /* 10286 */ + IC_64BIT_REXW_XS, /* 10287 */ + IC_OPSIZE_ADSIZE, /* 10288 */ + IC_64BIT_OPSIZE_ADSIZE, /* 10289 */ + IC_XS_OPSIZE, /* 10290 */ + IC_64BIT_XS_OPSIZE, /* 10291 */ + IC_XD_OPSIZE, /* 10292 */ + IC_64BIT_XD_OPSIZE, /* 10293 */ + IC_XS_OPSIZE, /* 10294 */ + IC_64BIT_XD_OPSIZE, /* 10295 */ + IC_OPSIZE_ADSIZE, /* 10296 */ + IC_64BIT_REXW_OPSIZE, /* 10297 */ + IC_XS_OPSIZE, /* 10298 */ + IC_64BIT_REXW_XS, /* 10299 */ + IC_XD_OPSIZE, /* 10300 */ + IC_64BIT_REXW_XD, /* 10301 */ + IC_XS_OPSIZE, /* 10302 */ + IC_64BIT_REXW_XS, /* 10303 */ + IC_VEX, /* 10304 */ + IC_VEX, /* 10305 */ + IC_VEX_XS, /* 10306 */ + IC_VEX_XS, /* 10307 */ + IC_VEX_XD, /* 10308 */ + IC_VEX_XD, /* 10309 */ + IC_VEX_XD, /* 10310 */ + IC_VEX_XD, /* 10311 */ + IC_VEX_W, /* 10312 */ + IC_VEX_W, /* 10313 */ + IC_VEX_W_XS, /* 10314 */ + IC_VEX_W_XS, /* 10315 */ + IC_VEX_W_XD, /* 10316 */ + IC_VEX_W_XD, /* 10317 */ + IC_VEX_W_XD, /* 10318 */ + IC_VEX_W_XD, /* 10319 */ + IC_VEX_OPSIZE, /* 10320 */ + IC_VEX_OPSIZE, /* 10321 */ + IC_VEX_OPSIZE, /* 10322 */ + IC_VEX_OPSIZE, /* 10323 */ + IC_VEX_OPSIZE, /* 10324 */ + IC_VEX_OPSIZE, /* 10325 */ + IC_VEX_OPSIZE, /* 10326 */ + IC_VEX_OPSIZE, /* 10327 */ + IC_VEX_W_OPSIZE, /* 10328 */ + IC_VEX_W_OPSIZE, /* 10329 */ + IC_VEX_W_OPSIZE, /* 10330 */ + IC_VEX_W_OPSIZE, /* 10331 */ + IC_VEX_W_OPSIZE, /* 10332 */ + IC_VEX_W_OPSIZE, /* 10333 */ + IC_VEX_W_OPSIZE, /* 10334 */ + IC_VEX_W_OPSIZE, /* 10335 */ + IC_VEX, /* 10336 */ + IC_VEX, /* 10337 */ + IC_VEX_XS, /* 10338 */ + IC_VEX_XS, /* 10339 */ + IC_VEX_XD, /* 10340 */ + IC_VEX_XD, /* 10341 */ + IC_VEX_XD, /* 10342 */ + IC_VEX_XD, /* 10343 */ + IC_VEX_W, /* 10344 */ + IC_VEX_W, /* 10345 */ + IC_VEX_W_XS, /* 10346 */ + IC_VEX_W_XS, /* 10347 */ + IC_VEX_W_XD, /* 10348 */ + IC_VEX_W_XD, /* 10349 */ + IC_VEX_W_XD, /* 10350 */ + IC_VEX_W_XD, /* 10351 */ + IC_VEX_OPSIZE, /* 10352 */ + IC_VEX_OPSIZE, /* 10353 */ + IC_VEX_OPSIZE, /* 10354 */ + IC_VEX_OPSIZE, /* 10355 */ + IC_VEX_OPSIZE, /* 10356 */ + IC_VEX_OPSIZE, /* 10357 */ + IC_VEX_OPSIZE, /* 10358 */ + IC_VEX_OPSIZE, /* 10359 */ + IC_VEX_W_OPSIZE, /* 10360 */ + IC_VEX_W_OPSIZE, /* 10361 */ + IC_VEX_W_OPSIZE, /* 10362 */ + IC_VEX_W_OPSIZE, /* 10363 */ + IC_VEX_W_OPSIZE, /* 10364 */ + IC_VEX_W_OPSIZE, /* 10365 */ + IC_VEX_W_OPSIZE, /* 10366 */ + IC_VEX_W_OPSIZE, /* 10367 */ + IC_VEX_L, /* 10368 */ + IC_VEX_L, /* 10369 */ + IC_VEX_L_XS, /* 10370 */ + IC_VEX_L_XS, /* 10371 */ + IC_VEX_L_XD, /* 10372 */ + IC_VEX_L_XD, /* 10373 */ + IC_VEX_L_XD, /* 10374 */ + IC_VEX_L_XD, /* 10375 */ + IC_VEX_L_W, /* 10376 */ + IC_VEX_L_W, /* 10377 */ + IC_VEX_L_W_XS, /* 10378 */ + IC_VEX_L_W_XS, /* 10379 */ + IC_VEX_L_W_XD, /* 10380 */ + IC_VEX_L_W_XD, /* 10381 */ + IC_VEX_L_W_XD, /* 10382 */ + IC_VEX_L_W_XD, /* 10383 */ + IC_VEX_L_OPSIZE, /* 10384 */ + IC_VEX_L_OPSIZE, /* 10385 */ + IC_VEX_L_OPSIZE, /* 10386 */ + IC_VEX_L_OPSIZE, /* 10387 */ + IC_VEX_L_OPSIZE, /* 10388 */ + IC_VEX_L_OPSIZE, /* 10389 */ + IC_VEX_L_OPSIZE, /* 10390 */ + IC_VEX_L_OPSIZE, /* 10391 */ + IC_VEX_L_W_OPSIZE, /* 10392 */ + IC_VEX_L_W_OPSIZE, /* 10393 */ + IC_VEX_L_W_OPSIZE, /* 10394 */ + IC_VEX_L_W_OPSIZE, /* 10395 */ + IC_VEX_L_W_OPSIZE, /* 10396 */ + IC_VEX_L_W_OPSIZE, /* 10397 */ + IC_VEX_L_W_OPSIZE, /* 10398 */ + IC_VEX_L_W_OPSIZE, /* 10399 */ + IC_VEX_L, /* 10400 */ + IC_VEX_L, /* 10401 */ + IC_VEX_L_XS, /* 10402 */ + IC_VEX_L_XS, /* 10403 */ + IC_VEX_L_XD, /* 10404 */ + IC_VEX_L_XD, /* 10405 */ + IC_VEX_L_XD, /* 10406 */ + IC_VEX_L_XD, /* 10407 */ + IC_VEX_L_W, /* 10408 */ + IC_VEX_L_W, /* 10409 */ + IC_VEX_L_W_XS, /* 10410 */ + IC_VEX_L_W_XS, /* 10411 */ + IC_VEX_L_W_XD, /* 10412 */ + IC_VEX_L_W_XD, /* 10413 */ + IC_VEX_L_W_XD, /* 10414 */ + IC_VEX_L_W_XD, /* 10415 */ + IC_VEX_L_OPSIZE, /* 10416 */ + IC_VEX_L_OPSIZE, /* 10417 */ + IC_VEX_L_OPSIZE, /* 10418 */ + IC_VEX_L_OPSIZE, /* 10419 */ + IC_VEX_L_OPSIZE, /* 10420 */ + IC_VEX_L_OPSIZE, /* 10421 */ + IC_VEX_L_OPSIZE, /* 10422 */ + IC_VEX_L_OPSIZE, /* 10423 */ + IC_VEX_L_W_OPSIZE, /* 10424 */ + IC_VEX_L_W_OPSIZE, /* 10425 */ + IC_VEX_L_W_OPSIZE, /* 10426 */ + IC_VEX_L_W_OPSIZE, /* 10427 */ + IC_VEX_L_W_OPSIZE, /* 10428 */ + IC_VEX_L_W_OPSIZE, /* 10429 */ + IC_VEX_L_W_OPSIZE, /* 10430 */ + IC_VEX_L_W_OPSIZE, /* 10431 */ + IC_VEX_L, /* 10432 */ + IC_VEX_L, /* 10433 */ + IC_VEX_L_XS, /* 10434 */ + IC_VEX_L_XS, /* 10435 */ + IC_VEX_L_XD, /* 10436 */ + IC_VEX_L_XD, /* 10437 */ + IC_VEX_L_XD, /* 10438 */ + IC_VEX_L_XD, /* 10439 */ + IC_VEX_L_W, /* 10440 */ + IC_VEX_L_W, /* 10441 */ + IC_VEX_L_W_XS, /* 10442 */ + IC_VEX_L_W_XS, /* 10443 */ + IC_VEX_L_W_XD, /* 10444 */ + IC_VEX_L_W_XD, /* 10445 */ + IC_VEX_L_W_XD, /* 10446 */ + IC_VEX_L_W_XD, /* 10447 */ + IC_VEX_L_OPSIZE, /* 10448 */ + IC_VEX_L_OPSIZE, /* 10449 */ + IC_VEX_L_OPSIZE, /* 10450 */ + IC_VEX_L_OPSIZE, /* 10451 */ + IC_VEX_L_OPSIZE, /* 10452 */ + IC_VEX_L_OPSIZE, /* 10453 */ + IC_VEX_L_OPSIZE, /* 10454 */ + IC_VEX_L_OPSIZE, /* 10455 */ + IC_VEX_L_W_OPSIZE, /* 10456 */ + IC_VEX_L_W_OPSIZE, /* 10457 */ + IC_VEX_L_W_OPSIZE, /* 10458 */ + IC_VEX_L_W_OPSIZE, /* 10459 */ + IC_VEX_L_W_OPSIZE, /* 10460 */ + IC_VEX_L_W_OPSIZE, /* 10461 */ + IC_VEX_L_W_OPSIZE, /* 10462 */ + IC_VEX_L_W_OPSIZE, /* 10463 */ + IC_VEX_L, /* 10464 */ + IC_VEX_L, /* 10465 */ + IC_VEX_L_XS, /* 10466 */ + IC_VEX_L_XS, /* 10467 */ + IC_VEX_L_XD, /* 10468 */ + IC_VEX_L_XD, /* 10469 */ + IC_VEX_L_XD, /* 10470 */ + IC_VEX_L_XD, /* 10471 */ + IC_VEX_L_W, /* 10472 */ + IC_VEX_L_W, /* 10473 */ + IC_VEX_L_W_XS, /* 10474 */ + IC_VEX_L_W_XS, /* 10475 */ + IC_VEX_L_W_XD, /* 10476 */ + IC_VEX_L_W_XD, /* 10477 */ + IC_VEX_L_W_XD, /* 10478 */ + IC_VEX_L_W_XD, /* 10479 */ + IC_VEX_L_OPSIZE, /* 10480 */ + IC_VEX_L_OPSIZE, /* 10481 */ + IC_VEX_L_OPSIZE, /* 10482 */ + IC_VEX_L_OPSIZE, /* 10483 */ + IC_VEX_L_OPSIZE, /* 10484 */ + IC_VEX_L_OPSIZE, /* 10485 */ + IC_VEX_L_OPSIZE, /* 10486 */ + IC_VEX_L_OPSIZE, /* 10487 */ + IC_VEX_L_W_OPSIZE, /* 10488 */ + IC_VEX_L_W_OPSIZE, /* 10489 */ + IC_VEX_L_W_OPSIZE, /* 10490 */ + IC_VEX_L_W_OPSIZE, /* 10491 */ + IC_VEX_L_W_OPSIZE, /* 10492 */ + IC_VEX_L_W_OPSIZE, /* 10493 */ + IC_VEX_L_W_OPSIZE, /* 10494 */ + IC_VEX_L_W_OPSIZE, /* 10495 */ + IC_EVEX_K_B, /* 10496 */ + IC_EVEX_K_B, /* 10497 */ + IC_EVEX_XS_K_B, /* 10498 */ + IC_EVEX_XS_K_B, /* 10499 */ + IC_EVEX_XD_K_B, /* 10500 */ + IC_EVEX_XD_K_B, /* 10501 */ + IC_EVEX_XD_K_B, /* 10502 */ + IC_EVEX_XD_K_B, /* 10503 */ + IC_EVEX_W_K_B, /* 10504 */ + IC_EVEX_W_K_B, /* 10505 */ + IC_EVEX_W_XS_K_B, /* 10506 */ + IC_EVEX_W_XS_K_B, /* 10507 */ + IC_EVEX_W_XD_K_B, /* 10508 */ + IC_EVEX_W_XD_K_B, /* 10509 */ + IC_EVEX_W_XD_K_B, /* 10510 */ + IC_EVEX_W_XD_K_B, /* 10511 */ + IC_EVEX_OPSIZE_K_B, /* 10512 */ + IC_EVEX_OPSIZE_K_B, /* 10513 */ + IC_EVEX_OPSIZE_K_B, /* 10514 */ + IC_EVEX_OPSIZE_K_B, /* 10515 */ + IC_EVEX_OPSIZE_K_B, /* 10516 */ + IC_EVEX_OPSIZE_K_B, /* 10517 */ + IC_EVEX_OPSIZE_K_B, /* 10518 */ + IC_EVEX_OPSIZE_K_B, /* 10519 */ + IC_EVEX_W_OPSIZE_K_B, /* 10520 */ + IC_EVEX_W_OPSIZE_K_B, /* 10521 */ + IC_EVEX_W_OPSIZE_K_B, /* 10522 */ + IC_EVEX_W_OPSIZE_K_B, /* 10523 */ + IC_EVEX_W_OPSIZE_K_B, /* 10524 */ + IC_EVEX_W_OPSIZE_K_B, /* 10525 */ + IC_EVEX_W_OPSIZE_K_B, /* 10526 */ + IC_EVEX_W_OPSIZE_K_B, /* 10527 */ + IC_EVEX_K_B, /* 10528 */ + IC_EVEX_K_B, /* 10529 */ + IC_EVEX_XS_K_B, /* 10530 */ + IC_EVEX_XS_K_B, /* 10531 */ + IC_EVEX_XD_K_B, /* 10532 */ + IC_EVEX_XD_K_B, /* 10533 */ + IC_EVEX_XD_K_B, /* 10534 */ + IC_EVEX_XD_K_B, /* 10535 */ + IC_EVEX_W_K_B, /* 10536 */ + IC_EVEX_W_K_B, /* 10537 */ + IC_EVEX_W_XS_K_B, /* 10538 */ + IC_EVEX_W_XS_K_B, /* 10539 */ + IC_EVEX_W_XD_K_B, /* 10540 */ + IC_EVEX_W_XD_K_B, /* 10541 */ + IC_EVEX_W_XD_K_B, /* 10542 */ + IC_EVEX_W_XD_K_B, /* 10543 */ + IC_EVEX_OPSIZE_K_B, /* 10544 */ + IC_EVEX_OPSIZE_K_B, /* 10545 */ + IC_EVEX_OPSIZE_K_B, /* 10546 */ + IC_EVEX_OPSIZE_K_B, /* 10547 */ + IC_EVEX_OPSIZE_K_B, /* 10548 */ + IC_EVEX_OPSIZE_K_B, /* 10549 */ + IC_EVEX_OPSIZE_K_B, /* 10550 */ + IC_EVEX_OPSIZE_K_B, /* 10551 */ + IC_EVEX_W_OPSIZE_K_B, /* 10552 */ + IC_EVEX_W_OPSIZE_K_B, /* 10553 */ + IC_EVEX_W_OPSIZE_K_B, /* 10554 */ + IC_EVEX_W_OPSIZE_K_B, /* 10555 */ + IC_EVEX_W_OPSIZE_K_B, /* 10556 */ + IC_EVEX_W_OPSIZE_K_B, /* 10557 */ + IC_EVEX_W_OPSIZE_K_B, /* 10558 */ + IC_EVEX_W_OPSIZE_K_B, /* 10559 */ + IC_EVEX_K_B, /* 10560 */ + IC_EVEX_K_B, /* 10561 */ + IC_EVEX_XS_K_B, /* 10562 */ + IC_EVEX_XS_K_B, /* 10563 */ + IC_EVEX_XD_K_B, /* 10564 */ + IC_EVEX_XD_K_B, /* 10565 */ + IC_EVEX_XD_K_B, /* 10566 */ + IC_EVEX_XD_K_B, /* 10567 */ + IC_EVEX_W_K_B, /* 10568 */ + IC_EVEX_W_K_B, /* 10569 */ + IC_EVEX_W_XS_K_B, /* 10570 */ + IC_EVEX_W_XS_K_B, /* 10571 */ + IC_EVEX_W_XD_K_B, /* 10572 */ + IC_EVEX_W_XD_K_B, /* 10573 */ + IC_EVEX_W_XD_K_B, /* 10574 */ + IC_EVEX_W_XD_K_B, /* 10575 */ + IC_EVEX_OPSIZE_K_B, /* 10576 */ + IC_EVEX_OPSIZE_K_B, /* 10577 */ + IC_EVEX_OPSIZE_K_B, /* 10578 */ + IC_EVEX_OPSIZE_K_B, /* 10579 */ + IC_EVEX_OPSIZE_K_B, /* 10580 */ + IC_EVEX_OPSIZE_K_B, /* 10581 */ + IC_EVEX_OPSIZE_K_B, /* 10582 */ + IC_EVEX_OPSIZE_K_B, /* 10583 */ + IC_EVEX_W_OPSIZE_K_B, /* 10584 */ + IC_EVEX_W_OPSIZE_K_B, /* 10585 */ + IC_EVEX_W_OPSIZE_K_B, /* 10586 */ + IC_EVEX_W_OPSIZE_K_B, /* 10587 */ + IC_EVEX_W_OPSIZE_K_B, /* 10588 */ + IC_EVEX_W_OPSIZE_K_B, /* 10589 */ + IC_EVEX_W_OPSIZE_K_B, /* 10590 */ + IC_EVEX_W_OPSIZE_K_B, /* 10591 */ + IC_EVEX_K_B, /* 10592 */ + IC_EVEX_K_B, /* 10593 */ + IC_EVEX_XS_K_B, /* 10594 */ + IC_EVEX_XS_K_B, /* 10595 */ + IC_EVEX_XD_K_B, /* 10596 */ + IC_EVEX_XD_K_B, /* 10597 */ + IC_EVEX_XD_K_B, /* 10598 */ + IC_EVEX_XD_K_B, /* 10599 */ + IC_EVEX_W_K_B, /* 10600 */ + IC_EVEX_W_K_B, /* 10601 */ + IC_EVEX_W_XS_K_B, /* 10602 */ + IC_EVEX_W_XS_K_B, /* 10603 */ + IC_EVEX_W_XD_K_B, /* 10604 */ + IC_EVEX_W_XD_K_B, /* 10605 */ + IC_EVEX_W_XD_K_B, /* 10606 */ + IC_EVEX_W_XD_K_B, /* 10607 */ + IC_EVEX_OPSIZE_K_B, /* 10608 */ + IC_EVEX_OPSIZE_K_B, /* 10609 */ + IC_EVEX_OPSIZE_K_B, /* 10610 */ + IC_EVEX_OPSIZE_K_B, /* 10611 */ + IC_EVEX_OPSIZE_K_B, /* 10612 */ + IC_EVEX_OPSIZE_K_B, /* 10613 */ + IC_EVEX_OPSIZE_K_B, /* 10614 */ + IC_EVEX_OPSIZE_K_B, /* 10615 */ + IC_EVEX_W_OPSIZE_K_B, /* 10616 */ + IC_EVEX_W_OPSIZE_K_B, /* 10617 */ + IC_EVEX_W_OPSIZE_K_B, /* 10618 */ + IC_EVEX_W_OPSIZE_K_B, /* 10619 */ + IC_EVEX_W_OPSIZE_K_B, /* 10620 */ + IC_EVEX_W_OPSIZE_K_B, /* 10621 */ + IC_EVEX_W_OPSIZE_K_B, /* 10622 */ + IC_EVEX_W_OPSIZE_K_B, /* 10623 */ + IC_EVEX_K_B, /* 10624 */ + IC_EVEX_K_B, /* 10625 */ + IC_EVEX_XS_K_B, /* 10626 */ + IC_EVEX_XS_K_B, /* 10627 */ + IC_EVEX_XD_K_B, /* 10628 */ + IC_EVEX_XD_K_B, /* 10629 */ + IC_EVEX_XD_K_B, /* 10630 */ + IC_EVEX_XD_K_B, /* 10631 */ + IC_EVEX_W_K_B, /* 10632 */ + IC_EVEX_W_K_B, /* 10633 */ + IC_EVEX_W_XS_K_B, /* 10634 */ + IC_EVEX_W_XS_K_B, /* 10635 */ + IC_EVEX_W_XD_K_B, /* 10636 */ + IC_EVEX_W_XD_K_B, /* 10637 */ + IC_EVEX_W_XD_K_B, /* 10638 */ + IC_EVEX_W_XD_K_B, /* 10639 */ + IC_EVEX_OPSIZE_K_B, /* 10640 */ + IC_EVEX_OPSIZE_K_B, /* 10641 */ + IC_EVEX_OPSIZE_K_B, /* 10642 */ + IC_EVEX_OPSIZE_K_B, /* 10643 */ + IC_EVEX_OPSIZE_K_B, /* 10644 */ + IC_EVEX_OPSIZE_K_B, /* 10645 */ + IC_EVEX_OPSIZE_K_B, /* 10646 */ + IC_EVEX_OPSIZE_K_B, /* 10647 */ + IC_EVEX_W_OPSIZE_K_B, /* 10648 */ + IC_EVEX_W_OPSIZE_K_B, /* 10649 */ + IC_EVEX_W_OPSIZE_K_B, /* 10650 */ + IC_EVEX_W_OPSIZE_K_B, /* 10651 */ + IC_EVEX_W_OPSIZE_K_B, /* 10652 */ + IC_EVEX_W_OPSIZE_K_B, /* 10653 */ + IC_EVEX_W_OPSIZE_K_B, /* 10654 */ + IC_EVEX_W_OPSIZE_K_B, /* 10655 */ + IC_EVEX_K_B, /* 10656 */ + IC_EVEX_K_B, /* 10657 */ + IC_EVEX_XS_K_B, /* 10658 */ + IC_EVEX_XS_K_B, /* 10659 */ + IC_EVEX_XD_K_B, /* 10660 */ + IC_EVEX_XD_K_B, /* 10661 */ + IC_EVEX_XD_K_B, /* 10662 */ + IC_EVEX_XD_K_B, /* 10663 */ + IC_EVEX_W_K_B, /* 10664 */ + IC_EVEX_W_K_B, /* 10665 */ + IC_EVEX_W_XS_K_B, /* 10666 */ + IC_EVEX_W_XS_K_B, /* 10667 */ + IC_EVEX_W_XD_K_B, /* 10668 */ + IC_EVEX_W_XD_K_B, /* 10669 */ + IC_EVEX_W_XD_K_B, /* 10670 */ + IC_EVEX_W_XD_K_B, /* 10671 */ + IC_EVEX_OPSIZE_K_B, /* 10672 */ + IC_EVEX_OPSIZE_K_B, /* 10673 */ + IC_EVEX_OPSIZE_K_B, /* 10674 */ + IC_EVEX_OPSIZE_K_B, /* 10675 */ + IC_EVEX_OPSIZE_K_B, /* 10676 */ + IC_EVEX_OPSIZE_K_B, /* 10677 */ + IC_EVEX_OPSIZE_K_B, /* 10678 */ + IC_EVEX_OPSIZE_K_B, /* 10679 */ + IC_EVEX_W_OPSIZE_K_B, /* 10680 */ + IC_EVEX_W_OPSIZE_K_B, /* 10681 */ + IC_EVEX_W_OPSIZE_K_B, /* 10682 */ + IC_EVEX_W_OPSIZE_K_B, /* 10683 */ + IC_EVEX_W_OPSIZE_K_B, /* 10684 */ + IC_EVEX_W_OPSIZE_K_B, /* 10685 */ + IC_EVEX_W_OPSIZE_K_B, /* 10686 */ + IC_EVEX_W_OPSIZE_K_B, /* 10687 */ + IC_EVEX_K_B, /* 10688 */ + IC_EVEX_K_B, /* 10689 */ + IC_EVEX_XS_K_B, /* 10690 */ + IC_EVEX_XS_K_B, /* 10691 */ + IC_EVEX_XD_K_B, /* 10692 */ + IC_EVEX_XD_K_B, /* 10693 */ + IC_EVEX_XD_K_B, /* 10694 */ + IC_EVEX_XD_K_B, /* 10695 */ + IC_EVEX_W_K_B, /* 10696 */ + IC_EVEX_W_K_B, /* 10697 */ + IC_EVEX_W_XS_K_B, /* 10698 */ + IC_EVEX_W_XS_K_B, /* 10699 */ + IC_EVEX_W_XD_K_B, /* 10700 */ + IC_EVEX_W_XD_K_B, /* 10701 */ + IC_EVEX_W_XD_K_B, /* 10702 */ + IC_EVEX_W_XD_K_B, /* 10703 */ + IC_EVEX_OPSIZE_K_B, /* 10704 */ + IC_EVEX_OPSIZE_K_B, /* 10705 */ + IC_EVEX_OPSIZE_K_B, /* 10706 */ + IC_EVEX_OPSIZE_K_B, /* 10707 */ + IC_EVEX_OPSIZE_K_B, /* 10708 */ + IC_EVEX_OPSIZE_K_B, /* 10709 */ + IC_EVEX_OPSIZE_K_B, /* 10710 */ + IC_EVEX_OPSIZE_K_B, /* 10711 */ + IC_EVEX_W_OPSIZE_K_B, /* 10712 */ + IC_EVEX_W_OPSIZE_K_B, /* 10713 */ + IC_EVEX_W_OPSIZE_K_B, /* 10714 */ + IC_EVEX_W_OPSIZE_K_B, /* 10715 */ + IC_EVEX_W_OPSIZE_K_B, /* 10716 */ + IC_EVEX_W_OPSIZE_K_B, /* 10717 */ + IC_EVEX_W_OPSIZE_K_B, /* 10718 */ + IC_EVEX_W_OPSIZE_K_B, /* 10719 */ + IC_EVEX_K_B, /* 10720 */ + IC_EVEX_K_B, /* 10721 */ + IC_EVEX_XS_K_B, /* 10722 */ + IC_EVEX_XS_K_B, /* 10723 */ + IC_EVEX_XD_K_B, /* 10724 */ + IC_EVEX_XD_K_B, /* 10725 */ + IC_EVEX_XD_K_B, /* 10726 */ + IC_EVEX_XD_K_B, /* 10727 */ + IC_EVEX_W_K_B, /* 10728 */ + IC_EVEX_W_K_B, /* 10729 */ + IC_EVEX_W_XS_K_B, /* 10730 */ + IC_EVEX_W_XS_K_B, /* 10731 */ + IC_EVEX_W_XD_K_B, /* 10732 */ + IC_EVEX_W_XD_K_B, /* 10733 */ + IC_EVEX_W_XD_K_B, /* 10734 */ + IC_EVEX_W_XD_K_B, /* 10735 */ + IC_EVEX_OPSIZE_K_B, /* 10736 */ + IC_EVEX_OPSIZE_K_B, /* 10737 */ + IC_EVEX_OPSIZE_K_B, /* 10738 */ + IC_EVEX_OPSIZE_K_B, /* 10739 */ + IC_EVEX_OPSIZE_K_B, /* 10740 */ + IC_EVEX_OPSIZE_K_B, /* 10741 */ + IC_EVEX_OPSIZE_K_B, /* 10742 */ + IC_EVEX_OPSIZE_K_B, /* 10743 */ + IC_EVEX_W_OPSIZE_K_B, /* 10744 */ + IC_EVEX_W_OPSIZE_K_B, /* 10745 */ + IC_EVEX_W_OPSIZE_K_B, /* 10746 */ + IC_EVEX_W_OPSIZE_K_B, /* 10747 */ + IC_EVEX_W_OPSIZE_K_B, /* 10748 */ + IC_EVEX_W_OPSIZE_K_B, /* 10749 */ + IC_EVEX_W_OPSIZE_K_B, /* 10750 */ + IC_EVEX_W_OPSIZE_K_B, /* 10751 */ + IC, /* 10752 */ + IC_64BIT, /* 10753 */ + IC_XS, /* 10754 */ + IC_64BIT_XS, /* 10755 */ + IC_XD, /* 10756 */ + IC_64BIT_XD, /* 10757 */ + IC_XS, /* 10758 */ + IC_64BIT_XS, /* 10759 */ + IC, /* 10760 */ + IC_64BIT_REXW, /* 10761 */ + IC_XS, /* 10762 */ + IC_64BIT_REXW_XS, /* 10763 */ + IC_XD, /* 10764 */ + IC_64BIT_REXW_XD, /* 10765 */ + IC_XS, /* 10766 */ + IC_64BIT_REXW_XS, /* 10767 */ + IC_OPSIZE, /* 10768 */ + IC_64BIT_OPSIZE, /* 10769 */ + IC_XS_OPSIZE, /* 10770 */ + IC_64BIT_XS_OPSIZE, /* 10771 */ + IC_XD_OPSIZE, /* 10772 */ + IC_64BIT_XD_OPSIZE, /* 10773 */ + IC_XS_OPSIZE, /* 10774 */ + IC_64BIT_XD_OPSIZE, /* 10775 */ + IC_OPSIZE, /* 10776 */ + IC_64BIT_REXW_OPSIZE, /* 10777 */ + IC_XS_OPSIZE, /* 10778 */ + IC_64BIT_REXW_XS, /* 10779 */ + IC_XD_OPSIZE, /* 10780 */ + IC_64BIT_REXW_XD, /* 10781 */ + IC_XS_OPSIZE, /* 10782 */ + IC_64BIT_REXW_XS, /* 10783 */ + IC_ADSIZE, /* 10784 */ + IC_64BIT_ADSIZE, /* 10785 */ + IC_XS_ADSIZE, /* 10786 */ + IC_64BIT_XS_ADSIZE, /* 10787 */ + IC_XD_ADSIZE, /* 10788 */ + IC_64BIT_XD_ADSIZE, /* 10789 */ + IC_XS_ADSIZE, /* 10790 */ + IC_64BIT_XD_ADSIZE, /* 10791 */ + IC_ADSIZE, /* 10792 */ + IC_64BIT_REXW_ADSIZE, /* 10793 */ + IC_XS_ADSIZE, /* 10794 */ + IC_64BIT_REXW_XS, /* 10795 */ + IC_XD_ADSIZE, /* 10796 */ + IC_64BIT_REXW_XD, /* 10797 */ + IC_XS_ADSIZE, /* 10798 */ + IC_64BIT_REXW_XS, /* 10799 */ + IC_OPSIZE_ADSIZE, /* 10800 */ + IC_64BIT_OPSIZE_ADSIZE, /* 10801 */ + IC_XS_OPSIZE, /* 10802 */ + IC_64BIT_XS_OPSIZE, /* 10803 */ + IC_XD_OPSIZE, /* 10804 */ + IC_64BIT_XD_OPSIZE, /* 10805 */ + IC_XS_OPSIZE, /* 10806 */ + IC_64BIT_XD_OPSIZE, /* 10807 */ + IC_OPSIZE_ADSIZE, /* 10808 */ + IC_64BIT_REXW_OPSIZE, /* 10809 */ + IC_XS_OPSIZE, /* 10810 */ + IC_64BIT_REXW_XS, /* 10811 */ + IC_XD_OPSIZE, /* 10812 */ + IC_64BIT_REXW_XD, /* 10813 */ + IC_XS_OPSIZE, /* 10814 */ + IC_64BIT_REXW_XS, /* 10815 */ + IC_VEX, /* 10816 */ + IC_VEX, /* 10817 */ + IC_VEX_XS, /* 10818 */ + IC_VEX_XS, /* 10819 */ + IC_VEX_XD, /* 10820 */ + IC_VEX_XD, /* 10821 */ + IC_VEX_XD, /* 10822 */ + IC_VEX_XD, /* 10823 */ + IC_VEX_W, /* 10824 */ + IC_VEX_W, /* 10825 */ + IC_VEX_W_XS, /* 10826 */ + IC_VEX_W_XS, /* 10827 */ + IC_VEX_W_XD, /* 10828 */ + IC_VEX_W_XD, /* 10829 */ + IC_VEX_W_XD, /* 10830 */ + IC_VEX_W_XD, /* 10831 */ + IC_VEX_OPSIZE, /* 10832 */ + IC_VEX_OPSIZE, /* 10833 */ + IC_VEX_OPSIZE, /* 10834 */ + IC_VEX_OPSIZE, /* 10835 */ + IC_VEX_OPSIZE, /* 10836 */ + IC_VEX_OPSIZE, /* 10837 */ + IC_VEX_OPSIZE, /* 10838 */ + IC_VEX_OPSIZE, /* 10839 */ + IC_VEX_W_OPSIZE, /* 10840 */ + IC_VEX_W_OPSIZE, /* 10841 */ + IC_VEX_W_OPSIZE, /* 10842 */ + IC_VEX_W_OPSIZE, /* 10843 */ + IC_VEX_W_OPSIZE, /* 10844 */ + IC_VEX_W_OPSIZE, /* 10845 */ + IC_VEX_W_OPSIZE, /* 10846 */ + IC_VEX_W_OPSIZE, /* 10847 */ + IC_VEX, /* 10848 */ + IC_VEX, /* 10849 */ + IC_VEX_XS, /* 10850 */ + IC_VEX_XS, /* 10851 */ + IC_VEX_XD, /* 10852 */ + IC_VEX_XD, /* 10853 */ + IC_VEX_XD, /* 10854 */ + IC_VEX_XD, /* 10855 */ + IC_VEX_W, /* 10856 */ + IC_VEX_W, /* 10857 */ + IC_VEX_W_XS, /* 10858 */ + IC_VEX_W_XS, /* 10859 */ + IC_VEX_W_XD, /* 10860 */ + IC_VEX_W_XD, /* 10861 */ + IC_VEX_W_XD, /* 10862 */ + IC_VEX_W_XD, /* 10863 */ + IC_VEX_OPSIZE, /* 10864 */ + IC_VEX_OPSIZE, /* 10865 */ + IC_VEX_OPSIZE, /* 10866 */ + IC_VEX_OPSIZE, /* 10867 */ + IC_VEX_OPSIZE, /* 10868 */ + IC_VEX_OPSIZE, /* 10869 */ + IC_VEX_OPSIZE, /* 10870 */ + IC_VEX_OPSIZE, /* 10871 */ + IC_VEX_W_OPSIZE, /* 10872 */ + IC_VEX_W_OPSIZE, /* 10873 */ + IC_VEX_W_OPSIZE, /* 10874 */ + IC_VEX_W_OPSIZE, /* 10875 */ + IC_VEX_W_OPSIZE, /* 10876 */ + IC_VEX_W_OPSIZE, /* 10877 */ + IC_VEX_W_OPSIZE, /* 10878 */ + IC_VEX_W_OPSIZE, /* 10879 */ + IC_VEX_L, /* 10880 */ + IC_VEX_L, /* 10881 */ + IC_VEX_L_XS, /* 10882 */ + IC_VEX_L_XS, /* 10883 */ + IC_VEX_L_XD, /* 10884 */ + IC_VEX_L_XD, /* 10885 */ + IC_VEX_L_XD, /* 10886 */ + IC_VEX_L_XD, /* 10887 */ + IC_VEX_L_W, /* 10888 */ + IC_VEX_L_W, /* 10889 */ + IC_VEX_L_W_XS, /* 10890 */ + IC_VEX_L_W_XS, /* 10891 */ + IC_VEX_L_W_XD, /* 10892 */ + IC_VEX_L_W_XD, /* 10893 */ + IC_VEX_L_W_XD, /* 10894 */ + IC_VEX_L_W_XD, /* 10895 */ + IC_VEX_L_OPSIZE, /* 10896 */ + IC_VEX_L_OPSIZE, /* 10897 */ + IC_VEX_L_OPSIZE, /* 10898 */ + IC_VEX_L_OPSIZE, /* 10899 */ + IC_VEX_L_OPSIZE, /* 10900 */ + IC_VEX_L_OPSIZE, /* 10901 */ + IC_VEX_L_OPSIZE, /* 10902 */ + IC_VEX_L_OPSIZE, /* 10903 */ + IC_VEX_L_W_OPSIZE, /* 10904 */ + IC_VEX_L_W_OPSIZE, /* 10905 */ + IC_VEX_L_W_OPSIZE, /* 10906 */ + IC_VEX_L_W_OPSIZE, /* 10907 */ + IC_VEX_L_W_OPSIZE, /* 10908 */ + IC_VEX_L_W_OPSIZE, /* 10909 */ + IC_VEX_L_W_OPSIZE, /* 10910 */ + IC_VEX_L_W_OPSIZE, /* 10911 */ + IC_VEX_L, /* 10912 */ + IC_VEX_L, /* 10913 */ + IC_VEX_L_XS, /* 10914 */ + IC_VEX_L_XS, /* 10915 */ + IC_VEX_L_XD, /* 10916 */ + IC_VEX_L_XD, /* 10917 */ + IC_VEX_L_XD, /* 10918 */ + IC_VEX_L_XD, /* 10919 */ + IC_VEX_L_W, /* 10920 */ + IC_VEX_L_W, /* 10921 */ + IC_VEX_L_W_XS, /* 10922 */ + IC_VEX_L_W_XS, /* 10923 */ + IC_VEX_L_W_XD, /* 10924 */ + IC_VEX_L_W_XD, /* 10925 */ + IC_VEX_L_W_XD, /* 10926 */ + IC_VEX_L_W_XD, /* 10927 */ + IC_VEX_L_OPSIZE, /* 10928 */ + IC_VEX_L_OPSIZE, /* 10929 */ + IC_VEX_L_OPSIZE, /* 10930 */ + IC_VEX_L_OPSIZE, /* 10931 */ + IC_VEX_L_OPSIZE, /* 10932 */ + IC_VEX_L_OPSIZE, /* 10933 */ + IC_VEX_L_OPSIZE, /* 10934 */ + IC_VEX_L_OPSIZE, /* 10935 */ + IC_VEX_L_W_OPSIZE, /* 10936 */ + IC_VEX_L_W_OPSIZE, /* 10937 */ + IC_VEX_L_W_OPSIZE, /* 10938 */ + IC_VEX_L_W_OPSIZE, /* 10939 */ + IC_VEX_L_W_OPSIZE, /* 10940 */ + IC_VEX_L_W_OPSIZE, /* 10941 */ + IC_VEX_L_W_OPSIZE, /* 10942 */ + IC_VEX_L_W_OPSIZE, /* 10943 */ + IC_VEX_L, /* 10944 */ + IC_VEX_L, /* 10945 */ + IC_VEX_L_XS, /* 10946 */ + IC_VEX_L_XS, /* 10947 */ + IC_VEX_L_XD, /* 10948 */ + IC_VEX_L_XD, /* 10949 */ + IC_VEX_L_XD, /* 10950 */ + IC_VEX_L_XD, /* 10951 */ + IC_VEX_L_W, /* 10952 */ + IC_VEX_L_W, /* 10953 */ + IC_VEX_L_W_XS, /* 10954 */ + IC_VEX_L_W_XS, /* 10955 */ + IC_VEX_L_W_XD, /* 10956 */ + IC_VEX_L_W_XD, /* 10957 */ + IC_VEX_L_W_XD, /* 10958 */ + IC_VEX_L_W_XD, /* 10959 */ + IC_VEX_L_OPSIZE, /* 10960 */ + IC_VEX_L_OPSIZE, /* 10961 */ + IC_VEX_L_OPSIZE, /* 10962 */ + IC_VEX_L_OPSIZE, /* 10963 */ + IC_VEX_L_OPSIZE, /* 10964 */ + IC_VEX_L_OPSIZE, /* 10965 */ + IC_VEX_L_OPSIZE, /* 10966 */ + IC_VEX_L_OPSIZE, /* 10967 */ + IC_VEX_L_W_OPSIZE, /* 10968 */ + IC_VEX_L_W_OPSIZE, /* 10969 */ + IC_VEX_L_W_OPSIZE, /* 10970 */ + IC_VEX_L_W_OPSIZE, /* 10971 */ + IC_VEX_L_W_OPSIZE, /* 10972 */ + IC_VEX_L_W_OPSIZE, /* 10973 */ + IC_VEX_L_W_OPSIZE, /* 10974 */ + IC_VEX_L_W_OPSIZE, /* 10975 */ + IC_VEX_L, /* 10976 */ + IC_VEX_L, /* 10977 */ + IC_VEX_L_XS, /* 10978 */ + IC_VEX_L_XS, /* 10979 */ + IC_VEX_L_XD, /* 10980 */ + IC_VEX_L_XD, /* 10981 */ + IC_VEX_L_XD, /* 10982 */ + IC_VEX_L_XD, /* 10983 */ + IC_VEX_L_W, /* 10984 */ + IC_VEX_L_W, /* 10985 */ + IC_VEX_L_W_XS, /* 10986 */ + IC_VEX_L_W_XS, /* 10987 */ + IC_VEX_L_W_XD, /* 10988 */ + IC_VEX_L_W_XD, /* 10989 */ + IC_VEX_L_W_XD, /* 10990 */ + IC_VEX_L_W_XD, /* 10991 */ + IC_VEX_L_OPSIZE, /* 10992 */ + IC_VEX_L_OPSIZE, /* 10993 */ + IC_VEX_L_OPSIZE, /* 10994 */ + IC_VEX_L_OPSIZE, /* 10995 */ + IC_VEX_L_OPSIZE, /* 10996 */ + IC_VEX_L_OPSIZE, /* 10997 */ + IC_VEX_L_OPSIZE, /* 10998 */ + IC_VEX_L_OPSIZE, /* 10999 */ + IC_VEX_L_W_OPSIZE, /* 11000 */ + IC_VEX_L_W_OPSIZE, /* 11001 */ + IC_VEX_L_W_OPSIZE, /* 11002 */ + IC_VEX_L_W_OPSIZE, /* 11003 */ + IC_VEX_L_W_OPSIZE, /* 11004 */ + IC_VEX_L_W_OPSIZE, /* 11005 */ + IC_VEX_L_W_OPSIZE, /* 11006 */ + IC_VEX_L_W_OPSIZE, /* 11007 */ + IC_EVEX_L_K_B, /* 11008 */ + IC_EVEX_L_K_B, /* 11009 */ + IC_EVEX_L_XS_K_B, /* 11010 */ + IC_EVEX_L_XS_K_B, /* 11011 */ + IC_EVEX_L_XD_K_B, /* 11012 */ + IC_EVEX_L_XD_K_B, /* 11013 */ + IC_EVEX_L_XD_K_B, /* 11014 */ + IC_EVEX_L_XD_K_B, /* 11015 */ + IC_EVEX_L_W_K_B, /* 11016 */ + IC_EVEX_L_W_K_B, /* 11017 */ + IC_EVEX_L_W_XS_K_B, /* 11018 */ + IC_EVEX_L_W_XS_K_B, /* 11019 */ + IC_EVEX_L_W_XD_K_B, /* 11020 */ + IC_EVEX_L_W_XD_K_B, /* 11021 */ + IC_EVEX_L_W_XD_K_B, /* 11022 */ + IC_EVEX_L_W_XD_K_B, /* 11023 */ + IC_EVEX_L_OPSIZE_K_B, /* 11024 */ + IC_EVEX_L_OPSIZE_K_B, /* 11025 */ + IC_EVEX_L_OPSIZE_K_B, /* 11026 */ + IC_EVEX_L_OPSIZE_K_B, /* 11027 */ + IC_EVEX_L_OPSIZE_K_B, /* 11028 */ + IC_EVEX_L_OPSIZE_K_B, /* 11029 */ + IC_EVEX_L_OPSIZE_K_B, /* 11030 */ + IC_EVEX_L_OPSIZE_K_B, /* 11031 */ + IC_EVEX_L_W_OPSIZE_K_B, /* 11032 */ + IC_EVEX_L_W_OPSIZE_K_B, /* 11033 */ + IC_EVEX_L_W_OPSIZE_K_B, /* 11034 */ + IC_EVEX_L_W_OPSIZE_K_B, /* 11035 */ + IC_EVEX_L_W_OPSIZE_K_B, /* 11036 */ + IC_EVEX_L_W_OPSIZE_K_B, /* 11037 */ + IC_EVEX_L_W_OPSIZE_K_B, /* 11038 */ + IC_EVEX_L_W_OPSIZE_K_B, /* 11039 */ + IC_EVEX_L_K_B, /* 11040 */ + IC_EVEX_L_K_B, /* 11041 */ + IC_EVEX_L_XS_K_B, /* 11042 */ + IC_EVEX_L_XS_K_B, /* 11043 */ + IC_EVEX_L_XD_K_B, /* 11044 */ + IC_EVEX_L_XD_K_B, /* 11045 */ + IC_EVEX_L_XD_K_B, /* 11046 */ + IC_EVEX_L_XD_K_B, /* 11047 */ + IC_EVEX_L_W_K_B, /* 11048 */ + IC_EVEX_L_W_K_B, /* 11049 */ + IC_EVEX_L_W_XS_K_B, /* 11050 */ + IC_EVEX_L_W_XS_K_B, /* 11051 */ + IC_EVEX_L_W_XD_K_B, /* 11052 */ + IC_EVEX_L_W_XD_K_B, /* 11053 */ + IC_EVEX_L_W_XD_K_B, /* 11054 */ + IC_EVEX_L_W_XD_K_B, /* 11055 */ + IC_EVEX_L_OPSIZE_K_B, /* 11056 */ + IC_EVEX_L_OPSIZE_K_B, /* 11057 */ + IC_EVEX_L_OPSIZE_K_B, /* 11058 */ + IC_EVEX_L_OPSIZE_K_B, /* 11059 */ + IC_EVEX_L_OPSIZE_K_B, /* 11060 */ + IC_EVEX_L_OPSIZE_K_B, /* 11061 */ + IC_EVEX_L_OPSIZE_K_B, /* 11062 */ + IC_EVEX_L_OPSIZE_K_B, /* 11063 */ + IC_EVEX_L_W_OPSIZE_K_B, /* 11064 */ + IC_EVEX_L_W_OPSIZE_K_B, /* 11065 */ + IC_EVEX_L_W_OPSIZE_K_B, /* 11066 */ + IC_EVEX_L_W_OPSIZE_K_B, /* 11067 */ + IC_EVEX_L_W_OPSIZE_K_B, /* 11068 */ + IC_EVEX_L_W_OPSIZE_K_B, /* 11069 */ + IC_EVEX_L_W_OPSIZE_K_B, /* 11070 */ + IC_EVEX_L_W_OPSIZE_K_B, /* 11071 */ + IC_EVEX_L_K_B, /* 11072 */ + IC_EVEX_L_K_B, /* 11073 */ + IC_EVEX_L_XS_K_B, /* 11074 */ + IC_EVEX_L_XS_K_B, /* 11075 */ + IC_EVEX_L_XD_K_B, /* 11076 */ + IC_EVEX_L_XD_K_B, /* 11077 */ + IC_EVEX_L_XD_K_B, /* 11078 */ + IC_EVEX_L_XD_K_B, /* 11079 */ + IC_EVEX_L_W_K_B, /* 11080 */ + IC_EVEX_L_W_K_B, /* 11081 */ + IC_EVEX_L_W_XS_K_B, /* 11082 */ + IC_EVEX_L_W_XS_K_B, /* 11083 */ + IC_EVEX_L_W_XD_K_B, /* 11084 */ + IC_EVEX_L_W_XD_K_B, /* 11085 */ + IC_EVEX_L_W_XD_K_B, /* 11086 */ + IC_EVEX_L_W_XD_K_B, /* 11087 */ + IC_EVEX_L_OPSIZE_K_B, /* 11088 */ + IC_EVEX_L_OPSIZE_K_B, /* 11089 */ + IC_EVEX_L_OPSIZE_K_B, /* 11090 */ + IC_EVEX_L_OPSIZE_K_B, /* 11091 */ + IC_EVEX_L_OPSIZE_K_B, /* 11092 */ + IC_EVEX_L_OPSIZE_K_B, /* 11093 */ + IC_EVEX_L_OPSIZE_K_B, /* 11094 */ + IC_EVEX_L_OPSIZE_K_B, /* 11095 */ + IC_EVEX_L_W_OPSIZE_K_B, /* 11096 */ + IC_EVEX_L_W_OPSIZE_K_B, /* 11097 */ + IC_EVEX_L_W_OPSIZE_K_B, /* 11098 */ + IC_EVEX_L_W_OPSIZE_K_B, /* 11099 */ + IC_EVEX_L_W_OPSIZE_K_B, /* 11100 */ + IC_EVEX_L_W_OPSIZE_K_B, /* 11101 */ + IC_EVEX_L_W_OPSIZE_K_B, /* 11102 */ + IC_EVEX_L_W_OPSIZE_K_B, /* 11103 */ + IC_EVEX_L_K_B, /* 11104 */ + IC_EVEX_L_K_B, /* 11105 */ + IC_EVEX_L_XS_K_B, /* 11106 */ + IC_EVEX_L_XS_K_B, /* 11107 */ + IC_EVEX_L_XD_K_B, /* 11108 */ + IC_EVEX_L_XD_K_B, /* 11109 */ + IC_EVEX_L_XD_K_B, /* 11110 */ + IC_EVEX_L_XD_K_B, /* 11111 */ + IC_EVEX_L_W_K_B, /* 11112 */ + IC_EVEX_L_W_K_B, /* 11113 */ + IC_EVEX_L_W_XS_K_B, /* 11114 */ + IC_EVEX_L_W_XS_K_B, /* 11115 */ + IC_EVEX_L_W_XD_K_B, /* 11116 */ + IC_EVEX_L_W_XD_K_B, /* 11117 */ + IC_EVEX_L_W_XD_K_B, /* 11118 */ + IC_EVEX_L_W_XD_K_B, /* 11119 */ + IC_EVEX_L_OPSIZE_K_B, /* 11120 */ + IC_EVEX_L_OPSIZE_K_B, /* 11121 */ + IC_EVEX_L_OPSIZE_K_B, /* 11122 */ + IC_EVEX_L_OPSIZE_K_B, /* 11123 */ + IC_EVEX_L_OPSIZE_K_B, /* 11124 */ + IC_EVEX_L_OPSIZE_K_B, /* 11125 */ + IC_EVEX_L_OPSIZE_K_B, /* 11126 */ + IC_EVEX_L_OPSIZE_K_B, /* 11127 */ + IC_EVEX_L_W_OPSIZE_K_B, /* 11128 */ + IC_EVEX_L_W_OPSIZE_K_B, /* 11129 */ + IC_EVEX_L_W_OPSIZE_K_B, /* 11130 */ + IC_EVEX_L_W_OPSIZE_K_B, /* 11131 */ + IC_EVEX_L_W_OPSIZE_K_B, /* 11132 */ + IC_EVEX_L_W_OPSIZE_K_B, /* 11133 */ + IC_EVEX_L_W_OPSIZE_K_B, /* 11134 */ + IC_EVEX_L_W_OPSIZE_K_B, /* 11135 */ + IC_EVEX_L_K_B, /* 11136 */ + IC_EVEX_L_K_B, /* 11137 */ + IC_EVEX_L_XS_K_B, /* 11138 */ + IC_EVEX_L_XS_K_B, /* 11139 */ + IC_EVEX_L_XD_K_B, /* 11140 */ + IC_EVEX_L_XD_K_B, /* 11141 */ + IC_EVEX_L_XD_K_B, /* 11142 */ + IC_EVEX_L_XD_K_B, /* 11143 */ + IC_EVEX_L_W_K_B, /* 11144 */ + IC_EVEX_L_W_K_B, /* 11145 */ + IC_EVEX_L_W_XS_K_B, /* 11146 */ + IC_EVEX_L_W_XS_K_B, /* 11147 */ + IC_EVEX_L_W_XD_K_B, /* 11148 */ + IC_EVEX_L_W_XD_K_B, /* 11149 */ + IC_EVEX_L_W_XD_K_B, /* 11150 */ + IC_EVEX_L_W_XD_K_B, /* 11151 */ + IC_EVEX_L_OPSIZE_K_B, /* 11152 */ + IC_EVEX_L_OPSIZE_K_B, /* 11153 */ + IC_EVEX_L_OPSIZE_K_B, /* 11154 */ + IC_EVEX_L_OPSIZE_K_B, /* 11155 */ + IC_EVEX_L_OPSIZE_K_B, /* 11156 */ + IC_EVEX_L_OPSIZE_K_B, /* 11157 */ + IC_EVEX_L_OPSIZE_K_B, /* 11158 */ + IC_EVEX_L_OPSIZE_K_B, /* 11159 */ + IC_EVEX_L_W_OPSIZE_K_B, /* 11160 */ + IC_EVEX_L_W_OPSIZE_K_B, /* 11161 */ + IC_EVEX_L_W_OPSIZE_K_B, /* 11162 */ + IC_EVEX_L_W_OPSIZE_K_B, /* 11163 */ + IC_EVEX_L_W_OPSIZE_K_B, /* 11164 */ + IC_EVEX_L_W_OPSIZE_K_B, /* 11165 */ + IC_EVEX_L_W_OPSIZE_K_B, /* 11166 */ + IC_EVEX_L_W_OPSIZE_K_B, /* 11167 */ + IC_EVEX_L_K_B, /* 11168 */ + IC_EVEX_L_K_B, /* 11169 */ + IC_EVEX_L_XS_K_B, /* 11170 */ + IC_EVEX_L_XS_K_B, /* 11171 */ + IC_EVEX_L_XD_K_B, /* 11172 */ + IC_EVEX_L_XD_K_B, /* 11173 */ + IC_EVEX_L_XD_K_B, /* 11174 */ + IC_EVEX_L_XD_K_B, /* 11175 */ + IC_EVEX_L_W_K_B, /* 11176 */ + IC_EVEX_L_W_K_B, /* 11177 */ + IC_EVEX_L_W_XS_K_B, /* 11178 */ + IC_EVEX_L_W_XS_K_B, /* 11179 */ + IC_EVEX_L_W_XD_K_B, /* 11180 */ + IC_EVEX_L_W_XD_K_B, /* 11181 */ + IC_EVEX_L_W_XD_K_B, /* 11182 */ + IC_EVEX_L_W_XD_K_B, /* 11183 */ + IC_EVEX_L_OPSIZE_K_B, /* 11184 */ + IC_EVEX_L_OPSIZE_K_B, /* 11185 */ + IC_EVEX_L_OPSIZE_K_B, /* 11186 */ + IC_EVEX_L_OPSIZE_K_B, /* 11187 */ + IC_EVEX_L_OPSIZE_K_B, /* 11188 */ + IC_EVEX_L_OPSIZE_K_B, /* 11189 */ + IC_EVEX_L_OPSIZE_K_B, /* 11190 */ + IC_EVEX_L_OPSIZE_K_B, /* 11191 */ + IC_EVEX_L_W_OPSIZE_K_B, /* 11192 */ + IC_EVEX_L_W_OPSIZE_K_B, /* 11193 */ + IC_EVEX_L_W_OPSIZE_K_B, /* 11194 */ + IC_EVEX_L_W_OPSIZE_K_B, /* 11195 */ + IC_EVEX_L_W_OPSIZE_K_B, /* 11196 */ + IC_EVEX_L_W_OPSIZE_K_B, /* 11197 */ + IC_EVEX_L_W_OPSIZE_K_B, /* 11198 */ + IC_EVEX_L_W_OPSIZE_K_B, /* 11199 */ + IC_EVEX_L_K_B, /* 11200 */ + IC_EVEX_L_K_B, /* 11201 */ + IC_EVEX_L_XS_K_B, /* 11202 */ + IC_EVEX_L_XS_K_B, /* 11203 */ + IC_EVEX_L_XD_K_B, /* 11204 */ + IC_EVEX_L_XD_K_B, /* 11205 */ + IC_EVEX_L_XD_K_B, /* 11206 */ + IC_EVEX_L_XD_K_B, /* 11207 */ + IC_EVEX_L_W_K_B, /* 11208 */ + IC_EVEX_L_W_K_B, /* 11209 */ + IC_EVEX_L_W_XS_K_B, /* 11210 */ + IC_EVEX_L_W_XS_K_B, /* 11211 */ + IC_EVEX_L_W_XD_K_B, /* 11212 */ + IC_EVEX_L_W_XD_K_B, /* 11213 */ + IC_EVEX_L_W_XD_K_B, /* 11214 */ + IC_EVEX_L_W_XD_K_B, /* 11215 */ + IC_EVEX_L_OPSIZE_K_B, /* 11216 */ + IC_EVEX_L_OPSIZE_K_B, /* 11217 */ + IC_EVEX_L_OPSIZE_K_B, /* 11218 */ + IC_EVEX_L_OPSIZE_K_B, /* 11219 */ + IC_EVEX_L_OPSIZE_K_B, /* 11220 */ + IC_EVEX_L_OPSIZE_K_B, /* 11221 */ + IC_EVEX_L_OPSIZE_K_B, /* 11222 */ + IC_EVEX_L_OPSIZE_K_B, /* 11223 */ + IC_EVEX_L_W_OPSIZE_K_B, /* 11224 */ + IC_EVEX_L_W_OPSIZE_K_B, /* 11225 */ + IC_EVEX_L_W_OPSIZE_K_B, /* 11226 */ + IC_EVEX_L_W_OPSIZE_K_B, /* 11227 */ + IC_EVEX_L_W_OPSIZE_K_B, /* 11228 */ + IC_EVEX_L_W_OPSIZE_K_B, /* 11229 */ + IC_EVEX_L_W_OPSIZE_K_B, /* 11230 */ + IC_EVEX_L_W_OPSIZE_K_B, /* 11231 */ + IC_EVEX_L_K_B, /* 11232 */ + IC_EVEX_L_K_B, /* 11233 */ + IC_EVEX_L_XS_K_B, /* 11234 */ + IC_EVEX_L_XS_K_B, /* 11235 */ + IC_EVEX_L_XD_K_B, /* 11236 */ + IC_EVEX_L_XD_K_B, /* 11237 */ + IC_EVEX_L_XD_K_B, /* 11238 */ + IC_EVEX_L_XD_K_B, /* 11239 */ + IC_EVEX_L_W_K_B, /* 11240 */ + IC_EVEX_L_W_K_B, /* 11241 */ + IC_EVEX_L_W_XS_K_B, /* 11242 */ + IC_EVEX_L_W_XS_K_B, /* 11243 */ + IC_EVEX_L_W_XD_K_B, /* 11244 */ + IC_EVEX_L_W_XD_K_B, /* 11245 */ + IC_EVEX_L_W_XD_K_B, /* 11246 */ + IC_EVEX_L_W_XD_K_B, /* 11247 */ + IC_EVEX_L_OPSIZE_K_B, /* 11248 */ + IC_EVEX_L_OPSIZE_K_B, /* 11249 */ + IC_EVEX_L_OPSIZE_K_B, /* 11250 */ + IC_EVEX_L_OPSIZE_K_B, /* 11251 */ + IC_EVEX_L_OPSIZE_K_B, /* 11252 */ + IC_EVEX_L_OPSIZE_K_B, /* 11253 */ + IC_EVEX_L_OPSIZE_K_B, /* 11254 */ + IC_EVEX_L_OPSIZE_K_B, /* 11255 */ + IC_EVEX_L_W_OPSIZE_K_B, /* 11256 */ + IC_EVEX_L_W_OPSIZE_K_B, /* 11257 */ + IC_EVEX_L_W_OPSIZE_K_B, /* 11258 */ + IC_EVEX_L_W_OPSIZE_K_B, /* 11259 */ + IC_EVEX_L_W_OPSIZE_K_B, /* 11260 */ + IC_EVEX_L_W_OPSIZE_K_B, /* 11261 */ + IC_EVEX_L_W_OPSIZE_K_B, /* 11262 */ + IC_EVEX_L_W_OPSIZE_K_B, /* 11263 */ + IC, /* 11264 */ + IC_64BIT, /* 11265 */ + IC_XS, /* 11266 */ + IC_64BIT_XS, /* 11267 */ + IC_XD, /* 11268 */ + IC_64BIT_XD, /* 11269 */ + IC_XS, /* 11270 */ + IC_64BIT_XS, /* 11271 */ + IC, /* 11272 */ + IC_64BIT_REXW, /* 11273 */ + IC_XS, /* 11274 */ + IC_64BIT_REXW_XS, /* 11275 */ + IC_XD, /* 11276 */ + IC_64BIT_REXW_XD, /* 11277 */ + IC_XS, /* 11278 */ + IC_64BIT_REXW_XS, /* 11279 */ + IC_OPSIZE, /* 11280 */ + IC_64BIT_OPSIZE, /* 11281 */ + IC_XS_OPSIZE, /* 11282 */ + IC_64BIT_XS_OPSIZE, /* 11283 */ + IC_XD_OPSIZE, /* 11284 */ + IC_64BIT_XD_OPSIZE, /* 11285 */ + IC_XS_OPSIZE, /* 11286 */ + IC_64BIT_XD_OPSIZE, /* 11287 */ + IC_OPSIZE, /* 11288 */ + IC_64BIT_REXW_OPSIZE, /* 11289 */ + IC_XS_OPSIZE, /* 11290 */ + IC_64BIT_REXW_XS, /* 11291 */ + IC_XD_OPSIZE, /* 11292 */ + IC_64BIT_REXW_XD, /* 11293 */ + IC_XS_OPSIZE, /* 11294 */ + IC_64BIT_REXW_XS, /* 11295 */ + IC_ADSIZE, /* 11296 */ + IC_64BIT_ADSIZE, /* 11297 */ + IC_XS_ADSIZE, /* 11298 */ + IC_64BIT_XS_ADSIZE, /* 11299 */ + IC_XD_ADSIZE, /* 11300 */ + IC_64BIT_XD_ADSIZE, /* 11301 */ + IC_XS_ADSIZE, /* 11302 */ + IC_64BIT_XD_ADSIZE, /* 11303 */ + IC_ADSIZE, /* 11304 */ + IC_64BIT_REXW_ADSIZE, /* 11305 */ + IC_XS_ADSIZE, /* 11306 */ + IC_64BIT_REXW_XS, /* 11307 */ + IC_XD_ADSIZE, /* 11308 */ + IC_64BIT_REXW_XD, /* 11309 */ + IC_XS_ADSIZE, /* 11310 */ + IC_64BIT_REXW_XS, /* 11311 */ + IC_OPSIZE_ADSIZE, /* 11312 */ + IC_64BIT_OPSIZE_ADSIZE, /* 11313 */ + IC_XS_OPSIZE, /* 11314 */ + IC_64BIT_XS_OPSIZE, /* 11315 */ + IC_XD_OPSIZE, /* 11316 */ + IC_64BIT_XD_OPSIZE, /* 11317 */ + IC_XS_OPSIZE, /* 11318 */ + IC_64BIT_XD_OPSIZE, /* 11319 */ + IC_OPSIZE_ADSIZE, /* 11320 */ + IC_64BIT_REXW_OPSIZE, /* 11321 */ + IC_XS_OPSIZE, /* 11322 */ + IC_64BIT_REXW_XS, /* 11323 */ + IC_XD_OPSIZE, /* 11324 */ + IC_64BIT_REXW_XD, /* 11325 */ + IC_XS_OPSIZE, /* 11326 */ + IC_64BIT_REXW_XS, /* 11327 */ + IC_VEX, /* 11328 */ + IC_VEX, /* 11329 */ + IC_VEX_XS, /* 11330 */ + IC_VEX_XS, /* 11331 */ + IC_VEX_XD, /* 11332 */ + IC_VEX_XD, /* 11333 */ + IC_VEX_XD, /* 11334 */ + IC_VEX_XD, /* 11335 */ + IC_VEX_W, /* 11336 */ + IC_VEX_W, /* 11337 */ + IC_VEX_W_XS, /* 11338 */ + IC_VEX_W_XS, /* 11339 */ + IC_VEX_W_XD, /* 11340 */ + IC_VEX_W_XD, /* 11341 */ + IC_VEX_W_XD, /* 11342 */ + IC_VEX_W_XD, /* 11343 */ + IC_VEX_OPSIZE, /* 11344 */ + IC_VEX_OPSIZE, /* 11345 */ + IC_VEX_OPSIZE, /* 11346 */ + IC_VEX_OPSIZE, /* 11347 */ + IC_VEX_OPSIZE, /* 11348 */ + IC_VEX_OPSIZE, /* 11349 */ + IC_VEX_OPSIZE, /* 11350 */ + IC_VEX_OPSIZE, /* 11351 */ + IC_VEX_W_OPSIZE, /* 11352 */ + IC_VEX_W_OPSIZE, /* 11353 */ + IC_VEX_W_OPSIZE, /* 11354 */ + IC_VEX_W_OPSIZE, /* 11355 */ + IC_VEX_W_OPSIZE, /* 11356 */ + IC_VEX_W_OPSIZE, /* 11357 */ + IC_VEX_W_OPSIZE, /* 11358 */ + IC_VEX_W_OPSIZE, /* 11359 */ + IC_VEX, /* 11360 */ + IC_VEX, /* 11361 */ + IC_VEX_XS, /* 11362 */ + IC_VEX_XS, /* 11363 */ + IC_VEX_XD, /* 11364 */ + IC_VEX_XD, /* 11365 */ + IC_VEX_XD, /* 11366 */ + IC_VEX_XD, /* 11367 */ + IC_VEX_W, /* 11368 */ + IC_VEX_W, /* 11369 */ + IC_VEX_W_XS, /* 11370 */ + IC_VEX_W_XS, /* 11371 */ + IC_VEX_W_XD, /* 11372 */ + IC_VEX_W_XD, /* 11373 */ + IC_VEX_W_XD, /* 11374 */ + IC_VEX_W_XD, /* 11375 */ + IC_VEX_OPSIZE, /* 11376 */ + IC_VEX_OPSIZE, /* 11377 */ + IC_VEX_OPSIZE, /* 11378 */ + IC_VEX_OPSIZE, /* 11379 */ + IC_VEX_OPSIZE, /* 11380 */ + IC_VEX_OPSIZE, /* 11381 */ + IC_VEX_OPSIZE, /* 11382 */ + IC_VEX_OPSIZE, /* 11383 */ + IC_VEX_W_OPSIZE, /* 11384 */ + IC_VEX_W_OPSIZE, /* 11385 */ + IC_VEX_W_OPSIZE, /* 11386 */ + IC_VEX_W_OPSIZE, /* 11387 */ + IC_VEX_W_OPSIZE, /* 11388 */ + IC_VEX_W_OPSIZE, /* 11389 */ + IC_VEX_W_OPSIZE, /* 11390 */ + IC_VEX_W_OPSIZE, /* 11391 */ + IC_VEX_L, /* 11392 */ + IC_VEX_L, /* 11393 */ + IC_VEX_L_XS, /* 11394 */ + IC_VEX_L_XS, /* 11395 */ + IC_VEX_L_XD, /* 11396 */ + IC_VEX_L_XD, /* 11397 */ + IC_VEX_L_XD, /* 11398 */ + IC_VEX_L_XD, /* 11399 */ + IC_VEX_L_W, /* 11400 */ + IC_VEX_L_W, /* 11401 */ + IC_VEX_L_W_XS, /* 11402 */ + IC_VEX_L_W_XS, /* 11403 */ + IC_VEX_L_W_XD, /* 11404 */ + IC_VEX_L_W_XD, /* 11405 */ + IC_VEX_L_W_XD, /* 11406 */ + IC_VEX_L_W_XD, /* 11407 */ + IC_VEX_L_OPSIZE, /* 11408 */ + IC_VEX_L_OPSIZE, /* 11409 */ + IC_VEX_L_OPSIZE, /* 11410 */ + IC_VEX_L_OPSIZE, /* 11411 */ + IC_VEX_L_OPSIZE, /* 11412 */ + IC_VEX_L_OPSIZE, /* 11413 */ + IC_VEX_L_OPSIZE, /* 11414 */ + IC_VEX_L_OPSIZE, /* 11415 */ + IC_VEX_L_W_OPSIZE, /* 11416 */ + IC_VEX_L_W_OPSIZE, /* 11417 */ + IC_VEX_L_W_OPSIZE, /* 11418 */ + IC_VEX_L_W_OPSIZE, /* 11419 */ + IC_VEX_L_W_OPSIZE, /* 11420 */ + IC_VEX_L_W_OPSIZE, /* 11421 */ + IC_VEX_L_W_OPSIZE, /* 11422 */ + IC_VEX_L_W_OPSIZE, /* 11423 */ + IC_VEX_L, /* 11424 */ + IC_VEX_L, /* 11425 */ + IC_VEX_L_XS, /* 11426 */ + IC_VEX_L_XS, /* 11427 */ + IC_VEX_L_XD, /* 11428 */ + IC_VEX_L_XD, /* 11429 */ + IC_VEX_L_XD, /* 11430 */ + IC_VEX_L_XD, /* 11431 */ + IC_VEX_L_W, /* 11432 */ + IC_VEX_L_W, /* 11433 */ + IC_VEX_L_W_XS, /* 11434 */ + IC_VEX_L_W_XS, /* 11435 */ + IC_VEX_L_W_XD, /* 11436 */ + IC_VEX_L_W_XD, /* 11437 */ + IC_VEX_L_W_XD, /* 11438 */ + IC_VEX_L_W_XD, /* 11439 */ + IC_VEX_L_OPSIZE, /* 11440 */ + IC_VEX_L_OPSIZE, /* 11441 */ + IC_VEX_L_OPSIZE, /* 11442 */ + IC_VEX_L_OPSIZE, /* 11443 */ + IC_VEX_L_OPSIZE, /* 11444 */ + IC_VEX_L_OPSIZE, /* 11445 */ + IC_VEX_L_OPSIZE, /* 11446 */ + IC_VEX_L_OPSIZE, /* 11447 */ + IC_VEX_L_W_OPSIZE, /* 11448 */ + IC_VEX_L_W_OPSIZE, /* 11449 */ + IC_VEX_L_W_OPSIZE, /* 11450 */ + IC_VEX_L_W_OPSIZE, /* 11451 */ + IC_VEX_L_W_OPSIZE, /* 11452 */ + IC_VEX_L_W_OPSIZE, /* 11453 */ + IC_VEX_L_W_OPSIZE, /* 11454 */ + IC_VEX_L_W_OPSIZE, /* 11455 */ + IC_VEX_L, /* 11456 */ + IC_VEX_L, /* 11457 */ + IC_VEX_L_XS, /* 11458 */ + IC_VEX_L_XS, /* 11459 */ + IC_VEX_L_XD, /* 11460 */ + IC_VEX_L_XD, /* 11461 */ + IC_VEX_L_XD, /* 11462 */ + IC_VEX_L_XD, /* 11463 */ + IC_VEX_L_W, /* 11464 */ + IC_VEX_L_W, /* 11465 */ + IC_VEX_L_W_XS, /* 11466 */ + IC_VEX_L_W_XS, /* 11467 */ + IC_VEX_L_W_XD, /* 11468 */ + IC_VEX_L_W_XD, /* 11469 */ + IC_VEX_L_W_XD, /* 11470 */ + IC_VEX_L_W_XD, /* 11471 */ + IC_VEX_L_OPSIZE, /* 11472 */ + IC_VEX_L_OPSIZE, /* 11473 */ + IC_VEX_L_OPSIZE, /* 11474 */ + IC_VEX_L_OPSIZE, /* 11475 */ + IC_VEX_L_OPSIZE, /* 11476 */ + IC_VEX_L_OPSIZE, /* 11477 */ + IC_VEX_L_OPSIZE, /* 11478 */ + IC_VEX_L_OPSIZE, /* 11479 */ + IC_VEX_L_W_OPSIZE, /* 11480 */ + IC_VEX_L_W_OPSIZE, /* 11481 */ + IC_VEX_L_W_OPSIZE, /* 11482 */ + IC_VEX_L_W_OPSIZE, /* 11483 */ + IC_VEX_L_W_OPSIZE, /* 11484 */ + IC_VEX_L_W_OPSIZE, /* 11485 */ + IC_VEX_L_W_OPSIZE, /* 11486 */ + IC_VEX_L_W_OPSIZE, /* 11487 */ + IC_VEX_L, /* 11488 */ + IC_VEX_L, /* 11489 */ + IC_VEX_L_XS, /* 11490 */ + IC_VEX_L_XS, /* 11491 */ + IC_VEX_L_XD, /* 11492 */ + IC_VEX_L_XD, /* 11493 */ + IC_VEX_L_XD, /* 11494 */ + IC_VEX_L_XD, /* 11495 */ + IC_VEX_L_W, /* 11496 */ + IC_VEX_L_W, /* 11497 */ + IC_VEX_L_W_XS, /* 11498 */ + IC_VEX_L_W_XS, /* 11499 */ + IC_VEX_L_W_XD, /* 11500 */ + IC_VEX_L_W_XD, /* 11501 */ + IC_VEX_L_W_XD, /* 11502 */ + IC_VEX_L_W_XD, /* 11503 */ + IC_VEX_L_OPSIZE, /* 11504 */ + IC_VEX_L_OPSIZE, /* 11505 */ + IC_VEX_L_OPSIZE, /* 11506 */ + IC_VEX_L_OPSIZE, /* 11507 */ + IC_VEX_L_OPSIZE, /* 11508 */ + IC_VEX_L_OPSIZE, /* 11509 */ + IC_VEX_L_OPSIZE, /* 11510 */ + IC_VEX_L_OPSIZE, /* 11511 */ + IC_VEX_L_W_OPSIZE, /* 11512 */ + IC_VEX_L_W_OPSIZE, /* 11513 */ + IC_VEX_L_W_OPSIZE, /* 11514 */ + IC_VEX_L_W_OPSIZE, /* 11515 */ + IC_VEX_L_W_OPSIZE, /* 11516 */ + IC_VEX_L_W_OPSIZE, /* 11517 */ + IC_VEX_L_W_OPSIZE, /* 11518 */ + IC_VEX_L_W_OPSIZE, /* 11519 */ + IC_EVEX_L2_K_B, /* 11520 */ + IC_EVEX_L2_K_B, /* 11521 */ + IC_EVEX_L2_XS_K_B, /* 11522 */ + IC_EVEX_L2_XS_K_B, /* 11523 */ + IC_EVEX_L2_XD_K_B, /* 11524 */ + IC_EVEX_L2_XD_K_B, /* 11525 */ + IC_EVEX_L2_XD_K_B, /* 11526 */ + IC_EVEX_L2_XD_K_B, /* 11527 */ + IC_EVEX_L2_W_K_B, /* 11528 */ + IC_EVEX_L2_W_K_B, /* 11529 */ + IC_EVEX_L2_W_XS_K_B, /* 11530 */ + IC_EVEX_L2_W_XS_K_B, /* 11531 */ + IC_EVEX_L2_W_XD_K_B, /* 11532 */ + IC_EVEX_L2_W_XD_K_B, /* 11533 */ + IC_EVEX_L2_W_XD_K_B, /* 11534 */ + IC_EVEX_L2_W_XD_K_B, /* 11535 */ + IC_EVEX_L2_OPSIZE_K_B, /* 11536 */ + IC_EVEX_L2_OPSIZE_K_B, /* 11537 */ + IC_EVEX_L2_OPSIZE_K_B, /* 11538 */ + IC_EVEX_L2_OPSIZE_K_B, /* 11539 */ + IC_EVEX_L2_OPSIZE_K_B, /* 11540 */ + IC_EVEX_L2_OPSIZE_K_B, /* 11541 */ + IC_EVEX_L2_OPSIZE_K_B, /* 11542 */ + IC_EVEX_L2_OPSIZE_K_B, /* 11543 */ + IC_EVEX_L2_W_OPSIZE_K_B, /* 11544 */ + IC_EVEX_L2_W_OPSIZE_K_B, /* 11545 */ + IC_EVEX_L2_W_OPSIZE_K_B, /* 11546 */ + IC_EVEX_L2_W_OPSIZE_K_B, /* 11547 */ + IC_EVEX_L2_W_OPSIZE_K_B, /* 11548 */ + IC_EVEX_L2_W_OPSIZE_K_B, /* 11549 */ + IC_EVEX_L2_W_OPSIZE_K_B, /* 11550 */ + IC_EVEX_L2_W_OPSIZE_K_B, /* 11551 */ + IC_EVEX_L2_K_B, /* 11552 */ + IC_EVEX_L2_K_B, /* 11553 */ + IC_EVEX_L2_XS_K_B, /* 11554 */ + IC_EVEX_L2_XS_K_B, /* 11555 */ + IC_EVEX_L2_XD_K_B, /* 11556 */ + IC_EVEX_L2_XD_K_B, /* 11557 */ + IC_EVEX_L2_XD_K_B, /* 11558 */ + IC_EVEX_L2_XD_K_B, /* 11559 */ + IC_EVEX_L2_W_K_B, /* 11560 */ + IC_EVEX_L2_W_K_B, /* 11561 */ + IC_EVEX_L2_W_XS_K_B, /* 11562 */ + IC_EVEX_L2_W_XS_K_B, /* 11563 */ + IC_EVEX_L2_W_XD_K_B, /* 11564 */ + IC_EVEX_L2_W_XD_K_B, /* 11565 */ + IC_EVEX_L2_W_XD_K_B, /* 11566 */ + IC_EVEX_L2_W_XD_K_B, /* 11567 */ + IC_EVEX_L2_OPSIZE_K_B, /* 11568 */ + IC_EVEX_L2_OPSIZE_K_B, /* 11569 */ + IC_EVEX_L2_OPSIZE_K_B, /* 11570 */ + IC_EVEX_L2_OPSIZE_K_B, /* 11571 */ + IC_EVEX_L2_OPSIZE_K_B, /* 11572 */ + IC_EVEX_L2_OPSIZE_K_B, /* 11573 */ + IC_EVEX_L2_OPSIZE_K_B, /* 11574 */ + IC_EVEX_L2_OPSIZE_K_B, /* 11575 */ + IC_EVEX_L2_W_OPSIZE_K_B, /* 11576 */ + IC_EVEX_L2_W_OPSIZE_K_B, /* 11577 */ + IC_EVEX_L2_W_OPSIZE_K_B, /* 11578 */ + IC_EVEX_L2_W_OPSIZE_K_B, /* 11579 */ + IC_EVEX_L2_W_OPSIZE_K_B, /* 11580 */ + IC_EVEX_L2_W_OPSIZE_K_B, /* 11581 */ + IC_EVEX_L2_W_OPSIZE_K_B, /* 11582 */ + IC_EVEX_L2_W_OPSIZE_K_B, /* 11583 */ + IC_EVEX_L2_K_B, /* 11584 */ + IC_EVEX_L2_K_B, /* 11585 */ + IC_EVEX_L2_XS_K_B, /* 11586 */ + IC_EVEX_L2_XS_K_B, /* 11587 */ + IC_EVEX_L2_XD_K_B, /* 11588 */ + IC_EVEX_L2_XD_K_B, /* 11589 */ + IC_EVEX_L2_XD_K_B, /* 11590 */ + IC_EVEX_L2_XD_K_B, /* 11591 */ + IC_EVEX_L2_W_K_B, /* 11592 */ + IC_EVEX_L2_W_K_B, /* 11593 */ + IC_EVEX_L2_W_XS_K_B, /* 11594 */ + IC_EVEX_L2_W_XS_K_B, /* 11595 */ + IC_EVEX_L2_W_XD_K_B, /* 11596 */ + IC_EVEX_L2_W_XD_K_B, /* 11597 */ + IC_EVEX_L2_W_XD_K_B, /* 11598 */ + IC_EVEX_L2_W_XD_K_B, /* 11599 */ + IC_EVEX_L2_OPSIZE_K_B, /* 11600 */ + IC_EVEX_L2_OPSIZE_K_B, /* 11601 */ + IC_EVEX_L2_OPSIZE_K_B, /* 11602 */ + IC_EVEX_L2_OPSIZE_K_B, /* 11603 */ + IC_EVEX_L2_OPSIZE_K_B, /* 11604 */ + IC_EVEX_L2_OPSIZE_K_B, /* 11605 */ + IC_EVEX_L2_OPSIZE_K_B, /* 11606 */ + IC_EVEX_L2_OPSIZE_K_B, /* 11607 */ + IC_EVEX_L2_W_OPSIZE_K_B, /* 11608 */ + IC_EVEX_L2_W_OPSIZE_K_B, /* 11609 */ + IC_EVEX_L2_W_OPSIZE_K_B, /* 11610 */ + IC_EVEX_L2_W_OPSIZE_K_B, /* 11611 */ + IC_EVEX_L2_W_OPSIZE_K_B, /* 11612 */ + IC_EVEX_L2_W_OPSIZE_K_B, /* 11613 */ + IC_EVEX_L2_W_OPSIZE_K_B, /* 11614 */ + IC_EVEX_L2_W_OPSIZE_K_B, /* 11615 */ + IC_EVEX_L2_K_B, /* 11616 */ + IC_EVEX_L2_K_B, /* 11617 */ + IC_EVEX_L2_XS_K_B, /* 11618 */ + IC_EVEX_L2_XS_K_B, /* 11619 */ + IC_EVEX_L2_XD_K_B, /* 11620 */ + IC_EVEX_L2_XD_K_B, /* 11621 */ + IC_EVEX_L2_XD_K_B, /* 11622 */ + IC_EVEX_L2_XD_K_B, /* 11623 */ + IC_EVEX_L2_W_K_B, /* 11624 */ + IC_EVEX_L2_W_K_B, /* 11625 */ + IC_EVEX_L2_W_XS_K_B, /* 11626 */ + IC_EVEX_L2_W_XS_K_B, /* 11627 */ + IC_EVEX_L2_W_XD_K_B, /* 11628 */ + IC_EVEX_L2_W_XD_K_B, /* 11629 */ + IC_EVEX_L2_W_XD_K_B, /* 11630 */ + IC_EVEX_L2_W_XD_K_B, /* 11631 */ + IC_EVEX_L2_OPSIZE_K_B, /* 11632 */ + IC_EVEX_L2_OPSIZE_K_B, /* 11633 */ + IC_EVEX_L2_OPSIZE_K_B, /* 11634 */ + IC_EVEX_L2_OPSIZE_K_B, /* 11635 */ + IC_EVEX_L2_OPSIZE_K_B, /* 11636 */ + IC_EVEX_L2_OPSIZE_K_B, /* 11637 */ + IC_EVEX_L2_OPSIZE_K_B, /* 11638 */ + IC_EVEX_L2_OPSIZE_K_B, /* 11639 */ + IC_EVEX_L2_W_OPSIZE_K_B, /* 11640 */ + IC_EVEX_L2_W_OPSIZE_K_B, /* 11641 */ + IC_EVEX_L2_W_OPSIZE_K_B, /* 11642 */ + IC_EVEX_L2_W_OPSIZE_K_B, /* 11643 */ + IC_EVEX_L2_W_OPSIZE_K_B, /* 11644 */ + IC_EVEX_L2_W_OPSIZE_K_B, /* 11645 */ + IC_EVEX_L2_W_OPSIZE_K_B, /* 11646 */ + IC_EVEX_L2_W_OPSIZE_K_B, /* 11647 */ + IC_EVEX_L2_K_B, /* 11648 */ + IC_EVEX_L2_K_B, /* 11649 */ + IC_EVEX_L2_XS_K_B, /* 11650 */ + IC_EVEX_L2_XS_K_B, /* 11651 */ + IC_EVEX_L2_XD_K_B, /* 11652 */ + IC_EVEX_L2_XD_K_B, /* 11653 */ + IC_EVEX_L2_XD_K_B, /* 11654 */ + IC_EVEX_L2_XD_K_B, /* 11655 */ + IC_EVEX_L2_W_K_B, /* 11656 */ + IC_EVEX_L2_W_K_B, /* 11657 */ + IC_EVEX_L2_W_XS_K_B, /* 11658 */ + IC_EVEX_L2_W_XS_K_B, /* 11659 */ + IC_EVEX_L2_W_XD_K_B, /* 11660 */ + IC_EVEX_L2_W_XD_K_B, /* 11661 */ + IC_EVEX_L2_W_XD_K_B, /* 11662 */ + IC_EVEX_L2_W_XD_K_B, /* 11663 */ + IC_EVEX_L2_OPSIZE_K_B, /* 11664 */ + IC_EVEX_L2_OPSIZE_K_B, /* 11665 */ + IC_EVEX_L2_OPSIZE_K_B, /* 11666 */ + IC_EVEX_L2_OPSIZE_K_B, /* 11667 */ + IC_EVEX_L2_OPSIZE_K_B, /* 11668 */ + IC_EVEX_L2_OPSIZE_K_B, /* 11669 */ + IC_EVEX_L2_OPSIZE_K_B, /* 11670 */ + IC_EVEX_L2_OPSIZE_K_B, /* 11671 */ + IC_EVEX_L2_W_OPSIZE_K_B, /* 11672 */ + IC_EVEX_L2_W_OPSIZE_K_B, /* 11673 */ + IC_EVEX_L2_W_OPSIZE_K_B, /* 11674 */ + IC_EVEX_L2_W_OPSIZE_K_B, /* 11675 */ + IC_EVEX_L2_W_OPSIZE_K_B, /* 11676 */ + IC_EVEX_L2_W_OPSIZE_K_B, /* 11677 */ + IC_EVEX_L2_W_OPSIZE_K_B, /* 11678 */ + IC_EVEX_L2_W_OPSIZE_K_B, /* 11679 */ + IC_EVEX_L2_K_B, /* 11680 */ + IC_EVEX_L2_K_B, /* 11681 */ + IC_EVEX_L2_XS_K_B, /* 11682 */ + IC_EVEX_L2_XS_K_B, /* 11683 */ + IC_EVEX_L2_XD_K_B, /* 11684 */ + IC_EVEX_L2_XD_K_B, /* 11685 */ + IC_EVEX_L2_XD_K_B, /* 11686 */ + IC_EVEX_L2_XD_K_B, /* 11687 */ + IC_EVEX_L2_W_K_B, /* 11688 */ + IC_EVEX_L2_W_K_B, /* 11689 */ + IC_EVEX_L2_W_XS_K_B, /* 11690 */ + IC_EVEX_L2_W_XS_K_B, /* 11691 */ + IC_EVEX_L2_W_XD_K_B, /* 11692 */ + IC_EVEX_L2_W_XD_K_B, /* 11693 */ + IC_EVEX_L2_W_XD_K_B, /* 11694 */ + IC_EVEX_L2_W_XD_K_B, /* 11695 */ + IC_EVEX_L2_OPSIZE_K_B, /* 11696 */ + IC_EVEX_L2_OPSIZE_K_B, /* 11697 */ + IC_EVEX_L2_OPSIZE_K_B, /* 11698 */ + IC_EVEX_L2_OPSIZE_K_B, /* 11699 */ + IC_EVEX_L2_OPSIZE_K_B, /* 11700 */ + IC_EVEX_L2_OPSIZE_K_B, /* 11701 */ + IC_EVEX_L2_OPSIZE_K_B, /* 11702 */ + IC_EVEX_L2_OPSIZE_K_B, /* 11703 */ + IC_EVEX_L2_W_OPSIZE_K_B, /* 11704 */ + IC_EVEX_L2_W_OPSIZE_K_B, /* 11705 */ + IC_EVEX_L2_W_OPSIZE_K_B, /* 11706 */ + IC_EVEX_L2_W_OPSIZE_K_B, /* 11707 */ + IC_EVEX_L2_W_OPSIZE_K_B, /* 11708 */ + IC_EVEX_L2_W_OPSIZE_K_B, /* 11709 */ + IC_EVEX_L2_W_OPSIZE_K_B, /* 11710 */ + IC_EVEX_L2_W_OPSIZE_K_B, /* 11711 */ + IC_EVEX_L2_K_B, /* 11712 */ + IC_EVEX_L2_K_B, /* 11713 */ + IC_EVEX_L2_XS_K_B, /* 11714 */ + IC_EVEX_L2_XS_K_B, /* 11715 */ + IC_EVEX_L2_XD_K_B, /* 11716 */ + IC_EVEX_L2_XD_K_B, /* 11717 */ + IC_EVEX_L2_XD_K_B, /* 11718 */ + IC_EVEX_L2_XD_K_B, /* 11719 */ + IC_EVEX_L2_W_K_B, /* 11720 */ + IC_EVEX_L2_W_K_B, /* 11721 */ + IC_EVEX_L2_W_XS_K_B, /* 11722 */ + IC_EVEX_L2_W_XS_K_B, /* 11723 */ + IC_EVEX_L2_W_XD_K_B, /* 11724 */ + IC_EVEX_L2_W_XD_K_B, /* 11725 */ + IC_EVEX_L2_W_XD_K_B, /* 11726 */ + IC_EVEX_L2_W_XD_K_B, /* 11727 */ + IC_EVEX_L2_OPSIZE_K_B, /* 11728 */ + IC_EVEX_L2_OPSIZE_K_B, /* 11729 */ + IC_EVEX_L2_OPSIZE_K_B, /* 11730 */ + IC_EVEX_L2_OPSIZE_K_B, /* 11731 */ + IC_EVEX_L2_OPSIZE_K_B, /* 11732 */ + IC_EVEX_L2_OPSIZE_K_B, /* 11733 */ + IC_EVEX_L2_OPSIZE_K_B, /* 11734 */ + IC_EVEX_L2_OPSIZE_K_B, /* 11735 */ + IC_EVEX_L2_W_OPSIZE_K_B, /* 11736 */ + IC_EVEX_L2_W_OPSIZE_K_B, /* 11737 */ + IC_EVEX_L2_W_OPSIZE_K_B, /* 11738 */ + IC_EVEX_L2_W_OPSIZE_K_B, /* 11739 */ + IC_EVEX_L2_W_OPSIZE_K_B, /* 11740 */ + IC_EVEX_L2_W_OPSIZE_K_B, /* 11741 */ + IC_EVEX_L2_W_OPSIZE_K_B, /* 11742 */ + IC_EVEX_L2_W_OPSIZE_K_B, /* 11743 */ + IC_EVEX_L2_K_B, /* 11744 */ + IC_EVEX_L2_K_B, /* 11745 */ + IC_EVEX_L2_XS_K_B, /* 11746 */ + IC_EVEX_L2_XS_K_B, /* 11747 */ + IC_EVEX_L2_XD_K_B, /* 11748 */ + IC_EVEX_L2_XD_K_B, /* 11749 */ + IC_EVEX_L2_XD_K_B, /* 11750 */ + IC_EVEX_L2_XD_K_B, /* 11751 */ + IC_EVEX_L2_W_K_B, /* 11752 */ + IC_EVEX_L2_W_K_B, /* 11753 */ + IC_EVEX_L2_W_XS_K_B, /* 11754 */ + IC_EVEX_L2_W_XS_K_B, /* 11755 */ + IC_EVEX_L2_W_XD_K_B, /* 11756 */ + IC_EVEX_L2_W_XD_K_B, /* 11757 */ + IC_EVEX_L2_W_XD_K_B, /* 11758 */ + IC_EVEX_L2_W_XD_K_B, /* 11759 */ + IC_EVEX_L2_OPSIZE_K_B, /* 11760 */ + IC_EVEX_L2_OPSIZE_K_B, /* 11761 */ + IC_EVEX_L2_OPSIZE_K_B, /* 11762 */ + IC_EVEX_L2_OPSIZE_K_B, /* 11763 */ + IC_EVEX_L2_OPSIZE_K_B, /* 11764 */ + IC_EVEX_L2_OPSIZE_K_B, /* 11765 */ + IC_EVEX_L2_OPSIZE_K_B, /* 11766 */ + IC_EVEX_L2_OPSIZE_K_B, /* 11767 */ + IC_EVEX_L2_W_OPSIZE_K_B, /* 11768 */ + IC_EVEX_L2_W_OPSIZE_K_B, /* 11769 */ + IC_EVEX_L2_W_OPSIZE_K_B, /* 11770 */ + IC_EVEX_L2_W_OPSIZE_K_B, /* 11771 */ + IC_EVEX_L2_W_OPSIZE_K_B, /* 11772 */ + IC_EVEX_L2_W_OPSIZE_K_B, /* 11773 */ + IC_EVEX_L2_W_OPSIZE_K_B, /* 11774 */ + IC_EVEX_L2_W_OPSIZE_K_B, /* 11775 */ + IC, /* 11776 */ + IC_64BIT, /* 11777 */ + IC_XS, /* 11778 */ + IC_64BIT_XS, /* 11779 */ + IC_XD, /* 11780 */ + IC_64BIT_XD, /* 11781 */ + IC_XS, /* 11782 */ + IC_64BIT_XS, /* 11783 */ + IC, /* 11784 */ + IC_64BIT_REXW, /* 11785 */ + IC_XS, /* 11786 */ + IC_64BIT_REXW_XS, /* 11787 */ + IC_XD, /* 11788 */ + IC_64BIT_REXW_XD, /* 11789 */ + IC_XS, /* 11790 */ + IC_64BIT_REXW_XS, /* 11791 */ + IC_OPSIZE, /* 11792 */ + IC_64BIT_OPSIZE, /* 11793 */ + IC_XS_OPSIZE, /* 11794 */ + IC_64BIT_XS_OPSIZE, /* 11795 */ + IC_XD_OPSIZE, /* 11796 */ + IC_64BIT_XD_OPSIZE, /* 11797 */ + IC_XS_OPSIZE, /* 11798 */ + IC_64BIT_XD_OPSIZE, /* 11799 */ + IC_OPSIZE, /* 11800 */ + IC_64BIT_REXW_OPSIZE, /* 11801 */ + IC_XS_OPSIZE, /* 11802 */ + IC_64BIT_REXW_XS, /* 11803 */ + IC_XD_OPSIZE, /* 11804 */ + IC_64BIT_REXW_XD, /* 11805 */ + IC_XS_OPSIZE, /* 11806 */ + IC_64BIT_REXW_XS, /* 11807 */ + IC_ADSIZE, /* 11808 */ + IC_64BIT_ADSIZE, /* 11809 */ + IC_XS_ADSIZE, /* 11810 */ + IC_64BIT_XS_ADSIZE, /* 11811 */ + IC_XD_ADSIZE, /* 11812 */ + IC_64BIT_XD_ADSIZE, /* 11813 */ + IC_XS_ADSIZE, /* 11814 */ + IC_64BIT_XD_ADSIZE, /* 11815 */ + IC_ADSIZE, /* 11816 */ + IC_64BIT_REXW_ADSIZE, /* 11817 */ + IC_XS_ADSIZE, /* 11818 */ + IC_64BIT_REXW_XS, /* 11819 */ + IC_XD_ADSIZE, /* 11820 */ + IC_64BIT_REXW_XD, /* 11821 */ + IC_XS_ADSIZE, /* 11822 */ + IC_64BIT_REXW_XS, /* 11823 */ + IC_OPSIZE_ADSIZE, /* 11824 */ + IC_64BIT_OPSIZE_ADSIZE, /* 11825 */ + IC_XS_OPSIZE, /* 11826 */ + IC_64BIT_XS_OPSIZE, /* 11827 */ + IC_XD_OPSIZE, /* 11828 */ + IC_64BIT_XD_OPSIZE, /* 11829 */ + IC_XS_OPSIZE, /* 11830 */ + IC_64BIT_XD_OPSIZE, /* 11831 */ + IC_OPSIZE_ADSIZE, /* 11832 */ + IC_64BIT_REXW_OPSIZE, /* 11833 */ + IC_XS_OPSIZE, /* 11834 */ + IC_64BIT_REXW_XS, /* 11835 */ + IC_XD_OPSIZE, /* 11836 */ + IC_64BIT_REXW_XD, /* 11837 */ + IC_XS_OPSIZE, /* 11838 */ + IC_64BIT_REXW_XS, /* 11839 */ + IC_VEX, /* 11840 */ + IC_VEX, /* 11841 */ + IC_VEX_XS, /* 11842 */ + IC_VEX_XS, /* 11843 */ + IC_VEX_XD, /* 11844 */ + IC_VEX_XD, /* 11845 */ + IC_VEX_XD, /* 11846 */ + IC_VEX_XD, /* 11847 */ + IC_VEX_W, /* 11848 */ + IC_VEX_W, /* 11849 */ + IC_VEX_W_XS, /* 11850 */ + IC_VEX_W_XS, /* 11851 */ + IC_VEX_W_XD, /* 11852 */ + IC_VEX_W_XD, /* 11853 */ + IC_VEX_W_XD, /* 11854 */ + IC_VEX_W_XD, /* 11855 */ + IC_VEX_OPSIZE, /* 11856 */ + IC_VEX_OPSIZE, /* 11857 */ + IC_VEX_OPSIZE, /* 11858 */ + IC_VEX_OPSIZE, /* 11859 */ + IC_VEX_OPSIZE, /* 11860 */ + IC_VEX_OPSIZE, /* 11861 */ + IC_VEX_OPSIZE, /* 11862 */ + IC_VEX_OPSIZE, /* 11863 */ + IC_VEX_W_OPSIZE, /* 11864 */ + IC_VEX_W_OPSIZE, /* 11865 */ + IC_VEX_W_OPSIZE, /* 11866 */ + IC_VEX_W_OPSIZE, /* 11867 */ + IC_VEX_W_OPSIZE, /* 11868 */ + IC_VEX_W_OPSIZE, /* 11869 */ + IC_VEX_W_OPSIZE, /* 11870 */ + IC_VEX_W_OPSIZE, /* 11871 */ + IC_VEX, /* 11872 */ + IC_VEX, /* 11873 */ + IC_VEX_XS, /* 11874 */ + IC_VEX_XS, /* 11875 */ + IC_VEX_XD, /* 11876 */ + IC_VEX_XD, /* 11877 */ + IC_VEX_XD, /* 11878 */ + IC_VEX_XD, /* 11879 */ + IC_VEX_W, /* 11880 */ + IC_VEX_W, /* 11881 */ + IC_VEX_W_XS, /* 11882 */ + IC_VEX_W_XS, /* 11883 */ + IC_VEX_W_XD, /* 11884 */ + IC_VEX_W_XD, /* 11885 */ + IC_VEX_W_XD, /* 11886 */ + IC_VEX_W_XD, /* 11887 */ + IC_VEX_OPSIZE, /* 11888 */ + IC_VEX_OPSIZE, /* 11889 */ + IC_VEX_OPSIZE, /* 11890 */ + IC_VEX_OPSIZE, /* 11891 */ + IC_VEX_OPSIZE, /* 11892 */ + IC_VEX_OPSIZE, /* 11893 */ + IC_VEX_OPSIZE, /* 11894 */ + IC_VEX_OPSIZE, /* 11895 */ + IC_VEX_W_OPSIZE, /* 11896 */ + IC_VEX_W_OPSIZE, /* 11897 */ + IC_VEX_W_OPSIZE, /* 11898 */ + IC_VEX_W_OPSIZE, /* 11899 */ + IC_VEX_W_OPSIZE, /* 11900 */ + IC_VEX_W_OPSIZE, /* 11901 */ + IC_VEX_W_OPSIZE, /* 11902 */ + IC_VEX_W_OPSIZE, /* 11903 */ + IC_VEX_L, /* 11904 */ + IC_VEX_L, /* 11905 */ + IC_VEX_L_XS, /* 11906 */ + IC_VEX_L_XS, /* 11907 */ + IC_VEX_L_XD, /* 11908 */ + IC_VEX_L_XD, /* 11909 */ + IC_VEX_L_XD, /* 11910 */ + IC_VEX_L_XD, /* 11911 */ + IC_VEX_L_W, /* 11912 */ + IC_VEX_L_W, /* 11913 */ + IC_VEX_L_W_XS, /* 11914 */ + IC_VEX_L_W_XS, /* 11915 */ + IC_VEX_L_W_XD, /* 11916 */ + IC_VEX_L_W_XD, /* 11917 */ + IC_VEX_L_W_XD, /* 11918 */ + IC_VEX_L_W_XD, /* 11919 */ + IC_VEX_L_OPSIZE, /* 11920 */ + IC_VEX_L_OPSIZE, /* 11921 */ + IC_VEX_L_OPSIZE, /* 11922 */ + IC_VEX_L_OPSIZE, /* 11923 */ + IC_VEX_L_OPSIZE, /* 11924 */ + IC_VEX_L_OPSIZE, /* 11925 */ + IC_VEX_L_OPSIZE, /* 11926 */ + IC_VEX_L_OPSIZE, /* 11927 */ + IC_VEX_L_W_OPSIZE, /* 11928 */ + IC_VEX_L_W_OPSIZE, /* 11929 */ + IC_VEX_L_W_OPSIZE, /* 11930 */ + IC_VEX_L_W_OPSIZE, /* 11931 */ + IC_VEX_L_W_OPSIZE, /* 11932 */ + IC_VEX_L_W_OPSIZE, /* 11933 */ + IC_VEX_L_W_OPSIZE, /* 11934 */ + IC_VEX_L_W_OPSIZE, /* 11935 */ + IC_VEX_L, /* 11936 */ + IC_VEX_L, /* 11937 */ + IC_VEX_L_XS, /* 11938 */ + IC_VEX_L_XS, /* 11939 */ + IC_VEX_L_XD, /* 11940 */ + IC_VEX_L_XD, /* 11941 */ + IC_VEX_L_XD, /* 11942 */ + IC_VEX_L_XD, /* 11943 */ + IC_VEX_L_W, /* 11944 */ + IC_VEX_L_W, /* 11945 */ + IC_VEX_L_W_XS, /* 11946 */ + IC_VEX_L_W_XS, /* 11947 */ + IC_VEX_L_W_XD, /* 11948 */ + IC_VEX_L_W_XD, /* 11949 */ + IC_VEX_L_W_XD, /* 11950 */ + IC_VEX_L_W_XD, /* 11951 */ + IC_VEX_L_OPSIZE, /* 11952 */ + IC_VEX_L_OPSIZE, /* 11953 */ + IC_VEX_L_OPSIZE, /* 11954 */ + IC_VEX_L_OPSIZE, /* 11955 */ + IC_VEX_L_OPSIZE, /* 11956 */ + IC_VEX_L_OPSIZE, /* 11957 */ + IC_VEX_L_OPSIZE, /* 11958 */ + IC_VEX_L_OPSIZE, /* 11959 */ + IC_VEX_L_W_OPSIZE, /* 11960 */ + IC_VEX_L_W_OPSIZE, /* 11961 */ + IC_VEX_L_W_OPSIZE, /* 11962 */ + IC_VEX_L_W_OPSIZE, /* 11963 */ + IC_VEX_L_W_OPSIZE, /* 11964 */ + IC_VEX_L_W_OPSIZE, /* 11965 */ + IC_VEX_L_W_OPSIZE, /* 11966 */ + IC_VEX_L_W_OPSIZE, /* 11967 */ + IC_VEX_L, /* 11968 */ + IC_VEX_L, /* 11969 */ + IC_VEX_L_XS, /* 11970 */ + IC_VEX_L_XS, /* 11971 */ + IC_VEX_L_XD, /* 11972 */ + IC_VEX_L_XD, /* 11973 */ + IC_VEX_L_XD, /* 11974 */ + IC_VEX_L_XD, /* 11975 */ + IC_VEX_L_W, /* 11976 */ + IC_VEX_L_W, /* 11977 */ + IC_VEX_L_W_XS, /* 11978 */ + IC_VEX_L_W_XS, /* 11979 */ + IC_VEX_L_W_XD, /* 11980 */ + IC_VEX_L_W_XD, /* 11981 */ + IC_VEX_L_W_XD, /* 11982 */ + IC_VEX_L_W_XD, /* 11983 */ + IC_VEX_L_OPSIZE, /* 11984 */ + IC_VEX_L_OPSIZE, /* 11985 */ + IC_VEX_L_OPSIZE, /* 11986 */ + IC_VEX_L_OPSIZE, /* 11987 */ + IC_VEX_L_OPSIZE, /* 11988 */ + IC_VEX_L_OPSIZE, /* 11989 */ + IC_VEX_L_OPSIZE, /* 11990 */ + IC_VEX_L_OPSIZE, /* 11991 */ + IC_VEX_L_W_OPSIZE, /* 11992 */ + IC_VEX_L_W_OPSIZE, /* 11993 */ + IC_VEX_L_W_OPSIZE, /* 11994 */ + IC_VEX_L_W_OPSIZE, /* 11995 */ + IC_VEX_L_W_OPSIZE, /* 11996 */ + IC_VEX_L_W_OPSIZE, /* 11997 */ + IC_VEX_L_W_OPSIZE, /* 11998 */ + IC_VEX_L_W_OPSIZE, /* 11999 */ + IC_VEX_L, /* 12000 */ + IC_VEX_L, /* 12001 */ + IC_VEX_L_XS, /* 12002 */ + IC_VEX_L_XS, /* 12003 */ + IC_VEX_L_XD, /* 12004 */ + IC_VEX_L_XD, /* 12005 */ + IC_VEX_L_XD, /* 12006 */ + IC_VEX_L_XD, /* 12007 */ + IC_VEX_L_W, /* 12008 */ + IC_VEX_L_W, /* 12009 */ + IC_VEX_L_W_XS, /* 12010 */ + IC_VEX_L_W_XS, /* 12011 */ + IC_VEX_L_W_XD, /* 12012 */ + IC_VEX_L_W_XD, /* 12013 */ + IC_VEX_L_W_XD, /* 12014 */ + IC_VEX_L_W_XD, /* 12015 */ + IC_VEX_L_OPSIZE, /* 12016 */ + IC_VEX_L_OPSIZE, /* 12017 */ + IC_VEX_L_OPSIZE, /* 12018 */ + IC_VEX_L_OPSIZE, /* 12019 */ + IC_VEX_L_OPSIZE, /* 12020 */ + IC_VEX_L_OPSIZE, /* 12021 */ + IC_VEX_L_OPSIZE, /* 12022 */ + IC_VEX_L_OPSIZE, /* 12023 */ + IC_VEX_L_W_OPSIZE, /* 12024 */ + IC_VEX_L_W_OPSIZE, /* 12025 */ + IC_VEX_L_W_OPSIZE, /* 12026 */ + IC_VEX_L_W_OPSIZE, /* 12027 */ + IC_VEX_L_W_OPSIZE, /* 12028 */ + IC_VEX_L_W_OPSIZE, /* 12029 */ + IC_VEX_L_W_OPSIZE, /* 12030 */ + IC_VEX_L_W_OPSIZE, /* 12031 */ + IC_EVEX_L2_K_B, /* 12032 */ + IC_EVEX_L2_K_B, /* 12033 */ + IC_EVEX_L2_XS_K_B, /* 12034 */ + IC_EVEX_L2_XS_K_B, /* 12035 */ + IC_EVEX_L2_XD_K_B, /* 12036 */ + IC_EVEX_L2_XD_K_B, /* 12037 */ + IC_EVEX_L2_XD_K_B, /* 12038 */ + IC_EVEX_L2_XD_K_B, /* 12039 */ + IC_EVEX_L2_W_K_B, /* 12040 */ + IC_EVEX_L2_W_K_B, /* 12041 */ + IC_EVEX_L2_W_XS_K_B, /* 12042 */ + IC_EVEX_L2_W_XS_K_B, /* 12043 */ + IC_EVEX_L2_W_XD_K_B, /* 12044 */ + IC_EVEX_L2_W_XD_K_B, /* 12045 */ + IC_EVEX_L2_W_XD_K_B, /* 12046 */ + IC_EVEX_L2_W_XD_K_B, /* 12047 */ + IC_EVEX_L2_OPSIZE_K_B, /* 12048 */ + IC_EVEX_L2_OPSIZE_K_B, /* 12049 */ + IC_EVEX_L2_OPSIZE_K_B, /* 12050 */ + IC_EVEX_L2_OPSIZE_K_B, /* 12051 */ + IC_EVEX_L2_OPSIZE_K_B, /* 12052 */ + IC_EVEX_L2_OPSIZE_K_B, /* 12053 */ + IC_EVEX_L2_OPSIZE_K_B, /* 12054 */ + IC_EVEX_L2_OPSIZE_K_B, /* 12055 */ + IC_EVEX_L2_W_OPSIZE_K_B, /* 12056 */ + IC_EVEX_L2_W_OPSIZE_K_B, /* 12057 */ + IC_EVEX_L2_W_OPSIZE_K_B, /* 12058 */ + IC_EVEX_L2_W_OPSIZE_K_B, /* 12059 */ + IC_EVEX_L2_W_OPSIZE_K_B, /* 12060 */ + IC_EVEX_L2_W_OPSIZE_K_B, /* 12061 */ + IC_EVEX_L2_W_OPSIZE_K_B, /* 12062 */ + IC_EVEX_L2_W_OPSIZE_K_B, /* 12063 */ + IC_EVEX_L2_K_B, /* 12064 */ + IC_EVEX_L2_K_B, /* 12065 */ + IC_EVEX_L2_XS_K_B, /* 12066 */ + IC_EVEX_L2_XS_K_B, /* 12067 */ + IC_EVEX_L2_XD_K_B, /* 12068 */ + IC_EVEX_L2_XD_K_B, /* 12069 */ + IC_EVEX_L2_XD_K_B, /* 12070 */ + IC_EVEX_L2_XD_K_B, /* 12071 */ + IC_EVEX_L2_W_K_B, /* 12072 */ + IC_EVEX_L2_W_K_B, /* 12073 */ + IC_EVEX_L2_W_XS_K_B, /* 12074 */ + IC_EVEX_L2_W_XS_K_B, /* 12075 */ + IC_EVEX_L2_W_XD_K_B, /* 12076 */ + IC_EVEX_L2_W_XD_K_B, /* 12077 */ + IC_EVEX_L2_W_XD_K_B, /* 12078 */ + IC_EVEX_L2_W_XD_K_B, /* 12079 */ + IC_EVEX_L2_OPSIZE_K_B, /* 12080 */ + IC_EVEX_L2_OPSIZE_K_B, /* 12081 */ + IC_EVEX_L2_OPSIZE_K_B, /* 12082 */ + IC_EVEX_L2_OPSIZE_K_B, /* 12083 */ + IC_EVEX_L2_OPSIZE_K_B, /* 12084 */ + IC_EVEX_L2_OPSIZE_K_B, /* 12085 */ + IC_EVEX_L2_OPSIZE_K_B, /* 12086 */ + IC_EVEX_L2_OPSIZE_K_B, /* 12087 */ + IC_EVEX_L2_W_OPSIZE_K_B, /* 12088 */ + IC_EVEX_L2_W_OPSIZE_K_B, /* 12089 */ + IC_EVEX_L2_W_OPSIZE_K_B, /* 12090 */ + IC_EVEX_L2_W_OPSIZE_K_B, /* 12091 */ + IC_EVEX_L2_W_OPSIZE_K_B, /* 12092 */ + IC_EVEX_L2_W_OPSIZE_K_B, /* 12093 */ + IC_EVEX_L2_W_OPSIZE_K_B, /* 12094 */ + IC_EVEX_L2_W_OPSIZE_K_B, /* 12095 */ + IC_EVEX_L2_K_B, /* 12096 */ + IC_EVEX_L2_K_B, /* 12097 */ + IC_EVEX_L2_XS_K_B, /* 12098 */ + IC_EVEX_L2_XS_K_B, /* 12099 */ + IC_EVEX_L2_XD_K_B, /* 12100 */ + IC_EVEX_L2_XD_K_B, /* 12101 */ + IC_EVEX_L2_XD_K_B, /* 12102 */ + IC_EVEX_L2_XD_K_B, /* 12103 */ + IC_EVEX_L2_W_K_B, /* 12104 */ + IC_EVEX_L2_W_K_B, /* 12105 */ + IC_EVEX_L2_W_XS_K_B, /* 12106 */ + IC_EVEX_L2_W_XS_K_B, /* 12107 */ + IC_EVEX_L2_W_XD_K_B, /* 12108 */ + IC_EVEX_L2_W_XD_K_B, /* 12109 */ + IC_EVEX_L2_W_XD_K_B, /* 12110 */ + IC_EVEX_L2_W_XD_K_B, /* 12111 */ + IC_EVEX_L2_OPSIZE_K_B, /* 12112 */ + IC_EVEX_L2_OPSIZE_K_B, /* 12113 */ + IC_EVEX_L2_OPSIZE_K_B, /* 12114 */ + IC_EVEX_L2_OPSIZE_K_B, /* 12115 */ + IC_EVEX_L2_OPSIZE_K_B, /* 12116 */ + IC_EVEX_L2_OPSIZE_K_B, /* 12117 */ + IC_EVEX_L2_OPSIZE_K_B, /* 12118 */ + IC_EVEX_L2_OPSIZE_K_B, /* 12119 */ + IC_EVEX_L2_W_OPSIZE_K_B, /* 12120 */ + IC_EVEX_L2_W_OPSIZE_K_B, /* 12121 */ + IC_EVEX_L2_W_OPSIZE_K_B, /* 12122 */ + IC_EVEX_L2_W_OPSIZE_K_B, /* 12123 */ + IC_EVEX_L2_W_OPSIZE_K_B, /* 12124 */ + IC_EVEX_L2_W_OPSIZE_K_B, /* 12125 */ + IC_EVEX_L2_W_OPSIZE_K_B, /* 12126 */ + IC_EVEX_L2_W_OPSIZE_K_B, /* 12127 */ + IC_EVEX_L2_K_B, /* 12128 */ + IC_EVEX_L2_K_B, /* 12129 */ + IC_EVEX_L2_XS_K_B, /* 12130 */ + IC_EVEX_L2_XS_K_B, /* 12131 */ + IC_EVEX_L2_XD_K_B, /* 12132 */ + IC_EVEX_L2_XD_K_B, /* 12133 */ + IC_EVEX_L2_XD_K_B, /* 12134 */ + IC_EVEX_L2_XD_K_B, /* 12135 */ + IC_EVEX_L2_W_K_B, /* 12136 */ + IC_EVEX_L2_W_K_B, /* 12137 */ + IC_EVEX_L2_W_XS_K_B, /* 12138 */ + IC_EVEX_L2_W_XS_K_B, /* 12139 */ + IC_EVEX_L2_W_XD_K_B, /* 12140 */ + IC_EVEX_L2_W_XD_K_B, /* 12141 */ + IC_EVEX_L2_W_XD_K_B, /* 12142 */ + IC_EVEX_L2_W_XD_K_B, /* 12143 */ + IC_EVEX_L2_OPSIZE_K_B, /* 12144 */ + IC_EVEX_L2_OPSIZE_K_B, /* 12145 */ + IC_EVEX_L2_OPSIZE_K_B, /* 12146 */ + IC_EVEX_L2_OPSIZE_K_B, /* 12147 */ + IC_EVEX_L2_OPSIZE_K_B, /* 12148 */ + IC_EVEX_L2_OPSIZE_K_B, /* 12149 */ + IC_EVEX_L2_OPSIZE_K_B, /* 12150 */ + IC_EVEX_L2_OPSIZE_K_B, /* 12151 */ + IC_EVEX_L2_W_OPSIZE_K_B, /* 12152 */ + IC_EVEX_L2_W_OPSIZE_K_B, /* 12153 */ + IC_EVEX_L2_W_OPSIZE_K_B, /* 12154 */ + IC_EVEX_L2_W_OPSIZE_K_B, /* 12155 */ + IC_EVEX_L2_W_OPSIZE_K_B, /* 12156 */ + IC_EVEX_L2_W_OPSIZE_K_B, /* 12157 */ + IC_EVEX_L2_W_OPSIZE_K_B, /* 12158 */ + IC_EVEX_L2_W_OPSIZE_K_B, /* 12159 */ + IC_EVEX_L2_K_B, /* 12160 */ + IC_EVEX_L2_K_B, /* 12161 */ + IC_EVEX_L2_XS_K_B, /* 12162 */ + IC_EVEX_L2_XS_K_B, /* 12163 */ + IC_EVEX_L2_XD_K_B, /* 12164 */ + IC_EVEX_L2_XD_K_B, /* 12165 */ + IC_EVEX_L2_XD_K_B, /* 12166 */ + IC_EVEX_L2_XD_K_B, /* 12167 */ + IC_EVEX_L2_W_K_B, /* 12168 */ + IC_EVEX_L2_W_K_B, /* 12169 */ + IC_EVEX_L2_W_XS_K_B, /* 12170 */ + IC_EVEX_L2_W_XS_K_B, /* 12171 */ + IC_EVEX_L2_W_XD_K_B, /* 12172 */ + IC_EVEX_L2_W_XD_K_B, /* 12173 */ + IC_EVEX_L2_W_XD_K_B, /* 12174 */ + IC_EVEX_L2_W_XD_K_B, /* 12175 */ + IC_EVEX_L2_OPSIZE_K_B, /* 12176 */ + IC_EVEX_L2_OPSIZE_K_B, /* 12177 */ + IC_EVEX_L2_OPSIZE_K_B, /* 12178 */ + IC_EVEX_L2_OPSIZE_K_B, /* 12179 */ + IC_EVEX_L2_OPSIZE_K_B, /* 12180 */ + IC_EVEX_L2_OPSIZE_K_B, /* 12181 */ + IC_EVEX_L2_OPSIZE_K_B, /* 12182 */ + IC_EVEX_L2_OPSIZE_K_B, /* 12183 */ + IC_EVEX_L2_W_OPSIZE_K_B, /* 12184 */ + IC_EVEX_L2_W_OPSIZE_K_B, /* 12185 */ + IC_EVEX_L2_W_OPSIZE_K_B, /* 12186 */ + IC_EVEX_L2_W_OPSIZE_K_B, /* 12187 */ + IC_EVEX_L2_W_OPSIZE_K_B, /* 12188 */ + IC_EVEX_L2_W_OPSIZE_K_B, /* 12189 */ + IC_EVEX_L2_W_OPSIZE_K_B, /* 12190 */ + IC_EVEX_L2_W_OPSIZE_K_B, /* 12191 */ + IC_EVEX_L2_K_B, /* 12192 */ + IC_EVEX_L2_K_B, /* 12193 */ + IC_EVEX_L2_XS_K_B, /* 12194 */ + IC_EVEX_L2_XS_K_B, /* 12195 */ + IC_EVEX_L2_XD_K_B, /* 12196 */ + IC_EVEX_L2_XD_K_B, /* 12197 */ + IC_EVEX_L2_XD_K_B, /* 12198 */ + IC_EVEX_L2_XD_K_B, /* 12199 */ + IC_EVEX_L2_W_K_B, /* 12200 */ + IC_EVEX_L2_W_K_B, /* 12201 */ + IC_EVEX_L2_W_XS_K_B, /* 12202 */ + IC_EVEX_L2_W_XS_K_B, /* 12203 */ + IC_EVEX_L2_W_XD_K_B, /* 12204 */ + IC_EVEX_L2_W_XD_K_B, /* 12205 */ + IC_EVEX_L2_W_XD_K_B, /* 12206 */ + IC_EVEX_L2_W_XD_K_B, /* 12207 */ + IC_EVEX_L2_OPSIZE_K_B, /* 12208 */ + IC_EVEX_L2_OPSIZE_K_B, /* 12209 */ + IC_EVEX_L2_OPSIZE_K_B, /* 12210 */ + IC_EVEX_L2_OPSIZE_K_B, /* 12211 */ + IC_EVEX_L2_OPSIZE_K_B, /* 12212 */ + IC_EVEX_L2_OPSIZE_K_B, /* 12213 */ + IC_EVEX_L2_OPSIZE_K_B, /* 12214 */ + IC_EVEX_L2_OPSIZE_K_B, /* 12215 */ + IC_EVEX_L2_W_OPSIZE_K_B, /* 12216 */ + IC_EVEX_L2_W_OPSIZE_K_B, /* 12217 */ + IC_EVEX_L2_W_OPSIZE_K_B, /* 12218 */ + IC_EVEX_L2_W_OPSIZE_K_B, /* 12219 */ + IC_EVEX_L2_W_OPSIZE_K_B, /* 12220 */ + IC_EVEX_L2_W_OPSIZE_K_B, /* 12221 */ + IC_EVEX_L2_W_OPSIZE_K_B, /* 12222 */ + IC_EVEX_L2_W_OPSIZE_K_B, /* 12223 */ + IC_EVEX_L2_K_B, /* 12224 */ + IC_EVEX_L2_K_B, /* 12225 */ + IC_EVEX_L2_XS_K_B, /* 12226 */ + IC_EVEX_L2_XS_K_B, /* 12227 */ + IC_EVEX_L2_XD_K_B, /* 12228 */ + IC_EVEX_L2_XD_K_B, /* 12229 */ + IC_EVEX_L2_XD_K_B, /* 12230 */ + IC_EVEX_L2_XD_K_B, /* 12231 */ + IC_EVEX_L2_W_K_B, /* 12232 */ + IC_EVEX_L2_W_K_B, /* 12233 */ + IC_EVEX_L2_W_XS_K_B, /* 12234 */ + IC_EVEX_L2_W_XS_K_B, /* 12235 */ + IC_EVEX_L2_W_XD_K_B, /* 12236 */ + IC_EVEX_L2_W_XD_K_B, /* 12237 */ + IC_EVEX_L2_W_XD_K_B, /* 12238 */ + IC_EVEX_L2_W_XD_K_B, /* 12239 */ + IC_EVEX_L2_OPSIZE_K_B, /* 12240 */ + IC_EVEX_L2_OPSIZE_K_B, /* 12241 */ + IC_EVEX_L2_OPSIZE_K_B, /* 12242 */ + IC_EVEX_L2_OPSIZE_K_B, /* 12243 */ + IC_EVEX_L2_OPSIZE_K_B, /* 12244 */ + IC_EVEX_L2_OPSIZE_K_B, /* 12245 */ + IC_EVEX_L2_OPSIZE_K_B, /* 12246 */ + IC_EVEX_L2_OPSIZE_K_B, /* 12247 */ + IC_EVEX_L2_W_OPSIZE_K_B, /* 12248 */ + IC_EVEX_L2_W_OPSIZE_K_B, /* 12249 */ + IC_EVEX_L2_W_OPSIZE_K_B, /* 12250 */ + IC_EVEX_L2_W_OPSIZE_K_B, /* 12251 */ + IC_EVEX_L2_W_OPSIZE_K_B, /* 12252 */ + IC_EVEX_L2_W_OPSIZE_K_B, /* 12253 */ + IC_EVEX_L2_W_OPSIZE_K_B, /* 12254 */ + IC_EVEX_L2_W_OPSIZE_K_B, /* 12255 */ + IC_EVEX_L2_K_B, /* 12256 */ + IC_EVEX_L2_K_B, /* 12257 */ + IC_EVEX_L2_XS_K_B, /* 12258 */ + IC_EVEX_L2_XS_K_B, /* 12259 */ + IC_EVEX_L2_XD_K_B, /* 12260 */ + IC_EVEX_L2_XD_K_B, /* 12261 */ + IC_EVEX_L2_XD_K_B, /* 12262 */ + IC_EVEX_L2_XD_K_B, /* 12263 */ + IC_EVEX_L2_W_K_B, /* 12264 */ + IC_EVEX_L2_W_K_B, /* 12265 */ + IC_EVEX_L2_W_XS_K_B, /* 12266 */ + IC_EVEX_L2_W_XS_K_B, /* 12267 */ + IC_EVEX_L2_W_XD_K_B, /* 12268 */ + IC_EVEX_L2_W_XD_K_B, /* 12269 */ + IC_EVEX_L2_W_XD_K_B, /* 12270 */ + IC_EVEX_L2_W_XD_K_B, /* 12271 */ + IC_EVEX_L2_OPSIZE_K_B, /* 12272 */ + IC_EVEX_L2_OPSIZE_K_B, /* 12273 */ + IC_EVEX_L2_OPSIZE_K_B, /* 12274 */ + IC_EVEX_L2_OPSIZE_K_B, /* 12275 */ + IC_EVEX_L2_OPSIZE_K_B, /* 12276 */ + IC_EVEX_L2_OPSIZE_K_B, /* 12277 */ + IC_EVEX_L2_OPSIZE_K_B, /* 12278 */ + IC_EVEX_L2_OPSIZE_K_B, /* 12279 */ + IC_EVEX_L2_W_OPSIZE_K_B, /* 12280 */ + IC_EVEX_L2_W_OPSIZE_K_B, /* 12281 */ + IC_EVEX_L2_W_OPSIZE_K_B, /* 12282 */ + IC_EVEX_L2_W_OPSIZE_K_B, /* 12283 */ + IC_EVEX_L2_W_OPSIZE_K_B, /* 12284 */ + IC_EVEX_L2_W_OPSIZE_K_B, /* 12285 */ + IC_EVEX_L2_W_OPSIZE_K_B, /* 12286 */ + IC_EVEX_L2_W_OPSIZE_K_B, /* 12287 */ + IC, /* 12288 */ + IC_64BIT, /* 12289 */ + IC_XS, /* 12290 */ + IC_64BIT_XS, /* 12291 */ + IC_XD, /* 12292 */ + IC_64BIT_XD, /* 12293 */ + IC_XS, /* 12294 */ + IC_64BIT_XS, /* 12295 */ + IC, /* 12296 */ + IC_64BIT_REXW, /* 12297 */ + IC_XS, /* 12298 */ + IC_64BIT_REXW_XS, /* 12299 */ + IC_XD, /* 12300 */ + IC_64BIT_REXW_XD, /* 12301 */ + IC_XS, /* 12302 */ + IC_64BIT_REXW_XS, /* 12303 */ + IC_OPSIZE, /* 12304 */ + IC_64BIT_OPSIZE, /* 12305 */ + IC_XS_OPSIZE, /* 12306 */ + IC_64BIT_XS_OPSIZE, /* 12307 */ + IC_XD_OPSIZE, /* 12308 */ + IC_64BIT_XD_OPSIZE, /* 12309 */ + IC_XS_OPSIZE, /* 12310 */ + IC_64BIT_XD_OPSIZE, /* 12311 */ + IC_OPSIZE, /* 12312 */ + IC_64BIT_REXW_OPSIZE, /* 12313 */ + IC_XS_OPSIZE, /* 12314 */ + IC_64BIT_REXW_XS, /* 12315 */ + IC_XD_OPSIZE, /* 12316 */ + IC_64BIT_REXW_XD, /* 12317 */ + IC_XS_OPSIZE, /* 12318 */ + IC_64BIT_REXW_XS, /* 12319 */ + IC_ADSIZE, /* 12320 */ + IC_64BIT_ADSIZE, /* 12321 */ + IC_XS_ADSIZE, /* 12322 */ + IC_64BIT_XS_ADSIZE, /* 12323 */ + IC_XD_ADSIZE, /* 12324 */ + IC_64BIT_XD_ADSIZE, /* 12325 */ + IC_XS_ADSIZE, /* 12326 */ + IC_64BIT_XD_ADSIZE, /* 12327 */ + IC_ADSIZE, /* 12328 */ + IC_64BIT_REXW_ADSIZE, /* 12329 */ + IC_XS_ADSIZE, /* 12330 */ + IC_64BIT_REXW_XS, /* 12331 */ + IC_XD_ADSIZE, /* 12332 */ + IC_64BIT_REXW_XD, /* 12333 */ + IC_XS_ADSIZE, /* 12334 */ + IC_64BIT_REXW_XS, /* 12335 */ + IC_OPSIZE_ADSIZE, /* 12336 */ + IC_64BIT_OPSIZE_ADSIZE, /* 12337 */ + IC_XS_OPSIZE, /* 12338 */ + IC_64BIT_XS_OPSIZE, /* 12339 */ + IC_XD_OPSIZE, /* 12340 */ + IC_64BIT_XD_OPSIZE, /* 12341 */ + IC_XS_OPSIZE, /* 12342 */ + IC_64BIT_XD_OPSIZE, /* 12343 */ + IC_OPSIZE_ADSIZE, /* 12344 */ + IC_64BIT_REXW_OPSIZE, /* 12345 */ + IC_XS_OPSIZE, /* 12346 */ + IC_64BIT_REXW_XS, /* 12347 */ + IC_XD_OPSIZE, /* 12348 */ + IC_64BIT_REXW_XD, /* 12349 */ + IC_XS_OPSIZE, /* 12350 */ + IC_64BIT_REXW_XS, /* 12351 */ + IC_VEX, /* 12352 */ + IC_VEX, /* 12353 */ + IC_VEX_XS, /* 12354 */ + IC_VEX_XS, /* 12355 */ + IC_VEX_XD, /* 12356 */ + IC_VEX_XD, /* 12357 */ + IC_VEX_XD, /* 12358 */ + IC_VEX_XD, /* 12359 */ + IC_VEX_W, /* 12360 */ + IC_VEX_W, /* 12361 */ + IC_VEX_W_XS, /* 12362 */ + IC_VEX_W_XS, /* 12363 */ + IC_VEX_W_XD, /* 12364 */ + IC_VEX_W_XD, /* 12365 */ + IC_VEX_W_XD, /* 12366 */ + IC_VEX_W_XD, /* 12367 */ + IC_VEX_OPSIZE, /* 12368 */ + IC_VEX_OPSIZE, /* 12369 */ + IC_VEX_OPSIZE, /* 12370 */ + IC_VEX_OPSIZE, /* 12371 */ + IC_VEX_OPSIZE, /* 12372 */ + IC_VEX_OPSIZE, /* 12373 */ + IC_VEX_OPSIZE, /* 12374 */ + IC_VEX_OPSIZE, /* 12375 */ + IC_VEX_W_OPSIZE, /* 12376 */ + IC_VEX_W_OPSIZE, /* 12377 */ + IC_VEX_W_OPSIZE, /* 12378 */ + IC_VEX_W_OPSIZE, /* 12379 */ + IC_VEX_W_OPSIZE, /* 12380 */ + IC_VEX_W_OPSIZE, /* 12381 */ + IC_VEX_W_OPSIZE, /* 12382 */ + IC_VEX_W_OPSIZE, /* 12383 */ + IC_VEX, /* 12384 */ + IC_VEX, /* 12385 */ + IC_VEX_XS, /* 12386 */ + IC_VEX_XS, /* 12387 */ + IC_VEX_XD, /* 12388 */ + IC_VEX_XD, /* 12389 */ + IC_VEX_XD, /* 12390 */ + IC_VEX_XD, /* 12391 */ + IC_VEX_W, /* 12392 */ + IC_VEX_W, /* 12393 */ + IC_VEX_W_XS, /* 12394 */ + IC_VEX_W_XS, /* 12395 */ + IC_VEX_W_XD, /* 12396 */ + IC_VEX_W_XD, /* 12397 */ + IC_VEX_W_XD, /* 12398 */ + IC_VEX_W_XD, /* 12399 */ + IC_VEX_OPSIZE, /* 12400 */ + IC_VEX_OPSIZE, /* 12401 */ + IC_VEX_OPSIZE, /* 12402 */ + IC_VEX_OPSIZE, /* 12403 */ + IC_VEX_OPSIZE, /* 12404 */ + IC_VEX_OPSIZE, /* 12405 */ + IC_VEX_OPSIZE, /* 12406 */ + IC_VEX_OPSIZE, /* 12407 */ + IC_VEX_W_OPSIZE, /* 12408 */ + IC_VEX_W_OPSIZE, /* 12409 */ + IC_VEX_W_OPSIZE, /* 12410 */ + IC_VEX_W_OPSIZE, /* 12411 */ + IC_VEX_W_OPSIZE, /* 12412 */ + IC_VEX_W_OPSIZE, /* 12413 */ + IC_VEX_W_OPSIZE, /* 12414 */ + IC_VEX_W_OPSIZE, /* 12415 */ + IC_VEX_L, /* 12416 */ + IC_VEX_L, /* 12417 */ + IC_VEX_L_XS, /* 12418 */ + IC_VEX_L_XS, /* 12419 */ + IC_VEX_L_XD, /* 12420 */ + IC_VEX_L_XD, /* 12421 */ + IC_VEX_L_XD, /* 12422 */ + IC_VEX_L_XD, /* 12423 */ + IC_VEX_L_W, /* 12424 */ + IC_VEX_L_W, /* 12425 */ + IC_VEX_L_W_XS, /* 12426 */ + IC_VEX_L_W_XS, /* 12427 */ + IC_VEX_L_W_XD, /* 12428 */ + IC_VEX_L_W_XD, /* 12429 */ + IC_VEX_L_W_XD, /* 12430 */ + IC_VEX_L_W_XD, /* 12431 */ + IC_VEX_L_OPSIZE, /* 12432 */ + IC_VEX_L_OPSIZE, /* 12433 */ + IC_VEX_L_OPSIZE, /* 12434 */ + IC_VEX_L_OPSIZE, /* 12435 */ + IC_VEX_L_OPSIZE, /* 12436 */ + IC_VEX_L_OPSIZE, /* 12437 */ + IC_VEX_L_OPSIZE, /* 12438 */ + IC_VEX_L_OPSIZE, /* 12439 */ + IC_VEX_L_W_OPSIZE, /* 12440 */ + IC_VEX_L_W_OPSIZE, /* 12441 */ + IC_VEX_L_W_OPSIZE, /* 12442 */ + IC_VEX_L_W_OPSIZE, /* 12443 */ + IC_VEX_L_W_OPSIZE, /* 12444 */ + IC_VEX_L_W_OPSIZE, /* 12445 */ + IC_VEX_L_W_OPSIZE, /* 12446 */ + IC_VEX_L_W_OPSIZE, /* 12447 */ + IC_VEX_L, /* 12448 */ + IC_VEX_L, /* 12449 */ + IC_VEX_L_XS, /* 12450 */ + IC_VEX_L_XS, /* 12451 */ + IC_VEX_L_XD, /* 12452 */ + IC_VEX_L_XD, /* 12453 */ + IC_VEX_L_XD, /* 12454 */ + IC_VEX_L_XD, /* 12455 */ + IC_VEX_L_W, /* 12456 */ + IC_VEX_L_W, /* 12457 */ + IC_VEX_L_W_XS, /* 12458 */ + IC_VEX_L_W_XS, /* 12459 */ + IC_VEX_L_W_XD, /* 12460 */ + IC_VEX_L_W_XD, /* 12461 */ + IC_VEX_L_W_XD, /* 12462 */ + IC_VEX_L_W_XD, /* 12463 */ + IC_VEX_L_OPSIZE, /* 12464 */ + IC_VEX_L_OPSIZE, /* 12465 */ + IC_VEX_L_OPSIZE, /* 12466 */ + IC_VEX_L_OPSIZE, /* 12467 */ + IC_VEX_L_OPSIZE, /* 12468 */ + IC_VEX_L_OPSIZE, /* 12469 */ + IC_VEX_L_OPSIZE, /* 12470 */ + IC_VEX_L_OPSIZE, /* 12471 */ + IC_VEX_L_W_OPSIZE, /* 12472 */ + IC_VEX_L_W_OPSIZE, /* 12473 */ + IC_VEX_L_W_OPSIZE, /* 12474 */ + IC_VEX_L_W_OPSIZE, /* 12475 */ + IC_VEX_L_W_OPSIZE, /* 12476 */ + IC_VEX_L_W_OPSIZE, /* 12477 */ + IC_VEX_L_W_OPSIZE, /* 12478 */ + IC_VEX_L_W_OPSIZE, /* 12479 */ + IC_VEX_L, /* 12480 */ + IC_VEX_L, /* 12481 */ + IC_VEX_L_XS, /* 12482 */ + IC_VEX_L_XS, /* 12483 */ + IC_VEX_L_XD, /* 12484 */ + IC_VEX_L_XD, /* 12485 */ + IC_VEX_L_XD, /* 12486 */ + IC_VEX_L_XD, /* 12487 */ + IC_VEX_L_W, /* 12488 */ + IC_VEX_L_W, /* 12489 */ + IC_VEX_L_W_XS, /* 12490 */ + IC_VEX_L_W_XS, /* 12491 */ + IC_VEX_L_W_XD, /* 12492 */ + IC_VEX_L_W_XD, /* 12493 */ + IC_VEX_L_W_XD, /* 12494 */ + IC_VEX_L_W_XD, /* 12495 */ + IC_VEX_L_OPSIZE, /* 12496 */ + IC_VEX_L_OPSIZE, /* 12497 */ + IC_VEX_L_OPSIZE, /* 12498 */ + IC_VEX_L_OPSIZE, /* 12499 */ + IC_VEX_L_OPSIZE, /* 12500 */ + IC_VEX_L_OPSIZE, /* 12501 */ + IC_VEX_L_OPSIZE, /* 12502 */ + IC_VEX_L_OPSIZE, /* 12503 */ + IC_VEX_L_W_OPSIZE, /* 12504 */ + IC_VEX_L_W_OPSIZE, /* 12505 */ + IC_VEX_L_W_OPSIZE, /* 12506 */ + IC_VEX_L_W_OPSIZE, /* 12507 */ + IC_VEX_L_W_OPSIZE, /* 12508 */ + IC_VEX_L_W_OPSIZE, /* 12509 */ + IC_VEX_L_W_OPSIZE, /* 12510 */ + IC_VEX_L_W_OPSIZE, /* 12511 */ + IC_VEX_L, /* 12512 */ + IC_VEX_L, /* 12513 */ + IC_VEX_L_XS, /* 12514 */ + IC_VEX_L_XS, /* 12515 */ + IC_VEX_L_XD, /* 12516 */ + IC_VEX_L_XD, /* 12517 */ + IC_VEX_L_XD, /* 12518 */ + IC_VEX_L_XD, /* 12519 */ + IC_VEX_L_W, /* 12520 */ + IC_VEX_L_W, /* 12521 */ + IC_VEX_L_W_XS, /* 12522 */ + IC_VEX_L_W_XS, /* 12523 */ + IC_VEX_L_W_XD, /* 12524 */ + IC_VEX_L_W_XD, /* 12525 */ + IC_VEX_L_W_XD, /* 12526 */ + IC_VEX_L_W_XD, /* 12527 */ + IC_VEX_L_OPSIZE, /* 12528 */ + IC_VEX_L_OPSIZE, /* 12529 */ + IC_VEX_L_OPSIZE, /* 12530 */ + IC_VEX_L_OPSIZE, /* 12531 */ + IC_VEX_L_OPSIZE, /* 12532 */ + IC_VEX_L_OPSIZE, /* 12533 */ + IC_VEX_L_OPSIZE, /* 12534 */ + IC_VEX_L_OPSIZE, /* 12535 */ + IC_VEX_L_W_OPSIZE, /* 12536 */ + IC_VEX_L_W_OPSIZE, /* 12537 */ + IC_VEX_L_W_OPSIZE, /* 12538 */ + IC_VEX_L_W_OPSIZE, /* 12539 */ + IC_VEX_L_W_OPSIZE, /* 12540 */ + IC_VEX_L_W_OPSIZE, /* 12541 */ + IC_VEX_L_W_OPSIZE, /* 12542 */ + IC_VEX_L_W_OPSIZE, /* 12543 */ + IC_EVEX_KZ_B, /* 12544 */ + IC_EVEX_KZ_B, /* 12545 */ + IC_EVEX_XS_KZ_B, /* 12546 */ + IC_EVEX_XS_KZ_B, /* 12547 */ + IC_EVEX_XD_KZ_B, /* 12548 */ + IC_EVEX_XD_KZ_B, /* 12549 */ + IC_EVEX_XD_KZ_B, /* 12550 */ + IC_EVEX_XD_KZ_B, /* 12551 */ + IC_EVEX_W_KZ_B, /* 12552 */ + IC_EVEX_W_KZ_B, /* 12553 */ + IC_EVEX_W_XS_KZ_B, /* 12554 */ + IC_EVEX_W_XS_KZ_B, /* 12555 */ + IC_EVEX_W_XD_KZ_B, /* 12556 */ + IC_EVEX_W_XD_KZ_B, /* 12557 */ + IC_EVEX_W_XD_KZ_B, /* 12558 */ + IC_EVEX_W_XD_KZ_B, /* 12559 */ + IC_EVEX_OPSIZE_KZ_B, /* 12560 */ + IC_EVEX_OPSIZE_KZ_B, /* 12561 */ + IC_EVEX_OPSIZE_KZ_B, /* 12562 */ + IC_EVEX_OPSIZE_KZ_B, /* 12563 */ + IC_EVEX_OPSIZE_KZ_B, /* 12564 */ + IC_EVEX_OPSIZE_KZ_B, /* 12565 */ + IC_EVEX_OPSIZE_KZ_B, /* 12566 */ + IC_EVEX_OPSIZE_KZ_B, /* 12567 */ + IC_EVEX_W_OPSIZE_KZ_B, /* 12568 */ + IC_EVEX_W_OPSIZE_KZ_B, /* 12569 */ + IC_EVEX_W_OPSIZE_KZ_B, /* 12570 */ + IC_EVEX_W_OPSIZE_KZ_B, /* 12571 */ + IC_EVEX_W_OPSIZE_KZ_B, /* 12572 */ + IC_EVEX_W_OPSIZE_KZ_B, /* 12573 */ + IC_EVEX_W_OPSIZE_KZ_B, /* 12574 */ + IC_EVEX_W_OPSIZE_KZ_B, /* 12575 */ + IC_EVEX_KZ_B, /* 12576 */ + IC_EVEX_KZ_B, /* 12577 */ + IC_EVEX_XS_KZ_B, /* 12578 */ + IC_EVEX_XS_KZ_B, /* 12579 */ + IC_EVEX_XD_KZ_B, /* 12580 */ + IC_EVEX_XD_KZ_B, /* 12581 */ + IC_EVEX_XD_KZ_B, /* 12582 */ + IC_EVEX_XD_KZ_B, /* 12583 */ + IC_EVEX_W_KZ_B, /* 12584 */ + IC_EVEX_W_KZ_B, /* 12585 */ + IC_EVEX_W_XS_KZ_B, /* 12586 */ + IC_EVEX_W_XS_KZ_B, /* 12587 */ + IC_EVEX_W_XD_KZ_B, /* 12588 */ + IC_EVEX_W_XD_KZ_B, /* 12589 */ + IC_EVEX_W_XD_KZ_B, /* 12590 */ + IC_EVEX_W_XD_KZ_B, /* 12591 */ + IC_EVEX_OPSIZE_KZ_B, /* 12592 */ + IC_EVEX_OPSIZE_KZ_B, /* 12593 */ + IC_EVEX_OPSIZE_KZ_B, /* 12594 */ + IC_EVEX_OPSIZE_KZ_B, /* 12595 */ + IC_EVEX_OPSIZE_KZ_B, /* 12596 */ + IC_EVEX_OPSIZE_KZ_B, /* 12597 */ + IC_EVEX_OPSIZE_KZ_B, /* 12598 */ + IC_EVEX_OPSIZE_KZ_B, /* 12599 */ + IC_EVEX_W_OPSIZE_KZ_B, /* 12600 */ + IC_EVEX_W_OPSIZE_KZ_B, /* 12601 */ + IC_EVEX_W_OPSIZE_KZ_B, /* 12602 */ + IC_EVEX_W_OPSIZE_KZ_B, /* 12603 */ + IC_EVEX_W_OPSIZE_KZ_B, /* 12604 */ + IC_EVEX_W_OPSIZE_KZ_B, /* 12605 */ + IC_EVEX_W_OPSIZE_KZ_B, /* 12606 */ + IC_EVEX_W_OPSIZE_KZ_B, /* 12607 */ + IC_EVEX_KZ_B, /* 12608 */ + IC_EVEX_KZ_B, /* 12609 */ + IC_EVEX_XS_KZ_B, /* 12610 */ + IC_EVEX_XS_KZ_B, /* 12611 */ + IC_EVEX_XD_KZ_B, /* 12612 */ + IC_EVEX_XD_KZ_B, /* 12613 */ + IC_EVEX_XD_KZ_B, /* 12614 */ + IC_EVEX_XD_KZ_B, /* 12615 */ + IC_EVEX_W_KZ_B, /* 12616 */ + IC_EVEX_W_KZ_B, /* 12617 */ + IC_EVEX_W_XS_KZ_B, /* 12618 */ + IC_EVEX_W_XS_KZ_B, /* 12619 */ + IC_EVEX_W_XD_KZ_B, /* 12620 */ + IC_EVEX_W_XD_KZ_B, /* 12621 */ + IC_EVEX_W_XD_KZ_B, /* 12622 */ + IC_EVEX_W_XD_KZ_B, /* 12623 */ + IC_EVEX_OPSIZE_KZ_B, /* 12624 */ + IC_EVEX_OPSIZE_KZ_B, /* 12625 */ + IC_EVEX_OPSIZE_KZ_B, /* 12626 */ + IC_EVEX_OPSIZE_KZ_B, /* 12627 */ + IC_EVEX_OPSIZE_KZ_B, /* 12628 */ + IC_EVEX_OPSIZE_KZ_B, /* 12629 */ + IC_EVEX_OPSIZE_KZ_B, /* 12630 */ + IC_EVEX_OPSIZE_KZ_B, /* 12631 */ + IC_EVEX_W_OPSIZE_KZ_B, /* 12632 */ + IC_EVEX_W_OPSIZE_KZ_B, /* 12633 */ + IC_EVEX_W_OPSIZE_KZ_B, /* 12634 */ + IC_EVEX_W_OPSIZE_KZ_B, /* 12635 */ + IC_EVEX_W_OPSIZE_KZ_B, /* 12636 */ + IC_EVEX_W_OPSIZE_KZ_B, /* 12637 */ + IC_EVEX_W_OPSIZE_KZ_B, /* 12638 */ + IC_EVEX_W_OPSIZE_KZ_B, /* 12639 */ + IC_EVEX_KZ_B, /* 12640 */ + IC_EVEX_KZ_B, /* 12641 */ + IC_EVEX_XS_KZ_B, /* 12642 */ + IC_EVEX_XS_KZ_B, /* 12643 */ + IC_EVEX_XD_KZ_B, /* 12644 */ + IC_EVEX_XD_KZ_B, /* 12645 */ + IC_EVEX_XD_KZ_B, /* 12646 */ + IC_EVEX_XD_KZ_B, /* 12647 */ + IC_EVEX_W_KZ_B, /* 12648 */ + IC_EVEX_W_KZ_B, /* 12649 */ + IC_EVEX_W_XS_KZ_B, /* 12650 */ + IC_EVEX_W_XS_KZ_B, /* 12651 */ + IC_EVEX_W_XD_KZ_B, /* 12652 */ + IC_EVEX_W_XD_KZ_B, /* 12653 */ + IC_EVEX_W_XD_KZ_B, /* 12654 */ + IC_EVEX_W_XD_KZ_B, /* 12655 */ + IC_EVEX_OPSIZE_KZ_B, /* 12656 */ + IC_EVEX_OPSIZE_KZ_B, /* 12657 */ + IC_EVEX_OPSIZE_KZ_B, /* 12658 */ + IC_EVEX_OPSIZE_KZ_B, /* 12659 */ + IC_EVEX_OPSIZE_KZ_B, /* 12660 */ + IC_EVEX_OPSIZE_KZ_B, /* 12661 */ + IC_EVEX_OPSIZE_KZ_B, /* 12662 */ + IC_EVEX_OPSIZE_KZ_B, /* 12663 */ + IC_EVEX_W_OPSIZE_KZ_B, /* 12664 */ + IC_EVEX_W_OPSIZE_KZ_B, /* 12665 */ + IC_EVEX_W_OPSIZE_KZ_B, /* 12666 */ + IC_EVEX_W_OPSIZE_KZ_B, /* 12667 */ + IC_EVEX_W_OPSIZE_KZ_B, /* 12668 */ + IC_EVEX_W_OPSIZE_KZ_B, /* 12669 */ + IC_EVEX_W_OPSIZE_KZ_B, /* 12670 */ + IC_EVEX_W_OPSIZE_KZ_B, /* 12671 */ + IC_EVEX_KZ_B, /* 12672 */ + IC_EVEX_KZ_B, /* 12673 */ + IC_EVEX_XS_KZ_B, /* 12674 */ + IC_EVEX_XS_KZ_B, /* 12675 */ + IC_EVEX_XD_KZ_B, /* 12676 */ + IC_EVEX_XD_KZ_B, /* 12677 */ + IC_EVEX_XD_KZ_B, /* 12678 */ + IC_EVEX_XD_KZ_B, /* 12679 */ + IC_EVEX_W_KZ_B, /* 12680 */ + IC_EVEX_W_KZ_B, /* 12681 */ + IC_EVEX_W_XS_KZ_B, /* 12682 */ + IC_EVEX_W_XS_KZ_B, /* 12683 */ + IC_EVEX_W_XD_KZ_B, /* 12684 */ + IC_EVEX_W_XD_KZ_B, /* 12685 */ + IC_EVEX_W_XD_KZ_B, /* 12686 */ + IC_EVEX_W_XD_KZ_B, /* 12687 */ + IC_EVEX_OPSIZE_KZ_B, /* 12688 */ + IC_EVEX_OPSIZE_KZ_B, /* 12689 */ + IC_EVEX_OPSIZE_KZ_B, /* 12690 */ + IC_EVEX_OPSIZE_KZ_B, /* 12691 */ + IC_EVEX_OPSIZE_KZ_B, /* 12692 */ + IC_EVEX_OPSIZE_KZ_B, /* 12693 */ + IC_EVEX_OPSIZE_KZ_B, /* 12694 */ + IC_EVEX_OPSIZE_KZ_B, /* 12695 */ + IC_EVEX_W_OPSIZE_KZ_B, /* 12696 */ + IC_EVEX_W_OPSIZE_KZ_B, /* 12697 */ + IC_EVEX_W_OPSIZE_KZ_B, /* 12698 */ + IC_EVEX_W_OPSIZE_KZ_B, /* 12699 */ + IC_EVEX_W_OPSIZE_KZ_B, /* 12700 */ + IC_EVEX_W_OPSIZE_KZ_B, /* 12701 */ + IC_EVEX_W_OPSIZE_KZ_B, /* 12702 */ + IC_EVEX_W_OPSIZE_KZ_B, /* 12703 */ + IC_EVEX_KZ_B, /* 12704 */ + IC_EVEX_KZ_B, /* 12705 */ + IC_EVEX_XS_KZ_B, /* 12706 */ + IC_EVEX_XS_KZ_B, /* 12707 */ + IC_EVEX_XD_KZ_B, /* 12708 */ + IC_EVEX_XD_KZ_B, /* 12709 */ + IC_EVEX_XD_KZ_B, /* 12710 */ + IC_EVEX_XD_KZ_B, /* 12711 */ + IC_EVEX_W_KZ_B, /* 12712 */ + IC_EVEX_W_KZ_B, /* 12713 */ + IC_EVEX_W_XS_KZ_B, /* 12714 */ + IC_EVEX_W_XS_KZ_B, /* 12715 */ + IC_EVEX_W_XD_KZ_B, /* 12716 */ + IC_EVEX_W_XD_KZ_B, /* 12717 */ + IC_EVEX_W_XD_KZ_B, /* 12718 */ + IC_EVEX_W_XD_KZ_B, /* 12719 */ + IC_EVEX_OPSIZE_KZ_B, /* 12720 */ + IC_EVEX_OPSIZE_KZ_B, /* 12721 */ + IC_EVEX_OPSIZE_KZ_B, /* 12722 */ + IC_EVEX_OPSIZE_KZ_B, /* 12723 */ + IC_EVEX_OPSIZE_KZ_B, /* 12724 */ + IC_EVEX_OPSIZE_KZ_B, /* 12725 */ + IC_EVEX_OPSIZE_KZ_B, /* 12726 */ + IC_EVEX_OPSIZE_KZ_B, /* 12727 */ + IC_EVEX_W_OPSIZE_KZ_B, /* 12728 */ + IC_EVEX_W_OPSIZE_KZ_B, /* 12729 */ + IC_EVEX_W_OPSIZE_KZ_B, /* 12730 */ + IC_EVEX_W_OPSIZE_KZ_B, /* 12731 */ + IC_EVEX_W_OPSIZE_KZ_B, /* 12732 */ + IC_EVEX_W_OPSIZE_KZ_B, /* 12733 */ + IC_EVEX_W_OPSIZE_KZ_B, /* 12734 */ + IC_EVEX_W_OPSIZE_KZ_B, /* 12735 */ + IC_EVEX_KZ_B, /* 12736 */ + IC_EVEX_KZ_B, /* 12737 */ + IC_EVEX_XS_KZ_B, /* 12738 */ + IC_EVEX_XS_KZ_B, /* 12739 */ + IC_EVEX_XD_KZ_B, /* 12740 */ + IC_EVEX_XD_KZ_B, /* 12741 */ + IC_EVEX_XD_KZ_B, /* 12742 */ + IC_EVEX_XD_KZ_B, /* 12743 */ + IC_EVEX_W_KZ_B, /* 12744 */ + IC_EVEX_W_KZ_B, /* 12745 */ + IC_EVEX_W_XS_KZ_B, /* 12746 */ + IC_EVEX_W_XS_KZ_B, /* 12747 */ + IC_EVEX_W_XD_KZ_B, /* 12748 */ + IC_EVEX_W_XD_KZ_B, /* 12749 */ + IC_EVEX_W_XD_KZ_B, /* 12750 */ + IC_EVEX_W_XD_KZ_B, /* 12751 */ + IC_EVEX_OPSIZE_KZ_B, /* 12752 */ + IC_EVEX_OPSIZE_KZ_B, /* 12753 */ + IC_EVEX_OPSIZE_KZ_B, /* 12754 */ + IC_EVEX_OPSIZE_KZ_B, /* 12755 */ + IC_EVEX_OPSIZE_KZ_B, /* 12756 */ + IC_EVEX_OPSIZE_KZ_B, /* 12757 */ + IC_EVEX_OPSIZE_KZ_B, /* 12758 */ + IC_EVEX_OPSIZE_KZ_B, /* 12759 */ + IC_EVEX_W_OPSIZE_KZ_B, /* 12760 */ + IC_EVEX_W_OPSIZE_KZ_B, /* 12761 */ + IC_EVEX_W_OPSIZE_KZ_B, /* 12762 */ + IC_EVEX_W_OPSIZE_KZ_B, /* 12763 */ + IC_EVEX_W_OPSIZE_KZ_B, /* 12764 */ + IC_EVEX_W_OPSIZE_KZ_B, /* 12765 */ + IC_EVEX_W_OPSIZE_KZ_B, /* 12766 */ + IC_EVEX_W_OPSIZE_KZ_B, /* 12767 */ + IC_EVEX_KZ_B, /* 12768 */ + IC_EVEX_KZ_B, /* 12769 */ + IC_EVEX_XS_KZ_B, /* 12770 */ + IC_EVEX_XS_KZ_B, /* 12771 */ + IC_EVEX_XD_KZ_B, /* 12772 */ + IC_EVEX_XD_KZ_B, /* 12773 */ + IC_EVEX_XD_KZ_B, /* 12774 */ + IC_EVEX_XD_KZ_B, /* 12775 */ + IC_EVEX_W_KZ_B, /* 12776 */ + IC_EVEX_W_KZ_B, /* 12777 */ + IC_EVEX_W_XS_KZ_B, /* 12778 */ + IC_EVEX_W_XS_KZ_B, /* 12779 */ + IC_EVEX_W_XD_KZ_B, /* 12780 */ + IC_EVEX_W_XD_KZ_B, /* 12781 */ + IC_EVEX_W_XD_KZ_B, /* 12782 */ + IC_EVEX_W_XD_KZ_B, /* 12783 */ + IC_EVEX_OPSIZE_KZ_B, /* 12784 */ + IC_EVEX_OPSIZE_KZ_B, /* 12785 */ + IC_EVEX_OPSIZE_KZ_B, /* 12786 */ + IC_EVEX_OPSIZE_KZ_B, /* 12787 */ + IC_EVEX_OPSIZE_KZ_B, /* 12788 */ + IC_EVEX_OPSIZE_KZ_B, /* 12789 */ + IC_EVEX_OPSIZE_KZ_B, /* 12790 */ + IC_EVEX_OPSIZE_KZ_B, /* 12791 */ + IC_EVEX_W_OPSIZE_KZ_B, /* 12792 */ + IC_EVEX_W_OPSIZE_KZ_B, /* 12793 */ + IC_EVEX_W_OPSIZE_KZ_B, /* 12794 */ + IC_EVEX_W_OPSIZE_KZ_B, /* 12795 */ + IC_EVEX_W_OPSIZE_KZ_B, /* 12796 */ + IC_EVEX_W_OPSIZE_KZ_B, /* 12797 */ + IC_EVEX_W_OPSIZE_KZ_B, /* 12798 */ + IC_EVEX_W_OPSIZE_KZ_B, /* 12799 */ + IC, /* 12800 */ + IC_64BIT, /* 12801 */ + IC_XS, /* 12802 */ + IC_64BIT_XS, /* 12803 */ + IC_XD, /* 12804 */ + IC_64BIT_XD, /* 12805 */ + IC_XS, /* 12806 */ + IC_64BIT_XS, /* 12807 */ + IC, /* 12808 */ + IC_64BIT_REXW, /* 12809 */ + IC_XS, /* 12810 */ + IC_64BIT_REXW_XS, /* 12811 */ + IC_XD, /* 12812 */ + IC_64BIT_REXW_XD, /* 12813 */ + IC_XS, /* 12814 */ + IC_64BIT_REXW_XS, /* 12815 */ + IC_OPSIZE, /* 12816 */ + IC_64BIT_OPSIZE, /* 12817 */ + IC_XS_OPSIZE, /* 12818 */ + IC_64BIT_XS_OPSIZE, /* 12819 */ + IC_XD_OPSIZE, /* 12820 */ + IC_64BIT_XD_OPSIZE, /* 12821 */ + IC_XS_OPSIZE, /* 12822 */ + IC_64BIT_XD_OPSIZE, /* 12823 */ + IC_OPSIZE, /* 12824 */ + IC_64BIT_REXW_OPSIZE, /* 12825 */ + IC_XS_OPSIZE, /* 12826 */ + IC_64BIT_REXW_XS, /* 12827 */ + IC_XD_OPSIZE, /* 12828 */ + IC_64BIT_REXW_XD, /* 12829 */ + IC_XS_OPSIZE, /* 12830 */ + IC_64BIT_REXW_XS, /* 12831 */ + IC_ADSIZE, /* 12832 */ + IC_64BIT_ADSIZE, /* 12833 */ + IC_XS_ADSIZE, /* 12834 */ + IC_64BIT_XS_ADSIZE, /* 12835 */ + IC_XD_ADSIZE, /* 12836 */ + IC_64BIT_XD_ADSIZE, /* 12837 */ + IC_XS_ADSIZE, /* 12838 */ + IC_64BIT_XD_ADSIZE, /* 12839 */ + IC_ADSIZE, /* 12840 */ + IC_64BIT_REXW_ADSIZE, /* 12841 */ + IC_XS_ADSIZE, /* 12842 */ + IC_64BIT_REXW_XS, /* 12843 */ + IC_XD_ADSIZE, /* 12844 */ + IC_64BIT_REXW_XD, /* 12845 */ + IC_XS_ADSIZE, /* 12846 */ + IC_64BIT_REXW_XS, /* 12847 */ + IC_OPSIZE_ADSIZE, /* 12848 */ + IC_64BIT_OPSIZE_ADSIZE, /* 12849 */ + IC_XS_OPSIZE, /* 12850 */ + IC_64BIT_XS_OPSIZE, /* 12851 */ + IC_XD_OPSIZE, /* 12852 */ + IC_64BIT_XD_OPSIZE, /* 12853 */ + IC_XS_OPSIZE, /* 12854 */ + IC_64BIT_XD_OPSIZE, /* 12855 */ + IC_OPSIZE_ADSIZE, /* 12856 */ + IC_64BIT_REXW_OPSIZE, /* 12857 */ + IC_XS_OPSIZE, /* 12858 */ + IC_64BIT_REXW_XS, /* 12859 */ + IC_XD_OPSIZE, /* 12860 */ + IC_64BIT_REXW_XD, /* 12861 */ + IC_XS_OPSIZE, /* 12862 */ + IC_64BIT_REXW_XS, /* 12863 */ + IC_VEX, /* 12864 */ + IC_VEX, /* 12865 */ + IC_VEX_XS, /* 12866 */ + IC_VEX_XS, /* 12867 */ + IC_VEX_XD, /* 12868 */ + IC_VEX_XD, /* 12869 */ + IC_VEX_XD, /* 12870 */ + IC_VEX_XD, /* 12871 */ + IC_VEX_W, /* 12872 */ + IC_VEX_W, /* 12873 */ + IC_VEX_W_XS, /* 12874 */ + IC_VEX_W_XS, /* 12875 */ + IC_VEX_W_XD, /* 12876 */ + IC_VEX_W_XD, /* 12877 */ + IC_VEX_W_XD, /* 12878 */ + IC_VEX_W_XD, /* 12879 */ + IC_VEX_OPSIZE, /* 12880 */ + IC_VEX_OPSIZE, /* 12881 */ + IC_VEX_OPSIZE, /* 12882 */ + IC_VEX_OPSIZE, /* 12883 */ + IC_VEX_OPSIZE, /* 12884 */ + IC_VEX_OPSIZE, /* 12885 */ + IC_VEX_OPSIZE, /* 12886 */ + IC_VEX_OPSIZE, /* 12887 */ + IC_VEX_W_OPSIZE, /* 12888 */ + IC_VEX_W_OPSIZE, /* 12889 */ + IC_VEX_W_OPSIZE, /* 12890 */ + IC_VEX_W_OPSIZE, /* 12891 */ + IC_VEX_W_OPSIZE, /* 12892 */ + IC_VEX_W_OPSIZE, /* 12893 */ + IC_VEX_W_OPSIZE, /* 12894 */ + IC_VEX_W_OPSIZE, /* 12895 */ + IC_VEX, /* 12896 */ + IC_VEX, /* 12897 */ + IC_VEX_XS, /* 12898 */ + IC_VEX_XS, /* 12899 */ + IC_VEX_XD, /* 12900 */ + IC_VEX_XD, /* 12901 */ + IC_VEX_XD, /* 12902 */ + IC_VEX_XD, /* 12903 */ + IC_VEX_W, /* 12904 */ + IC_VEX_W, /* 12905 */ + IC_VEX_W_XS, /* 12906 */ + IC_VEX_W_XS, /* 12907 */ + IC_VEX_W_XD, /* 12908 */ + IC_VEX_W_XD, /* 12909 */ + IC_VEX_W_XD, /* 12910 */ + IC_VEX_W_XD, /* 12911 */ + IC_VEX_OPSIZE, /* 12912 */ + IC_VEX_OPSIZE, /* 12913 */ + IC_VEX_OPSIZE, /* 12914 */ + IC_VEX_OPSIZE, /* 12915 */ + IC_VEX_OPSIZE, /* 12916 */ + IC_VEX_OPSIZE, /* 12917 */ + IC_VEX_OPSIZE, /* 12918 */ + IC_VEX_OPSIZE, /* 12919 */ + IC_VEX_W_OPSIZE, /* 12920 */ + IC_VEX_W_OPSIZE, /* 12921 */ + IC_VEX_W_OPSIZE, /* 12922 */ + IC_VEX_W_OPSIZE, /* 12923 */ + IC_VEX_W_OPSIZE, /* 12924 */ + IC_VEX_W_OPSIZE, /* 12925 */ + IC_VEX_W_OPSIZE, /* 12926 */ + IC_VEX_W_OPSIZE, /* 12927 */ + IC_VEX_L, /* 12928 */ + IC_VEX_L, /* 12929 */ + IC_VEX_L_XS, /* 12930 */ + IC_VEX_L_XS, /* 12931 */ + IC_VEX_L_XD, /* 12932 */ + IC_VEX_L_XD, /* 12933 */ + IC_VEX_L_XD, /* 12934 */ + IC_VEX_L_XD, /* 12935 */ + IC_VEX_L_W, /* 12936 */ + IC_VEX_L_W, /* 12937 */ + IC_VEX_L_W_XS, /* 12938 */ + IC_VEX_L_W_XS, /* 12939 */ + IC_VEX_L_W_XD, /* 12940 */ + IC_VEX_L_W_XD, /* 12941 */ + IC_VEX_L_W_XD, /* 12942 */ + IC_VEX_L_W_XD, /* 12943 */ + IC_VEX_L_OPSIZE, /* 12944 */ + IC_VEX_L_OPSIZE, /* 12945 */ + IC_VEX_L_OPSIZE, /* 12946 */ + IC_VEX_L_OPSIZE, /* 12947 */ + IC_VEX_L_OPSIZE, /* 12948 */ + IC_VEX_L_OPSIZE, /* 12949 */ + IC_VEX_L_OPSIZE, /* 12950 */ + IC_VEX_L_OPSIZE, /* 12951 */ + IC_VEX_L_W_OPSIZE, /* 12952 */ + IC_VEX_L_W_OPSIZE, /* 12953 */ + IC_VEX_L_W_OPSIZE, /* 12954 */ + IC_VEX_L_W_OPSIZE, /* 12955 */ + IC_VEX_L_W_OPSIZE, /* 12956 */ + IC_VEX_L_W_OPSIZE, /* 12957 */ + IC_VEX_L_W_OPSIZE, /* 12958 */ + IC_VEX_L_W_OPSIZE, /* 12959 */ + IC_VEX_L, /* 12960 */ + IC_VEX_L, /* 12961 */ + IC_VEX_L_XS, /* 12962 */ + IC_VEX_L_XS, /* 12963 */ + IC_VEX_L_XD, /* 12964 */ + IC_VEX_L_XD, /* 12965 */ + IC_VEX_L_XD, /* 12966 */ + IC_VEX_L_XD, /* 12967 */ + IC_VEX_L_W, /* 12968 */ + IC_VEX_L_W, /* 12969 */ + IC_VEX_L_W_XS, /* 12970 */ + IC_VEX_L_W_XS, /* 12971 */ + IC_VEX_L_W_XD, /* 12972 */ + IC_VEX_L_W_XD, /* 12973 */ + IC_VEX_L_W_XD, /* 12974 */ + IC_VEX_L_W_XD, /* 12975 */ + IC_VEX_L_OPSIZE, /* 12976 */ + IC_VEX_L_OPSIZE, /* 12977 */ + IC_VEX_L_OPSIZE, /* 12978 */ + IC_VEX_L_OPSIZE, /* 12979 */ + IC_VEX_L_OPSIZE, /* 12980 */ + IC_VEX_L_OPSIZE, /* 12981 */ + IC_VEX_L_OPSIZE, /* 12982 */ + IC_VEX_L_OPSIZE, /* 12983 */ + IC_VEX_L_W_OPSIZE, /* 12984 */ + IC_VEX_L_W_OPSIZE, /* 12985 */ + IC_VEX_L_W_OPSIZE, /* 12986 */ + IC_VEX_L_W_OPSIZE, /* 12987 */ + IC_VEX_L_W_OPSIZE, /* 12988 */ + IC_VEX_L_W_OPSIZE, /* 12989 */ + IC_VEX_L_W_OPSIZE, /* 12990 */ + IC_VEX_L_W_OPSIZE, /* 12991 */ + IC_VEX_L, /* 12992 */ + IC_VEX_L, /* 12993 */ + IC_VEX_L_XS, /* 12994 */ + IC_VEX_L_XS, /* 12995 */ + IC_VEX_L_XD, /* 12996 */ + IC_VEX_L_XD, /* 12997 */ + IC_VEX_L_XD, /* 12998 */ + IC_VEX_L_XD, /* 12999 */ + IC_VEX_L_W, /* 13000 */ + IC_VEX_L_W, /* 13001 */ + IC_VEX_L_W_XS, /* 13002 */ + IC_VEX_L_W_XS, /* 13003 */ + IC_VEX_L_W_XD, /* 13004 */ + IC_VEX_L_W_XD, /* 13005 */ + IC_VEX_L_W_XD, /* 13006 */ + IC_VEX_L_W_XD, /* 13007 */ + IC_VEX_L_OPSIZE, /* 13008 */ + IC_VEX_L_OPSIZE, /* 13009 */ + IC_VEX_L_OPSIZE, /* 13010 */ + IC_VEX_L_OPSIZE, /* 13011 */ + IC_VEX_L_OPSIZE, /* 13012 */ + IC_VEX_L_OPSIZE, /* 13013 */ + IC_VEX_L_OPSIZE, /* 13014 */ + IC_VEX_L_OPSIZE, /* 13015 */ + IC_VEX_L_W_OPSIZE, /* 13016 */ + IC_VEX_L_W_OPSIZE, /* 13017 */ + IC_VEX_L_W_OPSIZE, /* 13018 */ + IC_VEX_L_W_OPSIZE, /* 13019 */ + IC_VEX_L_W_OPSIZE, /* 13020 */ + IC_VEX_L_W_OPSIZE, /* 13021 */ + IC_VEX_L_W_OPSIZE, /* 13022 */ + IC_VEX_L_W_OPSIZE, /* 13023 */ + IC_VEX_L, /* 13024 */ + IC_VEX_L, /* 13025 */ + IC_VEX_L_XS, /* 13026 */ + IC_VEX_L_XS, /* 13027 */ + IC_VEX_L_XD, /* 13028 */ + IC_VEX_L_XD, /* 13029 */ + IC_VEX_L_XD, /* 13030 */ + IC_VEX_L_XD, /* 13031 */ + IC_VEX_L_W, /* 13032 */ + IC_VEX_L_W, /* 13033 */ + IC_VEX_L_W_XS, /* 13034 */ + IC_VEX_L_W_XS, /* 13035 */ + IC_VEX_L_W_XD, /* 13036 */ + IC_VEX_L_W_XD, /* 13037 */ + IC_VEX_L_W_XD, /* 13038 */ + IC_VEX_L_W_XD, /* 13039 */ + IC_VEX_L_OPSIZE, /* 13040 */ + IC_VEX_L_OPSIZE, /* 13041 */ + IC_VEX_L_OPSIZE, /* 13042 */ + IC_VEX_L_OPSIZE, /* 13043 */ + IC_VEX_L_OPSIZE, /* 13044 */ + IC_VEX_L_OPSIZE, /* 13045 */ + IC_VEX_L_OPSIZE, /* 13046 */ + IC_VEX_L_OPSIZE, /* 13047 */ + IC_VEX_L_W_OPSIZE, /* 13048 */ + IC_VEX_L_W_OPSIZE, /* 13049 */ + IC_VEX_L_W_OPSIZE, /* 13050 */ + IC_VEX_L_W_OPSIZE, /* 13051 */ + IC_VEX_L_W_OPSIZE, /* 13052 */ + IC_VEX_L_W_OPSIZE, /* 13053 */ + IC_VEX_L_W_OPSIZE, /* 13054 */ + IC_VEX_L_W_OPSIZE, /* 13055 */ + IC_EVEX_L_KZ_B, /* 13056 */ + IC_EVEX_L_KZ_B, /* 13057 */ + IC_EVEX_L_XS_KZ_B, /* 13058 */ + IC_EVEX_L_XS_KZ_B, /* 13059 */ + IC_EVEX_L_XD_KZ_B, /* 13060 */ + IC_EVEX_L_XD_KZ_B, /* 13061 */ + IC_EVEX_L_XD_KZ_B, /* 13062 */ + IC_EVEX_L_XD_KZ_B, /* 13063 */ + IC_EVEX_L_W_KZ_B, /* 13064 */ + IC_EVEX_L_W_KZ_B, /* 13065 */ + IC_EVEX_L_W_XS_KZ_B, /* 13066 */ + IC_EVEX_L_W_XS_KZ_B, /* 13067 */ + IC_EVEX_L_W_XD_KZ_B, /* 13068 */ + IC_EVEX_L_W_XD_KZ_B, /* 13069 */ + IC_EVEX_L_W_XD_KZ_B, /* 13070 */ + IC_EVEX_L_W_XD_KZ_B, /* 13071 */ + IC_EVEX_L_OPSIZE_KZ_B, /* 13072 */ + IC_EVEX_L_OPSIZE_KZ_B, /* 13073 */ + IC_EVEX_L_OPSIZE_KZ_B, /* 13074 */ + IC_EVEX_L_OPSIZE_KZ_B, /* 13075 */ + IC_EVEX_L_OPSIZE_KZ_B, /* 13076 */ + IC_EVEX_L_OPSIZE_KZ_B, /* 13077 */ + IC_EVEX_L_OPSIZE_KZ_B, /* 13078 */ + IC_EVEX_L_OPSIZE_KZ_B, /* 13079 */ + IC_EVEX_L_W_OPSIZE_KZ_B, /* 13080 */ + IC_EVEX_L_W_OPSIZE_KZ_B, /* 13081 */ + IC_EVEX_L_W_OPSIZE_KZ_B, /* 13082 */ + IC_EVEX_L_W_OPSIZE_KZ_B, /* 13083 */ + IC_EVEX_L_W_OPSIZE_KZ_B, /* 13084 */ + IC_EVEX_L_W_OPSIZE_KZ_B, /* 13085 */ + IC_EVEX_L_W_OPSIZE_KZ_B, /* 13086 */ + IC_EVEX_L_W_OPSIZE_KZ_B, /* 13087 */ + IC_EVEX_L_KZ_B, /* 13088 */ + IC_EVEX_L_KZ_B, /* 13089 */ + IC_EVEX_L_XS_KZ_B, /* 13090 */ + IC_EVEX_L_XS_KZ_B, /* 13091 */ + IC_EVEX_L_XD_KZ_B, /* 13092 */ + IC_EVEX_L_XD_KZ_B, /* 13093 */ + IC_EVEX_L_XD_KZ_B, /* 13094 */ + IC_EVEX_L_XD_KZ_B, /* 13095 */ + IC_EVEX_L_W_KZ_B, /* 13096 */ + IC_EVEX_L_W_KZ_B, /* 13097 */ + IC_EVEX_L_W_XS_KZ_B, /* 13098 */ + IC_EVEX_L_W_XS_KZ_B, /* 13099 */ + IC_EVEX_L_W_XD_KZ_B, /* 13100 */ + IC_EVEX_L_W_XD_KZ_B, /* 13101 */ + IC_EVEX_L_W_XD_KZ_B, /* 13102 */ + IC_EVEX_L_W_XD_KZ_B, /* 13103 */ + IC_EVEX_L_OPSIZE_KZ_B, /* 13104 */ + IC_EVEX_L_OPSIZE_KZ_B, /* 13105 */ + IC_EVEX_L_OPSIZE_KZ_B, /* 13106 */ + IC_EVEX_L_OPSIZE_KZ_B, /* 13107 */ + IC_EVEX_L_OPSIZE_KZ_B, /* 13108 */ + IC_EVEX_L_OPSIZE_KZ_B, /* 13109 */ + IC_EVEX_L_OPSIZE_KZ_B, /* 13110 */ + IC_EVEX_L_OPSIZE_KZ_B, /* 13111 */ + IC_EVEX_L_W_OPSIZE_KZ_B, /* 13112 */ + IC_EVEX_L_W_OPSIZE_KZ_B, /* 13113 */ + IC_EVEX_L_W_OPSIZE_KZ_B, /* 13114 */ + IC_EVEX_L_W_OPSIZE_KZ_B, /* 13115 */ + IC_EVEX_L_W_OPSIZE_KZ_B, /* 13116 */ + IC_EVEX_L_W_OPSIZE_KZ_B, /* 13117 */ + IC_EVEX_L_W_OPSIZE_KZ_B, /* 13118 */ + IC_EVEX_L_W_OPSIZE_KZ_B, /* 13119 */ + IC_EVEX_L_KZ_B, /* 13120 */ + IC_EVEX_L_KZ_B, /* 13121 */ + IC_EVEX_L_XS_KZ_B, /* 13122 */ + IC_EVEX_L_XS_KZ_B, /* 13123 */ + IC_EVEX_L_XD_KZ_B, /* 13124 */ + IC_EVEX_L_XD_KZ_B, /* 13125 */ + IC_EVEX_L_XD_KZ_B, /* 13126 */ + IC_EVEX_L_XD_KZ_B, /* 13127 */ + IC_EVEX_L_W_KZ_B, /* 13128 */ + IC_EVEX_L_W_KZ_B, /* 13129 */ + IC_EVEX_L_W_XS_KZ_B, /* 13130 */ + IC_EVEX_L_W_XS_KZ_B, /* 13131 */ + IC_EVEX_L_W_XD_KZ_B, /* 13132 */ + IC_EVEX_L_W_XD_KZ_B, /* 13133 */ + IC_EVEX_L_W_XD_KZ_B, /* 13134 */ + IC_EVEX_L_W_XD_KZ_B, /* 13135 */ + IC_EVEX_L_OPSIZE_KZ_B, /* 13136 */ + IC_EVEX_L_OPSIZE_KZ_B, /* 13137 */ + IC_EVEX_L_OPSIZE_KZ_B, /* 13138 */ + IC_EVEX_L_OPSIZE_KZ_B, /* 13139 */ + IC_EVEX_L_OPSIZE_KZ_B, /* 13140 */ + IC_EVEX_L_OPSIZE_KZ_B, /* 13141 */ + IC_EVEX_L_OPSIZE_KZ_B, /* 13142 */ + IC_EVEX_L_OPSIZE_KZ_B, /* 13143 */ + IC_EVEX_L_W_OPSIZE_KZ_B, /* 13144 */ + IC_EVEX_L_W_OPSIZE_KZ_B, /* 13145 */ + IC_EVEX_L_W_OPSIZE_KZ_B, /* 13146 */ + IC_EVEX_L_W_OPSIZE_KZ_B, /* 13147 */ + IC_EVEX_L_W_OPSIZE_KZ_B, /* 13148 */ + IC_EVEX_L_W_OPSIZE_KZ_B, /* 13149 */ + IC_EVEX_L_W_OPSIZE_KZ_B, /* 13150 */ + IC_EVEX_L_W_OPSIZE_KZ_B, /* 13151 */ + IC_EVEX_L_KZ_B, /* 13152 */ + IC_EVEX_L_KZ_B, /* 13153 */ + IC_EVEX_L_XS_KZ_B, /* 13154 */ + IC_EVEX_L_XS_KZ_B, /* 13155 */ + IC_EVEX_L_XD_KZ_B, /* 13156 */ + IC_EVEX_L_XD_KZ_B, /* 13157 */ + IC_EVEX_L_XD_KZ_B, /* 13158 */ + IC_EVEX_L_XD_KZ_B, /* 13159 */ + IC_EVEX_L_W_KZ_B, /* 13160 */ + IC_EVEX_L_W_KZ_B, /* 13161 */ + IC_EVEX_L_W_XS_KZ_B, /* 13162 */ + IC_EVEX_L_W_XS_KZ_B, /* 13163 */ + IC_EVEX_L_W_XD_KZ_B, /* 13164 */ + IC_EVEX_L_W_XD_KZ_B, /* 13165 */ + IC_EVEX_L_W_XD_KZ_B, /* 13166 */ + IC_EVEX_L_W_XD_KZ_B, /* 13167 */ + IC_EVEX_L_OPSIZE_KZ_B, /* 13168 */ + IC_EVEX_L_OPSIZE_KZ_B, /* 13169 */ + IC_EVEX_L_OPSIZE_KZ_B, /* 13170 */ + IC_EVEX_L_OPSIZE_KZ_B, /* 13171 */ + IC_EVEX_L_OPSIZE_KZ_B, /* 13172 */ + IC_EVEX_L_OPSIZE_KZ_B, /* 13173 */ + IC_EVEX_L_OPSIZE_KZ_B, /* 13174 */ + IC_EVEX_L_OPSIZE_KZ_B, /* 13175 */ + IC_EVEX_L_W_OPSIZE_KZ_B, /* 13176 */ + IC_EVEX_L_W_OPSIZE_KZ_B, /* 13177 */ + IC_EVEX_L_W_OPSIZE_KZ_B, /* 13178 */ + IC_EVEX_L_W_OPSIZE_KZ_B, /* 13179 */ + IC_EVEX_L_W_OPSIZE_KZ_B, /* 13180 */ + IC_EVEX_L_W_OPSIZE_KZ_B, /* 13181 */ + IC_EVEX_L_W_OPSIZE_KZ_B, /* 13182 */ + IC_EVEX_L_W_OPSIZE_KZ_B, /* 13183 */ + IC_EVEX_L_KZ_B, /* 13184 */ + IC_EVEX_L_KZ_B, /* 13185 */ + IC_EVEX_L_XS_KZ_B, /* 13186 */ + IC_EVEX_L_XS_KZ_B, /* 13187 */ + IC_EVEX_L_XD_KZ_B, /* 13188 */ + IC_EVEX_L_XD_KZ_B, /* 13189 */ + IC_EVEX_L_XD_KZ_B, /* 13190 */ + IC_EVEX_L_XD_KZ_B, /* 13191 */ + IC_EVEX_L_W_KZ_B, /* 13192 */ + IC_EVEX_L_W_KZ_B, /* 13193 */ + IC_EVEX_L_W_XS_KZ_B, /* 13194 */ + IC_EVEX_L_W_XS_KZ_B, /* 13195 */ + IC_EVEX_L_W_XD_KZ_B, /* 13196 */ + IC_EVEX_L_W_XD_KZ_B, /* 13197 */ + IC_EVEX_L_W_XD_KZ_B, /* 13198 */ + IC_EVEX_L_W_XD_KZ_B, /* 13199 */ + IC_EVEX_L_OPSIZE_KZ_B, /* 13200 */ + IC_EVEX_L_OPSIZE_KZ_B, /* 13201 */ + IC_EVEX_L_OPSIZE_KZ_B, /* 13202 */ + IC_EVEX_L_OPSIZE_KZ_B, /* 13203 */ + IC_EVEX_L_OPSIZE_KZ_B, /* 13204 */ + IC_EVEX_L_OPSIZE_KZ_B, /* 13205 */ + IC_EVEX_L_OPSIZE_KZ_B, /* 13206 */ + IC_EVEX_L_OPSIZE_KZ_B, /* 13207 */ + IC_EVEX_L_W_OPSIZE_KZ_B, /* 13208 */ + IC_EVEX_L_W_OPSIZE_KZ_B, /* 13209 */ + IC_EVEX_L_W_OPSIZE_KZ_B, /* 13210 */ + IC_EVEX_L_W_OPSIZE_KZ_B, /* 13211 */ + IC_EVEX_L_W_OPSIZE_KZ_B, /* 13212 */ + IC_EVEX_L_W_OPSIZE_KZ_B, /* 13213 */ + IC_EVEX_L_W_OPSIZE_KZ_B, /* 13214 */ + IC_EVEX_L_W_OPSIZE_KZ_B, /* 13215 */ + IC_EVEX_L_KZ_B, /* 13216 */ + IC_EVEX_L_KZ_B, /* 13217 */ + IC_EVEX_L_XS_KZ_B, /* 13218 */ + IC_EVEX_L_XS_KZ_B, /* 13219 */ + IC_EVEX_L_XD_KZ_B, /* 13220 */ + IC_EVEX_L_XD_KZ_B, /* 13221 */ + IC_EVEX_L_XD_KZ_B, /* 13222 */ + IC_EVEX_L_XD_KZ_B, /* 13223 */ + IC_EVEX_L_W_KZ_B, /* 13224 */ + IC_EVEX_L_W_KZ_B, /* 13225 */ + IC_EVEX_L_W_XS_KZ_B, /* 13226 */ + IC_EVEX_L_W_XS_KZ_B, /* 13227 */ + IC_EVEX_L_W_XD_KZ_B, /* 13228 */ + IC_EVEX_L_W_XD_KZ_B, /* 13229 */ + IC_EVEX_L_W_XD_KZ_B, /* 13230 */ + IC_EVEX_L_W_XD_KZ_B, /* 13231 */ + IC_EVEX_L_OPSIZE_KZ_B, /* 13232 */ + IC_EVEX_L_OPSIZE_KZ_B, /* 13233 */ + IC_EVEX_L_OPSIZE_KZ_B, /* 13234 */ + IC_EVEX_L_OPSIZE_KZ_B, /* 13235 */ + IC_EVEX_L_OPSIZE_KZ_B, /* 13236 */ + IC_EVEX_L_OPSIZE_KZ_B, /* 13237 */ + IC_EVEX_L_OPSIZE_KZ_B, /* 13238 */ + IC_EVEX_L_OPSIZE_KZ_B, /* 13239 */ + IC_EVEX_L_W_OPSIZE_KZ_B, /* 13240 */ + IC_EVEX_L_W_OPSIZE_KZ_B, /* 13241 */ + IC_EVEX_L_W_OPSIZE_KZ_B, /* 13242 */ + IC_EVEX_L_W_OPSIZE_KZ_B, /* 13243 */ + IC_EVEX_L_W_OPSIZE_KZ_B, /* 13244 */ + IC_EVEX_L_W_OPSIZE_KZ_B, /* 13245 */ + IC_EVEX_L_W_OPSIZE_KZ_B, /* 13246 */ + IC_EVEX_L_W_OPSIZE_KZ_B, /* 13247 */ + IC_EVEX_L_KZ_B, /* 13248 */ + IC_EVEX_L_KZ_B, /* 13249 */ + IC_EVEX_L_XS_KZ_B, /* 13250 */ + IC_EVEX_L_XS_KZ_B, /* 13251 */ + IC_EVEX_L_XD_KZ_B, /* 13252 */ + IC_EVEX_L_XD_KZ_B, /* 13253 */ + IC_EVEX_L_XD_KZ_B, /* 13254 */ + IC_EVEX_L_XD_KZ_B, /* 13255 */ + IC_EVEX_L_W_KZ_B, /* 13256 */ + IC_EVEX_L_W_KZ_B, /* 13257 */ + IC_EVEX_L_W_XS_KZ_B, /* 13258 */ + IC_EVEX_L_W_XS_KZ_B, /* 13259 */ + IC_EVEX_L_W_XD_KZ_B, /* 13260 */ + IC_EVEX_L_W_XD_KZ_B, /* 13261 */ + IC_EVEX_L_W_XD_KZ_B, /* 13262 */ + IC_EVEX_L_W_XD_KZ_B, /* 13263 */ + IC_EVEX_L_OPSIZE_KZ_B, /* 13264 */ + IC_EVEX_L_OPSIZE_KZ_B, /* 13265 */ + IC_EVEX_L_OPSIZE_KZ_B, /* 13266 */ + IC_EVEX_L_OPSIZE_KZ_B, /* 13267 */ + IC_EVEX_L_OPSIZE_KZ_B, /* 13268 */ + IC_EVEX_L_OPSIZE_KZ_B, /* 13269 */ + IC_EVEX_L_OPSIZE_KZ_B, /* 13270 */ + IC_EVEX_L_OPSIZE_KZ_B, /* 13271 */ + IC_EVEX_L_W_OPSIZE_KZ_B, /* 13272 */ + IC_EVEX_L_W_OPSIZE_KZ_B, /* 13273 */ + IC_EVEX_L_W_OPSIZE_KZ_B, /* 13274 */ + IC_EVEX_L_W_OPSIZE_KZ_B, /* 13275 */ + IC_EVEX_L_W_OPSIZE_KZ_B, /* 13276 */ + IC_EVEX_L_W_OPSIZE_KZ_B, /* 13277 */ + IC_EVEX_L_W_OPSIZE_KZ_B, /* 13278 */ + IC_EVEX_L_W_OPSIZE_KZ_B, /* 13279 */ + IC_EVEX_L_KZ_B, /* 13280 */ + IC_EVEX_L_KZ_B, /* 13281 */ + IC_EVEX_L_XS_KZ_B, /* 13282 */ + IC_EVEX_L_XS_KZ_B, /* 13283 */ + IC_EVEX_L_XD_KZ_B, /* 13284 */ + IC_EVEX_L_XD_KZ_B, /* 13285 */ + IC_EVEX_L_XD_KZ_B, /* 13286 */ + IC_EVEX_L_XD_KZ_B, /* 13287 */ + IC_EVEX_L_W_KZ_B, /* 13288 */ + IC_EVEX_L_W_KZ_B, /* 13289 */ + IC_EVEX_L_W_XS_KZ_B, /* 13290 */ + IC_EVEX_L_W_XS_KZ_B, /* 13291 */ + IC_EVEX_L_W_XD_KZ_B, /* 13292 */ + IC_EVEX_L_W_XD_KZ_B, /* 13293 */ + IC_EVEX_L_W_XD_KZ_B, /* 13294 */ + IC_EVEX_L_W_XD_KZ_B, /* 13295 */ + IC_EVEX_L_OPSIZE_KZ_B, /* 13296 */ + IC_EVEX_L_OPSIZE_KZ_B, /* 13297 */ + IC_EVEX_L_OPSIZE_KZ_B, /* 13298 */ + IC_EVEX_L_OPSIZE_KZ_B, /* 13299 */ + IC_EVEX_L_OPSIZE_KZ_B, /* 13300 */ + IC_EVEX_L_OPSIZE_KZ_B, /* 13301 */ + IC_EVEX_L_OPSIZE_KZ_B, /* 13302 */ + IC_EVEX_L_OPSIZE_KZ_B, /* 13303 */ + IC_EVEX_L_W_OPSIZE_KZ_B, /* 13304 */ + IC_EVEX_L_W_OPSIZE_KZ_B, /* 13305 */ + IC_EVEX_L_W_OPSIZE_KZ_B, /* 13306 */ + IC_EVEX_L_W_OPSIZE_KZ_B, /* 13307 */ + IC_EVEX_L_W_OPSIZE_KZ_B, /* 13308 */ + IC_EVEX_L_W_OPSIZE_KZ_B, /* 13309 */ + IC_EVEX_L_W_OPSIZE_KZ_B, /* 13310 */ + IC_EVEX_L_W_OPSIZE_KZ_B, /* 13311 */ + IC, /* 13312 */ + IC_64BIT, /* 13313 */ + IC_XS, /* 13314 */ + IC_64BIT_XS, /* 13315 */ + IC_XD, /* 13316 */ + IC_64BIT_XD, /* 13317 */ + IC_XS, /* 13318 */ + IC_64BIT_XS, /* 13319 */ + IC, /* 13320 */ + IC_64BIT_REXW, /* 13321 */ + IC_XS, /* 13322 */ + IC_64BIT_REXW_XS, /* 13323 */ + IC_XD, /* 13324 */ + IC_64BIT_REXW_XD, /* 13325 */ + IC_XS, /* 13326 */ + IC_64BIT_REXW_XS, /* 13327 */ + IC_OPSIZE, /* 13328 */ + IC_64BIT_OPSIZE, /* 13329 */ + IC_XS_OPSIZE, /* 13330 */ + IC_64BIT_XS_OPSIZE, /* 13331 */ + IC_XD_OPSIZE, /* 13332 */ + IC_64BIT_XD_OPSIZE, /* 13333 */ + IC_XS_OPSIZE, /* 13334 */ + IC_64BIT_XD_OPSIZE, /* 13335 */ + IC_OPSIZE, /* 13336 */ + IC_64BIT_REXW_OPSIZE, /* 13337 */ + IC_XS_OPSIZE, /* 13338 */ + IC_64BIT_REXW_XS, /* 13339 */ + IC_XD_OPSIZE, /* 13340 */ + IC_64BIT_REXW_XD, /* 13341 */ + IC_XS_OPSIZE, /* 13342 */ + IC_64BIT_REXW_XS, /* 13343 */ + IC_ADSIZE, /* 13344 */ + IC_64BIT_ADSIZE, /* 13345 */ + IC_XS_ADSIZE, /* 13346 */ + IC_64BIT_XS_ADSIZE, /* 13347 */ + IC_XD_ADSIZE, /* 13348 */ + IC_64BIT_XD_ADSIZE, /* 13349 */ + IC_XS_ADSIZE, /* 13350 */ + IC_64BIT_XD_ADSIZE, /* 13351 */ + IC_ADSIZE, /* 13352 */ + IC_64BIT_REXW_ADSIZE, /* 13353 */ + IC_XS_ADSIZE, /* 13354 */ + IC_64BIT_REXW_XS, /* 13355 */ + IC_XD_ADSIZE, /* 13356 */ + IC_64BIT_REXW_XD, /* 13357 */ + IC_XS_ADSIZE, /* 13358 */ + IC_64BIT_REXW_XS, /* 13359 */ + IC_OPSIZE_ADSIZE, /* 13360 */ + IC_64BIT_OPSIZE_ADSIZE, /* 13361 */ + IC_XS_OPSIZE, /* 13362 */ + IC_64BIT_XS_OPSIZE, /* 13363 */ + IC_XD_OPSIZE, /* 13364 */ + IC_64BIT_XD_OPSIZE, /* 13365 */ + IC_XS_OPSIZE, /* 13366 */ + IC_64BIT_XD_OPSIZE, /* 13367 */ + IC_OPSIZE_ADSIZE, /* 13368 */ + IC_64BIT_REXW_OPSIZE, /* 13369 */ + IC_XS_OPSIZE, /* 13370 */ + IC_64BIT_REXW_XS, /* 13371 */ + IC_XD_OPSIZE, /* 13372 */ + IC_64BIT_REXW_XD, /* 13373 */ + IC_XS_OPSIZE, /* 13374 */ + IC_64BIT_REXW_XS, /* 13375 */ + IC_VEX, /* 13376 */ + IC_VEX, /* 13377 */ + IC_VEX_XS, /* 13378 */ + IC_VEX_XS, /* 13379 */ + IC_VEX_XD, /* 13380 */ + IC_VEX_XD, /* 13381 */ + IC_VEX_XD, /* 13382 */ + IC_VEX_XD, /* 13383 */ + IC_VEX_W, /* 13384 */ + IC_VEX_W, /* 13385 */ + IC_VEX_W_XS, /* 13386 */ + IC_VEX_W_XS, /* 13387 */ + IC_VEX_W_XD, /* 13388 */ + IC_VEX_W_XD, /* 13389 */ + IC_VEX_W_XD, /* 13390 */ + IC_VEX_W_XD, /* 13391 */ + IC_VEX_OPSIZE, /* 13392 */ + IC_VEX_OPSIZE, /* 13393 */ + IC_VEX_OPSIZE, /* 13394 */ + IC_VEX_OPSIZE, /* 13395 */ + IC_VEX_OPSIZE, /* 13396 */ + IC_VEX_OPSIZE, /* 13397 */ + IC_VEX_OPSIZE, /* 13398 */ + IC_VEX_OPSIZE, /* 13399 */ + IC_VEX_W_OPSIZE, /* 13400 */ + IC_VEX_W_OPSIZE, /* 13401 */ + IC_VEX_W_OPSIZE, /* 13402 */ + IC_VEX_W_OPSIZE, /* 13403 */ + IC_VEX_W_OPSIZE, /* 13404 */ + IC_VEX_W_OPSIZE, /* 13405 */ + IC_VEX_W_OPSIZE, /* 13406 */ + IC_VEX_W_OPSIZE, /* 13407 */ + IC_VEX, /* 13408 */ + IC_VEX, /* 13409 */ + IC_VEX_XS, /* 13410 */ + IC_VEX_XS, /* 13411 */ + IC_VEX_XD, /* 13412 */ + IC_VEX_XD, /* 13413 */ + IC_VEX_XD, /* 13414 */ + IC_VEX_XD, /* 13415 */ + IC_VEX_W, /* 13416 */ + IC_VEX_W, /* 13417 */ + IC_VEX_W_XS, /* 13418 */ + IC_VEX_W_XS, /* 13419 */ + IC_VEX_W_XD, /* 13420 */ + IC_VEX_W_XD, /* 13421 */ + IC_VEX_W_XD, /* 13422 */ + IC_VEX_W_XD, /* 13423 */ + IC_VEX_OPSIZE, /* 13424 */ + IC_VEX_OPSIZE, /* 13425 */ + IC_VEX_OPSIZE, /* 13426 */ + IC_VEX_OPSIZE, /* 13427 */ + IC_VEX_OPSIZE, /* 13428 */ + IC_VEX_OPSIZE, /* 13429 */ + IC_VEX_OPSIZE, /* 13430 */ + IC_VEX_OPSIZE, /* 13431 */ + IC_VEX_W_OPSIZE, /* 13432 */ + IC_VEX_W_OPSIZE, /* 13433 */ + IC_VEX_W_OPSIZE, /* 13434 */ + IC_VEX_W_OPSIZE, /* 13435 */ + IC_VEX_W_OPSIZE, /* 13436 */ + IC_VEX_W_OPSIZE, /* 13437 */ + IC_VEX_W_OPSIZE, /* 13438 */ + IC_VEX_W_OPSIZE, /* 13439 */ + IC_VEX_L, /* 13440 */ + IC_VEX_L, /* 13441 */ + IC_VEX_L_XS, /* 13442 */ + IC_VEX_L_XS, /* 13443 */ + IC_VEX_L_XD, /* 13444 */ + IC_VEX_L_XD, /* 13445 */ + IC_VEX_L_XD, /* 13446 */ + IC_VEX_L_XD, /* 13447 */ + IC_VEX_L_W, /* 13448 */ + IC_VEX_L_W, /* 13449 */ + IC_VEX_L_W_XS, /* 13450 */ + IC_VEX_L_W_XS, /* 13451 */ + IC_VEX_L_W_XD, /* 13452 */ + IC_VEX_L_W_XD, /* 13453 */ + IC_VEX_L_W_XD, /* 13454 */ + IC_VEX_L_W_XD, /* 13455 */ + IC_VEX_L_OPSIZE, /* 13456 */ + IC_VEX_L_OPSIZE, /* 13457 */ + IC_VEX_L_OPSIZE, /* 13458 */ + IC_VEX_L_OPSIZE, /* 13459 */ + IC_VEX_L_OPSIZE, /* 13460 */ + IC_VEX_L_OPSIZE, /* 13461 */ + IC_VEX_L_OPSIZE, /* 13462 */ + IC_VEX_L_OPSIZE, /* 13463 */ + IC_VEX_L_W_OPSIZE, /* 13464 */ + IC_VEX_L_W_OPSIZE, /* 13465 */ + IC_VEX_L_W_OPSIZE, /* 13466 */ + IC_VEX_L_W_OPSIZE, /* 13467 */ + IC_VEX_L_W_OPSIZE, /* 13468 */ + IC_VEX_L_W_OPSIZE, /* 13469 */ + IC_VEX_L_W_OPSIZE, /* 13470 */ + IC_VEX_L_W_OPSIZE, /* 13471 */ + IC_VEX_L, /* 13472 */ + IC_VEX_L, /* 13473 */ + IC_VEX_L_XS, /* 13474 */ + IC_VEX_L_XS, /* 13475 */ + IC_VEX_L_XD, /* 13476 */ + IC_VEX_L_XD, /* 13477 */ + IC_VEX_L_XD, /* 13478 */ + IC_VEX_L_XD, /* 13479 */ + IC_VEX_L_W, /* 13480 */ + IC_VEX_L_W, /* 13481 */ + IC_VEX_L_W_XS, /* 13482 */ + IC_VEX_L_W_XS, /* 13483 */ + IC_VEX_L_W_XD, /* 13484 */ + IC_VEX_L_W_XD, /* 13485 */ + IC_VEX_L_W_XD, /* 13486 */ + IC_VEX_L_W_XD, /* 13487 */ + IC_VEX_L_OPSIZE, /* 13488 */ + IC_VEX_L_OPSIZE, /* 13489 */ + IC_VEX_L_OPSIZE, /* 13490 */ + IC_VEX_L_OPSIZE, /* 13491 */ + IC_VEX_L_OPSIZE, /* 13492 */ + IC_VEX_L_OPSIZE, /* 13493 */ + IC_VEX_L_OPSIZE, /* 13494 */ + IC_VEX_L_OPSIZE, /* 13495 */ + IC_VEX_L_W_OPSIZE, /* 13496 */ + IC_VEX_L_W_OPSIZE, /* 13497 */ + IC_VEX_L_W_OPSIZE, /* 13498 */ + IC_VEX_L_W_OPSIZE, /* 13499 */ + IC_VEX_L_W_OPSIZE, /* 13500 */ + IC_VEX_L_W_OPSIZE, /* 13501 */ + IC_VEX_L_W_OPSIZE, /* 13502 */ + IC_VEX_L_W_OPSIZE, /* 13503 */ + IC_VEX_L, /* 13504 */ + IC_VEX_L, /* 13505 */ + IC_VEX_L_XS, /* 13506 */ + IC_VEX_L_XS, /* 13507 */ + IC_VEX_L_XD, /* 13508 */ + IC_VEX_L_XD, /* 13509 */ + IC_VEX_L_XD, /* 13510 */ + IC_VEX_L_XD, /* 13511 */ + IC_VEX_L_W, /* 13512 */ + IC_VEX_L_W, /* 13513 */ + IC_VEX_L_W_XS, /* 13514 */ + IC_VEX_L_W_XS, /* 13515 */ + IC_VEX_L_W_XD, /* 13516 */ + IC_VEX_L_W_XD, /* 13517 */ + IC_VEX_L_W_XD, /* 13518 */ + IC_VEX_L_W_XD, /* 13519 */ + IC_VEX_L_OPSIZE, /* 13520 */ + IC_VEX_L_OPSIZE, /* 13521 */ + IC_VEX_L_OPSIZE, /* 13522 */ + IC_VEX_L_OPSIZE, /* 13523 */ + IC_VEX_L_OPSIZE, /* 13524 */ + IC_VEX_L_OPSIZE, /* 13525 */ + IC_VEX_L_OPSIZE, /* 13526 */ + IC_VEX_L_OPSIZE, /* 13527 */ + IC_VEX_L_W_OPSIZE, /* 13528 */ + IC_VEX_L_W_OPSIZE, /* 13529 */ + IC_VEX_L_W_OPSIZE, /* 13530 */ + IC_VEX_L_W_OPSIZE, /* 13531 */ + IC_VEX_L_W_OPSIZE, /* 13532 */ + IC_VEX_L_W_OPSIZE, /* 13533 */ + IC_VEX_L_W_OPSIZE, /* 13534 */ + IC_VEX_L_W_OPSIZE, /* 13535 */ + IC_VEX_L, /* 13536 */ + IC_VEX_L, /* 13537 */ + IC_VEX_L_XS, /* 13538 */ + IC_VEX_L_XS, /* 13539 */ + IC_VEX_L_XD, /* 13540 */ + IC_VEX_L_XD, /* 13541 */ + IC_VEX_L_XD, /* 13542 */ + IC_VEX_L_XD, /* 13543 */ + IC_VEX_L_W, /* 13544 */ + IC_VEX_L_W, /* 13545 */ + IC_VEX_L_W_XS, /* 13546 */ + IC_VEX_L_W_XS, /* 13547 */ + IC_VEX_L_W_XD, /* 13548 */ + IC_VEX_L_W_XD, /* 13549 */ + IC_VEX_L_W_XD, /* 13550 */ + IC_VEX_L_W_XD, /* 13551 */ + IC_VEX_L_OPSIZE, /* 13552 */ + IC_VEX_L_OPSIZE, /* 13553 */ + IC_VEX_L_OPSIZE, /* 13554 */ + IC_VEX_L_OPSIZE, /* 13555 */ + IC_VEX_L_OPSIZE, /* 13556 */ + IC_VEX_L_OPSIZE, /* 13557 */ + IC_VEX_L_OPSIZE, /* 13558 */ + IC_VEX_L_OPSIZE, /* 13559 */ + IC_VEX_L_W_OPSIZE, /* 13560 */ + IC_VEX_L_W_OPSIZE, /* 13561 */ + IC_VEX_L_W_OPSIZE, /* 13562 */ + IC_VEX_L_W_OPSIZE, /* 13563 */ + IC_VEX_L_W_OPSIZE, /* 13564 */ + IC_VEX_L_W_OPSIZE, /* 13565 */ + IC_VEX_L_W_OPSIZE, /* 13566 */ + IC_VEX_L_W_OPSIZE, /* 13567 */ + IC_EVEX_L2_KZ_B, /* 13568 */ + IC_EVEX_L2_KZ_B, /* 13569 */ + IC_EVEX_L2_XS_KZ_B, /* 13570 */ + IC_EVEX_L2_XS_KZ_B, /* 13571 */ + IC_EVEX_L2_XD_KZ_B, /* 13572 */ + IC_EVEX_L2_XD_KZ_B, /* 13573 */ + IC_EVEX_L2_XD_KZ_B, /* 13574 */ + IC_EVEX_L2_XD_KZ_B, /* 13575 */ + IC_EVEX_L2_W_KZ_B, /* 13576 */ + IC_EVEX_L2_W_KZ_B, /* 13577 */ + IC_EVEX_L2_W_XS_KZ_B, /* 13578 */ + IC_EVEX_L2_W_XS_KZ_B, /* 13579 */ + IC_EVEX_L2_W_XD_KZ_B, /* 13580 */ + IC_EVEX_L2_W_XD_KZ_B, /* 13581 */ + IC_EVEX_L2_W_XD_KZ_B, /* 13582 */ + IC_EVEX_L2_W_XD_KZ_B, /* 13583 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 13584 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 13585 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 13586 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 13587 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 13588 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 13589 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 13590 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 13591 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 13592 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 13593 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 13594 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 13595 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 13596 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 13597 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 13598 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 13599 */ + IC_EVEX_L2_KZ_B, /* 13600 */ + IC_EVEX_L2_KZ_B, /* 13601 */ + IC_EVEX_L2_XS_KZ_B, /* 13602 */ + IC_EVEX_L2_XS_KZ_B, /* 13603 */ + IC_EVEX_L2_XD_KZ_B, /* 13604 */ + IC_EVEX_L2_XD_KZ_B, /* 13605 */ + IC_EVEX_L2_XD_KZ_B, /* 13606 */ + IC_EVEX_L2_XD_KZ_B, /* 13607 */ + IC_EVEX_L2_W_KZ_B, /* 13608 */ + IC_EVEX_L2_W_KZ_B, /* 13609 */ + IC_EVEX_L2_W_XS_KZ_B, /* 13610 */ + IC_EVEX_L2_W_XS_KZ_B, /* 13611 */ + IC_EVEX_L2_W_XD_KZ_B, /* 13612 */ + IC_EVEX_L2_W_XD_KZ_B, /* 13613 */ + IC_EVEX_L2_W_XD_KZ_B, /* 13614 */ + IC_EVEX_L2_W_XD_KZ_B, /* 13615 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 13616 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 13617 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 13618 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 13619 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 13620 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 13621 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 13622 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 13623 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 13624 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 13625 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 13626 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 13627 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 13628 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 13629 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 13630 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 13631 */ + IC_EVEX_L2_KZ_B, /* 13632 */ + IC_EVEX_L2_KZ_B, /* 13633 */ + IC_EVEX_L2_XS_KZ_B, /* 13634 */ + IC_EVEX_L2_XS_KZ_B, /* 13635 */ + IC_EVEX_L2_XD_KZ_B, /* 13636 */ + IC_EVEX_L2_XD_KZ_B, /* 13637 */ + IC_EVEX_L2_XD_KZ_B, /* 13638 */ + IC_EVEX_L2_XD_KZ_B, /* 13639 */ + IC_EVEX_L2_W_KZ_B, /* 13640 */ + IC_EVEX_L2_W_KZ_B, /* 13641 */ + IC_EVEX_L2_W_XS_KZ_B, /* 13642 */ + IC_EVEX_L2_W_XS_KZ_B, /* 13643 */ + IC_EVEX_L2_W_XD_KZ_B, /* 13644 */ + IC_EVEX_L2_W_XD_KZ_B, /* 13645 */ + IC_EVEX_L2_W_XD_KZ_B, /* 13646 */ + IC_EVEX_L2_W_XD_KZ_B, /* 13647 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 13648 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 13649 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 13650 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 13651 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 13652 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 13653 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 13654 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 13655 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 13656 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 13657 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 13658 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 13659 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 13660 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 13661 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 13662 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 13663 */ + IC_EVEX_L2_KZ_B, /* 13664 */ + IC_EVEX_L2_KZ_B, /* 13665 */ + IC_EVEX_L2_XS_KZ_B, /* 13666 */ + IC_EVEX_L2_XS_KZ_B, /* 13667 */ + IC_EVEX_L2_XD_KZ_B, /* 13668 */ + IC_EVEX_L2_XD_KZ_B, /* 13669 */ + IC_EVEX_L2_XD_KZ_B, /* 13670 */ + IC_EVEX_L2_XD_KZ_B, /* 13671 */ + IC_EVEX_L2_W_KZ_B, /* 13672 */ + IC_EVEX_L2_W_KZ_B, /* 13673 */ + IC_EVEX_L2_W_XS_KZ_B, /* 13674 */ + IC_EVEX_L2_W_XS_KZ_B, /* 13675 */ + IC_EVEX_L2_W_XD_KZ_B, /* 13676 */ + IC_EVEX_L2_W_XD_KZ_B, /* 13677 */ + IC_EVEX_L2_W_XD_KZ_B, /* 13678 */ + IC_EVEX_L2_W_XD_KZ_B, /* 13679 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 13680 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 13681 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 13682 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 13683 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 13684 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 13685 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 13686 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 13687 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 13688 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 13689 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 13690 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 13691 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 13692 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 13693 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 13694 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 13695 */ + IC_EVEX_L2_KZ_B, /* 13696 */ + IC_EVEX_L2_KZ_B, /* 13697 */ + IC_EVEX_L2_XS_KZ_B, /* 13698 */ + IC_EVEX_L2_XS_KZ_B, /* 13699 */ + IC_EVEX_L2_XD_KZ_B, /* 13700 */ + IC_EVEX_L2_XD_KZ_B, /* 13701 */ + IC_EVEX_L2_XD_KZ_B, /* 13702 */ + IC_EVEX_L2_XD_KZ_B, /* 13703 */ + IC_EVEX_L2_W_KZ_B, /* 13704 */ + IC_EVEX_L2_W_KZ_B, /* 13705 */ + IC_EVEX_L2_W_XS_KZ_B, /* 13706 */ + IC_EVEX_L2_W_XS_KZ_B, /* 13707 */ + IC_EVEX_L2_W_XD_KZ_B, /* 13708 */ + IC_EVEX_L2_W_XD_KZ_B, /* 13709 */ + IC_EVEX_L2_W_XD_KZ_B, /* 13710 */ + IC_EVEX_L2_W_XD_KZ_B, /* 13711 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 13712 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 13713 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 13714 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 13715 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 13716 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 13717 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 13718 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 13719 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 13720 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 13721 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 13722 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 13723 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 13724 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 13725 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 13726 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 13727 */ + IC_EVEX_L2_KZ_B, /* 13728 */ + IC_EVEX_L2_KZ_B, /* 13729 */ + IC_EVEX_L2_XS_KZ_B, /* 13730 */ + IC_EVEX_L2_XS_KZ_B, /* 13731 */ + IC_EVEX_L2_XD_KZ_B, /* 13732 */ + IC_EVEX_L2_XD_KZ_B, /* 13733 */ + IC_EVEX_L2_XD_KZ_B, /* 13734 */ + IC_EVEX_L2_XD_KZ_B, /* 13735 */ + IC_EVEX_L2_W_KZ_B, /* 13736 */ + IC_EVEX_L2_W_KZ_B, /* 13737 */ + IC_EVEX_L2_W_XS_KZ_B, /* 13738 */ + IC_EVEX_L2_W_XS_KZ_B, /* 13739 */ + IC_EVEX_L2_W_XD_KZ_B, /* 13740 */ + IC_EVEX_L2_W_XD_KZ_B, /* 13741 */ + IC_EVEX_L2_W_XD_KZ_B, /* 13742 */ + IC_EVEX_L2_W_XD_KZ_B, /* 13743 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 13744 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 13745 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 13746 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 13747 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 13748 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 13749 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 13750 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 13751 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 13752 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 13753 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 13754 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 13755 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 13756 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 13757 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 13758 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 13759 */ + IC_EVEX_L2_KZ_B, /* 13760 */ + IC_EVEX_L2_KZ_B, /* 13761 */ + IC_EVEX_L2_XS_KZ_B, /* 13762 */ + IC_EVEX_L2_XS_KZ_B, /* 13763 */ + IC_EVEX_L2_XD_KZ_B, /* 13764 */ + IC_EVEX_L2_XD_KZ_B, /* 13765 */ + IC_EVEX_L2_XD_KZ_B, /* 13766 */ + IC_EVEX_L2_XD_KZ_B, /* 13767 */ + IC_EVEX_L2_W_KZ_B, /* 13768 */ + IC_EVEX_L2_W_KZ_B, /* 13769 */ + IC_EVEX_L2_W_XS_KZ_B, /* 13770 */ + IC_EVEX_L2_W_XS_KZ_B, /* 13771 */ + IC_EVEX_L2_W_XD_KZ_B, /* 13772 */ + IC_EVEX_L2_W_XD_KZ_B, /* 13773 */ + IC_EVEX_L2_W_XD_KZ_B, /* 13774 */ + IC_EVEX_L2_W_XD_KZ_B, /* 13775 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 13776 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 13777 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 13778 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 13779 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 13780 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 13781 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 13782 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 13783 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 13784 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 13785 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 13786 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 13787 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 13788 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 13789 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 13790 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 13791 */ + IC_EVEX_L2_KZ_B, /* 13792 */ + IC_EVEX_L2_KZ_B, /* 13793 */ + IC_EVEX_L2_XS_KZ_B, /* 13794 */ + IC_EVEX_L2_XS_KZ_B, /* 13795 */ + IC_EVEX_L2_XD_KZ_B, /* 13796 */ + IC_EVEX_L2_XD_KZ_B, /* 13797 */ + IC_EVEX_L2_XD_KZ_B, /* 13798 */ + IC_EVEX_L2_XD_KZ_B, /* 13799 */ + IC_EVEX_L2_W_KZ_B, /* 13800 */ + IC_EVEX_L2_W_KZ_B, /* 13801 */ + IC_EVEX_L2_W_XS_KZ_B, /* 13802 */ + IC_EVEX_L2_W_XS_KZ_B, /* 13803 */ + IC_EVEX_L2_W_XD_KZ_B, /* 13804 */ + IC_EVEX_L2_W_XD_KZ_B, /* 13805 */ + IC_EVEX_L2_W_XD_KZ_B, /* 13806 */ + IC_EVEX_L2_W_XD_KZ_B, /* 13807 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 13808 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 13809 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 13810 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 13811 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 13812 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 13813 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 13814 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 13815 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 13816 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 13817 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 13818 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 13819 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 13820 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 13821 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 13822 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 13823 */ + IC, /* 13824 */ + IC_64BIT, /* 13825 */ + IC_XS, /* 13826 */ + IC_64BIT_XS, /* 13827 */ + IC_XD, /* 13828 */ + IC_64BIT_XD, /* 13829 */ + IC_XS, /* 13830 */ + IC_64BIT_XS, /* 13831 */ + IC, /* 13832 */ + IC_64BIT_REXW, /* 13833 */ + IC_XS, /* 13834 */ + IC_64BIT_REXW_XS, /* 13835 */ + IC_XD, /* 13836 */ + IC_64BIT_REXW_XD, /* 13837 */ + IC_XS, /* 13838 */ + IC_64BIT_REXW_XS, /* 13839 */ + IC_OPSIZE, /* 13840 */ + IC_64BIT_OPSIZE, /* 13841 */ + IC_XS_OPSIZE, /* 13842 */ + IC_64BIT_XS_OPSIZE, /* 13843 */ + IC_XD_OPSIZE, /* 13844 */ + IC_64BIT_XD_OPSIZE, /* 13845 */ + IC_XS_OPSIZE, /* 13846 */ + IC_64BIT_XD_OPSIZE, /* 13847 */ + IC_OPSIZE, /* 13848 */ + IC_64BIT_REXW_OPSIZE, /* 13849 */ + IC_XS_OPSIZE, /* 13850 */ + IC_64BIT_REXW_XS, /* 13851 */ + IC_XD_OPSIZE, /* 13852 */ + IC_64BIT_REXW_XD, /* 13853 */ + IC_XS_OPSIZE, /* 13854 */ + IC_64BIT_REXW_XS, /* 13855 */ + IC_ADSIZE, /* 13856 */ + IC_64BIT_ADSIZE, /* 13857 */ + IC_XS_ADSIZE, /* 13858 */ + IC_64BIT_XS_ADSIZE, /* 13859 */ + IC_XD_ADSIZE, /* 13860 */ + IC_64BIT_XD_ADSIZE, /* 13861 */ + IC_XS_ADSIZE, /* 13862 */ + IC_64BIT_XD_ADSIZE, /* 13863 */ + IC_ADSIZE, /* 13864 */ + IC_64BIT_REXW_ADSIZE, /* 13865 */ + IC_XS_ADSIZE, /* 13866 */ + IC_64BIT_REXW_XS, /* 13867 */ + IC_XD_ADSIZE, /* 13868 */ + IC_64BIT_REXW_XD, /* 13869 */ + IC_XS_ADSIZE, /* 13870 */ + IC_64BIT_REXW_XS, /* 13871 */ + IC_OPSIZE_ADSIZE, /* 13872 */ + IC_64BIT_OPSIZE_ADSIZE, /* 13873 */ + IC_XS_OPSIZE, /* 13874 */ + IC_64BIT_XS_OPSIZE, /* 13875 */ + IC_XD_OPSIZE, /* 13876 */ + IC_64BIT_XD_OPSIZE, /* 13877 */ + IC_XS_OPSIZE, /* 13878 */ + IC_64BIT_XD_OPSIZE, /* 13879 */ + IC_OPSIZE_ADSIZE, /* 13880 */ + IC_64BIT_REXW_OPSIZE, /* 13881 */ + IC_XS_OPSIZE, /* 13882 */ + IC_64BIT_REXW_XS, /* 13883 */ + IC_XD_OPSIZE, /* 13884 */ + IC_64BIT_REXW_XD, /* 13885 */ + IC_XS_OPSIZE, /* 13886 */ + IC_64BIT_REXW_XS, /* 13887 */ + IC_VEX, /* 13888 */ + IC_VEX, /* 13889 */ + IC_VEX_XS, /* 13890 */ + IC_VEX_XS, /* 13891 */ + IC_VEX_XD, /* 13892 */ + IC_VEX_XD, /* 13893 */ + IC_VEX_XD, /* 13894 */ + IC_VEX_XD, /* 13895 */ + IC_VEX_W, /* 13896 */ + IC_VEX_W, /* 13897 */ + IC_VEX_W_XS, /* 13898 */ + IC_VEX_W_XS, /* 13899 */ + IC_VEX_W_XD, /* 13900 */ + IC_VEX_W_XD, /* 13901 */ + IC_VEX_W_XD, /* 13902 */ + IC_VEX_W_XD, /* 13903 */ + IC_VEX_OPSIZE, /* 13904 */ + IC_VEX_OPSIZE, /* 13905 */ + IC_VEX_OPSIZE, /* 13906 */ + IC_VEX_OPSIZE, /* 13907 */ + IC_VEX_OPSIZE, /* 13908 */ + IC_VEX_OPSIZE, /* 13909 */ + IC_VEX_OPSIZE, /* 13910 */ + IC_VEX_OPSIZE, /* 13911 */ + IC_VEX_W_OPSIZE, /* 13912 */ + IC_VEX_W_OPSIZE, /* 13913 */ + IC_VEX_W_OPSIZE, /* 13914 */ + IC_VEX_W_OPSIZE, /* 13915 */ + IC_VEX_W_OPSIZE, /* 13916 */ + IC_VEX_W_OPSIZE, /* 13917 */ + IC_VEX_W_OPSIZE, /* 13918 */ + IC_VEX_W_OPSIZE, /* 13919 */ + IC_VEX, /* 13920 */ + IC_VEX, /* 13921 */ + IC_VEX_XS, /* 13922 */ + IC_VEX_XS, /* 13923 */ + IC_VEX_XD, /* 13924 */ + IC_VEX_XD, /* 13925 */ + IC_VEX_XD, /* 13926 */ + IC_VEX_XD, /* 13927 */ + IC_VEX_W, /* 13928 */ + IC_VEX_W, /* 13929 */ + IC_VEX_W_XS, /* 13930 */ + IC_VEX_W_XS, /* 13931 */ + IC_VEX_W_XD, /* 13932 */ + IC_VEX_W_XD, /* 13933 */ + IC_VEX_W_XD, /* 13934 */ + IC_VEX_W_XD, /* 13935 */ + IC_VEX_OPSIZE, /* 13936 */ + IC_VEX_OPSIZE, /* 13937 */ + IC_VEX_OPSIZE, /* 13938 */ + IC_VEX_OPSIZE, /* 13939 */ + IC_VEX_OPSIZE, /* 13940 */ + IC_VEX_OPSIZE, /* 13941 */ + IC_VEX_OPSIZE, /* 13942 */ + IC_VEX_OPSIZE, /* 13943 */ + IC_VEX_W_OPSIZE, /* 13944 */ + IC_VEX_W_OPSIZE, /* 13945 */ + IC_VEX_W_OPSIZE, /* 13946 */ + IC_VEX_W_OPSIZE, /* 13947 */ + IC_VEX_W_OPSIZE, /* 13948 */ + IC_VEX_W_OPSIZE, /* 13949 */ + IC_VEX_W_OPSIZE, /* 13950 */ + IC_VEX_W_OPSIZE, /* 13951 */ + IC_VEX_L, /* 13952 */ + IC_VEX_L, /* 13953 */ + IC_VEX_L_XS, /* 13954 */ + IC_VEX_L_XS, /* 13955 */ + IC_VEX_L_XD, /* 13956 */ + IC_VEX_L_XD, /* 13957 */ + IC_VEX_L_XD, /* 13958 */ + IC_VEX_L_XD, /* 13959 */ + IC_VEX_L_W, /* 13960 */ + IC_VEX_L_W, /* 13961 */ + IC_VEX_L_W_XS, /* 13962 */ + IC_VEX_L_W_XS, /* 13963 */ + IC_VEX_L_W_XD, /* 13964 */ + IC_VEX_L_W_XD, /* 13965 */ + IC_VEX_L_W_XD, /* 13966 */ + IC_VEX_L_W_XD, /* 13967 */ + IC_VEX_L_OPSIZE, /* 13968 */ + IC_VEX_L_OPSIZE, /* 13969 */ + IC_VEX_L_OPSIZE, /* 13970 */ + IC_VEX_L_OPSIZE, /* 13971 */ + IC_VEX_L_OPSIZE, /* 13972 */ + IC_VEX_L_OPSIZE, /* 13973 */ + IC_VEX_L_OPSIZE, /* 13974 */ + IC_VEX_L_OPSIZE, /* 13975 */ + IC_VEX_L_W_OPSIZE, /* 13976 */ + IC_VEX_L_W_OPSIZE, /* 13977 */ + IC_VEX_L_W_OPSIZE, /* 13978 */ + IC_VEX_L_W_OPSIZE, /* 13979 */ + IC_VEX_L_W_OPSIZE, /* 13980 */ + IC_VEX_L_W_OPSIZE, /* 13981 */ + IC_VEX_L_W_OPSIZE, /* 13982 */ + IC_VEX_L_W_OPSIZE, /* 13983 */ + IC_VEX_L, /* 13984 */ + IC_VEX_L, /* 13985 */ + IC_VEX_L_XS, /* 13986 */ + IC_VEX_L_XS, /* 13987 */ + IC_VEX_L_XD, /* 13988 */ + IC_VEX_L_XD, /* 13989 */ + IC_VEX_L_XD, /* 13990 */ + IC_VEX_L_XD, /* 13991 */ + IC_VEX_L_W, /* 13992 */ + IC_VEX_L_W, /* 13993 */ + IC_VEX_L_W_XS, /* 13994 */ + IC_VEX_L_W_XS, /* 13995 */ + IC_VEX_L_W_XD, /* 13996 */ + IC_VEX_L_W_XD, /* 13997 */ + IC_VEX_L_W_XD, /* 13998 */ + IC_VEX_L_W_XD, /* 13999 */ + IC_VEX_L_OPSIZE, /* 14000 */ + IC_VEX_L_OPSIZE, /* 14001 */ + IC_VEX_L_OPSIZE, /* 14002 */ + IC_VEX_L_OPSIZE, /* 14003 */ + IC_VEX_L_OPSIZE, /* 14004 */ + IC_VEX_L_OPSIZE, /* 14005 */ + IC_VEX_L_OPSIZE, /* 14006 */ + IC_VEX_L_OPSIZE, /* 14007 */ + IC_VEX_L_W_OPSIZE, /* 14008 */ + IC_VEX_L_W_OPSIZE, /* 14009 */ + IC_VEX_L_W_OPSIZE, /* 14010 */ + IC_VEX_L_W_OPSIZE, /* 14011 */ + IC_VEX_L_W_OPSIZE, /* 14012 */ + IC_VEX_L_W_OPSIZE, /* 14013 */ + IC_VEX_L_W_OPSIZE, /* 14014 */ + IC_VEX_L_W_OPSIZE, /* 14015 */ + IC_VEX_L, /* 14016 */ + IC_VEX_L, /* 14017 */ + IC_VEX_L_XS, /* 14018 */ + IC_VEX_L_XS, /* 14019 */ + IC_VEX_L_XD, /* 14020 */ + IC_VEX_L_XD, /* 14021 */ + IC_VEX_L_XD, /* 14022 */ + IC_VEX_L_XD, /* 14023 */ + IC_VEX_L_W, /* 14024 */ + IC_VEX_L_W, /* 14025 */ + IC_VEX_L_W_XS, /* 14026 */ + IC_VEX_L_W_XS, /* 14027 */ + IC_VEX_L_W_XD, /* 14028 */ + IC_VEX_L_W_XD, /* 14029 */ + IC_VEX_L_W_XD, /* 14030 */ + IC_VEX_L_W_XD, /* 14031 */ + IC_VEX_L_OPSIZE, /* 14032 */ + IC_VEX_L_OPSIZE, /* 14033 */ + IC_VEX_L_OPSIZE, /* 14034 */ + IC_VEX_L_OPSIZE, /* 14035 */ + IC_VEX_L_OPSIZE, /* 14036 */ + IC_VEX_L_OPSIZE, /* 14037 */ + IC_VEX_L_OPSIZE, /* 14038 */ + IC_VEX_L_OPSIZE, /* 14039 */ + IC_VEX_L_W_OPSIZE, /* 14040 */ + IC_VEX_L_W_OPSIZE, /* 14041 */ + IC_VEX_L_W_OPSIZE, /* 14042 */ + IC_VEX_L_W_OPSIZE, /* 14043 */ + IC_VEX_L_W_OPSIZE, /* 14044 */ + IC_VEX_L_W_OPSIZE, /* 14045 */ + IC_VEX_L_W_OPSIZE, /* 14046 */ + IC_VEX_L_W_OPSIZE, /* 14047 */ + IC_VEX_L, /* 14048 */ + IC_VEX_L, /* 14049 */ + IC_VEX_L_XS, /* 14050 */ + IC_VEX_L_XS, /* 14051 */ + IC_VEX_L_XD, /* 14052 */ + IC_VEX_L_XD, /* 14053 */ + IC_VEX_L_XD, /* 14054 */ + IC_VEX_L_XD, /* 14055 */ + IC_VEX_L_W, /* 14056 */ + IC_VEX_L_W, /* 14057 */ + IC_VEX_L_W_XS, /* 14058 */ + IC_VEX_L_W_XS, /* 14059 */ + IC_VEX_L_W_XD, /* 14060 */ + IC_VEX_L_W_XD, /* 14061 */ + IC_VEX_L_W_XD, /* 14062 */ + IC_VEX_L_W_XD, /* 14063 */ + IC_VEX_L_OPSIZE, /* 14064 */ + IC_VEX_L_OPSIZE, /* 14065 */ + IC_VEX_L_OPSIZE, /* 14066 */ + IC_VEX_L_OPSIZE, /* 14067 */ + IC_VEX_L_OPSIZE, /* 14068 */ + IC_VEX_L_OPSIZE, /* 14069 */ + IC_VEX_L_OPSIZE, /* 14070 */ + IC_VEX_L_OPSIZE, /* 14071 */ + IC_VEX_L_W_OPSIZE, /* 14072 */ + IC_VEX_L_W_OPSIZE, /* 14073 */ + IC_VEX_L_W_OPSIZE, /* 14074 */ + IC_VEX_L_W_OPSIZE, /* 14075 */ + IC_VEX_L_W_OPSIZE, /* 14076 */ + IC_VEX_L_W_OPSIZE, /* 14077 */ + IC_VEX_L_W_OPSIZE, /* 14078 */ + IC_VEX_L_W_OPSIZE, /* 14079 */ + IC_EVEX_L2_KZ_B, /* 14080 */ + IC_EVEX_L2_KZ_B, /* 14081 */ + IC_EVEX_L2_XS_KZ_B, /* 14082 */ + IC_EVEX_L2_XS_KZ_B, /* 14083 */ + IC_EVEX_L2_XD_KZ_B, /* 14084 */ + IC_EVEX_L2_XD_KZ_B, /* 14085 */ + IC_EVEX_L2_XD_KZ_B, /* 14086 */ + IC_EVEX_L2_XD_KZ_B, /* 14087 */ + IC_EVEX_L2_W_KZ_B, /* 14088 */ + IC_EVEX_L2_W_KZ_B, /* 14089 */ + IC_EVEX_L2_W_XS_KZ_B, /* 14090 */ + IC_EVEX_L2_W_XS_KZ_B, /* 14091 */ + IC_EVEX_L2_W_XD_KZ_B, /* 14092 */ + IC_EVEX_L2_W_XD_KZ_B, /* 14093 */ + IC_EVEX_L2_W_XD_KZ_B, /* 14094 */ + IC_EVEX_L2_W_XD_KZ_B, /* 14095 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 14096 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 14097 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 14098 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 14099 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 14100 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 14101 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 14102 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 14103 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 14104 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 14105 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 14106 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 14107 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 14108 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 14109 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 14110 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 14111 */ + IC_EVEX_L2_KZ_B, /* 14112 */ + IC_EVEX_L2_KZ_B, /* 14113 */ + IC_EVEX_L2_XS_KZ_B, /* 14114 */ + IC_EVEX_L2_XS_KZ_B, /* 14115 */ + IC_EVEX_L2_XD_KZ_B, /* 14116 */ + IC_EVEX_L2_XD_KZ_B, /* 14117 */ + IC_EVEX_L2_XD_KZ_B, /* 14118 */ + IC_EVEX_L2_XD_KZ_B, /* 14119 */ + IC_EVEX_L2_W_KZ_B, /* 14120 */ + IC_EVEX_L2_W_KZ_B, /* 14121 */ + IC_EVEX_L2_W_XS_KZ_B, /* 14122 */ + IC_EVEX_L2_W_XS_KZ_B, /* 14123 */ + IC_EVEX_L2_W_XD_KZ_B, /* 14124 */ + IC_EVEX_L2_W_XD_KZ_B, /* 14125 */ + IC_EVEX_L2_W_XD_KZ_B, /* 14126 */ + IC_EVEX_L2_W_XD_KZ_B, /* 14127 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 14128 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 14129 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 14130 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 14131 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 14132 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 14133 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 14134 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 14135 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 14136 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 14137 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 14138 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 14139 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 14140 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 14141 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 14142 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 14143 */ + IC_EVEX_L2_KZ_B, /* 14144 */ + IC_EVEX_L2_KZ_B, /* 14145 */ + IC_EVEX_L2_XS_KZ_B, /* 14146 */ + IC_EVEX_L2_XS_KZ_B, /* 14147 */ + IC_EVEX_L2_XD_KZ_B, /* 14148 */ + IC_EVEX_L2_XD_KZ_B, /* 14149 */ + IC_EVEX_L2_XD_KZ_B, /* 14150 */ + IC_EVEX_L2_XD_KZ_B, /* 14151 */ + IC_EVEX_L2_W_KZ_B, /* 14152 */ + IC_EVEX_L2_W_KZ_B, /* 14153 */ + IC_EVEX_L2_W_XS_KZ_B, /* 14154 */ + IC_EVEX_L2_W_XS_KZ_B, /* 14155 */ + IC_EVEX_L2_W_XD_KZ_B, /* 14156 */ + IC_EVEX_L2_W_XD_KZ_B, /* 14157 */ + IC_EVEX_L2_W_XD_KZ_B, /* 14158 */ + IC_EVEX_L2_W_XD_KZ_B, /* 14159 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 14160 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 14161 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 14162 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 14163 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 14164 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 14165 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 14166 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 14167 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 14168 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 14169 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 14170 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 14171 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 14172 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 14173 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 14174 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 14175 */ + IC_EVEX_L2_KZ_B, /* 14176 */ + IC_EVEX_L2_KZ_B, /* 14177 */ + IC_EVEX_L2_XS_KZ_B, /* 14178 */ + IC_EVEX_L2_XS_KZ_B, /* 14179 */ + IC_EVEX_L2_XD_KZ_B, /* 14180 */ + IC_EVEX_L2_XD_KZ_B, /* 14181 */ + IC_EVEX_L2_XD_KZ_B, /* 14182 */ + IC_EVEX_L2_XD_KZ_B, /* 14183 */ + IC_EVEX_L2_W_KZ_B, /* 14184 */ + IC_EVEX_L2_W_KZ_B, /* 14185 */ + IC_EVEX_L2_W_XS_KZ_B, /* 14186 */ + IC_EVEX_L2_W_XS_KZ_B, /* 14187 */ + IC_EVEX_L2_W_XD_KZ_B, /* 14188 */ + IC_EVEX_L2_W_XD_KZ_B, /* 14189 */ + IC_EVEX_L2_W_XD_KZ_B, /* 14190 */ + IC_EVEX_L2_W_XD_KZ_B, /* 14191 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 14192 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 14193 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 14194 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 14195 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 14196 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 14197 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 14198 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 14199 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 14200 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 14201 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 14202 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 14203 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 14204 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 14205 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 14206 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 14207 */ + IC_EVEX_L2_KZ_B, /* 14208 */ + IC_EVEX_L2_KZ_B, /* 14209 */ + IC_EVEX_L2_XS_KZ_B, /* 14210 */ + IC_EVEX_L2_XS_KZ_B, /* 14211 */ + IC_EVEX_L2_XD_KZ_B, /* 14212 */ + IC_EVEX_L2_XD_KZ_B, /* 14213 */ + IC_EVEX_L2_XD_KZ_B, /* 14214 */ + IC_EVEX_L2_XD_KZ_B, /* 14215 */ + IC_EVEX_L2_W_KZ_B, /* 14216 */ + IC_EVEX_L2_W_KZ_B, /* 14217 */ + IC_EVEX_L2_W_XS_KZ_B, /* 14218 */ + IC_EVEX_L2_W_XS_KZ_B, /* 14219 */ + IC_EVEX_L2_W_XD_KZ_B, /* 14220 */ + IC_EVEX_L2_W_XD_KZ_B, /* 14221 */ + IC_EVEX_L2_W_XD_KZ_B, /* 14222 */ + IC_EVEX_L2_W_XD_KZ_B, /* 14223 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 14224 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 14225 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 14226 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 14227 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 14228 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 14229 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 14230 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 14231 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 14232 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 14233 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 14234 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 14235 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 14236 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 14237 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 14238 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 14239 */ + IC_EVEX_L2_KZ_B, /* 14240 */ + IC_EVEX_L2_KZ_B, /* 14241 */ + IC_EVEX_L2_XS_KZ_B, /* 14242 */ + IC_EVEX_L2_XS_KZ_B, /* 14243 */ + IC_EVEX_L2_XD_KZ_B, /* 14244 */ + IC_EVEX_L2_XD_KZ_B, /* 14245 */ + IC_EVEX_L2_XD_KZ_B, /* 14246 */ + IC_EVEX_L2_XD_KZ_B, /* 14247 */ + IC_EVEX_L2_W_KZ_B, /* 14248 */ + IC_EVEX_L2_W_KZ_B, /* 14249 */ + IC_EVEX_L2_W_XS_KZ_B, /* 14250 */ + IC_EVEX_L2_W_XS_KZ_B, /* 14251 */ + IC_EVEX_L2_W_XD_KZ_B, /* 14252 */ + IC_EVEX_L2_W_XD_KZ_B, /* 14253 */ + IC_EVEX_L2_W_XD_KZ_B, /* 14254 */ + IC_EVEX_L2_W_XD_KZ_B, /* 14255 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 14256 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 14257 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 14258 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 14259 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 14260 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 14261 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 14262 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 14263 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 14264 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 14265 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 14266 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 14267 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 14268 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 14269 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 14270 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 14271 */ + IC_EVEX_L2_KZ_B, /* 14272 */ + IC_EVEX_L2_KZ_B, /* 14273 */ + IC_EVEX_L2_XS_KZ_B, /* 14274 */ + IC_EVEX_L2_XS_KZ_B, /* 14275 */ + IC_EVEX_L2_XD_KZ_B, /* 14276 */ + IC_EVEX_L2_XD_KZ_B, /* 14277 */ + IC_EVEX_L2_XD_KZ_B, /* 14278 */ + IC_EVEX_L2_XD_KZ_B, /* 14279 */ + IC_EVEX_L2_W_KZ_B, /* 14280 */ + IC_EVEX_L2_W_KZ_B, /* 14281 */ + IC_EVEX_L2_W_XS_KZ_B, /* 14282 */ + IC_EVEX_L2_W_XS_KZ_B, /* 14283 */ + IC_EVEX_L2_W_XD_KZ_B, /* 14284 */ + IC_EVEX_L2_W_XD_KZ_B, /* 14285 */ + IC_EVEX_L2_W_XD_KZ_B, /* 14286 */ + IC_EVEX_L2_W_XD_KZ_B, /* 14287 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 14288 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 14289 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 14290 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 14291 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 14292 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 14293 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 14294 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 14295 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 14296 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 14297 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 14298 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 14299 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 14300 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 14301 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 14302 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 14303 */ + IC_EVEX_L2_KZ_B, /* 14304 */ + IC_EVEX_L2_KZ_B, /* 14305 */ + IC_EVEX_L2_XS_KZ_B, /* 14306 */ + IC_EVEX_L2_XS_KZ_B, /* 14307 */ + IC_EVEX_L2_XD_KZ_B, /* 14308 */ + IC_EVEX_L2_XD_KZ_B, /* 14309 */ + IC_EVEX_L2_XD_KZ_B, /* 14310 */ + IC_EVEX_L2_XD_KZ_B, /* 14311 */ + IC_EVEX_L2_W_KZ_B, /* 14312 */ + IC_EVEX_L2_W_KZ_B, /* 14313 */ + IC_EVEX_L2_W_XS_KZ_B, /* 14314 */ + IC_EVEX_L2_W_XS_KZ_B, /* 14315 */ + IC_EVEX_L2_W_XD_KZ_B, /* 14316 */ + IC_EVEX_L2_W_XD_KZ_B, /* 14317 */ + IC_EVEX_L2_W_XD_KZ_B, /* 14318 */ + IC_EVEX_L2_W_XD_KZ_B, /* 14319 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 14320 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 14321 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 14322 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 14323 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 14324 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 14325 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 14326 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 14327 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 14328 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 14329 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 14330 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 14331 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 14332 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 14333 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 14334 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 14335 */ + IC, /* 14336 */ + IC_64BIT, /* 14337 */ + IC_XS, /* 14338 */ + IC_64BIT_XS, /* 14339 */ + IC_XD, /* 14340 */ + IC_64BIT_XD, /* 14341 */ + IC_XS, /* 14342 */ + IC_64BIT_XS, /* 14343 */ + IC, /* 14344 */ + IC_64BIT_REXW, /* 14345 */ + IC_XS, /* 14346 */ + IC_64BIT_REXW_XS, /* 14347 */ + IC_XD, /* 14348 */ + IC_64BIT_REXW_XD, /* 14349 */ + IC_XS, /* 14350 */ + IC_64BIT_REXW_XS, /* 14351 */ + IC_OPSIZE, /* 14352 */ + IC_64BIT_OPSIZE, /* 14353 */ + IC_XS_OPSIZE, /* 14354 */ + IC_64BIT_XS_OPSIZE, /* 14355 */ + IC_XD_OPSIZE, /* 14356 */ + IC_64BIT_XD_OPSIZE, /* 14357 */ + IC_XS_OPSIZE, /* 14358 */ + IC_64BIT_XD_OPSIZE, /* 14359 */ + IC_OPSIZE, /* 14360 */ + IC_64BIT_REXW_OPSIZE, /* 14361 */ + IC_XS_OPSIZE, /* 14362 */ + IC_64BIT_REXW_XS, /* 14363 */ + IC_XD_OPSIZE, /* 14364 */ + IC_64BIT_REXW_XD, /* 14365 */ + IC_XS_OPSIZE, /* 14366 */ + IC_64BIT_REXW_XS, /* 14367 */ + IC_ADSIZE, /* 14368 */ + IC_64BIT_ADSIZE, /* 14369 */ + IC_XS_ADSIZE, /* 14370 */ + IC_64BIT_XS_ADSIZE, /* 14371 */ + IC_XD_ADSIZE, /* 14372 */ + IC_64BIT_XD_ADSIZE, /* 14373 */ + IC_XS_ADSIZE, /* 14374 */ + IC_64BIT_XD_ADSIZE, /* 14375 */ + IC_ADSIZE, /* 14376 */ + IC_64BIT_REXW_ADSIZE, /* 14377 */ + IC_XS_ADSIZE, /* 14378 */ + IC_64BIT_REXW_XS, /* 14379 */ + IC_XD_ADSIZE, /* 14380 */ + IC_64BIT_REXW_XD, /* 14381 */ + IC_XS_ADSIZE, /* 14382 */ + IC_64BIT_REXW_XS, /* 14383 */ + IC_OPSIZE_ADSIZE, /* 14384 */ + IC_64BIT_OPSIZE_ADSIZE, /* 14385 */ + IC_XS_OPSIZE, /* 14386 */ + IC_64BIT_XS_OPSIZE, /* 14387 */ + IC_XD_OPSIZE, /* 14388 */ + IC_64BIT_XD_OPSIZE, /* 14389 */ + IC_XS_OPSIZE, /* 14390 */ + IC_64BIT_XD_OPSIZE, /* 14391 */ + IC_OPSIZE_ADSIZE, /* 14392 */ + IC_64BIT_REXW_OPSIZE, /* 14393 */ + IC_XS_OPSIZE, /* 14394 */ + IC_64BIT_REXW_XS, /* 14395 */ + IC_XD_OPSIZE, /* 14396 */ + IC_64BIT_REXW_XD, /* 14397 */ + IC_XS_OPSIZE, /* 14398 */ + IC_64BIT_REXW_XS, /* 14399 */ + IC_VEX, /* 14400 */ + IC_VEX, /* 14401 */ + IC_VEX_XS, /* 14402 */ + IC_VEX_XS, /* 14403 */ + IC_VEX_XD, /* 14404 */ + IC_VEX_XD, /* 14405 */ + IC_VEX_XD, /* 14406 */ + IC_VEX_XD, /* 14407 */ + IC_VEX_W, /* 14408 */ + IC_VEX_W, /* 14409 */ + IC_VEX_W_XS, /* 14410 */ + IC_VEX_W_XS, /* 14411 */ + IC_VEX_W_XD, /* 14412 */ + IC_VEX_W_XD, /* 14413 */ + IC_VEX_W_XD, /* 14414 */ + IC_VEX_W_XD, /* 14415 */ + IC_VEX_OPSIZE, /* 14416 */ + IC_VEX_OPSIZE, /* 14417 */ + IC_VEX_OPSIZE, /* 14418 */ + IC_VEX_OPSIZE, /* 14419 */ + IC_VEX_OPSIZE, /* 14420 */ + IC_VEX_OPSIZE, /* 14421 */ + IC_VEX_OPSIZE, /* 14422 */ + IC_VEX_OPSIZE, /* 14423 */ + IC_VEX_W_OPSIZE, /* 14424 */ + IC_VEX_W_OPSIZE, /* 14425 */ + IC_VEX_W_OPSIZE, /* 14426 */ + IC_VEX_W_OPSIZE, /* 14427 */ + IC_VEX_W_OPSIZE, /* 14428 */ + IC_VEX_W_OPSIZE, /* 14429 */ + IC_VEX_W_OPSIZE, /* 14430 */ + IC_VEX_W_OPSIZE, /* 14431 */ + IC_VEX, /* 14432 */ + IC_VEX, /* 14433 */ + IC_VEX_XS, /* 14434 */ + IC_VEX_XS, /* 14435 */ + IC_VEX_XD, /* 14436 */ + IC_VEX_XD, /* 14437 */ + IC_VEX_XD, /* 14438 */ + IC_VEX_XD, /* 14439 */ + IC_VEX_W, /* 14440 */ + IC_VEX_W, /* 14441 */ + IC_VEX_W_XS, /* 14442 */ + IC_VEX_W_XS, /* 14443 */ + IC_VEX_W_XD, /* 14444 */ + IC_VEX_W_XD, /* 14445 */ + IC_VEX_W_XD, /* 14446 */ + IC_VEX_W_XD, /* 14447 */ + IC_VEX_OPSIZE, /* 14448 */ + IC_VEX_OPSIZE, /* 14449 */ + IC_VEX_OPSIZE, /* 14450 */ + IC_VEX_OPSIZE, /* 14451 */ + IC_VEX_OPSIZE, /* 14452 */ + IC_VEX_OPSIZE, /* 14453 */ + IC_VEX_OPSIZE, /* 14454 */ + IC_VEX_OPSIZE, /* 14455 */ + IC_VEX_W_OPSIZE, /* 14456 */ + IC_VEX_W_OPSIZE, /* 14457 */ + IC_VEX_W_OPSIZE, /* 14458 */ + IC_VEX_W_OPSIZE, /* 14459 */ + IC_VEX_W_OPSIZE, /* 14460 */ + IC_VEX_W_OPSIZE, /* 14461 */ + IC_VEX_W_OPSIZE, /* 14462 */ + IC_VEX_W_OPSIZE, /* 14463 */ + IC_VEX_L, /* 14464 */ + IC_VEX_L, /* 14465 */ + IC_VEX_L_XS, /* 14466 */ + IC_VEX_L_XS, /* 14467 */ + IC_VEX_L_XD, /* 14468 */ + IC_VEX_L_XD, /* 14469 */ + IC_VEX_L_XD, /* 14470 */ + IC_VEX_L_XD, /* 14471 */ + IC_VEX_L_W, /* 14472 */ + IC_VEX_L_W, /* 14473 */ + IC_VEX_L_W_XS, /* 14474 */ + IC_VEX_L_W_XS, /* 14475 */ + IC_VEX_L_W_XD, /* 14476 */ + IC_VEX_L_W_XD, /* 14477 */ + IC_VEX_L_W_XD, /* 14478 */ + IC_VEX_L_W_XD, /* 14479 */ + IC_VEX_L_OPSIZE, /* 14480 */ + IC_VEX_L_OPSIZE, /* 14481 */ + IC_VEX_L_OPSIZE, /* 14482 */ + IC_VEX_L_OPSIZE, /* 14483 */ + IC_VEX_L_OPSIZE, /* 14484 */ + IC_VEX_L_OPSIZE, /* 14485 */ + IC_VEX_L_OPSIZE, /* 14486 */ + IC_VEX_L_OPSIZE, /* 14487 */ + IC_VEX_L_W_OPSIZE, /* 14488 */ + IC_VEX_L_W_OPSIZE, /* 14489 */ + IC_VEX_L_W_OPSIZE, /* 14490 */ + IC_VEX_L_W_OPSIZE, /* 14491 */ + IC_VEX_L_W_OPSIZE, /* 14492 */ + IC_VEX_L_W_OPSIZE, /* 14493 */ + IC_VEX_L_W_OPSIZE, /* 14494 */ + IC_VEX_L_W_OPSIZE, /* 14495 */ + IC_VEX_L, /* 14496 */ + IC_VEX_L, /* 14497 */ + IC_VEX_L_XS, /* 14498 */ + IC_VEX_L_XS, /* 14499 */ + IC_VEX_L_XD, /* 14500 */ + IC_VEX_L_XD, /* 14501 */ + IC_VEX_L_XD, /* 14502 */ + IC_VEX_L_XD, /* 14503 */ + IC_VEX_L_W, /* 14504 */ + IC_VEX_L_W, /* 14505 */ + IC_VEX_L_W_XS, /* 14506 */ + IC_VEX_L_W_XS, /* 14507 */ + IC_VEX_L_W_XD, /* 14508 */ + IC_VEX_L_W_XD, /* 14509 */ + IC_VEX_L_W_XD, /* 14510 */ + IC_VEX_L_W_XD, /* 14511 */ + IC_VEX_L_OPSIZE, /* 14512 */ + IC_VEX_L_OPSIZE, /* 14513 */ + IC_VEX_L_OPSIZE, /* 14514 */ + IC_VEX_L_OPSIZE, /* 14515 */ + IC_VEX_L_OPSIZE, /* 14516 */ + IC_VEX_L_OPSIZE, /* 14517 */ + IC_VEX_L_OPSIZE, /* 14518 */ + IC_VEX_L_OPSIZE, /* 14519 */ + IC_VEX_L_W_OPSIZE, /* 14520 */ + IC_VEX_L_W_OPSIZE, /* 14521 */ + IC_VEX_L_W_OPSIZE, /* 14522 */ + IC_VEX_L_W_OPSIZE, /* 14523 */ + IC_VEX_L_W_OPSIZE, /* 14524 */ + IC_VEX_L_W_OPSIZE, /* 14525 */ + IC_VEX_L_W_OPSIZE, /* 14526 */ + IC_VEX_L_W_OPSIZE, /* 14527 */ + IC_VEX_L, /* 14528 */ + IC_VEX_L, /* 14529 */ + IC_VEX_L_XS, /* 14530 */ + IC_VEX_L_XS, /* 14531 */ + IC_VEX_L_XD, /* 14532 */ + IC_VEX_L_XD, /* 14533 */ + IC_VEX_L_XD, /* 14534 */ + IC_VEX_L_XD, /* 14535 */ + IC_VEX_L_W, /* 14536 */ + IC_VEX_L_W, /* 14537 */ + IC_VEX_L_W_XS, /* 14538 */ + IC_VEX_L_W_XS, /* 14539 */ + IC_VEX_L_W_XD, /* 14540 */ + IC_VEX_L_W_XD, /* 14541 */ + IC_VEX_L_W_XD, /* 14542 */ + IC_VEX_L_W_XD, /* 14543 */ + IC_VEX_L_OPSIZE, /* 14544 */ + IC_VEX_L_OPSIZE, /* 14545 */ + IC_VEX_L_OPSIZE, /* 14546 */ + IC_VEX_L_OPSIZE, /* 14547 */ + IC_VEX_L_OPSIZE, /* 14548 */ + IC_VEX_L_OPSIZE, /* 14549 */ + IC_VEX_L_OPSIZE, /* 14550 */ + IC_VEX_L_OPSIZE, /* 14551 */ + IC_VEX_L_W_OPSIZE, /* 14552 */ + IC_VEX_L_W_OPSIZE, /* 14553 */ + IC_VEX_L_W_OPSIZE, /* 14554 */ + IC_VEX_L_W_OPSIZE, /* 14555 */ + IC_VEX_L_W_OPSIZE, /* 14556 */ + IC_VEX_L_W_OPSIZE, /* 14557 */ + IC_VEX_L_W_OPSIZE, /* 14558 */ + IC_VEX_L_W_OPSIZE, /* 14559 */ + IC_VEX_L, /* 14560 */ + IC_VEX_L, /* 14561 */ + IC_VEX_L_XS, /* 14562 */ + IC_VEX_L_XS, /* 14563 */ + IC_VEX_L_XD, /* 14564 */ + IC_VEX_L_XD, /* 14565 */ + IC_VEX_L_XD, /* 14566 */ + IC_VEX_L_XD, /* 14567 */ + IC_VEX_L_W, /* 14568 */ + IC_VEX_L_W, /* 14569 */ + IC_VEX_L_W_XS, /* 14570 */ + IC_VEX_L_W_XS, /* 14571 */ + IC_VEX_L_W_XD, /* 14572 */ + IC_VEX_L_W_XD, /* 14573 */ + IC_VEX_L_W_XD, /* 14574 */ + IC_VEX_L_W_XD, /* 14575 */ + IC_VEX_L_OPSIZE, /* 14576 */ + IC_VEX_L_OPSIZE, /* 14577 */ + IC_VEX_L_OPSIZE, /* 14578 */ + IC_VEX_L_OPSIZE, /* 14579 */ + IC_VEX_L_OPSIZE, /* 14580 */ + IC_VEX_L_OPSIZE, /* 14581 */ + IC_VEX_L_OPSIZE, /* 14582 */ + IC_VEX_L_OPSIZE, /* 14583 */ + IC_VEX_L_W_OPSIZE, /* 14584 */ + IC_VEX_L_W_OPSIZE, /* 14585 */ + IC_VEX_L_W_OPSIZE, /* 14586 */ + IC_VEX_L_W_OPSIZE, /* 14587 */ + IC_VEX_L_W_OPSIZE, /* 14588 */ + IC_VEX_L_W_OPSIZE, /* 14589 */ + IC_VEX_L_W_OPSIZE, /* 14590 */ + IC_VEX_L_W_OPSIZE, /* 14591 */ + IC_EVEX_KZ_B, /* 14592 */ + IC_EVEX_KZ_B, /* 14593 */ + IC_EVEX_XS_KZ_B, /* 14594 */ + IC_EVEX_XS_KZ_B, /* 14595 */ + IC_EVEX_XD_KZ_B, /* 14596 */ + IC_EVEX_XD_KZ_B, /* 14597 */ + IC_EVEX_XD_KZ_B, /* 14598 */ + IC_EVEX_XD_KZ_B, /* 14599 */ + IC_EVEX_W_KZ_B, /* 14600 */ + IC_EVEX_W_KZ_B, /* 14601 */ + IC_EVEX_W_XS_KZ_B, /* 14602 */ + IC_EVEX_W_XS_KZ_B, /* 14603 */ + IC_EVEX_W_XD_KZ_B, /* 14604 */ + IC_EVEX_W_XD_KZ_B, /* 14605 */ + IC_EVEX_W_XD_KZ_B, /* 14606 */ + IC_EVEX_W_XD_KZ_B, /* 14607 */ + IC_EVEX_OPSIZE_KZ_B, /* 14608 */ + IC_EVEX_OPSIZE_KZ_B, /* 14609 */ + IC_EVEX_OPSIZE_KZ_B, /* 14610 */ + IC_EVEX_OPSIZE_KZ_B, /* 14611 */ + IC_EVEX_OPSIZE_KZ_B, /* 14612 */ + IC_EVEX_OPSIZE_KZ_B, /* 14613 */ + IC_EVEX_OPSIZE_KZ_B, /* 14614 */ + IC_EVEX_OPSIZE_KZ_B, /* 14615 */ + IC_EVEX_W_OPSIZE_KZ_B, /* 14616 */ + IC_EVEX_W_OPSIZE_KZ_B, /* 14617 */ + IC_EVEX_W_OPSIZE_KZ_B, /* 14618 */ + IC_EVEX_W_OPSIZE_KZ_B, /* 14619 */ + IC_EVEX_W_OPSIZE_KZ_B, /* 14620 */ + IC_EVEX_W_OPSIZE_KZ_B, /* 14621 */ + IC_EVEX_W_OPSIZE_KZ_B, /* 14622 */ + IC_EVEX_W_OPSIZE_KZ_B, /* 14623 */ + IC_EVEX_KZ_B, /* 14624 */ + IC_EVEX_KZ_B, /* 14625 */ + IC_EVEX_XS_KZ_B, /* 14626 */ + IC_EVEX_XS_KZ_B, /* 14627 */ + IC_EVEX_XD_KZ_B, /* 14628 */ + IC_EVEX_XD_KZ_B, /* 14629 */ + IC_EVEX_XD_KZ_B, /* 14630 */ + IC_EVEX_XD_KZ_B, /* 14631 */ + IC_EVEX_W_KZ_B, /* 14632 */ + IC_EVEX_W_KZ_B, /* 14633 */ + IC_EVEX_W_XS_KZ_B, /* 14634 */ + IC_EVEX_W_XS_KZ_B, /* 14635 */ + IC_EVEX_W_XD_KZ_B, /* 14636 */ + IC_EVEX_W_XD_KZ_B, /* 14637 */ + IC_EVEX_W_XD_KZ_B, /* 14638 */ + IC_EVEX_W_XD_KZ_B, /* 14639 */ + IC_EVEX_OPSIZE_KZ_B, /* 14640 */ + IC_EVEX_OPSIZE_KZ_B, /* 14641 */ + IC_EVEX_OPSIZE_KZ_B, /* 14642 */ + IC_EVEX_OPSIZE_KZ_B, /* 14643 */ + IC_EVEX_OPSIZE_KZ_B, /* 14644 */ + IC_EVEX_OPSIZE_KZ_B, /* 14645 */ + IC_EVEX_OPSIZE_KZ_B, /* 14646 */ + IC_EVEX_OPSIZE_KZ_B, /* 14647 */ + IC_EVEX_W_OPSIZE_KZ_B, /* 14648 */ + IC_EVEX_W_OPSIZE_KZ_B, /* 14649 */ + IC_EVEX_W_OPSIZE_KZ_B, /* 14650 */ + IC_EVEX_W_OPSIZE_KZ_B, /* 14651 */ + IC_EVEX_W_OPSIZE_KZ_B, /* 14652 */ + IC_EVEX_W_OPSIZE_KZ_B, /* 14653 */ + IC_EVEX_W_OPSIZE_KZ_B, /* 14654 */ + IC_EVEX_W_OPSIZE_KZ_B, /* 14655 */ + IC_EVEX_KZ_B, /* 14656 */ + IC_EVEX_KZ_B, /* 14657 */ + IC_EVEX_XS_KZ_B, /* 14658 */ + IC_EVEX_XS_KZ_B, /* 14659 */ + IC_EVEX_XD_KZ_B, /* 14660 */ + IC_EVEX_XD_KZ_B, /* 14661 */ + IC_EVEX_XD_KZ_B, /* 14662 */ + IC_EVEX_XD_KZ_B, /* 14663 */ + IC_EVEX_W_KZ_B, /* 14664 */ + IC_EVEX_W_KZ_B, /* 14665 */ + IC_EVEX_W_XS_KZ_B, /* 14666 */ + IC_EVEX_W_XS_KZ_B, /* 14667 */ + IC_EVEX_W_XD_KZ_B, /* 14668 */ + IC_EVEX_W_XD_KZ_B, /* 14669 */ + IC_EVEX_W_XD_KZ_B, /* 14670 */ + IC_EVEX_W_XD_KZ_B, /* 14671 */ + IC_EVEX_OPSIZE_KZ_B, /* 14672 */ + IC_EVEX_OPSIZE_KZ_B, /* 14673 */ + IC_EVEX_OPSIZE_KZ_B, /* 14674 */ + IC_EVEX_OPSIZE_KZ_B, /* 14675 */ + IC_EVEX_OPSIZE_KZ_B, /* 14676 */ + IC_EVEX_OPSIZE_KZ_B, /* 14677 */ + IC_EVEX_OPSIZE_KZ_B, /* 14678 */ + IC_EVEX_OPSIZE_KZ_B, /* 14679 */ + IC_EVEX_W_OPSIZE_KZ_B, /* 14680 */ + IC_EVEX_W_OPSIZE_KZ_B, /* 14681 */ + IC_EVEX_W_OPSIZE_KZ_B, /* 14682 */ + IC_EVEX_W_OPSIZE_KZ_B, /* 14683 */ + IC_EVEX_W_OPSIZE_KZ_B, /* 14684 */ + IC_EVEX_W_OPSIZE_KZ_B, /* 14685 */ + IC_EVEX_W_OPSIZE_KZ_B, /* 14686 */ + IC_EVEX_W_OPSIZE_KZ_B, /* 14687 */ + IC_EVEX_KZ_B, /* 14688 */ + IC_EVEX_KZ_B, /* 14689 */ + IC_EVEX_XS_KZ_B, /* 14690 */ + IC_EVEX_XS_KZ_B, /* 14691 */ + IC_EVEX_XD_KZ_B, /* 14692 */ + IC_EVEX_XD_KZ_B, /* 14693 */ + IC_EVEX_XD_KZ_B, /* 14694 */ + IC_EVEX_XD_KZ_B, /* 14695 */ + IC_EVEX_W_KZ_B, /* 14696 */ + IC_EVEX_W_KZ_B, /* 14697 */ + IC_EVEX_W_XS_KZ_B, /* 14698 */ + IC_EVEX_W_XS_KZ_B, /* 14699 */ + IC_EVEX_W_XD_KZ_B, /* 14700 */ + IC_EVEX_W_XD_KZ_B, /* 14701 */ + IC_EVEX_W_XD_KZ_B, /* 14702 */ + IC_EVEX_W_XD_KZ_B, /* 14703 */ + IC_EVEX_OPSIZE_KZ_B, /* 14704 */ + IC_EVEX_OPSIZE_KZ_B, /* 14705 */ + IC_EVEX_OPSIZE_KZ_B, /* 14706 */ + IC_EVEX_OPSIZE_KZ_B, /* 14707 */ + IC_EVEX_OPSIZE_KZ_B, /* 14708 */ + IC_EVEX_OPSIZE_KZ_B, /* 14709 */ + IC_EVEX_OPSIZE_KZ_B, /* 14710 */ + IC_EVEX_OPSIZE_KZ_B, /* 14711 */ + IC_EVEX_W_OPSIZE_KZ_B, /* 14712 */ + IC_EVEX_W_OPSIZE_KZ_B, /* 14713 */ + IC_EVEX_W_OPSIZE_KZ_B, /* 14714 */ + IC_EVEX_W_OPSIZE_KZ_B, /* 14715 */ + IC_EVEX_W_OPSIZE_KZ_B, /* 14716 */ + IC_EVEX_W_OPSIZE_KZ_B, /* 14717 */ + IC_EVEX_W_OPSIZE_KZ_B, /* 14718 */ + IC_EVEX_W_OPSIZE_KZ_B, /* 14719 */ + IC_EVEX_KZ_B, /* 14720 */ + IC_EVEX_KZ_B, /* 14721 */ + IC_EVEX_XS_KZ_B, /* 14722 */ + IC_EVEX_XS_KZ_B, /* 14723 */ + IC_EVEX_XD_KZ_B, /* 14724 */ + IC_EVEX_XD_KZ_B, /* 14725 */ + IC_EVEX_XD_KZ_B, /* 14726 */ + IC_EVEX_XD_KZ_B, /* 14727 */ + IC_EVEX_W_KZ_B, /* 14728 */ + IC_EVEX_W_KZ_B, /* 14729 */ + IC_EVEX_W_XS_KZ_B, /* 14730 */ + IC_EVEX_W_XS_KZ_B, /* 14731 */ + IC_EVEX_W_XD_KZ_B, /* 14732 */ + IC_EVEX_W_XD_KZ_B, /* 14733 */ + IC_EVEX_W_XD_KZ_B, /* 14734 */ + IC_EVEX_W_XD_KZ_B, /* 14735 */ + IC_EVEX_OPSIZE_KZ_B, /* 14736 */ + IC_EVEX_OPSIZE_KZ_B, /* 14737 */ + IC_EVEX_OPSIZE_KZ_B, /* 14738 */ + IC_EVEX_OPSIZE_KZ_B, /* 14739 */ + IC_EVEX_OPSIZE_KZ_B, /* 14740 */ + IC_EVEX_OPSIZE_KZ_B, /* 14741 */ + IC_EVEX_OPSIZE_KZ_B, /* 14742 */ + IC_EVEX_OPSIZE_KZ_B, /* 14743 */ + IC_EVEX_W_OPSIZE_KZ_B, /* 14744 */ + IC_EVEX_W_OPSIZE_KZ_B, /* 14745 */ + IC_EVEX_W_OPSIZE_KZ_B, /* 14746 */ + IC_EVEX_W_OPSIZE_KZ_B, /* 14747 */ + IC_EVEX_W_OPSIZE_KZ_B, /* 14748 */ + IC_EVEX_W_OPSIZE_KZ_B, /* 14749 */ + IC_EVEX_W_OPSIZE_KZ_B, /* 14750 */ + IC_EVEX_W_OPSIZE_KZ_B, /* 14751 */ + IC_EVEX_KZ_B, /* 14752 */ + IC_EVEX_KZ_B, /* 14753 */ + IC_EVEX_XS_KZ_B, /* 14754 */ + IC_EVEX_XS_KZ_B, /* 14755 */ + IC_EVEX_XD_KZ_B, /* 14756 */ + IC_EVEX_XD_KZ_B, /* 14757 */ + IC_EVEX_XD_KZ_B, /* 14758 */ + IC_EVEX_XD_KZ_B, /* 14759 */ + IC_EVEX_W_KZ_B, /* 14760 */ + IC_EVEX_W_KZ_B, /* 14761 */ + IC_EVEX_W_XS_KZ_B, /* 14762 */ + IC_EVEX_W_XS_KZ_B, /* 14763 */ + IC_EVEX_W_XD_KZ_B, /* 14764 */ + IC_EVEX_W_XD_KZ_B, /* 14765 */ + IC_EVEX_W_XD_KZ_B, /* 14766 */ + IC_EVEX_W_XD_KZ_B, /* 14767 */ + IC_EVEX_OPSIZE_KZ_B, /* 14768 */ + IC_EVEX_OPSIZE_KZ_B, /* 14769 */ + IC_EVEX_OPSIZE_KZ_B, /* 14770 */ + IC_EVEX_OPSIZE_KZ_B, /* 14771 */ + IC_EVEX_OPSIZE_KZ_B, /* 14772 */ + IC_EVEX_OPSIZE_KZ_B, /* 14773 */ + IC_EVEX_OPSIZE_KZ_B, /* 14774 */ + IC_EVEX_OPSIZE_KZ_B, /* 14775 */ + IC_EVEX_W_OPSIZE_KZ_B, /* 14776 */ + IC_EVEX_W_OPSIZE_KZ_B, /* 14777 */ + IC_EVEX_W_OPSIZE_KZ_B, /* 14778 */ + IC_EVEX_W_OPSIZE_KZ_B, /* 14779 */ + IC_EVEX_W_OPSIZE_KZ_B, /* 14780 */ + IC_EVEX_W_OPSIZE_KZ_B, /* 14781 */ + IC_EVEX_W_OPSIZE_KZ_B, /* 14782 */ + IC_EVEX_W_OPSIZE_KZ_B, /* 14783 */ + IC_EVEX_KZ_B, /* 14784 */ + IC_EVEX_KZ_B, /* 14785 */ + IC_EVEX_XS_KZ_B, /* 14786 */ + IC_EVEX_XS_KZ_B, /* 14787 */ + IC_EVEX_XD_KZ_B, /* 14788 */ + IC_EVEX_XD_KZ_B, /* 14789 */ + IC_EVEX_XD_KZ_B, /* 14790 */ + IC_EVEX_XD_KZ_B, /* 14791 */ + IC_EVEX_W_KZ_B, /* 14792 */ + IC_EVEX_W_KZ_B, /* 14793 */ + IC_EVEX_W_XS_KZ_B, /* 14794 */ + IC_EVEX_W_XS_KZ_B, /* 14795 */ + IC_EVEX_W_XD_KZ_B, /* 14796 */ + IC_EVEX_W_XD_KZ_B, /* 14797 */ + IC_EVEX_W_XD_KZ_B, /* 14798 */ + IC_EVEX_W_XD_KZ_B, /* 14799 */ + IC_EVEX_OPSIZE_KZ_B, /* 14800 */ + IC_EVEX_OPSIZE_KZ_B, /* 14801 */ + IC_EVEX_OPSIZE_KZ_B, /* 14802 */ + IC_EVEX_OPSIZE_KZ_B, /* 14803 */ + IC_EVEX_OPSIZE_KZ_B, /* 14804 */ + IC_EVEX_OPSIZE_KZ_B, /* 14805 */ + IC_EVEX_OPSIZE_KZ_B, /* 14806 */ + IC_EVEX_OPSIZE_KZ_B, /* 14807 */ + IC_EVEX_W_OPSIZE_KZ_B, /* 14808 */ + IC_EVEX_W_OPSIZE_KZ_B, /* 14809 */ + IC_EVEX_W_OPSIZE_KZ_B, /* 14810 */ + IC_EVEX_W_OPSIZE_KZ_B, /* 14811 */ + IC_EVEX_W_OPSIZE_KZ_B, /* 14812 */ + IC_EVEX_W_OPSIZE_KZ_B, /* 14813 */ + IC_EVEX_W_OPSIZE_KZ_B, /* 14814 */ + IC_EVEX_W_OPSIZE_KZ_B, /* 14815 */ + IC_EVEX_KZ_B, /* 14816 */ + IC_EVEX_KZ_B, /* 14817 */ + IC_EVEX_XS_KZ_B, /* 14818 */ + IC_EVEX_XS_KZ_B, /* 14819 */ + IC_EVEX_XD_KZ_B, /* 14820 */ + IC_EVEX_XD_KZ_B, /* 14821 */ + IC_EVEX_XD_KZ_B, /* 14822 */ + IC_EVEX_XD_KZ_B, /* 14823 */ + IC_EVEX_W_KZ_B, /* 14824 */ + IC_EVEX_W_KZ_B, /* 14825 */ + IC_EVEX_W_XS_KZ_B, /* 14826 */ + IC_EVEX_W_XS_KZ_B, /* 14827 */ + IC_EVEX_W_XD_KZ_B, /* 14828 */ + IC_EVEX_W_XD_KZ_B, /* 14829 */ + IC_EVEX_W_XD_KZ_B, /* 14830 */ + IC_EVEX_W_XD_KZ_B, /* 14831 */ + IC_EVEX_OPSIZE_KZ_B, /* 14832 */ + IC_EVEX_OPSIZE_KZ_B, /* 14833 */ + IC_EVEX_OPSIZE_KZ_B, /* 14834 */ + IC_EVEX_OPSIZE_KZ_B, /* 14835 */ + IC_EVEX_OPSIZE_KZ_B, /* 14836 */ + IC_EVEX_OPSIZE_KZ_B, /* 14837 */ + IC_EVEX_OPSIZE_KZ_B, /* 14838 */ + IC_EVEX_OPSIZE_KZ_B, /* 14839 */ + IC_EVEX_W_OPSIZE_KZ_B, /* 14840 */ + IC_EVEX_W_OPSIZE_KZ_B, /* 14841 */ + IC_EVEX_W_OPSIZE_KZ_B, /* 14842 */ + IC_EVEX_W_OPSIZE_KZ_B, /* 14843 */ + IC_EVEX_W_OPSIZE_KZ_B, /* 14844 */ + IC_EVEX_W_OPSIZE_KZ_B, /* 14845 */ + IC_EVEX_W_OPSIZE_KZ_B, /* 14846 */ + IC_EVEX_W_OPSIZE_KZ_B, /* 14847 */ + IC, /* 14848 */ + IC_64BIT, /* 14849 */ + IC_XS, /* 14850 */ + IC_64BIT_XS, /* 14851 */ + IC_XD, /* 14852 */ + IC_64BIT_XD, /* 14853 */ + IC_XS, /* 14854 */ + IC_64BIT_XS, /* 14855 */ + IC, /* 14856 */ + IC_64BIT_REXW, /* 14857 */ + IC_XS, /* 14858 */ + IC_64BIT_REXW_XS, /* 14859 */ + IC_XD, /* 14860 */ + IC_64BIT_REXW_XD, /* 14861 */ + IC_XS, /* 14862 */ + IC_64BIT_REXW_XS, /* 14863 */ + IC_OPSIZE, /* 14864 */ + IC_64BIT_OPSIZE, /* 14865 */ + IC_XS_OPSIZE, /* 14866 */ + IC_64BIT_XS_OPSIZE, /* 14867 */ + IC_XD_OPSIZE, /* 14868 */ + IC_64BIT_XD_OPSIZE, /* 14869 */ + IC_XS_OPSIZE, /* 14870 */ + IC_64BIT_XD_OPSIZE, /* 14871 */ + IC_OPSIZE, /* 14872 */ + IC_64BIT_REXW_OPSIZE, /* 14873 */ + IC_XS_OPSIZE, /* 14874 */ + IC_64BIT_REXW_XS, /* 14875 */ + IC_XD_OPSIZE, /* 14876 */ + IC_64BIT_REXW_XD, /* 14877 */ + IC_XS_OPSIZE, /* 14878 */ + IC_64BIT_REXW_XS, /* 14879 */ + IC_ADSIZE, /* 14880 */ + IC_64BIT_ADSIZE, /* 14881 */ + IC_XS_ADSIZE, /* 14882 */ + IC_64BIT_XS_ADSIZE, /* 14883 */ + IC_XD_ADSIZE, /* 14884 */ + IC_64BIT_XD_ADSIZE, /* 14885 */ + IC_XS_ADSIZE, /* 14886 */ + IC_64BIT_XD_ADSIZE, /* 14887 */ + IC_ADSIZE, /* 14888 */ + IC_64BIT_REXW_ADSIZE, /* 14889 */ + IC_XS_ADSIZE, /* 14890 */ + IC_64BIT_REXW_XS, /* 14891 */ + IC_XD_ADSIZE, /* 14892 */ + IC_64BIT_REXW_XD, /* 14893 */ + IC_XS_ADSIZE, /* 14894 */ + IC_64BIT_REXW_XS, /* 14895 */ + IC_OPSIZE_ADSIZE, /* 14896 */ + IC_64BIT_OPSIZE_ADSIZE, /* 14897 */ + IC_XS_OPSIZE, /* 14898 */ + IC_64BIT_XS_OPSIZE, /* 14899 */ + IC_XD_OPSIZE, /* 14900 */ + IC_64BIT_XD_OPSIZE, /* 14901 */ + IC_XS_OPSIZE, /* 14902 */ + IC_64BIT_XD_OPSIZE, /* 14903 */ + IC_OPSIZE_ADSIZE, /* 14904 */ + IC_64BIT_REXW_OPSIZE, /* 14905 */ + IC_XS_OPSIZE, /* 14906 */ + IC_64BIT_REXW_XS, /* 14907 */ + IC_XD_OPSIZE, /* 14908 */ + IC_64BIT_REXW_XD, /* 14909 */ + IC_XS_OPSIZE, /* 14910 */ + IC_64BIT_REXW_XS, /* 14911 */ + IC_VEX, /* 14912 */ + IC_VEX, /* 14913 */ + IC_VEX_XS, /* 14914 */ + IC_VEX_XS, /* 14915 */ + IC_VEX_XD, /* 14916 */ + IC_VEX_XD, /* 14917 */ + IC_VEX_XD, /* 14918 */ + IC_VEX_XD, /* 14919 */ + IC_VEX_W, /* 14920 */ + IC_VEX_W, /* 14921 */ + IC_VEX_W_XS, /* 14922 */ + IC_VEX_W_XS, /* 14923 */ + IC_VEX_W_XD, /* 14924 */ + IC_VEX_W_XD, /* 14925 */ + IC_VEX_W_XD, /* 14926 */ + IC_VEX_W_XD, /* 14927 */ + IC_VEX_OPSIZE, /* 14928 */ + IC_VEX_OPSIZE, /* 14929 */ + IC_VEX_OPSIZE, /* 14930 */ + IC_VEX_OPSIZE, /* 14931 */ + IC_VEX_OPSIZE, /* 14932 */ + IC_VEX_OPSIZE, /* 14933 */ + IC_VEX_OPSIZE, /* 14934 */ + IC_VEX_OPSIZE, /* 14935 */ + IC_VEX_W_OPSIZE, /* 14936 */ + IC_VEX_W_OPSIZE, /* 14937 */ + IC_VEX_W_OPSIZE, /* 14938 */ + IC_VEX_W_OPSIZE, /* 14939 */ + IC_VEX_W_OPSIZE, /* 14940 */ + IC_VEX_W_OPSIZE, /* 14941 */ + IC_VEX_W_OPSIZE, /* 14942 */ + IC_VEX_W_OPSIZE, /* 14943 */ + IC_VEX, /* 14944 */ + IC_VEX, /* 14945 */ + IC_VEX_XS, /* 14946 */ + IC_VEX_XS, /* 14947 */ + IC_VEX_XD, /* 14948 */ + IC_VEX_XD, /* 14949 */ + IC_VEX_XD, /* 14950 */ + IC_VEX_XD, /* 14951 */ + IC_VEX_W, /* 14952 */ + IC_VEX_W, /* 14953 */ + IC_VEX_W_XS, /* 14954 */ + IC_VEX_W_XS, /* 14955 */ + IC_VEX_W_XD, /* 14956 */ + IC_VEX_W_XD, /* 14957 */ + IC_VEX_W_XD, /* 14958 */ + IC_VEX_W_XD, /* 14959 */ + IC_VEX_OPSIZE, /* 14960 */ + IC_VEX_OPSIZE, /* 14961 */ + IC_VEX_OPSIZE, /* 14962 */ + IC_VEX_OPSIZE, /* 14963 */ + IC_VEX_OPSIZE, /* 14964 */ + IC_VEX_OPSIZE, /* 14965 */ + IC_VEX_OPSIZE, /* 14966 */ + IC_VEX_OPSIZE, /* 14967 */ + IC_VEX_W_OPSIZE, /* 14968 */ + IC_VEX_W_OPSIZE, /* 14969 */ + IC_VEX_W_OPSIZE, /* 14970 */ + IC_VEX_W_OPSIZE, /* 14971 */ + IC_VEX_W_OPSIZE, /* 14972 */ + IC_VEX_W_OPSIZE, /* 14973 */ + IC_VEX_W_OPSIZE, /* 14974 */ + IC_VEX_W_OPSIZE, /* 14975 */ + IC_VEX_L, /* 14976 */ + IC_VEX_L, /* 14977 */ + IC_VEX_L_XS, /* 14978 */ + IC_VEX_L_XS, /* 14979 */ + IC_VEX_L_XD, /* 14980 */ + IC_VEX_L_XD, /* 14981 */ + IC_VEX_L_XD, /* 14982 */ + IC_VEX_L_XD, /* 14983 */ + IC_VEX_L_W, /* 14984 */ + IC_VEX_L_W, /* 14985 */ + IC_VEX_L_W_XS, /* 14986 */ + IC_VEX_L_W_XS, /* 14987 */ + IC_VEX_L_W_XD, /* 14988 */ + IC_VEX_L_W_XD, /* 14989 */ + IC_VEX_L_W_XD, /* 14990 */ + IC_VEX_L_W_XD, /* 14991 */ + IC_VEX_L_OPSIZE, /* 14992 */ + IC_VEX_L_OPSIZE, /* 14993 */ + IC_VEX_L_OPSIZE, /* 14994 */ + IC_VEX_L_OPSIZE, /* 14995 */ + IC_VEX_L_OPSIZE, /* 14996 */ + IC_VEX_L_OPSIZE, /* 14997 */ + IC_VEX_L_OPSIZE, /* 14998 */ + IC_VEX_L_OPSIZE, /* 14999 */ + IC_VEX_L_W_OPSIZE, /* 15000 */ + IC_VEX_L_W_OPSIZE, /* 15001 */ + IC_VEX_L_W_OPSIZE, /* 15002 */ + IC_VEX_L_W_OPSIZE, /* 15003 */ + IC_VEX_L_W_OPSIZE, /* 15004 */ + IC_VEX_L_W_OPSIZE, /* 15005 */ + IC_VEX_L_W_OPSIZE, /* 15006 */ + IC_VEX_L_W_OPSIZE, /* 15007 */ + IC_VEX_L, /* 15008 */ + IC_VEX_L, /* 15009 */ + IC_VEX_L_XS, /* 15010 */ + IC_VEX_L_XS, /* 15011 */ + IC_VEX_L_XD, /* 15012 */ + IC_VEX_L_XD, /* 15013 */ + IC_VEX_L_XD, /* 15014 */ + IC_VEX_L_XD, /* 15015 */ + IC_VEX_L_W, /* 15016 */ + IC_VEX_L_W, /* 15017 */ + IC_VEX_L_W_XS, /* 15018 */ + IC_VEX_L_W_XS, /* 15019 */ + IC_VEX_L_W_XD, /* 15020 */ + IC_VEX_L_W_XD, /* 15021 */ + IC_VEX_L_W_XD, /* 15022 */ + IC_VEX_L_W_XD, /* 15023 */ + IC_VEX_L_OPSIZE, /* 15024 */ + IC_VEX_L_OPSIZE, /* 15025 */ + IC_VEX_L_OPSIZE, /* 15026 */ + IC_VEX_L_OPSIZE, /* 15027 */ + IC_VEX_L_OPSIZE, /* 15028 */ + IC_VEX_L_OPSIZE, /* 15029 */ + IC_VEX_L_OPSIZE, /* 15030 */ + IC_VEX_L_OPSIZE, /* 15031 */ + IC_VEX_L_W_OPSIZE, /* 15032 */ + IC_VEX_L_W_OPSIZE, /* 15033 */ + IC_VEX_L_W_OPSIZE, /* 15034 */ + IC_VEX_L_W_OPSIZE, /* 15035 */ + IC_VEX_L_W_OPSIZE, /* 15036 */ + IC_VEX_L_W_OPSIZE, /* 15037 */ + IC_VEX_L_W_OPSIZE, /* 15038 */ + IC_VEX_L_W_OPSIZE, /* 15039 */ + IC_VEX_L, /* 15040 */ + IC_VEX_L, /* 15041 */ + IC_VEX_L_XS, /* 15042 */ + IC_VEX_L_XS, /* 15043 */ + IC_VEX_L_XD, /* 15044 */ + IC_VEX_L_XD, /* 15045 */ + IC_VEX_L_XD, /* 15046 */ + IC_VEX_L_XD, /* 15047 */ + IC_VEX_L_W, /* 15048 */ + IC_VEX_L_W, /* 15049 */ + IC_VEX_L_W_XS, /* 15050 */ + IC_VEX_L_W_XS, /* 15051 */ + IC_VEX_L_W_XD, /* 15052 */ + IC_VEX_L_W_XD, /* 15053 */ + IC_VEX_L_W_XD, /* 15054 */ + IC_VEX_L_W_XD, /* 15055 */ + IC_VEX_L_OPSIZE, /* 15056 */ + IC_VEX_L_OPSIZE, /* 15057 */ + IC_VEX_L_OPSIZE, /* 15058 */ + IC_VEX_L_OPSIZE, /* 15059 */ + IC_VEX_L_OPSIZE, /* 15060 */ + IC_VEX_L_OPSIZE, /* 15061 */ + IC_VEX_L_OPSIZE, /* 15062 */ + IC_VEX_L_OPSIZE, /* 15063 */ + IC_VEX_L_W_OPSIZE, /* 15064 */ + IC_VEX_L_W_OPSIZE, /* 15065 */ + IC_VEX_L_W_OPSIZE, /* 15066 */ + IC_VEX_L_W_OPSIZE, /* 15067 */ + IC_VEX_L_W_OPSIZE, /* 15068 */ + IC_VEX_L_W_OPSIZE, /* 15069 */ + IC_VEX_L_W_OPSIZE, /* 15070 */ + IC_VEX_L_W_OPSIZE, /* 15071 */ + IC_VEX_L, /* 15072 */ + IC_VEX_L, /* 15073 */ + IC_VEX_L_XS, /* 15074 */ + IC_VEX_L_XS, /* 15075 */ + IC_VEX_L_XD, /* 15076 */ + IC_VEX_L_XD, /* 15077 */ + IC_VEX_L_XD, /* 15078 */ + IC_VEX_L_XD, /* 15079 */ + IC_VEX_L_W, /* 15080 */ + IC_VEX_L_W, /* 15081 */ + IC_VEX_L_W_XS, /* 15082 */ + IC_VEX_L_W_XS, /* 15083 */ + IC_VEX_L_W_XD, /* 15084 */ + IC_VEX_L_W_XD, /* 15085 */ + IC_VEX_L_W_XD, /* 15086 */ + IC_VEX_L_W_XD, /* 15087 */ + IC_VEX_L_OPSIZE, /* 15088 */ + IC_VEX_L_OPSIZE, /* 15089 */ + IC_VEX_L_OPSIZE, /* 15090 */ + IC_VEX_L_OPSIZE, /* 15091 */ + IC_VEX_L_OPSIZE, /* 15092 */ + IC_VEX_L_OPSIZE, /* 15093 */ + IC_VEX_L_OPSIZE, /* 15094 */ + IC_VEX_L_OPSIZE, /* 15095 */ + IC_VEX_L_W_OPSIZE, /* 15096 */ + IC_VEX_L_W_OPSIZE, /* 15097 */ + IC_VEX_L_W_OPSIZE, /* 15098 */ + IC_VEX_L_W_OPSIZE, /* 15099 */ + IC_VEX_L_W_OPSIZE, /* 15100 */ + IC_VEX_L_W_OPSIZE, /* 15101 */ + IC_VEX_L_W_OPSIZE, /* 15102 */ + IC_VEX_L_W_OPSIZE, /* 15103 */ + IC_EVEX_L_KZ_B, /* 15104 */ + IC_EVEX_L_KZ_B, /* 15105 */ + IC_EVEX_L_XS_KZ_B, /* 15106 */ + IC_EVEX_L_XS_KZ_B, /* 15107 */ + IC_EVEX_L_XD_KZ_B, /* 15108 */ + IC_EVEX_L_XD_KZ_B, /* 15109 */ + IC_EVEX_L_XD_KZ_B, /* 15110 */ + IC_EVEX_L_XD_KZ_B, /* 15111 */ + IC_EVEX_L_W_KZ_B, /* 15112 */ + IC_EVEX_L_W_KZ_B, /* 15113 */ + IC_EVEX_L_W_XS_KZ_B, /* 15114 */ + IC_EVEX_L_W_XS_KZ_B, /* 15115 */ + IC_EVEX_L_W_XD_KZ_B, /* 15116 */ + IC_EVEX_L_W_XD_KZ_B, /* 15117 */ + IC_EVEX_L_W_XD_KZ_B, /* 15118 */ + IC_EVEX_L_W_XD_KZ_B, /* 15119 */ + IC_EVEX_L_OPSIZE_KZ_B, /* 15120 */ + IC_EVEX_L_OPSIZE_KZ_B, /* 15121 */ + IC_EVEX_L_OPSIZE_KZ_B, /* 15122 */ + IC_EVEX_L_OPSIZE_KZ_B, /* 15123 */ + IC_EVEX_L_OPSIZE_KZ_B, /* 15124 */ + IC_EVEX_L_OPSIZE_KZ_B, /* 15125 */ + IC_EVEX_L_OPSIZE_KZ_B, /* 15126 */ + IC_EVEX_L_OPSIZE_KZ_B, /* 15127 */ + IC_EVEX_L_W_OPSIZE_KZ_B, /* 15128 */ + IC_EVEX_L_W_OPSIZE_KZ_B, /* 15129 */ + IC_EVEX_L_W_OPSIZE_KZ_B, /* 15130 */ + IC_EVEX_L_W_OPSIZE_KZ_B, /* 15131 */ + IC_EVEX_L_W_OPSIZE_KZ_B, /* 15132 */ + IC_EVEX_L_W_OPSIZE_KZ_B, /* 15133 */ + IC_EVEX_L_W_OPSIZE_KZ_B, /* 15134 */ + IC_EVEX_L_W_OPSIZE_KZ_B, /* 15135 */ + IC_EVEX_L_KZ_B, /* 15136 */ + IC_EVEX_L_KZ_B, /* 15137 */ + IC_EVEX_L_XS_KZ_B, /* 15138 */ + IC_EVEX_L_XS_KZ_B, /* 15139 */ + IC_EVEX_L_XD_KZ_B, /* 15140 */ + IC_EVEX_L_XD_KZ_B, /* 15141 */ + IC_EVEX_L_XD_KZ_B, /* 15142 */ + IC_EVEX_L_XD_KZ_B, /* 15143 */ + IC_EVEX_L_W_KZ_B, /* 15144 */ + IC_EVEX_L_W_KZ_B, /* 15145 */ + IC_EVEX_L_W_XS_KZ_B, /* 15146 */ + IC_EVEX_L_W_XS_KZ_B, /* 15147 */ + IC_EVEX_L_W_XD_KZ_B, /* 15148 */ + IC_EVEX_L_W_XD_KZ_B, /* 15149 */ + IC_EVEX_L_W_XD_KZ_B, /* 15150 */ + IC_EVEX_L_W_XD_KZ_B, /* 15151 */ + IC_EVEX_L_OPSIZE_KZ_B, /* 15152 */ + IC_EVEX_L_OPSIZE_KZ_B, /* 15153 */ + IC_EVEX_L_OPSIZE_KZ_B, /* 15154 */ + IC_EVEX_L_OPSIZE_KZ_B, /* 15155 */ + IC_EVEX_L_OPSIZE_KZ_B, /* 15156 */ + IC_EVEX_L_OPSIZE_KZ_B, /* 15157 */ + IC_EVEX_L_OPSIZE_KZ_B, /* 15158 */ + IC_EVEX_L_OPSIZE_KZ_B, /* 15159 */ + IC_EVEX_L_W_OPSIZE_KZ_B, /* 15160 */ + IC_EVEX_L_W_OPSIZE_KZ_B, /* 15161 */ + IC_EVEX_L_W_OPSIZE_KZ_B, /* 15162 */ + IC_EVEX_L_W_OPSIZE_KZ_B, /* 15163 */ + IC_EVEX_L_W_OPSIZE_KZ_B, /* 15164 */ + IC_EVEX_L_W_OPSIZE_KZ_B, /* 15165 */ + IC_EVEX_L_W_OPSIZE_KZ_B, /* 15166 */ + IC_EVEX_L_W_OPSIZE_KZ_B, /* 15167 */ + IC_EVEX_L_KZ_B, /* 15168 */ + IC_EVEX_L_KZ_B, /* 15169 */ + IC_EVEX_L_XS_KZ_B, /* 15170 */ + IC_EVEX_L_XS_KZ_B, /* 15171 */ + IC_EVEX_L_XD_KZ_B, /* 15172 */ + IC_EVEX_L_XD_KZ_B, /* 15173 */ + IC_EVEX_L_XD_KZ_B, /* 15174 */ + IC_EVEX_L_XD_KZ_B, /* 15175 */ + IC_EVEX_L_W_KZ_B, /* 15176 */ + IC_EVEX_L_W_KZ_B, /* 15177 */ + IC_EVEX_L_W_XS_KZ_B, /* 15178 */ + IC_EVEX_L_W_XS_KZ_B, /* 15179 */ + IC_EVEX_L_W_XD_KZ_B, /* 15180 */ + IC_EVEX_L_W_XD_KZ_B, /* 15181 */ + IC_EVEX_L_W_XD_KZ_B, /* 15182 */ + IC_EVEX_L_W_XD_KZ_B, /* 15183 */ + IC_EVEX_L_OPSIZE_KZ_B, /* 15184 */ + IC_EVEX_L_OPSIZE_KZ_B, /* 15185 */ + IC_EVEX_L_OPSIZE_KZ_B, /* 15186 */ + IC_EVEX_L_OPSIZE_KZ_B, /* 15187 */ + IC_EVEX_L_OPSIZE_KZ_B, /* 15188 */ + IC_EVEX_L_OPSIZE_KZ_B, /* 15189 */ + IC_EVEX_L_OPSIZE_KZ_B, /* 15190 */ + IC_EVEX_L_OPSIZE_KZ_B, /* 15191 */ + IC_EVEX_L_W_OPSIZE_KZ_B, /* 15192 */ + IC_EVEX_L_W_OPSIZE_KZ_B, /* 15193 */ + IC_EVEX_L_W_OPSIZE_KZ_B, /* 15194 */ + IC_EVEX_L_W_OPSIZE_KZ_B, /* 15195 */ + IC_EVEX_L_W_OPSIZE_KZ_B, /* 15196 */ + IC_EVEX_L_W_OPSIZE_KZ_B, /* 15197 */ + IC_EVEX_L_W_OPSIZE_KZ_B, /* 15198 */ + IC_EVEX_L_W_OPSIZE_KZ_B, /* 15199 */ + IC_EVEX_L_KZ_B, /* 15200 */ + IC_EVEX_L_KZ_B, /* 15201 */ + IC_EVEX_L_XS_KZ_B, /* 15202 */ + IC_EVEX_L_XS_KZ_B, /* 15203 */ + IC_EVEX_L_XD_KZ_B, /* 15204 */ + IC_EVEX_L_XD_KZ_B, /* 15205 */ + IC_EVEX_L_XD_KZ_B, /* 15206 */ + IC_EVEX_L_XD_KZ_B, /* 15207 */ + IC_EVEX_L_W_KZ_B, /* 15208 */ + IC_EVEX_L_W_KZ_B, /* 15209 */ + IC_EVEX_L_W_XS_KZ_B, /* 15210 */ + IC_EVEX_L_W_XS_KZ_B, /* 15211 */ + IC_EVEX_L_W_XD_KZ_B, /* 15212 */ + IC_EVEX_L_W_XD_KZ_B, /* 15213 */ + IC_EVEX_L_W_XD_KZ_B, /* 15214 */ + IC_EVEX_L_W_XD_KZ_B, /* 15215 */ + IC_EVEX_L_OPSIZE_KZ_B, /* 15216 */ + IC_EVEX_L_OPSIZE_KZ_B, /* 15217 */ + IC_EVEX_L_OPSIZE_KZ_B, /* 15218 */ + IC_EVEX_L_OPSIZE_KZ_B, /* 15219 */ + IC_EVEX_L_OPSIZE_KZ_B, /* 15220 */ + IC_EVEX_L_OPSIZE_KZ_B, /* 15221 */ + IC_EVEX_L_OPSIZE_KZ_B, /* 15222 */ + IC_EVEX_L_OPSIZE_KZ_B, /* 15223 */ + IC_EVEX_L_W_OPSIZE_KZ_B, /* 15224 */ + IC_EVEX_L_W_OPSIZE_KZ_B, /* 15225 */ + IC_EVEX_L_W_OPSIZE_KZ_B, /* 15226 */ + IC_EVEX_L_W_OPSIZE_KZ_B, /* 15227 */ + IC_EVEX_L_W_OPSIZE_KZ_B, /* 15228 */ + IC_EVEX_L_W_OPSIZE_KZ_B, /* 15229 */ + IC_EVEX_L_W_OPSIZE_KZ_B, /* 15230 */ + IC_EVEX_L_W_OPSIZE_KZ_B, /* 15231 */ + IC_EVEX_L_KZ_B, /* 15232 */ + IC_EVEX_L_KZ_B, /* 15233 */ + IC_EVEX_L_XS_KZ_B, /* 15234 */ + IC_EVEX_L_XS_KZ_B, /* 15235 */ + IC_EVEX_L_XD_KZ_B, /* 15236 */ + IC_EVEX_L_XD_KZ_B, /* 15237 */ + IC_EVEX_L_XD_KZ_B, /* 15238 */ + IC_EVEX_L_XD_KZ_B, /* 15239 */ + IC_EVEX_L_W_KZ_B, /* 15240 */ + IC_EVEX_L_W_KZ_B, /* 15241 */ + IC_EVEX_L_W_XS_KZ_B, /* 15242 */ + IC_EVEX_L_W_XS_KZ_B, /* 15243 */ + IC_EVEX_L_W_XD_KZ_B, /* 15244 */ + IC_EVEX_L_W_XD_KZ_B, /* 15245 */ + IC_EVEX_L_W_XD_KZ_B, /* 15246 */ + IC_EVEX_L_W_XD_KZ_B, /* 15247 */ + IC_EVEX_L_OPSIZE_KZ_B, /* 15248 */ + IC_EVEX_L_OPSIZE_KZ_B, /* 15249 */ + IC_EVEX_L_OPSIZE_KZ_B, /* 15250 */ + IC_EVEX_L_OPSIZE_KZ_B, /* 15251 */ + IC_EVEX_L_OPSIZE_KZ_B, /* 15252 */ + IC_EVEX_L_OPSIZE_KZ_B, /* 15253 */ + IC_EVEX_L_OPSIZE_KZ_B, /* 15254 */ + IC_EVEX_L_OPSIZE_KZ_B, /* 15255 */ + IC_EVEX_L_W_OPSIZE_KZ_B, /* 15256 */ + IC_EVEX_L_W_OPSIZE_KZ_B, /* 15257 */ + IC_EVEX_L_W_OPSIZE_KZ_B, /* 15258 */ + IC_EVEX_L_W_OPSIZE_KZ_B, /* 15259 */ + IC_EVEX_L_W_OPSIZE_KZ_B, /* 15260 */ + IC_EVEX_L_W_OPSIZE_KZ_B, /* 15261 */ + IC_EVEX_L_W_OPSIZE_KZ_B, /* 15262 */ + IC_EVEX_L_W_OPSIZE_KZ_B, /* 15263 */ + IC_EVEX_L_KZ_B, /* 15264 */ + IC_EVEX_L_KZ_B, /* 15265 */ + IC_EVEX_L_XS_KZ_B, /* 15266 */ + IC_EVEX_L_XS_KZ_B, /* 15267 */ + IC_EVEX_L_XD_KZ_B, /* 15268 */ + IC_EVEX_L_XD_KZ_B, /* 15269 */ + IC_EVEX_L_XD_KZ_B, /* 15270 */ + IC_EVEX_L_XD_KZ_B, /* 15271 */ + IC_EVEX_L_W_KZ_B, /* 15272 */ + IC_EVEX_L_W_KZ_B, /* 15273 */ + IC_EVEX_L_W_XS_KZ_B, /* 15274 */ + IC_EVEX_L_W_XS_KZ_B, /* 15275 */ + IC_EVEX_L_W_XD_KZ_B, /* 15276 */ + IC_EVEX_L_W_XD_KZ_B, /* 15277 */ + IC_EVEX_L_W_XD_KZ_B, /* 15278 */ + IC_EVEX_L_W_XD_KZ_B, /* 15279 */ + IC_EVEX_L_OPSIZE_KZ_B, /* 15280 */ + IC_EVEX_L_OPSIZE_KZ_B, /* 15281 */ + IC_EVEX_L_OPSIZE_KZ_B, /* 15282 */ + IC_EVEX_L_OPSIZE_KZ_B, /* 15283 */ + IC_EVEX_L_OPSIZE_KZ_B, /* 15284 */ + IC_EVEX_L_OPSIZE_KZ_B, /* 15285 */ + IC_EVEX_L_OPSIZE_KZ_B, /* 15286 */ + IC_EVEX_L_OPSIZE_KZ_B, /* 15287 */ + IC_EVEX_L_W_OPSIZE_KZ_B, /* 15288 */ + IC_EVEX_L_W_OPSIZE_KZ_B, /* 15289 */ + IC_EVEX_L_W_OPSIZE_KZ_B, /* 15290 */ + IC_EVEX_L_W_OPSIZE_KZ_B, /* 15291 */ + IC_EVEX_L_W_OPSIZE_KZ_B, /* 15292 */ + IC_EVEX_L_W_OPSIZE_KZ_B, /* 15293 */ + IC_EVEX_L_W_OPSIZE_KZ_B, /* 15294 */ + IC_EVEX_L_W_OPSIZE_KZ_B, /* 15295 */ + IC_EVEX_L_KZ_B, /* 15296 */ + IC_EVEX_L_KZ_B, /* 15297 */ + IC_EVEX_L_XS_KZ_B, /* 15298 */ + IC_EVEX_L_XS_KZ_B, /* 15299 */ + IC_EVEX_L_XD_KZ_B, /* 15300 */ + IC_EVEX_L_XD_KZ_B, /* 15301 */ + IC_EVEX_L_XD_KZ_B, /* 15302 */ + IC_EVEX_L_XD_KZ_B, /* 15303 */ + IC_EVEX_L_W_KZ_B, /* 15304 */ + IC_EVEX_L_W_KZ_B, /* 15305 */ + IC_EVEX_L_W_XS_KZ_B, /* 15306 */ + IC_EVEX_L_W_XS_KZ_B, /* 15307 */ + IC_EVEX_L_W_XD_KZ_B, /* 15308 */ + IC_EVEX_L_W_XD_KZ_B, /* 15309 */ + IC_EVEX_L_W_XD_KZ_B, /* 15310 */ + IC_EVEX_L_W_XD_KZ_B, /* 15311 */ + IC_EVEX_L_OPSIZE_KZ_B, /* 15312 */ + IC_EVEX_L_OPSIZE_KZ_B, /* 15313 */ + IC_EVEX_L_OPSIZE_KZ_B, /* 15314 */ + IC_EVEX_L_OPSIZE_KZ_B, /* 15315 */ + IC_EVEX_L_OPSIZE_KZ_B, /* 15316 */ + IC_EVEX_L_OPSIZE_KZ_B, /* 15317 */ + IC_EVEX_L_OPSIZE_KZ_B, /* 15318 */ + IC_EVEX_L_OPSIZE_KZ_B, /* 15319 */ + IC_EVEX_L_W_OPSIZE_KZ_B, /* 15320 */ + IC_EVEX_L_W_OPSIZE_KZ_B, /* 15321 */ + IC_EVEX_L_W_OPSIZE_KZ_B, /* 15322 */ + IC_EVEX_L_W_OPSIZE_KZ_B, /* 15323 */ + IC_EVEX_L_W_OPSIZE_KZ_B, /* 15324 */ + IC_EVEX_L_W_OPSIZE_KZ_B, /* 15325 */ + IC_EVEX_L_W_OPSIZE_KZ_B, /* 15326 */ + IC_EVEX_L_W_OPSIZE_KZ_B, /* 15327 */ + IC_EVEX_L_KZ_B, /* 15328 */ + IC_EVEX_L_KZ_B, /* 15329 */ + IC_EVEX_L_XS_KZ_B, /* 15330 */ + IC_EVEX_L_XS_KZ_B, /* 15331 */ + IC_EVEX_L_XD_KZ_B, /* 15332 */ + IC_EVEX_L_XD_KZ_B, /* 15333 */ + IC_EVEX_L_XD_KZ_B, /* 15334 */ + IC_EVEX_L_XD_KZ_B, /* 15335 */ + IC_EVEX_L_W_KZ_B, /* 15336 */ + IC_EVEX_L_W_KZ_B, /* 15337 */ + IC_EVEX_L_W_XS_KZ_B, /* 15338 */ + IC_EVEX_L_W_XS_KZ_B, /* 15339 */ + IC_EVEX_L_W_XD_KZ_B, /* 15340 */ + IC_EVEX_L_W_XD_KZ_B, /* 15341 */ + IC_EVEX_L_W_XD_KZ_B, /* 15342 */ + IC_EVEX_L_W_XD_KZ_B, /* 15343 */ + IC_EVEX_L_OPSIZE_KZ_B, /* 15344 */ + IC_EVEX_L_OPSIZE_KZ_B, /* 15345 */ + IC_EVEX_L_OPSIZE_KZ_B, /* 15346 */ + IC_EVEX_L_OPSIZE_KZ_B, /* 15347 */ + IC_EVEX_L_OPSIZE_KZ_B, /* 15348 */ + IC_EVEX_L_OPSIZE_KZ_B, /* 15349 */ + IC_EVEX_L_OPSIZE_KZ_B, /* 15350 */ + IC_EVEX_L_OPSIZE_KZ_B, /* 15351 */ + IC_EVEX_L_W_OPSIZE_KZ_B, /* 15352 */ + IC_EVEX_L_W_OPSIZE_KZ_B, /* 15353 */ + IC_EVEX_L_W_OPSIZE_KZ_B, /* 15354 */ + IC_EVEX_L_W_OPSIZE_KZ_B, /* 15355 */ + IC_EVEX_L_W_OPSIZE_KZ_B, /* 15356 */ + IC_EVEX_L_W_OPSIZE_KZ_B, /* 15357 */ + IC_EVEX_L_W_OPSIZE_KZ_B, /* 15358 */ + IC_EVEX_L_W_OPSIZE_KZ_B, /* 15359 */ + IC, /* 15360 */ + IC_64BIT, /* 15361 */ + IC_XS, /* 15362 */ + IC_64BIT_XS, /* 15363 */ + IC_XD, /* 15364 */ + IC_64BIT_XD, /* 15365 */ + IC_XS, /* 15366 */ + IC_64BIT_XS, /* 15367 */ + IC, /* 15368 */ + IC_64BIT_REXW, /* 15369 */ + IC_XS, /* 15370 */ + IC_64BIT_REXW_XS, /* 15371 */ + IC_XD, /* 15372 */ + IC_64BIT_REXW_XD, /* 15373 */ + IC_XS, /* 15374 */ + IC_64BIT_REXW_XS, /* 15375 */ + IC_OPSIZE, /* 15376 */ + IC_64BIT_OPSIZE, /* 15377 */ + IC_XS_OPSIZE, /* 15378 */ + IC_64BIT_XS_OPSIZE, /* 15379 */ + IC_XD_OPSIZE, /* 15380 */ + IC_64BIT_XD_OPSIZE, /* 15381 */ + IC_XS_OPSIZE, /* 15382 */ + IC_64BIT_XD_OPSIZE, /* 15383 */ + IC_OPSIZE, /* 15384 */ + IC_64BIT_REXW_OPSIZE, /* 15385 */ + IC_XS_OPSIZE, /* 15386 */ + IC_64BIT_REXW_XS, /* 15387 */ + IC_XD_OPSIZE, /* 15388 */ + IC_64BIT_REXW_XD, /* 15389 */ + IC_XS_OPSIZE, /* 15390 */ + IC_64BIT_REXW_XS, /* 15391 */ + IC_ADSIZE, /* 15392 */ + IC_64BIT_ADSIZE, /* 15393 */ + IC_XS_ADSIZE, /* 15394 */ + IC_64BIT_XS_ADSIZE, /* 15395 */ + IC_XD_ADSIZE, /* 15396 */ + IC_64BIT_XD_ADSIZE, /* 15397 */ + IC_XS_ADSIZE, /* 15398 */ + IC_64BIT_XD_ADSIZE, /* 15399 */ + IC_ADSIZE, /* 15400 */ + IC_64BIT_REXW_ADSIZE, /* 15401 */ + IC_XS_ADSIZE, /* 15402 */ + IC_64BIT_REXW_XS, /* 15403 */ + IC_XD_ADSIZE, /* 15404 */ + IC_64BIT_REXW_XD, /* 15405 */ + IC_XS_ADSIZE, /* 15406 */ + IC_64BIT_REXW_XS, /* 15407 */ + IC_OPSIZE_ADSIZE, /* 15408 */ + IC_64BIT_OPSIZE_ADSIZE, /* 15409 */ + IC_XS_OPSIZE, /* 15410 */ + IC_64BIT_XS_OPSIZE, /* 15411 */ + IC_XD_OPSIZE, /* 15412 */ + IC_64BIT_XD_OPSIZE, /* 15413 */ + IC_XS_OPSIZE, /* 15414 */ + IC_64BIT_XD_OPSIZE, /* 15415 */ + IC_OPSIZE_ADSIZE, /* 15416 */ + IC_64BIT_REXW_OPSIZE, /* 15417 */ + IC_XS_OPSIZE, /* 15418 */ + IC_64BIT_REXW_XS, /* 15419 */ + IC_XD_OPSIZE, /* 15420 */ + IC_64BIT_REXW_XD, /* 15421 */ + IC_XS_OPSIZE, /* 15422 */ + IC_64BIT_REXW_XS, /* 15423 */ + IC_VEX, /* 15424 */ + IC_VEX, /* 15425 */ + IC_VEX_XS, /* 15426 */ + IC_VEX_XS, /* 15427 */ + IC_VEX_XD, /* 15428 */ + IC_VEX_XD, /* 15429 */ + IC_VEX_XD, /* 15430 */ + IC_VEX_XD, /* 15431 */ + IC_VEX_W, /* 15432 */ + IC_VEX_W, /* 15433 */ + IC_VEX_W_XS, /* 15434 */ + IC_VEX_W_XS, /* 15435 */ + IC_VEX_W_XD, /* 15436 */ + IC_VEX_W_XD, /* 15437 */ + IC_VEX_W_XD, /* 15438 */ + IC_VEX_W_XD, /* 15439 */ + IC_VEX_OPSIZE, /* 15440 */ + IC_VEX_OPSIZE, /* 15441 */ + IC_VEX_OPSIZE, /* 15442 */ + IC_VEX_OPSIZE, /* 15443 */ + IC_VEX_OPSIZE, /* 15444 */ + IC_VEX_OPSIZE, /* 15445 */ + IC_VEX_OPSIZE, /* 15446 */ + IC_VEX_OPSIZE, /* 15447 */ + IC_VEX_W_OPSIZE, /* 15448 */ + IC_VEX_W_OPSIZE, /* 15449 */ + IC_VEX_W_OPSIZE, /* 15450 */ + IC_VEX_W_OPSIZE, /* 15451 */ + IC_VEX_W_OPSIZE, /* 15452 */ + IC_VEX_W_OPSIZE, /* 15453 */ + IC_VEX_W_OPSIZE, /* 15454 */ + IC_VEX_W_OPSIZE, /* 15455 */ + IC_VEX, /* 15456 */ + IC_VEX, /* 15457 */ + IC_VEX_XS, /* 15458 */ + IC_VEX_XS, /* 15459 */ + IC_VEX_XD, /* 15460 */ + IC_VEX_XD, /* 15461 */ + IC_VEX_XD, /* 15462 */ + IC_VEX_XD, /* 15463 */ + IC_VEX_W, /* 15464 */ + IC_VEX_W, /* 15465 */ + IC_VEX_W_XS, /* 15466 */ + IC_VEX_W_XS, /* 15467 */ + IC_VEX_W_XD, /* 15468 */ + IC_VEX_W_XD, /* 15469 */ + IC_VEX_W_XD, /* 15470 */ + IC_VEX_W_XD, /* 15471 */ + IC_VEX_OPSIZE, /* 15472 */ + IC_VEX_OPSIZE, /* 15473 */ + IC_VEX_OPSIZE, /* 15474 */ + IC_VEX_OPSIZE, /* 15475 */ + IC_VEX_OPSIZE, /* 15476 */ + IC_VEX_OPSIZE, /* 15477 */ + IC_VEX_OPSIZE, /* 15478 */ + IC_VEX_OPSIZE, /* 15479 */ + IC_VEX_W_OPSIZE, /* 15480 */ + IC_VEX_W_OPSIZE, /* 15481 */ + IC_VEX_W_OPSIZE, /* 15482 */ + IC_VEX_W_OPSIZE, /* 15483 */ + IC_VEX_W_OPSIZE, /* 15484 */ + IC_VEX_W_OPSIZE, /* 15485 */ + IC_VEX_W_OPSIZE, /* 15486 */ + IC_VEX_W_OPSIZE, /* 15487 */ + IC_VEX_L, /* 15488 */ + IC_VEX_L, /* 15489 */ + IC_VEX_L_XS, /* 15490 */ + IC_VEX_L_XS, /* 15491 */ + IC_VEX_L_XD, /* 15492 */ + IC_VEX_L_XD, /* 15493 */ + IC_VEX_L_XD, /* 15494 */ + IC_VEX_L_XD, /* 15495 */ + IC_VEX_L_W, /* 15496 */ + IC_VEX_L_W, /* 15497 */ + IC_VEX_L_W_XS, /* 15498 */ + IC_VEX_L_W_XS, /* 15499 */ + IC_VEX_L_W_XD, /* 15500 */ + IC_VEX_L_W_XD, /* 15501 */ + IC_VEX_L_W_XD, /* 15502 */ + IC_VEX_L_W_XD, /* 15503 */ + IC_VEX_L_OPSIZE, /* 15504 */ + IC_VEX_L_OPSIZE, /* 15505 */ + IC_VEX_L_OPSIZE, /* 15506 */ + IC_VEX_L_OPSIZE, /* 15507 */ + IC_VEX_L_OPSIZE, /* 15508 */ + IC_VEX_L_OPSIZE, /* 15509 */ + IC_VEX_L_OPSIZE, /* 15510 */ + IC_VEX_L_OPSIZE, /* 15511 */ + IC_VEX_L_W_OPSIZE, /* 15512 */ + IC_VEX_L_W_OPSIZE, /* 15513 */ + IC_VEX_L_W_OPSIZE, /* 15514 */ + IC_VEX_L_W_OPSIZE, /* 15515 */ + IC_VEX_L_W_OPSIZE, /* 15516 */ + IC_VEX_L_W_OPSIZE, /* 15517 */ + IC_VEX_L_W_OPSIZE, /* 15518 */ + IC_VEX_L_W_OPSIZE, /* 15519 */ + IC_VEX_L, /* 15520 */ + IC_VEX_L, /* 15521 */ + IC_VEX_L_XS, /* 15522 */ + IC_VEX_L_XS, /* 15523 */ + IC_VEX_L_XD, /* 15524 */ + IC_VEX_L_XD, /* 15525 */ + IC_VEX_L_XD, /* 15526 */ + IC_VEX_L_XD, /* 15527 */ + IC_VEX_L_W, /* 15528 */ + IC_VEX_L_W, /* 15529 */ + IC_VEX_L_W_XS, /* 15530 */ + IC_VEX_L_W_XS, /* 15531 */ + IC_VEX_L_W_XD, /* 15532 */ + IC_VEX_L_W_XD, /* 15533 */ + IC_VEX_L_W_XD, /* 15534 */ + IC_VEX_L_W_XD, /* 15535 */ + IC_VEX_L_OPSIZE, /* 15536 */ + IC_VEX_L_OPSIZE, /* 15537 */ + IC_VEX_L_OPSIZE, /* 15538 */ + IC_VEX_L_OPSIZE, /* 15539 */ + IC_VEX_L_OPSIZE, /* 15540 */ + IC_VEX_L_OPSIZE, /* 15541 */ + IC_VEX_L_OPSIZE, /* 15542 */ + IC_VEX_L_OPSIZE, /* 15543 */ + IC_VEX_L_W_OPSIZE, /* 15544 */ + IC_VEX_L_W_OPSIZE, /* 15545 */ + IC_VEX_L_W_OPSIZE, /* 15546 */ + IC_VEX_L_W_OPSIZE, /* 15547 */ + IC_VEX_L_W_OPSIZE, /* 15548 */ + IC_VEX_L_W_OPSIZE, /* 15549 */ + IC_VEX_L_W_OPSIZE, /* 15550 */ + IC_VEX_L_W_OPSIZE, /* 15551 */ + IC_VEX_L, /* 15552 */ + IC_VEX_L, /* 15553 */ + IC_VEX_L_XS, /* 15554 */ + IC_VEX_L_XS, /* 15555 */ + IC_VEX_L_XD, /* 15556 */ + IC_VEX_L_XD, /* 15557 */ + IC_VEX_L_XD, /* 15558 */ + IC_VEX_L_XD, /* 15559 */ + IC_VEX_L_W, /* 15560 */ + IC_VEX_L_W, /* 15561 */ + IC_VEX_L_W_XS, /* 15562 */ + IC_VEX_L_W_XS, /* 15563 */ + IC_VEX_L_W_XD, /* 15564 */ + IC_VEX_L_W_XD, /* 15565 */ + IC_VEX_L_W_XD, /* 15566 */ + IC_VEX_L_W_XD, /* 15567 */ + IC_VEX_L_OPSIZE, /* 15568 */ + IC_VEX_L_OPSIZE, /* 15569 */ + IC_VEX_L_OPSIZE, /* 15570 */ + IC_VEX_L_OPSIZE, /* 15571 */ + IC_VEX_L_OPSIZE, /* 15572 */ + IC_VEX_L_OPSIZE, /* 15573 */ + IC_VEX_L_OPSIZE, /* 15574 */ + IC_VEX_L_OPSIZE, /* 15575 */ + IC_VEX_L_W_OPSIZE, /* 15576 */ + IC_VEX_L_W_OPSIZE, /* 15577 */ + IC_VEX_L_W_OPSIZE, /* 15578 */ + IC_VEX_L_W_OPSIZE, /* 15579 */ + IC_VEX_L_W_OPSIZE, /* 15580 */ + IC_VEX_L_W_OPSIZE, /* 15581 */ + IC_VEX_L_W_OPSIZE, /* 15582 */ + IC_VEX_L_W_OPSIZE, /* 15583 */ + IC_VEX_L, /* 15584 */ + IC_VEX_L, /* 15585 */ + IC_VEX_L_XS, /* 15586 */ + IC_VEX_L_XS, /* 15587 */ + IC_VEX_L_XD, /* 15588 */ + IC_VEX_L_XD, /* 15589 */ + IC_VEX_L_XD, /* 15590 */ + IC_VEX_L_XD, /* 15591 */ + IC_VEX_L_W, /* 15592 */ + IC_VEX_L_W, /* 15593 */ + IC_VEX_L_W_XS, /* 15594 */ + IC_VEX_L_W_XS, /* 15595 */ + IC_VEX_L_W_XD, /* 15596 */ + IC_VEX_L_W_XD, /* 15597 */ + IC_VEX_L_W_XD, /* 15598 */ + IC_VEX_L_W_XD, /* 15599 */ + IC_VEX_L_OPSIZE, /* 15600 */ + IC_VEX_L_OPSIZE, /* 15601 */ + IC_VEX_L_OPSIZE, /* 15602 */ + IC_VEX_L_OPSIZE, /* 15603 */ + IC_VEX_L_OPSIZE, /* 15604 */ + IC_VEX_L_OPSIZE, /* 15605 */ + IC_VEX_L_OPSIZE, /* 15606 */ + IC_VEX_L_OPSIZE, /* 15607 */ + IC_VEX_L_W_OPSIZE, /* 15608 */ + IC_VEX_L_W_OPSIZE, /* 15609 */ + IC_VEX_L_W_OPSIZE, /* 15610 */ + IC_VEX_L_W_OPSIZE, /* 15611 */ + IC_VEX_L_W_OPSIZE, /* 15612 */ + IC_VEX_L_W_OPSIZE, /* 15613 */ + IC_VEX_L_W_OPSIZE, /* 15614 */ + IC_VEX_L_W_OPSIZE, /* 15615 */ + IC_EVEX_L2_KZ_B, /* 15616 */ + IC_EVEX_L2_KZ_B, /* 15617 */ + IC_EVEX_L2_XS_KZ_B, /* 15618 */ + IC_EVEX_L2_XS_KZ_B, /* 15619 */ + IC_EVEX_L2_XD_KZ_B, /* 15620 */ + IC_EVEX_L2_XD_KZ_B, /* 15621 */ + IC_EVEX_L2_XD_KZ_B, /* 15622 */ + IC_EVEX_L2_XD_KZ_B, /* 15623 */ + IC_EVEX_L2_W_KZ_B, /* 15624 */ + IC_EVEX_L2_W_KZ_B, /* 15625 */ + IC_EVEX_L2_W_XS_KZ_B, /* 15626 */ + IC_EVEX_L2_W_XS_KZ_B, /* 15627 */ + IC_EVEX_L2_W_XD_KZ_B, /* 15628 */ + IC_EVEX_L2_W_XD_KZ_B, /* 15629 */ + IC_EVEX_L2_W_XD_KZ_B, /* 15630 */ + IC_EVEX_L2_W_XD_KZ_B, /* 15631 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 15632 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 15633 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 15634 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 15635 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 15636 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 15637 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 15638 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 15639 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 15640 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 15641 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 15642 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 15643 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 15644 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 15645 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 15646 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 15647 */ + IC_EVEX_L2_KZ_B, /* 15648 */ + IC_EVEX_L2_KZ_B, /* 15649 */ + IC_EVEX_L2_XS_KZ_B, /* 15650 */ + IC_EVEX_L2_XS_KZ_B, /* 15651 */ + IC_EVEX_L2_XD_KZ_B, /* 15652 */ + IC_EVEX_L2_XD_KZ_B, /* 15653 */ + IC_EVEX_L2_XD_KZ_B, /* 15654 */ + IC_EVEX_L2_XD_KZ_B, /* 15655 */ + IC_EVEX_L2_W_KZ_B, /* 15656 */ + IC_EVEX_L2_W_KZ_B, /* 15657 */ + IC_EVEX_L2_W_XS_KZ_B, /* 15658 */ + IC_EVEX_L2_W_XS_KZ_B, /* 15659 */ + IC_EVEX_L2_W_XD_KZ_B, /* 15660 */ + IC_EVEX_L2_W_XD_KZ_B, /* 15661 */ + IC_EVEX_L2_W_XD_KZ_B, /* 15662 */ + IC_EVEX_L2_W_XD_KZ_B, /* 15663 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 15664 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 15665 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 15666 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 15667 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 15668 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 15669 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 15670 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 15671 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 15672 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 15673 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 15674 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 15675 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 15676 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 15677 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 15678 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 15679 */ + IC_EVEX_L2_KZ_B, /* 15680 */ + IC_EVEX_L2_KZ_B, /* 15681 */ + IC_EVEX_L2_XS_KZ_B, /* 15682 */ + IC_EVEX_L2_XS_KZ_B, /* 15683 */ + IC_EVEX_L2_XD_KZ_B, /* 15684 */ + IC_EVEX_L2_XD_KZ_B, /* 15685 */ + IC_EVEX_L2_XD_KZ_B, /* 15686 */ + IC_EVEX_L2_XD_KZ_B, /* 15687 */ + IC_EVEX_L2_W_KZ_B, /* 15688 */ + IC_EVEX_L2_W_KZ_B, /* 15689 */ + IC_EVEX_L2_W_XS_KZ_B, /* 15690 */ + IC_EVEX_L2_W_XS_KZ_B, /* 15691 */ + IC_EVEX_L2_W_XD_KZ_B, /* 15692 */ + IC_EVEX_L2_W_XD_KZ_B, /* 15693 */ + IC_EVEX_L2_W_XD_KZ_B, /* 15694 */ + IC_EVEX_L2_W_XD_KZ_B, /* 15695 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 15696 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 15697 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 15698 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 15699 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 15700 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 15701 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 15702 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 15703 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 15704 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 15705 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 15706 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 15707 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 15708 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 15709 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 15710 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 15711 */ + IC_EVEX_L2_KZ_B, /* 15712 */ + IC_EVEX_L2_KZ_B, /* 15713 */ + IC_EVEX_L2_XS_KZ_B, /* 15714 */ + IC_EVEX_L2_XS_KZ_B, /* 15715 */ + IC_EVEX_L2_XD_KZ_B, /* 15716 */ + IC_EVEX_L2_XD_KZ_B, /* 15717 */ + IC_EVEX_L2_XD_KZ_B, /* 15718 */ + IC_EVEX_L2_XD_KZ_B, /* 15719 */ + IC_EVEX_L2_W_KZ_B, /* 15720 */ + IC_EVEX_L2_W_KZ_B, /* 15721 */ + IC_EVEX_L2_W_XS_KZ_B, /* 15722 */ + IC_EVEX_L2_W_XS_KZ_B, /* 15723 */ + IC_EVEX_L2_W_XD_KZ_B, /* 15724 */ + IC_EVEX_L2_W_XD_KZ_B, /* 15725 */ + IC_EVEX_L2_W_XD_KZ_B, /* 15726 */ + IC_EVEX_L2_W_XD_KZ_B, /* 15727 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 15728 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 15729 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 15730 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 15731 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 15732 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 15733 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 15734 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 15735 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 15736 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 15737 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 15738 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 15739 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 15740 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 15741 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 15742 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 15743 */ + IC_EVEX_L2_KZ_B, /* 15744 */ + IC_EVEX_L2_KZ_B, /* 15745 */ + IC_EVEX_L2_XS_KZ_B, /* 15746 */ + IC_EVEX_L2_XS_KZ_B, /* 15747 */ + IC_EVEX_L2_XD_KZ_B, /* 15748 */ + IC_EVEX_L2_XD_KZ_B, /* 15749 */ + IC_EVEX_L2_XD_KZ_B, /* 15750 */ + IC_EVEX_L2_XD_KZ_B, /* 15751 */ + IC_EVEX_L2_W_KZ_B, /* 15752 */ + IC_EVEX_L2_W_KZ_B, /* 15753 */ + IC_EVEX_L2_W_XS_KZ_B, /* 15754 */ + IC_EVEX_L2_W_XS_KZ_B, /* 15755 */ + IC_EVEX_L2_W_XD_KZ_B, /* 15756 */ + IC_EVEX_L2_W_XD_KZ_B, /* 15757 */ + IC_EVEX_L2_W_XD_KZ_B, /* 15758 */ + IC_EVEX_L2_W_XD_KZ_B, /* 15759 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 15760 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 15761 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 15762 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 15763 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 15764 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 15765 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 15766 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 15767 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 15768 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 15769 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 15770 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 15771 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 15772 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 15773 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 15774 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 15775 */ + IC_EVEX_L2_KZ_B, /* 15776 */ + IC_EVEX_L2_KZ_B, /* 15777 */ + IC_EVEX_L2_XS_KZ_B, /* 15778 */ + IC_EVEX_L2_XS_KZ_B, /* 15779 */ + IC_EVEX_L2_XD_KZ_B, /* 15780 */ + IC_EVEX_L2_XD_KZ_B, /* 15781 */ + IC_EVEX_L2_XD_KZ_B, /* 15782 */ + IC_EVEX_L2_XD_KZ_B, /* 15783 */ + IC_EVEX_L2_W_KZ_B, /* 15784 */ + IC_EVEX_L2_W_KZ_B, /* 15785 */ + IC_EVEX_L2_W_XS_KZ_B, /* 15786 */ + IC_EVEX_L2_W_XS_KZ_B, /* 15787 */ + IC_EVEX_L2_W_XD_KZ_B, /* 15788 */ + IC_EVEX_L2_W_XD_KZ_B, /* 15789 */ + IC_EVEX_L2_W_XD_KZ_B, /* 15790 */ + IC_EVEX_L2_W_XD_KZ_B, /* 15791 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 15792 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 15793 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 15794 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 15795 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 15796 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 15797 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 15798 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 15799 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 15800 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 15801 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 15802 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 15803 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 15804 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 15805 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 15806 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 15807 */ + IC_EVEX_L2_KZ_B, /* 15808 */ + IC_EVEX_L2_KZ_B, /* 15809 */ + IC_EVEX_L2_XS_KZ_B, /* 15810 */ + IC_EVEX_L2_XS_KZ_B, /* 15811 */ + IC_EVEX_L2_XD_KZ_B, /* 15812 */ + IC_EVEX_L2_XD_KZ_B, /* 15813 */ + IC_EVEX_L2_XD_KZ_B, /* 15814 */ + IC_EVEX_L2_XD_KZ_B, /* 15815 */ + IC_EVEX_L2_W_KZ_B, /* 15816 */ + IC_EVEX_L2_W_KZ_B, /* 15817 */ + IC_EVEX_L2_W_XS_KZ_B, /* 15818 */ + IC_EVEX_L2_W_XS_KZ_B, /* 15819 */ + IC_EVEX_L2_W_XD_KZ_B, /* 15820 */ + IC_EVEX_L2_W_XD_KZ_B, /* 15821 */ + IC_EVEX_L2_W_XD_KZ_B, /* 15822 */ + IC_EVEX_L2_W_XD_KZ_B, /* 15823 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 15824 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 15825 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 15826 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 15827 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 15828 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 15829 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 15830 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 15831 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 15832 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 15833 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 15834 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 15835 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 15836 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 15837 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 15838 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 15839 */ + IC_EVEX_L2_KZ_B, /* 15840 */ + IC_EVEX_L2_KZ_B, /* 15841 */ + IC_EVEX_L2_XS_KZ_B, /* 15842 */ + IC_EVEX_L2_XS_KZ_B, /* 15843 */ + IC_EVEX_L2_XD_KZ_B, /* 15844 */ + IC_EVEX_L2_XD_KZ_B, /* 15845 */ + IC_EVEX_L2_XD_KZ_B, /* 15846 */ + IC_EVEX_L2_XD_KZ_B, /* 15847 */ + IC_EVEX_L2_W_KZ_B, /* 15848 */ + IC_EVEX_L2_W_KZ_B, /* 15849 */ + IC_EVEX_L2_W_XS_KZ_B, /* 15850 */ + IC_EVEX_L2_W_XS_KZ_B, /* 15851 */ + IC_EVEX_L2_W_XD_KZ_B, /* 15852 */ + IC_EVEX_L2_W_XD_KZ_B, /* 15853 */ + IC_EVEX_L2_W_XD_KZ_B, /* 15854 */ + IC_EVEX_L2_W_XD_KZ_B, /* 15855 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 15856 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 15857 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 15858 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 15859 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 15860 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 15861 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 15862 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 15863 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 15864 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 15865 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 15866 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 15867 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 15868 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 15869 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 15870 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 15871 */ + IC, /* 15872 */ + IC_64BIT, /* 15873 */ + IC_XS, /* 15874 */ + IC_64BIT_XS, /* 15875 */ + IC_XD, /* 15876 */ + IC_64BIT_XD, /* 15877 */ + IC_XS, /* 15878 */ + IC_64BIT_XS, /* 15879 */ + IC, /* 15880 */ + IC_64BIT_REXW, /* 15881 */ + IC_XS, /* 15882 */ + IC_64BIT_REXW_XS, /* 15883 */ + IC_XD, /* 15884 */ + IC_64BIT_REXW_XD, /* 15885 */ + IC_XS, /* 15886 */ + IC_64BIT_REXW_XS, /* 15887 */ + IC_OPSIZE, /* 15888 */ + IC_64BIT_OPSIZE, /* 15889 */ + IC_XS_OPSIZE, /* 15890 */ + IC_64BIT_XS_OPSIZE, /* 15891 */ + IC_XD_OPSIZE, /* 15892 */ + IC_64BIT_XD_OPSIZE, /* 15893 */ + IC_XS_OPSIZE, /* 15894 */ + IC_64BIT_XD_OPSIZE, /* 15895 */ + IC_OPSIZE, /* 15896 */ + IC_64BIT_REXW_OPSIZE, /* 15897 */ + IC_XS_OPSIZE, /* 15898 */ + IC_64BIT_REXW_XS, /* 15899 */ + IC_XD_OPSIZE, /* 15900 */ + IC_64BIT_REXW_XD, /* 15901 */ + IC_XS_OPSIZE, /* 15902 */ + IC_64BIT_REXW_XS, /* 15903 */ + IC_ADSIZE, /* 15904 */ + IC_64BIT_ADSIZE, /* 15905 */ + IC_XS_ADSIZE, /* 15906 */ + IC_64BIT_XS_ADSIZE, /* 15907 */ + IC_XD_ADSIZE, /* 15908 */ + IC_64BIT_XD_ADSIZE, /* 15909 */ + IC_XS_ADSIZE, /* 15910 */ + IC_64BIT_XD_ADSIZE, /* 15911 */ + IC_ADSIZE, /* 15912 */ + IC_64BIT_REXW_ADSIZE, /* 15913 */ + IC_XS_ADSIZE, /* 15914 */ + IC_64BIT_REXW_XS, /* 15915 */ + IC_XD_ADSIZE, /* 15916 */ + IC_64BIT_REXW_XD, /* 15917 */ + IC_XS_ADSIZE, /* 15918 */ + IC_64BIT_REXW_XS, /* 15919 */ + IC_OPSIZE_ADSIZE, /* 15920 */ + IC_64BIT_OPSIZE_ADSIZE, /* 15921 */ + IC_XS_OPSIZE, /* 15922 */ + IC_64BIT_XS_OPSIZE, /* 15923 */ + IC_XD_OPSIZE, /* 15924 */ + IC_64BIT_XD_OPSIZE, /* 15925 */ + IC_XS_OPSIZE, /* 15926 */ + IC_64BIT_XD_OPSIZE, /* 15927 */ + IC_OPSIZE_ADSIZE, /* 15928 */ + IC_64BIT_REXW_OPSIZE, /* 15929 */ + IC_XS_OPSIZE, /* 15930 */ + IC_64BIT_REXW_XS, /* 15931 */ + IC_XD_OPSIZE, /* 15932 */ + IC_64BIT_REXW_XD, /* 15933 */ + IC_XS_OPSIZE, /* 15934 */ + IC_64BIT_REXW_XS, /* 15935 */ + IC_VEX, /* 15936 */ + IC_VEX, /* 15937 */ + IC_VEX_XS, /* 15938 */ + IC_VEX_XS, /* 15939 */ + IC_VEX_XD, /* 15940 */ + IC_VEX_XD, /* 15941 */ + IC_VEX_XD, /* 15942 */ + IC_VEX_XD, /* 15943 */ + IC_VEX_W, /* 15944 */ + IC_VEX_W, /* 15945 */ + IC_VEX_W_XS, /* 15946 */ + IC_VEX_W_XS, /* 15947 */ + IC_VEX_W_XD, /* 15948 */ + IC_VEX_W_XD, /* 15949 */ + IC_VEX_W_XD, /* 15950 */ + IC_VEX_W_XD, /* 15951 */ + IC_VEX_OPSIZE, /* 15952 */ + IC_VEX_OPSIZE, /* 15953 */ + IC_VEX_OPSIZE, /* 15954 */ + IC_VEX_OPSIZE, /* 15955 */ + IC_VEX_OPSIZE, /* 15956 */ + IC_VEX_OPSIZE, /* 15957 */ + IC_VEX_OPSIZE, /* 15958 */ + IC_VEX_OPSIZE, /* 15959 */ + IC_VEX_W_OPSIZE, /* 15960 */ + IC_VEX_W_OPSIZE, /* 15961 */ + IC_VEX_W_OPSIZE, /* 15962 */ + IC_VEX_W_OPSIZE, /* 15963 */ + IC_VEX_W_OPSIZE, /* 15964 */ + IC_VEX_W_OPSIZE, /* 15965 */ + IC_VEX_W_OPSIZE, /* 15966 */ + IC_VEX_W_OPSIZE, /* 15967 */ + IC_VEX, /* 15968 */ + IC_VEX, /* 15969 */ + IC_VEX_XS, /* 15970 */ + IC_VEX_XS, /* 15971 */ + IC_VEX_XD, /* 15972 */ + IC_VEX_XD, /* 15973 */ + IC_VEX_XD, /* 15974 */ + IC_VEX_XD, /* 15975 */ + IC_VEX_W, /* 15976 */ + IC_VEX_W, /* 15977 */ + IC_VEX_W_XS, /* 15978 */ + IC_VEX_W_XS, /* 15979 */ + IC_VEX_W_XD, /* 15980 */ + IC_VEX_W_XD, /* 15981 */ + IC_VEX_W_XD, /* 15982 */ + IC_VEX_W_XD, /* 15983 */ + IC_VEX_OPSIZE, /* 15984 */ + IC_VEX_OPSIZE, /* 15985 */ + IC_VEX_OPSIZE, /* 15986 */ + IC_VEX_OPSIZE, /* 15987 */ + IC_VEX_OPSIZE, /* 15988 */ + IC_VEX_OPSIZE, /* 15989 */ + IC_VEX_OPSIZE, /* 15990 */ + IC_VEX_OPSIZE, /* 15991 */ + IC_VEX_W_OPSIZE, /* 15992 */ + IC_VEX_W_OPSIZE, /* 15993 */ + IC_VEX_W_OPSIZE, /* 15994 */ + IC_VEX_W_OPSIZE, /* 15995 */ + IC_VEX_W_OPSIZE, /* 15996 */ + IC_VEX_W_OPSIZE, /* 15997 */ + IC_VEX_W_OPSIZE, /* 15998 */ + IC_VEX_W_OPSIZE, /* 15999 */ + IC_VEX_L, /* 16000 */ + IC_VEX_L, /* 16001 */ + IC_VEX_L_XS, /* 16002 */ + IC_VEX_L_XS, /* 16003 */ + IC_VEX_L_XD, /* 16004 */ + IC_VEX_L_XD, /* 16005 */ + IC_VEX_L_XD, /* 16006 */ + IC_VEX_L_XD, /* 16007 */ + IC_VEX_L_W, /* 16008 */ + IC_VEX_L_W, /* 16009 */ + IC_VEX_L_W_XS, /* 16010 */ + IC_VEX_L_W_XS, /* 16011 */ + IC_VEX_L_W_XD, /* 16012 */ + IC_VEX_L_W_XD, /* 16013 */ + IC_VEX_L_W_XD, /* 16014 */ + IC_VEX_L_W_XD, /* 16015 */ + IC_VEX_L_OPSIZE, /* 16016 */ + IC_VEX_L_OPSIZE, /* 16017 */ + IC_VEX_L_OPSIZE, /* 16018 */ + IC_VEX_L_OPSIZE, /* 16019 */ + IC_VEX_L_OPSIZE, /* 16020 */ + IC_VEX_L_OPSIZE, /* 16021 */ + IC_VEX_L_OPSIZE, /* 16022 */ + IC_VEX_L_OPSIZE, /* 16023 */ + IC_VEX_L_W_OPSIZE, /* 16024 */ + IC_VEX_L_W_OPSIZE, /* 16025 */ + IC_VEX_L_W_OPSIZE, /* 16026 */ + IC_VEX_L_W_OPSIZE, /* 16027 */ + IC_VEX_L_W_OPSIZE, /* 16028 */ + IC_VEX_L_W_OPSIZE, /* 16029 */ + IC_VEX_L_W_OPSIZE, /* 16030 */ + IC_VEX_L_W_OPSIZE, /* 16031 */ + IC_VEX_L, /* 16032 */ + IC_VEX_L, /* 16033 */ + IC_VEX_L_XS, /* 16034 */ + IC_VEX_L_XS, /* 16035 */ + IC_VEX_L_XD, /* 16036 */ + IC_VEX_L_XD, /* 16037 */ + IC_VEX_L_XD, /* 16038 */ + IC_VEX_L_XD, /* 16039 */ + IC_VEX_L_W, /* 16040 */ + IC_VEX_L_W, /* 16041 */ + IC_VEX_L_W_XS, /* 16042 */ + IC_VEX_L_W_XS, /* 16043 */ + IC_VEX_L_W_XD, /* 16044 */ + IC_VEX_L_W_XD, /* 16045 */ + IC_VEX_L_W_XD, /* 16046 */ + IC_VEX_L_W_XD, /* 16047 */ + IC_VEX_L_OPSIZE, /* 16048 */ + IC_VEX_L_OPSIZE, /* 16049 */ + IC_VEX_L_OPSIZE, /* 16050 */ + IC_VEX_L_OPSIZE, /* 16051 */ + IC_VEX_L_OPSIZE, /* 16052 */ + IC_VEX_L_OPSIZE, /* 16053 */ + IC_VEX_L_OPSIZE, /* 16054 */ + IC_VEX_L_OPSIZE, /* 16055 */ + IC_VEX_L_W_OPSIZE, /* 16056 */ + IC_VEX_L_W_OPSIZE, /* 16057 */ + IC_VEX_L_W_OPSIZE, /* 16058 */ + IC_VEX_L_W_OPSIZE, /* 16059 */ + IC_VEX_L_W_OPSIZE, /* 16060 */ + IC_VEX_L_W_OPSIZE, /* 16061 */ + IC_VEX_L_W_OPSIZE, /* 16062 */ + IC_VEX_L_W_OPSIZE, /* 16063 */ + IC_VEX_L, /* 16064 */ + IC_VEX_L, /* 16065 */ + IC_VEX_L_XS, /* 16066 */ + IC_VEX_L_XS, /* 16067 */ + IC_VEX_L_XD, /* 16068 */ + IC_VEX_L_XD, /* 16069 */ + IC_VEX_L_XD, /* 16070 */ + IC_VEX_L_XD, /* 16071 */ + IC_VEX_L_W, /* 16072 */ + IC_VEX_L_W, /* 16073 */ + IC_VEX_L_W_XS, /* 16074 */ + IC_VEX_L_W_XS, /* 16075 */ + IC_VEX_L_W_XD, /* 16076 */ + IC_VEX_L_W_XD, /* 16077 */ + IC_VEX_L_W_XD, /* 16078 */ + IC_VEX_L_W_XD, /* 16079 */ + IC_VEX_L_OPSIZE, /* 16080 */ + IC_VEX_L_OPSIZE, /* 16081 */ + IC_VEX_L_OPSIZE, /* 16082 */ + IC_VEX_L_OPSIZE, /* 16083 */ + IC_VEX_L_OPSIZE, /* 16084 */ + IC_VEX_L_OPSIZE, /* 16085 */ + IC_VEX_L_OPSIZE, /* 16086 */ + IC_VEX_L_OPSIZE, /* 16087 */ + IC_VEX_L_W_OPSIZE, /* 16088 */ + IC_VEX_L_W_OPSIZE, /* 16089 */ + IC_VEX_L_W_OPSIZE, /* 16090 */ + IC_VEX_L_W_OPSIZE, /* 16091 */ + IC_VEX_L_W_OPSIZE, /* 16092 */ + IC_VEX_L_W_OPSIZE, /* 16093 */ + IC_VEX_L_W_OPSIZE, /* 16094 */ + IC_VEX_L_W_OPSIZE, /* 16095 */ + IC_VEX_L, /* 16096 */ + IC_VEX_L, /* 16097 */ + IC_VEX_L_XS, /* 16098 */ + IC_VEX_L_XS, /* 16099 */ + IC_VEX_L_XD, /* 16100 */ + IC_VEX_L_XD, /* 16101 */ + IC_VEX_L_XD, /* 16102 */ + IC_VEX_L_XD, /* 16103 */ + IC_VEX_L_W, /* 16104 */ + IC_VEX_L_W, /* 16105 */ + IC_VEX_L_W_XS, /* 16106 */ + IC_VEX_L_W_XS, /* 16107 */ + IC_VEX_L_W_XD, /* 16108 */ + IC_VEX_L_W_XD, /* 16109 */ + IC_VEX_L_W_XD, /* 16110 */ + IC_VEX_L_W_XD, /* 16111 */ + IC_VEX_L_OPSIZE, /* 16112 */ + IC_VEX_L_OPSIZE, /* 16113 */ + IC_VEX_L_OPSIZE, /* 16114 */ + IC_VEX_L_OPSIZE, /* 16115 */ + IC_VEX_L_OPSIZE, /* 16116 */ + IC_VEX_L_OPSIZE, /* 16117 */ + IC_VEX_L_OPSIZE, /* 16118 */ + IC_VEX_L_OPSIZE, /* 16119 */ + IC_VEX_L_W_OPSIZE, /* 16120 */ + IC_VEX_L_W_OPSIZE, /* 16121 */ + IC_VEX_L_W_OPSIZE, /* 16122 */ + IC_VEX_L_W_OPSIZE, /* 16123 */ + IC_VEX_L_W_OPSIZE, /* 16124 */ + IC_VEX_L_W_OPSIZE, /* 16125 */ + IC_VEX_L_W_OPSIZE, /* 16126 */ + IC_VEX_L_W_OPSIZE, /* 16127 */ + IC_EVEX_L2_KZ_B, /* 16128 */ + IC_EVEX_L2_KZ_B, /* 16129 */ + IC_EVEX_L2_XS_KZ_B, /* 16130 */ + IC_EVEX_L2_XS_KZ_B, /* 16131 */ + IC_EVEX_L2_XD_KZ_B, /* 16132 */ + IC_EVEX_L2_XD_KZ_B, /* 16133 */ + IC_EVEX_L2_XD_KZ_B, /* 16134 */ + IC_EVEX_L2_XD_KZ_B, /* 16135 */ + IC_EVEX_L2_W_KZ_B, /* 16136 */ + IC_EVEX_L2_W_KZ_B, /* 16137 */ + IC_EVEX_L2_W_XS_KZ_B, /* 16138 */ + IC_EVEX_L2_W_XS_KZ_B, /* 16139 */ + IC_EVEX_L2_W_XD_KZ_B, /* 16140 */ + IC_EVEX_L2_W_XD_KZ_B, /* 16141 */ + IC_EVEX_L2_W_XD_KZ_B, /* 16142 */ + IC_EVEX_L2_W_XD_KZ_B, /* 16143 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 16144 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 16145 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 16146 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 16147 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 16148 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 16149 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 16150 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 16151 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 16152 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 16153 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 16154 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 16155 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 16156 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 16157 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 16158 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 16159 */ + IC_EVEX_L2_KZ_B, /* 16160 */ + IC_EVEX_L2_KZ_B, /* 16161 */ + IC_EVEX_L2_XS_KZ_B, /* 16162 */ + IC_EVEX_L2_XS_KZ_B, /* 16163 */ + IC_EVEX_L2_XD_KZ_B, /* 16164 */ + IC_EVEX_L2_XD_KZ_B, /* 16165 */ + IC_EVEX_L2_XD_KZ_B, /* 16166 */ + IC_EVEX_L2_XD_KZ_B, /* 16167 */ + IC_EVEX_L2_W_KZ_B, /* 16168 */ + IC_EVEX_L2_W_KZ_B, /* 16169 */ + IC_EVEX_L2_W_XS_KZ_B, /* 16170 */ + IC_EVEX_L2_W_XS_KZ_B, /* 16171 */ + IC_EVEX_L2_W_XD_KZ_B, /* 16172 */ + IC_EVEX_L2_W_XD_KZ_B, /* 16173 */ + IC_EVEX_L2_W_XD_KZ_B, /* 16174 */ + IC_EVEX_L2_W_XD_KZ_B, /* 16175 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 16176 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 16177 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 16178 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 16179 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 16180 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 16181 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 16182 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 16183 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 16184 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 16185 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 16186 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 16187 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 16188 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 16189 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 16190 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 16191 */ + IC_EVEX_L2_KZ_B, /* 16192 */ + IC_EVEX_L2_KZ_B, /* 16193 */ + IC_EVEX_L2_XS_KZ_B, /* 16194 */ + IC_EVEX_L2_XS_KZ_B, /* 16195 */ + IC_EVEX_L2_XD_KZ_B, /* 16196 */ + IC_EVEX_L2_XD_KZ_B, /* 16197 */ + IC_EVEX_L2_XD_KZ_B, /* 16198 */ + IC_EVEX_L2_XD_KZ_B, /* 16199 */ + IC_EVEX_L2_W_KZ_B, /* 16200 */ + IC_EVEX_L2_W_KZ_B, /* 16201 */ + IC_EVEX_L2_W_XS_KZ_B, /* 16202 */ + IC_EVEX_L2_W_XS_KZ_B, /* 16203 */ + IC_EVEX_L2_W_XD_KZ_B, /* 16204 */ + IC_EVEX_L2_W_XD_KZ_B, /* 16205 */ + IC_EVEX_L2_W_XD_KZ_B, /* 16206 */ + IC_EVEX_L2_W_XD_KZ_B, /* 16207 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 16208 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 16209 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 16210 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 16211 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 16212 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 16213 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 16214 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 16215 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 16216 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 16217 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 16218 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 16219 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 16220 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 16221 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 16222 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 16223 */ + IC_EVEX_L2_KZ_B, /* 16224 */ + IC_EVEX_L2_KZ_B, /* 16225 */ + IC_EVEX_L2_XS_KZ_B, /* 16226 */ + IC_EVEX_L2_XS_KZ_B, /* 16227 */ + IC_EVEX_L2_XD_KZ_B, /* 16228 */ + IC_EVEX_L2_XD_KZ_B, /* 16229 */ + IC_EVEX_L2_XD_KZ_B, /* 16230 */ + IC_EVEX_L2_XD_KZ_B, /* 16231 */ + IC_EVEX_L2_W_KZ_B, /* 16232 */ + IC_EVEX_L2_W_KZ_B, /* 16233 */ + IC_EVEX_L2_W_XS_KZ_B, /* 16234 */ + IC_EVEX_L2_W_XS_KZ_B, /* 16235 */ + IC_EVEX_L2_W_XD_KZ_B, /* 16236 */ + IC_EVEX_L2_W_XD_KZ_B, /* 16237 */ + IC_EVEX_L2_W_XD_KZ_B, /* 16238 */ + IC_EVEX_L2_W_XD_KZ_B, /* 16239 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 16240 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 16241 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 16242 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 16243 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 16244 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 16245 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 16246 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 16247 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 16248 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 16249 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 16250 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 16251 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 16252 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 16253 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 16254 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 16255 */ + IC_EVEX_L2_KZ_B, /* 16256 */ + IC_EVEX_L2_KZ_B, /* 16257 */ + IC_EVEX_L2_XS_KZ_B, /* 16258 */ + IC_EVEX_L2_XS_KZ_B, /* 16259 */ + IC_EVEX_L2_XD_KZ_B, /* 16260 */ + IC_EVEX_L2_XD_KZ_B, /* 16261 */ + IC_EVEX_L2_XD_KZ_B, /* 16262 */ + IC_EVEX_L2_XD_KZ_B, /* 16263 */ + IC_EVEX_L2_W_KZ_B, /* 16264 */ + IC_EVEX_L2_W_KZ_B, /* 16265 */ + IC_EVEX_L2_W_XS_KZ_B, /* 16266 */ + IC_EVEX_L2_W_XS_KZ_B, /* 16267 */ + IC_EVEX_L2_W_XD_KZ_B, /* 16268 */ + IC_EVEX_L2_W_XD_KZ_B, /* 16269 */ + IC_EVEX_L2_W_XD_KZ_B, /* 16270 */ + IC_EVEX_L2_W_XD_KZ_B, /* 16271 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 16272 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 16273 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 16274 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 16275 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 16276 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 16277 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 16278 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 16279 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 16280 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 16281 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 16282 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 16283 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 16284 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 16285 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 16286 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 16287 */ + IC_EVEX_L2_KZ_B, /* 16288 */ + IC_EVEX_L2_KZ_B, /* 16289 */ + IC_EVEX_L2_XS_KZ_B, /* 16290 */ + IC_EVEX_L2_XS_KZ_B, /* 16291 */ + IC_EVEX_L2_XD_KZ_B, /* 16292 */ + IC_EVEX_L2_XD_KZ_B, /* 16293 */ + IC_EVEX_L2_XD_KZ_B, /* 16294 */ + IC_EVEX_L2_XD_KZ_B, /* 16295 */ + IC_EVEX_L2_W_KZ_B, /* 16296 */ + IC_EVEX_L2_W_KZ_B, /* 16297 */ + IC_EVEX_L2_W_XS_KZ_B, /* 16298 */ + IC_EVEX_L2_W_XS_KZ_B, /* 16299 */ + IC_EVEX_L2_W_XD_KZ_B, /* 16300 */ + IC_EVEX_L2_W_XD_KZ_B, /* 16301 */ + IC_EVEX_L2_W_XD_KZ_B, /* 16302 */ + IC_EVEX_L2_W_XD_KZ_B, /* 16303 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 16304 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 16305 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 16306 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 16307 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 16308 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 16309 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 16310 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 16311 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 16312 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 16313 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 16314 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 16315 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 16316 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 16317 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 16318 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 16319 */ + IC_EVEX_L2_KZ_B, /* 16320 */ + IC_EVEX_L2_KZ_B, /* 16321 */ + IC_EVEX_L2_XS_KZ_B, /* 16322 */ + IC_EVEX_L2_XS_KZ_B, /* 16323 */ + IC_EVEX_L2_XD_KZ_B, /* 16324 */ + IC_EVEX_L2_XD_KZ_B, /* 16325 */ + IC_EVEX_L2_XD_KZ_B, /* 16326 */ + IC_EVEX_L2_XD_KZ_B, /* 16327 */ + IC_EVEX_L2_W_KZ_B, /* 16328 */ + IC_EVEX_L2_W_KZ_B, /* 16329 */ + IC_EVEX_L2_W_XS_KZ_B, /* 16330 */ + IC_EVEX_L2_W_XS_KZ_B, /* 16331 */ + IC_EVEX_L2_W_XD_KZ_B, /* 16332 */ + IC_EVEX_L2_W_XD_KZ_B, /* 16333 */ + IC_EVEX_L2_W_XD_KZ_B, /* 16334 */ + IC_EVEX_L2_W_XD_KZ_B, /* 16335 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 16336 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 16337 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 16338 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 16339 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 16340 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 16341 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 16342 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 16343 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 16344 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 16345 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 16346 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 16347 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 16348 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 16349 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 16350 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 16351 */ + IC_EVEX_L2_KZ_B, /* 16352 */ + IC_EVEX_L2_KZ_B, /* 16353 */ + IC_EVEX_L2_XS_KZ_B, /* 16354 */ + IC_EVEX_L2_XS_KZ_B, /* 16355 */ + IC_EVEX_L2_XD_KZ_B, /* 16356 */ + IC_EVEX_L2_XD_KZ_B, /* 16357 */ + IC_EVEX_L2_XD_KZ_B, /* 16358 */ + IC_EVEX_L2_XD_KZ_B, /* 16359 */ + IC_EVEX_L2_W_KZ_B, /* 16360 */ + IC_EVEX_L2_W_KZ_B, /* 16361 */ + IC_EVEX_L2_W_XS_KZ_B, /* 16362 */ + IC_EVEX_L2_W_XS_KZ_B, /* 16363 */ + IC_EVEX_L2_W_XD_KZ_B, /* 16364 */ + IC_EVEX_L2_W_XD_KZ_B, /* 16365 */ + IC_EVEX_L2_W_XD_KZ_B, /* 16366 */ + IC_EVEX_L2_W_XD_KZ_B, /* 16367 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 16368 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 16369 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 16370 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 16371 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 16372 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 16373 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 16374 */ + IC_EVEX_L2_OPSIZE_KZ_B, /* 16375 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 16376 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 16377 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 16378 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 16379 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 16380 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 16381 */ + IC_EVEX_L2_W_OPSIZE_KZ_B, /* 16382 */ + IC_EVEX_L2_W_OPSIZE_KZ_B /* 16383 */ +}; + +static const InstrUID modRMTable[] = { +/* EmptyTable */ + 0x0, +/* Table1 */ + 0xc8, /* ADD8mr */ + 0xcc, /* ADD8rr */ +/* Table3 */ + 0xb6, /* ADD32mr */ + 0xba, /* ADD32rr */ +/* Table5 */ + 0xcb, /* ADD8rm */ + 0xcd, /* ADD8rr_REV */ +/* Table7 */ + 0xb9, /* ADD32rm */ + 0xbb, /* ADD32rr_REV */ +/* Table9 */ + 0xc5, /* ADD8i8 */ +/* Table10 */ + 0xb3, /* ADD32i32 */ +/* Table11 */ + 0x436, /* PUSHES32 */ +/* Table12 */ + 0x412, /* POPES32 */ +/* Table13 */ + 0x3ec, /* OR8mr */ + 0x3f0, /* OR8rr */ +/* Table15 */ + 0x3da, /* OR32mr */ + 0x3de, /* OR32rr */ +/* Table17 */ + 0x3ef, /* OR8rm */ + 0x3f1, /* OR8rr_REV */ +/* Table19 */ + 0x3dd, /* OR32rm */ + 0x3df, /* OR32rr_REV */ +/* Table21 */ + 0x3e9, /* OR8i8 */ +/* Table22 */ + 0x3d7, /* OR32i32 */ +/* Table23 */ + 0x432, /* PUSHCS32 */ +/* Table24 */ + 0xa0, /* ADC8mr */ + 0xa4, /* ADC8rr */ +/* Table26 */ + 0x8e, /* ADC32mr */ + 0x92, /* ADC32rr */ +/* Table28 */ + 0xa3, /* ADC8rm */ + 0xa5, /* ADC8rr_REV */ +/* Table30 */ + 0x91, /* ADC32rm */ + 0x93, /* ADC32rr_REV */ +/* Table32 */ + 0x9d, /* ADC8i8 */ +/* Table33 */ + 0x8b, /* ADC32i32 */ +/* Table34 */ + 0x441, /* PUSHSS32 */ +/* Table35 */ + 0x41d, /* POPSS32 */ +/* Table36 */ + 0x51b, /* SBB8mr */ + 0x51f, /* SBB8rr */ +/* Table38 */ + 0x509, /* SBB32mr */ + 0x50d, /* SBB32rr */ +/* Table40 */ + 0x51e, /* SBB8rm */ + 0x520, /* SBB8rr_REV */ +/* Table42 */ + 0x50c, /* SBB32rm */ + 0x50e, /* SBB32rr_REV */ +/* Table44 */ + 0x518, /* SBB8i8 */ +/* Table45 */ + 0x506, /* SBB32i32 */ +/* Table46 */ + 0x434, /* PUSHDS32 */ +/* Table47 */ + 0x410, /* POPDS32 */ +/* Table48 */ + 0xf0, /* AND8mr */ + 0xf4, /* AND8rr */ +/* Table50 */ + 0xde, /* AND32mr */ + 0xe2, /* AND32rr */ +/* Table52 */ + 0xf3, /* AND8rm */ + 0xf5, /* AND8rr_REV */ +/* Table54 */ + 0xe1, /* AND32rm */ + 0xe3, /* AND32rr_REV */ +/* Table56 */ + 0xed, /* AND8i8 */ +/* Table57 */ + 0xdb, /* AND32i32 */ +/* Table58 */ + 0x225, /* DAA */ +/* Table59 */ + 0x5d2, /* SUB8mr */ + 0x5d6, /* SUB8rr */ +/* Table61 */ + 0x5c0, /* SUB32mr */ + 0x5c4, /* SUB32rr */ +/* Table63 */ + 0x5d5, /* SUB8rm */ + 0x5d7, /* SUB8rr_REV */ +/* Table65 */ + 0x5c3, /* SUB32rm */ + 0x5c5, /* SUB32rr_REV */ +/* Table67 */ + 0x5cf, /* SUB8i8 */ +/* Table68 */ + 0x5bd, /* SUB32i32 */ +/* Table69 */ + 0x226, /* DAS */ +/* Table70 */ + 0x671, /* XOR8mr */ + 0x675, /* XOR8rr */ +/* Table72 */ + 0x65f, /* XOR32mr */ + 0x663, /* XOR32rr */ +/* Table74 */ + 0x674, /* XOR8rm */ + 0x676, /* XOR8rr_REV */ +/* Table76 */ + 0x662, /* XOR32rm */ + 0x664, /* XOR32rr_REV */ +/* Table78 */ + 0x66e, /* XOR8i8 */ +/* Table79 */ + 0x65c, /* XOR32i32 */ +/* Table80 */ + 0x7e, /* AAA */ +/* Table81 */ + 0x20d, /* CMP8mr */ + 0x211, /* CMP8rr */ +/* Table83 */ + 0x1fb, /* CMP32mr */ + 0x1ff, /* CMP32rr */ +/* Table85 */ + 0x210, /* CMP8rm */ + 0x212, /* CMP8rr_REV */ +/* Table87 */ + 0x1fe, /* CMP32rm */ + 0x200, /* CMP32rr_REV */ +/* Table89 */ + 0x20a, /* CMP8i8 */ +/* Table90 */ + 0x1f8, /* CMP32i32 */ +/* Table91 */ + 0x81, /* AAS */ +/* Table92 */ + 0x277, /* INC32r_alt */ +/* Table93 */ + 0x22d, /* DEC32r_alt */ +/* Table94 */ + 0x427, /* PUSH32r */ +/* Table95 */ + 0x407, /* POP32r */ +/* Table96 */ + 0x430, /* PUSHA32 */ +/* Table97 */ + 0x40e, /* POPA32 */ +/* Table98 */ + 0x12d, /* BOUNDS32rm */ + 0x0, /* */ +/* Table100 */ + 0xfa, /* ARPL16mr */ + 0xfb, /* ARPL16rr */ +/* Table102 */ + 0x227, /* DATA16_PREFIX */ +/* Table103 */ + 0x443, /* PUSHi32 */ +/* Table104 */ + 0x25d, /* IMUL32rmi */ + 0x260, /* IMUL32rri */ +/* Table106 */ + 0x426, /* PUSH32i8 */ +/* Table107 */ + 0x25e, /* IMUL32rmi8 */ + 0x261, /* IMUL32rri8 */ +/* Table109 */ + 0x27e, /* INSB */ +/* Table110 */ + 0x27f, /* INSL */ +/* Table111 */ + 0x3f8, /* OUTSB */ +/* Table112 */ + 0x3f9, /* OUTSL */ +/* Table113 */ + 0x2ca, /* JO_1 */ +/* Table114 */ + 0x2c1, /* JNO_1 */ +/* Table115 */ + 0x29b, /* JB_1 */ +/* Table116 */ + 0x292, /* JAE_1 */ +/* Table117 */ + 0x2a0, /* JE_1 */ +/* Table118 */ + 0x2be, /* JNE_1 */ +/* Table119 */ + 0x298, /* JBE_1 */ +/* Table120 */ + 0x295, /* JA_1 */ +/* Table121 */ + 0x2d1, /* JS_1 */ +/* Table122 */ + 0x2c7, /* JNS_1 */ +/* Table123 */ + 0x2cd, /* JP_1 */ +/* Table124 */ + 0x2c4, /* JNP_1 */ +/* Table125 */ + 0x2ac, /* JL_1 */ +/* Table126 */ + 0x2a3, /* JGE_1 */ +/* Table127 */ + 0x2a9, /* JLE_1 */ +/* Table128 */ + 0x2a6, /* JG_1 */ +/* Table129 */ + 0xc6, /* ADD8mi */ + 0x3ea, /* OR8mi */ + 0x9e, /* ADC8mi */ + 0x519, /* SBB8mi */ + 0xee, /* AND8mi */ + 0x5d0, /* SUB8mi */ + 0x66f, /* XOR8mi */ + 0x20b, /* CMP8mi */ + 0xc9, /* ADD8ri */ + 0x3ed, /* OR8ri */ + 0xa1, /* ADC8ri */ + 0x51c, /* SBB8ri */ + 0xf1, /* AND8ri */ + 0x5d3, /* SUB8ri */ + 0x672, /* XOR8ri */ + 0x20e, /* CMP8ri */ +/* Table145 */ + 0xb4, /* ADD32mi */ + 0x3d8, /* OR32mi */ + 0x8c, /* ADC32mi */ + 0x507, /* SBB32mi */ + 0xdc, /* AND32mi */ + 0x5be, /* SUB32mi */ + 0x65d, /* XOR32mi */ + 0x1f9, /* CMP32mi */ + 0xb7, /* ADD32ri */ + 0x3db, /* OR32ri */ + 0x8f, /* ADC32ri */ + 0x50a, /* SBB32ri */ + 0xdf, /* AND32ri */ + 0x5c1, /* SUB32ri */ + 0x660, /* XOR32ri */ + 0x1fc, /* CMP32ri */ +/* Table161 */ + 0xc7, /* ADD8mi8 */ + 0x3eb, /* OR8mi8 */ + 0x9f, /* ADC8mi8 */ + 0x51a, /* SBB8mi8 */ + 0xef, /* AND8mi8 */ + 0x5d1, /* SUB8mi8 */ + 0x670, /* XOR8mi8 */ + 0x20c, /* CMP8mi8 */ + 0xca, /* ADD8ri8 */ + 0x3ee, /* OR8ri8 */ + 0xa2, /* ADC8ri8 */ + 0x51d, /* SBB8ri8 */ + 0xf2, /* AND8ri8 */ + 0x5d4, /* SUB8ri8 */ + 0x673, /* XOR8ri8 */ + 0x20f, /* CMP8ri8 */ +/* Table177 */ + 0xb5, /* ADD32mi8 */ + 0x3d9, /* OR32mi8 */ + 0x8d, /* ADC32mi8 */ + 0x508, /* SBB32mi8 */ + 0xdd, /* AND32mi8 */ + 0x5bf, /* SUB32mi8 */ + 0x65e, /* XOR32mi8 */ + 0x1fa, /* CMP32mi8 */ + 0xb8, /* ADD32ri8 */ + 0x3dc, /* OR32ri8 */ + 0x90, /* ADC32ri8 */ + 0x50b, /* SBB32ri8 */ + 0xe0, /* AND32ri8 */ + 0x5c2, /* SUB32ri8 */ + 0x661, /* XOR32ri8 */ + 0x1fd, /* CMP32ri8 */ +/* Table193 */ + 0x5fb, /* TEST8mr */ + 0x5fe, /* TEST8rr */ +/* Table195 */ + 0x5ed, /* TEST32mr */ + 0x5f0, /* TEST32rr */ +/* Table197 */ + 0x64a, /* XCHG8rm */ + 0x64b, /* XCHG8rr */ +/* Table199 */ + 0x645, /* XCHG32rm */ + 0x646, /* XCHG32rr */ +/* Table201 */ + 0x359, /* MOV8mr */ + 0x362, /* MOV8rr */ +/* Table203 */ + 0x337, /* MOV32mr */ + 0x340, /* MOV32rr */ +/* Table205 */ + 0x360, /* MOV8rm */ + 0x364, /* MOV8rr_REV */ +/* Table207 */ + 0x33f, /* MOV32rm */ + 0x341, /* MOV32rr_REV */ +/* Table209 */ + 0x325, /* MOV16ms */ + 0x342, /* MOV32rs */ +/* Table211 */ + 0x2de, /* LEA32r */ + 0x0, /* */ +/* Table213 */ + 0x32f, /* MOV16sm */ + 0x343, /* MOV32sr */ +/* Table215 */ + 0x408, /* POP32rmm */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x409, /* POP32rmr */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ +/* Table231 */ + 0x3a7, /* NOOP */ +/* Table232 */ + 0x644, /* XCHG32ar */ +/* Table233 */ + 0x224, /* CWDE */ +/* Table234 */ + 0x181, /* CDQ */ +/* Table235 */ + 0x23f, /* FARCALL32i */ +/* Table236 */ + 0x438, /* PUSHF32 */ +/* Table237 */ + 0x414, /* POPF32 */ +/* Table238 */ + 0x4c6, /* SAHF */ +/* Table239 */ + 0x2d4, /* LAHF */ +/* Table240 */ + 0x356, /* MOV8ao32 */ +/* Table241 */ + 0x332, /* MOV32ao32 */ +/* Table242 */ + 0x35c, /* MOV8o32a */ +/* Table243 */ + 0x339, /* MOV32o32a */ +/* Table244 */ + 0x370, /* MOVSB */ +/* Table245 */ + 0x371, /* MOVSL */ +/* Table246 */ + 0x213, /* CMPSB */ +/* Table247 */ + 0x214, /* CMPSL */ +/* Table248 */ + 0x5f8, /* TEST8i8 */ +/* Table249 */ + 0x5ea, /* TEST32i32 */ +/* Table250 */ + 0x5ac, /* STOSB */ +/* Table251 */ + 0x5ad, /* STOSL */ +/* Table252 */ + 0x2f8, /* LODSB */ +/* Table253 */ + 0x2f9, /* LODSL */ +/* Table254 */ + 0x521, /* SCASB */ +/* Table255 */ + 0x522, /* SCASL */ +/* Table256 */ + 0x35e, /* MOV8ri */ +/* Table257 */ + 0x33d, /* MOV32ri */ +/* Table258 */ + 0x4a4, /* ROL8mi */ + 0x4bc, /* ROR8mi */ + 0x458, /* RCL8mi */ + 0x470, /* RCR8mi */ + 0x55d, /* SHL8mi */ + 0x585, /* SHR8mi */ + 0x4db, /* SAL8mi */ + 0x4f4, /* SAR8mi */ + 0x4a7, /* ROL8ri */ + 0x4bf, /* ROR8ri */ + 0x45b, /* RCL8ri */ + 0x473, /* RCR8ri */ + 0x560, /* SHL8ri */ + 0x588, /* SHR8ri */ + 0x4de, /* SAL8ri */ + 0x4f7, /* SAR8ri */ +/* Table274 */ + 0x498, /* ROL32mi */ + 0x4b0, /* ROR32mi */ + 0x44c, /* RCL32mi */ + 0x464, /* RCR32mi */ + 0x551, /* SHL32mi */ + 0x579, /* SHR32mi */ + 0x4cf, /* SAL32mi */ + 0x4e8, /* SAR32mi */ + 0x49b, /* ROL32ri */ + 0x4b3, /* ROR32ri */ + 0x44f, /* RCL32ri */ + 0x467, /* RCR32ri */ + 0x554, /* SHL32ri */ + 0x57c, /* SHR32ri */ + 0x4d2, /* SAL32ri */ + 0x4eb, /* SAR32ri */ +/* Table290 */ + 0x489, /* RETIL */ +/* Table291 */ + 0x48c, /* RETL */ +/* Table292 */ + 0x2e4, /* LES32rm */ + 0x0, /* */ +/* Table294 */ + 0x2dc, /* LDS32rm */ + 0x0, /* */ +/* Table296 */ + 0x358, /* MOV8mi */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x35f, /* MOV8ri_alt */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ +/* Table312 */ + 0x336, /* MOV32mi */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x33e, /* MOV32ri_alt */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ +/* Table328 */ + 0x23c, /* ENTER */ +/* Table329 */ + 0x2e1, /* LEAVE */ +/* Table330 */ + 0x2ff, /* LRETIL */ +/* Table331 */ + 0x302, /* LRETL */ +/* Table332 */ + 0x283, /* INT3 */ +/* Table333 */ + 0x281, /* INT */ +/* Table334 */ + 0x284, /* INTO */ +/* Table335 */ + 0x290, /* IRET32 */ +/* Table336 */ + 0x4a2, /* ROL8m1 */ + 0x4ba, /* ROR8m1 */ + 0x456, /* RCL8m1 */ + 0x46e, /* RCR8m1 */ + 0x55b, /* SHL8m1 */ + 0x583, /* SHR8m1 */ + 0x4d9, /* SAL8m1 */ + 0x4f2, /* SAR8m1 */ + 0x4a5, /* ROL8r1 */ + 0x4bd, /* ROR8r1 */ + 0x459, /* RCL8r1 */ + 0x471, /* RCR8r1 */ + 0x55e, /* SHL8r1 */ + 0x586, /* SHR8r1 */ + 0x4dc, /* SAL8r1 */ + 0x4f5, /* SAR8r1 */ +/* Table352 */ + 0x496, /* ROL32m1 */ + 0x4ae, /* ROR32m1 */ + 0x44a, /* RCL32m1 */ + 0x462, /* RCR32m1 */ + 0x54f, /* SHL32m1 */ + 0x577, /* SHR32m1 */ + 0x4cd, /* SAL32m1 */ + 0x4e6, /* SAR32m1 */ + 0x499, /* ROL32r1 */ + 0x4b1, /* ROR32r1 */ + 0x44d, /* RCL32r1 */ + 0x465, /* RCR32r1 */ + 0x552, /* SHL32r1 */ + 0x57a, /* SHR32r1 */ + 0x4d0, /* SAL32r1 */ + 0x4e9, /* SAR32r1 */ +/* Table368 */ + 0x4a3, /* ROL8mCL */ + 0x4bb, /* ROR8mCL */ + 0x457, /* RCL8mCL */ + 0x46f, /* RCR8mCL */ + 0x55c, /* SHL8mCL */ + 0x584, /* SHR8mCL */ + 0x4da, /* SAL8mCL */ + 0x4f3, /* SAR8mCL */ + 0x4a6, /* ROL8rCL */ + 0x4be, /* ROR8rCL */ + 0x45a, /* RCL8rCL */ + 0x472, /* RCR8rCL */ + 0x55f, /* SHL8rCL */ + 0x587, /* SHR8rCL */ + 0x4dd, /* SAL8rCL */ + 0x4f6, /* SAR8rCL */ +/* Table384 */ + 0x497, /* ROL32mCL */ + 0x4af, /* ROR32mCL */ + 0x44b, /* RCL32mCL */ + 0x463, /* RCR32mCL */ + 0x550, /* SHL32mCL */ + 0x578, /* SHR32mCL */ + 0x4ce, /* SAL32mCL */ + 0x4e7, /* SAR32mCL */ + 0x49a, /* ROL32rCL */ + 0x4b2, /* ROR32rCL */ + 0x44e, /* RCL32rCL */ + 0x466, /* RCR32rCL */ + 0x553, /* SHL32rCL */ + 0x57b, /* SHR32rCL */ + 0x4d1, /* SAL32rCL */ + 0x4ea, /* SAR32rCL */ +/* Table400 */ + 0x80, /* AAM8i8 */ +/* Table401 */ + 0x7f, /* AAD8i8 */ +/* Table402 */ + 0x4df, /* SALC */ +/* Table403 */ + 0x652, /* XLAT */ +/* Table404 */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x247, /* FSETPM */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ +/* Table476 */ + 0x2fe, /* LOOPNE */ +/* Table477 */ + 0x2fd, /* LOOPE */ +/* Table478 */ + 0x2fc, /* LOOP */ +/* Table479 */ + 0x29f, /* JECXZ */ +/* Table480 */ + 0x270, /* IN8ri */ +/* Table481 */ + 0x26e, /* IN32ri */ +/* Table482 */ + 0x3f6, /* OUT8ir */ +/* Table483 */ + 0x3f4, /* OUT32ir */ +/* Table484 */ + 0x17f, /* CALLpcrel32 */ +/* Table485 */ + 0x2bd, /* JMP_4 */ +/* Table486 */ + 0x244, /* FARJMP32i */ +/* Table487 */ + 0x2bb, /* JMP_1 */ +/* Table488 */ + 0x271, /* IN8rr */ +/* Table489 */ + 0x26f, /* IN32rr */ +/* Table490 */ + 0x3f7, /* OUT8rr */ +/* Table491 */ + 0x3f5, /* OUT32rr */ +/* Table492 */ + 0x2f7, /* LOCK_PREFIX */ +/* Table493 */ + 0x282, /* INT1 */ +/* Table494 */ + 0x487, /* REPNE_PREFIX */ +/* Table495 */ + 0x488, /* REP_PREFIX */ +/* Table496 */ + 0x249, /* HLT */ +/* Table497 */ + 0x18e, /* CMC */ +/* Table498 */ + 0x5f9, /* TEST8mi */ + 0x5fa, /* TEST8mi_alt */ + 0x3cc, /* NOT8m */ + 0x3a5, /* NEG8m */ + 0x398, /* MUL8m */ + 0x26a, /* IMUL8m */ + 0x238, /* DIV8m */ + 0x250, /* IDIV8m */ + 0x5fc, /* TEST8ri */ + 0x5fd, /* TEST8ri_alt */ + 0x3cd, /* NOT8r */ + 0x3a6, /* NEG8r */ + 0x399, /* MUL8r */ + 0x26b, /* IMUL8r */ + 0x239, /* DIV8r */ + 0x251, /* IDIV8r */ +/* Table514 */ + 0x5eb, /* TEST32mi */ + 0x5ec, /* TEST32mi_alt */ + 0x3c8, /* NOT32m */ + 0x3a1, /* NEG32m */ + 0x394, /* MUL32m */ + 0x25a, /* IMUL32m */ + 0x234, /* DIV32m */ + 0x24c, /* IDIV32m */ + 0x5ee, /* TEST32ri */ + 0x5ef, /* TEST32ri_alt */ + 0x3c9, /* NOT32r */ + 0x3a2, /* NEG32r */ + 0x395, /* MUL32r */ + 0x25b, /* IMUL32r */ + 0x235, /* DIV32r */ + 0x24d, /* IDIV32r */ +/* Table530 */ + 0x184, /* CLC */ +/* Table531 */ + 0x5a8, /* STC */ +/* Table532 */ + 0x189, /* CLI */ +/* Table533 */ + 0x5ab, /* STI */ +/* Table534 */ + 0x185, /* CLD */ +/* Table535 */ + 0x5a9, /* STD */ +/* Table536 */ + 0x27a, /* INC8m */ + 0x230, /* DEC8m */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x27b, /* INC8r */ + 0x231, /* DEC8r */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ +/* Table552 */ + 0x275, /* INC32m */ + 0x22b, /* DEC32m */ + 0x175, /* CALL32m */ + 0x240, /* FARCALL32m */ + 0x2b3, /* JMP32m */ + 0x245, /* FARJMP32m */ + 0x428, /* PUSH32rmm */ + 0x0, /* */ + 0x276, /* INC32r */ + 0x22c, /* DEC32r */ + 0x177, /* CALL32r */ + 0x0, /* */ + 0x2b5, /* JMP32r */ + 0x0, /* */ + 0x429, /* PUSH32rmr */ + 0x0, /* */ +/* Table568 */ + 0x48f, /* REX64_PREFIX */ +/* Table569 */ + 0x42c, /* PUSH64r */ +/* Table570 */ + 0x40a, /* POP64r */ +/* Table571 */ + 0x42a, /* PUSH64i32 */ +/* Table572 */ + 0x42b, /* PUSH64i8 */ +/* Table573 */ + 0x2df, /* LEA64_32r */ + 0x0, /* */ +/* Table575 */ + 0x40b, /* POP64rmm */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x40c, /* POP64rmr */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ +/* Table591 */ + 0x439, /* PUSHF64 */ +/* Table592 */ + 0x415, /* POPF64 */ +/* Table593 */ + 0x357, /* MOV8ao64 */ +/* Table594 */ + 0x333, /* MOV32ao64 */ +/* Table595 */ + 0x35d, /* MOV8o64a */ +/* Table596 */ + 0x33a, /* MOV32o64a */ +/* Table597 */ + 0x48a, /* RETIQ */ +/* Table598 */ + 0x48d, /* RETQ */ +/* Table599 */ + 0x2e2, /* LEAVE64 */ +/* Table600 */ + 0x2d0, /* JRCXZ */ +/* Table601 */ + 0x17b, /* CALL64pcrel32 */ +/* Table602 */ + 0x275, /* INC32m */ + 0x22b, /* DEC32m */ + 0x179, /* CALL64m */ + 0x240, /* FARCALL32m */ + 0x2b7, /* JMP64m */ + 0x245, /* FARJMP32m */ + 0x42d, /* PUSH64rmm */ + 0x0, /* */ + 0x276, /* INC32r */ + 0x22c, /* DEC32r */ + 0x17c, /* CALL64r */ + 0x0, /* */ + 0x2b9, /* JMP64r */ + 0x0, /* */ + 0x42e, /* PUSH64rmr */ + 0x0, /* */ +/* Table618 */ + 0xad, /* ADD16mr */ + 0xb1, /* ADD16rr */ +/* Table620 */ + 0xb0, /* ADD16rm */ + 0xb2, /* ADD16rr_REV */ +/* Table622 */ + 0xaa, /* ADD16i16 */ +/* Table623 */ + 0x435, /* PUSHES16 */ +/* Table624 */ + 0x411, /* POPES16 */ +/* Table625 */ + 0x3d1, /* OR16mr */ + 0x3d5, /* OR16rr */ +/* Table627 */ + 0x3d4, /* OR16rm */ + 0x3d6, /* OR16rr_REV */ +/* Table629 */ + 0x3ce, /* OR16i16 */ +/* Table630 */ + 0x431, /* PUSHCS16 */ +/* Table631 */ + 0x85, /* ADC16mr */ + 0x89, /* ADC16rr */ +/* Table633 */ + 0x88, /* ADC16rm */ + 0x8a, /* ADC16rr_REV */ +/* Table635 */ + 0x82, /* ADC16i16 */ +/* Table636 */ + 0x440, /* PUSHSS16 */ +/* Table637 */ + 0x41c, /* POPSS16 */ +/* Table638 */ + 0x500, /* SBB16mr */ + 0x504, /* SBB16rr */ +/* Table640 */ + 0x503, /* SBB16rm */ + 0x505, /* SBB16rr_REV */ +/* Table642 */ + 0x4fd, /* SBB16i16 */ +/* Table643 */ + 0x433, /* PUSHDS16 */ +/* Table644 */ + 0x40f, /* POPDS16 */ +/* Table645 */ + 0xd5, /* AND16mr */ + 0xd9, /* AND16rr */ +/* Table647 */ + 0xd8, /* AND16rm */ + 0xda, /* AND16rr_REV */ +/* Table649 */ + 0xd2, /* AND16i16 */ +/* Table650 */ + 0x5b7, /* SUB16mr */ + 0x5bb, /* SUB16rr */ +/* Table652 */ + 0x5ba, /* SUB16rm */ + 0x5bc, /* SUB16rr_REV */ +/* Table654 */ + 0x5b4, /* SUB16i16 */ +/* Table655 */ + 0x656, /* XOR16mr */ + 0x65a, /* XOR16rr */ +/* Table657 */ + 0x659, /* XOR16rm */ + 0x65b, /* XOR16rr_REV */ +/* Table659 */ + 0x653, /* XOR16i16 */ +/* Table660 */ + 0x1f2, /* CMP16mr */ + 0x1f6, /* CMP16rr */ +/* Table662 */ + 0x1f5, /* CMP16rm */ + 0x1f7, /* CMP16rr_REV */ +/* Table664 */ + 0x1ef, /* CMP16i16 */ +/* Table665 */ + 0x274, /* INC16r_alt */ +/* Table666 */ + 0x22a, /* DEC16r_alt */ +/* Table667 */ + 0x423, /* PUSH16r */ +/* Table668 */ + 0x404, /* POP16r */ +/* Table669 */ + 0x42f, /* PUSHA16 */ +/* Table670 */ + 0x40d, /* POPA16 */ +/* Table671 */ + 0x12c, /* BOUNDS16rm */ + 0x0, /* */ +/* Table673 */ + 0x442, /* PUSHi16 */ +/* Table674 */ + 0x255, /* IMUL16rmi */ + 0x258, /* IMUL16rri */ +/* Table676 */ + 0x422, /* PUSH16i8 */ +/* Table677 */ + 0x256, /* IMUL16rmi8 */ + 0x259, /* IMUL16rri8 */ +/* Table679 */ + 0x280, /* INSW */ +/* Table680 */ + 0x3fa, /* OUTSW */ +/* Table681 */ + 0xab, /* ADD16mi */ + 0x3cf, /* OR16mi */ + 0x83, /* ADC16mi */ + 0x4fe, /* SBB16mi */ + 0xd3, /* AND16mi */ + 0x5b5, /* SUB16mi */ + 0x654, /* XOR16mi */ + 0x1f0, /* CMP16mi */ + 0xae, /* ADD16ri */ + 0x3d2, /* OR16ri */ + 0x86, /* ADC16ri */ + 0x501, /* SBB16ri */ + 0xd6, /* AND16ri */ + 0x5b8, /* SUB16ri */ + 0x657, /* XOR16ri */ + 0x1f3, /* CMP16ri */ +/* Table697 */ + 0xac, /* ADD16mi8 */ + 0x3d0, /* OR16mi8 */ + 0x84, /* ADC16mi8 */ + 0x4ff, /* SBB16mi8 */ + 0xd4, /* AND16mi8 */ + 0x5b6, /* SUB16mi8 */ + 0x655, /* XOR16mi8 */ + 0x1f1, /* CMP16mi8 */ + 0xaf, /* ADD16ri8 */ + 0x3d3, /* OR16ri8 */ + 0x87, /* ADC16ri8 */ + 0x502, /* SBB16ri8 */ + 0xd7, /* AND16ri8 */ + 0x5b9, /* SUB16ri8 */ + 0x658, /* XOR16ri8 */ + 0x1f4, /* CMP16ri8 */ +/* Table713 */ + 0x5e6, /* TEST16mr */ + 0x5e9, /* TEST16rr */ +/* Table715 */ + 0x642, /* XCHG16rm */ + 0x643, /* XCHG16rr */ +/* Table717 */ + 0x324, /* MOV16mr */ + 0x32c, /* MOV16rr */ +/* Table719 */ + 0x32b, /* MOV16rm */ + 0x32d, /* MOV16rr_REV */ +/* Table721 */ + 0x325, /* MOV16ms */ + 0x32e, /* MOV16rs */ +/* Table723 */ + 0x2dd, /* LEA16r */ + 0x0, /* */ +/* Table725 */ + 0x32f, /* MOV16sm */ + 0x330, /* MOV16sr */ +/* Table727 */ + 0x405, /* POP16rmm */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x406, /* POP16rmr */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ +/* Table743 */ + 0x641, /* XCHG16ar */ +/* Table744 */ + 0x180, /* CBW */ +/* Table745 */ + 0x223, /* CWD */ +/* Table746 */ + 0x23d, /* FARCALL16i */ +/* Table747 */ + 0x437, /* PUSHF16 */ +/* Table748 */ + 0x413, /* POPF16 */ +/* Table749 */ + 0x321, /* MOV16ao32 */ +/* Table750 */ + 0x327, /* MOV16o32a */ +/* Table751 */ + 0x373, /* MOVSW */ +/* Table752 */ + 0x216, /* CMPSW */ +/* Table753 */ + 0x5e3, /* TEST16i16 */ +/* Table754 */ + 0x5af, /* STOSW */ +/* Table755 */ + 0x2fb, /* LODSW */ +/* Table756 */ + 0x524, /* SCASW */ +/* Table757 */ + 0x329, /* MOV16ri */ +/* Table758 */ + 0x492, /* ROL16mi */ + 0x4aa, /* ROR16mi */ + 0x446, /* RCL16mi */ + 0x45e, /* RCR16mi */ + 0x54b, /* SHL16mi */ + 0x573, /* SHR16mi */ + 0x4c9, /* SAL16mi */ + 0x4e2, /* SAR16mi */ + 0x495, /* ROL16ri */ + 0x4ad, /* ROR16ri */ + 0x449, /* RCL16ri */ + 0x461, /* RCR16ri */ + 0x54e, /* SHL16ri */ + 0x576, /* SHR16ri */ + 0x4cc, /* SAL16ri */ + 0x4e5, /* SAR16ri */ +/* Table774 */ + 0x48b, /* RETIW */ +/* Table775 */ + 0x48e, /* RETW */ +/* Table776 */ + 0x2e3, /* LES16rm */ + 0x0, /* */ +/* Table778 */ + 0x2db, /* LDS16rm */ + 0x0, /* */ +/* Table780 */ + 0x323, /* MOV16mi */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x32a, /* MOV16ri_alt */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ +/* Table796 */ + 0x301, /* LRETIW */ +/* Table797 */ + 0x304, /* LRETW */ +/* Table798 */ + 0x28f, /* IRET16 */ +/* Table799 */ + 0x490, /* ROL16m1 */ + 0x4a8, /* ROR16m1 */ + 0x444, /* RCL16m1 */ + 0x45c, /* RCR16m1 */ + 0x549, /* SHL16m1 */ + 0x571, /* SHR16m1 */ + 0x4c7, /* SAL16m1 */ + 0x4e0, /* SAR16m1 */ + 0x493, /* ROL16r1 */ + 0x4ab, /* ROR16r1 */ + 0x447, /* RCL16r1 */ + 0x45f, /* RCR16r1 */ + 0x54c, /* SHL16r1 */ + 0x574, /* SHR16r1 */ + 0x4ca, /* SAL16r1 */ + 0x4e3, /* SAR16r1 */ +/* Table815 */ + 0x491, /* ROL16mCL */ + 0x4a9, /* ROR16mCL */ + 0x445, /* RCL16mCL */ + 0x45d, /* RCR16mCL */ + 0x54a, /* SHL16mCL */ + 0x572, /* SHR16mCL */ + 0x4c8, /* SAL16mCL */ + 0x4e1, /* SAR16mCL */ + 0x494, /* ROL16rCL */ + 0x4ac, /* ROR16rCL */ + 0x448, /* RCL16rCL */ + 0x460, /* RCR16rCL */ + 0x54d, /* SHL16rCL */ + 0x575, /* SHR16rCL */ + 0x4cb, /* SAL16rCL */ + 0x4e4, /* SAR16rCL */ +/* Table831 */ + 0x26c, /* IN16ri */ +/* Table832 */ + 0x3f2, /* OUT16ir */ +/* Table833 */ + 0x17e, /* CALLpcrel16 */ +/* Table834 */ + 0x2bc, /* JMP_2 */ +/* Table835 */ + 0x242, /* FARJMP16i */ +/* Table836 */ + 0x26d, /* IN16rr */ +/* Table837 */ + 0x3f3, /* OUT16rr */ +/* Table838 */ + 0x5e4, /* TEST16mi */ + 0x5e5, /* TEST16mi_alt */ + 0x3c6, /* NOT16m */ + 0x39f, /* NEG16m */ + 0x392, /* MUL16m */ + 0x252, /* IMUL16m */ + 0x232, /* DIV16m */ + 0x24a, /* IDIV16m */ + 0x5e7, /* TEST16ri */ + 0x5e8, /* TEST16ri_alt */ + 0x3c7, /* NOT16r */ + 0x3a0, /* NEG16r */ + 0x393, /* MUL16r */ + 0x253, /* IMUL16r */ + 0x233, /* DIV16r */ + 0x24b, /* IDIV16r */ +/* Table854 */ + 0x272, /* INC16m */ + 0x228, /* DEC16m */ + 0x171, /* CALL16m */ + 0x23e, /* FARCALL16m */ + 0x2af, /* JMP16m */ + 0x243, /* FARJMP16m */ + 0x424, /* PUSH16rmm */ + 0x0, /* */ + 0x273, /* INC16r */ + 0x229, /* DEC16r */ + 0x173, /* CALL16r */ + 0x0, /* */ + 0x2b1, /* JMP16r */ + 0x0, /* */ + 0x425, /* PUSH16rmr */ + 0x0, /* */ +/* Table870 */ + 0x355, /* MOV8ao16 */ +/* Table871 */ + 0x331, /* MOV32ao16 */ +/* Table872 */ + 0x35b, /* MOV8o16a */ +/* Table873 */ + 0x338, /* MOV32o16a */ +/* Table874 */ + 0x29e, /* JCXZ */ +/* Table875 */ + 0x320, /* MOV16ao16 */ +/* Table876 */ + 0x326, /* MOV16o16a */ +/* Table877 */ + 0xbf, /* ADD64mr */ + 0xc3, /* ADD64rr */ +/* Table879 */ + 0xc2, /* ADD64rm */ + 0xc4, /* ADD64rr_REV */ +/* Table881 */ + 0xbc, /* ADD64i32 */ +/* Table882 */ + 0x3e3, /* OR64mr */ + 0x3e7, /* OR64rr */ +/* Table884 */ + 0x3e6, /* OR64rm */ + 0x3e8, /* OR64rr_REV */ +/* Table886 */ + 0x3e0, /* OR64i32 */ +/* Table887 */ + 0x97, /* ADC64mr */ + 0x9b, /* ADC64rr */ +/* Table889 */ + 0x9a, /* ADC64rm */ + 0x9c, /* ADC64rr_REV */ +/* Table891 */ + 0x94, /* ADC64i32 */ +/* Table892 */ + 0x512, /* SBB64mr */ + 0x516, /* SBB64rr */ +/* Table894 */ + 0x515, /* SBB64rm */ + 0x517, /* SBB64rr_REV */ +/* Table896 */ + 0x50f, /* SBB64i32 */ +/* Table897 */ + 0xe7, /* AND64mr */ + 0xeb, /* AND64rr */ +/* Table899 */ + 0xea, /* AND64rm */ + 0xec, /* AND64rr_REV */ +/* Table901 */ + 0xe4, /* AND64i32 */ +/* Table902 */ + 0x5c9, /* SUB64mr */ + 0x5cd, /* SUB64rr */ +/* Table904 */ + 0x5cc, /* SUB64rm */ + 0x5ce, /* SUB64rr_REV */ +/* Table906 */ + 0x5c6, /* SUB64i32 */ +/* Table907 */ + 0x668, /* XOR64mr */ + 0x66c, /* XOR64rr */ +/* Table909 */ + 0x66b, /* XOR64rm */ + 0x66d, /* XOR64rr_REV */ +/* Table911 */ + 0x665, /* XOR64i32 */ +/* Table912 */ + 0x204, /* CMP64mr */ + 0x208, /* CMP64rr */ +/* Table914 */ + 0x207, /* CMP64rm */ + 0x209, /* CMP64rr_REV */ +/* Table916 */ + 0x201, /* CMP64i32 */ +/* Table917 */ + 0x37f, /* MOVSX64rm32 */ + 0x382, /* MOVSX64rr32 */ +/* Table919 */ + 0x265, /* IMUL64rmi32 */ + 0x268, /* IMUL64rri32 */ +/* Table921 */ + 0x266, /* IMUL64rmi8 */ + 0x269, /* IMUL64rri8 */ +/* Table923 */ + 0xbd, /* ADD64mi32 */ + 0x3e1, /* OR64mi32 */ + 0x95, /* ADC64mi32 */ + 0x510, /* SBB64mi32 */ + 0xe5, /* AND64mi32 */ + 0x5c7, /* SUB64mi32 */ + 0x666, /* XOR64mi32 */ + 0x202, /* CMP64mi32 */ + 0xc0, /* ADD64ri32 */ + 0x3e4, /* OR64ri32 */ + 0x98, /* ADC64ri32 */ + 0x513, /* SBB64ri32 */ + 0xe8, /* AND64ri32 */ + 0x5ca, /* SUB64ri32 */ + 0x669, /* XOR64ri32 */ + 0x205, /* CMP64ri32 */ +/* Table939 */ + 0xbe, /* ADD64mi8 */ + 0x3e2, /* OR64mi8 */ + 0x96, /* ADC64mi8 */ + 0x511, /* SBB64mi8 */ + 0xe6, /* AND64mi8 */ + 0x5c8, /* SUB64mi8 */ + 0x667, /* XOR64mi8 */ + 0x203, /* CMP64mi8 */ + 0xc1, /* ADD64ri8 */ + 0x3e5, /* OR64ri8 */ + 0x99, /* ADC64ri8 */ + 0x514, /* SBB64ri8 */ + 0xe9, /* AND64ri8 */ + 0x5cb, /* SUB64ri8 */ + 0x66a, /* XOR64ri8 */ + 0x206, /* CMP64ri8 */ +/* Table955 */ + 0x5f4, /* TEST64mr */ + 0x5f7, /* TEST64rr */ +/* Table957 */ + 0x648, /* XCHG64rm */ + 0x649, /* XCHG64rr */ +/* Table959 */ + 0x349, /* MOV64mr */ + 0x351, /* MOV64rr */ +/* Table961 */ + 0x350, /* MOV64rm */ + 0x352, /* MOV64rr_REV */ +/* Table963 */ + 0x325, /* MOV16ms */ + 0x353, /* MOV64rs */ +/* Table965 */ + 0x2e0, /* LEA64r */ + 0x0, /* */ +/* Table967 */ + 0x32f, /* MOV16sm */ + 0x354, /* MOV64sr */ +/* Table969 */ + 0x647, /* XCHG64ar */ +/* Table970 */ + 0x182, /* CDQE */ +/* Table971 */ + 0x222, /* CQO */ +/* Table972 */ + 0x345, /* MOV64ao64 */ +/* Table973 */ + 0x34b, /* MOV64o64a */ +/* Table974 */ + 0x372, /* MOVSQ */ +/* Table975 */ + 0x215, /* CMPSQ */ +/* Table976 */ + 0x5f1, /* TEST64i32 */ +/* Table977 */ + 0x5ae, /* STOSQ */ +/* Table978 */ + 0x2fa, /* LODSQ */ +/* Table979 */ + 0x523, /* SCASQ */ +/* Table980 */ + 0x34e, /* MOV64ri */ +/* Table981 */ + 0x49e, /* ROL64mi */ + 0x4b6, /* ROR64mi */ + 0x452, /* RCL64mi */ + 0x46a, /* RCR64mi */ + 0x557, /* SHL64mi */ + 0x57f, /* SHR64mi */ + 0x4d5, /* SAL64mi */ + 0x4ee, /* SAR64mi */ + 0x4a1, /* ROL64ri */ + 0x4b9, /* ROR64ri */ + 0x455, /* RCL64ri */ + 0x46d, /* RCR64ri */ + 0x55a, /* SHL64ri */ + 0x582, /* SHR64ri */ + 0x4d8, /* SAL64ri */ + 0x4f1, /* SAR64ri */ +/* Table997 */ + 0x348, /* MOV64mi32 */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x34f, /* MOV64ri32 */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ +/* Table1013 */ + 0x300, /* LRETIQ */ +/* Table1014 */ + 0x303, /* LRETQ */ +/* Table1015 */ + 0x291, /* IRET64 */ +/* Table1016 */ + 0x49c, /* ROL64m1 */ + 0x4b4, /* ROR64m1 */ + 0x450, /* RCL64m1 */ + 0x468, /* RCR64m1 */ + 0x555, /* SHL64m1 */ + 0x57d, /* SHR64m1 */ + 0x4d3, /* SAL64m1 */ + 0x4ec, /* SAR64m1 */ + 0x49f, /* ROL64r1 */ + 0x4b7, /* ROR64r1 */ + 0x453, /* RCL64r1 */ + 0x46b, /* RCR64r1 */ + 0x558, /* SHL64r1 */ + 0x580, /* SHR64r1 */ + 0x4d6, /* SAL64r1 */ + 0x4ef, /* SAR64r1 */ +/* Table1032 */ + 0x49d, /* ROL64mCL */ + 0x4b5, /* ROR64mCL */ + 0x451, /* RCL64mCL */ + 0x469, /* RCR64mCL */ + 0x556, /* SHL64mCL */ + 0x57e, /* SHR64mCL */ + 0x4d4, /* SAL64mCL */ + 0x4ed, /* SAR64mCL */ + 0x4a0, /* ROL64rCL */ + 0x4b8, /* ROR64rCL */ + 0x454, /* RCL64rCL */ + 0x46c, /* RCR64rCL */ + 0x559, /* SHL64rCL */ + 0x581, /* SHR64rCL */ + 0x4d7, /* SAL64rCL */ + 0x4f0, /* SAR64rCL */ +/* Table1048 */ + 0x5f2, /* TEST64mi32 */ + 0x5f3, /* TEST64mi32_alt */ + 0x3ca, /* NOT64m */ + 0x3a3, /* NEG64m */ + 0x396, /* MUL64m */ + 0x262, /* IMUL64m */ + 0x236, /* DIV64m */ + 0x24e, /* IDIV64m */ + 0x5f5, /* TEST64ri32 */ + 0x5f6, /* TEST64ri32_alt */ + 0x3cb, /* NOT64r */ + 0x3a4, /* NEG64r */ + 0x397, /* MUL64r */ + 0x263, /* IMUL64r */ + 0x237, /* DIV64r */ + 0x24f, /* IDIV64r */ +/* Table1064 */ + 0x278, /* INC64m */ + 0x22e, /* DEC64m */ + 0x179, /* CALL64m */ + 0x241, /* FARCALL64 */ + 0x2b7, /* JMP64m */ + 0x246, /* FARJMP64 */ + 0x42d, /* PUSH64rmm */ + 0x0, /* */ + 0x279, /* INC64r */ + 0x22f, /* DEC64r */ + 0x17c, /* CALL64r */ + 0x0, /* */ + 0x2b9, /* JMP64r */ + 0x0, /* */ + 0x42e, /* PUSH64rmr */ + 0x0, /* */ +/* Table1080 */ + 0x344, /* MOV64ao32 */ +/* Table1081 */ + 0x34a, /* MOV64o32a */ +/* Table1082 */ + 0x278, /* INC64m */ + 0x22e, /* DEC64m */ + 0x179, /* CALL64m */ + 0x241, /* FARCALL64 */ + 0x2b7, /* JMP64m */ + 0x246, /* FARJMP64 */ + 0x424, /* PUSH16rmm */ + 0x0, /* */ + 0x279, /* INC64r */ + 0x22f, /* DEC64r */ + 0x17c, /* CALL64r */ + 0x0, /* */ + 0x2b9, /* JMP64r */ + 0x0, /* */ + 0x425, /* PUSH16rmr */ + 0x0, /* */ +/* Table1098 */ + 0x322, /* MOV16ao64 */ +/* Table1099 */ + 0x328, /* MOV16o64a */ +/* Table1100 */ + 0x272, /* INC16m */ + 0x228, /* DEC16m */ + 0x179, /* CALL64m */ + 0x23e, /* FARCALL16m */ + 0x2b7, /* JMP64m */ + 0x243, /* FARJMP16m */ + 0x424, /* PUSH16rmm */ + 0x0, /* */ + 0x273, /* INC16r */ + 0x229, /* DEC16r */ + 0x17c, /* CALL64r */ + 0x0, /* */ + 0x2b9, /* JMP64r */ + 0x0, /* */ + 0x425, /* PUSH16rmr */ + 0x0, /* */ +/* Table1116 */ + 0x59d, /* SLDT16m */ + 0x5b3, /* STRm */ + 0x2f1, /* LLDT16m */ + 0x30e, /* LTRm */ + 0x611, /* VERRm */ + 0x613, /* VERWm */ + 0x0, /* */ + 0x0, /* */ + 0x59f, /* SLDT32r */ + 0x5b1, /* STR32r */ + 0x2f2, /* LLDT16r */ + 0x30f, /* LTRr */ + 0x612, /* VERRr */ + 0x614, /* VERWr */ + 0x0, /* */ + 0x0, /* */ +/* Table1132 */ + 0x547, /* SGDT32m */ + 0x59a, /* SIDT32m */ + 0x2e9, /* LGDT32m */ + 0x2ef, /* LIDT32m */ + 0x5a3, /* SMSW16m */ + 0x0, /* */ + 0x2f5, /* LMSW16m */ + 0x288, /* INVLPG */ + 0x0, /* */ + 0x615, /* VMCALL */ + 0x618, /* VMLAUNCH */ + 0x622, /* VMRESUME */ + 0x62b, /* VMXOFF */ + 0x3fb, /* PCONFIG */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x183, /* CLAC */ + 0x5a7, /* STAC */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x651, /* XGETBV */ + 0x683, /* XSETBV */ + 0x0, /* */ + 0x0, /* */ + 0x617, /* VMFUNC */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x623, /* VMRUN32 */ + 0x61b, /* VMMCALL */ + 0x619, /* VMLOAD32 */ + 0x625, /* VMSAVE32 */ + 0x5aa, /* STGI */ + 0x188, /* CLGI */ + 0x59c, /* SKINIT */ + 0x289, /* INVLPGA32 */ + 0x5a5, /* SMSW32r */ + 0x5a5, /* SMSW32r */ + 0x5a5, /* SMSW32r */ + 0x5a5, /* SMSW32r */ + 0x5a5, /* SMSW32r */ + 0x5a5, /* SMSW32r */ + 0x5a5, /* SMSW32r */ + 0x5a5, /* SMSW32r */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x47b, /* RDPKRUr */ + 0x634, /* WRPKRUr */ + 0x2f6, /* LMSW16r */ + 0x2f6, /* LMSW16r */ + 0x2f6, /* LMSW16r */ + 0x2f6, /* LMSW16r */ + 0x2f6, /* LMSW16r */ + 0x2f6, /* LMSW16r */ + 0x2f6, /* LMSW16r */ + 0x2f6, /* LMSW16r */ + 0x5d8, /* SWAPGS */ + 0x486, /* RDTSCP */ + 0x31e, /* MONITORXrrr */ + 0x39e, /* MWAITXrrr */ + 0x18d, /* CLZEROr */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ +/* Table1204 */ + 0x2d7, /* LAR32rm */ + 0x2d8, /* LAR32rr */ +/* Table1206 */ + 0x307, /* LSL32rm */ + 0x308, /* LSL32rr */ +/* Table1208 */ + 0x5d9, /* SYSCALL */ +/* Table1209 */ + 0x18b, /* CLTS */ +/* Table1210 */ + 0x5dd, /* SYSRET */ +/* Table1211 */ + 0x285, /* INVD */ +/* Table1212 */ + 0x62d, /* WBINVD */ +/* Table1213 */ + 0x60c, /* UD2 */ +/* Table1214 */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x3b0, /* NOOP18_m4 */ + 0x3b1, /* NOOP18_m5 */ + 0x3b2, /* NOOP18_m6 */ + 0x3b3, /* NOOP18_m7 */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x3b4, /* NOOP18_r4 */ + 0x3b5, /* NOOP18_r5 */ + 0x3b6, /* NOOP18_r6 */ + 0x3b7, /* NOOP18_r7 */ +/* Table1230 */ + 0x3ba, /* NOOPL_19 */ + 0x3b8, /* NOOP19rr */ +/* Table1232 */ + 0x186, /* CLDEMOTE */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ +/* Table1248 */ + 0x3bb, /* NOOPL_1d */ + 0x0, /* */ +/* Table1250 */ + 0x3bc, /* NOOPL_1e */ + 0x0, /* */ +/* Table1252 */ + 0x3b9, /* NOOPL */ + 0x3bd, /* NOOPLr */ +/* Table1254 */ + 0x0, /* */ + 0x33b, /* MOV32rc */ +/* Table1256 */ + 0x0, /* */ + 0x33c, /* MOV32rd */ +/* Table1258 */ + 0x0, /* */ + 0x334, /* MOV32cr */ +/* Table1260 */ + 0x0, /* */ + 0x335, /* MOV32dr */ +/* Table1262 */ + 0x633, /* WRMSR */ +/* Table1263 */ + 0x485, /* RDTSC */ +/* Table1264 */ + 0x478, /* RDMSR */ +/* Table1265 */ + 0x47c, /* RDPMC */ +/* Table1266 */ + 0x5da, /* SYSENTER */ +/* Table1267 */ + 0x5db, /* SYSEXIT */ +/* Table1268 */ + 0x248, /* GETSEC */ +/* Table1269 */ + 0x1df, /* CMOVO32rm */ + 0x1e0, /* CMOVO32rr */ +/* Table1271 */ + 0x1cd, /* CMOVNO32rm */ + 0x1ce, /* CMOVNO32rr */ +/* Table1273 */ + 0x19d, /* CMOVB32rm */ + 0x19e, /* CMOVB32rr */ +/* Table1275 */ + 0x197, /* CMOVAE32rm */ + 0x198, /* CMOVAE32rr */ +/* Table1277 */ + 0x1a9, /* CMOVE32rm */ + 0x1aa, /* CMOVE32rr */ +/* Table1279 */ + 0x1c7, /* CMOVNE32rm */ + 0x1c8, /* CMOVNE32rr */ +/* Table1281 */ + 0x1a3, /* CMOVBE32rm */ + 0x1a4, /* CMOVBE32rr */ +/* Table1283 */ + 0x191, /* CMOVA32rm */ + 0x192, /* CMOVA32rr */ +/* Table1285 */ + 0x1eb, /* CMOVS32rm */ + 0x1ec, /* CMOVS32rr */ +/* Table1287 */ + 0x1d9, /* CMOVNS32rm */ + 0x1da, /* CMOVNS32rr */ +/* Table1289 */ + 0x1e5, /* CMOVP32rm */ + 0x1e6, /* CMOVP32rr */ +/* Table1291 */ + 0x1d3, /* CMOVNP32rm */ + 0x1d4, /* CMOVNP32rr */ +/* Table1293 */ + 0x1bb, /* CMOVL32rm */ + 0x1bc, /* CMOVL32rr */ +/* Table1295 */ + 0x1b5, /* CMOVGE32rm */ + 0x1b6, /* CMOVGE32rr */ +/* Table1297 */ + 0x1c1, /* CMOVLE32rm */ + 0x1c2, /* CMOVLE32rr */ +/* Table1299 */ + 0x1af, /* CMOVG32rm */ + 0x1b0, /* CMOVG32rr */ +/* Table1301 */ + 0x61e, /* VMREAD32mr */ + 0x61f, /* VMREAD32rr */ +/* Table1303 */ + 0x627, /* VMWRITE32rm */ + 0x628, /* VMWRITE32rr */ +/* Table1305 */ + 0x2cc, /* JO_4 */ +/* Table1306 */ + 0x2c3, /* JNO_4 */ +/* Table1307 */ + 0x29d, /* JB_4 */ +/* Table1308 */ + 0x294, /* JAE_4 */ +/* Table1309 */ + 0x2a2, /* JE_4 */ +/* Table1310 */ + 0x2c0, /* JNE_4 */ +/* Table1311 */ + 0x29a, /* JBE_4 */ +/* Table1312 */ + 0x297, /* JA_4 */ +/* Table1313 */ + 0x2d3, /* JS_4 */ +/* Table1314 */ + 0x2c9, /* JNS_4 */ +/* Table1315 */ + 0x2cf, /* JP_4 */ +/* Table1316 */ + 0x2c6, /* JNP_4 */ +/* Table1317 */ + 0x2ae, /* JL_4 */ +/* Table1318 */ + 0x2a5, /* JGE_4 */ +/* Table1319 */ + 0x2ab, /* JLE_4 */ +/* Table1320 */ + 0x2a8, /* JG_4 */ +/* Table1321 */ + 0x53f, /* SETOm */ + 0x540, /* SETOr */ +/* Table1323 */ + 0x539, /* SETNOm */ + 0x53a, /* SETNOr */ +/* Table1325 */ + 0x52b, /* SETBm */ + 0x52c, /* SETBr */ +/* Table1327 */ + 0x525, /* SETAEm */ + 0x526, /* SETAEr */ +/* Table1329 */ + 0x52d, /* SETEm */ + 0x52e, /* SETEr */ +/* Table1331 */ + 0x537, /* SETNEm */ + 0x538, /* SETNEr */ +/* Table1333 */ + 0x529, /* SETBEm */ + 0x52a, /* SETBEr */ +/* Table1335 */ + 0x527, /* SETAm */ + 0x528, /* SETAr */ +/* Table1337 */ + 0x544, /* SETSm */ + 0x545, /* SETSr */ +/* Table1339 */ + 0x53d, /* SETNSm */ + 0x53e, /* SETNSr */ +/* Table1341 */ + 0x541, /* SETPm */ + 0x542, /* SETPr */ +/* Table1343 */ + 0x53b, /* SETNPm */ + 0x53c, /* SETNPr */ +/* Table1345 */ + 0x535, /* SETLm */ + 0x536, /* SETLr */ +/* Table1347 */ + 0x52f, /* SETGEm */ + 0x530, /* SETGEr */ +/* Table1349 */ + 0x533, /* SETLEm */ + 0x534, /* SETLEr */ +/* Table1351 */ + 0x531, /* SETGm */ + 0x532, /* SETGr */ +/* Table1353 */ + 0x43b, /* PUSHFS32 */ +/* Table1354 */ + 0x417, /* POPFS32 */ +/* Table1355 */ + 0x221, /* CPUID */ +/* Table1356 */ + 0x142, /* BT32mr */ + 0x144, /* BT32rr */ +/* Table1358 */ + 0x566, /* SHLD32mri8 */ + 0x568, /* SHLD32rri8 */ +/* Table1360 */ + 0x565, /* SHLD32mrCL */ + 0x567, /* SHLD32rrCL */ +/* Table1362 */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x31f, /* MONTMUL */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x684, /* XSHA1 */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x685, /* XSHA256 */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ +/* Table1434 */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x686, /* XSTORE */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x64f, /* XCRYPTECB */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x64c, /* XCRYPTCBC */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x64e, /* XCRYPTCTR */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x64d, /* XCRYPTCFB */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x650, /* XCRYPTOFB */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ +/* Table1506 */ + 0x43e, /* PUSHGS32 */ +/* Table1507 */ + 0x41a, /* POPGS32 */ +/* Table1508 */ + 0x4c4, /* RSM */ +/* Table1509 */ + 0x166, /* BTS32mr */ + 0x168, /* BTS32rr */ +/* Table1511 */ + 0x58e, /* SHRD32mri8 */ + 0x590, /* SHRD32rri8 */ +/* Table1513 */ + 0x58d, /* SHRD32mrCL */ + 0x58f, /* SHRD32rrCL */ +/* Table1515 */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x67b, /* XSAVE */ + 0x677, /* XRSTOR */ + 0x67f, /* XSAVEOPT */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ +/* Table1531 */ + 0x25c, /* IMUL32rm */ + 0x25f, /* IMUL32rr */ +/* Table1533 */ + 0x21f, /* CMPXCHG8rm */ + 0x220, /* CMPXCHG8rr */ +/* Table1535 */ + 0x21a, /* CMPXCHG32rm */ + 0x21b, /* CMPXCHG32rr */ +/* Table1537 */ + 0x30c, /* LSS32rm */ + 0x0, /* */ +/* Table1539 */ + 0x15a, /* BTR32mr */ + 0x15c, /* BTR32rr */ +/* Table1541 */ + 0x2e6, /* LFS32rm */ + 0x0, /* */ +/* Table1543 */ + 0x2ec, /* LGS32rm */ + 0x0, /* */ +/* Table1545 */ + 0x389, /* MOVZX32rm8 */ + 0x38c, /* MOVZX32rr8 */ +/* Table1547 */ + 0x388, /* MOVZX32rm16 */ + 0x38b, /* MOVZX32rr16 */ +/* Table1549 */ + 0x60b, /* UD1 */ +/* Table1550 */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x141, /* BT32mi8 */ + 0x165, /* BTS32mi8 */ + 0x159, /* BTR32mi8 */ + 0x14d, /* BTC32mi8 */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x143, /* BT32ri8 */ + 0x167, /* BTS32ri8 */ + 0x15b, /* BTR32ri8 */ + 0x14f, /* BTC32ri8 */ +/* Table1566 */ + 0x14e, /* BTC32mr */ + 0x150, /* BTC32rr */ +/* Table1568 */ + 0x130, /* BSF32rm */ + 0x131, /* BSF32rr */ +/* Table1570 */ + 0x136, /* BSR32rm */ + 0x137, /* BSR32rr */ +/* Table1572 */ + 0x379, /* MOVSX32rm8 */ + 0x37c, /* MOVSX32rr8 */ +/* Table1574 */ + 0x378, /* MOVSX32rm16 */ + 0x37b, /* MOVSX32rr16 */ +/* Table1576 */ + 0x63f, /* XADD8rm */ + 0x640, /* XADD8rr */ +/* Table1578 */ + 0x63b, /* XADD32rm */ + 0x63c, /* XADD32rr */ +/* Table1580 */ + 0x0, /* */ + 0x21e, /* CMPXCHG8B */ + 0x0, /* */ + 0x679, /* XRSTORS */ + 0x67d, /* XSAVEC */ + 0x681, /* XSAVES */ + 0x61c, /* VMPTRLDm */ + 0x61d, /* VMPTRSTm */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x47e, /* RDRAND32r */ + 0x481, /* RDSEED32r */ +/* Table1596 */ + 0x13b, /* BSWAP32r */ +/* Table1597 */ + 0x60a, /* UD0 */ +/* Table1598 */ + 0x548, /* SGDT64m */ + 0x59b, /* SIDT64m */ + 0x2ea, /* LGDT64m */ + 0x2f0, /* LIDT64m */ + 0x5a3, /* SMSW16m */ + 0x0, /* */ + 0x2f5, /* LMSW16m */ + 0x288, /* INVLPG */ + 0x0, /* */ + 0x615, /* VMCALL */ + 0x618, /* VMLAUNCH */ + 0x622, /* VMRESUME */ + 0x62b, /* VMXOFF */ + 0x3fb, /* PCONFIG */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x183, /* CLAC */ + 0x5a7, /* STAC */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x651, /* XGETBV */ + 0x683, /* XSETBV */ + 0x0, /* */ + 0x0, /* */ + 0x617, /* VMFUNC */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x624, /* VMRUN64 */ + 0x61b, /* VMMCALL */ + 0x61a, /* VMLOAD64 */ + 0x626, /* VMSAVE64 */ + 0x5aa, /* STGI */ + 0x188, /* CLGI */ + 0x59c, /* SKINIT */ + 0x28a, /* INVLPGA64 */ + 0x5a5, /* SMSW32r */ + 0x5a5, /* SMSW32r */ + 0x5a5, /* SMSW32r */ + 0x5a5, /* SMSW32r */ + 0x5a5, /* SMSW32r */ + 0x5a5, /* SMSW32r */ + 0x5a5, /* SMSW32r */ + 0x5a5, /* SMSW32r */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x47b, /* RDPKRUr */ + 0x634, /* WRPKRUr */ + 0x2f6, /* LMSW16r */ + 0x2f6, /* LMSW16r */ + 0x2f6, /* LMSW16r */ + 0x2f6, /* LMSW16r */ + 0x2f6, /* LMSW16r */ + 0x2f6, /* LMSW16r */ + 0x2f6, /* LMSW16r */ + 0x2f6, /* LMSW16r */ + 0x5d8, /* SWAPGS */ + 0x486, /* RDTSCP */ + 0x31e, /* MONITORXrrr */ + 0x39e, /* MWAITXrrr */ + 0x18d, /* CLZEROr */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ +/* Table1670 */ + 0x0, /* */ + 0x34c, /* MOV64rc */ +/* Table1672 */ + 0x0, /* */ + 0x34d, /* MOV64rd */ +/* Table1674 */ + 0x0, /* */ + 0x346, /* MOV64cr */ +/* Table1676 */ + 0x0, /* */ + 0x347, /* MOV64dr */ +/* Table1678 */ + 0x620, /* VMREAD64mr */ + 0x621, /* VMREAD64rr */ +/* Table1680 */ + 0x629, /* VMWRITE64rm */ + 0x62a, /* VMWRITE64rr */ +/* Table1682 */ + 0x43c, /* PUSHFS64 */ +/* Table1683 */ + 0x418, /* POPFS64 */ +/* Table1684 */ + 0x43f, /* PUSHGS64 */ +/* Table1685 */ + 0x41b, /* POPGS64 */ +/* Table1686 */ + 0x59d, /* SLDT16m */ + 0x5b3, /* STRm */ + 0x2f1, /* LLDT16m */ + 0x30e, /* LTRm */ + 0x611, /* VERRm */ + 0x613, /* VERWm */ + 0x0, /* */ + 0x0, /* */ + 0x59e, /* SLDT16r */ + 0x5b0, /* STR16r */ + 0x2f2, /* LLDT16r */ + 0x30f, /* LTRr */ + 0x612, /* VERRr */ + 0x614, /* VERWr */ + 0x0, /* */ + 0x0, /* */ +/* Table1702 */ + 0x546, /* SGDT16m */ + 0x599, /* SIDT16m */ + 0x2e8, /* LGDT16m */ + 0x2ee, /* LIDT16m */ + 0x5a3, /* SMSW16m */ + 0x0, /* */ + 0x2f5, /* LMSW16m */ + 0x288, /* INVLPG */ + 0x0, /* */ + 0x615, /* VMCALL */ + 0x618, /* VMLAUNCH */ + 0x622, /* VMRESUME */ + 0x62b, /* VMXOFF */ + 0x3fb, /* PCONFIG */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x183, /* CLAC */ + 0x5a7, /* STAC */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x651, /* XGETBV */ + 0x683, /* XSETBV */ + 0x0, /* */ + 0x0, /* */ + 0x617, /* VMFUNC */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x623, /* VMRUN32 */ + 0x61b, /* VMMCALL */ + 0x619, /* VMLOAD32 */ + 0x625, /* VMSAVE32 */ + 0x5aa, /* STGI */ + 0x188, /* CLGI */ + 0x59c, /* SKINIT */ + 0x289, /* INVLPGA32 */ + 0x5a4, /* SMSW16r */ + 0x5a4, /* SMSW16r */ + 0x5a4, /* SMSW16r */ + 0x5a4, /* SMSW16r */ + 0x5a4, /* SMSW16r */ + 0x5a4, /* SMSW16r */ + 0x5a4, /* SMSW16r */ + 0x5a4, /* SMSW16r */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x47b, /* RDPKRUr */ + 0x634, /* WRPKRUr */ + 0x2f6, /* LMSW16r */ + 0x2f6, /* LMSW16r */ + 0x2f6, /* LMSW16r */ + 0x2f6, /* LMSW16r */ + 0x2f6, /* LMSW16r */ + 0x2f6, /* LMSW16r */ + 0x2f6, /* LMSW16r */ + 0x2f6, /* LMSW16r */ + 0x5d8, /* SWAPGS */ + 0x486, /* RDTSCP */ + 0x31e, /* MONITORXrrr */ + 0x39e, /* MWAITXrrr */ + 0x18d, /* CLZEROr */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ +/* Table1774 */ + 0x2d5, /* LAR16rm */ + 0x2d6, /* LAR16rr */ +/* Table1776 */ + 0x305, /* LSL16rm */ + 0x306, /* LSL16rr */ +/* Table1778 */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x3a8, /* NOOP18_16m4 */ + 0x3a9, /* NOOP18_16m5 */ + 0x3aa, /* NOOP18_16m6 */ + 0x3ab, /* NOOP18_16m7 */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x3ac, /* NOOP18_16r4 */ + 0x3ad, /* NOOP18_16r5 */ + 0x3ae, /* NOOP18_16r6 */ + 0x3af, /* NOOP18_16r7 */ +/* Table1794 */ + 0x3c1, /* NOOPW_19 */ + 0x3b8, /* NOOP19rr */ +/* Table1796 */ + 0x3c2, /* NOOPW_1c */ + 0x0, /* */ +/* Table1798 */ + 0x3c3, /* NOOPW_1d */ + 0x0, /* */ +/* Table1800 */ + 0x3c4, /* NOOPW_1e */ + 0x0, /* */ +/* Table1802 */ + 0x3c0, /* NOOPW */ + 0x3c5, /* NOOPWr */ +/* Table1804 */ + 0x1dd, /* CMOVO16rm */ + 0x1de, /* CMOVO16rr */ +/* Table1806 */ + 0x1cb, /* CMOVNO16rm */ + 0x1cc, /* CMOVNO16rr */ +/* Table1808 */ + 0x19b, /* CMOVB16rm */ + 0x19c, /* CMOVB16rr */ +/* Table1810 */ + 0x195, /* CMOVAE16rm */ + 0x196, /* CMOVAE16rr */ +/* Table1812 */ + 0x1a7, /* CMOVE16rm */ + 0x1a8, /* CMOVE16rr */ +/* Table1814 */ + 0x1c5, /* CMOVNE16rm */ + 0x1c6, /* CMOVNE16rr */ +/* Table1816 */ + 0x1a1, /* CMOVBE16rm */ + 0x1a2, /* CMOVBE16rr */ +/* Table1818 */ + 0x18f, /* CMOVA16rm */ + 0x190, /* CMOVA16rr */ +/* Table1820 */ + 0x1e9, /* CMOVS16rm */ + 0x1ea, /* CMOVS16rr */ +/* Table1822 */ + 0x1d7, /* CMOVNS16rm */ + 0x1d8, /* CMOVNS16rr */ +/* Table1824 */ + 0x1e3, /* CMOVP16rm */ + 0x1e4, /* CMOVP16rr */ +/* Table1826 */ + 0x1d1, /* CMOVNP16rm */ + 0x1d2, /* CMOVNP16rr */ +/* Table1828 */ + 0x1b9, /* CMOVL16rm */ + 0x1ba, /* CMOVL16rr */ +/* Table1830 */ + 0x1b3, /* CMOVGE16rm */ + 0x1b4, /* CMOVGE16rr */ +/* Table1832 */ + 0x1bf, /* CMOVLE16rm */ + 0x1c0, /* CMOVLE16rr */ +/* Table1834 */ + 0x1ad, /* CMOVG16rm */ + 0x1ae, /* CMOVG16rr */ +/* Table1836 */ + 0x2cb, /* JO_2 */ +/* Table1837 */ + 0x2c2, /* JNO_2 */ +/* Table1838 */ + 0x29c, /* JB_2 */ +/* Table1839 */ + 0x293, /* JAE_2 */ +/* Table1840 */ + 0x2a1, /* JE_2 */ +/* Table1841 */ + 0x2bf, /* JNE_2 */ +/* Table1842 */ + 0x299, /* JBE_2 */ +/* Table1843 */ + 0x296, /* JA_2 */ +/* Table1844 */ + 0x2d2, /* JS_2 */ +/* Table1845 */ + 0x2c8, /* JNS_2 */ +/* Table1846 */ + 0x2ce, /* JP_2 */ +/* Table1847 */ + 0x2c5, /* JNP_2 */ +/* Table1848 */ + 0x2ad, /* JL_2 */ +/* Table1849 */ + 0x2a4, /* JGE_2 */ +/* Table1850 */ + 0x2aa, /* JLE_2 */ +/* Table1851 */ + 0x2a7, /* JG_2 */ +/* Table1852 */ + 0x43a, /* PUSHFS16 */ +/* Table1853 */ + 0x416, /* POPFS16 */ +/* Table1854 */ + 0x13e, /* BT16mr */ + 0x140, /* BT16rr */ +/* Table1856 */ + 0x562, /* SHLD16mri8 */ + 0x564, /* SHLD16rri8 */ +/* Table1858 */ + 0x561, /* SHLD16mrCL */ + 0x563, /* SHLD16rrCL */ +/* Table1860 */ + 0x43d, /* PUSHGS16 */ +/* Table1861 */ + 0x419, /* POPGS16 */ +/* Table1862 */ + 0x162, /* BTS16mr */ + 0x164, /* BTS16rr */ +/* Table1864 */ + 0x58a, /* SHRD16mri8 */ + 0x58c, /* SHRD16rri8 */ +/* Table1866 */ + 0x589, /* SHRD16mrCL */ + 0x58b, /* SHRD16rrCL */ +/* Table1868 */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x18c, /* CLWB */ + 0x187, /* CLFLUSHOPT */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x5ff, /* TPAUSE */ + 0x0, /* */ +/* Table1884 */ + 0x254, /* IMUL16rm */ + 0x257, /* IMUL16rr */ +/* Table1886 */ + 0x218, /* CMPXCHG16rm */ + 0x219, /* CMPXCHG16rr */ +/* Table1888 */ + 0x30b, /* LSS16rm */ + 0x0, /* */ +/* Table1890 */ + 0x156, /* BTR16mr */ + 0x158, /* BTR16rr */ +/* Table1892 */ + 0x2e5, /* LFS16rm */ + 0x0, /* */ +/* Table1894 */ + 0x2eb, /* LGS16rm */ + 0x0, /* */ +/* Table1896 */ + 0x385, /* MOVZX16rm8 */ + 0x387, /* MOVZX16rr8 */ +/* Table1898 */ + 0x384, /* MOVZX16rm16 */ + 0x386, /* MOVZX16rr16 */ +/* Table1900 */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x13d, /* BT16mi8 */ + 0x161, /* BTS16mi8 */ + 0x155, /* BTR16mi8 */ + 0x149, /* BTC16mi8 */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x13f, /* BT16ri8 */ + 0x163, /* BTS16ri8 */ + 0x157, /* BTR16ri8 */ + 0x14b, /* BTC16ri8 */ +/* Table1916 */ + 0x14a, /* BTC16mr */ + 0x14c, /* BTC16rr */ +/* Table1918 */ + 0x12e, /* BSF16rm */ + 0x12f, /* BSF16rr */ +/* Table1920 */ + 0x134, /* BSR16rm */ + 0x135, /* BSR16rr */ +/* Table1922 */ + 0x375, /* MOVSX16rm8 */ + 0x377, /* MOVSX16rr8 */ +/* Table1924 */ + 0x374, /* MOVSX16rm16 */ + 0x376, /* MOVSX16rr16 */ +/* Table1926 */ + 0x639, /* XADD16rm */ + 0x63a, /* XADD16rr */ +/* Table1928 */ + 0x0, /* */ + 0x21e, /* CMPXCHG8B */ + 0x0, /* */ + 0x679, /* XRSTORS */ + 0x67d, /* XSAVEC */ + 0x681, /* XSAVES */ + 0x616, /* VMCLEARm */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x47d, /* RDRAND16r */ + 0x480, /* RDSEED16r */ +/* Table1944 */ + 0x13a, /* BSWAP16r_BAD */ +/* Table1945 */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x67b, /* XSAVE */ + 0x677, /* XRSTOR */ + 0x18c, /* CLWB */ + 0x187, /* CLFLUSHOPT */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x5ff, /* TPAUSE */ + 0x0, /* */ +/* Table1961 */ + 0x0, /* */ + 0x21e, /* CMPXCHG8B */ + 0x0, /* */ + 0x679, /* XRSTORS */ + 0x67d, /* XSAVEC */ + 0x681, /* XSAVES */ + 0x616, /* VMCLEARm */ + 0x61d, /* VMPTRSTm */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x47d, /* RDRAND16r */ + 0x480, /* RDSEED16r */ +/* Table1977 */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x610, /* UMWAIT */ + 0x0, /* */ +/* Table1993 */ + 0x0, /* */ + 0x21e, /* CMPXCHG8B */ + 0x0, /* */ + 0x679, /* XRSTORS */ + 0x67d, /* XSAVEC */ + 0x681, /* XSAVES */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ +/* Table2009 */ + 0x547, /* SGDT32m */ + 0x59a, /* SIDT32m */ + 0x2e9, /* LGDT32m */ + 0x2ef, /* LIDT32m */ + 0x5a3, /* SMSW16m */ + 0x4c5, /* RSTORSSP */ + 0x2f5, /* LMSW16m */ + 0x288, /* INVLPG */ + 0x0, /* */ + 0x615, /* VMCALL */ + 0x618, /* VMLAUNCH */ + 0x622, /* VMRESUME */ + 0x62b, /* VMXOFF */ + 0x3fb, /* PCONFIG */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x183, /* CLAC */ + 0x5a7, /* STAC */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x651, /* XGETBV */ + 0x683, /* XSETBV */ + 0x0, /* */ + 0x0, /* */ + 0x617, /* VMFUNC */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x623, /* VMRUN32 */ + 0x61b, /* VMMCALL */ + 0x619, /* VMLOAD32 */ + 0x625, /* VMSAVE32 */ + 0x5aa, /* STGI */ + 0x188, /* CLGI */ + 0x59c, /* SKINIT */ + 0x289, /* INVLPGA32 */ + 0x5a5, /* SMSW32r */ + 0x5a5, /* SMSW32r */ + 0x5a5, /* SMSW32r */ + 0x5a5, /* SMSW32r */ + 0x5a5, /* SMSW32r */ + 0x5a5, /* SMSW32r */ + 0x5a5, /* SMSW32r */ + 0x5a5, /* SMSW32r */ + 0x543, /* SETSSBSY */ + 0x0, /* */ + 0x4fc, /* SAVEPREVSSP */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x47b, /* RDPKRUr */ + 0x634, /* WRPKRUr */ + 0x2f6, /* LMSW16r */ + 0x2f6, /* LMSW16r */ + 0x2f6, /* LMSW16r */ + 0x2f6, /* LMSW16r */ + 0x2f6, /* LMSW16r */ + 0x2f6, /* LMSW16r */ + 0x2f6, /* LMSW16r */ + 0x2f6, /* LMSW16r */ + 0x5d8, /* SWAPGS */ + 0x486, /* RDTSCP */ + 0x31e, /* MONITORXrrr */ + 0x39e, /* MWAITXrrr */ + 0x18d, /* CLZEROr */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ +/* Table2081 */ + 0x62e, /* WBNOINVD */ +/* Table2082 */ + 0x3bc, /* NOOPL_1e */ + 0x3bc, /* NOOPL_1e */ + 0x3bc, /* NOOPL_1e */ + 0x3bc, /* NOOPL_1e */ + 0x3bc, /* NOOPL_1e */ + 0x3bc, /* NOOPL_1e */ + 0x3bc, /* NOOPL_1e */ + 0x3bc, /* NOOPL_1e */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x483, /* RDSSPD */ + 0x483, /* RDSSPD */ + 0x483, /* RDSSPD */ + 0x483, /* RDSSPD */ + 0x483, /* RDSSPD */ + 0x483, /* RDSSPD */ + 0x483, /* RDSSPD */ + 0x483, /* RDSSPD */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x23b, /* ENDBR64 */ + 0x23a, /* ENDBR32 */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ +/* Table2154 */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x420, /* PTWRITEm */ + 0x0, /* */ + 0x18a, /* CLRSSBSY */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x421, /* PTWRITEr */ + 0x27c, /* INCSSPD */ + 0x60e, /* UMONITOR32 */ + 0x0, /* */ +/* Table2170 */ + 0x602, /* TZCNT32rm */ + 0x603, /* TZCNT32rr */ +/* Table2172 */ + 0x31a, /* LZCNT32rm */ + 0x31b, /* LZCNT32rr */ +/* Table2174 */ + 0x0, /* */ + 0x21e, /* CMPXCHG8B */ + 0x0, /* */ + 0x679, /* XRSTORS */ + 0x67d, /* XSAVEC */ + 0x681, /* XSAVES */ + 0x62c, /* VMXON */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x479, /* RDPID32 */ +/* Table2190 */ + 0x600, /* TZCNT16rm */ + 0x601, /* TZCNT16rr */ +/* Table2192 */ + 0x318, /* LZCNT16rm */ + 0x319, /* LZCNT16rr */ +/* Table2194 */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x60d, /* UMONITOR16 */ + 0x0, /* */ +/* Table2210 */ + 0x59d, /* SLDT16m */ + 0x5b3, /* STRm */ + 0x2f1, /* LLDT16m */ + 0x30e, /* LTRm */ + 0x611, /* VERRm */ + 0x613, /* VERWm */ + 0x0, /* */ + 0x0, /* */ + 0x5a0, /* SLDT64r */ + 0x5b2, /* STR64r */ + 0x2f2, /* LLDT16r */ + 0x30f, /* LTRr */ + 0x612, /* VERRr */ + 0x614, /* VERWr */ + 0x0, /* */ + 0x0, /* */ +/* Table2226 */ + 0x548, /* SGDT64m */ + 0x59b, /* SIDT64m */ + 0x2ea, /* LGDT64m */ + 0x2f0, /* LIDT64m */ + 0x5a3, /* SMSW16m */ + 0x0, /* */ + 0x2f5, /* LMSW16m */ + 0x288, /* INVLPG */ + 0x0, /* */ + 0x615, /* VMCALL */ + 0x618, /* VMLAUNCH */ + 0x622, /* VMRESUME */ + 0x62b, /* VMXOFF */ + 0x3fb, /* PCONFIG */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x183, /* CLAC */ + 0x5a7, /* STAC */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x651, /* XGETBV */ + 0x683, /* XSETBV */ + 0x0, /* */ + 0x0, /* */ + 0x617, /* VMFUNC */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x624, /* VMRUN64 */ + 0x61b, /* VMMCALL */ + 0x61a, /* VMLOAD64 */ + 0x626, /* VMSAVE64 */ + 0x5aa, /* STGI */ + 0x188, /* CLGI */ + 0x59c, /* SKINIT */ + 0x28a, /* INVLPGA64 */ + 0x5a6, /* SMSW64r */ + 0x5a6, /* SMSW64r */ + 0x5a6, /* SMSW64r */ + 0x5a6, /* SMSW64r */ + 0x5a6, /* SMSW64r */ + 0x5a6, /* SMSW64r */ + 0x5a6, /* SMSW64r */ + 0x5a6, /* SMSW64r */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x47b, /* RDPKRUr */ + 0x634, /* WRPKRUr */ + 0x2f6, /* LMSW16r */ + 0x2f6, /* LMSW16r */ + 0x2f6, /* LMSW16r */ + 0x2f6, /* LMSW16r */ + 0x2f6, /* LMSW16r */ + 0x2f6, /* LMSW16r */ + 0x2f6, /* LMSW16r */ + 0x2f6, /* LMSW16r */ + 0x5d8, /* SWAPGS */ + 0x486, /* RDTSCP */ + 0x31e, /* MONITORXrrr */ + 0x39e, /* MWAITXrrr */ + 0x18d, /* CLZEROr */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ +/* Table2298 */ + 0x2d9, /* LAR64rm */ + 0x2da, /* LAR64rr */ +/* Table2300 */ + 0x309, /* LSL64rm */ + 0x30a, /* LSL64rr */ +/* Table2302 */ + 0x5de, /* SYSRET64 */ +/* Table2303 */ + 0x3be, /* NOOPQ */ + 0x3bf, /* NOOPQr */ +/* Table2305 */ + 0x5dc, /* SYSEXIT64 */ +/* Table2306 */ + 0x1e1, /* CMOVO64rm */ + 0x1e2, /* CMOVO64rr */ +/* Table2308 */ + 0x1cf, /* CMOVNO64rm */ + 0x1d0, /* CMOVNO64rr */ +/* Table2310 */ + 0x19f, /* CMOVB64rm */ + 0x1a0, /* CMOVB64rr */ +/* Table2312 */ + 0x199, /* CMOVAE64rm */ + 0x19a, /* CMOVAE64rr */ +/* Table2314 */ + 0x1ab, /* CMOVE64rm */ + 0x1ac, /* CMOVE64rr */ +/* Table2316 */ + 0x1c9, /* CMOVNE64rm */ + 0x1ca, /* CMOVNE64rr */ +/* Table2318 */ + 0x1a5, /* CMOVBE64rm */ + 0x1a6, /* CMOVBE64rr */ +/* Table2320 */ + 0x193, /* CMOVA64rm */ + 0x194, /* CMOVA64rr */ +/* Table2322 */ + 0x1ed, /* CMOVS64rm */ + 0x1ee, /* CMOVS64rr */ +/* Table2324 */ + 0x1db, /* CMOVNS64rm */ + 0x1dc, /* CMOVNS64rr */ +/* Table2326 */ + 0x1e7, /* CMOVP64rm */ + 0x1e8, /* CMOVP64rr */ +/* Table2328 */ + 0x1d5, /* CMOVNP64rm */ + 0x1d6, /* CMOVNP64rr */ +/* Table2330 */ + 0x1bd, /* CMOVL64rm */ + 0x1be, /* CMOVL64rr */ +/* Table2332 */ + 0x1b7, /* CMOVGE64rm */ + 0x1b8, /* CMOVGE64rr */ +/* Table2334 */ + 0x1c3, /* CMOVLE64rm */ + 0x1c4, /* CMOVLE64rr */ +/* Table2336 */ + 0x1b1, /* CMOVG64rm */ + 0x1b2, /* CMOVG64rr */ +/* Table2338 */ + 0x146, /* BT64mr */ + 0x148, /* BT64rr */ +/* Table2340 */ + 0x56a, /* SHLD64mri8 */ + 0x56c, /* SHLD64rri8 */ +/* Table2342 */ + 0x569, /* SHLD64mrCL */ + 0x56b, /* SHLD64rrCL */ +/* Table2344 */ + 0x16a, /* BTS64mr */ + 0x16c, /* BTS64rr */ +/* Table2346 */ + 0x592, /* SHRD64mri8 */ + 0x594, /* SHRD64rri8 */ +/* Table2348 */ + 0x591, /* SHRD64mrCL */ + 0x593, /* SHRD64rrCL */ +/* Table2350 */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x67c, /* XSAVE64 */ + 0x678, /* XRSTOR64 */ + 0x680, /* XSAVEOPT64 */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ +/* Table2366 */ + 0x264, /* IMUL64rm */ + 0x267, /* IMUL64rr */ +/* Table2368 */ + 0x21c, /* CMPXCHG64rm */ + 0x21d, /* CMPXCHG64rr */ +/* Table2370 */ + 0x30d, /* LSS64rm */ + 0x0, /* */ +/* Table2372 */ + 0x15e, /* BTR64mr */ + 0x160, /* BTR64rr */ +/* Table2374 */ + 0x2e7, /* LFS64rm */ + 0x0, /* */ +/* Table2376 */ + 0x2ed, /* LGS64rm */ + 0x0, /* */ +/* Table2378 */ + 0x38f, /* MOVZX64rm8 */ + 0x391, /* MOVZX64rr8 */ +/* Table2380 */ + 0x38e, /* MOVZX64rm16 */ + 0x390, /* MOVZX64rr16 */ +/* Table2382 */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x145, /* BT64mi8 */ + 0x169, /* BTS64mi8 */ + 0x15d, /* BTR64mi8 */ + 0x151, /* BTC64mi8 */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x147, /* BT64ri8 */ + 0x16b, /* BTS64ri8 */ + 0x15f, /* BTR64ri8 */ + 0x153, /* BTC64ri8 */ +/* Table2398 */ + 0x152, /* BTC64mr */ + 0x154, /* BTC64rr */ +/* Table2400 */ + 0x132, /* BSF64rm */ + 0x133, /* BSF64rr */ +/* Table2402 */ + 0x138, /* BSR64rm */ + 0x139, /* BSR64rr */ +/* Table2404 */ + 0x380, /* MOVSX64rm8 */ + 0x383, /* MOVSX64rr8 */ +/* Table2406 */ + 0x37e, /* MOVSX64rm16 */ + 0x381, /* MOVSX64rr16 */ +/* Table2408 */ + 0x63d, /* XADD64rm */ + 0x63e, /* XADD64rr */ +/* Table2410 */ + 0x0, /* */ + 0x217, /* CMPXCHG16B */ + 0x0, /* */ + 0x67a, /* XRSTORS64 */ + 0x67e, /* XSAVEC64 */ + 0x682, /* XSAVES64 */ + 0x61c, /* VMPTRLDm */ + 0x61d, /* VMPTRSTm */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x47f, /* RDRAND64r */ + 0x482, /* RDSEED64r */ +/* Table2426 */ + 0x13c, /* BSWAP64r */ +/* Table2427 */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x67c, /* XSAVE64 */ + 0x678, /* XRSTOR64 */ + 0x680, /* XSAVEOPT64 */ + 0x187, /* CLFLUSHOPT */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x5ff, /* TPAUSE */ + 0x0, /* */ +/* Table2443 */ + 0x0, /* */ + 0x217, /* CMPXCHG16B */ + 0x0, /* */ + 0x67a, /* XRSTORS64 */ + 0x67e, /* XSAVEC64 */ + 0x682, /* XSAVES64 */ + 0x616, /* VMCLEARm */ + 0x61d, /* VMPTRSTm */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x47f, /* RDRAND64r */ + 0x482, /* RDSEED64r */ +/* Table2459 */ + 0x548, /* SGDT64m */ + 0x59b, /* SIDT64m */ + 0x2ea, /* LGDT64m */ + 0x2f0, /* LIDT64m */ + 0x5a3, /* SMSW16m */ + 0x0, /* */ + 0x2f5, /* LMSW16m */ + 0x288, /* INVLPG */ + 0x0, /* */ + 0x615, /* VMCALL */ + 0x618, /* VMLAUNCH */ + 0x622, /* VMRESUME */ + 0x62b, /* VMXOFF */ + 0x3fb, /* PCONFIG */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x183, /* CLAC */ + 0x5a7, /* STAC */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x651, /* XGETBV */ + 0x683, /* XSETBV */ + 0x0, /* */ + 0x0, /* */ + 0x617, /* VMFUNC */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x624, /* VMRUN64 */ + 0x61b, /* VMMCALL */ + 0x61a, /* VMLOAD64 */ + 0x626, /* VMSAVE64 */ + 0x5aa, /* STGI */ + 0x188, /* CLGI */ + 0x59c, /* SKINIT */ + 0x28a, /* INVLPGA64 */ + 0x5a4, /* SMSW16r */ + 0x5a4, /* SMSW16r */ + 0x5a4, /* SMSW16r */ + 0x5a4, /* SMSW16r */ + 0x5a4, /* SMSW16r */ + 0x5a4, /* SMSW16r */ + 0x5a4, /* SMSW16r */ + 0x5a4, /* SMSW16r */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x47b, /* RDPKRUr */ + 0x634, /* WRPKRUr */ + 0x2f6, /* LMSW16r */ + 0x2f6, /* LMSW16r */ + 0x2f6, /* LMSW16r */ + 0x2f6, /* LMSW16r */ + 0x2f6, /* LMSW16r */ + 0x2f6, /* LMSW16r */ + 0x2f6, /* LMSW16r */ + 0x2f6, /* LMSW16r */ + 0x5d8, /* SWAPGS */ + 0x486, /* RDTSCP */ + 0x31e, /* MONITORXrrr */ + 0x39e, /* MWAITXrrr */ + 0x18d, /* CLZEROr */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ +/* Table2531 */ + 0x548, /* SGDT64m */ + 0x59b, /* SIDT64m */ + 0x2ea, /* LGDT64m */ + 0x2f0, /* LIDT64m */ + 0x5a3, /* SMSW16m */ + 0x4c5, /* RSTORSSP */ + 0x2f5, /* LMSW16m */ + 0x288, /* INVLPG */ + 0x0, /* */ + 0x615, /* VMCALL */ + 0x618, /* VMLAUNCH */ + 0x622, /* VMRESUME */ + 0x62b, /* VMXOFF */ + 0x3fb, /* PCONFIG */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x183, /* CLAC */ + 0x5a7, /* STAC */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x651, /* XGETBV */ + 0x683, /* XSETBV */ + 0x0, /* */ + 0x0, /* */ + 0x617, /* VMFUNC */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x624, /* VMRUN64 */ + 0x61b, /* VMMCALL */ + 0x61a, /* VMLOAD64 */ + 0x626, /* VMSAVE64 */ + 0x5aa, /* STGI */ + 0x188, /* CLGI */ + 0x59c, /* SKINIT */ + 0x28a, /* INVLPGA64 */ + 0x5a5, /* SMSW32r */ + 0x5a5, /* SMSW32r */ + 0x5a5, /* SMSW32r */ + 0x5a5, /* SMSW32r */ + 0x5a5, /* SMSW32r */ + 0x5a5, /* SMSW32r */ + 0x5a5, /* SMSW32r */ + 0x5a5, /* SMSW32r */ + 0x543, /* SETSSBSY */ + 0x0, /* */ + 0x4fc, /* SAVEPREVSSP */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x47b, /* RDPKRUr */ + 0x634, /* WRPKRUr */ + 0x2f6, /* LMSW16r */ + 0x2f6, /* LMSW16r */ + 0x2f6, /* LMSW16r */ + 0x2f6, /* LMSW16r */ + 0x2f6, /* LMSW16r */ + 0x2f6, /* LMSW16r */ + 0x2f6, /* LMSW16r */ + 0x2f6, /* LMSW16r */ + 0x5d8, /* SWAPGS */ + 0x486, /* RDTSCP */ + 0x31e, /* MONITORXrrr */ + 0x39e, /* MWAITXrrr */ + 0x18d, /* CLZEROr */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ +/* Table2603 */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x420, /* PTWRITEm */ + 0x0, /* */ + 0x18a, /* CLRSSBSY */ + 0x0, /* */ + 0x474, /* RDFSBASE */ + 0x476, /* RDGSBASE */ + 0x62f, /* WRFSBASE */ + 0x631, /* WRGSBASE */ + 0x421, /* PTWRITEr */ + 0x27c, /* INCSSPD */ + 0x60f, /* UMONITOR64 */ + 0x0, /* */ +/* Table2619 */ + 0x0, /* */ + 0x21e, /* CMPXCHG8B */ + 0x0, /* */ + 0x679, /* XRSTORS */ + 0x67d, /* XSAVEC */ + 0x681, /* XSAVES */ + 0x62c, /* VMXON */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x47a, /* RDPID64 */ +/* Table2635 */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x420, /* PTWRITEm */ + 0x0, /* */ + 0x18a, /* CLRSSBSY */ + 0x0, /* */ + 0x474, /* RDFSBASE */ + 0x476, /* RDGSBASE */ + 0x62f, /* WRFSBASE */ + 0x631, /* WRGSBASE */ + 0x421, /* PTWRITEr */ + 0x27c, /* INCSSPD */ + 0x60e, /* UMONITOR32 */ + 0x0, /* */ +/* Table2651 */ + 0x548, /* SGDT64m */ + 0x59b, /* SIDT64m */ + 0x2ea, /* LGDT64m */ + 0x2f0, /* LIDT64m */ + 0x5a3, /* SMSW16m */ + 0x4c5, /* RSTORSSP */ + 0x2f5, /* LMSW16m */ + 0x288, /* INVLPG */ + 0x0, /* */ + 0x615, /* VMCALL */ + 0x618, /* VMLAUNCH */ + 0x622, /* VMRESUME */ + 0x62b, /* VMXOFF */ + 0x3fb, /* PCONFIG */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x183, /* CLAC */ + 0x5a7, /* STAC */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x651, /* XGETBV */ + 0x683, /* XSETBV */ + 0x0, /* */ + 0x0, /* */ + 0x617, /* VMFUNC */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x624, /* VMRUN64 */ + 0x61b, /* VMMCALL */ + 0x61a, /* VMLOAD64 */ + 0x626, /* VMSAVE64 */ + 0x5aa, /* STGI */ + 0x188, /* CLGI */ + 0x59c, /* SKINIT */ + 0x28a, /* INVLPGA64 */ + 0x5a6, /* SMSW64r */ + 0x5a6, /* SMSW64r */ + 0x5a6, /* SMSW64r */ + 0x5a6, /* SMSW64r */ + 0x5a6, /* SMSW64r */ + 0x5a6, /* SMSW64r */ + 0x5a6, /* SMSW64r */ + 0x5a6, /* SMSW64r */ + 0x543, /* SETSSBSY */ + 0x0, /* */ + 0x4fc, /* SAVEPREVSSP */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x47b, /* RDPKRUr */ + 0x634, /* WRPKRUr */ + 0x2f6, /* LMSW16r */ + 0x2f6, /* LMSW16r */ + 0x2f6, /* LMSW16r */ + 0x2f6, /* LMSW16r */ + 0x2f6, /* LMSW16r */ + 0x2f6, /* LMSW16r */ + 0x2f6, /* LMSW16r */ + 0x2f6, /* LMSW16r */ + 0x5d8, /* SWAPGS */ + 0x486, /* RDTSCP */ + 0x31e, /* MONITORXrrr */ + 0x39e, /* MWAITXrrr */ + 0x18d, /* CLZEROr */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ +/* Table2723 */ + 0x3bc, /* NOOPL_1e */ + 0x3bc, /* NOOPL_1e */ + 0x3bc, /* NOOPL_1e */ + 0x3bc, /* NOOPL_1e */ + 0x3bc, /* NOOPL_1e */ + 0x3bc, /* NOOPL_1e */ + 0x3bc, /* NOOPL_1e */ + 0x3bc, /* NOOPL_1e */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x484, /* RDSSPQ */ + 0x484, /* RDSSPQ */ + 0x484, /* RDSSPQ */ + 0x484, /* RDSSPQ */ + 0x484, /* RDSSPQ */ + 0x484, /* RDSSPQ */ + 0x484, /* RDSSPQ */ + 0x484, /* RDSSPQ */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x23b, /* ENDBR64 */ + 0x23a, /* ENDBR32 */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ +/* Table2795 */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x41e, /* PTWRITE64m */ + 0x677, /* XRSTOR */ + 0x18a, /* CLRSSBSY */ + 0x0, /* */ + 0x475, /* RDFSBASE64 */ + 0x477, /* RDGSBASE64 */ + 0x630, /* WRFSBASE64 */ + 0x632, /* WRGSBASE64 */ + 0x41f, /* PTWRITE64r */ + 0x27d, /* INCSSPQ */ + 0x60f, /* UMONITOR64 */ + 0x0, /* */ +/* Table2811 */ + 0x604, /* TZCNT64rm */ + 0x605, /* TZCNT64rr */ +/* Table2813 */ + 0x31c, /* LZCNT64rm */ + 0x31d, /* LZCNT64rr */ +/* Table2815 */ + 0x0, /* */ + 0x217, /* CMPXCHG16B */ + 0x0, /* */ + 0x67a, /* XRSTORS64 */ + 0x67e, /* XSAVEC64 */ + 0x682, /* XSAVES64 */ + 0x62c, /* VMXON */ + 0x61d, /* VMPTRSTm */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x47e, /* RDRAND32r */ + 0x47a, /* RDPID64 */ +/* Table2831 */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x67b, /* XSAVE */ + 0x677, /* XRSTOR */ + 0x67f, /* XSAVEOPT */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x610, /* UMWAIT */ + 0x0, /* */ +/* Table2847 */ + 0x0, /* */ + 0x217, /* CMPXCHG16B */ + 0x0, /* */ + 0x67a, /* XRSTORS64 */ + 0x67e, /* XSAVEC64 */ + 0x682, /* XSAVES64 */ + 0x61c, /* VMPTRLDm */ + 0x61d, /* VMPTRSTm */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x47e, /* RDRAND32r */ + 0x481, /* RDSEED32r */ +/* Table2863 */ + 0x0, /* */ + 0x217, /* CMPXCHG16B */ + 0x0, /* */ + 0x67a, /* XRSTORS64 */ + 0x67e, /* XSAVEC64 */ + 0x682, /* XSAVES64 */ + 0x616, /* VMCLEARm */ + 0x61d, /* VMPTRSTm */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x47d, /* RDRAND16r */ + 0x480, /* RDSEED16r */ +/* Table2879 */ + 0x368, /* MOVBE32rm */ + 0x0, /* */ +/* Table2881 */ + 0x367, /* MOVBE32mr */ + 0x0, /* */ +/* Table2883 */ + 0x635, /* WRSSD */ + 0x0, /* */ +/* Table2885 */ + 0x36e, /* MOVDIRI32 */ + 0x0, /* */ +/* Table2887 */ + 0x286, /* INVEPT32 */ + 0x0, /* */ +/* Table2889 */ + 0x28d, /* INVVPID32 */ + 0x0, /* */ +/* Table2891 */ + 0x28b, /* INVPCID32 */ + 0x0, /* */ +/* Table2893 */ + 0x366, /* MOVBE16rm */ + 0x0, /* */ +/* Table2895 */ + 0x365, /* MOVBE16mr */ + 0x0, /* */ +/* Table2897 */ + 0x637, /* WRUSSD */ + 0x0, /* */ +/* Table2899 */ + 0xa6, /* ADCX32rm */ + 0xa7, /* ADCX32rr */ +/* Table2901 */ + 0x36c, /* MOVDIR64B32 */ + 0x0, /* */ +/* Table2903 */ + 0x36b, /* MOVDIR64B16 */ + 0x0, /* */ +/* Table2905 */ + 0xce, /* ADOX32rm */ + 0xcf, /* ADOX32rr */ +/* Table2907 */ + 0x36a, /* MOVBE64rm */ + 0x0, /* */ +/* Table2909 */ + 0x369, /* MOVBE64mr */ + 0x0, /* */ +/* Table2911 */ + 0x636, /* WRSSQ */ + 0x0, /* */ +/* Table2913 */ + 0x36f, /* MOVDIRI64 */ + 0x0, /* */ +/* Table2915 */ + 0x287, /* INVEPT64 */ + 0x0, /* */ +/* Table2917 */ + 0x28e, /* INVVPID64 */ + 0x0, /* */ +/* Table2919 */ + 0x28c, /* INVPCID64 */ + 0x0, /* */ +/* Table2921 */ + 0x636, /* WRSSQ */ + 0xa7, /* ADCX32rr */ +/* Table2923 */ + 0x36d, /* MOVDIR64B64 */ + 0x0, /* */ +/* Table2925 */ + 0xd0, /* ADOX64rm */ + 0xd1, /* ADOX64rr */ +/* Table2927 */ + 0x638, /* WRUSSQ */ + 0x0, /* */ +/* Table2929 */ + 0xa8, /* ADCX64rm */ + 0xa9, /* ADCX64rr */ +/* Table2931 */ + 0xf6, /* ANDN32rm */ + 0xf7, /* ANDN32rr */ +/* Table2933 */ + 0x0, /* */ + 0x128, /* BLSR32rm */ + 0x124, /* BLSMSK32rm */ + 0x11c, /* BLSI32rm */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x129, /* BLSR32rr */ + 0x125, /* BLSMSK32rr */ + 0x11d, /* BLSI32rr */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ +/* Table2949 */ + 0x16d, /* BZHI32rm */ + 0x16e, /* BZHI32rr */ +/* Table2951 */ + 0xfc, /* BEXTR32rm */ + 0xfd, /* BEXTR32rr */ +/* Table2953 */ + 0x400, /* PEXT32rm */ + 0x401, /* PEXT32rr */ +/* Table2955 */ + 0x4f8, /* SARX32rm */ + 0x4f9, /* SARX32rr */ +/* Table2957 */ + 0x3fc, /* PDEP32rm */ + 0x3fd, /* PDEP32rr */ +/* Table2959 */ + 0x39a, /* MULX32rm */ + 0x39b, /* MULX32rr */ +/* Table2961 */ + 0x595, /* SHRX32rm */ + 0x596, /* SHRX32rr */ +/* Table2963 */ + 0x56d, /* SHLX32rm */ + 0x56e, /* SHLX32rr */ +/* Table2965 */ + 0xf8, /* ANDN64rm */ + 0xf9, /* ANDN64rr */ +/* Table2967 */ + 0x0, /* */ + 0x12a, /* BLSR64rm */ + 0x126, /* BLSMSK64rm */ + 0x11e, /* BLSI64rm */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x12b, /* BLSR64rr */ + 0x127, /* BLSMSK64rr */ + 0x11f, /* BLSI64rr */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ +/* Table2983 */ + 0x16f, /* BZHI64rm */ + 0x170, /* BZHI64rr */ +/* Table2985 */ + 0xfe, /* BEXTR64rm */ + 0xff, /* BEXTR64rr */ +/* Table2987 */ + 0x402, /* PEXT64rm */ + 0x403, /* PEXT64rr */ +/* Table2989 */ + 0x4fa, /* SARX64rm */ + 0x4fb, /* SARX64rr */ +/* Table2991 */ + 0x3fe, /* PDEP64rm */ + 0x3ff, /* PDEP64rr */ +/* Table2993 */ + 0x39c, /* MULX64rm */ + 0x39d, /* MULX64rr */ +/* Table2995 */ + 0x597, /* SHRX64rm */ + 0x598, /* SHRX64rr */ +/* Table2997 */ + 0x56f, /* SHLX64rm */ + 0x570, /* SHLX64rr */ +/* Table2999 */ + 0x4c0, /* RORX32mi */ + 0x4c1, /* RORX32ri */ +/* Table3001 */ + 0x4c2, /* RORX64mi */ + 0x4c3, /* RORX64ri */ +/* Table3003 */ + 0x0, /* */ + 0x104, /* BLCFILL32rm */ + 0x118, /* BLSFILL32rm */ + 0x114, /* BLCS32rm */ + 0x606, /* TZMSK32rm */ + 0x10c, /* BLCIC32rm */ + 0x120, /* BLSIC32rm */ + 0x5df, /* T1MSKC32rm */ + 0x0, /* */ + 0x105, /* BLCFILL32rr */ + 0x119, /* BLSFILL32rr */ + 0x115, /* BLCS32rr */ + 0x607, /* TZMSK32rr */ + 0x10d, /* BLCIC32rr */ + 0x121, /* BLSIC32rr */ + 0x5e0, /* T1MSKC32rr */ +/* Table3019 */ + 0x0, /* */ + 0x110, /* BLCMSK32rm */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x108, /* BLCI32rm */ + 0x0, /* */ + 0x0, /* */ + 0x111, /* BLCMSK32rr */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x109, /* BLCI32rr */ + 0x0, /* */ +/* Table3035 */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x2f3, /* LLWPCB */ + 0x5a1, /* SLWPCB */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ +/* Table3051 */ + 0x0, /* */ + 0x106, /* BLCFILL64rm */ + 0x11a, /* BLSFILL64rm */ + 0x116, /* BLCS64rm */ + 0x608, /* TZMSK64rm */ + 0x10e, /* BLCIC64rm */ + 0x122, /* BLSIC64rm */ + 0x5e1, /* T1MSKC64rm */ + 0x0, /* */ + 0x107, /* BLCFILL64rr */ + 0x11b, /* BLSFILL64rr */ + 0x117, /* BLCS64rr */ + 0x609, /* TZMSK64rr */ + 0x10f, /* BLCIC64rr */ + 0x123, /* BLSIC64rr */ + 0x5e2, /* T1MSKC64rr */ +/* Table3067 */ + 0x0, /* */ + 0x112, /* BLCMSK64rm */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x10a, /* BLCI64rm */ + 0x0, /* */ + 0x0, /* */ + 0x113, /* BLCMSK64rr */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x10b, /* BLCI64rr */ + 0x0, /* */ +/* Table3083 */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x2f4, /* LLWPCB64 */ + 0x5a2, /* SLWPCB64 */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ +/* Table3099 */ + 0x100, /* BEXTRI32mi */ + 0x101, /* BEXTRI32ri */ +/* Table3101 */ + 0x310, /* LWPINS32rmi */ + 0x314, /* LWPVAL32rmi */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x311, /* LWPINS32rri */ + 0x315, /* LWPVAL32rri */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ +/* Table3117 */ + 0x102, /* BEXTRI64mi */ + 0x103, /* BEXTRI64ri */ +/* Table3119 */ + 0x312, /* LWPINS64rmi */ + 0x316, /* LWPVAL64rmi */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x313, /* LWPINS64rri */ + 0x317, /* LWPVAL64rri */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0, /* */ + 0x0 +}; + |