Struct iced_x86::code_asm::AsmMemoryOperand

pub struct AsmMemoryOperand { /* private fields */ }

A memory operand passed to CodeAssembler methods.

The struct name is not part of the public API. Its methods, however, are part of the public API.

You can create a memory operand in many different ways:

use iced_x86::code_asm::*;

// <???> ptr [rax+rdx*4]
let _ = rax + rdx * 4;
// byte ptr [rax]
let _ = byte_ptr(rax);
// <???> ptr gs:[rcx*4+123]
let _ = ptr(rcx * 4 + 123).gs();
// qword bcst [rdx+xmm0*8+123]
let _ = qword_bcst(rdx + xmm0 * 8 + 123);

Implementations

impl AsmMemoryOperand

pub fn es(self) -> Self

Adds an ES segment override

pub fn cs(self) -> Self

Adds a CS segment override

pub fn ss(self) -> Self

Adds an SS segment override

pub fn ds(self) -> Self

Adds a DS segment override

pub fn fs(self) -> Self

Adds an FS segment override

pub fn gs(self) -> Self

Adds a GS segment override

pub fn k1(self) -> Self

Adds a {k1} opmask register

pub fn k2(self) -> Self

Adds a {k2} opmask register

pub fn k3(self) -> Self

Adds a {k3} opmask register

pub fn k4(self) -> Self

Adds a {k4} opmask register

pub fn k5(self) -> Self

Adds a {k5} opmask register

pub fn k6(self) -> Self

Adds a {k6} opmask register

pub fn k7(self) -> Self

Adds a {k7} opmask register

Trait Implementations

impl Add<AsmMemoryOperand> for AsmMemoryOperand

type Output = AsmMemoryOperand

The resulting type after applying the + operator.

fn add(self, rhs: AsmMemoryOperand) -> Self::Output

Performs the + operation.

impl Add<AsmMemoryOperand> for AsmRegister16

type Output = AsmMemoryOperand

The resulting type after applying the + operator.

fn add(self, rhs: AsmMemoryOperand) -> Self::Output

Performs the + operation.

impl Add<AsmMemoryOperand> for AsmRegister32

type Output = AsmMemoryOperand

The resulting type after applying the + operator.

fn add(self, rhs: AsmMemoryOperand) -> Self::Output

Performs the + operation.

impl Add<AsmMemoryOperand> for AsmRegister64

type Output = AsmMemoryOperand

The resulting type after applying the + operator.

fn add(self, rhs: AsmMemoryOperand) -> Self::Output

Performs the + operation.

impl Add<AsmMemoryOperand> for i16

type Output = AsmMemoryOperand

The resulting type after applying the + operator.

fn add(self, rhs: AsmMemoryOperand) -> Self::Output

Performs the + operation.

impl Add<AsmMemoryOperand> for i32

type Output = AsmMemoryOperand

The resulting type after applying the + operator.

fn add(self, rhs: AsmMemoryOperand) -> Self::Output

Performs the + operation.

impl Add<AsmMemoryOperand> for i64

type Output = AsmMemoryOperand

The resulting type after applying the + operator.

fn add(self, rhs: AsmMemoryOperand) -> Self::Output

Performs the + operation.

impl Add<AsmMemoryOperand> for i8

type Output = AsmMemoryOperand

The resulting type after applying the + operator.

fn add(self, rhs: AsmMemoryOperand) -> Self::Output

Performs the + operation.

impl Add<AsmMemoryOperand> for isize

type Output = AsmMemoryOperand

The resulting type after applying the + operator.

fn add(self, rhs: AsmMemoryOperand) -> Self::Output

Performs the + operation.

impl Add<AsmMemoryOperand> for u16

type Output = AsmMemoryOperand

The resulting type after applying the + operator.

fn add(self, rhs: AsmMemoryOperand) -> Self::Output

Performs the + operation.

impl Add<AsmMemoryOperand> for u32

type Output = AsmMemoryOperand

The resulting type after applying the + operator.

fn add(self, rhs: AsmMemoryOperand) -> Self::Output

Performs the + operation.

impl Add<AsmMemoryOperand> for u64

type Output = AsmMemoryOperand

The resulting type after applying the + operator.

fn add(self, rhs: AsmMemoryOperand) -> Self::Output

Performs the + operation.

impl Add<AsmMemoryOperand> for u8

type Output = AsmMemoryOperand

The resulting type after applying the + operator.

fn add(self, rhs: AsmMemoryOperand) -> Self::Output

Performs the + operation.

impl Add<AsmMemoryOperand> for usize

type Output = AsmMemoryOperand

The resulting type after applying the + operator.

fn add(self, rhs: AsmMemoryOperand) -> Self::Output

Performs the + operation.

impl Add<AsmRegister16> for AsmMemoryOperand

type Output = AsmMemoryOperand

The resulting type after applying the + operator.

fn add(self, rhs: AsmRegister16) -> Self::Output

Performs the + operation.

impl Add<AsmRegister32> for AsmMemoryOperand

type Output = AsmMemoryOperand

The resulting type after applying the + operator.

fn add(self, rhs: AsmRegister32) -> Self::Output

Performs the + operation.

impl Add<AsmRegister64> for AsmMemoryOperand

type Output = AsmMemoryOperand

The resulting type after applying the + operator.

fn add(self, rhs: AsmRegister64) -> Self::Output

Performs the + operation.

impl Add<i16> for AsmMemoryOperand

type Output = AsmMemoryOperand

The resulting type after applying the + operator.

fn add(self, rhs: i16) -> Self::Output

Performs the + operation.

impl Add<i32> for AsmMemoryOperand

type Output = AsmMemoryOperand

The resulting type after applying the + operator.

fn add(self, rhs: i32) -> Self::Output

Performs the + operation.

impl Add<i64> for AsmMemoryOperand

type Output = AsmMemoryOperand

The resulting type after applying the + operator.

fn add(self, rhs: i64) -> Self::Output

Performs the + operation.

impl Add<i8> for AsmMemoryOperand

type Output = AsmMemoryOperand

The resulting type after applying the + operator.

fn add(self, rhs: i8) -> Self::Output

Performs the + operation.

impl Add<isize> for AsmMemoryOperand

type Output = AsmMemoryOperand

The resulting type after applying the + operator.

fn add(self, rhs: isize) -> Self::Output

Performs the + operation.

impl Add<u16> for AsmMemoryOperand

type Output = AsmMemoryOperand

The resulting type after applying the + operator.

fn add(self, rhs: u16) -> Self::Output

Performs the + operation.

impl Add<u32> for AsmMemoryOperand

type Output = AsmMemoryOperand

The resulting type after applying the + operator.

fn add(self, rhs: u32) -> Self::Output

Performs the + operation.

impl Add<u64> for AsmMemoryOperand

type Output = AsmMemoryOperand

The resulting type after applying the + operator.

fn add(self, rhs: u64) -> Self::Output

Performs the + operation.

impl Add<u8> for AsmMemoryOperand

type Output = AsmMemoryOperand

The resulting type after applying the + operator.

fn add(self, rhs: u8) -> Self::Output

Performs the + operation.

impl Add<usize> for AsmMemoryOperand

type Output = AsmMemoryOperand

The resulting type after applying the + operator.

fn add(self, rhs: usize) -> Self::Output

Performs the + operation.

impl Clone for AsmMemoryOperand

fn clone(&self) -> AsmMemoryOperand

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl CodeAsmAdc<AsmMemoryOperand, AsmRegister16> for CodeAssembler

fn adc(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegister16
) -> Result<(), IcedError>

impl CodeAsmAdc<AsmMemoryOperand, AsmRegister32> for CodeAssembler

fn adc(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegister32
) -> Result<(), IcedError>

impl CodeAsmAdc<AsmMemoryOperand, AsmRegister64> for CodeAssembler

fn adc(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegister64
) -> Result<(), IcedError>

impl CodeAsmAdc<AsmMemoryOperand, AsmRegister8> for CodeAssembler

fn adc(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegister8
) -> Result<(), IcedError>

impl CodeAsmAdc<AsmMemoryOperand, i32> for CodeAssembler

fn adc(&mut self, op0: AsmMemoryOperand, op1: i32) -> Result<(), IcedError>

impl CodeAsmAdc<AsmMemoryOperand, u32> for CodeAssembler

fn adc(&mut self, op0: AsmMemoryOperand, op1: u32) -> Result<(), IcedError>

impl CodeAsmAdc<AsmRegister16, AsmMemoryOperand> for CodeAssembler

fn adc(
    &mut self,
    op0: AsmRegister16,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmAdc<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn adc(
    &mut self,
    op0: AsmRegister32,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmAdc<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn adc(
    &mut self,
    op0: AsmRegister64,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmAdc<AsmRegister8, AsmMemoryOperand> for CodeAssembler

fn adc(
    &mut self,
    op0: AsmRegister8,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmAdcx<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn adcx(
    &mut self,
    op0: AsmRegister32,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmAdcx<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn adcx(
    &mut self,
    op0: AsmRegister64,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmAdd<AsmMemoryOperand, AsmRegister16> for CodeAssembler

fn add(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegister16
) -> Result<(), IcedError>

impl CodeAsmAdd<AsmMemoryOperand, AsmRegister32> for CodeAssembler

fn add(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegister32
) -> Result<(), IcedError>

impl CodeAsmAdd<AsmMemoryOperand, AsmRegister64> for CodeAssembler

fn add(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegister64
) -> Result<(), IcedError>

impl CodeAsmAdd<AsmMemoryOperand, AsmRegister8> for CodeAssembler

fn add(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegister8
) -> Result<(), IcedError>

impl CodeAsmAdd<AsmMemoryOperand, i32> for CodeAssembler

fn add(&mut self, op0: AsmMemoryOperand, op1: i32) -> Result<(), IcedError>

impl CodeAsmAdd<AsmMemoryOperand, u32> for CodeAssembler

fn add(&mut self, op0: AsmMemoryOperand, op1: u32) -> Result<(), IcedError>

impl CodeAsmAdd<AsmRegister16, AsmMemoryOperand> for CodeAssembler

fn add(
    &mut self,
    op0: AsmRegister16,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmAdd<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn add(
    &mut self,
    op0: AsmRegister32,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmAdd<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn add(
    &mut self,
    op0: AsmRegister64,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmAdd<AsmRegister8, AsmMemoryOperand> for CodeAssembler

fn add(
    &mut self,
    op0: AsmRegister8,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmAddpd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn addpd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmAddps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn addps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmAddsd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn addsd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmAddss<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn addss(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmAddsubpd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn addsubpd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmAddsubps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn addsubps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmAdox<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn adox(
    &mut self,
    op0: AsmRegister32,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmAdox<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn adox(
    &mut self,
    op0: AsmRegister64,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmAesdec<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn aesdec(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmAesdec128kl<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn aesdec128kl(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmAesdec256kl<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn aesdec256kl(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmAesdeclast<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn aesdeclast(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmAesdecwide128kl<AsmMemoryOperand> for CodeAssembler

fn aesdecwide128kl(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmAesdecwide256kl<AsmMemoryOperand> for CodeAssembler

fn aesdecwide256kl(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmAesenc<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn aesenc(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmAesenc128kl<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn aesenc128kl(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmAesenc256kl<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn aesenc256kl(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmAesenclast<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn aesenclast(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmAesencwide128kl<AsmMemoryOperand> for CodeAssembler

fn aesencwide128kl(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmAesencwide256kl<AsmMemoryOperand> for CodeAssembler

fn aesencwide256kl(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmAesimc<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn aesimc(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmAeskeygenassist<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn aeskeygenassist(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmAeskeygenassist<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn aeskeygenassist(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmAnd<AsmMemoryOperand, AsmRegister16> for CodeAssembler

fn and(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegister16
) -> Result<(), IcedError>

impl CodeAsmAnd<AsmMemoryOperand, AsmRegister32> for CodeAssembler

fn and(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegister32
) -> Result<(), IcedError>

impl CodeAsmAnd<AsmMemoryOperand, AsmRegister64> for CodeAssembler

fn and(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegister64
) -> Result<(), IcedError>

impl CodeAsmAnd<AsmMemoryOperand, AsmRegister8> for CodeAssembler

fn and(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegister8
) -> Result<(), IcedError>

impl CodeAsmAnd<AsmMemoryOperand, i32> for CodeAssembler

fn and(&mut self, op0: AsmMemoryOperand, op1: i32) -> Result<(), IcedError>

impl CodeAsmAnd<AsmMemoryOperand, u32> for CodeAssembler

fn and(&mut self, op0: AsmMemoryOperand, op1: u32) -> Result<(), IcedError>

impl CodeAsmAnd<AsmRegister16, AsmMemoryOperand> for CodeAssembler

fn and(
    &mut self,
    op0: AsmRegister16,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmAnd<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn and(
    &mut self,
    op0: AsmRegister32,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmAnd<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn and(
    &mut self,
    op0: AsmRegister64,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmAnd<AsmRegister8, AsmMemoryOperand> for CodeAssembler

fn and(
    &mut self,
    op0: AsmRegister8,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmAndn<AsmRegister32, AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn andn(
    &mut self,
    op0: AsmRegister32,
    op1: AsmRegister32,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmAndn<AsmRegister64, AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn andn(
    &mut self,
    op0: AsmRegister64,
    op1: AsmRegister64,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmAndnpd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn andnpd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmAndnps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn andnps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmAndpd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn andpd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmAndps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn andps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmArpl<AsmMemoryOperand, AsmRegister16> for CodeAssembler

fn arpl(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegister16
) -> Result<(), IcedError>

impl CodeAsmArpl<AsmMemoryOperand, AsmRegister32> for CodeAssembler

fn arpl(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegister32
) -> Result<(), IcedError>

impl CodeAsmBextr<AsmRegister32, AsmMemoryOperand, AsmRegister32> for CodeAssembler

fn bextr(
    &mut self,
    op0: AsmRegister32,
    op1: AsmMemoryOperand,
    op2: AsmRegister32
) -> Result<(), IcedError>

impl CodeAsmBextr<AsmRegister32, AsmMemoryOperand, i32> for CodeAssembler

fn bextr(
    &mut self,
    op0: AsmRegister32,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmBextr<AsmRegister32, AsmMemoryOperand, u32> for CodeAssembler

fn bextr(
    &mut self,
    op0: AsmRegister32,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmBextr<AsmRegister64, AsmMemoryOperand, AsmRegister64> for CodeAssembler

fn bextr(
    &mut self,
    op0: AsmRegister64,
    op1: AsmMemoryOperand,
    op2: AsmRegister64
) -> Result<(), IcedError>

impl CodeAsmBextr<AsmRegister64, AsmMemoryOperand, i32> for CodeAssembler

fn bextr(
    &mut self,
    op0: AsmRegister64,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmBextr<AsmRegister64, AsmMemoryOperand, u32> for CodeAssembler

fn bextr(
    &mut self,
    op0: AsmRegister64,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmBlcfill<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn blcfill(
    &mut self,
    op0: AsmRegister32,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmBlcfill<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn blcfill(
    &mut self,
    op0: AsmRegister64,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmBlci<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn blci(
    &mut self,
    op0: AsmRegister32,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmBlci<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn blci(
    &mut self,
    op0: AsmRegister64,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmBlcic<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn blcic(
    &mut self,
    op0: AsmRegister32,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmBlcic<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn blcic(
    &mut self,
    op0: AsmRegister64,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmBlcmsk<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn blcmsk(
    &mut self,
    op0: AsmRegister32,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmBlcmsk<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn blcmsk(
    &mut self,
    op0: AsmRegister64,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmBlcs<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn blcs(
    &mut self,
    op0: AsmRegister32,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmBlcs<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn blcs(
    &mut self,
    op0: AsmRegister64,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmBlendpd<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn blendpd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmBlendpd<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn blendpd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmBlendps<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn blendps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmBlendps<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn blendps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmBlendvpd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn blendvpd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmBlendvps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn blendvps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmBlsfill<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn blsfill(
    &mut self,
    op0: AsmRegister32,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmBlsfill<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn blsfill(
    &mut self,
    op0: AsmRegister64,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmBlsi<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn blsi(
    &mut self,
    op0: AsmRegister32,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmBlsi<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn blsi(
    &mut self,
    op0: AsmRegister64,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmBlsic<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn blsic(
    &mut self,
    op0: AsmRegister32,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmBlsic<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn blsic(
    &mut self,
    op0: AsmRegister64,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmBlsmsk<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn blsmsk(
    &mut self,
    op0: AsmRegister32,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmBlsmsk<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn blsmsk(
    &mut self,
    op0: AsmRegister64,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmBlsr<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn blsr(
    &mut self,
    op0: AsmRegister32,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmBlsr<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn blsr(
    &mut self,
    op0: AsmRegister64,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmBndcl<AsmRegisterBnd, AsmMemoryOperand> for CodeAssembler

fn bndcl(
    &mut self,
    op0: AsmRegisterBnd,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmBndcn<AsmRegisterBnd, AsmMemoryOperand> for CodeAssembler

fn bndcn(
    &mut self,
    op0: AsmRegisterBnd,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmBndcu<AsmRegisterBnd, AsmMemoryOperand> for CodeAssembler

fn bndcu(
    &mut self,
    op0: AsmRegisterBnd,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmBndldx<AsmRegisterBnd, AsmMemoryOperand> for CodeAssembler

fn bndldx(
    &mut self,
    op0: AsmRegisterBnd,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmBndmk<AsmRegisterBnd, AsmMemoryOperand> for CodeAssembler

fn bndmk(
    &mut self,
    op0: AsmRegisterBnd,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmBndmov<AsmMemoryOperand, AsmRegisterBnd> for CodeAssembler

fn bndmov(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterBnd
) -> Result<(), IcedError>

impl CodeAsmBndmov<AsmRegisterBnd, AsmMemoryOperand> for CodeAssembler

fn bndmov(
    &mut self,
    op0: AsmRegisterBnd,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmBndstx<AsmMemoryOperand, AsmRegisterBnd> for CodeAssembler

fn bndstx(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterBnd
) -> Result<(), IcedError>

impl CodeAsmBound<AsmRegister16, AsmMemoryOperand> for CodeAssembler

fn bound(
    &mut self,
    op0: AsmRegister16,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmBound<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn bound(
    &mut self,
    op0: AsmRegister32,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmBsf<AsmRegister16, AsmMemoryOperand> for CodeAssembler

fn bsf(
    &mut self,
    op0: AsmRegister16,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmBsf<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn bsf(
    &mut self,
    op0: AsmRegister32,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmBsf<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn bsf(
    &mut self,
    op0: AsmRegister64,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmBsr<AsmRegister16, AsmMemoryOperand> for CodeAssembler

fn bsr(
    &mut self,
    op0: AsmRegister16,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmBsr<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn bsr(
    &mut self,
    op0: AsmRegister32,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmBsr<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn bsr(
    &mut self,
    op0: AsmRegister64,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmBt<AsmMemoryOperand, AsmRegister16> for CodeAssembler

fn bt(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegister16
) -> Result<(), IcedError>

impl CodeAsmBt<AsmMemoryOperand, AsmRegister32> for CodeAssembler

fn bt(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegister32
) -> Result<(), IcedError>

impl CodeAsmBt<AsmMemoryOperand, AsmRegister64> for CodeAssembler

fn bt(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegister64
) -> Result<(), IcedError>

impl CodeAsmBt<AsmMemoryOperand, i32> for CodeAssembler

fn bt(&mut self, op0: AsmMemoryOperand, op1: i32) -> Result<(), IcedError>

impl CodeAsmBt<AsmMemoryOperand, u32> for CodeAssembler

fn bt(&mut self, op0: AsmMemoryOperand, op1: u32) -> Result<(), IcedError>

impl CodeAsmBtc<AsmMemoryOperand, AsmRegister16> for CodeAssembler

fn btc(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegister16
) -> Result<(), IcedError>

impl CodeAsmBtc<AsmMemoryOperand, AsmRegister32> for CodeAssembler

fn btc(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegister32
) -> Result<(), IcedError>

impl CodeAsmBtc<AsmMemoryOperand, AsmRegister64> for CodeAssembler

fn btc(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegister64
) -> Result<(), IcedError>

impl CodeAsmBtc<AsmMemoryOperand, i32> for CodeAssembler

fn btc(&mut self, op0: AsmMemoryOperand, op1: i32) -> Result<(), IcedError>

impl CodeAsmBtc<AsmMemoryOperand, u32> for CodeAssembler

fn btc(&mut self, op0: AsmMemoryOperand, op1: u32) -> Result<(), IcedError>

impl CodeAsmBtr<AsmMemoryOperand, AsmRegister16> for CodeAssembler

fn btr(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegister16
) -> Result<(), IcedError>

impl CodeAsmBtr<AsmMemoryOperand, AsmRegister32> for CodeAssembler

fn btr(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegister32
) -> Result<(), IcedError>

impl CodeAsmBtr<AsmMemoryOperand, AsmRegister64> for CodeAssembler

fn btr(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegister64
) -> Result<(), IcedError>

impl CodeAsmBtr<AsmMemoryOperand, i32> for CodeAssembler

fn btr(&mut self, op0: AsmMemoryOperand, op1: i32) -> Result<(), IcedError>

impl CodeAsmBtr<AsmMemoryOperand, u32> for CodeAssembler

fn btr(&mut self, op0: AsmMemoryOperand, op1: u32) -> Result<(), IcedError>

impl CodeAsmBts<AsmMemoryOperand, AsmRegister16> for CodeAssembler

fn bts(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegister16
) -> Result<(), IcedError>

impl CodeAsmBts<AsmMemoryOperand, AsmRegister32> for CodeAssembler

fn bts(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegister32
) -> Result<(), IcedError>

impl CodeAsmBts<AsmMemoryOperand, AsmRegister64> for CodeAssembler

fn bts(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegister64
) -> Result<(), IcedError>

impl CodeAsmBts<AsmMemoryOperand, i32> for CodeAssembler

fn bts(&mut self, op0: AsmMemoryOperand, op1: i32) -> Result<(), IcedError>

impl CodeAsmBts<AsmMemoryOperand, u32> for CodeAssembler

fn bts(&mut self, op0: AsmMemoryOperand, op1: u32) -> Result<(), IcedError>

impl CodeAsmBzhi<AsmRegister32, AsmMemoryOperand, AsmRegister32> for CodeAssembler

fn bzhi(
    &mut self,
    op0: AsmRegister32,
    op1: AsmMemoryOperand,
    op2: AsmRegister32
) -> Result<(), IcedError>

impl CodeAsmBzhi<AsmRegister64, AsmMemoryOperand, AsmRegister64> for CodeAssembler

fn bzhi(
    &mut self,
    op0: AsmRegister64,
    op1: AsmMemoryOperand,
    op2: AsmRegister64
) -> Result<(), IcedError>

impl CodeAsmCall<AsmMemoryOperand> for CodeAssembler

fn call(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmCldemote<AsmMemoryOperand> for CodeAssembler

fn cldemote(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmClflush<AsmMemoryOperand> for CodeAssembler

fn clflush(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmClflushopt<AsmMemoryOperand> for CodeAssembler

fn clflushopt(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmClrssbsy<AsmMemoryOperand> for CodeAssembler

fn clrssbsy(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmClwb<AsmMemoryOperand> for CodeAssembler

fn clwb(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmCmova<AsmRegister16, AsmMemoryOperand> for CodeAssembler

fn cmova(
    &mut self,
    op0: AsmRegister16,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmCmova<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn cmova(
    &mut self,
    op0: AsmRegister32,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmCmova<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn cmova(
    &mut self,
    op0: AsmRegister64,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmCmovae<AsmRegister16, AsmMemoryOperand> for CodeAssembler

fn cmovae(
    &mut self,
    op0: AsmRegister16,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmCmovae<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn cmovae(
    &mut self,
    op0: AsmRegister32,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmCmovae<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn cmovae(
    &mut self,
    op0: AsmRegister64,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmCmovb<AsmRegister16, AsmMemoryOperand> for CodeAssembler

fn cmovb(
    &mut self,
    op0: AsmRegister16,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmCmovb<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn cmovb(
    &mut self,
    op0: AsmRegister32,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmCmovb<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn cmovb(
    &mut self,
    op0: AsmRegister64,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmCmovbe<AsmRegister16, AsmMemoryOperand> for CodeAssembler

fn cmovbe(
    &mut self,
    op0: AsmRegister16,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmCmovbe<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn cmovbe(
    &mut self,
    op0: AsmRegister32,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmCmovbe<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn cmovbe(
    &mut self,
    op0: AsmRegister64,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmCmovc<AsmRegister16, AsmMemoryOperand> for CodeAssembler

fn cmovc(
    &mut self,
    op0: AsmRegister16,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmCmovc<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn cmovc(
    &mut self,
    op0: AsmRegister32,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmCmovc<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn cmovc(
    &mut self,
    op0: AsmRegister64,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmCmove<AsmRegister16, AsmMemoryOperand> for CodeAssembler

fn cmove(
    &mut self,
    op0: AsmRegister16,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmCmove<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn cmove(
    &mut self,
    op0: AsmRegister32,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmCmove<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn cmove(
    &mut self,
    op0: AsmRegister64,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmCmovg<AsmRegister16, AsmMemoryOperand> for CodeAssembler

fn cmovg(
    &mut self,
    op0: AsmRegister16,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmCmovg<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn cmovg(
    &mut self,
    op0: AsmRegister32,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmCmovg<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn cmovg(
    &mut self,
    op0: AsmRegister64,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmCmovge<AsmRegister16, AsmMemoryOperand> for CodeAssembler

fn cmovge(
    &mut self,
    op0: AsmRegister16,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmCmovge<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn cmovge(
    &mut self,
    op0: AsmRegister32,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmCmovge<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn cmovge(
    &mut self,
    op0: AsmRegister64,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmCmovl<AsmRegister16, AsmMemoryOperand> for CodeAssembler

fn cmovl(
    &mut self,
    op0: AsmRegister16,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmCmovl<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn cmovl(
    &mut self,
    op0: AsmRegister32,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmCmovl<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn cmovl(
    &mut self,
    op0: AsmRegister64,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmCmovle<AsmRegister16, AsmMemoryOperand> for CodeAssembler

fn cmovle(
    &mut self,
    op0: AsmRegister16,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmCmovle<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn cmovle(
    &mut self,
    op0: AsmRegister32,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmCmovle<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn cmovle(
    &mut self,
    op0: AsmRegister64,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmCmovna<AsmRegister16, AsmMemoryOperand> for CodeAssembler

fn cmovna(
    &mut self,
    op0: AsmRegister16,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmCmovna<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn cmovna(
    &mut self,
    op0: AsmRegister32,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmCmovna<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn cmovna(
    &mut self,
    op0: AsmRegister64,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmCmovnae<AsmRegister16, AsmMemoryOperand> for CodeAssembler

fn cmovnae(
    &mut self,
    op0: AsmRegister16,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmCmovnae<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn cmovnae(
    &mut self,
    op0: AsmRegister32,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmCmovnae<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn cmovnae(
    &mut self,
    op0: AsmRegister64,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmCmovnb<AsmRegister16, AsmMemoryOperand> for CodeAssembler

fn cmovnb(
    &mut self,
    op0: AsmRegister16,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmCmovnb<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn cmovnb(
    &mut self,
    op0: AsmRegister32,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmCmovnb<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn cmovnb(
    &mut self,
    op0: AsmRegister64,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmCmovnbe<AsmRegister16, AsmMemoryOperand> for CodeAssembler

fn cmovnbe(
    &mut self,
    op0: AsmRegister16,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmCmovnbe<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn cmovnbe(
    &mut self,
    op0: AsmRegister32,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmCmovnbe<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn cmovnbe(
    &mut self,
    op0: AsmRegister64,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmCmovnc<AsmRegister16, AsmMemoryOperand> for CodeAssembler

fn cmovnc(
    &mut self,
    op0: AsmRegister16,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmCmovnc<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn cmovnc(
    &mut self,
    op0: AsmRegister32,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmCmovnc<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn cmovnc(
    &mut self,
    op0: AsmRegister64,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmCmovne<AsmRegister16, AsmMemoryOperand> for CodeAssembler

fn cmovne(
    &mut self,
    op0: AsmRegister16,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmCmovne<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn cmovne(
    &mut self,
    op0: AsmRegister32,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmCmovne<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn cmovne(
    &mut self,
    op0: AsmRegister64,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmCmovng<AsmRegister16, AsmMemoryOperand> for CodeAssembler

fn cmovng(
    &mut self,
    op0: AsmRegister16,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmCmovng<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn cmovng(
    &mut self,
    op0: AsmRegister32,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmCmovng<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn cmovng(
    &mut self,
    op0: AsmRegister64,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmCmovnge<AsmRegister16, AsmMemoryOperand> for CodeAssembler

fn cmovnge(
    &mut self,
    op0: AsmRegister16,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmCmovnge<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn cmovnge(
    &mut self,
    op0: AsmRegister32,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmCmovnge<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn cmovnge(
    &mut self,
    op0: AsmRegister64,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmCmovnl<AsmRegister16, AsmMemoryOperand> for CodeAssembler

fn cmovnl(
    &mut self,
    op0: AsmRegister16,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmCmovnl<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn cmovnl(
    &mut self,
    op0: AsmRegister32,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmCmovnl<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn cmovnl(
    &mut self,
    op0: AsmRegister64,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmCmovnle<AsmRegister16, AsmMemoryOperand> for CodeAssembler

fn cmovnle(
    &mut self,
    op0: AsmRegister16,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmCmovnle<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn cmovnle(
    &mut self,
    op0: AsmRegister32,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmCmovnle<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn cmovnle(
    &mut self,
    op0: AsmRegister64,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmCmovno<AsmRegister16, AsmMemoryOperand> for CodeAssembler

fn cmovno(
    &mut self,
    op0: AsmRegister16,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmCmovno<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn cmovno(
    &mut self,
    op0: AsmRegister32,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmCmovno<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn cmovno(
    &mut self,
    op0: AsmRegister64,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmCmovnp<AsmRegister16, AsmMemoryOperand> for CodeAssembler

fn cmovnp(
    &mut self,
    op0: AsmRegister16,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmCmovnp<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn cmovnp(
    &mut self,
    op0: AsmRegister32,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmCmovnp<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn cmovnp(
    &mut self,
    op0: AsmRegister64,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmCmovns<AsmRegister16, AsmMemoryOperand> for CodeAssembler

fn cmovns(
    &mut self,
    op0: AsmRegister16,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmCmovns<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn cmovns(
    &mut self,
    op0: AsmRegister32,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmCmovns<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn cmovns(
    &mut self,
    op0: AsmRegister64,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmCmovnz<AsmRegister16, AsmMemoryOperand> for CodeAssembler

fn cmovnz(
    &mut self,
    op0: AsmRegister16,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmCmovnz<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn cmovnz(
    &mut self,
    op0: AsmRegister32,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmCmovnz<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn cmovnz(
    &mut self,
    op0: AsmRegister64,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmCmovo<AsmRegister16, AsmMemoryOperand> for CodeAssembler

fn cmovo(
    &mut self,
    op0: AsmRegister16,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmCmovo<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn cmovo(
    &mut self,
    op0: AsmRegister32,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmCmovo<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn cmovo(
    &mut self,
    op0: AsmRegister64,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmCmovp<AsmRegister16, AsmMemoryOperand> for CodeAssembler

fn cmovp(
    &mut self,
    op0: AsmRegister16,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmCmovp<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn cmovp(
    &mut self,
    op0: AsmRegister32,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmCmovp<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn cmovp(
    &mut self,
    op0: AsmRegister64,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmCmovpe<AsmRegister16, AsmMemoryOperand> for CodeAssembler

fn cmovpe(
    &mut self,
    op0: AsmRegister16,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmCmovpe<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn cmovpe(
    &mut self,
    op0: AsmRegister32,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmCmovpe<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn cmovpe(
    &mut self,
    op0: AsmRegister64,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmCmovpo<AsmRegister16, AsmMemoryOperand> for CodeAssembler

fn cmovpo(
    &mut self,
    op0: AsmRegister16,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmCmovpo<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn cmovpo(
    &mut self,
    op0: AsmRegister32,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmCmovpo<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn cmovpo(
    &mut self,
    op0: AsmRegister64,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmCmovs<AsmRegister16, AsmMemoryOperand> for CodeAssembler

fn cmovs(
    &mut self,
    op0: AsmRegister16,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmCmovs<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn cmovs(
    &mut self,
    op0: AsmRegister32,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmCmovs<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn cmovs(
    &mut self,
    op0: AsmRegister64,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmCmovz<AsmRegister16, AsmMemoryOperand> for CodeAssembler

fn cmovz(
    &mut self,
    op0: AsmRegister16,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmCmovz<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn cmovz(
    &mut self,
    op0: AsmRegister32,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmCmovz<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn cmovz(
    &mut self,
    op0: AsmRegister64,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmCmp<AsmMemoryOperand, AsmRegister16> for CodeAssembler

fn cmp(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegister16
) -> Result<(), IcedError>

impl CodeAsmCmp<AsmMemoryOperand, AsmRegister32> for CodeAssembler

fn cmp(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegister32
) -> Result<(), IcedError>

impl CodeAsmCmp<AsmMemoryOperand, AsmRegister64> for CodeAssembler

fn cmp(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegister64
) -> Result<(), IcedError>

impl CodeAsmCmp<AsmMemoryOperand, AsmRegister8> for CodeAssembler

fn cmp(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegister8
) -> Result<(), IcedError>

impl CodeAsmCmp<AsmMemoryOperand, i32> for CodeAssembler

fn cmp(&mut self, op0: AsmMemoryOperand, op1: i32) -> Result<(), IcedError>

impl CodeAsmCmp<AsmMemoryOperand, u32> for CodeAssembler

fn cmp(&mut self, op0: AsmMemoryOperand, op1: u32) -> Result<(), IcedError>

impl CodeAsmCmp<AsmRegister16, AsmMemoryOperand> for CodeAssembler

fn cmp(
    &mut self,
    op0: AsmRegister16,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmCmp<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn cmp(
    &mut self,
    op0: AsmRegister32,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmCmp<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn cmp(
    &mut self,
    op0: AsmRegister64,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmCmp<AsmRegister8, AsmMemoryOperand> for CodeAssembler

fn cmp(
    &mut self,
    op0: AsmRegister8,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmCmpeqpd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn cmpeqpd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmCmpeqps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn cmpeqps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmCmpeqsd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn cmpeqsd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmCmpeqss<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn cmpeqss(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmCmplepd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn cmplepd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmCmpleps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn cmpleps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmCmplesd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn cmplesd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmCmpless<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn cmpless(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmCmpltpd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn cmpltpd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmCmpltps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn cmpltps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmCmpltsd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn cmpltsd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmCmpltss<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn cmpltss(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmCmpneqpd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn cmpneqpd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmCmpneqps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn cmpneqps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmCmpneqsd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn cmpneqsd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmCmpneqss<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn cmpneqss(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmCmpnlepd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn cmpnlepd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmCmpnleps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn cmpnleps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmCmpnlesd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn cmpnlesd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmCmpnless<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn cmpnless(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmCmpnltpd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn cmpnltpd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmCmpnltps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn cmpnltps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmCmpnltsd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn cmpnltsd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmCmpnltss<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn cmpnltss(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmCmpordpd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn cmpordpd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmCmpordps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn cmpordps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmCmpordsd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn cmpordsd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmCmpordss<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn cmpordss(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmCmppd<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn cmppd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmCmppd<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn cmppd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmCmpps<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn cmpps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmCmpps<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn cmpps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmCmpsd3<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn cmpsd_3(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmCmpsd3<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn cmpsd_3(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmCmpss<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn cmpss(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmCmpss<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn cmpss(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmCmpunordpd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn cmpunordpd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmCmpunordps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn cmpunordps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmCmpunordsd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn cmpunordsd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmCmpunordss<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn cmpunordss(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmCmpxchg<AsmMemoryOperand, AsmRegister16> for CodeAssembler

fn cmpxchg(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegister16
) -> Result<(), IcedError>

impl CodeAsmCmpxchg<AsmMemoryOperand, AsmRegister32> for CodeAssembler

fn cmpxchg(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegister32
) -> Result<(), IcedError>

impl CodeAsmCmpxchg<AsmMemoryOperand, AsmRegister64> for CodeAssembler

fn cmpxchg(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegister64
) -> Result<(), IcedError>

impl CodeAsmCmpxchg<AsmMemoryOperand, AsmRegister8> for CodeAssembler

fn cmpxchg(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegister8
) -> Result<(), IcedError>

impl CodeAsmCmpxchg16b<AsmMemoryOperand> for CodeAssembler

fn cmpxchg16b(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmCmpxchg8b<AsmMemoryOperand> for CodeAssembler

fn cmpxchg8b(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmComisd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn comisd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmComiss<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn comiss(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmCrc32<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn crc32(
    &mut self,
    op0: AsmRegister32,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmCrc32<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn crc32(
    &mut self,
    op0: AsmRegister64,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmCvtdq2pd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn cvtdq2pd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmCvtdq2ps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn cvtdq2ps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmCvtpd2dq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn cvtpd2dq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmCvtpd2pi<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn cvtpd2pi(
    &mut self,
    op0: AsmRegisterMm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmCvtpd2ps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn cvtpd2ps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmCvtpi2pd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn cvtpi2pd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmCvtpi2ps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn cvtpi2ps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmCvtps2dq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn cvtps2dq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmCvtps2pd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn cvtps2pd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmCvtps2pi<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn cvtps2pi(
    &mut self,
    op0: AsmRegisterMm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmCvtsd2si<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn cvtsd2si(
    &mut self,
    op0: AsmRegister32,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmCvtsd2si<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn cvtsd2si(
    &mut self,
    op0: AsmRegister64,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmCvtsd2ss<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn cvtsd2ss(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmCvtsi2sd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn cvtsi2sd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmCvtsi2ss<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn cvtsi2ss(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmCvtss2sd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn cvtss2sd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmCvtss2si<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn cvtss2si(
    &mut self,
    op0: AsmRegister32,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmCvtss2si<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn cvtss2si(
    &mut self,
    op0: AsmRegister64,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmCvttpd2dq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn cvttpd2dq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmCvttpd2pi<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn cvttpd2pi(
    &mut self,
    op0: AsmRegisterMm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmCvttps2dq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn cvttps2dq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmCvttps2pi<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn cvttps2pi(
    &mut self,
    op0: AsmRegisterMm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmCvttsd2si<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn cvttsd2si(
    &mut self,
    op0: AsmRegister32,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmCvttsd2si<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn cvttsd2si(
    &mut self,
    op0: AsmRegister64,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmCvttss2si<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn cvttss2si(
    &mut self,
    op0: AsmRegister32,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmCvttss2si<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn cvttss2si(
    &mut self,
    op0: AsmRegister64,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmDec<AsmMemoryOperand> for CodeAssembler

fn dec(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmDiv<AsmMemoryOperand> for CodeAssembler

fn div(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmDivpd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn divpd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmDivps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn divps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmDivsd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn divsd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmDivss<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn divss(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmDppd<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn dppd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmDppd<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn dppd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmDpps<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn dpps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmDpps<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn dpps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmEnqcmd<AsmRegister16, AsmMemoryOperand> for CodeAssembler

fn enqcmd(
    &mut self,
    op0: AsmRegister16,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmEnqcmd<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn enqcmd(
    &mut self,
    op0: AsmRegister32,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmEnqcmd<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn enqcmd(
    &mut self,
    op0: AsmRegister64,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmEnqcmds<AsmRegister16, AsmMemoryOperand> for CodeAssembler

fn enqcmds(
    &mut self,
    op0: AsmRegister16,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmEnqcmds<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn enqcmds(
    &mut self,
    op0: AsmRegister32,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmEnqcmds<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn enqcmds(
    &mut self,
    op0: AsmRegister64,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmExtractps<AsmMemoryOperand, AsmRegisterXmm, i32> for CodeAssembler

fn extractps(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterXmm,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmExtractps<AsmMemoryOperand, AsmRegisterXmm, u32> for CodeAssembler

fn extractps(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterXmm,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmFadd<AsmMemoryOperand> for CodeAssembler

fn fadd(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmFbld<AsmMemoryOperand> for CodeAssembler

fn fbld(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmFbstp<AsmMemoryOperand> for CodeAssembler

fn fbstp(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmFcom<AsmMemoryOperand> for CodeAssembler

fn fcom(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmFcomp<AsmMemoryOperand> for CodeAssembler

fn fcomp(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmFdiv<AsmMemoryOperand> for CodeAssembler

fn fdiv(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmFdivr<AsmMemoryOperand> for CodeAssembler

fn fdivr(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmFiadd<AsmMemoryOperand> for CodeAssembler

fn fiadd(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmFicom<AsmMemoryOperand> for CodeAssembler

fn ficom(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmFicomp<AsmMemoryOperand> for CodeAssembler

fn ficomp(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmFidiv<AsmMemoryOperand> for CodeAssembler

fn fidiv(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmFidivr<AsmMemoryOperand> for CodeAssembler

fn fidivr(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmFild<AsmMemoryOperand> for CodeAssembler

fn fild(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmFimul<AsmMemoryOperand> for CodeAssembler

fn fimul(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmFist<AsmMemoryOperand> for CodeAssembler

fn fist(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmFistp<AsmMemoryOperand> for CodeAssembler

fn fistp(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmFisttp<AsmMemoryOperand> for CodeAssembler

fn fisttp(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmFisub<AsmMemoryOperand> for CodeAssembler

fn fisub(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmFisubr<AsmMemoryOperand> for CodeAssembler

fn fisubr(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmFld<AsmMemoryOperand> for CodeAssembler

fn fld(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmFldcw<AsmMemoryOperand> for CodeAssembler

fn fldcw(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmFldenv<AsmMemoryOperand> for CodeAssembler

fn fldenv(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmFmul<AsmMemoryOperand> for CodeAssembler

fn fmul(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmFnsave<AsmMemoryOperand> for CodeAssembler

fn fnsave(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmFnstcw<AsmMemoryOperand> for CodeAssembler

fn fnstcw(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmFnstenv<AsmMemoryOperand> for CodeAssembler

fn fnstenv(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmFnstsw<AsmMemoryOperand> for CodeAssembler

fn fnstsw(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmFrstor<AsmMemoryOperand> for CodeAssembler

fn frstor(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmFsave<AsmMemoryOperand> for CodeAssembler

fn fsave(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmFst<AsmMemoryOperand> for CodeAssembler

fn fst(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmFstcw<AsmMemoryOperand> for CodeAssembler

fn fstcw(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmFstenv<AsmMemoryOperand> for CodeAssembler

fn fstenv(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmFstp<AsmMemoryOperand> for CodeAssembler

fn fstp(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmFstsw<AsmMemoryOperand> for CodeAssembler

fn fstsw(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmFsub<AsmMemoryOperand> for CodeAssembler

fn fsub(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmFsubr<AsmMemoryOperand> for CodeAssembler

fn fsubr(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmFxrstor<AsmMemoryOperand> for CodeAssembler

fn fxrstor(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmFxrstor64<AsmMemoryOperand> for CodeAssembler

fn fxrstor64(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmFxsave<AsmMemoryOperand> for CodeAssembler

fn fxsave(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmFxsave64<AsmMemoryOperand> for CodeAssembler

fn fxsave64(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmGf2p8affineinvqb<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn gf2p8affineinvqb(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmGf2p8affineinvqb<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn gf2p8affineinvqb(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmGf2p8affineqb<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn gf2p8affineqb(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmGf2p8affineqb<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn gf2p8affineqb(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmGf2p8mulb<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn gf2p8mulb(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmHaddpd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn haddpd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmHaddps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn haddps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmHsubpd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn hsubpd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmHsubps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn hsubps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmIbts<AsmMemoryOperand, AsmRegister16> for CodeAssembler

fn ibts(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegister16
) -> Result<(), IcedError>

impl CodeAsmIbts<AsmMemoryOperand, AsmRegister32> for CodeAssembler

fn ibts(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegister32
) -> Result<(), IcedError>

impl CodeAsmIdiv<AsmMemoryOperand> for CodeAssembler

fn idiv(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmImul<AsmMemoryOperand> for CodeAssembler

fn imul(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmImul2<AsmRegister16, AsmMemoryOperand> for CodeAssembler

fn imul_2(
    &mut self,
    op0: AsmRegister16,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmImul2<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn imul_2(
    &mut self,
    op0: AsmRegister32,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmImul2<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn imul_2(
    &mut self,
    op0: AsmRegister64,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmImul3<AsmRegister16, AsmMemoryOperand, i32> for CodeAssembler

fn imul_3(
    &mut self,
    op0: AsmRegister16,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmImul3<AsmRegister16, AsmMemoryOperand, u32> for CodeAssembler

fn imul_3(
    &mut self,
    op0: AsmRegister16,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmImul3<AsmRegister32, AsmMemoryOperand, i32> for CodeAssembler

fn imul_3(
    &mut self,
    op0: AsmRegister32,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmImul3<AsmRegister32, AsmMemoryOperand, u32> for CodeAssembler

fn imul_3(
    &mut self,
    op0: AsmRegister32,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmImul3<AsmRegister64, AsmMemoryOperand, i32> for CodeAssembler

fn imul_3(
    &mut self,
    op0: AsmRegister64,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmInc<AsmMemoryOperand> for CodeAssembler

fn inc(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmInsertps<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn insertps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmInsertps<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn insertps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmInvept<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn invept(
    &mut self,
    op0: AsmRegister32,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmInvept<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn invept(
    &mut self,
    op0: AsmRegister64,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmInvlpg<AsmMemoryOperand> for CodeAssembler

fn invlpg(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmInvpcid<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn invpcid(
    &mut self,
    op0: AsmRegister32,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmInvpcid<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn invpcid(
    &mut self,
    op0: AsmRegister64,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmInvvpid<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn invvpid(
    &mut self,
    op0: AsmRegister32,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmInvvpid<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn invvpid(
    &mut self,
    op0: AsmRegister64,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmJmp<AsmMemoryOperand> for CodeAssembler

fn jmp(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmJmpe<AsmMemoryOperand> for CodeAssembler

fn jmpe(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmKmovb<AsmMemoryOperand, AsmRegisterK> for CodeAssembler

fn kmovb(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterK
) -> Result<(), IcedError>

impl CodeAsmKmovb<AsmRegisterK, AsmMemoryOperand> for CodeAssembler

fn kmovb(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmKmovd<AsmMemoryOperand, AsmRegisterK> for CodeAssembler

fn kmovd(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterK
) -> Result<(), IcedError>

impl CodeAsmKmovd<AsmRegisterK, AsmMemoryOperand> for CodeAssembler

fn kmovd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmKmovq<AsmMemoryOperand, AsmRegisterK> for CodeAssembler

fn kmovq(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterK
) -> Result<(), IcedError>

impl CodeAsmKmovq<AsmRegisterK, AsmMemoryOperand> for CodeAssembler

fn kmovq(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmKmovw<AsmMemoryOperand, AsmRegisterK> for CodeAssembler

fn kmovw(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterK
) -> Result<(), IcedError>

impl CodeAsmKmovw<AsmRegisterK, AsmMemoryOperand> for CodeAssembler

fn kmovw(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmLar<AsmRegister16, AsmMemoryOperand> for CodeAssembler

fn lar(
    &mut self,
    op0: AsmRegister16,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmLar<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn lar(
    &mut self,
    op0: AsmRegister32,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmLddqu<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn lddqu(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmLdmxcsr<AsmMemoryOperand> for CodeAssembler

fn ldmxcsr(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmLds<AsmRegister16, AsmMemoryOperand> for CodeAssembler

fn lds(
    &mut self,
    op0: AsmRegister16,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmLds<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn lds(
    &mut self,
    op0: AsmRegister32,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmLdtilecfg<AsmMemoryOperand> for CodeAssembler

fn ldtilecfg(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmLea<AsmRegister16, AsmMemoryOperand> for CodeAssembler

fn lea(
    &mut self,
    op0: AsmRegister16,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmLea<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn lea(
    &mut self,
    op0: AsmRegister32,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmLea<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn lea(
    &mut self,
    op0: AsmRegister64,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmLes<AsmRegister16, AsmMemoryOperand> for CodeAssembler

fn les(
    &mut self,
    op0: AsmRegister16,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmLes<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn les(
    &mut self,
    op0: AsmRegister32,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmLfs<AsmRegister16, AsmMemoryOperand> for CodeAssembler

fn lfs(
    &mut self,
    op0: AsmRegister16,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmLfs<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn lfs(
    &mut self,
    op0: AsmRegister32,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmLfs<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn lfs(
    &mut self,
    op0: AsmRegister64,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmLgdt<AsmMemoryOperand> for CodeAssembler

fn lgdt(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmLgs<AsmRegister16, AsmMemoryOperand> for CodeAssembler

fn lgs(
    &mut self,
    op0: AsmRegister16,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmLgs<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn lgs(
    &mut self,
    op0: AsmRegister32,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmLgs<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn lgs(
    &mut self,
    op0: AsmRegister64,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmLidt<AsmMemoryOperand> for CodeAssembler

fn lidt(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmLkgs<AsmMemoryOperand> for CodeAssembler

fn lkgs(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmLldt<AsmMemoryOperand> for CodeAssembler

fn lldt(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmLmsw<AsmMemoryOperand> for CodeAssembler

fn lmsw(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmLsl<AsmRegister16, AsmMemoryOperand> for CodeAssembler

fn lsl(
    &mut self,
    op0: AsmRegister16,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmLsl<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn lsl(
    &mut self,
    op0: AsmRegister32,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmLss<AsmRegister16, AsmMemoryOperand> for CodeAssembler

fn lss(
    &mut self,
    op0: AsmRegister16,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmLss<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn lss(
    &mut self,
    op0: AsmRegister32,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmLss<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn lss(
    &mut self,
    op0: AsmRegister64,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmLtr<AsmMemoryOperand> for CodeAssembler

fn ltr(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmLwpins<AsmRegister32, AsmMemoryOperand, i32> for CodeAssembler

fn lwpins(
    &mut self,
    op0: AsmRegister32,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmLwpins<AsmRegister32, AsmMemoryOperand, u32> for CodeAssembler

fn lwpins(
    &mut self,
    op0: AsmRegister32,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmLwpins<AsmRegister64, AsmMemoryOperand, i32> for CodeAssembler

fn lwpins(
    &mut self,
    op0: AsmRegister64,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmLwpins<AsmRegister64, AsmMemoryOperand, u32> for CodeAssembler

fn lwpins(
    &mut self,
    op0: AsmRegister64,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmLwpval<AsmRegister32, AsmMemoryOperand, i32> for CodeAssembler

fn lwpval(
    &mut self,
    op0: AsmRegister32,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmLwpval<AsmRegister32, AsmMemoryOperand, u32> for CodeAssembler

fn lwpval(
    &mut self,
    op0: AsmRegister32,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmLwpval<AsmRegister64, AsmMemoryOperand, i32> for CodeAssembler

fn lwpval(
    &mut self,
    op0: AsmRegister64,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmLwpval<AsmRegister64, AsmMemoryOperand, u32> for CodeAssembler

fn lwpval(
    &mut self,
    op0: AsmRegister64,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmLzcnt<AsmRegister16, AsmMemoryOperand> for CodeAssembler

fn lzcnt(
    &mut self,
    op0: AsmRegister16,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmLzcnt<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn lzcnt(
    &mut self,
    op0: AsmRegister32,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmLzcnt<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn lzcnt(
    &mut self,
    op0: AsmRegister64,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmMaxpd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn maxpd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmMaxps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn maxps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmMaxsd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn maxsd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmMaxss<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn maxss(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmMinpd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn minpd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmMinps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn minps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmMinsd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn minsd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmMinss<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn minss(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmMov<AsmMemoryOperand, AsmRegister16> for CodeAssembler

fn mov(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegister16
) -> Result<(), IcedError>

impl CodeAsmMov<AsmMemoryOperand, AsmRegister32> for CodeAssembler

fn mov(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegister32
) -> Result<(), IcedError>

impl CodeAsmMov<AsmMemoryOperand, AsmRegister64> for CodeAssembler

fn mov(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegister64
) -> Result<(), IcedError>

impl CodeAsmMov<AsmMemoryOperand, AsmRegister8> for CodeAssembler

fn mov(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegister8
) -> Result<(), IcedError>

impl CodeAsmMov<AsmMemoryOperand, AsmRegisterSegment> for CodeAssembler

fn mov(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterSegment
) -> Result<(), IcedError>

impl CodeAsmMov<AsmMemoryOperand, i32> for CodeAssembler

fn mov(&mut self, op0: AsmMemoryOperand, op1: i32) -> Result<(), IcedError>

impl CodeAsmMov<AsmMemoryOperand, u32> for CodeAssembler

fn mov(&mut self, op0: AsmMemoryOperand, op1: u32) -> Result<(), IcedError>

impl CodeAsmMov<AsmRegister16, AsmMemoryOperand> for CodeAssembler

fn mov(
    &mut self,
    op0: AsmRegister16,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmMov<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn mov(
    &mut self,
    op0: AsmRegister32,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmMov<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn mov(
    &mut self,
    op0: AsmRegister64,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmMov<AsmRegister8, AsmMemoryOperand> for CodeAssembler

fn mov(
    &mut self,
    op0: AsmRegister8,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmMov<AsmRegisterSegment, AsmMemoryOperand> for CodeAssembler

fn mov(
    &mut self,
    op0: AsmRegisterSegment,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmMovapd<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn movapd(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterXmm
) -> Result<(), IcedError>

impl CodeAsmMovapd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn movapd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmMovaps<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn movaps(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterXmm
) -> Result<(), IcedError>

impl CodeAsmMovaps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn movaps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmMovbe<AsmMemoryOperand, AsmRegister16> for CodeAssembler

fn movbe(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegister16
) -> Result<(), IcedError>

impl CodeAsmMovbe<AsmMemoryOperand, AsmRegister32> for CodeAssembler

fn movbe(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegister32
) -> Result<(), IcedError>

impl CodeAsmMovbe<AsmMemoryOperand, AsmRegister64> for CodeAssembler

fn movbe(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegister64
) -> Result<(), IcedError>

impl CodeAsmMovbe<AsmRegister16, AsmMemoryOperand> for CodeAssembler

fn movbe(
    &mut self,
    op0: AsmRegister16,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmMovbe<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn movbe(
    &mut self,
    op0: AsmRegister32,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmMovbe<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn movbe(
    &mut self,
    op0: AsmRegister64,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmMovd<AsmMemoryOperand, AsmRegisterMm> for CodeAssembler

fn movd(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterMm
) -> Result<(), IcedError>

impl CodeAsmMovd<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn movd(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterXmm
) -> Result<(), IcedError>

impl CodeAsmMovd<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn movd(
    &mut self,
    op0: AsmRegisterMm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmMovd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn movd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmMovddup<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn movddup(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmMovdir64b<AsmRegister16, AsmMemoryOperand> for CodeAssembler

fn movdir64b(
    &mut self,
    op0: AsmRegister16,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmMovdir64b<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn movdir64b(
    &mut self,
    op0: AsmRegister32,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmMovdir64b<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn movdir64b(
    &mut self,
    op0: AsmRegister64,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmMovdiri<AsmMemoryOperand, AsmRegister32> for CodeAssembler

fn movdiri(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegister32
) -> Result<(), IcedError>

impl CodeAsmMovdiri<AsmMemoryOperand, AsmRegister64> for CodeAssembler

fn movdiri(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegister64
) -> Result<(), IcedError>

impl CodeAsmMovdqa<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn movdqa(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterXmm
) -> Result<(), IcedError>

impl CodeAsmMovdqa<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn movdqa(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmMovdqu<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn movdqu(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterXmm
) -> Result<(), IcedError>

impl CodeAsmMovdqu<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn movdqu(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmMovhpd<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn movhpd(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterXmm
) -> Result<(), IcedError>

impl CodeAsmMovhpd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn movhpd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmMovhps<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn movhps(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterXmm
) -> Result<(), IcedError>

impl CodeAsmMovhps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn movhps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmMovlpd<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn movlpd(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterXmm
) -> Result<(), IcedError>

impl CodeAsmMovlpd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn movlpd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmMovlps<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn movlps(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterXmm
) -> Result<(), IcedError>

impl CodeAsmMovlps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn movlps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmMovntdq<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn movntdq(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterXmm
) -> Result<(), IcedError>

impl CodeAsmMovntdqa<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn movntdqa(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmMovnti<AsmMemoryOperand, AsmRegister32> for CodeAssembler

fn movnti(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegister32
) -> Result<(), IcedError>

impl CodeAsmMovnti<AsmMemoryOperand, AsmRegister64> for CodeAssembler

fn movnti(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegister64
) -> Result<(), IcedError>

impl CodeAsmMovntpd<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn movntpd(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterXmm
) -> Result<(), IcedError>

impl CodeAsmMovntps<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn movntps(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterXmm
) -> Result<(), IcedError>

impl CodeAsmMovntq<AsmMemoryOperand, AsmRegisterMm> for CodeAssembler

fn movntq(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterMm
) -> Result<(), IcedError>

impl CodeAsmMovntsd<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn movntsd(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterXmm
) -> Result<(), IcedError>

impl CodeAsmMovntss<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn movntss(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterXmm
) -> Result<(), IcedError>

impl CodeAsmMovq<AsmMemoryOperand, AsmRegisterMm> for CodeAssembler

fn movq(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterMm
) -> Result<(), IcedError>

impl CodeAsmMovq<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn movq(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterXmm
) -> Result<(), IcedError>

impl CodeAsmMovq<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn movq(
    &mut self,
    op0: AsmRegisterMm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmMovq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn movq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmMovsd2<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn movsd_2(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterXmm
) -> Result<(), IcedError>

impl CodeAsmMovsd2<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn movsd_2(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmMovshdup<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn movshdup(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmMovsldup<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn movsldup(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmMovss<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn movss(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterXmm
) -> Result<(), IcedError>

impl CodeAsmMovss<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn movss(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmMovsx<AsmRegister16, AsmMemoryOperand> for CodeAssembler

fn movsx(
    &mut self,
    op0: AsmRegister16,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmMovsx<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn movsx(
    &mut self,
    op0: AsmRegister32,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmMovsx<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn movsx(
    &mut self,
    op0: AsmRegister64,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmMovsxd<AsmRegister16, AsmMemoryOperand> for CodeAssembler

fn movsxd(
    &mut self,
    op0: AsmRegister16,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmMovsxd<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn movsxd(
    &mut self,
    op0: AsmRegister32,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmMovsxd<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn movsxd(
    &mut self,
    op0: AsmRegister64,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmMovupd<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn movupd(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterXmm
) -> Result<(), IcedError>

impl CodeAsmMovupd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn movupd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmMovups<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn movups(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterXmm
) -> Result<(), IcedError>

impl CodeAsmMovups<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn movups(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmMovzx<AsmRegister16, AsmMemoryOperand> for CodeAssembler

fn movzx(
    &mut self,
    op0: AsmRegister16,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmMovzx<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn movzx(
    &mut self,
    op0: AsmRegister32,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmMovzx<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn movzx(
    &mut self,
    op0: AsmRegister64,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmMpsadbw<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn mpsadbw(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmMpsadbw<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn mpsadbw(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmMul<AsmMemoryOperand> for CodeAssembler

fn mul(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmMulpd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn mulpd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmMulps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn mulps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmMulsd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn mulsd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmMulss<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn mulss(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmMulx<AsmRegister32, AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn mulx(
    &mut self,
    op0: AsmRegister32,
    op1: AsmRegister32,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmMulx<AsmRegister64, AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn mulx(
    &mut self,
    op0: AsmRegister64,
    op1: AsmRegister64,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmNeg<AsmMemoryOperand> for CodeAssembler

fn neg(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmNop1<AsmMemoryOperand> for CodeAssembler

fn nop_1(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmNot<AsmMemoryOperand> for CodeAssembler

fn not(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmOr<AsmMemoryOperand, AsmRegister16> for CodeAssembler

fn or(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegister16
) -> Result<(), IcedError>

impl CodeAsmOr<AsmMemoryOperand, AsmRegister32> for CodeAssembler

fn or(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegister32
) -> Result<(), IcedError>

impl CodeAsmOr<AsmMemoryOperand, AsmRegister64> for CodeAssembler

fn or(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegister64
) -> Result<(), IcedError>

impl CodeAsmOr<AsmMemoryOperand, AsmRegister8> for CodeAssembler

fn or(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegister8
) -> Result<(), IcedError>

impl CodeAsmOr<AsmMemoryOperand, i32> for CodeAssembler

fn or(&mut self, op0: AsmMemoryOperand, op1: i32) -> Result<(), IcedError>

impl CodeAsmOr<AsmMemoryOperand, u32> for CodeAssembler

fn or(&mut self, op0: AsmMemoryOperand, op1: u32) -> Result<(), IcedError>

impl CodeAsmOr<AsmRegister16, AsmMemoryOperand> for CodeAssembler

fn or(
    &mut self,
    op0: AsmRegister16,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmOr<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn or(
    &mut self,
    op0: AsmRegister32,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmOr<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn or(
    &mut self,
    op0: AsmRegister64,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmOr<AsmRegister8, AsmMemoryOperand> for CodeAssembler

fn or(
    &mut self,
    op0: AsmRegister8,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmOrpd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn orpd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmOrps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn orps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPabsb<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn pabsb(
    &mut self,
    op0: AsmRegisterMm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPabsb<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn pabsb(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPabsd<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn pabsd(
    &mut self,
    op0: AsmRegisterMm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPabsd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn pabsd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPabsw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn pabsw(
    &mut self,
    op0: AsmRegisterMm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPabsw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn pabsw(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPackssdw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn packssdw(
    &mut self,
    op0: AsmRegisterMm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPackssdw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn packssdw(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPacksswb<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn packsswb(
    &mut self,
    op0: AsmRegisterMm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPacksswb<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn packsswb(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPackusdw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn packusdw(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPackuswb<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn packuswb(
    &mut self,
    op0: AsmRegisterMm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPackuswb<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn packuswb(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPaddb<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn paddb(
    &mut self,
    op0: AsmRegisterMm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPaddb<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn paddb(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPaddd<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn paddd(
    &mut self,
    op0: AsmRegisterMm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPaddd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn paddd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPaddq<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn paddq(
    &mut self,
    op0: AsmRegisterMm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPaddq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn paddq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPaddsb<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn paddsb(
    &mut self,
    op0: AsmRegisterMm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPaddsb<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn paddsb(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPaddsiw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn paddsiw(
    &mut self,
    op0: AsmRegisterMm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPaddsw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn paddsw(
    &mut self,
    op0: AsmRegisterMm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPaddsw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn paddsw(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPaddusb<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn paddusb(
    &mut self,
    op0: AsmRegisterMm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPaddusb<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn paddusb(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPaddusw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn paddusw(
    &mut self,
    op0: AsmRegisterMm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPaddusw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn paddusw(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPaddw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn paddw(
    &mut self,
    op0: AsmRegisterMm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPaddw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn paddw(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPalignr<AsmRegisterMm, AsmMemoryOperand, i32> for CodeAssembler

fn palignr(
    &mut self,
    op0: AsmRegisterMm,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmPalignr<AsmRegisterMm, AsmMemoryOperand, u32> for CodeAssembler

fn palignr(
    &mut self,
    op0: AsmRegisterMm,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmPalignr<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn palignr(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmPalignr<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn palignr(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmPand<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn pand(
    &mut self,
    op0: AsmRegisterMm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPand<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn pand(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPandn<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn pandn(
    &mut self,
    op0: AsmRegisterMm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPandn<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn pandn(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPaveb<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn paveb(
    &mut self,
    op0: AsmRegisterMm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPavgb<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn pavgb(
    &mut self,
    op0: AsmRegisterMm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPavgb<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn pavgb(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPavgusb<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn pavgusb(
    &mut self,
    op0: AsmRegisterMm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPavgw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn pavgw(
    &mut self,
    op0: AsmRegisterMm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPavgw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn pavgw(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPblendvb<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn pblendvb(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPblendw<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn pblendw(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmPblendw<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn pblendw(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmPclmulhqhqdq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn pclmulhqhqdq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPclmulhqlqdq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn pclmulhqlqdq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPclmullqhqdq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn pclmullqhqdq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPclmullqlqdq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn pclmullqlqdq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPclmulqdq<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn pclmulqdq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmPclmulqdq<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn pclmulqdq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmPcmpeqb<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn pcmpeqb(
    &mut self,
    op0: AsmRegisterMm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPcmpeqb<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn pcmpeqb(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPcmpeqd<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn pcmpeqd(
    &mut self,
    op0: AsmRegisterMm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPcmpeqd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn pcmpeqd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPcmpeqq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn pcmpeqq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPcmpeqw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn pcmpeqw(
    &mut self,
    op0: AsmRegisterMm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPcmpeqw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn pcmpeqw(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPcmpestri<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn pcmpestri(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmPcmpestri<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn pcmpestri(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmPcmpestri64<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn pcmpestri64(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmPcmpestri64<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn pcmpestri64(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmPcmpestrm<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn pcmpestrm(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmPcmpestrm<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn pcmpestrm(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmPcmpestrm64<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn pcmpestrm64(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmPcmpestrm64<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn pcmpestrm64(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmPcmpgtb<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn pcmpgtb(
    &mut self,
    op0: AsmRegisterMm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPcmpgtb<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn pcmpgtb(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPcmpgtd<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn pcmpgtd(
    &mut self,
    op0: AsmRegisterMm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPcmpgtd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn pcmpgtd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPcmpgtq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn pcmpgtq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPcmpgtw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn pcmpgtw(
    &mut self,
    op0: AsmRegisterMm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPcmpgtw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn pcmpgtw(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPcmpistri<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn pcmpistri(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmPcmpistri<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn pcmpistri(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmPcmpistrm<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn pcmpistrm(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmPcmpistrm<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn pcmpistrm(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmPdep<AsmRegister32, AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn pdep(
    &mut self,
    op0: AsmRegister32,
    op1: AsmRegister32,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPdep<AsmRegister64, AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn pdep(
    &mut self,
    op0: AsmRegister64,
    op1: AsmRegister64,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPdistib<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn pdistib(
    &mut self,
    op0: AsmRegisterMm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPext<AsmRegister32, AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn pext(
    &mut self,
    op0: AsmRegister32,
    op1: AsmRegister32,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPext<AsmRegister64, AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn pext(
    &mut self,
    op0: AsmRegister64,
    op1: AsmRegister64,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPextrb<AsmMemoryOperand, AsmRegisterXmm, i32> for CodeAssembler

fn pextrb(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterXmm,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmPextrb<AsmMemoryOperand, AsmRegisterXmm, u32> for CodeAssembler

fn pextrb(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterXmm,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmPextrd<AsmMemoryOperand, AsmRegisterXmm, i32> for CodeAssembler

fn pextrd(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterXmm,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmPextrd<AsmMemoryOperand, AsmRegisterXmm, u32> for CodeAssembler

fn pextrd(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterXmm,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmPextrq<AsmMemoryOperand, AsmRegisterXmm, i32> for CodeAssembler

fn pextrq(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterXmm,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmPextrq<AsmMemoryOperand, AsmRegisterXmm, u32> for CodeAssembler

fn pextrq(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterXmm,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmPextrw<AsmMemoryOperand, AsmRegisterXmm, i32> for CodeAssembler

fn pextrw(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterXmm,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmPextrw<AsmMemoryOperand, AsmRegisterXmm, u32> for CodeAssembler

fn pextrw(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterXmm,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmPf2id<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn pf2id(
    &mut self,
    op0: AsmRegisterMm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPf2iw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn pf2iw(
    &mut self,
    op0: AsmRegisterMm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPfacc<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn pfacc(
    &mut self,
    op0: AsmRegisterMm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPfadd<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn pfadd(
    &mut self,
    op0: AsmRegisterMm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPfcmpeq<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn pfcmpeq(
    &mut self,
    op0: AsmRegisterMm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPfcmpge<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn pfcmpge(
    &mut self,
    op0: AsmRegisterMm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPfcmpgt<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn pfcmpgt(
    &mut self,
    op0: AsmRegisterMm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPfmax<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn pfmax(
    &mut self,
    op0: AsmRegisterMm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPfmin<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn pfmin(
    &mut self,
    op0: AsmRegisterMm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPfmul<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn pfmul(
    &mut self,
    op0: AsmRegisterMm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPfnacc<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn pfnacc(
    &mut self,
    op0: AsmRegisterMm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPfpnacc<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn pfpnacc(
    &mut self,
    op0: AsmRegisterMm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPfrcp<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn pfrcp(
    &mut self,
    op0: AsmRegisterMm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPfrcpit1<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn pfrcpit1(
    &mut self,
    op0: AsmRegisterMm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPfrcpit2<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn pfrcpit2(
    &mut self,
    op0: AsmRegisterMm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPfrcpv<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn pfrcpv(
    &mut self,
    op0: AsmRegisterMm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPfrsqit1<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn pfrsqit1(
    &mut self,
    op0: AsmRegisterMm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPfrsqrt<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn pfrsqrt(
    &mut self,
    op0: AsmRegisterMm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPfrsqrtv<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn pfrsqrtv(
    &mut self,
    op0: AsmRegisterMm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPfsub<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn pfsub(
    &mut self,
    op0: AsmRegisterMm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPfsubr<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn pfsubr(
    &mut self,
    op0: AsmRegisterMm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPhaddd<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn phaddd(
    &mut self,
    op0: AsmRegisterMm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPhaddd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn phaddd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPhaddsw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn phaddsw(
    &mut self,
    op0: AsmRegisterMm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPhaddsw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn phaddsw(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPhaddw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn phaddw(
    &mut self,
    op0: AsmRegisterMm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPhaddw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn phaddw(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPhminposuw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn phminposuw(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPhsubd<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn phsubd(
    &mut self,
    op0: AsmRegisterMm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPhsubd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn phsubd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPhsubsw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn phsubsw(
    &mut self,
    op0: AsmRegisterMm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPhsubsw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn phsubsw(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPhsubw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn phsubw(
    &mut self,
    op0: AsmRegisterMm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPhsubw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn phsubw(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPi2fd<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn pi2fd(
    &mut self,
    op0: AsmRegisterMm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPi2fw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn pi2fw(
    &mut self,
    op0: AsmRegisterMm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPinsrb<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn pinsrb(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmPinsrb<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn pinsrb(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmPinsrd<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn pinsrd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmPinsrd<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn pinsrd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmPinsrq<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn pinsrq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmPinsrq<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn pinsrq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmPinsrw<AsmRegisterMm, AsmMemoryOperand, i32> for CodeAssembler

fn pinsrw(
    &mut self,
    op0: AsmRegisterMm,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmPinsrw<AsmRegisterMm, AsmMemoryOperand, u32> for CodeAssembler

fn pinsrw(
    &mut self,
    op0: AsmRegisterMm,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmPinsrw<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn pinsrw(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmPinsrw<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn pinsrw(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmPmachriw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn pmachriw(
    &mut self,
    op0: AsmRegisterMm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPmaddubsw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn pmaddubsw(
    &mut self,
    op0: AsmRegisterMm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPmaddubsw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn pmaddubsw(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPmaddwd<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn pmaddwd(
    &mut self,
    op0: AsmRegisterMm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPmaddwd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn pmaddwd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPmagw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn pmagw(
    &mut self,
    op0: AsmRegisterMm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPmaxsb<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn pmaxsb(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPmaxsd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn pmaxsd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPmaxsw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn pmaxsw(
    &mut self,
    op0: AsmRegisterMm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPmaxsw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn pmaxsw(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPmaxub<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn pmaxub(
    &mut self,
    op0: AsmRegisterMm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPmaxub<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn pmaxub(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPmaxud<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn pmaxud(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPmaxuw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn pmaxuw(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPminsb<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn pminsb(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPminsd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn pminsd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPminsw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn pminsw(
    &mut self,
    op0: AsmRegisterMm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPminsw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn pminsw(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPminub<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn pminub(
    &mut self,
    op0: AsmRegisterMm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPminub<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn pminub(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPminud<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn pminud(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPminuw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn pminuw(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPmovsxbd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn pmovsxbd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPmovsxbq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn pmovsxbq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPmovsxbw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn pmovsxbw(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPmovsxdq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn pmovsxdq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPmovsxwd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn pmovsxwd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPmovsxwq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn pmovsxwq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPmovzxbd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn pmovzxbd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPmovzxbq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn pmovzxbq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPmovzxbw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn pmovzxbw(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPmovzxdq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn pmovzxdq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPmovzxwd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn pmovzxwd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPmovzxwq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn pmovzxwq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPmuldq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn pmuldq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPmulhriw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn pmulhriw(
    &mut self,
    op0: AsmRegisterMm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPmulhrsw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn pmulhrsw(
    &mut self,
    op0: AsmRegisterMm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPmulhrsw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn pmulhrsw(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPmulhrw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn pmulhrw(
    &mut self,
    op0: AsmRegisterMm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPmulhrw_cyrix<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn pmulhrw_cyrix(
    &mut self,
    op0: AsmRegisterMm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPmulhuw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn pmulhuw(
    &mut self,
    op0: AsmRegisterMm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPmulhuw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn pmulhuw(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPmulhw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn pmulhw(
    &mut self,
    op0: AsmRegisterMm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPmulhw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn pmulhw(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPmulld<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn pmulld(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPmullw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn pmullw(
    &mut self,
    op0: AsmRegisterMm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPmullw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn pmullw(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPmuludq<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn pmuludq(
    &mut self,
    op0: AsmRegisterMm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPmuludq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn pmuludq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPmvgezb<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn pmvgezb(
    &mut self,
    op0: AsmRegisterMm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPmvlzb<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn pmvlzb(
    &mut self,
    op0: AsmRegisterMm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPmvnzb<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn pmvnzb(
    &mut self,
    op0: AsmRegisterMm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPmvzb<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn pmvzb(
    &mut self,
    op0: AsmRegisterMm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPop<AsmMemoryOperand> for CodeAssembler

fn pop(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmPopcnt<AsmRegister16, AsmMemoryOperand> for CodeAssembler

fn popcnt(
    &mut self,
    op0: AsmRegister16,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPopcnt<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn popcnt(
    &mut self,
    op0: AsmRegister32,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPopcnt<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn popcnt(
    &mut self,
    op0: AsmRegister64,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPor<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn por(
    &mut self,
    op0: AsmRegisterMm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPor<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn por(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPrefetch<AsmMemoryOperand> for CodeAssembler

fn prefetch(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmPrefetchnta<AsmMemoryOperand> for CodeAssembler

fn prefetchnta(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmPrefetcht0<AsmMemoryOperand> for CodeAssembler

fn prefetcht0(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmPrefetcht1<AsmMemoryOperand> for CodeAssembler

fn prefetcht1(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmPrefetcht2<AsmMemoryOperand> for CodeAssembler

fn prefetcht2(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmPrefetchw<AsmMemoryOperand> for CodeAssembler

fn prefetchw(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmPrefetchwt1<AsmMemoryOperand> for CodeAssembler

fn prefetchwt1(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmPsadbw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn psadbw(
    &mut self,
    op0: AsmRegisterMm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPsadbw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn psadbw(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPshufb<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn pshufb(
    &mut self,
    op0: AsmRegisterMm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPshufb<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn pshufb(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPshufd<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn pshufd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmPshufd<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn pshufd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmPshufhw<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn pshufhw(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmPshufhw<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn pshufhw(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmPshuflw<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn pshuflw(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmPshuflw<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn pshuflw(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmPshufw<AsmRegisterMm, AsmMemoryOperand, i32> for CodeAssembler

fn pshufw(
    &mut self,
    op0: AsmRegisterMm,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmPshufw<AsmRegisterMm, AsmMemoryOperand, u32> for CodeAssembler

fn pshufw(
    &mut self,
    op0: AsmRegisterMm,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmPsignb<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn psignb(
    &mut self,
    op0: AsmRegisterMm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPsignb<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn psignb(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPsignd<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn psignd(
    &mut self,
    op0: AsmRegisterMm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPsignd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn psignd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPsignw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn psignw(
    &mut self,
    op0: AsmRegisterMm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPsignw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn psignw(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPslld<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn pslld(
    &mut self,
    op0: AsmRegisterMm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPslld<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn pslld(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPsllq<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn psllq(
    &mut self,
    op0: AsmRegisterMm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPsllq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn psllq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPsllw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn psllw(
    &mut self,
    op0: AsmRegisterMm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPsllw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn psllw(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPsrad<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn psrad(
    &mut self,
    op0: AsmRegisterMm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPsrad<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn psrad(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPsraw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn psraw(
    &mut self,
    op0: AsmRegisterMm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPsraw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn psraw(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPsrld<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn psrld(
    &mut self,
    op0: AsmRegisterMm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPsrld<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn psrld(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPsrlq<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn psrlq(
    &mut self,
    op0: AsmRegisterMm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPsrlq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn psrlq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPsrlw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn psrlw(
    &mut self,
    op0: AsmRegisterMm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPsrlw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn psrlw(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPsubb<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn psubb(
    &mut self,
    op0: AsmRegisterMm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPsubb<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn psubb(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPsubd<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn psubd(
    &mut self,
    op0: AsmRegisterMm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPsubd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn psubd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPsubq<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn psubq(
    &mut self,
    op0: AsmRegisterMm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPsubq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn psubq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPsubsb<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn psubsb(
    &mut self,
    op0: AsmRegisterMm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPsubsb<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn psubsb(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPsubsiw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn psubsiw(
    &mut self,
    op0: AsmRegisterMm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPsubsw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn psubsw(
    &mut self,
    op0: AsmRegisterMm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPsubsw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn psubsw(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPsubusb<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn psubusb(
    &mut self,
    op0: AsmRegisterMm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPsubusb<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn psubusb(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPsubusw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn psubusw(
    &mut self,
    op0: AsmRegisterMm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPsubusw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn psubusw(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPsubw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn psubw(
    &mut self,
    op0: AsmRegisterMm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPsubw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn psubw(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPswapd<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn pswapd(
    &mut self,
    op0: AsmRegisterMm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPtest<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn ptest(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPtwrite<AsmMemoryOperand> for CodeAssembler

fn ptwrite(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmPunpckhbw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn punpckhbw(
    &mut self,
    op0: AsmRegisterMm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPunpckhbw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn punpckhbw(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPunpckhdq<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn punpckhdq(
    &mut self,
    op0: AsmRegisterMm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPunpckhdq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn punpckhdq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPunpckhqdq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn punpckhqdq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPunpckhwd<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn punpckhwd(
    &mut self,
    op0: AsmRegisterMm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPunpckhwd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn punpckhwd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPunpcklbw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn punpcklbw(
    &mut self,
    op0: AsmRegisterMm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPunpcklbw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn punpcklbw(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPunpckldq<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn punpckldq(
    &mut self,
    op0: AsmRegisterMm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPunpckldq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn punpckldq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPunpcklqdq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn punpcklqdq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPunpcklwd<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn punpcklwd(
    &mut self,
    op0: AsmRegisterMm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPunpcklwd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn punpcklwd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPush<AsmMemoryOperand> for CodeAssembler

fn push(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmPxor<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn pxor(
    &mut self,
    op0: AsmRegisterMm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmPxor<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn pxor(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmRcl<AsmMemoryOperand, AsmRegister8> for CodeAssembler

fn rcl(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegister8
) -> Result<(), IcedError>

impl CodeAsmRcl<AsmMemoryOperand, i32> for CodeAssembler

fn rcl(&mut self, op0: AsmMemoryOperand, op1: i32) -> Result<(), IcedError>

impl CodeAsmRcl<AsmMemoryOperand, u32> for CodeAssembler

fn rcl(&mut self, op0: AsmMemoryOperand, op1: u32) -> Result<(), IcedError>

impl CodeAsmRcpps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn rcpps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmRcpss<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn rcpss(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmRcr<AsmMemoryOperand, AsmRegister8> for CodeAssembler

fn rcr(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegister8
) -> Result<(), IcedError>

impl CodeAsmRcr<AsmMemoryOperand, i32> for CodeAssembler

fn rcr(&mut self, op0: AsmMemoryOperand, op1: i32) -> Result<(), IcedError>

impl CodeAsmRcr<AsmMemoryOperand, u32> for CodeAssembler

fn rcr(&mut self, op0: AsmMemoryOperand, op1: u32) -> Result<(), IcedError>

impl CodeAsmRdshr<AsmMemoryOperand> for CodeAssembler

fn rdshr(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmReservednop_0f0d<AsmMemoryOperand, AsmRegister16> for CodeAssembler

fn reservednop_0f0d(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegister16
) -> Result<(), IcedError>

impl CodeAsmReservednop_0f0d<AsmMemoryOperand, AsmRegister32> for CodeAssembler

fn reservednop_0f0d(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegister32
) -> Result<(), IcedError>

impl CodeAsmReservednop_0f0d<AsmMemoryOperand, AsmRegister64> for CodeAssembler

fn reservednop_0f0d(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegister64
) -> Result<(), IcedError>

impl CodeAsmReservednop_0f18<AsmMemoryOperand, AsmRegister16> for CodeAssembler

fn reservednop_0f18(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegister16
) -> Result<(), IcedError>

impl CodeAsmReservednop_0f18<AsmMemoryOperand, AsmRegister32> for CodeAssembler

fn reservednop_0f18(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegister32
) -> Result<(), IcedError>

impl CodeAsmReservednop_0f18<AsmMemoryOperand, AsmRegister64> for CodeAssembler

fn reservednop_0f18(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegister64
) -> Result<(), IcedError>

impl CodeAsmReservednop_0f19<AsmMemoryOperand, AsmRegister16> for CodeAssembler

fn reservednop_0f19(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegister16
) -> Result<(), IcedError>

impl CodeAsmReservednop_0f19<AsmMemoryOperand, AsmRegister32> for CodeAssembler

fn reservednop_0f19(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegister32
) -> Result<(), IcedError>

impl CodeAsmReservednop_0f19<AsmMemoryOperand, AsmRegister64> for CodeAssembler

fn reservednop_0f19(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegister64
) -> Result<(), IcedError>

impl CodeAsmReservednop_0f1a<AsmMemoryOperand, AsmRegister16> for CodeAssembler

fn reservednop_0f1a(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegister16
) -> Result<(), IcedError>

impl CodeAsmReservednop_0f1a<AsmMemoryOperand, AsmRegister32> for CodeAssembler

fn reservednop_0f1a(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegister32
) -> Result<(), IcedError>

impl CodeAsmReservednop_0f1a<AsmMemoryOperand, AsmRegister64> for CodeAssembler

fn reservednop_0f1a(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegister64
) -> Result<(), IcedError>

impl CodeAsmReservednop_0f1b<AsmMemoryOperand, AsmRegister16> for CodeAssembler

fn reservednop_0f1b(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegister16
) -> Result<(), IcedError>

impl CodeAsmReservednop_0f1b<AsmMemoryOperand, AsmRegister32> for CodeAssembler

fn reservednop_0f1b(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegister32
) -> Result<(), IcedError>

impl CodeAsmReservednop_0f1b<AsmMemoryOperand, AsmRegister64> for CodeAssembler

fn reservednop_0f1b(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegister64
) -> Result<(), IcedError>

impl CodeAsmReservednop_0f1c<AsmMemoryOperand, AsmRegister16> for CodeAssembler

fn reservednop_0f1c(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegister16
) -> Result<(), IcedError>

impl CodeAsmReservednop_0f1c<AsmMemoryOperand, AsmRegister32> for CodeAssembler

fn reservednop_0f1c(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegister32
) -> Result<(), IcedError>

impl CodeAsmReservednop_0f1c<AsmMemoryOperand, AsmRegister64> for CodeAssembler

fn reservednop_0f1c(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegister64
) -> Result<(), IcedError>

impl CodeAsmReservednop_0f1d<AsmMemoryOperand, AsmRegister16> for CodeAssembler

fn reservednop_0f1d(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegister16
) -> Result<(), IcedError>

impl CodeAsmReservednop_0f1d<AsmMemoryOperand, AsmRegister32> for CodeAssembler

fn reservednop_0f1d(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegister32
) -> Result<(), IcedError>

impl CodeAsmReservednop_0f1d<AsmMemoryOperand, AsmRegister64> for CodeAssembler

fn reservednop_0f1d(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegister64
) -> Result<(), IcedError>

impl CodeAsmReservednop_0f1e<AsmMemoryOperand, AsmRegister16> for CodeAssembler

fn reservednop_0f1e(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegister16
) -> Result<(), IcedError>

impl CodeAsmReservednop_0f1e<AsmMemoryOperand, AsmRegister32> for CodeAssembler

fn reservednop_0f1e(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegister32
) -> Result<(), IcedError>

impl CodeAsmReservednop_0f1e<AsmMemoryOperand, AsmRegister64> for CodeAssembler

fn reservednop_0f1e(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegister64
) -> Result<(), IcedError>

impl CodeAsmReservednop_0f1f<AsmMemoryOperand, AsmRegister16> for CodeAssembler

fn reservednop_0f1f(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegister16
) -> Result<(), IcedError>

impl CodeAsmReservednop_0f1f<AsmMemoryOperand, AsmRegister32> for CodeAssembler

fn reservednop_0f1f(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegister32
) -> Result<(), IcedError>

impl CodeAsmReservednop_0f1f<AsmMemoryOperand, AsmRegister64> for CodeAssembler

fn reservednop_0f1f(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegister64
) -> Result<(), IcedError>

impl CodeAsmRol<AsmMemoryOperand, AsmRegister8> for CodeAssembler

fn rol(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegister8
) -> Result<(), IcedError>

impl CodeAsmRol<AsmMemoryOperand, i32> for CodeAssembler

fn rol(&mut self, op0: AsmMemoryOperand, op1: i32) -> Result<(), IcedError>

impl CodeAsmRol<AsmMemoryOperand, u32> for CodeAssembler

fn rol(&mut self, op0: AsmMemoryOperand, op1: u32) -> Result<(), IcedError>

impl CodeAsmRor<AsmMemoryOperand, AsmRegister8> for CodeAssembler

fn ror(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegister8
) -> Result<(), IcedError>

impl CodeAsmRor<AsmMemoryOperand, i32> for CodeAssembler

fn ror(&mut self, op0: AsmMemoryOperand, op1: i32) -> Result<(), IcedError>

impl CodeAsmRor<AsmMemoryOperand, u32> for CodeAssembler

fn ror(&mut self, op0: AsmMemoryOperand, op1: u32) -> Result<(), IcedError>

impl CodeAsmRorx<AsmRegister32, AsmMemoryOperand, i32> for CodeAssembler

fn rorx(
    &mut self,
    op0: AsmRegister32,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmRorx<AsmRegister32, AsmMemoryOperand, u32> for CodeAssembler

fn rorx(
    &mut self,
    op0: AsmRegister32,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmRorx<AsmRegister64, AsmMemoryOperand, i32> for CodeAssembler

fn rorx(
    &mut self,
    op0: AsmRegister64,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmRorx<AsmRegister64, AsmMemoryOperand, u32> for CodeAssembler

fn rorx(
    &mut self,
    op0: AsmRegister64,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmRoundpd<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn roundpd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmRoundpd<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn roundpd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmRoundps<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn roundps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmRoundps<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn roundps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmRoundsd<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn roundsd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmRoundsd<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn roundsd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmRoundss<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn roundss(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmRoundss<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn roundss(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmRsdc<AsmRegisterSegment, AsmMemoryOperand> for CodeAssembler

fn rsdc(
    &mut self,
    op0: AsmRegisterSegment,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmRsldt<AsmMemoryOperand> for CodeAssembler

fn rsldt(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmRsqrtps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn rsqrtps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmRsqrtss<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn rsqrtss(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmRstorssp<AsmMemoryOperand> for CodeAssembler

fn rstorssp(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmRsts<AsmMemoryOperand> for CodeAssembler

fn rsts(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmSal<AsmMemoryOperand, AsmRegister8> for CodeAssembler

fn sal(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegister8
) -> Result<(), IcedError>

impl CodeAsmSal<AsmMemoryOperand, i32> for CodeAssembler

fn sal(&mut self, op0: AsmMemoryOperand, op1: i32) -> Result<(), IcedError>

impl CodeAsmSal<AsmMemoryOperand, u32> for CodeAssembler

fn sal(&mut self, op0: AsmMemoryOperand, op1: u32) -> Result<(), IcedError>

impl CodeAsmSar<AsmMemoryOperand, AsmRegister8> for CodeAssembler

fn sar(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegister8
) -> Result<(), IcedError>

impl CodeAsmSar<AsmMemoryOperand, i32> for CodeAssembler

fn sar(&mut self, op0: AsmMemoryOperand, op1: i32) -> Result<(), IcedError>

impl CodeAsmSar<AsmMemoryOperand, u32> for CodeAssembler

fn sar(&mut self, op0: AsmMemoryOperand, op1: u32) -> Result<(), IcedError>

impl CodeAsmSarx<AsmRegister32, AsmMemoryOperand, AsmRegister32> for CodeAssembler

fn sarx(
    &mut self,
    op0: AsmRegister32,
    op1: AsmMemoryOperand,
    op2: AsmRegister32
) -> Result<(), IcedError>

impl CodeAsmSarx<AsmRegister64, AsmMemoryOperand, AsmRegister64> for CodeAssembler

fn sarx(
    &mut self,
    op0: AsmRegister64,
    op1: AsmMemoryOperand,
    op2: AsmRegister64
) -> Result<(), IcedError>

impl CodeAsmSbb<AsmMemoryOperand, AsmRegister16> for CodeAssembler

fn sbb(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegister16
) -> Result<(), IcedError>

impl CodeAsmSbb<AsmMemoryOperand, AsmRegister32> for CodeAssembler

fn sbb(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegister32
) -> Result<(), IcedError>

impl CodeAsmSbb<AsmMemoryOperand, AsmRegister64> for CodeAssembler

fn sbb(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegister64
) -> Result<(), IcedError>

impl CodeAsmSbb<AsmMemoryOperand, AsmRegister8> for CodeAssembler

fn sbb(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegister8
) -> Result<(), IcedError>

impl CodeAsmSbb<AsmMemoryOperand, i32> for CodeAssembler

fn sbb(&mut self, op0: AsmMemoryOperand, op1: i32) -> Result<(), IcedError>

impl CodeAsmSbb<AsmMemoryOperand, u32> for CodeAssembler

fn sbb(&mut self, op0: AsmMemoryOperand, op1: u32) -> Result<(), IcedError>

impl CodeAsmSbb<AsmRegister16, AsmMemoryOperand> for CodeAssembler

fn sbb(
    &mut self,
    op0: AsmRegister16,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmSbb<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn sbb(
    &mut self,
    op0: AsmRegister32,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmSbb<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn sbb(
    &mut self,
    op0: AsmRegister64,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmSbb<AsmRegister8, AsmMemoryOperand> for CodeAssembler

fn sbb(
    &mut self,
    op0: AsmRegister8,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmSeta<AsmMemoryOperand> for CodeAssembler

fn seta(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmSetae<AsmMemoryOperand> for CodeAssembler

fn setae(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmSetb<AsmMemoryOperand> for CodeAssembler

fn setb(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmSetbe<AsmMemoryOperand> for CodeAssembler

fn setbe(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmSetc<AsmMemoryOperand> for CodeAssembler

fn setc(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmSete<AsmMemoryOperand> for CodeAssembler

fn sete(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmSetg<AsmMemoryOperand> for CodeAssembler

fn setg(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmSetge<AsmMemoryOperand> for CodeAssembler

fn setge(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmSetl<AsmMemoryOperand> for CodeAssembler

fn setl(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmSetle<AsmMemoryOperand> for CodeAssembler

fn setle(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmSetna<AsmMemoryOperand> for CodeAssembler

fn setna(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmSetnae<AsmMemoryOperand> for CodeAssembler

fn setnae(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmSetnb<AsmMemoryOperand> for CodeAssembler

fn setnb(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmSetnbe<AsmMemoryOperand> for CodeAssembler

fn setnbe(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmSetnc<AsmMemoryOperand> for CodeAssembler

fn setnc(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmSetne<AsmMemoryOperand> for CodeAssembler

fn setne(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmSetng<AsmMemoryOperand> for CodeAssembler

fn setng(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmSetnge<AsmMemoryOperand> for CodeAssembler

fn setnge(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmSetnl<AsmMemoryOperand> for CodeAssembler

fn setnl(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmSetnle<AsmMemoryOperand> for CodeAssembler

fn setnle(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmSetno<AsmMemoryOperand> for CodeAssembler

fn setno(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmSetnp<AsmMemoryOperand> for CodeAssembler

fn setnp(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmSetns<AsmMemoryOperand> for CodeAssembler

fn setns(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmSetnz<AsmMemoryOperand> for CodeAssembler

fn setnz(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmSeto<AsmMemoryOperand> for CodeAssembler

fn seto(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmSetp<AsmMemoryOperand> for CodeAssembler

fn setp(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmSetpe<AsmMemoryOperand> for CodeAssembler

fn setpe(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmSetpo<AsmMemoryOperand> for CodeAssembler

fn setpo(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmSets<AsmMemoryOperand> for CodeAssembler

fn sets(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmSetz<AsmMemoryOperand> for CodeAssembler

fn setz(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmSgdt<AsmMemoryOperand> for CodeAssembler

fn sgdt(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmSha1msg1<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn sha1msg1(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmSha1msg2<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn sha1msg2(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmSha1nexte<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn sha1nexte(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmSha1rnds4<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn sha1rnds4(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmSha1rnds4<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn sha1rnds4(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmSha256msg1<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn sha256msg1(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmSha256msg2<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn sha256msg2(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmSha256rnds2<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn sha256rnds2(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmShl<AsmMemoryOperand, AsmRegister8> for CodeAssembler

fn shl(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegister8
) -> Result<(), IcedError>

impl CodeAsmShl<AsmMemoryOperand, i32> for CodeAssembler

fn shl(&mut self, op0: AsmMemoryOperand, op1: i32) -> Result<(), IcedError>

impl CodeAsmShl<AsmMemoryOperand, u32> for CodeAssembler

fn shl(&mut self, op0: AsmMemoryOperand, op1: u32) -> Result<(), IcedError>

impl CodeAsmShld<AsmMemoryOperand, AsmRegister16, AsmRegister8> for CodeAssembler

fn shld(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegister16,
    op2: AsmRegister8
) -> Result<(), IcedError>

impl CodeAsmShld<AsmMemoryOperand, AsmRegister16, i32> for CodeAssembler

fn shld(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegister16,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmShld<AsmMemoryOperand, AsmRegister16, u32> for CodeAssembler

fn shld(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegister16,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmShld<AsmMemoryOperand, AsmRegister32, AsmRegister8> for CodeAssembler

fn shld(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegister32,
    op2: AsmRegister8
) -> Result<(), IcedError>

impl CodeAsmShld<AsmMemoryOperand, AsmRegister32, i32> for CodeAssembler

fn shld(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegister32,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmShld<AsmMemoryOperand, AsmRegister32, u32> for CodeAssembler

fn shld(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegister32,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmShld<AsmMemoryOperand, AsmRegister64, AsmRegister8> for CodeAssembler

fn shld(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegister64,
    op2: AsmRegister8
) -> Result<(), IcedError>

impl CodeAsmShld<AsmMemoryOperand, AsmRegister64, i32> for CodeAssembler

fn shld(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegister64,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmShld<AsmMemoryOperand, AsmRegister64, u32> for CodeAssembler

fn shld(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegister64,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmShlx<AsmRegister32, AsmMemoryOperand, AsmRegister32> for CodeAssembler

fn shlx(
    &mut self,
    op0: AsmRegister32,
    op1: AsmMemoryOperand,
    op2: AsmRegister32
) -> Result<(), IcedError>

impl CodeAsmShlx<AsmRegister64, AsmMemoryOperand, AsmRegister64> for CodeAssembler

fn shlx(
    &mut self,
    op0: AsmRegister64,
    op1: AsmMemoryOperand,
    op2: AsmRegister64
) -> Result<(), IcedError>

impl CodeAsmShr<AsmMemoryOperand, AsmRegister8> for CodeAssembler

fn shr(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegister8
) -> Result<(), IcedError>

impl CodeAsmShr<AsmMemoryOperand, i32> for CodeAssembler

fn shr(&mut self, op0: AsmMemoryOperand, op1: i32) -> Result<(), IcedError>

impl CodeAsmShr<AsmMemoryOperand, u32> for CodeAssembler

fn shr(&mut self, op0: AsmMemoryOperand, op1: u32) -> Result<(), IcedError>

impl CodeAsmShrd<AsmMemoryOperand, AsmRegister16, AsmRegister8> for CodeAssembler

fn shrd(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegister16,
    op2: AsmRegister8
) -> Result<(), IcedError>

impl CodeAsmShrd<AsmMemoryOperand, AsmRegister16, i32> for CodeAssembler

fn shrd(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegister16,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmShrd<AsmMemoryOperand, AsmRegister16, u32> for CodeAssembler

fn shrd(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegister16,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmShrd<AsmMemoryOperand, AsmRegister32, AsmRegister8> for CodeAssembler

fn shrd(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegister32,
    op2: AsmRegister8
) -> Result<(), IcedError>

impl CodeAsmShrd<AsmMemoryOperand, AsmRegister32, i32> for CodeAssembler

fn shrd(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegister32,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmShrd<AsmMemoryOperand, AsmRegister32, u32> for CodeAssembler

fn shrd(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegister32,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmShrd<AsmMemoryOperand, AsmRegister64, AsmRegister8> for CodeAssembler

fn shrd(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegister64,
    op2: AsmRegister8
) -> Result<(), IcedError>

impl CodeAsmShrd<AsmMemoryOperand, AsmRegister64, i32> for CodeAssembler

fn shrd(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegister64,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmShrd<AsmMemoryOperand, AsmRegister64, u32> for CodeAssembler

fn shrd(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegister64,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmShrx<AsmRegister32, AsmMemoryOperand, AsmRegister32> for CodeAssembler

fn shrx(
    &mut self,
    op0: AsmRegister32,
    op1: AsmMemoryOperand,
    op2: AsmRegister32
) -> Result<(), IcedError>

impl CodeAsmShrx<AsmRegister64, AsmMemoryOperand, AsmRegister64> for CodeAssembler

fn shrx(
    &mut self,
    op0: AsmRegister64,
    op1: AsmMemoryOperand,
    op2: AsmRegister64
) -> Result<(), IcedError>

impl CodeAsmShufpd<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn shufpd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmShufpd<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn shufpd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmShufps<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn shufps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmShufps<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn shufps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmSidt<AsmMemoryOperand> for CodeAssembler

fn sidt(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmSldt<AsmMemoryOperand> for CodeAssembler

fn sldt(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmSmsw<AsmMemoryOperand> for CodeAssembler

fn smsw(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmSqrtpd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn sqrtpd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmSqrtps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn sqrtps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmSqrtsd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn sqrtsd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmSqrtss<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn sqrtss(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmStmxcsr<AsmMemoryOperand> for CodeAssembler

fn stmxcsr(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmStr<AsmMemoryOperand> for CodeAssembler

fn str(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmSttilecfg<AsmMemoryOperand> for CodeAssembler

fn sttilecfg(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmSub<AsmMemoryOperand, AsmRegister16> for CodeAssembler

fn sub(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegister16
) -> Result<(), IcedError>

impl CodeAsmSub<AsmMemoryOperand, AsmRegister32> for CodeAssembler

fn sub(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegister32
) -> Result<(), IcedError>

impl CodeAsmSub<AsmMemoryOperand, AsmRegister64> for CodeAssembler

fn sub(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegister64
) -> Result<(), IcedError>

impl CodeAsmSub<AsmMemoryOperand, AsmRegister8> for CodeAssembler

fn sub(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegister8
) -> Result<(), IcedError>

impl CodeAsmSub<AsmMemoryOperand, i32> for CodeAssembler

fn sub(&mut self, op0: AsmMemoryOperand, op1: i32) -> Result<(), IcedError>

impl CodeAsmSub<AsmMemoryOperand, u32> for CodeAssembler

fn sub(&mut self, op0: AsmMemoryOperand, op1: u32) -> Result<(), IcedError>

impl CodeAsmSub<AsmRegister16, AsmMemoryOperand> for CodeAssembler

fn sub(
    &mut self,
    op0: AsmRegister16,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmSub<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn sub(
    &mut self,
    op0: AsmRegister32,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmSub<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn sub(
    &mut self,
    op0: AsmRegister64,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmSub<AsmRegister8, AsmMemoryOperand> for CodeAssembler

fn sub(
    &mut self,
    op0: AsmRegister8,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmSubpd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn subpd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmSubps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn subps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmSubsd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn subsd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmSubss<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn subss(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmSvdc<AsmMemoryOperand, AsmRegisterSegment> for CodeAssembler

fn svdc(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterSegment
) -> Result<(), IcedError>

impl CodeAsmSvldt<AsmMemoryOperand> for CodeAssembler

fn svldt(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmSvts<AsmMemoryOperand> for CodeAssembler

fn svts(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmT1mskc<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn t1mskc(
    &mut self,
    op0: AsmRegister32,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmT1mskc<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn t1mskc(
    &mut self,
    op0: AsmRegister64,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmTest<AsmMemoryOperand, AsmRegister16> for CodeAssembler

fn test(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegister16
) -> Result<(), IcedError>

impl CodeAsmTest<AsmMemoryOperand, AsmRegister32> for CodeAssembler

fn test(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegister32
) -> Result<(), IcedError>

impl CodeAsmTest<AsmMemoryOperand, AsmRegister64> for CodeAssembler

fn test(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegister64
) -> Result<(), IcedError>

impl CodeAsmTest<AsmMemoryOperand, AsmRegister8> for CodeAssembler

fn test(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegister8
) -> Result<(), IcedError>

impl CodeAsmTest<AsmMemoryOperand, i32> for CodeAssembler

fn test(&mut self, op0: AsmMemoryOperand, op1: i32) -> Result<(), IcedError>

impl CodeAsmTest<AsmMemoryOperand, u32> for CodeAssembler

fn test(&mut self, op0: AsmMemoryOperand, op1: u32) -> Result<(), IcedError>

impl CodeAsmTileloadd<AsmRegisterTmm, AsmMemoryOperand> for CodeAssembler

fn tileloadd(
    &mut self,
    op0: AsmRegisterTmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmTileloaddt1<AsmRegisterTmm, AsmMemoryOperand> for CodeAssembler

fn tileloaddt1(
    &mut self,
    op0: AsmRegisterTmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmTilestored<AsmMemoryOperand, AsmRegisterTmm> for CodeAssembler

fn tilestored(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterTmm
) -> Result<(), IcedError>

impl CodeAsmTzcnt<AsmRegister16, AsmMemoryOperand> for CodeAssembler

fn tzcnt(
    &mut self,
    op0: AsmRegister16,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmTzcnt<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn tzcnt(
    &mut self,
    op0: AsmRegister32,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmTzcnt<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn tzcnt(
    &mut self,
    op0: AsmRegister64,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmTzmsk<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn tzmsk(
    &mut self,
    op0: AsmRegister32,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmTzmsk<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn tzmsk(
    &mut self,
    op0: AsmRegister64,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmUcomisd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn ucomisd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmUcomiss<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn ucomiss(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmUd02<AsmRegister16, AsmMemoryOperand> for CodeAssembler

fn ud0_2(
    &mut self,
    op0: AsmRegister16,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmUd02<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn ud0_2(
    &mut self,
    op0: AsmRegister32,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmUd02<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn ud0_2(
    &mut self,
    op0: AsmRegister64,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmUd1<AsmRegister16, AsmMemoryOperand> for CodeAssembler

fn ud1(
    &mut self,
    op0: AsmRegister16,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmUd1<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn ud1(
    &mut self,
    op0: AsmRegister32,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmUd1<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn ud1(
    &mut self,
    op0: AsmRegister64,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmUmov<AsmMemoryOperand, AsmRegister16> for CodeAssembler

fn umov(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegister16
) -> Result<(), IcedError>

impl CodeAsmUmov<AsmMemoryOperand, AsmRegister32> for CodeAssembler

fn umov(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegister32
) -> Result<(), IcedError>

impl CodeAsmUmov<AsmMemoryOperand, AsmRegister8> for CodeAssembler

fn umov(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegister8
) -> Result<(), IcedError>

impl CodeAsmUmov<AsmRegister16, AsmMemoryOperand> for CodeAssembler

fn umov(
    &mut self,
    op0: AsmRegister16,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmUmov<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn umov(
    &mut self,
    op0: AsmRegister32,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmUmov<AsmRegister8, AsmMemoryOperand> for CodeAssembler

fn umov(
    &mut self,
    op0: AsmRegister8,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmUnpckhpd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn unpckhpd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmUnpckhps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn unpckhps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmUnpcklpd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn unpcklpd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmUnpcklps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn unpcklps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmV4fmaddps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn v4fmaddps(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmV4fmaddss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn v4fmaddss(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmV4fnmaddps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn v4fnmaddps(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmV4fnmaddss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn v4fnmaddss(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVaddpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vaddpd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVaddpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vaddpd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVaddpd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vaddpd(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVaddph<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vaddph(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVaddph<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vaddph(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVaddph<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vaddph(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVaddps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vaddps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVaddps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vaddps(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVaddps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vaddps(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVaddsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vaddsd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVaddsh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vaddsh(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVaddss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vaddss(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVaddsubpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vaddsubpd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVaddsubpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vaddsubpd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVaddsubps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vaddsubps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVaddsubps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vaddsubps(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVaesdec<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vaesdec(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVaesdec<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vaesdec(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVaesdec<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vaesdec(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVaesdeclast<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vaesdeclast(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVaesdeclast<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vaesdeclast(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVaesdeclast<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vaesdeclast(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVaesenc<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vaesenc(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVaesenc<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vaesenc(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVaesenc<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vaesenc(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVaesenclast<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vaesenclast(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVaesenclast<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vaesenclast(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVaesenclast<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vaesenclast(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVaesimc<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vaesimc(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVaeskeygenassist<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vaeskeygenassist(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmVaeskeygenassist<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vaeskeygenassist(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmValignd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn valignd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmValignd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn valignd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmValignd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn valignd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmValignd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn valignd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmValignd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn valignd(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmValignd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn valignd(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmValignq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn valignq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmValignq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn valignq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmValignq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn valignq(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmValignq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn valignq(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmValignq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn valignq(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmValignq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn valignq(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVandnpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vandnpd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVandnpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vandnpd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVandnpd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vandnpd(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVandnps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vandnps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVandnps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vandnps(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVandnps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vandnps(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVandpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vandpd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVandpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vandpd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVandpd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vandpd(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVandps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vandps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVandps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vandps(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVandps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vandps(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVblendmpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vblendmpd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVblendmpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vblendmpd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVblendmpd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vblendmpd(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVblendmps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vblendmps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVblendmps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vblendmps(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVblendmps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vblendmps(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVblendpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vblendpd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVblendpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vblendpd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVblendpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vblendpd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVblendpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vblendpd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVblendps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vblendps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVblendps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vblendps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVblendps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vblendps(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVblendps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vblendps(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVblendvpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vblendvpd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: AsmRegisterXmm
) -> Result<(), IcedError>

impl CodeAsmVblendvpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vblendvpd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand,
    op3: AsmRegisterYmm
) -> Result<(), IcedError>

impl CodeAsmVblendvps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vblendvps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: AsmRegisterXmm
) -> Result<(), IcedError>

impl CodeAsmVblendvps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vblendvps(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand,
    op3: AsmRegisterYmm
) -> Result<(), IcedError>

impl CodeAsmVbroadcastf128<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vbroadcastf128(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVbroadcastf32x2<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vbroadcastf32x2(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVbroadcastf32x2<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vbroadcastf32x2(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVbroadcastf32x4<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vbroadcastf32x4(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVbroadcastf32x4<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vbroadcastf32x4(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVbroadcastf32x8<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vbroadcastf32x8(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVbroadcastf64x2<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vbroadcastf64x2(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVbroadcastf64x2<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vbroadcastf64x2(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVbroadcastf64x4<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vbroadcastf64x4(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVbroadcasti128<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vbroadcasti128(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVbroadcasti32x2<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vbroadcasti32x2(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVbroadcasti32x2<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vbroadcasti32x2(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVbroadcasti32x2<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vbroadcasti32x2(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVbroadcasti32x4<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vbroadcasti32x4(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVbroadcasti32x4<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vbroadcasti32x4(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVbroadcasti32x8<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vbroadcasti32x8(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVbroadcasti64x2<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vbroadcasti64x2(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVbroadcasti64x2<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vbroadcasti64x2(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVbroadcasti64x4<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vbroadcasti64x4(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVbroadcastsd<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vbroadcastsd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVbroadcastsd<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vbroadcastsd(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVbroadcastss<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vbroadcastss(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVbroadcastss<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vbroadcastss(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVbroadcastss<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vbroadcastss(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpeq_ospd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_ospd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpeq_ospd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_ospd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpeq_ospd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_ospd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpeq_ospd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_ospd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpeq_ospd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_ospd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpeq_osph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_osph(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpeq_osph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_osph(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpeq_osph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_osph(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpeq_osps<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_osps(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpeq_osps<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_osps(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpeq_osps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_osps(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpeq_osps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_osps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpeq_osps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_osps(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpeq_ossd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_ossd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpeq_ossd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_ossd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpeq_ossh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_ossh(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpeq_osss<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_osss(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpeq_osss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_osss(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpeq_uqpd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_uqpd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpeq_uqpd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_uqpd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpeq_uqpd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_uqpd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpeq_uqpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_uqpd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpeq_uqpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_uqpd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpeq_uqph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_uqph(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpeq_uqph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_uqph(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpeq_uqph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_uqph(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpeq_uqps<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_uqps(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpeq_uqps<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_uqps(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpeq_uqps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_uqps(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpeq_uqps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_uqps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpeq_uqps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_uqps(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpeq_uqsd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_uqsd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpeq_uqsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_uqsd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpeq_uqsh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_uqsh(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpeq_uqss<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_uqss(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpeq_uqss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_uqss(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpeq_uspd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_uspd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpeq_uspd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_uspd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpeq_uspd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_uspd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpeq_uspd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_uspd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpeq_uspd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_uspd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpeq_usph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_usph(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpeq_usph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_usph(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpeq_usph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_usph(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpeq_usps<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_usps(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpeq_usps<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_usps(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpeq_usps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_usps(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpeq_usps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_usps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpeq_usps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_usps(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpeq_ussd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_ussd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpeq_ussd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_ussd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpeq_ussh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_ussh(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpeq_usss<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_usss(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpeq_usss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_usss(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpeqpd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeqpd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpeqpd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeqpd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpeqpd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeqpd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpeqpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeqpd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpeqpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeqpd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpeqph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeqph(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpeqph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeqph(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpeqph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeqph(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpeqps<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeqps(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpeqps<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeqps(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpeqps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeqps(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpeqps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeqps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpeqps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeqps(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpeqsd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeqsd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpeqsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeqsd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpeqsh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeqsh(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpeqss<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeqss(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpeqss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeqss(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpfalse_ospd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpfalse_ospd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpfalse_ospd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpfalse_ospd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpfalse_ospd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpfalse_ospd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpfalse_ospd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpfalse_ospd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpfalse_ospd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpfalse_ospd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpfalse_osph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpfalse_osph(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpfalse_osph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpfalse_osph(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpfalse_osph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpfalse_osph(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpfalse_osps<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpfalse_osps(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpfalse_osps<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpfalse_osps(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpfalse_osps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpfalse_osps(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpfalse_osps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpfalse_osps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpfalse_osps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpfalse_osps(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpfalse_ossd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpfalse_ossd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpfalse_ossd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpfalse_ossd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpfalse_ossh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpfalse_ossh(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpfalse_osss<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpfalse_osss(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpfalse_osss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpfalse_osss(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpfalsepd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpfalsepd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpfalsepd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpfalsepd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpfalsepd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpfalsepd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpfalsepd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpfalsepd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpfalsepd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpfalsepd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpfalseph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpfalseph(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpfalseph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpfalseph(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpfalseph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpfalseph(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpfalseps<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpfalseps(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpfalseps<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpfalseps(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpfalseps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpfalseps(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpfalseps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpfalseps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpfalseps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpfalseps(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpfalsesd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpfalsesd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpfalsesd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpfalsesd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpfalsesh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpfalsesh(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpfalsess<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpfalsess(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpfalsess<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpfalsess(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpge_oqpd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpge_oqpd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpge_oqpd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpge_oqpd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpge_oqpd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpge_oqpd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpge_oqpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpge_oqpd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpge_oqpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpge_oqpd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpge_oqph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpge_oqph(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpge_oqph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpge_oqph(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpge_oqph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpge_oqph(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpge_oqps<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpge_oqps(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpge_oqps<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpge_oqps(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpge_oqps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpge_oqps(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpge_oqps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpge_oqps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpge_oqps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpge_oqps(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpge_oqsd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpge_oqsd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpge_oqsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpge_oqsd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpge_oqsh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpge_oqsh(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpge_oqss<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpge_oqss(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpge_oqss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpge_oqss(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpgepd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgepd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpgepd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgepd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpgepd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgepd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpgepd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgepd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpgepd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgepd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpgeph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgeph(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpgeph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgeph(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpgeph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgeph(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpgeps<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgeps(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpgeps<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgeps(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpgeps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgeps(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpgeps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgeps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpgeps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgeps(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpgesd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgesd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpgesd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgesd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpgesh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgesh(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpgess<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgess(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpgess<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgess(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpgt_oqpd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgt_oqpd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpgt_oqpd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgt_oqpd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpgt_oqpd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgt_oqpd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpgt_oqpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgt_oqpd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpgt_oqpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgt_oqpd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpgt_oqph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgt_oqph(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpgt_oqph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgt_oqph(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpgt_oqph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgt_oqph(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpgt_oqps<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgt_oqps(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpgt_oqps<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgt_oqps(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpgt_oqps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgt_oqps(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpgt_oqps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgt_oqps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpgt_oqps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgt_oqps(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpgt_oqsd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgt_oqsd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpgt_oqsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgt_oqsd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpgt_oqsh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgt_oqsh(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpgt_oqss<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgt_oqss(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpgt_oqss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgt_oqss(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpgtpd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgtpd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpgtpd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgtpd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpgtpd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgtpd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpgtpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgtpd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpgtpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgtpd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpgtph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgtph(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpgtph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgtph(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpgtph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgtph(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpgtps<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgtps(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpgtps<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgtps(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpgtps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgtps(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpgtps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgtps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpgtps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgtps(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpgtsd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgtsd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpgtsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgtsd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpgtsh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgtsh(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpgtss<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgtss(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpgtss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgtss(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmple_oqpd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmple_oqpd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmple_oqpd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmple_oqpd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmple_oqpd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmple_oqpd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmple_oqpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmple_oqpd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmple_oqpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmple_oqpd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmple_oqph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmple_oqph(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmple_oqph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmple_oqph(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmple_oqph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmple_oqph(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmple_oqps<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmple_oqps(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmple_oqps<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmple_oqps(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmple_oqps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmple_oqps(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmple_oqps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmple_oqps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmple_oqps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmple_oqps(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmple_oqsd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmple_oqsd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmple_oqsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmple_oqsd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmple_oqsh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmple_oqsh(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmple_oqss<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmple_oqss(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmple_oqss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmple_oqss(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmplepd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmplepd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmplepd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmplepd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmplepd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmplepd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmplepd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmplepd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmplepd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmplepd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpleph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpleph(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpleph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpleph(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpleph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpleph(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpleps<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpleps(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpleps<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpleps(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpleps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpleps(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpleps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpleps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpleps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpleps(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmplesd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmplesd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmplesd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmplesd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmplesh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmplesh(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpless<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpless(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpless<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpless(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmplt_oqpd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmplt_oqpd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmplt_oqpd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmplt_oqpd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmplt_oqpd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmplt_oqpd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmplt_oqpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmplt_oqpd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmplt_oqpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmplt_oqpd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmplt_oqph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmplt_oqph(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmplt_oqph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmplt_oqph(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmplt_oqph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmplt_oqph(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmplt_oqps<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmplt_oqps(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmplt_oqps<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmplt_oqps(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmplt_oqps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmplt_oqps(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmplt_oqps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmplt_oqps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmplt_oqps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmplt_oqps(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmplt_oqsd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmplt_oqsd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmplt_oqsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmplt_oqsd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmplt_oqsh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmplt_oqsh(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmplt_oqss<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmplt_oqss(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmplt_oqss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmplt_oqss(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpltpd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpltpd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpltpd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpltpd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpltpd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpltpd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpltpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpltpd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpltpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpltpd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpltph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpltph(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpltph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpltph(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpltph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpltph(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpltps<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpltps(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpltps<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpltps(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpltps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpltps(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpltps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpltps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpltps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpltps(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpltsd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpltsd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpltsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpltsd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpltsh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpltsh(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpltss<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpltss(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpltss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpltss(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpneq_oqpd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_oqpd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpneq_oqpd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_oqpd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpneq_oqpd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_oqpd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpneq_oqpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_oqpd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpneq_oqpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_oqpd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpneq_oqph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_oqph(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpneq_oqph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_oqph(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpneq_oqph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_oqph(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpneq_oqps<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_oqps(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpneq_oqps<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_oqps(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpneq_oqps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_oqps(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpneq_oqps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_oqps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpneq_oqps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_oqps(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpneq_oqsd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_oqsd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpneq_oqsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_oqsd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpneq_oqsh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_oqsh(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpneq_oqss<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_oqss(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpneq_oqss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_oqss(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpneq_ospd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_ospd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpneq_ospd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_ospd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpneq_ospd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_ospd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpneq_ospd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_ospd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpneq_ospd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_ospd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpneq_osph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_osph(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpneq_osph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_osph(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpneq_osph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_osph(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpneq_osps<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_osps(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpneq_osps<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_osps(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpneq_osps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_osps(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpneq_osps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_osps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpneq_osps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_osps(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpneq_ossd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_ossd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpneq_ossd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_ossd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpneq_ossh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_ossh(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpneq_osss<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_osss(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpneq_osss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_osss(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpneq_uspd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_uspd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpneq_uspd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_uspd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpneq_uspd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_uspd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpneq_uspd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_uspd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpneq_uspd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_uspd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpneq_usph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_usph(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpneq_usph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_usph(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpneq_usph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_usph(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpneq_usps<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_usps(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpneq_usps<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_usps(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpneq_usps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_usps(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpneq_usps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_usps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpneq_usps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_usps(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpneq_ussd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_ussd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpneq_ussd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_ussd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpneq_ussh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_ussh(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpneq_usss<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_usss(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpneq_usss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_usss(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpneqpd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneqpd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpneqpd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneqpd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpneqpd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneqpd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpneqpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneqpd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpneqpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneqpd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpneqph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneqph(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpneqph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneqph(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpneqph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneqph(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpneqps<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneqps(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpneqps<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneqps(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpneqps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneqps(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpneqps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneqps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpneqps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneqps(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpneqsd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneqsd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpneqsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneqsd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpneqsh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneqsh(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpneqss<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneqss(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpneqss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneqss(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpnge_uqpd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnge_uqpd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpnge_uqpd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnge_uqpd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpnge_uqpd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnge_uqpd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpnge_uqpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnge_uqpd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpnge_uqpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnge_uqpd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpnge_uqph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnge_uqph(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpnge_uqph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnge_uqph(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpnge_uqph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnge_uqph(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpnge_uqps<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnge_uqps(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpnge_uqps<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnge_uqps(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpnge_uqps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnge_uqps(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpnge_uqps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnge_uqps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpnge_uqps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnge_uqps(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpnge_uqsd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnge_uqsd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpnge_uqsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnge_uqsd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpnge_uqsh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnge_uqsh(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpnge_uqss<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnge_uqss(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpnge_uqss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnge_uqss(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpngepd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngepd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpngepd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngepd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpngepd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngepd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpngepd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngepd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpngepd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngepd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpngeph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngeph(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpngeph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngeph(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpngeph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngeph(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpngeps<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngeps(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpngeps<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngeps(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpngeps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngeps(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpngeps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngeps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpngeps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngeps(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpngesd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngesd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpngesd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngesd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpngesh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngesh(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpngess<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngess(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpngess<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngess(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpngt_uqpd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngt_uqpd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpngt_uqpd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngt_uqpd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpngt_uqpd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngt_uqpd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpngt_uqpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngt_uqpd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpngt_uqpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngt_uqpd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpngt_uqph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngt_uqph(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpngt_uqph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngt_uqph(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpngt_uqph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngt_uqph(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpngt_uqps<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngt_uqps(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpngt_uqps<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngt_uqps(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpngt_uqps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngt_uqps(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpngt_uqps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngt_uqps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpngt_uqps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngt_uqps(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpngt_uqsd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngt_uqsd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpngt_uqsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngt_uqsd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpngt_uqsh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngt_uqsh(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpngt_uqss<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngt_uqss(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpngt_uqss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngt_uqss(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpngtpd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngtpd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpngtpd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngtpd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpngtpd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngtpd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpngtpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngtpd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpngtpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngtpd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpngtph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngtph(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpngtph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngtph(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpngtph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngtph(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpngtps<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngtps(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpngtps<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngtps(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpngtps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngtps(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpngtps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngtps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpngtps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngtps(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpngtsd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngtsd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpngtsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngtsd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpngtsh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngtsh(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpngtss<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngtss(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpngtss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngtss(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpnle_uqpd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnle_uqpd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpnle_uqpd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnle_uqpd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpnle_uqpd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnle_uqpd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpnle_uqpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnle_uqpd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpnle_uqpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnle_uqpd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpnle_uqph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnle_uqph(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpnle_uqph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnle_uqph(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpnle_uqph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnle_uqph(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpnle_uqps<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnle_uqps(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpnle_uqps<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnle_uqps(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpnle_uqps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnle_uqps(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpnle_uqps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnle_uqps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpnle_uqps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnle_uqps(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpnle_uqsd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnle_uqsd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpnle_uqsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnle_uqsd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpnle_uqsh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnle_uqsh(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpnle_uqss<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnle_uqss(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpnle_uqss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnle_uqss(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpnlepd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnlepd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpnlepd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnlepd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpnlepd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnlepd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpnlepd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnlepd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpnlepd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnlepd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpnleph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnleph(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpnleph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnleph(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpnleph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnleph(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpnleps<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnleps(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpnleps<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnleps(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpnleps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnleps(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpnleps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnleps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpnleps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnleps(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpnlesd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnlesd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpnlesd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnlesd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpnlesh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnlesh(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpnless<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnless(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpnless<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnless(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpnlt_uqpd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnlt_uqpd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpnlt_uqpd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnlt_uqpd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpnlt_uqpd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnlt_uqpd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpnlt_uqpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnlt_uqpd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpnlt_uqpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnlt_uqpd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpnlt_uqph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnlt_uqph(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpnlt_uqph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnlt_uqph(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpnlt_uqph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnlt_uqph(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpnlt_uqps<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnlt_uqps(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpnlt_uqps<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnlt_uqps(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpnlt_uqps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnlt_uqps(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpnlt_uqps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnlt_uqps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpnlt_uqps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnlt_uqps(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpnlt_uqsd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnlt_uqsd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpnlt_uqsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnlt_uqsd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpnlt_uqsh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnlt_uqsh(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpnlt_uqss<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnlt_uqss(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpnlt_uqss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnlt_uqss(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpnltpd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnltpd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpnltpd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnltpd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpnltpd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnltpd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpnltpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnltpd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpnltpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnltpd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpnltph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnltph(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpnltph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnltph(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpnltph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnltph(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpnltps<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnltps(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpnltps<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnltps(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpnltps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnltps(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpnltps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnltps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpnltps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnltps(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpnltsd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnltsd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpnltsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnltsd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpnltsh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnltsh(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpnltss<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnltss(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpnltss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnltss(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpord_spd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpord_spd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpord_spd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpord_spd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpord_spd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpord_spd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpord_spd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpord_spd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpord_spd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpord_spd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpord_sph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpord_sph(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpord_sph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpord_sph(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpord_sph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpord_sph(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpord_sps<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpord_sps(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpord_sps<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpord_sps(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpord_sps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpord_sps(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpord_sps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpord_sps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpord_sps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpord_sps(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpord_ssd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpord_ssd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpord_ssd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpord_ssd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpord_ssh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpord_ssh(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpord_sss<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpord_sss(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpord_sss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpord_sss(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpordpd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpordpd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpordpd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpordpd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpordpd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpordpd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpordpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpordpd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpordpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpordpd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpordph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpordph(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpordph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpordph(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpordph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpordph(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpordps<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpordps(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpordps<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpordps(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpordps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpordps(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpordps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpordps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpordps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpordps(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpordsd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpordsd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpordsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpordsd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpordsh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpordsh(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpordss<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpordss(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpordss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpordss(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmppd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vcmppd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVcmppd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vcmppd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVcmppd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vcmppd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVcmppd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vcmppd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVcmppd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vcmppd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVcmppd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vcmppd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVcmppd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vcmppd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVcmppd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vcmppd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVcmppd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vcmppd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVcmppd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vcmppd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVcmpph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vcmpph(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVcmpph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vcmpph(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVcmpph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vcmpph(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVcmpph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vcmpph(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVcmpph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vcmpph(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVcmpph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vcmpph(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVcmpps<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vcmpps(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVcmpps<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vcmpps(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVcmpps<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vcmpps(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVcmpps<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vcmpps(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVcmpps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vcmpps(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVcmpps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vcmpps(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVcmpps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vcmpps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVcmpps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vcmpps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVcmpps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vcmpps(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVcmpps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vcmpps(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVcmpsd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vcmpsd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVcmpsd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vcmpsd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVcmpsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vcmpsd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVcmpsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vcmpsd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVcmpsh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vcmpsh(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVcmpsh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vcmpsh(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVcmpss<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vcmpss(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVcmpss<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vcmpss(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVcmpss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vcmpss(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVcmpss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vcmpss(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVcmptrue_uspd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmptrue_uspd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmptrue_uspd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmptrue_uspd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmptrue_uspd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmptrue_uspd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmptrue_uspd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmptrue_uspd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmptrue_uspd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmptrue_uspd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmptrue_usph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmptrue_usph(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmptrue_usph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmptrue_usph(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmptrue_usph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmptrue_usph(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmptrue_usps<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmptrue_usps(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmptrue_usps<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmptrue_usps(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmptrue_usps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmptrue_usps(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmptrue_usps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmptrue_usps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmptrue_usps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmptrue_usps(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmptrue_ussd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmptrue_ussd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmptrue_ussd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmptrue_ussd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmptrue_ussh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmptrue_ussh(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmptrue_usss<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmptrue_usss(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmptrue_usss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmptrue_usss(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmptruepd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmptruepd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmptruepd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmptruepd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmptruepd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmptruepd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmptruepd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmptruepd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmptruepd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmptruepd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmptrueph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmptrueph(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmptrueph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmptrueph(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmptrueph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmptrueph(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmptrueps<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmptrueps(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmptrueps<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmptrueps(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmptrueps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmptrueps(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmptrueps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmptrueps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmptrueps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmptrueps(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmptruesd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmptruesd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmptruesd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmptruesd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmptruesh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmptruesh(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmptruess<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmptruess(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmptruess<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmptruess(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpunord_spd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpunord_spd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpunord_spd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpunord_spd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpunord_spd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpunord_spd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpunord_spd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpunord_spd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpunord_spd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpunord_spd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpunord_sph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpunord_sph(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpunord_sph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpunord_sph(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpunord_sph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpunord_sph(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpunord_sps<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpunord_sps(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpunord_sps<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpunord_sps(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpunord_sps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpunord_sps(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpunord_sps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpunord_sps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpunord_sps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpunord_sps(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpunord_ssd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpunord_ssd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpunord_ssd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpunord_ssd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpunord_ssh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpunord_ssh(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpunord_sss<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpunord_sss(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpunord_sss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpunord_sss(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpunordpd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpunordpd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpunordpd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpunordpd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpunordpd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpunordpd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpunordpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpunordpd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpunordpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpunordpd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpunordph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpunordph(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpunordph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpunordph(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpunordph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpunordph(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpunordps<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpunordps(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpunordps<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpunordps(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpunordps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpunordps(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpunordps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpunordps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpunordps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpunordps(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpunordsd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpunordsd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpunordsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpunordsd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpunordsh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpunordsh(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpunordss<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpunordss(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcmpunordss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpunordss(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcomisd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcomisd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcomish<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcomish(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcomiss<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcomiss(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcompresspd<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vcompresspd(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterXmm
) -> Result<(), IcedError>

impl CodeAsmVcompresspd<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vcompresspd(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterYmm
) -> Result<(), IcedError>

impl CodeAsmVcompresspd<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

fn vcompresspd(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterZmm
) -> Result<(), IcedError>

impl CodeAsmVcompressps<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vcompressps(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterXmm
) -> Result<(), IcedError>

impl CodeAsmVcompressps<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vcompressps(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterYmm
) -> Result<(), IcedError>

impl CodeAsmVcompressps<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

fn vcompressps(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterZmm
) -> Result<(), IcedError>

impl CodeAsmVcvtdq2pd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtdq2pd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvtdq2pd<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcvtdq2pd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvtdq2pd<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcvtdq2pd(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvtdq2ph<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtdq2ph(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvtdq2ph<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcvtdq2ph(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvtdq2phx<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtdq2phx(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvtdq2phy<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtdq2phy(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvtdq2ps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtdq2ps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvtdq2ps<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcvtdq2ps(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvtdq2ps<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcvtdq2ps(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvtne2ps2bf16<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtne2ps2bf16(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvtne2ps2bf16<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcvtne2ps2bf16(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvtne2ps2bf16<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcvtne2ps2bf16(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvtneps2bf16<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtneps2bf16(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvtneps2bf16<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcvtneps2bf16(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvtneps2bf16x<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtneps2bf16x(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvtneps2bf16y<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtneps2bf16y(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvtpd2dq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtpd2dq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvtpd2dq<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcvtpd2dq(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvtpd2dqx<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtpd2dqx(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvtpd2dqy<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtpd2dqy(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvtpd2ph<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtpd2ph(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvtpd2phx<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtpd2phx(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvtpd2phy<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtpd2phy(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvtpd2phz<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtpd2phz(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvtpd2ps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtpd2ps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvtpd2ps<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcvtpd2ps(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvtpd2psx<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtpd2psx(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvtpd2psy<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtpd2psy(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvtpd2qq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtpd2qq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvtpd2qq<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcvtpd2qq(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvtpd2qq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcvtpd2qq(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvtpd2udq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtpd2udq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvtpd2udq<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcvtpd2udq(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvtpd2udqx<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtpd2udqx(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvtpd2udqy<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtpd2udqy(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvtpd2uqq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtpd2uqq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvtpd2uqq<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcvtpd2uqq(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvtpd2uqq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcvtpd2uqq(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvtph2dq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtph2dq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvtph2dq<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcvtph2dq(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvtph2dq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcvtph2dq(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvtph2pd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtph2pd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvtph2pd<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcvtph2pd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvtph2pd<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcvtph2pd(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvtph2ps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtph2ps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvtph2ps<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcvtph2ps(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvtph2ps<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcvtph2ps(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvtph2psx<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtph2psx(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvtph2psx<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcvtph2psx(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvtph2psx<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcvtph2psx(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvtph2qq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtph2qq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvtph2qq<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcvtph2qq(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvtph2qq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcvtph2qq(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvtph2udq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtph2udq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvtph2udq<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcvtph2udq(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvtph2udq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcvtph2udq(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvtph2uqq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtph2uqq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvtph2uqq<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcvtph2uqq(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvtph2uqq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcvtph2uqq(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvtph2uw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtph2uw(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvtph2uw<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcvtph2uw(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvtph2uw<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcvtph2uw(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvtph2w<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtph2w(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvtph2w<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcvtph2w(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvtph2w<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcvtph2w(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvtps2dq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtps2dq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvtps2dq<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcvtps2dq(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvtps2dq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcvtps2dq(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvtps2pd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtps2pd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvtps2pd<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcvtps2pd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvtps2pd<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcvtps2pd(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvtps2ph<AsmMemoryOperand, AsmRegisterXmm, i32> for CodeAssembler

fn vcvtps2ph(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterXmm,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmVcvtps2ph<AsmMemoryOperand, AsmRegisterXmm, u32> for CodeAssembler

fn vcvtps2ph(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterXmm,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmVcvtps2ph<AsmMemoryOperand, AsmRegisterYmm, i32> for CodeAssembler

fn vcvtps2ph(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterYmm,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmVcvtps2ph<AsmMemoryOperand, AsmRegisterYmm, u32> for CodeAssembler

fn vcvtps2ph(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterYmm,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmVcvtps2ph<AsmMemoryOperand, AsmRegisterZmm, i32> for CodeAssembler

fn vcvtps2ph(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterZmm,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmVcvtps2ph<AsmMemoryOperand, AsmRegisterZmm, u32> for CodeAssembler

fn vcvtps2ph(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterZmm,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmVcvtps2phx<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtps2phx(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvtps2phx<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcvtps2phx(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvtps2phxx<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtps2phxx(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvtps2phxy<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtps2phxy(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvtps2qq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtps2qq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvtps2qq<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcvtps2qq(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvtps2qq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcvtps2qq(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvtps2udq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtps2udq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvtps2udq<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcvtps2udq(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvtps2udq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcvtps2udq(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvtps2uqq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtps2uqq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvtps2uqq<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcvtps2uqq(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvtps2uqq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcvtps2uqq(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvtqq2pd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtqq2pd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvtqq2pd<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcvtqq2pd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvtqq2pd<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcvtqq2pd(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvtqq2ph<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtqq2ph(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvtqq2phx<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtqq2phx(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvtqq2phy<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtqq2phy(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvtqq2phz<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtqq2phz(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvtqq2ps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtqq2ps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvtqq2ps<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcvtqq2ps(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvtqq2psx<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtqq2psx(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvtqq2psy<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtqq2psy(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvtsd2sh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtsd2sh(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvtsd2si<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn vcvtsd2si(
    &mut self,
    op0: AsmRegister32,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvtsd2si<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn vcvtsd2si(
    &mut self,
    op0: AsmRegister64,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvtsd2ss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtsd2ss(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvtsd2usi<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn vcvtsd2usi(
    &mut self,
    op0: AsmRegister32,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvtsd2usi<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn vcvtsd2usi(
    &mut self,
    op0: AsmRegister64,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvtsh2sd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtsh2sd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvtsh2si<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn vcvtsh2si(
    &mut self,
    op0: AsmRegister32,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvtsh2si<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn vcvtsh2si(
    &mut self,
    op0: AsmRegister64,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvtsh2ss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtsh2ss(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvtsh2usi<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn vcvtsh2usi(
    &mut self,
    op0: AsmRegister32,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvtsh2usi<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn vcvtsh2usi(
    &mut self,
    op0: AsmRegister64,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvtsi2sd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtsi2sd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvtsi2sh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtsi2sh(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvtsi2ss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtsi2ss(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvtss2sd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtss2sd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvtss2sh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtss2sh(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvtss2si<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn vcvtss2si(
    &mut self,
    op0: AsmRegister32,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvtss2si<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn vcvtss2si(
    &mut self,
    op0: AsmRegister64,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvtss2usi<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn vcvtss2usi(
    &mut self,
    op0: AsmRegister32,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvtss2usi<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn vcvtss2usi(
    &mut self,
    op0: AsmRegister64,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvttpd2dq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvttpd2dq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvttpd2dq<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcvttpd2dq(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvttpd2dqx<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvttpd2dqx(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvttpd2dqy<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvttpd2dqy(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvttpd2qq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvttpd2qq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvttpd2qq<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcvttpd2qq(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvttpd2qq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcvttpd2qq(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvttpd2udq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvttpd2udq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvttpd2udq<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcvttpd2udq(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvttpd2udqx<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvttpd2udqx(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvttpd2udqy<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvttpd2udqy(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvttpd2uqq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvttpd2uqq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvttpd2uqq<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcvttpd2uqq(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvttpd2uqq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcvttpd2uqq(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvttph2dq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvttph2dq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvttph2dq<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcvttph2dq(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvttph2dq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcvttph2dq(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvttph2qq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvttph2qq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvttph2qq<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcvttph2qq(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvttph2qq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcvttph2qq(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvttph2udq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvttph2udq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvttph2udq<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcvttph2udq(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvttph2udq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcvttph2udq(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvttph2uqq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvttph2uqq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvttph2uqq<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcvttph2uqq(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvttph2uqq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcvttph2uqq(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvttph2uw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvttph2uw(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvttph2uw<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcvttph2uw(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvttph2uw<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcvttph2uw(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvttph2w<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvttph2w(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvttph2w<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcvttph2w(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvttph2w<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcvttph2w(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvttps2dq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvttps2dq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvttps2dq<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcvttps2dq(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvttps2dq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcvttps2dq(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvttps2qq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvttps2qq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvttps2qq<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcvttps2qq(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvttps2qq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcvttps2qq(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvttps2udq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvttps2udq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvttps2udq<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcvttps2udq(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvttps2udq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcvttps2udq(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvttps2uqq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvttps2uqq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvttps2uqq<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcvttps2uqq(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvttps2uqq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcvttps2uqq(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvttsd2si<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn vcvttsd2si(
    &mut self,
    op0: AsmRegister32,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvttsd2si<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn vcvttsd2si(
    &mut self,
    op0: AsmRegister64,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvttsd2usi<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn vcvttsd2usi(
    &mut self,
    op0: AsmRegister32,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvttsd2usi<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn vcvttsd2usi(
    &mut self,
    op0: AsmRegister64,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvttsh2si<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn vcvttsh2si(
    &mut self,
    op0: AsmRegister32,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvttsh2si<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn vcvttsh2si(
    &mut self,
    op0: AsmRegister64,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvttsh2usi<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn vcvttsh2usi(
    &mut self,
    op0: AsmRegister32,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvttsh2usi<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn vcvttsh2usi(
    &mut self,
    op0: AsmRegister64,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvttss2si<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn vcvttss2si(
    &mut self,
    op0: AsmRegister32,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvttss2si<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn vcvttss2si(
    &mut self,
    op0: AsmRegister64,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvttss2usi<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn vcvttss2usi(
    &mut self,
    op0: AsmRegister32,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvttss2usi<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn vcvttss2usi(
    &mut self,
    op0: AsmRegister64,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvtudq2pd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtudq2pd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvtudq2pd<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcvtudq2pd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvtudq2pd<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcvtudq2pd(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvtudq2ph<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtudq2ph(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvtudq2ph<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcvtudq2ph(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvtudq2phx<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtudq2phx(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvtudq2phy<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtudq2phy(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvtudq2ps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtudq2ps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvtudq2ps<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcvtudq2ps(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvtudq2ps<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcvtudq2ps(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvtuqq2pd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtuqq2pd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvtuqq2pd<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcvtuqq2pd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvtuqq2pd<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcvtuqq2pd(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvtuqq2ph<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtuqq2ph(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvtuqq2phx<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtuqq2phx(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvtuqq2phy<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtuqq2phy(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvtuqq2phz<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtuqq2phz(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvtuqq2ps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtuqq2ps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvtuqq2ps<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcvtuqq2ps(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvtuqq2psx<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtuqq2psx(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvtuqq2psy<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtuqq2psy(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvtusi2sd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtusi2sd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvtusi2sh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtusi2sh(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvtusi2ss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtusi2ss(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvtuw2ph<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtuw2ph(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvtuw2ph<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcvtuw2ph(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvtuw2ph<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcvtuw2ph(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvtw2ph<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtw2ph(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvtw2ph<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcvtw2ph(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVcvtw2ph<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcvtw2ph(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVdbpsadbw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vdbpsadbw(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVdbpsadbw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vdbpsadbw(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVdbpsadbw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vdbpsadbw(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVdbpsadbw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vdbpsadbw(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVdbpsadbw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vdbpsadbw(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVdbpsadbw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vdbpsadbw(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVdivpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vdivpd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVdivpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vdivpd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVdivpd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vdivpd(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVdivph<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vdivph(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVdivph<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vdivph(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVdivph<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vdivph(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVdivps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vdivps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVdivps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vdivps(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVdivps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vdivps(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVdivsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vdivsd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVdivsh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vdivsh(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVdivss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vdivss(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVdpbf16ps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vdpbf16ps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVdpbf16ps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vdpbf16ps(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVdpbf16ps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vdpbf16ps(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVdppd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vdppd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVdppd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vdppd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVdpps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vdpps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVdpps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vdpps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVdpps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vdpps(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVdpps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vdpps(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVerr<AsmMemoryOperand> for CodeAssembler

fn verr(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmVerw<AsmMemoryOperand> for CodeAssembler

fn verw(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmVexp2pd<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vexp2pd(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVexp2ps<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vexp2ps(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVexpandpd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vexpandpd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVexpandpd<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vexpandpd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVexpandpd<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vexpandpd(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVexpandps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vexpandps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVexpandps<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vexpandps(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVexpandps<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vexpandps(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVextractf128<AsmMemoryOperand, AsmRegisterYmm, i32> for CodeAssembler

fn vextractf128(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterYmm,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmVextractf128<AsmMemoryOperand, AsmRegisterYmm, u32> for CodeAssembler

fn vextractf128(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterYmm,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmVextractf32x4<AsmMemoryOperand, AsmRegisterYmm, i32> for CodeAssembler

fn vextractf32x4(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterYmm,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmVextractf32x4<AsmMemoryOperand, AsmRegisterYmm, u32> for CodeAssembler

fn vextractf32x4(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterYmm,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmVextractf32x4<AsmMemoryOperand, AsmRegisterZmm, i32> for CodeAssembler

fn vextractf32x4(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterZmm,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmVextractf32x4<AsmMemoryOperand, AsmRegisterZmm, u32> for CodeAssembler

fn vextractf32x4(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterZmm,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmVextractf32x8<AsmMemoryOperand, AsmRegisterZmm, i32> for CodeAssembler

fn vextractf32x8(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterZmm,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmVextractf32x8<AsmMemoryOperand, AsmRegisterZmm, u32> for CodeAssembler

fn vextractf32x8(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterZmm,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmVextractf64x2<AsmMemoryOperand, AsmRegisterYmm, i32> for CodeAssembler

fn vextractf64x2(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterYmm,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmVextractf64x2<AsmMemoryOperand, AsmRegisterYmm, u32> for CodeAssembler

fn vextractf64x2(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterYmm,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmVextractf64x2<AsmMemoryOperand, AsmRegisterZmm, i32> for CodeAssembler

fn vextractf64x2(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterZmm,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmVextractf64x2<AsmMemoryOperand, AsmRegisterZmm, u32> for CodeAssembler

fn vextractf64x2(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterZmm,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmVextractf64x4<AsmMemoryOperand, AsmRegisterZmm, i32> for CodeAssembler

fn vextractf64x4(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterZmm,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmVextractf64x4<AsmMemoryOperand, AsmRegisterZmm, u32> for CodeAssembler

fn vextractf64x4(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterZmm,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmVextracti128<AsmMemoryOperand, AsmRegisterYmm, i32> for CodeAssembler

fn vextracti128(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterYmm,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmVextracti128<AsmMemoryOperand, AsmRegisterYmm, u32> for CodeAssembler

fn vextracti128(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterYmm,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmVextracti32x4<AsmMemoryOperand, AsmRegisterYmm, i32> for CodeAssembler

fn vextracti32x4(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterYmm,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmVextracti32x4<AsmMemoryOperand, AsmRegisterYmm, u32> for CodeAssembler

fn vextracti32x4(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterYmm,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmVextracti32x4<AsmMemoryOperand, AsmRegisterZmm, i32> for CodeAssembler

fn vextracti32x4(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterZmm,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmVextracti32x4<AsmMemoryOperand, AsmRegisterZmm, u32> for CodeAssembler

fn vextracti32x4(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterZmm,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmVextracti32x8<AsmMemoryOperand, AsmRegisterZmm, i32> for CodeAssembler

fn vextracti32x8(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterZmm,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmVextracti32x8<AsmMemoryOperand, AsmRegisterZmm, u32> for CodeAssembler

fn vextracti32x8(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterZmm,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmVextracti64x2<AsmMemoryOperand, AsmRegisterYmm, i32> for CodeAssembler

fn vextracti64x2(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterYmm,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmVextracti64x2<AsmMemoryOperand, AsmRegisterYmm, u32> for CodeAssembler

fn vextracti64x2(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterYmm,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmVextracti64x2<AsmMemoryOperand, AsmRegisterZmm, i32> for CodeAssembler

fn vextracti64x2(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterZmm,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmVextracti64x2<AsmMemoryOperand, AsmRegisterZmm, u32> for CodeAssembler

fn vextracti64x2(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterZmm,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmVextracti64x4<AsmMemoryOperand, AsmRegisterZmm, i32> for CodeAssembler

fn vextracti64x4(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterZmm,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmVextracti64x4<AsmMemoryOperand, AsmRegisterZmm, u32> for CodeAssembler

fn vextracti64x4(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterZmm,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmVextractps<AsmMemoryOperand, AsmRegisterXmm, i32> for CodeAssembler

fn vextractps(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterXmm,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmVextractps<AsmMemoryOperand, AsmRegisterXmm, u32> for CodeAssembler

fn vextractps(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterXmm,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmVfcmaddcph<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfcmaddcph(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfcmaddcph<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfcmaddcph(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfcmaddcph<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfcmaddcph(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfcmaddcsh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfcmaddcsh(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfcmulcph<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfcmulcph(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfcmulcph<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfcmulcph(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfcmulcph<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfcmulcph(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfcmulcsh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfcmulcsh(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfixupimmpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vfixupimmpd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVfixupimmpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vfixupimmpd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVfixupimmpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vfixupimmpd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVfixupimmpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vfixupimmpd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVfixupimmpd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vfixupimmpd(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVfixupimmpd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vfixupimmpd(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVfixupimmps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vfixupimmps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVfixupimmps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vfixupimmps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVfixupimmps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vfixupimmps(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVfixupimmps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vfixupimmps(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVfixupimmps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vfixupimmps(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVfixupimmps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vfixupimmps(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVfixupimmsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vfixupimmsd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVfixupimmsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vfixupimmsd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVfixupimmss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vfixupimmss(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVfixupimmss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vfixupimmss(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVfmadd132pd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmadd132pd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfmadd132pd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfmadd132pd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfmadd132pd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfmadd132pd(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfmadd132ph<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmadd132ph(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfmadd132ph<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfmadd132ph(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfmadd132ph<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfmadd132ph(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfmadd132ps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmadd132ps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfmadd132ps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfmadd132ps(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfmadd132ps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfmadd132ps(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfmadd132sd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmadd132sd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfmadd132sh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmadd132sh(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfmadd132ss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmadd132ss(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfmadd213pd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmadd213pd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfmadd213pd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfmadd213pd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfmadd213pd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfmadd213pd(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfmadd213ph<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmadd213ph(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfmadd213ph<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfmadd213ph(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfmadd213ph<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfmadd213ph(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfmadd213ps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmadd213ps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfmadd213ps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfmadd213ps(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfmadd213ps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfmadd213ps(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfmadd213sd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmadd213sd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfmadd213sh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmadd213sh(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfmadd213ss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmadd213ss(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfmadd231pd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmadd231pd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfmadd231pd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfmadd231pd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfmadd231pd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfmadd231pd(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfmadd231ph<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmadd231ph(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfmadd231ph<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfmadd231ph(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfmadd231ph<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfmadd231ph(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfmadd231ps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmadd231ps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfmadd231ps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfmadd231ps(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfmadd231ps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfmadd231ps(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfmadd231sd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmadd231sd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfmadd231sh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmadd231sh(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfmadd231ss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmadd231ss(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfmaddcph<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmaddcph(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfmaddcph<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfmaddcph(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfmaddcph<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfmaddcph(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfmaddcsh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmaddcsh(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfmaddpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vfmaddpd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: AsmRegisterXmm
) -> Result<(), IcedError>

impl CodeAsmVfmaddpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmaddpd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmRegisterXmm,
    op3: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfmaddpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vfmaddpd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand,
    op3: AsmRegisterYmm
) -> Result<(), IcedError>

impl CodeAsmVfmaddpd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfmaddpd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmRegisterYmm,
    op3: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfmaddps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vfmaddps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: AsmRegisterXmm
) -> Result<(), IcedError>

impl CodeAsmVfmaddps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmaddps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmRegisterXmm,
    op3: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfmaddps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vfmaddps(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand,
    op3: AsmRegisterYmm
) -> Result<(), IcedError>

impl CodeAsmVfmaddps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfmaddps(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmRegisterYmm,
    op3: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfmaddsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vfmaddsd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: AsmRegisterXmm
) -> Result<(), IcedError>

impl CodeAsmVfmaddsd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmaddsd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmRegisterXmm,
    op3: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfmaddss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vfmaddss(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: AsmRegisterXmm
) -> Result<(), IcedError>

impl CodeAsmVfmaddss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmaddss(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmRegisterXmm,
    op3: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfmaddsub132pd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmaddsub132pd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfmaddsub132pd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfmaddsub132pd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfmaddsub132pd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfmaddsub132pd(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfmaddsub132ph<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmaddsub132ph(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfmaddsub132ph<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfmaddsub132ph(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfmaddsub132ph<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfmaddsub132ph(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfmaddsub132ps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmaddsub132ps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfmaddsub132ps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfmaddsub132ps(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfmaddsub132ps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfmaddsub132ps(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfmaddsub213pd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmaddsub213pd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfmaddsub213pd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfmaddsub213pd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfmaddsub213pd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfmaddsub213pd(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfmaddsub213ph<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmaddsub213ph(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfmaddsub213ph<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfmaddsub213ph(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfmaddsub213ph<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfmaddsub213ph(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfmaddsub213ps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmaddsub213ps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfmaddsub213ps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfmaddsub213ps(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfmaddsub213ps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfmaddsub213ps(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfmaddsub231pd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmaddsub231pd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfmaddsub231pd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfmaddsub231pd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfmaddsub231pd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfmaddsub231pd(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfmaddsub231ph<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmaddsub231ph(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfmaddsub231ph<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfmaddsub231ph(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfmaddsub231ph<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfmaddsub231ph(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfmaddsub231ps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmaddsub231ps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfmaddsub231ps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfmaddsub231ps(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfmaddsub231ps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfmaddsub231ps(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfmaddsubpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vfmaddsubpd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: AsmRegisterXmm
) -> Result<(), IcedError>

impl CodeAsmVfmaddsubpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmaddsubpd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmRegisterXmm,
    op3: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfmaddsubpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vfmaddsubpd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand,
    op3: AsmRegisterYmm
) -> Result<(), IcedError>

impl CodeAsmVfmaddsubpd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfmaddsubpd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmRegisterYmm,
    op3: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfmaddsubps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vfmaddsubps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: AsmRegisterXmm
) -> Result<(), IcedError>

impl CodeAsmVfmaddsubps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmaddsubps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmRegisterXmm,
    op3: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfmaddsubps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vfmaddsubps(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand,
    op3: AsmRegisterYmm
) -> Result<(), IcedError>

impl CodeAsmVfmaddsubps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfmaddsubps(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmRegisterYmm,
    op3: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfmsub132pd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmsub132pd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfmsub132pd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfmsub132pd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfmsub132pd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfmsub132pd(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfmsub132ph<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmsub132ph(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfmsub132ph<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfmsub132ph(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfmsub132ph<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfmsub132ph(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfmsub132ps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmsub132ps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfmsub132ps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfmsub132ps(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfmsub132ps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfmsub132ps(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfmsub132sd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmsub132sd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfmsub132sh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmsub132sh(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfmsub132ss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmsub132ss(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfmsub213pd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmsub213pd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfmsub213pd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfmsub213pd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfmsub213pd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfmsub213pd(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfmsub213ph<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmsub213ph(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfmsub213ph<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfmsub213ph(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfmsub213ph<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfmsub213ph(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfmsub213ps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmsub213ps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfmsub213ps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfmsub213ps(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfmsub213ps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfmsub213ps(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfmsub213sd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmsub213sd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfmsub213sh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmsub213sh(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfmsub213ss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmsub213ss(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfmsub231pd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmsub231pd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfmsub231pd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfmsub231pd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfmsub231pd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfmsub231pd(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfmsub231ph<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmsub231ph(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfmsub231ph<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfmsub231ph(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfmsub231ph<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfmsub231ph(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfmsub231ps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmsub231ps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfmsub231ps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfmsub231ps(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfmsub231ps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfmsub231ps(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfmsub231sd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmsub231sd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfmsub231sh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmsub231sh(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfmsub231ss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmsub231ss(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfmsubadd132pd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmsubadd132pd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfmsubadd132pd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfmsubadd132pd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfmsubadd132pd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfmsubadd132pd(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfmsubadd132ph<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmsubadd132ph(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfmsubadd132ph<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfmsubadd132ph(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfmsubadd132ph<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfmsubadd132ph(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfmsubadd132ps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmsubadd132ps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfmsubadd132ps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfmsubadd132ps(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfmsubadd132ps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfmsubadd132ps(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfmsubadd213pd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmsubadd213pd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfmsubadd213pd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfmsubadd213pd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfmsubadd213pd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfmsubadd213pd(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfmsubadd213ph<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmsubadd213ph(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfmsubadd213ph<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfmsubadd213ph(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfmsubadd213ph<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfmsubadd213ph(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfmsubadd213ps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmsubadd213ps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfmsubadd213ps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfmsubadd213ps(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfmsubadd213ps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfmsubadd213ps(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfmsubadd231pd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmsubadd231pd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfmsubadd231pd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfmsubadd231pd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfmsubadd231pd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfmsubadd231pd(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfmsubadd231ph<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmsubadd231ph(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfmsubadd231ph<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfmsubadd231ph(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfmsubadd231ph<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfmsubadd231ph(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfmsubadd231ps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmsubadd231ps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfmsubadd231ps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfmsubadd231ps(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfmsubadd231ps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfmsubadd231ps(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfmsubaddpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vfmsubaddpd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: AsmRegisterXmm
) -> Result<(), IcedError>

impl CodeAsmVfmsubaddpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmsubaddpd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmRegisterXmm,
    op3: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfmsubaddpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vfmsubaddpd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand,
    op3: AsmRegisterYmm
) -> Result<(), IcedError>

impl CodeAsmVfmsubaddpd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfmsubaddpd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmRegisterYmm,
    op3: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfmsubaddps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vfmsubaddps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: AsmRegisterXmm
) -> Result<(), IcedError>

impl CodeAsmVfmsubaddps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmsubaddps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmRegisterXmm,
    op3: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfmsubaddps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vfmsubaddps(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand,
    op3: AsmRegisterYmm
) -> Result<(), IcedError>

impl CodeAsmVfmsubaddps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfmsubaddps(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmRegisterYmm,
    op3: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfmsubpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vfmsubpd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: AsmRegisterXmm
) -> Result<(), IcedError>

impl CodeAsmVfmsubpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmsubpd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmRegisterXmm,
    op3: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfmsubpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vfmsubpd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand,
    op3: AsmRegisterYmm
) -> Result<(), IcedError>

impl CodeAsmVfmsubpd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfmsubpd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmRegisterYmm,
    op3: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfmsubps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vfmsubps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: AsmRegisterXmm
) -> Result<(), IcedError>

impl CodeAsmVfmsubps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmsubps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmRegisterXmm,
    op3: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfmsubps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vfmsubps(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand,
    op3: AsmRegisterYmm
) -> Result<(), IcedError>

impl CodeAsmVfmsubps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfmsubps(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmRegisterYmm,
    op3: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfmsubsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vfmsubsd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: AsmRegisterXmm
) -> Result<(), IcedError>

impl CodeAsmVfmsubsd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmsubsd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmRegisterXmm,
    op3: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfmsubss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vfmsubss(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: AsmRegisterXmm
) -> Result<(), IcedError>

impl CodeAsmVfmsubss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmsubss(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmRegisterXmm,
    op3: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfmulcph<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmulcph(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfmulcph<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfmulcph(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfmulcph<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfmulcph(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfmulcsh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmulcsh(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfnmadd132pd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmadd132pd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfnmadd132pd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfnmadd132pd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfnmadd132pd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfnmadd132pd(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfnmadd132ph<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmadd132ph(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfnmadd132ph<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfnmadd132ph(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfnmadd132ph<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfnmadd132ph(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfnmadd132ps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmadd132ps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfnmadd132ps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfnmadd132ps(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfnmadd132ps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfnmadd132ps(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfnmadd132sd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmadd132sd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfnmadd132sh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmadd132sh(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfnmadd132ss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmadd132ss(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfnmadd213pd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmadd213pd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfnmadd213pd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfnmadd213pd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfnmadd213pd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfnmadd213pd(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfnmadd213ph<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmadd213ph(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfnmadd213ph<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfnmadd213ph(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfnmadd213ph<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfnmadd213ph(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfnmadd213ps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmadd213ps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfnmadd213ps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfnmadd213ps(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfnmadd213ps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfnmadd213ps(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfnmadd213sd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmadd213sd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfnmadd213sh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmadd213sh(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfnmadd213ss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmadd213ss(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfnmadd231pd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmadd231pd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfnmadd231pd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfnmadd231pd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfnmadd231pd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfnmadd231pd(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfnmadd231ph<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmadd231ph(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfnmadd231ph<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfnmadd231ph(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfnmadd231ph<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfnmadd231ph(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfnmadd231ps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmadd231ps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfnmadd231ps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfnmadd231ps(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfnmadd231ps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfnmadd231ps(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfnmadd231sd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmadd231sd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfnmadd231sh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmadd231sh(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfnmadd231ss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmadd231ss(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfnmaddpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vfnmaddpd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: AsmRegisterXmm
) -> Result<(), IcedError>

impl CodeAsmVfnmaddpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmaddpd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmRegisterXmm,
    op3: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfnmaddpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vfnmaddpd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand,
    op3: AsmRegisterYmm
) -> Result<(), IcedError>

impl CodeAsmVfnmaddpd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfnmaddpd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmRegisterYmm,
    op3: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfnmaddps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vfnmaddps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: AsmRegisterXmm
) -> Result<(), IcedError>

impl CodeAsmVfnmaddps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmaddps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmRegisterXmm,
    op3: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfnmaddps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vfnmaddps(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand,
    op3: AsmRegisterYmm
) -> Result<(), IcedError>

impl CodeAsmVfnmaddps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfnmaddps(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmRegisterYmm,
    op3: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfnmaddsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vfnmaddsd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: AsmRegisterXmm
) -> Result<(), IcedError>

impl CodeAsmVfnmaddsd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmaddsd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmRegisterXmm,
    op3: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfnmaddss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vfnmaddss(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: AsmRegisterXmm
) -> Result<(), IcedError>

impl CodeAsmVfnmaddss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmaddss(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmRegisterXmm,
    op3: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfnmsub132pd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmsub132pd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfnmsub132pd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfnmsub132pd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfnmsub132pd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfnmsub132pd(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfnmsub132ph<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmsub132ph(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfnmsub132ph<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfnmsub132ph(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfnmsub132ph<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfnmsub132ph(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfnmsub132ps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmsub132ps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfnmsub132ps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfnmsub132ps(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfnmsub132ps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfnmsub132ps(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfnmsub132sd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmsub132sd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfnmsub132sh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmsub132sh(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfnmsub132ss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmsub132ss(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfnmsub213pd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmsub213pd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfnmsub213pd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfnmsub213pd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfnmsub213pd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfnmsub213pd(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfnmsub213ph<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmsub213ph(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfnmsub213ph<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfnmsub213ph(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfnmsub213ph<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfnmsub213ph(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfnmsub213ps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmsub213ps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfnmsub213ps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfnmsub213ps(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfnmsub213ps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfnmsub213ps(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfnmsub213sd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmsub213sd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfnmsub213sh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmsub213sh(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfnmsub213ss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmsub213ss(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfnmsub231pd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmsub231pd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfnmsub231pd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfnmsub231pd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfnmsub231pd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfnmsub231pd(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfnmsub231ph<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmsub231ph(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfnmsub231ph<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfnmsub231ph(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfnmsub231ph<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfnmsub231ph(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfnmsub231ps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmsub231ps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfnmsub231ps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfnmsub231ps(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfnmsub231ps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfnmsub231ps(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfnmsub231sd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmsub231sd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfnmsub231sh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmsub231sh(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfnmsub231ss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmsub231ss(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfnmsubpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vfnmsubpd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: AsmRegisterXmm
) -> Result<(), IcedError>

impl CodeAsmVfnmsubpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmsubpd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmRegisterXmm,
    op3: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfnmsubpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vfnmsubpd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand,
    op3: AsmRegisterYmm
) -> Result<(), IcedError>

impl CodeAsmVfnmsubpd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfnmsubpd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmRegisterYmm,
    op3: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfnmsubps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vfnmsubps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: AsmRegisterXmm
) -> Result<(), IcedError>

impl CodeAsmVfnmsubps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmsubps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmRegisterXmm,
    op3: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfnmsubps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vfnmsubps(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand,
    op3: AsmRegisterYmm
) -> Result<(), IcedError>

impl CodeAsmVfnmsubps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfnmsubps(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmRegisterYmm,
    op3: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfnmsubsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vfnmsubsd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: AsmRegisterXmm
) -> Result<(), IcedError>

impl CodeAsmVfnmsubsd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmsubsd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmRegisterXmm,
    op3: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfnmsubss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vfnmsubss(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: AsmRegisterXmm
) -> Result<(), IcedError>

impl CodeAsmVfnmsubss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmsubss(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmRegisterXmm,
    op3: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfpclasspd<AsmRegisterK, AsmMemoryOperand, i32> for CodeAssembler

fn vfpclasspd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmVfpclasspd<AsmRegisterK, AsmMemoryOperand, u32> for CodeAssembler

fn vfpclasspd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmVfpclasspdx<AsmRegisterK, AsmMemoryOperand, i32> for CodeAssembler

fn vfpclasspdx(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmVfpclasspdx<AsmRegisterK, AsmMemoryOperand, u32> for CodeAssembler

fn vfpclasspdx(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmVfpclasspdy<AsmRegisterK, AsmMemoryOperand, i32> for CodeAssembler

fn vfpclasspdy(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmVfpclasspdy<AsmRegisterK, AsmMemoryOperand, u32> for CodeAssembler

fn vfpclasspdy(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmVfpclasspdz<AsmRegisterK, AsmMemoryOperand, i32> for CodeAssembler

fn vfpclasspdz(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmVfpclasspdz<AsmRegisterK, AsmMemoryOperand, u32> for CodeAssembler

fn vfpclasspdz(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmVfpclassph<AsmRegisterK, AsmMemoryOperand, i32> for CodeAssembler

fn vfpclassph(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmVfpclassph<AsmRegisterK, AsmMemoryOperand, u32> for CodeAssembler

fn vfpclassph(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmVfpclassphx<AsmRegisterK, AsmMemoryOperand, i32> for CodeAssembler

fn vfpclassphx(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmVfpclassphx<AsmRegisterK, AsmMemoryOperand, u32> for CodeAssembler

fn vfpclassphx(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmVfpclassphy<AsmRegisterK, AsmMemoryOperand, i32> for CodeAssembler

fn vfpclassphy(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmVfpclassphy<AsmRegisterK, AsmMemoryOperand, u32> for CodeAssembler

fn vfpclassphy(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmVfpclassphz<AsmRegisterK, AsmMemoryOperand, i32> for CodeAssembler

fn vfpclassphz(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmVfpclassphz<AsmRegisterK, AsmMemoryOperand, u32> for CodeAssembler

fn vfpclassphz(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmVfpclassps<AsmRegisterK, AsmMemoryOperand, i32> for CodeAssembler

fn vfpclassps(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmVfpclassps<AsmRegisterK, AsmMemoryOperand, u32> for CodeAssembler

fn vfpclassps(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmVfpclasspsx<AsmRegisterK, AsmMemoryOperand, i32> for CodeAssembler

fn vfpclasspsx(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmVfpclasspsx<AsmRegisterK, AsmMemoryOperand, u32> for CodeAssembler

fn vfpclasspsx(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmVfpclasspsy<AsmRegisterK, AsmMemoryOperand, i32> for CodeAssembler

fn vfpclasspsy(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmVfpclasspsy<AsmRegisterK, AsmMemoryOperand, u32> for CodeAssembler

fn vfpclasspsy(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmVfpclasspsz<AsmRegisterK, AsmMemoryOperand, i32> for CodeAssembler

fn vfpclasspsz(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmVfpclasspsz<AsmRegisterK, AsmMemoryOperand, u32> for CodeAssembler

fn vfpclasspsz(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmVfpclasssd<AsmRegisterK, AsmMemoryOperand, i32> for CodeAssembler

fn vfpclasssd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmVfpclasssd<AsmRegisterK, AsmMemoryOperand, u32> for CodeAssembler

fn vfpclasssd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmVfpclasssh<AsmRegisterK, AsmMemoryOperand, i32> for CodeAssembler

fn vfpclasssh(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmVfpclasssh<AsmRegisterK, AsmMemoryOperand, u32> for CodeAssembler

fn vfpclasssh(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmVfpclassss<AsmRegisterK, AsmMemoryOperand, i32> for CodeAssembler

fn vfpclassss(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmVfpclassss<AsmRegisterK, AsmMemoryOperand, u32> for CodeAssembler

fn vfpclassss(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmVfrczpd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfrczpd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfrczpd<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfrczpd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfrczps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfrczps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfrczps<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfrczps(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfrczsd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfrczsd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVfrczss<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfrczss(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVgatherdpd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vgatherdpd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVgatherdpd<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vgatherdpd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVgatherdpd<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vgatherdpd(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVgatherdpd3<AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vgatherdpd_3(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: AsmRegisterXmm
) -> Result<(), IcedError>

impl CodeAsmVgatherdpd3<AsmRegisterYmm, AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vgatherdpd_3(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand,
    op2: AsmRegisterYmm
) -> Result<(), IcedError>

impl CodeAsmVgatherdps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vgatherdps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVgatherdps<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vgatherdps(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVgatherdps<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vgatherdps(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVgatherdps3<AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vgatherdps_3(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: AsmRegisterXmm
) -> Result<(), IcedError>

impl CodeAsmVgatherdps3<AsmRegisterYmm, AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vgatherdps_3(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand,
    op2: AsmRegisterYmm
) -> Result<(), IcedError>

impl CodeAsmVgatherpf0dpd<AsmMemoryOperand> for CodeAssembler

fn vgatherpf0dpd(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmVgatherpf0dps<AsmMemoryOperand> for CodeAssembler

fn vgatherpf0dps(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmVgatherpf0qpd<AsmMemoryOperand> for CodeAssembler

fn vgatherpf0qpd(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmVgatherpf0qps<AsmMemoryOperand> for CodeAssembler

fn vgatherpf0qps(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmVgatherpf1dpd<AsmMemoryOperand> for CodeAssembler

fn vgatherpf1dpd(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmVgatherpf1dps<AsmMemoryOperand> for CodeAssembler

fn vgatherpf1dps(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmVgatherpf1qpd<AsmMemoryOperand> for CodeAssembler

fn vgatherpf1qpd(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmVgatherpf1qps<AsmMemoryOperand> for CodeAssembler

fn vgatherpf1qps(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmVgatherqpd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vgatherqpd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVgatherqpd<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vgatherqpd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVgatherqpd<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vgatherqpd(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVgatherqpd3<AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vgatherqpd_3(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: AsmRegisterXmm
) -> Result<(), IcedError>

impl CodeAsmVgatherqpd3<AsmRegisterYmm, AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vgatherqpd_3(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand,
    op2: AsmRegisterYmm
) -> Result<(), IcedError>

impl CodeAsmVgatherqps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vgatherqps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVgatherqps<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vgatherqps(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVgatherqps3<AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vgatherqps_3(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: AsmRegisterXmm
) -> Result<(), IcedError>

impl CodeAsmVgetexppd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vgetexppd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVgetexppd<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vgetexppd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVgetexppd<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vgetexppd(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVgetexpph<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vgetexpph(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVgetexpph<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vgetexpph(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVgetexpph<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vgetexpph(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVgetexpps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vgetexpps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVgetexpps<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vgetexpps(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVgetexpps<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vgetexpps(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVgetexpsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vgetexpsd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVgetexpsh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vgetexpsh(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVgetexpss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vgetexpss(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVgetmantpd<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vgetmantpd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmVgetmantpd<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vgetmantpd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmVgetmantpd<AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vgetmantpd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmVgetmantpd<AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vgetmantpd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmVgetmantpd<AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vgetmantpd(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmVgetmantpd<AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vgetmantpd(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmVgetmantph<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vgetmantph(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmVgetmantph<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vgetmantph(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmVgetmantph<AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vgetmantph(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmVgetmantph<AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vgetmantph(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmVgetmantph<AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vgetmantph(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmVgetmantph<AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vgetmantph(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmVgetmantps<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vgetmantps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmVgetmantps<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vgetmantps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmVgetmantps<AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vgetmantps(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmVgetmantps<AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vgetmantps(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmVgetmantps<AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vgetmantps(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmVgetmantps<AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vgetmantps(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmVgetmantsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vgetmantsd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVgetmantsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vgetmantsd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVgetmantsh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vgetmantsh(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVgetmantsh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vgetmantsh(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVgetmantss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vgetmantss(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVgetmantss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vgetmantss(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVgf2p8affineinvqb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vgf2p8affineinvqb(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVgf2p8affineinvqb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vgf2p8affineinvqb(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVgf2p8affineinvqb<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vgf2p8affineinvqb(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVgf2p8affineinvqb<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vgf2p8affineinvqb(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVgf2p8affineinvqb<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vgf2p8affineinvqb(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVgf2p8affineinvqb<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vgf2p8affineinvqb(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVgf2p8affineqb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vgf2p8affineqb(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVgf2p8affineqb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vgf2p8affineqb(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVgf2p8affineqb<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vgf2p8affineqb(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVgf2p8affineqb<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vgf2p8affineqb(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVgf2p8affineqb<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vgf2p8affineqb(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVgf2p8affineqb<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vgf2p8affineqb(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVgf2p8mulb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vgf2p8mulb(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVgf2p8mulb<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vgf2p8mulb(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVgf2p8mulb<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vgf2p8mulb(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVhaddpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vhaddpd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVhaddpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vhaddpd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVhaddps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vhaddps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVhaddps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vhaddps(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVhsubpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vhsubpd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVhsubpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vhsubpd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVhsubps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vhsubps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVhsubps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vhsubps(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVinsertf128<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vinsertf128(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVinsertf128<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vinsertf128(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVinsertf32x4<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vinsertf32x4(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVinsertf32x4<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vinsertf32x4(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVinsertf32x4<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vinsertf32x4(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVinsertf32x4<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vinsertf32x4(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVinsertf32x8<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vinsertf32x8(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVinsertf32x8<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vinsertf32x8(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVinsertf64x2<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vinsertf64x2(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVinsertf64x2<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vinsertf64x2(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVinsertf64x2<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vinsertf64x2(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVinsertf64x2<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vinsertf64x2(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVinsertf64x4<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vinsertf64x4(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVinsertf64x4<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vinsertf64x4(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVinserti128<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vinserti128(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVinserti128<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vinserti128(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVinserti32x4<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vinserti32x4(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVinserti32x4<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vinserti32x4(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVinserti32x4<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vinserti32x4(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVinserti32x4<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vinserti32x4(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVinserti32x8<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vinserti32x8(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVinserti32x8<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vinserti32x8(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVinserti64x2<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vinserti64x2(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVinserti64x2<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vinserti64x2(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVinserti64x2<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vinserti64x2(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVinserti64x2<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vinserti64x2(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVinserti64x4<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vinserti64x4(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVinserti64x4<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vinserti64x4(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVinsertps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vinsertps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVinsertps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vinsertps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVlddqu<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vlddqu(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVlddqu<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vlddqu(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVldmxcsr<AsmMemoryOperand> for CodeAssembler

fn vldmxcsr(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmVmaskmovpd<AsmMemoryOperand, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vmaskmovpd(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterXmm,
    op2: AsmRegisterXmm
) -> Result<(), IcedError>

impl CodeAsmVmaskmovpd<AsmMemoryOperand, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vmaskmovpd(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterYmm,
    op2: AsmRegisterYmm
) -> Result<(), IcedError>

impl CodeAsmVmaskmovpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vmaskmovpd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVmaskmovpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vmaskmovpd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVmaskmovps<AsmMemoryOperand, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vmaskmovps(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterXmm,
    op2: AsmRegisterXmm
) -> Result<(), IcedError>

impl CodeAsmVmaskmovps<AsmMemoryOperand, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vmaskmovps(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterYmm,
    op2: AsmRegisterYmm
) -> Result<(), IcedError>

impl CodeAsmVmaskmovps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vmaskmovps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVmaskmovps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vmaskmovps(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVmaxpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vmaxpd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVmaxpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vmaxpd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVmaxpd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vmaxpd(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVmaxph<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vmaxph(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVmaxph<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vmaxph(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVmaxph<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vmaxph(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVmaxps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vmaxps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVmaxps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vmaxps(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVmaxps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vmaxps(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVmaxsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vmaxsd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVmaxsh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vmaxsh(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVmaxss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vmaxss(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVmclear<AsmMemoryOperand> for CodeAssembler

fn vmclear(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmVminpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vminpd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVminpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vminpd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVminpd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vminpd(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVminph<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vminph(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVminph<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vminph(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVminph<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vminph(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVminps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vminps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVminps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vminps(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVminps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vminps(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVminsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vminsd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVminsh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vminsh(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVminss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vminss(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVmovapd<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vmovapd(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterXmm
) -> Result<(), IcedError>

impl CodeAsmVmovapd<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vmovapd(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterYmm
) -> Result<(), IcedError>

impl CodeAsmVmovapd<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

fn vmovapd(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterZmm
) -> Result<(), IcedError>

impl CodeAsmVmovapd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vmovapd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVmovapd<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vmovapd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVmovapd<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vmovapd(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVmovaps<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vmovaps(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterXmm
) -> Result<(), IcedError>

impl CodeAsmVmovaps<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vmovaps(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterYmm
) -> Result<(), IcedError>

impl CodeAsmVmovaps<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

fn vmovaps(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterZmm
) -> Result<(), IcedError>

impl CodeAsmVmovaps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vmovaps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVmovaps<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vmovaps(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVmovaps<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vmovaps(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVmovd<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vmovd(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterXmm
) -> Result<(), IcedError>

impl CodeAsmVmovd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vmovd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVmovddup<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vmovddup(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVmovddup<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vmovddup(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVmovddup<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vmovddup(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVmovdqa<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vmovdqa(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterXmm
) -> Result<(), IcedError>

impl CodeAsmVmovdqa<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vmovdqa(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterYmm
) -> Result<(), IcedError>

impl CodeAsmVmovdqa<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vmovdqa(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVmovdqa<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vmovdqa(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVmovdqa32<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vmovdqa32(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterXmm
) -> Result<(), IcedError>

impl CodeAsmVmovdqa32<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vmovdqa32(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterYmm
) -> Result<(), IcedError>

impl CodeAsmVmovdqa32<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

fn vmovdqa32(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterZmm
) -> Result<(), IcedError>

impl CodeAsmVmovdqa32<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vmovdqa32(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVmovdqa32<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vmovdqa32(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVmovdqa32<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vmovdqa32(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVmovdqa64<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vmovdqa64(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterXmm
) -> Result<(), IcedError>

impl CodeAsmVmovdqa64<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vmovdqa64(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterYmm
) -> Result<(), IcedError>

impl CodeAsmVmovdqa64<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

fn vmovdqa64(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterZmm
) -> Result<(), IcedError>

impl CodeAsmVmovdqa64<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vmovdqa64(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVmovdqa64<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vmovdqa64(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVmovdqa64<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vmovdqa64(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVmovdqu<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vmovdqu(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterXmm
) -> Result<(), IcedError>

impl CodeAsmVmovdqu<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vmovdqu(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterYmm
) -> Result<(), IcedError>

impl CodeAsmVmovdqu<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vmovdqu(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVmovdqu<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vmovdqu(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVmovdqu16<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vmovdqu16(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterXmm
) -> Result<(), IcedError>

impl CodeAsmVmovdqu16<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vmovdqu16(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterYmm
) -> Result<(), IcedError>

impl CodeAsmVmovdqu16<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

fn vmovdqu16(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterZmm
) -> Result<(), IcedError>

impl CodeAsmVmovdqu16<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vmovdqu16(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVmovdqu16<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vmovdqu16(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVmovdqu16<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vmovdqu16(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVmovdqu32<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vmovdqu32(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterXmm
) -> Result<(), IcedError>

impl CodeAsmVmovdqu32<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vmovdqu32(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterYmm
) -> Result<(), IcedError>

impl CodeAsmVmovdqu32<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

fn vmovdqu32(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterZmm
) -> Result<(), IcedError>

impl CodeAsmVmovdqu32<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vmovdqu32(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVmovdqu32<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vmovdqu32(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVmovdqu32<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vmovdqu32(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVmovdqu64<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vmovdqu64(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterXmm
) -> Result<(), IcedError>

impl CodeAsmVmovdqu64<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vmovdqu64(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterYmm
) -> Result<(), IcedError>

impl CodeAsmVmovdqu64<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

fn vmovdqu64(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterZmm
) -> Result<(), IcedError>

impl CodeAsmVmovdqu64<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vmovdqu64(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVmovdqu64<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vmovdqu64(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVmovdqu64<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vmovdqu64(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVmovdqu8<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vmovdqu8(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterXmm
) -> Result<(), IcedError>

impl CodeAsmVmovdqu8<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vmovdqu8(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterYmm
) -> Result<(), IcedError>

impl CodeAsmVmovdqu8<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

fn vmovdqu8(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterZmm
) -> Result<(), IcedError>

impl CodeAsmVmovdqu8<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vmovdqu8(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVmovdqu8<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vmovdqu8(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVmovdqu8<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vmovdqu8(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVmovhpd<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vmovhpd(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterXmm
) -> Result<(), IcedError>

impl CodeAsmVmovhpd3<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vmovhpd_3(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVmovhps<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vmovhps(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterXmm
) -> Result<(), IcedError>

impl CodeAsmVmovhps3<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vmovhps_3(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVmovlpd<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vmovlpd(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterXmm
) -> Result<(), IcedError>

impl CodeAsmVmovlpd3<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vmovlpd_3(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVmovlps<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vmovlps(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterXmm
) -> Result<(), IcedError>

impl CodeAsmVmovlps3<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vmovlps_3(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVmovntdq<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vmovntdq(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterXmm
) -> Result<(), IcedError>

impl CodeAsmVmovntdq<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vmovntdq(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterYmm
) -> Result<(), IcedError>

impl CodeAsmVmovntdq<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

fn vmovntdq(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterZmm
) -> Result<(), IcedError>

impl CodeAsmVmovntdqa<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vmovntdqa(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVmovntdqa<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vmovntdqa(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVmovntdqa<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vmovntdqa(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVmovntpd<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vmovntpd(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterXmm
) -> Result<(), IcedError>

impl CodeAsmVmovntpd<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vmovntpd(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterYmm
) -> Result<(), IcedError>

impl CodeAsmVmovntpd<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

fn vmovntpd(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterZmm
) -> Result<(), IcedError>

impl CodeAsmVmovntps<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vmovntps(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterXmm
) -> Result<(), IcedError>

impl CodeAsmVmovntps<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vmovntps(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterYmm
) -> Result<(), IcedError>

impl CodeAsmVmovntps<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

fn vmovntps(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterZmm
) -> Result<(), IcedError>

impl CodeAsmVmovq<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vmovq(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterXmm
) -> Result<(), IcedError>

impl CodeAsmVmovq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vmovq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVmovsd<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vmovsd(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterXmm
) -> Result<(), IcedError>

impl CodeAsmVmovsd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vmovsd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVmovsh<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vmovsh(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterXmm
) -> Result<(), IcedError>

impl CodeAsmVmovsh<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vmovsh(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVmovshdup<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vmovshdup(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVmovshdup<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vmovshdup(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVmovshdup<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vmovshdup(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVmovsldup<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vmovsldup(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVmovsldup<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vmovsldup(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVmovsldup<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vmovsldup(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVmovss<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vmovss(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterXmm
) -> Result<(), IcedError>

impl CodeAsmVmovss<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vmovss(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVmovupd<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vmovupd(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterXmm
) -> Result<(), IcedError>

impl CodeAsmVmovupd<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vmovupd(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterYmm
) -> Result<(), IcedError>

impl CodeAsmVmovupd<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

fn vmovupd(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterZmm
) -> Result<(), IcedError>

impl CodeAsmVmovupd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vmovupd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVmovupd<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vmovupd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVmovupd<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vmovupd(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVmovups<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vmovups(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterXmm
) -> Result<(), IcedError>

impl CodeAsmVmovups<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vmovups(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterYmm
) -> Result<(), IcedError>

impl CodeAsmVmovups<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

fn vmovups(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterZmm
) -> Result<(), IcedError>

impl CodeAsmVmovups<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vmovups(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVmovups<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vmovups(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVmovups<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vmovups(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVmovw<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vmovw(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterXmm
) -> Result<(), IcedError>

impl CodeAsmVmovw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vmovw(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVmpsadbw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vmpsadbw(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVmpsadbw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vmpsadbw(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVmpsadbw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vmpsadbw(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVmpsadbw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vmpsadbw(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVmptrld<AsmMemoryOperand> for CodeAssembler

fn vmptrld(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmVmptrst<AsmMemoryOperand> for CodeAssembler

fn vmptrst(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmVmread<AsmMemoryOperand, AsmRegister32> for CodeAssembler

fn vmread(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegister32
) -> Result<(), IcedError>

impl CodeAsmVmread<AsmMemoryOperand, AsmRegister64> for CodeAssembler

fn vmread(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegister64
) -> Result<(), IcedError>

impl CodeAsmVmulpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vmulpd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVmulpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vmulpd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVmulpd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vmulpd(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVmulph<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vmulph(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVmulph<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vmulph(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVmulph<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vmulph(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVmulps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vmulps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVmulps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vmulps(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVmulps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vmulps(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVmulsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vmulsd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVmulsh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vmulsh(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVmulss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vmulss(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVmwrite<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn vmwrite(
    &mut self,
    op0: AsmRegister32,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVmwrite<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn vmwrite(
    &mut self,
    op0: AsmRegister64,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVmxon<AsmMemoryOperand> for CodeAssembler

fn vmxon(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmVorpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vorpd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVorpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vorpd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVorpd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vorpd(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVorps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vorps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVorps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vorps(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVorps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vorps(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVp2intersectd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vp2intersectd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVp2intersectd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vp2intersectd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVp2intersectd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vp2intersectd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVp2intersectq<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vp2intersectq(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVp2intersectq<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vp2intersectq(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVp2intersectq<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vp2intersectq(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVp4dpwssd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vp4dpwssd(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVp4dpwssds<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vp4dpwssds(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpabsb<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpabsb(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpabsb<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpabsb(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpabsb<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpabsb(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpabsd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpabsd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpabsd<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpabsd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpabsd<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpabsd(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpabsq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpabsq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpabsq<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpabsq(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpabsq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpabsq(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpabsw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpabsw(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpabsw<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpabsw(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpabsw<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpabsw(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpackssdw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpackssdw(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpackssdw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpackssdw(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpackssdw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpackssdw(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpacksswb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpacksswb(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpacksswb<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpacksswb(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpacksswb<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpacksswb(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpackusdw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpackusdw(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpackusdw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpackusdw(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpackusdw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpackusdw(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpackuswb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpackuswb(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpackuswb<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpackuswb(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpackuswb<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpackuswb(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpaddb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpaddb(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpaddb<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpaddb(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpaddb<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpaddb(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpaddd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpaddd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpaddd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpaddd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpaddd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpaddd(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpaddq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpaddq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpaddq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpaddq(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpaddq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpaddq(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpaddsb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpaddsb(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpaddsb<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpaddsb(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpaddsb<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpaddsb(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpaddsw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpaddsw(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpaddsw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpaddsw(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpaddsw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpaddsw(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpaddusb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpaddusb(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpaddusb<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpaddusb(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpaddusb<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpaddusb(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpaddusw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpaddusw(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpaddusw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpaddusw(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpaddusw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpaddusw(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpaddw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpaddw(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpaddw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpaddw(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpaddw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpaddw(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpalignr<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpalignr(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVpalignr<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpalignr(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVpalignr<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpalignr(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVpalignr<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpalignr(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVpalignr<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpalignr(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVpalignr<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpalignr(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVpand<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpand(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpand<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpand(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpandd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpandd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpandd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpandd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpandd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpandd(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpandn<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpandn(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpandn<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpandn(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpandnd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpandnd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpandnd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpandnd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpandnd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpandnd(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpandnq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpandnq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpandnq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpandnq(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpandnq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpandnq(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpandq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpandq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpandq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpandq(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpandq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpandq(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpavgb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpavgb(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpavgb<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpavgb(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpavgb<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpavgb(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpavgw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpavgw(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpavgw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpavgw(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpavgw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpavgw(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpblendd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpblendd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVpblendd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpblendd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVpblendd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpblendd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVpblendd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpblendd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVpblendmb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpblendmb(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpblendmb<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpblendmb(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpblendmb<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpblendmb(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpblendmd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpblendmd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpblendmd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpblendmd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpblendmd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpblendmd(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpblendmq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpblendmq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpblendmq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpblendmq(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpblendmq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpblendmq(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpblendmw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpblendmw(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpblendmw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpblendmw(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpblendmw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpblendmw(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpblendvb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpblendvb(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: AsmRegisterXmm
) -> Result<(), IcedError>

impl CodeAsmVpblendvb<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vpblendvb(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand,
    op3: AsmRegisterYmm
) -> Result<(), IcedError>

impl CodeAsmVpblendw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpblendw(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVpblendw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpblendw(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVpblendw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpblendw(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVpblendw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpblendw(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVpbroadcastb<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpbroadcastb(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpbroadcastb<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpbroadcastb(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpbroadcastb<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpbroadcastb(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpbroadcastd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpbroadcastd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpbroadcastd<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpbroadcastd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpbroadcastd<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpbroadcastd(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpbroadcastq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpbroadcastq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpbroadcastq<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpbroadcastq(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpbroadcastq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpbroadcastq(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpbroadcastw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpbroadcastw(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpbroadcastw<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpbroadcastw(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpbroadcastw<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpbroadcastw(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpclmulhqhqdq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpclmulhqhqdq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpclmulhqhqdq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpclmulhqhqdq(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpclmulhqhqdq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpclmulhqhqdq(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpclmulhqlqdq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpclmulhqlqdq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpclmulhqlqdq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpclmulhqlqdq(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpclmulhqlqdq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpclmulhqlqdq(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpclmullqhqdq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpclmullqhqdq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpclmullqhqdq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpclmullqhqdq(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpclmullqhqdq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpclmullqhqdq(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpclmullqlqdq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpclmullqlqdq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpclmullqlqdq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpclmullqlqdq(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpclmullqlqdq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpclmullqlqdq(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpclmulqdq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpclmulqdq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVpclmulqdq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpclmulqdq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVpclmulqdq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpclmulqdq(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVpclmulqdq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpclmulqdq(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVpclmulqdq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpclmulqdq(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVpclmulqdq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpclmulqdq(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVpcmov<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpcmov(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: AsmRegisterXmm
) -> Result<(), IcedError>

impl CodeAsmVpcmov<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmov(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmRegisterXmm,
    op3: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmov<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vpcmov(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand,
    op3: AsmRegisterYmm
) -> Result<(), IcedError>

impl CodeAsmVpcmov<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmov(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmRegisterYmm,
    op3: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpb<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpcmpb(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVpcmpb<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpcmpb(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVpcmpb<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpcmpb(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVpcmpb<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpcmpb(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVpcmpb<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpcmpb(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVpcmpb<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpcmpb(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVpcmpd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpcmpd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVpcmpd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpcmpd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVpcmpd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpcmpd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVpcmpd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpcmpd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVpcmpd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpcmpd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVpcmpd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpcmpd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVpcmpeqb<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpeqb(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpeqb<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpeqb(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpeqb<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpeqb(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpeqb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpeqb(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpeqb<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpeqb(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpeqd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpeqd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpeqd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpeqd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpeqd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpeqd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpeqd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpeqd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpeqd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpeqd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpeqq<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpeqq(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpeqq<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpeqq(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpeqq<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpeqq(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpeqq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpeqq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpeqq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpeqq(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpequb<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpequb(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpequb<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpequb(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpequb<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpequb(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpequd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpequd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpequd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpequd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpequd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpequd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpequq<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpequq(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpequq<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpequq(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpequq<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpequq(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpequw<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpequw(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpequw<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpequw(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpequw<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpequw(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpeqw<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpeqw(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpeqw<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpeqw(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpeqw<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpeqw(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpeqw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpeqw(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpeqw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpeqw(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpestri<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpcmpestri(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmVpcmpestri<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpcmpestri(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmVpcmpestri64<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpcmpestri64(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmVpcmpestri64<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpcmpestri64(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmVpcmpestrm<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpcmpestrm(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmVpcmpestrm<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpcmpestrm(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmVpcmpestrm64<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpcmpestrm64(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmVpcmpestrm64<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpcmpestrm64(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmVpcmpfalseb<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpfalseb(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpfalseb<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpfalseb(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpfalseb<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpfalseb(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpfalsed<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpfalsed(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpfalsed<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpfalsed(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpfalsed<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpfalsed(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpfalseq<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpfalseq(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpfalseq<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpfalseq(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpfalseq<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpfalseq(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpfalseub<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpfalseub(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpfalseub<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpfalseub(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpfalseub<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpfalseub(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpfalseud<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpfalseud(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpfalseud<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpfalseud(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpfalseud<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpfalseud(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpfalseuq<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpfalseuq(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpfalseuq<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpfalseuq(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpfalseuq<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpfalseuq(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpfalseuw<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpfalseuw(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpfalseuw<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpfalseuw(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpfalseuw<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpfalseuw(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpfalsew<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpfalsew(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpfalsew<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpfalsew(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpfalsew<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpfalsew(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpgtb<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpgtb(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpgtb<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpgtb(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpgtb<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpgtb(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpgtb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpgtb(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpgtb<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpgtb(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpgtd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpgtd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpgtd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpgtd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpgtd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpgtd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpgtd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpgtd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpgtd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpgtd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpgtq<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpgtq(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpgtq<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpgtq(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpgtq<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpgtq(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpgtq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpgtq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpgtq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpgtq(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpgtw<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpgtw(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpgtw<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpgtw(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpgtw<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpgtw(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpgtw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpgtw(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpgtw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpgtw(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpistri<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpcmpistri(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmVpcmpistri<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpcmpistri(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmVpcmpistrm<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpcmpistrm(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmVpcmpistrm<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpcmpistrm(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmVpcmpleb<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpleb(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpleb<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpleb(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpleb<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpleb(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpled<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpled(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpled<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpled(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpled<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpled(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpleq<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpleq(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpleq<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpleq(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpleq<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpleq(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpleub<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpleub(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpleub<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpleub(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpleub<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpleub(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpleud<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpleud(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpleud<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpleud(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpleud<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpleud(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpleuq<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpleuq(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpleuq<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpleuq(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpleuq<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpleuq(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpleuw<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpleuw(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpleuw<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpleuw(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpleuw<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpleuw(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmplew<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmplew(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmplew<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmplew(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmplew<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmplew(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpltb<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpltb(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpltb<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpltb(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpltb<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpltb(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpltd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpltd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpltd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpltd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpltd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpltd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpltq<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpltq(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpltq<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpltq(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpltq<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpltq(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpltub<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpltub(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpltub<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpltub(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpltub<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpltub(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpltud<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpltud(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpltud<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpltud(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpltud<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpltud(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpltuq<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpltuq(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpltuq<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpltuq(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpltuq<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpltuq(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpltuw<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpltuw(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpltuw<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpltuw(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpltuw<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpltuw(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpltw<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpltw(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpltw<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpltw(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpltw<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpltw(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpneqb<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpneqb(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpneqb<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpneqb(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpneqb<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpneqb(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpneqd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpneqd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpneqd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpneqd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpneqd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpneqd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpneqq<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpneqq(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpneqq<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpneqq(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpneqq<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpneqq(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpnequb<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnequb(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpnequb<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnequb(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpnequb<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnequb(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpnequd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnequd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpnequd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnequd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpnequd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnequd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpnequq<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnequq(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpnequq<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnequq(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpnequq<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnequq(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpnequw<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnequw(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpnequw<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnequw(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpnequw<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnequw(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpneqw<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpneqw(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpneqw<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpneqw(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpneqw<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpneqw(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpnleb<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnleb(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpnleb<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnleb(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpnleb<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnleb(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpnled<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnled(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpnled<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnled(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpnled<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnled(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpnleq<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnleq(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpnleq<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnleq(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpnleq<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnleq(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpnleub<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnleub(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpnleub<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnleub(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpnleub<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnleub(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpnleud<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnleud(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpnleud<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnleud(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpnleud<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnleud(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpnleuq<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnleuq(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpnleuq<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnleuq(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpnleuq<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnleuq(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpnleuw<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnleuw(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpnleuw<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnleuw(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpnleuw<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnleuw(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpnlew<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnlew(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpnlew<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnlew(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpnlew<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnlew(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpnltb<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnltb(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpnltb<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnltb(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpnltb<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnltb(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpnltd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnltd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpnltd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnltd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpnltd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnltd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpnltq<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnltq(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpnltq<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnltq(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpnltq<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnltq(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpnltub<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnltub(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpnltub<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnltub(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpnltub<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnltub(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpnltud<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnltud(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpnltud<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnltud(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpnltud<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnltud(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpnltuq<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnltuq(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpnltuq<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnltuq(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpnltuq<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnltuq(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpnltuw<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnltuw(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpnltuw<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnltuw(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpnltuw<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnltuw(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpnltw<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnltw(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpnltw<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnltw(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpnltw<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnltw(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpq<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpcmpq(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVpcmpq<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpcmpq(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVpcmpq<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpcmpq(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVpcmpq<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpcmpq(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVpcmpq<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpcmpq(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVpcmpq<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpcmpq(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVpcmptrueb<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmptrueb(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmptrueb<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmptrueb(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmptrueb<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmptrueb(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmptrued<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmptrued(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmptrued<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmptrued(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmptrued<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmptrued(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmptrueq<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmptrueq(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmptrueq<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmptrueq(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmptrueq<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmptrueq(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmptrueub<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmptrueub(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmptrueub<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmptrueub(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmptrueub<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmptrueub(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmptrueud<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmptrueud(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmptrueud<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmptrueud(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmptrueud<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmptrueud(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmptrueuq<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmptrueuq(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmptrueuq<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmptrueuq(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmptrueuq<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmptrueuq(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmptrueuw<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmptrueuw(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmptrueuw<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmptrueuw(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmptrueuw<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmptrueuw(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmptruew<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmptruew(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmptruew<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmptruew(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmptruew<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmptruew(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcmpub<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpcmpub(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVpcmpub<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpcmpub(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVpcmpub<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpcmpub(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVpcmpub<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpcmpub(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVpcmpub<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpcmpub(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVpcmpub<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpcmpub(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVpcmpud<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpcmpud(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVpcmpud<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpcmpud(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVpcmpud<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpcmpud(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVpcmpud<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpcmpud(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVpcmpud<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpcmpud(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVpcmpud<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpcmpud(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVpcmpuq<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpcmpuq(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVpcmpuq<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpcmpuq(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVpcmpuq<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpcmpuq(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVpcmpuq<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpcmpuq(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVpcmpuq<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpcmpuq(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVpcmpuq<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpcmpuq(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVpcmpuw<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpcmpuw(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVpcmpuw<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpcmpuw(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVpcmpuw<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpcmpuw(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVpcmpuw<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpcmpuw(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVpcmpuw<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpcmpuw(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVpcmpuw<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpcmpuw(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVpcmpw<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpcmpw(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVpcmpw<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpcmpw(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVpcmpw<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpcmpw(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVpcmpw<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpcmpw(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVpcmpw<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpcmpw(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVpcmpw<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpcmpw(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVpcomb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpcomb(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVpcomb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpcomb(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVpcomd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpcomd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVpcomd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpcomd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVpcomeqb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomeqb(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcomeqd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomeqd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcomeqq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomeqq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcomequb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomequb(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcomequd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomequd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcomequq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomequq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcomequw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomequw(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcomeqw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomeqw(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcomfalseb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomfalseb(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcomfalsed<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomfalsed(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcomfalseq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomfalseq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcomfalseub<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomfalseub(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcomfalseud<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomfalseud(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcomfalseuq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomfalseuq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcomfalseuw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomfalseuw(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcomfalsew<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomfalsew(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcomgeb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomgeb(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcomged<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomged(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcomgeq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomgeq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcomgeub<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomgeub(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcomgeud<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomgeud(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcomgeuq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomgeuq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcomgeuw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomgeuw(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcomgew<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomgew(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcomgtb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomgtb(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcomgtd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomgtd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcomgtq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomgtq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcomgtub<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomgtub(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcomgtud<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomgtud(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcomgtuq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomgtuq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcomgtuw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomgtuw(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcomgtw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomgtw(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcomleb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomleb(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcomled<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomled(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcomleq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomleq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcomleub<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomleub(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcomleud<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomleud(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcomleuq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomleuq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcomleuw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomleuw(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcomlew<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomlew(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcomltb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomltb(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcomltd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomltd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcomltq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomltq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcomltub<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomltub(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcomltud<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomltud(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcomltuq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomltuq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcomltuw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomltuw(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcomltw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomltw(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcomneqb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomneqb(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcomneqd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomneqd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcomneqq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomneqq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcomnequb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomnequb(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcomnequd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomnequd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcomnequq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomnequq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcomnequw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomnequw(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcomneqw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomneqw(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcompressb<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpcompressb(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterXmm
) -> Result<(), IcedError>

impl CodeAsmVpcompressb<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vpcompressb(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterYmm
) -> Result<(), IcedError>

impl CodeAsmVpcompressb<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

fn vpcompressb(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterZmm
) -> Result<(), IcedError>

impl CodeAsmVpcompressd<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpcompressd(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterXmm
) -> Result<(), IcedError>

impl CodeAsmVpcompressd<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vpcompressd(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterYmm
) -> Result<(), IcedError>

impl CodeAsmVpcompressd<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

fn vpcompressd(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterZmm
) -> Result<(), IcedError>

impl CodeAsmVpcompressq<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpcompressq(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterXmm
) -> Result<(), IcedError>

impl CodeAsmVpcompressq<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vpcompressq(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterYmm
) -> Result<(), IcedError>

impl CodeAsmVpcompressq<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

fn vpcompressq(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterZmm
) -> Result<(), IcedError>

impl CodeAsmVpcompressw<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpcompressw(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterXmm
) -> Result<(), IcedError>

impl CodeAsmVpcompressw<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vpcompressw(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterYmm
) -> Result<(), IcedError>

impl CodeAsmVpcompressw<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

fn vpcompressw(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterZmm
) -> Result<(), IcedError>

impl CodeAsmVpcomq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpcomq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVpcomq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpcomq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVpcomtrueb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomtrueb(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcomtrued<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomtrued(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcomtrueq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomtrueq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcomtrueub<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomtrueub(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcomtrueud<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomtrueud(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcomtrueuq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomtrueuq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcomtrueuw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomtrueuw(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcomtruew<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomtruew(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpcomub<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpcomub(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVpcomub<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpcomub(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVpcomud<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpcomud(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVpcomud<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpcomud(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVpcomuq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpcomuq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVpcomuq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpcomuq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVpcomuw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpcomuw(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVpcomuw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpcomuw(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVpcomw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpcomw(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVpcomw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpcomw(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVpconflictd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpconflictd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpconflictd<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpconflictd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpconflictd<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpconflictd(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpconflictq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpconflictq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpconflictq<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpconflictq(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpconflictq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpconflictq(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpdpbusd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpdpbusd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpdpbusd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpdpbusd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpdpbusd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpdpbusd(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpdpbusds<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpdpbusds(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpdpbusds<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpdpbusds(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpdpbusds<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpdpbusds(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpdpwssd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpdpwssd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpdpwssd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpdpwssd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpdpwssd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpdpwssd(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpdpwssds<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpdpwssds(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpdpwssds<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpdpwssds(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpdpwssds<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpdpwssds(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVperm2f128<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vperm2f128(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVperm2f128<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vperm2f128(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVperm2i128<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vperm2i128(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVperm2i128<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vperm2i128(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVpermb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpermb(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpermb<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpermb(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpermb<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpermb(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpermd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpermd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpermd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpermd(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpermi2b<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpermi2b(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpermi2b<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpermi2b(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpermi2b<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpermi2b(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpermi2d<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpermi2d(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpermi2d<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpermi2d(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpermi2d<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpermi2d(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpermi2pd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpermi2pd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpermi2pd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpermi2pd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpermi2pd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpermi2pd(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpermi2ps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpermi2ps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpermi2ps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpermi2ps(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpermi2ps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpermi2ps(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpermi2q<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpermi2q(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpermi2q<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpermi2q(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpermi2q<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpermi2q(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpermi2w<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpermi2w(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpermi2w<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpermi2w(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpermi2w<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpermi2w(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpermil2pd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm, i32> for CodeAssembler

fn vpermil2pd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: AsmRegisterXmm,
    op4: i32
) -> Result<(), IcedError>

impl CodeAsmVpermil2pd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm, u32> for CodeAssembler

fn vpermil2pd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: AsmRegisterXmm,
    op4: u32
) -> Result<(), IcedError>

impl CodeAsmVpermil2pd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpermil2pd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmRegisterXmm,
    op3: AsmMemoryOperand,
    op4: i32
) -> Result<(), IcedError>

impl CodeAsmVpermil2pd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpermil2pd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmRegisterXmm,
    op3: AsmMemoryOperand,
    op4: u32
) -> Result<(), IcedError>

impl CodeAsmVpermil2pd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, AsmRegisterYmm, i32> for CodeAssembler

fn vpermil2pd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand,
    op3: AsmRegisterYmm,
    op4: i32
) -> Result<(), IcedError>

impl CodeAsmVpermil2pd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, AsmRegisterYmm, u32> for CodeAssembler

fn vpermil2pd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand,
    op3: AsmRegisterYmm,
    op4: u32
) -> Result<(), IcedError>

impl CodeAsmVpermil2pd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpermil2pd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmRegisterYmm,
    op3: AsmMemoryOperand,
    op4: i32
) -> Result<(), IcedError>

impl CodeAsmVpermil2pd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpermil2pd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmRegisterYmm,
    op3: AsmMemoryOperand,
    op4: u32
) -> Result<(), IcedError>

impl CodeAsmVpermil2ps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm, i32> for CodeAssembler

fn vpermil2ps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: AsmRegisterXmm,
    op4: i32
) -> Result<(), IcedError>

impl CodeAsmVpermil2ps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm, u32> for CodeAssembler

fn vpermil2ps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: AsmRegisterXmm,
    op4: u32
) -> Result<(), IcedError>

impl CodeAsmVpermil2ps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpermil2ps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmRegisterXmm,
    op3: AsmMemoryOperand,
    op4: i32
) -> Result<(), IcedError>

impl CodeAsmVpermil2ps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpermil2ps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmRegisterXmm,
    op3: AsmMemoryOperand,
    op4: u32
) -> Result<(), IcedError>

impl CodeAsmVpermil2ps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, AsmRegisterYmm, i32> for CodeAssembler

fn vpermil2ps(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand,
    op3: AsmRegisterYmm,
    op4: i32
) -> Result<(), IcedError>

impl CodeAsmVpermil2ps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, AsmRegisterYmm, u32> for CodeAssembler

fn vpermil2ps(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand,
    op3: AsmRegisterYmm,
    op4: u32
) -> Result<(), IcedError>

impl CodeAsmVpermil2ps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpermil2ps(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmRegisterYmm,
    op3: AsmMemoryOperand,
    op4: i32
) -> Result<(), IcedError>

impl CodeAsmVpermil2ps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpermil2ps(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmRegisterYmm,
    op3: AsmMemoryOperand,
    op4: u32
) -> Result<(), IcedError>

impl CodeAsmVpermilpd<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpermilpd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmVpermilpd<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpermilpd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmVpermilpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpermilpd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpermilpd<AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpermilpd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmVpermilpd<AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpermilpd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmVpermilpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpermilpd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpermilpd<AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpermilpd(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmVpermilpd<AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpermilpd(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmVpermilpd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpermilpd(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpermilps<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpermilps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmVpermilps<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpermilps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmVpermilps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpermilps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpermilps<AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpermilps(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmVpermilps<AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpermilps(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmVpermilps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpermilps(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpermilps<AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpermilps(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmVpermilps<AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpermilps(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmVpermilps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpermilps(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpermpd<AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpermpd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmVpermpd<AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpermpd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmVpermpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpermpd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpermpd<AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpermpd(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmVpermpd<AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpermpd(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmVpermpd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpermpd(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpermps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpermps(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpermps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpermps(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpermq<AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpermq(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmVpermq<AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpermq(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmVpermq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpermq(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpermq<AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpermq(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmVpermq<AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpermq(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmVpermq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpermq(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpermt2b<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpermt2b(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpermt2b<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpermt2b(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpermt2b<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpermt2b(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpermt2d<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpermt2d(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpermt2d<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpermt2d(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpermt2d<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpermt2d(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpermt2pd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpermt2pd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpermt2pd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpermt2pd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpermt2pd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpermt2pd(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpermt2ps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpermt2ps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpermt2ps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpermt2ps(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpermt2ps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpermt2ps(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpermt2q<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpermt2q(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpermt2q<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpermt2q(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpermt2q<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpermt2q(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpermt2w<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpermt2w(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpermt2w<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpermt2w(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpermt2w<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpermt2w(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpermw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpermw(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpermw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpermw(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpermw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpermw(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpexpandb<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpexpandb(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpexpandb<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpexpandb(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpexpandb<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpexpandb(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpexpandd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpexpandd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpexpandd<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpexpandd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpexpandd<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpexpandd(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpexpandq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpexpandq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpexpandq<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpexpandq(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpexpandq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpexpandq(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpexpandw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpexpandw(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpexpandw<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpexpandw(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpexpandw<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpexpandw(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpextrb<AsmMemoryOperand, AsmRegisterXmm, i32> for CodeAssembler

fn vpextrb(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterXmm,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmVpextrb<AsmMemoryOperand, AsmRegisterXmm, u32> for CodeAssembler

fn vpextrb(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterXmm,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmVpextrd<AsmMemoryOperand, AsmRegisterXmm, i32> for CodeAssembler

fn vpextrd(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterXmm,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmVpextrd<AsmMemoryOperand, AsmRegisterXmm, u32> for CodeAssembler

fn vpextrd(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterXmm,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmVpextrq<AsmMemoryOperand, AsmRegisterXmm, i32> for CodeAssembler

fn vpextrq(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterXmm,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmVpextrq<AsmMemoryOperand, AsmRegisterXmm, u32> for CodeAssembler

fn vpextrq(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterXmm,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmVpextrw<AsmMemoryOperand, AsmRegisterXmm, i32> for CodeAssembler

fn vpextrw(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterXmm,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmVpextrw<AsmMemoryOperand, AsmRegisterXmm, u32> for CodeAssembler

fn vpextrw(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterXmm,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmVpgatherdd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpgatherdd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpgatherdd<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpgatherdd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpgatherdd<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpgatherdd(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpgatherdd3<AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpgatherdd_3(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: AsmRegisterXmm
) -> Result<(), IcedError>

impl CodeAsmVpgatherdd3<AsmRegisterYmm, AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vpgatherdd_3(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand,
    op2: AsmRegisterYmm
) -> Result<(), IcedError>

impl CodeAsmVpgatherdq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpgatherdq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpgatherdq<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpgatherdq(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpgatherdq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpgatherdq(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpgatherdq3<AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpgatherdq_3(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: AsmRegisterXmm
) -> Result<(), IcedError>

impl CodeAsmVpgatherdq3<AsmRegisterYmm, AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vpgatherdq_3(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand,
    op2: AsmRegisterYmm
) -> Result<(), IcedError>

impl CodeAsmVpgatherqd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpgatherqd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpgatherqd<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpgatherqd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpgatherqd3<AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpgatherqd_3(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: AsmRegisterXmm
) -> Result<(), IcedError>

impl CodeAsmVpgatherqq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpgatherqq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpgatherqq<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpgatherqq(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpgatherqq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpgatherqq(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpgatherqq3<AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpgatherqq_3(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: AsmRegisterXmm
) -> Result<(), IcedError>

impl CodeAsmVpgatherqq3<AsmRegisterYmm, AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vpgatherqq_3(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand,
    op2: AsmRegisterYmm
) -> Result<(), IcedError>

impl CodeAsmVphaddbd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vphaddbd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVphaddbq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vphaddbq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVphaddbw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vphaddbw(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVphaddd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vphaddd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVphaddd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vphaddd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVphadddq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vphadddq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVphaddsw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vphaddsw(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVphaddsw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vphaddsw(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVphaddubd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vphaddubd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVphaddubq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vphaddubq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVphaddubw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vphaddubw(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVphaddudq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vphaddudq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVphadduwd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vphadduwd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVphadduwq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vphadduwq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVphaddw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vphaddw(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVphaddw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vphaddw(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVphaddwd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vphaddwd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVphaddwq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vphaddwq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVphminposuw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vphminposuw(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVphsubbw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vphsubbw(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVphsubd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vphsubd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVphsubd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vphsubd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVphsubdq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vphsubdq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVphsubsw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vphsubsw(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVphsubsw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vphsubsw(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVphsubw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vphsubw(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVphsubw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vphsubw(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVphsubwd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vphsubwd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpinsrb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpinsrb(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVpinsrb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpinsrb(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVpinsrd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpinsrd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVpinsrd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpinsrd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVpinsrq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpinsrq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVpinsrq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpinsrq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVpinsrw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpinsrw(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVpinsrw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpinsrw(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVplzcntd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vplzcntd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVplzcntd<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vplzcntd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVplzcntd<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vplzcntd(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVplzcntq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vplzcntq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVplzcntq<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vplzcntq(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVplzcntq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vplzcntq(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpmacsdd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpmacsdd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: AsmRegisterXmm
) -> Result<(), IcedError>

impl CodeAsmVpmacsdqh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpmacsdqh(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: AsmRegisterXmm
) -> Result<(), IcedError>

impl CodeAsmVpmacsdql<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpmacsdql(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: AsmRegisterXmm
) -> Result<(), IcedError>

impl CodeAsmVpmacssdd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpmacssdd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: AsmRegisterXmm
) -> Result<(), IcedError>

impl CodeAsmVpmacssdqh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpmacssdqh(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: AsmRegisterXmm
) -> Result<(), IcedError>

impl CodeAsmVpmacssdql<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpmacssdql(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: AsmRegisterXmm
) -> Result<(), IcedError>

impl CodeAsmVpmacsswd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpmacsswd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: AsmRegisterXmm
) -> Result<(), IcedError>

impl CodeAsmVpmacssww<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpmacssww(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: AsmRegisterXmm
) -> Result<(), IcedError>

impl CodeAsmVpmacswd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpmacswd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: AsmRegisterXmm
) -> Result<(), IcedError>

impl CodeAsmVpmacsww<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpmacsww(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: AsmRegisterXmm
) -> Result<(), IcedError>

impl CodeAsmVpmadcsswd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpmadcsswd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: AsmRegisterXmm
) -> Result<(), IcedError>

impl CodeAsmVpmadcswd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpmadcswd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: AsmRegisterXmm
) -> Result<(), IcedError>

impl CodeAsmVpmadd52huq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpmadd52huq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpmadd52huq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpmadd52huq(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpmadd52huq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpmadd52huq(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpmadd52luq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpmadd52luq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpmadd52luq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpmadd52luq(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpmadd52luq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpmadd52luq(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpmaddubsw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpmaddubsw(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpmaddubsw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpmaddubsw(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpmaddubsw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpmaddubsw(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpmaddwd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpmaddwd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpmaddwd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpmaddwd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpmaddwd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpmaddwd(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpmaskmovd<AsmMemoryOperand, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpmaskmovd(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterXmm,
    op2: AsmRegisterXmm
) -> Result<(), IcedError>

impl CodeAsmVpmaskmovd<AsmMemoryOperand, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpmaskmovd(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterYmm,
    op2: AsmRegisterYmm
) -> Result<(), IcedError>

impl CodeAsmVpmaskmovd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpmaskmovd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpmaskmovd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpmaskmovd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpmaskmovq<AsmMemoryOperand, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpmaskmovq(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterXmm,
    op2: AsmRegisterXmm
) -> Result<(), IcedError>

impl CodeAsmVpmaskmovq<AsmMemoryOperand, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpmaskmovq(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterYmm,
    op2: AsmRegisterYmm
) -> Result<(), IcedError>

impl CodeAsmVpmaskmovq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpmaskmovq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpmaskmovq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpmaskmovq(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpmaxsb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpmaxsb(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpmaxsb<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpmaxsb(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpmaxsb<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpmaxsb(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpmaxsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpmaxsd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpmaxsd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpmaxsd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpmaxsd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpmaxsd(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpmaxsq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpmaxsq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpmaxsq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpmaxsq(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpmaxsq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpmaxsq(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpmaxsw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpmaxsw(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpmaxsw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpmaxsw(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpmaxsw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpmaxsw(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpmaxub<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpmaxub(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpmaxub<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpmaxub(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpmaxub<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpmaxub(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpmaxud<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpmaxud(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpmaxud<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpmaxud(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpmaxud<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpmaxud(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpmaxuq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpmaxuq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpmaxuq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpmaxuq(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpmaxuq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpmaxuq(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpmaxuw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpmaxuw(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpmaxuw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpmaxuw(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpmaxuw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpmaxuw(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpminsb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpminsb(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpminsb<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpminsb(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpminsb<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpminsb(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpminsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpminsd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpminsd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpminsd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpminsd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpminsd(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpminsq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpminsq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpminsq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpminsq(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpminsq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpminsq(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpminsw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpminsw(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpminsw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpminsw(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpminsw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpminsw(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpminub<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpminub(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpminub<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpminub(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpminub<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpminub(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpminud<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpminud(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpminud<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpminud(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpminud<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpminud(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpminuq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpminuq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpminuq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpminuq(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpminuq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpminuq(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpminuw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpminuw(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpminuw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpminuw(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpminuw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpminuw(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpmovdb<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpmovdb(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterXmm
) -> Result<(), IcedError>

impl CodeAsmVpmovdb<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vpmovdb(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterYmm
) -> Result<(), IcedError>

impl CodeAsmVpmovdb<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

fn vpmovdb(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterZmm
) -> Result<(), IcedError>

impl CodeAsmVpmovdw<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpmovdw(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterXmm
) -> Result<(), IcedError>

impl CodeAsmVpmovdw<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vpmovdw(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterYmm
) -> Result<(), IcedError>

impl CodeAsmVpmovdw<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

fn vpmovdw(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterZmm
) -> Result<(), IcedError>

impl CodeAsmVpmovqb<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpmovqb(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterXmm
) -> Result<(), IcedError>

impl CodeAsmVpmovqb<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vpmovqb(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterYmm
) -> Result<(), IcedError>

impl CodeAsmVpmovqb<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

fn vpmovqb(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterZmm
) -> Result<(), IcedError>

impl CodeAsmVpmovqd<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpmovqd(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterXmm
) -> Result<(), IcedError>

impl CodeAsmVpmovqd<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vpmovqd(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterYmm
) -> Result<(), IcedError>

impl CodeAsmVpmovqd<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

fn vpmovqd(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterZmm
) -> Result<(), IcedError>

impl CodeAsmVpmovqw<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpmovqw(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterXmm
) -> Result<(), IcedError>

impl CodeAsmVpmovqw<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vpmovqw(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterYmm
) -> Result<(), IcedError>

impl CodeAsmVpmovqw<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

fn vpmovqw(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterZmm
) -> Result<(), IcedError>

impl CodeAsmVpmovsdb<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpmovsdb(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterXmm
) -> Result<(), IcedError>

impl CodeAsmVpmovsdb<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vpmovsdb(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterYmm
) -> Result<(), IcedError>

impl CodeAsmVpmovsdb<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

fn vpmovsdb(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterZmm
) -> Result<(), IcedError>

impl CodeAsmVpmovsdw<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpmovsdw(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterXmm
) -> Result<(), IcedError>

impl CodeAsmVpmovsdw<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vpmovsdw(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterYmm
) -> Result<(), IcedError>

impl CodeAsmVpmovsdw<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

fn vpmovsdw(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterZmm
) -> Result<(), IcedError>

impl CodeAsmVpmovsqb<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpmovsqb(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterXmm
) -> Result<(), IcedError>

impl CodeAsmVpmovsqb<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vpmovsqb(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterYmm
) -> Result<(), IcedError>

impl CodeAsmVpmovsqb<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

fn vpmovsqb(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterZmm
) -> Result<(), IcedError>

impl CodeAsmVpmovsqd<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpmovsqd(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterXmm
) -> Result<(), IcedError>

impl CodeAsmVpmovsqd<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vpmovsqd(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterYmm
) -> Result<(), IcedError>

impl CodeAsmVpmovsqd<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

fn vpmovsqd(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterZmm
) -> Result<(), IcedError>

impl CodeAsmVpmovsqw<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpmovsqw(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterXmm
) -> Result<(), IcedError>

impl CodeAsmVpmovsqw<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vpmovsqw(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterYmm
) -> Result<(), IcedError>

impl CodeAsmVpmovsqw<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

fn vpmovsqw(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterZmm
) -> Result<(), IcedError>

impl CodeAsmVpmovswb<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpmovswb(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterXmm
) -> Result<(), IcedError>

impl CodeAsmVpmovswb<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vpmovswb(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterYmm
) -> Result<(), IcedError>

impl CodeAsmVpmovswb<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

fn vpmovswb(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterZmm
) -> Result<(), IcedError>

impl CodeAsmVpmovsxbd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpmovsxbd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpmovsxbd<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpmovsxbd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpmovsxbd<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpmovsxbd(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpmovsxbq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpmovsxbq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpmovsxbq<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpmovsxbq(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpmovsxbq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpmovsxbq(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpmovsxbw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpmovsxbw(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpmovsxbw<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpmovsxbw(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpmovsxbw<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpmovsxbw(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpmovsxdq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpmovsxdq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpmovsxdq<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpmovsxdq(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpmovsxdq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpmovsxdq(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpmovsxwd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpmovsxwd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpmovsxwd<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpmovsxwd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpmovsxwd<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpmovsxwd(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpmovsxwq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpmovsxwq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpmovsxwq<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpmovsxwq(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpmovsxwq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpmovsxwq(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpmovusdb<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpmovusdb(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterXmm
) -> Result<(), IcedError>

impl CodeAsmVpmovusdb<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vpmovusdb(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterYmm
) -> Result<(), IcedError>

impl CodeAsmVpmovusdb<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

fn vpmovusdb(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterZmm
) -> Result<(), IcedError>

impl CodeAsmVpmovusdw<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpmovusdw(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterXmm
) -> Result<(), IcedError>

impl CodeAsmVpmovusdw<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vpmovusdw(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterYmm
) -> Result<(), IcedError>

impl CodeAsmVpmovusdw<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

fn vpmovusdw(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterZmm
) -> Result<(), IcedError>

impl CodeAsmVpmovusqb<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpmovusqb(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterXmm
) -> Result<(), IcedError>

impl CodeAsmVpmovusqb<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vpmovusqb(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterYmm
) -> Result<(), IcedError>

impl CodeAsmVpmovusqb<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

fn vpmovusqb(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterZmm
) -> Result<(), IcedError>

impl CodeAsmVpmovusqd<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpmovusqd(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterXmm
) -> Result<(), IcedError>

impl CodeAsmVpmovusqd<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vpmovusqd(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterYmm
) -> Result<(), IcedError>

impl CodeAsmVpmovusqd<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

fn vpmovusqd(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterZmm
) -> Result<(), IcedError>

impl CodeAsmVpmovusqw<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpmovusqw(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterXmm
) -> Result<(), IcedError>

impl CodeAsmVpmovusqw<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vpmovusqw(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterYmm
) -> Result<(), IcedError>

impl CodeAsmVpmovusqw<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

fn vpmovusqw(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterZmm
) -> Result<(), IcedError>

impl CodeAsmVpmovuswb<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpmovuswb(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterXmm
) -> Result<(), IcedError>

impl CodeAsmVpmovuswb<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vpmovuswb(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterYmm
) -> Result<(), IcedError>

impl CodeAsmVpmovuswb<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

fn vpmovuswb(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterZmm
) -> Result<(), IcedError>

impl CodeAsmVpmovwb<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpmovwb(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterXmm
) -> Result<(), IcedError>

impl CodeAsmVpmovwb<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vpmovwb(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterYmm
) -> Result<(), IcedError>

impl CodeAsmVpmovwb<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

fn vpmovwb(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterZmm
) -> Result<(), IcedError>

impl CodeAsmVpmovzxbd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpmovzxbd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpmovzxbd<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpmovzxbd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpmovzxbd<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpmovzxbd(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpmovzxbq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpmovzxbq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpmovzxbq<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpmovzxbq(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpmovzxbq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpmovzxbq(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpmovzxbw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpmovzxbw(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpmovzxbw<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpmovzxbw(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpmovzxbw<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpmovzxbw(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpmovzxdq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpmovzxdq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpmovzxdq<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpmovzxdq(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpmovzxdq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpmovzxdq(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpmovzxwd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpmovzxwd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpmovzxwd<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpmovzxwd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpmovzxwd<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpmovzxwd(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpmovzxwq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpmovzxwq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpmovzxwq<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpmovzxwq(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpmovzxwq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpmovzxwq(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpmuldq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpmuldq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpmuldq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpmuldq(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpmuldq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpmuldq(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpmulhrsw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpmulhrsw(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpmulhrsw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpmulhrsw(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpmulhrsw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpmulhrsw(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpmulhuw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpmulhuw(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpmulhuw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpmulhuw(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpmulhuw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpmulhuw(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpmulhw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpmulhw(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpmulhw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpmulhw(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpmulhw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpmulhw(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpmulld<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpmulld(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpmulld<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpmulld(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpmulld<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpmulld(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpmullq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpmullq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpmullq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpmullq(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpmullq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpmullq(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpmullw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpmullw(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpmullw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpmullw(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpmullw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpmullw(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpmultishiftqb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpmultishiftqb(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpmultishiftqb<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpmultishiftqb(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpmultishiftqb<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpmultishiftqb(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpmuludq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpmuludq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpmuludq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpmuludq(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpmuludq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpmuludq(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpopcntb<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpopcntb(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpopcntb<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpopcntb(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpopcntb<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpopcntb(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpopcntd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpopcntd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpopcntd<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpopcntd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpopcntd<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpopcntd(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpopcntq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpopcntq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpopcntq<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpopcntq(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpopcntq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpopcntq(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpopcntw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpopcntw(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpopcntw<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpopcntw(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpopcntw<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpopcntw(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpor<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpor(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpor<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpor(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpord<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpord(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpord<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpord(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpord<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpord(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVporq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vporq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVporq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vporq(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVporq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vporq(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpperm<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpperm(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: AsmRegisterXmm
) -> Result<(), IcedError>

impl CodeAsmVpperm<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpperm(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmRegisterXmm,
    op3: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVprold<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vprold(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmVprold<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vprold(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmVprold<AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vprold(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmVprold<AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vprold(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmVprold<AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vprold(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmVprold<AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vprold(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmVprolq<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vprolq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmVprolq<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vprolq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmVprolq<AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vprolq(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmVprolq<AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vprolq(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmVprolq<AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vprolq(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmVprolq<AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vprolq(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmVprolvd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vprolvd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVprolvd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vprolvd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVprolvd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vprolvd(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVprolvq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vprolvq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVprolvq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vprolvq(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVprolvq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vprolvq(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVprord<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vprord(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmVprord<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vprord(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmVprord<AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vprord(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmVprord<AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vprord(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmVprord<AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vprord(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmVprord<AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vprord(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmVprorq<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vprorq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmVprorq<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vprorq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmVprorq<AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vprorq(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmVprorq<AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vprorq(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmVprorq<AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vprorq(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmVprorq<AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vprorq(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmVprorvd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vprorvd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVprorvd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vprorvd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVprorvd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vprorvd(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVprorvq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vprorvq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVprorvq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vprorvq(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVprorvq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vprorvq(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVprotb<AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vprotb(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: AsmRegisterXmm
) -> Result<(), IcedError>

impl CodeAsmVprotb<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vprotb(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmVprotb<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vprotb(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmVprotb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vprotb(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVprotd<AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vprotd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: AsmRegisterXmm
) -> Result<(), IcedError>

impl CodeAsmVprotd<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vprotd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmVprotd<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vprotd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmVprotd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vprotd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVprotq<AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vprotq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: AsmRegisterXmm
) -> Result<(), IcedError>

impl CodeAsmVprotq<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vprotq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmVprotq<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vprotq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmVprotq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vprotq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVprotw<AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vprotw(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: AsmRegisterXmm
) -> Result<(), IcedError>

impl CodeAsmVprotw<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vprotw(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmVprotw<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vprotw(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmVprotw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vprotw(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpsadbw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpsadbw(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpsadbw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpsadbw(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpsadbw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpsadbw(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpscatterdd<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpscatterdd(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterXmm
) -> Result<(), IcedError>

impl CodeAsmVpscatterdd<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vpscatterdd(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterYmm
) -> Result<(), IcedError>

impl CodeAsmVpscatterdd<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

fn vpscatterdd(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterZmm
) -> Result<(), IcedError>

impl CodeAsmVpscatterdq<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpscatterdq(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterXmm
) -> Result<(), IcedError>

impl CodeAsmVpscatterdq<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vpscatterdq(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterYmm
) -> Result<(), IcedError>

impl CodeAsmVpscatterdq<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

fn vpscatterdq(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterZmm
) -> Result<(), IcedError>

impl CodeAsmVpscatterqd<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpscatterqd(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterXmm
) -> Result<(), IcedError>

impl CodeAsmVpscatterqd<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vpscatterqd(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterYmm
) -> Result<(), IcedError>

impl CodeAsmVpscatterqq<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpscatterqq(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterXmm
) -> Result<(), IcedError>

impl CodeAsmVpscatterqq<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vpscatterqq(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterYmm
) -> Result<(), IcedError>

impl CodeAsmVpscatterqq<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

fn vpscatterqq(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterZmm
) -> Result<(), IcedError>

impl CodeAsmVpshab<AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpshab(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: AsmRegisterXmm
) -> Result<(), IcedError>

impl CodeAsmVpshab<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpshab(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpshad<AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpshad(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: AsmRegisterXmm
) -> Result<(), IcedError>

impl CodeAsmVpshad<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpshad(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpshaq<AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpshaq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: AsmRegisterXmm
) -> Result<(), IcedError>

impl CodeAsmVpshaq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpshaq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpshaw<AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpshaw(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: AsmRegisterXmm
) -> Result<(), IcedError>

impl CodeAsmVpshaw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpshaw(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpshlb<AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpshlb(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: AsmRegisterXmm
) -> Result<(), IcedError>

impl CodeAsmVpshlb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpshlb(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpshld<AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpshld(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: AsmRegisterXmm
) -> Result<(), IcedError>

impl CodeAsmVpshld<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpshld(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpshldd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpshldd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVpshldd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpshldd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVpshldd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpshldd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVpshldd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpshldd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVpshldd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpshldd(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVpshldd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpshldd(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVpshldq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpshldq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVpshldq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpshldq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVpshldq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpshldq(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVpshldq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpshldq(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVpshldq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpshldq(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVpshldq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpshldq(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVpshldvd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpshldvd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpshldvd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpshldvd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpshldvd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpshldvd(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpshldvq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpshldvq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpshldvq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpshldvq(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpshldvq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpshldvq(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpshldvw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpshldvw(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpshldvw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpshldvw(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpshldvw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpshldvw(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpshldw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpshldw(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVpshldw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpshldw(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVpshldw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpshldw(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVpshldw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpshldw(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVpshldw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpshldw(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVpshldw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpshldw(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVpshlq<AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpshlq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: AsmRegisterXmm
) -> Result<(), IcedError>

impl CodeAsmVpshlq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpshlq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpshlw<AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpshlw(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: AsmRegisterXmm
) -> Result<(), IcedError>

impl CodeAsmVpshlw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpshlw(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpshrdd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpshrdd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVpshrdd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpshrdd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVpshrdd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpshrdd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVpshrdd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpshrdd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVpshrdd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpshrdd(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVpshrdd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpshrdd(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVpshrdq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpshrdq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVpshrdq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpshrdq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVpshrdq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpshrdq(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVpshrdq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpshrdq(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVpshrdq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpshrdq(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVpshrdq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpshrdq(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVpshrdvd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpshrdvd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpshrdvd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpshrdvd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpshrdvd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpshrdvd(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpshrdvq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpshrdvq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpshrdvq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpshrdvq(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpshrdvq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpshrdvq(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpshrdvw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpshrdvw(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpshrdvw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpshrdvw(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpshrdvw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpshrdvw(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpshrdw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpshrdw(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVpshrdw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpshrdw(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVpshrdw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpshrdw(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVpshrdw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpshrdw(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVpshrdw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpshrdw(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVpshrdw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpshrdw(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVpshufb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpshufb(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpshufb<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpshufb(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpshufb<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpshufb(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpshufbitqmb<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpshufbitqmb(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpshufbitqmb<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpshufbitqmb(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpshufbitqmb<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpshufbitqmb(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpshufd<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpshufd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmVpshufd<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpshufd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmVpshufd<AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpshufd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmVpshufd<AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpshufd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmVpshufd<AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpshufd(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmVpshufd<AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpshufd(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmVpshufhw<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpshufhw(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmVpshufhw<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpshufhw(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmVpshufhw<AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpshufhw(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmVpshufhw<AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpshufhw(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmVpshufhw<AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpshufhw(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmVpshufhw<AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpshufhw(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmVpshuflw<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpshuflw(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmVpshuflw<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpshuflw(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmVpshuflw<AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpshuflw(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmVpshuflw<AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpshuflw(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmVpshuflw<AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpshuflw(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmVpshuflw<AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpshuflw(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmVpsignb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpsignb(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpsignb<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpsignb(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpsignd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpsignd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpsignd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpsignd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpsignw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpsignw(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpsignw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpsignw(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpslld<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpslld(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmVpslld<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpslld(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmVpslld<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpslld(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpslld<AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpslld(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmVpslld<AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpslld(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmVpslld<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpslld(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpslld<AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpslld(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmVpslld<AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpslld(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmVpslld<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpslld(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpslldq<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpslldq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmVpslldq<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpslldq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmVpslldq<AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpslldq(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmVpslldq<AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpslldq(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmVpslldq<AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpslldq(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmVpslldq<AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpslldq(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmVpsllq<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpsllq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmVpsllq<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpsllq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmVpsllq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpsllq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpsllq<AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpsllq(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmVpsllq<AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpsllq(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmVpsllq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpsllq(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpsllq<AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpsllq(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmVpsllq<AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpsllq(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmVpsllq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpsllq(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpsllvd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpsllvd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpsllvd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpsllvd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpsllvd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpsllvd(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpsllvq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpsllvq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpsllvq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpsllvq(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpsllvq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpsllvq(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpsllvw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpsllvw(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpsllvw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpsllvw(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpsllvw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpsllvw(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpsllw<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpsllw(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmVpsllw<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpsllw(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmVpsllw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpsllw(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpsllw<AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpsllw(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmVpsllw<AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpsllw(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmVpsllw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpsllw(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpsllw<AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpsllw(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmVpsllw<AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpsllw(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmVpsllw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpsllw(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpsrad<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpsrad(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmVpsrad<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpsrad(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmVpsrad<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpsrad(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpsrad<AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpsrad(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmVpsrad<AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpsrad(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmVpsrad<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpsrad(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpsrad<AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpsrad(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmVpsrad<AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpsrad(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmVpsrad<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpsrad(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpsraq<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpsraq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmVpsraq<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpsraq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmVpsraq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpsraq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpsraq<AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpsraq(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmVpsraq<AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpsraq(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmVpsraq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpsraq(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpsraq<AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpsraq(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmVpsraq<AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpsraq(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmVpsraq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpsraq(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpsravd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpsravd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpsravd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpsravd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpsravd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpsravd(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpsravq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpsravq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpsravq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpsravq(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpsravq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpsravq(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpsravw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpsravw(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpsravw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpsravw(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpsravw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpsravw(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpsraw<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpsraw(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmVpsraw<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpsraw(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmVpsraw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpsraw(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpsraw<AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpsraw(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmVpsraw<AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpsraw(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmVpsraw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpsraw(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpsraw<AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpsraw(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmVpsraw<AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpsraw(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmVpsraw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpsraw(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpsrld<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpsrld(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmVpsrld<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpsrld(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmVpsrld<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpsrld(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpsrld<AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpsrld(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmVpsrld<AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpsrld(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmVpsrld<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpsrld(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpsrld<AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpsrld(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmVpsrld<AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpsrld(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmVpsrld<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpsrld(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpsrldq<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpsrldq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmVpsrldq<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpsrldq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmVpsrldq<AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpsrldq(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmVpsrldq<AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpsrldq(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmVpsrldq<AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpsrldq(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmVpsrldq<AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpsrldq(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmVpsrlq<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpsrlq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmVpsrlq<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpsrlq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmVpsrlq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpsrlq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpsrlq<AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpsrlq(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmVpsrlq<AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpsrlq(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmVpsrlq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpsrlq(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpsrlq<AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpsrlq(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmVpsrlq<AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpsrlq(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmVpsrlq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpsrlq(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpsrlvd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpsrlvd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpsrlvd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpsrlvd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpsrlvd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpsrlvd(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpsrlvq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpsrlvq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpsrlvq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpsrlvq(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpsrlvq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpsrlvq(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpsrlvw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpsrlvw(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpsrlvw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpsrlvw(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpsrlvw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpsrlvw(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpsrlw<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpsrlw(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmVpsrlw<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpsrlw(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmVpsrlw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpsrlw(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpsrlw<AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpsrlw(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmVpsrlw<AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpsrlw(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmVpsrlw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpsrlw(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpsrlw<AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpsrlw(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmVpsrlw<AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpsrlw(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmVpsrlw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpsrlw(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpsubb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpsubb(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpsubb<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpsubb(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpsubb<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpsubb(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpsubd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpsubd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpsubd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpsubd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpsubd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpsubd(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpsubq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpsubq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpsubq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpsubq(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpsubq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpsubq(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpsubsb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpsubsb(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpsubsb<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpsubsb(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpsubsb<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpsubsb(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpsubsw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpsubsw(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpsubsw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpsubsw(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpsubsw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpsubsw(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpsubusb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpsubusb(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpsubusb<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpsubusb(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpsubusb<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpsubusb(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpsubusw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpsubusw(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpsubusw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpsubusw(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpsubusw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpsubusw(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpsubw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpsubw(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpsubw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpsubw(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpsubw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpsubw(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpternlogd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpternlogd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVpternlogd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpternlogd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVpternlogd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpternlogd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVpternlogd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpternlogd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVpternlogd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpternlogd(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVpternlogd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpternlogd(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVpternlogq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpternlogq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVpternlogq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpternlogq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVpternlogq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpternlogq(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVpternlogq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpternlogq(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVpternlogq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpternlogq(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVpternlogq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpternlogq(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVptest<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vptest(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVptest<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vptest(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVptestmb<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vptestmb(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVptestmb<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vptestmb(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVptestmb<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vptestmb(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVptestmd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vptestmd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVptestmd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vptestmd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVptestmd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vptestmd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVptestmq<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vptestmq(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVptestmq<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vptestmq(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVptestmq<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vptestmq(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVptestmw<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vptestmw(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVptestmw<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vptestmw(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVptestmw<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vptestmw(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVptestnmb<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vptestnmb(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVptestnmb<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vptestnmb(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVptestnmb<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vptestnmb(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVptestnmd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vptestnmd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVptestnmd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vptestnmd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVptestnmd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vptestnmd(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVptestnmq<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vptestnmq(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVptestnmq<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vptestnmq(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVptestnmq<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vptestnmq(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVptestnmw<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vptestnmw(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVptestnmw<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vptestnmw(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVptestnmw<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vptestnmw(
    &mut self,
    op0: AsmRegisterK,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpunpckhbw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpunpckhbw(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpunpckhbw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpunpckhbw(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpunpckhbw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpunpckhbw(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpunpckhdq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpunpckhdq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpunpckhdq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpunpckhdq(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpunpckhdq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpunpckhdq(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpunpckhqdq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpunpckhqdq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpunpckhqdq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpunpckhqdq(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpunpckhqdq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpunpckhqdq(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpunpckhwd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpunpckhwd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpunpckhwd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpunpckhwd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpunpckhwd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpunpckhwd(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpunpcklbw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpunpcklbw(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpunpcklbw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpunpcklbw(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpunpcklbw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpunpcklbw(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpunpckldq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpunpckldq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpunpckldq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpunpckldq(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpunpckldq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpunpckldq(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpunpcklqdq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpunpcklqdq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpunpcklqdq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpunpcklqdq(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpunpcklqdq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpunpcklqdq(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpunpcklwd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpunpcklwd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpunpcklwd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpunpcklwd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpunpcklwd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpunpcklwd(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpxor<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpxor(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpxor<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpxor(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpxord<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpxord(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpxord<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpxord(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpxord<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpxord(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpxorq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpxorq(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpxorq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpxorq(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVpxorq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpxorq(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVrangepd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vrangepd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVrangepd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vrangepd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVrangepd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vrangepd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVrangepd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vrangepd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVrangepd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vrangepd(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVrangepd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vrangepd(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVrangeps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vrangeps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVrangeps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vrangeps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVrangeps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vrangeps(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVrangeps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vrangeps(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVrangeps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vrangeps(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVrangeps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vrangeps(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVrangesd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vrangesd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVrangesd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vrangesd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVrangess<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vrangess(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVrangess<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vrangess(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVrcp14pd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vrcp14pd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVrcp14pd<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vrcp14pd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVrcp14pd<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vrcp14pd(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVrcp14ps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vrcp14ps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVrcp14ps<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vrcp14ps(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVrcp14ps<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vrcp14ps(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVrcp14sd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vrcp14sd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVrcp14ss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vrcp14ss(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVrcp28pd<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vrcp28pd(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVrcp28ps<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vrcp28ps(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVrcp28sd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vrcp28sd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVrcp28ss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vrcp28ss(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVrcpph<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vrcpph(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVrcpph<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vrcpph(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVrcpph<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vrcpph(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVrcpps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vrcpps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVrcpps<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vrcpps(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVrcpsh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vrcpsh(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVrcpss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vrcpss(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVreducepd<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vreducepd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmVreducepd<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vreducepd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmVreducepd<AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vreducepd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmVreducepd<AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vreducepd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmVreducepd<AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vreducepd(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmVreducepd<AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vreducepd(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmVreduceph<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vreduceph(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmVreduceph<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vreduceph(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmVreduceph<AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vreduceph(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmVreduceph<AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vreduceph(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmVreduceph<AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vreduceph(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmVreduceph<AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vreduceph(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmVreduceps<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vreduceps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmVreduceps<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vreduceps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmVreduceps<AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vreduceps(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmVreduceps<AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vreduceps(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmVreduceps<AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vreduceps(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmVreduceps<AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vreduceps(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmVreducesd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vreducesd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVreducesd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vreducesd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVreducesh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vreducesh(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVreducesh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vreducesh(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVreducess<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vreducess(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVreducess<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vreducess(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVrndscalepd<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vrndscalepd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmVrndscalepd<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vrndscalepd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmVrndscalepd<AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vrndscalepd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmVrndscalepd<AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vrndscalepd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmVrndscalepd<AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vrndscalepd(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmVrndscalepd<AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vrndscalepd(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmVrndscaleph<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vrndscaleph(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmVrndscaleph<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vrndscaleph(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmVrndscaleph<AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vrndscaleph(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmVrndscaleph<AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vrndscaleph(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmVrndscaleph<AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vrndscaleph(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmVrndscaleph<AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vrndscaleph(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmVrndscaleps<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vrndscaleps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmVrndscaleps<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vrndscaleps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmVrndscaleps<AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vrndscaleps(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmVrndscaleps<AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vrndscaleps(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmVrndscaleps<AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vrndscaleps(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmVrndscaleps<AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vrndscaleps(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmVrndscalesd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vrndscalesd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVrndscalesd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vrndscalesd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVrndscalesh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vrndscalesh(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVrndscalesh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vrndscalesh(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVrndscaless<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vrndscaless(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVrndscaless<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vrndscaless(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVroundpd<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vroundpd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmVroundpd<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vroundpd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmVroundpd<AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vroundpd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmVroundpd<AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vroundpd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmVroundps<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vroundps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmVroundps<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vroundps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmVroundps<AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vroundps(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand,
    op2: i32
) -> Result<(), IcedError>

impl CodeAsmVroundps<AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vroundps(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand,
    op2: u32
) -> Result<(), IcedError>

impl CodeAsmVroundsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vroundsd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVroundsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vroundsd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVroundss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vroundss(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVroundss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vroundss(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVrsqrt14pd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vrsqrt14pd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVrsqrt14pd<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vrsqrt14pd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVrsqrt14pd<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vrsqrt14pd(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVrsqrt14ps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vrsqrt14ps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVrsqrt14ps<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vrsqrt14ps(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVrsqrt14ps<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vrsqrt14ps(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVrsqrt14sd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vrsqrt14sd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVrsqrt14ss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vrsqrt14ss(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVrsqrt28pd<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vrsqrt28pd(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVrsqrt28ps<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vrsqrt28ps(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVrsqrt28sd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vrsqrt28sd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVrsqrt28ss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vrsqrt28ss(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVrsqrtph<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vrsqrtph(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVrsqrtph<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vrsqrtph(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVrsqrtph<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vrsqrtph(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVrsqrtps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vrsqrtps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVrsqrtps<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vrsqrtps(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVrsqrtsh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vrsqrtsh(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVrsqrtss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vrsqrtss(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVscalefpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vscalefpd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVscalefpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vscalefpd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVscalefpd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vscalefpd(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVscalefph<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vscalefph(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVscalefph<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vscalefph(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVscalefph<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vscalefph(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVscalefps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vscalefps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVscalefps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vscalefps(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVscalefps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vscalefps(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVscalefsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vscalefsd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVscalefsh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vscalefsh(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVscalefss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vscalefss(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVscatterdpd<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vscatterdpd(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterXmm
) -> Result<(), IcedError>

impl CodeAsmVscatterdpd<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vscatterdpd(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterYmm
) -> Result<(), IcedError>

impl CodeAsmVscatterdpd<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

fn vscatterdpd(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterZmm
) -> Result<(), IcedError>

impl CodeAsmVscatterdps<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vscatterdps(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterXmm
) -> Result<(), IcedError>

impl CodeAsmVscatterdps<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vscatterdps(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterYmm
) -> Result<(), IcedError>

impl CodeAsmVscatterdps<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

fn vscatterdps(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterZmm
) -> Result<(), IcedError>

impl CodeAsmVscatterpf0dpd<AsmMemoryOperand> for CodeAssembler

fn vscatterpf0dpd(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmVscatterpf0dps<AsmMemoryOperand> for CodeAssembler

fn vscatterpf0dps(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmVscatterpf0qpd<AsmMemoryOperand> for CodeAssembler

fn vscatterpf0qpd(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmVscatterpf0qps<AsmMemoryOperand> for CodeAssembler

fn vscatterpf0qps(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmVscatterpf1dpd<AsmMemoryOperand> for CodeAssembler

fn vscatterpf1dpd(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmVscatterpf1dps<AsmMemoryOperand> for CodeAssembler

fn vscatterpf1dps(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmVscatterpf1qpd<AsmMemoryOperand> for CodeAssembler

fn vscatterpf1qpd(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmVscatterpf1qps<AsmMemoryOperand> for CodeAssembler

fn vscatterpf1qps(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmVscatterqpd<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vscatterqpd(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterXmm
) -> Result<(), IcedError>

impl CodeAsmVscatterqpd<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vscatterqpd(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterYmm
) -> Result<(), IcedError>

impl CodeAsmVscatterqpd<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

fn vscatterqpd(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterZmm
) -> Result<(), IcedError>

impl CodeAsmVscatterqps<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vscatterqps(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterXmm
) -> Result<(), IcedError>

impl CodeAsmVscatterqps<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vscatterqps(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegisterYmm
) -> Result<(), IcedError>

impl CodeAsmVshuff32x4<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vshuff32x4(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVshuff32x4<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vshuff32x4(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVshuff32x4<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vshuff32x4(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVshuff32x4<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vshuff32x4(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVshuff64x2<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vshuff64x2(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVshuff64x2<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vshuff64x2(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVshuff64x2<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vshuff64x2(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVshuff64x2<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vshuff64x2(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVshufi32x4<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vshufi32x4(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVshufi32x4<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vshufi32x4(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVshufi32x4<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vshufi32x4(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVshufi32x4<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vshufi32x4(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVshufi64x2<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vshufi64x2(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVshufi64x2<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vshufi64x2(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVshufi64x2<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vshufi64x2(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVshufi64x2<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vshufi64x2(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVshufpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vshufpd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVshufpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vshufpd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVshufpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vshufpd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVshufpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vshufpd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVshufpd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vshufpd(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVshufpd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vshufpd(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVshufps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vshufps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVshufps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vshufps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVshufps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vshufps(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVshufps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vshufps(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVshufps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vshufps(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand,
    op3: i32
) -> Result<(), IcedError>

impl CodeAsmVshufps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vshufps(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand,
    op3: u32
) -> Result<(), IcedError>

impl CodeAsmVsqrtpd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vsqrtpd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVsqrtpd<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vsqrtpd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVsqrtpd<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vsqrtpd(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVsqrtph<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vsqrtph(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVsqrtph<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vsqrtph(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVsqrtph<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vsqrtph(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVsqrtps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vsqrtps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVsqrtps<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vsqrtps(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVsqrtps<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vsqrtps(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVsqrtsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vsqrtsd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVsqrtsh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vsqrtsh(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVsqrtss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vsqrtss(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVstmxcsr<AsmMemoryOperand> for CodeAssembler

fn vstmxcsr(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmVsubpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vsubpd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVsubpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vsubpd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVsubpd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vsubpd(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVsubph<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vsubph(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVsubph<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vsubph(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVsubph<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vsubph(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVsubps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vsubps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVsubps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vsubps(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVsubps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vsubps(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVsubsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vsubsd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVsubsh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vsubsh(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVsubss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vsubss(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVtestpd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vtestpd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVtestpd<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vtestpd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVtestps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vtestps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVtestps<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vtestps(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVucomisd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vucomisd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVucomish<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vucomish(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVucomiss<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vucomiss(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVunpckhpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vunpckhpd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVunpckhpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vunpckhpd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVunpckhpd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vunpckhpd(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVunpckhps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vunpckhps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVunpckhps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vunpckhps(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVunpckhps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vunpckhps(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVunpcklpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vunpcklpd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVunpcklpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vunpcklpd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVunpcklpd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vunpcklpd(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVunpcklps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vunpcklps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVunpcklps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vunpcklps(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVunpcklps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vunpcklps(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVxorpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vxorpd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVxorpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vxorpd(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVxorpd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vxorpd(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVxorps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vxorps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmRegisterXmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVxorps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vxorps(
    &mut self,
    op0: AsmRegisterYmm,
    op1: AsmRegisterYmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmVxorps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vxorps(
    &mut self,
    op0: AsmRegisterZmm,
    op1: AsmRegisterZmm,
    op2: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmWrshr<AsmMemoryOperand> for CodeAssembler

fn wrshr(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmWrssd<AsmMemoryOperand, AsmRegister32> for CodeAssembler

fn wrssd(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegister32
) -> Result<(), IcedError>

impl CodeAsmWrssq<AsmMemoryOperand, AsmRegister64> for CodeAssembler

fn wrssq(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegister64
) -> Result<(), IcedError>

impl CodeAsmWrussd<AsmMemoryOperand, AsmRegister32> for CodeAssembler

fn wrussd(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegister32
) -> Result<(), IcedError>

impl CodeAsmWrussq<AsmMemoryOperand, AsmRegister64> for CodeAssembler

fn wrussq(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegister64
) -> Result<(), IcedError>

impl CodeAsmXadd<AsmMemoryOperand, AsmRegister16> for CodeAssembler

fn xadd(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegister16
) -> Result<(), IcedError>

impl CodeAsmXadd<AsmMemoryOperand, AsmRegister32> for CodeAssembler

fn xadd(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegister32
) -> Result<(), IcedError>

impl CodeAsmXadd<AsmMemoryOperand, AsmRegister64> for CodeAssembler

fn xadd(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegister64
) -> Result<(), IcedError>

impl CodeAsmXadd<AsmMemoryOperand, AsmRegister8> for CodeAssembler

fn xadd(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegister8
) -> Result<(), IcedError>

impl CodeAsmXbts<AsmRegister16, AsmMemoryOperand> for CodeAssembler

fn xbts(
    &mut self,
    op0: AsmRegister16,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmXbts<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn xbts(
    &mut self,
    op0: AsmRegister32,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmXchg<AsmMemoryOperand, AsmRegister16> for CodeAssembler

fn xchg(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegister16
) -> Result<(), IcedError>

impl CodeAsmXchg<AsmMemoryOperand, AsmRegister32> for CodeAssembler

fn xchg(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegister32
) -> Result<(), IcedError>

impl CodeAsmXchg<AsmMemoryOperand, AsmRegister64> for CodeAssembler

fn xchg(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegister64
) -> Result<(), IcedError>

impl CodeAsmXchg<AsmMemoryOperand, AsmRegister8> for CodeAssembler

fn xchg(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegister8
) -> Result<(), IcedError>

impl CodeAsmXor<AsmMemoryOperand, AsmRegister16> for CodeAssembler

fn xor(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegister16
) -> Result<(), IcedError>

impl CodeAsmXor<AsmMemoryOperand, AsmRegister32> for CodeAssembler

fn xor(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegister32
) -> Result<(), IcedError>

impl CodeAsmXor<AsmMemoryOperand, AsmRegister64> for CodeAssembler

fn xor(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegister64
) -> Result<(), IcedError>

impl CodeAsmXor<AsmMemoryOperand, AsmRegister8> for CodeAssembler

fn xor(
    &mut self,
    op0: AsmMemoryOperand,
    op1: AsmRegister8
) -> Result<(), IcedError>

impl CodeAsmXor<AsmMemoryOperand, i32> for CodeAssembler

fn xor(&mut self, op0: AsmMemoryOperand, op1: i32) -> Result<(), IcedError>

impl CodeAsmXor<AsmMemoryOperand, u32> for CodeAssembler

fn xor(&mut self, op0: AsmMemoryOperand, op1: u32) -> Result<(), IcedError>

impl CodeAsmXor<AsmRegister16, AsmMemoryOperand> for CodeAssembler

fn xor(
    &mut self,
    op0: AsmRegister16,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmXor<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn xor(
    &mut self,
    op0: AsmRegister32,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmXor<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn xor(
    &mut self,
    op0: AsmRegister64,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmXor<AsmRegister8, AsmMemoryOperand> for CodeAssembler

fn xor(
    &mut self,
    op0: AsmRegister8,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmXorpd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn xorpd(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmXorps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn xorps(
    &mut self,
    op0: AsmRegisterXmm,
    op1: AsmMemoryOperand
) -> Result<(), IcedError>

impl CodeAsmXrstor<AsmMemoryOperand> for CodeAssembler

fn xrstor(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmXrstor64<AsmMemoryOperand> for CodeAssembler

fn xrstor64(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmXrstors<AsmMemoryOperand> for CodeAssembler

fn xrstors(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmXrstors64<AsmMemoryOperand> for CodeAssembler

fn xrstors64(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmXsave<AsmMemoryOperand> for CodeAssembler

fn xsave(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmXsave64<AsmMemoryOperand> for CodeAssembler

fn xsave64(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmXsavec<AsmMemoryOperand> for CodeAssembler

fn xsavec(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmXsavec64<AsmMemoryOperand> for CodeAssembler

fn xsavec64(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmXsaveopt<AsmMemoryOperand> for CodeAssembler

fn xsaveopt(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmXsaveopt64<AsmMemoryOperand> for CodeAssembler

fn xsaveopt64(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmXsaves<AsmMemoryOperand> for CodeAssembler

fn xsaves(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmXsaves64<AsmMemoryOperand> for CodeAssembler

fn xsaves64(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl Debug for AsmMemoryOperand

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl From<CodeLabel> for AsmMemoryOperand

fn from(other: CodeLabel) -> Self

Converts to this type from the input type.

impl<R: Into<Register>> From<R> for AsmMemoryOperand

fn from(other: R) -> Self

Converts to this type from the input type.

impl From<i16> for AsmMemoryOperand

fn from(other: i16) -> Self

Converts to this type from the input type.

impl From<i32> for AsmMemoryOperand

fn from(other: i32) -> Self

Converts to this type from the input type.

impl From<i64> for AsmMemoryOperand

fn from(other: i64) -> Self

Converts to this type from the input type.

impl From<i8> for AsmMemoryOperand

fn from(other: i8) -> Self

Converts to this type from the input type.

impl From<isize> for AsmMemoryOperand

fn from(other: isize) -> Self

Converts to this type from the input type.

impl From<u16> for AsmMemoryOperand

fn from(other: u16) -> Self

Converts to this type from the input type.

impl From<u32> for AsmMemoryOperand

fn from(other: u32) -> Self

Converts to this type from the input type.

impl From<u64> for AsmMemoryOperand

fn from(other: u64) -> Self

Converts to this type from the input type.

impl From<u8> for AsmMemoryOperand

fn from(other: u8) -> Self

Converts to this type from the input type.

impl From<usize> for AsmMemoryOperand

fn from(other: usize) -> Self

Converts to this type from the input type.

impl PartialEq<AsmMemoryOperand> for AsmMemoryOperand

fn eq(&self, other: &AsmMemoryOperand) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Sub<i16> for AsmMemoryOperand

type Output = AsmMemoryOperand

The resulting type after applying the - operator.

fn sub(self, rhs: i16) -> Self::Output

Performs the - operation.

impl Sub<i32> for AsmMemoryOperand

type Output = AsmMemoryOperand

The resulting type after applying the - operator.

fn sub(self, rhs: i32) -> Self::Output

Performs the - operation.

impl Sub<i64> for AsmMemoryOperand

type Output = AsmMemoryOperand

The resulting type after applying the - operator.

fn sub(self, rhs: i64) -> Self::Output

Performs the - operation.

impl Sub<i8> for AsmMemoryOperand

type Output = AsmMemoryOperand

The resulting type after applying the - operator.

fn sub(self, rhs: i8) -> Self::Output

Performs the - operation.

impl Sub<isize> for AsmMemoryOperand

type Output = AsmMemoryOperand

The resulting type after applying the - operator.

fn sub(self, rhs: isize) -> Self::Output

Performs the - operation.

impl Sub<u16> for AsmMemoryOperand

type Output = AsmMemoryOperand

The resulting type after applying the - operator.

fn sub(self, rhs: u16) -> Self::Output

Performs the - operation.

impl Sub<u32> for AsmMemoryOperand

type Output = AsmMemoryOperand

The resulting type after applying the - operator.

fn sub(self, rhs: u32) -> Self::Output

Performs the - operation.

impl Sub<u64> for AsmMemoryOperand

type Output = AsmMemoryOperand

The resulting type after applying the - operator.

fn sub(self, rhs: u64) -> Self::Output

Performs the - operation.

impl Sub<u8> for AsmMemoryOperand

type Output = AsmMemoryOperand

The resulting type after applying the - operator.

fn sub(self, rhs: u8) -> Self::Output

Performs the - operation.

impl Sub<usize> for AsmMemoryOperand

type Output = AsmMemoryOperand

The resulting type after applying the - operator.

fn sub(self, rhs: usize) -> Self::Output

Performs the - operation.

impl Copy for AsmMemoryOperand

impl Eq for AsmMemoryOperand

impl StructuralEq for AsmMemoryOperand

impl StructuralPartialEq for AsmMemoryOperand