...
▽

Package x86_64

import "github.com/chenzhuoyu/iasm/x86_64"
Overview
Index

Overview ▾

Index ▾

Constants
Variables
type AddressType
type Addressable
    func (self *Addressable) String() string
type Arch
    func CreateArch() *Arch
    func (self *Arch) CreateProgram() *Program
    func (self *Arch) DisableISA(isa ISA) *Arch
    func (self *Arch) EnableISA(isa ISA) *Arch
    func (self *Arch) HasISA(isa ISA) bool
type Assembler
    func (self *Assembler) Assemble(src string) error
    func (self *Assembler) Base() uintptr
    func (self *Assembler) Code() []byte
    func (self *Assembler) Entry() uintptr
    func (self *Assembler) Options() *Options
    func (self *Assembler) WithBase(pc uintptr) *Assembler
type Disposable
type ExceptionControl
    func (ExceptionControl) String() string
type ISA
    func ParseISA(name string) ISA
    func (self ISA) String() string
type Instruction
    func (self *Instruction) CS() *Instruction
    func (self *Instruction) DS() *Instruction
    func (self *Instruction) Domain() InstructionDomain
    func (self *Instruction) ES() *Instruction
    func (self *Instruction) FS() *Instruction
    func (self *Instruction) GS() *Instruction
    func (self *Instruction) LOCK() *Instruction
    func (self *Instruction) Name() string
    func (self *Instruction) Operands() []interface{}
    func (self *Instruction) SS() *Instruction
type InstructionDomain
type InstructionPrefix
type KRegister
    func (self KRegister) String() string
type Label
    func CreateLabel(name string) *Label
    func (self *Label) Evaluate() (int64, error)
    func (self *Label) Free()
    func (self *Label) Retain() *Label
    func (self *Label) String() string
type LabelKind
type LineKind
type MMRegister
    func (self MMRegister) String() string
type MaskedRegister
    func (self MaskedRegister) String() string
type MemoryAddress
    func (self *MemoryAddress) EnsureValid()
    func (self *MemoryAddress) String() string
type MemoryOperand
    func Abs(disp int32) *MemoryOperand
    func CreateMemoryOperand() *MemoryOperand
    func Ptr(base Register, disp int32) *MemoryOperand
    func Ref(ref *Label) (v *MemoryOperand)
    func Sib(base Register, index Register, scale uint8, disp int32) (v *MemoryOperand)
    func (self *MemoryOperand) EnsureValid()
    func (self *MemoryOperand) Free()
    func (self *MemoryOperand) Retain() *MemoryOperand
    func (self *MemoryOperand) String() string
type OperandKind
type Operands
type Options
type ParsedCommand
type ParsedCommandArg
type ParsedInstruction
type ParsedLabel
type ParsedLine
type ParsedOperand
type Parser
    func (self *Parser) Directive(line string) (err error)
    func (self *Parser) Feed(src string) (ret *ParsedLine, err error)
    func (self *Parser) Parse(src string) (ret []*ParsedLine, err error)
type Program
    func (self *Program) ADCB(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) ADCL(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) ADCQ(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) ADCW(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) ADCXL(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) ADCXQ(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) ADDB(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) ADDL(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) ADDPD(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) ADDPS(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) ADDQ(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) ADDSD(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) ADDSS(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) ADDSUBPD(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) ADDSUBPS(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) ADDW(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) ADOXL(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) ADOXQ(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) AESDEC(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) AESDECLAST(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) AESENC(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) AESENCLAST(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) AESIMC(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) AESKEYGENASSIST(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) ANDB(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) ANDL(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) ANDNL(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) ANDNPD(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) ANDNPS(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) ANDNQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) ANDPD(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) ANDPS(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) ANDQ(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) ANDW(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) Align(align uint64, padding *expr.Expr) (p *Instruction)
    func (self *Program) Assemble(pc uintptr) (ret []byte)
    func (self *Program) AssembleAndFree(pc uintptr) (ret []byte)
    func (self *Program) BEXTR(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) BLCFILL(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) BLCI(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) BLCIC(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) BLCMSK(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) BLCS(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) BLENDPD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) BLENDPS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) BLENDVPD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) BLENDVPS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) BLSFILL(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) BLSI(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) BLSIC(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) BLSMSK(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) BLSR(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) BSFL(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) BSFQ(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) BSFW(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) BSRL(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) BSRQ(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) BSRW(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) BSWAPL(v0 interface{}) *Instruction
    func (self *Program) BSWAPQ(v0 interface{}) *Instruction
    func (self *Program) BTCL(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) BTCQ(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) BTCW(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) BTL(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) BTQ(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) BTRL(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) BTRQ(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) BTRW(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) BTSL(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) BTSQ(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) BTSW(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) BTW(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) BZHI(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) Byte(v *expr.Expr) (p *Instruction)
    func (self *Program) CALL(v0 interface{}) *Instruction
    func (self *Program) CALLQ(v0 interface{}) *Instruction
    func (self *Program) CBTW() *Instruction
    func (self *Program) CLC() *Instruction
    func (self *Program) CLD() *Instruction
    func (self *Program) CLFLUSH(v0 interface{}) *Instruction
    func (self *Program) CLFLUSHOPT(v0 interface{}) *Instruction
    func (self *Program) CLTD() *Instruction
    func (self *Program) CLTQ() *Instruction
    func (self *Program) CLWB(v0 interface{}) *Instruction
    func (self *Program) CLZERO() *Instruction
    func (self *Program) CMC() *Instruction
    func (self *Program) CMOVA(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) CMOVAE(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) CMOVB(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) CMOVBE(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) CMOVC(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) CMOVE(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) CMOVG(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) CMOVGE(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) CMOVL(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) CMOVLE(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) CMOVNA(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) CMOVNAE(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) CMOVNB(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) CMOVNBE(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) CMOVNC(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) CMOVNE(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) CMOVNG(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) CMOVNGE(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) CMOVNL(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) CMOVNLE(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) CMOVNO(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) CMOVNP(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) CMOVNS(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) CMOVNZ(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) CMOVO(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) CMOVP(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) CMOVPE(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) CMOVPO(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) CMOVS(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) CMOVZ(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) CMPB(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) CMPL(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) CMPPD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) CMPPS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) CMPQ(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) CMPSD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) CMPSS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) CMPW(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) CMPXCHG16B(v0 interface{}) *Instruction
    func (self *Program) CMPXCHG8B(v0 interface{}) *Instruction
    func (self *Program) CMPXCHGB(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) CMPXCHGL(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) CMPXCHGQ(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) CMPXCHGW(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) COMISD(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) COMISS(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) CPUID() *Instruction
    func (self *Program) CQTO() *Instruction
    func (self *Program) CRC32B(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) CRC32L(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) CRC32Q(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) CRC32W(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) CVTDQ2PD(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) CVTDQ2PS(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) CVTPD2DQ(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) CVTPD2PI(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) CVTPD2PS(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) CVTPI2PD(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) CVTPI2PS(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) CVTPS2DQ(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) CVTPS2PD(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) CVTPS2PI(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) CVTSD2SI(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) CVTSD2SS(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) CVTSI2SD(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) CVTSI2SS(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) CVTSS2SD(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) CVTSS2SI(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) CVTTPD2DQ(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) CVTTPD2PI(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) CVTTPS2DQ(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) CVTTPS2PI(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) CVTTSD2SI(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) CVTTSS2SI(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) CWTD() *Instruction
    func (self *Program) CWTL() *Instruction
    func (self *Program) DECB(v0 interface{}) *Instruction
    func (self *Program) DECL(v0 interface{}) *Instruction
    func (self *Program) DECQ(v0 interface{}) *Instruction
    func (self *Program) DECW(v0 interface{}) *Instruction
    func (self *Program) DIVB(v0 interface{}) *Instruction
    func (self *Program) DIVL(v0 interface{}) *Instruction
    func (self *Program) DIVPD(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) DIVPS(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) DIVQ(v0 interface{}) *Instruction
    func (self *Program) DIVSD(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) DIVSS(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) DIVW(v0 interface{}) *Instruction
    func (self *Program) DPPD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) DPPS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) Data(v []byte) (p *Instruction)
    func (self *Program) EMMS() *Instruction
    func (self *Program) EXTRACTPS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) EXTRQ(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
    func (self *Program) FEMMS() *Instruction
    func (self *Program) Free()
    func (self *Program) HADDPD(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) HADDPS(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) HSUBPD(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) HSUBPS(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) IDIVB(v0 interface{}) *Instruction
    func (self *Program) IDIVL(v0 interface{}) *Instruction
    func (self *Program) IDIVQ(v0 interface{}) *Instruction
    func (self *Program) IDIVW(v0 interface{}) *Instruction
    func (self *Program) IMULB(v0 interface{}) *Instruction
    func (self *Program) IMULL(v0 interface{}, vv ...interface{}) *Instruction
    func (self *Program) IMULQ(v0 interface{}, vv ...interface{}) *Instruction
    func (self *Program) IMULW(v0 interface{}, vv ...interface{}) *Instruction
    func (self *Program) INCB(v0 interface{}) *Instruction
    func (self *Program) INCL(v0 interface{}) *Instruction
    func (self *Program) INCQ(v0 interface{}) *Instruction
    func (self *Program) INCW(v0 interface{}) *Instruction
    func (self *Program) INSERTPS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) INSERTQ(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
    func (self *Program) INT(v0 interface{}) *Instruction
    func (self *Program) JA(v0 interface{}) *Instruction
    func (self *Program) JAE(v0 interface{}) *Instruction
    func (self *Program) JB(v0 interface{}) *Instruction
    func (self *Program) JBE(v0 interface{}) *Instruction
    func (self *Program) JC(v0 interface{}) *Instruction
    func (self *Program) JE(v0 interface{}) *Instruction
    func (self *Program) JECXZ(v0 interface{}) *Instruction
    func (self *Program) JG(v0 interface{}) *Instruction
    func (self *Program) JGE(v0 interface{}) *Instruction
    func (self *Program) JL(v0 interface{}) *Instruction
    func (self *Program) JLE(v0 interface{}) *Instruction
    func (self *Program) JMP(v0 interface{}) *Instruction
    func (self *Program) JMPQ(v0 interface{}) *Instruction
    func (self *Program) JNA(v0 interface{}) *Instruction
    func (self *Program) JNAE(v0 interface{}) *Instruction
    func (self *Program) JNB(v0 interface{}) *Instruction
    func (self *Program) JNBE(v0 interface{}) *Instruction
    func (self *Program) JNC(v0 interface{}) *Instruction
    func (self *Program) JNE(v0 interface{}) *Instruction
    func (self *Program) JNG(v0 interface{}) *Instruction
    func (self *Program) JNGE(v0 interface{}) *Instruction
    func (self *Program) JNL(v0 interface{}) *Instruction
    func (self *Program) JNLE(v0 interface{}) *Instruction
    func (self *Program) JNO(v0 interface{}) *Instruction
    func (self *Program) JNP(v0 interface{}) *Instruction
    func (self *Program) JNS(v0 interface{}) *Instruction
    func (self *Program) JNZ(v0 interface{}) *Instruction
    func (self *Program) JO(v0 interface{}) *Instruction
    func (self *Program) JP(v0 interface{}) *Instruction
    func (self *Program) JPE(v0 interface{}) *Instruction
    func (self *Program) JPO(v0 interface{}) *Instruction
    func (self *Program) JRCXZ(v0 interface{}) *Instruction
    func (self *Program) JS(v0 interface{}) *Instruction
    func (self *Program) JZ(v0 interface{}) *Instruction
    func (self *Program) KADDB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) KADDD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) KADDQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) KADDW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) KANDB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) KANDD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) KANDNB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) KANDND(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) KANDNQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) KANDNW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) KANDQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) KANDW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) KMOVB(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) KMOVD(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) KMOVQ(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) KMOVW(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) KNOTB(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) KNOTD(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) KNOTQ(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) KNOTW(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) KORB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) KORD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) KORQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) KORTESTB(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) KORTESTD(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) KORTESTQ(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) KORTESTW(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) KORW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) KSHIFTLB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) KSHIFTLD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) KSHIFTLQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) KSHIFTLW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) KSHIFTRB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) KSHIFTRD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) KSHIFTRQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) KSHIFTRW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) KTESTB(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) KTESTD(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) KTESTQ(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) KTESTW(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) KUNPCKBW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) KUNPCKDQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) KUNPCKWD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) KXNORB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) KXNORD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) KXNORQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) KXNORW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) KXORB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) KXORD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) KXORQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) KXORW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) LDDQU(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) LDMXCSR(v0 interface{}) *Instruction
    func (self *Program) LEAL(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) LEAQ(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) LEAW(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) LFENCE() *Instruction
    func (self *Program) LZCNTL(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) LZCNTQ(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) LZCNTW(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) Link(p *Label)
    func (self *Program) Long(v *expr.Expr) (p *Instruction)
    func (self *Program) MASKMOVDQU(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) MASKMOVQ(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) MAXPD(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) MAXPS(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) MAXSD(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) MAXSS(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) MFENCE() *Instruction
    func (self *Program) MINPD(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) MINPS(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) MINSD(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) MINSS(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) MONITOR() *Instruction
    func (self *Program) MONITORX() *Instruction
    func (self *Program) MOVAPD(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) MOVAPS(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) MOVB(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) MOVBEL(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) MOVBEQ(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) MOVBEW(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) MOVD(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) MOVDDUP(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) MOVDQ2Q(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) MOVDQA(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) MOVDQU(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) MOVHLPS(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) MOVHPD(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) MOVHPS(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) MOVL(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) MOVLHPS(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) MOVLPD(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) MOVLPS(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) MOVMSKPD(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) MOVMSKPS(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) MOVNTDQ(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) MOVNTDQA(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) MOVNTIL(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) MOVNTIQ(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) MOVNTPD(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) MOVNTPS(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) MOVNTQ(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) MOVNTSD(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) MOVNTSS(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) MOVQ(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) MOVQ2DQ(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) MOVSBL(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) MOVSBQ(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) MOVSBW(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) MOVSD(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) MOVSHDUP(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) MOVSLDUP(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) MOVSLQ(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) MOVSS(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) MOVSWL(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) MOVSWQ(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) MOVUPD(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) MOVUPS(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) MOVW(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) MOVZBL(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) MOVZBQ(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) MOVZBW(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) MOVZWL(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) MOVZWQ(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) MPSADBW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) MULB(v0 interface{}) *Instruction
    func (self *Program) MULL(v0 interface{}) *Instruction
    func (self *Program) MULPD(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) MULPS(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) MULQ(v0 interface{}) *Instruction
    func (self *Program) MULSD(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) MULSS(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) MULW(v0 interface{}) *Instruction
    func (self *Program) MULXL(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) MULXQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) MWAIT() *Instruction
    func (self *Program) MWAITX() *Instruction
    func (self *Program) NEGB(v0 interface{}) *Instruction
    func (self *Program) NEGL(v0 interface{}) *Instruction
    func (self *Program) NEGQ(v0 interface{}) *Instruction
    func (self *Program) NEGW(v0 interface{}) *Instruction
    func (self *Program) NOP() *Instruction
    func (self *Program) NOTB(v0 interface{}) *Instruction
    func (self *Program) NOTL(v0 interface{}) *Instruction
    func (self *Program) NOTQ(v0 interface{}) *Instruction
    func (self *Program) NOTW(v0 interface{}) *Instruction
    func (self *Program) ORB(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) ORL(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) ORPD(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) ORPS(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) ORQ(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) ORW(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) PABSB(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) PABSD(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) PABSW(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) PACKSSDW(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) PACKSSWB(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) PACKUSDW(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) PACKUSWB(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) PADDB(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) PADDD(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) PADDQ(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) PADDSB(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) PADDSW(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) PADDUSB(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) PADDUSW(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) PADDW(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) PALIGNR(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) PAND(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) PANDN(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) PAUSE() *Instruction
    func (self *Program) PAVGB(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) PAVGUSB(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) PAVGW(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) PBLENDVB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) PBLENDW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) PCLMULQDQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) PCMPEQB(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) PCMPEQD(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) PCMPEQQ(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) PCMPEQW(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) PCMPESTRI(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) PCMPESTRM(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) PCMPGTB(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) PCMPGTD(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) PCMPGTQ(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) PCMPGTW(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) PCMPISTRI(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) PCMPISTRM(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) PDEP(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) PEXT(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) PEXTRB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) PEXTRD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) PEXTRQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) PEXTRW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) PF2ID(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) PF2IW(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) PFACC(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) PFADD(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) PFCMPEQ(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) PFCMPGE(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) PFCMPGT(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) PFMAX(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) PFMIN(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) PFMUL(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) PFNACC(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) PFPNACC(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) PFRCP(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) PFRCPIT1(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) PFRCPIT2(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) PFRSQIT1(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) PFRSQRT(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) PFSUB(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) PFSUBR(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) PHADDD(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) PHADDSW(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) PHADDW(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) PHMINPOSUW(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) PHSUBD(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) PHSUBSW(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) PHSUBW(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) PI2FD(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) PI2FW(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) PINSRB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) PINSRD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) PINSRQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) PINSRW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) PMADDUBSW(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) PMADDWD(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) PMAXSB(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) PMAXSD(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) PMAXSW(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) PMAXUB(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) PMAXUD(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) PMAXUW(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) PMINSB(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) PMINSD(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) PMINSW(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) PMINUB(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) PMINUD(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) PMINUW(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) PMOVMSKB(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) PMOVSXBD(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) PMOVSXBQ(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) PMOVSXBW(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) PMOVSXDQ(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) PMOVSXWD(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) PMOVSXWQ(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) PMOVZXBD(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) PMOVZXBQ(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) PMOVZXBW(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) PMOVZXDQ(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) PMOVZXWD(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) PMOVZXWQ(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) PMULDQ(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) PMULHRSW(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) PMULHRW(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) PMULHUW(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) PMULHW(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) PMULLD(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) PMULLW(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) PMULUDQ(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) POPCNTL(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) POPCNTQ(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) POPCNTW(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) POPQ(v0 interface{}) *Instruction
    func (self *Program) POPW(v0 interface{}) *Instruction
    func (self *Program) POR(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) PREFETCH(v0 interface{}) *Instruction
    func (self *Program) PREFETCHNTA(v0 interface{}) *Instruction
    func (self *Program) PREFETCHT0(v0 interface{}) *Instruction
    func (self *Program) PREFETCHT1(v0 interface{}) *Instruction
    func (self *Program) PREFETCHT2(v0 interface{}) *Instruction
    func (self *Program) PREFETCHW(v0 interface{}) *Instruction
    func (self *Program) PREFETCHWT1(v0 interface{}) *Instruction
    func (self *Program) PSADBW(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) PSHUFB(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) PSHUFD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) PSHUFHW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) PSHUFLW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) PSHUFW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) PSIGNB(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) PSIGND(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) PSIGNW(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) PSLLD(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) PSLLDQ(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) PSLLQ(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) PSLLW(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) PSRAD(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) PSRAW(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) PSRLD(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) PSRLDQ(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) PSRLQ(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) PSRLW(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) PSUBB(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) PSUBD(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) PSUBQ(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) PSUBSB(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) PSUBSW(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) PSUBUSB(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) PSUBUSW(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) PSUBW(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) PSWAPD(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) PTEST(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) PUNPCKHBW(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) PUNPCKHDQ(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) PUNPCKHQDQ(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) PUNPCKHWD(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) PUNPCKLBW(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) PUNPCKLDQ(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) PUNPCKLQDQ(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) PUNPCKLWD(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) PUSHQ(v0 interface{}) *Instruction
    func (self *Program) PUSHW(v0 interface{}) *Instruction
    func (self *Program) PXOR(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) Quad(v *expr.Expr) (p *Instruction)
    func (self *Program) RCLB(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) RCLL(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) RCLQ(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) RCLW(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) RCPPS(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) RCPSS(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) RCRB(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) RCRL(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) RCRQ(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) RCRW(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) RDRAND(v0 interface{}) *Instruction
    func (self *Program) RDSEED(v0 interface{}) *Instruction
    func (self *Program) RDTSC() *Instruction
    func (self *Program) RDTSCP() *Instruction
    func (self *Program) RET(vv ...interface{}) *Instruction
    func (self *Program) ROLB(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) ROLL(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) ROLQ(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) ROLW(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) RORB(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) RORL(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) RORQ(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) RORW(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) RORXL(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) RORXQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) ROUNDPD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) ROUNDPS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) ROUNDSD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) ROUNDSS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) RSQRTPS(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) RSQRTSS(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) SALB(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) SALL(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) SALQ(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) SALW(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) SARB(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) SARL(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) SARQ(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) SARW(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) SARXL(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) SARXQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) SBBB(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) SBBL(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) SBBQ(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) SBBW(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) SETA(v0 interface{}) *Instruction
    func (self *Program) SETAE(v0 interface{}) *Instruction
    func (self *Program) SETB(v0 interface{}) *Instruction
    func (self *Program) SETBE(v0 interface{}) *Instruction
    func (self *Program) SETC(v0 interface{}) *Instruction
    func (self *Program) SETE(v0 interface{}) *Instruction
    func (self *Program) SETG(v0 interface{}) *Instruction
    func (self *Program) SETGE(v0 interface{}) *Instruction
    func (self *Program) SETL(v0 interface{}) *Instruction
    func (self *Program) SETLE(v0 interface{}) *Instruction
    func (self *Program) SETNA(v0 interface{}) *Instruction
    func (self *Program) SETNAE(v0 interface{}) *Instruction
    func (self *Program) SETNB(v0 interface{}) *Instruction
    func (self *Program) SETNBE(v0 interface{}) *Instruction
    func (self *Program) SETNC(v0 interface{}) *Instruction
    func (self *Program) SETNE(v0 interface{}) *Instruction
    func (self *Program) SETNG(v0 interface{}) *Instruction
    func (self *Program) SETNGE(v0 interface{}) *Instruction
    func (self *Program) SETNL(v0 interface{}) *Instruction
    func (self *Program) SETNLE(v0 interface{}) *Instruction
    func (self *Program) SETNO(v0 interface{}) *Instruction
    func (self *Program) SETNP(v0 interface{}) *Instruction
    func (self *Program) SETNS(v0 interface{}) *Instruction
    func (self *Program) SETNZ(v0 interface{}) *Instruction
    func (self *Program) SETO(v0 interface{}) *Instruction
    func (self *Program) SETP(v0 interface{}) *Instruction
    func (self *Program) SETPE(v0 interface{}) *Instruction
    func (self *Program) SETPO(v0 interface{}) *Instruction
    func (self *Program) SETS(v0 interface{}) *Instruction
    func (self *Program) SETZ(v0 interface{}) *Instruction
    func (self *Program) SFENCE() *Instruction
    func (self *Program) SHA1MSG1(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) SHA1MSG2(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) SHA1NEXTE(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) SHA1RNDS4(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) SHA256MSG1(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) SHA256MSG2(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) SHA256RNDS2(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) SHLB(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) SHLDL(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) SHLDQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) SHLDW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) SHLL(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) SHLQ(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) SHLW(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) SHLXL(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) SHLXQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) SHRB(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) SHRDL(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) SHRDQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) SHRDW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) SHRL(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) SHRQ(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) SHRW(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) SHRXL(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) SHRXQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) SHUFPD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) SHUFPS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) SQRTPD(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) SQRTPS(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) SQRTSD(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) SQRTSS(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) STC() *Instruction
    func (self *Program) STD() *Instruction
    func (self *Program) STMXCSR(v0 interface{}) *Instruction
    func (self *Program) SUBB(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) SUBL(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) SUBPD(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) SUBPS(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) SUBQ(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) SUBSD(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) SUBSS(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) SUBW(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) SYSCALL() *Instruction
    func (self *Program) T1MSKC(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) TESTB(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) TESTL(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) TESTQ(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) TESTW(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) TZCNTL(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) TZCNTQ(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) TZCNTW(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) TZMSK(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) UCOMISD(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) UCOMISS(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) UD2() *Instruction
    func (self *Program) UNPCKHPD(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) UNPCKHPS(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) UNPCKLPD(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) UNPCKLPS(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) VADDPD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VADDPS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VADDSD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VADDSS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VADDSUBPD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VADDSUBPS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VAESDEC(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VAESDECLAST(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VAESENC(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VAESENCLAST(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VAESIMC(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) VAESKEYGENASSIST(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VALIGND(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
    func (self *Program) VALIGNQ(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
    func (self *Program) VANDNPD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VANDNPS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VANDPD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VANDPS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VBLENDMPD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VBLENDMPS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VBLENDPD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
    func (self *Program) VBLENDPS(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
    func (self *Program) VBLENDVPD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
    func (self *Program) VBLENDVPS(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
    func (self *Program) VBROADCASTF128(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) VBROADCASTF32X2(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) VBROADCASTF32X4(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) VBROADCASTF32X8(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) VBROADCASTF64X2(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) VBROADCASTF64X4(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) VBROADCASTI128(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) VBROADCASTI32X2(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) VBROADCASTI32X4(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) VBROADCASTI32X8(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) VBROADCASTI64X2(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) VBROADCASTI64X4(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) VBROADCASTSD(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) VBROADCASTSS(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) VCMPPD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VCMPPS(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VCMPSD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VCMPSS(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VCOMISD(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VCOMISS(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VCOMPRESSPD(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) VCOMPRESSPS(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) VCVTDQ2PD(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) VCVTDQ2PS(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VCVTPD2DQ(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VCVTPD2PS(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VCVTPD2QQ(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VCVTPD2UDQ(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VCVTPD2UQQ(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VCVTPH2PS(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VCVTPS2DQ(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VCVTPS2PD(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VCVTPS2PH(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VCVTPS2QQ(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VCVTPS2UDQ(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VCVTPS2UQQ(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VCVTQQ2PD(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VCVTQQ2PS(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VCVTSD2SI(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VCVTSD2SS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VCVTSD2USI(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VCVTSI2SD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VCVTSI2SS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VCVTSS2SD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VCVTSS2SI(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VCVTSS2USI(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VCVTTPD2DQ(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VCVTTPD2QQ(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VCVTTPD2UDQ(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VCVTTPD2UQQ(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VCVTTPS2DQ(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VCVTTPS2QQ(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VCVTTPS2UDQ(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VCVTTPS2UQQ(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VCVTTSD2SI(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VCVTTSD2USI(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VCVTTSS2SI(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VCVTTSS2USI(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VCVTUDQ2PD(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) VCVTUDQ2PS(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VCVTUQQ2PD(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VCVTUQQ2PS(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VCVTUSI2SD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VCVTUSI2SS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VDBPSADBW(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
    func (self *Program) VDIVPD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VDIVPS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VDIVSD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VDIVSS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VDPPD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
    func (self *Program) VDPPS(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
    func (self *Program) VEXP2PD(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VEXP2PS(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VEXPANDPD(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) VEXPANDPS(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) VEXTRACTF128(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VEXTRACTF32X4(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VEXTRACTF32X8(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VEXTRACTF64X2(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VEXTRACTF64X4(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VEXTRACTI128(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VEXTRACTI32X4(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VEXTRACTI32X8(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VEXTRACTI64X2(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VEXTRACTI64X4(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VEXTRACTPS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VFIXUPIMMPD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VFIXUPIMMPS(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VFIXUPIMMSD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VFIXUPIMMSS(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VFMADD132PD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VFMADD132PS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VFMADD132SD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VFMADD132SS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VFMADD213PD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VFMADD213PS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VFMADD213SD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VFMADD213SS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VFMADD231PD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VFMADD231PS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VFMADD231SD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VFMADD231SS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VFMADDPD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
    func (self *Program) VFMADDPS(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
    func (self *Program) VFMADDSD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
    func (self *Program) VFMADDSS(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
    func (self *Program) VFMADDSUB132PD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VFMADDSUB132PS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VFMADDSUB213PD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VFMADDSUB213PS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VFMADDSUB231PD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VFMADDSUB231PS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VFMADDSUBPD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
    func (self *Program) VFMADDSUBPS(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
    func (self *Program) VFMSUB132PD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VFMSUB132PS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VFMSUB132SD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VFMSUB132SS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VFMSUB213PD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VFMSUB213PS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VFMSUB213SD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VFMSUB213SS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VFMSUB231PD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VFMSUB231PS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VFMSUB231SD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VFMSUB231SS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VFMSUBADD132PD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VFMSUBADD132PS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VFMSUBADD213PD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VFMSUBADD213PS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VFMSUBADD231PD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VFMSUBADD231PS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VFMSUBADDPD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
    func (self *Program) VFMSUBADDPS(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
    func (self *Program) VFMSUBPD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
    func (self *Program) VFMSUBPS(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
    func (self *Program) VFMSUBSD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
    func (self *Program) VFMSUBSS(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
    func (self *Program) VFNMADD132PD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VFNMADD132PS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VFNMADD132SD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VFNMADD132SS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VFNMADD213PD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VFNMADD213PS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VFNMADD213SD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VFNMADD213SS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VFNMADD231PD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VFNMADD231PS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VFNMADD231SD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VFNMADD231SS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VFNMADDPD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
    func (self *Program) VFNMADDPS(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
    func (self *Program) VFNMADDSD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
    func (self *Program) VFNMADDSS(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
    func (self *Program) VFNMSUB132PD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VFNMSUB132PS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VFNMSUB132SD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VFNMSUB132SS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VFNMSUB213PD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VFNMSUB213PS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VFNMSUB213SD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VFNMSUB213SS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VFNMSUB231PD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VFNMSUB231PS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VFNMSUB231SD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VFNMSUB231SS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VFNMSUBPD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
    func (self *Program) VFNMSUBPS(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
    func (self *Program) VFNMSUBSD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
    func (self *Program) VFNMSUBSS(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
    func (self *Program) VFPCLASSPD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VFPCLASSPS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VFPCLASSSD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VFPCLASSSS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VFRCZPD(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) VFRCZPS(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) VFRCZSD(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) VFRCZSS(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) VGATHERDPD(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VGATHERDPS(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VGATHERPF0DPD(v0 interface{}) *Instruction
    func (self *Program) VGATHERPF0DPS(v0 interface{}) *Instruction
    func (self *Program) VGATHERPF0QPD(v0 interface{}) *Instruction
    func (self *Program) VGATHERPF0QPS(v0 interface{}) *Instruction
    func (self *Program) VGATHERPF1DPD(v0 interface{}) *Instruction
    func (self *Program) VGATHERPF1DPS(v0 interface{}) *Instruction
    func (self *Program) VGATHERPF1QPD(v0 interface{}) *Instruction
    func (self *Program) VGATHERPF1QPS(v0 interface{}) *Instruction
    func (self *Program) VGATHERQPD(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VGATHERQPS(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VGETEXPPD(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VGETEXPPS(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VGETEXPSD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VGETEXPSS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VGETMANTPD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VGETMANTPS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VGETMANTSD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VGETMANTSS(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VHADDPD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VHADDPS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VHSUBPD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VHSUBPS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VINSERTF128(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
    func (self *Program) VINSERTF32X4(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
    func (self *Program) VINSERTF32X8(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
    func (self *Program) VINSERTF64X2(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
    func (self *Program) VINSERTF64X4(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
    func (self *Program) VINSERTI128(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
    func (self *Program) VINSERTI32X4(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
    func (self *Program) VINSERTI32X8(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
    func (self *Program) VINSERTI64X2(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
    func (self *Program) VINSERTI64X4(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
    func (self *Program) VINSERTPS(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
    func (self *Program) VLDDQU(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) VLDMXCSR(v0 interface{}) *Instruction
    func (self *Program) VMASKMOVDQU(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) VMASKMOVPD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VMASKMOVPS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VMAXPD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VMAXPS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VMAXSD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VMAXSS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VMINPD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VMINPS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VMINSD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VMINSS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VMOVAPD(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) VMOVAPS(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) VMOVD(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) VMOVDDUP(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) VMOVDQA(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) VMOVDQA32(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) VMOVDQA64(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) VMOVDQU(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) VMOVDQU16(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) VMOVDQU32(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) VMOVDQU64(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) VMOVDQU8(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) VMOVHLPS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VMOVHPD(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VMOVHPS(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VMOVLHPS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VMOVLPD(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VMOVLPS(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VMOVMSKPD(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) VMOVMSKPS(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) VMOVNTDQ(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) VMOVNTDQA(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) VMOVNTPD(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) VMOVNTPS(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) VMOVQ(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) VMOVSD(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VMOVSHDUP(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) VMOVSLDUP(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) VMOVSS(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VMOVUPD(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) VMOVUPS(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) VMPSADBW(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
    func (self *Program) VMULPD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VMULPS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VMULSD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VMULSS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VORPD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VORPS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPABSB(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) VPABSD(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) VPABSQ(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) VPABSW(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) VPACKSSDW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPACKSSWB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPACKUSDW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPACKUSWB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPADDB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPADDD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPADDQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPADDSB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPADDSW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPADDUSB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPADDUSW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPADDW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPALIGNR(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
    func (self *Program) VPAND(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPANDD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPANDN(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPANDND(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPANDNQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPANDQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPAVGB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPAVGW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPBLENDD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
    func (self *Program) VPBLENDMB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPBLENDMD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPBLENDMQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPBLENDMW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPBLENDVB(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
    func (self *Program) VPBLENDW(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
    func (self *Program) VPBROADCASTB(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) VPBROADCASTD(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) VPBROADCASTMB2Q(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) VPBROADCASTMW2D(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) VPBROADCASTQ(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) VPBROADCASTW(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) VPCLMULQDQ(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
    func (self *Program) VPCMOV(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
    func (self *Program) VPCMPB(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
    func (self *Program) VPCMPD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
    func (self *Program) VPCMPEQB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPCMPEQD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPCMPEQQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPCMPEQW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPCMPESTRI(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPCMPESTRM(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPCMPGTB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPCMPGTD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPCMPGTQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPCMPGTW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPCMPISTRI(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPCMPISTRM(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPCMPQ(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
    func (self *Program) VPCMPUB(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
    func (self *Program) VPCMPUD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
    func (self *Program) VPCMPUQ(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
    func (self *Program) VPCMPUW(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
    func (self *Program) VPCMPW(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
    func (self *Program) VPCOMB(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
    func (self *Program) VPCOMD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
    func (self *Program) VPCOMPRESSD(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) VPCOMPRESSQ(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) VPCOMQ(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
    func (self *Program) VPCOMUB(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
    func (self *Program) VPCOMUD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
    func (self *Program) VPCOMUQ(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
    func (self *Program) VPCOMUW(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
    func (self *Program) VPCOMW(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
    func (self *Program) VPCONFLICTD(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) VPCONFLICTQ(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) VPERM2F128(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
    func (self *Program) VPERM2I128(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
    func (self *Program) VPERMB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPERMD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPERMI2B(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPERMI2D(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPERMI2PD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPERMI2PS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPERMI2Q(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPERMI2W(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPERMIL2PD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}, v4 interface{}) *Instruction
    func (self *Program) VPERMIL2PS(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}, v4 interface{}) *Instruction
    func (self *Program) VPERMILPD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPERMILPS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPERMPD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPERMPS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPERMQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPERMT2B(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPERMT2D(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPERMT2PD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPERMT2PS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPERMT2Q(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPERMT2W(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPERMW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPEXPANDD(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) VPEXPANDQ(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) VPEXTRB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPEXTRD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPEXTRQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPEXTRW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPGATHERDD(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VPGATHERDQ(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VPGATHERQD(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VPGATHERQQ(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VPHADDBD(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) VPHADDBQ(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) VPHADDBW(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) VPHADDD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPHADDDQ(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) VPHADDSW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPHADDUBD(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) VPHADDUBQ(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) VPHADDUBW(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) VPHADDUDQ(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) VPHADDUWD(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) VPHADDUWQ(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) VPHADDW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPHADDWD(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) VPHADDWQ(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) VPHMINPOSUW(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) VPHSUBBW(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) VPHSUBD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPHSUBDQ(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) VPHSUBSW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPHSUBW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPHSUBWD(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) VPINSRB(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
    func (self *Program) VPINSRD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
    func (self *Program) VPINSRQ(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
    func (self *Program) VPINSRW(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
    func (self *Program) VPLZCNTD(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) VPLZCNTQ(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) VPMACSDD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
    func (self *Program) VPMACSDQH(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
    func (self *Program) VPMACSDQL(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
    func (self *Program) VPMACSSDD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
    func (self *Program) VPMACSSDQH(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
    func (self *Program) VPMACSSDQL(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
    func (self *Program) VPMACSSWD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
    func (self *Program) VPMACSSWW(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
    func (self *Program) VPMACSWD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
    func (self *Program) VPMACSWW(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
    func (self *Program) VPMADCSSWD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
    func (self *Program) VPMADCSWD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
    func (self *Program) VPMADD52HUQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPMADD52LUQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPMADDUBSW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPMADDWD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPMASKMOVD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPMASKMOVQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPMAXSB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPMAXSD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPMAXSQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPMAXSW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPMAXUB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPMAXUD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPMAXUQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPMAXUW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPMINSB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPMINSD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPMINSQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPMINSW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPMINUB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPMINUD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPMINUQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPMINUW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPMOVB2M(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) VPMOVD2M(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) VPMOVDB(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) VPMOVDW(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) VPMOVM2B(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) VPMOVM2D(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) VPMOVM2Q(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) VPMOVM2W(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) VPMOVMSKB(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) VPMOVQ2M(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) VPMOVQB(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) VPMOVQD(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) VPMOVQW(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) VPMOVSDB(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) VPMOVSDW(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) VPMOVSQB(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) VPMOVSQD(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) VPMOVSQW(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) VPMOVSWB(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) VPMOVSXBD(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) VPMOVSXBQ(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) VPMOVSXBW(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) VPMOVSXDQ(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) VPMOVSXWD(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) VPMOVSXWQ(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) VPMOVUSDB(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) VPMOVUSDW(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) VPMOVUSQB(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) VPMOVUSQD(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) VPMOVUSQW(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) VPMOVUSWB(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) VPMOVW2M(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) VPMOVWB(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) VPMOVZXBD(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) VPMOVZXBQ(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) VPMOVZXBW(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) VPMOVZXDQ(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) VPMOVZXWD(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) VPMOVZXWQ(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) VPMULDQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPMULHRSW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPMULHUW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPMULHW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPMULLD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPMULLQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPMULLW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPMULTISHIFTQB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPMULUDQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPOPCNTD(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) VPOPCNTQ(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) VPOR(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPORD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPORQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPPERM(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
    func (self *Program) VPROLD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPROLQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPROLVD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPROLVQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPRORD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPRORQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPRORVD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPRORVQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPROTB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPROTD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPROTQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPROTW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPSADBW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPSCATTERDD(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) VPSCATTERDQ(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) VPSCATTERQD(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) VPSCATTERQQ(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) VPSHAB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPSHAD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPSHAQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPSHAW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPSHLB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPSHLD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPSHLQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPSHLW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPSHUFB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPSHUFD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPSHUFHW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPSHUFLW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPSIGNB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPSIGND(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPSIGNW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPSLLD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPSLLDQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPSLLQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPSLLVD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPSLLVQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPSLLVW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPSLLW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPSRAD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPSRAQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPSRAVD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPSRAVQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPSRAVW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPSRAW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPSRLD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPSRLDQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPSRLQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPSRLVD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPSRLVQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPSRLVW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPSRLW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPSUBB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPSUBD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPSUBQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPSUBSB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPSUBSW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPSUBUSB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPSUBUSW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPSUBW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPTERNLOGD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
    func (self *Program) VPTERNLOGQ(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
    func (self *Program) VPTEST(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) VPTESTMB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPTESTMD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPTESTMQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPTESTMW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPTESTNMB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPTESTNMD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPTESTNMQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPTESTNMW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPUNPCKHBW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPUNPCKHDQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPUNPCKHQDQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPUNPCKHWD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPUNPCKLBW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPUNPCKLDQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPUNPCKLQDQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPUNPCKLWD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPXOR(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPXORD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VPXORQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VRANGEPD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VRANGEPS(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VRANGESD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VRANGESS(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VRCP14PD(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) VRCP14PS(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) VRCP14SD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VRCP14SS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VRCP28PD(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VRCP28PS(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VRCP28SD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VRCP28SS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VRCPPS(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) VRCPSS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VREDUCEPD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VREDUCEPS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VREDUCESD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
    func (self *Program) VREDUCESS(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
    func (self *Program) VRNDSCALEPD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VRNDSCALEPS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VRNDSCALESD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VRNDSCALESS(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VROUNDPD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VROUNDPS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VROUNDSD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
    func (self *Program) VROUNDSS(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
    func (self *Program) VRSQRT14PD(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) VRSQRT14PS(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) VRSQRT14SD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VRSQRT14SS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VRSQRT28PD(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VRSQRT28PS(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VRSQRT28SD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VRSQRT28SS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VRSQRTPS(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) VRSQRTSS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VSCALEFPD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VSCALEFPS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VSCALEFSD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VSCALEFSS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VSCATTERDPD(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) VSCATTERDPS(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) VSCATTERPF0DPD(v0 interface{}) *Instruction
    func (self *Program) VSCATTERPF0DPS(v0 interface{}) *Instruction
    func (self *Program) VSCATTERPF0QPD(v0 interface{}) *Instruction
    func (self *Program) VSCATTERPF0QPS(v0 interface{}) *Instruction
    func (self *Program) VSCATTERPF1DPD(v0 interface{}) *Instruction
    func (self *Program) VSCATTERPF1DPS(v0 interface{}) *Instruction
    func (self *Program) VSCATTERPF1QPD(v0 interface{}) *Instruction
    func (self *Program) VSCATTERPF1QPS(v0 interface{}) *Instruction
    func (self *Program) VSCATTERQPD(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) VSCATTERQPS(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) VSHUFF32X4(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
    func (self *Program) VSHUFF64X2(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
    func (self *Program) VSHUFI32X4(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
    func (self *Program) VSHUFI64X2(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
    func (self *Program) VSHUFPD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
    func (self *Program) VSHUFPS(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
    func (self *Program) VSQRTPD(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VSQRTPS(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VSQRTSD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VSQRTSS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VSTMXCSR(v0 interface{}) *Instruction
    func (self *Program) VSUBPD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VSUBPS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VSUBSD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VSUBSS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VTESTPD(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) VTESTPS(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) VUCOMISD(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VUCOMISS(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
    func (self *Program) VUNPCKHPD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VUNPCKHPS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VUNPCKLPD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VUNPCKLPS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VXORPD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VXORPS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
    func (self *Program) VZEROALL() *Instruction
    func (self *Program) VZEROUPPER() *Instruction
    func (self *Program) Word(v *expr.Expr) (p *Instruction)
    func (self *Program) XADDB(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) XADDL(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) XADDQ(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) XADDW(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) XCHGB(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) XCHGL(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) XCHGQ(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) XCHGW(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) XGETBV() *Instruction
    func (self *Program) XLATB() *Instruction
    func (self *Program) XORB(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) XORL(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) XORPD(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) XORPS(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) XORQ(v0 interface{}, v1 interface{}) *Instruction
    func (self *Program) XORW(v0 interface{}, v1 interface{}) *Instruction
type Register
type Register16
    func (self Register16) String() string
type Register32
    func (self Register32) String() string
type Register64
    func (self Register64) String() string
type Register8
    func (self Register8) String() string
type RegisterMask
    func (self RegisterMask) String() string
type RelativeOffset
    func (self RelativeOffset) String() string
type RoundingControl
    func (self RoundingControl) String() string
type SyntaxError
    func (self *SyntaxError) Error() string
type XMMRegister
    func (self XMMRegister) String() string
type YMMRegister
    func (self YMMRegister) String() string
type ZMMRegister
    func (self ZMMRegister) String() string

Package files

arch.go assembler.go assembler_alias.go eface.go encodings.go instructions.go instructions_table.go operands.go pools.go program.go registers.go utils.go

Constants

const (
    AH = SPL | 0x80
    CH = BPL | 0x80
    DH = SIL | 0x80
    BH = DIL | 0x80
)

Variables

DefaultArch is the default architecture with all ISA enabled. 

var DefaultArch = CreateArch()

Instructions maps all the instruction name to it's encoder function. 

var Instructions = map[string]_InstructionEncoder{
    "adcb":             __asm_proxy_ADCB__,
    "adcl":             __asm_proxy_ADCL__,
    "adcq":             __asm_proxy_ADCQ__,
    "adcw":             __asm_proxy_ADCW__,
    "adcxl":            __asm_proxy_ADCXL__,
    "adcxq":            __asm_proxy_ADCXQ__,
    "addb":             __asm_proxy_ADDB__,
    "addl":             __asm_proxy_ADDL__,
    "addpd":            __asm_proxy_ADDPD__,
    "addps":            __asm_proxy_ADDPS__,
    "addq":             __asm_proxy_ADDQ__,
    "addsd":            __asm_proxy_ADDSD__,
    "addss":            __asm_proxy_ADDSS__,
    "addsubpd":         __asm_proxy_ADDSUBPD__,
    "addsubps":         __asm_proxy_ADDSUBPS__,
    "addw":             __asm_proxy_ADDW__,
    "adoxl":            __asm_proxy_ADOXL__,
    "adoxq":            __asm_proxy_ADOXQ__,
    "aesdec":           __asm_proxy_AESDEC__,
    "aesdeclast":       __asm_proxy_AESDECLAST__,
    "aesenc":           __asm_proxy_AESENC__,
    "aesenclast":       __asm_proxy_AESENCLAST__,
    "aesimc":           __asm_proxy_AESIMC__,
    "aeskeygenassist":  __asm_proxy_AESKEYGENASSIST__,
    "andb":             __asm_proxy_ANDB__,
    "andl":             __asm_proxy_ANDL__,
    "andnl":            __asm_proxy_ANDNL__,
    "andnpd":           __asm_proxy_ANDNPD__,
    "andnps":           __asm_proxy_ANDNPS__,
    "andnq":            __asm_proxy_ANDNQ__,
    "andpd":            __asm_proxy_ANDPD__,
    "andps":            __asm_proxy_ANDPS__,
    "andq":             __asm_proxy_ANDQ__,
    "andw":             __asm_proxy_ANDW__,
    "bextr":            __asm_proxy_BEXTR__,
    "blcfill":          __asm_proxy_BLCFILL__,
    "blci":             __asm_proxy_BLCI__,
    "blcic":            __asm_proxy_BLCIC__,
    "blcmsk":           __asm_proxy_BLCMSK__,
    "blcs":             __asm_proxy_BLCS__,
    "blendpd":          __asm_proxy_BLENDPD__,
    "blendps":          __asm_proxy_BLENDPS__,
    "blendvpd":         __asm_proxy_BLENDVPD__,
    "blendvps":         __asm_proxy_BLENDVPS__,
    "blsfill":          __asm_proxy_BLSFILL__,
    "blsi":             __asm_proxy_BLSI__,
    "blsic":            __asm_proxy_BLSIC__,
    "blsmsk":           __asm_proxy_BLSMSK__,
    "blsr":             __asm_proxy_BLSR__,
    "bsfl":             __asm_proxy_BSFL__,
    "bsfq":             __asm_proxy_BSFQ__,
    "bsfw":             __asm_proxy_BSFW__,
    "bsrl":             __asm_proxy_BSRL__,
    "bsrq":             __asm_proxy_BSRQ__,
    "bsrw":             __asm_proxy_BSRW__,
    "bswapl":           __asm_proxy_BSWAPL__,
    "bswapq":           __asm_proxy_BSWAPQ__,
    "btcl":             __asm_proxy_BTCL__,
    "btcq":             __asm_proxy_BTCQ__,
    "btcw":             __asm_proxy_BTCW__,
    "btl":              __asm_proxy_BTL__,
    "btq":              __asm_proxy_BTQ__,
    "btrl":             __asm_proxy_BTRL__,
    "btrq":             __asm_proxy_BTRQ__,
    "btrw":             __asm_proxy_BTRW__,
    "btsl":             __asm_proxy_BTSL__,
    "btsq":             __asm_proxy_BTSQ__,
    "btsw":             __asm_proxy_BTSW__,
    "btw":              __asm_proxy_BTW__,
    "bzhi":             __asm_proxy_BZHI__,
    "call":             __asm_proxy_CALL__,
    "callq":            __asm_proxy_CALLQ__,
    "cbtw":             __asm_proxy_CBTW__,
    "clc":              __asm_proxy_CLC__,
    "cld":              __asm_proxy_CLD__,
    "clflush":          __asm_proxy_CLFLUSH__,
    "clflushopt":       __asm_proxy_CLFLUSHOPT__,
    "cltd":             __asm_proxy_CLTD__,
    "cltq":             __asm_proxy_CLTQ__,
    "clwb":             __asm_proxy_CLWB__,
    "clzero":           __asm_proxy_CLZERO__,
    "cmc":              __asm_proxy_CMC__,
    "cmova":            __asm_proxy_CMOVA__,
    "cmovae":           __asm_proxy_CMOVAE__,
    "cmovb":            __asm_proxy_CMOVB__,
    "cmovbe":           __asm_proxy_CMOVBE__,
    "cmovc":            __asm_proxy_CMOVC__,
    "cmove":            __asm_proxy_CMOVE__,
    "cmovg":            __asm_proxy_CMOVG__,
    "cmovge":           __asm_proxy_CMOVGE__,
    "cmovl":            __asm_proxy_CMOVL__,
    "cmovle":           __asm_proxy_CMOVLE__,
    "cmovna":           __asm_proxy_CMOVNA__,
    "cmovnae":          __asm_proxy_CMOVNAE__,
    "cmovnb":           __asm_proxy_CMOVNB__,
    "cmovnbe":          __asm_proxy_CMOVNBE__,
    "cmovnc":           __asm_proxy_CMOVNC__,
    "cmovne":           __asm_proxy_CMOVNE__,
    "cmovng":           __asm_proxy_CMOVNG__,
    "cmovnge":          __asm_proxy_CMOVNGE__,
    "cmovnl":           __asm_proxy_CMOVNL__,
    "cmovnle":          __asm_proxy_CMOVNLE__,
    "cmovno":           __asm_proxy_CMOVNO__,
    "cmovnp":           __asm_proxy_CMOVNP__,
    "cmovns":           __asm_proxy_CMOVNS__,
    "cmovnz":           __asm_proxy_CMOVNZ__,
    "cmovo":            __asm_proxy_CMOVO__,
    "cmovp":            __asm_proxy_CMOVP__,
    "cmovpe":           __asm_proxy_CMOVPE__,
    "cmovpo":           __asm_proxy_CMOVPO__,
    "cmovs":            __asm_proxy_CMOVS__,
    "cmovz":            __asm_proxy_CMOVZ__,
    "cmpb":             __asm_proxy_CMPB__,
    "cmpl":             __asm_proxy_CMPL__,
    "cmppd":            __asm_proxy_CMPPD__,
    "cmpps":            __asm_proxy_CMPPS__,
    "cmpq":             __asm_proxy_CMPQ__,
    "cmpsd":            __asm_proxy_CMPSD__,
    "cmpss":            __asm_proxy_CMPSS__,
    "cmpw":             __asm_proxy_CMPW__,
    "cmpxchg16b":       __asm_proxy_CMPXCHG16B__,
    "cmpxchg8b":        __asm_proxy_CMPXCHG8B__,
    "cmpxchgb":         __asm_proxy_CMPXCHGB__,
    "cmpxchgl":         __asm_proxy_CMPXCHGL__,
    "cmpxchgq":         __asm_proxy_CMPXCHGQ__,
    "cmpxchgw":         __asm_proxy_CMPXCHGW__,
    "comisd":           __asm_proxy_COMISD__,
    "comiss":           __asm_proxy_COMISS__,
    "cpuid":            __asm_proxy_CPUID__,
    "cqto":             __asm_proxy_CQTO__,
    "crc32b":           __asm_proxy_CRC32B__,
    "crc32l":           __asm_proxy_CRC32L__,
    "crc32q":           __asm_proxy_CRC32Q__,
    "crc32w":           __asm_proxy_CRC32W__,
    "cvtdq2pd":         __asm_proxy_CVTDQ2PD__,
    "cvtdq2ps":         __asm_proxy_CVTDQ2PS__,
    "cvtpd2dq":         __asm_proxy_CVTPD2DQ__,
    "cvtpd2pi":         __asm_proxy_CVTPD2PI__,
    "cvtpd2ps":         __asm_proxy_CVTPD2PS__,
    "cvtpi2pd":         __asm_proxy_CVTPI2PD__,
    "cvtpi2ps":         __asm_proxy_CVTPI2PS__,
    "cvtps2dq":         __asm_proxy_CVTPS2DQ__,
    "cvtps2pd":         __asm_proxy_CVTPS2PD__,
    "cvtps2pi":         __asm_proxy_CVTPS2PI__,
    "cvtsd2si":         __asm_proxy_CVTSD2SI__,
    "cvtsd2ss":         __asm_proxy_CVTSD2SS__,
    "cvtsi2sd":         __asm_proxy_CVTSI2SD__,
    "cvtsi2ss":         __asm_proxy_CVTSI2SS__,
    "cvtss2sd":         __asm_proxy_CVTSS2SD__,
    "cvtss2si":         __asm_proxy_CVTSS2SI__,
    "cvttpd2dq":        __asm_proxy_CVTTPD2DQ__,
    "cvttpd2pi":        __asm_proxy_CVTTPD2PI__,
    "cvttps2dq":        __asm_proxy_CVTTPS2DQ__,
    "cvttps2pi":        __asm_proxy_CVTTPS2PI__,
    "cvttsd2si":        __asm_proxy_CVTTSD2SI__,
    "cvttss2si":        __asm_proxy_CVTTSS2SI__,
    "cwtd":             __asm_proxy_CWTD__,
    "cwtl":             __asm_proxy_CWTL__,
    "decb":             __asm_proxy_DECB__,
    "decl":             __asm_proxy_DECL__,
    "decq":             __asm_proxy_DECQ__,
    "decw":             __asm_proxy_DECW__,
    "divb":             __asm_proxy_DIVB__,
    "divl":             __asm_proxy_DIVL__,
    "divpd":            __asm_proxy_DIVPD__,
    "divps":            __asm_proxy_DIVPS__,
    "divq":             __asm_proxy_DIVQ__,
    "divsd":            __asm_proxy_DIVSD__,
    "divss":            __asm_proxy_DIVSS__,
    "divw":             __asm_proxy_DIVW__,
    "dppd":             __asm_proxy_DPPD__,
    "dpps":             __asm_proxy_DPPS__,
    "emms":             __asm_proxy_EMMS__,
    "extractps":        __asm_proxy_EXTRACTPS__,
    "extrq":            __asm_proxy_EXTRQ__,
    "femms":            __asm_proxy_FEMMS__,
    "haddpd":           __asm_proxy_HADDPD__,
    "haddps":           __asm_proxy_HADDPS__,
    "hsubpd":           __asm_proxy_HSUBPD__,
    "hsubps":           __asm_proxy_HSUBPS__,
    "idivb":            __asm_proxy_IDIVB__,
    "idivl":            __asm_proxy_IDIVL__,
    "idivq":            __asm_proxy_IDIVQ__,
    "idivw":            __asm_proxy_IDIVW__,
    "imulb":            __asm_proxy_IMULB__,
    "imull":            __asm_proxy_IMULL__,
    "imulq":            __asm_proxy_IMULQ__,
    "imulw":            __asm_proxy_IMULW__,
    "incb":             __asm_proxy_INCB__,
    "incl":             __asm_proxy_INCL__,
    "incq":             __asm_proxy_INCQ__,
    "incw":             __asm_proxy_INCW__,
    "insertps":         __asm_proxy_INSERTPS__,
    "insertq":          __asm_proxy_INSERTQ__,
    "int":              __asm_proxy_INT__,
    "ja":               __asm_proxy_JA__,
    "jae":              __asm_proxy_JAE__,
    "jb":               __asm_proxy_JB__,
    "jbe":              __asm_proxy_JBE__,
    "jc":               __asm_proxy_JC__,
    "je":               __asm_proxy_JE__,
    "jecxz":            __asm_proxy_JECXZ__,
    "jg":               __asm_proxy_JG__,
    "jge":              __asm_proxy_JGE__,
    "jl":               __asm_proxy_JL__,
    "jle":              __asm_proxy_JLE__,
    "jmp":              __asm_proxy_JMP__,
    "jmpq":             __asm_proxy_JMPQ__,
    "jna":              __asm_proxy_JNA__,
    "jnae":             __asm_proxy_JNAE__,
    "jnb":              __asm_proxy_JNB__,
    "jnbe":             __asm_proxy_JNBE__,
    "jnc":              __asm_proxy_JNC__,
    "jne":              __asm_proxy_JNE__,
    "jng":              __asm_proxy_JNG__,
    "jnge":             __asm_proxy_JNGE__,
    "jnl":              __asm_proxy_JNL__,
    "jnle":             __asm_proxy_JNLE__,
    "jno":              __asm_proxy_JNO__,
    "jnp":              __asm_proxy_JNP__,
    "jns":              __asm_proxy_JNS__,
    "jnz":              __asm_proxy_JNZ__,
    "jo":               __asm_proxy_JO__,
    "jp":               __asm_proxy_JP__,
    "jpe":              __asm_proxy_JPE__,
    "jpo":              __asm_proxy_JPO__,
    "jrcxz":            __asm_proxy_JRCXZ__,
    "js":               __asm_proxy_JS__,
    "jz":               __asm_proxy_JZ__,
    "kaddb":            __asm_proxy_KADDB__,
    "kaddd":            __asm_proxy_KADDD__,
    "kaddq":            __asm_proxy_KADDQ__,
    "kaddw":            __asm_proxy_KADDW__,
    "kandb":            __asm_proxy_KANDB__,
    "kandd":            __asm_proxy_KANDD__,
    "kandnb":           __asm_proxy_KANDNB__,
    "kandnd":           __asm_proxy_KANDND__,
    "kandnq":           __asm_proxy_KANDNQ__,
    "kandnw":           __asm_proxy_KANDNW__,
    "kandq":            __asm_proxy_KANDQ__,
    "kandw":            __asm_proxy_KANDW__,
    "kmovb":            __asm_proxy_KMOVB__,
    "kmovd":            __asm_proxy_KMOVD__,
    "kmovq":            __asm_proxy_KMOVQ__,
    "kmovw":            __asm_proxy_KMOVW__,
    "knotb":            __asm_proxy_KNOTB__,
    "knotd":            __asm_proxy_KNOTD__,
    "knotq":            __asm_proxy_KNOTQ__,
    "knotw":            __asm_proxy_KNOTW__,
    "korb":             __asm_proxy_KORB__,
    "kord":             __asm_proxy_KORD__,
    "korq":             __asm_proxy_KORQ__,
    "kortestb":         __asm_proxy_KORTESTB__,
    "kortestd":         __asm_proxy_KORTESTD__,
    "kortestq":         __asm_proxy_KORTESTQ__,
    "kortestw":         __asm_proxy_KORTESTW__,
    "korw":             __asm_proxy_KORW__,
    "kshiftlb":         __asm_proxy_KSHIFTLB__,
    "kshiftld":         __asm_proxy_KSHIFTLD__,
    "kshiftlq":         __asm_proxy_KSHIFTLQ__,
    "kshiftlw":         __asm_proxy_KSHIFTLW__,
    "kshiftrb":         __asm_proxy_KSHIFTRB__,
    "kshiftrd":         __asm_proxy_KSHIFTRD__,
    "kshiftrq":         __asm_proxy_KSHIFTRQ__,
    "kshiftrw":         __asm_proxy_KSHIFTRW__,
    "ktestb":           __asm_proxy_KTESTB__,
    "ktestd":           __asm_proxy_KTESTD__,
    "ktestq":           __asm_proxy_KTESTQ__,
    "ktestw":           __asm_proxy_KTESTW__,
    "kunpckbw":         __asm_proxy_KUNPCKBW__,
    "kunpckdq":         __asm_proxy_KUNPCKDQ__,
    "kunpckwd":         __asm_proxy_KUNPCKWD__,
    "kxnorb":           __asm_proxy_KXNORB__,
    "kxnord":           __asm_proxy_KXNORD__,
    "kxnorq":           __asm_proxy_KXNORQ__,
    "kxnorw":           __asm_proxy_KXNORW__,
    "kxorb":            __asm_proxy_KXORB__,
    "kxord":            __asm_proxy_KXORD__,
    "kxorq":            __asm_proxy_KXORQ__,
    "kxorw":            __asm_proxy_KXORW__,
    "lddqu":            __asm_proxy_LDDQU__,
    "ldmxcsr":          __asm_proxy_LDMXCSR__,
    "leal":             __asm_proxy_LEAL__,
    "leaq":             __asm_proxy_LEAQ__,
    "leaw":             __asm_proxy_LEAW__,
    "lfence":           __asm_proxy_LFENCE__,
    "lzcntl":           __asm_proxy_LZCNTL__,
    "lzcntq":           __asm_proxy_LZCNTQ__,
    "lzcntw":           __asm_proxy_LZCNTW__,
    "maskmovdqu":       __asm_proxy_MASKMOVDQU__,
    "maskmovq":         __asm_proxy_MASKMOVQ__,
    "maxpd":            __asm_proxy_MAXPD__,
    "maxps":            __asm_proxy_MAXPS__,
    "maxsd":            __asm_proxy_MAXSD__,
    "maxss":            __asm_proxy_MAXSS__,
    "mfence":           __asm_proxy_MFENCE__,
    "minpd":            __asm_proxy_MINPD__,
    "minps":            __asm_proxy_MINPS__,
    "minsd":            __asm_proxy_MINSD__,
    "minss":            __asm_proxy_MINSS__,
    "monitor":          __asm_proxy_MONITOR__,
    "monitorx":         __asm_proxy_MONITORX__,
    "movapd":           __asm_proxy_MOVAPD__,
    "movaps":           __asm_proxy_MOVAPS__,
    "movb":             __asm_proxy_MOVB__,
    "movbel":           __asm_proxy_MOVBEL__,
    "movbeq":           __asm_proxy_MOVBEQ__,
    "movbew":           __asm_proxy_MOVBEW__,
    "movd":             __asm_proxy_MOVD__,
    "movddup":          __asm_proxy_MOVDDUP__,
    "movdq2q":          __asm_proxy_MOVDQ2Q__,
    "movdqa":           __asm_proxy_MOVDQA__,
    "movdqu":           __asm_proxy_MOVDQU__,
    "movhlps":          __asm_proxy_MOVHLPS__,
    "movhpd":           __asm_proxy_MOVHPD__,
    "movhps":           __asm_proxy_MOVHPS__,
    "movl":             __asm_proxy_MOVL__,
    "movlhps":          __asm_proxy_MOVLHPS__,
    "movlpd":           __asm_proxy_MOVLPD__,
    "movlps":           __asm_proxy_MOVLPS__,
    "movmskpd":         __asm_proxy_MOVMSKPD__,
    "movmskps":         __asm_proxy_MOVMSKPS__,
    "movntdq":          __asm_proxy_MOVNTDQ__,
    "movntdqa":         __asm_proxy_MOVNTDQA__,
    "movntil":          __asm_proxy_MOVNTIL__,
    "movntiq":          __asm_proxy_MOVNTIQ__,
    "movntpd":          __asm_proxy_MOVNTPD__,
    "movntps":          __asm_proxy_MOVNTPS__,
    "movntq":           __asm_proxy_MOVNTQ__,
    "movntsd":          __asm_proxy_MOVNTSD__,
    "movntss":          __asm_proxy_MOVNTSS__,
    "movq":             __asm_proxy_MOVQ__,
    "movq2dq":          __asm_proxy_MOVQ2DQ__,
    "movsbl":           __asm_proxy_MOVSBL__,
    "movsbq":           __asm_proxy_MOVSBQ__,
    "movsbw":           __asm_proxy_MOVSBW__,
    "movsd":            __asm_proxy_MOVSD__,
    "movshdup":         __asm_proxy_MOVSHDUP__,
    "movsldup":         __asm_proxy_MOVSLDUP__,
    "movslq":           __asm_proxy_MOVSLQ__,
    "movss":            __asm_proxy_MOVSS__,
    "movswl":           __asm_proxy_MOVSWL__,
    "movswq":           __asm_proxy_MOVSWQ__,
    "movupd":           __asm_proxy_MOVUPD__,
    "movups":           __asm_proxy_MOVUPS__,
    "movw":             __asm_proxy_MOVW__,
    "movzbl":           __asm_proxy_MOVZBL__,
    "movzbq":           __asm_proxy_MOVZBQ__,
    "movzbw":           __asm_proxy_MOVZBW__,
    "movzwl":           __asm_proxy_MOVZWL__,
    "movzwq":           __asm_proxy_MOVZWQ__,
    "mpsadbw":          __asm_proxy_MPSADBW__,
    "mulb":             __asm_proxy_MULB__,
    "mull":             __asm_proxy_MULL__,
    "mulpd":            __asm_proxy_MULPD__,
    "mulps":            __asm_proxy_MULPS__,
    "mulq":             __asm_proxy_MULQ__,
    "mulsd":            __asm_proxy_MULSD__,
    "mulss":            __asm_proxy_MULSS__,
    "mulw":             __asm_proxy_MULW__,
    "mulxl":            __asm_proxy_MULXL__,
    "mulxq":            __asm_proxy_MULXQ__,
    "mwait":            __asm_proxy_MWAIT__,
    "mwaitx":           __asm_proxy_MWAITX__,
    "negb":             __asm_proxy_NEGB__,
    "negl":             __asm_proxy_NEGL__,
    "negq":             __asm_proxy_NEGQ__,
    "negw":             __asm_proxy_NEGW__,
    "nop":              __asm_proxy_NOP__,
    "notb":             __asm_proxy_NOTB__,
    "notl":             __asm_proxy_NOTL__,
    "notq":             __asm_proxy_NOTQ__,
    "notw":             __asm_proxy_NOTW__,
    "orb":              __asm_proxy_ORB__,
    "orl":              __asm_proxy_ORL__,
    "orpd":             __asm_proxy_ORPD__,
    "orps":             __asm_proxy_ORPS__,
    "orq":              __asm_proxy_ORQ__,
    "orw":              __asm_proxy_ORW__,
    "pabsb":            __asm_proxy_PABSB__,
    "pabsd":            __asm_proxy_PABSD__,
    "pabsw":            __asm_proxy_PABSW__,
    "packssdw":         __asm_proxy_PACKSSDW__,
    "packsswb":         __asm_proxy_PACKSSWB__,
    "packusdw":         __asm_proxy_PACKUSDW__,
    "packuswb":         __asm_proxy_PACKUSWB__,
    "paddb":            __asm_proxy_PADDB__,
    "paddd":            __asm_proxy_PADDD__,
    "paddq":            __asm_proxy_PADDQ__,
    "paddsb":           __asm_proxy_PADDSB__,
    "paddsw":           __asm_proxy_PADDSW__,
    "paddusb":          __asm_proxy_PADDUSB__,
    "paddusw":          __asm_proxy_PADDUSW__,
    "paddw":            __asm_proxy_PADDW__,
    "palignr":          __asm_proxy_PALIGNR__,
    "pand":             __asm_proxy_PAND__,
    "pandn":            __asm_proxy_PANDN__,
    "pause":            __asm_proxy_PAUSE__,
    "pavgb":            __asm_proxy_PAVGB__,
    "pavgusb":          __asm_proxy_PAVGUSB__,
    "pavgw":            __asm_proxy_PAVGW__,
    "pblendvb":         __asm_proxy_PBLENDVB__,
    "pblendw":          __asm_proxy_PBLENDW__,
    "pclmulqdq":        __asm_proxy_PCLMULQDQ__,
    "pcmpeqb":          __asm_proxy_PCMPEQB__,
    "pcmpeqd":          __asm_proxy_PCMPEQD__,
    "pcmpeqq":          __asm_proxy_PCMPEQQ__,
    "pcmpeqw":          __asm_proxy_PCMPEQW__,
    "pcmpestri":        __asm_proxy_PCMPESTRI__,
    "pcmpestrm":        __asm_proxy_PCMPESTRM__,
    "pcmpgtb":          __asm_proxy_PCMPGTB__,
    "pcmpgtd":          __asm_proxy_PCMPGTD__,
    "pcmpgtq":          __asm_proxy_PCMPGTQ__,
    "pcmpgtw":          __asm_proxy_PCMPGTW__,
    "pcmpistri":        __asm_proxy_PCMPISTRI__,
    "pcmpistrm":        __asm_proxy_PCMPISTRM__,
    "pdep":             __asm_proxy_PDEP__,
    "pext":             __asm_proxy_PEXT__,
    "pextrb":           __asm_proxy_PEXTRB__,
    "pextrd":           __asm_proxy_PEXTRD__,
    "pextrq":           __asm_proxy_PEXTRQ__,
    "pextrw":           __asm_proxy_PEXTRW__,
    "pf2id":            __asm_proxy_PF2ID__,
    "pf2iw":            __asm_proxy_PF2IW__,
    "pfacc":            __asm_proxy_PFACC__,
    "pfadd":            __asm_proxy_PFADD__,
    "pfcmpeq":          __asm_proxy_PFCMPEQ__,
    "pfcmpge":          __asm_proxy_PFCMPGE__,
    "pfcmpgt":          __asm_proxy_PFCMPGT__,
    "pfmax":            __asm_proxy_PFMAX__,
    "pfmin":            __asm_proxy_PFMIN__,
    "pfmul":            __asm_proxy_PFMUL__,
    "pfnacc":           __asm_proxy_PFNACC__,
    "pfpnacc":          __asm_proxy_PFPNACC__,
    "pfrcp":            __asm_proxy_PFRCP__,
    "pfrcpit1":         __asm_proxy_PFRCPIT1__,
    "pfrcpit2":         __asm_proxy_PFRCPIT2__,
    "pfrsqit1":         __asm_proxy_PFRSQIT1__,
    "pfrsqrt":          __asm_proxy_PFRSQRT__,
    "pfsub":            __asm_proxy_PFSUB__,
    "pfsubr":           __asm_proxy_PFSUBR__,
    "phaddd":           __asm_proxy_PHADDD__,
    "phaddsw":          __asm_proxy_PHADDSW__,
    "phaddw":           __asm_proxy_PHADDW__,
    "phminposuw":       __asm_proxy_PHMINPOSUW__,
    "phsubd":           __asm_proxy_PHSUBD__,
    "phsubsw":          __asm_proxy_PHSUBSW__,
    "phsubw":           __asm_proxy_PHSUBW__,
    "pi2fd":            __asm_proxy_PI2FD__,
    "pi2fw":            __asm_proxy_PI2FW__,
    "pinsrb":           __asm_proxy_PINSRB__,
    "pinsrd":           __asm_proxy_PINSRD__,
    "pinsrq":           __asm_proxy_PINSRQ__,
    "pinsrw":           __asm_proxy_PINSRW__,
    "pmaddubsw":        __asm_proxy_PMADDUBSW__,
    "pmaddwd":          __asm_proxy_PMADDWD__,
    "pmaxsb":           __asm_proxy_PMAXSB__,
    "pmaxsd":           __asm_proxy_PMAXSD__,
    "pmaxsw":           __asm_proxy_PMAXSW__,
    "pmaxub":           __asm_proxy_PMAXUB__,
    "pmaxud":           __asm_proxy_PMAXUD__,
    "pmaxuw":           __asm_proxy_PMAXUW__,
    "pminsb":           __asm_proxy_PMINSB__,
    "pminsd":           __asm_proxy_PMINSD__,
    "pminsw":           __asm_proxy_PMINSW__,
    "pminub":           __asm_proxy_PMINUB__,
    "pminud":           __asm_proxy_PMINUD__,
    "pminuw":           __asm_proxy_PMINUW__,
    "pmovmskb":         __asm_proxy_PMOVMSKB__,
    "pmovsxbd":         __asm_proxy_PMOVSXBD__,
    "pmovsxbq":         __asm_proxy_PMOVSXBQ__,
    "pmovsxbw":         __asm_proxy_PMOVSXBW__,
    "pmovsxdq":         __asm_proxy_PMOVSXDQ__,
    "pmovsxwd":         __asm_proxy_PMOVSXWD__,
    "pmovsxwq":         __asm_proxy_PMOVSXWQ__,
    "pmovzxbd":         __asm_proxy_PMOVZXBD__,
    "pmovzxbq":         __asm_proxy_PMOVZXBQ__,
    "pmovzxbw":         __asm_proxy_PMOVZXBW__,
    "pmovzxdq":         __asm_proxy_PMOVZXDQ__,
    "pmovzxwd":         __asm_proxy_PMOVZXWD__,
    "pmovzxwq":         __asm_proxy_PMOVZXWQ__,
    "pmuldq":           __asm_proxy_PMULDQ__,
    "pmulhrsw":         __asm_proxy_PMULHRSW__,
    "pmulhrw":          __asm_proxy_PMULHRW__,
    "pmulhuw":          __asm_proxy_PMULHUW__,
    "pmulhw":           __asm_proxy_PMULHW__,
    "pmulld":           __asm_proxy_PMULLD__,
    "pmullw":           __asm_proxy_PMULLW__,
    "pmuludq":          __asm_proxy_PMULUDQ__,
    "popcntl":          __asm_proxy_POPCNTL__,
    "popcntq":          __asm_proxy_POPCNTQ__,
    "popcntw":          __asm_proxy_POPCNTW__,
    "popq":             __asm_proxy_POPQ__,
    "popw":             __asm_proxy_POPW__,
    "por":              __asm_proxy_POR__,
    "prefetch":         __asm_proxy_PREFETCH__,
    "prefetchnta":      __asm_proxy_PREFETCHNTA__,
    "prefetcht0":       __asm_proxy_PREFETCHT0__,
    "prefetcht1":       __asm_proxy_PREFETCHT1__,
    "prefetcht2":       __asm_proxy_PREFETCHT2__,
    "prefetchw":        __asm_proxy_PREFETCHW__,
    "prefetchwt1":      __asm_proxy_PREFETCHWT1__,
    "psadbw":           __asm_proxy_PSADBW__,
    "pshufb":           __asm_proxy_PSHUFB__,
    "pshufd":           __asm_proxy_PSHUFD__,
    "pshufhw":          __asm_proxy_PSHUFHW__,
    "pshuflw":          __asm_proxy_PSHUFLW__,
    "pshufw":           __asm_proxy_PSHUFW__,
    "psignb":           __asm_proxy_PSIGNB__,
    "psignd":           __asm_proxy_PSIGND__,
    "psignw":           __asm_proxy_PSIGNW__,
    "pslld":            __asm_proxy_PSLLD__,
    "pslldq":           __asm_proxy_PSLLDQ__,
    "psllq":            __asm_proxy_PSLLQ__,
    "psllw":            __asm_proxy_PSLLW__,
    "psrad":            __asm_proxy_PSRAD__,
    "psraw":            __asm_proxy_PSRAW__,
    "psrld":            __asm_proxy_PSRLD__,
    "psrldq":           __asm_proxy_PSRLDQ__,
    "psrlq":            __asm_proxy_PSRLQ__,
    "psrlw":            __asm_proxy_PSRLW__,
    "psubb":            __asm_proxy_PSUBB__,
    "psubd":            __asm_proxy_PSUBD__,
    "psubq":            __asm_proxy_PSUBQ__,
    "psubsb":           __asm_proxy_PSUBSB__,
    "psubsw":           __asm_proxy_PSUBSW__,
    "psubusb":          __asm_proxy_PSUBUSB__,
    "psubusw":          __asm_proxy_PSUBUSW__,
    "psubw":            __asm_proxy_PSUBW__,
    "pswapd":           __asm_proxy_PSWAPD__,
    "ptest":            __asm_proxy_PTEST__,
    "punpckhbw":        __asm_proxy_PUNPCKHBW__,
    "punpckhdq":        __asm_proxy_PUNPCKHDQ__,
    "punpckhqdq":       __asm_proxy_PUNPCKHQDQ__,
    "punpckhwd":        __asm_proxy_PUNPCKHWD__,
    "punpcklbw":        __asm_proxy_PUNPCKLBW__,
    "punpckldq":        __asm_proxy_PUNPCKLDQ__,
    "punpcklqdq":       __asm_proxy_PUNPCKLQDQ__,
    "punpcklwd":        __asm_proxy_PUNPCKLWD__,
    "pushq":            __asm_proxy_PUSHQ__,
    "pushw":            __asm_proxy_PUSHW__,
    "pxor":             __asm_proxy_PXOR__,
    "rclb":             __asm_proxy_RCLB__,
    "rcll":             __asm_proxy_RCLL__,
    "rclq":             __asm_proxy_RCLQ__,
    "rclw":             __asm_proxy_RCLW__,
    "rcpps":            __asm_proxy_RCPPS__,
    "rcpss":            __asm_proxy_RCPSS__,
    "rcrb":             __asm_proxy_RCRB__,
    "rcrl":             __asm_proxy_RCRL__,
    "rcrq":             __asm_proxy_RCRQ__,
    "rcrw":             __asm_proxy_RCRW__,
    "rdrand":           __asm_proxy_RDRAND__,
    "rdseed":           __asm_proxy_RDSEED__,
    "rdtsc":            __asm_proxy_RDTSC__,
    "rdtscp":           __asm_proxy_RDTSCP__,
    "ret":              __asm_proxy_RET__,
    "rolb":             __asm_proxy_ROLB__,
    "roll":             __asm_proxy_ROLL__,
    "rolq":             __asm_proxy_ROLQ__,
    "rolw":             __asm_proxy_ROLW__,
    "rorb":             __asm_proxy_RORB__,
    "rorl":             __asm_proxy_RORL__,
    "rorq":             __asm_proxy_RORQ__,
    "rorw":             __asm_proxy_RORW__,
    "rorxl":            __asm_proxy_RORXL__,
    "rorxq":            __asm_proxy_RORXQ__,
    "roundpd":          __asm_proxy_ROUNDPD__,
    "roundps":          __asm_proxy_ROUNDPS__,
    "roundsd":          __asm_proxy_ROUNDSD__,
    "roundss":          __asm_proxy_ROUNDSS__,
    "rsqrtps":          __asm_proxy_RSQRTPS__,
    "rsqrtss":          __asm_proxy_RSQRTSS__,
    "salb":             __asm_proxy_SALB__,
    "sall":             __asm_proxy_SALL__,
    "salq":             __asm_proxy_SALQ__,
    "salw":             __asm_proxy_SALW__,
    "sarb":             __asm_proxy_SARB__,
    "sarl":             __asm_proxy_SARL__,
    "sarq":             __asm_proxy_SARQ__,
    "sarw":             __asm_proxy_SARW__,
    "sarxl":            __asm_proxy_SARXL__,
    "sarxq":            __asm_proxy_SARXQ__,
    "sbbb":             __asm_proxy_SBBB__,
    "sbbl":             __asm_proxy_SBBL__,
    "sbbq":             __asm_proxy_SBBQ__,
    "sbbw":             __asm_proxy_SBBW__,
    "seta":             __asm_proxy_SETA__,
    "setae":            __asm_proxy_SETAE__,
    "setb":             __asm_proxy_SETB__,
    "setbe":            __asm_proxy_SETBE__,
    "setc":             __asm_proxy_SETC__,
    "sete":             __asm_proxy_SETE__,
    "setg":             __asm_proxy_SETG__,
    "setge":            __asm_proxy_SETGE__,
    "setl":             __asm_proxy_SETL__,
    "setle":            __asm_proxy_SETLE__,
    "setna":            __asm_proxy_SETNA__,
    "setnae":           __asm_proxy_SETNAE__,
    "setnb":            __asm_proxy_SETNB__,
    "setnbe":           __asm_proxy_SETNBE__,
    "setnc":            __asm_proxy_SETNC__,
    "setne":            __asm_proxy_SETNE__,
    "setng":            __asm_proxy_SETNG__,
    "setnge":           __asm_proxy_SETNGE__,
    "setnl":            __asm_proxy_SETNL__,
    "setnle":           __asm_proxy_SETNLE__,
    "setno":            __asm_proxy_SETNO__,
    "setnp":            __asm_proxy_SETNP__,
    "setns":            __asm_proxy_SETNS__,
    "setnz":            __asm_proxy_SETNZ__,
    "seto":             __asm_proxy_SETO__,
    "setp":             __asm_proxy_SETP__,
    "setpe":            __asm_proxy_SETPE__,
    "setpo":            __asm_proxy_SETPO__,
    "sets":             __asm_proxy_SETS__,
    "setz":             __asm_proxy_SETZ__,
    "sfence":           __asm_proxy_SFENCE__,
    "sha1msg1":         __asm_proxy_SHA1MSG1__,
    "sha1msg2":         __asm_proxy_SHA1MSG2__,
    "sha1nexte":        __asm_proxy_SHA1NEXTE__,
    "sha1rnds4":        __asm_proxy_SHA1RNDS4__,
    "sha256msg1":       __asm_proxy_SHA256MSG1__,
    "sha256msg2":       __asm_proxy_SHA256MSG2__,
    "sha256rnds2":      __asm_proxy_SHA256RNDS2__,
    "shlb":             __asm_proxy_SHLB__,
    "shldl":            __asm_proxy_SHLDL__,
    "shldq":            __asm_proxy_SHLDQ__,
    "shldw":            __asm_proxy_SHLDW__,
    "shll":             __asm_proxy_SHLL__,
    "shlq":             __asm_proxy_SHLQ__,
    "shlw":             __asm_proxy_SHLW__,
    "shlxl":            __asm_proxy_SHLXL__,
    "shlxq":            __asm_proxy_SHLXQ__,
    "shrb":             __asm_proxy_SHRB__,
    "shrdl":            __asm_proxy_SHRDL__,
    "shrdq":            __asm_proxy_SHRDQ__,
    "shrdw":            __asm_proxy_SHRDW__,
    "shrl":             __asm_proxy_SHRL__,
    "shrq":             __asm_proxy_SHRQ__,
    "shrw":             __asm_proxy_SHRW__,
    "shrxl":            __asm_proxy_SHRXL__,
    "shrxq":            __asm_proxy_SHRXQ__,
    "shufpd":           __asm_proxy_SHUFPD__,
    "shufps":           __asm_proxy_SHUFPS__,
    "sqrtpd":           __asm_proxy_SQRTPD__,
    "sqrtps":           __asm_proxy_SQRTPS__,
    "sqrtsd":           __asm_proxy_SQRTSD__,
    "sqrtss":           __asm_proxy_SQRTSS__,
    "stc":              __asm_proxy_STC__,
    "std":              __asm_proxy_STD__,
    "stmxcsr":          __asm_proxy_STMXCSR__,
    "subb":             __asm_proxy_SUBB__,
    "subl":             __asm_proxy_SUBL__,
    "subpd":            __asm_proxy_SUBPD__,
    "subps":            __asm_proxy_SUBPS__,
    "subq":             __asm_proxy_SUBQ__,
    "subsd":            __asm_proxy_SUBSD__,
    "subss":            __asm_proxy_SUBSS__,
    "subw":             __asm_proxy_SUBW__,
    "syscall":          __asm_proxy_SYSCALL__,
    "t1mskc":           __asm_proxy_T1MSKC__,
    "testb":            __asm_proxy_TESTB__,
    "testl":            __asm_proxy_TESTL__,
    "testq":            __asm_proxy_TESTQ__,
    "testw":            __asm_proxy_TESTW__,
    "tzcntl":           __asm_proxy_TZCNTL__,
    "tzcntq":           __asm_proxy_TZCNTQ__,
    "tzcntw":           __asm_proxy_TZCNTW__,
    "tzmsk":            __asm_proxy_TZMSK__,
    "ucomisd":          __asm_proxy_UCOMISD__,
    "ucomiss":          __asm_proxy_UCOMISS__,
    "ud2":              __asm_proxy_UD2__,
    "unpckhpd":         __asm_proxy_UNPCKHPD__,
    "unpckhps":         __asm_proxy_UNPCKHPS__,
    "unpcklpd":         __asm_proxy_UNPCKLPD__,
    "unpcklps":         __asm_proxy_UNPCKLPS__,
    "vaddpd":           __asm_proxy_VADDPD__,
    "vaddps":           __asm_proxy_VADDPS__,
    "vaddsd":           __asm_proxy_VADDSD__,
    "vaddss":           __asm_proxy_VADDSS__,
    "vaddsubpd":        __asm_proxy_VADDSUBPD__,
    "vaddsubps":        __asm_proxy_VADDSUBPS__,
    "vaesdec":          __asm_proxy_VAESDEC__,
    "vaesdeclast":      __asm_proxy_VAESDECLAST__,
    "vaesenc":          __asm_proxy_VAESENC__,
    "vaesenclast":      __asm_proxy_VAESENCLAST__,
    "vaesimc":          __asm_proxy_VAESIMC__,
    "vaeskeygenassist": __asm_proxy_VAESKEYGENASSIST__,
    "valignd":          __asm_proxy_VALIGND__,
    "valignq":          __asm_proxy_VALIGNQ__,
    "vandnpd":          __asm_proxy_VANDNPD__,
    "vandnps":          __asm_proxy_VANDNPS__,
    "vandpd":           __asm_proxy_VANDPD__,
    "vandps":           __asm_proxy_VANDPS__,
    "vblendmpd":        __asm_proxy_VBLENDMPD__,
    "vblendmps":        __asm_proxy_VBLENDMPS__,
    "vblendpd":         __asm_proxy_VBLENDPD__,
    "vblendps":         __asm_proxy_VBLENDPS__,
    "vblendvpd":        __asm_proxy_VBLENDVPD__,
    "vblendvps":        __asm_proxy_VBLENDVPS__,
    "vbroadcastf128":   __asm_proxy_VBROADCASTF128__,
    "vbroadcastf32x2":  __asm_proxy_VBROADCASTF32X2__,
    "vbroadcastf32x4":  __asm_proxy_VBROADCASTF32X4__,
    "vbroadcastf32x8":  __asm_proxy_VBROADCASTF32X8__,
    "vbroadcastf64x2":  __asm_proxy_VBROADCASTF64X2__,
    "vbroadcastf64x4":  __asm_proxy_VBROADCASTF64X4__,
    "vbroadcasti128":   __asm_proxy_VBROADCASTI128__,
    "vbroadcasti32x2":  __asm_proxy_VBROADCASTI32X2__,
    "vbroadcasti32x4":  __asm_proxy_VBROADCASTI32X4__,
    "vbroadcasti32x8":  __asm_proxy_VBROADCASTI32X8__,
    "vbroadcasti64x2":  __asm_proxy_VBROADCASTI64X2__,
    "vbroadcasti64x4":  __asm_proxy_VBROADCASTI64X4__,
    "vbroadcastsd":     __asm_proxy_VBROADCASTSD__,
    "vbroadcastss":     __asm_proxy_VBROADCASTSS__,
    "vcmppd":           __asm_proxy_VCMPPD__,
    "vcmpps":           __asm_proxy_VCMPPS__,
    "vcmpsd":           __asm_proxy_VCMPSD__,
    "vcmpss":           __asm_proxy_VCMPSS__,
    "vcomisd":          __asm_proxy_VCOMISD__,
    "vcomiss":          __asm_proxy_VCOMISS__,
    "vcompresspd":      __asm_proxy_VCOMPRESSPD__,
    "vcompressps":      __asm_proxy_VCOMPRESSPS__,
    "vcvtdq2pd":        __asm_proxy_VCVTDQ2PD__,
    "vcvtdq2ps":        __asm_proxy_VCVTDQ2PS__,
    "vcvtpd2dq":        __asm_proxy_VCVTPD2DQ__,
    "vcvtpd2ps":        __asm_proxy_VCVTPD2PS__,
    "vcvtpd2qq":        __asm_proxy_VCVTPD2QQ__,
    "vcvtpd2udq":       __asm_proxy_VCVTPD2UDQ__,
    "vcvtpd2uqq":       __asm_proxy_VCVTPD2UQQ__,
    "vcvtph2ps":        __asm_proxy_VCVTPH2PS__,
    "vcvtps2dq":        __asm_proxy_VCVTPS2DQ__,
    "vcvtps2pd":        __asm_proxy_VCVTPS2PD__,
    "vcvtps2ph":        __asm_proxy_VCVTPS2PH__,
    "vcvtps2qq":        __asm_proxy_VCVTPS2QQ__,
    "vcvtps2udq":       __asm_proxy_VCVTPS2UDQ__,
    "vcvtps2uqq":       __asm_proxy_VCVTPS2UQQ__,
    "vcvtqq2pd":        __asm_proxy_VCVTQQ2PD__,
    "vcvtqq2ps":        __asm_proxy_VCVTQQ2PS__,
    "vcvtsd2si":        __asm_proxy_VCVTSD2SI__,
    "vcvtsd2ss":        __asm_proxy_VCVTSD2SS__,
    "vcvtsd2usi":       __asm_proxy_VCVTSD2USI__,
    "vcvtsi2sd":        __asm_proxy_VCVTSI2SD__,
    "vcvtsi2ss":        __asm_proxy_VCVTSI2SS__,
    "vcvtss2sd":        __asm_proxy_VCVTSS2SD__,
    "vcvtss2si":        __asm_proxy_VCVTSS2SI__,
    "vcvtss2usi":       __asm_proxy_VCVTSS2USI__,
    "vcvttpd2dq":       __asm_proxy_VCVTTPD2DQ__,
    "vcvttpd2qq":       __asm_proxy_VCVTTPD2QQ__,
    "vcvttpd2udq":      __asm_proxy_VCVTTPD2UDQ__,
    "vcvttpd2uqq":      __asm_proxy_VCVTTPD2UQQ__,
    "vcvttps2dq":       __asm_proxy_VCVTTPS2DQ__,
    "vcvttps2qq":       __asm_proxy_VCVTTPS2QQ__,
    "vcvttps2udq":      __asm_proxy_VCVTTPS2UDQ__,
    "vcvttps2uqq":      __asm_proxy_VCVTTPS2UQQ__,
    "vcvttsd2si":       __asm_proxy_VCVTTSD2SI__,
    "vcvttsd2usi":      __asm_proxy_VCVTTSD2USI__,
    "vcvttss2si":       __asm_proxy_VCVTTSS2SI__,
    "vcvttss2usi":      __asm_proxy_VCVTTSS2USI__,
    "vcvtudq2pd":       __asm_proxy_VCVTUDQ2PD__,
    "vcvtudq2ps":       __asm_proxy_VCVTUDQ2PS__,
    "vcvtuqq2pd":       __asm_proxy_VCVTUQQ2PD__,
    "vcvtuqq2ps":       __asm_proxy_VCVTUQQ2PS__,
    "vcvtusi2sd":       __asm_proxy_VCVTUSI2SD__,
    "vcvtusi2ss":       __asm_proxy_VCVTUSI2SS__,
    "vdbpsadbw":        __asm_proxy_VDBPSADBW__,
    "vdivpd":           __asm_proxy_VDIVPD__,
    "vdivps":           __asm_proxy_VDIVPS__,
    "vdivsd":           __asm_proxy_VDIVSD__,
    "vdivss":           __asm_proxy_VDIVSS__,
    "vdppd":            __asm_proxy_VDPPD__,
    "vdpps":            __asm_proxy_VDPPS__,
    "vexp2pd":          __asm_proxy_VEXP2PD__,
    "vexp2ps":          __asm_proxy_VEXP2PS__,
    "vexpandpd":        __asm_proxy_VEXPANDPD__,
    "vexpandps":        __asm_proxy_VEXPANDPS__,
    "vextractf128":     __asm_proxy_VEXTRACTF128__,
    "vextractf32x4":    __asm_proxy_VEXTRACTF32X4__,
    "vextractf32x8":    __asm_proxy_VEXTRACTF32X8__,
    "vextractf64x2":    __asm_proxy_VEXTRACTF64X2__,
    "vextractf64x4":    __asm_proxy_VEXTRACTF64X4__,
    "vextracti128":     __asm_proxy_VEXTRACTI128__,
    "vextracti32x4":    __asm_proxy_VEXTRACTI32X4__,
    "vextracti32x8":    __asm_proxy_VEXTRACTI32X8__,
    "vextracti64x2":    __asm_proxy_VEXTRACTI64X2__,
    "vextracti64x4":    __asm_proxy_VEXTRACTI64X4__,
    "vextractps":       __asm_proxy_VEXTRACTPS__,
    "vfixupimmpd":      __asm_proxy_VFIXUPIMMPD__,
    "vfixupimmps":      __asm_proxy_VFIXUPIMMPS__,
    "vfixupimmsd":      __asm_proxy_VFIXUPIMMSD__,
    "vfixupimmss":      __asm_proxy_VFIXUPIMMSS__,
    "vfmadd132pd":      __asm_proxy_VFMADD132PD__,
    "vfmadd132ps":      __asm_proxy_VFMADD132PS__,
    "vfmadd132sd":      __asm_proxy_VFMADD132SD__,
    "vfmadd132ss":      __asm_proxy_VFMADD132SS__,
    "vfmadd213pd":      __asm_proxy_VFMADD213PD__,
    "vfmadd213ps":      __asm_proxy_VFMADD213PS__,
    "vfmadd213sd":      __asm_proxy_VFMADD213SD__,
    "vfmadd213ss":      __asm_proxy_VFMADD213SS__,
    "vfmadd231pd":      __asm_proxy_VFMADD231PD__,
    "vfmadd231ps":      __asm_proxy_VFMADD231PS__,
    "vfmadd231sd":      __asm_proxy_VFMADD231SD__,
    "vfmadd231ss":      __asm_proxy_VFMADD231SS__,
    "vfmaddpd":         __asm_proxy_VFMADDPD__,
    "vfmaddps":         __asm_proxy_VFMADDPS__,
    "vfmaddsd":         __asm_proxy_VFMADDSD__,
    "vfmaddss":         __asm_proxy_VFMADDSS__,
    "vfmaddsub132pd":   __asm_proxy_VFMADDSUB132PD__,
    "vfmaddsub132ps":   __asm_proxy_VFMADDSUB132PS__,
    "vfmaddsub213pd":   __asm_proxy_VFMADDSUB213PD__,
    "vfmaddsub213ps":   __asm_proxy_VFMADDSUB213PS__,
    "vfmaddsub231pd":   __asm_proxy_VFMADDSUB231PD__,
    "vfmaddsub231ps":   __asm_proxy_VFMADDSUB231PS__,
    "vfmaddsubpd":      __asm_proxy_VFMADDSUBPD__,
    "vfmaddsubps":      __asm_proxy_VFMADDSUBPS__,
    "vfmsub132pd":      __asm_proxy_VFMSUB132PD__,
    "vfmsub132ps":      __asm_proxy_VFMSUB132PS__,
    "vfmsub132sd":      __asm_proxy_VFMSUB132SD__,
    "vfmsub132ss":      __asm_proxy_VFMSUB132SS__,
    "vfmsub213pd":      __asm_proxy_VFMSUB213PD__,
    "vfmsub213ps":      __asm_proxy_VFMSUB213PS__,
    "vfmsub213sd":      __asm_proxy_VFMSUB213SD__,
    "vfmsub213ss":      __asm_proxy_VFMSUB213SS__,
    "vfmsub231pd":      __asm_proxy_VFMSUB231PD__,
    "vfmsub231ps":      __asm_proxy_VFMSUB231PS__,
    "vfmsub231sd":      __asm_proxy_VFMSUB231SD__,
    "vfmsub231ss":      __asm_proxy_VFMSUB231SS__,
    "vfmsubadd132pd":   __asm_proxy_VFMSUBADD132PD__,
    "vfmsubadd132ps":   __asm_proxy_VFMSUBADD132PS__,
    "vfmsubadd213pd":   __asm_proxy_VFMSUBADD213PD__,
    "vfmsubadd213ps":   __asm_proxy_VFMSUBADD213PS__,
    "vfmsubadd231pd":   __asm_proxy_VFMSUBADD231PD__,
    "vfmsubadd231ps":   __asm_proxy_VFMSUBADD231PS__,
    "vfmsubaddpd":      __asm_proxy_VFMSUBADDPD__,
    "vfmsubaddps":      __asm_proxy_VFMSUBADDPS__,
    "vfmsubpd":         __asm_proxy_VFMSUBPD__,
    "vfmsubps":         __asm_proxy_VFMSUBPS__,
    "vfmsubsd":         __asm_proxy_VFMSUBSD__,
    "vfmsubss":         __asm_proxy_VFMSUBSS__,
    "vfnmadd132pd":     __asm_proxy_VFNMADD132PD__,
    "vfnmadd132ps":     __asm_proxy_VFNMADD132PS__,
    "vfnmadd132sd":     __asm_proxy_VFNMADD132SD__,
    "vfnmadd132ss":     __asm_proxy_VFNMADD132SS__,
    "vfnmadd213pd":     __asm_proxy_VFNMADD213PD__,
    "vfnmadd213ps":     __asm_proxy_VFNMADD213PS__,
    "vfnmadd213sd":     __asm_proxy_VFNMADD213SD__,
    "vfnmadd213ss":     __asm_proxy_VFNMADD213SS__,
    "vfnmadd231pd":     __asm_proxy_VFNMADD231PD__,
    "vfnmadd231ps":     __asm_proxy_VFNMADD231PS__,
    "vfnmadd231sd":     __asm_proxy_VFNMADD231SD__,
    "vfnmadd231ss":     __asm_proxy_VFNMADD231SS__,
    "vfnmaddpd":        __asm_proxy_VFNMADDPD__,
    "vfnmaddps":        __asm_proxy_VFNMADDPS__,
    "vfnmaddsd":        __asm_proxy_VFNMADDSD__,
    "vfnmaddss":        __asm_proxy_VFNMADDSS__,
    "vfnmsub132pd":     __asm_proxy_VFNMSUB132PD__,
    "vfnmsub132ps":     __asm_proxy_VFNMSUB132PS__,
    "vfnmsub132sd":     __asm_proxy_VFNMSUB132SD__,
    "vfnmsub132ss":     __asm_proxy_VFNMSUB132SS__,
    "vfnmsub213pd":     __asm_proxy_VFNMSUB213PD__,
    "vfnmsub213ps":     __asm_proxy_VFNMSUB213PS__,
    "vfnmsub213sd":     __asm_proxy_VFNMSUB213SD__,
    "vfnmsub213ss":     __asm_proxy_VFNMSUB213SS__,
    "vfnmsub231pd":     __asm_proxy_VFNMSUB231PD__,
    "vfnmsub231ps":     __asm_proxy_VFNMSUB231PS__,
    "vfnmsub231sd":     __asm_proxy_VFNMSUB231SD__,
    "vfnmsub231ss":     __asm_proxy_VFNMSUB231SS__,
    "vfnmsubpd":        __asm_proxy_VFNMSUBPD__,
    "vfnmsubps":        __asm_proxy_VFNMSUBPS__,
    "vfnmsubsd":        __asm_proxy_VFNMSUBSD__,
    "vfnmsubss":        __asm_proxy_VFNMSUBSS__,
    "vfpclasspd":       __asm_proxy_VFPCLASSPD__,
    "vfpclassps":       __asm_proxy_VFPCLASSPS__,
    "vfpclasssd":       __asm_proxy_VFPCLASSSD__,
    "vfpclassss":       __asm_proxy_VFPCLASSSS__,
    "vfrczpd":          __asm_proxy_VFRCZPD__,
    "vfrczps":          __asm_proxy_VFRCZPS__,
    "vfrczsd":          __asm_proxy_VFRCZSD__,
    "vfrczss":          __asm_proxy_VFRCZSS__,
    "vgatherdpd":       __asm_proxy_VGATHERDPD__,
    "vgatherdps":       __asm_proxy_VGATHERDPS__,
    "vgatherpf0dpd":    __asm_proxy_VGATHERPF0DPD__,
    "vgatherpf0dps":    __asm_proxy_VGATHERPF0DPS__,
    "vgatherpf0qpd":    __asm_proxy_VGATHERPF0QPD__,
    "vgatherpf0qps":    __asm_proxy_VGATHERPF0QPS__,
    "vgatherpf1dpd":    __asm_proxy_VGATHERPF1DPD__,
    "vgatherpf1dps":    __asm_proxy_VGATHERPF1DPS__,
    "vgatherpf1qpd":    __asm_proxy_VGATHERPF1QPD__,
    "vgatherpf1qps":    __asm_proxy_VGATHERPF1QPS__,
    "vgatherqpd":       __asm_proxy_VGATHERQPD__,
    "vgatherqps":       __asm_proxy_VGATHERQPS__,
    "vgetexppd":        __asm_proxy_VGETEXPPD__,
    "vgetexpps":        __asm_proxy_VGETEXPPS__,
    "vgetexpsd":        __asm_proxy_VGETEXPSD__,
    "vgetexpss":        __asm_proxy_VGETEXPSS__,
    "vgetmantpd":       __asm_proxy_VGETMANTPD__,
    "vgetmantps":       __asm_proxy_VGETMANTPS__,
    "vgetmantsd":       __asm_proxy_VGETMANTSD__,
    "vgetmantss":       __asm_proxy_VGETMANTSS__,
    "vhaddpd":          __asm_proxy_VHADDPD__,
    "vhaddps":          __asm_proxy_VHADDPS__,
    "vhsubpd":          __asm_proxy_VHSUBPD__,
    "vhsubps":          __asm_proxy_VHSUBPS__,
    "vinsertf128":      __asm_proxy_VINSERTF128__,
    "vinsertf32x4":     __asm_proxy_VINSERTF32X4__,
    "vinsertf32x8":     __asm_proxy_VINSERTF32X8__,
    "vinsertf64x2":     __asm_proxy_VINSERTF64X2__,
    "vinsertf64x4":     __asm_proxy_VINSERTF64X4__,
    "vinserti128":      __asm_proxy_VINSERTI128__,
    "vinserti32x4":     __asm_proxy_VINSERTI32X4__,
    "vinserti32x8":     __asm_proxy_VINSERTI32X8__,
    "vinserti64x2":     __asm_proxy_VINSERTI64X2__,
    "vinserti64x4":     __asm_proxy_VINSERTI64X4__,
    "vinsertps":        __asm_proxy_VINSERTPS__,
    "vlddqu":           __asm_proxy_VLDDQU__,
    "vldmxcsr":         __asm_proxy_VLDMXCSR__,
    "vmaskmovdqu":      __asm_proxy_VMASKMOVDQU__,
    "vmaskmovpd":       __asm_proxy_VMASKMOVPD__,
    "vmaskmovps":       __asm_proxy_VMASKMOVPS__,
    "vmaxpd":           __asm_proxy_VMAXPD__,
    "vmaxps":           __asm_proxy_VMAXPS__,
    "vmaxsd":           __asm_proxy_VMAXSD__,
    "vmaxss":           __asm_proxy_VMAXSS__,
    "vminpd":           __asm_proxy_VMINPD__,
    "vminps":           __asm_proxy_VMINPS__,
    "vminsd":           __asm_proxy_VMINSD__,
    "vminss":           __asm_proxy_VMINSS__,
    "vmovapd":          __asm_proxy_VMOVAPD__,
    "vmovaps":          __asm_proxy_VMOVAPS__,
    "vmovd":            __asm_proxy_VMOVD__,
    "vmovddup":         __asm_proxy_VMOVDDUP__,
    "vmovdqa":          __asm_proxy_VMOVDQA__,
    "vmovdqa32":        __asm_proxy_VMOVDQA32__,
    "vmovdqa64":        __asm_proxy_VMOVDQA64__,
    "vmovdqu":          __asm_proxy_VMOVDQU__,
    "vmovdqu16":        __asm_proxy_VMOVDQU16__,
    "vmovdqu32":        __asm_proxy_VMOVDQU32__,
    "vmovdqu64":        __asm_proxy_VMOVDQU64__,
    "vmovdqu8":         __asm_proxy_VMOVDQU8__,
    "vmovhlps":         __asm_proxy_VMOVHLPS__,
    "vmovhpd":          __asm_proxy_VMOVHPD__,
    "vmovhps":          __asm_proxy_VMOVHPS__,
    "vmovlhps":         __asm_proxy_VMOVLHPS__,
    "vmovlpd":          __asm_proxy_VMOVLPD__,
    "vmovlps":          __asm_proxy_VMOVLPS__,
    "vmovmskpd":        __asm_proxy_VMOVMSKPD__,
    "vmovmskps":        __asm_proxy_VMOVMSKPS__,
    "vmovntdq":         __asm_proxy_VMOVNTDQ__,
    "vmovntdqa":        __asm_proxy_VMOVNTDQA__,
    "vmovntpd":         __asm_proxy_VMOVNTPD__,
    "vmovntps":         __asm_proxy_VMOVNTPS__,
    "vmovq":            __asm_proxy_VMOVQ__,
    "vmovsd":           __asm_proxy_VMOVSD__,
    "vmovshdup":        __asm_proxy_VMOVSHDUP__,
    "vmovsldup":        __asm_proxy_VMOVSLDUP__,
    "vmovss":           __asm_proxy_VMOVSS__,
    "vmovupd":          __asm_proxy_VMOVUPD__,
    "vmovups":          __asm_proxy_VMOVUPS__,
    "vmpsadbw":         __asm_proxy_VMPSADBW__,
    "vmulpd":           __asm_proxy_VMULPD__,
    "vmulps":           __asm_proxy_VMULPS__,
    "vmulsd":           __asm_proxy_VMULSD__,
    "vmulss":           __asm_proxy_VMULSS__,
    "vorpd":            __asm_proxy_VORPD__,
    "vorps":            __asm_proxy_VORPS__,
    "vpabsb":           __asm_proxy_VPABSB__,
    "vpabsd":           __asm_proxy_VPABSD__,
    "vpabsq":           __asm_proxy_VPABSQ__,
    "vpabsw":           __asm_proxy_VPABSW__,
    "vpackssdw":        __asm_proxy_VPACKSSDW__,
    "vpacksswb":        __asm_proxy_VPACKSSWB__,
    "vpackusdw":        __asm_proxy_VPACKUSDW__,
    "vpackuswb":        __asm_proxy_VPACKUSWB__,
    "vpaddb":           __asm_proxy_VPADDB__,
    "vpaddd":           __asm_proxy_VPADDD__,
    "vpaddq":           __asm_proxy_VPADDQ__,
    "vpaddsb":          __asm_proxy_VPADDSB__,
    "vpaddsw":          __asm_proxy_VPADDSW__,
    "vpaddusb":         __asm_proxy_VPADDUSB__,
    "vpaddusw":         __asm_proxy_VPADDUSW__,
    "vpaddw":           __asm_proxy_VPADDW__,
    "vpalignr":         __asm_proxy_VPALIGNR__,
    "vpand":            __asm_proxy_VPAND__,
    "vpandd":           __asm_proxy_VPANDD__,
    "vpandn":           __asm_proxy_VPANDN__,
    "vpandnd":          __asm_proxy_VPANDND__,
    "vpandnq":          __asm_proxy_VPANDNQ__,
    "vpandq":           __asm_proxy_VPANDQ__,
    "vpavgb":           __asm_proxy_VPAVGB__,
    "vpavgw":           __asm_proxy_VPAVGW__,
    "vpblendd":         __asm_proxy_VPBLENDD__,
    "vpblendmb":        __asm_proxy_VPBLENDMB__,
    "vpblendmd":        __asm_proxy_VPBLENDMD__,
    "vpblendmq":        __asm_proxy_VPBLENDMQ__,
    "vpblendmw":        __asm_proxy_VPBLENDMW__,
    "vpblendvb":        __asm_proxy_VPBLENDVB__,
    "vpblendw":         __asm_proxy_VPBLENDW__,
    "vpbroadcastb":     __asm_proxy_VPBROADCASTB__,
    "vpbroadcastd":     __asm_proxy_VPBROADCASTD__,
    "vpbroadcastmb2q":  __asm_proxy_VPBROADCASTMB2Q__,
    "vpbroadcastmw2d":  __asm_proxy_VPBROADCASTMW2D__,
    "vpbroadcastq":     __asm_proxy_VPBROADCASTQ__,
    "vpbroadcastw":     __asm_proxy_VPBROADCASTW__,
    "vpclmulqdq":       __asm_proxy_VPCLMULQDQ__,
    "vpcmov":           __asm_proxy_VPCMOV__,
    "vpcmpb":           __asm_proxy_VPCMPB__,
    "vpcmpd":           __asm_proxy_VPCMPD__,
    "vpcmpeqb":         __asm_proxy_VPCMPEQB__,
    "vpcmpeqd":         __asm_proxy_VPCMPEQD__,
    "vpcmpeqq":         __asm_proxy_VPCMPEQQ__,
    "vpcmpeqw":         __asm_proxy_VPCMPEQW__,
    "vpcmpestri":       __asm_proxy_VPCMPESTRI__,
    "vpcmpestrm":       __asm_proxy_VPCMPESTRM__,
    "vpcmpgtb":         __asm_proxy_VPCMPGTB__,
    "vpcmpgtd":         __asm_proxy_VPCMPGTD__,
    "vpcmpgtq":         __asm_proxy_VPCMPGTQ__,
    "vpcmpgtw":         __asm_proxy_VPCMPGTW__,
    "vpcmpistri":       __asm_proxy_VPCMPISTRI__,
    "vpcmpistrm":       __asm_proxy_VPCMPISTRM__,
    "vpcmpq":           __asm_proxy_VPCMPQ__,
    "vpcmpub":          __asm_proxy_VPCMPUB__,
    "vpcmpud":          __asm_proxy_VPCMPUD__,
    "vpcmpuq":          __asm_proxy_VPCMPUQ__,
    "vpcmpuw":          __asm_proxy_VPCMPUW__,
    "vpcmpw":           __asm_proxy_VPCMPW__,
    "vpcomb":           __asm_proxy_VPCOMB__,
    "vpcomd":           __asm_proxy_VPCOMD__,
    "vpcompressd":      __asm_proxy_VPCOMPRESSD__,
    "vpcompressq":      __asm_proxy_VPCOMPRESSQ__,
    "vpcomq":           __asm_proxy_VPCOMQ__,
    "vpcomub":          __asm_proxy_VPCOMUB__,
    "vpcomud":          __asm_proxy_VPCOMUD__,
    "vpcomuq":          __asm_proxy_VPCOMUQ__,
    "vpcomuw":          __asm_proxy_VPCOMUW__,
    "vpcomw":           __asm_proxy_VPCOMW__,
    "vpconflictd":      __asm_proxy_VPCONFLICTD__,
    "vpconflictq":      __asm_proxy_VPCONFLICTQ__,
    "vperm2f128":       __asm_proxy_VPERM2F128__,
    "vperm2i128":       __asm_proxy_VPERM2I128__,
    "vpermb":           __asm_proxy_VPERMB__,
    "vpermd":           __asm_proxy_VPERMD__,
    "vpermi2b":         __asm_proxy_VPERMI2B__,
    "vpermi2d":         __asm_proxy_VPERMI2D__,
    "vpermi2pd":        __asm_proxy_VPERMI2PD__,
    "vpermi2ps":        __asm_proxy_VPERMI2PS__,
    "vpermi2q":         __asm_proxy_VPERMI2Q__,
    "vpermi2w":         __asm_proxy_VPERMI2W__,
    "vpermil2pd":       __asm_proxy_VPERMIL2PD__,
    "vpermil2ps":       __asm_proxy_VPERMIL2PS__,
    "vpermilpd":        __asm_proxy_VPERMILPD__,
    "vpermilps":        __asm_proxy_VPERMILPS__,
    "vpermpd":          __asm_proxy_VPERMPD__,
    "vpermps":          __asm_proxy_VPERMPS__,
    "vpermq":           __asm_proxy_VPERMQ__,
    "vpermt2b":         __asm_proxy_VPERMT2B__,
    "vpermt2d":         __asm_proxy_VPERMT2D__,
    "vpermt2pd":        __asm_proxy_VPERMT2PD__,
    "vpermt2ps":        __asm_proxy_VPERMT2PS__,
    "vpermt2q":         __asm_proxy_VPERMT2Q__,
    "vpermt2w":         __asm_proxy_VPERMT2W__,
    "vpermw":           __asm_proxy_VPERMW__,
    "vpexpandd":        __asm_proxy_VPEXPANDD__,
    "vpexpandq":        __asm_proxy_VPEXPANDQ__,
    "vpextrb":          __asm_proxy_VPEXTRB__,
    "vpextrd":          __asm_proxy_VPEXTRD__,
    "vpextrq":          __asm_proxy_VPEXTRQ__,
    "vpextrw":          __asm_proxy_VPEXTRW__,
    "vpgatherdd":       __asm_proxy_VPGATHERDD__,
    "vpgatherdq":       __asm_proxy_VPGATHERDQ__,
    "vpgatherqd":       __asm_proxy_VPGATHERQD__,
    "vpgatherqq":       __asm_proxy_VPGATHERQQ__,
    "vphaddbd":         __asm_proxy_VPHADDBD__,
    "vphaddbq":         __asm_proxy_VPHADDBQ__,
    "vphaddbw":         __asm_proxy_VPHADDBW__,
    "vphaddd":          __asm_proxy_VPHADDD__,
    "vphadddq":         __asm_proxy_VPHADDDQ__,
    "vphaddsw":         __asm_proxy_VPHADDSW__,
    "vphaddubd":        __asm_proxy_VPHADDUBD__,
    "vphaddubq":        __asm_proxy_VPHADDUBQ__,
    "vphaddubw":        __asm_proxy_VPHADDUBW__,
    "vphaddudq":        __asm_proxy_VPHADDUDQ__,
    "vphadduwd":        __asm_proxy_VPHADDUWD__,
    "vphadduwq":        __asm_proxy_VPHADDUWQ__,
    "vphaddw":          __asm_proxy_VPHADDW__,
    "vphaddwd":         __asm_proxy_VPHADDWD__,
    "vphaddwq":         __asm_proxy_VPHADDWQ__,
    "vphminposuw":      __asm_proxy_VPHMINPOSUW__,
    "vphsubbw":         __asm_proxy_VPHSUBBW__,
    "vphsubd":          __asm_proxy_VPHSUBD__,
    "vphsubdq":         __asm_proxy_VPHSUBDQ__,
    "vphsubsw":         __asm_proxy_VPHSUBSW__,
    "vphsubw":          __asm_proxy_VPHSUBW__,
    "vphsubwd":         __asm_proxy_VPHSUBWD__,
    "vpinsrb":          __asm_proxy_VPINSRB__,
    "vpinsrd":          __asm_proxy_VPINSRD__,
    "vpinsrq":          __asm_proxy_VPINSRQ__,
    "vpinsrw":          __asm_proxy_VPINSRW__,
    "vplzcntd":         __asm_proxy_VPLZCNTD__,
    "vplzcntq":         __asm_proxy_VPLZCNTQ__,
    "vpmacsdd":         __asm_proxy_VPMACSDD__,
    "vpmacsdqh":        __asm_proxy_VPMACSDQH__,
    "vpmacsdql":        __asm_proxy_VPMACSDQL__,
    "vpmacssdd":        __asm_proxy_VPMACSSDD__,
    "vpmacssdqh":       __asm_proxy_VPMACSSDQH__,
    "vpmacssdql":       __asm_proxy_VPMACSSDQL__,
    "vpmacsswd":        __asm_proxy_VPMACSSWD__,
    "vpmacssww":        __asm_proxy_VPMACSSWW__,
    "vpmacswd":         __asm_proxy_VPMACSWD__,
    "vpmacsww":         __asm_proxy_VPMACSWW__,
    "vpmadcsswd":       __asm_proxy_VPMADCSSWD__,
    "vpmadcswd":        __asm_proxy_VPMADCSWD__,
    "vpmadd52huq":      __asm_proxy_VPMADD52HUQ__,
    "vpmadd52luq":      __asm_proxy_VPMADD52LUQ__,
    "vpmaddubsw":       __asm_proxy_VPMADDUBSW__,
    "vpmaddwd":         __asm_proxy_VPMADDWD__,
    "vpmaskmovd":       __asm_proxy_VPMASKMOVD__,
    "vpmaskmovq":       __asm_proxy_VPMASKMOVQ__,
    "vpmaxsb":          __asm_proxy_VPMAXSB__,
    "vpmaxsd":          __asm_proxy_VPMAXSD__,
    "vpmaxsq":          __asm_proxy_VPMAXSQ__,
    "vpmaxsw":          __asm_proxy_VPMAXSW__,
    "vpmaxub":          __asm_proxy_VPMAXUB__,
    "vpmaxud":          __asm_proxy_VPMAXUD__,
    "vpmaxuq":          __asm_proxy_VPMAXUQ__,
    "vpmaxuw":          __asm_proxy_VPMAXUW__,
    "vpminsb":          __asm_proxy_VPMINSB__,
    "vpminsd":          __asm_proxy_VPMINSD__,
    "vpminsq":          __asm_proxy_VPMINSQ__,
    "vpminsw":          __asm_proxy_VPMINSW__,
    "vpminub":          __asm_proxy_VPMINUB__,
    "vpminud":          __asm_proxy_VPMINUD__,
    "vpminuq":          __asm_proxy_VPMINUQ__,
    "vpminuw":          __asm_proxy_VPMINUW__,
    "vpmovb2m":         __asm_proxy_VPMOVB2M__,
    "vpmovd2m":         __asm_proxy_VPMOVD2M__,
    "vpmovdb":          __asm_proxy_VPMOVDB__,
    "vpmovdw":          __asm_proxy_VPMOVDW__,
    "vpmovm2b":         __asm_proxy_VPMOVM2B__,
    "vpmovm2d":         __asm_proxy_VPMOVM2D__,
    "vpmovm2q":         __asm_proxy_VPMOVM2Q__,
    "vpmovm2w":         __asm_proxy_VPMOVM2W__,
    "vpmovmskb":        __asm_proxy_VPMOVMSKB__,
    "vpmovq2m":         __asm_proxy_VPMOVQ2M__,
    "vpmovqb":          __asm_proxy_VPMOVQB__,
    "vpmovqd":          __asm_proxy_VPMOVQD__,
    "vpmovqw":          __asm_proxy_VPMOVQW__,
    "vpmovsdb":         __asm_proxy_VPMOVSDB__,
    "vpmovsdw":         __asm_proxy_VPMOVSDW__,
    "vpmovsqb":         __asm_proxy_VPMOVSQB__,
    "vpmovsqd":         __asm_proxy_VPMOVSQD__,
    "vpmovsqw":         __asm_proxy_VPMOVSQW__,
    "vpmovswb":         __asm_proxy_VPMOVSWB__,
    "vpmovsxbd":        __asm_proxy_VPMOVSXBD__,
    "vpmovsxbq":        __asm_proxy_VPMOVSXBQ__,
    "vpmovsxbw":        __asm_proxy_VPMOVSXBW__,
    "vpmovsxdq":        __asm_proxy_VPMOVSXDQ__,
    "vpmovsxwd":        __asm_proxy_VPMOVSXWD__,
    "vpmovsxwq":        __asm_proxy_VPMOVSXWQ__,
    "vpmovusdb":        __asm_proxy_VPMOVUSDB__,
    "vpmovusdw":        __asm_proxy_VPMOVUSDW__,
    "vpmovusqb":        __asm_proxy_VPMOVUSQB__,
    "vpmovusqd":        __asm_proxy_VPMOVUSQD__,
    "vpmovusqw":        __asm_proxy_VPMOVUSQW__,
    "vpmovuswb":        __asm_proxy_VPMOVUSWB__,
    "vpmovw2m":         __asm_proxy_VPMOVW2M__,
    "vpmovwb":          __asm_proxy_VPMOVWB__,
    "vpmovzxbd":        __asm_proxy_VPMOVZXBD__,
    "vpmovzxbq":        __asm_proxy_VPMOVZXBQ__,
    "vpmovzxbw":        __asm_proxy_VPMOVZXBW__,
    "vpmovzxdq":        __asm_proxy_VPMOVZXDQ__,
    "vpmovzxwd":        __asm_proxy_VPMOVZXWD__,
    "vpmovzxwq":        __asm_proxy_VPMOVZXWQ__,
    "vpmuldq":          __asm_proxy_VPMULDQ__,
    "vpmulhrsw":        __asm_proxy_VPMULHRSW__,
    "vpmulhuw":         __asm_proxy_VPMULHUW__,
    "vpmulhw":          __asm_proxy_VPMULHW__,
    "vpmulld":          __asm_proxy_VPMULLD__,
    "vpmullq":          __asm_proxy_VPMULLQ__,
    "vpmullw":          __asm_proxy_VPMULLW__,
    "vpmultishiftqb":   __asm_proxy_VPMULTISHIFTQB__,
    "vpmuludq":         __asm_proxy_VPMULUDQ__,
    "vpopcntd":         __asm_proxy_VPOPCNTD__,
    "vpopcntq":         __asm_proxy_VPOPCNTQ__,
    "vpor":             __asm_proxy_VPOR__,
    "vpord":            __asm_proxy_VPORD__,
    "vporq":            __asm_proxy_VPORQ__,
    "vpperm":           __asm_proxy_VPPERM__,
    "vprold":           __asm_proxy_VPROLD__,
    "vprolq":           __asm_proxy_VPROLQ__,
    "vprolvd":          __asm_proxy_VPROLVD__,
    "vprolvq":          __asm_proxy_VPROLVQ__,
    "vprord":           __asm_proxy_VPRORD__,
    "vprorq":           __asm_proxy_VPRORQ__,
    "vprorvd":          __asm_proxy_VPRORVD__,
    "vprorvq":          __asm_proxy_VPRORVQ__,
    "vprotb":           __asm_proxy_VPROTB__,
    "vprotd":           __asm_proxy_VPROTD__,
    "vprotq":           __asm_proxy_VPROTQ__,
    "vprotw":           __asm_proxy_VPROTW__,
    "vpsadbw":          __asm_proxy_VPSADBW__,
    "vpscatterdd":      __asm_proxy_VPSCATTERDD__,
    "vpscatterdq":      __asm_proxy_VPSCATTERDQ__,
    "vpscatterqd":      __asm_proxy_VPSCATTERQD__,
    "vpscatterqq":      __asm_proxy_VPSCATTERQQ__,
    "vpshab":           __asm_proxy_VPSHAB__,
    "vpshad":           __asm_proxy_VPSHAD__,
    "vpshaq":           __asm_proxy_VPSHAQ__,
    "vpshaw":           __asm_proxy_VPSHAW__,
    "vpshlb":           __asm_proxy_VPSHLB__,
    "vpshld":           __asm_proxy_VPSHLD__,
    "vpshlq":           __asm_proxy_VPSHLQ__,
    "vpshlw":           __asm_proxy_VPSHLW__,
    "vpshufb":          __asm_proxy_VPSHUFB__,
    "vpshufd":          __asm_proxy_VPSHUFD__,
    "vpshufhw":         __asm_proxy_VPSHUFHW__,
    "vpshuflw":         __asm_proxy_VPSHUFLW__,
    "vpsignb":          __asm_proxy_VPSIGNB__,
    "vpsignd":          __asm_proxy_VPSIGND__,
    "vpsignw":          __asm_proxy_VPSIGNW__,
    "vpslld":           __asm_proxy_VPSLLD__,
    "vpslldq":          __asm_proxy_VPSLLDQ__,
    "vpsllq":           __asm_proxy_VPSLLQ__,
    "vpsllvd":          __asm_proxy_VPSLLVD__,
    "vpsllvq":          __asm_proxy_VPSLLVQ__,
    "vpsllvw":          __asm_proxy_VPSLLVW__,
    "vpsllw":           __asm_proxy_VPSLLW__,
    "vpsrad":           __asm_proxy_VPSRAD__,
    "vpsraq":           __asm_proxy_VPSRAQ__,
    "vpsravd":          __asm_proxy_VPSRAVD__,
    "vpsravq":          __asm_proxy_VPSRAVQ__,
    "vpsravw":          __asm_proxy_VPSRAVW__,
    "vpsraw":           __asm_proxy_VPSRAW__,
    "vpsrld":           __asm_proxy_VPSRLD__,
    "vpsrldq":          __asm_proxy_VPSRLDQ__,
    "vpsrlq":           __asm_proxy_VPSRLQ__,
    "vpsrlvd":          __asm_proxy_VPSRLVD__,
    "vpsrlvq":          __asm_proxy_VPSRLVQ__,
    "vpsrlvw":          __asm_proxy_VPSRLVW__,
    "vpsrlw":           __asm_proxy_VPSRLW__,
    "vpsubb":           __asm_proxy_VPSUBB__,
    "vpsubd":           __asm_proxy_VPSUBD__,
    "vpsubq":           __asm_proxy_VPSUBQ__,
    "vpsubsb":          __asm_proxy_VPSUBSB__,
    "vpsubsw":          __asm_proxy_VPSUBSW__,
    "vpsubusb":         __asm_proxy_VPSUBUSB__,
    "vpsubusw":         __asm_proxy_VPSUBUSW__,
    "vpsubw":           __asm_proxy_VPSUBW__,
    "vpternlogd":       __asm_proxy_VPTERNLOGD__,
    "vpternlogq":       __asm_proxy_VPTERNLOGQ__,
    "vptest":           __asm_proxy_VPTEST__,
    "vptestmb":         __asm_proxy_VPTESTMB__,
    "vptestmd":         __asm_proxy_VPTESTMD__,
    "vptestmq":         __asm_proxy_VPTESTMQ__,
    "vptestmw":         __asm_proxy_VPTESTMW__,
    "vptestnmb":        __asm_proxy_VPTESTNMB__,
    "vptestnmd":        __asm_proxy_VPTESTNMD__,
    "vptestnmq":        __asm_proxy_VPTESTNMQ__,
    "vptestnmw":        __asm_proxy_VPTESTNMW__,
    "vpunpckhbw":       __asm_proxy_VPUNPCKHBW__,
    "vpunpckhdq":       __asm_proxy_VPUNPCKHDQ__,
    "vpunpckhqdq":      __asm_proxy_VPUNPCKHQDQ__,
    "vpunpckhwd":       __asm_proxy_VPUNPCKHWD__,
    "vpunpcklbw":       __asm_proxy_VPUNPCKLBW__,
    "vpunpckldq":       __asm_proxy_VPUNPCKLDQ__,
    "vpunpcklqdq":      __asm_proxy_VPUNPCKLQDQ__,
    "vpunpcklwd":       __asm_proxy_VPUNPCKLWD__,
    "vpxor":            __asm_proxy_VPXOR__,
    "vpxord":           __asm_proxy_VPXORD__,
    "vpxorq":           __asm_proxy_VPXORQ__,
    "vrangepd":         __asm_proxy_VRANGEPD__,
    "vrangeps":         __asm_proxy_VRANGEPS__,
    "vrangesd":         __asm_proxy_VRANGESD__,
    "vrangess":         __asm_proxy_VRANGESS__,
    "vrcp14pd":         __asm_proxy_VRCP14PD__,
    "vrcp14ps":         __asm_proxy_VRCP14PS__,
    "vrcp14sd":         __asm_proxy_VRCP14SD__,
    "vrcp14ss":         __asm_proxy_VRCP14SS__,
    "vrcp28pd":         __asm_proxy_VRCP28PD__,
    "vrcp28ps":         __asm_proxy_VRCP28PS__,
    "vrcp28sd":         __asm_proxy_VRCP28SD__,
    "vrcp28ss":         __asm_proxy_VRCP28SS__,
    "vrcpps":           __asm_proxy_VRCPPS__,
    "vrcpss":           __asm_proxy_VRCPSS__,
    "vreducepd":        __asm_proxy_VREDUCEPD__,
    "vreduceps":        __asm_proxy_VREDUCEPS__,
    "vreducesd":        __asm_proxy_VREDUCESD__,
    "vreducess":        __asm_proxy_VREDUCESS__,
    "vrndscalepd":      __asm_proxy_VRNDSCALEPD__,
    "vrndscaleps":      __asm_proxy_VRNDSCALEPS__,
    "vrndscalesd":      __asm_proxy_VRNDSCALESD__,
    "vrndscaless":      __asm_proxy_VRNDSCALESS__,
    "vroundpd":         __asm_proxy_VROUNDPD__,
    "vroundps":         __asm_proxy_VROUNDPS__,
    "vroundsd":         __asm_proxy_VROUNDSD__,
    "vroundss":         __asm_proxy_VROUNDSS__,
    "vrsqrt14pd":       __asm_proxy_VRSQRT14PD__,
    "vrsqrt14ps":       __asm_proxy_VRSQRT14PS__,
    "vrsqrt14sd":       __asm_proxy_VRSQRT14SD__,
    "vrsqrt14ss":       __asm_proxy_VRSQRT14SS__,
    "vrsqrt28pd":       __asm_proxy_VRSQRT28PD__,
    "vrsqrt28ps":       __asm_proxy_VRSQRT28PS__,
    "vrsqrt28sd":       __asm_proxy_VRSQRT28SD__,
    "vrsqrt28ss":       __asm_proxy_VRSQRT28SS__,
    "vrsqrtps":         __asm_proxy_VRSQRTPS__,
    "vrsqrtss":         __asm_proxy_VRSQRTSS__,
    "vscalefpd":        __asm_proxy_VSCALEFPD__,
    "vscalefps":        __asm_proxy_VSCALEFPS__,
    "vscalefsd":        __asm_proxy_VSCALEFSD__,
    "vscalefss":        __asm_proxy_VSCALEFSS__,
    "vscatterdpd":      __asm_proxy_VSCATTERDPD__,
    "vscatterdps":      __asm_proxy_VSCATTERDPS__,
    "vscatterpf0dpd":   __asm_proxy_VSCATTERPF0DPD__,
    "vscatterpf0dps":   __asm_proxy_VSCATTERPF0DPS__,
    "vscatterpf0qpd":   __asm_proxy_VSCATTERPF0QPD__,
    "vscatterpf0qps":   __asm_proxy_VSCATTERPF0QPS__,
    "vscatterpf1dpd":   __asm_proxy_VSCATTERPF1DPD__,
    "vscatterpf1dps":   __asm_proxy_VSCATTERPF1DPS__,
    "vscatterpf1qpd":   __asm_proxy_VSCATTERPF1QPD__,
    "vscatterpf1qps":   __asm_proxy_VSCATTERPF1QPS__,
    "vscatterqpd":      __asm_proxy_VSCATTERQPD__,
    "vscatterqps":      __asm_proxy_VSCATTERQPS__,
    "vshuff32x4":       __asm_proxy_VSHUFF32X4__,
    "vshuff64x2":       __asm_proxy_VSHUFF64X2__,
    "vshufi32x4":       __asm_proxy_VSHUFI32X4__,
    "vshufi64x2":       __asm_proxy_VSHUFI64X2__,
    "vshufpd":          __asm_proxy_VSHUFPD__,
    "vshufps":          __asm_proxy_VSHUFPS__,
    "vsqrtpd":          __asm_proxy_VSQRTPD__,
    "vsqrtps":          __asm_proxy_VSQRTPS__,
    "vsqrtsd":          __asm_proxy_VSQRTSD__,
    "vsqrtss":          __asm_proxy_VSQRTSS__,
    "vstmxcsr":         __asm_proxy_VSTMXCSR__,
    "vsubpd":           __asm_proxy_VSUBPD__,
    "vsubps":           __asm_proxy_VSUBPS__,
    "vsubsd":           __asm_proxy_VSUBSD__,
    "vsubss":           __asm_proxy_VSUBSS__,
    "vtestpd":          __asm_proxy_VTESTPD__,
    "vtestps":          __asm_proxy_VTESTPS__,
    "vucomisd":         __asm_proxy_VUCOMISD__,
    "vucomiss":         __asm_proxy_VUCOMISS__,
    "vunpckhpd":        __asm_proxy_VUNPCKHPD__,
    "vunpckhps":        __asm_proxy_VUNPCKHPS__,
    "vunpcklpd":        __asm_proxy_VUNPCKLPD__,
    "vunpcklps":        __asm_proxy_VUNPCKLPS__,
    "vxorpd":           __asm_proxy_VXORPD__,
    "vxorps":           __asm_proxy_VXORPS__,
    "vzeroall":         __asm_proxy_VZEROALL__,
    "vzeroupper":       __asm_proxy_VZEROUPPER__,
    "xaddb":            __asm_proxy_XADDB__,
    "xaddl":            __asm_proxy_XADDL__,
    "xaddq":            __asm_proxy_XADDQ__,
    "xaddw":            __asm_proxy_XADDW__,
    "xchgb":            __asm_proxy_XCHGB__,
    "xchgl":            __asm_proxy_XCHGL__,
    "xchgq":            __asm_proxy_XCHGQ__,
    "xchgw":            __asm_proxy_XCHGW__,
    "xgetbv":           __asm_proxy_XGETBV__,
    "xlatb":            __asm_proxy_XLATB__,
    "xorb":             __asm_proxy_XORB__,
    "xorl":             __asm_proxy_XORL__,
    "xorpd":            __asm_proxy_XORPD__,
    "xorps":            __asm_proxy_XORPS__,
    "xorq":             __asm_proxy_XORQ__,
    "xorw":             __asm_proxy_XORW__,
}

Registers maps register name into Register instances. 

var Registers = map[string]Register{
    "al":    AL,
    "cl":    CL,
    "dl":    DL,
    "bl":    BL,
    "spl":   SPL,
    "bpl":   BPL,
    "sil":   SIL,
    "dil":   DIL,
    "r8b":   R8b,
    "r9b":   R9b,
    "r10b":  R10b,
    "r11b":  R11b,
    "r12b":  R12b,
    "r13b":  R13b,
    "r14b":  R14b,
    "r15b":  R15b,
    "ah":    AH,
    "ch":    CH,
    "dh":    DH,
    "bh":    BH,
    "ax":    AX,
    "cx":    CX,
    "dx":    DX,
    "bx":    BX,
    "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,
    "r8d":   R8d,
    "r9d":   R9d,
    "r10d":  R10d,
    "r11d":  R11d,
    "r12d":  R12d,
    "r13d":  R13d,
    "r14d":  R14d,
    "r15d":  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,
    "k0":    K0,
    "k1":    K1,
    "k2":    K2,
    "k3":    K3,
    "k4":    K4,
    "k5":    K5,
    "k6":    K6,
    "k7":    K7,
    "mm0":   MM0,
    "mm1":   MM1,
    "mm2":   MM2,
    "mm3":   MM3,
    "mm4":   MM4,
    "mm5":   MM5,
    "mm6":   MM6,
    "mm7":   MM7,
    "xmm0":  XMM0,
    "xmm1":  XMM1,
    "xmm2":  XMM2,
    "xmm3":  XMM3,
    "xmm4":  XMM4,
    "xmm5":  XMM5,
    "xmm6":  XMM6,
    "xmm7":  XMM7,
    "xmm8":  XMM8,
    "xmm9":  XMM9,
    "xmm10": XMM10,
    "xmm11": XMM11,
    "xmm12": XMM12,
    "xmm13": XMM13,
    "xmm14": XMM14,
    "xmm15": XMM15,
    "xmm16": XMM16,
    "xmm17": XMM17,
    "xmm18": XMM18,
    "xmm19": XMM19,
    "xmm20": XMM20,
    "xmm21": XMM21,
    "xmm22": XMM22,
    "xmm23": XMM23,
    "xmm24": XMM24,
    "xmm25": XMM25,
    "xmm26": XMM26,
    "xmm27": XMM27,
    "xmm28": XMM28,
    "xmm29": XMM29,
    "xmm30": XMM30,
    "xmm31": XMM31,
    "ymm0":  YMM0,
    "ymm1":  YMM1,
    "ymm2":  YMM2,
    "ymm3":  YMM3,
    "ymm4":  YMM4,
    "ymm5":  YMM5,
    "ymm6":  YMM6,
    "ymm7":  YMM7,
    "ymm8":  YMM8,
    "ymm9":  YMM9,
    "ymm10": YMM10,
    "ymm11": YMM11,
    "ymm12": YMM12,
    "ymm13": YMM13,
    "ymm14": YMM14,
    "ymm15": YMM15,
    "ymm16": YMM16,
    "ymm17": YMM17,
    "ymm18": YMM18,
    "ymm19": YMM19,
    "ymm20": YMM20,
    "ymm21": YMM21,
    "ymm22": YMM22,
    "ymm23": YMM23,
    "ymm24": YMM24,
    "ymm25": YMM25,
    "ymm26": YMM26,
    "ymm27": YMM27,
    "ymm28": YMM28,
    "ymm29": YMM29,
    "ymm30": YMM30,
    "ymm31": YMM31,
    "zmm0":  ZMM0,
    "zmm1":  ZMM1,
    "zmm2":  ZMM2,
    "zmm3":  ZMM3,
    "zmm4":  ZMM4,
    "zmm5":  ZMM5,
    "zmm6":  ZMM6,
    "zmm7":  ZMM7,
    "zmm8":  ZMM8,
    "zmm9":  ZMM9,
    "zmm10": ZMM10,
    "zmm11": ZMM11,
    "zmm12": ZMM12,
    "zmm13": ZMM13,
    "zmm14": ZMM14,
    "zmm15": ZMM15,
    "zmm16": ZMM16,
    "zmm17": ZMM17,
    "zmm18": ZMM18,
    "zmm19": ZMM19,
    "zmm20": ZMM20,
    "zmm21": ZMM21,
    "zmm22": ZMM22,
    "zmm23": ZMM23,
    "zmm24": ZMM24,
    "zmm25": ZMM25,
    "zmm26": ZMM26,
    "zmm27": ZMM27,
    "zmm28": ZMM28,
    "zmm29": ZMM29,
    "zmm30": ZMM30,
    "zmm31": ZMM31,
}

type AddressType

AddressType indicates which kind of value that an Addressable object contains. 

type AddressType uint
const (
    // None indicates the Addressable does not contain any addressable value.
    None AddressType = iota

    // Memory indicates the Addressable contains a memory address.
    Memory

    // Offset indicates the Addressable contains an RIP-relative offset.
    Offset

    // Reference indicates the Addressable contains a label reference.
    Reference
)

type Addressable

Addressable is a union to represent an addressable operand. 

type Addressable struct {
    Type      AddressType
    Memory    MemoryAddress
    Offset    RelativeOffset
    Reference *Label
}

func (*Addressable) String 

func (self *Addressable) String() string

String implements the fmt.Stringer interface.

type Arch

Arch represents the x86_64 architecture. 

type Arch struct {
    // contains filtered or unexported fields
}

func CreateArch 

func CreateArch() *Arch

CreateArch creates a new Arch with all ISA enabled.

func (*Arch) CreateProgram 

func (self *Arch) CreateProgram() *Program

CreateProgram creates a new empty program.

func (*Arch) DisableISA 

func (self *Arch) DisableISA(isa ISA) *Arch

DisableISA disables a particular ISA.

func (*Arch) EnableISA 

func (self *Arch) EnableISA(isa ISA) *Arch

EnableISA enables a particular ISA.

func (*Arch) HasISA 

func (self *Arch) HasISA(isa ISA) bool

HasISA checks if a particular ISA was enabled.

type Assembler

Assembler assembles the entire assembly program and generates the corresponding machine code representations. 

type Assembler struct {
    // contains filtered or unexported fields
}

func (*Assembler) Assemble 

func (self *Assembler) Assemble(src string) error

Assemble assembles the assembly source and save the machine code to internal buffer.

func (*Assembler) Base 

func (self *Assembler) Base() uintptr

Base returns the origin.

func (*Assembler) Code 

func (self *Assembler) Code() []byte

Code returns the assembled machine code.

func (*Assembler) Entry 

func (self *Assembler) Entry() uintptr

Entry returns the address of the specified entry point, or the origin if not specified.

func (*Assembler) Options 

func (self *Assembler) Options() *Options

Options returns the internal options reference, changing it WILL affect this Assembler instance.

func (*Assembler) WithBase 

func (self *Assembler) WithBase(pc uintptr) *Assembler

WithBase resets the origin to pc.

type Disposable

Disposable is a type of object that can be Free'd manually. 

type Disposable interface {
    Free()
}

type ExceptionControl

ExceptionControl represents the "Suppress All Exceptions" flag. 

type ExceptionControl uint8
const (
    // SAE represents the flag "Suppress All Exceptions" for floating point operations.
    SAE ExceptionControl = iota
)

func (ExceptionControl) String 

func (ExceptionControl) String() string

type ISA

ISA represents an extension to x86-64 instruction set. 

type ISA uint64
const (
    ISA_CPUID ISA = 1 << iota
    ISA_RDTSC
    ISA_RDTSCP
    ISA_CMOV
    ISA_MOVBE
    ISA_POPCNT
    ISA_LZCNT
    ISA_TBM
    ISA_BMI
    ISA_BMI2
    ISA_ADX
    ISA_MMX
    ISA_MMX_PLUS
    ISA_FEMMS
    ISA_3DNOW
    ISA_3DNOW_PLUS
    ISA_SSE
    ISA_SSE2
    ISA_SSE3
    ISA_SSSE3
    ISA_SSE4A
    ISA_SSE4_1
    ISA_SSE4_2
    ISA_FMA3
    ISA_FMA4
    ISA_XOP
    ISA_F16C
    ISA_AVX
    ISA_AVX2
    ISA_AVX512F
    ISA_AVX512BW
    ISA_AVX512DQ
    ISA_AVX512VL
    ISA_AVX512PF
    ISA_AVX512ER
    ISA_AVX512CD
    ISA_AVX512VBMI
    ISA_AVX512IFMA
    ISA_AVX512VPOPCNTDQ
    ISA_AVX512_4VNNIW
    ISA_AVX512_4FMAPS
    ISA_PREFETCH
    ISA_PREFETCHW
    ISA_PREFETCHWT1
    ISA_CLFLUSH
    ISA_CLFLUSHOPT
    ISA_CLWB
    ISA_CLZERO
    ISA_RDRAND
    ISA_RDSEED
    ISA_PCLMULQDQ
    ISA_AES
    ISA_SHA
    ISA_MONITOR
    ISA_MONITORX
    ISA_ALL = ^ISA(0)
)

func ParseISA 

func ParseISA(name string) ISA

ParseISA parses name into ISA, it will panic if the name is invalid.

func (ISA) String 

func (self ISA) String() string

type Instruction

Instruction represents an unencoded instruction. 

type Instruction struct {
    // contains filtered or unexported fields
}

func (*Instruction) CS 

func (self *Instruction) CS() *Instruction

CS overrides the memory operation of this instruction to CS.

func (*Instruction) DS 

func (self *Instruction) DS() *Instruction

DS overrides the memory operation of this instruction to DS, this is the default section for most instructions if not specified.

func (*Instruction) Domain 

func (self *Instruction) Domain() InstructionDomain

Domain returns the domain of this instruction.

func (*Instruction) ES 

func (self *Instruction) ES() *Instruction

ES overrides the memory operation of this instruction to ES.

func (*Instruction) FS 

func (self *Instruction) FS() *Instruction

FS overrides the memory operation of this instruction to FS.

func (*Instruction) GS 

func (self *Instruction) GS() *Instruction

GS overrides the memory operation of this instruction to GS.

func (*Instruction) LOCK 

func (self *Instruction) LOCK() *Instruction

LOCK causes the processor's LOCK# signal to be asserted during execution of the accompanying instruction (turns the instruction into an atomic instruction). In a multiprocessor environment, the LOCK# signal insures that the processor has exclusive use of any shared memory while the signal is asserted.

func (*Instruction) Name 

func (self *Instruction) Name() string

Name returns the instruction name.

func (*Instruction) Operands 

func (self *Instruction) Operands() []interface{}

Operands returns the operands of this instruction.

func (*Instruction) SS 

func (self *Instruction) SS() *Instruction

SS overrides the memory operation of this instruction to SS.

type InstructionDomain

InstructionDomain represents the domain of an instruction. 

type InstructionDomain uint8
const (
    DomainGeneric InstructionDomain = iota
    DomainMMXSSE
    DomainAVX
    DomainFMA
    DomainCrypto
    DomainMask
    DomainAMDSpecific
    DomainMisc
    DomainPseudo
)

type InstructionPrefix

InstructionPrefix indicates the prefix bytes prepended to the instruction. 

type InstructionPrefix byte
const (
    // PrefixLock causes the processor's LOCK# signal to be asserted during execution of
    // the accompanying instruction (turns the instruction into an atomic instruction).
    // In a multiprocessor environment, the LOCK# signal insures that the processor
    // has exclusive use of any shared memory while the signal is asserted.
    PrefixLock InstructionPrefix = iota

    // PrefixSegmentCS overrides the memory operation of this instruction to CS (Code Segment).
    PrefixSegmentCS

    // PrefixSegmentDS overrides the memory operation of this instruction to DS (Data Segment),
    // this is the default section for most instructions if not specified.
    PrefixSegmentDS

    // PrefixSegmentES overrides the memory operation of this instruction to ES (Extra Segment).
    PrefixSegmentES

    // PrefixSegmentFS overrides the memory operation of this instruction to FS.
    PrefixSegmentFS

    // PrefixSegmentGS overrides the memory operation of this instruction to GS.
    PrefixSegmentGS

    // PrefixSegmentSS overrides the memory operation of this instruction to SS (Stack Segment).
    PrefixSegmentSS
)

type KRegister 

type KRegister byte
const (
    K0 KRegister = iota
    K1
    K2
    K3
    K4
    K5
    K6
    K7
)

func (KRegister) String 

func (self KRegister) String() string

type Label

Label represents a location within the program. 

type Label struct {
    Name string
    Dest *Instruction
    // contains filtered or unexported fields
}

func CreateLabel 

func CreateLabel(name string) *Label

CreateLabel creates a new Label, it may allocate a new one or grab one from a pool.

func (*Label) Evaluate 

func (self *Label) Evaluate() (int64, error)

Evaluate implements the interface expr.Term.

func (*Label) Free 

func (self *Label) Free()

Free decreases the reference count of a Label, if the refcount drops to 0, the Label will be recycled.

func (*Label) Retain 

func (self *Label) Retain() *Label

Retain increases the reference count of a Label.

func (*Label) String 

func (self *Label) String() string

String implements the fmt.Stringer interface.

type LabelKind

LabelKind indicates the type of label reference. 

type LabelKind int
const (
    // Declaration means the label is a declaration.
    Declaration LabelKind = iota + 1

    // BranchTarget means the label should be treated as a branch target.
    BranchTarget

    // RelativeAddress means the label should be treated as a reference to
    // the code section (e.g. RIP-relative addressing).
    RelativeAddress
)

type LineKind

LineKind indicates the type of ParsedLine. 

type LineKind int
const (
    // LineLabel means the ParsedLine is a label.
    LineLabel LineKind = iota + 1

    // LineInstr means the ParsedLine is an instruction.
    LineInstr

    // LineCommand means the ParsedLine is a ParsedCommand.
    LineCommand
)

type MMRegister 

type MMRegister byte
const (
    MM0 MMRegister = iota
    MM1
    MM2
    MM3
    MM4
    MM5
    MM6
    MM7
)

func (MMRegister) String 

func (self MMRegister) String() string

type MaskedRegister

MaskedRegister is a Register masked by a RegisterMask. 

type MaskedRegister struct {
    Reg  Register
    Mask RegisterMask
}

func (MaskedRegister) String 

func (self MaskedRegister) String() string

String implements the fmt.Stringer interface.

type MemoryAddress

MemoryAddress represents a memory address. 

type MemoryAddress struct {
    Base         Register
    Index        Register
    Scale        uint8
    Displacement int32
}

func (*MemoryAddress) EnsureValid 

func (self *MemoryAddress) EnsureValid()

EnsureValid checks if the memory address is valid, if not, it panics.

func (*MemoryAddress) String 

func (self *MemoryAddress) String() string

String implements the fmt.Stringer interface.

type MemoryOperand

MemoryOperand represents a memory operand for an instruction. 

type MemoryOperand struct {
    Size      int
    Addr      Addressable
    Mask      RegisterMask
    Masked    bool
    Broadcast uint8
    // contains filtered or unexported fields
}

func Abs 

func Abs(disp int32) *MemoryOperand

Abs construct a simple memory address that represents absolute addressing.

func CreateMemoryOperand 

func CreateMemoryOperand() *MemoryOperand

CreateMemoryOperand creates a new MemoryOperand, it may allocate a new one or grab one from a pool.

func Ptr 

func Ptr(base Register, disp int32) *MemoryOperand

Ptr constructs a simple memory operand with base and displacement.

func Ref 

func Ref(ref *Label) (v *MemoryOperand)

Ref constructs a memory reference to a label.

func Sib 

func Sib(base Register, index Register, scale uint8, disp int32) (v *MemoryOperand)

Sib constructs a simple memory operand that represents a complete memory address.

func (*MemoryOperand) EnsureValid 

func (self *MemoryOperand) EnsureValid()

EnsureValid checks if the memory operand is valid, if not, it panics.

func (*MemoryOperand) Free 

func (self *MemoryOperand) Free()

Free decreases the reference count of a MemoryOperand, if the refcount drops to 0, the Label will be recycled.

func (*MemoryOperand) Retain 

func (self *MemoryOperand) Retain() *MemoryOperand

Retain increases the reference count of a MemoryOperand.

func (*MemoryOperand) String 

func (self *MemoryOperand) String() string

String implements the fmt.Stringer interface.

type OperandKind

OperandKind indicates the type of the operand. 

type OperandKind int
const (
    // OpImm means the operand is an immediate value.
    OpImm OperandKind = 1 << iota

    // OpReg means the operand is a register.
    OpReg

    // OpMem means the operand is a memory address.
    OpMem

    // OpLabel means the operand is a label, specifically for
    // branch instructions.
    OpLabel
)

type Operands

Operands represents a sequence of operand required by an instruction. 

type Operands [_N_args]interface{}

type Options

Options controls the behavior of Assembler. 

type Options struct {
    // InstructionAliasing specifies whether to enable instruction aliasing.
    // Set to true enables instruction aliasing, and the Assembler will try harder to find instructions.
    InstructionAliasing bool

    // IgnoreUnknownDirectives specifies whether to report errors when encountered unknown directives.
    // Set to true ignores all unknwon directives silently, useful for parsing generated assembly.
    IgnoreUnknownDirectives bool
}

type ParsedCommand

ParsedCommand represents a parsed assembly directive command. 

type ParsedCommand struct {
    Cmd  string
    Args []ParsedCommandArg
}

type ParsedCommandArg

ParsedCommandArg represents an argument of a ParsedCommand. 

type ParsedCommandArg struct {
    Value    string
    IsString bool
}

type ParsedInstruction

ParsedInstruction represents an instruction in the source. 

type ParsedInstruction struct {
    Mnemonic string
    Operands []ParsedOperand
    Prefixes []InstructionPrefix
}

type ParsedLabel

ParsedLabel represents a label in the source, either a jump target or an RIP-relative addressing. 

type ParsedLabel struct {
    Name string
    Kind LabelKind
}

type ParsedLine

ParsedLine represents a parsed source line. 

type ParsedLine struct {
    Row         int
    Src         []rune
    Kind        LineKind
    Label       ParsedLabel
    Command     ParsedCommand
    Instruction ParsedInstruction
}

type ParsedOperand

ParsedOperand represents an operand of an instruction in the source. 

type ParsedOperand struct {
    Op     OperandKind
    Imm    int64
    Reg    Register
    Label  ParsedLabel
    Memory MemoryAddress
}

type Parser

Parser parses the source, and generates a sequence of ParsedInstruction's. 

type Parser struct {
    // contains filtered or unexported fields
}

func (*Parser) Directive 

func (self *Parser) Directive(line string) (err error)

Directive handles the directive.

func (*Parser) Feed 

func (self *Parser) Feed(src string) (ret *ParsedLine, err error)

Feed feeds the parser with one more line, and the parser parses it into a ParsedLine.

NOTE: Feed does not handle empty lines or multiple lines, 

it panics when this happens. Use Parse to parse multiple
lines of assembly source.

func (*Parser) Parse 

func (self *Parser) Parse(src string) (ret []*ParsedLine, err error)

Parse parses the entire assembly source (possibly multiple lines) into a sequence of *ParsedLine.

type Program

Program represents a sequence of instructions. 

type Program struct {
    // contains filtered or unexported fields
}

func (*Program) ADCB 

func (self *Program) ADCB(v0 interface{}, v1 interface{}) *Instruction

ADCB performs "Add with Carry".

Mnemonic : ADC Supported forms : (6 forms)

func (*Program) ADCL 

func (self *Program) ADCL(v0 interface{}, v1 interface{}) *Instruction

ADCL performs "Add with Carry".

Mnemonic : ADC Supported forms : (8 forms)

func (*Program) ADCQ 

func (self *Program) ADCQ(v0 interface{}, v1 interface{}) *Instruction

ADCQ performs "Add with Carry".

Mnemonic : ADC Supported forms : (8 forms)

func (*Program) ADCW 

func (self *Program) ADCW(v0 interface{}, v1 interface{}) *Instruction

ADCW performs "Add with Carry".

Mnemonic : ADC Supported forms : (8 forms)

func (*Program) ADCXL 

func (self *Program) ADCXL(v0 interface{}, v1 interface{}) *Instruction

ADCXL performs "Unsigned Integer Addition of Two Operands with Carry Flag".

Mnemonic : ADCX Supported forms : (2 forms)

func (*Program) ADCXQ 

func (self *Program) ADCXQ(v0 interface{}, v1 interface{}) *Instruction

ADCXQ performs "Unsigned Integer Addition of Two Operands with Carry Flag".

Mnemonic : ADCX Supported forms : (2 forms)

func (*Program) ADDB 

func (self *Program) ADDB(v0 interface{}, v1 interface{}) *Instruction

ADDB performs "Add".

Mnemonic : ADD Supported forms : (6 forms)

func (*Program) ADDL 

func (self *Program) ADDL(v0 interface{}, v1 interface{}) *Instruction

ADDL performs "Add".

Mnemonic : ADD Supported forms : (8 forms)

func (*Program) ADDPD 

func (self *Program) ADDPD(v0 interface{}, v1 interface{}) *Instruction

ADDPD performs "Add Packed Double-Precision Floating-Point Values".

Mnemonic : ADDPD Supported forms : (2 forms)

func (*Program) ADDPS 

func (self *Program) ADDPS(v0 interface{}, v1 interface{}) *Instruction

ADDPS performs "Add Packed Single-Precision Floating-Point Values".

Mnemonic : ADDPS Supported forms : (2 forms)

func (*Program) ADDQ 

func (self *Program) ADDQ(v0 interface{}, v1 interface{}) *Instruction

ADDQ performs "Add".

Mnemonic : ADD Supported forms : (8 forms)

func (*Program) ADDSD 

func (self *Program) ADDSD(v0 interface{}, v1 interface{}) *Instruction

ADDSD performs "Add Scalar Double-Precision Floating-Point Values".

Mnemonic : ADDSD Supported forms : (2 forms)

func (*Program) ADDSS 

func (self *Program) ADDSS(v0 interface{}, v1 interface{}) *Instruction

ADDSS performs "Add Scalar Single-Precision Floating-Point Values".

Mnemonic : ADDSS Supported forms : (2 forms)

func (*Program) ADDSUBPD 

func (self *Program) ADDSUBPD(v0 interface{}, v1 interface{}) *Instruction

ADDSUBPD performs "Packed Double-FP Add/Subtract".

Mnemonic : ADDSUBPD Supported forms : (2 forms)

func (*Program) ADDSUBPS 

func (self *Program) ADDSUBPS(v0 interface{}, v1 interface{}) *Instruction

ADDSUBPS performs "Packed Single-FP Add/Subtract".

Mnemonic : ADDSUBPS Supported forms : (2 forms)

func (*Program) ADDW 

func (self *Program) ADDW(v0 interface{}, v1 interface{}) *Instruction

ADDW performs "Add".

Mnemonic : ADD Supported forms : (8 forms)

func (*Program) ADOXL 

func (self *Program) ADOXL(v0 interface{}, v1 interface{}) *Instruction

ADOXL performs "Unsigned Integer Addition of Two Operands with Overflow Flag".

Mnemonic : ADOX Supported forms : (2 forms)

func (*Program) ADOXQ 

func (self *Program) ADOXQ(v0 interface{}, v1 interface{}) *Instruction

ADOXQ performs "Unsigned Integer Addition of Two Operands with Overflow Flag".

Mnemonic : ADOX Supported forms : (2 forms)

func (*Program) AESDEC 

func (self *Program) AESDEC(v0 interface{}, v1 interface{}) *Instruction

AESDEC performs "Perform One Round of an AES Decryption Flow".

Mnemonic : AESDEC Supported forms : (2 forms)

func (*Program) AESDECLAST 

func (self *Program) AESDECLAST(v0 interface{}, v1 interface{}) *Instruction

AESDECLAST performs "Perform Last Round of an AES Decryption Flow".

Mnemonic : AESDECLAST Supported forms : (2 forms)

func (*Program) AESENC 

func (self *Program) AESENC(v0 interface{}, v1 interface{}) *Instruction

AESENC performs "Perform One Round of an AES Encryption Flow".

Mnemonic : AESENC Supported forms : (2 forms)

func (*Program) AESENCLAST 

func (self *Program) AESENCLAST(v0 interface{}, v1 interface{}) *Instruction

AESENCLAST performs "Perform Last Round of an AES Encryption Flow".

Mnemonic : AESENCLAST Supported forms : (2 forms)

func (*Program) AESIMC 

func (self *Program) AESIMC(v0 interface{}, v1 interface{}) *Instruction

AESIMC performs "Perform the AES InvMixColumn Transformation".

Mnemonic : AESIMC Supported forms : (2 forms)

func (*Program) AESKEYGENASSIST 

func (self *Program) AESKEYGENASSIST(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

AESKEYGENASSIST performs "AES Round Key Generation Assist".

Mnemonic : AESKEYGENASSIST Supported forms : (2 forms)

func (*Program) ANDB 

func (self *Program) ANDB(v0 interface{}, v1 interface{}) *Instruction

ANDB performs "Logical AND".

Mnemonic : AND Supported forms : (6 forms)

func (*Program) ANDL 

func (self *Program) ANDL(v0 interface{}, v1 interface{}) *Instruction

ANDL performs "Logical AND".

Mnemonic : AND Supported forms : (8 forms)

func (*Program) ANDNL 

func (self *Program) ANDNL(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

ANDNL performs "Logical AND NOT".

Mnemonic : ANDN Supported forms : (2 forms)

func (*Program) ANDNPD 

func (self *Program) ANDNPD(v0 interface{}, v1 interface{}) *Instruction

ANDNPD performs "Bitwise Logical AND NOT of Packed Double-Precision Floating-Point Values".

Mnemonic : ANDNPD Supported forms : (2 forms)

func (*Program) ANDNPS 

func (self *Program) ANDNPS(v0 interface{}, v1 interface{}) *Instruction

ANDNPS performs "Bitwise Logical AND NOT of Packed Single-Precision Floating-Point Values".

Mnemonic : ANDNPS Supported forms : (2 forms)

func (*Program) ANDNQ 

func (self *Program) ANDNQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

ANDNQ performs "Logical AND NOT".

Mnemonic : ANDN Supported forms : (2 forms)

func (*Program) ANDPD 

func (self *Program) ANDPD(v0 interface{}, v1 interface{}) *Instruction

ANDPD performs "Bitwise Logical AND of Packed Double-Precision Floating-Point Values".

Mnemonic : ANDPD Supported forms : (2 forms)

func (*Program) ANDPS 

func (self *Program) ANDPS(v0 interface{}, v1 interface{}) *Instruction

ANDPS performs "Bitwise Logical AND of Packed Single-Precision Floating-Point Values".

Mnemonic : ANDPS Supported forms : (2 forms)

func (*Program) ANDQ 

func (self *Program) ANDQ(v0 interface{}, v1 interface{}) *Instruction

ANDQ performs "Logical AND".

Mnemonic : AND Supported forms : (8 forms)

func (*Program) ANDW 

func (self *Program) ANDW(v0 interface{}, v1 interface{}) *Instruction

ANDW performs "Logical AND".

Mnemonic : AND Supported forms : (8 forms)

func (*Program) Align 

func (self *Program) Align(align uint64, padding *expr.Expr) (p *Instruction)

Align is a pseudo-instruction to ensure the PC is aligned to a certain value.

func (*Program) Assemble 

func (self *Program) Assemble(pc uintptr) (ret []byte)

Assemble assembles and links the entire program into machine code.

func (*Program) AssembleAndFree 

func (self *Program) AssembleAndFree(pc uintptr) (ret []byte)

AssembleAndFree is like Assemble, but it frees the Program after assembling.

func (*Program) BEXTR 

func (self *Program) BEXTR(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

BEXTR performs "Bit Field Extract".

Mnemonic : BEXTR Supported forms : (8 forms)

func (*Program) BLCFILL 

func (self *Program) BLCFILL(v0 interface{}, v1 interface{}) *Instruction

BLCFILL performs "Fill From Lowest Clear Bit".

Mnemonic : BLCFILL Supported forms : (4 forms)

func (*Program) BLCI 

func (self *Program) BLCI(v0 interface{}, v1 interface{}) *Instruction

BLCI performs "Isolate Lowest Clear Bit".

Mnemonic : BLCI Supported forms : (4 forms)

func (*Program) BLCIC 

func (self *Program) BLCIC(v0 interface{}, v1 interface{}) *Instruction

BLCIC performs "Isolate Lowest Set Bit and Complement".

Mnemonic : BLCIC Supported forms : (4 forms)

func (*Program) BLCMSK 

func (self *Program) BLCMSK(v0 interface{}, v1 interface{}) *Instruction

BLCMSK performs "Mask From Lowest Clear Bit".

Mnemonic : BLCMSK Supported forms : (4 forms)

func (*Program) BLCS 

func (self *Program) BLCS(v0 interface{}, v1 interface{}) *Instruction

BLCS performs "Set Lowest Clear Bit".

Mnemonic : BLCS Supported forms : (4 forms)

func (*Program) BLENDPD 

func (self *Program) BLENDPD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

BLENDPD performs "Blend Packed Double Precision Floating-Point Values".

Mnemonic : BLENDPD Supported forms : (2 forms)

func (*Program) BLENDPS 

func (self *Program) BLENDPS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

BLENDPS performs " Blend Packed Single Precision Floating-Point Values".

Mnemonic : BLENDPS Supported forms : (2 forms)

func (*Program) BLENDVPD 

func (self *Program) BLENDVPD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

BLENDVPD performs " Variable Blend Packed Double Precision Floating-Point Values".

Mnemonic : BLENDVPD Supported forms : (2 forms)

func (*Program) BLENDVPS 

func (self *Program) BLENDVPS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

BLENDVPS performs " Variable Blend Packed Single Precision Floating-Point Values".

Mnemonic : BLENDVPS Supported forms : (2 forms)

func (*Program) BLSFILL 

func (self *Program) BLSFILL(v0 interface{}, v1 interface{}) *Instruction

BLSFILL performs "Fill From Lowest Set Bit".

Mnemonic : BLSFILL Supported forms : (4 forms)

func (*Program) BLSI 

func (self *Program) BLSI(v0 interface{}, v1 interface{}) *Instruction

BLSI performs "Isolate Lowest Set Bit".

Mnemonic : BLSI Supported forms : (4 forms)

func (*Program) BLSIC 

func (self *Program) BLSIC(v0 interface{}, v1 interface{}) *Instruction

BLSIC performs "Isolate Lowest Set Bit and Complement".

Mnemonic : BLSIC Supported forms : (4 forms)

func (*Program) BLSMSK 

func (self *Program) BLSMSK(v0 interface{}, v1 interface{}) *Instruction

BLSMSK performs "Mask From Lowest Set Bit".

Mnemonic : BLSMSK Supported forms : (4 forms)

func (*Program) BLSR 

func (self *Program) BLSR(v0 interface{}, v1 interface{}) *Instruction

BLSR performs "Reset Lowest Set Bit".

Mnemonic : BLSR Supported forms : (4 forms)

func (*Program) BSFL 

func (self *Program) BSFL(v0 interface{}, v1 interface{}) *Instruction

BSFL performs "Bit Scan Forward".

Mnemonic : BSF Supported forms : (2 forms)

func (*Program) BSFQ 

func (self *Program) BSFQ(v0 interface{}, v1 interface{}) *Instruction

BSFQ performs "Bit Scan Forward".

Mnemonic : BSF Supported forms : (2 forms)

func (*Program) BSFW 

func (self *Program) BSFW(v0 interface{}, v1 interface{}) *Instruction

BSFW performs "Bit Scan Forward".

Mnemonic : BSF Supported forms : (2 forms)

func (*Program) BSRL 

func (self *Program) BSRL(v0 interface{}, v1 interface{}) *Instruction

BSRL performs "Bit Scan Reverse".

Mnemonic : BSR Supported forms : (2 forms)

func (*Program) BSRQ 

func (self *Program) BSRQ(v0 interface{}, v1 interface{}) *Instruction

BSRQ performs "Bit Scan Reverse".

Mnemonic : BSR Supported forms : (2 forms)

func (*Program) BSRW 

func (self *Program) BSRW(v0 interface{}, v1 interface{}) *Instruction

BSRW performs "Bit Scan Reverse".

Mnemonic : BSR Supported forms : (2 forms)

func (*Program) BSWAPL 

func (self *Program) BSWAPL(v0 interface{}) *Instruction

BSWAPL performs "Byte Swap".

Mnemonic : BSWAP Supported forms : (1 form)

func (*Program) BSWAPQ 

func (self *Program) BSWAPQ(v0 interface{}) *Instruction

BSWAPQ performs "Byte Swap".

Mnemonic : BSWAP Supported forms : (1 form)

func (*Program) BTCL 

func (self *Program) BTCL(v0 interface{}, v1 interface{}) *Instruction

BTCL performs "Bit Test and Complement".

Mnemonic : BTC Supported forms : (4 forms)

func (*Program) BTCQ 

func (self *Program) BTCQ(v0 interface{}, v1 interface{}) *Instruction

BTCQ performs "Bit Test and Complement".

Mnemonic : BTC Supported forms : (4 forms)

func (*Program) BTCW 

func (self *Program) BTCW(v0 interface{}, v1 interface{}) *Instruction

BTCW performs "Bit Test and Complement".

Mnemonic : BTC Supported forms : (4 forms)

func (*Program) BTL 

func (self *Program) BTL(v0 interface{}, v1 interface{}) *Instruction

BTL performs "Bit Test".

Mnemonic : BT Supported forms : (4 forms)

func (*Program) BTQ 

func (self *Program) BTQ(v0 interface{}, v1 interface{}) *Instruction

BTQ performs "Bit Test".

Mnemonic : BT Supported forms : (4 forms)

func (*Program) BTRL 

func (self *Program) BTRL(v0 interface{}, v1 interface{}) *Instruction

BTRL performs "Bit Test and Reset".

Mnemonic : BTR Supported forms : (4 forms)

func (*Program) BTRQ 

func (self *Program) BTRQ(v0 interface{}, v1 interface{}) *Instruction

BTRQ performs "Bit Test and Reset".

Mnemonic : BTR Supported forms : (4 forms)

func (*Program) BTRW 

func (self *Program) BTRW(v0 interface{}, v1 interface{}) *Instruction

BTRW performs "Bit Test and Reset".

Mnemonic : BTR Supported forms : (4 forms)

func (*Program) BTSL 

func (self *Program) BTSL(v0 interface{}, v1 interface{}) *Instruction

BTSL performs "Bit Test and Set".

Mnemonic : BTS Supported forms : (4 forms)

func (*Program) BTSQ 

func (self *Program) BTSQ(v0 interface{}, v1 interface{}) *Instruction

BTSQ performs "Bit Test and Set".

Mnemonic : BTS Supported forms : (4 forms)

func (*Program) BTSW 

func (self *Program) BTSW(v0 interface{}, v1 interface{}) *Instruction

BTSW performs "Bit Test and Set".

Mnemonic : BTS Supported forms : (4 forms)

func (*Program) BTW 

func (self *Program) BTW(v0 interface{}, v1 interface{}) *Instruction

BTW performs "Bit Test".

Mnemonic : BT Supported forms : (4 forms)

func (*Program) BZHI 

func (self *Program) BZHI(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

BZHI performs "Zero High Bits Starting with Specified Bit Position".

Mnemonic : BZHI Supported forms : (4 forms)

func (*Program) Byte 

func (self *Program) Byte(v *expr.Expr) (p *Instruction)

Byte is a pseudo-instruction to add raw byte to the assembled code.

func (*Program) CALL 

func (self *Program) CALL(v0 interface{}) *Instruction

CALL performs "Call Procedure".

Mnemonic : CALL Supported forms : (1 form)

func (*Program) CALLQ 

func (self *Program) CALLQ(v0 interface{}) *Instruction

CALLQ performs "Call Procedure".

Mnemonic : CALL Supported forms : (2 forms)

func (*Program) CBTW 

func (self *Program) CBTW() *Instruction

CBTW performs "Convert Byte to Word".

Mnemonic : CBW Supported forms : (1 form)

func (*Program) CLC 

func (self *Program) CLC() *Instruction

CLC performs "Clear Carry Flag".

Mnemonic : CLC Supported forms : (1 form)

func (*Program) CLD 

func (self *Program) CLD() *Instruction

CLD performs "Clear Direction Flag".

Mnemonic : CLD Supported forms : (1 form)

func (*Program) CLFLUSH 

func (self *Program) CLFLUSH(v0 interface{}) *Instruction

CLFLUSH performs "Flush Cache Line".

Mnemonic : CLFLUSH Supported forms : (1 form)

func (*Program) CLFLUSHOPT 

func (self *Program) CLFLUSHOPT(v0 interface{}) *Instruction

CLFLUSHOPT performs "Flush Cache Line Optimized".

Mnemonic : CLFLUSHOPT Supported forms : (1 form)

func (*Program) CLTD 

func (self *Program) CLTD() *Instruction

CLTD performs "Convert Doubleword to Quadword".

Mnemonic : CDQ Supported forms : (1 form)

func (*Program) CLTQ 

func (self *Program) CLTQ() *Instruction

CLTQ performs "Convert Doubleword to Quadword".

Mnemonic : CDQE Supported forms : (1 form)

func (*Program) CLWB 

func (self *Program) CLWB(v0 interface{}) *Instruction

CLWB performs "Cache Line Write Back".

Mnemonic : CLWB Supported forms : (1 form)

func (*Program) CLZERO 

func (self *Program) CLZERO() *Instruction

CLZERO performs "Zero-out 64-bit Cache Line".

Mnemonic : CLZERO Supported forms : (1 form)

func (*Program) CMC 

func (self *Program) CMC() *Instruction

CMC performs "Complement Carry Flag".

Mnemonic : CMC Supported forms : (1 form)

func (*Program) CMOVA 

func (self *Program) CMOVA(v0 interface{}, v1 interface{}) *Instruction

CMOVA performs "Move if above (CF == 0 and ZF == 0)".

Mnemonic : CMOVA Supported forms : (6 forms)

func (*Program) CMOVAE 

func (self *Program) CMOVAE(v0 interface{}, v1 interface{}) *Instruction

CMOVAE performs "Move if above or equal (CF == 0)".

Mnemonic : CMOVAE Supported forms : (6 forms)

func (*Program) CMOVB 

func (self *Program) CMOVB(v0 interface{}, v1 interface{}) *Instruction

CMOVB performs "Move if below (CF == 1)".

Mnemonic : CMOVB Supported forms : (6 forms)

func (*Program) CMOVBE 

func (self *Program) CMOVBE(v0 interface{}, v1 interface{}) *Instruction

CMOVBE performs "Move if below or equal (CF == 1 or ZF == 1)".

Mnemonic : CMOVBE Supported forms : (6 forms)

func (*Program) CMOVC 

func (self *Program) CMOVC(v0 interface{}, v1 interface{}) *Instruction

CMOVC performs "Move if carry (CF == 1)".

Mnemonic : CMOVC Supported forms : (6 forms)

func (*Program) CMOVE 

func (self *Program) CMOVE(v0 interface{}, v1 interface{}) *Instruction

CMOVE performs "Move if equal (ZF == 1)".

Mnemonic : CMOVE Supported forms : (6 forms)

func (*Program) CMOVG 

func (self *Program) CMOVG(v0 interface{}, v1 interface{}) *Instruction

CMOVG performs "Move if greater (ZF == 0 and SF == OF)".

Mnemonic : CMOVG Supported forms : (6 forms)

func (*Program) CMOVGE 

func (self *Program) CMOVGE(v0 interface{}, v1 interface{}) *Instruction

CMOVGE performs "Move if greater or equal (SF == OF)".

Mnemonic : CMOVGE Supported forms : (6 forms)

func (*Program) CMOVL 

func (self *Program) CMOVL(v0 interface{}, v1 interface{}) *Instruction

CMOVL performs "Move if less (SF != OF)".

Mnemonic : CMOVL Supported forms : (6 forms)

func (*Program) CMOVLE 

func (self *Program) CMOVLE(v0 interface{}, v1 interface{}) *Instruction

CMOVLE performs "Move if less or equal (ZF == 1 or SF != OF)".

Mnemonic : CMOVLE Supported forms : (6 forms)

func (*Program) CMOVNA 

func (self *Program) CMOVNA(v0 interface{}, v1 interface{}) *Instruction

CMOVNA performs "Move if not above (CF == 1 or ZF == 1)".

Mnemonic : CMOVNA Supported forms : (6 forms)

func (*Program) CMOVNAE 

func (self *Program) CMOVNAE(v0 interface{}, v1 interface{}) *Instruction

CMOVNAE performs "Move if not above or equal (CF == 1)".

Mnemonic : CMOVNAE Supported forms : (6 forms)

func (*Program) CMOVNB 

func (self *Program) CMOVNB(v0 interface{}, v1 interface{}) *Instruction

CMOVNB performs "Move if not below (CF == 0)".

Mnemonic : CMOVNB Supported forms : (6 forms)

func (*Program) CMOVNBE 

func (self *Program) CMOVNBE(v0 interface{}, v1 interface{}) *Instruction

CMOVNBE performs "Move if not below or equal (CF == 0 and ZF == 0)".

Mnemonic : CMOVNBE Supported forms : (6 forms)

func (*Program) CMOVNC 

func (self *Program) CMOVNC(v0 interface{}, v1 interface{}) *Instruction

CMOVNC performs "Move if not carry (CF == 0)".

Mnemonic : CMOVNC Supported forms : (6 forms)

func (*Program) CMOVNE 

func (self *Program) CMOVNE(v0 interface{}, v1 interface{}) *Instruction

CMOVNE performs "Move if not equal (ZF == 0)".

Mnemonic : CMOVNE Supported forms : (6 forms)

func (*Program) CMOVNG 

func (self *Program) CMOVNG(v0 interface{}, v1 interface{}) *Instruction

CMOVNG performs "Move if not greater (ZF == 1 or SF != OF)".

Mnemonic : CMOVNG Supported forms : (6 forms)

func (*Program) CMOVNGE 

func (self *Program) CMOVNGE(v0 interface{}, v1 interface{}) *Instruction

CMOVNGE performs "Move if not greater or equal (SF != OF)".

Mnemonic : CMOVNGE Supported forms : (6 forms)

func (*Program) CMOVNL 

func (self *Program) CMOVNL(v0 interface{}, v1 interface{}) *Instruction

CMOVNL performs "Move if not less (SF == OF)".

Mnemonic : CMOVNL Supported forms : (6 forms)

func (*Program) CMOVNLE 

func (self *Program) CMOVNLE(v0 interface{}, v1 interface{}) *Instruction

CMOVNLE performs "Move if not less or equal (ZF == 0 and SF == OF)".

Mnemonic : CMOVNLE Supported forms : (6 forms)

func (*Program) CMOVNO 

func (self *Program) CMOVNO(v0 interface{}, v1 interface{}) *Instruction

CMOVNO performs "Move if not overflow (OF == 0)".

Mnemonic : CMOVNO Supported forms : (6 forms)

func (*Program) CMOVNP 

func (self *Program) CMOVNP(v0 interface{}, v1 interface{}) *Instruction

CMOVNP performs "Move if not parity (PF == 0)".

Mnemonic : CMOVNP Supported forms : (6 forms)

func (*Program) CMOVNS 

func (self *Program) CMOVNS(v0 interface{}, v1 interface{}) *Instruction

CMOVNS performs "Move if not sign (SF == 0)".

Mnemonic : CMOVNS Supported forms : (6 forms)

func (*Program) CMOVNZ 

func (self *Program) CMOVNZ(v0 interface{}, v1 interface{}) *Instruction

CMOVNZ performs "Move if not zero (ZF == 0)".

Mnemonic : CMOVNZ Supported forms : (6 forms)

func (*Program) CMOVO 

func (self *Program) CMOVO(v0 interface{}, v1 interface{}) *Instruction

CMOVO performs "Move if overflow (OF == 1)".

Mnemonic : CMOVO Supported forms : (6 forms)

func (*Program) CMOVP 

func (self *Program) CMOVP(v0 interface{}, v1 interface{}) *Instruction

CMOVP performs "Move if parity (PF == 1)".

Mnemonic : CMOVP Supported forms : (6 forms)

func (*Program) CMOVPE 

func (self *Program) CMOVPE(v0 interface{}, v1 interface{}) *Instruction

CMOVPE performs "Move if parity even (PF == 1)".

Mnemonic : CMOVPE Supported forms : (6 forms)

func (*Program) CMOVPO 

func (self *Program) CMOVPO(v0 interface{}, v1 interface{}) *Instruction

CMOVPO performs "Move if parity odd (PF == 0)".

Mnemonic : CMOVPO Supported forms : (6 forms)

func (*Program) CMOVS 

func (self *Program) CMOVS(v0 interface{}, v1 interface{}) *Instruction

CMOVS performs "Move if sign (SF == 1)".

Mnemonic : CMOVS Supported forms : (6 forms)

func (*Program) CMOVZ 

func (self *Program) CMOVZ(v0 interface{}, v1 interface{}) *Instruction

CMOVZ performs "Move if zero (ZF == 1)".

Mnemonic : CMOVZ Supported forms : (6 forms)

func (*Program) CMPB 

func (self *Program) CMPB(v0 interface{}, v1 interface{}) *Instruction

CMPB performs "Compare Two Operands".

Mnemonic : CMP Supported forms : (6 forms)

func (*Program) CMPL 

func (self *Program) CMPL(v0 interface{}, v1 interface{}) *Instruction

CMPL performs "Compare Two Operands".

Mnemonic : CMP Supported forms : (8 forms)

func (*Program) CMPPD 

func (self *Program) CMPPD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

CMPPD performs "Compare Packed Double-Precision Floating-Point Values".

Mnemonic : CMPPD Supported forms : (2 forms)

func (*Program) CMPPS 

func (self *Program) CMPPS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

CMPPS performs "Compare Packed Single-Precision Floating-Point Values".

Mnemonic : CMPPS Supported forms : (2 forms)

func (*Program) CMPQ 

func (self *Program) CMPQ(v0 interface{}, v1 interface{}) *Instruction

CMPQ performs "Compare Two Operands".

Mnemonic : CMP Supported forms : (8 forms)

func (*Program) CMPSD 

func (self *Program) CMPSD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

CMPSD performs "Compare Scalar Double-Precision Floating-Point Values".

Mnemonic : CMPSD Supported forms : (2 forms)

func (*Program) CMPSS 

func (self *Program) CMPSS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

CMPSS performs "Compare Scalar Single-Precision Floating-Point Values".

Mnemonic : CMPSS Supported forms : (2 forms)

func (*Program) CMPW 

func (self *Program) CMPW(v0 interface{}, v1 interface{}) *Instruction

CMPW performs "Compare Two Operands".

Mnemonic : CMP Supported forms : (8 forms)

func (*Program) CMPXCHG16B 

func (self *Program) CMPXCHG16B(v0 interface{}) *Instruction

CMPXCHG16B performs "Compare and Exchange 16 Bytes".

Mnemonic : CMPXCHG16B Supported forms : (1 form)

func (*Program) CMPXCHG8B 

func (self *Program) CMPXCHG8B(v0 interface{}) *Instruction

CMPXCHG8B performs "Compare and Exchange 8 Bytes".

Mnemonic : CMPXCHG8B Supported forms : (1 form)

func (*Program) CMPXCHGB 

func (self *Program) CMPXCHGB(v0 interface{}, v1 interface{}) *Instruction

CMPXCHGB performs "Compare and Exchange".

Mnemonic : CMPXCHG Supported forms : (2 forms)

func (*Program) CMPXCHGL 

func (self *Program) CMPXCHGL(v0 interface{}, v1 interface{}) *Instruction

CMPXCHGL performs "Compare and Exchange".

Mnemonic : CMPXCHG Supported forms : (2 forms)

func (*Program) CMPXCHGQ 

func (self *Program) CMPXCHGQ(v0 interface{}, v1 interface{}) *Instruction

CMPXCHGQ performs "Compare and Exchange".

Mnemonic : CMPXCHG Supported forms : (2 forms)

func (*Program) CMPXCHGW 

func (self *Program) CMPXCHGW(v0 interface{}, v1 interface{}) *Instruction

CMPXCHGW performs "Compare and Exchange".

Mnemonic : CMPXCHG Supported forms : (2 forms)

func (*Program) COMISD 

func (self *Program) COMISD(v0 interface{}, v1 interface{}) *Instruction

COMISD performs "Compare Scalar Ordered Double-Precision Floating-Point Values and Set EFLAGS".

Mnemonic : COMISD Supported forms : (2 forms)

func (*Program) COMISS 

func (self *Program) COMISS(v0 interface{}, v1 interface{}) *Instruction

COMISS performs "Compare Scalar Ordered Single-Precision Floating-Point Values and Set EFLAGS".

Mnemonic : COMISS Supported forms : (2 forms)

func (*Program) CPUID 

func (self *Program) CPUID() *Instruction

CPUID performs "CPU Identification".

Mnemonic : CPUID Supported forms : (1 form)

func (*Program) CQTO 

func (self *Program) CQTO() *Instruction

CQTO performs "Convert Quadword to Octaword".

Mnemonic : CQO Supported forms : (1 form)

func (*Program) CRC32B 

func (self *Program) CRC32B(v0 interface{}, v1 interface{}) *Instruction

CRC32B performs "Accumulate CRC32 Value".

Mnemonic : CRC32 Supported forms : (4 forms)

func (*Program) CRC32L 

func (self *Program) CRC32L(v0 interface{}, v1 interface{}) *Instruction

CRC32L performs "Accumulate CRC32 Value".

Mnemonic : CRC32 Supported forms : (2 forms)

func (*Program) CRC32Q 

func (self *Program) CRC32Q(v0 interface{}, v1 interface{}) *Instruction

CRC32Q performs "Accumulate CRC32 Value".

Mnemonic : CRC32 Supported forms : (2 forms)

func (*Program) CRC32W 

func (self *Program) CRC32W(v0 interface{}, v1 interface{}) *Instruction

CRC32W performs "Accumulate CRC32 Value".

Mnemonic : CRC32 Supported forms : (2 forms)

func (*Program) CVTDQ2PD 

func (self *Program) CVTDQ2PD(v0 interface{}, v1 interface{}) *Instruction

CVTDQ2PD performs "Convert Packed Dword Integers to Packed Double-Precision FP Values".

Mnemonic : CVTDQ2PD Supported forms : (2 forms)

func (*Program) CVTDQ2PS 

func (self *Program) CVTDQ2PS(v0 interface{}, v1 interface{}) *Instruction

CVTDQ2PS performs "Convert Packed Dword Integers to Packed Single-Precision FP Values".

Mnemonic : CVTDQ2PS Supported forms : (2 forms)

func (*Program) CVTPD2DQ 

func (self *Program) CVTPD2DQ(v0 interface{}, v1 interface{}) *Instruction

CVTPD2DQ performs "Convert Packed Double-Precision FP Values to Packed Dword Integers".

Mnemonic : CVTPD2DQ Supported forms : (2 forms)

func (*Program) CVTPD2PI 

func (self *Program) CVTPD2PI(v0 interface{}, v1 interface{}) *Instruction

CVTPD2PI performs "Convert Packed Double-Precision FP Values to Packed Dword Integers".

Mnemonic : CVTPD2PI Supported forms : (2 forms)

func (*Program) CVTPD2PS 

func (self *Program) CVTPD2PS(v0 interface{}, v1 interface{}) *Instruction

CVTPD2PS performs "Convert Packed Double-Precision FP Values to Packed Single-Precision FP Values".

Mnemonic : CVTPD2PS Supported forms : (2 forms)

func (*Program) CVTPI2PD 

func (self *Program) CVTPI2PD(v0 interface{}, v1 interface{}) *Instruction

CVTPI2PD performs "Convert Packed Dword Integers to Packed Double-Precision FP Values".

Mnemonic : CVTPI2PD Supported forms : (2 forms)

func (*Program) CVTPI2PS 

func (self *Program) CVTPI2PS(v0 interface{}, v1 interface{}) *Instruction

CVTPI2PS performs "Convert Packed Dword Integers to Packed Single-Precision FP Values".

Mnemonic : CVTPI2PS Supported forms : (2 forms)

func (*Program) CVTPS2DQ 

func (self *Program) CVTPS2DQ(v0 interface{}, v1 interface{}) *Instruction

CVTPS2DQ performs "Convert Packed Single-Precision FP Values to Packed Dword Integers".

Mnemonic : CVTPS2DQ Supported forms : (2 forms)

func (*Program) CVTPS2PD 

func (self *Program) CVTPS2PD(v0 interface{}, v1 interface{}) *Instruction

CVTPS2PD performs "Convert Packed Single-Precision FP Values to Packed Double-Precision FP Values".

Mnemonic : CVTPS2PD Supported forms : (2 forms)

func (*Program) CVTPS2PI 

func (self *Program) CVTPS2PI(v0 interface{}, v1 interface{}) *Instruction

CVTPS2PI performs "Convert Packed Single-Precision FP Values to Packed Dword Integers".

Mnemonic : CVTPS2PI Supported forms : (2 forms)

func (*Program) CVTSD2SI 

func (self *Program) CVTSD2SI(v0 interface{}, v1 interface{}) *Instruction

CVTSD2SI performs "Convert Scalar Double-Precision FP Value to Integer".

Mnemonic : CVTSD2SI Supported forms : (4 forms)

func (*Program) CVTSD2SS 

func (self *Program) CVTSD2SS(v0 interface{}, v1 interface{}) *Instruction

CVTSD2SS performs "Convert Scalar Double-Precision FP Value to Scalar Single-Precision FP Value".

Mnemonic : CVTSD2SS Supported forms : (2 forms)

func (*Program) CVTSI2SD 

func (self *Program) CVTSI2SD(v0 interface{}, v1 interface{}) *Instruction

CVTSI2SD performs "Convert Dword Integer to Scalar Double-Precision FP Value".

Mnemonic : CVTSI2SD Supported forms : (4 forms)

func (*Program) CVTSI2SS 

func (self *Program) CVTSI2SS(v0 interface{}, v1 interface{}) *Instruction

CVTSI2SS performs "Convert Dword Integer to Scalar Single-Precision FP Value".

Mnemonic : CVTSI2SS Supported forms : (4 forms)

func (*Program) CVTSS2SD 

func (self *Program) CVTSS2SD(v0 interface{}, v1 interface{}) *Instruction

CVTSS2SD performs "Convert Scalar Single-Precision FP Value to Scalar Double-Precision FP Value".

Mnemonic : CVTSS2SD Supported forms : (2 forms)

func (*Program) CVTSS2SI 

func (self *Program) CVTSS2SI(v0 interface{}, v1 interface{}) *Instruction

CVTSS2SI performs "Convert Scalar Single-Precision FP Value to Dword Integer".

Mnemonic : CVTSS2SI Supported forms : (4 forms)

func (*Program) CVTTPD2DQ 

func (self *Program) CVTTPD2DQ(v0 interface{}, v1 interface{}) *Instruction

CVTTPD2DQ performs "Convert with Truncation Packed Double-Precision FP Values to Packed Dword Integers".

Mnemonic : CVTTPD2DQ Supported forms : (2 forms)

func (*Program) CVTTPD2PI 

func (self *Program) CVTTPD2PI(v0 interface{}, v1 interface{}) *Instruction

CVTTPD2PI performs "Convert with Truncation Packed Double-Precision FP Values to Packed Dword Integers".

Mnemonic : CVTTPD2PI Supported forms : (2 forms)

func (*Program) CVTTPS2DQ 

func (self *Program) CVTTPS2DQ(v0 interface{}, v1 interface{}) *Instruction

CVTTPS2DQ performs "Convert with Truncation Packed Single-Precision FP Values to Packed Dword Integers".

Mnemonic : CVTTPS2DQ Supported forms : (2 forms)

func (*Program) CVTTPS2PI 

func (self *Program) CVTTPS2PI(v0 interface{}, v1 interface{}) *Instruction

CVTTPS2PI performs "Convert with Truncation Packed Single-Precision FP Values to Packed Dword Integers".

Mnemonic : CVTTPS2PI Supported forms : (2 forms)

func (*Program) CVTTSD2SI 

func (self *Program) CVTTSD2SI(v0 interface{}, v1 interface{}) *Instruction

CVTTSD2SI performs "Convert with Truncation Scalar Double-Precision FP Value to Signed Integer".

Mnemonic : CVTTSD2SI Supported forms : (4 forms)

func (*Program) CVTTSS2SI 

func (self *Program) CVTTSS2SI(v0 interface{}, v1 interface{}) *Instruction

CVTTSS2SI performs "Convert with Truncation Scalar Single-Precision FP Value to Dword Integer".

Mnemonic : CVTTSS2SI Supported forms : (4 forms)

func (*Program) CWTD 

func (self *Program) CWTD() *Instruction

CWTD performs "Convert Word to Doubleword".

Mnemonic : CWD Supported forms : (1 form)

func (*Program) CWTL 

func (self *Program) CWTL() *Instruction

CWTL performs "Convert Word to Doubleword".

Mnemonic : CWDE Supported forms : (1 form)

func (*Program) DECB 

func (self *Program) DECB(v0 interface{}) *Instruction

DECB performs "Decrement by 1".

Mnemonic : DEC Supported forms : (2 forms)

func (*Program) DECL 

func (self *Program) DECL(v0 interface{}) *Instruction

DECL performs "Decrement by 1".

Mnemonic : DEC Supported forms : (2 forms)

func (*Program) DECQ 

func (self *Program) DECQ(v0 interface{}) *Instruction

DECQ performs "Decrement by 1".

Mnemonic : DEC Supported forms : (2 forms)

func (*Program) DECW 

func (self *Program) DECW(v0 interface{}) *Instruction

DECW performs "Decrement by 1".

Mnemonic : DEC Supported forms : (2 forms)

func (*Program) DIVB 

func (self *Program) DIVB(v0 interface{}) *Instruction

DIVB performs "Unsigned Divide".

Mnemonic : DIV Supported forms : (2 forms)

func (*Program) DIVL 

func (self *Program) DIVL(v0 interface{}) *Instruction

DIVL performs "Unsigned Divide".

Mnemonic : DIV Supported forms : (2 forms)

func (*Program) DIVPD 

func (self *Program) DIVPD(v0 interface{}, v1 interface{}) *Instruction

DIVPD performs "Divide Packed Double-Precision Floating-Point Values".

Mnemonic : DIVPD Supported forms : (2 forms)

func (*Program) DIVPS 

func (self *Program) DIVPS(v0 interface{}, v1 interface{}) *Instruction

DIVPS performs "Divide Packed Single-Precision Floating-Point Values".

Mnemonic : DIVPS Supported forms : (2 forms)

func (*Program) DIVQ 

func (self *Program) DIVQ(v0 interface{}) *Instruction

DIVQ performs "Unsigned Divide".

Mnemonic : DIV Supported forms : (2 forms)

func (*Program) DIVSD 

func (self *Program) DIVSD(v0 interface{}, v1 interface{}) *Instruction

DIVSD performs "Divide Scalar Double-Precision Floating-Point Values".

Mnemonic : DIVSD Supported forms : (2 forms)

func (*Program) DIVSS 

func (self *Program) DIVSS(v0 interface{}, v1 interface{}) *Instruction

DIVSS performs "Divide Scalar Single-Precision Floating-Point Values".

Mnemonic : DIVSS Supported forms : (2 forms)

func (*Program) DIVW 

func (self *Program) DIVW(v0 interface{}) *Instruction

DIVW performs "Unsigned Divide".

Mnemonic : DIV Supported forms : (2 forms)

func (*Program) DPPD 

func (self *Program) DPPD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

DPPD performs "Dot Product of Packed Double Precision Floating-Point Values".

Mnemonic : DPPD Supported forms : (2 forms)

func (*Program) DPPS 

func (self *Program) DPPS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

DPPS performs "Dot Product of Packed Single Precision Floating-Point Values".

Mnemonic : DPPS Supported forms : (2 forms)

func (*Program) Data 

func (self *Program) Data(v []byte) (p *Instruction)

Data is a pseudo-instruction to add raw bytes to the assembled code.

func (*Program) EMMS 

func (self *Program) EMMS() *Instruction

EMMS performs "Exit MMX State".

Mnemonic : EMMS Supported forms : (1 form)

func (*Program) EXTRACTPS 

func (self *Program) EXTRACTPS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

EXTRACTPS performs "Extract Packed Single Precision Floating-Point Value".

Mnemonic : EXTRACTPS Supported forms : (2 forms)

func (*Program) EXTRQ 

func (self *Program) EXTRQ(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction

EXTRQ performs "Extract Field".

Mnemonic : EXTRQ Supported forms : (2 forms)

func (*Program) FEMMS 

func (self *Program) FEMMS() *Instruction

FEMMS performs "Fast Exit Multimedia State".

Mnemonic : FEMMS Supported forms : (1 form)

func (*Program) Free 

func (self *Program) Free()

Free returns the Program object into pool. Any operation performed after Free is undefined behavior.

NOTE: This also frees all the instructions, labels, memory 

operands and expressions associated with this program.

func (*Program) HADDPD 

func (self *Program) HADDPD(v0 interface{}, v1 interface{}) *Instruction

HADDPD performs "Packed Double-FP Horizontal Add".

Mnemonic : HADDPD Supported forms : (2 forms)

func (*Program) HADDPS 

func (self *Program) HADDPS(v0 interface{}, v1 interface{}) *Instruction

HADDPS performs "Packed Single-FP Horizontal Add".

Mnemonic : HADDPS Supported forms : (2 forms)

func (*Program) HSUBPD 

func (self *Program) HSUBPD(v0 interface{}, v1 interface{}) *Instruction

HSUBPD performs "Packed Double-FP Horizontal Subtract".

Mnemonic : HSUBPD Supported forms : (2 forms)

func (*Program) HSUBPS 

func (self *Program) HSUBPS(v0 interface{}, v1 interface{}) *Instruction

HSUBPS performs "Packed Single-FP Horizontal Subtract".

Mnemonic : HSUBPS Supported forms : (2 forms)

func (*Program) IDIVB 

func (self *Program) IDIVB(v0 interface{}) *Instruction

IDIVB performs "Signed Divide".

Mnemonic : IDIV Supported forms : (2 forms)

func (*Program) IDIVL 

func (self *Program) IDIVL(v0 interface{}) *Instruction

IDIVL performs "Signed Divide".

Mnemonic : IDIV Supported forms : (2 forms)

func (*Program) IDIVQ 

func (self *Program) IDIVQ(v0 interface{}) *Instruction

IDIVQ performs "Signed Divide".

Mnemonic : IDIV Supported forms : (2 forms)

func (*Program) IDIVW 

func (self *Program) IDIVW(v0 interface{}) *Instruction

IDIVW performs "Signed Divide".

Mnemonic : IDIV Supported forms : (2 forms)

func (*Program) IMULB 

func (self *Program) IMULB(v0 interface{}) *Instruction

IMULB performs "Signed Multiply".

Mnemonic : IMUL Supported forms : (2 forms)

func (*Program) IMULL 

func (self *Program) IMULL(v0 interface{}, vv ...interface{}) *Instruction

IMULL performs "Signed Multiply".

Mnemonic : IMUL Supported forms : (8 forms)

func (*Program) IMULQ 

func (self *Program) IMULQ(v0 interface{}, vv ...interface{}) *Instruction

IMULQ performs "Signed Multiply".

Mnemonic : IMUL Supported forms : (8 forms)

func (*Program) IMULW 

func (self *Program) IMULW(v0 interface{}, vv ...interface{}) *Instruction

IMULW performs "Signed Multiply".

Mnemonic : IMUL Supported forms : (8 forms)

func (*Program) INCB 

func (self *Program) INCB(v0 interface{}) *Instruction

INCB performs "Increment by 1".

Mnemonic : INC Supported forms : (2 forms)

func (*Program) INCL 

func (self *Program) INCL(v0 interface{}) *Instruction

INCL performs "Increment by 1".

Mnemonic : INC Supported forms : (2 forms)

func (*Program) INCQ 

func (self *Program) INCQ(v0 interface{}) *Instruction

INCQ performs "Increment by 1".

Mnemonic : INC Supported forms : (2 forms)

func (*Program) INCW 

func (self *Program) INCW(v0 interface{}) *Instruction

INCW performs "Increment by 1".

Mnemonic : INC Supported forms : (2 forms)

func (*Program) INSERTPS 

func (self *Program) INSERTPS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

INSERTPS performs "Insert Packed Single Precision Floating-Point Value".

Mnemonic : INSERTPS Supported forms : (2 forms)

func (*Program) INSERTQ 

func (self *Program) INSERTQ(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction

INSERTQ performs "Insert Field".

Mnemonic : INSERTQ Supported forms : (2 forms)

func (*Program) INT 

func (self *Program) INT(v0 interface{}) *Instruction

INT performs "Call to Interrupt Procedure".

Mnemonic : INT Supported forms : (2 forms)

func (*Program) JA 

func (self *Program) JA(v0 interface{}) *Instruction

JA performs "Jump if above (CF == 0 and ZF == 0)".

Mnemonic : JA Supported forms : (2 forms)

func (*Program) JAE 

func (self *Program) JAE(v0 interface{}) *Instruction

JAE performs "Jump if above or equal (CF == 0)".

Mnemonic : JAE Supported forms : (2 forms)

func (*Program) JB 

func (self *Program) JB(v0 interface{}) *Instruction

JB performs "Jump if below (CF == 1)".

Mnemonic : JB Supported forms : (2 forms)

func (*Program) JBE 

func (self *Program) JBE(v0 interface{}) *Instruction

JBE performs "Jump if below or equal (CF == 1 or ZF == 1)".

Mnemonic : JBE Supported forms : (2 forms)

func (*Program) JC 

func (self *Program) JC(v0 interface{}) *Instruction

JC performs "Jump if carry (CF == 1)".

Mnemonic : JC Supported forms : (2 forms)

func (*Program) JE 

func (self *Program) JE(v0 interface{}) *Instruction

JE performs "Jump if equal (ZF == 1)".

Mnemonic : JE Supported forms : (2 forms)

func (*Program) JECXZ 

func (self *Program) JECXZ(v0 interface{}) *Instruction

JECXZ performs "Jump if ECX register is 0".

Mnemonic : JECXZ Supported forms : (1 form)

func (*Program) JG 

func (self *Program) JG(v0 interface{}) *Instruction

JG performs "Jump if greater (ZF == 0 and SF == OF)".

Mnemonic : JG Supported forms : (2 forms)

func (*Program) JGE 

func (self *Program) JGE(v0 interface{}) *Instruction

JGE performs "Jump if greater or equal (SF == OF)".

Mnemonic : JGE Supported forms : (2 forms)

func (*Program) JL 

func (self *Program) JL(v0 interface{}) *Instruction

JL performs "Jump if less (SF != OF)".

Mnemonic : JL Supported forms : (2 forms)

func (*Program) JLE 

func (self *Program) JLE(v0 interface{}) *Instruction

JLE performs "Jump if less or equal (ZF == 1 or SF != OF)".

Mnemonic : JLE Supported forms : (2 forms)

func (*Program) JMP 

func (self *Program) JMP(v0 interface{}) *Instruction

JMP performs "Jump Unconditionally".

Mnemonic : JMP Supported forms : (2 forms)

func (*Program) JMPQ 

func (self *Program) JMPQ(v0 interface{}) *Instruction

JMPQ performs "Jump Unconditionally".

Mnemonic : JMP Supported forms : (2 forms)

func (*Program) JNA 

func (self *Program) JNA(v0 interface{}) *Instruction

JNA performs "Jump if not above (CF == 1 or ZF == 1)".

Mnemonic : JNA Supported forms : (2 forms)

func (*Program) JNAE 

func (self *Program) JNAE(v0 interface{}) *Instruction

JNAE performs "Jump if not above or equal (CF == 1)".

Mnemonic : JNAE Supported forms : (2 forms)

func (*Program) JNB 

func (self *Program) JNB(v0 interface{}) *Instruction

JNB performs "Jump if not below (CF == 0)".

Mnemonic : JNB Supported forms : (2 forms)

func (*Program) JNBE 

func (self *Program) JNBE(v0 interface{}) *Instruction

JNBE performs "Jump if not below or equal (CF == 0 and ZF == 0)".

Mnemonic : JNBE Supported forms : (2 forms)

func (*Program) JNC 

func (self *Program) JNC(v0 interface{}) *Instruction

JNC performs "Jump if not carry (CF == 0)".

Mnemonic : JNC Supported forms : (2 forms)

func (*Program) JNE 

func (self *Program) JNE(v0 interface{}) *Instruction

JNE performs "Jump if not equal (ZF == 0)".

Mnemonic : JNE Supported forms : (2 forms)

func (*Program) JNG 

func (self *Program) JNG(v0 interface{}) *Instruction

JNG performs "Jump if not greater (ZF == 1 or SF != OF)".

Mnemonic : JNG Supported forms : (2 forms)

func (*Program) JNGE 

func (self *Program) JNGE(v0 interface{}) *Instruction

JNGE performs "Jump if not greater or equal (SF != OF)".

Mnemonic : JNGE Supported forms : (2 forms)

func (*Program) JNL 

func (self *Program) JNL(v0 interface{}) *Instruction

JNL performs "Jump if not less (SF == OF)".

Mnemonic : JNL Supported forms : (2 forms)

func (*Program) JNLE 

func (self *Program) JNLE(v0 interface{}) *Instruction

JNLE performs "Jump if not less or equal (ZF == 0 and SF == OF)".

Mnemonic : JNLE Supported forms : (2 forms)

func (*Program) JNO 

func (self *Program) JNO(v0 interface{}) *Instruction

JNO performs "Jump if not overflow (OF == 0)".

Mnemonic : JNO Supported forms : (2 forms)

func (*Program) JNP 

func (self *Program) JNP(v0 interface{}) *Instruction

JNP performs "Jump if not parity (PF == 0)".

Mnemonic : JNP Supported forms : (2 forms)

func (*Program) JNS 

func (self *Program) JNS(v0 interface{}) *Instruction

JNS performs "Jump if not sign (SF == 0)".

Mnemonic : JNS Supported forms : (2 forms)

func (*Program) JNZ 

func (self *Program) JNZ(v0 interface{}) *Instruction

JNZ performs "Jump if not zero (ZF == 0)".

Mnemonic : JNZ Supported forms : (2 forms)

func (*Program) JO 

func (self *Program) JO(v0 interface{}) *Instruction

JO performs "Jump if overflow (OF == 1)".

Mnemonic : JO Supported forms : (2 forms)

func (*Program) JP 

func (self *Program) JP(v0 interface{}) *Instruction

JP performs "Jump if parity (PF == 1)".

Mnemonic : JP Supported forms : (2 forms)

func (*Program) JPE 

func (self *Program) JPE(v0 interface{}) *Instruction

JPE performs "Jump if parity even (PF == 1)".

Mnemonic : JPE Supported forms : (2 forms)

func (*Program) JPO 

func (self *Program) JPO(v0 interface{}) *Instruction

JPO performs "Jump if parity odd (PF == 0)".

Mnemonic : JPO Supported forms : (2 forms)

func (*Program) JRCXZ 

func (self *Program) JRCXZ(v0 interface{}) *Instruction

JRCXZ performs "Jump if RCX register is 0".

Mnemonic : JRCXZ Supported forms : (1 form)

func (*Program) JS 

func (self *Program) JS(v0 interface{}) *Instruction

JS performs "Jump if sign (SF == 1)".

Mnemonic : JS Supported forms : (2 forms)

func (*Program) JZ 

func (self *Program) JZ(v0 interface{}) *Instruction

JZ performs "Jump if zero (ZF == 1)".

Mnemonic : JZ Supported forms : (2 forms)

func (*Program) KADDB 

func (self *Program) KADDB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

KADDB performs "ADD Two 8-bit Masks".

Mnemonic : KADDB Supported forms : (1 form)

func (*Program) KADDD 

func (self *Program) KADDD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

KADDD performs "ADD Two 32-bit Masks".

Mnemonic : KADDD Supported forms : (1 form)

func (*Program) KADDQ 

func (self *Program) KADDQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

KADDQ performs "ADD Two 64-bit Masks".

Mnemonic : KADDQ Supported forms : (1 form)

func (*Program) KADDW 

func (self *Program) KADDW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

KADDW performs "ADD Two 16-bit Masks".

Mnemonic : KADDW Supported forms : (1 form)

func (*Program) KANDB 

func (self *Program) KANDB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

KANDB performs "Bitwise Logical AND 8-bit Masks".

Mnemonic : KANDB Supported forms : (1 form)

func (*Program) KANDD 

func (self *Program) KANDD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

KANDD performs "Bitwise Logical AND 32-bit Masks".

Mnemonic : KANDD Supported forms : (1 form)

func (*Program) KANDNB 

func (self *Program) KANDNB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

KANDNB performs "Bitwise Logical AND NOT 8-bit Masks".

Mnemonic : KANDNB Supported forms : (1 form)

func (*Program) KANDND 

func (self *Program) KANDND(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

KANDND performs "Bitwise Logical AND NOT 32-bit Masks".

Mnemonic : KANDND Supported forms : (1 form)

func (*Program) KANDNQ 

func (self *Program) KANDNQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

KANDNQ performs "Bitwise Logical AND NOT 64-bit Masks".

Mnemonic : KANDNQ Supported forms : (1 form)

func (*Program) KANDNW 

func (self *Program) KANDNW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

KANDNW performs "Bitwise Logical AND NOT 16-bit Masks".

Mnemonic : KANDNW Supported forms : (1 form)

func (*Program) KANDQ 

func (self *Program) KANDQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

KANDQ performs "Bitwise Logical AND 64-bit Masks".

Mnemonic : KANDQ Supported forms : (1 form)

func (*Program) KANDW 

func (self *Program) KANDW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

KANDW performs "Bitwise Logical AND 16-bit Masks".

Mnemonic : KANDW Supported forms : (1 form)

func (*Program) KMOVB 

func (self *Program) KMOVB(v0 interface{}, v1 interface{}) *Instruction

KMOVB performs "Move 8-bit Mask".

Mnemonic : KMOVB Supported forms : (5 forms)

func (*Program) KMOVD 

func (self *Program) KMOVD(v0 interface{}, v1 interface{}) *Instruction

KMOVD performs "Move 32-bit Mask".

Mnemonic : KMOVD Supported forms : (5 forms)

func (*Program) KMOVQ 

func (self *Program) KMOVQ(v0 interface{}, v1 interface{}) *Instruction

KMOVQ performs "Move 64-bit Mask".

Mnemonic : KMOVQ Supported forms : (5 forms)

func (*Program) KMOVW 

func (self *Program) KMOVW(v0 interface{}, v1 interface{}) *Instruction

KMOVW performs "Move 16-bit Mask".

Mnemonic : KMOVW Supported forms : (5 forms)

func (*Program) KNOTB 

func (self *Program) KNOTB(v0 interface{}, v1 interface{}) *Instruction

KNOTB performs "NOT 8-bit Mask Register".

Mnemonic : KNOTB Supported forms : (1 form)

func (*Program) KNOTD 

func (self *Program) KNOTD(v0 interface{}, v1 interface{}) *Instruction

KNOTD performs "NOT 32-bit Mask Register".

Mnemonic : KNOTD Supported forms : (1 form)

func (*Program) KNOTQ 

func (self *Program) KNOTQ(v0 interface{}, v1 interface{}) *Instruction

KNOTQ performs "NOT 64-bit Mask Register".

Mnemonic : KNOTQ Supported forms : (1 form)

func (*Program) KNOTW 

func (self *Program) KNOTW(v0 interface{}, v1 interface{}) *Instruction

KNOTW performs "NOT 16-bit Mask Register".

Mnemonic : KNOTW Supported forms : (1 form)

func (*Program) KORB 

func (self *Program) KORB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

KORB performs "Bitwise Logical OR 8-bit Masks".

Mnemonic : KORB Supported forms : (1 form)

func (*Program) KORD 

func (self *Program) KORD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

KORD performs "Bitwise Logical OR 32-bit Masks".

Mnemonic : KORD Supported forms : (1 form)

func (*Program) KORQ 

func (self *Program) KORQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

KORQ performs "Bitwise Logical OR 64-bit Masks".

Mnemonic : KORQ Supported forms : (1 form)

func (*Program) KORTESTB 

func (self *Program) KORTESTB(v0 interface{}, v1 interface{}) *Instruction

KORTESTB performs "OR 8-bit Masks and Set Flags".

Mnemonic : KORTESTB Supported forms : (1 form)

func (*Program) KORTESTD 

func (self *Program) KORTESTD(v0 interface{}, v1 interface{}) *Instruction

KORTESTD performs "OR 32-bit Masks and Set Flags".

Mnemonic : KORTESTD Supported forms : (1 form)

func (*Program) KORTESTQ 

func (self *Program) KORTESTQ(v0 interface{}, v1 interface{}) *Instruction

KORTESTQ performs "OR 64-bit Masks and Set Flags".

Mnemonic : KORTESTQ Supported forms : (1 form)

func (*Program) KORTESTW 

func (self *Program) KORTESTW(v0 interface{}, v1 interface{}) *Instruction

KORTESTW performs "OR 16-bit Masks and Set Flags".

Mnemonic : KORTESTW Supported forms : (1 form)

func (*Program) KORW 

func (self *Program) KORW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

KORW performs "Bitwise Logical OR 16-bit Masks".

Mnemonic : KORW Supported forms : (1 form)

func (*Program) KSHIFTLB 

func (self *Program) KSHIFTLB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

KSHIFTLB performs "Shift Left 8-bit Masks".

Mnemonic : KSHIFTLB Supported forms : (1 form)

func (*Program) KSHIFTLD 

func (self *Program) KSHIFTLD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

KSHIFTLD performs "Shift Left 32-bit Masks".

Mnemonic : KSHIFTLD Supported forms : (1 form)

func (*Program) KSHIFTLQ 

func (self *Program) KSHIFTLQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

KSHIFTLQ performs "Shift Left 64-bit Masks".

Mnemonic : KSHIFTLQ Supported forms : (1 form)

func (*Program) KSHIFTLW 

func (self *Program) KSHIFTLW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

KSHIFTLW performs "Shift Left 16-bit Masks".

Mnemonic : KSHIFTLW Supported forms : (1 form)

func (*Program) KSHIFTRB 

func (self *Program) KSHIFTRB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

KSHIFTRB performs "Shift Right 8-bit Masks".

Mnemonic : KSHIFTRB Supported forms : (1 form)

func (*Program) KSHIFTRD 

func (self *Program) KSHIFTRD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

KSHIFTRD performs "Shift Right 32-bit Masks".

Mnemonic : KSHIFTRD Supported forms : (1 form)

func (*Program) KSHIFTRQ 

func (self *Program) KSHIFTRQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

KSHIFTRQ performs "Shift Right 64-bit Masks".

Mnemonic : KSHIFTRQ Supported forms : (1 form)

func (*Program) KSHIFTRW 

func (self *Program) KSHIFTRW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

KSHIFTRW performs "Shift Right 16-bit Masks".

Mnemonic : KSHIFTRW Supported forms : (1 form)

func (*Program) KTESTB 

func (self *Program) KTESTB(v0 interface{}, v1 interface{}) *Instruction

KTESTB performs "Bit Test 8-bit Masks and Set Flags".

Mnemonic : KTESTB Supported forms : (1 form)

func (*Program) KTESTD 

func (self *Program) KTESTD(v0 interface{}, v1 interface{}) *Instruction

KTESTD performs "Bit Test 32-bit Masks and Set Flags".

Mnemonic : KTESTD Supported forms : (1 form)

func (*Program) KTESTQ 

func (self *Program) KTESTQ(v0 interface{}, v1 interface{}) *Instruction

KTESTQ performs "Bit Test 64-bit Masks and Set Flags".

Mnemonic : KTESTQ Supported forms : (1 form)

func (*Program) KTESTW 

func (self *Program) KTESTW(v0 interface{}, v1 interface{}) *Instruction

KTESTW performs "Bit Test 16-bit Masks and Set Flags".

Mnemonic : KTESTW Supported forms : (1 form)

func (*Program) KUNPCKBW 

func (self *Program) KUNPCKBW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

KUNPCKBW performs "Unpack and Interleave 8-bit Masks".

Mnemonic : KUNPCKBW Supported forms : (1 form)

func (*Program) KUNPCKDQ 

func (self *Program) KUNPCKDQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

KUNPCKDQ performs "Unpack and Interleave 32-bit Masks".

Mnemonic : KUNPCKDQ Supported forms : (1 form)

func (*Program) KUNPCKWD 

func (self *Program) KUNPCKWD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

KUNPCKWD performs "Unpack and Interleave 16-bit Masks".

Mnemonic : KUNPCKWD Supported forms : (1 form)

func (*Program) KXNORB 

func (self *Program) KXNORB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

KXNORB performs "Bitwise Logical XNOR 8-bit Masks".

Mnemonic : KXNORB Supported forms : (1 form)

func (*Program) KXNORD 

func (self *Program) KXNORD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

KXNORD performs "Bitwise Logical XNOR 32-bit Masks".

Mnemonic : KXNORD Supported forms : (1 form)

func (*Program) KXNORQ 

func (self *Program) KXNORQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

KXNORQ performs "Bitwise Logical XNOR 64-bit Masks".

Mnemonic : KXNORQ Supported forms : (1 form)

func (*Program) KXNORW 

func (self *Program) KXNORW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

KXNORW performs "Bitwise Logical XNOR 16-bit Masks".

Mnemonic : KXNORW Supported forms : (1 form)

func (*Program) KXORB 

func (self *Program) KXORB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

KXORB performs "Bitwise Logical XOR 8-bit Masks".

Mnemonic : KXORB Supported forms : (1 form)

func (*Program) KXORD 

func (self *Program) KXORD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

KXORD performs "Bitwise Logical XOR 32-bit Masks".

Mnemonic : KXORD Supported forms : (1 form)

func (*Program) KXORQ 

func (self *Program) KXORQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

KXORQ performs "Bitwise Logical XOR 64-bit Masks".

Mnemonic : KXORQ Supported forms : (1 form)

func (*Program) KXORW 

func (self *Program) KXORW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

KXORW performs "Bitwise Logical XOR 16-bit Masks".

Mnemonic : KXORW Supported forms : (1 form)

func (*Program) LDDQU 

func (self *Program) LDDQU(v0 interface{}, v1 interface{}) *Instruction

LDDQU performs "Load Unaligned Integer 128 Bits".

Mnemonic : LDDQU Supported forms : (1 form)

func (*Program) LDMXCSR 

func (self *Program) LDMXCSR(v0 interface{}) *Instruction

LDMXCSR performs "Load MXCSR Register".

Mnemonic : LDMXCSR Supported forms : (1 form)

func (*Program) LEAL 

func (self *Program) LEAL(v0 interface{}, v1 interface{}) *Instruction

LEAL performs "Load Effective Address".

Mnemonic : LEA Supported forms : (1 form)

func (*Program) LEAQ 

func (self *Program) LEAQ(v0 interface{}, v1 interface{}) *Instruction

LEAQ performs "Load Effective Address".

Mnemonic : LEA Supported forms : (1 form)

func (*Program) LEAW 

func (self *Program) LEAW(v0 interface{}, v1 interface{}) *Instruction

LEAW performs "Load Effective Address".

Mnemonic : LEA Supported forms : (1 form)

func (*Program) LFENCE 

func (self *Program) LFENCE() *Instruction

LFENCE performs "Load Fence".

Mnemonic : LFENCE Supported forms : (1 form)

func (*Program) LZCNTL 

func (self *Program) LZCNTL(v0 interface{}, v1 interface{}) *Instruction

LZCNTL performs "Count the Number of Leading Zero Bits".

Mnemonic : LZCNT Supported forms : (2 forms)

func (*Program) LZCNTQ 

func (self *Program) LZCNTQ(v0 interface{}, v1 interface{}) *Instruction

LZCNTQ performs "Count the Number of Leading Zero Bits".

Mnemonic : LZCNT Supported forms : (2 forms)

func (*Program) LZCNTW 

func (self *Program) LZCNTW(v0 interface{}, v1 interface{}) *Instruction

LZCNTW performs "Count the Number of Leading Zero Bits".

Mnemonic : LZCNT Supported forms : (2 forms) 

func (self *Program) Link(p *Label)

Link pins a label at the current position.

func (*Program) Long 

func (self *Program) Long(v *expr.Expr) (p *Instruction)

Long is a pseudo-instruction to add raw uint32 as little-endian to the assembled code.

func (*Program) MASKMOVDQU 

func (self *Program) MASKMOVDQU(v0 interface{}, v1 interface{}) *Instruction

MASKMOVDQU performs "Store Selected Bytes of Double Quadword".

Mnemonic : MASKMOVDQU Supported forms : (1 form)

func (*Program) MASKMOVQ 

func (self *Program) MASKMOVQ(v0 interface{}, v1 interface{}) *Instruction

MASKMOVQ performs "Store Selected Bytes of Quadword".

Mnemonic : MASKMOVQ Supported forms : (1 form)

func (*Program) MAXPD 

func (self *Program) MAXPD(v0 interface{}, v1 interface{}) *Instruction

MAXPD performs "Return Maximum Packed Double-Precision Floating-Point Values".

Mnemonic : MAXPD Supported forms : (2 forms)

func (*Program) MAXPS 

func (self *Program) MAXPS(v0 interface{}, v1 interface{}) *Instruction

MAXPS performs "Return Maximum Packed Single-Precision Floating-Point Values".

Mnemonic : MAXPS Supported forms : (2 forms)

func (*Program) MAXSD 

func (self *Program) MAXSD(v0 interface{}, v1 interface{}) *Instruction

MAXSD performs "Return Maximum Scalar Double-Precision Floating-Point Value".

Mnemonic : MAXSD Supported forms : (2 forms)

func (*Program) MAXSS 

func (self *Program) MAXSS(v0 interface{}, v1 interface{}) *Instruction

MAXSS performs "Return Maximum Scalar Single-Precision Floating-Point Value".

Mnemonic : MAXSS Supported forms : (2 forms)

func (*Program) MFENCE 

func (self *Program) MFENCE() *Instruction

MFENCE performs "Memory Fence".

Mnemonic : MFENCE Supported forms : (1 form)

func (*Program) MINPD 

func (self *Program) MINPD(v0 interface{}, v1 interface{}) *Instruction

MINPD performs "Return Minimum Packed Double-Precision Floating-Point Values".

Mnemonic : MINPD Supported forms : (2 forms)

func (*Program) MINPS 

func (self *Program) MINPS(v0 interface{}, v1 interface{}) *Instruction

MINPS performs "Return Minimum Packed Single-Precision Floating-Point Values".

Mnemonic : MINPS Supported forms : (2 forms)

func (*Program) MINSD 

func (self *Program) MINSD(v0 interface{}, v1 interface{}) *Instruction

MINSD performs "Return Minimum Scalar Double-Precision Floating-Point Value".

Mnemonic : MINSD Supported forms : (2 forms)

func (*Program) MINSS 

func (self *Program) MINSS(v0 interface{}, v1 interface{}) *Instruction

MINSS performs "Return Minimum Scalar Single-Precision Floating-Point Value".

Mnemonic : MINSS Supported forms : (2 forms)

func (*Program) MONITOR 

func (self *Program) MONITOR() *Instruction

MONITOR performs "Monitor a Linear Address Range".

Mnemonic : MONITOR Supported forms : (1 form)

func (*Program) MONITORX 

func (self *Program) MONITORX() *Instruction

MONITORX performs "Monitor a Linear Address Range with Timeout".

Mnemonic : MONITORX Supported forms : (1 form)

func (*Program) MOVAPD 

func (self *Program) MOVAPD(v0 interface{}, v1 interface{}) *Instruction

MOVAPD performs "Move Aligned Packed Double-Precision Floating-Point Values".

Mnemonic : MOVAPD Supported forms : (3 forms)

func (*Program) MOVAPS 

func (self *Program) MOVAPS(v0 interface{}, v1 interface{}) *Instruction

MOVAPS performs "Move Aligned Packed Single-Precision Floating-Point Values".

Mnemonic : MOVAPS Supported forms : (3 forms)

func (*Program) MOVB 

func (self *Program) MOVB(v0 interface{}, v1 interface{}) *Instruction

MOVB performs "Move".

Mnemonic : MOV Supported forms : (5 forms)

func (*Program) MOVBEL 

func (self *Program) MOVBEL(v0 interface{}, v1 interface{}) *Instruction

MOVBEL performs "Move Data After Swapping Bytes".

Mnemonic : MOVBE Supported forms : (2 forms)

func (*Program) MOVBEQ 

func (self *Program) MOVBEQ(v0 interface{}, v1 interface{}) *Instruction

MOVBEQ performs "Move Data After Swapping Bytes".

Mnemonic : MOVBE Supported forms : (2 forms)

func (*Program) MOVBEW 

func (self *Program) MOVBEW(v0 interface{}, v1 interface{}) *Instruction

MOVBEW performs "Move Data After Swapping Bytes".

Mnemonic : MOVBE Supported forms : (2 forms)

func (*Program) MOVD 

func (self *Program) MOVD(v0 interface{}, v1 interface{}) *Instruction

MOVD performs "Move Doubleword".

Mnemonic : MOVD Supported forms : (8 forms)

func (*Program) MOVDDUP 

func (self *Program) MOVDDUP(v0 interface{}, v1 interface{}) *Instruction

MOVDDUP performs "Move One Double-FP and Duplicate".

Mnemonic : MOVDDUP Supported forms : (2 forms)

func (*Program) MOVDQ2Q 

func (self *Program) MOVDQ2Q(v0 interface{}, v1 interface{}) *Instruction

MOVDQ2Q performs "Move Quadword from XMM to MMX Technology Register".

Mnemonic : MOVDQ2Q Supported forms : (1 form)

func (*Program) MOVDQA 

func (self *Program) MOVDQA(v0 interface{}, v1 interface{}) *Instruction

MOVDQA performs "Move Aligned Double Quadword".

Mnemonic : MOVDQA Supported forms : (3 forms)

func (*Program) MOVDQU 

func (self *Program) MOVDQU(v0 interface{}, v1 interface{}) *Instruction

MOVDQU performs "Move Unaligned Double Quadword".

Mnemonic : MOVDQU Supported forms : (3 forms)

func (*Program) MOVHLPS 

func (self *Program) MOVHLPS(v0 interface{}, v1 interface{}) *Instruction

MOVHLPS performs "Move Packed Single-Precision Floating-Point Values High to Low".

Mnemonic : MOVHLPS Supported forms : (1 form)

func (*Program) MOVHPD 

func (self *Program) MOVHPD(v0 interface{}, v1 interface{}) *Instruction

MOVHPD performs "Move High Packed Double-Precision Floating-Point Value".

Mnemonic : MOVHPD Supported forms : (2 forms)

func (*Program) MOVHPS 

func (self *Program) MOVHPS(v0 interface{}, v1 interface{}) *Instruction

MOVHPS performs "Move High Packed Single-Precision Floating-Point Values".

Mnemonic : MOVHPS Supported forms : (2 forms)

func (*Program) MOVL 

func (self *Program) MOVL(v0 interface{}, v1 interface{}) *Instruction

MOVL performs "Move".

Mnemonic : MOV Supported forms : (5 forms)

func (*Program) MOVLHPS 

func (self *Program) MOVLHPS(v0 interface{}, v1 interface{}) *Instruction

MOVLHPS performs "Move Packed Single-Precision Floating-Point Values Low to High".

Mnemonic : MOVLHPS Supported forms : (1 form)

func (*Program) MOVLPD 

func (self *Program) MOVLPD(v0 interface{}, v1 interface{}) *Instruction

MOVLPD performs "Move Low Packed Double-Precision Floating-Point Value".

Mnemonic : MOVLPD Supported forms : (2 forms)

func (*Program) MOVLPS 

func (self *Program) MOVLPS(v0 interface{}, v1 interface{}) *Instruction

MOVLPS performs "Move Low Packed Single-Precision Floating-Point Values".

Mnemonic : MOVLPS Supported forms : (2 forms)

func (*Program) MOVMSKPD 

func (self *Program) MOVMSKPD(v0 interface{}, v1 interface{}) *Instruction

MOVMSKPD performs "Extract Packed Double-Precision Floating-Point Sign Mask".

Mnemonic : MOVMSKPD Supported forms : (1 form)

func (*Program) MOVMSKPS 

func (self *Program) MOVMSKPS(v0 interface{}, v1 interface{}) *Instruction

MOVMSKPS performs "Extract Packed Single-Precision Floating-Point Sign Mask".

Mnemonic : MOVMSKPS Supported forms : (1 form)

func (*Program) MOVNTDQ 

func (self *Program) MOVNTDQ(v0 interface{}, v1 interface{}) *Instruction

MOVNTDQ performs "Store Double Quadword Using Non-Temporal Hint".

Mnemonic : MOVNTDQ Supported forms : (1 form)

func (*Program) MOVNTDQA 

func (self *Program) MOVNTDQA(v0 interface{}, v1 interface{}) *Instruction

MOVNTDQA performs "Load Double Quadword Non-Temporal Aligned Hint".

Mnemonic : MOVNTDQA Supported forms : (1 form)

func (*Program) MOVNTIL 

func (self *Program) MOVNTIL(v0 interface{}, v1 interface{}) *Instruction

MOVNTIL performs "Store Doubleword Using Non-Temporal Hint".

Mnemonic : MOVNTI Supported forms : (1 form)

func (*Program) MOVNTIQ 

func (self *Program) MOVNTIQ(v0 interface{}, v1 interface{}) *Instruction

MOVNTIQ performs "Store Doubleword Using Non-Temporal Hint".

Mnemonic : MOVNTI Supported forms : (1 form)

func (*Program) MOVNTPD 

func (self *Program) MOVNTPD(v0 interface{}, v1 interface{}) *Instruction

MOVNTPD performs "Store Packed Double-Precision Floating-Point Values Using Non-Temporal Hint".

Mnemonic : MOVNTPD Supported forms : (1 form)

func (*Program) MOVNTPS 

func (self *Program) MOVNTPS(v0 interface{}, v1 interface{}) *Instruction

MOVNTPS performs "Store Packed Single-Precision Floating-Point Values Using Non-Temporal Hint".

Mnemonic : MOVNTPS Supported forms : (1 form)

func (*Program) MOVNTQ 

func (self *Program) MOVNTQ(v0 interface{}, v1 interface{}) *Instruction

MOVNTQ performs "Store of Quadword Using Non-Temporal Hint".

Mnemonic : MOVNTQ Supported forms : (1 form)

func (*Program) MOVNTSD 

func (self *Program) MOVNTSD(v0 interface{}, v1 interface{}) *Instruction

MOVNTSD performs "Store Scalar Double-Precision Floating-Point Values Using Non-Temporal Hint".

Mnemonic : MOVNTSD Supported forms : (1 form)

func (*Program) MOVNTSS 

func (self *Program) MOVNTSS(v0 interface{}, v1 interface{}) *Instruction

MOVNTSS performs "Store Scalar Single-Precision Floating-Point Values Using Non-Temporal Hint".

Mnemonic : MOVNTSS Supported forms : (1 form)

func (*Program) MOVQ 

func (self *Program) MOVQ(v0 interface{}, v1 interface{}) *Instruction

MOVQ performs "Move".

Mnemonic : MOV Supported forms : (16 forms)

func (*Program) MOVQ2DQ 

func (self *Program) MOVQ2DQ(v0 interface{}, v1 interface{}) *Instruction

MOVQ2DQ performs "Move Quadword from MMX Technology to XMM Register".

Mnemonic : MOVQ2DQ Supported forms : (1 form)

func (*Program) MOVSBL 

func (self *Program) MOVSBL(v0 interface{}, v1 interface{}) *Instruction

MOVSBL performs "Move with Sign-Extension".

Mnemonic : MOVSX Supported forms : (2 forms)

func (*Program) MOVSBQ 

func (self *Program) MOVSBQ(v0 interface{}, v1 interface{}) *Instruction

MOVSBQ performs "Move with Sign-Extension".

Mnemonic : MOVSX Supported forms : (2 forms)

func (*Program) MOVSBW 

func (self *Program) MOVSBW(v0 interface{}, v1 interface{}) *Instruction

MOVSBW performs "Move with Sign-Extension".

Mnemonic : MOVSX Supported forms : (2 forms)

func (*Program) MOVSD 

func (self *Program) MOVSD(v0 interface{}, v1 interface{}) *Instruction

MOVSD performs "Move Scalar Double-Precision Floating-Point Value".

Mnemonic : MOVSD Supported forms : (3 forms)

func (*Program) MOVSHDUP 

func (self *Program) MOVSHDUP(v0 interface{}, v1 interface{}) *Instruction

MOVSHDUP performs "Move Packed Single-FP High and Duplicate".

Mnemonic : MOVSHDUP Supported forms : (2 forms)

func (*Program) MOVSLDUP 

func (self *Program) MOVSLDUP(v0 interface{}, v1 interface{}) *Instruction

MOVSLDUP performs "Move Packed Single-FP Low and Duplicate".

Mnemonic : MOVSLDUP Supported forms : (2 forms)

func (*Program) MOVSLQ 

func (self *Program) MOVSLQ(v0 interface{}, v1 interface{}) *Instruction

MOVSLQ performs "Move Doubleword to Quadword with Sign-Extension".

Mnemonic : MOVSXD Supported forms : (2 forms)

func (*Program) MOVSS 

func (self *Program) MOVSS(v0 interface{}, v1 interface{}) *Instruction

MOVSS performs "Move Scalar Single-Precision Floating-Point Values".

Mnemonic : MOVSS Supported forms : (3 forms)

func (*Program) MOVSWL 

func (self *Program) MOVSWL(v0 interface{}, v1 interface{}) *Instruction

MOVSWL performs "Move with Sign-Extension".

Mnemonic : MOVSX Supported forms : (2 forms)

func (*Program) MOVSWQ 

func (self *Program) MOVSWQ(v0 interface{}, v1 interface{}) *Instruction

MOVSWQ performs "Move with Sign-Extension".

Mnemonic : MOVSX Supported forms : (2 forms)

func (*Program) MOVUPD 

func (self *Program) MOVUPD(v0 interface{}, v1 interface{}) *Instruction

MOVUPD performs "Move Unaligned Packed Double-Precision Floating-Point Values".

Mnemonic : MOVUPD Supported forms : (3 forms)

func (*Program) MOVUPS 

func (self *Program) MOVUPS(v0 interface{}, v1 interface{}) *Instruction

MOVUPS performs "Move Unaligned Packed Single-Precision Floating-Point Values".

Mnemonic : MOVUPS Supported forms : (3 forms)

func (*Program) MOVW 

func (self *Program) MOVW(v0 interface{}, v1 interface{}) *Instruction

MOVW performs "Move".

Mnemonic : MOV Supported forms : (5 forms)

func (*Program) MOVZBL 

func (self *Program) MOVZBL(v0 interface{}, v1 interface{}) *Instruction

MOVZBL performs "Move with Zero-Extend".

Mnemonic : MOVZX Supported forms : (2 forms)

func (*Program) MOVZBQ 

func (self *Program) MOVZBQ(v0 interface{}, v1 interface{}) *Instruction

MOVZBQ performs "Move with Zero-Extend".

Mnemonic : MOVZX Supported forms : (2 forms)

func (*Program) MOVZBW 

func (self *Program) MOVZBW(v0 interface{}, v1 interface{}) *Instruction

MOVZBW performs "Move with Zero-Extend".

Mnemonic : MOVZX Supported forms : (2 forms)

func (*Program) MOVZWL 

func (self *Program) MOVZWL(v0 interface{}, v1 interface{}) *Instruction

MOVZWL performs "Move with Zero-Extend".

Mnemonic : MOVZX Supported forms : (2 forms)

func (*Program) MOVZWQ 

func (self *Program) MOVZWQ(v0 interface{}, v1 interface{}) *Instruction

MOVZWQ performs "Move with Zero-Extend".

Mnemonic : MOVZX Supported forms : (2 forms)

func (*Program) MPSADBW 

func (self *Program) MPSADBW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

MPSADBW performs "Compute Multiple Packed Sums of Absolute Difference".

Mnemonic : MPSADBW Supported forms : (2 forms)

func (*Program) MULB 

func (self *Program) MULB(v0 interface{}) *Instruction

MULB performs "Unsigned Multiply".

Mnemonic : MUL Supported forms : (2 forms)

func (*Program) MULL 

func (self *Program) MULL(v0 interface{}) *Instruction

MULL performs "Unsigned Multiply".

Mnemonic : MUL Supported forms : (2 forms)

func (*Program) MULPD 

func (self *Program) MULPD(v0 interface{}, v1 interface{}) *Instruction

MULPD performs "Multiply Packed Double-Precision Floating-Point Values".

Mnemonic : MULPD Supported forms : (2 forms)

func (*Program) MULPS 

func (self *Program) MULPS(v0 interface{}, v1 interface{}) *Instruction

MULPS performs "Multiply Packed Single-Precision Floating-Point Values".

Mnemonic : MULPS Supported forms : (2 forms)

func (*Program) MULQ 

func (self *Program) MULQ(v0 interface{}) *Instruction

MULQ performs "Unsigned Multiply".

Mnemonic : MUL Supported forms : (2 forms)

func (*Program) MULSD 

func (self *Program) MULSD(v0 interface{}, v1 interface{}) *Instruction

MULSD performs "Multiply Scalar Double-Precision Floating-Point Values".

Mnemonic : MULSD Supported forms : (2 forms)

func (*Program) MULSS 

func (self *Program) MULSS(v0 interface{}, v1 interface{}) *Instruction

MULSS performs "Multiply Scalar Single-Precision Floating-Point Values".

Mnemonic : MULSS Supported forms : (2 forms)

func (*Program) MULW 

func (self *Program) MULW(v0 interface{}) *Instruction

MULW performs "Unsigned Multiply".

Mnemonic : MUL Supported forms : (2 forms)

func (*Program) MULXL 

func (self *Program) MULXL(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

MULXL performs "Unsigned Multiply Without Affecting Flags".

Mnemonic : MULX Supported forms : (2 forms)

func (*Program) MULXQ 

func (self *Program) MULXQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

MULXQ performs "Unsigned Multiply Without Affecting Flags".

Mnemonic : MULX Supported forms : (2 forms)

func (*Program) MWAIT 

func (self *Program) MWAIT() *Instruction

MWAIT performs "Monitor Wait".

Mnemonic : MWAIT Supported forms : (1 form)

func (*Program) MWAITX 

func (self *Program) MWAITX() *Instruction

MWAITX performs "Monitor Wait with Timeout".

Mnemonic : MWAITX Supported forms : (1 form)

func (*Program) NEGB 

func (self *Program) NEGB(v0 interface{}) *Instruction

NEGB performs "Two's Complement Negation".

Mnemonic : NEG Supported forms : (2 forms)

func (*Program) NEGL 

func (self *Program) NEGL(v0 interface{}) *Instruction

NEGL performs "Two's Complement Negation".

Mnemonic : NEG Supported forms : (2 forms)

func (*Program) NEGQ 

func (self *Program) NEGQ(v0 interface{}) *Instruction

NEGQ performs "Two's Complement Negation".

Mnemonic : NEG Supported forms : (2 forms)

func (*Program) NEGW 

func (self *Program) NEGW(v0 interface{}) *Instruction

NEGW performs "Two's Complement Negation".

Mnemonic : NEG Supported forms : (2 forms)

func (*Program) NOP 

func (self *Program) NOP() *Instruction

NOP performs "No Operation".

Mnemonic : NOP Supported forms : (1 form)

func (*Program) NOTB 

func (self *Program) NOTB(v0 interface{}) *Instruction

NOTB performs "One's Complement Negation".

Mnemonic : NOT Supported forms : (2 forms)

func (*Program) NOTL 

func (self *Program) NOTL(v0 interface{}) *Instruction

NOTL performs "One's Complement Negation".

Mnemonic : NOT Supported forms : (2 forms)

func (*Program) NOTQ 

func (self *Program) NOTQ(v0 interface{}) *Instruction

NOTQ performs "One's Complement Negation".

Mnemonic : NOT Supported forms : (2 forms)

func (*Program) NOTW 

func (self *Program) NOTW(v0 interface{}) *Instruction

NOTW performs "One's Complement Negation".

Mnemonic : NOT Supported forms : (2 forms)

func (*Program) ORB 

func (self *Program) ORB(v0 interface{}, v1 interface{}) *Instruction

ORB performs "Logical Inclusive OR".

Mnemonic : OR Supported forms : (6 forms)

func (*Program) ORL 

func (self *Program) ORL(v0 interface{}, v1 interface{}) *Instruction

ORL performs "Logical Inclusive OR".

Mnemonic : OR Supported forms : (8 forms)

func (*Program) ORPD 

func (self *Program) ORPD(v0 interface{}, v1 interface{}) *Instruction

ORPD performs "Bitwise Logical OR of Double-Precision Floating-Point Values".

Mnemonic : ORPD Supported forms : (2 forms)

func (*Program) ORPS 

func (self *Program) ORPS(v0 interface{}, v1 interface{}) *Instruction

ORPS performs "Bitwise Logical OR of Single-Precision Floating-Point Values".

Mnemonic : ORPS Supported forms : (2 forms)

func (*Program) ORQ 

func (self *Program) ORQ(v0 interface{}, v1 interface{}) *Instruction

ORQ performs "Logical Inclusive OR".

Mnemonic : OR Supported forms : (8 forms)

func (*Program) ORW 

func (self *Program) ORW(v0 interface{}, v1 interface{}) *Instruction

ORW performs "Logical Inclusive OR".

Mnemonic : OR Supported forms : (8 forms)

func (*Program) PABSB 

func (self *Program) PABSB(v0 interface{}, v1 interface{}) *Instruction

PABSB performs "Packed Absolute Value of Byte Integers".

Mnemonic : PABSB Supported forms : (4 forms)

func (*Program) PABSD 

func (self *Program) PABSD(v0 interface{}, v1 interface{}) *Instruction

PABSD performs "Packed Absolute Value of Doubleword Integers".

Mnemonic : PABSD Supported forms : (4 forms)

func (*Program) PABSW 

func (self *Program) PABSW(v0 interface{}, v1 interface{}) *Instruction

PABSW performs "Packed Absolute Value of Word Integers".

Mnemonic : PABSW Supported forms : (4 forms)

func (*Program) PACKSSDW 

func (self *Program) PACKSSDW(v0 interface{}, v1 interface{}) *Instruction

PACKSSDW performs "Pack Doublewords into Words with Signed Saturation".

Mnemonic : PACKSSDW Supported forms : (4 forms)

func (*Program) PACKSSWB 

func (self *Program) PACKSSWB(v0 interface{}, v1 interface{}) *Instruction

PACKSSWB performs "Pack Words into Bytes with Signed Saturation".

Mnemonic : PACKSSWB Supported forms : (4 forms)

func (*Program) PACKUSDW 

func (self *Program) PACKUSDW(v0 interface{}, v1 interface{}) *Instruction

PACKUSDW performs "Pack Doublewords into Words with Unsigned Saturation".

Mnemonic : PACKUSDW Supported forms : (2 forms)

func (*Program) PACKUSWB 

func (self *Program) PACKUSWB(v0 interface{}, v1 interface{}) *Instruction

PACKUSWB performs "Pack Words into Bytes with Unsigned Saturation".

Mnemonic : PACKUSWB Supported forms : (4 forms)

func (*Program) PADDB 

func (self *Program) PADDB(v0 interface{}, v1 interface{}) *Instruction

PADDB performs "Add Packed Byte Integers".

Mnemonic : PADDB Supported forms : (4 forms)

func (*Program) PADDD 

func (self *Program) PADDD(v0 interface{}, v1 interface{}) *Instruction

PADDD performs "Add Packed Doubleword Integers".

Mnemonic : PADDD Supported forms : (4 forms)

func (*Program) PADDQ 

func (self *Program) PADDQ(v0 interface{}, v1 interface{}) *Instruction

PADDQ performs "Add Packed Quadword Integers".

Mnemonic : PADDQ Supported forms : (4 forms)

func (*Program) PADDSB 

func (self *Program) PADDSB(v0 interface{}, v1 interface{}) *Instruction

PADDSB performs "Add Packed Signed Byte Integers with Signed Saturation".

Mnemonic : PADDSB Supported forms : (4 forms)

func (*Program) PADDSW 

func (self *Program) PADDSW(v0 interface{}, v1 interface{}) *Instruction

PADDSW performs "Add Packed Signed Word Integers with Signed Saturation".

Mnemonic : PADDSW Supported forms : (4 forms)

func (*Program) PADDUSB 

func (self *Program) PADDUSB(v0 interface{}, v1 interface{}) *Instruction

PADDUSB performs "Add Packed Unsigned Byte Integers with Unsigned Saturation".

Mnemonic : PADDUSB Supported forms : (4 forms)

func (*Program) PADDUSW 

func (self *Program) PADDUSW(v0 interface{}, v1 interface{}) *Instruction

PADDUSW performs "Add Packed Unsigned Word Integers with Unsigned Saturation".

Mnemonic : PADDUSW Supported forms : (4 forms)

func (*Program) PADDW 

func (self *Program) PADDW(v0 interface{}, v1 interface{}) *Instruction

PADDW performs "Add Packed Word Integers".

Mnemonic : PADDW Supported forms : (4 forms)

func (*Program) PALIGNR 

func (self *Program) PALIGNR(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

PALIGNR performs "Packed Align Right".

Mnemonic : PALIGNR Supported forms : (4 forms)

func (*Program) PAND 

func (self *Program) PAND(v0 interface{}, v1 interface{}) *Instruction

PAND performs "Packed Bitwise Logical AND".

Mnemonic : PAND Supported forms : (4 forms)

func (*Program) PANDN 

func (self *Program) PANDN(v0 interface{}, v1 interface{}) *Instruction

PANDN performs "Packed Bitwise Logical AND NOT".

Mnemonic : PANDN Supported forms : (4 forms)

func (*Program) PAUSE 

func (self *Program) PAUSE() *Instruction

PAUSE performs "Spin Loop Hint".

Mnemonic : PAUSE Supported forms : (1 form)

func (*Program) PAVGB 

func (self *Program) PAVGB(v0 interface{}, v1 interface{}) *Instruction

PAVGB performs "Average Packed Byte Integers".

Mnemonic : PAVGB Supported forms : (4 forms)

func (*Program) PAVGUSB 

func (self *Program) PAVGUSB(v0 interface{}, v1 interface{}) *Instruction

PAVGUSB performs "Average Packed Byte Integers".

Mnemonic : PAVGUSB Supported forms : (2 forms)

func (*Program) PAVGW 

func (self *Program) PAVGW(v0 interface{}, v1 interface{}) *Instruction

PAVGW performs "Average Packed Word Integers".

Mnemonic : PAVGW Supported forms : (4 forms)

func (*Program) PBLENDVB 

func (self *Program) PBLENDVB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

PBLENDVB performs "Variable Blend Packed Bytes".

Mnemonic : PBLENDVB Supported forms : (2 forms)

func (*Program) PBLENDW 

func (self *Program) PBLENDW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

PBLENDW performs "Blend Packed Words".

Mnemonic : PBLENDW Supported forms : (2 forms)

func (*Program) PCLMULQDQ 

func (self *Program) PCLMULQDQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

PCLMULQDQ performs "Carry-Less Quadword Multiplication".

Mnemonic : PCLMULQDQ Supported forms : (2 forms)

func (*Program) PCMPEQB 

func (self *Program) PCMPEQB(v0 interface{}, v1 interface{}) *Instruction

PCMPEQB performs "Compare Packed Byte Data for Equality".

Mnemonic : PCMPEQB Supported forms : (4 forms)

func (*Program) PCMPEQD 

func (self *Program) PCMPEQD(v0 interface{}, v1 interface{}) *Instruction

PCMPEQD performs "Compare Packed Doubleword Data for Equality".

Mnemonic : PCMPEQD Supported forms : (4 forms)

func (*Program) PCMPEQQ 

func (self *Program) PCMPEQQ(v0 interface{}, v1 interface{}) *Instruction

PCMPEQQ performs "Compare Packed Quadword Data for Equality".

Mnemonic : PCMPEQQ Supported forms : (2 forms)

func (*Program) PCMPEQW 

func (self *Program) PCMPEQW(v0 interface{}, v1 interface{}) *Instruction

PCMPEQW performs "Compare Packed Word Data for Equality".

Mnemonic : PCMPEQW Supported forms : (4 forms)

func (*Program) PCMPESTRI 

func (self *Program) PCMPESTRI(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

PCMPESTRI performs "Packed Compare Explicit Length Strings, Return Index".

Mnemonic : PCMPESTRI Supported forms : (2 forms)

func (*Program) PCMPESTRM 

func (self *Program) PCMPESTRM(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

PCMPESTRM performs "Packed Compare Explicit Length Strings, Return Mask".

Mnemonic : PCMPESTRM Supported forms : (2 forms)

func (*Program) PCMPGTB 

func (self *Program) PCMPGTB(v0 interface{}, v1 interface{}) *Instruction

PCMPGTB performs "Compare Packed Signed Byte Integers for Greater Than".

Mnemonic : PCMPGTB Supported forms : (4 forms)

func (*Program) PCMPGTD 

func (self *Program) PCMPGTD(v0 interface{}, v1 interface{}) *Instruction

PCMPGTD performs "Compare Packed Signed Doubleword Integers for Greater Than".

Mnemonic : PCMPGTD Supported forms : (4 forms)

func (*Program) PCMPGTQ 

func (self *Program) PCMPGTQ(v0 interface{}, v1 interface{}) *Instruction

PCMPGTQ performs "Compare Packed Data for Greater Than".

Mnemonic : PCMPGTQ Supported forms : (2 forms)

func (*Program) PCMPGTW 

func (self *Program) PCMPGTW(v0 interface{}, v1 interface{}) *Instruction

PCMPGTW performs "Compare Packed Signed Word Integers for Greater Than".

Mnemonic : PCMPGTW Supported forms : (4 forms)

func (*Program) PCMPISTRI 

func (self *Program) PCMPISTRI(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

PCMPISTRI performs "Packed Compare Implicit Length Strings, Return Index".

Mnemonic : PCMPISTRI Supported forms : (2 forms)

func (*Program) PCMPISTRM 

func (self *Program) PCMPISTRM(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

PCMPISTRM performs "Packed Compare Implicit Length Strings, Return Mask".

Mnemonic : PCMPISTRM Supported forms : (2 forms)

func (*Program) PDEP 

func (self *Program) PDEP(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

PDEP performs "Parallel Bits Deposit".

Mnemonic : PDEP Supported forms : (4 forms)

func (*Program) PEXT 

func (self *Program) PEXT(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

PEXT performs "Parallel Bits Extract".

Mnemonic : PEXT Supported forms : (4 forms)

func (*Program) PEXTRB 

func (self *Program) PEXTRB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

PEXTRB performs "Extract Byte".

Mnemonic : PEXTRB Supported forms : (2 forms)

func (*Program) PEXTRD 

func (self *Program) PEXTRD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

PEXTRD performs "Extract Doubleword".

Mnemonic : PEXTRD Supported forms : (2 forms)

func (*Program) PEXTRQ 

func (self *Program) PEXTRQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

PEXTRQ performs "Extract Quadword".

Mnemonic : PEXTRQ Supported forms : (2 forms)

func (*Program) PEXTRW 

func (self *Program) PEXTRW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

PEXTRW performs "Extract Word".

Mnemonic : PEXTRW Supported forms : (3 forms)

func (*Program) PF2ID 

func (self *Program) PF2ID(v0 interface{}, v1 interface{}) *Instruction

PF2ID performs "Packed Floating-Point to Integer Doubleword Converson".

Mnemonic : PF2ID Supported forms : (2 forms)

func (*Program) PF2IW 

func (self *Program) PF2IW(v0 interface{}, v1 interface{}) *Instruction

PF2IW performs "Packed Floating-Point to Integer Word Conversion".

Mnemonic : PF2IW Supported forms : (2 forms)

func (*Program) PFACC 

func (self *Program) PFACC(v0 interface{}, v1 interface{}) *Instruction

PFACC performs "Packed Floating-Point Accumulate".

Mnemonic : PFACC Supported forms : (2 forms)

func (*Program) PFADD 

func (self *Program) PFADD(v0 interface{}, v1 interface{}) *Instruction

PFADD performs "Packed Floating-Point Add".

Mnemonic : PFADD Supported forms : (2 forms)

func (*Program) PFCMPEQ 

func (self *Program) PFCMPEQ(v0 interface{}, v1 interface{}) *Instruction

PFCMPEQ performs "Packed Floating-Point Compare for Equal".

Mnemonic : PFCMPEQ Supported forms : (2 forms)

func (*Program) PFCMPGE 

func (self *Program) PFCMPGE(v0 interface{}, v1 interface{}) *Instruction

PFCMPGE performs "Packed Floating-Point Compare for Greater or Equal".

Mnemonic : PFCMPGE Supported forms : (2 forms)

func (*Program) PFCMPGT 

func (self *Program) PFCMPGT(v0 interface{}, v1 interface{}) *Instruction

PFCMPGT performs "Packed Floating-Point Compare for Greater Than".

Mnemonic : PFCMPGT Supported forms : (2 forms)

func (*Program) PFMAX 

func (self *Program) PFMAX(v0 interface{}, v1 interface{}) *Instruction

PFMAX performs "Packed Floating-Point Maximum".

Mnemonic : PFMAX Supported forms : (2 forms)

func (*Program) PFMIN 

func (self *Program) PFMIN(v0 interface{}, v1 interface{}) *Instruction

PFMIN performs "Packed Floating-Point Minimum".

Mnemonic : PFMIN Supported forms : (2 forms)

func (*Program) PFMUL 

func (self *Program) PFMUL(v0 interface{}, v1 interface{}) *Instruction

PFMUL performs "Packed Floating-Point Multiply".

Mnemonic : PFMUL Supported forms : (2 forms)

func (*Program) PFNACC 

func (self *Program) PFNACC(v0 interface{}, v1 interface{}) *Instruction

PFNACC performs "Packed Floating-Point Negative Accumulate".

Mnemonic : PFNACC Supported forms : (2 forms)

func (*Program) PFPNACC 

func (self *Program) PFPNACC(v0 interface{}, v1 interface{}) *Instruction

PFPNACC performs "Packed Floating-Point Positive-Negative Accumulate".

Mnemonic : PFPNACC Supported forms : (2 forms)

func (*Program) PFRCP 

func (self *Program) PFRCP(v0 interface{}, v1 interface{}) *Instruction

PFRCP performs "Packed Floating-Point Reciprocal Approximation".

Mnemonic : PFRCP Supported forms : (2 forms)

func (*Program) PFRCPIT1 

func (self *Program) PFRCPIT1(v0 interface{}, v1 interface{}) *Instruction

PFRCPIT1 performs "Packed Floating-Point Reciprocal Iteration 1".

Mnemonic : PFRCPIT1 Supported forms : (2 forms)

func (*Program) PFRCPIT2 

func (self *Program) PFRCPIT2(v0 interface{}, v1 interface{}) *Instruction

PFRCPIT2 performs "Packed Floating-Point Reciprocal Iteration 2".

Mnemonic : PFRCPIT2 Supported forms : (2 forms)

func (*Program) PFRSQIT1 

func (self *Program) PFRSQIT1(v0 interface{}, v1 interface{}) *Instruction

PFRSQIT1 performs "Packed Floating-Point Reciprocal Square Root Iteration 1".

Mnemonic : PFRSQIT1 Supported forms : (2 forms)

func (*Program) PFRSQRT 

func (self *Program) PFRSQRT(v0 interface{}, v1 interface{}) *Instruction

PFRSQRT performs "Packed Floating-Point Reciprocal Square Root Approximation".

Mnemonic : PFRSQRT Supported forms : (2 forms)

func (*Program) PFSUB 

func (self *Program) PFSUB(v0 interface{}, v1 interface{}) *Instruction

PFSUB performs "Packed Floating-Point Subtract".

Mnemonic : PFSUB Supported forms : (2 forms)

func (*Program) PFSUBR 

func (self *Program) PFSUBR(v0 interface{}, v1 interface{}) *Instruction

PFSUBR performs "Packed Floating-Point Subtract Reverse".

Mnemonic : PFSUBR Supported forms : (2 forms)

func (*Program) PHADDD 

func (self *Program) PHADDD(v0 interface{}, v1 interface{}) *Instruction

PHADDD performs "Packed Horizontal Add Doubleword Integer".

Mnemonic : PHADDD Supported forms : (4 forms)

func (*Program) PHADDSW 

func (self *Program) PHADDSW(v0 interface{}, v1 interface{}) *Instruction

PHADDSW performs "Packed Horizontal Add Signed Word Integers with Signed Saturation".

Mnemonic : PHADDSW Supported forms : (4 forms)

func (*Program) PHADDW 

func (self *Program) PHADDW(v0 interface{}, v1 interface{}) *Instruction

PHADDW performs "Packed Horizontal Add Word Integers".

Mnemonic : PHADDW Supported forms : (4 forms)

func (*Program) PHMINPOSUW 

func (self *Program) PHMINPOSUW(v0 interface{}, v1 interface{}) *Instruction

PHMINPOSUW performs "Packed Horizontal Minimum of Unsigned Word Integers".

Mnemonic : PHMINPOSUW Supported forms : (2 forms)

func (*Program) PHSUBD 

func (self *Program) PHSUBD(v0 interface{}, v1 interface{}) *Instruction

PHSUBD performs "Packed Horizontal Subtract Doubleword Integers".

Mnemonic : PHSUBD Supported forms : (4 forms)

func (*Program) PHSUBSW 

func (self *Program) PHSUBSW(v0 interface{}, v1 interface{}) *Instruction

PHSUBSW performs "Packed Horizontal Subtract Signed Word Integers with Signed Saturation".

Mnemonic : PHSUBSW Supported forms : (4 forms)

func (*Program) PHSUBW 

func (self *Program) PHSUBW(v0 interface{}, v1 interface{}) *Instruction

PHSUBW performs "Packed Horizontal Subtract Word Integers".

Mnemonic : PHSUBW Supported forms : (4 forms)

func (*Program) PI2FD 

func (self *Program) PI2FD(v0 interface{}, v1 interface{}) *Instruction

PI2FD performs "Packed Integer to Floating-Point Doubleword Conversion".

Mnemonic : PI2FD Supported forms : (2 forms)

func (*Program) PI2FW 

func (self *Program) PI2FW(v0 interface{}, v1 interface{}) *Instruction

PI2FW performs "Packed Integer to Floating-Point Word Conversion".

Mnemonic : PI2FW Supported forms : (2 forms)

func (*Program) PINSRB 

func (self *Program) PINSRB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

PINSRB performs "Insert Byte".

Mnemonic : PINSRB Supported forms : (2 forms)

func (*Program) PINSRD 

func (self *Program) PINSRD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

PINSRD performs "Insert Doubleword".

Mnemonic : PINSRD Supported forms : (2 forms)

func (*Program) PINSRQ 

func (self *Program) PINSRQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

PINSRQ performs "Insert Quadword".

Mnemonic : PINSRQ Supported forms : (2 forms)

func (*Program) PINSRW 

func (self *Program) PINSRW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

PINSRW performs "Insert Word".

Mnemonic : PINSRW Supported forms : (4 forms)

func (*Program) PMADDUBSW 

func (self *Program) PMADDUBSW(v0 interface{}, v1 interface{}) *Instruction

PMADDUBSW performs "Multiply and Add Packed Signed and Unsigned Byte Integers".

Mnemonic : PMADDUBSW Supported forms : (4 forms)

func (*Program) PMADDWD 

func (self *Program) PMADDWD(v0 interface{}, v1 interface{}) *Instruction

PMADDWD performs "Multiply and Add Packed Signed Word Integers".

Mnemonic : PMADDWD Supported forms : (4 forms)

func (*Program) PMAXSB 

func (self *Program) PMAXSB(v0 interface{}, v1 interface{}) *Instruction

PMAXSB performs "Maximum of Packed Signed Byte Integers".

Mnemonic : PMAXSB Supported forms : (2 forms)

func (*Program) PMAXSD 

func (self *Program) PMAXSD(v0 interface{}, v1 interface{}) *Instruction

PMAXSD performs "Maximum of Packed Signed Doubleword Integers".

Mnemonic : PMAXSD Supported forms : (2 forms)

func (*Program) PMAXSW 

func (self *Program) PMAXSW(v0 interface{}, v1 interface{}) *Instruction

PMAXSW performs "Maximum of Packed Signed Word Integers".

Mnemonic : PMAXSW Supported forms : (4 forms)

func (*Program) PMAXUB 

func (self *Program) PMAXUB(v0 interface{}, v1 interface{}) *Instruction

PMAXUB performs "Maximum of Packed Unsigned Byte Integers".

Mnemonic : PMAXUB Supported forms : (4 forms)

func (*Program) PMAXUD 

func (self *Program) PMAXUD(v0 interface{}, v1 interface{}) *Instruction

PMAXUD performs "Maximum of Packed Unsigned Doubleword Integers".

Mnemonic : PMAXUD Supported forms : (2 forms)

func (*Program) PMAXUW 

func (self *Program) PMAXUW(v0 interface{}, v1 interface{}) *Instruction

PMAXUW performs "Maximum of Packed Unsigned Word Integers".

Mnemonic : PMAXUW Supported forms : (2 forms)

func (*Program) PMINSB 

func (self *Program) PMINSB(v0 interface{}, v1 interface{}) *Instruction

PMINSB performs "Minimum of Packed Signed Byte Integers".

Mnemonic : PMINSB Supported forms : (2 forms)

func (*Program) PMINSD 

func (self *Program) PMINSD(v0 interface{}, v1 interface{}) *Instruction

PMINSD performs "Minimum of Packed Signed Doubleword Integers".

Mnemonic : PMINSD Supported forms : (2 forms)

func (*Program) PMINSW 

func (self *Program) PMINSW(v0 interface{}, v1 interface{}) *Instruction

PMINSW performs "Minimum of Packed Signed Word Integers".

Mnemonic : PMINSW Supported forms : (4 forms)

func (*Program) PMINUB 

func (self *Program) PMINUB(v0 interface{}, v1 interface{}) *Instruction

PMINUB performs "Minimum of Packed Unsigned Byte Integers".

Mnemonic : PMINUB Supported forms : (4 forms)

func (*Program) PMINUD 

func (self *Program) PMINUD(v0 interface{}, v1 interface{}) *Instruction

PMINUD performs "Minimum of Packed Unsigned Doubleword Integers".

Mnemonic : PMINUD Supported forms : (2 forms)

func (*Program) PMINUW 

func (self *Program) PMINUW(v0 interface{}, v1 interface{}) *Instruction

PMINUW performs "Minimum of Packed Unsigned Word Integers".

Mnemonic : PMINUW Supported forms : (2 forms)

func (*Program) PMOVMSKB 

func (self *Program) PMOVMSKB(v0 interface{}, v1 interface{}) *Instruction

PMOVMSKB performs "Move Byte Mask".

Mnemonic : PMOVMSKB Supported forms : (2 forms)

func (*Program) PMOVSXBD 

func (self *Program) PMOVSXBD(v0 interface{}, v1 interface{}) *Instruction

PMOVSXBD performs "Move Packed Byte Integers to Doubleword Integers with Sign Extension".

Mnemonic : PMOVSXBD Supported forms : (2 forms)

func (*Program) PMOVSXBQ 

func (self *Program) PMOVSXBQ(v0 interface{}, v1 interface{}) *Instruction

PMOVSXBQ performs "Move Packed Byte Integers to Quadword Integers with Sign Extension".

Mnemonic : PMOVSXBQ Supported forms : (2 forms)

func (*Program) PMOVSXBW 

func (self *Program) PMOVSXBW(v0 interface{}, v1 interface{}) *Instruction

PMOVSXBW performs "Move Packed Byte Integers to Word Integers with Sign Extension".

Mnemonic : PMOVSXBW Supported forms : (2 forms)

func (*Program) PMOVSXDQ 

func (self *Program) PMOVSXDQ(v0 interface{}, v1 interface{}) *Instruction

PMOVSXDQ performs "Move Packed Doubleword Integers to Quadword Integers with Sign Extension".

Mnemonic : PMOVSXDQ Supported forms : (2 forms)

func (*Program) PMOVSXWD 

func (self *Program) PMOVSXWD(v0 interface{}, v1 interface{}) *Instruction

PMOVSXWD performs "Move Packed Word Integers to Doubleword Integers with Sign Extension".

Mnemonic : PMOVSXWD Supported forms : (2 forms)

func (*Program) PMOVSXWQ 

func (self *Program) PMOVSXWQ(v0 interface{}, v1 interface{}) *Instruction

PMOVSXWQ performs "Move Packed Word Integers to Quadword Integers with Sign Extension".

Mnemonic : PMOVSXWQ Supported forms : (2 forms)

func (*Program) PMOVZXBD 

func (self *Program) PMOVZXBD(v0 interface{}, v1 interface{}) *Instruction

PMOVZXBD performs "Move Packed Byte Integers to Doubleword Integers with Zero Extension".

Mnemonic : PMOVZXBD Supported forms : (2 forms)

func (*Program) PMOVZXBQ 

func (self *Program) PMOVZXBQ(v0 interface{}, v1 interface{}) *Instruction

PMOVZXBQ performs "Move Packed Byte Integers to Quadword Integers with Zero Extension".

Mnemonic : PMOVZXBQ Supported forms : (2 forms)

func (*Program) PMOVZXBW 

func (self *Program) PMOVZXBW(v0 interface{}, v1 interface{}) *Instruction

PMOVZXBW performs "Move Packed Byte Integers to Word Integers with Zero Extension".

Mnemonic : PMOVZXBW Supported forms : (2 forms)

func (*Program) PMOVZXDQ 

func (self *Program) PMOVZXDQ(v0 interface{}, v1 interface{}) *Instruction

PMOVZXDQ performs "Move Packed Doubleword Integers to Quadword Integers with Zero Extension".

Mnemonic : PMOVZXDQ Supported forms : (2 forms)

func (*Program) PMOVZXWD 

func (self *Program) PMOVZXWD(v0 interface{}, v1 interface{}) *Instruction

PMOVZXWD performs "Move Packed Word Integers to Doubleword Integers with Zero Extension".

Mnemonic : PMOVZXWD Supported forms : (2 forms)

func (*Program) PMOVZXWQ 

func (self *Program) PMOVZXWQ(v0 interface{}, v1 interface{}) *Instruction

PMOVZXWQ performs "Move Packed Word Integers to Quadword Integers with Zero Extension".

Mnemonic : PMOVZXWQ Supported forms : (2 forms)

func (*Program) PMULDQ 

func (self *Program) PMULDQ(v0 interface{}, v1 interface{}) *Instruction

PMULDQ performs "Multiply Packed Signed Doubleword Integers and Store Quadword Result".

Mnemonic : PMULDQ Supported forms : (2 forms)

func (*Program) PMULHRSW 

func (self *Program) PMULHRSW(v0 interface{}, v1 interface{}) *Instruction

PMULHRSW performs "Packed Multiply Signed Word Integers and Store High Result with Round and Scale".

Mnemonic : PMULHRSW Supported forms : (4 forms)

func (*Program) PMULHRW 

func (self *Program) PMULHRW(v0 interface{}, v1 interface{}) *Instruction

PMULHRW performs "Packed Multiply High Rounded Word".

Mnemonic : PMULHRW Supported forms : (2 forms)

func (*Program) PMULHUW 

func (self *Program) PMULHUW(v0 interface{}, v1 interface{}) *Instruction

PMULHUW performs "Multiply Packed Unsigned Word Integers and Store High Result".

Mnemonic : PMULHUW Supported forms : (4 forms)

func (*Program) PMULHW 

func (self *Program) PMULHW(v0 interface{}, v1 interface{}) *Instruction

PMULHW performs "Multiply Packed Signed Word Integers and Store High Result".

Mnemonic : PMULHW Supported forms : (4 forms)

func (*Program) PMULLD 

func (self *Program) PMULLD(v0 interface{}, v1 interface{}) *Instruction

PMULLD performs "Multiply Packed Signed Doubleword Integers and Store Low Result".

Mnemonic : PMULLD Supported forms : (2 forms)

func (*Program) PMULLW 

func (self *Program) PMULLW(v0 interface{}, v1 interface{}) *Instruction

PMULLW performs "Multiply Packed Signed Word Integers and Store Low Result".

Mnemonic : PMULLW Supported forms : (4 forms)

func (*Program) PMULUDQ 

func (self *Program) PMULUDQ(v0 interface{}, v1 interface{}) *Instruction

PMULUDQ performs "Multiply Packed Unsigned Doubleword Integers".

Mnemonic : PMULUDQ Supported forms : (4 forms)

func (*Program) POPCNTL 

func (self *Program) POPCNTL(v0 interface{}, v1 interface{}) *Instruction

POPCNTL performs "Count of Number of Bits Set to 1".

Mnemonic : POPCNT Supported forms : (2 forms)

func (*Program) POPCNTQ 

func (self *Program) POPCNTQ(v0 interface{}, v1 interface{}) *Instruction

POPCNTQ performs "Count of Number of Bits Set to 1".

Mnemonic : POPCNT Supported forms : (2 forms)

func (*Program) POPCNTW 

func (self *Program) POPCNTW(v0 interface{}, v1 interface{}) *Instruction

POPCNTW performs "Count of Number of Bits Set to 1".

Mnemonic : POPCNT Supported forms : (2 forms)

func (*Program) POPQ 

func (self *Program) POPQ(v0 interface{}) *Instruction

POPQ performs "Pop a Value from the Stack".

Mnemonic : POP Supported forms : (2 forms)

func (*Program) POPW 

func (self *Program) POPW(v0 interface{}) *Instruction

POPW performs "Pop a Value from the Stack".

Mnemonic : POP Supported forms : (2 forms)

func (*Program) POR 

func (self *Program) POR(v0 interface{}, v1 interface{}) *Instruction

POR performs "Packed Bitwise Logical OR".

Mnemonic : POR Supported forms : (4 forms)

func (*Program) PREFETCH 

func (self *Program) PREFETCH(v0 interface{}) *Instruction

PREFETCH performs "Prefetch Data into Caches".

Mnemonic : PREFETCH Supported forms : (1 form)

func (*Program) PREFETCHNTA 

func (self *Program) PREFETCHNTA(v0 interface{}) *Instruction

PREFETCHNTA performs "Prefetch Data Into Caches using NTA Hint".

Mnemonic : PREFETCHNTA Supported forms : (1 form)

func (*Program) PREFETCHT0 

func (self *Program) PREFETCHT0(v0 interface{}) *Instruction

PREFETCHT0 performs "Prefetch Data Into Caches using T0 Hint".

Mnemonic : PREFETCHT0 Supported forms : (1 form)

func (*Program) PREFETCHT1 

func (self *Program) PREFETCHT1(v0 interface{}) *Instruction

PREFETCHT1 performs "Prefetch Data Into Caches using T1 Hint".

Mnemonic : PREFETCHT1 Supported forms : (1 form)

func (*Program) PREFETCHT2 

func (self *Program) PREFETCHT2(v0 interface{}) *Instruction

PREFETCHT2 performs "Prefetch Data Into Caches using T2 Hint".

Mnemonic : PREFETCHT2 Supported forms : (1 form)

func (*Program) PREFETCHW 

func (self *Program) PREFETCHW(v0 interface{}) *Instruction

PREFETCHW performs "Prefetch Data into Caches in Anticipation of a Write".

Mnemonic : PREFETCHW Supported forms : (1 form)

func (*Program) PREFETCHWT1 

func (self *Program) PREFETCHWT1(v0 interface{}) *Instruction

PREFETCHWT1 performs "Prefetch Vector Data Into Caches with Intent to Write and T1 Hint".

Mnemonic : PREFETCHWT1 Supported forms : (1 form)

func (*Program) PSADBW 

func (self *Program) PSADBW(v0 interface{}, v1 interface{}) *Instruction

PSADBW performs "Compute Sum of Absolute Differences".

Mnemonic : PSADBW Supported forms : (4 forms)

func (*Program) PSHUFB 

func (self *Program) PSHUFB(v0 interface{}, v1 interface{}) *Instruction

PSHUFB performs "Packed Shuffle Bytes".

Mnemonic : PSHUFB Supported forms : (4 forms)

func (*Program) PSHUFD 

func (self *Program) PSHUFD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

PSHUFD performs "Shuffle Packed Doublewords".

Mnemonic : PSHUFD Supported forms : (2 forms)

func (*Program) PSHUFHW 

func (self *Program) PSHUFHW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

PSHUFHW performs "Shuffle Packed High Words".

Mnemonic : PSHUFHW Supported forms : (2 forms)

func (*Program) PSHUFLW 

func (self *Program) PSHUFLW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

PSHUFLW performs "Shuffle Packed Low Words".

Mnemonic : PSHUFLW Supported forms : (2 forms)

func (*Program) PSHUFW 

func (self *Program) PSHUFW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

PSHUFW performs "Shuffle Packed Words".

Mnemonic : PSHUFW Supported forms : (2 forms)

func (*Program) PSIGNB 

func (self *Program) PSIGNB(v0 interface{}, v1 interface{}) *Instruction

PSIGNB performs "Packed Sign of Byte Integers".

Mnemonic : PSIGNB Supported forms : (4 forms)

func (*Program) PSIGND 

func (self *Program) PSIGND(v0 interface{}, v1 interface{}) *Instruction

PSIGND performs "Packed Sign of Doubleword Integers".

Mnemonic : PSIGND Supported forms : (4 forms)

func (*Program) PSIGNW 

func (self *Program) PSIGNW(v0 interface{}, v1 interface{}) *Instruction

PSIGNW performs "Packed Sign of Word Integers".

Mnemonic : PSIGNW Supported forms : (4 forms)

func (*Program) PSLLD 

func (self *Program) PSLLD(v0 interface{}, v1 interface{}) *Instruction

PSLLD performs "Shift Packed Doubleword Data Left Logical".

Mnemonic : PSLLD Supported forms : (6 forms)

func (*Program) PSLLDQ 

func (self *Program) PSLLDQ(v0 interface{}, v1 interface{}) *Instruction

PSLLDQ performs "Shift Packed Double Quadword Left Logical".

Mnemonic : PSLLDQ Supported forms : (1 form)

func (*Program) PSLLQ 

func (self *Program) PSLLQ(v0 interface{}, v1 interface{}) *Instruction

PSLLQ performs "Shift Packed Quadword Data Left Logical".

Mnemonic : PSLLQ Supported forms : (6 forms)

func (*Program) PSLLW 

func (self *Program) PSLLW(v0 interface{}, v1 interface{}) *Instruction

PSLLW performs "Shift Packed Word Data Left Logical".

Mnemonic : PSLLW Supported forms : (6 forms)

func (*Program) PSRAD 

func (self *Program) PSRAD(v0 interface{}, v1 interface{}) *Instruction

PSRAD performs "Shift Packed Doubleword Data Right Arithmetic".

Mnemonic : PSRAD Supported forms : (6 forms)

func (*Program) PSRAW 

func (self *Program) PSRAW(v0 interface{}, v1 interface{}) *Instruction

PSRAW performs "Shift Packed Word Data Right Arithmetic".

Mnemonic : PSRAW Supported forms : (6 forms)

func (*Program) PSRLD 

func (self *Program) PSRLD(v0 interface{}, v1 interface{}) *Instruction

PSRLD performs "Shift Packed Doubleword Data Right Logical".

Mnemonic : PSRLD Supported forms : (6 forms)

func (*Program) PSRLDQ 

func (self *Program) PSRLDQ(v0 interface{}, v1 interface{}) *Instruction

PSRLDQ performs "Shift Packed Double Quadword Right Logical".

Mnemonic : PSRLDQ Supported forms : (1 form)

func (*Program) PSRLQ 

func (self *Program) PSRLQ(v0 interface{}, v1 interface{}) *Instruction

PSRLQ performs "Shift Packed Quadword Data Right Logical".

Mnemonic : PSRLQ Supported forms : (6 forms)

func (*Program) PSRLW 

func (self *Program) PSRLW(v0 interface{}, v1 interface{}) *Instruction

PSRLW performs "Shift Packed Word Data Right Logical".

Mnemonic : PSRLW Supported forms : (6 forms)

func (*Program) PSUBB 

func (self *Program) PSUBB(v0 interface{}, v1 interface{}) *Instruction

PSUBB performs "Subtract Packed Byte Integers".

Mnemonic : PSUBB Supported forms : (4 forms)

func (*Program) PSUBD 

func (self *Program) PSUBD(v0 interface{}, v1 interface{}) *Instruction

PSUBD performs "Subtract Packed Doubleword Integers".

Mnemonic : PSUBD Supported forms : (4 forms)

func (*Program) PSUBQ 

func (self *Program) PSUBQ(v0 interface{}, v1 interface{}) *Instruction

PSUBQ performs "Subtract Packed Quadword Integers".

Mnemonic : PSUBQ Supported forms : (4 forms)

func (*Program) PSUBSB 

func (self *Program) PSUBSB(v0 interface{}, v1 interface{}) *Instruction

PSUBSB performs "Subtract Packed Signed Byte Integers with Signed Saturation".

Mnemonic : PSUBSB Supported forms : (4 forms)

func (*Program) PSUBSW 

func (self *Program) PSUBSW(v0 interface{}, v1 interface{}) *Instruction

PSUBSW performs "Subtract Packed Signed Word Integers with Signed Saturation".

Mnemonic : PSUBSW Supported forms : (4 forms)

func (*Program) PSUBUSB 

func (self *Program) PSUBUSB(v0 interface{}, v1 interface{}) *Instruction

PSUBUSB performs "Subtract Packed Unsigned Byte Integers with Unsigned Saturation".

Mnemonic : PSUBUSB Supported forms : (4 forms)

func (*Program) PSUBUSW 

func (self *Program) PSUBUSW(v0 interface{}, v1 interface{}) *Instruction

PSUBUSW performs "Subtract Packed Unsigned Word Integers with Unsigned Saturation".

Mnemonic : PSUBUSW Supported forms : (4 forms)

func (*Program) PSUBW 

func (self *Program) PSUBW(v0 interface{}, v1 interface{}) *Instruction

PSUBW performs "Subtract Packed Word Integers".

Mnemonic : PSUBW Supported forms : (4 forms)

func (*Program) PSWAPD 

func (self *Program) PSWAPD(v0 interface{}, v1 interface{}) *Instruction

PSWAPD performs "Packed Swap Doubleword".

Mnemonic : PSWAPD Supported forms : (2 forms)

func (*Program) PTEST 

func (self *Program) PTEST(v0 interface{}, v1 interface{}) *Instruction

PTEST performs "Packed Logical Compare".

Mnemonic : PTEST Supported forms : (2 forms)

func (*Program) PUNPCKHBW 

func (self *Program) PUNPCKHBW(v0 interface{}, v1 interface{}) *Instruction

PUNPCKHBW performs "Unpack and Interleave High-Order Bytes into Words".

Mnemonic : PUNPCKHBW Supported forms : (4 forms)

func (*Program) PUNPCKHDQ 

func (self *Program) PUNPCKHDQ(v0 interface{}, v1 interface{}) *Instruction

PUNPCKHDQ performs "Unpack and Interleave High-Order Doublewords into Quadwords".

Mnemonic : PUNPCKHDQ Supported forms : (4 forms)

func (*Program) PUNPCKHQDQ 

func (self *Program) PUNPCKHQDQ(v0 interface{}, v1 interface{}) *Instruction

PUNPCKHQDQ performs "Unpack and Interleave High-Order Quadwords into Double Quadwords".

Mnemonic : PUNPCKHQDQ Supported forms : (2 forms)

func (*Program) PUNPCKHWD 

func (self *Program) PUNPCKHWD(v0 interface{}, v1 interface{}) *Instruction

PUNPCKHWD performs "Unpack and Interleave High-Order Words into Doublewords".

Mnemonic : PUNPCKHWD Supported forms : (4 forms)

func (*Program) PUNPCKLBW 

func (self *Program) PUNPCKLBW(v0 interface{}, v1 interface{}) *Instruction

PUNPCKLBW performs "Unpack and Interleave Low-Order Bytes into Words".

Mnemonic : PUNPCKLBW Supported forms : (4 forms)

func (*Program) PUNPCKLDQ 

func (self *Program) PUNPCKLDQ(v0 interface{}, v1 interface{}) *Instruction

PUNPCKLDQ performs "Unpack and Interleave Low-Order Doublewords into Quadwords".

Mnemonic : PUNPCKLDQ Supported forms : (4 forms)

func (*Program) PUNPCKLQDQ 

func (self *Program) PUNPCKLQDQ(v0 interface{}, v1 interface{}) *Instruction

PUNPCKLQDQ performs "Unpack and Interleave Low-Order Quadwords into Double Quadwords".

Mnemonic : PUNPCKLQDQ Supported forms : (2 forms)

func (*Program) PUNPCKLWD 

func (self *Program) PUNPCKLWD(v0 interface{}, v1 interface{}) *Instruction

PUNPCKLWD performs "Unpack and Interleave Low-Order Words into Doublewords".

Mnemonic : PUNPCKLWD Supported forms : (4 forms)

func (*Program) PUSHQ 

func (self *Program) PUSHQ(v0 interface{}) *Instruction

PUSHQ performs "Push Value Onto the Stack".

Mnemonic : PUSH Supported forms : (4 forms)

func (*Program) PUSHW 

func (self *Program) PUSHW(v0 interface{}) *Instruction

PUSHW performs "Push Value Onto the Stack".

Mnemonic : PUSH Supported forms : (2 forms)

func (*Program) PXOR 

func (self *Program) PXOR(v0 interface{}, v1 interface{}) *Instruction

PXOR performs "Packed Bitwise Logical Exclusive OR".

Mnemonic : PXOR Supported forms : (4 forms)

func (*Program) Quad 

func (self *Program) Quad(v *expr.Expr) (p *Instruction)

Quad is a pseudo-instruction to add raw uint64 as little-endian to the assembled code.

func (*Program) RCLB 

func (self *Program) RCLB(v0 interface{}, v1 interface{}) *Instruction

RCLB performs "Rotate Left through Carry Flag".

Mnemonic : RCL Supported forms : (6 forms)

func (*Program) RCLL 

func (self *Program) RCLL(v0 interface{}, v1 interface{}) *Instruction

RCLL performs "Rotate Left through Carry Flag".

Mnemonic : RCL Supported forms : (6 forms)

func (*Program) RCLQ 

func (self *Program) RCLQ(v0 interface{}, v1 interface{}) *Instruction

RCLQ performs "Rotate Left through Carry Flag".

Mnemonic : RCL Supported forms : (6 forms)

func (*Program) RCLW 

func (self *Program) RCLW(v0 interface{}, v1 interface{}) *Instruction

RCLW performs "Rotate Left through Carry Flag".

Mnemonic : RCL Supported forms : (6 forms)

func (*Program) RCPPS 

func (self *Program) RCPPS(v0 interface{}, v1 interface{}) *Instruction

RCPPS performs "Compute Approximate Reciprocals of Packed Single-Precision Floating-Point Values".

Mnemonic : RCPPS Supported forms : (2 forms)

func (*Program) RCPSS 

func (self *Program) RCPSS(v0 interface{}, v1 interface{}) *Instruction

RCPSS performs "Compute Approximate Reciprocal of Scalar Single-Precision Floating-Point Values".

Mnemonic : RCPSS Supported forms : (2 forms)

func (*Program) RCRB 

func (self *Program) RCRB(v0 interface{}, v1 interface{}) *Instruction

RCRB performs "Rotate Right through Carry Flag".

Mnemonic : RCR Supported forms : (6 forms)

func (*Program) RCRL 

func (self *Program) RCRL(v0 interface{}, v1 interface{}) *Instruction

RCRL performs "Rotate Right through Carry Flag".

Mnemonic : RCR Supported forms : (6 forms)

func (*Program) RCRQ 

func (self *Program) RCRQ(v0 interface{}, v1 interface{}) *Instruction

RCRQ performs "Rotate Right through Carry Flag".

Mnemonic : RCR Supported forms : (6 forms)

func (*Program) RCRW 

func (self *Program) RCRW(v0 interface{}, v1 interface{}) *Instruction

RCRW performs "Rotate Right through Carry Flag".

Mnemonic : RCR Supported forms : (6 forms)

func (*Program) RDRAND 

func (self *Program) RDRAND(v0 interface{}) *Instruction

RDRAND performs "Read Random Number".

Mnemonic : RDRAND Supported forms : (3 forms)

func (*Program) RDSEED 

func (self *Program) RDSEED(v0 interface{}) *Instruction

RDSEED performs "Read Random SEED".

Mnemonic : RDSEED Supported forms : (3 forms)

func (*Program) RDTSC 

func (self *Program) RDTSC() *Instruction

RDTSC performs "Read Time-Stamp Counter".

Mnemonic : RDTSC Supported forms : (1 form)

func (*Program) RDTSCP 

func (self *Program) RDTSCP() *Instruction

RDTSCP performs "Read Time-Stamp Counter and Processor ID".

Mnemonic : RDTSCP Supported forms : (1 form)

func (*Program) RET 

func (self *Program) RET(vv ...interface{}) *Instruction

RET performs "Return from Procedure".

Mnemonic : RET Supported forms : (2 forms)

func (*Program) ROLB 

func (self *Program) ROLB(v0 interface{}, v1 interface{}) *Instruction

ROLB performs "Rotate Left".

Mnemonic : ROL Supported forms : (6 forms)

func (*Program) ROLL 

func (self *Program) ROLL(v0 interface{}, v1 interface{}) *Instruction

ROLL performs "Rotate Left".

Mnemonic : ROL Supported forms : (6 forms)

func (*Program) ROLQ 

func (self *Program) ROLQ(v0 interface{}, v1 interface{}) *Instruction

ROLQ performs "Rotate Left".

Mnemonic : ROL Supported forms : (6 forms)

func (*Program) ROLW 

func (self *Program) ROLW(v0 interface{}, v1 interface{}) *Instruction

ROLW performs "Rotate Left".

Mnemonic : ROL Supported forms : (6 forms)

func (*Program) RORB 

func (self *Program) RORB(v0 interface{}, v1 interface{}) *Instruction

RORB performs "Rotate Right".

Mnemonic : ROR Supported forms : (6 forms)

func (*Program) RORL 

func (self *Program) RORL(v0 interface{}, v1 interface{}) *Instruction

RORL performs "Rotate Right".

Mnemonic : ROR Supported forms : (6 forms)

func (*Program) RORQ 

func (self *Program) RORQ(v0 interface{}, v1 interface{}) *Instruction

RORQ performs "Rotate Right".

Mnemonic : ROR Supported forms : (6 forms)

func (*Program) RORW 

func (self *Program) RORW(v0 interface{}, v1 interface{}) *Instruction

RORW performs "Rotate Right".

Mnemonic : ROR Supported forms : (6 forms)

func (*Program) RORXL 

func (self *Program) RORXL(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

RORXL performs "Rotate Right Logical Without Affecting Flags".

Mnemonic : RORX Supported forms : (2 forms)

func (*Program) RORXQ 

func (self *Program) RORXQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

RORXQ performs "Rotate Right Logical Without Affecting Flags".

Mnemonic : RORX Supported forms : (2 forms)

func (*Program) ROUNDPD 

func (self *Program) ROUNDPD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

ROUNDPD performs "Round Packed Double Precision Floating-Point Values".

Mnemonic : ROUNDPD Supported forms : (2 forms)

func (*Program) ROUNDPS 

func (self *Program) ROUNDPS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

ROUNDPS performs "Round Packed Single Precision Floating-Point Values".

Mnemonic : ROUNDPS Supported forms : (2 forms)

func (*Program) ROUNDSD 

func (self *Program) ROUNDSD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

ROUNDSD performs "Round Scalar Double Precision Floating-Point Values".

Mnemonic : ROUNDSD Supported forms : (2 forms)

func (*Program) ROUNDSS 

func (self *Program) ROUNDSS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

ROUNDSS performs "Round Scalar Single Precision Floating-Point Values".

Mnemonic : ROUNDSS Supported forms : (2 forms)

func (*Program) RSQRTPS 

func (self *Program) RSQRTPS(v0 interface{}, v1 interface{}) *Instruction

RSQRTPS performs "Compute Reciprocals of Square Roots of Packed Single-Precision Floating-Point Values".

Mnemonic : RSQRTPS Supported forms : (2 forms)

func (*Program) RSQRTSS 

func (self *Program) RSQRTSS(v0 interface{}, v1 interface{}) *Instruction

RSQRTSS performs "Compute Reciprocal of Square Root of Scalar Single-Precision Floating-Point Value".

Mnemonic : RSQRTSS Supported forms : (2 forms)

func (*Program) SALB 

func (self *Program) SALB(v0 interface{}, v1 interface{}) *Instruction

SALB performs "Arithmetic Shift Left".

Mnemonic : SAL Supported forms : (6 forms)

func (*Program) SALL 

func (self *Program) SALL(v0 interface{}, v1 interface{}) *Instruction

SALL performs "Arithmetic Shift Left".

Mnemonic : SAL Supported forms : (6 forms)

func (*Program) SALQ 

func (self *Program) SALQ(v0 interface{}, v1 interface{}) *Instruction

SALQ performs "Arithmetic Shift Left".

Mnemonic : SAL Supported forms : (6 forms)

func (*Program) SALW 

func (self *Program) SALW(v0 interface{}, v1 interface{}) *Instruction

SALW performs "Arithmetic Shift Left".

Mnemonic : SAL Supported forms : (6 forms)

func (*Program) SARB 

func (self *Program) SARB(v0 interface{}, v1 interface{}) *Instruction

SARB performs "Arithmetic Shift Right".

Mnemonic : SAR Supported forms : (6 forms)

func (*Program) SARL 

func (self *Program) SARL(v0 interface{}, v1 interface{}) *Instruction

SARL performs "Arithmetic Shift Right".

Mnemonic : SAR Supported forms : (6 forms)

func (*Program) SARQ 

func (self *Program) SARQ(v0 interface{}, v1 interface{}) *Instruction

SARQ performs "Arithmetic Shift Right".

Mnemonic : SAR Supported forms : (6 forms)

func (*Program) SARW 

func (self *Program) SARW(v0 interface{}, v1 interface{}) *Instruction

SARW performs "Arithmetic Shift Right".

Mnemonic : SAR Supported forms : (6 forms)

func (*Program) SARXL 

func (self *Program) SARXL(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

SARXL performs "Arithmetic Shift Right Without Affecting Flags".

Mnemonic : SARX Supported forms : (2 forms)

func (*Program) SARXQ 

func (self *Program) SARXQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

SARXQ performs "Arithmetic Shift Right Without Affecting Flags".

Mnemonic : SARX Supported forms : (2 forms)

func (*Program) SBBB 

func (self *Program) SBBB(v0 interface{}, v1 interface{}) *Instruction

SBBB performs "Subtract with Borrow".

Mnemonic : SBB Supported forms : (6 forms)

func (*Program) SBBL 

func (self *Program) SBBL(v0 interface{}, v1 interface{}) *Instruction

SBBL performs "Subtract with Borrow".

Mnemonic : SBB Supported forms : (8 forms)

func (*Program) SBBQ 

func (self *Program) SBBQ(v0 interface{}, v1 interface{}) *Instruction

SBBQ performs "Subtract with Borrow".

Mnemonic : SBB Supported forms : (8 forms)

func (*Program) SBBW 

func (self *Program) SBBW(v0 interface{}, v1 interface{}) *Instruction

SBBW performs "Subtract with Borrow".

Mnemonic : SBB Supported forms : (8 forms)

func (*Program) SETA 

func (self *Program) SETA(v0 interface{}) *Instruction

SETA performs "Set byte if above (CF == 0 and ZF == 0)".

Mnemonic : SETA Supported forms : (2 forms)

func (*Program) SETAE 

func (self *Program) SETAE(v0 interface{}) *Instruction

SETAE performs "Set byte if above or equal (CF == 0)".

Mnemonic : SETAE Supported forms : (2 forms)

func (*Program) SETB 

func (self *Program) SETB(v0 interface{}) *Instruction

SETB performs "Set byte if below (CF == 1)".

Mnemonic : SETB Supported forms : (2 forms)

func (*Program) SETBE 

func (self *Program) SETBE(v0 interface{}) *Instruction

SETBE performs "Set byte if below or equal (CF == 1 or ZF == 1)".

Mnemonic : SETBE Supported forms : (2 forms)

func (*Program) SETC 

func (self *Program) SETC(v0 interface{}) *Instruction

SETC performs "Set byte if carry (CF == 1)".

Mnemonic : SETC Supported forms : (2 forms)

func (*Program) SETE 

func (self *Program) SETE(v0 interface{}) *Instruction

SETE performs "Set byte if equal (ZF == 1)".

Mnemonic : SETE Supported forms : (2 forms)

func (*Program) SETG 

func (self *Program) SETG(v0 interface{}) *Instruction

SETG performs "Set byte if greater (ZF == 0 and SF == OF)".

Mnemonic : SETG Supported forms : (2 forms)

func (*Program) SETGE 

func (self *Program) SETGE(v0 interface{}) *Instruction

SETGE performs "Set byte if greater or equal (SF == OF)".

Mnemonic : SETGE Supported forms : (2 forms)

func (*Program) SETL 

func (self *Program) SETL(v0 interface{}) *Instruction

SETL performs "Set byte if less (SF != OF)".

Mnemonic : SETL Supported forms : (2 forms)

func (*Program) SETLE 

func (self *Program) SETLE(v0 interface{}) *Instruction

SETLE performs "Set byte if less or equal (ZF == 1 or SF != OF)".

Mnemonic : SETLE Supported forms : (2 forms)

func (*Program) SETNA 

func (self *Program) SETNA(v0 interface{}) *Instruction

SETNA performs "Set byte if not above (CF == 1 or ZF == 1)".

Mnemonic : SETNA Supported forms : (2 forms)

func (*Program) SETNAE 

func (self *Program) SETNAE(v0 interface{}) *Instruction

SETNAE performs "Set byte if not above or equal (CF == 1)".

Mnemonic : SETNAE Supported forms : (2 forms)

func (*Program) SETNB 

func (self *Program) SETNB(v0 interface{}) *Instruction

SETNB performs "Set byte if not below (CF == 0)".

Mnemonic : SETNB Supported forms : (2 forms)

func (*Program) SETNBE 

func (self *Program) SETNBE(v0 interface{}) *Instruction

SETNBE performs "Set byte if not below or equal (CF == 0 and ZF == 0)".

Mnemonic : SETNBE Supported forms : (2 forms)

func (*Program) SETNC 

func (self *Program) SETNC(v0 interface{}) *Instruction

SETNC performs "Set byte if not carry (CF == 0)".

Mnemonic : SETNC Supported forms : (2 forms)

func (*Program) SETNE 

func (self *Program) SETNE(v0 interface{}) *Instruction

SETNE performs "Set byte if not equal (ZF == 0)".

Mnemonic : SETNE Supported forms : (2 forms)

func (*Program) SETNG 

func (self *Program) SETNG(v0 interface{}) *Instruction

SETNG performs "Set byte if not greater (ZF == 1 or SF != OF)".

Mnemonic : SETNG Supported forms : (2 forms)

func (*Program) SETNGE 

func (self *Program) SETNGE(v0 interface{}) *Instruction

SETNGE performs "Set byte if not greater or equal (SF != OF)".

Mnemonic : SETNGE Supported forms : (2 forms)

func (*Program) SETNL 

func (self *Program) SETNL(v0 interface{}) *Instruction

SETNL performs "Set byte if not less (SF == OF)".

Mnemonic : SETNL Supported forms : (2 forms)

func (*Program) SETNLE 

func (self *Program) SETNLE(v0 interface{}) *Instruction

SETNLE performs "Set byte if not less or equal (ZF == 0 and SF == OF)".

Mnemonic : SETNLE Supported forms : (2 forms)

func (*Program) SETNO 

func (self *Program) SETNO(v0 interface{}) *Instruction

SETNO performs "Set byte if not overflow (OF == 0)".

Mnemonic : SETNO Supported forms : (2 forms)

func (*Program) SETNP 

func (self *Program) SETNP(v0 interface{}) *Instruction

SETNP performs "Set byte if not parity (PF == 0)".

Mnemonic : SETNP Supported forms : (2 forms)

func (*Program) SETNS 

func (self *Program) SETNS(v0 interface{}) *Instruction

SETNS performs "Set byte if not sign (SF == 0)".

Mnemonic : SETNS Supported forms : (2 forms)

func (*Program) SETNZ 

func (self *Program) SETNZ(v0 interface{}) *Instruction

SETNZ performs "Set byte if not zero (ZF == 0)".

Mnemonic : SETNZ Supported forms : (2 forms)

func (*Program) SETO 

func (self *Program) SETO(v0 interface{}) *Instruction

SETO performs "Set byte if overflow (OF == 1)".

Mnemonic : SETO Supported forms : (2 forms)

func (*Program) SETP 

func (self *Program) SETP(v0 interface{}) *Instruction

SETP performs "Set byte if parity (PF == 1)".

Mnemonic : SETP Supported forms : (2 forms)

func (*Program) SETPE 

func (self *Program) SETPE(v0 interface{}) *Instruction

SETPE performs "Set byte if parity even (PF == 1)".

Mnemonic : SETPE Supported forms : (2 forms)

func (*Program) SETPO 

func (self *Program) SETPO(v0 interface{}) *Instruction

SETPO performs "Set byte if parity odd (PF == 0)".

Mnemonic : SETPO Supported forms : (2 forms)

func (*Program) SETS 

func (self *Program) SETS(v0 interface{}) *Instruction

SETS performs "Set byte if sign (SF == 1)".

Mnemonic : SETS Supported forms : (2 forms)

func (*Program) SETZ 

func (self *Program) SETZ(v0 interface{}) *Instruction

SETZ performs "Set byte if zero (ZF == 1)".

Mnemonic : SETZ Supported forms : (2 forms)

func (*Program) SFENCE 

func (self *Program) SFENCE() *Instruction

SFENCE performs "Store Fence".

Mnemonic : SFENCE Supported forms : (1 form)

func (*Program) SHA1MSG1 

func (self *Program) SHA1MSG1(v0 interface{}, v1 interface{}) *Instruction

SHA1MSG1 performs "Perform an Intermediate Calculation for the Next Four SHA1 Message Doublewords".

Mnemonic : SHA1MSG1 Supported forms : (2 forms)

func (*Program) SHA1MSG2 

func (self *Program) SHA1MSG2(v0 interface{}, v1 interface{}) *Instruction

SHA1MSG2 performs "Perform a Final Calculation for the Next Four SHA1 Message Doublewords".

Mnemonic : SHA1MSG2 Supported forms : (2 forms)

func (*Program) SHA1NEXTE 

func (self *Program) SHA1NEXTE(v0 interface{}, v1 interface{}) *Instruction

SHA1NEXTE performs "Calculate SHA1 State Variable E after Four Rounds".

Mnemonic : SHA1NEXTE Supported forms : (2 forms)

func (*Program) SHA1RNDS4 

func (self *Program) SHA1RNDS4(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

SHA1RNDS4 performs "Perform Four Rounds of SHA1 Operation".

Mnemonic : SHA1RNDS4 Supported forms : (2 forms)

func (*Program) SHA256MSG1 

func (self *Program) SHA256MSG1(v0 interface{}, v1 interface{}) *Instruction

SHA256MSG1 performs "Perform an Intermediate Calculation for the Next Four SHA256 Message Doublewords".

Mnemonic : SHA256MSG1 Supported forms : (2 forms)

func (*Program) SHA256MSG2 

func (self *Program) SHA256MSG2(v0 interface{}, v1 interface{}) *Instruction

SHA256MSG2 performs "Perform a Final Calculation for the Next Four SHA256 Message Doublewords".

Mnemonic : SHA256MSG2 Supported forms : (2 forms)

func (*Program) SHA256RNDS2 

func (self *Program) SHA256RNDS2(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

SHA256RNDS2 performs "Perform Two Rounds of SHA256 Operation".

Mnemonic : SHA256RNDS2 Supported forms : (2 forms)

func (*Program) SHLB 

func (self *Program) SHLB(v0 interface{}, v1 interface{}) *Instruction

SHLB performs "Logical Shift Left".

Mnemonic : SHL Supported forms : (6 forms)

func (*Program) SHLDL 

func (self *Program) SHLDL(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

SHLDL performs "Integer Double Precision Shift Left".

Mnemonic : SHLD Supported forms : (4 forms)

func (*Program) SHLDQ 

func (self *Program) SHLDQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

SHLDQ performs "Integer Double Precision Shift Left".

Mnemonic : SHLD Supported forms : (4 forms)

func (*Program) SHLDW 

func (self *Program) SHLDW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

SHLDW performs "Integer Double Precision Shift Left".

Mnemonic : SHLD Supported forms : (4 forms)

func (*Program) SHLL 

func (self *Program) SHLL(v0 interface{}, v1 interface{}) *Instruction

SHLL performs "Logical Shift Left".

Mnemonic : SHL Supported forms : (6 forms)

func (*Program) SHLQ 

func (self *Program) SHLQ(v0 interface{}, v1 interface{}) *Instruction

SHLQ performs "Logical Shift Left".

Mnemonic : SHL Supported forms : (6 forms)

func (*Program) SHLW 

func (self *Program) SHLW(v0 interface{}, v1 interface{}) *Instruction

SHLW performs "Logical Shift Left".

Mnemonic : SHL Supported forms : (6 forms)

func (*Program) SHLXL 

func (self *Program) SHLXL(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

SHLXL performs "Logical Shift Left Without Affecting Flags".

Mnemonic : SHLX Supported forms : (2 forms)

func (*Program) SHLXQ 

func (self *Program) SHLXQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

SHLXQ performs "Logical Shift Left Without Affecting Flags".

Mnemonic : SHLX Supported forms : (2 forms)

func (*Program) SHRB 

func (self *Program) SHRB(v0 interface{}, v1 interface{}) *Instruction

SHRB performs "Logical Shift Right".

Mnemonic : SHR Supported forms : (6 forms)

func (*Program) SHRDL 

func (self *Program) SHRDL(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

SHRDL performs "Integer Double Precision Shift Right".

Mnemonic : SHRD Supported forms : (4 forms)

func (*Program) SHRDQ 

func (self *Program) SHRDQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

SHRDQ performs "Integer Double Precision Shift Right".

Mnemonic : SHRD Supported forms : (4 forms)

func (*Program) SHRDW 

func (self *Program) SHRDW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

SHRDW performs "Integer Double Precision Shift Right".

Mnemonic : SHRD Supported forms : (4 forms)

func (*Program) SHRL 

func (self *Program) SHRL(v0 interface{}, v1 interface{}) *Instruction

SHRL performs "Logical Shift Right".

Mnemonic : SHR Supported forms : (6 forms)

func (*Program) SHRQ 

func (self *Program) SHRQ(v0 interface{}, v1 interface{}) *Instruction

SHRQ performs "Logical Shift Right".

Mnemonic : SHR Supported forms : (6 forms)

func (*Program) SHRW 

func (self *Program) SHRW(v0 interface{}, v1 interface{}) *Instruction

SHRW performs "Logical Shift Right".

Mnemonic : SHR Supported forms : (6 forms)

func (*Program) SHRXL 

func (self *Program) SHRXL(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

SHRXL performs "Logical Shift Right Without Affecting Flags".

Mnemonic : SHRX Supported forms : (2 forms)

func (*Program) SHRXQ 

func (self *Program) SHRXQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

SHRXQ performs "Logical Shift Right Without Affecting Flags".

Mnemonic : SHRX Supported forms : (2 forms)

func (*Program) SHUFPD 

func (self *Program) SHUFPD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

SHUFPD performs "Shuffle Packed Double-Precision Floating-Point Values".

Mnemonic : SHUFPD Supported forms : (2 forms)

func (*Program) SHUFPS 

func (self *Program) SHUFPS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

SHUFPS performs "Shuffle Packed Single-Precision Floating-Point Values".

Mnemonic : SHUFPS Supported forms : (2 forms)

func (*Program) SQRTPD 

func (self *Program) SQRTPD(v0 interface{}, v1 interface{}) *Instruction

SQRTPD performs "Compute Square Roots of Packed Double-Precision Floating-Point Values".

Mnemonic : SQRTPD Supported forms : (2 forms)

func (*Program) SQRTPS 

func (self *Program) SQRTPS(v0 interface{}, v1 interface{}) *Instruction

SQRTPS performs "Compute Square Roots of Packed Single-Precision Floating-Point Values".

Mnemonic : SQRTPS Supported forms : (2 forms)

func (*Program) SQRTSD 

func (self *Program) SQRTSD(v0 interface{}, v1 interface{}) *Instruction

SQRTSD performs "Compute Square Root of Scalar Double-Precision Floating-Point Value".

Mnemonic : SQRTSD Supported forms : (2 forms)

func (*Program) SQRTSS 

func (self *Program) SQRTSS(v0 interface{}, v1 interface{}) *Instruction

SQRTSS performs "Compute Square Root of Scalar Single-Precision Floating-Point Value".

Mnemonic : SQRTSS Supported forms : (2 forms)

func (*Program) STC 

func (self *Program) STC() *Instruction

STC performs "Set Carry Flag".

Mnemonic : STC Supported forms : (1 form)

func (*Program) STD 

func (self *Program) STD() *Instruction

STD performs "Set Direction Flag".

Mnemonic : STD Supported forms : (1 form)

func (*Program) STMXCSR 

func (self *Program) STMXCSR(v0 interface{}) *Instruction

STMXCSR performs "Store MXCSR Register State".

Mnemonic : STMXCSR Supported forms : (1 form)

func (*Program) SUBB 

func (self *Program) SUBB(v0 interface{}, v1 interface{}) *Instruction

SUBB performs "Subtract".

Mnemonic : SUB Supported forms : (6 forms)

func (*Program) SUBL 

func (self *Program) SUBL(v0 interface{}, v1 interface{}) *Instruction

SUBL performs "Subtract".

Mnemonic : SUB Supported forms : (8 forms)

func (*Program) SUBPD 

func (self *Program) SUBPD(v0 interface{}, v1 interface{}) *Instruction

SUBPD performs "Subtract Packed Double-Precision Floating-Point Values".

Mnemonic : SUBPD Supported forms : (2 forms)

func (*Program) SUBPS 

func (self *Program) SUBPS(v0 interface{}, v1 interface{}) *Instruction

SUBPS performs "Subtract Packed Single-Precision Floating-Point Values".

Mnemonic : SUBPS Supported forms : (2 forms)

func (*Program) SUBQ 

func (self *Program) SUBQ(v0 interface{}, v1 interface{}) *Instruction

SUBQ performs "Subtract".

Mnemonic : SUB Supported forms : (8 forms)

func (*Program) SUBSD 

func (self *Program) SUBSD(v0 interface{}, v1 interface{}) *Instruction

SUBSD performs "Subtract Scalar Double-Precision Floating-Point Values".

Mnemonic : SUBSD Supported forms : (2 forms)

func (*Program) SUBSS 

func (self *Program) SUBSS(v0 interface{}, v1 interface{}) *Instruction

SUBSS performs "Subtract Scalar Single-Precision Floating-Point Values".

Mnemonic : SUBSS Supported forms : (2 forms)

func (*Program) SUBW 

func (self *Program) SUBW(v0 interface{}, v1 interface{}) *Instruction

SUBW performs "Subtract".

Mnemonic : SUB Supported forms : (8 forms)

func (*Program) SYSCALL 

func (self *Program) SYSCALL() *Instruction

SYSCALL performs "Fast System Call".

Mnemonic : SYSCALL Supported forms : (1 form)

func (*Program) T1MSKC 

func (self *Program) T1MSKC(v0 interface{}, v1 interface{}) *Instruction

T1MSKC performs "Inverse Mask From Trailing Ones".

Mnemonic : T1MSKC Supported forms : (4 forms)

func (*Program) TESTB 

func (self *Program) TESTB(v0 interface{}, v1 interface{}) *Instruction

TESTB performs "Logical Compare".

Mnemonic : TEST Supported forms : (5 forms)

func (*Program) TESTL 

func (self *Program) TESTL(v0 interface{}, v1 interface{}) *Instruction

TESTL performs "Logical Compare".

Mnemonic : TEST Supported forms : (5 forms)

func (*Program) TESTQ 

func (self *Program) TESTQ(v0 interface{}, v1 interface{}) *Instruction

TESTQ performs "Logical Compare".

Mnemonic : TEST Supported forms : (5 forms)

func (*Program) TESTW 

func (self *Program) TESTW(v0 interface{}, v1 interface{}) *Instruction

TESTW performs "Logical Compare".

Mnemonic : TEST Supported forms : (5 forms)

func (*Program) TZCNTL 

func (self *Program) TZCNTL(v0 interface{}, v1 interface{}) *Instruction

TZCNTL performs "Count the Number of Trailing Zero Bits".

Mnemonic : TZCNT Supported forms : (2 forms)

func (*Program) TZCNTQ 

func (self *Program) TZCNTQ(v0 interface{}, v1 interface{}) *Instruction

TZCNTQ performs "Count the Number of Trailing Zero Bits".

Mnemonic : TZCNT Supported forms : (2 forms)

func (*Program) TZCNTW 

func (self *Program) TZCNTW(v0 interface{}, v1 interface{}) *Instruction

TZCNTW performs "Count the Number of Trailing Zero Bits".

Mnemonic : TZCNT Supported forms : (2 forms)

func (*Program) TZMSK 

func (self *Program) TZMSK(v0 interface{}, v1 interface{}) *Instruction

TZMSK performs "Mask From Trailing Zeros".

Mnemonic : TZMSK Supported forms : (4 forms)

func (*Program) UCOMISD 

func (self *Program) UCOMISD(v0 interface{}, v1 interface{}) *Instruction

UCOMISD performs "Unordered Compare Scalar Double-Precision Floating-Point Values and Set EFLAGS".

Mnemonic : UCOMISD Supported forms : (2 forms)

func (*Program) UCOMISS 

func (self *Program) UCOMISS(v0 interface{}, v1 interface{}) *Instruction

UCOMISS performs "Unordered Compare Scalar Single-Precision Floating-Point Values and Set EFLAGS".

Mnemonic : UCOMISS Supported forms : (2 forms)

func (*Program) UD2 

func (self *Program) UD2() *Instruction

UD2 performs "Undefined Instruction".

Mnemonic : UD2 Supported forms : (1 form)

func (*Program) UNPCKHPD 

func (self *Program) UNPCKHPD(v0 interface{}, v1 interface{}) *Instruction

UNPCKHPD performs "Unpack and Interleave High Packed Double-Precision Floating-Point Values".

Mnemonic : UNPCKHPD Supported forms : (2 forms)

func (*Program) UNPCKHPS 

func (self *Program) UNPCKHPS(v0 interface{}, v1 interface{}) *Instruction

UNPCKHPS performs "Unpack and Interleave High Packed Single-Precision Floating-Point Values".

Mnemonic : UNPCKHPS Supported forms : (2 forms)

func (*Program) UNPCKLPD 

func (self *Program) UNPCKLPD(v0 interface{}, v1 interface{}) *Instruction

UNPCKLPD performs "Unpack and Interleave Low Packed Double-Precision Floating-Point Values".

Mnemonic : UNPCKLPD Supported forms : (2 forms)

func (*Program) UNPCKLPS 

func (self *Program) UNPCKLPS(v0 interface{}, v1 interface{}) *Instruction

UNPCKLPS performs "Unpack and Interleave Low Packed Single-Precision Floating-Point Values".

Mnemonic : UNPCKLPS Supported forms : (2 forms)

func (*Program) VADDPD 

func (self *Program) VADDPD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VADDPD performs "Add Packed Double-Precision Floating-Point Values".

Mnemonic : VADDPD Supported forms : (11 forms)

func (*Program) VADDPS 

func (self *Program) VADDPS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VADDPS performs "Add Packed Single-Precision Floating-Point Values".

Mnemonic : VADDPS Supported forms : (11 forms)

func (*Program) VADDSD 

func (self *Program) VADDSD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VADDSD performs "Add Scalar Double-Precision Floating-Point Values".

Mnemonic : VADDSD Supported forms : (5 forms)

func (*Program) VADDSS 

func (self *Program) VADDSS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VADDSS performs "Add Scalar Single-Precision Floating-Point Values".

Mnemonic : VADDSS Supported forms : (5 forms)

func (*Program) VADDSUBPD 

func (self *Program) VADDSUBPD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VADDSUBPD performs "Packed Double-FP Add/Subtract".

Mnemonic : VADDSUBPD Supported forms : (4 forms)

func (*Program) VADDSUBPS 

func (self *Program) VADDSUBPS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VADDSUBPS performs "Packed Single-FP Add/Subtract".

Mnemonic : VADDSUBPS Supported forms : (4 forms)

func (*Program) VAESDEC 

func (self *Program) VAESDEC(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VAESDEC performs "Perform One Round of an AES Decryption Flow".

Mnemonic : VAESDEC Supported forms : (2 forms)

func (*Program) VAESDECLAST 

func (self *Program) VAESDECLAST(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VAESDECLAST performs "Perform Last Round of an AES Decryption Flow".

Mnemonic : VAESDECLAST Supported forms : (2 forms)

func (*Program) VAESENC 

func (self *Program) VAESENC(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VAESENC performs "Perform One Round of an AES Encryption Flow".

Mnemonic : VAESENC Supported forms : (2 forms)

func (*Program) VAESENCLAST 

func (self *Program) VAESENCLAST(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VAESENCLAST performs "Perform Last Round of an AES Encryption Flow".

Mnemonic : VAESENCLAST Supported forms : (2 forms)

func (*Program) VAESIMC 

func (self *Program) VAESIMC(v0 interface{}, v1 interface{}) *Instruction

VAESIMC performs "Perform the AES InvMixColumn Transformation".

Mnemonic : VAESIMC Supported forms : (2 forms)

func (*Program) VAESKEYGENASSIST 

func (self *Program) VAESKEYGENASSIST(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VAESKEYGENASSIST performs "AES Round Key Generation Assist".

Mnemonic : VAESKEYGENASSIST Supported forms : (2 forms)

func (*Program) VALIGND 

func (self *Program) VALIGND(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VALIGND performs "Align Doubleword Vectors".

Mnemonic : VALIGND Supported forms : (6 forms)

func (*Program) VALIGNQ 

func (self *Program) VALIGNQ(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VALIGNQ performs "Align Quadword Vectors".

Mnemonic : VALIGNQ Supported forms : (6 forms)

func (*Program) VANDNPD 

func (self *Program) VANDNPD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VANDNPD performs "Bitwise Logical AND NOT of Packed Double-Precision Floating-Point Values".

Mnemonic : VANDNPD Supported forms : (10 forms)

func (*Program) VANDNPS 

func (self *Program) VANDNPS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VANDNPS performs "Bitwise Logical AND NOT of Packed Single-Precision Floating-Point Values".

Mnemonic : VANDNPS Supported forms : (10 forms)

func (*Program) VANDPD 

func (self *Program) VANDPD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VANDPD performs "Bitwise Logical AND of Packed Double-Precision Floating-Point Values".

Mnemonic : VANDPD Supported forms : (10 forms)

func (*Program) VANDPS 

func (self *Program) VANDPS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VANDPS performs "Bitwise Logical AND of Packed Single-Precision Floating-Point Values".

Mnemonic : VANDPS Supported forms : (10 forms)

func (*Program) VBLENDMPD 

func (self *Program) VBLENDMPD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VBLENDMPD performs "Blend Packed Double-Precision Floating-Point Vectors Using an OpMask Control".

Mnemonic : VBLENDMPD Supported forms : (6 forms)

func (*Program) VBLENDMPS 

func (self *Program) VBLENDMPS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VBLENDMPS performs "Blend Packed Single-Precision Floating-Point Vectors Using an OpMask Control".

Mnemonic : VBLENDMPS Supported forms : (6 forms)

func (*Program) VBLENDPD 

func (self *Program) VBLENDPD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VBLENDPD performs "Blend Packed Double Precision Floating-Point Values".

Mnemonic : VBLENDPD Supported forms : (4 forms)

func (*Program) VBLENDPS 

func (self *Program) VBLENDPS(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VBLENDPS performs " Blend Packed Single Precision Floating-Point Values".

Mnemonic : VBLENDPS Supported forms : (4 forms)

func (*Program) VBLENDVPD 

func (self *Program) VBLENDVPD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VBLENDVPD performs " Variable Blend Packed Double Precision Floating-Point Values".

Mnemonic : VBLENDVPD Supported forms : (4 forms)

func (*Program) VBLENDVPS 

func (self *Program) VBLENDVPS(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VBLENDVPS performs " Variable Blend Packed Single Precision Floating-Point Values".

Mnemonic : VBLENDVPS Supported forms : (4 forms)

func (*Program) VBROADCASTF128 

func (self *Program) VBROADCASTF128(v0 interface{}, v1 interface{}) *Instruction

VBROADCASTF128 performs "Broadcast 128 Bit of Floating-Point Data".

Mnemonic : VBROADCASTF128 Supported forms : (1 form)

func (*Program) VBROADCASTF32X2 

func (self *Program) VBROADCASTF32X2(v0 interface{}, v1 interface{}) *Instruction

VBROADCASTF32X2 performs "Broadcast Two Single-Precision Floating-Point Elements".

Mnemonic : VBROADCASTF32X2 Supported forms : (4 forms)

func (*Program) VBROADCASTF32X4 

func (self *Program) VBROADCASTF32X4(v0 interface{}, v1 interface{}) *Instruction

VBROADCASTF32X4 performs "Broadcast Four Single-Precision Floating-Point Elements".

Mnemonic : VBROADCASTF32X4 Supported forms : (2 forms)

func (*Program) VBROADCASTF32X8 

func (self *Program) VBROADCASTF32X8(v0 interface{}, v1 interface{}) *Instruction

VBROADCASTF32X8 performs "Broadcast Eight Single-Precision Floating-Point Elements".

Mnemonic : VBROADCASTF32X8 Supported forms : (1 form)

func (*Program) VBROADCASTF64X2 

func (self *Program) VBROADCASTF64X2(v0 interface{}, v1 interface{}) *Instruction

VBROADCASTF64X2 performs "Broadcast Two Double-Precision Floating-Point Elements".

Mnemonic : VBROADCASTF64X2 Supported forms : (2 forms)

func (*Program) VBROADCASTF64X4 

func (self *Program) VBROADCASTF64X4(v0 interface{}, v1 interface{}) *Instruction

VBROADCASTF64X4 performs "Broadcast Four Double-Precision Floating-Point Elements".

Mnemonic : VBROADCASTF64X4 Supported forms : (1 form)

func (*Program) VBROADCASTI128 

func (self *Program) VBROADCASTI128(v0 interface{}, v1 interface{}) *Instruction

VBROADCASTI128 performs "Broadcast 128 Bits of Integer Data".

Mnemonic : VBROADCASTI128 Supported forms : (1 form)

func (*Program) VBROADCASTI32X2 

func (self *Program) VBROADCASTI32X2(v0 interface{}, v1 interface{}) *Instruction

VBROADCASTI32X2 performs "Broadcast Two Doubleword Elements".

Mnemonic : VBROADCASTI32X2 Supported forms : (6 forms)

func (*Program) VBROADCASTI32X4 

func (self *Program) VBROADCASTI32X4(v0 interface{}, v1 interface{}) *Instruction

VBROADCASTI32X4 performs "Broadcast Four Doubleword Elements".

Mnemonic : VBROADCASTI32X4 Supported forms : (2 forms)

func (*Program) VBROADCASTI32X8 

func (self *Program) VBROADCASTI32X8(v0 interface{}, v1 interface{}) *Instruction

VBROADCASTI32X8 performs "Broadcast Eight Doubleword Elements".

Mnemonic : VBROADCASTI32X8 Supported forms : (1 form)

func (*Program) VBROADCASTI64X2 

func (self *Program) VBROADCASTI64X2(v0 interface{}, v1 interface{}) *Instruction

VBROADCASTI64X2 performs "Broadcast Two Quadword Elements".

Mnemonic : VBROADCASTI64X2 Supported forms : (2 forms)

func (*Program) VBROADCASTI64X4 

func (self *Program) VBROADCASTI64X4(v0 interface{}, v1 interface{}) *Instruction

VBROADCASTI64X4 performs "Broadcast Four Quadword Elements".

Mnemonic : VBROADCASTI64X4 Supported forms : (1 form)

func (*Program) VBROADCASTSD 

func (self *Program) VBROADCASTSD(v0 interface{}, v1 interface{}) *Instruction

VBROADCASTSD performs "Broadcast Double-Precision Floating-Point Element".

Mnemonic : VBROADCASTSD Supported forms : (6 forms)

func (*Program) VBROADCASTSS 

func (self *Program) VBROADCASTSS(v0 interface{}, v1 interface{}) *Instruction

VBROADCASTSS performs "Broadcast Single-Precision Floating-Point Element".

Mnemonic : VBROADCASTSS Supported forms : (8 forms)

func (*Program) VCMPPD 

func (self *Program) VCMPPD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}, vv ...interface{}) *Instruction

VCMPPD performs "Compare Packed Double-Precision Floating-Point Values".

Mnemonic : VCMPPD Supported forms : (11 forms)

func (*Program) VCMPPS 

func (self *Program) VCMPPS(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}, vv ...interface{}) *Instruction

VCMPPS performs "Compare Packed Single-Precision Floating-Point Values".

Mnemonic : VCMPPS Supported forms : (11 forms)

func (*Program) VCMPSD 

func (self *Program) VCMPSD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}, vv ...interface{}) *Instruction

VCMPSD performs "Compare Scalar Double-Precision Floating-Point Values".

Mnemonic : VCMPSD Supported forms : (5 forms)

func (*Program) VCMPSS 

func (self *Program) VCMPSS(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}, vv ...interface{}) *Instruction

VCMPSS performs "Compare Scalar Single-Precision Floating-Point Values".

Mnemonic : VCMPSS Supported forms : (5 forms)

func (*Program) VCOMISD 

func (self *Program) VCOMISD(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction

VCOMISD performs "Compare Scalar Ordered Double-Precision Floating-Point Values and Set EFLAGS".

Mnemonic : VCOMISD Supported forms : (5 forms)

func (*Program) VCOMISS 

func (self *Program) VCOMISS(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction

VCOMISS performs "Compare Scalar Ordered Single-Precision Floating-Point Values and Set EFLAGS".

Mnemonic : VCOMISS Supported forms : (5 forms)

func (*Program) VCOMPRESSPD 

func (self *Program) VCOMPRESSPD(v0 interface{}, v1 interface{}) *Instruction

VCOMPRESSPD performs "Store Sparse Packed Double-Precision Floating-Point Values into Dense Memory/Register".

Mnemonic : VCOMPRESSPD Supported forms : (6 forms)

func (*Program) VCOMPRESSPS 

func (self *Program) VCOMPRESSPS(v0 interface{}, v1 interface{}) *Instruction

VCOMPRESSPS performs "Store Sparse Packed Single-Precision Floating-Point Values into Dense Memory/Register".

Mnemonic : VCOMPRESSPS Supported forms : (6 forms)

func (*Program) VCVTDQ2PD 

func (self *Program) VCVTDQ2PD(v0 interface{}, v1 interface{}) *Instruction

VCVTDQ2PD performs "Convert Packed Dword Integers to Packed Double-Precision FP Values".

Mnemonic : VCVTDQ2PD Supported forms : (10 forms)

func (*Program) VCVTDQ2PS 

func (self *Program) VCVTDQ2PS(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction

VCVTDQ2PS performs "Convert Packed Dword Integers to Packed Single-Precision FP Values".

Mnemonic : VCVTDQ2PS Supported forms : (11 forms)

func (*Program) VCVTPD2DQ 

func (self *Program) VCVTPD2DQ(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction

VCVTPD2DQ performs "Convert Packed Double-Precision FP Values to Packed Dword Integers".

Mnemonic : VCVTPD2DQ Supported forms : (11 forms)

func (*Program) VCVTPD2PS 

func (self *Program) VCVTPD2PS(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction

VCVTPD2PS performs "Convert Packed Double-Precision FP Values to Packed Single-Precision FP Values".

Mnemonic : VCVTPD2PS Supported forms : (11 forms)

func (*Program) VCVTPD2QQ 

func (self *Program) VCVTPD2QQ(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction

VCVTPD2QQ performs "Convert Packed Double-Precision Floating-Point Values to Packed Quadword Integers".

Mnemonic : VCVTPD2QQ Supported forms : (7 forms)

func (*Program) VCVTPD2UDQ 

func (self *Program) VCVTPD2UDQ(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction

VCVTPD2UDQ performs "Convert Packed Double-Precision Floating-Point Values to Packed Unsigned Doubleword Integers".

Mnemonic : VCVTPD2UDQ Supported forms : (7 forms)

func (*Program) VCVTPD2UQQ 

func (self *Program) VCVTPD2UQQ(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction

VCVTPD2UQQ performs "Convert Packed Double-Precision Floating-Point Values to Packed Unsigned Quadword Integers".

Mnemonic : VCVTPD2UQQ Supported forms : (7 forms)

func (*Program) VCVTPH2PS 

func (self *Program) VCVTPH2PS(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction

VCVTPH2PS performs "Convert Half-Precision FP Values to Single-Precision FP Values".

Mnemonic : VCVTPH2PS Supported forms : (11 forms)

func (*Program) VCVTPS2DQ 

func (self *Program) VCVTPS2DQ(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction

VCVTPS2DQ performs "Convert Packed Single-Precision FP Values to Packed Dword Integers".

Mnemonic : VCVTPS2DQ Supported forms : (11 forms)

func (*Program) VCVTPS2PD 

func (self *Program) VCVTPS2PD(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction

VCVTPS2PD performs "Convert Packed Single-Precision FP Values to Packed Double-Precision FP Values".

Mnemonic : VCVTPS2PD Supported forms : (11 forms)

func (*Program) VCVTPS2PH 

func (self *Program) VCVTPS2PH(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VCVTPS2PH performs "Convert Single-Precision FP value to Half-Precision FP value".

Mnemonic : VCVTPS2PH Supported forms : (11 forms)

func (*Program) VCVTPS2QQ 

func (self *Program) VCVTPS2QQ(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction

VCVTPS2QQ performs "Convert Packed Single Precision Floating-Point Values to Packed Singed Quadword Integer Values".

Mnemonic : VCVTPS2QQ Supported forms : (7 forms)

func (*Program) VCVTPS2UDQ 

func (self *Program) VCVTPS2UDQ(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction

VCVTPS2UDQ performs "Convert Packed Single-Precision Floating-Point Values to Packed Unsigned Doubleword Integer Values".

Mnemonic : VCVTPS2UDQ Supported forms : (7 forms)

func (*Program) VCVTPS2UQQ 

func (self *Program) VCVTPS2UQQ(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction

VCVTPS2UQQ performs "Convert Packed Single Precision Floating-Point Values to Packed Unsigned Quadword Integer Values".

Mnemonic : VCVTPS2UQQ Supported forms : (7 forms)

func (*Program) VCVTQQ2PD 

func (self *Program) VCVTQQ2PD(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction

VCVTQQ2PD performs "Convert Packed Quadword Integers to Packed Double-Precision Floating-Point Values".

Mnemonic : VCVTQQ2PD Supported forms : (7 forms)

func (*Program) VCVTQQ2PS 

func (self *Program) VCVTQQ2PS(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction

VCVTQQ2PS performs "Convert Packed Quadword Integers to Packed Single-Precision Floating-Point Values".

Mnemonic : VCVTQQ2PS Supported forms : (7 forms)

func (*Program) VCVTSD2SI 

func (self *Program) VCVTSD2SI(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction

VCVTSD2SI performs "Convert Scalar Double-Precision FP Value to Integer".

Mnemonic : VCVTSD2SI Supported forms : (10 forms)

func (*Program) VCVTSD2SS 

func (self *Program) VCVTSD2SS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VCVTSD2SS performs "Convert Scalar Double-Precision FP Value to Scalar Single-Precision FP Value".

Mnemonic : VCVTSD2SS Supported forms : (5 forms)

func (*Program) VCVTSD2USI 

func (self *Program) VCVTSD2USI(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction

VCVTSD2USI performs "Convert Scalar Double-Precision Floating-Point Value to Unsigned Doubleword Integer".

Mnemonic : VCVTSD2USI Supported forms : (6 forms)

func (*Program) VCVTSI2SD 

func (self *Program) VCVTSI2SD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VCVTSI2SD performs "Convert Dword Integer to Scalar Double-Precision FP Value".

Mnemonic : VCVTSI2SD Supported forms : (9 forms)

func (*Program) VCVTSI2SS 

func (self *Program) VCVTSI2SS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VCVTSI2SS performs "Convert Dword Integer to Scalar Single-Precision FP Value".

Mnemonic : VCVTSI2SS Supported forms : (10 forms)

func (*Program) VCVTSS2SD 

func (self *Program) VCVTSS2SD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VCVTSS2SD performs "Convert Scalar Single-Precision FP Value to Scalar Double-Precision FP Value".

Mnemonic : VCVTSS2SD Supported forms : (5 forms)

func (*Program) VCVTSS2SI 

func (self *Program) VCVTSS2SI(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction

VCVTSS2SI performs "Convert Scalar Single-Precision FP Value to Dword Integer".

Mnemonic : VCVTSS2SI Supported forms : (10 forms)

func (*Program) VCVTSS2USI 

func (self *Program) VCVTSS2USI(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction

VCVTSS2USI performs "Convert Scalar Single-Precision Floating-Point Value to Unsigned Doubleword Integer".

Mnemonic : VCVTSS2USI Supported forms : (6 forms)

func (*Program) VCVTTPD2DQ 

func (self *Program) VCVTTPD2DQ(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction

VCVTTPD2DQ performs "Convert with Truncation Packed Double-Precision FP Values to Packed Dword Integers".

Mnemonic : VCVTTPD2DQ Supported forms : (11 forms)

func (*Program) VCVTTPD2QQ 

func (self *Program) VCVTTPD2QQ(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction

VCVTTPD2QQ performs "Convert with Truncation Packed Double-Precision Floating-Point Values to Packed Quadword Integers".

Mnemonic : VCVTTPD2QQ Supported forms : (7 forms)

func (*Program) VCVTTPD2UDQ 

func (self *Program) VCVTTPD2UDQ(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction

VCVTTPD2UDQ performs "Convert with Truncation Packed Double-Precision Floating-Point Values to Packed Unsigned Doubleword Integers".

Mnemonic : VCVTTPD2UDQ Supported forms : (7 forms)

func (*Program) VCVTTPD2UQQ 

func (self *Program) VCVTTPD2UQQ(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction

VCVTTPD2UQQ performs "Convert with Truncation Packed Double-Precision Floating-Point Values to Packed Unsigned Quadword Integers".

Mnemonic : VCVTTPD2UQQ Supported forms : (7 forms)

func (*Program) VCVTTPS2DQ 

func (self *Program) VCVTTPS2DQ(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction

VCVTTPS2DQ performs "Convert with Truncation Packed Single-Precision FP Values to Packed Dword Integers".

Mnemonic : VCVTTPS2DQ Supported forms : (11 forms)

func (*Program) VCVTTPS2QQ 

func (self *Program) VCVTTPS2QQ(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction

VCVTTPS2QQ performs "Convert with Truncation Packed Single Precision Floating-Point Values to Packed Singed Quadword Integer Values".

Mnemonic : VCVTTPS2QQ Supported forms : (7 forms)

func (*Program) VCVTTPS2UDQ 

func (self *Program) VCVTTPS2UDQ(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction

VCVTTPS2UDQ performs "Convert with Truncation Packed Single-Precision Floating-Point Values to Packed Unsigned Doubleword Integer Values".

Mnemonic : VCVTTPS2UDQ Supported forms : (7 forms)

func (*Program) VCVTTPS2UQQ 

func (self *Program) VCVTTPS2UQQ(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction

VCVTTPS2UQQ performs "Convert with Truncation Packed Single Precision Floating-Point Values to Packed Unsigned Quadword Integer Values".

Mnemonic : VCVTTPS2UQQ Supported forms : (7 forms)

func (*Program) VCVTTSD2SI 

func (self *Program) VCVTTSD2SI(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction

VCVTTSD2SI performs "Convert with Truncation Scalar Double-Precision FP Value to Signed Integer".

Mnemonic : VCVTTSD2SI Supported forms : (10 forms)

func (*Program) VCVTTSD2USI 

func (self *Program) VCVTTSD2USI(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction

VCVTTSD2USI performs "Convert with Truncation Scalar Double-Precision Floating-Point Value to Unsigned Integer".

Mnemonic : VCVTTSD2USI Supported forms : (6 forms)

func (*Program) VCVTTSS2SI 

func (self *Program) VCVTTSS2SI(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction

VCVTTSS2SI performs "Convert with Truncation Scalar Single-Precision FP Value to Dword Integer".

Mnemonic : VCVTTSS2SI Supported forms : (10 forms)

func (*Program) VCVTTSS2USI 

func (self *Program) VCVTTSS2USI(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction

VCVTTSS2USI performs "Convert with Truncation Scalar Single-Precision Floating-Point Value to Unsigned Integer".

Mnemonic : VCVTTSS2USI Supported forms : (6 forms)

func (*Program) VCVTUDQ2PD 

func (self *Program) VCVTUDQ2PD(v0 interface{}, v1 interface{}) *Instruction

VCVTUDQ2PD performs "Convert Packed Unsigned Doubleword Integers to Packed Double-Precision Floating-Point Values".

Mnemonic : VCVTUDQ2PD Supported forms : (6 forms)

func (*Program) VCVTUDQ2PS 

func (self *Program) VCVTUDQ2PS(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction

VCVTUDQ2PS performs "Convert Packed Unsigned Doubleword Integers to Packed Single-Precision Floating-Point Values".

Mnemonic : VCVTUDQ2PS Supported forms : (7 forms)

func (*Program) VCVTUQQ2PD 

func (self *Program) VCVTUQQ2PD(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction

VCVTUQQ2PD performs "Convert Packed Unsigned Quadword Integers to Packed Double-Precision Floating-Point Values".

Mnemonic : VCVTUQQ2PD Supported forms : (7 forms)

func (*Program) VCVTUQQ2PS 

func (self *Program) VCVTUQQ2PS(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction

VCVTUQQ2PS performs "Convert Packed Unsigned Quadword Integers to Packed Single-Precision Floating-Point Values".

Mnemonic : VCVTUQQ2PS Supported forms : (7 forms)

func (*Program) VCVTUSI2SD 

func (self *Program) VCVTUSI2SD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VCVTUSI2SD performs "Convert Unsigned Integer to Scalar Double-Precision Floating-Point Value".

Mnemonic : VCVTUSI2SD Supported forms : (5 forms)

func (*Program) VCVTUSI2SS 

func (self *Program) VCVTUSI2SS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VCVTUSI2SS performs "Convert Unsigned Integer to Scalar Single-Precision Floating-Point Value".

Mnemonic : VCVTUSI2SS Supported forms : (6 forms)

func (*Program) VDBPSADBW 

func (self *Program) VDBPSADBW(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VDBPSADBW performs "Double Block Packed Sum-Absolute-Differences on Unsigned Bytes".

Mnemonic : VDBPSADBW Supported forms : (6 forms)

func (*Program) VDIVPD 

func (self *Program) VDIVPD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VDIVPD performs "Divide Packed Double-Precision Floating-Point Values".

Mnemonic : VDIVPD Supported forms : (11 forms)

func (*Program) VDIVPS 

func (self *Program) VDIVPS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VDIVPS performs "Divide Packed Single-Precision Floating-Point Values".

Mnemonic : VDIVPS Supported forms : (11 forms)

func (*Program) VDIVSD 

func (self *Program) VDIVSD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VDIVSD performs "Divide Scalar Double-Precision Floating-Point Values".

Mnemonic : VDIVSD Supported forms : (5 forms)

func (*Program) VDIVSS 

func (self *Program) VDIVSS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VDIVSS performs "Divide Scalar Single-Precision Floating-Point Values".

Mnemonic : VDIVSS Supported forms : (5 forms)

func (*Program) VDPPD 

func (self *Program) VDPPD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VDPPD performs "Dot Product of Packed Double Precision Floating-Point Values".

Mnemonic : VDPPD Supported forms : (2 forms)

func (*Program) VDPPS 

func (self *Program) VDPPS(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VDPPS performs "Dot Product of Packed Single Precision Floating-Point Values".

Mnemonic : VDPPS Supported forms : (4 forms)

func (*Program) VEXP2PD 

func (self *Program) VEXP2PD(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction

VEXP2PD performs "Approximation to the Exponential 2^x of Packed Double-Precision Floating-Point Values with Less Than 2^-23 Relative Error".

Mnemonic : VEXP2PD Supported forms : (3 forms)

func (*Program) VEXP2PS 

func (self *Program) VEXP2PS(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction

VEXP2PS performs "Approximation to the Exponential 2^x of Packed Single-Precision Floating-Point Values with Less Than 2^-23 Relative Error".

Mnemonic : VEXP2PS Supported forms : (3 forms)

func (*Program) VEXPANDPD 

func (self *Program) VEXPANDPD(v0 interface{}, v1 interface{}) *Instruction

VEXPANDPD performs "Load Sparse Packed Double-Precision Floating-Point Values from Dense Memory".

Mnemonic : VEXPANDPD Supported forms : (6 forms)

func (*Program) VEXPANDPS 

func (self *Program) VEXPANDPS(v0 interface{}, v1 interface{}) *Instruction

VEXPANDPS performs "Load Sparse Packed Single-Precision Floating-Point Values from Dense Memory".

Mnemonic : VEXPANDPS Supported forms : (6 forms)

func (*Program) VEXTRACTF128 

func (self *Program) VEXTRACTF128(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VEXTRACTF128 performs "Extract Packed Floating-Point Values".

Mnemonic : VEXTRACTF128 Supported forms : (2 forms)

func (*Program) VEXTRACTF32X4 

func (self *Program) VEXTRACTF32X4(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VEXTRACTF32X4 performs "Extract 128 Bits of Packed Single-Precision Floating-Point Values".

Mnemonic : VEXTRACTF32X4 Supported forms : (4 forms)

func (*Program) VEXTRACTF32X8 

func (self *Program) VEXTRACTF32X8(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VEXTRACTF32X8 performs "Extract 256 Bits of Packed Single-Precision Floating-Point Values".

Mnemonic : VEXTRACTF32X8 Supported forms : (2 forms)

func (*Program) VEXTRACTF64X2 

func (self *Program) VEXTRACTF64X2(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VEXTRACTF64X2 performs "Extract 128 Bits of Packed Double-Precision Floating-Point Values".

Mnemonic : VEXTRACTF64X2 Supported forms : (4 forms)

func (*Program) VEXTRACTF64X4 

func (self *Program) VEXTRACTF64X4(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VEXTRACTF64X4 performs "Extract 256 Bits of Packed Double-Precision Floating-Point Values".

Mnemonic : VEXTRACTF64X4 Supported forms : (2 forms)

func (*Program) VEXTRACTI128 

func (self *Program) VEXTRACTI128(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VEXTRACTI128 performs "Extract Packed Integer Values".

Mnemonic : VEXTRACTI128 Supported forms : (2 forms)

func (*Program) VEXTRACTI32X4 

func (self *Program) VEXTRACTI32X4(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VEXTRACTI32X4 performs "Extract 128 Bits of Packed Doubleword Integer Values".

Mnemonic : VEXTRACTI32X4 Supported forms : (4 forms)

func (*Program) VEXTRACTI32X8 

func (self *Program) VEXTRACTI32X8(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VEXTRACTI32X8 performs "Extract 256 Bits of Packed Doubleword Integer Values".

Mnemonic : VEXTRACTI32X8 Supported forms : (2 forms)

func (*Program) VEXTRACTI64X2 

func (self *Program) VEXTRACTI64X2(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VEXTRACTI64X2 performs "Extract 128 Bits of Packed Quadword Integer Values".

Mnemonic : VEXTRACTI64X2 Supported forms : (4 forms)

func (*Program) VEXTRACTI64X4 

func (self *Program) VEXTRACTI64X4(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VEXTRACTI64X4 performs "Extract 256 Bits of Packed Quadword Integer Values".

Mnemonic : VEXTRACTI64X4 Supported forms : (2 forms)

func (*Program) VEXTRACTPS 

func (self *Program) VEXTRACTPS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VEXTRACTPS performs "Extract Packed Single Precision Floating-Point Value".

Mnemonic : VEXTRACTPS Supported forms : (4 forms)

func (*Program) VFIXUPIMMPD 

func (self *Program) VFIXUPIMMPD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}, vv ...interface{}) *Instruction

VFIXUPIMMPD performs "Fix Up Special Packed Double-Precision Floating-Point Values".

Mnemonic : VFIXUPIMMPD Supported forms : (7 forms)

func (*Program) VFIXUPIMMPS 

func (self *Program) VFIXUPIMMPS(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}, vv ...interface{}) *Instruction

VFIXUPIMMPS performs "Fix Up Special Packed Single-Precision Floating-Point Values".

Mnemonic : VFIXUPIMMPS Supported forms : (7 forms)

func (*Program) VFIXUPIMMSD 

func (self *Program) VFIXUPIMMSD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}, vv ...interface{}) *Instruction

VFIXUPIMMSD performs "Fix Up Special Scalar Double-Precision Floating-Point Value".

Mnemonic : VFIXUPIMMSD Supported forms : (3 forms)

func (*Program) VFIXUPIMMSS 

func (self *Program) VFIXUPIMMSS(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}, vv ...interface{}) *Instruction

VFIXUPIMMSS performs "Fix Up Special Scalar Single-Precision Floating-Point Value".

Mnemonic : VFIXUPIMMSS Supported forms : (3 forms)

func (*Program) VFMADD132PD 

func (self *Program) VFMADD132PD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VFMADD132PD performs "Fused Multiply-Add of Packed Double-Precision Floating-Point Values".

Mnemonic : VFMADD132PD Supported forms : (11 forms)

func (*Program) VFMADD132PS 

func (self *Program) VFMADD132PS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VFMADD132PS performs "Fused Multiply-Add of Packed Single-Precision Floating-Point Values".

Mnemonic : VFMADD132PS Supported forms : (11 forms)

func (*Program) VFMADD132SD 

func (self *Program) VFMADD132SD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VFMADD132SD performs "Fused Multiply-Add of Scalar Double-Precision Floating-Point Values".

Mnemonic : VFMADD132SD Supported forms : (5 forms)

func (*Program) VFMADD132SS 

func (self *Program) VFMADD132SS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VFMADD132SS performs "Fused Multiply-Add of Scalar Single-Precision Floating-Point Values".

Mnemonic : VFMADD132SS Supported forms : (5 forms)

func (*Program) VFMADD213PD 

func (self *Program) VFMADD213PD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VFMADD213PD performs "Fused Multiply-Add of Packed Double-Precision Floating-Point Values".

Mnemonic : VFMADD213PD Supported forms : (11 forms)

func (*Program) VFMADD213PS 

func (self *Program) VFMADD213PS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VFMADD213PS performs "Fused Multiply-Add of Packed Single-Precision Floating-Point Values".

Mnemonic : VFMADD213PS Supported forms : (11 forms)

func (*Program) VFMADD213SD 

func (self *Program) VFMADD213SD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VFMADD213SD performs "Fused Multiply-Add of Scalar Double-Precision Floating-Point Values".

Mnemonic : VFMADD213SD Supported forms : (5 forms)

func (*Program) VFMADD213SS 

func (self *Program) VFMADD213SS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VFMADD213SS performs "Fused Multiply-Add of Scalar Single-Precision Floating-Point Values".

Mnemonic : VFMADD213SS Supported forms : (5 forms)

func (*Program) VFMADD231PD 

func (self *Program) VFMADD231PD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VFMADD231PD performs "Fused Multiply-Add of Packed Double-Precision Floating-Point Values".

Mnemonic : VFMADD231PD Supported forms : (11 forms)

func (*Program) VFMADD231PS 

func (self *Program) VFMADD231PS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VFMADD231PS performs "Fused Multiply-Add of Packed Single-Precision Floating-Point Values".

Mnemonic : VFMADD231PS Supported forms : (11 forms)

func (*Program) VFMADD231SD 

func (self *Program) VFMADD231SD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VFMADD231SD performs "Fused Multiply-Add of Scalar Double-Precision Floating-Point Values".

Mnemonic : VFMADD231SD Supported forms : (5 forms)

func (*Program) VFMADD231SS 

func (self *Program) VFMADD231SS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VFMADD231SS performs "Fused Multiply-Add of Scalar Single-Precision Floating-Point Values".

Mnemonic : VFMADD231SS Supported forms : (5 forms)

func (*Program) VFMADDPD 

func (self *Program) VFMADDPD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VFMADDPD performs "Fused Multiply-Add of Packed Double-Precision Floating-Point Values".

Mnemonic : VFMADDPD Supported forms : (6 forms)

func (*Program) VFMADDPS 

func (self *Program) VFMADDPS(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VFMADDPS performs "Fused Multiply-Add of Packed Single-Precision Floating-Point Values".

Mnemonic : VFMADDPS Supported forms : (6 forms)

func (*Program) VFMADDSD 

func (self *Program) VFMADDSD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VFMADDSD performs "Fused Multiply-Add of Scalar Double-Precision Floating-Point Values".

Mnemonic : VFMADDSD Supported forms : (3 forms)

func (*Program) VFMADDSS 

func (self *Program) VFMADDSS(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VFMADDSS performs "Fused Multiply-Add of Scalar Single-Precision Floating-Point Values".

Mnemonic : VFMADDSS Supported forms : (3 forms)

func (*Program) VFMADDSUB132PD 

func (self *Program) VFMADDSUB132PD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VFMADDSUB132PD performs "Fused Multiply-Alternating Add/Subtract of Packed Double-Precision Floating-Point Values".

Mnemonic : VFMADDSUB132PD Supported forms : (11 forms)

func (*Program) VFMADDSUB132PS 

func (self *Program) VFMADDSUB132PS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VFMADDSUB132PS performs "Fused Multiply-Alternating Add/Subtract of Packed Single-Precision Floating-Point Values".

Mnemonic : VFMADDSUB132PS Supported forms : (11 forms)

func (*Program) VFMADDSUB213PD 

func (self *Program) VFMADDSUB213PD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VFMADDSUB213PD performs "Fused Multiply-Alternating Add/Subtract of Packed Double-Precision Floating-Point Values".

Mnemonic : VFMADDSUB213PD Supported forms : (11 forms)

func (*Program) VFMADDSUB213PS 

func (self *Program) VFMADDSUB213PS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VFMADDSUB213PS performs "Fused Multiply-Alternating Add/Subtract of Packed Single-Precision Floating-Point Values".

Mnemonic : VFMADDSUB213PS Supported forms : (11 forms)

func (*Program) VFMADDSUB231PD 

func (self *Program) VFMADDSUB231PD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VFMADDSUB231PD performs "Fused Multiply-Alternating Add/Subtract of Packed Double-Precision Floating-Point Values".

Mnemonic : VFMADDSUB231PD Supported forms : (11 forms)

func (*Program) VFMADDSUB231PS 

func (self *Program) VFMADDSUB231PS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VFMADDSUB231PS performs "Fused Multiply-Alternating Add/Subtract of Packed Single-Precision Floating-Point Values".

Mnemonic : VFMADDSUB231PS Supported forms : (11 forms)

func (*Program) VFMADDSUBPD 

func (self *Program) VFMADDSUBPD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VFMADDSUBPD performs "Fused Multiply-Alternating Add/Subtract of Packed Double-Precision Floating-Point Values".

Mnemonic : VFMADDSUBPD Supported forms : (6 forms)

func (*Program) VFMADDSUBPS 

func (self *Program) VFMADDSUBPS(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VFMADDSUBPS performs "Fused Multiply-Alternating Add/Subtract of Packed Single-Precision Floating-Point Values".

Mnemonic : VFMADDSUBPS Supported forms : (6 forms)

func (*Program) VFMSUB132PD 

func (self *Program) VFMSUB132PD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VFMSUB132PD performs "Fused Multiply-Subtract of Packed Double-Precision Floating-Point Values".

Mnemonic : VFMSUB132PD Supported forms : (11 forms)

func (*Program) VFMSUB132PS 

func (self *Program) VFMSUB132PS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VFMSUB132PS performs "Fused Multiply-Subtract of Packed Single-Precision Floating-Point Values".

Mnemonic : VFMSUB132PS Supported forms : (11 forms)

func (*Program) VFMSUB132SD 

func (self *Program) VFMSUB132SD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VFMSUB132SD performs "Fused Multiply-Subtract of Scalar Double-Precision Floating-Point Values".

Mnemonic : VFMSUB132SD Supported forms : (5 forms)

func (*Program) VFMSUB132SS 

func (self *Program) VFMSUB132SS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VFMSUB132SS performs "Fused Multiply-Subtract of Scalar Single-Precision Floating-Point Values".

Mnemonic : VFMSUB132SS Supported forms : (5 forms)

func (*Program) VFMSUB213PD 

func (self *Program) VFMSUB213PD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VFMSUB213PD performs "Fused Multiply-Subtract of Packed Double-Precision Floating-Point Values".

Mnemonic : VFMSUB213PD Supported forms : (11 forms)

func (*Program) VFMSUB213PS 

func (self *Program) VFMSUB213PS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VFMSUB213PS performs "Fused Multiply-Subtract of Packed Single-Precision Floating-Point Values".

Mnemonic : VFMSUB213PS Supported forms : (11 forms)

func (*Program) VFMSUB213SD 

func (self *Program) VFMSUB213SD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VFMSUB213SD performs "Fused Multiply-Subtract of Scalar Double-Precision Floating-Point Values".

Mnemonic : VFMSUB213SD Supported forms : (5 forms)

func (*Program) VFMSUB213SS 

func (self *Program) VFMSUB213SS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VFMSUB213SS performs "Fused Multiply-Subtract of Scalar Single-Precision Floating-Point Values".

Mnemonic : VFMSUB213SS Supported forms : (5 forms)

func (*Program) VFMSUB231PD 

func (self *Program) VFMSUB231PD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VFMSUB231PD performs "Fused Multiply-Subtract of Packed Double-Precision Floating-Point Values".

Mnemonic : VFMSUB231PD Supported forms : (11 forms)

func (*Program) VFMSUB231PS 

func (self *Program) VFMSUB231PS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VFMSUB231PS performs "Fused Multiply-Subtract of Packed Single-Precision Floating-Point Values".

Mnemonic : VFMSUB231PS Supported forms : (11 forms)

func (*Program) VFMSUB231SD 

func (self *Program) VFMSUB231SD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VFMSUB231SD performs "Fused Multiply-Subtract of Scalar Double-Precision Floating-Point Values".

Mnemonic : VFMSUB231SD Supported forms : (5 forms)

func (*Program) VFMSUB231SS 

func (self *Program) VFMSUB231SS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VFMSUB231SS performs "Fused Multiply-Subtract of Scalar Single-Precision Floating-Point Values".

Mnemonic : VFMSUB231SS Supported forms : (5 forms)

func (*Program) VFMSUBADD132PD 

func (self *Program) VFMSUBADD132PD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VFMSUBADD132PD performs "Fused Multiply-Alternating Subtract/Add of Packed Double-Precision Floating-Point Values".

Mnemonic : VFMSUBADD132PD Supported forms : (11 forms)

func (*Program) VFMSUBADD132PS 

func (self *Program) VFMSUBADD132PS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VFMSUBADD132PS performs "Fused Multiply-Alternating Subtract/Add of Packed Single-Precision Floating-Point Values".

Mnemonic : VFMSUBADD132PS Supported forms : (11 forms)

func (*Program) VFMSUBADD213PD 

func (self *Program) VFMSUBADD213PD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VFMSUBADD213PD performs "Fused Multiply-Alternating Subtract/Add of Packed Double-Precision Floating-Point Values".

Mnemonic : VFMSUBADD213PD Supported forms : (11 forms)

func (*Program) VFMSUBADD213PS 

func (self *Program) VFMSUBADD213PS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VFMSUBADD213PS performs "Fused Multiply-Alternating Subtract/Add of Packed Single-Precision Floating-Point Values".

Mnemonic : VFMSUBADD213PS Supported forms : (11 forms)

func (*Program) VFMSUBADD231PD 

func (self *Program) VFMSUBADD231PD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VFMSUBADD231PD performs "Fused Multiply-Alternating Subtract/Add of Packed Double-Precision Floating-Point Values".

Mnemonic : VFMSUBADD231PD Supported forms : (11 forms)

func (*Program) VFMSUBADD231PS 

func (self *Program) VFMSUBADD231PS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VFMSUBADD231PS performs "Fused Multiply-Alternating Subtract/Add of Packed Single-Precision Floating-Point Values".

Mnemonic : VFMSUBADD231PS Supported forms : (11 forms)

func (*Program) VFMSUBADDPD 

func (self *Program) VFMSUBADDPD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VFMSUBADDPD performs "Fused Multiply-Alternating Subtract/Add of Packed Double-Precision Floating-Point Values".

Mnemonic : VFMSUBADDPD Supported forms : (6 forms)

func (*Program) VFMSUBADDPS 

func (self *Program) VFMSUBADDPS(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VFMSUBADDPS performs "Fused Multiply-Alternating Subtract/Add of Packed Single-Precision Floating-Point Values".

Mnemonic : VFMSUBADDPS Supported forms : (6 forms)

func (*Program) VFMSUBPD 

func (self *Program) VFMSUBPD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VFMSUBPD performs "Fused Multiply-Subtract of Packed Double-Precision Floating-Point Values".

Mnemonic : VFMSUBPD Supported forms : (6 forms)

func (*Program) VFMSUBPS 

func (self *Program) VFMSUBPS(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VFMSUBPS performs "Fused Multiply-Subtract of Packed Single-Precision Floating-Point Values".

Mnemonic : VFMSUBPS Supported forms : (6 forms)

func (*Program) VFMSUBSD 

func (self *Program) VFMSUBSD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VFMSUBSD performs "Fused Multiply-Subtract of Scalar Double-Precision Floating-Point Values".

Mnemonic : VFMSUBSD Supported forms : (3 forms)

func (*Program) VFMSUBSS 

func (self *Program) VFMSUBSS(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VFMSUBSS performs "Fused Multiply-Subtract of Scalar Single-Precision Floating-Point Values".

Mnemonic : VFMSUBSS Supported forms : (3 forms)

func (*Program) VFNMADD132PD 

func (self *Program) VFNMADD132PD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VFNMADD132PD performs "Fused Negative Multiply-Add of Packed Double-Precision Floating-Point Values".

Mnemonic : VFNMADD132PD Supported forms : (11 forms)

func (*Program) VFNMADD132PS 

func (self *Program) VFNMADD132PS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VFNMADD132PS performs "Fused Negative Multiply-Add of Packed Single-Precision Floating-Point Values".

Mnemonic : VFNMADD132PS Supported forms : (11 forms)

func (*Program) VFNMADD132SD 

func (self *Program) VFNMADD132SD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VFNMADD132SD performs "Fused Negative Multiply-Add of Scalar Double-Precision Floating-Point Values".

Mnemonic : VFNMADD132SD Supported forms : (5 forms)

func (*Program) VFNMADD132SS 

func (self *Program) VFNMADD132SS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VFNMADD132SS performs "Fused Negative Multiply-Add of Scalar Single-Precision Floating-Point Values".

Mnemonic : VFNMADD132SS Supported forms : (5 forms)

func (*Program) VFNMADD213PD 

func (self *Program) VFNMADD213PD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VFNMADD213PD performs "Fused Negative Multiply-Add of Packed Double-Precision Floating-Point Values".

Mnemonic : VFNMADD213PD Supported forms : (11 forms)

func (*Program) VFNMADD213PS 

func (self *Program) VFNMADD213PS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VFNMADD213PS performs "Fused Negative Multiply-Add of Packed Single-Precision Floating-Point Values".

Mnemonic : VFNMADD213PS Supported forms : (11 forms)

func (*Program) VFNMADD213SD 

func (self *Program) VFNMADD213SD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VFNMADD213SD performs "Fused Negative Multiply-Add of Scalar Double-Precision Floating-Point Values".

Mnemonic : VFNMADD213SD Supported forms : (5 forms)

func (*Program) VFNMADD213SS 

func (self *Program) VFNMADD213SS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VFNMADD213SS performs "Fused Negative Multiply-Add of Scalar Single-Precision Floating-Point Values".

Mnemonic : VFNMADD213SS Supported forms : (5 forms)

func (*Program) VFNMADD231PD 

func (self *Program) VFNMADD231PD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VFNMADD231PD performs "Fused Negative Multiply-Add of Packed Double-Precision Floating-Point Values".

Mnemonic : VFNMADD231PD Supported forms : (11 forms)

func (*Program) VFNMADD231PS 

func (self *Program) VFNMADD231PS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VFNMADD231PS performs "Fused Negative Multiply-Add of Packed Single-Precision Floating-Point Values".

Mnemonic : VFNMADD231PS Supported forms : (11 forms)

func (*Program) VFNMADD231SD 

func (self *Program) VFNMADD231SD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VFNMADD231SD performs "Fused Negative Multiply-Add of Scalar Double-Precision Floating-Point Values".

Mnemonic : VFNMADD231SD Supported forms : (5 forms)

func (*Program) VFNMADD231SS 

func (self *Program) VFNMADD231SS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VFNMADD231SS performs "Fused Negative Multiply-Add of Scalar Single-Precision Floating-Point Values".

Mnemonic : VFNMADD231SS Supported forms : (5 forms)

func (*Program) VFNMADDPD 

func (self *Program) VFNMADDPD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VFNMADDPD performs "Fused Negative Multiply-Add of Packed Double-Precision Floating-Point Values".

Mnemonic : VFNMADDPD Supported forms : (6 forms)

func (*Program) VFNMADDPS 

func (self *Program) VFNMADDPS(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VFNMADDPS performs "Fused Negative Multiply-Add of Packed Single-Precision Floating-Point Values".

Mnemonic : VFNMADDPS Supported forms : (6 forms)

func (*Program) VFNMADDSD 

func (self *Program) VFNMADDSD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VFNMADDSD performs "Fused Negative Multiply-Add of Scalar Double-Precision Floating-Point Values".

Mnemonic : VFNMADDSD Supported forms : (3 forms)

func (*Program) VFNMADDSS 

func (self *Program) VFNMADDSS(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VFNMADDSS performs "Fused Negative Multiply-Add of Scalar Single-Precision Floating-Point Values".

Mnemonic : VFNMADDSS Supported forms : (3 forms)

func (*Program) VFNMSUB132PD 

func (self *Program) VFNMSUB132PD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VFNMSUB132PD performs "Fused Negative Multiply-Subtract of Packed Double-Precision Floating-Point Values".

Mnemonic : VFNMSUB132PD Supported forms : (11 forms)

func (*Program) VFNMSUB132PS 

func (self *Program) VFNMSUB132PS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VFNMSUB132PS performs "Fused Negative Multiply-Subtract of Packed Single-Precision Floating-Point Values".

Mnemonic : VFNMSUB132PS Supported forms : (11 forms)

func (*Program) VFNMSUB132SD 

func (self *Program) VFNMSUB132SD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VFNMSUB132SD performs "Fused Negative Multiply-Subtract of Scalar Double-Precision Floating-Point Values".

Mnemonic : VFNMSUB132SD Supported forms : (5 forms)

func (*Program) VFNMSUB132SS 

func (self *Program) VFNMSUB132SS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VFNMSUB132SS performs "Fused Negative Multiply-Subtract of Scalar Single-Precision Floating-Point Values".

Mnemonic : VFNMSUB132SS Supported forms : (5 forms)

func (*Program) VFNMSUB213PD 

func (self *Program) VFNMSUB213PD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VFNMSUB213PD performs "Fused Negative Multiply-Subtract of Packed Double-Precision Floating-Point Values".

Mnemonic : VFNMSUB213PD Supported forms : (11 forms)

func (*Program) VFNMSUB213PS 

func (self *Program) VFNMSUB213PS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VFNMSUB213PS performs "Fused Negative Multiply-Subtract of Packed Single-Precision Floating-Point Values".

Mnemonic : VFNMSUB213PS Supported forms : (11 forms)

func (*Program) VFNMSUB213SD 

func (self *Program) VFNMSUB213SD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VFNMSUB213SD performs "Fused Negative Multiply-Subtract of Scalar Double-Precision Floating-Point Values".

Mnemonic : VFNMSUB213SD Supported forms : (5 forms)

func (*Program) VFNMSUB213SS 

func (self *Program) VFNMSUB213SS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VFNMSUB213SS performs "Fused Negative Multiply-Subtract of Scalar Single-Precision Floating-Point Values".

Mnemonic : VFNMSUB213SS Supported forms : (5 forms)

func (*Program) VFNMSUB231PD 

func (self *Program) VFNMSUB231PD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VFNMSUB231PD performs "Fused Negative Multiply-Subtract of Packed Double-Precision Floating-Point Values".

Mnemonic : VFNMSUB231PD Supported forms : (11 forms)

func (*Program) VFNMSUB231PS 

func (self *Program) VFNMSUB231PS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VFNMSUB231PS performs "Fused Negative Multiply-Subtract of Packed Single-Precision Floating-Point Values".

Mnemonic : VFNMSUB231PS Supported forms : (11 forms)

func (*Program) VFNMSUB231SD 

func (self *Program) VFNMSUB231SD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VFNMSUB231SD performs "Fused Negative Multiply-Subtract of Scalar Double-Precision Floating-Point Values".

Mnemonic : VFNMSUB231SD Supported forms : (5 forms)

func (*Program) VFNMSUB231SS 

func (self *Program) VFNMSUB231SS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VFNMSUB231SS performs "Fused Negative Multiply-Subtract of Scalar Single-Precision Floating-Point Values".

Mnemonic : VFNMSUB231SS Supported forms : (5 forms)

func (*Program) VFNMSUBPD 

func (self *Program) VFNMSUBPD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VFNMSUBPD performs "Fused Negative Multiply-Subtract of Packed Double-Precision Floating-Point Values".

Mnemonic : VFNMSUBPD Supported forms : (6 forms)

func (*Program) VFNMSUBPS 

func (self *Program) VFNMSUBPS(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VFNMSUBPS performs "Fused Negative Multiply-Subtract of Packed Single-Precision Floating-Point Values".

Mnemonic : VFNMSUBPS Supported forms : (6 forms)

func (*Program) VFNMSUBSD 

func (self *Program) VFNMSUBSD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VFNMSUBSD performs "Fused Negative Multiply-Subtract of Scalar Double-Precision Floating-Point Values".

Mnemonic : VFNMSUBSD Supported forms : (3 forms)

func (*Program) VFNMSUBSS 

func (self *Program) VFNMSUBSS(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VFNMSUBSS performs "Fused Negative Multiply-Subtract of Scalar Single-Precision Floating-Point Values".

Mnemonic : VFNMSUBSS Supported forms : (3 forms)

func (*Program) VFPCLASSPD 

func (self *Program) VFPCLASSPD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VFPCLASSPD performs "Test Class of Packed Double-Precision Floating-Point Values".

Mnemonic : VFPCLASSPD Supported forms : (6 forms)

func (*Program) VFPCLASSPS 

func (self *Program) VFPCLASSPS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VFPCLASSPS performs "Test Class of Packed Single-Precision Floating-Point Values".

Mnemonic : VFPCLASSPS Supported forms : (6 forms)

func (*Program) VFPCLASSSD 

func (self *Program) VFPCLASSSD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VFPCLASSSD performs "Test Class of Scalar Double-Precision Floating-Point Value".

Mnemonic : VFPCLASSSD Supported forms : (2 forms)

func (*Program) VFPCLASSSS 

func (self *Program) VFPCLASSSS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VFPCLASSSS performs "Test Class of Scalar Single-Precision Floating-Point Value".

Mnemonic : VFPCLASSSS Supported forms : (2 forms)

func (*Program) VFRCZPD 

func (self *Program) VFRCZPD(v0 interface{}, v1 interface{}) *Instruction

VFRCZPD performs "Extract Fraction Packed Double-Precision Floating-Point".

Mnemonic : VFRCZPD Supported forms : (4 forms)

func (*Program) VFRCZPS 

func (self *Program) VFRCZPS(v0 interface{}, v1 interface{}) *Instruction

VFRCZPS performs "Extract Fraction Packed Single-Precision Floating-Point".

Mnemonic : VFRCZPS Supported forms : (4 forms)

func (*Program) VFRCZSD 

func (self *Program) VFRCZSD(v0 interface{}, v1 interface{}) *Instruction

VFRCZSD performs "Extract Fraction Scalar Double-Precision Floating-Point".

Mnemonic : VFRCZSD Supported forms : (2 forms)

func (*Program) VFRCZSS 

func (self *Program) VFRCZSS(v0 interface{}, v1 interface{}) *Instruction

VFRCZSS performs "Extract Fraction Scalar Single-Precision Floating Point".

Mnemonic : VFRCZSS Supported forms : (2 forms)

func (*Program) VGATHERDPD 

func (self *Program) VGATHERDPD(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction

VGATHERDPD performs "Gather Packed Double-Precision Floating-Point Values Using Signed Doubleword Indices".

Mnemonic : VGATHERDPD Supported forms : (5 forms)

func (*Program) VGATHERDPS 

func (self *Program) VGATHERDPS(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction

VGATHERDPS performs "Gather Packed Single-Precision Floating-Point Values Using Signed Doubleword Indices".

Mnemonic : VGATHERDPS Supported forms : (5 forms)

func (*Program) VGATHERPF0DPD 

func (self *Program) VGATHERPF0DPD(v0 interface{}) *Instruction

VGATHERPF0DPD performs "Sparse Prefetch Packed Double-Precision Floating-Point Data Values with Signed Doubleword Indices Using T0 Hint".

Mnemonic : VGATHERPF0DPD Supported forms : (1 form)

func (*Program) VGATHERPF0DPS 

func (self *Program) VGATHERPF0DPS(v0 interface{}) *Instruction

VGATHERPF0DPS performs "Sparse Prefetch Packed Single-Precision Floating-Point Data Values with Signed Doubleword Indices Using T0 Hint".

Mnemonic : VGATHERPF0DPS Supported forms : (1 form)

func (*Program) VGATHERPF0QPD 

func (self *Program) VGATHERPF0QPD(v0 interface{}) *Instruction

VGATHERPF0QPD performs "Sparse Prefetch Packed Double-Precision Floating-Point Data Values with Signed Quadword Indices Using T0 Hint".

Mnemonic : VGATHERPF0QPD Supported forms : (1 form)

func (*Program) VGATHERPF0QPS 

func (self *Program) VGATHERPF0QPS(v0 interface{}) *Instruction

VGATHERPF0QPS performs "Sparse Prefetch Packed Single-Precision Floating-Point Data Values with Signed Quadword Indices Using T0 Hint".

Mnemonic : VGATHERPF0QPS Supported forms : (1 form)

func (*Program) VGATHERPF1DPD 

func (self *Program) VGATHERPF1DPD(v0 interface{}) *Instruction

VGATHERPF1DPD performs "Sparse Prefetch Packed Double-Precision Floating-Point Data Values with Signed Doubleword Indices Using T1 Hint".

Mnemonic : VGATHERPF1DPD Supported forms : (1 form)

func (*Program) VGATHERPF1DPS 

func (self *Program) VGATHERPF1DPS(v0 interface{}) *Instruction

VGATHERPF1DPS performs "Sparse Prefetch Packed Single-Precision Floating-Point Data Values with Signed Doubleword Indices Using T1 Hint".

Mnemonic : VGATHERPF1DPS Supported forms : (1 form)

func (*Program) VGATHERPF1QPD 

func (self *Program) VGATHERPF1QPD(v0 interface{}) *Instruction

VGATHERPF1QPD performs "Sparse Prefetch Packed Double-Precision Floating-Point Data Values with Signed Quadword Indices Using T1 Hint".

Mnemonic : VGATHERPF1QPD Supported forms : (1 form)

func (*Program) VGATHERPF1QPS 

func (self *Program) VGATHERPF1QPS(v0 interface{}) *Instruction

VGATHERPF1QPS performs "Sparse Prefetch Packed Single-Precision Floating-Point Data Values with Signed Quadword Indices Using T1 Hint".

Mnemonic : VGATHERPF1QPS Supported forms : (1 form)

func (*Program) VGATHERQPD 

func (self *Program) VGATHERQPD(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction

VGATHERQPD performs "Gather Packed Double-Precision Floating-Point Values Using Signed Quadword Indices".

Mnemonic : VGATHERQPD Supported forms : (5 forms)

func (*Program) VGATHERQPS 

func (self *Program) VGATHERQPS(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction

VGATHERQPS performs "Gather Packed Single-Precision Floating-Point Values Using Signed Quadword Indices".

Mnemonic : VGATHERQPS Supported forms : (5 forms)

func (*Program) VGETEXPPD 

func (self *Program) VGETEXPPD(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction

VGETEXPPD performs "Extract Exponents of Packed Double-Precision Floating-Point Values as Double-Precision Floating-Point Values".

Mnemonic : VGETEXPPD Supported forms : (7 forms)

func (*Program) VGETEXPPS 

func (self *Program) VGETEXPPS(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction

VGETEXPPS performs "Extract Exponents of Packed Single-Precision Floating-Point Values as Single-Precision Floating-Point Values".

Mnemonic : VGETEXPPS Supported forms : (7 forms)

func (*Program) VGETEXPSD 

func (self *Program) VGETEXPSD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VGETEXPSD performs "Extract Exponent of Scalar Double-Precision Floating-Point Value as Double-Precision Floating-Point Value".

Mnemonic : VGETEXPSD Supported forms : (3 forms)

func (*Program) VGETEXPSS 

func (self *Program) VGETEXPSS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VGETEXPSS performs "Extract Exponent of Scalar Single-Precision Floating-Point Value as Single-Precision Floating-Point Value".

Mnemonic : VGETEXPSS Supported forms : (3 forms)

func (*Program) VGETMANTPD 

func (self *Program) VGETMANTPD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VGETMANTPD performs "Extract Normalized Mantissas from Packed Double-Precision Floating-Point Values".

Mnemonic : VGETMANTPD Supported forms : (7 forms)

func (*Program) VGETMANTPS 

func (self *Program) VGETMANTPS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VGETMANTPS performs "Extract Normalized Mantissas from Packed Single-Precision Floating-Point Values".

Mnemonic : VGETMANTPS Supported forms : (7 forms)

func (*Program) VGETMANTSD 

func (self *Program) VGETMANTSD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}, vv ...interface{}) *Instruction

VGETMANTSD performs "Extract Normalized Mantissa from Scalar Double-Precision Floating-Point Value".

Mnemonic : VGETMANTSD Supported forms : (3 forms)

func (*Program) VGETMANTSS 

func (self *Program) VGETMANTSS(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}, vv ...interface{}) *Instruction

VGETMANTSS performs "Extract Normalized Mantissa from Scalar Single-Precision Floating-Point Value".

Mnemonic : VGETMANTSS Supported forms : (3 forms)

func (*Program) VHADDPD 

func (self *Program) VHADDPD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VHADDPD performs "Packed Double-FP Horizontal Add".

Mnemonic : VHADDPD Supported forms : (4 forms)

func (*Program) VHADDPS 

func (self *Program) VHADDPS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VHADDPS performs "Packed Single-FP Horizontal Add".

Mnemonic : VHADDPS Supported forms : (4 forms)

func (*Program) VHSUBPD 

func (self *Program) VHSUBPD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VHSUBPD performs "Packed Double-FP Horizontal Subtract".

Mnemonic : VHSUBPD Supported forms : (4 forms)

func (*Program) VHSUBPS 

func (self *Program) VHSUBPS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VHSUBPS performs "Packed Single-FP Horizontal Subtract".

Mnemonic : VHSUBPS Supported forms : (4 forms)

func (*Program) VINSERTF128 

func (self *Program) VINSERTF128(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VINSERTF128 performs "Insert Packed Floating-Point Values".

Mnemonic : VINSERTF128 Supported forms : (2 forms)

func (*Program) VINSERTF32X4 

func (self *Program) VINSERTF32X4(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VINSERTF32X4 performs "Insert 128 Bits of Packed Single-Precision Floating-Point Values".

Mnemonic : VINSERTF32X4 Supported forms : (4 forms)

func (*Program) VINSERTF32X8 

func (self *Program) VINSERTF32X8(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VINSERTF32X8 performs "Insert 256 Bits of Packed Single-Precision Floating-Point Values".

Mnemonic : VINSERTF32X8 Supported forms : (2 forms)

func (*Program) VINSERTF64X2 

func (self *Program) VINSERTF64X2(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VINSERTF64X2 performs "Insert 128 Bits of Packed Double-Precision Floating-Point Values".

Mnemonic : VINSERTF64X2 Supported forms : (4 forms)

func (*Program) VINSERTF64X4 

func (self *Program) VINSERTF64X4(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VINSERTF64X4 performs "Insert 256 Bits of Packed Double-Precision Floating-Point Values".

Mnemonic : VINSERTF64X4 Supported forms : (2 forms)

func (*Program) VINSERTI128 

func (self *Program) VINSERTI128(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VINSERTI128 performs "Insert Packed Integer Values".

Mnemonic : VINSERTI128 Supported forms : (2 forms)

func (*Program) VINSERTI32X4 

func (self *Program) VINSERTI32X4(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VINSERTI32X4 performs "Insert 128 Bits of Packed Doubleword Integer Values".

Mnemonic : VINSERTI32X4 Supported forms : (4 forms)

func (*Program) VINSERTI32X8 

func (self *Program) VINSERTI32X8(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VINSERTI32X8 performs "Insert 256 Bits of Packed Doubleword Integer Values".

Mnemonic : VINSERTI32X8 Supported forms : (2 forms)

func (*Program) VINSERTI64X2 

func (self *Program) VINSERTI64X2(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VINSERTI64X2 performs "Insert 128 Bits of Packed Quadword Integer Values".

Mnemonic : VINSERTI64X2 Supported forms : (4 forms)

func (*Program) VINSERTI64X4 

func (self *Program) VINSERTI64X4(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VINSERTI64X4 performs "Insert 256 Bits of Packed Quadword Integer Values".

Mnemonic : VINSERTI64X4 Supported forms : (2 forms)

func (*Program) VINSERTPS 

func (self *Program) VINSERTPS(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VINSERTPS performs "Insert Packed Single Precision Floating-Point Value".

Mnemonic : VINSERTPS Supported forms : (4 forms)

func (*Program) VLDDQU 

func (self *Program) VLDDQU(v0 interface{}, v1 interface{}) *Instruction

VLDDQU performs "Load Unaligned Integer 128 Bits".

Mnemonic : VLDDQU Supported forms : (2 forms)

func (*Program) VLDMXCSR 

func (self *Program) VLDMXCSR(v0 interface{}) *Instruction

VLDMXCSR performs "Load MXCSR Register".

Mnemonic : VLDMXCSR Supported forms : (1 form)

func (*Program) VMASKMOVDQU 

func (self *Program) VMASKMOVDQU(v0 interface{}, v1 interface{}) *Instruction

VMASKMOVDQU performs "Store Selected Bytes of Double Quadword".

Mnemonic : VMASKMOVDQU Supported forms : (1 form)

func (*Program) VMASKMOVPD 

func (self *Program) VMASKMOVPD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VMASKMOVPD performs "Conditional Move Packed Double-Precision Floating-Point Values".

Mnemonic : VMASKMOVPD Supported forms : (4 forms)

func (*Program) VMASKMOVPS 

func (self *Program) VMASKMOVPS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VMASKMOVPS performs "Conditional Move Packed Single-Precision Floating-Point Values".

Mnemonic : VMASKMOVPS Supported forms : (4 forms)

func (*Program) VMAXPD 

func (self *Program) VMAXPD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VMAXPD performs "Return Maximum Packed Double-Precision Floating-Point Values".

Mnemonic : VMAXPD Supported forms : (11 forms)

func (*Program) VMAXPS 

func (self *Program) VMAXPS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VMAXPS performs "Return Maximum Packed Single-Precision Floating-Point Values".

Mnemonic : VMAXPS Supported forms : (11 forms)

func (*Program) VMAXSD 

func (self *Program) VMAXSD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VMAXSD performs "Return Maximum Scalar Double-Precision Floating-Point Value".

Mnemonic : VMAXSD Supported forms : (5 forms)

func (*Program) VMAXSS 

func (self *Program) VMAXSS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VMAXSS performs "Return Maximum Scalar Single-Precision Floating-Point Value".

Mnemonic : VMAXSS Supported forms : (5 forms)

func (*Program) VMINPD 

func (self *Program) VMINPD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VMINPD performs "Return Minimum Packed Double-Precision Floating-Point Values".

Mnemonic : VMINPD Supported forms : (11 forms)

func (*Program) VMINPS 

func (self *Program) VMINPS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VMINPS performs "Return Minimum Packed Single-Precision Floating-Point Values".

Mnemonic : VMINPS Supported forms : (11 forms)

func (*Program) VMINSD 

func (self *Program) VMINSD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VMINSD performs "Return Minimum Scalar Double-Precision Floating-Point Value".

Mnemonic : VMINSD Supported forms : (5 forms)

func (*Program) VMINSS 

func (self *Program) VMINSS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VMINSS performs "Return Minimum Scalar Single-Precision Floating-Point Value".

Mnemonic : VMINSS Supported forms : (5 forms)

func (*Program) VMOVAPD 

func (self *Program) VMOVAPD(v0 interface{}, v1 interface{}) *Instruction

VMOVAPD performs "Move Aligned Packed Double-Precision Floating-Point Values".

Mnemonic : VMOVAPD Supported forms : (15 forms)

func (*Program) VMOVAPS 

func (self *Program) VMOVAPS(v0 interface{}, v1 interface{}) *Instruction

VMOVAPS performs "Move Aligned Packed Single-Precision Floating-Point Values".

Mnemonic : VMOVAPS Supported forms : (15 forms)

func (*Program) VMOVD 

func (self *Program) VMOVD(v0 interface{}, v1 interface{}) *Instruction

VMOVD performs "Move Doubleword".

Mnemonic : VMOVD Supported forms : (8 forms)

func (*Program) VMOVDDUP 

func (self *Program) VMOVDDUP(v0 interface{}, v1 interface{}) *Instruction

VMOVDDUP performs "Move One Double-FP and Duplicate".

Mnemonic : VMOVDDUP Supported forms : (10 forms)

func (*Program) VMOVDQA 

func (self *Program) VMOVDQA(v0 interface{}, v1 interface{}) *Instruction

VMOVDQA performs "Move Aligned Double Quadword".

Mnemonic : VMOVDQA Supported forms : (6 forms)

func (*Program) VMOVDQA32 

func (self *Program) VMOVDQA32(v0 interface{}, v1 interface{}) *Instruction

VMOVDQA32 performs "Move Aligned Doubleword Values".

Mnemonic : VMOVDQA32 Supported forms : (9 forms)

func (*Program) VMOVDQA64 

func (self *Program) VMOVDQA64(v0 interface{}, v1 interface{}) *Instruction

VMOVDQA64 performs "Move Aligned Quadword Values".

Mnemonic : VMOVDQA64 Supported forms : (9 forms)

func (*Program) VMOVDQU 

func (self *Program) VMOVDQU(v0 interface{}, v1 interface{}) *Instruction

VMOVDQU performs "Move Unaligned Double Quadword".

Mnemonic : VMOVDQU Supported forms : (6 forms)

func (*Program) VMOVDQU16 

func (self *Program) VMOVDQU16(v0 interface{}, v1 interface{}) *Instruction

VMOVDQU16 performs "Move Unaligned Word Values".

Mnemonic : VMOVDQU16 Supported forms : (9 forms)

func (*Program) VMOVDQU32 

func (self *Program) VMOVDQU32(v0 interface{}, v1 interface{}) *Instruction

VMOVDQU32 performs "Move Unaligned Doubleword Values".

Mnemonic : VMOVDQU32 Supported forms : (9 forms)

func (*Program) VMOVDQU64 

func (self *Program) VMOVDQU64(v0 interface{}, v1 interface{}) *Instruction

VMOVDQU64 performs "Move Unaligned Quadword Values".

Mnemonic : VMOVDQU64 Supported forms : (9 forms)

func (*Program) VMOVDQU8 

func (self *Program) VMOVDQU8(v0 interface{}, v1 interface{}) *Instruction

VMOVDQU8 performs "Move Unaligned Byte Values".

Mnemonic : VMOVDQU8 Supported forms : (9 forms)

func (*Program) VMOVHLPS 

func (self *Program) VMOVHLPS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VMOVHLPS performs "Move Packed Single-Precision Floating-Point Values High to Low".

Mnemonic : VMOVHLPS Supported forms : (2 forms)

func (*Program) VMOVHPD 

func (self *Program) VMOVHPD(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction

VMOVHPD performs "Move High Packed Double-Precision Floating-Point Value".

Mnemonic : VMOVHPD Supported forms : (4 forms)

func (*Program) VMOVHPS 

func (self *Program) VMOVHPS(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction

VMOVHPS performs "Move High Packed Single-Precision Floating-Point Values".

Mnemonic : VMOVHPS Supported forms : (4 forms)

func (*Program) VMOVLHPS 

func (self *Program) VMOVLHPS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VMOVLHPS performs "Move Packed Single-Precision Floating-Point Values Low to High".

Mnemonic : VMOVLHPS Supported forms : (2 forms)

func (*Program) VMOVLPD 

func (self *Program) VMOVLPD(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction

VMOVLPD performs "Move Low Packed Double-Precision Floating-Point Value".

Mnemonic : VMOVLPD Supported forms : (4 forms)

func (*Program) VMOVLPS 

func (self *Program) VMOVLPS(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction

VMOVLPS performs "Move Low Packed Single-Precision Floating-Point Values".

Mnemonic : VMOVLPS Supported forms : (4 forms)

func (*Program) VMOVMSKPD 

func (self *Program) VMOVMSKPD(v0 interface{}, v1 interface{}) *Instruction

VMOVMSKPD performs "Extract Packed Double-Precision Floating-Point Sign Mask".

Mnemonic : VMOVMSKPD Supported forms : (2 forms)

func (*Program) VMOVMSKPS 

func (self *Program) VMOVMSKPS(v0 interface{}, v1 interface{}) *Instruction

VMOVMSKPS performs "Extract Packed Single-Precision Floating-Point Sign Mask".

Mnemonic : VMOVMSKPS Supported forms : (2 forms)

func (*Program) VMOVNTDQ 

func (self *Program) VMOVNTDQ(v0 interface{}, v1 interface{}) *Instruction

VMOVNTDQ performs "Store Double Quadword Using Non-Temporal Hint".

Mnemonic : VMOVNTDQ Supported forms : (5 forms)

func (*Program) VMOVNTDQA 

func (self *Program) VMOVNTDQA(v0 interface{}, v1 interface{}) *Instruction

VMOVNTDQA performs "Load Double Quadword Non-Temporal Aligned Hint".

Mnemonic : VMOVNTDQA Supported forms : (5 forms)

func (*Program) VMOVNTPD 

func (self *Program) VMOVNTPD(v0 interface{}, v1 interface{}) *Instruction

VMOVNTPD performs "Store Packed Double-Precision Floating-Point Values Using Non-Temporal Hint".

Mnemonic : VMOVNTPD Supported forms : (5 forms)

func (*Program) VMOVNTPS 

func (self *Program) VMOVNTPS(v0 interface{}, v1 interface{}) *Instruction

VMOVNTPS performs "Store Packed Single-Precision Floating-Point Values Using Non-Temporal Hint".

Mnemonic : VMOVNTPS Supported forms : (5 forms)

func (*Program) VMOVQ 

func (self *Program) VMOVQ(v0 interface{}, v1 interface{}) *Instruction

VMOVQ performs "Move Quadword".

Mnemonic : VMOVQ Supported forms : (10 forms)

func (*Program) VMOVSD 

func (self *Program) VMOVSD(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction

VMOVSD performs "Move Scalar Double-Precision Floating-Point Value".

Mnemonic : VMOVSD Supported forms : (6 forms)

func (*Program) VMOVSHDUP 

func (self *Program) VMOVSHDUP(v0 interface{}, v1 interface{}) *Instruction

VMOVSHDUP performs "Move Packed Single-FP High and Duplicate".

Mnemonic : VMOVSHDUP Supported forms : (10 forms)

func (*Program) VMOVSLDUP 

func (self *Program) VMOVSLDUP(v0 interface{}, v1 interface{}) *Instruction

VMOVSLDUP performs "Move Packed Single-FP Low and Duplicate".

Mnemonic : VMOVSLDUP Supported forms : (10 forms)

func (*Program) VMOVSS 

func (self *Program) VMOVSS(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction

VMOVSS performs "Move Scalar Single-Precision Floating-Point Values".

Mnemonic : VMOVSS Supported forms : (6 forms)

func (*Program) VMOVUPD 

func (self *Program) VMOVUPD(v0 interface{}, v1 interface{}) *Instruction

VMOVUPD performs "Move Unaligned Packed Double-Precision Floating-Point Values".

Mnemonic : VMOVUPD Supported forms : (15 forms)

func (*Program) VMOVUPS 

func (self *Program) VMOVUPS(v0 interface{}, v1 interface{}) *Instruction

VMOVUPS performs "Move Unaligned Packed Single-Precision Floating-Point Values".

Mnemonic : VMOVUPS Supported forms : (15 forms)

func (*Program) VMPSADBW 

func (self *Program) VMPSADBW(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VMPSADBW performs "Compute Multiple Packed Sums of Absolute Difference".

Mnemonic : VMPSADBW Supported forms : (4 forms)

func (*Program) VMULPD 

func (self *Program) VMULPD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VMULPD performs "Multiply Packed Double-Precision Floating-Point Values".

Mnemonic : VMULPD Supported forms : (11 forms)

func (*Program) VMULPS 

func (self *Program) VMULPS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VMULPS performs "Multiply Packed Single-Precision Floating-Point Values".

Mnemonic : VMULPS Supported forms : (11 forms)

func (*Program) VMULSD 

func (self *Program) VMULSD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VMULSD performs "Multiply Scalar Double-Precision Floating-Point Values".

Mnemonic : VMULSD Supported forms : (5 forms)

func (*Program) VMULSS 

func (self *Program) VMULSS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VMULSS performs "Multiply Scalar Single-Precision Floating-Point Values".

Mnemonic : VMULSS Supported forms : (5 forms)

func (*Program) VORPD 

func (self *Program) VORPD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VORPD performs "Bitwise Logical OR of Double-Precision Floating-Point Values".

Mnemonic : VORPD Supported forms : (10 forms)

func (*Program) VORPS 

func (self *Program) VORPS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VORPS performs "Bitwise Logical OR of Single-Precision Floating-Point Values".

Mnemonic : VORPS Supported forms : (10 forms)

func (*Program) VPABSB 

func (self *Program) VPABSB(v0 interface{}, v1 interface{}) *Instruction

VPABSB performs "Packed Absolute Value of Byte Integers".

Mnemonic : VPABSB Supported forms : (10 forms)

func (*Program) VPABSD 

func (self *Program) VPABSD(v0 interface{}, v1 interface{}) *Instruction

VPABSD performs "Packed Absolute Value of Doubleword Integers".

Mnemonic : VPABSD Supported forms : (10 forms)

func (*Program) VPABSQ 

func (self *Program) VPABSQ(v0 interface{}, v1 interface{}) *Instruction

VPABSQ performs "Packed Absolute Value of Quadword Integers".

Mnemonic : VPABSQ Supported forms : (6 forms)

func (*Program) VPABSW 

func (self *Program) VPABSW(v0 interface{}, v1 interface{}) *Instruction

VPABSW performs "Packed Absolute Value of Word Integers".

Mnemonic : VPABSW Supported forms : (10 forms)

func (*Program) VPACKSSDW 

func (self *Program) VPACKSSDW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPACKSSDW performs "Pack Doublewords into Words with Signed Saturation".

Mnemonic : VPACKSSDW Supported forms : (10 forms)

func (*Program) VPACKSSWB 

func (self *Program) VPACKSSWB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPACKSSWB performs "Pack Words into Bytes with Signed Saturation".

Mnemonic : VPACKSSWB Supported forms : (10 forms)

func (*Program) VPACKUSDW 

func (self *Program) VPACKUSDW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPACKUSDW performs "Pack Doublewords into Words with Unsigned Saturation".

Mnemonic : VPACKUSDW Supported forms : (10 forms)

func (*Program) VPACKUSWB 

func (self *Program) VPACKUSWB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPACKUSWB performs "Pack Words into Bytes with Unsigned Saturation".

Mnemonic : VPACKUSWB Supported forms : (10 forms)

func (*Program) VPADDB 

func (self *Program) VPADDB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPADDB performs "Add Packed Byte Integers".

Mnemonic : VPADDB Supported forms : (10 forms)

func (*Program) VPADDD 

func (self *Program) VPADDD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPADDD performs "Add Packed Doubleword Integers".

Mnemonic : VPADDD Supported forms : (10 forms)

func (*Program) VPADDQ 

func (self *Program) VPADDQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPADDQ performs "Add Packed Quadword Integers".

Mnemonic : VPADDQ Supported forms : (10 forms)

func (*Program) VPADDSB 

func (self *Program) VPADDSB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPADDSB performs "Add Packed Signed Byte Integers with Signed Saturation".

Mnemonic : VPADDSB Supported forms : (10 forms)

func (*Program) VPADDSW 

func (self *Program) VPADDSW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPADDSW performs "Add Packed Signed Word Integers with Signed Saturation".

Mnemonic : VPADDSW Supported forms : (10 forms)

func (*Program) VPADDUSB 

func (self *Program) VPADDUSB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPADDUSB performs "Add Packed Unsigned Byte Integers with Unsigned Saturation".

Mnemonic : VPADDUSB Supported forms : (10 forms)

func (*Program) VPADDUSW 

func (self *Program) VPADDUSW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPADDUSW performs "Add Packed Unsigned Word Integers with Unsigned Saturation".

Mnemonic : VPADDUSW Supported forms : (10 forms)

func (*Program) VPADDW 

func (self *Program) VPADDW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPADDW performs "Add Packed Word Integers".

Mnemonic : VPADDW Supported forms : (10 forms)

func (*Program) VPALIGNR 

func (self *Program) VPALIGNR(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VPALIGNR performs "Packed Align Right".

Mnemonic : VPALIGNR Supported forms : (10 forms)

func (*Program) VPAND 

func (self *Program) VPAND(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPAND performs "Packed Bitwise Logical AND".

Mnemonic : VPAND Supported forms : (4 forms)

func (*Program) VPANDD 

func (self *Program) VPANDD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPANDD performs "Bitwise Logical AND of Packed Doubleword Integers".

Mnemonic : VPANDD Supported forms : (6 forms)

func (*Program) VPANDN 

func (self *Program) VPANDN(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPANDN performs "Packed Bitwise Logical AND NOT".

Mnemonic : VPANDN Supported forms : (4 forms)

func (*Program) VPANDND 

func (self *Program) VPANDND(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPANDND performs "Bitwise Logical AND NOT of Packed Doubleword Integers".

Mnemonic : VPANDND Supported forms : (6 forms)

func (*Program) VPANDNQ 

func (self *Program) VPANDNQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPANDNQ performs "Bitwise Logical AND NOT of Packed Quadword Integers".

Mnemonic : VPANDNQ Supported forms : (6 forms)

func (*Program) VPANDQ 

func (self *Program) VPANDQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPANDQ performs "Bitwise Logical AND of Packed Quadword Integers".

Mnemonic : VPANDQ Supported forms : (6 forms)

func (*Program) VPAVGB 

func (self *Program) VPAVGB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPAVGB performs "Average Packed Byte Integers".

Mnemonic : VPAVGB Supported forms : (10 forms)

func (*Program) VPAVGW 

func (self *Program) VPAVGW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPAVGW performs "Average Packed Word Integers".

Mnemonic : VPAVGW Supported forms : (10 forms)

func (*Program) VPBLENDD 

func (self *Program) VPBLENDD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VPBLENDD performs "Blend Packed Doublewords".

Mnemonic : VPBLENDD Supported forms : (4 forms)

func (*Program) VPBLENDMB 

func (self *Program) VPBLENDMB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPBLENDMB performs "Blend Byte Vectors Using an OpMask Control".

Mnemonic : VPBLENDMB Supported forms : (6 forms)

func (*Program) VPBLENDMD 

func (self *Program) VPBLENDMD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPBLENDMD performs "Blend Doubleword Vectors Using an OpMask Control".

Mnemonic : VPBLENDMD Supported forms : (6 forms)

func (*Program) VPBLENDMQ 

func (self *Program) VPBLENDMQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPBLENDMQ performs "Blend Quadword Vectors Using an OpMask Control".

Mnemonic : VPBLENDMQ Supported forms : (6 forms)

func (*Program) VPBLENDMW 

func (self *Program) VPBLENDMW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPBLENDMW performs "Blend Word Vectors Using an OpMask Control".

Mnemonic : VPBLENDMW Supported forms : (6 forms)

func (*Program) VPBLENDVB 

func (self *Program) VPBLENDVB(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VPBLENDVB performs "Variable Blend Packed Bytes".

Mnemonic : VPBLENDVB Supported forms : (4 forms)

func (*Program) VPBLENDW 

func (self *Program) VPBLENDW(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VPBLENDW performs "Blend Packed Words".

Mnemonic : VPBLENDW Supported forms : (4 forms)

func (*Program) VPBROADCASTB 

func (self *Program) VPBROADCASTB(v0 interface{}, v1 interface{}) *Instruction

VPBROADCASTB performs "Broadcast Byte Integer".

Mnemonic : VPBROADCASTB Supported forms : (13 forms)

func (*Program) VPBROADCASTD 

func (self *Program) VPBROADCASTD(v0 interface{}, v1 interface{}) *Instruction

VPBROADCASTD performs "Broadcast Doubleword Integer".

Mnemonic : VPBROADCASTD Supported forms : (13 forms)

func (*Program) VPBROADCASTMB2Q 

func (self *Program) VPBROADCASTMB2Q(v0 interface{}, v1 interface{}) *Instruction

VPBROADCASTMB2Q performs "Broadcast Low Byte of Mask Register to Packed Quadword Values".

Mnemonic : VPBROADCASTMB2Q Supported forms : (3 forms)

func (*Program) VPBROADCASTMW2D 

func (self *Program) VPBROADCASTMW2D(v0 interface{}, v1 interface{}) *Instruction

VPBROADCASTMW2D performs "Broadcast Low Word of Mask Register to Packed Doubleword Values".

Mnemonic : VPBROADCASTMW2D Supported forms : (3 forms)

func (*Program) VPBROADCASTQ 

func (self *Program) VPBROADCASTQ(v0 interface{}, v1 interface{}) *Instruction

VPBROADCASTQ performs "Broadcast Quadword Integer".

Mnemonic : VPBROADCASTQ Supported forms : (13 forms)

func (*Program) VPBROADCASTW 

func (self *Program) VPBROADCASTW(v0 interface{}, v1 interface{}) *Instruction

VPBROADCASTW performs "Broadcast Word Integer".

Mnemonic : VPBROADCASTW Supported forms : (13 forms)

func (*Program) VPCLMULQDQ 

func (self *Program) VPCLMULQDQ(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VPCLMULQDQ performs "Carry-Less Quadword Multiplication".

Mnemonic : VPCLMULQDQ Supported forms : (2 forms)

func (*Program) VPCMOV 

func (self *Program) VPCMOV(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VPCMOV performs "Packed Conditional Move".

Mnemonic : VPCMOV Supported forms : (6 forms)

func (*Program) VPCMPB 

func (self *Program) VPCMPB(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VPCMPB performs "Compare Packed Signed Byte Values".

Mnemonic : VPCMPB Supported forms : (6 forms)

func (*Program) VPCMPD 

func (self *Program) VPCMPD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VPCMPD performs "Compare Packed Signed Doubleword Values".

Mnemonic : VPCMPD Supported forms : (6 forms)

func (*Program) VPCMPEQB 

func (self *Program) VPCMPEQB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPCMPEQB performs "Compare Packed Byte Data for Equality".

Mnemonic : VPCMPEQB Supported forms : (10 forms)

func (*Program) VPCMPEQD 

func (self *Program) VPCMPEQD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPCMPEQD performs "Compare Packed Doubleword Data for Equality".

Mnemonic : VPCMPEQD Supported forms : (10 forms)

func (*Program) VPCMPEQQ 

func (self *Program) VPCMPEQQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPCMPEQQ performs "Compare Packed Quadword Data for Equality".

Mnemonic : VPCMPEQQ Supported forms : (10 forms)

func (*Program) VPCMPEQW 

func (self *Program) VPCMPEQW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPCMPEQW performs "Compare Packed Word Data for Equality".

Mnemonic : VPCMPEQW Supported forms : (10 forms)

func (*Program) VPCMPESTRI 

func (self *Program) VPCMPESTRI(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPCMPESTRI performs "Packed Compare Explicit Length Strings, Return Index".

Mnemonic : VPCMPESTRI Supported forms : (2 forms)

func (*Program) VPCMPESTRM 

func (self *Program) VPCMPESTRM(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPCMPESTRM performs "Packed Compare Explicit Length Strings, Return Mask".

Mnemonic : VPCMPESTRM Supported forms : (2 forms)

func (*Program) VPCMPGTB 

func (self *Program) VPCMPGTB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPCMPGTB performs "Compare Packed Signed Byte Integers for Greater Than".

Mnemonic : VPCMPGTB Supported forms : (10 forms)

func (*Program) VPCMPGTD 

func (self *Program) VPCMPGTD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPCMPGTD performs "Compare Packed Signed Doubleword Integers for Greater Than".

Mnemonic : VPCMPGTD Supported forms : (10 forms)

func (*Program) VPCMPGTQ 

func (self *Program) VPCMPGTQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPCMPGTQ performs "Compare Packed Data for Greater Than".

Mnemonic : VPCMPGTQ Supported forms : (10 forms)

func (*Program) VPCMPGTW 

func (self *Program) VPCMPGTW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPCMPGTW performs "Compare Packed Signed Word Integers for Greater Than".

Mnemonic : VPCMPGTW Supported forms : (10 forms)

func (*Program) VPCMPISTRI 

func (self *Program) VPCMPISTRI(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPCMPISTRI performs "Packed Compare Implicit Length Strings, Return Index".

Mnemonic : VPCMPISTRI Supported forms : (2 forms)

func (*Program) VPCMPISTRM 

func (self *Program) VPCMPISTRM(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPCMPISTRM performs "Packed Compare Implicit Length Strings, Return Mask".

Mnemonic : VPCMPISTRM Supported forms : (2 forms)

func (*Program) VPCMPQ 

func (self *Program) VPCMPQ(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VPCMPQ performs "Compare Packed Signed Quadword Values".

Mnemonic : VPCMPQ Supported forms : (6 forms)

func (*Program) VPCMPUB 

func (self *Program) VPCMPUB(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VPCMPUB performs "Compare Packed Unsigned Byte Values".

Mnemonic : VPCMPUB Supported forms : (6 forms)

func (*Program) VPCMPUD 

func (self *Program) VPCMPUD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VPCMPUD performs "Compare Packed Unsigned Doubleword Values".

Mnemonic : VPCMPUD Supported forms : (6 forms)

func (*Program) VPCMPUQ 

func (self *Program) VPCMPUQ(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VPCMPUQ performs "Compare Packed Unsigned Quadword Values".

Mnemonic : VPCMPUQ Supported forms : (6 forms)

func (*Program) VPCMPUW 

func (self *Program) VPCMPUW(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VPCMPUW performs "Compare Packed Unsigned Word Values".

Mnemonic : VPCMPUW Supported forms : (6 forms)

func (*Program) VPCMPW 

func (self *Program) VPCMPW(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VPCMPW performs "Compare Packed Signed Word Values".

Mnemonic : VPCMPW Supported forms : (6 forms)

func (*Program) VPCOMB 

func (self *Program) VPCOMB(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VPCOMB performs "Compare Packed Signed Byte Integers".

Mnemonic : VPCOMB Supported forms : (2 forms)

func (*Program) VPCOMD 

func (self *Program) VPCOMD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VPCOMD performs "Compare Packed Signed Doubleword Integers".

Mnemonic : VPCOMD Supported forms : (2 forms)

func (*Program) VPCOMPRESSD 

func (self *Program) VPCOMPRESSD(v0 interface{}, v1 interface{}) *Instruction

VPCOMPRESSD performs "Store Sparse Packed Doubleword Integer Values into Dense Memory/Register".

Mnemonic : VPCOMPRESSD Supported forms : (6 forms)

func (*Program) VPCOMPRESSQ 

func (self *Program) VPCOMPRESSQ(v0 interface{}, v1 interface{}) *Instruction

VPCOMPRESSQ performs "Store Sparse Packed Quadword Integer Values into Dense Memory/Register".

Mnemonic : VPCOMPRESSQ Supported forms : (6 forms)

func (*Program) VPCOMQ 

func (self *Program) VPCOMQ(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VPCOMQ performs "Compare Packed Signed Quadword Integers".

Mnemonic : VPCOMQ Supported forms : (2 forms)

func (*Program) VPCOMUB 

func (self *Program) VPCOMUB(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VPCOMUB performs "Compare Packed Unsigned Byte Integers".

Mnemonic : VPCOMUB Supported forms : (2 forms)

func (*Program) VPCOMUD 

func (self *Program) VPCOMUD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VPCOMUD performs "Compare Packed Unsigned Doubleword Integers".

Mnemonic : VPCOMUD Supported forms : (2 forms)

func (*Program) VPCOMUQ 

func (self *Program) VPCOMUQ(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VPCOMUQ performs "Compare Packed Unsigned Quadword Integers".

Mnemonic : VPCOMUQ Supported forms : (2 forms)

func (*Program) VPCOMUW 

func (self *Program) VPCOMUW(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VPCOMUW performs "Compare Packed Unsigned Word Integers".

Mnemonic : VPCOMUW Supported forms : (2 forms)

func (*Program) VPCOMW 

func (self *Program) VPCOMW(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VPCOMW performs "Compare Packed Signed Word Integers".

Mnemonic : VPCOMW Supported forms : (2 forms)

func (*Program) VPCONFLICTD 

func (self *Program) VPCONFLICTD(v0 interface{}, v1 interface{}) *Instruction

VPCONFLICTD performs "Detect Conflicts Within a Vector of Packed Doubleword Values into Dense Memory/Register".

Mnemonic : VPCONFLICTD Supported forms : (6 forms)

func (*Program) VPCONFLICTQ 

func (self *Program) VPCONFLICTQ(v0 interface{}, v1 interface{}) *Instruction

VPCONFLICTQ performs "Detect Conflicts Within a Vector of Packed Quadword Values into Dense Memory/Register".

Mnemonic : VPCONFLICTQ Supported forms : (6 forms)

func (*Program) VPERM2F128 

func (self *Program) VPERM2F128(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VPERM2F128 performs "Permute Floating-Point Values".

Mnemonic : VPERM2F128 Supported forms : (2 forms)

func (*Program) VPERM2I128 

func (self *Program) VPERM2I128(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VPERM2I128 performs "Permute 128-Bit Integer Values".

Mnemonic : VPERM2I128 Supported forms : (2 forms)

func (*Program) VPERMB 

func (self *Program) VPERMB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPERMB performs "Permute Byte Integers".

Mnemonic : VPERMB Supported forms : (6 forms)

func (*Program) VPERMD 

func (self *Program) VPERMD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPERMD performs "Permute Doubleword Integers".

Mnemonic : VPERMD Supported forms : (6 forms)

func (*Program) VPERMI2B 

func (self *Program) VPERMI2B(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPERMI2B performs "Full Permute of Bytes From Two Tables Overwriting the Index".

Mnemonic : VPERMI2B Supported forms : (6 forms)

func (*Program) VPERMI2D 

func (self *Program) VPERMI2D(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPERMI2D performs "Full Permute of Doublewords From Two Tables Overwriting the Index".

Mnemonic : VPERMI2D Supported forms : (6 forms)

func (*Program) VPERMI2PD 

func (self *Program) VPERMI2PD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPERMI2PD performs "Full Permute of Double-Precision Floating-Point Values From Two Tables Overwriting the Index".

Mnemonic : VPERMI2PD Supported forms : (6 forms)

func (*Program) VPERMI2PS 

func (self *Program) VPERMI2PS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPERMI2PS performs "Full Permute of Single-Precision Floating-Point Values From Two Tables Overwriting the Index".

Mnemonic : VPERMI2PS Supported forms : (6 forms)

func (*Program) VPERMI2Q 

func (self *Program) VPERMI2Q(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPERMI2Q performs "Full Permute of Quadwords From Two Tables Overwriting the Index".

Mnemonic : VPERMI2Q Supported forms : (6 forms)

func (*Program) VPERMI2W 

func (self *Program) VPERMI2W(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPERMI2W performs "Full Permute of Words From Two Tables Overwriting the Index".

Mnemonic : VPERMI2W Supported forms : (6 forms)

func (*Program) VPERMIL2PD 

func (self *Program) VPERMIL2PD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}, v4 interface{}) *Instruction

VPERMIL2PD performs "Permute Two-Source Double-Precision Floating-Point Vectors".

Mnemonic : VPERMIL2PD Supported forms : (6 forms)

func (*Program) VPERMIL2PS 

func (self *Program) VPERMIL2PS(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}, v4 interface{}) *Instruction

VPERMIL2PS performs "Permute Two-Source Single-Precision Floating-Point Vectors".

Mnemonic : VPERMIL2PS Supported forms : (6 forms)

func (*Program) VPERMILPD 

func (self *Program) VPERMILPD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPERMILPD performs "Permute Double-Precision Floating-Point Values".

Mnemonic : VPERMILPD Supported forms : (20 forms)

func (*Program) VPERMILPS 

func (self *Program) VPERMILPS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPERMILPS performs "Permute Single-Precision Floating-Point Values".

Mnemonic : VPERMILPS Supported forms : (20 forms)

func (*Program) VPERMPD 

func (self *Program) VPERMPD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPERMPD performs "Permute Double-Precision Floating-Point Elements".

Mnemonic : VPERMPD Supported forms : (10 forms)

func (*Program) VPERMPS 

func (self *Program) VPERMPS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPERMPS performs "Permute Single-Precision Floating-Point Elements".

Mnemonic : VPERMPS Supported forms : (6 forms)

func (*Program) VPERMQ 

func (self *Program) VPERMQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPERMQ performs "Permute Quadword Integers".

Mnemonic : VPERMQ Supported forms : (10 forms)

func (*Program) VPERMT2B 

func (self *Program) VPERMT2B(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPERMT2B performs "Full Permute of Bytes From Two Tables Overwriting a Table".

Mnemonic : VPERMT2B Supported forms : (6 forms)

func (*Program) VPERMT2D 

func (self *Program) VPERMT2D(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPERMT2D performs "Full Permute of Doublewords From Two Tables Overwriting a Table".

Mnemonic : VPERMT2D Supported forms : (6 forms)

func (*Program) VPERMT2PD 

func (self *Program) VPERMT2PD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPERMT2PD performs "Full Permute of Double-Precision Floating-Point Values From Two Tables Overwriting a Table".

Mnemonic : VPERMT2PD Supported forms : (6 forms)

func (*Program) VPERMT2PS 

func (self *Program) VPERMT2PS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPERMT2PS performs "Full Permute of Single-Precision Floating-Point Values From Two Tables Overwriting a Table".

Mnemonic : VPERMT2PS Supported forms : (6 forms)

func (*Program) VPERMT2Q 

func (self *Program) VPERMT2Q(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPERMT2Q performs "Full Permute of Quadwords From Two Tables Overwriting a Table".

Mnemonic : VPERMT2Q Supported forms : (6 forms)

func (*Program) VPERMT2W 

func (self *Program) VPERMT2W(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPERMT2W performs "Full Permute of Words From Two Tables Overwriting a Table".

Mnemonic : VPERMT2W Supported forms : (6 forms)

func (*Program) VPERMW 

func (self *Program) VPERMW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPERMW performs "Permute Word Integers".

Mnemonic : VPERMW Supported forms : (6 forms)

func (*Program) VPEXPANDD 

func (self *Program) VPEXPANDD(v0 interface{}, v1 interface{}) *Instruction

VPEXPANDD performs "Load Sparse Packed Doubleword Integer Values from Dense Memory/Register".

Mnemonic : VPEXPANDD Supported forms : (6 forms)

func (*Program) VPEXPANDQ 

func (self *Program) VPEXPANDQ(v0 interface{}, v1 interface{}) *Instruction

VPEXPANDQ performs "Load Sparse Packed Quadword Integer Values from Dense Memory/Register".

Mnemonic : VPEXPANDQ Supported forms : (6 forms)

func (*Program) VPEXTRB 

func (self *Program) VPEXTRB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPEXTRB performs "Extract Byte".

Mnemonic : VPEXTRB Supported forms : (4 forms)

func (*Program) VPEXTRD 

func (self *Program) VPEXTRD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPEXTRD performs "Extract Doubleword".

Mnemonic : VPEXTRD Supported forms : (4 forms)

func (*Program) VPEXTRQ 

func (self *Program) VPEXTRQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPEXTRQ performs "Extract Quadword".

Mnemonic : VPEXTRQ Supported forms : (4 forms)

func (*Program) VPEXTRW 

func (self *Program) VPEXTRW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPEXTRW performs "Extract Word".

Mnemonic : VPEXTRW Supported forms : (4 forms)

func (*Program) VPGATHERDD 

func (self *Program) VPGATHERDD(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction

VPGATHERDD performs "Gather Packed Doubleword Values Using Signed Doubleword Indices".

Mnemonic : VPGATHERDD Supported forms : (5 forms)

func (*Program) VPGATHERDQ 

func (self *Program) VPGATHERDQ(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction

VPGATHERDQ performs "Gather Packed Quadword Values Using Signed Doubleword Indices".

Mnemonic : VPGATHERDQ Supported forms : (5 forms)

func (*Program) VPGATHERQD 

func (self *Program) VPGATHERQD(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction

VPGATHERQD performs "Gather Packed Doubleword Values Using Signed Quadword Indices".

Mnemonic : VPGATHERQD Supported forms : (5 forms)

func (*Program) VPGATHERQQ 

func (self *Program) VPGATHERQQ(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction

VPGATHERQQ performs "Gather Packed Quadword Values Using Signed Quadword Indices".

Mnemonic : VPGATHERQQ Supported forms : (5 forms)

func (*Program) VPHADDBD 

func (self *Program) VPHADDBD(v0 interface{}, v1 interface{}) *Instruction

VPHADDBD performs "Packed Horizontal Add Signed Byte to Signed Doubleword".

Mnemonic : VPHADDBD Supported forms : (2 forms)

func (*Program) VPHADDBQ 

func (self *Program) VPHADDBQ(v0 interface{}, v1 interface{}) *Instruction

VPHADDBQ performs "Packed Horizontal Add Signed Byte to Signed Quadword".

Mnemonic : VPHADDBQ Supported forms : (2 forms)

func (*Program) VPHADDBW 

func (self *Program) VPHADDBW(v0 interface{}, v1 interface{}) *Instruction

VPHADDBW performs "Packed Horizontal Add Signed Byte to Signed Word".

Mnemonic : VPHADDBW Supported forms : (2 forms)

func (*Program) VPHADDD 

func (self *Program) VPHADDD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPHADDD performs "Packed Horizontal Add Doubleword Integer".

Mnemonic : VPHADDD Supported forms : (4 forms)

func (*Program) VPHADDDQ 

func (self *Program) VPHADDDQ(v0 interface{}, v1 interface{}) *Instruction

VPHADDDQ performs "Packed Horizontal Add Signed Doubleword to Signed Quadword".

Mnemonic : VPHADDDQ Supported forms : (2 forms)

func (*Program) VPHADDSW 

func (self *Program) VPHADDSW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPHADDSW performs "Packed Horizontal Add Signed Word Integers with Signed Saturation".

Mnemonic : VPHADDSW Supported forms : (4 forms)

func (*Program) VPHADDUBD 

func (self *Program) VPHADDUBD(v0 interface{}, v1 interface{}) *Instruction

VPHADDUBD performs "Packed Horizontal Add Unsigned Byte to Doubleword".

Mnemonic : VPHADDUBD Supported forms : (2 forms)

func (*Program) VPHADDUBQ 

func (self *Program) VPHADDUBQ(v0 interface{}, v1 interface{}) *Instruction

VPHADDUBQ performs "Packed Horizontal Add Unsigned Byte to Quadword".

Mnemonic : VPHADDUBQ Supported forms : (2 forms)

func (*Program) VPHADDUBW 

func (self *Program) VPHADDUBW(v0 interface{}, v1 interface{}) *Instruction

VPHADDUBW performs "Packed Horizontal Add Unsigned Byte to Word".

Mnemonic : VPHADDUBW Supported forms : (2 forms)

func (*Program) VPHADDUDQ 

func (self *Program) VPHADDUDQ(v0 interface{}, v1 interface{}) *Instruction

VPHADDUDQ performs "Packed Horizontal Add Unsigned Doubleword to Quadword".

Mnemonic : VPHADDUDQ Supported forms : (2 forms)

func (*Program) VPHADDUWD 

func (self *Program) VPHADDUWD(v0 interface{}, v1 interface{}) *Instruction

VPHADDUWD performs "Packed Horizontal Add Unsigned Word to Doubleword".

Mnemonic : VPHADDUWD Supported forms : (2 forms)

func (*Program) VPHADDUWQ 

func (self *Program) VPHADDUWQ(v0 interface{}, v1 interface{}) *Instruction

VPHADDUWQ performs "Packed Horizontal Add Unsigned Word to Quadword".

Mnemonic : VPHADDUWQ Supported forms : (2 forms)

func (*Program) VPHADDW 

func (self *Program) VPHADDW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPHADDW performs "Packed Horizontal Add Word Integers".

Mnemonic : VPHADDW Supported forms : (4 forms)

func (*Program) VPHADDWD 

func (self *Program) VPHADDWD(v0 interface{}, v1 interface{}) *Instruction

VPHADDWD performs "Packed Horizontal Add Signed Word to Signed Doubleword".

Mnemonic : VPHADDWD Supported forms : (2 forms)

func (*Program) VPHADDWQ 

func (self *Program) VPHADDWQ(v0 interface{}, v1 interface{}) *Instruction

VPHADDWQ performs "Packed Horizontal Add Signed Word to Signed Quadword".

Mnemonic : VPHADDWQ Supported forms : (2 forms)

func (*Program) VPHMINPOSUW 

func (self *Program) VPHMINPOSUW(v0 interface{}, v1 interface{}) *Instruction

VPHMINPOSUW performs "Packed Horizontal Minimum of Unsigned Word Integers".

Mnemonic : VPHMINPOSUW Supported forms : (2 forms)

func (*Program) VPHSUBBW 

func (self *Program) VPHSUBBW(v0 interface{}, v1 interface{}) *Instruction

VPHSUBBW performs "Packed Horizontal Subtract Signed Byte to Signed Word".

Mnemonic : VPHSUBBW Supported forms : (2 forms)

func (*Program) VPHSUBD 

func (self *Program) VPHSUBD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPHSUBD performs "Packed Horizontal Subtract Doubleword Integers".

Mnemonic : VPHSUBD Supported forms : (4 forms)

func (*Program) VPHSUBDQ 

func (self *Program) VPHSUBDQ(v0 interface{}, v1 interface{}) *Instruction

VPHSUBDQ performs "Packed Horizontal Subtract Signed Doubleword to Signed Quadword".

Mnemonic : VPHSUBDQ Supported forms : (2 forms)

func (*Program) VPHSUBSW 

func (self *Program) VPHSUBSW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPHSUBSW performs "Packed Horizontal Subtract Signed Word Integers with Signed Saturation".

Mnemonic : VPHSUBSW Supported forms : (4 forms)

func (*Program) VPHSUBW 

func (self *Program) VPHSUBW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPHSUBW performs "Packed Horizontal Subtract Word Integers".

Mnemonic : VPHSUBW Supported forms : (4 forms)

func (*Program) VPHSUBWD 

func (self *Program) VPHSUBWD(v0 interface{}, v1 interface{}) *Instruction

VPHSUBWD performs "Packed Horizontal Subtract Signed Word to Signed Doubleword".

Mnemonic : VPHSUBWD Supported forms : (2 forms)

func (*Program) VPINSRB 

func (self *Program) VPINSRB(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VPINSRB performs "Insert Byte".

Mnemonic : VPINSRB Supported forms : (4 forms)

func (*Program) VPINSRD 

func (self *Program) VPINSRD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VPINSRD performs "Insert Doubleword".

Mnemonic : VPINSRD Supported forms : (4 forms)

func (*Program) VPINSRQ 

func (self *Program) VPINSRQ(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VPINSRQ performs "Insert Quadword".

Mnemonic : VPINSRQ Supported forms : (4 forms)

func (*Program) VPINSRW 

func (self *Program) VPINSRW(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VPINSRW performs "Insert Word".

Mnemonic : VPINSRW Supported forms : (4 forms)

func (*Program) VPLZCNTD 

func (self *Program) VPLZCNTD(v0 interface{}, v1 interface{}) *Instruction

VPLZCNTD performs "Count the Number of Leading Zero Bits for Packed Doubleword Values".

Mnemonic : VPLZCNTD Supported forms : (6 forms)

func (*Program) VPLZCNTQ 

func (self *Program) VPLZCNTQ(v0 interface{}, v1 interface{}) *Instruction

VPLZCNTQ performs "Count the Number of Leading Zero Bits for Packed Quadword Values".

Mnemonic : VPLZCNTQ Supported forms : (6 forms)

func (*Program) VPMACSDD 

func (self *Program) VPMACSDD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VPMACSDD performs "Packed Multiply Accumulate Signed Doubleword to Signed Doubleword".

Mnemonic : VPMACSDD Supported forms : (2 forms)

func (*Program) VPMACSDQH 

func (self *Program) VPMACSDQH(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VPMACSDQH performs "Packed Multiply Accumulate Signed High Doubleword to Signed Quadword".

Mnemonic : VPMACSDQH Supported forms : (2 forms)

func (*Program) VPMACSDQL 

func (self *Program) VPMACSDQL(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VPMACSDQL performs "Packed Multiply Accumulate Signed Low Doubleword to Signed Quadword".

Mnemonic : VPMACSDQL Supported forms : (2 forms)

func (*Program) VPMACSSDD 

func (self *Program) VPMACSSDD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VPMACSSDD performs "Packed Multiply Accumulate with Saturation Signed Doubleword to Signed Doubleword".

Mnemonic : VPMACSSDD Supported forms : (2 forms)

func (*Program) VPMACSSDQH 

func (self *Program) VPMACSSDQH(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VPMACSSDQH performs "Packed Multiply Accumulate with Saturation Signed High Doubleword to Signed Quadword".

Mnemonic : VPMACSSDQH Supported forms : (2 forms)

func (*Program) VPMACSSDQL 

func (self *Program) VPMACSSDQL(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VPMACSSDQL performs "Packed Multiply Accumulate with Saturation Signed Low Doubleword to Signed Quadword".

Mnemonic : VPMACSSDQL Supported forms : (2 forms)

func (*Program) VPMACSSWD 

func (self *Program) VPMACSSWD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VPMACSSWD performs "Packed Multiply Accumulate with Saturation Signed Word to Signed Doubleword".

Mnemonic : VPMACSSWD Supported forms : (2 forms)

func (*Program) VPMACSSWW 

func (self *Program) VPMACSSWW(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VPMACSSWW performs "Packed Multiply Accumulate with Saturation Signed Word to Signed Word".

Mnemonic : VPMACSSWW Supported forms : (2 forms)

func (*Program) VPMACSWD 

func (self *Program) VPMACSWD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VPMACSWD performs "Packed Multiply Accumulate Signed Word to Signed Doubleword".

Mnemonic : VPMACSWD Supported forms : (2 forms)

func (*Program) VPMACSWW 

func (self *Program) VPMACSWW(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VPMACSWW performs "Packed Multiply Accumulate Signed Word to Signed Word".

Mnemonic : VPMACSWW Supported forms : (2 forms)

func (*Program) VPMADCSSWD 

func (self *Program) VPMADCSSWD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VPMADCSSWD performs "Packed Multiply Add Accumulate with Saturation Signed Word to Signed Doubleword".

Mnemonic : VPMADCSSWD Supported forms : (2 forms)

func (*Program) VPMADCSWD 

func (self *Program) VPMADCSWD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VPMADCSWD performs "Packed Multiply Add Accumulate Signed Word to Signed Doubleword".

Mnemonic : VPMADCSWD Supported forms : (2 forms)

func (*Program) VPMADD52HUQ 

func (self *Program) VPMADD52HUQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPMADD52HUQ performs "Packed Multiply of Unsigned 52-bit Unsigned Integers and Add High 52-bit Products to Quadword Accumulators".

Mnemonic : VPMADD52HUQ Supported forms : (6 forms)

func (*Program) VPMADD52LUQ 

func (self *Program) VPMADD52LUQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPMADD52LUQ performs "Packed Multiply of Unsigned 52-bit Integers and Add the Low 52-bit Products to Quadword Accumulators".

Mnemonic : VPMADD52LUQ Supported forms : (6 forms)

func (*Program) VPMADDUBSW 

func (self *Program) VPMADDUBSW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPMADDUBSW performs "Multiply and Add Packed Signed and Unsigned Byte Integers".

Mnemonic : VPMADDUBSW Supported forms : (10 forms)

func (*Program) VPMADDWD 

func (self *Program) VPMADDWD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPMADDWD performs "Multiply and Add Packed Signed Word Integers".

Mnemonic : VPMADDWD Supported forms : (10 forms)

func (*Program) VPMASKMOVD 

func (self *Program) VPMASKMOVD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPMASKMOVD performs "Conditional Move Packed Doubleword Integers".

Mnemonic : VPMASKMOVD Supported forms : (4 forms)

func (*Program) VPMASKMOVQ 

func (self *Program) VPMASKMOVQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPMASKMOVQ performs "Conditional Move Packed Quadword Integers".

Mnemonic : VPMASKMOVQ Supported forms : (4 forms)

func (*Program) VPMAXSB 

func (self *Program) VPMAXSB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPMAXSB performs "Maximum of Packed Signed Byte Integers".

Mnemonic : VPMAXSB Supported forms : (10 forms)

func (*Program) VPMAXSD 

func (self *Program) VPMAXSD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPMAXSD performs "Maximum of Packed Signed Doubleword Integers".

Mnemonic : VPMAXSD Supported forms : (10 forms)

func (*Program) VPMAXSQ 

func (self *Program) VPMAXSQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPMAXSQ performs "Maximum of Packed Signed Quadword Integers".

Mnemonic : VPMAXSQ Supported forms : (6 forms)

func (*Program) VPMAXSW 

func (self *Program) VPMAXSW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPMAXSW performs "Maximum of Packed Signed Word Integers".

Mnemonic : VPMAXSW Supported forms : (10 forms)

func (*Program) VPMAXUB 

func (self *Program) VPMAXUB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPMAXUB performs "Maximum of Packed Unsigned Byte Integers".

Mnemonic : VPMAXUB Supported forms : (10 forms)

func (*Program) VPMAXUD 

func (self *Program) VPMAXUD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPMAXUD performs "Maximum of Packed Unsigned Doubleword Integers".

Mnemonic : VPMAXUD Supported forms : (10 forms)

func (*Program) VPMAXUQ 

func (self *Program) VPMAXUQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPMAXUQ performs "Maximum of Packed Unsigned Quadword Integers".

Mnemonic : VPMAXUQ Supported forms : (6 forms)

func (*Program) VPMAXUW 

func (self *Program) VPMAXUW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPMAXUW performs "Maximum of Packed Unsigned Word Integers".

Mnemonic : VPMAXUW Supported forms : (10 forms)

func (*Program) VPMINSB 

func (self *Program) VPMINSB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPMINSB performs "Minimum of Packed Signed Byte Integers".

Mnemonic : VPMINSB Supported forms : (10 forms)

func (*Program) VPMINSD 

func (self *Program) VPMINSD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPMINSD performs "Minimum of Packed Signed Doubleword Integers".

Mnemonic : VPMINSD Supported forms : (10 forms)

func (*Program) VPMINSQ 

func (self *Program) VPMINSQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPMINSQ performs "Minimum of Packed Signed Quadword Integers".

Mnemonic : VPMINSQ Supported forms : (6 forms)

func (*Program) VPMINSW 

func (self *Program) VPMINSW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPMINSW performs "Minimum of Packed Signed Word Integers".

Mnemonic : VPMINSW Supported forms : (10 forms)

func (*Program) VPMINUB 

func (self *Program) VPMINUB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPMINUB performs "Minimum of Packed Unsigned Byte Integers".

Mnemonic : VPMINUB Supported forms : (10 forms)

func (*Program) VPMINUD 

func (self *Program) VPMINUD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPMINUD performs "Minimum of Packed Unsigned Doubleword Integers".

Mnemonic : VPMINUD Supported forms : (10 forms)

func (*Program) VPMINUQ 

func (self *Program) VPMINUQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPMINUQ performs "Minimum of Packed Unsigned Quadword Integers".

Mnemonic : VPMINUQ Supported forms : (6 forms)

func (*Program) VPMINUW 

func (self *Program) VPMINUW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPMINUW performs "Minimum of Packed Unsigned Word Integers".

Mnemonic : VPMINUW Supported forms : (10 forms)

func (*Program) VPMOVB2M 

func (self *Program) VPMOVB2M(v0 interface{}, v1 interface{}) *Instruction

VPMOVB2M performs "Move Signs of Packed Byte Integers to Mask Register".

Mnemonic : VPMOVB2M Supported forms : (3 forms)

func (*Program) VPMOVD2M 

func (self *Program) VPMOVD2M(v0 interface{}, v1 interface{}) *Instruction

VPMOVD2M performs "Move Signs of Packed Doubleword Integers to Mask Register".

Mnemonic : VPMOVD2M Supported forms : (3 forms)

func (*Program) VPMOVDB 

func (self *Program) VPMOVDB(v0 interface{}, v1 interface{}) *Instruction

VPMOVDB performs "Down Convert Packed Doubleword Values to Byte Values with Truncation".

Mnemonic : VPMOVDB Supported forms : (6 forms)

func (*Program) VPMOVDW 

func (self *Program) VPMOVDW(v0 interface{}, v1 interface{}) *Instruction

VPMOVDW performs "Down Convert Packed Doubleword Values to Word Values with Truncation".

Mnemonic : VPMOVDW Supported forms : (6 forms)

func (*Program) VPMOVM2B 

func (self *Program) VPMOVM2B(v0 interface{}, v1 interface{}) *Instruction

VPMOVM2B performs "Expand Bits of Mask Register to Packed Byte Integers".

Mnemonic : VPMOVM2B Supported forms : (3 forms)

func (*Program) VPMOVM2D 

func (self *Program) VPMOVM2D(v0 interface{}, v1 interface{}) *Instruction

VPMOVM2D performs "Expand Bits of Mask Register to Packed Doubleword Integers".

Mnemonic : VPMOVM2D Supported forms : (3 forms)

func (*Program) VPMOVM2Q 

func (self *Program) VPMOVM2Q(v0 interface{}, v1 interface{}) *Instruction

VPMOVM2Q performs "Expand Bits of Mask Register to Packed Quadword Integers".

Mnemonic : VPMOVM2Q Supported forms : (3 forms)

func (*Program) VPMOVM2W 

func (self *Program) VPMOVM2W(v0 interface{}, v1 interface{}) *Instruction

VPMOVM2W performs "Expand Bits of Mask Register to Packed Word Integers".

Mnemonic : VPMOVM2W Supported forms : (3 forms)

func (*Program) VPMOVMSKB 

func (self *Program) VPMOVMSKB(v0 interface{}, v1 interface{}) *Instruction

VPMOVMSKB performs "Move Byte Mask".

Mnemonic : VPMOVMSKB Supported forms : (2 forms)

func (*Program) VPMOVQ2M 

func (self *Program) VPMOVQ2M(v0 interface{}, v1 interface{}) *Instruction

VPMOVQ2M performs "Move Signs of Packed Quadword Integers to Mask Register".

Mnemonic : VPMOVQ2M Supported forms : (3 forms)

func (*Program) VPMOVQB 

func (self *Program) VPMOVQB(v0 interface{}, v1 interface{}) *Instruction

VPMOVQB performs "Down Convert Packed Quadword Values to Byte Values with Truncation".

Mnemonic : VPMOVQB Supported forms : (6 forms)

func (*Program) VPMOVQD 

func (self *Program) VPMOVQD(v0 interface{}, v1 interface{}) *Instruction

VPMOVQD performs "Down Convert Packed Quadword Values to Doubleword Values with Truncation".

Mnemonic : VPMOVQD Supported forms : (6 forms)

func (*Program) VPMOVQW 

func (self *Program) VPMOVQW(v0 interface{}, v1 interface{}) *Instruction

VPMOVQW performs "Down Convert Packed Quadword Values to Word Values with Truncation".

Mnemonic : VPMOVQW Supported forms : (6 forms)

func (*Program) VPMOVSDB 

func (self *Program) VPMOVSDB(v0 interface{}, v1 interface{}) *Instruction

VPMOVSDB performs "Down Convert Packed Doubleword Values to Byte Values with Signed Saturation".

Mnemonic : VPMOVSDB Supported forms : (6 forms)

func (*Program) VPMOVSDW 

func (self *Program) VPMOVSDW(v0 interface{}, v1 interface{}) *Instruction

VPMOVSDW performs "Down Convert Packed Doubleword Values to Word Values with Signed Saturation".

Mnemonic : VPMOVSDW Supported forms : (6 forms)

func (*Program) VPMOVSQB 

func (self *Program) VPMOVSQB(v0 interface{}, v1 interface{}) *Instruction

VPMOVSQB performs "Down Convert Packed Quadword Values to Byte Values with Signed Saturation".

Mnemonic : VPMOVSQB Supported forms : (6 forms)

func (*Program) VPMOVSQD 

func (self *Program) VPMOVSQD(v0 interface{}, v1 interface{}) *Instruction

VPMOVSQD performs "Down Convert Packed Quadword Values to Doubleword Values with Signed Saturation".

Mnemonic : VPMOVSQD Supported forms : (6 forms)

func (*Program) VPMOVSQW 

func (self *Program) VPMOVSQW(v0 interface{}, v1 interface{}) *Instruction

VPMOVSQW performs "Down Convert Packed Quadword Values to Word Values with Signed Saturation".

Mnemonic : VPMOVSQW Supported forms : (6 forms)

func (*Program) VPMOVSWB 

func (self *Program) VPMOVSWB(v0 interface{}, v1 interface{}) *Instruction

VPMOVSWB performs "Down Convert Packed Word Values to Byte Values with Signed Saturation".

Mnemonic : VPMOVSWB Supported forms : (6 forms)

func (*Program) VPMOVSXBD 

func (self *Program) VPMOVSXBD(v0 interface{}, v1 interface{}) *Instruction

VPMOVSXBD performs "Move Packed Byte Integers to Doubleword Integers with Sign Extension".

Mnemonic : VPMOVSXBD Supported forms : (10 forms)

func (*Program) VPMOVSXBQ 

func (self *Program) VPMOVSXBQ(v0 interface{}, v1 interface{}) *Instruction

VPMOVSXBQ performs "Move Packed Byte Integers to Quadword Integers with Sign Extension".

Mnemonic : VPMOVSXBQ Supported forms : (10 forms)

func (*Program) VPMOVSXBW 

func (self *Program) VPMOVSXBW(v0 interface{}, v1 interface{}) *Instruction

VPMOVSXBW performs "Move Packed Byte Integers to Word Integers with Sign Extension".

Mnemonic : VPMOVSXBW Supported forms : (10 forms)

func (*Program) VPMOVSXDQ 

func (self *Program) VPMOVSXDQ(v0 interface{}, v1 interface{}) *Instruction

VPMOVSXDQ performs "Move Packed Doubleword Integers to Quadword Integers with Sign Extension".

Mnemonic : VPMOVSXDQ Supported forms : (10 forms)

func (*Program) VPMOVSXWD 

func (self *Program) VPMOVSXWD(v0 interface{}, v1 interface{}) *Instruction

VPMOVSXWD performs "Move Packed Word Integers to Doubleword Integers with Sign Extension".

Mnemonic : VPMOVSXWD Supported forms : (10 forms)

func (*Program) VPMOVSXWQ 

func (self *Program) VPMOVSXWQ(v0 interface{}, v1 interface{}) *Instruction

VPMOVSXWQ performs "Move Packed Word Integers to Quadword Integers with Sign Extension".

Mnemonic : VPMOVSXWQ Supported forms : (10 forms)

func (*Program) VPMOVUSDB 

func (self *Program) VPMOVUSDB(v0 interface{}, v1 interface{}) *Instruction

VPMOVUSDB performs "Down Convert Packed Doubleword Values to Byte Values with Unsigned Saturation".

Mnemonic : VPMOVUSDB Supported forms : (6 forms)

func (*Program) VPMOVUSDW 

func (self *Program) VPMOVUSDW(v0 interface{}, v1 interface{}) *Instruction

VPMOVUSDW performs "Down Convert Packed Doubleword Values to Word Values with Unsigned Saturation".

Mnemonic : VPMOVUSDW Supported forms : (6 forms)

func (*Program) VPMOVUSQB 

func (self *Program) VPMOVUSQB(v0 interface{}, v1 interface{}) *Instruction

VPMOVUSQB performs "Down Convert Packed Quadword Values to Byte Values with Unsigned Saturation".

Mnemonic : VPMOVUSQB Supported forms : (6 forms)

func (*Program) VPMOVUSQD 

func (self *Program) VPMOVUSQD(v0 interface{}, v1 interface{}) *Instruction

VPMOVUSQD performs "Down Convert Packed Quadword Values to Doubleword Values with Unsigned Saturation".

Mnemonic : VPMOVUSQD Supported forms : (6 forms)

func (*Program) VPMOVUSQW 

func (self *Program) VPMOVUSQW(v0 interface{}, v1 interface{}) *Instruction

VPMOVUSQW performs "Down Convert Packed Quadword Values to Word Values with Unsigned Saturation".

Mnemonic : VPMOVUSQW Supported forms : (6 forms)

func (*Program) VPMOVUSWB 

func (self *Program) VPMOVUSWB(v0 interface{}, v1 interface{}) *Instruction

VPMOVUSWB performs "Down Convert Packed Word Values to Byte Values with Unsigned Saturation".

Mnemonic : VPMOVUSWB Supported forms : (6 forms)

func (*Program) VPMOVW2M 

func (self *Program) VPMOVW2M(v0 interface{}, v1 interface{}) *Instruction

VPMOVW2M performs "Move Signs of Packed Word Integers to Mask Register".

Mnemonic : VPMOVW2M Supported forms : (3 forms)

func (*Program) VPMOVWB 

func (self *Program) VPMOVWB(v0 interface{}, v1 interface{}) *Instruction

VPMOVWB performs "Down Convert Packed Word Values to Byte Values with Truncation".

Mnemonic : VPMOVWB Supported forms : (6 forms)

func (*Program) VPMOVZXBD 

func (self *Program) VPMOVZXBD(v0 interface{}, v1 interface{}) *Instruction

VPMOVZXBD performs "Move Packed Byte Integers to Doubleword Integers with Zero Extension".

Mnemonic : VPMOVZXBD Supported forms : (10 forms)

func (*Program) VPMOVZXBQ 

func (self *Program) VPMOVZXBQ(v0 interface{}, v1 interface{}) *Instruction

VPMOVZXBQ performs "Move Packed Byte Integers to Quadword Integers with Zero Extension".

Mnemonic : VPMOVZXBQ Supported forms : (10 forms)

func (*Program) VPMOVZXBW 

func (self *Program) VPMOVZXBW(v0 interface{}, v1 interface{}) *Instruction

VPMOVZXBW performs "Move Packed Byte Integers to Word Integers with Zero Extension".

Mnemonic : VPMOVZXBW Supported forms : (10 forms)

func (*Program) VPMOVZXDQ 

func (self *Program) VPMOVZXDQ(v0 interface{}, v1 interface{}) *Instruction

VPMOVZXDQ performs "Move Packed Doubleword Integers to Quadword Integers with Zero Extension".

Mnemonic : VPMOVZXDQ Supported forms : (10 forms)

func (*Program) VPMOVZXWD 

func (self *Program) VPMOVZXWD(v0 interface{}, v1 interface{}) *Instruction

VPMOVZXWD performs "Move Packed Word Integers to Doubleword Integers with Zero Extension".

Mnemonic : VPMOVZXWD Supported forms : (10 forms)

func (*Program) VPMOVZXWQ 

func (self *Program) VPMOVZXWQ(v0 interface{}, v1 interface{}) *Instruction

VPMOVZXWQ performs "Move Packed Word Integers to Quadword Integers with Zero Extension".

Mnemonic : VPMOVZXWQ Supported forms : (10 forms)

func (*Program) VPMULDQ 

func (self *Program) VPMULDQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPMULDQ performs "Multiply Packed Signed Doubleword Integers and Store Quadword Result".

Mnemonic : VPMULDQ Supported forms : (10 forms)

func (*Program) VPMULHRSW 

func (self *Program) VPMULHRSW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPMULHRSW performs "Packed Multiply Signed Word Integers and Store High Result with Round and Scale".

Mnemonic : VPMULHRSW Supported forms : (10 forms)

func (*Program) VPMULHUW 

func (self *Program) VPMULHUW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPMULHUW performs "Multiply Packed Unsigned Word Integers and Store High Result".

Mnemonic : VPMULHUW Supported forms : (10 forms)

func (*Program) VPMULHW 

func (self *Program) VPMULHW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPMULHW performs "Multiply Packed Signed Word Integers and Store High Result".

Mnemonic : VPMULHW Supported forms : (10 forms)

func (*Program) VPMULLD 

func (self *Program) VPMULLD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPMULLD performs "Multiply Packed Signed Doubleword Integers and Store Low Result".

Mnemonic : VPMULLD Supported forms : (10 forms)

func (*Program) VPMULLQ 

func (self *Program) VPMULLQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPMULLQ performs "Multiply Packed Signed Quadword Integers and Store Low Result".

Mnemonic : VPMULLQ Supported forms : (6 forms)

func (*Program) VPMULLW 

func (self *Program) VPMULLW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPMULLW performs "Multiply Packed Signed Word Integers and Store Low Result".

Mnemonic : VPMULLW Supported forms : (10 forms)

func (*Program) VPMULTISHIFTQB 

func (self *Program) VPMULTISHIFTQB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPMULTISHIFTQB performs "Select Packed Unaligned Bytes from Quadword Sources".

Mnemonic : VPMULTISHIFTQB Supported forms : (6 forms)

func (*Program) VPMULUDQ 

func (self *Program) VPMULUDQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPMULUDQ performs "Multiply Packed Unsigned Doubleword Integers".

Mnemonic : VPMULUDQ Supported forms : (10 forms)

func (*Program) VPOPCNTD 

func (self *Program) VPOPCNTD(v0 interface{}, v1 interface{}) *Instruction

VPOPCNTD performs "Packed Population Count for Doubleword Integers".

Mnemonic : VPOPCNTD Supported forms : (2 forms)

func (*Program) VPOPCNTQ 

func (self *Program) VPOPCNTQ(v0 interface{}, v1 interface{}) *Instruction

VPOPCNTQ performs "Packed Population Count for Quadword Integers".

Mnemonic : VPOPCNTQ Supported forms : (2 forms)

func (*Program) VPOR 

func (self *Program) VPOR(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPOR performs "Packed Bitwise Logical OR".

Mnemonic : VPOR Supported forms : (4 forms)

func (*Program) VPORD 

func (self *Program) VPORD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPORD performs "Bitwise Logical OR of Packed Doubleword Integers".

Mnemonic : VPORD Supported forms : (6 forms)

func (*Program) VPORQ 

func (self *Program) VPORQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPORQ performs "Bitwise Logical OR of Packed Quadword Integers".

Mnemonic : VPORQ Supported forms : (6 forms)

func (*Program) VPPERM 

func (self *Program) VPPERM(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VPPERM performs "Packed Permute Bytes".

Mnemonic : VPPERM Supported forms : (3 forms)

func (*Program) VPROLD 

func (self *Program) VPROLD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPROLD performs "Rotate Packed Doubleword Left".

Mnemonic : VPROLD Supported forms : (6 forms)

func (*Program) VPROLQ 

func (self *Program) VPROLQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPROLQ performs "Rotate Packed Quadword Left".

Mnemonic : VPROLQ Supported forms : (6 forms)

func (*Program) VPROLVD 

func (self *Program) VPROLVD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPROLVD performs "Variable Rotate Packed Doubleword Left".

Mnemonic : VPROLVD Supported forms : (6 forms)

func (*Program) VPROLVQ 

func (self *Program) VPROLVQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPROLVQ performs "Variable Rotate Packed Quadword Left".

Mnemonic : VPROLVQ Supported forms : (6 forms)

func (*Program) VPRORD 

func (self *Program) VPRORD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPRORD performs "Rotate Packed Doubleword Right".

Mnemonic : VPRORD Supported forms : (6 forms)

func (*Program) VPRORQ 

func (self *Program) VPRORQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPRORQ performs "Rotate Packed Quadword Right".

Mnemonic : VPRORQ Supported forms : (6 forms)

func (*Program) VPRORVD 

func (self *Program) VPRORVD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPRORVD performs "Variable Rotate Packed Doubleword Right".

Mnemonic : VPRORVD Supported forms : (6 forms)

func (*Program) VPRORVQ 

func (self *Program) VPRORVQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPRORVQ performs "Variable Rotate Packed Quadword Right".

Mnemonic : VPRORVQ Supported forms : (6 forms)

func (*Program) VPROTB 

func (self *Program) VPROTB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPROTB performs "Packed Rotate Bytes".

Mnemonic : VPROTB Supported forms : (5 forms)

func (*Program) VPROTD 

func (self *Program) VPROTD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPROTD performs "Packed Rotate Doublewords".

Mnemonic : VPROTD Supported forms : (5 forms)

func (*Program) VPROTQ 

func (self *Program) VPROTQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPROTQ performs "Packed Rotate Quadwords".

Mnemonic : VPROTQ Supported forms : (5 forms)

func (*Program) VPROTW 

func (self *Program) VPROTW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPROTW performs "Packed Rotate Words".

Mnemonic : VPROTW Supported forms : (5 forms)

func (*Program) VPSADBW 

func (self *Program) VPSADBW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPSADBW performs "Compute Sum of Absolute Differences".

Mnemonic : VPSADBW Supported forms : (10 forms)

func (*Program) VPSCATTERDD 

func (self *Program) VPSCATTERDD(v0 interface{}, v1 interface{}) *Instruction

VPSCATTERDD performs "Scatter Packed Doubleword Values with Signed Doubleword Indices".

Mnemonic : VPSCATTERDD Supported forms : (3 forms)

func (*Program) VPSCATTERDQ 

func (self *Program) VPSCATTERDQ(v0 interface{}, v1 interface{}) *Instruction

VPSCATTERDQ performs "Scatter Packed Quadword Values with Signed Doubleword Indices".

Mnemonic : VPSCATTERDQ Supported forms : (3 forms)

func (*Program) VPSCATTERQD 

func (self *Program) VPSCATTERQD(v0 interface{}, v1 interface{}) *Instruction

VPSCATTERQD performs "Scatter Packed Doubleword Values with Signed Quadword Indices".

Mnemonic : VPSCATTERQD Supported forms : (3 forms)

func (*Program) VPSCATTERQQ 

func (self *Program) VPSCATTERQQ(v0 interface{}, v1 interface{}) *Instruction

VPSCATTERQQ performs "Scatter Packed Quadword Values with Signed Quadword Indices".

Mnemonic : VPSCATTERQQ Supported forms : (3 forms)

func (*Program) VPSHAB 

func (self *Program) VPSHAB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPSHAB performs "Packed Shift Arithmetic Bytes".

Mnemonic : VPSHAB Supported forms : (3 forms)

func (*Program) VPSHAD 

func (self *Program) VPSHAD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPSHAD performs "Packed Shift Arithmetic Doublewords".

Mnemonic : VPSHAD Supported forms : (3 forms)

func (*Program) VPSHAQ 

func (self *Program) VPSHAQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPSHAQ performs "Packed Shift Arithmetic Quadwords".

Mnemonic : VPSHAQ Supported forms : (3 forms)

func (*Program) VPSHAW 

func (self *Program) VPSHAW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPSHAW performs "Packed Shift Arithmetic Words".

Mnemonic : VPSHAW Supported forms : (3 forms)

func (*Program) VPSHLB 

func (self *Program) VPSHLB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPSHLB performs "Packed Shift Logical Bytes".

Mnemonic : VPSHLB Supported forms : (3 forms)

func (*Program) VPSHLD 

func (self *Program) VPSHLD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPSHLD performs "Packed Shift Logical Doublewords".

Mnemonic : VPSHLD Supported forms : (3 forms)

func (*Program) VPSHLQ 

func (self *Program) VPSHLQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPSHLQ performs "Packed Shift Logical Quadwords".

Mnemonic : VPSHLQ Supported forms : (3 forms)

func (*Program) VPSHLW 

func (self *Program) VPSHLW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPSHLW performs "Packed Shift Logical Words".

Mnemonic : VPSHLW Supported forms : (3 forms)

func (*Program) VPSHUFB 

func (self *Program) VPSHUFB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPSHUFB performs "Packed Shuffle Bytes".

Mnemonic : VPSHUFB Supported forms : (10 forms)

func (*Program) VPSHUFD 

func (self *Program) VPSHUFD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPSHUFD performs "Shuffle Packed Doublewords".

Mnemonic : VPSHUFD Supported forms : (10 forms)

func (*Program) VPSHUFHW 

func (self *Program) VPSHUFHW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPSHUFHW performs "Shuffle Packed High Words".

Mnemonic : VPSHUFHW Supported forms : (10 forms)

func (*Program) VPSHUFLW 

func (self *Program) VPSHUFLW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPSHUFLW performs "Shuffle Packed Low Words".

Mnemonic : VPSHUFLW Supported forms : (10 forms)

func (*Program) VPSIGNB 

func (self *Program) VPSIGNB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPSIGNB performs "Packed Sign of Byte Integers".

Mnemonic : VPSIGNB Supported forms : (4 forms)

func (*Program) VPSIGND 

func (self *Program) VPSIGND(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPSIGND performs "Packed Sign of Doubleword Integers".

Mnemonic : VPSIGND Supported forms : (4 forms)

func (*Program) VPSIGNW 

func (self *Program) VPSIGNW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPSIGNW performs "Packed Sign of Word Integers".

Mnemonic : VPSIGNW Supported forms : (4 forms)

func (*Program) VPSLLD 

func (self *Program) VPSLLD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPSLLD performs "Shift Packed Doubleword Data Left Logical".

Mnemonic : VPSLLD Supported forms : (18 forms)

func (*Program) VPSLLDQ 

func (self *Program) VPSLLDQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPSLLDQ performs "Shift Packed Double Quadword Left Logical".

Mnemonic : VPSLLDQ Supported forms : (8 forms)

func (*Program) VPSLLQ 

func (self *Program) VPSLLQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPSLLQ performs "Shift Packed Quadword Data Left Logical".

Mnemonic : VPSLLQ Supported forms : (18 forms)

func (*Program) VPSLLVD 

func (self *Program) VPSLLVD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPSLLVD performs "Variable Shift Packed Doubleword Data Left Logical".

Mnemonic : VPSLLVD Supported forms : (10 forms)

func (*Program) VPSLLVQ 

func (self *Program) VPSLLVQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPSLLVQ performs "Variable Shift Packed Quadword Data Left Logical".

Mnemonic : VPSLLVQ Supported forms : (10 forms)

func (*Program) VPSLLVW 

func (self *Program) VPSLLVW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPSLLVW performs "Variable Shift Packed Word Data Left Logical".

Mnemonic : VPSLLVW Supported forms : (6 forms)

func (*Program) VPSLLW 

func (self *Program) VPSLLW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPSLLW performs "Shift Packed Word Data Left Logical".

Mnemonic : VPSLLW Supported forms : (18 forms)

func (*Program) VPSRAD 

func (self *Program) VPSRAD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPSRAD performs "Shift Packed Doubleword Data Right Arithmetic".

Mnemonic : VPSRAD Supported forms : (18 forms)

func (*Program) VPSRAQ 

func (self *Program) VPSRAQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPSRAQ performs "Shift Packed Quadword Data Right Arithmetic".

Mnemonic : VPSRAQ Supported forms : (12 forms)

func (*Program) VPSRAVD 

func (self *Program) VPSRAVD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPSRAVD performs "Variable Shift Packed Doubleword Data Right Arithmetic".

Mnemonic : VPSRAVD Supported forms : (10 forms)

func (*Program) VPSRAVQ 

func (self *Program) VPSRAVQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPSRAVQ performs "Variable Shift Packed Quadword Data Right Arithmetic".

Mnemonic : VPSRAVQ Supported forms : (6 forms)

func (*Program) VPSRAVW 

func (self *Program) VPSRAVW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPSRAVW performs "Variable Shift Packed Word Data Right Arithmetic".

Mnemonic : VPSRAVW Supported forms : (6 forms)

func (*Program) VPSRAW 

func (self *Program) VPSRAW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPSRAW performs "Shift Packed Word Data Right Arithmetic".

Mnemonic : VPSRAW Supported forms : (18 forms)

func (*Program) VPSRLD 

func (self *Program) VPSRLD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPSRLD performs "Shift Packed Doubleword Data Right Logical".

Mnemonic : VPSRLD Supported forms : (18 forms)

func (*Program) VPSRLDQ 

func (self *Program) VPSRLDQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPSRLDQ performs "Shift Packed Double Quadword Right Logical".

Mnemonic : VPSRLDQ Supported forms : (8 forms)

func (*Program) VPSRLQ 

func (self *Program) VPSRLQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPSRLQ performs "Shift Packed Quadword Data Right Logical".

Mnemonic : VPSRLQ Supported forms : (18 forms)

func (*Program) VPSRLVD 

func (self *Program) VPSRLVD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPSRLVD performs "Variable Shift Packed Doubleword Data Right Logical".

Mnemonic : VPSRLVD Supported forms : (10 forms)

func (*Program) VPSRLVQ 

func (self *Program) VPSRLVQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPSRLVQ performs "Variable Shift Packed Quadword Data Right Logical".

Mnemonic : VPSRLVQ Supported forms : (10 forms)

func (*Program) VPSRLVW 

func (self *Program) VPSRLVW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPSRLVW performs "Variable Shift Packed Word Data Right Logical".

Mnemonic : VPSRLVW Supported forms : (6 forms)

func (*Program) VPSRLW 

func (self *Program) VPSRLW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPSRLW performs "Shift Packed Word Data Right Logical".

Mnemonic : VPSRLW Supported forms : (18 forms)

func (*Program) VPSUBB 

func (self *Program) VPSUBB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPSUBB performs "Subtract Packed Byte Integers".

Mnemonic : VPSUBB Supported forms : (10 forms)

func (*Program) VPSUBD 

func (self *Program) VPSUBD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPSUBD performs "Subtract Packed Doubleword Integers".

Mnemonic : VPSUBD Supported forms : (10 forms)

func (*Program) VPSUBQ 

func (self *Program) VPSUBQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPSUBQ performs "Subtract Packed Quadword Integers".

Mnemonic : VPSUBQ Supported forms : (10 forms)

func (*Program) VPSUBSB 

func (self *Program) VPSUBSB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPSUBSB performs "Subtract Packed Signed Byte Integers with Signed Saturation".

Mnemonic : VPSUBSB Supported forms : (10 forms)

func (*Program) VPSUBSW 

func (self *Program) VPSUBSW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPSUBSW performs "Subtract Packed Signed Word Integers with Signed Saturation".

Mnemonic : VPSUBSW Supported forms : (10 forms)

func (*Program) VPSUBUSB 

func (self *Program) VPSUBUSB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPSUBUSB performs "Subtract Packed Unsigned Byte Integers with Unsigned Saturation".

Mnemonic : VPSUBUSB Supported forms : (10 forms)

func (*Program) VPSUBUSW 

func (self *Program) VPSUBUSW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPSUBUSW performs "Subtract Packed Unsigned Word Integers with Unsigned Saturation".

Mnemonic : VPSUBUSW Supported forms : (10 forms)

func (*Program) VPSUBW 

func (self *Program) VPSUBW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPSUBW performs "Subtract Packed Word Integers".

Mnemonic : VPSUBW Supported forms : (10 forms)

func (*Program) VPTERNLOGD 

func (self *Program) VPTERNLOGD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VPTERNLOGD performs "Bitwise Ternary Logical Operation on Doubleword Values".

Mnemonic : VPTERNLOGD Supported forms : (6 forms)

func (*Program) VPTERNLOGQ 

func (self *Program) VPTERNLOGQ(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VPTERNLOGQ performs "Bitwise Ternary Logical Operation on Quadword Values".

Mnemonic : VPTERNLOGQ Supported forms : (6 forms)

func (*Program) VPTEST 

func (self *Program) VPTEST(v0 interface{}, v1 interface{}) *Instruction

VPTEST performs "Packed Logical Compare".

Mnemonic : VPTEST Supported forms : (4 forms)

func (*Program) VPTESTMB 

func (self *Program) VPTESTMB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPTESTMB performs "Logical AND of Packed Byte Integer Values and Set Mask".

Mnemonic : VPTESTMB Supported forms : (6 forms)

func (*Program) VPTESTMD 

func (self *Program) VPTESTMD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPTESTMD performs "Logical AND of Packed Doubleword Integer Values and Set Mask".

Mnemonic : VPTESTMD Supported forms : (6 forms)

func (*Program) VPTESTMQ 

func (self *Program) VPTESTMQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPTESTMQ performs "Logical AND of Packed Quadword Integer Values and Set Mask".

Mnemonic : VPTESTMQ Supported forms : (6 forms)

func (*Program) VPTESTMW 

func (self *Program) VPTESTMW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPTESTMW performs "Logical AND of Packed Word Integer Values and Set Mask".

Mnemonic : VPTESTMW Supported forms : (6 forms)

func (*Program) VPTESTNMB 

func (self *Program) VPTESTNMB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPTESTNMB performs "Logical NAND of Packed Byte Integer Values and Set Mask".

Mnemonic : VPTESTNMB Supported forms : (6 forms)

func (*Program) VPTESTNMD 

func (self *Program) VPTESTNMD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPTESTNMD performs "Logical NAND of Packed Doubleword Integer Values and Set Mask".

Mnemonic : VPTESTNMD Supported forms : (6 forms)

func (*Program) VPTESTNMQ 

func (self *Program) VPTESTNMQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPTESTNMQ performs "Logical NAND of Packed Quadword Integer Values and Set Mask".

Mnemonic : VPTESTNMQ Supported forms : (6 forms)

func (*Program) VPTESTNMW 

func (self *Program) VPTESTNMW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPTESTNMW performs "Logical NAND of Packed Word Integer Values and Set Mask".

Mnemonic : VPTESTNMW Supported forms : (6 forms)

func (*Program) VPUNPCKHBW 

func (self *Program) VPUNPCKHBW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPUNPCKHBW performs "Unpack and Interleave High-Order Bytes into Words".

Mnemonic : VPUNPCKHBW Supported forms : (10 forms)

func (*Program) VPUNPCKHDQ 

func (self *Program) VPUNPCKHDQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPUNPCKHDQ performs "Unpack and Interleave High-Order Doublewords into Quadwords".

Mnemonic : VPUNPCKHDQ Supported forms : (10 forms)

func (*Program) VPUNPCKHQDQ 

func (self *Program) VPUNPCKHQDQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPUNPCKHQDQ performs "Unpack and Interleave High-Order Quadwords into Double Quadwords".

Mnemonic : VPUNPCKHQDQ Supported forms : (10 forms)

func (*Program) VPUNPCKHWD 

func (self *Program) VPUNPCKHWD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPUNPCKHWD performs "Unpack and Interleave High-Order Words into Doublewords".

Mnemonic : VPUNPCKHWD Supported forms : (10 forms)

func (*Program) VPUNPCKLBW 

func (self *Program) VPUNPCKLBW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPUNPCKLBW performs "Unpack and Interleave Low-Order Bytes into Words".

Mnemonic : VPUNPCKLBW Supported forms : (10 forms)

func (*Program) VPUNPCKLDQ 

func (self *Program) VPUNPCKLDQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPUNPCKLDQ performs "Unpack and Interleave Low-Order Doublewords into Quadwords".

Mnemonic : VPUNPCKLDQ Supported forms : (10 forms)

func (*Program) VPUNPCKLQDQ 

func (self *Program) VPUNPCKLQDQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPUNPCKLQDQ performs "Unpack and Interleave Low-Order Quadwords into Double Quadwords".

Mnemonic : VPUNPCKLQDQ Supported forms : (10 forms)

func (*Program) VPUNPCKLWD 

func (self *Program) VPUNPCKLWD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPUNPCKLWD performs "Unpack and Interleave Low-Order Words into Doublewords".

Mnemonic : VPUNPCKLWD Supported forms : (10 forms)

func (*Program) VPXOR 

func (self *Program) VPXOR(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPXOR performs "Packed Bitwise Logical Exclusive OR".

Mnemonic : VPXOR Supported forms : (4 forms)

func (*Program) VPXORD 

func (self *Program) VPXORD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPXORD performs "Bitwise Logical Exclusive OR of Packed Doubleword Integers".

Mnemonic : VPXORD Supported forms : (6 forms)

func (*Program) VPXORQ 

func (self *Program) VPXORQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPXORQ performs "Bitwise Logical Exclusive OR of Packed Quadword Integers".

Mnemonic : VPXORQ Supported forms : (6 forms)

func (*Program) VRANGEPD 

func (self *Program) VRANGEPD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}, vv ...interface{}) *Instruction

VRANGEPD performs "Range Restriction Calculation For Packed Pairs of Double-Precision Floating-Point Values".

Mnemonic : VRANGEPD Supported forms : (7 forms)

func (*Program) VRANGEPS 

func (self *Program) VRANGEPS(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}, vv ...interface{}) *Instruction

VRANGEPS performs "Range Restriction Calculation For Packed Pairs of Single-Precision Floating-Point Values".

Mnemonic : VRANGEPS Supported forms : (7 forms)

func (*Program) VRANGESD 

func (self *Program) VRANGESD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}, vv ...interface{}) *Instruction

VRANGESD performs "Range Restriction Calculation For a pair of Scalar Double-Precision Floating-Point Values".

Mnemonic : VRANGESD Supported forms : (3 forms)

func (*Program) VRANGESS 

func (self *Program) VRANGESS(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}, vv ...interface{}) *Instruction

VRANGESS performs "Range Restriction Calculation For a pair of Scalar Single-Precision Floating-Point Values".

Mnemonic : VRANGESS Supported forms : (3 forms)

func (*Program) VRCP14PD 

func (self *Program) VRCP14PD(v0 interface{}, v1 interface{}) *Instruction

VRCP14PD performs "Compute Approximate Reciprocals of Packed Double-Precision Floating-Point Values".

Mnemonic : VRCP14PD Supported forms : (6 forms)

func (*Program) VRCP14PS 

func (self *Program) VRCP14PS(v0 interface{}, v1 interface{}) *Instruction

VRCP14PS performs "Compute Approximate Reciprocals of Packed Single-Precision Floating-Point Values".

Mnemonic : VRCP14PS Supported forms : (6 forms)

func (*Program) VRCP14SD 

func (self *Program) VRCP14SD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VRCP14SD performs "Compute Approximate Reciprocal of a Scalar Double-Precision Floating-Point Value".

Mnemonic : VRCP14SD Supported forms : (2 forms)

func (*Program) VRCP14SS 

func (self *Program) VRCP14SS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VRCP14SS performs "Compute Approximate Reciprocal of a Scalar Single-Precision Floating-Point Value".

Mnemonic : VRCP14SS Supported forms : (2 forms)

func (*Program) VRCP28PD 

func (self *Program) VRCP28PD(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction

VRCP28PD performs "Approximation to the Reciprocal of Packed Double-Precision Floating-Point Values with Less Than 2^-28 Relative Error".

Mnemonic : VRCP28PD Supported forms : (3 forms)

func (*Program) VRCP28PS 

func (self *Program) VRCP28PS(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction

VRCP28PS performs "Approximation to the Reciprocal of Packed Single-Precision Floating-Point Values with Less Than 2^-28 Relative Error".

Mnemonic : VRCP28PS Supported forms : (3 forms)

func (*Program) VRCP28SD 

func (self *Program) VRCP28SD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VRCP28SD performs "Approximation to the Reciprocal of a Scalar Double-Precision Floating-Point Value with Less Than 2^-28 Relative Error".

Mnemonic : VRCP28SD Supported forms : (3 forms)

func (*Program) VRCP28SS 

func (self *Program) VRCP28SS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VRCP28SS performs "Approximation to the Reciprocal of a Scalar Single-Precision Floating-Point Value with Less Than 2^-28 Relative Error".

Mnemonic : VRCP28SS Supported forms : (3 forms)

func (*Program) VRCPPS 

func (self *Program) VRCPPS(v0 interface{}, v1 interface{}) *Instruction

VRCPPS performs "Compute Approximate Reciprocals of Packed Single-Precision Floating-Point Values".

Mnemonic : VRCPPS Supported forms : (4 forms)

func (*Program) VRCPSS 

func (self *Program) VRCPSS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VRCPSS performs "Compute Approximate Reciprocal of Scalar Single-Precision Floating-Point Values".

Mnemonic : VRCPSS Supported forms : (2 forms)

func (*Program) VREDUCEPD 

func (self *Program) VREDUCEPD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VREDUCEPD performs "Perform Reduction Transformation on Packed Double-Precision Floating-Point Values".

Mnemonic : VREDUCEPD Supported forms : (6 forms)

func (*Program) VREDUCEPS 

func (self *Program) VREDUCEPS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VREDUCEPS performs "Perform Reduction Transformation on Packed Single-Precision Floating-Point Values".

Mnemonic : VREDUCEPS Supported forms : (6 forms)

func (*Program) VREDUCESD 

func (self *Program) VREDUCESD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VREDUCESD performs "Perform Reduction Transformation on a Scalar Double-Precision Floating-Point Value".

Mnemonic : VREDUCESD Supported forms : (2 forms)

func (*Program) VREDUCESS 

func (self *Program) VREDUCESS(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VREDUCESS performs "Perform Reduction Transformation on a Scalar Single-Precision Floating-Point Value".

Mnemonic : VREDUCESS Supported forms : (2 forms)

func (*Program) VRNDSCALEPD 

func (self *Program) VRNDSCALEPD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VRNDSCALEPD performs "Round Packed Double-Precision Floating-Point Values To Include A Given Number Of Fraction Bits".

Mnemonic : VRNDSCALEPD Supported forms : (7 forms)

func (*Program) VRNDSCALEPS 

func (self *Program) VRNDSCALEPS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VRNDSCALEPS performs "Round Packed Single-Precision Floating-Point Values To Include A Given Number Of Fraction Bits".

Mnemonic : VRNDSCALEPS Supported forms : (7 forms)

func (*Program) VRNDSCALESD 

func (self *Program) VRNDSCALESD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}, vv ...interface{}) *Instruction

VRNDSCALESD performs "Round Scalar Double-Precision Floating-Point Value To Include A Given Number Of Fraction Bits".

Mnemonic : VRNDSCALESD Supported forms : (3 forms)

func (*Program) VRNDSCALESS 

func (self *Program) VRNDSCALESS(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}, vv ...interface{}) *Instruction

VRNDSCALESS performs "Round Scalar Single-Precision Floating-Point Value To Include A Given Number Of Fraction Bits".

Mnemonic : VRNDSCALESS Supported forms : (3 forms)

func (*Program) VROUNDPD 

func (self *Program) VROUNDPD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VROUNDPD performs "Round Packed Double Precision Floating-Point Values".

Mnemonic : VROUNDPD Supported forms : (4 forms)

func (*Program) VROUNDPS 

func (self *Program) VROUNDPS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VROUNDPS performs "Round Packed Single Precision Floating-Point Values".

Mnemonic : VROUNDPS Supported forms : (4 forms)

func (*Program) VROUNDSD 

func (self *Program) VROUNDSD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VROUNDSD performs "Round Scalar Double Precision Floating-Point Values".

Mnemonic : VROUNDSD Supported forms : (2 forms)

func (*Program) VROUNDSS 

func (self *Program) VROUNDSS(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VROUNDSS performs "Round Scalar Single Precision Floating-Point Values".

Mnemonic : VROUNDSS Supported forms : (2 forms)

func (*Program) VRSQRT14PD 

func (self *Program) VRSQRT14PD(v0 interface{}, v1 interface{}) *Instruction

VRSQRT14PD performs "Compute Approximate Reciprocals of Square Roots of Packed Double-Precision Floating-Point Values".

Mnemonic : VRSQRT14PD Supported forms : (6 forms)

func (*Program) VRSQRT14PS 

func (self *Program) VRSQRT14PS(v0 interface{}, v1 interface{}) *Instruction

VRSQRT14PS performs "Compute Approximate Reciprocals of Square Roots of Packed Single-Precision Floating-Point Values".

Mnemonic : VRSQRT14PS Supported forms : (6 forms)

func (*Program) VRSQRT14SD 

func (self *Program) VRSQRT14SD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VRSQRT14SD performs "Compute Approximate Reciprocal of a Square Root of a Scalar Double-Precision Floating-Point Value".

Mnemonic : VRSQRT14SD Supported forms : (2 forms)

func (*Program) VRSQRT14SS 

func (self *Program) VRSQRT14SS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VRSQRT14SS performs "Compute Approximate Reciprocal of a Square Root of a Scalar Single-Precision Floating-Point Value".

Mnemonic : VRSQRT14SS Supported forms : (2 forms)

func (*Program) VRSQRT28PD 

func (self *Program) VRSQRT28PD(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction

VRSQRT28PD performs "Approximation to the Reciprocal Square Root of Packed Double-Precision Floating-Point Values with Less Than 2^-28 Relative Error".

Mnemonic : VRSQRT28PD Supported forms : (3 forms)

func (*Program) VRSQRT28PS 

func (self *Program) VRSQRT28PS(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction

VRSQRT28PS performs "Approximation to the Reciprocal Square Root of Packed Single-Precision Floating-Point Values with Less Than 2^-28 Relative Error".

Mnemonic : VRSQRT28PS Supported forms : (3 forms)

func (*Program) VRSQRT28SD 

func (self *Program) VRSQRT28SD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VRSQRT28SD performs "Approximation to the Reciprocal Square Root of a Scalar Double-Precision Floating-Point Value with Less Than 2^-28 Relative Error".

Mnemonic : VRSQRT28SD Supported forms : (3 forms)

func (*Program) VRSQRT28SS 

func (self *Program) VRSQRT28SS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VRSQRT28SS performs "Approximation to the Reciprocal Square Root of a Scalar Single-Precision Floating-Point Value with Less Than 2^-28 Relative Error".

Mnemonic : VRSQRT28SS Supported forms : (3 forms)

func (*Program) VRSQRTPS 

func (self *Program) VRSQRTPS(v0 interface{}, v1 interface{}) *Instruction

VRSQRTPS performs "Compute Reciprocals of Square Roots of Packed Single-Precision Floating-Point Values".

Mnemonic : VRSQRTPS Supported forms : (4 forms)

func (*Program) VRSQRTSS 

func (self *Program) VRSQRTSS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VRSQRTSS performs "Compute Reciprocal of Square Root of Scalar Single-Precision Floating-Point Value".

Mnemonic : VRSQRTSS Supported forms : (2 forms)

func (*Program) VSCALEFPD 

func (self *Program) VSCALEFPD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VSCALEFPD performs "Scale Packed Double-Precision Floating-Point Values With Double-Precision Floating-Point Values".

Mnemonic : VSCALEFPD Supported forms : (7 forms)

func (*Program) VSCALEFPS 

func (self *Program) VSCALEFPS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VSCALEFPS performs "Scale Packed Single-Precision Floating-Point Values With Single-Precision Floating-Point Values".

Mnemonic : VSCALEFPS Supported forms : (7 forms)

func (*Program) VSCALEFSD 

func (self *Program) VSCALEFSD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VSCALEFSD performs "Scale Scalar Double-Precision Floating-Point Value With a Double-Precision Floating-Point Value".

Mnemonic : VSCALEFSD Supported forms : (3 forms)

func (*Program) VSCALEFSS 

func (self *Program) VSCALEFSS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VSCALEFSS performs "Scale Scalar Single-Precision Floating-Point Value With a Single-Precision Floating-Point Value".

Mnemonic : VSCALEFSS Supported forms : (3 forms)

func (*Program) VSCATTERDPD 

func (self *Program) VSCATTERDPD(v0 interface{}, v1 interface{}) *Instruction

VSCATTERDPD performs "Scatter Packed Double-Precision Floating-Point Values with Signed Doubleword Indices".

Mnemonic : VSCATTERDPD Supported forms : (3 forms)

func (*Program) VSCATTERDPS 

func (self *Program) VSCATTERDPS(v0 interface{}, v1 interface{}) *Instruction

VSCATTERDPS performs "Scatter Packed Single-Precision Floating-Point Values with Signed Doubleword Indices".

Mnemonic : VSCATTERDPS Supported forms : (3 forms)

func (*Program) VSCATTERPF0DPD 

func (self *Program) VSCATTERPF0DPD(v0 interface{}) *Instruction

VSCATTERPF0DPD performs "Sparse Prefetch Packed Double-Precision Floating-Point Data Values with Signed Doubleword Indices Using T0 Hint with Intent to Write".

Mnemonic : VSCATTERPF0DPD Supported forms : (1 form)

func (*Program) VSCATTERPF0DPS 

func (self *Program) VSCATTERPF0DPS(v0 interface{}) *Instruction

VSCATTERPF0DPS performs "Sparse Prefetch Packed Single-Precision Floating-Point Data Values with Signed Doubleword Indices Using T0 Hint with Intent to Write".

Mnemonic : VSCATTERPF0DPS Supported forms : (1 form)

func (*Program) VSCATTERPF0QPD 

func (self *Program) VSCATTERPF0QPD(v0 interface{}) *Instruction

VSCATTERPF0QPD performs "Sparse Prefetch Packed Double-Precision Floating-Point Data Values with Signed Quadword Indices Using T0 Hint with Intent to Write".

Mnemonic : VSCATTERPF0QPD Supported forms : (1 form)

func (*Program) VSCATTERPF0QPS 

func (self *Program) VSCATTERPF0QPS(v0 interface{}) *Instruction

VSCATTERPF0QPS performs "Sparse Prefetch Packed Single-Precision Floating-Point Data Values with Signed Quadword Indices Using T0 Hint with Intent to Write".

Mnemonic : VSCATTERPF0QPS Supported forms : (1 form)

func (*Program) VSCATTERPF1DPD 

func (self *Program) VSCATTERPF1DPD(v0 interface{}) *Instruction

VSCATTERPF1DPD performs "Sparse Prefetch Packed Double-Precision Floating-Point Data Values with Signed Doubleword Indices Using T1 Hint with Intent to Write".

Mnemonic : VSCATTERPF1DPD Supported forms : (1 form)

func (*Program) VSCATTERPF1DPS 

func (self *Program) VSCATTERPF1DPS(v0 interface{}) *Instruction

VSCATTERPF1DPS performs "Sparse Prefetch Packed Single-Precision Floating-Point Data Values with Signed Doubleword Indices Using T1 Hint with Intent to Write".

Mnemonic : VSCATTERPF1DPS Supported forms : (1 form)

func (*Program) VSCATTERPF1QPD 

func (self *Program) VSCATTERPF1QPD(v0 interface{}) *Instruction

VSCATTERPF1QPD performs "Sparse Prefetch Packed Double-Precision Floating-Point Data Values with Signed Quadword Indices Using T1 Hint with Intent to Write".

Mnemonic : VSCATTERPF1QPD Supported forms : (1 form)

func (*Program) VSCATTERPF1QPS 

func (self *Program) VSCATTERPF1QPS(v0 interface{}) *Instruction

VSCATTERPF1QPS performs "Sparse Prefetch Packed Single-Precision Floating-Point Data Values with Signed Quadword Indices Using T1 Hint with Intent to Write".

Mnemonic : VSCATTERPF1QPS Supported forms : (1 form)

func (*Program) VSCATTERQPD 

func (self *Program) VSCATTERQPD(v0 interface{}, v1 interface{}) *Instruction

VSCATTERQPD performs "Scatter Packed Double-Precision Floating-Point Values with Signed Quadword Indices".

Mnemonic : VSCATTERQPD Supported forms : (3 forms)

func (*Program) VSCATTERQPS 

func (self *Program) VSCATTERQPS(v0 interface{}, v1 interface{}) *Instruction

VSCATTERQPS performs "Scatter Packed Single-Precision Floating-Point Values with Signed Quadword Indices".

Mnemonic : VSCATTERQPS Supported forms : (3 forms)

func (*Program) VSHUFF32X4 

func (self *Program) VSHUFF32X4(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VSHUFF32X4 performs "Shuffle 128-Bit Packed Single-Precision Floating-Point Values".

Mnemonic : VSHUFF32X4 Supported forms : (4 forms)

func (*Program) VSHUFF64X2 

func (self *Program) VSHUFF64X2(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VSHUFF64X2 performs "Shuffle 128-Bit Packed Double-Precision Floating-Point Values".

Mnemonic : VSHUFF64X2 Supported forms : (4 forms)

func (*Program) VSHUFI32X4 

func (self *Program) VSHUFI32X4(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VSHUFI32X4 performs "Shuffle 128-Bit Packed Doubleword Integer Values".

Mnemonic : VSHUFI32X4 Supported forms : (4 forms)

func (*Program) VSHUFI64X2 

func (self *Program) VSHUFI64X2(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VSHUFI64X2 performs "Shuffle 128-Bit Packed Quadword Integer Values".

Mnemonic : VSHUFI64X2 Supported forms : (4 forms)

func (*Program) VSHUFPD 

func (self *Program) VSHUFPD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VSHUFPD performs "Shuffle Packed Double-Precision Floating-Point Values".

Mnemonic : VSHUFPD Supported forms : (10 forms)

func (*Program) VSHUFPS 

func (self *Program) VSHUFPS(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VSHUFPS performs "Shuffle Packed Single-Precision Floating-Point Values".

Mnemonic : VSHUFPS Supported forms : (10 forms)

func (*Program) VSQRTPD 

func (self *Program) VSQRTPD(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction

VSQRTPD performs "Compute Square Roots of Packed Double-Precision Floating-Point Values".

Mnemonic : VSQRTPD Supported forms : (11 forms)

func (*Program) VSQRTPS 

func (self *Program) VSQRTPS(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction

VSQRTPS performs "Compute Square Roots of Packed Single-Precision Floating-Point Values".

Mnemonic : VSQRTPS Supported forms : (11 forms)

func (*Program) VSQRTSD 

func (self *Program) VSQRTSD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VSQRTSD performs "Compute Square Root of Scalar Double-Precision Floating-Point Value".

Mnemonic : VSQRTSD Supported forms : (5 forms)

func (*Program) VSQRTSS 

func (self *Program) VSQRTSS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VSQRTSS performs "Compute Square Root of Scalar Single-Precision Floating-Point Value".

Mnemonic : VSQRTSS Supported forms : (5 forms)

func (*Program) VSTMXCSR 

func (self *Program) VSTMXCSR(v0 interface{}) *Instruction

VSTMXCSR performs "Store MXCSR Register State".

Mnemonic : VSTMXCSR Supported forms : (1 form)

func (*Program) VSUBPD 

func (self *Program) VSUBPD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VSUBPD performs "Subtract Packed Double-Precision Floating-Point Values".

Mnemonic : VSUBPD Supported forms : (11 forms)

func (*Program) VSUBPS 

func (self *Program) VSUBPS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VSUBPS performs "Subtract Packed Single-Precision Floating-Point Values".

Mnemonic : VSUBPS Supported forms : (11 forms)

func (*Program) VSUBSD 

func (self *Program) VSUBSD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VSUBSD performs "Subtract Scalar Double-Precision Floating-Point Values".

Mnemonic : VSUBSD Supported forms : (5 forms)

func (*Program) VSUBSS 

func (self *Program) VSUBSS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VSUBSS performs "Subtract Scalar Single-Precision Floating-Point Values".

Mnemonic : VSUBSS Supported forms : (5 forms)

func (*Program) VTESTPD 

func (self *Program) VTESTPD(v0 interface{}, v1 interface{}) *Instruction

VTESTPD performs "Packed Double-Precision Floating-Point Bit Test".

Mnemonic : VTESTPD Supported forms : (4 forms)

func (*Program) VTESTPS 

func (self *Program) VTESTPS(v0 interface{}, v1 interface{}) *Instruction

VTESTPS performs "Packed Single-Precision Floating-Point Bit Test".

Mnemonic : VTESTPS Supported forms : (4 forms)

func (*Program) VUCOMISD 

func (self *Program) VUCOMISD(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction

VUCOMISD performs "Unordered Compare Scalar Double-Precision Floating-Point Values and Set EFLAGS".

Mnemonic : VUCOMISD Supported forms : (5 forms)

func (*Program) VUCOMISS 

func (self *Program) VUCOMISS(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction

VUCOMISS performs "Unordered Compare Scalar Single-Precision Floating-Point Values and Set EFLAGS".

Mnemonic : VUCOMISS Supported forms : (5 forms)

func (*Program) VUNPCKHPD 

func (self *Program) VUNPCKHPD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VUNPCKHPD performs "Unpack and Interleave High Packed Double-Precision Floating-Point Values".

Mnemonic : VUNPCKHPD Supported forms : (10 forms)

func (*Program) VUNPCKHPS 

func (self *Program) VUNPCKHPS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VUNPCKHPS performs "Unpack and Interleave High Packed Single-Precision Floating-Point Values".

Mnemonic : VUNPCKHPS Supported forms : (10 forms)

func (*Program) VUNPCKLPD 

func (self *Program) VUNPCKLPD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VUNPCKLPD performs "Unpack and Interleave Low Packed Double-Precision Floating-Point Values".

Mnemonic : VUNPCKLPD Supported forms : (10 forms)

func (*Program) VUNPCKLPS 

func (self *Program) VUNPCKLPS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VUNPCKLPS performs "Unpack and Interleave Low Packed Single-Precision Floating-Point Values".

Mnemonic : VUNPCKLPS Supported forms : (10 forms)

func (*Program) VXORPD 

func (self *Program) VXORPD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VXORPD performs "Bitwise Logical XOR for Double-Precision Floating-Point Values".

Mnemonic : VXORPD Supported forms : (10 forms)

func (*Program) VXORPS 

func (self *Program) VXORPS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VXORPS performs "Bitwise Logical XOR for Single-Precision Floating-Point Values".

Mnemonic : VXORPS Supported forms : (10 forms)

func (*Program) VZEROALL 

func (self *Program) VZEROALL() *Instruction

VZEROALL performs "Zero All YMM Registers".

Mnemonic : VZEROALL Supported forms : (1 form)

func (*Program) VZEROUPPER 

func (self *Program) VZEROUPPER() *Instruction

VZEROUPPER performs "Zero Upper Bits of YMM Registers".

Mnemonic : VZEROUPPER Supported forms : (1 form)

func (*Program) Word 

func (self *Program) Word(v *expr.Expr) (p *Instruction)

Word is a pseudo-instruction to add raw uint16 as little-endian to the assembled code.

func (*Program) XADDB 

func (self *Program) XADDB(v0 interface{}, v1 interface{}) *Instruction

XADDB performs "Exchange and Add".

Mnemonic : XADD Supported forms : (2 forms)

func (*Program) XADDL 

func (self *Program) XADDL(v0 interface{}, v1 interface{}) *Instruction

XADDL performs "Exchange and Add".

Mnemonic : XADD Supported forms : (2 forms)

func (*Program) XADDQ 

func (self *Program) XADDQ(v0 interface{}, v1 interface{}) *Instruction

XADDQ performs "Exchange and Add".

Mnemonic : XADD Supported forms : (2 forms)

func (*Program) XADDW 

func (self *Program) XADDW(v0 interface{}, v1 interface{}) *Instruction

XADDW performs "Exchange and Add".

Mnemonic : XADD Supported forms : (2 forms)

func (*Program) XCHGB 

func (self *Program) XCHGB(v0 interface{}, v1 interface{}) *Instruction

XCHGB performs "Exchange Register/Memory with Register".

Mnemonic : XCHG Supported forms : (3 forms)

func (*Program) XCHGL 

func (self *Program) XCHGL(v0 interface{}, v1 interface{}) *Instruction

XCHGL performs "Exchange Register/Memory with Register".

Mnemonic : XCHG Supported forms : (5 forms)

func (*Program) XCHGQ 

func (self *Program) XCHGQ(v0 interface{}, v1 interface{}) *Instruction

XCHGQ performs "Exchange Register/Memory with Register".

Mnemonic : XCHG Supported forms : (5 forms)

func (*Program) XCHGW 

func (self *Program) XCHGW(v0 interface{}, v1 interface{}) *Instruction

XCHGW performs "Exchange Register/Memory with Register".

Mnemonic : XCHG Supported forms : (5 forms)

func (*Program) XGETBV 

func (self *Program) XGETBV() *Instruction

XGETBV performs "Get Value of Extended Control Register".

Mnemonic : XGETBV Supported forms : (1 form)

func (*Program) XLATB 

func (self *Program) XLATB() *Instruction

XLATB performs "Table Look-up Translation".

Mnemonic : XLATB Supported forms : (2 forms)

func (*Program) XORB 

func (self *Program) XORB(v0 interface{}, v1 interface{}) *Instruction

XORB performs "Logical Exclusive OR".

Mnemonic : XOR Supported forms : (6 forms)

func (*Program) XORL 

func (self *Program) XORL(v0 interface{}, v1 interface{}) *Instruction

XORL performs "Logical Exclusive OR".

Mnemonic : XOR Supported forms : (8 forms)

func (*Program) XORPD 

func (self *Program) XORPD(v0 interface{}, v1 interface{}) *Instruction

XORPD performs "Bitwise Logical XOR for Double-Precision Floating-Point Values".

Mnemonic : XORPD Supported forms : (2 forms)

func (*Program) XORPS 

func (self *Program) XORPS(v0 interface{}, v1 interface{}) *Instruction

XORPS performs "Bitwise Logical XOR for Single-Precision Floating-Point Values".

Mnemonic : XORPS Supported forms : (2 forms)

func (*Program) XORQ 

func (self *Program) XORQ(v0 interface{}, v1 interface{}) *Instruction

XORQ performs "Logical Exclusive OR".

Mnemonic : XOR Supported forms : (8 forms)

func (*Program) XORW 

func (self *Program) XORW(v0 interface{}, v1 interface{}) *Instruction

XORW performs "Logical Exclusive OR".

Mnemonic : XOR Supported forms : (8 forms)

type Register

Register represents a hardware register. 

type Register interface {
    fmt.Stringer
    // contains filtered or unexported methods
}

type Register16 

type Register16 byte
const (
    AX Register16 = iota
    CX
    DX
    BX
    SP
    BP
    SI
    DI
    R8w
    R9w
    R10w
    R11w
    R12w
    R13w
    R14w
    R15w
)

func (Register16) String 

func (self Register16) String() string

type Register32 

type Register32 byte
const (
    EAX Register32 = iota
    ECX
    EDX
    EBX
    ESP
    EBP
    ESI
    EDI
    R8d
    R9d
    R10d
    R11d
    R12d
    R13d
    R14d
    R15d
)

func (Register32) String 

func (self Register32) String() string

type Register64 

type Register64 byte
const (
    RAX Register64 = iota
    RCX
    RDX
    RBX
    RSP
    RBP
    RSI
    RDI
    R8
    R9
    R10
    R11
    R12
    R13
    R14
    R15
)

func (Register64) String 

func (self Register64) String() string

type Register8 

type Register8 byte
const (
    AL Register8 = iota
    CL
    DL
    BL
    SPL
    BPL
    SIL
    DIL
    R8b
    R9b
    R10b
    R11b
    R12b
    R13b
    R14b
    R15b
)

func (Register8) String 

func (self Register8) String() string

type RegisterMask

RegisterMask is a KRegister used to mask another register. 

type RegisterMask struct {
    Z bool
    K KRegister
}

func (RegisterMask) String 

func (self RegisterMask) String() string

String implements the fmt.Stringer interface.

type RelativeOffset

RelativeOffset represents an RIP-relative offset. 

type RelativeOffset int32

func (RelativeOffset) String 

func (self RelativeOffset) String() string

String implements the fmt.Stringer interface.

type RoundingControl

RoundingControl represents a floating-point rounding option. 

type RoundingControl uint8
const (
    // RN_SAE represents "Round Nearest", which is the default rounding option.
    RN_SAE RoundingControl = iota

    // RD_SAE represents "Round Down".
    RD_SAE

    // RU_SAE represents "Round Up".
    RU_SAE

    // RZ_SAE represents "Round towards Zero".
    RZ_SAE
)

func (RoundingControl) String 

func (self RoundingControl) String() string

type SyntaxError

SyntaxError represents an error in the assembly syntax. 

type SyntaxError struct {
    Pos    int
    Row    int
    Src    []rune
    Reason string
}

func (*SyntaxError) Error 

func (self *SyntaxError) Error() string

Error implements the error interface.

type XMMRegister 

type XMMRegister byte
const (
    XMM0 XMMRegister = iota
    XMM1
    XMM2
    XMM3
    XMM4
    XMM5
    XMM6
    XMM7
    XMM8
    XMM9
    XMM10
    XMM11
    XMM12
    XMM13
    XMM14
    XMM15
    XMM16
    XMM17
    XMM18
    XMM19
    XMM20
    XMM21
    XMM22
    XMM23
    XMM24
    XMM25
    XMM26
    XMM27
    XMM28
    XMM29
    XMM30
    XMM31
)

func (XMMRegister) String 

func (self XMMRegister) String() string

type YMMRegister 

type YMMRegister byte
const (
    YMM0 YMMRegister = iota
    YMM1
    YMM2
    YMM3
    YMM4
    YMM5
    YMM6
    YMM7
    YMM8
    YMM9
    YMM10
    YMM11
    YMM12
    YMM13
    YMM14
    YMM15
    YMM16
    YMM17
    YMM18
    YMM19
    YMM20
    YMM21
    YMM22
    YMM23
    YMM24
    YMM25
    YMM26
    YMM27
    YMM28
    YMM29
    YMM30
    YMM31
)

func (YMMRegister) String 

func (self YMMRegister) String() string

type ZMMRegister 

type ZMMRegister byte
const (
    ZMM0 ZMMRegister = iota
    ZMM1
    ZMM2
    ZMM3
    ZMM4
    ZMM5
    ZMM6
    ZMM7
    ZMM8
    ZMM9
    ZMM10
    ZMM11
    ZMM12
    ZMM13
    ZMM14
    ZMM15
    ZMM16
    ZMM17
    ZMM18
    ZMM19
    ZMM20
    ZMM21
    ZMM22
    ZMM23
    ZMM24
    ZMM25
    ZMM26
    ZMM27
    ZMM28
    ZMM29
    ZMM30
    ZMM31
)

func (ZMMRegister) String 

func (self ZMMRegister) String() string