diff options
Diffstat (limited to 'src/cmd/objdump/x86.go')
| -rw-r--r-- | src/cmd/objdump/x86.go | 13800 |
1 files changed, 13800 insertions, 0 deletions
diff --git a/src/cmd/objdump/x86.go b/src/cmd/objdump/x86.go new file mode 100644 index 000000000..8e741331f --- /dev/null +++ b/src/cmd/objdump/x86.go @@ -0,0 +1,13800 @@ +// DO NOT EDIT. Generated by code.google.com/p/rsc/cmd/bundle +// bundle -p main -x x86_ rsc.io/x86/x86asm + +/* decode.go */ + +// Copyright 2014 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +// Table-driven decoding of x86 instructions. + +package main + +import ( + "bytes" + "encoding/binary" + "errors" + "fmt" + "runtime" + "strings" +) + +// Set trace to true to cause the decoder to print the PC sequence +// of the executed instruction codes. This is typically only useful +// when you are running a test of a single input case. +const x86_trace = false + +// A decodeOp is a single instruction in the decoder bytecode program. +// +// The decodeOps correspond to consuming and conditionally branching +// on input bytes, consuming additional fields, and then interpreting +// consumed data as instruction arguments. The names of the xRead and xArg +// operations are taken from the Intel manual conventions, for example +// Volume 2, Section 3.1.1, page 487 of +// http://www.intel.com/content/dam/www/public/us/en/documents/manuals/64-ia-32-architectures-software-developer-manual-325462.pdf +// +// The actual decoding program is generated by ../x86map. +// +// TODO(rsc): We may be able to merge various of the memory operands +// since we don't care about, say, the distinction between m80dec and m80bcd. +// Similarly, mm and mm1 have identical meaning, as do xmm and xmm1. + +type x86_decodeOp uint16 + +const ( + x86_xFail x86_decodeOp = iota // invalid instruction (return) + x86_xMatch // completed match + x86_xJump // jump to pc + + x86_xCondByte // switch on instruction byte value + x86_xCondSlashR // read and switch on instruction /r value + x86_xCondPrefix // switch on presence of instruction prefix + x86_xCondIs64 // switch on 64-bit processor mode + x86_xCondDataSize // switch on operand size + x86_xCondAddrSize // switch on address size + x86_xCondIsMem // switch on memory vs register argument + + x86_xSetOp // set instruction opcode + + x86_xReadSlashR // read /r + x86_xReadIb // read ib + x86_xReadIw // read iw + x86_xReadId // read id + x86_xReadIo // read io + x86_xReadCb // read cb + x86_xReadCw // read cw + x86_xReadCd // read cd + x86_xReadCp // read cp + x86_xReadCm // read cm + + x86_xArg1 // arg 1 + x86_xArg3 // arg 3 + x86_xArgAL // arg AL + x86_xArgAX // arg AX + x86_xArgCL // arg CL + x86_xArgCR0dashCR7 // arg CR0-CR7 + x86_xArgCS // arg CS + x86_xArgDR0dashDR7 // arg DR0-DR7 + x86_xArgDS // arg DS + x86_xArgDX // arg DX + x86_xArgEAX // arg EAX + x86_xArgEDX // arg EDX + x86_xArgES // arg ES + x86_xArgFS // arg FS + x86_xArgGS // arg GS + x86_xArgImm16 // arg imm16 + x86_xArgImm32 // arg imm32 + x86_xArgImm64 // arg imm64 + x86_xArgImm8 // arg imm8 + x86_xArgImm8u // arg imm8 but record as unsigned + x86_xArgImm16u // arg imm8 but record as unsigned + x86_xArgM // arg m + x86_xArgM128 // arg m128 + x86_xArgM1428byte // arg m14/28byte + x86_xArgM16 // arg m16 + x86_xArgM16and16 // arg m16&16 + x86_xArgM16and32 // arg m16&32 + x86_xArgM16and64 // arg m16&64 + x86_xArgM16colon16 // arg m16:16 + x86_xArgM16colon32 // arg m16:32 + x86_xArgM16colon64 // arg m16:64 + x86_xArgM16int // arg m16int + x86_xArgM2byte // arg m2byte + x86_xArgM32 // arg m32 + x86_xArgM32and32 // arg m32&32 + x86_xArgM32fp // arg m32fp + x86_xArgM32int // arg m32int + x86_xArgM512byte // arg m512byte + x86_xArgM64 // arg m64 + x86_xArgM64fp // arg m64fp + x86_xArgM64int // arg m64int + x86_xArgM8 // arg m8 + x86_xArgM80bcd // arg m80bcd + x86_xArgM80dec // arg m80dec + x86_xArgM80fp // arg m80fp + x86_xArgM94108byte // arg m94/108byte + x86_xArgMm // arg mm + x86_xArgMm1 // arg mm1 + x86_xArgMm2 // arg mm2 + x86_xArgMm2M64 // arg mm2/m64 + x86_xArgMmM32 // arg mm/m32 + x86_xArgMmM64 // arg mm/m64 + x86_xArgMem // arg mem + x86_xArgMoffs16 // arg moffs16 + x86_xArgMoffs32 // arg moffs32 + x86_xArgMoffs64 // arg moffs64 + x86_xArgMoffs8 // arg moffs8 + x86_xArgPtr16colon16 // arg ptr16:16 + x86_xArgPtr16colon32 // arg ptr16:32 + x86_xArgR16 // arg r16 + x86_xArgR16op // arg r16 with +rw in opcode + x86_xArgR32 // arg r32 + x86_xArgR32M16 // arg r32/m16 + x86_xArgR32M8 // arg r32/m8 + x86_xArgR32op // arg r32 with +rd in opcode + x86_xArgR64 // arg r64 + x86_xArgR64M16 // arg r64/m16 + x86_xArgR64op // arg r64 with +rd in opcode + x86_xArgR8 // arg r8 + x86_xArgR8op // arg r8 with +rb in opcode + x86_xArgRAX // arg RAX + x86_xArgRDX // arg RDX + x86_xArgRM // arg r/m + x86_xArgRM16 // arg r/m16 + x86_xArgRM32 // arg r/m32 + x86_xArgRM64 // arg r/m64 + x86_xArgRM8 // arg r/m8 + x86_xArgReg // arg reg + x86_xArgRegM16 // arg reg/m16 + x86_xArgRegM32 // arg reg/m32 + x86_xArgRegM8 // arg reg/m8 + x86_xArgRel16 // arg rel16 + x86_xArgRel32 // arg rel32 + x86_xArgRel8 // arg rel8 + x86_xArgSS // arg SS + x86_xArgST // arg ST, aka ST(0) + x86_xArgSTi // arg ST(i) with +i in opcode + x86_xArgSreg // arg Sreg + x86_xArgTR0dashTR7 // arg TR0-TR7 + x86_xArgXmm // arg xmm + x86_xArgXMM0 // arg <XMM0> + x86_xArgXmm1 // arg xmm1 + x86_xArgXmm2 // arg xmm2 + x86_xArgXmm2M128 // arg xmm2/m128 + x86_xArgXmm2M16 // arg xmm2/m16 + x86_xArgXmm2M32 // arg xmm2/m32 + x86_xArgXmm2M64 // arg xmm2/m64 + x86_xArgXmmM128 // arg xmm/m128 + x86_xArgXmmM32 // arg xmm/m32 + x86_xArgXmmM64 // arg xmm/m64 + x86_xArgRmf16 // arg r/m16 but force mod=3 + x86_xArgRmf32 // arg r/m32 but force mod=3 + x86_xArgRmf64 // arg r/m64 but force mod=3 +) + +// instPrefix returns an Inst describing just one prefix byte. +// It is only used if there is a prefix followed by an unintelligible +// or invalid instruction byte sequence. +func x86_instPrefix(b byte, mode int) (x86_Inst, error) { + // When tracing it is useful to see what called instPrefix to report an error. + if x86_trace { + _, file, line, _ := runtime.Caller(1) + fmt.Printf("%s:%d\n", file, line) + } + p := x86_Prefix(b) + switch p { + case x86_PrefixDataSize: + if mode == 16 { + p = x86_PrefixData32 + } else { + p = x86_PrefixData16 + } + case x86_PrefixAddrSize: + if mode == 32 { + p = x86_PrefixAddr16 + } else { + p = x86_PrefixAddr32 + } + } + // Note: using composite literal with Prefix key confuses 'bundle' tool. + inst := x86_Inst{Len: 1} + inst.Prefix = x86_Prefixes{p} + return inst, nil +} + +// truncated reports a truncated instruction. +// For now we use instPrefix but perhaps later we will return +// a specific error here. +func x86_truncated(src []byte, mode int) (x86_Inst, error) { + // return Inst{}, len(src), ErrTruncated + return x86_instPrefix(src[0], mode) // too long +} + +// These are the errors returned by Decode. +var ( + x86_ErrInvalidMode = errors.New("invalid x86 mode in Decode") + x86_ErrTruncated = errors.New("truncated instruction") + x86_ErrUnrecognized = errors.New("unrecognized instruction") +) + +// decoderCover records coverage information for which parts +// of the byte code have been executed. +// TODO(rsc): This is for testing. Only use this if a flag is given. +var x86_decoderCover []bool + +// Decode decodes the leading bytes in src as a single instruction. +// The mode arguments specifies the assumed processor mode: +// 16, 32, or 64 for 16-, 32-, and 64-bit execution modes. +func x86_Decode(src []byte, mode int) (inst x86_Inst, err error) { + return x86_decode1(src, mode, false) +} + +// decode1 is the implementation of Decode but takes an extra +// gnuCompat flag to cause it to change its behavior to mimic +// bugs (or at least unique features) of GNU libopcodes as used +// by objdump. We don't believe that logic is the right thing to do +// in general, but when testing against libopcodes it simplifies the +// comparison if we adjust a few small pieces of logic. +// The affected logic is in the conditional branch for "mandatory" prefixes, +// case xCondPrefix. +func x86_decode1(src []byte, mode int, gnuCompat bool) (x86_Inst, error) { + switch mode { + case 16, 32, 64: + // ok + // TODO(rsc): 64-bit mode not tested, probably not working. + default: + return x86_Inst{}, x86_ErrInvalidMode + } + + // Maximum instruction size is 15 bytes. + // If we need to read more, return 'truncated instruction. + if len(src) > 15 { + src = src[:15] + } + + var ( + // prefix decoding information + pos = 0 // position reading src + nprefix = 0 // number of prefixes + lockIndex = -1 // index of LOCK prefix in src and inst.Prefix + repIndex = -1 // index of REP/REPN prefix in src and inst.Prefix + segIndex = -1 // index of Group 2 prefix in src and inst.Prefix + dataSizeIndex = -1 // index of Group 3 prefix in src and inst.Prefix + addrSizeIndex = -1 // index of Group 4 prefix in src and inst.Prefix + rex x86_Prefix // rex byte if present (or 0) + rexUsed x86_Prefix // bits used in rex byte + rexIndex = -1 // index of rex byte + + addrMode = mode // address mode (width in bits) + dataMode = mode // operand mode (width in bits) + + // decoded ModR/M fields + haveModrm bool + modrm int + mod int + regop int + rm int + + // if ModR/M is memory reference, Mem form + mem x86_Mem + haveMem bool + + // decoded SIB fields + haveSIB bool + sib int + scale int + index int + base int + + // decoded immediate values + imm int64 + imm8 int8 + immc int64 + + // output + opshift int + inst x86_Inst + narg int // number of arguments written to inst + ) + + if mode == 64 { + dataMode = 32 + } + + // Prefixes are certainly the most complex and underspecified part of + // decoding x86 instructions. Although the manuals say things like + // up to four prefixes, one from each group, nearly everyone seems to + // agree that in practice as many prefixes as possible, including multiple + // from a particular group or repetitions of a given prefix, can be used on + // an instruction, provided the total instruction length including prefixes + // does not exceed the agreed-upon maximum of 15 bytes. + // Everyone also agrees that if one of these prefixes is the LOCK prefix + // and the instruction is not one of the instructions that can be used with + // the LOCK prefix or if the destination is not a memory operand, + // then the instruction is invalid and produces the #UD exception. + // However, that is the end of any semblance of agreement. + // + // What happens if prefixes are given that conflict with other prefixes? + // For example, the memory segment overrides CS, DS, ES, FS, GS, SS + // conflict with each other: only one segment can be in effect. + // Disassemblers seem to agree that later prefixes take priority over + // earlier ones. I have not taken the time to write assembly programs + // to check to see if the hardware agrees. + // + // What happens if prefixes are given that have no meaning for the + // specific instruction to which they are attached? It depends. + // If they really have no meaning, they are ignored. However, a future + // processor may assign a different meaning. As a disassembler, we + // don't really know whether we're seeing a meaningless prefix or one + // whose meaning we simply haven't been told yet. + // + // Combining the two questions, what happens when conflicting + // extension prefixes are given? No one seems to know for sure. + // For example, MOVQ is 66 0F D6 /r, MOVDQ2Q is F2 0F D6 /r, + // and MOVQ2DQ is F3 0F D6 /r. What is '66 F2 F3 0F D6 /r'? + // Which prefix wins? See the xCondPrefix prefix for more. + // + // Writing assembly test cases to divine which interpretation the + // CPU uses might clarify the situation, but more likely it would + // make the situation even less clear. + + // Read non-REX prefixes. +ReadPrefixes: + for ; pos < len(src); pos++ { + p := x86_Prefix(src[pos]) + switch p { + default: + nprefix = pos + break ReadPrefixes + + // Group 1 - lock and repeat prefixes + // According to Intel, there should only be one from this set, + // but according to AMD both can be present. + case 0xF0: + if lockIndex >= 0 { + inst.Prefix[lockIndex] |= x86_PrefixIgnored + } + lockIndex = pos + case 0xF2, 0xF3: + if repIndex >= 0 { + inst.Prefix[repIndex] |= x86_PrefixIgnored + } + repIndex = pos + + // Group 2 - segment override / branch hints + case 0x26, 0x2E, 0x36, 0x3E: + if mode == 64 { + p |= x86_PrefixIgnored + break + } + fallthrough + case 0x64, 0x65: + if segIndex >= 0 { + inst.Prefix[segIndex] |= x86_PrefixIgnored + } + segIndex = pos + + // Group 3 - operand size override + case 0x66: + if mode == 16 { + dataMode = 32 + p = x86_PrefixData32 + } else { + dataMode = 16 + p = x86_PrefixData16 + } + if dataSizeIndex >= 0 { + inst.Prefix[dataSizeIndex] |= x86_PrefixIgnored + } + dataSizeIndex = pos + + // Group 4 - address size override + case 0x67: + if mode == 32 { + addrMode = 16 + p = x86_PrefixAddr16 + } else { + addrMode = 32 + p = x86_PrefixAddr32 + } + if addrSizeIndex >= 0 { + inst.Prefix[addrSizeIndex] |= x86_PrefixIgnored + } + addrSizeIndex = pos + } + + if pos >= len(inst.Prefix) { + return x86_instPrefix(src[0], mode) // too long + } + + inst.Prefix[pos] = p + } + + // Read REX prefix. + if pos < len(src) && mode == 64 && x86_Prefix(src[pos]).IsREX() { + rex = x86_Prefix(src[pos]) + rexIndex = pos + if pos >= len(inst.Prefix) { + return x86_instPrefix(src[0], mode) // too long + } + inst.Prefix[pos] = rex + pos++ + if rex&x86_PrefixREXW != 0 { + dataMode = 64 + if dataSizeIndex >= 0 { + inst.Prefix[dataSizeIndex] |= x86_PrefixIgnored + } + } + } + + // Decode instruction stream, interpreting decoding instructions. + // opshift gives the shift to use when saving the next + // opcode byte into inst.Opcode. + opshift = 24 + if x86_decoderCover == nil { + x86_decoderCover = make([]bool, len(x86_decoder)) + } + + // Decode loop, executing decoder program. + var oldPC, prevPC int +Decode: + for pc := 1; ; { // TODO uint + oldPC = prevPC + prevPC = pc + if x86_trace { + println("run", pc) + } + x := x86_decoder[pc] + x86_decoderCover[pc] = true + pc++ + + // Read and decode ModR/M if needed by opcode. + switch x86_decodeOp(x) { + case x86_xCondSlashR, x86_xReadSlashR: + if haveModrm { + return x86_Inst{Len: pos}, x86_errInternal + } + haveModrm = true + if pos >= len(src) { + return x86_truncated(src, mode) + } + modrm = int(src[pos]) + pos++ + if opshift >= 0 { + inst.Opcode |= uint32(modrm) << uint(opshift) + opshift -= 8 + } + mod = modrm >> 6 + regop = (modrm >> 3) & 07 + rm = modrm & 07 + if rex&x86_PrefixREXR != 0 { + rexUsed |= x86_PrefixREXR + regop |= 8 + } + if addrMode == 16 { + // 16-bit modrm form + if mod != 3 { + haveMem = true + mem = x86_addr16[rm] + if rm == 6 && mod == 0 { + mem.Base = 0 + } + + // Consume disp16 if present. + if mod == 0 && rm == 6 || mod == 2 { + if pos+2 > len(src) { + return x86_truncated(src, mode) + } + mem.Disp = int64(binary.LittleEndian.Uint16(src[pos:])) + pos += 2 + } + + // Consume disp8 if present. + if mod == 1 { + if pos >= len(src) { + return x86_truncated(src, mode) + } + mem.Disp = int64(int8(src[pos])) + pos++ + } + } + } else { + haveMem = mod != 3 + + // 32-bit or 64-bit form + // Consume SIB encoding if present. + if rm == 4 && mod != 3 { + haveSIB = true + if pos >= len(src) { + return x86_truncated(src, mode) + } + sib = int(src[pos]) + pos++ + if opshift >= 0 { + inst.Opcode |= uint32(sib) << uint(opshift) + opshift -= 8 + } + scale = sib >> 6 + index = (sib >> 3) & 07 + base = sib & 07 + if rex&x86_PrefixREXB != 0 { + rexUsed |= x86_PrefixREXB + base |= 8 + } + if rex&x86_PrefixREXX != 0 { + rexUsed |= x86_PrefixREXX + index |= 8 + } + + mem.Scale = 1 << uint(scale) + if index == 4 { + // no mem.Index + } else { + mem.Index = x86_baseRegForBits(addrMode) + x86_Reg(index) + } + if base&7 == 5 && mod == 0 { + // no mem.Base + } else { + mem.Base = x86_baseRegForBits(addrMode) + x86_Reg(base) + } + } else { + if rex&x86_PrefixREXB != 0 { + rexUsed |= x86_PrefixREXB + rm |= 8 + } + if mod == 0 && rm&7 == 5 || rm&7 == 4 { + // base omitted + } else if mod != 3 { + mem.Base = x86_baseRegForBits(addrMode) + x86_Reg(rm) + } + } + + // Consume disp32 if present. + if mod == 0 && (rm&7 == 5 || haveSIB && base&7 == 5) || mod == 2 { + if pos+4 > len(src) { + return x86_truncated(src, mode) + } + mem.Disp = int64(binary.LittleEndian.Uint32(src[pos:])) + pos += 4 + } + + // Consume disp8 if present. + if mod == 1 { + if pos >= len(src) { + return x86_truncated(src, mode) + } + mem.Disp = int64(int8(src[pos])) + pos++ + } + + // In 64-bit, mod=0 rm=5 is PC-relative instead of just disp. + // See Vol 2A. Table 2-7. + if mode == 64 && mod == 0 && rm&7 == 5 { + if addrMode == 32 { + mem.Base = x86_EIP + } else { + mem.Base = x86_RIP + } + } + } + + if segIndex >= 0 { + mem.Segment = x86_prefixToSegment(inst.Prefix[segIndex]) + } + } + + // Execute single opcode. + switch x86_decodeOp(x) { + default: + println("bad op", x, "at", pc-1, "from", oldPC) + return x86_Inst{Len: pos}, x86_errInternal + + case x86_xFail: + inst.Op = 0 + break Decode + + case x86_xMatch: + break Decode + + case x86_xJump: + pc = int(x86_decoder[pc]) + + // Conditional branches. + + case x86_xCondByte: + if pos >= len(src) { + return x86_truncated(src, mode) + } + b := src[pos] + n := int(x86_decoder[pc]) + pc++ + for i := 0; i < n; i++ { + xb, xpc := x86_decoder[pc], int(x86_decoder[pc+1]) + pc += 2 + if b == byte(xb) { + pc = xpc + pos++ + if opshift >= 0 { + inst.Opcode |= uint32(b) << uint(opshift) + opshift -= 8 + } + continue Decode + } + } + // xCondByte is the only conditional with a fall through, + // so that it can be used to pick off special cases before + // an xCondSlash. If the fallthrough instruction is xFail, + // advance the position so that the decoded instruction + // size includes the byte we just compared against. + if x86_decodeOp(x86_decoder[pc]) == x86_xJump { + pc = int(x86_decoder[pc+1]) + } + if x86_decodeOp(x86_decoder[pc]) == x86_xFail { + pos++ + } + + case x86_xCondIs64: + if mode == 64 { + pc = int(x86_decoder[pc+1]) + } else { + pc = int(x86_decoder[pc]) + } + + case x86_xCondIsMem: + mem := haveMem + if !haveModrm { + if pos >= len(src) { + return x86_instPrefix(src[0], mode) // too long + } + mem = src[pos]>>6 != 3 + } + if mem { + pc = int(x86_decoder[pc+1]) + } else { + pc = int(x86_decoder[pc]) + } + + case x86_xCondDataSize: + switch dataMode { + case 16: + if dataSizeIndex >= 0 { + inst.Prefix[dataSizeIndex] |= x86_PrefixImplicit + } + pc = int(x86_decoder[pc]) + case 32: + if dataSizeIndex >= 0 { + inst.Prefix[dataSizeIndex] |= x86_PrefixImplicit + } + pc = int(x86_decoder[pc+1]) + case 64: + rexUsed |= x86_PrefixREXW + pc = int(x86_decoder[pc+2]) + } + + case x86_xCondAddrSize: + switch addrMode { + case 16: + if addrSizeIndex >= 0 { + inst.Prefix[addrSizeIndex] |= x86_PrefixImplicit + } + pc = int(x86_decoder[pc]) + case 32: + if addrSizeIndex >= 0 { + inst.Prefix[addrSizeIndex] |= x86_PrefixImplicit + } + pc = int(x86_decoder[pc+1]) + case 64: + pc = int(x86_decoder[pc+2]) + } + + case x86_xCondPrefix: + // Conditional branch based on presence or absence of prefixes. + // The conflict cases here are completely undocumented and + // differ significantly between GNU libopcodes and Intel xed. + // I have not written assembly code to divine what various CPUs + // do, but it wouldn't surprise me if they are not consistent either. + // + // The basic idea is to switch on the presence of a prefix, so that + // for example: + // + // xCondPrefix, 4 + // 0xF3, 123, + // 0xF2, 234, + // 0x66, 345, + // 0, 456 + // + // branch to 123 if the F3 prefix is present, 234 if the F2 prefix + // is present, 66 if the 345 prefix is present, and 456 otherwise. + // The prefixes are given in descending order so that the 0 will be last. + // + // It is unclear what should happen if multiple conditions are + // satisfied: what if F2 and F3 are both present, or if 66 and F2 + // are present, or if all three are present? The one chosen becomes + // part of the opcode and the others do not. Perhaps the answer + // depends on the specific opcodes in question. + // + // The only clear example is that CRC32 is F2 0F 38 F1 /r, and + // it comes in 16-bit and 32-bit forms based on the 66 prefix, + // so 66 F2 0F 38 F1 /r should be treated as F2 taking priority, + // with the 66 being only an operand size override, and probably + // F2 66 0F 38 F1 /r should be treated the same. + // Perhaps that rule is specific to the case of CRC32, since no + // 66 0F 38 F1 instruction is defined (today) (that we know of). + // However, both libopcodes and xed seem to generalize this + // example and choose F2/F3 in preference to 66, and we + // do the same. + // + // Next, what if both F2 and F3 are present? Which wins? + // The Intel xed rule, and ours, is that the one that occurs last wins. + // The GNU libopcodes rule, which we implement only in gnuCompat mode, + // is that F3 beats F2 unless F3 has no special meaning, in which + // case F3 can be a modified on an F2 special meaning. + // + // Concretely, + // 66 0F D6 /r is MOVQ + // F2 0F D6 /r is MOVDQ2Q + // F3 0F D6 /r is MOVQ2DQ. + // + // F2 66 0F D6 /r is 66 + MOVDQ2Q always. + // 66 F2 0F D6 /r is 66 + MOVDQ2Q always. + // F3 66 0F D6 /r is 66 + MOVQ2DQ always. + // 66 F3 0F D6 /r is 66 + MOVQ2DQ always. + // F2 F3 0F D6 /r is F2 + MOVQ2DQ always. + // F3 F2 0F D6 /r is F3 + MOVQ2DQ in Intel xed, but F2 + MOVQ2DQ in GNU libopcodes. + // Adding 66 anywhere in the prefix section of the + // last two cases does not change the outcome. + // + // Finally, what if there is a variant in which 66 is a mandatory + // prefix rather than an operand size override, but we know of + // no corresponding F2/F3 form, and we see both F2/F3 and 66. + // Does F2/F3 still take priority, so that the result is an unknown + // instruction, or does the 66 take priority, so that the extended + // 66 instruction should be interpreted as having a REP/REPN prefix? + // Intel xed does the former and GNU libopcodes does the latter. + // We side with Intel xed, unless we are trying to match libopcodes + // more closely during the comparison-based test suite. + // + // In 64-bit mode REX.W is another valid prefix to test for, but + // there is less ambiguity about that. When present, REX.W is + // always the first entry in the table. + n := int(x86_decoder[pc]) + pc++ + sawF3 := false + for j := 0; j < n; j++ { + prefix := x86_Prefix(x86_decoder[pc+2*j]) + if prefix.IsREX() { + rexUsed |= prefix + if rex&prefix == prefix { + pc = int(x86_decoder[pc+2*j+1]) + continue Decode + } + continue + } + ok := false + if prefix == 0 { + ok = true + } else if prefix.IsREX() { + rexUsed |= prefix + if rex&prefix == prefix { + ok = true + } + } else { + if prefix == 0xF3 { + sawF3 = true + } + switch prefix { + case x86_PrefixLOCK: + if lockIndex >= 0 { + inst.Prefix[lockIndex] |= x86_PrefixImplicit + ok = true + } + case x86_PrefixREP, x86_PrefixREPN: + if repIndex >= 0 && inst.Prefix[repIndex]&0xFF == prefix { + inst.Prefix[repIndex] |= x86_PrefixImplicit + ok = true + } + if gnuCompat && !ok && prefix == 0xF3 && repIndex >= 0 && (j+1 >= n || x86_decoder[pc+2*(j+1)] != 0xF2) { + // Check to see if earlier prefix F3 is present. + for i := repIndex - 1; i >= 0; i-- { + if inst.Prefix[i]&0xFF == prefix { + inst.Prefix[i] |= x86_PrefixImplicit + ok = true + } + } + } + if gnuCompat && !ok && prefix == 0xF2 && repIndex >= 0 && !sawF3 && inst.Prefix[repIndex]&0xFF == 0xF3 { + // Check to see if earlier prefix F2 is present. + for i := repIndex - 1; i >= 0; i-- { + if inst.Prefix[i]&0xFF == prefix { + inst.Prefix[i] |= x86_PrefixImplicit + ok = true + } + } + } + case x86_PrefixCS, x86_PrefixDS, x86_PrefixES, x86_PrefixFS, x86_PrefixGS, x86_PrefixSS: + if segIndex >= 0 && inst.Prefix[segIndex]&0xFF == prefix { + inst.Prefix[segIndex] |= x86_PrefixImplicit + ok = true + } + case x86_PrefixDataSize: + // Looking for 66 mandatory prefix. + // The F2/F3 mandatory prefixes take priority when both are present. + // If we got this far in the xCondPrefix table and an F2/F3 is present, + // it means the table didn't have any entry for that prefix. But if 66 has + // special meaning, perhaps F2/F3 have special meaning that we don't know. + // Intel xed works this way, treating the F2/F3 as inhibiting the 66. + // GNU libopcodes allows the 66 to match. We do what Intel xed does + // except in gnuCompat mode. + if repIndex >= 0 && !gnuCompat { + inst.Op = 0 + break Decode + } + if dataSizeIndex >= 0 { + inst.Prefix[dataSizeIndex] |= x86_PrefixImplicit + ok = true + } + case x86_PrefixAddrSize: + if addrSizeIndex >= 0 { + inst.Prefix[addrSizeIndex] |= x86_PrefixImplicit + ok = true + } + } + } + if ok { + pc = int(x86_decoder[pc+2*j+1]) + continue Decode + } + } + inst.Op = 0 + break Decode + + case x86_xCondSlashR: + pc = int(x86_decoder[pc+regop&7]) + + // Input. + + case x86_xReadSlashR: + // done above + + case x86_xReadIb: + if pos >= len(src) { + return x86_truncated(src, mode) + } + imm8 = int8(src[pos]) + pos++ + + case x86_xReadIw: + if pos+2 > len(src) { + return x86_truncated(src, mode) + } + imm = int64(binary.LittleEndian.Uint16(src[pos:])) + pos += 2 + + case x86_xReadId: + if pos+4 > len(src) { + return x86_truncated(src, mode) + } + imm = int64(binary.LittleEndian.Uint32(src[pos:])) + pos += 4 + + case x86_xReadIo: + if pos+8 > len(src) { + return x86_truncated(src, mode) + } + imm = int64(binary.LittleEndian.Uint64(src[pos:])) + pos += 8 + + case x86_xReadCb: + if pos >= len(src) { + return x86_truncated(src, mode) + } + immc = int64(src[pos]) + pos++ + + case x86_xReadCw: + if pos+2 > len(src) { + return x86_truncated(src, mode) + } + immc = int64(binary.LittleEndian.Uint16(src[pos:])) + pos += 2 + + case x86_xReadCm: + if addrMode == 16 { + if pos+2 > len(src) { + return x86_truncated(src, mode) + } + immc = int64(binary.LittleEndian.Uint16(src[pos:])) + pos += 2 + } else if addrMode == 32 { + if pos+4 > len(src) { + return x86_truncated(src, mode) + } + immc = int64(binary.LittleEndian.Uint32(src[pos:])) + pos += 4 + } else { + if pos+8 > len(src) { + return x86_truncated(src, mode) + } + immc = int64(binary.LittleEndian.Uint64(src[pos:])) + pos += 8 + } + case x86_xReadCd: + if pos+4 > len(src) { + return x86_truncated(src, mode) + } + immc = int64(binary.LittleEndian.Uint32(src[pos:])) + pos += 4 + + case x86_xReadCp: + if pos+6 > len(src) { + return x86_truncated(src, mode) + } + w := binary.LittleEndian.Uint32(src[pos:]) + w2 := binary.LittleEndian.Uint16(src[pos+4:]) + immc = int64(w2)<<32 | int64(w) + pos += 6 + + // Output. + + case x86_xSetOp: + inst.Op = x86_Op(x86_decoder[pc]) + pc++ + + case x86_xArg1, + x86_xArg3, + x86_xArgAL, + x86_xArgAX, + x86_xArgCL, + x86_xArgCS, + x86_xArgDS, + x86_xArgDX, + x86_xArgEAX, + x86_xArgEDX, + x86_xArgES, + x86_xArgFS, + x86_xArgGS, + x86_xArgRAX, + x86_xArgRDX, + x86_xArgSS, + x86_xArgST, + x86_xArgXMM0: + inst.Args[narg] = x86_fixedArg[x] + narg++ + + case x86_xArgImm8: + inst.Args[narg] = x86_Imm(imm8) + narg++ + + case x86_xArgImm8u: + inst.Args[narg] = x86_Imm(uint8(imm8)) + narg++ + + case x86_xArgImm16: + inst.Args[narg] = x86_Imm(int16(imm)) + narg++ + + case x86_xArgImm16u: + inst.Args[narg] = x86_Imm(uint16(imm)) + narg++ + + case x86_xArgImm32: + inst.Args[narg] = x86_Imm(int32(imm)) + narg++ + + case x86_xArgImm64: + inst.Args[narg] = x86_Imm(imm) + narg++ + + case x86_xArgM, + x86_xArgM128, + x86_xArgM1428byte, + x86_xArgM16, + x86_xArgM16and16, + x86_xArgM16and32, + x86_xArgM16and64, + x86_xArgM16colon16, + x86_xArgM16colon32, + x86_xArgM16colon64, + x86_xArgM16int, + x86_xArgM2byte, + x86_xArgM32, + x86_xArgM32and32, + x86_xArgM32fp, + x86_xArgM32int, + x86_xArgM512byte, + x86_xArgM64, + x86_xArgM64fp, + x86_xArgM64int, + x86_xArgM8, + x86_xArgM80bcd, + x86_xArgM80dec, + x86_xArgM80fp, + x86_xArgM94108byte, + x86_xArgMem: + if !haveMem { + inst.Op = 0 + break Decode + } + inst.Args[narg] = mem + inst.MemBytes = int(x86_memBytes[x86_decodeOp(x)]) + narg++ + + case x86_xArgPtr16colon16: + inst.Args[narg] = x86_Imm(immc >> 16) + inst.Args[narg+1] = x86_Imm(immc & (1<<16 - 1)) + narg += 2 + + case x86_xArgPtr16colon32: + inst.Args[narg] = x86_Imm(immc >> 32) + inst.Args[narg+1] = x86_Imm(immc & (1<<32 - 1)) + narg += 2 + + case x86_xArgMoffs8, x86_xArgMoffs16, x86_xArgMoffs32, x86_xArgMoffs64: + // TODO(rsc): Can address be 64 bits? + mem = x86_Mem{Disp: int64(immc)} + if segIndex >= 0 { + mem.Segment = x86_prefixToSegment(inst.Prefix[segIndex]) + inst.Prefix[segIndex] |= x86_PrefixImplicit + } + inst.Args[narg] = mem + inst.MemBytes = int(x86_memBytes[x86_decodeOp(x)]) + narg++ + + case x86_xArgR8, x86_xArgR16, x86_xArgR32, x86_xArgR64, x86_xArgXmm, x86_xArgXmm1, x86_xArgDR0dashDR7: + base := x86_baseReg[x] + index := x86_Reg(regop) + if rex != 0 && base == x86_AL && index >= 4 { + rexUsed |= x86_PrefixREX + index -= 4 + base = x86_SPB + } + inst.Args[narg] = base + index + narg++ + + case x86_xArgMm, x86_xArgMm1, x86_xArgTR0dashTR7: + inst.Args[narg] = x86_baseReg[x] + x86_Reg(regop&7) + narg++ + + case x86_xArgCR0dashCR7: + // AMD documents an extension that the LOCK prefix + // can be used in place of a REX prefix in order to access + // CR8 from 32-bit mode. The LOCK prefix is allowed in + // all modes, provided the corresponding CPUID bit is set. + if lockIndex >= 0 { + inst.Prefix[lockIndex] |= x86_PrefixImplicit + regop += 8 + } + inst.Args[narg] = x86_CR0 + x86_Reg(regop) + narg++ + + case x86_xArgSreg: + regop &= 7 + if regop >= 6 { + inst.Op = 0 + break Decode + } + inst.Args[narg] = x86_ES + x86_Reg(regop) + narg++ + + case x86_xArgRmf16, x86_xArgRmf32, x86_xArgRmf64: + base := x86_baseReg[x] + index := x86_Reg(modrm & 07) + if rex&x86_PrefixREXB != 0 { + rexUsed |= x86_PrefixREXB + index += 8 + } + inst.Args[narg] = base + index + narg++ + + case x86_xArgR8op, x86_xArgR16op, x86_xArgR32op, x86_xArgR64op, x86_xArgSTi: + n := inst.Opcode >> uint(opshift+8) & 07 + base := x86_baseReg[x] + index := x86_Reg(n) + if rex&x86_PrefixREXB != 0 && x86_decodeOp(x) != x86_xArgSTi { + rexUsed |= x86_PrefixREXB + index += 8 + } + if rex != 0 && base == x86_AL && index >= 4 { + rexUsed |= x86_PrefixREX + index -= 4 + base = x86_SPB + } + inst.Args[narg] = base + index + narg++ + + case x86_xArgRM8, x86_xArgRM16, x86_xArgRM32, x86_xArgRM64, x86_xArgR32M16, x86_xArgR32M8, x86_xArgR64M16, + x86_xArgMmM32, x86_xArgMmM64, x86_xArgMm2M64, + x86_xArgXmm2M16, x86_xArgXmm2M32, x86_xArgXmm2M64, x86_xArgXmmM64, x86_xArgXmmM128, x86_xArgXmmM32, x86_xArgXmm2M128: + if haveMem { + inst.Args[narg] = mem + inst.MemBytes = int(x86_memBytes[x86_decodeOp(x)]) + } else { + base := x86_baseReg[x] + index := x86_Reg(rm) + switch x86_decodeOp(x) { + case x86_xArgMmM32, x86_xArgMmM64, x86_xArgMm2M64: + // There are only 8 MMX registers, so these ignore the REX.X bit. + index &= 7 + case x86_xArgRM8: + if rex != 0 && index >= 4 { + rexUsed |= x86_PrefixREX + index -= 4 + base = x86_SPB + } + } + inst.Args[narg] = base + index + } + narg++ + + case x86_xArgMm2: // register only; TODO(rsc): Handle with tag modrm_regonly tag + if haveMem { + inst.Op = 0 + break Decode + } + inst.Args[narg] = x86_baseReg[x] + x86_Reg(rm&7) + narg++ + + case x86_xArgXmm2: // register only; TODO(rsc): Handle with tag modrm_regonly tag + if haveMem { + inst.Op = 0 + break Decode + } + inst.Args[narg] = x86_baseReg[x] + x86_Reg(rm) + narg++ + + case x86_xArgRel8: + inst.Args[narg] = x86_Rel(int8(immc)) + narg++ + + case x86_xArgRel16: + inst.Args[narg] = x86_Rel(int16(immc)) + narg++ + + case x86_xArgRel32: + inst.Args[narg] = x86_Rel(int32(immc)) + narg++ + } + } + + if inst.Op == 0 { + // Invalid instruction. + if nprefix > 0 { + return x86_instPrefix(src[0], mode) // invalid instruction + } + return x86_Inst{Len: pos}, x86_ErrUnrecognized + } + + // Matched! Hooray! + + // 90 decodes as XCHG EAX, EAX but is NOP. + // 66 90 decodes as XCHG AX, AX and is NOP too. + // 48 90 decodes as XCHG RAX, RAX and is NOP too. + // 43 90 decodes as XCHG R8D, EAX and is *not* NOP. + // F3 90 decodes as REP XCHG EAX, EAX but is PAUSE. + // It's all too special to handle in the decoding tables, at least for now. + if inst.Op == x86_XCHG && inst.Opcode>>24 == 0x90 { + if inst.Args[0] == x86_RAX || inst.Args[0] == x86_EAX || inst.Args[0] == x86_AX { + inst.Op = x86_NOP + if dataSizeIndex >= 0 { + inst.Prefix[dataSizeIndex] &^= x86_PrefixImplicit + } + inst.Args[0] = nil + inst.Args[1] = nil + } + if repIndex >= 0 && inst.Prefix[repIndex] == 0xF3 { + inst.Prefix[repIndex] |= x86_PrefixImplicit + inst.Op = x86_PAUSE + inst.Args[0] = nil + inst.Args[1] = nil + } else if gnuCompat { + for i := nprefix - 1; i >= 0; i-- { + if inst.Prefix[i]&0xFF == 0xF3 { + inst.Prefix[i] |= x86_PrefixImplicit + inst.Op = x86_PAUSE + inst.Args[0] = nil + inst.Args[1] = nil + break + } + } + } + } + + // defaultSeg returns the default segment for an implicit + // memory reference: the final override if present, or else DS. + defaultSeg := func() x86_Reg { + if segIndex >= 0 { + inst.Prefix[segIndex] |= x86_PrefixImplicit + return x86_prefixToSegment(inst.Prefix[segIndex]) + } + return x86_DS + } + + // Add implicit arguments not present in the tables. + // Normally we shy away from making implicit arguments explicit, + // following the Intel manuals, but adding the arguments seems + // the best way to express the effect of the segment override prefixes. + // TODO(rsc): Perhaps add these to the tables and + // create bytecode instructions for them. + usedAddrSize := false + switch inst.Op { + case x86_INSB, x86_INSW, x86_INSD: + inst.Args[0] = x86_Mem{Segment: x86_ES, Base: x86_baseRegForBits(addrMode) + x86_DI - x86_AX} + inst.Args[1] = x86_DX + usedAddrSize = true + + case x86_OUTSB, x86_OUTSW, x86_OUTSD: + inst.Args[0] = x86_DX + inst.Args[1] = x86_Mem{Segment: defaultSeg(), Base: x86_baseRegForBits(addrMode) + x86_SI - x86_AX} + usedAddrSize = true + + case x86_MOVSB, x86_MOVSW, x86_MOVSD, x86_MOVSQ: + inst.Args[0] = x86_Mem{Segment: x86_ES, Base: x86_baseRegForBits(addrMode) + x86_DI - x86_AX} + inst.Args[1] = x86_Mem{Segment: defaultSeg(), Base: x86_baseRegForBits(addrMode) + x86_SI - x86_AX} + usedAddrSize = true + + case x86_CMPSB, x86_CMPSW, x86_CMPSD, x86_CMPSQ: + inst.Args[0] = x86_Mem{Segment: defaultSeg(), Base: x86_baseRegForBits(addrMode) + x86_SI - x86_AX} + inst.Args[1] = x86_Mem{Segment: x86_ES, Base: x86_baseRegForBits(addrMode) + x86_DI - x86_AX} + usedAddrSize = true + + case x86_LODSB, x86_LODSW, x86_LODSD, x86_LODSQ: + switch inst.Op { + case x86_LODSB: + inst.Args[0] = x86_AL + case x86_LODSW: + inst.Args[0] = x86_AX + case x86_LODSD: + inst.Args[0] = x86_EAX + case x86_LODSQ: + inst.Args[0] = x86_RAX + } + inst.Args[1] = x86_Mem{Segment: defaultSeg(), Base: x86_baseRegForBits(addrMode) + x86_SI - x86_AX} + usedAddrSize = true + + case x86_STOSB, x86_STOSW, x86_STOSD, x86_STOSQ: + inst.Args[0] = x86_Mem{Segment: x86_ES, Base: x86_baseRegForBits(addrMode) + x86_DI - x86_AX} + switch inst.Op { + case x86_STOSB: + inst.Args[1] = x86_AL + case x86_STOSW: + inst.Args[1] = x86_AX + case x86_STOSD: + inst.Args[1] = x86_EAX + case x86_STOSQ: + inst.Args[1] = x86_RAX + } + usedAddrSize = true + + case x86_SCASB, x86_SCASW, x86_SCASD, x86_SCASQ: + inst.Args[1] = x86_Mem{Segment: x86_ES, Base: x86_baseRegForBits(addrMode) + x86_DI - x86_AX} + switch inst.Op { + case x86_SCASB: + inst.Args[0] = x86_AL + case x86_SCASW: + inst.Args[0] = x86_AX + case x86_SCASD: + inst.Args[0] = x86_EAX + case x86_SCASQ: + inst.Args[0] = x86_RAX + } + usedAddrSize = true + + case x86_XLATB: + inst.Args[0] = x86_Mem{Segment: defaultSeg(), Base: x86_baseRegForBits(addrMode) + x86_BX - x86_AX} + usedAddrSize = true + } + + // If we used the address size annotation to construct the + // argument list, mark that prefix as implicit: it doesn't need + // to be shown when printing the instruction. + if haveMem || usedAddrSize { + if addrSizeIndex >= 0 { + inst.Prefix[addrSizeIndex] |= x86_PrefixImplicit + } + } + + // Similarly, if there's some memory operand, the segment + // will be shown there and doesn't need to be shown as an + // explicit prefix. + if haveMem { + if segIndex >= 0 { + inst.Prefix[segIndex] |= x86_PrefixImplicit + } + } + + // Branch predict prefixes are overloaded segment prefixes, + // since segment prefixes don't make sense on conditional jumps. + // Rewrite final instance to prediction prefix. + // The set of instructions to which the prefixes apply (other then the + // Jcc conditional jumps) is not 100% clear from the manuals, but + // the disassemblers seem to agree about the LOOP and JCXZ instructions, + // so we'll follow along. + // TODO(rsc): Perhaps this instruction class should be derived from the CSV. + if x86_isCondJmp[inst.Op] || x86_isLoop[inst.Op] || inst.Op == x86_JCXZ || inst.Op == x86_JECXZ || inst.Op == x86_JRCXZ { + PredictLoop: + for i := nprefix - 1; i >= 0; i-- { + p := inst.Prefix[i] + switch p & 0xFF { + case x86_PrefixCS: + inst.Prefix[i] = x86_PrefixPN + break PredictLoop + case x86_PrefixDS: + inst.Prefix[i] = x86_PrefixPT + break PredictLoop + } + } + } + + // The BND prefix is part of the Intel Memory Protection Extensions (MPX). + // A REPN applied to certain control transfers is a BND prefix to bound + // the range of possible destinations. There's surprisingly little documentation + // about this, so we just do what libopcodes and xed agree on. + // In particular, it's unclear why a REPN applied to LOOP or JCXZ instructions + // does not turn into a BND. + // TODO(rsc): Perhaps this instruction class should be derived from the CSV. + if x86_isCondJmp[inst.Op] || inst.Op == x86_JMP || inst.Op == x86_CALL || inst.Op == x86_RET { + for i := nprefix - 1; i >= 0; i-- { + p := inst.Prefix[i] + if p&^x86_PrefixIgnored == x86_PrefixREPN { + inst.Prefix[i] = x86_PrefixBND + break + } + } + } + + // The LOCK prefix only applies to certain instructions, and then only + // to instances of the instruction with a memory destination. + // Other uses of LOCK are invalid and cause a processor exception, + // in contrast to the "just ignore it" spirit applied to all other prefixes. + // Mark invalid lock prefixes. + hasLock := false + if lockIndex >= 0 && inst.Prefix[lockIndex]&x86_PrefixImplicit == 0 { + switch inst.Op { + // TODO(rsc): Perhaps this instruction class should be derived from the CSV. + case x86_ADD, x86_ADC, x86_AND, x86_BTC, x86_BTR, x86_BTS, x86_CMPXCHG, x86_CMPXCHG8B, x86_CMPXCHG16B, x86_DEC, x86_INC, x86_NEG, x86_NOT, x86_OR, x86_SBB, x86_SUB, x86_XOR, x86_XADD, x86_XCHG: + if x86_isMem(inst.Args[0]) { + hasLock = true + break + } + fallthrough + default: + inst.Prefix[lockIndex] |= x86_PrefixInvalid + } + } + + // In certain cases, all of which require a memory destination, + // the REPN and REP prefixes are interpreted as XACQUIRE and XRELEASE + // from the Intel Transactional Synchroniation Extensions (TSX). + // + // The specific rules are: + // (1) Any instruction with a valid LOCK prefix can have XACQUIRE or XRELEASE. + // (2) Any XCHG, which always has an implicit LOCK, can have XACQUIRE or XRELEASE. + // (3) Any 0x88-, 0x89-, 0xC6-, or 0xC7-opcode MOV can have XRELEASE. + if x86_isMem(inst.Args[0]) { + if inst.Op == x86_XCHG { + hasLock = true + } + + for i := len(inst.Prefix) - 1; i >= 0; i-- { + p := inst.Prefix[i] &^ x86_PrefixIgnored + switch p { + case x86_PrefixREPN: + if hasLock { + inst.Prefix[i] = inst.Prefix[i]&x86_PrefixIgnored | x86_PrefixXACQUIRE + } + + case x86_PrefixREP: + if hasLock { + inst.Prefix[i] = inst.Prefix[i]&x86_PrefixIgnored | x86_PrefixXRELEASE + } + + if inst.Op == x86_MOV { + op := (inst.Opcode >> 24) &^ 1 + if op == 0x88 || op == 0xC6 { + inst.Prefix[i] = inst.Prefix[i]&x86_PrefixIgnored | x86_PrefixXRELEASE + } + } + } + } + } + + // If REP is used on a non-REP-able instruction, mark the prefix as ignored. + if repIndex >= 0 { + switch inst.Prefix[repIndex] { + case x86_PrefixREP, x86_PrefixREPN: + switch inst.Op { + // According to the manuals, the REP/REPE prefix applies to all of these, + // while the REPN applies only to some of them. However, both libopcodes + // and xed show both prefixes explicitly for all instructions, so we do the same. + // TODO(rsc): Perhaps this instruction class should be derived from the CSV. + case x86_INSB, x86_INSW, x86_INSD, + x86_MOVSB, x86_MOVSW, x86_MOVSD, x86_MOVSQ, + x86_OUTSB, x86_OUTSW, x86_OUTSD, + x86_LODSB, x86_LODSW, x86_LODSD, x86_LODSQ, + x86_CMPSB, x86_CMPSW, x86_CMPSD, x86_CMPSQ, + x86_SCASB, x86_SCASW, x86_SCASD, x86_SCASQ, + x86_STOSB, x86_STOSW, x86_STOSD, x86_STOSQ: + // ok + default: + inst.Prefix[repIndex] |= x86_PrefixIgnored + } + } + } + + // If REX was present, mark implicit if all the 1 bits were consumed. + if rexIndex >= 0 { + if rexUsed != 0 { + rexUsed |= x86_PrefixREX + } + if rex&^rexUsed == 0 { + inst.Prefix[rexIndex] |= x86_PrefixImplicit + } + } + + inst.DataSize = dataMode + inst.AddrSize = addrMode + inst.Mode = mode + inst.Len = pos + return inst, nil +} + +var x86_errInternal = errors.New("internal error") + +// addr16 records the eight 16-bit addressing modes. +var x86_addr16 = [8]x86_Mem{ + {Base: x86_BX, Scale: 1, Index: x86_SI}, + {Base: x86_BX, Scale: 1, Index: x86_DI}, + {Base: x86_BP, Scale: 1, Index: x86_SI}, + {Base: x86_BP, Scale: 1, Index: x86_DI}, + {Base: x86_SI}, + {Base: x86_DI}, + {Base: x86_BP}, + {Base: x86_BX}, +} + +// baseReg returns the base register for a given register size in bits. +func x86_baseRegForBits(bits int) x86_Reg { + switch bits { + case 8: + return x86_AL + case 16: + return x86_AX + case 32: + return x86_EAX + case 64: + return x86_RAX + } + return 0 +} + +// baseReg records the base register for argument types that specify +// a range of registers indexed by op, regop, or rm. +var x86_baseReg = [...]x86_Reg{ + x86_xArgDR0dashDR7: x86_DR0, + x86_xArgMm1: x86_M0, + x86_xArgMm2: x86_M0, + x86_xArgMm2M64: x86_M0, + x86_xArgMm: x86_M0, + x86_xArgMmM32: x86_M0, + x86_xArgMmM64: x86_M0, + x86_xArgR16: x86_AX, + x86_xArgR16op: x86_AX, + x86_xArgR32: x86_EAX, + x86_xArgR32M16: x86_EAX, + x86_xArgR32M8: x86_EAX, + x86_xArgR32op: x86_EAX, + x86_xArgR64: x86_RAX, + x86_xArgR64M16: x86_RAX, + x86_xArgR64op: x86_RAX, + x86_xArgR8: x86_AL, + x86_xArgR8op: x86_AL, + x86_xArgRM16: x86_AX, + x86_xArgRM32: x86_EAX, + x86_xArgRM64: x86_RAX, + x86_xArgRM8: x86_AL, + x86_xArgRmf16: x86_AX, + x86_xArgRmf32: x86_EAX, + x86_xArgRmf64: x86_RAX, + x86_xArgSTi: x86_F0, + x86_xArgTR0dashTR7: x86_TR0, + x86_xArgXmm1: x86_X0, + x86_xArgXmm2: x86_X0, + x86_xArgXmm2M128: x86_X0, + x86_xArgXmm2M16: x86_X0, + x86_xArgXmm2M32: x86_X0, + x86_xArgXmm2M64: x86_X0, + x86_xArgXmm: x86_X0, + x86_xArgXmmM128: x86_X0, + x86_xArgXmmM32: x86_X0, + x86_xArgXmmM64: x86_X0, +} + +// prefixToSegment returns the segment register +// corresponding to a particular segment prefix. +func x86_prefixToSegment(p x86_Prefix) x86_Reg { + switch p &^ x86_PrefixImplicit { + case x86_PrefixCS: + return x86_CS + case x86_PrefixDS: + return x86_DS + case x86_PrefixES: + return x86_ES + case x86_PrefixFS: + return x86_FS + case x86_PrefixGS: + return x86_GS + case x86_PrefixSS: + return x86_SS + } + return 0 +} + +// fixedArg records the fixed arguments corresponding to the given bytecodes. +var x86_fixedArg = [...]x86_Arg{ + x86_xArg1: x86_Imm(1), + x86_xArg3: x86_Imm(3), + x86_xArgAL: x86_AL, + x86_xArgAX: x86_AX, + x86_xArgDX: x86_DX, + x86_xArgEAX: x86_EAX, + x86_xArgEDX: x86_EDX, + x86_xArgRAX: x86_RAX, + x86_xArgRDX: x86_RDX, + x86_xArgCL: x86_CL, + x86_xArgCS: x86_CS, + x86_xArgDS: x86_DS, + x86_xArgES: x86_ES, + x86_xArgFS: x86_FS, + x86_xArgGS: x86_GS, + x86_xArgSS: x86_SS, + x86_xArgST: x86_F0, + x86_xArgXMM0: x86_X0, +} + +// memBytes records the size of the memory pointed at +// by a memory argument of the given form. +var x86_memBytes = [...]int8{ + x86_xArgM128: 128 / 8, + x86_xArgM16: 16 / 8, + x86_xArgM16and16: (16 + 16) / 8, + x86_xArgM16colon16: (16 + 16) / 8, + x86_xArgM16colon32: (16 + 32) / 8, + x86_xArgM16int: 16 / 8, + x86_xArgM2byte: 2, + x86_xArgM32: 32 / 8, + x86_xArgM32and32: (32 + 32) / 8, + x86_xArgM32fp: 32 / 8, + x86_xArgM32int: 32 / 8, + x86_xArgM64: 64 / 8, + x86_xArgM64fp: 64 / 8, + x86_xArgM64int: 64 / 8, + x86_xArgMm2M64: 64 / 8, + x86_xArgMmM32: 32 / 8, + x86_xArgMmM64: 64 / 8, + x86_xArgMoffs16: 16 / 8, + x86_xArgMoffs32: 32 / 8, + x86_xArgMoffs64: 64 / 8, + x86_xArgMoffs8: 8 / 8, + x86_xArgR32M16: 16 / 8, + x86_xArgR32M8: 8 / 8, + x86_xArgR64M16: 16 / 8, + x86_xArgRM16: 16 / 8, + x86_xArgRM32: 32 / 8, + x86_xArgRM64: 64 / 8, + x86_xArgRM8: 8 / 8, + x86_xArgXmm2M128: 128 / 8, + x86_xArgXmm2M16: 16 / 8, + x86_xArgXmm2M32: 32 / 8, + x86_xArgXmm2M64: 64 / 8, + x86_xArgXmm: 128 / 8, + x86_xArgXmmM128: 128 / 8, + x86_xArgXmmM32: 32 / 8, + x86_xArgXmmM64: 64 / 8, +} + +// isCondJmp records the conditional jumps. +var x86_isCondJmp = [x86_maxOp + 1]bool{ + x86_JA: true, + x86_JAE: true, + x86_JB: true, + x86_JBE: true, + x86_JE: true, + x86_JG: true, + x86_JGE: true, + x86_JL: true, + x86_JLE: true, + x86_JNE: true, + x86_JNO: true, + x86_JNP: true, + x86_JNS: true, + x86_JO: true, + x86_JP: true, + x86_JS: true, +} + +// isLoop records the loop operators. +var x86_isLoop = [x86_maxOp + 1]bool{ + x86_LOOP: true, + x86_LOOPE: true, + x86_LOOPNE: true, + x86_JECXZ: true, + x86_JRCXZ: true, +} + +/* gnu.go */ + +// Copyright 2014 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +// GNUSyntax returns the GNU assembler syntax for the instruction, as defined by GNU binutils. +// This general form is often called ``AT&T syntax'' as a reference to AT&T System V Unix. +func x86_GNUSyntax(inst x86_Inst) string { + // Rewrite instruction to mimic GNU peculiarities. + // Note that inst has been passed by value and contains + // no pointers, so any changes we make here are local + // and will not propagate back out to the caller. + + // Adjust opcode [sic]. + switch inst.Op { + case x86_FDIV, x86_FDIVR, x86_FSUB, x86_FSUBR, x86_FDIVP, x86_FDIVRP, x86_FSUBP, x86_FSUBRP: + // DC E0, DC F0: libopcodes swaps FSUBR/FSUB and FDIVR/FDIV, at least + // if you believe the Intel manual is correct (the encoding is irregular as given; + // libopcodes uses the more regular expected encoding). + // TODO(rsc): Test to ensure Intel manuals are correct and report to libopcodes maintainers? + // NOTE: iant thinks this is deliberate, but we can't find the history. + _, reg1 := inst.Args[0].(x86_Reg) + _, reg2 := inst.Args[1].(x86_Reg) + if reg1 && reg2 && (inst.Opcode>>24 == 0xDC || inst.Opcode>>24 == 0xDE) { + switch inst.Op { + case x86_FDIV: + inst.Op = x86_FDIVR + case x86_FDIVR: + inst.Op = x86_FDIV + case x86_FSUB: + inst.Op = x86_FSUBR + case x86_FSUBR: + inst.Op = x86_FSUB + case x86_FDIVP: + inst.Op = x86_FDIVRP + case x86_FDIVRP: + inst.Op = x86_FDIVP + case x86_FSUBP: + inst.Op = x86_FSUBRP + case x86_FSUBRP: + inst.Op = x86_FSUBP + } + } + + case x86_MOVNTSD: + // MOVNTSD is F2 0F 2B /r. + // MOVNTSS is F3 0F 2B /r (supposedly; not in manuals). + // Usually inner prefixes win for display, + // so that F3 F2 0F 2B 11 is REP MOVNTSD + // and F2 F3 0F 2B 11 is REPN MOVNTSS. + // Libopcodes always prefers MOVNTSS regardless of prefix order. + if x86_countPrefix(&inst, 0xF3) > 0 { + found := false + for i := len(inst.Prefix) - 1; i >= 0; i-- { + switch inst.Prefix[i] & 0xFF { + case 0xF3: + if !found { + found = true + inst.Prefix[i] |= x86_PrefixImplicit + } + case 0xF2: + inst.Prefix[i] &^= x86_PrefixImplicit + } + } + inst.Op = x86_MOVNTSS + } + } + + // Add implicit arguments. + switch inst.Op { + case x86_MONITOR: + inst.Args[0] = x86_EDX + inst.Args[1] = x86_ECX + inst.Args[2] = x86_EAX + if inst.AddrSize == 16 { + inst.Args[2] = x86_AX + } + + case x86_MWAIT: + if inst.Mode == 64 { + inst.Args[0] = x86_RCX + inst.Args[1] = x86_RAX + } else { + inst.Args[0] = x86_ECX + inst.Args[1] = x86_EAX + } + } + + // Adjust which prefixes will be displayed. + // The rule is to display all the prefixes not implied by + // the usual instruction display, that is, all the prefixes + // except the ones with PrefixImplicit set. + // However, of course, there are exceptions to the rule. + switch inst.Op { + case x86_CRC32: + // CRC32 has a mandatory F2 prefix. + // If there are multiple F2s and no F3s, the extra F2s do not print. + // (And Decode has already marked them implicit.) + // However, if there is an F3 anywhere, then the extra F2s do print. + // If there are multiple F2 prefixes *and* an (ignored) F3, + // then libopcodes prints the extra F2s as REPNs. + if x86_countPrefix(&inst, 0xF2) > 1 { + x86_unmarkImplicit(&inst, 0xF2) + x86_markLastImplicit(&inst, 0xF2) + } + + // An unused data size override should probably be shown, + // to distinguish DATA16 CRC32B from plain CRC32B, + // but libopcodes always treats the final override as implicit + // and the others as explicit. + x86_unmarkImplicit(&inst, x86_PrefixDataSize) + x86_markLastImplicit(&inst, x86_PrefixDataSize) + + case x86_CVTSI2SD, x86_CVTSI2SS: + if !x86_isMem(inst.Args[1]) { + x86_markLastImplicit(&inst, x86_PrefixDataSize) + } + + case x86_CVTSD2SI, x86_CVTSS2SI, x86_CVTTSD2SI, x86_CVTTSS2SI, + x86_ENTER, x86_FLDENV, x86_FNSAVE, x86_FNSTENV, x86_FRSTOR, x86_LGDT, x86_LIDT, x86_LRET, + x86_POP, x86_PUSH, x86_RET, x86_SGDT, x86_SIDT, x86_SYSRET, x86_XBEGIN: + x86_markLastImplicit(&inst, x86_PrefixDataSize) + + case x86_LOOP, x86_LOOPE, x86_LOOPNE, x86_MONITOR: + x86_markLastImplicit(&inst, x86_PrefixAddrSize) + + case x86_MOV: + // The 16-bit and 32-bit forms of MOV Sreg, dst and MOV src, Sreg + // cannot be distinguished when src or dst refers to memory, because + // Sreg is always a 16-bit value, even when we're doing a 32-bit + // instruction. Because the instruction tables distinguished these two, + // any operand size prefix has been marked as used (to decide which + // branch to take). Unmark it, so that it will show up in disassembly, + // so that the reader can tell the size of memory operand. + // up with the same arguments + dst, _ := inst.Args[0].(x86_Reg) + src, _ := inst.Args[1].(x86_Reg) + if x86_ES <= src && src <= x86_GS && x86_isMem(inst.Args[0]) || x86_ES <= dst && dst <= x86_GS && x86_isMem(inst.Args[1]) { + x86_unmarkImplicit(&inst, x86_PrefixDataSize) + } + + case x86_MOVDQU: + if x86_countPrefix(&inst, 0xF3) > 1 { + x86_unmarkImplicit(&inst, 0xF3) + x86_markLastImplicit(&inst, 0xF3) + } + + case x86_MOVQ2DQ: + x86_markLastImplicit(&inst, x86_PrefixDataSize) + + case x86_SLDT, x86_SMSW, x86_STR, x86_FXRSTOR, x86_XRSTOR, x86_XSAVE, x86_XSAVEOPT, x86_CMPXCHG8B: + if x86_isMem(inst.Args[0]) { + x86_unmarkImplicit(&inst, x86_PrefixDataSize) + } + + case x86_SYSEXIT: + x86_unmarkImplicit(&inst, x86_PrefixDataSize) + } + + if x86_isCondJmp[inst.Op] || x86_isLoop[inst.Op] || inst.Op == x86_JCXZ || inst.Op == x86_JECXZ || inst.Op == x86_JRCXZ { + if x86_countPrefix(&inst, x86_PrefixCS) > 0 && x86_countPrefix(&inst, x86_PrefixDS) > 0 { + for i, p := range inst.Prefix { + switch p & 0xFFF { + case x86_PrefixPN, x86_PrefixPT: + inst.Prefix[i] &= 0xF0FF // cut interpretation bits, producing original segment prefix + } + } + } + } + + // XACQUIRE/XRELEASE adjustment. + if inst.Op == x86_MOV { + // MOV into memory is a candidate for turning REP into XRELEASE. + // However, if the REP is followed by a REPN, that REPN blocks the + // conversion. + haveREPN := false + for i := len(inst.Prefix) - 1; i >= 0; i-- { + switch inst.Prefix[i] &^ x86_PrefixIgnored { + case x86_PrefixREPN: + haveREPN = true + case x86_PrefixXRELEASE: + if haveREPN { + inst.Prefix[i] = x86_PrefixREP + } + } + } + } + + // We only format the final F2/F3 as XRELEASE/XACQUIRE. + haveXA := false + haveXR := false + for i := len(inst.Prefix) - 1; i >= 0; i-- { + switch inst.Prefix[i] &^ x86_PrefixIgnored { + case x86_PrefixXRELEASE: + if !haveXR { + haveXR = true + } else { + inst.Prefix[i] = x86_PrefixREP + } + + case x86_PrefixXACQUIRE: + if !haveXA { + haveXA = true + } else { + inst.Prefix[i] = x86_PrefixREPN + } + } + } + + // Determine opcode. + op := strings.ToLower(inst.Op.String()) + if alt := x86_gnuOp[inst.Op]; alt != "" { + op = alt + } + + // Determine opcode suffix. + // Libopcodes omits the suffix if the width of the operation + // can be inferred from a register arguments. For example, + // add $1, %ebx has no suffix because you can tell from the + // 32-bit register destination that it is a 32-bit add, + // but in addl $1, (%ebx), the destination is memory, so the + // size is not evident without the l suffix. + needSuffix := true +SuffixLoop: + for i, a := range inst.Args { + if a == nil { + break + } + switch a := a.(type) { + case x86_Reg: + switch inst.Op { + case x86_MOVSX, x86_MOVZX: + continue + + case x86_SHL, x86_SHR, x86_RCL, x86_RCR, x86_ROL, x86_ROR, x86_SAR: + if i == 1 { + // shift count does not tell us operand size + continue + } + + case x86_CRC32: + // The source argument does tell us operand size, + // but libopcodes still always puts a suffix on crc32. + continue + + case x86_PUSH, x86_POP: + // Even though segment registers are 16-bit, push and pop + // can save/restore them from 32-bit slots, so they + // do not imply operand size. + if x86_ES <= a && a <= x86_GS { + continue + } + + case x86_CVTSI2SD, x86_CVTSI2SS: + // The integer register argument takes priority. + if x86_X0 <= a && a <= x86_X15 { + continue + } + } + + if x86_AL <= a && a <= x86_R15 || x86_ES <= a && a <= x86_GS || x86_X0 <= a && a <= x86_X15 || x86_M0 <= a && a <= x86_M7 { + needSuffix = false + break SuffixLoop + } + } + } + + if needSuffix { + switch inst.Op { + case x86_CMPXCHG8B, x86_FLDCW, x86_FNSTCW, x86_FNSTSW, x86_LDMXCSR, x86_LLDT, x86_LMSW, x86_LTR, x86_PCLMULQDQ, + x86_SETA, x86_SETAE, x86_SETB, x86_SETBE, x86_SETE, x86_SETG, x86_SETGE, x86_SETL, x86_SETLE, x86_SETNE, x86_SETNO, x86_SETNP, x86_SETNS, x86_SETO, x86_SETP, x86_SETS, + x86_SLDT, x86_SMSW, x86_STMXCSR, x86_STR, x86_VERR, x86_VERW: + // For various reasons, libopcodes emits no suffix for these instructions. + + case x86_CRC32: + op += x86_byteSizeSuffix(x86_argBytes(&inst, inst.Args[1])) + + case x86_LGDT, x86_LIDT, x86_SGDT, x86_SIDT: + op += x86_byteSizeSuffix(inst.DataSize / 8) + + case x86_MOVZX, x86_MOVSX: + // Integer size conversions get two suffixes. + op = op[:4] + x86_byteSizeSuffix(x86_argBytes(&inst, inst.Args[1])) + x86_byteSizeSuffix(x86_argBytes(&inst, inst.Args[0])) + + case x86_LOOP, x86_LOOPE, x86_LOOPNE: + // Add w suffix to indicate use of CX register instead of ECX. + if inst.AddrSize == 16 { + op += "w" + } + + case x86_CALL, x86_ENTER, x86_JMP, x86_LCALL, x86_LEAVE, x86_LJMP, x86_LRET, x86_RET, x86_SYSRET, x86_XBEGIN: + // Add w suffix to indicate use of 16-bit target. + // Exclude JMP rel8. + if inst.Opcode>>24 == 0xEB { + break + } + if inst.DataSize == 16 && inst.Mode != 16 { + x86_markLastImplicit(&inst, x86_PrefixDataSize) + op += "w" + } else if inst.Mode == 64 { + op += "q" + } + + case x86_FRSTOR, x86_FNSAVE, x86_FNSTENV, x86_FLDENV: + // Add s suffix to indicate shortened FPU state (I guess). + if inst.DataSize == 16 { + op += "s" + } + + case x86_PUSH, x86_POP: + if x86_markLastImplicit(&inst, x86_PrefixDataSize) { + op += x86_byteSizeSuffix(inst.DataSize / 8) + } else if inst.Mode == 64 { + op += "q" + } else { + op += x86_byteSizeSuffix(inst.MemBytes) + } + + default: + if x86_isFloat(inst.Op) { + // I can't explain any of this, but it's what libopcodes does. + switch inst.MemBytes { + default: + if (inst.Op == x86_FLD || inst.Op == x86_FSTP) && x86_isMem(inst.Args[0]) { + op += "t" + } + case 4: + if x86_isFloatInt(inst.Op) { + op += "l" + } else { + op += "s" + } + case 8: + if x86_isFloatInt(inst.Op) { + op += "ll" + } else { + op += "l" + } + } + break + } + + op += x86_byteSizeSuffix(inst.MemBytes) + } + } + + // Adjust special case opcodes. + switch inst.Op { + case 0: + if inst.Prefix[0] != 0 { + return strings.ToLower(inst.Prefix[0].String()) + } + + case x86_INT: + if inst.Opcode>>24 == 0xCC { + inst.Args[0] = nil + op = "int3" + } + + case x86_CMPPS, x86_CMPPD, x86_CMPSD_XMM, x86_CMPSS: + imm, ok := inst.Args[2].(x86_Imm) + if ok && 0 <= imm && imm < 8 { + inst.Args[2] = nil + op = x86_cmppsOps[imm] + op[3:] + } + + case x86_PCLMULQDQ: + imm, ok := inst.Args[2].(x86_Imm) + if ok && imm&^0x11 == 0 { + inst.Args[2] = nil + op = x86_pclmulqOps[(imm&0x10)>>3|(imm&1)] + } + + case x86_XLATB: + if x86_markLastImplicit(&inst, x86_PrefixAddrSize) { + op = "xlat" // not xlatb + } + } + + // Build list of argument strings. + var ( + usedPrefixes bool // segment prefixes consumed by Mem formatting + args []string // formatted arguments + ) + for i, a := range inst.Args { + if a == nil { + break + } + switch inst.Op { + case x86_MOVSB, x86_MOVSW, x86_MOVSD, x86_MOVSQ, x86_OUTSB, x86_OUTSW, x86_OUTSD: + if i == 0 { + usedPrefixes = true // disable use of prefixes for first argument + } else { + usedPrefixes = false + } + } + if a == x86_Imm(1) && (inst.Opcode>>24)&^1 == 0xD0 { + continue + } + args = append(args, x86_gnuArg(&inst, a, &usedPrefixes)) + } + + // The default is to print the arguments in reverse Intel order. + // A few instructions inhibit this behavior. + switch inst.Op { + case x86_BOUND, x86_LCALL, x86_ENTER, x86_LJMP: + // no reverse + default: + // reverse args + for i, j := 0, len(args)-1; i < j; i, j = i+1, j-1 { + args[i], args[j] = args[j], args[i] + } + } + + // Build prefix string. + // Must be after argument formatting, which can turn off segment prefixes. + var ( + prefix = "" // output string + numAddr = 0 + numData = 0 + implicitData = false + ) + for _, p := range inst.Prefix { + if p&0xFF == x86_PrefixDataSize && p&x86_PrefixImplicit != 0 { + implicitData = true + } + } + for _, p := range inst.Prefix { + if p == 0 { + break + } + if p&x86_PrefixImplicit != 0 { + continue + } + switch p &^ (x86_PrefixIgnored | x86_PrefixInvalid) { + default: + if p.IsREX() { + if p&0xFF == x86_PrefixREX { + prefix += "rex " + } else { + prefix += "rex." + p.String()[4:] + " " + } + break + } + prefix += strings.ToLower(p.String()) + " " + + case x86_PrefixPN: + op += ",pn" + continue + + case x86_PrefixPT: + op += ",pt" + continue + + case x86_PrefixAddrSize, x86_PrefixAddr16, x86_PrefixAddr32: + // For unknown reasons, if the addr16 prefix is repeated, + // libopcodes displays all but the last as addr32, even though + // the addressing form used in a memory reference is clearly + // still 16-bit. + n := 32 + if inst.Mode == 32 { + n = 16 + } + numAddr++ + if x86_countPrefix(&inst, x86_PrefixAddrSize) > numAddr { + n = inst.Mode + } + prefix += fmt.Sprintf("addr%d ", n) + continue + + case x86_PrefixData16, x86_PrefixData32: + if implicitData && x86_countPrefix(&inst, x86_PrefixDataSize) > 1 { + // Similar to the addr32 logic above, but it only kicks in + // when something used the data size prefix (one is implicit). + n := 16 + if inst.Mode == 16 { + n = 32 + } + numData++ + if x86_countPrefix(&inst, x86_PrefixDataSize) > numData { + if inst.Mode == 16 { + n = 16 + } else { + n = 32 + } + } + prefix += fmt.Sprintf("data%d ", n) + continue + } + prefix += strings.ToLower(p.String()) + " " + } + } + + // Finally! Put it all together. + text := prefix + op + if args != nil { + text += " " + // Indirect call/jmp gets a star to distinguish from direct jump address. + if (inst.Op == x86_CALL || inst.Op == x86_JMP || inst.Op == x86_LJMP || inst.Op == x86_LCALL) && (x86_isMem(inst.Args[0]) || x86_isReg(inst.Args[0])) { + text += "*" + } + text += strings.Join(args, ",") + } + return text +} + +// gnuArg returns the GNU syntax for the argument x from the instruction inst. +// If *usedPrefixes is false and x is a Mem, then the formatting +// includes any segment prefixes and sets *usedPrefixes to true. +func x86_gnuArg(inst *x86_Inst, x x86_Arg, usedPrefixes *bool) string { + if x == nil { + return "<nil>" + } + switch x := x.(type) { + case x86_Reg: + switch inst.Op { + case x86_CVTSI2SS, x86_CVTSI2SD, x86_CVTSS2SI, x86_CVTSD2SI, x86_CVTTSD2SI, x86_CVTTSS2SI: + if inst.DataSize == 16 && x86_EAX <= x && x <= x86_R15L { + x -= x86_EAX - x86_AX + } + + case x86_IN, x86_INSB, x86_INSW, x86_INSD, x86_OUT, x86_OUTSB, x86_OUTSW, x86_OUTSD: + // DX is the port, but libopcodes prints it as if it were a memory reference. + if x == x86_DX { + return "(%dx)" + } + } + return x86_gccRegName[x] + case x86_Mem: + seg := "" + var haveCS, haveDS, haveES, haveFS, haveGS, haveSS bool + switch x.Segment { + case x86_CS: + haveCS = true + case x86_DS: + haveDS = true + case x86_ES: + haveES = true + case x86_FS: + haveFS = true + case x86_GS: + haveGS = true + case x86_SS: + haveSS = true + } + switch inst.Op { + case x86_INSB, x86_INSW, x86_INSD, x86_STOSB, x86_STOSW, x86_STOSD, x86_STOSQ, x86_SCASB, x86_SCASW, x86_SCASD, x86_SCASQ: + // These do not accept segment prefixes, at least in the GNU rendering. + default: + if *usedPrefixes { + break + } + for i := len(inst.Prefix) - 1; i >= 0; i-- { + p := inst.Prefix[i] &^ x86_PrefixIgnored + if p == 0 { + continue + } + switch p { + case x86_PrefixCS: + if !haveCS { + haveCS = true + inst.Prefix[i] |= x86_PrefixImplicit + } + case x86_PrefixDS: + if !haveDS { + haveDS = true + inst.Prefix[i] |= x86_PrefixImplicit + } + case x86_PrefixES: + if !haveES { + haveES = true + inst.Prefix[i] |= x86_PrefixImplicit + } + case x86_PrefixFS: + if !haveFS { + haveFS = true + inst.Prefix[i] |= x86_PrefixImplicit + } + case x86_PrefixGS: + if !haveGS { + haveGS = true + inst.Prefix[i] |= x86_PrefixImplicit + } + case x86_PrefixSS: + if !haveSS { + haveSS = true + inst.Prefix[i] |= x86_PrefixImplicit + } + } + } + *usedPrefixes = true + } + if haveCS { + seg += "%cs:" + } + if haveDS { + seg += "%ds:" + } + if haveSS { + seg += "%ss:" + } + if haveES { + seg += "%es:" + } + if haveFS { + seg += "%fs:" + } + if haveGS { + seg += "%gs:" + } + disp := "" + if x.Disp != 0 { + disp = fmt.Sprintf("%#x", x.Disp) + } + if x.Scale == 0 || x.Index == 0 && x.Scale == 1 && (x.Base == x86_ESP || x.Base == x86_RSP || x.Base == 0 && inst.Mode == 64) { + if x.Base == 0 { + return seg + disp + } + return fmt.Sprintf("%s%s(%s)", seg, disp, x86_gccRegName[x.Base]) + } + base := x86_gccRegName[x.Base] + if x.Base == 0 { + base = "" + } + index := x86_gccRegName[x.Index] + if x.Index == 0 { + if inst.AddrSize == 64 { + index = "%riz" + } else { + index = "%eiz" + } + } + if x86_AX <= x.Base && x.Base <= x86_DI { + // 16-bit addressing - no scale + return fmt.Sprintf("%s%s(%s,%s)", seg, disp, base, index) + } + return fmt.Sprintf("%s%s(%s,%s,%d)", seg, disp, base, index, x.Scale) + case x86_Rel: + return fmt.Sprintf(".%+#x", int32(x)) + case x86_Imm: + if inst.Mode == 32 { + return fmt.Sprintf("$%#x", uint32(x)) + } + return fmt.Sprintf("$%#x", int64(x)) + } + return x.String() +} + +var x86_gccRegName = [...]string{ + 0: "REG0", + x86_AL: "%al", + x86_CL: "%cl", + x86_BL: "%bl", + x86_DL: "%dl", + x86_AH: "%ah", + x86_CH: "%ch", + x86_BH: "%bh", + x86_DH: "%dh", + x86_SPB: "%spl", + x86_BPB: "%bpl", + x86_SIB: "%sil", + x86_DIB: "%dil", + x86_R8B: "%r8b", + x86_R9B: "%r9b", + x86_R10B: "%r10b", + x86_R11B: "%r11b", + x86_R12B: "%r12b", + x86_R13B: "%r13b", + x86_R14B: "%r14b", + x86_R15B: "%r15b", + x86_AX: "%ax", + x86_CX: "%cx", + x86_BX: "%bx", + x86_DX: "%dx", + x86_SP: "%sp", + x86_BP: "%bp", + x86_SI: "%si", + x86_DI: "%di", + x86_R8W: "%r8w", + x86_R9W: "%r9w", + x86_R10W: "%r10w", + x86_R11W: "%r11w", + x86_R12W: "%r12w", + x86_R13W: "%r13w", + x86_R14W: "%r14w", + x86_R15W: "%r15w", + x86_EAX: "%eax", + x86_ECX: "%ecx", + x86_EDX: "%edx", + x86_EBX: "%ebx", + x86_ESP: "%esp", + x86_EBP: "%ebp", + x86_ESI: "%esi", + x86_EDI: "%edi", + x86_R8L: "%r8d", + x86_R9L: "%r9d", + x86_R10L: "%r10d", + x86_R11L: "%r11d", + x86_R12L: "%r12d", + x86_R13L: "%r13d", + x86_R14L: "%r14d", + x86_R15L: "%r15d", + x86_RAX: "%rax", + x86_RCX: "%rcx", + x86_RDX: "%rdx", + x86_RBX: "%rbx", + x86_RSP: "%rsp", + x86_RBP: "%rbp", + x86_RSI: "%rsi", + x86_RDI: "%rdi", + x86_R8: "%r8", + x86_R9: "%r9", + x86_R10: "%r10", + x86_R11: "%r11", + x86_R12: "%r12", + x86_R13: "%r13", + x86_R14: "%r14", + x86_R15: "%r15", + x86_IP: "%ip", + x86_EIP: "%eip", + x86_RIP: "%rip", + x86_F0: "%st", + x86_F1: "%st(1)", + x86_F2: "%st(2)", + x86_F3: "%st(3)", + x86_F4: "%st(4)", + x86_F5: "%st(5)", + x86_F6: "%st(6)", + x86_F7: "%st(7)", + x86_M0: "%mm0", + x86_M1: "%mm1", + x86_M2: "%mm2", + x86_M3: "%mm3", + x86_M4: "%mm4", + x86_M5: "%mm5", + x86_M6: "%mm6", + x86_M7: "%mm7", + x86_X0: "%xmm0", + x86_X1: "%xmm1", + x86_X2: "%xmm2", + x86_X3: "%xmm3", + x86_X4: "%xmm4", + x86_X5: "%xmm5", + x86_X6: "%xmm6", + x86_X7: "%xmm7", + x86_X8: "%xmm8", + x86_X9: "%xmm9", + x86_X10: "%xmm10", + x86_X11: "%xmm11", + x86_X12: "%xmm12", + x86_X13: "%xmm13", + x86_X14: "%xmm14", + x86_X15: "%xmm15", + x86_CS: "%cs", + x86_SS: "%ss", + x86_DS: "%ds", + x86_ES: "%es", + x86_FS: "%fs", + x86_GS: "%gs", + x86_GDTR: "%gdtr", + x86_IDTR: "%idtr", + x86_LDTR: "%ldtr", + x86_MSW: "%msw", + x86_TASK: "%task", + x86_CR0: "%cr0", + x86_CR1: "%cr1", + x86_CR2: "%cr2", + x86_CR3: "%cr3", + x86_CR4: "%cr4", + x86_CR5: "%cr5", + x86_CR6: "%cr6", + x86_CR7: "%cr7", + x86_CR8: "%cr8", + x86_CR9: "%cr9", + x86_CR10: "%cr10", + x86_CR11: "%cr11", + x86_CR12: "%cr12", + x86_CR13: "%cr13", + x86_CR14: "%cr14", + x86_CR15: "%cr15", + x86_DR0: "%db0", + x86_DR1: "%db1", + x86_DR2: "%db2", + x86_DR3: "%db3", + x86_DR4: "%db4", + x86_DR5: "%db5", + x86_DR6: "%db6", + x86_DR7: "%db7", + x86_TR0: "%tr0", + x86_TR1: "%tr1", + x86_TR2: "%tr2", + x86_TR3: "%tr3", + x86_TR4: "%tr4", + x86_TR5: "%tr5", + x86_TR6: "%tr6", + x86_TR7: "%tr7", +} + +var x86_gnuOp = map[x86_Op]string{ + x86_CBW: "cbtw", + x86_CDQ: "cltd", + x86_CMPSD: "cmpsl", + x86_CMPSD_XMM: "cmpsd", + x86_CWD: "cwtd", + x86_CWDE: "cwtl", + x86_CQO: "cqto", + x86_INSD: "insl", + x86_IRET: "iretw", + x86_IRETD: "iret", + x86_IRETQ: "iretq", + x86_LODSB: "lods", + x86_LODSD: "lods", + x86_LODSQ: "lods", + x86_LODSW: "lods", + x86_MOVSD: "movsl", + x86_MOVSD_XMM: "movsd", + x86_OUTSD: "outsl", + x86_POPA: "popaw", + x86_POPAD: "popa", + x86_POPF: "popfw", + x86_POPFD: "popf", + x86_PUSHA: "pushaw", + x86_PUSHAD: "pusha", + x86_PUSHF: "pushfw", + x86_PUSHFD: "pushf", + x86_SCASB: "scas", + x86_SCASD: "scas", + x86_SCASQ: "scas", + x86_SCASW: "scas", + x86_STOSB: "stos", + x86_STOSD: "stos", + x86_STOSQ: "stos", + x86_STOSW: "stos", + x86_XLATB: "xlat", +} + +var x86_cmppsOps = []string{ + "cmpeq", + "cmplt", + "cmple", + "cmpunord", + "cmpneq", + "cmpnlt", + "cmpnle", + "cmpord", +} + +var x86_pclmulqOps = []string{ + "pclmullqlqdq", + "pclmulhqlqdq", + "pclmullqhqdq", + "pclmulhqhqdq", +} + +func x86_countPrefix(inst *x86_Inst, target x86_Prefix) int { + n := 0 + for _, p := range inst.Prefix { + if p&0xFF == target&0xFF { + n++ + } + } + return n +} + +func x86_markLastImplicit(inst *x86_Inst, prefix x86_Prefix) bool { + for i := len(inst.Prefix) - 1; i >= 0; i-- { + p := inst.Prefix[i] + if p&0xFF == prefix { + inst.Prefix[i] |= x86_PrefixImplicit + return true + } + } + return false +} + +func x86_unmarkImplicit(inst *x86_Inst, prefix x86_Prefix) { + for i := len(inst.Prefix) - 1; i >= 0; i-- { + p := inst.Prefix[i] + if p&0xFF == prefix { + inst.Prefix[i] &^= x86_PrefixImplicit + } + } +} + +func x86_byteSizeSuffix(b int) string { + switch b { + case 1: + return "b" + case 2: + return "w" + case 4: + return "l" + case 8: + return "q" + } + return "" +} + +func x86_argBytes(inst *x86_Inst, arg x86_Arg) int { + if x86_isMem(arg) { + return inst.MemBytes + } + return x86_regBytes(arg) +} + +func x86_isFloat(op x86_Op) bool { + switch op { + case x86_FADD, x86_FCOM, x86_FCOMP, x86_FDIV, x86_FDIVR, x86_FIADD, x86_FICOM, x86_FICOMP, x86_FIDIV, x86_FIDIVR, x86_FILD, x86_FIMUL, x86_FIST, x86_FISTP, x86_FISTTP, x86_FISUB, x86_FISUBR, x86_FLD, x86_FMUL, x86_FST, x86_FSTP, x86_FSUB, x86_FSUBR: + return true + } + return false +} + +func x86_isFloatInt(op x86_Op) bool { + switch op { + case x86_FIADD, x86_FICOM, x86_FICOMP, x86_FIDIV, x86_FIDIVR, x86_FILD, x86_FIMUL, x86_FIST, x86_FISTP, x86_FISTTP, x86_FISUB, x86_FISUBR: + return true + } + return false +} + +/* inst.go */ + +// Copyright 2014 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +// Package x86asm implements decoding of x86 machine code. + +// An Inst is a single instruction. +type x86_Inst struct { + Prefix x86_Prefixes // Prefixes applied to the instruction. + Op x86_Op // Opcode mnemonic + Opcode uint32 // Encoded opcode bits, left aligned (first byte is Opcode>>24, etc) + Args x86_Args // Instruction arguments, in Intel order + Mode int // processor mode in bits: 16, 32, or 64 + AddrSize int // address size in bits: 16, 32, or 64 + DataSize int // operand size in bits: 16, 32, or 64 + MemBytes int // size of memory argument in bytes: 1, 2, 4, 8, 16, and so on. + Len int // length of encoded instruction in bytes +} + +// Prefixes is an array of prefixes associated with a single instruction. +// The prefixes are listed in the same order as found in the instruction: +// each prefix byte corresponds to one slot in the array. The first zero +// in the array marks the end of the prefixes. +type x86_Prefixes [14]x86_Prefix + +// A Prefix represents an Intel instruction prefix. +// The low 8 bits are the actual prefix byte encoding, +// and the top 8 bits contain distinguishing bits and metadata. +type x86_Prefix uint16 + +const ( + // Metadata about the role of a prefix in an instruction. + x86_PrefixImplicit x86_Prefix = 0x8000 // prefix is implied by instruction text + x86_PrefixIgnored x86_Prefix = 0x4000 // prefix is ignored: either irrelevant or overridden by a later prefix + x86_PrefixInvalid x86_Prefix = 0x2000 // prefix makes entire instruction invalid (bad LOCK) + + // Memory segment overrides. + x86_PrefixES x86_Prefix = 0x26 // ES segment override + x86_PrefixCS x86_Prefix = 0x2E // CS segment override + x86_PrefixSS x86_Prefix = 0x36 // SS segment override + x86_PrefixDS x86_Prefix = 0x3E // DS segment override + x86_PrefixFS x86_Prefix = 0x64 // FS segment override + x86_PrefixGS x86_Prefix = 0x65 // GS segment override + + // Branch prediction. + x86_PrefixPN x86_Prefix = 0x12E // predict not taken (conditional branch only) + x86_PrefixPT x86_Prefix = 0x13E // predict taken (conditional branch only) + + // Size attributes. + x86_PrefixDataSize x86_Prefix = 0x66 // operand size override + x86_PrefixData16 x86_Prefix = 0x166 + x86_PrefixData32 x86_Prefix = 0x266 + x86_PrefixAddrSize x86_Prefix = 0x67 // address size override + x86_PrefixAddr16 x86_Prefix = 0x167 + x86_PrefixAddr32 x86_Prefix = 0x267 + + // One of a kind. + x86_PrefixLOCK x86_Prefix = 0xF0 // lock + x86_PrefixREPN x86_Prefix = 0xF2 // repeat not zero + x86_PrefixXACQUIRE x86_Prefix = 0x1F2 + x86_PrefixBND x86_Prefix = 0x2F2 + x86_PrefixREP x86_Prefix = 0xF3 // repeat + x86_PrefixXRELEASE x86_Prefix = 0x1F3 + + // The REX prefixes must be in the range [PrefixREX, PrefixREX+0x10). + // the other bits are set or not according to the intended use. + x86_PrefixREX x86_Prefix = 0x40 // REX 64-bit extension prefix + x86_PrefixREXW x86_Prefix = 0x08 // extension bit W (64-bit instruction width) + x86_PrefixREXR x86_Prefix = 0x04 // extension bit R (r field in modrm) + x86_PrefixREXX x86_Prefix = 0x02 // extension bit X (index field in sib) + x86_PrefixREXB x86_Prefix = 0x01 // extension bit B (r/m field in modrm or base field in sib) +) + +// IsREX reports whether p is a REX prefix byte. +func (p x86_Prefix) IsREX() bool { + return p&0xF0 == x86_PrefixREX +} + +func (p x86_Prefix) String() string { + p &^= x86_PrefixImplicit | x86_PrefixIgnored | x86_PrefixInvalid + if s := x86_prefixNames[p]; s != "" { + return s + } + + if p.IsREX() { + s := "REX." + if p&x86_PrefixREXW != 0 { + s += "W" + } + if p&x86_PrefixREXR != 0 { + s += "R" + } + if p&x86_PrefixREXX != 0 { + s += "X" + } + if p&x86_PrefixREXB != 0 { + s += "B" + } + return s + } + + return fmt.Sprintf("Prefix(%#x)", int(p)) +} + +// An Op is an x86 opcode. +type x86_Op uint32 + +func (op x86_Op) String() string { + i := int(op) + if i < 0 || i >= len(x86_opNames) || x86_opNames[i] == "" { + return fmt.Sprintf("Op(%d)", i) + } + return x86_opNames[i] +} + +// An Args holds the instruction arguments. +// If an instruction has fewer than 4 arguments, +// the final elements in the array are nil. +type x86_Args [4]x86_Arg + +// An Arg is a single instruction argument, +// one of these types: Reg, Mem, Imm, Rel. +type x86_Arg interface { + String() string + isArg() +} + +// Note that the implements of Arg that follow are all sized +// so that on a 64-bit machine the data can be inlined in +// the interface value instead of requiring an allocation. + +// A Reg is a single register. +// The zero Reg value has no name but indicates ``no register.'' +type x86_Reg uint8 + +const ( + _ x86_Reg = iota + + // 8-bit + x86_AL + x86_CL + x86_DL + x86_BL + x86_AH + x86_CH + x86_DH + x86_BH + x86_SPB + x86_BPB + x86_SIB + x86_DIB + x86_R8B + x86_R9B + x86_R10B + x86_R11B + x86_R12B + x86_R13B + x86_R14B + x86_R15B + + // 16-bit + x86_AX + x86_CX + x86_DX + x86_BX + x86_SP + x86_BP + x86_SI + x86_DI + x86_R8W + x86_R9W + x86_R10W + x86_R11W + x86_R12W + x86_R13W + x86_R14W + x86_R15W + + // 32-bit + x86_EAX + x86_ECX + x86_EDX + x86_EBX + x86_ESP + x86_EBP + x86_ESI + x86_EDI + x86_R8L + x86_R9L + x86_R10L + x86_R11L + x86_R12L + x86_R13L + x86_R14L + x86_R15L + + // 64-bit + x86_RAX + x86_RCX + x86_RDX + x86_RBX + x86_RSP + x86_RBP + x86_RSI + x86_RDI + x86_R8 + x86_R9 + x86_R10 + x86_R11 + x86_R12 + x86_R13 + x86_R14 + x86_R15 + + // Instruction pointer. + x86_IP // 16-bit + x86_EIP // 32-bit + x86_RIP // 64-bit + + // 387 floating point registers. + x86_F0 + x86_F1 + x86_F2 + x86_F3 + x86_F4 + x86_F5 + x86_F6 + x86_F7 + + // MMX registers. + x86_M0 + x86_M1 + x86_M2 + x86_M3 + x86_M4 + x86_M5 + x86_M6 + x86_M7 + + // XMM registers. + x86_X0 + x86_X1 + x86_X2 + x86_X3 + x86_X4 + x86_X5 + x86_X6 + x86_X7 + x86_X8 + x86_X9 + x86_X10 + x86_X11 + x86_X12 + x86_X13 + x86_X14 + x86_X15 + + // Segment registers. + x86_ES + x86_CS + x86_SS + x86_DS + x86_FS + x86_GS + + // System registers. + x86_GDTR + x86_IDTR + x86_LDTR + x86_MSW + x86_TASK + + // Control registers. + x86_CR0 + x86_CR1 + x86_CR2 + x86_CR3 + x86_CR4 + x86_CR5 + x86_CR6 + x86_CR7 + x86_CR8 + x86_CR9 + x86_CR10 + x86_CR11 + x86_CR12 + x86_CR13 + x86_CR14 + x86_CR15 + + // Debug registers. + x86_DR0 + x86_DR1 + x86_DR2 + x86_DR3 + x86_DR4 + x86_DR5 + x86_DR6 + x86_DR7 + x86_DR8 + x86_DR9 + x86_DR10 + x86_DR11 + x86_DR12 + x86_DR13 + x86_DR14 + x86_DR15 + + // Task registers. + x86_TR0 + x86_TR1 + x86_TR2 + x86_TR3 + x86_TR4 + x86_TR5 + x86_TR6 + x86_TR7 +) + +const x86_regMax = x86_TR7 + +func (x86_Reg) isArg() {} + +func (r x86_Reg) String() string { + i := int(r) + if i < 0 || i >= len(x86_regNames) || x86_regNames[i] == "" { + return fmt.Sprintf("Reg(%d)", i) + } + return x86_regNames[i] +} + +// A Mem is a memory reference. +// The general form is Segment:[Base+Scale*Index+Disp]. +type x86_Mem struct { + Segment x86_Reg + Base x86_Reg + Scale uint8 + Index x86_Reg + Disp int64 +} + +func (x86_Mem) isArg() {} + +func (m x86_Mem) String() string { + var base, plus, scale, index, disp string + + if m.Base != 0 { + base = m.Base.String() + } + if m.Scale != 0 { + if m.Base != 0 { + plus = "+" + } + if m.Scale > 1 { + scale = fmt.Sprintf("%d*", m.Scale) + } + index = m.Index.String() + } + if m.Disp != 0 || m.Base == 0 && m.Scale == 0 { + disp = fmt.Sprintf("%+#x", m.Disp) + } + return "[" + base + plus + scale + index + disp + "]" +} + +// A Rel is an offset relative to the current instruction pointer. +type x86_Rel int32 + +func (x86_Rel) isArg() {} + +func (r x86_Rel) String() string { + return fmt.Sprintf(".%+d", r) +} + +// An Imm is an integer constant. +type x86_Imm int64 + +func (x86_Imm) isArg() {} + +func (i x86_Imm) String() string { + return fmt.Sprintf("%#x", int64(i)) +} + +func (i x86_Inst) String() string { + var buf bytes.Buffer + for _, p := range i.Prefix { + if p == 0 { + break + } + if p&x86_PrefixImplicit != 0 { + continue + } + fmt.Fprintf(&buf, "%v ", p) + } + fmt.Fprintf(&buf, "%v", i.Op) + sep := " " + for _, v := range i.Args { + if v == nil { + break + } + fmt.Fprintf(&buf, "%s%v", sep, v) + sep = ", " + } + return buf.String() +} + +func x86_isReg(a x86_Arg) bool { + _, ok := a.(x86_Reg) + return ok +} + +func x86_isSegReg(a x86_Arg) bool { + r, ok := a.(x86_Reg) + return ok && x86_ES <= r && r <= x86_GS +} + +func x86_isMem(a x86_Arg) bool { + _, ok := a.(x86_Mem) + return ok +} + +func x86_isImm(a x86_Arg) bool { + _, ok := a.(x86_Imm) + return ok +} + +func x86_regBytes(a x86_Arg) int { + r, ok := a.(x86_Reg) + if !ok { + return 0 + } + if x86_AL <= r && r <= x86_R15B { + return 1 + } + if x86_AX <= r && r <= x86_R15W { + return 2 + } + if x86_EAX <= r && r <= x86_R15L { + return 4 + } + if x86_RAX <= r && r <= x86_R15 { + return 8 + } + return 0 +} + +func x86_isSegment(p x86_Prefix) bool { + switch p { + case x86_PrefixCS, x86_PrefixDS, x86_PrefixES, x86_PrefixFS, x86_PrefixGS, x86_PrefixSS: + return true + } + return false +} + +// The Op definitions and string list are in tables.go. + +var x86_prefixNames = map[x86_Prefix]string{ + x86_PrefixCS: "CS", + x86_PrefixDS: "DS", + x86_PrefixES: "ES", + x86_PrefixFS: "FS", + x86_PrefixGS: "GS", + x86_PrefixSS: "SS", + x86_PrefixLOCK: "LOCK", + x86_PrefixREP: "REP", + x86_PrefixREPN: "REPN", + x86_PrefixAddrSize: "ADDRSIZE", + x86_PrefixDataSize: "DATASIZE", + x86_PrefixAddr16: "ADDR16", + x86_PrefixData16: "DATA16", + x86_PrefixAddr32: "ADDR32", + x86_PrefixData32: "DATA32", + x86_PrefixBND: "BND", + x86_PrefixXACQUIRE: "XACQUIRE", + x86_PrefixXRELEASE: "XRELEASE", + x86_PrefixREX: "REX", + x86_PrefixPT: "PT", + x86_PrefixPN: "PN", +} + +var x86_regNames = [...]string{ + x86_AL: "AL", + x86_CL: "CL", + x86_BL: "BL", + x86_DL: "DL", + x86_AH: "AH", + x86_CH: "CH", + x86_BH: "BH", + x86_DH: "DH", + x86_SPB: "SPB", + x86_BPB: "BPB", + x86_SIB: "SIB", + x86_DIB: "DIB", + x86_R8B: "R8B", + x86_R9B: "R9B", + x86_R10B: "R10B", + x86_R11B: "R11B", + x86_R12B: "R12B", + x86_R13B: "R13B", + x86_R14B: "R14B", + x86_R15B: "R15B", + x86_AX: "AX", + x86_CX: "CX", + x86_BX: "BX", + x86_DX: "DX", + x86_SP: "SP", + x86_BP: "BP", + x86_SI: "SI", + x86_DI: "DI", + x86_R8W: "R8W", + x86_R9W: "R9W", + x86_R10W: "R10W", + x86_R11W: "R11W", + x86_R12W: "R12W", + x86_R13W: "R13W", + x86_R14W: "R14W", + x86_R15W: "R15W", + x86_EAX: "EAX", + x86_ECX: "ECX", + x86_EDX: "EDX", + x86_EBX: "EBX", + x86_ESP: "ESP", + x86_EBP: "EBP", + x86_ESI: "ESI", + x86_EDI: "EDI", + x86_R8L: "R8L", + x86_R9L: "R9L", + x86_R10L: "R10L", + x86_R11L: "R11L", + x86_R12L: "R12L", + x86_R13L: "R13L", + x86_R14L: "R14L", + x86_R15L: "R15L", + x86_RAX: "RAX", + x86_RCX: "RCX", + x86_RDX: "RDX", + x86_RBX: "RBX", + x86_RSP: "RSP", + x86_RBP: "RBP", + x86_RSI: "RSI", + x86_RDI: "RDI", + x86_R8: "R8", + x86_R9: "R9", + x86_R10: "R10", + x86_R11: "R11", + x86_R12: "R12", + x86_R13: "R13", + x86_R14: "R14", + x86_R15: "R15", + x86_IP: "IP", + x86_EIP: "EIP", + x86_RIP: "RIP", + x86_F0: "F0", + x86_F1: "F1", + x86_F2: "F2", + x86_F3: "F3", + x86_F4: "F4", + x86_F5: "F5", + x86_F6: "F6", + x86_F7: "F7", + x86_M0: "M0", + x86_M1: "M1", + x86_M2: "M2", + x86_M3: "M3", + x86_M4: "M4", + x86_M5: "M5", + x86_M6: "M6", + x86_M7: "M7", + x86_X0: "X0", + x86_X1: "X1", + x86_X2: "X2", + x86_X3: "X3", + x86_X4: "X4", + x86_X5: "X5", + x86_X6: "X6", + x86_X7: "X7", + x86_X8: "X8", + x86_X9: "X9", + x86_X10: "X10", + x86_X11: "X11", + x86_X12: "X12", + x86_X13: "X13", + x86_X14: "X14", + x86_X15: "X15", + x86_CS: "CS", + x86_SS: "SS", + x86_DS: "DS", + x86_ES: "ES", + x86_FS: "FS", + x86_GS: "GS", + x86_GDTR: "GDTR", + x86_IDTR: "IDTR", + x86_LDTR: "LDTR", + x86_MSW: "MSW", + x86_TASK: "TASK", + x86_CR0: "CR0", + x86_CR1: "CR1", + x86_CR2: "CR2", + x86_CR3: "CR3", + x86_CR4: "CR4", + x86_CR5: "CR5", + x86_CR6: "CR6", + x86_CR7: "CR7", + x86_CR8: "CR8", + x86_CR9: "CR9", + x86_CR10: "CR10", + x86_CR11: "CR11", + x86_CR12: "CR12", + x86_CR13: "CR13", + x86_CR14: "CR14", + x86_CR15: "CR15", + x86_DR0: "DR0", + x86_DR1: "DR1", + x86_DR2: "DR2", + x86_DR3: "DR3", + x86_DR4: "DR4", + x86_DR5: "DR5", + x86_DR6: "DR6", + x86_DR7: "DR7", + x86_DR8: "DR8", + x86_DR9: "DR9", + x86_DR10: "DR10", + x86_DR11: "DR11", + x86_DR12: "DR12", + x86_DR13: "DR13", + x86_DR14: "DR14", + x86_DR15: "DR15", + x86_TR0: "TR0", + x86_TR1: "TR1", + x86_TR2: "TR2", + x86_TR3: "TR3", + x86_TR4: "TR4", + x86_TR5: "TR5", + x86_TR6: "TR6", + x86_TR7: "TR7", +} + +/* intel.go */ + +// Copyright 2014 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +// IntelSyntax returns the Intel assembler syntax for the instruction, as defined by Intel's XED tool. +func x86_IntelSyntax(inst x86_Inst) string { + var iargs []x86_Arg + for _, a := range inst.Args { + if a == nil { + break + } + iargs = append(iargs, a) + } + + switch inst.Op { + case x86_INSB, x86_INSD, x86_INSW, x86_OUTSB, x86_OUTSD, x86_OUTSW, x86_LOOPNE, x86_JCXZ, x86_JECXZ, x86_JRCXZ, x86_LOOP, x86_LOOPE, x86_MOV, x86_XLATB: + if inst.Op == x86_MOV && (inst.Opcode>>16)&0xFFFC != 0x0F20 { + break + } + for i, p := range inst.Prefix { + if p&0xFF == x86_PrefixAddrSize { + inst.Prefix[i] &^= x86_PrefixImplicit + } + } + } + + switch inst.Op { + case x86_MOV: + dst, _ := inst.Args[0].(x86_Reg) + src, _ := inst.Args[1].(x86_Reg) + if x86_ES <= dst && dst <= x86_GS && x86_EAX <= src && src <= x86_R15L { + src -= x86_EAX - x86_AX + iargs[1] = src + } + if x86_ES <= dst && dst <= x86_GS && x86_RAX <= src && src <= x86_R15 { + src -= x86_RAX - x86_AX + iargs[1] = src + } + + if inst.Opcode>>24&^3 == 0xA0 { + for i, p := range inst.Prefix { + if p&0xFF == x86_PrefixAddrSize { + inst.Prefix[i] |= x86_PrefixImplicit + } + } + } + } + + switch inst.Op { + case x86_AAM, x86_AAD: + if imm, ok := iargs[0].(x86_Imm); ok { + if inst.DataSize == 32 { + iargs[0] = x86_Imm(uint32(int8(imm))) + } else if inst.DataSize == 16 { + iargs[0] = x86_Imm(uint16(int8(imm))) + } + } + + case x86_PUSH: + if imm, ok := iargs[0].(x86_Imm); ok { + iargs[0] = x86_Imm(uint32(imm)) + } + } + + for _, p := range inst.Prefix { + if p&x86_PrefixImplicit != 0 { + for j, pj := range inst.Prefix { + if pj&0xFF == p&0xFF { + inst.Prefix[j] |= x86_PrefixImplicit + } + } + } + } + + if inst.Op != 0 { + for i, p := range inst.Prefix { + switch p &^ x86_PrefixIgnored { + case x86_PrefixData16, x86_PrefixData32, x86_PrefixCS, x86_PrefixDS, x86_PrefixES, x86_PrefixSS: + inst.Prefix[i] |= x86_PrefixImplicit + } + if p.IsREX() { + inst.Prefix[i] |= x86_PrefixImplicit + } + } + } + + if x86_isLoop[inst.Op] || inst.Op == x86_JCXZ || inst.Op == x86_JECXZ || inst.Op == x86_JRCXZ { + for i, p := range inst.Prefix { + if p == x86_PrefixPT || p == x86_PrefixPN { + inst.Prefix[i] |= x86_PrefixImplicit + } + } + } + + switch inst.Op { + case x86_AAA, x86_AAS, x86_CBW, x86_CDQE, x86_CLC, x86_CLD, x86_CLI, x86_CLTS, x86_CMC, x86_CPUID, x86_CQO, x86_CWD, x86_DAA, x86_DAS, + x86_FDECSTP, x86_FINCSTP, x86_FNCLEX, x86_FNINIT, x86_FNOP, x86_FWAIT, x86_HLT, + x86_ICEBP, x86_INSB, x86_INSD, x86_INSW, x86_INT, x86_INTO, x86_INVD, x86_IRET, x86_IRETQ, + x86_LAHF, x86_LEAVE, x86_LRET, x86_MONITOR, x86_MWAIT, x86_NOP, x86_OUTSB, x86_OUTSD, x86_OUTSW, + x86_PAUSE, x86_POPA, x86_POPF, x86_POPFQ, x86_PUSHA, x86_PUSHF, x86_PUSHFQ, + x86_RDMSR, x86_RDPMC, x86_RDTSC, x86_RDTSCP, x86_RET, x86_RSM, + x86_SAHF, x86_STC, x86_STD, x86_STI, x86_SYSENTER, x86_SYSEXIT, x86_SYSRET, + x86_UD2, x86_WBINVD, x86_WRMSR, x86_XEND, x86_XLATB, x86_XTEST: + + if inst.Op == x86_NOP && inst.Opcode>>24 != 0x90 { + break + } + if inst.Op == x86_RET && inst.Opcode>>24 != 0xC3 { + break + } + if inst.Op == x86_INT && inst.Opcode>>24 != 0xCC { + break + } + if inst.Op == x86_LRET && inst.Opcode>>24 != 0xcb { + break + } + for i, p := range inst.Prefix { + if p&0xFF == x86_PrefixDataSize { + inst.Prefix[i] &^= x86_PrefixImplicit | x86_PrefixIgnored + } + } + + case 0: + // ok + } + + switch inst.Op { + case x86_INSB, x86_INSD, x86_INSW, x86_OUTSB, x86_OUTSD, x86_OUTSW, x86_MONITOR, x86_MWAIT, x86_XLATB: + iargs = nil + + case x86_STOSB, x86_STOSW, x86_STOSD, x86_STOSQ: + iargs = iargs[:1] + + case x86_LODSB, x86_LODSW, x86_LODSD, x86_LODSQ, x86_SCASB, x86_SCASW, x86_SCASD, x86_SCASQ: + iargs = iargs[1:] + } + + const ( + haveData16 = 1 << iota + haveData32 + haveAddr16 + haveAddr32 + haveXacquire + haveXrelease + haveLock + haveHintTaken + haveHintNotTaken + haveBnd + ) + var prefixBits uint32 + prefix := "" + for _, p := range inst.Prefix { + if p == 0 { + break + } + if p&0xFF == 0xF3 { + prefixBits &^= haveBnd + } + if p&(x86_PrefixImplicit|x86_PrefixIgnored) != 0 { + continue + } + switch p { + default: + prefix += strings.ToLower(p.String()) + " " + case x86_PrefixCS, x86_PrefixDS, x86_PrefixES, x86_PrefixFS, x86_PrefixGS, x86_PrefixSS: + if inst.Op == 0 { + prefix += strings.ToLower(p.String()) + " " + } + case x86_PrefixREPN: + prefix += "repne " + case x86_PrefixLOCK: + prefixBits |= haveLock + case x86_PrefixData16, x86_PrefixDataSize: + prefixBits |= haveData16 + case x86_PrefixData32: + prefixBits |= haveData32 + case x86_PrefixAddrSize, x86_PrefixAddr16: + prefixBits |= haveAddr16 + case x86_PrefixAddr32: + prefixBits |= haveAddr32 + case x86_PrefixXACQUIRE: + prefixBits |= haveXacquire + case x86_PrefixXRELEASE: + prefixBits |= haveXrelease + case x86_PrefixPT: + prefixBits |= haveHintTaken + case x86_PrefixPN: + prefixBits |= haveHintNotTaken + case x86_PrefixBND: + prefixBits |= haveBnd + } + } + switch inst.Op { + case x86_JMP: + if inst.Opcode>>24 == 0xEB { + prefixBits &^= haveBnd + } + case x86_RET, x86_LRET: + prefixBits &^= haveData16 | haveData32 + } + + if prefixBits&haveXacquire != 0 { + prefix += "xacquire " + } + if prefixBits&haveXrelease != 0 { + prefix += "xrelease " + } + if prefixBits&haveLock != 0 { + prefix += "lock " + } + if prefixBits&haveBnd != 0 { + prefix += "bnd " + } + if prefixBits&haveHintTaken != 0 { + prefix += "hint-taken " + } + if prefixBits&haveHintNotTaken != 0 { + prefix += "hint-not-taken " + } + if prefixBits&haveAddr16 != 0 { + prefix += "addr16 " + } + if prefixBits&haveAddr32 != 0 { + prefix += "addr32 " + } + if prefixBits&haveData16 != 0 { + prefix += "data16 " + } + if prefixBits&haveData32 != 0 { + prefix += "data32 " + } + + if inst.Op == 0 { + if prefix == "" { + return "<no instruction>" + } + return prefix[:len(prefix)-1] + } + + var args []string + for _, a := range iargs { + if a == nil { + break + } + args = append(args, x86_intelArg(&inst, a)) + } + + var op string + switch inst.Op { + case x86_NOP: + if inst.Opcode>>24 == 0x0F { + if inst.DataSize == 16 { + args = append(args, "ax") + } else { + args = append(args, "eax") + } + } + + case x86_BLENDVPD, x86_BLENDVPS, x86_PBLENDVB: + args = args[:2] + + case x86_INT: + if inst.Opcode>>24 == 0xCC { + args = nil + op = "int3" + } + + case x86_LCALL, x86_LJMP: + if len(args) == 2 { + args[0], args[1] = args[1], args[0] + } + + case x86_FCHS, x86_FABS, x86_FTST, x86_FLDPI, x86_FLDL2E, x86_FLDLG2, x86_F2XM1, x86_FXAM, x86_FLD1, x86_FLDL2T, x86_FSQRT, x86_FRNDINT, x86_FCOS, x86_FSIN: + if len(args) == 0 { + args = append(args, "st0") + } + + case x86_FPTAN, x86_FSINCOS, x86_FUCOMPP, x86_FCOMPP, x86_FYL2X, x86_FPATAN, x86_FXTRACT, x86_FPREM1, x86_FPREM, x86_FYL2XP1, x86_FSCALE: + if len(args) == 0 { + args = []string{"st0", "st1"} + } + + case x86_FST, x86_FSTP, x86_FISTTP, x86_FIST, x86_FISTP, x86_FBSTP: + if len(args) == 1 { + args = append(args, "st0") + } + + case x86_FLD, x86_FXCH, x86_FCOM, x86_FCOMP, x86_FIADD, x86_FIMUL, x86_FICOM, x86_FICOMP, x86_FISUBR, x86_FIDIV, x86_FUCOM, x86_FUCOMP, x86_FILD, x86_FBLD, x86_FADD, x86_FMUL, x86_FSUB, x86_FSUBR, x86_FISUB, x86_FDIV, x86_FDIVR, x86_FIDIVR: + if len(args) == 1 { + args = []string{"st0", args[0]} + } + + case x86_MASKMOVDQU, x86_MASKMOVQ, x86_XLATB, x86_OUTSB, x86_OUTSW, x86_OUTSD: + FixSegment: + for i := len(inst.Prefix) - 1; i >= 0; i-- { + p := inst.Prefix[i] & 0xFF + switch p { + case x86_PrefixCS, x86_PrefixES, x86_PrefixFS, x86_PrefixGS, x86_PrefixSS: + if inst.Mode != 64 || p == x86_PrefixFS || p == x86_PrefixGS { + args = append(args, strings.ToLower((inst.Prefix[i] & 0xFF).String())) + break FixSegment + } + case x86_PrefixDS: + if inst.Mode != 64 { + break FixSegment + } + } + } + } + + if op == "" { + op = x86_intelOp[inst.Op] + } + if op == "" { + op = strings.ToLower(inst.Op.String()) + } + if args != nil { + op += " " + strings.Join(args, ", ") + } + return prefix + op +} + +func x86_intelArg(inst *x86_Inst, arg x86_Arg) string { + switch a := arg.(type) { + case x86_Imm: + if inst.Mode == 32 { + return fmt.Sprintf("%#x", uint32(a)) + } + if x86_Imm(int32(a)) == a { + return fmt.Sprintf("%#x", int64(a)) + } + return fmt.Sprintf("%#x", uint64(a)) + case x86_Mem: + if a.Base == x86_EIP { + a.Base = x86_RIP + } + prefix := "" + switch inst.MemBytes { + case 1: + prefix = "byte " + case 2: + prefix = "word " + case 4: + prefix = "dword " + case 8: + prefix = "qword " + case 16: + prefix = "xmmword " + } + switch inst.Op { + case x86_INVLPG: + prefix = "byte " + case x86_STOSB, x86_MOVSB, x86_CMPSB, x86_LODSB, x86_SCASB: + prefix = "byte " + case x86_STOSW, x86_MOVSW, x86_CMPSW, x86_LODSW, x86_SCASW: + prefix = "word " + case x86_STOSD, x86_MOVSD, x86_CMPSD, x86_LODSD, x86_SCASD: + prefix = "dword " + case x86_STOSQ, x86_MOVSQ, x86_CMPSQ, x86_LODSQ, x86_SCASQ: + prefix = "qword " + case x86_LAR: + prefix = "word " + case x86_BOUND: + if inst.Mode == 32 { + prefix = "qword " + } else { + prefix = "dword " + } + case x86_PREFETCHW, x86_PREFETCHNTA, x86_PREFETCHT0, x86_PREFETCHT1, x86_PREFETCHT2, x86_CLFLUSH: + prefix = "zmmword " + } + switch inst.Op { + case x86_MOVSB, x86_MOVSW, x86_MOVSD, x86_MOVSQ, x86_CMPSB, x86_CMPSW, x86_CMPSD, x86_CMPSQ, x86_STOSB, x86_STOSW, x86_STOSD, x86_STOSQ, x86_SCASB, x86_SCASW, x86_SCASD, x86_SCASQ, x86_LODSB, x86_LODSW, x86_LODSD, x86_LODSQ: + switch a.Base { + case x86_DI, x86_EDI, x86_RDI: + if a.Segment == x86_ES { + a.Segment = 0 + } + case x86_SI, x86_ESI, x86_RSI: + if a.Segment == x86_DS { + a.Segment = 0 + } + } + case x86_LEA: + a.Segment = 0 + default: + switch a.Base { + case x86_SP, x86_ESP, x86_RSP, x86_BP, x86_EBP, x86_RBP: + if a.Segment == x86_SS { + a.Segment = 0 + } + default: + if a.Segment == x86_DS { + a.Segment = 0 + } + } + } + + if inst.Mode == 64 && a.Segment != x86_FS && a.Segment != x86_GS { + a.Segment = 0 + } + + prefix += "ptr " + if a.Segment != 0 { + prefix += strings.ToLower(a.Segment.String()) + ":" + } + prefix += "[" + if a.Base != 0 { + prefix += x86_intelArg(inst, a.Base) + } + if a.Scale != 0 && a.Index != 0 { + if a.Base != 0 { + prefix += "+" + } + prefix += fmt.Sprintf("%s*%d", x86_intelArg(inst, a.Index), a.Scale) + } + if a.Disp != 0 { + if prefix[len(prefix)-1] == '[' && (a.Disp >= 0 || int64(int32(a.Disp)) != a.Disp) { + prefix += fmt.Sprintf("%#x", uint64(a.Disp)) + } else { + prefix += fmt.Sprintf("%+#x", a.Disp) + } + } + prefix += "]" + return prefix + case x86_Rel: + return fmt.Sprintf(".%+#x", int64(a)) + case x86_Reg: + if int(a) < len(x86_intelReg) && x86_intelReg[a] != "" { + return x86_intelReg[a] + } + } + return strings.ToLower(arg.String()) +} + +var x86_intelOp = map[x86_Op]string{ + x86_JAE: "jnb", + x86_JA: "jnbe", + x86_JGE: "jnl", + x86_JNE: "jnz", + x86_JG: "jnle", + x86_JE: "jz", + x86_SETAE: "setnb", + x86_SETA: "setnbe", + x86_SETGE: "setnl", + x86_SETNE: "setnz", + x86_SETG: "setnle", + x86_SETE: "setz", + x86_CMOVAE: "cmovnb", + x86_CMOVA: "cmovnbe", + x86_CMOVGE: "cmovnl", + x86_CMOVNE: "cmovnz", + x86_CMOVG: "cmovnle", + x86_CMOVE: "cmovz", + x86_LCALL: "call far", + x86_LJMP: "jmp far", + x86_LRET: "ret far", + x86_ICEBP: "int1", + x86_MOVSD_XMM: "movsd", + x86_XLATB: "xlat", +} + +var x86_intelReg = [...]string{ + x86_F0: "st0", + x86_F1: "st1", + x86_F2: "st2", + x86_F3: "st3", + x86_F4: "st4", + x86_F5: "st5", + x86_F6: "st6", + x86_F7: "st7", + x86_M0: "mmx0", + x86_M1: "mmx1", + x86_M2: "mmx2", + x86_M3: "mmx3", + x86_M4: "mmx4", + x86_M5: "mmx5", + x86_M6: "mmx6", + x86_M7: "mmx7", + x86_X0: "xmm0", + x86_X1: "xmm1", + x86_X2: "xmm2", + x86_X3: "xmm3", + x86_X4: "xmm4", + x86_X5: "xmm5", + x86_X6: "xmm6", + x86_X7: "xmm7", + x86_X8: "xmm8", + x86_X9: "xmm9", + x86_X10: "xmm10", + x86_X11: "xmm11", + x86_X12: "xmm12", + x86_X13: "xmm13", + x86_X14: "xmm14", + x86_X15: "xmm15", + + // TODO: Maybe the constants are named wrong. + x86_SPB: "spl", + x86_BPB: "bpl", + x86_SIB: "sil", + x86_DIB: "dil", + + x86_R8L: "r8d", + x86_R9L: "r9d", + x86_R10L: "r10d", + x86_R11L: "r11d", + x86_R12L: "r12d", + x86_R13L: "r13d", + x86_R14L: "r14d", + x86_R15L: "r15d", +} + +/* plan9x.go */ + +// Copyright 2014 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +// plan9Syntax returns the Go assembler syntax for the instruction. +// The syntax was originally defined by Plan 9. +// The pc is the program counter of the instruction, used for expanding +// PC-relative addresses into absolute ones. +// The symname function queries the symbol table for the program +// being disassembled. Given a target address it returns the name and base +// address of the symbol containing the target, if any; otherwise it returns "", 0. +func x86_plan9Syntax(inst x86_Inst, pc uint64, symname func(uint64) (string, uint64)) string { + if symname == nil { + symname = func(uint64) (string, uint64) { return "", 0 } + } + var args []string + for i := len(inst.Args) - 1; i >= 0; i-- { + a := inst.Args[i] + if a == nil { + continue + } + args = append(args, x86_plan9Arg(&inst, pc, symname, a)) + } + + var last x86_Prefix + for _, p := range inst.Prefix { + if p == 0 || p.IsREX() { + break + } + last = p + } + + prefix := "" + switch last & 0xFF { + case 0, 0x66, 0x67: + // ignore + case x86_PrefixREPN: + prefix += "REPNE " + default: + prefix += last.String() + " " + } + + op := inst.Op.String() + if x86_plan9Suffix[inst.Op] { + switch inst.DataSize { + case 8: + op += "B" + case 16: + op += "W" + case 32: + op += "L" + case 64: + op += "Q" + } + } + + if args != nil { + op += " " + strings.Join(args, ", ") + } + + return prefix + op +} + +func x86_plan9Arg(inst *x86_Inst, pc uint64, symname func(uint64) (string, uint64), arg x86_Arg) string { + switch a := arg.(type) { + case x86_Reg: + return x86_plan9Reg[a] + case x86_Rel: + if pc == 0 { + break + } + // If the absolute address is the start of a symbol, use the name. + // Otherwise use the raw address, so that things like relative + // jumps show up as JMP 0x123 instead of JMP f+10(SB). + // It is usually easier to search for 0x123 than to do the mental + // arithmetic to find f+10. + addr := pc + uint64(inst.Len) + uint64(a) + if s, base := symname(addr); s != "" && addr == base { + return fmt.Sprintf("%s(SB)", s) + } + return fmt.Sprintf("%#x", addr) + + case x86_Imm: + if s, base := symname(uint64(a)); s != "" { + suffix := "" + if uint64(a) != base { + suffix = fmt.Sprintf("%+d", uint64(a)-base) + } + return fmt.Sprintf("$%s%s(SB)", s, suffix) + } + if inst.Mode == 32 { + return fmt.Sprintf("$%#x", uint32(a)) + } + if x86_Imm(int32(a)) == a { + return fmt.Sprintf("$%#x", int64(a)) + } + return fmt.Sprintf("$%#x", uint64(a)) + case x86_Mem: + if a.Segment == 0 && a.Disp != 0 && a.Base == 0 && (a.Index == 0 || a.Scale == 0) { + if s, base := symname(uint64(a.Disp)); s != "" { + suffix := "" + if uint64(a.Disp) != base { + suffix = fmt.Sprintf("%+d", uint64(a.Disp)-base) + } + return fmt.Sprintf("%s%s(SB)", s, suffix) + } + } + s := "" + if a.Segment != 0 { + s += fmt.Sprintf("%s:", x86_plan9Reg[a.Segment]) + } + if a.Disp != 0 { + s += fmt.Sprintf("%#x", a.Disp) + } else { + s += "0" + } + if a.Base != 0 { + s += fmt.Sprintf("(%s)", x86_plan9Reg[a.Base]) + } + if a.Index != 0 && a.Scale != 0 { + s += fmt.Sprintf("(%s*%d)", x86_plan9Reg[a.Index], a.Scale) + } + return s + } + return arg.String() +} + +var x86_plan9Suffix = [x86_maxOp + 1]bool{ + x86_ADC: true, + x86_ADD: true, + x86_AND: true, + x86_BSF: true, + x86_BSR: true, + x86_BT: true, + x86_BTC: true, + x86_BTR: true, + x86_BTS: true, + x86_CMP: true, + x86_CMPXCHG: true, + x86_CVTSI2SD: true, + x86_CVTSI2SS: true, + x86_CVTSD2SI: true, + x86_CVTSS2SI: true, + x86_CVTTSD2SI: true, + x86_CVTTSS2SI: true, + x86_DEC: true, + x86_DIV: true, + x86_FLDENV: true, + x86_FRSTOR: true, + x86_IDIV: true, + x86_IMUL: true, + x86_IN: true, + x86_INC: true, + x86_LEA: true, + x86_MOV: true, + x86_MOVNTI: true, + x86_MUL: true, + x86_NEG: true, + x86_NOP: true, + x86_NOT: true, + x86_OR: true, + x86_OUT: true, + x86_POP: true, + x86_POPA: true, + x86_PUSH: true, + x86_PUSHA: true, + x86_RCL: true, + x86_RCR: true, + x86_ROL: true, + x86_ROR: true, + x86_SAR: true, + x86_SBB: true, + x86_SHL: true, + x86_SHLD: true, + x86_SHR: true, + x86_SHRD: true, + x86_SUB: true, + x86_TEST: true, + x86_XADD: true, + x86_XCHG: true, + x86_XOR: true, +} + +var x86_plan9Reg = [...]string{ + x86_AL: "AL", + x86_CL: "CL", + x86_BL: "BL", + x86_DL: "DL", + x86_AH: "AH", + x86_CH: "CH", + x86_BH: "BH", + x86_DH: "DH", + x86_SPB: "SP", + x86_BPB: "BP", + x86_SIB: "SI", + x86_DIB: "DI", + x86_R8B: "R8", + x86_R9B: "R9", + x86_R10B: "R10", + x86_R11B: "R11", + x86_R12B: "R12", + x86_R13B: "R13", + x86_R14B: "R14", + x86_R15B: "R15", + x86_AX: "AX", + x86_CX: "CX", + x86_BX: "BX", + x86_DX: "DX", + x86_SP: "SP", + x86_BP: "BP", + x86_SI: "SI", + x86_DI: "DI", + x86_R8W: "R8", + x86_R9W: "R9", + x86_R10W: "R10", + x86_R11W: "R11", + x86_R12W: "R12", + x86_R13W: "R13", + x86_R14W: "R14", + x86_R15W: "R15", + x86_EAX: "AX", + x86_ECX: "CX", + x86_EDX: "DX", + x86_EBX: "BX", + x86_ESP: "SP", + x86_EBP: "BP", + x86_ESI: "SI", + x86_EDI: "DI", + x86_R8L: "R8", + x86_R9L: "R9", + x86_R10L: "R10", + x86_R11L: "R11", + x86_R12L: "R12", + x86_R13L: "R13", + x86_R14L: "R14", + x86_R15L: "R15", + x86_RAX: "AX", + x86_RCX: "CX", + x86_RDX: "DX", + x86_RBX: "BX", + x86_RSP: "SP", + x86_RBP: "BP", + x86_RSI: "SI", + x86_RDI: "DI", + x86_R8: "R8", + x86_R9: "R9", + x86_R10: "R10", + x86_R11: "R11", + x86_R12: "R12", + x86_R13: "R13", + x86_R14: "R14", + x86_R15: "R15", + x86_IP: "IP", + x86_EIP: "IP", + x86_RIP: "IP", + x86_F0: "F0", + x86_F1: "F1", + x86_F2: "F2", + x86_F3: "F3", + x86_F4: "F4", + x86_F5: "F5", + x86_F6: "F6", + x86_F7: "F7", + x86_M0: "M0", + x86_M1: "M1", + x86_M2: "M2", + x86_M3: "M3", + x86_M4: "M4", + x86_M5: "M5", + x86_M6: "M6", + x86_M7: "M7", + x86_X0: "X0", + x86_X1: "X1", + x86_X2: "X2", + x86_X3: "X3", + x86_X4: "X4", + x86_X5: "X5", + x86_X6: "X6", + x86_X7: "X7", + x86_X8: "X8", + x86_X9: "X9", + x86_X10: "X10", + x86_X11: "X11", + x86_X12: "X12", + x86_X13: "X13", + x86_X14: "X14", + x86_X15: "X15", + x86_CS: "CS", + x86_SS: "SS", + x86_DS: "DS", + x86_ES: "ES", + x86_FS: "FS", + x86_GS: "GS", + x86_GDTR: "GDTR", + x86_IDTR: "IDTR", + x86_LDTR: "LDTR", + x86_MSW: "MSW", + x86_TASK: "TASK", + x86_CR0: "CR0", + x86_CR1: "CR1", + x86_CR2: "CR2", + x86_CR3: "CR3", + x86_CR4: "CR4", + x86_CR5: "CR5", + x86_CR6: "CR6", + x86_CR7: "CR7", + x86_CR8: "CR8", + x86_CR9: "CR9", + x86_CR10: "CR10", + x86_CR11: "CR11", + x86_CR12: "CR12", + x86_CR13: "CR13", + x86_CR14: "CR14", + x86_CR15: "CR15", + x86_DR0: "DR0", + x86_DR1: "DR1", + x86_DR2: "DR2", + x86_DR3: "DR3", + x86_DR4: "DR4", + x86_DR5: "DR5", + x86_DR6: "DR6", + x86_DR7: "DR7", + x86_DR8: "DR8", + x86_DR9: "DR9", + x86_DR10: "DR10", + x86_DR11: "DR11", + x86_DR12: "DR12", + x86_DR13: "DR13", + x86_DR14: "DR14", + x86_DR15: "DR15", + x86_TR0: "TR0", + x86_TR1: "TR1", + x86_TR2: "TR2", + x86_TR3: "TR3", + x86_TR4: "TR4", + x86_TR5: "TR5", + x86_TR6: "TR6", + x86_TR7: "TR7", +} + +/* tables.go */ + +// DO NOT EDIT +// generated by: x86map -fmt=decoder ../x86.csv + +var x86_decoder = [...]uint16{ + uint16(x86_xFail), + /*1*/ uint16(x86_xCondByte), 243, + 0x00, 490, + 0x01, 496, + 0x02, 525, + 0x03, 531, + 0x04, 560, + 0x05, 566, + 0x06, 595, + 0x07, 602, + 0x08, 609, + 0x09, 615, + 0x0A, 644, + 0x0B, 650, + 0x0C, 679, + 0x0D, 685, + 0x0E, 714, + 0x0F, 721, + 0x10, 8026, + 0x11, 8032, + 0x12, 8061, + 0x13, 8067, + 0x14, 8096, + 0x15, 8102, + 0x16, 8131, + 0x17, 8138, + 0x18, 8145, + 0x19, 8151, + 0x1A, 8180, + 0x1B, 8186, + 0x1C, 8215, + 0x1D, 8221, + 0x1E, 8250, + 0x1F, 8257, + 0x20, 8264, + 0x21, 8270, + 0x22, 8299, + 0x23, 8305, + 0x24, 8334, + 0x25, 8340, + 0x27, 8369, + 0x28, 8375, + 0x29, 8381, + 0x2A, 8410, + 0x2B, 8416, + 0x2C, 8445, + 0x2D, 8451, + 0x2F, 8480, + 0x30, 8486, + 0x31, 8492, + 0x32, 8521, + 0x33, 8527, + 0x34, 8556, + 0x35, 8562, + 0x37, 8591, + 0x38, 8597, + 0x39, 8603, + 0x3A, 8632, + 0x3B, 8638, + 0x3C, 8667, + 0x3D, 8673, + 0x3F, 8702, + 0x40, 8708, + 0x41, 8708, + 0x42, 8708, + 0x43, 8708, + 0x44, 8708, + 0x45, 8708, + 0x46, 8708, + 0x47, 8708, + 0x48, 8723, + 0x49, 8723, + 0x4a, 8723, + 0x4b, 8723, + 0x4c, 8723, + 0x4d, 8723, + 0x4e, 8723, + 0x4f, 8723, + 0x50, 8738, + 0x51, 8738, + 0x52, 8738, + 0x53, 8738, + 0x54, 8738, + 0x55, 8738, + 0x56, 8738, + 0x57, 8738, + 0x58, 8765, + 0x59, 8765, + 0x5a, 8765, + 0x5b, 8765, + 0x5c, 8765, + 0x5d, 8765, + 0x5e, 8765, + 0x5f, 8765, + 0x60, 8792, + 0x61, 8805, + 0x62, 8818, + 0x63, 8837, + 0x68, 8868, + 0x69, 8887, + 0x6A, 8922, + 0x6B, 8927, + 0x6C, 8962, + 0x6D, 8965, + 0x6E, 8978, + 0x6F, 8981, + 0x70, 8994, + 0x71, 8999, + 0x72, 9004, + 0x73, 9009, + 0x74, 9014, + 0x75, 9019, + 0x76, 9024, + 0x77, 9029, + 0x78, 9034, + 0x79, 9039, + 0x7A, 9044, + 0x7B, 9049, + 0x7C, 9054, + 0x7D, 9059, + 0x7E, 9064, + 0x7F, 9069, + 0x80, 9074, + 0x81, 9131, + 0x83, 9372, + 0x84, 9613, + 0x85, 9619, + 0x86, 9648, + 0x87, 9654, + 0x88, 9683, + 0x89, 9689, + 0x8A, 9711, + 0x8B, 9717, + 0x8C, 9739, + 0x8D, 9768, + 0x8E, 9797, + 0x8F, 9826, + 0x90, 9862, + 0x91, 9862, + 0x92, 9862, + 0x93, 9862, + 0x94, 9862, + 0x95, 9862, + 0x96, 9862, + 0x97, 9862, + 0x98, 9888, + 0x99, 9908, + 0x9A, 9928, + 0x9B, 9945, + 0x9C, 9948, + 0x9D, 9971, + 0x9E, 9994, + 0x9F, 9997, + 0xA0, 10000, + 0xA1, 10019, + 0xA2, 10041, + 0xA3, 10060, + 0xA4, 10082, + 0xA5, 10085, + 0xA6, 10105, + 0xA7, 10108, + 0xA8, 10128, + 0xA9, 10134, + 0xAA, 10163, + 0xAB, 10166, + 0xAC, 10186, + 0xAD, 10189, + 0xAE, 10209, + 0xAF, 10212, + 0xb0, 10232, + 0xb1, 10232, + 0xb2, 10232, + 0xb3, 10232, + 0xb4, 10232, + 0xb5, 10232, + 0xb6, 10232, + 0xb7, 10232, + 0xb8, 10238, + 0xb9, 10238, + 0xba, 10238, + 0xbb, 10238, + 0xbc, 10238, + 0xbd, 10238, + 0xbe, 10238, + 0xbf, 10238, + 0xC0, 10267, + 0xC1, 10318, + 0xC2, 10516, + 0xC3, 10521, + 0xC4, 10524, + 0xC5, 10543, + 0xC6, 10562, + 0xC7, 10586, + 0xC8, 10647, + 0xC9, 10654, + 0xCA, 10677, + 0xCB, 10682, + 0xCC, 10685, + 0xCD, 10689, + 0xCE, 10694, + 0xCF, 10700, + 0xD0, 10720, + 0xD1, 10764, + 0xD2, 10955, + 0xD3, 10999, + 0xD4, 11190, + 0xD5, 11198, + 0xD7, 11206, + 0xD8, 11219, + 0xD9, 11428, + 0xDA, 11637, + 0xDB, 11769, + 0xDC, 11940, + 0xDD, 12109, + 0xDE, 12248, + 0xDF, 12422, + 0xE0, 12533, + 0xE1, 12538, + 0xE2, 12543, + 0xE3, 12548, + 0xE4, 12574, + 0xE5, 12580, + 0xE6, 12602, + 0xE7, 12608, + 0xE8, 12630, + 0xE9, 12661, + 0xEA, 12692, + 0xEB, 12709, + 0xEC, 12714, + 0xED, 12719, + 0xEE, 12738, + 0xEF, 12743, + 0xF1, 12762, + 0xF4, 12765, + 0xF5, 12768, + 0xF6, 12771, + 0xF7, 12810, + 0xF8, 12986, + 0xF9, 12989, + 0xFA, 12992, + 0xFB, 12995, + 0xFC, 12998, + 0xFD, 13001, + 0xFE, 13004, + 0xFF, 13021, + uint16(x86_xFail), + /*490*/ uint16(x86_xSetOp), uint16(x86_ADD), + /*492*/ uint16(x86_xReadSlashR), + /*493*/ uint16(x86_xArgRM8), + /*494*/ uint16(x86_xArgR8), + /*495*/ uint16(x86_xMatch), + /*496*/ uint16(x86_xCondIs64), 499, 515, + /*499*/ uint16(x86_xCondDataSize), 503, 509, 0, + /*503*/ uint16(x86_xSetOp), uint16(x86_ADD), + /*505*/ uint16(x86_xReadSlashR), + /*506*/ uint16(x86_xArgRM16), + /*507*/ uint16(x86_xArgR16), + /*508*/ uint16(x86_xMatch), + /*509*/ uint16(x86_xSetOp), uint16(x86_ADD), + /*511*/ uint16(x86_xReadSlashR), + /*512*/ uint16(x86_xArgRM32), + /*513*/ uint16(x86_xArgR32), + /*514*/ uint16(x86_xMatch), + /*515*/ uint16(x86_xCondDataSize), 503, 509, 519, + /*519*/ uint16(x86_xSetOp), uint16(x86_ADD), + /*521*/ uint16(x86_xReadSlashR), + /*522*/ uint16(x86_xArgRM64), + /*523*/ uint16(x86_xArgR64), + /*524*/ uint16(x86_xMatch), + /*525*/ uint16(x86_xSetOp), uint16(x86_ADD), + /*527*/ uint16(x86_xReadSlashR), + /*528*/ uint16(x86_xArgR8), + /*529*/ uint16(x86_xArgRM8), + /*530*/ uint16(x86_xMatch), + /*531*/ uint16(x86_xCondIs64), 534, 550, + /*534*/ uint16(x86_xCondDataSize), 538, 544, 0, + /*538*/ uint16(x86_xSetOp), uint16(x86_ADD), + /*540*/ uint16(x86_xReadSlashR), + /*541*/ uint16(x86_xArgR16), + /*542*/ uint16(x86_xArgRM16), + /*543*/ uint16(x86_xMatch), + /*544*/ uint16(x86_xSetOp), uint16(x86_ADD), + /*546*/ uint16(x86_xReadSlashR), + /*547*/ uint16(x86_xArgR32), + /*548*/ uint16(x86_xArgRM32), + /*549*/ uint16(x86_xMatch), + /*550*/ uint16(x86_xCondDataSize), 538, 544, 554, + /*554*/ uint16(x86_xSetOp), uint16(x86_ADD), + /*556*/ uint16(x86_xReadSlashR), + /*557*/ uint16(x86_xArgR64), + /*558*/ uint16(x86_xArgRM64), + /*559*/ uint16(x86_xMatch), + /*560*/ uint16(x86_xSetOp), uint16(x86_ADD), + /*562*/ uint16(x86_xReadIb), + /*563*/ uint16(x86_xArgAL), + /*564*/ uint16(x86_xArgImm8u), + /*565*/ uint16(x86_xMatch), + /*566*/ uint16(x86_xCondIs64), 569, 585, + /*569*/ uint16(x86_xCondDataSize), 573, 579, 0, + /*573*/ uint16(x86_xSetOp), uint16(x86_ADD), + /*575*/ uint16(x86_xReadIw), + /*576*/ uint16(x86_xArgAX), + /*577*/ uint16(x86_xArgImm16), + /*578*/ uint16(x86_xMatch), + /*579*/ uint16(x86_xSetOp), uint16(x86_ADD), + /*581*/ uint16(x86_xReadId), + /*582*/ uint16(x86_xArgEAX), + /*583*/ uint16(x86_xArgImm32), + /*584*/ uint16(x86_xMatch), + /*585*/ uint16(x86_xCondDataSize), 573, 579, 589, + /*589*/ uint16(x86_xSetOp), uint16(x86_ADD), + /*591*/ uint16(x86_xReadId), + /*592*/ uint16(x86_xArgRAX), + /*593*/ uint16(x86_xArgImm32), + /*594*/ uint16(x86_xMatch), + /*595*/ uint16(x86_xCondIs64), 598, 0, + /*598*/ uint16(x86_xSetOp), uint16(x86_PUSH), + /*600*/ uint16(x86_xArgES), + /*601*/ uint16(x86_xMatch), + /*602*/ uint16(x86_xCondIs64), 605, 0, + /*605*/ uint16(x86_xSetOp), uint16(x86_POP), + /*607*/ uint16(x86_xArgES), + /*608*/ uint16(x86_xMatch), + /*609*/ uint16(x86_xSetOp), uint16(x86_OR), + /*611*/ uint16(x86_xReadSlashR), + /*612*/ uint16(x86_xArgRM8), + /*613*/ uint16(x86_xArgR8), + /*614*/ uint16(x86_xMatch), + /*615*/ uint16(x86_xCondIs64), 618, 634, + /*618*/ uint16(x86_xCondDataSize), 622, 628, 0, + /*622*/ uint16(x86_xSetOp), uint16(x86_OR), + /*624*/ uint16(x86_xReadSlashR), + /*625*/ uint16(x86_xArgRM16), + /*626*/ uint16(x86_xArgR16), + /*627*/ uint16(x86_xMatch), + /*628*/ uint16(x86_xSetOp), uint16(x86_OR), + /*630*/ uint16(x86_xReadSlashR), + /*631*/ uint16(x86_xArgRM32), + /*632*/ uint16(x86_xArgR32), + /*633*/ uint16(x86_xMatch), + /*634*/ uint16(x86_xCondDataSize), 622, 628, 638, + /*638*/ uint16(x86_xSetOp), uint16(x86_OR), + /*640*/ uint16(x86_xReadSlashR), + /*641*/ uint16(x86_xArgRM64), + /*642*/ uint16(x86_xArgR64), + /*643*/ uint16(x86_xMatch), + /*644*/ uint16(x86_xSetOp), uint16(x86_OR), + /*646*/ uint16(x86_xReadSlashR), + /*647*/ uint16(x86_xArgR8), + /*648*/ uint16(x86_xArgRM8), + /*649*/ uint16(x86_xMatch), + /*650*/ uint16(x86_xCondIs64), 653, 669, + /*653*/ uint16(x86_xCondDataSize), 657, 663, 0, + /*657*/ uint16(x86_xSetOp), uint16(x86_OR), + /*659*/ uint16(x86_xReadSlashR), + /*660*/ uint16(x86_xArgR16), + /*661*/ uint16(x86_xArgRM16), + /*662*/ uint16(x86_xMatch), + /*663*/ uint16(x86_xSetOp), uint16(x86_OR), + /*665*/ uint16(x86_xReadSlashR), + /*666*/ uint16(x86_xArgR32), + /*667*/ uint16(x86_xArgRM32), + /*668*/ uint16(x86_xMatch), + /*669*/ uint16(x86_xCondDataSize), 657, 663, 673, + /*673*/ uint16(x86_xSetOp), uint16(x86_OR), + /*675*/ uint16(x86_xReadSlashR), + /*676*/ uint16(x86_xArgR64), + /*677*/ uint16(x86_xArgRM64), + /*678*/ uint16(x86_xMatch), + /*679*/ uint16(x86_xSetOp), uint16(x86_OR), + /*681*/ uint16(x86_xReadIb), + /*682*/ uint16(x86_xArgAL), + /*683*/ uint16(x86_xArgImm8u), + /*684*/ uint16(x86_xMatch), + /*685*/ uint16(x86_xCondIs64), 688, 704, + /*688*/ uint16(x86_xCondDataSize), 692, 698, 0, + /*692*/ uint16(x86_xSetOp), uint16(x86_OR), + /*694*/ uint16(x86_xReadIw), + /*695*/ uint16(x86_xArgAX), + /*696*/ uint16(x86_xArgImm16), + /*697*/ uint16(x86_xMatch), + /*698*/ uint16(x86_xSetOp), uint16(x86_OR), + /*700*/ uint16(x86_xReadId), + /*701*/ uint16(x86_xArgEAX), + /*702*/ uint16(x86_xArgImm32), + /*703*/ uint16(x86_xMatch), + /*704*/ uint16(x86_xCondDataSize), 692, 698, 708, + /*708*/ uint16(x86_xSetOp), uint16(x86_OR), + /*710*/ uint16(x86_xReadId), + /*711*/ uint16(x86_xArgRAX), + /*712*/ uint16(x86_xArgImm32), + /*713*/ uint16(x86_xMatch), + /*714*/ uint16(x86_xCondIs64), 717, 0, + /*717*/ uint16(x86_xSetOp), uint16(x86_PUSH), + /*719*/ uint16(x86_xArgCS), + /*720*/ uint16(x86_xMatch), + /*721*/ uint16(x86_xCondByte), 228, + 0x00, 1180, + 0x01, 1237, + 0x02, 1345, + 0x03, 1367, + 0x05, 1389, + 0x06, 1395, + 0x07, 1398, + 0x08, 1404, + 0x09, 1407, + 0x0B, 1410, + 0x0D, 1413, + 0x10, 1426, + 0x11, 1460, + 0x12, 1494, + 0x13, 1537, + 0x14, 1555, + 0x15, 1573, + 0x16, 1591, + 0x17, 1626, + 0x18, 1644, + 0x1F, 1669, + 0x20, 1690, + 0x21, 1705, + 0x22, 1720, + 0x23, 1735, + 0x24, 1750, + 0x26, 1765, + 0x28, 1780, + 0x29, 1798, + 0x2A, 1816, + 0x2B, 1903, + 0x2C, 1937, + 0x2D, 2024, + 0x2E, 2111, + 0x2F, 2129, + 0x30, 2147, + 0x31, 2150, + 0x32, 2153, + 0x33, 2156, + 0x34, 2159, + 0x35, 2162, + 0x38, 2172, + 0x3A, 3073, + 0x40, 3484, + 0x41, 3513, + 0x42, 3542, + 0x43, 3571, + 0x44, 3600, + 0x45, 3629, + 0x46, 3658, + 0x47, 3687, + 0x48, 3716, + 0x49, 3745, + 0x4A, 3774, + 0x4B, 3803, + 0x4C, 3832, + 0x4D, 3861, + 0x4E, 3890, + 0x4F, 3919, + 0x50, 3948, + 0x51, 3966, + 0x52, 4000, + 0x53, 4018, + 0x54, 4036, + 0x55, 4054, + 0x56, 4072, + 0x57, 4090, + 0x58, 4108, + 0x59, 4142, + 0x5A, 4176, + 0x5B, 4210, + 0x5C, 4236, + 0x5D, 4270, + 0x5E, 4304, + 0x5F, 4338, + 0x60, 4372, + 0x61, 4390, + 0x62, 4408, + 0x63, 4426, + 0x64, 4444, + 0x65, 4462, + 0x66, 4480, + 0x67, 4498, + 0x68, 4516, + 0x69, 4534, + 0x6A, 4552, + 0x6B, 4570, + 0x6C, 4588, + 0x6D, 4598, + 0x6E, 4608, + 0x6F, 4675, + 0x70, 4701, + 0x71, 4743, + 0x72, 4806, + 0x73, 4869, + 0x74, 4934, + 0x75, 4952, + 0x76, 4970, + 0x77, 4988, + 0x7C, 4991, + 0x7D, 5009, + 0x7E, 5027, + 0x7F, 5104, + 0x80, 5130, + 0x81, 5161, + 0x82, 5192, + 0x83, 5223, + 0x84, 5254, + 0x85, 5285, + 0x86, 5316, + 0x87, 5347, + 0x88, 5378, + 0x89, 5409, + 0x8A, 5440, + 0x8B, 5471, + 0x8C, 5502, + 0x8D, 5533, + 0x8E, 5564, + 0x8F, 5595, + 0x90, 5626, + 0x91, 5631, + 0x92, 5636, + 0x93, 5641, + 0x94, 5646, + 0x95, 5651, + 0x96, 5656, + 0x97, 5661, + 0x98, 5666, + 0x99, 5671, + 0x9A, 5676, + 0x9B, 5681, + 0x9C, 5686, + 0x9D, 5691, + 0x9E, 5696, + 0x9F, 5701, + 0xA0, 5706, + 0xA1, 5710, + 0xA2, 5737, + 0xA3, 5740, + 0xA4, 5769, + 0xA5, 5804, + 0xA8, 5836, + 0xA9, 5840, + 0xAA, 5867, + 0xAB, 5870, + 0xAC, 5899, + 0xAD, 5934, + 0xAE, 5966, + 0xAF, 6224, + 0xB0, 6253, + 0xB1, 6259, + 0xB2, 6288, + 0xB3, 6317, + 0xB4, 6346, + 0xB5, 6375, + 0xB6, 6404, + 0xB7, 6433, + 0xB8, 6462, + 0xB9, 6499, + 0xBA, 6502, + 0xBB, 6627, + 0xBC, 6656, + 0xBD, 6723, + 0xBE, 6790, + 0xBF, 6819, + 0xC0, 6848, + 0xC1, 6854, + 0xC2, 6883, + 0xC3, 6925, + 0xC4, 6954, + 0xC5, 6976, + 0xC6, 6998, + 0xC7, 7020, + 0xc8, 7149, + 0xc9, 7149, + 0xca, 7149, + 0xcb, 7149, + 0xcc, 7149, + 0xcd, 7149, + 0xce, 7149, + 0xcf, 7149, + 0xD0, 7172, + 0xD1, 7190, + 0xD2, 7208, + 0xD3, 7226, + 0xD4, 7244, + 0xD5, 7262, + 0xD6, 7280, + 0xD7, 7306, + 0xD8, 7324, + 0xD9, 7342, + 0xDA, 7360, + 0xDB, 7378, + 0xDC, 7396, + 0xDD, 7414, + 0xDE, 7432, + 0xDF, 7450, + 0xE0, 7468, + 0xE1, 7486, + 0xE2, 7504, + 0xE3, 7522, + 0xE4, 7540, + 0xE5, 7558, + 0xE6, 7576, + 0xE7, 7602, + 0xE8, 7620, + 0xE9, 7638, + 0xEA, 7656, + 0xEB, 7674, + 0xEC, 7692, + 0xED, 7710, + 0xEE, 7728, + 0xEF, 7746, + 0xF0, 7764, + 0xF1, 7774, + 0xF2, 7792, + 0xF3, 7810, + 0xF4, 7828, + 0xF5, 7846, + 0xF6, 7864, + 0xF7, 7882, + 0xF8, 7900, + 0xF9, 7918, + 0xFA, 7936, + 0xFB, 7954, + 0xFC, 7972, + 0xFD, 7990, + 0xFE, 8008, + uint16(x86_xFail), + /*1180*/ uint16(x86_xCondSlashR), + 1189, // 0 + 1205, // 1 + 1221, // 2 + 1225, // 3 + 1229, // 4 + 1233, // 5 + 0, // 6 + 0, // 7 + /*1189*/ uint16(x86_xCondDataSize), 1193, 1197, 1201, + /*1193*/ uint16(x86_xSetOp), uint16(x86_SLDT), + /*1195*/ uint16(x86_xArgRM16), + /*1196*/ uint16(x86_xMatch), + /*1197*/ uint16(x86_xSetOp), uint16(x86_SLDT), + /*1199*/ uint16(x86_xArgR32M16), + /*1200*/ uint16(x86_xMatch), + /*1201*/ uint16(x86_xSetOp), uint16(x86_SLDT), + /*1203*/ uint16(x86_xArgR64M16), + /*1204*/ uint16(x86_xMatch), + /*1205*/ uint16(x86_xCondDataSize), 1209, 1213, 1217, + /*1209*/ uint16(x86_xSetOp), uint16(x86_STR), + /*1211*/ uint16(x86_xArgRM16), + /*1212*/ uint16(x86_xMatch), + /*1213*/ uint16(x86_xSetOp), uint16(x86_STR), + /*1215*/ uint16(x86_xArgR32M16), + /*1216*/ uint16(x86_xMatch), + /*1217*/ uint16(x86_xSetOp), uint16(x86_STR), + /*1219*/ uint16(x86_xArgR64M16), + /*1220*/ uint16(x86_xMatch), + /*1221*/ uint16(x86_xSetOp), uint16(x86_LLDT), + /*1223*/ uint16(x86_xArgRM16), + /*1224*/ uint16(x86_xMatch), + /*1225*/ uint16(x86_xSetOp), uint16(x86_LTR), + /*1227*/ uint16(x86_xArgRM16), + /*1228*/ uint16(x86_xMatch), + /*1229*/ uint16(x86_xSetOp), uint16(x86_VERR), + /*1231*/ uint16(x86_xArgRM16), + /*1232*/ uint16(x86_xMatch), + /*1233*/ uint16(x86_xSetOp), uint16(x86_VERW), + /*1235*/ uint16(x86_xArgRM16), + /*1236*/ uint16(x86_xMatch), + /*1237*/ uint16(x86_xCondByte), 8, + 0xC8, 1318, + 0xC9, 1321, + 0xD0, 1324, + 0xD1, 1327, + 0xD5, 1330, + 0xD6, 1333, + 0xF8, 1336, + 0xF9, 1342, + /*1255*/ uint16(x86_xCondSlashR), + 1264, // 0 + 1268, // 1 + 1272, // 2 + 1283, // 3 + 1294, // 4 + 0, // 5 + 1310, // 6 + 1314, // 7 + /*1264*/ uint16(x86_xSetOp), uint16(x86_SGDT), + /*1266*/ uint16(x86_xArgM), + /*1267*/ uint16(x86_xMatch), + /*1268*/ uint16(x86_xSetOp), uint16(x86_SIDT), + /*1270*/ uint16(x86_xArgM), + /*1271*/ uint16(x86_xMatch), + /*1272*/ uint16(x86_xCondIs64), 1275, 1279, + /*1275*/ uint16(x86_xSetOp), uint16(x86_LGDT), + /*1277*/ uint16(x86_xArgM16and32), + /*1278*/ uint16(x86_xMatch), + /*1279*/ uint16(x86_xSetOp), uint16(x86_LGDT), + /*1281*/ uint16(x86_xArgM16and64), + /*1282*/ uint16(x86_xMatch), + /*1283*/ uint16(x86_xCondIs64), 1286, 1290, + /*1286*/ uint16(x86_xSetOp), uint16(x86_LIDT), + /*1288*/ uint16(x86_xArgM16and32), + /*1289*/ uint16(x86_xMatch), + /*1290*/ uint16(x86_xSetOp), uint16(x86_LIDT), + /*1292*/ uint16(x86_xArgM16and64), + /*1293*/ uint16(x86_xMatch), + /*1294*/ uint16(x86_xCondDataSize), 1298, 1302, 1306, + /*1298*/ uint16(x86_xSetOp), uint16(x86_SMSW), + /*1300*/ uint16(x86_xArgRM16), + /*1301*/ uint16(x86_xMatch), + /*1302*/ uint16(x86_xSetOp), uint16(x86_SMSW), + /*1304*/ uint16(x86_xArgR32M16), + /*1305*/ uint16(x86_xMatch), + /*1306*/ uint16(x86_xSetOp), uint16(x86_SMSW), + /*1308*/ uint16(x86_xArgR64M16), + /*1309*/ uint16(x86_xMatch), + /*1310*/ uint16(x86_xSetOp), uint16(x86_LMSW), + /*1312*/ uint16(x86_xArgRM16), + /*1313*/ uint16(x86_xMatch), + /*1314*/ uint16(x86_xSetOp), uint16(x86_INVLPG), + /*1316*/ uint16(x86_xArgM), + /*1317*/ uint16(x86_xMatch), + /*1318*/ uint16(x86_xSetOp), uint16(x86_MONITOR), + /*1320*/ uint16(x86_xMatch), + /*1321*/ uint16(x86_xSetOp), uint16(x86_MWAIT), + /*1323*/ uint16(x86_xMatch), + /*1324*/ uint16(x86_xSetOp), uint16(x86_XGETBV), + /*1326*/ uint16(x86_xMatch), + /*1327*/ uint16(x86_xSetOp), uint16(x86_XSETBV), + /*1329*/ uint16(x86_xMatch), + /*1330*/ uint16(x86_xSetOp), uint16(x86_XEND), + /*1332*/ uint16(x86_xMatch), + /*1333*/ uint16(x86_xSetOp), uint16(x86_XTEST), + /*1335*/ uint16(x86_xMatch), + /*1336*/ uint16(x86_xCondIs64), 0, 1339, + /*1339*/ uint16(x86_xSetOp), uint16(x86_SWAPGS), + /*1341*/ uint16(x86_xMatch), + /*1342*/ uint16(x86_xSetOp), uint16(x86_RDTSCP), + /*1344*/ uint16(x86_xMatch), + /*1345*/ uint16(x86_xCondDataSize), 1349, 1355, 1361, + /*1349*/ uint16(x86_xSetOp), uint16(x86_LAR), + /*1351*/ uint16(x86_xReadSlashR), + /*1352*/ uint16(x86_xArgR16), + /*1353*/ uint16(x86_xArgRM16), + /*1354*/ uint16(x86_xMatch), + /*1355*/ uint16(x86_xSetOp), uint16(x86_LAR), + /*1357*/ uint16(x86_xReadSlashR), + /*1358*/ uint16(x86_xArgR32), + /*1359*/ uint16(x86_xArgR32M16), + /*1360*/ uint16(x86_xMatch), + /*1361*/ uint16(x86_xSetOp), uint16(x86_LAR), + /*1363*/ uint16(x86_xReadSlashR), + /*1364*/ uint16(x86_xArgR64), + /*1365*/ uint16(x86_xArgR64M16), + /*1366*/ uint16(x86_xMatch), + /*1367*/ uint16(x86_xCondDataSize), 1371, 1377, 1383, + /*1371*/ uint16(x86_xSetOp), uint16(x86_LSL), + /*1373*/ uint16(x86_xReadSlashR), + /*1374*/ uint16(x86_xArgR16), + /*1375*/ uint16(x86_xArgRM16), + /*1376*/ uint16(x86_xMatch), + /*1377*/ uint16(x86_xSetOp), uint16(x86_LSL), + /*1379*/ uint16(x86_xReadSlashR), + /*1380*/ uint16(x86_xArgR32), + /*1381*/ uint16(x86_xArgR32M16), + /*1382*/ uint16(x86_xMatch), + /*1383*/ uint16(x86_xSetOp), uint16(x86_LSL), + /*1385*/ uint16(x86_xReadSlashR), + /*1386*/ uint16(x86_xArgR64), + /*1387*/ uint16(x86_xArgR32M16), + /*1388*/ uint16(x86_xMatch), + /*1389*/ uint16(x86_xCondIs64), 0, 1392, + /*1392*/ uint16(x86_xSetOp), uint16(x86_SYSCALL), + /*1394*/ uint16(x86_xMatch), + /*1395*/ uint16(x86_xSetOp), uint16(x86_CLTS), + /*1397*/ uint16(x86_xMatch), + /*1398*/ uint16(x86_xCondIs64), 0, 1401, + /*1401*/ uint16(x86_xSetOp), uint16(x86_SYSRET), + /*1403*/ uint16(x86_xMatch), + /*1404*/ uint16(x86_xSetOp), uint16(x86_INVD), + /*1406*/ uint16(x86_xMatch), + /*1407*/ uint16(x86_xSetOp), uint16(x86_WBINVD), + /*1409*/ uint16(x86_xMatch), + /*1410*/ uint16(x86_xSetOp), uint16(x86_UD2), + /*1412*/ uint16(x86_xMatch), + /*1413*/ uint16(x86_xCondSlashR), + 0, // 0 + 1422, // 1 + 0, // 2 + 0, // 3 + 0, // 4 + 0, // 5 + 0, // 6 + 0, // 7 + /*1422*/ uint16(x86_xSetOp), uint16(x86_PREFETCHW), + /*1424*/ uint16(x86_xArgM8), + /*1425*/ uint16(x86_xMatch), + /*1426*/ uint16(x86_xCondPrefix), 4, + 0xF3, 1454, + 0xF2, 1448, + 0x66, 1442, + 0x0, 1436, + /*1436*/ uint16(x86_xSetOp), uint16(x86_MOVUPS), + /*1438*/ uint16(x86_xReadSlashR), + /*1439*/ uint16(x86_xArgXmm1), + /*1440*/ uint16(x86_xArgXmm2M128), + /*1441*/ uint16(x86_xMatch), + /*1442*/ uint16(x86_xSetOp), uint16(x86_MOVUPD), + /*1444*/ uint16(x86_xReadSlashR), + /*1445*/ uint16(x86_xArgXmm1), + /*1446*/ uint16(x86_xArgXmm2M128), + /*1447*/ uint16(x86_xMatch), + /*1448*/ uint16(x86_xSetOp), uint16(x86_MOVSD_XMM), + /*1450*/ uint16(x86_xReadSlashR), + /*1451*/ uint16(x86_xArgXmm1), + /*1452*/ uint16(x86_xArgXmm2M64), + /*1453*/ uint16(x86_xMatch), + /*1454*/ uint16(x86_xSetOp), uint16(x86_MOVSS), + /*1456*/ uint16(x86_xReadSlashR), + /*1457*/ uint16(x86_xArgXmm1), + /*1458*/ uint16(x86_xArgXmm2M32), + /*1459*/ uint16(x86_xMatch), + /*1460*/ uint16(x86_xCondPrefix), 4, + 0xF3, 1488, + 0xF2, 1482, + 0x66, 1476, + 0x0, 1470, + /*1470*/ uint16(x86_xSetOp), uint16(x86_MOVUPS), + /*1472*/ uint16(x86_xReadSlashR), + /*1473*/ uint16(x86_xArgXmm2M128), + /*1474*/ uint16(x86_xArgXmm1), + /*1475*/ uint16(x86_xMatch), + /*1476*/ uint16(x86_xSetOp), uint16(x86_MOVUPD), + /*1478*/ uint16(x86_xReadSlashR), + /*1479*/ uint16(x86_xArgXmm2M128), + /*1480*/ uint16(x86_xArgXmm), + /*1481*/ uint16(x86_xMatch), + /*1482*/ uint16(x86_xSetOp), uint16(x86_MOVSD_XMM), + /*1484*/ uint16(x86_xReadSlashR), + /*1485*/ uint16(x86_xArgXmm2M64), + /*1486*/ uint16(x86_xArgXmm1), + /*1487*/ uint16(x86_xMatch), + /*1488*/ uint16(x86_xSetOp), uint16(x86_MOVSS), + /*1490*/ uint16(x86_xReadSlashR), + /*1491*/ uint16(x86_xArgXmm2M32), + /*1492*/ uint16(x86_xArgXmm), + /*1493*/ uint16(x86_xMatch), + /*1494*/ uint16(x86_xCondPrefix), 4, + 0xF3, 1531, + 0xF2, 1525, + 0x66, 1519, + 0x0, 1504, + /*1504*/ uint16(x86_xCondIsMem), 1507, 1513, + /*1507*/ uint16(x86_xSetOp), uint16(x86_MOVHLPS), + /*1509*/ uint16(x86_xReadSlashR), + /*1510*/ uint16(x86_xArgXmm1), + /*1511*/ uint16(x86_xArgXmm2), + /*1512*/ uint16(x86_xMatch), + /*1513*/ uint16(x86_xSetOp), uint16(x86_MOVLPS), + /*1515*/ uint16(x86_xReadSlashR), + /*1516*/ uint16(x86_xArgXmm), + /*1517*/ uint16(x86_xArgM64), + /*1518*/ uint16(x86_xMatch), + /*1519*/ uint16(x86_xSetOp), uint16(x86_MOVLPD), + /*1521*/ uint16(x86_xReadSlashR), + /*1522*/ uint16(x86_xArgXmm), + /*1523*/ uint16(x86_xArgXmm2M64), + /*1524*/ uint16(x86_xMatch), + /*1525*/ uint16(x86_xSetOp), uint16(x86_MOVDDUP), + /*1527*/ uint16(x86_xReadSlashR), + /*1528*/ uint16(x86_xArgXmm1), + /*1529*/ uint16(x86_xArgXmm2M64), + /*1530*/ uint16(x86_xMatch), + /*1531*/ uint16(x86_xSetOp), uint16(x86_MOVSLDUP), + /*1533*/ uint16(x86_xReadSlashR), + /*1534*/ uint16(x86_xArgXmm1), + /*1535*/ uint16(x86_xArgXmm2M128), + /*1536*/ uint16(x86_xMatch), + /*1537*/ uint16(x86_xCondPrefix), 2, + 0x66, 1549, + 0x0, 1543, + /*1543*/ uint16(x86_xSetOp), uint16(x86_MOVLPS), + /*1545*/ uint16(x86_xReadSlashR), + /*1546*/ uint16(x86_xArgM64), + /*1547*/ uint16(x86_xArgXmm), + /*1548*/ uint16(x86_xMatch), + /*1549*/ uint16(x86_xSetOp), uint16(x86_MOVLPD), + /*1551*/ uint16(x86_xReadSlashR), + /*1552*/ uint16(x86_xArgXmm2M64), + /*1553*/ uint16(x86_xArgXmm), + /*1554*/ uint16(x86_xMatch), + /*1555*/ uint16(x86_xCondPrefix), 2, + 0x66, 1567, + 0x0, 1561, + /*1561*/ uint16(x86_xSetOp), uint16(x86_UNPCKLPS), + /*1563*/ uint16(x86_xReadSlashR), + /*1564*/ uint16(x86_xArgXmm1), + /*1565*/ uint16(x86_xArgXmm2M128), + /*1566*/ uint16(x86_xMatch), + /*1567*/ uint16(x86_xSetOp), uint16(x86_UNPCKLPD), + /*1569*/ uint16(x86_xReadSlashR), + /*1570*/ uint16(x86_xArgXmm1), + /*1571*/ uint16(x86_xArgXmm2M128), + /*1572*/ uint16(x86_xMatch), + /*1573*/ uint16(x86_xCondPrefix), 2, + 0x66, 1585, + 0x0, 1579, + /*1579*/ uint16(x86_xSetOp), uint16(x86_UNPCKHPS), + /*1581*/ uint16(x86_xReadSlashR), + /*1582*/ uint16(x86_xArgXmm1), + /*1583*/ uint16(x86_xArgXmm2M128), + /*1584*/ uint16(x86_xMatch), + /*1585*/ uint16(x86_xSetOp), uint16(x86_UNPCKHPD), + /*1587*/ uint16(x86_xReadSlashR), + /*1588*/ uint16(x86_xArgXmm1), + /*1589*/ uint16(x86_xArgXmm2M128), + /*1590*/ uint16(x86_xMatch), + /*1591*/ uint16(x86_xCondPrefix), 3, + 0xF3, 1620, + 0x66, 1614, + 0x0, 1599, + /*1599*/ uint16(x86_xCondIsMem), 1602, 1608, + /*1602*/ uint16(x86_xSetOp), uint16(x86_MOVLHPS), + /*1604*/ uint16(x86_xReadSlashR), + /*1605*/ uint16(x86_xArgXmm1), + /*1606*/ uint16(x86_xArgXmm2), + /*1607*/ uint16(x86_xMatch), + /*1608*/ uint16(x86_xSetOp), uint16(x86_MOVHPS), + /*1610*/ uint16(x86_xReadSlashR), + /*1611*/ uint16(x86_xArgXmm), + /*1612*/ uint16(x86_xArgM64), + /*1613*/ uint16(x86_xMatch), + /*1614*/ uint16(x86_xSetOp), uint16(x86_MOVHPD), + /*1616*/ uint16(x86_xReadSlashR), + /*1617*/ uint16(x86_xArgXmm), + /*1618*/ uint16(x86_xArgXmm2M64), + /*1619*/ uint16(x86_xMatch), + /*1620*/ uint16(x86_xSetOp), uint16(x86_MOVSHDUP), + /*1622*/ uint16(x86_xReadSlashR), + /*1623*/ uint16(x86_xArgXmm1), + /*1624*/ uint16(x86_xArgXmm2M128), + /*1625*/ uint16(x86_xMatch), + /*1626*/ uint16(x86_xCondPrefix), 2, + 0x66, 1638, + 0x0, 1632, + /*1632*/ uint16(x86_xSetOp), uint16(x86_MOVHPS), + /*1634*/ uint16(x86_xReadSlashR), + /*1635*/ uint16(x86_xArgM64), + /*1636*/ uint16(x86_xArgXmm), + /*1637*/ uint16(x86_xMatch), + /*1638*/ uint16(x86_xSetOp), uint16(x86_MOVHPD), + /*1640*/ uint16(x86_xReadSlashR), + /*1641*/ uint16(x86_xArgXmm2M64), + /*1642*/ uint16(x86_xArgXmm), + /*1643*/ uint16(x86_xMatch), + /*1644*/ uint16(x86_xCondSlashR), + 1653, // 0 + 1657, // 1 + 1661, // 2 + 1665, // 3 + 0, // 4 + 0, // 5 + 0, // 6 + 0, // 7 + /*1653*/ uint16(x86_xSetOp), uint16(x86_PREFETCHNTA), + /*1655*/ uint16(x86_xArgM8), + /*1656*/ uint16(x86_xMatch), + /*1657*/ uint16(x86_xSetOp), uint16(x86_PREFETCHT0), + /*1659*/ uint16(x86_xArgM8), + /*1660*/ uint16(x86_xMatch), + /*1661*/ uint16(x86_xSetOp), uint16(x86_PREFETCHT1), + /*1663*/ uint16(x86_xArgM8), + /*1664*/ uint16(x86_xMatch), + /*1665*/ uint16(x86_xSetOp), uint16(x86_PREFETCHT2), + /*1667*/ uint16(x86_xArgM8), + /*1668*/ uint16(x86_xMatch), + /*1669*/ uint16(x86_xCondSlashR), + 1678, // 0 + 0, // 1 + 0, // 2 + 0, // 3 + 0, // 4 + 0, // 5 + 0, // 6 + 0, // 7 + /*1678*/ uint16(x86_xCondDataSize), 1682, 1686, 0, + /*1682*/ uint16(x86_xSetOp), uint16(x86_NOP), + /*1684*/ uint16(x86_xArgRM16), + /*1685*/ uint16(x86_xMatch), + /*1686*/ uint16(x86_xSetOp), uint16(x86_NOP), + /*1688*/ uint16(x86_xArgRM32), + /*1689*/ uint16(x86_xMatch), + /*1690*/ uint16(x86_xCondIs64), 1693, 1699, + /*1693*/ uint16(x86_xSetOp), uint16(x86_MOV), + /*1695*/ uint16(x86_xReadSlashR), + /*1696*/ uint16(x86_xArgRmf32), + /*1697*/ uint16(x86_xArgCR0dashCR7), + /*1698*/ uint16(x86_xMatch), + /*1699*/ uint16(x86_xSetOp), uint16(x86_MOV), + /*1701*/ uint16(x86_xReadSlashR), + /*1702*/ uint16(x86_xArgRmf64), + /*1703*/ uint16(x86_xArgCR0dashCR7), + /*1704*/ uint16(x86_xMatch), + /*1705*/ uint16(x86_xCondIs64), 1708, 1714, + /*1708*/ uint16(x86_xSetOp), uint16(x86_MOV), + /*1710*/ uint16(x86_xReadSlashR), + /*1711*/ uint16(x86_xArgRmf32), + /*1712*/ uint16(x86_xArgDR0dashDR7), + /*1713*/ uint16(x86_xMatch), + /*1714*/ uint16(x86_xSetOp), uint16(x86_MOV), + /*1716*/ uint16(x86_xReadSlashR), + /*1717*/ uint16(x86_xArgRmf64), + /*1718*/ uint16(x86_xArgDR0dashDR7), + /*1719*/ uint16(x86_xMatch), + /*1720*/ uint16(x86_xCondIs64), 1723, 1729, + /*1723*/ uint16(x86_xSetOp), uint16(x86_MOV), + /*1725*/ uint16(x86_xReadSlashR), + /*1726*/ uint16(x86_xArgCR0dashCR7), + /*1727*/ uint16(x86_xArgRmf32), + /*1728*/ uint16(x86_xMatch), + /*1729*/ uint16(x86_xSetOp), uint16(x86_MOV), + /*1731*/ uint16(x86_xReadSlashR), + /*1732*/ uint16(x86_xArgCR0dashCR7), + /*1733*/ uint16(x86_xArgRmf64), + /*1734*/ uint16(x86_xMatch), + /*1735*/ uint16(x86_xCondIs64), 1738, 1744, + /*1738*/ uint16(x86_xSetOp), uint16(x86_MOV), + /*1740*/ uint16(x86_xReadSlashR), + /*1741*/ uint16(x86_xArgDR0dashDR7), + /*1742*/ uint16(x86_xArgRmf32), + /*1743*/ uint16(x86_xMatch), + /*1744*/ uint16(x86_xSetOp), uint16(x86_MOV), + /*1746*/ uint16(x86_xReadSlashR), + /*1747*/ uint16(x86_xArgDR0dashDR7), + /*1748*/ uint16(x86_xArgRmf64), + /*1749*/ uint16(x86_xMatch), + /*1750*/ uint16(x86_xCondIs64), 1753, 1759, + /*1753*/ uint16(x86_xSetOp), uint16(x86_MOV), + /*1755*/ uint16(x86_xReadSlashR), + /*1756*/ uint16(x86_xArgRmf32), + /*1757*/ uint16(x86_xArgTR0dashTR7), + /*1758*/ uint16(x86_xMatch), + /*1759*/ uint16(x86_xSetOp), uint16(x86_MOV), + /*1761*/ uint16(x86_xReadSlashR), + /*1762*/ uint16(x86_xArgRmf64), + /*1763*/ uint16(x86_xArgTR0dashTR7), + /*1764*/ uint16(x86_xMatch), + /*1765*/ uint16(x86_xCondIs64), 1768, 1774, + /*1768*/ uint16(x86_xSetOp), uint16(x86_MOV), + /*1770*/ uint16(x86_xReadSlashR), + /*1771*/ uint16(x86_xArgTR0dashTR7), + /*1772*/ uint16(x86_xArgRmf32), + /*1773*/ uint16(x86_xMatch), + /*1774*/ uint16(x86_xSetOp), uint16(x86_MOV), + /*1776*/ uint16(x86_xReadSlashR), + /*1777*/ uint16(x86_xArgTR0dashTR7), + /*1778*/ uint16(x86_xArgRmf64), + /*1779*/ uint16(x86_xMatch), + /*1780*/ uint16(x86_xCondPrefix), 2, + 0x66, 1792, + 0x0, 1786, + /*1786*/ uint16(x86_xSetOp), uint16(x86_MOVAPS), + /*1788*/ uint16(x86_xReadSlashR), + /*1789*/ uint16(x86_xArgXmm1), + /*1790*/ uint16(x86_xArgXmm2M128), + /*1791*/ uint16(x86_xMatch), + /*1792*/ uint16(x86_xSetOp), uint16(x86_MOVAPD), + /*1794*/ uint16(x86_xReadSlashR), + /*1795*/ uint16(x86_xArgXmm1), + /*1796*/ uint16(x86_xArgXmm2M128), + /*1797*/ uint16(x86_xMatch), + /*1798*/ uint16(x86_xCondPrefix), 2, + 0x66, 1810, + 0x0, 1804, + /*1804*/ uint16(x86_xSetOp), uint16(x86_MOVAPS), + /*1806*/ uint16(x86_xReadSlashR), + /*1807*/ uint16(x86_xArgXmm2M128), + /*1808*/ uint16(x86_xArgXmm1), + /*1809*/ uint16(x86_xMatch), + /*1810*/ uint16(x86_xSetOp), uint16(x86_MOVAPD), + /*1812*/ uint16(x86_xReadSlashR), + /*1813*/ uint16(x86_xArgXmm2M128), + /*1814*/ uint16(x86_xArgXmm1), + /*1815*/ uint16(x86_xMatch), + /*1816*/ uint16(x86_xCondIs64), 1819, 1873, + /*1819*/ uint16(x86_xCondPrefix), 4, + 0xF3, 1857, + 0xF2, 1841, + 0x66, 1835, + 0x0, 1829, + /*1829*/ uint16(x86_xSetOp), uint16(x86_CVTPI2PS), + /*1831*/ uint16(x86_xReadSlashR), + /*1832*/ uint16(x86_xArgXmm), + /*1833*/ uint16(x86_xArgMmM64), + /*1834*/ uint16(x86_xMatch), + /*1835*/ uint16(x86_xSetOp), uint16(x86_CVTPI2PD), + /*1837*/ uint16(x86_xReadSlashR), + /*1838*/ uint16(x86_xArgXmm), + /*1839*/ uint16(x86_xArgMmM64), + /*1840*/ uint16(x86_xMatch), + /*1841*/ uint16(x86_xCondDataSize), 1845, 1851, 0, + /*1845*/ uint16(x86_xSetOp), uint16(x86_CVTSI2SD), + /*1847*/ uint16(x86_xReadSlashR), + /*1848*/ uint16(x86_xArgXmm), + /*1849*/ uint16(x86_xArgRM32), + /*1850*/ uint16(x86_xMatch), + /*1851*/ uint16(x86_xSetOp), uint16(x86_CVTSI2SD), + /*1853*/ uint16(x86_xReadSlashR), + /*1854*/ uint16(x86_xArgXmm), + /*1855*/ uint16(x86_xArgRM32), + /*1856*/ uint16(x86_xMatch), + /*1857*/ uint16(x86_xCondDataSize), 1861, 1867, 0, + /*1861*/ uint16(x86_xSetOp), uint16(x86_CVTSI2SS), + /*1863*/ uint16(x86_xReadSlashR), + /*1864*/ uint16(x86_xArgXmm), + /*1865*/ uint16(x86_xArgRM32), + /*1866*/ uint16(x86_xMatch), + /*1867*/ uint16(x86_xSetOp), uint16(x86_CVTSI2SS), + /*1869*/ uint16(x86_xReadSlashR), + /*1870*/ uint16(x86_xArgXmm), + /*1871*/ uint16(x86_xArgRM32), + /*1872*/ uint16(x86_xMatch), + /*1873*/ uint16(x86_xCondPrefix), 4, + 0xF3, 1893, + 0xF2, 1883, + 0x66, 1835, + 0x0, 1829, + /*1883*/ uint16(x86_xCondDataSize), 1845, 1851, 1887, + /*1887*/ uint16(x86_xSetOp), uint16(x86_CVTSI2SD), + /*1889*/ uint16(x86_xReadSlashR), + /*1890*/ uint16(x86_xArgXmm), + /*1891*/ uint16(x86_xArgRM64), + /*1892*/ uint16(x86_xMatch), + /*1893*/ uint16(x86_xCondDataSize), 1861, 1867, 1897, + /*1897*/ uint16(x86_xSetOp), uint16(x86_CVTSI2SS), + /*1899*/ uint16(x86_xReadSlashR), + /*1900*/ uint16(x86_xArgXmm), + /*1901*/ uint16(x86_xArgRM64), + /*1902*/ uint16(x86_xMatch), + /*1903*/ uint16(x86_xCondPrefix), 4, + 0xF3, 1931, + 0xF2, 1925, + 0x66, 1919, + 0x0, 1913, + /*1913*/ uint16(x86_xSetOp), uint16(x86_MOVNTPS), + /*1915*/ uint16(x86_xReadSlashR), + /*1916*/ uint16(x86_xArgM128), + /*1917*/ uint16(x86_xArgXmm), + /*1918*/ uint16(x86_xMatch), + /*1919*/ uint16(x86_xSetOp), uint16(x86_MOVNTPD), + /*1921*/ uint16(x86_xReadSlashR), + /*1922*/ uint16(x86_xArgM128), + /*1923*/ uint16(x86_xArgXmm), + /*1924*/ uint16(x86_xMatch), + /*1925*/ uint16(x86_xSetOp), uint16(x86_MOVNTSD), + /*1927*/ uint16(x86_xReadSlashR), + /*1928*/ uint16(x86_xArgM64), + /*1929*/ uint16(x86_xArgXmm), + /*1930*/ uint16(x86_xMatch), + /*1931*/ uint16(x86_xSetOp), uint16(x86_MOVNTSS), + /*1933*/ uint16(x86_xReadSlashR), + /*1934*/ uint16(x86_xArgM32), + /*1935*/ uint16(x86_xArgXmm), + /*1936*/ uint16(x86_xMatch), + /*1937*/ uint16(x86_xCondIs64), 1940, 1994, + /*1940*/ uint16(x86_xCondPrefix), 4, + 0xF3, 1978, + 0xF2, 1962, + 0x66, 1956, + 0x0, 1950, + /*1950*/ uint16(x86_xSetOp), uint16(x86_CVTTPS2PI), + /*1952*/ uint16(x86_xReadSlashR), + /*1953*/ uint16(x86_xArgMm), + /*1954*/ uint16(x86_xArgXmmM64), + /*1955*/ uint16(x86_xMatch), + /*1956*/ uint16(x86_xSetOp), uint16(x86_CVTTPD2PI), + /*1958*/ uint16(x86_xReadSlashR), + /*1959*/ uint16(x86_xArgMm), + /*1960*/ uint16(x86_xArgXmmM128), + /*1961*/ uint16(x86_xMatch), + /*1962*/ uint16(x86_xCondDataSize), 1966, 1972, 0, + /*1966*/ uint16(x86_xSetOp), uint16(x86_CVTTSD2SI), + /*1968*/ uint16(x86_xReadSlashR), + /*1969*/ uint16(x86_xArgR32), + /*1970*/ uint16(x86_xArgXmmM64), + /*1971*/ uint16(x86_xMatch), + /*1972*/ uint16(x86_xSetOp), uint16(x86_CVTTSD2SI), + /*1974*/ uint16(x86_xReadSlashR), + /*1975*/ uint16(x86_xArgR32), + /*1976*/ uint16(x86_xArgXmmM64), + /*1977*/ uint16(x86_xMatch), + /*1978*/ uint16(x86_xCondDataSize), 1982, 1988, 0, + /*1982*/ uint16(x86_xSetOp), uint16(x86_CVTTSS2SI), + /*1984*/ uint16(x86_xReadSlashR), + /*1985*/ uint16(x86_xArgR32), + /*1986*/ uint16(x86_xArgXmmM32), + /*1987*/ uint16(x86_xMatch), + /*1988*/ uint16(x86_xSetOp), uint16(x86_CVTTSS2SI), + /*1990*/ uint16(x86_xReadSlashR), + /*1991*/ uint16(x86_xArgR32), + /*1992*/ uint16(x86_xArgXmmM32), + /*1993*/ uint16(x86_xMatch), + /*1994*/ uint16(x86_xCondPrefix), 4, + 0xF3, 2014, + 0xF2, 2004, + 0x66, 1956, + 0x0, 1950, + /*2004*/ uint16(x86_xCondDataSize), 1966, 1972, 2008, + /*2008*/ uint16(x86_xSetOp), uint16(x86_CVTTSD2SI), + /*2010*/ uint16(x86_xReadSlashR), + /*2011*/ uint16(x86_xArgR64), + /*2012*/ uint16(x86_xArgXmmM64), + /*2013*/ uint16(x86_xMatch), + /*2014*/ uint16(x86_xCondDataSize), 1982, 1988, 2018, + /*2018*/ uint16(x86_xSetOp), uint16(x86_CVTTSS2SI), + /*2020*/ uint16(x86_xReadSlashR), + /*2021*/ uint16(x86_xArgR64), + /*2022*/ uint16(x86_xArgXmmM32), + /*2023*/ uint16(x86_xMatch), + /*2024*/ uint16(x86_xCondIs64), 2027, 2081, + /*2027*/ uint16(x86_xCondPrefix), 4, + 0xF3, 2065, + 0xF2, 2049, + 0x66, 2043, + 0x0, 2037, + /*2037*/ uint16(x86_xSetOp), uint16(x86_CVTPS2PI), + /*2039*/ uint16(x86_xReadSlashR), + /*2040*/ uint16(x86_xArgMm), + /*2041*/ uint16(x86_xArgXmmM64), + /*2042*/ uint16(x86_xMatch), + /*2043*/ uint16(x86_xSetOp), uint16(x86_CVTPD2PI), + /*2045*/ uint16(x86_xReadSlashR), + /*2046*/ uint16(x86_xArgMm), + /*2047*/ uint16(x86_xArgXmmM128), + /*2048*/ uint16(x86_xMatch), + /*2049*/ uint16(x86_xCondDataSize), 2053, 2059, 0, + /*2053*/ uint16(x86_xSetOp), uint16(x86_CVTSD2SI), + /*2055*/ uint16(x86_xReadSlashR), + /*2056*/ uint16(x86_xArgR32), + /*2057*/ uint16(x86_xArgXmmM64), + /*2058*/ uint16(x86_xMatch), + /*2059*/ uint16(x86_xSetOp), uint16(x86_CVTSD2SI), + /*2061*/ uint16(x86_xReadSlashR), + /*2062*/ uint16(x86_xArgR32), + /*2063*/ uint16(x86_xArgXmmM64), + /*2064*/ uint16(x86_xMatch), + /*2065*/ uint16(x86_xCondDataSize), 2069, 2075, 0, + /*2069*/ uint16(x86_xSetOp), uint16(x86_CVTSS2SI), + /*2071*/ uint16(x86_xReadSlashR), + /*2072*/ uint16(x86_xArgR32), + /*2073*/ uint16(x86_xArgXmmM32), + /*2074*/ uint16(x86_xMatch), + /*2075*/ uint16(x86_xSetOp), uint16(x86_CVTSS2SI), + /*2077*/ uint16(x86_xReadSlashR), + /*2078*/ uint16(x86_xArgR32), + /*2079*/ uint16(x86_xArgXmmM32), + /*2080*/ uint16(x86_xMatch), + /*2081*/ uint16(x86_xCondPrefix), 4, + 0xF3, 2101, + 0xF2, 2091, + 0x66, 2043, + 0x0, 2037, + /*2091*/ uint16(x86_xCondDataSize), 2053, 2059, 2095, + /*2095*/ uint16(x86_xSetOp), uint16(x86_CVTSD2SI), + /*2097*/ uint16(x86_xReadSlashR), + /*2098*/ uint16(x86_xArgR64), + /*2099*/ uint16(x86_xArgXmmM64), + /*2100*/ uint16(x86_xMatch), + /*2101*/ uint16(x86_xCondDataSize), 2069, 2075, 2105, + /*2105*/ uint16(x86_xSetOp), uint16(x86_CVTSS2SI), + /*2107*/ uint16(x86_xReadSlashR), + /*2108*/ uint16(x86_xArgR64), + /*2109*/ uint16(x86_xArgXmmM32), + /*2110*/ uint16(x86_xMatch), + /*2111*/ uint16(x86_xCondPrefix), 2, + 0x66, 2123, + 0x0, 2117, + /*2117*/ uint16(x86_xSetOp), uint16(x86_UCOMISS), + /*2119*/ uint16(x86_xReadSlashR), + /*2120*/ uint16(x86_xArgXmm1), + /*2121*/ uint16(x86_xArgXmm2M32), + /*2122*/ uint16(x86_xMatch), + /*2123*/ uint16(x86_xSetOp), uint16(x86_UCOMISD), + /*2125*/ uint16(x86_xReadSlashR), + /*2126*/ uint16(x86_xArgXmm1), + /*2127*/ uint16(x86_xArgXmm2M64), + /*2128*/ uint16(x86_xMatch), + /*2129*/ uint16(x86_xCondPrefix), 2, + 0x66, 2141, + 0x0, 2135, + /*2135*/ uint16(x86_xSetOp), uint16(x86_COMISS), + /*2137*/ uint16(x86_xReadSlashR), + /*2138*/ uint16(x86_xArgXmm1), + /*2139*/ uint16(x86_xArgXmm2M32), + /*2140*/ uint16(x86_xMatch), + /*2141*/ uint16(x86_xSetOp), uint16(x86_COMISD), + /*2143*/ uint16(x86_xReadSlashR), + /*2144*/ uint16(x86_xArgXmm1), + /*2145*/ uint16(x86_xArgXmm2M64), + /*2146*/ uint16(x86_xMatch), + /*2147*/ uint16(x86_xSetOp), uint16(x86_WRMSR), + /*2149*/ uint16(x86_xMatch), + /*2150*/ uint16(x86_xSetOp), uint16(x86_RDTSC), + /*2152*/ uint16(x86_xMatch), + /*2153*/ uint16(x86_xSetOp), uint16(x86_RDMSR), + /*2155*/ uint16(x86_xMatch), + /*2156*/ uint16(x86_xSetOp), uint16(x86_RDPMC), + /*2158*/ uint16(x86_xMatch), + /*2159*/ uint16(x86_xSetOp), uint16(x86_SYSENTER), + /*2161*/ uint16(x86_xMatch), + /*2162*/ uint16(x86_xCondDataSize), 2166, 2166, 2169, + /*2166*/ uint16(x86_xSetOp), uint16(x86_SYSEXIT), + /*2168*/ uint16(x86_xMatch), + /*2169*/ uint16(x86_xSetOp), uint16(x86_SYSEXIT), + /*2171*/ uint16(x86_xMatch), + /*2172*/ uint16(x86_xCondByte), 54, + 0x00, 2283, + 0x01, 2301, + 0x02, 2319, + 0x03, 2337, + 0x04, 2355, + 0x05, 2373, + 0x06, 2391, + 0x07, 2409, + 0x08, 2427, + 0x09, 2445, + 0x0A, 2463, + 0x0B, 2481, + 0x10, 2499, + 0x14, 2510, + 0x15, 2521, + 0x17, 2532, + 0x1C, 2542, + 0x1D, 2560, + 0x1E, 2578, + 0x20, 2596, + 0x21, 2606, + 0x22, 2616, + 0x23, 2626, + 0x24, 2636, + 0x25, 2646, + 0x28, 2656, + 0x29, 2666, + 0x2A, 2676, + 0x2B, 2686, + 0x30, 2696, + 0x31, 2706, + 0x32, 2716, + 0x33, 2726, + 0x34, 2736, + 0x35, 2746, + 0x37, 2756, + 0x38, 2766, + 0x39, 2776, + 0x3A, 2786, + 0x3B, 2796, + 0x3C, 2806, + 0x3D, 2816, + 0x3E, 2826, + 0x3F, 2836, + 0x40, 2846, + 0x41, 2856, + 0x82, 2866, + 0xDB, 2889, + 0xDC, 2899, + 0xDD, 2909, + 0xDE, 2919, + 0xDF, 2929, + 0xF0, 2939, + 0xF1, 3006, + uint16(x86_xFail), + /*2283*/ uint16(x86_xCondPrefix), 2, + 0x66, 2295, + 0x0, 2289, + /*2289*/ uint16(x86_xSetOp), uint16(x86_PSHUFB), + /*2291*/ uint16(x86_xReadSlashR), + /*2292*/ uint16(x86_xArgMm1), + /*2293*/ uint16(x86_xArgMm2M64), + /*2294*/ uint16(x86_xMatch), + /*2295*/ uint16(x86_xSetOp), uint16(x86_PSHUFB), + /*2297*/ uint16(x86_xReadSlashR), + /*2298*/ uint16(x86_xArgXmm1), + /*2299*/ uint16(x86_xArgXmm2M128), + /*2300*/ uint16(x86_xMatch), + /*2301*/ uint16(x86_xCondPrefix), 2, + 0x66, 2313, + 0x0, 2307, + /*2307*/ uint16(x86_xSetOp), uint16(x86_PHADDW), + /*2309*/ uint16(x86_xReadSlashR), + /*2310*/ uint16(x86_xArgMm1), + /*2311*/ uint16(x86_xArgMm2M64), + /*2312*/ uint16(x86_xMatch), + /*2313*/ uint16(x86_xSetOp), uint16(x86_PHADDW), + /*2315*/ uint16(x86_xReadSlashR), + /*2316*/ uint16(x86_xArgXmm1), + /*2317*/ uint16(x86_xArgXmm2M128), + /*2318*/ uint16(x86_xMatch), + /*2319*/ uint16(x86_xCondPrefix), 2, + 0x66, 2331, + 0x0, 2325, + /*2325*/ uint16(x86_xSetOp), uint16(x86_PHADDD), + /*2327*/ uint16(x86_xReadSlashR), + /*2328*/ uint16(x86_xArgMm1), + /*2329*/ uint16(x86_xArgMm2M64), + /*2330*/ uint16(x86_xMatch), + /*2331*/ uint16(x86_xSetOp), uint16(x86_PHADDD), + /*2333*/ uint16(x86_xReadSlashR), + /*2334*/ uint16(x86_xArgXmm1), + /*2335*/ uint16(x86_xArgXmm2M128), + /*2336*/ uint16(x86_xMatch), + /*2337*/ uint16(x86_xCondPrefix), 2, + 0x66, 2349, + 0x0, 2343, + /*2343*/ uint16(x86_xSetOp), uint16(x86_PHADDSW), + /*2345*/ uint16(x86_xReadSlashR), + /*2346*/ uint16(x86_xArgMm1), + /*2347*/ uint16(x86_xArgMm2M64), + /*2348*/ uint16(x86_xMatch), + /*2349*/ uint16(x86_xSetOp), uint16(x86_PHADDSW), + /*2351*/ uint16(x86_xReadSlashR), + /*2352*/ uint16(x86_xArgXmm1), + /*2353*/ uint16(x86_xArgXmm2M128), + /*2354*/ uint16(x86_xMatch), + /*2355*/ uint16(x86_xCondPrefix), 2, + 0x66, 2367, + 0x0, 2361, + /*2361*/ uint16(x86_xSetOp), uint16(x86_PMADDUBSW), + /*2363*/ uint16(x86_xReadSlashR), + /*2364*/ uint16(x86_xArgMm1), + /*2365*/ uint16(x86_xArgMm2M64), + /*2366*/ uint16(x86_xMatch), + /*2367*/ uint16(x86_xSetOp), uint16(x86_PMADDUBSW), + /*2369*/ uint16(x86_xReadSlashR), + /*2370*/ uint16(x86_xArgXmm1), + /*2371*/ uint16(x86_xArgXmm2M128), + /*2372*/ uint16(x86_xMatch), + /*2373*/ uint16(x86_xCondPrefix), 2, + 0x66, 2385, + 0x0, 2379, + /*2379*/ uint16(x86_xSetOp), uint16(x86_PHSUBW), + /*2381*/ uint16(x86_xReadSlashR), + /*2382*/ uint16(x86_xArgMm1), + /*2383*/ uint16(x86_xArgMm2M64), + /*2384*/ uint16(x86_xMatch), + /*2385*/ uint16(x86_xSetOp), uint16(x86_PHSUBW), + /*2387*/ uint16(x86_xReadSlashR), + /*2388*/ uint16(x86_xArgXmm1), + /*2389*/ uint16(x86_xArgXmm2M128), + /*2390*/ uint16(x86_xMatch), + /*2391*/ uint16(x86_xCondPrefix), 2, + 0x66, 2403, + 0x0, 2397, + /*2397*/ uint16(x86_xSetOp), uint16(x86_PHSUBD), + /*2399*/ uint16(x86_xReadSlashR), + /*2400*/ uint16(x86_xArgMm1), + /*2401*/ uint16(x86_xArgMm2M64), + /*2402*/ uint16(x86_xMatch), + /*2403*/ uint16(x86_xSetOp), uint16(x86_PHSUBD), + /*2405*/ uint16(x86_xReadSlashR), + /*2406*/ uint16(x86_xArgXmm1), + /*2407*/ uint16(x86_xArgXmm2M128), + /*2408*/ uint16(x86_xMatch), + /*2409*/ uint16(x86_xCondPrefix), 2, + 0x66, 2421, + 0x0, 2415, + /*2415*/ uint16(x86_xSetOp), uint16(x86_PHSUBSW), + /*2417*/ uint16(x86_xReadSlashR), + /*2418*/ uint16(x86_xArgMm1), + /*2419*/ uint16(x86_xArgMm2M64), + /*2420*/ uint16(x86_xMatch), + /*2421*/ uint16(x86_xSetOp), uint16(x86_PHSUBSW), + /*2423*/ uint16(x86_xReadSlashR), + /*2424*/ uint16(x86_xArgXmm1), + /*2425*/ uint16(x86_xArgXmm2M128), + /*2426*/ uint16(x86_xMatch), + /*2427*/ uint16(x86_xCondPrefix), 2, + 0x66, 2439, + 0x0, 2433, + /*2433*/ uint16(x86_xSetOp), uint16(x86_PSIGNB), + /*2435*/ uint16(x86_xReadSlashR), + /*2436*/ uint16(x86_xArgMm1), + /*2437*/ uint16(x86_xArgMm2M64), + /*2438*/ uint16(x86_xMatch), + /*2439*/ uint16(x86_xSetOp), uint16(x86_PSIGNB), + /*2441*/ uint16(x86_xReadSlashR), + /*2442*/ uint16(x86_xArgXmm1), + /*2443*/ uint16(x86_xArgXmm2M128), + /*2444*/ uint16(x86_xMatch), + /*2445*/ uint16(x86_xCondPrefix), 2, + 0x66, 2457, + 0x0, 2451, + /*2451*/ uint16(x86_xSetOp), uint16(x86_PSIGNW), + /*2453*/ uint16(x86_xReadSlashR), + /*2454*/ uint16(x86_xArgMm1), + /*2455*/ uint16(x86_xArgMm2M64), + /*2456*/ uint16(x86_xMatch), + /*2457*/ uint16(x86_xSetOp), uint16(x86_PSIGNW), + /*2459*/ uint16(x86_xReadSlashR), + /*2460*/ uint16(x86_xArgXmm1), + /*2461*/ uint16(x86_xArgXmm2M128), + /*2462*/ uint16(x86_xMatch), + /*2463*/ uint16(x86_xCondPrefix), 2, + 0x66, 2475, + 0x0, 2469, + /*2469*/ uint16(x86_xSetOp), uint16(x86_PSIGND), + /*2471*/ uint16(x86_xReadSlashR), + /*2472*/ uint16(x86_xArgMm1), + /*2473*/ uint16(x86_xArgMm2M64), + /*2474*/ uint16(x86_xMatch), + /*2475*/ uint16(x86_xSetOp), uint16(x86_PSIGND), + /*2477*/ uint16(x86_xReadSlashR), + /*2478*/ uint16(x86_xArgXmm1), + /*2479*/ uint16(x86_xArgXmm2M128), + /*2480*/ uint16(x86_xMatch), + /*2481*/ uint16(x86_xCondPrefix), 2, + 0x66, 2493, + 0x0, 2487, + /*2487*/ uint16(x86_xSetOp), uint16(x86_PMULHRSW), + /*2489*/ uint16(x86_xReadSlashR), + /*2490*/ uint16(x86_xArgMm1), + /*2491*/ uint16(x86_xArgMm2M64), + /*2492*/ uint16(x86_xMatch), + /*2493*/ uint16(x86_xSetOp), uint16(x86_PMULHRSW), + /*2495*/ uint16(x86_xReadSlashR), + /*2496*/ uint16(x86_xArgXmm1), + /*2497*/ uint16(x86_xArgXmm2M128), + /*2498*/ uint16(x86_xMatch), + /*2499*/ uint16(x86_xCondPrefix), 1, + 0x66, 2503, + /*2503*/ uint16(x86_xSetOp), uint16(x86_PBLENDVB), + /*2505*/ uint16(x86_xReadSlashR), + /*2506*/ uint16(x86_xArgXmm1), + /*2507*/ uint16(x86_xArgXmm2M128), + /*2508*/ uint16(x86_xArgXMM0), + /*2509*/ uint16(x86_xMatch), + /*2510*/ uint16(x86_xCondPrefix), 1, + 0x66, 2514, + /*2514*/ uint16(x86_xSetOp), uint16(x86_BLENDVPS), + /*2516*/ uint16(x86_xReadSlashR), + /*2517*/ uint16(x86_xArgXmm1), + /*2518*/ uint16(x86_xArgXmm2M128), + /*2519*/ uint16(x86_xArgXMM0), + /*2520*/ uint16(x86_xMatch), + /*2521*/ uint16(x86_xCondPrefix), 1, + 0x66, 2525, + /*2525*/ uint16(x86_xSetOp), uint16(x86_BLENDVPD), + /*2527*/ uint16(x86_xReadSlashR), + /*2528*/ uint16(x86_xArgXmm1), + /*2529*/ uint16(x86_xArgXmm2M128), + /*2530*/ uint16(x86_xArgXMM0), + /*2531*/ uint16(x86_xMatch), + /*2532*/ uint16(x86_xCondPrefix), 1, + 0x66, 2536, + /*2536*/ uint16(x86_xSetOp), uint16(x86_PTEST), + /*2538*/ uint16(x86_xReadSlashR), + /*2539*/ uint16(x86_xArgXmm1), + /*2540*/ uint16(x86_xArgXmm2M128), + /*2541*/ uint16(x86_xMatch), + /*2542*/ uint16(x86_xCondPrefix), 2, + 0x66, 2554, + 0x0, 2548, + /*2548*/ uint16(x86_xSetOp), uint16(x86_PABSB), + /*2550*/ uint16(x86_xReadSlashR), + /*2551*/ uint16(x86_xArgMm1), + /*2552*/ uint16(x86_xArgMm2M64), + /*2553*/ uint16(x86_xMatch), + /*2554*/ uint16(x86_xSetOp), uint16(x86_PABSB), + /*2556*/ uint16(x86_xReadSlashR), + /*2557*/ uint16(x86_xArgXmm1), + /*2558*/ uint16(x86_xArgXmm2M128), + /*2559*/ uint16(x86_xMatch), + /*2560*/ uint16(x86_xCondPrefix), 2, + 0x66, 2572, + 0x0, 2566, + /*2566*/ uint16(x86_xSetOp), uint16(x86_PABSW), + /*2568*/ uint16(x86_xReadSlashR), + /*2569*/ uint16(x86_xArgMm1), + /*2570*/ uint16(x86_xArgMm2M64), + /*2571*/ uint16(x86_xMatch), + /*2572*/ uint16(x86_xSetOp), uint16(x86_PABSW), + /*2574*/ uint16(x86_xReadSlashR), + /*2575*/ uint16(x86_xArgXmm1), + /*2576*/ uint16(x86_xArgXmm2M128), + /*2577*/ uint16(x86_xMatch), + /*2578*/ uint16(x86_xCondPrefix), 2, + 0x66, 2590, + 0x0, 2584, + /*2584*/ uint16(x86_xSetOp), uint16(x86_PABSD), + /*2586*/ uint16(x86_xReadSlashR), + /*2587*/ uint16(x86_xArgMm1), + /*2588*/ uint16(x86_xArgMm2M64), + /*2589*/ uint16(x86_xMatch), + /*2590*/ uint16(x86_xSetOp), uint16(x86_PABSD), + /*2592*/ uint16(x86_xReadSlashR), + /*2593*/ uint16(x86_xArgXmm1), + /*2594*/ uint16(x86_xArgXmm2M128), + /*2595*/ uint16(x86_xMatch), + /*2596*/ uint16(x86_xCondPrefix), 1, + 0x66, 2600, + /*2600*/ uint16(x86_xSetOp), uint16(x86_PMOVSXBW), + /*2602*/ uint16(x86_xReadSlashR), + /*2603*/ uint16(x86_xArgXmm1), + /*2604*/ uint16(x86_xArgXmm2M64), + /*2605*/ uint16(x86_xMatch), + /*2606*/ uint16(x86_xCondPrefix), 1, + 0x66, 2610, + /*2610*/ uint16(x86_xSetOp), uint16(x86_PMOVSXBD), + /*2612*/ uint16(x86_xReadSlashR), + /*2613*/ uint16(x86_xArgXmm1), + /*2614*/ uint16(x86_xArgXmm2M32), + /*2615*/ uint16(x86_xMatch), + /*2616*/ uint16(x86_xCondPrefix), 1, + 0x66, 2620, + /*2620*/ uint16(x86_xSetOp), uint16(x86_PMOVSXBQ), + /*2622*/ uint16(x86_xReadSlashR), + /*2623*/ uint16(x86_xArgXmm1), + /*2624*/ uint16(x86_xArgXmm2M16), + /*2625*/ uint16(x86_xMatch), + /*2626*/ uint16(x86_xCondPrefix), 1, + 0x66, 2630, + /*2630*/ uint16(x86_xSetOp), uint16(x86_PMOVSXWD), + /*2632*/ uint16(x86_xReadSlashR), + /*2633*/ uint16(x86_xArgXmm1), + /*2634*/ uint16(x86_xArgXmm2M64), + /*2635*/ uint16(x86_xMatch), + /*2636*/ uint16(x86_xCondPrefix), 1, + 0x66, 2640, + /*2640*/ uint16(x86_xSetOp), uint16(x86_PMOVSXWQ), + /*2642*/ uint16(x86_xReadSlashR), + /*2643*/ uint16(x86_xArgXmm1), + /*2644*/ uint16(x86_xArgXmm2M32), + /*2645*/ uint16(x86_xMatch), + /*2646*/ uint16(x86_xCondPrefix), 1, + 0x66, 2650, + /*2650*/ uint16(x86_xSetOp), uint16(x86_PMOVSXDQ), + /*2652*/ uint16(x86_xReadSlashR), + /*2653*/ uint16(x86_xArgXmm1), + /*2654*/ uint16(x86_xArgXmm2M64), + /*2655*/ uint16(x86_xMatch), + /*2656*/ uint16(x86_xCondPrefix), 1, + 0x66, 2660, + /*2660*/ uint16(x86_xSetOp), uint16(x86_PMULDQ), + /*2662*/ uint16(x86_xReadSlashR), + /*2663*/ uint16(x86_xArgXmm1), + /*2664*/ uint16(x86_xArgXmm2M128), + /*2665*/ uint16(x86_xMatch), + /*2666*/ uint16(x86_xCondPrefix), 1, + 0x66, 2670, + /*2670*/ uint16(x86_xSetOp), uint16(x86_PCMPEQQ), + /*2672*/ uint16(x86_xReadSlashR), + /*2673*/ uint16(x86_xArgXmm1), + /*2674*/ uint16(x86_xArgXmm2M128), + /*2675*/ uint16(x86_xMatch), + /*2676*/ uint16(x86_xCondPrefix), 1, + 0x66, 2680, + /*2680*/ uint16(x86_xSetOp), uint16(x86_MOVNTDQA), + /*2682*/ uint16(x86_xReadSlashR), + /*2683*/ uint16(x86_xArgXmm1), + /*2684*/ uint16(x86_xArgM128), + /*2685*/ uint16(x86_xMatch), + /*2686*/ uint16(x86_xCondPrefix), 1, + 0x66, 2690, + /*2690*/ uint16(x86_xSetOp), uint16(x86_PACKUSDW), + /*2692*/ uint16(x86_xReadSlashR), + /*2693*/ uint16(x86_xArgXmm1), + /*2694*/ uint16(x86_xArgXmm2M128), + /*2695*/ uint16(x86_xMatch), + /*2696*/ uint16(x86_xCondPrefix), 1, + 0x66, 2700, + /*2700*/ uint16(x86_xSetOp), uint16(x86_PMOVZXBW), + /*2702*/ uint16(x86_xReadSlashR), + /*2703*/ uint16(x86_xArgXmm1), + /*2704*/ uint16(x86_xArgXmm2M64), + /*2705*/ uint16(x86_xMatch), + /*2706*/ uint16(x86_xCondPrefix), 1, + 0x66, 2710, + /*2710*/ uint16(x86_xSetOp), uint16(x86_PMOVZXBD), + /*2712*/ uint16(x86_xReadSlashR), + /*2713*/ uint16(x86_xArgXmm1), + /*2714*/ uint16(x86_xArgXmm2M32), + /*2715*/ uint16(x86_xMatch), + /*2716*/ uint16(x86_xCondPrefix), 1, + 0x66, 2720, + /*2720*/ uint16(x86_xSetOp), uint16(x86_PMOVZXBQ), + /*2722*/ uint16(x86_xReadSlashR), + /*2723*/ uint16(x86_xArgXmm1), + /*2724*/ uint16(x86_xArgXmm2M16), + /*2725*/ uint16(x86_xMatch), + /*2726*/ uint16(x86_xCondPrefix), 1, + 0x66, 2730, + /*2730*/ uint16(x86_xSetOp), uint16(x86_PMOVZXWD), + /*2732*/ uint16(x86_xReadSlashR), + /*2733*/ uint16(x86_xArgXmm1), + /*2734*/ uint16(x86_xArgXmm2M64), + /*2735*/ uint16(x86_xMatch), + /*2736*/ uint16(x86_xCondPrefix), 1, + 0x66, 2740, + /*2740*/ uint16(x86_xSetOp), uint16(x86_PMOVZXWQ), + /*2742*/ uint16(x86_xReadSlashR), + /*2743*/ uint16(x86_xArgXmm1), + /*2744*/ uint16(x86_xArgXmm2M32), + /*2745*/ uint16(x86_xMatch), + /*2746*/ uint16(x86_xCondPrefix), 1, + 0x66, 2750, + /*2750*/ uint16(x86_xSetOp), uint16(x86_PMOVZXDQ), + /*2752*/ uint16(x86_xReadSlashR), + /*2753*/ uint16(x86_xArgXmm1), + /*2754*/ uint16(x86_xArgXmm2M64), + /*2755*/ uint16(x86_xMatch), + /*2756*/ uint16(x86_xCondPrefix), 1, + 0x66, 2760, + /*2760*/ uint16(x86_xSetOp), uint16(x86_PCMPGTQ), + /*2762*/ uint16(x86_xReadSlashR), + /*2763*/ uint16(x86_xArgXmm1), + /*2764*/ uint16(x86_xArgXmm2M128), + /*2765*/ uint16(x86_xMatch), + /*2766*/ uint16(x86_xCondPrefix), 1, + 0x66, 2770, + /*2770*/ uint16(x86_xSetOp), uint16(x86_PMINSB), + /*2772*/ uint16(x86_xReadSlashR), + /*2773*/ uint16(x86_xArgXmm1), + /*2774*/ uint16(x86_xArgXmm2M128), + /*2775*/ uint16(x86_xMatch), + /*2776*/ uint16(x86_xCondPrefix), 1, + 0x66, 2780, + /*2780*/ uint16(x86_xSetOp), uint16(x86_PMINSD), + /*2782*/ uint16(x86_xReadSlashR), + /*2783*/ uint16(x86_xArgXmm1), + /*2784*/ uint16(x86_xArgXmm2M128), + /*2785*/ uint16(x86_xMatch), + /*2786*/ uint16(x86_xCondPrefix), 1, + 0x66, 2790, + /*2790*/ uint16(x86_xSetOp), uint16(x86_PMINUW), + /*2792*/ uint16(x86_xReadSlashR), + /*2793*/ uint16(x86_xArgXmm1), + /*2794*/ uint16(x86_xArgXmm2M128), + /*2795*/ uint16(x86_xMatch), + /*2796*/ uint16(x86_xCondPrefix), 1, + 0x66, 2800, + /*2800*/ uint16(x86_xSetOp), uint16(x86_PMINUD), + /*2802*/ uint16(x86_xReadSlashR), + /*2803*/ uint16(x86_xArgXmm1), + /*2804*/ uint16(x86_xArgXmm2M128), + /*2805*/ uint16(x86_xMatch), + /*2806*/ uint16(x86_xCondPrefix), 1, + 0x66, 2810, + /*2810*/ uint16(x86_xSetOp), uint16(x86_PMAXSB), + /*2812*/ uint16(x86_xReadSlashR), + /*2813*/ uint16(x86_xArgXmm1), + /*2814*/ uint16(x86_xArgXmm2M128), + /*2815*/ uint16(x86_xMatch), + /*2816*/ uint16(x86_xCondPrefix), 1, + 0x66, 2820, + /*2820*/ uint16(x86_xSetOp), uint16(x86_PMAXSD), + /*2822*/ uint16(x86_xReadSlashR), + /*2823*/ uint16(x86_xArgXmm1), + /*2824*/ uint16(x86_xArgXmm2M128), + /*2825*/ uint16(x86_xMatch), + /*2826*/ uint16(x86_xCondPrefix), 1, + 0x66, 2830, + /*2830*/ uint16(x86_xSetOp), uint16(x86_PMAXUW), + /*2832*/ uint16(x86_xReadSlashR), + /*2833*/ uint16(x86_xArgXmm1), + /*2834*/ uint16(x86_xArgXmm2M128), + /*2835*/ uint16(x86_xMatch), + /*2836*/ uint16(x86_xCondPrefix), 1, + 0x66, 2840, + /*2840*/ uint16(x86_xSetOp), uint16(x86_PMAXUD), + /*2842*/ uint16(x86_xReadSlashR), + /*2843*/ uint16(x86_xArgXmm1), + /*2844*/ uint16(x86_xArgXmm2M128), + /*2845*/ uint16(x86_xMatch), + /*2846*/ uint16(x86_xCondPrefix), 1, + 0x66, 2850, + /*2850*/ uint16(x86_xSetOp), uint16(x86_PMULLD), + /*2852*/ uint16(x86_xReadSlashR), + /*2853*/ uint16(x86_xArgXmm1), + /*2854*/ uint16(x86_xArgXmm2M128), + /*2855*/ uint16(x86_xMatch), + /*2856*/ uint16(x86_xCondPrefix), 1, + 0x66, 2860, + /*2860*/ uint16(x86_xSetOp), uint16(x86_PHMINPOSUW), + /*2862*/ uint16(x86_xReadSlashR), + /*2863*/ uint16(x86_xArgXmm1), + /*2864*/ uint16(x86_xArgXmm2M128), + /*2865*/ uint16(x86_xMatch), + /*2866*/ uint16(x86_xCondIs64), 2869, 2879, + /*2869*/ uint16(x86_xCondPrefix), 1, + 0x66, 2873, + /*2873*/ uint16(x86_xSetOp), uint16(x86_INVPCID), + /*2875*/ uint16(x86_xReadSlashR), + /*2876*/ uint16(x86_xArgR32), + /*2877*/ uint16(x86_xArgM128), + /*2878*/ uint16(x86_xMatch), + /*2879*/ uint16(x86_xCondPrefix), 1, + 0x66, 2883, + /*2883*/ uint16(x86_xSetOp), uint16(x86_INVPCID), + /*2885*/ uint16(x86_xReadSlashR), + /*2886*/ uint16(x86_xArgR64), + /*2887*/ uint16(x86_xArgM128), + /*2888*/ uint16(x86_xMatch), + /*2889*/ uint16(x86_xCondPrefix), 1, + 0x66, 2893, + /*2893*/ uint16(x86_xSetOp), uint16(x86_AESIMC), + /*2895*/ uint16(x86_xReadSlashR), + /*2896*/ uint16(x86_xArgXmm1), + /*2897*/ uint16(x86_xArgXmm2M128), + /*2898*/ uint16(x86_xMatch), + /*2899*/ uint16(x86_xCondPrefix), 1, + 0x66, 2903, + /*2903*/ uint16(x86_xSetOp), uint16(x86_AESENC), + /*2905*/ uint16(x86_xReadSlashR), + /*2906*/ uint16(x86_xArgXmm1), + /*2907*/ uint16(x86_xArgXmm2M128), + /*2908*/ uint16(x86_xMatch), + /*2909*/ uint16(x86_xCondPrefix), 1, + 0x66, 2913, + /*2913*/ uint16(x86_xSetOp), uint16(x86_AESENCLAST), + /*2915*/ uint16(x86_xReadSlashR), + /*2916*/ uint16(x86_xArgXmm1), + /*2917*/ uint16(x86_xArgXmm2M128), + /*2918*/ uint16(x86_xMatch), + /*2919*/ uint16(x86_xCondPrefix), 1, + 0x66, 2923, + /*2923*/ uint16(x86_xSetOp), uint16(x86_AESDEC), + /*2925*/ uint16(x86_xReadSlashR), + /*2926*/ uint16(x86_xArgXmm1), + /*2927*/ uint16(x86_xArgXmm2M128), + /*2928*/ uint16(x86_xMatch), + /*2929*/ uint16(x86_xCondPrefix), 1, + 0x66, 2933, + /*2933*/ uint16(x86_xSetOp), uint16(x86_AESDECLAST), + /*2935*/ uint16(x86_xReadSlashR), + /*2936*/ uint16(x86_xArgXmm1), + /*2937*/ uint16(x86_xArgXmm2M128), + /*2938*/ uint16(x86_xMatch), + /*2939*/ uint16(x86_xCondIs64), 2942, 2980, + /*2942*/ uint16(x86_xCondPrefix), 2, + 0xF2, 2964, + 0x0, 2948, + /*2948*/ uint16(x86_xCondDataSize), 2952, 2958, 0, + /*2952*/ uint16(x86_xSetOp), uint16(x86_MOVBE), + /*2954*/ uint16(x86_xReadSlashR), + /*2955*/ uint16(x86_xArgR16), + /*2956*/ uint16(x86_xArgM16), + /*2957*/ uint16(x86_xMatch), + /*2958*/ uint16(x86_xSetOp), uint16(x86_MOVBE), + /*2960*/ uint16(x86_xReadSlashR), + /*2961*/ uint16(x86_xArgR32), + /*2962*/ uint16(x86_xArgM32), + /*2963*/ uint16(x86_xMatch), + /*2964*/ uint16(x86_xCondDataSize), 2968, 2974, 0, + /*2968*/ uint16(x86_xSetOp), uint16(x86_CRC32), + /*2970*/ uint16(x86_xReadSlashR), + /*2971*/ uint16(x86_xArgR32), + /*2972*/ uint16(x86_xArgRM8), + /*2973*/ uint16(x86_xMatch), + /*2974*/ uint16(x86_xSetOp), uint16(x86_CRC32), + /*2976*/ uint16(x86_xReadSlashR), + /*2977*/ uint16(x86_xArgR32), + /*2978*/ uint16(x86_xArgRM8), + /*2979*/ uint16(x86_xMatch), + /*2980*/ uint16(x86_xCondPrefix), 2, + 0xF2, 2996, + 0x0, 2986, + /*2986*/ uint16(x86_xCondDataSize), 2952, 2958, 2990, + /*2990*/ uint16(x86_xSetOp), uint16(x86_MOVBE), + /*2992*/ uint16(x86_xReadSlashR), + /*2993*/ uint16(x86_xArgR64), + /*2994*/ uint16(x86_xArgM64), + /*2995*/ uint16(x86_xMatch), + /*2996*/ uint16(x86_xCondDataSize), 2968, 2974, 3000, + /*3000*/ uint16(x86_xSetOp), uint16(x86_CRC32), + /*3002*/ uint16(x86_xReadSlashR), + /*3003*/ uint16(x86_xArgR64), + /*3004*/ uint16(x86_xArgRM8), + /*3005*/ uint16(x86_xMatch), + /*3006*/ uint16(x86_xCondIs64), 3009, 3047, + /*3009*/ uint16(x86_xCondPrefix), 2, + 0xF2, 3031, + 0x0, 3015, + /*3015*/ uint16(x86_xCondDataSize), 3019, 3025, 0, + /*3019*/ uint16(x86_xSetOp), uint16(x86_MOVBE), + /*3021*/ uint16(x86_xReadSlashR), + /*3022*/ uint16(x86_xArgM16), + /*3023*/ uint16(x86_xArgR16), + /*3024*/ uint16(x86_xMatch), + /*3025*/ uint16(x86_xSetOp), uint16(x86_MOVBE), + /*3027*/ uint16(x86_xReadSlashR), + /*3028*/ uint16(x86_xArgM32), + /*3029*/ uint16(x86_xArgR32), + /*3030*/ uint16(x86_xMatch), + /*3031*/ uint16(x86_xCondDataSize), 3035, 3041, 0, + /*3035*/ uint16(x86_xSetOp), uint16(x86_CRC32), + /*3037*/ uint16(x86_xReadSlashR), + /*3038*/ uint16(x86_xArgR32), + /*3039*/ uint16(x86_xArgRM16), + /*3040*/ uint16(x86_xMatch), + /*3041*/ uint16(x86_xSetOp), uint16(x86_CRC32), + /*3043*/ uint16(x86_xReadSlashR), + /*3044*/ uint16(x86_xArgR32), + /*3045*/ uint16(x86_xArgRM32), + /*3046*/ uint16(x86_xMatch), + /*3047*/ uint16(x86_xCondPrefix), 2, + 0xF2, 3063, + 0x0, 3053, + /*3053*/ uint16(x86_xCondDataSize), 3019, 3025, 3057, + /*3057*/ uint16(x86_xSetOp), uint16(x86_MOVBE), + /*3059*/ uint16(x86_xReadSlashR), + /*3060*/ uint16(x86_xArgM64), + /*3061*/ uint16(x86_xArgR64), + /*3062*/ uint16(x86_xMatch), + /*3063*/ uint16(x86_xCondDataSize), 3035, 3041, 3067, + /*3067*/ uint16(x86_xSetOp), uint16(x86_CRC32), + /*3069*/ uint16(x86_xReadSlashR), + /*3070*/ uint16(x86_xArgR64), + /*3071*/ uint16(x86_xArgRM64), + /*3072*/ uint16(x86_xMatch), + /*3073*/ uint16(x86_xCondByte), 24, + 0x08, 3124, + 0x09, 3136, + 0x0A, 3148, + 0x0B, 3160, + 0x0C, 3172, + 0x0D, 3184, + 0x0E, 3196, + 0x0F, 3208, + 0x14, 3230, + 0x15, 3242, + 0x16, 3254, + 0x17, 3297, + 0x20, 3309, + 0x21, 3321, + 0x22, 3333, + 0x40, 3376, + 0x41, 3388, + 0x42, 3400, + 0x44, 3412, + 0x60, 3424, + 0x61, 3436, + 0x62, 3448, + 0x63, 3460, + 0xDF, 3472, + uint16(x86_xFail), + /*3124*/ uint16(x86_xCondPrefix), 1, + 0x66, 3128, + /*3128*/ uint16(x86_xSetOp), uint16(x86_ROUNDPS), + /*3130*/ uint16(x86_xReadSlashR), + /*3131*/ uint16(x86_xReadIb), + /*3132*/ uint16(x86_xArgXmm1), + /*3133*/ uint16(x86_xArgXmm2M128), + /*3134*/ uint16(x86_xArgImm8u), + /*3135*/ uint16(x86_xMatch), + /*3136*/ uint16(x86_xCondPrefix), 1, + 0x66, 3140, + /*3140*/ uint16(x86_xSetOp), uint16(x86_ROUNDPD), + /*3142*/ uint16(x86_xReadSlashR), + /*3143*/ uint16(x86_xReadIb), + /*3144*/ uint16(x86_xArgXmm1), + /*3145*/ uint16(x86_xArgXmm2M128), + /*3146*/ uint16(x86_xArgImm8u), + /*3147*/ uint16(x86_xMatch), + /*3148*/ uint16(x86_xCondPrefix), 1, + 0x66, 3152, + /*3152*/ uint16(x86_xSetOp), uint16(x86_ROUNDSS), + /*3154*/ uint16(x86_xReadSlashR), + /*3155*/ uint16(x86_xReadIb), + /*3156*/ uint16(x86_xArgXmm1), + /*3157*/ uint16(x86_xArgXmm2M32), + /*3158*/ uint16(x86_xArgImm8u), + /*3159*/ uint16(x86_xMatch), + /*3160*/ uint16(x86_xCondPrefix), 1, + 0x66, 3164, + /*3164*/ uint16(x86_xSetOp), uint16(x86_ROUNDSD), + /*3166*/ uint16(x86_xReadSlashR), + /*3167*/ uint16(x86_xReadIb), + /*3168*/ uint16(x86_xArgXmm1), + /*3169*/ uint16(x86_xArgXmm2M64), + /*3170*/ uint16(x86_xArgImm8u), + /*3171*/ uint16(x86_xMatch), + /*3172*/ uint16(x86_xCondPrefix), 1, + 0x66, 3176, + /*3176*/ uint16(x86_xSetOp), uint16(x86_BLENDPS), + /*3178*/ uint16(x86_xReadSlashR), + /*3179*/ uint16(x86_xReadIb), + /*3180*/ uint16(x86_xArgXmm1), + /*3181*/ uint16(x86_xArgXmm2M128), + /*3182*/ uint16(x86_xArgImm8u), + /*3183*/ uint16(x86_xMatch), + /*3184*/ uint16(x86_xCondPrefix), 1, + 0x66, 3188, + /*3188*/ uint16(x86_xSetOp), uint16(x86_BLENDPD), + /*3190*/ uint16(x86_xReadSlashR), + /*3191*/ uint16(x86_xReadIb), + /*3192*/ uint16(x86_xArgXmm1), + /*3193*/ uint16(x86_xArgXmm2M128), + /*3194*/ uint16(x86_xArgImm8u), + /*3195*/ uint16(x86_xMatch), + /*3196*/ uint16(x86_xCondPrefix), 1, + 0x66, 3200, + /*3200*/ uint16(x86_xSetOp), uint16(x86_PBLENDW), + /*3202*/ uint16(x86_xReadSlashR), + /*3203*/ uint16(x86_xReadIb), + /*3204*/ uint16(x86_xArgXmm1), + /*3205*/ uint16(x86_xArgXmm2M128), + /*3206*/ uint16(x86_xArgImm8u), + /*3207*/ uint16(x86_xMatch), + /*3208*/ uint16(x86_xCondPrefix), 2, + 0x66, 3222, + 0x0, 3214, + /*3214*/ uint16(x86_xSetOp), uint16(x86_PALIGNR), + /*3216*/ uint16(x86_xReadSlashR), + /*3217*/ uint16(x86_xReadIb), + /*3218*/ uint16(x86_xArgMm1), + /*3219*/ uint16(x86_xArgMm2M64), + /*3220*/ uint16(x86_xArgImm8u), + /*3221*/ uint16(x86_xMatch), + /*3222*/ uint16(x86_xSetOp), uint16(x86_PALIGNR), + /*3224*/ uint16(x86_xReadSlashR), + /*3225*/ uint16(x86_xReadIb), + /*3226*/ uint16(x86_xArgXmm1), + /*3227*/ uint16(x86_xArgXmm2M128), + /*3228*/ uint16(x86_xArgImm8u), + /*3229*/ uint16(x86_xMatch), + /*3230*/ uint16(x86_xCondPrefix), 1, + 0x66, 3234, + /*3234*/ uint16(x86_xSetOp), uint16(x86_PEXTRB), + /*3236*/ uint16(x86_xReadSlashR), + /*3237*/ uint16(x86_xReadIb), + /*3238*/ uint16(x86_xArgR32M8), + /*3239*/ uint16(x86_xArgXmm1), + /*3240*/ uint16(x86_xArgImm8u), + /*3241*/ uint16(x86_xMatch), + /*3242*/ uint16(x86_xCondPrefix), 1, + 0x66, 3246, + /*3246*/ uint16(x86_xSetOp), uint16(x86_PEXTRW), + /*3248*/ uint16(x86_xReadSlashR), + /*3249*/ uint16(x86_xReadIb), + /*3250*/ uint16(x86_xArgR32M16), + /*3251*/ uint16(x86_xArgXmm1), + /*3252*/ uint16(x86_xArgImm8u), + /*3253*/ uint16(x86_xMatch), + /*3254*/ uint16(x86_xCondIs64), 3257, 3281, + /*3257*/ uint16(x86_xCondPrefix), 1, + 0x66, 3261, + /*3261*/ uint16(x86_xCondDataSize), 3265, 3273, 0, + /*3265*/ uint16(x86_xSetOp), uint16(x86_PEXTRD), + /*3267*/ uint16(x86_xReadSlashR), + /*3268*/ uint16(x86_xReadIb), + /*3269*/ uint16(x86_xArgRM32), + /*3270*/ uint16(x86_xArgXmm1), + /*3271*/ uint16(x86_xArgImm8u), + /*3272*/ uint16(x86_xMatch), + /*3273*/ uint16(x86_xSetOp), uint16(x86_PEXTRD), + /*3275*/ uint16(x86_xReadSlashR), + /*3276*/ uint16(x86_xReadIb), + /*3277*/ uint16(x86_xArgRM32), + /*3278*/ uint16(x86_xArgXmm1), + /*3279*/ uint16(x86_xArgImm8u), + /*3280*/ uint16(x86_xMatch), + /*3281*/ uint16(x86_xCondPrefix), 1, + 0x66, 3285, + /*3285*/ uint16(x86_xCondDataSize), 3265, 3273, 3289, + /*3289*/ uint16(x86_xSetOp), uint16(x86_PEXTRQ), + /*3291*/ uint16(x86_xReadSlashR), + /*3292*/ uint16(x86_xReadIb), + /*3293*/ uint16(x86_xArgRM64), + /*3294*/ uint16(x86_xArgXmm1), + /*3295*/ uint16(x86_xArgImm8u), + /*3296*/ uint16(x86_xMatch), + /*3297*/ uint16(x86_xCondPrefix), 1, + 0x66, 3301, + /*3301*/ uint16(x86_xSetOp), uint16(x86_EXTRACTPS), + /*3303*/ uint16(x86_xReadSlashR), + /*3304*/ uint16(x86_xReadIb), + /*3305*/ uint16(x86_xArgRM32), + /*3306*/ uint16(x86_xArgXmm1), + /*3307*/ uint16(x86_xArgImm8u), + /*3308*/ uint16(x86_xMatch), + /*3309*/ uint16(x86_xCondPrefix), 1, + 0x66, 3313, + /*3313*/ uint16(x86_xSetOp), uint16(x86_PINSRB), + /*3315*/ uint16(x86_xReadSlashR), + /*3316*/ uint16(x86_xReadIb), + /*3317*/ uint16(x86_xArgXmm1), + /*3318*/ uint16(x86_xArgR32M8), + /*3319*/ uint16(x86_xArgImm8u), + /*3320*/ uint16(x86_xMatch), + /*3321*/ uint16(x86_xCondPrefix), 1, + 0x66, 3325, + /*3325*/ uint16(x86_xSetOp), uint16(x86_INSERTPS), + /*3327*/ uint16(x86_xReadSlashR), + /*3328*/ uint16(x86_xReadIb), + /*3329*/ uint16(x86_xArgXmm1), + /*3330*/ uint16(x86_xArgXmm2M32), + /*3331*/ uint16(x86_xArgImm8u), + /*3332*/ uint16(x86_xMatch), + /*3333*/ uint16(x86_xCondIs64), 3336, 3360, + /*3336*/ uint16(x86_xCondPrefix), 1, + 0x66, 3340, + /*3340*/ uint16(x86_xCondDataSize), 3344, 3352, 0, + /*3344*/ uint16(x86_xSetOp), uint16(x86_PINSRD), + /*3346*/ uint16(x86_xReadSlashR), + /*3347*/ uint16(x86_xReadIb), + /*3348*/ uint16(x86_xArgXmm1), + /*3349*/ uint16(x86_xArgRM32), + /*3350*/ uint16(x86_xArgImm8u), + /*3351*/ uint16(x86_xMatch), + /*3352*/ uint16(x86_xSetOp), uint16(x86_PINSRD), + /*3354*/ uint16(x86_xReadSlashR), + /*3355*/ uint16(x86_xReadIb), + /*3356*/ uint16(x86_xArgXmm1), + /*3357*/ uint16(x86_xArgRM32), + /*3358*/ uint16(x86_xArgImm8u), + /*3359*/ uint16(x86_xMatch), + /*3360*/ uint16(x86_xCondPrefix), 1, + 0x66, 3364, + /*3364*/ uint16(x86_xCondDataSize), 3344, 3352, 3368, + /*3368*/ uint16(x86_xSetOp), uint16(x86_PINSRQ), + /*3370*/ uint16(x86_xReadSlashR), + /*3371*/ uint16(x86_xReadIb), + /*3372*/ uint16(x86_xArgXmm1), + /*3373*/ uint16(x86_xArgRM64), + /*3374*/ uint16(x86_xArgImm8u), + /*3375*/ uint16(x86_xMatch), + /*3376*/ uint16(x86_xCondPrefix), 1, + 0x66, 3380, + /*3380*/ uint16(x86_xSetOp), uint16(x86_DPPS), + /*3382*/ uint16(x86_xReadSlashR), + /*3383*/ uint16(x86_xReadIb), + /*3384*/ uint16(x86_xArgXmm1), + /*3385*/ uint16(x86_xArgXmm2M128), + /*3386*/ uint16(x86_xArgImm8u), + /*3387*/ uint16(x86_xMatch), + /*3388*/ uint16(x86_xCondPrefix), 1, + 0x66, 3392, + /*3392*/ uint16(x86_xSetOp), uint16(x86_DPPD), + /*3394*/ uint16(x86_xReadSlashR), + /*3395*/ uint16(x86_xReadIb), + /*3396*/ uint16(x86_xArgXmm1), + /*3397*/ uint16(x86_xArgXmm2M128), + /*3398*/ uint16(x86_xArgImm8u), + /*3399*/ uint16(x86_xMatch), + /*3400*/ uint16(x86_xCondPrefix), 1, + 0x66, 3404, + /*3404*/ uint16(x86_xSetOp), uint16(x86_MPSADBW), + /*3406*/ uint16(x86_xReadSlashR), + /*3407*/ uint16(x86_xReadIb), + /*3408*/ uint16(x86_xArgXmm1), + /*3409*/ uint16(x86_xArgXmm2M128), + /*3410*/ uint16(x86_xArgImm8u), + /*3411*/ uint16(x86_xMatch), + /*3412*/ uint16(x86_xCondPrefix), 1, + 0x66, 3416, + /*3416*/ uint16(x86_xSetOp), uint16(x86_PCLMULQDQ), + /*3418*/ uint16(x86_xReadSlashR), + /*3419*/ uint16(x86_xReadIb), + /*3420*/ uint16(x86_xArgXmm1), + /*3421*/ uint16(x86_xArgXmm2M128), + /*3422*/ uint16(x86_xArgImm8u), + /*3423*/ uint16(x86_xMatch), + /*3424*/ uint16(x86_xCondPrefix), 1, + 0x66, 3428, + /*3428*/ uint16(x86_xSetOp), uint16(x86_PCMPESTRM), + /*3430*/ uint16(x86_xReadSlashR), + /*3431*/ uint16(x86_xReadIb), + /*3432*/ uint16(x86_xArgXmm1), + /*3433*/ uint16(x86_xArgXmm2M128), + /*3434*/ uint16(x86_xArgImm8u), + /*3435*/ uint16(x86_xMatch), + /*3436*/ uint16(x86_xCondPrefix), 1, + 0x66, 3440, + /*3440*/ uint16(x86_xSetOp), uint16(x86_PCMPESTRI), + /*3442*/ uint16(x86_xReadSlashR), + /*3443*/ uint16(x86_xReadIb), + /*3444*/ uint16(x86_xArgXmm1), + /*3445*/ uint16(x86_xArgXmm2M128), + /*3446*/ uint16(x86_xArgImm8u), + /*3447*/ uint16(x86_xMatch), + /*3448*/ uint16(x86_xCondPrefix), 1, + 0x66, 3452, + /*3452*/ uint16(x86_xSetOp), uint16(x86_PCMPISTRM), + /*3454*/ uint16(x86_xReadSlashR), + /*3455*/ uint16(x86_xReadIb), + /*3456*/ uint16(x86_xArgXmm1), + /*3457*/ uint16(x86_xArgXmm2M128), + /*3458*/ uint16(x86_xArgImm8u), + /*3459*/ uint16(x86_xMatch), + /*3460*/ uint16(x86_xCondPrefix), 1, + 0x66, 3464, + /*3464*/ uint16(x86_xSetOp), uint16(x86_PCMPISTRI), + /*3466*/ uint16(x86_xReadSlashR), + /*3467*/ uint16(x86_xReadIb), + /*3468*/ uint16(x86_xArgXmm1), + /*3469*/ uint16(x86_xArgXmm2M128), + /*3470*/ uint16(x86_xArgImm8u), + /*3471*/ uint16(x86_xMatch), + /*3472*/ uint16(x86_xCondPrefix), 1, + 0x66, 3476, + /*3476*/ uint16(x86_xSetOp), uint16(x86_AESKEYGENASSIST), + /*3478*/ uint16(x86_xReadSlashR), + /*3479*/ uint16(x86_xReadIb), + /*3480*/ uint16(x86_xArgXmm1), + /*3481*/ uint16(x86_xArgXmm2M128), + /*3482*/ uint16(x86_xArgImm8u), + /*3483*/ uint16(x86_xMatch), + /*3484*/ uint16(x86_xCondIs64), 3487, 3503, + /*3487*/ uint16(x86_xCondDataSize), 3491, 3497, 0, + /*3491*/ uint16(x86_xSetOp), uint16(x86_CMOVO), + /*3493*/ uint16(x86_xReadSlashR), + /*3494*/ uint16(x86_xArgR16), + /*3495*/ uint16(x86_xArgRM16), + /*3496*/ uint16(x86_xMatch), + /*3497*/ uint16(x86_xSetOp), uint16(x86_CMOVO), + /*3499*/ uint16(x86_xReadSlashR), + /*3500*/ uint16(x86_xArgR32), + /*3501*/ uint16(x86_xArgRM32), + /*3502*/ uint16(x86_xMatch), + /*3503*/ uint16(x86_xCondDataSize), 3491, 3497, 3507, + /*3507*/ uint16(x86_xSetOp), uint16(x86_CMOVO), + /*3509*/ uint16(x86_xReadSlashR), + /*3510*/ uint16(x86_xArgR64), + /*3511*/ uint16(x86_xArgRM64), + /*3512*/ uint16(x86_xMatch), + /*3513*/ uint16(x86_xCondIs64), 3516, 3532, + /*3516*/ uint16(x86_xCondDataSize), 3520, 3526, 0, + /*3520*/ uint16(x86_xSetOp), uint16(x86_CMOVNO), + /*3522*/ uint16(x86_xReadSlashR), + /*3523*/ uint16(x86_xArgR16), + /*3524*/ uint16(x86_xArgRM16), + /*3525*/ uint16(x86_xMatch), + /*3526*/ uint16(x86_xSetOp), uint16(x86_CMOVNO), + /*3528*/ uint16(x86_xReadSlashR), + /*3529*/ uint16(x86_xArgR32), + /*3530*/ uint16(x86_xArgRM32), + /*3531*/ uint16(x86_xMatch), + /*3532*/ uint16(x86_xCondDataSize), 3520, 3526, 3536, + /*3536*/ uint16(x86_xSetOp), uint16(x86_CMOVNO), + /*3538*/ uint16(x86_xReadSlashR), + /*3539*/ uint16(x86_xArgR64), + /*3540*/ uint16(x86_xArgRM64), + /*3541*/ uint16(x86_xMatch), + /*3542*/ uint16(x86_xCondIs64), 3545, 3561, + /*3545*/ uint16(x86_xCondDataSize), 3549, 3555, 0, + /*3549*/ uint16(x86_xSetOp), uint16(x86_CMOVB), + /*3551*/ uint16(x86_xReadSlashR), + /*3552*/ uint16(x86_xArgR16), + /*3553*/ uint16(x86_xArgRM16), + /*3554*/ uint16(x86_xMatch), + /*3555*/ uint16(x86_xSetOp), uint16(x86_CMOVB), + /*3557*/ uint16(x86_xReadSlashR), + /*3558*/ uint16(x86_xArgR32), + /*3559*/ uint16(x86_xArgRM32), + /*3560*/ uint16(x86_xMatch), + /*3561*/ uint16(x86_xCondDataSize), 3549, 3555, 3565, + /*3565*/ uint16(x86_xSetOp), uint16(x86_CMOVB), + /*3567*/ uint16(x86_xReadSlashR), + /*3568*/ uint16(x86_xArgR64), + /*3569*/ uint16(x86_xArgRM64), + /*3570*/ uint16(x86_xMatch), + /*3571*/ uint16(x86_xCondIs64), 3574, 3590, + /*3574*/ uint16(x86_xCondDataSize), 3578, 3584, 0, + /*3578*/ uint16(x86_xSetOp), uint16(x86_CMOVAE), + /*3580*/ uint16(x86_xReadSlashR), + /*3581*/ uint16(x86_xArgR16), + /*3582*/ uint16(x86_xArgRM16), + /*3583*/ uint16(x86_xMatch), + /*3584*/ uint16(x86_xSetOp), uint16(x86_CMOVAE), + /*3586*/ uint16(x86_xReadSlashR), + /*3587*/ uint16(x86_xArgR32), + /*3588*/ uint16(x86_xArgRM32), + /*3589*/ uint16(x86_xMatch), + /*3590*/ uint16(x86_xCondDataSize), 3578, 3584, 3594, + /*3594*/ uint16(x86_xSetOp), uint16(x86_CMOVAE), + /*3596*/ uint16(x86_xReadSlashR), + /*3597*/ uint16(x86_xArgR64), + /*3598*/ uint16(x86_xArgRM64), + /*3599*/ uint16(x86_xMatch), + /*3600*/ uint16(x86_xCondIs64), 3603, 3619, + /*3603*/ uint16(x86_xCondDataSize), 3607, 3613, 0, + /*3607*/ uint16(x86_xSetOp), uint16(x86_CMOVE), + /*3609*/ uint16(x86_xReadSlashR), + /*3610*/ uint16(x86_xArgR16), + /*3611*/ uint16(x86_xArgRM16), + /*3612*/ uint16(x86_xMatch), + /*3613*/ uint16(x86_xSetOp), uint16(x86_CMOVE), + /*3615*/ uint16(x86_xReadSlashR), + /*3616*/ uint16(x86_xArgR32), + /*3617*/ uint16(x86_xArgRM32), + /*3618*/ uint16(x86_xMatch), + /*3619*/ uint16(x86_xCondDataSize), 3607, 3613, 3623, + /*3623*/ uint16(x86_xSetOp), uint16(x86_CMOVE), + /*3625*/ uint16(x86_xReadSlashR), + /*3626*/ uint16(x86_xArgR64), + /*3627*/ uint16(x86_xArgRM64), + /*3628*/ uint16(x86_xMatch), + /*3629*/ uint16(x86_xCondIs64), 3632, 3648, + /*3632*/ uint16(x86_xCondDataSize), 3636, 3642, 0, + /*3636*/ uint16(x86_xSetOp), uint16(x86_CMOVNE), + /*3638*/ uint16(x86_xReadSlashR), + /*3639*/ uint16(x86_xArgR16), + /*3640*/ uint16(x86_xArgRM16), + /*3641*/ uint16(x86_xMatch), + /*3642*/ uint16(x86_xSetOp), uint16(x86_CMOVNE), + /*3644*/ uint16(x86_xReadSlashR), + /*3645*/ uint16(x86_xArgR32), + /*3646*/ uint16(x86_xArgRM32), + /*3647*/ uint16(x86_xMatch), + /*3648*/ uint16(x86_xCondDataSize), 3636, 3642, 3652, + /*3652*/ uint16(x86_xSetOp), uint16(x86_CMOVNE), + /*3654*/ uint16(x86_xReadSlashR), + /*3655*/ uint16(x86_xArgR64), + /*3656*/ uint16(x86_xArgRM64), + /*3657*/ uint16(x86_xMatch), + /*3658*/ uint16(x86_xCondIs64), 3661, 3677, + /*3661*/ uint16(x86_xCondDataSize), 3665, 3671, 0, + /*3665*/ uint16(x86_xSetOp), uint16(x86_CMOVBE), + /*3667*/ uint16(x86_xReadSlashR), + /*3668*/ uint16(x86_xArgR16), + /*3669*/ uint16(x86_xArgRM16), + /*3670*/ uint16(x86_xMatch), + /*3671*/ uint16(x86_xSetOp), uint16(x86_CMOVBE), + /*3673*/ uint16(x86_xReadSlashR), + /*3674*/ uint16(x86_xArgR32), + /*3675*/ uint16(x86_xArgRM32), + /*3676*/ uint16(x86_xMatch), + /*3677*/ uint16(x86_xCondDataSize), 3665, 3671, 3681, + /*3681*/ uint16(x86_xSetOp), uint16(x86_CMOVBE), + /*3683*/ uint16(x86_xReadSlashR), + /*3684*/ uint16(x86_xArgR64), + /*3685*/ uint16(x86_xArgRM64), + /*3686*/ uint16(x86_xMatch), + /*3687*/ uint16(x86_xCondIs64), 3690, 3706, + /*3690*/ uint16(x86_xCondDataSize), 3694, 3700, 0, + /*3694*/ uint16(x86_xSetOp), uint16(x86_CMOVA), + /*3696*/ uint16(x86_xReadSlashR), + /*3697*/ uint16(x86_xArgR16), + /*3698*/ uint16(x86_xArgRM16), + /*3699*/ uint16(x86_xMatch), + /*3700*/ uint16(x86_xSetOp), uint16(x86_CMOVA), + /*3702*/ uint16(x86_xReadSlashR), + /*3703*/ uint16(x86_xArgR32), + /*3704*/ uint16(x86_xArgRM32), + /*3705*/ uint16(x86_xMatch), + /*3706*/ uint16(x86_xCondDataSize), 3694, 3700, 3710, + /*3710*/ uint16(x86_xSetOp), uint16(x86_CMOVA), + /*3712*/ uint16(x86_xReadSlashR), + /*3713*/ uint16(x86_xArgR64), + /*3714*/ uint16(x86_xArgRM64), + /*3715*/ uint16(x86_xMatch), + /*3716*/ uint16(x86_xCondIs64), 3719, 3735, + /*3719*/ uint16(x86_xCondDataSize), 3723, 3729, 0, + /*3723*/ uint16(x86_xSetOp), uint16(x86_CMOVS), + /*3725*/ uint16(x86_xReadSlashR), + /*3726*/ uint16(x86_xArgR16), + /*3727*/ uint16(x86_xArgRM16), + /*3728*/ uint16(x86_xMatch), + /*3729*/ uint16(x86_xSetOp), uint16(x86_CMOVS), + /*3731*/ uint16(x86_xReadSlashR), + /*3732*/ uint16(x86_xArgR32), + /*3733*/ uint16(x86_xArgRM32), + /*3734*/ uint16(x86_xMatch), + /*3735*/ uint16(x86_xCondDataSize), 3723, 3729, 3739, + /*3739*/ uint16(x86_xSetOp), uint16(x86_CMOVS), + /*3741*/ uint16(x86_xReadSlashR), + /*3742*/ uint16(x86_xArgR64), + /*3743*/ uint16(x86_xArgRM64), + /*3744*/ uint16(x86_xMatch), + /*3745*/ uint16(x86_xCondIs64), 3748, 3764, + /*3748*/ uint16(x86_xCondDataSize), 3752, 3758, 0, + /*3752*/ uint16(x86_xSetOp), uint16(x86_CMOVNS), + /*3754*/ uint16(x86_xReadSlashR), + /*3755*/ uint16(x86_xArgR16), + /*3756*/ uint16(x86_xArgRM16), + /*3757*/ uint16(x86_xMatch), + /*3758*/ uint16(x86_xSetOp), uint16(x86_CMOVNS), + /*3760*/ uint16(x86_xReadSlashR), + /*3761*/ uint16(x86_xArgR32), + /*3762*/ uint16(x86_xArgRM32), + /*3763*/ uint16(x86_xMatch), + /*3764*/ uint16(x86_xCondDataSize), 3752, 3758, 3768, + /*3768*/ uint16(x86_xSetOp), uint16(x86_CMOVNS), + /*3770*/ uint16(x86_xReadSlashR), + /*3771*/ uint16(x86_xArgR64), + /*3772*/ uint16(x86_xArgRM64), + /*3773*/ uint16(x86_xMatch), + /*3774*/ uint16(x86_xCondIs64), 3777, 3793, + /*3777*/ uint16(x86_xCondDataSize), 3781, 3787, 0, + /*3781*/ uint16(x86_xSetOp), uint16(x86_CMOVP), + /*3783*/ uint16(x86_xReadSlashR), + /*3784*/ uint16(x86_xArgR16), + /*3785*/ uint16(x86_xArgRM16), + /*3786*/ uint16(x86_xMatch), + /*3787*/ uint16(x86_xSetOp), uint16(x86_CMOVP), + /*3789*/ uint16(x86_xReadSlashR), + /*3790*/ uint16(x86_xArgR32), + /*3791*/ uint16(x86_xArgRM32), + /*3792*/ uint16(x86_xMatch), + /*3793*/ uint16(x86_xCondDataSize), 3781, 3787, 3797, + /*3797*/ uint16(x86_xSetOp), uint16(x86_CMOVP), + /*3799*/ uint16(x86_xReadSlashR), + /*3800*/ uint16(x86_xArgR64), + /*3801*/ uint16(x86_xArgRM64), + /*3802*/ uint16(x86_xMatch), + /*3803*/ uint16(x86_xCondIs64), 3806, 3822, + /*3806*/ uint16(x86_xCondDataSize), 3810, 3816, 0, + /*3810*/ uint16(x86_xSetOp), uint16(x86_CMOVNP), + /*3812*/ uint16(x86_xReadSlashR), + /*3813*/ uint16(x86_xArgR16), + /*3814*/ uint16(x86_xArgRM16), + /*3815*/ uint16(x86_xMatch), + /*3816*/ uint16(x86_xSetOp), uint16(x86_CMOVNP), + /*3818*/ uint16(x86_xReadSlashR), + /*3819*/ uint16(x86_xArgR32), + /*3820*/ uint16(x86_xArgRM32), + /*3821*/ uint16(x86_xMatch), + /*3822*/ uint16(x86_xCondDataSize), 3810, 3816, 3826, + /*3826*/ uint16(x86_xSetOp), uint16(x86_CMOVNP), + /*3828*/ uint16(x86_xReadSlashR), + /*3829*/ uint16(x86_xArgR64), + /*3830*/ uint16(x86_xArgRM64), + /*3831*/ uint16(x86_xMatch), + /*3832*/ uint16(x86_xCondIs64), 3835, 3851, + /*3835*/ uint16(x86_xCondDataSize), 3839, 3845, 0, + /*3839*/ uint16(x86_xSetOp), uint16(x86_CMOVL), + /*3841*/ uint16(x86_xReadSlashR), + /*3842*/ uint16(x86_xArgR16), + /*3843*/ uint16(x86_xArgRM16), + /*3844*/ uint16(x86_xMatch), + /*3845*/ uint16(x86_xSetOp), uint16(x86_CMOVL), + /*3847*/ uint16(x86_xReadSlashR), + /*3848*/ uint16(x86_xArgR32), + /*3849*/ uint16(x86_xArgRM32), + /*3850*/ uint16(x86_xMatch), + /*3851*/ uint16(x86_xCondDataSize), 3839, 3845, 3855, + /*3855*/ uint16(x86_xSetOp), uint16(x86_CMOVL), + /*3857*/ uint16(x86_xReadSlashR), + /*3858*/ uint16(x86_xArgR64), + /*3859*/ uint16(x86_xArgRM64), + /*3860*/ uint16(x86_xMatch), + /*3861*/ uint16(x86_xCondIs64), 3864, 3880, + /*3864*/ uint16(x86_xCondDataSize), 3868, 3874, 0, + /*3868*/ uint16(x86_xSetOp), uint16(x86_CMOVGE), + /*3870*/ uint16(x86_xReadSlashR), + /*3871*/ uint16(x86_xArgR16), + /*3872*/ uint16(x86_xArgRM16), + /*3873*/ uint16(x86_xMatch), + /*3874*/ uint16(x86_xSetOp), uint16(x86_CMOVGE), + /*3876*/ uint16(x86_xReadSlashR), + /*3877*/ uint16(x86_xArgR32), + /*3878*/ uint16(x86_xArgRM32), + /*3879*/ uint16(x86_xMatch), + /*3880*/ uint16(x86_xCondDataSize), 3868, 3874, 3884, + /*3884*/ uint16(x86_xSetOp), uint16(x86_CMOVGE), + /*3886*/ uint16(x86_xReadSlashR), + /*3887*/ uint16(x86_xArgR64), + /*3888*/ uint16(x86_xArgRM64), + /*3889*/ uint16(x86_xMatch), + /*3890*/ uint16(x86_xCondIs64), 3893, 3909, + /*3893*/ uint16(x86_xCondDataSize), 3897, 3903, 0, + /*3897*/ uint16(x86_xSetOp), uint16(x86_CMOVLE), + /*3899*/ uint16(x86_xReadSlashR), + /*3900*/ uint16(x86_xArgR16), + /*3901*/ uint16(x86_xArgRM16), + /*3902*/ uint16(x86_xMatch), + /*3903*/ uint16(x86_xSetOp), uint16(x86_CMOVLE), + /*3905*/ uint16(x86_xReadSlashR), + /*3906*/ uint16(x86_xArgR32), + /*3907*/ uint16(x86_xArgRM32), + /*3908*/ uint16(x86_xMatch), + /*3909*/ uint16(x86_xCondDataSize), 3897, 3903, 3913, + /*3913*/ uint16(x86_xSetOp), uint16(x86_CMOVLE), + /*3915*/ uint16(x86_xReadSlashR), + /*3916*/ uint16(x86_xArgR64), + /*3917*/ uint16(x86_xArgRM64), + /*3918*/ uint16(x86_xMatch), + /*3919*/ uint16(x86_xCondIs64), 3922, 3938, + /*3922*/ uint16(x86_xCondDataSize), 3926, 3932, 0, + /*3926*/ uint16(x86_xSetOp), uint16(x86_CMOVG), + /*3928*/ uint16(x86_xReadSlashR), + /*3929*/ uint16(x86_xArgR16), + /*3930*/ uint16(x86_xArgRM16), + /*3931*/ uint16(x86_xMatch), + /*3932*/ uint16(x86_xSetOp), uint16(x86_CMOVG), + /*3934*/ uint16(x86_xReadSlashR), + /*3935*/ uint16(x86_xArgR32), + /*3936*/ uint16(x86_xArgRM32), + /*3937*/ uint16(x86_xMatch), + /*3938*/ uint16(x86_xCondDataSize), 3926, 3932, 3942, + /*3942*/ uint16(x86_xSetOp), uint16(x86_CMOVG), + /*3944*/ uint16(x86_xReadSlashR), + /*3945*/ uint16(x86_xArgR64), + /*3946*/ uint16(x86_xArgRM64), + /*3947*/ uint16(x86_xMatch), + /*3948*/ uint16(x86_xCondPrefix), 2, + 0x66, 3960, + 0x0, 3954, + /*3954*/ uint16(x86_xSetOp), uint16(x86_MOVMSKPS), + /*3956*/ uint16(x86_xReadSlashR), + /*3957*/ uint16(x86_xArgR32), + /*3958*/ uint16(x86_xArgXmm2), + /*3959*/ uint16(x86_xMatch), + /*3960*/ uint16(x86_xSetOp), uint16(x86_MOVMSKPD), + /*3962*/ uint16(x86_xReadSlashR), + /*3963*/ uint16(x86_xArgR32), + /*3964*/ uint16(x86_xArgXmm2), + /*3965*/ uint16(x86_xMatch), + /*3966*/ uint16(x86_xCondPrefix), 4, + 0xF3, 3994, + 0xF2, 3988, + 0x66, 3982, + 0x0, 3976, + /*3976*/ uint16(x86_xSetOp), uint16(x86_SQRTPS), + /*3978*/ uint16(x86_xReadSlashR), + /*3979*/ uint16(x86_xArgXmm1), + /*3980*/ uint16(x86_xArgXmm2M128), + /*3981*/ uint16(x86_xMatch), + /*3982*/ uint16(x86_xSetOp), uint16(x86_SQRTPD), + /*3984*/ uint16(x86_xReadSlashR), + /*3985*/ uint16(x86_xArgXmm1), + /*3986*/ uint16(x86_xArgXmm2M128), + /*3987*/ uint16(x86_xMatch), + /*3988*/ uint16(x86_xSetOp), uint16(x86_SQRTSD), + /*3990*/ uint16(x86_xReadSlashR), + /*3991*/ uint16(x86_xArgXmm1), + /*3992*/ uint16(x86_xArgXmm2M64), + /*3993*/ uint16(x86_xMatch), + /*3994*/ uint16(x86_xSetOp), uint16(x86_SQRTSS), + /*3996*/ uint16(x86_xReadSlashR), + /*3997*/ uint16(x86_xArgXmm1), + /*3998*/ uint16(x86_xArgXmm2M32), + /*3999*/ uint16(x86_xMatch), + /*4000*/ uint16(x86_xCondPrefix), 2, + 0xF3, 4012, + 0x0, 4006, + /*4006*/ uint16(x86_xSetOp), uint16(x86_RSQRTPS), + /*4008*/ uint16(x86_xReadSlashR), + /*4009*/ uint16(x86_xArgXmm1), + /*4010*/ uint16(x86_xArgXmm2M128), + /*4011*/ uint16(x86_xMatch), + /*4012*/ uint16(x86_xSetOp), uint16(x86_RSQRTSS), + /*4014*/ uint16(x86_xReadSlashR), + /*4015*/ uint16(x86_xArgXmm1), + /*4016*/ uint16(x86_xArgXmm2M32), + /*4017*/ uint16(x86_xMatch), + /*4018*/ uint16(x86_xCondPrefix), 2, + 0xF3, 4030, + 0x0, 4024, + /*4024*/ uint16(x86_xSetOp), uint16(x86_RCPPS), + /*4026*/ uint16(x86_xReadSlashR), + /*4027*/ uint16(x86_xArgXmm1), + /*4028*/ uint16(x86_xArgXmm2M128), + /*4029*/ uint16(x86_xMatch), + /*4030*/ uint16(x86_xSetOp), uint16(x86_RCPSS), + /*4032*/ uint16(x86_xReadSlashR), + /*4033*/ uint16(x86_xArgXmm1), + /*4034*/ uint16(x86_xArgXmm2M32), + /*4035*/ uint16(x86_xMatch), + /*4036*/ uint16(x86_xCondPrefix), 2, + 0x66, 4048, + 0x0, 4042, + /*4042*/ uint16(x86_xSetOp), uint16(x86_ANDPS), + /*4044*/ uint16(x86_xReadSlashR), + /*4045*/ uint16(x86_xArgXmm1), + /*4046*/ uint16(x86_xArgXmm2M128), + /*4047*/ uint16(x86_xMatch), + /*4048*/ uint16(x86_xSetOp), uint16(x86_ANDPD), + /*4050*/ uint16(x86_xReadSlashR), + /*4051*/ uint16(x86_xArgXmm1), + /*4052*/ uint16(x86_xArgXmm2M128), + /*4053*/ uint16(x86_xMatch), + /*4054*/ uint16(x86_xCondPrefix), 2, + 0x66, 4066, + 0x0, 4060, + /*4060*/ uint16(x86_xSetOp), uint16(x86_ANDNPS), + /*4062*/ uint16(x86_xReadSlashR), + /*4063*/ uint16(x86_xArgXmm1), + /*4064*/ uint16(x86_xArgXmm2M128), + /*4065*/ uint16(x86_xMatch), + /*4066*/ uint16(x86_xSetOp), uint16(x86_ANDNPD), + /*4068*/ uint16(x86_xReadSlashR), + /*4069*/ uint16(x86_xArgXmm1), + /*4070*/ uint16(x86_xArgXmm2M128), + /*4071*/ uint16(x86_xMatch), + /*4072*/ uint16(x86_xCondPrefix), 2, + 0x66, 4084, + 0x0, 4078, + /*4078*/ uint16(x86_xSetOp), uint16(x86_ORPS), + /*4080*/ uint16(x86_xReadSlashR), + /*4081*/ uint16(x86_xArgXmm1), + /*4082*/ uint16(x86_xArgXmm2M128), + /*4083*/ uint16(x86_xMatch), + /*4084*/ uint16(x86_xSetOp), uint16(x86_ORPD), + /*4086*/ uint16(x86_xReadSlashR), + /*4087*/ uint16(x86_xArgXmm1), + /*4088*/ uint16(x86_xArgXmm2M128), + /*4089*/ uint16(x86_xMatch), + /*4090*/ uint16(x86_xCondPrefix), 2, + 0x66, 4102, + 0x0, 4096, + /*4096*/ uint16(x86_xSetOp), uint16(x86_XORPS), + /*4098*/ uint16(x86_xReadSlashR), + /*4099*/ uint16(x86_xArgXmm1), + /*4100*/ uint16(x86_xArgXmm2M128), + /*4101*/ uint16(x86_xMatch), + /*4102*/ uint16(x86_xSetOp), uint16(x86_XORPD), + /*4104*/ uint16(x86_xReadSlashR), + /*4105*/ uint16(x86_xArgXmm1), + /*4106*/ uint16(x86_xArgXmm2M128), + /*4107*/ uint16(x86_xMatch), + /*4108*/ uint16(x86_xCondPrefix), 4, + 0xF3, 4136, + 0xF2, 4130, + 0x66, 4124, + 0x0, 4118, + /*4118*/ uint16(x86_xSetOp), uint16(x86_ADDPS), + /*4120*/ uint16(x86_xReadSlashR), + /*4121*/ uint16(x86_xArgXmm1), + /*4122*/ uint16(x86_xArgXmm2M128), + /*4123*/ uint16(x86_xMatch), + /*4124*/ uint16(x86_xSetOp), uint16(x86_ADDPD), + /*4126*/ uint16(x86_xReadSlashR), + /*4127*/ uint16(x86_xArgXmm1), + /*4128*/ uint16(x86_xArgXmm2M128), + /*4129*/ uint16(x86_xMatch), + /*4130*/ uint16(x86_xSetOp), uint16(x86_ADDSD), + /*4132*/ uint16(x86_xReadSlashR), + /*4133*/ uint16(x86_xArgXmm1), + /*4134*/ uint16(x86_xArgXmm2M64), + /*4135*/ uint16(x86_xMatch), + /*4136*/ uint16(x86_xSetOp), uint16(x86_ADDSS), + /*4138*/ uint16(x86_xReadSlashR), + /*4139*/ uint16(x86_xArgXmm1), + /*4140*/ uint16(x86_xArgXmm2M32), + /*4141*/ uint16(x86_xMatch), + /*4142*/ uint16(x86_xCondPrefix), 4, + 0xF3, 4170, + 0xF2, 4164, + 0x66, 4158, + 0x0, 4152, + /*4152*/ uint16(x86_xSetOp), uint16(x86_MULPS), + /*4154*/ uint16(x86_xReadSlashR), + /*4155*/ uint16(x86_xArgXmm1), + /*4156*/ uint16(x86_xArgXmm2M128), + /*4157*/ uint16(x86_xMatch), + /*4158*/ uint16(x86_xSetOp), uint16(x86_MULPD), + /*4160*/ uint16(x86_xReadSlashR), + /*4161*/ uint16(x86_xArgXmm1), + /*4162*/ uint16(x86_xArgXmm2M128), + /*4163*/ uint16(x86_xMatch), + /*4164*/ uint16(x86_xSetOp), uint16(x86_MULSD), + /*4166*/ uint16(x86_xReadSlashR), + /*4167*/ uint16(x86_xArgXmm1), + /*4168*/ uint16(x86_xArgXmm2M64), + /*4169*/ uint16(x86_xMatch), + /*4170*/ uint16(x86_xSetOp), uint16(x86_MULSS), + /*4172*/ uint16(x86_xReadSlashR), + /*4173*/ uint16(x86_xArgXmm1), + /*4174*/ uint16(x86_xArgXmm2M32), + /*4175*/ uint16(x86_xMatch), + /*4176*/ uint16(x86_xCondPrefix), 4, + 0xF3, 4204, + 0xF2, 4198, + 0x66, 4192, + 0x0, 4186, + /*4186*/ uint16(x86_xSetOp), uint16(x86_CVTPS2PD), + /*4188*/ uint16(x86_xReadSlashR), + /*4189*/ uint16(x86_xArgXmm1), + /*4190*/ uint16(x86_xArgXmm2M64), + /*4191*/ uint16(x86_xMatch), + /*4192*/ uint16(x86_xSetOp), uint16(x86_CVTPD2PS), + /*4194*/ uint16(x86_xReadSlashR), + /*4195*/ uint16(x86_xArgXmm1), + /*4196*/ uint16(x86_xArgXmm2M128), + /*4197*/ uint16(x86_xMatch), + /*4198*/ uint16(x86_xSetOp), uint16(x86_CVTSD2SS), + /*4200*/ uint16(x86_xReadSlashR), + /*4201*/ uint16(x86_xArgXmm1), + /*4202*/ uint16(x86_xArgXmm2M64), + /*4203*/ uint16(x86_xMatch), + /*4204*/ uint16(x86_xSetOp), uint16(x86_CVTSS2SD), + /*4206*/ uint16(x86_xReadSlashR), + /*4207*/ uint16(x86_xArgXmm1), + /*4208*/ uint16(x86_xArgXmm2M32), + /*4209*/ uint16(x86_xMatch), + /*4210*/ uint16(x86_xCondPrefix), 3, + 0xF3, 4230, + 0x66, 4224, + 0x0, 4218, + /*4218*/ uint16(x86_xSetOp), uint16(x86_CVTDQ2PS), + /*4220*/ uint16(x86_xReadSlashR), + /*4221*/ uint16(x86_xArgXmm1), + /*4222*/ uint16(x86_xArgXmm2M128), + /*4223*/ uint16(x86_xMatch), + /*4224*/ uint16(x86_xSetOp), uint16(x86_CVTPS2DQ), + /*4226*/ uint16(x86_xReadSlashR), + /*4227*/ uint16(x86_xArgXmm1), + /*4228*/ uint16(x86_xArgXmm2M128), + /*4229*/ uint16(x86_xMatch), + /*4230*/ uint16(x86_xSetOp), uint16(x86_CVTTPS2DQ), + /*4232*/ uint16(x86_xReadSlashR), + /*4233*/ uint16(x86_xArgXmm1), + /*4234*/ uint16(x86_xArgXmm2M128), + /*4235*/ uint16(x86_xMatch), + /*4236*/ uint16(x86_xCondPrefix), 4, + 0xF3, 4264, + 0xF2, 4258, + 0x66, 4252, + 0x0, 4246, + /*4246*/ uint16(x86_xSetOp), uint16(x86_SUBPS), + /*4248*/ uint16(x86_xReadSlashR), + /*4249*/ uint16(x86_xArgXmm1), + /*4250*/ uint16(x86_xArgXmm2M128), + /*4251*/ uint16(x86_xMatch), + /*4252*/ uint16(x86_xSetOp), uint16(x86_SUBPD), + /*4254*/ uint16(x86_xReadSlashR), + /*4255*/ uint16(x86_xArgXmm1), + /*4256*/ uint16(x86_xArgXmm2M128), + /*4257*/ uint16(x86_xMatch), + /*4258*/ uint16(x86_xSetOp), uint16(x86_SUBSD), + /*4260*/ uint16(x86_xReadSlashR), + /*4261*/ uint16(x86_xArgXmm1), + /*4262*/ uint16(x86_xArgXmm2M64), + /*4263*/ uint16(x86_xMatch), + /*4264*/ uint16(x86_xSetOp), uint16(x86_SUBSS), + /*4266*/ uint16(x86_xReadSlashR), + /*4267*/ uint16(x86_xArgXmm1), + /*4268*/ uint16(x86_xArgXmm2M32), + /*4269*/ uint16(x86_xMatch), + /*4270*/ uint16(x86_xCondPrefix), 4, + 0xF3, 4298, + 0xF2, 4292, + 0x66, 4286, + 0x0, 4280, + /*4280*/ uint16(x86_xSetOp), uint16(x86_MINPS), + /*4282*/ uint16(x86_xReadSlashR), + /*4283*/ uint16(x86_xArgXmm1), + /*4284*/ uint16(x86_xArgXmm2M128), + /*4285*/ uint16(x86_xMatch), + /*4286*/ uint16(x86_xSetOp), uint16(x86_MINPD), + /*4288*/ uint16(x86_xReadSlashR), + /*4289*/ uint16(x86_xArgXmm1), + /*4290*/ uint16(x86_xArgXmm2M128), + /*4291*/ uint16(x86_xMatch), + /*4292*/ uint16(x86_xSetOp), uint16(x86_MINSD), + /*4294*/ uint16(x86_xReadSlashR), + /*4295*/ uint16(x86_xArgXmm1), + /*4296*/ uint16(x86_xArgXmm2M64), + /*4297*/ uint16(x86_xMatch), + /*4298*/ uint16(x86_xSetOp), uint16(x86_MINSS), + /*4300*/ uint16(x86_xReadSlashR), + /*4301*/ uint16(x86_xArgXmm1), + /*4302*/ uint16(x86_xArgXmm2M32), + /*4303*/ uint16(x86_xMatch), + /*4304*/ uint16(x86_xCondPrefix), 4, + 0xF3, 4332, + 0xF2, 4326, + 0x66, 4320, + 0x0, 4314, + /*4314*/ uint16(x86_xSetOp), uint16(x86_DIVPS), + /*4316*/ uint16(x86_xReadSlashR), + /*4317*/ uint16(x86_xArgXmm1), + /*4318*/ uint16(x86_xArgXmm2M128), + /*4319*/ uint16(x86_xMatch), + /*4320*/ uint16(x86_xSetOp), uint16(x86_DIVPD), + /*4322*/ uint16(x86_xReadSlashR), + /*4323*/ uint16(x86_xArgXmm1), + /*4324*/ uint16(x86_xArgXmm2M128), + /*4325*/ uint16(x86_xMatch), + /*4326*/ uint16(x86_xSetOp), uint16(x86_DIVSD), + /*4328*/ uint16(x86_xReadSlashR), + /*4329*/ uint16(x86_xArgXmm1), + /*4330*/ uint16(x86_xArgXmm2M64), + /*4331*/ uint16(x86_xMatch), + /*4332*/ uint16(x86_xSetOp), uint16(x86_DIVSS), + /*4334*/ uint16(x86_xReadSlashR), + /*4335*/ uint16(x86_xArgXmm1), + /*4336*/ uint16(x86_xArgXmm2M32), + /*4337*/ uint16(x86_xMatch), + /*4338*/ uint16(x86_xCondPrefix), 4, + 0xF3, 4366, + 0xF2, 4360, + 0x66, 4354, + 0x0, 4348, + /*4348*/ uint16(x86_xSetOp), uint16(x86_MAXPS), + /*4350*/ uint16(x86_xReadSlashR), + /*4351*/ uint16(x86_xArgXmm1), + /*4352*/ uint16(x86_xArgXmm2M128), + /*4353*/ uint16(x86_xMatch), + /*4354*/ uint16(x86_xSetOp), uint16(x86_MAXPD), + /*4356*/ uint16(x86_xReadSlashR), + /*4357*/ uint16(x86_xArgXmm1), + /*4358*/ uint16(x86_xArgXmm2M128), + /*4359*/ uint16(x86_xMatch), + /*4360*/ uint16(x86_xSetOp), uint16(x86_MAXSD), + /*4362*/ uint16(x86_xReadSlashR), + /*4363*/ uint16(x86_xArgXmm1), + /*4364*/ uint16(x86_xArgXmm2M64), + /*4365*/ uint16(x86_xMatch), + /*4366*/ uint16(x86_xSetOp), uint16(x86_MAXSS), + /*4368*/ uint16(x86_xReadSlashR), + /*4369*/ uint16(x86_xArgXmm1), + /*4370*/ uint16(x86_xArgXmm2M32), + /*4371*/ uint16(x86_xMatch), + /*4372*/ uint16(x86_xCondPrefix), 2, + 0x66, 4384, + 0x0, 4378, + /*4378*/ uint16(x86_xSetOp), uint16(x86_PUNPCKLBW), + /*4380*/ uint16(x86_xReadSlashR), + /*4381*/ uint16(x86_xArgMm), + /*4382*/ uint16(x86_xArgMmM32), + /*4383*/ uint16(x86_xMatch), + /*4384*/ uint16(x86_xSetOp), uint16(x86_PUNPCKLBW), + /*4386*/ uint16(x86_xReadSlashR), + /*4387*/ uint16(x86_xArgXmm1), + /*4388*/ uint16(x86_xArgXmm2M128), + /*4389*/ uint16(x86_xMatch), + /*4390*/ uint16(x86_xCondPrefix), 2, + 0x66, 4402, + 0x0, 4396, + /*4396*/ uint16(x86_xSetOp), uint16(x86_PUNPCKLWD), + /*4398*/ uint16(x86_xReadSlashR), + /*4399*/ uint16(x86_xArgMm), + /*4400*/ uint16(x86_xArgMmM32), + /*4401*/ uint16(x86_xMatch), + /*4402*/ uint16(x86_xSetOp), uint16(x86_PUNPCKLWD), + /*4404*/ uint16(x86_xReadSlashR), + /*4405*/ uint16(x86_xArgXmm1), + /*4406*/ uint16(x86_xArgXmm2M128), + /*4407*/ uint16(x86_xMatch), + /*4408*/ uint16(x86_xCondPrefix), 2, + 0x66, 4420, + 0x0, 4414, + /*4414*/ uint16(x86_xSetOp), uint16(x86_PUNPCKLDQ), + /*4416*/ uint16(x86_xReadSlashR), + /*4417*/ uint16(x86_xArgMm), + /*4418*/ uint16(x86_xArgMmM32), + /*4419*/ uint16(x86_xMatch), + /*4420*/ uint16(x86_xSetOp), uint16(x86_PUNPCKLDQ), + /*4422*/ uint16(x86_xReadSlashR), + /*4423*/ uint16(x86_xArgXmm1), + /*4424*/ uint16(x86_xArgXmm2M128), + /*4425*/ uint16(x86_xMatch), + /*4426*/ uint16(x86_xCondPrefix), 2, + 0x66, 4438, + 0x0, 4432, + /*4432*/ uint16(x86_xSetOp), uint16(x86_PACKSSWB), + /*4434*/ uint16(x86_xReadSlashR), + /*4435*/ uint16(x86_xArgMm1), + /*4436*/ uint16(x86_xArgMm2M64), + /*4437*/ uint16(x86_xMatch), + /*4438*/ uint16(x86_xSetOp), uint16(x86_PACKSSWB), + /*4440*/ uint16(x86_xReadSlashR), + /*4441*/ uint16(x86_xArgXmm1), + /*4442*/ uint16(x86_xArgXmm2M128), + /*4443*/ uint16(x86_xMatch), + /*4444*/ uint16(x86_xCondPrefix), 2, + 0x66, 4456, + 0x0, 4450, + /*4450*/ uint16(x86_xSetOp), uint16(x86_PCMPGTB), + /*4452*/ uint16(x86_xReadSlashR), + /*4453*/ uint16(x86_xArgMm), + /*4454*/ uint16(x86_xArgMmM64), + /*4455*/ uint16(x86_xMatch), + /*4456*/ uint16(x86_xSetOp), uint16(x86_PCMPGTB), + /*4458*/ uint16(x86_xReadSlashR), + /*4459*/ uint16(x86_xArgXmm1), + /*4460*/ uint16(x86_xArgXmm2M128), + /*4461*/ uint16(x86_xMatch), + /*4462*/ uint16(x86_xCondPrefix), 2, + 0x66, 4474, + 0x0, 4468, + /*4468*/ uint16(x86_xSetOp), uint16(x86_PCMPGTW), + /*4470*/ uint16(x86_xReadSlashR), + /*4471*/ uint16(x86_xArgMm), + /*4472*/ uint16(x86_xArgMmM64), + /*4473*/ uint16(x86_xMatch), + /*4474*/ uint16(x86_xSetOp), uint16(x86_PCMPGTW), + /*4476*/ uint16(x86_xReadSlashR), + /*4477*/ uint16(x86_xArgXmm1), + /*4478*/ uint16(x86_xArgXmm2M128), + /*4479*/ uint16(x86_xMatch), + /*4480*/ uint16(x86_xCondPrefix), 2, + 0x66, 4492, + 0x0, 4486, + /*4486*/ uint16(x86_xSetOp), uint16(x86_PCMPGTD), + /*4488*/ uint16(x86_xReadSlashR), + /*4489*/ uint16(x86_xArgMm), + /*4490*/ uint16(x86_xArgMmM64), + /*4491*/ uint16(x86_xMatch), + /*4492*/ uint16(x86_xSetOp), uint16(x86_PCMPGTD), + /*4494*/ uint16(x86_xReadSlashR), + /*4495*/ uint16(x86_xArgXmm1), + /*4496*/ uint16(x86_xArgXmm2M128), + /*4497*/ uint16(x86_xMatch), + /*4498*/ uint16(x86_xCondPrefix), 2, + 0x66, 4510, + 0x0, 4504, + /*4504*/ uint16(x86_xSetOp), uint16(x86_PACKUSWB), + /*4506*/ uint16(x86_xReadSlashR), + /*4507*/ uint16(x86_xArgMm), + /*4508*/ uint16(x86_xArgMmM64), + /*4509*/ uint16(x86_xMatch), + /*4510*/ uint16(x86_xSetOp), uint16(x86_PACKUSWB), + /*4512*/ uint16(x86_xReadSlashR), + /*4513*/ uint16(x86_xArgXmm1), + /*4514*/ uint16(x86_xArgXmm2M128), + /*4515*/ uint16(x86_xMatch), + /*4516*/ uint16(x86_xCondPrefix), 2, + 0x66, 4528, + 0x0, 4522, + /*4522*/ uint16(x86_xSetOp), uint16(x86_PUNPCKHBW), + /*4524*/ uint16(x86_xReadSlashR), + /*4525*/ uint16(x86_xArgMm), + /*4526*/ uint16(x86_xArgMmM64), + /*4527*/ uint16(x86_xMatch), + /*4528*/ uint16(x86_xSetOp), uint16(x86_PUNPCKHBW), + /*4530*/ uint16(x86_xReadSlashR), + /*4531*/ uint16(x86_xArgXmm1), + /*4532*/ uint16(x86_xArgXmm2M128), + /*4533*/ uint16(x86_xMatch), + /*4534*/ uint16(x86_xCondPrefix), 2, + 0x66, 4546, + 0x0, 4540, + /*4540*/ uint16(x86_xSetOp), uint16(x86_PUNPCKHWD), + /*4542*/ uint16(x86_xReadSlashR), + /*4543*/ uint16(x86_xArgMm), + /*4544*/ uint16(x86_xArgMmM64), + /*4545*/ uint16(x86_xMatch), + /*4546*/ uint16(x86_xSetOp), uint16(x86_PUNPCKHWD), + /*4548*/ uint16(x86_xReadSlashR), + /*4549*/ uint16(x86_xArgXmm1), + /*4550*/ uint16(x86_xArgXmm2M128), + /*4551*/ uint16(x86_xMatch), + /*4552*/ uint16(x86_xCondPrefix), 2, + 0x66, 4564, + 0x0, 4558, + /*4558*/ uint16(x86_xSetOp), uint16(x86_PUNPCKHDQ), + /*4560*/ uint16(x86_xReadSlashR), + /*4561*/ uint16(x86_xArgMm), + /*4562*/ uint16(x86_xArgMmM64), + /*4563*/ uint16(x86_xMatch), + /*4564*/ uint16(x86_xSetOp), uint16(x86_PUNPCKHDQ), + /*4566*/ uint16(x86_xReadSlashR), + /*4567*/ uint16(x86_xArgXmm1), + /*4568*/ uint16(x86_xArgXmm2M128), + /*4569*/ uint16(x86_xMatch), + /*4570*/ uint16(x86_xCondPrefix), 2, + 0x66, 4582, + 0x0, 4576, + /*4576*/ uint16(x86_xSetOp), uint16(x86_PACKSSDW), + /*4578*/ uint16(x86_xReadSlashR), + /*4579*/ uint16(x86_xArgMm1), + /*4580*/ uint16(x86_xArgMm2M64), + /*4581*/ uint16(x86_xMatch), + /*4582*/ uint16(x86_xSetOp), uint16(x86_PACKSSDW), + /*4584*/ uint16(x86_xReadSlashR), + /*4585*/ uint16(x86_xArgXmm1), + /*4586*/ uint16(x86_xArgXmm2M128), + /*4587*/ uint16(x86_xMatch), + /*4588*/ uint16(x86_xCondPrefix), 1, + 0x66, 4592, + /*4592*/ uint16(x86_xSetOp), uint16(x86_PUNPCKLQDQ), + /*4594*/ uint16(x86_xReadSlashR), + /*4595*/ uint16(x86_xArgXmm1), + /*4596*/ uint16(x86_xArgXmm2M128), + /*4597*/ uint16(x86_xMatch), + /*4598*/ uint16(x86_xCondPrefix), 1, + 0x66, 4602, + /*4602*/ uint16(x86_xSetOp), uint16(x86_PUNPCKHQDQ), + /*4604*/ uint16(x86_xReadSlashR), + /*4605*/ uint16(x86_xArgXmm1), + /*4606*/ uint16(x86_xArgXmm2M128), + /*4607*/ uint16(x86_xMatch), + /*4608*/ uint16(x86_xCondIs64), 4611, 4649, + /*4611*/ uint16(x86_xCondPrefix), 2, + 0x66, 4633, + 0x0, 4617, + /*4617*/ uint16(x86_xCondDataSize), 4621, 4627, 0, + /*4621*/ uint16(x86_xSetOp), uint16(x86_MOVD), + /*4623*/ uint16(x86_xReadSlashR), + /*4624*/ uint16(x86_xArgMm), + /*4625*/ uint16(x86_xArgRM32), + /*4626*/ uint16(x86_xMatch), + /*4627*/ uint16(x86_xSetOp), uint16(x86_MOVD), + /*4629*/ uint16(x86_xReadSlashR), + /*4630*/ uint16(x86_xArgMm), + /*4631*/ uint16(x86_xArgRM32), + /*4632*/ uint16(x86_xMatch), + /*4633*/ uint16(x86_xCondDataSize), 4637, 4643, 0, + /*4637*/ uint16(x86_xSetOp), uint16(x86_MOVD), + /*4639*/ uint16(x86_xReadSlashR), + /*4640*/ uint16(x86_xArgXmm), + /*4641*/ uint16(x86_xArgRM32), + /*4642*/ uint16(x86_xMatch), + /*4643*/ uint16(x86_xSetOp), uint16(x86_MOVD), + /*4645*/ uint16(x86_xReadSlashR), + /*4646*/ uint16(x86_xArgXmm), + /*4647*/ uint16(x86_xArgRM32), + /*4648*/ uint16(x86_xMatch), + /*4649*/ uint16(x86_xCondPrefix), 2, + 0x66, 4665, + 0x0, 4655, + /*4655*/ uint16(x86_xCondDataSize), 4621, 4627, 4659, + /*4659*/ uint16(x86_xSetOp), uint16(x86_MOVQ), + /*4661*/ uint16(x86_xReadSlashR), + /*4662*/ uint16(x86_xArgMm), + /*4663*/ uint16(x86_xArgRM64), + /*4664*/ uint16(x86_xMatch), + /*4665*/ uint16(x86_xCondDataSize), 4637, 4643, 4669, + /*4669*/ uint16(x86_xSetOp), uint16(x86_MOVQ), + /*4671*/ uint16(x86_xReadSlashR), + /*4672*/ uint16(x86_xArgXmm), + /*4673*/ uint16(x86_xArgRM64), + /*4674*/ uint16(x86_xMatch), + /*4675*/ uint16(x86_xCondPrefix), 3, + 0xF3, 4695, + 0x66, 4689, + 0x0, 4683, + /*4683*/ uint16(x86_xSetOp), uint16(x86_MOVQ), + /*4685*/ uint16(x86_xReadSlashR), + /*4686*/ uint16(x86_xArgMm), + /*4687*/ uint16(x86_xArgMmM64), + /*4688*/ uint16(x86_xMatch), + /*4689*/ uint16(x86_xSetOp), uint16(x86_MOVDQA), + /*4691*/ uint16(x86_xReadSlashR), + /*4692*/ uint16(x86_xArgXmm1), + /*4693*/ uint16(x86_xArgXmm2M128), + /*4694*/ uint16(x86_xMatch), + /*4695*/ uint16(x86_xSetOp), uint16(x86_MOVDQU), + /*4697*/ uint16(x86_xReadSlashR), + /*4698*/ uint16(x86_xArgXmm1), + /*4699*/ uint16(x86_xArgXmm2M128), + /*4700*/ uint16(x86_xMatch), + /*4701*/ uint16(x86_xCondPrefix), 4, + 0xF3, 4735, + 0xF2, 4727, + 0x66, 4719, + 0x0, 4711, + /*4711*/ uint16(x86_xSetOp), uint16(x86_PSHUFW), + /*4713*/ uint16(x86_xReadSlashR), + /*4714*/ uint16(x86_xReadIb), + /*4715*/ uint16(x86_xArgMm1), + /*4716*/ uint16(x86_xArgMm2M64), + /*4717*/ uint16(x86_xArgImm8u), + /*4718*/ uint16(x86_xMatch), + /*4719*/ uint16(x86_xSetOp), uint16(x86_PSHUFD), + /*4721*/ uint16(x86_xReadSlashR), + /*4722*/ uint16(x86_xReadIb), + /*4723*/ uint16(x86_xArgXmm1), + /*4724*/ uint16(x86_xArgXmm2M128), + /*4725*/ uint16(x86_xArgImm8u), + /*4726*/ uint16(x86_xMatch), + /*4727*/ uint16(x86_xSetOp), uint16(x86_PSHUFLW), + /*4729*/ uint16(x86_xReadSlashR), + /*4730*/ uint16(x86_xReadIb), + /*4731*/ uint16(x86_xArgXmm1), + /*4732*/ uint16(x86_xArgXmm2M128), + /*4733*/ uint16(x86_xArgImm8u), + /*4734*/ uint16(x86_xMatch), + /*4735*/ uint16(x86_xSetOp), uint16(x86_PSHUFHW), + /*4737*/ uint16(x86_xReadSlashR), + /*4738*/ uint16(x86_xReadIb), + /*4739*/ uint16(x86_xArgXmm1), + /*4740*/ uint16(x86_xArgXmm2M128), + /*4741*/ uint16(x86_xArgImm8u), + /*4742*/ uint16(x86_xMatch), + /*4743*/ uint16(x86_xCondSlashR), + 0, // 0 + 0, // 1 + 4752, // 2 + 0, // 3 + 4770, // 4 + 0, // 5 + 4788, // 6 + 0, // 7 + /*4752*/ uint16(x86_xCondPrefix), 2, + 0x66, 4764, + 0x0, 4758, + /*4758*/ uint16(x86_xSetOp), uint16(x86_PSRLW), + /*4760*/ uint16(x86_xReadIb), + /*4761*/ uint16(x86_xArgMm2), + /*4762*/ uint16(x86_xArgImm8u), + /*4763*/ uint16(x86_xMatch), + /*4764*/ uint16(x86_xSetOp), uint16(x86_PSRLW), + /*4766*/ uint16(x86_xReadIb), + /*4767*/ uint16(x86_xArgXmm2), + /*4768*/ uint16(x86_xArgImm8u), + /*4769*/ uint16(x86_xMatch), + /*4770*/ uint16(x86_xCondPrefix), 2, + 0x66, 4782, + 0x0, 4776, + /*4776*/ uint16(x86_xSetOp), uint16(x86_PSRAW), + /*4778*/ uint16(x86_xReadIb), + /*4779*/ uint16(x86_xArgMm2), + /*4780*/ uint16(x86_xArgImm8u), + /*4781*/ uint16(x86_xMatch), + /*4782*/ uint16(x86_xSetOp), uint16(x86_PSRAW), + /*4784*/ uint16(x86_xReadIb), + /*4785*/ uint16(x86_xArgXmm2), + /*4786*/ uint16(x86_xArgImm8u), + /*4787*/ uint16(x86_xMatch), + /*4788*/ uint16(x86_xCondPrefix), 2, + 0x66, 4800, + 0x0, 4794, + /*4794*/ uint16(x86_xSetOp), uint16(x86_PSLLW), + /*4796*/ uint16(x86_xReadIb), + /*4797*/ uint16(x86_xArgMm2), + /*4798*/ uint16(x86_xArgImm8u), + /*4799*/ uint16(x86_xMatch), + /*4800*/ uint16(x86_xSetOp), uint16(x86_PSLLW), + /*4802*/ uint16(x86_xReadIb), + /*4803*/ uint16(x86_xArgXmm2), + /*4804*/ uint16(x86_xArgImm8u), + /*4805*/ uint16(x86_xMatch), + /*4806*/ uint16(x86_xCondSlashR), + 0, // 0 + 0, // 1 + 4815, // 2 + 0, // 3 + 4833, // 4 + 0, // 5 + 4851, // 6 + 0, // 7 + /*4815*/ uint16(x86_xCondPrefix), 2, + 0x66, 4827, + 0x0, 4821, + /*4821*/ uint16(x86_xSetOp), uint16(x86_PSRLD), + /*4823*/ uint16(x86_xReadIb), + /*4824*/ uint16(x86_xArgMm2), + /*4825*/ uint16(x86_xArgImm8u), + /*4826*/ uint16(x86_xMatch), + /*4827*/ uint16(x86_xSetOp), uint16(x86_PSRLD), + /*4829*/ uint16(x86_xReadIb), + /*4830*/ uint16(x86_xArgXmm2), + /*4831*/ uint16(x86_xArgImm8u), + /*4832*/ uint16(x86_xMatch), + /*4833*/ uint16(x86_xCondPrefix), 2, + 0x66, 4845, + 0x0, 4839, + /*4839*/ uint16(x86_xSetOp), uint16(x86_PSRAD), + /*4841*/ uint16(x86_xReadIb), + /*4842*/ uint16(x86_xArgMm2), + /*4843*/ uint16(x86_xArgImm8u), + /*4844*/ uint16(x86_xMatch), + /*4845*/ uint16(x86_xSetOp), uint16(x86_PSRAD), + /*4847*/ uint16(x86_xReadIb), + /*4848*/ uint16(x86_xArgXmm2), + /*4849*/ uint16(x86_xArgImm8u), + /*4850*/ uint16(x86_xMatch), + /*4851*/ uint16(x86_xCondPrefix), 2, + 0x66, 4863, + 0x0, 4857, + /*4857*/ uint16(x86_xSetOp), uint16(x86_PSLLD), + /*4859*/ uint16(x86_xReadIb), + /*4860*/ uint16(x86_xArgMm2), + /*4861*/ uint16(x86_xArgImm8u), + /*4862*/ uint16(x86_xMatch), + /*4863*/ uint16(x86_xSetOp), uint16(x86_PSLLD), + /*4865*/ uint16(x86_xReadIb), + /*4866*/ uint16(x86_xArgXmm2), + /*4867*/ uint16(x86_xArgImm8u), + /*4868*/ uint16(x86_xMatch), + /*4869*/ uint16(x86_xCondSlashR), + 0, // 0 + 0, // 1 + 4878, // 2 + 4896, // 3 + 0, // 4 + 0, // 5 + 4906, // 6 + 4924, // 7 + /*4878*/ uint16(x86_xCondPrefix), 2, + 0x66, 4890, + 0x0, 4884, + /*4884*/ uint16(x86_xSetOp), uint16(x86_PSRLQ), + /*4886*/ uint16(x86_xReadIb), + /*4887*/ uint16(x86_xArgMm2), + /*4888*/ uint16(x86_xArgImm8u), + /*4889*/ uint16(x86_xMatch), + /*4890*/ uint16(x86_xSetOp), uint16(x86_PSRLQ), + /*4892*/ uint16(x86_xReadIb), + /*4893*/ uint16(x86_xArgXmm2), + /*4894*/ uint16(x86_xArgImm8u), + /*4895*/ uint16(x86_xMatch), + /*4896*/ uint16(x86_xCondPrefix), 1, + 0x66, 4900, + /*4900*/ uint16(x86_xSetOp), uint16(x86_PSRLDQ), + /*4902*/ uint16(x86_xReadIb), + /*4903*/ uint16(x86_xArgXmm2), + /*4904*/ uint16(x86_xArgImm8u), + /*4905*/ uint16(x86_xMatch), + /*4906*/ uint16(x86_xCondPrefix), 2, + 0x66, 4918, + 0x0, 4912, + /*4912*/ uint16(x86_xSetOp), uint16(x86_PSLLQ), + /*4914*/ uint16(x86_xReadIb), + /*4915*/ uint16(x86_xArgMm2), + /*4916*/ uint16(x86_xArgImm8u), + /*4917*/ uint16(x86_xMatch), + /*4918*/ uint16(x86_xSetOp), uint16(x86_PSLLQ), + /*4920*/ uint16(x86_xReadIb), + /*4921*/ uint16(x86_xArgXmm2), + /*4922*/ uint16(x86_xArgImm8u), + /*4923*/ uint16(x86_xMatch), + /*4924*/ uint16(x86_xCondPrefix), 1, + 0x66, 4928, + /*4928*/ uint16(x86_xSetOp), uint16(x86_PSLLDQ), + /*4930*/ uint16(x86_xReadIb), + /*4931*/ uint16(x86_xArgXmm2), + /*4932*/ uint16(x86_xArgImm8u), + /*4933*/ uint16(x86_xMatch), + /*4934*/ uint16(x86_xCondPrefix), 2, + 0x66, 4946, + 0x0, 4940, + /*4940*/ uint16(x86_xSetOp), uint16(x86_PCMPEQB), + /*4942*/ uint16(x86_xReadSlashR), + /*4943*/ uint16(x86_xArgMm), + /*4944*/ uint16(x86_xArgMmM64), + /*4945*/ uint16(x86_xMatch), + /*4946*/ uint16(x86_xSetOp), uint16(x86_PCMPEQB), + /*4948*/ uint16(x86_xReadSlashR), + /*4949*/ uint16(x86_xArgXmm1), + /*4950*/ uint16(x86_xArgXmm2M128), + /*4951*/ uint16(x86_xMatch), + /*4952*/ uint16(x86_xCondPrefix), 2, + 0x66, 4964, + 0x0, 4958, + /*4958*/ uint16(x86_xSetOp), uint16(x86_PCMPEQW), + /*4960*/ uint16(x86_xReadSlashR), + /*4961*/ uint16(x86_xArgMm), + /*4962*/ uint16(x86_xArgMmM64), + /*4963*/ uint16(x86_xMatch), + /*4964*/ uint16(x86_xSetOp), uint16(x86_PCMPEQW), + /*4966*/ uint16(x86_xReadSlashR), + /*4967*/ uint16(x86_xArgXmm1), + /*4968*/ uint16(x86_xArgXmm2M128), + /*4969*/ uint16(x86_xMatch), + /*4970*/ uint16(x86_xCondPrefix), 2, + 0x66, 4982, + 0x0, 4976, + /*4976*/ uint16(x86_xSetOp), uint16(x86_PCMPEQD), + /*4978*/ uint16(x86_xReadSlashR), + /*4979*/ uint16(x86_xArgMm), + /*4980*/ uint16(x86_xArgMmM64), + /*4981*/ uint16(x86_xMatch), + /*4982*/ uint16(x86_xSetOp), uint16(x86_PCMPEQD), + /*4984*/ uint16(x86_xReadSlashR), + /*4985*/ uint16(x86_xArgXmm1), + /*4986*/ uint16(x86_xArgXmm2M128), + /*4987*/ uint16(x86_xMatch), + /*4988*/ uint16(x86_xSetOp), uint16(x86_EMMS), + /*4990*/ uint16(x86_xMatch), + /*4991*/ uint16(x86_xCondPrefix), 2, + 0xF2, 5003, + 0x66, 4997, + /*4997*/ uint16(x86_xSetOp), uint16(x86_HADDPD), + /*4999*/ uint16(x86_xReadSlashR), + /*5000*/ uint16(x86_xArgXmm1), + /*5001*/ uint16(x86_xArgXmm2M128), + /*5002*/ uint16(x86_xMatch), + /*5003*/ uint16(x86_xSetOp), uint16(x86_HADDPS), + /*5005*/ uint16(x86_xReadSlashR), + /*5006*/ uint16(x86_xArgXmm1), + /*5007*/ uint16(x86_xArgXmm2M128), + /*5008*/ uint16(x86_xMatch), + /*5009*/ uint16(x86_xCondPrefix), 2, + 0xF2, 5021, + 0x66, 5015, + /*5015*/ uint16(x86_xSetOp), uint16(x86_HSUBPD), + /*5017*/ uint16(x86_xReadSlashR), + /*5018*/ uint16(x86_xArgXmm1), + /*5019*/ uint16(x86_xArgXmm2M128), + /*5020*/ uint16(x86_xMatch), + /*5021*/ uint16(x86_xSetOp), uint16(x86_HSUBPS), + /*5023*/ uint16(x86_xReadSlashR), + /*5024*/ uint16(x86_xArgXmm1), + /*5025*/ uint16(x86_xArgXmm2M128), + /*5026*/ uint16(x86_xMatch), + /*5027*/ uint16(x86_xCondIs64), 5030, 5076, + /*5030*/ uint16(x86_xCondPrefix), 3, + 0xF3, 5070, + 0x66, 5054, + 0x0, 5038, + /*5038*/ uint16(x86_xCondDataSize), 5042, 5048, 0, + /*5042*/ uint16(x86_xSetOp), uint16(x86_MOVD), + /*5044*/ uint16(x86_xReadSlashR), + /*5045*/ uint16(x86_xArgRM32), + /*5046*/ uint16(x86_xArgMm), + /*5047*/ uint16(x86_xMatch), + /*5048*/ uint16(x86_xSetOp), uint16(x86_MOVD), + /*5050*/ uint16(x86_xReadSlashR), + /*5051*/ uint16(x86_xArgRM32), + /*5052*/ uint16(x86_xArgMm), + /*5053*/ uint16(x86_xMatch), + /*5054*/ uint16(x86_xCondDataSize), 5058, 5064, 0, + /*5058*/ uint16(x86_xSetOp), uint16(x86_MOVD), + /*5060*/ uint16(x86_xReadSlashR), + /*5061*/ uint16(x86_xArgRM32), + /*5062*/ uint16(x86_xArgXmm), + /*5063*/ uint16(x86_xMatch), + /*5064*/ uint16(x86_xSetOp), uint16(x86_MOVD), + /*5066*/ uint16(x86_xReadSlashR), + /*5067*/ uint16(x86_xArgRM32), + /*5068*/ uint16(x86_xArgXmm), + /*5069*/ uint16(x86_xMatch), + /*5070*/ uint16(x86_xSetOp), uint16(x86_MOVQ), + /*5072*/ uint16(x86_xReadSlashR), + /*5073*/ uint16(x86_xArgXmm1), + /*5074*/ uint16(x86_xArgXmm2M64), + /*5075*/ uint16(x86_xMatch), + /*5076*/ uint16(x86_xCondPrefix), 3, + 0xF3, 5070, + 0x66, 5094, + 0x0, 5084, + /*5084*/ uint16(x86_xCondDataSize), 5042, 5048, 5088, + /*5088*/ uint16(x86_xSetOp), uint16(x86_MOVQ), + /*5090*/ uint16(x86_xReadSlashR), + /*5091*/ uint16(x86_xArgRM64), + /*5092*/ uint16(x86_xArgMm), + /*5093*/ uint16(x86_xMatch), + /*5094*/ uint16(x86_xCondDataSize), 5058, 5064, 5098, + /*5098*/ uint16(x86_xSetOp), uint16(x86_MOVQ), + /*5100*/ uint16(x86_xReadSlashR), + /*5101*/ uint16(x86_xArgRM64), + /*5102*/ uint16(x86_xArgXmm), + /*5103*/ uint16(x86_xMatch), + /*5104*/ uint16(x86_xCondPrefix), 3, + 0xF3, 5124, + 0x66, 5118, + 0x0, 5112, + /*5112*/ uint16(x86_xSetOp), uint16(x86_MOVQ), + /*5114*/ uint16(x86_xReadSlashR), + /*5115*/ uint16(x86_xArgMmM64), + /*5116*/ uint16(x86_xArgMm), + /*5117*/ uint16(x86_xMatch), + /*5118*/ uint16(x86_xSetOp), uint16(x86_MOVDQA), + /*5120*/ uint16(x86_xReadSlashR), + /*5121*/ uint16(x86_xArgXmm2M128), + /*5122*/ uint16(x86_xArgXmm1), + /*5123*/ uint16(x86_xMatch), + /*5124*/ uint16(x86_xSetOp), uint16(x86_MOVDQU), + /*5126*/ uint16(x86_xReadSlashR), + /*5127*/ uint16(x86_xArgXmm2M128), + /*5128*/ uint16(x86_xArgXmm1), + /*5129*/ uint16(x86_xMatch), + /*5130*/ uint16(x86_xCondIs64), 5133, 5147, + /*5133*/ uint16(x86_xCondDataSize), 5137, 5142, 0, + /*5137*/ uint16(x86_xSetOp), uint16(x86_JO), + /*5139*/ uint16(x86_xReadCw), + /*5140*/ uint16(x86_xArgRel16), + /*5141*/ uint16(x86_xMatch), + /*5142*/ uint16(x86_xSetOp), uint16(x86_JO), + /*5144*/ uint16(x86_xReadCd), + /*5145*/ uint16(x86_xArgRel32), + /*5146*/ uint16(x86_xMatch), + /*5147*/ uint16(x86_xCondDataSize), 5151, 5142, 5156, + /*5151*/ uint16(x86_xSetOp), uint16(x86_JO), + /*5153*/ uint16(x86_xReadCd), + /*5154*/ uint16(x86_xArgRel32), + /*5155*/ uint16(x86_xMatch), + /*5156*/ uint16(x86_xSetOp), uint16(x86_JO), + /*5158*/ uint16(x86_xReadCd), + /*5159*/ uint16(x86_xArgRel32), + /*5160*/ uint16(x86_xMatch), + /*5161*/ uint16(x86_xCondIs64), 5164, 5178, + /*5164*/ uint16(x86_xCondDataSize), 5168, 5173, 0, + /*5168*/ uint16(x86_xSetOp), uint16(x86_JNO), + /*5170*/ uint16(x86_xReadCw), + /*5171*/ uint16(x86_xArgRel16), + /*5172*/ uint16(x86_xMatch), + /*5173*/ uint16(x86_xSetOp), uint16(x86_JNO), + /*5175*/ uint16(x86_xReadCd), + /*5176*/ uint16(x86_xArgRel32), + /*5177*/ uint16(x86_xMatch), + /*5178*/ uint16(x86_xCondDataSize), 5182, 5173, 5187, + /*5182*/ uint16(x86_xSetOp), uint16(x86_JNO), + /*5184*/ uint16(x86_xReadCd), + /*5185*/ uint16(x86_xArgRel32), + /*5186*/ uint16(x86_xMatch), + /*5187*/ uint16(x86_xSetOp), uint16(x86_JNO), + /*5189*/ uint16(x86_xReadCd), + /*5190*/ uint16(x86_xArgRel32), + /*5191*/ uint16(x86_xMatch), + /*5192*/ uint16(x86_xCondIs64), 5195, 5209, + /*5195*/ uint16(x86_xCondDataSize), 5199, 5204, 0, + /*5199*/ uint16(x86_xSetOp), uint16(x86_JB), + /*5201*/ uint16(x86_xReadCw), + /*5202*/ uint16(x86_xArgRel16), + /*5203*/ uint16(x86_xMatch), + /*5204*/ uint16(x86_xSetOp), uint16(x86_JB), + /*5206*/ uint16(x86_xReadCd), + /*5207*/ uint16(x86_xArgRel32), + /*5208*/ uint16(x86_xMatch), + /*5209*/ uint16(x86_xCondDataSize), 5213, 5204, 5218, + /*5213*/ uint16(x86_xSetOp), uint16(x86_JB), + /*5215*/ uint16(x86_xReadCd), + /*5216*/ uint16(x86_xArgRel32), + /*5217*/ uint16(x86_xMatch), + /*5218*/ uint16(x86_xSetOp), uint16(x86_JB), + /*5220*/ uint16(x86_xReadCd), + /*5221*/ uint16(x86_xArgRel32), + /*5222*/ uint16(x86_xMatch), + /*5223*/ uint16(x86_xCondIs64), 5226, 5240, + /*5226*/ uint16(x86_xCondDataSize), 5230, 5235, 0, + /*5230*/ uint16(x86_xSetOp), uint16(x86_JAE), + /*5232*/ uint16(x86_xReadCw), + /*5233*/ uint16(x86_xArgRel16), + /*5234*/ uint16(x86_xMatch), + /*5235*/ uint16(x86_xSetOp), uint16(x86_JAE), + /*5237*/ uint16(x86_xReadCd), + /*5238*/ uint16(x86_xArgRel32), + /*5239*/ uint16(x86_xMatch), + /*5240*/ uint16(x86_xCondDataSize), 5244, 5235, 5249, + /*5244*/ uint16(x86_xSetOp), uint16(x86_JAE), + /*5246*/ uint16(x86_xReadCd), + /*5247*/ uint16(x86_xArgRel32), + /*5248*/ uint16(x86_xMatch), + /*5249*/ uint16(x86_xSetOp), uint16(x86_JAE), + /*5251*/ uint16(x86_xReadCd), + /*5252*/ uint16(x86_xArgRel32), + /*5253*/ uint16(x86_xMatch), + /*5254*/ uint16(x86_xCondIs64), 5257, 5271, + /*5257*/ uint16(x86_xCondDataSize), 5261, 5266, 0, + /*5261*/ uint16(x86_xSetOp), uint16(x86_JE), + /*5263*/ uint16(x86_xReadCw), + /*5264*/ uint16(x86_xArgRel16), + /*5265*/ uint16(x86_xMatch), + /*5266*/ uint16(x86_xSetOp), uint16(x86_JE), + /*5268*/ uint16(x86_xReadCd), + /*5269*/ uint16(x86_xArgRel32), + /*5270*/ uint16(x86_xMatch), + /*5271*/ uint16(x86_xCondDataSize), 5275, 5266, 5280, + /*5275*/ uint16(x86_xSetOp), uint16(x86_JE), + /*5277*/ uint16(x86_xReadCd), + /*5278*/ uint16(x86_xArgRel32), + /*5279*/ uint16(x86_xMatch), + /*5280*/ uint16(x86_xSetOp), uint16(x86_JE), + /*5282*/ uint16(x86_xReadCd), + /*5283*/ uint16(x86_xArgRel32), + /*5284*/ uint16(x86_xMatch), + /*5285*/ uint16(x86_xCondIs64), 5288, 5302, + /*5288*/ uint16(x86_xCondDataSize), 5292, 5297, 0, + /*5292*/ uint16(x86_xSetOp), uint16(x86_JNE), + /*5294*/ uint16(x86_xReadCw), + /*5295*/ uint16(x86_xArgRel16), + /*5296*/ uint16(x86_xMatch), + /*5297*/ uint16(x86_xSetOp), uint16(x86_JNE), + /*5299*/ uint16(x86_xReadCd), + /*5300*/ uint16(x86_xArgRel32), + /*5301*/ uint16(x86_xMatch), + /*5302*/ uint16(x86_xCondDataSize), 5306, 5297, 5311, + /*5306*/ uint16(x86_xSetOp), uint16(x86_JNE), + /*5308*/ uint16(x86_xReadCd), + /*5309*/ uint16(x86_xArgRel32), + /*5310*/ uint16(x86_xMatch), + /*5311*/ uint16(x86_xSetOp), uint16(x86_JNE), + /*5313*/ uint16(x86_xReadCd), + /*5314*/ uint16(x86_xArgRel32), + /*5315*/ uint16(x86_xMatch), + /*5316*/ uint16(x86_xCondIs64), 5319, 5333, + /*5319*/ uint16(x86_xCondDataSize), 5323, 5328, 0, + /*5323*/ uint16(x86_xSetOp), uint16(x86_JBE), + /*5325*/ uint16(x86_xReadCw), + /*5326*/ uint16(x86_xArgRel16), + /*5327*/ uint16(x86_xMatch), + /*5328*/ uint16(x86_xSetOp), uint16(x86_JBE), + /*5330*/ uint16(x86_xReadCd), + /*5331*/ uint16(x86_xArgRel32), + /*5332*/ uint16(x86_xMatch), + /*5333*/ uint16(x86_xCondDataSize), 5337, 5328, 5342, + /*5337*/ uint16(x86_xSetOp), uint16(x86_JBE), + /*5339*/ uint16(x86_xReadCd), + /*5340*/ uint16(x86_xArgRel32), + /*5341*/ uint16(x86_xMatch), + /*5342*/ uint16(x86_xSetOp), uint16(x86_JBE), + /*5344*/ uint16(x86_xReadCd), + /*5345*/ uint16(x86_xArgRel32), + /*5346*/ uint16(x86_xMatch), + /*5347*/ uint16(x86_xCondIs64), 5350, 5364, + /*5350*/ uint16(x86_xCondDataSize), 5354, 5359, 0, + /*5354*/ uint16(x86_xSetOp), uint16(x86_JA), + /*5356*/ uint16(x86_xReadCw), + /*5357*/ uint16(x86_xArgRel16), + /*5358*/ uint16(x86_xMatch), + /*5359*/ uint16(x86_xSetOp), uint16(x86_JA), + /*5361*/ uint16(x86_xReadCd), + /*5362*/ uint16(x86_xArgRel32), + /*5363*/ uint16(x86_xMatch), + /*5364*/ uint16(x86_xCondDataSize), 5368, 5359, 5373, + /*5368*/ uint16(x86_xSetOp), uint16(x86_JA), + /*5370*/ uint16(x86_xReadCd), + /*5371*/ uint16(x86_xArgRel32), + /*5372*/ uint16(x86_xMatch), + /*5373*/ uint16(x86_xSetOp), uint16(x86_JA), + /*5375*/ uint16(x86_xReadCd), + /*5376*/ uint16(x86_xArgRel32), + /*5377*/ uint16(x86_xMatch), + /*5378*/ uint16(x86_xCondIs64), 5381, 5395, + /*5381*/ uint16(x86_xCondDataSize), 5385, 5390, 0, + /*5385*/ uint16(x86_xSetOp), uint16(x86_JS), + /*5387*/ uint16(x86_xReadCw), + /*5388*/ uint16(x86_xArgRel16), + /*5389*/ uint16(x86_xMatch), + /*5390*/ uint16(x86_xSetOp), uint16(x86_JS), + /*5392*/ uint16(x86_xReadCd), + /*5393*/ uint16(x86_xArgRel32), + /*5394*/ uint16(x86_xMatch), + /*5395*/ uint16(x86_xCondDataSize), 5399, 5390, 5404, + /*5399*/ uint16(x86_xSetOp), uint16(x86_JS), + /*5401*/ uint16(x86_xReadCd), + /*5402*/ uint16(x86_xArgRel32), + /*5403*/ uint16(x86_xMatch), + /*5404*/ uint16(x86_xSetOp), uint16(x86_JS), + /*5406*/ uint16(x86_xReadCd), + /*5407*/ uint16(x86_xArgRel32), + /*5408*/ uint16(x86_xMatch), + /*5409*/ uint16(x86_xCondIs64), 5412, 5426, + /*5412*/ uint16(x86_xCondDataSize), 5416, 5421, 0, + /*5416*/ uint16(x86_xSetOp), uint16(x86_JNS), + /*5418*/ uint16(x86_xReadCw), + /*5419*/ uint16(x86_xArgRel16), + /*5420*/ uint16(x86_xMatch), + /*5421*/ uint16(x86_xSetOp), uint16(x86_JNS), + /*5423*/ uint16(x86_xReadCd), + /*5424*/ uint16(x86_xArgRel32), + /*5425*/ uint16(x86_xMatch), + /*5426*/ uint16(x86_xCondDataSize), 5430, 5421, 5435, + /*5430*/ uint16(x86_xSetOp), uint16(x86_JNS), + /*5432*/ uint16(x86_xReadCd), + /*5433*/ uint16(x86_xArgRel32), + /*5434*/ uint16(x86_xMatch), + /*5435*/ uint16(x86_xSetOp), uint16(x86_JNS), + /*5437*/ uint16(x86_xReadCd), + /*5438*/ uint16(x86_xArgRel32), + /*5439*/ uint16(x86_xMatch), + /*5440*/ uint16(x86_xCondIs64), 5443, 5457, + /*5443*/ uint16(x86_xCondDataSize), 5447, 5452, 0, + /*5447*/ uint16(x86_xSetOp), uint16(x86_JP), + /*5449*/ uint16(x86_xReadCw), + /*5450*/ uint16(x86_xArgRel16), + /*5451*/ uint16(x86_xMatch), + /*5452*/ uint16(x86_xSetOp), uint16(x86_JP), + /*5454*/ uint16(x86_xReadCd), + /*5455*/ uint16(x86_xArgRel32), + /*5456*/ uint16(x86_xMatch), + /*5457*/ uint16(x86_xCondDataSize), 5461, 5452, 5466, + /*5461*/ uint16(x86_xSetOp), uint16(x86_JP), + /*5463*/ uint16(x86_xReadCd), + /*5464*/ uint16(x86_xArgRel32), + /*5465*/ uint16(x86_xMatch), + /*5466*/ uint16(x86_xSetOp), uint16(x86_JP), + /*5468*/ uint16(x86_xReadCd), + /*5469*/ uint16(x86_xArgRel32), + /*5470*/ uint16(x86_xMatch), + /*5471*/ uint16(x86_xCondIs64), 5474, 5488, + /*5474*/ uint16(x86_xCondDataSize), 5478, 5483, 0, + /*5478*/ uint16(x86_xSetOp), uint16(x86_JNP), + /*5480*/ uint16(x86_xReadCw), + /*5481*/ uint16(x86_xArgRel16), + /*5482*/ uint16(x86_xMatch), + /*5483*/ uint16(x86_xSetOp), uint16(x86_JNP), + /*5485*/ uint16(x86_xReadCd), + /*5486*/ uint16(x86_xArgRel32), + /*5487*/ uint16(x86_xMatch), + /*5488*/ uint16(x86_xCondDataSize), 5492, 5483, 5497, + /*5492*/ uint16(x86_xSetOp), uint16(x86_JNP), + /*5494*/ uint16(x86_xReadCd), + /*5495*/ uint16(x86_xArgRel32), + /*5496*/ uint16(x86_xMatch), + /*5497*/ uint16(x86_xSetOp), uint16(x86_JNP), + /*5499*/ uint16(x86_xReadCd), + /*5500*/ uint16(x86_xArgRel32), + /*5501*/ uint16(x86_xMatch), + /*5502*/ uint16(x86_xCondIs64), 5505, 5519, + /*5505*/ uint16(x86_xCondDataSize), 5509, 5514, 0, + /*5509*/ uint16(x86_xSetOp), uint16(x86_JL), + /*5511*/ uint16(x86_xReadCw), + /*5512*/ uint16(x86_xArgRel16), + /*5513*/ uint16(x86_xMatch), + /*5514*/ uint16(x86_xSetOp), uint16(x86_JL), + /*5516*/ uint16(x86_xReadCd), + /*5517*/ uint16(x86_xArgRel32), + /*5518*/ uint16(x86_xMatch), + /*5519*/ uint16(x86_xCondDataSize), 5523, 5514, 5528, + /*5523*/ uint16(x86_xSetOp), uint16(x86_JL), + /*5525*/ uint16(x86_xReadCd), + /*5526*/ uint16(x86_xArgRel32), + /*5527*/ uint16(x86_xMatch), + /*5528*/ uint16(x86_xSetOp), uint16(x86_JL), + /*5530*/ uint16(x86_xReadCd), + /*5531*/ uint16(x86_xArgRel32), + /*5532*/ uint16(x86_xMatch), + /*5533*/ uint16(x86_xCondIs64), 5536, 5550, + /*5536*/ uint16(x86_xCondDataSize), 5540, 5545, 0, + /*5540*/ uint16(x86_xSetOp), uint16(x86_JGE), + /*5542*/ uint16(x86_xReadCw), + /*5543*/ uint16(x86_xArgRel16), + /*5544*/ uint16(x86_xMatch), + /*5545*/ uint16(x86_xSetOp), uint16(x86_JGE), + /*5547*/ uint16(x86_xReadCd), + /*5548*/ uint16(x86_xArgRel32), + /*5549*/ uint16(x86_xMatch), + /*5550*/ uint16(x86_xCondDataSize), 5554, 5545, 5559, + /*5554*/ uint16(x86_xSetOp), uint16(x86_JGE), + /*5556*/ uint16(x86_xReadCd), + /*5557*/ uint16(x86_xArgRel32), + /*5558*/ uint16(x86_xMatch), + /*5559*/ uint16(x86_xSetOp), uint16(x86_JGE), + /*5561*/ uint16(x86_xReadCd), + /*5562*/ uint16(x86_xArgRel32), + /*5563*/ uint16(x86_xMatch), + /*5564*/ uint16(x86_xCondIs64), 5567, 5581, + /*5567*/ uint16(x86_xCondDataSize), 5571, 5576, 0, + /*5571*/ uint16(x86_xSetOp), uint16(x86_JLE), + /*5573*/ uint16(x86_xReadCw), + /*5574*/ uint16(x86_xArgRel16), + /*5575*/ uint16(x86_xMatch), + /*5576*/ uint16(x86_xSetOp), uint16(x86_JLE), + /*5578*/ uint16(x86_xReadCd), + /*5579*/ uint16(x86_xArgRel32), + /*5580*/ uint16(x86_xMatch), + /*5581*/ uint16(x86_xCondDataSize), 5585, 5576, 5590, + /*5585*/ uint16(x86_xSetOp), uint16(x86_JLE), + /*5587*/ uint16(x86_xReadCd), + /*5588*/ uint16(x86_xArgRel32), + /*5589*/ uint16(x86_xMatch), + /*5590*/ uint16(x86_xSetOp), uint16(x86_JLE), + /*5592*/ uint16(x86_xReadCd), + /*5593*/ uint16(x86_xArgRel32), + /*5594*/ uint16(x86_xMatch), + /*5595*/ uint16(x86_xCondIs64), 5598, 5612, + /*5598*/ uint16(x86_xCondDataSize), 5602, 5607, 0, + /*5602*/ uint16(x86_xSetOp), uint16(x86_JG), + /*5604*/ uint16(x86_xReadCw), + /*5605*/ uint16(x86_xArgRel16), + /*5606*/ uint16(x86_xMatch), + /*5607*/ uint16(x86_xSetOp), uint16(x86_JG), + /*5609*/ uint16(x86_xReadCd), + /*5610*/ uint16(x86_xArgRel32), + /*5611*/ uint16(x86_xMatch), + /*5612*/ uint16(x86_xCondDataSize), 5616, 5607, 5621, + /*5616*/ uint16(x86_xSetOp), uint16(x86_JG), + /*5618*/ uint16(x86_xReadCd), + /*5619*/ uint16(x86_xArgRel32), + /*5620*/ uint16(x86_xMatch), + /*5621*/ uint16(x86_xSetOp), uint16(x86_JG), + /*5623*/ uint16(x86_xReadCd), + /*5624*/ uint16(x86_xArgRel32), + /*5625*/ uint16(x86_xMatch), + /*5626*/ uint16(x86_xSetOp), uint16(x86_SETO), + /*5628*/ uint16(x86_xReadSlashR), + /*5629*/ uint16(x86_xArgRM8), + /*5630*/ uint16(x86_xMatch), + /*5631*/ uint16(x86_xSetOp), uint16(x86_SETNO), + /*5633*/ uint16(x86_xReadSlashR), + /*5634*/ uint16(x86_xArgRM8), + /*5635*/ uint16(x86_xMatch), + /*5636*/ uint16(x86_xSetOp), uint16(x86_SETB), + /*5638*/ uint16(x86_xReadSlashR), + /*5639*/ uint16(x86_xArgRM8), + /*5640*/ uint16(x86_xMatch), + /*5641*/ uint16(x86_xSetOp), uint16(x86_SETAE), + /*5643*/ uint16(x86_xReadSlashR), + /*5644*/ uint16(x86_xArgRM8), + /*5645*/ uint16(x86_xMatch), + /*5646*/ uint16(x86_xSetOp), uint16(x86_SETE), + /*5648*/ uint16(x86_xReadSlashR), + /*5649*/ uint16(x86_xArgRM8), + /*5650*/ uint16(x86_xMatch), + /*5651*/ uint16(x86_xSetOp), uint16(x86_SETNE), + /*5653*/ uint16(x86_xReadSlashR), + /*5654*/ uint16(x86_xArgRM8), + /*5655*/ uint16(x86_xMatch), + /*5656*/ uint16(x86_xSetOp), uint16(x86_SETBE), + /*5658*/ uint16(x86_xReadSlashR), + /*5659*/ uint16(x86_xArgRM8), + /*5660*/ uint16(x86_xMatch), + /*5661*/ uint16(x86_xSetOp), uint16(x86_SETA), + /*5663*/ uint16(x86_xReadSlashR), + /*5664*/ uint16(x86_xArgRM8), + /*5665*/ uint16(x86_xMatch), + /*5666*/ uint16(x86_xSetOp), uint16(x86_SETS), + /*5668*/ uint16(x86_xReadSlashR), + /*5669*/ uint16(x86_xArgRM8), + /*5670*/ uint16(x86_xMatch), + /*5671*/ uint16(x86_xSetOp), uint16(x86_SETNS), + /*5673*/ uint16(x86_xReadSlashR), + /*5674*/ uint16(x86_xArgRM8), + /*5675*/ uint16(x86_xMatch), + /*5676*/ uint16(x86_xSetOp), uint16(x86_SETP), + /*5678*/ uint16(x86_xReadSlashR), + /*5679*/ uint16(x86_xArgRM8), + /*5680*/ uint16(x86_xMatch), + /*5681*/ uint16(x86_xSetOp), uint16(x86_SETNP), + /*5683*/ uint16(x86_xReadSlashR), + /*5684*/ uint16(x86_xArgRM8), + /*5685*/ uint16(x86_xMatch), + /*5686*/ uint16(x86_xSetOp), uint16(x86_SETL), + /*5688*/ uint16(x86_xReadSlashR), + /*5689*/ uint16(x86_xArgRM8), + /*5690*/ uint16(x86_xMatch), + /*5691*/ uint16(x86_xSetOp), uint16(x86_SETGE), + /*5693*/ uint16(x86_xReadSlashR), + /*5694*/ uint16(x86_xArgRM8), + /*5695*/ uint16(x86_xMatch), + /*5696*/ uint16(x86_xSetOp), uint16(x86_SETLE), + /*5698*/ uint16(x86_xReadSlashR), + /*5699*/ uint16(x86_xArgRM8), + /*5700*/ uint16(x86_xMatch), + /*5701*/ uint16(x86_xSetOp), uint16(x86_SETG), + /*5703*/ uint16(x86_xReadSlashR), + /*5704*/ uint16(x86_xArgRM8), + /*5705*/ uint16(x86_xMatch), + /*5706*/ uint16(x86_xSetOp), uint16(x86_PUSH), + /*5708*/ uint16(x86_xArgFS), + /*5709*/ uint16(x86_xMatch), + /*5710*/ uint16(x86_xCondIs64), 5713, 5725, + /*5713*/ uint16(x86_xCondDataSize), 5717, 5721, 0, + /*5717*/ uint16(x86_xSetOp), uint16(x86_POP), + /*5719*/ uint16(x86_xArgFS), + /*5720*/ uint16(x86_xMatch), + /*5721*/ uint16(x86_xSetOp), uint16(x86_POP), + /*5723*/ uint16(x86_xArgFS), + /*5724*/ uint16(x86_xMatch), + /*5725*/ uint16(x86_xCondDataSize), 5717, 5729, 5733, + /*5729*/ uint16(x86_xSetOp), uint16(x86_POP), + /*5731*/ uint16(x86_xArgFS), + /*5732*/ uint16(x86_xMatch), + /*5733*/ uint16(x86_xSetOp), uint16(x86_POP), + /*5735*/ uint16(x86_xArgFS), + /*5736*/ uint16(x86_xMatch), + /*5737*/ uint16(x86_xSetOp), uint16(x86_CPUID), + /*5739*/ uint16(x86_xMatch), + /*5740*/ uint16(x86_xCondIs64), 5743, 5759, + /*5743*/ uint16(x86_xCondDataSize), 5747, 5753, 0, + /*5747*/ uint16(x86_xSetOp), uint16(x86_BT), + /*5749*/ uint16(x86_xReadSlashR), + /*5750*/ uint16(x86_xArgRM16), + /*5751*/ uint16(x86_xArgR16), + /*5752*/ uint16(x86_xMatch), + /*5753*/ uint16(x86_xSetOp), uint16(x86_BT), + /*5755*/ uint16(x86_xReadSlashR), + /*5756*/ uint16(x86_xArgRM32), + /*5757*/ uint16(x86_xArgR32), + /*5758*/ uint16(x86_xMatch), + /*5759*/ uint16(x86_xCondDataSize), 5747, 5753, 5763, + /*5763*/ uint16(x86_xSetOp), uint16(x86_BT), + /*5765*/ uint16(x86_xReadSlashR), + /*5766*/ uint16(x86_xArgRM64), + /*5767*/ uint16(x86_xArgR64), + /*5768*/ uint16(x86_xMatch), + /*5769*/ uint16(x86_xCondIs64), 5772, 5792, + /*5772*/ uint16(x86_xCondDataSize), 5776, 5784, 0, + /*5776*/ uint16(x86_xSetOp), uint16(x86_SHLD), + /*5778*/ uint16(x86_xReadSlashR), + /*5779*/ uint16(x86_xReadIb), + /*5780*/ uint16(x86_xArgRM16), + /*5781*/ uint16(x86_xArgR16), + /*5782*/ uint16(x86_xArgImm8u), + /*5783*/ uint16(x86_xMatch), + /*5784*/ uint16(x86_xSetOp), uint16(x86_SHLD), + /*5786*/ uint16(x86_xReadSlashR), + /*5787*/ uint16(x86_xReadIb), + /*5788*/ uint16(x86_xArgRM32), + /*5789*/ uint16(x86_xArgR32), + /*5790*/ uint16(x86_xArgImm8u), + /*5791*/ uint16(x86_xMatch), + /*5792*/ uint16(x86_xCondDataSize), 5776, 5784, 5796, + /*5796*/ uint16(x86_xSetOp), uint16(x86_SHLD), + /*5798*/ uint16(x86_xReadSlashR), + /*5799*/ uint16(x86_xReadIb), + /*5800*/ uint16(x86_xArgRM64), + /*5801*/ uint16(x86_xArgR64), + /*5802*/ uint16(x86_xArgImm8u), + /*5803*/ uint16(x86_xMatch), + /*5804*/ uint16(x86_xCondIs64), 5807, 5825, + /*5807*/ uint16(x86_xCondDataSize), 5811, 5818, 0, + /*5811*/ uint16(x86_xSetOp), uint16(x86_SHLD), + /*5813*/ uint16(x86_xReadSlashR), + /*5814*/ uint16(x86_xArgRM16), + /*5815*/ uint16(x86_xArgR16), + /*5816*/ uint16(x86_xArgCL), + /*5817*/ uint16(x86_xMatch), + /*5818*/ uint16(x86_xSetOp), uint16(x86_SHLD), + /*5820*/ uint16(x86_xReadSlashR), + /*5821*/ uint16(x86_xArgRM32), + /*5822*/ uint16(x86_xArgR32), + /*5823*/ uint16(x86_xArgCL), + /*5824*/ uint16(x86_xMatch), + /*5825*/ uint16(x86_xCondDataSize), 5811, 5818, 5829, + /*5829*/ uint16(x86_xSetOp), uint16(x86_SHLD), + /*5831*/ uint16(x86_xReadSlashR), + /*5832*/ uint16(x86_xArgRM64), + /*5833*/ uint16(x86_xArgR64), + /*5834*/ uint16(x86_xArgCL), + /*5835*/ uint16(x86_xMatch), + /*5836*/ uint16(x86_xSetOp), uint16(x86_PUSH), + /*5838*/ uint16(x86_xArgGS), + /*5839*/ uint16(x86_xMatch), + /*5840*/ uint16(x86_xCondIs64), 5843, 5855, + /*5843*/ uint16(x86_xCondDataSize), 5847, 5851, 0, + /*5847*/ uint16(x86_xSetOp), uint16(x86_POP), + /*5849*/ uint16(x86_xArgGS), + /*5850*/ uint16(x86_xMatch), + /*5851*/ uint16(x86_xSetOp), uint16(x86_POP), + /*5853*/ uint16(x86_xArgGS), + /*5854*/ uint16(x86_xMatch), + /*5855*/ uint16(x86_xCondDataSize), 5847, 5859, 5863, + /*5859*/ uint16(x86_xSetOp), uint16(x86_POP), + /*5861*/ uint16(x86_xArgGS), + /*5862*/ uint16(x86_xMatch), + /*5863*/ uint16(x86_xSetOp), uint16(x86_POP), + /*5865*/ uint16(x86_xArgGS), + /*5866*/ uint16(x86_xMatch), + /*5867*/ uint16(x86_xSetOp), uint16(x86_RSM), + /*5869*/ uint16(x86_xMatch), + /*5870*/ uint16(x86_xCondIs64), 5873, 5889, + /*5873*/ uint16(x86_xCondDataSize), 5877, 5883, 0, + /*5877*/ uint16(x86_xSetOp), uint16(x86_BTS), + /*5879*/ uint16(x86_xReadSlashR), + /*5880*/ uint16(x86_xArgRM16), + /*5881*/ uint16(x86_xArgR16), + /*5882*/ uint16(x86_xMatch), + /*5883*/ uint16(x86_xSetOp), uint16(x86_BTS), + /*5885*/ uint16(x86_xReadSlashR), + /*5886*/ uint16(x86_xArgRM32), + /*5887*/ uint16(x86_xArgR32), + /*5888*/ uint16(x86_xMatch), + /*5889*/ uint16(x86_xCondDataSize), 5877, 5883, 5893, + /*5893*/ uint16(x86_xSetOp), uint16(x86_BTS), + /*5895*/ uint16(x86_xReadSlashR), + /*5896*/ uint16(x86_xArgRM64), + /*5897*/ uint16(x86_xArgR64), + /*5898*/ uint16(x86_xMatch), + /*5899*/ uint16(x86_xCondIs64), 5902, 5922, + /*5902*/ uint16(x86_xCondDataSize), 5906, 5914, 0, + /*5906*/ uint16(x86_xSetOp), uint16(x86_SHRD), + /*5908*/ uint16(x86_xReadSlashR), + /*5909*/ uint16(x86_xReadIb), + /*5910*/ uint16(x86_xArgRM16), + /*5911*/ uint16(x86_xArgR16), + /*5912*/ uint16(x86_xArgImm8u), + /*5913*/ uint16(x86_xMatch), + /*5914*/ uint16(x86_xSetOp), uint16(x86_SHRD), + /*5916*/ uint16(x86_xReadSlashR), + /*5917*/ uint16(x86_xReadIb), + /*5918*/ uint16(x86_xArgRM32), + /*5919*/ uint16(x86_xArgR32), + /*5920*/ uint16(x86_xArgImm8u), + /*5921*/ uint16(x86_xMatch), + /*5922*/ uint16(x86_xCondDataSize), 5906, 5914, 5926, + /*5926*/ uint16(x86_xSetOp), uint16(x86_SHRD), + /*5928*/ uint16(x86_xReadSlashR), + /*5929*/ uint16(x86_xReadIb), + /*5930*/ uint16(x86_xArgRM64), + /*5931*/ uint16(x86_xArgR64), + /*5932*/ uint16(x86_xArgImm8u), + /*5933*/ uint16(x86_xMatch), + /*5934*/ uint16(x86_xCondIs64), 5937, 5955, + /*5937*/ uint16(x86_xCondDataSize), 5941, 5948, 0, + /*5941*/ uint16(x86_xSetOp), uint16(x86_SHRD), + /*5943*/ uint16(x86_xReadSlashR), + /*5944*/ uint16(x86_xArgRM16), + /*5945*/ uint16(x86_xArgR16), + /*5946*/ uint16(x86_xArgCL), + /*5947*/ uint16(x86_xMatch), + /*5948*/ uint16(x86_xSetOp), uint16(x86_SHRD), + /*5950*/ uint16(x86_xReadSlashR), + /*5951*/ uint16(x86_xArgRM32), + /*5952*/ uint16(x86_xArgR32), + /*5953*/ uint16(x86_xArgCL), + /*5954*/ uint16(x86_xMatch), + /*5955*/ uint16(x86_xCondDataSize), 5941, 5948, 5959, + /*5959*/ uint16(x86_xSetOp), uint16(x86_SHRD), + /*5961*/ uint16(x86_xReadSlashR), + /*5962*/ uint16(x86_xArgRM64), + /*5963*/ uint16(x86_xArgR64), + /*5964*/ uint16(x86_xArgCL), + /*5965*/ uint16(x86_xMatch), + /*5966*/ uint16(x86_xCondByte), 3, + 0xE8, 6215, + 0xF0, 6218, + 0xF8, 6221, + /*5974*/ uint16(x86_xCondSlashR), + 5983, // 0 + 6037, // 1 + 6091, // 2 + 6120, // 3 + 6149, // 4 + 6172, // 5 + 6195, // 6 + 6211, // 7 + /*5983*/ uint16(x86_xCondIs64), 5986, 5998, + /*5986*/ uint16(x86_xCondDataSize), 5990, 5994, 0, + /*5990*/ uint16(x86_xSetOp), uint16(x86_FXSAVE), + /*5992*/ uint16(x86_xArgM512byte), + /*5993*/ uint16(x86_xMatch), + /*5994*/ uint16(x86_xSetOp), uint16(x86_FXSAVE), + /*5996*/ uint16(x86_xArgM512byte), + /*5997*/ uint16(x86_xMatch), + /*5998*/ uint16(x86_xCondPrefix), 2, + 0xF3, 6012, + 0x0, 6004, + /*6004*/ uint16(x86_xCondDataSize), 5990, 5994, 6008, + /*6008*/ uint16(x86_xSetOp), uint16(x86_FXSAVE64), + /*6010*/ uint16(x86_xArgM512byte), + /*6011*/ uint16(x86_xMatch), + /*6012*/ uint16(x86_xCondDataSize), 6016, 6023, 6030, + /*6016*/ uint16(x86_xCondIsMem), 6019, 0, + /*6019*/ uint16(x86_xSetOp), uint16(x86_RDFSBASE), + /*6021*/ uint16(x86_xArgRM32), + /*6022*/ uint16(x86_xMatch), + /*6023*/ uint16(x86_xCondIsMem), 6026, 0, + /*6026*/ uint16(x86_xSetOp), uint16(x86_RDFSBASE), + /*6028*/ uint16(x86_xArgRM32), + /*6029*/ uint16(x86_xMatch), + /*6030*/ uint16(x86_xCondIsMem), 6033, 0, + /*6033*/ uint16(x86_xSetOp), uint16(x86_RDFSBASE), + /*6035*/ uint16(x86_xArgRM64), + /*6036*/ uint16(x86_xMatch), + /*6037*/ uint16(x86_xCondIs64), 6040, 6052, + /*6040*/ uint16(x86_xCondDataSize), 6044, 6048, 0, + /*6044*/ uint16(x86_xSetOp), uint16(x86_FXRSTOR), + /*6046*/ uint16(x86_xArgM512byte), + /*6047*/ uint16(x86_xMatch), + /*6048*/ uint16(x86_xSetOp), uint16(x86_FXRSTOR), + /*6050*/ uint16(x86_xArgM512byte), + /*6051*/ uint16(x86_xMatch), + /*6052*/ uint16(x86_xCondPrefix), 2, + 0xF3, 6066, + 0x0, 6058, + /*6058*/ uint16(x86_xCondDataSize), 6044, 6048, 6062, + /*6062*/ uint16(x86_xSetOp), uint16(x86_FXRSTOR64), + /*6064*/ uint16(x86_xArgM512byte), + /*6065*/ uint16(x86_xMatch), + /*6066*/ uint16(x86_xCondDataSize), 6070, 6077, 6084, + /*6070*/ uint16(x86_xCondIsMem), 6073, 0, + /*6073*/ uint16(x86_xSetOp), uint16(x86_RDGSBASE), + /*6075*/ uint16(x86_xArgRM32), + /*6076*/ uint16(x86_xMatch), + /*6077*/ uint16(x86_xCondIsMem), 6080, 0, + /*6080*/ uint16(x86_xSetOp), uint16(x86_RDGSBASE), + /*6082*/ uint16(x86_xArgRM32), + /*6083*/ uint16(x86_xMatch), + /*6084*/ uint16(x86_xCondIsMem), 6087, 0, + /*6087*/ uint16(x86_xSetOp), uint16(x86_RDGSBASE), + /*6089*/ uint16(x86_xArgRM64), + /*6090*/ uint16(x86_xMatch), + /*6091*/ uint16(x86_xCondIs64), 6094, 6098, + /*6094*/ uint16(x86_xSetOp), uint16(x86_LDMXCSR), + /*6096*/ uint16(x86_xArgM32), + /*6097*/ uint16(x86_xMatch), + /*6098*/ uint16(x86_xCondPrefix), 2, + 0xF3, 6104, + 0x0, 6094, + /*6104*/ uint16(x86_xCondDataSize), 6108, 6112, 6116, + /*6108*/ uint16(x86_xSetOp), uint16(x86_WRFSBASE), + /*6110*/ uint16(x86_xArgRM32), + /*6111*/ uint16(x86_xMatch), + /*6112*/ uint16(x86_xSetOp), uint16(x86_WRFSBASE), + /*6114*/ uint16(x86_xArgRM32), + /*6115*/ uint16(x86_xMatch), + /*6116*/ uint16(x86_xSetOp), uint16(x86_WRFSBASE), + /*6118*/ uint16(x86_xArgRM64), + /*6119*/ uint16(x86_xMatch), + /*6120*/ uint16(x86_xCondIs64), 6123, 6127, + /*6123*/ uint16(x86_xSetOp), uint16(x86_STMXCSR), + /*6125*/ uint16(x86_xArgM32), + /*6126*/ uint16(x86_xMatch), + /*6127*/ uint16(x86_xCondPrefix), 2, + 0xF3, 6133, + 0x0, 6123, + /*6133*/ uint16(x86_xCondDataSize), 6137, 6141, 6145, + /*6137*/ uint16(x86_xSetOp), uint16(x86_WRGSBASE), + /*6139*/ uint16(x86_xArgRM32), + /*6140*/ uint16(x86_xMatch), + /*6141*/ uint16(x86_xSetOp), uint16(x86_WRGSBASE), + /*6143*/ uint16(x86_xArgRM32), + /*6144*/ uint16(x86_xMatch), + /*6145*/ uint16(x86_xSetOp), uint16(x86_WRGSBASE), + /*6147*/ uint16(x86_xArgRM64), + /*6148*/ uint16(x86_xMatch), + /*6149*/ uint16(x86_xCondIs64), 6152, 6164, + /*6152*/ uint16(x86_xCondDataSize), 6156, 6160, 0, + /*6156*/ uint16(x86_xSetOp), uint16(x86_XSAVE), + /*6158*/ uint16(x86_xArgMem), + /*6159*/ uint16(x86_xMatch), + /*6160*/ uint16(x86_xSetOp), uint16(x86_XSAVE), + /*6162*/ uint16(x86_xArgMem), + /*6163*/ uint16(x86_xMatch), + /*6164*/ uint16(x86_xCondDataSize), 6156, 6160, 6168, + /*6168*/ uint16(x86_xSetOp), uint16(x86_XSAVE64), + /*6170*/ uint16(x86_xArgMem), + /*6171*/ uint16(x86_xMatch), + /*6172*/ uint16(x86_xCondIs64), 6175, 6187, + /*6175*/ uint16(x86_xCondDataSize), 6179, 6183, 0, + /*6179*/ uint16(x86_xSetOp), uint16(x86_XRSTOR), + /*6181*/ uint16(x86_xArgMem), + /*6182*/ uint16(x86_xMatch), + /*6183*/ uint16(x86_xSetOp), uint16(x86_XRSTOR), + /*6185*/ uint16(x86_xArgMem), + /*6186*/ uint16(x86_xMatch), + /*6187*/ uint16(x86_xCondDataSize), 6179, 6183, 6191, + /*6191*/ uint16(x86_xSetOp), uint16(x86_XRSTOR64), + /*6193*/ uint16(x86_xArgMem), + /*6194*/ uint16(x86_xMatch), + /*6195*/ uint16(x86_xCondDataSize), 6199, 6203, 6207, + /*6199*/ uint16(x86_xSetOp), uint16(x86_XSAVEOPT), + /*6201*/ uint16(x86_xArgMem), + /*6202*/ uint16(x86_xMatch), + /*6203*/ uint16(x86_xSetOp), uint16(x86_XSAVEOPT), + /*6205*/ uint16(x86_xArgMem), + /*6206*/ uint16(x86_xMatch), + /*6207*/ uint16(x86_xSetOp), uint16(x86_XSAVEOPT64), + /*6209*/ uint16(x86_xArgMem), + /*6210*/ uint16(x86_xMatch), + /*6211*/ uint16(x86_xSetOp), uint16(x86_CLFLUSH), + /*6213*/ uint16(x86_xArgM8), + /*6214*/ uint16(x86_xMatch), + /*6215*/ uint16(x86_xSetOp), uint16(x86_LFENCE), + /*6217*/ uint16(x86_xMatch), + /*6218*/ uint16(x86_xSetOp), uint16(x86_MFENCE), + /*6220*/ uint16(x86_xMatch), + /*6221*/ uint16(x86_xSetOp), uint16(x86_SFENCE), + /*6223*/ uint16(x86_xMatch), + /*6224*/ uint16(x86_xCondIs64), 6227, 6243, + /*6227*/ uint16(x86_xCondDataSize), 6231, 6237, 0, + /*6231*/ uint16(x86_xSetOp), uint16(x86_IMUL), + /*6233*/ uint16(x86_xReadSlashR), + /*6234*/ uint16(x86_xArgR16), + /*6235*/ uint16(x86_xArgRM16), + /*6236*/ uint16(x86_xMatch), + /*6237*/ uint16(x86_xSetOp), uint16(x86_IMUL), + /*6239*/ uint16(x86_xReadSlashR), + /*6240*/ uint16(x86_xArgR32), + /*6241*/ uint16(x86_xArgRM32), + /*6242*/ uint16(x86_xMatch), + /*6243*/ uint16(x86_xCondDataSize), 6231, 6237, 6247, + /*6247*/ uint16(x86_xSetOp), uint16(x86_IMUL), + /*6249*/ uint16(x86_xReadSlashR), + /*6250*/ uint16(x86_xArgR64), + /*6251*/ uint16(x86_xArgRM64), + /*6252*/ uint16(x86_xMatch), + /*6253*/ uint16(x86_xSetOp), uint16(x86_CMPXCHG), + /*6255*/ uint16(x86_xReadSlashR), + /*6256*/ uint16(x86_xArgRM8), + /*6257*/ uint16(x86_xArgR8), + /*6258*/ uint16(x86_xMatch), + /*6259*/ uint16(x86_xCondIs64), 6262, 6278, + /*6262*/ uint16(x86_xCondDataSize), 6266, 6272, 0, + /*6266*/ uint16(x86_xSetOp), uint16(x86_CMPXCHG), + /*6268*/ uint16(x86_xReadSlashR), + /*6269*/ uint16(x86_xArgRM16), + /*6270*/ uint16(x86_xArgR16), + /*6271*/ uint16(x86_xMatch), + /*6272*/ uint16(x86_xSetOp), uint16(x86_CMPXCHG), + /*6274*/ uint16(x86_xReadSlashR), + /*6275*/ uint16(x86_xArgRM32), + /*6276*/ uint16(x86_xArgR32), + /*6277*/ uint16(x86_xMatch), + /*6278*/ uint16(x86_xCondDataSize), 6266, 6272, 6282, + /*6282*/ uint16(x86_xSetOp), uint16(x86_CMPXCHG), + /*6284*/ uint16(x86_xReadSlashR), + /*6285*/ uint16(x86_xArgRM64), + /*6286*/ uint16(x86_xArgR64), + /*6287*/ uint16(x86_xMatch), + /*6288*/ uint16(x86_xCondIs64), 6291, 6307, + /*6291*/ uint16(x86_xCondDataSize), 6295, 6301, 0, + /*6295*/ uint16(x86_xSetOp), uint16(x86_LSS), + /*6297*/ uint16(x86_xReadSlashR), + /*6298*/ uint16(x86_xArgR16), + /*6299*/ uint16(x86_xArgM16colon16), + /*6300*/ uint16(x86_xMatch), + /*6301*/ uint16(x86_xSetOp), uint16(x86_LSS), + /*6303*/ uint16(x86_xReadSlashR), + /*6304*/ uint16(x86_xArgR32), + /*6305*/ uint16(x86_xArgM16colon32), + /*6306*/ uint16(x86_xMatch), + /*6307*/ uint16(x86_xCondDataSize), 6295, 6301, 6311, + /*6311*/ uint16(x86_xSetOp), uint16(x86_LSS), + /*6313*/ uint16(x86_xReadSlashR), + /*6314*/ uint16(x86_xArgR64), + /*6315*/ uint16(x86_xArgM16colon64), + /*6316*/ uint16(x86_xMatch), + /*6317*/ uint16(x86_xCondIs64), 6320, 6336, + /*6320*/ uint16(x86_xCondDataSize), 6324, 6330, 0, + /*6324*/ uint16(x86_xSetOp), uint16(x86_BTR), + /*6326*/ uint16(x86_xReadSlashR), + /*6327*/ uint16(x86_xArgRM16), + /*6328*/ uint16(x86_xArgR16), + /*6329*/ uint16(x86_xMatch), + /*6330*/ uint16(x86_xSetOp), uint16(x86_BTR), + /*6332*/ uint16(x86_xReadSlashR), + /*6333*/ uint16(x86_xArgRM32), + /*6334*/ uint16(x86_xArgR32), + /*6335*/ uint16(x86_xMatch), + /*6336*/ uint16(x86_xCondDataSize), 6324, 6330, 6340, + /*6340*/ uint16(x86_xSetOp), uint16(x86_BTR), + /*6342*/ uint16(x86_xReadSlashR), + /*6343*/ uint16(x86_xArgRM64), + /*6344*/ uint16(x86_xArgR64), + /*6345*/ uint16(x86_xMatch), + /*6346*/ uint16(x86_xCondIs64), 6349, 6365, + /*6349*/ uint16(x86_xCondDataSize), 6353, 6359, 0, + /*6353*/ uint16(x86_xSetOp), uint16(x86_LFS), + /*6355*/ uint16(x86_xReadSlashR), + /*6356*/ uint16(x86_xArgR16), + /*6357*/ uint16(x86_xArgM16colon16), + /*6358*/ uint16(x86_xMatch), + /*6359*/ uint16(x86_xSetOp), uint16(x86_LFS), + /*6361*/ uint16(x86_xReadSlashR), + /*6362*/ uint16(x86_xArgR32), + /*6363*/ uint16(x86_xArgM16colon32), + /*6364*/ uint16(x86_xMatch), + /*6365*/ uint16(x86_xCondDataSize), 6353, 6359, 6369, + /*6369*/ uint16(x86_xSetOp), uint16(x86_LFS), + /*6371*/ uint16(x86_xReadSlashR), + /*6372*/ uint16(x86_xArgR64), + /*6373*/ uint16(x86_xArgM16colon64), + /*6374*/ uint16(x86_xMatch), + /*6375*/ uint16(x86_xCondIs64), 6378, 6394, + /*6378*/ uint16(x86_xCondDataSize), 6382, 6388, 0, + /*6382*/ uint16(x86_xSetOp), uint16(x86_LGS), + /*6384*/ uint16(x86_xReadSlashR), + /*6385*/ uint16(x86_xArgR16), + /*6386*/ uint16(x86_xArgM16colon16), + /*6387*/ uint16(x86_xMatch), + /*6388*/ uint16(x86_xSetOp), uint16(x86_LGS), + /*6390*/ uint16(x86_xReadSlashR), + /*6391*/ uint16(x86_xArgR32), + /*6392*/ uint16(x86_xArgM16colon32), + /*6393*/ uint16(x86_xMatch), + /*6394*/ uint16(x86_xCondDataSize), 6382, 6388, 6398, + /*6398*/ uint16(x86_xSetOp), uint16(x86_LGS), + /*6400*/ uint16(x86_xReadSlashR), + /*6401*/ uint16(x86_xArgR64), + /*6402*/ uint16(x86_xArgM16colon64), + /*6403*/ uint16(x86_xMatch), + /*6404*/ uint16(x86_xCondIs64), 6407, 6423, + /*6407*/ uint16(x86_xCondDataSize), 6411, 6417, 0, + /*6411*/ uint16(x86_xSetOp), uint16(x86_MOVZX), + /*6413*/ uint16(x86_xReadSlashR), + /*6414*/ uint16(x86_xArgR16), + /*6415*/ uint16(x86_xArgRM8), + /*6416*/ uint16(x86_xMatch), + /*6417*/ uint16(x86_xSetOp), uint16(x86_MOVZX), + /*6419*/ uint16(x86_xReadSlashR), + /*6420*/ uint16(x86_xArgR32), + /*6421*/ uint16(x86_xArgRM8), + /*6422*/ uint16(x86_xMatch), + /*6423*/ uint16(x86_xCondDataSize), 6411, 6417, 6427, + /*6427*/ uint16(x86_xSetOp), uint16(x86_MOVZX), + /*6429*/ uint16(x86_xReadSlashR), + /*6430*/ uint16(x86_xArgR64), + /*6431*/ uint16(x86_xArgRM8), + /*6432*/ uint16(x86_xMatch), + /*6433*/ uint16(x86_xCondIs64), 6436, 6452, + /*6436*/ uint16(x86_xCondDataSize), 6440, 6446, 0, + /*6440*/ uint16(x86_xSetOp), uint16(x86_MOVZX), + /*6442*/ uint16(x86_xReadSlashR), + /*6443*/ uint16(x86_xArgR16), + /*6444*/ uint16(x86_xArgRM16), + /*6445*/ uint16(x86_xMatch), + /*6446*/ uint16(x86_xSetOp), uint16(x86_MOVZX), + /*6448*/ uint16(x86_xReadSlashR), + /*6449*/ uint16(x86_xArgR32), + /*6450*/ uint16(x86_xArgRM16), + /*6451*/ uint16(x86_xMatch), + /*6452*/ uint16(x86_xCondDataSize), 6440, 6446, 6456, + /*6456*/ uint16(x86_xSetOp), uint16(x86_MOVZX), + /*6458*/ uint16(x86_xReadSlashR), + /*6459*/ uint16(x86_xArgR64), + /*6460*/ uint16(x86_xArgRM16), + /*6461*/ uint16(x86_xMatch), + /*6462*/ uint16(x86_xCondIs64), 6465, 6485, + /*6465*/ uint16(x86_xCondPrefix), 1, + 0xF3, 6469, + /*6469*/ uint16(x86_xCondDataSize), 6473, 6479, 0, + /*6473*/ uint16(x86_xSetOp), uint16(x86_POPCNT), + /*6475*/ uint16(x86_xReadSlashR), + /*6476*/ uint16(x86_xArgR16), + /*6477*/ uint16(x86_xArgRM16), + /*6478*/ uint16(x86_xMatch), + /*6479*/ uint16(x86_xSetOp), uint16(x86_POPCNT), + /*6481*/ uint16(x86_xReadSlashR), + /*6482*/ uint16(x86_xArgR32), + /*6483*/ uint16(x86_xArgRM32), + /*6484*/ uint16(x86_xMatch), + /*6485*/ uint16(x86_xCondPrefix), 1, + 0xF3, 6489, + /*6489*/ uint16(x86_xCondDataSize), 6473, 6479, 6493, + /*6493*/ uint16(x86_xSetOp), uint16(x86_POPCNT), + /*6495*/ uint16(x86_xReadSlashR), + /*6496*/ uint16(x86_xArgR64), + /*6497*/ uint16(x86_xArgRM64), + /*6498*/ uint16(x86_xMatch), + /*6499*/ uint16(x86_xSetOp), uint16(x86_UD1), + /*6501*/ uint16(x86_xMatch), + /*6502*/ uint16(x86_xCondSlashR), + 0, // 0 + 0, // 1 + 0, // 2 + 0, // 3 + 6511, // 4 + 6540, // 5 + 6569, // 6 + 6598, // 7 + /*6511*/ uint16(x86_xCondIs64), 6514, 6530, + /*6514*/ uint16(x86_xCondDataSize), 6518, 6524, 0, + /*6518*/ uint16(x86_xSetOp), uint16(x86_BT), + /*6520*/ uint16(x86_xReadIb), + /*6521*/ uint16(x86_xArgRM16), + /*6522*/ uint16(x86_xArgImm8u), + /*6523*/ uint16(x86_xMatch), + /*6524*/ uint16(x86_xSetOp), uint16(x86_BT), + /*6526*/ uint16(x86_xReadIb), + /*6527*/ uint16(x86_xArgRM32), + /*6528*/ uint16(x86_xArgImm8u), + /*6529*/ uint16(x86_xMatch), + /*6530*/ uint16(x86_xCondDataSize), 6518, 6524, 6534, + /*6534*/ uint16(x86_xSetOp), uint16(x86_BT), + /*6536*/ uint16(x86_xReadIb), + /*6537*/ uint16(x86_xArgRM64), + /*6538*/ uint16(x86_xArgImm8u), + /*6539*/ uint16(x86_xMatch), + /*6540*/ uint16(x86_xCondIs64), 6543, 6559, + /*6543*/ uint16(x86_xCondDataSize), 6547, 6553, 0, + /*6547*/ uint16(x86_xSetOp), uint16(x86_BTS), + /*6549*/ uint16(x86_xReadIb), + /*6550*/ uint16(x86_xArgRM16), + /*6551*/ uint16(x86_xArgImm8u), + /*6552*/ uint16(x86_xMatch), + /*6553*/ uint16(x86_xSetOp), uint16(x86_BTS), + /*6555*/ uint16(x86_xReadIb), + /*6556*/ uint16(x86_xArgRM32), + /*6557*/ uint16(x86_xArgImm8u), + /*6558*/ uint16(x86_xMatch), + /*6559*/ uint16(x86_xCondDataSize), 6547, 6553, 6563, + /*6563*/ uint16(x86_xSetOp), uint16(x86_BTS), + /*6565*/ uint16(x86_xReadIb), + /*6566*/ uint16(x86_xArgRM64), + /*6567*/ uint16(x86_xArgImm8u), + /*6568*/ uint16(x86_xMatch), + /*6569*/ uint16(x86_xCondIs64), 6572, 6588, + /*6572*/ uint16(x86_xCondDataSize), 6576, 6582, 0, + /*6576*/ uint16(x86_xSetOp), uint16(x86_BTR), + /*6578*/ uint16(x86_xReadIb), + /*6579*/ uint16(x86_xArgRM16), + /*6580*/ uint16(x86_xArgImm8u), + /*6581*/ uint16(x86_xMatch), + /*6582*/ uint16(x86_xSetOp), uint16(x86_BTR), + /*6584*/ uint16(x86_xReadIb), + /*6585*/ uint16(x86_xArgRM32), + /*6586*/ uint16(x86_xArgImm8u), + /*6587*/ uint16(x86_xMatch), + /*6588*/ uint16(x86_xCondDataSize), 6576, 6582, 6592, + /*6592*/ uint16(x86_xSetOp), uint16(x86_BTR), + /*6594*/ uint16(x86_xReadIb), + /*6595*/ uint16(x86_xArgRM64), + /*6596*/ uint16(x86_xArgImm8u), + /*6597*/ uint16(x86_xMatch), + /*6598*/ uint16(x86_xCondIs64), 6601, 6617, + /*6601*/ uint16(x86_xCondDataSize), 6605, 6611, 0, + /*6605*/ uint16(x86_xSetOp), uint16(x86_BTC), + /*6607*/ uint16(x86_xReadIb), + /*6608*/ uint16(x86_xArgRM16), + /*6609*/ uint16(x86_xArgImm8u), + /*6610*/ uint16(x86_xMatch), + /*6611*/ uint16(x86_xSetOp), uint16(x86_BTC), + /*6613*/ uint16(x86_xReadIb), + /*6614*/ uint16(x86_xArgRM32), + /*6615*/ uint16(x86_xArgImm8u), + /*6616*/ uint16(x86_xMatch), + /*6617*/ uint16(x86_xCondDataSize), 6605, 6611, 6621, + /*6621*/ uint16(x86_xSetOp), uint16(x86_BTC), + /*6623*/ uint16(x86_xReadIb), + /*6624*/ uint16(x86_xArgRM64), + /*6625*/ uint16(x86_xArgImm8u), + /*6626*/ uint16(x86_xMatch), + /*6627*/ uint16(x86_xCondIs64), 6630, 6646, + /*6630*/ uint16(x86_xCondDataSize), 6634, 6640, 0, + /*6634*/ uint16(x86_xSetOp), uint16(x86_BTC), + /*6636*/ uint16(x86_xReadSlashR), + /*6637*/ uint16(x86_xArgRM16), + /*6638*/ uint16(x86_xArgR16), + /*6639*/ uint16(x86_xMatch), + /*6640*/ uint16(x86_xSetOp), uint16(x86_BTC), + /*6642*/ uint16(x86_xReadSlashR), + /*6643*/ uint16(x86_xArgRM32), + /*6644*/ uint16(x86_xArgR32), + /*6645*/ uint16(x86_xMatch), + /*6646*/ uint16(x86_xCondDataSize), 6634, 6640, 6650, + /*6650*/ uint16(x86_xSetOp), uint16(x86_BTC), + /*6652*/ uint16(x86_xReadSlashR), + /*6653*/ uint16(x86_xArgRM64), + /*6654*/ uint16(x86_xArgR64), + /*6655*/ uint16(x86_xMatch), + /*6656*/ uint16(x86_xCondIs64), 6659, 6697, + /*6659*/ uint16(x86_xCondPrefix), 2, + 0xF3, 6681, + 0x0, 6665, + /*6665*/ uint16(x86_xCondDataSize), 6669, 6675, 0, + /*6669*/ uint16(x86_xSetOp), uint16(x86_BSF), + /*6671*/ uint16(x86_xReadSlashR), + /*6672*/ uint16(x86_xArgR16), + /*6673*/ uint16(x86_xArgRM16), + /*6674*/ uint16(x86_xMatch), + /*6675*/ uint16(x86_xSetOp), uint16(x86_BSF), + /*6677*/ uint16(x86_xReadSlashR), + /*6678*/ uint16(x86_xArgR32), + /*6679*/ uint16(x86_xArgRM32), + /*6680*/ uint16(x86_xMatch), + /*6681*/ uint16(x86_xCondDataSize), 6685, 6691, 0, + /*6685*/ uint16(x86_xSetOp), uint16(x86_TZCNT), + /*6687*/ uint16(x86_xReadSlashR), + /*6688*/ uint16(x86_xArgR16), + /*6689*/ uint16(x86_xArgRM16), + /*6690*/ uint16(x86_xMatch), + /*6691*/ uint16(x86_xSetOp), uint16(x86_TZCNT), + /*6693*/ uint16(x86_xReadSlashR), + /*6694*/ uint16(x86_xArgR32), + /*6695*/ uint16(x86_xArgRM32), + /*6696*/ uint16(x86_xMatch), + /*6697*/ uint16(x86_xCondPrefix), 2, + 0xF3, 6713, + 0x0, 6703, + /*6703*/ uint16(x86_xCondDataSize), 6669, 6675, 6707, + /*6707*/ uint16(x86_xSetOp), uint16(x86_BSF), + /*6709*/ uint16(x86_xReadSlashR), + /*6710*/ uint16(x86_xArgR64), + /*6711*/ uint16(x86_xArgRM64), + /*6712*/ uint16(x86_xMatch), + /*6713*/ uint16(x86_xCondDataSize), 6685, 6691, 6717, + /*6717*/ uint16(x86_xSetOp), uint16(x86_TZCNT), + /*6719*/ uint16(x86_xReadSlashR), + /*6720*/ uint16(x86_xArgR64), + /*6721*/ uint16(x86_xArgRM64), + /*6722*/ uint16(x86_xMatch), + /*6723*/ uint16(x86_xCondIs64), 6726, 6764, + /*6726*/ uint16(x86_xCondPrefix), 2, + 0xF3, 6748, + 0x0, 6732, + /*6732*/ uint16(x86_xCondDataSize), 6736, 6742, 0, + /*6736*/ uint16(x86_xSetOp), uint16(x86_BSR), + /*6738*/ uint16(x86_xReadSlashR), + /*6739*/ uint16(x86_xArgR16), + /*6740*/ uint16(x86_xArgRM16), + /*6741*/ uint16(x86_xMatch), + /*6742*/ uint16(x86_xSetOp), uint16(x86_BSR), + /*6744*/ uint16(x86_xReadSlashR), + /*6745*/ uint16(x86_xArgR32), + /*6746*/ uint16(x86_xArgRM32), + /*6747*/ uint16(x86_xMatch), + /*6748*/ uint16(x86_xCondDataSize), 6752, 6758, 0, + /*6752*/ uint16(x86_xSetOp), uint16(x86_LZCNT), + /*6754*/ uint16(x86_xReadSlashR), + /*6755*/ uint16(x86_xArgR16), + /*6756*/ uint16(x86_xArgRM16), + /*6757*/ uint16(x86_xMatch), + /*6758*/ uint16(x86_xSetOp), uint16(x86_LZCNT), + /*6760*/ uint16(x86_xReadSlashR), + /*6761*/ uint16(x86_xArgR32), + /*6762*/ uint16(x86_xArgRM32), + /*6763*/ uint16(x86_xMatch), + /*6764*/ uint16(x86_xCondPrefix), 2, + 0xF3, 6780, + 0x0, 6770, + /*6770*/ uint16(x86_xCondDataSize), 6736, 6742, 6774, + /*6774*/ uint16(x86_xSetOp), uint16(x86_BSR), + /*6776*/ uint16(x86_xReadSlashR), + /*6777*/ uint16(x86_xArgR64), + /*6778*/ uint16(x86_xArgRM64), + /*6779*/ uint16(x86_xMatch), + /*6780*/ uint16(x86_xCondDataSize), 6752, 6758, 6784, + /*6784*/ uint16(x86_xSetOp), uint16(x86_LZCNT), + /*6786*/ uint16(x86_xReadSlashR), + /*6787*/ uint16(x86_xArgR64), + /*6788*/ uint16(x86_xArgRM64), + /*6789*/ uint16(x86_xMatch), + /*6790*/ uint16(x86_xCondIs64), 6793, 6809, + /*6793*/ uint16(x86_xCondDataSize), 6797, 6803, 0, + /*6797*/ uint16(x86_xSetOp), uint16(x86_MOVSX), + /*6799*/ uint16(x86_xReadSlashR), + /*6800*/ uint16(x86_xArgR16), + /*6801*/ uint16(x86_xArgRM8), + /*6802*/ uint16(x86_xMatch), + /*6803*/ uint16(x86_xSetOp), uint16(x86_MOVSX), + /*6805*/ uint16(x86_xReadSlashR), + /*6806*/ uint16(x86_xArgR32), + /*6807*/ uint16(x86_xArgRM8), + /*6808*/ uint16(x86_xMatch), + /*6809*/ uint16(x86_xCondDataSize), 6797, 6803, 6813, + /*6813*/ uint16(x86_xSetOp), uint16(x86_MOVSX), + /*6815*/ uint16(x86_xReadSlashR), + /*6816*/ uint16(x86_xArgR64), + /*6817*/ uint16(x86_xArgRM8), + /*6818*/ uint16(x86_xMatch), + /*6819*/ uint16(x86_xCondIs64), 6822, 6838, + /*6822*/ uint16(x86_xCondDataSize), 6826, 6832, 0, + /*6826*/ uint16(x86_xSetOp), uint16(x86_MOVSX), + /*6828*/ uint16(x86_xReadSlashR), + /*6829*/ uint16(x86_xArgR16), + /*6830*/ uint16(x86_xArgRM16), + /*6831*/ uint16(x86_xMatch), + /*6832*/ uint16(x86_xSetOp), uint16(x86_MOVSX), + /*6834*/ uint16(x86_xReadSlashR), + /*6835*/ uint16(x86_xArgR32), + /*6836*/ uint16(x86_xArgRM16), + /*6837*/ uint16(x86_xMatch), + /*6838*/ uint16(x86_xCondDataSize), 6826, 6832, 6842, + /*6842*/ uint16(x86_xSetOp), uint16(x86_MOVSX), + /*6844*/ uint16(x86_xReadSlashR), + /*6845*/ uint16(x86_xArgR64), + /*6846*/ uint16(x86_xArgRM16), + /*6847*/ uint16(x86_xMatch), + /*6848*/ uint16(x86_xSetOp), uint16(x86_XADD), + /*6850*/ uint16(x86_xReadSlashR), + /*6851*/ uint16(x86_xArgRM8), + /*6852*/ uint16(x86_xArgR8), + /*6853*/ uint16(x86_xMatch), + /*6854*/ uint16(x86_xCondIs64), 6857, 6873, + /*6857*/ uint16(x86_xCondDataSize), 6861, 6867, 0, + /*6861*/ uint16(x86_xSetOp), uint16(x86_XADD), + /*6863*/ uint16(x86_xReadSlashR), + /*6864*/ uint16(x86_xArgRM16), + /*6865*/ uint16(x86_xArgR16), + /*6866*/ uint16(x86_xMatch), + /*6867*/ uint16(x86_xSetOp), uint16(x86_XADD), + /*6869*/ uint16(x86_xReadSlashR), + /*6870*/ uint16(x86_xArgRM32), + /*6871*/ uint16(x86_xArgR32), + /*6872*/ uint16(x86_xMatch), + /*6873*/ uint16(x86_xCondDataSize), 6861, 6867, 6877, + /*6877*/ uint16(x86_xSetOp), uint16(x86_XADD), + /*6879*/ uint16(x86_xReadSlashR), + /*6880*/ uint16(x86_xArgRM64), + /*6881*/ uint16(x86_xArgR64), + /*6882*/ uint16(x86_xMatch), + /*6883*/ uint16(x86_xCondPrefix), 4, + 0xF3, 6917, + 0xF2, 6909, + 0x66, 6901, + 0x0, 6893, + /*6893*/ uint16(x86_xSetOp), uint16(x86_CMPPS), + /*6895*/ uint16(x86_xReadSlashR), + /*6896*/ uint16(x86_xReadIb), + /*6897*/ uint16(x86_xArgXmm1), + /*6898*/ uint16(x86_xArgXmm2M128), + /*6899*/ uint16(x86_xArgImm8u), + /*6900*/ uint16(x86_xMatch), + /*6901*/ uint16(x86_xSetOp), uint16(x86_CMPPD), + /*6903*/ uint16(x86_xReadSlashR), + /*6904*/ uint16(x86_xReadIb), + /*6905*/ uint16(x86_xArgXmm1), + /*6906*/ uint16(x86_xArgXmm2M128), + /*6907*/ uint16(x86_xArgImm8u), + /*6908*/ uint16(x86_xMatch), + /*6909*/ uint16(x86_xSetOp), uint16(x86_CMPSD_XMM), + /*6911*/ uint16(x86_xReadSlashR), + /*6912*/ uint16(x86_xReadIb), + /*6913*/ uint16(x86_xArgXmm1), + /*6914*/ uint16(x86_xArgXmm2M64), + /*6915*/ uint16(x86_xArgImm8u), + /*6916*/ uint16(x86_xMatch), + /*6917*/ uint16(x86_xSetOp), uint16(x86_CMPSS), + /*6919*/ uint16(x86_xReadSlashR), + /*6920*/ uint16(x86_xReadIb), + /*6921*/ uint16(x86_xArgXmm1), + /*6922*/ uint16(x86_xArgXmm2M32), + /*6923*/ uint16(x86_xArgImm8u), + /*6924*/ uint16(x86_xMatch), + /*6925*/ uint16(x86_xCondIs64), 6928, 6944, + /*6928*/ uint16(x86_xCondDataSize), 6932, 6938, 0, + /*6932*/ uint16(x86_xSetOp), uint16(x86_MOVNTI), + /*6934*/ uint16(x86_xReadSlashR), + /*6935*/ uint16(x86_xArgM32), + /*6936*/ uint16(x86_xArgR32), + /*6937*/ uint16(x86_xMatch), + /*6938*/ uint16(x86_xSetOp), uint16(x86_MOVNTI), + /*6940*/ uint16(x86_xReadSlashR), + /*6941*/ uint16(x86_xArgM32), + /*6942*/ uint16(x86_xArgR32), + /*6943*/ uint16(x86_xMatch), + /*6944*/ uint16(x86_xCondDataSize), 6932, 6938, 6948, + /*6948*/ uint16(x86_xSetOp), uint16(x86_MOVNTI), + /*6950*/ uint16(x86_xReadSlashR), + /*6951*/ uint16(x86_xArgM64), + /*6952*/ uint16(x86_xArgR64), + /*6953*/ uint16(x86_xMatch), + /*6954*/ uint16(x86_xCondPrefix), 2, + 0x66, 6968, + 0x0, 6960, + /*6960*/ uint16(x86_xSetOp), uint16(x86_PINSRW), + /*6962*/ uint16(x86_xReadSlashR), + /*6963*/ uint16(x86_xReadIb), + /*6964*/ uint16(x86_xArgMm), + /*6965*/ uint16(x86_xArgR32M16), + /*6966*/ uint16(x86_xArgImm8u), + /*6967*/ uint16(x86_xMatch), + /*6968*/ uint16(x86_xSetOp), uint16(x86_PINSRW), + /*6970*/ uint16(x86_xReadSlashR), + /*6971*/ uint16(x86_xReadIb), + /*6972*/ uint16(x86_xArgXmm), + /*6973*/ uint16(x86_xArgR32M16), + /*6974*/ uint16(x86_xArgImm8u), + /*6975*/ uint16(x86_xMatch), + /*6976*/ uint16(x86_xCondPrefix), 2, + 0x66, 6990, + 0x0, 6982, + /*6982*/ uint16(x86_xSetOp), uint16(x86_PEXTRW), + /*6984*/ uint16(x86_xReadSlashR), + /*6985*/ uint16(x86_xReadIb), + /*6986*/ uint16(x86_xArgR32), + /*6987*/ uint16(x86_xArgMm2), + /*6988*/ uint16(x86_xArgImm8u), + /*6989*/ uint16(x86_xMatch), + /*6990*/ uint16(x86_xSetOp), uint16(x86_PEXTRW), + /*6992*/ uint16(x86_xReadSlashR), + /*6993*/ uint16(x86_xReadIb), + /*6994*/ uint16(x86_xArgR32), + /*6995*/ uint16(x86_xArgXmm2), + /*6996*/ uint16(x86_xArgImm8u), + /*6997*/ uint16(x86_xMatch), + /*6998*/ uint16(x86_xCondPrefix), 2, + 0x66, 7012, + 0x0, 7004, + /*7004*/ uint16(x86_xSetOp), uint16(x86_SHUFPS), + /*7006*/ uint16(x86_xReadSlashR), + /*7007*/ uint16(x86_xReadIb), + /*7008*/ uint16(x86_xArgXmm1), + /*7009*/ uint16(x86_xArgXmm2M128), + /*7010*/ uint16(x86_xArgImm8u), + /*7011*/ uint16(x86_xMatch), + /*7012*/ uint16(x86_xSetOp), uint16(x86_SHUFPD), + /*7014*/ uint16(x86_xReadSlashR), + /*7015*/ uint16(x86_xReadIb), + /*7016*/ uint16(x86_xArgXmm1), + /*7017*/ uint16(x86_xArgXmm2M128), + /*7018*/ uint16(x86_xArgImm8u), + /*7019*/ uint16(x86_xMatch), + /*7020*/ uint16(x86_xCondSlashR), + 0, // 0 + 7029, // 1 + 0, // 2 + 7052, // 3 + 7075, // 4 + 7098, // 5 + 7121, // 6 + 0, // 7 + /*7029*/ uint16(x86_xCondIs64), 7032, 7044, + /*7032*/ uint16(x86_xCondDataSize), 7036, 7040, 0, + /*7036*/ uint16(x86_xSetOp), uint16(x86_CMPXCHG8B), + /*7038*/ uint16(x86_xArgM64), + /*7039*/ uint16(x86_xMatch), + /*7040*/ uint16(x86_xSetOp), uint16(x86_CMPXCHG8B), + /*7042*/ uint16(x86_xArgM64), + /*7043*/ uint16(x86_xMatch), + /*7044*/ uint16(x86_xCondDataSize), 7036, 7040, 7048, + /*7048*/ uint16(x86_xSetOp), uint16(x86_CMPXCHG16B), + /*7050*/ uint16(x86_xArgM128), + /*7051*/ uint16(x86_xMatch), + /*7052*/ uint16(x86_xCondIs64), 7055, 7067, + /*7055*/ uint16(x86_xCondDataSize), 7059, 7063, 0, + /*7059*/ uint16(x86_xSetOp), uint16(x86_XRSTORS), + /*7061*/ uint16(x86_xArgMem), + /*7062*/ uint16(x86_xMatch), + /*7063*/ uint16(x86_xSetOp), uint16(x86_XRSTORS), + /*7065*/ uint16(x86_xArgMem), + /*7066*/ uint16(x86_xMatch), + /*7067*/ uint16(x86_xCondDataSize), 7059, 7063, 7071, + /*7071*/ uint16(x86_xSetOp), uint16(x86_XRSTORS64), + /*7073*/ uint16(x86_xArgMem), + /*7074*/ uint16(x86_xMatch), + /*7075*/ uint16(x86_xCondIs64), 7078, 7090, + /*7078*/ uint16(x86_xCondDataSize), 7082, 7086, 0, + /*7082*/ uint16(x86_xSetOp), uint16(x86_XSAVEC), + /*7084*/ uint16(x86_xArgMem), + /*7085*/ uint16(x86_xMatch), + /*7086*/ uint16(x86_xSetOp), uint16(x86_XSAVEC), + /*7088*/ uint16(x86_xArgMem), + /*7089*/ uint16(x86_xMatch), + /*7090*/ uint16(x86_xCondDataSize), 7082, 7086, 7094, + /*7094*/ uint16(x86_xSetOp), uint16(x86_XSAVEC64), + /*7096*/ uint16(x86_xArgMem), + /*7097*/ uint16(x86_xMatch), + /*7098*/ uint16(x86_xCondIs64), 7101, 7113, + /*7101*/ uint16(x86_xCondDataSize), 7105, 7109, 0, + /*7105*/ uint16(x86_xSetOp), uint16(x86_XSAVES), + /*7107*/ uint16(x86_xArgMem), + /*7108*/ uint16(x86_xMatch), + /*7109*/ uint16(x86_xSetOp), uint16(x86_XSAVES), + /*7111*/ uint16(x86_xArgMem), + /*7112*/ uint16(x86_xMatch), + /*7113*/ uint16(x86_xCondDataSize), 7105, 7109, 7117, + /*7117*/ uint16(x86_xSetOp), uint16(x86_XSAVES64), + /*7119*/ uint16(x86_xArgMem), + /*7120*/ uint16(x86_xMatch), + /*7121*/ uint16(x86_xCondIs64), 7124, 7142, + /*7124*/ uint16(x86_xCondDataSize), 7128, 7135, 0, + /*7128*/ uint16(x86_xCondIsMem), 7131, 0, + /*7131*/ uint16(x86_xSetOp), uint16(x86_RDRAND), + /*7133*/ uint16(x86_xArgRmf16), + /*7134*/ uint16(x86_xMatch), + /*7135*/ uint16(x86_xCondIsMem), 7138, 0, + /*7138*/ uint16(x86_xSetOp), uint16(x86_RDRAND), + /*7140*/ uint16(x86_xArgRmf32), + /*7141*/ uint16(x86_xMatch), + /*7142*/ uint16(x86_xCondDataSize), 7128, 7135, 7146, + /*7146*/ uint16(x86_xSetOp), uint16(x86_RDRAND), + /*7148*/ uint16(x86_xMatch), + /*7149*/ uint16(x86_xCondIs64), 7152, 7164, + /*7152*/ uint16(x86_xCondDataSize), 7156, 7160, 0, + /*7156*/ uint16(x86_xSetOp), uint16(x86_BSWAP), + /*7158*/ uint16(x86_xArgR16op), + /*7159*/ uint16(x86_xMatch), + /*7160*/ uint16(x86_xSetOp), uint16(x86_BSWAP), + /*7162*/ uint16(x86_xArgR32op), + /*7163*/ uint16(x86_xMatch), + /*7164*/ uint16(x86_xCondDataSize), 7156, 7160, 7168, + /*7168*/ uint16(x86_xSetOp), uint16(x86_BSWAP), + /*7170*/ uint16(x86_xArgR64op), + /*7171*/ uint16(x86_xMatch), + /*7172*/ uint16(x86_xCondPrefix), 2, + 0xF2, 7184, + 0x66, 7178, + /*7178*/ uint16(x86_xSetOp), uint16(x86_ADDSUBPD), + /*7180*/ uint16(x86_xReadSlashR), + /*7181*/ uint16(x86_xArgXmm1), + /*7182*/ uint16(x86_xArgXmm2M128), + /*7183*/ uint16(x86_xMatch), + /*7184*/ uint16(x86_xSetOp), uint16(x86_ADDSUBPS), + /*7186*/ uint16(x86_xReadSlashR), + /*7187*/ uint16(x86_xArgXmm1), + /*7188*/ uint16(x86_xArgXmm2M128), + /*7189*/ uint16(x86_xMatch), + /*7190*/ uint16(x86_xCondPrefix), 2, + 0x66, 7202, + 0x0, 7196, + /*7196*/ uint16(x86_xSetOp), uint16(x86_PSRLW), + /*7198*/ uint16(x86_xReadSlashR), + /*7199*/ uint16(x86_xArgMm), + /*7200*/ uint16(x86_xArgMmM64), + /*7201*/ uint16(x86_xMatch), + /*7202*/ uint16(x86_xSetOp), uint16(x86_PSRLW), + /*7204*/ uint16(x86_xReadSlashR), + /*7205*/ uint16(x86_xArgXmm1), + /*7206*/ uint16(x86_xArgXmm2M128), + /*7207*/ uint16(x86_xMatch), + /*7208*/ uint16(x86_xCondPrefix), 2, + 0x66, 7220, + 0x0, 7214, + /*7214*/ uint16(x86_xSetOp), uint16(x86_PSRLD), + /*7216*/ uint16(x86_xReadSlashR), + /*7217*/ uint16(x86_xArgMm), + /*7218*/ uint16(x86_xArgMmM64), + /*7219*/ uint16(x86_xMatch), + /*7220*/ uint16(x86_xSetOp), uint16(x86_PSRLD), + /*7222*/ uint16(x86_xReadSlashR), + /*7223*/ uint16(x86_xArgXmm1), + /*7224*/ uint16(x86_xArgXmm2M128), + /*7225*/ uint16(x86_xMatch), + /*7226*/ uint16(x86_xCondPrefix), 2, + 0x66, 7238, + 0x0, 7232, + /*7232*/ uint16(x86_xSetOp), uint16(x86_PSRLQ), + /*7234*/ uint16(x86_xReadSlashR), + /*7235*/ uint16(x86_xArgMm), + /*7236*/ uint16(x86_xArgMmM64), + /*7237*/ uint16(x86_xMatch), + /*7238*/ uint16(x86_xSetOp), uint16(x86_PSRLQ), + /*7240*/ uint16(x86_xReadSlashR), + /*7241*/ uint16(x86_xArgXmm1), + /*7242*/ uint16(x86_xArgXmm2M128), + /*7243*/ uint16(x86_xMatch), + /*7244*/ uint16(x86_xCondPrefix), 2, + 0x66, 7256, + 0x0, 7250, + /*7250*/ uint16(x86_xSetOp), uint16(x86_PADDQ), + /*7252*/ uint16(x86_xReadSlashR), + /*7253*/ uint16(x86_xArgMm1), + /*7254*/ uint16(x86_xArgMm2M64), + /*7255*/ uint16(x86_xMatch), + /*7256*/ uint16(x86_xSetOp), uint16(x86_PADDQ), + /*7258*/ uint16(x86_xReadSlashR), + /*7259*/ uint16(x86_xArgXmm1), + /*7260*/ uint16(x86_xArgXmm2M128), + /*7261*/ uint16(x86_xMatch), + /*7262*/ uint16(x86_xCondPrefix), 2, + 0x66, 7274, + 0x0, 7268, + /*7268*/ uint16(x86_xSetOp), uint16(x86_PMULLW), + /*7270*/ uint16(x86_xReadSlashR), + /*7271*/ uint16(x86_xArgMm), + /*7272*/ uint16(x86_xArgMmM64), + /*7273*/ uint16(x86_xMatch), + /*7274*/ uint16(x86_xSetOp), uint16(x86_PMULLW), + /*7276*/ uint16(x86_xReadSlashR), + /*7277*/ uint16(x86_xArgXmm1), + /*7278*/ uint16(x86_xArgXmm2M128), + /*7279*/ uint16(x86_xMatch), + /*7280*/ uint16(x86_xCondPrefix), 3, + 0xF3, 7300, + 0xF2, 7294, + 0x66, 7288, + /*7288*/ uint16(x86_xSetOp), uint16(x86_MOVQ), + /*7290*/ uint16(x86_xReadSlashR), + /*7291*/ uint16(x86_xArgXmm2M64), + /*7292*/ uint16(x86_xArgXmm1), + /*7293*/ uint16(x86_xMatch), + /*7294*/ uint16(x86_xSetOp), uint16(x86_MOVDQ2Q), + /*7296*/ uint16(x86_xReadSlashR), + /*7297*/ uint16(x86_xArgMm), + /*7298*/ uint16(x86_xArgXmm2), + /*7299*/ uint16(x86_xMatch), + /*7300*/ uint16(x86_xSetOp), uint16(x86_MOVQ2DQ), + /*7302*/ uint16(x86_xReadSlashR), + /*7303*/ uint16(x86_xArgXmm1), + /*7304*/ uint16(x86_xArgMm2), + /*7305*/ uint16(x86_xMatch), + /*7306*/ uint16(x86_xCondPrefix), 2, + 0x66, 7318, + 0x0, 7312, + /*7312*/ uint16(x86_xSetOp), uint16(x86_PMOVMSKB), + /*7314*/ uint16(x86_xReadSlashR), + /*7315*/ uint16(x86_xArgR32), + /*7316*/ uint16(x86_xArgMm2), + /*7317*/ uint16(x86_xMatch), + /*7318*/ uint16(x86_xSetOp), uint16(x86_PMOVMSKB), + /*7320*/ uint16(x86_xReadSlashR), + /*7321*/ uint16(x86_xArgR32), + /*7322*/ uint16(x86_xArgXmm2), + /*7323*/ uint16(x86_xMatch), + /*7324*/ uint16(x86_xCondPrefix), 2, + 0x66, 7336, + 0x0, 7330, + /*7330*/ uint16(x86_xSetOp), uint16(x86_PSUBUSB), + /*7332*/ uint16(x86_xReadSlashR), + /*7333*/ uint16(x86_xArgMm), + /*7334*/ uint16(x86_xArgMmM64), + /*7335*/ uint16(x86_xMatch), + /*7336*/ uint16(x86_xSetOp), uint16(x86_PSUBUSB), + /*7338*/ uint16(x86_xReadSlashR), + /*7339*/ uint16(x86_xArgXmm1), + /*7340*/ uint16(x86_xArgXmm2M128), + /*7341*/ uint16(x86_xMatch), + /*7342*/ uint16(x86_xCondPrefix), 2, + 0x66, 7354, + 0x0, 7348, + /*7348*/ uint16(x86_xSetOp), uint16(x86_PSUBUSW), + /*7350*/ uint16(x86_xReadSlashR), + /*7351*/ uint16(x86_xArgMm), + /*7352*/ uint16(x86_xArgMmM64), + /*7353*/ uint16(x86_xMatch), + /*7354*/ uint16(x86_xSetOp), uint16(x86_PSUBUSW), + /*7356*/ uint16(x86_xReadSlashR), + /*7357*/ uint16(x86_xArgXmm1), + /*7358*/ uint16(x86_xArgXmm2M128), + /*7359*/ uint16(x86_xMatch), + /*7360*/ uint16(x86_xCondPrefix), 2, + 0x66, 7372, + 0x0, 7366, + /*7366*/ uint16(x86_xSetOp), uint16(x86_PMINUB), + /*7368*/ uint16(x86_xReadSlashR), + /*7369*/ uint16(x86_xArgMm1), + /*7370*/ uint16(x86_xArgMm2M64), + /*7371*/ uint16(x86_xMatch), + /*7372*/ uint16(x86_xSetOp), uint16(x86_PMINUB), + /*7374*/ uint16(x86_xReadSlashR), + /*7375*/ uint16(x86_xArgXmm1), + /*7376*/ uint16(x86_xArgXmm2M128), + /*7377*/ uint16(x86_xMatch), + /*7378*/ uint16(x86_xCondPrefix), 2, + 0x66, 7390, + 0x0, 7384, + /*7384*/ uint16(x86_xSetOp), uint16(x86_PAND), + /*7386*/ uint16(x86_xReadSlashR), + /*7387*/ uint16(x86_xArgMm), + /*7388*/ uint16(x86_xArgMmM64), + /*7389*/ uint16(x86_xMatch), + /*7390*/ uint16(x86_xSetOp), uint16(x86_PAND), + /*7392*/ uint16(x86_xReadSlashR), + /*7393*/ uint16(x86_xArgXmm1), + /*7394*/ uint16(x86_xArgXmm2M128), + /*7395*/ uint16(x86_xMatch), + /*7396*/ uint16(x86_xCondPrefix), 2, + 0x66, 7408, + 0x0, 7402, + /*7402*/ uint16(x86_xSetOp), uint16(x86_PADDUSB), + /*7404*/ uint16(x86_xReadSlashR), + /*7405*/ uint16(x86_xArgMm), + /*7406*/ uint16(x86_xArgMmM64), + /*7407*/ uint16(x86_xMatch), + /*7408*/ uint16(x86_xSetOp), uint16(x86_PADDUSB), + /*7410*/ uint16(x86_xReadSlashR), + /*7411*/ uint16(x86_xArgXmm1), + /*7412*/ uint16(x86_xArgXmm2M128), + /*7413*/ uint16(x86_xMatch), + /*7414*/ uint16(x86_xCondPrefix), 2, + 0x66, 7426, + 0x0, 7420, + /*7420*/ uint16(x86_xSetOp), uint16(x86_PADDUSW), + /*7422*/ uint16(x86_xReadSlashR), + /*7423*/ uint16(x86_xArgMm), + /*7424*/ uint16(x86_xArgMmM64), + /*7425*/ uint16(x86_xMatch), + /*7426*/ uint16(x86_xSetOp), uint16(x86_PADDUSW), + /*7428*/ uint16(x86_xReadSlashR), + /*7429*/ uint16(x86_xArgXmm1), + /*7430*/ uint16(x86_xArgXmm2M128), + /*7431*/ uint16(x86_xMatch), + /*7432*/ uint16(x86_xCondPrefix), 2, + 0x66, 7444, + 0x0, 7438, + /*7438*/ uint16(x86_xSetOp), uint16(x86_PMAXUB), + /*7440*/ uint16(x86_xReadSlashR), + /*7441*/ uint16(x86_xArgMm1), + /*7442*/ uint16(x86_xArgMm2M64), + /*7443*/ uint16(x86_xMatch), + /*7444*/ uint16(x86_xSetOp), uint16(x86_PMAXUB), + /*7446*/ uint16(x86_xReadSlashR), + /*7447*/ uint16(x86_xArgXmm1), + /*7448*/ uint16(x86_xArgXmm2M128), + /*7449*/ uint16(x86_xMatch), + /*7450*/ uint16(x86_xCondPrefix), 2, + 0x66, 7462, + 0x0, 7456, + /*7456*/ uint16(x86_xSetOp), uint16(x86_PANDN), + /*7458*/ uint16(x86_xReadSlashR), + /*7459*/ uint16(x86_xArgMm), + /*7460*/ uint16(x86_xArgMmM64), + /*7461*/ uint16(x86_xMatch), + /*7462*/ uint16(x86_xSetOp), uint16(x86_PANDN), + /*7464*/ uint16(x86_xReadSlashR), + /*7465*/ uint16(x86_xArgXmm1), + /*7466*/ uint16(x86_xArgXmm2M128), + /*7467*/ uint16(x86_xMatch), + /*7468*/ uint16(x86_xCondPrefix), 2, + 0x66, 7480, + 0x0, 7474, + /*7474*/ uint16(x86_xSetOp), uint16(x86_PAVGB), + /*7476*/ uint16(x86_xReadSlashR), + /*7477*/ uint16(x86_xArgMm1), + /*7478*/ uint16(x86_xArgMm2M64), + /*7479*/ uint16(x86_xMatch), + /*7480*/ uint16(x86_xSetOp), uint16(x86_PAVGB), + /*7482*/ uint16(x86_xReadSlashR), + /*7483*/ uint16(x86_xArgXmm1), + /*7484*/ uint16(x86_xArgXmm2M128), + /*7485*/ uint16(x86_xMatch), + /*7486*/ uint16(x86_xCondPrefix), 2, + 0x66, 7498, + 0x0, 7492, + /*7492*/ uint16(x86_xSetOp), uint16(x86_PSRAW), + /*7494*/ uint16(x86_xReadSlashR), + /*7495*/ uint16(x86_xArgMm), + /*7496*/ uint16(x86_xArgMmM64), + /*7497*/ uint16(x86_xMatch), + /*7498*/ uint16(x86_xSetOp), uint16(x86_PSRAW), + /*7500*/ uint16(x86_xReadSlashR), + /*7501*/ uint16(x86_xArgXmm1), + /*7502*/ uint16(x86_xArgXmm2M128), + /*7503*/ uint16(x86_xMatch), + /*7504*/ uint16(x86_xCondPrefix), 2, + 0x66, 7516, + 0x0, 7510, + /*7510*/ uint16(x86_xSetOp), uint16(x86_PSRAD), + /*7512*/ uint16(x86_xReadSlashR), + /*7513*/ uint16(x86_xArgMm), + /*7514*/ uint16(x86_xArgMmM64), + /*7515*/ uint16(x86_xMatch), + /*7516*/ uint16(x86_xSetOp), uint16(x86_PSRAD), + /*7518*/ uint16(x86_xReadSlashR), + /*7519*/ uint16(x86_xArgXmm1), + /*7520*/ uint16(x86_xArgXmm2M128), + /*7521*/ uint16(x86_xMatch), + /*7522*/ uint16(x86_xCondPrefix), 2, + 0x66, 7534, + 0x0, 7528, + /*7528*/ uint16(x86_xSetOp), uint16(x86_PAVGW), + /*7530*/ uint16(x86_xReadSlashR), + /*7531*/ uint16(x86_xArgMm1), + /*7532*/ uint16(x86_xArgMm2M64), + /*7533*/ uint16(x86_xMatch), + /*7534*/ uint16(x86_xSetOp), uint16(x86_PAVGW), + /*7536*/ uint16(x86_xReadSlashR), + /*7537*/ uint16(x86_xArgXmm1), + /*7538*/ uint16(x86_xArgXmm2M128), + /*7539*/ uint16(x86_xMatch), + /*7540*/ uint16(x86_xCondPrefix), 2, + 0x66, 7552, + 0x0, 7546, + /*7546*/ uint16(x86_xSetOp), uint16(x86_PMULHUW), + /*7548*/ uint16(x86_xReadSlashR), + /*7549*/ uint16(x86_xArgMm1), + /*7550*/ uint16(x86_xArgMm2M64), + /*7551*/ uint16(x86_xMatch), + /*7552*/ uint16(x86_xSetOp), uint16(x86_PMULHUW), + /*7554*/ uint16(x86_xReadSlashR), + /*7555*/ uint16(x86_xArgXmm1), + /*7556*/ uint16(x86_xArgXmm2M128), + /*7557*/ uint16(x86_xMatch), + /*7558*/ uint16(x86_xCondPrefix), 2, + 0x66, 7570, + 0x0, 7564, + /*7564*/ uint16(x86_xSetOp), uint16(x86_PMULHW), + /*7566*/ uint16(x86_xReadSlashR), + /*7567*/ uint16(x86_xArgMm), + /*7568*/ uint16(x86_xArgMmM64), + /*7569*/ uint16(x86_xMatch), + /*7570*/ uint16(x86_xSetOp), uint16(x86_PMULHW), + /*7572*/ uint16(x86_xReadSlashR), + /*7573*/ uint16(x86_xArgXmm1), + /*7574*/ uint16(x86_xArgXmm2M128), + /*7575*/ uint16(x86_xMatch), + /*7576*/ uint16(x86_xCondPrefix), 3, + 0xF3, 7596, + 0xF2, 7590, + 0x66, 7584, + /*7584*/ uint16(x86_xSetOp), uint16(x86_CVTTPD2DQ), + /*7586*/ uint16(x86_xReadSlashR), + /*7587*/ uint16(x86_xArgXmm1), + /*7588*/ uint16(x86_xArgXmm2M128), + /*7589*/ uint16(x86_xMatch), + /*7590*/ uint16(x86_xSetOp), uint16(x86_CVTPD2DQ), + /*7592*/ uint16(x86_xReadSlashR), + /*7593*/ uint16(x86_xArgXmm1), + /*7594*/ uint16(x86_xArgXmm2M128), + /*7595*/ uint16(x86_xMatch), + /*7596*/ uint16(x86_xSetOp), uint16(x86_CVTDQ2PD), + /*7598*/ uint16(x86_xReadSlashR), + /*7599*/ uint16(x86_xArgXmm1), + /*7600*/ uint16(x86_xArgXmm2M64), + /*7601*/ uint16(x86_xMatch), + /*7602*/ uint16(x86_xCondPrefix), 2, + 0x66, 7614, + 0x0, 7608, + /*7608*/ uint16(x86_xSetOp), uint16(x86_MOVNTQ), + /*7610*/ uint16(x86_xReadSlashR), + /*7611*/ uint16(x86_xArgM64), + /*7612*/ uint16(x86_xArgMm), + /*7613*/ uint16(x86_xMatch), + /*7614*/ uint16(x86_xSetOp), uint16(x86_MOVNTDQ), + /*7616*/ uint16(x86_xReadSlashR), + /*7617*/ uint16(x86_xArgM128), + /*7618*/ uint16(x86_xArgXmm), + /*7619*/ uint16(x86_xMatch), + /*7620*/ uint16(x86_xCondPrefix), 2, + 0x66, 7632, + 0x0, 7626, + /*7626*/ uint16(x86_xSetOp), uint16(x86_PSUBSB), + /*7628*/ uint16(x86_xReadSlashR), + /*7629*/ uint16(x86_xArgMm), + /*7630*/ uint16(x86_xArgMmM64), + /*7631*/ uint16(x86_xMatch), + /*7632*/ uint16(x86_xSetOp), uint16(x86_PSUBSB), + /*7634*/ uint16(x86_xReadSlashR), + /*7635*/ uint16(x86_xArgXmm1), + /*7636*/ uint16(x86_xArgXmm2M128), + /*7637*/ uint16(x86_xMatch), + /*7638*/ uint16(x86_xCondPrefix), 2, + 0x66, 7650, + 0x0, 7644, + /*7644*/ uint16(x86_xSetOp), uint16(x86_PSUBSW), + /*7646*/ uint16(x86_xReadSlashR), + /*7647*/ uint16(x86_xArgMm), + /*7648*/ uint16(x86_xArgMmM64), + /*7649*/ uint16(x86_xMatch), + /*7650*/ uint16(x86_xSetOp), uint16(x86_PSUBSW), + /*7652*/ uint16(x86_xReadSlashR), + /*7653*/ uint16(x86_xArgXmm1), + /*7654*/ uint16(x86_xArgXmm2M128), + /*7655*/ uint16(x86_xMatch), + /*7656*/ uint16(x86_xCondPrefix), 2, + 0x66, 7668, + 0x0, 7662, + /*7662*/ uint16(x86_xSetOp), uint16(x86_PMINSW), + /*7664*/ uint16(x86_xReadSlashR), + /*7665*/ uint16(x86_xArgMm1), + /*7666*/ uint16(x86_xArgMm2M64), + /*7667*/ uint16(x86_xMatch), + /*7668*/ uint16(x86_xSetOp), uint16(x86_PMINSW), + /*7670*/ uint16(x86_xReadSlashR), + /*7671*/ uint16(x86_xArgXmm1), + /*7672*/ uint16(x86_xArgXmm2M128), + /*7673*/ uint16(x86_xMatch), + /*7674*/ uint16(x86_xCondPrefix), 2, + 0x66, 7686, + 0x0, 7680, + /*7680*/ uint16(x86_xSetOp), uint16(x86_POR), + /*7682*/ uint16(x86_xReadSlashR), + /*7683*/ uint16(x86_xArgMm), + /*7684*/ uint16(x86_xArgMmM64), + /*7685*/ uint16(x86_xMatch), + /*7686*/ uint16(x86_xSetOp), uint16(x86_POR), + /*7688*/ uint16(x86_xReadSlashR), + /*7689*/ uint16(x86_xArgXmm1), + /*7690*/ uint16(x86_xArgXmm2M128), + /*7691*/ uint16(x86_xMatch), + /*7692*/ uint16(x86_xCondPrefix), 2, + 0x66, 7704, + 0x0, 7698, + /*7698*/ uint16(x86_xSetOp), uint16(x86_PADDSB), + /*7700*/ uint16(x86_xReadSlashR), + /*7701*/ uint16(x86_xArgMm), + /*7702*/ uint16(x86_xArgMmM64), + /*7703*/ uint16(x86_xMatch), + /*7704*/ uint16(x86_xSetOp), uint16(x86_PADDSB), + /*7706*/ uint16(x86_xReadSlashR), + /*7707*/ uint16(x86_xArgXmm1), + /*7708*/ uint16(x86_xArgXmm2M128), + /*7709*/ uint16(x86_xMatch), + /*7710*/ uint16(x86_xCondPrefix), 2, + 0x66, 7722, + 0x0, 7716, + /*7716*/ uint16(x86_xSetOp), uint16(x86_PADDSW), + /*7718*/ uint16(x86_xReadSlashR), + /*7719*/ uint16(x86_xArgMm), + /*7720*/ uint16(x86_xArgMmM64), + /*7721*/ uint16(x86_xMatch), + /*7722*/ uint16(x86_xSetOp), uint16(x86_PADDSW), + /*7724*/ uint16(x86_xReadSlashR), + /*7725*/ uint16(x86_xArgXmm1), + /*7726*/ uint16(x86_xArgXmm2M128), + /*7727*/ uint16(x86_xMatch), + /*7728*/ uint16(x86_xCondPrefix), 2, + 0x66, 7740, + 0x0, 7734, + /*7734*/ uint16(x86_xSetOp), uint16(x86_PMAXSW), + /*7736*/ uint16(x86_xReadSlashR), + /*7737*/ uint16(x86_xArgMm1), + /*7738*/ uint16(x86_xArgMm2M64), + /*7739*/ uint16(x86_xMatch), + /*7740*/ uint16(x86_xSetOp), uint16(x86_PMAXSW), + /*7742*/ uint16(x86_xReadSlashR), + /*7743*/ uint16(x86_xArgXmm1), + /*7744*/ uint16(x86_xArgXmm2M128), + /*7745*/ uint16(x86_xMatch), + /*7746*/ uint16(x86_xCondPrefix), 2, + 0x66, 7758, + 0x0, 7752, + /*7752*/ uint16(x86_xSetOp), uint16(x86_PXOR), + /*7754*/ uint16(x86_xReadSlashR), + /*7755*/ uint16(x86_xArgMm), + /*7756*/ uint16(x86_xArgMmM64), + /*7757*/ uint16(x86_xMatch), + /*7758*/ uint16(x86_xSetOp), uint16(x86_PXOR), + /*7760*/ uint16(x86_xReadSlashR), + /*7761*/ uint16(x86_xArgXmm1), + /*7762*/ uint16(x86_xArgXmm2M128), + /*7763*/ uint16(x86_xMatch), + /*7764*/ uint16(x86_xCondPrefix), 1, + 0xF2, 7768, + /*7768*/ uint16(x86_xSetOp), uint16(x86_LDDQU), + /*7770*/ uint16(x86_xReadSlashR), + /*7771*/ uint16(x86_xArgXmm1), + /*7772*/ uint16(x86_xArgM128), + /*7773*/ uint16(x86_xMatch), + /*7774*/ uint16(x86_xCondPrefix), 2, + 0x66, 7786, + 0x0, 7780, + /*7780*/ uint16(x86_xSetOp), uint16(x86_PSLLW), + /*7782*/ uint16(x86_xReadSlashR), + /*7783*/ uint16(x86_xArgMm), + /*7784*/ uint16(x86_xArgMmM64), + /*7785*/ uint16(x86_xMatch), + /*7786*/ uint16(x86_xSetOp), uint16(x86_PSLLW), + /*7788*/ uint16(x86_xReadSlashR), + /*7789*/ uint16(x86_xArgXmm1), + /*7790*/ uint16(x86_xArgXmm2M128), + /*7791*/ uint16(x86_xMatch), + /*7792*/ uint16(x86_xCondPrefix), 2, + 0x66, 7804, + 0x0, 7798, + /*7798*/ uint16(x86_xSetOp), uint16(x86_PSLLD), + /*7800*/ uint16(x86_xReadSlashR), + /*7801*/ uint16(x86_xArgMm), + /*7802*/ uint16(x86_xArgMmM64), + /*7803*/ uint16(x86_xMatch), + /*7804*/ uint16(x86_xSetOp), uint16(x86_PSLLD), + /*7806*/ uint16(x86_xReadSlashR), + /*7807*/ uint16(x86_xArgXmm1), + /*7808*/ uint16(x86_xArgXmm2M128), + /*7809*/ uint16(x86_xMatch), + /*7810*/ uint16(x86_xCondPrefix), 2, + 0x66, 7822, + 0x0, 7816, + /*7816*/ uint16(x86_xSetOp), uint16(x86_PSLLQ), + /*7818*/ uint16(x86_xReadSlashR), + /*7819*/ uint16(x86_xArgMm), + /*7820*/ uint16(x86_xArgMmM64), + /*7821*/ uint16(x86_xMatch), + /*7822*/ uint16(x86_xSetOp), uint16(x86_PSLLQ), + /*7824*/ uint16(x86_xReadSlashR), + /*7825*/ uint16(x86_xArgXmm1), + /*7826*/ uint16(x86_xArgXmm2M128), + /*7827*/ uint16(x86_xMatch), + /*7828*/ uint16(x86_xCondPrefix), 2, + 0x66, 7840, + 0x0, 7834, + /*7834*/ uint16(x86_xSetOp), uint16(x86_PMULUDQ), + /*7836*/ uint16(x86_xReadSlashR), + /*7837*/ uint16(x86_xArgMm1), + /*7838*/ uint16(x86_xArgMm2M64), + /*7839*/ uint16(x86_xMatch), + /*7840*/ uint16(x86_xSetOp), uint16(x86_PMULUDQ), + /*7842*/ uint16(x86_xReadSlashR), + /*7843*/ uint16(x86_xArgXmm1), + /*7844*/ uint16(x86_xArgXmm2M128), + /*7845*/ uint16(x86_xMatch), + /*7846*/ uint16(x86_xCondPrefix), 2, + 0x66, 7858, + 0x0, 7852, + /*7852*/ uint16(x86_xSetOp), uint16(x86_PMADDWD), + /*7854*/ uint16(x86_xReadSlashR), + /*7855*/ uint16(x86_xArgMm), + /*7856*/ uint16(x86_xArgMmM64), + /*7857*/ uint16(x86_xMatch), + /*7858*/ uint16(x86_xSetOp), uint16(x86_PMADDWD), + /*7860*/ uint16(x86_xReadSlashR), + /*7861*/ uint16(x86_xArgXmm1), + /*7862*/ uint16(x86_xArgXmm2M128), + /*7863*/ uint16(x86_xMatch), + /*7864*/ uint16(x86_xCondPrefix), 2, + 0x66, 7876, + 0x0, 7870, + /*7870*/ uint16(x86_xSetOp), uint16(x86_PSADBW), + /*7872*/ uint16(x86_xReadSlashR), + /*7873*/ uint16(x86_xArgMm1), + /*7874*/ uint16(x86_xArgMm2M64), + /*7875*/ uint16(x86_xMatch), + /*7876*/ uint16(x86_xSetOp), uint16(x86_PSADBW), + /*7878*/ uint16(x86_xReadSlashR), + /*7879*/ uint16(x86_xArgXmm1), + /*7880*/ uint16(x86_xArgXmm2M128), + /*7881*/ uint16(x86_xMatch), + /*7882*/ uint16(x86_xCondPrefix), 2, + 0x66, 7894, + 0x0, 7888, + /*7888*/ uint16(x86_xSetOp), uint16(x86_MASKMOVQ), + /*7890*/ uint16(x86_xReadSlashR), + /*7891*/ uint16(x86_xArgMm1), + /*7892*/ uint16(x86_xArgMm2), + /*7893*/ uint16(x86_xMatch), + /*7894*/ uint16(x86_xSetOp), uint16(x86_MASKMOVDQU), + /*7896*/ uint16(x86_xReadSlashR), + /*7897*/ uint16(x86_xArgXmm1), + /*7898*/ uint16(x86_xArgXmm2), + /*7899*/ uint16(x86_xMatch), + /*7900*/ uint16(x86_xCondPrefix), 2, + 0x66, 7912, + 0x0, 7906, + /*7906*/ uint16(x86_xSetOp), uint16(x86_PSUBB), + /*7908*/ uint16(x86_xReadSlashR), + /*7909*/ uint16(x86_xArgMm), + /*7910*/ uint16(x86_xArgMmM64), + /*7911*/ uint16(x86_xMatch), + /*7912*/ uint16(x86_xSetOp), uint16(x86_PSUBB), + /*7914*/ uint16(x86_xReadSlashR), + /*7915*/ uint16(x86_xArgXmm1), + /*7916*/ uint16(x86_xArgXmm2M128), + /*7917*/ uint16(x86_xMatch), + /*7918*/ uint16(x86_xCondPrefix), 2, + 0x66, 7930, + 0x0, 7924, + /*7924*/ uint16(x86_xSetOp), uint16(x86_PSUBW), + /*7926*/ uint16(x86_xReadSlashR), + /*7927*/ uint16(x86_xArgMm), + /*7928*/ uint16(x86_xArgMmM64), + /*7929*/ uint16(x86_xMatch), + /*7930*/ uint16(x86_xSetOp), uint16(x86_PSUBW), + /*7932*/ uint16(x86_xReadSlashR), + /*7933*/ uint16(x86_xArgXmm1), + /*7934*/ uint16(x86_xArgXmm2M128), + /*7935*/ uint16(x86_xMatch), + /*7936*/ uint16(x86_xCondPrefix), 2, + 0x66, 7948, + 0x0, 7942, + /*7942*/ uint16(x86_xSetOp), uint16(x86_PSUBD), + /*7944*/ uint16(x86_xReadSlashR), + /*7945*/ uint16(x86_xArgMm), + /*7946*/ uint16(x86_xArgMmM64), + /*7947*/ uint16(x86_xMatch), + /*7948*/ uint16(x86_xSetOp), uint16(x86_PSUBD), + /*7950*/ uint16(x86_xReadSlashR), + /*7951*/ uint16(x86_xArgXmm1), + /*7952*/ uint16(x86_xArgXmm2M128), + /*7953*/ uint16(x86_xMatch), + /*7954*/ uint16(x86_xCondPrefix), 2, + 0x66, 7966, + 0x0, 7960, + /*7960*/ uint16(x86_xSetOp), uint16(x86_PSUBQ), + /*7962*/ uint16(x86_xReadSlashR), + /*7963*/ uint16(x86_xArgMm1), + /*7964*/ uint16(x86_xArgMm2M64), + /*7965*/ uint16(x86_xMatch), + /*7966*/ uint16(x86_xSetOp), uint16(x86_PSUBQ), + /*7968*/ uint16(x86_xReadSlashR), + /*7969*/ uint16(x86_xArgXmm1), + /*7970*/ uint16(x86_xArgXmm2M128), + /*7971*/ uint16(x86_xMatch), + /*7972*/ uint16(x86_xCondPrefix), 2, + 0x66, 7984, + 0x0, 7978, + /*7978*/ uint16(x86_xSetOp), uint16(x86_PADDB), + /*7980*/ uint16(x86_xReadSlashR), + /*7981*/ uint16(x86_xArgMm), + /*7982*/ uint16(x86_xArgMmM64), + /*7983*/ uint16(x86_xMatch), + /*7984*/ uint16(x86_xSetOp), uint16(x86_PADDB), + /*7986*/ uint16(x86_xReadSlashR), + /*7987*/ uint16(x86_xArgXmm1), + /*7988*/ uint16(x86_xArgXmm2M128), + /*7989*/ uint16(x86_xMatch), + /*7990*/ uint16(x86_xCondPrefix), 2, + 0x66, 8002, + 0x0, 7996, + /*7996*/ uint16(x86_xSetOp), uint16(x86_PADDW), + /*7998*/ uint16(x86_xReadSlashR), + /*7999*/ uint16(x86_xArgMm), + /*8000*/ uint16(x86_xArgMmM64), + /*8001*/ uint16(x86_xMatch), + /*8002*/ uint16(x86_xSetOp), uint16(x86_PADDW), + /*8004*/ uint16(x86_xReadSlashR), + /*8005*/ uint16(x86_xArgXmm1), + /*8006*/ uint16(x86_xArgXmm2M128), + /*8007*/ uint16(x86_xMatch), + /*8008*/ uint16(x86_xCondPrefix), 2, + 0x66, 8020, + 0x0, 8014, + /*8014*/ uint16(x86_xSetOp), uint16(x86_PADDD), + /*8016*/ uint16(x86_xReadSlashR), + /*8017*/ uint16(x86_xArgMm), + /*8018*/ uint16(x86_xArgMmM64), + /*8019*/ uint16(x86_xMatch), + /*8020*/ uint16(x86_xSetOp), uint16(x86_PADDD), + /*8022*/ uint16(x86_xReadSlashR), + /*8023*/ uint16(x86_xArgXmm1), + /*8024*/ uint16(x86_xArgXmm2M128), + /*8025*/ uint16(x86_xMatch), + /*8026*/ uint16(x86_xSetOp), uint16(x86_ADC), + /*8028*/ uint16(x86_xReadSlashR), + /*8029*/ uint16(x86_xArgRM8), + /*8030*/ uint16(x86_xArgR8), + /*8031*/ uint16(x86_xMatch), + /*8032*/ uint16(x86_xCondIs64), 8035, 8051, + /*8035*/ uint16(x86_xCondDataSize), 8039, 8045, 0, + /*8039*/ uint16(x86_xSetOp), uint16(x86_ADC), + /*8041*/ uint16(x86_xReadSlashR), + /*8042*/ uint16(x86_xArgRM16), + /*8043*/ uint16(x86_xArgR16), + /*8044*/ uint16(x86_xMatch), + /*8045*/ uint16(x86_xSetOp), uint16(x86_ADC), + /*8047*/ uint16(x86_xReadSlashR), + /*8048*/ uint16(x86_xArgRM32), + /*8049*/ uint16(x86_xArgR32), + /*8050*/ uint16(x86_xMatch), + /*8051*/ uint16(x86_xCondDataSize), 8039, 8045, 8055, + /*8055*/ uint16(x86_xSetOp), uint16(x86_ADC), + /*8057*/ uint16(x86_xReadSlashR), + /*8058*/ uint16(x86_xArgRM64), + /*8059*/ uint16(x86_xArgR64), + /*8060*/ uint16(x86_xMatch), + /*8061*/ uint16(x86_xSetOp), uint16(x86_ADC), + /*8063*/ uint16(x86_xReadSlashR), + /*8064*/ uint16(x86_xArgR8), + /*8065*/ uint16(x86_xArgRM8), + /*8066*/ uint16(x86_xMatch), + /*8067*/ uint16(x86_xCondIs64), 8070, 8086, + /*8070*/ uint16(x86_xCondDataSize), 8074, 8080, 0, + /*8074*/ uint16(x86_xSetOp), uint16(x86_ADC), + /*8076*/ uint16(x86_xReadSlashR), + /*8077*/ uint16(x86_xArgR16), + /*8078*/ uint16(x86_xArgRM16), + /*8079*/ uint16(x86_xMatch), + /*8080*/ uint16(x86_xSetOp), uint16(x86_ADC), + /*8082*/ uint16(x86_xReadSlashR), + /*8083*/ uint16(x86_xArgR32), + /*8084*/ uint16(x86_xArgRM32), + /*8085*/ uint16(x86_xMatch), + /*8086*/ uint16(x86_xCondDataSize), 8074, 8080, 8090, + /*8090*/ uint16(x86_xSetOp), uint16(x86_ADC), + /*8092*/ uint16(x86_xReadSlashR), + /*8093*/ uint16(x86_xArgR64), + /*8094*/ uint16(x86_xArgRM64), + /*8095*/ uint16(x86_xMatch), + /*8096*/ uint16(x86_xSetOp), uint16(x86_ADC), + /*8098*/ uint16(x86_xReadIb), + /*8099*/ uint16(x86_xArgAL), + /*8100*/ uint16(x86_xArgImm8u), + /*8101*/ uint16(x86_xMatch), + /*8102*/ uint16(x86_xCondIs64), 8105, 8121, + /*8105*/ uint16(x86_xCondDataSize), 8109, 8115, 0, + /*8109*/ uint16(x86_xSetOp), uint16(x86_ADC), + /*8111*/ uint16(x86_xReadIw), + /*8112*/ uint16(x86_xArgAX), + /*8113*/ uint16(x86_xArgImm16), + /*8114*/ uint16(x86_xMatch), + /*8115*/ uint16(x86_xSetOp), uint16(x86_ADC), + /*8117*/ uint16(x86_xReadId), + /*8118*/ uint16(x86_xArgEAX), + /*8119*/ uint16(x86_xArgImm32), + /*8120*/ uint16(x86_xMatch), + /*8121*/ uint16(x86_xCondDataSize), 8109, 8115, 8125, + /*8125*/ uint16(x86_xSetOp), uint16(x86_ADC), + /*8127*/ uint16(x86_xReadId), + /*8128*/ uint16(x86_xArgRAX), + /*8129*/ uint16(x86_xArgImm32), + /*8130*/ uint16(x86_xMatch), + /*8131*/ uint16(x86_xCondIs64), 8134, 0, + /*8134*/ uint16(x86_xSetOp), uint16(x86_PUSH), + /*8136*/ uint16(x86_xArgSS), + /*8137*/ uint16(x86_xMatch), + /*8138*/ uint16(x86_xCondIs64), 8141, 0, + /*8141*/ uint16(x86_xSetOp), uint16(x86_POP), + /*8143*/ uint16(x86_xArgSS), + /*8144*/ uint16(x86_xMatch), + /*8145*/ uint16(x86_xSetOp), uint16(x86_SBB), + /*8147*/ uint16(x86_xReadSlashR), + /*8148*/ uint16(x86_xArgRM8), + /*8149*/ uint16(x86_xArgR8), + /*8150*/ uint16(x86_xMatch), + /*8151*/ uint16(x86_xCondIs64), 8154, 8170, + /*8154*/ uint16(x86_xCondDataSize), 8158, 8164, 0, + /*8158*/ uint16(x86_xSetOp), uint16(x86_SBB), + /*8160*/ uint16(x86_xReadSlashR), + /*8161*/ uint16(x86_xArgRM16), + /*8162*/ uint16(x86_xArgR16), + /*8163*/ uint16(x86_xMatch), + /*8164*/ uint16(x86_xSetOp), uint16(x86_SBB), + /*8166*/ uint16(x86_xReadSlashR), + /*8167*/ uint16(x86_xArgRM32), + /*8168*/ uint16(x86_xArgR32), + /*8169*/ uint16(x86_xMatch), + /*8170*/ uint16(x86_xCondDataSize), 8158, 8164, 8174, + /*8174*/ uint16(x86_xSetOp), uint16(x86_SBB), + /*8176*/ uint16(x86_xReadSlashR), + /*8177*/ uint16(x86_xArgRM64), + /*8178*/ uint16(x86_xArgR64), + /*8179*/ uint16(x86_xMatch), + /*8180*/ uint16(x86_xSetOp), uint16(x86_SBB), + /*8182*/ uint16(x86_xReadSlashR), + /*8183*/ uint16(x86_xArgR8), + /*8184*/ uint16(x86_xArgRM8), + /*8185*/ uint16(x86_xMatch), + /*8186*/ uint16(x86_xCondIs64), 8189, 8205, + /*8189*/ uint16(x86_xCondDataSize), 8193, 8199, 0, + /*8193*/ uint16(x86_xSetOp), uint16(x86_SBB), + /*8195*/ uint16(x86_xReadSlashR), + /*8196*/ uint16(x86_xArgR16), + /*8197*/ uint16(x86_xArgRM16), + /*8198*/ uint16(x86_xMatch), + /*8199*/ uint16(x86_xSetOp), uint16(x86_SBB), + /*8201*/ uint16(x86_xReadSlashR), + /*8202*/ uint16(x86_xArgR32), + /*8203*/ uint16(x86_xArgRM32), + /*8204*/ uint16(x86_xMatch), + /*8205*/ uint16(x86_xCondDataSize), 8193, 8199, 8209, + /*8209*/ uint16(x86_xSetOp), uint16(x86_SBB), + /*8211*/ uint16(x86_xReadSlashR), + /*8212*/ uint16(x86_xArgR64), + /*8213*/ uint16(x86_xArgRM64), + /*8214*/ uint16(x86_xMatch), + /*8215*/ uint16(x86_xSetOp), uint16(x86_SBB), + /*8217*/ uint16(x86_xReadIb), + /*8218*/ uint16(x86_xArgAL), + /*8219*/ uint16(x86_xArgImm8u), + /*8220*/ uint16(x86_xMatch), + /*8221*/ uint16(x86_xCondIs64), 8224, 8240, + /*8224*/ uint16(x86_xCondDataSize), 8228, 8234, 0, + /*8228*/ uint16(x86_xSetOp), uint16(x86_SBB), + /*8230*/ uint16(x86_xReadIw), + /*8231*/ uint16(x86_xArgAX), + /*8232*/ uint16(x86_xArgImm16), + /*8233*/ uint16(x86_xMatch), + /*8234*/ uint16(x86_xSetOp), uint16(x86_SBB), + /*8236*/ uint16(x86_xReadId), + /*8237*/ uint16(x86_xArgEAX), + /*8238*/ uint16(x86_xArgImm32), + /*8239*/ uint16(x86_xMatch), + /*8240*/ uint16(x86_xCondDataSize), 8228, 8234, 8244, + /*8244*/ uint16(x86_xSetOp), uint16(x86_SBB), + /*8246*/ uint16(x86_xReadId), + /*8247*/ uint16(x86_xArgRAX), + /*8248*/ uint16(x86_xArgImm32), + /*8249*/ uint16(x86_xMatch), + /*8250*/ uint16(x86_xCondIs64), 8253, 0, + /*8253*/ uint16(x86_xSetOp), uint16(x86_PUSH), + /*8255*/ uint16(x86_xArgDS), + /*8256*/ uint16(x86_xMatch), + /*8257*/ uint16(x86_xCondIs64), 8260, 0, + /*8260*/ uint16(x86_xSetOp), uint16(x86_POP), + /*8262*/ uint16(x86_xArgDS), + /*8263*/ uint16(x86_xMatch), + /*8264*/ uint16(x86_xSetOp), uint16(x86_AND), + /*8266*/ uint16(x86_xReadSlashR), + /*8267*/ uint16(x86_xArgRM8), + /*8268*/ uint16(x86_xArgR8), + /*8269*/ uint16(x86_xMatch), + /*8270*/ uint16(x86_xCondIs64), 8273, 8289, + /*8273*/ uint16(x86_xCondDataSize), 8277, 8283, 0, + /*8277*/ uint16(x86_xSetOp), uint16(x86_AND), + /*8279*/ uint16(x86_xReadSlashR), + /*8280*/ uint16(x86_xArgRM16), + /*8281*/ uint16(x86_xArgR16), + /*8282*/ uint16(x86_xMatch), + /*8283*/ uint16(x86_xSetOp), uint16(x86_AND), + /*8285*/ uint16(x86_xReadSlashR), + /*8286*/ uint16(x86_xArgRM32), + /*8287*/ uint16(x86_xArgR32), + /*8288*/ uint16(x86_xMatch), + /*8289*/ uint16(x86_xCondDataSize), 8277, 8283, 8293, + /*8293*/ uint16(x86_xSetOp), uint16(x86_AND), + /*8295*/ uint16(x86_xReadSlashR), + /*8296*/ uint16(x86_xArgRM64), + /*8297*/ uint16(x86_xArgR64), + /*8298*/ uint16(x86_xMatch), + /*8299*/ uint16(x86_xSetOp), uint16(x86_AND), + /*8301*/ uint16(x86_xReadSlashR), + /*8302*/ uint16(x86_xArgR8), + /*8303*/ uint16(x86_xArgRM8), + /*8304*/ uint16(x86_xMatch), + /*8305*/ uint16(x86_xCondIs64), 8308, 8324, + /*8308*/ uint16(x86_xCondDataSize), 8312, 8318, 0, + /*8312*/ uint16(x86_xSetOp), uint16(x86_AND), + /*8314*/ uint16(x86_xReadSlashR), + /*8315*/ uint16(x86_xArgR16), + /*8316*/ uint16(x86_xArgRM16), + /*8317*/ uint16(x86_xMatch), + /*8318*/ uint16(x86_xSetOp), uint16(x86_AND), + /*8320*/ uint16(x86_xReadSlashR), + /*8321*/ uint16(x86_xArgR32), + /*8322*/ uint16(x86_xArgRM32), + /*8323*/ uint16(x86_xMatch), + /*8324*/ uint16(x86_xCondDataSize), 8312, 8318, 8328, + /*8328*/ uint16(x86_xSetOp), uint16(x86_AND), + /*8330*/ uint16(x86_xReadSlashR), + /*8331*/ uint16(x86_xArgR64), + /*8332*/ uint16(x86_xArgRM64), + /*8333*/ uint16(x86_xMatch), + /*8334*/ uint16(x86_xSetOp), uint16(x86_AND), + /*8336*/ uint16(x86_xReadIb), + /*8337*/ uint16(x86_xArgAL), + /*8338*/ uint16(x86_xArgImm8u), + /*8339*/ uint16(x86_xMatch), + /*8340*/ uint16(x86_xCondIs64), 8343, 8359, + /*8343*/ uint16(x86_xCondDataSize), 8347, 8353, 0, + /*8347*/ uint16(x86_xSetOp), uint16(x86_AND), + /*8349*/ uint16(x86_xReadIw), + /*8350*/ uint16(x86_xArgAX), + /*8351*/ uint16(x86_xArgImm16), + /*8352*/ uint16(x86_xMatch), + /*8353*/ uint16(x86_xSetOp), uint16(x86_AND), + /*8355*/ uint16(x86_xReadId), + /*8356*/ uint16(x86_xArgEAX), + /*8357*/ uint16(x86_xArgImm32), + /*8358*/ uint16(x86_xMatch), + /*8359*/ uint16(x86_xCondDataSize), 8347, 8353, 8363, + /*8363*/ uint16(x86_xSetOp), uint16(x86_AND), + /*8365*/ uint16(x86_xReadId), + /*8366*/ uint16(x86_xArgRAX), + /*8367*/ uint16(x86_xArgImm32), + /*8368*/ uint16(x86_xMatch), + /*8369*/ uint16(x86_xCondIs64), 8372, 0, + /*8372*/ uint16(x86_xSetOp), uint16(x86_DAA), + /*8374*/ uint16(x86_xMatch), + /*8375*/ uint16(x86_xSetOp), uint16(x86_SUB), + /*8377*/ uint16(x86_xReadSlashR), + /*8378*/ uint16(x86_xArgRM8), + /*8379*/ uint16(x86_xArgR8), + /*8380*/ uint16(x86_xMatch), + /*8381*/ uint16(x86_xCondIs64), 8384, 8400, + /*8384*/ uint16(x86_xCondDataSize), 8388, 8394, 0, + /*8388*/ uint16(x86_xSetOp), uint16(x86_SUB), + /*8390*/ uint16(x86_xReadSlashR), + /*8391*/ uint16(x86_xArgRM16), + /*8392*/ uint16(x86_xArgR16), + /*8393*/ uint16(x86_xMatch), + /*8394*/ uint16(x86_xSetOp), uint16(x86_SUB), + /*8396*/ uint16(x86_xReadSlashR), + /*8397*/ uint16(x86_xArgRM32), + /*8398*/ uint16(x86_xArgR32), + /*8399*/ uint16(x86_xMatch), + /*8400*/ uint16(x86_xCondDataSize), 8388, 8394, 8404, + /*8404*/ uint16(x86_xSetOp), uint16(x86_SUB), + /*8406*/ uint16(x86_xReadSlashR), + /*8407*/ uint16(x86_xArgRM64), + /*8408*/ uint16(x86_xArgR64), + /*8409*/ uint16(x86_xMatch), + /*8410*/ uint16(x86_xSetOp), uint16(x86_SUB), + /*8412*/ uint16(x86_xReadSlashR), + /*8413*/ uint16(x86_xArgR8), + /*8414*/ uint16(x86_xArgRM8), + /*8415*/ uint16(x86_xMatch), + /*8416*/ uint16(x86_xCondIs64), 8419, 8435, + /*8419*/ uint16(x86_xCondDataSize), 8423, 8429, 0, + /*8423*/ uint16(x86_xSetOp), uint16(x86_SUB), + /*8425*/ uint16(x86_xReadSlashR), + /*8426*/ uint16(x86_xArgR16), + /*8427*/ uint16(x86_xArgRM16), + /*8428*/ uint16(x86_xMatch), + /*8429*/ uint16(x86_xSetOp), uint16(x86_SUB), + /*8431*/ uint16(x86_xReadSlashR), + /*8432*/ uint16(x86_xArgR32), + /*8433*/ uint16(x86_xArgRM32), + /*8434*/ uint16(x86_xMatch), + /*8435*/ uint16(x86_xCondDataSize), 8423, 8429, 8439, + /*8439*/ uint16(x86_xSetOp), uint16(x86_SUB), + /*8441*/ uint16(x86_xReadSlashR), + /*8442*/ uint16(x86_xArgR64), + /*8443*/ uint16(x86_xArgRM64), + /*8444*/ uint16(x86_xMatch), + /*8445*/ uint16(x86_xSetOp), uint16(x86_SUB), + /*8447*/ uint16(x86_xReadIb), + /*8448*/ uint16(x86_xArgAL), + /*8449*/ uint16(x86_xArgImm8u), + /*8450*/ uint16(x86_xMatch), + /*8451*/ uint16(x86_xCondIs64), 8454, 8470, + /*8454*/ uint16(x86_xCondDataSize), 8458, 8464, 0, + /*8458*/ uint16(x86_xSetOp), uint16(x86_SUB), + /*8460*/ uint16(x86_xReadIw), + /*8461*/ uint16(x86_xArgAX), + /*8462*/ uint16(x86_xArgImm16), + /*8463*/ uint16(x86_xMatch), + /*8464*/ uint16(x86_xSetOp), uint16(x86_SUB), + /*8466*/ uint16(x86_xReadId), + /*8467*/ uint16(x86_xArgEAX), + /*8468*/ uint16(x86_xArgImm32), + /*8469*/ uint16(x86_xMatch), + /*8470*/ uint16(x86_xCondDataSize), 8458, 8464, 8474, + /*8474*/ uint16(x86_xSetOp), uint16(x86_SUB), + /*8476*/ uint16(x86_xReadId), + /*8477*/ uint16(x86_xArgRAX), + /*8478*/ uint16(x86_xArgImm32), + /*8479*/ uint16(x86_xMatch), + /*8480*/ uint16(x86_xCondIs64), 8483, 0, + /*8483*/ uint16(x86_xSetOp), uint16(x86_DAS), + /*8485*/ uint16(x86_xMatch), + /*8486*/ uint16(x86_xSetOp), uint16(x86_XOR), + /*8488*/ uint16(x86_xReadSlashR), + /*8489*/ uint16(x86_xArgRM8), + /*8490*/ uint16(x86_xArgR8), + /*8491*/ uint16(x86_xMatch), + /*8492*/ uint16(x86_xCondIs64), 8495, 8511, + /*8495*/ uint16(x86_xCondDataSize), 8499, 8505, 0, + /*8499*/ uint16(x86_xSetOp), uint16(x86_XOR), + /*8501*/ uint16(x86_xReadSlashR), + /*8502*/ uint16(x86_xArgRM16), + /*8503*/ uint16(x86_xArgR16), + /*8504*/ uint16(x86_xMatch), + /*8505*/ uint16(x86_xSetOp), uint16(x86_XOR), + /*8507*/ uint16(x86_xReadSlashR), + /*8508*/ uint16(x86_xArgRM32), + /*8509*/ uint16(x86_xArgR32), + /*8510*/ uint16(x86_xMatch), + /*8511*/ uint16(x86_xCondDataSize), 8499, 8505, 8515, + /*8515*/ uint16(x86_xSetOp), uint16(x86_XOR), + /*8517*/ uint16(x86_xReadSlashR), + /*8518*/ uint16(x86_xArgRM64), + /*8519*/ uint16(x86_xArgR64), + /*8520*/ uint16(x86_xMatch), + /*8521*/ uint16(x86_xSetOp), uint16(x86_XOR), + /*8523*/ uint16(x86_xReadSlashR), + /*8524*/ uint16(x86_xArgR8), + /*8525*/ uint16(x86_xArgRM8), + /*8526*/ uint16(x86_xMatch), + /*8527*/ uint16(x86_xCondIs64), 8530, 8546, + /*8530*/ uint16(x86_xCondDataSize), 8534, 8540, 0, + /*8534*/ uint16(x86_xSetOp), uint16(x86_XOR), + /*8536*/ uint16(x86_xReadSlashR), + /*8537*/ uint16(x86_xArgR16), + /*8538*/ uint16(x86_xArgRM16), + /*8539*/ uint16(x86_xMatch), + /*8540*/ uint16(x86_xSetOp), uint16(x86_XOR), + /*8542*/ uint16(x86_xReadSlashR), + /*8543*/ uint16(x86_xArgR32), + /*8544*/ uint16(x86_xArgRM32), + /*8545*/ uint16(x86_xMatch), + /*8546*/ uint16(x86_xCondDataSize), 8534, 8540, 8550, + /*8550*/ uint16(x86_xSetOp), uint16(x86_XOR), + /*8552*/ uint16(x86_xReadSlashR), + /*8553*/ uint16(x86_xArgR64), + /*8554*/ uint16(x86_xArgRM64), + /*8555*/ uint16(x86_xMatch), + /*8556*/ uint16(x86_xSetOp), uint16(x86_XOR), + /*8558*/ uint16(x86_xReadIb), + /*8559*/ uint16(x86_xArgAL), + /*8560*/ uint16(x86_xArgImm8u), + /*8561*/ uint16(x86_xMatch), + /*8562*/ uint16(x86_xCondIs64), 8565, 8581, + /*8565*/ uint16(x86_xCondDataSize), 8569, 8575, 0, + /*8569*/ uint16(x86_xSetOp), uint16(x86_XOR), + /*8571*/ uint16(x86_xReadIw), + /*8572*/ uint16(x86_xArgAX), + /*8573*/ uint16(x86_xArgImm16), + /*8574*/ uint16(x86_xMatch), + /*8575*/ uint16(x86_xSetOp), uint16(x86_XOR), + /*8577*/ uint16(x86_xReadId), + /*8578*/ uint16(x86_xArgEAX), + /*8579*/ uint16(x86_xArgImm32), + /*8580*/ uint16(x86_xMatch), + /*8581*/ uint16(x86_xCondDataSize), 8569, 8575, 8585, + /*8585*/ uint16(x86_xSetOp), uint16(x86_XOR), + /*8587*/ uint16(x86_xReadId), + /*8588*/ uint16(x86_xArgRAX), + /*8589*/ uint16(x86_xArgImm32), + /*8590*/ uint16(x86_xMatch), + /*8591*/ uint16(x86_xCondIs64), 8594, 0, + /*8594*/ uint16(x86_xSetOp), uint16(x86_AAA), + /*8596*/ uint16(x86_xMatch), + /*8597*/ uint16(x86_xSetOp), uint16(x86_CMP), + /*8599*/ uint16(x86_xReadSlashR), + /*8600*/ uint16(x86_xArgRM8), + /*8601*/ uint16(x86_xArgR8), + /*8602*/ uint16(x86_xMatch), + /*8603*/ uint16(x86_xCondIs64), 8606, 8622, + /*8606*/ uint16(x86_xCondDataSize), 8610, 8616, 0, + /*8610*/ uint16(x86_xSetOp), uint16(x86_CMP), + /*8612*/ uint16(x86_xReadSlashR), + /*8613*/ uint16(x86_xArgRM16), + /*8614*/ uint16(x86_xArgR16), + /*8615*/ uint16(x86_xMatch), + /*8616*/ uint16(x86_xSetOp), uint16(x86_CMP), + /*8618*/ uint16(x86_xReadSlashR), + /*8619*/ uint16(x86_xArgRM32), + /*8620*/ uint16(x86_xArgR32), + /*8621*/ uint16(x86_xMatch), + /*8622*/ uint16(x86_xCondDataSize), 8610, 8616, 8626, + /*8626*/ uint16(x86_xSetOp), uint16(x86_CMP), + /*8628*/ uint16(x86_xReadSlashR), + /*8629*/ uint16(x86_xArgRM64), + /*8630*/ uint16(x86_xArgR64), + /*8631*/ uint16(x86_xMatch), + /*8632*/ uint16(x86_xSetOp), uint16(x86_CMP), + /*8634*/ uint16(x86_xReadSlashR), + /*8635*/ uint16(x86_xArgR8), + /*8636*/ uint16(x86_xArgRM8), + /*8637*/ uint16(x86_xMatch), + /*8638*/ uint16(x86_xCondIs64), 8641, 8657, + /*8641*/ uint16(x86_xCondDataSize), 8645, 8651, 0, + /*8645*/ uint16(x86_xSetOp), uint16(x86_CMP), + /*8647*/ uint16(x86_xReadSlashR), + /*8648*/ uint16(x86_xArgR16), + /*8649*/ uint16(x86_xArgRM16), + /*8650*/ uint16(x86_xMatch), + /*8651*/ uint16(x86_xSetOp), uint16(x86_CMP), + /*8653*/ uint16(x86_xReadSlashR), + /*8654*/ uint16(x86_xArgR32), + /*8655*/ uint16(x86_xArgRM32), + /*8656*/ uint16(x86_xMatch), + /*8657*/ uint16(x86_xCondDataSize), 8645, 8651, 8661, + /*8661*/ uint16(x86_xSetOp), uint16(x86_CMP), + /*8663*/ uint16(x86_xReadSlashR), + /*8664*/ uint16(x86_xArgR64), + /*8665*/ uint16(x86_xArgRM64), + /*8666*/ uint16(x86_xMatch), + /*8667*/ uint16(x86_xSetOp), uint16(x86_CMP), + /*8669*/ uint16(x86_xReadIb), + /*8670*/ uint16(x86_xArgAL), + /*8671*/ uint16(x86_xArgImm8u), + /*8672*/ uint16(x86_xMatch), + /*8673*/ uint16(x86_xCondIs64), 8676, 8692, + /*8676*/ uint16(x86_xCondDataSize), 8680, 8686, 0, + /*8680*/ uint16(x86_xSetOp), uint16(x86_CMP), + /*8682*/ uint16(x86_xReadIw), + /*8683*/ uint16(x86_xArgAX), + /*8684*/ uint16(x86_xArgImm16), + /*8685*/ uint16(x86_xMatch), + /*8686*/ uint16(x86_xSetOp), uint16(x86_CMP), + /*8688*/ uint16(x86_xReadId), + /*8689*/ uint16(x86_xArgEAX), + /*8690*/ uint16(x86_xArgImm32), + /*8691*/ uint16(x86_xMatch), + /*8692*/ uint16(x86_xCondDataSize), 8680, 8686, 8696, + /*8696*/ uint16(x86_xSetOp), uint16(x86_CMP), + /*8698*/ uint16(x86_xReadId), + /*8699*/ uint16(x86_xArgRAX), + /*8700*/ uint16(x86_xArgImm32), + /*8701*/ uint16(x86_xMatch), + /*8702*/ uint16(x86_xCondIs64), 8705, 0, + /*8705*/ uint16(x86_xSetOp), uint16(x86_AAS), + /*8707*/ uint16(x86_xMatch), + /*8708*/ uint16(x86_xCondIs64), 8711, 0, + /*8711*/ uint16(x86_xCondDataSize), 8715, 8719, 0, + /*8715*/ uint16(x86_xSetOp), uint16(x86_INC), + /*8717*/ uint16(x86_xArgR16op), + /*8718*/ uint16(x86_xMatch), + /*8719*/ uint16(x86_xSetOp), uint16(x86_INC), + /*8721*/ uint16(x86_xArgR32op), + /*8722*/ uint16(x86_xMatch), + /*8723*/ uint16(x86_xCondIs64), 8726, 0, + /*8726*/ uint16(x86_xCondDataSize), 8730, 8734, 0, + /*8730*/ uint16(x86_xSetOp), uint16(x86_DEC), + /*8732*/ uint16(x86_xArgR16op), + /*8733*/ uint16(x86_xMatch), + /*8734*/ uint16(x86_xSetOp), uint16(x86_DEC), + /*8736*/ uint16(x86_xArgR32op), + /*8737*/ uint16(x86_xMatch), + /*8738*/ uint16(x86_xCondIs64), 8741, 8753, + /*8741*/ uint16(x86_xCondDataSize), 8745, 8749, 0, + /*8745*/ uint16(x86_xSetOp), uint16(x86_PUSH), + /*8747*/ uint16(x86_xArgR16op), + /*8748*/ uint16(x86_xMatch), + /*8749*/ uint16(x86_xSetOp), uint16(x86_PUSH), + /*8751*/ uint16(x86_xArgR32op), + /*8752*/ uint16(x86_xMatch), + /*8753*/ uint16(x86_xCondDataSize), 8745, 8757, 8761, + /*8757*/ uint16(x86_xSetOp), uint16(x86_PUSH), + /*8759*/ uint16(x86_xArgR64op), + /*8760*/ uint16(x86_xMatch), + /*8761*/ uint16(x86_xSetOp), uint16(x86_PUSH), + /*8763*/ uint16(x86_xArgR64op), + /*8764*/ uint16(x86_xMatch), + /*8765*/ uint16(x86_xCondIs64), 8768, 8780, + /*8768*/ uint16(x86_xCondDataSize), 8772, 8776, 0, + /*8772*/ uint16(x86_xSetOp), uint16(x86_POP), + /*8774*/ uint16(x86_xArgR16op), + /*8775*/ uint16(x86_xMatch), + /*8776*/ uint16(x86_xSetOp), uint16(x86_POP), + /*8778*/ uint16(x86_xArgR32op), + /*8779*/ uint16(x86_xMatch), + /*8780*/ uint16(x86_xCondDataSize), 8772, 8784, 8788, + /*8784*/ uint16(x86_xSetOp), uint16(x86_POP), + /*8786*/ uint16(x86_xArgR64op), + /*8787*/ uint16(x86_xMatch), + /*8788*/ uint16(x86_xSetOp), uint16(x86_POP), + /*8790*/ uint16(x86_xArgR64op), + /*8791*/ uint16(x86_xMatch), + /*8792*/ uint16(x86_xCondIs64), 8795, 0, + /*8795*/ uint16(x86_xCondDataSize), 8799, 8802, 0, + /*8799*/ uint16(x86_xSetOp), uint16(x86_PUSHA), + /*8801*/ uint16(x86_xMatch), + /*8802*/ uint16(x86_xSetOp), uint16(x86_PUSHAD), + /*8804*/ uint16(x86_xMatch), + /*8805*/ uint16(x86_xCondIs64), 8808, 0, + /*8808*/ uint16(x86_xCondDataSize), 8812, 8815, 0, + /*8812*/ uint16(x86_xSetOp), uint16(x86_POPA), + /*8814*/ uint16(x86_xMatch), + /*8815*/ uint16(x86_xSetOp), uint16(x86_POPAD), + /*8817*/ uint16(x86_xMatch), + /*8818*/ uint16(x86_xCondIs64), 8821, 0, + /*8821*/ uint16(x86_xCondDataSize), 8825, 8831, 0, + /*8825*/ uint16(x86_xSetOp), uint16(x86_BOUND), + /*8827*/ uint16(x86_xReadSlashR), + /*8828*/ uint16(x86_xArgR16), + /*8829*/ uint16(x86_xArgM16and16), + /*8830*/ uint16(x86_xMatch), + /*8831*/ uint16(x86_xSetOp), uint16(x86_BOUND), + /*8833*/ uint16(x86_xReadSlashR), + /*8834*/ uint16(x86_xArgR32), + /*8835*/ uint16(x86_xArgM32and32), + /*8836*/ uint16(x86_xMatch), + /*8837*/ uint16(x86_xCondIs64), 8840, 8846, + /*8840*/ uint16(x86_xSetOp), uint16(x86_ARPL), + /*8842*/ uint16(x86_xReadSlashR), + /*8843*/ uint16(x86_xArgRM16), + /*8844*/ uint16(x86_xArgR16), + /*8845*/ uint16(x86_xMatch), + /*8846*/ uint16(x86_xCondDataSize), 8850, 8856, 8862, + /*8850*/ uint16(x86_xSetOp), uint16(x86_MOVSXD), + /*8852*/ uint16(x86_xReadSlashR), + /*8853*/ uint16(x86_xArgR16), + /*8854*/ uint16(x86_xArgRM32), + /*8855*/ uint16(x86_xMatch), + /*8856*/ uint16(x86_xSetOp), uint16(x86_MOVSXD), + /*8858*/ uint16(x86_xReadSlashR), + /*8859*/ uint16(x86_xArgR32), + /*8860*/ uint16(x86_xArgRM32), + /*8861*/ uint16(x86_xMatch), + /*8862*/ uint16(x86_xSetOp), uint16(x86_MOVSXD), + /*8864*/ uint16(x86_xReadSlashR), + /*8865*/ uint16(x86_xArgR64), + /*8866*/ uint16(x86_xArgRM32), + /*8867*/ uint16(x86_xMatch), + /*8868*/ uint16(x86_xCondDataSize), 8872, 8877, 8882, + /*8872*/ uint16(x86_xSetOp), uint16(x86_PUSH), + /*8874*/ uint16(x86_xReadIw), + /*8875*/ uint16(x86_xArgImm16), + /*8876*/ uint16(x86_xMatch), + /*8877*/ uint16(x86_xSetOp), uint16(x86_PUSH), + /*8879*/ uint16(x86_xReadId), + /*8880*/ uint16(x86_xArgImm32), + /*8881*/ uint16(x86_xMatch), + /*8882*/ uint16(x86_xSetOp), uint16(x86_PUSH), + /*8884*/ uint16(x86_xReadId), + /*8885*/ uint16(x86_xArgImm32), + /*8886*/ uint16(x86_xMatch), + /*8887*/ uint16(x86_xCondIs64), 8890, 8910, + /*8890*/ uint16(x86_xCondDataSize), 8894, 8902, 0, + /*8894*/ uint16(x86_xSetOp), uint16(x86_IMUL), + /*8896*/ uint16(x86_xReadSlashR), + /*8897*/ uint16(x86_xReadIw), + /*8898*/ uint16(x86_xArgR16), + /*8899*/ uint16(x86_xArgRM16), + /*8900*/ uint16(x86_xArgImm16), + /*8901*/ uint16(x86_xMatch), + /*8902*/ uint16(x86_xSetOp), uint16(x86_IMUL), + /*8904*/ uint16(x86_xReadSlashR), + /*8905*/ uint16(x86_xReadId), + /*8906*/ uint16(x86_xArgR32), + /*8907*/ uint16(x86_xArgRM32), + /*8908*/ uint16(x86_xArgImm32), + /*8909*/ uint16(x86_xMatch), + /*8910*/ uint16(x86_xCondDataSize), 8894, 8902, 8914, + /*8914*/ uint16(x86_xSetOp), uint16(x86_IMUL), + /*8916*/ uint16(x86_xReadSlashR), + /*8917*/ uint16(x86_xReadId), + /*8918*/ uint16(x86_xArgR64), + /*8919*/ uint16(x86_xArgRM64), + /*8920*/ uint16(x86_xArgImm32), + /*8921*/ uint16(x86_xMatch), + /*8922*/ uint16(x86_xSetOp), uint16(x86_PUSH), + /*8924*/ uint16(x86_xReadIb), + /*8925*/ uint16(x86_xArgImm8), + /*8926*/ uint16(x86_xMatch), + /*8927*/ uint16(x86_xCondIs64), 8930, 8950, + /*8930*/ uint16(x86_xCondDataSize), 8934, 8942, 0, + /*8934*/ uint16(x86_xSetOp), uint16(x86_IMUL), + /*8936*/ uint16(x86_xReadSlashR), + /*8937*/ uint16(x86_xReadIb), + /*8938*/ uint16(x86_xArgR16), + /*8939*/ uint16(x86_xArgRM16), + /*8940*/ uint16(x86_xArgImm8), + /*8941*/ uint16(x86_xMatch), + /*8942*/ uint16(x86_xSetOp), uint16(x86_IMUL), + /*8944*/ uint16(x86_xReadSlashR), + /*8945*/ uint16(x86_xReadIb), + /*8946*/ uint16(x86_xArgR32), + /*8947*/ uint16(x86_xArgRM32), + /*8948*/ uint16(x86_xArgImm8), + /*8949*/ uint16(x86_xMatch), + /*8950*/ uint16(x86_xCondDataSize), 8934, 8942, 8954, + /*8954*/ uint16(x86_xSetOp), uint16(x86_IMUL), + /*8956*/ uint16(x86_xReadSlashR), + /*8957*/ uint16(x86_xReadIb), + /*8958*/ uint16(x86_xArgR64), + /*8959*/ uint16(x86_xArgRM64), + /*8960*/ uint16(x86_xArgImm8), + /*8961*/ uint16(x86_xMatch), + /*8962*/ uint16(x86_xSetOp), uint16(x86_INSB), + /*8964*/ uint16(x86_xMatch), + /*8965*/ uint16(x86_xCondDataSize), 8969, 8972, 8975, + /*8969*/ uint16(x86_xSetOp), uint16(x86_INSW), + /*8971*/ uint16(x86_xMatch), + /*8972*/ uint16(x86_xSetOp), uint16(x86_INSD), + /*8974*/ uint16(x86_xMatch), + /*8975*/ uint16(x86_xSetOp), uint16(x86_INSD), + /*8977*/ uint16(x86_xMatch), + /*8978*/ uint16(x86_xSetOp), uint16(x86_OUTSB), + /*8980*/ uint16(x86_xMatch), + /*8981*/ uint16(x86_xCondDataSize), 8985, 8988, 8991, + /*8985*/ uint16(x86_xSetOp), uint16(x86_OUTSW), + /*8987*/ uint16(x86_xMatch), + /*8988*/ uint16(x86_xSetOp), uint16(x86_OUTSD), + /*8990*/ uint16(x86_xMatch), + /*8991*/ uint16(x86_xSetOp), uint16(x86_OUTSD), + /*8993*/ uint16(x86_xMatch), + /*8994*/ uint16(x86_xSetOp), uint16(x86_JO), + /*8996*/ uint16(x86_xReadCb), + /*8997*/ uint16(x86_xArgRel8), + /*8998*/ uint16(x86_xMatch), + /*8999*/ uint16(x86_xSetOp), uint16(x86_JNO), + /*9001*/ uint16(x86_xReadCb), + /*9002*/ uint16(x86_xArgRel8), + /*9003*/ uint16(x86_xMatch), + /*9004*/ uint16(x86_xSetOp), uint16(x86_JB), + /*9006*/ uint16(x86_xReadCb), + /*9007*/ uint16(x86_xArgRel8), + /*9008*/ uint16(x86_xMatch), + /*9009*/ uint16(x86_xSetOp), uint16(x86_JAE), + /*9011*/ uint16(x86_xReadCb), + /*9012*/ uint16(x86_xArgRel8), + /*9013*/ uint16(x86_xMatch), + /*9014*/ uint16(x86_xSetOp), uint16(x86_JE), + /*9016*/ uint16(x86_xReadCb), + /*9017*/ uint16(x86_xArgRel8), + /*9018*/ uint16(x86_xMatch), + /*9019*/ uint16(x86_xSetOp), uint16(x86_JNE), + /*9021*/ uint16(x86_xReadCb), + /*9022*/ uint16(x86_xArgRel8), + /*9023*/ uint16(x86_xMatch), + /*9024*/ uint16(x86_xSetOp), uint16(x86_JBE), + /*9026*/ uint16(x86_xReadCb), + /*9027*/ uint16(x86_xArgRel8), + /*9028*/ uint16(x86_xMatch), + /*9029*/ uint16(x86_xSetOp), uint16(x86_JA), + /*9031*/ uint16(x86_xReadCb), + /*9032*/ uint16(x86_xArgRel8), + /*9033*/ uint16(x86_xMatch), + /*9034*/ uint16(x86_xSetOp), uint16(x86_JS), + /*9036*/ uint16(x86_xReadCb), + /*9037*/ uint16(x86_xArgRel8), + /*9038*/ uint16(x86_xMatch), + /*9039*/ uint16(x86_xSetOp), uint16(x86_JNS), + /*9041*/ uint16(x86_xReadCb), + /*9042*/ uint16(x86_xArgRel8), + /*9043*/ uint16(x86_xMatch), + /*9044*/ uint16(x86_xSetOp), uint16(x86_JP), + /*9046*/ uint16(x86_xReadCb), + /*9047*/ uint16(x86_xArgRel8), + /*9048*/ uint16(x86_xMatch), + /*9049*/ uint16(x86_xSetOp), uint16(x86_JNP), + /*9051*/ uint16(x86_xReadCb), + /*9052*/ uint16(x86_xArgRel8), + /*9053*/ uint16(x86_xMatch), + /*9054*/ uint16(x86_xSetOp), uint16(x86_JL), + /*9056*/ uint16(x86_xReadCb), + /*9057*/ uint16(x86_xArgRel8), + /*9058*/ uint16(x86_xMatch), + /*9059*/ uint16(x86_xSetOp), uint16(x86_JGE), + /*9061*/ uint16(x86_xReadCb), + /*9062*/ uint16(x86_xArgRel8), + /*9063*/ uint16(x86_xMatch), + /*9064*/ uint16(x86_xSetOp), uint16(x86_JLE), + /*9066*/ uint16(x86_xReadCb), + /*9067*/ uint16(x86_xArgRel8), + /*9068*/ uint16(x86_xMatch), + /*9069*/ uint16(x86_xSetOp), uint16(x86_JG), + /*9071*/ uint16(x86_xReadCb), + /*9072*/ uint16(x86_xArgRel8), + /*9073*/ uint16(x86_xMatch), + /*9074*/ uint16(x86_xCondSlashR), + 9083, // 0 + 9089, // 1 + 9095, // 2 + 9101, // 3 + 9107, // 4 + 9113, // 5 + 9119, // 6 + 9125, // 7 + /*9083*/ uint16(x86_xSetOp), uint16(x86_ADD), + /*9085*/ uint16(x86_xReadIb), + /*9086*/ uint16(x86_xArgRM8), + /*9087*/ uint16(x86_xArgImm8u), + /*9088*/ uint16(x86_xMatch), + /*9089*/ uint16(x86_xSetOp), uint16(x86_OR), + /*9091*/ uint16(x86_xReadIb), + /*9092*/ uint16(x86_xArgRM8), + /*9093*/ uint16(x86_xArgImm8u), + /*9094*/ uint16(x86_xMatch), + /*9095*/ uint16(x86_xSetOp), uint16(x86_ADC), + /*9097*/ uint16(x86_xReadIb), + /*9098*/ uint16(x86_xArgRM8), + /*9099*/ uint16(x86_xArgImm8u), + /*9100*/ uint16(x86_xMatch), + /*9101*/ uint16(x86_xSetOp), uint16(x86_SBB), + /*9103*/ uint16(x86_xReadIb), + /*9104*/ uint16(x86_xArgRM8), + /*9105*/ uint16(x86_xArgImm8u), + /*9106*/ uint16(x86_xMatch), + /*9107*/ uint16(x86_xSetOp), uint16(x86_AND), + /*9109*/ uint16(x86_xReadIb), + /*9110*/ uint16(x86_xArgRM8), + /*9111*/ uint16(x86_xArgImm8u), + /*9112*/ uint16(x86_xMatch), + /*9113*/ uint16(x86_xSetOp), uint16(x86_SUB), + /*9115*/ uint16(x86_xReadIb), + /*9116*/ uint16(x86_xArgRM8), + /*9117*/ uint16(x86_xArgImm8u), + /*9118*/ uint16(x86_xMatch), + /*9119*/ uint16(x86_xSetOp), uint16(x86_XOR), + /*9121*/ uint16(x86_xReadIb), + /*9122*/ uint16(x86_xArgRM8), + /*9123*/ uint16(x86_xArgImm8u), + /*9124*/ uint16(x86_xMatch), + /*9125*/ uint16(x86_xSetOp), uint16(x86_CMP), + /*9127*/ uint16(x86_xReadIb), + /*9128*/ uint16(x86_xArgRM8), + /*9129*/ uint16(x86_xArgImm8u), + /*9130*/ uint16(x86_xMatch), + /*9131*/ uint16(x86_xCondSlashR), + 9140, // 0 + 9169, // 1 + 9198, // 2 + 9227, // 3 + 9256, // 4 + 9285, // 5 + 9314, // 6 + 9343, // 7 + /*9140*/ uint16(x86_xCondIs64), 9143, 9159, + /*9143*/ uint16(x86_xCondDataSize), 9147, 9153, 0, + /*9147*/ uint16(x86_xSetOp), uint16(x86_ADD), + /*9149*/ uint16(x86_xReadIw), + /*9150*/ uint16(x86_xArgRM16), + /*9151*/ uint16(x86_xArgImm16), + /*9152*/ uint16(x86_xMatch), + /*9153*/ uint16(x86_xSetOp), uint16(x86_ADD), + /*9155*/ uint16(x86_xReadId), + /*9156*/ uint16(x86_xArgRM32), + /*9157*/ uint16(x86_xArgImm32), + /*9158*/ uint16(x86_xMatch), + /*9159*/ uint16(x86_xCondDataSize), 9147, 9153, 9163, + /*9163*/ uint16(x86_xSetOp), uint16(x86_ADD), + /*9165*/ uint16(x86_xReadId), + /*9166*/ uint16(x86_xArgRM64), + /*9167*/ uint16(x86_xArgImm32), + /*9168*/ uint16(x86_xMatch), + /*9169*/ uint16(x86_xCondIs64), 9172, 9188, + /*9172*/ uint16(x86_xCondDataSize), 9176, 9182, 0, + /*9176*/ uint16(x86_xSetOp), uint16(x86_OR), + /*9178*/ uint16(x86_xReadIw), + /*9179*/ uint16(x86_xArgRM16), + /*9180*/ uint16(x86_xArgImm16), + /*9181*/ uint16(x86_xMatch), + /*9182*/ uint16(x86_xSetOp), uint16(x86_OR), + /*9184*/ uint16(x86_xReadId), + /*9185*/ uint16(x86_xArgRM32), + /*9186*/ uint16(x86_xArgImm32), + /*9187*/ uint16(x86_xMatch), + /*9188*/ uint16(x86_xCondDataSize), 9176, 9182, 9192, + /*9192*/ uint16(x86_xSetOp), uint16(x86_OR), + /*9194*/ uint16(x86_xReadId), + /*9195*/ uint16(x86_xArgRM64), + /*9196*/ uint16(x86_xArgImm32), + /*9197*/ uint16(x86_xMatch), + /*9198*/ uint16(x86_xCondIs64), 9201, 9217, + /*9201*/ uint16(x86_xCondDataSize), 9205, 9211, 0, + /*9205*/ uint16(x86_xSetOp), uint16(x86_ADC), + /*9207*/ uint16(x86_xReadIw), + /*9208*/ uint16(x86_xArgRM16), + /*9209*/ uint16(x86_xArgImm16), + /*9210*/ uint16(x86_xMatch), + /*9211*/ uint16(x86_xSetOp), uint16(x86_ADC), + /*9213*/ uint16(x86_xReadId), + /*9214*/ uint16(x86_xArgRM32), + /*9215*/ uint16(x86_xArgImm32), + /*9216*/ uint16(x86_xMatch), + /*9217*/ uint16(x86_xCondDataSize), 9205, 9211, 9221, + /*9221*/ uint16(x86_xSetOp), uint16(x86_ADC), + /*9223*/ uint16(x86_xReadId), + /*9224*/ uint16(x86_xArgRM64), + /*9225*/ uint16(x86_xArgImm32), + /*9226*/ uint16(x86_xMatch), + /*9227*/ uint16(x86_xCondIs64), 9230, 9246, + /*9230*/ uint16(x86_xCondDataSize), 9234, 9240, 0, + /*9234*/ uint16(x86_xSetOp), uint16(x86_SBB), + /*9236*/ uint16(x86_xReadIw), + /*9237*/ uint16(x86_xArgRM16), + /*9238*/ uint16(x86_xArgImm16), + /*9239*/ uint16(x86_xMatch), + /*9240*/ uint16(x86_xSetOp), uint16(x86_SBB), + /*9242*/ uint16(x86_xReadId), + /*9243*/ uint16(x86_xArgRM32), + /*9244*/ uint16(x86_xArgImm32), + /*9245*/ uint16(x86_xMatch), + /*9246*/ uint16(x86_xCondDataSize), 9234, 9240, 9250, + /*9250*/ uint16(x86_xSetOp), uint16(x86_SBB), + /*9252*/ uint16(x86_xReadId), + /*9253*/ uint16(x86_xArgRM64), + /*9254*/ uint16(x86_xArgImm32), + /*9255*/ uint16(x86_xMatch), + /*9256*/ uint16(x86_xCondIs64), 9259, 9275, + /*9259*/ uint16(x86_xCondDataSize), 9263, 9269, 0, + /*9263*/ uint16(x86_xSetOp), uint16(x86_AND), + /*9265*/ uint16(x86_xReadIw), + /*9266*/ uint16(x86_xArgRM16), + /*9267*/ uint16(x86_xArgImm16), + /*9268*/ uint16(x86_xMatch), + /*9269*/ uint16(x86_xSetOp), uint16(x86_AND), + /*9271*/ uint16(x86_xReadId), + /*9272*/ uint16(x86_xArgRM32), + /*9273*/ uint16(x86_xArgImm32), + /*9274*/ uint16(x86_xMatch), + /*9275*/ uint16(x86_xCondDataSize), 9263, 9269, 9279, + /*9279*/ uint16(x86_xSetOp), uint16(x86_AND), + /*9281*/ uint16(x86_xReadId), + /*9282*/ uint16(x86_xArgRM64), + /*9283*/ uint16(x86_xArgImm32), + /*9284*/ uint16(x86_xMatch), + /*9285*/ uint16(x86_xCondIs64), 9288, 9304, + /*9288*/ uint16(x86_xCondDataSize), 9292, 9298, 0, + /*9292*/ uint16(x86_xSetOp), uint16(x86_SUB), + /*9294*/ uint16(x86_xReadIw), + /*9295*/ uint16(x86_xArgRM16), + /*9296*/ uint16(x86_xArgImm16), + /*9297*/ uint16(x86_xMatch), + /*9298*/ uint16(x86_xSetOp), uint16(x86_SUB), + /*9300*/ uint16(x86_xReadId), + /*9301*/ uint16(x86_xArgRM32), + /*9302*/ uint16(x86_xArgImm32), + /*9303*/ uint16(x86_xMatch), + /*9304*/ uint16(x86_xCondDataSize), 9292, 9298, 9308, + /*9308*/ uint16(x86_xSetOp), uint16(x86_SUB), + /*9310*/ uint16(x86_xReadId), + /*9311*/ uint16(x86_xArgRM64), + /*9312*/ uint16(x86_xArgImm32), + /*9313*/ uint16(x86_xMatch), + /*9314*/ uint16(x86_xCondIs64), 9317, 9333, + /*9317*/ uint16(x86_xCondDataSize), 9321, 9327, 0, + /*9321*/ uint16(x86_xSetOp), uint16(x86_XOR), + /*9323*/ uint16(x86_xReadIw), + /*9324*/ uint16(x86_xArgRM16), + /*9325*/ uint16(x86_xArgImm16), + /*9326*/ uint16(x86_xMatch), + /*9327*/ uint16(x86_xSetOp), uint16(x86_XOR), + /*9329*/ uint16(x86_xReadId), + /*9330*/ uint16(x86_xArgRM32), + /*9331*/ uint16(x86_xArgImm32), + /*9332*/ uint16(x86_xMatch), + /*9333*/ uint16(x86_xCondDataSize), 9321, 9327, 9337, + /*9337*/ uint16(x86_xSetOp), uint16(x86_XOR), + /*9339*/ uint16(x86_xReadId), + /*9340*/ uint16(x86_xArgRM64), + /*9341*/ uint16(x86_xArgImm32), + /*9342*/ uint16(x86_xMatch), + /*9343*/ uint16(x86_xCondIs64), 9346, 9362, + /*9346*/ uint16(x86_xCondDataSize), 9350, 9356, 0, + /*9350*/ uint16(x86_xSetOp), uint16(x86_CMP), + /*9352*/ uint16(x86_xReadIw), + /*9353*/ uint16(x86_xArgRM16), + /*9354*/ uint16(x86_xArgImm16), + /*9355*/ uint16(x86_xMatch), + /*9356*/ uint16(x86_xSetOp), uint16(x86_CMP), + /*9358*/ uint16(x86_xReadId), + /*9359*/ uint16(x86_xArgRM32), + /*9360*/ uint16(x86_xArgImm32), + /*9361*/ uint16(x86_xMatch), + /*9362*/ uint16(x86_xCondDataSize), 9350, 9356, 9366, + /*9366*/ uint16(x86_xSetOp), uint16(x86_CMP), + /*9368*/ uint16(x86_xReadId), + /*9369*/ uint16(x86_xArgRM64), + /*9370*/ uint16(x86_xArgImm32), + /*9371*/ uint16(x86_xMatch), + /*9372*/ uint16(x86_xCondSlashR), + 9381, // 0 + 9410, // 1 + 9439, // 2 + 9468, // 3 + 9497, // 4 + 9526, // 5 + 9555, // 6 + 9584, // 7 + /*9381*/ uint16(x86_xCondIs64), 9384, 9400, + /*9384*/ uint16(x86_xCondDataSize), 9388, 9394, 0, + /*9388*/ uint16(x86_xSetOp), uint16(x86_ADD), + /*9390*/ uint16(x86_xReadIb), + /*9391*/ uint16(x86_xArgRM16), + /*9392*/ uint16(x86_xArgImm8), + /*9393*/ uint16(x86_xMatch), + /*9394*/ uint16(x86_xSetOp), uint16(x86_ADD), + /*9396*/ uint16(x86_xReadIb), + /*9397*/ uint16(x86_xArgRM32), + /*9398*/ uint16(x86_xArgImm8), + /*9399*/ uint16(x86_xMatch), + /*9400*/ uint16(x86_xCondDataSize), 9388, 9394, 9404, + /*9404*/ uint16(x86_xSetOp), uint16(x86_ADD), + /*9406*/ uint16(x86_xReadIb), + /*9407*/ uint16(x86_xArgRM64), + /*9408*/ uint16(x86_xArgImm8), + /*9409*/ uint16(x86_xMatch), + /*9410*/ uint16(x86_xCondIs64), 9413, 9429, + /*9413*/ uint16(x86_xCondDataSize), 9417, 9423, 0, + /*9417*/ uint16(x86_xSetOp), uint16(x86_OR), + /*9419*/ uint16(x86_xReadIb), + /*9420*/ uint16(x86_xArgRM16), + /*9421*/ uint16(x86_xArgImm8), + /*9422*/ uint16(x86_xMatch), + /*9423*/ uint16(x86_xSetOp), uint16(x86_OR), + /*9425*/ uint16(x86_xReadIb), + /*9426*/ uint16(x86_xArgRM32), + /*9427*/ uint16(x86_xArgImm8), + /*9428*/ uint16(x86_xMatch), + /*9429*/ uint16(x86_xCondDataSize), 9417, 9423, 9433, + /*9433*/ uint16(x86_xSetOp), uint16(x86_OR), + /*9435*/ uint16(x86_xReadIb), + /*9436*/ uint16(x86_xArgRM64), + /*9437*/ uint16(x86_xArgImm8), + /*9438*/ uint16(x86_xMatch), + /*9439*/ uint16(x86_xCondIs64), 9442, 9458, + /*9442*/ uint16(x86_xCondDataSize), 9446, 9452, 0, + /*9446*/ uint16(x86_xSetOp), uint16(x86_ADC), + /*9448*/ uint16(x86_xReadIb), + /*9449*/ uint16(x86_xArgRM16), + /*9450*/ uint16(x86_xArgImm8), + /*9451*/ uint16(x86_xMatch), + /*9452*/ uint16(x86_xSetOp), uint16(x86_ADC), + /*9454*/ uint16(x86_xReadIb), + /*9455*/ uint16(x86_xArgRM32), + /*9456*/ uint16(x86_xArgImm8), + /*9457*/ uint16(x86_xMatch), + /*9458*/ uint16(x86_xCondDataSize), 9446, 9452, 9462, + /*9462*/ uint16(x86_xSetOp), uint16(x86_ADC), + /*9464*/ uint16(x86_xReadIb), + /*9465*/ uint16(x86_xArgRM64), + /*9466*/ uint16(x86_xArgImm8), + /*9467*/ uint16(x86_xMatch), + /*9468*/ uint16(x86_xCondIs64), 9471, 9487, + /*9471*/ uint16(x86_xCondDataSize), 9475, 9481, 0, + /*9475*/ uint16(x86_xSetOp), uint16(x86_SBB), + /*9477*/ uint16(x86_xReadIb), + /*9478*/ uint16(x86_xArgRM16), + /*9479*/ uint16(x86_xArgImm8), + /*9480*/ uint16(x86_xMatch), + /*9481*/ uint16(x86_xSetOp), uint16(x86_SBB), + /*9483*/ uint16(x86_xReadIb), + /*9484*/ uint16(x86_xArgRM32), + /*9485*/ uint16(x86_xArgImm8), + /*9486*/ uint16(x86_xMatch), + /*9487*/ uint16(x86_xCondDataSize), 9475, 9481, 9491, + /*9491*/ uint16(x86_xSetOp), uint16(x86_SBB), + /*9493*/ uint16(x86_xReadIb), + /*9494*/ uint16(x86_xArgRM64), + /*9495*/ uint16(x86_xArgImm8), + /*9496*/ uint16(x86_xMatch), + /*9497*/ uint16(x86_xCondIs64), 9500, 9516, + /*9500*/ uint16(x86_xCondDataSize), 9504, 9510, 0, + /*9504*/ uint16(x86_xSetOp), uint16(x86_AND), + /*9506*/ uint16(x86_xReadIb), + /*9507*/ uint16(x86_xArgRM16), + /*9508*/ uint16(x86_xArgImm8), + /*9509*/ uint16(x86_xMatch), + /*9510*/ uint16(x86_xSetOp), uint16(x86_AND), + /*9512*/ uint16(x86_xReadIb), + /*9513*/ uint16(x86_xArgRM32), + /*9514*/ uint16(x86_xArgImm8), + /*9515*/ uint16(x86_xMatch), + /*9516*/ uint16(x86_xCondDataSize), 9504, 9510, 9520, + /*9520*/ uint16(x86_xSetOp), uint16(x86_AND), + /*9522*/ uint16(x86_xReadIb), + /*9523*/ uint16(x86_xArgRM64), + /*9524*/ uint16(x86_xArgImm8), + /*9525*/ uint16(x86_xMatch), + /*9526*/ uint16(x86_xCondIs64), 9529, 9545, + /*9529*/ uint16(x86_xCondDataSize), 9533, 9539, 0, + /*9533*/ uint16(x86_xSetOp), uint16(x86_SUB), + /*9535*/ uint16(x86_xReadIb), + /*9536*/ uint16(x86_xArgRM16), + /*9537*/ uint16(x86_xArgImm8), + /*9538*/ uint16(x86_xMatch), + /*9539*/ uint16(x86_xSetOp), uint16(x86_SUB), + /*9541*/ uint16(x86_xReadIb), + /*9542*/ uint16(x86_xArgRM32), + /*9543*/ uint16(x86_xArgImm8), + /*9544*/ uint16(x86_xMatch), + /*9545*/ uint16(x86_xCondDataSize), 9533, 9539, 9549, + /*9549*/ uint16(x86_xSetOp), uint16(x86_SUB), + /*9551*/ uint16(x86_xReadIb), + /*9552*/ uint16(x86_xArgRM64), + /*9553*/ uint16(x86_xArgImm8), + /*9554*/ uint16(x86_xMatch), + /*9555*/ uint16(x86_xCondIs64), 9558, 9574, + /*9558*/ uint16(x86_xCondDataSize), 9562, 9568, 0, + /*9562*/ uint16(x86_xSetOp), uint16(x86_XOR), + /*9564*/ uint16(x86_xReadIb), + /*9565*/ uint16(x86_xArgRM16), + /*9566*/ uint16(x86_xArgImm8), + /*9567*/ uint16(x86_xMatch), + /*9568*/ uint16(x86_xSetOp), uint16(x86_XOR), + /*9570*/ uint16(x86_xReadIb), + /*9571*/ uint16(x86_xArgRM32), + /*9572*/ uint16(x86_xArgImm8), + /*9573*/ uint16(x86_xMatch), + /*9574*/ uint16(x86_xCondDataSize), 9562, 9568, 9578, + /*9578*/ uint16(x86_xSetOp), uint16(x86_XOR), + /*9580*/ uint16(x86_xReadIb), + /*9581*/ uint16(x86_xArgRM64), + /*9582*/ uint16(x86_xArgImm8), + /*9583*/ uint16(x86_xMatch), + /*9584*/ uint16(x86_xCondIs64), 9587, 9603, + /*9587*/ uint16(x86_xCondDataSize), 9591, 9597, 0, + /*9591*/ uint16(x86_xSetOp), uint16(x86_CMP), + /*9593*/ uint16(x86_xReadIb), + /*9594*/ uint16(x86_xArgRM16), + /*9595*/ uint16(x86_xArgImm8), + /*9596*/ uint16(x86_xMatch), + /*9597*/ uint16(x86_xSetOp), uint16(x86_CMP), + /*9599*/ uint16(x86_xReadIb), + /*9600*/ uint16(x86_xArgRM32), + /*9601*/ uint16(x86_xArgImm8), + /*9602*/ uint16(x86_xMatch), + /*9603*/ uint16(x86_xCondDataSize), 9591, 9597, 9607, + /*9607*/ uint16(x86_xSetOp), uint16(x86_CMP), + /*9609*/ uint16(x86_xReadIb), + /*9610*/ uint16(x86_xArgRM64), + /*9611*/ uint16(x86_xArgImm8), + /*9612*/ uint16(x86_xMatch), + /*9613*/ uint16(x86_xSetOp), uint16(x86_TEST), + /*9615*/ uint16(x86_xReadSlashR), + /*9616*/ uint16(x86_xArgRM8), + /*9617*/ uint16(x86_xArgR8), + /*9618*/ uint16(x86_xMatch), + /*9619*/ uint16(x86_xCondIs64), 9622, 9638, + /*9622*/ uint16(x86_xCondDataSize), 9626, 9632, 0, + /*9626*/ uint16(x86_xSetOp), uint16(x86_TEST), + /*9628*/ uint16(x86_xReadSlashR), + /*9629*/ uint16(x86_xArgRM16), + /*9630*/ uint16(x86_xArgR16), + /*9631*/ uint16(x86_xMatch), + /*9632*/ uint16(x86_xSetOp), uint16(x86_TEST), + /*9634*/ uint16(x86_xReadSlashR), + /*9635*/ uint16(x86_xArgRM32), + /*9636*/ uint16(x86_xArgR32), + /*9637*/ uint16(x86_xMatch), + /*9638*/ uint16(x86_xCondDataSize), 9626, 9632, 9642, + /*9642*/ uint16(x86_xSetOp), uint16(x86_TEST), + /*9644*/ uint16(x86_xReadSlashR), + /*9645*/ uint16(x86_xArgRM64), + /*9646*/ uint16(x86_xArgR64), + /*9647*/ uint16(x86_xMatch), + /*9648*/ uint16(x86_xSetOp), uint16(x86_XCHG), + /*9650*/ uint16(x86_xReadSlashR), + /*9651*/ uint16(x86_xArgRM8), + /*9652*/ uint16(x86_xArgR8), + /*9653*/ uint16(x86_xMatch), + /*9654*/ uint16(x86_xCondIs64), 9657, 9673, + /*9657*/ uint16(x86_xCondDataSize), 9661, 9667, 0, + /*9661*/ uint16(x86_xSetOp), uint16(x86_XCHG), + /*9663*/ uint16(x86_xReadSlashR), + /*9664*/ uint16(x86_xArgRM16), + /*9665*/ uint16(x86_xArgR16), + /*9666*/ uint16(x86_xMatch), + /*9667*/ uint16(x86_xSetOp), uint16(x86_XCHG), + /*9669*/ uint16(x86_xReadSlashR), + /*9670*/ uint16(x86_xArgRM32), + /*9671*/ uint16(x86_xArgR32), + /*9672*/ uint16(x86_xMatch), + /*9673*/ uint16(x86_xCondDataSize), 9661, 9667, 9677, + /*9677*/ uint16(x86_xSetOp), uint16(x86_XCHG), + /*9679*/ uint16(x86_xReadSlashR), + /*9680*/ uint16(x86_xArgRM64), + /*9681*/ uint16(x86_xArgR64), + /*9682*/ uint16(x86_xMatch), + /*9683*/ uint16(x86_xSetOp), uint16(x86_MOV), + /*9685*/ uint16(x86_xReadSlashR), + /*9686*/ uint16(x86_xArgRM8), + /*9687*/ uint16(x86_xArgR8), + /*9688*/ uint16(x86_xMatch), + /*9689*/ uint16(x86_xCondDataSize), 9693, 9699, 9705, + /*9693*/ uint16(x86_xSetOp), uint16(x86_MOV), + /*9695*/ uint16(x86_xReadSlashR), + /*9696*/ uint16(x86_xArgRM16), + /*9697*/ uint16(x86_xArgR16), + /*9698*/ uint16(x86_xMatch), + /*9699*/ uint16(x86_xSetOp), uint16(x86_MOV), + /*9701*/ uint16(x86_xReadSlashR), + /*9702*/ uint16(x86_xArgRM32), + /*9703*/ uint16(x86_xArgR32), + /*9704*/ uint16(x86_xMatch), + /*9705*/ uint16(x86_xSetOp), uint16(x86_MOV), + /*9707*/ uint16(x86_xReadSlashR), + /*9708*/ uint16(x86_xArgRM64), + /*9709*/ uint16(x86_xArgR64), + /*9710*/ uint16(x86_xMatch), + /*9711*/ uint16(x86_xSetOp), uint16(x86_MOV), + /*9713*/ uint16(x86_xReadSlashR), + /*9714*/ uint16(x86_xArgR8), + /*9715*/ uint16(x86_xArgRM8), + /*9716*/ uint16(x86_xMatch), + /*9717*/ uint16(x86_xCondDataSize), 9721, 9727, 9733, + /*9721*/ uint16(x86_xSetOp), uint16(x86_MOV), + /*9723*/ uint16(x86_xReadSlashR), + /*9724*/ uint16(x86_xArgR16), + /*9725*/ uint16(x86_xArgRM16), + /*9726*/ uint16(x86_xMatch), + /*9727*/ uint16(x86_xSetOp), uint16(x86_MOV), + /*9729*/ uint16(x86_xReadSlashR), + /*9730*/ uint16(x86_xArgR32), + /*9731*/ uint16(x86_xArgRM32), + /*9732*/ uint16(x86_xMatch), + /*9733*/ uint16(x86_xSetOp), uint16(x86_MOV), + /*9735*/ uint16(x86_xReadSlashR), + /*9736*/ uint16(x86_xArgR64), + /*9737*/ uint16(x86_xArgRM64), + /*9738*/ uint16(x86_xMatch), + /*9739*/ uint16(x86_xCondIs64), 9742, 9758, + /*9742*/ uint16(x86_xCondDataSize), 9746, 9752, 0, + /*9746*/ uint16(x86_xSetOp), uint16(x86_MOV), + /*9748*/ uint16(x86_xReadSlashR), + /*9749*/ uint16(x86_xArgRM16), + /*9750*/ uint16(x86_xArgSreg), + /*9751*/ uint16(x86_xMatch), + /*9752*/ uint16(x86_xSetOp), uint16(x86_MOV), + /*9754*/ uint16(x86_xReadSlashR), + /*9755*/ uint16(x86_xArgR32M16), + /*9756*/ uint16(x86_xArgSreg), + /*9757*/ uint16(x86_xMatch), + /*9758*/ uint16(x86_xCondDataSize), 9746, 9752, 9762, + /*9762*/ uint16(x86_xSetOp), uint16(x86_MOV), + /*9764*/ uint16(x86_xReadSlashR), + /*9765*/ uint16(x86_xArgR64M16), + /*9766*/ uint16(x86_xArgSreg), + /*9767*/ uint16(x86_xMatch), + /*9768*/ uint16(x86_xCondIs64), 9771, 9787, + /*9771*/ uint16(x86_xCondDataSize), 9775, 9781, 0, + /*9775*/ uint16(x86_xSetOp), uint16(x86_LEA), + /*9777*/ uint16(x86_xReadSlashR), + /*9778*/ uint16(x86_xArgR16), + /*9779*/ uint16(x86_xArgM), + /*9780*/ uint16(x86_xMatch), + /*9781*/ uint16(x86_xSetOp), uint16(x86_LEA), + /*9783*/ uint16(x86_xReadSlashR), + /*9784*/ uint16(x86_xArgR32), + /*9785*/ uint16(x86_xArgM), + /*9786*/ uint16(x86_xMatch), + /*9787*/ uint16(x86_xCondDataSize), 9775, 9781, 9791, + /*9791*/ uint16(x86_xSetOp), uint16(x86_LEA), + /*9793*/ uint16(x86_xReadSlashR), + /*9794*/ uint16(x86_xArgR64), + /*9795*/ uint16(x86_xArgM), + /*9796*/ uint16(x86_xMatch), + /*9797*/ uint16(x86_xCondIs64), 9800, 9816, + /*9800*/ uint16(x86_xCondDataSize), 9804, 9810, 0, + /*9804*/ uint16(x86_xSetOp), uint16(x86_MOV), + /*9806*/ uint16(x86_xReadSlashR), + /*9807*/ uint16(x86_xArgSreg), + /*9808*/ uint16(x86_xArgRM16), + /*9809*/ uint16(x86_xMatch), + /*9810*/ uint16(x86_xSetOp), uint16(x86_MOV), + /*9812*/ uint16(x86_xReadSlashR), + /*9813*/ uint16(x86_xArgSreg), + /*9814*/ uint16(x86_xArgR32M16), + /*9815*/ uint16(x86_xMatch), + /*9816*/ uint16(x86_xCondDataSize), 9804, 9810, 9820, + /*9820*/ uint16(x86_xSetOp), uint16(x86_MOV), + /*9822*/ uint16(x86_xReadSlashR), + /*9823*/ uint16(x86_xArgSreg), + /*9824*/ uint16(x86_xArgR64M16), + /*9825*/ uint16(x86_xMatch), + /*9826*/ uint16(x86_xCondSlashR), + 9835, // 0 + 0, // 1 + 0, // 2 + 0, // 3 + 0, // 4 + 0, // 5 + 0, // 6 + 0, // 7 + /*9835*/ uint16(x86_xCondIs64), 9838, 9850, + /*9838*/ uint16(x86_xCondDataSize), 9842, 9846, 0, + /*9842*/ uint16(x86_xSetOp), uint16(x86_POP), + /*9844*/ uint16(x86_xArgRM16), + /*9845*/ uint16(x86_xMatch), + /*9846*/ uint16(x86_xSetOp), uint16(x86_POP), + /*9848*/ uint16(x86_xArgRM32), + /*9849*/ uint16(x86_xMatch), + /*9850*/ uint16(x86_xCondDataSize), 9842, 9854, 9858, + /*9854*/ uint16(x86_xSetOp), uint16(x86_POP), + /*9856*/ uint16(x86_xArgRM64), + /*9857*/ uint16(x86_xMatch), + /*9858*/ uint16(x86_xSetOp), uint16(x86_POP), + /*9860*/ uint16(x86_xArgRM64), + /*9861*/ uint16(x86_xMatch), + /*9862*/ uint16(x86_xCondIs64), 9865, 9879, + /*9865*/ uint16(x86_xCondDataSize), 9869, 9874, 0, + /*9869*/ uint16(x86_xSetOp), uint16(x86_XCHG), + /*9871*/ uint16(x86_xArgR16op), + /*9872*/ uint16(x86_xArgAX), + /*9873*/ uint16(x86_xMatch), + /*9874*/ uint16(x86_xSetOp), uint16(x86_XCHG), + /*9876*/ uint16(x86_xArgR32op), + /*9877*/ uint16(x86_xArgEAX), + /*9878*/ uint16(x86_xMatch), + /*9879*/ uint16(x86_xCondDataSize), 9869, 9874, 9883, + /*9883*/ uint16(x86_xSetOp), uint16(x86_XCHG), + /*9885*/ uint16(x86_xArgR64op), + /*9886*/ uint16(x86_xArgRAX), + /*9887*/ uint16(x86_xMatch), + /*9888*/ uint16(x86_xCondIs64), 9891, 9901, + /*9891*/ uint16(x86_xCondDataSize), 9895, 9898, 0, + /*9895*/ uint16(x86_xSetOp), uint16(x86_CBW), + /*9897*/ uint16(x86_xMatch), + /*9898*/ uint16(x86_xSetOp), uint16(x86_CWDE), + /*9900*/ uint16(x86_xMatch), + /*9901*/ uint16(x86_xCondDataSize), 9895, 9898, 9905, + /*9905*/ uint16(x86_xSetOp), uint16(x86_CDQE), + /*9907*/ uint16(x86_xMatch), + /*9908*/ uint16(x86_xCondIs64), 9911, 9921, + /*9911*/ uint16(x86_xCondDataSize), 9915, 9918, 0, + /*9915*/ uint16(x86_xSetOp), uint16(x86_CWD), + /*9917*/ uint16(x86_xMatch), + /*9918*/ uint16(x86_xSetOp), uint16(x86_CDQ), + /*9920*/ uint16(x86_xMatch), + /*9921*/ uint16(x86_xCondDataSize), 9915, 9918, 9925, + /*9925*/ uint16(x86_xSetOp), uint16(x86_CQO), + /*9927*/ uint16(x86_xMatch), + /*9928*/ uint16(x86_xCondIs64), 9931, 0, + /*9931*/ uint16(x86_xCondDataSize), 9935, 9940, 0, + /*9935*/ uint16(x86_xSetOp), uint16(x86_LCALL), + /*9937*/ uint16(x86_xReadCd), + /*9938*/ uint16(x86_xArgPtr16colon16), + /*9939*/ uint16(x86_xMatch), + /*9940*/ uint16(x86_xSetOp), uint16(x86_LCALL), + /*9942*/ uint16(x86_xReadCp), + /*9943*/ uint16(x86_xArgPtr16colon32), + /*9944*/ uint16(x86_xMatch), + /*9945*/ uint16(x86_xSetOp), uint16(x86_FWAIT), + /*9947*/ uint16(x86_xMatch), + /*9948*/ uint16(x86_xCondIs64), 9951, 9961, + /*9951*/ uint16(x86_xCondDataSize), 9955, 9958, 0, + /*9955*/ uint16(x86_xSetOp), uint16(x86_PUSHF), + /*9957*/ uint16(x86_xMatch), + /*9958*/ uint16(x86_xSetOp), uint16(x86_PUSHFD), + /*9960*/ uint16(x86_xMatch), + /*9961*/ uint16(x86_xCondDataSize), 9955, 9965, 9968, + /*9965*/ uint16(x86_xSetOp), uint16(x86_PUSHFQ), + /*9967*/ uint16(x86_xMatch), + /*9968*/ uint16(x86_xSetOp), uint16(x86_PUSHFQ), + /*9970*/ uint16(x86_xMatch), + /*9971*/ uint16(x86_xCondIs64), 9974, 9984, + /*9974*/ uint16(x86_xCondDataSize), 9978, 9981, 0, + /*9978*/ uint16(x86_xSetOp), uint16(x86_POPF), + /*9980*/ uint16(x86_xMatch), + /*9981*/ uint16(x86_xSetOp), uint16(x86_POPFD), + /*9983*/ uint16(x86_xMatch), + /*9984*/ uint16(x86_xCondDataSize), 9978, 9988, 9991, + /*9988*/ uint16(x86_xSetOp), uint16(x86_POPFQ), + /*9990*/ uint16(x86_xMatch), + /*9991*/ uint16(x86_xSetOp), uint16(x86_POPFQ), + /*9993*/ uint16(x86_xMatch), + /*9994*/ uint16(x86_xSetOp), uint16(x86_SAHF), + /*9996*/ uint16(x86_xMatch), + /*9997*/ uint16(x86_xSetOp), uint16(x86_LAHF), + /*9999*/ uint16(x86_xMatch), + /*10000*/ uint16(x86_xCondIs64), 10003, 10009, + /*10003*/ uint16(x86_xSetOp), uint16(x86_MOV), + /*10005*/ uint16(x86_xReadCm), + /*10006*/ uint16(x86_xArgAL), + /*10007*/ uint16(x86_xArgMoffs8), + /*10008*/ uint16(x86_xMatch), + /*10009*/ uint16(x86_xCondDataSize), 10003, 10003, 10013, + /*10013*/ uint16(x86_xSetOp), uint16(x86_MOV), + /*10015*/ uint16(x86_xReadCm), + /*10016*/ uint16(x86_xArgAL), + /*10017*/ uint16(x86_xArgMoffs8), + /*10018*/ uint16(x86_xMatch), + /*10019*/ uint16(x86_xCondDataSize), 10023, 10029, 10035, + /*10023*/ uint16(x86_xSetOp), uint16(x86_MOV), + /*10025*/ uint16(x86_xReadCm), + /*10026*/ uint16(x86_xArgAX), + /*10027*/ uint16(x86_xArgMoffs16), + /*10028*/ uint16(x86_xMatch), + /*10029*/ uint16(x86_xSetOp), uint16(x86_MOV), + /*10031*/ uint16(x86_xReadCm), + /*10032*/ uint16(x86_xArgEAX), + /*10033*/ uint16(x86_xArgMoffs32), + /*10034*/ uint16(x86_xMatch), + /*10035*/ uint16(x86_xSetOp), uint16(x86_MOV), + /*10037*/ uint16(x86_xReadCm), + /*10038*/ uint16(x86_xArgRAX), + /*10039*/ uint16(x86_xArgMoffs64), + /*10040*/ uint16(x86_xMatch), + /*10041*/ uint16(x86_xCondIs64), 10044, 10050, + /*10044*/ uint16(x86_xSetOp), uint16(x86_MOV), + /*10046*/ uint16(x86_xReadCm), + /*10047*/ uint16(x86_xArgMoffs8), + /*10048*/ uint16(x86_xArgAL), + /*10049*/ uint16(x86_xMatch), + /*10050*/ uint16(x86_xCondDataSize), 10044, 10044, 10054, + /*10054*/ uint16(x86_xSetOp), uint16(x86_MOV), + /*10056*/ uint16(x86_xReadCm), + /*10057*/ uint16(x86_xArgMoffs8), + /*10058*/ uint16(x86_xArgAL), + /*10059*/ uint16(x86_xMatch), + /*10060*/ uint16(x86_xCondDataSize), 10064, 10070, 10076, + /*10064*/ uint16(x86_xSetOp), uint16(x86_MOV), + /*10066*/ uint16(x86_xReadCm), + /*10067*/ uint16(x86_xArgMoffs16), + /*10068*/ uint16(x86_xArgAX), + /*10069*/ uint16(x86_xMatch), + /*10070*/ uint16(x86_xSetOp), uint16(x86_MOV), + /*10072*/ uint16(x86_xReadCm), + /*10073*/ uint16(x86_xArgMoffs32), + /*10074*/ uint16(x86_xArgEAX), + /*10075*/ uint16(x86_xMatch), + /*10076*/ uint16(x86_xSetOp), uint16(x86_MOV), + /*10078*/ uint16(x86_xReadCm), + /*10079*/ uint16(x86_xArgMoffs64), + /*10080*/ uint16(x86_xArgRAX), + /*10081*/ uint16(x86_xMatch), + /*10082*/ uint16(x86_xSetOp), uint16(x86_MOVSB), + /*10084*/ uint16(x86_xMatch), + /*10085*/ uint16(x86_xCondIs64), 10088, 10098, + /*10088*/ uint16(x86_xCondDataSize), 10092, 10095, 0, + /*10092*/ uint16(x86_xSetOp), uint16(x86_MOVSW), + /*10094*/ uint16(x86_xMatch), + /*10095*/ uint16(x86_xSetOp), uint16(x86_MOVSD), + /*10097*/ uint16(x86_xMatch), + /*10098*/ uint16(x86_xCondDataSize), 10092, 10095, 10102, + /*10102*/ uint16(x86_xSetOp), uint16(x86_MOVSQ), + /*10104*/ uint16(x86_xMatch), + /*10105*/ uint16(x86_xSetOp), uint16(x86_CMPSB), + /*10107*/ uint16(x86_xMatch), + /*10108*/ uint16(x86_xCondIs64), 10111, 10121, + /*10111*/ uint16(x86_xCondDataSize), 10115, 10118, 0, + /*10115*/ uint16(x86_xSetOp), uint16(x86_CMPSW), + /*10117*/ uint16(x86_xMatch), + /*10118*/ uint16(x86_xSetOp), uint16(x86_CMPSD), + /*10120*/ uint16(x86_xMatch), + /*10121*/ uint16(x86_xCondDataSize), 10115, 10118, 10125, + /*10125*/ uint16(x86_xSetOp), uint16(x86_CMPSQ), + /*10127*/ uint16(x86_xMatch), + /*10128*/ uint16(x86_xSetOp), uint16(x86_TEST), + /*10130*/ uint16(x86_xReadIb), + /*10131*/ uint16(x86_xArgAL), + /*10132*/ uint16(x86_xArgImm8u), + /*10133*/ uint16(x86_xMatch), + /*10134*/ uint16(x86_xCondIs64), 10137, 10153, + /*10137*/ uint16(x86_xCondDataSize), 10141, 10147, 0, + /*10141*/ uint16(x86_xSetOp), uint16(x86_TEST), + /*10143*/ uint16(x86_xReadIw), + /*10144*/ uint16(x86_xArgAX), + /*10145*/ uint16(x86_xArgImm16), + /*10146*/ uint16(x86_xMatch), + /*10147*/ uint16(x86_xSetOp), uint16(x86_TEST), + /*10149*/ uint16(x86_xReadId), + /*10150*/ uint16(x86_xArgEAX), + /*10151*/ uint16(x86_xArgImm32), + /*10152*/ uint16(x86_xMatch), + /*10153*/ uint16(x86_xCondDataSize), 10141, 10147, 10157, + /*10157*/ uint16(x86_xSetOp), uint16(x86_TEST), + /*10159*/ uint16(x86_xReadId), + /*10160*/ uint16(x86_xArgRAX), + /*10161*/ uint16(x86_xArgImm32), + /*10162*/ uint16(x86_xMatch), + /*10163*/ uint16(x86_xSetOp), uint16(x86_STOSB), + /*10165*/ uint16(x86_xMatch), + /*10166*/ uint16(x86_xCondIs64), 10169, 10179, + /*10169*/ uint16(x86_xCondDataSize), 10173, 10176, 0, + /*10173*/ uint16(x86_xSetOp), uint16(x86_STOSW), + /*10175*/ uint16(x86_xMatch), + /*10176*/ uint16(x86_xSetOp), uint16(x86_STOSD), + /*10178*/ uint16(x86_xMatch), + /*10179*/ uint16(x86_xCondDataSize), 10173, 10176, 10183, + /*10183*/ uint16(x86_xSetOp), uint16(x86_STOSQ), + /*10185*/ uint16(x86_xMatch), + /*10186*/ uint16(x86_xSetOp), uint16(x86_LODSB), + /*10188*/ uint16(x86_xMatch), + /*10189*/ uint16(x86_xCondIs64), 10192, 10202, + /*10192*/ uint16(x86_xCondDataSize), 10196, 10199, 0, + /*10196*/ uint16(x86_xSetOp), uint16(x86_LODSW), + /*10198*/ uint16(x86_xMatch), + /*10199*/ uint16(x86_xSetOp), uint16(x86_LODSD), + /*10201*/ uint16(x86_xMatch), + /*10202*/ uint16(x86_xCondDataSize), 10196, 10199, 10206, + /*10206*/ uint16(x86_xSetOp), uint16(x86_LODSQ), + /*10208*/ uint16(x86_xMatch), + /*10209*/ uint16(x86_xSetOp), uint16(x86_SCASB), + /*10211*/ uint16(x86_xMatch), + /*10212*/ uint16(x86_xCondIs64), 10215, 10225, + /*10215*/ uint16(x86_xCondDataSize), 10219, 10222, 0, + /*10219*/ uint16(x86_xSetOp), uint16(x86_SCASW), + /*10221*/ uint16(x86_xMatch), + /*10222*/ uint16(x86_xSetOp), uint16(x86_SCASD), + /*10224*/ uint16(x86_xMatch), + /*10225*/ uint16(x86_xCondDataSize), 10219, 10222, 10229, + /*10229*/ uint16(x86_xSetOp), uint16(x86_SCASQ), + /*10231*/ uint16(x86_xMatch), + /*10232*/ uint16(x86_xSetOp), uint16(x86_MOV), + /*10234*/ uint16(x86_xReadIb), + /*10235*/ uint16(x86_xArgR8op), + /*10236*/ uint16(x86_xArgImm8u), + /*10237*/ uint16(x86_xMatch), + /*10238*/ uint16(x86_xCondIs64), 10241, 10257, + /*10241*/ uint16(x86_xCondDataSize), 10245, 10251, 0, + /*10245*/ uint16(x86_xSetOp), uint16(x86_MOV), + /*10247*/ uint16(x86_xReadIw), + /*10248*/ uint16(x86_xArgR16op), + /*10249*/ uint16(x86_xArgImm16), + /*10250*/ uint16(x86_xMatch), + /*10251*/ uint16(x86_xSetOp), uint16(x86_MOV), + /*10253*/ uint16(x86_xReadId), + /*10254*/ uint16(x86_xArgR32op), + /*10255*/ uint16(x86_xArgImm32), + /*10256*/ uint16(x86_xMatch), + /*10257*/ uint16(x86_xCondDataSize), 10245, 10251, 10261, + /*10261*/ uint16(x86_xSetOp), uint16(x86_MOV), + /*10263*/ uint16(x86_xReadIo), + /*10264*/ uint16(x86_xArgR64op), + /*10265*/ uint16(x86_xArgImm64), + /*10266*/ uint16(x86_xMatch), + /*10267*/ uint16(x86_xCondSlashR), + 10276, // 0 + 10282, // 1 + 10288, // 2 + 10294, // 3 + 10300, // 4 + 10306, // 5 + 0, // 6 + 10312, // 7 + /*10276*/ uint16(x86_xSetOp), uint16(x86_ROL), + /*10278*/ uint16(x86_xReadIb), + /*10279*/ uint16(x86_xArgRM8), + /*10280*/ uint16(x86_xArgImm8u), + /*10281*/ uint16(x86_xMatch), + /*10282*/ uint16(x86_xSetOp), uint16(x86_ROR), + /*10284*/ uint16(x86_xReadIb), + /*10285*/ uint16(x86_xArgRM8), + /*10286*/ uint16(x86_xArgImm8u), + /*10287*/ uint16(x86_xMatch), + /*10288*/ uint16(x86_xSetOp), uint16(x86_RCL), + /*10290*/ uint16(x86_xReadIb), + /*10291*/ uint16(x86_xArgRM8), + /*10292*/ uint16(x86_xArgImm8u), + /*10293*/ uint16(x86_xMatch), + /*10294*/ uint16(x86_xSetOp), uint16(x86_RCR), + /*10296*/ uint16(x86_xReadIb), + /*10297*/ uint16(x86_xArgRM8), + /*10298*/ uint16(x86_xArgImm8u), + /*10299*/ uint16(x86_xMatch), + /*10300*/ uint16(x86_xSetOp), uint16(x86_SHL), + /*10302*/ uint16(x86_xReadIb), + /*10303*/ uint16(x86_xArgRM8), + /*10304*/ uint16(x86_xArgImm8u), + /*10305*/ uint16(x86_xMatch), + /*10306*/ uint16(x86_xSetOp), uint16(x86_SHR), + /*10308*/ uint16(x86_xReadIb), + /*10309*/ uint16(x86_xArgRM8), + /*10310*/ uint16(x86_xArgImm8u), + /*10311*/ uint16(x86_xMatch), + /*10312*/ uint16(x86_xSetOp), uint16(x86_SAR), + /*10314*/ uint16(x86_xReadIb), + /*10315*/ uint16(x86_xArgRM8), + /*10316*/ uint16(x86_xArgImm8u), + /*10317*/ uint16(x86_xMatch), + /*10318*/ uint16(x86_xCondSlashR), + 10327, // 0 + 10349, // 1 + 10371, // 2 + 10400, // 3 + 10429, // 4 + 10458, // 5 + 0, // 6 + 10487, // 7 + /*10327*/ uint16(x86_xCondDataSize), 10331, 10337, 10343, + /*10331*/ uint16(x86_xSetOp), uint16(x86_ROL), + /*10333*/ uint16(x86_xReadIb), + /*10334*/ uint16(x86_xArgRM16), + /*10335*/ uint16(x86_xArgImm8u), + /*10336*/ uint16(x86_xMatch), + /*10337*/ uint16(x86_xSetOp), uint16(x86_ROL), + /*10339*/ uint16(x86_xReadIb), + /*10340*/ uint16(x86_xArgRM32), + /*10341*/ uint16(x86_xArgImm8u), + /*10342*/ uint16(x86_xMatch), + /*10343*/ uint16(x86_xSetOp), uint16(x86_ROL), + /*10345*/ uint16(x86_xReadIb), + /*10346*/ uint16(x86_xArgRM64), + /*10347*/ uint16(x86_xArgImm8u), + /*10348*/ uint16(x86_xMatch), + /*10349*/ uint16(x86_xCondDataSize), 10353, 10359, 10365, + /*10353*/ uint16(x86_xSetOp), uint16(x86_ROR), + /*10355*/ uint16(x86_xReadIb), + /*10356*/ uint16(x86_xArgRM16), + /*10357*/ uint16(x86_xArgImm8u), + /*10358*/ uint16(x86_xMatch), + /*10359*/ uint16(x86_xSetOp), uint16(x86_ROR), + /*10361*/ uint16(x86_xReadIb), + /*10362*/ uint16(x86_xArgRM32), + /*10363*/ uint16(x86_xArgImm8u), + /*10364*/ uint16(x86_xMatch), + /*10365*/ uint16(x86_xSetOp), uint16(x86_ROR), + /*10367*/ uint16(x86_xReadIb), + /*10368*/ uint16(x86_xArgRM64), + /*10369*/ uint16(x86_xArgImm8u), + /*10370*/ uint16(x86_xMatch), + /*10371*/ uint16(x86_xCondIs64), 10374, 10390, + /*10374*/ uint16(x86_xCondDataSize), 10378, 10384, 0, + /*10378*/ uint16(x86_xSetOp), uint16(x86_RCL), + /*10380*/ uint16(x86_xReadIb), + /*10381*/ uint16(x86_xArgRM16), + /*10382*/ uint16(x86_xArgImm8u), + /*10383*/ uint16(x86_xMatch), + /*10384*/ uint16(x86_xSetOp), uint16(x86_RCL), + /*10386*/ uint16(x86_xReadIb), + /*10387*/ uint16(x86_xArgRM32), + /*10388*/ uint16(x86_xArgImm8u), + /*10389*/ uint16(x86_xMatch), + /*10390*/ uint16(x86_xCondDataSize), 10378, 10384, 10394, + /*10394*/ uint16(x86_xSetOp), uint16(x86_RCL), + /*10396*/ uint16(x86_xReadIb), + /*10397*/ uint16(x86_xArgRM64), + /*10398*/ uint16(x86_xArgImm8u), + /*10399*/ uint16(x86_xMatch), + /*10400*/ uint16(x86_xCondIs64), 10403, 10419, + /*10403*/ uint16(x86_xCondDataSize), 10407, 10413, 0, + /*10407*/ uint16(x86_xSetOp), uint16(x86_RCR), + /*10409*/ uint16(x86_xReadIb), + /*10410*/ uint16(x86_xArgRM16), + /*10411*/ uint16(x86_xArgImm8u), + /*10412*/ uint16(x86_xMatch), + /*10413*/ uint16(x86_xSetOp), uint16(x86_RCR), + /*10415*/ uint16(x86_xReadIb), + /*10416*/ uint16(x86_xArgRM32), + /*10417*/ uint16(x86_xArgImm8u), + /*10418*/ uint16(x86_xMatch), + /*10419*/ uint16(x86_xCondDataSize), 10407, 10413, 10423, + /*10423*/ uint16(x86_xSetOp), uint16(x86_RCR), + /*10425*/ uint16(x86_xReadIb), + /*10426*/ uint16(x86_xArgRM64), + /*10427*/ uint16(x86_xArgImm8u), + /*10428*/ uint16(x86_xMatch), + /*10429*/ uint16(x86_xCondIs64), 10432, 10448, + /*10432*/ uint16(x86_xCondDataSize), 10436, 10442, 0, + /*10436*/ uint16(x86_xSetOp), uint16(x86_SHL), + /*10438*/ uint16(x86_xReadIb), + /*10439*/ uint16(x86_xArgRM16), + /*10440*/ uint16(x86_xArgImm8u), + /*10441*/ uint16(x86_xMatch), + /*10442*/ uint16(x86_xSetOp), uint16(x86_SHL), + /*10444*/ uint16(x86_xReadIb), + /*10445*/ uint16(x86_xArgRM32), + /*10446*/ uint16(x86_xArgImm8u), + /*10447*/ uint16(x86_xMatch), + /*10448*/ uint16(x86_xCondDataSize), 10436, 10442, 10452, + /*10452*/ uint16(x86_xSetOp), uint16(x86_SHL), + /*10454*/ uint16(x86_xReadIb), + /*10455*/ uint16(x86_xArgRM64), + /*10456*/ uint16(x86_xArgImm8u), + /*10457*/ uint16(x86_xMatch), + /*10458*/ uint16(x86_xCondIs64), 10461, 10477, + /*10461*/ uint16(x86_xCondDataSize), 10465, 10471, 0, + /*10465*/ uint16(x86_xSetOp), uint16(x86_SHR), + /*10467*/ uint16(x86_xReadIb), + /*10468*/ uint16(x86_xArgRM16), + /*10469*/ uint16(x86_xArgImm8u), + /*10470*/ uint16(x86_xMatch), + /*10471*/ uint16(x86_xSetOp), uint16(x86_SHR), + /*10473*/ uint16(x86_xReadIb), + /*10474*/ uint16(x86_xArgRM32), + /*10475*/ uint16(x86_xArgImm8u), + /*10476*/ uint16(x86_xMatch), + /*10477*/ uint16(x86_xCondDataSize), 10465, 10471, 10481, + /*10481*/ uint16(x86_xSetOp), uint16(x86_SHR), + /*10483*/ uint16(x86_xReadIb), + /*10484*/ uint16(x86_xArgRM64), + /*10485*/ uint16(x86_xArgImm8u), + /*10486*/ uint16(x86_xMatch), + /*10487*/ uint16(x86_xCondIs64), 10490, 10506, + /*10490*/ uint16(x86_xCondDataSize), 10494, 10500, 0, + /*10494*/ uint16(x86_xSetOp), uint16(x86_SAR), + /*10496*/ uint16(x86_xReadIb), + /*10497*/ uint16(x86_xArgRM16), + /*10498*/ uint16(x86_xArgImm8u), + /*10499*/ uint16(x86_xMatch), + /*10500*/ uint16(x86_xSetOp), uint16(x86_SAR), + /*10502*/ uint16(x86_xReadIb), + /*10503*/ uint16(x86_xArgRM32), + /*10504*/ uint16(x86_xArgImm8u), + /*10505*/ uint16(x86_xMatch), + /*10506*/ uint16(x86_xCondDataSize), 10494, 10500, 10510, + /*10510*/ uint16(x86_xSetOp), uint16(x86_SAR), + /*10512*/ uint16(x86_xReadIb), + /*10513*/ uint16(x86_xArgRM64), + /*10514*/ uint16(x86_xArgImm8u), + /*10515*/ uint16(x86_xMatch), + /*10516*/ uint16(x86_xSetOp), uint16(x86_RET), + /*10518*/ uint16(x86_xReadIw), + /*10519*/ uint16(x86_xArgImm16u), + /*10520*/ uint16(x86_xMatch), + /*10521*/ uint16(x86_xSetOp), uint16(x86_RET), + /*10523*/ uint16(x86_xMatch), + /*10524*/ uint16(x86_xCondIs64), 10527, 0, + /*10527*/ uint16(x86_xCondDataSize), 10531, 10537, 0, + /*10531*/ uint16(x86_xSetOp), uint16(x86_LES), + /*10533*/ uint16(x86_xReadSlashR), + /*10534*/ uint16(x86_xArgR16), + /*10535*/ uint16(x86_xArgM16colon16), + /*10536*/ uint16(x86_xMatch), + /*10537*/ uint16(x86_xSetOp), uint16(x86_LES), + /*10539*/ uint16(x86_xReadSlashR), + /*10540*/ uint16(x86_xArgR32), + /*10541*/ uint16(x86_xArgM16colon32), + /*10542*/ uint16(x86_xMatch), + /*10543*/ uint16(x86_xCondIs64), 10546, 0, + /*10546*/ uint16(x86_xCondDataSize), 10550, 10556, 0, + /*10550*/ uint16(x86_xSetOp), uint16(x86_LDS), + /*10552*/ uint16(x86_xReadSlashR), + /*10553*/ uint16(x86_xArgR16), + /*10554*/ uint16(x86_xArgM16colon16), + /*10555*/ uint16(x86_xMatch), + /*10556*/ uint16(x86_xSetOp), uint16(x86_LDS), + /*10558*/ uint16(x86_xReadSlashR), + /*10559*/ uint16(x86_xArgR32), + /*10560*/ uint16(x86_xArgM16colon32), + /*10561*/ uint16(x86_xMatch), + /*10562*/ uint16(x86_xCondByte), 1, + 0xF8, 10581, + /*10566*/ uint16(x86_xCondSlashR), + 10575, // 0 + 0, // 1 + 0, // 2 + 0, // 3 + 0, // 4 + 0, // 5 + 0, // 6 + 0, // 7 + /*10575*/ uint16(x86_xSetOp), uint16(x86_MOV), + /*10577*/ uint16(x86_xReadIb), + /*10578*/ uint16(x86_xArgRM8), + /*10579*/ uint16(x86_xArgImm8u), + /*10580*/ uint16(x86_xMatch), + /*10581*/ uint16(x86_xSetOp), uint16(x86_XABORT), + /*10583*/ uint16(x86_xReadIb), + /*10584*/ uint16(x86_xArgImm8u), + /*10585*/ uint16(x86_xMatch), + /*10586*/ uint16(x86_xCondByte), 1, + 0xF8, 10628, + /*10590*/ uint16(x86_xCondSlashR), + 10599, // 0 + 0, // 1 + 0, // 2 + 0, // 3 + 0, // 4 + 0, // 5 + 0, // 6 + 0, // 7 + /*10599*/ uint16(x86_xCondIs64), 10602, 10618, + /*10602*/ uint16(x86_xCondDataSize), 10606, 10612, 0, + /*10606*/ uint16(x86_xSetOp), uint16(x86_MOV), + /*10608*/ uint16(x86_xReadIw), + /*10609*/ uint16(x86_xArgRM16), + /*10610*/ uint16(x86_xArgImm16), + /*10611*/ uint16(x86_xMatch), + /*10612*/ uint16(x86_xSetOp), uint16(x86_MOV), + /*10614*/ uint16(x86_xReadId), + /*10615*/ uint16(x86_xArgRM32), + /*10616*/ uint16(x86_xArgImm32), + /*10617*/ uint16(x86_xMatch), + /*10618*/ uint16(x86_xCondDataSize), 10606, 10612, 10622, + /*10622*/ uint16(x86_xSetOp), uint16(x86_MOV), + /*10624*/ uint16(x86_xReadId), + /*10625*/ uint16(x86_xArgRM64), + /*10626*/ uint16(x86_xArgImm32), + /*10627*/ uint16(x86_xMatch), + /*10628*/ uint16(x86_xCondDataSize), 10632, 10637, 10642, + /*10632*/ uint16(x86_xSetOp), uint16(x86_XBEGIN), + /*10634*/ uint16(x86_xReadCw), + /*10635*/ uint16(x86_xArgRel16), + /*10636*/ uint16(x86_xMatch), + /*10637*/ uint16(x86_xSetOp), uint16(x86_XBEGIN), + /*10639*/ uint16(x86_xReadCd), + /*10640*/ uint16(x86_xArgRel32), + /*10641*/ uint16(x86_xMatch), + /*10642*/ uint16(x86_xSetOp), uint16(x86_XBEGIN), + /*10644*/ uint16(x86_xReadCd), + /*10645*/ uint16(x86_xArgRel32), + /*10646*/ uint16(x86_xMatch), + /*10647*/ uint16(x86_xSetOp), uint16(x86_ENTER), + /*10649*/ uint16(x86_xReadIw), + /*10650*/ uint16(x86_xReadIb), + /*10651*/ uint16(x86_xArgImm16u), + /*10652*/ uint16(x86_xArgImm8u), + /*10653*/ uint16(x86_xMatch), + /*10654*/ uint16(x86_xCondIs64), 10657, 10667, + /*10657*/ uint16(x86_xCondDataSize), 10661, 10664, 0, + /*10661*/ uint16(x86_xSetOp), uint16(x86_LEAVE), + /*10663*/ uint16(x86_xMatch), + /*10664*/ uint16(x86_xSetOp), uint16(x86_LEAVE), + /*10666*/ uint16(x86_xMatch), + /*10667*/ uint16(x86_xCondDataSize), 10661, 10671, 10674, + /*10671*/ uint16(x86_xSetOp), uint16(x86_LEAVE), + /*10673*/ uint16(x86_xMatch), + /*10674*/ uint16(x86_xSetOp), uint16(x86_LEAVE), + /*10676*/ uint16(x86_xMatch), + /*10677*/ uint16(x86_xSetOp), uint16(x86_LRET), + /*10679*/ uint16(x86_xReadIw), + /*10680*/ uint16(x86_xArgImm16u), + /*10681*/ uint16(x86_xMatch), + /*10682*/ uint16(x86_xSetOp), uint16(x86_LRET), + /*10684*/ uint16(x86_xMatch), + /*10685*/ uint16(x86_xSetOp), uint16(x86_INT), + /*10687*/ uint16(x86_xArg3), + /*10688*/ uint16(x86_xMatch), + /*10689*/ uint16(x86_xSetOp), uint16(x86_INT), + /*10691*/ uint16(x86_xReadIb), + /*10692*/ uint16(x86_xArgImm8u), + /*10693*/ uint16(x86_xMatch), + /*10694*/ uint16(x86_xCondIs64), 10697, 0, + /*10697*/ uint16(x86_xSetOp), uint16(x86_INTO), + /*10699*/ uint16(x86_xMatch), + /*10700*/ uint16(x86_xCondIs64), 10703, 10713, + /*10703*/ uint16(x86_xCondDataSize), 10707, 10710, 0, + /*10707*/ uint16(x86_xSetOp), uint16(x86_IRET), + /*10709*/ uint16(x86_xMatch), + /*10710*/ uint16(x86_xSetOp), uint16(x86_IRETD), + /*10712*/ uint16(x86_xMatch), + /*10713*/ uint16(x86_xCondDataSize), 10707, 10710, 10717, + /*10717*/ uint16(x86_xSetOp), uint16(x86_IRETQ), + /*10719*/ uint16(x86_xMatch), + /*10720*/ uint16(x86_xCondSlashR), + 10729, // 0 + 10734, // 1 + 10739, // 2 + 10744, // 3 + 10749, // 4 + 10754, // 5 + 0, // 6 + 10759, // 7 + /*10729*/ uint16(x86_xSetOp), uint16(x86_ROL), + /*10731*/ uint16(x86_xArgRM8), + /*10732*/ uint16(x86_xArg1), + /*10733*/ uint16(x86_xMatch), + /*10734*/ uint16(x86_xSetOp), uint16(x86_ROR), + /*10736*/ uint16(x86_xArgRM8), + /*10737*/ uint16(x86_xArg1), + /*10738*/ uint16(x86_xMatch), + /*10739*/ uint16(x86_xSetOp), uint16(x86_RCL), + /*10741*/ uint16(x86_xArgRM8), + /*10742*/ uint16(x86_xArg1), + /*10743*/ uint16(x86_xMatch), + /*10744*/ uint16(x86_xSetOp), uint16(x86_RCR), + /*10746*/ uint16(x86_xArgRM8), + /*10747*/ uint16(x86_xArg1), + /*10748*/ uint16(x86_xMatch), + /*10749*/ uint16(x86_xSetOp), uint16(x86_SHL), + /*10751*/ uint16(x86_xArgRM8), + /*10752*/ uint16(x86_xArg1), + /*10753*/ uint16(x86_xMatch), + /*10754*/ uint16(x86_xSetOp), uint16(x86_SHR), + /*10756*/ uint16(x86_xArgRM8), + /*10757*/ uint16(x86_xArg1), + /*10758*/ uint16(x86_xMatch), + /*10759*/ uint16(x86_xSetOp), uint16(x86_SAR), + /*10761*/ uint16(x86_xArgRM8), + /*10762*/ uint16(x86_xArg1), + /*10763*/ uint16(x86_xMatch), + /*10764*/ uint16(x86_xCondSlashR), + 10773, // 0 + 10799, // 1 + 10825, // 2 + 10851, // 3 + 10877, // 4 + 10903, // 5 + 0, // 6 + 10929, // 7 + /*10773*/ uint16(x86_xCondIs64), 10776, 10790, + /*10776*/ uint16(x86_xCondDataSize), 10780, 10785, 0, + /*10780*/ uint16(x86_xSetOp), uint16(x86_ROL), + /*10782*/ uint16(x86_xArgRM16), + /*10783*/ uint16(x86_xArg1), + /*10784*/ uint16(x86_xMatch), + /*10785*/ uint16(x86_xSetOp), uint16(x86_ROL), + /*10787*/ uint16(x86_xArgRM32), + /*10788*/ uint16(x86_xArg1), + /*10789*/ uint16(x86_xMatch), + /*10790*/ uint16(x86_xCondDataSize), 10780, 10785, 10794, + /*10794*/ uint16(x86_xSetOp), uint16(x86_ROL), + /*10796*/ uint16(x86_xArgRM64), + /*10797*/ uint16(x86_xArg1), + /*10798*/ uint16(x86_xMatch), + /*10799*/ uint16(x86_xCondIs64), 10802, 10816, + /*10802*/ uint16(x86_xCondDataSize), 10806, 10811, 0, + /*10806*/ uint16(x86_xSetOp), uint16(x86_ROR), + /*10808*/ uint16(x86_xArgRM16), + /*10809*/ uint16(x86_xArg1), + /*10810*/ uint16(x86_xMatch), + /*10811*/ uint16(x86_xSetOp), uint16(x86_ROR), + /*10813*/ uint16(x86_xArgRM32), + /*10814*/ uint16(x86_xArg1), + /*10815*/ uint16(x86_xMatch), + /*10816*/ uint16(x86_xCondDataSize), 10806, 10811, 10820, + /*10820*/ uint16(x86_xSetOp), uint16(x86_ROR), + /*10822*/ uint16(x86_xArgRM64), + /*10823*/ uint16(x86_xArg1), + /*10824*/ uint16(x86_xMatch), + /*10825*/ uint16(x86_xCondIs64), 10828, 10842, + /*10828*/ uint16(x86_xCondDataSize), 10832, 10837, 0, + /*10832*/ uint16(x86_xSetOp), uint16(x86_RCL), + /*10834*/ uint16(x86_xArgRM16), + /*10835*/ uint16(x86_xArg1), + /*10836*/ uint16(x86_xMatch), + /*10837*/ uint16(x86_xSetOp), uint16(x86_RCL), + /*10839*/ uint16(x86_xArgRM32), + /*10840*/ uint16(x86_xArg1), + /*10841*/ uint16(x86_xMatch), + /*10842*/ uint16(x86_xCondDataSize), 10832, 10837, 10846, + /*10846*/ uint16(x86_xSetOp), uint16(x86_RCL), + /*10848*/ uint16(x86_xArgRM64), + /*10849*/ uint16(x86_xArg1), + /*10850*/ uint16(x86_xMatch), + /*10851*/ uint16(x86_xCondIs64), 10854, 10868, + /*10854*/ uint16(x86_xCondDataSize), 10858, 10863, 0, + /*10858*/ uint16(x86_xSetOp), uint16(x86_RCR), + /*10860*/ uint16(x86_xArgRM16), + /*10861*/ uint16(x86_xArg1), + /*10862*/ uint16(x86_xMatch), + /*10863*/ uint16(x86_xSetOp), uint16(x86_RCR), + /*10865*/ uint16(x86_xArgRM32), + /*10866*/ uint16(x86_xArg1), + /*10867*/ uint16(x86_xMatch), + /*10868*/ uint16(x86_xCondDataSize), 10858, 10863, 10872, + /*10872*/ uint16(x86_xSetOp), uint16(x86_RCR), + /*10874*/ uint16(x86_xArgRM64), + /*10875*/ uint16(x86_xArg1), + /*10876*/ uint16(x86_xMatch), + /*10877*/ uint16(x86_xCondIs64), 10880, 10894, + /*10880*/ uint16(x86_xCondDataSize), 10884, 10889, 0, + /*10884*/ uint16(x86_xSetOp), uint16(x86_SHL), + /*10886*/ uint16(x86_xArgRM16), + /*10887*/ uint16(x86_xArg1), + /*10888*/ uint16(x86_xMatch), + /*10889*/ uint16(x86_xSetOp), uint16(x86_SHL), + /*10891*/ uint16(x86_xArgRM32), + /*10892*/ uint16(x86_xArg1), + /*10893*/ uint16(x86_xMatch), + /*10894*/ uint16(x86_xCondDataSize), 10884, 10889, 10898, + /*10898*/ uint16(x86_xSetOp), uint16(x86_SHL), + /*10900*/ uint16(x86_xArgRM64), + /*10901*/ uint16(x86_xArg1), + /*10902*/ uint16(x86_xMatch), + /*10903*/ uint16(x86_xCondIs64), 10906, 10920, + /*10906*/ uint16(x86_xCondDataSize), 10910, 10915, 0, + /*10910*/ uint16(x86_xSetOp), uint16(x86_SHR), + /*10912*/ uint16(x86_xArgRM16), + /*10913*/ uint16(x86_xArg1), + /*10914*/ uint16(x86_xMatch), + /*10915*/ uint16(x86_xSetOp), uint16(x86_SHR), + /*10917*/ uint16(x86_xArgRM32), + /*10918*/ uint16(x86_xArg1), + /*10919*/ uint16(x86_xMatch), + /*10920*/ uint16(x86_xCondDataSize), 10910, 10915, 10924, + /*10924*/ uint16(x86_xSetOp), uint16(x86_SHR), + /*10926*/ uint16(x86_xArgRM64), + /*10927*/ uint16(x86_xArg1), + /*10928*/ uint16(x86_xMatch), + /*10929*/ uint16(x86_xCondIs64), 10932, 10946, + /*10932*/ uint16(x86_xCondDataSize), 10936, 10941, 0, + /*10936*/ uint16(x86_xSetOp), uint16(x86_SAR), + /*10938*/ uint16(x86_xArgRM16), + /*10939*/ uint16(x86_xArg1), + /*10940*/ uint16(x86_xMatch), + /*10941*/ uint16(x86_xSetOp), uint16(x86_SAR), + /*10943*/ uint16(x86_xArgRM32), + /*10944*/ uint16(x86_xArg1), + /*10945*/ uint16(x86_xMatch), + /*10946*/ uint16(x86_xCondDataSize), 10936, 10941, 10950, + /*10950*/ uint16(x86_xSetOp), uint16(x86_SAR), + /*10952*/ uint16(x86_xArgRM64), + /*10953*/ uint16(x86_xArg1), + /*10954*/ uint16(x86_xMatch), + /*10955*/ uint16(x86_xCondSlashR), + 10964, // 0 + 10969, // 1 + 10974, // 2 + 10979, // 3 + 10984, // 4 + 10989, // 5 + 0, // 6 + 10994, // 7 + /*10964*/ uint16(x86_xSetOp), uint16(x86_ROL), + /*10966*/ uint16(x86_xArgRM8), + /*10967*/ uint16(x86_xArgCL), + /*10968*/ uint16(x86_xMatch), + /*10969*/ uint16(x86_xSetOp), uint16(x86_ROR), + /*10971*/ uint16(x86_xArgRM8), + /*10972*/ uint16(x86_xArgCL), + /*10973*/ uint16(x86_xMatch), + /*10974*/ uint16(x86_xSetOp), uint16(x86_RCL), + /*10976*/ uint16(x86_xArgRM8), + /*10977*/ uint16(x86_xArgCL), + /*10978*/ uint16(x86_xMatch), + /*10979*/ uint16(x86_xSetOp), uint16(x86_RCR), + /*10981*/ uint16(x86_xArgRM8), + /*10982*/ uint16(x86_xArgCL), + /*10983*/ uint16(x86_xMatch), + /*10984*/ uint16(x86_xSetOp), uint16(x86_SHL), + /*10986*/ uint16(x86_xArgRM8), + /*10987*/ uint16(x86_xArgCL), + /*10988*/ uint16(x86_xMatch), + /*10989*/ uint16(x86_xSetOp), uint16(x86_SHR), + /*10991*/ uint16(x86_xArgRM8), + /*10992*/ uint16(x86_xArgCL), + /*10993*/ uint16(x86_xMatch), + /*10994*/ uint16(x86_xSetOp), uint16(x86_SAR), + /*10996*/ uint16(x86_xArgRM8), + /*10997*/ uint16(x86_xArgCL), + /*10998*/ uint16(x86_xMatch), + /*10999*/ uint16(x86_xCondSlashR), + 11008, // 0 + 11034, // 1 + 11060, // 2 + 11086, // 3 + 11112, // 4 + 11138, // 5 + 0, // 6 + 11164, // 7 + /*11008*/ uint16(x86_xCondIs64), 11011, 11025, + /*11011*/ uint16(x86_xCondDataSize), 11015, 11020, 0, + /*11015*/ uint16(x86_xSetOp), uint16(x86_ROL), + /*11017*/ uint16(x86_xArgRM16), + /*11018*/ uint16(x86_xArgCL), + /*11019*/ uint16(x86_xMatch), + /*11020*/ uint16(x86_xSetOp), uint16(x86_ROL), + /*11022*/ uint16(x86_xArgRM32), + /*11023*/ uint16(x86_xArgCL), + /*11024*/ uint16(x86_xMatch), + /*11025*/ uint16(x86_xCondDataSize), 11015, 11020, 11029, + /*11029*/ uint16(x86_xSetOp), uint16(x86_ROL), + /*11031*/ uint16(x86_xArgRM64), + /*11032*/ uint16(x86_xArgCL), + /*11033*/ uint16(x86_xMatch), + /*11034*/ uint16(x86_xCondIs64), 11037, 11051, + /*11037*/ uint16(x86_xCondDataSize), 11041, 11046, 0, + /*11041*/ uint16(x86_xSetOp), uint16(x86_ROR), + /*11043*/ uint16(x86_xArgRM16), + /*11044*/ uint16(x86_xArgCL), + /*11045*/ uint16(x86_xMatch), + /*11046*/ uint16(x86_xSetOp), uint16(x86_ROR), + /*11048*/ uint16(x86_xArgRM32), + /*11049*/ uint16(x86_xArgCL), + /*11050*/ uint16(x86_xMatch), + /*11051*/ uint16(x86_xCondDataSize), 11041, 11046, 11055, + /*11055*/ uint16(x86_xSetOp), uint16(x86_ROR), + /*11057*/ uint16(x86_xArgRM64), + /*11058*/ uint16(x86_xArgCL), + /*11059*/ uint16(x86_xMatch), + /*11060*/ uint16(x86_xCondIs64), 11063, 11077, + /*11063*/ uint16(x86_xCondDataSize), 11067, 11072, 0, + /*11067*/ uint16(x86_xSetOp), uint16(x86_RCL), + /*11069*/ uint16(x86_xArgRM16), + /*11070*/ uint16(x86_xArgCL), + /*11071*/ uint16(x86_xMatch), + /*11072*/ uint16(x86_xSetOp), uint16(x86_RCL), + /*11074*/ uint16(x86_xArgRM32), + /*11075*/ uint16(x86_xArgCL), + /*11076*/ uint16(x86_xMatch), + /*11077*/ uint16(x86_xCondDataSize), 11067, 11072, 11081, + /*11081*/ uint16(x86_xSetOp), uint16(x86_RCL), + /*11083*/ uint16(x86_xArgRM64), + /*11084*/ uint16(x86_xArgCL), + /*11085*/ uint16(x86_xMatch), + /*11086*/ uint16(x86_xCondIs64), 11089, 11103, + /*11089*/ uint16(x86_xCondDataSize), 11093, 11098, 0, + /*11093*/ uint16(x86_xSetOp), uint16(x86_RCR), + /*11095*/ uint16(x86_xArgRM16), + /*11096*/ uint16(x86_xArgCL), + /*11097*/ uint16(x86_xMatch), + /*11098*/ uint16(x86_xSetOp), uint16(x86_RCR), + /*11100*/ uint16(x86_xArgRM32), + /*11101*/ uint16(x86_xArgCL), + /*11102*/ uint16(x86_xMatch), + /*11103*/ uint16(x86_xCondDataSize), 11093, 11098, 11107, + /*11107*/ uint16(x86_xSetOp), uint16(x86_RCR), + /*11109*/ uint16(x86_xArgRM64), + /*11110*/ uint16(x86_xArgCL), + /*11111*/ uint16(x86_xMatch), + /*11112*/ uint16(x86_xCondIs64), 11115, 11129, + /*11115*/ uint16(x86_xCondDataSize), 11119, 11124, 0, + /*11119*/ uint16(x86_xSetOp), uint16(x86_SHL), + /*11121*/ uint16(x86_xArgRM16), + /*11122*/ uint16(x86_xArgCL), + /*11123*/ uint16(x86_xMatch), + /*11124*/ uint16(x86_xSetOp), uint16(x86_SHL), + /*11126*/ uint16(x86_xArgRM32), + /*11127*/ uint16(x86_xArgCL), + /*11128*/ uint16(x86_xMatch), + /*11129*/ uint16(x86_xCondDataSize), 11119, 11124, 11133, + /*11133*/ uint16(x86_xSetOp), uint16(x86_SHL), + /*11135*/ uint16(x86_xArgRM64), + /*11136*/ uint16(x86_xArgCL), + /*11137*/ uint16(x86_xMatch), + /*11138*/ uint16(x86_xCondIs64), 11141, 11155, + /*11141*/ uint16(x86_xCondDataSize), 11145, 11150, 0, + /*11145*/ uint16(x86_xSetOp), uint16(x86_SHR), + /*11147*/ uint16(x86_xArgRM16), + /*11148*/ uint16(x86_xArgCL), + /*11149*/ uint16(x86_xMatch), + /*11150*/ uint16(x86_xSetOp), uint16(x86_SHR), + /*11152*/ uint16(x86_xArgRM32), + /*11153*/ uint16(x86_xArgCL), + /*11154*/ uint16(x86_xMatch), + /*11155*/ uint16(x86_xCondDataSize), 11145, 11150, 11159, + /*11159*/ uint16(x86_xSetOp), uint16(x86_SHR), + /*11161*/ uint16(x86_xArgRM64), + /*11162*/ uint16(x86_xArgCL), + /*11163*/ uint16(x86_xMatch), + /*11164*/ uint16(x86_xCondIs64), 11167, 11181, + /*11167*/ uint16(x86_xCondDataSize), 11171, 11176, 0, + /*11171*/ uint16(x86_xSetOp), uint16(x86_SAR), + /*11173*/ uint16(x86_xArgRM16), + /*11174*/ uint16(x86_xArgCL), + /*11175*/ uint16(x86_xMatch), + /*11176*/ uint16(x86_xSetOp), uint16(x86_SAR), + /*11178*/ uint16(x86_xArgRM32), + /*11179*/ uint16(x86_xArgCL), + /*11180*/ uint16(x86_xMatch), + /*11181*/ uint16(x86_xCondDataSize), 11171, 11176, 11185, + /*11185*/ uint16(x86_xSetOp), uint16(x86_SAR), + /*11187*/ uint16(x86_xArgRM64), + /*11188*/ uint16(x86_xArgCL), + /*11189*/ uint16(x86_xMatch), + /*11190*/ uint16(x86_xCondIs64), 11193, 0, + /*11193*/ uint16(x86_xSetOp), uint16(x86_AAM), + /*11195*/ uint16(x86_xReadIb), + /*11196*/ uint16(x86_xArgImm8u), + /*11197*/ uint16(x86_xMatch), + /*11198*/ uint16(x86_xCondIs64), 11201, 0, + /*11201*/ uint16(x86_xSetOp), uint16(x86_AAD), + /*11203*/ uint16(x86_xReadIb), + /*11204*/ uint16(x86_xArgImm8u), + /*11205*/ uint16(x86_xMatch), + /*11206*/ uint16(x86_xCondIs64), 11209, 11212, + /*11209*/ uint16(x86_xSetOp), uint16(x86_XLATB), + /*11211*/ uint16(x86_xMatch), + /*11212*/ uint16(x86_xCondDataSize), 11209, 11209, 11216, + /*11216*/ uint16(x86_xSetOp), uint16(x86_XLATB), + /*11218*/ uint16(x86_xMatch), + /*11219*/ uint16(x86_xCondByte), 64, + 0xc0, 11390, + 0xc1, 11390, + 0xc2, 11390, + 0xc3, 11390, + 0xc4, 11390, + 0xc5, 11390, + 0xc6, 11390, + 0xc7, 11390, + 0xc8, 11395, + 0xc9, 11395, + 0xca, 11395, + 0xcb, 11395, + 0xcc, 11395, + 0xcd, 11395, + 0xce, 11395, + 0xcf, 11395, + 0xd0, 11400, + 0xd1, 11400, + 0xd2, 11400, + 0xd3, 11400, + 0xd4, 11400, + 0xd5, 11400, + 0xd6, 11400, + 0xd7, 11400, + 0xd8, 11404, + 0xd9, 11404, + 0xda, 11404, + 0xdb, 11404, + 0xdc, 11404, + 0xdd, 11404, + 0xde, 11404, + 0xdf, 11404, + 0xe0, 11408, + 0xe1, 11408, + 0xe2, 11408, + 0xe3, 11408, + 0xe4, 11408, + 0xe5, 11408, + 0xe6, 11408, + 0xe7, 11408, + 0xe8, 11413, + 0xe9, 11413, + 0xea, 11413, + 0xeb, 11413, + 0xec, 11413, + 0xed, 11413, + 0xee, 11413, + 0xef, 11413, + 0xf0, 11418, + 0xf1, 11418, + 0xf2, 11418, + 0xf3, 11418, + 0xf4, 11418, + 0xf5, 11418, + 0xf6, 11418, + 0xf7, 11418, + 0xf8, 11423, + 0xf9, 11423, + 0xfa, 11423, + 0xfb, 11423, + 0xfc, 11423, + 0xfd, 11423, + 0xfe, 11423, + 0xff, 11423, + /*11349*/ uint16(x86_xCondSlashR), + 11358, // 0 + 11362, // 1 + 11366, // 2 + 11370, // 3 + 11374, // 4 + 11378, // 5 + 11382, // 6 + 11386, // 7 + /*11358*/ uint16(x86_xSetOp), uint16(x86_FADD), + /*11360*/ uint16(x86_xArgM32fp), + /*11361*/ uint16(x86_xMatch), + /*11362*/ uint16(x86_xSetOp), uint16(x86_FMUL), + /*11364*/ uint16(x86_xArgM32fp), + /*11365*/ uint16(x86_xMatch), + /*11366*/ uint16(x86_xSetOp), uint16(x86_FCOM), + /*11368*/ uint16(x86_xArgM32fp), + /*11369*/ uint16(x86_xMatch), + /*11370*/ uint16(x86_xSetOp), uint16(x86_FCOMP), + /*11372*/ uint16(x86_xArgM32fp), + /*11373*/ uint16(x86_xMatch), + /*11374*/ uint16(x86_xSetOp), uint16(x86_FSUB), + /*11376*/ uint16(x86_xArgM32fp), + /*11377*/ uint16(x86_xMatch), + /*11378*/ uint16(x86_xSetOp), uint16(x86_FSUBR), + /*11380*/ uint16(x86_xArgM32fp), + /*11381*/ uint16(x86_xMatch), + /*11382*/ uint16(x86_xSetOp), uint16(x86_FDIV), + /*11384*/ uint16(x86_xArgM32fp), + /*11385*/ uint16(x86_xMatch), + /*11386*/ uint16(x86_xSetOp), uint16(x86_FDIVR), + /*11388*/ uint16(x86_xArgM32fp), + /*11389*/ uint16(x86_xMatch), + /*11390*/ uint16(x86_xSetOp), uint16(x86_FADD), + /*11392*/ uint16(x86_xArgST), + /*11393*/ uint16(x86_xArgSTi), + /*11394*/ uint16(x86_xMatch), + /*11395*/ uint16(x86_xSetOp), uint16(x86_FMUL), + /*11397*/ uint16(x86_xArgST), + /*11398*/ uint16(x86_xArgSTi), + /*11399*/ uint16(x86_xMatch), + /*11400*/ uint16(x86_xSetOp), uint16(x86_FCOM), + /*11402*/ uint16(x86_xArgSTi), + /*11403*/ uint16(x86_xMatch), + /*11404*/ uint16(x86_xSetOp), uint16(x86_FCOMP), + /*11406*/ uint16(x86_xArgSTi), + /*11407*/ uint16(x86_xMatch), + /*11408*/ uint16(x86_xSetOp), uint16(x86_FSUB), + /*11410*/ uint16(x86_xArgST), + /*11411*/ uint16(x86_xArgSTi), + /*11412*/ uint16(x86_xMatch), + /*11413*/ uint16(x86_xSetOp), uint16(x86_FSUBR), + /*11415*/ uint16(x86_xArgST), + /*11416*/ uint16(x86_xArgSTi), + /*11417*/ uint16(x86_xMatch), + /*11418*/ uint16(x86_xSetOp), uint16(x86_FDIV), + /*11420*/ uint16(x86_xArgST), + /*11421*/ uint16(x86_xArgSTi), + /*11422*/ uint16(x86_xMatch), + /*11423*/ uint16(x86_xSetOp), uint16(x86_FDIVR), + /*11425*/ uint16(x86_xArgST), + /*11426*/ uint16(x86_xArgSTi), + /*11427*/ uint16(x86_xMatch), + /*11428*/ uint16(x86_xCondByte), 42, + 0xc0, 11551, + 0xc1, 11551, + 0xc2, 11551, + 0xc3, 11551, + 0xc4, 11551, + 0xc5, 11551, + 0xc6, 11551, + 0xc7, 11551, + 0xc8, 11555, + 0xc9, 11555, + 0xca, 11555, + 0xcb, 11555, + 0xcc, 11555, + 0xcd, 11555, + 0xce, 11555, + 0xcf, 11555, + 0xD0, 11559, + 0xE0, 11562, + 0xE1, 11565, + 0xE4, 11568, + 0xE5, 11571, + 0xE8, 11574, + 0xE9, 11577, + 0xEA, 11580, + 0xEB, 11583, + 0xEC, 11586, + 0xF0, 11589, + 0xF1, 11592, + 0xF2, 11595, + 0xF3, 11598, + 0xF4, 11601, + 0xF5, 11604, + 0xF6, 11607, + 0xF7, 11610, + 0xF8, 11613, + 0xF9, 11616, + 0xFA, 11619, + 0xFB, 11622, + 0xFC, 11625, + 0xFD, 11628, + 0xFE, 11631, + 0xFF, 11634, + /*11514*/ uint16(x86_xCondSlashR), + 11523, // 0 + 0, // 1 + 11527, // 2 + 11531, // 3 + 11535, // 4 + 11539, // 5 + 11543, // 6 + 11547, // 7 + /*11523*/ uint16(x86_xSetOp), uint16(x86_FLD), + /*11525*/ uint16(x86_xArgM32fp), + /*11526*/ uint16(x86_xMatch), + /*11527*/ uint16(x86_xSetOp), uint16(x86_FST), + /*11529*/ uint16(x86_xArgM32fp), + /*11530*/ uint16(x86_xMatch), + /*11531*/ uint16(x86_xSetOp), uint16(x86_FSTP), + /*11533*/ uint16(x86_xArgM32fp), + /*11534*/ uint16(x86_xMatch), + /*11535*/ uint16(x86_xSetOp), uint16(x86_FLDENV), + /*11537*/ uint16(x86_xArgM1428byte), + /*11538*/ uint16(x86_xMatch), + /*11539*/ uint16(x86_xSetOp), uint16(x86_FLDCW), + /*11541*/ uint16(x86_xArgM2byte), + /*11542*/ uint16(x86_xMatch), + /*11543*/ uint16(x86_xSetOp), uint16(x86_FNSTENV), + /*11545*/ uint16(x86_xArgM1428byte), + /*11546*/ uint16(x86_xMatch), + /*11547*/ uint16(x86_xSetOp), uint16(x86_FNSTCW), + /*11549*/ uint16(x86_xArgM2byte), + /*11550*/ uint16(x86_xMatch), + /*11551*/ uint16(x86_xSetOp), uint16(x86_FLD), + /*11553*/ uint16(x86_xArgSTi), + /*11554*/ uint16(x86_xMatch), + /*11555*/ uint16(x86_xSetOp), uint16(x86_FXCH), + /*11557*/ uint16(x86_xArgSTi), + /*11558*/ uint16(x86_xMatch), + /*11559*/ uint16(x86_xSetOp), uint16(x86_FNOP), + /*11561*/ uint16(x86_xMatch), + /*11562*/ uint16(x86_xSetOp), uint16(x86_FCHS), + /*11564*/ uint16(x86_xMatch), + /*11565*/ uint16(x86_xSetOp), uint16(x86_FABS), + /*11567*/ uint16(x86_xMatch), + /*11568*/ uint16(x86_xSetOp), uint16(x86_FTST), + /*11570*/ uint16(x86_xMatch), + /*11571*/ uint16(x86_xSetOp), uint16(x86_FXAM), + /*11573*/ uint16(x86_xMatch), + /*11574*/ uint16(x86_xSetOp), uint16(x86_FLD1), + /*11576*/ uint16(x86_xMatch), + /*11577*/ uint16(x86_xSetOp), uint16(x86_FLDL2T), + /*11579*/ uint16(x86_xMatch), + /*11580*/ uint16(x86_xSetOp), uint16(x86_FLDL2E), + /*11582*/ uint16(x86_xMatch), + /*11583*/ uint16(x86_xSetOp), uint16(x86_FLDPI), + /*11585*/ uint16(x86_xMatch), + /*11586*/ uint16(x86_xSetOp), uint16(x86_FLDLG2), + /*11588*/ uint16(x86_xMatch), + /*11589*/ uint16(x86_xSetOp), uint16(x86_F2XM1), + /*11591*/ uint16(x86_xMatch), + /*11592*/ uint16(x86_xSetOp), uint16(x86_FYL2X), + /*11594*/ uint16(x86_xMatch), + /*11595*/ uint16(x86_xSetOp), uint16(x86_FPTAN), + /*11597*/ uint16(x86_xMatch), + /*11598*/ uint16(x86_xSetOp), uint16(x86_FPATAN), + /*11600*/ uint16(x86_xMatch), + /*11601*/ uint16(x86_xSetOp), uint16(x86_FXTRACT), + /*11603*/ uint16(x86_xMatch), + /*11604*/ uint16(x86_xSetOp), uint16(x86_FPREM1), + /*11606*/ uint16(x86_xMatch), + /*11607*/ uint16(x86_xSetOp), uint16(x86_FDECSTP), + /*11609*/ uint16(x86_xMatch), + /*11610*/ uint16(x86_xSetOp), uint16(x86_FINCSTP), + /*11612*/ uint16(x86_xMatch), + /*11613*/ uint16(x86_xSetOp), uint16(x86_FPREM), + /*11615*/ uint16(x86_xMatch), + /*11616*/ uint16(x86_xSetOp), uint16(x86_FYL2XP1), + /*11618*/ uint16(x86_xMatch), + /*11619*/ uint16(x86_xSetOp), uint16(x86_FSQRT), + /*11621*/ uint16(x86_xMatch), + /*11622*/ uint16(x86_xSetOp), uint16(x86_FSINCOS), + /*11624*/ uint16(x86_xMatch), + /*11625*/ uint16(x86_xSetOp), uint16(x86_FRNDINT), + /*11627*/ uint16(x86_xMatch), + /*11628*/ uint16(x86_xSetOp), uint16(x86_FSCALE), + /*11630*/ uint16(x86_xMatch), + /*11631*/ uint16(x86_xSetOp), uint16(x86_FSIN), + /*11633*/ uint16(x86_xMatch), + /*11634*/ uint16(x86_xSetOp), uint16(x86_FCOS), + /*11636*/ uint16(x86_xMatch), + /*11637*/ uint16(x86_xCondByte), 33, + 0xc0, 11746, + 0xc1, 11746, + 0xc2, 11746, + 0xc3, 11746, + 0xc4, 11746, + 0xc5, 11746, + 0xc6, 11746, + 0xc7, 11746, + 0xc8, 11751, + 0xc9, 11751, + 0xca, 11751, + 0xcb, 11751, + 0xcc, 11751, + 0xcd, 11751, + 0xce, 11751, + 0xcf, 11751, + 0xd0, 11756, + 0xd1, 11756, + 0xd2, 11756, + 0xd3, 11756, + 0xd4, 11756, + 0xd5, 11756, + 0xd6, 11756, + 0xd7, 11756, + 0xd8, 11761, + 0xd9, 11761, + 0xda, 11761, + 0xdb, 11761, + 0xdc, 11761, + 0xdd, 11761, + 0xde, 11761, + 0xdf, 11761, + 0xE9, 11766, + /*11705*/ uint16(x86_xCondSlashR), + 11714, // 0 + 11718, // 1 + 11722, // 2 + 11726, // 3 + 11730, // 4 + 11734, // 5 + 11738, // 6 + 11742, // 7 + /*11714*/ uint16(x86_xSetOp), uint16(x86_FIADD), + /*11716*/ uint16(x86_xArgM32int), + /*11717*/ uint16(x86_xMatch), + /*11718*/ uint16(x86_xSetOp), uint16(x86_FIMUL), + /*11720*/ uint16(x86_xArgM32int), + /*11721*/ uint16(x86_xMatch), + /*11722*/ uint16(x86_xSetOp), uint16(x86_FICOM), + /*11724*/ uint16(x86_xArgM32int), + /*11725*/ uint16(x86_xMatch), + /*11726*/ uint16(x86_xSetOp), uint16(x86_FICOMP), + /*11728*/ uint16(x86_xArgM32int), + /*11729*/ uint16(x86_xMatch), + /*11730*/ uint16(x86_xSetOp), uint16(x86_FISUB), + /*11732*/ uint16(x86_xArgM32int), + /*11733*/ uint16(x86_xMatch), + /*11734*/ uint16(x86_xSetOp), uint16(x86_FISUBR), + /*11736*/ uint16(x86_xArgM32int), + /*11737*/ uint16(x86_xMatch), + /*11738*/ uint16(x86_xSetOp), uint16(x86_FIDIV), + /*11740*/ uint16(x86_xArgM32int), + /*11741*/ uint16(x86_xMatch), + /*11742*/ uint16(x86_xSetOp), uint16(x86_FIDIVR), + /*11744*/ uint16(x86_xArgM32int), + /*11745*/ uint16(x86_xMatch), + /*11746*/ uint16(x86_xSetOp), uint16(x86_FCMOVB), + /*11748*/ uint16(x86_xArgST), + /*11749*/ uint16(x86_xArgSTi), + /*11750*/ uint16(x86_xMatch), + /*11751*/ uint16(x86_xSetOp), uint16(x86_FCMOVE), + /*11753*/ uint16(x86_xArgST), + /*11754*/ uint16(x86_xArgSTi), + /*11755*/ uint16(x86_xMatch), + /*11756*/ uint16(x86_xSetOp), uint16(x86_FCMOVBE), + /*11758*/ uint16(x86_xArgST), + /*11759*/ uint16(x86_xArgSTi), + /*11760*/ uint16(x86_xMatch), + /*11761*/ uint16(x86_xSetOp), uint16(x86_FCMOVU), + /*11763*/ uint16(x86_xArgST), + /*11764*/ uint16(x86_xArgSTi), + /*11765*/ uint16(x86_xMatch), + /*11766*/ uint16(x86_xSetOp), uint16(x86_FUCOMPP), + /*11768*/ uint16(x86_xMatch), + /*11769*/ uint16(x86_xCondByte), 50, + 0xc0, 11904, + 0xc1, 11904, + 0xc2, 11904, + 0xc3, 11904, + 0xc4, 11904, + 0xc5, 11904, + 0xc6, 11904, + 0xc7, 11904, + 0xc8, 11909, + 0xc9, 11909, + 0xca, 11909, + 0xcb, 11909, + 0xcc, 11909, + 0xcd, 11909, + 0xce, 11909, + 0xcf, 11909, + 0xd0, 11914, + 0xd1, 11914, + 0xd2, 11914, + 0xd3, 11914, + 0xd4, 11914, + 0xd5, 11914, + 0xd6, 11914, + 0xd7, 11914, + 0xd8, 11919, + 0xd9, 11919, + 0xda, 11919, + 0xdb, 11919, + 0xdc, 11919, + 0xdd, 11919, + 0xde, 11919, + 0xdf, 11919, + 0xE2, 11924, + 0xE3, 11927, + 0xe8, 11930, + 0xe9, 11930, + 0xea, 11930, + 0xeb, 11930, + 0xec, 11930, + 0xed, 11930, + 0xee, 11930, + 0xef, 11930, + 0xf0, 11935, + 0xf1, 11935, + 0xf2, 11935, + 0xf3, 11935, + 0xf4, 11935, + 0xf5, 11935, + 0xf6, 11935, + 0xf7, 11935, + /*11871*/ uint16(x86_xCondSlashR), + 11880, // 0 + 11884, // 1 + 11888, // 2 + 11892, // 3 + 0, // 4 + 11896, // 5 + 0, // 6 + 11900, // 7 + /*11880*/ uint16(x86_xSetOp), uint16(x86_FILD), + /*11882*/ uint16(x86_xArgM32int), + /*11883*/ uint16(x86_xMatch), + /*11884*/ uint16(x86_xSetOp), uint16(x86_FISTTP), + /*11886*/ uint16(x86_xArgM32int), + /*11887*/ uint16(x86_xMatch), + /*11888*/ uint16(x86_xSetOp), uint16(x86_FIST), + /*11890*/ uint16(x86_xArgM32int), + /*11891*/ uint16(x86_xMatch), + /*11892*/ uint16(x86_xSetOp), uint16(x86_FISTP), + /*11894*/ uint16(x86_xArgM32int), + /*11895*/ uint16(x86_xMatch), + /*11896*/ uint16(x86_xSetOp), uint16(x86_FLD), + /*11898*/ uint16(x86_xArgM80fp), + /*11899*/ uint16(x86_xMatch), + /*11900*/ uint16(x86_xSetOp), uint16(x86_FSTP), + /*11902*/ uint16(x86_xArgM80fp), + /*11903*/ uint16(x86_xMatch), + /*11904*/ uint16(x86_xSetOp), uint16(x86_FCMOVNB), + /*11906*/ uint16(x86_xArgST), + /*11907*/ uint16(x86_xArgSTi), + /*11908*/ uint16(x86_xMatch), + /*11909*/ uint16(x86_xSetOp), uint16(x86_FCMOVNE), + /*11911*/ uint16(x86_xArgST), + /*11912*/ uint16(x86_xArgSTi), + /*11913*/ uint16(x86_xMatch), + /*11914*/ uint16(x86_xSetOp), uint16(x86_FCMOVNBE), + /*11916*/ uint16(x86_xArgST), + /*11917*/ uint16(x86_xArgSTi), + /*11918*/ uint16(x86_xMatch), + /*11919*/ uint16(x86_xSetOp), uint16(x86_FCMOVNU), + /*11921*/ uint16(x86_xArgST), + /*11922*/ uint16(x86_xArgSTi), + /*11923*/ uint16(x86_xMatch), + /*11924*/ uint16(x86_xSetOp), uint16(x86_FNCLEX), + /*11926*/ uint16(x86_xMatch), + /*11927*/ uint16(x86_xSetOp), uint16(x86_FNINIT), + /*11929*/ uint16(x86_xMatch), + /*11930*/ uint16(x86_xSetOp), uint16(x86_FUCOMI), + /*11932*/ uint16(x86_xArgST), + /*11933*/ uint16(x86_xArgSTi), + /*11934*/ uint16(x86_xMatch), + /*11935*/ uint16(x86_xSetOp), uint16(x86_FCOMI), + /*11937*/ uint16(x86_xArgST), + /*11938*/ uint16(x86_xArgSTi), + /*11939*/ uint16(x86_xMatch), + /*11940*/ uint16(x86_xCondByte), 48, + 0xc0, 12079, + 0xc1, 12079, + 0xc2, 12079, + 0xc3, 12079, + 0xc4, 12079, + 0xc5, 12079, + 0xc6, 12079, + 0xc7, 12079, + 0xc8, 12084, + 0xc9, 12084, + 0xca, 12084, + 0xcb, 12084, + 0xcc, 12084, + 0xcd, 12084, + 0xce, 12084, + 0xcf, 12084, + 0xe0, 12089, + 0xe1, 12089, + 0xe2, 12089, + 0xe3, 12089, + 0xe4, 12089, + 0xe5, 12089, + 0xe6, 12089, + 0xe7, 12089, + 0xe8, 12094, + 0xe9, 12094, + 0xea, 12094, + 0xeb, 12094, + 0xec, 12094, + 0xed, 12094, + 0xee, 12094, + 0xef, 12094, + 0xf0, 12099, + 0xf1, 12099, + 0xf2, 12099, + 0xf3, 12099, + 0xf4, 12099, + 0xf5, 12099, + 0xf6, 12099, + 0xf7, 12099, + 0xf8, 12104, + 0xf9, 12104, + 0xfa, 12104, + 0xfb, 12104, + 0xfc, 12104, + 0xfd, 12104, + 0xfe, 12104, + 0xff, 12104, + /*12038*/ uint16(x86_xCondSlashR), + 12047, // 0 + 12051, // 1 + 12055, // 2 + 12059, // 3 + 12063, // 4 + 12067, // 5 + 12071, // 6 + 12075, // 7 + /*12047*/ uint16(x86_xSetOp), uint16(x86_FADD), + /*12049*/ uint16(x86_xArgM64fp), + /*12050*/ uint16(x86_xMatch), + /*12051*/ uint16(x86_xSetOp), uint16(x86_FMUL), + /*12053*/ uint16(x86_xArgM64fp), + /*12054*/ uint16(x86_xMatch), + /*12055*/ uint16(x86_xSetOp), uint16(x86_FCOM), + /*12057*/ uint16(x86_xArgM64fp), + /*12058*/ uint16(x86_xMatch), + /*12059*/ uint16(x86_xSetOp), uint16(x86_FCOMP), + /*12061*/ uint16(x86_xArgM64fp), + /*12062*/ uint16(x86_xMatch), + /*12063*/ uint16(x86_xSetOp), uint16(x86_FSUB), + /*12065*/ uint16(x86_xArgM64fp), + /*12066*/ uint16(x86_xMatch), + /*12067*/ uint16(x86_xSetOp), uint16(x86_FSUBR), + /*12069*/ uint16(x86_xArgM64fp), + /*12070*/ uint16(x86_xMatch), + /*12071*/ uint16(x86_xSetOp), uint16(x86_FDIV), + /*12073*/ uint16(x86_xArgM64fp), + /*12074*/ uint16(x86_xMatch), + /*12075*/ uint16(x86_xSetOp), uint16(x86_FDIVR), + /*12077*/ uint16(x86_xArgM64fp), + /*12078*/ uint16(x86_xMatch), + /*12079*/ uint16(x86_xSetOp), uint16(x86_FADD), + /*12081*/ uint16(x86_xArgSTi), + /*12082*/ uint16(x86_xArgST), + /*12083*/ uint16(x86_xMatch), + /*12084*/ uint16(x86_xSetOp), uint16(x86_FMUL), + /*12086*/ uint16(x86_xArgSTi), + /*12087*/ uint16(x86_xArgST), + /*12088*/ uint16(x86_xMatch), + /*12089*/ uint16(x86_xSetOp), uint16(x86_FSUBR), + /*12091*/ uint16(x86_xArgSTi), + /*12092*/ uint16(x86_xArgST), + /*12093*/ uint16(x86_xMatch), + /*12094*/ uint16(x86_xSetOp), uint16(x86_FSUB), + /*12096*/ uint16(x86_xArgSTi), + /*12097*/ uint16(x86_xArgST), + /*12098*/ uint16(x86_xMatch), + /*12099*/ uint16(x86_xSetOp), uint16(x86_FDIVR), + /*12101*/ uint16(x86_xArgSTi), + /*12102*/ uint16(x86_xArgST), + /*12103*/ uint16(x86_xMatch), + /*12104*/ uint16(x86_xSetOp), uint16(x86_FDIV), + /*12106*/ uint16(x86_xArgSTi), + /*12107*/ uint16(x86_xArgST), + /*12108*/ uint16(x86_xMatch), + /*12109*/ uint16(x86_xCondByte), 40, + 0xc0, 12228, + 0xc1, 12228, + 0xc2, 12228, + 0xc3, 12228, + 0xc4, 12228, + 0xc5, 12228, + 0xc6, 12228, + 0xc7, 12228, + 0xd0, 12232, + 0xd1, 12232, + 0xd2, 12232, + 0xd3, 12232, + 0xd4, 12232, + 0xd5, 12232, + 0xd6, 12232, + 0xd7, 12232, + 0xd8, 12236, + 0xd9, 12236, + 0xda, 12236, + 0xdb, 12236, + 0xdc, 12236, + 0xdd, 12236, + 0xde, 12236, + 0xdf, 12236, + 0xe0, 12240, + 0xe1, 12240, + 0xe2, 12240, + 0xe3, 12240, + 0xe4, 12240, + 0xe5, 12240, + 0xe6, 12240, + 0xe7, 12240, + 0xe8, 12244, + 0xe9, 12244, + 0xea, 12244, + 0xeb, 12244, + 0xec, 12244, + 0xed, 12244, + 0xee, 12244, + 0xef, 12244, + /*12191*/ uint16(x86_xCondSlashR), + 12200, // 0 + 12204, // 1 + 12208, // 2 + 12212, // 3 + 12216, // 4 + 0, // 5 + 12220, // 6 + 12224, // 7 + /*12200*/ uint16(x86_xSetOp), uint16(x86_FLD), + /*12202*/ uint16(x86_xArgM64fp), + /*12203*/ uint16(x86_xMatch), + /*12204*/ uint16(x86_xSetOp), uint16(x86_FISTTP), + /*12206*/ uint16(x86_xArgM64int), + /*12207*/ uint16(x86_xMatch), + /*12208*/ uint16(x86_xSetOp), uint16(x86_FST), + /*12210*/ uint16(x86_xArgM64fp), + /*12211*/ uint16(x86_xMatch), + /*12212*/ uint16(x86_xSetOp), uint16(x86_FSTP), + /*12214*/ uint16(x86_xArgM64fp), + /*12215*/ uint16(x86_xMatch), + /*12216*/ uint16(x86_xSetOp), uint16(x86_FRSTOR), + /*12218*/ uint16(x86_xArgM94108byte), + /*12219*/ uint16(x86_xMatch), + /*12220*/ uint16(x86_xSetOp), uint16(x86_FNSAVE), + /*12222*/ uint16(x86_xArgM94108byte), + /*12223*/ uint16(x86_xMatch), + /*12224*/ uint16(x86_xSetOp), uint16(x86_FNSTSW), + /*12226*/ uint16(x86_xArgM2byte), + /*12227*/ uint16(x86_xMatch), + /*12228*/ uint16(x86_xSetOp), uint16(x86_FFREE), + /*12230*/ uint16(x86_xArgSTi), + /*12231*/ uint16(x86_xMatch), + /*12232*/ uint16(x86_xSetOp), uint16(x86_FST), + /*12234*/ uint16(x86_xArgSTi), + /*12235*/ uint16(x86_xMatch), + /*12236*/ uint16(x86_xSetOp), uint16(x86_FSTP), + /*12238*/ uint16(x86_xArgSTi), + /*12239*/ uint16(x86_xMatch), + /*12240*/ uint16(x86_xSetOp), uint16(x86_FUCOM), + /*12242*/ uint16(x86_xArgSTi), + /*12243*/ uint16(x86_xMatch), + /*12244*/ uint16(x86_xSetOp), uint16(x86_FUCOMP), + /*12246*/ uint16(x86_xArgSTi), + /*12247*/ uint16(x86_xMatch), + /*12248*/ uint16(x86_xCondByte), 49, + 0xc0, 12389, + 0xc1, 12389, + 0xc2, 12389, + 0xc3, 12389, + 0xc4, 12389, + 0xc5, 12389, + 0xc6, 12389, + 0xc7, 12389, + 0xc8, 12394, + 0xc9, 12394, + 0xca, 12394, + 0xcb, 12394, + 0xcc, 12394, + 0xcd, 12394, + 0xce, 12394, + 0xcf, 12394, + 0xD9, 12399, + 0xe0, 12402, + 0xe1, 12402, + 0xe2, 12402, + 0xe3, 12402, + 0xe4, 12402, + 0xe5, 12402, + 0xe6, 12402, + 0xe7, 12402, + 0xe8, 12407, + 0xe9, 12407, + 0xea, 12407, + 0xeb, 12407, + 0xec, 12407, + 0xed, 12407, + 0xee, 12407, + 0xef, 12407, + 0xf0, 12412, + 0xf1, 12412, + 0xf2, 12412, + 0xf3, 12412, + 0xf4, 12412, + 0xf5, 12412, + 0xf6, 12412, + 0xf7, 12412, + 0xf8, 12417, + 0xf9, 12417, + 0xfa, 12417, + 0xfb, 12417, + 0xfc, 12417, + 0xfd, 12417, + 0xfe, 12417, + 0xff, 12417, + /*12348*/ uint16(x86_xCondSlashR), + 12357, // 0 + 12361, // 1 + 12365, // 2 + 12369, // 3 + 12373, // 4 + 12377, // 5 + 12381, // 6 + 12385, // 7 + /*12357*/ uint16(x86_xSetOp), uint16(x86_FIADD), + /*12359*/ uint16(x86_xArgM16int), + /*12360*/ uint16(x86_xMatch), + /*12361*/ uint16(x86_xSetOp), uint16(x86_FIMUL), + /*12363*/ uint16(x86_xArgM16int), + /*12364*/ uint16(x86_xMatch), + /*12365*/ uint16(x86_xSetOp), uint16(x86_FICOM), + /*12367*/ uint16(x86_xArgM16int), + /*12368*/ uint16(x86_xMatch), + /*12369*/ uint16(x86_xSetOp), uint16(x86_FICOMP), + /*12371*/ uint16(x86_xArgM16int), + /*12372*/ uint16(x86_xMatch), + /*12373*/ uint16(x86_xSetOp), uint16(x86_FISUB), + /*12375*/ uint16(x86_xArgM16int), + /*12376*/ uint16(x86_xMatch), + /*12377*/ uint16(x86_xSetOp), uint16(x86_FISUBR), + /*12379*/ uint16(x86_xArgM16int), + /*12380*/ uint16(x86_xMatch), + /*12381*/ uint16(x86_xSetOp), uint16(x86_FIDIV), + /*12383*/ uint16(x86_xArgM16int), + /*12384*/ uint16(x86_xMatch), + /*12385*/ uint16(x86_xSetOp), uint16(x86_FIDIVR), + /*12387*/ uint16(x86_xArgM16int), + /*12388*/ uint16(x86_xMatch), + /*12389*/ uint16(x86_xSetOp), uint16(x86_FADDP), + /*12391*/ uint16(x86_xArgSTi), + /*12392*/ uint16(x86_xArgST), + /*12393*/ uint16(x86_xMatch), + /*12394*/ uint16(x86_xSetOp), uint16(x86_FMULP), + /*12396*/ uint16(x86_xArgSTi), + /*12397*/ uint16(x86_xArgST), + /*12398*/ uint16(x86_xMatch), + /*12399*/ uint16(x86_xSetOp), uint16(x86_FCOMPP), + /*12401*/ uint16(x86_xMatch), + /*12402*/ uint16(x86_xSetOp), uint16(x86_FSUBRP), + /*12404*/ uint16(x86_xArgSTi), + /*12405*/ uint16(x86_xArgST), + /*12406*/ uint16(x86_xMatch), + /*12407*/ uint16(x86_xSetOp), uint16(x86_FSUBP), + /*12409*/ uint16(x86_xArgSTi), + /*12410*/ uint16(x86_xArgST), + /*12411*/ uint16(x86_xMatch), + /*12412*/ uint16(x86_xSetOp), uint16(x86_FDIVRP), + /*12414*/ uint16(x86_xArgSTi), + /*12415*/ uint16(x86_xArgST), + /*12416*/ uint16(x86_xMatch), + /*12417*/ uint16(x86_xSetOp), uint16(x86_FDIVP), + /*12419*/ uint16(x86_xArgSTi), + /*12420*/ uint16(x86_xArgST), + /*12421*/ uint16(x86_xMatch), + /*12422*/ uint16(x86_xCondByte), 25, + 0xc0, 12515, + 0xc1, 12515, + 0xc2, 12515, + 0xc3, 12515, + 0xc4, 12515, + 0xc5, 12515, + 0xc6, 12515, + 0xc7, 12515, + 0xE0, 12519, + 0xe8, 12523, + 0xe9, 12523, + 0xea, 12523, + 0xeb, 12523, + 0xec, 12523, + 0xed, 12523, + 0xee, 12523, + 0xef, 12523, + 0xf0, 12528, + 0xf1, 12528, + 0xf2, 12528, + 0xf3, 12528, + 0xf4, 12528, + 0xf5, 12528, + 0xf6, 12528, + 0xf7, 12528, + /*12474*/ uint16(x86_xCondSlashR), + 12483, // 0 + 12487, // 1 + 12491, // 2 + 12495, // 3 + 12499, // 4 + 12503, // 5 + 12507, // 6 + 12511, // 7 + /*12483*/ uint16(x86_xSetOp), uint16(x86_FILD), + /*12485*/ uint16(x86_xArgM16int), + /*12486*/ uint16(x86_xMatch), + /*12487*/ uint16(x86_xSetOp), uint16(x86_FISTTP), + /*12489*/ uint16(x86_xArgM16int), + /*12490*/ uint16(x86_xMatch), + /*12491*/ uint16(x86_xSetOp), uint16(x86_FIST), + /*12493*/ uint16(x86_xArgM16int), + /*12494*/ uint16(x86_xMatch), + /*12495*/ uint16(x86_xSetOp), uint16(x86_FISTP), + /*12497*/ uint16(x86_xArgM16int), + /*12498*/ uint16(x86_xMatch), + /*12499*/ uint16(x86_xSetOp), uint16(x86_FBLD), + /*12501*/ uint16(x86_xArgM80dec), + /*12502*/ uint16(x86_xMatch), + /*12503*/ uint16(x86_xSetOp), uint16(x86_FILD), + /*12505*/ uint16(x86_xArgM64int), + /*12506*/ uint16(x86_xMatch), + /*12507*/ uint16(x86_xSetOp), uint16(x86_FBSTP), + /*12509*/ uint16(x86_xArgM80bcd), + /*12510*/ uint16(x86_xMatch), + /*12511*/ uint16(x86_xSetOp), uint16(x86_FISTP), + /*12513*/ uint16(x86_xArgM64int), + /*12514*/ uint16(x86_xMatch), + /*12515*/ uint16(x86_xSetOp), uint16(x86_FFREEP), + /*12517*/ uint16(x86_xArgSTi), + /*12518*/ uint16(x86_xMatch), + /*12519*/ uint16(x86_xSetOp), uint16(x86_FNSTSW), + /*12521*/ uint16(x86_xArgAX), + /*12522*/ uint16(x86_xMatch), + /*12523*/ uint16(x86_xSetOp), uint16(x86_FUCOMIP), + /*12525*/ uint16(x86_xArgST), + /*12526*/ uint16(x86_xArgSTi), + /*12527*/ uint16(x86_xMatch), + /*12528*/ uint16(x86_xSetOp), uint16(x86_FCOMIP), + /*12530*/ uint16(x86_xArgST), + /*12531*/ uint16(x86_xArgSTi), + /*12532*/ uint16(x86_xMatch), + /*12533*/ uint16(x86_xSetOp), uint16(x86_LOOPNE), + /*12535*/ uint16(x86_xReadCb), + /*12536*/ uint16(x86_xArgRel8), + /*12537*/ uint16(x86_xMatch), + /*12538*/ uint16(x86_xSetOp), uint16(x86_LOOPE), + /*12540*/ uint16(x86_xReadCb), + /*12541*/ uint16(x86_xArgRel8), + /*12542*/ uint16(x86_xMatch), + /*12543*/ uint16(x86_xSetOp), uint16(x86_LOOP), + /*12545*/ uint16(x86_xReadCb), + /*12546*/ uint16(x86_xArgRel8), + /*12547*/ uint16(x86_xMatch), + /*12548*/ uint16(x86_xCondIs64), 12551, 12565, + /*12551*/ uint16(x86_xCondAddrSize), 12555, 12560, 0, + /*12555*/ uint16(x86_xSetOp), uint16(x86_JCXZ), + /*12557*/ uint16(x86_xReadCb), + /*12558*/ uint16(x86_xArgRel8), + /*12559*/ uint16(x86_xMatch), + /*12560*/ uint16(x86_xSetOp), uint16(x86_JECXZ), + /*12562*/ uint16(x86_xReadCb), + /*12563*/ uint16(x86_xArgRel8), + /*12564*/ uint16(x86_xMatch), + /*12565*/ uint16(x86_xCondAddrSize), 0, 12560, 12569, + /*12569*/ uint16(x86_xSetOp), uint16(x86_JRCXZ), + /*12571*/ uint16(x86_xReadCb), + /*12572*/ uint16(x86_xArgRel8), + /*12573*/ uint16(x86_xMatch), + /*12574*/ uint16(x86_xSetOp), uint16(x86_IN), + /*12576*/ uint16(x86_xReadIb), + /*12577*/ uint16(x86_xArgAL), + /*12578*/ uint16(x86_xArgImm8u), + /*12579*/ uint16(x86_xMatch), + /*12580*/ uint16(x86_xCondDataSize), 12584, 12590, 12596, + /*12584*/ uint16(x86_xSetOp), uint16(x86_IN), + /*12586*/ uint16(x86_xReadIb), + /*12587*/ uint16(x86_xArgAX), + /*12588*/ uint16(x86_xArgImm8u), + /*12589*/ uint16(x86_xMatch), + /*12590*/ uint16(x86_xSetOp), uint16(x86_IN), + /*12592*/ uint16(x86_xReadIb), + /*12593*/ uint16(x86_xArgEAX), + /*12594*/ uint16(x86_xArgImm8u), + /*12595*/ uint16(x86_xMatch), + /*12596*/ uint16(x86_xSetOp), uint16(x86_IN), + /*12598*/ uint16(x86_xReadIb), + /*12599*/ uint16(x86_xArgEAX), + /*12600*/ uint16(x86_xArgImm8u), + /*12601*/ uint16(x86_xMatch), + /*12602*/ uint16(x86_xSetOp), uint16(x86_OUT), + /*12604*/ uint16(x86_xReadIb), + /*12605*/ uint16(x86_xArgImm8u), + /*12606*/ uint16(x86_xArgAL), + /*12607*/ uint16(x86_xMatch), + /*12608*/ uint16(x86_xCondDataSize), 12612, 12618, 12624, + /*12612*/ uint16(x86_xSetOp), uint16(x86_OUT), + /*12614*/ uint16(x86_xReadIb), + /*12615*/ uint16(x86_xArgImm8u), + /*12616*/ uint16(x86_xArgAX), + /*12617*/ uint16(x86_xMatch), + /*12618*/ uint16(x86_xSetOp), uint16(x86_OUT), + /*12620*/ uint16(x86_xReadIb), + /*12621*/ uint16(x86_xArgImm8u), + /*12622*/ uint16(x86_xArgEAX), + /*12623*/ uint16(x86_xMatch), + /*12624*/ uint16(x86_xSetOp), uint16(x86_OUT), + /*12626*/ uint16(x86_xReadIb), + /*12627*/ uint16(x86_xArgImm8u), + /*12628*/ uint16(x86_xArgEAX), + /*12629*/ uint16(x86_xMatch), + /*12630*/ uint16(x86_xCondIs64), 12633, 12647, + /*12633*/ uint16(x86_xCondDataSize), 12637, 12642, 0, + /*12637*/ uint16(x86_xSetOp), uint16(x86_CALL), + /*12639*/ uint16(x86_xReadCw), + /*12640*/ uint16(x86_xArgRel16), + /*12641*/ uint16(x86_xMatch), + /*12642*/ uint16(x86_xSetOp), uint16(x86_CALL), + /*12644*/ uint16(x86_xReadCd), + /*12645*/ uint16(x86_xArgRel32), + /*12646*/ uint16(x86_xMatch), + /*12647*/ uint16(x86_xCondDataSize), 12651, 12642, 12656, + /*12651*/ uint16(x86_xSetOp), uint16(x86_CALL), + /*12653*/ uint16(x86_xReadCd), + /*12654*/ uint16(x86_xArgRel32), + /*12655*/ uint16(x86_xMatch), + /*12656*/ uint16(x86_xSetOp), uint16(x86_CALL), + /*12658*/ uint16(x86_xReadCd), + /*12659*/ uint16(x86_xArgRel32), + /*12660*/ uint16(x86_xMatch), + /*12661*/ uint16(x86_xCondIs64), 12664, 12678, + /*12664*/ uint16(x86_xCondDataSize), 12668, 12673, 0, + /*12668*/ uint16(x86_xSetOp), uint16(x86_JMP), + /*12670*/ uint16(x86_xReadCw), + /*12671*/ uint16(x86_xArgRel16), + /*12672*/ uint16(x86_xMatch), + /*12673*/ uint16(x86_xSetOp), uint16(x86_JMP), + /*12675*/ uint16(x86_xReadCd), + /*12676*/ uint16(x86_xArgRel32), + /*12677*/ uint16(x86_xMatch), + /*12678*/ uint16(x86_xCondDataSize), 12682, 12673, 12687, + /*12682*/ uint16(x86_xSetOp), uint16(x86_JMP), + /*12684*/ uint16(x86_xReadCd), + /*12685*/ uint16(x86_xArgRel32), + /*12686*/ uint16(x86_xMatch), + /*12687*/ uint16(x86_xSetOp), uint16(x86_JMP), + /*12689*/ uint16(x86_xReadCd), + /*12690*/ uint16(x86_xArgRel32), + /*12691*/ uint16(x86_xMatch), + /*12692*/ uint16(x86_xCondIs64), 12695, 0, + /*12695*/ uint16(x86_xCondDataSize), 12699, 12704, 0, + /*12699*/ uint16(x86_xSetOp), uint16(x86_LJMP), + /*12701*/ uint16(x86_xReadCd), + /*12702*/ uint16(x86_xArgPtr16colon16), + /*12703*/ uint16(x86_xMatch), + /*12704*/ uint16(x86_xSetOp), uint16(x86_LJMP), + /*12706*/ uint16(x86_xReadCp), + /*12707*/ uint16(x86_xArgPtr16colon32), + /*12708*/ uint16(x86_xMatch), + /*12709*/ uint16(x86_xSetOp), uint16(x86_JMP), + /*12711*/ uint16(x86_xReadCb), + /*12712*/ uint16(x86_xArgRel8), + /*12713*/ uint16(x86_xMatch), + /*12714*/ uint16(x86_xSetOp), uint16(x86_IN), + /*12716*/ uint16(x86_xArgAL), + /*12717*/ uint16(x86_xArgDX), + /*12718*/ uint16(x86_xMatch), + /*12719*/ uint16(x86_xCondDataSize), 12723, 12728, 12733, + /*12723*/ uint16(x86_xSetOp), uint16(x86_IN), + /*12725*/ uint16(x86_xArgAX), + /*12726*/ uint16(x86_xArgDX), + /*12727*/ uint16(x86_xMatch), + /*12728*/ uint16(x86_xSetOp), uint16(x86_IN), + /*12730*/ uint16(x86_xArgEAX), + /*12731*/ uint16(x86_xArgDX), + /*12732*/ uint16(x86_xMatch), + /*12733*/ uint16(x86_xSetOp), uint16(x86_IN), + /*12735*/ uint16(x86_xArgEAX), + /*12736*/ uint16(x86_xArgDX), + /*12737*/ uint16(x86_xMatch), + /*12738*/ uint16(x86_xSetOp), uint16(x86_OUT), + /*12740*/ uint16(x86_xArgDX), + /*12741*/ uint16(x86_xArgAL), + /*12742*/ uint16(x86_xMatch), + /*12743*/ uint16(x86_xCondDataSize), 12747, 12752, 12757, + /*12747*/ uint16(x86_xSetOp), uint16(x86_OUT), + /*12749*/ uint16(x86_xArgDX), + /*12750*/ uint16(x86_xArgAX), + /*12751*/ uint16(x86_xMatch), + /*12752*/ uint16(x86_xSetOp), uint16(x86_OUT), + /*12754*/ uint16(x86_xArgDX), + /*12755*/ uint16(x86_xArgEAX), + /*12756*/ uint16(x86_xMatch), + /*12757*/ uint16(x86_xSetOp), uint16(x86_OUT), + /*12759*/ uint16(x86_xArgDX), + /*12760*/ uint16(x86_xArgEAX), + /*12761*/ uint16(x86_xMatch), + /*12762*/ uint16(x86_xSetOp), uint16(x86_ICEBP), + /*12764*/ uint16(x86_xMatch), + /*12765*/ uint16(x86_xSetOp), uint16(x86_HLT), + /*12767*/ uint16(x86_xMatch), + /*12768*/ uint16(x86_xSetOp), uint16(x86_CMC), + /*12770*/ uint16(x86_xMatch), + /*12771*/ uint16(x86_xCondSlashR), + 12780, // 0 + 0, // 1 + 12786, // 2 + 12790, // 3 + 12794, // 4 + 12798, // 5 + 12802, // 6 + 12806, // 7 + /*12780*/ uint16(x86_xSetOp), uint16(x86_TEST), + /*12782*/ uint16(x86_xReadIb), + /*12783*/ uint16(x86_xArgRM8), + /*12784*/ uint16(x86_xArgImm8u), + /*12785*/ uint16(x86_xMatch), + /*12786*/ uint16(x86_xSetOp), uint16(x86_NOT), + /*12788*/ uint16(x86_xArgRM8), + /*12789*/ uint16(x86_xMatch), + /*12790*/ uint16(x86_xSetOp), uint16(x86_NEG), + /*12792*/ uint16(x86_xArgRM8), + /*12793*/ uint16(x86_xMatch), + /*12794*/ uint16(x86_xSetOp), uint16(x86_MUL), + /*12796*/ uint16(x86_xArgRM8), + /*12797*/ uint16(x86_xMatch), + /*12798*/ uint16(x86_xSetOp), uint16(x86_IMUL), + /*12800*/ uint16(x86_xArgRM8), + /*12801*/ uint16(x86_xMatch), + /*12802*/ uint16(x86_xSetOp), uint16(x86_DIV), + /*12804*/ uint16(x86_xArgRM8), + /*12805*/ uint16(x86_xMatch), + /*12806*/ uint16(x86_xSetOp), uint16(x86_IDIV), + /*12808*/ uint16(x86_xArgRM8), + /*12809*/ uint16(x86_xMatch), + /*12810*/ uint16(x86_xCondSlashR), + 12819, // 0 + 0, // 1 + 12848, // 2 + 12871, // 3 + 12894, // 4 + 12917, // 5 + 12940, // 6 + 12963, // 7 + /*12819*/ uint16(x86_xCondIs64), 12822, 12838, + /*12822*/ uint16(x86_xCondDataSize), 12826, 12832, 0, + /*12826*/ uint16(x86_xSetOp), uint16(x86_TEST), + /*12828*/ uint16(x86_xReadIw), + /*12829*/ uint16(x86_xArgRM16), + /*12830*/ uint16(x86_xArgImm16), + /*12831*/ uint16(x86_xMatch), + /*12832*/ uint16(x86_xSetOp), uint16(x86_TEST), + /*12834*/ uint16(x86_xReadId), + /*12835*/ uint16(x86_xArgRM32), + /*12836*/ uint16(x86_xArgImm32), + /*12837*/ uint16(x86_xMatch), + /*12838*/ uint16(x86_xCondDataSize), 12826, 12832, 12842, + /*12842*/ uint16(x86_xSetOp), uint16(x86_TEST), + /*12844*/ uint16(x86_xReadId), + /*12845*/ uint16(x86_xArgRM64), + /*12846*/ uint16(x86_xArgImm32), + /*12847*/ uint16(x86_xMatch), + /*12848*/ uint16(x86_xCondIs64), 12851, 12863, + /*12851*/ uint16(x86_xCondDataSize), 12855, 12859, 0, + /*12855*/ uint16(x86_xSetOp), uint16(x86_NOT), + /*12857*/ uint16(x86_xArgRM16), + /*12858*/ uint16(x86_xMatch), + /*12859*/ uint16(x86_xSetOp), uint16(x86_NOT), + /*12861*/ uint16(x86_xArgRM32), + /*12862*/ uint16(x86_xMatch), + /*12863*/ uint16(x86_xCondDataSize), 12855, 12859, 12867, + /*12867*/ uint16(x86_xSetOp), uint16(x86_NOT), + /*12869*/ uint16(x86_xArgRM64), + /*12870*/ uint16(x86_xMatch), + /*12871*/ uint16(x86_xCondIs64), 12874, 12886, + /*12874*/ uint16(x86_xCondDataSize), 12878, 12882, 0, + /*12878*/ uint16(x86_xSetOp), uint16(x86_NEG), + /*12880*/ uint16(x86_xArgRM16), + /*12881*/ uint16(x86_xMatch), + /*12882*/ uint16(x86_xSetOp), uint16(x86_NEG), + /*12884*/ uint16(x86_xArgRM32), + /*12885*/ uint16(x86_xMatch), + /*12886*/ uint16(x86_xCondDataSize), 12878, 12882, 12890, + /*12890*/ uint16(x86_xSetOp), uint16(x86_NEG), + /*12892*/ uint16(x86_xArgRM64), + /*12893*/ uint16(x86_xMatch), + /*12894*/ uint16(x86_xCondIs64), 12897, 12909, + /*12897*/ uint16(x86_xCondDataSize), 12901, 12905, 0, + /*12901*/ uint16(x86_xSetOp), uint16(x86_MUL), + /*12903*/ uint16(x86_xArgRM16), + /*12904*/ uint16(x86_xMatch), + /*12905*/ uint16(x86_xSetOp), uint16(x86_MUL), + /*12907*/ uint16(x86_xArgRM32), + /*12908*/ uint16(x86_xMatch), + /*12909*/ uint16(x86_xCondDataSize), 12901, 12905, 12913, + /*12913*/ uint16(x86_xSetOp), uint16(x86_MUL), + /*12915*/ uint16(x86_xArgRM64), + /*12916*/ uint16(x86_xMatch), + /*12917*/ uint16(x86_xCondIs64), 12920, 12932, + /*12920*/ uint16(x86_xCondDataSize), 12924, 12928, 0, + /*12924*/ uint16(x86_xSetOp), uint16(x86_IMUL), + /*12926*/ uint16(x86_xArgRM16), + /*12927*/ uint16(x86_xMatch), + /*12928*/ uint16(x86_xSetOp), uint16(x86_IMUL), + /*12930*/ uint16(x86_xArgRM32), + /*12931*/ uint16(x86_xMatch), + /*12932*/ uint16(x86_xCondDataSize), 12924, 12928, 12936, + /*12936*/ uint16(x86_xSetOp), uint16(x86_IMUL), + /*12938*/ uint16(x86_xArgRM64), + /*12939*/ uint16(x86_xMatch), + /*12940*/ uint16(x86_xCondIs64), 12943, 12955, + /*12943*/ uint16(x86_xCondDataSize), 12947, 12951, 0, + /*12947*/ uint16(x86_xSetOp), uint16(x86_DIV), + /*12949*/ uint16(x86_xArgRM16), + /*12950*/ uint16(x86_xMatch), + /*12951*/ uint16(x86_xSetOp), uint16(x86_DIV), + /*12953*/ uint16(x86_xArgRM32), + /*12954*/ uint16(x86_xMatch), + /*12955*/ uint16(x86_xCondDataSize), 12947, 12951, 12959, + /*12959*/ uint16(x86_xSetOp), uint16(x86_DIV), + /*12961*/ uint16(x86_xArgRM64), + /*12962*/ uint16(x86_xMatch), + /*12963*/ uint16(x86_xCondIs64), 12966, 12978, + /*12966*/ uint16(x86_xCondDataSize), 12970, 12974, 0, + /*12970*/ uint16(x86_xSetOp), uint16(x86_IDIV), + /*12972*/ uint16(x86_xArgRM16), + /*12973*/ uint16(x86_xMatch), + /*12974*/ uint16(x86_xSetOp), uint16(x86_IDIV), + /*12976*/ uint16(x86_xArgRM32), + /*12977*/ uint16(x86_xMatch), + /*12978*/ uint16(x86_xCondDataSize), 12970, 12974, 12982, + /*12982*/ uint16(x86_xSetOp), uint16(x86_IDIV), + /*12984*/ uint16(x86_xArgRM64), + /*12985*/ uint16(x86_xMatch), + /*12986*/ uint16(x86_xSetOp), uint16(x86_CLC), + /*12988*/ uint16(x86_xMatch), + /*12989*/ uint16(x86_xSetOp), uint16(x86_STC), + /*12991*/ uint16(x86_xMatch), + /*12992*/ uint16(x86_xSetOp), uint16(x86_CLI), + /*12994*/ uint16(x86_xMatch), + /*12995*/ uint16(x86_xSetOp), uint16(x86_STI), + /*12997*/ uint16(x86_xMatch), + /*12998*/ uint16(x86_xSetOp), uint16(x86_CLD), + /*13000*/ uint16(x86_xMatch), + /*13001*/ uint16(x86_xSetOp), uint16(x86_STD), + /*13003*/ uint16(x86_xMatch), + /*13004*/ uint16(x86_xCondSlashR), + 13013, // 0 + 13017, // 1 + 0, // 2 + 0, // 3 + 0, // 4 + 0, // 5 + 0, // 6 + 0, // 7 + /*13013*/ uint16(x86_xSetOp), uint16(x86_INC), + /*13015*/ uint16(x86_xArgRM8), + /*13016*/ uint16(x86_xMatch), + /*13017*/ uint16(x86_xSetOp), uint16(x86_DEC), + /*13019*/ uint16(x86_xArgRM8), + /*13020*/ uint16(x86_xMatch), + /*13021*/ uint16(x86_xCondSlashR), + 13030, // 0 + 13053, // 1 + 13076, // 2 + 13095, // 3 + 13118, // 4 + 13137, // 5 + 13160, // 6 + 0, // 7 + /*13030*/ uint16(x86_xCondIs64), 13033, 13045, + /*13033*/ uint16(x86_xCondDataSize), 13037, 13041, 0, + /*13037*/ uint16(x86_xSetOp), uint16(x86_INC), + /*13039*/ uint16(x86_xArgRM16), + /*13040*/ uint16(x86_xMatch), + /*13041*/ uint16(x86_xSetOp), uint16(x86_INC), + /*13043*/ uint16(x86_xArgRM32), + /*13044*/ uint16(x86_xMatch), + /*13045*/ uint16(x86_xCondDataSize), 13037, 13041, 13049, + /*13049*/ uint16(x86_xSetOp), uint16(x86_INC), + /*13051*/ uint16(x86_xArgRM64), + /*13052*/ uint16(x86_xMatch), + /*13053*/ uint16(x86_xCondIs64), 13056, 13068, + /*13056*/ uint16(x86_xCondDataSize), 13060, 13064, 0, + /*13060*/ uint16(x86_xSetOp), uint16(x86_DEC), + /*13062*/ uint16(x86_xArgRM16), + /*13063*/ uint16(x86_xMatch), + /*13064*/ uint16(x86_xSetOp), uint16(x86_DEC), + /*13066*/ uint16(x86_xArgRM32), + /*13067*/ uint16(x86_xMatch), + /*13068*/ uint16(x86_xCondDataSize), 13060, 13064, 13072, + /*13072*/ uint16(x86_xSetOp), uint16(x86_DEC), + /*13074*/ uint16(x86_xArgRM64), + /*13075*/ uint16(x86_xMatch), + /*13076*/ uint16(x86_xCondIs64), 13079, 13091, + /*13079*/ uint16(x86_xCondDataSize), 13083, 13087, 0, + /*13083*/ uint16(x86_xSetOp), uint16(x86_CALL), + /*13085*/ uint16(x86_xArgRM16), + /*13086*/ uint16(x86_xMatch), + /*13087*/ uint16(x86_xSetOp), uint16(x86_CALL), + /*13089*/ uint16(x86_xArgRM32), + /*13090*/ uint16(x86_xMatch), + /*13091*/ uint16(x86_xSetOp), uint16(x86_CALL), + /*13093*/ uint16(x86_xArgRM64), + /*13094*/ uint16(x86_xMatch), + /*13095*/ uint16(x86_xCondIs64), 13098, 13110, + /*13098*/ uint16(x86_xCondDataSize), 13102, 13106, 0, + /*13102*/ uint16(x86_xSetOp), uint16(x86_LCALL), + /*13104*/ uint16(x86_xArgM16colon16), + /*13105*/ uint16(x86_xMatch), + /*13106*/ uint16(x86_xSetOp), uint16(x86_LCALL), + /*13108*/ uint16(x86_xArgM16colon32), + /*13109*/ uint16(x86_xMatch), + /*13110*/ uint16(x86_xCondDataSize), 13102, 13106, 13114, + /*13114*/ uint16(x86_xSetOp), uint16(x86_LCALL), + /*13116*/ uint16(x86_xArgM16colon64), + /*13117*/ uint16(x86_xMatch), + /*13118*/ uint16(x86_xCondIs64), 13121, 13133, + /*13121*/ uint16(x86_xCondDataSize), 13125, 13129, 0, + /*13125*/ uint16(x86_xSetOp), uint16(x86_JMP), + /*13127*/ uint16(x86_xArgRM16), + /*13128*/ uint16(x86_xMatch), + /*13129*/ uint16(x86_xSetOp), uint16(x86_JMP), + /*13131*/ uint16(x86_xArgRM32), + /*13132*/ uint16(x86_xMatch), + /*13133*/ uint16(x86_xSetOp), uint16(x86_JMP), + /*13135*/ uint16(x86_xArgRM64), + /*13136*/ uint16(x86_xMatch), + /*13137*/ uint16(x86_xCondIs64), 13140, 13152, + /*13140*/ uint16(x86_xCondDataSize), 13144, 13148, 0, + /*13144*/ uint16(x86_xSetOp), uint16(x86_LJMP), + /*13146*/ uint16(x86_xArgM16colon16), + /*13147*/ uint16(x86_xMatch), + /*13148*/ uint16(x86_xSetOp), uint16(x86_LJMP), + /*13150*/ uint16(x86_xArgM16colon32), + /*13151*/ uint16(x86_xMatch), + /*13152*/ uint16(x86_xCondDataSize), 13144, 13148, 13156, + /*13156*/ uint16(x86_xSetOp), uint16(x86_LJMP), + /*13158*/ uint16(x86_xArgM16colon64), + /*13159*/ uint16(x86_xMatch), + /*13160*/ uint16(x86_xCondIs64), 13163, 13175, + /*13163*/ uint16(x86_xCondDataSize), 13167, 13171, 0, + /*13167*/ uint16(x86_xSetOp), uint16(x86_PUSH), + /*13169*/ uint16(x86_xArgRM16), + /*13170*/ uint16(x86_xMatch), + /*13171*/ uint16(x86_xSetOp), uint16(x86_PUSH), + /*13173*/ uint16(x86_xArgRM32), + /*13174*/ uint16(x86_xMatch), + /*13175*/ uint16(x86_xCondDataSize), 13167, 13179, 13183, + /*13179*/ uint16(x86_xSetOp), uint16(x86_PUSH), + /*13181*/ uint16(x86_xArgRM64), + /*13182*/ uint16(x86_xMatch), + /*13183*/ uint16(x86_xSetOp), uint16(x86_PUSH), + /*13185*/ uint16(x86_xArgRM64), + /*13186*/ uint16(x86_xMatch), +} + +const ( + _ x86_Op = iota + + x86_AAA + x86_AAD + x86_AAM + x86_AAS + x86_ADC + x86_ADD + x86_ADDPD + x86_ADDPS + x86_ADDSD + x86_ADDSS + x86_ADDSUBPD + x86_ADDSUBPS + x86_AESDEC + x86_AESDECLAST + x86_AESENC + x86_AESENCLAST + x86_AESIMC + x86_AESKEYGENASSIST + x86_AND + x86_ANDNPD + x86_ANDNPS + x86_ANDPD + x86_ANDPS + x86_ARPL + x86_BLENDPD + x86_BLENDPS + x86_BLENDVPD + x86_BLENDVPS + x86_BOUND + x86_BSF + x86_BSR + x86_BSWAP + x86_BT + x86_BTC + x86_BTR + x86_BTS + x86_CALL + x86_CBW + x86_CDQ + x86_CDQE + x86_CLC + x86_CLD + x86_CLFLUSH + x86_CLI + x86_CLTS + x86_CMC + x86_CMOVA + x86_CMOVAE + x86_CMOVB + x86_CMOVBE + x86_CMOVE + x86_CMOVG + x86_CMOVGE + x86_CMOVL + x86_CMOVLE + x86_CMOVNE + x86_CMOVNO + x86_CMOVNP + x86_CMOVNS + x86_CMOVO + x86_CMOVP + x86_CMOVS + x86_CMP + x86_CMPPD + x86_CMPPS + x86_CMPSB + x86_CMPSD + x86_CMPSD_XMM + x86_CMPSQ + x86_CMPSS + x86_CMPSW + x86_CMPXCHG + x86_CMPXCHG16B + x86_CMPXCHG8B + x86_COMISD + x86_COMISS + x86_CPUID + x86_CQO + x86_CRC32 + x86_CVTDQ2PD + x86_CVTDQ2PS + x86_CVTPD2DQ + x86_CVTPD2PI + x86_CVTPD2PS + x86_CVTPI2PD + x86_CVTPI2PS + x86_CVTPS2DQ + x86_CVTPS2PD + x86_CVTPS2PI + x86_CVTSD2SI + x86_CVTSD2SS + x86_CVTSI2SD + x86_CVTSI2SS + x86_CVTSS2SD + x86_CVTSS2SI + x86_CVTTPD2DQ + x86_CVTTPD2PI + x86_CVTTPS2DQ + x86_CVTTPS2PI + x86_CVTTSD2SI + x86_CVTTSS2SI + x86_CWD + x86_CWDE + x86_DAA + x86_DAS + x86_DEC + x86_DIV + x86_DIVPD + x86_DIVPS + x86_DIVSD + x86_DIVSS + x86_DPPD + x86_DPPS + x86_EMMS + x86_ENTER + x86_EXTRACTPS + x86_F2XM1 + x86_FABS + x86_FADD + x86_FADDP + x86_FBLD + x86_FBSTP + x86_FCHS + x86_FCMOVB + x86_FCMOVBE + x86_FCMOVE + x86_FCMOVNB + x86_FCMOVNBE + x86_FCMOVNE + x86_FCMOVNU + x86_FCMOVU + x86_FCOM + x86_FCOMI + x86_FCOMIP + x86_FCOMP + x86_FCOMPP + x86_FCOS + x86_FDECSTP + x86_FDIV + x86_FDIVP + x86_FDIVR + x86_FDIVRP + x86_FFREE + x86_FFREEP + x86_FIADD + x86_FICOM + x86_FICOMP + x86_FIDIV + x86_FIDIVR + x86_FILD + x86_FIMUL + x86_FINCSTP + x86_FIST + x86_FISTP + x86_FISTTP + x86_FISUB + x86_FISUBR + x86_FLD + x86_FLD1 + x86_FLDCW + x86_FLDENV + x86_FLDL2E + x86_FLDL2T + x86_FLDLG2 + x86_FLDPI + x86_FMUL + x86_FMULP + x86_FNCLEX + x86_FNINIT + x86_FNOP + x86_FNSAVE + x86_FNSTCW + x86_FNSTENV + x86_FNSTSW + x86_FPATAN + x86_FPREM + x86_FPREM1 + x86_FPTAN + x86_FRNDINT + x86_FRSTOR + x86_FSCALE + x86_FSIN + x86_FSINCOS + x86_FSQRT + x86_FST + x86_FSTP + x86_FSUB + x86_FSUBP + x86_FSUBR + x86_FSUBRP + x86_FTST + x86_FUCOM + x86_FUCOMI + x86_FUCOMIP + x86_FUCOMP + x86_FUCOMPP + x86_FWAIT + x86_FXAM + x86_FXCH + x86_FXRSTOR + x86_FXRSTOR64 + x86_FXSAVE + x86_FXSAVE64 + x86_FXTRACT + x86_FYL2X + x86_FYL2XP1 + x86_HADDPD + x86_HADDPS + x86_HLT + x86_HSUBPD + x86_HSUBPS + x86_ICEBP + x86_IDIV + x86_IMUL + x86_IN + x86_INC + x86_INSB + x86_INSD + x86_INSERTPS + x86_INSW + x86_INT + x86_INTO + x86_INVD + x86_INVLPG + x86_INVPCID + x86_IRET + x86_IRETD + x86_IRETQ + x86_JA + x86_JAE + x86_JB + x86_JBE + x86_JCXZ + x86_JE + x86_JECXZ + x86_JG + x86_JGE + x86_JL + x86_JLE + x86_JMP + x86_JNE + x86_JNO + x86_JNP + x86_JNS + x86_JO + x86_JP + x86_JRCXZ + x86_JS + x86_LAHF + x86_LAR + x86_LCALL + x86_LDDQU + x86_LDMXCSR + x86_LDS + x86_LEA + x86_LEAVE + x86_LES + x86_LFENCE + x86_LFS + x86_LGDT + x86_LGS + x86_LIDT + x86_LJMP + x86_LLDT + x86_LMSW + x86_LODSB + x86_LODSD + x86_LODSQ + x86_LODSW + x86_LOOP + x86_LOOPE + x86_LOOPNE + x86_LRET + x86_LSL + x86_LSS + x86_LTR + x86_LZCNT + x86_MASKMOVDQU + x86_MASKMOVQ + x86_MAXPD + x86_MAXPS + x86_MAXSD + x86_MAXSS + x86_MFENCE + x86_MINPD + x86_MINPS + x86_MINSD + x86_MINSS + x86_MONITOR + x86_MOV + x86_MOVAPD + x86_MOVAPS + x86_MOVBE + x86_MOVD + x86_MOVDDUP + x86_MOVDQ2Q + x86_MOVDQA + x86_MOVDQU + x86_MOVHLPS + x86_MOVHPD + x86_MOVHPS + x86_MOVLHPS + x86_MOVLPD + x86_MOVLPS + x86_MOVMSKPD + x86_MOVMSKPS + x86_MOVNTDQ + x86_MOVNTDQA + x86_MOVNTI + x86_MOVNTPD + x86_MOVNTPS + x86_MOVNTQ + x86_MOVNTSD + x86_MOVNTSS + x86_MOVQ + x86_MOVQ2DQ + x86_MOVSB + x86_MOVSD + x86_MOVSD_XMM + x86_MOVSHDUP + x86_MOVSLDUP + x86_MOVSQ + x86_MOVSS + x86_MOVSW + x86_MOVSX + x86_MOVSXD + x86_MOVUPD + x86_MOVUPS + x86_MOVZX + x86_MPSADBW + x86_MUL + x86_MULPD + x86_MULPS + x86_MULSD + x86_MULSS + x86_MWAIT + x86_NEG + x86_NOP + x86_NOT + x86_OR + x86_ORPD + x86_ORPS + x86_OUT + x86_OUTSB + x86_OUTSD + x86_OUTSW + x86_PABSB + x86_PABSD + x86_PABSW + x86_PACKSSDW + x86_PACKSSWB + x86_PACKUSDW + x86_PACKUSWB + x86_PADDB + x86_PADDD + x86_PADDQ + x86_PADDSB + x86_PADDSW + x86_PADDUSB + x86_PADDUSW + x86_PADDW + x86_PALIGNR + x86_PAND + x86_PANDN + x86_PAUSE + x86_PAVGB + x86_PAVGW + x86_PBLENDVB + x86_PBLENDW + x86_PCLMULQDQ + x86_PCMPEQB + x86_PCMPEQD + x86_PCMPEQQ + x86_PCMPEQW + x86_PCMPESTRI + x86_PCMPESTRM + x86_PCMPGTB + x86_PCMPGTD + x86_PCMPGTQ + x86_PCMPGTW + x86_PCMPISTRI + x86_PCMPISTRM + x86_PEXTRB + x86_PEXTRD + x86_PEXTRQ + x86_PEXTRW + x86_PHADDD + x86_PHADDSW + x86_PHADDW + x86_PHMINPOSUW + x86_PHSUBD + x86_PHSUBSW + x86_PHSUBW + x86_PINSRB + x86_PINSRD + x86_PINSRQ + x86_PINSRW + x86_PMADDUBSW + x86_PMADDWD + x86_PMAXSB + x86_PMAXSD + x86_PMAXSW + x86_PMAXUB + x86_PMAXUD + x86_PMAXUW + x86_PMINSB + x86_PMINSD + x86_PMINSW + x86_PMINUB + x86_PMINUD + x86_PMINUW + x86_PMOVMSKB + x86_PMOVSXBD + x86_PMOVSXBQ + x86_PMOVSXBW + x86_PMOVSXDQ + x86_PMOVSXWD + x86_PMOVSXWQ + x86_PMOVZXBD + x86_PMOVZXBQ + x86_PMOVZXBW + x86_PMOVZXDQ + x86_PMOVZXWD + x86_PMOVZXWQ + x86_PMULDQ + x86_PMULHRSW + x86_PMULHUW + x86_PMULHW + x86_PMULLD + x86_PMULLW + x86_PMULUDQ + x86_POP + x86_POPA + x86_POPAD + x86_POPCNT + x86_POPF + x86_POPFD + x86_POPFQ + x86_POR + x86_PREFETCHNTA + x86_PREFETCHT0 + x86_PREFETCHT1 + x86_PREFETCHT2 + x86_PREFETCHW + x86_PSADBW + x86_PSHUFB + x86_PSHUFD + x86_PSHUFHW + x86_PSHUFLW + x86_PSHUFW + x86_PSIGNB + x86_PSIGND + x86_PSIGNW + x86_PSLLD + x86_PSLLDQ + x86_PSLLQ + x86_PSLLW + x86_PSRAD + x86_PSRAW + x86_PSRLD + x86_PSRLDQ + x86_PSRLQ + x86_PSRLW + x86_PSUBB + x86_PSUBD + x86_PSUBQ + x86_PSUBSB + x86_PSUBSW + x86_PSUBUSB + x86_PSUBUSW + x86_PSUBW + x86_PTEST + x86_PUNPCKHBW + x86_PUNPCKHDQ + x86_PUNPCKHQDQ + x86_PUNPCKHWD + x86_PUNPCKLBW + x86_PUNPCKLDQ + x86_PUNPCKLQDQ + x86_PUNPCKLWD + x86_PUSH + x86_PUSHA + x86_PUSHAD + x86_PUSHF + x86_PUSHFD + x86_PUSHFQ + x86_PXOR + x86_RCL + x86_RCPPS + x86_RCPSS + x86_RCR + x86_RDFSBASE + x86_RDGSBASE + x86_RDMSR + x86_RDPMC + x86_RDRAND + x86_RDTSC + x86_RDTSCP + x86_RET + x86_ROL + x86_ROR + x86_ROUNDPD + x86_ROUNDPS + x86_ROUNDSD + x86_ROUNDSS + x86_RSM + x86_RSQRTPS + x86_RSQRTSS + x86_SAHF + x86_SAR + x86_SBB + x86_SCASB + x86_SCASD + x86_SCASQ + x86_SCASW + x86_SETA + x86_SETAE + x86_SETB + x86_SETBE + x86_SETE + x86_SETG + x86_SETGE + x86_SETL + x86_SETLE + x86_SETNE + x86_SETNO + x86_SETNP + x86_SETNS + x86_SETO + x86_SETP + x86_SETS + x86_SFENCE + x86_SGDT + x86_SHL + x86_SHLD + x86_SHR + x86_SHRD + x86_SHUFPD + x86_SHUFPS + x86_SIDT + x86_SLDT + x86_SMSW + x86_SQRTPD + x86_SQRTPS + x86_SQRTSD + x86_SQRTSS + x86_STC + x86_STD + x86_STI + x86_STMXCSR + x86_STOSB + x86_STOSD + x86_STOSQ + x86_STOSW + x86_STR + x86_SUB + x86_SUBPD + x86_SUBPS + x86_SUBSD + x86_SUBSS + x86_SWAPGS + x86_SYSCALL + x86_SYSENTER + x86_SYSEXIT + x86_SYSRET + x86_TEST + x86_TZCNT + x86_UCOMISD + x86_UCOMISS + x86_UD1 + x86_UD2 + x86_UNPCKHPD + x86_UNPCKHPS + x86_UNPCKLPD + x86_UNPCKLPS + x86_VERR + x86_VERW + x86_WBINVD + x86_WRFSBASE + x86_WRGSBASE + x86_WRMSR + x86_XABORT + x86_XADD + x86_XBEGIN + x86_XCHG + x86_XEND + x86_XGETBV + x86_XLATB + x86_XOR + x86_XORPD + x86_XORPS + x86_XRSTOR + x86_XRSTOR64 + x86_XRSTORS + x86_XRSTORS64 + x86_XSAVE + x86_XSAVE64 + x86_XSAVEC + x86_XSAVEC64 + x86_XSAVEOPT + x86_XSAVEOPT64 + x86_XSAVES + x86_XSAVES64 + x86_XSETBV + x86_XTEST +) + +const x86_maxOp = x86_XTEST + +var x86_opNames = [...]string{ + x86_AAA: "AAA", + x86_AAD: "AAD", + x86_AAM: "AAM", + x86_AAS: "AAS", + x86_ADC: "ADC", + x86_ADD: "ADD", + x86_ADDPD: "ADDPD", + x86_ADDPS: "ADDPS", + x86_ADDSD: "ADDSD", + x86_ADDSS: "ADDSS", + x86_ADDSUBPD: "ADDSUBPD", + x86_ADDSUBPS: "ADDSUBPS", + x86_AESDEC: "AESDEC", + x86_AESDECLAST: "AESDECLAST", + x86_AESENC: "AESENC", + x86_AESENCLAST: "AESENCLAST", + x86_AESIMC: "AESIMC", + x86_AESKEYGENASSIST: "AESKEYGENASSIST", + x86_AND: "AND", + x86_ANDNPD: "ANDNPD", + x86_ANDNPS: "ANDNPS", + x86_ANDPD: "ANDPD", + x86_ANDPS: "ANDPS", + x86_ARPL: "ARPL", + x86_BLENDPD: "BLENDPD", + x86_BLENDPS: "BLENDPS", + x86_BLENDVPD: "BLENDVPD", + x86_BLENDVPS: "BLENDVPS", + x86_BOUND: "BOUND", + x86_BSF: "BSF", + x86_BSR: "BSR", + x86_BSWAP: "BSWAP", + x86_BT: "BT", + x86_BTC: "BTC", + x86_BTR: "BTR", + x86_BTS: "BTS", + x86_CALL: "CALL", + x86_CBW: "CBW", + x86_CDQ: "CDQ", + x86_CDQE: "CDQE", + x86_CLC: "CLC", + x86_CLD: "CLD", + x86_CLFLUSH: "CLFLUSH", + x86_CLI: "CLI", + x86_CLTS: "CLTS", + x86_CMC: "CMC", + x86_CMOVA: "CMOVA", + x86_CMOVAE: "CMOVAE", + x86_CMOVB: "CMOVB", + x86_CMOVBE: "CMOVBE", + x86_CMOVE: "CMOVE", + x86_CMOVG: "CMOVG", + x86_CMOVGE: "CMOVGE", + x86_CMOVL: "CMOVL", + x86_CMOVLE: "CMOVLE", + x86_CMOVNE: "CMOVNE", + x86_CMOVNO: "CMOVNO", + x86_CMOVNP: "CMOVNP", + x86_CMOVNS: "CMOVNS", + x86_CMOVO: "CMOVO", + x86_CMOVP: "CMOVP", + x86_CMOVS: "CMOVS", + x86_CMP: "CMP", + x86_CMPPD: "CMPPD", + x86_CMPPS: "CMPPS", + x86_CMPSB: "CMPSB", + x86_CMPSD: "CMPSD", + x86_CMPSD_XMM: "CMPSD_XMM", + x86_CMPSQ: "CMPSQ", + x86_CMPSS: "CMPSS", + x86_CMPSW: "CMPSW", + x86_CMPXCHG: "CMPXCHG", + x86_CMPXCHG16B: "CMPXCHG16B", + x86_CMPXCHG8B: "CMPXCHG8B", + x86_COMISD: "COMISD", + x86_COMISS: "COMISS", + x86_CPUID: "CPUID", + x86_CQO: "CQO", + x86_CRC32: "CRC32", + x86_CVTDQ2PD: "CVTDQ2PD", + x86_CVTDQ2PS: "CVTDQ2PS", + x86_CVTPD2DQ: "CVTPD2DQ", + x86_CVTPD2PI: "CVTPD2PI", + x86_CVTPD2PS: "CVTPD2PS", + x86_CVTPI2PD: "CVTPI2PD", + x86_CVTPI2PS: "CVTPI2PS", + x86_CVTPS2DQ: "CVTPS2DQ", + x86_CVTPS2PD: "CVTPS2PD", + x86_CVTPS2PI: "CVTPS2PI", + x86_CVTSD2SI: "CVTSD2SI", + x86_CVTSD2SS: "CVTSD2SS", + x86_CVTSI2SD: "CVTSI2SD", + x86_CVTSI2SS: "CVTSI2SS", + x86_CVTSS2SD: "CVTSS2SD", + x86_CVTSS2SI: "CVTSS2SI", + x86_CVTTPD2DQ: "CVTTPD2DQ", + x86_CVTTPD2PI: "CVTTPD2PI", + x86_CVTTPS2DQ: "CVTTPS2DQ", + x86_CVTTPS2PI: "CVTTPS2PI", + x86_CVTTSD2SI: "CVTTSD2SI", + x86_CVTTSS2SI: "CVTTSS2SI", + x86_CWD: "CWD", + x86_CWDE: "CWDE", + x86_DAA: "DAA", + x86_DAS: "DAS", + x86_DEC: "DEC", + x86_DIV: "DIV", + x86_DIVPD: "DIVPD", + x86_DIVPS: "DIVPS", + x86_DIVSD: "DIVSD", + x86_DIVSS: "DIVSS", + x86_DPPD: "DPPD", + x86_DPPS: "DPPS", + x86_EMMS: "EMMS", + x86_ENTER: "ENTER", + x86_EXTRACTPS: "EXTRACTPS", + x86_F2XM1: "F2XM1", + x86_FABS: "FABS", + x86_FADD: "FADD", + x86_FADDP: "FADDP", + x86_FBLD: "FBLD", + x86_FBSTP: "FBSTP", + x86_FCHS: "FCHS", + x86_FCMOVB: "FCMOVB", + x86_FCMOVBE: "FCMOVBE", + x86_FCMOVE: "FCMOVE", + x86_FCMOVNB: "FCMOVNB", + x86_FCMOVNBE: "FCMOVNBE", + x86_FCMOVNE: "FCMOVNE", + x86_FCMOVNU: "FCMOVNU", + x86_FCMOVU: "FCMOVU", + x86_FCOM: "FCOM", + x86_FCOMI: "FCOMI", + x86_FCOMIP: "FCOMIP", + x86_FCOMP: "FCOMP", + x86_FCOMPP: "FCOMPP", + x86_FCOS: "FCOS", + x86_FDECSTP: "FDECSTP", + x86_FDIV: "FDIV", + x86_FDIVP: "FDIVP", + x86_FDIVR: "FDIVR", + x86_FDIVRP: "FDIVRP", + x86_FFREE: "FFREE", + x86_FFREEP: "FFREEP", + x86_FIADD: "FIADD", + x86_FICOM: "FICOM", + x86_FICOMP: "FICOMP", + x86_FIDIV: "FIDIV", + x86_FIDIVR: "FIDIVR", + x86_FILD: "FILD", + x86_FIMUL: "FIMUL", + x86_FINCSTP: "FINCSTP", + x86_FIST: "FIST", + x86_FISTP: "FISTP", + x86_FISTTP: "FISTTP", + x86_FISUB: "FISUB", + x86_FISUBR: "FISUBR", + x86_FLD: "FLD", + x86_FLD1: "FLD1", + x86_FLDCW: "FLDCW", + x86_FLDENV: "FLDENV", + x86_FLDL2E: "FLDL2E", + x86_FLDL2T: "FLDL2T", + x86_FLDLG2: "FLDLG2", + x86_FLDPI: "FLDPI", + x86_FMUL: "FMUL", + x86_FMULP: "FMULP", + x86_FNCLEX: "FNCLEX", + x86_FNINIT: "FNINIT", + x86_FNOP: "FNOP", + x86_FNSAVE: "FNSAVE", + x86_FNSTCW: "FNSTCW", + x86_FNSTENV: "FNSTENV", + x86_FNSTSW: "FNSTSW", + x86_FPATAN: "FPATAN", + x86_FPREM: "FPREM", + x86_FPREM1: "FPREM1", + x86_FPTAN: "FPTAN", + x86_FRNDINT: "FRNDINT", + x86_FRSTOR: "FRSTOR", + x86_FSCALE: "FSCALE", + x86_FSIN: "FSIN", + x86_FSINCOS: "FSINCOS", + x86_FSQRT: "FSQRT", + x86_FST: "FST", + x86_FSTP: "FSTP", + x86_FSUB: "FSUB", + x86_FSUBP: "FSUBP", + x86_FSUBR: "FSUBR", + x86_FSUBRP: "FSUBRP", + x86_FTST: "FTST", + x86_FUCOM: "FUCOM", + x86_FUCOMI: "FUCOMI", + x86_FUCOMIP: "FUCOMIP", + x86_FUCOMP: "FUCOMP", + x86_FUCOMPP: "FUCOMPP", + x86_FWAIT: "FWAIT", + x86_FXAM: "FXAM", + x86_FXCH: "FXCH", + x86_FXRSTOR: "FXRSTOR", + x86_FXRSTOR64: "FXRSTOR64", + x86_FXSAVE: "FXSAVE", + x86_FXSAVE64: "FXSAVE64", + x86_FXTRACT: "FXTRACT", + x86_FYL2X: "FYL2X", + x86_FYL2XP1: "FYL2XP1", + x86_HADDPD: "HADDPD", + x86_HADDPS: "HADDPS", + x86_HLT: "HLT", + x86_HSUBPD: "HSUBPD", + x86_HSUBPS: "HSUBPS", + x86_ICEBP: "ICEBP", + x86_IDIV: "IDIV", + x86_IMUL: "IMUL", + x86_IN: "IN", + x86_INC: "INC", + x86_INSB: "INSB", + x86_INSD: "INSD", + x86_INSERTPS: "INSERTPS", + x86_INSW: "INSW", + x86_INT: "INT", + x86_INTO: "INTO", + x86_INVD: "INVD", + x86_INVLPG: "INVLPG", + x86_INVPCID: "INVPCID", + x86_IRET: "IRET", + x86_IRETD: "IRETD", + x86_IRETQ: "IRETQ", + x86_JA: "JA", + x86_JAE: "JAE", + x86_JB: "JB", + x86_JBE: "JBE", + x86_JCXZ: "JCXZ", + x86_JE: "JE", + x86_JECXZ: "JECXZ", + x86_JG: "JG", + x86_JGE: "JGE", + x86_JL: "JL", + x86_JLE: "JLE", + x86_JMP: "JMP", + x86_JNE: "JNE", + x86_JNO: "JNO", + x86_JNP: "JNP", + x86_JNS: "JNS", + x86_JO: "JO", + x86_JP: "JP", + x86_JRCXZ: "JRCXZ", + x86_JS: "JS", + x86_LAHF: "LAHF", + x86_LAR: "LAR", + x86_LCALL: "LCALL", + x86_LDDQU: "LDDQU", + x86_LDMXCSR: "LDMXCSR", + x86_LDS: "LDS", + x86_LEA: "LEA", + x86_LEAVE: "LEAVE", + x86_LES: "LES", + x86_LFENCE: "LFENCE", + x86_LFS: "LFS", + x86_LGDT: "LGDT", + x86_LGS: "LGS", + x86_LIDT: "LIDT", + x86_LJMP: "LJMP", + x86_LLDT: "LLDT", + x86_LMSW: "LMSW", + x86_LODSB: "LODSB", + x86_LODSD: "LODSD", + x86_LODSQ: "LODSQ", + x86_LODSW: "LODSW", + x86_LOOP: "LOOP", + x86_LOOPE: "LOOPE", + x86_LOOPNE: "LOOPNE", + x86_LRET: "LRET", + x86_LSL: "LSL", + x86_LSS: "LSS", + x86_LTR: "LTR", + x86_LZCNT: "LZCNT", + x86_MASKMOVDQU: "MASKMOVDQU", + x86_MASKMOVQ: "MASKMOVQ", + x86_MAXPD: "MAXPD", + x86_MAXPS: "MAXPS", + x86_MAXSD: "MAXSD", + x86_MAXSS: "MAXSS", + x86_MFENCE: "MFENCE", + x86_MINPD: "MINPD", + x86_MINPS: "MINPS", + x86_MINSD: "MINSD", + x86_MINSS: "MINSS", + x86_MONITOR: "MONITOR", + x86_MOV: "MOV", + x86_MOVAPD: "MOVAPD", + x86_MOVAPS: "MOVAPS", + x86_MOVBE: "MOVBE", + x86_MOVD: "MOVD", + x86_MOVDDUP: "MOVDDUP", + x86_MOVDQ2Q: "MOVDQ2Q", + x86_MOVDQA: "MOVDQA", + x86_MOVDQU: "MOVDQU", + x86_MOVHLPS: "MOVHLPS", + x86_MOVHPD: "MOVHPD", + x86_MOVHPS: "MOVHPS", + x86_MOVLHPS: "MOVLHPS", + x86_MOVLPD: "MOVLPD", + x86_MOVLPS: "MOVLPS", + x86_MOVMSKPD: "MOVMSKPD", + x86_MOVMSKPS: "MOVMSKPS", + x86_MOVNTDQ: "MOVNTDQ", + x86_MOVNTDQA: "MOVNTDQA", + x86_MOVNTI: "MOVNTI", + x86_MOVNTPD: "MOVNTPD", + x86_MOVNTPS: "MOVNTPS", + x86_MOVNTQ: "MOVNTQ", + x86_MOVNTSD: "MOVNTSD", + x86_MOVNTSS: "MOVNTSS", + x86_MOVQ: "MOVQ", + x86_MOVQ2DQ: "MOVQ2DQ", + x86_MOVSB: "MOVSB", + x86_MOVSD: "MOVSD", + x86_MOVSD_XMM: "MOVSD_XMM", + x86_MOVSHDUP: "MOVSHDUP", + x86_MOVSLDUP: "MOVSLDUP", + x86_MOVSQ: "MOVSQ", + x86_MOVSS: "MOVSS", + x86_MOVSW: "MOVSW", + x86_MOVSX: "MOVSX", + x86_MOVSXD: "MOVSXD", + x86_MOVUPD: "MOVUPD", + x86_MOVUPS: "MOVUPS", + x86_MOVZX: "MOVZX", + x86_MPSADBW: "MPSADBW", + x86_MUL: "MUL", + x86_MULPD: "MULPD", + x86_MULPS: "MULPS", + x86_MULSD: "MULSD", + x86_MULSS: "MULSS", + x86_MWAIT: "MWAIT", + x86_NEG: "NEG", + x86_NOP: "NOP", + x86_NOT: "NOT", + x86_OR: "OR", + x86_ORPD: "ORPD", + x86_ORPS: "ORPS", + x86_OUT: "OUT", + x86_OUTSB: "OUTSB", + x86_OUTSD: "OUTSD", + x86_OUTSW: "OUTSW", + x86_PABSB: "PABSB", + x86_PABSD: "PABSD", + x86_PABSW: "PABSW", + x86_PACKSSDW: "PACKSSDW", + x86_PACKSSWB: "PACKSSWB", + x86_PACKUSDW: "PACKUSDW", + x86_PACKUSWB: "PACKUSWB", + x86_PADDB: "PADDB", + x86_PADDD: "PADDD", + x86_PADDQ: "PADDQ", + x86_PADDSB: "PADDSB", + x86_PADDSW: "PADDSW", + x86_PADDUSB: "PADDUSB", + x86_PADDUSW: "PADDUSW", + x86_PADDW: "PADDW", + x86_PALIGNR: "PALIGNR", + x86_PAND: "PAND", + x86_PANDN: "PANDN", + x86_PAUSE: "PAUSE", + x86_PAVGB: "PAVGB", + x86_PAVGW: "PAVGW", + x86_PBLENDVB: "PBLENDVB", + x86_PBLENDW: "PBLENDW", + x86_PCLMULQDQ: "PCLMULQDQ", + x86_PCMPEQB: "PCMPEQB", + x86_PCMPEQD: "PCMPEQD", + x86_PCMPEQQ: "PCMPEQQ", + x86_PCMPEQW: "PCMPEQW", + x86_PCMPESTRI: "PCMPESTRI", + x86_PCMPESTRM: "PCMPESTRM", + x86_PCMPGTB: "PCMPGTB", + x86_PCMPGTD: "PCMPGTD", + x86_PCMPGTQ: "PCMPGTQ", + x86_PCMPGTW: "PCMPGTW", + x86_PCMPISTRI: "PCMPISTRI", + x86_PCMPISTRM: "PCMPISTRM", + x86_PEXTRB: "PEXTRB", + x86_PEXTRD: "PEXTRD", + x86_PEXTRQ: "PEXTRQ", + x86_PEXTRW: "PEXTRW", + x86_PHADDD: "PHADDD", + x86_PHADDSW: "PHADDSW", + x86_PHADDW: "PHADDW", + x86_PHMINPOSUW: "PHMINPOSUW", + x86_PHSUBD: "PHSUBD", + x86_PHSUBSW: "PHSUBSW", + x86_PHSUBW: "PHSUBW", + x86_PINSRB: "PINSRB", + x86_PINSRD: "PINSRD", + x86_PINSRQ: "PINSRQ", + x86_PINSRW: "PINSRW", + x86_PMADDUBSW: "PMADDUBSW", + x86_PMADDWD: "PMADDWD", + x86_PMAXSB: "PMAXSB", + x86_PMAXSD: "PMAXSD", + x86_PMAXSW: "PMAXSW", + x86_PMAXUB: "PMAXUB", + x86_PMAXUD: "PMAXUD", + x86_PMAXUW: "PMAXUW", + x86_PMINSB: "PMINSB", + x86_PMINSD: "PMINSD", + x86_PMINSW: "PMINSW", + x86_PMINUB: "PMINUB", + x86_PMINUD: "PMINUD", + x86_PMINUW: "PMINUW", + x86_PMOVMSKB: "PMOVMSKB", + x86_PMOVSXBD: "PMOVSXBD", + x86_PMOVSXBQ: "PMOVSXBQ", + x86_PMOVSXBW: "PMOVSXBW", + x86_PMOVSXDQ: "PMOVSXDQ", + x86_PMOVSXWD: "PMOVSXWD", + x86_PMOVSXWQ: "PMOVSXWQ", + x86_PMOVZXBD: "PMOVZXBD", + x86_PMOVZXBQ: "PMOVZXBQ", + x86_PMOVZXBW: "PMOVZXBW", + x86_PMOVZXDQ: "PMOVZXDQ", + x86_PMOVZXWD: "PMOVZXWD", + x86_PMOVZXWQ: "PMOVZXWQ", + x86_PMULDQ: "PMULDQ", + x86_PMULHRSW: "PMULHRSW", + x86_PMULHUW: "PMULHUW", + x86_PMULHW: "PMULHW", + x86_PMULLD: "PMULLD", + x86_PMULLW: "PMULLW", + x86_PMULUDQ: "PMULUDQ", + x86_POP: "POP", + x86_POPA: "POPA", + x86_POPAD: "POPAD", + x86_POPCNT: "POPCNT", + x86_POPF: "POPF", + x86_POPFD: "POPFD", + x86_POPFQ: "POPFQ", + x86_POR: "POR", + x86_PREFETCHNTA: "PREFETCHNTA", + x86_PREFETCHT0: "PREFETCHT0", + x86_PREFETCHT1: "PREFETCHT1", + x86_PREFETCHT2: "PREFETCHT2", + x86_PREFETCHW: "PREFETCHW", + x86_PSADBW: "PSADBW", + x86_PSHUFB: "PSHUFB", + x86_PSHUFD: "PSHUFD", + x86_PSHUFHW: "PSHUFHW", + x86_PSHUFLW: "PSHUFLW", + x86_PSHUFW: "PSHUFW", + x86_PSIGNB: "PSIGNB", + x86_PSIGND: "PSIGND", + x86_PSIGNW: "PSIGNW", + x86_PSLLD: "PSLLD", + x86_PSLLDQ: "PSLLDQ", + x86_PSLLQ: "PSLLQ", + x86_PSLLW: "PSLLW", + x86_PSRAD: "PSRAD", + x86_PSRAW: "PSRAW", + x86_PSRLD: "PSRLD", + x86_PSRLDQ: "PSRLDQ", + x86_PSRLQ: "PSRLQ", + x86_PSRLW: "PSRLW", + x86_PSUBB: "PSUBB", + x86_PSUBD: "PSUBD", + x86_PSUBQ: "PSUBQ", + x86_PSUBSB: "PSUBSB", + x86_PSUBSW: "PSUBSW", + x86_PSUBUSB: "PSUBUSB", + x86_PSUBUSW: "PSUBUSW", + x86_PSUBW: "PSUBW", + x86_PTEST: "PTEST", + x86_PUNPCKHBW: "PUNPCKHBW", + x86_PUNPCKHDQ: "PUNPCKHDQ", + x86_PUNPCKHQDQ: "PUNPCKHQDQ", + x86_PUNPCKHWD: "PUNPCKHWD", + x86_PUNPCKLBW: "PUNPCKLBW", + x86_PUNPCKLDQ: "PUNPCKLDQ", + x86_PUNPCKLQDQ: "PUNPCKLQDQ", + x86_PUNPCKLWD: "PUNPCKLWD", + x86_PUSH: "PUSH", + x86_PUSHA: "PUSHA", + x86_PUSHAD: "PUSHAD", + x86_PUSHF: "PUSHF", + x86_PUSHFD: "PUSHFD", + x86_PUSHFQ: "PUSHFQ", + x86_PXOR: "PXOR", + x86_RCL: "RCL", + x86_RCPPS: "RCPPS", + x86_RCPSS: "RCPSS", + x86_RCR: "RCR", + x86_RDFSBASE: "RDFSBASE", + x86_RDGSBASE: "RDGSBASE", + x86_RDMSR: "RDMSR", + x86_RDPMC: "RDPMC", + x86_RDRAND: "RDRAND", + x86_RDTSC: "RDTSC", + x86_RDTSCP: "RDTSCP", + x86_RET: "RET", + x86_ROL: "ROL", + x86_ROR: "ROR", + x86_ROUNDPD: "ROUNDPD", + x86_ROUNDPS: "ROUNDPS", + x86_ROUNDSD: "ROUNDSD", + x86_ROUNDSS: "ROUNDSS", + x86_RSM: "RSM", + x86_RSQRTPS: "RSQRTPS", + x86_RSQRTSS: "RSQRTSS", + x86_SAHF: "SAHF", + x86_SAR: "SAR", + x86_SBB: "SBB", + x86_SCASB: "SCASB", + x86_SCASD: "SCASD", + x86_SCASQ: "SCASQ", + x86_SCASW: "SCASW", + x86_SETA: "SETA", + x86_SETAE: "SETAE", + x86_SETB: "SETB", + x86_SETBE: "SETBE", + x86_SETE: "SETE", + x86_SETG: "SETG", + x86_SETGE: "SETGE", + x86_SETL: "SETL", + x86_SETLE: "SETLE", + x86_SETNE: "SETNE", + x86_SETNO: "SETNO", + x86_SETNP: "SETNP", + x86_SETNS: "SETNS", + x86_SETO: "SETO", + x86_SETP: "SETP", + x86_SETS: "SETS", + x86_SFENCE: "SFENCE", + x86_SGDT: "SGDT", + x86_SHL: "SHL", + x86_SHLD: "SHLD", + x86_SHR: "SHR", + x86_SHRD: "SHRD", + x86_SHUFPD: "SHUFPD", + x86_SHUFPS: "SHUFPS", + x86_SIDT: "SIDT", + x86_SLDT: "SLDT", + x86_SMSW: "SMSW", + x86_SQRTPD: "SQRTPD", + x86_SQRTPS: "SQRTPS", + x86_SQRTSD: "SQRTSD", + x86_SQRTSS: "SQRTSS", + x86_STC: "STC", + x86_STD: "STD", + x86_STI: "STI", + x86_STMXCSR: "STMXCSR", + x86_STOSB: "STOSB", + x86_STOSD: "STOSD", + x86_STOSQ: "STOSQ", + x86_STOSW: "STOSW", + x86_STR: "STR", + x86_SUB: "SUB", + x86_SUBPD: "SUBPD", + x86_SUBPS: "SUBPS", + x86_SUBSD: "SUBSD", + x86_SUBSS: "SUBSS", + x86_SWAPGS: "SWAPGS", + x86_SYSCALL: "SYSCALL", + x86_SYSENTER: "SYSENTER", + x86_SYSEXIT: "SYSEXIT", + x86_SYSRET: "SYSRET", + x86_TEST: "TEST", + x86_TZCNT: "TZCNT", + x86_UCOMISD: "UCOMISD", + x86_UCOMISS: "UCOMISS", + x86_UD1: "UD1", + x86_UD2: "UD2", + x86_UNPCKHPD: "UNPCKHPD", + x86_UNPCKHPS: "UNPCKHPS", + x86_UNPCKLPD: "UNPCKLPD", + x86_UNPCKLPS: "UNPCKLPS", + x86_VERR: "VERR", + x86_VERW: "VERW", + x86_WBINVD: "WBINVD", + x86_WRFSBASE: "WRFSBASE", + x86_WRGSBASE: "WRGSBASE", + x86_WRMSR: "WRMSR", + x86_XABORT: "XABORT", + x86_XADD: "XADD", + x86_XBEGIN: "XBEGIN", + x86_XCHG: "XCHG", + x86_XEND: "XEND", + x86_XGETBV: "XGETBV", + x86_XLATB: "XLATB", + x86_XOR: "XOR", + x86_XORPD: "XORPD", + x86_XORPS: "XORPS", + x86_XRSTOR: "XRSTOR", + x86_XRSTOR64: "XRSTOR64", + x86_XRSTORS: "XRSTORS", + x86_XRSTORS64: "XRSTORS64", + x86_XSAVE: "XSAVE", + x86_XSAVE64: "XSAVE64", + x86_XSAVEC: "XSAVEC", + x86_XSAVEC64: "XSAVEC64", + x86_XSAVEOPT: "XSAVEOPT", + x86_XSAVEOPT64: "XSAVEOPT64", + x86_XSAVES: "XSAVES", + x86_XSAVES64: "XSAVES64", + x86_XSETBV: "XSETBV", + x86_XTEST: "XTEST", +} |