/*******************************************************************************
* Copyright 2020 FUJITSU LIMITED
*
* Licensed under the Apache License, Version 2.0 (the ""License"");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*     http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an ""AS IS"" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*******************************************************************************/

/*******************************************************************************
* Copyright 2016-2019 Intel Corporation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*     http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*******************************************************************************/

/*******************************************************************************
* Copyright (c) 2007 MITSUNARI Shigeo
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* Redistributions of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
* Neither the name of the copyright owner nor the names of its contributors may
* be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
* THE POSSIBILITY OF SUCH DAMAGE.
*******************************************************************************/

const char *getVersionString() const
{
	return "5.85";
}
void adc(const Operand& op, uint32 imm);
void adc(const Operand& op1, const Operand& op2);
void adcx(const Reg32e& reg, const Operand& op);
void add(const Operand& op, uint32 imm);
void add(const Operand& op1, const Operand& op2);
void addpd(const Xmm& xmm, const Operand& op);
void addps(const Xmm& xmm, const Operand& op);
void addsd(const Xmm& xmm, const Operand& op);
void addss(const Xmm& xmm, const Operand& op);
void addsubpd(const Xmm& xmm, const Operand& op);
void addsubps(const Xmm& xmm, const Operand& op);
void adox(const Reg32e& reg, const Operand& op);
void aesdec(const Xmm& xmm, const Operand& op);
void aesdeclast(const Xmm& xmm, const Operand& op);
void aesenc(const Xmm& xmm, const Operand& op);
void aesenclast(const Xmm& xmm, const Operand& op);
void aesimc(const Xmm& xmm, const Operand& op);
void aeskeygenassist(const Xmm& xmm, const Operand& op, uint8 imm);
void and_(const Operand& op, uint32 imm);
void and_(const Operand& op1, const Operand& op2);
void andn(const Reg32e& r1, const Reg32e& r2, const Operand& op);
void andnpd(const Xmm& xmm, const Operand& op);
void andnps(const Xmm& xmm, const Operand& op);
void andpd(const Xmm& xmm, const Operand& op);
void andps(const Xmm& xmm, const Operand& op);
void bextr(const Reg32e& r1, const Operand& op, const Reg32e& r2);
void blendpd(const Xmm& xmm, const Operand& op, int imm);
void blendps(const Xmm& xmm, const Operand& op, int imm);
void blendvpd(const Xmm& xmm, const Operand& op);
void blendvps(const Xmm& xmm, const Operand& op);
void blsi(const Reg32e& r, const Operand& op);
void blsmsk(const Reg32e& r, const Operand& op);
void blsr(const Reg32e& r, const Operand& op);
void bnd();
void bndcl(const BoundsReg& bnd, const Operand& op);
void bndcn(const BoundsReg& bnd, const Operand& op);
void bndcu(const BoundsReg& bnd, const Operand& op);
void bndldx(const BoundsReg& bnd, const Address& addr);
void bndmk(const BoundsReg& bnd, const Address& addr);
void bndmov(const Address& addr, const BoundsReg& bnd);
void bndmov(const BoundsReg& bnd, const Operand& op);
void bndstx(const Address& addr, const BoundsReg& bnd);
void bsf(const Reg& reg, const Operand& op);
void bsr(const Reg& reg, const Operand& op);
void bswap(const Reg32e& reg);
void bt(const Operand& op, const Reg& reg);
void bt(const Operand& op, uint8 imm);
void btc(const Operand& op, const Reg& reg);
void btc(const Operand& op, uint8 imm);
void btr(const Operand& op, const Reg& reg);
void btr(const Operand& op, uint8 imm);
void bts(const Operand& op, const Reg& reg);
void bts(const Operand& op, uint8 imm);
void bzhi(const Reg32e& r1, const Operand& op, const Reg32e& r2);
void cbw();
void cdq();
void clc();
void cld();
void clflush(const Address& addr);
void clflushopt(const Address& addr);
void cli();
void clzero();
void cmc();
void cmova(const Reg& reg, const Operand& op);
void cmovae(const Reg& reg, const Operand& op);
void cmovb(const Reg& reg, const Operand& op);
void cmovbe(const Reg& reg, const Operand& op);
void cmovc(const Reg& reg, const Operand& op);
void cmove(const Reg& reg, const Operand& op);
void cmovg(const Reg& reg, const Operand& op);
void cmovge(const Reg& reg, const Operand& op);
void cmovl(const Reg& reg, const Operand& op);
void cmovle(const Reg& reg, const Operand& op);
void cmovna(const Reg& reg, const Operand& op);
void cmovnae(const Reg& reg, const Operand& op);
void cmovnb(const Reg& reg, const Operand& op);
void cmovnbe(const Reg& reg, const Operand& op);
void cmovnc(const Reg& reg, const Operand& op);
void cmovne(const Reg& reg, const Operand& op);
void cmovng(const Reg& reg, const Operand& op);
void cmovnge(const Reg& reg, const Operand& op);
void cmovnl(const Reg& reg, const Operand& op);
void cmovnle(const Reg& reg, const Operand& op);
void cmovno(const Reg& reg, const Operand& op);
void cmovnp(const Reg& reg, const Operand& op);
void cmovns(const Reg& reg, const Operand& op);
void cmovnz(const Reg& reg, const Operand& op);
void cmovo(const Reg& reg, const Operand& op);
void cmovp(const Reg& reg, const Operand& op);
void cmovpe(const Reg& reg, const Operand& op);
void cmovpo(const Reg& reg, const Operand& op);
void cmovs(const Reg& reg, const Operand& op);
void cmovz(const Reg& reg, const Operand& op);
void cmp(const Operand& op, uint32 imm);
void cmp(const Operand& op1, const Operand& op2);
void cmpeqpd(const Xmm& x, const Operand& op);
void cmpeqps(const Xmm& x, const Operand& op);
void cmpeqsd(const Xmm& x, const Operand& op);
void cmpeqss(const Xmm& x, const Operand& op);
void cmplepd(const Xmm& x, const Operand& op);
void cmpleps(const Xmm& x, const Operand& op);
void cmplesd(const Xmm& x, const Operand& op);
void cmpless(const Xmm& x, const Operand& op);
void cmpltpd(const Xmm& x, const Operand& op);
void cmpltps(const Xmm& x, const Operand& op);
void cmpltsd(const Xmm& x, const Operand& op);
void cmpltss(const Xmm& x, const Operand& op);
void cmpneqpd(const Xmm& x, const Operand& op);
void cmpneqps(const Xmm& x, const Operand& op);
void cmpneqsd(const Xmm& x, const Operand& op);
void cmpneqss(const Xmm& x, const Operand& op);
void cmpnlepd(const Xmm& x, const Operand& op);
void cmpnleps(const Xmm& x, const Operand& op);
void cmpnlesd(const Xmm& x, const Operand& op);
void cmpnless(const Xmm& x, const Operand& op);
void cmpnltpd(const Xmm& x, const Operand& op);
void cmpnltps(const Xmm& x, const Operand& op);
void cmpnltsd(const Xmm& x, const Operand& op);
void cmpnltss(const Xmm& x, const Operand& op);
void cmpordpd(const Xmm& x, const Operand& op);
void cmpordps(const Xmm& x, const Operand& op);
void cmpordsd(const Xmm& x, const Operand& op);
void cmpordss(const Xmm& x, const Operand& op);
void cmppd(const Xmm& xmm, const Operand& op, uint8 imm8);
void cmpps(const Xmm& xmm, const Operand& op, uint8 imm8);
void cmpsb();
void cmpsd();
void cmpsd(const Xmm& xmm, const Operand& op, uint8 imm8);
void cmpss(const Xmm& xmm, const Operand& op, uint8 imm8);
void cmpsw();
void cmpunordpd(const Xmm& x, const Operand& op);
void cmpunordps(const Xmm& x, const Operand& op);
void cmpunordsd(const Xmm& x, const Operand& op);
void cmpunordss(const Xmm& x, const Operand& op);
void cmpxchg(const Operand& op, const Reg& reg);
void cmpxchg8b(const Address& addr);
void comisd(const Xmm& xmm, const Operand& op);
void comiss(const Xmm& xmm, const Operand& op);
void cpuid();
void crc32(const Reg32e& reg, const Operand& op);
void cvtdq2pd(const Xmm& xmm, const Operand& op);
void cvtdq2ps(const Xmm& xmm, const Operand& op);
void cvtpd2dq(const Xmm& xmm, const Operand& op);
void cvtpd2pi(const Operand& reg, const Operand& op);
void cvtpd2ps(const Xmm& xmm, const Operand& op);
void cvtpi2pd(const Operand& reg, const Operand& op);
void cvtpi2ps(const Operand& reg, const Operand& op);
void cvtps2dq(const Xmm& xmm, const Operand& op);
void cvtps2pd(const Xmm& xmm, const Operand& op);
void cvtps2pi(const Operand& reg, const Operand& op);
void cvtsd2si(const Operand& reg, const Operand& op);
void cvtsd2ss(const Xmm& xmm, const Operand& op);
void cvtsi2sd(const Operand& reg, const Operand& op);
void cvtsi2ss(const Operand& reg, const Operand& op);
void cvtss2sd(const Xmm& xmm, const Operand& op);
void cvtss2si(const Operand& reg, const Operand& op);
void cvttpd2dq(const Xmm& xmm, const Operand& op);
void cvttpd2pi(const Operand& reg, const Operand& op);
void cvttps2dq(const Xmm& xmm, const Operand& op);
void cvttps2pi(const Operand& reg, const Operand& op);
void cvttsd2si(const Operand& reg, const Operand& op);
void cvttss2si(const Operand& reg, const Operand& op);
void cwd();
void cwde();
void dec(const Operand& op);
void div(const Operand& op);
void divpd(const Xmm& xmm, const Operand& op);
void divps(const Xmm& xmm, const Operand& op);
void divsd(const Xmm& xmm, const Operand& op);
void divss(const Xmm& xmm, const Operand& op);
void dppd(const Xmm& xmm, const Operand& op, int imm);
void dpps(const Xmm& xmm, const Operand& op, int imm);
void emms();
void enter(uint16 x, uint8 y);
void extractps(const Operand& op, const Xmm& xmm, uint8 imm);
void f2xm1();
void fabs();
void fadd(const Address& addr);
void fadd(const Fpu& reg1);
void fadd(const Fpu& reg1, const Fpu& reg2);
void faddp();
void faddp(const Fpu& reg1);
void faddp(const Fpu& reg1, const Fpu& reg2);
void fbld(const Address& addr);
void fbstp(const Address& addr);
void fchs();
void fclex();
void fcmovb(const Fpu& reg1);
void fcmovb(const Fpu& reg1, const Fpu& reg2);
void fcmovbe(const Fpu& reg1);
void fcmovbe(const Fpu& reg1, const Fpu& reg2);
void fcmove(const Fpu& reg1);
void fcmove(const Fpu& reg1, const Fpu& reg2);
void fcmovnb(const Fpu& reg1);
void fcmovnb(const Fpu& reg1, const Fpu& reg2);
void fcmovnbe(const Fpu& reg1);
void fcmovnbe(const Fpu& reg1, const Fpu& reg2);
void fcmovne(const Fpu& reg1);
void fcmovne(const Fpu& reg1, const Fpu& reg2);
void fcmovnu(const Fpu& reg1);
void fcmovnu(const Fpu& reg1, const Fpu& reg2);
void fcmovu(const Fpu& reg1);
void fcmovu(const Fpu& reg1, const Fpu& reg2);
void fcom();
void fcom(const Address& addr);
void fcom(const Fpu& reg);
void fcomi(const Fpu& reg1);
void fcomi(const Fpu& reg1, const Fpu& reg2);
void fcomip(const Fpu& reg1);
void fcomip(const Fpu& reg1, const Fpu& reg2);
void fcomp();
void fcomp(const Address& addr);
void fcomp(const Fpu& reg);
void fcompp();
void fcos();
void fdecstp();
void fdiv(const Address& addr);
void fdiv(const Fpu& reg1);
void fdiv(const Fpu& reg1, const Fpu& reg2);
void fdivp();
void fdivp(const Fpu& reg1);
void fdivp(const Fpu& reg1, const Fpu& reg2);
void fdivr(const Address& addr);
void fdivr(const Fpu& reg1);
void fdivr(const Fpu& reg1, const Fpu& reg2);
void fdivrp();
void fdivrp(const Fpu& reg1);
void fdivrp(const Fpu& reg1, const Fpu& reg2);
void ffree(const Fpu& reg);
void fiadd(const Address& addr);
void ficom(const Address& addr);
void ficomp(const Address& addr);
void fidiv(const Address& addr);
void fidivr(const Address& addr);
void fild(const Address& addr);
void fimul(const Address& addr);
void fincstp();
void finit();
void fist(const Address& addr);
void fistp(const Address& addr);
void fisttp(const Address& addr);
void fisub(const Address& addr);
void fisubr(const Address& addr);
void fld(const Address& addr);
void fld(const Fpu& reg);
void fld1();
void fldcw(const Address& addr);
void fldenv(const Address& addr);
void fldl2e();
void fldl2t();
void fldlg2();
void fldln2();
void fldpi();
void fldz();
void fmul(const Address& addr);
void fmul(const Fpu& reg1);
void fmul(const Fpu& reg1, const Fpu& reg2);
void fmulp();
void fmulp(const Fpu& reg1);
void fmulp(const Fpu& reg1, const Fpu& reg2);
void fnclex();
void fninit();
void fnop();
void fnsave(const Address& addr);
void fnstcw(const Address& addr);
void fnstenv(const Address& addr);
void fnstsw(const Address& addr);
void fnstsw(const Reg16& r);
void fpatan();
void fprem();
void fprem1();
void fptan();
void frndint();
void frstor(const Address& addr);
void fsave(const Address& addr);
void fscale();
void fsin();
void fsincos();
void fsqrt();
void fst(const Address& addr);
void fst(const Fpu& reg);
void fstcw(const Address& addr);
void fstenv(const Address& addr);
void fstp(const Address& addr);
void fstp(const Fpu& reg);
void fstsw(const Address& addr);
void fstsw(const Reg16& r);
void fsub(const Address& addr);
void fsub(const Fpu& reg1);
void fsub(const Fpu& reg1, const Fpu& reg2);
void fsubp();
void fsubp(const Fpu& reg1);
void fsubp(const Fpu& reg1, const Fpu& reg2);
void fsubr(const Address& addr);
void fsubr(const Fpu& reg1);
void fsubr(const Fpu& reg1, const Fpu& reg2);
void fsubrp();
void fsubrp(const Fpu& reg1);
void fsubrp(const Fpu& reg1, const Fpu& reg2);
void ftst();
void fucom();
void fucom(const Fpu& reg);
void fucomi(const Fpu& reg1);
void fucomi(const Fpu& reg1, const Fpu& reg2);
void fucomip(const Fpu& reg1);
void fucomip(const Fpu& reg1, const Fpu& reg2);
void fucomp();
void fucomp(const Fpu& reg);
void fucompp();
void fwait();
void fxam();
void fxch();
void fxch(const Fpu& reg);
void fxrstor(const Address& addr);
void fxtract();
void fyl2x();
void fyl2xp1();
void gf2p8affineinvqb(const Xmm& xmm, const Operand& op, int imm);
void gf2p8affineqb(const Xmm& xmm, const Operand& op, int imm);
void gf2p8mulb(const Xmm& xmm, const Operand& op);
void haddpd(const Xmm& xmm, const Operand& op);
void haddps(const Xmm& xmm, const Operand& op);
void hsubpd(const Xmm& xmm, const Operand& op);
void hsubps(const Xmm& xmm, const Operand& op);
void idiv(const Operand& op);
void imul(const Operand& op);
void in_(const Reg& a, const Reg& d);
void in_(const Reg& a, uint8 v);
void inc(const Operand& op);
void insertps(const Xmm& xmm, const Operand& op, uint8 imm);
void int3();
void int_(uint8 x);
void ja(const Label& label, LabelType type = T_AUTO);
void ja(const char *label, LabelType type = T_AUTO);
void ja(const void *addr);
void ja(std::string label, LabelType type = T_AUTO);
void jae(const Label& label, LabelType type = T_AUTO);
void jae(const char *label, LabelType type = T_AUTO);
void jae(const void *addr);
void jae(std::string label, LabelType type = T_AUTO);
void jb(const Label& label, LabelType type = T_AUTO);
void jb(const char *label, LabelType type = T_AUTO);
void jb(const void *addr);
void jb(std::string label, LabelType type = T_AUTO);
void jbe(const Label& label, LabelType type = T_AUTO);
void jbe(const char *label, LabelType type = T_AUTO);
void jbe(const void *addr);
void jbe(std::string label, LabelType type = T_AUTO);
void jc(const Label& label, LabelType type = T_AUTO);
void jc(const char *label, LabelType type = T_AUTO);
void jc(const void *addr);
void jc(std::string label, LabelType type = T_AUTO);
void je(const Label& label, LabelType type = T_AUTO);
void je(const char *label, LabelType type = T_AUTO);
void je(const void *addr);
void je(std::string label, LabelType type = T_AUTO);
void jg(const Label& label, LabelType type = T_AUTO);
void jg(const char *label, LabelType type = T_AUTO);
void jg(const void *addr);
void jg(std::string label, LabelType type = T_AUTO);
void jge(const Label& label, LabelType type = T_AUTO);
void jge(const char *label, LabelType type = T_AUTO);
void jge(const void *addr);
void jge(std::string label, LabelType type = T_AUTO);
void jl(const Label& label, LabelType type = T_AUTO);
void jl(const char *label, LabelType type = T_AUTO);
void jl(const void *addr);
void jl(std::string label, LabelType type = T_AUTO);
void jle(const Label& label, LabelType type = T_AUTO);
void jle(const char *label, LabelType type = T_AUTO);
void jle(const void *addr);
void jle(std::string label, LabelType type = T_AUTO);
void jna(const Label& label, LabelType type = T_AUTO);
void jna(const char *label, LabelType type = T_AUTO);
void jna(const void *addr);
void jna(std::string label, LabelType type = T_AUTO);
void jnae(const Label& label, LabelType type = T_AUTO);
void jnae(const char *label, LabelType type = T_AUTO);
void jnae(const void *addr);
void jnae(std::string label, LabelType type = T_AUTO);
void jnb(const Label& label, LabelType type = T_AUTO);
void jnb(const char *label, LabelType type = T_AUTO);
void jnb(const void *addr);
void jnb(std::string label, LabelType type = T_AUTO);
void jnbe(const Label& label, LabelType type = T_AUTO);
void jnbe(const char *label, LabelType type = T_AUTO);
void jnbe(const void *addr);
void jnbe(std::string label, LabelType type = T_AUTO);
void jnc(const Label& label, LabelType type = T_AUTO);
void jnc(const char *label, LabelType type = T_AUTO);
void jnc(const void *addr);
void jnc(std::string label, LabelType type = T_AUTO);
void jne(const Label& label, LabelType type = T_AUTO);
void jne(const char *label, LabelType type = T_AUTO);
void jne(const void *addr);
void jne(std::string label, LabelType type = T_AUTO);
void jng(const Label& label, LabelType type = T_AUTO);
void jng(const char *label, LabelType type = T_AUTO);
void jng(const void *addr);
void jng(std::string label, LabelType type = T_AUTO);
void jnge(const Label& label, LabelType type = T_AUTO);
void jnge(const char *label, LabelType type = T_AUTO);
void jnge(const void *addr);
void jnge(std::string label, LabelType type = T_AUTO);
void jnl(const Label& label, LabelType type = T_AUTO);
void jnl(const char *label, LabelType type = T_AUTO);
void jnl(const void *addr);
void jnl(std::string label, LabelType type = T_AUTO);
void jnle(const Label& label, LabelType type = T_AUTO);
void jnle(const char *label, LabelType type = T_AUTO);
void jnle(const void *addr);
void jnle(std::string label, LabelType type = T_AUTO);
void jno(const Label& label, LabelType type = T_AUTO);
void jno(const char *label, LabelType type = T_AUTO);
void jno(const void *addr);
void jno(std::string label, LabelType type = T_AUTO);
void jnp(const Label& label, LabelType type = T_AUTO);
void jnp(const char *label, LabelType type = T_AUTO);
void jnp(const void *addr);
void jnp(std::string label, LabelType type = T_AUTO);
void jns(const Label& label, LabelType type = T_AUTO);
void jns(const char *label, LabelType type = T_AUTO);
void jns(const void *addr);
void jns(std::string label, LabelType type = T_AUTO);
void jnz(const Label& label, LabelType type = T_AUTO);
void jnz(const char *label, LabelType type = T_AUTO);
void jnz(const void *addr);
void jnz(std::string label, LabelType type = T_AUTO);
void jo(const Label& label, LabelType type = T_AUTO);
void jo(const char *label, LabelType type = T_AUTO);
void jo(const void *addr);
void jo(std::string label, LabelType type = T_AUTO);
/* Does AArch64 has parity flag? */
void jp(const Label& label, LabelType type = T_AUTO);
void jp(const char *label, LabelType type = T_AUTO);
void jp(const void *addr);
void jp(std::string label, LabelType type = T_AUTO);
void jpe(const Label& label, LabelType type = T_AUTO);
void jpe(const char *label, LabelType type = T_AUTO);
void jpe(const void *addr);
void jpe(std::string label, LabelType type = T_AUTO);
void jpo(const Label& label, LabelType type = T_AUTO);
void jpo(const char *label, LabelType type = T_AUTO);
void jpo(const void *addr);
void jpo(std::string label, LabelType type = T_AUTO);
void js(const Label& label, LabelType type = T_AUTO);
void js(const char *label, LabelType type = T_AUTO);
void js(const void *addr);
void js(std::string label, LabelType type = T_AUTO);
/* AArch64 CPU has no zero flag jmp instruction. */
void jz(const Label& label, LabelType type = T_AUTO);
void jz(const char *label, LabelType type = T_AUTO);
void jz(const void *addr);
void jz(std::string label, LabelType type = T_AUTO);
void lahf();
void lddqu(const Xmm& xmm, const Address& addr);
void ldmxcsr(const Address& addr);
void lea(const Reg& reg, const Address& addr);
void leave();
void lfence();
void lfs(const Reg& reg, const Address& addr);
void lgs(const Reg& reg, const Address& addr);
void lock();
void lodsb();
void lodsd();
void lodsw();
void loop(const Label& label);
void loop(const char *label);
void loop(std::string label);
void loope(const Label& label);
void loope(const char *label);
void loope(std::string label);
void loopne(const Label& label);
void loopne(const char *label);
void loopne(std::string label);
void lss(const Reg& reg, const Address& addr);
void lzcnt(const Reg& reg, const Operand& op);
void maskmovdqu(const Xmm& reg1, const Xmm& reg2);
void maskmovq(const Mmx& reg1, const Mmx& reg2);
void maxpd(const Xmm& xmm, const Operand& op);
void maxps(const Xmm& xmm, const Operand& op);
void maxsd(const Xmm& xmm, const Operand& op);
void maxss(const Xmm& xmm, const Operand& op);
void mfence();
void minpd(const Xmm& xmm, const Operand& op);
void minps(const Xmm& xmm, const Operand& op);
void minsd(const Xmm& xmm, const Operand& op);
void minss(const Xmm& xmm, const Operand& op);
void monitor();
void monitorx();
void movapd(const Address& addr, const Xmm& xmm);
void movapd(const Xmm& xmm, const Operand& op);
void movaps(const Address& addr, const Xmm& xmm);
void movaps(const Xmm& xmm, const Operand& op);
void movbe(const Address& addr, const Reg& reg);
void movbe(const Reg& reg, const Address& addr);
void movd(const Address& addr, const Mmx& mmx);
void movd(const Mmx& mmx, const Address& addr);
void movd(const Mmx& mmx, const Reg32& reg);
void movd(const Reg32& reg, const Mmx& mmx);
void movddup(const Xmm& xmm, const Operand& op);
void movdq2q(const Mmx& mmx, const Xmm& xmm);
void movdqa(const Address& addr, const Xmm& xmm);
void movdqa(const Xmm& xmm, const Operand& op);
void movdqu(const Address& addr, const Xmm& xmm);
void movdqu(const Xmm& xmm, const Operand& op);
void movhlps(const Xmm& reg1, const Xmm& reg2);
void movhpd(const Operand& op1, const Operand& op2);
void movhps(const Operand& op1, const Operand& op2);
void movlhps(const Xmm& reg1, const Xmm& reg2);
void movlpd(const Operand& op1, const Operand& op2);
void movlps(const Operand& op1, const Operand& op2);
void movmskpd(const Reg32e& reg, const Xmm& xmm);
void movmskps(const Reg32e& reg, const Xmm& xmm);
void movntdq(const Address& addr, const Xmm& reg);
void movntdqa(const Xmm& xmm, const Address& addr);
void movnti(const Address& addr, const Reg32e& reg);
void movntpd(const Address& addr, const Xmm& reg);
void movntps(const Address& addr, const Xmm& xmm);
void movntq(const Address& addr, const Mmx& mmx);
void movq(const Address& addr, const Mmx& mmx);
void movq(const Mmx& mmx, const Operand& op);
void movq2dq(const Xmm& xmm, const Mmx& mmx);
void movsb();
void movsd();
void movsd(const Address& addr, const Xmm& xmm);
void movsd(const Xmm& xmm, const Operand& op);
void movshdup(const Xmm& xmm, const Operand& op);
void movsldup(const Xmm& xmm, const Operand& op);
void movss(const Address& addr, const Xmm& xmm);
void movss(const Xmm& xmm, const Operand& op);
void movsw();
void movsx(const Reg& reg, const Operand& op);
void movupd(const Address& addr, const Xmm& xmm);
void movupd(const Xmm& xmm, const Operand& op);
void movups(const Address& addr, const Xmm& xmm);
void movups(const Xmm& xmm, const Operand& op);
void movzx(const Reg& reg, const Operand& op);
void mpsadbw(const Xmm& xmm, const Operand& op, int imm);
void mul(const Operand& op);
void mulpd(const Xmm& xmm, const Operand& op);
void mulps(const Xmm& xmm, const Operand& op);
void mulsd(const Xmm& xmm, const Operand& op);
void mulss(const Xmm& xmm, const Operand& op);
void mulx(const Reg32e& r1, const Reg32e& r2, const Operand& op);
void mwait();
void mwaitx();
void neg(const Operand& op);
void not_(const Operand& op);
void or_(const Operand& op, uint32 imm);
void or_(const Operand& op1, const Operand& op2);
void orpd(const Xmm& xmm, const Operand& op);
void orps(const Xmm& xmm, const Operand& op);
void out_(const Reg& d, const Reg& a);
void out_(uint8 v, const Reg& a);
void outsb();
void outsd();
void outsw();
void pabsb(const Mmx& mmx, const Operand& op);
void pabsd(const Mmx& mmx, const Operand& op);
void pabsw(const Mmx& mmx, const Operand& op);
void packssdw(const Mmx& mmx, const Operand& op);
void packsswb(const Mmx& mmx, const Operand& op);
void packusdw(const Xmm& xmm, const Operand& op);
void packuswb(const Mmx& mmx, const Operand& op);
void paddb(const Mmx& mmx, const Operand& op);
void paddd(const Mmx& mmx, const Operand& op);
void paddq(const Mmx& mmx, const Operand& op);
void paddsb(const Mmx& mmx, const Operand& op);
void paddsw(const Mmx& mmx, const Operand& op);
void paddusb(const Mmx& mmx, const Operand& op);
void paddusw(const Mmx& mmx, const Operand& op);
void paddw(const Mmx& mmx, const Operand& op);
void palignr(const Mmx& mmx, const Operand& op, int imm);
void pand(const Mmx& mmx, const Operand& op);
void pandn(const Mmx& mmx, const Operand& op);
void pause();
void pavgb(const Mmx& mmx, const Operand& op);
void pavgw(const Mmx& mmx, const Operand& op);
void pblendvb(const Xmm& xmm, const Operand& op);
void pblendw(const Xmm& xmm, const Operand& op, int imm);
void pclmulhqhdq(const Xmm& xmm, const Operand& op);
void pclmulhqlqdq(const Xmm& xmm, const Operand& op);
void pclmullqhdq(const Xmm& xmm, const Operand& op);
void pclmullqlqdq(const Xmm& xmm, const Operand& op);
void pclmulqdq(const Xmm& xmm, const Operand& op, int imm);
void pcmpeqb(const Mmx& mmx, const Operand& op);
void pcmpeqd(const Mmx& mmx, const Operand& op);
void pcmpeqq(const Xmm& xmm, const Operand& op);
void pcmpeqw(const Mmx& mmx, const Operand& op);
void pcmpestri(const Xmm& xmm, const Operand& op, uint8 imm);
void pcmpestrm(const Xmm& xmm, const Operand& op, uint8 imm);
void pcmpgtb(const Mmx& mmx, const Operand& op);
void pcmpgtd(const Mmx& mmx, const Operand& op);
void pcmpgtq(const Xmm& xmm, const Operand& op);
void pcmpgtw(const Mmx& mmx, const Operand& op);
void pcmpistri(const Xmm& xmm, const Operand& op, uint8 imm);
void pcmpistrm(const Xmm& xmm, const Operand& op, uint8 imm);
void pdep(const Reg32e& r1, const Reg32e& r2, const Operand& op);
void pext(const Reg32e& r1, const Reg32e& r2, const Operand& op);
void pextrb(const Operand& op, const Xmm& xmm, uint8 imm);
void pextrd(const Operand& op, const Xmm& xmm, uint8 imm);
void pextrw(const Operand& op, const Mmx& xmm, uint8 imm);
void phaddd(const Mmx& mmx, const Operand& op);
void phaddsw(const Mmx& mmx, const Operand& op);
void phaddw(const Mmx& mmx, const Operand& op);
void phminposuw(const Xmm& xmm, const Operand& op);
void phsubd(const Mmx& mmx, const Operand& op);
void phsubsw(const Mmx& mmx, const Operand& op);
void phsubw(const Mmx& mmx, const Operand& op);
void pinsrb(const Xmm& xmm, const Operand& op, uint8 imm);
void pinsrd(const Xmm& xmm, const Operand& op, uint8 imm);
void pinsrw(const Mmx& mmx, const Operand& op, int imm);
void pmaddubsw(const Mmx& mmx, const Operand& op);
void pmaddwd(const Mmx& mmx, const Operand& op);
void pmaxsb(const Xmm& xmm, const Operand& op);
void pmaxsd(const Xmm& xmm, const Operand& op);
void pmaxsw(const Mmx& mmx, const Operand& op);
void pmaxub(const Mmx& mmx, const Operand& op);
void pmaxud(const Xmm& xmm, const Operand& op);
void pmaxuw(const Xmm& xmm, const Operand& op);
void pminsb(const Xmm& xmm, const Operand& op);
void pminsd(const Xmm& xmm, const Operand& op);
void pminsw(const Mmx& mmx, const Operand& op);
void pminub(const Mmx& mmx, const Operand& op);
void pminud(const Xmm& xmm, const Operand& op);
void pminuw(const Xmm& xmm, const Operand& op);
void pmovmskb(const Reg32e& reg, const Mmx& mmx);
void pmovsxbd(const Xmm& xmm, const Operand& op);
void pmovsxbq(const Xmm& xmm, const Operand& op);
void pmovsxbw(const Xmm& xmm, const Operand& op);
void pmovsxdq(const Xmm& xmm, const Operand& op);
void pmovsxwd(const Xmm& xmm, const Operand& op);
void pmovsxwq(const Xmm& xmm, const Operand& op);
void pmovzxbd(const Xmm& xmm, const Operand& op);
void pmovzxbq(const Xmm& xmm, const Operand& op);
void pmovzxbw(const Xmm& xmm, const Operand& op);
void pmovzxdq(const Xmm& xmm, const Operand& op);
void pmovzxwd(const Xmm& xmm, const Operand& op);
void pmovzxwq(const Xmm& xmm, const Operand& op);
void pmuldq(const Xmm& xmm, const Operand& op);
void pmulhrsw(const Mmx& mmx, const Operand& op);
void pmulhuw(const Mmx& mmx, const Operand& op);
void pmulhw(const Mmx& mmx, const Operand& op);
void pmulld(const Xmm& xmm, const Operand& op);
void pmullw(const Mmx& mmx, const Operand& op);
void pmuludq(const Mmx& mmx, const Operand& op);
void popcnt(const Reg& reg, const Operand& op);
void popf();
void por(const Mmx& mmx, const Operand& op);
void prefetchnta(const Address& addr);
void prefetcht0(const Address& addr);
void prefetcht1(const Address& addr);
void prefetcht2(const Address& addr);
void prefetchw(const Address& addr);
void prefetchwt1(const Address& addr);
void psadbw(const Mmx& mmx, const Operand& op);
void pshufb(const Mmx& mmx, const Operand& op);
void pshufd(const Mmx& mmx, const Operand& op, uint8 imm8);
void pshufhw(const Mmx& mmx, const Operand& op, uint8 imm8);
void pshuflw(const Mmx& mmx, const Operand& op, uint8 imm8);
void pshufw(const Mmx& mmx, const Operand& op, uint8 imm8);
void psignb(const Mmx& mmx, const Operand& op);
void psignd(const Mmx& mmx, const Operand& op);
void psignw(const Mmx& mmx, const Operand& op);
void pslld(const Mmx& mmx, const Operand& op);
void pslld(const Mmx& mmx, int imm8);
void pslldq(const Xmm& xmm, int imm8);
void psllq(const Mmx& mmx, const Operand& op);
void psllq(const Mmx& mmx, int imm8);
void psllw(const Mmx& mmx, const Operand& op);
void psllw(const Mmx& mmx, int imm8);
void psrad(const Mmx& mmx, const Operand& op);
void psrad(const Mmx& mmx, int imm8);
void psraw(const Mmx& mmx, const Operand& op);
void psraw(const Mmx& mmx, int imm8);
void psrld(const Mmx& mmx, const Operand& op);
void psrld(const Mmx& mmx, int imm8);
void psrldq(const Xmm& xmm, int imm8);
void psrlq(const Mmx& mmx, const Operand& op);
void psrlq(const Mmx& mmx, int imm8);
void psrlw(const Mmx& mmx, const Operand& op);
void psrlw(const Mmx& mmx, int imm8);
void psubb(const Mmx& mmx, const Operand& op);
void psubd(const Mmx& mmx, const Operand& op);
void psubq(const Mmx& mmx, const Operand& op);
void psubsb(const Mmx& mmx, const Operand& op);
void psubsw(const Mmx& mmx, const Operand& op);
void psubusb(const Mmx& mmx, const Operand& op);
void psubusw(const Mmx& mmx, const Operand& op);
void psubw(const Mmx& mmx, const Operand& op);
void ptest(const Xmm& xmm, const Operand& op);
void punpckhbw(const Mmx& mmx, const Operand& op);
void punpckhdq(const Mmx& mmx, const Operand& op);
void punpckhqdq(const Xmm& xmm, const Operand& op);
void punpckhwd(const Mmx& mmx, const Operand& op);
void punpcklbw(const Mmx& mmx, const Operand& op);
void punpckldq(const Mmx& mmx, const Operand& op);
void punpcklqdq(const Xmm& xmm, const Operand& op);
void punpcklwd(const Mmx& mmx, const Operand& op);
void pushf();
void pxor(const Mmx& mmx, const Operand& op);
void rcl(const Operand& op, const Reg8& _cl);
void rcl(const Operand& op, int imm);
void rcpps(const Xmm& xmm, const Operand& op);
void rcpss(const Xmm& xmm, const Operand& op);
void rcr(const Operand& op, const Reg8& _cl);
void rcr(const Operand& op, int imm);
void rdmsr();
void rdpmc();
void rdrand(const Reg& r);
void rdseed(const Reg& r);
void rdtsc();
void rdtscp();
void rep();
void repe();
void repne();
void repnz();
void repz();
void ret(int imm = 0);
void rol(const Operand& op, const Reg8& _cl);
void rol(const Operand& op, int imm);
void ror(const Operand& op, const Reg8& _cl);
void ror(const Operand& op, int imm);
void rorx(const Reg32e& r, const Operand& op, uint8 imm);
void roundpd(const Xmm& xmm, const Operand& op, uint8 imm);
void roundps(const Xmm& xmm, const Operand& op, uint8 imm);
void roundsd(const Xmm& xmm, const Operand& op, int imm);
void roundss(const Xmm& xmm, const Operand& op, int imm);
void rsqrtps(const Xmm& xmm, const Operand& op);
void rsqrtss(const Xmm& xmm, const Operand& op);
void sahf();
void sal(const Operand& op, const Reg8& _cl);
void sal(const Operand& op, int imm);
void sar(const Operand& op, const Reg8& _cl);
void sar(const Operand& op, int imm);
void sarx(const Reg32e& r1, const Operand& op, const Reg32e& r2);
void sbb(const Operand& op, uint32 imm);
void sbb(const Operand& op1, const Operand& op2);
void scasb();
void scasd();
void scasw();
void seta(const Operand& op);
void setae(const Operand& op);
void setb(const Operand& op);
void setbe(const Operand& op);
void setc(const Operand& op);
void sete(const Operand& op);
void setg(const Operand& op);
void setge(const Operand& op);
void setl(const Operand& op);
void setle(const Operand& op);
void setna(const Operand& op);
void setnae(const Operand& op);
void setnb(const Operand& op);
void setnbe(const Operand& op);
void setnc(const Operand& op);
void setne(const Operand& op);
void setng(const Operand& op);
void setnge(const Operand& op);
void setnl(const Operand& op);
void setnle(const Operand& op);
void setno(const Operand& op);
void setnp(const Operand& op);
void setns(const Operand& op);
void setnz(const Operand& op);
void seto(const Operand& op);
void setp(const Operand& op);
void setpe(const Operand& op);
void setpo(const Operand& op);
void sets(const Operand& op);
void setz(const Operand& op);
void sfence();
void sha1msg1(const Xmm& xmm, const Operand& op);
void sha1msg2(const Xmm& xmm, const Operand& op);
void sha1nexte(const Xmm& xmm, const Operand& op);
void sha1rnds4(const Xmm& xmm, const Operand& op, uint8 imm);
void sha256msg1(const Xmm& xmm, const Operand& op);
void sha256msg2(const Xmm& xmm, const Operand& op);
void sha256rnds2(const Xmm& xmm, const Operand& op);
void shl(const Operand& op, const Reg8& _cl);
void shl(const Operand& op, int imm);
void shld(const Operand& op, const Reg& reg, const Reg8& _cl);
void shld(const Operand& op, const Reg& reg, uint8 imm);
void shlx(const Reg32e& r1, const Operand& op, const Reg32e& r2);
void shr(const Operand& op, const Reg8& _cl);
void shr(const Operand& op, int imm);
void shrd(const Operand& op, const Reg& reg, const Reg8& _cl);
void shrd(const Operand& op, const Reg& reg, uint8 imm);
void shrx(const Reg32e& r1, const Operand& op, const Reg32e& r2);
void shufpd(const Xmm& xmm, const Operand& op, uint8 imm8);
void shufps(const Xmm& xmm, const Operand& op, uint8 imm8);
void sqrtpd(const Xmm& xmm, const Operand& op);
void sqrtps(const Xmm& xmm, const Operand& op);
void sqrtsd(const Xmm& xmm, const Operand& op);
void sqrtss(const Xmm& xmm, const Operand& op);
void stac();
void stc();
void std();
void sti();
void stmxcsr(const Address& addr);
void stosb();
void stosd();
void stosw();
void sub(const Operand& op, uint32 imm);
void sub(const Operand& op1, const Operand& op2);
void subpd(const Xmm& xmm, const Operand& op);
void subps(const Xmm& xmm, const Operand& op);
void subsd(const Xmm& xmm, const Operand& op);
void subss(const Xmm& xmm, const Operand& op);
void sysenter();
void sysexit();
void tzcnt(const Reg& reg, const Operand& op);
void ucomisd(const Xmm& xmm, const Operand& op);
void ucomiss(const Xmm& xmm, const Operand& op);
void ud2();
void unpckhpd(const Xmm& xmm, const Operand& op);
void unpckhps(const Xmm& xmm, const Operand& op);
void unpcklpd(const Xmm& xmm, const Operand& op);
void unpcklps(const Xmm& xmm, const Operand& op);
void vaddpd(const Xmm& xmm, const Operand& op1, const Operand& op2 = Operand());
void vaddps(const Xmm& xmm, const Operand& op1, const Operand& op2 = Operand());
void vaddsd(const Xmm& xmm, const Operand& op1, const Operand& op2 = Operand());
void vaddss(const Xmm& xmm, const Operand& op1, const Operand& op2 = Operand());
void vaddsubpd(const Xmm& xmm, const Operand& op1, const Operand& op2 = Operand());
void vaddsubps(const Xmm& xmm, const Operand& op1, const Operand& op2 = Operand());
void vaesdec(const Xmm& xmm, const Operand& op1, const Operand& op2 = Operand());
void vaesdeclast(const Xmm& xmm, const Operand& op1, const Operand& op2 = Operand());
void vaesenc(const Xmm& xmm, const Operand& op1, const Operand& op2 = Operand());
void vaesenclast(const Xmm& xmm, const Operand& op1, const Operand& op2 = Operand());
void vaesimc(const Xmm& xm, const Operand& op);
void vaeskeygenassist(const Xmm& xm, const Operand& op, uint8 imm);
void vandnpd(const Xmm& xmm, const Operand& op1, const Operand& op2 = Operand());
void vandnps(const Xmm& xmm, const Operand& op1, const Operand& op2 = Operand());
void vandpd(const Xmm& xmm, const Operand& op1, const Operand& op2 = Operand());
void vandps(const Xmm& xmm, const Operand& op1, const Operand& op2 = Operand());
void vblendpd(const Xmm& x1, const Xmm& x2, const Operand& op, uint8 imm);
void vblendps(const Xmm& x1, const Xmm& x2, const Operand& op, uint8 imm);
void vblendvpd(const Xmm& x1, const Xmm& x2, const Operand& op, const Xmm& x4);
void vblendvps(const Xmm& x1, const Xmm& x2, const Operand& op, const Xmm& x4);
void vbroadcastf128(const Ymm& y, const Address& addr);
void vbroadcasti128(const Ymm& y, const Address& addr);
void vbroadcastsd(const Ymm& y, const Operand& op);
void vbroadcastss(const Xmm& x, const Operand& op);
void vcmpeq_ospd(const Xmm& x1, const Xmm& x2, const Operand& op);
void vcmpeq_osps(const Xmm& x1, const Xmm& x2, const Operand& op);
void vcmpeq_ossd(const Xmm& x1, const Xmm& x2, const Operand& op);
void vcmpeq_osss(const Xmm& x1, const Xmm& x2, const Operand& op);
void vcmpeq_uqpd(const Xmm& x1, const Xmm& x2, const Operand& op);
void vcmpeq_uqps(const Xmm& x1, const Xmm& x2, const Operand& op);
void vcmpeq_uqsd(const Xmm& x1, const Xmm& x2, const Operand& op);
void vcmpeq_uqss(const Xmm& x1, const Xmm& x2, const Operand& op);
void vcmpeq_uspd(const Xmm& x1, const Xmm& x2, const Operand& op);
void vcmpeq_usps(const Xmm& x1, const Xmm& x2, const Operand& op);
void vcmpeq_ussd(const Xmm& x1, const Xmm& x2, const Operand& op);
void vcmpeq_usss(const Xmm& x1, const Xmm& x2, const Operand& op);
void vcmpeqpd(const Xmm& x1, const Xmm& x2, const Operand& op);
void vcmpeqps(const Xmm& x1, const Xmm& x2, const Operand& op);
void vcmpeqsd(const Xmm& x1, const Xmm& x2, const Operand& op);
void vcmpeqss(const Xmm& x1, const Xmm& x2, const Operand& op);
void vcmpfalse_ospd(const Xmm& x1, const Xmm& x2, const Operand& op);
void vcmpfalse_osps(const Xmm& x1, const Xmm& x2, const Operand& op);
void vcmpfalse_ossd(const Xmm& x1, const Xmm& x2, const Operand& op);
void vcmpfalse_osss(const Xmm& x1, const Xmm& x2, const Operand& op);
void vcmpfalsepd(const Xmm& x1, const Xmm& x2, const Operand& op);
void vcmpfalseps(const Xmm& x1, const Xmm& x2, const Operand& op);
void vcmpfalsesd(const Xmm& x1, const Xmm& x2, const Operand& op);
void vcmpfalsess(const Xmm& x1, const Xmm& x2, const Operand& op);
void vcmpge_oqpd(const Xmm& x1, const Xmm& x2, const Operand& op);
void vcmpge_oqps(const Xmm& x1, const Xmm& x2, const Operand& op);
void vcmpge_oqsd(const Xmm& x1, const Xmm& x2, const Operand& op);
void vcmpge_oqss(const Xmm& x1, const Xmm& x2, const Operand& op);
void vcmpgepd(const Xmm& x1, const Xmm& x2, const Operand& op);
void vcmpgeps(const Xmm& x1, const Xmm& x2, const Operand& op);
void vcmpgesd(const Xmm& x1, const Xmm& x2, const Operand& op);
void vcmpgess(const Xmm& x1, const Xmm& x2, const Operand& op);
void vcmpgt_oqpd(const Xmm& x1, const Xmm& x2, const Operand& op);
void vcmpgt_oqps(const Xmm& x1, const Xmm& x2, const Operand& op);
void vcmpgt_oqsd(const Xmm& x1, const Xmm& x2, const Operand& op);
void vcmpgt_oqss(const Xmm& x1, const Xmm& x2, const Operand& op);
void vcmpgtpd(const Xmm& x1, const Xmm& x2, const Operand& op);
void vcmpgtps(const Xmm& x1, const Xmm& x2, const Operand& op);
void vcmpgtsd(const Xmm& x1, const Xmm& x2, const Operand& op);
void vcmpgtss(const Xmm& x1, const Xmm& x2, const Operand& op);
void vcmple_oqpd(const Xmm& x1, const Xmm& x2, const Operand& op);
void vcmple_oqps(const Xmm& x1, const Xmm& x2, const Operand& op);
void vcmple_oqsd(const Xmm& x1, const Xmm& x2, const Operand& op);
void vcmple_oqss(const Xmm& x1, const Xmm& x2, const Operand& op);
void vcmplepd(const Xmm& x1, const Xmm& x2, const Operand& op);
void vcmpleps(const Xmm& x1, const Xmm& x2, const Operand& op);
void vcmplesd(const Xmm& x1, const Xmm& x2, const Operand& op);
void vcmpless(const Xmm& x1, const Xmm& x2, const Operand& op);
void vcmplt_oqpd(const Xmm& x1, const Xmm& x2, const Operand& op);
void vcmplt_oqps(const Xmm& x1, const Xmm& x2, const Operand& op);
void vcmplt_oqsd(const Xmm& x1, const Xmm& x2, const Operand& op);
void vcmplt_oqss(const Xmm& x1, const Xmm& x2, const Operand& op);
void vcmpltpd(const Xmm& x1, const Xmm& x2, const Operand& op);
void vcmpltps(const Xmm& x1, const Xmm& x2, const Operand& op);
void vcmpltsd(const Xmm& x1, const Xmm& x2, const Operand& op);
void vcmpltss(const Xmm& x1, const Xmm& x2, const Operand& op);
void vcmpneq_oqpd(const Xmm& x1, const Xmm& x2, const Operand& op);
void vcmpneq_oqps(const Xmm& x1, const Xmm& x2, const Operand& op);
void vcmpneq_oqsd(const Xmm& x1, const Xmm& x2, const Operand& op);
void vcmpneq_oqss(const Xmm& x1, const Xmm& x2, const Operand& op);
void vcmpneq_ospd(const Xmm& x1, const Xmm& x2, const Operand& op);
void vcmpneq_osps(const Xmm& x1, const Xmm& x2, const Operand& op);
void vcmpneq_ossd(const Xmm& x1, const Xmm& x2, const Operand& op);
void vcmpneq_osss(const Xmm& x1, const Xmm& x2, const Operand& op);
void vcmpneq_uspd(const Xmm& x1, const Xmm& x2, const Operand& op);
void vcmpneq_usps(const Xmm& x1, const Xmm& x2, const Operand& op);
void vcmpneq_ussd(const Xmm& x1, const Xmm& x2, const Operand& op);
void vcmpneq_usss(const Xmm& x1, const Xmm& x2, const Operand& op);
void vcmpneqpd(const Xmm& x1, const Xmm& x2, const Operand& op);
void vcmpneqps(const Xmm& x1, const Xmm& x2, const Operand& op);
void vcmpneqsd(const Xmm& x1, const Xmm& x2, const Operand& op);
void vcmpneqss(const Xmm& x1, const Xmm& x2, const Operand& op);
void vcmpnge_uqpd(const Xmm& x1, const Xmm& x2, const Operand& op);
void vcmpnge_uqps(const Xmm& x1, const Xmm& x2, const Operand& op);
void vcmpnge_uqsd(const Xmm& x1, const Xmm& x2, const Operand& op);
void vcmpnge_uqss(const Xmm& x1, const Xmm& x2, const Operand& op);
void vcmpngepd(const Xmm& x1, const Xmm& x2, const Operand& op);
void vcmpngeps(const Xmm& x1, const Xmm& x2, const Operand& op);
void vcmpngesd(const Xmm& x1, const Xmm& x2, const Operand& op);
void vcmpngess(const Xmm& x1, const Xmm& x2, const Operand& op);
void vcmpngt_uqpd(const Xmm& x1, const Xmm& x2, const Operand& op);
void vcmpngt_uqps(const Xmm& x1, const Xmm& x2, const Operand& op);
void vcmpngt_uqsd(const Xmm& x1, const Xmm& x2, const Operand& op);
void vcmpngt_uqss(const Xmm& x1, const Xmm& x2, const Operand& op);
void vcmpngtpd(const Xmm& x1, const Xmm& x2, const Operand& op);
void vcmpngtps(const Xmm& x1, const Xmm& x2, const Operand& op);
void vcmpngtsd(const Xmm& x1, const Xmm& x2, const Operand& op);
void vcmpngtss(const Xmm& x1, const Xmm& x2, const Operand& op);
void vcmpnle_uqpd(const Xmm& x1, const Xmm& x2, const Operand& op);
void vcmpnle_uqps(const Xmm& x1, const Xmm& x2, const Operand& op);
void vcmpnle_uqsd(const Xmm& x1, const Xmm& x2, const Operand& op);
void vcmpnle_uqss(const Xmm& x1, const Xmm& x2, const Operand& op);
void vcmpnlepd(const Xmm& x1, const Xmm& x2, const Operand& op);
void vcmpnleps(const Xmm& x1, const Xmm& x2, const Operand& op);
void vcmpnlesd(const Xmm& x1, const Xmm& x2, const Operand& op);
void vcmpnless(const Xmm& x1, const Xmm& x2, const Operand& op);
void vcmpnlt_uqpd(const Xmm& x1, const Xmm& x2, const Operand& op);
void vcmpnlt_uqps(const Xmm& x1, const Xmm& x2, const Operand& op);
void vcmpnlt_uqsd(const Xmm& x1, const Xmm& x2, const Operand& op);
void vcmpnlt_uqss(const Xmm& x1, const Xmm& x2, const Operand& op);
void vcmpnltpd(const Xmm& x1, const Xmm& x2, const Operand& op);
void vcmpnltps(const Xmm& x1, const Xmm& x2, const Operand& op);
void vcmpnltsd(const Xmm& x1, const Xmm& x2, const Operand& op);
void vcmpnltss(const Xmm& x1, const Xmm& x2, const Operand& op);
void vcmpord_spd(const Xmm& x1, const Xmm& x2, const Operand& op);
void vcmpord_sps(const Xmm& x1, const Xmm& x2, const Operand& op);
void vcmpord_ssd(const Xmm& x1, const Xmm& x2, const Operand& op);
void vcmpord_sss(const Xmm& x1, const Xmm& x2, const Operand& op);
void vcmpordpd(const Xmm& x1, const Xmm& x2, const Operand& op);
void vcmpordps(const Xmm& x1, const Xmm& x2, const Operand& op);
void vcmpordsd(const Xmm& x1, const Xmm& x2, const Operand& op);
void vcmpordss(const Xmm& x1, const Xmm& x2, const Operand& op);
void vcmppd(const Xmm& x1, const Xmm& x2, const Operand& op, uint8 imm);
void vcmpps(const Xmm& x1, const Xmm& x2, const Operand& op, uint8 imm);
void vcmpsd(const Xmm& x1, const Xmm& x2, const Operand& op, uint8 imm);
void vcmpss(const Xmm& x1, const Xmm& x2, const Operand& op, uint8 imm);
void vcmptrue_uspd(const Xmm& x1, const Xmm& x2, const Operand& op);
void vcmptrue_usps(const Xmm& x1, const Xmm& x2, const Operand& op);
void vcmptrue_ussd(const Xmm& x1, const Xmm& x2, const Operand& op);
void vcmptrue_usss(const Xmm& x1, const Xmm& x2, const Operand& op);
void vcmptruepd(const Xmm& x1, const Xmm& x2, const Operand& op);
void vcmptrueps(const Xmm& x1, const Xmm& x2, const Operand& op);
void vcmptruesd(const Xmm& x1, const Xmm& x2, const Operand& op);
void vcmptruess(const Xmm& x1, const Xmm& x2, const Operand& op);
void vcmpunord_spd(const Xmm& x1, const Xmm& x2, const Operand& op);
void vcmpunord_sps(const Xmm& x1, const Xmm& x2, const Operand& op);
void vcmpunord_ssd(const Xmm& x1, const Xmm& x2, const Operand& op);
void vcmpunord_sss(const Xmm& x1, const Xmm& x2, const Operand& op);
void vcmpunordpd(const Xmm& x1, const Xmm& x2, const Operand& op);
void vcmpunordps(const Xmm& x1, const Xmm& x2, const Operand& op);
void vcmpunordsd(const Xmm& x1, const Xmm& x2, const Operand& op);
void vcmpunordss(const Xmm& x1, const Xmm& x2, const Operand& op);
void vcomisd(const Xmm& xm, const Operand& op);
void vcomiss(const Xmm& xm, const Operand& op);
void vcvtdq2pd(const Xmm& x, const Operand& op);
void vcvtdq2ps(const Xmm& xm, const Operand& op);
void vcvtpd2dq(const Xmm& x, const Operand& op);
void vcvtpd2ps(const Xmm& x, const Operand& op);
void vcvtph2ps(const Xmm& x, const Operand& op);
void vcvtps2dq(const Xmm& xm, const Operand& op);
void vcvtps2pd(const Xmm& x, const Operand& op);
void vcvtps2ph(const Operand& op, const Xmm& x, uint8 imm);
void vcvtsd2si(const Reg32& r, const Operand& op);
void vcvtsd2ss(const Xmm& x1, const Xmm& x2, const Operand& op);
void vcvtsi2sd(const Xmm& x1, const Xmm& x2, const Operand& op);
void vcvtsi2ss(const Xmm& x1, const Xmm& x2, const Operand& op);
void vcvtss2sd(const Xmm& x1, const Xmm& x2, const Operand& op);
void vcvtss2si(const Reg32& r, const Operand& op);
void vcvttpd2dq(const Xmm& x, const Operand& op);
void vcvttps2dq(const Xmm& xm, const Operand& op);
void vcvttsd2si(const Reg32& r, const Operand& op);
void vcvttss2si(const Reg32& r, const Operand& op);
void vdivpd(const Xmm& xmm, const Operand& op1, const Operand& op2 = Operand());
void vdivps(const Xmm& xmm, const Operand& op1, const Operand& op2 = Operand());
void vdivsd(const Xmm& xmm, const Operand& op1, const Operand& op2 = Operand());
void vdivss(const Xmm& xmm, const Operand& op1, const Operand& op2 = Operand());
void vdppd(const Xmm& x1, const Xmm& x2, const Operand& op, uint8 imm);
void vdpps(const Xmm& x1, const Xmm& x2, const Operand& op, uint8 imm);
void vextractf128(const Operand& op, const Ymm& y, uint8 imm);
void vextracti128(const Operand& op, const Ymm& y, uint8 imm);
void vextractps(const Operand& op, const Xmm& x, uint8 imm);
void vfmadd132pd(const Xmm& x1, const Xmm& x2, const Operand& op);
void vfmadd132ps(const Xmm& x1, const Xmm& x2, const Operand& op);
void vfmadd132sd(const Xmm& x1, const Xmm& x2, const Operand& op);
void vfmadd132ss(const Xmm& x1, const Xmm& x2, const Operand& op);
void vfmadd213pd(const Xmm& x1, const Xmm& x2, const Operand& op);
void vfmadd213ps(const Xmm& x1, const Xmm& x2, const Operand& op);
void vfmadd213sd(const Xmm& x1, const Xmm& x2, const Operand& op);
void vfmadd213ss(const Xmm& x1, const Xmm& x2, const Operand& op);
void vfmadd231pd(const Xmm& x1, const Xmm& x2, const Operand& op);
void vfmadd231ps(const Xmm& x1, const Xmm& x2, const Operand& op);
void vfmadd231sd(const Xmm& x1, const Xmm& x2, const Operand& op);
void vfmadd231ss(const Xmm& x1, const Xmm& x2, const Operand& op);
void vfmaddsub132pd(const Xmm& x1, const Xmm& x2, const Operand& op);
void vfmaddsub132ps(const Xmm& x1, const Xmm& x2, const Operand& op);
void vfmaddsub213pd(const Xmm& x1, const Xmm& x2, const Operand& op);
void vfmaddsub213ps(const Xmm& x1, const Xmm& x2, const Operand& op);
void vfmaddsub231pd(const Xmm& x1, const Xmm& x2, const Operand& op);
void vfmaddsub231ps(const Xmm& x1, const Xmm& x2, const Operand& op);
void vfmsub132pd(const Xmm& x1, const Xmm& x2, const Operand& op);
void vfmsub132ps(const Xmm& x1, const Xmm& x2, const Operand& op);
void vfmsub132sd(const Xmm& x1, const Xmm& x2, const Operand& op);
void vfmsub132ss(const Xmm& x1, const Xmm& x2, const Operand& op);
void vfmsub213pd(const Xmm& x1, const Xmm& x2, const Operand& op);
void vfmsub213ps(const Xmm& x1, const Xmm& x2, const Operand& op);
void vfmsub213sd(const Xmm& x1, const Xmm& x2, const Operand& op);
void vfmsub213ss(const Xmm& x1, const Xmm& x2, const Operand& op);
void vfmsub231pd(const Xmm& x1, const Xmm& x2, const Operand& op);
void vfmsub231ps(const Xmm& x1, const Xmm& x2, const Operand& op);
void vfmsub231sd(const Xmm& x1, const Xmm& x2, const Operand& op);
void vfmsub231ss(const Xmm& x1, const Xmm& x2, const Operand& op);
void vfmsubadd132pd(const Xmm& x1, const Xmm& x2, const Operand& op);
void vfmsubadd132ps(const Xmm& x1, const Xmm& x2, const Operand& op);
void vfmsubadd213pd(const Xmm& x1, const Xmm& x2, const Operand& op);
void vfmsubadd213ps(const Xmm& x1, const Xmm& x2, const Operand& op);
void vfmsubadd231pd(const Xmm& x1, const Xmm& x2, const Operand& op);
void vfmsubadd231ps(const Xmm& x1, const Xmm& x2, const Operand& op);
void vfnmadd132pd(const Xmm& x1, const Xmm& x2, const Operand& op);
void vfnmadd132ps(const Xmm& x1, const Xmm& x2, const Operand& op);
void vfnmadd132sd(const Xmm& x1, const Xmm& x2, const Operand& op);
void vfnmadd132ss(const Xmm& x1, const Xmm& x2, const Operand& op);
void vfnmadd213pd(const Xmm& x1, const Xmm& x2, const Operand& op);
void vfnmadd213ps(const Xmm& x1, const Xmm& x2, const Operand& op);
void vfnmadd213sd(const Xmm& x1, const Xmm& x2, const Operand& op);
void vfnmadd213ss(const Xmm& x1, const Xmm& x2, const Operand& op);
void vfnmadd231pd(const Xmm& x1, const Xmm& x2, const Operand& op);
void vfnmadd231ps(const Xmm& x1, const Xmm& x2, const Operand& op);
void vfnmadd231sd(const Xmm& x1, const Xmm& x2, const Operand& op);
void vfnmadd231ss(const Xmm& x1, const Xmm& x2, const Operand& op);
void vfnmsub132pd(const Xmm& x1, const Xmm& x2, const Operand& op);
void vfnmsub132ps(const Xmm& x1, const Xmm& x2, const Operand& op);
void vfnmsub132sd(const Xmm& x1, const Xmm& x2, const Operand& op);
void vfnmsub132ss(const Xmm& x1, const Xmm& x2, const Operand& op);
void vfnmsub213pd(const Xmm& x1, const Xmm& x2, const Operand& op);
void vfnmsub213ps(const Xmm& x1, const Xmm& x2, const Operand& op);
void vfnmsub213sd(const Xmm& x1, const Xmm& x2, const Operand& op);
void vfnmsub213ss(const Xmm& x1, const Xmm& x2, const Operand& op);
void vfnmsub231pd(const Xmm& x1, const Xmm& x2, const Operand& op);
void vfnmsub231ps(const Xmm& x1, const Xmm& x2, const Operand& op);
void vfnmsub231sd(const Xmm& x1, const Xmm& x2, const Operand& op);
void vfnmsub231ss(const Xmm& x1, const Xmm& x2, const Operand& op);
void vgatherdpd(const Xmm& x1, const Address& addr, const Xmm& x2);
void vgatherdps(const Xmm& x1, const Address& addr, const Xmm& x2);
void vgatherqpd(const Xmm& x1, const Address& addr, const Xmm& x2);
void vgatherqps(const Xmm& x1, const Address& addr, const Xmm& x2);
void vgf2p8affineinvqb(const Xmm& x1, const Xmm& x2, const Operand& op, uint8 imm);
void vgf2p8affineqb(const Xmm& x1, const Xmm& x2, const Operand& op, uint8 imm);
void vgf2p8mulb(const Xmm& x1, const Xmm& x2, const Operand& op);
void vhaddpd(const Xmm& xmm, const Operand& op1, const Operand& op2 = Operand());
void vhaddps(const Xmm& xmm, const Operand& op1, const Operand& op2 = Operand());
void vhsubpd(const Xmm& xmm, const Operand& op1, const Operand& op2 = Operand());
void vhsubps(const Xmm& xmm, const Operand& op1, const Operand& op2 = Operand());
void vinsertf128(const Ymm& y1, const Ymm& y2, const Operand& op, uint8 imm);
void vinserti128(const Ymm& y1, const Ymm& y2, const Operand& op, uint8 imm);
void vinsertps(const Xmm& x1, const Xmm& x2, const Operand& op, uint8 imm);
void vlddqu(const Xmm& x, const Address& addr);
void vldmxcsr(const Address& addr);
void vmaskmovdqu(const Xmm& x1, const Xmm& x2);
void vmaskmovpd(const Address& addr, const Xmm& x1, const Xmm& x2);
void vmaskmovpd(const Xmm& x1, const Xmm& x2, const Address& addr);
void vmaskmovps(const Address& addr, const Xmm& x1, const Xmm& x2);
void vmaskmovps(const Xmm& x1, const Xmm& x2, const Address& addr);
void vmaxpd(const Xmm& xmm, const Operand& op1, const Operand& op2 = Operand());
void vmaxps(const Xmm& xmm, const Operand& op1, const Operand& op2 = Operand());
void vmaxsd(const Xmm& xmm, const Operand& op1, const Operand& op2 = Operand());
void vmaxss(const Xmm& xmm, const Operand& op1, const Operand& op2 = Operand());
void vminpd(const Xmm& xmm, const Operand& op1, const Operand& op2 = Operand());
void vminps(const Xmm& xmm, const Operand& op1, const Operand& op2 = Operand());
void vminsd(const Xmm& xmm, const Operand& op1, const Operand& op2 = Operand());
void vminss(const Xmm& xmm, const Operand& op1, const Operand& op2 = Operand());
void vmovapd(const Address& addr, const Xmm& xmm);
void vmovapd(const Xmm& xm, const Operand& op);
void vmovaps(const Address& addr, const Xmm& xmm);
void vmovaps(const Xmm& xm, const Operand& op);
void vmovd(const Operand& op, const Xmm& x);
void vmovd(const Xmm& x, const Operand& op);
void vmovddup(const Xmm& xm, const Operand& op);
void vmovdqa(const Address& addr, const Xmm& xmm);
void vmovdqa(const Xmm& xm, const Operand& op);
void vmovdqu(const Address& addr, const Xmm& xmm);
void vmovdqu(const Xmm& xm, const Operand& op);
void vmovhlps(const Xmm& x1, const Xmm& x2, const Operand& op = Operand());
void vmovhpd(const Address& addr, const Xmm& x);
void vmovhpd(const Xmm& x, const Operand& op1, const Operand& op2 = Operand());
void vmovhps(const Address& addr, const Xmm& x);
void vmovhps(const Xmm& x, const Operand& op1, const Operand& op2 = Operand());
void vmovlhps(const Xmm& x1, const Xmm& x2, const Operand& op = Operand());
void vmovlpd(const Address& addr, const Xmm& x);
void vmovlpd(const Xmm& x, const Operand& op1, const Operand& op2 = Operand());
void vmovlps(const Address& addr, const Xmm& x);
void vmovlps(const Xmm& x, const Operand& op1, const Operand& op2 = Operand());
void vmovmskpd(const Reg& r, const Xmm& x);
void vmovmskps(const Reg& r, const Xmm& x);
void vmovntdq(const Address& addr, const Xmm& x);
void vmovntdqa(const Xmm& x, const Address& addr);
void vmovntpd(const Address& addr, const Xmm& x);
void vmovntps(const Address& addr, const Xmm& x);
void vmovq(const Address& addr, const Xmm& x);
void vmovq(const Xmm& x, const Address& addr);
void vmovq(const Xmm& x1, const Xmm& x2);
void vmovsd(const Address& addr, const Xmm& x);
void vmovsd(const Xmm& x, const Address& addr);
void vmovsd(const Xmm& x1, const Xmm& x2, const Operand& op = Operand());
void vmovshdup(const Xmm& xm, const Operand& op);
void vmovsldup(const Xmm& xm, const Operand& op);
void vmovss(const Address& addr, const Xmm& x);
void vmovss(const Xmm& x, const Address& addr);
void vmovss(const Xmm& x1, const Xmm& x2, const Operand& op = Operand());
void vmovupd(const Address& addr, const Xmm& xmm);
void vmovupd(const Xmm& xm, const Operand& op);
void vmovups(const Address& addr, const Xmm& xmm);
void vmovups(const Xmm& xm, const Operand& op);
void vmpsadbw(const Xmm& x1, const Xmm& x2, const Operand& op, uint8 imm);
void vmulpd(const Xmm& xmm, const Operand& op1, const Operand& op2 = Operand());
void vmulps(const Xmm& xmm, const Operand& op1, const Operand& op2 = Operand());
void vmulsd(const Xmm& xmm, const Operand& op1, const Operand& op2 = Operand());
void vmulss(const Xmm& xmm, const Operand& op1, const Operand& op2 = Operand());
void vorpd(const Xmm& xmm, const Operand& op1, const Operand& op2 = Operand());
void vorps(const Xmm& xmm, const Operand& op1, const Operand& op2 = Operand());
void vpabsb(const Xmm& xm, const Operand& op);
void vpabsd(const Xmm& xm, const Operand& op);
void vpabsw(const Xmm& xm, const Operand& op);
void vpackssdw(const Xmm& x1, const Xmm& x2, const Operand& op);
void vpacksswb(const Xmm& x1, const Xmm& x2, const Operand& op);
void vpackusdw(const Xmm& x1, const Xmm& x2, const Operand& op);
void vpackuswb(const Xmm& x1, const Xmm& x2, const Operand& op);
void vpaddb(const Xmm& x1, const Xmm& x2, const Operand& op);
void vpaddd(const Xmm& x1, const Xmm& x2, const Operand& op);
void vpaddq(const Xmm& x1, const Xmm& x2, const Operand& op);
void vpaddsb(const Xmm& x1, const Xmm& x2, const Operand& op);
void vpaddsw(const Xmm& x1, const Xmm& x2, const Operand& op);
void vpaddusb(const Xmm& x1, const Xmm& x2, const Operand& op);
void vpaddusw(const Xmm& x1, const Xmm& x2, const Operand& op);
void vpaddw(const Xmm& x1, const Xmm& x2, const Operand& op);
void vpalignr(const Xmm& x1, const Xmm& x2, const Operand& op, uint8 imm);
void vpand(const Xmm& x1, const Xmm& x2, const Operand& op);
void vpandn(const Xmm& x1, const Xmm& x2, const Operand& op);
void vpavgb(const Xmm& x1, const Xmm& x2, const Operand& op);
void vpavgw(const Xmm& x1, const Xmm& x2, const Operand& op);
void vpblendd(const Xmm& x1, const Xmm& x2, const Operand& op, uint8 imm);
void vpblendvb(const Xmm& x1, const Xmm& x2, const Operand& op, const Xmm& x4);
void vpblendw(const Xmm& x1, const Xmm& x2, const Operand& op, uint8 imm);
void vpbroadcastb(const Xmm& x, const Operand& op);
void vpbroadcastd(const Xmm& x, const Operand& op);
void vpbroadcastq(const Xmm& x, const Operand& op);
void vpbroadcastw(const Xmm& x, const Operand& op);
void vpclmulqdq(const Xmm& x1, const Xmm& x2, const Operand& op, uint8 imm);
void vpcmpeqb(const Xmm& x1, const Xmm& x2, const Operand& op);
void vpcmpeqd(const Xmm& x1, const Xmm& x2, const Operand& op);
void vpcmpeqq(const Xmm& x1, const Xmm& x2, const Operand& op);
void vpcmpeqw(const Xmm& x1, const Xmm& x2, const Operand& op);
void vpcmpestri(const Xmm& xm, const Operand& op, uint8 imm);
void vpcmpestrm(const Xmm& xm, const Operand& op, uint8 imm);
void vpcmpgtb(const Xmm& x1, const Xmm& x2, const Operand& op);
void vpcmpgtd(const Xmm& x1, const Xmm& x2, const Operand& op);
void vpcmpgtq(const Xmm& x1, const Xmm& x2, const Operand& op);
void vpcmpgtw(const Xmm& x1, const Xmm& x2, const Operand& op);
void vpcmpistri(const Xmm& xm, const Operand& op, uint8 imm);
void vpcmpistrm(const Xmm& xm, const Operand& op, uint8 imm);
void vperm2f128(const Ymm& y1, const Ymm& y2, const Operand& op, uint8 imm);
void vperm2i128(const Ymm& y1, const Ymm& y2, const Operand& op, uint8 imm);
void vpermd(const Ymm& y1, const Ymm& y2, const Operand& op);
void vpermilpd(const Xmm& x1, const Xmm& x2, const Operand& op);
void vpermilpd(const Xmm& xm, const Operand& op, uint8 imm);
void vpermilps(const Xmm& x1, const Xmm& x2, const Operand& op);
void vpermilps(const Xmm& xm, const Operand& op, uint8 imm);
void vpermpd(const Ymm& y, const Operand& op, uint8 imm);
void vpermpd(const Ymm& y1, const Ymm& y2, const Operand& op);
void vpermps(const Ymm& y1, const Ymm& y2, const Operand& op);
void vpermq(const Ymm& y, const Operand& op, uint8 imm);
void vpermq(const Ymm& y1, const Ymm& y2, const Operand& op);
void vpextrb(const Operand& op, const Xmm& x, uint8 imm);
void vpextrd(const Operand& op, const Xmm& x, uint8 imm);
void vpextrq(const Operand& op, const Xmm& x, uint8 imm);
void vpextrw(const Operand& op, const Xmm& x, uint8 imm);
void vpgatherdd(const Xmm& x1, const Address& addr, const Xmm& x2);
void vpgatherdq(const Xmm& x1, const Address& addr, const Xmm& x2);
void vpgatherqd(const Xmm& x1, const Address& addr, const Xmm& x2);
void vpgatherqq(const Xmm& x1, const Address& addr, const Xmm& x2);
void vphaddd(const Xmm& x1, const Xmm& x2, const Operand& op);
void vphaddsw(const Xmm& x1, const Xmm& x2, const Operand& op);
void vphaddw(const Xmm& x1, const Xmm& x2, const Operand& op);
void vphminposuw(const Xmm& xm, const Operand& op);
void vphsubd(const Xmm& x1, const Xmm& x2, const Operand& op);
void vphsubsw(const Xmm& x1, const Xmm& x2, const Operand& op);
void vphsubw(const Xmm& x1, const Xmm& x2, const Operand& op);
void vpinsrb(const Xmm& x1, const Xmm& x2, const Operand& op, uint8 imm);
void vpinsrd(const Xmm& x1, const Xmm& x2, const Operand& op, uint8 imm);
void vpinsrq(const Xmm& x1, const Xmm& x2, const Operand& op, uint8 imm);
void vpinsrw(const Xmm& x1, const Xmm& x2, const Operand& op, uint8 imm);
void vpmaddubsw(const Xmm& x1, const Xmm& x2, const Operand& op);
void vpmaddwd(const Xmm& x1, const Xmm& x2, const Operand& op);
void vpmaskmovd(const Address& addr, const Xmm& x1, const Xmm& x2);
void vpmaskmovd(const Xmm& x1, const Xmm& x2, const Address& addr);
void vpmaskmovq(const Address& addr, const Xmm& x1, const Xmm& x2);
void vpmaskmovq(const Xmm& x1, const Xmm& x2, const Address& addr);
void vpmaxsb(const Xmm& x1, const Xmm& x2, const Operand& op);
void vpmaxsd(const Xmm& x1, const Xmm& x2, const Operand& op);
void vpmaxsw(const Xmm& x1, const Xmm& x2, const Operand& op);
void vpmaxub(const Xmm& x1, const Xmm& x2, const Operand& op);
void vpmaxud(const Xmm& x1, const Xmm& x2, const Operand& op);
void vpmaxuw(const Xmm& x1, const Xmm& x2, const Operand& op);
void vpminsb(const Xmm& x1, const Xmm& x2, const Operand& op);
void vpminsd(const Xmm& x1, const Xmm& x2, const Operand& op);
void vpminsw(const Xmm& x1, const Xmm& x2, const Operand& op);
void vpminub(const Xmm& x1, const Xmm& x2, const Operand& op);
void vpminud(const Xmm& x1, const Xmm& x2, const Operand& op);
void vpminuw(const Xmm& x1, const Xmm& x2, const Operand& op);
void vpmovmskb(const Reg32e& r, const Xmm& x);
void vpmovsxbd(const Xmm& xm, const Operand& op);
void vpmovsxbq(const Xmm& xm, const Operand& op);
void vpmovsxbw(const Xmm& xm, const Operand& op);
void vpmovsxdq(const Xmm& xm, const Operand& op);
void vpmovsxwd(const Xmm& xm, const Operand& op);
void vpmovsxwq(const Xmm& xm, const Operand& op);
void vpmovzxbd(const Xmm& xm, const Operand& op);
void vpmovzxbq(const Xmm& xm, const Operand& op);
void vpmovzxbw(const Xmm& xm, const Operand& op);
void vpmovzxdq(const Xmm& xm, const Operand& op);
void vpmovzxwd(const Xmm& xm, const Operand& op);
void vpmovzxwq(const Xmm& xm, const Operand& op);
void vpmuldq(const Xmm& x1, const Xmm& x2, const Operand& op);
void vpmulhrsw(const Xmm& x1, const Xmm& x2, const Operand& op);
void vpmulhuw(const Xmm& x1, const Xmm& x2, const Operand& op);
void vpmulhw(const Xmm& x1, const Xmm& x2, const Operand& op);
void vpmulld(const Xmm& x1, const Xmm& x2, const Operand& op);
void vpmullw(const Xmm& x1, const Xmm& x2, const Operand& op);
void vpmuludq(const Xmm& x1, const Xmm& x2, const Operand& op);
void vpor(const Xmm& x1, const Xmm& x2, const Operand& op);
void vpsadbw(const Xmm& x1, const Xmm& x2, const Operand& op);
void vpshufb(const Xmm& x1, const Xmm& x2, const Operand& op);
void vpshufd(const Xmm& xm, const Operand& op, uint8 imm);
void vpshufhw(const Xmm& xm, const Operand& op, uint8 imm);
void vpshuflw(const Xmm& xm, const Operand& op, uint8 imm);
void vpsignb(const Xmm& x1, const Xmm& x2, const Operand& op);
void vpsignd(const Xmm& x1, const Xmm& x2, const Operand& op);
void vpsignw(const Xmm& x1, const Xmm& x2, const Operand& op);
void vpslld(const Xmm& x, const Operand& op, uint8 imm);
void vpslld(const Xmm& x1, const Xmm& x2, const Operand& op);
void vpslldq(const Xmm& x, const Operand& op, uint8 imm);
void vpsllq(const Xmm& x, const Operand& op, uint8 imm);
void vpsllq(const Xmm& x1, const Xmm& x2, const Operand& op);
void vpsllvd(const Xmm& x1, const Xmm& x2, const Operand& op);
void vpsllvq(const Xmm& x1, const Xmm& x2, const Operand& op);
void vpsllw(const Xmm& x, const Operand& op, uint8 imm);
void vpsllw(const Xmm& x1, const Xmm& x2, const Operand& op);
void vpsrad(const Xmm& x, const Operand& op, uint8 imm);
void vpsrad(const Xmm& x1, const Xmm& x2, const Operand& op);
void vpsravd(const Xmm& x1, const Xmm& x2, const Operand& op);
void vpsraw(const Xmm& x, const Operand& op, uint8 imm);
void vpsraw(const Xmm& x1, const Xmm& x2, const Operand& op);
void vpsrld(const Xmm& x, const Operand& op, uint8 imm);
void vpsrld(const Xmm& x1, const Xmm& x2, const Operand& op);
void vpsrldq(const Xmm& x, const Operand& op, uint8 imm);
void vpsrlq(const Xmm& x, const Operand& op, uint8 imm);
void vpsrlq(const Xmm& x1, const Xmm& x2, const Operand& op);
void vpsrlvd(const Xmm& x1, const Xmm& x2, const Operand& op);
void vpsrlvq(const Xmm& x1, const Xmm& x2, const Operand& op);
void vpsrlw(const Xmm& x, const Operand& op, uint8 imm);
void vpsrlw(const Xmm& x1, const Xmm& x2, const Operand& op);
void vpsubb(const Xmm& x1, const Xmm& x2, const Operand& op);
void vpsubd(const Xmm& x1, const Xmm& x2, const Operand& op);
void vpsubq(const Xmm& x1, const Xmm& x2, const Operand& op);
void vpsubsb(const Xmm& x1, const Xmm& x2, const Operand& op);
void vpsubsw(const Xmm& x1, const Xmm& x2, const Operand& op);
void vpsubusb(const Xmm& x1, const Xmm& x2, const Operand& op);
void vpsubusw(const Xmm& x1, const Xmm& x2, const Operand& op);
void vpsubw(const Xmm& x1, const Xmm& x2, const Operand& op);
void vptest(const Xmm& xm, const Operand& op);
void vpunpckhbw(const Xmm& x1, const Xmm& x2, const Operand& op);
void vpunpckhdq(const Xmm& x1, const Xmm& x2, const Operand& op);
void vpunpckhqdq(const Xmm& x1, const Xmm& x2, const Operand& op);
void vpunpckhwd(const Xmm& x1, const Xmm& x2, const Operand& op);
void vpunpcklbw(const Xmm& x1, const Xmm& x2, const Operand& op);
void vpunpckldq(const Xmm& x1, const Xmm& x2, const Operand& op);
void vpunpcklqdq(const Xmm& x1, const Xmm& x2, const Operand& op);
void vpunpcklwd(const Xmm& x1, const Xmm& x2, const Operand& op);
void vpxor(const Xmm& x1, const Xmm& x2, const Operand& op);
void vrcpps(const Xmm& xm, const Operand& op);
void vrcpss(const Xmm& x1, const Xmm& x2, const Operand& op);
void vroundpd(const Xmm& xm, const Operand& op, uint8 imm);
void vroundps(const Xmm& xm, const Operand& op, uint8 imm);
void vroundsd(const Xmm& x1, const Xmm& x2, const Operand& op, uint8 imm);
void vroundss(const Xmm& x1, const Xmm& x2, const Operand& op, uint8 imm);
void vrsqrtps(const Xmm& xm, const Operand& op);
void vrsqrtss(const Xmm& x1, const Xmm& x2, const Operand& op);
void vshufpd(const Xmm& x1, const Xmm& x2, const Operand& op, uint8 imm);
void vshufps(const Xmm& x1, const Xmm& x2, const Operand& op, uint8 imm);
void vsqrtpd(const Xmm& xm, const Operand& op);
void vsqrtps(const Xmm& xm, const Operand& op);
void vsqrtsd(const Xmm& x1, const Xmm& x2, const Operand& op);
void vsqrtss(const Xmm& x1, const Xmm& x2, const Operand& op);
void vstmxcsr(const Address& addr);
void vsubpd(const Xmm& xmm, const Operand& op1, const Operand& op2 = Operand());
void vsubps(const Xmm& xmm, const Operand& op1, const Operand& op2 = Operand());
void vsubsd(const Xmm& xmm, const Operand& op1, const Operand& op2 = Operand());
void vsubss(const Xmm& xmm, const Operand& op1, const Operand& op2 = Operand());
void vtestpd(const Xmm& xm, const Operand& op);
void vtestps(const Xmm& xm, const Operand& op);
void vucomisd(const Xmm& xm, const Operand& op);
void vucomiss(const Xmm& xm, const Operand& op);
void vunpckhpd(const Xmm& x1, const Xmm& x2, const Operand& op);
void vunpckhps(const Xmm& x1, const Xmm& x2, const Operand& op);
void vunpcklpd(const Xmm& x1, const Xmm& x2, const Operand& op);
void vunpcklps(const Xmm& x1, const Xmm& x2, const Operand& op);
void vxorpd(const Xmm& xmm, const Operand& op1, const Operand& op2 = Operand());
void vxorps(const Xmm& xmm, const Operand& op1, const Operand& op2 = Operand());
void vzeroall();
void vzeroupper();
void wait();
void wbinvd();
void wrmsr();
void xadd(const Operand& op, const Reg& reg);
void xgetbv();
void xlatb();
void xor_(const Operand& op, uint32 imm);
void xor_(const Operand& op1, const Operand& op2);
void xorpd(const Xmm& xmm, const Operand& op);
void xorps(const Xmm& xmm, const Operand& op);
void vblendpd(const Xmm& x, const Operand& op, uint8 imm);
void vblendps(const Xmm& x, const Operand& op, uint8 imm);
void vblendvpd(const Xmm& x1, const Operand& op, const Xmm& x4);
void vblendvps(const Xmm& x1, const Operand& op, const Xmm& x4);
void vcmpeq_ospd(const Xmm& x, const Operand& op);
void vcmpeq_osps(const Xmm& x, const Operand& op);
void vcmpeq_ossd(const Xmm& x, const Operand& op);
void vcmpeq_osss(const Xmm& x, const Operand& op);
void vcmpeq_uqpd(const Xmm& x, const Operand& op);
void vcmpeq_uqps(const Xmm& x, const Operand& op);
void vcmpeq_uqsd(const Xmm& x, const Operand& op);
void vcmpeq_uqss(const Xmm& x, const Operand& op);
void vcmpeq_uspd(const Xmm& x, const Operand& op);
void vcmpeq_usps(const Xmm& x, const Operand& op);
void vcmpeq_ussd(const Xmm& x, const Operand& op);
void vcmpeq_usss(const Xmm& x, const Operand& op);
void vcmpeqpd(const Xmm& x, const Operand& op);
void vcmpeqps(const Xmm& x, const Operand& op);
void vcmpeqsd(const Xmm& x, const Operand& op);
void vcmpeqss(const Xmm& x, const Operand& op);
void vcmpfalse_ospd(const Xmm& x, const Operand& op);
void vcmpfalse_osps(const Xmm& x, const Operand& op);
void vcmpfalse_ossd(const Xmm& x, const Operand& op);
void vcmpfalse_osss(const Xmm& x, const Operand& op);
void vcmpfalsepd(const Xmm& x, const Operand& op);
void vcmpfalseps(const Xmm& x, const Operand& op);
void vcmpfalsesd(const Xmm& x, const Operand& op);
void vcmpfalsess(const Xmm& x, const Operand& op);
void vcmpge_oqpd(const Xmm& x, const Operand& op);
void vcmpge_oqps(const Xmm& x, const Operand& op);
void vcmpge_oqsd(const Xmm& x, const Operand& op);
void vcmpge_oqss(const Xmm& x, const Operand& op);
void vcmpgepd(const Xmm& x, const Operand& op);
void vcmpgeps(const Xmm& x, const Operand& op);
void vcmpgesd(const Xmm& x, const Operand& op);
void vcmpgess(const Xmm& x, const Operand& op);
void vcmpgt_oqpd(const Xmm& x, const Operand& op);
void vcmpgt_oqps(const Xmm& x, const Operand& op);
void vcmpgt_oqsd(const Xmm& x, const Operand& op);
void vcmpgt_oqss(const Xmm& x, const Operand& op);
void vcmpgtpd(const Xmm& x, const Operand& op);
void vcmpgtps(const Xmm& x, const Operand& op);
void vcmpgtsd(const Xmm& x, const Operand& op);
void vcmpgtss(const Xmm& x, const Operand& op);
void vcmple_oqpd(const Xmm& x, const Operand& op);
void vcmple_oqps(const Xmm& x, const Operand& op);
void vcmple_oqsd(const Xmm& x, const Operand& op);
void vcmple_oqss(const Xmm& x, const Operand& op);
void vcmplepd(const Xmm& x, const Operand& op);
void vcmpleps(const Xmm& x, const Operand& op);
void vcmplesd(const Xmm& x, const Operand& op);
void vcmpless(const Xmm& x, const Operand& op);
void vcmplt_oqpd(const Xmm& x, const Operand& op);
void vcmplt_oqps(const Xmm& x, const Operand& op);
void vcmplt_oqsd(const Xmm& x, const Operand& op);
void vcmplt_oqss(const Xmm& x, const Operand& op);
void vcmpltpd(const Xmm& x, const Operand& op);
void vcmpltps(const Xmm& x, const Operand& op);
void vcmpltsd(const Xmm& x, const Operand& op);
void vcmpltss(const Xmm& x, const Operand& op);
void vcmpneq_oqpd(const Xmm& x, const Operand& op);
void vcmpneq_oqps(const Xmm& x, const Operand& op);
void vcmpneq_oqsd(const Xmm& x, const Operand& op);
void vcmpneq_oqss(const Xmm& x, const Operand& op);
void vcmpneq_ospd(const Xmm& x, const Operand& op);
void vcmpneq_osps(const Xmm& x, const Operand& op);
void vcmpneq_ossd(const Xmm& x, const Operand& op);
void vcmpneq_osss(const Xmm& x, const Operand& op);
void vcmpneq_uspd(const Xmm& x, const Operand& op);
void vcmpneq_usps(const Xmm& x, const Operand& op);
void vcmpneq_ussd(const Xmm& x, const Operand& op);
void vcmpneq_usss(const Xmm& x, const Operand& op);
void vcmpneqpd(const Xmm& x, const Operand& op);
void vcmpneqps(const Xmm& x, const Operand& op);
void vcmpneqsd(const Xmm& x, const Operand& op);
void vcmpneqss(const Xmm& x, const Operand& op);
void vcmpnge_uqpd(const Xmm& x, const Operand& op);
void vcmpnge_uqps(const Xmm& x, const Operand& op);
void vcmpnge_uqsd(const Xmm& x, const Operand& op);
void vcmpnge_uqss(const Xmm& x, const Operand& op);
void vcmpngepd(const Xmm& x, const Operand& op);
void vcmpngeps(const Xmm& x, const Operand& op);
void vcmpngesd(const Xmm& x, const Operand& op);
void vcmpngess(const Xmm& x, const Operand& op);
void vcmpngt_uqpd(const Xmm& x, const Operand& op);
void vcmpngt_uqps(const Xmm& x, const Operand& op);
void vcmpngt_uqsd(const Xmm& x, const Operand& op);
void vcmpngt_uqss(const Xmm& x, const Operand& op);
void vcmpngtpd(const Xmm& x, const Operand& op);
void vcmpngtps(const Xmm& x, const Operand& op);
void vcmpngtsd(const Xmm& x, const Operand& op);
void vcmpngtss(const Xmm& x, const Operand& op);
void vcmpnle_uqpd(const Xmm& x, const Operand& op);
void vcmpnle_uqps(const Xmm& x, const Operand& op);
void vcmpnle_uqsd(const Xmm& x, const Operand& op);
void vcmpnle_uqss(const Xmm& x, const Operand& op);
void vcmpnlepd(const Xmm& x, const Operand& op);
void vcmpnleps(const Xmm& x, const Operand& op);
void vcmpnlesd(const Xmm& x, const Operand& op);
void vcmpnless(const Xmm& x, const Operand& op);
void vcmpnlt_uqpd(const Xmm& x, const Operand& op);
void vcmpnlt_uqps(const Xmm& x, const Operand& op);
void vcmpnlt_uqsd(const Xmm& x, const Operand& op);
void vcmpnlt_uqss(const Xmm& x, const Operand& op);
void vcmpnltpd(const Xmm& x, const Operand& op);
void vcmpnltps(const Xmm& x, const Operand& op);
void vcmpnltsd(const Xmm& x, const Operand& op);
void vcmpnltss(const Xmm& x, const Operand& op);
void vcmpord_spd(const Xmm& x, const Operand& op);
void vcmpord_sps(const Xmm& x, const Operand& op);
void vcmpord_ssd(const Xmm& x, const Operand& op);
void vcmpord_sss(const Xmm& x, const Operand& op);
void vcmpordpd(const Xmm& x, const Operand& op);
void vcmpordps(const Xmm& x, const Operand& op);
void vcmpordsd(const Xmm& x, const Operand& op);
void vcmpordss(const Xmm& x, const Operand& op);
void vcmppd(const Xmm& x, const Operand& op, uint8 imm);
void vcmpps(const Xmm& x, const Operand& op, uint8 imm);
void vcmpsd(const Xmm& x, const Operand& op, uint8 imm);
void vcmpss(const Xmm& x, const Operand& op, uint8 imm);
void vcmptrue_uspd(const Xmm& x, const Operand& op);
void vcmptrue_usps(const Xmm& x, const Operand& op);
void vcmptrue_ussd(const Xmm& x, const Operand& op);
void vcmptrue_usss(const Xmm& x, const Operand& op);
void vcmptruepd(const Xmm& x, const Operand& op);
void vcmptrueps(const Xmm& x, const Operand& op);
void vcmptruesd(const Xmm& x, const Operand& op);
void vcmptruess(const Xmm& x, const Operand& op);
void vcmpunord_spd(const Xmm& x, const Operand& op);
void vcmpunord_sps(const Xmm& x, const Operand& op);
void vcmpunord_ssd(const Xmm& x, const Operand& op);
void vcmpunord_sss(const Xmm& x, const Operand& op);
void vcmpunordpd(const Xmm& x, const Operand& op);
void vcmpunordps(const Xmm& x, const Operand& op);
void vcmpunordsd(const Xmm& x, const Operand& op);
void vcmpunordss(const Xmm& x, const Operand& op);
void vcvtsd2ss(const Xmm& x, const Operand& op);
void vcvtsi2sd(const Xmm& x, const Operand& op);
void vcvtsi2ss(const Xmm& x, const Operand& op);
void vcvtss2sd(const Xmm& x, const Operand& op);
void vdppd(const Xmm& x, const Operand& op, uint8 imm);
void vdpps(const Xmm& x, const Operand& op, uint8 imm);
void vinsertps(const Xmm& x, const Operand& op, uint8 imm);
void vmpsadbw(const Xmm& x, const Operand& op, uint8 imm);
void vpackssdw(const Xmm& x, const Operand& op);
void vpacksswb(const Xmm& x, const Operand& op);
void vpackusdw(const Xmm& x, const Operand& op);
void vpackuswb(const Xmm& x, const Operand& op);
void vpaddb(const Xmm& x, const Operand& op);
void vpaddd(const Xmm& x, const Operand& op);
void vpaddq(const Xmm& x, const Operand& op);
void vpaddsb(const Xmm& x, const Operand& op);
void vpaddsw(const Xmm& x, const Operand& op);
void vpaddusb(const Xmm& x, const Operand& op);
void vpaddusw(const Xmm& x, const Operand& op);
void vpaddw(const Xmm& x, const Operand& op);
void vpalignr(const Xmm& x, const Operand& op, uint8 imm);
void vpand(const Xmm& x, const Operand& op);
void vpandn(const Xmm& x, const Operand& op);
void vpavgb(const Xmm& x, const Operand& op);
void vpavgw(const Xmm& x, const Operand& op);
void vpblendd(const Xmm& x, const Operand& op, uint8 imm);
void vpblendvb(const Xmm& x1, const Operand& op, const Xmm& x4);
void vpblendw(const Xmm& x, const Operand& op, uint8 imm);
void vpclmulqdq(const Xmm& x, const Operand& op, uint8 imm);
void vpcmpeqb(const Xmm& x, const Operand& op);
void vpcmpeqd(const Xmm& x, const Operand& op);
void vpcmpeqq(const Xmm& x, const Operand& op);
void vpcmpeqw(const Xmm& x, const Operand& op);
void vpcmpgtb(const Xmm& x, const Operand& op);
void vpcmpgtd(const Xmm& x, const Operand& op);
void vpcmpgtq(const Xmm& x, const Operand& op);
void vpcmpgtw(const Xmm& x, const Operand& op);
void vphaddd(const Xmm& x, const Operand& op);
void vphaddsw(const Xmm& x, const Operand& op);
void vphaddw(const Xmm& x, const Operand& op);
void vphsubd(const Xmm& x, const Operand& op);
void vphsubsw(const Xmm& x, const Operand& op);
void vphsubw(const Xmm& x, const Operand& op);
void vpinsrb(const Xmm& x, const Operand& op, uint8 imm);
void vpinsrd(const Xmm& x, const Operand& op, uint8 imm);
void vpinsrq(const Xmm& x, const Operand& op, uint8 imm);
void vpinsrw(const Xmm& x, const Operand& op, uint8 imm);
void vpmaddubsw(const Xmm& x, const Operand& op);
void vpmaddwd(const Xmm& x, const Operand& op);
void vpmaxsb(const Xmm& x, const Operand& op);
void vpmaxsd(const Xmm& x, const Operand& op);
void vpmaxsw(const Xmm& x, const Operand& op);
void vpmaxub(const Xmm& x, const Operand& op);
void vpmaxud(const Xmm& x, const Operand& op);
void vpmaxuw(const Xmm& x, const Operand& op);
void vpminsb(const Xmm& x, const Operand& op);
void vpminsd(const Xmm& x, const Operand& op);
void vpminsw(const Xmm& x, const Operand& op);
void vpminub(const Xmm& x, const Operand& op);
void vpminud(const Xmm& x, const Operand& op);
void vpminuw(const Xmm& x, const Operand& op);
void vpmuldq(const Xmm& x, const Operand& op);
void vpmulhrsw(const Xmm& x, const Operand& op);
void vpmulhuw(const Xmm& x, const Operand& op);
void vpmulhw(const Xmm& x, const Operand& op);
void vpmulld(const Xmm& x, const Operand& op);
void vpmullw(const Xmm& x, const Operand& op);
void vpmuludq(const Xmm& x, const Operand& op);
void vpor(const Xmm& x, const Operand& op);
void vpsadbw(const Xmm& x, const Operand& op);
void vpsignb(const Xmm& x, const Operand& op);
void vpsignd(const Xmm& x, const Operand& op);
void vpsignw(const Xmm& x, const Operand& op);
void vpslld(const Xmm& x, const Operand& op);
void vpslld(const Xmm& x, uint8 imm);
void vpslldq(const Xmm& x, uint8 imm);
void vpsllq(const Xmm& x, const Operand& op);
void vpsllq(const Xmm& x, uint8 imm);
void vpsllw(const Xmm& x, const Operand& op);
void vpsllw(const Xmm& x, uint8 imm);
void vpsrad(const Xmm& x, const Operand& op);
void vpsrad(const Xmm& x, uint8 imm);
void vpsraw(const Xmm& x, const Operand& op);
void vpsraw(const Xmm& x, uint8 imm);
void vpsrld(const Xmm& x, const Operand& op);
void vpsrld(const Xmm& x, uint8 imm);
void vpsrldq(const Xmm& x, uint8 imm);
void vpsrlq(const Xmm& x, const Operand& op);
void vpsrlq(const Xmm& x, uint8 imm);
void vpsrlw(const Xmm& x, const Operand& op);
void vpsrlw(const Xmm& x, uint8 imm);
void vpsubb(const Xmm& x, const Operand& op);
void vpsubd(const Xmm& x, const Operand& op);
void vpsubq(const Xmm& x, const Operand& op);
void vpsubsb(const Xmm& x, const Operand& op);
void vpsubsw(const Xmm& x, const Operand& op);
void vpsubusb(const Xmm& x, const Operand& op);
void vpsubusw(const Xmm& x, const Operand& op);
void vpsubw(const Xmm& x, const Operand& op);
void vpunpckhbw(const Xmm& x, const Operand& op);
void vpunpckhdq(const Xmm& x, const Operand& op);
void vpunpckhqdq(const Xmm& x, const Operand& op);
void vpunpckhwd(const Xmm& x, const Operand& op);
void vpunpcklbw(const Xmm& x, const Operand& op);
void vpunpckldq(const Xmm& x, const Operand& op);
void vpunpcklqdq(const Xmm& x, const Operand& op);
void vpunpcklwd(const Xmm& x, const Operand& op);
void vpxor(const Xmm& x, const Operand& op);
void vrcpss(const Xmm& x, const Operand& op);
void vroundsd(const Xmm& x, const Operand& op, uint8 imm);
void vroundss(const Xmm& x, const Operand& op, uint8 imm);
void vrsqrtss(const Xmm& x, const Operand& op);
void vshufpd(const Xmm& x, const Operand& op, uint8 imm);
void vshufps(const Xmm& x, const Operand& op, uint8 imm);
void vsqrtsd(const Xmm& x, const Operand& op);
void vsqrtss(const Xmm& x, const Operand& op);
void vunpckhpd(const Xmm& x, const Operand& op);
void vunpckhps(const Xmm& x, const Operand& op);
void vunpcklpd(const Xmm& x, const Operand& op);
void vunpcklps(const Xmm& x, const Operand& op);
void jecxz(std::string label);
void jecxz(const Label& label);
void jrcxz(std::string label);
void jrcxz(const Label& label);
void cdqe();
void cqo();
void cmpsq();
void popfq();
void pushfq();
void lodsq();
void movsq();
void scasq();
void stosq();
void syscall();
void sysret();
void cmpxchg16b(const Address& addr);
void fxrstor64(const Address& addr);
void movq(const Reg64& reg, const Mmx& mmx);
void movq(const Mmx& mmx, const Reg64& reg);
void movsxd(const Reg64& reg, const Operand& op);
void pextrq(const Operand& op, const Xmm& xmm, uint8 imm);
void pinsrq(const Xmm& xmm, const Operand& op, uint8 imm);
void vcvtss2si(const Reg64& r, const Operand& op);
void vcvttss2si(const Reg64& r, const Operand& op);
void vcvtsd2si(const Reg64& r, const Operand& op);
void vcvttsd2si(const Reg64& r, const Operand& op);
void vmovq(const Xmm& x, const Reg64& r);
void vmovq(const Reg64& r, const Xmm& x);
void kaddb(const Opmask& r1, const Opmask& r2, const Opmask& r3);
void kaddd(const Opmask& r1, const Opmask& r2, const Opmask& r3);
void kaddq(const Opmask& r1, const Opmask& r2, const Opmask& r3);
void kaddw(const Opmask& r1, const Opmask& r2, const Opmask& r3);
void kandb(const Opmask& r1, const Opmask& r2, const Opmask& r3);
void kandd(const Opmask& r1, const Opmask& r2, const Opmask& r3);
void kandnb(const Opmask& r1, const Opmask& r2, const Opmask& r3);
void kandnd(const Opmask& r1, const Opmask& r2, const Opmask& r3);
void kandnq(const Opmask& r1, const Opmask& r2, const Opmask& r3);
void kandnw(const Opmask& r1, const Opmask& r2, const Opmask& r3);
void kandq(const Opmask& r1, const Opmask& r2, const Opmask& r3);
void kandw(const Opmask& r1, const Opmask& r2, const Opmask& r3);
void kmovb(const Address& addr, const Opmask& k);
void kmovb(const Opmask& k, const Operand& op);
void kmovb(const Opmask& k, const Reg32& r);
void kmovb(const Reg32& r, const Opmask& k);
void kmovd(const Address& addr, const Opmask& k);
void kmovd(const Opmask& k, const Operand& op);
void kmovd(const Opmask& k, const Reg32& r);
void kmovd(const Reg32& r, const Opmask& k);
void kmovq(const Address& addr, const Opmask& k);
void kmovq(const Opmask& k, const Operand& op);
void kmovw(const Address& addr, const Opmask& k);
void kmovw(const Opmask& k, const Operand& op);
void kmovw(const Opmask& k, const Reg32& r);
void kmovw(const Reg32& r, const Opmask& k);
void knotb(const Opmask& r1, const Opmask& r2);
void knotd(const Opmask& r1, const Opmask& r2);
void knotq(const Opmask& r1, const Opmask& r2);
void knotw(const Opmask& r1, const Opmask& r2);
void korb(const Opmask& r1, const Opmask& r2, const Opmask& r3);
void kord(const Opmask& r1, const Opmask& r2, const Opmask& r3);
void korq(const Opmask& r1, const Opmask& r2, const Opmask& r3);
void kortestb(const Opmask& r1, const Opmask& r2);
void kortestd(const Opmask& r1, const Opmask& r2);
void kortestq(const Opmask& r1, const Opmask& r2);
void kortestw(const Opmask& r1, const Opmask& r2);
void korw(const Opmask& r1, const Opmask& r2, const Opmask& r3);
void kshiftlb(const Opmask& r1, const Opmask& r2, uint8 imm);
void kshiftld(const Opmask& r1, const Opmask& r2, uint8 imm);
void kshiftlq(const Opmask& r1, const Opmask& r2, uint8 imm);
void kshiftlw(const Opmask& r1, const Opmask& r2, uint8 imm);
void kshiftrb(const Opmask& r1, const Opmask& r2, uint8 imm);
void kshiftrd(const Opmask& r1, const Opmask& r2, uint8 imm);
void kshiftrq(const Opmask& r1, const Opmask& r2, uint8 imm);
void kshiftrw(const Opmask& r1, const Opmask& r2, uint8 imm);
void ktestb(const Opmask& r1, const Opmask& r2);
void ktestd(const Opmask& r1, const Opmask& r2);
void ktestq(const Opmask& r1, const Opmask& r2);
void ktestw(const Opmask& r1, const Opmask& r2);
void kunpckbw(const Opmask& r1, const Opmask& r2, const Opmask& r3);
void kunpckdq(const Opmask& r1, const Opmask& r2, const Opmask& r3);
void kunpckwd(const Opmask& r1, const Opmask& r2, const Opmask& r3);
void kxnorb(const Opmask& r1, const Opmask& r2, const Opmask& r3);
void kxnord(const Opmask& r1, const Opmask& r2, const Opmask& r3);
void kxnorq(const Opmask& r1, const Opmask& r2, const Opmask& r3);
void kxnorw(const Opmask& r1, const Opmask& r2, const Opmask& r3);
void kxorb(const Opmask& r1, const Opmask& r2, const Opmask& r3);
void kxord(const Opmask& r1, const Opmask& r2, const Opmask& r3);
void kxorq(const Opmask& r1, const Opmask& r2, const Opmask& r3);
void kxorw(const Opmask& r1, const Opmask& r2, const Opmask& r3);
void v4fmaddps(const Zmm& z1, const Zmm& z2, const Address& addr);
void v4fmaddss(const Xmm& x1, const Xmm& x2, const Address& addr);
void v4fnmaddps(const Zmm& z1, const Zmm& z2, const Address& addr);
void v4fnmaddss(const Xmm& x1, const Xmm& x2, const Address& addr);
void valignd(const Xmm& x1, const Xmm& x2, const Operand& op, uint8 imm);
void valignq(const Xmm& x1, const Xmm& x2, const Operand& op, uint8 imm);
void vblendmpd(const Xmm& x1, const Xmm& x2, const Operand& op);
void vblendmps(const Xmm& x1, const Xmm& x2, const Operand& op);
void vbroadcastf32x2(const Ymm& y, const Operand& op);
void vbroadcastf32x4(const Ymm& y, const Address& addr);
void vbroadcastf32x8(const Zmm& y, const Address& addr);
void vbroadcastf64x2(const Ymm& y, const Address& addr);
void vbroadcastf64x4(const Zmm& y, const Address& addr);
void vbroadcasti32x2(const Xmm& x, const Operand& op);
void vbroadcasti32x4(const Ymm& y, const Operand& op);
void vbroadcasti32x8(const Zmm& z, const Operand& op);
void vbroadcasti64x2(const Ymm& y, const Operand& op);
void vbroadcasti64x4(const Zmm& z, const Operand& op);
void vcmppd(const Opmask& k, const Xmm& x, const Operand& op, uint8 imm);
void vcmpps(const Opmask& k, const Xmm& x, const Operand& op, uint8 imm);
void vcmpsd(const Opmask& k, const Xmm& x, const Operand& op, uint8 imm);
void vcmpss(const Opmask& k, const Xmm& x, const Operand& op, uint8 imm);
void vcompressb(const Operand& op, const Xmm& x);
void vcompresspd(const Operand& op, const Xmm& x);
void vcompressps(const Operand& op, const Xmm& x);
void vcompressw(const Operand& op, const Xmm& x);
void vcvtne2ps2bf16(const Xmm& x1, const Xmm& x2, const Operand& op);
void vcvtneps2bf16(const Xmm& x, const Operand& op);
void vcvtpd2qq(const Xmm& x, const Operand& op);
void vcvtpd2udq(const Xmm& x, const Operand& op);
void vcvtpd2uqq(const Xmm& x, const Operand& op);
void vcvtps2qq(const Xmm& x, const Operand& op);
void vcvtps2udq(const Xmm& x, const Operand& op);
void vcvtps2uqq(const Xmm& x, const Operand& op);
void vcvtqq2pd(const Xmm& x, const Operand& op);
void vcvtqq2ps(const Xmm& x, const Operand& op);
void vcvtsd2usi(const Reg32e& r, const Operand& op);
void vcvtss2usi(const Reg32e& r, const Operand& op);
void vcvttpd2qq(const Xmm& x, const Operand& op);
void vcvttpd2udq(const Xmm& x, const Operand& op);
void vcvttpd2uqq(const Xmm& x, const Operand& op);
void vcvttps2qq(const Xmm& x, const Operand& op);
void vcvttps2udq(const Xmm& x, const Operand& op);
void vcvttps2uqq(const Xmm& x, const Operand& op);
void vcvttsd2usi(const Reg32e& r, const Operand& op);
void vcvttss2usi(const Reg32e& r, const Operand& op);
void vcvtudq2pd(const Xmm& x, const Operand& op);
void vcvtudq2ps(const Xmm& x, const Operand& op);
void vcvtuqq2pd(const Xmm& x, const Operand& op);
void vcvtuqq2ps(const Xmm& x, const Operand& op);
void vcvtusi2sd(const Xmm& x1, const Xmm& x2, const Operand& op);
void vcvtusi2ss(const Xmm& x1, const Xmm& x2, const Operand& op);
void vdbpsadbw(const Xmm& x1, const Xmm& x2, const Operand& op, uint8 imm);
void vdpbf16ps(const Xmm& x1, const Xmm& x2, const Operand& op);
void vexp2pd(const Zmm& z, const Operand& op);
void vexp2ps(const Zmm& z, const Operand& op);
void vexpandpd(const Xmm& x, const Operand& op);
void vexpandps(const Xmm& x, const Operand& op);
void vextractf32x4(const Operand& op, const Ymm& r, uint8 imm);
void vextractf32x8(const Operand& op, const Zmm& r, uint8 imm);
void vextractf64x2(const Operand& op, const Ymm& r, uint8 imm);
void vextractf64x4(const Operand& op, const Zmm& r, uint8 imm);
void vextracti32x4(const Operand& op, const Ymm& r, uint8 imm);
void vextracti32x8(const Operand& op, const Zmm& r, uint8 imm);
void vextracti64x2(const Operand& op, const Ymm& r, uint8 imm);
void vextracti64x4(const Operand& op, const Zmm& r, uint8 imm);
void vfixupimmpd(const Xmm& x1, const Xmm& x2, const Operand& op, uint8 imm);
void vfixupimmps(const Xmm& x1, const Xmm& x2, const Operand& op, uint8 imm);
void vfixupimmsd(const Xmm& x1, const Xmm& x2, const Operand& op, uint8 imm);
void vfixupimmss(const Xmm& x1, const Xmm& x2, const Operand& op, uint8 imm);
void vfpclasspd(const Opmask& k, const Operand& op, uint8 imm);
void vfpclassps(const Opmask& k, const Operand& op, uint8 imm);
void vfpclasssd(const Opmask& k, const Operand& op, uint8 imm);
void vfpclassss(const Opmask& k, const Operand& op, uint8 imm);
void vgatherdpd(const Xmm& x, const Address& addr);
void vgatherdps(const Xmm& x, const Address& addr);
void vgatherpf0dpd(const Address& addr);
void vgatherpf0dps(const Address& addr);
void vgatherpf0qpd(const Address& addr);
void vgatherpf0qps(const Address& addr);
void vgatherpf1dpd(const Address& addr);
void vgatherpf1dps(const Address& addr);
void vgatherpf1qpd(const Address& addr);
void vgatherpf1qps(const Address& addr);
void vgatherqpd(const Xmm& x, const Address& addr);
void vgatherqps(const Xmm& x, const Address& addr);
void vgetexppd(const Xmm& x, const Operand& op);
void vgetexpps(const Xmm& x, const Operand& op);
void vgetexpsd(const Xmm& x1, const Xmm& x2, const Operand& op);
void vgetexpss(const Xmm& x1, const Xmm& x2, const Operand& op);
void vgetmantpd(const Xmm& x, const Operand& op, uint8 imm);
void vgetmantps(const Xmm& x, const Operand& op, uint8 imm);
void vgetmantsd(const Xmm& x1, const Xmm& x2, const Operand& op, uint8 imm);
void vgetmantss(const Xmm& x1, const Xmm& x2, const Operand& op, uint8 imm);
void vinsertf32x4(const Ymm& r1, const Ymm& r2, const Operand& op, uint8 imm);
void vinsertf32x8(const Zmm& r1, const Zmm& r2, const Operand& op, uint8 imm);
void vinsertf64x2(const Ymm& r1, const Ymm& r2, const Operand& op, uint8 imm);
void vinsertf64x4(const Zmm& r1, const Zmm& r2, const Operand& op, uint8 imm);
void vinserti32x4(const Ymm& r1, const Ymm& r2, const Operand& op, uint8 imm);
void vinserti32x8(const Zmm& r1, const Zmm& r2, const Operand& op, uint8 imm);
void vinserti64x2(const Ymm& r1, const Ymm& r2, const Operand& op, uint8 imm);
void vinserti64x4(const Zmm& r1, const Zmm& r2, const Operand& op, uint8 imm);
void vmovdqa32(const Address& addr, const Xmm& x);
void vmovdqa32(const Xmm& x, const Operand& op);
void vmovdqa64(const Address& addr, const Xmm& x);
void vmovdqa64(const Xmm& x, const Operand& op);
void vmovdqu16(const Address& addr, const Xmm& x);
void vmovdqu16(const Xmm& x, const Operand& op);
void vmovdqu32(const Address& addr, const Xmm& x);
void vmovdqu32(const Xmm& x, const Operand& op);
void vmovdqu64(const Address& addr, const Xmm& x);
void vmovdqu64(const Xmm& x, const Operand& op);
void vmovdqu8(const Address& addr, const Xmm& x);
void vmovdqu8(const Xmm& x, const Operand& op);
void vp2intersectd(const Opmask& k, const Xmm& x, const Operand& op);
void vp2intersectq(const Opmask& k, const Xmm& x, const Operand& op);
void vp4dpwssd(const Zmm& z1, const Zmm& z2, const Address& addr);
void vp4dpwssds(const Zmm& z1, const Zmm& z2, const Address& addr);
void vpabsq(const Xmm& x, const Operand& op);
void vpandd(const Xmm& x1, const Xmm& x2, const Operand& op);
void vpandnd(const Xmm& x1, const Xmm& x2, const Operand& op);
void vpandnq(const Xmm& x1, const Xmm& x2, const Operand& op);
void vpandq(const Xmm& x1, const Xmm& x2, const Operand& op);
void vpblendmb(const Xmm& x1, const Xmm& x2, const Operand& op);
void vpblendmd(const Xmm& x1, const Xmm& x2, const Operand& op);
void vpblendmq(const Xmm& x1, const Xmm& x2, const Operand& op);
void vpblendmw(const Xmm& x1, const Xmm& x2, const Operand& op);
void vpbroadcastb(const Xmm& x, const Reg8& r);
void vpbroadcastd(const Xmm& x, const Reg32& r);
void vpbroadcastmb2q(const Xmm& x, const Opmask& k);
void vpbroadcastmw2d(const Xmm& x, const Opmask& k);
void vpbroadcastw(const Xmm& x, const Reg16& r);
void vpcmpb(const Opmask& k, const Xmm& x, const Operand& op, uint8 imm);
void vpcmpd(const Opmask& k, const Xmm& x, const Operand& op, uint8 imm);
void vpcmpeqb(const Opmask& k, const Xmm& x, const Operand& op);
void vpcmpeqd(const Opmask& k, const Xmm& x, const Operand& op);
void vpcmpeqq(const Opmask& k, const Xmm& x, const Operand& op);
void vpcmpeqw(const Opmask& k, const Xmm& x, const Operand& op);
void vpcmpgtb(const Opmask& k, const Xmm& x, const Operand& op);
void vpcmpgtd(const Opmask& k, const Xmm& x, const Operand& op);
void vpcmpgtq(const Opmask& k, const Xmm& x, const Operand& op);
void vpcmpgtw(const Opmask& k, const Xmm& x, const Operand& op);
void vpcmpq(const Opmask& k, const Xmm& x, const Operand& op, uint8 imm);
void vpcmpub(const Opmask& k, const Xmm& x, const Operand& op, uint8 imm);
void vpcmpud(const Opmask& k, const Xmm& x, const Operand& op, uint8 imm);
void vpcmpuq(const Opmask& k, const Xmm& x, const Operand& op, uint8 imm);
void vpcmpuw(const Opmask& k, const Xmm& x, const Operand& op, uint8 imm);
void vpcmpw(const Opmask& k, const Xmm& x, const Operand& op, uint8 imm);
void vpcompressd(const Operand& op, const Xmm& x);
void vpcompressq(const Operand& op, const Xmm& x);
void vpconflictd(const Xmm& x, const Operand& op);
void vpconflictq(const Xmm& x, const Operand& op);
void vpdpbusd(const Xmm& x1, const Xmm& x2, const Operand& op);
void vpdpbusds(const Xmm& x1, const Xmm& x2, const Operand& op);
void vpdpwssd(const Xmm& x1, const Xmm& x2, const Operand& op);
void vpdpwssds(const Xmm& x1, const Xmm& x2, const Operand& op);
void vpermb(const Xmm& x1, const Xmm& x2, const Operand& op);
void vpermi2b(const Xmm& x1, const Xmm& x2, const Operand& op);
void vpermi2d(const Xmm& x1, const Xmm& x2, const Operand& op);
void vpermi2pd(const Xmm& x1, const Xmm& x2, const Operand& op);
void vpermi2ps(const Xmm& x1, const Xmm& x2, const Operand& op);
void vpermi2q(const Xmm& x1, const Xmm& x2, const Operand& op);
void vpermi2w(const Xmm& x1, const Xmm& x2, const Operand& op);
void vpermt2b(const Xmm& x1, const Xmm& x2, const Operand& op);
void vpermt2d(const Xmm& x1, const Xmm& x2, const Operand& op);
void vpermt2pd(const Xmm& x1, const Xmm& x2, const Operand& op);
void vpermt2ps(const Xmm& x1, const Xmm& x2, const Operand& op);
void vpermt2q(const Xmm& x1, const Xmm& x2, const Operand& op);
void vpermt2w(const Xmm& x1, const Xmm& x2, const Operand& op);
void vpermw(const Xmm& x1, const Xmm& x2, const Operand& op);
void vpexpandb(const Xmm& x, const Operand& op);
void vpexpandd(const Xmm& x, const Operand& op);
void vpexpandq(const Xmm& x, const Operand& op);
void vpexpandw(const Xmm& x, const Operand& op);
void vpgatherdd(const Xmm& x, const Address& addr);
void vpgatherdq(const Xmm& x, const Address& addr);
void vpgatherqd(const Xmm& x, const Address& addr);
void vpgatherqq(const Xmm& x, const Address& addr);
void vplzcntd(const Xmm& x, const Operand& op);
void vplzcntq(const Xmm& x, const Operand& op);
void vpmadd52huq(const Xmm& x1, const Xmm& x2, const Operand& op);
void vpmadd52luq(const Xmm& x1, const Xmm& x2, const Operand& op);
void vpmaxsq(const Xmm& x1, const Xmm& x2, const Operand& op);
void vpmaxuq(const Xmm& x1, const Xmm& x2, const Operand& op);
void vpminsq(const Xmm& x1, const Xmm& x2, const Operand& op);
void vpminuq(const Xmm& x1, const Xmm& x2, const Operand& op);
void vpmovb2m(const Opmask& k, const Xmm& x);
void vpmovd2m(const Opmask& k, const Xmm& x);
void vpmovdb(const Operand& op, const Xmm& x);
void vpmovdw(const Operand& op, const Xmm& x);
void vpmovm2b(const Xmm& x, const Opmask& k);
void vpmovm2d(const Xmm& x, const Opmask& k);
void vpmovm2q(const Xmm& x, const Opmask& k);
void vpmovm2w(const Xmm& x, const Opmask& k);
void vpmovq2m(const Opmask& k, const Xmm& x);
void vpmovqb(const Operand& op, const Xmm& x);
void vpmovqd(const Operand& op, const Xmm& x);
void vpmovqw(const Operand& op, const Xmm& x);
void vpmovsdb(const Operand& op, const Xmm& x);
void vpmovsdw(const Operand& op, const Xmm& x);
void vpmovsqb(const Operand& op, const Xmm& x);
void vpmovsqd(const Operand& op, const Xmm& x);
void vpmovsqw(const Operand& op, const Xmm& x);
void vpmovswb(const Operand& op, const Xmm& x);
void vpmovusdb(const Operand& op, const Xmm& x);
void vpmovusdw(const Operand& op, const Xmm& x);
void vpmovusqb(const Operand& op, const Xmm& x);
void vpmovusqd(const Operand& op, const Xmm& x);
void vpmovusqw(const Operand& op, const Xmm& x);
void vpmovuswb(const Operand& op, const Xmm& x);
void vpmovw2m(const Opmask& k, const Xmm& x);
void vpmovwb(const Operand& op, const Xmm& x);
void vpmullq(const Xmm& x1, const Xmm& x2, const Operand& op);
void vpmultishiftqb(const Xmm& x1, const Xmm& x2, const Operand& op);
void vpopcntb(const Xmm& x, const Operand& op);
void vpopcntd(const Xmm& x, const Operand& op);
void vpopcntq(const Xmm& x, const Operand& op);
void vpopcntw(const Xmm& x, const Operand& op);
void vpord(const Xmm& x1, const Xmm& x2, const Operand& op);
void vporq(const Xmm& x1, const Xmm& x2, const Operand& op);
void vprold(const Xmm& x, const Operand& op, uint8 imm);
void vprolq(const Xmm& x, const Operand& op, uint8 imm);
void vprolvd(const Xmm& x1, const Xmm& x2, const Operand& op);
void vprolvq(const Xmm& x1, const Xmm& x2, const Operand& op);
void vprord(const Xmm& x, const Operand& op, uint8 imm);
void vprorq(const Xmm& x, const Operand& op, uint8 imm);
void vprorvd(const Xmm& x1, const Xmm& x2, const Operand& op);
void vprorvq(const Xmm& x1, const Xmm& x2, const Operand& op);
void vpscatterdd(const Address& addr, const Xmm& x);
void vpscatterdq(const Address& addr, const Xmm& x);
void vpscatterqd(const Address& addr, const Xmm& x);
void vpscatterqq(const Address& addr, const Xmm& x);
void vpshldd(const Xmm& x1, const Xmm& x2, const Operand& op, uint8 imm);
void vpshldq(const Xmm& x1, const Xmm& x2, const Operand& op, uint8 imm);
void vpshldvd(const Xmm& x1, const Xmm& x2, const Operand& op);
void vpshldvq(const Xmm& x1, const Xmm& x2, const Operand& op);
void vpshldvw(const Xmm& x1, const Xmm& x2, const Operand& op);
void vpshldw(const Xmm& x1, const Xmm& x2, const Operand& op, uint8 imm);
void vpshrdd(const Xmm& x1, const Xmm& x2, const Operand& op, uint8 imm);
void vpshrdq(const Xmm& x1, const Xmm& x2, const Operand& op, uint8 imm);
void vpshrdvd(const Xmm& x1, const Xmm& x2, const Operand& op);
void vpshrdvq(const Xmm& x1, const Xmm& x2, const Operand& op);
void vpshrdvw(const Xmm& x1, const Xmm& x2, const Operand& op);
void vpshrdw(const Xmm& x1, const Xmm& x2, const Operand& op, uint8 imm);
void vpshufbitqmb(const Opmask& k, const Xmm& x, const Operand& op);
void vpsllvw(const Xmm& x1, const Xmm& x2, const Operand& op);
void vpsraq(const Xmm& x, const Operand& op, uint8 imm);
void vpsraq(const Xmm& x1, const Xmm& x2, const Operand& op);
void vpsravq(const Xmm& x1, const Xmm& x2, const Operand& op);
void vpsravw(const Xmm& x1, const Xmm& x2, const Operand& op);
void vpsrlvw(const Xmm& x1, const Xmm& x2, const Operand& op);
void vpternlogd(const Xmm& x1, const Xmm& x2, const Operand& op, uint8 imm);
void vpternlogq(const Xmm& x1, const Xmm& x2, const Operand& op, uint8 imm);
void vptestmb(const Opmask& k, const Xmm& x, const Operand& op);
void vptestmd(const Opmask& k, const Xmm& x, const Operand& op);
void vptestmq(const Opmask& k, const Xmm& x, const Operand& op);
void vptestmw(const Opmask& k, const Xmm& x, const Operand& op);
void vptestnmb(const Opmask& k, const Xmm& x, const Operand& op);
void vptestnmd(const Opmask& k, const Xmm& x, const Operand& op);
void vptestnmq(const Opmask& k, const Xmm& x, const Operand& op);
void vptestnmw(const Opmask& k, const Xmm& x, const Operand& op);
void vpxord(const Xmm& x1, const Xmm& x2, const Operand& op);
void vpxorq(const Xmm& x1, const Xmm& x2, const Operand& op);
void vrangepd(const Xmm& x1, const Xmm& x2, const Operand& op, uint8 imm);
void vrangeps(const Xmm& x1, const Xmm& x2, const Operand& op, uint8 imm);
void vrangesd(const Xmm& x1, const Xmm& x2, const Operand& op, uint8 imm);
void vrangess(const Xmm& x1, const Xmm& x2, const Operand& op, uint8 imm);
void vrcp14pd(const Xmm& x, const Operand& op);
void vrcp14ps(const Xmm& x, const Operand& op);
void vrcp14sd(const Xmm& x1, const Xmm& x2, const Operand& op);
void vrcp14ss(const Xmm& x1, const Xmm& x2, const Operand& op);
void vrcp28pd(const Zmm& z, const Operand& op);
void vrcp28ps(const Zmm& z, const Operand& op);
void vrcp28sd(const Xmm& x1, const Xmm& x2, const Operand& op);
void vrcp28ss(const Xmm& x1, const Xmm& x2, const Operand& op);
void vreducepd(const Xmm& x, const Operand& op, uint8 imm);
void vreduceps(const Xmm& x, const Operand& op, uint8 imm);
void vreducesd(const Xmm& x1, const Xmm& x2, const Operand& op, uint8 imm);
void vreducess(const Xmm& x1, const Xmm& x2, const Operand& op, uint8 imm);
void vrndscalepd(const Xmm& x, const Operand& op, uint8 imm);
void vrndscaleps(const Xmm& x, const Operand& op, uint8 imm);
void vrndscalesd(const Xmm& x1, const Xmm& x2, const Operand& op, uint8 imm);
void vrndscaless(const Xmm& x1, const Xmm& x2, const Operand& op, uint8 imm);
void vrsqrt14pd(const Xmm& x, const Operand& op);
void vrsqrt14ps(const Xmm& x, const Operand& op);
void vrsqrt14sd(const Xmm& x1, const Xmm& x2, const Operand& op);
void vrsqrt14ss(const Xmm& x1, const Xmm& x2, const Operand& op);
void vrsqrt28pd(const Zmm& z, const Operand& op);
void vrsqrt28ps(const Zmm& z, const Operand& op);
void vrsqrt28sd(const Xmm& x1, const Xmm& x2, const Operand& op);
void vrsqrt28ss(const Xmm& x1, const Xmm& x2, const Operand& op);
void vscalefpd(const Xmm& x1, const Xmm& x2, const Operand& op);
void vscalefps(const Xmm& x1, const Xmm& x2, const Operand& op);
void vscalefsd(const Xmm& x1, const Xmm& x2, const Operand& op);
void vscalefss(const Xmm& x1, const Xmm& x2, const Operand& op);
void vscatterdpd(const Address& addr, const Xmm& x);
void vscatterdps(const Address& addr, const Xmm& x);
void vscatterpf0dpd(const Address& addr);
void vscatterpf0dps(const Address& addr);
void vscatterpf0qpd(const Address& addr);
void vscatterpf0qps(const Address& addr);
void vscatterpf1dpd(const Address& addr);
void vscatterpf1dps(const Address& addr);
void vscatterpf1qpd(const Address& addr);
void vscatterpf1qps(const Address& addr);
void vscatterqpd(const Address& addr, const Xmm& x);
void vscatterqps(const Address& addr, const Xmm& x);
void vshuff32x4(const Ymm& y1, const Ymm& y2, const Operand& op, uint8 imm);
void vshuff64x2(const Ymm& y1, const Ymm& y2, const Operand& op, uint8 imm);
void vshufi32x4(const Ymm& y1, const Ymm& y2, const Operand& op, uint8 imm);
void vshufi64x2(const Ymm& y1, const Ymm& y2, const Operand& op, uint8 imm);
void kmovq(const Opmask& k, const Reg64& r);
void kmovq(const Reg64& r, const Opmask& k);
void vpbroadcastq(const Xmm& x, const Reg64& r);
