Use mod vendor for vendored directory (backwards compatible)

7 files changed, 0 insertions, 14124 deletions

diff --git a/vendor/golang.org/x/arch/x86/x86asm/LICENSE b/vendor/golang.org/x/arch/x86/x86asm/LICENSE
deleted file mode 100644
index d29b3726..00000000
--- a/vendor/golang.org/x/arch/x86/x86asm/LICENSE
+++ /dev/null
@@ -1,27 +0,0 @@
-Copyright (c) 2015 The Go Authors. All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are
-met:
-
-   * Redistributions of source code must retain the above copyright
-notice, this list of conditions and the following disclaimer.
-   * Redistributions in binary form must reproduce the above
-copyright notice, this list of conditions and the following disclaimer
-in the documentation and/or other materials provided with the
-distribution.
-   * Neither the name of Google Inc. nor the names of its
-contributors may be used to endorse or promote products derived from
-this software without specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/vendor/golang.org/x/arch/x86/x86asm/decode.go b/vendor/golang.org/x/arch/x86/x86asm/decode.go
deleted file mode 100644
index 148870b7..00000000
--- a/vendor/golang.org/x/arch/x86/x86asm/decode.go
+++ /dev/null
@@ -1,1724 +0,0 @@
-// 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 x86asm
-
-import (
-	"encoding/binary"
-	"errors"
-	"fmt"
-	"runtime"
-)
-
-// 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 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 decodeOp uint16
-
-const (
-	xFail  decodeOp = iota // invalid instruction (return)
-	xMatch                 // completed match
-	xJump                  // jump to pc
-
-	xCondByte     // switch on instruction byte value
-	xCondSlashR   // read and switch on instruction /r value
-	xCondPrefix   // switch on presence of instruction prefix
-	xCondIs64     // switch on 64-bit processor mode
-	xCondDataSize // switch on operand size
-	xCondAddrSize // switch on address size
-	xCondIsMem    // switch on memory vs register argument
-
-	xSetOp // set instruction opcode
-
-	xReadSlashR // read /r
-	xReadIb     // read ib
-	xReadIw     // read iw
-	xReadId     // read id
-	xReadIo     // read io
-	xReadCb     // read cb
-	xReadCw     // read cw
-	xReadCd     // read cd
-	xReadCp     // read cp
-	xReadCm     // read cm
-
-	xArg1            // arg 1
-	xArg3            // arg 3
-	xArgAL           // arg AL
-	xArgAX           // arg AX
-	xArgCL           // arg CL
-	xArgCR0dashCR7   // arg CR0-CR7
-	xArgCS           // arg CS
-	xArgDR0dashDR7   // arg DR0-DR7
-	xArgDS           // arg DS
-	xArgDX           // arg DX
-	xArgEAX          // arg EAX
-	xArgEDX          // arg EDX
-	xArgES           // arg ES
-	xArgFS           // arg FS
-	xArgGS           // arg GS
-	xArgImm16        // arg imm16
-	xArgImm32        // arg imm32
-	xArgImm64        // arg imm64
-	xArgImm8         // arg imm8
-	xArgImm8u        // arg imm8 but record as unsigned
-	xArgImm16u       // arg imm8 but record as unsigned
-	xArgM            // arg m
-	xArgM128         // arg m128
-	xArgM256         // arg m256
-	xArgM1428byte    // arg m14/28byte
-	xArgM16          // arg m16
-	xArgM16and16     // arg m16&16
-	xArgM16and32     // arg m16&32
-	xArgM16and64     // arg m16&64
-	xArgM16colon16   // arg m16:16
-	xArgM16colon32   // arg m16:32
-	xArgM16colon64   // arg m16:64
-	xArgM16int       // arg m16int
-	xArgM2byte       // arg m2byte
-	xArgM32          // arg m32
-	xArgM32and32     // arg m32&32
-	xArgM32fp        // arg m32fp
-	xArgM32int       // arg m32int
-	xArgM512byte     // arg m512byte
-	xArgM64          // arg m64
-	xArgM64fp        // arg m64fp
-	xArgM64int       // arg m64int
-	xArgM8           // arg m8
-	xArgM80bcd       // arg m80bcd
-	xArgM80dec       // arg m80dec
-	xArgM80fp        // arg m80fp
-	xArgM94108byte   // arg m94/108byte
-	xArgMm           // arg mm
-	xArgMm1          // arg mm1
-	xArgMm2          // arg mm2
-	xArgMm2M64       // arg mm2/m64
-	xArgMmM32        // arg mm/m32
-	xArgMmM64        // arg mm/m64
-	xArgMem          // arg mem
-	xArgMoffs16      // arg moffs16
-	xArgMoffs32      // arg moffs32
-	xArgMoffs64      // arg moffs64
-	xArgMoffs8       // arg moffs8
-	xArgPtr16colon16 // arg ptr16:16
-	xArgPtr16colon32 // arg ptr16:32
-	xArgR16          // arg r16
-	xArgR16op        // arg r16 with +rw in opcode
-	xArgR32          // arg r32
-	xArgR32M16       // arg r32/m16
-	xArgR32M8        // arg r32/m8
-	xArgR32op        // arg r32 with +rd in opcode
-	xArgR64          // arg r64
-	xArgR64M16       // arg r64/m16
-	xArgR64op        // arg r64 with +rd in opcode
-	xArgR8           // arg r8
-	xArgR8op         // arg r8 with +rb in opcode
-	xArgRAX          // arg RAX
-	xArgRDX          // arg RDX
-	xArgRM           // arg r/m
-	xArgRM16         // arg r/m16
-	xArgRM32         // arg r/m32
-	xArgRM64         // arg r/m64
-	xArgRM8          // arg r/m8
-	xArgReg          // arg reg
-	xArgRegM16       // arg reg/m16
-	xArgRegM32       // arg reg/m32
-	xArgRegM8        // arg reg/m8
-	xArgRel16        // arg rel16
-	xArgRel32        // arg rel32
-	xArgRel8         // arg rel8
-	xArgSS           // arg SS
-	xArgST           // arg ST, aka ST(0)
-	xArgSTi          // arg ST(i) with +i in opcode
-	xArgSreg         // arg Sreg
-	xArgTR0dashTR7   // arg TR0-TR7
-	xArgXmm          // arg xmm
-	xArgXMM0         // arg <XMM0>
-	xArgXmm1         // arg xmm1
-	xArgXmm2         // arg xmm2
-	xArgXmm2M128     // arg xmm2/m128
-	xArgYmm2M256     // arg ymm2/m256
-	xArgXmm2M16      // arg xmm2/m16
-	xArgXmm2M32      // arg xmm2/m32
-	xArgXmm2M64      // arg xmm2/m64
-	xArgXmmM128      // arg xmm/m128
-	xArgXmmM32       // arg xmm/m32
-	xArgXmmM64       // arg xmm/m64
-	xArgYmm1         // arg ymm1
-	xArgRmf16        // arg r/m16 but force mod=3
-	xArgRmf32        // arg r/m32 but force mod=3
-	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 instPrefix(b byte, mode int) (Inst, error) {
-	// When tracing it is useful to see what called instPrefix to report an error.
-	if trace {
-		_, file, line, _ := runtime.Caller(1)
-		fmt.Printf("%s:%d\n", file, line)
-	}
-	p := Prefix(b)
-	switch p {
-	case PrefixDataSize:
-		if mode == 16 {
-			p = PrefixData32
-		} else {
-			p = PrefixData16
-		}
-	case PrefixAddrSize:
-		if mode == 32 {
-			p = PrefixAddr16
-		} else {
-			p = PrefixAddr32
-		}
-	}
-	// Note: using composite literal with Prefix key confuses 'bundle' tool.
-	inst := Inst{Len: 1}
-	inst.Prefix = 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 truncated(src []byte, mode int) (Inst, error) {
-	//	return Inst{}, len(src), ErrTruncated
-	return instPrefix(src[0], mode) // too long
-}
-
-// These are the errors returned by Decode.
-var (
-	ErrInvalidMode  = errors.New("invalid x86 mode in Decode")
-	ErrTruncated    = errors.New("truncated instruction")
-	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 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 Decode(src []byte, mode int) (inst Inst, err error) {
-	return 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 decode1(src []byte, mode int, gnuCompat bool) (Inst, error) {
-	switch mode {
-	case 16, 32, 64:
-		// ok
-		// TODO(rsc): 64-bit mode not tested, probably not working.
-	default:
-		return Inst{}, 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           Prefix // rex byte if present (or 0)
-		rexUsed       Prefix // bits used in rex byte
-		rexIndex      = -1   // index of rex byte
-		vex           Prefix // use vex encoding
-		vexIndex      = -1   // index of vex prefix
-
-		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     Mem
-		haveMem bool
-
-		// decoded SIB fields
-		haveSIB bool
-		sib     int
-		scale   int
-		index   int
-		base    int
-		displen int
-		dispoff int
-
-		// decoded immediate values
-		imm     int64
-		imm8    int8
-		immc    int64
-		immcpos int
-
-		// output
-		opshift int
-		inst    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 := 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] |= PrefixIgnored
-			}
-			lockIndex = pos
-		case 0xF2, 0xF3:
-			if repIndex >= 0 {
-				inst.Prefix[repIndex] |= PrefixIgnored
-			}
-			repIndex = pos
-
-		// Group 2 - segment override / branch hints
-		case 0x26, 0x2E, 0x36, 0x3E:
-			if mode == 64 {
-				p |= PrefixIgnored
-				break
-			}
-			fallthrough
-		case 0x64, 0x65:
-			if segIndex >= 0 {
-				inst.Prefix[segIndex] |= PrefixIgnored
-			}
-			segIndex = pos
-
-		// Group 3 - operand size override
-		case 0x66:
-			if mode == 16 {
-				dataMode = 32
-				p = PrefixData32
-			} else {
-				dataMode = 16
-				p = PrefixData16
-			}
-			if dataSizeIndex >= 0 {
-				inst.Prefix[dataSizeIndex] |= PrefixIgnored
-			}
-			dataSizeIndex = pos
-
-		// Group 4 - address size override
-		case 0x67:
-			if mode == 32 {
-				addrMode = 16
-				p = PrefixAddr16
-			} else {
-				addrMode = 32
-				p = PrefixAddr32
-			}
-			if addrSizeIndex >= 0 {
-				inst.Prefix[addrSizeIndex] |= PrefixIgnored
-			}
-			addrSizeIndex = pos
-
-		//Group 5 - Vex encoding
-		case 0xC5:
-			if pos == 0 && (mode == 64 || (mode == 32 && pos+1 < len(src) && src[pos+1]&0xc0 == 0xc0)) {
-				vex = p
-				vexIndex = pos
-				inst.Prefix[pos] = p
-				inst.Prefix[pos+1] = Prefix(src[pos+1])
-				pos += 1
-				continue
-			} else {
-				nprefix = pos
-				break ReadPrefixes
-			}
-		case 0xC4:
-			if pos == 0 && (mode == 64 || (mode == 32 && pos+2 < len(src) && src[pos+1]&0xc0 == 0xc0)) {
-				vex = p
-				vexIndex = pos
-				inst.Prefix[pos] = p
-				inst.Prefix[pos+1] = Prefix(src[pos+1])
-				inst.Prefix[pos+2] = Prefix(src[pos+2])
-				pos += 2
-				continue
-			} else {
-				nprefix = pos
-				break ReadPrefixes
-			}
-		}
-
-		if pos >= len(inst.Prefix) {
-			return instPrefix(src[0], mode) // too long
-		}
-
-		inst.Prefix[pos] = p
-	}
-
-	// Read REX prefix.
-	if pos < len(src) && mode == 64 && Prefix(src[pos]).IsREX() && vex == 0 {
-		rex = Prefix(src[pos])
-		rexIndex = pos
-		if pos >= len(inst.Prefix) {
-			return instPrefix(src[0], mode) // too long
-		}
-		inst.Prefix[pos] = rex
-		pos++
-		if rex&PrefixREXW != 0 {
-			dataMode = 64
-			if dataSizeIndex >= 0 {
-				inst.Prefix[dataSizeIndex] |= 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 decoderCover == nil {
-		decoderCover = make([]bool, len(decoder))
-	}
-
-	// Decode loop, executing decoder program.
-	var oldPC, prevPC int
-Decode:
-	for pc := 1; ; { // TODO uint
-		oldPC = prevPC
-		prevPC = pc
-		if trace {
-			println("run", pc)
-		}
-		x := decoder[pc]
-		decoderCover[pc] = true
-		pc++
-
-		// Read and decode ModR/M if needed by opcode.
-		switch decodeOp(x) {
-		case xCondSlashR, xReadSlashR:
-			if haveModrm {
-				return Inst{Len: pos}, errInternal
-			}
-			haveModrm = true
-			if pos >= len(src) {
-				return 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&PrefixREXR != 0 {
-				rexUsed |= PrefixREXR
-				regop |= 8
-			}
-			if addrMode == 16 {
-				// 16-bit modrm form
-				if mod != 3 {
-					haveMem = true
-					mem = 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 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 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 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&PrefixREXB != 0 || vex == 0xC4 && inst.Prefix[vexIndex+1]&0x20 == 0 {
-						rexUsed |= PrefixREXB
-						base |= 8
-					}
-					if rex&PrefixREXX != 0 || vex == 0xC4 && inst.Prefix[vexIndex+1]&0x40 == 0 {
-						rexUsed |= PrefixREXX
-						index |= 8
-					}
-
-					mem.Scale = 1 << uint(scale)
-					if index == 4 {
-						// no mem.Index
-					} else {
-						mem.Index = baseRegForBits(addrMode) + Reg(index)
-					}
-					if base&7 == 5 && mod == 0 {
-						// no mem.Base
-					} else {
-						mem.Base = baseRegForBits(addrMode) + Reg(base)
-					}
-				} else {
-					if rex&PrefixREXB != 0 {
-						rexUsed |= PrefixREXB
-						rm |= 8
-					}
-					if mod == 0 && rm&7 == 5 || rm&7 == 4 {
-						// base omitted
-					} else if mod != 3 {
-						mem.Base = baseRegForBits(addrMode) + Reg(rm)
-					}
-				}
-
-				// Consume disp32 if present.
-				if mod == 0 && (rm&7 == 5 || haveSIB && base&7 == 5) || mod == 2 {
-					if pos+4 > len(src) {
-						return truncated(src, mode)
-					}
-					dispoff = pos
-					displen = 4
-					mem.Disp = int64(binary.LittleEndian.Uint32(src[pos:]))
-					pos += 4
-				}
-
-				// Consume disp8 if present.
-				if mod == 1 {
-					if pos >= len(src) {
-						return truncated(src, mode)
-					}
-					dispoff = pos
-					displen = 1
-					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 = EIP
-					} else {
-						mem.Base = RIP
-					}
-				}
-			}
-
-			if segIndex >= 0 {
-				mem.Segment = prefixToSegment(inst.Prefix[segIndex])
-			}
-		}
-
-		// Execute single opcode.
-		switch decodeOp(x) {
-		default:
-			println("bad op", x, "at", pc-1, "from", oldPC)
-			return Inst{Len: pos}, errInternal
-
-		case xFail:
-			inst.Op = 0
-			break Decode
-
-		case xMatch:
-			break Decode
-
-		case xJump:
-			pc = int(decoder[pc])
-
-		// Conditional branches.
-
-		case xCondByte:
-			if pos >= len(src) {
-				return truncated(src, mode)
-			}
-			b := src[pos]
-			n := int(decoder[pc])
-			pc++
-			for i := 0; i < n; i++ {
-				xb, xpc := decoder[pc], int(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 decodeOp(decoder[pc]) == xJump {
-				pc = int(decoder[pc+1])
-			}
-			if decodeOp(decoder[pc]) == xFail {
-				pos++
-			}
-
-		case xCondIs64:
-			if mode == 64 {
-				pc = int(decoder[pc+1])
-			} else {
-				pc = int(decoder[pc])
-			}
-
-		case xCondIsMem:
-			mem := haveMem
-			if !haveModrm {
-				if pos >= len(src) {
-					return instPrefix(src[0], mode) // too long
-				}
-				mem = src[pos]>>6 != 3
-			}
-			if mem {
-				pc = int(decoder[pc+1])
-			} else {
-				pc = int(decoder[pc])
-			}
-
-		case xCondDataSize:
-			switch dataMode {
-			case 16:
-				if dataSizeIndex >= 0 {
-					inst.Prefix[dataSizeIndex] |= PrefixImplicit
-				}
-				pc = int(decoder[pc])
-			case 32:
-				if dataSizeIndex >= 0 {
-					inst.Prefix[dataSizeIndex] |= PrefixImplicit
-				}
-				pc = int(decoder[pc+1])
-			case 64:
-				rexUsed |= PrefixREXW
-				pc = int(decoder[pc+2])
-			}
-
-		case xCondAddrSize:
-			switch addrMode {
-			case 16:
-				if addrSizeIndex >= 0 {
-					inst.Prefix[addrSizeIndex] |= PrefixImplicit
-				}
-				pc = int(decoder[pc])
-			case 32:
-				if addrSizeIndex >= 0 {
-					inst.Prefix[addrSizeIndex] |= PrefixImplicit
-				}
-				pc = int(decoder[pc+1])
-			case 64:
-				pc = int(decoder[pc+2])
-			}
-
-		case 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(decoder[pc])
-			pc++
-			sawF3 := false
-			for j := 0; j < n; j++ {
-				prefix := Prefix(decoder[pc+2*j])
-				if prefix.IsREX() {
-					rexUsed |= prefix
-					if rex&prefix == prefix {
-						pc = int(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 == 0xC5 || prefix == 0xC4 {
-					if vex == prefix {
-						ok = true
-					}
-				} else if vex != 0 && (prefix == 0x0F || prefix == 0x0F38 || prefix == 0x0F3A ||
-					prefix == 0x66 || prefix == 0xF2 || prefix == 0xF3) {
-					var vexM, vexP Prefix
-					if vex == 0xC5 {
-						vexM = 1 // 2 byte vex always implies 0F
-						vexP = inst.Prefix[vexIndex+1]
-					} else {
-						vexM = inst.Prefix[vexIndex+1]
-						vexP = inst.Prefix[vexIndex+2]
-					}
-					switch prefix {
-					case 0x66:
-						ok = vexP&3 == 1
-					case 0xF3:
-						ok = vexP&3 == 2
-					case 0xF2:
-						ok = vexP&3 == 3
-					case 0x0F:
-						ok = vexM&3 == 1
-					case 0x0F38:
-						ok = vexM&3 == 2
-					case 0x0F3A:
-						ok = vexM&3 == 3
-					}
-				} else {
-					if prefix == 0xF3 {
-						sawF3 = true
-					}
-					switch prefix {
-					case PrefixLOCK:
-						if lockIndex >= 0 {
-							inst.Prefix[lockIndex] |= PrefixImplicit
-							ok = true
-						}
-					case PrefixREP, PrefixREPN:
-						if repIndex >= 0 && inst.Prefix[repIndex]&0xFF == prefix {
-							inst.Prefix[repIndex] |= PrefixImplicit
-							ok = true
-						}
-						if gnuCompat && !ok && prefix == 0xF3 && repIndex >= 0 && (j+1 >= n || 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] |= 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] |= PrefixImplicit
-									ok = true
-								}
-							}
-						}
-					case PrefixCS, PrefixDS, PrefixES, PrefixFS, PrefixGS, PrefixSS:
-						if segIndex >= 0 && inst.Prefix[segIndex]&0xFF == prefix {
-							inst.Prefix[segIndex] |= PrefixImplicit
-							ok = true
-						}
-					case 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] |= PrefixImplicit
-							ok = true
-						}
-					case PrefixAddrSize:
-						if addrSizeIndex >= 0 {
-							inst.Prefix[addrSizeIndex] |= PrefixImplicit
-							ok = true
-						}
-					}
-				}
-				if ok {
-					pc = int(decoder[pc+2*j+1])
-					continue Decode
-				}
-			}
-			inst.Op = 0
-			break Decode
-
-		case xCondSlashR:
-			pc = int(decoder[pc+regop&7])
-
-		// Input.
-
-		case xReadSlashR:
-			// done above
-
-		case xReadIb:
-			if pos >= len(src) {
-				return truncated(src, mode)
-			}
-			imm8 = int8(src[pos])
-			pos++
-
-		case xReadIw:
-			if pos+2 > len(src) {
-				return truncated(src, mode)
-			}
-			imm = int64(binary.LittleEndian.Uint16(src[pos:]))
-			pos += 2
-
-		case xReadId:
-			if pos+4 > len(src) {
-				return truncated(src, mode)
-			}
-			imm = int64(binary.LittleEndian.Uint32(src[pos:]))
-			pos += 4
-
-		case xReadIo:
-			if pos+8 > len(src) {
-				return truncated(src, mode)
-			}
-			imm = int64(binary.LittleEndian.Uint64(src[pos:]))
-			pos += 8
-
-		case xReadCb:
-			if pos >= len(src) {
-				return truncated(src, mode)
-			}
-			immcpos = pos
-			immc = int64(src[pos])
-			pos++
-
-		case xReadCw:
-			if pos+2 > len(src) {
-				return truncated(src, mode)
-			}
-			immcpos = pos
-			immc = int64(binary.LittleEndian.Uint16(src[pos:]))
-			pos += 2
-
-		case xReadCm:
-			immcpos = pos
-			if addrMode == 16 {
-				if pos+2 > len(src) {
-					return truncated(src, mode)
-				}
-				immc = int64(binary.LittleEndian.Uint16(src[pos:]))
-				pos += 2
-			} else if addrMode == 32 {
-				if pos+4 > len(src) {
-					return truncated(src, mode)
-				}
-				immc = int64(binary.LittleEndian.Uint32(src[pos:]))
-				pos += 4
-			} else {
-				if pos+8 > len(src) {
-					return truncated(src, mode)
-				}
-				immc = int64(binary.LittleEndian.Uint64(src[pos:]))
-				pos += 8
-			}
-		case xReadCd:
-			immcpos = pos
-			if pos+4 > len(src) {
-				return truncated(src, mode)
-			}
-			immc = int64(binary.LittleEndian.Uint32(src[pos:]))
-			pos += 4
-
-		case xReadCp:
-			immcpos = pos
-			if pos+6 > len(src) {
-				return 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 xSetOp:
-			inst.Op = Op(decoder[pc])
-			pc++
-
-		case xArg1,
-			xArg3,
-			xArgAL,
-			xArgAX,
-			xArgCL,
-			xArgCS,
-			xArgDS,
-			xArgDX,
-			xArgEAX,
-			xArgEDX,
-			xArgES,
-			xArgFS,
-			xArgGS,
-			xArgRAX,
-			xArgRDX,
-			xArgSS,
-			xArgST,
-			xArgXMM0:
-			inst.Args[narg] = fixedArg[x]
-			narg++
-
-		case xArgImm8:
-			inst.Args[narg] = Imm(imm8)
-			narg++
-
-		case xArgImm8u:
-			inst.Args[narg] = Imm(uint8(imm8))
-			narg++
-
-		case xArgImm16:
-			inst.Args[narg] = Imm(int16(imm))
-			narg++
-
-		case xArgImm16u:
-			inst.Args[narg] = Imm(uint16(imm))
-			narg++
-
-		case xArgImm32:
-			inst.Args[narg] = Imm(int32(imm))
-			narg++
-
-		case xArgImm64:
-			inst.Args[narg] = Imm(imm)
-			narg++
-
-		case xArgM,
-			xArgM128,
-			xArgM256,
-			xArgM1428byte,
-			xArgM16,
-			xArgM16and16,
-			xArgM16and32,
-			xArgM16and64,
-			xArgM16colon16,
-			xArgM16colon32,
-			xArgM16colon64,
-			xArgM16int,
-			xArgM2byte,
-			xArgM32,
-			xArgM32and32,
-			xArgM32fp,
-			xArgM32int,
-			xArgM512byte,
-			xArgM64,
-			xArgM64fp,
-			xArgM64int,
-			xArgM8,
-			xArgM80bcd,
-			xArgM80dec,
-			xArgM80fp,
-			xArgM94108byte,
-			xArgMem:
-			if !haveMem {
-				inst.Op = 0
-				break Decode
-			}
-			inst.Args[narg] = mem
-			inst.MemBytes = int(memBytes[decodeOp(x)])
-			if mem.Base == RIP {
-				inst.PCRel = displen
-				inst.PCRelOff = dispoff
-			}
-			narg++
-
-		case xArgPtr16colon16:
-			inst.Args[narg] = Imm(immc >> 16)
-			inst.Args[narg+1] = Imm(immc & (1<<16 - 1))
-			narg += 2
-
-		case xArgPtr16colon32:
-			inst.Args[narg] = Imm(immc >> 32)
-			inst.Args[narg+1] = Imm(immc & (1<<32 - 1))
-			narg += 2
-
-		case xArgMoffs8, xArgMoffs16, xArgMoffs32, xArgMoffs64:
-			// TODO(rsc): Can address be 64 bits?
-			mem = Mem{Disp: int64(immc)}
-			if segIndex >= 0 {
-				mem.Segment = prefixToSegment(inst.Prefix[segIndex])
-				inst.Prefix[segIndex] |= PrefixImplicit
-			}
-			inst.Args[narg] = mem
-			inst.MemBytes = int(memBytes[decodeOp(x)])
-			if mem.Base == RIP {
-				inst.PCRel = displen
-				inst.PCRelOff = dispoff
-			}
-			narg++
-
-		case xArgYmm1:
-			base := baseReg[x]
-			index := Reg(regop)
-			if inst.Prefix[vexIndex+1]&0x80 == 0 {
-				index += 8
-			}
-			inst.Args[narg] = base + index
-			narg++
-
-		case xArgR8, xArgR16, xArgR32, xArgR64, xArgXmm, xArgXmm1, xArgDR0dashDR7:
-			base := baseReg[x]
-			index := Reg(regop)
-			if rex != 0 && base == AL && index >= 4 {
-				rexUsed |= PrefixREX
-				index -= 4
-				base = SPB
-			}
-			inst.Args[narg] = base + index
-			narg++
-
-		case xArgMm, xArgMm1, xArgTR0dashTR7:
-			inst.Args[narg] = baseReg[x] + Reg(regop&7)
-			narg++
-
-		case 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] |= PrefixImplicit
-				regop += 8
-			}
-			inst.Args[narg] = CR0 + Reg(regop)
-			narg++
-
-		case xArgSreg:
-			regop &= 7
-			if regop >= 6 {
-				inst.Op = 0
-				break Decode
-			}
-			inst.Args[narg] = ES + Reg(regop)
-			narg++
-
-		case xArgRmf16, xArgRmf32, xArgRmf64:
-			base := baseReg[x]
-			index := Reg(modrm & 07)
-			if rex&PrefixREXB != 0 {
-				rexUsed |= PrefixREXB
-				index += 8
-			}
-			inst.Args[narg] = base + index
-			narg++
-
-		case xArgR8op, xArgR16op, xArgR32op, xArgR64op, xArgSTi:
-			n := inst.Opcode >> uint(opshift+8) & 07
-			base := baseReg[x]
-			index := Reg(n)
-			if rex&PrefixREXB != 0 && decodeOp(x) != xArgSTi {
-				rexUsed |= PrefixREXB
-				index += 8
-			}
-			if rex != 0 && base == AL && index >= 4 {
-				rexUsed |= PrefixREX
-				index -= 4
-				base = SPB
-			}
-			inst.Args[narg] = base + index
-			narg++
-		case xArgRM8, xArgRM16, xArgRM32, xArgRM64, xArgR32M16, xArgR32M8, xArgR64M16,
-			xArgMmM32, xArgMmM64, xArgMm2M64,
-			xArgXmm2M16, xArgXmm2M32, xArgXmm2M64, xArgXmmM64, xArgXmmM128, xArgXmmM32, xArgXmm2M128,
-			xArgYmm2M256:
-			if haveMem {
-				inst.Args[narg] = mem
-				inst.MemBytes = int(memBytes[decodeOp(x)])
-				if mem.Base == RIP {
-					inst.PCRel = displen
-					inst.PCRelOff = dispoff
-				}
-			} else {
-				base := baseReg[x]
-				index := Reg(rm)
-				switch decodeOp(x) {
-				case xArgMmM32, xArgMmM64, xArgMm2M64:
-					// There are only 8 MMX registers, so these ignore the REX.X bit.
-					index &= 7
-				case xArgRM8:
-					if rex != 0 && index >= 4 {
-						rexUsed |= PrefixREX
-						index -= 4
-						base = SPB
-					}
-				case xArgYmm2M256:
-					if vex == 0xC4 && inst.Prefix[vexIndex+1]&0x40 == 0x40 {
-						index += 8
-					}
-				}
-				inst.Args[narg] = base + index
-			}
-			narg++
-
-		case xArgMm2: // register only; TODO(rsc): Handle with tag modrm_regonly tag
-			if haveMem {
-				inst.Op = 0
-				break Decode
-			}
-			inst.Args[narg] = baseReg[x] + Reg(rm&7)
-			narg++
-
-		case xArgXmm2: // register only; TODO(rsc): Handle with tag modrm_regonly tag
-			if haveMem {
-				inst.Op = 0
-				break Decode
-			}
-			inst.Args[narg] = baseReg[x] + Reg(rm)
-			narg++
-
-		case xArgRel8:
-			inst.PCRelOff = immcpos
-			inst.PCRel = 1
-			inst.Args[narg] = Rel(int8(immc))
-			narg++
-
-		case xArgRel16:
-			inst.PCRelOff = immcpos
-			inst.PCRel = 2
-			inst.Args[narg] = Rel(int16(immc))
-			narg++
-
-		case xArgRel32:
-			inst.PCRelOff = immcpos
-			inst.PCRel = 4
-			inst.Args[narg] = Rel(int32(immc))
-			narg++
-		}
-	}
-
-	if inst.Op == 0 {
-		// Invalid instruction.
-		if nprefix > 0 {
-			return instPrefix(src[0], mode) // invalid instruction
-		}
-		return Inst{Len: pos}, 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 == XCHG && inst.Opcode>>24 == 0x90 {
-		if inst.Args[0] == RAX || inst.Args[0] == EAX || inst.Args[0] == AX {
-			inst.Op = NOP
-			if dataSizeIndex >= 0 {
-				inst.Prefix[dataSizeIndex] &^= PrefixImplicit
-			}
-			inst.Args[0] = nil
-			inst.Args[1] = nil
-		}
-		if repIndex >= 0 && inst.Prefix[repIndex] == 0xF3 {
-			inst.Prefix[repIndex] |= PrefixImplicit
-			inst.Op = 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] |= PrefixImplicit
-					inst.Op = 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() Reg {
-		if segIndex >= 0 {
-			inst.Prefix[segIndex] |= PrefixImplicit
-			return prefixToSegment(inst.Prefix[segIndex])
-		}
-		return 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 INSB, INSW, INSD:
-		inst.Args[0] = Mem{Segment: ES, Base: baseRegForBits(addrMode) + DI - AX}
-		inst.Args[1] = DX
-		usedAddrSize = true
-
-	case OUTSB, OUTSW, OUTSD:
-		inst.Args[0] = DX
-		inst.Args[1] = Mem{Segment: defaultSeg(), Base: baseRegForBits(addrMode) + SI - AX}
-		usedAddrSize = true
-
-	case MOVSB, MOVSW, MOVSD, MOVSQ:
-		inst.Args[0] = Mem{Segment: ES, Base: baseRegForBits(addrMode) + DI - AX}
-		inst.Args[1] = Mem{Segment: defaultSeg(), Base: baseRegForBits(addrMode) + SI - AX}
-		usedAddrSize = true
-
-	case CMPSB, CMPSW, CMPSD, CMPSQ:
-		inst.Args[0] = Mem{Segment: defaultSeg(), Base: baseRegForBits(addrMode) + SI - AX}
-		inst.Args[1] = Mem{Segment: ES, Base: baseRegForBits(addrMode) + DI - AX}
-		usedAddrSize = true
-
-	case LODSB, LODSW, LODSD, LODSQ:
-		switch inst.Op {
-		case LODSB:
-			inst.Args[0] = AL
-		case LODSW:
-			inst.Args[0] = AX
-		case LODSD:
-			inst.Args[0] = EAX
-		case LODSQ:
-			inst.Args[0] = RAX
-		}
-		inst.Args[1] = Mem{Segment: defaultSeg(), Base: baseRegForBits(addrMode) + SI - AX}
-		usedAddrSize = true
-
-	case STOSB, STOSW, STOSD, STOSQ:
-		inst.Args[0] = Mem{Segment: ES, Base: baseRegForBits(addrMode) + DI - AX}
-		switch inst.Op {
-		case STOSB:
-			inst.Args[1] = AL
-		case STOSW:
-			inst.Args[1] = AX
-		case STOSD:
-			inst.Args[1] = EAX
-		case STOSQ:
-			inst.Args[1] = RAX
-		}
-		usedAddrSize = true
-
-	case SCASB, SCASW, SCASD, SCASQ:
-		inst.Args[1] = Mem{Segment: ES, Base: baseRegForBits(addrMode) + DI - AX}
-		switch inst.Op {
-		case SCASB:
-			inst.Args[0] = AL
-		case SCASW:
-			inst.Args[0] = AX
-		case SCASD:
-			inst.Args[0] = EAX
-		case SCASQ:
-			inst.Args[0] = RAX
-		}
-		usedAddrSize = true
-
-	case XLATB:
-		inst.Args[0] = Mem{Segment: defaultSeg(), Base: baseRegForBits(addrMode) + BX - 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] |= 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] |= 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 isCondJmp[inst.Op] || isLoop[inst.Op] || inst.Op == JCXZ || inst.Op == JECXZ || inst.Op == JRCXZ {
-	PredictLoop:
-		for i := nprefix - 1; i >= 0; i-- {
-			p := inst.Prefix[i]
-			switch p & 0xFF {
-			case PrefixCS:
-				inst.Prefix[i] = PrefixPN
-				break PredictLoop
-			case PrefixDS:
-				inst.Prefix[i] = 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 isCondJmp[inst.Op] || inst.Op == JMP || inst.Op == CALL || inst.Op == RET {
-		for i := nprefix - 1; i >= 0; i-- {
-			p := inst.Prefix[i]
-			if p&^PrefixIgnored == PrefixREPN {
-				inst.Prefix[i] = 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]&PrefixImplicit == 0 {
-		switch inst.Op {
-		// TODO(rsc): Perhaps this instruction class should be derived from the CSV.
-		case ADD, ADC, AND, BTC, BTR, BTS, CMPXCHG, CMPXCHG8B, CMPXCHG16B, DEC, INC, NEG, NOT, OR, SBB, SUB, XOR, XADD, XCHG:
-			if isMem(inst.Args[0]) {
-				hasLock = true
-				break
-			}
-			fallthrough
-		default:
-			inst.Prefix[lockIndex] |= 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 isMem(inst.Args[0]) {
-		if inst.Op == XCHG {
-			hasLock = true
-		}
-
-		for i := len(inst.Prefix) - 1; i >= 0; i-- {
-			p := inst.Prefix[i] &^ PrefixIgnored
-			switch p {
-			case PrefixREPN:
-				if hasLock {
-					inst.Prefix[i] = inst.Prefix[i]&PrefixIgnored | PrefixXACQUIRE
-				}
-
-			case PrefixREP:
-				if hasLock {
-					inst.Prefix[i] = inst.Prefix[i]&PrefixIgnored | PrefixXRELEASE
-				}
-
-				if inst.Op == MOV {
-					op := (inst.Opcode >> 24) &^ 1
-					if op == 0x88 || op == 0xC6 {
-						inst.Prefix[i] = inst.Prefix[i]&PrefixIgnored | PrefixXRELEASE
-					}
-				}
-			}
-		}
-	}
-
-	// If REP is used on a non-REP-able instruction, mark the prefix as ignored.
-	if repIndex >= 0 {
-		switch inst.Prefix[repIndex] {
-		case PrefixREP, 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 INSB, INSW, INSD,
-				MOVSB, MOVSW, MOVSD, MOVSQ,
-				OUTSB, OUTSW, OUTSD,
-				LODSB, LODSW, LODSD, LODSQ,
-				CMPSB, CMPSW, CMPSD, CMPSQ,
-				SCASB, SCASW, SCASD, SCASQ,
-				STOSB, STOSW, STOSD, STOSQ:
-				// ok
-			default:
-				inst.Prefix[repIndex] |= PrefixIgnored
-			}
-		}
-	}
-
-	// If REX was present, mark implicit if all the 1 bits were consumed.
-	if rexIndex >= 0 {
-		if rexUsed != 0 {
-			rexUsed |= PrefixREX
-		}
-		if rex&^rexUsed == 0 {
-			inst.Prefix[rexIndex] |= PrefixImplicit
-		}
-	}
-
-	inst.DataSize = dataMode
-	inst.AddrSize = addrMode
-	inst.Mode = mode
-	inst.Len = pos
-	return inst, nil
-}
-
-var errInternal = errors.New("internal error")
-
-// addr16 records the eight 16-bit addressing modes.
-var addr16 = [8]Mem{
-	{Base: BX, Scale: 1, Index: SI},
-	{Base: BX, Scale: 1, Index: DI},
-	{Base: BP, Scale: 1, Index: SI},
-	{Base: BP, Scale: 1, Index: DI},
-	{Base: SI},
-	{Base: DI},
-	{Base: BP},
-	{Base: BX},
-}
-
-// baseReg returns the base register for a given register size in bits.
-func baseRegForBits(bits int) Reg {
-	switch bits {
-	case 8:
-		return AL
-	case 16:
-		return AX
-	case 32:
-		return EAX
-	case 64:
-		return RAX
-	}
-	return 0
-}
-
-// baseReg records the base register for argument types that specify
-// a range of registers indexed by op, regop, or rm.
-var baseReg = [...]Reg{
-	xArgDR0dashDR7: DR0,
-	xArgMm1:        M0,
-	xArgMm2:        M0,
-	xArgMm2M64:     M0,
-	xArgMm:         M0,
-	xArgMmM32:      M0,
-	xArgMmM64:      M0,
-	xArgR16:        AX,
-	xArgR16op:      AX,
-	xArgR32:        EAX,
-	xArgR32M16:     EAX,
-	xArgR32M8:      EAX,
-	xArgR32op:      EAX,
-	xArgR64:        RAX,
-	xArgR64M16:     RAX,
-	xArgR64op:      RAX,
-	xArgR8:         AL,
-	xArgR8op:       AL,
-	xArgRM16:       AX,
-	xArgRM32:       EAX,
-	xArgRM64:       RAX,
-	xArgRM8:        AL,
-	xArgRmf16:      AX,
-	xArgRmf32:      EAX,
-	xArgRmf64:      RAX,
-	xArgSTi:        F0,
-	xArgTR0dashTR7: TR0,
-	xArgXmm1:       X0,
-	xArgYmm1:       X0,
-	xArgXmm2:       X0,
-	xArgXmm2M128:   X0,
-	xArgYmm2M256:   X0,
-	xArgXmm2M16:    X0,
-	xArgXmm2M32:    X0,
-	xArgXmm2M64:    X0,
-	xArgXmm:        X0,
-	xArgXmmM128:    X0,
-	xArgXmmM32:     X0,
-	xArgXmmM64:     X0,
-}
-
-// prefixToSegment returns the segment register
-// corresponding to a particular segment prefix.
-func prefixToSegment(p Prefix) Reg {
-	switch p &^ PrefixImplicit {
-	case PrefixCS:
-		return CS
-	case PrefixDS:
-		return DS
-	case PrefixES:
-		return ES
-	case PrefixFS:
-		return FS
-	case PrefixGS:
-		return GS
-	case PrefixSS:
-		return SS
-	}
-	return 0
-}
-
-// fixedArg records the fixed arguments corresponding to the given bytecodes.
-var fixedArg = [...]Arg{
-	xArg1:    Imm(1),
-	xArg3:    Imm(3),
-	xArgAL:   AL,
-	xArgAX:   AX,
-	xArgDX:   DX,
-	xArgEAX:  EAX,
-	xArgEDX:  EDX,
-	xArgRAX:  RAX,
-	xArgRDX:  RDX,
-	xArgCL:   CL,
-	xArgCS:   CS,
-	xArgDS:   DS,
-	xArgES:   ES,
-	xArgFS:   FS,
-	xArgGS:   GS,
-	xArgSS:   SS,
-	xArgST:   F0,
-	xArgXMM0: X0,
-}
-
-// memBytes records the size of the memory pointed at
-// by a memory argument of the given form.
-var memBytes = [...]int8{
-	xArgM128:       128 / 8,
-	xArgM256:       256 / 8,
-	xArgM16:        16 / 8,
-	xArgM16and16:   (16 + 16) / 8,
-	xArgM16colon16: (16 + 16) / 8,
-	xArgM16colon32: (16 + 32) / 8,
-	xArgM16int:     16 / 8,
-	xArgM2byte:     2,
-	xArgM32:        32 / 8,
-	xArgM32and32:   (32 + 32) / 8,
-	xArgM32fp:      32 / 8,
-	xArgM32int:     32 / 8,
-	xArgM64:        64 / 8,
-	xArgM64fp:      64 / 8,
-	xArgM64int:     64 / 8,
-	xArgMm2M64:     64 / 8,
-	xArgMmM32:      32 / 8,
-	xArgMmM64:      64 / 8,
-	xArgMoffs16:    16 / 8,
-	xArgMoffs32:    32 / 8,
-	xArgMoffs64:    64 / 8,
-	xArgMoffs8:     8 / 8,
-	xArgR32M16:     16 / 8,
-	xArgR32M8:      8 / 8,
-	xArgR64M16:     16 / 8,
-	xArgRM16:       16 / 8,
-	xArgRM32:       32 / 8,
-	xArgRM64:       64 / 8,
-	xArgRM8:        8 / 8,
-	xArgXmm2M128:   128 / 8,
-	xArgYmm2M256:   256 / 8,
-	xArgXmm2M16:    16 / 8,
-	xArgXmm2M32:    32 / 8,
-	xArgXmm2M64:    64 / 8,
-	xArgXmm:        128 / 8,
-	xArgXmmM128:    128 / 8,
-	xArgXmmM32:     32 / 8,
-	xArgXmmM64:     64 / 8,
-}
-
-// isCondJmp records the conditional jumps.
-var isCondJmp = [maxOp + 1]bool{
-	JA:  true,
-	JAE: true,
-	JB:  true,
-	JBE: true,
-	JE:  true,
-	JG:  true,
-	JGE: true,
-	JL:  true,
-	JLE: true,
-	JNE: true,
-	JNO: true,
-	JNP: true,
-	JNS: true,
-	JO:  true,
-	JP:  true,
-	JS:  true,
-}
-
-// isLoop records the loop operators.
-var isLoop = [maxOp + 1]bool{
-	LOOP:   true,
-	LOOPE:  true,
-	LOOPNE: true,
-	JECXZ:  true,
-	JRCXZ:  true,
-}
diff --git a/vendor/golang.org/x/arch/x86/x86asm/gnu.go b/vendor/golang.org/x/arch/x86/x86asm/gnu.go
deleted file mode 100644
index 728e5d18..00000000
--- a/vendor/golang.org/x/arch/x86/x86asm/gnu.go
+++ /dev/null
@@ -1,928 +0,0 @@
-// 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
-
-import (
-	"fmt"
-	"strings"
-)
-
-// 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 GNUSyntax(inst 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 FDIV, FDIVR, FSUB, FSUBR, FDIVP, FDIVRP, FSUBP, 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].(Reg)
-		_, reg2 := inst.Args[1].(Reg)
-		if reg1 && reg2 && (inst.Opcode>>24 == 0xDC || inst.Opcode>>24 == 0xDE) {
-			switch inst.Op {
-			case FDIV:
-				inst.Op = FDIVR
-			case FDIVR:
-				inst.Op = FDIV
-			case FSUB:
-				inst.Op = FSUBR
-			case FSUBR:
-				inst.Op = FSUB
-			case FDIVP:
-				inst.Op = FDIVRP
-			case FDIVRP:
-				inst.Op = FDIVP
-			case FSUBP:
-				inst.Op = FSUBRP
-			case FSUBRP:
-				inst.Op = FSUBP
-			}
-		}
-
-	case 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 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] |= PrefixImplicit
-					}
-				case 0xF2:
-					inst.Prefix[i] &^= PrefixImplicit
-				}
-			}
-			inst.Op = MOVNTSS
-		}
-	}
-
-	// Add implicit arguments.
-	switch inst.Op {
-	case MONITOR:
-		inst.Args[0] = EDX
-		inst.Args[1] = ECX
-		inst.Args[2] = EAX
-		if inst.AddrSize == 16 {
-			inst.Args[2] = AX
-		}
-
-	case MWAIT:
-		if inst.Mode == 64 {
-			inst.Args[0] = RCX
-			inst.Args[1] = RAX
-		} else {
-			inst.Args[0] = ECX
-			inst.Args[1] = 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 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 countPrefix(&inst, 0xF2) > 1 {
-			unmarkImplicit(&inst, 0xF2)
-			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.
-		unmarkImplicit(&inst, PrefixDataSize)
-		markLastImplicit(&inst, PrefixDataSize)
-
-	case CVTSI2SD, CVTSI2SS:
-		if !isMem(inst.Args[1]) {
-			markLastImplicit(&inst, PrefixDataSize)
-		}
-
-	case CVTSD2SI, CVTSS2SI, CVTTSD2SI, CVTTSS2SI,
-		ENTER, FLDENV, FNSAVE, FNSTENV, FRSTOR, LGDT, LIDT, LRET,
-		POP, PUSH, RET, SGDT, SIDT, SYSRET, XBEGIN:
-		markLastImplicit(&inst, PrefixDataSize)
-
-	case LOOP, LOOPE, LOOPNE, MONITOR:
-		markLastImplicit(&inst, PrefixAddrSize)
-
-	case 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].(Reg)
-		src, _ := inst.Args[1].(Reg)
-		if ES <= src && src <= GS && isMem(inst.Args[0]) || ES <= dst && dst <= GS && isMem(inst.Args[1]) {
-			unmarkImplicit(&inst, PrefixDataSize)
-		}
-
-	case MOVDQU:
-		if countPrefix(&inst, 0xF3) > 1 {
-			unmarkImplicit(&inst, 0xF3)
-			markLastImplicit(&inst, 0xF3)
-		}
-
-	case MOVQ2DQ:
-		markLastImplicit(&inst, PrefixDataSize)
-
-	case SLDT, SMSW, STR, FXRSTOR, XRSTOR, XSAVE, XSAVEOPT, CMPXCHG8B:
-		if isMem(inst.Args[0]) {
-			unmarkImplicit(&inst, PrefixDataSize)
-		}
-
-	case SYSEXIT:
-		unmarkImplicit(&inst, PrefixDataSize)
-	}
-
-	if isCondJmp[inst.Op] || isLoop[inst.Op] || inst.Op == JCXZ || inst.Op == JECXZ || inst.Op == JRCXZ {
-		if countPrefix(&inst, PrefixCS) > 0 && countPrefix(&inst, PrefixDS) > 0 {
-			for i, p := range inst.Prefix {
-				switch p & 0xFFF {
-				case PrefixPN, PrefixPT:
-					inst.Prefix[i] &= 0xF0FF // cut interpretation bits, producing original segment prefix
-				}
-			}
-		}
-	}
-
-	// XACQUIRE/XRELEASE adjustment.
-	if inst.Op == 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] &^ PrefixIgnored {
-			case PrefixREPN:
-				haveREPN = true
-			case PrefixXRELEASE:
-				if haveREPN {
-					inst.Prefix[i] = 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] &^ PrefixIgnored {
-		case PrefixXRELEASE:
-			if !haveXR {
-				haveXR = true
-			} else {
-				inst.Prefix[i] = PrefixREP
-			}
-
-		case PrefixXACQUIRE:
-			if !haveXA {
-				haveXA = true
-			} else {
-				inst.Prefix[i] = PrefixREPN
-			}
-		}
-	}
-
-	// Determine opcode.
-	op := strings.ToLower(inst.Op.String())
-	if alt := 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 Reg:
-			switch inst.Op {
-			case MOVSX, MOVZX:
-				continue
-
-			case SHL, SHR, RCL, RCR, ROL, ROR, SAR:
-				if i == 1 {
-					// shift count does not tell us operand size
-					continue
-				}
-
-			case CRC32:
-				// The source argument does tell us operand size,
-				// but libopcodes still always puts a suffix on crc32.
-				continue
-
-			case PUSH, 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 ES <= a && a <= GS {
-					continue
-				}
-
-			case CVTSI2SD, CVTSI2SS:
-				// The integer register argument takes priority.
-				if X0 <= a && a <= X15 {
-					continue
-				}
-			}
-
-			if AL <= a && a <= R15 || ES <= a && a <= GS || X0 <= a && a <= X15 || M0 <= a && a <= M7 {
-				needSuffix = false
-				break SuffixLoop
-			}
-		}
-	}
-
-	if needSuffix {
-		switch inst.Op {
-		case CMPXCHG8B, FLDCW, FNSTCW, FNSTSW, LDMXCSR, LLDT, LMSW, LTR, PCLMULQDQ,
-			SETA, SETAE, SETB, SETBE, SETE, SETG, SETGE, SETL, SETLE, SETNE, SETNO, SETNP, SETNS, SETO, SETP, SETS,
-			SLDT, SMSW, STMXCSR, STR, VERR, VERW:
-			// For various reasons, libopcodes emits no suffix for these instructions.
-
-		case CRC32:
-			op += byteSizeSuffix(argBytes(&inst, inst.Args[1]))
-
-		case LGDT, LIDT, SGDT, SIDT:
-			op += byteSizeSuffix(inst.DataSize / 8)
-
-		case MOVZX, MOVSX:
-			// Integer size conversions get two suffixes.
-			op = op[:4] + byteSizeSuffix(argBytes(&inst, inst.Args[1])) + byteSizeSuffix(argBytes(&inst, inst.Args[0]))
-
-		case LOOP, LOOPE, LOOPNE:
-			// Add w suffix to indicate use of CX register instead of ECX.
-			if inst.AddrSize == 16 {
-				op += "w"
-			}
-
-		case CALL, ENTER, JMP, LCALL, LEAVE, LJMP, LRET, RET, SYSRET, 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 {
-				markLastImplicit(&inst, PrefixDataSize)
-				op += "w"
-			} else if inst.Mode == 64 {
-				op += "q"
-			}
-
-		case FRSTOR, FNSAVE, FNSTENV, FLDENV:
-			// Add s suffix to indicate shortened FPU state (I guess).
-			if inst.DataSize == 16 {
-				op += "s"
-			}
-
-		case PUSH, POP:
-			if markLastImplicit(&inst, PrefixDataSize) {
-				op += byteSizeSuffix(inst.DataSize / 8)
-			} else if inst.Mode == 64 {
-				op += "q"
-			} else {
-				op += byteSizeSuffix(inst.MemBytes)
-			}
-
-		default:
-			if isFloat(inst.Op) {
-				// I can't explain any of this, but it's what libopcodes does.
-				switch inst.MemBytes {
-				default:
-					if (inst.Op == FLD || inst.Op == FSTP) && isMem(inst.Args[0]) {
-						op += "t"
-					}
-				case 4:
-					if isFloatInt(inst.Op) {
-						op += "l"
-					} else {
-						op += "s"
-					}
-				case 8:
-					if isFloatInt(inst.Op) {
-						op += "ll"
-					} else {
-						op += "l"
-					}
-				}
-				break
-			}
-
-			op += 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 INT:
-		if inst.Opcode>>24 == 0xCC {
-			inst.Args[0] = nil
-			op = "int3"
-		}
-
-	case CMPPS, CMPPD, CMPSD_XMM, CMPSS:
-		imm, ok := inst.Args[2].(Imm)
-		if ok && 0 <= imm && imm < 8 {
-			inst.Args[2] = nil
-			op = cmppsOps[imm] + op[3:]
-		}
-
-	case PCLMULQDQ:
-		imm, ok := inst.Args[2].(Imm)
-		if ok && imm&^0x11 == 0 {
-			inst.Args[2] = nil
-			op = pclmulqOps[(imm&0x10)>>3|(imm&1)]
-		}
-
-	case XLATB:
-		if markLastImplicit(&inst, 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 MOVSB, MOVSW, MOVSD, MOVSQ, OUTSB, OUTSW, OUTSD:
-			if i == 0 {
-				usedPrefixes = true // disable use of prefixes for first argument
-			} else {
-				usedPrefixes = false
-			}
-		}
-		if a == Imm(1) && (inst.Opcode>>24)&^1 == 0xD0 {
-			continue
-		}
-		args = append(args, 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 BOUND, LCALL, ENTER, 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 == PrefixDataSize && p&PrefixImplicit != 0 {
-			implicitData = true
-		}
-	}
-	for _, p := range inst.Prefix {
-		if p == 0 || p.IsVEX() {
-			break
-		}
-		if p&PrefixImplicit != 0 {
-			continue
-		}
-		switch p &^ (PrefixIgnored | PrefixInvalid) {
-		default:
-			if p.IsREX() {
-				if p&0xFF == PrefixREX {
-					prefix += "rex "
-				} else {
-					prefix += "rex." + p.String()[4:] + " "
-				}
-				break
-			}
-			prefix += strings.ToLower(p.String()) + " "
-
-		case PrefixPN:
-			op += ",pn"
-			continue
-
-		case PrefixPT:
-			op += ",pt"
-			continue
-
-		case PrefixAddrSize, PrefixAddr16, 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 countPrefix(&inst, PrefixAddrSize) > numAddr {
-				n = inst.Mode
-			}
-			prefix += fmt.Sprintf("addr%d ", n)
-			continue
-
-		case PrefixData16, PrefixData32:
-			if implicitData && countPrefix(&inst, 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 countPrefix(&inst, 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 == CALL || inst.Op == JMP || inst.Op == LJMP || inst.Op == LCALL) && (isMem(inst.Args[0]) || 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 gnuArg(inst *Inst, x Arg, usedPrefixes *bool) string {
-	if x == nil {
-		return "<nil>"
-	}
-	switch x := x.(type) {
-	case Reg:
-		switch inst.Op {
-		case CVTSI2SS, CVTSI2SD, CVTSS2SI, CVTSD2SI, CVTTSD2SI, CVTTSS2SI:
-			if inst.DataSize == 16 && EAX <= x && x <= R15L {
-				x -= EAX - AX
-			}
-
-		case IN, INSB, INSW, INSD, OUT, OUTSB, OUTSW, OUTSD:
-			// DX is the port, but libopcodes prints it as if it were a memory reference.
-			if x == DX {
-				return "(%dx)"
-			}
-		case VMOVDQA, VMOVDQU, VMOVNTDQA, VMOVNTDQ:
-			return strings.Replace(gccRegName[x], "xmm", "ymm", -1)
-		}
-		return gccRegName[x]
-	case Mem:
-		seg := ""
-		var haveCS, haveDS, haveES, haveFS, haveGS, haveSS bool
-		switch x.Segment {
-		case CS:
-			haveCS = true
-		case DS:
-			haveDS = true
-		case ES:
-			haveES = true
-		case FS:
-			haveFS = true
-		case GS:
-			haveGS = true
-		case SS:
-			haveSS = true
-		}
-		switch inst.Op {
-		case INSB, INSW, INSD, STOSB, STOSW, STOSD, STOSQ, SCASB, SCASW, SCASD, 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] &^ PrefixIgnored
-				if p == 0 {
-					continue
-				}
-				switch p {
-				case PrefixCS:
-					if !haveCS {
-						haveCS = true
-						inst.Prefix[i] |= PrefixImplicit
-					}
-				case PrefixDS:
-					if !haveDS {
-						haveDS = true
-						inst.Prefix[i] |= PrefixImplicit
-					}
-				case PrefixES:
-					if !haveES {
-						haveES = true
-						inst.Prefix[i] |= PrefixImplicit
-					}
-				case PrefixFS:
-					if !haveFS {
-						haveFS = true
-						inst.Prefix[i] |= PrefixImplicit
-					}
-				case PrefixGS:
-					if !haveGS {
-						haveGS = true
-						inst.Prefix[i] |= PrefixImplicit
-					}
-				case PrefixSS:
-					if !haveSS {
-						haveSS = true
-						inst.Prefix[i] |= 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 == ESP || x.Base == RSP || x.Base == 0 && inst.Mode == 64) {
-			if x.Base == 0 {
-				return seg + disp
-			}
-			return fmt.Sprintf("%s%s(%s)", seg, disp, gccRegName[x.Base])
-		}
-		base := gccRegName[x.Base]
-		if x.Base == 0 {
-			base = ""
-		}
-		index := gccRegName[x.Index]
-		if x.Index == 0 {
-			if inst.AddrSize == 64 {
-				index = "%riz"
-			} else {
-				index = "%eiz"
-			}
-		}
-		if AX <= x.Base && x.Base <= 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 Rel:
-		return fmt.Sprintf(".%+#x", int32(x))
-	case Imm:
-		if inst.Mode == 32 {
-			return fmt.Sprintf("$%#x", uint32(x))
-		}
-		return fmt.Sprintf("$%#x", int64(x))
-	}
-	return x.String()
-}
-
-var gccRegName = [...]string{
-	0:    "REG0",
-	AL:   "%al",
-	CL:   "%cl",
-	BL:   "%bl",
-	DL:   "%dl",
-	AH:   "%ah",
-	CH:   "%ch",
-	BH:   "%bh",
-	DH:   "%dh",
-	SPB:  "%spl",
-	BPB:  "%bpl",
-	SIB:  "%sil",
-	DIB:  "%dil",
-	R8B:  "%r8b",
-	R9B:  "%r9b",
-	R10B: "%r10b",
-	R11B: "%r11b",
-	R12B: "%r12b",
-	R13B: "%r13b",
-	R14B: "%r14b",
-	R15B: "%r15b",
-	AX:   "%ax",
-	CX:   "%cx",
-	BX:   "%bx",
-	DX:   "%dx",
-	SP:   "%sp",
-	BP:   "%bp",
-	SI:   "%si",
-	DI:   "%di",
-	R8W:  "%r8w",
-	R9W:  "%r9w",
-	R10W: "%r10w",
-	R11W: "%r11w",
-	R12W: "%r12w",
-	R13W: "%r13w",
-	R14W: "%r14w",
-	R15W: "%r15w",
-	EAX:  "%eax",
-	ECX:  "%ecx",
-	EDX:  "%edx",
-	EBX:  "%ebx",
-	ESP:  "%esp",
-	EBP:  "%ebp",
-	ESI:  "%esi",
-	EDI:  "%edi",
-	R8L:  "%r8d",
-	R9L:  "%r9d",
-	R10L: "%r10d",
-	R11L: "%r11d",
-	R12L: "%r12d",
-	R13L: "%r13d",
-	R14L: "%r14d",
-	R15L: "%r15d",
-	RAX:  "%rax",
-	RCX:  "%rcx",
-	RDX:  "%rdx",
-	RBX:  "%rbx",
-	RSP:  "%rsp",
-	RBP:  "%rbp",
-	RSI:  "%rsi",
-	RDI:  "%rdi",
-	R8:   "%r8",
-	R9:   "%r9",
-	R10:  "%r10",
-	R11:  "%r11",
-	R12:  "%r12",
-	R13:  "%r13",
-	R14:  "%r14",
-	R15:  "%r15",
-	IP:   "%ip",
-	EIP:  "%eip",
-	RIP:  "%rip",
-	F0:   "%st",
-	F1:   "%st(1)",
-	F2:   "%st(2)",
-	F3:   "%st(3)",
-	F4:   "%st(4)",
-	F5:   "%st(5)",
-	F6:   "%st(6)",
-	F7:   "%st(7)",
-	M0:   "%mm0",
-	M1:   "%mm1",
-	M2:   "%mm2",
-	M3:   "%mm3",
-	M4:   "%mm4",
-	M5:   "%mm5",
-	M6:   "%mm6",
-	M7:   "%mm7",
-	X0:   "%xmm0",
-	X1:   "%xmm1",
-	X2:   "%xmm2",
-	X3:   "%xmm3",
-	X4:   "%xmm4",
-	X5:   "%xmm5",
-	X6:   "%xmm6",
-	X7:   "%xmm7",
-	X8:   "%xmm8",
-	X9:   "%xmm9",
-	X10:  "%xmm10",
-	X11:  "%xmm11",
-	X12:  "%xmm12",
-	X13:  "%xmm13",
-	X14:  "%xmm14",
-	X15:  "%xmm15",
-	CS:   "%cs",
-	SS:   "%ss",
-	DS:   "%ds",
-	ES:   "%es",
-	FS:   "%fs",
-	GS:   "%gs",
-	GDTR: "%gdtr",
-	IDTR: "%idtr",
-	LDTR: "%ldtr",
-	MSW:  "%msw",
-	TASK: "%task",
-	CR0:  "%cr0",
-	CR1:  "%cr1",
-	CR2:  "%cr2",
-	CR3:  "%cr3",
-	CR4:  "%cr4",
-	CR5:  "%cr5",
-	CR6:  "%cr6",
-	CR7:  "%cr7",
-	CR8:  "%cr8",
-	CR9:  "%cr9",
-	CR10: "%cr10",
-	CR11: "%cr11",
-	CR12: "%cr12",
-	CR13: "%cr13",
-	CR14: "%cr14",
-	CR15: "%cr15",
-	DR0:  "%db0",
-	DR1:  "%db1",
-	DR2:  "%db2",
-	DR3:  "%db3",
-	DR4:  "%db4",
-	DR5:  "%db5",
-	DR6:  "%db6",
-	DR7:  "%db7",
-	TR0:  "%tr0",
-	TR1:  "%tr1",
-	TR2:  "%tr2",
-	TR3:  "%tr3",
-	TR4:  "%tr4",
-	TR5:  "%tr5",
-	TR6:  "%tr6",
-	TR7:  "%tr7",
-}
-
-var gnuOp = map[Op]string{
-	CBW:       "cbtw",
-	CDQ:       "cltd",
-	CMPSD:     "cmpsl",
-	CMPSD_XMM: "cmpsd",
-	CWD:       "cwtd",
-	CWDE:      "cwtl",
-	CQO:       "cqto",
-	INSD:      "insl",
-	IRET:      "iretw",
-	IRETD:     "iret",
-	IRETQ:     "iretq",
-	LODSB:     "lods",
-	LODSD:     "lods",
-	LODSQ:     "lods",
-	LODSW:     "lods",
-	MOVSD:     "movsl",
-	MOVSD_XMM: "movsd",
-	OUTSD:     "outsl",
-	POPA:      "popaw",
-	POPAD:     "popa",
-	POPF:      "popfw",
-	POPFD:     "popf",
-	PUSHA:     "pushaw",
-	PUSHAD:    "pusha",
-	PUSHF:     "pushfw",
-	PUSHFD:    "pushf",
-	SCASB:     "scas",
-	SCASD:     "scas",
-	SCASQ:     "scas",
-	SCASW:     "scas",
-	STOSB:     "stos",
-	STOSD:     "stos",
-	STOSQ:     "stos",
-	STOSW:     "stos",
-	XLATB:     "xlat",
-}
-
-var cmppsOps = []string{
-	"cmpeq",
-	"cmplt",
-	"cmple",
-	"cmpunord",
-	"cmpneq",
-	"cmpnlt",
-	"cmpnle",
-	"cmpord",
-}
-
-var pclmulqOps = []string{
-	"pclmullqlqdq",
-	"pclmulhqlqdq",
-	"pclmullqhqdq",
-	"pclmulhqhqdq",
-}
-
-func countPrefix(inst *Inst, target Prefix) int {
-	n := 0
-	for _, p := range inst.Prefix {
-		if p&0xFF == target&0xFF {
-			n++
-		}
-	}
-	return n
-}
-
-func markLastImplicit(inst *Inst, prefix Prefix) bool {
-	for i := len(inst.Prefix) - 1; i >= 0; i-- {
-		p := inst.Prefix[i]
-		if p&0xFF == prefix {
-			inst.Prefix[i] |= PrefixImplicit
-			return true
-		}
-	}
-	return false
-}
-
-func unmarkImplicit(inst *Inst, prefix Prefix) {
-	for i := len(inst.Prefix) - 1; i >= 0; i-- {
-		p := inst.Prefix[i]
-		if p&0xFF == prefix {
-			inst.Prefix[i] &^= PrefixImplicit
-		}
-	}
-}
-
-func byteSizeSuffix(b int) string {
-	switch b {
-	case 1:
-		return "b"
-	case 2:
-		return "w"
-	case 4:
-		return "l"
-	case 8:
-		return "q"
-	}
-	return ""
-}
-
-func argBytes(inst *Inst, arg Arg) int {
-	if isMem(arg) {
-		return inst.MemBytes
-	}
-	return regBytes(arg)
-}
-
-func isFloat(op Op) bool {
-	switch op {
-	case FADD, FCOM, FCOMP, FDIV, FDIVR, FIADD, FICOM, FICOMP, FIDIV, FIDIVR, FILD, FIMUL, FIST, FISTP, FISTTP, FISUB, FISUBR, FLD, FMUL, FST, FSTP, FSUB, FSUBR:
-		return true
-	}
-	return false
-}
-
-func isFloatInt(op Op) bool {
-	switch op {
-	case FIADD, FICOM, FICOMP, FIDIV, FIDIVR, FILD, FIMUL, FIST, FISTP, FISTTP, FISUB, FISUBR:
-		return true
-	}
-	return false
-}
diff --git a/vendor/golang.org/x/arch/x86/x86asm/inst.go b/vendor/golang.org/x/arch/x86/x86asm/inst.go
deleted file mode 100644
index 4632b506..00000000
--- a/vendor/golang.org/x/arch/x86/x86asm/inst.go
+++ /dev/null
@@ -1,649 +0,0 @@
-// 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.
-package x86asm
-
-import (
-	"bytes"
-	"fmt"
-)
-
-// An Inst is a single instruction.
-type Inst struct {
-	Prefix   Prefixes // Prefixes applied to the instruction.
-	Op       Op       // Opcode mnemonic
-	Opcode   uint32   // Encoded opcode bits, left aligned (first byte is Opcode>>24, etc)
-	Args     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
-	PCRel    int      // length of PC-relative address in instruction encoding
-	PCRelOff int      // index of start of PC-relative address in instruction encoding
-}
-
-// 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 Prefixes [14]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 Prefix uint16
-
-const (
-	// Metadata about the role of a prefix in an instruction.
-	PrefixImplicit Prefix = 0x8000 // prefix is implied by instruction text
-	PrefixIgnored  Prefix = 0x4000 // prefix is ignored: either irrelevant or overridden by a later prefix
-	PrefixInvalid  Prefix = 0x2000 // prefix makes entire instruction invalid (bad LOCK)
-
-	// Memory segment overrides.
-	PrefixES Prefix = 0x26 // ES segment override
-	PrefixCS Prefix = 0x2E // CS segment override
-	PrefixSS Prefix = 0x36 // SS segment override
-	PrefixDS Prefix = 0x3E // DS segment override
-	PrefixFS Prefix = 0x64 // FS segment override
-	PrefixGS Prefix = 0x65 // GS segment override
-
-	// Branch prediction.
-	PrefixPN Prefix = 0x12E // predict not taken (conditional branch only)
-	PrefixPT Prefix = 0x13E // predict taken (conditional branch only)
-
-	// Size attributes.
-	PrefixDataSize Prefix = 0x66 // operand size override
-	PrefixData16   Prefix = 0x166
-	PrefixData32   Prefix = 0x266
-	PrefixAddrSize Prefix = 0x67 // address size override
-	PrefixAddr16   Prefix = 0x167
-	PrefixAddr32   Prefix = 0x267
-
-	// One of a kind.
-	PrefixLOCK     Prefix = 0xF0 // lock
-	PrefixREPN     Prefix = 0xF2 // repeat not zero
-	PrefixXACQUIRE Prefix = 0x1F2
-	PrefixBND      Prefix = 0x2F2
-	PrefixREP      Prefix = 0xF3 // repeat
-	PrefixXRELEASE 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.
-	PrefixREX       Prefix = 0x40 // REX 64-bit extension prefix
-	PrefixREXW      Prefix = 0x08 // extension bit W (64-bit instruction width)
-	PrefixREXR      Prefix = 0x04 // extension bit R (r field in modrm)
-	PrefixREXX      Prefix = 0x02 // extension bit X (index field in sib)
-	PrefixREXB      Prefix = 0x01 // extension bit B (r/m field in modrm or base field in sib)
-	PrefixVEX2Bytes Prefix = 0xC5 // Short form of vex prefix
-	PrefixVEX3Bytes Prefix = 0xC4 // Long form of vex prefix
-)
-
-// IsREX reports whether p is a REX prefix byte.
-func (p Prefix) IsREX() bool {
-	return p&0xF0 == PrefixREX
-}
-
-func (p Prefix) IsVEX() bool {
-	return p&0xFF == PrefixVEX2Bytes || p&0xFF == PrefixVEX3Bytes
-}
-
-func (p Prefix) String() string {
-	p &^= PrefixImplicit | PrefixIgnored | PrefixInvalid
-	if s := prefixNames[p]; s != "" {
-		return s
-	}
-
-	if p.IsREX() {
-		s := "REX."
-		if p&PrefixREXW != 0 {
-			s += "W"
-		}
-		if p&PrefixREXR != 0 {
-			s += "R"
-		}
-		if p&PrefixREXX != 0 {
-			s += "X"
-		}
-		if p&PrefixREXB != 0 {
-			s += "B"
-		}
-		return s
-	}
-
-	return fmt.Sprintf("Prefix(%#x)", int(p))
-}
-
-// An Op is an x86 opcode.
-type Op uint32
-
-func (op Op) String() string {
-	i := int(op)
-	if i < 0 || i >= len(opNames) || opNames[i] == "" {
-		return fmt.Sprintf("Op(%d)", i)
-	}
-	return 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 Args [4]Arg
-
-// An Arg is a single instruction argument,
-// one of these types: Reg, Mem, Imm, Rel.
-type 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 Reg uint8
-
-const (
-	_ Reg = iota
-
-	// 8-bit
-	AL
-	CL
-	DL
-	BL
-	AH
-	CH
-	DH
-	BH
-	SPB
-	BPB
-	SIB
-	DIB
-	R8B
-	R9B
-	R10B
-	R11B
-	R12B
-	R13B
-	R14B
-	R15B
-
-	// 16-bit
-	AX
-	CX
-	DX
-	BX
-	SP
-	BP
-	SI
-	DI
-	R8W
-	R9W
-	R10W
-	R11W
-	R12W
-	R13W
-	R14W
-	R15W
-
-	// 32-bit
-	EAX
-	ECX
-	EDX
-	EBX
-	ESP
-	EBP
-	ESI
-	EDI
-	R8L
-	R9L
-	R10L
-	R11L
-	R12L
-	R13L
-	R14L
-	R15L
-
-	// 64-bit
-	RAX
-	RCX
-	RDX
-	RBX
-	RSP
-	RBP
-	RSI
-	RDI
-	R8
-	R9
-	R10
-	R11
-	R12
-	R13
-	R14
-	R15
-
-	// Instruction pointer.
-	IP  // 16-bit
-	EIP // 32-bit
-	RIP // 64-bit
-
-	// 387 floating point registers.
-	F0
-	F1
-	F2
-	F3
-	F4
-	F5
-	F6
-	F7
-
-	// MMX registers.
-	M0
-	M1
-	M2
-	M3
-	M4
-	M5
-	M6
-	M7
-
-	// XMM registers.
-	X0
-	X1
-	X2
-	X3
-	X4
-	X5
-	X6
-	X7
-	X8
-	X9
-	X10
-	X11
-	X12
-	X13
-	X14
-	X15
-
-	// Segment registers.
-	ES
-	CS
-	SS
-	DS
-	FS
-	GS
-
-	// System registers.
-	GDTR
-	IDTR
-	LDTR
-	MSW
-	TASK
-
-	// Control registers.
-	CR0
-	CR1
-	CR2
-	CR3
-	CR4
-	CR5
-	CR6
-	CR7
-	CR8
-	CR9
-	CR10
-	CR11
-	CR12
-	CR13
-	CR14
-	CR15
-
-	// Debug registers.
-	DR0
-	DR1
-	DR2
-	DR3
-	DR4
-	DR5
-	DR6
-	DR7
-	DR8
-	DR9
-	DR10
-	DR11
-	DR12
-	DR13
-	DR14
-	DR15
-
-	// Task registers.
-	TR0
-	TR1
-	TR2
-	TR3
-	TR4
-	TR5
-	TR6
-	TR7
-)
-
-const regMax = TR7
-
-func (Reg) isArg() {}
-
-func (r Reg) String() string {
-	i := int(r)
-	if i < 0 || i >= len(regNames) || regNames[i] == "" {
-		return fmt.Sprintf("Reg(%d)", i)
-	}
-	return regNames[i]
-}
-
-// A Mem is a memory reference.
-// The general form is Segment:[Base+Scale*Index+Disp].
-type Mem struct {
-	Segment Reg
-	Base    Reg
-	Scale   uint8
-	Index   Reg
-	Disp    int64
-}
-
-func (Mem) isArg() {}
-
-func (m 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 Rel int32
-
-func (Rel) isArg() {}
-
-func (r Rel) String() string {
-	return fmt.Sprintf(".%+d", r)
-}
-
-// An Imm is an integer constant.
-type Imm int64
-
-func (Imm) isArg() {}
-
-func (i Imm) String() string {
-	return fmt.Sprintf("%#x", int64(i))
-}
-
-func (i Inst) String() string {
-	var buf bytes.Buffer
-	for _, p := range i.Prefix {
-		if p == 0 {
-			break
-		}
-		if p&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 isReg(a Arg) bool {
-	_, ok := a.(Reg)
-	return ok
-}
-
-func isSegReg(a Arg) bool {
-	r, ok := a.(Reg)
-	return ok && ES <= r && r <= GS
-}
-
-func isMem(a Arg) bool {
-	_, ok := a.(Mem)
-	return ok
-}
-
-func isImm(a Arg) bool {
-	_, ok := a.(Imm)
-	return ok
-}
-
-func regBytes(a Arg) int {
-	r, ok := a.(Reg)
-	if !ok {
-		return 0
-	}
-	if AL <= r && r <= R15B {
-		return 1
-	}
-	if AX <= r && r <= R15W {
-		return 2
-	}
-	if EAX <= r && r <= R15L {
-		return 4
-	}
-	if RAX <= r && r <= R15 {
-		return 8
-	}
-	return 0
-}
-
-func isSegment(p Prefix) bool {
-	switch p {
-	case PrefixCS, PrefixDS, PrefixES, PrefixFS, PrefixGS, PrefixSS:
-		return true
-	}
-	return false
-}
-
-// The Op definitions and string list are in tables.go.
-
-var prefixNames = map[Prefix]string{
-	PrefixCS:       "CS",
-	PrefixDS:       "DS",
-	PrefixES:       "ES",
-	PrefixFS:       "FS",
-	PrefixGS:       "GS",
-	PrefixSS:       "SS",
-	PrefixLOCK:     "LOCK",
-	PrefixREP:      "REP",
-	PrefixREPN:     "REPN",
-	PrefixAddrSize: "ADDRSIZE",
-	PrefixDataSize: "DATASIZE",
-	PrefixAddr16:   "ADDR16",
-	PrefixData16:   "DATA16",
-	PrefixAddr32:   "ADDR32",
-	PrefixData32:   "DATA32",
-	PrefixBND:      "BND",
-	PrefixXACQUIRE: "XACQUIRE",
-	PrefixXRELEASE: "XRELEASE",
-	PrefixREX:      "REX",
-	PrefixPT:       "PT",
-	PrefixPN:       "PN",
-}
-
-var regNames = [...]string{
-	AL:   "AL",
-	CL:   "CL",
-	BL:   "BL",
-	DL:   "DL",
-	AH:   "AH",
-	CH:   "CH",
-	BH:   "BH",
-	DH:   "DH",
-	SPB:  "SPB",
-	BPB:  "BPB",
-	SIB:  "SIB",
-	DIB:  "DIB",
-	R8B:  "R8B",
-	R9B:  "R9B",
-	R10B: "R10B",
-	R11B: "R11B",
-	R12B: "R12B",
-	R13B: "R13B",
-	R14B: "R14B",
-	R15B: "R15B",
-	AX:   "AX",
-	CX:   "CX",
-	BX:   "BX",
-	DX:   "DX",
-	SP:   "SP",
-	BP:   "BP",
-	SI:   "SI",
-	DI:   "DI",
-	R8W:  "R8W",
-	R9W:  "R9W",
-	R10W: "R10W",
-	R11W: "R11W",
-	R12W: "R12W",
-	R13W: "R13W",
-	R14W: "R14W",
-	R15W: "R15W",
-	EAX:  "EAX",
-	ECX:  "ECX",
-	EDX:  "EDX",
-	EBX:  "EBX",
-	ESP:  "ESP",
-	EBP:  "EBP",
-	ESI:  "ESI",
-	EDI:  "EDI",
-	R8L:  "R8L",
-	R9L:  "R9L",
-	R10L: "R10L",
-	R11L: "R11L",
-	R12L: "R12L",
-	R13L: "R13L",
-	R14L: "R14L",
-	R15L: "R15L",
-	RAX:  "RAX",
-	RCX:  "RCX",
-	RDX:  "RDX",
-	RBX:  "RBX",
-	RSP:  "RSP",
-	RBP:  "RBP",
-	RSI:  "RSI",
-	RDI:  "RDI",
-	R8:   "R8",
-	R9:   "R9",
-	R10:  "R10",
-	R11:  "R11",
-	R12:  "R12",
-	R13:  "R13",
-	R14:  "R14",
-	R15:  "R15",
-	IP:   "IP",
-	EIP:  "EIP",
-	RIP:  "RIP",
-	F0:   "F0",
-	F1:   "F1",
-	F2:   "F2",
-	F3:   "F3",
-	F4:   "F4",
-	F5:   "F5",
-	F6:   "F6",
-	F7:   "F7",
-	M0:   "M0",
-	M1:   "M1",
-	M2:   "M2",
-	M3:   "M3",
-	M4:   "M4",
-	M5:   "M5",
-	M6:   "M6",
-	M7:   "M7",
-	X0:   "X0",
-	X1:   "X1",
-	X2:   "X2",
-	X3:   "X3",
-	X4:   "X4",
-	X5:   "X5",
-	X6:   "X6",
-	X7:   "X7",
-	X8:   "X8",
-	X9:   "X9",
-	X10:  "X10",
-	X11:  "X11",
-	X12:  "X12",
-	X13:  "X13",
-	X14:  "X14",
-	X15:  "X15",
-	CS:   "CS",
-	SS:   "SS",
-	DS:   "DS",
-	ES:   "ES",
-	FS:   "FS",
-	GS:   "GS",
-	GDTR: "GDTR",
-	IDTR: "IDTR",
-	LDTR: "LDTR",
-	MSW:  "MSW",
-	TASK: "TASK",
-	CR0:  "CR0",
-	CR1:  "CR1",
-	CR2:  "CR2",
-	CR3:  "CR3",
-	CR4:  "CR4",
-	CR5:  "CR5",
-	CR6:  "CR6",
-	CR7:  "CR7",
-	CR8:  "CR8",
-	CR9:  "CR9",
-	CR10: "CR10",
-	CR11: "CR11",
-	CR12: "CR12",
-	CR13: "CR13",
-	CR14: "CR14",
-	CR15: "CR15",
-	DR0:  "DR0",
-	DR1:  "DR1",
-	DR2:  "DR2",
-	DR3:  "DR3",
-	DR4:  "DR4",
-	DR5:  "DR5",
-	DR6:  "DR6",
-	DR7:  "DR7",
-	DR8:  "DR8",
-	DR9:  "DR9",
-	DR10: "DR10",
-	DR11: "DR11",
-	DR12: "DR12",
-	DR13: "DR13",
-	DR14: "DR14",
-	DR15: "DR15",
-	TR0:  "TR0",
-	TR1:  "TR1",
-	TR2:  "TR2",
-	TR3:  "TR3",
-	TR4:  "TR4",
-	TR5:  "TR5",
-	TR6:  "TR6",
-	TR7:  "TR7",
-}
diff --git a/vendor/golang.org/x/arch/x86/x86asm/intel.go b/vendor/golang.org/x/arch/x86/x86asm/intel.go
deleted file mode 100644
index 63fa2cfc..00000000
--- a/vendor/golang.org/x/arch/x86/x86asm/intel.go
+++ /dev/null
@@ -1,532 +0,0 @@
-// 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
-
-import (
-	"fmt"
-	"strings"
-)
-
-// IntelSyntax returns the Intel assembler syntax for the instruction, as defined by Intel's XED tool.
-func IntelSyntax(inst Inst) string {
-	var iargs []Arg
-	for _, a := range inst.Args {
-		if a == nil {
-			break
-		}
-		iargs = append(iargs, a)
-	}
-
-	switch inst.Op {
-	case INSB, INSD, INSW, OUTSB, OUTSD, OUTSW, LOOPNE, JCXZ, JECXZ, JRCXZ, LOOP, LOOPE, MOV, XLATB:
-		if inst.Op == MOV && (inst.Opcode>>16)&0xFFFC != 0x0F20 {
-			break
-		}
-		for i, p := range inst.Prefix {
-			if p&0xFF == PrefixAddrSize {
-				inst.Prefix[i] &^= PrefixImplicit
-			}
-		}
-	}
-
-	switch inst.Op {
-	case MOV:
-		dst, _ := inst.Args[0].(Reg)
-		src, _ := inst.Args[1].(Reg)
-		if ES <= dst && dst <= GS && EAX <= src && src <= R15L {
-			src -= EAX - AX
-			iargs[1] = src
-		}
-		if ES <= dst && dst <= GS && RAX <= src && src <= R15 {
-			src -= RAX - AX
-			iargs[1] = src
-		}
-
-		if inst.Opcode>>24&^3 == 0xA0 {
-			for i, p := range inst.Prefix {
-				if p&0xFF == PrefixAddrSize {
-					inst.Prefix[i] |= PrefixImplicit
-				}
-			}
-		}
-	}
-
-	switch inst.Op {
-	case AAM, AAD:
-		if imm, ok := iargs[0].(Imm); ok {
-			if inst.DataSize == 32 {
-				iargs[0] = Imm(uint32(int8(imm)))
-			} else if inst.DataSize == 16 {
-				iargs[0] = Imm(uint16(int8(imm)))
-			}
-		}
-
-	case PUSH:
-		if imm, ok := iargs[0].(Imm); ok {
-			iargs[0] = Imm(uint32(imm))
-		}
-	}
-
-	for _, p := range inst.Prefix {
-		if p&PrefixImplicit != 0 {
-			for j, pj := range inst.Prefix {
-				if pj&0xFF == p&0xFF {
-					inst.Prefix[j] |= PrefixImplicit
-				}
-			}
-		}
-	}
-
-	if inst.Op != 0 {
-		for i, p := range inst.Prefix {
-			switch p &^ PrefixIgnored {
-			case PrefixData16, PrefixData32, PrefixCS, PrefixDS, PrefixES, PrefixSS:
-				inst.Prefix[i] |= PrefixImplicit
-			}
-			if p.IsREX() {
-				inst.Prefix[i] |= PrefixImplicit
-			}
-			if p.IsVEX() {
-				if p == PrefixVEX3Bytes {
-					inst.Prefix[i+2] |= PrefixImplicit
-				}
-				inst.Prefix[i] |= PrefixImplicit
-				inst.Prefix[i+1] |= PrefixImplicit
-			}
-		}
-	}
-
-	if isLoop[inst.Op] || inst.Op == JCXZ || inst.Op == JECXZ || inst.Op == JRCXZ {
-		for i, p := range inst.Prefix {
-			if p == PrefixPT || p == PrefixPN {
-				inst.Prefix[i] |= PrefixImplicit
-			}
-		}
-	}
-
-	switch inst.Op {
-	case AAA, AAS, CBW, CDQE, CLC, CLD, CLI, CLTS, CMC, CPUID, CQO, CWD, DAA, DAS,
-		FDECSTP, FINCSTP, FNCLEX, FNINIT, FNOP, FWAIT, HLT,
-		ICEBP, INSB, INSD, INSW, INT, INTO, INVD, IRET, IRETQ,
-		LAHF, LEAVE, LRET, MONITOR, MWAIT, NOP, OUTSB, OUTSD, OUTSW,
-		PAUSE, POPA, POPF, POPFQ, PUSHA, PUSHF, PUSHFQ,
-		RDMSR, RDPMC, RDTSC, RDTSCP, RET, RSM,
-		SAHF, STC, STD, STI, SYSENTER, SYSEXIT, SYSRET,
-		UD2, WBINVD, WRMSR, XEND, XLATB, XTEST:
-
-		if inst.Op == NOP && inst.Opcode>>24 != 0x90 {
-			break
-		}
-		if inst.Op == RET && inst.Opcode>>24 != 0xC3 {
-			break
-		}
-		if inst.Op == INT && inst.Opcode>>24 != 0xCC {
-			break
-		}
-		if inst.Op == LRET && inst.Opcode>>24 != 0xcb {
-			break
-		}
-		for i, p := range inst.Prefix {
-			if p&0xFF == PrefixDataSize {
-				inst.Prefix[i] &^= PrefixImplicit | PrefixIgnored
-			}
-		}
-
-	case 0:
-		// ok
-	}
-
-	switch inst.Op {
-	case INSB, INSD, INSW, OUTSB, OUTSD, OUTSW, MONITOR, MWAIT, XLATB:
-		iargs = nil
-
-	case STOSB, STOSW, STOSD, STOSQ:
-		iargs = iargs[:1]
-
-	case LODSB, LODSW, LODSD, LODSQ, SCASB, SCASW, SCASD, 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&(PrefixImplicit|PrefixIgnored) != 0 {
-			continue
-		}
-		switch p {
-		default:
-			prefix += strings.ToLower(p.String()) + " "
-		case PrefixCS, PrefixDS, PrefixES, PrefixFS, PrefixGS, PrefixSS:
-			if inst.Op == 0 {
-				prefix += strings.ToLower(p.String()) + " "
-			}
-		case PrefixREPN:
-			prefix += "repne "
-		case PrefixLOCK:
-			prefixBits |= haveLock
-		case PrefixData16, PrefixDataSize:
-			prefixBits |= haveData16
-		case PrefixData32:
-			prefixBits |= haveData32
-		case PrefixAddrSize, PrefixAddr16:
-			prefixBits |= haveAddr16
-		case PrefixAddr32:
-			prefixBits |= haveAddr32
-		case PrefixXACQUIRE:
-			prefixBits |= haveXacquire
-		case PrefixXRELEASE:
-			prefixBits |= haveXrelease
-		case PrefixPT:
-			prefixBits |= haveHintTaken
-		case PrefixPN:
-			prefixBits |= haveHintNotTaken
-		case PrefixBND:
-			prefixBits |= haveBnd
-		}
-	}
-	switch inst.Op {
-	case JMP:
-		if inst.Opcode>>24 == 0xEB {
-			prefixBits &^= haveBnd
-		}
-	case RET, 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, intelArg(&inst, a))
-	}
-
-	var op string
-	switch inst.Op {
-	case NOP:
-		if inst.Opcode>>24 == 0x0F {
-			if inst.DataSize == 16 {
-				args = append(args, "ax")
-			} else {
-				args = append(args, "eax")
-			}
-		}
-
-	case BLENDVPD, BLENDVPS, PBLENDVB:
-		args = args[:2]
-
-	case INT:
-		if inst.Opcode>>24 == 0xCC {
-			args = nil
-			op = "int3"
-		}
-
-	case LCALL, LJMP:
-		if len(args) == 2 {
-			args[0], args[1] = args[1], args[0]
-		}
-
-	case FCHS, FABS, FTST, FLDPI, FLDL2E, FLDLG2, F2XM1, FXAM, FLD1, FLDL2T, FSQRT, FRNDINT, FCOS, FSIN:
-		if len(args) == 0 {
-			args = append(args, "st0")
-		}
-
-	case FPTAN, FSINCOS, FUCOMPP, FCOMPP, FYL2X, FPATAN, FXTRACT, FPREM1, FPREM, FYL2XP1, FSCALE:
-		if len(args) == 0 {
-			args = []string{"st0", "st1"}
-		}
-
-	case FST, FSTP, FISTTP, FIST, FISTP, FBSTP:
-		if len(args) == 1 {
-			args = append(args, "st0")
-		}
-
-	case FLD, FXCH, FCOM, FCOMP, FIADD, FIMUL, FICOM, FICOMP, FISUBR, FIDIV, FUCOM, FUCOMP, FILD, FBLD, FADD, FMUL, FSUB, FSUBR, FISUB, FDIV, FDIVR, FIDIVR:
-		if len(args) == 1 {
-			args = []string{"st0", args[0]}
-		}
-
-	case MASKMOVDQU, MASKMOVQ, XLATB, OUTSB, OUTSW, OUTSD:
-	FixSegment:
-		for i := len(inst.Prefix) - 1; i >= 0; i-- {
-			p := inst.Prefix[i] & 0xFF
-			switch p {
-			case PrefixCS, PrefixES, PrefixFS, PrefixGS, PrefixSS:
-				if inst.Mode != 64 || p == PrefixFS || p == PrefixGS {
-					args = append(args, strings.ToLower((inst.Prefix[i] & 0xFF).String()))
-					break FixSegment
-				}
-			case PrefixDS:
-				if inst.Mode != 64 {
-					break FixSegment
-				}
-			}
-		}
-	}
-
-	if op == "" {
-		op = intelOp[inst.Op]
-	}
-	if op == "" {
-		op = strings.ToLower(inst.Op.String())
-	}
-	if args != nil {
-		op += " " + strings.Join(args, ", ")
-	}
-	return prefix + op
-}
-
-func intelArg(inst *Inst, arg Arg) string {
-	switch a := arg.(type) {
-	case Imm:
-		if inst.Mode == 32 {
-			return fmt.Sprintf("%#x", uint32(a))
-		}
-		if Imm(int32(a)) == a {
-			return fmt.Sprintf("%#x", int64(a))
-		}
-		return fmt.Sprintf("%#x", uint64(a))
-	case Mem:
-		if a.Base == EIP {
-			a.Base = 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 "
-		case 32:
-			prefix = "ymmword "
-		}
-		switch inst.Op {
-		case INVLPG:
-			prefix = "byte "
-		case STOSB, MOVSB, CMPSB, LODSB, SCASB:
-			prefix = "byte "
-		case STOSW, MOVSW, CMPSW, LODSW, SCASW:
-			prefix = "word "
-		case STOSD, MOVSD, CMPSD, LODSD, SCASD:
-			prefix = "dword "
-		case STOSQ, MOVSQ, CMPSQ, LODSQ, SCASQ:
-			prefix = "qword "
-		case LAR:
-			prefix = "word "
-		case BOUND:
-			if inst.Mode == 32 {
-				prefix = "qword "
-			} else {
-				prefix = "dword "
-			}
-		case PREFETCHW, PREFETCHNTA, PREFETCHT0, PREFETCHT1, PREFETCHT2, CLFLUSH:
-			prefix = "zmmword "
-		}
-		switch inst.Op {
-		case MOVSB, MOVSW, MOVSD, MOVSQ, CMPSB, CMPSW, CMPSD, CMPSQ, STOSB, STOSW, STOSD, STOSQ, SCASB, SCASW, SCASD, SCASQ, LODSB, LODSW, LODSD, LODSQ:
-			switch a.Base {
-			case DI, EDI, RDI:
-				if a.Segment == ES {
-					a.Segment = 0
-				}
-			case SI, ESI, RSI:
-				if a.Segment == DS {
-					a.Segment = 0
-				}
-			}
-		case LEA:
-			a.Segment = 0
-		default:
-			switch a.Base {
-			case SP, ESP, RSP, BP, EBP, RBP:
-				if a.Segment == SS {
-					a.Segment = 0
-				}
-			default:
-				if a.Segment == DS {
-					a.Segment = 0
-				}
-			}
-		}
-
-		if inst.Mode == 64 && a.Segment != FS && a.Segment != GS {
-			a.Segment = 0
-		}
-
-		prefix += "ptr "
-		if a.Segment != 0 {
-			prefix += strings.ToLower(a.Segment.String()) + ":"
-		}
-		prefix += "["
-		if a.Base != 0 {
-			prefix += intelArg(inst, a.Base)
-		}
-		if a.Scale != 0 && a.Index != 0 {
-			if a.Base != 0 {
-				prefix += "+"
-			}
-			prefix += fmt.Sprintf("%s*%d", 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 Rel:
-		return fmt.Sprintf(".%+#x", int64(a))
-	case Reg:
-		if int(a) < len(intelReg) && intelReg[a] != "" {
-			switch inst.Op {
-			case VMOVDQA, VMOVDQU, VMOVNTDQA, VMOVNTDQ:
-				return strings.Replace(intelReg[a], "xmm", "ymm", -1)
-			default:
-				return intelReg[a]
-			}
-		}
-	}
-	return strings.ToLower(arg.String())
-}
-
-var intelOp = map[Op]string{
-	JAE:       "jnb",
-	JA:        "jnbe",
-	JGE:       "jnl",
-	JNE:       "jnz",
-	JG:        "jnle",
-	JE:        "jz",
-	SETAE:     "setnb",
-	SETA:      "setnbe",
-	SETGE:     "setnl",
-	SETNE:     "setnz",
-	SETG:      "setnle",
-	SETE:      "setz",
-	CMOVAE:    "cmovnb",
-	CMOVA:     "cmovnbe",
-	CMOVGE:    "cmovnl",
-	CMOVNE:    "cmovnz",
-	CMOVG:     "cmovnle",
-	CMOVE:     "cmovz",
-	LCALL:     "call far",
-	LJMP:      "jmp far",
-	LRET:      "ret far",
-	ICEBP:     "int1",
-	MOVSD_XMM: "movsd",
-	XLATB:     "xlat",
-}
-
-var intelReg = [...]string{
-	F0:  "st0",
-	F1:  "st1",
-	F2:  "st2",
-	F3:  "st3",
-	F4:  "st4",
-	F5:  "st5",
-	F6:  "st6",
-	F7:  "st7",
-	M0:  "mmx0",
-	M1:  "mmx1",
-	M2:  "mmx2",
-	M3:  "mmx3",
-	M4:  "mmx4",
-	M5:  "mmx5",
-	M6:  "mmx6",
-	M7:  "mmx7",
-	X0:  "xmm0",
-	X1:  "xmm1",
-	X2:  "xmm2",
-	X3:  "xmm3",
-	X4:  "xmm4",
-	X5:  "xmm5",
-	X6:  "xmm6",
-	X7:  "xmm7",
-	X8:  "xmm8",
-	X9:  "xmm9",
-	X10: "xmm10",
-	X11: "xmm11",
-	X12: "xmm12",
-	X13: "xmm13",
-	X14: "xmm14",
-	X15: "xmm15",
-
-	// TODO: Maybe the constants are named wrong.
-	SPB: "spl",
-	BPB: "bpl",
-	SIB: "sil",
-	DIB: "dil",
-
-	R8L:  "r8d",
-	R9L:  "r9d",
-	R10L: "r10d",
-	R11L: "r11d",
-	R12L: "r12d",
-	R13L: "r13d",
-	R14L: "r14d",
-	R15L: "r15d",
-}
diff --git a/vendor/golang.org/x/arch/x86/x86asm/plan9x.go b/vendor/golang.org/x/arch/x86/x86asm/plan9x.go
deleted file mode 100644
index 41cfc08f..00000000
--- a/vendor/golang.org/x/arch/x86/x86asm/plan9x.go
+++ /dev/null
@@ -1,362 +0,0 @@
-// 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
-
-import (
-	"fmt"
-	"strings"
-)
-
-// GoSyntax 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 GoSyntax(inst 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, plan9Arg(&inst, pc, symname, a))
-	}
-
-	var rep string
-	var last Prefix
-	for _, p := range inst.Prefix {
-		if p == 0 || p.IsREX() || p.IsVEX() {
-			break
-		}
-
-		switch {
-		// Don't show prefixes implied by the instruction text.
-		case p&0xFF00 == PrefixImplicit:
-			continue
-		// Only REP and REPN are recognized repeaters. Plan 9 syntax
-		// treats them as separate opcodes.
-		case p&0xFF == PrefixREP:
-			rep = "REP; "
-		case p&0xFF == PrefixREPN:
-			rep = "REPNE; "
-		default:
-			last = p
-		}
-	}
-
-	prefix := ""
-	switch last & 0xFF {
-	case 0, 0x66, 0x67:
-		// ignore
-	default:
-		prefix += last.String() + " "
-	}
-
-	op := inst.Op.String()
-	if plan9Suffix[inst.Op] {
-		s := inst.DataSize
-		if inst.MemBytes != 0 {
-			s = inst.MemBytes * 8
-		}
-		switch s {
-		case 8:
-			op += "B"
-		case 16:
-			op += "W"
-		case 32:
-			op += "L"
-		case 64:
-			op += "Q"
-		}
-	}
-
-	if args != nil {
-		op += " " + strings.Join(args, ", ")
-	}
-
-	return rep + prefix + op
-}
-
-func plan9Arg(inst *Inst, pc uint64, symname func(uint64) (string, uint64), arg Arg) string {
-	switch a := arg.(type) {
-	case Reg:
-		return plan9Reg[a]
-	case 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 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 Imm(int32(a)) == a {
-			return fmt.Sprintf("$%#x", int64(a))
-		}
-		return fmt.Sprintf("$%#x", uint64(a))
-	case 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:", plan9Reg[a.Segment])
-		}
-		if a.Disp != 0 {
-			s += fmt.Sprintf("%#x", a.Disp)
-		} else {
-			s += "0"
-		}
-		if a.Base != 0 {
-			s += fmt.Sprintf("(%s)", plan9Reg[a.Base])
-		}
-		if a.Index != 0 && a.Scale != 0 {
-			s += fmt.Sprintf("(%s*%d)", plan9Reg[a.Index], a.Scale)
-		}
-		return s
-	}
-	return arg.String()
-}
-
-var plan9Suffix = [maxOp + 1]bool{
-	ADC:       true,
-	ADD:       true,
-	AND:       true,
-	BSF:       true,
-	BSR:       true,
-	BT:        true,
-	BTC:       true,
-	BTR:       true,
-	BTS:       true,
-	CMP:       true,
-	CMPXCHG:   true,
-	CVTSI2SD:  true,
-	CVTSI2SS:  true,
-	CVTSD2SI:  true,
-	CVTSS2SI:  true,
-	CVTTSD2SI: true,
-	CVTTSS2SI: true,
-	DEC:       true,
-	DIV:       true,
-	FLDENV:    true,
-	FRSTOR:    true,
-	IDIV:      true,
-	IMUL:      true,
-	IN:        true,
-	INC:       true,
-	LEA:       true,
-	MOV:       true,
-	MOVNTI:    true,
-	MUL:       true,
-	NEG:       true,
-	NOP:       true,
-	NOT:       true,
-	OR:        true,
-	OUT:       true,
-	POP:       true,
-	POPA:      true,
-	PUSH:      true,
-	PUSHA:     true,
-	RCL:       true,
-	RCR:       true,
-	ROL:       true,
-	ROR:       true,
-	SAR:       true,
-	SBB:       true,
-	SHL:       true,
-	SHLD:      true,
-	SHR:       true,
-	SHRD:      true,
-	SUB:       true,
-	TEST:      true,
-	XADD:      true,
-	XCHG:      true,
-	XOR:       true,
-}
-
-var plan9Reg = [...]string{
-	AL:   "AL",
-	CL:   "CL",
-	BL:   "BL",
-	DL:   "DL",
-	AH:   "AH",
-	CH:   "CH",
-	BH:   "BH",
-	DH:   "DH",
-	SPB:  "SP",
-	BPB:  "BP",
-	SIB:  "SI",
-	DIB:  "DI",
-	R8B:  "R8",
-	R9B:  "R9",
-	R10B: "R10",
-	R11B: "R11",
-	R12B: "R12",
-	R13B: "R13",
-	R14B: "R14",
-	R15B: "R15",
-	AX:   "AX",
-	CX:   "CX",
-	BX:   "BX",
-	DX:   "DX",
-	SP:   "SP",
-	BP:   "BP",
-	SI:   "SI",
-	DI:   "DI",
-	R8W:  "R8",
-	R9W:  "R9",
-	R10W: "R10",
-	R11W: "R11",
-	R12W: "R12",
-	R13W: "R13",
-	R14W: "R14",
-	R15W: "R15",
-	EAX:  "AX",
-	ECX:  "CX",
-	EDX:  "DX",
-	EBX:  "BX",
-	ESP:  "SP",
-	EBP:  "BP",
-	ESI:  "SI",
-	EDI:  "DI",
-	R8L:  "R8",
-	R9L:  "R9",
-	R10L: "R10",
-	R11L: "R11",
-	R12L: "R12",
-	R13L: "R13",
-	R14L: "R14",
-	R15L: "R15",
-	RAX:  "AX",
-	RCX:  "CX",
-	RDX:  "DX",
-	RBX:  "BX",
-	RSP:  "SP",
-	RBP:  "BP",
-	RSI:  "SI",
-	RDI:  "DI",
-	R8:   "R8",
-	R9:   "R9",
-	R10:  "R10",
-	R11:  "R11",
-	R12:  "R12",
-	R13:  "R13",
-	R14:  "R14",
-	R15:  "R15",
-	IP:   "IP",
-	EIP:  "IP",
-	RIP:  "IP",
-	F0:   "F0",
-	F1:   "F1",
-	F2:   "F2",
-	F3:   "F3",
-	F4:   "F4",
-	F5:   "F5",
-	F6:   "F6",
-	F7:   "F7",
-	M0:   "M0",
-	M1:   "M1",
-	M2:   "M2",
-	M3:   "M3",
-	M4:   "M4",
-	M5:   "M5",
-	M6:   "M6",
-	M7:   "M7",
-	X0:   "X0",
-	X1:   "X1",
-	X2:   "X2",
-	X3:   "X3",
-	X4:   "X4",
-	X5:   "X5",
-	X6:   "X6",
-	X7:   "X7",
-	X8:   "X8",
-	X9:   "X9",
-	X10:  "X10",
-	X11:  "X11",
-	X12:  "X12",
-	X13:  "X13",
-	X14:  "X14",
-	X15:  "X15",
-	CS:   "CS",
-	SS:   "SS",
-	DS:   "DS",
-	ES:   "ES",
-	FS:   "FS",
-	GS:   "GS",
-	GDTR: "GDTR",
-	IDTR: "IDTR",
-	LDTR: "LDTR",
-	MSW:  "MSW",
-	TASK: "TASK",
-	CR0:  "CR0",
-	CR1:  "CR1",
-	CR2:  "CR2",
-	CR3:  "CR3",
-	CR4:  "CR4",
-	CR5:  "CR5",
-	CR6:  "CR6",
-	CR7:  "CR7",
-	CR8:  "CR8",
-	CR9:  "CR9",
-	CR10: "CR10",
-	CR11: "CR11",
-	CR12: "CR12",
-	CR13: "CR13",
-	CR14: "CR14",
-	CR15: "CR15",
-	DR0:  "DR0",
-	DR1:  "DR1",
-	DR2:  "DR2",
-	DR3:  "DR3",
-	DR4:  "DR4",
-	DR5:  "DR5",
-	DR6:  "DR6",
-	DR7:  "DR7",
-	DR8:  "DR8",
-	DR9:  "DR9",
-	DR10: "DR10",
-	DR11: "DR11",
-	DR12: "DR12",
-	DR13: "DR13",
-	DR14: "DR14",
-	DR15: "DR15",
-	TR0:  "TR0",
-	TR1:  "TR1",
-	TR2:  "TR2",
-	TR3:  "TR3",
-	TR4:  "TR4",
-	TR5:  "TR5",
-	TR6:  "TR6",
-	TR7:  "TR7",
-}
diff --git a/vendor/golang.org/x/arch/x86/x86asm/tables.go b/vendor/golang.org/x/arch/x86/x86asm/tables.go
deleted file mode 100644
index 5b39b744..00000000
--- a/vendor/golang.org/x/arch/x86/x86asm/tables.go
+++ /dev/null
@@ -1,9902 +0,0 @@
-// DO NOT EDIT
-// generated by: x86map -fmt=decoder ../x86.csv
-
-package x86asm
-
-var decoder = [...]uint16{
-	uint16(xFail),
-	/*1*/ uint16(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, 8452,
-	0x2C, 8481,
-	0x2D, 8487,
-	0x2F, 8516,
-	0x30, 8522,
-	0x31, 8528,
-	0x32, 8557,
-	0x33, 8563,
-	0x34, 8592,
-	0x35, 8598,
-	0x37, 8627,
-	0x38, 8633,
-	0x39, 8639,
-	0x3A, 8668,
-	0x3B, 8674,
-	0x3C, 8703,
-	0x3D, 8709,
-	0x3F, 8738,
-	0x40, 8744,
-	0x41, 8744,
-	0x42, 8744,
-	0x43, 8744,
-	0x44, 8744,
-	0x45, 8744,
-	0x46, 8744,
-	0x47, 8744,
-	0x48, 8759,
-	0x49, 8759,
-	0x4a, 8759,
-	0x4b, 8759,
-	0x4c, 8759,
-	0x4d, 8759,
-	0x4e, 8759,
-	0x4f, 8759,
-	0x50, 8774,
-	0x51, 8774,
-	0x52, 8774,
-	0x53, 8774,
-	0x54, 8774,
-	0x55, 8774,
-	0x56, 8774,
-	0x57, 8774,
-	0x58, 8801,
-	0x59, 8801,
-	0x5a, 8801,
-	0x5b, 8801,
-	0x5c, 8801,
-	0x5d, 8801,
-	0x5e, 8801,
-	0x5f, 8801,
-	0x60, 8828,
-	0x61, 8841,
-	0x62, 8854,
-	0x63, 8873,
-	0x68, 8904,
-	0x69, 8923,
-	0x6A, 8958,
-	0x6B, 8963,
-	0x6C, 8998,
-	0x6D, 9001,
-	0x6E, 9014,
-	0x6F, 9017,
-	0x70, 9090,
-	0x71, 9095,
-	0x72, 9100,
-	0x73, 9105,
-	0x74, 9110,
-	0x75, 9115,
-	0x76, 9120,
-	0x77, 9125,
-	0x78, 9152,
-	0x79, 9157,
-	0x7A, 9162,
-	0x7B, 9167,
-	0x7C, 9172,
-	0x7D, 9177,
-	0x7E, 9182,
-	0x7F, 9187,
-	0x80, 9252,
-	0x81, 9309,
-	0x83, 9550,
-	0x84, 9791,
-	0x85, 9797,
-	0x86, 9826,
-	0x87, 9832,
-	0x88, 9861,
-	0x89, 9867,
-	0x8A, 9889,
-	0x8B, 9895,
-	0x8C, 9917,
-	0x8D, 9946,
-	0x8E, 9975,
-	0x8F, 10004,
-	0x90, 10040,
-	0x91, 10040,
-	0x92, 10040,
-	0x93, 10040,
-	0x94, 10040,
-	0x95, 10040,
-	0x96, 10040,
-	0x97, 10040,
-	0x98, 10066,
-	0x99, 10086,
-	0x9A, 10106,
-	0x9B, 10123,
-	0x9C, 10126,
-	0x9D, 10149,
-	0x9E, 10172,
-	0x9F, 10175,
-	0xA0, 10178,
-	0xA1, 10197,
-	0xA2, 10219,
-	0xA3, 10238,
-	0xA4, 10260,
-	0xA5, 10263,
-	0xA6, 10283,
-	0xA7, 10286,
-	0xA8, 10306,
-	0xA9, 10312,
-	0xAA, 10341,
-	0xAB, 10344,
-	0xAC, 10364,
-	0xAD, 10367,
-	0xAE, 10387,
-	0xAF, 10390,
-	0xb0, 10410,
-	0xb1, 10410,
-	0xb2, 10410,
-	0xb3, 10410,
-	0xb4, 10410,
-	0xb5, 10410,
-	0xb6, 10410,
-	0xb7, 10410,
-	0xb8, 10416,
-	0xb9, 10416,
-	0xba, 10416,
-	0xbb, 10416,
-	0xbc, 10416,
-	0xbd, 10416,
-	0xbe, 10416,
-	0xbf, 10416,
-	0xC0, 10445,
-	0xC1, 10496,
-	0xC2, 10694,
-	0xC3, 10699,
-	0xC4, 10702,
-	0xC5, 10721,
-	0xC6, 10740,
-	0xC7, 10764,
-	0xC8, 10825,
-	0xC9, 10832,
-	0xCA, 10855,
-	0xCB, 10860,
-	0xCC, 10863,
-	0xCD, 10867,
-	0xCE, 10872,
-	0xCF, 10878,
-	0xD0, 10898,
-	0xD1, 10942,
-	0xD2, 11133,
-	0xD3, 11177,
-	0xD4, 11368,
-	0xD5, 11376,
-	0xD7, 11384,
-	0xD8, 11397,
-	0xD9, 11606,
-	0xDA, 11815,
-	0xDB, 11947,
-	0xDC, 12118,
-	0xDD, 12287,
-	0xDE, 12426,
-	0xDF, 12600,
-	0xE0, 12711,
-	0xE1, 12716,
-	0xE2, 12721,
-	0xE3, 12726,
-	0xE4, 12752,
-	0xE5, 12758,
-	0xE6, 12780,
-	0xE7, 12786,
-	0xE8, 12844,
-	0xE9, 12875,
-	0xEA, 12906,
-	0xEB, 12923,
-	0xEC, 12928,
-	0xED, 12933,
-	0xEE, 12952,
-	0xEF, 12957,
-	0xF1, 12976,
-	0xF4, 12979,
-	0xF5, 12982,
-	0xF6, 12985,
-	0xF7, 13024,
-	0xF8, 13200,
-	0xF9, 13203,
-	0xFA, 13206,
-	0xFB, 13209,
-	0xFC, 13212,
-	0xFD, 13215,
-	0xFE, 13218,
-	0xFF, 13235,
-	uint16(xFail),
-	/*490*/ uint16(xSetOp), uint16(ADD),
-	/*492*/ uint16(xReadSlashR),
-	/*493*/ uint16(xArgRM8),
-	/*494*/ uint16(xArgR8),
-	/*495*/ uint16(xMatch),
-	/*496*/ uint16(xCondIs64), 499, 515,
-	/*499*/ uint16(xCondDataSize), 503, 509, 0,
-	/*503*/ uint16(xSetOp), uint16(ADD),
-	/*505*/ uint16(xReadSlashR),
-	/*506*/ uint16(xArgRM16),
-	/*507*/ uint16(xArgR16),
-	/*508*/ uint16(xMatch),
-	/*509*/ uint16(xSetOp), uint16(ADD),
-	/*511*/ uint16(xReadSlashR),
-	/*512*/ uint16(xArgRM32),
-	/*513*/ uint16(xArgR32),
-	/*514*/ uint16(xMatch),
-	/*515*/ uint16(xCondDataSize), 503, 509, 519,
-	/*519*/ uint16(xSetOp), uint16(ADD),
-	/*521*/ uint16(xReadSlashR),
-	/*522*/ uint16(xArgRM64),
-	/*523*/ uint16(xArgR64),
-	/*524*/ uint16(xMatch),
-	/*525*/ uint16(xSetOp), uint16(ADD),
-	/*527*/ uint16(xReadSlashR),
-	/*528*/ uint16(xArgR8),
-	/*529*/ uint16(xArgRM8),
-	/*530*/ uint16(xMatch),
-	/*531*/ uint16(xCondIs64), 534, 550,
-	/*534*/ uint16(xCondDataSize), 538, 544, 0,
-	/*538*/ uint16(xSetOp), uint16(ADD),
-	/*540*/ uint16(xReadSlashR),
-	/*541*/ uint16(xArgR16),
-	/*542*/ uint16(xArgRM16),
-	/*543*/ uint16(xMatch),
-	/*544*/ uint16(xSetOp), uint16(ADD),
-	/*546*/ uint16(xReadSlashR),
-	/*547*/ uint16(xArgR32),
-	/*548*/ uint16(xArgRM32),
-	/*549*/ uint16(xMatch),
-	/*550*/ uint16(xCondDataSize), 538, 544, 554,
-	/*554*/ uint16(xSetOp), uint16(ADD),
-	/*556*/ uint16(xReadSlashR),
-	/*557*/ uint16(xArgR64),
-	/*558*/ uint16(xArgRM64),
-	/*559*/ uint16(xMatch),
-	/*560*/ uint16(xSetOp), uint16(ADD),
-	/*562*/ uint16(xReadIb),
-	/*563*/ uint16(xArgAL),
-	/*564*/ uint16(xArgImm8u),
-	/*565*/ uint16(xMatch),
-	/*566*/ uint16(xCondIs64), 569, 585,
-	/*569*/ uint16(xCondDataSize), 573, 579, 0,
-	/*573*/ uint16(xSetOp), uint16(ADD),
-	/*575*/ uint16(xReadIw),
-	/*576*/ uint16(xArgAX),
-	/*577*/ uint16(xArgImm16),
-	/*578*/ uint16(xMatch),
-	/*579*/ uint16(xSetOp), uint16(ADD),
-	/*581*/ uint16(xReadId),
-	/*582*/ uint16(xArgEAX),
-	/*583*/ uint16(xArgImm32),
-	/*584*/ uint16(xMatch),
-	/*585*/ uint16(xCondDataSize), 573, 579, 589,
-	/*589*/ uint16(xSetOp), uint16(ADD),
-	/*591*/ uint16(xReadId),
-	/*592*/ uint16(xArgRAX),
-	/*593*/ uint16(xArgImm32),
-	/*594*/ uint16(xMatch),
-	/*595*/ uint16(xCondIs64), 598, 0,
-	/*598*/ uint16(xSetOp), uint16(PUSH),
-	/*600*/ uint16(xArgES),
-	/*601*/ uint16(xMatch),
-	/*602*/ uint16(xCondIs64), 605, 0,
-	/*605*/ uint16(xSetOp), uint16(POP),
-	/*607*/ uint16(xArgES),
-	/*608*/ uint16(xMatch),
-	/*609*/ uint16(xSetOp), uint16(OR),
-	/*611*/ uint16(xReadSlashR),
-	/*612*/ uint16(xArgRM8),
-	/*613*/ uint16(xArgR8),
-	/*614*/ uint16(xMatch),
-	/*615*/ uint16(xCondIs64), 618, 634,
-	/*618*/ uint16(xCondDataSize), 622, 628, 0,
-	/*622*/ uint16(xSetOp), uint16(OR),
-	/*624*/ uint16(xReadSlashR),
-	/*625*/ uint16(xArgRM16),
-	/*626*/ uint16(xArgR16),
-	/*627*/ uint16(xMatch),
-	/*628*/ uint16(xSetOp), uint16(OR),
-	/*630*/ uint16(xReadSlashR),
-	/*631*/ uint16(xArgRM32),
-	/*632*/ uint16(xArgR32),
-	/*633*/ uint16(xMatch),
-	/*634*/ uint16(xCondDataSize), 622, 628, 638,
-	/*638*/ uint16(xSetOp), uint16(OR),
-	/*640*/ uint16(xReadSlashR),
-	/*641*/ uint16(xArgRM64),
-	/*642*/ uint16(xArgR64),
-	/*643*/ uint16(xMatch),
-	/*644*/ uint16(xSetOp), uint16(OR),
-	/*646*/ uint16(xReadSlashR),
-	/*647*/ uint16(xArgR8),
-	/*648*/ uint16(xArgRM8),
-	/*649*/ uint16(xMatch),
-	/*650*/ uint16(xCondIs64), 653, 669,
-	/*653*/ uint16(xCondDataSize), 657, 663, 0,
-	/*657*/ uint16(xSetOp), uint16(OR),
-	/*659*/ uint16(xReadSlashR),
-	/*660*/ uint16(xArgR16),
-	/*661*/ uint16(xArgRM16),
-	/*662*/ uint16(xMatch),
-	/*663*/ uint16(xSetOp), uint16(OR),
-	/*665*/ uint16(xReadSlashR),
-	/*666*/ uint16(xArgR32),
-	/*667*/ uint16(xArgRM32),
-	/*668*/ uint16(xMatch),
-	/*669*/ uint16(xCondDataSize), 657, 663, 673,
-	/*673*/ uint16(xSetOp), uint16(OR),
-	/*675*/ uint16(xReadSlashR),
-	/*676*/ uint16(xArgR64),
-	/*677*/ uint16(xArgRM64),
-	/*678*/ uint16(xMatch),
-	/*679*/ uint16(xSetOp), uint16(OR),
-	/*681*/ uint16(xReadIb),
-	/*682*/ uint16(xArgAL),
-	/*683*/ uint16(xArgImm8u),
-	/*684*/ uint16(xMatch),
-	/*685*/ uint16(xCondIs64), 688, 704,
-	/*688*/ uint16(xCondDataSize), 692, 698, 0,
-	/*692*/ uint16(xSetOp), uint16(OR),
-	/*694*/ uint16(xReadIw),
-	/*695*/ uint16(xArgAX),
-	/*696*/ uint16(xArgImm16),
-	/*697*/ uint16(xMatch),
-	/*698*/ uint16(xSetOp), uint16(OR),
-	/*700*/ uint16(xReadId),
-	/*701*/ uint16(xArgEAX),
-	/*702*/ uint16(xArgImm32),
-	/*703*/ uint16(xMatch),
-	/*704*/ uint16(xCondDataSize), 692, 698, 708,
-	/*708*/ uint16(xSetOp), uint16(OR),
-	/*710*/ uint16(xReadId),
-	/*711*/ uint16(xArgRAX),
-	/*712*/ uint16(xArgImm32),
-	/*713*/ uint16(xMatch),
-	/*714*/ uint16(xCondIs64), 717, 0,
-	/*717*/ uint16(xSetOp), uint16(PUSH),
-	/*719*/ uint16(xArgCS),
-	/*720*/ uint16(xMatch),
-	/*721*/ uint16(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(xFail),
-	/*1180*/ uint16(xCondSlashR),
-	1189, // 0
-	1205, // 1
-	1221, // 2
-	1225, // 3
-	1229, // 4
-	1233, // 5
-	0,    // 6
-	0,    // 7
-	/*1189*/ uint16(xCondDataSize), 1193, 1197, 1201,
-	/*1193*/ uint16(xSetOp), uint16(SLDT),
-	/*1195*/ uint16(xArgRM16),
-	/*1196*/ uint16(xMatch),
-	/*1197*/ uint16(xSetOp), uint16(SLDT),
-	/*1199*/ uint16(xArgR32M16),
-	/*1200*/ uint16(xMatch),
-	/*1201*/ uint16(xSetOp), uint16(SLDT),
-	/*1203*/ uint16(xArgR64M16),
-	/*1204*/ uint16(xMatch),
-	/*1205*/ uint16(xCondDataSize), 1209, 1213, 1217,
-	/*1209*/ uint16(xSetOp), uint16(STR),
-	/*1211*/ uint16(xArgRM16),
-	/*1212*/ uint16(xMatch),
-	/*1213*/ uint16(xSetOp), uint16(STR),
-	/*1215*/ uint16(xArgR32M16),
-	/*1216*/ uint16(xMatch),
-	/*1217*/ uint16(xSetOp), uint16(STR),
-	/*1219*/ uint16(xArgR64M16),
-	/*1220*/ uint16(xMatch),
-	/*1221*/ uint16(xSetOp), uint16(LLDT),
-	/*1223*/ uint16(xArgRM16),
-	/*1224*/ uint16(xMatch),
-	/*1225*/ uint16(xSetOp), uint16(LTR),
-	/*1227*/ uint16(xArgRM16),
-	/*1228*/ uint16(xMatch),
-	/*1229*/ uint16(xSetOp), uint16(VERR),
-	/*1231*/ uint16(xArgRM16),
-	/*1232*/ uint16(xMatch),
-	/*1233*/ uint16(xSetOp), uint16(VERW),
-	/*1235*/ uint16(xArgRM16),
-	/*1236*/ uint16(xMatch),
-	/*1237*/ uint16(xCondByte), 8,
-	0xC8, 1318,
-	0xC9, 1321,
-	0xD0, 1324,
-	0xD1, 1327,
-	0xD5, 1330,
-	0xD6, 1333,
-	0xF8, 1336,
-	0xF9, 1342,
-	/*1255*/ uint16(xCondSlashR),
-	1264, // 0
-	1268, // 1
-	1272, // 2
-	1283, // 3
-	1294, // 4
-	0,    // 5
-	1310, // 6
-	1314, // 7
-	/*1264*/ uint16(xSetOp), uint16(SGDT),
-	/*1266*/ uint16(xArgM),
-	/*1267*/ uint16(xMatch),
-	/*1268*/ uint16(xSetOp), uint16(SIDT),
-	/*1270*/ uint16(xArgM),
-	/*1271*/ uint16(xMatch),
-	/*1272*/ uint16(xCondIs64), 1275, 1279,
-	/*1275*/ uint16(xSetOp), uint16(LGDT),
-	/*1277*/ uint16(xArgM16and32),
-	/*1278*/ uint16(xMatch),
-	/*1279*/ uint16(xSetOp), uint16(LGDT),
-	/*1281*/ uint16(xArgM16and64),
-	/*1282*/ uint16(xMatch),
-	/*1283*/ uint16(xCondIs64), 1286, 1290,
-	/*1286*/ uint16(xSetOp), uint16(LIDT),
-	/*1288*/ uint16(xArgM16and32),
-	/*1289*/ uint16(xMatch),
-	/*1290*/ uint16(xSetOp), uint16(LIDT),
-	/*1292*/ uint16(xArgM16and64),
-	/*1293*/ uint16(xMatch),
-	/*1294*/ uint16(xCondDataSize), 1298, 1302, 1306,
-	/*1298*/ uint16(xSetOp), uint16(SMSW),
-	/*1300*/ uint16(xArgRM16),
-	/*1301*/ uint16(xMatch),
-	/*1302*/ uint16(xSetOp), uint16(SMSW),
-	/*1304*/ uint16(xArgR32M16),
-	/*1305*/ uint16(xMatch),
-	/*1306*/ uint16(xSetOp), uint16(SMSW),
-	/*1308*/ uint16(xArgR64M16),
-	/*1309*/ uint16(xMatch),
-	/*1310*/ uint16(xSetOp), uint16(LMSW),
-	/*1312*/ uint16(xArgRM16),
-	/*1313*/ uint16(xMatch),
-	/*1314*/ uint16(xSetOp), uint16(INVLPG),
-	/*1316*/ uint16(xArgM),
-	/*1317*/ uint16(xMatch),
-	/*1318*/ uint16(xSetOp), uint16(MONITOR),
-	/*1320*/ uint16(xMatch),
-	/*1321*/ uint16(xSetOp), uint16(MWAIT),
-	/*1323*/ uint16(xMatch),
-	/*1324*/ uint16(xSetOp), uint16(XGETBV),
-	/*1326*/ uint16(xMatch),
-	/*1327*/ uint16(xSetOp), uint16(XSETBV),
-	/*1329*/ uint16(xMatch),
-	/*1330*/ uint16(xSetOp), uint16(XEND),
-	/*1332*/ uint16(xMatch),
-	/*1333*/ uint16(xSetOp), uint16(XTEST),
-	/*1335*/ uint16(xMatch),
-	/*1336*/ uint16(xCondIs64), 0, 1339,
-	/*1339*/ uint16(xSetOp), uint16(SWAPGS),
-	/*1341*/ uint16(xMatch),
-	/*1342*/ uint16(xSetOp), uint16(RDTSCP),
-	/*1344*/ uint16(xMatch),
-	/*1345*/ uint16(xCondDataSize), 1349, 1355, 1361,
-	/*1349*/ uint16(xSetOp), uint16(LAR),
-	/*1351*/ uint16(xReadSlashR),
-	/*1352*/ uint16(xArgR16),
-	/*1353*/ uint16(xArgRM16),
-	/*1354*/ uint16(xMatch),
-	/*1355*/ uint16(xSetOp), uint16(LAR),
-	/*1357*/ uint16(xReadSlashR),
-	/*1358*/ uint16(xArgR32),
-	/*1359*/ uint16(xArgR32M16),
-	/*1360*/ uint16(xMatch),
-	/*1361*/ uint16(xSetOp), uint16(LAR),
-	/*1363*/ uint16(xReadSlashR),
-	/*1364*/ uint16(xArgR64),
-	/*1365*/ uint16(xArgR64M16),
-	/*1366*/ uint16(xMatch),
-	/*1367*/ uint16(xCondDataSize), 1371, 1377, 1383,
-	/*1371*/ uint16(xSetOp), uint16(LSL),
-	/*1373*/ uint16(xReadSlashR),
-	/*1374*/ uint16(xArgR16),
-	/*1375*/ uint16(xArgRM16),
-	/*1376*/ uint16(xMatch),
-	/*1377*/ uint16(xSetOp), uint16(LSL),
-	/*1379*/ uint16(xReadSlashR),
-	/*1380*/ uint16(xArgR32),
-	/*1381*/ uint16(xArgR32M16),
-	/*1382*/ uint16(xMatch),
-	/*1383*/ uint16(xSetOp), uint16(LSL),
-	/*1385*/ uint16(xReadSlashR),
-	/*1386*/ uint16(xArgR64),
-	/*1387*/ uint16(xArgR32M16),
-	/*1388*/ uint16(xMatch),
-	/*1389*/ uint16(xCondIs64), 0, 1392,
-	/*1392*/ uint16(xSetOp), uint16(SYSCALL),
-	/*1394*/ uint16(xMatch),
-	/*1395*/ uint16(xSetOp), uint16(CLTS),
-	/*1397*/ uint16(xMatch),
-	/*1398*/ uint16(xCondIs64), 0, 1401,
-	/*1401*/ uint16(xSetOp), uint16(SYSRET),
-	/*1403*/ uint16(xMatch),
-	/*1404*/ uint16(xSetOp), uint16(INVD),
-	/*1406*/ uint16(xMatch),
-	/*1407*/ uint16(xSetOp), uint16(WBINVD),
-	/*1409*/ uint16(xMatch),
-	/*1410*/ uint16(xSetOp), uint16(UD2),
-	/*1412*/ uint16(xMatch),
-	/*1413*/ uint16(xCondSlashR),
-	0,    // 0
-	1422, // 1
-	0,    // 2
-	0,    // 3
-	0,    // 4
-	0,    // 5
-	0,    // 6
-	0,    // 7
-	/*1422*/ uint16(xSetOp), uint16(PREFETCHW),
-	/*1424*/ uint16(xArgM8),
-	/*1425*/ uint16(xMatch),
-	/*1426*/ uint16(xCondPrefix), 4,
-	0xF3, 1454,
-	0xF2, 1448,
-	0x66, 1442,
-	0x0, 1436,
-	/*1436*/ uint16(xSetOp), uint16(MOVUPS),
-	/*1438*/ uint16(xReadSlashR),
-	/*1439*/ uint16(xArgXmm1),
-	/*1440*/ uint16(xArgXmm2M128),
-	/*1441*/ uint16(xMatch),
-	/*1442*/ uint16(xSetOp), uint16(MOVUPD),
-	/*1444*/ uint16(xReadSlashR),
-	/*1445*/ uint16(xArgXmm1),
-	/*1446*/ uint16(xArgXmm2M128),
-	/*1447*/ uint16(xMatch),
-	/*1448*/ uint16(xSetOp), uint16(MOVSD_XMM),
-	/*1450*/ uint16(xReadSlashR),
-	/*1451*/ uint16(xArgXmm1),
-	/*1452*/ uint16(xArgXmm2M64),
-	/*1453*/ uint16(xMatch),
-	/*1454*/ uint16(xSetOp), uint16(MOVSS),
-	/*1456*/ uint16(xReadSlashR),
-	/*1457*/ uint16(xArgXmm1),
-	/*1458*/ uint16(xArgXmm2M32),
-	/*1459*/ uint16(xMatch),
-	/*1460*/ uint16(xCondPrefix), 4,
-	0xF3, 1488,
-	0xF2, 1482,
-	0x66, 1476,
-	0x0, 1470,
-	/*1470*/ uint16(xSetOp), uint16(MOVUPS),
-	/*1472*/ uint16(xReadSlashR),
-	/*1473*/ uint16(xArgXmm2M128),
-	/*1474*/ uint16(xArgXmm1),
-	/*1475*/ uint16(xMatch),
-	/*1476*/ uint16(xSetOp), uint16(MOVUPD),
-	/*1478*/ uint16(xReadSlashR),
-	/*1479*/ uint16(xArgXmm2M128),
-	/*1480*/ uint16(xArgXmm),
-	/*1481*/ uint16(xMatch),
-	/*1482*/ uint16(xSetOp), uint16(MOVSD_XMM),
-	/*1484*/ uint16(xReadSlashR),
-	/*1485*/ uint16(xArgXmm2M64),
-	/*1486*/ uint16(xArgXmm1),
-	/*1487*/ uint16(xMatch),
-	/*1488*/ uint16(xSetOp), uint16(MOVSS),
-	/*1490*/ uint16(xReadSlashR),
-	/*1491*/ uint16(xArgXmm2M32),
-	/*1492*/ uint16(xArgXmm),
-	/*1493*/ uint16(xMatch),
-	/*1494*/ uint16(xCondPrefix), 4,
-	0xF3, 1531,
-	0xF2, 1525,
-	0x66, 1519,
-	0x0, 1504,
-	/*1504*/ uint16(xCondIsMem), 1507, 1513,
-	/*1507*/ uint16(xSetOp), uint16(MOVHLPS),
-	/*1509*/ uint16(xReadSlashR),
-	/*1510*/ uint16(xArgXmm1),
-	/*1511*/ uint16(xArgXmm2),
-	/*1512*/ uint16(xMatch),
-	/*1513*/ uint16(xSetOp), uint16(MOVLPS),
-	/*1515*/ uint16(xReadSlashR),
-	/*1516*/ uint16(xArgXmm),
-	/*1517*/ uint16(xArgM64),
-	/*1518*/ uint16(xMatch),
-	/*1519*/ uint16(xSetOp), uint16(MOVLPD),
-	/*1521*/ uint16(xReadSlashR),
-	/*1522*/ uint16(xArgXmm),
-	/*1523*/ uint16(xArgXmm2M64),
-	/*1524*/ uint16(xMatch),
-	/*1525*/ uint16(xSetOp), uint16(MOVDDUP),
-	/*1527*/ uint16(xReadSlashR),
-	/*1528*/ uint16(xArgXmm1),
-	/*1529*/ uint16(xArgXmm2M64),
-	/*1530*/ uint16(xMatch),
-	/*1531*/ uint16(xSetOp), uint16(MOVSLDUP),
-	/*1533*/ uint16(xReadSlashR),
-	/*1534*/ uint16(xArgXmm1),
-	/*1535*/ uint16(xArgXmm2M128),
-	/*1536*/ uint16(xMatch),
-	/*1537*/ uint16(xCondPrefix), 2,
-	0x66, 1549,
-	0x0, 1543,
-	/*1543*/ uint16(xSetOp), uint16(MOVLPS),
-	/*1545*/ uint16(xReadSlashR),
-	/*1546*/ uint16(xArgM64),
-	/*1547*/ uint16(xArgXmm),
-	/*1548*/ uint16(xMatch),
-	/*1549*/ uint16(xSetOp), uint16(MOVLPD),
-	/*1551*/ uint16(xReadSlashR),
-	/*1552*/ uint16(xArgXmm2M64),
-	/*1553*/ uint16(xArgXmm),
-	/*1554*/ uint16(xMatch),
-	/*1555*/ uint16(xCondPrefix), 2,
-	0x66, 1567,
-	0x0, 1561,
-	/*1561*/ uint16(xSetOp), uint16(UNPCKLPS),
-	/*1563*/ uint16(xReadSlashR),
-	/*1564*/ uint16(xArgXmm1),
-	/*1565*/ uint16(xArgXmm2M128),
-	/*1566*/ uint16(xMatch),
-	/*1567*/ uint16(xSetOp), uint16(UNPCKLPD),
-	/*1569*/ uint16(xReadSlashR),
-	/*1570*/ uint16(xArgXmm1),
-	/*1571*/ uint16(xArgXmm2M128),
-	/*1572*/ uint16(xMatch),
-	/*1573*/ uint16(xCondPrefix), 2,
-	0x66, 1585,
-	0x0, 1579,
-	/*1579*/ uint16(xSetOp), uint16(UNPCKHPS),
-	/*1581*/ uint16(xReadSlashR),
-	/*1582*/ uint16(xArgXmm1),
-	/*1583*/ uint16(xArgXmm2M128),
-	/*1584*/ uint16(xMatch),
-	/*1585*/ uint16(xSetOp), uint16(UNPCKHPD),
-	/*1587*/ uint16(xReadSlashR),
-	/*1588*/ uint16(xArgXmm1),
-	/*1589*/ uint16(xArgXmm2M128),
-	/*1590*/ uint16(xMatch),
-	/*1591*/ uint16(xCondPrefix), 3,
-	0xF3, 1620,
-	0x66, 1614,
-	0x0, 1599,
-	/*1599*/ uint16(xCondIsMem), 1602, 1608,
-	/*1602*/ uint16(xSetOp), uint16(MOVLHPS),
-	/*1604*/ uint16(xReadSlashR),
-	/*1605*/ uint16(xArgXmm1),
-	/*1606*/ uint16(xArgXmm2),
-	/*1607*/ uint16(xMatch),
-	/*1608*/ uint16(xSetOp), uint16(MOVHPS),
-	/*1610*/ uint16(xReadSlashR),
-	/*1611*/ uint16(xArgXmm),
-	/*1612*/ uint16(xArgM64),
-	/*1613*/ uint16(xMatch),
-	/*1614*/ uint16(xSetOp), uint16(MOVHPD),
-	/*1616*/ uint16(xReadSlashR),
-	/*1617*/ uint16(xArgXmm),
-	/*1618*/ uint16(xArgXmm2M64),
-	/*1619*/ uint16(xMatch),
-	/*1620*/ uint16(xSetOp), uint16(MOVSHDUP),
-	/*1622*/ uint16(xReadSlashR),
-	/*1623*/ uint16(xArgXmm1),
-	/*1624*/ uint16(xArgXmm2M128),
-	/*1625*/ uint16(xMatch),
-	/*1626*/ uint16(xCondPrefix), 2,
-	0x66, 1638,
-	0x0, 1632,
-	/*1632*/ uint16(xSetOp), uint16(MOVHPS),
-	/*1634*/ uint16(xReadSlashR),
-	/*1635*/ uint16(xArgM64),
-	/*1636*/ uint16(xArgXmm),
-	/*1637*/ uint16(xMatch),
-	/*1638*/ uint16(xSetOp), uint16(MOVHPD),
-	/*1640*/ uint16(xReadSlashR),
-	/*1641*/ uint16(xArgXmm2M64),
-	/*1642*/ uint16(xArgXmm),
-	/*1643*/ uint16(xMatch),
-	/*1644*/ uint16(xCondSlashR),
-	1653, // 0
-	1657, // 1
-	1661, // 2
-	1665, // 3
-	0,    // 4
-	0,    // 5
-	0,    // 6
-	0,    // 7
-	/*1653*/ uint16(xSetOp), uint16(PREFETCHNTA),
-	/*1655*/ uint16(xArgM8),
-	/*1656*/ uint16(xMatch),
-	/*1657*/ uint16(xSetOp), uint16(PREFETCHT0),
-	/*1659*/ uint16(xArgM8),
-	/*1660*/ uint16(xMatch),
-	/*1661*/ uint16(xSetOp), uint16(PREFETCHT1),
-	/*1663*/ uint16(xArgM8),
-	/*1664*/ uint16(xMatch),
-	/*1665*/ uint16(xSetOp), uint16(PREFETCHT2),
-	/*1667*/ uint16(xArgM8),
-	/*1668*/ uint16(xMatch),
-	/*1669*/ uint16(xCondSlashR),
-	1678, // 0
-	0,    // 1
-	0,    // 2
-	0,    // 3
-	0,    // 4
-	0,    // 5
-	0,    // 6
-	0,    // 7
-	/*1678*/ uint16(xCondDataSize), 1682, 1686, 0,
-	/*1682*/ uint16(xSetOp), uint16(NOP),
-	/*1684*/ uint16(xArgRM16),
-	/*1685*/ uint16(xMatch),
-	/*1686*/ uint16(xSetOp), uint16(NOP),
-	/*1688*/ uint16(xArgRM32),
-	/*1689*/ uint16(xMatch),
-	/*1690*/ uint16(xCondIs64), 1693, 1699,
-	/*1693*/ uint16(xSetOp), uint16(MOV),
-	/*1695*/ uint16(xReadSlashR),
-	/*1696*/ uint16(xArgRmf32),
-	/*1697*/ uint16(xArgCR0dashCR7),
-	/*1698*/ uint16(xMatch),
-	/*1699*/ uint16(xSetOp), uint16(MOV),
-	/*1701*/ uint16(xReadSlashR),
-	/*1702*/ uint16(xArgRmf64),
-	/*1703*/ uint16(xArgCR0dashCR7),
-	/*1704*/ uint16(xMatch),
-	/*1705*/ uint16(xCondIs64), 1708, 1714,
-	/*1708*/ uint16(xSetOp), uint16(MOV),
-	/*1710*/ uint16(xReadSlashR),
-	/*1711*/ uint16(xArgRmf32),
-	/*1712*/ uint16(xArgDR0dashDR7),
-	/*1713*/ uint16(xMatch),
-	/*1714*/ uint16(xSetOp), uint16(MOV),
-	/*1716*/ uint16(xReadSlashR),
-	/*1717*/ uint16(xArgRmf64),
-	/*1718*/ uint16(xArgDR0dashDR7),
-	/*1719*/ uint16(xMatch),
-	/*1720*/ uint16(xCondIs64), 1723, 1729,
-	/*1723*/ uint16(xSetOp), uint16(MOV),
-	/*1725*/ uint16(xReadSlashR),
-	/*1726*/ uint16(xArgCR0dashCR7),
-	/*1727*/ uint16(xArgRmf32),
-	/*1728*/ uint16(xMatch),
-	/*1729*/ uint16(xSetOp), uint16(MOV),
-	/*1731*/ uint16(xReadSlashR),
-	/*1732*/ uint16(xArgCR0dashCR7),
-	/*1733*/ uint16(xArgRmf64),
-	/*1734*/ uint16(xMatch),
-	/*1735*/ uint16(xCondIs64), 1738, 1744,
-	/*1738*/ uint16(xSetOp), uint16(MOV),
-	/*1740*/ uint16(xReadSlashR),
-	/*1741*/ uint16(xArgDR0dashDR7),
-	/*1742*/ uint16(xArgRmf32),
-	/*1743*/ uint16(xMatch),
-	/*1744*/ uint16(xSetOp), uint16(MOV),
-	/*1746*/ uint16(xReadSlashR),
-	/*1747*/ uint16(xArgDR0dashDR7),
-	/*1748*/ uint16(xArgRmf64),
-	/*1749*/ uint16(xMatch),
-	/*1750*/ uint16(xCondIs64), 1753, 1759,
-	/*1753*/ uint16(xSetOp), uint16(MOV),
-	/*1755*/ uint16(xReadSlashR),
-	/*1756*/ uint16(xArgRmf32),
-	/*1757*/ uint16(xArgTR0dashTR7),
-	/*1758*/ uint16(xMatch),
-	/*1759*/ uint16(xSetOp), uint16(MOV),
-	/*1761*/ uint16(xReadSlashR),
-	/*1762*/ uint16(xArgRmf64),
-	/*1763*/ uint16(xArgTR0dashTR7),
-	/*1764*/ uint16(xMatch),
-	/*1765*/ uint16(xCondIs64), 1768, 1774,
-	/*1768*/ uint16(xSetOp), uint16(MOV),
-	/*1770*/ uint16(xReadSlashR),
-	/*1771*/ uint16(xArgTR0dashTR7),
-	/*1772*/ uint16(xArgRmf32),
-	/*1773*/ uint16(xMatch),
-	/*1774*/ uint16(xSetOp), uint16(MOV),
-	/*1776*/ uint16(xReadSlashR),
-	/*1777*/ uint16(xArgTR0dashTR7),
-	/*1778*/ uint16(xArgRmf64),
-	/*1779*/ uint16(xMatch),
-	/*1780*/ uint16(xCondPrefix), 2,
-	0x66, 1792,
-	0x0, 1786,
-	/*1786*/ uint16(xSetOp), uint16(MOVAPS),
-	/*1788*/ uint16(xReadSlashR),
-	/*1789*/ uint16(xArgXmm1),
-	/*1790*/ uint16(xArgXmm2M128),
-	/*1791*/ uint16(xMatch),
-	/*1792*/ uint16(xSetOp), uint16(MOVAPD),
-	/*1794*/ uint16(xReadSlashR),
-	/*1795*/ uint16(xArgXmm1),
-	/*1796*/ uint16(xArgXmm2M128),
-	/*1797*/ uint16(xMatch),
-	/*1798*/ uint16(xCondPrefix), 2,
-	0x66, 1810,
-	0x0, 1804,
-	/*1804*/ uint16(xSetOp), uint16(MOVAPS),
-	/*1806*/ uint16(xReadSlashR),
-	/*1807*/ uint16(xArgXmm2M128),
-	/*1808*/ uint16(xArgXmm1),
-	/*1809*/ uint16(xMatch),
-	/*1810*/ uint16(xSetOp), uint16(MOVAPD),
-	/*1812*/ uint16(xReadSlashR),
-	/*1813*/ uint16(xArgXmm2M128),
-	/*1814*/ uint16(xArgXmm1),
-	/*1815*/ uint16(xMatch),
-	/*1816*/ uint16(xCondIs64), 1819, 1873,
-	/*1819*/ uint16(xCondPrefix), 4,
-	0xF3, 1857,
-	0xF2, 1841,
-	0x66, 1835,
-	0x0, 1829,
-	/*1829*/ uint16(xSetOp), uint16(CVTPI2PS),
-	/*1831*/ uint16(xReadSlashR),
-	/*1832*/ uint16(xArgXmm),
-	/*1833*/ uint16(xArgMmM64),
-	/*1834*/ uint16(xMatch),
-	/*1835*/ uint16(xSetOp), uint16(CVTPI2PD),
-	/*1837*/ uint16(xReadSlashR),
-	/*1838*/ uint16(xArgXmm),
-	/*1839*/ uint16(xArgMmM64),
-	/*1840*/ uint16(xMatch),
-	/*1841*/ uint16(xCondDataSize), 1845, 1851, 0,
-	/*1845*/ uint16(xSetOp), uint16(CVTSI2SD),
-	/*1847*/ uint16(xReadSlashR),
-	/*1848*/ uint16(xArgXmm),
-	/*1849*/ uint16(xArgRM32),
-	/*1850*/ uint16(xMatch),
-	/*1851*/ uint16(xSetOp), uint16(CVTSI2SD),
-	/*1853*/ uint16(xReadSlashR),
-	/*1854*/ uint16(xArgXmm),
-	/*1855*/ uint16(xArgRM32),
-	/*1856*/ uint16(xMatch),
-	/*1857*/ uint16(xCondDataSize), 1861, 1867, 0,
-	/*1861*/ uint16(xSetOp), uint16(CVTSI2SS),
-	/*1863*/ uint16(xReadSlashR),
-	/*1864*/ uint16(xArgXmm),
-	/*1865*/ uint16(xArgRM32),
-	/*1866*/ uint16(xMatch),
-	/*1867*/ uint16(xSetOp), uint16(CVTSI2SS),
-	/*1869*/ uint16(xReadSlashR),
-	/*1870*/ uint16(xArgXmm),
-	/*1871*/ uint16(xArgRM32),
-	/*1872*/ uint16(xMatch),
-	/*1873*/ uint16(xCondPrefix), 4,
-	0xF3, 1893,
-	0xF2, 1883,
-	0x66, 1835,
-	0x0, 1829,
-	/*1883*/ uint16(xCondDataSize), 1845, 1851, 1887,
-	/*1887*/ uint16(xSetOp), uint16(CVTSI2SD),
-	/*1889*/ uint16(xReadSlashR),
-	/*1890*/ uint16(xArgXmm),
-	/*1891*/ uint16(xArgRM64),
-	/*1892*/ uint16(xMatch),
-	/*1893*/ uint16(xCondDataSize), 1861, 1867, 1897,
-	/*1897*/ uint16(xSetOp), uint16(CVTSI2SS),
-	/*1899*/ uint16(xReadSlashR),
-	/*1900*/ uint16(xArgXmm),
-	/*1901*/ uint16(xArgRM64),
-	/*1902*/ uint16(xMatch),
-	/*1903*/ uint16(xCondPrefix), 4,
-	0xF3, 1931,
-	0xF2, 1925,
-	0x66, 1919,
-	0x0, 1913,
-	/*1913*/ uint16(xSetOp), uint16(MOVNTPS),
-	/*1915*/ uint16(xReadSlashR),
-	/*1916*/ uint16(xArgM128),
-	/*1917*/ uint16(xArgXmm),
-	/*1918*/ uint16(xMatch),
-	/*1919*/ uint16(xSetOp), uint16(MOVNTPD),
-	/*1921*/ uint16(xReadSlashR),
-	/*1922*/ uint16(xArgM128),
-	/*1923*/ uint16(xArgXmm),
-	/*1924*/ uint16(xMatch),
-	/*1925*/ uint16(xSetOp), uint16(MOVNTSD),
-	/*1927*/ uint16(xReadSlashR),
-	/*1928*/ uint16(xArgM64),
-	/*1929*/ uint16(xArgXmm),
-	/*1930*/ uint16(xMatch),
-	/*1931*/ uint16(xSetOp), uint16(MOVNTSS),
-	/*1933*/ uint16(xReadSlashR),
-	/*1934*/ uint16(xArgM32),
-	/*1935*/ uint16(xArgXmm),
-	/*1936*/ uint16(xMatch),
-	/*1937*/ uint16(xCondIs64), 1940, 1994,
-	/*1940*/ uint16(xCondPrefix), 4,
-	0xF3, 1978,
-	0xF2, 1962,
-	0x66, 1956,
-	0x0, 1950,
-	/*1950*/ uint16(xSetOp), uint16(CVTTPS2PI),
-	/*1952*/ uint16(xReadSlashR),
-	/*1953*/ uint16(xArgMm),
-	/*1954*/ uint16(xArgXmmM64),
-	/*1955*/ uint16(xMatch),
-	/*1956*/ uint16(xSetOp), uint16(CVTTPD2PI),
-	/*1958*/ uint16(xReadSlashR),
-	/*1959*/ uint16(xArgMm),
-	/*1960*/ uint16(xArgXmmM128),
-	/*1961*/ uint16(xMatch),
-	/*1962*/ uint16(xCondDataSize), 1966, 1972, 0,
-	/*1966*/ uint16(xSetOp), uint16(CVTTSD2SI),
-	/*1968*/ uint16(xReadSlashR),
-	/*1969*/ uint16(xArgR32),
-	/*1970*/ uint16(xArgXmmM64),
-	/*1971*/ uint16(xMatch),
-	/*1972*/ uint16(xSetOp), uint16(CVTTSD2SI),
-	/*1974*/ uint16(xReadSlashR),
-	/*1975*/ uint16(xArgR32),
-	/*1976*/ uint16(xArgXmmM64),
-	/*1977*/ uint16(xMatch),
-	/*1978*/ uint16(xCondDataSize), 1982, 1988, 0,
-	/*1982*/ uint16(xSetOp), uint16(CVTTSS2SI),
-	/*1984*/ uint16(xReadSlashR),
-	/*1985*/ uint16(xArgR32),
-	/*1986*/ uint16(xArgXmmM32),
-	/*1987*/ uint16(xMatch),
-	/*1988*/ uint16(xSetOp), uint16(CVTTSS2SI),
-	/*1990*/ uint16(xReadSlashR),
-	/*1991*/ uint16(xArgR32),
-	/*1992*/ uint16(xArgXmmM32),
-	/*1993*/ uint16(xMatch),
-	/*1994*/ uint16(xCondPrefix), 4,
-	0xF3, 2014,
-	0xF2, 2004,
-	0x66, 1956,
-	0x0, 1950,
-	/*2004*/ uint16(xCondDataSize), 1966, 1972, 2008,
-	/*2008*/ uint16(xSetOp), uint16(CVTTSD2SI),
-	/*2010*/ uint16(xReadSlashR),
-	/*2011*/ uint16(xArgR64),
-	/*2012*/ uint16(xArgXmmM64),
-	/*2013*/ uint16(xMatch),
-	/*2014*/ uint16(xCondDataSize), 1982, 1988, 2018,
-	/*2018*/ uint16(xSetOp), uint16(CVTTSS2SI),
-	/*2020*/ uint16(xReadSlashR),
-	/*2021*/ uint16(xArgR64),
-	/*2022*/ uint16(xArgXmmM32),
-	/*2023*/ uint16(xMatch),
-	/*2024*/ uint16(xCondIs64), 2027, 2081,
-	/*2027*/ uint16(xCondPrefix), 4,
-	0xF3, 2065,
-	0xF2, 2049,
-	0x66, 2043,
-	0x0, 2037,
-	/*2037*/ uint16(xSetOp), uint16(CVTPS2PI),
-	/*2039*/ uint16(xReadSlashR),
-	/*2040*/ uint16(xArgMm),
-	/*2041*/ uint16(xArgXmmM64),
-	/*2042*/ uint16(xMatch),
-	/*2043*/ uint16(xSetOp), uint16(CVTPD2PI),
-	/*2045*/ uint16(xReadSlashR),
-	/*2046*/ uint16(xArgMm),
-	/*2047*/ uint16(xArgXmmM128),
-	/*2048*/ uint16(xMatch),
-	/*2049*/ uint16(xCondDataSize), 2053, 2059, 0,
-	/*2053*/ uint16(xSetOp), uint16(CVTSD2SI),
-	/*2055*/ uint16(xReadSlashR),
-	/*2056*/ uint16(xArgR32),
-	/*2057*/ uint16(xArgXmmM64),
-	/*2058*/ uint16(xMatch),
-	/*2059*/ uint16(xSetOp), uint16(CVTSD2SI),
-	/*2061*/ uint16(xReadSlashR),
-	/*2062*/ uint16(xArgR32),
-	/*2063*/ uint16(xArgXmmM64),
-	/*2064*/ uint16(xMatch),
-	/*2065*/ uint16(xCondDataSize), 2069, 2075, 0,
-	/*2069*/ uint16(xSetOp), uint16(CVTSS2SI),
-	/*2071*/ uint16(xReadSlashR),
-	/*2072*/ uint16(xArgR32),
-	/*2073*/ uint16(xArgXmmM32),
-	/*2074*/ uint16(xMatch),
-	/*2075*/ uint16(xSetOp), uint16(CVTSS2SI),
-	/*2077*/ uint16(xReadSlashR),
-	/*2078*/ uint16(xArgR32),
-	/*2079*/ uint16(xArgXmmM32),
-	/*2080*/ uint16(xMatch),
-	/*2081*/ uint16(xCondPrefix), 4,
-	0xF3, 2101,
-	0xF2, 2091,
-	0x66, 2043,
-	0x0, 2037,
-	/*2091*/ uint16(xCondDataSize), 2053, 2059, 2095,
-	/*2095*/ uint16(xSetOp), uint16(CVTSD2SI),
-	/*2097*/ uint16(xReadSlashR),
-	/*2098*/ uint16(xArgR64),
-	/*2099*/ uint16(xArgXmmM64),
-	/*2100*/ uint16(xMatch),
-	/*2101*/ uint16(xCondDataSize), 2069, 2075, 2105,
-	/*2105*/ uint16(xSetOp), uint16(CVTSS2SI),
-	/*2107*/ uint16(xReadSlashR),
-	/*2108*/ uint16(xArgR64),
-	/*2109*/ uint16(xArgXmmM32),
-	/*2110*/ uint16(xMatch),
-	/*2111*/ uint16(xCondPrefix), 2,
-	0x66, 2123,
-	0x0, 2117,
-	/*2117*/ uint16(xSetOp), uint16(UCOMISS),
-	/*2119*/ uint16(xReadSlashR),
-	/*2120*/ uint16(xArgXmm1),
-	/*2121*/ uint16(xArgXmm2M32),
-	/*2122*/ uint16(xMatch),
-	/*2123*/ uint16(xSetOp), uint16(UCOMISD),
-	/*2125*/ uint16(xReadSlashR),
-	/*2126*/ uint16(xArgXmm1),
-	/*2127*/ uint16(xArgXmm2M64),
-	/*2128*/ uint16(xMatch),
-	/*2129*/ uint16(xCondPrefix), 2,
-	0x66, 2141,
-	0x0, 2135,
-	/*2135*/ uint16(xSetOp), uint16(COMISS),
-	/*2137*/ uint16(xReadSlashR),
-	/*2138*/ uint16(xArgXmm1),
-	/*2139*/ uint16(xArgXmm2M32),
-	/*2140*/ uint16(xMatch),
-	/*2141*/ uint16(xSetOp), uint16(COMISD),
-	/*2143*/ uint16(xReadSlashR),
-	/*2144*/ uint16(xArgXmm1),
-	/*2145*/ uint16(xArgXmm2M64),
-	/*2146*/ uint16(xMatch),
-	/*2147*/ uint16(xSetOp), uint16(WRMSR),
-	/*2149*/ uint16(xMatch),
-	/*2150*/ uint16(xSetOp), uint16(RDTSC),
-	/*2152*/ uint16(xMatch),
-	/*2153*/ uint16(xSetOp), uint16(RDMSR),
-	/*2155*/ uint16(xMatch),
-	/*2156*/ uint16(xSetOp), uint16(RDPMC),
-	/*2158*/ uint16(xMatch),
-	/*2159*/ uint16(xSetOp), uint16(SYSENTER),
-	/*2161*/ uint16(xMatch),
-	/*2162*/ uint16(xCondDataSize), 2166, 2166, 2169,
-	/*2166*/ uint16(xSetOp), uint16(SYSEXIT),
-	/*2168*/ uint16(xMatch),
-	/*2169*/ uint16(xSetOp), uint16(SYSEXIT),
-	/*2171*/ uint16(xMatch),
-	/*2172*/ uint16(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(xFail),
-	/*2283*/ uint16(xCondPrefix), 2,
-	0x66, 2295,
-	0x0, 2289,
-	/*2289*/ uint16(xSetOp), uint16(PSHUFB),
-	/*2291*/ uint16(xReadSlashR),
-	/*2292*/ uint16(xArgMm1),
-	/*2293*/ uint16(xArgMm2M64),
-	/*2294*/ uint16(xMatch),
-	/*2295*/ uint16(xSetOp), uint16(PSHUFB),
-	/*2297*/ uint16(xReadSlashR),
-	/*2298*/ uint16(xArgXmm1),
-	/*2299*/ uint16(xArgXmm2M128),
-	/*2300*/ uint16(xMatch),
-	/*2301*/ uint16(xCondPrefix), 2,
-	0x66, 2313,
-	0x0, 2307,
-	/*2307*/ uint16(xSetOp), uint16(PHADDW),
-	/*2309*/ uint16(xReadSlashR),
-	/*2310*/ uint16(xArgMm1),
-	/*2311*/ uint16(xArgMm2M64),
-	/*2312*/ uint16(xMatch),
-	/*2313*/ uint16(xSetOp), uint16(PHADDW),
-	/*2315*/ uint16(xReadSlashR),
-	/*2316*/ uint16(xArgXmm1),
-	/*2317*/ uint16(xArgXmm2M128),
-	/*2318*/ uint16(xMatch),
-	/*2319*/ uint16(xCondPrefix), 2,
-	0x66, 2331,
-	0x0, 2325,
-	/*2325*/ uint16(xSetOp), uint16(PHADDD),
-	/*2327*/ uint16(xReadSlashR),
-	/*2328*/ uint16(xArgMm1),
-	/*2329*/ uint16(xArgMm2M64),
-	/*2330*/ uint16(xMatch),
-	/*2331*/ uint16(xSetOp), uint16(PHADDD),
-	/*2333*/ uint16(xReadSlashR),
-	/*2334*/ uint16(xArgXmm1),
-	/*2335*/ uint16(xArgXmm2M128),
-	/*2336*/ uint16(xMatch),
-	/*2337*/ uint16(xCondPrefix), 2,
-	0x66, 2349,
-	0x0, 2343,
-	/*2343*/ uint16(xSetOp), uint16(PHADDSW),
-	/*2345*/ uint16(xReadSlashR),
-	/*2346*/ uint16(xArgMm1),
-	/*2347*/ uint16(xArgMm2M64),
-	/*2348*/ uint16(xMatch),
-	/*2349*/ uint16(xSetOp), uint16(PHADDSW),
-	/*2351*/ uint16(xReadSlashR),
-	/*2352*/ uint16(xArgXmm1),
-	/*2353*/ uint16(xArgXmm2M128),
-	/*2354*/ uint16(xMatch),
-	/*2355*/ uint16(xCondPrefix), 2,
-	0x66, 2367,
-	0x0, 2361,
-	/*2361*/ uint16(xSetOp), uint16(PMADDUBSW),
-	/*2363*/ uint16(xReadSlashR),
-	/*2364*/ uint16(xArgMm1),
-	/*2365*/ uint16(xArgMm2M64),
-	/*2366*/ uint16(xMatch),
-	/*2367*/ uint16(xSetOp), uint16(PMADDUBSW),
-	/*2369*/ uint16(xReadSlashR),
-	/*2370*/ uint16(xArgXmm1),
-	/*2371*/ uint16(xArgXmm2M128),
-	/*2372*/ uint16(xMatch),
-	/*2373*/ uint16(xCondPrefix), 2,
-	0x66, 2385,
-	0x0, 2379,
-	/*2379*/ uint16(xSetOp), uint16(PHSUBW),
-	/*2381*/ uint16(xReadSlashR),
-	/*2382*/ uint16(xArgMm1),
-	/*2383*/ uint16(xArgMm2M64),
-	/*2384*/ uint16(xMatch),
-	/*2385*/ uint16(xSetOp), uint16(PHSUBW),
-	/*2387*/ uint16(xReadSlashR),
-	/*2388*/ uint16(xArgXmm1),
-	/*2389*/ uint16(xArgXmm2M128),
-	/*2390*/ uint16(xMatch),
-	/*2391*/ uint16(xCondPrefix), 2,
-	0x66, 2403,
-	0x0, 2397,
-	/*2397*/ uint16(xSetOp), uint16(PHSUBD),
-	/*2399*/ uint16(xReadSlashR),
-	/*2400*/ uint16(xArgMm1),
-	/*2401*/ uint16(xArgMm2M64),
-	/*2402*/ uint16(xMatch),
-	/*2403*/ uint16(xSetOp), uint16(PHSUBD),
-	/*2405*/ uint16(xReadSlashR),
-	/*2406*/ uint16(xArgXmm1),
-	/*2407*/ uint16(xArgXmm2M128),
-	/*2408*/ uint16(xMatch),
-	/*2409*/ uint16(xCondPrefix), 2,
-	0x66, 2421,
-	0x0, 2415,
-	/*2415*/ uint16(xSetOp), uint16(PHSUBSW),
-	/*2417*/ uint16(xReadSlashR),
-	/*2418*/ uint16(xArgMm1),
-	/*2419*/ uint16(xArgMm2M64),
-	/*2420*/ uint16(xMatch),
-	/*2421*/ uint16(xSetOp), uint16(PHSUBSW),
-	/*2423*/ uint16(xReadSlashR),
-	/*2424*/ uint16(xArgXmm1),
-	/*2425*/ uint16(xArgXmm2M128),
-	/*2426*/ uint16(xMatch),
-	/*2427*/ uint16(xCondPrefix), 2,
-	0x66, 2439,
-	0x0, 2433,
-	/*2433*/ uint16(xSetOp), uint16(PSIGNB),
-	/*2435*/ uint16(xReadSlashR),
-	/*2436*/ uint16(xArgMm1),
-	/*2437*/ uint16(xArgMm2M64),
-	/*2438*/ uint16(xMatch),
-	/*2439*/ uint16(xSetOp), uint16(PSIGNB),
-	/*2441*/ uint16(xReadSlashR),
-	/*2442*/ uint16(xArgXmm1),
-	/*2443*/ uint16(xArgXmm2M128),
-	/*2444*/ uint16(xMatch),
-	/*2445*/ uint16(xCondPrefix), 2,
-	0x66, 2457,
-	0x0, 2451,
-	/*2451*/ uint16(xSetOp), uint16(PSIGNW),
-	/*2453*/ uint16(xReadSlashR),
-	/*2454*/ uint16(xArgMm1),
-	/*2455*/ uint16(xArgMm2M64),
-	/*2456*/ uint16(xMatch),
-	/*2457*/ uint16(xSetOp), uint16(PSIGNW),
-	/*2459*/ uint16(xReadSlashR),
-	/*2460*/ uint16(xArgXmm1),
-	/*2461*/ uint16(xArgXmm2M128),
-	/*2462*/ uint16(xMatch),
-	/*2463*/ uint16(xCondPrefix), 2,
-	0x66, 2475,
-	0x0, 2469,
-	/*2469*/ uint16(xSetOp), uint16(PSIGND),
-	/*2471*/ uint16(xReadSlashR),
-	/*2472*/ uint16(xArgMm1),
-	/*2473*/ uint16(xArgMm2M64),
-	/*2474*/ uint16(xMatch),
-	/*2475*/ uint16(xSetOp), uint16(PSIGND),
-	/*2477*/ uint16(xReadSlashR),
-	/*2478*/ uint16(xArgXmm1),
-	/*2479*/ uint16(xArgXmm2M128),
-	/*2480*/ uint16(xMatch),
-	/*2481*/ uint16(xCondPrefix), 2,
-	0x66, 2493,
-	0x0, 2487,
-	/*2487*/ uint16(xSetOp), uint16(PMULHRSW),
-	/*2489*/ uint16(xReadSlashR),
-	/*2490*/ uint16(xArgMm1),
-	/*2491*/ uint16(xArgMm2M64),
-	/*2492*/ uint16(xMatch),
-	/*2493*/ uint16(xSetOp), uint16(PMULHRSW),
-	/*2495*/ uint16(xReadSlashR),
-	/*2496*/ uint16(xArgXmm1),
-	/*2497*/ uint16(xArgXmm2M128),
-	/*2498*/ uint16(xMatch),
-	/*2499*/ uint16(xCondPrefix), 1,
-	0x66, 2503,
-	/*2503*/ uint16(xSetOp), uint16(PBLENDVB),
-	/*2505*/ uint16(xReadSlashR),
-	/*2506*/ uint16(xArgXmm1),
-	/*2507*/ uint16(xArgXmm2M128),
-	/*2508*/ uint16(xArgXMM0),
-	/*2509*/ uint16(xMatch),
-	/*2510*/ uint16(xCondPrefix), 1,
-	0x66, 2514,
-	/*2514*/ uint16(xSetOp), uint16(BLENDVPS),
-	/*2516*/ uint16(xReadSlashR),
-	/*2517*/ uint16(xArgXmm1),
-	/*2518*/ uint16(xArgXmm2M128),
-	/*2519*/ uint16(xArgXMM0),
-	/*2520*/ uint16(xMatch),
-	/*2521*/ uint16(xCondPrefix), 1,
-	0x66, 2525,
-	/*2525*/ uint16(xSetOp), uint16(BLENDVPD),
-	/*2527*/ uint16(xReadSlashR),
-	/*2528*/ uint16(xArgXmm1),
-	/*2529*/ uint16(xArgXmm2M128),
-	/*2530*/ uint16(xArgXMM0),
-	/*2531*/ uint16(xMatch),
-	/*2532*/ uint16(xCondPrefix), 1,
-	0x66, 2536,
-	/*2536*/ uint16(xSetOp), uint16(PTEST),
-	/*2538*/ uint16(xReadSlashR),
-	/*2539*/ uint16(xArgXmm1),
-	/*2540*/ uint16(xArgXmm2M128),
-	/*2541*/ uint16(xMatch),
-	/*2542*/ uint16(xCondPrefix), 2,
-	0x66, 2554,
-	0x0, 2548,
-	/*2548*/ uint16(xSetOp), uint16(PABSB),
-	/*2550*/ uint16(xReadSlashR),
-	/*2551*/ uint16(xArgMm1),
-	/*2552*/ uint16(xArgMm2M64),
-	/*2553*/ uint16(xMatch),
-	/*2554*/ uint16(xSetOp), uint16(PABSB),
-	/*2556*/ uint16(xReadSlashR),
-	/*2557*/ uint16(xArgXmm1),
-	/*2558*/ uint16(xArgXmm2M128),
-	/*2559*/ uint16(xMatch),
-	/*2560*/ uint16(xCondPrefix), 2,
-	0x66, 2572,
-	0x0, 2566,
-	/*2566*/ uint16(xSetOp), uint16(PABSW),
-	/*2568*/ uint16(xReadSlashR),
-	/*2569*/ uint16(xArgMm1),
-	/*2570*/ uint16(xArgMm2M64),
-	/*2571*/ uint16(xMatch),
-	/*2572*/ uint16(xSetOp), uint16(PABSW),
-	/*2574*/ uint16(xReadSlashR),
-	/*2575*/ uint16(xArgXmm1),
-	/*2576*/ uint16(xArgXmm2M128),
-	/*2577*/ uint16(xMatch),
-	/*2578*/ uint16(xCondPrefix), 2,
-	0x66, 2590,
-	0x0, 2584,
-	/*2584*/ uint16(xSetOp), uint16(PABSD),
-	/*2586*/ uint16(xReadSlashR),
-	/*2587*/ uint16(xArgMm1),
-	/*2588*/ uint16(xArgMm2M64),
-	/*2589*/ uint16(xMatch),
-	/*2590*/ uint16(xSetOp), uint16(PABSD),
-	/*2592*/ uint16(xReadSlashR),
-	/*2593*/ uint16(xArgXmm1),
-	/*2594*/ uint16(xArgXmm2M128),
-	/*2595*/ uint16(xMatch),
-	/*2596*/ uint16(xCondPrefix), 1,
-	0x66, 2600,
-	/*2600*/ uint16(xSetOp), uint16(PMOVSXBW),
-	/*2602*/ uint16(xReadSlashR),
-	/*2603*/ uint16(xArgXmm1),
-	/*2604*/ uint16(xArgXmm2M64),
-	/*2605*/ uint16(xMatch),
-	/*2606*/ uint16(xCondPrefix), 1,
-	0x66, 2610,
-	/*2610*/ uint16(xSetOp), uint16(PMOVSXBD),
-	/*2612*/ uint16(xReadSlashR),
-	/*2613*/ uint16(xArgXmm1),
-	/*2614*/ uint16(xArgXmm2M32),
-	/*2615*/ uint16(xMatch),
-	/*2616*/ uint16(xCondPrefix), 1,
-	0x66, 2620,
-	/*2620*/ uint16(xSetOp), uint16(PMOVSXBQ),
-	/*2622*/ uint16(xReadSlashR),
-	/*2623*/ uint16(xArgXmm1),
-	/*2624*/ uint16(xArgXmm2M16),
-	/*2625*/ uint16(xMatch),
-	/*2626*/ uint16(xCondPrefix), 1,
-	0x66, 2630,
-	/*2630*/ uint16(xSetOp), uint16(PMOVSXWD),
-	/*2632*/ uint16(xReadSlashR),
-	/*2633*/ uint16(xArgXmm1),
-	/*2634*/ uint16(xArgXmm2M64),
-	/*2635*/ uint16(xMatch),
-	/*2636*/ uint16(xCondPrefix), 1,
-	0x66, 2640,
-	/*2640*/ uint16(xSetOp), uint16(PMOVSXWQ),
-	/*2642*/ uint16(xReadSlashR),
-	/*2643*/ uint16(xArgXmm1),
-	/*2644*/ uint16(xArgXmm2M32),
-	/*2645*/ uint16(xMatch),
-	/*2646*/ uint16(xCondPrefix), 1,
-	0x66, 2650,
-	/*2650*/ uint16(xSetOp), uint16(PMOVSXDQ),
-	/*2652*/ uint16(xReadSlashR),
-	/*2653*/ uint16(xArgXmm1),
-	/*2654*/ uint16(xArgXmm2M64),
-	/*2655*/ uint16(xMatch),
-	/*2656*/ uint16(xCondPrefix), 1,
-	0x66, 2660,
-	/*2660*/ uint16(xSetOp), uint16(PMULDQ),
-	/*2662*/ uint16(xReadSlashR),
-	/*2663*/ uint16(xArgXmm1),
-	/*2664*/ uint16(xArgXmm2M128),
-	/*2665*/ uint16(xMatch),
-	/*2666*/ uint16(xCondPrefix), 1,
-	0x66, 2670,
-	/*2670*/ uint16(xSetOp), uint16(PCMPEQQ),
-	/*2672*/ uint16(xReadSlashR),
-	/*2673*/ uint16(xArgXmm1),
-	/*2674*/ uint16(xArgXmm2M128),
-	/*2675*/ uint16(xMatch),
-	/*2676*/ uint16(xCondPrefix), 1,
-	0x66, 2680,
-	/*2680*/ uint16(xSetOp), uint16(MOVNTDQA),
-	/*2682*/ uint16(xReadSlashR),
-	/*2683*/ uint16(xArgXmm1),
-	/*2684*/ uint16(xArgM128),
-	/*2685*/ uint16(xMatch),
-	/*2686*/ uint16(xCondPrefix), 1,
-	0x66, 2690,
-	/*2690*/ uint16(xSetOp), uint16(PACKUSDW),
-	/*2692*/ uint16(xReadSlashR),
-	/*2693*/ uint16(xArgXmm1),
-	/*2694*/ uint16(xArgXmm2M128),
-	/*2695*/ uint16(xMatch),
-	/*2696*/ uint16(xCondPrefix), 1,
-	0x66, 2700,
-	/*2700*/ uint16(xSetOp), uint16(PMOVZXBW),
-	/*2702*/ uint16(xReadSlashR),
-	/*2703*/ uint16(xArgXmm1),
-	/*2704*/ uint16(xArgXmm2M64),
-	/*2705*/ uint16(xMatch),
-	/*2706*/ uint16(xCondPrefix), 1,
-	0x66, 2710,
-	/*2710*/ uint16(xSetOp), uint16(PMOVZXBD),
-	/*2712*/ uint16(xReadSlashR),
-	/*2713*/ uint16(xArgXmm1),
-	/*2714*/ uint16(xArgXmm2M32),
-	/*2715*/ uint16(xMatch),
-	/*2716*/ uint16(xCondPrefix), 1,
-	0x66, 2720,
-	/*2720*/ uint16(xSetOp), uint16(PMOVZXBQ),
-	/*2722*/ uint16(xReadSlashR),
-	/*2723*/ uint16(xArgXmm1),
-	/*2724*/ uint16(xArgXmm2M16),
-	/*2725*/ uint16(xMatch),
-	/*2726*/ uint16(xCondPrefix), 1,
-	0x66, 2730,
-	/*2730*/ uint16(xSetOp), uint16(PMOVZXWD),
-	/*2732*/ uint16(xReadSlashR),
-	/*2733*/ uint16(xArgXmm1),
-	/*2734*/ uint16(xArgXmm2M64),
-	/*2735*/ uint16(xMatch),
-	/*2736*/ uint16(xCondPrefix), 1,
-	0x66, 2740,
-	/*2740*/ uint16(xSetOp), uint16(PMOVZXWQ),
-	/*2742*/ uint16(xReadSlashR),
-	/*2743*/ uint16(xArgXmm1),
-	/*2744*/ uint16(xArgXmm2M32),
-	/*2745*/ uint16(xMatch),
-	/*2746*/ uint16(xCondPrefix), 1,
-	0x66, 2750,
-	/*2750*/ uint16(xSetOp), uint16(PMOVZXDQ),
-	/*2752*/ uint16(xReadSlashR),
-	/*2753*/ uint16(xArgXmm1),
-	/*2754*/ uint16(xArgXmm2M64),
-	/*2755*/ uint16(xMatch),
-	/*2756*/ uint16(xCondPrefix), 1,
-	0x66, 2760,
-	/*2760*/ uint16(xSetOp), uint16(PCMPGTQ),
-	/*2762*/ uint16(xReadSlashR),
-	/*2763*/ uint16(xArgXmm1),
-	/*2764*/ uint16(xArgXmm2M128),
-	/*2765*/ uint16(xMatch),
-	/*2766*/ uint16(xCondPrefix), 1,
-	0x66, 2770,
-	/*2770*/ uint16(xSetOp), uint16(PMINSB),
-	/*2772*/ uint16(xReadSlashR),
-	/*2773*/ uint16(xArgXmm1),
-	/*2774*/ uint16(xArgXmm2M128),
-	/*2775*/ uint16(xMatch),
-	/*2776*/ uint16(xCondPrefix), 1,
-	0x66, 2780,
-	/*2780*/ uint16(xSetOp), uint16(PMINSD),
-	/*2782*/ uint16(xReadSlashR),
-	/*2783*/ uint16(xArgXmm1),
-	/*2784*/ uint16(xArgXmm2M128),
-	/*2785*/ uint16(xMatch),
-	/*2786*/ uint16(xCondPrefix), 1,
-	0x66, 2790,
-	/*2790*/ uint16(xSetOp), uint16(PMINUW),
-	/*2792*/ uint16(xReadSlashR),
-	/*2793*/ uint16(xArgXmm1),
-	/*2794*/ uint16(xArgXmm2M128),
-	/*2795*/ uint16(xMatch),
-	/*2796*/ uint16(xCondPrefix), 1,
-	0x66, 2800,
-	/*2800*/ uint16(xSetOp), uint16(PMINUD),
-	/*2802*/ uint16(xReadSlashR),
-	/*2803*/ uint16(xArgXmm1),
-	/*2804*/ uint16(xArgXmm2M128),
-	/*2805*/ uint16(xMatch),
-	/*2806*/ uint16(xCondPrefix), 1,
-	0x66, 2810,
-	/*2810*/ uint16(xSetOp), uint16(PMAXSB),
-	/*2812*/ uint16(xReadSlashR),
-	/*2813*/ uint16(xArgXmm1),
-	/*2814*/ uint16(xArgXmm2M128),
-	/*2815*/ uint16(xMatch),
-	/*2816*/ uint16(xCondPrefix), 1,
-	0x66, 2820,
-	/*2820*/ uint16(xSetOp), uint16(PMAXSD),
-	/*2822*/ uint16(xReadSlashR),
-	/*2823*/ uint16(xArgXmm1),
-	/*2824*/ uint16(xArgXmm2M128),
-	/*2825*/ uint16(xMatch),
-	/*2826*/ uint16(xCondPrefix), 1,
-	0x66, 2830,
-	/*2830*/ uint16(xSetOp), uint16(PMAXUW),
-	/*2832*/ uint16(xReadSlashR),
-	/*2833*/ uint16(xArgXmm1),
-	/*2834*/ uint16(xArgXmm2M128),
-	/*2835*/ uint16(xMatch),
-	/*2836*/ uint16(xCondPrefix), 1,
-	0x66, 2840,
-	/*2840*/ uint16(xSetOp), uint16(PMAXUD),
-	/*2842*/ uint16(xReadSlashR),
-	/*2843*/ uint16(xArgXmm1),
-	/*2844*/ uint16(xArgXmm2M128),
-	/*2845*/ uint16(xMatch),
-	/*2846*/ uint16(xCondPrefix), 1,
-	0x66, 2850,
-	/*2850*/ uint16(xSetOp), uint16(PMULLD),
-	/*2852*/ uint16(xReadSlashR),
-	/*2853*/ uint16(xArgXmm1),
-	/*2854*/ uint16(xArgXmm2M128),
-	/*2855*/ uint16(xMatch),
-	/*2856*/ uint16(xCondPrefix), 1,
-	0x66, 2860,
-	/*2860*/ uint16(xSetOp), uint16(PHMINPOSUW),
-	/*2862*/ uint16(xReadSlashR),
-	/*2863*/ uint16(xArgXmm1),
-	/*2864*/ uint16(xArgXmm2M128),
-	/*2865*/ uint16(xMatch),
-	/*2866*/ uint16(xCondIs64), 2869, 2879,
-	/*2869*/ uint16(xCondPrefix), 1,
-	0x66, 2873,
-	/*2873*/ uint16(xSetOp), uint16(INVPCID),
-	/*2875*/ uint16(xReadSlashR),
-	/*2876*/ uint16(xArgR32),
-	/*2877*/ uint16(xArgM128),
-	/*2878*/ uint16(xMatch),
-	/*2879*/ uint16(xCondPrefix), 1,
-	0x66, 2883,
-	/*2883*/ uint16(xSetOp), uint16(INVPCID),
-	/*2885*/ uint16(xReadSlashR),
-	/*2886*/ uint16(xArgR64),
-	/*2887*/ uint16(xArgM128),
-	/*2888*/ uint16(xMatch),
-	/*2889*/ uint16(xCondPrefix), 1,
-	0x66, 2893,
-	/*2893*/ uint16(xSetOp), uint16(AESIMC),
-	/*2895*/ uint16(xReadSlashR),
-	/*2896*/ uint16(xArgXmm1),
-	/*2897*/ uint16(xArgXmm2M128),
-	/*2898*/ uint16(xMatch),
-	/*2899*/ uint16(xCondPrefix), 1,
-	0x66, 2903,
-	/*2903*/ uint16(xSetOp), uint16(AESENC),
-	/*2905*/ uint16(xReadSlashR),
-	/*2906*/ uint16(xArgXmm1),
-	/*2907*/ uint16(xArgXmm2M128),
-	/*2908*/ uint16(xMatch),
-	/*2909*/ uint16(xCondPrefix), 1,
-	0x66, 2913,
-	/*2913*/ uint16(xSetOp), uint16(AESENCLAST),
-	/*2915*/ uint16(xReadSlashR),
-	/*2916*/ uint16(xArgXmm1),
-	/*2917*/ uint16(xArgXmm2M128),
-	/*2918*/ uint16(xMatch),
-	/*2919*/ uint16(xCondPrefix), 1,
-	0x66, 2923,
-	/*2923*/ uint16(xSetOp), uint16(AESDEC),
-	/*2925*/ uint16(xReadSlashR),
-	/*2926*/ uint16(xArgXmm1),
-	/*2927*/ uint16(xArgXmm2M128),
-	/*2928*/ uint16(xMatch),
-	/*2929*/ uint16(xCondPrefix), 1,
-	0x66, 2933,
-	/*2933*/ uint16(xSetOp), uint16(AESDECLAST),
-	/*2935*/ uint16(xReadSlashR),
-	/*2936*/ uint16(xArgXmm1),
-	/*2937*/ uint16(xArgXmm2M128),
-	/*2938*/ uint16(xMatch),
-	/*2939*/ uint16(xCondIs64), 2942, 2980,
-	/*2942*/ uint16(xCondPrefix), 2,
-	0xF2, 2964,
-	0x0, 2948,
-	/*2948*/ uint16(xCondDataSize), 2952, 2958, 0,
-	/*2952*/ uint16(xSetOp), uint16(MOVBE),
-	/*2954*/ uint16(xReadSlashR),
-	/*2955*/ uint16(xArgR16),
-	/*2956*/ uint16(xArgM16),
-	/*2957*/ uint16(xMatch),
-	/*2958*/ uint16(xSetOp), uint16(MOVBE),
-	/*2960*/ uint16(xReadSlashR),
-	/*2961*/ uint16(xArgR32),
-	/*2962*/ uint16(xArgM32),
-	/*2963*/ uint16(xMatch),
-	/*2964*/ uint16(xCondDataSize), 2968, 2974, 0,
-	/*2968*/ uint16(xSetOp), uint16(CRC32),
-	/*2970*/ uint16(xReadSlashR),
-	/*2971*/ uint16(xArgR32),
-	/*2972*/ uint16(xArgRM8),
-	/*2973*/ uint16(xMatch),
-	/*2974*/ uint16(xSetOp), uint16(CRC32),
-	/*2976*/ uint16(xReadSlashR),
-	/*2977*/ uint16(xArgR32),
-	/*2978*/ uint16(xArgRM8),
-	/*2979*/ uint16(xMatch),
-	/*2980*/ uint16(xCondPrefix), 2,
-	0xF2, 2996,
-	0x0, 2986,
-	/*2986*/ uint16(xCondDataSize), 2952, 2958, 2990,
-	/*2990*/ uint16(xSetOp), uint16(MOVBE),
-	/*2992*/ uint16(xReadSlashR),
-	/*2993*/ uint16(xArgR64),
-	/*2994*/ uint16(xArgM64),
-	/*2995*/ uint16(xMatch),
-	/*2996*/ uint16(xCondDataSize), 2968, 2974, 3000,
-	/*3000*/ uint16(xSetOp), uint16(CRC32),
-	/*3002*/ uint16(xReadSlashR),
-	/*3003*/ uint16(xArgR64),
-	/*3004*/ uint16(xArgRM8),
-	/*3005*/ uint16(xMatch),
-	/*3006*/ uint16(xCondIs64), 3009, 3047,
-	/*3009*/ uint16(xCondPrefix), 2,
-	0xF2, 3031,
-	0x0, 3015,
-	/*3015*/ uint16(xCondDataSize), 3019, 3025, 0,
-	/*3019*/ uint16(xSetOp), uint16(MOVBE),
-	/*3021*/ uint16(xReadSlashR),
-	/*3022*/ uint16(xArgM16),
-	/*3023*/ uint16(xArgR16),
-	/*3024*/ uint16(xMatch),
-	/*3025*/ uint16(xSetOp), uint16(MOVBE),
-	/*3027*/ uint16(xReadSlashR),
-	/*3028*/ uint16(xArgM32),
-	/*3029*/ uint16(xArgR32),
-	/*3030*/ uint16(xMatch),
-	/*3031*/ uint16(xCondDataSize), 3035, 3041, 0,
-	/*3035*/ uint16(xSetOp), uint16(CRC32),
-	/*3037*/ uint16(xReadSlashR),
-	/*3038*/ uint16(xArgR32),
-	/*3039*/ uint16(xArgRM16),
-	/*3040*/ uint16(xMatch),
-	/*3041*/ uint16(xSetOp), uint16(CRC32),
-	/*3043*/ uint16(xReadSlashR),
-	/*3044*/ uint16(xArgR32),
-	/*3045*/ uint16(xArgRM32),
-	/*3046*/ uint16(xMatch),
-	/*3047*/ uint16(xCondPrefix), 2,
-	0xF2, 3063,
-	0x0, 3053,
-	/*3053*/ uint16(xCondDataSize), 3019, 3025, 3057,
-	/*3057*/ uint16(xSetOp), uint16(MOVBE),
-	/*3059*/ uint16(xReadSlashR),
-	/*3060*/ uint16(xArgM64),
-	/*3061*/ uint16(xArgR64),
-	/*3062*/ uint16(xMatch),
-	/*3063*/ uint16(xCondDataSize), 3035, 3041, 3067,
-	/*3067*/ uint16(xSetOp), uint16(CRC32),
-	/*3069*/ uint16(xReadSlashR),
-	/*3070*/ uint16(xArgR64),
-	/*3071*/ uint16(xArgRM64),
-	/*3072*/ uint16(xMatch),
-	/*3073*/ uint16(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(xFail),
-	/*3124*/ uint16(xCondPrefix), 1,
-	0x66, 3128,
-	/*3128*/ uint16(xSetOp), uint16(ROUNDPS),
-	/*3130*/ uint16(xReadSlashR),
-	/*3131*/ uint16(xReadIb),
-	/*3132*/ uint16(xArgXmm1),
-	/*3133*/ uint16(xArgXmm2M128),
-	/*3134*/ uint16(xArgImm8u),
-	/*3135*/ uint16(xMatch),
-	/*3136*/ uint16(xCondPrefix), 1,
-	0x66, 3140,
-	/*3140*/ uint16(xSetOp), uint16(ROUNDPD),
-	/*3142*/ uint16(xReadSlashR),
-	/*3143*/ uint16(xReadIb),
-	/*3144*/ uint16(xArgXmm1),
-	/*3145*/ uint16(xArgXmm2M128),
-	/*3146*/ uint16(xArgImm8u),
-	/*3147*/ uint16(xMatch),
-	/*3148*/ uint16(xCondPrefix), 1,
-	0x66, 3152,
-	/*3152*/ uint16(xSetOp), uint16(ROUNDSS),
-	/*3154*/ uint16(xReadSlashR),
-	/*3155*/ uint16(xReadIb),
-	/*3156*/ uint16(xArgXmm1),
-	/*3157*/ uint16(xArgXmm2M32),
-	/*3158*/ uint16(xArgImm8u),
-	/*3159*/ uint16(xMatch),
-	/*3160*/ uint16(xCondPrefix), 1,
-	0x66, 3164,
-	/*3164*/ uint16(xSetOp), uint16(ROUNDSD),
-	/*3166*/ uint16(xReadSlashR),
-	/*3167*/ uint16(xReadIb),
-	/*3168*/ uint16(xArgXmm1),
-	/*3169*/ uint16(xArgXmm2M64),
-	/*3170*/ uint16(xArgImm8u),
-	/*3171*/ uint16(xMatch),
-	/*3172*/ uint16(xCondPrefix), 1,
-	0x66, 3176,
-	/*3176*/ uint16(xSetOp), uint16(BLENDPS),
-	/*3178*/ uint16(xReadSlashR),
-	/*3179*/ uint16(xReadIb),
-	/*3180*/ uint16(xArgXmm1),
-	/*3181*/ uint16(xArgXmm2M128),
-	/*3182*/ uint16(xArgImm8u),
-	/*3183*/ uint16(xMatch),
-	/*3184*/ uint16(xCondPrefix), 1,
-	0x66, 3188,
-	/*3188*/ uint16(xSetOp), uint16(BLENDPD),
-	/*3190*/ uint16(xReadSlashR),
-	/*3191*/ uint16(xReadIb),
-	/*3192*/ uint16(xArgXmm1),
-	/*3193*/ uint16(xArgXmm2M128),
-	/*3194*/ uint16(xArgImm8u),
-	/*3195*/ uint16(xMatch),
-	/*3196*/ uint16(xCondPrefix), 1,
-	0x66, 3200,
-	/*3200*/ uint16(xSetOp), uint16(PBLENDW),
-	/*3202*/ uint16(xReadSlashR),
-	/*3203*/ uint16(xReadIb),
-	/*3204*/ uint16(xArgXmm1),
-	/*3205*/ uint16(xArgXmm2M128),
-	/*3206*/ uint16(xArgImm8u),
-	/*3207*/ uint16(xMatch),
-	/*3208*/ uint16(xCondPrefix), 2,
-	0x66, 3222,
-	0x0, 3214,
-	/*3214*/ uint16(xSetOp), uint16(PALIGNR),
-	/*3216*/ uint16(xReadSlashR),
-	/*3217*/ uint16(xReadIb),
-	/*3218*/ uint16(xArgMm1),
-	/*3219*/ uint16(xArgMm2M64),
-	/*3220*/ uint16(xArgImm8u),
-	/*3221*/ uint16(xMatch),
-	/*3222*/ uint16(xSetOp), uint16(PALIGNR),
-	/*3224*/ uint16(xReadSlashR),
-	/*3225*/ uint16(xReadIb),
-	/*3226*/ uint16(xArgXmm1),
-	/*3227*/ uint16(xArgXmm2M128),
-	/*3228*/ uint16(xArgImm8u),
-	/*3229*/ uint16(xMatch),
-	/*3230*/ uint16(xCondPrefix), 1,
-	0x66, 3234,
-	/*3234*/ uint16(xSetOp), uint16(PEXTRB),
-	/*3236*/ uint16(xReadSlashR),
-	/*3237*/ uint16(xReadIb),
-	/*3238*/ uint16(xArgR32M8),
-	/*3239*/ uint16(xArgXmm1),
-	/*3240*/ uint16(xArgImm8u),
-	/*3241*/ uint16(xMatch),
-	/*3242*/ uint16(xCondPrefix), 1,
-	0x66, 3246,
-	/*3246*/ uint16(xSetOp), uint16(PEXTRW),
-	/*3248*/ uint16(xReadSlashR),
-	/*3249*/ uint16(xReadIb),
-	/*3250*/ uint16(xArgR32M16),
-	/*3251*/ uint16(xArgXmm1),
-	/*3252*/ uint16(xArgImm8u),
-	/*3253*/ uint16(xMatch),
-	/*3254*/ uint16(xCondIs64), 3257, 3281,
-	/*3257*/ uint16(xCondPrefix), 1,
-	0x66, 3261,
-	/*3261*/ uint16(xCondDataSize), 3265, 3273, 0,
-	/*3265*/ uint16(xSetOp), uint16(PEXTRD),
-	/*3267*/ uint16(xReadSlashR),
-	/*3268*/ uint16(xReadIb),
-	/*3269*/ uint16(xArgRM32),
-	/*3270*/ uint16(xArgXmm1),
-	/*3271*/ uint16(xArgImm8u),
-	/*3272*/ uint16(xMatch),
-	/*3273*/ uint16(xSetOp), uint16(PEXTRD),
-	/*3275*/ uint16(xReadSlashR),
-	/*3276*/ uint16(xReadIb),
-	/*3277*/ uint16(xArgRM32),
-	/*3278*/ uint16(xArgXmm1),
-	/*3279*/ uint16(xArgImm8u),
-	/*3280*/ uint16(xMatch),
-	/*3281*/ uint16(xCondPrefix), 1,
-	0x66, 3285,
-	/*3285*/ uint16(xCondDataSize), 3265, 3273, 3289,
-	/*3289*/ uint16(xSetOp), uint16(PEXTRQ),
-	/*3291*/ uint16(xReadSlashR),
-	/*3292*/ uint16(xReadIb),
-	/*3293*/ uint16(xArgRM64),
-	/*3294*/ uint16(xArgXmm1),
-	/*3295*/ uint16(xArgImm8u),
-	/*3296*/ uint16(xMatch),
-	/*3297*/ uint16(xCondPrefix), 1,
-	0x66, 3301,
-	/*3301*/ uint16(xSetOp), uint16(EXTRACTPS),
-	/*3303*/ uint16(xReadSlashR),
-	/*3304*/ uint16(xReadIb),
-	/*3305*/ uint16(xArgRM32),
-	/*3306*/ uint16(xArgXmm1),
-	/*3307*/ uint16(xArgImm8u),
-	/*3308*/ uint16(xMatch),
-	/*3309*/ uint16(xCondPrefix), 1,
-	0x66, 3313,
-	/*3313*/ uint16(xSetOp), uint16(PINSRB),
-	/*3315*/ uint16(xReadSlashR),
-	/*3316*/ uint16(xReadIb),
-	/*3317*/ uint16(xArgXmm1),
-	/*3318*/ uint16(xArgR32M8),
-	/*3319*/ uint16(xArgImm8u),
-	/*3320*/ uint16(xMatch),
-	/*3321*/ uint16(xCondPrefix), 1,
-	0x66, 3325,
-	/*3325*/ uint16(xSetOp), uint16(INSERTPS),
-	/*3327*/ uint16(xReadSlashR),
-	/*3328*/ uint16(xReadIb),
-	/*3329*/ uint16(xArgXmm1),
-	/*3330*/ uint16(xArgXmm2M32),
-	/*3331*/ uint16(xArgImm8u),
-	/*3332*/ uint16(xMatch),
-	/*3333*/ uint16(xCondIs64), 3336, 3360,
-	/*3336*/ uint16(xCondPrefix), 1,
-	0x66, 3340,
-	/*3340*/ uint16(xCondDataSize), 3344, 3352, 0,
-	/*3344*/ uint16(xSetOp), uint16(PINSRD),
-	/*3346*/ uint16(xReadSlashR),
-	/*3347*/ uint16(xReadIb),
-	/*3348*/ uint16(xArgXmm1),
-	/*3349*/ uint16(xArgRM32),
-	/*3350*/ uint16(xArgImm8u),
-	/*3351*/ uint16(xMatch),
-	/*3352*/ uint16(xSetOp), uint16(PINSRD),
-	/*3354*/ uint16(xReadSlashR),
-	/*3355*/ uint16(xReadIb),
-	/*3356*/ uint16(xArgXmm1),
-	/*3357*/ uint16(xArgRM32),
-	/*3358*/ uint16(xArgImm8u),
-	/*3359*/ uint16(xMatch),
-	/*3360*/ uint16(xCondPrefix), 1,
-	0x66, 3364,
-	/*3364*/ uint16(xCondDataSize), 3344, 3352, 3368,
-	/*3368*/ uint16(xSetOp), uint16(PINSRQ),
-	/*3370*/ uint16(xReadSlashR),
-	/*3371*/ uint16(xReadIb),
-	/*3372*/ uint16(xArgXmm1),
-	/*3373*/ uint16(xArgRM64),
-	/*3374*/ uint16(xArgImm8u),
-	/*3375*/ uint16(xMatch),
-	/*3376*/ uint16(xCondPrefix), 1,
-	0x66, 3380,
-	/*3380*/ uint16(xSetOp), uint16(DPPS),
-	/*3382*/ uint16(xReadSlashR),
-	/*3383*/ uint16(xReadIb),
-	/*3384*/ uint16(xArgXmm1),
-	/*3385*/ uint16(xArgXmm2M128),
-	/*3386*/ uint16(xArgImm8u),
-	/*3387*/ uint16(xMatch),
-	/*3388*/ uint16(xCondPrefix), 1,
-	0x66, 3392,
-	/*3392*/ uint16(xSetOp), uint16(DPPD),
-	/*3394*/ uint16(xReadSlashR),
-	/*3395*/ uint16(xReadIb),
-	/*3396*/ uint16(xArgXmm1),
-	/*3397*/ uint16(xArgXmm2M128),
-	/*3398*/ uint16(xArgImm8u),
-	/*3399*/ uint16(xMatch),
-	/*3400*/ uint16(xCondPrefix), 1,
-	0x66, 3404,
-	/*3404*/ uint16(xSetOp), uint16(MPSADBW),
-	/*3406*/ uint16(xReadSlashR),
-	/*3407*/ uint16(xReadIb),
-	/*3408*/ uint16(xArgXmm1),
-	/*3409*/ uint16(xArgXmm2M128),
-	/*3410*/ uint16(xArgImm8u),
-	/*3411*/ uint16(xMatch),
-	/*3412*/ uint16(xCondPrefix), 1,
-	0x66, 3416,
-	/*3416*/ uint16(xSetOp), uint16(PCLMULQDQ),
-	/*3418*/ uint16(xReadSlashR),
-	/*3419*/ uint16(xReadIb),
-	/*3420*/ uint16(xArgXmm1),
-	/*3421*/ uint16(xArgXmm2M128),
-	/*3422*/ uint16(xArgImm8u),
-	/*3423*/ uint16(xMatch),
-	/*3424*/ uint16(xCondPrefix), 1,
-	0x66, 3428,
-	/*3428*/ uint16(xSetOp), uint16(PCMPESTRM),
-	/*3430*/ uint16(xReadSlashR),
-	/*3431*/ uint16(xReadIb),
-	/*3432*/ uint16(xArgXmm1),
-	/*3433*/ uint16(xArgXmm2M128),
-	/*3434*/ uint16(xArgImm8u),
-	/*3435*/ uint16(xMatch),
-	/*3436*/ uint16(xCondPrefix), 1,
-	0x66, 3440,
-	/*3440*/ uint16(xSetOp), uint16(PCMPESTRI),
-	/*3442*/ uint16(xReadSlashR),
-	/*3443*/ uint16(xReadIb),
-	/*3444*/ uint16(xArgXmm1),
-	/*3445*/ uint16(xArgXmm2M128),
-	/*3446*/ uint16(xArgImm8u),
-	/*3447*/ uint16(xMatch),
-	/*3448*/ uint16(xCondPrefix), 1,
-	0x66, 3452,
-	/*3452*/ uint16(xSetOp), uint16(PCMPISTRM),
-	/*3454*/ uint16(xReadSlashR),
-	/*3455*/ uint16(xReadIb),
-	/*3456*/ uint16(xArgXmm1),
-	/*3457*/ uint16(xArgXmm2M128),
-	/*3458*/ uint16(xArgImm8u),
-	/*3459*/ uint16(xMatch),
-	/*3460*/ uint16(xCondPrefix), 1,
-	0x66, 3464,
-	/*3464*/ uint16(xSetOp), uint16(PCMPISTRI),
-	/*3466*/ uint16(xReadSlashR),
-	/*3467*/ uint16(xReadIb),
-	/*3468*/ uint16(xArgXmm1),
-	/*3469*/ uint16(xArgXmm2M128),
-	/*3470*/ uint16(xArgImm8u),
-	/*3471*/ uint16(xMatch),
-	/*3472*/ uint16(xCondPrefix), 1,
-	0x66, 3476,
-	/*3476*/ uint16(xSetOp), uint16(AESKEYGENASSIST),
-	/*3478*/ uint16(xReadSlashR),
-	/*3479*/ uint16(xReadIb),
-	/*3480*/ uint16(xArgXmm1),
-	/*3481*/ uint16(xArgXmm2M128),
-	/*3482*/ uint16(xArgImm8u),
-	/*3483*/ uint16(xMatch),
-	/*3484*/ uint16(xCondIs64), 3487, 3503,
-	/*3487*/ uint16(xCondDataSize), 3491, 3497, 0,
-	/*3491*/ uint16(xSetOp), uint16(CMOVO),
-	/*3493*/ uint16(xReadSlashR),
-	/*3494*/ uint16(xArgR16),
-	/*3495*/ uint16(xArgRM16),
-	/*3496*/ uint16(xMatch),
-	/*3497*/ uint16(xSetOp), uint16(CMOVO),
-	/*3499*/ uint16(xReadSlashR),
-	/*3500*/ uint16(xArgR32),
-	/*3501*/ uint16(xArgRM32),
-	/*3502*/ uint16(xMatch),
-	/*3503*/ uint16(xCondDataSize), 3491, 3497, 3507,
-	/*3507*/ uint16(xSetOp), uint16(CMOVO),
-	/*3509*/ uint16(xReadSlashR),
-	/*3510*/ uint16(xArgR64),
-	/*3511*/ uint16(xArgRM64),
-	/*3512*/ uint16(xMatch),
-	/*3513*/ uint16(xCondIs64), 3516, 3532,
-	/*3516*/ uint16(xCondDataSize), 3520, 3526, 0,
-	/*3520*/ uint16(xSetOp), uint16(CMOVNO),
-	/*3522*/ uint16(xReadSlashR),
-	/*3523*/ uint16(xArgR16),
-	/*3524*/ uint16(xArgRM16),
-	/*3525*/ uint16(xMatch),
-	/*3526*/ uint16(xSetOp), uint16(CMOVNO),
-	/*3528*/ uint16(xReadSlashR),
-	/*3529*/ uint16(xArgR32),
-	/*3530*/ uint16(xArgRM32),
-	/*3531*/ uint16(xMatch),
-	/*3532*/ uint16(xCondDataSize), 3520, 3526, 3536,
-	/*3536*/ uint16(xSetOp), uint16(CMOVNO),
-	/*3538*/ uint16(xReadSlashR),
-	/*3539*/ uint16(xArgR64),
-	/*3540*/ uint16(xArgRM64),
-	/*3541*/ uint16(xMatch),
-	/*3542*/ uint16(xCondIs64), 3545, 3561,
-	/*3545*/ uint16(xCondDataSize), 3549, 3555, 0,
-	/*3549*/ uint16(xSetOp), uint16(CMOVB),
-	/*3551*/ uint16(xReadSlashR),
-	/*3552*/ uint16(xArgR16),
-	/*3553*/ uint16(xArgRM16),
-	/*3554*/ uint16(xMatch),
-	/*3555*/ uint16(xSetOp), uint16(CMOVB),
-	/*3557*/ uint16(xReadSlashR),
-	/*3558*/ uint16(xArgR32),
-	/*3559*/ uint16(xArgRM32),
-	/*3560*/ uint16(xMatch),
-	/*3561*/ uint16(xCondDataSize), 3549, 3555, 3565,
-	/*3565*/ uint16(xSetOp), uint16(CMOVB),
-	/*3567*/ uint16(xReadSlashR),
-	/*3568*/ uint16(xArgR64),
-	/*3569*/ uint16(xArgRM64),
-	/*3570*/ uint16(xMatch),
-	/*3571*/ uint16(xCondIs64), 3574, 3590,
-	/*3574*/ uint16(xCondDataSize), 3578, 3584, 0,
-	/*3578*/ uint16(xSetOp), uint16(CMOVAE),
-	/*3580*/ uint16(xReadSlashR),
-	/*3581*/ uint16(xArgR16),
-	/*3582*/ uint16(xArgRM16),
-	/*3583*/ uint16(xMatch),
-	/*3584*/ uint16(xSetOp), uint16(CMOVAE),
-	/*3586*/ uint16(xReadSlashR),
-	/*3587*/ uint16(xArgR32),
-	/*3588*/ uint16(xArgRM32),
-	/*3589*/ uint16(xMatch),
-	/*3590*/ uint16(xCondDataSize), 3578, 3584, 3594,
-	/*3594*/ uint16(xSetOp), uint16(CMOVAE),
-	/*3596*/ uint16(xReadSlashR),
-	/*3597*/ uint16(xArgR64),
-	/*3598*/ uint16(xArgRM64),
-	/*3599*/ uint16(xMatch),
-	/*3600*/ uint16(xCondIs64), 3603, 3619,
-	/*3603*/ uint16(xCondDataSize), 3607, 3613, 0,
-	/*3607*/ uint16(xSetOp), uint16(CMOVE),
-	/*3609*/ uint16(xReadSlashR),
-	/*3610*/ uint16(xArgR16),
-	/*3611*/ uint16(xArgRM16),
-	/*3612*/ uint16(xMatch),
-	/*3613*/ uint16(xSetOp), uint16(CMOVE),
-	/*3615*/ uint16(xReadSlashR),
-	/*3616*/ uint16(xArgR32),
-	/*3617*/ uint16(xArgRM32),
-	/*3618*/ uint16(xMatch),
-	/*3619*/ uint16(xCondDataSize), 3607, 3613, 3623,
-	/*3623*/ uint16(xSetOp), uint16(CMOVE),
-	/*3625*/ uint16(xReadSlashR),
-	/*3626*/ uint16(xArgR64),
-	/*3627*/ uint16(xArgRM64),
-	/*3628*/ uint16(xMatch),
-	/*3629*/ uint16(xCondIs64), 3632, 3648,
-	/*3632*/ uint16(xCondDataSize), 3636, 3642, 0,
-	/*3636*/ uint16(xSetOp), uint16(CMOVNE),
-	/*3638*/ uint16(xReadSlashR),
-	/*3639*/ uint16(xArgR16),
-	/*3640*/ uint16(xArgRM16),
-	/*3641*/ uint16(xMatch),
-	/*3642*/ uint16(xSetOp), uint16(CMOVNE),
-	/*3644*/ uint16(xReadSlashR),
-	/*3645*/ uint16(xArgR32),
-	/*3646*/ uint16(xArgRM32),
-	/*3647*/ uint16(xMatch),
-	/*3648*/ uint16(xCondDataSize), 3636, 3642, 3652,
-	/*3652*/ uint16(xSetOp), uint16(CMOVNE),
-	/*3654*/ uint16(xReadSlashR),
-	/*3655*/ uint16(xArgR64),
-	/*3656*/ uint16(xArgRM64),
-	/*3657*/ uint16(xMatch),
-	/*3658*/ uint16(xCondIs64), 3661, 3677,
-	/*3661*/ uint16(xCondDataSize), 3665, 3671, 0,
-	/*3665*/ uint16(xSetOp), uint16(CMOVBE),
-	/*3667*/ uint16(xReadSlashR),
-	/*3668*/ uint16(xArgR16),
-	/*3669*/ uint16(xArgRM16),
-	/*3670*/ uint16(xMatch),
-	/*3671*/ uint16(xSetOp), uint16(CMOVBE),
-	/*3673*/ uint16(xReadSlashR),
-	/*3674*/ uint16(xArgR32),
-	/*3675*/ uint16(xArgRM32),
-	/*3676*/ uint16(xMatch),
-	/*3677*/ uint16(xCondDataSize), 3665, 3671, 3681,
-	/*3681*/ uint16(xSetOp), uint16(CMOVBE),
-	/*3683*/ uint16(xReadSlashR),
-	/*3684*/ uint16(xArgR64),
-	/*3685*/ uint16(xArgRM64),
-	/*3686*/ uint16(xMatch),
-	/*3687*/ uint16(xCondIs64), 3690, 3706,
-	/*3690*/ uint16(xCondDataSize), 3694, 3700, 0,
-	/*3694*/ uint16(xSetOp), uint16(CMOVA),
-	/*3696*/ uint16(xReadSlashR),
-	/*3697*/ uint16(xArgR16),
-	/*3698*/ uint16(xArgRM16),
-	/*3699*/ uint16(xMatch),
-	/*3700*/ uint16(xSetOp), uint16(CMOVA),
-	/*3702*/ uint16(xReadSlashR),
-	/*3703*/ uint16(xArgR32),
-	/*3704*/ uint16(xArgRM32),
-	/*3705*/ uint16(xMatch),
-	/*3706*/ uint16(xCondDataSize), 3694, 3700, 3710,
-	/*3710*/ uint16(xSetOp), uint16(CMOVA),
-	/*3712*/ uint16(xReadSlashR),
-	/*3713*/ uint16(xArgR64),
-	/*3714*/ uint16(xArgRM64),
-	/*3715*/ uint16(xMatch),
-	/*3716*/ uint16(xCondIs64), 3719, 3735,
-	/*3719*/ uint16(xCondDataSize), 3723, 3729, 0,
-	/*3723*/ uint16(xSetOp), uint16(CMOVS),
-	/*3725*/ uint16(xReadSlashR),
-	/*3726*/ uint16(xArgR16),
-	/*3727*/ uint16(xArgRM16),
-	/*3728*/ uint16(xMatch),
-	/*3729*/ uint16(xSetOp), uint16(CMOVS),
-	/*3731*/ uint16(xReadSlashR),
-	/*3732*/ uint16(xArgR32),
-	/*3733*/ uint16(xArgRM32),
-	/*3734*/ uint16(xMatch),
-	/*3735*/ uint16(xCondDataSize), 3723, 3729, 3739,
-	/*3739*/ uint16(xSetOp), uint16(CMOVS),
-	/*3741*/ uint16(xReadSlashR),
-	/*3742*/ uint16(xArgR64),
-	/*3743*/ uint16(xArgRM64),
-	/*3744*/ uint16(xMatch),
-	/*3745*/ uint16(xCondIs64), 3748, 3764,
-	/*3748*/ uint16(xCondDataSize), 3752, 3758, 0,
-	/*3752*/ uint16(xSetOp), uint16(CMOVNS),
-	/*3754*/ uint16(xReadSlashR),
-	/*3755*/ uint16(xArgR16),
-	/*3756*/ uint16(xArgRM16),
-	/*3757*/ uint16(xMatch),
-	/*3758*/ uint16(xSetOp), uint16(CMOVNS),
-	/*3760*/ uint16(xReadSlashR),
-	/*3761*/ uint16(xArgR32),
-	/*3762*/ uint16(xArgRM32),
-	/*3763*/ uint16(xMatch),
-	/*3764*/ uint16(xCondDataSize), 3752, 3758, 3768,
-	/*3768*/ uint16(xSetOp), uint16(CMOVNS),
-	/*3770*/ uint16(xReadSlashR),
-	/*3771*/ uint16(xArgR64),
-	/*3772*/ uint16(xArgRM64),
-	/*3773*/ uint16(xMatch),
-	/*3774*/ uint16(xCondIs64), 3777, 3793,
-	/*3777*/ uint16(xCondDataSize), 3781, 3787, 0,
-	/*3781*/ uint16(xSetOp), uint16(CMOVP),
-	/*3783*/ uint16(xReadSlashR),
-	/*3784*/ uint16(xArgR16),
-	/*3785*/ uint16(xArgRM16),
-	/*3786*/ uint16(xMatch),
-	/*3787*/ uint16(xSetOp), uint16(CMOVP),
-	/*3789*/ uint16(xReadSlashR),
-	/*3790*/ uint16(xArgR32),
-	/*3791*/ uint16(xArgRM32),
-	/*3792*/ uint16(xMatch),
-	/*3793*/ uint16(xCondDataSize), 3781, 3787, 3797,
-	/*3797*/ uint16(xSetOp), uint16(CMOVP),
-	/*3799*/ uint16(xReadSlashR),
-	/*3800*/ uint16(xArgR64),
-	/*3801*/ uint16(xArgRM64),
-	/*3802*/ uint16(xMatch),
-	/*3803*/ uint16(xCondIs64), 3806, 3822,
-	/*3806*/ uint16(xCondDataSize), 3810, 3816, 0,
-	/*3810*/ uint16(xSetOp), uint16(CMOVNP),
-	/*3812*/ uint16(xReadSlashR),
-	/*3813*/ uint16(xArgR16),
-	/*3814*/ uint16(xArgRM16),
-	/*3815*/ uint16(xMatch),
-	/*3816*/ uint16(xSetOp), uint16(CMOVNP),
-	/*3818*/ uint16(xReadSlashR),
-	/*3819*/ uint16(xArgR32),
-	/*3820*/ uint16(xArgRM32),
-	/*3821*/ uint16(xMatch),
-	/*3822*/ uint16(xCondDataSize), 3810, 3816, 3826,
-	/*3826*/ uint16(xSetOp), uint16(CMOVNP),
-	/*3828*/ uint16(xReadSlashR),
-	/*3829*/ uint16(xArgR64),
-	/*3830*/ uint16(xArgRM64),
-	/*3831*/ uint16(xMatch),
-	/*3832*/ uint16(xCondIs64), 3835, 3851,
-	/*3835*/ uint16(xCondDataSize), 3839, 3845, 0,
-	/*3839*/ uint16(xSetOp), uint16(CMOVL),
-	/*3841*/ uint16(xReadSlashR),
-	/*3842*/ uint16(xArgR16),
-	/*3843*/ uint16(xArgRM16),
-	/*3844*/ uint16(xMatch),
-	/*3845*/ uint16(xSetOp), uint16(CMOVL),
-	/*3847*/ uint16(xReadSlashR),
-	/*3848*/ uint16(xArgR32),
-	/*3849*/ uint16(xArgRM32),
-	/*3850*/ uint16(xMatch),
-	/*3851*/ uint16(xCondDataSize), 3839, 3845, 3855,
-	/*3855*/ uint16(xSetOp), uint16(CMOVL),
-	/*3857*/ uint16(xReadSlashR),
-	/*3858*/ uint16(xArgR64),
-	/*3859*/ uint16(xArgRM64),
-	/*3860*/ uint16(xMatch),
-	/*3861*/ uint16(xCondIs64), 3864, 3880,
-	/*3864*/ uint16(xCondDataSize), 3868, 3874, 0,
-	/*3868*/ uint16(xSetOp), uint16(CMOVGE),
-	/*3870*/ uint16(xReadSlashR),
-	/*3871*/ uint16(xArgR16),
-	/*3872*/ uint16(xArgRM16),
-	/*3873*/ uint16(xMatch),
-	/*3874*/ uint16(xSetOp), uint16(CMOVGE),
-	/*3876*/ uint16(xReadSlashR),
-	/*3877*/ uint16(xArgR32),
-	/*3878*/ uint16(xArgRM32),
-	/*3879*/ uint16(xMatch),
-	/*3880*/ uint16(xCondDataSize), 3868, 3874, 3884,
-	/*3884*/ uint16(xSetOp), uint16(CMOVGE),
-	/*3886*/ uint16(xReadSlashR),
-	/*3887*/ uint16(xArgR64),
-	/*3888*/ uint16(xArgRM64),
-	/*3889*/ uint16(xMatch),
-	/*3890*/ uint16(xCondIs64), 3893, 3909,
-	/*3893*/ uint16(xCondDataSize), 3897, 3903, 0,
-	/*3897*/ uint16(xSetOp), uint16(CMOVLE),
-	/*3899*/ uint16(xReadSlashR),
-	/*3900*/ uint16(xArgR16),
-	/*3901*/ uint16(xArgRM16),
-	/*3902*/ uint16(xMatch),
-	/*3903*/ uint16(xSetOp), uint16(CMOVLE),
-	/*3905*/ uint16(xReadSlashR),
-	/*3906*/ uint16(xArgR32),
-	/*3907*/ uint16(xArgRM32),
-	/*3908*/ uint16(xMatch),
-	/*3909*/ uint16(xCondDataSize), 3897, 3903, 3913,
-	/*3913*/ uint16(xSetOp), uint16(CMOVLE),
-	/*3915*/ uint16(xReadSlashR),
-	/*3916*/ uint16(xArgR64),
-	/*3917*/ uint16(xArgRM64),
-	/*3918*/ uint16(xMatch),
-	/*3919*/ uint16(xCondIs64), 3922, 3938,
-	/*3922*/ uint16(xCondDataSize), 3926, 3932, 0,
-	/*3926*/ uint16(xSetOp), uint16(CMOVG),
-	/*3928*/ uint16(xReadSlashR),
-	/*3929*/ uint16(xArgR16),
-	/*3930*/ uint16(xArgRM16),
-	/*3931*/ uint16(xMatch),
-	/*3932*/ uint16(xSetOp), uint16(CMOVG),
-	/*3934*/ uint16(xReadSlashR),
-	/*3935*/ uint16(xArgR32),
-	/*3936*/ uint16(xArgRM32),
-	/*3937*/ uint16(xMatch),
-	/*3938*/ uint16(xCondDataSize), 3926, 3932, 3942,
-	/*3942*/ uint16(xSetOp), uint16(CMOVG),
-	/*3944*/ uint16(xReadSlashR),
-	/*3945*/ uint16(xArgR64),
-	/*3946*/ uint16(xArgRM64),
-	/*3947*/ uint16(xMatch),
-	/*3948*/ uint16(xCondPrefix), 2,
-	0x66, 3960,
-	0x0, 3954,
-	/*3954*/ uint16(xSetOp), uint16(MOVMSKPS),
-	/*3956*/ uint16(xReadSlashR),
-	/*3957*/ uint16(xArgR32),
-	/*3958*/ uint16(xArgXmm2),
-	/*3959*/ uint16(xMatch),
-	/*3960*/ uint16(xSetOp), uint16(MOVMSKPD),
-	/*3962*/ uint16(xReadSlashR),
-	/*3963*/ uint16(xArgR32),
-	/*3964*/ uint16(xArgXmm2),
-	/*3965*/ uint16(xMatch),
-	/*3966*/ uint16(xCondPrefix), 4,
-	0xF3, 3994,
-	0xF2, 3988,
-	0x66, 3982,
-	0x0, 3976,
-	/*3976*/ uint16(xSetOp), uint16(SQRTPS),
-	/*3978*/ uint16(xReadSlashR),
-	/*3979*/ uint16(xArgXmm1),
-	/*3980*/ uint16(xArgXmm2M128),
-	/*3981*/ uint16(xMatch),
-	/*3982*/ uint16(xSetOp), uint16(SQRTPD),
-	/*3984*/ uint16(xReadSlashR),
-	/*3985*/ uint16(xArgXmm1),
-	/*3986*/ uint16(xArgXmm2M128),
-	/*3987*/ uint16(xMatch),
-	/*3988*/ uint16(xSetOp), uint16(SQRTSD),
-	/*3990*/ uint16(xReadSlashR),
-	/*3991*/ uint16(xArgXmm1),
-	/*3992*/ uint16(xArgXmm2M64),
-	/*3993*/ uint16(xMatch),
-	/*3994*/ uint16(xSetOp), uint16(SQRTSS),
-	/*3996*/ uint16(xReadSlashR),
-	/*3997*/ uint16(xArgXmm1),
-	/*3998*/ uint16(xArgXmm2M32),
-	/*3999*/ uint16(xMatch),
-	/*4000*/ uint16(xCondPrefix), 2,
-	0xF3, 4012,
-	0x0, 4006,
-	/*4006*/ uint16(xSetOp), uint16(RSQRTPS),
-	/*4008*/ uint16(xReadSlashR),
-	/*4009*/ uint16(xArgXmm1),
-	/*4010*/ uint16(xArgXmm2M128),
-	/*4011*/ uint16(xMatch),
-	/*4012*/ uint16(xSetOp), uint16(RSQRTSS),
-	/*4014*/ uint16(xReadSlashR),
-	/*4015*/ uint16(xArgXmm1),
-	/*4016*/ uint16(xArgXmm2M32),
-	/*4017*/ uint16(xMatch),
-	/*4018*/ uint16(xCondPrefix), 2,
-	0xF3, 4030,
-	0x0, 4024,
-	/*4024*/ uint16(xSetOp), uint16(RCPPS),
-	/*4026*/ uint16(xReadSlashR),
-	/*4027*/ uint16(xArgXmm1),
-	/*4028*/ uint16(xArgXmm2M128),
-	/*4029*/ uint16(xMatch),
-	/*4030*/ uint16(xSetOp), uint16(RCPSS),
-	/*4032*/ uint16(xReadSlashR),
-	/*4033*/ uint16(xArgXmm1),
-	/*4034*/ uint16(xArgXmm2M32),
-	/*4035*/ uint16(xMatch),
-	/*4036*/ uint16(xCondPrefix), 2,
-	0x66, 4048,
-	0x0, 4042,
-	/*4042*/ uint16(xSetOp), uint16(ANDPS),
-	/*4044*/ uint16(xReadSlashR),
-	/*4045*/ uint16(xArgXmm1),
-	/*4046*/ uint16(xArgXmm2M128),
-	/*4047*/ uint16(xMatch),
-	/*4048*/ uint16(xSetOp), uint16(ANDPD),
-	/*4050*/ uint16(xReadSlashR),
-	/*4051*/ uint16(xArgXmm1),
-	/*4052*/ uint16(xArgXmm2M128),
-	/*4053*/ uint16(xMatch),
-	/*4054*/ uint16(xCondPrefix), 2,
-	0x66, 4066,
-	0x0, 4060,
-	/*4060*/ uint16(xSetOp), uint16(ANDNPS),
-	/*4062*/ uint16(xReadSlashR),
-	/*4063*/ uint16(xArgXmm1),
-	/*4064*/ uint16(xArgXmm2M128),
-	/*4065*/ uint16(xMatch),
-	/*4066*/ uint16(xSetOp), uint16(ANDNPD),
-	/*4068*/ uint16(xReadSlashR),
-	/*4069*/ uint16(xArgXmm1),
-	/*4070*/ uint16(xArgXmm2M128),
-	/*4071*/ uint16(xMatch),
-	/*4072*/ uint16(xCondPrefix), 2,
-	0x66, 4084,
-	0x0, 4078,
-	/*4078*/ uint16(xSetOp), uint16(ORPS),
-	/*4080*/ uint16(xReadSlashR),
-	/*4081*/ uint16(xArgXmm1),
-	/*4082*/ uint16(xArgXmm2M128),
-	/*4083*/ uint16(xMatch),
-	/*4084*/ uint16(xSetOp), uint16(ORPD),
-	/*4086*/ uint16(xReadSlashR),
-	/*4087*/ uint16(xArgXmm1),
-	/*4088*/ uint16(xArgXmm2M128),
-	/*4089*/ uint16(xMatch),
-	/*4090*/ uint16(xCondPrefix), 2,
-	0x66, 4102,
-	0x0, 4096,
-	/*4096*/ uint16(xSetOp), uint16(XORPS),
-	/*4098*/ uint16(xReadSlashR),
-	/*4099*/ uint16(xArgXmm1),
-	/*4100*/ uint16(xArgXmm2M128),
-	/*4101*/ uint16(xMatch),
-	/*4102*/ uint16(xSetOp), uint16(XORPD),
-	/*4104*/ uint16(xReadSlashR),
-	/*4105*/ uint16(xArgXmm1),
-	/*4106*/ uint16(xArgXmm2M128),
-	/*4107*/ uint16(xMatch),
-	/*4108*/ uint16(xCondPrefix), 4,
-	0xF3, 4136,
-	0xF2, 4130,
-	0x66, 4124,
-	0x0, 4118,
-	/*4118*/ uint16(xSetOp), uint16(ADDPS),
-	/*4120*/ uint16(xReadSlashR),
-	/*4121*/ uint16(xArgXmm1),
-	/*4122*/ uint16(xArgXmm2M128),
-	/*4123*/ uint16(xMatch),
-	/*4124*/ uint16(xSetOp), uint16(ADDPD),
-	/*4126*/ uint16(xReadSlashR),
-	/*4127*/ uint16(xArgXmm1),
-	/*4128*/ uint16(xArgXmm2M128),
-	/*4129*/ uint16(xMatch),
-	/*4130*/ uint16(xSetOp), uint16(ADDSD),
-	/*4132*/ uint16(xReadSlashR),
-	/*4133*/ uint16(xArgXmm1),
-	/*4134*/ uint16(xArgXmm2M64),
-	/*4135*/ uint16(xMatch),
-	/*4136*/ uint16(xSetOp), uint16(ADDSS),
-	/*4138*/ uint16(xReadSlashR),
-	/*4139*/ uint16(xArgXmm1),
-	/*4140*/ uint16(xArgXmm2M32),
-	/*4141*/ uint16(xMatch),
-	/*4142*/ uint16(xCondPrefix), 4,
-	0xF3, 4170,
-	0xF2, 4164,
-	0x66, 4158,
-	0x0, 4152,
-	/*4152*/ uint16(xSetOp), uint16(MULPS),
-	/*4154*/ uint16(xReadSlashR),
-	/*4155*/ uint16(xArgXmm1),
-	/*4156*/ uint16(xArgXmm2M128),
-	/*4157*/ uint16(xMatch),
-	/*4158*/ uint16(xSetOp), uint16(MULPD),
-	/*4160*/ uint16(xReadSlashR),
-	/*4161*/ uint16(xArgXmm1),
-	/*4162*/ uint16(xArgXmm2M128),
-	/*4163*/ uint16(xMatch),
-	/*4164*/ uint16(xSetOp), uint16(MULSD),
-	/*4166*/ uint16(xReadSlashR),
-	/*4167*/ uint16(xArgXmm1),
-	/*4168*/ uint16(xArgXmm2M64),
-	/*4169*/ uint16(xMatch),
-	/*4170*/ uint16(xSetOp), uint16(MULSS),
-	/*4172*/ uint16(xReadSlashR),
-	/*4173*/ uint16(xArgXmm1),
-	/*4174*/ uint16(xArgXmm2M32),
-	/*4175*/ uint16(xMatch),
-	/*4176*/ uint16(xCondPrefix), 4,
-	0xF3, 4204,
-	0xF2, 4198,
-	0x66, 4192,
-	0x0, 4186,
-	/*4186*/ uint16(xSetOp), uint16(CVTPS2PD),
-	/*4188*/ uint16(xReadSlashR),
-	/*4189*/ uint16(xArgXmm1),
-	/*4190*/ uint16(xArgXmm2M64),
-	/*4191*/ uint16(xMatch),
-	/*4192*/ uint16(xSetOp), uint16(CVTPD2PS),
-	/*4194*/ uint16(xReadSlashR),
-	/*4195*/ uint16(xArgXmm1),
-	/*4196*/ uint16(xArgXmm2M128),
-	/*4197*/ uint16(xMatch),
-	/*4198*/ uint16(xSetOp), uint16(CVTSD2SS),
-	/*4200*/ uint16(xReadSlashR),
-	/*4201*/ uint16(xArgXmm1),
-	/*4202*/ uint16(xArgXmm2M64),
-	/*4203*/ uint16(xMatch),
-	/*4204*/ uint16(xSetOp), uint16(CVTSS2SD),
-	/*4206*/ uint16(xReadSlashR),
-	/*4207*/ uint16(xArgXmm1),
-	/*4208*/ uint16(xArgXmm2M32),
-	/*4209*/ uint16(xMatch),
-	/*4210*/ uint16(xCondPrefix), 3,
-	0xF3, 4230,
-	0x66, 4224,
-	0x0, 4218,
-	/*4218*/ uint16(xSetOp), uint16(CVTDQ2PS),
-	/*4220*/ uint16(xReadSlashR),
-	/*4221*/ uint16(xArgXmm1),
-	/*4222*/ uint16(xArgXmm2M128),
-	/*4223*/ uint16(xMatch),
-	/*4224*/ uint16(xSetOp), uint16(CVTPS2DQ),
-	/*4226*/ uint16(xReadSlashR),
-	/*4227*/ uint16(xArgXmm1),
-	/*4228*/ uint16(xArgXmm2M128),
-	/*4229*/ uint16(xMatch),
-	/*4230*/ uint16(xSetOp), uint16(CVTTPS2DQ),
-	/*4232*/ uint16(xReadSlashR),
-	/*4233*/ uint16(xArgXmm1),
-	/*4234*/ uint16(xArgXmm2M128),
-	/*4235*/ uint16(xMatch),
-	/*4236*/ uint16(xCondPrefix), 4,
-	0xF3, 4264,
-	0xF2, 4258,
-	0x66, 4252,
-	0x0, 4246,
-	/*4246*/ uint16(xSetOp), uint16(SUBPS),
-	/*4248*/ uint16(xReadSlashR),
-	/*4249*/ uint16(xArgXmm1),
-	/*4250*/ uint16(xArgXmm2M128),
-	/*4251*/ uint16(xMatch),
-	/*4252*/ uint16(xSetOp), uint16(SUBPD),
-	/*4254*/ uint16(xReadSlashR),
-	/*4255*/ uint16(xArgXmm1),
-	/*4256*/ uint16(xArgXmm2M128),
-	/*4257*/ uint16(xMatch),
-	/*4258*/ uint16(xSetOp), uint16(SUBSD),
-	/*4260*/ uint16(xReadSlashR),
-	/*4261*/ uint16(xArgXmm1),
-	/*4262*/ uint16(xArgXmm2M64),
-	/*4263*/ uint16(xMatch),
-	/*4264*/ uint16(xSetOp), uint16(SUBSS),
-	/*4266*/ uint16(xReadSlashR),
-	/*4267*/ uint16(xArgXmm1),
-	/*4268*/ uint16(xArgXmm2M32),
-	/*4269*/ uint16(xMatch),
-	/*4270*/ uint16(xCondPrefix), 4,
-	0xF3, 4298,
-	0xF2, 4292,
-	0x66, 4286,
-	0x0, 4280,
-	/*4280*/ uint16(xSetOp), uint16(MINPS),
-	/*4282*/ uint16(xReadSlashR),
-	/*4283*/ uint16(xArgXmm1),
-	/*4284*/ uint16(xArgXmm2M128),
-	/*4285*/ uint16(xMatch),
-	/*4286*/ uint16(xSetOp), uint16(MINPD),
-	/*4288*/ uint16(xReadSlashR),
-	/*4289*/ uint16(xArgXmm1),
-	/*4290*/ uint16(xArgXmm2M128),
-	/*4291*/ uint16(xMatch),
-	/*4292*/ uint16(xSetOp), uint16(MINSD),
-	/*4294*/ uint16(xReadSlashR),
-	/*4295*/ uint16(xArgXmm1),
-	/*4296*/ uint16(xArgXmm2M64),
-	/*4297*/ uint16(xMatch),
-	/*4298*/ uint16(xSetOp), uint16(MINSS),
-	/*4300*/ uint16(xReadSlashR),
-	/*4301*/ uint16(xArgXmm1),
-	/*4302*/ uint16(xArgXmm2M32),
-	/*4303*/ uint16(xMatch),
-	/*4304*/ uint16(xCondPrefix), 4,
-	0xF3, 4332,
-	0xF2, 4326,
-	0x66, 4320,
-	0x0, 4314,
-	/*4314*/ uint16(xSetOp), uint16(DIVPS),
-	/*4316*/ uint16(xReadSlashR),
-	/*4317*/ uint16(xArgXmm1),
-	/*4318*/ uint16(xArgXmm2M128),
-	/*4319*/ uint16(xMatch),
-	/*4320*/ uint16(xSetOp), uint16(DIVPD),
-	/*4322*/ uint16(xReadSlashR),
-	/*4323*/ uint16(xArgXmm1),
-	/*4324*/ uint16(xArgXmm2M128),
-	/*4325*/ uint16(xMatch),
-	/*4326*/ uint16(xSetOp), uint16(DIVSD),
-	/*4328*/ uint16(xReadSlashR),
-	/*4329*/ uint16(xArgXmm1),
-	/*4330*/ uint16(xArgXmm2M64),
-	/*4331*/ uint16(xMatch),
-	/*4332*/ uint16(xSetOp), uint16(DIVSS),
-	/*4334*/ uint16(xReadSlashR),
-	/*4335*/ uint16(xArgXmm1),
-	/*4336*/ uint16(xArgXmm2M32),
-	/*4337*/ uint16(xMatch),
-	/*4338*/ uint16(xCondPrefix), 4,
-	0xF3, 4366,
-	0xF2, 4360,
-	0x66, 4354,
-	0x0, 4348,
-	/*4348*/ uint16(xSetOp), uint16(MAXPS),
-	/*4350*/ uint16(xReadSlashR),
-	/*4351*/ uint16(xArgXmm1),
-	/*4352*/ uint16(xArgXmm2M128),
-	/*4353*/ uint16(xMatch),
-	/*4354*/ uint16(xSetOp), uint16(MAXPD),
-	/*4356*/ uint16(xReadSlashR),
-	/*4357*/ uint16(xArgXmm1),
-	/*4358*/ uint16(xArgXmm2M128),
-	/*4359*/ uint16(xMatch),
-	/*4360*/ uint16(xSetOp), uint16(MAXSD),
-	/*4362*/ uint16(xReadSlashR),
-	/*4363*/ uint16(xArgXmm1),
-	/*4364*/ uint16(xArgXmm2M64),
-	/*4365*/ uint16(xMatch),
-	/*4366*/ uint16(xSetOp), uint16(MAXSS),
-	/*4368*/ uint16(xReadSlashR),
-	/*4369*/ uint16(xArgXmm1),
-	/*4370*/ uint16(xArgXmm2M32),
-	/*4371*/ uint16(xMatch),
-	/*4372*/ uint16(xCondPrefix), 2,
-	0x66, 4384,
-	0x0, 4378,
-	/*4378*/ uint16(xSetOp), uint16(PUNPCKLBW),
-	/*4380*/ uint16(xReadSlashR),
-	/*4381*/ uint16(xArgMm),
-	/*4382*/ uint16(xArgMmM32),
-	/*4383*/ uint16(xMatch),
-	/*4384*/ uint16(xSetOp), uint16(PUNPCKLBW),
-	/*4386*/ uint16(xReadSlashR),
-	/*4387*/ uint16(xArgXmm1),
-	/*4388*/ uint16(xArgXmm2M128),
-	/*4389*/ uint16(xMatch),
-	/*4390*/ uint16(xCondPrefix), 2,
-	0x66, 4402,
-	0x0, 4396,
-	/*4396*/ uint16(xSetOp), uint16(PUNPCKLWD),
-	/*4398*/ uint16(xReadSlashR),
-	/*4399*/ uint16(xArgMm),
-	/*4400*/ uint16(xArgMmM32),
-	/*4401*/ uint16(xMatch),
-	/*4402*/ uint16(xSetOp), uint16(PUNPCKLWD),
-	/*4404*/ uint16(xReadSlashR),
-	/*4405*/ uint16(xArgXmm1),
-	/*4406*/ uint16(xArgXmm2M128),
-	/*4407*/ uint16(xMatch),
-	/*4408*/ uint16(xCondPrefix), 2,
-	0x66, 4420,
-	0x0, 4414,
-	/*4414*/ uint16(xSetOp), uint16(PUNPCKLDQ),
-	/*4416*/ uint16(xReadSlashR),
-	/*4417*/ uint16(xArgMm),
-	/*4418*/ uint16(xArgMmM32),
-	/*4419*/ uint16(xMatch),
-	/*4420*/ uint16(xSetOp), uint16(PUNPCKLDQ),
-	/*4422*/ uint16(xReadSlashR),
-	/*4423*/ uint16(xArgXmm1),
-	/*4424*/ uint16(xArgXmm2M128),
-	/*4425*/ uint16(xMatch),
-	/*4426*/ uint16(xCondPrefix), 2,
-	0x66, 4438,
-	0x0, 4432,
-	/*4432*/ uint16(xSetOp), uint16(PACKSSWB),
-	/*4434*/ uint16(xReadSlashR),
-	/*4435*/ uint16(xArgMm1),
-	/*4436*/ uint16(xArgMm2M64),
-	/*4437*/ uint16(xMatch),
-	/*4438*/ uint16(xSetOp), uint16(PACKSSWB),
-	/*4440*/ uint16(xReadSlashR),
-	/*4441*/ uint16(xArgXmm1),
-	/*4442*/ uint16(xArgXmm2M128),
-	/*4443*/ uint16(xMatch),
-	/*4444*/ uint16(xCondPrefix), 2,
-	0x66, 4456,
-	0x0, 4450,
-	/*4450*/ uint16(xSetOp), uint16(PCMPGTB),
-	/*4452*/ uint16(xReadSlashR),
-	/*4453*/ uint16(xArgMm),
-	/*4454*/ uint16(xArgMmM64),
-	/*4455*/ uint16(xMatch),
-	/*4456*/ uint16(xSetOp), uint16(PCMPGTB),
-	/*4458*/ uint16(xReadSlashR),
-	/*4459*/ uint16(xArgXmm1),
-	/*4460*/ uint16(xArgXmm2M128),
-	/*4461*/ uint16(xMatch),
-	/*4462*/ uint16(xCondPrefix), 2,
-	0x66, 4474,
-	0x0, 4468,
-	/*4468*/ uint16(xSetOp), uint16(PCMPGTW),
-	/*4470*/ uint16(xReadSlashR),
-	/*4471*/ uint16(xArgMm),
-	/*4472*/ uint16(xArgMmM64),
-	/*4473*/ uint16(xMatch),
-	/*4474*/ uint16(xSetOp), uint16(PCMPGTW),
-	/*4476*/ uint16(xReadSlashR),
-	/*4477*/ uint16(xArgXmm1),
-	/*4478*/ uint16(xArgXmm2M128),
-	/*4479*/ uint16(xMatch),
-	/*4480*/ uint16(xCondPrefix), 2,
-	0x66, 4492,
-	0x0, 4486,
-	/*4486*/ uint16(xSetOp), uint16(PCMPGTD),
-	/*4488*/ uint16(xReadSlashR),
-	/*4489*/ uint16(xArgMm),
-	/*4490*/ uint16(xArgMmM64),
-	/*4491*/ uint16(xMatch),
-	/*4492*/ uint16(xSetOp), uint16(PCMPGTD),
-	/*4494*/ uint16(xReadSlashR),
-	/*4495*/ uint16(xArgXmm1),
-	/*4496*/ uint16(xArgXmm2M128),
-	/*4497*/ uint16(xMatch),
-	/*4498*/ uint16(xCondPrefix), 2,
-	0x66, 4510,
-	0x0, 4504,
-	/*4504*/ uint16(xSetOp), uint16(PACKUSWB),
-	/*4506*/ uint16(xReadSlashR),
-	/*4507*/ uint16(xArgMm),
-	/*4508*/ uint16(xArgMmM64),
-	/*4509*/ uint16(xMatch),
-	/*4510*/ uint16(xSetOp), uint16(PACKUSWB),
-	/*4512*/ uint16(xReadSlashR),
-	/*4513*/ uint16(xArgXmm1),
-	/*4514*/ uint16(xArgXmm2M128),
-	/*4515*/ uint16(xMatch),
-	/*4516*/ uint16(xCondPrefix), 2,
-	0x66, 4528,
-	0x0, 4522,
-	/*4522*/ uint16(xSetOp), uint16(PUNPCKHBW),
-	/*4524*/ uint16(xReadSlashR),
-	/*4525*/ uint16(xArgMm),
-	/*4526*/ uint16(xArgMmM64),
-	/*4527*/ uint16(xMatch),
-	/*4528*/ uint16(xSetOp), uint16(PUNPCKHBW),
-	/*4530*/ uint16(xReadSlashR),
-	/*4531*/ uint16(xArgXmm1),
-	/*4532*/ uint16(xArgXmm2M128),
-	/*4533*/ uint16(xMatch),
-	/*4534*/ uint16(xCondPrefix), 2,
-	0x66, 4546,
-	0x0, 4540,
-	/*4540*/ uint16(xSetOp), uint16(PUNPCKHWD),
-	/*4542*/ uint16(xReadSlashR),
-	/*4543*/ uint16(xArgMm),
-	/*4544*/ uint16(xArgMmM64),
-	/*4545*/ uint16(xMatch),
-	/*4546*/ uint16(xSetOp), uint16(PUNPCKHWD),
-	/*4548*/ uint16(xReadSlashR),
-	/*4549*/ uint16(xArgXmm1),
-	/*4550*/ uint16(xArgXmm2M128),
-	/*4551*/ uint16(xMatch),
-	/*4552*/ uint16(xCondPrefix), 2,
-	0x66, 4564,
-	0x0, 4558,
-	/*4558*/ uint16(xSetOp), uint16(PUNPCKHDQ),
-	/*4560*/ uint16(xReadSlashR),
-	/*4561*/ uint16(xArgMm),
-	/*4562*/ uint16(xArgMmM64),
-	/*4563*/ uint16(xMatch),
-	/*4564*/ uint16(xSetOp), uint16(PUNPCKHDQ),
-	/*4566*/ uint16(xReadSlashR),
-	/*4567*/ uint16(xArgXmm1),
-	/*4568*/ uint16(xArgXmm2M128),
-	/*4569*/ uint16(xMatch),
-	/*4570*/ uint16(xCondPrefix), 2,
-	0x66, 4582,
-	0x0, 4576,
-	/*4576*/ uint16(xSetOp), uint16(PACKSSDW),
-	/*4578*/ uint16(xReadSlashR),
-	/*4579*/ uint16(xArgMm1),
-	/*4580*/ uint16(xArgMm2M64),
-	/*4581*/ uint16(xMatch),
-	/*4582*/ uint16(xSetOp), uint16(PACKSSDW),
-	/*4584*/ uint16(xReadSlashR),
-	/*4585*/ uint16(xArgXmm1),
-	/*4586*/ uint16(xArgXmm2M128),
-	/*4587*/ uint16(xMatch),
-	/*4588*/ uint16(xCondPrefix), 1,
-	0x66, 4592,
-	/*4592*/ uint16(xSetOp), uint16(PUNPCKLQDQ),
-	/*4594*/ uint16(xReadSlashR),
-	/*4595*/ uint16(xArgXmm1),
-	/*4596*/ uint16(xArgXmm2M128),
-	/*4597*/ uint16(xMatch),
-	/*4598*/ uint16(xCondPrefix), 1,
-	0x66, 4602,
-	/*4602*/ uint16(xSetOp), uint16(PUNPCKHQDQ),
-	/*4604*/ uint16(xReadSlashR),
-	/*4605*/ uint16(xArgXmm1),
-	/*4606*/ uint16(xArgXmm2M128),
-	/*4607*/ uint16(xMatch),
-	/*4608*/ uint16(xCondIs64), 4611, 4649,
-	/*4611*/ uint16(xCondPrefix), 2,
-	0x66, 4633,
-	0x0, 4617,
-	/*4617*/ uint16(xCondDataSize), 4621, 4627, 0,
-	/*4621*/ uint16(xSetOp), uint16(MOVD),
-	/*4623*/ uint16(xReadSlashR),
-	/*4624*/ uint16(xArgMm),
-	/*4625*/ uint16(xArgRM32),
-	/*4626*/ uint16(xMatch),
-	/*4627*/ uint16(xSetOp), uint16(MOVD),
-	/*4629*/ uint16(xReadSlashR),
-	/*4630*/ uint16(xArgMm),
-	/*4631*/ uint16(xArgRM32),
-	/*4632*/ uint16(xMatch),
-	/*4633*/ uint16(xCondDataSize), 4637, 4643, 0,
-	/*4637*/ uint16(xSetOp), uint16(MOVD),
-	/*4639*/ uint16(xReadSlashR),
-	/*4640*/ uint16(xArgXmm),
-	/*4641*/ uint16(xArgRM32),
-	/*4642*/ uint16(xMatch),
-	/*4643*/ uint16(xSetOp), uint16(MOVD),
-	/*4645*/ uint16(xReadSlashR),
-	/*4646*/ uint16(xArgXmm),
-	/*4647*/ uint16(xArgRM32),
-	/*4648*/ uint16(xMatch),
-	/*4649*/ uint16(xCondPrefix), 2,
-	0x66, 4665,
-	0x0, 4655,
-	/*4655*/ uint16(xCondDataSize), 4621, 4627, 4659,
-	/*4659*/ uint16(xSetOp), uint16(MOVQ),
-	/*4661*/ uint16(xReadSlashR),
-	/*4662*/ uint16(xArgMm),
-	/*4663*/ uint16(xArgRM64),
-	/*4664*/ uint16(xMatch),
-	/*4665*/ uint16(xCondDataSize), 4637, 4643, 4669,
-	/*4669*/ uint16(xSetOp), uint16(MOVQ),
-	/*4671*/ uint16(xReadSlashR),
-	/*4672*/ uint16(xArgXmm),
-	/*4673*/ uint16(xArgRM64),
-	/*4674*/ uint16(xMatch),
-	/*4675*/ uint16(xCondPrefix), 3,
-	0xF3, 4695,
-	0x66, 4689,
-	0x0, 4683,
-	/*4683*/ uint16(xSetOp), uint16(MOVQ),
-	/*4685*/ uint16(xReadSlashR),
-	/*4686*/ uint16(xArgMm),
-	/*4687*/ uint16(xArgMmM64),
-	/*4688*/ uint16(xMatch),
-	/*4689*/ uint16(xSetOp), uint16(MOVDQA),
-	/*4691*/ uint16(xReadSlashR),
-	/*4692*/ uint16(xArgXmm1),
-	/*4693*/ uint16(xArgXmm2M128),
-	/*4694*/ uint16(xMatch),
-	/*4695*/ uint16(xSetOp), uint16(MOVDQU),
-	/*4697*/ uint16(xReadSlashR),
-	/*4698*/ uint16(xArgXmm1),
-	/*4699*/ uint16(xArgXmm2M128),
-	/*4700*/ uint16(xMatch),
-	/*4701*/ uint16(xCondPrefix), 4,
-	0xF3, 4735,
-	0xF2, 4727,
-	0x66, 4719,
-	0x0, 4711,
-	/*4711*/ uint16(xSetOp), uint16(PSHUFW),
-	/*4713*/ uint16(xReadSlashR),
-	/*4714*/ uint16(xReadIb),
-	/*4715*/ uint16(xArgMm1),
-	/*4716*/ uint16(xArgMm2M64),
-	/*4717*/ uint16(xArgImm8u),
-	/*4718*/ uint16(xMatch),
-	/*4719*/ uint16(xSetOp), uint16(PSHUFD),
-	/*4721*/ uint16(xReadSlashR),
-	/*4722*/ uint16(xReadIb),
-	/*4723*/ uint16(xArgXmm1),
-	/*4724*/ uint16(xArgXmm2M128),
-	/*4725*/ uint16(xArgImm8u),
-	/*4726*/ uint16(xMatch),
-	/*4727*/ uint16(xSetOp), uint16(PSHUFLW),
-	/*4729*/ uint16(xReadSlashR),
-	/*4730*/ uint16(xReadIb),
-	/*4731*/ uint16(xArgXmm1),
-	/*4732*/ uint16(xArgXmm2M128),
-	/*4733*/ uint16(xArgImm8u),
-	/*4734*/ uint16(xMatch),
-	/*4735*/ uint16(xSetOp), uint16(PSHUFHW),
-	/*4737*/ uint16(xReadSlashR),
-	/*4738*/ uint16(xReadIb),
-	/*4739*/ uint16(xArgXmm1),
-	/*4740*/ uint16(xArgXmm2M128),
-	/*4741*/ uint16(xArgImm8u),
-	/*4742*/ uint16(xMatch),
-	/*4743*/ uint16(xCondSlashR),
-	0,    // 0
-	0,    // 1
-	4752, // 2
-	0,    // 3
-	4770, // 4
-	0,    // 5
-	4788, // 6
-	0,    // 7
-	/*4752*/ uint16(xCondPrefix), 2,
-	0x66, 4764,
-	0x0, 4758,
-	/*4758*/ uint16(xSetOp), uint16(PSRLW),
-	/*4760*/ uint16(xReadIb),
-	/*4761*/ uint16(xArgMm2),
-	/*4762*/ uint16(xArgImm8u),
-	/*4763*/ uint16(xMatch),
-	/*4764*/ uint16(xSetOp), uint16(PSRLW),
-	/*4766*/ uint16(xReadIb),
-	/*4767*/ uint16(xArgXmm2),
-	/*4768*/ uint16(xArgImm8u),
-	/*4769*/ uint16(xMatch),
-	/*4770*/ uint16(xCondPrefix), 2,
-	0x66, 4782,
-	0x0, 4776,
-	/*4776*/ uint16(xSetOp), uint16(PSRAW),
-	/*4778*/ uint16(xReadIb),
-	/*4779*/ uint16(xArgMm2),
-	/*4780*/ uint16(xArgImm8u),
-	/*4781*/ uint16(xMatch),
-	/*4782*/ uint16(xSetOp), uint16(PSRAW),
-	/*4784*/ uint16(xReadIb),
-	/*4785*/ uint16(xArgXmm2),
-	/*4786*/ uint16(xArgImm8u),
-	/*4787*/ uint16(xMatch),
-	/*4788*/ uint16(xCondPrefix), 2,
-	0x66, 4800,
-	0x0, 4794,
-	/*4794*/ uint16(xSetOp), uint16(PSLLW),
-	/*4796*/ uint16(xReadIb),
-	/*4797*/ uint16(xArgMm2),
-	/*4798*/ uint16(xArgImm8u),
-	/*4799*/ uint16(xMatch),
-	/*4800*/ uint16(xSetOp), uint16(PSLLW),
-	/*4802*/ uint16(xReadIb),
-	/*4803*/ uint16(xArgXmm2),
-	/*4804*/ uint16(xArgImm8u),
-	/*4805*/ uint16(xMatch),
-	/*4806*/ uint16(xCondSlashR),
-	0,    // 0
-	0,    // 1
-	4815, // 2
-	0,    // 3
-	4833, // 4
-	0,    // 5
-	4851, // 6
-	0,    // 7
-	/*4815*/ uint16(xCondPrefix), 2,
-	0x66, 4827,
-	0x0, 4821,
-	/*4821*/ uint16(xSetOp), uint16(PSRLD),
-	/*4823*/ uint16(xReadIb),
-	/*4824*/ uint16(xArgMm2),
-	/*4825*/ uint16(xArgImm8u),
-	/*4826*/ uint16(xMatch),
-	/*4827*/ uint16(xSetOp), uint16(PSRLD),
-	/*4829*/ uint16(xReadIb),
-	/*4830*/ uint16(xArgXmm2),
-	/*4831*/ uint16(xArgImm8u),
-	/*4832*/ uint16(xMatch),
-	/*4833*/ uint16(xCondPrefix), 2,
-	0x66, 4845,
-	0x0, 4839,
-	/*4839*/ uint16(xSetOp), uint16(PSRAD),
-	/*4841*/ uint16(xReadIb),
-	/*4842*/ uint16(xArgMm2),
-	/*4843*/ uint16(xArgImm8u),
-	/*4844*/ uint16(xMatch),
-	/*4845*/ uint16(xSetOp), uint16(PSRAD),
-	/*4847*/ uint16(xReadIb),
-	/*4848*/ uint16(xArgXmm2),
-	/*4849*/ uint16(xArgImm8u),
-	/*4850*/ uint16(xMatch),
-	/*4851*/ uint16(xCondPrefix), 2,
-	0x66, 4863,
-	0x0, 4857,
-	/*4857*/ uint16(xSetOp), uint16(PSLLD),
-	/*4859*/ uint16(xReadIb),
-	/*4860*/ uint16(xArgMm2),
-	/*4861*/ uint16(xArgImm8u),
-	/*4862*/ uint16(xMatch),
-	/*4863*/ uint16(xSetOp), uint16(PSLLD),
-	/*4865*/ uint16(xReadIb),
-	/*4866*/ uint16(xArgXmm2),
-	/*4867*/ uint16(xArgImm8u),
-	/*4868*/ uint16(xMatch),
-	/*4869*/ uint16(xCondSlashR),
-	0,    // 0
-	0,    // 1
-	4878, // 2
-	4896, // 3
-	0,    // 4
-	0,    // 5
-	4906, // 6
-	4924, // 7
-	/*4878*/ uint16(xCondPrefix), 2,
-	0x66, 4890,
-	0x0, 4884,
-	/*4884*/ uint16(xSetOp), uint16(PSRLQ),
-	/*4886*/ uint16(xReadIb),
-	/*4887*/ uint16(xArgMm2),
-	/*4888*/ uint16(xArgImm8u),
-	/*4889*/ uint16(xMatch),
-	/*4890*/ uint16(xSetOp), uint16(PSRLQ),
-	/*4892*/ uint16(xReadIb),
-	/*4893*/ uint16(xArgXmm2),
-	/*4894*/ uint16(xArgImm8u),
-	/*4895*/ uint16(xMatch),
-	/*4896*/ uint16(xCondPrefix), 1,
-	0x66, 4900,
-	/*4900*/ uint16(xSetOp), uint16(PSRLDQ),
-	/*4902*/ uint16(xReadIb),
-	/*4903*/ uint16(xArgXmm2),
-	/*4904*/ uint16(xArgImm8u),
-	/*4905*/ uint16(xMatch),
-	/*4906*/ uint16(xCondPrefix), 2,
-	0x66, 4918,
-	0x0, 4912,
-	/*4912*/ uint16(xSetOp), uint16(PSLLQ),
-	/*4914*/ uint16(xReadIb),
-	/*4915*/ uint16(xArgMm2),
-	/*4916*/ uint16(xArgImm8u),
-	/*4917*/ uint16(xMatch),
-	/*4918*/ uint16(xSetOp), uint16(PSLLQ),
-	/*4920*/ uint16(xReadIb),
-	/*4921*/ uint16(xArgXmm2),
-	/*4922*/ uint16(xArgImm8u),
-	/*4923*/ uint16(xMatch),
-	/*4924*/ uint16(xCondPrefix), 1,
-	0x66, 4928,
-	/*4928*/ uint16(xSetOp), uint16(PSLLDQ),
-	/*4930*/ uint16(xReadIb),
-	/*4931*/ uint16(xArgXmm2),
-	/*4932*/ uint16(xArgImm8u),
-	/*4933*/ uint16(xMatch),
-	/*4934*/ uint16(xCondPrefix), 2,
-	0x66, 4946,
-	0x0, 4940,
-	/*4940*/ uint16(xSetOp), uint16(PCMPEQB),
-	/*4942*/ uint16(xReadSlashR),
-	/*4943*/ uint16(xArgMm),
-	/*4944*/ uint16(xArgMmM64),
-	/*4945*/ uint16(xMatch),
-	/*4946*/ uint16(xSetOp), uint16(PCMPEQB),
-	/*4948*/ uint16(xReadSlashR),
-	/*4949*/ uint16(xArgXmm1),
-	/*4950*/ uint16(xArgXmm2M128),
-	/*4951*/ uint16(xMatch),
-	/*4952*/ uint16(xCondPrefix), 2,
-	0x66, 4964,
-	0x0, 4958,
-	/*4958*/ uint16(xSetOp), uint16(PCMPEQW),
-	/*4960*/ uint16(xReadSlashR),
-	/*4961*/ uint16(xArgMm),
-	/*4962*/ uint16(xArgMmM64),
-	/*4963*/ uint16(xMatch),
-	/*4964*/ uint16(xSetOp), uint16(PCMPEQW),
-	/*4966*/ uint16(xReadSlashR),
-	/*4967*/ uint16(xArgXmm1),
-	/*4968*/ uint16(xArgXmm2M128),
-	/*4969*/ uint16(xMatch),
-	/*4970*/ uint16(xCondPrefix), 2,
-	0x66, 4982,
-	0x0, 4976,
-	/*4976*/ uint16(xSetOp), uint16(PCMPEQD),
-	/*4978*/ uint16(xReadSlashR),
-	/*4979*/ uint16(xArgMm),
-	/*4980*/ uint16(xArgMmM64),
-	/*4981*/ uint16(xMatch),
-	/*4982*/ uint16(xSetOp), uint16(PCMPEQD),
-	/*4984*/ uint16(xReadSlashR),
-	/*4985*/ uint16(xArgXmm1),
-	/*4986*/ uint16(xArgXmm2M128),
-	/*4987*/ uint16(xMatch),
-	/*4988*/ uint16(xSetOp), uint16(EMMS),
-	/*4990*/ uint16(xMatch),
-	/*4991*/ uint16(xCondPrefix), 2,
-	0xF2, 5003,
-	0x66, 4997,
-	/*4997*/ uint16(xSetOp), uint16(HADDPD),
-	/*4999*/ uint16(xReadSlashR),
-	/*5000*/ uint16(xArgXmm1),
-	/*5001*/ uint16(xArgXmm2M128),
-	/*5002*/ uint16(xMatch),
-	/*5003*/ uint16(xSetOp), uint16(HADDPS),
-	/*5005*/ uint16(xReadSlashR),
-	/*5006*/ uint16(xArgXmm1),
-	/*5007*/ uint16(xArgXmm2M128),
-	/*5008*/ uint16(xMatch),
-	/*5009*/ uint16(xCondPrefix), 2,
-	0xF2, 5021,
-	0x66, 5015,
-	/*5015*/ uint16(xSetOp), uint16(HSUBPD),
-	/*5017*/ uint16(xReadSlashR),
-	/*5018*/ uint16(xArgXmm1),
-	/*5019*/ uint16(xArgXmm2M128),
-	/*5020*/ uint16(xMatch),
-	/*5021*/ uint16(xSetOp), uint16(HSUBPS),
-	/*5023*/ uint16(xReadSlashR),
-	/*5024*/ uint16(xArgXmm1),
-	/*5025*/ uint16(xArgXmm2M128),
-	/*5026*/ uint16(xMatch),
-	/*5027*/ uint16(xCondIs64), 5030, 5076,
-	/*5030*/ uint16(xCondPrefix), 3,
-	0xF3, 5070,
-	0x66, 5054,
-	0x0, 5038,
-	/*5038*/ uint16(xCondDataSize), 5042, 5048, 0,
-	/*5042*/ uint16(xSetOp), uint16(MOVD),
-	/*5044*/ uint16(xReadSlashR),
-	/*5045*/ uint16(xArgRM32),
-	/*5046*/ uint16(xArgMm),
-	/*5047*/ uint16(xMatch),
-	/*5048*/ uint16(xSetOp), uint16(MOVD),
-	/*5050*/ uint16(xReadSlashR),
-	/*5051*/ uint16(xArgRM32),
-	/*5052*/ uint16(xArgMm),
-	/*5053*/ uint16(xMatch),
-	/*5054*/ uint16(xCondDataSize), 5058, 5064, 0,
-	/*5058*/ uint16(xSetOp), uint16(MOVD),
-	/*5060*/ uint16(xReadSlashR),
-	/*5061*/ uint16(xArgRM32),
-	/*5062*/ uint16(xArgXmm),
-	/*5063*/ uint16(xMatch),
-	/*5064*/ uint16(xSetOp), uint16(MOVD),
-	/*5066*/ uint16(xReadSlashR),
-	/*5067*/ uint16(xArgRM32),
-	/*5068*/ uint16(xArgXmm),
-	/*5069*/ uint16(xMatch),
-	/*5070*/ uint16(xSetOp), uint16(MOVQ),
-	/*5072*/ uint16(xReadSlashR),
-	/*5073*/ uint16(xArgXmm1),
-	/*5074*/ uint16(xArgXmm2M64),
-	/*5075*/ uint16(xMatch),
-	/*5076*/ uint16(xCondPrefix), 3,
-	0xF3, 5070,
-	0x66, 5094,
-	0x0, 5084,
-	/*5084*/ uint16(xCondDataSize), 5042, 5048, 5088,
-	/*5088*/ uint16(xSetOp), uint16(MOVQ),
-	/*5090*/ uint16(xReadSlashR),
-	/*5091*/ uint16(xArgRM64),
-	/*5092*/ uint16(xArgMm),
-	/*5093*/ uint16(xMatch),
-	/*5094*/ uint16(xCondDataSize), 5058, 5064, 5098,
-	/*5098*/ uint16(xSetOp), uint16(MOVQ),
-	/*5100*/ uint16(xReadSlashR),
-	/*5101*/ uint16(xArgRM64),
-	/*5102*/ uint16(xArgXmm),
-	/*5103*/ uint16(xMatch),
-	/*5104*/ uint16(xCondPrefix), 3,
-	0xF3, 5124,
-	0x66, 5118,
-	0x0, 5112,
-	/*5112*/ uint16(xSetOp), uint16(MOVQ),
-	/*5114*/ uint16(xReadSlashR),
-	/*5115*/ uint16(xArgMmM64),
-	/*5116*/ uint16(xArgMm),
-	/*5117*/ uint16(xMatch),
-	/*5118*/ uint16(xSetOp), uint16(MOVDQA),
-	/*5120*/ uint16(xReadSlashR),
-	/*5121*/ uint16(xArgXmm2M128),
-	/*5122*/ uint16(xArgXmm1),
-	/*5123*/ uint16(xMatch),
-	/*5124*/ uint16(xSetOp), uint16(MOVDQU),
-	/*5126*/ uint16(xReadSlashR),
-	/*5127*/ uint16(xArgXmm2M128),
-	/*5128*/ uint16(xArgXmm1),
-	/*5129*/ uint16(xMatch),
-	/*5130*/ uint16(xCondIs64), 5133, 5147,
-	/*5133*/ uint16(xCondDataSize), 5137, 5142, 0,
-	/*5137*/ uint16(xSetOp), uint16(JO),
-	/*5139*/ uint16(xReadCw),
-	/*5140*/ uint16(xArgRel16),
-	/*5141*/ uint16(xMatch),
-	/*5142*/ uint16(xSetOp), uint16(JO),
-	/*5144*/ uint16(xReadCd),
-	/*5145*/ uint16(xArgRel32),
-	/*5146*/ uint16(xMatch),
-	/*5147*/ uint16(xCondDataSize), 5151, 5142, 5156,
-	/*5151*/ uint16(xSetOp), uint16(JO),
-	/*5153*/ uint16(xReadCd),
-	/*5154*/ uint16(xArgRel32),
-	/*5155*/ uint16(xMatch),
-	/*5156*/ uint16(xSetOp), uint16(JO),
-	/*5158*/ uint16(xReadCd),
-	/*5159*/ uint16(xArgRel32),
-	/*5160*/ uint16(xMatch),
-	/*5161*/ uint16(xCondIs64), 5164, 5178,
-	/*5164*/ uint16(xCondDataSize), 5168, 5173, 0,
-	/*5168*/ uint16(xSetOp), uint16(JNO),
-	/*5170*/ uint16(xReadCw),
-	/*5171*/ uint16(xArgRel16),
-	/*5172*/ uint16(xMatch),
-	/*5173*/ uint16(xSetOp), uint16(JNO),
-	/*5175*/ uint16(xReadCd),
-	/*5176*/ uint16(xArgRel32),
-	/*5177*/ uint16(xMatch),
-	/*5178*/ uint16(xCondDataSize), 5182, 5173, 5187,
-	/*5182*/ uint16(xSetOp), uint16(JNO),
-	/*5184*/ uint16(xReadCd),
-	/*5185*/ uint16(xArgRel32),
-	/*5186*/ uint16(xMatch),
-	/*5187*/ uint16(xSetOp), uint16(JNO),
-	/*5189*/ uint16(xReadCd),
-	/*5190*/ uint16(xArgRel32),
-	/*5191*/ uint16(xMatch),
-	/*5192*/ uint16(xCondIs64), 5195, 5209,
-	/*5195*/ uint16(xCondDataSize), 5199, 5204, 0,
-	/*5199*/ uint16(xSetOp), uint16(JB),
-	/*5201*/ uint16(xReadCw),
-	/*5202*/ uint16(xArgRel16),
-	/*5203*/ uint16(xMatch),
-	/*5204*/ uint16(xSetOp), uint16(JB),
-	/*5206*/ uint16(xReadCd),
-	/*5207*/ uint16(xArgRel32),
-	/*5208*/ uint16(xMatch),
-	/*5209*/ uint16(xCondDataSize), 5213, 5204, 5218,
-	/*5213*/ uint16(xSetOp), uint16(JB),
-	/*5215*/ uint16(xReadCd),
-	/*5216*/ uint16(xArgRel32),
-	/*5217*/ uint16(xMatch),
-	/*5218*/ uint16(xSetOp), uint16(JB),
-	/*5220*/ uint16(xReadCd),
-	/*5221*/ uint16(xArgRel32),
-	/*5222*/ uint16(xMatch),
-	/*5223*/ uint16(xCondIs64), 5226, 5240,
-	/*5226*/ uint16(xCondDataSize), 5230, 5235, 0,
-	/*5230*/ uint16(xSetOp), uint16(JAE),
-	/*5232*/ uint16(xReadCw),
-	/*5233*/ uint16(xArgRel16),
-	/*5234*/ uint16(xMatch),
-	/*5235*/ uint16(xSetOp), uint16(JAE),
-	/*5237*/ uint16(xReadCd),
-	/*5238*/ uint16(xArgRel32),
-	/*5239*/ uint16(xMatch),
-	/*5240*/ uint16(xCondDataSize), 5244, 5235, 5249,
-	/*5244*/ uint16(xSetOp), uint16(JAE),
-	/*5246*/ uint16(xReadCd),
-	/*5247*/ uint16(xArgRel32),
-	/*5248*/ uint16(xMatch),
-	/*5249*/ uint16(xSetOp), uint16(JAE),
-	/*5251*/ uint16(xReadCd),
-	/*5252*/ uint16(xArgRel32),
-	/*5253*/ uint16(xMatch),
-	/*5254*/ uint16(xCondIs64), 5257, 5271,
-	/*5257*/ uint16(xCondDataSize), 5261, 5266, 0,
-	/*5261*/ uint16(xSetOp), uint16(JE),
-	/*5263*/ uint16(xReadCw),
-	/*5264*/ uint16(xArgRel16),
-	/*5265*/ uint16(xMatch),
-	/*5266*/ uint16(xSetOp), uint16(JE),
-	/*5268*/ uint16(xReadCd),
-	/*5269*/ uint16(xArgRel32),
-	/*5270*/ uint16(xMatch),
-	/*5271*/ uint16(xCondDataSize), 5275, 5266, 5280,
-	/*5275*/ uint16(xSetOp), uint16(JE),
-	/*5277*/ uint16(xReadCd),
-	/*5278*/ uint16(xArgRel32),
-	/*5279*/ uint16(xMatch),
-	/*5280*/ uint16(xSetOp), uint16(JE),
-	/*5282*/ uint16(xReadCd),
-	/*5283*/ uint16(xArgRel32),
-	/*5284*/ uint16(xMatch),
-	/*5285*/ uint16(xCondIs64), 5288, 5302,
-	/*5288*/ uint16(xCondDataSize), 5292, 5297, 0,
-	/*5292*/ uint16(xSetOp), uint16(JNE),
-	/*5294*/ uint16(xReadCw),
-	/*5295*/ uint16(xArgRel16),
-	/*5296*/ uint16(xMatch),
-	/*5297*/ uint16(xSetOp), uint16(JNE),
-	/*5299*/ uint16(xReadCd),
-	/*5300*/ uint16(xArgRel32),
-	/*5301*/ uint16(xMatch),
-	/*5302*/ uint16(xCondDataSize), 5306, 5297, 5311,
-	/*5306*/ uint16(xSetOp), uint16(JNE),
-	/*5308*/ uint16(xReadCd),
-	/*5309*/ uint16(xArgRel32),
-	/*5310*/ uint16(xMatch),
-	/*5311*/ uint16(xSetOp), uint16(JNE),
-	/*5313*/ uint16(xReadCd),
-	/*5314*/ uint16(xArgRel32),
-	/*5315*/ uint16(xMatch),
-	/*5316*/ uint16(xCondIs64), 5319, 5333,
-	/*5319*/ uint16(xCondDataSize), 5323, 5328, 0,
-	/*5323*/ uint16(xSetOp), uint16(JBE),
-	/*5325*/ uint16(xReadCw),
-	/*5326*/ uint16(xArgRel16),
-	/*5327*/ uint16(xMatch),
-	/*5328*/ uint16(xSetOp), uint16(JBE),
-	/*5330*/ uint16(xReadCd),
-	/*5331*/ uint16(xArgRel32),
-	/*5332*/ uint16(xMatch),
-	/*5333*/ uint16(xCondDataSize), 5337, 5328, 5342,
-	/*5337*/ uint16(xSetOp), uint16(JBE),
-	/*5339*/ uint16(xReadCd),
-	/*5340*/ uint16(xArgRel32),
-	/*5341*/ uint16(xMatch),
-	/*5342*/ uint16(xSetOp), uint16(JBE),
-	/*5344*/ uint16(xReadCd),
-	/*5345*/ uint16(xArgRel32),
-	/*5346*/ uint16(xMatch),
-	/*5347*/ uint16(xCondIs64), 5350, 5364,
-	/*5350*/ uint16(xCondDataSize), 5354, 5359, 0,
-	/*5354*/ uint16(xSetOp), uint16(JA),
-	/*5356*/ uint16(xReadCw),
-	/*5357*/ uint16(xArgRel16),
-	/*5358*/ uint16(xMatch),
-	/*5359*/ uint16(xSetOp), uint16(JA),
-	/*5361*/ uint16(xReadCd),
-	/*5362*/ uint16(xArgRel32),
-	/*5363*/ uint16(xMatch),
-	/*5364*/ uint16(xCondDataSize), 5368, 5359, 5373,
-	/*5368*/ uint16(xSetOp), uint16(JA),
-	/*5370*/ uint16(xReadCd),
-	/*5371*/ uint16(xArgRel32),
-	/*5372*/ uint16(xMatch),
-	/*5373*/ uint16(xSetOp), uint16(JA),
-	/*5375*/ uint16(xReadCd),
-	/*5376*/ uint16(xArgRel32),
-	/*5377*/ uint16(xMatch),
-	/*5378*/ uint16(xCondIs64), 5381, 5395,
-	/*5381*/ uint16(xCondDataSize), 5385, 5390, 0,
-	/*5385*/ uint16(xSetOp), uint16(JS),
-	/*5387*/ uint16(xReadCw),
-	/*5388*/ uint16(xArgRel16),
-	/*5389*/ uint16(xMatch),
-	/*5390*/ uint16(xSetOp), uint16(JS),
-	/*5392*/ uint16(xReadCd),
-	/*5393*/ uint16(xArgRel32),
-	/*5394*/ uint16(xMatch),
-	/*5395*/ uint16(xCondDataSize), 5399, 5390, 5404,
-	/*5399*/ uint16(xSetOp), uint16(JS),
-	/*5401*/ uint16(xReadCd),
-	/*5402*/ uint16(xArgRel32),
-	/*5403*/ uint16(xMatch),
-	/*5404*/ uint16(xSetOp), uint16(JS),
-	/*5406*/ uint16(xReadCd),
-	/*5407*/ uint16(xArgRel32),
-	/*5408*/ uint16(xMatch),
-	/*5409*/ uint16(xCondIs64), 5412, 5426,
-	/*5412*/ uint16(xCondDataSize), 5416, 5421, 0,
-	/*5416*/ uint16(xSetOp), uint16(JNS),
-	/*5418*/ uint16(xReadCw),
-	/*5419*/ uint16(xArgRel16),
-	/*5420*/ uint16(xMatch),
-	/*5421*/ uint16(xSetOp), uint16(JNS),
-	/*5423*/ uint16(xReadCd),
-	/*5424*/ uint16(xArgRel32),
-	/*5425*/ uint16(xMatch),
-	/*5426*/ uint16(xCondDataSize), 5430, 5421, 5435,
-	/*5430*/ uint16(xSetOp), uint16(JNS),
-	/*5432*/ uint16(xReadCd),
-	/*5433*/ uint16(xArgRel32),
-	/*5434*/ uint16(xMatch),
-	/*5435*/ uint16(xSetOp), uint16(JNS),
-	/*5437*/ uint16(xReadCd),
-	/*5438*/ uint16(xArgRel32),
-	/*5439*/ uint16(xMatch),
-	/*5440*/ uint16(xCondIs64), 5443, 5457,
-	/*5443*/ uint16(xCondDataSize), 5447, 5452, 0,
-	/*5447*/ uint16(xSetOp), uint16(JP),
-	/*5449*/ uint16(xReadCw),
-	/*5450*/ uint16(xArgRel16),
-	/*5451*/ uint16(xMatch),
-	/*5452*/ uint16(xSetOp), uint16(JP),
-	/*5454*/ uint16(xReadCd),
-	/*5455*/ uint16(xArgRel32),
-	/*5456*/ uint16(xMatch),
-	/*5457*/ uint16(xCondDataSize), 5461, 5452, 5466,
-	/*5461*/ uint16(xSetOp), uint16(JP),
-	/*5463*/ uint16(xReadCd),
-	/*5464*/ uint16(xArgRel32),
-	/*5465*/ uint16(xMatch),
-	/*5466*/ uint16(xSetOp), uint16(JP),
-	/*5468*/ uint16(xReadCd),
-	/*5469*/ uint16(xArgRel32),
-	/*5470*/ uint16(xMatch),
-	/*5471*/ uint16(xCondIs64), 5474, 5488,
-	/*5474*/ uint16(xCondDataSize), 5478, 5483, 0,
-	/*5478*/ uint16(xSetOp), uint16(JNP),
-	/*5480*/ uint16(xReadCw),
-	/*5481*/ uint16(xArgRel16),
-	/*5482*/ uint16(xMatch),
-	/*5483*/ uint16(xSetOp), uint16(JNP),
-	/*5485*/ uint16(xReadCd),
-	/*5486*/ uint16(xArgRel32),
-	/*5487*/ uint16(xMatch),
-	/*5488*/ uint16(xCondDataSize), 5492, 5483, 5497,
-	/*5492*/ uint16(xSetOp), uint16(JNP),
-	/*5494*/ uint16(xReadCd),
-	/*5495*/ uint16(xArgRel32),
-	/*5496*/ uint16(xMatch),
-	/*5497*/ uint16(xSetOp), uint16(JNP),
-	/*5499*/ uint16(xReadCd),
-	/*5500*/ uint16(xArgRel32),
-	/*5501*/ uint16(xMatch),
-	/*5502*/ uint16(xCondIs64), 5505, 5519,
-	/*5505*/ uint16(xCondDataSize), 5509, 5514, 0,
-	/*5509*/ uint16(xSetOp), uint16(JL),
-	/*5511*/ uint16(xReadCw),
-	/*5512*/ uint16(xArgRel16),
-	/*5513*/ uint16(xMatch),
-	/*5514*/ uint16(xSetOp), uint16(JL),
-	/*5516*/ uint16(xReadCd),
-	/*5517*/ uint16(xArgRel32),
-	/*5518*/ uint16(xMatch),
-	/*5519*/ uint16(xCondDataSize), 5523, 5514, 5528,
-	/*5523*/ uint16(xSetOp), uint16(JL),
-	/*5525*/ uint16(xReadCd),
-	/*5526*/ uint16(xArgRel32),
-	/*5527*/ uint16(xMatch),
-	/*5528*/ uint16(xSetOp), uint16(JL),
-	/*5530*/ uint16(xReadCd),
-	/*5531*/ uint16(xArgRel32),
-	/*5532*/ uint16(xMatch),
-	/*5533*/ uint16(xCondIs64), 5536, 5550,
-	/*5536*/ uint16(xCondDataSize), 5540, 5545, 0,
-	/*5540*/ uint16(xSetOp), uint16(JGE),
-	/*5542*/ uint16(xReadCw),
-	/*5543*/ uint16(xArgRel16),
-	/*5544*/ uint16(xMatch),
-	/*5545*/ uint16(xSetOp), uint16(JGE),
-	/*5547*/ uint16(xReadCd),
-	/*5548*/ uint16(xArgRel32),
-	/*5549*/ uint16(xMatch),
-	/*5550*/ uint16(xCondDataSize), 5554, 5545, 5559,
-	/*5554*/ uint16(xSetOp), uint16(JGE),
-	/*5556*/ uint16(xReadCd),
-	/*5557*/ uint16(xArgRel32),
-	/*5558*/ uint16(xMatch),
-	/*5559*/ uint16(xSetOp), uint16(JGE),
-	/*5561*/ uint16(xReadCd),
-	/*5562*/ uint16(xArgRel32),
-	/*5563*/ uint16(xMatch),
-	/*5564*/ uint16(xCondIs64), 5567, 5581,
-	/*5567*/ uint16(xCondDataSize), 5571, 5576, 0,
-	/*5571*/ uint16(xSetOp), uint16(JLE),
-	/*5573*/ uint16(xReadCw),
-	/*5574*/ uint16(xArgRel16),
-	/*5575*/ uint16(xMatch),
-	/*5576*/ uint16(xSetOp), uint16(JLE),
-	/*5578*/ uint16(xReadCd),
-	/*5579*/ uint16(xArgRel32),
-	/*5580*/ uint16(xMatch),
-	/*5581*/ uint16(xCondDataSize), 5585, 5576, 5590,
-	/*5585*/ uint16(xSetOp), uint16(JLE),
-	/*5587*/ uint16(xReadCd),
-	/*5588*/ uint16(xArgRel32),
-	/*5589*/ uint16(xMatch),
-	/*5590*/ uint16(xSetOp), uint16(JLE),
-	/*5592*/ uint16(xReadCd),
-	/*5593*/ uint16(xArgRel32),
-	/*5594*/ uint16(xMatch),
-	/*5595*/ uint16(xCondIs64), 5598, 5612,
-	/*5598*/ uint16(xCondDataSize), 5602, 5607, 0,
-	/*5602*/ uint16(xSetOp), uint16(JG),
-	/*5604*/ uint16(xReadCw),
-	/*5605*/ uint16(xArgRel16),
-	/*5606*/ uint16(xMatch),
-	/*5607*/ uint16(xSetOp), uint16(JG),
-	/*5609*/ uint16(xReadCd),
-	/*5610*/ uint16(xArgRel32),
-	/*5611*/ uint16(xMatch),
-	/*5612*/ uint16(xCondDataSize), 5616, 5607, 5621,
-	/*5616*/ uint16(xSetOp), uint16(JG),
-	/*5618*/ uint16(xReadCd),
-	/*5619*/ uint16(xArgRel32),
-	/*5620*/ uint16(xMatch),
-	/*5621*/ uint16(xSetOp), uint16(JG),
-	/*5623*/ uint16(xReadCd),
-	/*5624*/ uint16(xArgRel32),
-	/*5625*/ uint16(xMatch),
-	/*5626*/ uint16(xSetOp), uint16(SETO),
-	/*5628*/ uint16(xReadSlashR),
-	/*5629*/ uint16(xArgRM8),
-	/*5630*/ uint16(xMatch),
-	/*5631*/ uint16(xSetOp), uint16(SETNO),
-	/*5633*/ uint16(xReadSlashR),
-	/*5634*/ uint16(xArgRM8),
-	/*5635*/ uint16(xMatch),
-	/*5636*/ uint16(xSetOp), uint16(SETB),
-	/*5638*/ uint16(xReadSlashR),
-	/*5639*/ uint16(xArgRM8),
-	/*5640*/ uint16(xMatch),
-	/*5641*/ uint16(xSetOp), uint16(SETAE),
-	/*5643*/ uint16(xReadSlashR),
-	/*5644*/ uint16(xArgRM8),
-	/*5645*/ uint16(xMatch),
-	/*5646*/ uint16(xSetOp), uint16(SETE),
-	/*5648*/ uint16(xReadSlashR),
-	/*5649*/ uint16(xArgRM8),
-	/*5650*/ uint16(xMatch),
-	/*5651*/ uint16(xSetOp), uint16(SETNE),
-	/*5653*/ uint16(xReadSlashR),
-	/*5654*/ uint16(xArgRM8),
-	/*5655*/ uint16(xMatch),
-	/*5656*/ uint16(xSetOp), uint16(SETBE),
-	/*5658*/ uint16(xReadSlashR),
-	/*5659*/ uint16(xArgRM8),
-	/*5660*/ uint16(xMatch),
-	/*5661*/ uint16(xSetOp), uint16(SETA),
-	/*5663*/ uint16(xReadSlashR),
-	/*5664*/ uint16(xArgRM8),
-	/*5665*/ uint16(xMatch),
-	/*5666*/ uint16(xSetOp), uint16(SETS),
-	/*5668*/ uint16(xReadSlashR),
-	/*5669*/ uint16(xArgRM8),
-	/*5670*/ uint16(xMatch),
-	/*5671*/ uint16(xSetOp), uint16(SETNS),
-	/*5673*/ uint16(xReadSlashR),
-	/*5674*/ uint16(xArgRM8),
-	/*5675*/ uint16(xMatch),
-	/*5676*/ uint16(xSetOp), uint16(SETP),
-	/*5678*/ uint16(xReadSlashR),
-	/*5679*/ uint16(xArgRM8),
-	/*5680*/ uint16(xMatch),
-	/*5681*/ uint16(xSetOp), uint16(SETNP),
-	/*5683*/ uint16(xReadSlashR),
-	/*5684*/ uint16(xArgRM8),
-	/*5685*/ uint16(xMatch),
-	/*5686*/ uint16(xSetOp), uint16(SETL),
-	/*5688*/ uint16(xReadSlashR),
-	/*5689*/ uint16(xArgRM8),
-	/*5690*/ uint16(xMatch),
-	/*5691*/ uint16(xSetOp), uint16(SETGE),
-	/*5693*/ uint16(xReadSlashR),
-	/*5694*/ uint16(xArgRM8),
-	/*5695*/ uint16(xMatch),
-	/*5696*/ uint16(xSetOp), uint16(SETLE),
-	/*5698*/ uint16(xReadSlashR),
-	/*5699*/ uint16(xArgRM8),
-	/*5700*/ uint16(xMatch),
-	/*5701*/ uint16(xSetOp), uint16(SETG),
-	/*5703*/ uint16(xReadSlashR),
-	/*5704*/ uint16(xArgRM8),
-	/*5705*/ uint16(xMatch),
-	/*5706*/ uint16(xSetOp), uint16(PUSH),
-	/*5708*/ uint16(xArgFS),
-	/*5709*/ uint16(xMatch),
-	/*5710*/ uint16(xCondIs64), 5713, 5725,
-	/*5713*/ uint16(xCondDataSize), 5717, 5721, 0,
-	/*5717*/ uint16(xSetOp), uint16(POP),
-	/*5719*/ uint16(xArgFS),
-	/*5720*/ uint16(xMatch),
-	/*5721*/ uint16(xSetOp), uint16(POP),
-	/*5723*/ uint16(xArgFS),
-	/*5724*/ uint16(xMatch),
-	/*5725*/ uint16(xCondDataSize), 5717, 5729, 5733,
-	/*5729*/ uint16(xSetOp), uint16(POP),
-	/*5731*/ uint16(xArgFS),
-	/*5732*/ uint16(xMatch),
-	/*5733*/ uint16(xSetOp), uint16(POP),
-	/*5735*/ uint16(xArgFS),
-	/*5736*/ uint16(xMatch),
-	/*5737*/ uint16(xSetOp), uint16(CPUID),
-	/*5739*/ uint16(xMatch),
-	/*5740*/ uint16(xCondIs64), 5743, 5759,
-	/*5743*/ uint16(xCondDataSize), 5747, 5753, 0,
-	/*5747*/ uint16(xSetOp), uint16(BT),
-	/*5749*/ uint16(xReadSlashR),
-	/*5750*/ uint16(xArgRM16),
-	/*5751*/ uint16(xArgR16),
-	/*5752*/ uint16(xMatch),
-	/*5753*/ uint16(xSetOp), uint16(BT),
-	/*5755*/ uint16(xReadSlashR),
-	/*5756*/ uint16(xArgRM32),
-	/*5757*/ uint16(xArgR32),
-	/*5758*/ uint16(xMatch),
-	/*5759*/ uint16(xCondDataSize), 5747, 5753, 5763,
-	/*5763*/ uint16(xSetOp), uint16(BT),
-	/*5765*/ uint16(xReadSlashR),
-	/*5766*/ uint16(xArgRM64),
-	/*5767*/ uint16(xArgR64),
-	/*5768*/ uint16(xMatch),
-	/*5769*/ uint16(xCondIs64), 5772, 5792,
-	/*5772*/ uint16(xCondDataSize), 5776, 5784, 0,
-	/*5776*/ uint16(xSetOp), uint16(SHLD),
-	/*5778*/ uint16(xReadSlashR),
-	/*5779*/ uint16(xReadIb),
-	/*5780*/ uint16(xArgRM16),
-	/*5781*/ uint16(xArgR16),
-	/*5782*/ uint16(xArgImm8u),
-	/*5783*/ uint16(xMatch),
-	/*5784*/ uint16(xSetOp), uint16(SHLD),
-	/*5786*/ uint16(xReadSlashR),
-	/*5787*/ uint16(xReadIb),
-	/*5788*/ uint16(xArgRM32),
-	/*5789*/ uint16(xArgR32),
-	/*5790*/ uint16(xArgImm8u),
-	/*5791*/ uint16(xMatch),
-	/*5792*/ uint16(xCondDataSize), 5776, 5784, 5796,
-	/*5796*/ uint16(xSetOp), uint16(SHLD),
-	/*5798*/ uint16(xReadSlashR),
-	/*5799*/ uint16(xReadIb),
-	/*5800*/ uint16(xArgRM64),
-	/*5801*/ uint16(xArgR64),
-	/*5802*/ uint16(xArgImm8u),
-	/*5803*/ uint16(xMatch),
-	/*5804*/ uint16(xCondIs64), 5807, 5825,
-	/*5807*/ uint16(xCondDataSize), 5811, 5818, 0,
-	/*5811*/ uint16(xSetOp), uint16(SHLD),
-	/*5813*/ uint16(xReadSlashR),
-	/*5814*/ uint16(xArgRM16),
-	/*5815*/ uint16(xArgR16),
-	/*5816*/ uint16(xArgCL),
-	/*5817*/ uint16(xMatch),
-	/*5818*/ uint16(xSetOp), uint16(SHLD),
-	/*5820*/ uint16(xReadSlashR),
-	/*5821*/ uint16(xArgRM32),
-	/*5822*/ uint16(xArgR32),
-	/*5823*/ uint16(xArgCL),
-	/*5824*/ uint16(xMatch),
-	/*5825*/ uint16(xCondDataSize), 5811, 5818, 5829,
-	/*5829*/ uint16(xSetOp), uint16(SHLD),
-	/*5831*/ uint16(xReadSlashR),
-	/*5832*/ uint16(xArgRM64),
-	/*5833*/ uint16(xArgR64),
-	/*5834*/ uint16(xArgCL),
-	/*5835*/ uint16(xMatch),
-	/*5836*/ uint16(xSetOp), uint16(PUSH),
-	/*5838*/ uint16(xArgGS),
-	/*5839*/ uint16(xMatch),
-	/*5840*/ uint16(xCondIs64), 5843, 5855,
-	/*5843*/ uint16(xCondDataSize), 5847, 5851, 0,
-	/*5847*/ uint16(xSetOp), uint16(POP),
-	/*5849*/ uint16(xArgGS),
-	/*5850*/ uint16(xMatch),
-	/*5851*/ uint16(xSetOp), uint16(POP),
-	/*5853*/ uint16(xArgGS),
-	/*5854*/ uint16(xMatch),
-	/*5855*/ uint16(xCondDataSize), 5847, 5859, 5863,
-	/*5859*/ uint16(xSetOp), uint16(POP),
-	/*5861*/ uint16(xArgGS),
-	/*5862*/ uint16(xMatch),
-	/*5863*/ uint16(xSetOp), uint16(POP),
-	/*5865*/ uint16(xArgGS),
-	/*5866*/ uint16(xMatch),
-	/*5867*/ uint16(xSetOp), uint16(RSM),
-	/*5869*/ uint16(xMatch),
-	/*5870*/ uint16(xCondIs64), 5873, 5889,
-	/*5873*/ uint16(xCondDataSize), 5877, 5883, 0,
-	/*5877*/ uint16(xSetOp), uint16(BTS),
-	/*5879*/ uint16(xReadSlashR),
-	/*5880*/ uint16(xArgRM16),
-	/*5881*/ uint16(xArgR16),
-	/*5882*/ uint16(xMatch),
-	/*5883*/ uint16(xSetOp), uint16(BTS),
-	/*5885*/ uint16(xReadSlashR),
-	/*5886*/ uint16(xArgRM32),
-	/*5887*/ uint16(xArgR32),
-	/*5888*/ uint16(xMatch),
-	/*5889*/ uint16(xCondDataSize), 5877, 5883, 5893,
-	/*5893*/ uint16(xSetOp), uint16(BTS),
-	/*5895*/ uint16(xReadSlashR),
-	/*5896*/ uint16(xArgRM64),
-	/*5897*/ uint16(xArgR64),
-	/*5898*/ uint16(xMatch),
-	/*5899*/ uint16(xCondIs64), 5902, 5922,
-	/*5902*/ uint16(xCondDataSize), 5906, 5914, 0,
-	/*5906*/ uint16(xSetOp), uint16(SHRD),
-	/*5908*/ uint16(xReadSlashR),
-	/*5909*/ uint16(xReadIb),
-	/*5910*/ uint16(xArgRM16),
-	/*5911*/ uint16(xArgR16),
-	/*5912*/ uint16(xArgImm8u),
-	/*5913*/ uint16(xMatch),
-	/*5914*/ uint16(xSetOp), uint16(SHRD),
-	/*5916*/ uint16(xReadSlashR),
-	/*5917*/ uint16(xReadIb),
-	/*5918*/ uint16(xArgRM32),
-	/*5919*/ uint16(xArgR32),
-	/*5920*/ uint16(xArgImm8u),
-	/*5921*/ uint16(xMatch),
-	/*5922*/ uint16(xCondDataSize), 5906, 5914, 5926,
-	/*5926*/ uint16(xSetOp), uint16(SHRD),
-	/*5928*/ uint16(xReadSlashR),
-	/*5929*/ uint16(xReadIb),
-	/*5930*/ uint16(xArgRM64),
-	/*5931*/ uint16(xArgR64),
-	/*5932*/ uint16(xArgImm8u),
-	/*5933*/ uint16(xMatch),
-	/*5934*/ uint16(xCondIs64), 5937, 5955,
-	/*5937*/ uint16(xCondDataSize), 5941, 5948, 0,
-	/*5941*/ uint16(xSetOp), uint16(SHRD),
-	/*5943*/ uint16(xReadSlashR),
-	/*5944*/ uint16(xArgRM16),
-	/*5945*/ uint16(xArgR16),
-	/*5946*/ uint16(xArgCL),
-	/*5947*/ uint16(xMatch),
-	/*5948*/ uint16(xSetOp), uint16(SHRD),
-	/*5950*/ uint16(xReadSlashR),
-	/*5951*/ uint16(xArgRM32),
-	/*5952*/ uint16(xArgR32),
-	/*5953*/ uint16(xArgCL),
-	/*5954*/ uint16(xMatch),
-	/*5955*/ uint16(xCondDataSize), 5941, 5948, 5959,
-	/*5959*/ uint16(xSetOp), uint16(SHRD),
-	/*5961*/ uint16(xReadSlashR),
-	/*5962*/ uint16(xArgRM64),
-	/*5963*/ uint16(xArgR64),
-	/*5964*/ uint16(xArgCL),
-	/*5965*/ uint16(xMatch),
-	/*5966*/ uint16(xCondByte), 3,
-	0xE8, 6215,
-	0xF0, 6218,
-	0xF8, 6221,
-	/*5974*/ uint16(xCondSlashR),
-	5983, // 0
-	6037, // 1
-	6091, // 2
-	6120, // 3
-	6149, // 4
-	6172, // 5
-	6195, // 6
-	6211, // 7
-	/*5983*/ uint16(xCondIs64), 5986, 5998,
-	/*5986*/ uint16(xCondDataSize), 5990, 5994, 0,
-	/*5990*/ uint16(xSetOp), uint16(FXSAVE),
-	/*5992*/ uint16(xArgM512byte),
-	/*5993*/ uint16(xMatch),
-	/*5994*/ uint16(xSetOp), uint16(FXSAVE),
-	/*5996*/ uint16(xArgM512byte),
-	/*5997*/ uint16(xMatch),
-	/*5998*/ uint16(xCondPrefix), 2,
-	0xF3, 6012,
-	0x0, 6004,
-	/*6004*/ uint16(xCondDataSize), 5990, 5994, 6008,
-	/*6008*/ uint16(xSetOp), uint16(FXSAVE64),
-	/*6010*/ uint16(xArgM512byte),
-	/*6011*/ uint16(xMatch),
-	/*6012*/ uint16(xCondDataSize), 6016, 6023, 6030,
-	/*6016*/ uint16(xCondIsMem), 6019, 0,
-	/*6019*/ uint16(xSetOp), uint16(RDFSBASE),
-	/*6021*/ uint16(xArgRM32),
-	/*6022*/ uint16(xMatch),
-	/*6023*/ uint16(xCondIsMem), 6026, 0,
-	/*6026*/ uint16(xSetOp), uint16(RDFSBASE),
-	/*6028*/ uint16(xArgRM32),
-	/*6029*/ uint16(xMatch),
-	/*6030*/ uint16(xCondIsMem), 6033, 0,
-	/*6033*/ uint16(xSetOp), uint16(RDFSBASE),
-	/*6035*/ uint16(xArgRM64),
-	/*6036*/ uint16(xMatch),
-	/*6037*/ uint16(xCondIs64), 6040, 6052,
-	/*6040*/ uint16(xCondDataSize), 6044, 6048, 0,
-	/*6044*/ uint16(xSetOp), uint16(FXRSTOR),
-	/*6046*/ uint16(xArgM512byte),
-	/*6047*/ uint16(xMatch),
-	/*6048*/ uint16(xSetOp), uint16(FXRSTOR),
-	/*6050*/ uint16(xArgM512byte),
-	/*6051*/ uint16(xMatch),
-	/*6052*/ uint16(xCondPrefix), 2,
-	0xF3, 6066,
-	0x0, 6058,
-	/*6058*/ uint16(xCondDataSize), 6044, 6048, 6062,
-	/*6062*/ uint16(xSetOp), uint16(FXRSTOR64),
-	/*6064*/ uint16(xArgM512byte),
-	/*6065*/ uint16(xMatch),
-	/*6066*/ uint16(xCondDataSize), 6070, 6077, 6084,
-	/*6070*/ uint16(xCondIsMem), 6073, 0,
-	/*6073*/ uint16(xSetOp), uint16(RDGSBASE),
-	/*6075*/ uint16(xArgRM32),
-	/*6076*/ uint16(xMatch),
-	/*6077*/ uint16(xCondIsMem), 6080, 0,
-	/*6080*/ uint16(xSetOp), uint16(RDGSBASE),
-	/*6082*/ uint16(xArgRM32),
-	/*6083*/ uint16(xMatch),
-	/*6084*/ uint16(xCondIsMem), 6087, 0,
-	/*6087*/ uint16(xSetOp), uint16(RDGSBASE),
-	/*6089*/ uint16(xArgRM64),
-	/*6090*/ uint16(xMatch),
-	/*6091*/ uint16(xCondIs64), 6094, 6098,
-	/*6094*/ uint16(xSetOp), uint16(LDMXCSR),
-	/*6096*/ uint16(xArgM32),
-	/*6097*/ uint16(xMatch),
-	/*6098*/ uint16(xCondPrefix), 2,
-	0xF3, 6104,
-	0x0, 6094,
-	/*6104*/ uint16(xCondDataSize), 6108, 6112, 6116,
-	/*6108*/ uint16(xSetOp), uint16(WRFSBASE),
-	/*6110*/ uint16(xArgRM32),
-	/*6111*/ uint16(xMatch),
-	/*6112*/ uint16(xSetOp), uint16(WRFSBASE),
-	/*6114*/ uint16(xArgRM32),
-	/*6115*/ uint16(xMatch),
-	/*6116*/ uint16(xSetOp), uint16(WRFSBASE),
-	/*6118*/ uint16(xArgRM64),
-	/*6119*/ uint16(xMatch),
-	/*6120*/ uint16(xCondIs64), 6123, 6127,
-	/*6123*/ uint16(xSetOp), uint16(STMXCSR),
-	/*6125*/ uint16(xArgM32),
-	/*6126*/ uint16(xMatch),
-	/*6127*/ uint16(xCondPrefix), 2,
-	0xF3, 6133,
-	0x0, 6123,
-	/*6133*/ uint16(xCondDataSize), 6137, 6141, 6145,
-	/*6137*/ uint16(xSetOp), uint16(WRGSBASE),
-	/*6139*/ uint16(xArgRM32),
-	/*6140*/ uint16(xMatch),
-	/*6141*/ uint16(xSetOp), uint16(WRGSBASE),
-	/*6143*/ uint16(xArgRM32),
-	/*6144*/ uint16(xMatch),
-	/*6145*/ uint16(xSetOp), uint16(WRGSBASE),
-	/*6147*/ uint16(xArgRM64),
-	/*6148*/ uint16(xMatch),
-	/*6149*/ uint16(xCondIs64), 6152, 6164,
-	/*6152*/ uint16(xCondDataSize), 6156, 6160, 0,
-	/*6156*/ uint16(xSetOp), uint16(XSAVE),
-	/*6158*/ uint16(xArgMem),
-	/*6159*/ uint16(xMatch),
-	/*6160*/ uint16(xSetOp), uint16(XSAVE),
-	/*6162*/ uint16(xArgMem),
-	/*6163*/ uint16(xMatch),
-	/*6164*/ uint16(xCondDataSize), 6156, 6160, 6168,
-	/*6168*/ uint16(xSetOp), uint16(XSAVE64),
-	/*6170*/ uint16(xArgMem),
-	/*6171*/ uint16(xMatch),
-	/*6172*/ uint16(xCondIs64), 6175, 6187,
-	/*6175*/ uint16(xCondDataSize), 6179, 6183, 0,
-	/*6179*/ uint16(xSetOp), uint16(XRSTOR),
-	/*6181*/ uint16(xArgMem),
-	/*6182*/ uint16(xMatch),
-	/*6183*/ uint16(xSetOp), uint16(XRSTOR),
-	/*6185*/ uint16(xArgMem),
-	/*6186*/ uint16(xMatch),
-	/*6187*/ uint16(xCondDataSize), 6179, 6183, 6191,
-	/*6191*/ uint16(xSetOp), uint16(XRSTOR64),
-	/*6193*/ uint16(xArgMem),
-	/*6194*/ uint16(xMatch),
-	/*6195*/ uint16(xCondDataSize), 6199, 6203, 6207,
-	/*6199*/ uint16(xSetOp), uint16(XSAVEOPT),
-	/*6201*/ uint16(xArgMem),
-	/*6202*/ uint16(xMatch),
-	/*6203*/ uint16(xSetOp), uint16(XSAVEOPT),
-	/*6205*/ uint16(xArgMem),
-	/*6206*/ uint16(xMatch),
-	/*6207*/ uint16(xSetOp), uint16(XSAVEOPT64),
-	/*6209*/ uint16(xArgMem),
-	/*6210*/ uint16(xMatch),
-	/*6211*/ uint16(xSetOp), uint16(CLFLUSH),
-	/*6213*/ uint16(xArgM8),
-	/*6214*/ uint16(xMatch),
-	/*6215*/ uint16(xSetOp), uint16(LFENCE),
-	/*6217*/ uint16(xMatch),
-	/*6218*/ uint16(xSetOp), uint16(MFENCE),
-	/*6220*/ uint16(xMatch),
-	/*6221*/ uint16(xSetOp), uint16(SFENCE),
-	/*6223*/ uint16(xMatch),
-	/*6224*/ uint16(xCondIs64), 6227, 6243,
-	/*6227*/ uint16(xCondDataSize), 6231, 6237, 0,
-	/*6231*/ uint16(xSetOp), uint16(IMUL),
-	/*6233*/ uint16(xReadSlashR),
-	/*6234*/ uint16(xArgR16),
-	/*6235*/ uint16(xArgRM16),
-	/*6236*/ uint16(xMatch),
-	/*6237*/ uint16(xSetOp), uint16(IMUL),
-	/*6239*/ uint16(xReadSlashR),
-	/*6240*/ uint16(xArgR32),
-	/*6241*/ uint16(xArgRM32),
-	/*6242*/ uint16(xMatch),
-	/*6243*/ uint16(xCondDataSize), 6231, 6237, 6247,
-	/*6247*/ uint16(xSetOp), uint16(IMUL),
-	/*6249*/ uint16(xReadSlashR),
-	/*6250*/ uint16(xArgR64),
-	/*6251*/ uint16(xArgRM64),
-	/*6252*/ uint16(xMatch),
-	/*6253*/ uint16(xSetOp), uint16(CMPXCHG),
-	/*6255*/ uint16(xReadSlashR),
-	/*6256*/ uint16(xArgRM8),
-	/*6257*/ uint16(xArgR8),
-	/*6258*/ uint16(xMatch),
-	/*6259*/ uint16(xCondIs64), 6262, 6278,
-	/*6262*/ uint16(xCondDataSize), 6266, 6272, 0,
-	/*6266*/ uint16(xSetOp), uint16(CMPXCHG),
-	/*6268*/ uint16(xReadSlashR),
-	/*6269*/ uint16(xArgRM16),
-	/*6270*/ uint16(xArgR16),
-	/*6271*/ uint16(xMatch),
-	/*6272*/ uint16(xSetOp), uint16(CMPXCHG),
-	/*6274*/ uint16(xReadSlashR),
-	/*6275*/ uint16(xArgRM32),
-	/*6276*/ uint16(xArgR32),
-	/*6277*/ uint16(xMatch),
-	/*6278*/ uint16(xCondDataSize), 6266, 6272, 6282,
-	/*6282*/ uint16(xSetOp), uint16(CMPXCHG),
-	/*6284*/ uint16(xReadSlashR),
-	/*6285*/ uint16(xArgRM64),
-	/*6286*/ uint16(xArgR64),
-	/*6287*/ uint16(xMatch),
-	/*6288*/ uint16(xCondIs64), 6291, 6307,
-	/*6291*/ uint16(xCondDataSize), 6295, 6301, 0,
-	/*6295*/ uint16(xSetOp), uint16(LSS),
-	/*6297*/ uint16(xReadSlashR),
-	/*6298*/ uint16(xArgR16),
-	/*6299*/ uint16(xArgM16colon16),
-	/*6300*/ uint16(xMatch),
-	/*6301*/ uint16(xSetOp), uint16(LSS),
-	/*6303*/ uint16(xReadSlashR),
-	/*6304*/ uint16(xArgR32),
-	/*6305*/ uint16(xArgM16colon32),
-	/*6306*/ uint16(xMatch),
-	/*6307*/ uint16(xCondDataSize), 6295, 6301, 6311,
-	/*6311*/ uint16(xSetOp), uint16(LSS),
-	/*6313*/ uint16(xReadSlashR),
-	/*6314*/ uint16(xArgR64),
-	/*6315*/ uint16(xArgM16colon64),
-	/*6316*/ uint16(xMatch),
-	/*6317*/ uint16(xCondIs64), 6320, 6336,
-	/*6320*/ uint16(xCondDataSize), 6324, 6330, 0,
-	/*6324*/ uint16(xSetOp), uint16(BTR),
-	/*6326*/ uint16(xReadSlashR),
-	/*6327*/ uint16(xArgRM16),
-	/*6328*/ uint16(xArgR16),
-	/*6329*/ uint16(xMatch),
-	/*6330*/ uint16(xSetOp), uint16(BTR),
-	/*6332*/ uint16(xReadSlashR),
-	/*6333*/ uint16(xArgRM32),
-	/*6334*/ uint16(xArgR32),
-	/*6335*/ uint16(xMatch),
-	/*6336*/ uint16(xCondDataSize), 6324, 6330, 6340,
-	/*6340*/ uint16(xSetOp), uint16(BTR),
-	/*6342*/ uint16(xReadSlashR),
-	/*6343*/ uint16(xArgRM64),
-	/*6344*/ uint16(xArgR64),
-	/*6345*/ uint16(xMatch),
-	/*6346*/ uint16(xCondIs64), 6349, 6365,
-	/*6349*/ uint16(xCondDataSize), 6353, 6359, 0,
-	/*6353*/ uint16(xSetOp), uint16(LFS),
-	/*6355*/ uint16(xReadSlashR),
-	/*6356*/ uint16(xArgR16),
-	/*6357*/ uint16(xArgM16colon16),
-	/*6358*/ uint16(xMatch),
-	/*6359*/ uint16(xSetOp), uint16(LFS),
-	/*6361*/ uint16(xReadSlashR),
-	/*6362*/ uint16(xArgR32),
-	/*6363*/ uint16(xArgM16colon32),
-	/*6364*/ uint16(xMatch),
-	/*6365*/ uint16(xCondDataSize), 6353, 6359, 6369,
-	/*6369*/ uint16(xSetOp), uint16(LFS),
-	/*6371*/ uint16(xReadSlashR),
-	/*6372*/ uint16(xArgR64),
-	/*6373*/ uint16(xArgM16colon64),
-	/*6374*/ uint16(xMatch),
-	/*6375*/ uint16(xCondIs64), 6378, 6394,
-	/*6378*/ uint16(xCondDataSize), 6382, 6388, 0,
-	/*6382*/ uint16(xSetOp), uint16(LGS),
-	/*6384*/ uint16(xReadSlashR),
-	/*6385*/ uint16(xArgR16),
-	/*6386*/ uint16(xArgM16colon16),
-	/*6387*/ uint16(xMatch),
-	/*6388*/ uint16(xSetOp), uint16(LGS),
-	/*6390*/ uint16(xReadSlashR),
-	/*6391*/ uint16(xArgR32),
-	/*6392*/ uint16(xArgM16colon32),
-	/*6393*/ uint16(xMatch),
-	/*6394*/ uint16(xCondDataSize), 6382, 6388, 6398,
-	/*6398*/ uint16(xSetOp), uint16(LGS),
-	/*6400*/ uint16(xReadSlashR),
-	/*6401*/ uint16(xArgR64),
-	/*6402*/ uint16(xArgM16colon64),
-	/*6403*/ uint16(xMatch),
-	/*6404*/ uint16(xCondIs64), 6407, 6423,
-	/*6407*/ uint16(xCondDataSize), 6411, 6417, 0,
-	/*6411*/ uint16(xSetOp), uint16(MOVZX),
-	/*6413*/ uint16(xReadSlashR),
-	/*6414*/ uint16(xArgR16),
-	/*6415*/ uint16(xArgRM8),
-	/*6416*/ uint16(xMatch),
-	/*6417*/ uint16(xSetOp), uint16(MOVZX),
-	/*6419*/ uint16(xReadSlashR),
-	/*6420*/ uint16(xArgR32),
-	/*6421*/ uint16(xArgRM8),
-	/*6422*/ uint16(xMatch),
-	/*6423*/ uint16(xCondDataSize), 6411, 6417, 6427,
-	/*6427*/ uint16(xSetOp), uint16(MOVZX),
-	/*6429*/ uint16(xReadSlashR),
-	/*6430*/ uint16(xArgR64),
-	/*6431*/ uint16(xArgRM8),
-	/*6432*/ uint16(xMatch),
-	/*6433*/ uint16(xCondIs64), 6436, 6452,
-	/*6436*/ uint16(xCondDataSize), 6440, 6446, 0,
-	/*6440*/ uint16(xSetOp), uint16(MOVZX),
-	/*6442*/ uint16(xReadSlashR),
-	/*6443*/ uint16(xArgR16),
-	/*6444*/ uint16(xArgRM16),
-	/*6445*/ uint16(xMatch),
-	/*6446*/ uint16(xSetOp), uint16(MOVZX),
-	/*6448*/ uint16(xReadSlashR),
-	/*6449*/ uint16(xArgR32),
-	/*6450*/ uint16(xArgRM16),
-	/*6451*/ uint16(xMatch),
-	/*6452*/ uint16(xCondDataSize), 6440, 6446, 6456,
-	/*6456*/ uint16(xSetOp), uint16(MOVZX),
-	/*6458*/ uint16(xReadSlashR),
-	/*6459*/ uint16(xArgR64),
-	/*6460*/ uint16(xArgRM16),
-	/*6461*/ uint16(xMatch),
-	/*6462*/ uint16(xCondIs64), 6465, 6485,
-	/*6465*/ uint16(xCondPrefix), 1,
-	0xF3, 6469,
-	/*6469*/ uint16(xCondDataSize), 6473, 6479, 0,
-	/*6473*/ uint16(xSetOp), uint16(POPCNT),
-	/*6475*/ uint16(xReadSlashR),
-	/*6476*/ uint16(xArgR16),
-	/*6477*/ uint16(xArgRM16),
-	/*6478*/ uint16(xMatch),
-	/*6479*/ uint16(xSetOp), uint16(POPCNT),
-	/*6481*/ uint16(xReadSlashR),
-	/*6482*/ uint16(xArgR32),
-	/*6483*/ uint16(xArgRM32),
-	/*6484*/ uint16(xMatch),
-	/*6485*/ uint16(xCondPrefix), 1,
-	0xF3, 6489,
-	/*6489*/ uint16(xCondDataSize), 6473, 6479, 6493,
-	/*6493*/ uint16(xSetOp), uint16(POPCNT),
-	/*6495*/ uint16(xReadSlashR),
-	/*6496*/ uint16(xArgR64),
-	/*6497*/ uint16(xArgRM64),
-	/*6498*/ uint16(xMatch),
-	/*6499*/ uint16(xSetOp), uint16(UD1),
-	/*6501*/ uint16(xMatch),
-	/*6502*/ uint16(xCondSlashR),
-	0,    // 0
-	0,    // 1
-	0,    // 2
-	0,    // 3
-	6511, // 4
-	6540, // 5
-	6569, // 6
-	6598, // 7
-	/*6511*/ uint16(xCondIs64), 6514, 6530,
-	/*6514*/ uint16(xCondDataSize), 6518, 6524, 0,
-	/*6518*/ uint16(xSetOp), uint16(BT),
-	/*6520*/ uint16(xReadIb),
-	/*6521*/ uint16(xArgRM16),
-	/*6522*/ uint16(xArgImm8u),
-	/*6523*/ uint16(xMatch),
-	/*6524*/ uint16(xSetOp), uint16(BT),
-	/*6526*/ uint16(xReadIb),
-	/*6527*/ uint16(xArgRM32),
-	/*6528*/ uint16(xArgImm8u),
-	/*6529*/ uint16(xMatch),
-	/*6530*/ uint16(xCondDataSize), 6518, 6524, 6534,
-	/*6534*/ uint16(xSetOp), uint16(BT),
-	/*6536*/ uint16(xReadIb),
-	/*6537*/ uint16(xArgRM64),
-	/*6538*/ uint16(xArgImm8u),
-	/*6539*/ uint16(xMatch),
-	/*6540*/ uint16(xCondIs64), 6543, 6559,
-	/*6543*/ uint16(xCondDataSize), 6547, 6553, 0,
-	/*6547*/ uint16(xSetOp), uint16(BTS),
-	/*6549*/ uint16(xReadIb),
-	/*6550*/ uint16(xArgRM16),
-	/*6551*/ uint16(xArgImm8u),
-	/*6552*/ uint16(xMatch),
-	/*6553*/ uint16(xSetOp), uint16(BTS),
-	/*6555*/ uint16(xReadIb),
-	/*6556*/ uint16(xArgRM32),
-	/*6557*/ uint16(xArgImm8u),
-	/*6558*/ uint16(xMatch),
-	/*6559*/ uint16(xCondDataSize), 6547, 6553, 6563,
-	/*6563*/ uint16(xSetOp), uint16(BTS),
-	/*6565*/ uint16(xReadIb),
-	/*6566*/ uint16(xArgRM64),
-	/*6567*/ uint16(xArgImm8u),
-	/*6568*/ uint16(xMatch),
-	/*6569*/ uint16(xCondIs64), 6572, 6588,
-	/*6572*/ uint16(xCondDataSize), 6576, 6582, 0,
-	/*6576*/ uint16(xSetOp), uint16(BTR),
-	/*6578*/ uint16(xReadIb),
-	/*6579*/ uint16(xArgRM16),
-	/*6580*/ uint16(xArgImm8u),
-	/*6581*/ uint16(xMatch),
-	/*6582*/ uint16(xSetOp), uint16(BTR),
-	/*6584*/ uint16(xReadIb),
-	/*6585*/ uint16(xArgRM32),
-	/*6586*/ uint16(xArgImm8u),
-	/*6587*/ uint16(xMatch),
-	/*6588*/ uint16(xCondDataSize), 6576, 6582, 6592,
-	/*6592*/ uint16(xSetOp), uint16(BTR),
-	/*6594*/ uint16(xReadIb),
-	/*6595*/ uint16(xArgRM64),
-	/*6596*/ uint16(xArgImm8u),
-	/*6597*/ uint16(xMatch),
-	/*6598*/ uint16(xCondIs64), 6601, 6617,
-	/*6601*/ uint16(xCondDataSize), 6605, 6611, 0,
-	/*6605*/ uint16(xSetOp), uint16(BTC),
-	/*6607*/ uint16(xReadIb),
-	/*6608*/ uint16(xArgRM16),
-	/*6609*/ uint16(xArgImm8u),
-	/*6610*/ uint16(xMatch),
-	/*6611*/ uint16(xSetOp), uint16(BTC),
-	/*6613*/ uint16(xReadIb),
-	/*6614*/ uint16(xArgRM32),
-	/*6615*/ uint16(xArgImm8u),
-	/*6616*/ uint16(xMatch),
-	/*6617*/ uint16(xCondDataSize), 6605, 6611, 6621,
-	/*6621*/ uint16(xSetOp), uint16(BTC),
-	/*6623*/ uint16(xReadIb),
-	/*6624*/ uint16(xArgRM64),
-	/*6625*/ uint16(xArgImm8u),
-	/*6626*/ uint16(xMatch),
-	/*6627*/ uint16(xCondIs64), 6630, 6646,
-	/*6630*/ uint16(xCondDataSize), 6634, 6640, 0,
-	/*6634*/ uint16(xSetOp), uint16(BTC),
-	/*6636*/ uint16(xReadSlashR),
-	/*6637*/ uint16(xArgRM16),
-	/*6638*/ uint16(xArgR16),
-	/*6639*/ uint16(xMatch),
-	/*6640*/ uint16(xSetOp), uint16(BTC),
-	/*6642*/ uint16(xReadSlashR),
-	/*6643*/ uint16(xArgRM32),
-	/*6644*/ uint16(xArgR32),
-	/*6645*/ uint16(xMatch),
-	/*6646*/ uint16(xCondDataSize), 6634, 6640, 6650,
-	/*6650*/ uint16(xSetOp), uint16(BTC),
-	/*6652*/ uint16(xReadSlashR),
-	/*6653*/ uint16(xArgRM64),
-	/*6654*/ uint16(xArgR64),
-	/*6655*/ uint16(xMatch),
-	/*6656*/ uint16(xCondIs64), 6659, 6697,
-	/*6659*/ uint16(xCondPrefix), 2,
-	0xF3, 6681,
-	0x0, 6665,
-	/*6665*/ uint16(xCondDataSize), 6669, 6675, 0,
-	/*6669*/ uint16(xSetOp), uint16(BSF),
-	/*6671*/ uint16(xReadSlashR),
-	/*6672*/ uint16(xArgR16),
-	/*6673*/ uint16(xArgRM16),
-	/*6674*/ uint16(xMatch),
-	/*6675*/ uint16(xSetOp), uint16(BSF),
-	/*6677*/ uint16(xReadSlashR),
-	/*6678*/ uint16(xArgR32),
-	/*6679*/ uint16(xArgRM32),
-	/*6680*/ uint16(xMatch),
-	/*6681*/ uint16(xCondDataSize), 6685, 6691, 0,
-	/*6685*/ uint16(xSetOp), uint16(TZCNT),
-	/*6687*/ uint16(xReadSlashR),
-	/*6688*/ uint16(xArgR16),
-	/*6689*/ uint16(xArgRM16),
-	/*6690*/ uint16(xMatch),
-	/*6691*/ uint16(xSetOp), uint16(TZCNT),
-	/*6693*/ uint16(xReadSlashR),
-	/*6694*/ uint16(xArgR32),
-	/*6695*/ uint16(xArgRM32),
-	/*6696*/ uint16(xMatch),
-	/*6697*/ uint16(xCondPrefix), 2,
-	0xF3, 6713,
-	0x0, 6703,
-	/*6703*/ uint16(xCondDataSize), 6669, 6675, 6707,
-	/*6707*/ uint16(xSetOp), uint16(BSF),
-	/*6709*/ uint16(xReadSlashR),
-	/*6710*/ uint16(xArgR64),
-	/*6711*/ uint16(xArgRM64),
-	/*6712*/ uint16(xMatch),
-	/*6713*/ uint16(xCondDataSize), 6685, 6691, 6717,
-	/*6717*/ uint16(xSetOp), uint16(TZCNT),
-	/*6719*/ uint16(xReadSlashR),
-	/*6720*/ uint16(xArgR64),
-	/*6721*/ uint16(xArgRM64),
-	/*6722*/ uint16(xMatch),
-	/*6723*/ uint16(xCondIs64), 6726, 6764,
-	/*6726*/ uint16(xCondPrefix), 2,
-	0xF3, 6748,
-	0x0, 6732,
-	/*6732*/ uint16(xCondDataSize), 6736, 6742, 0,
-	/*6736*/ uint16(xSetOp), uint16(BSR),
-	/*6738*/ uint16(xReadSlashR),
-	/*6739*/ uint16(xArgR16),
-	/*6740*/ uint16(xArgRM16),
-	/*6741*/ uint16(xMatch),
-	/*6742*/ uint16(xSetOp), uint16(BSR),
-	/*6744*/ uint16(xReadSlashR),
-	/*6745*/ uint16(xArgR32),
-	/*6746*/ uint16(xArgRM32),
-	/*6747*/ uint16(xMatch),
-	/*6748*/ uint16(xCondDataSize), 6752, 6758, 0,
-	/*6752*/ uint16(xSetOp), uint16(LZCNT),
-	/*6754*/ uint16(xReadSlashR),
-	/*6755*/ uint16(xArgR16),
-	/*6756*/ uint16(xArgRM16),
-	/*6757*/ uint16(xMatch),
-	/*6758*/ uint16(xSetOp), uint16(LZCNT),
-	/*6760*/ uint16(xReadSlashR),
-	/*6761*/ uint16(xArgR32),
-	/*6762*/ uint16(xArgRM32),
-	/*6763*/ uint16(xMatch),
-	/*6764*/ uint16(xCondPrefix), 2,
-	0xF3, 6780,
-	0x0, 6770,
-	/*6770*/ uint16(xCondDataSize), 6736, 6742, 6774,
-	/*6774*/ uint16(xSetOp), uint16(BSR),
-	/*6776*/ uint16(xReadSlashR),
-	/*6777*/ uint16(xArgR64),
-	/*6778*/ uint16(xArgRM64),
-	/*6779*/ uint16(xMatch),
-	/*6780*/ uint16(xCondDataSize), 6752, 6758, 6784,
-	/*6784*/ uint16(xSetOp), uint16(LZCNT),
-	/*6786*/ uint16(xReadSlashR),
-	/*6787*/ uint16(xArgR64),
-	/*6788*/ uint16(xArgRM64),
-	/*6789*/ uint16(xMatch),
-	/*6790*/ uint16(xCondIs64), 6793, 6809,
-	/*6793*/ uint16(xCondDataSize), 6797, 6803, 0,
-	/*6797*/ uint16(xSetOp), uint16(MOVSX),
-	/*6799*/ uint16(xReadSlashR),
-	/*6800*/ uint16(xArgR16),
-	/*6801*/ uint16(xArgRM8),
-	/*6802*/ uint16(xMatch),
-	/*6803*/ uint16(xSetOp), uint16(MOVSX),
-	/*6805*/ uint16(xReadSlashR),
-	/*6806*/ uint16(xArgR32),
-	/*6807*/ uint16(xArgRM8),
-	/*6808*/ uint16(xMatch),
-	/*6809*/ uint16(xCondDataSize), 6797, 6803, 6813,
-	/*6813*/ uint16(xSetOp), uint16(MOVSX),
-	/*6815*/ uint16(xReadSlashR),
-	/*6816*/ uint16(xArgR64),
-	/*6817*/ uint16(xArgRM8),
-	/*6818*/ uint16(xMatch),
-	/*6819*/ uint16(xCondIs64), 6822, 6838,
-	/*6822*/ uint16(xCondDataSize), 6826, 6832, 0,
-	/*6826*/ uint16(xSetOp), uint16(MOVSX),
-	/*6828*/ uint16(xReadSlashR),
-	/*6829*/ uint16(xArgR16),
-	/*6830*/ uint16(xArgRM16),
-	/*6831*/ uint16(xMatch),
-	/*6832*/ uint16(xSetOp), uint16(MOVSX),
-	/*6834*/ uint16(xReadSlashR),
-	/*6835*/ uint16(xArgR32),
-	/*6836*/ uint16(xArgRM16),
-	/*6837*/ uint16(xMatch),
-	/*6838*/ uint16(xCondDataSize), 6826, 6832, 6842,
-	/*6842*/ uint16(xSetOp), uint16(MOVSX),
-	/*6844*/ uint16(xReadSlashR),
-	/*6845*/ uint16(xArgR64),
-	/*6846*/ uint16(xArgRM16),
-	/*6847*/ uint16(xMatch),
-	/*6848*/ uint16(xSetOp), uint16(XADD),
-	/*6850*/ uint16(xReadSlashR),
-	/*6851*/ uint16(xArgRM8),
-	/*6852*/ uint16(xArgR8),
-	/*6853*/ uint16(xMatch),
-	/*6854*/ uint16(xCondIs64), 6857, 6873,
-	/*6857*/ uint16(xCondDataSize), 6861, 6867, 0,
-	/*6861*/ uint16(xSetOp), uint16(XADD),
-	/*6863*/ uint16(xReadSlashR),
-	/*6864*/ uint16(xArgRM16),
-	/*6865*/ uint16(xArgR16),
-	/*6866*/ uint16(xMatch),
-	/*6867*/ uint16(xSetOp), uint16(XADD),
-	/*6869*/ uint16(xReadSlashR),
-	/*6870*/ uint16(xArgRM32),
-	/*6871*/ uint16(xArgR32),
-	/*6872*/ uint16(xMatch),
-	/*6873*/ uint16(xCondDataSize), 6861, 6867, 6877,
-	/*6877*/ uint16(xSetOp), uint16(XADD),
-	/*6879*/ uint16(xReadSlashR),
-	/*6880*/ uint16(xArgRM64),
-	/*6881*/ uint16(xArgR64),
-	/*6882*/ uint16(xMatch),
-	/*6883*/ uint16(xCondPrefix), 4,
-	0xF3, 6917,
-	0xF2, 6909,
-	0x66, 6901,
-	0x0, 6893,
-	/*6893*/ uint16(xSetOp), uint16(CMPPS),
-	/*6895*/ uint16(xReadSlashR),
-	/*6896*/ uint16(xReadIb),
-	/*6897*/ uint16(xArgXmm1),
-	/*6898*/ uint16(xArgXmm2M128),
-	/*6899*/ uint16(xArgImm8u),
-	/*6900*/ uint16(xMatch),
-	/*6901*/ uint16(xSetOp), uint16(CMPPD),
-	/*6903*/ uint16(xReadSlashR),
-	/*6904*/ uint16(xReadIb),
-	/*6905*/ uint16(xArgXmm1),
-	/*6906*/ uint16(xArgXmm2M128),
-	/*6907*/ uint16(xArgImm8u),
-	/*6908*/ uint16(xMatch),
-	/*6909*/ uint16(xSetOp), uint16(CMPSD_XMM),
-	/*6911*/ uint16(xReadSlashR),
-	/*6912*/ uint16(xReadIb),
-	/*6913*/ uint16(xArgXmm1),
-	/*6914*/ uint16(xArgXmm2M64),
-	/*6915*/ uint16(xArgImm8u),
-	/*6916*/ uint16(xMatch),
-	/*6917*/ uint16(xSetOp), uint16(CMPSS),
-	/*6919*/ uint16(xReadSlashR),
-	/*6920*/ uint16(xReadIb),
-	/*6921*/ uint16(xArgXmm1),
-	/*6922*/ uint16(xArgXmm2M32),
-	/*6923*/ uint16(xArgImm8u),
-	/*6924*/ uint16(xMatch),
-	/*6925*/ uint16(xCondIs64), 6928, 6944,
-	/*6928*/ uint16(xCondDataSize), 6932, 6938, 0,
-	/*6932*/ uint16(xSetOp), uint16(MOVNTI),
-	/*6934*/ uint16(xReadSlashR),
-	/*6935*/ uint16(xArgM32),
-	/*6936*/ uint16(xArgR32),
-	/*6937*/ uint16(xMatch),
-	/*6938*/ uint16(xSetOp), uint16(MOVNTI),
-	/*6940*/ uint16(xReadSlashR),
-	/*6941*/ uint16(xArgM32),
-	/*6942*/ uint16(xArgR32),
-	/*6943*/ uint16(xMatch),
-	/*6944*/ uint16(xCondDataSize), 6932, 6938, 6948,
-	/*6948*/ uint16(xSetOp), uint16(MOVNTI),
-	/*6950*/ uint16(xReadSlashR),
-	/*6951*/ uint16(xArgM64),
-	/*6952*/ uint16(xArgR64),
-	/*6953*/ uint16(xMatch),
-	/*6954*/ uint16(xCondPrefix), 2,
-	0x66, 6968,
-	0x0, 6960,
-	/*6960*/ uint16(xSetOp), uint16(PINSRW),
-	/*6962*/ uint16(xReadSlashR),
-	/*6963*/ uint16(xReadIb),
-	/*6964*/ uint16(xArgMm),
-	/*6965*/ uint16(xArgR32M16),
-	/*6966*/ uint16(xArgImm8u),
-	/*6967*/ uint16(xMatch),
-	/*6968*/ uint16(xSetOp), uint16(PINSRW),
-	/*6970*/ uint16(xReadSlashR),
-	/*6971*/ uint16(xReadIb),
-	/*6972*/ uint16(xArgXmm),
-	/*6973*/ uint16(xArgR32M16),
-	/*6974*/ uint16(xArgImm8u),
-	/*6975*/ uint16(xMatch),
-	/*6976*/ uint16(xCondPrefix), 2,
-	0x66, 6990,
-	0x0, 6982,
-	/*6982*/ uint16(xSetOp), uint16(PEXTRW),
-	/*6984*/ uint16(xReadSlashR),
-	/*6985*/ uint16(xReadIb),
-	/*6986*/ uint16(xArgR32),
-	/*6987*/ uint16(xArgMm2),
-	/*6988*/ uint16(xArgImm8u),
-	/*6989*/ uint16(xMatch),
-	/*6990*/ uint16(xSetOp), uint16(PEXTRW),
-	/*6992*/ uint16(xReadSlashR),
-	/*6993*/ uint16(xReadIb),
-	/*6994*/ uint16(xArgR32),
-	/*6995*/ uint16(xArgXmm2),
-	/*6996*/ uint16(xArgImm8u),
-	/*6997*/ uint16(xMatch),
-	/*6998*/ uint16(xCondPrefix), 2,
-	0x66, 7012,
-	0x0, 7004,
-	/*7004*/ uint16(xSetOp), uint16(SHUFPS),
-	/*7006*/ uint16(xReadSlashR),
-	/*7007*/ uint16(xReadIb),
-	/*7008*/ uint16(xArgXmm1),
-	/*7009*/ uint16(xArgXmm2M128),
-	/*7010*/ uint16(xArgImm8u),
-	/*7011*/ uint16(xMatch),
-	/*7012*/ uint16(xSetOp), uint16(SHUFPD),
-	/*7014*/ uint16(xReadSlashR),
-	/*7015*/ uint16(xReadIb),
-	/*7016*/ uint16(xArgXmm1),
-	/*7017*/ uint16(xArgXmm2M128),
-	/*7018*/ uint16(xArgImm8u),
-	/*7019*/ uint16(xMatch),
-	/*7020*/ uint16(xCondSlashR),
-	0,    // 0
-	7029, // 1
-	0,    // 2
-	7052, // 3
-	7075, // 4
-	7098, // 5
-	7121, // 6
-	0,    // 7
-	/*7029*/ uint16(xCondIs64), 7032, 7044,
-	/*7032*/ uint16(xCondDataSize), 7036, 7040, 0,
-	/*7036*/ uint16(xSetOp), uint16(CMPXCHG8B),
-	/*7038*/ uint16(xArgM64),
-	/*7039*/ uint16(xMatch),
-	/*7040*/ uint16(xSetOp), uint16(CMPXCHG8B),
-	/*7042*/ uint16(xArgM64),
-	/*7043*/ uint16(xMatch),
-	/*7044*/ uint16(xCondDataSize), 7036, 7040, 7048,
-	/*7048*/ uint16(xSetOp), uint16(CMPXCHG16B),
-	/*7050*/ uint16(xArgM128),
-	/*7051*/ uint16(xMatch),
-	/*7052*/ uint16(xCondIs64), 7055, 7067,
-	/*7055*/ uint16(xCondDataSize), 7059, 7063, 0,
-	/*7059*/ uint16(xSetOp), uint16(XRSTORS),
-	/*7061*/ uint16(xArgMem),
-	/*7062*/ uint16(xMatch),
-	/*7063*/ uint16(xSetOp), uint16(XRSTORS),
-	/*7065*/ uint16(xArgMem),
-	/*7066*/ uint16(xMatch),
-	/*7067*/ uint16(xCondDataSize), 7059, 7063, 7071,
-	/*7071*/ uint16(xSetOp), uint16(XRSTORS64),
-	/*7073*/ uint16(xArgMem),
-	/*7074*/ uint16(xMatch),
-	/*7075*/ uint16(xCondIs64), 7078, 7090,
-	/*7078*/ uint16(xCondDataSize), 7082, 7086, 0,
-	/*7082*/ uint16(xSetOp), uint16(XSAVEC),
-	/*7084*/ uint16(xArgMem),
-	/*7085*/ uint16(xMatch),
-	/*7086*/ uint16(xSetOp), uint16(XSAVEC),
-	/*7088*/ uint16(xArgMem),
-	/*7089*/ uint16(xMatch),
-	/*7090*/ uint16(xCondDataSize), 7082, 7086, 7094,
-	/*7094*/ uint16(xSetOp), uint16(XSAVEC64),
-	/*7096*/ uint16(xArgMem),
-	/*7097*/ uint16(xMatch),
-	/*7098*/ uint16(xCondIs64), 7101, 7113,
-	/*7101*/ uint16(xCondDataSize), 7105, 7109, 0,
-	/*7105*/ uint16(xSetOp), uint16(XSAVES),
-	/*7107*/ uint16(xArgMem),
-	/*7108*/ uint16(xMatch),
-	/*7109*/ uint16(xSetOp), uint16(XSAVES),
-	/*7111*/ uint16(xArgMem),
-	/*7112*/ uint16(xMatch),
-	/*7113*/ uint16(xCondDataSize), 7105, 7109, 7117,
-	/*7117*/ uint16(xSetOp), uint16(XSAVES64),
-	/*7119*/ uint16(xArgMem),
-	/*7120*/ uint16(xMatch),
-	/*7121*/ uint16(xCondIs64), 7124, 7142,
-	/*7124*/ uint16(xCondDataSize), 7128, 7135, 0,
-	/*7128*/ uint16(xCondIsMem), 7131, 0,
-	/*7131*/ uint16(xSetOp), uint16(RDRAND),
-	/*7133*/ uint16(xArgRmf16),
-	/*7134*/ uint16(xMatch),
-	/*7135*/ uint16(xCondIsMem), 7138, 0,
-	/*7138*/ uint16(xSetOp), uint16(RDRAND),
-	/*7140*/ uint16(xArgRmf32),
-	/*7141*/ uint16(xMatch),
-	/*7142*/ uint16(xCondDataSize), 7128, 7135, 7146,
-	/*7146*/ uint16(xSetOp), uint16(RDRAND),
-	/*7148*/ uint16(xMatch),
-	/*7149*/ uint16(xCondIs64), 7152, 7164,
-	/*7152*/ uint16(xCondDataSize), 7156, 7160, 0,
-	/*7156*/ uint16(xSetOp), uint16(BSWAP),
-	/*7158*/ uint16(xArgR16op),
-	/*7159*/ uint16(xMatch),
-	/*7160*/ uint16(xSetOp), uint16(BSWAP),
-	/*7162*/ uint16(xArgR32op),
-	/*7163*/ uint16(xMatch),
-	/*7164*/ uint16(xCondDataSize), 7156, 7160, 7168,
-	/*7168*/ uint16(xSetOp), uint16(BSWAP),
-	/*7170*/ uint16(xArgR64op),
-	/*7171*/ uint16(xMatch),
-	/*7172*/ uint16(xCondPrefix), 2,
-	0xF2, 7184,
-	0x66, 7178,
-	/*7178*/ uint16(xSetOp), uint16(ADDSUBPD),
-	/*7180*/ uint16(xReadSlashR),
-	/*7181*/ uint16(xArgXmm1),
-	/*7182*/ uint16(xArgXmm2M128),
-	/*7183*/ uint16(xMatch),
-	/*7184*/ uint16(xSetOp), uint16(ADDSUBPS),
-	/*7186*/ uint16(xReadSlashR),
-	/*7187*/ uint16(xArgXmm1),
-	/*7188*/ uint16(xArgXmm2M128),
-	/*7189*/ uint16(xMatch),
-	/*7190*/ uint16(xCondPrefix), 2,
-	0x66, 7202,
-	0x0, 7196,
-	/*7196*/ uint16(xSetOp), uint16(PSRLW),
-	/*7198*/ uint16(xReadSlashR),
-	/*7199*/ uint16(xArgMm),
-	/*7200*/ uint16(xArgMmM64),
-	/*7201*/ uint16(xMatch),
-	/*7202*/ uint16(xSetOp), uint16(PSRLW),
-	/*7204*/ uint16(xReadSlashR),
-	/*7205*/ uint16(xArgXmm1),
-	/*7206*/ uint16(xArgXmm2M128),
-	/*7207*/ uint16(xMatch),
-	/*7208*/ uint16(xCondPrefix), 2,
-	0x66, 7220,
-	0x0, 7214,
-	/*7214*/ uint16(xSetOp), uint16(PSRLD),
-	/*7216*/ uint16(xReadSlashR),
-	/*7217*/ uint16(xArgMm),
-	/*7218*/ uint16(xArgMmM64),
-	/*7219*/ uint16(xMatch),
-	/*7220*/ uint16(xSetOp), uint16(PSRLD),
-	/*7222*/ uint16(xReadSlashR),
-	/*7223*/ uint16(xArgXmm1),
-	/*7224*/ uint16(xArgXmm2M128),
-	/*7225*/ uint16(xMatch),
-	/*7226*/ uint16(xCondPrefix), 2,
-	0x66, 7238,
-	0x0, 7232,
-	/*7232*/ uint16(xSetOp), uint16(PSRLQ),
-	/*7234*/ uint16(xReadSlashR),
-	/*7235*/ uint16(xArgMm),
-	/*7236*/ uint16(xArgMmM64),
-	/*7237*/ uint16(xMatch),
-	/*7238*/ uint16(xSetOp), uint16(PSRLQ),
-	/*7240*/ uint16(xReadSlashR),
-	/*7241*/ uint16(xArgXmm1),
-	/*7242*/ uint16(xArgXmm2M128),
-	/*7243*/ uint16(xMatch),
-	/*7244*/ uint16(xCondPrefix), 2,
-	0x66, 7256,
-	0x0, 7250,
-	/*7250*/ uint16(xSetOp), uint16(PADDQ),
-	/*7252*/ uint16(xReadSlashR),
-	/*7253*/ uint16(xArgMm1),
-	/*7254*/ uint16(xArgMm2M64),
-	/*7255*/ uint16(xMatch),
-	/*7256*/ uint16(xSetOp), uint16(PADDQ),
-	/*7258*/ uint16(xReadSlashR),
-	/*7259*/ uint16(xArgXmm1),
-	/*7260*/ uint16(xArgXmm2M128),
-	/*7261*/ uint16(xMatch),
-	/*7262*/ uint16(xCondPrefix), 2,
-	0x66, 7274,
-	0x0, 7268,
-	/*7268*/ uint16(xSetOp), uint16(PMULLW),
-	/*7270*/ uint16(xReadSlashR),
-	/*7271*/ uint16(xArgMm),
-	/*7272*/ uint16(xArgMmM64),
-	/*7273*/ uint16(xMatch),
-	/*7274*/ uint16(xSetOp), uint16(PMULLW),
-	/*7276*/ uint16(xReadSlashR),
-	/*7277*/ uint16(xArgXmm1),
-	/*7278*/ uint16(xArgXmm2M128),
-	/*7279*/ uint16(xMatch),
-	/*7280*/ uint16(xCondPrefix), 3,
-	0xF3, 7300,
-	0xF2, 7294,
-	0x66, 7288,
-	/*7288*/ uint16(xSetOp), uint16(MOVQ),
-	/*7290*/ uint16(xReadSlashR),
-	/*7291*/ uint16(xArgXmm2M64),
-	/*7292*/ uint16(xArgXmm1),
-	/*7293*/ uint16(xMatch),
-	/*7294*/ uint16(xSetOp), uint16(MOVDQ2Q),
-	/*7296*/ uint16(xReadSlashR),
-	/*7297*/ uint16(xArgMm),
-	/*7298*/ uint16(xArgXmm2),
-	/*7299*/ uint16(xMatch),
-	/*7300*/ uint16(xSetOp), uint16(MOVQ2DQ),
-	/*7302*/ uint16(xReadSlashR),
-	/*7303*/ uint16(xArgXmm1),
-	/*7304*/ uint16(xArgMm2),
-	/*7305*/ uint16(xMatch),
-	/*7306*/ uint16(xCondPrefix), 2,
-	0x66, 7318,
-	0x0, 7312,
-	/*7312*/ uint16(xSetOp), uint16(PMOVMSKB),
-	/*7314*/ uint16(xReadSlashR),
-	/*7315*/ uint16(xArgR32),
-	/*7316*/ uint16(xArgMm2),
-	/*7317*/ uint16(xMatch),
-	/*7318*/ uint16(xSetOp), uint16(PMOVMSKB),
-	/*7320*/ uint16(xReadSlashR),
-	/*7321*/ uint16(xArgR32),
-	/*7322*/ uint16(xArgXmm2),
-	/*7323*/ uint16(xMatch),
-	/*7324*/ uint16(xCondPrefix), 2,
-	0x66, 7336,
-	0x0, 7330,
-	/*7330*/ uint16(xSetOp), uint16(PSUBUSB),
-	/*7332*/ uint16(xReadSlashR),
-	/*7333*/ uint16(xArgMm),
-	/*7334*/ uint16(xArgMmM64),
-	/*7335*/ uint16(xMatch),
-	/*7336*/ uint16(xSetOp), uint16(PSUBUSB),
-	/*7338*/ uint16(xReadSlashR),
-	/*7339*/ uint16(xArgXmm1),
-	/*7340*/ uint16(xArgXmm2M128),
-	/*7341*/ uint16(xMatch),
-	/*7342*/ uint16(xCondPrefix), 2,
-	0x66, 7354,
-	0x0, 7348,
-	/*7348*/ uint16(xSetOp), uint16(PSUBUSW),
-	/*7350*/ uint16(xReadSlashR),
-	/*7351*/ uint16(xArgMm),
-	/*7352*/ uint16(xArgMmM64),
-	/*7353*/ uint16(xMatch),
-	/*7354*/ uint16(xSetOp), uint16(PSUBUSW),
-	/*7356*/ uint16(xReadSlashR),
-	/*7357*/ uint16(xArgXmm1),
-	/*7358*/ uint16(xArgXmm2M128),
-	/*7359*/ uint16(xMatch),
-	/*7360*/ uint16(xCondPrefix), 2,
-	0x66, 7372,
-	0x0, 7366,
-	/*7366*/ uint16(xSetOp), uint16(PMINUB),
-	/*7368*/ uint16(xReadSlashR),
-	/*7369*/ uint16(xArgMm1),
-	/*7370*/ uint16(xArgMm2M64),
-	/*7371*/ uint16(xMatch),
-	/*7372*/ uint16(xSetOp), uint16(PMINUB),
-	/*7374*/ uint16(xReadSlashR),
-	/*7375*/ uint16(xArgXmm1),
-	/*7376*/ uint16(xArgXmm2M128),
-	/*7377*/ uint16(xMatch),
-	/*7378*/ uint16(xCondPrefix), 2,
-	0x66, 7390,
-	0x0, 7384,
-	/*7384*/ uint16(xSetOp), uint16(PAND),
-	/*7386*/ uint16(xReadSlashR),
-	/*7387*/ uint16(xArgMm),
-	/*7388*/ uint16(xArgMmM64),
-	/*7389*/ uint16(xMatch),
-	/*7390*/ uint16(xSetOp), uint16(PAND),
-	/*7392*/ uint16(xReadSlashR),
-	/*7393*/ uint16(xArgXmm1),
-	/*7394*/ uint16(xArgXmm2M128),
-	/*7395*/ uint16(xMatch),
-	/*7396*/ uint16(xCondPrefix), 2,
-	0x66, 7408,
-	0x0, 7402,
-	/*7402*/ uint16(xSetOp), uint16(PADDUSB),
-	/*7404*/ uint16(xReadSlashR),
-	/*7405*/ uint16(xArgMm),
-	/*7406*/ uint16(xArgMmM64),
-	/*7407*/ uint16(xMatch),
-	/*7408*/ uint16(xSetOp), uint16(PADDUSB),
-	/*7410*/ uint16(xReadSlashR),
-	/*7411*/ uint16(xArgXmm1),
-	/*7412*/ uint16(xArgXmm2M128),
-	/*7413*/ uint16(xMatch),
-	/*7414*/ uint16(xCondPrefix), 2,
-	0x66, 7426,
-	0x0, 7420,
-	/*7420*/ uint16(xSetOp), uint16(PADDUSW),
-	/*7422*/ uint16(xReadSlashR),
-	/*7423*/ uint16(xArgMm),
-	/*7424*/ uint16(xArgMmM64),
-	/*7425*/ uint16(xMatch),
-	/*7426*/ uint16(xSetOp), uint16(PADDUSW),
-	/*7428*/ uint16(xReadSlashR),
-	/*7429*/ uint16(xArgXmm1),
-	/*7430*/ uint16(xArgXmm2M128),
-	/*7431*/ uint16(xMatch),
-	/*7432*/ uint16(xCondPrefix), 2,
-	0x66, 7444,
-	0x0, 7438,
-	/*7438*/ uint16(xSetOp), uint16(PMAXUB),
-	/*7440*/ uint16(xReadSlashR),
-	/*7441*/ uint16(xArgMm1),
-	/*7442*/ uint16(xArgMm2M64),
-	/*7443*/ uint16(xMatch),
-	/*7444*/ uint16(xSetOp), uint16(PMAXUB),
-	/*7446*/ uint16(xReadSlashR),
-	/*7447*/ uint16(xArgXmm1),
-	/*7448*/ uint16(xArgXmm2M128),
-	/*7449*/ uint16(xMatch),
-	/*7450*/ uint16(xCondPrefix), 2,
-	0x66, 7462,
-	0x0, 7456,
-	/*7456*/ uint16(xSetOp), uint16(PANDN),
-	/*7458*/ uint16(xReadSlashR),
-	/*7459*/ uint16(xArgMm),
-	/*7460*/ uint16(xArgMmM64),
-	/*7461*/ uint16(xMatch),
-	/*7462*/ uint16(xSetOp), uint16(PANDN),
-	/*7464*/ uint16(xReadSlashR),
-	/*7465*/ uint16(xArgXmm1),
-	/*7466*/ uint16(xArgXmm2M128),
-	/*7467*/ uint16(xMatch),
-	/*7468*/ uint16(xCondPrefix), 2,
-	0x66, 7480,
-	0x0, 7474,
-	/*7474*/ uint16(xSetOp), uint16(PAVGB),
-	/*7476*/ uint16(xReadSlashR),
-	/*7477*/ uint16(xArgMm1),
-	/*7478*/ uint16(xArgMm2M64),
-	/*7479*/ uint16(xMatch),
-	/*7480*/ uint16(xSetOp), uint16(PAVGB),
-	/*7482*/ uint16(xReadSlashR),
-	/*7483*/ uint16(xArgXmm1),
-	/*7484*/ uint16(xArgXmm2M128),
-	/*7485*/ uint16(xMatch),
-	/*7486*/ uint16(xCondPrefix), 2,
-	0x66, 7498,
-	0x0, 7492,
-	/*7492*/ uint16(xSetOp), uint16(PSRAW),
-	/*7494*/ uint16(xReadSlashR),
-	/*7495*/ uint16(xArgMm),
-	/*7496*/ uint16(xArgMmM64),
-	/*7497*/ uint16(xMatch),
-	/*7498*/ uint16(xSetOp), uint16(PSRAW),
-	/*7500*/ uint16(xReadSlashR),
-	/*7501*/ uint16(xArgXmm1),
-	/*7502*/ uint16(xArgXmm2M128),
-	/*7503*/ uint16(xMatch),
-	/*7504*/ uint16(xCondPrefix), 2,
-	0x66, 7516,
-	0x0, 7510,
-	/*7510*/ uint16(xSetOp), uint16(PSRAD),
-	/*7512*/ uint16(xReadSlashR),
-	/*7513*/ uint16(xArgMm),
-	/*7514*/ uint16(xArgMmM64),
-	/*7515*/ uint16(xMatch),
-	/*7516*/ uint16(xSetOp), uint16(PSRAD),
-	/*7518*/ uint16(xReadSlashR),
-	/*7519*/ uint16(xArgXmm1),
-	/*7520*/ uint16(xArgXmm2M128),
-	/*7521*/ uint16(xMatch),
-	/*7522*/ uint16(xCondPrefix), 2,
-	0x66, 7534,
-	0x0, 7528,
-	/*7528*/ uint16(xSetOp), uint16(PAVGW),
-	/*7530*/ uint16(xReadSlashR),
-	/*7531*/ uint16(xArgMm1),
-	/*7532*/ uint16(xArgMm2M64),
-	/*7533*/ uint16(xMatch),
-	/*7534*/ uint16(xSetOp), uint16(PAVGW),
-	/*7536*/ uint16(xReadSlashR),
-	/*7537*/ uint16(xArgXmm1),
-	/*7538*/ uint16(xArgXmm2M128),
-	/*7539*/ uint16(xMatch),
-	/*7540*/ uint16(xCondPrefix), 2,
-	0x66, 7552,
-	0x0, 7546,
-	/*7546*/ uint16(xSetOp), uint16(PMULHUW),
-	/*7548*/ uint16(xReadSlashR),
-	/*7549*/ uint16(xArgMm1),
-	/*7550*/ uint16(xArgMm2M64),
-	/*7551*/ uint16(xMatch),
-	/*7552*/ uint16(xSetOp), uint16(PMULHUW),
-	/*7554*/ uint16(xReadSlashR),
-	/*7555*/ uint16(xArgXmm1),
-	/*7556*/ uint16(xArgXmm2M128),
-	/*7557*/ uint16(xMatch),
-	/*7558*/ uint16(xCondPrefix), 2,
-	0x66, 7570,
-	0x0, 7564,
-	/*7564*/ uint16(xSetOp), uint16(PMULHW),
-	/*7566*/ uint16(xReadSlashR),
-	/*7567*/ uint16(xArgMm),
-	/*7568*/ uint16(xArgMmM64),
-	/*7569*/ uint16(xMatch),
-	/*7570*/ uint16(xSetOp), uint16(PMULHW),
-	/*7572*/ uint16(xReadSlashR),
-	/*7573*/ uint16(xArgXmm1),
-	/*7574*/ uint16(xArgXmm2M128),
-	/*7575*/ uint16(xMatch),
-	/*7576*/ uint16(xCondPrefix), 3,
-	0xF3, 7596,
-	0xF2, 7590,
-	0x66, 7584,
-	/*7584*/ uint16(xSetOp), uint16(CVTTPD2DQ),
-	/*7586*/ uint16(xReadSlashR),
-	/*7587*/ uint16(xArgXmm1),
-	/*7588*/ uint16(xArgXmm2M128),
-	/*7589*/ uint16(xMatch),
-	/*7590*/ uint16(xSetOp), uint16(CVTPD2DQ),
-	/*7592*/ uint16(xReadSlashR),
-	/*7593*/ uint16(xArgXmm1),
-	/*7594*/ uint16(xArgXmm2M128),
-	/*7595*/ uint16(xMatch),
-	/*7596*/ uint16(xSetOp), uint16(CVTDQ2PD),
-	/*7598*/ uint16(xReadSlashR),
-	/*7599*/ uint16(xArgXmm1),
-	/*7600*/ uint16(xArgXmm2M64),
-	/*7601*/ uint16(xMatch),
-	/*7602*/ uint16(xCondPrefix), 2,
-	0x66, 7614,
-	0x0, 7608,
-	/*7608*/ uint16(xSetOp), uint16(MOVNTQ),
-	/*7610*/ uint16(xReadSlashR),
-	/*7611*/ uint16(xArgM64),
-	/*7612*/ uint16(xArgMm),
-	/*7613*/ uint16(xMatch),
-	/*7614*/ uint16(xSetOp), uint16(MOVNTDQ),
-	/*7616*/ uint16(xReadSlashR),
-	/*7617*/ uint16(xArgM128),
-	/*7618*/ uint16(xArgXmm),
-	/*7619*/ uint16(xMatch),
-	/*7620*/ uint16(xCondPrefix), 2,
-	0x66, 7632,
-	0x0, 7626,
-	/*7626*/ uint16(xSetOp), uint16(PSUBSB),
-	/*7628*/ uint16(xReadSlashR),
-	/*7629*/ uint16(xArgMm),
-	/*7630*/ uint16(xArgMmM64),
-	/*7631*/ uint16(xMatch),
-	/*7632*/ uint16(xSetOp), uint16(PSUBSB),
-	/*7634*/ uint16(xReadSlashR),
-	/*7635*/ uint16(xArgXmm1),
-	/*7636*/ uint16(xArgXmm2M128),
-	/*7637*/ uint16(xMatch),
-	/*7638*/ uint16(xCondPrefix), 2,
-	0x66, 7650,
-	0x0, 7644,
-	/*7644*/ uint16(xSetOp), uint16(PSUBSW),
-	/*7646*/ uint16(xReadSlashR),
-	/*7647*/ uint16(xArgMm),
-	/*7648*/ uint16(xArgMmM64),
-	/*7649*/ uint16(xMatch),
-	/*7650*/ uint16(xSetOp), uint16(PSUBSW),
-	/*7652*/ uint16(xReadSlashR),
-	/*7653*/ uint16(xArgXmm1),
-	/*7654*/ uint16(xArgXmm2M128),
-	/*7655*/ uint16(xMatch),
-	/*7656*/ uint16(xCondPrefix), 2,
-	0x66, 7668,
-	0x0, 7662,
-	/*7662*/ uint16(xSetOp), uint16(PMINSW),
-	/*7664*/ uint16(xReadSlashR),
-	/*7665*/ uint16(xArgMm1),
-	/*7666*/ uint16(xArgMm2M64),
-	/*7667*/ uint16(xMatch),
-	/*7668*/ uint16(xSetOp), uint16(PMINSW),
-	/*7670*/ uint16(xReadSlashR),
-	/*7671*/ uint16(xArgXmm1),
-	/*7672*/ uint16(xArgXmm2M128),
-	/*7673*/ uint16(xMatch),
-	/*7674*/ uint16(xCondPrefix), 2,
-	0x66, 7686,
-	0x0, 7680,
-	/*7680*/ uint16(xSetOp), uint16(POR),
-	/*7682*/ uint16(xReadSlashR),
-	/*7683*/ uint16(xArgMm),
-	/*7684*/ uint16(xArgMmM64),
-	/*7685*/ uint16(xMatch),
-	/*7686*/ uint16(xSetOp), uint16(POR),
-	/*7688*/ uint16(xReadSlashR),
-	/*7689*/ uint16(xArgXmm1),
-	/*7690*/ uint16(xArgXmm2M128),
-	/*7691*/ uint16(xMatch),
-	/*7692*/ uint16(xCondPrefix), 2,
-	0x66, 7704,
-	0x0, 7698,
-	/*7698*/ uint16(xSetOp), uint16(PADDSB),
-	/*7700*/ uint16(xReadSlashR),
-	/*7701*/ uint16(xArgMm),
-	/*7702*/ uint16(xArgMmM64),
-	/*7703*/ uint16(xMatch),
-	/*7704*/ uint16(xSetOp), uint16(PADDSB),
-	/*7706*/ uint16(xReadSlashR),
-	/*7707*/ uint16(xArgXmm1),
-	/*7708*/ uint16(xArgXmm2M128),
-	/*7709*/ uint16(xMatch),
-	/*7710*/ uint16(xCondPrefix), 2,
-	0x66, 7722,
-	0x0, 7716,
-	/*7716*/ uint16(xSetOp), uint16(PADDSW),
-	/*7718*/ uint16(xReadSlashR),
-	/*7719*/ uint16(xArgMm),
-	/*7720*/ uint16(xArgMmM64),
-	/*7721*/ uint16(xMatch),
-	/*7722*/ uint16(xSetOp), uint16(PADDSW),
-	/*7724*/ uint16(xReadSlashR),
-	/*7725*/ uint16(xArgXmm1),
-	/*7726*/ uint16(xArgXmm2M128),
-	/*7727*/ uint16(xMatch),
-	/*7728*/ uint16(xCondPrefix), 2,
-	0x66, 7740,
-	0x0, 7734,
-	/*7734*/ uint16(xSetOp), uint16(PMAXSW),
-	/*7736*/ uint16(xReadSlashR),
-	/*7737*/ uint16(xArgMm1),
-	/*7738*/ uint16(xArgMm2M64),
-	/*7739*/ uint16(xMatch),
-	/*7740*/ uint16(xSetOp), uint16(PMAXSW),
-	/*7742*/ uint16(xReadSlashR),
-	/*7743*/ uint16(xArgXmm1),
-	/*7744*/ uint16(xArgXmm2M128),
-	/*7745*/ uint16(xMatch),
-	/*7746*/ uint16(xCondPrefix), 2,
-	0x66, 7758,
-	0x0, 7752,
-	/*7752*/ uint16(xSetOp), uint16(PXOR),
-	/*7754*/ uint16(xReadSlashR),
-	/*7755*/ uint16(xArgMm),
-	/*7756*/ uint16(xArgMmM64),
-	/*7757*/ uint16(xMatch),
-	/*7758*/ uint16(xSetOp), uint16(PXOR),
-	/*7760*/ uint16(xReadSlashR),
-	/*7761*/ uint16(xArgXmm1),
-	/*7762*/ uint16(xArgXmm2M128),
-	/*7763*/ uint16(xMatch),
-	/*7764*/ uint16(xCondPrefix), 1,
-	0xF2, 7768,
-	/*7768*/ uint16(xSetOp), uint16(LDDQU),
-	/*7770*/ uint16(xReadSlashR),
-	/*7771*/ uint16(xArgXmm1),
-	/*7772*/ uint16(xArgM128),
-	/*7773*/ uint16(xMatch),
-	/*7774*/ uint16(xCondPrefix), 2,
-	0x66, 7786,
-	0x0, 7780,
-	/*7780*/ uint16(xSetOp), uint16(PSLLW),
-	/*7782*/ uint16(xReadSlashR),
-	/*7783*/ uint16(xArgMm),
-	/*7784*/ uint16(xArgMmM64),
-	/*7785*/ uint16(xMatch),
-	/*7786*/ uint16(xSetOp), uint16(PSLLW),
-	/*7788*/ uint16(xReadSlashR),
-	/*7789*/ uint16(xArgXmm1),
-	/*7790*/ uint16(xArgXmm2M128),
-	/*7791*/ uint16(xMatch),
-	/*7792*/ uint16(xCondPrefix), 2,
-	0x66, 7804,
-	0x0, 7798,
-	/*7798*/ uint16(xSetOp), uint16(PSLLD),
-	/*7800*/ uint16(xReadSlashR),
-	/*7801*/ uint16(xArgMm),
-	/*7802*/ uint16(xArgMmM64),
-	/*7803*/ uint16(xMatch),
-	/*7804*/ uint16(xSetOp), uint16(PSLLD),
-	/*7806*/ uint16(xReadSlashR),
-	/*7807*/ uint16(xArgXmm1),
-	/*7808*/ uint16(xArgXmm2M128),
-	/*7809*/ uint16(xMatch),
-	/*7810*/ uint16(xCondPrefix), 2,
-	0x66, 7822,
-	0x0, 7816,
-	/*7816*/ uint16(xSetOp), uint16(PSLLQ),
-	/*7818*/ uint16(xReadSlashR),
-	/*7819*/ uint16(xArgMm),
-	/*7820*/ uint16(xArgMmM64),
-	/*7821*/ uint16(xMatch),
-	/*7822*/ uint16(xSetOp), uint16(PSLLQ),
-	/*7824*/ uint16(xReadSlashR),
-	/*7825*/ uint16(xArgXmm1),
-	/*7826*/ uint16(xArgXmm2M128),
-	/*7827*/ uint16(xMatch),
-	/*7828*/ uint16(xCondPrefix), 2,
-	0x66, 7840,
-	0x0, 7834,
-	/*7834*/ uint16(xSetOp), uint16(PMULUDQ),
-	/*7836*/ uint16(xReadSlashR),
-	/*7837*/ uint16(xArgMm1),
-	/*7838*/ uint16(xArgMm2M64),
-	/*7839*/ uint16(xMatch),
-	/*7840*/ uint16(xSetOp), uint16(PMULUDQ),
-	/*7842*/ uint16(xReadSlashR),
-	/*7843*/ uint16(xArgXmm1),
-	/*7844*/ uint16(xArgXmm2M128),
-	/*7845*/ uint16(xMatch),
-	/*7846*/ uint16(xCondPrefix), 2,
-	0x66, 7858,
-	0x0, 7852,
-	/*7852*/ uint16(xSetOp), uint16(PMADDWD),
-	/*7854*/ uint16(xReadSlashR),
-	/*7855*/ uint16(xArgMm),
-	/*7856*/ uint16(xArgMmM64),
-	/*7857*/ uint16(xMatch),
-	/*7858*/ uint16(xSetOp), uint16(PMADDWD),
-	/*7860*/ uint16(xReadSlashR),
-	/*7861*/ uint16(xArgXmm1),
-	/*7862*/ uint16(xArgXmm2M128),
-	/*7863*/ uint16(xMatch),
-	/*7864*/ uint16(xCondPrefix), 2,
-	0x66, 7876,
-	0x0, 7870,
-	/*7870*/ uint16(xSetOp), uint16(PSADBW),
-	/*7872*/ uint16(xReadSlashR),
-	/*7873*/ uint16(xArgMm1),
-	/*7874*/ uint16(xArgMm2M64),
-	/*7875*/ uint16(xMatch),
-	/*7876*/ uint16(xSetOp), uint16(PSADBW),
-	/*7878*/ uint16(xReadSlashR),
-	/*7879*/ uint16(xArgXmm1),
-	/*7880*/ uint16(xArgXmm2M128),
-	/*7881*/ uint16(xMatch),
-	/*7882*/ uint16(xCondPrefix), 2,
-	0x66, 7894,
-	0x0, 7888,
-	/*7888*/ uint16(xSetOp), uint16(MASKMOVQ),
-	/*7890*/ uint16(xReadSlashR),
-	/*7891*/ uint16(xArgMm1),
-	/*7892*/ uint16(xArgMm2),
-	/*7893*/ uint16(xMatch),
-	/*7894*/ uint16(xSetOp), uint16(MASKMOVDQU),
-	/*7896*/ uint16(xReadSlashR),
-	/*7897*/ uint16(xArgXmm1),
-	/*7898*/ uint16(xArgXmm2),
-	/*7899*/ uint16(xMatch),
-	/*7900*/ uint16(xCondPrefix), 2,
-	0x66, 7912,
-	0x0, 7906,
-	/*7906*/ uint16(xSetOp), uint16(PSUBB),
-	/*7908*/ uint16(xReadSlashR),
-	/*7909*/ uint16(xArgMm),
-	/*7910*/ uint16(xArgMmM64),
-	/*7911*/ uint16(xMatch),
-	/*7912*/ uint16(xSetOp), uint16(PSUBB),
-	/*7914*/ uint16(xReadSlashR),
-	/*7915*/ uint16(xArgXmm1),
-	/*7916*/ uint16(xArgXmm2M128),
-	/*7917*/ uint16(xMatch),
-	/*7918*/ uint16(xCondPrefix), 2,
-	0x66, 7930,
-	0x0, 7924,
-	/*7924*/ uint16(xSetOp), uint16(PSUBW),
-	/*7926*/ uint16(xReadSlashR),
-	/*7927*/ uint16(xArgMm),
-	/*7928*/ uint16(xArgMmM64),
-	/*7929*/ uint16(xMatch),
-	/*7930*/ uint16(xSetOp), uint16(PSUBW),
-	/*7932*/ uint16(xReadSlashR),
-	/*7933*/ uint16(xArgXmm1),
-	/*7934*/ uint16(xArgXmm2M128),
-	/*7935*/ uint16(xMatch),
-	/*7936*/ uint16(xCondPrefix), 2,
-	0x66, 7948,
-	0x0, 7942,
-	/*7942*/ uint16(xSetOp), uint16(PSUBD),
-	/*7944*/ uint16(xReadSlashR),
-	/*7945*/ uint16(xArgMm),
-	/*7946*/ uint16(xArgMmM64),
-	/*7947*/ uint16(xMatch),
-	/*7948*/ uint16(xSetOp), uint16(PSUBD),
-	/*7950*/ uint16(xReadSlashR),
-	/*7951*/ uint16(xArgXmm1),
-	/*7952*/ uint16(xArgXmm2M128),
-	/*7953*/ uint16(xMatch),
-	/*7954*/ uint16(xCondPrefix), 2,
-	0x66, 7966,
-	0x0, 7960,
-	/*7960*/ uint16(xSetOp), uint16(PSUBQ),
-	/*7962*/ uint16(xReadSlashR),
-	/*7963*/ uint16(xArgMm1),
-	/*7964*/ uint16(xArgMm2M64),
-	/*7965*/ uint16(xMatch),
-	/*7966*/ uint16(xSetOp), uint16(PSUBQ),
-	/*7968*/ uint16(xReadSlashR),
-	/*7969*/ uint16(xArgXmm1),
-	/*7970*/ uint16(xArgXmm2M128),
-	/*7971*/ uint16(xMatch),
-	/*7972*/ uint16(xCondPrefix), 2,
-	0x66, 7984,
-	0x0, 7978,
-	/*7978*/ uint16(xSetOp), uint16(PADDB),
-	/*7980*/ uint16(xReadSlashR),
-	/*7981*/ uint16(xArgMm),
-	/*7982*/ uint16(xArgMmM64),
-	/*7983*/ uint16(xMatch),
-	/*7984*/ uint16(xSetOp), uint16(PADDB),
-	/*7986*/ uint16(xReadSlashR),
-	/*7987*/ uint16(xArgXmm1),
-	/*7988*/ uint16(xArgXmm2M128),
-	/*7989*/ uint16(xMatch),
-	/*7990*/ uint16(xCondPrefix), 2,
-	0x66, 8002,
-	0x0, 7996,
-	/*7996*/ uint16(xSetOp), uint16(PADDW),
-	/*7998*/ uint16(xReadSlashR),
-	/*7999*/ uint16(xArgMm),
-	/*8000*/ uint16(xArgMmM64),
-	/*8001*/ uint16(xMatch),
-	/*8002*/ uint16(xSetOp), uint16(PADDW),
-	/*8004*/ uint16(xReadSlashR),
-	/*8005*/ uint16(xArgXmm1),
-	/*8006*/ uint16(xArgXmm2M128),
-	/*8007*/ uint16(xMatch),
-	/*8008*/ uint16(xCondPrefix), 2,
-	0x66, 8020,
-	0x0, 8014,
-	/*8014*/ uint16(xSetOp), uint16(PADDD),
-	/*8016*/ uint16(xReadSlashR),
-	/*8017*/ uint16(xArgMm),
-	/*8018*/ uint16(xArgMmM64),
-	/*8019*/ uint16(xMatch),
-	/*8020*/ uint16(xSetOp), uint16(PADDD),
-	/*8022*/ uint16(xReadSlashR),
-	/*8023*/ uint16(xArgXmm1),
-	/*8024*/ uint16(xArgXmm2M128),
-	/*8025*/ uint16(xMatch),
-	/*8026*/ uint16(xSetOp), uint16(ADC),
-	/*8028*/ uint16(xReadSlashR),
-	/*8029*/ uint16(xArgRM8),
-	/*8030*/ uint16(xArgR8),
-	/*8031*/ uint16(xMatch),
-	/*8032*/ uint16(xCondIs64), 8035, 8051,
-	/*8035*/ uint16(xCondDataSize), 8039, 8045, 0,
-	/*8039*/ uint16(xSetOp), uint16(ADC),
-	/*8041*/ uint16(xReadSlashR),
-	/*8042*/ uint16(xArgRM16),
-	/*8043*/ uint16(xArgR16),
-	/*8044*/ uint16(xMatch),
-	/*8045*/ uint16(xSetOp), uint16(ADC),
-	/*8047*/ uint16(xReadSlashR),
-	/*8048*/ uint16(xArgRM32),
-	/*8049*/ uint16(xArgR32),
-	/*8050*/ uint16(xMatch),
-	/*8051*/ uint16(xCondDataSize), 8039, 8045, 8055,
-	/*8055*/ uint16(xSetOp), uint16(ADC),
-	/*8057*/ uint16(xReadSlashR),
-	/*8058*/ uint16(xArgRM64),
-	/*8059*/ uint16(xArgR64),
-	/*8060*/ uint16(xMatch),
-	/*8061*/ uint16(xSetOp), uint16(ADC),
-	/*8063*/ uint16(xReadSlashR),
-	/*8064*/ uint16(xArgR8),
-	/*8065*/ uint16(xArgRM8),
-	/*8066*/ uint16(xMatch),
-	/*8067*/ uint16(xCondIs64), 8070, 8086,
-	/*8070*/ uint16(xCondDataSize), 8074, 8080, 0,
-	/*8074*/ uint16(xSetOp), uint16(ADC),
-	/*8076*/ uint16(xReadSlashR),
-	/*8077*/ uint16(xArgR16),
-	/*8078*/ uint16(xArgRM16),
-	/*8079*/ uint16(xMatch),
-	/*8080*/ uint16(xSetOp), uint16(ADC),
-	/*8082*/ uint16(xReadSlashR),
-	/*8083*/ uint16(xArgR32),
-	/*8084*/ uint16(xArgRM32),
-	/*8085*/ uint16(xMatch),
-	/*8086*/ uint16(xCondDataSize), 8074, 8080, 8090,
-	/*8090*/ uint16(xSetOp), uint16(ADC),
-	/*8092*/ uint16(xReadSlashR),
-	/*8093*/ uint16(xArgR64),
-	/*8094*/ uint16(xArgRM64),
-	/*8095*/ uint16(xMatch),
-	/*8096*/ uint16(xSetOp), uint16(ADC),
-	/*8098*/ uint16(xReadIb),
-	/*8099*/ uint16(xArgAL),
-	/*8100*/ uint16(xArgImm8u),
-	/*8101*/ uint16(xMatch),
-	/*8102*/ uint16(xCondIs64), 8105, 8121,
-	/*8105*/ uint16(xCondDataSize), 8109, 8115, 0,
-	/*8109*/ uint16(xSetOp), uint16(ADC),
-	/*8111*/ uint16(xReadIw),
-	/*8112*/ uint16(xArgAX),
-	/*8113*/ uint16(xArgImm16),
-	/*8114*/ uint16(xMatch),
-	/*8115*/ uint16(xSetOp), uint16(ADC),
-	/*8117*/ uint16(xReadId),
-	/*8118*/ uint16(xArgEAX),
-	/*8119*/ uint16(xArgImm32),
-	/*8120*/ uint16(xMatch),
-	/*8121*/ uint16(xCondDataSize), 8109, 8115, 8125,
-	/*8125*/ uint16(xSetOp), uint16(ADC),
-	/*8127*/ uint16(xReadId),
-	/*8128*/ uint16(xArgRAX),
-	/*8129*/ uint16(xArgImm32),
-	/*8130*/ uint16(xMatch),
-	/*8131*/ uint16(xCondIs64), 8134, 0,
-	/*8134*/ uint16(xSetOp), uint16(PUSH),
-	/*8136*/ uint16(xArgSS),
-	/*8137*/ uint16(xMatch),
-	/*8138*/ uint16(xCondIs64), 8141, 0,
-	/*8141*/ uint16(xSetOp), uint16(POP),
-	/*8143*/ uint16(xArgSS),
-	/*8144*/ uint16(xMatch),
-	/*8145*/ uint16(xSetOp), uint16(SBB),
-	/*8147*/ uint16(xReadSlashR),
-	/*8148*/ uint16(xArgRM8),
-	/*8149*/ uint16(xArgR8),
-	/*8150*/ uint16(xMatch),
-	/*8151*/ uint16(xCondIs64), 8154, 8170,
-	/*8154*/ uint16(xCondDataSize), 8158, 8164, 0,
-	/*8158*/ uint16(xSetOp), uint16(SBB),
-	/*8160*/ uint16(xReadSlashR),
-	/*8161*/ uint16(xArgRM16),
-	/*8162*/ uint16(xArgR16),
-	/*8163*/ uint16(xMatch),
-	/*8164*/ uint16(xSetOp), uint16(SBB),
-	/*8166*/ uint16(xReadSlashR),
-	/*8167*/ uint16(xArgRM32),
-	/*8168*/ uint16(xArgR32),
-	/*8169*/ uint16(xMatch),
-	/*8170*/ uint16(xCondDataSize), 8158, 8164, 8174,
-	/*8174*/ uint16(xSetOp), uint16(SBB),
-	/*8176*/ uint16(xReadSlashR),
-	/*8177*/ uint16(xArgRM64),
-	/*8178*/ uint16(xArgR64),
-	/*8179*/ uint16(xMatch),
-	/*8180*/ uint16(xSetOp), uint16(SBB),
-	/*8182*/ uint16(xReadSlashR),
-	/*8183*/ uint16(xArgR8),
-	/*8184*/ uint16(xArgRM8),
-	/*8185*/ uint16(xMatch),
-	/*8186*/ uint16(xCondIs64), 8189, 8205,
-	/*8189*/ uint16(xCondDataSize), 8193, 8199, 0,
-	/*8193*/ uint16(xSetOp), uint16(SBB),
-	/*8195*/ uint16(xReadSlashR),
-	/*8196*/ uint16(xArgR16),
-	/*8197*/ uint16(xArgRM16),
-	/*8198*/ uint16(xMatch),
-	/*8199*/ uint16(xSetOp), uint16(SBB),
-	/*8201*/ uint16(xReadSlashR),
-	/*8202*/ uint16(xArgR32),
-	/*8203*/ uint16(xArgRM32),
-	/*8204*/ uint16(xMatch),
-	/*8205*/ uint16(xCondDataSize), 8193, 8199, 8209,
-	/*8209*/ uint16(xSetOp), uint16(SBB),
-	/*8211*/ uint16(xReadSlashR),
-	/*8212*/ uint16(xArgR64),
-	/*8213*/ uint16(xArgRM64),
-	/*8214*/ uint16(xMatch),
-	/*8215*/ uint16(xSetOp), uint16(SBB),
-	/*8217*/ uint16(xReadIb),
-	/*8218*/ uint16(xArgAL),
-	/*8219*/ uint16(xArgImm8u),
-	/*8220*/ uint16(xMatch),
-	/*8221*/ uint16(xCondIs64), 8224, 8240,
-	/*8224*/ uint16(xCondDataSize), 8228, 8234, 0,
-	/*8228*/ uint16(xSetOp), uint16(SBB),
-	/*8230*/ uint16(xReadIw),
-	/*8231*/ uint16(xArgAX),
-	/*8232*/ uint16(xArgImm16),
-	/*8233*/ uint16(xMatch),
-	/*8234*/ uint16(xSetOp), uint16(SBB),
-	/*8236*/ uint16(xReadId),
-	/*8237*/ uint16(xArgEAX),
-	/*8238*/ uint16(xArgImm32),
-	/*8239*/ uint16(xMatch),
-	/*8240*/ uint16(xCondDataSize), 8228, 8234, 8244,
-	/*8244*/ uint16(xSetOp), uint16(SBB),
-	/*8246*/ uint16(xReadId),
-	/*8247*/ uint16(xArgRAX),
-	/*8248*/ uint16(xArgImm32),
-	/*8249*/ uint16(xMatch),
-	/*8250*/ uint16(xCondIs64), 8253, 0,
-	/*8253*/ uint16(xSetOp), uint16(PUSH),
-	/*8255*/ uint16(xArgDS),
-	/*8256*/ uint16(xMatch),
-	/*8257*/ uint16(xCondIs64), 8260, 0,
-	/*8260*/ uint16(xSetOp), uint16(POP),
-	/*8262*/ uint16(xArgDS),
-	/*8263*/ uint16(xMatch),
-	/*8264*/ uint16(xSetOp), uint16(AND),
-	/*8266*/ uint16(xReadSlashR),
-	/*8267*/ uint16(xArgRM8),
-	/*8268*/ uint16(xArgR8),
-	/*8269*/ uint16(xMatch),
-	/*8270*/ uint16(xCondIs64), 8273, 8289,
-	/*8273*/ uint16(xCondDataSize), 8277, 8283, 0,
-	/*8277*/ uint16(xSetOp), uint16(AND),
-	/*8279*/ uint16(xReadSlashR),
-	/*8280*/ uint16(xArgRM16),
-	/*8281*/ uint16(xArgR16),
-	/*8282*/ uint16(xMatch),
-	/*8283*/ uint16(xSetOp), uint16(AND),
-	/*8285*/ uint16(xReadSlashR),
-	/*8286*/ uint16(xArgRM32),
-	/*8287*/ uint16(xArgR32),
-	/*8288*/ uint16(xMatch),
-	/*8289*/ uint16(xCondDataSize), 8277, 8283, 8293,
-	/*8293*/ uint16(xSetOp), uint16(AND),
-	/*8295*/ uint16(xReadSlashR),
-	/*8296*/ uint16(xArgRM64),
-	/*8297*/ uint16(xArgR64),
-	/*8298*/ uint16(xMatch),
-	/*8299*/ uint16(xSetOp), uint16(AND),
-	/*8301*/ uint16(xReadSlashR),
-	/*8302*/ uint16(xArgR8),
-	/*8303*/ uint16(xArgRM8),
-	/*8304*/ uint16(xMatch),
-	/*8305*/ uint16(xCondIs64), 8308, 8324,
-	/*8308*/ uint16(xCondDataSize), 8312, 8318, 0,
-	/*8312*/ uint16(xSetOp), uint16(AND),
-	/*8314*/ uint16(xReadSlashR),
-	/*8315*/ uint16(xArgR16),
-	/*8316*/ uint16(xArgRM16),
-	/*8317*/ uint16(xMatch),
-	/*8318*/ uint16(xSetOp), uint16(AND),
-	/*8320*/ uint16(xReadSlashR),
-	/*8321*/ uint16(xArgR32),
-	/*8322*/ uint16(xArgRM32),
-	/*8323*/ uint16(xMatch),
-	/*8324*/ uint16(xCondDataSize), 8312, 8318, 8328,
-	/*8328*/ uint16(xSetOp), uint16(AND),
-	/*8330*/ uint16(xReadSlashR),
-	/*8331*/ uint16(xArgR64),
-	/*8332*/ uint16(xArgRM64),
-	/*8333*/ uint16(xMatch),
-	/*8334*/ uint16(xSetOp), uint16(AND),
-	/*8336*/ uint16(xReadIb),
-	/*8337*/ uint16(xArgAL),
-	/*8338*/ uint16(xArgImm8u),
-	/*8339*/ uint16(xMatch),
-	/*8340*/ uint16(xCondIs64), 8343, 8359,
-	/*8343*/ uint16(xCondDataSize), 8347, 8353, 0,
-	/*8347*/ uint16(xSetOp), uint16(AND),
-	/*8349*/ uint16(xReadIw),
-	/*8350*/ uint16(xArgAX),
-	/*8351*/ uint16(xArgImm16),
-	/*8352*/ uint16(xMatch),
-	/*8353*/ uint16(xSetOp), uint16(AND),
-	/*8355*/ uint16(xReadId),
-	/*8356*/ uint16(xArgEAX),
-	/*8357*/ uint16(xArgImm32),
-	/*8358*/ uint16(xMatch),
-	/*8359*/ uint16(xCondDataSize), 8347, 8353, 8363,
-	/*8363*/ uint16(xSetOp), uint16(AND),
-	/*8365*/ uint16(xReadId),
-	/*8366*/ uint16(xArgRAX),
-	/*8367*/ uint16(xArgImm32),
-	/*8368*/ uint16(xMatch),
-	/*8369*/ uint16(xCondIs64), 8372, 0,
-	/*8372*/ uint16(xSetOp), uint16(DAA),
-	/*8374*/ uint16(xMatch),
-	/*8375*/ uint16(xSetOp), uint16(SUB),
-	/*8377*/ uint16(xReadSlashR),
-	/*8378*/ uint16(xArgRM8),
-	/*8379*/ uint16(xArgR8),
-	/*8380*/ uint16(xMatch),
-	/*8381*/ uint16(xCondIs64), 8384, 8400,
-	/*8384*/ uint16(xCondDataSize), 8388, 8394, 0,
-	/*8388*/ uint16(xSetOp), uint16(SUB),
-	/*8390*/ uint16(xReadSlashR),
-	/*8391*/ uint16(xArgRM16),
-	/*8392*/ uint16(xArgR16),
-	/*8393*/ uint16(xMatch),
-	/*8394*/ uint16(xSetOp), uint16(SUB),
-	/*8396*/ uint16(xReadSlashR),
-	/*8397*/ uint16(xArgRM32),
-	/*8398*/ uint16(xArgR32),
-	/*8399*/ uint16(xMatch),
-	/*8400*/ uint16(xCondDataSize), 8388, 8394, 8404,
-	/*8404*/ uint16(xSetOp), uint16(SUB),
-	/*8406*/ uint16(xReadSlashR),
-	/*8407*/ uint16(xArgRM64),
-	/*8408*/ uint16(xArgR64),
-	/*8409*/ uint16(xMatch),
-	/*8410*/ uint16(xCondPrefix), 3,
-	0xC5, 8438,
-	0xC4, 8424,
-	0x0, 8418,
-	/*8418*/ uint16(xSetOp), uint16(SUB),
-	/*8420*/ uint16(xReadSlashR),
-	/*8421*/ uint16(xArgR8),
-	/*8422*/ uint16(xArgRM8),
-	/*8423*/ uint16(xMatch),
-	/*8424*/ uint16(xCondPrefix), 1,
-	0x66, 8428,
-	/*8428*/ uint16(xCondPrefix), 1,
-	0x0F38, 8432,
-	/*8432*/ uint16(xSetOp), uint16(VMOVNTDQA),
-	/*8434*/ uint16(xReadSlashR),
-	/*8435*/ uint16(xArgYmm1),
-	/*8436*/ uint16(xArgM256),
-	/*8437*/ uint16(xMatch),
-	/*8438*/ uint16(xCondPrefix), 1,
-	0x66, 8442,
-	/*8442*/ uint16(xCondPrefix), 1,
-	0x0F38, 8446,
-	/*8446*/ uint16(xSetOp), uint16(VMOVNTDQA),
-	/*8448*/ uint16(xReadSlashR),
-	/*8449*/ uint16(xArgYmm1),
-	/*8450*/ uint16(xArgM256),
-	/*8451*/ uint16(xMatch),
-	/*8452*/ uint16(xCondIs64), 8455, 8471,
-	/*8455*/ uint16(xCondDataSize), 8459, 8465, 0,
-	/*8459*/ uint16(xSetOp), uint16(SUB),
-	/*8461*/ uint16(xReadSlashR),
-	/*8462*/ uint16(xArgR16),
-	/*8463*/ uint16(xArgRM16),
-	/*8464*/ uint16(xMatch),
-	/*8465*/ uint16(xSetOp), uint16(SUB),
-	/*8467*/ uint16(xReadSlashR),
-	/*8468*/ uint16(xArgR32),
-	/*8469*/ uint16(xArgRM32),
-	/*8470*/ uint16(xMatch),
-	/*8471*/ uint16(xCondDataSize), 8459, 8465, 8475,
-	/*8475*/ uint16(xSetOp), uint16(SUB),
-	/*8477*/ uint16(xReadSlashR),
-	/*8478*/ uint16(xArgR64),
-	/*8479*/ uint16(xArgRM64),
-	/*8480*/ uint16(xMatch),
-	/*8481*/ uint16(xSetOp), uint16(SUB),
-	/*8483*/ uint16(xReadIb),
-	/*8484*/ uint16(xArgAL),
-	/*8485*/ uint16(xArgImm8u),
-	/*8486*/ uint16(xMatch),
-	/*8487*/ uint16(xCondIs64), 8490, 8506,
-	/*8490*/ uint16(xCondDataSize), 8494, 8500, 0,
-	/*8494*/ uint16(xSetOp), uint16(SUB),
-	/*8496*/ uint16(xReadIw),
-	/*8497*/ uint16(xArgAX),
-	/*8498*/ uint16(xArgImm16),
-	/*8499*/ uint16(xMatch),
-	/*8500*/ uint16(xSetOp), uint16(SUB),
-	/*8502*/ uint16(xReadId),
-	/*8503*/ uint16(xArgEAX),
-	/*8504*/ uint16(xArgImm32),
-	/*8505*/ uint16(xMatch),
-	/*8506*/ uint16(xCondDataSize), 8494, 8500, 8510,
-	/*8510*/ uint16(xSetOp), uint16(SUB),
-	/*8512*/ uint16(xReadId),
-	/*8513*/ uint16(xArgRAX),
-	/*8514*/ uint16(xArgImm32),
-	/*8515*/ uint16(xMatch),
-	/*8516*/ uint16(xCondIs64), 8519, 0,
-	/*8519*/ uint16(xSetOp), uint16(DAS),
-	/*8521*/ uint16(xMatch),
-	/*8522*/ uint16(xSetOp), uint16(XOR),
-	/*8524*/ uint16(xReadSlashR),
-	/*8525*/ uint16(xArgRM8),
-	/*8526*/ uint16(xArgR8),
-	/*8527*/ uint16(xMatch),
-	/*8528*/ uint16(xCondIs64), 8531, 8547,
-	/*8531*/ uint16(xCondDataSize), 8535, 8541, 0,
-	/*8535*/ uint16(xSetOp), uint16(XOR),
-	/*8537*/ uint16(xReadSlashR),
-	/*8538*/ uint16(xArgRM16),
-	/*8539*/ uint16(xArgR16),
-	/*8540*/ uint16(xMatch),
-	/*8541*/ uint16(xSetOp), uint16(XOR),
-	/*8543*/ uint16(xReadSlashR),
-	/*8544*/ uint16(xArgRM32),
-	/*8545*/ uint16(xArgR32),
-	/*8546*/ uint16(xMatch),
-	/*8547*/ uint16(xCondDataSize), 8535, 8541, 8551,
-	/*8551*/ uint16(xSetOp), uint16(XOR),
-	/*8553*/ uint16(xReadSlashR),
-	/*8554*/ uint16(xArgRM64),
-	/*8555*/ uint16(xArgR64),
-	/*8556*/ uint16(xMatch),
-	/*8557*/ uint16(xSetOp), uint16(XOR),
-	/*8559*/ uint16(xReadSlashR),
-	/*8560*/ uint16(xArgR8),
-	/*8561*/ uint16(xArgRM8),
-	/*8562*/ uint16(xMatch),
-	/*8563*/ uint16(xCondIs64), 8566, 8582,
-	/*8566*/ uint16(xCondDataSize), 8570, 8576, 0,
-	/*8570*/ uint16(xSetOp), uint16(XOR),
-	/*8572*/ uint16(xReadSlashR),
-	/*8573*/ uint16(xArgR16),
-	/*8574*/ uint16(xArgRM16),
-	/*8575*/ uint16(xMatch),
-	/*8576*/ uint16(xSetOp), uint16(XOR),
-	/*8578*/ uint16(xReadSlashR),
-	/*8579*/ uint16(xArgR32),
-	/*8580*/ uint16(xArgRM32),
-	/*8581*/ uint16(xMatch),
-	/*8582*/ uint16(xCondDataSize), 8570, 8576, 8586,
-	/*8586*/ uint16(xSetOp), uint16(XOR),
-	/*8588*/ uint16(xReadSlashR),
-	/*8589*/ uint16(xArgR64),
-	/*8590*/ uint16(xArgRM64),
-	/*8591*/ uint16(xMatch),
-	/*8592*/ uint16(xSetOp), uint16(XOR),
-	/*8594*/ uint16(xReadIb),
-	/*8595*/ uint16(xArgAL),
-	/*8596*/ uint16(xArgImm8u),
-	/*8597*/ uint16(xMatch),
-	/*8598*/ uint16(xCondIs64), 8601, 8617,
-	/*8601*/ uint16(xCondDataSize), 8605, 8611, 0,
-	/*8605*/ uint16(xSetOp), uint16(XOR),
-	/*8607*/ uint16(xReadIw),
-	/*8608*/ uint16(xArgAX),
-	/*8609*/ uint16(xArgImm16),
-	/*8610*/ uint16(xMatch),
-	/*8611*/ uint16(xSetOp), uint16(XOR),
-	/*8613*/ uint16(xReadId),
-	/*8614*/ uint16(xArgEAX),
-	/*8615*/ uint16(xArgImm32),
-	/*8616*/ uint16(xMatch),
-	/*8617*/ uint16(xCondDataSize), 8605, 8611, 8621,
-	/*8621*/ uint16(xSetOp), uint16(XOR),
-	/*8623*/ uint16(xReadId),
-	/*8624*/ uint16(xArgRAX),
-	/*8625*/ uint16(xArgImm32),
-	/*8626*/ uint16(xMatch),
-	/*8627*/ uint16(xCondIs64), 8630, 0,
-	/*8630*/ uint16(xSetOp), uint16(AAA),
-	/*8632*/ uint16(xMatch),
-	/*8633*/ uint16(xSetOp), uint16(CMP),
-	/*8635*/ uint16(xReadSlashR),
-	/*8636*/ uint16(xArgRM8),
-	/*8637*/ uint16(xArgR8),
-	/*8638*/ uint16(xMatch),
-	/*8639*/ uint16(xCondIs64), 8642, 8658,
-	/*8642*/ uint16(xCondDataSize), 8646, 8652, 0,
-	/*8646*/ uint16(xSetOp), uint16(CMP),
-	/*8648*/ uint16(xReadSlashR),
-	/*8649*/ uint16(xArgRM16),
-	/*8650*/ uint16(xArgR16),
-	/*8651*/ uint16(xMatch),
-	/*8652*/ uint16(xSetOp), uint16(CMP),
-	/*8654*/ uint16(xReadSlashR),
-	/*8655*/ uint16(xArgRM32),
-	/*8656*/ uint16(xArgR32),
-	/*8657*/ uint16(xMatch),
-	/*8658*/ uint16(xCondDataSize), 8646, 8652, 8662,
-	/*8662*/ uint16(xSetOp), uint16(CMP),
-	/*8664*/ uint16(xReadSlashR),
-	/*8665*/ uint16(xArgRM64),
-	/*8666*/ uint16(xArgR64),
-	/*8667*/ uint16(xMatch),
-	/*8668*/ uint16(xSetOp), uint16(CMP),
-	/*8670*/ uint16(xReadSlashR),
-	/*8671*/ uint16(xArgR8),
-	/*8672*/ uint16(xArgRM8),
-	/*8673*/ uint16(xMatch),
-	/*8674*/ uint16(xCondIs64), 8677, 8693,
-	/*8677*/ uint16(xCondDataSize), 8681, 8687, 0,
-	/*8681*/ uint16(xSetOp), uint16(CMP),
-	/*8683*/ uint16(xReadSlashR),
-	/*8684*/ uint16(xArgR16),
-	/*8685*/ uint16(xArgRM16),
-	/*8686*/ uint16(xMatch),
-	/*8687*/ uint16(xSetOp), uint16(CMP),
-	/*8689*/ uint16(xReadSlashR),
-	/*8690*/ uint16(xArgR32),
-	/*8691*/ uint16(xArgRM32),
-	/*8692*/ uint16(xMatch),
-	/*8693*/ uint16(xCondDataSize), 8681, 8687, 8697,
-	/*8697*/ uint16(xSetOp), uint16(CMP),
-	/*8699*/ uint16(xReadSlashR),
-	/*8700*/ uint16(xArgR64),
-	/*8701*/ uint16(xArgRM64),
-	/*8702*/ uint16(xMatch),
-	/*8703*/ uint16(xSetOp), uint16(CMP),
-	/*8705*/ uint16(xReadIb),
-	/*8706*/ uint16(xArgAL),
-	/*8707*/ uint16(xArgImm8u),
-	/*8708*/ uint16(xMatch),
-	/*8709*/ uint16(xCondIs64), 8712, 8728,
-	/*8712*/ uint16(xCondDataSize), 8716, 8722, 0,
-	/*8716*/ uint16(xSetOp), uint16(CMP),
-	/*8718*/ uint16(xReadIw),
-	/*8719*/ uint16(xArgAX),
-	/*8720*/ uint16(xArgImm16),
-	/*8721*/ uint16(xMatch),
-	/*8722*/ uint16(xSetOp), uint16(CMP),
-	/*8724*/ uint16(xReadId),
-	/*8725*/ uint16(xArgEAX),
-	/*8726*/ uint16(xArgImm32),
-	/*8727*/ uint16(xMatch),
-	/*8728*/ uint16(xCondDataSize), 8716, 8722, 8732,
-	/*8732*/ uint16(xSetOp), uint16(CMP),
-	/*8734*/ uint16(xReadId),
-	/*8735*/ uint16(xArgRAX),
-	/*8736*/ uint16(xArgImm32),
-	/*8737*/ uint16(xMatch),
-	/*8738*/ uint16(xCondIs64), 8741, 0,
-	/*8741*/ uint16(xSetOp), uint16(AAS),
-	/*8743*/ uint16(xMatch),
-	/*8744*/ uint16(xCondIs64), 8747, 0,
-	/*8747*/ uint16(xCondDataSize), 8751, 8755, 0,
-	/*8751*/ uint16(xSetOp), uint16(INC),
-	/*8753*/ uint16(xArgR16op),
-	/*8754*/ uint16(xMatch),
-	/*8755*/ uint16(xSetOp), uint16(INC),
-	/*8757*/ uint16(xArgR32op),
-	/*8758*/ uint16(xMatch),
-	/*8759*/ uint16(xCondIs64), 8762, 0,
-	/*8762*/ uint16(xCondDataSize), 8766, 8770, 0,
-	/*8766*/ uint16(xSetOp), uint16(DEC),
-	/*8768*/ uint16(xArgR16op),
-	/*8769*/ uint16(xMatch),
-	/*8770*/ uint16(xSetOp), uint16(DEC),
-	/*8772*/ uint16(xArgR32op),
-	/*8773*/ uint16(xMatch),
-	/*8774*/ uint16(xCondIs64), 8777, 8789,
-	/*8777*/ uint16(xCondDataSize), 8781, 8785, 0,
-	/*8781*/ uint16(xSetOp), uint16(PUSH),
-	/*8783*/ uint16(xArgR16op),
-	/*8784*/ uint16(xMatch),
-	/*8785*/ uint16(xSetOp), uint16(PUSH),
-	/*8787*/ uint16(xArgR32op),
-	/*8788*/ uint16(xMatch),
-	/*8789*/ uint16(xCondDataSize), 8781, 8793, 8797,
-	/*8793*/ uint16(xSetOp), uint16(PUSH),
-	/*8795*/ uint16(xArgR64op),
-	/*8796*/ uint16(xMatch),
-	/*8797*/ uint16(xSetOp), uint16(PUSH),
-	/*8799*/ uint16(xArgR64op),
-	/*8800*/ uint16(xMatch),
-	/*8801*/ uint16(xCondIs64), 8804, 8816,
-	/*8804*/ uint16(xCondDataSize), 8808, 8812, 0,
-	/*8808*/ uint16(xSetOp), uint16(POP),
-	/*8810*/ uint16(xArgR16op),
-	/*8811*/ uint16(xMatch),
-	/*8812*/ uint16(xSetOp), uint16(POP),
-	/*8814*/ uint16(xArgR32op),
-	/*8815*/ uint16(xMatch),
-	/*8816*/ uint16(xCondDataSize), 8808, 8820, 8824,
-	/*8820*/ uint16(xSetOp), uint16(POP),
-	/*8822*/ uint16(xArgR64op),
-	/*8823*/ uint16(xMatch),
-	/*8824*/ uint16(xSetOp), uint16(POP),
-	/*8826*/ uint16(xArgR64op),
-	/*8827*/ uint16(xMatch),
-	/*8828*/ uint16(xCondIs64), 8831, 0,
-	/*8831*/ uint16(xCondDataSize), 8835, 8838, 0,
-	/*8835*/ uint16(xSetOp), uint16(PUSHA),
-	/*8837*/ uint16(xMatch),
-	/*8838*/ uint16(xSetOp), uint16(PUSHAD),
-	/*8840*/ uint16(xMatch),
-	/*8841*/ uint16(xCondIs64), 8844, 0,
-	/*8844*/ uint16(xCondDataSize), 8848, 8851, 0,
-	/*8848*/ uint16(xSetOp), uint16(POPA),
-	/*8850*/ uint16(xMatch),
-	/*8851*/ uint16(xSetOp), uint16(POPAD),
-	/*8853*/ uint16(xMatch),
-	/*8854*/ uint16(xCondIs64), 8857, 0,
-	/*8857*/ uint16(xCondDataSize), 8861, 8867, 0,
-	/*8861*/ uint16(xSetOp), uint16(BOUND),
-	/*8863*/ uint16(xReadSlashR),
-	/*8864*/ uint16(xArgR16),
-	/*8865*/ uint16(xArgM16and16),
-	/*8866*/ uint16(xMatch),
-	/*8867*/ uint16(xSetOp), uint16(BOUND),
-	/*8869*/ uint16(xReadSlashR),
-	/*8870*/ uint16(xArgR32),
-	/*8871*/ uint16(xArgM32and32),
-	/*8872*/ uint16(xMatch),
-	/*8873*/ uint16(xCondIs64), 8876, 8882,
-	/*8876*/ uint16(xSetOp), uint16(ARPL),
-	/*8878*/ uint16(xReadSlashR),
-	/*8879*/ uint16(xArgRM16),
-	/*8880*/ uint16(xArgR16),
-	/*8881*/ uint16(xMatch),
-	/*8882*/ uint16(xCondDataSize), 8886, 8892, 8898,
-	/*8886*/ uint16(xSetOp), uint16(MOVSXD),
-	/*8888*/ uint16(xReadSlashR),
-	/*8889*/ uint16(xArgR16),
-	/*8890*/ uint16(xArgRM32),
-	/*8891*/ uint16(xMatch),
-	/*8892*/ uint16(xSetOp), uint16(MOVSXD),
-	/*8894*/ uint16(xReadSlashR),
-	/*8895*/ uint16(xArgR32),
-	/*8896*/ uint16(xArgRM32),
-	/*8897*/ uint16(xMatch),
-	/*8898*/ uint16(xSetOp), uint16(MOVSXD),
-	/*8900*/ uint16(xReadSlashR),
-	/*8901*/ uint16(xArgR64),
-	/*8902*/ uint16(xArgRM32),
-	/*8903*/ uint16(xMatch),
-	/*8904*/ uint16(xCondDataSize), 8908, 8913, 8918,
-	/*8908*/ uint16(xSetOp), uint16(PUSH),
-	/*8910*/ uint16(xReadIw),
-	/*8911*/ uint16(xArgImm16),
-	/*8912*/ uint16(xMatch),
-	/*8913*/ uint16(xSetOp), uint16(PUSH),
-	/*8915*/ uint16(xReadId),
-	/*8916*/ uint16(xArgImm32),
-	/*8917*/ uint16(xMatch),
-	/*8918*/ uint16(xSetOp), uint16(PUSH),
-	/*8920*/ uint16(xReadId),
-	/*8921*/ uint16(xArgImm32),
-	/*8922*/ uint16(xMatch),
-	/*8923*/ uint16(xCondIs64), 8926, 8946,
-	/*8926*/ uint16(xCondDataSize), 8930, 8938, 0,
-	/*8930*/ uint16(xSetOp), uint16(IMUL),
-	/*8932*/ uint16(xReadSlashR),
-	/*8933*/ uint16(xReadIw),
-	/*8934*/ uint16(xArgR16),
-	/*8935*/ uint16(xArgRM16),
-	/*8936*/ uint16(xArgImm16),
-	/*8937*/ uint16(xMatch),
-	/*8938*/ uint16(xSetOp), uint16(IMUL),
-	/*8940*/ uint16(xReadSlashR),
-	/*8941*/ uint16(xReadId),
-	/*8942*/ uint16(xArgR32),
-	/*8943*/ uint16(xArgRM32),
-	/*8944*/ uint16(xArgImm32),
-	/*8945*/ uint16(xMatch),
-	/*8946*/ uint16(xCondDataSize), 8930, 8938, 8950,
-	/*8950*/ uint16(xSetOp), uint16(IMUL),
-	/*8952*/ uint16(xReadSlashR),
-	/*8953*/ uint16(xReadId),
-	/*8954*/ uint16(xArgR64),
-	/*8955*/ uint16(xArgRM64),
-	/*8956*/ uint16(xArgImm32),
-	/*8957*/ uint16(xMatch),
-	/*8958*/ uint16(xSetOp), uint16(PUSH),
-	/*8960*/ uint16(xReadIb),
-	/*8961*/ uint16(xArgImm8),
-	/*8962*/ uint16(xMatch),
-	/*8963*/ uint16(xCondIs64), 8966, 8986,
-	/*8966*/ uint16(xCondDataSize), 8970, 8978, 0,
-	/*8970*/ uint16(xSetOp), uint16(IMUL),
-	/*8972*/ uint16(xReadSlashR),
-	/*8973*/ uint16(xReadIb),
-	/*8974*/ uint16(xArgR16),
-	/*8975*/ uint16(xArgRM16),
-	/*8976*/ uint16(xArgImm8),
-	/*8977*/ uint16(xMatch),
-	/*8978*/ uint16(xSetOp), uint16(IMUL),
-	/*8980*/ uint16(xReadSlashR),
-	/*8981*/ uint16(xReadIb),
-	/*8982*/ uint16(xArgR32),
-	/*8983*/ uint16(xArgRM32),
-	/*8984*/ uint16(xArgImm8),
-	/*8985*/ uint16(xMatch),
-	/*8986*/ uint16(xCondDataSize), 8970, 8978, 8990,
-	/*8990*/ uint16(xSetOp), uint16(IMUL),
-	/*8992*/ uint16(xReadSlashR),
-	/*8993*/ uint16(xReadIb),
-	/*8994*/ uint16(xArgR64),
-	/*8995*/ uint16(xArgRM64),
-	/*8996*/ uint16(xArgImm8),
-	/*8997*/ uint16(xMatch),
-	/*8998*/ uint16(xSetOp), uint16(INSB),
-	/*9000*/ uint16(xMatch),
-	/*9001*/ uint16(xCondDataSize), 9005, 9008, 9011,
-	/*9005*/ uint16(xSetOp), uint16(INSW),
-	/*9007*/ uint16(xMatch),
-	/*9008*/ uint16(xSetOp), uint16(INSD),
-	/*9010*/ uint16(xMatch),
-	/*9011*/ uint16(xSetOp), uint16(INSD),
-	/*9013*/ uint16(xMatch),
-	/*9014*/ uint16(xSetOp), uint16(OUTSB),
-	/*9016*/ uint16(xMatch),
-	/*9017*/ uint16(xCondPrefix), 3,
-	0xC5, 9064,
-	0xC4, 9038,
-	0x0, 9025,
-	/*9025*/ uint16(xCondDataSize), 9029, 9032, 9035,
-	/*9029*/ uint16(xSetOp), uint16(OUTSW),
-	/*9031*/ uint16(xMatch),
-	/*9032*/ uint16(xSetOp), uint16(OUTSD),
-	/*9034*/ uint16(xMatch),
-	/*9035*/ uint16(xSetOp), uint16(OUTSD),
-	/*9037*/ uint16(xMatch),
-	/*9038*/ uint16(xCondPrefix), 2,
-	0xF3, 9054,
-	0x66, 9044,
-	/*9044*/ uint16(xCondPrefix), 1,
-	0x0F, 9048,
-	/*9048*/ uint16(xSetOp), uint16(VMOVDQA),
-	/*9050*/ uint16(xReadSlashR),
-	/*9051*/ uint16(xArgYmm1),
-	/*9052*/ uint16(xArgYmm2M256),
-	/*9053*/ uint16(xMatch),
-	/*9054*/ uint16(xCondPrefix), 1,
-	0x0F, 9058,
-	/*9058*/ uint16(xSetOp), uint16(VMOVDQU),
-	/*9060*/ uint16(xReadSlashR),
-	/*9061*/ uint16(xArgYmm1),
-	/*9062*/ uint16(xArgYmm2M256),
-	/*9063*/ uint16(xMatch),
-	/*9064*/ uint16(xCondPrefix), 2,
-	0xF3, 9080,
-	0x66, 9070,
-	/*9070*/ uint16(xCondPrefix), 1,
-	0x0F, 9074,
-	/*9074*/ uint16(xSetOp), uint16(VMOVDQA),
-	/*9076*/ uint16(xReadSlashR),
-	/*9077*/ uint16(xArgYmm1),
-	/*9078*/ uint16(xArgYmm2M256),
-	/*9079*/ uint16(xMatch),
-	/*9080*/ uint16(xCondPrefix), 1,
-	0x0F, 9084,
-	/*9084*/ uint16(xSetOp), uint16(VMOVDQU),
-	/*9086*/ uint16(xReadSlashR),
-	/*9087*/ uint16(xArgYmm1),
-	/*9088*/ uint16(xArgYmm2M256),
-	/*9089*/ uint16(xMatch),
-	/*9090*/ uint16(xSetOp), uint16(JO),
-	/*9092*/ uint16(xReadCb),
-	/*9093*/ uint16(xArgRel8),
-	/*9094*/ uint16(xMatch),
-	/*9095*/ uint16(xSetOp), uint16(JNO),
-	/*9097*/ uint16(xReadCb),
-	/*9098*/ uint16(xArgRel8),
-	/*9099*/ uint16(xMatch),
-	/*9100*/ uint16(xSetOp), uint16(JB),
-	/*9102*/ uint16(xReadCb),
-	/*9103*/ uint16(xArgRel8),
-	/*9104*/ uint16(xMatch),
-	/*9105*/ uint16(xSetOp), uint16(JAE),
-	/*9107*/ uint16(xReadCb),
-	/*9108*/ uint16(xArgRel8),
-	/*9109*/ uint16(xMatch),
-	/*9110*/ uint16(xSetOp), uint16(JE),
-	/*9112*/ uint16(xReadCb),
-	/*9113*/ uint16(xArgRel8),
-	/*9114*/ uint16(xMatch),
-	/*9115*/ uint16(xSetOp), uint16(JNE),
-	/*9117*/ uint16(xReadCb),
-	/*9118*/ uint16(xArgRel8),
-	/*9119*/ uint16(xMatch),
-	/*9120*/ uint16(xSetOp), uint16(JBE),
-	/*9122*/ uint16(xReadCb),
-	/*9123*/ uint16(xArgRel8),
-	/*9124*/ uint16(xMatch),
-	/*9125*/ uint16(xCondPrefix), 3,
-	0xC5, 9145,
-	0xC4, 9138,
-	0x0, 9133,
-	/*9133*/ uint16(xSetOp), uint16(JA),
-	/*9135*/ uint16(xReadCb),
-	/*9136*/ uint16(xArgRel8),
-	/*9137*/ uint16(xMatch),
-	/*9138*/ uint16(xCondPrefix), 1,
-	0x0F, 9142,
-	/*9142*/ uint16(xSetOp), uint16(VZEROUPPER),
-	/*9144*/ uint16(xMatch),
-	/*9145*/ uint16(xCondPrefix), 1,
-	0x0F, 9149,
-	/*9149*/ uint16(xSetOp), uint16(VZEROUPPER),
-	/*9151*/ uint16(xMatch),
-	/*9152*/ uint16(xSetOp), uint16(JS),
-	/*9154*/ uint16(xReadCb),
-	/*9155*/ uint16(xArgRel8),
-	/*9156*/ uint16(xMatch),
-	/*9157*/ uint16(xSetOp), uint16(JNS),
-	/*9159*/ uint16(xReadCb),
-	/*9160*/ uint16(xArgRel8),
-	/*9161*/ uint16(xMatch),
-	/*9162*/ uint16(xSetOp), uint16(JP),
-	/*9164*/ uint16(xReadCb),
-	/*9165*/ uint16(xArgRel8),
-	/*9166*/ uint16(xMatch),
-	/*9167*/ uint16(xSetOp), uint16(JNP),
-	/*9169*/ uint16(xReadCb),
-	/*9170*/ uint16(xArgRel8),
-	/*9171*/ uint16(xMatch),
-	/*9172*/ uint16(xSetOp), uint16(JL),
-	/*9174*/ uint16(xReadCb),
-	/*9175*/ uint16(xArgRel8),
-	/*9176*/ uint16(xMatch),
-	/*9177*/ uint16(xSetOp), uint16(JGE),
-	/*9179*/ uint16(xReadCb),
-	/*9180*/ uint16(xArgRel8),
-	/*9181*/ uint16(xMatch),
-	/*9182*/ uint16(xSetOp), uint16(JLE),
-	/*9184*/ uint16(xReadCb),
-	/*9185*/ uint16(xArgRel8),
-	/*9186*/ uint16(xMatch),
-	/*9187*/ uint16(xCondPrefix), 3,
-	0xC5, 9226,
-	0xC4, 9200,
-	0x0, 9195,
-	/*9195*/ uint16(xSetOp), uint16(JG),
-	/*9197*/ uint16(xReadCb),
-	/*9198*/ uint16(xArgRel8),
-	/*9199*/ uint16(xMatch),
-	/*9200*/ uint16(xCondPrefix), 2,
-	0xF3, 9216,
-	0x66, 9206,
-	/*9206*/ uint16(xCondPrefix), 1,
-	0x0F, 9210,
-	/*9210*/ uint16(xSetOp), uint16(VMOVDQA),
-	/*9212*/ uint16(xReadSlashR),
-	/*9213*/ uint16(xArgYmm2M256),
-	/*9214*/ uint16(xArgYmm1),
-	/*9215*/ uint16(xMatch),
-	/*9216*/ uint16(xCondPrefix), 1,
-	0x0F, 9220,
-	/*9220*/ uint16(xSetOp), uint16(VMOVDQU),
-	/*9222*/ uint16(xReadSlashR),
-	/*9223*/ uint16(xArgYmm2M256),
-	/*9224*/ uint16(xArgYmm1),
-	/*9225*/ uint16(xMatch),
-	/*9226*/ uint16(xCondPrefix), 2,
-	0xF3, 9242,
-	0x66, 9232,
-	/*9232*/ uint16(xCondPrefix), 1,
-	0x0F, 9236,
-	/*9236*/ uint16(xSetOp), uint16(VMOVDQA),
-	/*9238*/ uint16(xReadSlashR),
-	/*9239*/ uint16(xArgYmm2M256),
-	/*9240*/ uint16(xArgYmm1),
-	/*9241*/ uint16(xMatch),
-	/*9242*/ uint16(xCondPrefix), 1,
-	0x0F, 9246,
-	/*9246*/ uint16(xSetOp), uint16(VMOVDQU),
-	/*9248*/ uint16(xReadSlashR),
-	/*9249*/ uint16(xArgYmm2M256),
-	/*9250*/ uint16(xArgYmm1),
-	/*9251*/ uint16(xMatch),
-	/*9252*/ uint16(xCondSlashR),
-	9261, // 0
-	9267, // 1
-	9273, // 2
-	9279, // 3
-	9285, // 4
-	9291, // 5
-	9297, // 6
-	9303, // 7
-	/*9261*/ uint16(xSetOp), uint16(ADD),
-	/*9263*/ uint16(xReadIb),
-	/*9264*/ uint16(xArgRM8),
-	/*9265*/ uint16(xArgImm8u),
-	/*9266*/ uint16(xMatch),
-	/*9267*/ uint16(xSetOp), uint16(OR),
-	/*9269*/ uint16(xReadIb),
-	/*9270*/ uint16(xArgRM8),
-	/*9271*/ uint16(xArgImm8u),
-	/*9272*/ uint16(xMatch),
-	/*9273*/ uint16(xSetOp), uint16(ADC),
-	/*9275*/ uint16(xReadIb),
-	/*9276*/ uint16(xArgRM8),
-	/*9277*/ uint16(xArgImm8u),
-	/*9278*/ uint16(xMatch),
-	/*9279*/ uint16(xSetOp), uint16(SBB),
-	/*9281*/ uint16(xReadIb),
-	/*9282*/ uint16(xArgRM8),
-	/*9283*/ uint16(xArgImm8u),
-	/*9284*/ uint16(xMatch),
-	/*9285*/ uint16(xSetOp), uint16(AND),
-	/*9287*/ uint16(xReadIb),
-	/*9288*/ uint16(xArgRM8),
-	/*9289*/ uint16(xArgImm8u),
-	/*9290*/ uint16(xMatch),
-	/*9291*/ uint16(xSetOp), uint16(SUB),
-	/*9293*/ uint16(xReadIb),
-	/*9294*/ uint16(xArgRM8),
-	/*9295*/ uint16(xArgImm8u),
-	/*9296*/ uint16(xMatch),
-	/*9297*/ uint16(xSetOp), uint16(XOR),
-	/*9299*/ uint16(xReadIb),
-	/*9300*/ uint16(xArgRM8),
-	/*9301*/ uint16(xArgImm8u),
-	/*9302*/ uint16(xMatch),
-	/*9303*/ uint16(xSetOp), uint16(CMP),
-	/*9305*/ uint16(xReadIb),
-	/*9306*/ uint16(xArgRM8),
-	/*9307*/ uint16(xArgImm8u),
-	/*9308*/ uint16(xMatch),
-	/*9309*/ uint16(xCondSlashR),
-	9318, // 0
-	9347, // 1
-	9376, // 2
-	9405, // 3
-	9434, // 4
-	9463, // 5
-	9492, // 6
-	9521, // 7
-	/*9318*/ uint16(xCondIs64), 9321, 9337,
-	/*9321*/ uint16(xCondDataSize), 9325, 9331, 0,
-	/*9325*/ uint16(xSetOp), uint16(ADD),
-	/*9327*/ uint16(xReadIw),
-	/*9328*/ uint16(xArgRM16),
-	/*9329*/ uint16(xArgImm16),
-	/*9330*/ uint16(xMatch),
-	/*9331*/ uint16(xSetOp), uint16(ADD),
-	/*9333*/ uint16(xReadId),
-	/*9334*/ uint16(xArgRM32),
-	/*9335*/ uint16(xArgImm32),
-	/*9336*/ uint16(xMatch),
-	/*9337*/ uint16(xCondDataSize), 9325, 9331, 9341,
-	/*9341*/ uint16(xSetOp), uint16(ADD),
-	/*9343*/ uint16(xReadId),
-	/*9344*/ uint16(xArgRM64),
-	/*9345*/ uint16(xArgImm32),
-	/*9346*/ uint16(xMatch),
-	/*9347*/ uint16(xCondIs64), 9350, 9366,
-	/*9350*/ uint16(xCondDataSize), 9354, 9360, 0,
-	/*9354*/ uint16(xSetOp), uint16(OR),
-	/*9356*/ uint16(xReadIw),
-	/*9357*/ uint16(xArgRM16),
-	/*9358*/ uint16(xArgImm16),
-	/*9359*/ uint16(xMatch),
-	/*9360*/ uint16(xSetOp), uint16(OR),
-	/*9362*/ uint16(xReadId),
-	/*9363*/ uint16(xArgRM32),
-	/*9364*/ uint16(xArgImm32),
-	/*9365*/ uint16(xMatch),
-	/*9366*/ uint16(xCondDataSize), 9354, 9360, 9370,
-	/*9370*/ uint16(xSetOp), uint16(OR),
-	/*9372*/ uint16(xReadId),
-	/*9373*/ uint16(xArgRM64),
-	/*9374*/ uint16(xArgImm32),
-	/*9375*/ uint16(xMatch),
-	/*9376*/ uint16(xCondIs64), 9379, 9395,
-	/*9379*/ uint16(xCondDataSize), 9383, 9389, 0,
-	/*9383*/ uint16(xSetOp), uint16(ADC),
-	/*9385*/ uint16(xReadIw),
-	/*9386*/ uint16(xArgRM16),
-	/*9387*/ uint16(xArgImm16),
-	/*9388*/ uint16(xMatch),
-	/*9389*/ uint16(xSetOp), uint16(ADC),
-	/*9391*/ uint16(xReadId),
-	/*9392*/ uint16(xArgRM32),
-	/*9393*/ uint16(xArgImm32),
-	/*9394*/ uint16(xMatch),
-	/*9395*/ uint16(xCondDataSize), 9383, 9389, 9399,
-	/*9399*/ uint16(xSetOp), uint16(ADC),
-	/*9401*/ uint16(xReadId),
-	/*9402*/ uint16(xArgRM64),
-	/*9403*/ uint16(xArgImm32),
-	/*9404*/ uint16(xMatch),
-	/*9405*/ uint16(xCondIs64), 9408, 9424,
-	/*9408*/ uint16(xCondDataSize), 9412, 9418, 0,
-	/*9412*/ uint16(xSetOp), uint16(SBB),
-	/*9414*/ uint16(xReadIw),
-	/*9415*/ uint16(xArgRM16),
-	/*9416*/ uint16(xArgImm16),
-	/*9417*/ uint16(xMatch),
-	/*9418*/ uint16(xSetOp), uint16(SBB),
-	/*9420*/ uint16(xReadId),
-	/*9421*/ uint16(xArgRM32),
-	/*9422*/ uint16(xArgImm32),
-	/*9423*/ uint16(xMatch),
-	/*9424*/ uint16(xCondDataSize), 9412, 9418, 9428,
-	/*9428*/ uint16(xSetOp), uint16(SBB),
-	/*9430*/ uint16(xReadId),
-	/*9431*/ uint16(xArgRM64),
-	/*9432*/ uint16(xArgImm32),
-	/*9433*/ uint16(xMatch),
-	/*9434*/ uint16(xCondIs64), 9437, 9453,
-	/*9437*/ uint16(xCondDataSize), 9441, 9447, 0,
-	/*9441*/ uint16(xSetOp), uint16(AND),
-	/*9443*/ uint16(xReadIw),
-	/*9444*/ uint16(xArgRM16),
-	/*9445*/ uint16(xArgImm16),
-	/*9446*/ uint16(xMatch),
-	/*9447*/ uint16(xSetOp), uint16(AND),
-	/*9449*/ uint16(xReadId),
-	/*9450*/ uint16(xArgRM32),
-	/*9451*/ uint16(xArgImm32),
-	/*9452*/ uint16(xMatch),
-	/*9453*/ uint16(xCondDataSize), 9441, 9447, 9457,
-	/*9457*/ uint16(xSetOp), uint16(AND),
-	/*9459*/ uint16(xReadId),
-	/*9460*/ uint16(xArgRM64),
-	/*9461*/ uint16(xArgImm32),
-	/*9462*/ uint16(xMatch),
-	/*9463*/ uint16(xCondIs64), 9466, 9482,
-	/*9466*/ uint16(xCondDataSize), 9470, 9476, 0,
-	/*9470*/ uint16(xSetOp), uint16(SUB),
-	/*9472*/ uint16(xReadIw),
-	/*9473*/ uint16(xArgRM16),
-	/*9474*/ uint16(xArgImm16),
-	/*9475*/ uint16(xMatch),
-	/*9476*/ uint16(xSetOp), uint16(SUB),
-	/*9478*/ uint16(xReadId),
-	/*9479*/ uint16(xArgRM32),
-	/*9480*/ uint16(xArgImm32),
-	/*9481*/ uint16(xMatch),
-	/*9482*/ uint16(xCondDataSize), 9470, 9476, 9486,
-	/*9486*/ uint16(xSetOp), uint16(SUB),
-	/*9488*/ uint16(xReadId),
-	/*9489*/ uint16(xArgRM64),
-	/*9490*/ uint16(xArgImm32),
-	/*9491*/ uint16(xMatch),
-	/*9492*/ uint16(xCondIs64), 9495, 9511,
-	/*9495*/ uint16(xCondDataSize), 9499, 9505, 0,
-	/*9499*/ uint16(xSetOp), uint16(XOR),
-	/*9501*/ uint16(xReadIw),
-	/*9502*/ uint16(xArgRM16),
-	/*9503*/ uint16(xArgImm16),
-	/*9504*/ uint16(xMatch),
-	/*9505*/ uint16(xSetOp), uint16(XOR),
-	/*9507*/ uint16(xReadId),
-	/*9508*/ uint16(xArgRM32),
-	/*9509*/ uint16(xArgImm32),
-	/*9510*/ uint16(xMatch),
-	/*9511*/ uint16(xCondDataSize), 9499, 9505, 9515,
-	/*9515*/ uint16(xSetOp), uint16(XOR),
-	/*9517*/ uint16(xReadId),
-	/*9518*/ uint16(xArgRM64),
-	/*9519*/ uint16(xArgImm32),
-	/*9520*/ uint16(xMatch),
-	/*9521*/ uint16(xCondIs64), 9524, 9540,
-	/*9524*/ uint16(xCondDataSize), 9528, 9534, 0,
-	/*9528*/ uint16(xSetOp), uint16(CMP),
-	/*9530*/ uint16(xReadIw),
-	/*9531*/ uint16(xArgRM16),
-	/*9532*/ uint16(xArgImm16),
-	/*9533*/ uint16(xMatch),
-	/*9534*/ uint16(xSetOp), uint16(CMP),
-	/*9536*/ uint16(xReadId),
-	/*9537*/ uint16(xArgRM32),
-	/*9538*/ uint16(xArgImm32),
-	/*9539*/ uint16(xMatch),
-	/*9540*/ uint16(xCondDataSize), 9528, 9534, 9544,
-	/*9544*/ uint16(xSetOp), uint16(CMP),
-	/*9546*/ uint16(xReadId),
-	/*9547*/ uint16(xArgRM64),
-	/*9548*/ uint16(xArgImm32),
-	/*9549*/ uint16(xMatch),
-	/*9550*/ uint16(xCondSlashR),
-	9559, // 0
-	9588, // 1
-	9617, // 2
-	9646, // 3
-	9675, // 4
-	9704, // 5
-	9733, // 6
-	9762, // 7
-	/*9559*/ uint16(xCondIs64), 9562, 9578,
-	/*9562*/ uint16(xCondDataSize), 9566, 9572, 0,
-	/*9566*/ uint16(xSetOp), uint16(ADD),
-	/*9568*/ uint16(xReadIb),
-	/*9569*/ uint16(xArgRM16),
-	/*9570*/ uint16(xArgImm8),
-	/*9571*/ uint16(xMatch),
-	/*9572*/ uint16(xSetOp), uint16(ADD),
-	/*9574*/ uint16(xReadIb),
-	/*9575*/ uint16(xArgRM32),
-	/*9576*/ uint16(xArgImm8),
-	/*9577*/ uint16(xMatch),
-	/*9578*/ uint16(xCondDataSize), 9566, 9572, 9582,
-	/*9582*/ uint16(xSetOp), uint16(ADD),
-	/*9584*/ uint16(xReadIb),
-	/*9585*/ uint16(xArgRM64),
-	/*9586*/ uint16(xArgImm8),
-	/*9587*/ uint16(xMatch),
-	/*9588*/ uint16(xCondIs64), 9591, 9607,
-	/*9591*/ uint16(xCondDataSize), 9595, 9601, 0,
-	/*9595*/ uint16(xSetOp), uint16(OR),
-	/*9597*/ uint16(xReadIb),
-	/*9598*/ uint16(xArgRM16),
-	/*9599*/ uint16(xArgImm8),
-	/*9600*/ uint16(xMatch),
-	/*9601*/ uint16(xSetOp), uint16(OR),
-	/*9603*/ uint16(xReadIb),
-	/*9604*/ uint16(xArgRM32),
-	/*9605*/ uint16(xArgImm8),
-	/*9606*/ uint16(xMatch),
-	/*9607*/ uint16(xCondDataSize), 9595, 9601, 9611,
-	/*9611*/ uint16(xSetOp), uint16(OR),
-	/*9613*/ uint16(xReadIb),
-	/*9614*/ uint16(xArgRM64),
-	/*9615*/ uint16(xArgImm8),
-	/*9616*/ uint16(xMatch),
-	/*9617*/ uint16(xCondIs64), 9620, 9636,
-	/*9620*/ uint16(xCondDataSize), 9624, 9630, 0,
-	/*9624*/ uint16(xSetOp), uint16(ADC),
-	/*9626*/ uint16(xReadIb),
-	/*9627*/ uint16(xArgRM16),
-	/*9628*/ uint16(xArgImm8),
-	/*9629*/ uint16(xMatch),
-	/*9630*/ uint16(xSetOp), uint16(ADC),
-	/*9632*/ uint16(xReadIb),
-	/*9633*/ uint16(xArgRM32),
-	/*9634*/ uint16(xArgImm8),
-	/*9635*/ uint16(xMatch),
-	/*9636*/ uint16(xCondDataSize), 9624, 9630, 9640,
-	/*9640*/ uint16(xSetOp), uint16(ADC),
-	/*9642*/ uint16(xReadIb),
-	/*9643*/ uint16(xArgRM64),
-	/*9644*/ uint16(xArgImm8),
-	/*9645*/ uint16(xMatch),
-	/*9646*/ uint16(xCondIs64), 9649, 9665,
-	/*9649*/ uint16(xCondDataSize), 9653, 9659, 0,
-	/*9653*/ uint16(xSetOp), uint16(SBB),
-	/*9655*/ uint16(xReadIb),
-	/*9656*/ uint16(xArgRM16),
-	/*9657*/ uint16(xArgImm8),
-	/*9658*/ uint16(xMatch),
-	/*9659*/ uint16(xSetOp), uint16(SBB),
-	/*9661*/ uint16(xReadIb),
-	/*9662*/ uint16(xArgRM32),
-	/*9663*/ uint16(xArgImm8),
-	/*9664*/ uint16(xMatch),
-	/*9665*/ uint16(xCondDataSize), 9653, 9659, 9669,
-	/*9669*/ uint16(xSetOp), uint16(SBB),
-	/*9671*/ uint16(xReadIb),
-	/*9672*/ uint16(xArgRM64),
-	/*9673*/ uint16(xArgImm8),
-	/*9674*/ uint16(xMatch),
-	/*9675*/ uint16(xCondIs64), 9678, 9694,
-	/*9678*/ uint16(xCondDataSize), 9682, 9688, 0,
-	/*9682*/ uint16(xSetOp), uint16(AND),
-	/*9684*/ uint16(xReadIb),
-	/*9685*/ uint16(xArgRM16),
-	/*9686*/ uint16(xArgImm8),
-	/*9687*/ uint16(xMatch),
-	/*9688*/ uint16(xSetOp), uint16(AND),
-	/*9690*/ uint16(xReadIb),
-	/*9691*/ uint16(xArgRM32),
-	/*9692*/ uint16(xArgImm8),
-	/*9693*/ uint16(xMatch),
-	/*9694*/ uint16(xCondDataSize), 9682, 9688, 9698,
-	/*9698*/ uint16(xSetOp), uint16(AND),
-	/*9700*/ uint16(xReadIb),
-	/*9701*/ uint16(xArgRM64),
-	/*9702*/ uint16(xArgImm8),
-	/*9703*/ uint16(xMatch),
-	/*9704*/ uint16(xCondIs64), 9707, 9723,
-	/*9707*/ uint16(xCondDataSize), 9711, 9717, 0,
-	/*9711*/ uint16(xSetOp), uint16(SUB),
-	/*9713*/ uint16(xReadIb),
-	/*9714*/ uint16(xArgRM16),
-	/*9715*/ uint16(xArgImm8),
-	/*9716*/ uint16(xMatch),
-	/*9717*/ uint16(xSetOp), uint16(SUB),
-	/*9719*/ uint16(xReadIb),
-	/*9720*/ uint16(xArgRM32),
-	/*9721*/ uint16(xArgImm8),
-	/*9722*/ uint16(xMatch),
-	/*9723*/ uint16(xCondDataSize), 9711, 9717, 9727,
-	/*9727*/ uint16(xSetOp), uint16(SUB),
-	/*9729*/ uint16(xReadIb),
-	/*9730*/ uint16(xArgRM64),
-	/*9731*/ uint16(xArgImm8),
-	/*9732*/ uint16(xMatch),
-	/*9733*/ uint16(xCondIs64), 9736, 9752,
-	/*9736*/ uint16(xCondDataSize), 9740, 9746, 0,
-	/*9740*/ uint16(xSetOp), uint16(XOR),
-	/*9742*/ uint16(xReadIb),
-	/*9743*/ uint16(xArgRM16),
-	/*9744*/ uint16(xArgImm8),
-	/*9745*/ uint16(xMatch),
-	/*9746*/ uint16(xSetOp), uint16(XOR),
-	/*9748*/ uint16(xReadIb),
-	/*9749*/ uint16(xArgRM32),
-	/*9750*/ uint16(xArgImm8),
-	/*9751*/ uint16(xMatch),
-	/*9752*/ uint16(xCondDataSize), 9740, 9746, 9756,
-	/*9756*/ uint16(xSetOp), uint16(XOR),
-	/*9758*/ uint16(xReadIb),
-	/*9759*/ uint16(xArgRM64),
-	/*9760*/ uint16(xArgImm8),
-	/*9761*/ uint16(xMatch),
-	/*9762*/ uint16(xCondIs64), 9765, 9781,
-	/*9765*/ uint16(xCondDataSize), 9769, 9775, 0,
-	/*9769*/ uint16(xSetOp), uint16(CMP),
-	/*9771*/ uint16(xReadIb),
-	/*9772*/ uint16(xArgRM16),
-	/*9773*/ uint16(xArgImm8),
-	/*9774*/ uint16(xMatch),
-	/*9775*/ uint16(xSetOp), uint16(CMP),
-	/*9777*/ uint16(xReadIb),
-	/*9778*/ uint16(xArgRM32),
-	/*9779*/ uint16(xArgImm8),
-	/*9780*/ uint16(xMatch),
-	/*9781*/ uint16(xCondDataSize), 9769, 9775, 9785,
-	/*9785*/ uint16(xSetOp), uint16(CMP),
-	/*9787*/ uint16(xReadIb),
-	/*9788*/ uint16(xArgRM64),
-	/*9789*/ uint16(xArgImm8),
-	/*9790*/ uint16(xMatch),
-	/*9791*/ uint16(xSetOp), uint16(TEST),
-	/*9793*/ uint16(xReadSlashR),
-	/*9794*/ uint16(xArgRM8),
-	/*9795*/ uint16(xArgR8),
-	/*9796*/ uint16(xMatch),
-	/*9797*/ uint16(xCondIs64), 9800, 9816,
-	/*9800*/ uint16(xCondDataSize), 9804, 9810, 0,
-	/*9804*/ uint16(xSetOp), uint16(TEST),
-	/*9806*/ uint16(xReadSlashR),
-	/*9807*/ uint16(xArgRM16),
-	/*9808*/ uint16(xArgR16),
-	/*9809*/ uint16(xMatch),
-	/*9810*/ uint16(xSetOp), uint16(TEST),
-	/*9812*/ uint16(xReadSlashR),
-	/*9813*/ uint16(xArgRM32),
-	/*9814*/ uint16(xArgR32),
-	/*9815*/ uint16(xMatch),
-	/*9816*/ uint16(xCondDataSize), 9804, 9810, 9820,
-	/*9820*/ uint16(xSetOp), uint16(TEST),
-	/*9822*/ uint16(xReadSlashR),
-	/*9823*/ uint16(xArgRM64),
-	/*9824*/ uint16(xArgR64),
-	/*9825*/ uint16(xMatch),
-	/*9826*/ uint16(xSetOp), uint16(XCHG),
-	/*9828*/ uint16(xReadSlashR),
-	/*9829*/ uint16(xArgRM8),
-	/*9830*/ uint16(xArgR8),
-	/*9831*/ uint16(xMatch),
-	/*9832*/ uint16(xCondIs64), 9835, 9851,
-	/*9835*/ uint16(xCondDataSize), 9839, 9845, 0,
-	/*9839*/ uint16(xSetOp), uint16(XCHG),
-	/*9841*/ uint16(xReadSlashR),
-	/*9842*/ uint16(xArgRM16),
-	/*9843*/ uint16(xArgR16),
-	/*9844*/ uint16(xMatch),
-	/*9845*/ uint16(xSetOp), uint16(XCHG),
-	/*9847*/ uint16(xReadSlashR),
-	/*9848*/ uint16(xArgRM32),
-	/*9849*/ uint16(xArgR32),
-	/*9850*/ uint16(xMatch),
-	/*9851*/ uint16(xCondDataSize), 9839, 9845, 9855,
-	/*9855*/ uint16(xSetOp), uint16(XCHG),
-	/*9857*/ uint16(xReadSlashR),
-	/*9858*/ uint16(xArgRM64),
-	/*9859*/ uint16(xArgR64),
-	/*9860*/ uint16(xMatch),
-	/*9861*/ uint16(xSetOp), uint16(MOV),
-	/*9863*/ uint16(xReadSlashR),
-	/*9864*/ uint16(xArgRM8),
-	/*9865*/ uint16(xArgR8),
-	/*9866*/ uint16(xMatch),
-	/*9867*/ uint16(xCondDataSize), 9871, 9877, 9883,
-	/*9871*/ uint16(xSetOp), uint16(MOV),
-	/*9873*/ uint16(xReadSlashR),
-	/*9874*/ uint16(xArgRM16),
-	/*9875*/ uint16(xArgR16),
-	/*9876*/ uint16(xMatch),
-	/*9877*/ uint16(xSetOp), uint16(MOV),
-	/*9879*/ uint16(xReadSlashR),
-	/*9880*/ uint16(xArgRM32),
-	/*9881*/ uint16(xArgR32),
-	/*9882*/ uint16(xMatch),
-	/*9883*/ uint16(xSetOp), uint16(MOV),
-	/*9885*/ uint16(xReadSlashR),
-	/*9886*/ uint16(xArgRM64),
-	/*9887*/ uint16(xArgR64),
-	/*9888*/ uint16(xMatch),
-	/*9889*/ uint16(xSetOp), uint16(MOV),
-	/*9891*/ uint16(xReadSlashR),
-	/*9892*/ uint16(xArgR8),
-	/*9893*/ uint16(xArgRM8),
-	/*9894*/ uint16(xMatch),
-	/*9895*/ uint16(xCondDataSize), 9899, 9905, 9911,
-	/*9899*/ uint16(xSetOp), uint16(MOV),
-	/*9901*/ uint16(xReadSlashR),
-	/*9902*/ uint16(xArgR16),
-	/*9903*/ uint16(xArgRM16),
-	/*9904*/ uint16(xMatch),
-	/*9905*/ uint16(xSetOp), uint16(MOV),
-	/*9907*/ uint16(xReadSlashR),
-	/*9908*/ uint16(xArgR32),
-	/*9909*/ uint16(xArgRM32),
-	/*9910*/ uint16(xMatch),
-	/*9911*/ uint16(xSetOp), uint16(MOV),
-	/*9913*/ uint16(xReadSlashR),
-	/*9914*/ uint16(xArgR64),
-	/*9915*/ uint16(xArgRM64),
-	/*9916*/ uint16(xMatch),
-	/*9917*/ uint16(xCondIs64), 9920, 9936,
-	/*9920*/ uint16(xCondDataSize), 9924, 9930, 0,
-	/*9924*/ uint16(xSetOp), uint16(MOV),
-	/*9926*/ uint16(xReadSlashR),
-	/*9927*/ uint16(xArgRM16),
-	/*9928*/ uint16(xArgSreg),
-	/*9929*/ uint16(xMatch),
-	/*9930*/ uint16(xSetOp), uint16(MOV),
-	/*9932*/ uint16(xReadSlashR),
-	/*9933*/ uint16(xArgR32M16),
-	/*9934*/ uint16(xArgSreg),
-	/*9935*/ uint16(xMatch),
-	/*9936*/ uint16(xCondDataSize), 9924, 9930, 9940,
-	/*9940*/ uint16(xSetOp), uint16(MOV),
-	/*9942*/ uint16(xReadSlashR),
-	/*9943*/ uint16(xArgR64M16),
-	/*9944*/ uint16(xArgSreg),
-	/*9945*/ uint16(xMatch),
-	/*9946*/ uint16(xCondIs64), 9949, 9965,
-	/*9949*/ uint16(xCondDataSize), 9953, 9959, 0,
-	/*9953*/ uint16(xSetOp), uint16(LEA),
-	/*9955*/ uint16(xReadSlashR),
-	/*9956*/ uint16(xArgR16),
-	/*9957*/ uint16(xArgM),
-	/*9958*/ uint16(xMatch),
-	/*9959*/ uint16(xSetOp), uint16(LEA),
-	/*9961*/ uint16(xReadSlashR),
-	/*9962*/ uint16(xArgR32),
-	/*9963*/ uint16(xArgM),
-	/*9964*/ uint16(xMatch),
-	/*9965*/ uint16(xCondDataSize), 9953, 9959, 9969,
-	/*9969*/ uint16(xSetOp), uint16(LEA),
-	/*9971*/ uint16(xReadSlashR),
-	/*9972*/ uint16(xArgR64),
-	/*9973*/ uint16(xArgM),
-	/*9974*/ uint16(xMatch),
-	/*9975*/ uint16(xCondIs64), 9978, 9994,
-	/*9978*/ uint16(xCondDataSize), 9982, 9988, 0,
-	/*9982*/ uint16(xSetOp), uint16(MOV),
-	/*9984*/ uint16(xReadSlashR),
-	/*9985*/ uint16(xArgSreg),
-	/*9986*/ uint16(xArgRM16),
-	/*9987*/ uint16(xMatch),
-	/*9988*/ uint16(xSetOp), uint16(MOV),
-	/*9990*/ uint16(xReadSlashR),
-	/*9991*/ uint16(xArgSreg),
-	/*9992*/ uint16(xArgR32M16),
-	/*9993*/ uint16(xMatch),
-	/*9994*/ uint16(xCondDataSize), 9982, 9988, 9998,
-	/*9998*/ uint16(xSetOp), uint16(MOV),
-	/*10000*/ uint16(xReadSlashR),
-	/*10001*/ uint16(xArgSreg),
-	/*10002*/ uint16(xArgR64M16),
-	/*10003*/ uint16(xMatch),
-	/*10004*/ uint16(xCondSlashR),
-	10013, // 0
-	0,     // 1
-	0,     // 2
-	0,     // 3
-	0,     // 4
-	0,     // 5
-	0,     // 6
-	0,     // 7
-	/*10013*/ uint16(xCondIs64), 10016, 10028,
-	/*10016*/ uint16(xCondDataSize), 10020, 10024, 0,
-	/*10020*/ uint16(xSetOp), uint16(POP),
-	/*10022*/ uint16(xArgRM16),
-	/*10023*/ uint16(xMatch),
-	/*10024*/ uint16(xSetOp), uint16(POP),
-	/*10026*/ uint16(xArgRM32),
-	/*10027*/ uint16(xMatch),
-	/*10028*/ uint16(xCondDataSize), 10020, 10032, 10036,
-	/*10032*/ uint16(xSetOp), uint16(POP),
-	/*10034*/ uint16(xArgRM64),
-	/*10035*/ uint16(xMatch),
-	/*10036*/ uint16(xSetOp), uint16(POP),
-	/*10038*/ uint16(xArgRM64),
-	/*10039*/ uint16(xMatch),
-	/*10040*/ uint16(xCondIs64), 10043, 10057,
-	/*10043*/ uint16(xCondDataSize), 10047, 10052, 0,
-	/*10047*/ uint16(xSetOp), uint16(XCHG),
-	/*10049*/ uint16(xArgR16op),
-	/*10050*/ uint16(xArgAX),
-	/*10051*/ uint16(xMatch),
-	/*10052*/ uint16(xSetOp), uint16(XCHG),
-	/*10054*/ uint16(xArgR32op),
-	/*10055*/ uint16(xArgEAX),
-	/*10056*/ uint16(xMatch),
-	/*10057*/ uint16(xCondDataSize), 10047, 10052, 10061,
-	/*10061*/ uint16(xSetOp), uint16(XCHG),
-	/*10063*/ uint16(xArgR64op),
-	/*10064*/ uint16(xArgRAX),
-	/*10065*/ uint16(xMatch),
-	/*10066*/ uint16(xCondIs64), 10069, 10079,
-	/*10069*/ uint16(xCondDataSize), 10073, 10076, 0,
-	/*10073*/ uint16(xSetOp), uint16(CBW),
-	/*10075*/ uint16(xMatch),
-	/*10076*/ uint16(xSetOp), uint16(CWDE),
-	/*10078*/ uint16(xMatch),
-	/*10079*/ uint16(xCondDataSize), 10073, 10076, 10083,
-	/*10083*/ uint16(xSetOp), uint16(CDQE),
-	/*10085*/ uint16(xMatch),
-	/*10086*/ uint16(xCondIs64), 10089, 10099,
-	/*10089*/ uint16(xCondDataSize), 10093, 10096, 0,
-	/*10093*/ uint16(xSetOp), uint16(CWD),
-	/*10095*/ uint16(xMatch),
-	/*10096*/ uint16(xSetOp), uint16(CDQ),
-	/*10098*/ uint16(xMatch),
-	/*10099*/ uint16(xCondDataSize), 10093, 10096, 10103,
-	/*10103*/ uint16(xSetOp), uint16(CQO),
-	/*10105*/ uint16(xMatch),
-	/*10106*/ uint16(xCondIs64), 10109, 0,
-	/*10109*/ uint16(xCondDataSize), 10113, 10118, 0,
-	/*10113*/ uint16(xSetOp), uint16(LCALL),
-	/*10115*/ uint16(xReadCd),
-	/*10116*/ uint16(xArgPtr16colon16),
-	/*10117*/ uint16(xMatch),
-	/*10118*/ uint16(xSetOp), uint16(LCALL),
-	/*10120*/ uint16(xReadCp),
-	/*10121*/ uint16(xArgPtr16colon32),
-	/*10122*/ uint16(xMatch),
-	/*10123*/ uint16(xSetOp), uint16(FWAIT),
-	/*10125*/ uint16(xMatch),
-	/*10126*/ uint16(xCondIs64), 10129, 10139,
-	/*10129*/ uint16(xCondDataSize), 10133, 10136, 0,
-	/*10133*/ uint16(xSetOp), uint16(PUSHF),
-	/*10135*/ uint16(xMatch),
-	/*10136*/ uint16(xSetOp), uint16(PUSHFD),
-	/*10138*/ uint16(xMatch),
-	/*10139*/ uint16(xCondDataSize), 10133, 10143, 10146,
-	/*10143*/ uint16(xSetOp), uint16(PUSHFQ),
-	/*10145*/ uint16(xMatch),
-	/*10146*/ uint16(xSetOp), uint16(PUSHFQ),
-	/*10148*/ uint16(xMatch),
-	/*10149*/ uint16(xCondIs64), 10152, 10162,
-	/*10152*/ uint16(xCondDataSize), 10156, 10159, 0,
-	/*10156*/ uint16(xSetOp), uint16(POPF),
-	/*10158*/ uint16(xMatch),
-	/*10159*/ uint16(xSetOp), uint16(POPFD),
-	/*10161*/ uint16(xMatch),
-	/*10162*/ uint16(xCondDataSize), 10156, 10166, 10169,
-	/*10166*/ uint16(xSetOp), uint16(POPFQ),
-	/*10168*/ uint16(xMatch),
-	/*10169*/ uint16(xSetOp), uint16(POPFQ),
-	/*10171*/ uint16(xMatch),
-	/*10172*/ uint16(xSetOp), uint16(SAHF),
-	/*10174*/ uint16(xMatch),
-	/*10175*/ uint16(xSetOp), uint16(LAHF),
-	/*10177*/ uint16(xMatch),
-	/*10178*/ uint16(xCondIs64), 10181, 10187,
-	/*10181*/ uint16(xSetOp), uint16(MOV),
-	/*10183*/ uint16(xReadCm),
-	/*10184*/ uint16(xArgAL),
-	/*10185*/ uint16(xArgMoffs8),
-	/*10186*/ uint16(xMatch),
-	/*10187*/ uint16(xCondDataSize), 10181, 10181, 10191,
-	/*10191*/ uint16(xSetOp), uint16(MOV),
-	/*10193*/ uint16(xReadCm),
-	/*10194*/ uint16(xArgAL),
-	/*10195*/ uint16(xArgMoffs8),
-	/*10196*/ uint16(xMatch),
-	/*10197*/ uint16(xCondDataSize), 10201, 10207, 10213,
-	/*10201*/ uint16(xSetOp), uint16(MOV),
-	/*10203*/ uint16(xReadCm),
-	/*10204*/ uint16(xArgAX),
-	/*10205*/ uint16(xArgMoffs16),
-	/*10206*/ uint16(xMatch),
-	/*10207*/ uint16(xSetOp), uint16(MOV),
-	/*10209*/ uint16(xReadCm),
-	/*10210*/ uint16(xArgEAX),
-	/*10211*/ uint16(xArgMoffs32),
-	/*10212*/ uint16(xMatch),
-	/*10213*/ uint16(xSetOp), uint16(MOV),
-	/*10215*/ uint16(xReadCm),
-	/*10216*/ uint16(xArgRAX),
-	/*10217*/ uint16(xArgMoffs64),
-	/*10218*/ uint16(xMatch),
-	/*10219*/ uint16(xCondIs64), 10222, 10228,
-	/*10222*/ uint16(xSetOp), uint16(MOV),
-	/*10224*/ uint16(xReadCm),
-	/*10225*/ uint16(xArgMoffs8),
-	/*10226*/ uint16(xArgAL),
-	/*10227*/ uint16(xMatch),
-	/*10228*/ uint16(xCondDataSize), 10222, 10222, 10232,
-	/*10232*/ uint16(xSetOp), uint16(MOV),
-	/*10234*/ uint16(xReadCm),
-	/*10235*/ uint16(xArgMoffs8),
-	/*10236*/ uint16(xArgAL),
-	/*10237*/ uint16(xMatch),
-	/*10238*/ uint16(xCondDataSize), 10242, 10248, 10254,
-	/*10242*/ uint16(xSetOp), uint16(MOV),
-	/*10244*/ uint16(xReadCm),
-	/*10245*/ uint16(xArgMoffs16),
-	/*10246*/ uint16(xArgAX),
-	/*10247*/ uint16(xMatch),
-	/*10248*/ uint16(xSetOp), uint16(MOV),
-	/*10250*/ uint16(xReadCm),
-	/*10251*/ uint16(xArgMoffs32),
-	/*10252*/ uint16(xArgEAX),
-	/*10253*/ uint16(xMatch),
-	/*10254*/ uint16(xSetOp), uint16(MOV),
-	/*10256*/ uint16(xReadCm),
-	/*10257*/ uint16(xArgMoffs64),
-	/*10258*/ uint16(xArgRAX),
-	/*10259*/ uint16(xMatch),
-	/*10260*/ uint16(xSetOp), uint16(MOVSB),
-	/*10262*/ uint16(xMatch),
-	/*10263*/ uint16(xCondIs64), 10266, 10276,
-	/*10266*/ uint16(xCondDataSize), 10270, 10273, 0,
-	/*10270*/ uint16(xSetOp), uint16(MOVSW),
-	/*10272*/ uint16(xMatch),
-	/*10273*/ uint16(xSetOp), uint16(MOVSD),
-	/*10275*/ uint16(xMatch),
-	/*10276*/ uint16(xCondDataSize), 10270, 10273, 10280,
-	/*10280*/ uint16(xSetOp), uint16(MOVSQ),
-	/*10282*/ uint16(xMatch),
-	/*10283*/ uint16(xSetOp), uint16(CMPSB),
-	/*10285*/ uint16(xMatch),
-	/*10286*/ uint16(xCondIs64), 10289, 10299,
-	/*10289*/ uint16(xCondDataSize), 10293, 10296, 0,
-	/*10293*/ uint16(xSetOp), uint16(CMPSW),
-	/*10295*/ uint16(xMatch),
-	/*10296*/ uint16(xSetOp), uint16(CMPSD),
-	/*10298*/ uint16(xMatch),
-	/*10299*/ uint16(xCondDataSize), 10293, 10296, 10303,
-	/*10303*/ uint16(xSetOp), uint16(CMPSQ),
-	/*10305*/ uint16(xMatch),
-	/*10306*/ uint16(xSetOp), uint16(TEST),
-	/*10308*/ uint16(xReadIb),
-	/*10309*/ uint16(xArgAL),
-	/*10310*/ uint16(xArgImm8u),
-	/*10311*/ uint16(xMatch),
-	/*10312*/ uint16(xCondIs64), 10315, 10331,
-	/*10315*/ uint16(xCondDataSize), 10319, 10325, 0,
-	/*10319*/ uint16(xSetOp), uint16(TEST),
-	/*10321*/ uint16(xReadIw),
-	/*10322*/ uint16(xArgAX),
-	/*10323*/ uint16(xArgImm16),
-	/*10324*/ uint16(xMatch),
-	/*10325*/ uint16(xSetOp), uint16(TEST),
-	/*10327*/ uint16(xReadId),
-	/*10328*/ uint16(xArgEAX),
-	/*10329*/ uint16(xArgImm32),
-	/*10330*/ uint16(xMatch),
-	/*10331*/ uint16(xCondDataSize), 10319, 10325, 10335,
-	/*10335*/ uint16(xSetOp), uint16(TEST),
-	/*10337*/ uint16(xReadId),
-	/*10338*/ uint16(xArgRAX),
-	/*10339*/ uint16(xArgImm32),
-	/*10340*/ uint16(xMatch),
-	/*10341*/ uint16(xSetOp), uint16(STOSB),
-	/*10343*/ uint16(xMatch),
-	/*10344*/ uint16(xCondIs64), 10347, 10357,
-	/*10347*/ uint16(xCondDataSize), 10351, 10354, 0,
-	/*10351*/ uint16(xSetOp), uint16(STOSW),
-	/*10353*/ uint16(xMatch),
-	/*10354*/ uint16(xSetOp), uint16(STOSD),
-	/*10356*/ uint16(xMatch),
-	/*10357*/ uint16(xCondDataSize), 10351, 10354, 10361,
-	/*10361*/ uint16(xSetOp), uint16(STOSQ),
-	/*10363*/ uint16(xMatch),
-	/*10364*/ uint16(xSetOp), uint16(LODSB),
-	/*10366*/ uint16(xMatch),
-	/*10367*/ uint16(xCondIs64), 10370, 10380,
-	/*10370*/ uint16(xCondDataSize), 10374, 10377, 0,
-	/*10374*/ uint16(xSetOp), uint16(LODSW),
-	/*10376*/ uint16(xMatch),
-	/*10377*/ uint16(xSetOp), uint16(LODSD),
-	/*10379*/ uint16(xMatch),
-	/*10380*/ uint16(xCondDataSize), 10374, 10377, 10384,
-	/*10384*/ uint16(xSetOp), uint16(LODSQ),
-	/*10386*/ uint16(xMatch),
-	/*10387*/ uint16(xSetOp), uint16(SCASB),
-	/*10389*/ uint16(xMatch),
-	/*10390*/ uint16(xCondIs64), 10393, 10403,
-	/*10393*/ uint16(xCondDataSize), 10397, 10400, 0,
-	/*10397*/ uint16(xSetOp), uint16(SCASW),
-	/*10399*/ uint16(xMatch),
-	/*10400*/ uint16(xSetOp), uint16(SCASD),
-	/*10402*/ uint16(xMatch),
-	/*10403*/ uint16(xCondDataSize), 10397, 10400, 10407,
-	/*10407*/ uint16(xSetOp), uint16(SCASQ),
-	/*10409*/ uint16(xMatch),
-	/*10410*/ uint16(xSetOp), uint16(MOV),
-	/*10412*/ uint16(xReadIb),
-	/*10413*/ uint16(xArgR8op),
-	/*10414*/ uint16(xArgImm8u),
-	/*10415*/ uint16(xMatch),
-	/*10416*/ uint16(xCondIs64), 10419, 10435,
-	/*10419*/ uint16(xCondDataSize), 10423, 10429, 0,
-	/*10423*/ uint16(xSetOp), uint16(MOV),
-	/*10425*/ uint16(xReadIw),
-	/*10426*/ uint16(xArgR16op),
-	/*10427*/ uint16(xArgImm16),
-	/*10428*/ uint16(xMatch),
-	/*10429*/ uint16(xSetOp), uint16(MOV),
-	/*10431*/ uint16(xReadId),
-	/*10432*/ uint16(xArgR32op),
-	/*10433*/ uint16(xArgImm32),
-	/*10434*/ uint16(xMatch),
-	/*10435*/ uint16(xCondDataSize), 10423, 10429, 10439,
-	/*10439*/ uint16(xSetOp), uint16(MOV),
-	/*10441*/ uint16(xReadIo),
-	/*10442*/ uint16(xArgR64op),
-	/*10443*/ uint16(xArgImm64),
-	/*10444*/ uint16(xMatch),
-	/*10445*/ uint16(xCondSlashR),
-	10454, // 0
-	10460, // 1
-	10466, // 2
-	10472, // 3
-	10478, // 4
-	10484, // 5
-	0,     // 6
-	10490, // 7
-	/*10454*/ uint16(xSetOp), uint16(ROL),
-	/*10456*/ uint16(xReadIb),
-	/*10457*/ uint16(xArgRM8),
-	/*10458*/ uint16(xArgImm8u),
-	/*10459*/ uint16(xMatch),
-	/*10460*/ uint16(xSetOp), uint16(ROR),
-	/*10462*/ uint16(xReadIb),
-	/*10463*/ uint16(xArgRM8),
-	/*10464*/ uint16(xArgImm8u),
-	/*10465*/ uint16(xMatch),
-	/*10466*/ uint16(xSetOp), uint16(RCL),
-	/*10468*/ uint16(xReadIb),
-	/*10469*/ uint16(xArgRM8),
-	/*10470*/ uint16(xArgImm8u),
-	/*10471*/ uint16(xMatch),
-	/*10472*/ uint16(xSetOp), uint16(RCR),
-	/*10474*/ uint16(xReadIb),
-	/*10475*/ uint16(xArgRM8),
-	/*10476*/ uint16(xArgImm8u),
-	/*10477*/ uint16(xMatch),
-	/*10478*/ uint16(xSetOp), uint16(SHL),
-	/*10480*/ uint16(xReadIb),
-	/*10481*/ uint16(xArgRM8),
-	/*10482*/ uint16(xArgImm8u),
-	/*10483*/ uint16(xMatch),
-	/*10484*/ uint16(xSetOp), uint16(SHR),
-	/*10486*/ uint16(xReadIb),
-	/*10487*/ uint16(xArgRM8),
-	/*10488*/ uint16(xArgImm8u),
-	/*10489*/ uint16(xMatch),
-	/*10490*/ uint16(xSetOp), uint16(SAR),
-	/*10492*/ uint16(xReadIb),
-	/*10493*/ uint16(xArgRM8),
-	/*10494*/ uint16(xArgImm8u),
-	/*10495*/ uint16(xMatch),
-	/*10496*/ uint16(xCondSlashR),
-	10505, // 0
-	10527, // 1
-	10549, // 2
-	10578, // 3
-	10607, // 4
-	10636, // 5
-	0,     // 6
-	10665, // 7
-	/*10505*/ uint16(xCondDataSize), 10509, 10515, 10521,
-	/*10509*/ uint16(xSetOp), uint16(ROL),
-	/*10511*/ uint16(xReadIb),
-	/*10512*/ uint16(xArgRM16),
-	/*10513*/ uint16(xArgImm8u),
-	/*10514*/ uint16(xMatch),
-	/*10515*/ uint16(xSetOp), uint16(ROL),
-	/*10517*/ uint16(xReadIb),
-	/*10518*/ uint16(xArgRM32),
-	/*10519*/ uint16(xArgImm8u),
-	/*10520*/ uint16(xMatch),
-	/*10521*/ uint16(xSetOp), uint16(ROL),
-	/*10523*/ uint16(xReadIb),
-	/*10524*/ uint16(xArgRM64),
-	/*10525*/ uint16(xArgImm8u),
-	/*10526*/ uint16(xMatch),
-	/*10527*/ uint16(xCondDataSize), 10531, 10537, 10543,
-	/*10531*/ uint16(xSetOp), uint16(ROR),
-	/*10533*/ uint16(xReadIb),
-	/*10534*/ uint16(xArgRM16),
-	/*10535*/ uint16(xArgImm8u),
-	/*10536*/ uint16(xMatch),
-	/*10537*/ uint16(xSetOp), uint16(ROR),
-	/*10539*/ uint16(xReadIb),
-	/*10540*/ uint16(xArgRM32),
-	/*10541*/ uint16(xArgImm8u),
-	/*10542*/ uint16(xMatch),
-	/*10543*/ uint16(xSetOp), uint16(ROR),
-	/*10545*/ uint16(xReadIb),
-	/*10546*/ uint16(xArgRM64),
-	/*10547*/ uint16(xArgImm8u),
-	/*10548*/ uint16(xMatch),
-	/*10549*/ uint16(xCondIs64), 10552, 10568,
-	/*10552*/ uint16(xCondDataSize), 10556, 10562, 0,
-	/*10556*/ uint16(xSetOp), uint16(RCL),
-	/*10558*/ uint16(xReadIb),
-	/*10559*/ uint16(xArgRM16),
-	/*10560*/ uint16(xArgImm8u),
-	/*10561*/ uint16(xMatch),
-	/*10562*/ uint16(xSetOp), uint16(RCL),
-	/*10564*/ uint16(xReadIb),
-	/*10565*/ uint16(xArgRM32),
-	/*10566*/ uint16(xArgImm8u),
-	/*10567*/ uint16(xMatch),
-	/*10568*/ uint16(xCondDataSize), 10556, 10562, 10572,
-	/*10572*/ uint16(xSetOp), uint16(RCL),
-	/*10574*/ uint16(xReadIb),
-	/*10575*/ uint16(xArgRM64),
-	/*10576*/ uint16(xArgImm8u),
-	/*10577*/ uint16(xMatch),
-	/*10578*/ uint16(xCondIs64), 10581, 10597,
-	/*10581*/ uint16(xCondDataSize), 10585, 10591, 0,
-	/*10585*/ uint16(xSetOp), uint16(RCR),
-	/*10587*/ uint16(xReadIb),
-	/*10588*/ uint16(xArgRM16),
-	/*10589*/ uint16(xArgImm8u),
-	/*10590*/ uint16(xMatch),
-	/*10591*/ uint16(xSetOp), uint16(RCR),
-	/*10593*/ uint16(xReadIb),
-	/*10594*/ uint16(xArgRM32),
-	/*10595*/ uint16(xArgImm8u),
-	/*10596*/ uint16(xMatch),
-	/*10597*/ uint16(xCondDataSize), 10585, 10591, 10601,
-	/*10601*/ uint16(xSetOp), uint16(RCR),
-	/*10603*/ uint16(xReadIb),
-	/*10604*/ uint16(xArgRM64),
-	/*10605*/ uint16(xArgImm8u),
-	/*10606*/ uint16(xMatch),
-	/*10607*/ uint16(xCondIs64), 10610, 10626,
-	/*10610*/ uint16(xCondDataSize), 10614, 10620, 0,
-	/*10614*/ uint16(xSetOp), uint16(SHL),
-	/*10616*/ uint16(xReadIb),
-	/*10617*/ uint16(xArgRM16),
-	/*10618*/ uint16(xArgImm8u),
-	/*10619*/ uint16(xMatch),
-	/*10620*/ uint16(xSetOp), uint16(SHL),
-	/*10622*/ uint16(xReadIb),
-	/*10623*/ uint16(xArgRM32),
-	/*10624*/ uint16(xArgImm8u),
-	/*10625*/ uint16(xMatch),
-	/*10626*/ uint16(xCondDataSize), 10614, 10620, 10630,
-	/*10630*/ uint16(xSetOp), uint16(SHL),
-	/*10632*/ uint16(xReadIb),
-	/*10633*/ uint16(xArgRM64),
-	/*10634*/ uint16(xArgImm8u),
-	/*10635*/ uint16(xMatch),
-	/*10636*/ uint16(xCondIs64), 10639, 10655,
-	/*10639*/ uint16(xCondDataSize), 10643, 10649, 0,
-	/*10643*/ uint16(xSetOp), uint16(SHR),
-	/*10645*/ uint16(xReadIb),
-	/*10646*/ uint16(xArgRM16),
-	/*10647*/ uint16(xArgImm8u),
-	/*10648*/ uint16(xMatch),
-	/*10649*/ uint16(xSetOp), uint16(SHR),
-	/*10651*/ uint16(xReadIb),
-	/*10652*/ uint16(xArgRM32),
-	/*10653*/ uint16(xArgImm8u),
-	/*10654*/ uint16(xMatch),
-	/*10655*/ uint16(xCondDataSize), 10643, 10649, 10659,
-	/*10659*/ uint16(xSetOp), uint16(SHR),
-	/*10661*/ uint16(xReadIb),
-	/*10662*/ uint16(xArgRM64),
-	/*10663*/ uint16(xArgImm8u),
-	/*10664*/ uint16(xMatch),
-	/*10665*/ uint16(xCondIs64), 10668, 10684,
-	/*10668*/ uint16(xCondDataSize), 10672, 10678, 0,
-	/*10672*/ uint16(xSetOp), uint16(SAR),
-	/*10674*/ uint16(xReadIb),
-	/*10675*/ uint16(xArgRM16),
-	/*10676*/ uint16(xArgImm8u),
-	/*10677*/ uint16(xMatch),
-	/*10678*/ uint16(xSetOp), uint16(SAR),
-	/*10680*/ uint16(xReadIb),
-	/*10681*/ uint16(xArgRM32),
-	/*10682*/ uint16(xArgImm8u),
-	/*10683*/ uint16(xMatch),
-	/*10684*/ uint16(xCondDataSize), 10672, 10678, 10688,
-	/*10688*/ uint16(xSetOp), uint16(SAR),
-	/*10690*/ uint16(xReadIb),
-	/*10691*/ uint16(xArgRM64),
-	/*10692*/ uint16(xArgImm8u),
-	/*10693*/ uint16(xMatch),
-	/*10694*/ uint16(xSetOp), uint16(RET),
-	/*10696*/ uint16(xReadIw),
-	/*10697*/ uint16(xArgImm16u),
-	/*10698*/ uint16(xMatch),
-	/*10699*/ uint16(xSetOp), uint16(RET),
-	/*10701*/ uint16(xMatch),
-	/*10702*/ uint16(xCondIs64), 10705, 0,
-	/*10705*/ uint16(xCondDataSize), 10709, 10715, 0,
-	/*10709*/ uint16(xSetOp), uint16(LES),
-	/*10711*/ uint16(xReadSlashR),
-	/*10712*/ uint16(xArgR16),
-	/*10713*/ uint16(xArgM16colon16),
-	/*10714*/ uint16(xMatch),
-	/*10715*/ uint16(xSetOp), uint16(LES),
-	/*10717*/ uint16(xReadSlashR),
-	/*10718*/ uint16(xArgR32),
-	/*10719*/ uint16(xArgM16colon32),
-	/*10720*/ uint16(xMatch),
-	/*10721*/ uint16(xCondIs64), 10724, 0,
-	/*10724*/ uint16(xCondDataSize), 10728, 10734, 0,
-	/*10728*/ uint16(xSetOp), uint16(LDS),
-	/*10730*/ uint16(xReadSlashR),
-	/*10731*/ uint16(xArgR16),
-	/*10732*/ uint16(xArgM16colon16),
-	/*10733*/ uint16(xMatch),
-	/*10734*/ uint16(xSetOp), uint16(LDS),
-	/*10736*/ uint16(xReadSlashR),
-	/*10737*/ uint16(xArgR32),
-	/*10738*/ uint16(xArgM16colon32),
-	/*10739*/ uint16(xMatch),
-	/*10740*/ uint16(xCondByte), 1,
-	0xF8, 10759,
-	/*10744*/ uint16(xCondSlashR),
-	10753, // 0
-	0,     // 1
-	0,     // 2
-	0,     // 3
-	0,     // 4
-	0,     // 5
-	0,     // 6
-	0,     // 7
-	/*10753*/ uint16(xSetOp), uint16(MOV),
-	/*10755*/ uint16(xReadIb),
-	/*10756*/ uint16(xArgRM8),
-	/*10757*/ uint16(xArgImm8u),
-	/*10758*/ uint16(xMatch),
-	/*10759*/ uint16(xSetOp), uint16(XABORT),
-	/*10761*/ uint16(xReadIb),
-	/*10762*/ uint16(xArgImm8u),
-	/*10763*/ uint16(xMatch),
-	/*10764*/ uint16(xCondByte), 1,
-	0xF8, 10806,
-	/*10768*/ uint16(xCondSlashR),
-	10777, // 0
-	0,     // 1
-	0,     // 2
-	0,     // 3
-	0,     // 4
-	0,     // 5
-	0,     // 6
-	0,     // 7
-	/*10777*/ uint16(xCondIs64), 10780, 10796,
-	/*10780*/ uint16(xCondDataSize), 10784, 10790, 0,
-	/*10784*/ uint16(xSetOp), uint16(MOV),
-	/*10786*/ uint16(xReadIw),
-	/*10787*/ uint16(xArgRM16),
-	/*10788*/ uint16(xArgImm16),
-	/*10789*/ uint16(xMatch),
-	/*10790*/ uint16(xSetOp), uint16(MOV),
-	/*10792*/ uint16(xReadId),
-	/*10793*/ uint16(xArgRM32),
-	/*10794*/ uint16(xArgImm32),
-	/*10795*/ uint16(xMatch),
-	/*10796*/ uint16(xCondDataSize), 10784, 10790, 10800,
-	/*10800*/ uint16(xSetOp), uint16(MOV),
-	/*10802*/ uint16(xReadId),
-	/*10803*/ uint16(xArgRM64),
-	/*10804*/ uint16(xArgImm32),
-	/*10805*/ uint16(xMatch),
-	/*10806*/ uint16(xCondDataSize), 10810, 10815, 10820,
-	/*10810*/ uint16(xSetOp), uint16(XBEGIN),
-	/*10812*/ uint16(xReadCw),
-	/*10813*/ uint16(xArgRel16),
-	/*10814*/ uint16(xMatch),
-	/*10815*/ uint16(xSetOp), uint16(XBEGIN),
-	/*10817*/ uint16(xReadCd),
-	/*10818*/ uint16(xArgRel32),
-	/*10819*/ uint16(xMatch),
-	/*10820*/ uint16(xSetOp), uint16(XBEGIN),
-	/*10822*/ uint16(xReadCd),
-	/*10823*/ uint16(xArgRel32),
-	/*10824*/ uint16(xMatch),
-	/*10825*/ uint16(xSetOp), uint16(ENTER),
-	/*10827*/ uint16(xReadIw),
-	/*10828*/ uint16(xReadIb),
-	/*10829*/ uint16(xArgImm16u),
-	/*10830*/ uint16(xArgImm8u),
-	/*10831*/ uint16(xMatch),
-	/*10832*/ uint16(xCondIs64), 10835, 10845,
-	/*10835*/ uint16(xCondDataSize), 10839, 10842, 0,
-	/*10839*/ uint16(xSetOp), uint16(LEAVE),
-	/*10841*/ uint16(xMatch),
-	/*10842*/ uint16(xSetOp), uint16(LEAVE),
-	/*10844*/ uint16(xMatch),
-	/*10845*/ uint16(xCondDataSize), 10839, 10849, 10852,
-	/*10849*/ uint16(xSetOp), uint16(LEAVE),
-	/*10851*/ uint16(xMatch),
-	/*10852*/ uint16(xSetOp), uint16(LEAVE),
-	/*10854*/ uint16(xMatch),
-	/*10855*/ uint16(xSetOp), uint16(LRET),
-	/*10857*/ uint16(xReadIw),
-	/*10858*/ uint16(xArgImm16u),
-	/*10859*/ uint16(xMatch),
-	/*10860*/ uint16(xSetOp), uint16(LRET),
-	/*10862*/ uint16(xMatch),
-	/*10863*/ uint16(xSetOp), uint16(INT),
-	/*10865*/ uint16(xArg3),
-	/*10866*/ uint16(xMatch),
-	/*10867*/ uint16(xSetOp), uint16(INT),
-	/*10869*/ uint16(xReadIb),
-	/*10870*/ uint16(xArgImm8u),
-	/*10871*/ uint16(xMatch),
-	/*10872*/ uint16(xCondIs64), 10875, 0,
-	/*10875*/ uint16(xSetOp), uint16(INTO),
-	/*10877*/ uint16(xMatch),
-	/*10878*/ uint16(xCondIs64), 10881, 10891,
-	/*10881*/ uint16(xCondDataSize), 10885, 10888, 0,
-	/*10885*/ uint16(xSetOp), uint16(IRET),
-	/*10887*/ uint16(xMatch),
-	/*10888*/ uint16(xSetOp), uint16(IRETD),
-	/*10890*/ uint16(xMatch),
-	/*10891*/ uint16(xCondDataSize), 10885, 10888, 10895,
-	/*10895*/ uint16(xSetOp), uint16(IRETQ),
-	/*10897*/ uint16(xMatch),
-	/*10898*/ uint16(xCondSlashR),
-	10907, // 0
-	10912, // 1
-	10917, // 2
-	10922, // 3
-	10927, // 4
-	10932, // 5
-	0,     // 6
-	10937, // 7
-	/*10907*/ uint16(xSetOp), uint16(ROL),
-	/*10909*/ uint16(xArgRM8),
-	/*10910*/ uint16(xArg1),
-	/*10911*/ uint16(xMatch),
-	/*10912*/ uint16(xSetOp), uint16(ROR),
-	/*10914*/ uint16(xArgRM8),
-	/*10915*/ uint16(xArg1),
-	/*10916*/ uint16(xMatch),
-	/*10917*/ uint16(xSetOp), uint16(RCL),
-	/*10919*/ uint16(xArgRM8),
-	/*10920*/ uint16(xArg1),
-	/*10921*/ uint16(xMatch),
-	/*10922*/ uint16(xSetOp), uint16(RCR),
-	/*10924*/ uint16(xArgRM8),
-	/*10925*/ uint16(xArg1),
-	/*10926*/ uint16(xMatch),
-	/*10927*/ uint16(xSetOp), uint16(SHL),
-	/*10929*/ uint16(xArgRM8),
-	/*10930*/ uint16(xArg1),
-	/*10931*/ uint16(xMatch),
-	/*10932*/ uint16(xSetOp), uint16(SHR),
-	/*10934*/ uint16(xArgRM8),
-	/*10935*/ uint16(xArg1),
-	/*10936*/ uint16(xMatch),
-	/*10937*/ uint16(xSetOp), uint16(SAR),
-	/*10939*/ uint16(xArgRM8),
-	/*10940*/ uint16(xArg1),
-	/*10941*/ uint16(xMatch),
-	/*10942*/ uint16(xCondSlashR),
-	10951, // 0
-	10977, // 1
-	11003, // 2
-	11029, // 3
-	11055, // 4
-	11081, // 5
-	0,     // 6
-	11107, // 7
-	/*10951*/ uint16(xCondIs64), 10954, 10968,
-	/*10954*/ uint16(xCondDataSize), 10958, 10963, 0,
-	/*10958*/ uint16(xSetOp), uint16(ROL),
-	/*10960*/ uint16(xArgRM16),
-	/*10961*/ uint16(xArg1),
-	/*10962*/ uint16(xMatch),
-	/*10963*/ uint16(xSetOp), uint16(ROL),
-	/*10965*/ uint16(xArgRM32),
-	/*10966*/ uint16(xArg1),
-	/*10967*/ uint16(xMatch),
-	/*10968*/ uint16(xCondDataSize), 10958, 10963, 10972,
-	/*10972*/ uint16(xSetOp), uint16(ROL),
-	/*10974*/ uint16(xArgRM64),
-	/*10975*/ uint16(xArg1),
-	/*10976*/ uint16(xMatch),
-	/*10977*/ uint16(xCondIs64), 10980, 10994,
-	/*10980*/ uint16(xCondDataSize), 10984, 10989, 0,
-	/*10984*/ uint16(xSetOp), uint16(ROR),
-	/*10986*/ uint16(xArgRM16),
-	/*10987*/ uint16(xArg1),
-	/*10988*/ uint16(xMatch),
-	/*10989*/ uint16(xSetOp), uint16(ROR),
-	/*10991*/ uint16(xArgRM32),
-	/*10992*/ uint16(xArg1),
-	/*10993*/ uint16(xMatch),
-	/*10994*/ uint16(xCondDataSize), 10984, 10989, 10998,
-	/*10998*/ uint16(xSetOp), uint16(ROR),
-	/*11000*/ uint16(xArgRM64),
-	/*11001*/ uint16(xArg1),
-	/*11002*/ uint16(xMatch),
-	/*11003*/ uint16(xCondIs64), 11006, 11020,
-	/*11006*/ uint16(xCondDataSize), 11010, 11015, 0,
-	/*11010*/ uint16(xSetOp), uint16(RCL),
-	/*11012*/ uint16(xArgRM16),
-	/*11013*/ uint16(xArg1),
-	/*11014*/ uint16(xMatch),
-	/*11015*/ uint16(xSetOp), uint16(RCL),
-	/*11017*/ uint16(xArgRM32),
-	/*11018*/ uint16(xArg1),
-	/*11019*/ uint16(xMatch),
-	/*11020*/ uint16(xCondDataSize), 11010, 11015, 11024,
-	/*11024*/ uint16(xSetOp), uint16(RCL),
-	/*11026*/ uint16(xArgRM64),
-	/*11027*/ uint16(xArg1),
-	/*11028*/ uint16(xMatch),
-	/*11029*/ uint16(xCondIs64), 11032, 11046,
-	/*11032*/ uint16(xCondDataSize), 11036, 11041, 0,
-	/*11036*/ uint16(xSetOp), uint16(RCR),
-	/*11038*/ uint16(xArgRM16),
-	/*11039*/ uint16(xArg1),
-	/*11040*/ uint16(xMatch),
-	/*11041*/ uint16(xSetOp), uint16(RCR),
-	/*11043*/ uint16(xArgRM32),
-	/*11044*/ uint16(xArg1),
-	/*11045*/ uint16(xMatch),
-	/*11046*/ uint16(xCondDataSize), 11036, 11041, 11050,
-	/*11050*/ uint16(xSetOp), uint16(RCR),
-	/*11052*/ uint16(xArgRM64),
-	/*11053*/ uint16(xArg1),
-	/*11054*/ uint16(xMatch),
-	/*11055*/ uint16(xCondIs64), 11058, 11072,
-	/*11058*/ uint16(xCondDataSize), 11062, 11067, 0,
-	/*11062*/ uint16(xSetOp), uint16(SHL),
-	/*11064*/ uint16(xArgRM16),
-	/*11065*/ uint16(xArg1),
-	/*11066*/ uint16(xMatch),
-	/*11067*/ uint16(xSetOp), uint16(SHL),
-	/*11069*/ uint16(xArgRM32),
-	/*11070*/ uint16(xArg1),
-	/*11071*/ uint16(xMatch),
-	/*11072*/ uint16(xCondDataSize), 11062, 11067, 11076,
-	/*11076*/ uint16(xSetOp), uint16(SHL),
-	/*11078*/ uint16(xArgRM64),
-	/*11079*/ uint16(xArg1),
-	/*11080*/ uint16(xMatch),
-	/*11081*/ uint16(xCondIs64), 11084, 11098,
-	/*11084*/ uint16(xCondDataSize), 11088, 11093, 0,
-	/*11088*/ uint16(xSetOp), uint16(SHR),
-	/*11090*/ uint16(xArgRM16),
-	/*11091*/ uint16(xArg1),
-	/*11092*/ uint16(xMatch),
-	/*11093*/ uint16(xSetOp), uint16(SHR),
-	/*11095*/ uint16(xArgRM32),
-	/*11096*/ uint16(xArg1),
-	/*11097*/ uint16(xMatch),
-	/*11098*/ uint16(xCondDataSize), 11088, 11093, 11102,
-	/*11102*/ uint16(xSetOp), uint16(SHR),
-	/*11104*/ uint16(xArgRM64),
-	/*11105*/ uint16(xArg1),
-	/*11106*/ uint16(xMatch),
-	/*11107*/ uint16(xCondIs64), 11110, 11124,
-	/*11110*/ uint16(xCondDataSize), 11114, 11119, 0,
-	/*11114*/ uint16(xSetOp), uint16(SAR),
-	/*11116*/ uint16(xArgRM16),
-	/*11117*/ uint16(xArg1),
-	/*11118*/ uint16(xMatch),
-	/*11119*/ uint16(xSetOp), uint16(SAR),
-	/*11121*/ uint16(xArgRM32),
-	/*11122*/ uint16(xArg1),
-	/*11123*/ uint16(xMatch),
-	/*11124*/ uint16(xCondDataSize), 11114, 11119, 11128,
-	/*11128*/ uint16(xSetOp), uint16(SAR),
-	/*11130*/ uint16(xArgRM64),
-	/*11131*/ uint16(xArg1),
-	/*11132*/ uint16(xMatch),
-	/*11133*/ uint16(xCondSlashR),
-	11142, // 0
-	11147, // 1
-	11152, // 2
-	11157, // 3
-	11162, // 4
-	11167, // 5
-	0,     // 6
-	11172, // 7
-	/*11142*/ uint16(xSetOp), uint16(ROL),
-	/*11144*/ uint16(xArgRM8),
-	/*11145*/ uint16(xArgCL),
-	/*11146*/ uint16(xMatch),
-	/*11147*/ uint16(xSetOp), uint16(ROR),
-	/*11149*/ uint16(xArgRM8),
-	/*11150*/ uint16(xArgCL),
-	/*11151*/ uint16(xMatch),
-	/*11152*/ uint16(xSetOp), uint16(RCL),
-	/*11154*/ uint16(xArgRM8),
-	/*11155*/ uint16(xArgCL),
-	/*11156*/ uint16(xMatch),
-	/*11157*/ uint16(xSetOp), uint16(RCR),
-	/*11159*/ uint16(xArgRM8),
-	/*11160*/ uint16(xArgCL),
-	/*11161*/ uint16(xMatch),
-	/*11162*/ uint16(xSetOp), uint16(SHL),
-	/*11164*/ uint16(xArgRM8),
-	/*11165*/ uint16(xArgCL),
-	/*11166*/ uint16(xMatch),
-	/*11167*/ uint16(xSetOp), uint16(SHR),
-	/*11169*/ uint16(xArgRM8),
-	/*11170*/ uint16(xArgCL),
-	/*11171*/ uint16(xMatch),
-	/*11172*/ uint16(xSetOp), uint16(SAR),
-	/*11174*/ uint16(xArgRM8),
-	/*11175*/ uint16(xArgCL),
-	/*11176*/ uint16(xMatch),
-	/*11177*/ uint16(xCondSlashR),
-	11186, // 0
-	11212, // 1
-	11238, // 2
-	11264, // 3
-	11290, // 4
-	11316, // 5
-	0,     // 6
-	11342, // 7
-	/*11186*/ uint16(xCondIs64), 11189, 11203,
-	/*11189*/ uint16(xCondDataSize), 11193, 11198, 0,
-	/*11193*/ uint16(xSetOp), uint16(ROL),
-	/*11195*/ uint16(xArgRM16),
-	/*11196*/ uint16(xArgCL),
-	/*11197*/ uint16(xMatch),
-	/*11198*/ uint16(xSetOp), uint16(ROL),
-	/*11200*/ uint16(xArgRM32),
-	/*11201*/ uint16(xArgCL),
-	/*11202*/ uint16(xMatch),
-	/*11203*/ uint16(xCondDataSize), 11193, 11198, 11207,
-	/*11207*/ uint16(xSetOp), uint16(ROL),
-	/*11209*/ uint16(xArgRM64),
-	/*11210*/ uint16(xArgCL),
-	/*11211*/ uint16(xMatch),
-	/*11212*/ uint16(xCondIs64), 11215, 11229,
-	/*11215*/ uint16(xCondDataSize), 11219, 11224, 0,
-	/*11219*/ uint16(xSetOp), uint16(ROR),
-	/*11221*/ uint16(xArgRM16),
-	/*11222*/ uint16(xArgCL),
-	/*11223*/ uint16(xMatch),
-	/*11224*/ uint16(xSetOp), uint16(ROR),
-	/*11226*/ uint16(xArgRM32),
-	/*11227*/ uint16(xArgCL),
-	/*11228*/ uint16(xMatch),
-	/*11229*/ uint16(xCondDataSize), 11219, 11224, 11233,
-	/*11233*/ uint16(xSetOp), uint16(ROR),
-	/*11235*/ uint16(xArgRM64),
-	/*11236*/ uint16(xArgCL),
-	/*11237*/ uint16(xMatch),
-	/*11238*/ uint16(xCondIs64), 11241, 11255,
-	/*11241*/ uint16(xCondDataSize), 11245, 11250, 0,
-	/*11245*/ uint16(xSetOp), uint16(RCL),
-	/*11247*/ uint16(xArgRM16),
-	/*11248*/ uint16(xArgCL),
-	/*11249*/ uint16(xMatch),
-	/*11250*/ uint16(xSetOp), uint16(RCL),
-	/*11252*/ uint16(xArgRM32),
-	/*11253*/ uint16(xArgCL),
-	/*11254*/ uint16(xMatch),
-	/*11255*/ uint16(xCondDataSize), 11245, 11250, 11259,
-	/*11259*/ uint16(xSetOp), uint16(RCL),
-	/*11261*/ uint16(xArgRM64),
-	/*11262*/ uint16(xArgCL),
-	/*11263*/ uint16(xMatch),
-	/*11264*/ uint16(xCondIs64), 11267, 11281,
-	/*11267*/ uint16(xCondDataSize), 11271, 11276, 0,
-	/*11271*/ uint16(xSetOp), uint16(RCR),
-	/*11273*/ uint16(xArgRM16),
-	/*11274*/ uint16(xArgCL),
-	/*11275*/ uint16(xMatch),
-	/*11276*/ uint16(xSetOp), uint16(RCR),
-	/*11278*/ uint16(xArgRM32),
-	/*11279*/ uint16(xArgCL),
-	/*11280*/ uint16(xMatch),
-	/*11281*/ uint16(xCondDataSize), 11271, 11276, 11285,
-	/*11285*/ uint16(xSetOp), uint16(RCR),
-	/*11287*/ uint16(xArgRM64),
-	/*11288*/ uint16(xArgCL),
-	/*11289*/ uint16(xMatch),
-	/*11290*/ uint16(xCondIs64), 11293, 11307,
-	/*11293*/ uint16(xCondDataSize), 11297, 11302, 0,
-	/*11297*/ uint16(xSetOp), uint16(SHL),
-	/*11299*/ uint16(xArgRM16),
-	/*11300*/ uint16(xArgCL),
-	/*11301*/ uint16(xMatch),
-	/*11302*/ uint16(xSetOp), uint16(SHL),
-	/*11304*/ uint16(xArgRM32),
-	/*11305*/ uint16(xArgCL),
-	/*11306*/ uint16(xMatch),
-	/*11307*/ uint16(xCondDataSize), 11297, 11302, 11311,
-	/*11311*/ uint16(xSetOp), uint16(SHL),
-	/*11313*/ uint16(xArgRM64),
-	/*11314*/ uint16(xArgCL),
-	/*11315*/ uint16(xMatch),
-	/*11316*/ uint16(xCondIs64), 11319, 11333,
-	/*11319*/ uint16(xCondDataSize), 11323, 11328, 0,
-	/*11323*/ uint16(xSetOp), uint16(SHR),
-	/*11325*/ uint16(xArgRM16),
-	/*11326*/ uint16(xArgCL),
-	/*11327*/ uint16(xMatch),
-	/*11328*/ uint16(xSetOp), uint16(SHR),
-	/*11330*/ uint16(xArgRM32),
-	/*11331*/ uint16(xArgCL),
-	/*11332*/ uint16(xMatch),
-	/*11333*/ uint16(xCondDataSize), 11323, 11328, 11337,
-	/*11337*/ uint16(xSetOp), uint16(SHR),
-	/*11339*/ uint16(xArgRM64),
-	/*11340*/ uint16(xArgCL),
-	/*11341*/ uint16(xMatch),
-	/*11342*/ uint16(xCondIs64), 11345, 11359,
-	/*11345*/ uint16(xCondDataSize), 11349, 11354, 0,
-	/*11349*/ uint16(xSetOp), uint16(SAR),
-	/*11351*/ uint16(xArgRM16),
-	/*11352*/ uint16(xArgCL),
-	/*11353*/ uint16(xMatch),
-	/*11354*/ uint16(xSetOp), uint16(SAR),
-	/*11356*/ uint16(xArgRM32),
-	/*11357*/ uint16(xArgCL),
-	/*11358*/ uint16(xMatch),
-	/*11359*/ uint16(xCondDataSize), 11349, 11354, 11363,
-	/*11363*/ uint16(xSetOp), uint16(SAR),
-	/*11365*/ uint16(xArgRM64),
-	/*11366*/ uint16(xArgCL),
-	/*11367*/ uint16(xMatch),
-	/*11368*/ uint16(xCondIs64), 11371, 0,
-	/*11371*/ uint16(xSetOp), uint16(AAM),
-	/*11373*/ uint16(xReadIb),
-	/*11374*/ uint16(xArgImm8u),
-	/*11375*/ uint16(xMatch),
-	/*11376*/ uint16(xCondIs64), 11379, 0,
-	/*11379*/ uint16(xSetOp), uint16(AAD),
-	/*11381*/ uint16(xReadIb),
-	/*11382*/ uint16(xArgImm8u),
-	/*11383*/ uint16(xMatch),
-	/*11384*/ uint16(xCondIs64), 11387, 11390,
-	/*11387*/ uint16(xSetOp), uint16(XLATB),
-	/*11389*/ uint16(xMatch),
-	/*11390*/ uint16(xCondDataSize), 11387, 11387, 11394,
-	/*11394*/ uint16(xSetOp), uint16(XLATB),
-	/*11396*/ uint16(xMatch),
-	/*11397*/ uint16(xCondByte), 64,
-	0xc0, 11568,
-	0xc1, 11568,
-	0xc2, 11568,
-	0xc3, 11568,
-	0xc4, 11568,
-	0xc5, 11568,
-	0xc6, 11568,
-	0xc7, 11568,
-	0xc8, 11573,
-	0xc9, 11573,
-	0xca, 11573,
-	0xcb, 11573,
-	0xcc, 11573,
-	0xcd, 11573,
-	0xce, 11573,
-	0xcf, 11573,
-	0xd0, 11578,
-	0xd1, 11578,
-	0xd2, 11578,
-	0xd3, 11578,
-	0xd4, 11578,
-	0xd5, 11578,
-	0xd6, 11578,
-	0xd7, 11578,
-	0xd8, 11582,
-	0xd9, 11582,
-	0xda, 11582,
-	0xdb, 11582,
-	0xdc, 11582,
-	0xdd, 11582,
-	0xde, 11582,
-	0xdf, 11582,
-	0xe0, 11586,
-	0xe1, 11586,
-	0xe2, 11586,
-	0xe3, 11586,
-	0xe4, 11586,
-	0xe5, 11586,
-	0xe6, 11586,
-	0xe7, 11586,
-	0xe8, 11591,
-	0xe9, 11591,
-	0xea, 11591,
-	0xeb, 11591,
-	0xec, 11591,
-	0xed, 11591,
-	0xee, 11591,
-	0xef, 11591,
-	0xf0, 11596,
-	0xf1, 11596,
-	0xf2, 11596,
-	0xf3, 11596,
-	0xf4, 11596,
-	0xf5, 11596,
-	0xf6, 11596,
-	0xf7, 11596,
-	0xf8, 11601,
-	0xf9, 11601,
-	0xfa, 11601,
-	0xfb, 11601,
-	0xfc, 11601,
-	0xfd, 11601,
-	0xfe, 11601,
-	0xff, 11601,
-	/*11527*/ uint16(xCondSlashR),
-	11536, // 0
-	11540, // 1
-	11544, // 2
-	11548, // 3
-	11552, // 4
-	11556, // 5
-	11560, // 6
-	11564, // 7
-	/*11536*/ uint16(xSetOp), uint16(FADD),
-	/*11538*/ uint16(xArgM32fp),
-	/*11539*/ uint16(xMatch),
-	/*11540*/ uint16(xSetOp), uint16(FMUL),
-	/*11542*/ uint16(xArgM32fp),
-	/*11543*/ uint16(xMatch),
-	/*11544*/ uint16(xSetOp), uint16(FCOM),
-	/*11546*/ uint16(xArgM32fp),
-	/*11547*/ uint16(xMatch),
-	/*11548*/ uint16(xSetOp), uint16(FCOMP),
-	/*11550*/ uint16(xArgM32fp),
-	/*11551*/ uint16(xMatch),
-	/*11552*/ uint16(xSetOp), uint16(FSUB),
-	/*11554*/ uint16(xArgM32fp),
-	/*11555*/ uint16(xMatch),
-	/*11556*/ uint16(xSetOp), uint16(FSUBR),
-	/*11558*/ uint16(xArgM32fp),
-	/*11559*/ uint16(xMatch),
-	/*11560*/ uint16(xSetOp), uint16(FDIV),
-	/*11562*/ uint16(xArgM32fp),
-	/*11563*/ uint16(xMatch),
-	/*11564*/ uint16(xSetOp), uint16(FDIVR),
-	/*11566*/ uint16(xArgM32fp),
-	/*11567*/ uint16(xMatch),
-	/*11568*/ uint16(xSetOp), uint16(FADD),
-	/*11570*/ uint16(xArgST),
-	/*11571*/ uint16(xArgSTi),
-	/*11572*/ uint16(xMatch),
-	/*11573*/ uint16(xSetOp), uint16(FMUL),
-	/*11575*/ uint16(xArgST),
-	/*11576*/ uint16(xArgSTi),
-	/*11577*/ uint16(xMatch),
-	/*11578*/ uint16(xSetOp), uint16(FCOM),
-	/*11580*/ uint16(xArgSTi),
-	/*11581*/ uint16(xMatch),
-	/*11582*/ uint16(xSetOp), uint16(FCOMP),
-	/*11584*/ uint16(xArgSTi),
-	/*11585*/ uint16(xMatch),
-	/*11586*/ uint16(xSetOp), uint16(FSUB),
-	/*11588*/ uint16(xArgST),
-	/*11589*/ uint16(xArgSTi),
-	/*11590*/ uint16(xMatch),
-	/*11591*/ uint16(xSetOp), uint16(FSUBR),
-	/*11593*/ uint16(xArgST),
-	/*11594*/ uint16(xArgSTi),
-	/*11595*/ uint16(xMatch),
-	/*11596*/ uint16(xSetOp), uint16(FDIV),
-	/*11598*/ uint16(xArgST),
-	/*11599*/ uint16(xArgSTi),
-	/*11600*/ uint16(xMatch),
-	/*11601*/ uint16(xSetOp), uint16(FDIVR),
-	/*11603*/ uint16(xArgST),
-	/*11604*/ uint16(xArgSTi),
-	/*11605*/ uint16(xMatch),
-	/*11606*/ uint16(xCondByte), 42,
-	0xc0, 11729,
-	0xc1, 11729,
-	0xc2, 11729,
-	0xc3, 11729,
-	0xc4, 11729,
-	0xc5, 11729,
-	0xc6, 11729,
-	0xc7, 11729,
-	0xc8, 11733,
-	0xc9, 11733,
-	0xca, 11733,
-	0xcb, 11733,
-	0xcc, 11733,
-	0xcd, 11733,
-	0xce, 11733,
-	0xcf, 11733,
-	0xD0, 11737,
-	0xE0, 11740,
-	0xE1, 11743,
-	0xE4, 11746,
-	0xE5, 11749,
-	0xE8, 11752,
-	0xE9, 11755,
-	0xEA, 11758,
-	0xEB, 11761,
-	0xEC, 11764,
-	0xF0, 11767,
-	0xF1, 11770,
-	0xF2, 11773,
-	0xF3, 11776,
-	0xF4, 11779,
-	0xF5, 11782,
-	0xF6, 11785,
-	0xF7, 11788,
-	0xF8, 11791,
-	0xF9, 11794,
-	0xFA, 11797,
-	0xFB, 11800,
-	0xFC, 11803,
-	0xFD, 11806,
-	0xFE, 11809,
-	0xFF, 11812,
-	/*11692*/ uint16(xCondSlashR),
-	11701, // 0
-	0,     // 1
-	11705, // 2
-	11709, // 3
-	11713, // 4
-	11717, // 5
-	11721, // 6
-	11725, // 7
-	/*11701*/ uint16(xSetOp), uint16(FLD),
-	/*11703*/ uint16(xArgM32fp),
-	/*11704*/ uint16(xMatch),
-	/*11705*/ uint16(xSetOp), uint16(FST),
-	/*11707*/ uint16(xArgM32fp),
-	/*11708*/ uint16(xMatch),
-	/*11709*/ uint16(xSetOp), uint16(FSTP),
-	/*11711*/ uint16(xArgM32fp),
-	/*11712*/ uint16(xMatch),
-	/*11713*/ uint16(xSetOp), uint16(FLDENV),
-	/*11715*/ uint16(xArgM1428byte),
-	/*11716*/ uint16(xMatch),
-	/*11717*/ uint16(xSetOp), uint16(FLDCW),
-	/*11719*/ uint16(xArgM2byte),
-	/*11720*/ uint16(xMatch),
-	/*11721*/ uint16(xSetOp), uint16(FNSTENV),
-	/*11723*/ uint16(xArgM1428byte),
-	/*11724*/ uint16(xMatch),
-	/*11725*/ uint16(xSetOp), uint16(FNSTCW),
-	/*11727*/ uint16(xArgM2byte),
-	/*11728*/ uint16(xMatch),
-	/*11729*/ uint16(xSetOp), uint16(FLD),
-	/*11731*/ uint16(xArgSTi),
-	/*11732*/ uint16(xMatch),
-	/*11733*/ uint16(xSetOp), uint16(FXCH),
-	/*11735*/ uint16(xArgSTi),
-	/*11736*/ uint16(xMatch),
-	/*11737*/ uint16(xSetOp), uint16(FNOP),
-	/*11739*/ uint16(xMatch),
-	/*11740*/ uint16(xSetOp), uint16(FCHS),
-	/*11742*/ uint16(xMatch),
-	/*11743*/ uint16(xSetOp), uint16(FABS),
-	/*11745*/ uint16(xMatch),
-	/*11746*/ uint16(xSetOp), uint16(FTST),
-	/*11748*/ uint16(xMatch),
-	/*11749*/ uint16(xSetOp), uint16(FXAM),
-	/*11751*/ uint16(xMatch),
-	/*11752*/ uint16(xSetOp), uint16(FLD1),
-	/*11754*/ uint16(xMatch),
-	/*11755*/ uint16(xSetOp), uint16(FLDL2T),
-	/*11757*/ uint16(xMatch),
-	/*11758*/ uint16(xSetOp), uint16(FLDL2E),
-	/*11760*/ uint16(xMatch),
-	/*11761*/ uint16(xSetOp), uint16(FLDPI),
-	/*11763*/ uint16(xMatch),
-	/*11764*/ uint16(xSetOp), uint16(FLDLG2),
-	/*11766*/ uint16(xMatch),
-	/*11767*/ uint16(xSetOp), uint16(F2XM1),
-	/*11769*/ uint16(xMatch),
-	/*11770*/ uint16(xSetOp), uint16(FYL2X),
-	/*11772*/ uint16(xMatch),
-	/*11773*/ uint16(xSetOp), uint16(FPTAN),
-	/*11775*/ uint16(xMatch),
-	/*11776*/ uint16(xSetOp), uint16(FPATAN),
-	/*11778*/ uint16(xMatch),
-	/*11779*/ uint16(xSetOp), uint16(FXTRACT),
-	/*11781*/ uint16(xMatch),
-	/*11782*/ uint16(xSetOp), uint16(FPREM1),
-	/*11784*/ uint16(xMatch),
-	/*11785*/ uint16(xSetOp), uint16(FDECSTP),
-	/*11787*/ uint16(xMatch),
-	/*11788*/ uint16(xSetOp), uint16(FINCSTP),
-	/*11790*/ uint16(xMatch),
-	/*11791*/ uint16(xSetOp), uint16(FPREM),
-	/*11793*/ uint16(xMatch),
-	/*11794*/ uint16(xSetOp), uint16(FYL2XP1),
-	/*11796*/ uint16(xMatch),
-	/*11797*/ uint16(xSetOp), uint16(FSQRT),
-	/*11799*/ uint16(xMatch),
-	/*11800*/ uint16(xSetOp), uint16(FSINCOS),
-	/*11802*/ uint16(xMatch),
-	/*11803*/ uint16(xSetOp), uint16(FRNDINT),
-	/*11805*/ uint16(xMatch),
-	/*11806*/ uint16(xSetOp), uint16(FSCALE),
-	/*11808*/ uint16(xMatch),
-	/*11809*/ uint16(xSetOp), uint16(FSIN),
-	/*11811*/ uint16(xMatch),
-	/*11812*/ uint16(xSetOp), uint16(FCOS),
-	/*11814*/ uint16(xMatch),
-	/*11815*/ uint16(xCondByte), 33,
-	0xc0, 11924,
-	0xc1, 11924,
-	0xc2, 11924,
-	0xc3, 11924,
-	0xc4, 11924,
-	0xc5, 11924,
-	0xc6, 11924,
-	0xc7, 11924,
-	0xc8, 11929,
-	0xc9, 11929,
-	0xca, 11929,
-	0xcb, 11929,
-	0xcc, 11929,
-	0xcd, 11929,
-	0xce, 11929,
-	0xcf, 11929,
-	0xd0, 11934,
-	0xd1, 11934,
-	0xd2, 11934,
-	0xd3, 11934,
-	0xd4, 11934,
-	0xd5, 11934,
-	0xd6, 11934,
-	0xd7, 11934,
-	0xd8, 11939,
-	0xd9, 11939,
-	0xda, 11939,
-	0xdb, 11939,
-	0xdc, 11939,
-	0xdd, 11939,
-	0xde, 11939,
-	0xdf, 11939,
-	0xE9, 11944,
-	/*11883*/ uint16(xCondSlashR),
-	11892, // 0
-	11896, // 1
-	11900, // 2
-	11904, // 3
-	11908, // 4
-	11912, // 5
-	11916, // 6
-	11920, // 7
-	/*11892*/ uint16(xSetOp), uint16(FIADD),
-	/*11894*/ uint16(xArgM32int),
-	/*11895*/ uint16(xMatch),
-	/*11896*/ uint16(xSetOp), uint16(FIMUL),
-	/*11898*/ uint16(xArgM32int),
-	/*11899*/ uint16(xMatch),
-	/*11900*/ uint16(xSetOp), uint16(FICOM),
-	/*11902*/ uint16(xArgM32int),
-	/*11903*/ uint16(xMatch),
-	/*11904*/ uint16(xSetOp), uint16(FICOMP),
-	/*11906*/ uint16(xArgM32int),
-	/*11907*/ uint16(xMatch),
-	/*11908*/ uint16(xSetOp), uint16(FISUB),
-	/*11910*/ uint16(xArgM32int),
-	/*11911*/ uint16(xMatch),
-	/*11912*/ uint16(xSetOp), uint16(FISUBR),
-	/*11914*/ uint16(xArgM32int),
-	/*11915*/ uint16(xMatch),
-	/*11916*/ uint16(xSetOp), uint16(FIDIV),
-	/*11918*/ uint16(xArgM32int),
-	/*11919*/ uint16(xMatch),
-	/*11920*/ uint16(xSetOp), uint16(FIDIVR),
-	/*11922*/ uint16(xArgM32int),
-	/*11923*/ uint16(xMatch),
-	/*11924*/ uint16(xSetOp), uint16(FCMOVB),
-	/*11926*/ uint16(xArgST),
-	/*11927*/ uint16(xArgSTi),
-	/*11928*/ uint16(xMatch),
-	/*11929*/ uint16(xSetOp), uint16(FCMOVE),
-	/*11931*/ uint16(xArgST),
-	/*11932*/ uint16(xArgSTi),
-	/*11933*/ uint16(xMatch),
-	/*11934*/ uint16(xSetOp), uint16(FCMOVBE),
-	/*11936*/ uint16(xArgST),
-	/*11937*/ uint16(xArgSTi),
-	/*11938*/ uint16(xMatch),
-	/*11939*/ uint16(xSetOp), uint16(FCMOVU),
-	/*11941*/ uint16(xArgST),
-	/*11942*/ uint16(xArgSTi),
-	/*11943*/ uint16(xMatch),
-	/*11944*/ uint16(xSetOp), uint16(FUCOMPP),
-	/*11946*/ uint16(xMatch),
-	/*11947*/ uint16(xCondByte), 50,
-	0xc0, 12082,
-	0xc1, 12082,
-	0xc2, 12082,
-	0xc3, 12082,
-	0xc4, 12082,
-	0xc5, 12082,
-	0xc6, 12082,
-	0xc7, 12082,
-	0xc8, 12087,
-	0xc9, 12087,
-	0xca, 12087,
-	0xcb, 12087,
-	0xcc, 12087,
-	0xcd, 12087,
-	0xce, 12087,
-	0xcf, 12087,
-	0xd0, 12092,
-	0xd1, 12092,
-	0xd2, 12092,
-	0xd3, 12092,
-	0xd4, 12092,
-	0xd5, 12092,
-	0xd6, 12092,
-	0xd7, 12092,
-	0xd8, 12097,
-	0xd9, 12097,
-	0xda, 12097,
-	0xdb, 12097,
-	0xdc, 12097,
-	0xdd, 12097,
-	0xde, 12097,
-	0xdf, 12097,
-	0xE2, 12102,
-	0xE3, 12105,
-	0xe8, 12108,
-	0xe9, 12108,
-	0xea, 12108,
-	0xeb, 12108,
-	0xec, 12108,
-	0xed, 12108,
-	0xee, 12108,
-	0xef, 12108,
-	0xf0, 12113,
-	0xf1, 12113,
-	0xf2, 12113,
-	0xf3, 12113,
-	0xf4, 12113,
-	0xf5, 12113,
-	0xf6, 12113,
-	0xf7, 12113,
-	/*12049*/ uint16(xCondSlashR),
-	12058, // 0
-	12062, // 1
-	12066, // 2
-	12070, // 3
-	0,     // 4
-	12074, // 5
-	0,     // 6
-	12078, // 7
-	/*12058*/ uint16(xSetOp), uint16(FILD),
-	/*12060*/ uint16(xArgM32int),
-	/*12061*/ uint16(xMatch),
-	/*12062*/ uint16(xSetOp), uint16(FISTTP),
-	/*12064*/ uint16(xArgM32int),
-	/*12065*/ uint16(xMatch),
-	/*12066*/ uint16(xSetOp), uint16(FIST),
-	/*12068*/ uint16(xArgM32int),
-	/*12069*/ uint16(xMatch),
-	/*12070*/ uint16(xSetOp), uint16(FISTP),
-	/*12072*/ uint16(xArgM32int),
-	/*12073*/ uint16(xMatch),
-	/*12074*/ uint16(xSetOp), uint16(FLD),
-	/*12076*/ uint16(xArgM80fp),
-	/*12077*/ uint16(xMatch),
-	/*12078*/ uint16(xSetOp), uint16(FSTP),
-	/*12080*/ uint16(xArgM80fp),
-	/*12081*/ uint16(xMatch),
-	/*12082*/ uint16(xSetOp), uint16(FCMOVNB),
-	/*12084*/ uint16(xArgST),
-	/*12085*/ uint16(xArgSTi),
-	/*12086*/ uint16(xMatch),
-	/*12087*/ uint16(xSetOp), uint16(FCMOVNE),
-	/*12089*/ uint16(xArgST),
-	/*12090*/ uint16(xArgSTi),
-	/*12091*/ uint16(xMatch),
-	/*12092*/ uint16(xSetOp), uint16(FCMOVNBE),
-	/*12094*/ uint16(xArgST),
-	/*12095*/ uint16(xArgSTi),
-	/*12096*/ uint16(xMatch),
-	/*12097*/ uint16(xSetOp), uint16(FCMOVNU),
-	/*12099*/ uint16(xArgST),
-	/*12100*/ uint16(xArgSTi),
-	/*12101*/ uint16(xMatch),
-	/*12102*/ uint16(xSetOp), uint16(FNCLEX),
-	/*12104*/ uint16(xMatch),
-	/*12105*/ uint16(xSetOp), uint16(FNINIT),
-	/*12107*/ uint16(xMatch),
-	/*12108*/ uint16(xSetOp), uint16(FUCOMI),
-	/*12110*/ uint16(xArgST),
-	/*12111*/ uint16(xArgSTi),
-	/*12112*/ uint16(xMatch),
-	/*12113*/ uint16(xSetOp), uint16(FCOMI),
-	/*12115*/ uint16(xArgST),
-	/*12116*/ uint16(xArgSTi),
-	/*12117*/ uint16(xMatch),
-	/*12118*/ uint16(xCondByte), 48,
-	0xc0, 12257,
-	0xc1, 12257,
-	0xc2, 12257,
-	0xc3, 12257,
-	0xc4, 12257,
-	0xc5, 12257,
-	0xc6, 12257,
-	0xc7, 12257,
-	0xc8, 12262,
-	0xc9, 12262,
-	0xca, 12262,
-	0xcb, 12262,
-	0xcc, 12262,
-	0xcd, 12262,
-	0xce, 12262,
-	0xcf, 12262,
-	0xe0, 12267,
-	0xe1, 12267,
-	0xe2, 12267,
-	0xe3, 12267,
-	0xe4, 12267,
-	0xe5, 12267,
-	0xe6, 12267,
-	0xe7, 12267,
-	0xe8, 12272,
-	0xe9, 12272,
-	0xea, 12272,
-	0xeb, 12272,
-	0xec, 12272,
-	0xed, 12272,
-	0xee, 12272,
-	0xef, 12272,
-	0xf0, 12277,
-	0xf1, 12277,
-	0xf2, 12277,
-	0xf3, 12277,
-	0xf4, 12277,
-	0xf5, 12277,
-	0xf6, 12277,
-	0xf7, 12277,
-	0xf8, 12282,
-	0xf9, 12282,
-	0xfa, 12282,
-	0xfb, 12282,
-	0xfc, 12282,
-	0xfd, 12282,
-	0xfe, 12282,
-	0xff, 12282,
-	/*12216*/ uint16(xCondSlashR),
-	12225, // 0
-	12229, // 1
-	12233, // 2
-	12237, // 3
-	12241, // 4
-	12245, // 5
-	12249, // 6
-	12253, // 7
-	/*12225*/ uint16(xSetOp), uint16(FADD),
-	/*12227*/ uint16(xArgM64fp),
-	/*12228*/ uint16(xMatch),
-	/*12229*/ uint16(xSetOp), uint16(FMUL),
-	/*12231*/ uint16(xArgM64fp),
-	/*12232*/ uint16(xMatch),
-	/*12233*/ uint16(xSetOp), uint16(FCOM),
-	/*12235*/ uint16(xArgM64fp),
-	/*12236*/ uint16(xMatch),
-	/*12237*/ uint16(xSetOp), uint16(FCOMP),
-	/*12239*/ uint16(xArgM64fp),
-	/*12240*/ uint16(xMatch),
-	/*12241*/ uint16(xSetOp), uint16(FSUB),
-	/*12243*/ uint16(xArgM64fp),
-	/*12244*/ uint16(xMatch),
-	/*12245*/ uint16(xSetOp), uint16(FSUBR),
-	/*12247*/ uint16(xArgM64fp),
-	/*12248*/ uint16(xMatch),
-	/*12249*/ uint16(xSetOp), uint16(FDIV),
-	/*12251*/ uint16(xArgM64fp),
-	/*12252*/ uint16(xMatch),
-	/*12253*/ uint16(xSetOp), uint16(FDIVR),
-	/*12255*/ uint16(xArgM64fp),
-	/*12256*/ uint16(xMatch),
-	/*12257*/ uint16(xSetOp), uint16(FADD),
-	/*12259*/ uint16(xArgSTi),
-	/*12260*/ uint16(xArgST),
-	/*12261*/ uint16(xMatch),
-	/*12262*/ uint16(xSetOp), uint16(FMUL),
-	/*12264*/ uint16(xArgSTi),
-	/*12265*/ uint16(xArgST),
-	/*12266*/ uint16(xMatch),
-	/*12267*/ uint16(xSetOp), uint16(FSUBR),
-	/*12269*/ uint16(xArgSTi),
-	/*12270*/ uint16(xArgST),
-	/*12271*/ uint16(xMatch),
-	/*12272*/ uint16(xSetOp), uint16(FSUB),
-	/*12274*/ uint16(xArgSTi),
-	/*12275*/ uint16(xArgST),
-	/*12276*/ uint16(xMatch),
-	/*12277*/ uint16(xSetOp), uint16(FDIVR),
-	/*12279*/ uint16(xArgSTi),
-	/*12280*/ uint16(xArgST),
-	/*12281*/ uint16(xMatch),
-	/*12282*/ uint16(xSetOp), uint16(FDIV),
-	/*12284*/ uint16(xArgSTi),
-	/*12285*/ uint16(xArgST),
-	/*12286*/ uint16(xMatch),
-	/*12287*/ uint16(xCondByte), 40,
-	0xc0, 12406,
-	0xc1, 12406,
-	0xc2, 12406,
-	0xc3, 12406,
-	0xc4, 12406,
-	0xc5, 12406,
-	0xc6, 12406,
-	0xc7, 12406,
-	0xd0, 12410,
-	0xd1, 12410,
-	0xd2, 12410,
-	0xd3, 12410,
-	0xd4, 12410,
-	0xd5, 12410,
-	0xd6, 12410,
-	0xd7, 12410,
-	0xd8, 12414,
-	0xd9, 12414,
-	0xda, 12414,
-	0xdb, 12414,
-	0xdc, 12414,
-	0xdd, 12414,
-	0xde, 12414,
-	0xdf, 12414,
-	0xe0, 12418,
-	0xe1, 12418,
-	0xe2, 12418,
-	0xe3, 12418,
-	0xe4, 12418,
-	0xe5, 12418,
-	0xe6, 12418,
-	0xe7, 12418,
-	0xe8, 12422,
-	0xe9, 12422,
-	0xea, 12422,
-	0xeb, 12422,
-	0xec, 12422,
-	0xed, 12422,
-	0xee, 12422,
-	0xef, 12422,
-	/*12369*/ uint16(xCondSlashR),
-	12378, // 0
-	12382, // 1
-	12386, // 2
-	12390, // 3
-	12394, // 4
-	0,     // 5
-	12398, // 6
-	12402, // 7
-	/*12378*/ uint16(xSetOp), uint16(FLD),
-	/*12380*/ uint16(xArgM64fp),
-	/*12381*/ uint16(xMatch),
-	/*12382*/ uint16(xSetOp), uint16(FISTTP),
-	/*12384*/ uint16(xArgM64int),
-	/*12385*/ uint16(xMatch),
-	/*12386*/ uint16(xSetOp), uint16(FST),
-	/*12388*/ uint16(xArgM64fp),
-	/*12389*/ uint16(xMatch),
-	/*12390*/ uint16(xSetOp), uint16(FSTP),
-	/*12392*/ uint16(xArgM64fp),
-	/*12393*/ uint16(xMatch),
-	/*12394*/ uint16(xSetOp), uint16(FRSTOR),
-	/*12396*/ uint16(xArgM94108byte),
-	/*12397*/ uint16(xMatch),
-	/*12398*/ uint16(xSetOp), uint16(FNSAVE),
-	/*12400*/ uint16(xArgM94108byte),
-	/*12401*/ uint16(xMatch),
-	/*12402*/ uint16(xSetOp), uint16(FNSTSW),
-	/*12404*/ uint16(xArgM2byte),
-	/*12405*/ uint16(xMatch),
-	/*12406*/ uint16(xSetOp), uint16(FFREE),
-	/*12408*/ uint16(xArgSTi),
-	/*12409*/ uint16(xMatch),
-	/*12410*/ uint16(xSetOp), uint16(FST),
-	/*12412*/ uint16(xArgSTi),
-	/*12413*/ uint16(xMatch),
-	/*12414*/ uint16(xSetOp), uint16(FSTP),
-	/*12416*/ uint16(xArgSTi),
-	/*12417*/ uint16(xMatch),
-	/*12418*/ uint16(xSetOp), uint16(FUCOM),
-	/*12420*/ uint16(xArgSTi),
-	/*12421*/ uint16(xMatch),
-	/*12422*/ uint16(xSetOp), uint16(FUCOMP),
-	/*12424*/ uint16(xArgSTi),
-	/*12425*/ uint16(xMatch),
-	/*12426*/ uint16(xCondByte), 49,
-	0xc0, 12567,
-	0xc1, 12567,
-	0xc2, 12567,
-	0xc3, 12567,
-	0xc4, 12567,
-	0xc5, 12567,
-	0xc6, 12567,
-	0xc7, 12567,
-	0xc8, 12572,
-	0xc9, 12572,
-	0xca, 12572,
-	0xcb, 12572,
-	0xcc, 12572,
-	0xcd, 12572,
-	0xce, 12572,
-	0xcf, 12572,
-	0xD9, 12577,
-	0xe0, 12580,
-	0xe1, 12580,
-	0xe2, 12580,
-	0xe3, 12580,
-	0xe4, 12580,
-	0xe5, 12580,
-	0xe6, 12580,
-	0xe7, 12580,
-	0xe8, 12585,
-	0xe9, 12585,
-	0xea, 12585,
-	0xeb, 12585,
-	0xec, 12585,
-	0xed, 12585,
-	0xee, 12585,
-	0xef, 12585,
-	0xf0, 12590,
-	0xf1, 12590,
-	0xf2, 12590,
-	0xf3, 12590,
-	0xf4, 12590,
-	0xf5, 12590,
-	0xf6, 12590,
-	0xf7, 12590,
-	0xf8, 12595,
-	0xf9, 12595,
-	0xfa, 12595,
-	0xfb, 12595,
-	0xfc, 12595,
-	0xfd, 12595,
-	0xfe, 12595,
-	0xff, 12595,
-	/*12526*/ uint16(xCondSlashR),
-	12535, // 0
-	12539, // 1
-	12543, // 2
-	12547, // 3
-	12551, // 4
-	12555, // 5
-	12559, // 6
-	12563, // 7
-	/*12535*/ uint16(xSetOp), uint16(FIADD),
-	/*12537*/ uint16(xArgM16int),
-	/*12538*/ uint16(xMatch),
-	/*12539*/ uint16(xSetOp), uint16(FIMUL),
-	/*12541*/ uint16(xArgM16int),
-	/*12542*/ uint16(xMatch),
-	/*12543*/ uint16(xSetOp), uint16(FICOM),
-	/*12545*/ uint16(xArgM16int),
-	/*12546*/ uint16(xMatch),
-	/*12547*/ uint16(xSetOp), uint16(FICOMP),
-	/*12549*/ uint16(xArgM16int),
-	/*12550*/ uint16(xMatch),
-	/*12551*/ uint16(xSetOp), uint16(FISUB),
-	/*12553*/ uint16(xArgM16int),
-	/*12554*/ uint16(xMatch),
-	/*12555*/ uint16(xSetOp), uint16(FISUBR),
-	/*12557*/ uint16(xArgM16int),
-	/*12558*/ uint16(xMatch),
-	/*12559*/ uint16(xSetOp), uint16(FIDIV),
-	/*12561*/ uint16(xArgM16int),
-	/*12562*/ uint16(xMatch),
-	/*12563*/ uint16(xSetOp), uint16(FIDIVR),
-	/*12565*/ uint16(xArgM16int),
-	/*12566*/ uint16(xMatch),
-	/*12567*/ uint16(xSetOp), uint16(FADDP),
-	/*12569*/ uint16(xArgSTi),
-	/*12570*/ uint16(xArgST),
-	/*12571*/ uint16(xMatch),
-	/*12572*/ uint16(xSetOp), uint16(FMULP),
-	/*12574*/ uint16(xArgSTi),
-	/*12575*/ uint16(xArgST),
-	/*12576*/ uint16(xMatch),
-	/*12577*/ uint16(xSetOp), uint16(FCOMPP),
-	/*12579*/ uint16(xMatch),
-	/*12580*/ uint16(xSetOp), uint16(FSUBRP),
-	/*12582*/ uint16(xArgSTi),
-	/*12583*/ uint16(xArgST),
-	/*12584*/ uint16(xMatch),
-	/*12585*/ uint16(xSetOp), uint16(FSUBP),
-	/*12587*/ uint16(xArgSTi),
-	/*12588*/ uint16(xArgST),
-	/*12589*/ uint16(xMatch),
-	/*12590*/ uint16(xSetOp), uint16(FDIVRP),
-	/*12592*/ uint16(xArgSTi),
-	/*12593*/ uint16(xArgST),
-	/*12594*/ uint16(xMatch),
-	/*12595*/ uint16(xSetOp), uint16(FDIVP),
-	/*12597*/ uint16(xArgSTi),
-	/*12598*/ uint16(xArgST),
-	/*12599*/ uint16(xMatch),
-	/*12600*/ uint16(xCondByte), 25,
-	0xc0, 12693,
-	0xc1, 12693,
-	0xc2, 12693,
-	0xc3, 12693,
-	0xc4, 12693,
-	0xc5, 12693,
-	0xc6, 12693,
-	0xc7, 12693,
-	0xE0, 12697,
-	0xe8, 12701,
-	0xe9, 12701,
-	0xea, 12701,
-	0xeb, 12701,
-	0xec, 12701,
-	0xed, 12701,
-	0xee, 12701,
-	0xef, 12701,
-	0xf0, 12706,
-	0xf1, 12706,
-	0xf2, 12706,
-	0xf3, 12706,
-	0xf4, 12706,
-	0xf5, 12706,
-	0xf6, 12706,
-	0xf7, 12706,
-	/*12652*/ uint16(xCondSlashR),
-	12661, // 0
-	12665, // 1
-	12669, // 2
-	12673, // 3
-	12677, // 4
-	12681, // 5
-	12685, // 6
-	12689, // 7
-	/*12661*/ uint16(xSetOp), uint16(FILD),
-	/*12663*/ uint16(xArgM16int),
-	/*12664*/ uint16(xMatch),
-	/*12665*/ uint16(xSetOp), uint16(FISTTP),
-	/*12667*/ uint16(xArgM16int),
-	/*12668*/ uint16(xMatch),
-	/*12669*/ uint16(xSetOp), uint16(FIST),
-	/*12671*/ uint16(xArgM16int),
-	/*12672*/ uint16(xMatch),
-	/*12673*/ uint16(xSetOp), uint16(FISTP),
-	/*12675*/ uint16(xArgM16int),
-	/*12676*/ uint16(xMatch),
-	/*12677*/ uint16(xSetOp), uint16(FBLD),
-	/*12679*/ uint16(xArgM80dec),
-	/*12680*/ uint16(xMatch),
-	/*12681*/ uint16(xSetOp), uint16(FILD),
-	/*12683*/ uint16(xArgM64int),
-	/*12684*/ uint16(xMatch),
-	/*12685*/ uint16(xSetOp), uint16(FBSTP),
-	/*12687*/ uint16(xArgM80bcd),
-	/*12688*/ uint16(xMatch),
-	/*12689*/ uint16(xSetOp), uint16(FISTP),
-	/*12691*/ uint16(xArgM64int),
-	/*12692*/ uint16(xMatch),
-	/*12693*/ uint16(xSetOp), uint16(FFREEP),
-	/*12695*/ uint16(xArgSTi),
-	/*12696*/ uint16(xMatch),
-	/*12697*/ uint16(xSetOp), uint16(FNSTSW),
-	/*12699*/ uint16(xArgAX),
-	/*12700*/ uint16(xMatch),
-	/*12701*/ uint16(xSetOp), uint16(FUCOMIP),
-	/*12703*/ uint16(xArgST),
-	/*12704*/ uint16(xArgSTi),
-	/*12705*/ uint16(xMatch),
-	/*12706*/ uint16(xSetOp), uint16(FCOMIP),
-	/*12708*/ uint16(xArgST),
-	/*12709*/ uint16(xArgSTi),
-	/*12710*/ uint16(xMatch),
-	/*12711*/ uint16(xSetOp), uint16(LOOPNE),
-	/*12713*/ uint16(xReadCb),
-	/*12714*/ uint16(xArgRel8),
-	/*12715*/ uint16(xMatch),
-	/*12716*/ uint16(xSetOp), uint16(LOOPE),
-	/*12718*/ uint16(xReadCb),
-	/*12719*/ uint16(xArgRel8),
-	/*12720*/ uint16(xMatch),
-	/*12721*/ uint16(xSetOp), uint16(LOOP),
-	/*12723*/ uint16(xReadCb),
-	/*12724*/ uint16(xArgRel8),
-	/*12725*/ uint16(xMatch),
-	/*12726*/ uint16(xCondIs64), 12729, 12743,
-	/*12729*/ uint16(xCondAddrSize), 12733, 12738, 0,
-	/*12733*/ uint16(xSetOp), uint16(JCXZ),
-	/*12735*/ uint16(xReadCb),
-	/*12736*/ uint16(xArgRel8),
-	/*12737*/ uint16(xMatch),
-	/*12738*/ uint16(xSetOp), uint16(JECXZ),
-	/*12740*/ uint16(xReadCb),
-	/*12741*/ uint16(xArgRel8),
-	/*12742*/ uint16(xMatch),
-	/*12743*/ uint16(xCondAddrSize), 0, 12738, 12747,
-	/*12747*/ uint16(xSetOp), uint16(JRCXZ),
-	/*12749*/ uint16(xReadCb),
-	/*12750*/ uint16(xArgRel8),
-	/*12751*/ uint16(xMatch),
-	/*12752*/ uint16(xSetOp), uint16(IN),
-	/*12754*/ uint16(xReadIb),
-	/*12755*/ uint16(xArgAL),
-	/*12756*/ uint16(xArgImm8u),
-	/*12757*/ uint16(xMatch),
-	/*12758*/ uint16(xCondDataSize), 12762, 12768, 12774,
-	/*12762*/ uint16(xSetOp), uint16(IN),
-	/*12764*/ uint16(xReadIb),
-	/*12765*/ uint16(xArgAX),
-	/*12766*/ uint16(xArgImm8u),
-	/*12767*/ uint16(xMatch),
-	/*12768*/ uint16(xSetOp), uint16(IN),
-	/*12770*/ uint16(xReadIb),
-	/*12771*/ uint16(xArgEAX),
-	/*12772*/ uint16(xArgImm8u),
-	/*12773*/ uint16(xMatch),
-	/*12774*/ uint16(xSetOp), uint16(IN),
-	/*12776*/ uint16(xReadIb),
-	/*12777*/ uint16(xArgEAX),
-	/*12778*/ uint16(xArgImm8u),
-	/*12779*/ uint16(xMatch),
-	/*12780*/ uint16(xSetOp), uint16(OUT),
-	/*12782*/ uint16(xReadIb),
-	/*12783*/ uint16(xArgImm8u),
-	/*12784*/ uint16(xArgAL),
-	/*12785*/ uint16(xMatch),
-	/*12786*/ uint16(xCondPrefix), 3,
-	0xC5, 12830,
-	0xC4, 12816,
-	0x0, 12794,
-	/*12794*/ uint16(xCondDataSize), 12798, 12804, 12810,
-	/*12798*/ uint16(xSetOp), uint16(OUT),
-	/*12800*/ uint16(xReadIb),
-	/*12801*/ uint16(xArgImm8u),
-	/*12802*/ uint16(xArgAX),
-	/*12803*/ uint16(xMatch),
-	/*12804*/ uint16(xSetOp), uint16(OUT),
-	/*12806*/ uint16(xReadIb),
-	/*12807*/ uint16(xArgImm8u),
-	/*12808*/ uint16(xArgEAX),
-	/*12809*/ uint16(xMatch),
-	/*12810*/ uint16(xSetOp), uint16(OUT),
-	/*12812*/ uint16(xReadIb),
-	/*12813*/ uint16(xArgImm8u),
-	/*12814*/ uint16(xArgEAX),
-	/*12815*/ uint16(xMatch),
-	/*12816*/ uint16(xCondPrefix), 1,
-	0x66, 12820,
-	/*12820*/ uint16(xCondPrefix), 1,
-	0x0F, 12824,
-	/*12824*/ uint16(xSetOp), uint16(VMOVNTDQ),
-	/*12826*/ uint16(xReadSlashR),
-	/*12827*/ uint16(xArgM256),
-	/*12828*/ uint16(xArgYmm1),
-	/*12829*/ uint16(xMatch),
-	/*12830*/ uint16(xCondPrefix), 1,
-	0x66, 12834,
-	/*12834*/ uint16(xCondPrefix), 1,
-	0x0F, 12838,
-	/*12838*/ uint16(xSetOp), uint16(VMOVNTDQ),
-	/*12840*/ uint16(xReadSlashR),
-	/*12841*/ uint16(xArgM256),
-	/*12842*/ uint16(xArgYmm1),
-	/*12843*/ uint16(xMatch),
-	/*12844*/ uint16(xCondIs64), 12847, 12861,
-	/*12847*/ uint16(xCondDataSize), 12851, 12856, 0,
-	/*12851*/ uint16(xSetOp), uint16(CALL),
-	/*12853*/ uint16(xReadCw),
-	/*12854*/ uint16(xArgRel16),
-	/*12855*/ uint16(xMatch),
-	/*12856*/ uint16(xSetOp), uint16(CALL),
-	/*12858*/ uint16(xReadCd),
-	/*12859*/ uint16(xArgRel32),
-	/*12860*/ uint16(xMatch),
-	/*12861*/ uint16(xCondDataSize), 12865, 12856, 12870,
-	/*12865*/ uint16(xSetOp), uint16(CALL),
-	/*12867*/ uint16(xReadCd),
-	/*12868*/ uint16(xArgRel32),
-	/*12869*/ uint16(xMatch),
-	/*12870*/ uint16(xSetOp), uint16(CALL),
-	/*12872*/ uint16(xReadCd),
-	/*12873*/ uint16(xArgRel32),
-	/*12874*/ uint16(xMatch),
-	/*12875*/ uint16(xCondIs64), 12878, 12892,
-	/*12878*/ uint16(xCondDataSize), 12882, 12887, 0,
-	/*12882*/ uint16(xSetOp), uint16(JMP),
-	/*12884*/ uint16(xReadCw),
-	/*12885*/ uint16(xArgRel16),
-	/*12886*/ uint16(xMatch),
-	/*12887*/ uint16(xSetOp), uint16(JMP),
-	/*12889*/ uint16(xReadCd),
-	/*12890*/ uint16(xArgRel32),
-	/*12891*/ uint16(xMatch),
-	/*12892*/ uint16(xCondDataSize), 12896, 12887, 12901,
-	/*12896*/ uint16(xSetOp), uint16(JMP),
-	/*12898*/ uint16(xReadCd),
-	/*12899*/ uint16(xArgRel32),
-	/*12900*/ uint16(xMatch),
-	/*12901*/ uint16(xSetOp), uint16(JMP),
-	/*12903*/ uint16(xReadCd),
-	/*12904*/ uint16(xArgRel32),
-	/*12905*/ uint16(xMatch),
-	/*12906*/ uint16(xCondIs64), 12909, 0,
-	/*12909*/ uint16(xCondDataSize), 12913, 12918, 0,
-	/*12913*/ uint16(xSetOp), uint16(LJMP),
-	/*12915*/ uint16(xReadCd),
-	/*12916*/ uint16(xArgPtr16colon16),
-	/*12917*/ uint16(xMatch),
-	/*12918*/ uint16(xSetOp), uint16(LJMP),
-	/*12920*/ uint16(xReadCp),
-	/*12921*/ uint16(xArgPtr16colon32),
-	/*12922*/ uint16(xMatch),
-	/*12923*/ uint16(xSetOp), uint16(JMP),
-	/*12925*/ uint16(xReadCb),
-	/*12926*/ uint16(xArgRel8),
-	/*12927*/ uint16(xMatch),
-	/*12928*/ uint16(xSetOp), uint16(IN),
-	/*12930*/ uint16(xArgAL),
-	/*12931*/ uint16(xArgDX),
-	/*12932*/ uint16(xMatch),
-	/*12933*/ uint16(xCondDataSize), 12937, 12942, 12947,
-	/*12937*/ uint16(xSetOp), uint16(IN),
-	/*12939*/ uint16(xArgAX),
-	/*12940*/ uint16(xArgDX),
-	/*12941*/ uint16(xMatch),
-	/*12942*/ uint16(xSetOp), uint16(IN),
-	/*12944*/ uint16(xArgEAX),
-	/*12945*/ uint16(xArgDX),
-	/*12946*/ uint16(xMatch),
-	/*12947*/ uint16(xSetOp), uint16(IN),
-	/*12949*/ uint16(xArgEAX),
-	/*12950*/ uint16(xArgDX),
-	/*12951*/ uint16(xMatch),
-	/*12952*/ uint16(xSetOp), uint16(OUT),
-	/*12954*/ uint16(xArgDX),
-	/*12955*/ uint16(xArgAL),
-	/*12956*/ uint16(xMatch),
-	/*12957*/ uint16(xCondDataSize), 12961, 12966, 12971,
-	/*12961*/ uint16(xSetOp), uint16(OUT),
-	/*12963*/ uint16(xArgDX),
-	/*12964*/ uint16(xArgAX),
-	/*12965*/ uint16(xMatch),
-	/*12966*/ uint16(xSetOp), uint16(OUT),
-	/*12968*/ uint16(xArgDX),
-	/*12969*/ uint16(xArgEAX),
-	/*12970*/ uint16(xMatch),
-	/*12971*/ uint16(xSetOp), uint16(OUT),
-	/*12973*/ uint16(xArgDX),
-	/*12974*/ uint16(xArgEAX),
-	/*12975*/ uint16(xMatch),
-	/*12976*/ uint16(xSetOp), uint16(ICEBP),
-	/*12978*/ uint16(xMatch),
-	/*12979*/ uint16(xSetOp), uint16(HLT),
-	/*12981*/ uint16(xMatch),
-	/*12982*/ uint16(xSetOp), uint16(CMC),
-	/*12984*/ uint16(xMatch),
-	/*12985*/ uint16(xCondSlashR),
-	12994, // 0
-	0,     // 1
-	13000, // 2
-	13004, // 3
-	13008, // 4
-	13012, // 5
-	13016, // 6
-	13020, // 7
-	/*12994*/ uint16(xSetOp), uint16(TEST),
-	/*12996*/ uint16(xReadIb),
-	/*12997*/ uint16(xArgRM8),
-	/*12998*/ uint16(xArgImm8u),
-	/*12999*/ uint16(xMatch),
-	/*13000*/ uint16(xSetOp), uint16(NOT),
-	/*13002*/ uint16(xArgRM8),
-	/*13003*/ uint16(xMatch),
-	/*13004*/ uint16(xSetOp), uint16(NEG),
-	/*13006*/ uint16(xArgRM8),
-	/*13007*/ uint16(xMatch),
-	/*13008*/ uint16(xSetOp), uint16(MUL),
-	/*13010*/ uint16(xArgRM8),
-	/*13011*/ uint16(xMatch),
-	/*13012*/ uint16(xSetOp), uint16(IMUL),
-	/*13014*/ uint16(xArgRM8),
-	/*13015*/ uint16(xMatch),
-	/*13016*/ uint16(xSetOp), uint16(DIV),
-	/*13018*/ uint16(xArgRM8),
-	/*13019*/ uint16(xMatch),
-	/*13020*/ uint16(xSetOp), uint16(IDIV),
-	/*13022*/ uint16(xArgRM8),
-	/*13023*/ uint16(xMatch),
-	/*13024*/ uint16(xCondSlashR),
-	13033, // 0
-	0,     // 1
-	13062, // 2
-	13085, // 3
-	13108, // 4
-	13131, // 5
-	13154, // 6
-	13177, // 7
-	/*13033*/ uint16(xCondIs64), 13036, 13052,
-	/*13036*/ uint16(xCondDataSize), 13040, 13046, 0,
-	/*13040*/ uint16(xSetOp), uint16(TEST),
-	/*13042*/ uint16(xReadIw),
-	/*13043*/ uint16(xArgRM16),
-	/*13044*/ uint16(xArgImm16),
-	/*13045*/ uint16(xMatch),
-	/*13046*/ uint16(xSetOp), uint16(TEST),
-	/*13048*/ uint16(xReadId),
-	/*13049*/ uint16(xArgRM32),
-	/*13050*/ uint16(xArgImm32),
-	/*13051*/ uint16(xMatch),
-	/*13052*/ uint16(xCondDataSize), 13040, 13046, 13056,
-	/*13056*/ uint16(xSetOp), uint16(TEST),
-	/*13058*/ uint16(xReadId),
-	/*13059*/ uint16(xArgRM64),
-	/*13060*/ uint16(xArgImm32),
-	/*13061*/ uint16(xMatch),
-	/*13062*/ uint16(xCondIs64), 13065, 13077,
-	/*13065*/ uint16(xCondDataSize), 13069, 13073, 0,
-	/*13069*/ uint16(xSetOp), uint16(NOT),
-	/*13071*/ uint16(xArgRM16),
-	/*13072*/ uint16(xMatch),
-	/*13073*/ uint16(xSetOp), uint16(NOT),
-	/*13075*/ uint16(xArgRM32),
-	/*13076*/ uint16(xMatch),
-	/*13077*/ uint16(xCondDataSize), 13069, 13073, 13081,
-	/*13081*/ uint16(xSetOp), uint16(NOT),
-	/*13083*/ uint16(xArgRM64),
-	/*13084*/ uint16(xMatch),
-	/*13085*/ uint16(xCondIs64), 13088, 13100,
-	/*13088*/ uint16(xCondDataSize), 13092, 13096, 0,
-	/*13092*/ uint16(xSetOp), uint16(NEG),
-	/*13094*/ uint16(xArgRM16),
-	/*13095*/ uint16(xMatch),
-	/*13096*/ uint16(xSetOp), uint16(NEG),
-	/*13098*/ uint16(xArgRM32),
-	/*13099*/ uint16(xMatch),
-	/*13100*/ uint16(xCondDataSize), 13092, 13096, 13104,
-	/*13104*/ uint16(xSetOp), uint16(NEG),
-	/*13106*/ uint16(xArgRM64),
-	/*13107*/ uint16(xMatch),
-	/*13108*/ uint16(xCondIs64), 13111, 13123,
-	/*13111*/ uint16(xCondDataSize), 13115, 13119, 0,
-	/*13115*/ uint16(xSetOp), uint16(MUL),
-	/*13117*/ uint16(xArgRM16),
-	/*13118*/ uint16(xMatch),
-	/*13119*/ uint16(xSetOp), uint16(MUL),
-	/*13121*/ uint16(xArgRM32),
-	/*13122*/ uint16(xMatch),
-	/*13123*/ uint16(xCondDataSize), 13115, 13119, 13127,
-	/*13127*/ uint16(xSetOp), uint16(MUL),
-	/*13129*/ uint16(xArgRM64),
-	/*13130*/ uint16(xMatch),
-	/*13131*/ uint16(xCondIs64), 13134, 13146,
-	/*13134*/ uint16(xCondDataSize), 13138, 13142, 0,
-	/*13138*/ uint16(xSetOp), uint16(IMUL),
-	/*13140*/ uint16(xArgRM16),
-	/*13141*/ uint16(xMatch),
-	/*13142*/ uint16(xSetOp), uint16(IMUL),
-	/*13144*/ uint16(xArgRM32),
-	/*13145*/ uint16(xMatch),
-	/*13146*/ uint16(xCondDataSize), 13138, 13142, 13150,
-	/*13150*/ uint16(xSetOp), uint16(IMUL),
-	/*13152*/ uint16(xArgRM64),
-	/*13153*/ uint16(xMatch),
-	/*13154*/ uint16(xCondIs64), 13157, 13169,
-	/*13157*/ uint16(xCondDataSize), 13161, 13165, 0,
-	/*13161*/ uint16(xSetOp), uint16(DIV),
-	/*13163*/ uint16(xArgRM16),
-	/*13164*/ uint16(xMatch),
-	/*13165*/ uint16(xSetOp), uint16(DIV),
-	/*13167*/ uint16(xArgRM32),
-	/*13168*/ uint16(xMatch),
-	/*13169*/ uint16(xCondDataSize), 13161, 13165, 13173,
-	/*13173*/ uint16(xSetOp), uint16(DIV),
-	/*13175*/ uint16(xArgRM64),
-	/*13176*/ uint16(xMatch),
-	/*13177*/ uint16(xCondIs64), 13180, 13192,
-	/*13180*/ uint16(xCondDataSize), 13184, 13188, 0,
-	/*13184*/ uint16(xSetOp), uint16(IDIV),
-	/*13186*/ uint16(xArgRM16),
-	/*13187*/ uint16(xMatch),
-	/*13188*/ uint16(xSetOp), uint16(IDIV),
-	/*13190*/ uint16(xArgRM32),
-	/*13191*/ uint16(xMatch),
-	/*13192*/ uint16(xCondDataSize), 13184, 13188, 13196,
-	/*13196*/ uint16(xSetOp), uint16(IDIV),
-	/*13198*/ uint16(xArgRM64),
-	/*13199*/ uint16(xMatch),
-	/*13200*/ uint16(xSetOp), uint16(CLC),
-	/*13202*/ uint16(xMatch),
-	/*13203*/ uint16(xSetOp), uint16(STC),
-	/*13205*/ uint16(xMatch),
-	/*13206*/ uint16(xSetOp), uint16(CLI),
-	/*13208*/ uint16(xMatch),
-	/*13209*/ uint16(xSetOp), uint16(STI),
-	/*13211*/ uint16(xMatch),
-	/*13212*/ uint16(xSetOp), uint16(CLD),
-	/*13214*/ uint16(xMatch),
-	/*13215*/ uint16(xSetOp), uint16(STD),
-	/*13217*/ uint16(xMatch),
-	/*13218*/ uint16(xCondSlashR),
-	13227, // 0
-	13231, // 1
-	0,     // 2
-	0,     // 3
-	0,     // 4
-	0,     // 5
-	0,     // 6
-	0,     // 7
-	/*13227*/ uint16(xSetOp), uint16(INC),
-	/*13229*/ uint16(xArgRM8),
-	/*13230*/ uint16(xMatch),
-	/*13231*/ uint16(xSetOp), uint16(DEC),
-	/*13233*/ uint16(xArgRM8),
-	/*13234*/ uint16(xMatch),
-	/*13235*/ uint16(xCondSlashR),
-	13244, // 0
-	13267, // 1
-	13290, // 2
-	13309, // 3
-	13332, // 4
-	13351, // 5
-	13374, // 6
-	0,     // 7
-	/*13244*/ uint16(xCondIs64), 13247, 13259,
-	/*13247*/ uint16(xCondDataSize), 13251, 13255, 0,
-	/*13251*/ uint16(xSetOp), uint16(INC),
-	/*13253*/ uint16(xArgRM16),
-	/*13254*/ uint16(xMatch),
-	/*13255*/ uint16(xSetOp), uint16(INC),
-	/*13257*/ uint16(xArgRM32),
-	/*13258*/ uint16(xMatch),
-	/*13259*/ uint16(xCondDataSize), 13251, 13255, 13263,
-	/*13263*/ uint16(xSetOp), uint16(INC),
-	/*13265*/ uint16(xArgRM64),
-	/*13266*/ uint16(xMatch),
-	/*13267*/ uint16(xCondIs64), 13270, 13282,
-	/*13270*/ uint16(xCondDataSize), 13274, 13278, 0,
-	/*13274*/ uint16(xSetOp), uint16(DEC),
-	/*13276*/ uint16(xArgRM16),
-	/*13277*/ uint16(xMatch),
-	/*13278*/ uint16(xSetOp), uint16(DEC),
-	/*13280*/ uint16(xArgRM32),
-	/*13281*/ uint16(xMatch),
-	/*13282*/ uint16(xCondDataSize), 13274, 13278, 13286,
-	/*13286*/ uint16(xSetOp), uint16(DEC),
-	/*13288*/ uint16(xArgRM64),
-	/*13289*/ uint16(xMatch),
-	/*13290*/ uint16(xCondIs64), 13293, 13305,
-	/*13293*/ uint16(xCondDataSize), 13297, 13301, 0,
-	/*13297*/ uint16(xSetOp), uint16(CALL),
-	/*13299*/ uint16(xArgRM16),
-	/*13300*/ uint16(xMatch),
-	/*13301*/ uint16(xSetOp), uint16(CALL),
-	/*13303*/ uint16(xArgRM32),
-	/*13304*/ uint16(xMatch),
-	/*13305*/ uint16(xSetOp), uint16(CALL),
-	/*13307*/ uint16(xArgRM64),
-	/*13308*/ uint16(xMatch),
-	/*13309*/ uint16(xCondIs64), 13312, 13324,
-	/*13312*/ uint16(xCondDataSize), 13316, 13320, 0,
-	/*13316*/ uint16(xSetOp), uint16(LCALL),
-	/*13318*/ uint16(xArgM16colon16),
-	/*13319*/ uint16(xMatch),
-	/*13320*/ uint16(xSetOp), uint16(LCALL),
-	/*13322*/ uint16(xArgM16colon32),
-	/*13323*/ uint16(xMatch),
-	/*13324*/ uint16(xCondDataSize), 13316, 13320, 13328,
-	/*13328*/ uint16(xSetOp), uint16(LCALL),
-	/*13330*/ uint16(xArgM16colon64),
-	/*13331*/ uint16(xMatch),
-	/*13332*/ uint16(xCondIs64), 13335, 13347,
-	/*13335*/ uint16(xCondDataSize), 13339, 13343, 0,
-	/*13339*/ uint16(xSetOp), uint16(JMP),
-	/*13341*/ uint16(xArgRM16),
-	/*13342*/ uint16(xMatch),
-	/*13343*/ uint16(xSetOp), uint16(JMP),
-	/*13345*/ uint16(xArgRM32),
-	/*13346*/ uint16(xMatch),
-	/*13347*/ uint16(xSetOp), uint16(JMP),
-	/*13349*/ uint16(xArgRM64),
-	/*13350*/ uint16(xMatch),
-	/*13351*/ uint16(xCondIs64), 13354, 13366,
-	/*13354*/ uint16(xCondDataSize), 13358, 13362, 0,
-	/*13358*/ uint16(xSetOp), uint16(LJMP),
-	/*13360*/ uint16(xArgM16colon16),
-	/*13361*/ uint16(xMatch),
-	/*13362*/ uint16(xSetOp), uint16(LJMP),
-	/*13364*/ uint16(xArgM16colon32),
-	/*13365*/ uint16(xMatch),
-	/*13366*/ uint16(xCondDataSize), 13358, 13362, 13370,
-	/*13370*/ uint16(xSetOp), uint16(LJMP),
-	/*13372*/ uint16(xArgM16colon64),
-	/*13373*/ uint16(xMatch),
-	/*13374*/ uint16(xCondIs64), 13377, 13389,
-	/*13377*/ uint16(xCondDataSize), 13381, 13385, 0,
-	/*13381*/ uint16(xSetOp), uint16(PUSH),
-	/*13383*/ uint16(xArgRM16),
-	/*13384*/ uint16(xMatch),
-	/*13385*/ uint16(xSetOp), uint16(PUSH),
-	/*13387*/ uint16(xArgRM32),
-	/*13388*/ uint16(xMatch),
-	/*13389*/ uint16(xCondDataSize), 13381, 13393, 13397,
-	/*13393*/ uint16(xSetOp), uint16(PUSH),
-	/*13395*/ uint16(xArgRM64),
-	/*13396*/ uint16(xMatch),
-	/*13397*/ uint16(xSetOp), uint16(PUSH),
-	/*13399*/ uint16(xArgRM64),
-	/*13400*/ uint16(xMatch),
-}
-
-const (
-	_ Op = iota
-
-	AAA
-	AAD
-	AAM
-	AAS
-	ADC
-	ADD
-	ADDPD
-	ADDPS
-	ADDSD
-	ADDSS
-	ADDSUBPD
-	ADDSUBPS
-	AESDEC
-	AESDECLAST
-	AESENC
-	AESENCLAST
-	AESIMC
-	AESKEYGENASSIST
-	AND
-	ANDNPD
-	ANDNPS
-	ANDPD
-	ANDPS
-	ARPL
-	BLENDPD
-	BLENDPS
-	BLENDVPD
-	BLENDVPS
-	BOUND
-	BSF
-	BSR
-	BSWAP
-	BT
-	BTC
-	BTR
-	BTS
-	CALL
-	CBW
-	CDQ
-	CDQE
-	CLC
-	CLD
-	CLFLUSH
-	CLI
-	CLTS
-	CMC
-	CMOVA
-	CMOVAE
-	CMOVB
-	CMOVBE
-	CMOVE
-	CMOVG
-	CMOVGE
-	CMOVL
-	CMOVLE
-	CMOVNE
-	CMOVNO
-	CMOVNP
-	CMOVNS
-	CMOVO
-	CMOVP
-	CMOVS
-	CMP
-	CMPPD
-	CMPPS
-	CMPSB
-	CMPSD
-	CMPSD_XMM
-	CMPSQ
-	CMPSS
-	CMPSW
-	CMPXCHG
-	CMPXCHG16B
-	CMPXCHG8B
-	COMISD
-	COMISS
-	CPUID
-	CQO
-	CRC32
-	CVTDQ2PD
-	CVTDQ2PS
-	CVTPD2DQ
-	CVTPD2PI
-	CVTPD2PS
-	CVTPI2PD
-	CVTPI2PS
-	CVTPS2DQ
-	CVTPS2PD
-	CVTPS2PI
-	CVTSD2SI
-	CVTSD2SS
-	CVTSI2SD
-	CVTSI2SS
-	CVTSS2SD
-	CVTSS2SI
-	CVTTPD2DQ
-	CVTTPD2PI
-	CVTTPS2DQ
-	CVTTPS2PI
-	CVTTSD2SI
-	CVTTSS2SI
-	CWD
-	CWDE
-	DAA
-	DAS
-	DEC
-	DIV
-	DIVPD
-	DIVPS
-	DIVSD
-	DIVSS
-	DPPD
-	DPPS
-	EMMS
-	ENTER
-	EXTRACTPS
-	F2XM1
-	FABS
-	FADD
-	FADDP
-	FBLD
-	FBSTP
-	FCHS
-	FCMOVB
-	FCMOVBE
-	FCMOVE
-	FCMOVNB
-	FCMOVNBE
-	FCMOVNE
-	FCMOVNU
-	FCMOVU
-	FCOM
-	FCOMI
-	FCOMIP
-	FCOMP
-	FCOMPP
-	FCOS
-	FDECSTP
-	FDIV
-	FDIVP
-	FDIVR
-	FDIVRP
-	FFREE
-	FFREEP
-	FIADD
-	FICOM
-	FICOMP
-	FIDIV
-	FIDIVR
-	FILD
-	FIMUL
-	FINCSTP
-	FIST
-	FISTP
-	FISTTP
-	FISUB
-	FISUBR
-	FLD
-	FLD1
-	FLDCW
-	FLDENV
-	FLDL2E
-	FLDL2T
-	FLDLG2
-	FLDPI
-	FMUL
-	FMULP
-	FNCLEX
-	FNINIT
-	FNOP
-	FNSAVE
-	FNSTCW
-	FNSTENV
-	FNSTSW
-	FPATAN
-	FPREM
-	FPREM1
-	FPTAN
-	FRNDINT
-	FRSTOR
-	FSCALE
-	FSIN
-	FSINCOS
-	FSQRT
-	FST
-	FSTP
-	FSUB
-	FSUBP
-	FSUBR
-	FSUBRP
-	FTST
-	FUCOM
-	FUCOMI
-	FUCOMIP
-	FUCOMP
-	FUCOMPP
-	FWAIT
-	FXAM
-	FXCH
-	FXRSTOR
-	FXRSTOR64
-	FXSAVE
-	FXSAVE64
-	FXTRACT
-	FYL2X
-	FYL2XP1
-	HADDPD
-	HADDPS
-	HLT
-	HSUBPD
-	HSUBPS
-	ICEBP
-	IDIV
-	IMUL
-	IN
-	INC
-	INSB
-	INSD
-	INSERTPS
-	INSW
-	INT
-	INTO
-	INVD
-	INVLPG
-	INVPCID
-	IRET
-	IRETD
-	IRETQ
-	JA
-	JAE
-	JB
-	JBE
-	JCXZ
-	JE
-	JECXZ
-	JG
-	JGE
-	JL
-	JLE
-	JMP
-	JNE
-	JNO
-	JNP
-	JNS
-	JO
-	JP
-	JRCXZ
-	JS
-	LAHF
-	LAR
-	LCALL
-	LDDQU
-	LDMXCSR
-	LDS
-	LEA
-	LEAVE
-	LES
-	LFENCE
-	LFS
-	LGDT
-	LGS
-	LIDT
-	LJMP
-	LLDT
-	LMSW
-	LODSB
-	LODSD
-	LODSQ
-	LODSW
-	LOOP
-	LOOPE
-	LOOPNE
-	LRET
-	LSL
-	LSS
-	LTR
-	LZCNT
-	MASKMOVDQU
-	MASKMOVQ
-	MAXPD
-	MAXPS
-	MAXSD
-	MAXSS
-	MFENCE
-	MINPD
-	MINPS
-	MINSD
-	MINSS
-	MONITOR
-	MOV
-	MOVAPD
-	MOVAPS
-	MOVBE
-	MOVD
-	MOVDDUP
-	MOVDQ2Q
-	MOVDQA
-	MOVDQU
-	MOVHLPS
-	MOVHPD
-	MOVHPS
-	MOVLHPS
-	MOVLPD
-	MOVLPS
-	MOVMSKPD
-	MOVMSKPS
-	MOVNTDQ
-	MOVNTDQA
-	MOVNTI
-	MOVNTPD
-	MOVNTPS
-	MOVNTQ
-	MOVNTSD
-	MOVNTSS
-	MOVQ
-	MOVQ2DQ
-	MOVSB
-	MOVSD
-	MOVSD_XMM
-	MOVSHDUP
-	MOVSLDUP
-	MOVSQ
-	MOVSS
-	MOVSW
-	MOVSX
-	MOVSXD
-	MOVUPD
-	MOVUPS
-	MOVZX
-	MPSADBW
-	MUL
-	MULPD
-	MULPS
-	MULSD
-	MULSS
-	MWAIT
-	NEG
-	NOP
-	NOT
-	OR
-	ORPD
-	ORPS
-	OUT
-	OUTSB
-	OUTSD
-	OUTSW
-	PABSB
-	PABSD
-	PABSW
-	PACKSSDW
-	PACKSSWB
-	PACKUSDW
-	PACKUSWB
-	PADDB
-	PADDD
-	PADDQ
-	PADDSB
-	PADDSW
-	PADDUSB
-	PADDUSW
-	PADDW
-	PALIGNR
-	PAND
-	PANDN
-	PAUSE
-	PAVGB
-	PAVGW
-	PBLENDVB
-	PBLENDW
-	PCLMULQDQ
-	PCMPEQB
-	PCMPEQD
-	PCMPEQQ
-	PCMPEQW
-	PCMPESTRI
-	PCMPESTRM
-	PCMPGTB
-	PCMPGTD
-	PCMPGTQ
-	PCMPGTW
-	PCMPISTRI
-	PCMPISTRM
-	PEXTRB
-	PEXTRD
-	PEXTRQ
-	PEXTRW
-	PHADDD
-	PHADDSW
-	PHADDW
-	PHMINPOSUW
-	PHSUBD
-	PHSUBSW
-	PHSUBW
-	PINSRB
-	PINSRD
-	PINSRQ
-	PINSRW
-	PMADDUBSW
-	PMADDWD
-	PMAXSB
-	PMAXSD
-	PMAXSW
-	PMAXUB
-	PMAXUD
-	PMAXUW
-	PMINSB
-	PMINSD
-	PMINSW
-	PMINUB
-	PMINUD
-	PMINUW
-	PMOVMSKB
-	PMOVSXBD
-	PMOVSXBQ
-	PMOVSXBW
-	PMOVSXDQ
-	PMOVSXWD
-	PMOVSXWQ
-	PMOVZXBD
-	PMOVZXBQ
-	PMOVZXBW
-	PMOVZXDQ
-	PMOVZXWD
-	PMOVZXWQ
-	PMULDQ
-	PMULHRSW
-	PMULHUW
-	PMULHW
-	PMULLD
-	PMULLW
-	PMULUDQ
-	POP
-	POPA
-	POPAD
-	POPCNT
-	POPF
-	POPFD
-	POPFQ
-	POR
-	PREFETCHNTA
-	PREFETCHT0
-	PREFETCHT1
-	PREFETCHT2
-	PREFETCHW
-	PSADBW
-	PSHUFB
-	PSHUFD
-	PSHUFHW
-	PSHUFLW
-	PSHUFW
-	PSIGNB
-	PSIGND
-	PSIGNW
-	PSLLD
-	PSLLDQ
-	PSLLQ
-	PSLLW
-	PSRAD
-	PSRAW
-	PSRLD
-	PSRLDQ
-	PSRLQ
-	PSRLW
-	PSUBB
-	PSUBD
-	PSUBQ
-	PSUBSB
-	PSUBSW
-	PSUBUSB
-	PSUBUSW
-	PSUBW
-	PTEST
-	PUNPCKHBW
-	PUNPCKHDQ
-	PUNPCKHQDQ
-	PUNPCKHWD
-	PUNPCKLBW
-	PUNPCKLDQ
-	PUNPCKLQDQ
-	PUNPCKLWD
-	PUSH
-	PUSHA
-	PUSHAD
-	PUSHF
-	PUSHFD
-	PUSHFQ
-	PXOR
-	RCL
-	RCPPS
-	RCPSS
-	RCR
-	RDFSBASE
-	RDGSBASE
-	RDMSR
-	RDPMC
-	RDRAND
-	RDTSC
-	RDTSCP
-	RET
-	ROL
-	ROR
-	ROUNDPD
-	ROUNDPS
-	ROUNDSD
-	ROUNDSS
-	RSM
-	RSQRTPS
-	RSQRTSS
-	SAHF
-	SAR
-	SBB
-	SCASB
-	SCASD
-	SCASQ
-	SCASW
-	SETA
-	SETAE
-	SETB
-	SETBE
-	SETE
-	SETG
-	SETGE
-	SETL
-	SETLE
-	SETNE
-	SETNO
-	SETNP
-	SETNS
-	SETO
-	SETP
-	SETS
-	SFENCE
-	SGDT
-	SHL
-	SHLD
-	SHR
-	SHRD
-	SHUFPD
-	SHUFPS
-	SIDT
-	SLDT
-	SMSW
-	SQRTPD
-	SQRTPS
-	SQRTSD
-	SQRTSS
-	STC
-	STD
-	STI
-	STMXCSR
-	STOSB
-	STOSD
-	STOSQ
-	STOSW
-	STR
-	SUB
-	SUBPD
-	SUBPS
-	SUBSD
-	SUBSS
-	SWAPGS
-	SYSCALL
-	SYSENTER
-	SYSEXIT
-	SYSRET
-	TEST
-	TZCNT
-	UCOMISD
-	UCOMISS
-	UD1
-	UD2
-	UNPCKHPD
-	UNPCKHPS
-	UNPCKLPD
-	UNPCKLPS
-	VERR
-	VERW
-	VMOVDQA
-	VMOVDQU
-	VMOVNTDQ
-	VMOVNTDQA
-	VZEROUPPER
-	WBINVD
-	WRFSBASE
-	WRGSBASE
-	WRMSR
-	XABORT
-	XADD
-	XBEGIN
-	XCHG
-	XEND
-	XGETBV
-	XLATB
-	XOR
-	XORPD
-	XORPS
-	XRSTOR
-	XRSTOR64
-	XRSTORS
-	XRSTORS64
-	XSAVE
-	XSAVE64
-	XSAVEC
-	XSAVEC64
-	XSAVEOPT
-	XSAVEOPT64
-	XSAVES
-	XSAVES64
-	XSETBV
-	XTEST
-)
-
-const maxOp = XTEST
-
-var opNames = [...]string{
-	AAA:             "AAA",
-	AAD:             "AAD",
-	AAM:             "AAM",
-	AAS:             "AAS",
-	ADC:             "ADC",
-	ADD:             "ADD",
-	ADDPD:           "ADDPD",
-	ADDPS:           "ADDPS",
-	ADDSD:           "ADDSD",
-	ADDSS:           "ADDSS",
-	ADDSUBPD:        "ADDSUBPD",
-	ADDSUBPS:        "ADDSUBPS",
-	AESDEC:          "AESDEC",
-	AESDECLAST:      "AESDECLAST",
-	AESENC:          "AESENC",
-	AESENCLAST:      "AESENCLAST",
-	AESIMC:          "AESIMC",
-	AESKEYGENASSIST: "AESKEYGENASSIST",
-	AND:             "AND",
-	ANDNPD:          "ANDNPD",
-	ANDNPS:          "ANDNPS",
-	ANDPD:           "ANDPD",
-	ANDPS:           "ANDPS",
-	ARPL:            "ARPL",
-	BLENDPD:         "BLENDPD",
-	BLENDPS:         "BLENDPS",
-	BLENDVPD:        "BLENDVPD",
-	BLENDVPS:        "BLENDVPS",
-	BOUND:           "BOUND",
-	BSF:             "BSF",
-	BSR:             "BSR",
-	BSWAP:           "BSWAP",
-	BT:              "BT",
-	BTC:             "BTC",
-	BTR:             "BTR",
-	BTS:             "BTS",
-	CALL:            "CALL",
-	CBW:             "CBW",
-	CDQ:             "CDQ",
-	CDQE:            "CDQE",
-	CLC:             "CLC",
-	CLD:             "CLD",
-	CLFLUSH:         "CLFLUSH",
-	CLI:             "CLI",
-	CLTS:            "CLTS",
-	CMC:             "CMC",
-	CMOVA:           "CMOVA",
-	CMOVAE:          "CMOVAE",
-	CMOVB:           "CMOVB",
-	CMOVBE:          "CMOVBE",
-	CMOVE:           "CMOVE",
-	CMOVG:           "CMOVG",
-	CMOVGE:          "CMOVGE",
-	CMOVL:           "CMOVL",
-	CMOVLE:          "CMOVLE",
-	CMOVNE:          "CMOVNE",
-	CMOVNO:          "CMOVNO",
-	CMOVNP:          "CMOVNP",
-	CMOVNS:          "CMOVNS",
-	CMOVO:           "CMOVO",
-	CMOVP:           "CMOVP",
-	CMOVS:           "CMOVS",
-	CMP:             "CMP",
-	CMPPD:           "CMPPD",
-	CMPPS:           "CMPPS",
-	CMPSB:           "CMPSB",
-	CMPSD:           "CMPSD",
-	CMPSD_XMM:       "CMPSD_XMM",
-	CMPSQ:           "CMPSQ",
-	CMPSS:           "CMPSS",
-	CMPSW:           "CMPSW",
-	CMPXCHG:         "CMPXCHG",
-	CMPXCHG16B:      "CMPXCHG16B",
-	CMPXCHG8B:       "CMPXCHG8B",
-	COMISD:          "COMISD",
-	COMISS:          "COMISS",
-	CPUID:           "CPUID",
-	CQO:             "CQO",
-	CRC32:           "CRC32",
-	CVTDQ2PD:        "CVTDQ2PD",
-	CVTDQ2PS:        "CVTDQ2PS",
-	CVTPD2DQ:        "CVTPD2DQ",
-	CVTPD2PI:        "CVTPD2PI",
-	CVTPD2PS:        "CVTPD2PS",
-	CVTPI2PD:        "CVTPI2PD",
-	CVTPI2PS:        "CVTPI2PS",
-	CVTPS2DQ:        "CVTPS2DQ",
-	CVTPS2PD:        "CVTPS2PD",
-	CVTPS2PI:        "CVTPS2PI",
-	CVTSD2SI:        "CVTSD2SI",
-	CVTSD2SS:        "CVTSD2SS",
-	CVTSI2SD:        "CVTSI2SD",
-	CVTSI2SS:        "CVTSI2SS",
-	CVTSS2SD:        "CVTSS2SD",
-	CVTSS2SI:        "CVTSS2SI",
-	CVTTPD2DQ:       "CVTTPD2DQ",
-	CVTTPD2PI:       "CVTTPD2PI",
-	CVTTPS2DQ:       "CVTTPS2DQ",
-	CVTTPS2PI:       "CVTTPS2PI",
-	CVTTSD2SI:       "CVTTSD2SI",
-	CVTTSS2SI:       "CVTTSS2SI",
-	CWD:             "CWD",
-	CWDE:            "CWDE",
-	DAA:             "DAA",
-	DAS:             "DAS",
-	DEC:             "DEC",
-	DIV:             "DIV",
-	DIVPD:           "DIVPD",
-	DIVPS:           "DIVPS",
-	DIVSD:           "DIVSD",
-	DIVSS:           "DIVSS",
-	DPPD:            "DPPD",
-	DPPS:            "DPPS",
-	EMMS:            "EMMS",
-	ENTER:           "ENTER",
-	EXTRACTPS:       "EXTRACTPS",
-	F2XM1:           "F2XM1",
-	FABS:            "FABS",
-	FADD:            "FADD",
-	FADDP:           "FADDP",
-	FBLD:            "FBLD",
-	FBSTP:           "FBSTP",
-	FCHS:            "FCHS",
-	FCMOVB:          "FCMOVB",
-	FCMOVBE:         "FCMOVBE",
-	FCMOVE:          "FCMOVE",
-	FCMOVNB:         "FCMOVNB",
-	FCMOVNBE:        "FCMOVNBE",
-	FCMOVNE:         "FCMOVNE",
-	FCMOVNU:         "FCMOVNU",
-	FCMOVU:          "FCMOVU",
-	FCOM:            "FCOM",
-	FCOMI:           "FCOMI",
-	FCOMIP:          "FCOMIP",
-	FCOMP:           "FCOMP",
-	FCOMPP:          "FCOMPP",
-	FCOS:            "FCOS",
-	FDECSTP:         "FDECSTP",
-	FDIV:            "FDIV",
-	FDIVP:           "FDIVP",
-	FDIVR:           "FDIVR",
-	FDIVRP:          "FDIVRP",
-	FFREE:           "FFREE",
-	FFREEP:          "FFREEP",
-	FIADD:           "FIADD",
-	FICOM:           "FICOM",
-	FICOMP:          "FICOMP",
-	FIDIV:           "FIDIV",
-	FIDIVR:          "FIDIVR",
-	FILD:            "FILD",
-	FIMUL:           "FIMUL",
-	FINCSTP:         "FINCSTP",
-	FIST:            "FIST",
-	FISTP:           "FISTP",
-	FISTTP:          "FISTTP",
-	FISUB:           "FISUB",
-	FISUBR:          "FISUBR",
-	FLD:             "FLD",
-	FLD1:            "FLD1",
-	FLDCW:           "FLDCW",
-	FLDENV:          "FLDENV",
-	FLDL2E:          "FLDL2E",
-	FLDL2T:          "FLDL2T",
-	FLDLG2:          "FLDLG2",
-	FLDPI:           "FLDPI",
-	FMUL:            "FMUL",
-	FMULP:           "FMULP",
-	FNCLEX:          "FNCLEX",
-	FNINIT:          "FNINIT",
-	FNOP:            "FNOP",
-	FNSAVE:          "FNSAVE",
-	FNSTCW:          "FNSTCW",
-	FNSTENV:         "FNSTENV",
-	FNSTSW:          "FNSTSW",
-	FPATAN:          "FPATAN",
-	FPREM:           "FPREM",
-	FPREM1:          "FPREM1",
-	FPTAN:           "FPTAN",
-	FRNDINT:         "FRNDINT",
-	FRSTOR:          "FRSTOR",
-	FSCALE:          "FSCALE",
-	FSIN:            "FSIN",
-	FSINCOS:         "FSINCOS",
-	FSQRT:           "FSQRT",
-	FST:             "FST",
-	FSTP:            "FSTP",
-	FSUB:            "FSUB",
-	FSUBP:           "FSUBP",
-	FSUBR:           "FSUBR",
-	FSUBRP:          "FSUBRP",
-	FTST:            "FTST",
-	FUCOM:           "FUCOM",
-	FUCOMI:          "FUCOMI",
-	FUCOMIP:         "FUCOMIP",
-	FUCOMP:          "FUCOMP",
-	FUCOMPP:         "FUCOMPP",
-	FWAIT:           "FWAIT",
-	FXAM:            "FXAM",
-	FXCH:            "FXCH",
-	FXRSTOR:         "FXRSTOR",
-	FXRSTOR64:       "FXRSTOR64",
-	FXSAVE:          "FXSAVE",
-	FXSAVE64:        "FXSAVE64",
-	FXTRACT:         "FXTRACT",
-	FYL2X:           "FYL2X",
-	FYL2XP1:         "FYL2XP1",
-	HADDPD:          "HADDPD",
-	HADDPS:          "HADDPS",
-	HLT:             "HLT",
-	HSUBPD:          "HSUBPD",
-	HSUBPS:          "HSUBPS",
-	ICEBP:           "ICEBP",
-	IDIV:            "IDIV",
-	IMUL:            "IMUL",
-	IN:              "IN",
-	INC:             "INC",
-	INSB:            "INSB",
-	INSD:            "INSD",
-	INSERTPS:        "INSERTPS",
-	INSW:            "INSW",
-	INT:             "INT",
-	INTO:            "INTO",
-	INVD:            "INVD",
-	INVLPG:          "INVLPG",
-	INVPCID:         "INVPCID",
-	IRET:            "IRET",
-	IRETD:           "IRETD",
-	IRETQ:           "IRETQ",
-	JA:              "JA",
-	JAE:             "JAE",
-	JB:              "JB",
-	JBE:             "JBE",
-	JCXZ:            "JCXZ",
-	JE:              "JE",
-	JECXZ:           "JECXZ",
-	JG:              "JG",
-	JGE:             "JGE",
-	JL:              "JL",
-	JLE:             "JLE",
-	JMP:             "JMP",
-	JNE:             "JNE",
-	JNO:             "JNO",
-	JNP:             "JNP",
-	JNS:             "JNS",
-	JO:              "JO",
-	JP:              "JP",
-	JRCXZ:           "JRCXZ",
-	JS:              "JS",
-	LAHF:            "LAHF",
-	LAR:             "LAR",
-	LCALL:           "LCALL",
-	LDDQU:           "LDDQU",
-	LDMXCSR:         "LDMXCSR",
-	LDS:             "LDS",
-	LEA:             "LEA",
-	LEAVE:           "LEAVE",
-	LES:             "LES",
-	LFENCE:          "LFENCE",
-	LFS:             "LFS",
-	LGDT:            "LGDT",
-	LGS:             "LGS",
-	LIDT:            "LIDT",
-	LJMP:            "LJMP",
-	LLDT:            "LLDT",
-	LMSW:            "LMSW",
-	LODSB:           "LODSB",
-	LODSD:           "LODSD",
-	LODSQ:           "LODSQ",
-	LODSW:           "LODSW",
-	LOOP:            "LOOP",
-	LOOPE:           "LOOPE",
-	LOOPNE:          "LOOPNE",
-	LRET:            "LRET",
-	LSL:             "LSL",
-	LSS:             "LSS",
-	LTR:             "LTR",
-	LZCNT:           "LZCNT",
-	MASKMOVDQU:      "MASKMOVDQU",
-	MASKMOVQ:        "MASKMOVQ",
-	MAXPD:           "MAXPD",
-	MAXPS:           "MAXPS",
-	MAXSD:           "MAXSD",
-	MAXSS:           "MAXSS",
-	MFENCE:          "MFENCE",
-	MINPD:           "MINPD",
-	MINPS:           "MINPS",
-	MINSD:           "MINSD",
-	MINSS:           "MINSS",
-	MONITOR:         "MONITOR",
-	MOV:             "MOV",
-	MOVAPD:          "MOVAPD",
-	MOVAPS:          "MOVAPS",
-	MOVBE:           "MOVBE",
-	MOVD:            "MOVD",
-	MOVDDUP:         "MOVDDUP",
-	MOVDQ2Q:         "MOVDQ2Q",
-	MOVDQA:          "MOVDQA",
-	MOVDQU:          "MOVDQU",
-	MOVHLPS:         "MOVHLPS",
-	MOVHPD:          "MOVHPD",
-	MOVHPS:          "MOVHPS",
-	MOVLHPS:         "MOVLHPS",
-	MOVLPD:          "MOVLPD",
-	MOVLPS:          "MOVLPS",
-	MOVMSKPD:        "MOVMSKPD",
-	MOVMSKPS:        "MOVMSKPS",
-	MOVNTDQ:         "MOVNTDQ",
-	MOVNTDQA:        "MOVNTDQA",
-	MOVNTI:          "MOVNTI",
-	MOVNTPD:         "MOVNTPD",
-	MOVNTPS:         "MOVNTPS",
-	MOVNTQ:          "MOVNTQ",
-	MOVNTSD:         "MOVNTSD",
-	MOVNTSS:         "MOVNTSS",
-	MOVQ:            "MOVQ",
-	MOVQ2DQ:         "MOVQ2DQ",
-	MOVSB:           "MOVSB",
-	MOVSD:           "MOVSD",
-	MOVSD_XMM:       "MOVSD_XMM",
-	MOVSHDUP:        "MOVSHDUP",
-	MOVSLDUP:        "MOVSLDUP",
-	MOVSQ:           "MOVSQ",
-	MOVSS:           "MOVSS",
-	MOVSW:           "MOVSW",
-	MOVSX:           "MOVSX",
-	MOVSXD:          "MOVSXD",
-	MOVUPD:          "MOVUPD",
-	MOVUPS:          "MOVUPS",
-	MOVZX:           "MOVZX",
-	MPSADBW:         "MPSADBW",
-	MUL:             "MUL",
-	MULPD:           "MULPD",
-	MULPS:           "MULPS",
-	MULSD:           "MULSD",
-	MULSS:           "MULSS",
-	MWAIT:           "MWAIT",
-	NEG:             "NEG",
-	NOP:             "NOP",
-	NOT:             "NOT",
-	OR:              "OR",
-	ORPD:            "ORPD",
-	ORPS:            "ORPS",
-	OUT:             "OUT",
-	OUTSB:           "OUTSB",
-	OUTSD:           "OUTSD",
-	OUTSW:           "OUTSW",
-	PABSB:           "PABSB",
-	PABSD:           "PABSD",
-	PABSW:           "PABSW",
-	PACKSSDW:        "PACKSSDW",
-	PACKSSWB:        "PACKSSWB",
-	PACKUSDW:        "PACKUSDW",
-	PACKUSWB:        "PACKUSWB",
-	PADDB:           "PADDB",
-	PADDD:           "PADDD",
-	PADDQ:           "PADDQ",
-	PADDSB:          "PADDSB",
-	PADDSW:          "PADDSW",
-	PADDUSB:         "PADDUSB",
-	PADDUSW:         "PADDUSW",
-	PADDW:           "PADDW",
-	PALIGNR:         "PALIGNR",
-	PAND:            "PAND",
-	PANDN:           "PANDN",
-	PAUSE:           "PAUSE",
-	PAVGB:           "PAVGB",
-	PAVGW:           "PAVGW",
-	PBLENDVB:        "PBLENDVB",
-	PBLENDW:         "PBLENDW",
-	PCLMULQDQ:       "PCLMULQDQ",
-	PCMPEQB:         "PCMPEQB",
-	PCMPEQD:         "PCMPEQD",
-	PCMPEQQ:         "PCMPEQQ",
-	PCMPEQW:         "PCMPEQW",
-	PCMPESTRI:       "PCMPESTRI",
-	PCMPESTRM:       "PCMPESTRM",
-	PCMPGTB:         "PCMPGTB",
-	PCMPGTD:         "PCMPGTD",
-	PCMPGTQ:         "PCMPGTQ",
-	PCMPGTW:         "PCMPGTW",
-	PCMPISTRI:       "PCMPISTRI",
-	PCMPISTRM:       "PCMPISTRM",
-	PEXTRB:          "PEXTRB",
-	PEXTRD:          "PEXTRD",
-	PEXTRQ:          "PEXTRQ",
-	PEXTRW:          "PEXTRW",
-	PHADDD:          "PHADDD",
-	PHADDSW:         "PHADDSW",
-	PHADDW:          "PHADDW",
-	PHMINPOSUW:      "PHMINPOSUW",
-	PHSUBD:          "PHSUBD",
-	PHSUBSW:         "PHSUBSW",
-	PHSUBW:          "PHSUBW",
-	PINSRB:          "PINSRB",
-	PINSRD:          "PINSRD",
-	PINSRQ:          "PINSRQ",
-	PINSRW:          "PINSRW",
-	PMADDUBSW:       "PMADDUBSW",
-	PMADDWD:         "PMADDWD",
-	PMAXSB:          "PMAXSB",
-	PMAXSD:          "PMAXSD",
-	PMAXSW:          "PMAXSW",
-	PMAXUB:          "PMAXUB",
-	PMAXUD:          "PMAXUD",
-	PMAXUW:          "PMAXUW",
-	PMINSB:          "PMINSB",
-	PMINSD:          "PMINSD",
-	PMINSW:          "PMINSW",
-	PMINUB:          "PMINUB",
-	PMINUD:          "PMINUD",
-	PMINUW:          "PMINUW",
-	PMOVMSKB:        "PMOVMSKB",
-	PMOVSXBD:        "PMOVSXBD",
-	PMOVSXBQ:        "PMOVSXBQ",
-	PMOVSXBW:        "PMOVSXBW",
-	PMOVSXDQ:        "PMOVSXDQ",
-	PMOVSXWD:        "PMOVSXWD",
-	PMOVSXWQ:        "PMOVSXWQ",
-	PMOVZXBD:        "PMOVZXBD",
-	PMOVZXBQ:        "PMOVZXBQ",
-	PMOVZXBW:        "PMOVZXBW",
-	PMOVZXDQ:        "PMOVZXDQ",
-	PMOVZXWD:        "PMOVZXWD",
-	PMOVZXWQ:        "PMOVZXWQ",
-	PMULDQ:          "PMULDQ",
-	PMULHRSW:        "PMULHRSW",
-	PMULHUW:         "PMULHUW",
-	PMULHW:          "PMULHW",
-	PMULLD:          "PMULLD",
-	PMULLW:          "PMULLW",
-	PMULUDQ:         "PMULUDQ",
-	POP:             "POP",
-	POPA:            "POPA",
-	POPAD:           "POPAD",
-	POPCNT:          "POPCNT",
-	POPF:            "POPF",
-	POPFD:           "POPFD",
-	POPFQ:           "POPFQ",
-	POR:             "POR",
-	PREFETCHNTA:     "PREFETCHNTA",
-	PREFETCHT0:      "PREFETCHT0",
-	PREFETCHT1:      "PREFETCHT1",
-	PREFETCHT2:      "PREFETCHT2",
-	PREFETCHW:       "PREFETCHW",
-	PSADBW:          "PSADBW",
-	PSHUFB:          "PSHUFB",
-	PSHUFD:          "PSHUFD",
-	PSHUFHW:         "PSHUFHW",
-	PSHUFLW:         "PSHUFLW",
-	PSHUFW:          "PSHUFW",
-	PSIGNB:          "PSIGNB",
-	PSIGND:          "PSIGND",
-	PSIGNW:          "PSIGNW",
-	PSLLD:           "PSLLD",
-	PSLLDQ:          "PSLLDQ",
-	PSLLQ:           "PSLLQ",
-	PSLLW:           "PSLLW",
-	PSRAD:           "PSRAD",
-	PSRAW:           "PSRAW",
-	PSRLD:           "PSRLD",
-	PSRLDQ:          "PSRLDQ",
-	PSRLQ:           "PSRLQ",
-	PSRLW:           "PSRLW",
-	PSUBB:           "PSUBB",
-	PSUBD:           "PSUBD",
-	PSUBQ:           "PSUBQ",
-	PSUBSB:          "PSUBSB",
-	PSUBSW:          "PSUBSW",
-	PSUBUSB:         "PSUBUSB",
-	PSUBUSW:         "PSUBUSW",
-	PSUBW:           "PSUBW",
-	PTEST:           "PTEST",
-	PUNPCKHBW:       "PUNPCKHBW",
-	PUNPCKHDQ:       "PUNPCKHDQ",
-	PUNPCKHQDQ:      "PUNPCKHQDQ",
-	PUNPCKHWD:       "PUNPCKHWD",
-	PUNPCKLBW:       "PUNPCKLBW",
-	PUNPCKLDQ:       "PUNPCKLDQ",
-	PUNPCKLQDQ:      "PUNPCKLQDQ",
-	PUNPCKLWD:       "PUNPCKLWD",
-	PUSH:            "PUSH",
-	PUSHA:           "PUSHA",
-	PUSHAD:          "PUSHAD",
-	PUSHF:           "PUSHF",
-	PUSHFD:          "PUSHFD",
-	PUSHFQ:          "PUSHFQ",
-	PXOR:            "PXOR",
-	RCL:             "RCL",
-	RCPPS:           "RCPPS",
-	RCPSS:           "RCPSS",
-	RCR:             "RCR",
-	RDFSBASE:        "RDFSBASE",
-	RDGSBASE:        "RDGSBASE",
-	RDMSR:           "RDMSR",
-	RDPMC:           "RDPMC",
-	RDRAND:          "RDRAND",
-	RDTSC:           "RDTSC",
-	RDTSCP:          "RDTSCP",
-	RET:             "RET",
-	ROL:             "ROL",
-	ROR:             "ROR",
-	ROUNDPD:         "ROUNDPD",
-	ROUNDPS:         "ROUNDPS",
-	ROUNDSD:         "ROUNDSD",
-	ROUNDSS:         "ROUNDSS",
-	RSM:             "RSM",
-	RSQRTPS:         "RSQRTPS",
-	RSQRTSS:         "RSQRTSS",
-	SAHF:            "SAHF",
-	SAR:             "SAR",
-	SBB:             "SBB",
-	SCASB:           "SCASB",
-	SCASD:           "SCASD",
-	SCASQ:           "SCASQ",
-	SCASW:           "SCASW",
-	SETA:            "SETA",
-	SETAE:           "SETAE",
-	SETB:            "SETB",
-	SETBE:           "SETBE",
-	SETE:            "SETE",
-	SETG:            "SETG",
-	SETGE:           "SETGE",
-	SETL:            "SETL",
-	SETLE:           "SETLE",
-	SETNE:           "SETNE",
-	SETNO:           "SETNO",
-	SETNP:           "SETNP",
-	SETNS:           "SETNS",
-	SETO:            "SETO",
-	SETP:            "SETP",
-	SETS:            "SETS",
-	SFENCE:          "SFENCE",
-	SGDT:            "SGDT",
-	SHL:             "SHL",
-	SHLD:            "SHLD",
-	SHR:             "SHR",
-	SHRD:            "SHRD",
-	SHUFPD:          "SHUFPD",
-	SHUFPS:          "SHUFPS",
-	SIDT:            "SIDT",
-	SLDT:            "SLDT",
-	SMSW:            "SMSW",
-	SQRTPD:          "SQRTPD",
-	SQRTPS:          "SQRTPS",
-	SQRTSD:          "SQRTSD",
-	SQRTSS:          "SQRTSS",
-	STC:             "STC",
-	STD:             "STD",
-	STI:             "STI",
-	STMXCSR:         "STMXCSR",
-	STOSB:           "STOSB",
-	STOSD:           "STOSD",
-	STOSQ:           "STOSQ",
-	STOSW:           "STOSW",
-	STR:             "STR",
-	SUB:             "SUB",
-	SUBPD:           "SUBPD",
-	SUBPS:           "SUBPS",
-	SUBSD:           "SUBSD",
-	SUBSS:           "SUBSS",
-	SWAPGS:          "SWAPGS",
-	SYSCALL:         "SYSCALL",
-	SYSENTER:        "SYSENTER",
-	SYSEXIT:         "SYSEXIT",
-	SYSRET:          "SYSRET",
-	TEST:            "TEST",
-	TZCNT:           "TZCNT",
-	UCOMISD:         "UCOMISD",
-	UCOMISS:         "UCOMISS",
-	UD1:             "UD1",
-	UD2:             "UD2",
-	UNPCKHPD:        "UNPCKHPD",
-	UNPCKHPS:        "UNPCKHPS",
-	UNPCKLPD:        "UNPCKLPD",
-	UNPCKLPS:        "UNPCKLPS",
-	VERR:            "VERR",
-	VERW:            "VERW",
-	VMOVDQA:         "VMOVDQA",
-	VMOVDQU:         "VMOVDQU",
-	VMOVNTDQ:        "VMOVNTDQ",
-	VMOVNTDQA:       "VMOVNTDQA",
-	VZEROUPPER:      "VZEROUPPER",
-	WBINVD:          "WBINVD",
-	WRFSBASE:        "WRFSBASE",
-	WRGSBASE:        "WRGSBASE",
-	WRMSR:           "WRMSR",
-	XABORT:          "XABORT",
-	XADD:            "XADD",
-	XBEGIN:          "XBEGIN",
-	XCHG:            "XCHG",
-	XEND:            "XEND",
-	XGETBV:          "XGETBV",
-	XLATB:           "XLATB",
-	XOR:             "XOR",
-	XORPD:           "XORPD",
-	XORPS:           "XORPS",
-	XRSTOR:          "XRSTOR",
-	XRSTOR64:        "XRSTOR64",
-	XRSTORS:         "XRSTORS",
-	XRSTORS64:       "XRSTORS64",
-	XSAVE:           "XSAVE",
-	XSAVE64:         "XSAVE64",
-	XSAVEC:          "XSAVEC",
-	XSAVEC64:        "XSAVEC64",
-	XSAVEOPT:        "XSAVEOPT",
-	XSAVEOPT64:      "XSAVEOPT64",
-	XSAVES:          "XSAVES",
-	XSAVES64:        "XSAVES64",
-	XSETBV:          "XSETBV",
-	XTEST:           "XTEST",
-}