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