pub enum Inst<R: Registers> {
Show 1050 variants
pabsb_a(pabsb_a<R>),
vpabsb_a(vpabsb_a<R>),
pabsw_a(pabsw_a<R>),
vpabsw_a(vpabsw_a<R>),
pabsd_a(pabsd_a<R>),
vpabsd_a(vpabsd_a<R>),
addb_i(addb_i<R>),
addw_i(addw_i<R>),
addl_i(addl_i<R>),
addq_i_sxl(addq_i_sxl<R>),
addb_mi(addb_mi<R>),
addw_mi(addw_mi<R>),
addl_mi(addl_mi<R>),
addq_mi_sxl(addq_mi_sxl<R>),
addl_mi_sxb(addl_mi_sxb<R>),
addq_mi_sxb(addq_mi_sxb<R>),
addb_mr(addb_mr<R>),
addw_mr(addw_mr<R>),
addl_mr(addl_mr<R>),
addq_mr(addq_mr<R>),
addb_rm(addb_rm<R>),
addw_rm(addw_rm<R>),
addl_rm(addl_rm<R>),
addq_rm(addq_rm<R>),
adcb_i(adcb_i<R>),
adcw_i(adcw_i<R>),
adcl_i(adcl_i<R>),
adcq_i_sxl(adcq_i_sxl<R>),
adcb_mi(adcb_mi<R>),
adcw_mi(adcw_mi<R>),
adcl_mi(adcl_mi<R>),
adcq_mi_sxl(adcq_mi_sxl<R>),
adcl_mi_sxb(adcl_mi_sxb<R>),
adcq_mi_sxb(adcq_mi_sxb<R>),
adcb_mr(adcb_mr<R>),
adcw_mr(adcw_mr<R>),
adcl_mr(adcl_mr<R>),
adcq_mr(adcq_mr<R>),
adcb_rm(adcb_rm<R>),
adcw_rm(adcw_rm<R>),
adcl_rm(adcl_rm<R>),
adcq_rm(adcq_rm<R>),
lock_addb_mi(lock_addb_mi<R>),
lock_addw_mi(lock_addw_mi<R>),
lock_addl_mi(lock_addl_mi<R>),
lock_addq_mi_sxl(lock_addq_mi_sxl<R>),
lock_addl_mi_sxb(lock_addl_mi_sxb<R>),
lock_addq_mi_sxb(lock_addq_mi_sxb<R>),
lock_addb_mr(lock_addb_mr<R>),
lock_addw_mr(lock_addw_mr<R>),
lock_addl_mr(lock_addl_mr<R>),
lock_addq_mr(lock_addq_mr<R>),
lock_adcb_mi(lock_adcb_mi<R>),
lock_adcw_mi(lock_adcw_mi<R>),
lock_adcl_mi(lock_adcl_mi<R>),
lock_adcq_mi_sxl(lock_adcq_mi_sxl<R>),
lock_adcl_mi_sxb(lock_adcl_mi_sxb<R>),
lock_adcq_mi_sxb(lock_adcq_mi_sxb<R>),
lock_adcb_mr(lock_adcb_mr<R>),
lock_adcw_mr(lock_adcw_mr<R>),
lock_adcl_mr(lock_adcl_mr<R>),
lock_adcq_mr(lock_adcq_mr<R>),
lock_xaddb_mr(lock_xaddb_mr<R>),
lock_xaddw_mr(lock_xaddw_mr<R>),
lock_xaddl_mr(lock_xaddl_mr<R>),
lock_xaddq_mr(lock_xaddq_mr<R>),
addss_a(addss_a<R>),
addsd_a(addsd_a<R>),
addps_a(addps_a<R>),
addpd_a(addpd_a<R>),
paddb_a(paddb_a<R>),
paddw_a(paddw_a<R>),
paddd_a(paddd_a<R>),
paddq_a(paddq_a<R>),
paddsb_a(paddsb_a<R>),
paddsw_a(paddsw_a<R>),
paddusb_a(paddusb_a<R>),
paddusw_a(paddusw_a<R>),
phaddw_a(phaddw_a<R>),
phaddd_a(phaddd_a<R>),
vaddss_b(vaddss_b<R>),
vaddsd_b(vaddsd_b<R>),
vaddps_b(vaddps_b<R>),
vaddpd_b(vaddpd_b<R>),
vpaddb_b(vpaddb_b<R>),
vpaddw_b(vpaddw_b<R>),
vpaddd_b(vpaddd_b<R>),
vpaddq_b(vpaddq_b<R>),
vpaddsb_b(vpaddsb_b<R>),
vpaddsw_b(vpaddsw_b<R>),
vpaddusb_b(vpaddusb_b<R>),
vpaddusw_b(vpaddusw_b<R>),
vphaddw_b(vphaddw_b<R>),
vphaddd_b(vphaddd_b<R>),
palignr_a(palignr_a<R>),
vpalignr_b(vpalignr_b<R>),
andb_i(andb_i<R>),
andw_i(andw_i<R>),
andl_i(andl_i<R>),
andq_i_sxl(andq_i_sxl<R>),
andb_mi(andb_mi<R>),
andw_mi(andw_mi<R>),
andl_mi(andl_mi<R>),
andq_mi_sxl(andq_mi_sxl<R>),
andl_mi_sxb(andl_mi_sxb<R>),
andq_mi_sxb(andq_mi_sxb<R>),
andb_mr(andb_mr<R>),
andw_mr(andw_mr<R>),
andl_mr(andl_mr<R>),
andq_mr(andq_mr<R>),
andb_rm(andb_rm<R>),
andw_rm(andw_rm<R>),
andl_rm(andl_rm<R>),
andq_rm(andq_rm<R>),
andnl_rvm(andnl_rvm<R>),
andnq_rvm(andnq_rvm<R>),
lock_andb_mi(lock_andb_mi<R>),
lock_andw_mi(lock_andw_mi<R>),
lock_andl_mi(lock_andl_mi<R>),
lock_andq_mi_sxl(lock_andq_mi_sxl<R>),
lock_andl_mi_sxb(lock_andl_mi_sxb<R>),
lock_andq_mi_sxb(lock_andq_mi_sxb<R>),
lock_andb_mr(lock_andb_mr<R>),
lock_andw_mr(lock_andw_mr<R>),
lock_andl_mr(lock_andl_mr<R>),
lock_andq_mr(lock_andq_mr<R>),
andps_a(andps_a<R>),
andpd_a(andpd_a<R>),
andnps_a(andnps_a<R>),
andnpd_a(andnpd_a<R>),
pand_a(pand_a<R>),
pandn_a(pandn_a<R>),
vandps_b(vandps_b<R>),
vandpd_b(vandpd_b<R>),
vandnps_b(vandnps_b<R>),
vandnpd_b(vandnpd_b<R>),
vpand_b(vpand_b<R>),
vpandn_b(vpandn_b<R>),
xchgb_rm(xchgb_rm<R>),
xchgw_rm(xchgw_rm<R>),
xchgl_rm(xchgl_rm<R>),
xchgq_rm(xchgq_rm<R>),
cmpxchg16b_m(cmpxchg16b_m<R>),
lock_cmpxchg16b_m(lock_cmpxchg16b_m<R>),
cmpxchgb_mr(cmpxchgb_mr<R>),
cmpxchgw_mr(cmpxchgw_mr<R>),
cmpxchgl_mr(cmpxchgl_mr<R>),
cmpxchgq_mr(cmpxchgq_mr<R>),
lock_cmpxchgb_mr(lock_cmpxchgb_mr<R>),
lock_cmpxchgw_mr(lock_cmpxchgw_mr<R>),
lock_cmpxchgl_mr(lock_cmpxchgl_mr<R>),
lock_cmpxchgq_mr(lock_cmpxchgq_mr<R>),
pavgb_a(pavgb_a<R>),
pavgw_a(pavgw_a<R>),
vpavgb_b(vpavgb_b<R>),
vpavgw_b(vpavgw_b<R>),
bsfw_rm(bsfw_rm<R>),
bsfl_rm(bsfl_rm<R>),
bsfq_rm(bsfq_rm<R>),
bsrw_rm(bsrw_rm<R>),
bsrl_rm(bsrl_rm<R>),
bsrq_rm(bsrq_rm<R>),
tzcntw_a(tzcntw_a<R>),
tzcntl_a(tzcntl_a<R>),
tzcntq_a(tzcntq_a<R>),
lzcntw_rm(lzcntw_rm<R>),
lzcntl_rm(lzcntl_rm<R>),
lzcntq_rm(lzcntq_rm<R>),
popcntw_rm(popcntw_rm<R>),
popcntl_rm(popcntl_rm<R>),
popcntq_rm(popcntq_rm<R>),
btw_mr(btw_mr<R>),
btl_mr(btl_mr<R>),
btq_mr(btq_mr<R>),
btw_mi(btw_mi<R>),
btl_mi(btl_mi<R>),
btq_mi(btq_mi<R>),
cbtw_zo(cbtw_zo<R>),
cwtl_zo(cwtl_zo<R>),
cltq_zo(cltq_zo<R>),
cwtd_zo(cwtd_zo<R>),
cltd_zo(cltd_zo<R>),
cqto_zo(cqto_zo<R>),
bswapl_o(bswapl_o<R>),
bswapq_o(bswapq_o<R>),
blsrl_vm(blsrl_vm<R>),
blsrq_vm(blsrq_vm<R>),
blsmskl_vm(blsmskl_vm<R>),
blsmskq_vm(blsmskq_vm<R>),
blsil_vm(blsil_vm<R>),
blsiq_vm(blsiq_vm<R>),
bzhil_rmv(bzhil_rmv<R>),
bzhiq_rmv(bzhiq_rmv<R>),
cmovaw_rm(cmovaw_rm<R>),
cmoval_rm(cmoval_rm<R>),
cmovaq_rm(cmovaq_rm<R>),
cmovaew_rm(cmovaew_rm<R>),
cmovael_rm(cmovael_rm<R>),
cmovaeq_rm(cmovaeq_rm<R>),
cmovbw_rm(cmovbw_rm<R>),
cmovbl_rm(cmovbl_rm<R>),
cmovbq_rm(cmovbq_rm<R>),
cmovbew_rm(cmovbew_rm<R>),
cmovbel_rm(cmovbel_rm<R>),
cmovbeq_rm(cmovbeq_rm<R>),
cmovew_rm(cmovew_rm<R>),
cmovel_rm(cmovel_rm<R>),
cmoveq_rm(cmoveq_rm<R>),
cmovgw_rm(cmovgw_rm<R>),
cmovgl_rm(cmovgl_rm<R>),
cmovgq_rm(cmovgq_rm<R>),
cmovgew_rm(cmovgew_rm<R>),
cmovgel_rm(cmovgel_rm<R>),
cmovgeq_rm(cmovgeq_rm<R>),
cmovlw_rm(cmovlw_rm<R>),
cmovll_rm(cmovll_rm<R>),
cmovlq_rm(cmovlq_rm<R>),
cmovlew_rm(cmovlew_rm<R>),
cmovlel_rm(cmovlel_rm<R>),
cmovleq_rm(cmovleq_rm<R>),
cmovnew_rm(cmovnew_rm<R>),
cmovnel_rm(cmovnel_rm<R>),
cmovneq_rm(cmovneq_rm<R>),
cmovnow_rm(cmovnow_rm<R>),
cmovnol_rm(cmovnol_rm<R>),
cmovnoq_rm(cmovnoq_rm<R>),
cmovnpw_rm(cmovnpw_rm<R>),
cmovnpl_rm(cmovnpl_rm<R>),
cmovnpq_rm(cmovnpq_rm<R>),
cmovnsw_rm(cmovnsw_rm<R>),
cmovnsl_rm(cmovnsl_rm<R>),
cmovnsq_rm(cmovnsq_rm<R>),
cmovow_rm(cmovow_rm<R>),
cmovol_rm(cmovol_rm<R>),
cmovoq_rm(cmovoq_rm<R>),
cmovpw_rm(cmovpw_rm<R>),
cmovpl_rm(cmovpl_rm<R>),
cmovpq_rm(cmovpq_rm<R>),
cmovsw_rm(cmovsw_rm<R>),
cmovsl_rm(cmovsl_rm<R>),
cmovsq_rm(cmovsq_rm<R>),
cmpb_i(cmpb_i<R>),
cmpw_i(cmpw_i<R>),
cmpl_i(cmpl_i<R>),
cmpq_i(cmpq_i<R>),
cmpb_mi(cmpb_mi<R>),
cmpw_mi(cmpw_mi<R>),
cmpl_mi(cmpl_mi<R>),
cmpq_mi(cmpq_mi<R>),
cmpw_mi_sxb(cmpw_mi_sxb<R>),
cmpl_mi_sxb(cmpl_mi_sxb<R>),
cmpq_mi_sxb(cmpq_mi_sxb<R>),
cmpb_mr(cmpb_mr<R>),
cmpw_mr(cmpw_mr<R>),
cmpl_mr(cmpl_mr<R>),
cmpq_mr(cmpq_mr<R>),
cmpb_rm(cmpb_rm<R>),
cmpw_rm(cmpw_rm<R>),
cmpl_rm(cmpl_rm<R>),
cmpq_rm(cmpq_rm<R>),
testb_i(testb_i<R>),
testw_i(testw_i<R>),
testl_i(testl_i<R>),
testq_i(testq_i<R>),
testb_mi(testb_mi<R>),
testw_mi(testw_mi<R>),
testl_mi(testl_mi<R>),
testq_mi(testq_mi<R>),
testb_mr(testb_mr<R>),
testw_mr(testw_mr<R>),
testl_mr(testl_mr<R>),
testq_mr(testq_mr<R>),
ptest_rm(ptest_rm<R>),
vptest_rm(vptest_rm<R>),
ucomiss_a(ucomiss_a<R>),
ucomisd_a(ucomisd_a<R>),
vucomiss_a(vucomiss_a<R>),
vucomisd_a(vucomisd_a<R>),
cmpss_a(cmpss_a<R>),
cmpsd_a(cmpsd_a<R>),
cmpps_a(cmpps_a<R>),
cmppd_a(cmppd_a<R>),
vcmpss_b(vcmpss_b<R>),
vcmpsd_b(vcmpsd_b<R>),
vcmpps_b(vcmpps_b<R>),
vcmppd_b(vcmppd_b<R>),
pcmpeqb_a(pcmpeqb_a<R>),
pcmpeqw_a(pcmpeqw_a<R>),
pcmpeqd_a(pcmpeqd_a<R>),
pcmpeqq_a(pcmpeqq_a<R>),
pcmpgtb_a(pcmpgtb_a<R>),
pcmpgtw_a(pcmpgtw_a<R>),
pcmpgtd_a(pcmpgtd_a<R>),
pcmpgtq_a(pcmpgtq_a<R>),
vpcmpeqb_b(vpcmpeqb_b<R>),
vpcmpeqw_b(vpcmpeqw_b<R>),
vpcmpeqd_b(vpcmpeqd_b<R>),
vpcmpeqq_b(vpcmpeqq_b<R>),
vpcmpgtb_b(vpcmpgtb_b<R>),
vpcmpgtw_b(vpcmpgtw_b<R>),
vpcmpgtd_b(vpcmpgtd_b<R>),
vpcmpgtq_b(vpcmpgtq_b<R>),
cvtps2pd_a(cvtps2pd_a<R>),
cvttps2dq_a(cvttps2dq_a<R>),
cvtss2sd_a(cvtss2sd_a<R>),
cvtss2si_a(cvtss2si_a<R>),
cvtss2si_aq(cvtss2si_aq<R>),
cvttss2si_a(cvttss2si_a<R>),
cvttss2si_aq(cvttss2si_aq<R>),
vcvtps2pd_a(vcvtps2pd_a<R>),
vcvttps2dq_a(vcvttps2dq_a<R>),
vcvtss2sd_b(vcvtss2sd_b<R>),
vcvtss2si_a(vcvtss2si_a<R>),
vcvtss2si_aq(vcvtss2si_aq<R>),
vcvttss2si_a(vcvttss2si_a<R>),
vcvttss2si_aq(vcvttss2si_aq<R>),
cvtpd2ps_a(cvtpd2ps_a<R>),
cvttpd2dq_a(cvttpd2dq_a<R>),
cvtsd2ss_a(cvtsd2ss_a<R>),
cvtsd2si_a(cvtsd2si_a<R>),
cvtsd2si_aq(cvtsd2si_aq<R>),
cvttsd2si_a(cvttsd2si_a<R>),
cvttsd2si_aq(cvttsd2si_aq<R>),
vcvtpd2ps_a(vcvtpd2ps_a<R>),
vcvttpd2dq_a(vcvttpd2dq_a<R>),
vcvtsd2ss_b(vcvtsd2ss_b<R>),
vcvtsd2si_a(vcvtsd2si_a<R>),
vcvtsd2si_aq(vcvtsd2si_aq<R>),
vcvttsd2si_a(vcvttsd2si_a<R>),
vcvttsd2si_aq(vcvttsd2si_aq<R>),
cvtdq2ps_a(cvtdq2ps_a<R>),
cvtdq2pd_a(cvtdq2pd_a<R>),
cvtsi2ssl_a(cvtsi2ssl_a<R>),
cvtsi2ssq_a(cvtsi2ssq_a<R>),
cvtsi2sdl_a(cvtsi2sdl_a<R>),
cvtsi2sdq_a(cvtsi2sdq_a<R>),
vcvtdq2pd_a(vcvtdq2pd_a<R>),
vcvtdq2ps_a(vcvtdq2ps_a<R>),
vcvtsi2sdl_b(vcvtsi2sdl_b<R>),
vcvtsi2sdq_b(vcvtsi2sdq_b<R>),
vcvtsi2ssl_b(vcvtsi2ssl_b<R>),
vcvtsi2ssq_b(vcvtsi2ssq_b<R>),
divb_m(divb_m<R>),
divw_m(divw_m<R>),
divl_m(divl_m<R>),
divq_m(divq_m<R>),
idivb_m(idivb_m<R>),
idivw_m(idivw_m<R>),
idivl_m(idivl_m<R>),
idivq_m(idivq_m<R>),
divss_a(divss_a<R>),
divsd_a(divsd_a<R>),
divps_a(divps_a<R>),
divpd_a(divpd_a<R>),
vdivss_b(vdivss_b<R>),
vdivsd_b(vdivsd_b<R>),
vdivps_b(vdivps_b<R>),
vdivpd_b(vdivpd_b<R>),
vfmadd132ss_a(vfmadd132ss_a<R>),
vfmadd213ss_a(vfmadd213ss_a<R>),
vfmadd231ss_a(vfmadd231ss_a<R>),
vfmadd132sd_a(vfmadd132sd_a<R>),
vfmadd213sd_a(vfmadd213sd_a<R>),
vfmadd231sd_a(vfmadd231sd_a<R>),
vfmadd132ps_a(vfmadd132ps_a<R>),
vfmadd213ps_a(vfmadd213ps_a<R>),
vfmadd231ps_a(vfmadd231ps_a<R>),
vfmadd132pd_a(vfmadd132pd_a<R>),
vfmadd213pd_a(vfmadd213pd_a<R>),
vfmadd231pd_a(vfmadd231pd_a<R>),
vfnmadd132ss_a(vfnmadd132ss_a<R>),
vfnmadd213ss_a(vfnmadd213ss_a<R>),
vfnmadd231ss_a(vfnmadd231ss_a<R>),
vfnmadd132sd_a(vfnmadd132sd_a<R>),
vfnmadd213sd_a(vfnmadd213sd_a<R>),
vfnmadd231sd_a(vfnmadd231sd_a<R>),
vfnmadd132ps_a(vfnmadd132ps_a<R>),
vfnmadd213ps_a(vfnmadd213ps_a<R>),
vfnmadd231ps_a(vfnmadd231ps_a<R>),
vfnmadd132pd_a(vfnmadd132pd_a<R>),
vfnmadd213pd_a(vfnmadd213pd_a<R>),
vfnmadd231pd_a(vfnmadd231pd_a<R>),
vfmsub132ss_a(vfmsub132ss_a<R>),
vfmsub213ss_a(vfmsub213ss_a<R>),
vfmsub231ss_a(vfmsub231ss_a<R>),
vfmsub132sd_a(vfmsub132sd_a<R>),
vfmsub213sd_a(vfmsub213sd_a<R>),
vfmsub231sd_a(vfmsub231sd_a<R>),
vfmsub132ps_a(vfmsub132ps_a<R>),
vfmsub213ps_a(vfmsub213ps_a<R>),
vfmsub231ps_a(vfmsub231ps_a<R>),
vfmsub132pd_a(vfmsub132pd_a<R>),
vfmsub213pd_a(vfmsub213pd_a<R>),
vfmsub231pd_a(vfmsub231pd_a<R>),
vfnmsub132ss_a(vfnmsub132ss_a<R>),
vfnmsub213ss_a(vfnmsub213ss_a<R>),
vfnmsub231ss_a(vfnmsub231ss_a<R>),
vfnmsub132sd_a(vfnmsub132sd_a<R>),
vfnmsub213sd_a(vfnmsub213sd_a<R>),
vfnmsub231sd_a(vfnmsub231sd_a<R>),
vfnmsub132ps_a(vfnmsub132ps_a<R>),
vfnmsub213ps_a(vfnmsub213ps_a<R>),
vfnmsub231ps_a(vfnmsub231ps_a<R>),
vfnmsub132pd_a(vfnmsub132pd_a<R>),
vfnmsub213pd_a(vfnmsub213pd_a<R>),
vfnmsub231pd_a(vfnmsub231pd_a<R>),
jmpq_m(jmpq_m<R>),
jmp_d8(jmp_d8),
jmp_d32(jmp_d32),
ja_d8(ja_d8),
ja_d32(ja_d32),
jae_d8(jae_d8),
jae_d32(jae_d32),
jb_d8(jb_d8),
jb_d32(jb_d32),
jbe_d8(jbe_d8),
jbe_d32(jbe_d32),
je_d8(je_d8),
je_d32(je_d32),
jg_d8(jg_d8),
jg_d32(jg_d32),
jge_d8(jge_d8),
jge_d32(jge_d32),
jl_d8(jl_d8),
jl_d32(jl_d32),
jle_d8(jle_d8),
jle_d32(jle_d32),
jne_d8(jne_d8),
jne_d32(jne_d32),
jno_d8(jno_d8),
jno_d32(jno_d32),
jnp_d8(jnp_d8),
jnp_d32(jnp_d32),
jns_d8(jns_d8),
jns_d32(jns_d32),
jo_d8(jo_d8),
jo_d32(jo_d32),
jp_d8(jp_d8),
jp_d32(jp_d32),
js_d8(js_d8),
js_d32(js_d32),
extractps_a(extractps_a<R>),
pextrb_a(pextrb_a<R>),
pextrw_a(pextrw_a<R>),
pextrw_b(pextrw_b<R>),
pextrd_a(pextrd_a<R>),
pextrq_a(pextrq_a<R>),
vextractps_b(vextractps_b<R>),
vpextrb_a(vpextrb_a<R>),
vpextrw_a(vpextrw_a<R>),
vpextrw_b(vpextrw_b<R>),
vpextrd_a(vpextrd_a<R>),
vpextrq_a(vpextrq_a<R>),
insertps_a(insertps_a<R>),
pinsrb_a(pinsrb_a<R>),
pinsrw_a(pinsrw_a<R>),
pinsrd_a(pinsrd_a<R>),
pinsrq_a(pinsrq_a<R>),
vinsertps_b(vinsertps_b<R>),
vpinsrb_b(vpinsrb_b<R>),
vpinsrw_b(vpinsrw_b<R>),
vpinsrd_b(vpinsrd_b<R>),
vpinsrq_b(vpinsrq_b<R>),
movmskps_rm(movmskps_rm<R>),
movmskpd_rm(movmskpd_rm<R>),
pmovmskb_rm(pmovmskb_rm<R>),
vmovmskps_rm(vmovmskps_rm<R>),
vmovmskpd_rm(vmovmskpd_rm<R>),
vpmovmskb_rm(vpmovmskb_rm<R>),
movhps_a(movhps_a<R>),
movlhps_rm(movlhps_rm<R>),
vmovhps_b(vmovhps_b<R>),
vmovlhps_rvm(vmovlhps_rvm<R>),
movddup_a(movddup_a<R>),
vmovddup_a(vmovddup_a<R>),
pblendw_rmi(pblendw_rmi<R>),
pblendvb_rm(pblendvb_rm<R>),
blendvps_rm0(blendvps_rm0<R>),
blendvpd_rm0(blendvpd_rm0<R>),
vpblendw_rvmi(vpblendw_rvmi<R>),
vpblendvb_rvmr(vpblendvb_rvmr<R>),
vblendvps_rvmr(vblendvps_rvmr<R>),
vblendvpd_rvmr(vblendvpd_rvmr<R>),
shufpd_a(shufpd_a<R>),
vshufpd_b(vshufpd_b<R>),
shufps_a(shufps_a<R>),
vshufps_b(vshufps_b<R>),
pshufb_a(pshufb_a<R>),
pshufd_a(pshufd_a<R>),
pshuflw_a(pshuflw_a<R>),
pshufhw_a(pshufhw_a<R>),
vpshufb_b(vpshufb_b<R>),
vpshufd_a(vpshufd_a<R>),
vpshuflw_a(vpshuflw_a<R>),
vpshufhw_a(vpshufhw_a<R>),
vbroadcastss_a_m(vbroadcastss_a_m<R>),
vbroadcastss_a_r(vbroadcastss_a_r<R>),
vpbroadcastb_a(vpbroadcastb_a<R>),
vpbroadcastw_a(vpbroadcastw_a<R>),
vpbroadcastd_a(vpbroadcastd_a<R>),
vpbroadcastq_a(vpbroadcastq_a<R>),
maxss_a(maxss_a<R>),
maxsd_a(maxsd_a<R>),
maxps_a(maxps_a<R>),
maxpd_a(maxpd_a<R>),
vmaxss_b(vmaxss_b<R>),
vmaxsd_b(vmaxsd_b<R>),
vmaxps_b(vmaxps_b<R>),
vmaxpd_b(vmaxpd_b<R>),
pmaxsb_a(pmaxsb_a<R>),
pmaxsw_a(pmaxsw_a<R>),
pmaxsd_a(pmaxsd_a<R>),
pmaxub_a(pmaxub_a<R>),
pmaxuw_a(pmaxuw_a<R>),
pmaxud_a(pmaxud_a<R>),
vpmaxsb_b(vpmaxsb_b<R>),
vpmaxsw_b(vpmaxsw_b<R>),
vpmaxsd_b(vpmaxsd_b<R>),
vpmaxub_b(vpmaxub_b<R>),
vpmaxuw_b(vpmaxuw_b<R>),
vpmaxud_b(vpmaxud_b<R>),
minss_a(minss_a<R>),
minsd_a(minsd_a<R>),
minps_a(minps_a<R>),
minpd_a(minpd_a<R>),
vminss_b(vminss_b<R>),
vminsd_b(vminsd_b<R>),
vminps_b(vminps_b<R>),
vminpd_b(vminpd_b<R>),
pminsb_a(pminsb_a<R>),
pminsw_a(pminsw_a<R>),
pminsd_a(pminsd_a<R>),
pminub_a(pminub_a<R>),
pminuw_a(pminuw_a<R>),
pminud_a(pminud_a<R>),
vpminsb_b(vpminsb_b<R>),
vpminsw_b(vpminsw_b<R>),
vpminsd_b(vpminsd_b<R>),
vpminub_b(vpminub_b<R>),
vpminuw_b(vpminuw_b<R>),
vpminud_b(vpminud_b<R>),
mfence_zo(mfence_zo),
sfence_zo(sfence_zo),
lfence_zo(lfence_zo),
hlt_zo(hlt_zo),
ud2_zo(ud2_zo),
int3_zo(int3_zo),
retq_zo(retq_zo),
retq_i(retq_i),
leaw_rm(leaw_rm<R>),
leal_rm(leal_rm<R>),
leaq_rm(leaq_rm<R>),
callq_d(callq_d),
callq_m(callq_m<R>),
movb_mr(movb_mr<R>),
movw_mr(movw_mr<R>),
movl_mr(movl_mr<R>),
movq_mr(movq_mr<R>),
movb_rm(movb_rm<R>),
movw_rm(movw_rm<R>),
movl_rm(movl_rm<R>),
movq_rm(movq_rm<R>),
movb_oi(movb_oi<R>),
movw_oi(movw_oi<R>),
movl_oi(movl_oi<R>),
movabsq_oi(movabsq_oi<R>),
movb_mi(movb_mi<R>),
movw_mi(movw_mi<R>),
movl_mi(movl_mi<R>),
movq_mi_sxl(movq_mi_sxl<R>),
movsbw_rm(movsbw_rm<R>),
movsbl_rm(movsbl_rm<R>),
movsbq_rm(movsbq_rm<R>),
movsww_rm(movsww_rm<R>),
movswl_rm(movswl_rm<R>),
movswq_rm(movswq_rm<R>),
movslq_rm(movslq_rm<R>),
movzbw_rm(movzbw_rm<R>),
movzbl_rm(movzbl_rm<R>),
movzbq_rm(movzbq_rm<R>),
movzww_rm(movzww_rm<R>),
movzwl_rm(movzwl_rm<R>),
movzwq_rm(movzwq_rm<R>),
movd_a(movd_a<R>),
movq_a(movq_a<R>),
movd_b(movd_b<R>),
movq_b(movq_b<R>),
vmovd_a(vmovd_a<R>),
vmovq_a(vmovq_a<R>),
vmovd_b(vmovd_b<R>),
vmovq_b(vmovq_b<R>),
movss_a_m(movss_a_m<R>),
movss_a_r(movss_a_r<R>),
movss_c_m(movss_c_m<R>),
movsd_a_m(movsd_a_m<R>),
movsd_a_r(movsd_a_r<R>),
movsd_c_m(movsd_c_m<R>),
vmovss_d(vmovss_d<R>),
vmovss_b(vmovss_b<R>),
vmovss_c_m(vmovss_c_m<R>),
vmovsd_d(vmovsd_d<R>),
vmovsd_b(vmovsd_b<R>),
vmovsd_c_m(vmovsd_c_m<R>),
movapd_a(movapd_a<R>),
movapd_b(movapd_b<R>),
movaps_a(movaps_a<R>),
movaps_b(movaps_b<R>),
movdqa_a(movdqa_a<R>),
movdqa_b(movdqa_b<R>),
vmovapd_a(vmovapd_a<R>),
vmovapd_b(vmovapd_b<R>),
vmovaps_a(vmovaps_a<R>),
vmovaps_b(vmovaps_b<R>),
vmovdqa_a(vmovdqa_a<R>),
vmovdqa_b(vmovdqa_b<R>),
movupd_a(movupd_a<R>),
movupd_b(movupd_b<R>),
movups_a(movups_a<R>),
movups_b(movups_b<R>),
movdqu_a(movdqu_a<R>),
movdqu_b(movdqu_b<R>),
vmovupd_a(vmovupd_a<R>),
vmovupd_b(vmovupd_b<R>),
vmovups_a(vmovups_a<R>),
vmovups_b(vmovups_b<R>),
vmovdqu_a(vmovdqu_a<R>),
vmovdqu_b(vmovdqu_b<R>),
pmovsxbw_a(pmovsxbw_a<R>),
pmovsxbd_a(pmovsxbd_a<R>),
pmovsxbq_a(pmovsxbq_a<R>),
pmovsxwd_a(pmovsxwd_a<R>),
pmovsxwq_a(pmovsxwq_a<R>),
pmovsxdq_a(pmovsxdq_a<R>),
vpmovsxbw_a(vpmovsxbw_a<R>),
vpmovsxbd_a(vpmovsxbd_a<R>),
vpmovsxbq_a(vpmovsxbq_a<R>),
vpmovsxwd_a(vpmovsxwd_a<R>),
vpmovsxwq_a(vpmovsxwq_a<R>),
vpmovsxdq_a(vpmovsxdq_a<R>),
pmovzxbw_a(pmovzxbw_a<R>),
pmovzxbd_a(pmovzxbd_a<R>),
pmovzxbq_a(pmovzxbq_a<R>),
pmovzxwd_a(pmovzxwd_a<R>),
pmovzxwq_a(pmovzxwq_a<R>),
pmovzxdq_a(pmovzxdq_a<R>),
vpmovzxbw_a(vpmovzxbw_a<R>),
vpmovzxbd_a(vpmovzxbd_a<R>),
vpmovzxbq_a(vpmovzxbq_a<R>),
vpmovzxwd_a(vpmovzxwd_a<R>),
vpmovzxwq_a(vpmovzxwq_a<R>),
vpmovzxdq_a(vpmovzxdq_a<R>),
mulb_m(mulb_m<R>),
mulw_m(mulw_m<R>),
mull_m(mull_m<R>),
mulq_m(mulq_m<R>),
imulb_m(imulb_m<R>),
imulw_m(imulw_m<R>),
imull_m(imull_m<R>),
imulq_m(imulq_m<R>),
imulw_rm(imulw_rm<R>),
imull_rm(imull_rm<R>),
imulq_rm(imulq_rm<R>),
imulw_rmi_sxb(imulw_rmi_sxb<R>),
imull_rmi_sxb(imull_rmi_sxb<R>),
imulq_rmi_sxb(imulq_rmi_sxb<R>),
imulw_rmi(imulw_rmi<R>),
imull_rmi(imull_rmi<R>),
imulq_rmi_sxl(imulq_rmi_sxl<R>),
mulxl_rvm(mulxl_rvm<R>),
mulxq_rvm(mulxq_rvm<R>),
mulss_a(mulss_a<R>),
mulsd_a(mulsd_a<R>),
mulps_a(mulps_a<R>),
mulpd_a(mulpd_a<R>),
pmuldq_a(pmuldq_a<R>),
pmulhrsw_a(pmulhrsw_a<R>),
pmulhuw_a(pmulhuw_a<R>),
pmulhw_a(pmulhw_a<R>),
pmulld_a(pmulld_a<R>),
pmullw_a(pmullw_a<R>),
pmuludq_a(pmuludq_a<R>),
vmulss_b(vmulss_b<R>),
vmulsd_b(vmulsd_b<R>),
vmulps_b(vmulps_b<R>),
vmulpd_b(vmulpd_b<R>),
vpmuldq_b(vpmuldq_b<R>),
vpmulhrsw_b(vpmulhrsw_b<R>),
vpmulhuw_b(vpmulhuw_b<R>),
vpmulhw_b(vpmulhw_b<R>),
vpmulld_b(vpmulld_b<R>),
vpmullw_b(vpmullw_b<R>),
vpmuludq_b(vpmuludq_b<R>),
negb_m(negb_m<R>),
negw_m(negw_m<R>),
negl_m(negl_m<R>),
negq_m(negq_m<R>),
notb_m(notb_m<R>),
notw_m(notw_m<R>),
notl_m(notl_m<R>),
notq_m(notq_m<R>),
nop_zo(nop_zo),
nopl_m(nopl_m<R>),
nop_1b(nop_1b),
nop_2b(nop_2b),
nop_3b(nop_3b),
nop_4b(nop_4b),
nop_5b(nop_5b),
nop_6b(nop_6b),
nop_7b(nop_7b),
nop_8b(nop_8b),
nop_9b(nop_9b),
orb_i(orb_i<R>),
orw_i(orw_i<R>),
orl_i(orl_i<R>),
orq_i_sxl(orq_i_sxl<R>),
orb_mi(orb_mi<R>),
orw_mi(orw_mi<R>),
orl_mi(orl_mi<R>),
orq_mi_sxl(orq_mi_sxl<R>),
orl_mi_sxb(orl_mi_sxb<R>),
orq_mi_sxb(orq_mi_sxb<R>),
orb_mr(orb_mr<R>),
orw_mr(orw_mr<R>),
orl_mr(orl_mr<R>),
orq_mr(orq_mr<R>),
orb_rm(orb_rm<R>),
orw_rm(orw_rm<R>),
orl_rm(orl_rm<R>),
orq_rm(orq_rm<R>),
lock_orb_mi(lock_orb_mi<R>),
lock_orw_mi(lock_orw_mi<R>),
lock_orl_mi(lock_orl_mi<R>),
lock_orq_mi_sxl(lock_orq_mi_sxl<R>),
lock_orl_mi_sxb(lock_orl_mi_sxb<R>),
lock_orq_mi_sxb(lock_orq_mi_sxb<R>),
lock_orb_mr(lock_orb_mr<R>),
lock_orw_mr(lock_orw_mr<R>),
lock_orl_mr(lock_orl_mr<R>),
lock_orq_mr(lock_orq_mr<R>),
orps_a(orps_a<R>),
orpd_a(orpd_a<R>),
por_a(por_a<R>),
vorps_b(vorps_b<R>),
vorpd_b(vorpd_b<R>),
vpor_b(vpor_b<R>),
packsswb_a(packsswb_a<R>),
packssdw_a(packssdw_a<R>),
vpacksswb_b(vpacksswb_b<R>),
vpackssdw_b(vpackssdw_b<R>),
packuswb_a(packuswb_a<R>),
packusdw_a(packusdw_a<R>),
vpackuswb_b(vpackuswb_b<R>),
vpackusdw_b(vpackusdw_b<R>),
pmaddwd_a(pmaddwd_a<R>),
vpmaddwd_b(vpmaddwd_b<R>),
pmaddubsw_a(pmaddubsw_a<R>),
vpmaddubsw_b(vpmaddubsw_b<R>),
rcpps_rm(rcpps_rm<R>),
rcpss_rm(rcpss_rm<R>),
rsqrtps_rm(rsqrtps_rm<R>),
rsqrtss_rm(rsqrtss_rm<R>),
vrcpps_rm(vrcpps_rm<R>),
vrcpss_rvm(vrcpss_rvm<R>),
vrsqrtps_rm(vrsqrtps_rm<R>),
vrsqrtss_rvm(vrsqrtss_rvm<R>),
roundpd_rmi(roundpd_rmi<R>),
roundps_rmi(roundps_rmi<R>),
roundsd_rmi(roundsd_rmi<R>),
roundss_rmi(roundss_rmi<R>),
vroundpd_rmi(vroundpd_rmi<R>),
vroundps_rmi(vroundps_rmi<R>),
vroundsd_rvmi(vroundsd_rvmi<R>),
vroundss_rvmi(vroundss_rvmi<R>),
seta_m(seta_m<R>),
setae_m(setae_m<R>),
setb_m(setb_m<R>),
setbe_m(setbe_m<R>),
sete_m(sete_m<R>),
setg_m(setg_m<R>),
setge_m(setge_m<R>),
setl_m(setl_m<R>),
setle_m(setle_m<R>),
setne_m(setne_m<R>),
setno_m(setno_m<R>),
setnp_m(setnp_m<R>),
setns_m(setns_m<R>),
seto_m(seto_m<R>),
setp_m(setp_m<R>),
sets_m(sets_m<R>),
sarb_mc(sarb_mc<R>),
sarb_mi(sarb_mi<R>),
sarb_m1(sarb_m1<R>),
sarw_mc(sarw_mc<R>),
sarw_mi(sarw_mi<R>),
sarw_m1(sarw_m1<R>),
sarl_mc(sarl_mc<R>),
sarl_mi(sarl_mi<R>),
sarl_m1(sarl_m1<R>),
sarq_mc(sarq_mc<R>),
sarq_mi(sarq_mi<R>),
sarq_m1(sarq_m1<R>),
shlb_mc(shlb_mc<R>),
shlb_mi(shlb_mi<R>),
shlb_m1(shlb_m1<R>),
shlw_mc(shlw_mc<R>),
shlw_mi(shlw_mi<R>),
shlw_m1(shlw_m1<R>),
shll_mc(shll_mc<R>),
shll_mi(shll_mi<R>),
shll_m1(shll_m1<R>),
shlq_mc(shlq_mc<R>),
shlq_mi(shlq_mi<R>),
shlq_m1(shlq_m1<R>),
shrb_mc(shrb_mc<R>),
shrb_mi(shrb_mi<R>),
shrb_m1(shrb_m1<R>),
shrw_mc(shrw_mc<R>),
shrw_mi(shrw_mi<R>),
shrw_m1(shrw_m1<R>),
shrl_mc(shrl_mc<R>),
shrl_mi(shrl_mi<R>),
shrl_m1(shrl_m1<R>),
shrq_mc(shrq_mc<R>),
shrq_mi(shrq_mi<R>),
shrq_m1(shrq_m1<R>),
rolb_mc(rolb_mc<R>),
rolb_mi(rolb_mi<R>),
rolb_m1(rolb_m1<R>),
rolw_mc(rolw_mc<R>),
rolw_mi(rolw_mi<R>),
rolw_m1(rolw_m1<R>),
roll_mc(roll_mc<R>),
roll_mi(roll_mi<R>),
roll_m1(roll_m1<R>),
rolq_mc(rolq_mc<R>),
rolq_mi(rolq_mi<R>),
rolq_m1(rolq_m1<R>),
rorb_mc(rorb_mc<R>),
rorb_mi(rorb_mi<R>),
rorb_m1(rorb_m1<R>),
rorw_mc(rorw_mc<R>),
rorw_mi(rorw_mi<R>),
rorw_m1(rorw_m1<R>),
rorl_mc(rorl_mc<R>),
rorl_mi(rorl_mi<R>),
rorl_m1(rorl_m1<R>),
rorq_mc(rorq_mc<R>),
rorq_mi(rorq_mi<R>),
rorq_m1(rorq_m1<R>),
shldw_mri(shldw_mri<R>),
shldw_mrc(shldw_mrc<R>),
shldl_mri(shldl_mri<R>),
shldq_mri(shldq_mri<R>),
shldl_mrc(shldl_mrc<R>),
shldq_mrc(shldq_mrc<R>),
sarxl_rmv(sarxl_rmv<R>),
shlxl_rmv(shlxl_rmv<R>),
shrxl_rmv(shrxl_rmv<R>),
sarxq_rmv(sarxq_rmv<R>),
shlxq_rmv(shlxq_rmv<R>),
shrxq_rmv(shrxq_rmv<R>),
rorxl_rmi(rorxl_rmi<R>),
rorxq_rmi(rorxq_rmi<R>),
psllw_a(psllw_a<R>),
psllw_b(psllw_b<R>),
pslld_a(pslld_a<R>),
pslld_b(pslld_b<R>),
psllq_a(psllq_a<R>),
psllq_b(psllq_b<R>),
vpsllw_c(vpsllw_c<R>),
vpsllw_d(vpsllw_d<R>),
vpslld_c(vpslld_c<R>),
vpslld_d(vpslld_d<R>),
vpsllq_c(vpsllq_c<R>),
vpsllq_d(vpsllq_d<R>),
psraw_a(psraw_a<R>),
psraw_b(psraw_b<R>),
psrad_a(psrad_a<R>),
psrad_b(psrad_b<R>),
psrlw_a(psrlw_a<R>),
psrlw_b(psrlw_b<R>),
psrld_a(psrld_a<R>),
psrld_b(psrld_b<R>),
psrlq_a(psrlq_a<R>),
psrlq_b(psrlq_b<R>),
vpsraw_c(vpsraw_c<R>),
vpsraw_d(vpsraw_d<R>),
vpsrad_c(vpsrad_c<R>),
vpsrad_d(vpsrad_d<R>),
vpsrlw_c(vpsrlw_c<R>),
vpsrlw_d(vpsrlw_d<R>),
vpsrld_c(vpsrld_c<R>),
vpsrld_d(vpsrld_d<R>),
vpsrlq_c(vpsrlq_c<R>),
vpsrlq_d(vpsrlq_d<R>),
sqrtss_a(sqrtss_a<R>),
sqrtsd_a(sqrtsd_a<R>),
sqrtps_a(sqrtps_a<R>),
sqrtpd_a(sqrtpd_a<R>),
vsqrtss_b(vsqrtss_b<R>),
vsqrtsd_b(vsqrtsd_b<R>),
vsqrtps_b(vsqrtps_b<R>),
vsqrtpd_b(vsqrtpd_b<R>),
popw_m(popw_m<R>),
popq_m(popq_m<R>),
popw_o(popw_o<R>),
popq_o(popq_o<R>),
pushw_m(pushw_m<R>),
pushq_m(pushq_m<R>),
pushw_o(pushw_o<R>),
pushq_o(pushq_o<R>),
pushq_i8(pushq_i8),
pushw_i16(pushw_i16),
pushq_i32(pushq_i32),
subb_i(subb_i<R>),
subw_i(subw_i<R>),
subl_i(subl_i<R>),
subq_i_sxl(subq_i_sxl<R>),
subb_mi(subb_mi<R>),
subw_mi(subw_mi<R>),
subl_mi(subl_mi<R>),
subq_mi_sxl(subq_mi_sxl<R>),
subl_mi_sxb(subl_mi_sxb<R>),
subq_mi_sxb(subq_mi_sxb<R>),
subb_mr(subb_mr<R>),
subw_mr(subw_mr<R>),
subl_mr(subl_mr<R>),
subq_mr(subq_mr<R>),
subb_rm(subb_rm<R>),
subw_rm(subw_rm<R>),
subl_rm(subl_rm<R>),
subq_rm(subq_rm<R>),
sbbb_i(sbbb_i<R>),
sbbw_i(sbbw_i<R>),
sbbl_i(sbbl_i<R>),
sbbq_i_sxl(sbbq_i_sxl<R>),
sbbb_mi(sbbb_mi<R>),
sbbw_mi(sbbw_mi<R>),
sbbl_mi(sbbl_mi<R>),
sbbq_mi_sxl(sbbq_mi_sxl<R>),
sbbl_mi_sxb(sbbl_mi_sxb<R>),
sbbq_mi_sxb(sbbq_mi_sxb<R>),
sbbb_mr(sbbb_mr<R>),
sbbw_mr(sbbw_mr<R>),
sbbl_mr(sbbl_mr<R>),
sbbq_mr(sbbq_mr<R>),
sbbb_rm(sbbb_rm<R>),
sbbw_rm(sbbw_rm<R>),
sbbl_rm(sbbl_rm<R>),
sbbq_rm(sbbq_rm<R>),
lock_subb_mi(lock_subb_mi<R>),
lock_subw_mi(lock_subw_mi<R>),
lock_subl_mi(lock_subl_mi<R>),
lock_subq_mi_sxl(lock_subq_mi_sxl<R>),
lock_subl_mi_sxb(lock_subl_mi_sxb<R>),
lock_subq_mi_sxb(lock_subq_mi_sxb<R>),
lock_subb_mr(lock_subb_mr<R>),
lock_subw_mr(lock_subw_mr<R>),
lock_subl_mr(lock_subl_mr<R>),
lock_subq_mr(lock_subq_mr<R>),
lock_sbbb_mi(lock_sbbb_mi<R>),
lock_sbbw_mi(lock_sbbw_mi<R>),
lock_sbbl_mi(lock_sbbl_mi<R>),
lock_sbbq_mi_sxl(lock_sbbq_mi_sxl<R>),
lock_sbbl_mi_sxb(lock_sbbl_mi_sxb<R>),
lock_sbbq_mi_sxb(lock_sbbq_mi_sxb<R>),
lock_sbbb_mr(lock_sbbb_mr<R>),
lock_sbbw_mr(lock_sbbw_mr<R>),
lock_sbbl_mr(lock_sbbl_mr<R>),
lock_sbbq_mr(lock_sbbq_mr<R>),
subss_a(subss_a<R>),
subsd_a(subsd_a<R>),
subps_a(subps_a<R>),
subpd_a(subpd_a<R>),
psubb_a(psubb_a<R>),
psubw_a(psubw_a<R>),
psubd_a(psubd_a<R>),
psubq_a(psubq_a<R>),
psubsb_a(psubsb_a<R>),
psubsw_a(psubsw_a<R>),
psubusb_a(psubusb_a<R>),
psubusw_a(psubusw_a<R>),
vsubss_b(vsubss_b<R>),
vsubsd_b(vsubsd_b<R>),
vsubps_b(vsubps_b<R>),
vsubpd_b(vsubpd_b<R>),
vpsubb_b(vpsubb_b<R>),
vpsubw_b(vpsubw_b<R>),
vpsubd_b(vpsubd_b<R>),
vpsubq_b(vpsubq_b<R>),
vpsubsb_b(vpsubsb_b<R>),
vpsubsw_b(vpsubsw_b<R>),
vpsubusb_b(vpsubusb_b<R>),
vpsubusw_b(vpsubusw_b<R>),
unpcklps_a(unpcklps_a<R>),
unpcklpd_a(unpcklpd_a<R>),
unpckhps_a(unpckhps_a<R>),
vunpcklps_b(vunpcklps_b<R>),
vunpcklpd_b(vunpcklpd_b<R>),
vunpckhps_b(vunpckhps_b<R>),
punpckhbw_a(punpckhbw_a<R>),
punpckhwd_a(punpckhwd_a<R>),
punpckhdq_a(punpckhdq_a<R>),
punpckhqdq_a(punpckhqdq_a<R>),
punpcklwd_a(punpcklwd_a<R>),
punpcklbw_a(punpcklbw_a<R>),
punpckldq_a(punpckldq_a<R>),
punpcklqdq_a(punpcklqdq_a<R>),
vpunpckhbw_b(vpunpckhbw_b<R>),
vpunpckhwd_b(vpunpckhwd_b<R>),
vpunpckhdq_b(vpunpckhdq_b<R>),
vpunpckhqdq_b(vpunpckhqdq_b<R>),
vpunpcklwd_b(vpunpcklwd_b<R>),
vpunpcklbw_b(vpunpcklbw_b<R>),
vpunpckldq_b(vpunpckldq_b<R>),
vpunpcklqdq_b(vpunpcklqdq_b<R>),
xorb_i(xorb_i<R>),
xorw_i(xorw_i<R>),
xorl_i(xorl_i<R>),
xorq_i_sxl(xorq_i_sxl<R>),
xorb_mi(xorb_mi<R>),
xorw_mi(xorw_mi<R>),
xorl_mi(xorl_mi<R>),
xorq_mi_sxl(xorq_mi_sxl<R>),
xorl_mi_sxb(xorl_mi_sxb<R>),
xorq_mi_sxb(xorq_mi_sxb<R>),
xorb_mr(xorb_mr<R>),
xorw_mr(xorw_mr<R>),
xorl_mr(xorl_mr<R>),
xorq_mr(xorq_mr<R>),
xorb_rm(xorb_rm<R>),
xorw_rm(xorw_rm<R>),
xorl_rm(xorl_rm<R>),
xorq_rm(xorq_rm<R>),
lock_xorb_mi(lock_xorb_mi<R>),
lock_xorw_mi(lock_xorw_mi<R>),
lock_xorl_mi(lock_xorl_mi<R>),
lock_xorq_mi_sxl(lock_xorq_mi_sxl<R>),
lock_xorl_mi_sxb(lock_xorl_mi_sxb<R>),
lock_xorq_mi_sxb(lock_xorq_mi_sxb<R>),
lock_xorb_mr(lock_xorb_mr<R>),
lock_xorw_mr(lock_xorw_mr<R>),
lock_xorl_mr(lock_xorl_mr<R>),
lock_xorq_mr(lock_xorq_mr<R>),
xorps_a(xorps_a<R>),
xorpd_a(xorpd_a<R>),
pxor_a(pxor_a<R>),
vxorps_b(vxorps_b<R>),
vxorpd_b(vxorpd_b<R>),
vpxor_b(vpxor_b<R>),
}Expand description
An assembly instruction; contains all instructions known to the assembler.
This wraps all inst structures into a single enumeration for collecting
instructions.