--- /dev/null
+// 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",
+}