Struct assembler::InstructionStream

pub struct InstructionStream<'a> { /* private fields */ }

An instruction stream.

Has functions for writing x64 instructions, organized by mnemonic and the parameters they need.

When finished, call finish().

When writing 8-bit Jcc (JMP and conditional JMP instructions), a ShortJmpResult is returned in error if the target effective address could be resolved and its displacement exceeds the size of an i8. In this case, the instruction stream is rolled back to point to just before where the instruction started to be emitted. Use this result to try to make a 8-bit JMP and then replace it with a 32-bit one if an error occurs.

Note that unresolved labels (ie those yet to be attached to a location in the instruction stream) will not produce such an error. Instead a panic (in debug builds) or silent error will occur when finish() is called.

Implementations

impl<'a> InstructionStream<'a>

pub fn finish(self) -> (&'a [u8], InstructionStreamHints)

Resolves all remaining labels and makes code executable.

Will panic in debug builds if labels can not be resolved, 8-bit JMPs are too far away or 32-bit JMPs have displacements of more than 2Gb!

Returns a slice containing just the instructions encoded; useful for testing or for dumping to a file; and hints to use for the next instance.

pub fn create_and_attach_label(&mut self) -> Label

Creates an unique label and uses it to label the current location.

pub fn create_label(&mut self) -> Label

Creates an unique label, scoped to this instance of the Instruction Stream.

The label is created unattached.

pub fn attach_label(&mut self, label: Label)

Labels the current location.

It is an error to use the same label to label more than one location (or to label the current location with the same label twice or more).

This only checked for in debug builds where it causes a runtime panic.

Labels should be created using self.create_label(); no checks are made for labels created with another instance and attached to this one.

pub fn emit_label(&mut self, label: Label)

Emits the 64-bit value of a label at the current location.

Typically used when build jump tables.

It is an error to use the same label to label more than one location (or to label the current location with the same label twice or more).

This only checked for in debug builds where it causes a runtime panic.

Labels should be created using self.create_label(); no checks are made for labels created with another instance and attached to this one.

pub fn push_stack_frame(&mut self)

Emits a non-leaf function prologue suitable for both the System V Application Binary Interface for AMD64 and the Microsoft x64 Calling Convention.

pub fn pop_stack_frame_and_return(&mut self)

Emits a non-leaf function epilogue (which returns) suitable for both the System V Application Binary Interface for AMD64 and the Microsoft x64 Calling Convention.

pub fn zero_RAX(&mut self)

Zeroes the RAX register using the most efficient code (XOR RAX, RAX, although could just as easily be SUB RAX, RAX).

Also equivalent to a C _Bool’s false value.

pub fn set_RAX_to_c_bool_false(&mut self)

Sets the RAX register to be equivalent to a C _Bool’s false value using the most efficient code (MOV AL, 0x00).

Note that this is not necessarily 0x00000000_00000001, just that the bottom eight bits of RAX are 0x00.

pub fn set_RAX_to_c_bool_true(&mut self)

Sets the RAX register to be equivalent to a C _Bool’s true value using the most efficient code (MOV AL, 0x01).

Note that this is not necessarily 0x00000000_00000001, just that the bottom eight bits of RAX are 0x01.

pub fn nullary_function_pointer<R>(&self) -> unsafe extern "C" fn() -> R

Creates a function pointer to the current location that takes no arguments and returns a result of type R.

Resultant function will not execute (and in all likelihood cause an uncaught signal to occur) until self.finish() is called.

pub fn unary_function_pointer<R, A>(&self) -> unsafe extern "C" fn(_: A) -> R

Creates a function pointer to the current location that takes one argument of type A and returns a result of type R.

Resultant function will not execute (and in all likelihood cause an uncaught signal to occur) until self.finish() is called.

pub fn binary_function_pointer<R, A, B>(
    &self
) -> unsafe extern "C" fn(_: A, _: B) -> R

Creates a function pointer to the current location that takes two argument of types A and B and returns a result of type R.

Resultant function will not execute (and in all likelihood cause an uncaught signal to occur) until self.finish() is called.

pub fn ternary_function_pointer<R, A, B, C>(
    &self
) -> unsafe extern "C" fn(_: A, _: B, _: C) -> R

Creates a function pointer to the current location that takes three argument of types A, B and C and returns a result of type R.

Resultant function will not execute (and in all likelihood cause an uncaught signal to occur) until self.finish() is called.

pub fn quaternary_function_pointer<R, A, B, C, D>(
    &self
) -> unsafe extern "C" fn(_: A, _: B, _: C, _: D) -> R

Creates a function pointer to the current location that takes four argument of types A, B, C and D and returns a result of type R.

Resultant function will not execute (and in all likelihood cause an uncaught signal to occur) until self.finish() is called.

pub fn quinary_function_pointer<R, A, B, C, D, E>(
    &self
) -> unsafe extern "C" fn(_: A, _: B, _: C, _: D, _: E) -> R

Creates a function pointer to the current location that takes five argument of types A, B, C, D and E and returns a result of type R.

Resultant function will not execute (and in all likelihood cause an uncaught signal to occur) until self.finish() is called.

pub fn senary_function_pointer<R, A, B, C, D, E, F>(
    &self
) -> unsafe extern "C" fn(_: A, _: B, _: C, _: D, _: E, _: F) -> R

Creates a function pointer to the current location that takes six argument of types A, B, C, D, E and F and returns a result of type R.

Resultant function will not execute (and in all likelihood cause an uncaught signal to occur) until self.finish() is called.

pub fn emit_byte(&mut self, byte: u8)

Emits (pushes) a byte into the instruction stream at the current location.

The byte can be data or instructions.

pub fn emit_word(&mut self, word: u16)

Emits (pushes) a word (2 bytes) into the instruction stream at the current location.

The word can be data or instructions.

The word will be swapped into the little endian form (a no-op on x64 platforms).

pub fn emit_double_word(&mut self, double_word: u32)

Emits (pushes) a double word (4 bytes) into the instruction stream at the current location.

The word can be data or instructions.

The word will be swapped into the little endian form (a no-op on x64 platforms).

pub fn emit_quad_word(&mut self, quad_word: u64)

Emits (pushes) a quad word (8 bytes) into the instruction stream at the current location.

The word can be data or instructions.

The word will be swapped into the little endian form (a no-op on x64 platforms).

pub fn emit_double_quad_word(&mut self, double_quad_word: u128)

Emits (pushes) a double quad word (16 bytes) into the instruction stream at the current location.

The word can be data or instructions.

The word will be swapped into the little endian form (a no-op on x64 platforms).

pub fn emit_bytes(&mut self, bytes: &[u8])

Emits (pushes) zero or more bytes into the instruction stream at the current location.

Bytes can be data or instructions.

pub fn rewind_to_emit_byte(&mut self, byte: u8)

Rewinds by the length of a byte (1 byte) and then emits byte.

pub fn rewind_to_emit_double_word(&mut self, double_word: u32)

Rewinds by the length of a double word (4 bytes) and then emits double_word.

pub fn skip_bytes(&mut self, count: usize)

Skips over zero or more count bytes in the instruction stream at the current location.

pub fn emit_nops(&mut self, count: usize)

Emits (pushes) NOPs (No Operation) opcodes into the instruction stream at the current location to ensure the desired alignment.

Efficient for alignments up to 32 (needed for AVX-2).

pub fn emit_alignment(&mut self, alignment: usize)

Emits (pushes) NOPs (No Operation) opcodes into the instruction stream at the current location to ensure the desired alignment.

Efficient for alignments up to 32 (needed for AVX-2).

pub fn instruction_pointer(&self) -> InstructionPointer

The current instruction pointer.

pub fn start_instruction_pointer(&self) -> InstructionPointer

The location of the start of instructions.

pub fn jmp_Any64BitMemory_statically_relative_address(
    &mut self,
    index_register: Register64Bit,
    scale: IndexScale,
    base_register_holding_start_of_instructions_pointer: Register64Bit
)

Attempts to calculate a Jump destination which uses an index register and scale but an absolute offset from address 0.

Typically used for when building jump tables and for other uses of ‘computed jumps’ (also known as indirect branches, indirect jumps and register-indirect jumps).

Will try to use a form that does not need a register first (See Agner Fog’s Optimizing Volume 2 (Optimizing subroutines in assembly language) § 3.3 Addressing Modes - Addressing static arrays in 64 bit mode, Example 3.11b).

If this is not possible, then falls back to Agner Fog’s Optimizing Volume 2 (Optimizing subroutines in assembly language) § 3.3 Addressing Modes - Addressing static arrays in 64 bit mode, Example 3.11c using the value in base_register_holding_start_of_instructions_pointer.

A typically register to use for base_register_holding_start_of_instructions_pointer would be RBX.

The fallback approach will panic if base_register_holding_start_of_instructions_pointer is None, or if the required Jump is more than 2Gb relatively (unlikely).

Ideally, make sure the argument allocate_in_first_2Gb to ExecutableAnonymousMemoryMap::new() is true (or test that the start of instructions is below 0x80000000 (2^31 bytes)) and then base_register_holding_start_of_instructions_pointer can be None safely.

pub fn statically_relative_address<BM: BitMemory>(
    &self,
    array_location_in_memory: InstructionPointer,
    index_register: Register64Bit,
    scale: IndexScale,
    base_register_holding_start_of_instructions_pointer: Register64Bit
) -> BM

Typically used for when trying to reference static (global) arrays in memory using an index with instructions such as MOV or VPTEST.

Can be used with jmp_Any64BitMemory(), but only if the start of the jump table is known in advance.

If it is not, use the method jmp_Any64BitMemory_accounting_for_first_2Gb().

The result is only valid as long as an instruction is not written into this instruction stream.

Will try to use a form that does not need a register first (See Agner Fog’s Optimizing Volume 2 (Optimizing subroutines in assembly language) § 3.3 Addressing Modes - Addressing static arrays in 64 bit mode, Example 3.11b).

If this is not possible, then falls back to Agner Fog’s Optimizing Volume 2 (Optimizing subroutines in assembly language) § 3.3 Addressing Modes - Addressing static arrays in 64 bit mode, Example 3.11c using the value in base_register_holding_start_of_instructions_pointer.

A typically register to use for base_register_holding_start_of_instructions_pointer would be RBX.

The fallback approach will panic if the required Jump is more than 2Gb relatively (unlikely).

If the result is None, one can apply Agner Fog’s Optimizing Volume 2 (Optimizing subroutines in assembly language) § 3.3 Addressing Modes - Addressing static arrays in 64 bit mode, Example 3.11e (this will require a LEA Register, [array_location_in_memory] prior to this instruction).

Ideally, make sure the argument allocate_in_first_2Gb to ExecutableAnonymousMemoryMap::new() is true (or test that the start of instructions is below 0x80000000 (2^31 bytes)) and then base_register_holding_start_of_instructions_pointer can be None safely.

pub fn overwrite_last_32bit_displacement_with_relative_address_to(
    &mut self,
    location_in_memory: InstructionPointer
)

Use as follows with Memory::relative_instruction_pointer_relative():-

instruction_stream.vmovdqa_YMM_Any256BitMemory(ymm_register, Any256BitMemory::relative_instruction_pointer_relative());
instruction_stream.overwrite_last_displacement_with_relative_address_to(absolute_address);

Will panic in debug builds if the required displacement is more than 2Gb (such a displacement is extremely unlikely).

pub fn emit_fixed_size_block<R>(
    &mut self,
    scale: impl Into<u8>,
    emit_instructions: impl FnMut(&mut Self) -> R
) -> R

Emits a block of a fixed size (blocks are padded to the desired size).

Panics in debug builds if the block is too large.

Typically used for jump table blocks.

Size is actually specified as a scale (power of two); use a u8 or IndexScale.

impl<'a> InstructionStream<'a>

pub fn adc_AL_Immediate8Bit(&mut self, arg1: Immediate8Bit)

Add with carry imm8 to AL.

pub fn adc_AX_Immediate16Bit(&mut self, arg1: Immediate16Bit)

Add with carry imm16 to AX.

pub fn adc_EAX_Immediate32Bit(&mut self, arg1: Immediate32Bit)

Add with carry imm32 to EAX.

pub fn adc_Any16BitMemory_Immediate16Bit(
    &mut self,
    arg0: Any16BitMemory,
    arg1: Immediate16Bit
)

Add with carry imm16 to r/m16.

pub fn adc_Any16BitMemory_Immediate8Bit(
    &mut self,
    arg0: Any16BitMemory,
    arg1: Immediate8Bit
)

Add with Carry Flag (CF) sign-extended imm8 to r/m16.

pub fn adc_Any16BitMemory_Register16Bit(
    &mut self,
    arg0: Any16BitMemory,
    arg1: Register16Bit
)

Add with carry r16 to r/m16.

pub fn adc_Any32BitMemory_Immediate32Bit(
    &mut self,
    arg0: Any32BitMemory,
    arg1: Immediate32Bit
)

Add with Carry Flag (CF) imm32 to r/m32.

pub fn adc_Any32BitMemory_Immediate8Bit(
    &mut self,
    arg0: Any32BitMemory,
    arg1: Immediate8Bit
)

Add with Carry Flag (CF) sign-extended imm8 into r/m32.

pub fn adc_Any32BitMemory_Register32Bit(
    &mut self,
    arg0: Any32BitMemory,
    arg1: Register32Bit
)

Add with Carry Flag (CF) r32 to r/m32.

pub fn adc_Any64BitMemory_Immediate32Bit(
    &mut self,
    arg0: Any64BitMemory,
    arg1: Immediate32Bit
)

Add with Carry Flag (CF) imm32 sign extended to 64-bits to r/m64.

pub fn adc_Any64BitMemory_Immediate8Bit(
    &mut self,
    arg0: Any64BitMemory,
    arg1: Immediate8Bit
)

Add with Carry Flag (CF) sign-extended imm8 into r/m64.

pub fn adc_Any64BitMemory_Register64Bit(
    &mut self,
    arg0: Any64BitMemory,
    arg1: Register64Bit
)

Add with Carry Flag (CF) r64 to r/m64.

pub fn adc_Any8BitMemory_Immediate8Bit(
    &mut self,
    arg0: Any8BitMemory,
    arg1: Immediate8Bit
)

Add with carry imm8 to r/m8.

pub fn adc_Any8BitMemory_Register8Bit(
    &mut self,
    arg0: Any8BitMemory,
    arg1: Register8Bit
)

Add with carry byte register to r/m8.

pub fn adc_Any8BitMemory_RegisterHigh8BitsOf16Bits(
    &mut self,
    arg0: Any8BitMemory,
    arg1: RegisterHigh8BitsOf16Bits
)

Add with carry byte register to r/m8.

pub fn adc_Register16Bit_Immediate16Bit(
    &mut self,
    arg0: Register16Bit,
    arg1: Immediate16Bit
)

Add with carry imm16 to r/m16.

pub fn adc_Register16Bit_Immediate8Bit(
    &mut self,
    arg0: Register16Bit,
    arg1: Immediate8Bit
)

Add with Carry Flag (CF) sign-extended imm8 to r/m16.

pub fn adc_Register16Bit_Any16BitMemory(
    &mut self,
    arg0: Register16Bit,
    arg1: Any16BitMemory
)

Add with carry r/m16 to r16.

pub fn adc_Register16Bit_Register16Bit(
    &mut self,
    arg0: Register16Bit,
    arg1: Register16Bit
)

Add with carry r16 to r/m16.

pub fn adc_Register16Bit_Register16Bit_1(
    &mut self,
    arg0: Register16Bit,
    arg1: Register16Bit
)

Add with carry r/m16 to r16.

pub fn adc_Register32Bit_Immediate32Bit(
    &mut self,
    arg0: Register32Bit,
    arg1: Immediate32Bit
)

Add with Carry Flag (CF) imm32 to r/m32.

pub fn adc_Register32Bit_Immediate8Bit(
    &mut self,
    arg0: Register32Bit,
    arg1: Immediate8Bit
)

Add with Carry Flag (CF) sign-extended imm8 into r/m32.

pub fn adc_Register32Bit_Any32BitMemory(
    &mut self,
    arg0: Register32Bit,
    arg1: Any32BitMemory
)

Add with Carry Flag (CF) r/m32 to r32.

pub fn adc_Register32Bit_Register32Bit(
    &mut self,
    arg0: Register32Bit,
    arg1: Register32Bit
)

Add with Carry Flag (CF) r32 to r/m32.

pub fn adc_Register32Bit_Register32Bit_1(
    &mut self,
    arg0: Register32Bit,
    arg1: Register32Bit
)

Add with Carry Flag (CF) r/m32 to r32.

pub fn adc_Register64Bit_Immediate32Bit(
    &mut self,
    arg0: Register64Bit,
    arg1: Immediate32Bit
)

Add with Carry Flag (CF) imm32 sign extended to 64-bits to r/m64.

pub fn adc_Register64Bit_Immediate8Bit(
    &mut self,
    arg0: Register64Bit,
    arg1: Immediate8Bit
)

Add with Carry Flag (CF) sign-extended imm8 into r/m64.

pub fn adc_Register64Bit_Any64BitMemory(
    &mut self,
    arg0: Register64Bit,
    arg1: Any64BitMemory
)

Add with Carry Flag (CF) r/m64 to r64.

pub fn adc_Register64Bit_Register64Bit(
    &mut self,
    arg0: Register64Bit,
    arg1: Register64Bit
)

Add with Carry Flag (CF) r64 to r/m64.

pub fn adc_Register64Bit_Register64Bit_1(
    &mut self,
    arg0: Register64Bit,
    arg1: Register64Bit
)

Add with Carry Flag (CF) r/m64 to r64.

pub fn adc_Register8Bit_Immediate8Bit(
    &mut self,
    arg0: Register8Bit,
    arg1: Immediate8Bit
)

Add with carry imm8 to r/m8.

pub fn adc_Register8Bit_Any8BitMemory(
    &mut self,
    arg0: Register8Bit,
    arg1: Any8BitMemory
)

Add with carry r/m8 to byte register.

pub fn adc_Register8Bit_Register8Bit(
    &mut self,
    arg0: Register8Bit,
    arg1: Register8Bit
)

Add with carry byte register to r/m8.

pub fn adc_Register8Bit_Register8Bit_1(
    &mut self,
    arg0: Register8Bit,
    arg1: Register8Bit
)

Add with carry r/m8 to byte register.

pub fn adc_Register8Bit_RegisterHigh8BitsOf16Bits(
    &mut self,
    arg0: Register8Bit,
    arg1: RegisterHigh8BitsOf16Bits
)

Add with carry byte register to r/m8.

pub fn adc_Register8Bit_RegisterHigh8BitsOf16Bits_1(
    &mut self,
    arg0: Register8Bit,
    arg1: RegisterHigh8BitsOf16Bits
)

Add with carry r/m8 to byte register.

pub fn adc_RAX_Immediate32Bit(&mut self, arg1: Immediate32Bit)

Add with carry imm32 sign extended to 64-bits to RAX.

pub fn adc_RegisterHigh8BitsOf16Bits_Immediate8Bit(
    &mut self,
    arg0: RegisterHigh8BitsOf16Bits,
    arg1: Immediate8Bit
)

Add with carry imm8 to r/m8.

pub fn adc_RegisterHigh8BitsOf16Bits_Any8BitMemory(
    &mut self,
    arg0: RegisterHigh8BitsOf16Bits,
    arg1: Any8BitMemory
)

Add with carry r/m8 to byte register.

pub fn adc_RegisterHigh8BitsOf16Bits_Register8Bit(
    &mut self,
    arg0: RegisterHigh8BitsOf16Bits,
    arg1: Register8Bit
)

Add with carry byte register to r/m8.

pub fn adc_RegisterHigh8BitsOf16Bits_Register8Bit_1(
    &mut self,
    arg0: RegisterHigh8BitsOf16Bits,
    arg1: Register8Bit
)

Add with carry r/m8 to byte register.

pub fn adc_RegisterHigh8BitsOf16Bits_RegisterHigh8BitsOf16Bits(
    &mut self,
    arg0: RegisterHigh8BitsOf16Bits,
    arg1: RegisterHigh8BitsOf16Bits
)

Add with carry byte register to r/m8.

pub fn adc_RegisterHigh8BitsOf16Bits_RegisterHigh8BitsOf16Bits_1(
    &mut self,
    arg0: RegisterHigh8BitsOf16Bits,
    arg1: RegisterHigh8BitsOf16Bits
)

Add with carry r/m8 to byte register.

pub fn add_AL_Immediate8Bit(&mut self, arg1: Immediate8Bit)

Add imm8 to AL.

pub fn add_AX_Immediate16Bit(&mut self, arg1: Immediate16Bit)

Add imm16 to AX.

pub fn add_EAX_Immediate32Bit(&mut self, arg1: Immediate32Bit)

Add imm32 to EAX.

pub fn add_Any16BitMemory_Immediate16Bit(
    &mut self,
    arg0: Any16BitMemory,
    arg1: Immediate16Bit
)

Add imm16 to r/m16.

pub fn add_Any16BitMemory_Immediate8Bit(
    &mut self,
    arg0: Any16BitMemory,
    arg1: Immediate8Bit
)

Add sign-extended imm8 to r/m16.

pub fn add_Any16BitMemory_Register16Bit(
    &mut self,
    arg0: Any16BitMemory,
    arg1: Register16Bit
)

Add r16 to r/m16.

pub fn add_Any32BitMemory_Immediate32Bit(
    &mut self,
    arg0: Any32BitMemory,
    arg1: Immediate32Bit
)

Add imm32 to r/m32.

pub fn add_Any32BitMemory_Immediate8Bit(
    &mut self,
    arg0: Any32BitMemory,
    arg1: Immediate8Bit
)

Add sign-extended imm8 to r/m32.

pub fn add_Any32BitMemory_Register32Bit(
    &mut self,
    arg0: Any32BitMemory,
    arg1: Register32Bit
)

Add r32 to r/m32.

pub fn add_Any64BitMemory_Immediate32Bit(
    &mut self,
    arg0: Any64BitMemory,
    arg1: Immediate32Bit
)

Add imm32 sign-extended to 64-bits to r/m64.

pub fn add_Any64BitMemory_Immediate8Bit(
    &mut self,
    arg0: Any64BitMemory,
    arg1: Immediate8Bit
)

Add sign-extended imm8 to r/m64.

pub fn add_Any64BitMemory_Register64Bit(
    &mut self,
    arg0: Any64BitMemory,
    arg1: Register64Bit
)

Add r64 to r/m64.

pub fn add_Any8BitMemory_Immediate8Bit(
    &mut self,
    arg0: Any8BitMemory,
    arg1: Immediate8Bit
)

Add imm8 to r/m8.

pub fn add_Any8BitMemory_Register8Bit(
    &mut self,
    arg0: Any8BitMemory,
    arg1: Register8Bit
)

Add r8 to r/m8.

pub fn add_Any8BitMemory_RegisterHigh8BitsOf16Bits(
    &mut self,
    arg0: Any8BitMemory,
    arg1: RegisterHigh8BitsOf16Bits
)

Add r8 to r/m8.

pub fn add_Register16Bit_Immediate16Bit(
    &mut self,
    arg0: Register16Bit,
    arg1: Immediate16Bit
)

Add imm16 to r/m16.

pub fn add_Register16Bit_Immediate8Bit(
    &mut self,
    arg0: Register16Bit,
    arg1: Immediate8Bit
)

Add sign-extended imm8 to r/m16.

pub fn add_Register16Bit_Any16BitMemory(
    &mut self,
    arg0: Register16Bit,
    arg1: Any16BitMemory
)

Add r/m16 to r16.

pub fn add_Register16Bit_Register16Bit(
    &mut self,
    arg0: Register16Bit,
    arg1: Register16Bit
)

Add r16 to r/m16.

pub fn add_Register16Bit_Register16Bit_1(
    &mut self,
    arg0: Register16Bit,
    arg1: Register16Bit
)

Add r/m16 to r16.

pub fn add_Register32Bit_Immediate32Bit(
    &mut self,
    arg0: Register32Bit,
    arg1: Immediate32Bit
)

Add imm32 to r/m32.

pub fn add_Register32Bit_Immediate8Bit(
    &mut self,
    arg0: Register32Bit,
    arg1: Immediate8Bit
)

Add sign-extended imm8 to r/m32.

pub fn add_Register32Bit_Any32BitMemory(
    &mut self,
    arg0: Register32Bit,
    arg1: Any32BitMemory
)

Add r/m32 to r32.

pub fn add_Register32Bit_Register32Bit(
    &mut self,
    arg0: Register32Bit,
    arg1: Register32Bit
)

Add r32 to r/m32.

pub fn add_Register32Bit_Register32Bit_1(
    &mut self,
    arg0: Register32Bit,
    arg1: Register32Bit
)

Add r/m32 to r32.

pub fn add_Register64Bit_Immediate32Bit(
    &mut self,
    arg0: Register64Bit,
    arg1: Immediate32Bit
)

Add imm32 sign-extended to 64-bits to r/m64.

pub fn add_Register64Bit_Immediate8Bit(
    &mut self,
    arg0: Register64Bit,
    arg1: Immediate8Bit
)

Add sign-extended imm8 to r/m64.

pub fn add_Register64Bit_Any64BitMemory(
    &mut self,
    arg0: Register64Bit,
    arg1: Any64BitMemory
)

Add r/m64 to r64.

pub fn add_Register64Bit_Register64Bit(
    &mut self,
    arg0: Register64Bit,
    arg1: Register64Bit
)

Add r64 to r/m64.

pub fn add_Register64Bit_Register64Bit_1(
    &mut self,
    arg0: Register64Bit,
    arg1: Register64Bit
)

Add r/m64 to r64.

pub fn add_Register8Bit_Immediate8Bit(
    &mut self,
    arg0: Register8Bit,
    arg1: Immediate8Bit
)

Add imm8 to r/m8.

pub fn add_Register8Bit_Any8BitMemory(
    &mut self,
    arg0: Register8Bit,
    arg1: Any8BitMemory
)

Add r/m8 to r8.

pub fn add_Register8Bit_Register8Bit(
    &mut self,
    arg0: Register8Bit,
    arg1: Register8Bit
)

Add r8 to r/m8.

pub fn add_Register8Bit_Register8Bit_1(
    &mut self,
    arg0: Register8Bit,
    arg1: Register8Bit
)

Add r/m8 to r8.

pub fn add_Register8Bit_RegisterHigh8BitsOf16Bits(
    &mut self,
    arg0: Register8Bit,
    arg1: RegisterHigh8BitsOf16Bits
)

Add r8 to r/m8.

pub fn add_Register8Bit_RegisterHigh8BitsOf16Bits_1(
    &mut self,
    arg0: Register8Bit,
    arg1: RegisterHigh8BitsOf16Bits
)

Add r/m8 to r8.

pub fn add_RAX_Immediate32Bit(&mut self, arg1: Immediate32Bit)

Add imm32 sign-extended to 64-bits to RAX.

pub fn add_RegisterHigh8BitsOf16Bits_Immediate8Bit(
    &mut self,
    arg0: RegisterHigh8BitsOf16Bits,
    arg1: Immediate8Bit
)

Add imm8 to r/m8.

pub fn add_RegisterHigh8BitsOf16Bits_Any8BitMemory(
    &mut self,
    arg0: RegisterHigh8BitsOf16Bits,
    arg1: Any8BitMemory
)

Add r/m8 to r8.

pub fn add_RegisterHigh8BitsOf16Bits_Register8Bit(
    &mut self,
    arg0: RegisterHigh8BitsOf16Bits,
    arg1: Register8Bit
)

Add r8 to r/m8.

pub fn add_RegisterHigh8BitsOf16Bits_Register8Bit_1(
    &mut self,
    arg0: RegisterHigh8BitsOf16Bits,
    arg1: Register8Bit
)

Add r/m8 to r8.

pub fn add_RegisterHigh8BitsOf16Bits_RegisterHigh8BitsOf16Bits(
    &mut self,
    arg0: RegisterHigh8BitsOf16Bits,
    arg1: RegisterHigh8BitsOf16Bits
)

Add r8 to r/m8.

pub fn add_RegisterHigh8BitsOf16Bits_RegisterHigh8BitsOf16Bits_1(
    &mut self,
    arg0: RegisterHigh8BitsOf16Bits,
    arg1: RegisterHigh8BitsOf16Bits
)

Add r/m8 to r8.

pub fn addpd_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Add packed double-precision floating-point values from xmm2/m128 to xmm1.

pub fn addpd_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Add packed double-precision floating-point values from xmm2/m128 to xmm1.

pub fn addps_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Add packed single-precision floating-point values from xmm2/m128 to xmm1 and stores result in xmm1.

pub fn addps_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Add packed single-precision floating-point values from xmm2/m128 to xmm1 and stores result in xmm1.

pub fn addsd_XMMRegister_Any64BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any64BitMemory
)

Add the low double-precision floating-point value from xmm2/m64 to xmm1.

pub fn addsd_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Add the low double-precision floating-point value from xmm2/m64 to xmm1.

pub fn addss_XMMRegister_Any32BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any32BitMemory
)

Add the low single-precision floating-point value from xmm2/m32 to xmm1.

pub fn addss_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Add the low single-precision floating-point value from xmm2/m32 to xmm1.

pub fn addsubpd_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Add/subtract double-precision floating-point values from xmm2/m128 to xmm1.

pub fn addsubpd_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Add/subtract double-precision floating-point values from xmm2/m128 to xmm1.

pub fn addsubps_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Add/subtract single-precision floating-point values from xmm2/m128 to xmm1.

pub fn addsubps_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Add/subtract single-precision floating-point values from xmm2/m128 to xmm1.

pub fn aesdec_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Perform one round of an AES decryption flow, using the Equivalent Inverse Cipher, operating on a 128-bit data (state) from xmm1 with a 128-bit round key from xmm2/m128.

pub fn aesdec_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Perform one round of an AES decryption flow, using the Equivalent Inverse Cipher, operating on a 128-bit data (state) from xmm1 with a 128-bit round key from xmm2/m128.

pub fn aesdeclast_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Perform the last round of an AES decryption flow, using the Equivalent Inverse Cipher, operating on a 128-bit data (state) from xmm1 with a 128-bit round key from xmm2/m128.

pub fn aesdeclast_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Perform the last round of an AES decryption flow, using the Equivalent Inverse Cipher, operating on a 128-bit data (state) from xmm1 with a 128-bit round key from xmm2/m128.

pub fn aesenc_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Perform one round of an AES encryption flow, operating on a 128-bit data (state) from xmm1 with a 128-bit round key from xmm2/m128.

pub fn aesenc_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Perform one round of an AES encryption flow, operating on a 128-bit data (state) from xmm1 with a 128-bit round key from xmm2/m128.

pub fn aesenclast_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Perform the last round of an AES encryption flow, operating on a 128-bit data (state) from xmm1 with a 128-bit round key from xmm2/m128.

pub fn aesenclast_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Perform the last round of an AES encryption flow, operating on a 128-bit data (state) from xmm1 with a 128-bit round key from xmm2/m128.

pub fn aesimc_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Perform the InvMixColumn transformation on a 128-bit round key from xmm2/m128 and store the result in xmm1.

pub fn aesimc_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Perform the InvMixColumn transformation on a 128-bit round key from xmm2/m128 and store the result in xmm1.

pub fn aeskeygenassist_XMMRegister_Any128BitMemory_Immediate8Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory,
    arg2: Immediate8Bit
)

Assist in AES round key generation using an 8 bits Round Constant (RCON) specified in the imm8, operating on 128 bits of data specified in xmm2/m128 and stores the result in xmm1.

pub fn aeskeygenassist_XMMRegister_XMMRegister_Immediate8Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Immediate8Bit
)

Assist in AES round key generation using an 8 bits Round Constant (RCON) specified in the imm8, operating on 128 bits of data specified in xmm2/m128 and stores the result in xmm1.

pub fn and_AL_Immediate8Bit(&mut self, arg1: Immediate8Bit)

AL && imm8.

pub fn and_AX_Immediate16Bit(&mut self, arg1: Immediate16Bit)

AX && imm16.

pub fn and_EAX_Immediate32Bit(&mut self, arg1: Immediate32Bit)

EAX && imm32.

pub fn and_Any16BitMemory_Immediate16Bit(
    &mut self,
    arg0: Any16BitMemory,
    arg1: Immediate16Bit
)

r/m16 && imm16.

pub fn and_Any16BitMemory_Immediate8Bit(
    &mut self,
    arg0: Any16BitMemory,
    arg1: Immediate8Bit
)

r/m16 && imm8 (sign-extended).

pub fn and_Any16BitMemory_Register16Bit(
    &mut self,
    arg0: Any16BitMemory,
    arg1: Register16Bit
)

r/m16 && r16.

pub fn and_Any32BitMemory_Immediate32Bit(
    &mut self,
    arg0: Any32BitMemory,
    arg1: Immediate32Bit
)

r/m32 && imm32.

pub fn and_Any32BitMemory_Immediate8Bit(
    &mut self,
    arg0: Any32BitMemory,
    arg1: Immediate8Bit
)

r/m32 && imm8 (sign-extended).

pub fn and_Any32BitMemory_Register32Bit(
    &mut self,
    arg0: Any32BitMemory,
    arg1: Register32Bit
)

r/m32 && r32.

pub fn and_Any64BitMemory_Immediate32Bit(
    &mut self,
    arg0: Any64BitMemory,
    arg1: Immediate32Bit
)

r/m64 && imm32 sign extended to 64-bits.

pub fn and_Any64BitMemory_Immediate8Bit(
    &mut self,
    arg0: Any64BitMemory,
    arg1: Immediate8Bit
)

r/m64 && imm8 (sign-extended).

pub fn and_Any64BitMemory_Register64Bit(
    &mut self,
    arg0: Any64BitMemory,
    arg1: Register64Bit
)

r/m64 && r32.

pub fn and_Any8BitMemory_Immediate8Bit(
    &mut self,
    arg0: Any8BitMemory,
    arg1: Immediate8Bit
)

r/m8 && imm8.

pub fn and_Any8BitMemory_Register8Bit(
    &mut self,
    arg0: Any8BitMemory,
    arg1: Register8Bit
)

r/m8 && r8.

pub fn and_Any8BitMemory_RegisterHigh8BitsOf16Bits(
    &mut self,
    arg0: Any8BitMemory,
    arg1: RegisterHigh8BitsOf16Bits
)

r/m8 && r8.

pub fn and_Register16Bit_Immediate16Bit(
    &mut self,
    arg0: Register16Bit,
    arg1: Immediate16Bit
)

r/m16 && imm16.

pub fn and_Register16Bit_Immediate8Bit(
    &mut self,
    arg0: Register16Bit,
    arg1: Immediate8Bit
)

r/m16 && imm8 (sign-extended).

pub fn and_Register16Bit_Any16BitMemory(
    &mut self,
    arg0: Register16Bit,
    arg1: Any16BitMemory
)

r16 && r/m16.

pub fn and_Register16Bit_Register16Bit(
    &mut self,
    arg0: Register16Bit,
    arg1: Register16Bit
)

r/m16 && r16.

pub fn and_Register16Bit_Register16Bit_1(
    &mut self,
    arg0: Register16Bit,
    arg1: Register16Bit
)

r16 && r/m16.

pub fn and_Register32Bit_Immediate32Bit(
    &mut self,
    arg0: Register32Bit,
    arg1: Immediate32Bit
)

r/m32 && imm32.

pub fn and_Register32Bit_Immediate8Bit(
    &mut self,
    arg0: Register32Bit,
    arg1: Immediate8Bit
)

r/m32 && imm8 (sign-extended).

pub fn and_Register32Bit_Any32BitMemory(
    &mut self,
    arg0: Register32Bit,
    arg1: Any32BitMemory
)

r32 && r/m32.

pub fn and_Register32Bit_Register32Bit(
    &mut self,
    arg0: Register32Bit,
    arg1: Register32Bit
)

r/m32 && r32.

pub fn and_Register32Bit_Register32Bit_1(
    &mut self,
    arg0: Register32Bit,
    arg1: Register32Bit
)

r32 && r/m32.

pub fn and_Register64Bit_Immediate32Bit(
    &mut self,
    arg0: Register64Bit,
    arg1: Immediate32Bit
)

r/m64 && imm32 sign extended to 64-bits.

pub fn and_Register64Bit_Immediate8Bit(
    &mut self,
    arg0: Register64Bit,
    arg1: Immediate8Bit
)

r/m64 && imm8 (sign-extended).

pub fn and_Register64Bit_Any64BitMemory(
    &mut self,
    arg0: Register64Bit,
    arg1: Any64BitMemory
)

r64 && r/m64.

pub fn and_Register64Bit_Register64Bit(
    &mut self,
    arg0: Register64Bit,
    arg1: Register64Bit
)

r/m64 && r32.

pub fn and_Register64Bit_Register64Bit_1(
    &mut self,
    arg0: Register64Bit,
    arg1: Register64Bit
)

r64 && r/m64.

pub fn and_Register8Bit_Immediate8Bit(
    &mut self,
    arg0: Register8Bit,
    arg1: Immediate8Bit
)

r/m8 && imm8.

pub fn and_Register8Bit_Any8BitMemory(
    &mut self,
    arg0: Register8Bit,
    arg1: Any8BitMemory
)

r8 && r/m8.

pub fn and_Register8Bit_Register8Bit(
    &mut self,
    arg0: Register8Bit,
    arg1: Register8Bit
)

r/m8 && r8.

pub fn and_Register8Bit_Register8Bit_1(
    &mut self,
    arg0: Register8Bit,
    arg1: Register8Bit
)

r8 && r/m8.

pub fn and_Register8Bit_RegisterHigh8BitsOf16Bits(
    &mut self,
    arg0: Register8Bit,
    arg1: RegisterHigh8BitsOf16Bits
)

r/m8 && r8.

pub fn and_Register8Bit_RegisterHigh8BitsOf16Bits_1(
    &mut self,
    arg0: Register8Bit,
    arg1: RegisterHigh8BitsOf16Bits
)

r8 && r/m8.

pub fn and_RAX_Immediate32Bit(&mut self, arg1: Immediate32Bit)

RAX AND imm32 sign-extended to 64-bits.

pub fn and_RegisterHigh8BitsOf16Bits_Immediate8Bit(
    &mut self,
    arg0: RegisterHigh8BitsOf16Bits,
    arg1: Immediate8Bit
)

r/m8 && imm8.

pub fn and_RegisterHigh8BitsOf16Bits_Any8BitMemory(
    &mut self,
    arg0: RegisterHigh8BitsOf16Bits,
    arg1: Any8BitMemory
)

r8 && r/m8.

pub fn and_RegisterHigh8BitsOf16Bits_Register8Bit(
    &mut self,
    arg0: RegisterHigh8BitsOf16Bits,
    arg1: Register8Bit
)

r/m8 && r8.

pub fn and_RegisterHigh8BitsOf16Bits_Register8Bit_1(
    &mut self,
    arg0: RegisterHigh8BitsOf16Bits,
    arg1: Register8Bit
)

r8 && r/m8.

pub fn and_RegisterHigh8BitsOf16Bits_RegisterHigh8BitsOf16Bits(
    &mut self,
    arg0: RegisterHigh8BitsOf16Bits,
    arg1: RegisterHigh8BitsOf16Bits
)

r/m8 && r8.

pub fn and_RegisterHigh8BitsOf16Bits_RegisterHigh8BitsOf16Bits_1(
    &mut self,
    arg0: RegisterHigh8BitsOf16Bits,
    arg1: RegisterHigh8BitsOf16Bits
)

r8 && r/m8.

pub fn andn_Register32Bit_Register32Bit_Any32BitMemory(
    &mut self,
    arg0: Register32Bit,
    arg1: Register32Bit,
    arg2: Any32BitMemory
)

Bitwise AND of inverted r32b with r/m32 with result stored in in r32a.

pub fn andn_Register32Bit_Register32Bit_Register32Bit(
    &mut self,
    arg0: Register32Bit,
    arg1: Register32Bit,
    arg2: Register32Bit
)

Bitwise AND of inverted r32b with r/m32 with result stored in in r32a.

pub fn andn_Register64Bit_Register64Bit_Any64BitMemory(
    &mut self,
    arg0: Register64Bit,
    arg1: Register64Bit,
    arg2: Any64BitMemory
)

Bitwise AND of inverted r64b with r/m64 with result stored in in r64a.

pub fn andn_Register64Bit_Register64Bit_Register64Bit(
    &mut self,
    arg0: Register64Bit,
    arg1: Register64Bit,
    arg2: Register64Bit
)

Bitwise AND of inverted r64b with r/m64 with result stored in in r64a.

pub fn andnpd_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Bitwise logical AND NOT of xmm2/m128 and xmm1.

pub fn andnpd_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Bitwise logical AND NOT of xmm2/m128 and xmm1.

pub fn andnps_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Bitwise logical AND NOT of xmm2/m128 and xmm1.

pub fn andnps_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Bitwise logical AND NOT of xmm2/m128 and xmm1.

pub fn andpd_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Return the bitwise logical AND of packed double-precision floating-point values in xmm1 and xmm2/m128.

pub fn andpd_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Return the bitwise logical AND of packed double-precision floating-point values in xmm1 and xmm2/m128.

pub fn andps_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Bitwise logical AND of xmm2/m128 and xmm1.

pub fn andps_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Bitwise logical AND of xmm2/m128 and xmm1.

pub fn bextr_Register32Bit_Any32BitMemory_Register32Bit(
    &mut self,
    arg0: Register32Bit,
    arg1: Any32BitMemory,
    arg2: Register32Bit
)

Contiguous bitwise extract from r/m32 using r32b as control.

Stores result in r32a.

pub fn bextr_Register32Bit_Register32Bit_Register32Bit(
    &mut self,
    arg0: Register32Bit,
    arg1: Register32Bit,
    arg2: Register32Bit
)

Contiguous bitwise extract from r/m32 using r32b as control.

Stores result in r32a.

pub fn bextr_Register64Bit_Any64BitMemory_Register64Bit(
    &mut self,
    arg0: Register64Bit,
    arg1: Any64BitMemory,
    arg2: Register64Bit
)

Contiguous bitwise extract from r/m64 using r64b as control.

Stores result in r64a.

pub fn bextr_Register64Bit_Register64Bit_Register64Bit(
    &mut self,
    arg0: Register64Bit,
    arg1: Register64Bit,
    arg2: Register64Bit
)

Contiguous bitwise extract from r/m64 using r64b as control.

Stores result in r64a.

pub fn blendpd_XMMRegister_Any128BitMemory_Immediate8Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory,
    arg2: Immediate8Bit
)

Select packed DP-FP values from xmm1 and xmm2/m128 from mask specified in imm8 and store the values into xmm1.

pub fn blendpd_XMMRegister_XMMRegister_Immediate8Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Immediate8Bit
)

Select packed DP-FP values from xmm1 and xmm2/m128 from mask specified in imm8 and store the values into xmm1.

pub fn blendps_XMMRegister_Any128BitMemory_Immediate8Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory,
    arg2: Immediate8Bit
)

Select packed single-precision floating-point values from xmm1 and xmm2/m128 from mask specified in imm8 and store the values into xmm1.

pub fn blendps_XMMRegister_XMMRegister_Immediate8Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Immediate8Bit
)

Select packed single-precision floating-point values from xmm1 and xmm2/m128 from mask specified in imm8 and store the values into xmm1.

pub fn blendvpd_XMMRegister_Any128BitMemory_XMMRegister0(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Select packed DP FP values from xmm1 and xmm2 from mask specified in XMM0 and store the values in xmm1.

pub fn blendvpd_XMMRegister_XMMRegister_XMMRegister0(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Select packed DP FP values from xmm1 and xmm2 from mask specified in XMM0 and store the values in xmm1.

pub fn blendvps_XMMRegister_Any128BitMemory_XMMRegister0(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Select packed single-precision floating-point values from xmm1 and xmm2/m128 from mask specified in XMM0 and store the values into xmm1.

pub fn blendvps_XMMRegister_XMMRegister_XMMRegister0(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Select packed single-precision floating-point values from xmm1 and xmm2/m128 from mask specified in XMM0 and store the values into xmm1.

pub fn blsi_Register32Bit_Any32BitMemory(
    &mut self,
    arg0: Register32Bit,
    arg1: Any32BitMemory
)

Extract lowest set bit from r/m32 and set that bit in r32.

pub fn blsi_Register32Bit_Register32Bit(
    &mut self,
    arg0: Register32Bit,
    arg1: Register32Bit
)

Extract lowest set bit from r/m32 and set that bit in r32.

pub fn blsi_Register64Bit_Any64BitMemory(
    &mut self,
    arg0: Register64Bit,
    arg1: Any64BitMemory
)

Extract lowest set bit from r/m64, and set that bit in r64.

pub fn blsi_Register64Bit_Register64Bit(
    &mut self,
    arg0: Register64Bit,
    arg1: Register64Bit
)

Extract lowest set bit from r/m64, and set that bit in r64.

pub fn blsmsk_Register32Bit_Any32BitMemory(
    &mut self,
    arg0: Register32Bit,
    arg1: Any32BitMemory
)

Set all lower bits in r32 to 1 starting from bit 0 to lowest set bit in r/m32.

pub fn blsmsk_Register32Bit_Register32Bit(
    &mut self,
    arg0: Register32Bit,
    arg1: Register32Bit
)

Set all lower bits in r32 to 1 starting from bit 0 to lowest set bit in r/m32.

pub fn blsmsk_Register64Bit_Any64BitMemory(
    &mut self,
    arg0: Register64Bit,
    arg1: Any64BitMemory
)

Set all lower bits in r64 to 1 starting from bit 0 to lowest set bit in r/m64.

pub fn blsmsk_Register64Bit_Register64Bit(
    &mut self,
    arg0: Register64Bit,
    arg1: Register64Bit
)

Set all lower bits in r64 to 1 starting from bit 0 to lowest set bit in r/m64.

pub fn blsr_Register32Bit_Any32BitMemory(
    &mut self,
    arg0: Register32Bit,
    arg1: Any32BitMemory
)

Reset lowest set bit of r/m32, keep all other bits of r/m32 and write result to r32.

pub fn blsr_Register32Bit_Register32Bit(
    &mut self,
    arg0: Register32Bit,
    arg1: Register32Bit
)

Reset lowest set bit of r/m32, keep all other bits of r/m32 and write result to r32.

pub fn blsr_Register64Bit_Any64BitMemory(
    &mut self,
    arg0: Register64Bit,
    arg1: Any64BitMemory
)

Reset lowest set bit of r/m64, keep all other bits of r/m64 and write result to r64.

pub fn blsr_Register64Bit_Register64Bit(
    &mut self,
    arg0: Register64Bit,
    arg1: Register64Bit
)

Reset lowest set bit of r/m64, keep all other bits of r/m64 and write result to r64.

pub fn bsf_Register16Bit_Any16BitMemory(
    &mut self,
    arg0: Register16Bit,
    arg1: Any16BitMemory
)

Bit scan forward on r/m16.

pub fn bsf_Register16Bit_Register16Bit(
    &mut self,
    arg0: Register16Bit,
    arg1: Register16Bit
)

Bit scan forward on r/m16.

pub fn bsf_Register32Bit_Any32BitMemory(
    &mut self,
    arg0: Register32Bit,
    arg1: Any32BitMemory
)

Bit scan forward on r/m32.

pub fn bsf_Register32Bit_Register32Bit(
    &mut self,
    arg0: Register32Bit,
    arg1: Register32Bit
)

Bit scan forward on r/m32.

pub fn bsf_Register64Bit_Any64BitMemory(
    &mut self,
    arg0: Register64Bit,
    arg1: Any64BitMemory
)

Bit scan forward on r/m64.

pub fn bsf_Register64Bit_Register64Bit(
    &mut self,
    arg0: Register64Bit,
    arg1: Register64Bit
)

Bit scan forward on r/m64.

pub fn bsr_Register16Bit_Any16BitMemory(
    &mut self,
    arg0: Register16Bit,
    arg1: Any16BitMemory
)

Bit scan reverse on r/m16.

pub fn bsr_Register16Bit_Register16Bit(
    &mut self,
    arg0: Register16Bit,
    arg1: Register16Bit
)

Bit scan reverse on r/m16.

pub fn bsr_Register32Bit_Any32BitMemory(
    &mut self,
    arg0: Register32Bit,
    arg1: Any32BitMemory
)

Bit scan reverse on r/m32.

pub fn bsr_Register32Bit_Register32Bit(
    &mut self,
    arg0: Register32Bit,
    arg1: Register32Bit
)

Bit scan reverse on r/m32.

pub fn bsr_Register64Bit_Any64BitMemory(
    &mut self,
    arg0: Register64Bit,
    arg1: Any64BitMemory
)

Bit scan reverse on r/m64.

pub fn bsr_Register64Bit_Register64Bit(
    &mut self,
    arg0: Register64Bit,
    arg1: Register64Bit
)

Bit scan reverse on r/m64.

pub fn bswap_Register32Bit(&mut self, arg0: Register32Bit)

Reverses the byte order of a 32-bit register.

pub fn bswap_Register64Bit(&mut self, arg0: Register64Bit)

Reverses the byte order of a 64-bit register.

pub fn bt_Any16BitMemory_Immediate8Bit(
    &mut self,
    arg0: Any16BitMemory,
    arg1: Immediate8Bit
)

Store selected bit in Carry Flag (CF).

pub fn bt_Any16BitMemory_Register16Bit(
    &mut self,
    arg0: Any16BitMemory,
    arg1: Register16Bit
)

Store selected bit in Carry Flag (CF).

pub fn bt_Any32BitMemory_Immediate8Bit(
    &mut self,
    arg0: Any32BitMemory,
    arg1: Immediate8Bit
)

Store selected bit in Carry Flag (CF).

pub fn bt_Any32BitMemory_Register32Bit(
    &mut self,
    arg0: Any32BitMemory,
    arg1: Register32Bit
)

Store selected bit in Carry Flag (CF).

pub fn bt_Any64BitMemory_Immediate8Bit(
    &mut self,
    arg0: Any64BitMemory,
    arg1: Immediate8Bit
)

Store selected bit in Carry Flag (CF).

pub fn bt_Any64BitMemory_Register64Bit(
    &mut self,
    arg0: Any64BitMemory,
    arg1: Register64Bit
)

Store selected bit in Carry Flag (CF).

pub fn bt_Register16Bit_Immediate8Bit(
    &mut self,
    arg0: Register16Bit,
    arg1: Immediate8Bit
)

Store selected bit in Carry Flag (CF).

pub fn bt_Register16Bit_Register16Bit(
    &mut self,
    arg0: Register16Bit,
    arg1: Register16Bit
)

Store selected bit in Carry Flag (CF).

pub fn bt_Register32Bit_Immediate8Bit(
    &mut self,
    arg0: Register32Bit,
    arg1: Immediate8Bit
)

Store selected bit in Carry Flag (CF).

pub fn bt_Register32Bit_Register32Bit(
    &mut self,
    arg0: Register32Bit,
    arg1: Register32Bit
)

Store selected bit in Carry Flag (CF).

pub fn bt_Register64Bit_Immediate8Bit(
    &mut self,
    arg0: Register64Bit,
    arg1: Immediate8Bit
)

Store selected bit in Carry Flag (CF).

pub fn bt_Register64Bit_Register64Bit(
    &mut self,
    arg0: Register64Bit,
    arg1: Register64Bit
)

Store selected bit in Carry Flag (CF).

pub fn btc_Any16BitMemory_Immediate8Bit(
    &mut self,
    arg0: Any16BitMemory,
    arg1: Immediate8Bit
)

Store selected bit in Carry Flag (CF) and complement.

pub fn btc_Any16BitMemory_Register16Bit(
    &mut self,
    arg0: Any16BitMemory,
    arg1: Register16Bit
)

Store selected bit in Carry Flag (CF) and complement.

pub fn btc_Any32BitMemory_Immediate8Bit(
    &mut self,
    arg0: Any32BitMemory,
    arg1: Immediate8Bit
)

Store selected bit in Carry Flag (CF) and complement.

pub fn btc_Any32BitMemory_Register32Bit(
    &mut self,
    arg0: Any32BitMemory,
    arg1: Register32Bit
)

Store selected bit in Carry Flag (CF) and complement.

pub fn btc_Any64BitMemory_Immediate8Bit(
    &mut self,
    arg0: Any64BitMemory,
    arg1: Immediate8Bit
)

Store selected bit in Carry Flag (CF) and complement.

pub fn btc_Any64BitMemory_Register64Bit(
    &mut self,
    arg0: Any64BitMemory,
    arg1: Register64Bit
)

Store selected bit in Carry Flag (CF) and complement.

pub fn btc_Register16Bit_Immediate8Bit(
    &mut self,
    arg0: Register16Bit,
    arg1: Immediate8Bit
)

Store selected bit in Carry Flag (CF) and complement.

pub fn btc_Register16Bit_Register16Bit(
    &mut self,
    arg0: Register16Bit,
    arg1: Register16Bit
)

Store selected bit in Carry Flag (CF) and complement.

pub fn btc_Register32Bit_Immediate8Bit(
    &mut self,
    arg0: Register32Bit,
    arg1: Immediate8Bit
)

Store selected bit in Carry Flag (CF) and complement.

pub fn btc_Register32Bit_Register32Bit(
    &mut self,
    arg0: Register32Bit,
    arg1: Register32Bit
)

Store selected bit in Carry Flag (CF) and complement.

pub fn btc_Register64Bit_Immediate8Bit(
    &mut self,
    arg0: Register64Bit,
    arg1: Immediate8Bit
)

Store selected bit in Carry Flag (CF) and complement.

pub fn btc_Register64Bit_Register64Bit(
    &mut self,
    arg0: Register64Bit,
    arg1: Register64Bit
)

Store selected bit in Carry Flag (CF) and complement.

pub fn btr_Any16BitMemory_Immediate8Bit(
    &mut self,
    arg0: Any16BitMemory,
    arg1: Immediate8Bit
)

Store selected bit in Carry Flag (CF) and clear.

pub fn btr_Any16BitMemory_Register16Bit(
    &mut self,
    arg0: Any16BitMemory,
    arg1: Register16Bit
)

Store selected bit in Carry Flag (CF) and clear.

pub fn btr_Any32BitMemory_Immediate8Bit(
    &mut self,
    arg0: Any32BitMemory,
    arg1: Immediate8Bit
)

Store selected bit in Carry Flag (CF) and clear.

pub fn btr_Any32BitMemory_Register32Bit(
    &mut self,
    arg0: Any32BitMemory,
    arg1: Register32Bit
)

Store selected bit in Carry Flag (CF) and clear.

pub fn btr_Any64BitMemory_Immediate8Bit(
    &mut self,
    arg0: Any64BitMemory,
    arg1: Immediate8Bit
)

Store selected bit in Carry Flag (CF) and clear.

pub fn btr_Any64BitMemory_Register64Bit(
    &mut self,
    arg0: Any64BitMemory,
    arg1: Register64Bit
)

Store selected bit in Carry Flag (CF) and clear.

pub fn btr_Register16Bit_Immediate8Bit(
    &mut self,
    arg0: Register16Bit,
    arg1: Immediate8Bit
)

Store selected bit in Carry Flag (CF) and clear.

pub fn btr_Register16Bit_Register16Bit(
    &mut self,
    arg0: Register16Bit,
    arg1: Register16Bit
)

Store selected bit in Carry Flag (CF) and clear.

pub fn btr_Register32Bit_Immediate8Bit(
    &mut self,
    arg0: Register32Bit,
    arg1: Immediate8Bit
)

Store selected bit in Carry Flag (CF) and clear.

pub fn btr_Register32Bit_Register32Bit(
    &mut self,
    arg0: Register32Bit,
    arg1: Register32Bit
)

Store selected bit in Carry Flag (CF) and clear.

pub fn btr_Register64Bit_Immediate8Bit(
    &mut self,
    arg0: Register64Bit,
    arg1: Immediate8Bit
)

Store selected bit in Carry Flag (CF) and clear.

pub fn btr_Register64Bit_Register64Bit(
    &mut self,
    arg0: Register64Bit,
    arg1: Register64Bit
)

Store selected bit in Carry Flag (CF) and clear.

pub fn bts_Any16BitMemory_Immediate8Bit(
    &mut self,
    arg0: Any16BitMemory,
    arg1: Immediate8Bit
)

Store selected bit in Carry Flag (CF) and set.

pub fn bts_Any16BitMemory_Register16Bit(
    &mut self,
    arg0: Any16BitMemory,
    arg1: Register16Bit
)

Store selected bit in Carry Flag (CF) and set.

pub fn bts_Any32BitMemory_Immediate8Bit(
    &mut self,
    arg0: Any32BitMemory,
    arg1: Immediate8Bit
)

Store selected bit in Carry Flag (CF) and set.

pub fn bts_Any32BitMemory_Register32Bit(
    &mut self,
    arg0: Any32BitMemory,
    arg1: Register32Bit
)

Store selected bit in Carry Flag (CF) and set.

pub fn bts_Any64BitMemory_Immediate8Bit(
    &mut self,
    arg0: Any64BitMemory,
    arg1: Immediate8Bit
)

Store selected bit in Carry Flag (CF) and set.

pub fn bts_Any64BitMemory_Register64Bit(
    &mut self,
    arg0: Any64BitMemory,
    arg1: Register64Bit
)

Store selected bit in Carry Flag (CF) and set.

pub fn bts_Register16Bit_Immediate8Bit(
    &mut self,
    arg0: Register16Bit,
    arg1: Immediate8Bit
)

Store selected bit in Carry Flag (CF) and set.

pub fn bts_Register16Bit_Register16Bit(
    &mut self,
    arg0: Register16Bit,
    arg1: Register16Bit
)

Store selected bit in Carry Flag (CF) and set.

pub fn bts_Register32Bit_Immediate8Bit(
    &mut self,
    arg0: Register32Bit,
    arg1: Immediate8Bit
)

Store selected bit in Carry Flag (CF) and set.

pub fn bts_Register32Bit_Register32Bit(
    &mut self,
    arg0: Register32Bit,
    arg1: Register32Bit
)

Store selected bit in Carry Flag (CF) and set.

pub fn bts_Register64Bit_Immediate8Bit(
    &mut self,
    arg0: Register64Bit,
    arg1: Immediate8Bit
)

Store selected bit in Carry Flag (CF) and set.

pub fn bts_Register64Bit_Register64Bit(
    &mut self,
    arg0: Register64Bit,
    arg1: Register64Bit
)

Store selected bit in Carry Flag (CF) and set.

pub fn bzhi_Register32Bit_Any32BitMemory_Register32Bit(
    &mut self,
    arg0: Register32Bit,
    arg1: Any32BitMemory,
    arg2: Register32Bit
)

Zero bits in r/m32 starting with the position in r32b, write result to r32a.

pub fn bzhi_Register32Bit_Register32Bit_Register32Bit(
    &mut self,
    arg0: Register32Bit,
    arg1: Register32Bit,
    arg2: Register32Bit
)

Zero bits in r/m32 starting with the position in r32b, write result to r32a.

pub fn bzhi_Register64Bit_Any64BitMemory_Register64Bit(
    &mut self,
    arg0: Register64Bit,
    arg1: Any64BitMemory,
    arg2: Register64Bit
)

Zero bits in r/m64 starting with the position in r64b, write result to r64a.

pub fn bzhi_Register64Bit_Register64Bit_Register64Bit(
    &mut self,
    arg0: Register64Bit,
    arg1: Register64Bit,
    arg2: Register64Bit
)

Zero bits in r/m64 starting with the position in r64b, write result to r64a.

pub fn call_FarPointer16BitTo16BitMemory(
    &mut self,
    arg0: FarPointer16BitTo16BitMemory
)

Call far, absolute indirect address given in m16:16.

In 32-bit mode: if selector points to a gate, then RIP = 32-bit zero extended displacement taken from gate else RIP = zero extended 16-bit offset from far pointer referenced in the instruction.

pub fn call_FarPointer16BitTo32BitMemory(
    &mut self,
    arg0: FarPointer16BitTo32BitMemory
)

Call far, absolute indirect address given in m16:32.

In 64-bit mode: If selector points to a gate, then RIP = 64-bit displacement taken from gate else RIP = zero extended 32-bit offset from far pointer referenced in the instruction.

pub fn call_FarPointer16BitTo64BitMemory(
    &mut self,
    arg0: FarPointer16BitTo64BitMemory
)

Call far, absolute indirect address given in m16:64.

In 64-bit mode: If selector points to a gate, then RIP = 64-bit displacement taken from gate else RIP = 64-bit offset from far pointer referenced in the instruction.

pub fn call_Label(&mut self, arg0: Label)

Call near, relative, displacement relative to next instruction.

32-bit displacement sign extended to 64-bits in 64-bit mode.

Identical encoding to call_function and call_RelativeAddress32Bit.

pub fn call_Any64BitMemory(&mut self, arg0: Any64BitMemory)

Call near, absolute indirect, address given in r/m64.

pub fn call_Register64Bit(&mut self, arg0: Register64Bit)

Call near, absolute indirect, address given in r64.

pub fn call_function(&mut self, function_pointer: impl FunctionPointer)

Call near, relative, displacement relative to next instruction.

32-bit displacement sign extended to 64-bits in 64-bit mode.

Identical encoding to call_Label and call_RelativeAddress32Bit.

WARNING: The location of emitted code may be such that if it is more than 2Gb away from common library function calls (eg printf); it may be preferrable to use an absolute address indirectly in this case, eg call_Register64Bit or call_Any64BitMemory.

WARNING: No checks are made for addresses that would exceed the boundaries of signed integers…

WARNING: In Kernel-model code, addresses are in the top half of the address space and so this function will be invalid.

pub fn call_RelativeAddress32Bit(&mut self, arg0: RelativeAddress32Bit)

Call near, relative, displacement relative to next instruction.

32-bit displacement sign extended to 64-bits in 64-bit mode.

Identical encoding to call_Label and call_function.

pub fn cbw(&mut self)

AX = sign-extend of AL.

pub fn cdq(&mut self)

EDX:EAX = sign-extend of EAX.

pub fn cdqe(&mut self)

RAX = sign-extend of EAX.

pub fn clc(&mut self)

Clear Carry Flag (CF).

pub fn cld(&mut self)

Clear Direction Flag (DF).

pub fn clflush_Any8BitMemory(&mut self, arg0: Any8BitMemory)

Flushes cache line containing m8.

pub fn cli(&mut self)

Clear interrupt flag; interrupts disabled when interrupt flag cleared.

pub fn cmc(&mut self)

Complement Carry Flag (CF).

pub fn cmova_Register16Bit_Any16BitMemory(
    &mut self,
    arg0: Register16Bit,
    arg1: Any16BitMemory
)

Move if above (Carry Flag (CF) is 0 and Zero Flag (ZF) is 0).

pub fn cmova_Register16Bit_Register16Bit(
    &mut self,
    arg0: Register16Bit,
    arg1: Register16Bit
)

Move if above (Carry Flag (CF) is 0 and Zero Flag (ZF) is 0).

pub fn cmova_Register32Bit_Any32BitMemory(
    &mut self,
    arg0: Register32Bit,
    arg1: Any32BitMemory
)

Move if above (Carry Flag (CF) is 0 and Zero Flag (ZF) is 0).

pub fn cmova_Register32Bit_Register32Bit(
    &mut self,
    arg0: Register32Bit,
    arg1: Register32Bit
)

Move if above (Carry Flag (CF) is 0 and Zero Flag (ZF) is 0).

pub fn cmova_Register64Bit_Any64BitMemory(
    &mut self,
    arg0: Register64Bit,
    arg1: Any64BitMemory
)

Move if above (Carry Flag (CF) is 0 and Zero Flag (ZF) is 0).

pub fn cmova_Register64Bit_Register64Bit(
    &mut self,
    arg0: Register64Bit,
    arg1: Register64Bit
)

Move if above (Carry Flag (CF) is 0 and Zero Flag (ZF) is 0).

pub fn cmovae_Register16Bit_Any16BitMemory(
    &mut self,
    arg0: Register16Bit,
    arg1: Any16BitMemory
)

Move if above or equal (Carry Flag (CF) is 0).

pub fn cmovae_Register16Bit_Register16Bit(
    &mut self,
    arg0: Register16Bit,
    arg1: Register16Bit
)

Move if above or equal (Carry Flag (CF) is 0).

pub fn cmovae_Register32Bit_Any32BitMemory(
    &mut self,
    arg0: Register32Bit,
    arg1: Any32BitMemory
)

Move if above or equal (Carry Flag (CF) is 0).

pub fn cmovae_Register32Bit_Register32Bit(
    &mut self,
    arg0: Register32Bit,
    arg1: Register32Bit
)

Move if above or equal (Carry Flag (CF) is 0).

pub fn cmovae_Register64Bit_Any64BitMemory(
    &mut self,
    arg0: Register64Bit,
    arg1: Any64BitMemory
)

Move if above or equal (Carry Flag (CF) is 0).

pub fn cmovae_Register64Bit_Register64Bit(
    &mut self,
    arg0: Register64Bit,
    arg1: Register64Bit
)

Move if above or equal (Carry Flag (CF) is 0).

pub fn cmovb_Register16Bit_Any16BitMemory(
    &mut self,
    arg0: Register16Bit,
    arg1: Any16BitMemory
)

Move if below (Carry Flag (CF) is 1).

pub fn cmovb_Register16Bit_Register16Bit(
    &mut self,
    arg0: Register16Bit,
    arg1: Register16Bit
)

Move if below (Carry Flag (CF) is 1).

pub fn cmovb_Register32Bit_Any32BitMemory(
    &mut self,
    arg0: Register32Bit,
    arg1: Any32BitMemory
)

Move if below (Carry Flag (CF) is 1).

pub fn cmovb_Register32Bit_Register32Bit(
    &mut self,
    arg0: Register32Bit,
    arg1: Register32Bit
)

Move if below (Carry Flag (CF) is 1).

pub fn cmovb_Register64Bit_Any64BitMemory(
    &mut self,
    arg0: Register64Bit,
    arg1: Any64BitMemory
)

Move if below (Carry Flag (CF) is 1).

pub fn cmovb_Register64Bit_Register64Bit(
    &mut self,
    arg0: Register64Bit,
    arg1: Register64Bit
)

Move if below (Carry Flag (CF) is 1).

pub fn cmovbe_Register16Bit_Any16BitMemory(
    &mut self,
    arg0: Register16Bit,
    arg1: Any16BitMemory
)

Move if below or equal (Carry Flag (CF) is 1 or Zero Flag (ZF) is 1).

pub fn cmovbe_Register16Bit_Register16Bit(
    &mut self,
    arg0: Register16Bit,
    arg1: Register16Bit
)

Move if below or equal (Carry Flag (CF) is 1 or Zero Flag (ZF) is 1).

pub fn cmovbe_Register32Bit_Any32BitMemory(
    &mut self,
    arg0: Register32Bit,
    arg1: Any32BitMemory
)

Move if below or equal (Carry Flag (CF) is 1 or Zero Flag (ZF) is 1).

pub fn cmovbe_Register32Bit_Register32Bit(
    &mut self,
    arg0: Register32Bit,
    arg1: Register32Bit
)

Move if below or equal (Carry Flag (CF) is 1 or Zero Flag (ZF) is 1).

pub fn cmovbe_Register64Bit_Any64BitMemory(
    &mut self,
    arg0: Register64Bit,
    arg1: Any64BitMemory
)

Move if below or equal (Carry Flag (CF) is 1 or Zero Flag (ZF) is 1).

pub fn cmovbe_Register64Bit_Register64Bit(
    &mut self,
    arg0: Register64Bit,
    arg1: Register64Bit
)

Move if below or equal (Carry Flag (CF) is 1 or Zero Flag (ZF) is 1).

pub fn cmovc_Register16Bit_Any16BitMemory(
    &mut self,
    arg0: Register16Bit,
    arg1: Any16BitMemory
)

Move if carry (Carry Flag (CF) is 1).

pub fn cmovc_Register16Bit_Register16Bit(
    &mut self,
    arg0: Register16Bit,
    arg1: Register16Bit
)

Move if carry (Carry Flag (CF) is 1).

pub fn cmovc_Register32Bit_Any32BitMemory(
    &mut self,
    arg0: Register32Bit,
    arg1: Any32BitMemory
)

Move if carry (Carry Flag (CF) is 1).

pub fn cmovc_Register32Bit_Register32Bit(
    &mut self,
    arg0: Register32Bit,
    arg1: Register32Bit
)

Move if carry (Carry Flag (CF) is 1).

pub fn cmovc_Register64Bit_Any64BitMemory(
    &mut self,
    arg0: Register64Bit,
    arg1: Any64BitMemory
)

Move if carry (Carry Flag (CF) is 1).

pub fn cmovc_Register64Bit_Register64Bit(
    &mut self,
    arg0: Register64Bit,
    arg1: Register64Bit
)

Move if carry (Carry Flag (CF) is 1).

pub fn cmove_Register16Bit_Any16BitMemory(
    &mut self,
    arg0: Register16Bit,
    arg1: Any16BitMemory
)

Move if equal (Zero Flag (ZF) is 1).

pub fn cmove_Register16Bit_Register16Bit(
    &mut self,
    arg0: Register16Bit,
    arg1: Register16Bit
)

Move if equal (Zero Flag (ZF) is 1).

pub fn cmove_Register32Bit_Any32BitMemory(
    &mut self,
    arg0: Register32Bit,
    arg1: Any32BitMemory
)

Move if equal (Zero Flag (ZF) is 1).

pub fn cmove_Register32Bit_Register32Bit(
    &mut self,
    arg0: Register32Bit,
    arg1: Register32Bit
)

Move if equal (Zero Flag (ZF) is 1).

pub fn cmove_Register64Bit_Any64BitMemory(
    &mut self,
    arg0: Register64Bit,
    arg1: Any64BitMemory
)

Move if equal (Zero Flag (ZF) is 1).

pub fn cmove_Register64Bit_Register64Bit(
    &mut self,
    arg0: Register64Bit,
    arg1: Register64Bit
)

Move if equal (Zero Flag (ZF) is 1).

pub fn cmovg_Register16Bit_Any16BitMemory(
    &mut self,
    arg0: Register16Bit,
    arg1: Any16BitMemory
)

Move if greater (Zero Flag (ZF) is 0 and Sign Flag (SF) == Overflow Flag (OF)).

pub fn cmovg_Register16Bit_Register16Bit(
    &mut self,
    arg0: Register16Bit,
    arg1: Register16Bit
)

Move if greater (Zero Flag (ZF) is 0 and Sign Flag (SF) == Overflow Flag (OF)).

pub fn cmovg_Register32Bit_Any32BitMemory(
    &mut self,
    arg0: Register32Bit,
    arg1: Any32BitMemory
)

Move if greater (Zero Flag (ZF) is 0 and Sign Flag (SF) == Overflow Flag (OF)).

pub fn cmovg_Register32Bit_Register32Bit(
    &mut self,
    arg0: Register32Bit,
    arg1: Register32Bit
)

Move if greater (Zero Flag (ZF) is 0 and Sign Flag (SF) == Overflow Flag (OF)).

pub fn cmovg_Register64Bit_Any64BitMemory(
    &mut self,
    arg0: Register64Bit,
    arg1: Any64BitMemory
)

Move if greater (Zero Flag (ZF) is 0 and Sign Flag (SF) == Overflow Flag (OF)).

pub fn cmovg_Register64Bit_Register64Bit(
    &mut self,
    arg0: Register64Bit,
    arg1: Register64Bit
)

Move if greater (Zero Flag (ZF) is 0 and Sign Flag (SF) == Overflow Flag (OF)).

pub fn cmovge_Register16Bit_Any16BitMemory(
    &mut self,
    arg0: Register16Bit,
    arg1: Any16BitMemory
)

Move if greater or equal (Sign Flag (SF) == Overflow Flag (OF)).

pub fn cmovge_Register16Bit_Register16Bit(
    &mut self,
    arg0: Register16Bit,
    arg1: Register16Bit
)

Move if greater or equal (Sign Flag (SF) == Overflow Flag (OF)).

pub fn cmovge_Register32Bit_Any32BitMemory(
    &mut self,
    arg0: Register32Bit,
    arg1: Any32BitMemory
)

Move if greater or equal (Sign Flag (SF) == Overflow Flag (OF)).

pub fn cmovge_Register32Bit_Register32Bit(
    &mut self,
    arg0: Register32Bit,
    arg1: Register32Bit
)

Move if greater or equal (Sign Flag (SF) == Overflow Flag (OF)).

pub fn cmovge_Register64Bit_Any64BitMemory(
    &mut self,
    arg0: Register64Bit,
    arg1: Any64BitMemory
)

Move if greater or equal (Sign Flag (SF) == Overflow Flag (OF)).

pub fn cmovge_Register64Bit_Register64Bit(
    &mut self,
    arg0: Register64Bit,
    arg1: Register64Bit
)

Move if greater or equal (Sign Flag (SF) == Overflow Flag (OF)).

pub fn cmovl_Register16Bit_Any16BitMemory(
    &mut self,
    arg0: Register16Bit,
    arg1: Any16BitMemory
)

Move if less (Sign Flag (SF) != Overflow Flag (OF)).

pub fn cmovl_Register16Bit_Register16Bit(
    &mut self,
    arg0: Register16Bit,
    arg1: Register16Bit
)

Move if less (Sign Flag (SF) != Overflow Flag (OF)).

pub fn cmovl_Register32Bit_Any32BitMemory(
    &mut self,
    arg0: Register32Bit,
    arg1: Any32BitMemory
)

Move if less (Sign Flag (SF) != Overflow Flag (OF)).

pub fn cmovl_Register32Bit_Register32Bit(
    &mut self,
    arg0: Register32Bit,
    arg1: Register32Bit
)

Move if less (Sign Flag (SF) != Overflow Flag (OF)).

pub fn cmovl_Register64Bit_Any64BitMemory(
    &mut self,
    arg0: Register64Bit,
    arg1: Any64BitMemory
)

Move if less (Sign Flag (SF) != Overflow Flag (OF)).

pub fn cmovl_Register64Bit_Register64Bit(
    &mut self,
    arg0: Register64Bit,
    arg1: Register64Bit
)

Move if less (Sign Flag (SF) != Overflow Flag (OF)).

pub fn cmovle_Register16Bit_Any16BitMemory(
    &mut self,
    arg0: Register16Bit,
    arg1: Any16BitMemory
)

Move if less or equal (Zero Flag (ZF) is 1 or Sign Flag (SF) != Overflow Flag (OF)).

pub fn cmovle_Register16Bit_Register16Bit(
    &mut self,
    arg0: Register16Bit,
    arg1: Register16Bit
)

Move if less or equal (Zero Flag (ZF) is 1 or Sign Flag (SF) != Overflow Flag (OF)).

pub fn cmovle_Register32Bit_Any32BitMemory(
    &mut self,
    arg0: Register32Bit,
    arg1: Any32BitMemory
)

Move if less or equal (Zero Flag (ZF) is 1 or Sign Flag (SF) != Overflow Flag (OF)).

pub fn cmovle_Register32Bit_Register32Bit(
    &mut self,
    arg0: Register32Bit,
    arg1: Register32Bit
)

Move if less or equal (Zero Flag (ZF) is 1 or Sign Flag (SF) != Overflow Flag (OF)).

pub fn cmovle_Register64Bit_Any64BitMemory(
    &mut self,
    arg0: Register64Bit,
    arg1: Any64BitMemory
)

Move if less or equal (Zero Flag (ZF) is 1 or Sign Flag (SF) != Overflow Flag (OF)).

pub fn cmovle_Register64Bit_Register64Bit(
    &mut self,
    arg0: Register64Bit,
    arg1: Register64Bit
)

Move if less or equal (Zero Flag (ZF) is 1 or Sign Flag (SF) != Overflow Flag (OF)).

pub fn cmovna_Register16Bit_Any16BitMemory(
    &mut self,
    arg0: Register16Bit,
    arg1: Any16BitMemory
)

Move if not above (Carry Flag (CF) is 1 or Zero Flag (ZF) is 1).

pub fn cmovna_Register16Bit_Register16Bit(
    &mut self,
    arg0: Register16Bit,
    arg1: Register16Bit
)

Move if not above (Carry Flag (CF) is 1 or Zero Flag (ZF) is 1).

pub fn cmovna_Register32Bit_Any32BitMemory(
    &mut self,
    arg0: Register32Bit,
    arg1: Any32BitMemory
)

Move if not above (Carry Flag (CF) is 1 or Zero Flag (ZF) is 1).

pub fn cmovna_Register32Bit_Register32Bit(
    &mut self,
    arg0: Register32Bit,
    arg1: Register32Bit
)

Move if not above (Carry Flag (CF) is 1 or Zero Flag (ZF) is 1).

pub fn cmovna_Register64Bit_Any64BitMemory(
    &mut self,
    arg0: Register64Bit,
    arg1: Any64BitMemory
)

Move if not above (Carry Flag (CF) is 1 or Zero Flag (ZF) is 1).

pub fn cmovna_Register64Bit_Register64Bit(
    &mut self,
    arg0: Register64Bit,
    arg1: Register64Bit
)

Move if not above (Carry Flag (CF) is 1 or Zero Flag (ZF) is 1).

pub fn cmovnae_Register16Bit_Any16BitMemory(
    &mut self,
    arg0: Register16Bit,
    arg1: Any16BitMemory
)

Move if not above or equal (Carry Flag (CF) is 1).

pub fn cmovnae_Register16Bit_Register16Bit(
    &mut self,
    arg0: Register16Bit,
    arg1: Register16Bit
)

Move if not above or equal (Carry Flag (CF) is 1).

pub fn cmovnae_Register32Bit_Any32BitMemory(
    &mut self,
    arg0: Register32Bit,
    arg1: Any32BitMemory
)

Move if not above or equal (Carry Flag (CF) is 1).

pub fn cmovnae_Register32Bit_Register32Bit(
    &mut self,
    arg0: Register32Bit,
    arg1: Register32Bit
)

Move if not above or equal (Carry Flag (CF) is 1).

pub fn cmovnae_Register64Bit_Any64BitMemory(
    &mut self,
    arg0: Register64Bit,
    arg1: Any64BitMemory
)

Move if not above or equal (Carry Flag (CF) is 1).

pub fn cmovnae_Register64Bit_Register64Bit(
    &mut self,
    arg0: Register64Bit,
    arg1: Register64Bit
)

Move if not above or equal (Carry Flag (CF) is 1).

pub fn cmovnb_Register16Bit_Any16BitMemory(
    &mut self,
    arg0: Register16Bit,
    arg1: Any16BitMemory
)

Move if not below (Carry Flag (CF) is 0).

pub fn cmovnb_Register16Bit_Register16Bit(
    &mut self,
    arg0: Register16Bit,
    arg1: Register16Bit
)

Move if not below (Carry Flag (CF) is 0).

pub fn cmovnb_Register32Bit_Any32BitMemory(
    &mut self,
    arg0: Register32Bit,
    arg1: Any32BitMemory
)

Move if not below (Carry Flag (CF) is 0).

pub fn cmovnb_Register32Bit_Register32Bit(
    &mut self,
    arg0: Register32Bit,
    arg1: Register32Bit
)

Move if not below (Carry Flag (CF) is 0).

pub fn cmovnb_Register64Bit_Any64BitMemory(
    &mut self,
    arg0: Register64Bit,
    arg1: Any64BitMemory
)

Move if not below (Carry Flag (CF) is 0).

pub fn cmovnb_Register64Bit_Register64Bit(
    &mut self,
    arg0: Register64Bit,
    arg1: Register64Bit
)

Move if not below (Carry Flag (CF) is 0).

pub fn cmovnbe_Register16Bit_Any16BitMemory(
    &mut self,
    arg0: Register16Bit,
    arg1: Any16BitMemory
)

Move if not below or equal (Carry Flag (CF) is 0 and Zero Flag (ZF) is 0).

pub fn cmovnbe_Register16Bit_Register16Bit(
    &mut self,
    arg0: Register16Bit,
    arg1: Register16Bit
)

Move if not below or equal (Carry Flag (CF) is 0 and Zero Flag (ZF) is 0).

pub fn cmovnbe_Register32Bit_Any32BitMemory(
    &mut self,
    arg0: Register32Bit,
    arg1: Any32BitMemory
)

Move if not below or equal (Carry Flag (CF) is 0 and Zero Flag (ZF) is 0).

pub fn cmovnbe_Register32Bit_Register32Bit(
    &mut self,
    arg0: Register32Bit,
    arg1: Register32Bit
)

Move if not below or equal (Carry Flag (CF) is 0 and Zero Flag (ZF) is 0).

pub fn cmovnbe_Register64Bit_Any64BitMemory(
    &mut self,
    arg0: Register64Bit,
    arg1: Any64BitMemory
)

Move if not below or equal (Carry Flag (CF) is 0 and Zero Flag (ZF) is 0).

pub fn cmovnbe_Register64Bit_Register64Bit(
    &mut self,
    arg0: Register64Bit,
    arg1: Register64Bit
)

Move if not below or equal (Carry Flag (CF) is 0 and Zero Flag (ZF) is 0).

pub fn cmovnc_Register16Bit_Any16BitMemory(
    &mut self,
    arg0: Register16Bit,
    arg1: Any16BitMemory
)

Move if not carry (Carry Flag (CF) is 0).

pub fn cmovnc_Register16Bit_Register16Bit(
    &mut self,
    arg0: Register16Bit,
    arg1: Register16Bit
)

Move if not carry (Carry Flag (CF) is 0).

pub fn cmovnc_Register32Bit_Any32BitMemory(
    &mut self,
    arg0: Register32Bit,
    arg1: Any32BitMemory
)

Move if not carry (Carry Flag (CF) is 0).

pub fn cmovnc_Register32Bit_Register32Bit(
    &mut self,
    arg0: Register32Bit,
    arg1: Register32Bit
)

Move if not carry (Carry Flag (CF) is 0).

pub fn cmovnc_Register64Bit_Any64BitMemory(
    &mut self,
    arg0: Register64Bit,
    arg1: Any64BitMemory
)

Move if not carry (Carry Flag (CF) is 0).

pub fn cmovnc_Register64Bit_Register64Bit(
    &mut self,
    arg0: Register64Bit,
    arg1: Register64Bit
)

Move if not carry (Carry Flag (CF) is 0).

pub fn cmovne_Register16Bit_Any16BitMemory(
    &mut self,
    arg0: Register16Bit,
    arg1: Any16BitMemory
)

Move if not equal (Zero Flag (ZF) is 0).

pub fn cmovne_Register16Bit_Register16Bit(
    &mut self,
    arg0: Register16Bit,
    arg1: Register16Bit
)

Move if not equal (Zero Flag (ZF) is 0).

pub fn cmovne_Register32Bit_Any32BitMemory(
    &mut self,
    arg0: Register32Bit,
    arg1: Any32BitMemory
)

Move if not equal (Zero Flag (ZF) is 0).

pub fn cmovne_Register32Bit_Register32Bit(
    &mut self,
    arg0: Register32Bit,
    arg1: Register32Bit
)

Move if not equal (Zero Flag (ZF) is 0).

pub fn cmovne_Register64Bit_Any64BitMemory(
    &mut self,
    arg0: Register64Bit,
    arg1: Any64BitMemory
)

Move if not equal (Zero Flag (ZF) is 0).

pub fn cmovne_Register64Bit_Register64Bit(
    &mut self,
    arg0: Register64Bit,
    arg1: Register64Bit
)

Move if not equal (Zero Flag (ZF) is 0).

pub fn cmovng_Register16Bit_Any16BitMemory(
    &mut self,
    arg0: Register16Bit,
    arg1: Any16BitMemory
)

Move if not greater (Zero Flag (ZF) is 1 or Sign Flag (SF) != Overflow Flag (OF)).

pub fn cmovng_Register16Bit_Register16Bit(
    &mut self,
    arg0: Register16Bit,
    arg1: Register16Bit
)

Move if not greater (Zero Flag (ZF) is 1 or Sign Flag (SF) != Overflow Flag (OF)).

pub fn cmovng_Register32Bit_Any32BitMemory(
    &mut self,
    arg0: Register32Bit,
    arg1: Any32BitMemory
)

Move if not greater (Zero Flag (ZF) is 1 or Sign Flag (SF) != Overflow Flag (OF)).

pub fn cmovng_Register32Bit_Register32Bit(
    &mut self,
    arg0: Register32Bit,
    arg1: Register32Bit
)

Move if not greater (Zero Flag (ZF) is 1 or Sign Flag (SF) != Overflow Flag (OF)).

pub fn cmovng_Register64Bit_Any64BitMemory(
    &mut self,
    arg0: Register64Bit,
    arg1: Any64BitMemory
)

Move if not greater (Zero Flag (ZF) is 1 or Sign Flag (SF) != Overflow Flag (OF)).

pub fn cmovng_Register64Bit_Register64Bit(
    &mut self,
    arg0: Register64Bit,
    arg1: Register64Bit
)

Move if not greater (Zero Flag (ZF) is 1 or Sign Flag (SF) != Overflow Flag (OF)).

pub fn cmovnge_Register16Bit_Any16BitMemory(
    &mut self,
    arg0: Register16Bit,
    arg1: Any16BitMemory
)

Move if not greater or equal (Sign Flag (SF) != Overflow Flag (OF)).

pub fn cmovnge_Register16Bit_Register16Bit(
    &mut self,
    arg0: Register16Bit,
    arg1: Register16Bit
)

Move if not greater or equal (Sign Flag (SF) != Overflow Flag (OF)).

pub fn cmovnge_Register32Bit_Any32BitMemory(
    &mut self,
    arg0: Register32Bit,
    arg1: Any32BitMemory
)

Move if not greater or equal (Sign Flag (SF) != Overflow Flag (OF)).

pub fn cmovnge_Register32Bit_Register32Bit(
    &mut self,
    arg0: Register32Bit,
    arg1: Register32Bit
)

Move if not greater or equal (Sign Flag (SF) != Overflow Flag (OF)).

pub fn cmovnge_Register64Bit_Any64BitMemory(
    &mut self,
    arg0: Register64Bit,
    arg1: Any64BitMemory
)

Move if not greater or equal (Sign Flag (SF) != Overflow Flag (OF)).

pub fn cmovnge_Register64Bit_Register64Bit(
    &mut self,
    arg0: Register64Bit,
    arg1: Register64Bit
)

Move if not greater or equal (Sign Flag (SF) != Overflow Flag (OF)).

pub fn cmovnl_Register16Bit_Any16BitMemory(
    &mut self,
    arg0: Register16Bit,
    arg1: Any16BitMemory
)

Move if not less (Sign Flag (SF) == Overflow Flag (OF)).

pub fn cmovnl_Register16Bit_Register16Bit(
    &mut self,
    arg0: Register16Bit,
    arg1: Register16Bit
)

Move if not less (Sign Flag (SF) == Overflow Flag (OF)).

pub fn cmovnl_Register32Bit_Any32BitMemory(
    &mut self,
    arg0: Register32Bit,
    arg1: Any32BitMemory
)

Move if not less (Sign Flag (SF) == Overflow Flag (OF)).

pub fn cmovnl_Register32Bit_Register32Bit(
    &mut self,
    arg0: Register32Bit,
    arg1: Register32Bit
)

Move if not less (Sign Flag (SF) == Overflow Flag (OF)).

pub fn cmovnl_Register64Bit_Any64BitMemory(
    &mut self,
    arg0: Register64Bit,
    arg1: Any64BitMemory
)

Move if not less (Sign Flag (SF) == Overflow Flag (OF)).

pub fn cmovnl_Register64Bit_Register64Bit(
    &mut self,
    arg0: Register64Bit,
    arg1: Register64Bit
)

Move if not less (Sign Flag (SF) == Overflow Flag (OF)).

pub fn cmovnle_Register16Bit_Any16BitMemory(
    &mut self,
    arg0: Register16Bit,
    arg1: Any16BitMemory
)

Move if not less or equal (Zero Flag (ZF) is 0 and Sign Flag (SF) == Overflow Flag (OF)).

pub fn cmovnle_Register16Bit_Register16Bit(
    &mut self,
    arg0: Register16Bit,
    arg1: Register16Bit
)

Move if not less or equal (Zero Flag (ZF) is 0 and Sign Flag (SF) == Overflow Flag (OF)).

pub fn cmovnle_Register32Bit_Any32BitMemory(
    &mut self,
    arg0: Register32Bit,
    arg1: Any32BitMemory
)

Move if not less or equal (Zero Flag (ZF) is 0 and Sign Flag (SF) == Overflow Flag (OF)).

pub fn cmovnle_Register32Bit_Register32Bit(
    &mut self,
    arg0: Register32Bit,
    arg1: Register32Bit
)

Move if not less or equal (Zero Flag (ZF) is 0 and Sign Flag (SF) == Overflow Flag (OF)).

pub fn cmovnle_Register64Bit_Any64BitMemory(
    &mut self,
    arg0: Register64Bit,
    arg1: Any64BitMemory
)

Move if not less or equal (Zero Flag (ZF) is 0 and Sign Flag (SF) == Overflow Flag (OF)).

pub fn cmovnle_Register64Bit_Register64Bit(
    &mut self,
    arg0: Register64Bit,
    arg1: Register64Bit
)

Move if not less or equal (Zero Flag (ZF) is 0 and Sign Flag (SF) == Overflow Flag (OF)).

pub fn cmovno_Register16Bit_Any16BitMemory(
    &mut self,
    arg0: Register16Bit,
    arg1: Any16BitMemory
)

Move if not overflow (Overflow Flag (OF) is 0).

pub fn cmovno_Register16Bit_Register16Bit(
    &mut self,
    arg0: Register16Bit,
    arg1: Register16Bit
)

Move if not overflow (Overflow Flag (OF) is 0).

pub fn cmovno_Register32Bit_Any32BitMemory(
    &mut self,
    arg0: Register32Bit,
    arg1: Any32BitMemory
)

Move if not overflow (Overflow Flag (OF) is 0).

pub fn cmovno_Register32Bit_Register32Bit(
    &mut self,
    arg0: Register32Bit,
    arg1: Register32Bit
)

Move if not overflow (Overflow Flag (OF) is 0).

pub fn cmovno_Register64Bit_Any64BitMemory(
    &mut self,
    arg0: Register64Bit,
    arg1: Any64BitMemory
)

Move if not overflow (Overflow Flag (OF) is 0).

pub fn cmovno_Register64Bit_Register64Bit(
    &mut self,
    arg0: Register64Bit,
    arg1: Register64Bit
)

Move if not overflow (Overflow Flag (OF) is 0).

pub fn cmovnp_Register16Bit_Any16BitMemory(
    &mut self,
    arg0: Register16Bit,
    arg1: Any16BitMemory
)

Move if not parity (Parity Flag (PF) is 0).

pub fn cmovnp_Register16Bit_Register16Bit(
    &mut self,
    arg0: Register16Bit,
    arg1: Register16Bit
)

Move if not parity (Parity Flag (PF) is 0).

pub fn cmovnp_Register32Bit_Any32BitMemory(
    &mut self,
    arg0: Register32Bit,
    arg1: Any32BitMemory
)

Move if not parity (Parity Flag (PF) is 0).

pub fn cmovnp_Register32Bit_Register32Bit(
    &mut self,
    arg0: Register32Bit,
    arg1: Register32Bit
)

Move if not parity (Parity Flag (PF) is 0).

pub fn cmovnp_Register64Bit_Any64BitMemory(
    &mut self,
    arg0: Register64Bit,
    arg1: Any64BitMemory
)

Move if not parity (Parity Flag (PF) is 0).

pub fn cmovnp_Register64Bit_Register64Bit(
    &mut self,
    arg0: Register64Bit,
    arg1: Register64Bit
)

Move if not parity (Parity Flag (PF) is 0).

pub fn cmovns_Register16Bit_Any16BitMemory(
    &mut self,
    arg0: Register16Bit,
    arg1: Any16BitMemory
)

Move if not sign (Sign Flag (SF) is 0).

pub fn cmovns_Register16Bit_Register16Bit(
    &mut self,
    arg0: Register16Bit,
    arg1: Register16Bit
)

Move if not sign (Sign Flag (SF) is 0).

pub fn cmovns_Register32Bit_Any32BitMemory(
    &mut self,
    arg0: Register32Bit,
    arg1: Any32BitMemory
)

Move if not sign (Sign Flag (SF) is 0).

pub fn cmovns_Register32Bit_Register32Bit(
    &mut self,
    arg0: Register32Bit,
    arg1: Register32Bit
)

Move if not sign (Sign Flag (SF) is 0).

pub fn cmovns_Register64Bit_Any64BitMemory(
    &mut self,
    arg0: Register64Bit,
    arg1: Any64BitMemory
)

Move if not sign (Sign Flag (SF) is 0).

pub fn cmovns_Register64Bit_Register64Bit(
    &mut self,
    arg0: Register64Bit,
    arg1: Register64Bit
)

Move if not sign (Sign Flag (SF) is 0).

pub fn cmovnz_Register16Bit_Any16BitMemory(
    &mut self,
    arg0: Register16Bit,
    arg1: Any16BitMemory
)

Move if not zero (Zero Flag (ZF) is 0).

pub fn cmovnz_Register16Bit_Register16Bit(
    &mut self,
    arg0: Register16Bit,
    arg1: Register16Bit
)

Move if not zero (Zero Flag (ZF) is 0).

pub fn cmovnz_Register32Bit_Any32BitMemory(
    &mut self,
    arg0: Register32Bit,
    arg1: Any32BitMemory
)

Move if not zero (Zero Flag (ZF) is 0).

pub fn cmovnz_Register32Bit_Register32Bit(
    &mut self,
    arg0: Register32Bit,
    arg1: Register32Bit
)

Move if not zero (Zero Flag (ZF) is 0).

pub fn cmovnz_Register64Bit_Any64BitMemory(
    &mut self,
    arg0: Register64Bit,
    arg1: Any64BitMemory
)

Move if not zero (Zero Flag (ZF) is 0).

pub fn cmovnz_Register64Bit_Register64Bit(
    &mut self,
    arg0: Register64Bit,
    arg1: Register64Bit
)

Move if not zero (Zero Flag (ZF) is 0).

pub fn cmovo_Register16Bit_Any16BitMemory(
    &mut self,
    arg0: Register16Bit,
    arg1: Any16BitMemory
)

Move if overflow (Overflow Flag (OF) is 1).

pub fn cmovo_Register16Bit_Register16Bit(
    &mut self,
    arg0: Register16Bit,
    arg1: Register16Bit
)

Move if overflow (Overflow Flag (OF) is 1).

pub fn cmovo_Register32Bit_Any32BitMemory(
    &mut self,
    arg0: Register32Bit,
    arg1: Any32BitMemory
)

Move if overflow (Overflow Flag (OF) is 1).

pub fn cmovo_Register32Bit_Register32Bit(
    &mut self,
    arg0: Register32Bit,
    arg1: Register32Bit
)

Move if overflow (Overflow Flag (OF) is 1).

pub fn cmovo_Register64Bit_Any64BitMemory(
    &mut self,
    arg0: Register64Bit,
    arg1: Any64BitMemory
)

Move if overflow (Overflow Flag (OF) is 1).

pub fn cmovo_Register64Bit_Register64Bit(
    &mut self,
    arg0: Register64Bit,
    arg1: Register64Bit
)

Move if overflow (Overflow Flag (OF) is 1).

pub fn cmovp_Register16Bit_Any16BitMemory(
    &mut self,
    arg0: Register16Bit,
    arg1: Any16BitMemory
)

Move if parity (Parity Flag (PF) is 1).

pub fn cmovp_Register16Bit_Register16Bit(
    &mut self,
    arg0: Register16Bit,
    arg1: Register16Bit
)

Move if parity (Parity Flag (PF) is 1).

pub fn cmovp_Register32Bit_Any32BitMemory(
    &mut self,
    arg0: Register32Bit,
    arg1: Any32BitMemory
)

Move if parity (Parity Flag (PF) is 1).

pub fn cmovp_Register32Bit_Register32Bit(
    &mut self,
    arg0: Register32Bit,
    arg1: Register32Bit
)

Move if parity (Parity Flag (PF) is 1).

pub fn cmovp_Register64Bit_Any64BitMemory(
    &mut self,
    arg0: Register64Bit,
    arg1: Any64BitMemory
)

Move if parity (Parity Flag (PF) is 1).

pub fn cmovp_Register64Bit_Register64Bit(
    &mut self,
    arg0: Register64Bit,
    arg1: Register64Bit
)

Move if parity (Parity Flag (PF) is 1).

pub fn cmovpe_Register16Bit_Any16BitMemory(
    &mut self,
    arg0: Register16Bit,
    arg1: Any16BitMemory
)

Move if parity even (Parity Flag (PF) is 1).

pub fn cmovpe_Register16Bit_Register16Bit(
    &mut self,
    arg0: Register16Bit,
    arg1: Register16Bit
)

Move if parity even (Parity Flag (PF) is 1).

pub fn cmovpe_Register32Bit_Any32BitMemory(
    &mut self,
    arg0: Register32Bit,
    arg1: Any32BitMemory
)

Move if parity even (Parity Flag (PF) is 1).

pub fn cmovpe_Register32Bit_Register32Bit(
    &mut self,
    arg0: Register32Bit,
    arg1: Register32Bit
)

Move if parity even (Parity Flag (PF) is 1).

pub fn cmovpe_Register64Bit_Any64BitMemory(
    &mut self,
    arg0: Register64Bit,
    arg1: Any64BitMemory
)

Move if parity even (Parity Flag (PF) is 1).

pub fn cmovpe_Register64Bit_Register64Bit(
    &mut self,
    arg0: Register64Bit,
    arg1: Register64Bit
)

Move if parity even (Parity Flag (PF) is 1).

pub fn cmovpo_Register16Bit_Any16BitMemory(
    &mut self,
    arg0: Register16Bit,
    arg1: Any16BitMemory
)

Move if parity odd (Parity Flag (PF) is 0).

pub fn cmovpo_Register16Bit_Register16Bit(
    &mut self,
    arg0: Register16Bit,
    arg1: Register16Bit
)

Move if parity odd (Parity Flag (PF) is 0).

pub fn cmovpo_Register32Bit_Any32BitMemory(
    &mut self,
    arg0: Register32Bit,
    arg1: Any32BitMemory
)

Move if parity odd (Parity Flag (PF) is 0).

pub fn cmovpo_Register32Bit_Register32Bit(
    &mut self,
    arg0: Register32Bit,
    arg1: Register32Bit
)

Move if parity odd (Parity Flag (PF) is 0).

pub fn cmovpo_Register64Bit_Any64BitMemory(
    &mut self,
    arg0: Register64Bit,
    arg1: Any64BitMemory
)

Move if parity odd (Parity Flag (PF) is 0).

pub fn cmovpo_Register64Bit_Register64Bit(
    &mut self,
    arg0: Register64Bit,
    arg1: Register64Bit
)

Move if parity odd (Parity Flag (PF) is 0).

pub fn cmovs_Register16Bit_Any16BitMemory(
    &mut self,
    arg0: Register16Bit,
    arg1: Any16BitMemory
)

Move if sign (Sign Flag (SF) is 1).

pub fn cmovs_Register16Bit_Register16Bit(
    &mut self,
    arg0: Register16Bit,
    arg1: Register16Bit
)

Move if sign (Sign Flag (SF) is 1).

pub fn cmovs_Register32Bit_Any32BitMemory(
    &mut self,
    arg0: Register32Bit,
    arg1: Any32BitMemory
)

Move if sign (Sign Flag (SF) is 1).

pub fn cmovs_Register32Bit_Register32Bit(
    &mut self,
    arg0: Register32Bit,
    arg1: Register32Bit
)

Move if sign (Sign Flag (SF) is 1).

pub fn cmovs_Register64Bit_Any64BitMemory(
    &mut self,
    arg0: Register64Bit,
    arg1: Any64BitMemory
)

Move if sign (Sign Flag (SF) is 1).

pub fn cmovs_Register64Bit_Register64Bit(
    &mut self,
    arg0: Register64Bit,
    arg1: Register64Bit
)

Move if sign (Sign Flag (SF) is 1).

pub fn cmovz_Register16Bit_Any16BitMemory(
    &mut self,
    arg0: Register16Bit,
    arg1: Any16BitMemory
)

Move if zero (Zero Flag (ZF) is 1).

pub fn cmovz_Register16Bit_Register16Bit(
    &mut self,
    arg0: Register16Bit,
    arg1: Register16Bit
)

Move if zero (Zero Flag (ZF) is 1).

pub fn cmovz_Register32Bit_Any32BitMemory(
    &mut self,
    arg0: Register32Bit,
    arg1: Any32BitMemory
)

Move if zero (Zero Flag (ZF) is 1).

pub fn cmovz_Register32Bit_Register32Bit(
    &mut self,
    arg0: Register32Bit,
    arg1: Register32Bit
)

Move if zero (Zero Flag (ZF) is 1).

pub fn cmovz_Register64Bit_Any64BitMemory(
    &mut self,
    arg0: Register64Bit,
    arg1: Any64BitMemory
)

Move if zero (Zero Flag (ZF) is 1).

pub fn cmovz_Register64Bit_Register64Bit(
    &mut self,
    arg0: Register64Bit,
    arg1: Register64Bit
)

Move if zero (Zero Flag (ZF) is 1).

pub fn cmp_AL_Immediate8Bit(&mut self, arg1: Immediate8Bit)

Compare imm8 with AL.

pub fn cmp_AX_Immediate16Bit(&mut self, arg1: Immediate16Bit)

Compare imm16 with AX.

pub fn cmp_EAX_Immediate32Bit(&mut self, arg1: Immediate32Bit)

Compare imm32 with EAX.

pub fn cmp_Any16BitMemory_Immediate16Bit(
    &mut self,
    arg0: Any16BitMemory,
    arg1: Immediate16Bit
)

Compare imm16 with r/m16.

pub fn cmp_Any16BitMemory_Immediate8Bit(
    &mut self,
    arg0: Any16BitMemory,
    arg1: Immediate8Bit
)

Compare imm8 with r/m16.

pub fn cmp_Any16BitMemory_Register16Bit(
    &mut self,
    arg0: Any16BitMemory,
    arg1: Register16Bit
)

Compare r16 with r/m16.

pub fn cmp_Any32BitMemory_Immediate32Bit(
    &mut self,
    arg0: Any32BitMemory,
    arg1: Immediate32Bit
)

Compare imm32 with r/m32.

pub fn cmp_Any32BitMemory_Immediate8Bit(
    &mut self,
    arg0: Any32BitMemory,
    arg1: Immediate8Bit
)

Compare imm8 with r/m32.

pub fn cmp_Any32BitMemory_Register32Bit(
    &mut self,
    arg0: Any32BitMemory,
    arg1: Register32Bit
)

Compare r32 with r/m32.

pub fn cmp_Any64BitMemory_Immediate32Bit(
    &mut self,
    arg0: Any64BitMemory,
    arg1: Immediate32Bit
)

Compare imm32 sign-extended to 64-bits with r/m64.

pub fn cmp_Any64BitMemory_Immediate8Bit(
    &mut self,
    arg0: Any64BitMemory,
    arg1: Immediate8Bit
)

Compare imm8 with r/m64.

pub fn cmp_Any64BitMemory_Register64Bit(
    &mut self,
    arg0: Any64BitMemory,
    arg1: Register64Bit
)

Compare r64 with r/m64.

pub fn cmp_Any8BitMemory_Immediate8Bit(
    &mut self,
    arg0: Any8BitMemory,
    arg1: Immediate8Bit
)

Compare imm8 with r/m8.

pub fn cmp_Any8BitMemory_Register8Bit(
    &mut self,
    arg0: Any8BitMemory,
    arg1: Register8Bit
)

Compare r8 with r/m8.

pub fn cmp_Any8BitMemory_RegisterHigh8BitsOf16Bits(
    &mut self,
    arg0: Any8BitMemory,
    arg1: RegisterHigh8BitsOf16Bits
)

Compare r8 with r/m8.

pub fn cmp_Register16Bit_Immediate16Bit(
    &mut self,
    arg0: Register16Bit,
    arg1: Immediate16Bit
)

Compare imm16 with r/m16.

pub fn cmp_Register16Bit_Immediate8Bit(
    &mut self,
    arg0: Register16Bit,
    arg1: Immediate8Bit
)

Compare imm8 with r/m16.

pub fn cmp_Register16Bit_Any16BitMemory(
    &mut self,
    arg0: Register16Bit,
    arg1: Any16BitMemory
)

Compare r/m16 with r16.

pub fn cmp_Register16Bit_Register16Bit(
    &mut self,
    arg0: Register16Bit,
    arg1: Register16Bit
)

Compare r16 with r/m16.

pub fn cmp_Register16Bit_Register16Bit_1(
    &mut self,
    arg0: Register16Bit,
    arg1: Register16Bit
)

Compare r/m16 with r16.

pub fn cmp_Register32Bit_Immediate32Bit(
    &mut self,
    arg0: Register32Bit,
    arg1: Immediate32Bit
)

Compare imm32 with r/m32.

pub fn cmp_Register32Bit_Immediate8Bit(
    &mut self,
    arg0: Register32Bit,
    arg1: Immediate8Bit
)

Compare imm8 with r/m32.

pub fn cmp_Register32Bit_Any32BitMemory(
    &mut self,
    arg0: Register32Bit,
    arg1: Any32BitMemory
)

Compare r/m32 with r32.

pub fn cmp_Register32Bit_Register32Bit(
    &mut self,
    arg0: Register32Bit,
    arg1: Register32Bit
)

Compare r32 with r/m32.

pub fn cmp_Register32Bit_Register32Bit_1(
    &mut self,
    arg0: Register32Bit,
    arg1: Register32Bit
)

Compare r/m32 with r32.

pub fn cmp_Register64Bit_Immediate32Bit(
    &mut self,
    arg0: Register64Bit,
    arg1: Immediate32Bit
)

Compare imm32 sign-extended to 64-bits with r/m64.

pub fn cmp_Register64Bit_Immediate8Bit(
    &mut self,
    arg0: Register64Bit,
    arg1: Immediate8Bit
)

Compare imm8 with r/m64.

pub fn cmp_Register64Bit_Any64BitMemory(
    &mut self,
    arg0: Register64Bit,
    arg1: Any64BitMemory
)

Compare r/m64 with r64.

pub fn cmp_Register64Bit_Register64Bit(
    &mut self,
    arg0: Register64Bit,
    arg1: Register64Bit
)

Compare r64 with r/m64.

pub fn cmp_Register64Bit_Register64Bit_1(
    &mut self,
    arg0: Register64Bit,
    arg1: Register64Bit
)

Compare r/m64 with r64.

pub fn cmp_Register8Bit_Immediate8Bit(
    &mut self,
    arg0: Register8Bit,
    arg1: Immediate8Bit
)

Compare imm8 with r/m8.

pub fn cmp_Register8Bit_Any8BitMemory(
    &mut self,
    arg0: Register8Bit,
    arg1: Any8BitMemory
)

Compare r/m8 with r8.

pub fn cmp_Register8Bit_Register8Bit(
    &mut self,
    arg0: Register8Bit,
    arg1: Register8Bit
)

Compare r8 with r/m8.

pub fn cmp_Register8Bit_Register8Bit_1(
    &mut self,
    arg0: Register8Bit,
    arg1: Register8Bit
)

Compare r/m8 with r8.

pub fn cmp_Register8Bit_RegisterHigh8BitsOf16Bits(
    &mut self,
    arg0: Register8Bit,
    arg1: RegisterHigh8BitsOf16Bits
)

Compare r8 with r/m8.

pub fn cmp_Register8Bit_RegisterHigh8BitsOf16Bits_1(
    &mut self,
    arg0: Register8Bit,
    arg1: RegisterHigh8BitsOf16Bits
)

Compare r/m8 with r8.

pub fn cmp_RAX_Immediate32Bit(&mut self, arg1: Immediate32Bit)

Compare imm32 sign-extended to 64-bits with RAX.

pub fn cmp_RegisterHigh8BitsOf16Bits_Immediate8Bit(
    &mut self,
    arg0: RegisterHigh8BitsOf16Bits,
    arg1: Immediate8Bit
)

Compare imm8 with r/m8.

pub fn cmp_RegisterHigh8BitsOf16Bits_Any8BitMemory(
    &mut self,
    arg0: RegisterHigh8BitsOf16Bits,
    arg1: Any8BitMemory
)

Compare r/m8 with r8.

pub fn cmp_RegisterHigh8BitsOf16Bits_Register8Bit(
    &mut self,
    arg0: RegisterHigh8BitsOf16Bits,
    arg1: Register8Bit
)

Compare r8 with r/m8.

pub fn cmp_RegisterHigh8BitsOf16Bits_Register8Bit_1(
    &mut self,
    arg0: RegisterHigh8BitsOf16Bits,
    arg1: Register8Bit
)

Compare r/m8 with r8.

pub fn cmp_RegisterHigh8BitsOf16Bits_RegisterHigh8BitsOf16Bits(
    &mut self,
    arg0: RegisterHigh8BitsOf16Bits,
    arg1: RegisterHigh8BitsOf16Bits
)

Compare r8 with r/m8.

pub fn cmp_RegisterHigh8BitsOf16Bits_RegisterHigh8BitsOf16Bits_1(
    &mut self,
    arg0: RegisterHigh8BitsOf16Bits,
    arg1: RegisterHigh8BitsOf16Bits
)

Compare r/m8 with r8.

pub fn cmppd_XMMRegister_Any128BitMemory_Immediate8Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory,
    arg2: Immediate8Bit
)

Compare packed double-precision floating-point values in xmm2/m128 and xmm1 using imm8 as comparison predicate.

pub fn cmppd_XMMRegister_XMMRegister_Immediate8Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Immediate8Bit
)

Compare packed double-precision floating-point values in xmm2/m128 and xmm1 using imm8 as comparison predicate.

pub fn cmpps_XMMRegister_Any128BitMemory_Immediate8Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory,
    arg2: Immediate8Bit
)

Compare packed single-precision floating-point values in xmm2/mem and xmm1 using imm8 as comparison predicate.

pub fn cmpps_XMMRegister_XMMRegister_Immediate8Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Immediate8Bit
)

Compare packed single-precision floating-point values in xmm2/mem and xmm1 using imm8 as comparison predicate.

pub fn cmps_Any16BitMemory_Any16BitMemory(
    &mut self,
    arg0: Option<SegmentRegister>,
    address_override_for_32_bit: bool
)

For legacy mode, compare word at address DS:(E)SI with word at address ES:(E)DI.

For 64-bit mode compare word at address (R E)SI with word at address (R E)DI.

The status flags are set accordingly.

pub fn cmps_Any32BitMemory_Any32BitMemory(
    &mut self,
    arg0: Option<SegmentRegister>,
    address_override_for_32_bit: bool
)

For legacy mode, compare dword at address DS:(E)SI at dword at address ES:(E)DI.

For 64-bit mode compare dword at address (R E)SI at dword at address (R E)DI.

The status flags are set accordingly.

pub fn cmps_Any64BitMemory_Any64BitMemory(
    &mut self,
    arg0: Option<SegmentRegister>,
    address_override_for_32_bit: bool
)

Compares quadword at address (R E)SI with quadword at address (R E)DI and sets the status flags accordingly.

pub fn cmps_Any8BitMemory_Any8BitMemory(
    &mut self,
    arg0: Option<SegmentRegister>,
    address_override_for_32_bit: bool
)

For legacy mode, compare byte at address DS:(E)SI with byte at address ES:(E)DI.

For 64-bit mode compare byte at address (R E)SI to byte at address (R E)DI.

The status flags are set accordingly.

pub fn cmpsb(&mut self)

For legacy mode, compare byte at address DS:(E)SI with byte at address ES:(E)DI.

For 64-bit mode compare byte at address (R E)SI with byte at address (R E)DI.

The status flags are set accordingly.

pub fn cmpsd(&mut self)

For legacy mode, compare dword at address DS:(E)SI with dword at address ES:(E)DI.

For 64-bit mode compare dword at address (R E)SI with dword at address (R E)DI.

The status flags are set accordingly.

pub fn cmpsd_XMMRegister_Any64BitMemory_Immediate8Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: Any64BitMemory,
    arg2: Immediate8Bit
)

Compare low double-precision floating-point value in xmm2/m64 and xmm1 using imm8 as comparison predicate.

pub fn cmpsd_XMMRegister_XMMRegister_Immediate8Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Immediate8Bit
)

Compare low double-precision floating-point value in xmm2/m64 and xmm1 using imm8 as comparison predicate.

pub fn cmpsq(&mut self)

Compares quadword at address (R E)SI with quadword at address (R E)DI and sets the status flags accordingly.

pub fn cmpss_XMMRegister_Any32BitMemory_Immediate8Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: Any32BitMemory,
    arg2: Immediate8Bit
)

Compare low single-precision floating-point value in xmm2/m32 and xmm1 using imm8 as comparison predicate.

pub fn cmpss_XMMRegister_XMMRegister_Immediate8Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Immediate8Bit
)

Compare low single-precision floating-point value in xmm2/m32 and xmm1 using imm8 as comparison predicate.

pub fn cmpsw(&mut self)

For legacy mode, compare word at address DS:(E)SI with word at address ES:(E)DI.

For 64-bit mode compare word at address (R E)SI with word at address (R E)DI.

The status flags are set accordingly.

pub fn cmpxchg_Any16BitMemory_Register16Bit(
    &mut self,
    arg0: Any16BitMemory,
    arg1: Register16Bit
)

Compare AX with r/m16.

If equal the Zero Flag (ZF) is set and r16 is loaded into r/m16.

Otherwise clears the Zero Flag (ZF) and loads r/m16 into AX.

pub fn cmpxchg_Any32BitMemory_Register32Bit(
    &mut self,
    arg0: Any32BitMemory,
    arg1: Register32Bit
)

Compare EAX with r/m32.

If equal the Zero Flag (ZF) is set and r32 is loaded into r/m32.

Otherwise clears the Zero Flag (ZF) and loads r/m32 into EAX.

pub fn cmpxchg_Any64BitMemory_Register64Bit(
    &mut self,
    arg0: Any64BitMemory,
    arg1: Register64Bit
)

Compare RAX with r/m64.

If equal the Zero Flag (ZF) is set and r64 is loaded into r/m64.

Otherwise clears the Zero Flag (ZF) and loads r/m64 into RAX.

pub fn cmpxchg_Any8BitMemory_Register8Bit(
    &mut self,
    arg0: Any8BitMemory,
    arg1: Register8Bit
)

Compare AL with r/m8.

If equal the Zero Flag (ZF) is set and r8 is loaded into r/m8.

Otherwise clears the Zero Flag (ZF) and loads r/m8 into AL.

pub fn cmpxchg_Any8BitMemory_RegisterHigh8BitsOf16Bits(
    &mut self,
    arg0: Any8BitMemory,
    arg1: RegisterHigh8BitsOf16Bits
)

Compare AL with r/m8.

If equal the Zero Flag (ZF) is set and r8 is loaded into r/m8.

Otherwise clears the Zero Flag (ZF) and loads r/m8 into AL.

pub fn cmpxchg_Register16Bit_Register16Bit(
    &mut self,
    arg0: Register16Bit,
    arg1: Register16Bit
)

Compare AX with r/m16.

If equal the Zero Flag (ZF) is set and r16 is loaded into r/m16.

Otherwise clears the Zero Flag (ZF) and loads r/m16 into AX.

pub fn cmpxchg_Register32Bit_Register32Bit(
    &mut self,
    arg0: Register32Bit,
    arg1: Register32Bit
)

Compare EAX with r/m32.

If equal the Zero Flag (ZF) is set and r32 is loaded into r/m32.

Otherwise clears the Zero Flag (ZF) and loads r/m32 into EAX.

pub fn cmpxchg_Register64Bit_Register64Bit(
    &mut self,
    arg0: Register64Bit,
    arg1: Register64Bit
)

Compare RAX with r/m64.

If equal the Zero Flag (ZF) is set and r64 is loaded into r/m64.

Otherwise clears the Zero Flag (ZF) and loads r/m64 into RAX.

pub fn cmpxchg_Register8Bit_Register8Bit(
    &mut self,
    arg0: Register8Bit,
    arg1: Register8Bit
)

Compare AL with r/m8.

If equal the Zero Flag (ZF) is set and r8 is loaded into r/m8.

Otherwise clears the Zero Flag (ZF) and loads r/m8 into AL.

pub fn cmpxchg_Register8Bit_RegisterHigh8BitsOf16Bits(
    &mut self,
    arg0: Register8Bit,
    arg1: RegisterHigh8BitsOf16Bits
)

Compare AL with r/m8.

If equal the Zero Flag (ZF) is set and r8 is loaded into r/m8.

Otherwise clears the Zero Flag (ZF) and loads r/m8 into AL.

pub fn cmpxchg_RegisterHigh8BitsOf16Bits_Register8Bit(
    &mut self,
    arg0: RegisterHigh8BitsOf16Bits,
    arg1: Register8Bit
)

Compare AL with r/m8.

If equal the Zero Flag (ZF) is set and r8 is loaded into r/m8.

Otherwise clears the Zero Flag (ZF) and loads r/m8 into AL.

pub fn cmpxchg_RegisterHigh8BitsOf16Bits_RegisterHigh8BitsOf16Bits(
    &mut self,
    arg0: RegisterHigh8BitsOf16Bits,
    arg1: RegisterHigh8BitsOf16Bits
)

Compare AL with r/m8.

If equal the Zero Flag (ZF) is set and r8 is loaded into r/m8.

Otherwise clears the Zero Flag (ZF) and loads r/m8 into AL.

pub fn cmpxchg16b_Any128BitMemory(&mut self, arg0: Any128BitMemory)

Compare RDX:RAX with m128.

If equal, set ZF and load RCX:RBX into m128.

Otherwise clears the Zero Flag (ZF) and loads m128 into RDX:RAX.

pub fn cmpxchg8b_Any64BitMemory(&mut self, arg0: Any64BitMemory)

Compare EDX:EAX with m64.

If equal, set ZF and load ECX:EBX into m64.

Otherwise clears the Zero Flag (ZF) and loads m64 into EDX:EAX.

pub fn comisd_XMMRegister_Any64BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any64BitMemory
)

Compare low double-precision floating-point values in xmm1 and xmm2/mem64 and sets the appropriate flags in EFLAGS accordingly.

pub fn comisd_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Compare low double-precision floating-point values in xmm1 and xmm2/mem64 and sets the appropriate flags in EFLAGS accordingly.

pub fn comiss_XMMRegister_Any32BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any32BitMemory
)

Compare low single-precision floating-point values in xmm1 and xmm2/mem32 and sets the appropriate flags in EFLAGS accordingly.

pub fn comiss_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Compare low single-precision floating-point values in xmm1 and xmm2/mem32 and sets the appropriate flags in EFLAGS accordingly.

pub fn cpuid(&mut self)

Returns processor identification and feature information into the EAX, EBX, ECX, and EDX registers as determined by the value in EAX, and, in some cases, ECX as well.

pub fn cqo(&mut self)

RDX:RAX = sign-extend of RAX.

pub fn crc32_Register32Bit_Any16BitMemory(
    &mut self,
    arg0: Register32Bit,
    arg1: Any16BitMemory
)

Accumulate Cyclic Redundancy Check 32 (CRC32) on r/m16.

pub fn crc32_Register32Bit_Any32BitMemory(
    &mut self,
    arg0: Register32Bit,
    arg1: Any32BitMemory
)

Accumulate Cyclic Redundancy Check 32 (CRC32) on r/m32.

pub fn crc32_Register32Bit_Any8BitMemory(
    &mut self,
    arg0: Register32Bit,
    arg1: Any8BitMemory
)

Accumulate Cyclic Redundancy Check 32 (CRC32) on r/m8.

pub fn crc32_Register32Bit_Register16Bit(
    &mut self,
    arg0: Register32Bit,
    arg1: Register16Bit
)

Accumulate Cyclic Redundancy Check 32 (CRC32) on r/m16.

pub fn crc32_Register32Bit_Register32Bit(
    &mut self,
    arg0: Register32Bit,
    arg1: Register32Bit
)

Accumulate Cyclic Redundancy Check 32 (CRC32) on r/m32.

pub fn crc32_Register32Bit_Register8Bit(
    &mut self,
    arg0: Register32Bit,
    arg1: Register8Bit
)

Accumulate Cyclic Redundancy Check 32 (CRC32) on r/m8.

pub fn crc32_Register32Bit_RegisterHigh8BitsOf16Bits(
    &mut self,
    arg0: Register32Bit,
    arg1: RegisterHigh8BitsOf16Bits
)

Accumulate Cyclic Redundancy Check 32 (CRC32) on r/m8.

pub fn crc32_Register64Bit_Any64BitMemory(
    &mut self,
    arg0: Register64Bit,
    arg1: Any64BitMemory
)

Accumulate Cyclic Redundancy Check 32 (CRC32) on r/m64.

pub fn crc32_Register64Bit_Any8BitMemory(
    &mut self,
    arg0: Register64Bit,
    arg1: Any8BitMemory
)

Accumulate Cyclic Redundancy Check 32 (CRC32) on r/m8.

pub fn crc32_Register64Bit_Register64Bit(
    &mut self,
    arg0: Register64Bit,
    arg1: Register64Bit
)

Accumulate Cyclic Redundancy Check 32 (CRC32) on r/m64.

pub fn crc32_Register64Bit_Register8Bit(
    &mut self,
    arg0: Register64Bit,
    arg1: Register8Bit
)

Accumulate Cyclic Redundancy Check 32 (CRC32) on r/m8.

pub fn cvtdq2pd_XMMRegister_Any64BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any64BitMemory
)

Convert two packed signed doubleword integers from xmm2/m128 to two packed double-precision floating-point values in xmm1.

pub fn cvtdq2pd_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Convert two packed signed doubleword integers from xmm2/m128 to two packed double-precision floating-point values in xmm1.

pub fn cvtdq2ps_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Convert four packed signed doubleword integers from xmm2/m128 to four packed single-precision floating-point values in xmm1.

pub fn cvtdq2ps_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Convert four packed signed doubleword integers from xmm2/m128 to four packed single-precision floating-point values in xmm1.

pub fn cvtpd2dq_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Convert two packed double-precision floating-point values from xmm2/m128 to two packed signed doubleword integers in xmm1.

pub fn cvtpd2dq_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Convert two packed double-precision floating-point values from xmm2/m128 to two packed signed doubleword integers in xmm1.

pub fn cvtpd2pi_MMRegister_Any128BitMemory(
    &mut self,
    arg0: MMRegister,
    arg1: Any128BitMemory
)

Convert two packed double-precision floating-point values from xmm/m32 to two packed signed doubleword integers in mm.

pub fn cvtpd2pi_MMRegister_XMMRegister(
    &mut self,
    arg0: MMRegister,
    arg1: XMMRegister
)

Convert two packed double-precision floating-point values from xmm/m32 to two packed signed doubleword integers in mm.

pub fn cvtpd2ps_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Convert two packed double-precision floating-point values in xmm2/m128 to two packed single-precision floating-point values in xmm1.

pub fn cvtpd2ps_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Convert two packed double-precision floating-point values in xmm2/m128 to two packed single-precision floating-point values in xmm1.

pub fn cvtpi2pd_XMMRegister_Any64BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any64BitMemory
)

Convert two packed signed doubleword integers from mm/mem64 to two packed double-precision floating-point values in xmm.

pub fn cvtpi2pd_XMMRegister_MMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: MMRegister
)

Convert two packed signed doubleword integers from mm/mem64 to two packed double-precision floating-point values in xmm.

pub fn cvtpi2ps_XMMRegister_Any64BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any64BitMemory
)

Convert two signed doubleword integers from mm/m64 to two single-precision floating-point values in xmm.

pub fn cvtpi2ps_XMMRegister_MMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: MMRegister
)

Convert two signed doubleword integers from mm/m64 to two single-precision floating-point values in xmm.

pub fn cvtps2dq_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Convert four packed single-precision floating-point values from xmm2/m128 to four packed signed doubleword integers in xmm1.

pub fn cvtps2dq_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Convert four packed single-precision floating-point values from xmm2/m128 to four packed signed doubleword integers in xmm1.

pub fn cvtps2pd_XMMRegister_Any64BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any64BitMemory
)

Convert two packed single-precision floating-point values in xmm2/m64 to two packed double-precision floating-point values in xmm1.

pub fn cvtps2pd_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Convert two packed single-precision floating-point values in xmm2/m64 to two packed double-precision floating-point values in xmm1.

pub fn cvtps2pi_MMRegister_Any64BitMemory(
    &mut self,
    arg0: MMRegister,
    arg1: Any64BitMemory
)

Convert two packed single-precision floating-point values from xmm/m64 to two packed signed doubleword integers in mm.

pub fn cvtps2pi_MMRegister_XMMRegister(
    &mut self,
    arg0: MMRegister,
    arg1: XMMRegister
)

Convert two packed single-precision floating-point values from xmm/m64 to two packed signed doubleword integers in mm.

pub fn cvtsd2si_Register32Bit_Any64BitMemory(
    &mut self,
    arg0: Register32Bit,
    arg1: Any64BitMemory
)

Convert one double-precision floating-point value from xmm/m64 to one signed doubleword integer r32.

pub fn cvtsd2si_Register32Bit_XMMRegister(
    &mut self,
    arg0: Register32Bit,
    arg1: XMMRegister
)

Convert one double-precision floating-point value from xmm/m64 to one signed doubleword integer r32.

pub fn cvtsd2si_Register64Bit_Any64BitMemory(
    &mut self,
    arg0: Register64Bit,
    arg1: Any64BitMemory
)

Convert one double-precision floating-point value from xmm/m64 to one signed quadword integer sign-extended into r64.

pub fn cvtsd2si_Register64Bit_XMMRegister(
    &mut self,
    arg0: Register64Bit,
    arg1: XMMRegister
)

Convert one double-precision floating-point value from xmm/m64 to one signed quadword integer sign-extended into r64.

pub fn cvtsd2ss_XMMRegister_Any64BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any64BitMemory
)

Convert one double-precision floating-point value in xmm2/m64 to one single-precision floating-point value in xmm1.

pub fn cvtsd2ss_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Convert one double-precision floating-point value in xmm2/m64 to one single-precision floating-point value in xmm1.

pub fn cvtsi2sd_XMMRegister_Any32BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any32BitMemory
)

Convert one signed doubleword integer from r/m32 to one double-precision floating-point value in xmm.

pub fn cvtsi2sd_XMMRegister_Any64BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any64BitMemory
)

Convert one signed quadword integer from r/m64 to one double-precision floating-point value in xmm.

pub fn cvtsi2sd_XMMRegister_Register32Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: Register32Bit
)

Convert one signed doubleword integer from r/m32 to one double-precision floating-point value in xmm.

pub fn cvtsi2sd_XMMRegister_Register64Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: Register64Bit
)

Convert one signed quadword integer from r/m64 to one double-precision floating-point value in xmm.

pub fn cvtsi2ss_XMMRegister_Any32BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any32BitMemory
)

Convert one signed doubleword integer from r/m32 to one single-precision floating-point value in xmm.

pub fn cvtsi2ss_XMMRegister_Any64BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any64BitMemory
)

Convert one signed quadword integer from r/m64 to one single-precision floating-point value in xmm.

pub fn cvtsi2ss_XMMRegister_Register32Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: Register32Bit
)

Convert one signed doubleword integer from r/m32 to one single-precision floating-point value in xmm.

pub fn cvtsi2ss_XMMRegister_Register64Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: Register64Bit
)

Convert one signed quadword integer from r/m64 to one single-precision floating-point value in xmm.

pub fn cvtss2sd_XMMRegister_Any32BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any32BitMemory
)

Convert one single-precision floating-point value in xmm2/m32 to one double-precision floating-point value in xmm1.

pub fn cvtss2sd_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Convert one single-precision floating-point value in xmm2/m32 to one double-precision floating-point value in xmm1.

pub fn cvtss2si_Register32Bit_Any32BitMemory(
    &mut self,
    arg0: Register32Bit,
    arg1: Any32BitMemory
)

Convert one single-precision floating-point value from xmm/m32 to one signed doubleword integer in r32.

pub fn cvtss2si_Register32Bit_XMMRegister(
    &mut self,
    arg0: Register32Bit,
    arg1: XMMRegister
)

Convert one single-precision floating-point value from xmm/m32 to one signed doubleword integer in r32.

pub fn cvtss2si_Register64Bit_Any32BitMemory(
    &mut self,
    arg0: Register64Bit,
    arg1: Any32BitMemory
)

Convert one single-precision floating-point value from xmm/m32 to one signed quadword integer in r64.

pub fn cvtss2si_Register64Bit_XMMRegister(
    &mut self,
    arg0: Register64Bit,
    arg1: XMMRegister
)

Convert one single-precision floating-point value from xmm/m32 to one signed quadword integer in r64.

pub fn cvttpd2dq_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Convert two packed double-precision floating-point values from xmm2/m128 to two packed signed doubleword integers in xmm1 using truncation.

pub fn cvttpd2dq_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Convert two packed double-precision floating-point values from xmm2/m128 to two packed signed doubleword integers in xmm1 using truncation.

pub fn cvttpd2pi_MMRegister_Any128BitMemory(
    &mut self,
    arg0: MMRegister,
    arg1: Any128BitMemory
)

Convert two packer double-precision floating-point values from xmm/m32 to two packed signed doubleword integers in mm using truncation.

pub fn cvttpd2pi_MMRegister_XMMRegister(
    &mut self,
    arg0: MMRegister,
    arg1: XMMRegister
)

Convert two packer double-precision floating-point values from xmm/m32 to two packed signed doubleword integers in mm using truncation.

pub fn cvttps2dq_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Convert four single-precision floating-point values from xmm2/m128 to four signed doubleword integers in xmm1 using truncation.

pub fn cvttps2dq_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Convert four single-precision floating-point values from xmm2/m128 to four signed doubleword integers in xmm1 using truncation.

pub fn cvttps2pi_MMRegister_Any64BitMemory(
    &mut self,
    arg0: MMRegister,
    arg1: Any64BitMemory
)

Convert two single-precision floating-point values from xmm/m64 to two signed doubleword signed integers in mm using truncation.

pub fn cvttps2pi_MMRegister_XMMRegister(
    &mut self,
    arg0: MMRegister,
    arg1: XMMRegister
)

Convert two single-precision floating-point values from xmm/m64 to two signed doubleword signed integers in mm using truncation.

pub fn cvttsd2si_Register32Bit_Any64BitMemory(
    &mut self,
    arg0: Register32Bit,
    arg1: Any64BitMemory
)

Convert one double-precision floating-point value from xmm/m64 to one signed doubleword integer in r32 using truncation.

pub fn cvttsd2si_Register32Bit_XMMRegister(
    &mut self,
    arg0: Register32Bit,
    arg1: XMMRegister
)

Convert one double-precision floating-point value from xmm/m64 to one signed doubleword integer in r32 using truncation.

pub fn cvttsd2si_Register64Bit_Any64BitMemory(
    &mut self,
    arg0: Register64Bit,
    arg1: Any64BitMemory
)

Convert one double-precision floating-point value from xmm/m64 to one signedquadword integer in r64 using truncation.

pub fn cvttsd2si_Register64Bit_XMMRegister(
    &mut self,
    arg0: Register64Bit,
    arg1: XMMRegister
)

Convert one double-precision floating-point value from xmm/m64 to one signedquadword integer in r64 using truncation.

pub fn cvttss2si_Register32Bit_Any32BitMemory(
    &mut self,
    arg0: Register32Bit,
    arg1: Any32BitMemory
)

Convert one single-precision floating-point value from xmm/m32 to one signed doubleword integer in r32 using truncation.

pub fn cvttss2si_Register32Bit_XMMRegister(
    &mut self,
    arg0: Register32Bit,
    arg1: XMMRegister
)

Convert one single-precision floating-point value from xmm/m32 to one signed doubleword integer in r32 using truncation.

pub fn cvttss2si_Register64Bit_Any32BitMemory(
    &mut self,
    arg0: Register64Bit,
    arg1: Any32BitMemory
)

Convert one single-precision floating-point value from xmm/m32 to one signed quadword integer in r64 using truncation.

pub fn cvttss2si_Register64Bit_XMMRegister(
    &mut self,
    arg0: Register64Bit,
    arg1: XMMRegister
)

Convert one single-precision floating-point value from xmm/m32 to one signed quadword integer in r64 using truncation.

pub fn cwd(&mut self)

DX:AX = sign-extend of AX.

pub fn cwde(&mut self)

EAX = sign-extend of AX.

pub fn dec_Any16BitMemory(&mut self, arg0: Any16BitMemory)

Decrement r/m16 by 1.

pub fn dec_Any32BitMemory(&mut self, arg0: Any32BitMemory)

Decrement r/m32 by 1.

pub fn dec_Any64BitMemory(&mut self, arg0: Any64BitMemory)

Decrement r/m64 by 1.

pub fn dec_Any8BitMemory(&mut self, arg0: Any8BitMemory)

Decrement r/m8 by 1.

pub fn dec_Register16Bit(&mut self, arg0: Register16Bit)

Decrement r/m16 by 1.

pub fn dec_Register32Bit(&mut self, arg0: Register32Bit)

Decrement r/m32 by 1.

pub fn dec_Register64Bit(&mut self, arg0: Register64Bit)

Decrement r/m64 by 1.

pub fn dec_Register8Bit(&mut self, arg0: Register8Bit)

Decrement r/m8 by 1.

pub fn dec_RegisterHigh8BitsOf16Bits(&mut self, arg0: RegisterHigh8BitsOf16Bits)

Decrement r/m8 by 1.

pub fn div_Any16BitMemory(&mut self, arg0: Any16BitMemory)

Unsigned divide DX:AX by r/m16, with result stored in AX (Quotient) and DX (Remainder).

pub fn div_Any32BitMemory(&mut self, arg0: Any32BitMemory)

Unsigned divide EDX:EAX by r/m32, with result stored in EAX (Quotient) and EDX (Remainder).

pub fn div_Any64BitMemory(&mut self, arg0: Any64BitMemory)

Unsigned divide RDX:RAX by r/m64, with result stored in RAX (Quotient) and RDX (Remainder).

pub fn div_Any8BitMemory(&mut self, arg0: Any8BitMemory)

Unsigned divide AX by r/m8, with result stored in AL (Quotient) and AH (Remainder).

pub fn div_Register16Bit(&mut self, arg0: Register16Bit)

Unsigned divide DX:AX by r/m16, with result stored in AX (Quotient) and DX (Remainder).

pub fn div_Register32Bit(&mut self, arg0: Register32Bit)

Unsigned divide EDX:EAX by r/m32, with result stored in EAX (Quotient) and EDX (Remainder).

pub fn div_Register64Bit(&mut self, arg0: Register64Bit)

Unsigned divide RDX:RAX by r/m64, with result stored in RAX (Quotient) and RDX (Remainder).

pub fn div_Register8Bit(&mut self, arg0: Register8Bit)

Unsigned divide AX by r/m8, with result stored in AL (Quotient) and AH (Remainder).

pub fn div_RegisterHigh8BitsOf16Bits(&mut self, arg0: RegisterHigh8BitsOf16Bits)

Unsigned divide AX by r/m8, with result stored in AL (Quotient) and AH (Remainder).

pub fn divpd_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Divide packed double-precision floating-point values in xmm1 by packed double-precision floating-point values xmm2/m128.

pub fn divpd_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Divide packed double-precision floating-point values in xmm1 by packed double-precision floating-point values xmm2/m128.

pub fn divps_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Divide packed single-precision floating-point values in xmm1 by packed single-precision floating-point values xmm2/m128.

pub fn divps_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Divide packed single-precision floating-point values in xmm1 by packed single-precision floating-point values xmm2/m128.

pub fn divsd_XMMRegister_Any64BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any64BitMemory
)

Divide low double-precision floating-point value in xmm1 by low double-precision floating-point value in xmm2/mem64.

pub fn divsd_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Divide low double-precision floating-point value in xmm1 by low double-precision floating-point value in xmm2/mem64.

pub fn divss_XMMRegister_Any32BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any32BitMemory
)

Divide low single-precision floating-point value in xmm1 by low single-precision floating-point value in xmm2/m32.

pub fn divss_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Divide low single-precision floating-point value in xmm1 by low single-precision floating-point value in xmm2/m32.

pub fn dppd_XMMRegister_Any128BitMemory_Immediate8Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory,
    arg2: Immediate8Bit
)

Selectively multiply packed double-precision floating-point values from xmm1 with packed double-precision floating-point values from xmm2. add and selectively store the packed double-precision floating-point values to xmm1.

pub fn dppd_XMMRegister_XMMRegister_Immediate8Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Immediate8Bit
)

Selectively multiply packed double-precision floating-point values from xmm1 with packed double-precision floating-point values from xmm2. add and selectively store the packed double-precision floating-point values to xmm1.

pub fn dpps_XMMRegister_Any128BitMemory_Immediate8Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory,
    arg2: Immediate8Bit
)

Selectively multiply packed single-precision floating-point values from xmm1 with packed single-precision floating-point values from xmm2. add and selectively store the packed single-precision floating-point values or zero values to xmm1.

pub fn dpps_XMMRegister_XMMRegister_Immediate8Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Immediate8Bit
)

Selectively multiply packed single-precision floating-point values from xmm1 with packed single-precision floating-point values from xmm2. add and selectively store the packed single-precision floating-point values or zero values to xmm1.

pub fn emms(&mut self)

Set the x87 Floating Point Unit (FPU) tag word to empty.

pub fn enter_Immediate8Bit_Immediate16Bit(
    &mut self,
    arg0: Immediate8Bit,
    arg1: Immediate16Bit
)

Create a nested stack frame for a procedure.

pub fn enter_One_Immediate16Bit(&mut self, arg1: Immediate16Bit)

Create a nested stack frame for a procedure.

pub fn enter_Zero_Immediate16Bit(&mut self, arg1: Immediate16Bit)

Create a stack frame for a procedure.

pub fn extractps_Any32BitMemory_XMMRegister_Immediate8Bit(
    &mut self,
    arg0: Any32BitMemory,
    arg1: XMMRegister,
    arg2: Immediate8Bit
)

Extract a single-precision floating-point value from xmm2 at the source offset specified by imm8 and store the result to reg or m32.

The upper 32 bits of r64 is zeroed if reg is r64.

pub fn extractps_Register32Bit_XMMRegister_Immediate8Bit(
    &mut self,
    arg0: Register32Bit,
    arg1: XMMRegister,
    arg2: Immediate8Bit
)

Extract a single-precision floating-point value from xmm2 at the source offset specified by imm8 and store the result to reg or m32.

The upper 32 bits of r64 is zeroed if reg is r64.

pub fn extractps_Register64Bit_XMMRegister_Immediate8Bit(
    &mut self,
    arg0: Register64Bit,
    arg1: XMMRegister,
    arg2: Immediate8Bit
)

Extract a single-precision floating-point value from xmm2 at the source offset specified by imm8 and store the result to reg or m32.

The upper 32 bits of r64 is zeroed if reg is r64.

pub fn f2xm1(&mut self)

Replace ST(0) with (2^(ST(0)) - 1).

pub fn fabs(&mut self)

Replace ST with its absolute value.

pub fn fadd_X87Float32BitMemory(&mut self, arg0: X87Float32BitMemory)

Add m32fp to ST(0) and store result in ST(0).

pub fn fadd_X87Float64BitMemory(&mut self, arg0: X87Float64BitMemory)

Add m64fp to ST(0) and store result in ST(0).

pub fn fadd_X87Register_ST0(&mut self, arg0: X87Register)

Add ST(i) to ST(0) and store result in ST(i).

pub fn fadd_ST0_X87Register(&mut self, arg1: X87Register)

Add ST(0) to ST(i) and store result in ST(0).

pub fn faddp(&mut self)

Add ST(0) to ST(1) with result stored in in ST(1), and pop the register stack.

pub fn faddp_X87Register_ST0(&mut self, arg0: X87Register)

Add ST(0) to ST(i) with result stored in in ST(i), and pop the register stack.

pub fn fbld_X87BinaryCodedDecimal80BitMemory(
    &mut self,
    arg0: X87BinaryCodedDecimal80BitMemory
)

Convert binary coded decimal value to floating-point and push onto the Floating Point Unit (FPU) stack.

pub fn fbstp_X87BinaryCodedDecimal80BitMemory(
    &mut self,
    arg0: X87BinaryCodedDecimal80BitMemory
)

Store ST(0) in arg0 and pop ST(0).

pub fn fchs(&mut self)

Complements sign of ST(0).

pub fn fclex(&mut self)

Clear floating-point exception flags after checking for pending unmasked floating-point exceptions.

pub fn fcmovb_ST0_X87Register(&mut self, arg1: X87Register)

Move if below (Carry Flag (CF) is 1).

pub fn fcmovbe_ST0_X87Register(&mut self, arg1: X87Register)

Move if below or equal (Carry Flag (CF) is 1 or Zero Flag (ZF) is 1).

pub fn fcmove_ST0_X87Register(&mut self, arg1: X87Register)

Move if equal (Zero Flag (ZF) is 1).

pub fn fcmovnb_ST0_X87Register(&mut self, arg1: X87Register)

Move if not below (Carry Flag (CF) is 0).

pub fn fcmovnbe_ST0_X87Register(&mut self, arg1: X87Register)

Move if not below or equal (Carry Flag (CF) is 0 and Zero Flag (ZF) is 0).

pub fn fcmovne_ST0_X87Register(&mut self, arg1: X87Register)

Move if not equal (Zero Flag (ZF) is 0).

pub fn fcmovnu_ST0_X87Register(&mut self, arg1: X87Register)

Move if not unordered (Parity Flag (PF) is 0).

pub fn fcmovu_ST0_X87Register(&mut self, arg1: X87Register)

Move if unordered (Parity Flag (PF) is 1).

pub fn fcom(&mut self)

Compare ST(0) with ST(1).

pub fn fcom_X87Float32BitMemory(&mut self, arg0: X87Float32BitMemory)

Compare ST(0) with m32fp.

pub fn fcom_X87Float64BitMemory(&mut self, arg0: X87Float64BitMemory)

Compare ST(0) with m64fp.

pub fn fcom_X87Register(&mut self, arg0: X87Register)

Compare ST(0) with ST(i).

pub fn fcomi_ST0_X87Register(&mut self, arg1: X87Register)

Compare ST(0) with ST(i) and set status flags accordingly.

pub fn fcomip_ST0_X87Register(&mut self, arg1: X87Register)

Compare ST(0) with ST(i), set status flags accordingly, and pop register stack.

pub fn fcomp(&mut self)

Compare ST(0) with ST(1) and pop register stack.

pub fn fcomp_X87Float32BitMemory(&mut self, arg0: X87Float32BitMemory)

Compare ST(0) with m32fp and pop register stack.

pub fn fcomp_X87Float64BitMemory(&mut self, arg0: X87Float64BitMemory)

Compare ST(0) with m64fp and pop register stack.

pub fn fcomp_X87Register(&mut self, arg0: X87Register)

Compare ST(0) with ST(i) and pop register stack.

pub fn fcompp(&mut self)

Compare ST(0) with ST(1) and pop register stack twice.

pub fn fcos(&mut self)

Replace ST(0) with its cosine.

pub fn fdecstp(&mut self)

Decrement TOP field in Floating Point Unit (FPU) status word.

pub fn fdiv_X87Float32BitMemory(&mut self, arg0: X87Float32BitMemory)

Divide ST(0) by m32fp and store result in ST(0).

pub fn fdiv_X87Float64BitMemory(&mut self, arg0: X87Float64BitMemory)

Compare ST(0) with ST(i), set status flags accordingly, and pop register stack.

pub fn fdiv_X87Register_ST0(&mut self, arg0: X87Register)

Divide ST(i) by ST(0) and store result in ST(i).

pub fn fdiv_ST0_X87Register(&mut self, arg1: X87Register)

Divide ST(0) by ST(i) and store result in ST(0).

pub fn fdivp(&mut self)

Divide ST(1) by ST(0) with result stored in in ST(1), and pop the register stack.

pub fn fdivp_X87Register_ST0(&mut self, arg0: X87Register)

Divide ST(i) by ST(0) with result stored in in ST(i), and pop the register stack.

pub fn fdivr_X87Float32BitMemory(&mut self, arg0: X87Float32BitMemory)

Divide m32fp by ST(0) and store result in ST(0).

pub fn fdivr_X87Float64BitMemory(&mut self, arg0: X87Float64BitMemory)

Divide m64fp by ST(0) and store result in ST(0).

pub fn fdivr_X87Register_ST0(&mut self, arg0: X87Register)

Divide ST(0) by ST(i) and store result in ST(i).

pub fn fdivr_ST0_X87Register(&mut self, arg1: X87Register)

Divide ST(i) by ST(0) and store result in ST(0).

pub fn fdivrp(&mut self)

Divide ST(0) by ST(1) with result stored in in ST(1), and pop the register stack.

pub fn fdivrp_X87Register_ST0(&mut self, arg0: X87Register)

Divide ST(0) by ST(i) with result stored in in ST(i), and pop the register stack.

pub fn ffree_X87Register(&mut self, arg0: X87Register)

Sets tag for ST(i) to empty.

pub fn fiadd_X87Integer16BitMemory(&mut self, arg0: X87Integer16BitMemory)

Add m16int to ST(0) and store result in ST(0).

pub fn fiadd_X87Integer32BitMemory(&mut self, arg0: X87Integer32BitMemory)

Add m32int to ST(0) and store result in ST(0).

pub fn ficom_X87Integer16BitMemory(&mut self, arg0: X87Integer16BitMemory)

Compare ST(0) with m16int.

pub fn ficom_X87Integer32BitMemory(&mut self, arg0: X87Integer32BitMemory)

Compare ST(0) with m32int.

pub fn ficomp_X87Integer16BitMemory(&mut self, arg0: X87Integer16BitMemory)

Compare ST(0) with m16int and pop stack register.

pub fn ficomp_X87Integer32BitMemory(&mut self, arg0: X87Integer32BitMemory)

Compare ST(0) with m32int and pop stack register.

pub fn fidiv_X87Integer16BitMemory(&mut self, arg0: X87Integer16BitMemory)

Divide ST(0) by m64int and store result in ST(0).

pub fn fidiv_X87Integer32BitMemory(&mut self, arg0: X87Integer32BitMemory)

Divide ST(0) by m32int and store result in ST(0).

pub fn fidivr_X87Integer16BitMemory(&mut self, arg0: X87Integer16BitMemory)

Divide m16int by ST(0) and store result in ST(0).

pub fn fidivr_X87Integer32BitMemory(&mut self, arg0: X87Integer32BitMemory)

Divide m32int by ST(0) and store result in ST(0).

pub fn fild_X87Integer16BitMemory(&mut self, arg0: X87Integer16BitMemory)

Push m16int onto the Floating Point Unit (FPU) register stack.

pub fn fild_X87Integer32BitMemory(&mut self, arg0: X87Integer32BitMemory)

Push m32int onto the Floating Point Unit (FPU) register stack.

pub fn fild_X87Integer64BitMemory(&mut self, arg0: X87Integer64BitMemory)

Push m64int onto the Floating Point Unit (FPU) register stack.

pub fn fimul_X87Integer16BitMemory(&mut self, arg0: X87Integer16BitMemory)

Multiply ST(0) by m16int and store result in ST(0).

pub fn fimul_X87Integer32BitMemory(&mut self, arg0: X87Integer32BitMemory)

Multiply ST(0) by m32int and store result in ST(0).

pub fn fincstp(&mut self)

Increment the TOP field in the Floating Point Unit (FPU) status register.

pub fn finit(&mut self)

Initialize Floating Point Unit (FPU) after checking for pending unmasked floating-point exceptions.

pub fn fist_X87Integer16BitMemory(&mut self, arg0: X87Integer16BitMemory)

Store ST(0) in m16int.

pub fn fist_X87Integer32BitMemory(&mut self, arg0: X87Integer32BitMemory)

Store ST(0) in m32int.

pub fn fistp_X87Integer16BitMemory(&mut self, arg0: X87Integer16BitMemory)

Store ST(0) in m16int and pop register stack.

pub fn fistp_X87Integer32BitMemory(&mut self, arg0: X87Integer32BitMemory)

Store ST(0) in m32int and pop register stack.

pub fn fistp_X87Integer64BitMemory(&mut self, arg0: X87Integer64BitMemory)

Store ST(0) in m64int and pop register stack.

pub fn fisttp_X87Integer16BitMemory(&mut self, arg0: X87Integer16BitMemory)

Store ST(0) in m16int with truncation.

pub fn fisttp_X87Integer32BitMemory(&mut self, arg0: X87Integer32BitMemory)

Store ST(0) in m32int with truncation.

pub fn fisttp_X87Integer64BitMemory(&mut self, arg0: X87Integer64BitMemory)

Store ST(0) in m64int with truncation.

pub fn fisub_X87Integer16BitMemory(&mut self, arg0: X87Integer16BitMemory)

Subtract m16int from ST(0) and store result in ST(0).

pub fn fisub_X87Integer32BitMemory(&mut self, arg0: X87Integer32BitMemory)

Subtract m32int from ST(0) and store result in ST(0).

pub fn fisubr_X87Integer16BitMemory(&mut self, arg0: X87Integer16BitMemory)

Subtract ST(0) from m16int and store result in ST(0).

pub fn fisubr_X87Integer32BitMemory(&mut self, arg0: X87Integer32BitMemory)

Subtract ST(0) from m32int and store result in ST(0).

pub fn fld_X87Float32BitMemory(&mut self, arg0: X87Float32BitMemory)

Push m32fp onto the Floating Point Unit (FPU) register stack.

pub fn fld_X87Float64BitMemory(&mut self, arg0: X87Float64BitMemory)

Push m64fp onto the Floating Point Unit (FPU) register stack.

pub fn fld_X87Float80BitMemory(&mut self, arg0: X87Float80BitMemory)

Push m80fp onto the Floating Point Unit (FPU) register stack.

pub fn fld_X87Register(&mut self, arg0: X87Register)

Push ST(i) onto the Floating Point Unit (FPU) register stack.

pub fn fld1(&mut self)

Push +1.0 onto the Floating Point Unit (FPU) register stack.

pub fn fldcw_Contiguous2ByteMemory(&mut self, arg0: Contiguous2ByteMemory)

Load Floating Point Unit (FPU) control word from m2byte.

pub fn fldenv_Contiguous28ByteMemory(&mut self, arg0: Contiguous28ByteMemory)

Load Floating Point Unit (FPU) environment from m14byte or m28byte.

pub fn fldl2e(&mut self)

Push log2e onto the Floating Point Unit (FPU) register stack.

pub fn fldl2t(&mut self)

Push log210 onto the Floating Point Unit (FPU) register stack.

pub fn fldlg2(&mut self)

Push log102 onto the Floating Point Unit (FPU) register stack.

pub fn fldln2(&mut self)

Push loge2 onto the Floating Point Unit (FPU) register stack.

pub fn fldpi(&mut self)

Push pi onto the Floating Point Unit (FPU) register stack.

pub fn fldz(&mut self)

Push +0.0 onto the Floating Point Unit (FPU) register stack.

pub fn fmul_X87Float32BitMemory(&mut self, arg0: X87Float32BitMemory)

Multiply ST(0) by m32fp and store result in ST(0).

pub fn fmul_X87Float64BitMemory(&mut self, arg0: X87Float64BitMemory)

Multiply ST(0) by m64fp and store result in ST(0).

pub fn fmul_X87Register_ST0(&mut self, arg0: X87Register)

Multiply ST(i) by ST(0) and store result in ST(i).

pub fn fmul_ST0_X87Register(&mut self, arg1: X87Register)

Multiply ST(0) by ST(i) and store result in ST(0).

pub fn fmulp(&mut self)

Multiply ST(1) by ST(0) with result stored in in ST(1), and pop the register stack.

pub fn fmulp_X87Register_ST0(&mut self, arg0: X87Register)

Multiply ST(i) by ST(0) with result stored in in ST(i), and pop the register stack.

pub fn fnclex(&mut self)

Clear floating-point exception flags without checking for pending unmasked floating-point exceptions.

pub fn fninit(&mut self)

Initialize Floating Point Unit (FPU) without checking for pending unmasked floating-point exceptions.

pub fn fnop(&mut self)

No operation is performed.

pub fn fnsave_Contiguous108ByteMemory(&mut self, arg0: Contiguous108ByteMemory)

Store Floating Point Unit (FPU) environment to m94byte or m108byte without checking for pending unmasked floating-point exceptions.

Then re-initialize the Floating Point Unit (FPU).

pub fn fnstcw_Contiguous2ByteMemory(&mut self, arg0: Contiguous2ByteMemory)

Store Floating Point Unit (FPU) control word to m2byte without checking for pending unmasked floating-point exceptions.

pub fn fnstenv_Contiguous28ByteMemory(&mut self, arg0: Contiguous28ByteMemory)

Store Floating Point Unit (FPU) environment to m14byte or m28byte without checking for pending unmasked floating-point exceptions.

Then mask all floating-point exceptions.

pub fn fnstsw_AX(&mut self)

Store Floating Point Unit (FPU) status word in AX register without checking for pending unmasked floating-point exceptions.

pub fn fnstsw_Contiguous2ByteMemory(&mut self, arg0: Contiguous2ByteMemory)

Store Floating Point Unit (FPU) status word at m2byte without checking for pending unmasked floating-point exceptions.

pub fn fpatan(&mut self)

Replace ST(1) with arctan(ST(1)/ST(0)) and pop the register stack.

pub fn fprem(&mut self)

Replace ST(0) with the remainder obtained from dividing ST(0) by ST(1).

pub fn fprem1(&mut self)

Replace ST(0) with the IEEE remainder obtained from dividing ST(0) by ST(1).

pub fn fptan(&mut self)

Replace ST(0) with its tangent and push 1 onto the Floating Point Unit (FPU) stack.

pub fn frndint(&mut self)

Round ST(0) to an integer.

pub fn frstor_Contiguous108ByteMemory(&mut self, arg0: Contiguous108ByteMemory)

Load Floating Point Unit (FPU) state from m94byte or m108byte.

pub fn fsave_Contiguous108ByteMemory(&mut self, arg0: Contiguous108ByteMemory)

Store Floating Point Unit (FPU) state to m94byte or m108byte after checking for pending unmasked floating-point exceptions.

Then re-initialize the Floating Point Unit (FPU).

pub fn fscale(&mut self)

Scale ST(0) by ST(1).

pub fn fsin(&mut self)

Replace ST(0) with its sine.

pub fn fsincos(&mut self)

Compute the sine and cosine of ST(0); replace ST(0) with the sine, and push the cosine onto the register stack.

pub fn fsqrt(&mut self)

Computes square root of ST(0) and stores the result in ST(0).

pub fn fst_X87Float32BitMemory(&mut self, arg0: X87Float32BitMemory)

Copy ST(0) to m32fp.

pub fn fst_X87Float64BitMemory(&mut self, arg0: X87Float64BitMemory)

Copy ST(0) to m64fp.

pub fn fst_X87Register(&mut self, arg0: X87Register)

Copy ST(0) to ST(i).

pub fn fstcw_Contiguous2ByteMemory(&mut self, arg0: Contiguous2ByteMemory)

Store Floating Point Unit (FPU) control word to m2byte after checking for pending unmasked floating-point exceptions.

pub fn fstenv_Contiguous28ByteMemory(&mut self, arg0: Contiguous28ByteMemory)

Store Floating Point Unit (FPU) environment to m14byte or m28byte after checking for pending unmasked floating-point exceptions.

Then mask all floating-point exceptions.

pub fn fstp_X87Float32BitMemory(&mut self, arg0: X87Float32BitMemory)

Copy ST(0) to m32fp and pop register stack.

pub fn fstp_X87Float64BitMemory(&mut self, arg0: X87Float64BitMemory)

Copy ST(0) to m64fp and pop register stack.

pub fn fstp_X87Float80BitMemory(&mut self, arg0: X87Float80BitMemory)

Copy ST(0) to m80fp and pop register stack.

pub fn fstp_X87Register(&mut self, arg0: X87Register)

Copy ST(0) to ST(i) and pop register stack.

pub fn fstsw_AX(&mut self)

Store Floating Point Unit (FPU) status word in AX register after checking for pending unmasked floating-point exceptions.

pub fn fstsw_Contiguous2ByteMemory(&mut self, arg0: Contiguous2ByteMemory)

Store Floating Point Unit (FPU) status word at m2byte after checking for pending unmasked floating-point exceptions.

pub fn fsub_X87Float32BitMemory(&mut self, arg0: X87Float32BitMemory)

Subtract m32fp from ST(0) and store result in ST(0).

pub fn fsub_X87Float64BitMemory(&mut self, arg0: X87Float64BitMemory)

Subtract m64fp from ST(0) and store result in ST(0).

pub fn fsub_X87Register_ST0(&mut self, arg0: X87Register)

Subtract ST(0) from ST(i) and store result in ST(i).

pub fn fsub_ST0_X87Register(&mut self, arg1: X87Register)

Subtract ST(i) from ST(0) and store result in ST(0).

pub fn fsubp(&mut self)

Subtract ST(0) from ST(1) with result stored in in ST(1), and pop register stack.

pub fn fsubp_X87Register_ST0(&mut self, arg0: X87Register)

Subtract ST(0) from ST(i) with result stored in in ST(i), and pop register stack.

pub fn fsubr_X87Float32BitMemory(&mut self, arg0: X87Float32BitMemory)

Subtract ST(0) from m32fp and store result in ST(0).

pub fn fsubr_X87Float64BitMemory(&mut self, arg0: X87Float64BitMemory)

Subtract ST(0) from m64fp and store result in ST(0).

pub fn fsubr_X87Register_ST0(&mut self, arg0: X87Register)

Subtract ST(i) from ST(0) and store result in ST(i).

pub fn fsubr_ST0_X87Register(&mut self, arg1: X87Register)

Subtract ST(0) from ST(i) and store result in ST(0).

pub fn fsubrp(&mut self)

Subtract ST(1) from ST(0) with result stored in in ST(1), and pop register stack.

pub fn fsubrp_X87Register_ST0(&mut self, arg0: X87Register)

Subtract ST(i) from ST(0) with result stored in in ST(i), and pop register stack.

pub fn ftst(&mut self)

Compare ST(0) with 0.0.

pub fn fucom(&mut self)

Compare ST(0) with ST(1).

pub fn fucom_X87Register(&mut self, arg0: X87Register)

Compare ST(0) with ST(i).

pub fn fucomi_ST0_X87Register(&mut self, arg1: X87Register)

Compare ST(0) with ST(i), check for ordered values, and set status flags accordingly.

pub fn fucomip_ST0_X87Register(&mut self, arg1: X87Register)

Compare ST(0) with ST(i), check for ordered values, set status flags accordingly, and pop register stack.

pub fn fucomp(&mut self)

Compare ST(0) with ST(1) and pop register stack.

pub fn fucomp_X87Register(&mut self, arg0: X87Register)

Compare ST(0) with ST(i) and pop register stack.

pub fn fucompp(&mut self)

Compare ST(0) with ST(1) and pop register stack twice.

pub fn fwait(&mut self)

Check pending unmasked floating-point exceptions.

pub fn fxam(&mut self)

Classify value or number in ST(0).

pub fn fxch(&mut self)

Exchange the contents of ST(0) and ST(1).

pub fn fxch_X87Register(&mut self, arg0: X87Register)

Exchange the contents of ST(0) and ST(i).

pub fn fxrstor_Contiguous512ByteMemory(&mut self, arg0: Contiguous512ByteMemory)

Restore the x87 Floating Point Unit (FPU), MMX, XMM, and MXCSR register state from m512byte.

pub fn fxrstor64_Contiguous512ByteMemory(
    &mut self,
    arg0: Contiguous512ByteMemory
)

Restore the x87 Floating Point Unit (FPU), MMX, XMM, and MXCSR register state from m512byte.

pub fn fxsave_Contiguous512ByteMemory(&mut self, arg0: Contiguous512ByteMemory)

Save the x87 Floating Point Unit (FPU), MMX, XMM, and MXCSR register state to m512byte.

pub fn fxsave64_Contiguous512ByteMemory(&mut self, arg0: Contiguous512ByteMemory)

Save the x87 Floating Point Unit (FPU), MMX, XMM, and MXCSR register state to m512byte.

pub fn fxtract(&mut self)

Separate value in ST(0) into exponent and significand, store exponent in ST(0), and push the significand onto the register stack.

pub fn fyl2x(&mut self)

Replace ST(1) with (ST(1) * log2ST(0)) and pop the register stack.

pub fn fyl2xp1(&mut self)

Replace ST(1) with ST(1) * log2(ST(0) + 1.0) and pop the register stack.

pub fn haddpd_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Horizontal add packed double-precision floating-point values from xmm2/m128 to xmm1.

pub fn haddpd_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Horizontal add packed double-precision floating-point values from xmm2/m128 to xmm1.

pub fn haddps_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Horizontal add packed single-precision floating-point values from xmm2/m128 to xmm1.

pub fn haddps_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Horizontal add packed single-precision floating-point values from xmm2/m128 to xmm1.

pub fn hsubpd_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Horizontal subtract packed double-precision floating-point values from xmm2/m128 to xmm1.

pub fn hsubpd_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Horizontal subtract packed double-precision floating-point values from xmm2/m128 to xmm1.

pub fn hsubps_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Horizontal subtract packed single-precision floating-point values from xmm2/m128 to xmm1.

pub fn hsubps_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Horizontal subtract packed single-precision floating-point values from xmm2/m128 to xmm1.

pub fn idiv_Any16BitMemory(&mut self, arg0: Any16BitMemory)

Signed divide DX:AX by r/m16, with result stored in AX (Quotient) and DX (Remainder).

pub fn idiv_Any32BitMemory(&mut self, arg0: Any32BitMemory)

Signed divide EDX:EAX by r/m32, with result stored in EAX (Quotient) and EDX (Remainder).

pub fn idiv_Any64BitMemory(&mut self, arg0: Any64BitMemory)

Signed divide RDX:RAX by r/m64, with result stored in RAX (Quotient) and RDX (Remainder).

pub fn idiv_Any8BitMemory(&mut self, arg0: Any8BitMemory)

Signed divide AX by r/m8, with result stored in AL (Quotient) and AH (Remainder).

pub fn idiv_Register16Bit(&mut self, arg0: Register16Bit)

Signed divide DX:AX by r/m16, with result stored in AX (Quotient) and DX (Remainder).

pub fn idiv_Register32Bit(&mut self, arg0: Register32Bit)

Signed divide EDX:EAX by r/m32, with result stored in EAX (Quotient) and EDX (Remainder).

pub fn idiv_Register64Bit(&mut self, arg0: Register64Bit)

Signed divide RDX:RAX by r/m64, with result stored in RAX (Quotient) and RDX (Remainder).

pub fn idiv_Register8Bit(&mut self, arg0: Register8Bit)

Signed divide AX by r/m8, with result stored in AL (Quotient) and AH (Remainder).

pub fn idiv_RegisterHigh8BitsOf16Bits(&mut self, arg0: RegisterHigh8BitsOf16Bits)

Signed divide AX by r/m8, with result stored in AL (Quotient) and AH (Remainder).

pub fn imul_Any16BitMemory(&mut self, arg0: Any16BitMemory)

DX:AX = AX * r/m16.

pub fn imul_Any32BitMemory(&mut self, arg0: Any32BitMemory)

EDX:EAX = EAX * r/m32.

pub fn imul_Any64BitMemory(&mut self, arg0: Any64BitMemory)

RDX:RAX = RAX * r/m64.

pub fn imul_Any8BitMemory(&mut self, arg0: Any8BitMemory)

AX = AL * r/m8.

pub fn imul_Register16Bit(&mut self, arg0: Register16Bit)

DX:AX = AX * r/m16.

pub fn imul_Register16Bit_Any16BitMemory(
    &mut self,
    arg0: Register16Bit,
    arg1: Any16BitMemory
)

word register = word register * r/m16.

pub fn imul_Register16Bit_Any16BitMemory_Immediate16Bit(
    &mut self,
    arg0: Register16Bit,
    arg1: Any16BitMemory,
    arg2: Immediate16Bit
)

word register = r/m16 * immediate word.

pub fn imul_Register16Bit_Any16BitMemory_Immediate8Bit(
    &mut self,
    arg0: Register16Bit,
    arg1: Any16BitMemory,
    arg2: Immediate8Bit
)

word register = r/m16 * sign-extended imm8.

pub fn imul_Register16Bit_Register16Bit(
    &mut self,
    arg0: Register16Bit,
    arg1: Register16Bit
)

word register = word register * r/m16.

pub fn imul_Register16Bit_Register16Bit_Immediate16Bit(
    &mut self,
    arg0: Register16Bit,
    arg1: Register16Bit,
    arg2: Immediate16Bit
)

word register = r/m16 * immediate word.

pub fn imul_Register16Bit_Register16Bit_Immediate8Bit(
    &mut self,
    arg0: Register16Bit,
    arg1: Register16Bit,
    arg2: Immediate8Bit
)

word register = r/m16 * sign-extended imm8.

pub fn imul_Register32Bit(&mut self, arg0: Register32Bit)

EDX:EAX = EAX * r/m32.

pub fn imul_Register32Bit_Any32BitMemory(
    &mut self,
    arg0: Register32Bit,
    arg1: Any32BitMemory
)

doubleword register = doubleword register * r/m32.

pub fn imul_Register32Bit_Any32BitMemory_Immediate32Bit(
    &mut self,
    arg0: Register32Bit,
    arg1: Any32BitMemory,
    arg2: Immediate32Bit
)

doubleword register = r/m32 * imm32.

pub fn imul_Register32Bit_Any32BitMemory_Immediate8Bit(
    &mut self,
    arg0: Register32Bit,
    arg1: Any32BitMemory,
    arg2: Immediate8Bit
)

doubleword register = r/m32 * sign-extended imm8.

pub fn imul_Register32Bit_Register32Bit(
    &mut self,
    arg0: Register32Bit,
    arg1: Register32Bit
)

doubleword register = doubleword register * r/m32.

pub fn imul_Register32Bit_Register32Bit_Immediate32Bit(
    &mut self,
    arg0: Register32Bit,
    arg1: Register32Bit,
    arg2: Immediate32Bit
)

doubleword register = r/m32 * imm32.

pub fn imul_Register32Bit_Register32Bit_Immediate8Bit(
    &mut self,
    arg0: Register32Bit,
    arg1: Register32Bit,
    arg2: Immediate8Bit
)

doubleword register = r/m32 * sign-extended imm8.

pub fn imul_Register64Bit(&mut self, arg0: Register64Bit)

RDX:RAX = RAX * r/m64.

pub fn imul_Register64Bit_Any64BitMemory(
    &mut self,
    arg0: Register64Bit,
    arg1: Any64BitMemory
)

Quadword register = Quadword register * r/m64.

pub fn imul_Register64Bit_Any64BitMemory_Immediate32Bit(
    &mut self,
    arg0: Register64Bit,
    arg1: Any64BitMemory,
    arg2: Immediate32Bit
)

Quadword register = r/m64 * imm32.

pub fn imul_Register64Bit_Any64BitMemory_Immediate8Bit(
    &mut self,
    arg0: Register64Bit,
    arg1: Any64BitMemory,
    arg2: Immediate8Bit
)

Quadword register = r/m64 * sign-extended imm8.

pub fn imul_Register64Bit_Register64Bit(
    &mut self,
    arg0: Register64Bit,
    arg1: Register64Bit
)

Quadword register = Quadword register * r/m64.

pub fn imul_Register64Bit_Register64Bit_Immediate32Bit(
    &mut self,
    arg0: Register64Bit,
    arg1: Register64Bit,
    arg2: Immediate32Bit
)

Quadword register = r/m64 * imm32.

pub fn imul_Register64Bit_Register64Bit_Immediate8Bit(
    &mut self,
    arg0: Register64Bit,
    arg1: Register64Bit,
    arg2: Immediate8Bit
)

Quadword register = r/m64 * sign-extended imm8.

pub fn imul_Register8Bit(&mut self, arg0: Register8Bit)

AX = AL * r/m8.

pub fn imul_RegisterHigh8BitsOf16Bits(&mut self, arg0: RegisterHigh8BitsOf16Bits)

AX = AL * r/m8.

pub fn in_AL_DX(&mut self)

Input byte from I/O port in DX into AL.

pub fn in_AL_Immediate8Bit(&mut self, arg1: Immediate8Bit)

Input byte from imm8 I/O port address into AL.

pub fn in_AX_DX(&mut self)

Input word from I/O port in DX into AX.

pub fn in_AX_Immediate8Bit(&mut self, arg1: Immediate8Bit)

Input word from imm8 I/O port address into AX.

pub fn in_EAX_DX(&mut self)

Input doubleword from I/O port in DX into EAX.

pub fn in_EAX_Immediate8Bit(&mut self, arg1: Immediate8Bit)

Input dword from imm8 I/O port address into EAX.

pub fn inc_Any16BitMemory(&mut self, arg0: Any16BitMemory)

Increment r/m16 by 1.

pub fn inc_Any32BitMemory(&mut self, arg0: Any32BitMemory)

Increment r/m32 by 1.

pub fn inc_Any64BitMemory(&mut self, arg0: Any64BitMemory)

Increment r/m64 by 1.

pub fn inc_Any8BitMemory(&mut self, arg0: Any8BitMemory)

Increment r/m8 by 1.

pub fn inc_Register16Bit(&mut self, arg0: Register16Bit)

Increment r/m16 by 1.

pub fn inc_Register32Bit(&mut self, arg0: Register32Bit)

Increment r/m32 by 1.

pub fn inc_Register64Bit(&mut self, arg0: Register64Bit)

Increment r/m64 by 1.

pub fn inc_Register8Bit(&mut self, arg0: Register8Bit)

Increment r/m8 by 1.

pub fn inc_RegisterHigh8BitsOf16Bits(&mut self, arg0: RegisterHigh8BitsOf16Bits)

Increment r/m8 by 1.

pub fn ins_Any16BitMemory_DX(
    &mut self,
    arg0: Option<SegmentRegister>,
    address_override_for_32_bit: bool
)

Input word from I/O port specified in DX into memory location specified in ES:(E)DI or RDI.

pub fn ins_Any32BitMemory_DX(
    &mut self,
    arg0: Option<SegmentRegister>,
    address_override_for_32_bit: bool
)

Input doubleword from I/O port specified in DX into memory location specified in ES:(E)DI or RDI.

pub fn ins_Any8BitMemory_DX(
    &mut self,
    arg0: Option<SegmentRegister>,
    address_override_for_32_bit: bool
)

Input byte from I/O port specified in DX into memory location specified in ES:(E)DI or RDI.

pub fn insb(&mut self)

Input byte from I/O port specified in DX into memory location specified with ES:(E)DI or RDI.

pub fn insd(&mut self)

Input doubleword from I/O port specified in DX into memory location specified in ES:(E)DI or RDI.

pub fn insertps_XMMRegister_Any32BitMemory_Immediate8Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: Any32BitMemory,
    arg2: Immediate8Bit
)

Insert a single-precision floating-point value selected by imm8 from xmm2/m32 into xmm1 at the specified destination element specified by imm8 and zero out destination elements in xmm1 as indicated in imm8.

pub fn insertps_XMMRegister_XMMRegister_Immediate8Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Immediate8Bit
)

Insert a single-precision floating-point value selected by imm8 from xmm2/m32 into xmm1 at the specified destination element specified by imm8 and zero out destination elements in xmm1 as indicated in imm8.

pub fn insw(&mut self)

Input word from I/O port specified in DX into memory location specified in ES:(E)DI or RDI.

pub fn int_Immediate8Bit(&mut self, arg0: Immediate8Bit)

Interrupt vector number specified by imm8.

pub fn int_Three(&mut self)

Interrupt 3-trap to debugger.

pub fn invpcid_Register64Bit_Any128BitMemory(
    &mut self,
    arg0: Register64Bit,
    arg1: Any128BitMemory
)

Invalidates entries in the TLBs and paging-structure caches based on invalidation type in r64 and descriptor in m128.

pub fn iret(&mut self)

Interrupt return (16-bit operand size).

pub fn iretd(&mut self)

Interrupt return (32-bit operand size).

pub fn iretq(&mut self)

Interrupt return (64-bit operand size).

pub fn ja_Label(&mut self, arg0: Label) -> ShortJmpResult

Jump short if above (Carry Flag (CF) is 0 and Zero Flag (ZF) is 0).

pub fn ja_Label_1(&mut self, arg0: Label)

Jump near if above (Carry Flag (CF) is 0 and Zero Flag (ZF) is 0).

pub fn ja_Label_BranchHint(
    &mut self,
    arg0: Label,
    arg1: BranchHint
) -> ShortJmpResult

Jump short if above (Carry Flag (CF) is 0 and Zero Flag (ZF) is 0).

pub fn ja_Label_BranchHint_1(&mut self, arg0: Label, arg1: BranchHint)

Jump near if above (Carry Flag (CF) is 0 and Zero Flag (ZF) is 0).

pub fn ja_RelativeAddress32Bit(&mut self, arg0: RelativeAddress32Bit)

Jump near if above (Carry Flag (CF) is 0 and Zero Flag (ZF) is 0).

pub fn ja_RelativeAddress32Bit_BranchHint(
    &mut self,
    arg0: RelativeAddress32Bit,
    arg1: BranchHint
)

Jump near if above (Carry Flag (CF) is 0 and Zero Flag (ZF) is 0).

pub fn ja_RelativeAddress8Bit(&mut self, arg0: RelativeAddress8Bit)

Jump short if above (Carry Flag (CF) is 0 and Zero Flag (ZF) is 0).

pub fn ja_RelativeAddress8Bit_BranchHint(
    &mut self,
    arg0: RelativeAddress8Bit,
    arg1: BranchHint
)

Jump short if above (Carry Flag (CF) is 0 and Zero Flag (ZF) is 0).

pub fn jae_Label(&mut self, arg0: Label) -> ShortJmpResult

Jump short if above or equal (Carry Flag (CF) is 0).

pub fn jae_Label_1(&mut self, arg0: Label)

Jump near if above or equal (Carry Flag (CF) is 0).

pub fn jae_Label_BranchHint(
    &mut self,
    arg0: Label,
    arg1: BranchHint
) -> ShortJmpResult

Jump short if above or equal (Carry Flag (CF) is 0).

pub fn jae_Label_BranchHint_1(&mut self, arg0: Label, arg1: BranchHint)

Jump near if above or equal (Carry Flag (CF) is 0).

pub fn jae_RelativeAddress32Bit(&mut self, arg0: RelativeAddress32Bit)

Jump near if above or equal (Carry Flag (CF) is 0).

pub fn jae_RelativeAddress32Bit_BranchHint(
    &mut self,
    arg0: RelativeAddress32Bit,
    arg1: BranchHint
)

Jump near if above or equal (Carry Flag (CF) is 0).

pub fn jae_RelativeAddress8Bit(&mut self, arg0: RelativeAddress8Bit)

Jump short if above or equal (Carry Flag (CF) is 0).

pub fn jae_RelativeAddress8Bit_BranchHint(
    &mut self,
    arg0: RelativeAddress8Bit,
    arg1: BranchHint
)

Jump short if above or equal (Carry Flag (CF) is 0).

pub fn jb_Label(&mut self, arg0: Label) -> ShortJmpResult

Jump short if below (Carry Flag (CF) is 1).

pub fn jb_Label_1(&mut self, arg0: Label)

Jump near if below (Carry Flag (CF) is 1).

pub fn jb_Label_BranchHint(
    &mut self,
    arg0: Label,
    arg1: BranchHint
) -> ShortJmpResult

Jump short if below (Carry Flag (CF) is 1).

pub fn jb_Label_BranchHint_1(&mut self, arg0: Label, arg1: BranchHint)

Jump near if below (Carry Flag (CF) is 1).

pub fn jb_RelativeAddress32Bit(&mut self, arg0: RelativeAddress32Bit)

Jump near if below (Carry Flag (CF) is 1).

pub fn jb_RelativeAddress32Bit_BranchHint(
    &mut self,
    arg0: RelativeAddress32Bit,
    arg1: BranchHint
)

Jump near if below (Carry Flag (CF) is 1).

pub fn jb_RelativeAddress8Bit(&mut self, arg0: RelativeAddress8Bit)

Jump short if below (Carry Flag (CF) is 1).

pub fn jb_RelativeAddress8Bit_BranchHint(
    &mut self,
    arg0: RelativeAddress8Bit,
    arg1: BranchHint
)

Jump short if below (Carry Flag (CF) is 1).

pub fn jbe_Label(&mut self, arg0: Label) -> ShortJmpResult

Jump short if below or equal (Carry Flag (CF) is 1 or Zero Flag (ZF) is 1).

pub fn jbe_Label_1(&mut self, arg0: Label)

Jump near if below or equal (Carry Flag (CF) is 1 or Zero Flag (ZF) is 1).

pub fn jbe_Label_BranchHint(
    &mut self,
    arg0: Label,
    arg1: BranchHint
) -> ShortJmpResult

Jump short if below or equal (Carry Flag (CF) is 1 or Zero Flag (ZF) is 1).

pub fn jbe_Label_BranchHint_1(&mut self, arg0: Label, arg1: BranchHint)

Jump near if below or equal (Carry Flag (CF) is 1 or Zero Flag (ZF) is 1).

pub fn jbe_RelativeAddress32Bit(&mut self, arg0: RelativeAddress32Bit)

Jump near if below or equal (Carry Flag (CF) is 1 or Zero Flag (ZF) is 1).

pub fn jbe_RelativeAddress32Bit_BranchHint(
    &mut self,
    arg0: RelativeAddress32Bit,
    arg1: BranchHint
)

Jump near if below or equal (Carry Flag (CF) is 1 or Zero Flag (ZF) is 1).

pub fn jbe_RelativeAddress8Bit(&mut self, arg0: RelativeAddress8Bit)

Jump short if below or equal (Carry Flag (CF) is 1 or Zero Flag (ZF) is 1).

pub fn jbe_RelativeAddress8Bit_BranchHint(
    &mut self,
    arg0: RelativeAddress8Bit,
    arg1: BranchHint
)

Jump short if below or equal (Carry Flag (CF) is 1 or Zero Flag (ZF) is 1).

pub fn jc_Label(&mut self, arg0: Label) -> ShortJmpResult

Jump short if carry (Carry Flag (CF) is 1).

pub fn jc_Label_1(&mut self, arg0: Label)

Jump near if carry (Carry Flag (CF) is 1).

pub fn jc_Label_BranchHint(
    &mut self,
    arg0: Label,
    arg1: BranchHint
) -> ShortJmpResult

Jump short if carry (Carry Flag (CF) is 1).

pub fn jc_Label_BranchHint_1(&mut self, arg0: Label, arg1: BranchHint)

Jump near if carry (Carry Flag (CF) is 1).

pub fn jc_RelativeAddress32Bit(&mut self, arg0: RelativeAddress32Bit)

Jump near if carry (Carry Flag (CF) is 1).

pub fn jc_RelativeAddress32Bit_BranchHint(
    &mut self,
    arg0: RelativeAddress32Bit,
    arg1: BranchHint
)

Jump near if carry (Carry Flag (CF) is 1).

pub fn jc_RelativeAddress8Bit(&mut self, arg0: RelativeAddress8Bit)

Jump short if carry (Carry Flag (CF) is 1).

pub fn jc_RelativeAddress8Bit_BranchHint(
    &mut self,
    arg0: RelativeAddress8Bit,
    arg1: BranchHint
)

Jump short if carry (Carry Flag (CF) is 1).

pub fn je_Label(&mut self, arg0: Label) -> ShortJmpResult

Jump short if equal (Zero Flag (ZF) is 1).

pub fn je_Label_1(&mut self, arg0: Label)

Jump near if 0 (Zero Flag (ZF) is 1).

pub fn je_Label_BranchHint(
    &mut self,
    arg0: Label,
    arg1: BranchHint
) -> ShortJmpResult

Jump short if equal (Zero Flag (ZF) is 1).

pub fn je_Label_BranchHint_1(&mut self, arg0: Label, arg1: BranchHint)

Jump near if 0 (Zero Flag (ZF) is 1).

pub fn je_RelativeAddress32Bit(&mut self, arg0: RelativeAddress32Bit)

Jump near if 0 (Zero Flag (ZF) is 1).

pub fn je_RelativeAddress32Bit_BranchHint(
    &mut self,
    arg0: RelativeAddress32Bit,
    arg1: BranchHint
)

Jump near if 0 (Zero Flag (ZF) is 1).

pub fn je_RelativeAddress8Bit(&mut self, arg0: RelativeAddress8Bit)

Jump short if equal (Zero Flag (ZF) is 1).

pub fn je_RelativeAddress8Bit_BranchHint(
    &mut self,
    arg0: RelativeAddress8Bit,
    arg1: BranchHint
)

Jump short if equal (Zero Flag (ZF) is 1).

pub fn jecxz_Label(&mut self, arg0: Label) -> ShortJmpResult

Jump short if ECX register is 0.

pub fn jecxz_Label_BranchHint(
    &mut self,
    arg0: Label,
    arg1: BranchHint
) -> ShortJmpResult

Jump short if ECX register is 0.

pub fn jecxz_RelativeAddress8Bit(&mut self, arg0: RelativeAddress8Bit)

Jump short if ECX register is 0.

pub fn jecxz_RelativeAddress8Bit_BranchHint(
    &mut self,
    arg0: RelativeAddress8Bit,
    arg1: BranchHint
)

Jump short if ECX register is 0.

pub fn jg_Label(&mut self, arg0: Label) -> ShortJmpResult

Jump short if greater (Zero Flag (ZF) is 0 and Sign Flag (SF) == Overflow Flag (OF)).

pub fn jg_Label_1(&mut self, arg0: Label)

Jump near if greater (Zero Flag (ZF) is 0 and Sign Flag (SF) == Overflow Flag (OF)).

pub fn jg_Label_BranchHint(
    &mut self,
    arg0: Label,
    arg1: BranchHint
) -> ShortJmpResult

Jump short if greater (Zero Flag (ZF) is 0 and Sign Flag (SF) == Overflow Flag (OF)).

pub fn jg_Label_BranchHint_1(&mut self, arg0: Label, arg1: BranchHint)

Jump near if greater (Zero Flag (ZF) is 0 and Sign Flag (SF) == Overflow Flag (OF)).

pub fn jg_RelativeAddress32Bit(&mut self, arg0: RelativeAddress32Bit)

Jump near if greater (Zero Flag (ZF) is 0 and Sign Flag (SF) == Overflow Flag (OF)).

pub fn jg_RelativeAddress32Bit_BranchHint(
    &mut self,
    arg0: RelativeAddress32Bit,
    arg1: BranchHint
)

Jump near if greater (Zero Flag (ZF) is 0 and Sign Flag (SF) == Overflow Flag (OF)).

pub fn jg_RelativeAddress8Bit(&mut self, arg0: RelativeAddress8Bit)

Jump short if greater (Zero Flag (ZF) is 0 and Sign Flag (SF) == Overflow Flag (OF)).

pub fn jg_RelativeAddress8Bit_BranchHint(
    &mut self,
    arg0: RelativeAddress8Bit,
    arg1: BranchHint
)

Jump short if greater (Zero Flag (ZF) is 0 and Sign Flag (SF) == Overflow Flag (OF)).

pub fn jge_Label(&mut self, arg0: Label) -> ShortJmpResult

Jump short if greater or equal (Sign Flag (SF) == Overflow Flag (OF)).

pub fn jge_Label_1(&mut self, arg0: Label)

Jump near if greater or equal (Sign Flag (SF) == Overflow Flag (OF)).

pub fn jge_Label_BranchHint(
    &mut self,
    arg0: Label,
    arg1: BranchHint
) -> ShortJmpResult

Jump short if greater or equal (Sign Flag (SF) == Overflow Flag (OF)).

pub fn jge_Label_BranchHint_1(&mut self, arg0: Label, arg1: BranchHint)

Jump near if greater or equal (Sign Flag (SF) == Overflow Flag (OF)).

pub fn jge_RelativeAddress32Bit(&mut self, arg0: RelativeAddress32Bit)

Jump near if greater or equal (Sign Flag (SF) == Overflow Flag (OF)).

pub fn jge_RelativeAddress32Bit_BranchHint(
    &mut self,
    arg0: RelativeAddress32Bit,
    arg1: BranchHint
)

Jump near if greater or equal (Sign Flag (SF) == Overflow Flag (OF)).

pub fn jge_RelativeAddress8Bit(&mut self, arg0: RelativeAddress8Bit)

Jump short if greater or equal (Sign Flag (SF) == Overflow Flag (OF)).

pub fn jge_RelativeAddress8Bit_BranchHint(
    &mut self,
    arg0: RelativeAddress8Bit,
    arg1: BranchHint
)

Jump short if greater or equal (Sign Flag (SF) == Overflow Flag (OF)).

pub fn jl_Label(&mut self, arg0: Label) -> ShortJmpResult

Jump short if less (Sign Flag (SF) != Overflow Flag (OF)).

pub fn jl_Label_1(&mut self, arg0: Label)

Jump near if less (Sign Flag (SF) != Overflow Flag (OF)).

pub fn jl_Label_BranchHint(
    &mut self,
    arg0: Label,
    arg1: BranchHint
) -> ShortJmpResult

Jump short if less (Sign Flag (SF) != Overflow Flag (OF)).

pub fn jl_Label_BranchHint_1(&mut self, arg0: Label, arg1: BranchHint)

Jump near if less (Sign Flag (SF) != Overflow Flag (OF)).

pub fn jl_RelativeAddress32Bit(&mut self, arg0: RelativeAddress32Bit)

Jump near if less (Sign Flag (SF) != Overflow Flag (OF)).

pub fn jl_RelativeAddress32Bit_BranchHint(
    &mut self,
    arg0: RelativeAddress32Bit,
    arg1: BranchHint
)

Jump near if less (Sign Flag (SF) != Overflow Flag (OF)).

pub fn jl_RelativeAddress8Bit(&mut self, arg0: RelativeAddress8Bit)

Jump short if less (Sign Flag (SF) != Overflow Flag (OF)).

pub fn jl_RelativeAddress8Bit_BranchHint(
    &mut self,
    arg0: RelativeAddress8Bit,
    arg1: BranchHint
)

Jump short if less (Sign Flag (SF) != Overflow Flag (OF)).

pub fn jle_Label(&mut self, arg0: Label) -> ShortJmpResult

Jump short if less or equal (Zero Flag (ZF) is 1 or Sign Flag (SF) != Overflow Flag (OF)).

pub fn jle_Label_1(&mut self, arg0: Label)

Jump near if less or equal (Zero Flag (ZF) is 1 or Sign Flag (SF) != Overflow Flag (OF)).

pub fn jle_Label_BranchHint(
    &mut self,
    arg0: Label,
    arg1: BranchHint
) -> ShortJmpResult

Jump short if less or equal (Zero Flag (ZF) is 1 or Sign Flag (SF) != Overflow Flag (OF)).

pub fn jle_Label_BranchHint_1(&mut self, arg0: Label, arg1: BranchHint)

Jump near if less or equal (Zero Flag (ZF) is 1 or Sign Flag (SF) != Overflow Flag (OF)).

pub fn jle_RelativeAddress32Bit(&mut self, arg0: RelativeAddress32Bit)

Jump near if less or equal (Zero Flag (ZF) is 1 or Sign Flag (SF) != Overflow Flag (OF)).

pub fn jle_RelativeAddress32Bit_BranchHint(
    &mut self,
    arg0: RelativeAddress32Bit,
    arg1: BranchHint
)

Jump near if less or equal (Zero Flag (ZF) is 1 or Sign Flag (SF) != Overflow Flag (OF)).

pub fn jle_RelativeAddress8Bit(&mut self, arg0: RelativeAddress8Bit)

Jump short if less or equal (Zero Flag (ZF) is 1 or Sign Flag (SF) != Overflow Flag (OF)).

pub fn jle_RelativeAddress8Bit_BranchHint(
    &mut self,
    arg0: RelativeAddress8Bit,
    arg1: BranchHint
)

Jump short if less or equal (Zero Flag (ZF) is 1 or Sign Flag (SF) != Overflow Flag (OF)).

pub fn jmp_FarPointer16BitTo16BitMemory(
    &mut self,
    arg0: FarPointer16BitTo16BitMemory
)

Jump far, absolute indirect, address given in m16:16.

pub fn jmp_FarPointer16BitTo32BitMemory(
    &mut self,
    arg0: FarPointer16BitTo32BitMemory
)

Jump far, absolute indirect, address given in m16:32.

pub fn jmp_FarPointer16BitTo64BitMemory(
    &mut self,
    arg0: FarPointer16BitTo64BitMemory
)

Jump far, absolute indirect, address given in m16:64.

pub fn jmp_Label(&mut self, arg0: Label) -> ShortJmpResult

Jump short, RIP = RIP + 8-bit displacement sign extended to 64-bits.

pub fn jmp_Label_1(&mut self, arg0: Label)

Jump near, relative, RIP = RIP + 32-bit displacement sign extended to 64-bits.

pub fn jmp_Any64BitMemory(&mut self, arg0: Any64BitMemory)

Jump near, absolute indirect, RIP = 64-Bit offset from register or memory.

pub fn jmp_Register64Bit(&mut self, arg0: Register64Bit)

Jump near, absolute indirect, RIP = 64-Bit offset from register or memory.

pub fn jmp_RelativeAddress32Bit(&mut self, arg0: RelativeAddress32Bit)

Jump near, relative, RIP = RIP + 32-bit displacement sign extended to 64-bits.

pub fn jmp_RelativeAddress8Bit(&mut self, arg0: RelativeAddress8Bit)

Jump short, RIP = RIP + 8-bit displacement sign extended to 64-bits.

pub fn jna_Label(&mut self, arg0: Label) -> ShortJmpResult

Jump short if not above (Carry Flag (CF) is 1 or Zero Flag (ZF) is 1).

pub fn jna_Label_1(&mut self, arg0: Label)

Jump near if not above (Carry Flag (CF) is 1 or Zero Flag (ZF) is 1).

pub fn jna_Label_BranchHint(
    &mut self,
    arg0: Label,
    arg1: BranchHint
) -> ShortJmpResult

Jump short if not above (Carry Flag (CF) is 1 or Zero Flag (ZF) is 1).

pub fn jna_Label_BranchHint_1(&mut self, arg0: Label, arg1: BranchHint)

Jump near if not above (Carry Flag (CF) is 1 or Zero Flag (ZF) is 1).

pub fn jna_RelativeAddress32Bit(&mut self, arg0: RelativeAddress32Bit)

Jump near if not above (Carry Flag (CF) is 1 or Zero Flag (ZF) is 1).

pub fn jna_RelativeAddress32Bit_BranchHint(
    &mut self,
    arg0: RelativeAddress32Bit,
    arg1: BranchHint
)

Jump near if not above (Carry Flag (CF) is 1 or Zero Flag (ZF) is 1).

pub fn jna_RelativeAddress8Bit(&mut self, arg0: RelativeAddress8Bit)

Jump short if not above (Carry Flag (CF) is 1 or Zero Flag (ZF) is 1).

pub fn jna_RelativeAddress8Bit_BranchHint(
    &mut self,
    arg0: RelativeAddress8Bit,
    arg1: BranchHint
)

Jump short if not above (Carry Flag (CF) is 1 or Zero Flag (ZF) is 1).

pub fn jnae_Label(&mut self, arg0: Label) -> ShortJmpResult

Jump short if not above or equal (Carry Flag (CF) is 1).

pub fn jnae_Label_1(&mut self, arg0: Label)

Jump near if not above or equal (Carry Flag (CF) is 1).

pub fn jnae_Label_BranchHint(
    &mut self,
    arg0: Label,
    arg1: BranchHint
) -> ShortJmpResult

Jump short if not above or equal (Carry Flag (CF) is 1).

pub fn jnae_Label_BranchHint_1(&mut self, arg0: Label, arg1: BranchHint)

Jump near if not above or equal (Carry Flag (CF) is 1).

pub fn jnae_RelativeAddress32Bit(&mut self, arg0: RelativeAddress32Bit)

Jump near if not above or equal (Carry Flag (CF) is 1).

pub fn jnae_RelativeAddress32Bit_BranchHint(
    &mut self,
    arg0: RelativeAddress32Bit,
    arg1: BranchHint
)

Jump near if not above or equal (Carry Flag (CF) is 1).

pub fn jnae_RelativeAddress8Bit(&mut self, arg0: RelativeAddress8Bit)

Jump short if not above or equal (Carry Flag (CF) is 1).

pub fn jnae_RelativeAddress8Bit_BranchHint(
    &mut self,
    arg0: RelativeAddress8Bit,
    arg1: BranchHint
)

Jump short if not above or equal (Carry Flag (CF) is 1).

pub fn jnb_Label(&mut self, arg0: Label) -> ShortJmpResult

Jump short if not below (Carry Flag (CF) is 0).

pub fn jnb_Label_1(&mut self, arg0: Label)

Jump near if not below (Carry Flag (CF) is 0).

pub fn jnb_Label_BranchHint(
    &mut self,
    arg0: Label,
    arg1: BranchHint
) -> ShortJmpResult

Jump short if not below (Carry Flag (CF) is 0).

pub fn jnb_Label_BranchHint_1(&mut self, arg0: Label, arg1: BranchHint)

Jump near if not below (Carry Flag (CF) is 0).

pub fn jnb_RelativeAddress32Bit(&mut self, arg0: RelativeAddress32Bit)

Jump near if not below (Carry Flag (CF) is 0).

pub fn jnb_RelativeAddress32Bit_BranchHint(
    &mut self,
    arg0: RelativeAddress32Bit,
    arg1: BranchHint
)

Jump near if not below (Carry Flag (CF) is 0).

pub fn jnb_RelativeAddress8Bit(&mut self, arg0: RelativeAddress8Bit)

Jump short if not below (Carry Flag (CF) is 0).

pub fn jnb_RelativeAddress8Bit_BranchHint(
    &mut self,
    arg0: RelativeAddress8Bit,
    arg1: BranchHint
)

Jump short if not below (Carry Flag (CF) is 0).

pub fn jnbe_Label(&mut self, arg0: Label) -> ShortJmpResult

Jump short if not below or equal (Carry Flag (CF) is 0 and Zero Flag (ZF) is 0).

pub fn jnbe_Label_1(&mut self, arg0: Label)

Jump near if not below or equal (Carry Flag (CF) is 0 and Zero Flag (ZF) is 0).

pub fn jnbe_Label_BranchHint(
    &mut self,
    arg0: Label,
    arg1: BranchHint
) -> ShortJmpResult

Jump short if not below or equal (Carry Flag (CF) is 0 and Zero Flag (ZF) is 0).

pub fn jnbe_Label_BranchHint_1(&mut self, arg0: Label, arg1: BranchHint)

Jump near if not below or equal (Carry Flag (CF) is 0 and Zero Flag (ZF) is 0).

pub fn jnbe_RelativeAddress32Bit(&mut self, arg0: RelativeAddress32Bit)

Jump near if not below or equal (Carry Flag (CF) is 0 and Zero Flag (ZF) is 0).

pub fn jnbe_RelativeAddress32Bit_BranchHint(
    &mut self,
    arg0: RelativeAddress32Bit,
    arg1: BranchHint
)

Jump near if not below or equal (Carry Flag (CF) is 0 and Zero Flag (ZF) is 0).

pub fn jnbe_RelativeAddress8Bit(&mut self, arg0: RelativeAddress8Bit)

Jump short if not below or equal (Carry Flag (CF) is 0 and Zero Flag (ZF) is 0).

pub fn jnbe_RelativeAddress8Bit_BranchHint(
    &mut self,
    arg0: RelativeAddress8Bit,
    arg1: BranchHint
)

Jump short if not below or equal (Carry Flag (CF) is 0 and Zero Flag (ZF) is 0).

pub fn jnc_Label(&mut self, arg0: Label) -> ShortJmpResult

Jump short if not carry (Carry Flag (CF) is 0).

pub fn jnc_Label_1(&mut self, arg0: Label)

Jump near if not carry (Carry Flag (CF) is 0).

pub fn jnc_Label_BranchHint(
    &mut self,
    arg0: Label,
    arg1: BranchHint
) -> ShortJmpResult

Jump short if not carry (Carry Flag (CF) is 0).

pub fn jnc_Label_BranchHint_1(&mut self, arg0: Label, arg1: BranchHint)

Jump near if not carry (Carry Flag (CF) is 0).

pub fn jnc_RelativeAddress32Bit(&mut self, arg0: RelativeAddress32Bit)

Jump near if not carry (Carry Flag (CF) is 0).

pub fn jnc_RelativeAddress32Bit_BranchHint(
    &mut self,
    arg0: RelativeAddress32Bit,
    arg1: BranchHint
)

Jump near if not carry (Carry Flag (CF) is 0).

pub fn jnc_RelativeAddress8Bit(&mut self, arg0: RelativeAddress8Bit)

Jump short if not carry (Carry Flag (CF) is 0).

pub fn jnc_RelativeAddress8Bit_BranchHint(
    &mut self,
    arg0: RelativeAddress8Bit,
    arg1: BranchHint
)

Jump short if not carry (Carry Flag (CF) is 0).

pub fn jne_Label(&mut self, arg0: Label) -> ShortJmpResult

Jump short if not equal (Zero Flag (ZF) is 0).

pub fn jne_Label_1(&mut self, arg0: Label)

Jump near if not equal (Zero Flag (ZF) is 0).

pub fn jne_Label_BranchHint(
    &mut self,
    arg0: Label,
    arg1: BranchHint
) -> ShortJmpResult

Jump short if not equal (Zero Flag (ZF) is 0).

pub fn jne_Label_BranchHint_1(&mut self, arg0: Label, arg1: BranchHint)

Jump near if not equal (Zero Flag (ZF) is 0).

pub fn jne_RelativeAddress32Bit(&mut self, arg0: RelativeAddress32Bit)

Jump near if not equal (Zero Flag (ZF) is 0).

pub fn jne_RelativeAddress32Bit_BranchHint(
    &mut self,
    arg0: RelativeAddress32Bit,
    arg1: BranchHint
)

Jump near if not equal (Zero Flag (ZF) is 0).

pub fn jne_RelativeAddress8Bit(&mut self, arg0: RelativeAddress8Bit)

Jump short if not equal (Zero Flag (ZF) is 0).

pub fn jne_RelativeAddress8Bit_BranchHint(
    &mut self,
    arg0: RelativeAddress8Bit,
    arg1: BranchHint
)

Jump short if not equal (Zero Flag (ZF) is 0).

pub fn jng_Label(&mut self, arg0: Label) -> ShortJmpResult

Jump short if not greater (Zero Flag (ZF) is 1 or Sign Flag (SF) != Overflow Flag (OF)).

pub fn jng_Label_1(&mut self, arg0: Label)

Jump near if not greater (Zero Flag (ZF) is 1 or Sign Flag (SF) != Overflow Flag (OF)).

pub fn jng_Label_BranchHint(
    &mut self,
    arg0: Label,
    arg1: BranchHint
) -> ShortJmpResult

Jump short if not greater (Zero Flag (ZF) is 1 or Sign Flag (SF) != Overflow Flag (OF)).

pub fn jng_Label_BranchHint_1(&mut self, arg0: Label, arg1: BranchHint)

Jump near if not greater (Zero Flag (ZF) is 1 or Sign Flag (SF) != Overflow Flag (OF)).

pub fn jng_RelativeAddress32Bit(&mut self, arg0: RelativeAddress32Bit)

Jump near if not greater (Zero Flag (ZF) is 1 or Sign Flag (SF) != Overflow Flag (OF)).

pub fn jng_RelativeAddress32Bit_BranchHint(
    &mut self,
    arg0: RelativeAddress32Bit,
    arg1: BranchHint
)

Jump near if not greater (Zero Flag (ZF) is 1 or Sign Flag (SF) != Overflow Flag (OF)).

pub fn jng_RelativeAddress8Bit(&mut self, arg0: RelativeAddress8Bit)

Jump short if not greater (Zero Flag (ZF) is 1 or Sign Flag (SF) != Overflow Flag (OF)).

pub fn jng_RelativeAddress8Bit_BranchHint(
    &mut self,
    arg0: RelativeAddress8Bit,
    arg1: BranchHint
)

Jump short if not greater (Zero Flag (ZF) is 1 or Sign Flag (SF) != Overflow Flag (OF)).

pub fn jnge_Label(&mut self, arg0: Label) -> ShortJmpResult

Jump short if not greater or equal (Sign Flag (SF) != Overflow Flag (OF)).

pub fn jnge_Label_1(&mut self, arg0: Label)

Jump near if not greater or equal (Sign Flag (SF) != Overflow Flag (OF)).

pub fn jnge_Label_BranchHint(
    &mut self,
    arg0: Label,
    arg1: BranchHint
) -> ShortJmpResult

Jump short if not greater or equal (Sign Flag (SF) != Overflow Flag (OF)).

pub fn jnge_Label_BranchHint_1(&mut self, arg0: Label, arg1: BranchHint)

Jump near if not greater or equal (Sign Flag (SF) != Overflow Flag (OF)).

pub fn jnge_RelativeAddress32Bit(&mut self, arg0: RelativeAddress32Bit)

Jump near if not greater or equal (Sign Flag (SF) != Overflow Flag (OF)).

pub fn jnge_RelativeAddress32Bit_BranchHint(
    &mut self,
    arg0: RelativeAddress32Bit,
    arg1: BranchHint
)

Jump near if not greater or equal (Sign Flag (SF) != Overflow Flag (OF)).

pub fn jnge_RelativeAddress8Bit(&mut self, arg0: RelativeAddress8Bit)

Jump short if not greater or equal (Sign Flag (SF) != Overflow Flag (OF)).

pub fn jnge_RelativeAddress8Bit_BranchHint(
    &mut self,
    arg0: RelativeAddress8Bit,
    arg1: BranchHint
)

Jump short if not greater or equal (Sign Flag (SF) != Overflow Flag (OF)).

pub fn jnl_Label(&mut self, arg0: Label) -> ShortJmpResult

Jump short if not less (Sign Flag (SF) == Overflow Flag (OF)).

pub fn jnl_Label_1(&mut self, arg0: Label)

Jump near if not less (Sign Flag (SF) == Overflow Flag (OF)).

pub fn jnl_Label_BranchHint(
    &mut self,
    arg0: Label,
    arg1: BranchHint
) -> ShortJmpResult

Jump short if not less (Sign Flag (SF) == Overflow Flag (OF)).

pub fn jnl_Label_BranchHint_1(&mut self, arg0: Label, arg1: BranchHint)

Jump near if not less (Sign Flag (SF) == Overflow Flag (OF)).

pub fn jnl_RelativeAddress32Bit(&mut self, arg0: RelativeAddress32Bit)

Jump near if not less (Sign Flag (SF) == Overflow Flag (OF)).

pub fn jnl_RelativeAddress32Bit_BranchHint(
    &mut self,
    arg0: RelativeAddress32Bit,
    arg1: BranchHint
)

Jump near if not less (Sign Flag (SF) == Overflow Flag (OF)).

pub fn jnl_RelativeAddress8Bit(&mut self, arg0: RelativeAddress8Bit)

Jump short if not less (Sign Flag (SF) == Overflow Flag (OF)).

pub fn jnl_RelativeAddress8Bit_BranchHint(
    &mut self,
    arg0: RelativeAddress8Bit,
    arg1: BranchHint
)

Jump short if not less (Sign Flag (SF) == Overflow Flag (OF)).

pub fn jnle_Label(&mut self, arg0: Label) -> ShortJmpResult

Jump short if not less or equal (Zero Flag (ZF) is 0 and Sign Flag (SF) == Overflow Flag (OF)).

pub fn jnle_Label_1(&mut self, arg0: Label)

Jump near if not less or equal (Zero Flag (ZF) is 0 and Sign Flag (SF) == Overflow Flag (OF)).

pub fn jnle_Label_BranchHint(
    &mut self,
    arg0: Label,
    arg1: BranchHint
) -> ShortJmpResult

Jump short if not less or equal (Zero Flag (ZF) is 0 and Sign Flag (SF) == Overflow Flag (OF)).

pub fn jnle_Label_BranchHint_1(&mut self, arg0: Label, arg1: BranchHint)

Jump near if not less or equal (Zero Flag (ZF) is 0 and Sign Flag (SF) == Overflow Flag (OF)).

pub fn jnle_RelativeAddress32Bit(&mut self, arg0: RelativeAddress32Bit)

Jump near if not less or equal (Zero Flag (ZF) is 0 and Sign Flag (SF) == Overflow Flag (OF)).

pub fn jnle_RelativeAddress32Bit_BranchHint(
    &mut self,
    arg0: RelativeAddress32Bit,
    arg1: BranchHint
)

Jump near if not less or equal (Zero Flag (ZF) is 0 and Sign Flag (SF) == Overflow Flag (OF)).

pub fn jnle_RelativeAddress8Bit(&mut self, arg0: RelativeAddress8Bit)

Jump short if not less or equal (Zero Flag (ZF) is 0 and Sign Flag (SF) == Overflow Flag (OF)).

pub fn jnle_RelativeAddress8Bit_BranchHint(
    &mut self,
    arg0: RelativeAddress8Bit,
    arg1: BranchHint
)

Jump short if not less or equal (Zero Flag (ZF) is 0 and Sign Flag (SF) == Overflow Flag (OF)).

pub fn jno_Label(&mut self, arg0: Label) -> ShortJmpResult

Jump short if not overflow (Overflow Flag (OF) is 0).

pub fn jno_Label_1(&mut self, arg0: Label)

Jump near if not overflow (Overflow Flag (OF) is 0).

pub fn jno_Label_BranchHint(
    &mut self,
    arg0: Label,
    arg1: BranchHint
) -> ShortJmpResult

Jump short if not overflow (Overflow Flag (OF) is 0).

pub fn jno_Label_BranchHint_1(&mut self, arg0: Label, arg1: BranchHint)

Jump near if not overflow (Overflow Flag (OF) is 0).

pub fn jno_RelativeAddress32Bit(&mut self, arg0: RelativeAddress32Bit)

Jump near if not overflow (Overflow Flag (OF) is 0).

pub fn jno_RelativeAddress32Bit_BranchHint(
    &mut self,
    arg0: RelativeAddress32Bit,
    arg1: BranchHint
)

Jump near if not overflow (Overflow Flag (OF) is 0).

pub fn jno_RelativeAddress8Bit(&mut self, arg0: RelativeAddress8Bit)

Jump short if not overflow (Overflow Flag (OF) is 0).

pub fn jno_RelativeAddress8Bit_BranchHint(
    &mut self,
    arg0: RelativeAddress8Bit,
    arg1: BranchHint
)

Jump short if not overflow (Overflow Flag (OF) is 0).

pub fn jnp_Label(&mut self, arg0: Label) -> ShortJmpResult

Jump short if not parity (Parity Flag (PF) is 0).

pub fn jnp_Label_1(&mut self, arg0: Label)

Jump near if not parity (Parity Flag (PF) is 0).

pub fn jnp_Label_BranchHint(
    &mut self,
    arg0: Label,
    arg1: BranchHint
) -> ShortJmpResult

Jump short if not parity (Parity Flag (PF) is 0).

pub fn jnp_Label_BranchHint_1(&mut self, arg0: Label, arg1: BranchHint)

Jump near if not parity (Parity Flag (PF) is 0).

pub fn jnp_RelativeAddress32Bit(&mut self, arg0: RelativeAddress32Bit)

Jump near if not parity (Parity Flag (PF) is 0).

pub fn jnp_RelativeAddress32Bit_BranchHint(
    &mut self,
    arg0: RelativeAddress32Bit,
    arg1: BranchHint
)

Jump near if not parity (Parity Flag (PF) is 0).

pub fn jnp_RelativeAddress8Bit(&mut self, arg0: RelativeAddress8Bit)

Jump short if not parity (Parity Flag (PF) is 0).

pub fn jnp_RelativeAddress8Bit_BranchHint(
    &mut self,
    arg0: RelativeAddress8Bit,
    arg1: BranchHint
)

Jump short if not parity (Parity Flag (PF) is 0).

pub fn jns_Label(&mut self, arg0: Label) -> ShortJmpResult

Jump short if not sign (Sign Flag (SF) is 0).

pub fn jns_Label_1(&mut self, arg0: Label)

Jump near if not sign (Sign Flag (SF) is 0).

pub fn jns_Label_BranchHint(
    &mut self,
    arg0: Label,
    arg1: BranchHint
) -> ShortJmpResult

Jump short if not sign (Sign Flag (SF) is 0).

pub fn jns_Label_BranchHint_1(&mut self, arg0: Label, arg1: BranchHint)

Jump near if not sign (Sign Flag (SF) is 0).

pub fn jns_RelativeAddress32Bit(&mut self, arg0: RelativeAddress32Bit)

Jump near if not sign (Sign Flag (SF) is 0).

pub fn jns_RelativeAddress32Bit_BranchHint(
    &mut self,
    arg0: RelativeAddress32Bit,
    arg1: BranchHint
)

Jump near if not sign (Sign Flag (SF) is 0).

pub fn jns_RelativeAddress8Bit(&mut self, arg0: RelativeAddress8Bit)

Jump short if not sign (Sign Flag (SF) is 0).

pub fn jns_RelativeAddress8Bit_BranchHint(
    &mut self,
    arg0: RelativeAddress8Bit,
    arg1: BranchHint
)

Jump short if not sign (Sign Flag (SF) is 0).

pub fn jnz_Label(&mut self, arg0: Label) -> ShortJmpResult

Jump short if not zero (Zero Flag (ZF) is 0).

pub fn jnz_Label_1(&mut self, arg0: Label)

Jump near if not zero (Zero Flag (ZF) is 0).

pub fn jnz_Label_BranchHint(
    &mut self,
    arg0: Label,
    arg1: BranchHint
) -> ShortJmpResult

Jump short if not zero (Zero Flag (ZF) is 0).

pub fn jnz_Label_BranchHint_1(&mut self, arg0: Label, arg1: BranchHint)

Jump near if not zero (Zero Flag (ZF) is 0).

pub fn jnz_RelativeAddress32Bit(&mut self, arg0: RelativeAddress32Bit)

Jump near if not zero (Zero Flag (ZF) is 0).

pub fn jnz_RelativeAddress32Bit_BranchHint(
    &mut self,
    arg0: RelativeAddress32Bit,
    arg1: BranchHint
)

Jump near if not zero (Zero Flag (ZF) is 0).

pub fn jnz_RelativeAddress8Bit(&mut self, arg0: RelativeAddress8Bit)

Jump short if not zero (Zero Flag (ZF) is 0).

pub fn jnz_RelativeAddress8Bit_BranchHint(
    &mut self,
    arg0: RelativeAddress8Bit,
    arg1: BranchHint
)

Jump short if not zero (Zero Flag (ZF) is 0).

pub fn jo_Label(&mut self, arg0: Label) -> ShortJmpResult

Jump short if overflow (Overflow Flag (OF) is 1).

pub fn jo_Label_1(&mut self, arg0: Label)

Jump near if overflow (Overflow Flag (OF) is 1).

pub fn jo_Label_BranchHint(
    &mut self,
    arg0: Label,
    arg1: BranchHint
) -> ShortJmpResult

Jump short if overflow (Overflow Flag (OF) is 1).

pub fn jo_Label_BranchHint_1(&mut self, arg0: Label, arg1: BranchHint)

Jump near if overflow (Overflow Flag (OF) is 1).

pub fn jo_RelativeAddress32Bit(&mut self, arg0: RelativeAddress32Bit)

Jump near if overflow (Overflow Flag (OF) is 1).

pub fn jo_RelativeAddress32Bit_BranchHint(
    &mut self,
    arg0: RelativeAddress32Bit,
    arg1: BranchHint
)

Jump near if overflow (Overflow Flag (OF) is 1).

pub fn jo_RelativeAddress8Bit(&mut self, arg0: RelativeAddress8Bit)

Jump short if overflow (Overflow Flag (OF) is 1).

pub fn jo_RelativeAddress8Bit_BranchHint(
    &mut self,
    arg0: RelativeAddress8Bit,
    arg1: BranchHint
)

Jump short if overflow (Overflow Flag (OF) is 1).

pub fn jp_Label(&mut self, arg0: Label) -> ShortJmpResult

Jump short if parity (Parity Flag (PF) is 1).

pub fn jp_Label_1(&mut self, arg0: Label)

Jump near if parity (Parity Flag (PF) is 1).

pub fn jp_Label_BranchHint(
    &mut self,
    arg0: Label,
    arg1: BranchHint
) -> ShortJmpResult

Jump short if parity (Parity Flag (PF) is 1).

pub fn jp_Label_BranchHint_1(&mut self, arg0: Label, arg1: BranchHint)

Jump near if parity (Parity Flag (PF) is 1).

pub fn jp_RelativeAddress32Bit(&mut self, arg0: RelativeAddress32Bit)

Jump near if parity (Parity Flag (PF) is 1).

pub fn jp_RelativeAddress32Bit_BranchHint(
    &mut self,
    arg0: RelativeAddress32Bit,
    arg1: BranchHint
)

Jump near if parity (Parity Flag (PF) is 1).

pub fn jp_RelativeAddress8Bit(&mut self, arg0: RelativeAddress8Bit)

Jump short if parity (Parity Flag (PF) is 1).

pub fn jp_RelativeAddress8Bit_BranchHint(
    &mut self,
    arg0: RelativeAddress8Bit,
    arg1: BranchHint
)

Jump short if parity (Parity Flag (PF) is 1).

pub fn jpe_Label(&mut self, arg0: Label) -> ShortJmpResult

Jump short if parity even (Parity Flag (PF) is 1).

pub fn jpe_Label_1(&mut self, arg0: Label)

Jump near if parity even (Parity Flag (PF) is 1).

pub fn jpe_Label_BranchHint(
    &mut self,
    arg0: Label,
    arg1: BranchHint
) -> ShortJmpResult

Jump short if parity even (Parity Flag (PF) is 1).

pub fn jpe_Label_BranchHint_1(&mut self, arg0: Label, arg1: BranchHint)

Jump near if parity even (Parity Flag (PF) is 1).

pub fn jpe_RelativeAddress32Bit(&mut self, arg0: RelativeAddress32Bit)

Jump near if parity even (Parity Flag (PF) is 1).

pub fn jpe_RelativeAddress32Bit_BranchHint(
    &mut self,
    arg0: RelativeAddress32Bit,
    arg1: BranchHint
)

Jump near if parity even (Parity Flag (PF) is 1).

pub fn jpe_RelativeAddress8Bit(&mut self, arg0: RelativeAddress8Bit)

Jump short if parity even (Parity Flag (PF) is 1).

pub fn jpe_RelativeAddress8Bit_BranchHint(
    &mut self,
    arg0: RelativeAddress8Bit,
    arg1: BranchHint
)

Jump short if parity even (Parity Flag (PF) is 1).

pub fn jpo_Label(&mut self, arg0: Label) -> ShortJmpResult

Jump short if parity odd (Parity Flag (PF) is 0).

pub fn jpo_Label_1(&mut self, arg0: Label)

Jump near if parity odd (Parity Flag (PF) is 0).

pub fn jpo_Label_BranchHint(
    &mut self,
    arg0: Label,
    arg1: BranchHint
) -> ShortJmpResult

Jump short if parity odd (Parity Flag (PF) is 0).

pub fn jpo_Label_BranchHint_1(&mut self, arg0: Label, arg1: BranchHint)

Jump near if parity odd (Parity Flag (PF) is 0).

pub fn jpo_RelativeAddress32Bit(&mut self, arg0: RelativeAddress32Bit)

Jump near if parity odd (Parity Flag (PF) is 0).

pub fn jpo_RelativeAddress32Bit_BranchHint(
    &mut self,
    arg0: RelativeAddress32Bit,
    arg1: BranchHint
)

Jump near if parity odd (Parity Flag (PF) is 0).

pub fn jpo_RelativeAddress8Bit(&mut self, arg0: RelativeAddress8Bit)

Jump short if parity odd (Parity Flag (PF) is 0).

pub fn jpo_RelativeAddress8Bit_BranchHint(
    &mut self,
    arg0: RelativeAddress8Bit,
    arg1: BranchHint
)

Jump short if parity odd (Parity Flag (PF) is 0).

pub fn jrcxz_Label(&mut self, arg0: Label) -> ShortJmpResult

Jump short if RCX register is 0.

pub fn jrcxz_Label_BranchHint(
    &mut self,
    arg0: Label,
    arg1: BranchHint
) -> ShortJmpResult

Jump short if RCX register is 0.

pub fn jrcxz_RelativeAddress8Bit(&mut self, arg0: RelativeAddress8Bit)

Jump short if RCX register is 0.

pub fn jrcxz_RelativeAddress8Bit_BranchHint(
    &mut self,
    arg0: RelativeAddress8Bit,
    arg1: BranchHint
)

Jump short if RCX register is 0.

pub fn js_Label(&mut self, arg0: Label) -> ShortJmpResult

Jump short if sign (Sign Flag (SF) is 1).

pub fn js_Label_1(&mut self, arg0: Label)

Jump near if sign (Sign Flag (SF) is 1).

pub fn js_Label_BranchHint(
    &mut self,
    arg0: Label,
    arg1: BranchHint
) -> ShortJmpResult

Jump short if sign (Sign Flag (SF) is 1).

pub fn js_Label_BranchHint_1(&mut self, arg0: Label, arg1: BranchHint)

Jump near if sign (Sign Flag (SF) is 1).

pub fn js_RelativeAddress32Bit(&mut self, arg0: RelativeAddress32Bit)

Jump near if sign (Sign Flag (SF) is 1).

pub fn js_RelativeAddress32Bit_BranchHint(
    &mut self,
    arg0: RelativeAddress32Bit,
    arg1: BranchHint
)

Jump near if sign (Sign Flag (SF) is 1).

pub fn js_RelativeAddress8Bit(&mut self, arg0: RelativeAddress8Bit)

Jump short if sign (Sign Flag (SF) is 1).

pub fn js_RelativeAddress8Bit_BranchHint(
    &mut self,
    arg0: RelativeAddress8Bit,
    arg1: BranchHint
)

Jump short if sign (Sign Flag (SF) is 1).

pub fn jz_Label(&mut self, arg0: Label) -> ShortJmpResult

Jump short if zero (Zero Flag (ZF) is 1).

pub fn jz_Label_1(&mut self, arg0: Label)

Jump near if 0 (Zero Flag (ZF) is 1).

pub fn jz_Label_BranchHint(
    &mut self,
    arg0: Label,
    arg1: BranchHint
) -> ShortJmpResult

Jump short if zero (Zero Flag (ZF) is 1).

pub fn jz_Label_BranchHint_1(&mut self, arg0: Label, arg1: BranchHint)

Jump near if 0 (Zero Flag (ZF) is 1).

pub fn jz_RelativeAddress32Bit(&mut self, arg0: RelativeAddress32Bit)

Jump near if 0 (Zero Flag (ZF) is 1).

pub fn jz_RelativeAddress32Bit_BranchHint(
    &mut self,
    arg0: RelativeAddress32Bit,
    arg1: BranchHint
)

Jump near if 0 (Zero Flag (ZF) is 1).

pub fn jz_RelativeAddress8Bit(&mut self, arg0: RelativeAddress8Bit)

Jump short if zero (Zero Flag (ZF) is 1).

pub fn jz_RelativeAddress8Bit_BranchHint(
    &mut self,
    arg0: RelativeAddress8Bit,
    arg1: BranchHint
)

Jump short if zero (Zero Flag (ZF) is 1).

pub fn lahf(&mut self)

Load: AH = EFLAGS(SF:ZF:0:AF:0:PF:1:CF).

pub fn lar_Register16Bit_Any16BitMemory(
    &mut self,
    arg0: Register16Bit,
    arg1: Any16BitMemory
)

r16 = access rights referenced by r16/m16.

pub fn lar_Register16Bit_Register16Bit(
    &mut self,
    arg0: Register16Bit,
    arg1: Register16Bit
)

r16 = access rights referenced by r16/m16.

pub fn lar_Register32Bit_Any16BitMemory(
    &mut self,
    arg0: Register32Bit,
    arg1: Any16BitMemory
)

reg = access rights referenced by r32/m16.

pub fn lar_Register32Bit_Register32Bit(
    &mut self,
    arg0: Register32Bit,
    arg1: Register32Bit
)

reg = access rights referenced by r32/m16.

pub fn lar_Register64Bit_Any16BitMemory(
    &mut self,
    arg0: Register64Bit,
    arg1: Any16BitMemory
)

reg = access rights referenced by r32/m16.

pub fn lar_Register64Bit_Register32Bit(
    &mut self,
    arg0: Register64Bit,
    arg1: Register32Bit
)

reg = access rights referenced by r32/m16.

pub fn lddqu_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Load unaligned data from mem and return double quadword in xmm1.

pub fn ldmxcsr_Any32BitMemory(&mut self, arg0: Any32BitMemory)

Load MXCSR register from m32.

pub fn lea_Register16Bit_Any16BitMemory(
    &mut self,
    arg0: Register16Bit,
    arg1: Any16BitMemory
)

Store effective address for m16 in register r16.

pub fn lea_Register16Bit_Any32BitMemory(
    &mut self,
    arg0: Register16Bit,
    arg1: Any32BitMemory
)

Store effective address for m32 in register r16.

pub fn lea_Register16Bit_Any64BitMemory(
    &mut self,
    arg0: Register16Bit,
    arg1: Any64BitMemory
)

Store effective address for m64 in register r16.

pub fn lea_Register32Bit_Any16BitMemory(
    &mut self,
    arg0: Register32Bit,
    arg1: Any16BitMemory
)

Store effective address for m16 in register r32.

pub fn lea_Register32Bit_Any32BitMemory(
    &mut self,
    arg0: Register32Bit,
    arg1: Any32BitMemory
)

Store effective address for m32 in register r32.

pub fn lea_Register32Bit_Any64BitMemory(
    &mut self,
    arg0: Register32Bit,
    arg1: Any64BitMemory
)

Store effective address for m64 in register r32.

pub fn lea_Register64Bit_Any16BitMemory(
    &mut self,
    arg0: Register64Bit,
    arg1: Any16BitMemory
)

Store effective address for m16 in register r64.

pub fn lea_Register64Bit_Any32BitMemory(
    &mut self,
    arg0: Register64Bit,
    arg1: Any32BitMemory
)

Store effective address for m32 in register r64.

pub fn lea_Register64Bit_Any64BitMemory(
    &mut self,
    arg0: Register64Bit,
    arg1: Any64BitMemory
)

Store effective address for m64 in register r64.

pub fn leave(&mut self)

Set RSP to RBP, then pop RBP.

pub fn leave_Prefix66(&mut self)

Set SP to BP, then pop BP.

pub fn lfence(&mut self)

Serializes load operations.

pub fn lfs_Register16Bit_FarPointer16BitTo16BitMemory(
    &mut self,
    arg0: Register16Bit,
    arg1: FarPointer16BitTo16BitMemory
)

Load FS:r16 with far pointer from memory.

pub fn lfs_Register32Bit_FarPointer16BitTo32BitMemory(
    &mut self,
    arg0: Register32Bit,
    arg1: FarPointer16BitTo32BitMemory
)

Load FS:r32 with far pointer from memory.

pub fn lfs_Register64Bit_FarPointer16BitTo64BitMemory(
    &mut self,
    arg0: Register64Bit,
    arg1: FarPointer16BitTo64BitMemory
)

Load FS:r64 with far pointer from memory.

pub fn lgs_Register16Bit_FarPointer16BitTo16BitMemory(
    &mut self,
    arg0: Register16Bit,
    arg1: FarPointer16BitTo16BitMemory
)

Load GS:r16 with far pointer from memory.

pub fn lgs_Register32Bit_FarPointer16BitTo32BitMemory(
    &mut self,
    arg0: Register32Bit,
    arg1: FarPointer16BitTo32BitMemory
)

Load GS:r32 with far pointer from memory.

pub fn lgs_Register64Bit_FarPointer16BitTo64BitMemory(
    &mut self,
    arg0: Register64Bit,
    arg1: FarPointer16BitTo64BitMemory
)

Load GS:r64 with far pointer from memory.

pub fn lock(&mut self)

Asserts LOCK# signal for duration of the accompanying instruction.

pub fn lods_Any16BitMemory(
    &mut self,
    arg0: Option<SegmentRegister>,
    address_override_for_32_bit: bool
)

For legacy mode load word at address DS:(E)SI into AX.

For 64-bit mode load word at address (R)SI into AX.

pub fn lods_Any32BitMemory(
    &mut self,
    arg0: Option<SegmentRegister>,
    address_override_for_32_bit: bool
)

For legacy mode load dword at address DS:(E)SI into EAX.

For 64-bit mode load dword at address (R)SI into EAX.

pub fn lods_Any64BitMemory(
    &mut self,
    arg0: Option<SegmentRegister>,
    address_override_for_32_bit: bool
)

Load qword at address (R)SI into RAX.

pub fn lods_Any8BitMemory(
    &mut self,
    arg0: Option<SegmentRegister>,
    address_override_for_32_bit: bool
)

For legacy mode load byte at address DS:(E)SI into AL.

For 64-bit mode load byte at address (R)SI into AL.

pub fn lodsb(&mut self)

For legacy mode load byte at address DS:(E)SI into AL.

For 64-bit mode load byte at address (R)SI into AL.

pub fn lodsd(&mut self)

For legacy mode load dword at address DS:(E)SI into EAX.

For 64-bit mode load dword at address (R)SI into EAX.

pub fn lodsq(&mut self)

Load qword at address (R)SI into RAX.

pub fn lodsw(&mut self)

For legacy mode load word at address DS:(E)SI into AX.

For 64-bit mode load word at address (R)SI into AX.

pub fn loop_Label(&mut self, arg0: Label) -> ShortJmpResult

Decrement count; jump short if count != 0.

pub fn loop_RelativeAddress8Bit(&mut self, arg0: RelativeAddress8Bit)

Decrement count; jump short if count != 0.

pub fn loope_Label(&mut self, arg0: Label) -> ShortJmpResult

Decrement count; jump short if count != 0 and Zero Flag (ZF) is 1.

pub fn loope_RelativeAddress8Bit(&mut self, arg0: RelativeAddress8Bit)

Decrement count; jump short if count != 0 and Zero Flag (ZF) is 1.

pub fn loopne_Label(&mut self, arg0: Label) -> ShortJmpResult

Decrement count; jump short if count != 0 and Zero Flag (ZF) is 0.

pub fn loopne_RelativeAddress8Bit(&mut self, arg0: RelativeAddress8Bit)

Decrement count; jump short if count != 0 and Zero Flag (ZF) is 0.

pub fn lsl_Register16Bit_Any16BitMemory(
    &mut self,
    arg0: Register16Bit,
    arg1: Any16BitMemory
)

Load: r16 = segment limit, selector r16/m16.

pub fn lsl_Register16Bit_Register16Bit(
    &mut self,
    arg0: Register16Bit,
    arg1: Register16Bit
)

Load: r16 = segment limit, selector r16/m16.

pub fn lsl_Register32Bit_Any16BitMemory(
    &mut self,
    arg0: Register32Bit,
    arg1: Any16BitMemory
)

Load: r32 = segment limit, selector r32/m16.

pub fn lsl_Register32Bit_Register32Bit(
    &mut self,
    arg0: Register32Bit,
    arg1: Register32Bit
)

Load: r32 = segment limit, selector r32/m16.

pub fn lsl_Register64Bit_Any16BitMemory(
    &mut self,
    arg0: Register64Bit,
    arg1: Any16BitMemory
)

Load: r64 = segment limit, selector r32/m16.

pub fn lsl_Register64Bit_Register32Bit(
    &mut self,
    arg0: Register64Bit,
    arg1: Register32Bit
)

Load: r64 = segment limit, selector r32/m16.

pub fn lss_Register16Bit_FarPointer16BitTo16BitMemory(
    &mut self,
    arg0: Register16Bit,
    arg1: FarPointer16BitTo16BitMemory
)

Load SS:r16 with far pointer from memory.

pub fn lss_Register32Bit_FarPointer16BitTo32BitMemory(
    &mut self,
    arg0: Register32Bit,
    arg1: FarPointer16BitTo32BitMemory
)

Load SS:r32 with far pointer from memory.

pub fn lss_Register64Bit_FarPointer16BitTo64BitMemory(
    &mut self,
    arg0: Register64Bit,
    arg1: FarPointer16BitTo64BitMemory
)

Load SS:r64 with far pointer from memory.

pub fn lzcnt_Register16Bit_Any16BitMemory(
    &mut self,
    arg0: Register16Bit,
    arg1: Any16BitMemory
)

Count the number of leading zero bits in r/m16 and return result in r16.

pub fn lzcnt_Register16Bit_Register16Bit(
    &mut self,
    arg0: Register16Bit,
    arg1: Register16Bit
)

Count the number of leading zero bits in r/m16 and return result in r16.

pub fn lzcnt_Register32Bit_Any32BitMemory(
    &mut self,
    arg0: Register32Bit,
    arg1: Any32BitMemory
)

Count the number of leading zero bits in r/m32 and return result in r32.

pub fn lzcnt_Register32Bit_Register32Bit(
    &mut self,
    arg0: Register32Bit,
    arg1: Register32Bit
)

Count the number of leading zero bits in r/m32 and return result in r32.

pub fn lzcnt_Register64Bit_Any64BitMemory(
    &mut self,
    arg0: Register64Bit,
    arg1: Any64BitMemory
)

Count the number of leading zero bits in r/m64 and return result in r64.

pub fn lzcnt_Register64Bit_Register64Bit(
    &mut self,
    arg0: Register64Bit,
    arg1: Register64Bit
)

Count the number of leading zero bits in r/m64 and return result in r64.

pub fn maskmovdqu_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Selectively write bytes from xmm1 to memory location using the byte mask in xmm2.

The default memory location is specified by DS:DI, EDI or RDI.

pub fn maskmovq_MMRegister_MMRegister(
    &mut self,
    arg0: MMRegister,
    arg1: MMRegister
)

Selectively write bytes from mm1 to memory location using the byte mask in mm2.

The default memory location is specified by DS:DI, EDI or RDI.

pub fn maxpd_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Return the maximum double-precision floating-point values between xmm2/m128 and xmm1.

pub fn maxpd_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Return the maximum double-precision floating-point values between xmm2/m128 and xmm1.

pub fn maxps_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Return the maximum single-precision floating-point values between xmm2/m128 and xmm1.

pub fn maxps_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Return the maximum single-precision floating-point values between xmm2/m128 and xmm1.

pub fn maxsd_XMMRegister_Any64BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any64BitMemory
)

Return the maximum scalar double-precision floating-point value between xmm2/mem64 and xmm1.

pub fn maxsd_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Return the maximum scalar double-precision floating-point value between xmm2/mem64 and xmm1.

pub fn maxss_XMMRegister_Any32BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any32BitMemory
)

Return the maximum scalar single-precision floating-point value between xmm2/mem32 and xmm1.

pub fn maxss_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Return the maximum scalar single-precision floating-point value between xmm2/mem32 and xmm1.

pub fn mfence(&mut self)

Serializes load and store operations.

pub fn minpd_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Return the minimum double-precision floating-point values between xmm2/m128 and xmm1.

pub fn minpd_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Return the minimum double-precision floating-point values between xmm2/m128 and xmm1.

pub fn minps_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Return the minimum single-precision floating-point values between xmm2/m128 and xmm1.

pub fn minps_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Return the minimum single-precision floating-point values between xmm2/m128 and xmm1.

pub fn minsd_XMMRegister_Any64BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any64BitMemory
)

Return the minimum scalar double-precision floating-point value between xmm2/mem64 and xmm1.

pub fn minsd_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Return the minimum scalar double-precision floating-point value between xmm2/mem64 and xmm1.

pub fn minss_XMMRegister_Any32BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any32BitMemory
)

Return the minimum scalar single-precision floating-point value between xmm2/mem32 and xmm1.

pub fn minss_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Return the minimum scalar single-precision floating-point value between xmm2/mem32 and xmm1.

pub fn monitor(&mut self)

Sets up a linear address range to be monitored by hardware and activates the monitor.

The address range should be a write-back memory caching type.

The address is DS:EAX (DS:RAX in 64-bit mode).

pub fn mov_AL_MemoryOffset8Bit(&mut self, arg1: MemoryOffset8Bit)

Move byte at segment:offset to AL.

pub fn mov_AL_MemoryOffset8Bit_PrefixRexW(&mut self, arg1: MemoryOffset8Bit)

Move byte at offset to AL.

pub fn mov_AX_MemoryOffset16Bit(&mut self, arg1: MemoryOffset16Bit)

Move word at segment:offset to AX.

pub fn mov_EAX_MemoryOffset32Bit(&mut self, arg1: MemoryOffset32Bit)

Move doubleword at segment:offset to EAX.

pub fn mov_Any16BitMemory_Immediate16Bit(
    &mut self,
    arg0: Any16BitMemory,
    arg1: Immediate16Bit
)

Move imm16 to r/m16.

pub fn mov_Any16BitMemory_Register16Bit(
    &mut self,
    arg0: Any16BitMemory,
    arg1: Register16Bit
)

Move r16 to r/m16.

pub fn mov_Any16BitMemory_SegmentRegister(
    &mut self,
    arg0: Any16BitMemory,
    arg1: SegmentRegister
)

Move segment register to r/m16.

pub fn mov_Any32BitMemory_Immediate32Bit(
    &mut self,
    arg0: Any32BitMemory,
    arg1: Immediate32Bit
)

Move imm32 to r/m32.

pub fn mov_Any32BitMemory_Register32Bit(
    &mut self,
    arg0: Any32BitMemory,
    arg1: Register32Bit
)

Move r32 to r/m32.

pub fn mov_Any64BitMemory_Immediate32Bit(
    &mut self,
    arg0: Any64BitMemory,
    arg1: Immediate32Bit
)

Move imm32 sign extended to 64-bits to r/m64.

pub fn mov_Any64BitMemory_Register64Bit(
    &mut self,
    arg0: Any64BitMemory,
    arg1: Register64Bit
)

Move r64 to r/m64.

pub fn mov_Any64BitMemory_SegmentRegister(
    &mut self,
    arg0: Any64BitMemory,
    arg1: SegmentRegister
)

Move zero extended 16-bit segment register to r/m64.

pub fn mov_Any8BitMemory_Immediate8Bit(
    &mut self,
    arg0: Any8BitMemory,
    arg1: Immediate8Bit
)

Move imm8 to r/m8.

pub fn mov_Any8BitMemory_Register8Bit(
    &mut self,
    arg0: Any8BitMemory,
    arg1: Register8Bit
)

Move r8 to r/m8.

pub fn mov_Any8BitMemory_RegisterHigh8BitsOf16Bits(
    &mut self,
    arg0: Any8BitMemory,
    arg1: RegisterHigh8BitsOf16Bits
)

Move r8 to r/m8.

pub fn mov_MemoryOffset16Bit_AX(&mut self, arg0: MemoryOffset16Bit)

Move AX to segment:offset.

pub fn mov_MemoryOffset32Bit_EAX(&mut self, arg0: MemoryOffset32Bit)

Move EAX to segment:offset.

pub fn mov_MemoryOffset64Bit_RAX(&mut self, arg0: MemoryOffset64Bit)

Move RAX to offset.

pub fn mov_MemoryOffset8Bit_AL(&mut self, arg0: MemoryOffset8Bit)

Move AL to segment:offset.

pub fn mov_MemoryOffset8Bit_AL_PrefixRexW(&mut self, arg0: MemoryOffset8Bit)

Move AL to offset.

pub fn mov_Register16Bit_Immediate16Bit(
    &mut self,
    arg0: Register16Bit,
    arg1: Immediate16Bit
)

Move imm16 to r16.

pub fn mov_Register16Bit_Immediate16Bit_1(
    &mut self,
    arg0: Register16Bit,
    arg1: Immediate16Bit
)

Move imm16 to r/m16.

pub fn mov_Register16Bit_Any16BitMemory(
    &mut self,
    arg0: Register16Bit,
    arg1: Any16BitMemory
)

Move r/m16 to r16.

pub fn mov_Register16Bit_Register16Bit(
    &mut self,
    arg0: Register16Bit,
    arg1: Register16Bit
)

Move r16 to r/m16.

pub fn mov_Register16Bit_Register16Bit_1(
    &mut self,
    arg0: Register16Bit,
    arg1: Register16Bit
)

Move r/m16 to r16.

pub fn mov_Register16Bit_SegmentRegister(
    &mut self,
    arg0: Register16Bit,
    arg1: SegmentRegister
)

Move segment register to r/m16.

pub fn mov_Register32Bit_Immediate32Bit(
    &mut self,
    arg0: Register32Bit,
    arg1: Immediate32Bit
)

Move imm32 to r32.

pub fn mov_Register32Bit_Immediate32Bit_1(
    &mut self,
    arg0: Register32Bit,
    arg1: Immediate32Bit
)

Move imm32 to r/m32.

pub fn mov_Register32Bit_Any32BitMemory(
    &mut self,
    arg0: Register32Bit,
    arg1: Any32BitMemory
)

Move r/m32 to r32.

pub fn mov_Register32Bit_Register32Bit(
    &mut self,
    arg0: Register32Bit,
    arg1: Register32Bit
)

Move r32 to r/m32.

pub fn mov_Register32Bit_Register32Bit_1(
    &mut self,
    arg0: Register32Bit,
    arg1: Register32Bit
)

Move r/m32 to r32.

pub fn mov_Register64Bit_Immediate32Bit(
    &mut self,
    arg0: Register64Bit,
    arg1: Immediate32Bit
)

Move imm32 sign extended to 64-bits to r/m64.

pub fn mov_Register64Bit_Immediate64Bit(
    &mut self,
    arg0: Register64Bit,
    arg1: Immediate64Bit
)

Move imm64 to r64.

pub fn mov_Register64Bit_Any64BitMemory(
    &mut self,
    arg0: Register64Bit,
    arg1: Any64BitMemory
)

Move r/m64 to r64.

pub fn mov_Register64Bit_Register64Bit_r64_rm64(
    &mut self,
    arg0: Register64Bit,
    arg1: Register64Bit
)

Move r64 to r/m64.

pub fn mov_Register64Bit_Register64Bit_rm64_r64(
    &mut self,
    arg0: Register64Bit,
    arg1: Register64Bit
)

Move r/m64 to r64.

pub fn mov_Register64Bit_SegmentRegister(
    &mut self,
    arg0: Register64Bit,
    arg1: SegmentRegister
)

Move zero extended 16-bit segment register to r/m64.

pub fn mov_Register8Bit_Immediate8Bit(
    &mut self,
    arg0: Register8Bit,
    arg1: Immediate8Bit
)

Move imm8 to r8.

pub fn mov_Register8Bit_Immediate8Bit_1(
    &mut self,
    arg0: Register8Bit,
    arg1: Immediate8Bit
)

Move imm8 to r/m8.

pub fn mov_Register8Bit_Any8BitMemory(
    &mut self,
    arg0: Register8Bit,
    arg1: Any8BitMemory
)

Move r/m8 to r8.

pub fn mov_Register8Bit_Register8Bit(
    &mut self,
    arg0: Register8Bit,
    arg1: Register8Bit
)

Move r8 to r/m8.

pub fn mov_Register8Bit_Register8Bit_1(
    &mut self,
    arg0: Register8Bit,
    arg1: Register8Bit
)

Move r/m8 to r8.

pub fn mov_Register8Bit_RegisterHigh8BitsOf16Bits(
    &mut self,
    arg0: Register8Bit,
    arg1: RegisterHigh8BitsOf16Bits
)

Move r8 to r/m8.

pub fn mov_Register8Bit_RegisterHigh8BitsOf16Bits_1(
    &mut self,
    arg0: Register8Bit,
    arg1: RegisterHigh8BitsOf16Bits
)

Move r/m8 to r8.

pub fn mov_RAX_MemoryOffset64Bit(&mut self, arg1: MemoryOffset64Bit)

Move quadword at offset to RAX.

pub fn mov_RegisterHigh8BitsOf16Bits_Immediate8Bit(
    &mut self,
    arg0: RegisterHigh8BitsOf16Bits,
    arg1: Immediate8Bit
)

Move imm8 to r8.

pub fn mov_RegisterHigh8BitsOf16Bits_Immediate8Bit_1(
    &mut self,
    arg0: RegisterHigh8BitsOf16Bits,
    arg1: Immediate8Bit
)

Move imm8 to r/m8.

pub fn mov_RegisterHigh8BitsOf16Bits_Any8BitMemory(
    &mut self,
    arg0: RegisterHigh8BitsOf16Bits,
    arg1: Any8BitMemory
)

Move r/m8 to r8.

pub fn mov_RegisterHigh8BitsOf16Bits_Register8Bit(
    &mut self,
    arg0: RegisterHigh8BitsOf16Bits,
    arg1: Register8Bit
)

Move r8 to r/m8.

pub fn mov_RegisterHigh8BitsOf16Bits_Register8Bit_1(
    &mut self,
    arg0: RegisterHigh8BitsOf16Bits,
    arg1: Register8Bit
)

Move r/m8 to r8.

pub fn mov_RegisterHigh8BitsOf16Bits_RegisterHigh8BitsOf16Bits(
    &mut self,
    arg0: RegisterHigh8BitsOf16Bits,
    arg1: RegisterHigh8BitsOf16Bits
)

Move r8 to r/m8.

pub fn mov_RegisterHigh8BitsOf16Bits_RegisterHigh8BitsOf16Bits_1(
    &mut self,
    arg0: RegisterHigh8BitsOf16Bits,
    arg1: RegisterHigh8BitsOf16Bits
)

Move r/m8 to r8.

pub fn mov_SegmentRegister_Any16BitMemory(
    &mut self,
    arg0: SegmentRegister,
    arg1: Any16BitMemory
)

Move r/m16 to segment register.

pub fn mov_SegmentRegister_Any64BitMemory(
    &mut self,
    arg0: SegmentRegister,
    arg1: Any64BitMemory
)

Move lower 16 bits of r/m64 to segment register.

pub fn mov_SegmentRegister_Register16Bit(
    &mut self,
    arg0: SegmentRegister,
    arg1: Register16Bit
)

Move r/m16 to segment register.

pub fn mov_SegmentRegister_Register64Bit(
    &mut self,
    arg0: SegmentRegister,
    arg1: Register64Bit
)

Move lower 16 bits of r/m64 to segment register.

pub fn movapd_Any128BitMemory_XMMRegister(
    &mut self,
    arg0: Any128BitMemory,
    arg1: XMMRegister
)

Move packed double-precision floating-point values from xmm1 to xmm2/m128.

pub fn movapd_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Move packed double-precision floating-point values from xmm2/m128 to xmm1.

pub fn movapd_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Move packed double-precision floating-point values from xmm2/m128 to xmm1.

pub fn movapd_XMMRegister_XMMRegister_1(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Move packed double-precision floating-point values from xmm1 to xmm2/m128.

pub fn movaps_Any128BitMemory_XMMRegister(
    &mut self,
    arg0: Any128BitMemory,
    arg1: XMMRegister
)

Move packed single-precision floating-point values from xmm1 to xmm2/m128.

pub fn movaps_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Move packed single-precision floating-point values from xmm2/m128 to xmm1.

pub fn movaps_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Move packed single-precision floating-point values from xmm2/m128 to xmm1.

pub fn movaps_XMMRegister_XMMRegister_1(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Move packed single-precision floating-point values from xmm1 to xmm2/m128.

pub fn movbe_Any16BitMemory_Register16Bit(
    &mut self,
    arg0: Any16BitMemory,
    arg1: Register16Bit
)

Reverse byte order in r16 and move to m16.

pub fn movbe_Any32BitMemory_Register32Bit(
    &mut self,
    arg0: Any32BitMemory,
    arg1: Register32Bit
)

Reverse byte order in r32 and move to m32.

pub fn movbe_Any64BitMemory_Register64Bit(
    &mut self,
    arg0: Any64BitMemory,
    arg1: Register64Bit
)

Reverse byte order in r64 and move to m64.

pub fn movbe_Register16Bit_Any16BitMemory(
    &mut self,
    arg0: Register16Bit,
    arg1: Any16BitMemory
)

Reverse byte order in m16 and move to r16.

pub fn movbe_Register32Bit_Any32BitMemory(
    &mut self,
    arg0: Register32Bit,
    arg1: Any32BitMemory
)

Reverse byte order in m32 and move to r32.

pub fn movbe_Register64Bit_Any64BitMemory(
    &mut self,
    arg0: Register64Bit,
    arg1: Any64BitMemory
)

Reverse byte order in m64 and move to r64.

pub fn movd_Any32BitMemory_MMRegister(
    &mut self,
    arg0: Any32BitMemory,
    arg1: MMRegister
)

Move doubleword from mm to r/m32.

pub fn movd_Any32BitMemory_XMMRegister(
    &mut self,
    arg0: Any32BitMemory,
    arg1: XMMRegister
)

Move doubleword from xmm register to r/m32.

pub fn movd_MMRegister_Any32BitMemory(
    &mut self,
    arg0: MMRegister,
    arg1: Any32BitMemory
)

Move doubleword from r/m32 to mm.

pub fn movd_MMRegister_Register32Bit(
    &mut self,
    arg0: MMRegister,
    arg1: Register32Bit
)

Move doubleword from r/m32 to mm.

pub fn movd_Register32Bit_MMRegister(
    &mut self,
    arg0: Register32Bit,
    arg1: MMRegister
)

Move doubleword from mm to r/m32.

pub fn movd_Register32Bit_XMMRegister(
    &mut self,
    arg0: Register32Bit,
    arg1: XMMRegister
)

Move doubleword from xmm register to r/m32.

pub fn movd_XMMRegister_Any32BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any32BitMemory
)

Move doubleword from r/m32 to xmm.

pub fn movd_XMMRegister_Register32Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: Register32Bit
)

Move doubleword from r/m32 to xmm.

pub fn movddup_XMMRegister_Any64BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any64BitMemory
)

Move one double-precision floating-point value from the lower 64-bit operand in xmm2/m64 to xmm1 and duplicate.

pub fn movddup_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Move one double-precision floating-point value from the lower 64-bit operand in xmm2/m64 to xmm1 and duplicate.

pub fn movdq2q_MMRegister_XMMRegister(
    &mut self,
    arg0: MMRegister,
    arg1: XMMRegister
)

Move low quadword from xmm to mm.

pub fn movdqa_Any128BitMemory_XMMRegister(
    &mut self,
    arg0: Any128BitMemory,
    arg1: XMMRegister
)

Move aligned double quadword from xmm1 to xmm2/m128.

pub fn movdqa_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Move aligned double quadword from xmm2/m128 to xmm1.

pub fn movdqa_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Move aligned double quadword from xmm2/m128 to xmm1.

pub fn movdqa_XMMRegister_XMMRegister_1(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Move aligned double quadword from xmm1 to xmm2/m128.

pub fn movdqu_Any128BitMemory_XMMRegister(
    &mut self,
    arg0: Any128BitMemory,
    arg1: XMMRegister
)

Move unaligned double quadword from xmm1 to xmm2/m128.

pub fn movdqu_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Move unaligned double quadword from xmm2/m128 to xmm1.

pub fn movdqu_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Move unaligned double quadword from xmm2/m128 to xmm1.

pub fn movdqu_XMMRegister_XMMRegister_1(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Move unaligned double quadword from xmm1 to xmm2/m128.

pub fn movhlps_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Move two packed single-precision floating-point values from high quadword of xmm2 to low quadword of xmm1.

pub fn movhpd_Any64BitMemory_XMMRegister(
    &mut self,
    arg0: Any64BitMemory,
    arg1: XMMRegister
)

Move double-precision floating-point value from high quadword of xmm to m64.

pub fn movhpd_XMMRegister_Any64BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any64BitMemory
)

Move double-precision floating-point value from m64 to high quadword of xmm.

pub fn movhps_Any64BitMemory_XMMRegister(
    &mut self,
    arg0: Any64BitMemory,
    arg1: XMMRegister
)

Move two packed single-precision floating-point values from high quadword of xmm to m64.

pub fn movhps_XMMRegister_Any64BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any64BitMemory
)

Move two packed single-precision floating-point values from m64 to high quadword of xmm.

pub fn movlhps_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Move two packed single-precision floating-point values from low quadword of xmm2 to high quadword of xmm1.

pub fn movlpd_Any64BitMemory_XMMRegister(
    &mut self,
    arg0: Any64BitMemory,
    arg1: XMMRegister
)

Move double-precision floating-point nvalue from low quadword of xmm register to m64.

pub fn movlpd_XMMRegister_Any64BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any64BitMemory
)

Move double-precision floating-point value from m64 to low quadword of xmm register.

pub fn movlps_Any64BitMemory_XMMRegister(
    &mut self,
    arg0: Any64BitMemory,
    arg1: XMMRegister
)

Move two packed single-precision floating-point values from low quadword of xmm to m64.

pub fn movlps_XMMRegister_Any64BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any64BitMemory
)

Move two packed single-precision floating-point values from m64 to low quadword of xmm.

pub fn movmskpd_Register32Bit_XMMRegister(
    &mut self,
    arg0: Register32Bit,
    arg1: XMMRegister
)

Extract 2-bit sign mask from xmm and store in r32.

The upper bits of r32 or r64 are filled with zeros.

pub fn movmskpd_Register64Bit_XMMRegister(
    &mut self,
    arg0: Register64Bit,
    arg1: XMMRegister
)

Extract 2-bit sign mask from xmm and store in r64.

The upper bits of r32 or r64 are filled with zeros.

pub fn movmskps_Register32Bit_XMMRegister(
    &mut self,
    arg0: Register32Bit,
    arg1: XMMRegister
)

Extract 4-bit sign mask from xmm and store in r32.

The upper bits of r32 or r64 are filled with zeros.

pub fn movmskps_Register64Bit_XMMRegister(
    &mut self,
    arg0: Register64Bit,
    arg1: XMMRegister
)

Extract 4-bit sign mask from xmm and store in r64.

The upper bits of r32 or r64 are filled with zeros.

pub fn movntdq_Any128BitMemory_XMMRegister(
    &mut self,
    arg0: Any128BitMemory,
    arg1: XMMRegister
)

Move double quadword from xmm to m128 using non-temporal hint.

pub fn movntdqa_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Move double quadword from m128 to xmm using non-temporal hint if Write Commit (WC) memory type.

pub fn movnti_Any32BitMemory_Register32Bit(
    &mut self,
    arg0: Any32BitMemory,
    arg1: Register32Bit
)

Move doubleword from r32 to m32 using non-temporal hint.

pub fn movnti_Any64BitMemory_Register64Bit(
    &mut self,
    arg0: Any64BitMemory,
    arg1: Register64Bit
)

Move quadword from r64 to m64 using non-temporal hint.

pub fn movntpd_Any128BitMemory_XMMRegister(
    &mut self,
    arg0: Any128BitMemory,
    arg1: XMMRegister
)

Move packed double-precision floating-point values from xmm to m128 using non-temporal hint.

pub fn movntps_Any128BitMemory_XMMRegister(
    &mut self,
    arg0: Any128BitMemory,
    arg1: XMMRegister
)

Move packed single-precision floating-point values from xmm to m128 using non-temporal hint.

pub fn movntq_Any64BitMemory_MMRegister(
    &mut self,
    arg0: Any64BitMemory,
    arg1: MMRegister
)

Move quadword from mm to m64 using non-temporal hint.

pub fn movq_Any64BitMemory_MMRegister(
    &mut self,
    arg0: Any64BitMemory,
    arg1: MMRegister
)

Move quadword from mm to r/m64.

pub fn movq_Any64BitMemory_MMRegister_1(
    &mut self,
    arg0: Any64BitMemory,
    arg1: MMRegister
)

Move quadword from mm to mm/m64.

pub fn movq_Any64BitMemory_XMMRegister(
    &mut self,
    arg0: Any64BitMemory,
    arg1: XMMRegister
)

Move quadword from xmm register to r/m64.

pub fn movq_Any64BitMemory_XMMRegister_1(
    &mut self,
    arg0: Any64BitMemory,
    arg1: XMMRegister
)

Move quadword from xmm1 to xmm2/mem64.

pub fn movq_MMRegister_Any64BitMemory(
    &mut self,
    arg0: MMRegister,
    arg1: Any64BitMemory
)

Move quadword from r/m64 to mm.

pub fn movq_MMRegister_Any64BitMemory_1(
    &mut self,
    arg0: MMRegister,
    arg1: Any64BitMemory
)

Move quadword from mm/m64 to mm.

pub fn movq_MMRegister_MMRegister(&mut self, arg0: MMRegister, arg1: MMRegister)

Move quadword from mm/m64 to mm.

pub fn movq_MMRegister_MMRegister_1(&mut self, arg0: MMRegister, arg1: MMRegister)

Move quadword from mm to mm/m64.

pub fn movq_MMRegister_Register64Bit(
    &mut self,
    arg0: MMRegister,
    arg1: Register64Bit
)

Move quadword from r/m64 to mm.

pub fn movq_Register64Bit_MMRegister(
    &mut self,
    arg0: Register64Bit,
    arg1: MMRegister
)

Move quadword from mm to r/m64.

pub fn movq_Register64Bit_XMMRegister(
    &mut self,
    arg0: Register64Bit,
    arg1: XMMRegister
)

Move quadword from xmm register to r/m64.

pub fn movq_XMMRegister_Any64BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any64BitMemory
)

Move quadword from r/m64 to xmm.

pub fn movq_XMMRegister_Any64BitMemory_1(
    &mut self,
    arg0: XMMRegister,
    arg1: Any64BitMemory
)

Move quadword from xmm2/mem64 to xmm1.

pub fn movq_XMMRegister_Register64Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: Register64Bit
)

Move quadword from r/m64 to xmm.

pub fn movq_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Move quadword from xmm2/mem64 to xmm1.

pub fn movq_XMMRegister_XMMRegister_1(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Move quadword from xmm1 to xmm2/mem64.

pub fn movq2dq_XMMRegister_MMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: MMRegister
)

Move quadword from mmx to low quadword of xmm.

pub fn movs_Any16BitMemory_Any16BitMemory(
    &mut self,
    arg0: Option<SegmentRegister>,
    address_override_for_32_bit: bool
)

For legacy mode, move word from address DS:(E)SI to ES:(E)DI.

For 64-bit mode move word at address (R|E)SI to (R|E)DI.

pub fn movs_Any32BitMemory_Any32BitMemory(
    &mut self,
    arg0: Option<SegmentRegister>,
    address_override_for_32_bit: bool
)

For legacy mode, move dword from address DS:(E)SI to ES:(E)DI.

For 64-bit mode move dword from address (R|E)SI to (R|E)DI.

pub fn movs_Any64BitMemory_Any64BitMemory(
    &mut self,
    arg0: Option<SegmentRegister>,
    address_override_for_32_bit: bool
)

Move qword from address (R|E)SI to (R|E)DI.

pub fn movs_Any8BitMemory_Any8BitMemory(
    &mut self,
    arg0: Option<SegmentRegister>,
    address_override_for_32_bit: bool
)

For legacy mode, Move byte from address DS:(E)SI to ES:(E)DI.

For 64-bit mode move byte from address (R|E)SI to (R|E)DI.

pub fn movsb(&mut self)

For legacy mode, Move byte from address DS:(E)SI to ES:(E)DI.

For 64-bit mode move byte from address (R|E)SI to (R|E)DI.

pub fn movsd(&mut self)

For legacy mode, move dword from address DS:(E)SI to ES:(E)DI.

For 64-bit mode move dword from address (R|E)SI to (R|E)DI.

pub fn movsd_Any64BitMemory_XMMRegister(
    &mut self,
    arg0: Any64BitMemory,
    arg1: XMMRegister
)

Move scalar double-precision floating-point value from xmm1 register to xmm2/m64.

pub fn movsd_XMMRegister_Any64BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any64BitMemory
)

Move scalar double-precision floating-point value from xmm2/m64 to xmm1.

pub fn movsd_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Move scalar double-precision floating-point value from xmm2/m64 to xmm1.

pub fn movsd_XMMRegister_XMMRegister_1(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Move scalar double-precision floating-point value from xmm1 register to xmm2/m64.

pub fn movshdup_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Move two single-precision floating-point values from the higher 32-bit operand of each qword in xmm2/m128 to xmm1 and duplicate each 32-bit operand to the lower 32-bits of each qword.

pub fn movshdup_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Move two single-precision floating-point values from the higher 32-bit operand of each qword in xmm2/m128 to xmm1 and duplicate each 32-bit operand to the lower 32-bits of each qword.

pub fn movsldup_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Move two single-precision floating-point values from the lower 32-bit operand of each qword in xmm2/m128 to xmm1 and duplicate each 32-bit operand to the higher 32-bits of each qword.

pub fn movsldup_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Move two single-precision floating-point values from the lower 32-bit operand of each qword in xmm2/m128 to xmm1 and duplicate each 32-bit operand to the higher 32-bits of each qword.

pub fn movsq(&mut self)

Move qword from address (R|E)SI to (R|E)DI.

pub fn movss_Any32BitMemory_XMMRegister(
    &mut self,
    arg0: Any32BitMemory,
    arg1: XMMRegister
)

Move scalar single-precision floating-point value from xmm1 register to xmm2/m32.

pub fn movss_XMMRegister_Any32BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any32BitMemory
)

Move scalar single-precision floating-point value from xmm2/m32 to xmm1.

pub fn movss_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Move scalar single-precision floating-point value from xmm2/m32 to xmm1.

pub fn movss_XMMRegister_XMMRegister_1(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Move scalar single-precision floating-point value from xmm1 register to xmm2/m32.

pub fn movsw(&mut self)

For legacy mode, move word from address DS:(E)SI to ES:(E)DI.

For 64-bit mode move word at address (R|E)SI to (R|E)DI.

pub fn movsx_Register16Bit_Any8BitMemory(
    &mut self,
    arg0: Register16Bit,
    arg1: Any8BitMemory
)

Move r/m8 to r16 with sign-extension.

pub fn movsx_Register16Bit_Register8Bit(
    &mut self,
    arg0: Register16Bit,
    arg1: Register8Bit
)

Move r8 to r16 with sign-extension.

pub fn movsx_Register16Bit_RegisterHigh8BitsOf16Bits(
    &mut self,
    arg0: Register16Bit,
    arg1: RegisterHigh8BitsOf16Bits
)

Move r/m8 to r16 with sign-extension.

pub fn movsx_Register32Bit_Any16BitMemory(
    &mut self,
    arg0: Register32Bit,
    arg1: Any16BitMemory
)

Move r/m16 to r32, with sign-extension.

pub fn movsx_Register32Bit_Any8BitMemory(
    &mut self,
    arg0: Register32Bit,
    arg1: Any8BitMemory
)

Move r/m8 to r32 with sign-extension.

pub fn movsx_Register32Bit_Register16Bit(
    &mut self,
    arg0: Register32Bit,
    arg1: Register16Bit
)

Move r16 to r32, with sign-extension.

pub fn movsx_Register32Bit_Register8Bit(
    &mut self,
    arg0: Register32Bit,
    arg1: Register8Bit
)

Move r8 to r32 with sign-extension.

pub fn movsx_Register32Bit_RegisterHigh8BitsOf16Bits(
    &mut self,
    arg0: Register32Bit,
    arg1: RegisterHigh8BitsOf16Bits
)

Move r/m8 to r32 with sign-extension.

pub fn movsx_Register64Bit_Any16BitMemory(
    &mut self,
    arg0: Register64Bit,
    arg1: Any16BitMemory
)

Move r/m16 to r64 with sign-extension.

pub fn movsx_Register64Bit_Any8BitMemory(
    &mut self,
    arg0: Register64Bit,
    arg1: Any8BitMemory
)

Move r/m8 to r64 with sign-extension.

pub fn movsx_Register64Bit_Register16Bit(
    &mut self,
    arg0: Register64Bit,
    arg1: Register16Bit
)

Move r16 to r64 with sign-extension.

pub fn movsx_Register64Bit_Register8Bit(
    &mut self,
    arg0: Register64Bit,
    arg1: Register8Bit
)

Move r8 to r64 with sign-extension.

pub fn movsxd_Register64Bit_Any32BitMemory(
    &mut self,
    arg0: Register64Bit,
    arg1: Any32BitMemory
)

Move r/m32 to r64 with sign-extension.

pub fn movsxd_Register64Bit_Register32Bit(
    &mut self,
    arg0: Register64Bit,
    arg1: Register32Bit
)

Move r32 to r64 with sign-extension.

pub fn movupd_Any128BitMemory_XMMRegister(
    &mut self,
    arg0: Any128BitMemory,
    arg1: XMMRegister
)

Move packed double-precision floating-point values from xmm1 to xmm2/m128.

pub fn movupd_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Move packed double-precision floating-point values from xmm2/m128 to xmm1.

pub fn movupd_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Move packed double-precision floating-point values from xmm2/m128 to xmm1.

pub fn movupd_XMMRegister_XMMRegister_1(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Move packed double-precision floating-point values from xmm1 to xmm2/m128.

pub fn movups_Any128BitMemory_XMMRegister(
    &mut self,
    arg0: Any128BitMemory,
    arg1: XMMRegister
)

Move packed single-precision floating-point values from xmm1 to xmm2/m128.

pub fn movups_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Move packed single-precision floating-point values from xmm2/m128 to xmm1.

pub fn movups_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Move packed single-precision floating-point values from xmm2/m128 to xmm1.

pub fn movups_XMMRegister_XMMRegister_1(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Move packed single-precision floating-point values from xmm1 to xmm2/m128.

pub fn movzx_Register16Bit_Any8BitMemory(
    &mut self,
    arg0: Register16Bit,
    arg1: Any8BitMemory
)

Move r/m8 to r16 with zero-extension.

pub fn movzx_Register16Bit_Register8Bit(
    &mut self,
    arg0: Register16Bit,
    arg1: Register8Bit
)

Move r/m8 to r16 with zero-extension.

pub fn movzx_Register16Bit_RegisterHigh8BitsOf16Bits(
    &mut self,
    arg0: Register16Bit,
    arg1: RegisterHigh8BitsOf16Bits
)

Move r/m8 to r16 with zero-extension.

pub fn movzx_Register32Bit_Any16BitMemory(
    &mut self,
    arg0: Register32Bit,
    arg1: Any16BitMemory
)

Move r/m16 to r32 with zero-extension.

pub fn movzx_Register32Bit_Any8BitMemory(
    &mut self,
    arg0: Register32Bit,
    arg1: Any8BitMemory
)

Move r/m8 to r32 with zero-extension.

pub fn movzx_Register32Bit_Register16Bit(
    &mut self,
    arg0: Register32Bit,
    arg1: Register16Bit
)

Move r/m16 to r32 with zero-extension.

pub fn movzx_Register32Bit_Register8Bit(
    &mut self,
    arg0: Register32Bit,
    arg1: Register8Bit
)

Move r/m8 to r32 with zero-extension.

pub fn movzx_Register32Bit_RegisterHigh8BitsOf16Bits(
    &mut self,
    arg0: Register32Bit,
    arg1: RegisterHigh8BitsOf16Bits
)

Move r/m8 to r32 with zero-extension.

pub fn movzx_Register64Bit_Any16BitMemory(
    &mut self,
    arg0: Register64Bit,
    arg1: Any16BitMemory
)

Move r/m16 to r64 with zero-extension.

pub fn movzx_Register64Bit_Any8BitMemory(
    &mut self,
    arg0: Register64Bit,
    arg1: Any8BitMemory
)

Move r/m8 to r64 with zero-extension.

pub fn movzx_Register64Bit_Register16Bit(
    &mut self,
    arg0: Register64Bit,
    arg1: Register16Bit
)

Move r/m16 to r64 with zero-extension.

pub fn movzx_Register64Bit_Register8Bit(
    &mut self,
    arg0: Register64Bit,
    arg1: Register8Bit
)

Move r/m8 to r64 with zero-extension.

pub fn mpsadbw_XMMRegister_Any128BitMemory_Immediate8Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory,
    arg2: Immediate8Bit
)

Sums absolute 8-bit integer difference of adjacent groups of 4 byte integers in xmm1 and xmm2/m128 and writes the results in xmm1.

Starting offsets within xmm1 and xmm2/m128 are determined by imm8.

pub fn mpsadbw_XMMRegister_XMMRegister_Immediate8Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Immediate8Bit
)

Sums absolute 8-bit integer difference of adjacent groups of 4 byte integers in xmm1 and xmm2/m128 and writes the results in xmm1.

Starting offsets within xmm1 and xmm2/m128 are determined by imm8.

pub fn mul_Any16BitMemory(&mut self, arg0: Any16BitMemory)

Unsigned multiply (DX:AX = AX * r/m16).

pub fn mul_Any32BitMemory(&mut self, arg0: Any32BitMemory)

Unsigned multiply (EDX:EAX = EAX * r/m32).

pub fn mul_Any64BitMemory(&mut self, arg0: Any64BitMemory)

Unsigned multiply (RDX:RAX = RAX * r/m64.

pub fn mul_Any8BitMemory(&mut self, arg0: Any8BitMemory)

Unsigned multiply (AX = AL * r/m8).

pub fn mul_Register16Bit(&mut self, arg0: Register16Bit)

Unsigned multiply (DX:AX = AX * r/m16).

pub fn mul_Register32Bit(&mut self, arg0: Register32Bit)

Unsigned multiply (EDX:EAX = EAX * r/m32).

pub fn mul_Register64Bit(&mut self, arg0: Register64Bit)

Unsigned multiply (RDX:RAX = RAX * r/m64.

pub fn mul_Register8Bit(&mut self, arg0: Register8Bit)

Unsigned multiply (AX = AL * r/m8).

pub fn mul_RegisterHigh8BitsOf16Bits(&mut self, arg0: RegisterHigh8BitsOf16Bits)

Unsigned multiply (AX = AL * r/m8).

pub fn mulpd_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Multiply packed double-precision floating-point values in xmm2/m128 by xmm1.

pub fn mulpd_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Multiply packed double-precision floating-point values in xmm2/m128 by xmm1.

pub fn mulps_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Multiply packed single-precision floating-point values in xmm2/mem by xmm1.

pub fn mulps_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Multiply packed single-precision floating-point values in xmm2/mem by xmm1.

pub fn mulsd_XMMRegister_Any64BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any64BitMemory
)

Multiply the low double-precision floating-point value in xmm2/mem64 by low double-precision floating-point value in xmm1.

pub fn mulsd_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Multiply the low double-precision floating-point value in xmm2/mem64 by low double-precision floating-point value in xmm1.

pub fn mulss_XMMRegister_Any32BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any32BitMemory
)

Multiply the low single-precision floating-point value in xmm2/mem by the low single-precision floating-point value in xmm1.

pub fn mulss_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Multiply the low single-precision floating-point value in xmm2/mem by the low single-precision floating-point value in xmm1.

pub fn mulx_Register32Bit_Register32Bit_Any32BitMemory(
    &mut self,
    arg0: Register32Bit,
    arg1: Register32Bit,
    arg2: Any32BitMemory
)

Unsigned multiply of r/m32 with EDX without affecting arithmetic flags.

pub fn mulx_Register32Bit_Register32Bit_Register32Bit(
    &mut self,
    arg0: Register32Bit,
    arg1: Register32Bit,
    arg2: Register32Bit
)

Unsigned multiply of r/m32 with EDX without affecting arithmetic flags.

pub fn mulx_Register64Bit_Register64Bit_Any64BitMemory(
    &mut self,
    arg0: Register64Bit,
    arg1: Register64Bit,
    arg2: Any64BitMemory
)

Unsigned multiply of r/m64 with RDX without affecting arithmetic flags.

pub fn mulx_Register64Bit_Register64Bit_Register64Bit(
    &mut self,
    arg0: Register64Bit,
    arg1: Register64Bit,
    arg2: Register64Bit
)

Unsigned multiply of r/m64 with RDX without affecting arithmetic flags.

pub fn mwait(&mut self)

A hint that allow the processor to stop instruction execution and enter an implementation-dependent optimized state until occurrence of a class of events.

pub fn neg_Any16BitMemory(&mut self, arg0: Any16BitMemory)

Two’s complement negate r/m16.

pub fn neg_Any32BitMemory(&mut self, arg0: Any32BitMemory)

Two’s complement negate r/m32.

pub fn neg_Any64BitMemory(&mut self, arg0: Any64BitMemory)

Two’s complement negate r/m64.

pub fn neg_Any8BitMemory(&mut self, arg0: Any8BitMemory)

Two’s complement negate r/m8.

pub fn neg_Register16Bit(&mut self, arg0: Register16Bit)

Two’s complement negate r/m16.

pub fn neg_Register32Bit(&mut self, arg0: Register32Bit)

Two’s complement negate r/m32.

pub fn neg_Register64Bit(&mut self, arg0: Register64Bit)

Two’s complement negate r/m64.

pub fn neg_Register8Bit(&mut self, arg0: Register8Bit)

Two’s complement negate r/m8.

pub fn neg_RegisterHigh8BitsOf16Bits(&mut self, arg0: RegisterHigh8BitsOf16Bits)

Two’s complement negate r/m8.

pub fn nop(&mut self)

One byte no-operation instruction.

pub fn nop_Any16BitMemory(&mut self, arg0: Any16BitMemory)

Multi-byte no-operation instruction.

pub fn nop_Any32BitMemory(&mut self, arg0: Any32BitMemory)

Multi-byte no-operation instruction.

pub fn nop_Register16Bit(&mut self, arg0: Register16Bit)

Multi-byte no-operation instruction.

pub fn nop_Register32Bit(&mut self, arg0: Register32Bit)

Multi-byte no-operation instruction.

pub fn not_Any16BitMemory(&mut self, arg0: Any16BitMemory)

Reverse each bit of r/m16.

pub fn not_Any32BitMemory(&mut self, arg0: Any32BitMemory)

Reverse each bit of r/m32.

pub fn not_Any64BitMemory(&mut self, arg0: Any64BitMemory)

Reverse each bit of r/m64.

pub fn not_Any8BitMemory(&mut self, arg0: Any8BitMemory)

Reverse each bit of r/m8.

pub fn not_Register16Bit(&mut self, arg0: Register16Bit)

Reverse each bit of r/m16.

pub fn not_Register32Bit(&mut self, arg0: Register32Bit)

Reverse each bit of r/m32.

pub fn not_Register64Bit(&mut self, arg0: Register64Bit)

Reverse each bit of r/m64.

pub fn not_Register8Bit(&mut self, arg0: Register8Bit)

Reverse each bit of r/m8.

pub fn not_RegisterHigh8BitsOf16Bits(&mut self, arg0: RegisterHigh8BitsOf16Bits)

Reverse each bit of r/m8.

pub fn or_AL_Immediate8Bit(&mut self, arg1: Immediate8Bit)

AL OR imm8.

pub fn or_AX_Immediate16Bit(&mut self, arg1: Immediate16Bit)

AX OR imm16.

pub fn or_EAX_Immediate32Bit(&mut self, arg1: Immediate32Bit)

EAX OR imm32.

pub fn or_Any16BitMemory_Immediate16Bit(
    &mut self,
    arg0: Any16BitMemory,
    arg1: Immediate16Bit
)

r/m16 OR imm16.

pub fn or_Any16BitMemory_Immediate8Bit(
    &mut self,
    arg0: Any16BitMemory,
    arg1: Immediate8Bit
)

r/m16 OR imm8 (sign-extended).

pub fn or_Any16BitMemory_Register16Bit(
    &mut self,
    arg0: Any16BitMemory,
    arg1: Register16Bit
)

r/m16 OR r16.

pub fn or_Any32BitMemory_Immediate32Bit(
    &mut self,
    arg0: Any32BitMemory,
    arg1: Immediate32Bit
)

r/m32 OR imm32.

pub fn or_Any32BitMemory_Immediate8Bit(
    &mut self,
    arg0: Any32BitMemory,
    arg1: Immediate8Bit
)

r/m32 OR imm8 (sign-extended).

pub fn or_Any32BitMemory_Register32Bit(
    &mut self,
    arg0: Any32BitMemory,
    arg1: Register32Bit
)

r/m32 OR r32.

pub fn or_Any64BitMemory_Immediate32Bit(
    &mut self,
    arg0: Any64BitMemory,
    arg1: Immediate32Bit
)

r/m64 OR imm32 (sign-extended).

pub fn or_Any64BitMemory_Immediate8Bit(
    &mut self,
    arg0: Any64BitMemory,
    arg1: Immediate8Bit
)

r/m64 OR imm8 (sign-extended).

pub fn or_Any64BitMemory_Register64Bit(
    &mut self,
    arg0: Any64BitMemory,
    arg1: Register64Bit
)

r/m64 OR r64.

pub fn or_Any8BitMemory_Immediate8Bit(
    &mut self,
    arg0: Any8BitMemory,
    arg1: Immediate8Bit
)

r/m8 OR imm8.

pub fn or_Any8BitMemory_Register8Bit(
    &mut self,
    arg0: Any8BitMemory,
    arg1: Register8Bit
)

r/m8 OR r8.

pub fn or_Any8BitMemory_RegisterHigh8BitsOf16Bits(
    &mut self,
    arg0: Any8BitMemory,
    arg1: RegisterHigh8BitsOf16Bits
)

r/m8 OR r8.

pub fn or_Register16Bit_Immediate16Bit(
    &mut self,
    arg0: Register16Bit,
    arg1: Immediate16Bit
)

r/m16 OR imm16.

pub fn or_Register16Bit_Immediate8Bit(
    &mut self,
    arg0: Register16Bit,
    arg1: Immediate8Bit
)

r/m16 OR imm8 (sign-extended).

pub fn or_Register16Bit_Any16BitMemory(
    &mut self,
    arg0: Register16Bit,
    arg1: Any16BitMemory
)

r16 OR r/m16.

pub fn or_Register16Bit_Register16Bit(
    &mut self,
    arg0: Register16Bit,
    arg1: Register16Bit
)

r/m16 OR r16.

pub fn or_Register16Bit_Register16Bit_1(
    &mut self,
    arg0: Register16Bit,
    arg1: Register16Bit
)

r16 OR r/m16.

pub fn or_Register32Bit_Immediate32Bit(
    &mut self,
    arg0: Register32Bit,
    arg1: Immediate32Bit
)

r/m32 OR imm32.

pub fn or_Register32Bit_Immediate8Bit(
    &mut self,
    arg0: Register32Bit,
    arg1: Immediate8Bit
)

r/m32 OR imm8 (sign-extended).

pub fn or_Register32Bit_Any32BitMemory(
    &mut self,
    arg0: Register32Bit,
    arg1: Any32BitMemory
)

r32 OR r/m32.

pub fn or_Register32Bit_Register32Bit(
    &mut self,
    arg0: Register32Bit,
    arg1: Register32Bit
)

r/m32 OR r32.

pub fn or_Register32Bit_Register32Bit_1(
    &mut self,
    arg0: Register32Bit,
    arg1: Register32Bit
)

r32 OR r/m32.

pub fn or_Register64Bit_Immediate32Bit(
    &mut self,
    arg0: Register64Bit,
    arg1: Immediate32Bit
)

r/m64 OR imm32 (sign-extended).

pub fn or_Register64Bit_Immediate8Bit(
    &mut self,
    arg0: Register64Bit,
    arg1: Immediate8Bit
)

r/m64 OR imm8 (sign-extended).

pub fn or_Register64Bit_Any64BitMemory(
    &mut self,
    arg0: Register64Bit,
    arg1: Any64BitMemory
)

r64 OR r/m64.

pub fn or_Register64Bit_Register64Bit(
    &mut self,
    arg0: Register64Bit,
    arg1: Register64Bit
)

r/m64 OR r64.

pub fn or_Register64Bit_Register64Bit_1(
    &mut self,
    arg0: Register64Bit,
    arg1: Register64Bit
)

r64 OR r/m64.

pub fn or_Register8Bit_Immediate8Bit(
    &mut self,
    arg0: Register8Bit,
    arg1: Immediate8Bit
)

r/m8 OR imm8.

pub fn or_Register8Bit_Any8BitMemory(
    &mut self,
    arg0: Register8Bit,
    arg1: Any8BitMemory
)

r8 OR r/m8.

pub fn or_Register8Bit_Register8Bit(
    &mut self,
    arg0: Register8Bit,
    arg1: Register8Bit
)

r/m8 OR r8.

pub fn or_Register8Bit_Register8Bit_1(
    &mut self,
    arg0: Register8Bit,
    arg1: Register8Bit
)

r8 OR r/m8.

pub fn or_Register8Bit_RegisterHigh8BitsOf16Bits(
    &mut self,
    arg0: Register8Bit,
    arg1: RegisterHigh8BitsOf16Bits
)

r/m8 OR r8.

pub fn or_Register8Bit_RegisterHigh8BitsOf16Bits_1(
    &mut self,
    arg0: Register8Bit,
    arg1: RegisterHigh8BitsOf16Bits
)

r8 OR r/m8.

pub fn or_RAX_Immediate32Bit(&mut self, arg1: Immediate32Bit)

RAX OR imm32 (sign-extended).

pub fn or_RegisterHigh8BitsOf16Bits_Immediate8Bit(
    &mut self,
    arg0: RegisterHigh8BitsOf16Bits,
    arg1: Immediate8Bit
)

r/m8 OR imm8.

pub fn or_RegisterHigh8BitsOf16Bits_Any8BitMemory(
    &mut self,
    arg0: RegisterHigh8BitsOf16Bits,
    arg1: Any8BitMemory
)

r8 OR r/m8.

pub fn or_RegisterHigh8BitsOf16Bits_Register8Bit(
    &mut self,
    arg0: RegisterHigh8BitsOf16Bits,
    arg1: Register8Bit
)

r/m8 OR r8.

pub fn or_RegisterHigh8BitsOf16Bits_Register8Bit_1(
    &mut self,
    arg0: RegisterHigh8BitsOf16Bits,
    arg1: Register8Bit
)

r8 OR r/m8.

pub fn or_RegisterHigh8BitsOf16Bits_RegisterHigh8BitsOf16Bits(
    &mut self,
    arg0: RegisterHigh8BitsOf16Bits,
    arg1: RegisterHigh8BitsOf16Bits
)

r/m8 OR r8.

pub fn or_RegisterHigh8BitsOf16Bits_RegisterHigh8BitsOf16Bits_1(
    &mut self,
    arg0: RegisterHigh8BitsOf16Bits,
    arg1: RegisterHigh8BitsOf16Bits
)

r8 OR r/m8.

pub fn orpd_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Bitwise OR of xmm2/m128 and xmm1.

pub fn orpd_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Bitwise OR of xmm2/m128 and xmm1.

pub fn orps_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Bitwise OR of xmm1 and xmm2/m128.

pub fn orps_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Bitwise OR of xmm1 and xmm2/m128.

pub fn out_DX_AL(&mut self)

Output byte in AL to I/O port address in DX.

pub fn out_DX_AX(&mut self)

Output word in AX to I/O port address in DX.

pub fn out_DX_EAX(&mut self)

Output doubleword in EAX to I/O port address in DX.

pub fn out_Immediate8Bit_AL(&mut self, arg0: Immediate8Bit)

Output byte in AL to I/O port address imm8.

pub fn out_Immediate8Bit_AX(&mut self, arg0: Immediate8Bit)

Output word in AX to I/O port address imm8.

pub fn out_Immediate8Bit_EAX(&mut self, arg0: Immediate8Bit)

Output doubleword in EAX to I/O port address imm8.

pub fn outs_DX_Any16BitMemory(
    &mut self,
    arg0: Option<SegmentRegister>,
    address_override_for_32_bit: bool
)

Output word from memory location specified in DS:(E)SI or RSI to I/O port specified in DX.

pub fn outs_DX_Any32BitMemory(
    &mut self,
    arg0: Option<SegmentRegister>,
    address_override_for_32_bit: bool
)

Output doubleword from memory location specified in DS:(E)SI or RSI to I/O port specified in DX.

pub fn outs_DX_Any8BitMemory(
    &mut self,
    arg0: Option<SegmentRegister>,
    address_override_for_32_bit: bool
)

Output byte from memory location specified in DS:(E)SI or RSI to I/O port specified in DX.

pub fn outsb(&mut self)

Output byte from memory location specified in DS:(E)SI or RSI to I/O port specified in DX.

pub fn outsd(&mut self)

Output doubleword from memory location specified in DS:(E)SI or RSI to I/O port specified in DX.

pub fn outsw(&mut self)

Output word from memory location specified in DS:(E)SI or RSI to I/O port specified in DX.

pub fn pabsb_MMRegister_Any64BitMemory(
    &mut self,
    arg0: MMRegister,
    arg1: Any64BitMemory
)

Compute the absolute value of bytes in mm2/m64 and store unsigned result in mm1.

pub fn pabsb_MMRegister_MMRegister(&mut self, arg0: MMRegister, arg1: MMRegister)

Compute the absolute value of bytes in mm2/m64 and store unsigned result in mm1.

pub fn pabsb_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Compute the absolute value of bytes in xmm2/m128 and store unsigned result in xmm1.

pub fn pabsb_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Compute the absolute value of bytes in xmm2/m128 and store unsigned result in xmm1.

pub fn pabsd_MMRegister_Any64BitMemory(
    &mut self,
    arg0: MMRegister,
    arg1: Any64BitMemory
)

Compute the absolute value of 32-bit integers in mm2/m64 and store unsigned result in mm1.

pub fn pabsd_MMRegister_MMRegister(&mut self, arg0: MMRegister, arg1: MMRegister)

Compute the absolute value of 32-bit integers in mm2/m64 and store unsigned result in mm1.

pub fn pabsd_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Compute the absolute value of 32-bit integers in xmm2/m128 and store unsigned result in xmm1.

pub fn pabsd_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Compute the absolute value of 32-bit integers in xmm2/m128 and store unsigned result in xmm1.

pub fn pabsw_MMRegister_Any64BitMemory(
    &mut self,
    arg0: MMRegister,
    arg1: Any64BitMemory
)

Compute the absolute value of 16-bit integers in mm2/m64 and store unsigned result in mm1.

pub fn pabsw_MMRegister_MMRegister(&mut self, arg0: MMRegister, arg1: MMRegister)

Compute the absolute value of 16-bit integers in mm2/m64 and store unsigned result in mm1.

pub fn pabsw_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Compute the absolute value of 16-bit integers in xmm2/m128 and store unsigned result in xmm1.

pub fn pabsw_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Compute the absolute value of 16-bit integers in xmm2/m128 and store unsigned result in xmm1.

pub fn packssdw_MMRegister_Any64BitMemory(
    &mut self,
    arg0: MMRegister,
    arg1: Any64BitMemory
)

Converts 2 packed signed doubleword integers from mm1 and from mm2/m64 into 4 packed signed word integers in mm1 using signed saturation.

pub fn packssdw_MMRegister_MMRegister(
    &mut self,
    arg0: MMRegister,
    arg1: MMRegister
)

Converts 2 packed signed doubleword integers from mm1 and from mm2/m64 into 4 packed signed word integers in mm1 using signed saturation.

pub fn packssdw_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Converts 4 packed signed doubleword integers from xmm1 and from xmm2/m128 into 8 packed signed word integers in xmm1 using signed saturation.

pub fn packssdw_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Converts 4 packed signed doubleword integers from xmm1 and from xmm2/m128 into 8 packed signed word integers in xmm1 using signed saturation.

pub fn packsswb_MMRegister_Any64BitMemory(
    &mut self,
    arg0: MMRegister,
    arg1: Any64BitMemory
)

Converts 4 packed signed word integers from mm1 and from mm2/m64 into 8 packed signed byte integers in mm1 using signed saturation.

pub fn packsswb_MMRegister_MMRegister(
    &mut self,
    arg0: MMRegister,
    arg1: MMRegister
)

Converts 4 packed signed word integers from mm1 and from mm2/m64 into 8 packed signed byte integers in mm1 using signed saturation.

pub fn packsswb_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Converts 8 packed signed word integers from xmm1 and from xmm2/m128 into 16 packed signed byte integers in xmm1 using signed saturation.

pub fn packsswb_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Converts 8 packed signed word integers from xmm1 and from xmm2/m128 into 16 packed signed byte integers in xmm1 using signed saturation.

pub fn packusdw_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Convert 4 packed signed doubleword integers from xmm1 and 4 packed signed doubleword integers from xmm2/m128 into 8 packed unsigned word integers in xmm1 using unsigned saturation.

pub fn packusdw_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Convert 4 packed signed doubleword integers from xmm1 and 4 packed signed doubleword integers from xmm2/m128 into 8 packed unsigned word integers in xmm1 using unsigned saturation.

pub fn packuswb_MMRegister_Any64BitMemory(
    &mut self,
    arg0: MMRegister,
    arg1: Any64BitMemory
)

Converts 4 signed word integers from mm and 4 signed word integers from mm/m64 into 8 unsigned byte integers in mm using unsigned saturation.

pub fn packuswb_MMRegister_MMRegister(
    &mut self,
    arg0: MMRegister,
    arg1: MMRegister
)

Converts 4 signed word integers from mm and 4 signed word integers from mm/m64 into 8 unsigned byte integers in mm using unsigned saturation.

pub fn packuswb_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Converts 8 signed word integers from xmm1 and 8 signed word integers from xmm2/m128 into 16 unsigned byte integers in xmm1 using unsigned saturation.

pub fn packuswb_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Converts 8 signed word integers from xmm1 and 8 signed word integers from xmm2/m128 into 16 unsigned byte integers in xmm1 using unsigned saturation.

pub fn paddb_MMRegister_Any64BitMemory(
    &mut self,
    arg0: MMRegister,
    arg1: Any64BitMemory
)

Add packed byte integers from mm/m64 and mm.

pub fn paddb_MMRegister_MMRegister(&mut self, arg0: MMRegister, arg1: MMRegister)

Add packed byte integers from mm/m64 and mm.

pub fn paddb_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Add packed byte integers from xmm2/m128 and xmm1.

pub fn paddb_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Add packed byte integers from xmm2/m128 and xmm1.

pub fn paddd_MMRegister_Any64BitMemory(
    &mut self,
    arg0: MMRegister,
    arg1: Any64BitMemory
)

Add packed doubleword integers from mm/m64 and mm.

pub fn paddd_MMRegister_MMRegister(&mut self, arg0: MMRegister, arg1: MMRegister)

Add packed doubleword integers from mm/m64 and mm.

pub fn paddd_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Add packed doubleword integers from xmm2/m128 and xmm1.

pub fn paddd_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Add packed doubleword integers from xmm2/m128 and xmm1.

pub fn paddq_MMRegister_Any64BitMemory(
    &mut self,
    arg0: MMRegister,
    arg1: Any64BitMemory
)

Add quadword integer mm2/m64 to mm1.

pub fn paddq_MMRegister_MMRegister(&mut self, arg0: MMRegister, arg1: MMRegister)

Add quadword integer mm2/m64 to mm1.

pub fn paddq_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Add packed quadword integers xmm2/m128 to xmm1.

pub fn paddq_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Add packed quadword integers xmm2/m128 to xmm1.

pub fn paddsb_MMRegister_Any64BitMemory(
    &mut self,
    arg0: MMRegister,
    arg1: Any64BitMemory
)

Add packed signed byte integers from mm/m64 and mm and saturate the results.

pub fn paddsb_MMRegister_MMRegister(&mut self, arg0: MMRegister, arg1: MMRegister)

Add packed signed byte integers from mm/m64 and mm and saturate the results.

pub fn paddsb_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Add packed signed byte integers from xmm2/m128 and xmm1 saturate the results.

pub fn paddsb_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Add packed signed byte integers from xmm2/m128 and xmm1 saturate the results.

pub fn paddsw_MMRegister_Any64BitMemory(
    &mut self,
    arg0: MMRegister,
    arg1: Any64BitMemory
)

Add packed signed word integers from mm/m64 and mm and saturate the results.

pub fn paddsw_MMRegister_MMRegister(&mut self, arg0: MMRegister, arg1: MMRegister)

Add packed signed word integers from mm/m64 and mm and saturate the results.

pub fn paddsw_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Add packed signed word integers from xmm2/m128 and xmm1 and saturate the results.

pub fn paddsw_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Add packed signed word integers from xmm2/m128 and xmm1 and saturate the results.

pub fn paddusb_MMRegister_Any64BitMemory(
    &mut self,
    arg0: MMRegister,
    arg1: Any64BitMemory
)

Add packed unsigned byte integers from mm/m64 and mm and saturate the results.

pub fn paddusb_MMRegister_MMRegister(
    &mut self,
    arg0: MMRegister,
    arg1: MMRegister
)

Add packed unsigned byte integers from mm/m64 and mm and saturate the results.

pub fn paddusb_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Add packed unsigned byte integers from xmm2/m128 and xmm1 saturate the results.

pub fn paddusb_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Add packed unsigned byte integers from xmm2/m128 and xmm1 saturate the results.

pub fn paddusw_MMRegister_Any64BitMemory(
    &mut self,
    arg0: MMRegister,
    arg1: Any64BitMemory
)

Add packed unsigned word integers from mm/m64 and mm and saturate the results.

pub fn paddusw_MMRegister_MMRegister(
    &mut self,
    arg0: MMRegister,
    arg1: MMRegister
)

Add packed unsigned word integers from mm/m64 and mm and saturate the results.

pub fn paddusw_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Add packed unsigned word integers from xmm2/m128 to xmm1 and saturate the results.

pub fn paddusw_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Add packed unsigned word integers from xmm2/m128 to xmm1 and saturate the results.

pub fn paddw_MMRegister_Any64BitMemory(
    &mut self,
    arg0: MMRegister,
    arg1: Any64BitMemory
)

Add packed word integers from mm/m64 and mm.

pub fn paddw_MMRegister_MMRegister(&mut self, arg0: MMRegister, arg1: MMRegister)

Add packed word integers from mm/m64 and mm.

pub fn paddw_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Add packed word integers from xmm2/m128 and xmm1.

pub fn paddw_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Add packed word integers from xmm2/m128 and xmm1.

pub fn palignr_MMRegister_Any64BitMemory_Immediate8Bit(
    &mut self,
    arg0: MMRegister,
    arg1: Any64BitMemory,
    arg2: Immediate8Bit
)

Concatenate destination and source operands, extract byte-aligned result shifted to the right by constant value in imm8 into mm1.

pub fn palignr_MMRegister_MMRegister_Immediate8Bit(
    &mut self,
    arg0: MMRegister,
    arg1: MMRegister,
    arg2: Immediate8Bit
)

Concatenate destination and source operands, extract byte-aligned result shifted to the right by constant value in imm8 into mm1.

pub fn palignr_XMMRegister_Any128BitMemory_Immediate8Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory,
    arg2: Immediate8Bit
)

Concatenate destination and source operands, extract byte-aligned result shifted to the right by constant value in imm8 into xmm1.

pub fn palignr_XMMRegister_XMMRegister_Immediate8Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Immediate8Bit
)

Concatenate destination and source operands, extract byte-aligned result shifted to the right by constant value in imm8 into xmm1.

pub fn pand_MMRegister_Any64BitMemory(
    &mut self,
    arg0: MMRegister,
    arg1: Any64BitMemory
)

Bitwise AND mm/m64 and mm.

pub fn pand_MMRegister_MMRegister(&mut self, arg0: MMRegister, arg1: MMRegister)

Bitwise AND mm/m64 and mm.

pub fn pand_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Bitwise AND of xmm2/m128 and xmm1.

pub fn pand_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Bitwise AND of xmm2/m128 and xmm1.

pub fn pandn_MMRegister_Any64BitMemory(
    &mut self,
    arg0: MMRegister,
    arg1: Any64BitMemory
)

Bitwise AND NOT of mm/m64 and mm.

pub fn pandn_MMRegister_MMRegister(&mut self, arg0: MMRegister, arg1: MMRegister)

Bitwise AND NOT of mm/m64 and mm.

pub fn pandn_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Bitwise AND NOT of xmm2/m128 and xmm1.

pub fn pandn_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Bitwise AND NOT of xmm2/m128 and xmm1.

pub fn pause(&mut self)

Gives hint to processor that improves performance of spin-wait loops.

pub fn pavgb_MMRegister_Any64BitMemory(
    &mut self,
    arg0: MMRegister,
    arg1: Any64BitMemory
)

Average packed unsigned byte integers from mm2/m64 and mm1 with rounding.

pub fn pavgb_MMRegister_MMRegister(&mut self, arg0: MMRegister, arg1: MMRegister)

Average packed unsigned byte integers from mm2/m64 and mm1 with rounding.

pub fn pavgb_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Average packed unsigned byte integers from xmm2/m128 and xmm1 with rounding.

pub fn pavgb_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Average packed unsigned byte integers from xmm2/m128 and xmm1 with rounding.

pub fn pavgw_MMRegister_Any64BitMemory(
    &mut self,
    arg0: MMRegister,
    arg1: Any64BitMemory
)

Average packed unsigned word integers from mm2/m64 and mm1 with rounding.

pub fn pavgw_MMRegister_MMRegister(&mut self, arg0: MMRegister, arg1: MMRegister)

Average packed unsigned word integers from mm2/m64 and mm1 with rounding.

pub fn pavgw_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Average packed unsigned word integers from xmm2/m128 and xmm1 with rounding.

pub fn pavgw_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Average packed unsigned word integers from xmm2/m128 and xmm1 with rounding.

pub fn pblendvb_XMMRegister_Any128BitMemory_XMMRegister0(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Select byte values from xmm1 and xmm2/m128 from mask specified in the high bit of each byte in XMM0 and store the values into xmm1.

pub fn pblendvb_XMMRegister_XMMRegister_XMMRegister0(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Select byte values from xmm1 and xmm2/m128 from mask specified in the high bit of each byte in XMM0 and store the values into xmm1.

pub fn pblendw_XMMRegister_Any128BitMemory_Immediate8Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory,
    arg2: Immediate8Bit
)

Select words from xmm1 and xmm2/m128 from mask specified in imm8 and store the values into xmm1.

pub fn pblendw_XMMRegister_XMMRegister_Immediate8Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Immediate8Bit
)

Select words from xmm1 and xmm2/m128 from mask specified in imm8 and store the values into xmm1.

pub fn pclmulqdq_XMMRegister_Any128BitMemory_Immediate8Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory,
    arg2: Immediate8Bit
)

Carry-less multiplication of one quadword of xmm1 by one quadword of xmm2/m128, stores the 128-bit result in xmm1.

The immediate is used to determine which quadwords of xmm1 and xmm2/m128 should be used.

pub fn pclmulqdq_XMMRegister_XMMRegister_Immediate8Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Immediate8Bit
)

Carry-less multiplication of one quadword of xmm1 by one quadword of xmm2/m128, stores the 128-bit result in xmm1.

The immediate is used to determine which quadwords of xmm1 and xmm2/m128 should be used.

pub fn pcmpeqb_MMRegister_Any64BitMemory(
    &mut self,
    arg0: MMRegister,
    arg1: Any64BitMemory
)

Compare packed bytes in mm/m64 and mm for equality.

pub fn pcmpeqb_MMRegister_MMRegister(
    &mut self,
    arg0: MMRegister,
    arg1: MMRegister
)

Compare packed bytes in mm/m64 and mm for equality.

pub fn pcmpeqb_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Compare packed bytes in xmm2/m128 and xmm1 for equality.

pub fn pcmpeqb_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Compare packed bytes in xmm2/m128 and xmm1 for equality.

pub fn pcmpeqd_MMRegister_Any64BitMemory(
    &mut self,
    arg0: MMRegister,
    arg1: Any64BitMemory
)

Compare packed doublewords in mm/m64 and mm for equality.

pub fn pcmpeqd_MMRegister_MMRegister(
    &mut self,
    arg0: MMRegister,
    arg1: MMRegister
)

Compare packed doublewords in mm/m64 and mm for equality.

pub fn pcmpeqd_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Compare packed doublewords in xmm2/m128 and xmm1 for equality.

pub fn pcmpeqd_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Compare packed doublewords in xmm2/m128 and xmm1 for equality.

pub fn pcmpeqq_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Compare packed qwords in xmm2/m128 and xmm1 for equality.

pub fn pcmpeqq_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Compare packed qwords in xmm2/m128 and xmm1 for equality.

pub fn pcmpeqw_MMRegister_Any64BitMemory(
    &mut self,
    arg0: MMRegister,
    arg1: Any64BitMemory
)

Compare packed words in mm/m64 and mm for equality.

pub fn pcmpeqw_MMRegister_MMRegister(
    &mut self,
    arg0: MMRegister,
    arg1: MMRegister
)

Compare packed words in mm/m64 and mm for equality.

pub fn pcmpeqw_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Compare packed words in xmm2/m128 and xmm1 for equality.

pub fn pcmpeqw_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Compare packed words in xmm2/m128 and xmm1 for equality.

pub fn pcmpestri_XMMRegister_Any128BitMemory_Immediate8Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory,
    arg2: Immediate8Bit
)

Perform a packed comparison of string data with explicit lengths, generating an index, and storing the result in ECX.

pub fn pcmpestri_XMMRegister_XMMRegister_Immediate8Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Immediate8Bit
)

Perform a packed comparison of string data with explicit lengths, generating an index, and storing the result in ECX.

pub fn pcmpestrm_XMMRegister_Any128BitMemory_Immediate8Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory,
    arg2: Immediate8Bit
)

Perform a packed comparison of string data with explicit lengths, generating a mask, and storing the result in XMM0.

pub fn pcmpestrm_XMMRegister_XMMRegister_Immediate8Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Immediate8Bit
)

Perform a packed comparison of string data with explicit lengths, generating a mask, and storing the result in XMM0.

pub fn pcmpgtb_MMRegister_Any64BitMemory(
    &mut self,
    arg0: MMRegister,
    arg1: Any64BitMemory
)

Compare packed signed byte integers in mm and mm/m64 for greater than.

pub fn pcmpgtb_MMRegister_MMRegister(
    &mut self,
    arg0: MMRegister,
    arg1: MMRegister
)

Compare packed signed byte integers in mm and mm/m64 for greater than.

pub fn pcmpgtb_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Compare packed signed byte integers in xmm1 and xmm2/m128 for greater than.

pub fn pcmpgtb_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Compare packed signed byte integers in xmm1 and xmm2/m128 for greater than.

pub fn pcmpgtd_MMRegister_Any64BitMemory(
    &mut self,
    arg0: MMRegister,
    arg1: Any64BitMemory
)

Compare packed signed doubleword integers in mm and mm/m64 for greater than.

pub fn pcmpgtd_MMRegister_MMRegister(
    &mut self,
    arg0: MMRegister,
    arg1: MMRegister
)

Compare packed signed doubleword integers in mm and mm/m64 for greater than.

pub fn pcmpgtd_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Compare packed signed doubleword integers in xmm1 and xmm2/m128 for greater than.

pub fn pcmpgtd_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Compare packed signed doubleword integers in xmm1 and xmm2/m128 for greater than.

pub fn pcmpgtq_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Compare packed signed qwords in xmm2/m128 and xmm1 for greater than.

pub fn pcmpgtq_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Compare packed signed qwords in xmm2/m128 and xmm1 for greater than.

pub fn pcmpgtw_MMRegister_Any64BitMemory(
    &mut self,
    arg0: MMRegister,
    arg1: Any64BitMemory
)

Compare packed signed word integers in mm and mm/m64 for greater than.

pub fn pcmpgtw_MMRegister_MMRegister(
    &mut self,
    arg0: MMRegister,
    arg1: MMRegister
)

Compare packed signed word integers in mm and mm/m64 for greater than.

pub fn pcmpgtw_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Compare packed signed word integers in xmm1 and xmm2/m128 for greater than.

pub fn pcmpgtw_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Compare packed signed word integers in xmm1 and xmm2/m128 for greater than.

pub fn pcmpistri_XMMRegister_Any128BitMemory_Immediate8Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory,
    arg2: Immediate8Bit
)

Perform a packed comparison of string data with implicit lengths, generating an index, and storing the result in ECX.

pub fn pcmpistri_XMMRegister_XMMRegister_Immediate8Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Immediate8Bit
)

Perform a packed comparison of string data with implicit lengths, generating an index, and storing the result in ECX.

pub fn pcmpistrm_XMMRegister_Any128BitMemory_Immediate8Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory,
    arg2: Immediate8Bit
)

Perform a packed comparison of string data with implicit lengths, generating a mask, and storing the result in XMM0.

pub fn pcmpistrm_XMMRegister_XMMRegister_Immediate8Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Immediate8Bit
)

Perform a packed comparison of string data with implicit lengths, generating a mask, and storing the result in XMM0.

pub fn pdep_Register32Bit_Register32Bit_Any32BitMemory(
    &mut self,
    arg0: Register32Bit,
    arg1: Register32Bit,
    arg2: Any32BitMemory
)

Parallel deposit of bits from r32b using mask in r/m32, result is written to r32a.

pub fn pdep_Register32Bit_Register32Bit_Register32Bit(
    &mut self,
    arg0: Register32Bit,
    arg1: Register32Bit,
    arg2: Register32Bit
)

Parallel deposit of bits from r32b using mask in r/m32, result is written to r32a.

pub fn pdep_Register64Bit_Register64Bit_Any64BitMemory(
    &mut self,
    arg0: Register64Bit,
    arg1: Register64Bit,
    arg2: Any64BitMemory
)

Parallel deposit of bits from r64b using mask in r/m64, result is written to r64a.

pub fn pdep_Register64Bit_Register64Bit_Register64Bit(
    &mut self,
    arg0: Register64Bit,
    arg1: Register64Bit,
    arg2: Register64Bit
)

Parallel deposit of bits from r64b using mask in r/m64, result is written to r64a.

pub fn pext_Register32Bit_Register32Bit_Any32BitMemory(
    &mut self,
    arg0: Register32Bit,
    arg1: Register32Bit,
    arg2: Any32BitMemory
)

Parallel extract of bits from r32b using mask in r/m32, result is written to r32a.

pub fn pext_Register32Bit_Register32Bit_Register32Bit(
    &mut self,
    arg0: Register32Bit,
    arg1: Register32Bit,
    arg2: Register32Bit
)

Parallel extract of bits from r32b using mask in r/m32, result is written to r32a.

pub fn pext_Register64Bit_Register64Bit_Any64BitMemory(
    &mut self,
    arg0: Register64Bit,
    arg1: Register64Bit,
    arg2: Any64BitMemory
)

Parallel extract of bits from r64b using mask in r/m64, result is written to r64a.

pub fn pext_Register64Bit_Register64Bit_Register64Bit(
    &mut self,
    arg0: Register64Bit,
    arg1: Register64Bit,
    arg2: Register64Bit
)

Parallel extract of bits from r64b using mask in r/m64, result is written to r64a.

pub fn pextrb_Any8BitMemory_XMMRegister_Immediate8Bit(
    &mut self,
    arg0: Any8BitMemory,
    arg1: XMMRegister,
    arg2: Immediate8Bit
)

Extract a byte integer value from xmm2 at the source byte offset specified by imm8 into rreg or m8.

The upper bits of r32 or r64 are zeroed.

pub fn pextrb_Register32Bit_XMMRegister_Immediate8Bit(
    &mut self,
    arg0: Register32Bit,
    arg1: XMMRegister,
    arg2: Immediate8Bit
)

Extract a byte integer value from xmm2 at the source byte offset specified by imm8 into rreg or m8.

The upper bits of r32 or r64 are zeroed.

pub fn pextrb_Register64Bit_XMMRegister_Immediate8Bit(
    &mut self,
    arg0: Register64Bit,
    arg1: XMMRegister,
    arg2: Immediate8Bit
)

Extract a byte integer value from xmm2 at the source byte offset specified by imm8 into rreg or m8.

The upper bits of r32 or r64 are zeroed.

pub fn pextrd_Any32BitMemory_XMMRegister_Immediate8Bit(
    &mut self,
    arg0: Any32BitMemory,
    arg1: XMMRegister,
    arg2: Immediate8Bit
)

Extract a dword integer value from xmm2 at the source dword offset specified by imm8 into r/m32.

pub fn pextrd_Register32Bit_XMMRegister_Immediate8Bit(
    &mut self,
    arg0: Register32Bit,
    arg1: XMMRegister,
    arg2: Immediate8Bit
)

Extract a dword integer value from xmm2 at the source dword offset specified by imm8 into r/m32.

pub fn pextrq_Any64BitMemory_XMMRegister_Immediate8Bit(
    &mut self,
    arg0: Any64BitMemory,
    arg1: XMMRegister,
    arg2: Immediate8Bit
)

Extract a qword integer value from xmm2 at the source qword offset specified by imm8 into r/m64.

pub fn pextrq_Register64Bit_XMMRegister_Immediate8Bit(
    &mut self,
    arg0: Register64Bit,
    arg1: XMMRegister,
    arg2: Immediate8Bit
)

Extract a qword integer value from xmm2 at the source qword offset specified by imm8 into r/m64.

pub fn pextrw_Any16BitMemory_XMMRegister_Immediate8Bit(
    &mut self,
    arg0: Any16BitMemory,
    arg1: XMMRegister,
    arg2: Immediate8Bit
)

Extract the word specified by imm8 from xmm and copy it to lowest 16 bits of reg or m16.

Zero-extend the result in the destination, r32 or r64.

pub fn pextrw_Register32Bit_MMRegister_Immediate8Bit(
    &mut self,
    arg0: Register32Bit,
    arg1: MMRegister,
    arg2: Immediate8Bit
)

Extract the word specified by imm8 from mm and move it to reg, bits 15-0.

The upper bits of r32 or r64 is zeroed.

pub fn pextrw_Register32Bit_XMMRegister_Immediate8Bit(
    &mut self,
    arg0: Register32Bit,
    arg1: XMMRegister,
    arg2: Immediate8Bit
)

Extract the word specified by imm8 from xmm and move it to reg, bits 15-0.

The upper bits of r32 or r64 is zeroed.

pub fn pextrw_Register32Bit_XMMRegister_Immediate8Bit_1(
    &mut self,
    arg0: Register32Bit,
    arg1: XMMRegister,
    arg2: Immediate8Bit
)

Extract the word specified by imm8 from xmm and move it to reg, bits 15-0.

The upper bits of r32 or r64 is zeroed. Extract the word specified by imm8 from xmm and move it to reg, bits 15-0.

The upper bits of r32 or r64 is zeroed.

pub fn pextrw_Register64Bit_MMRegister_Immediate8Bit(
    &mut self,
    arg0: Register64Bit,
    arg1: MMRegister,
    arg2: Immediate8Bit
)

Extract the word specified by imm8 from mm and move it to reg, bits 15-0.

The upper bits of r32 or r64 is zeroed.

pub fn pextrw_Register64Bit_XMMRegister_Immediate8Bit(
    &mut self,
    arg0: Register64Bit,
    arg1: XMMRegister,
    arg2: Immediate8Bit
)

Extract the word specified by imm8 from xmm and move it to reg, bits 15-0.

The upper bits of r32 or r64 is zeroed.

pub fn pextrw_Register64Bit_XMMRegister_Immediate8Bit_1(
    &mut self,
    arg0: Register64Bit,
    arg1: XMMRegister,
    arg2: Immediate8Bit
)

Extract the word specified by imm8 from xmm and move it to reg, bits 15-0.

The upper bits of r32 or r64 is zeroed.

pub fn phaddd_MMRegister_Any64BitMemory(
    &mut self,
    arg0: MMRegister,
    arg1: Any64BitMemory
)

Add 32-bit integers horizontally, pack to mm1.

pub fn phaddd_MMRegister_MMRegister(&mut self, arg0: MMRegister, arg1: MMRegister)

Add 32-bit integers horizontally, pack to mm1.

pub fn phaddd_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Add 32-bit integers horizontally, pack to xmm1.

pub fn phaddd_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Add 32-bit integers horizontally, pack to xmm1.

pub fn phaddsw_MMRegister_Any64BitMemory(
    &mut self,
    arg0: MMRegister,
    arg1: Any64BitMemory
)

Add 16-bit signed integers horizontally, pack saturated integers to mm1.

pub fn phaddsw_MMRegister_MMRegister(
    &mut self,
    arg0: MMRegister,
    arg1: MMRegister
)

Add 16-bit signed integers horizontally, pack saturated integers to mm1.

pub fn phaddsw_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Add 16-bit signed integers horizontally, pack saturated integers to xmm1.

pub fn phaddsw_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Add 16-bit signed integers horizontally, pack saturated integers to xmm1.

pub fn phaddw_MMRegister_Any64BitMemory(
    &mut self,
    arg0: MMRegister,
    arg1: Any64BitMemory
)

Add 16-bit integers horizontally, pack to mm1.

pub fn phaddw_MMRegister_MMRegister(&mut self, arg0: MMRegister, arg1: MMRegister)

Add 16-bit integers horizontally, pack to mm1.

pub fn phaddw_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Add 16-bit integers horizontally, pack to xmm1.

pub fn phaddw_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Add 16-bit integers horizontally, pack to xmm1.

pub fn phminposuw_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Find the minimum unsigned word in xmm2/m128 and place its value in the low word of xmm1 and its index in the second-lowest word of xmm1.

pub fn phminposuw_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Find the minimum unsigned word in xmm2/m128 and place its value in the low word of xmm1 and its index in the second-lowest word of xmm1.

pub fn phsubd_MMRegister_Any64BitMemory(
    &mut self,
    arg0: MMRegister,
    arg1: Any64BitMemory
)

Subtract 32-bit signed integers horizontally, pack to mm1.

pub fn phsubd_MMRegister_MMRegister(&mut self, arg0: MMRegister, arg1: MMRegister)

Subtract 32-bit signed integers horizontally, pack to mm1.

pub fn phsubd_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Subtract 32-bit signed integers horizontally, pack to xmm1.

pub fn phsubd_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Subtract 32-bit signed integers horizontally, pack to xmm1.

pub fn phsubsw_MMRegister_Any64BitMemory(
    &mut self,
    arg0: MMRegister,
    arg1: Any64BitMemory
)

Subtract 16-bit signed integer horizontally, pack saturated integers to mm1.

pub fn phsubsw_MMRegister_MMRegister(
    &mut self,
    arg0: MMRegister,
    arg1: MMRegister
)

Subtract 16-bit signed integer horizontally, pack saturated integers to mm1.

pub fn phsubsw_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Subtract 16-bit signed integer horizontally, pack saturated integers to xmm1.

pub fn phsubsw_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Subtract 16-bit signed integer horizontally, pack saturated integers to xmm1.

pub fn phsubw_MMRegister_Any64BitMemory(
    &mut self,
    arg0: MMRegister,
    arg1: Any64BitMemory
)

Subtract 16-bit signed integers horizontally, pack to mm1.

pub fn phsubw_MMRegister_MMRegister(&mut self, arg0: MMRegister, arg1: MMRegister)

Subtract 16-bit signed integers horizontally, pack to mm1.

pub fn phsubw_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Subtract 16-bit signed integers horizontally, pack to XMM1.

pub fn phsubw_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Subtract 16-bit signed integers horizontally, pack to xmm1.

pub fn pinsrb_XMMRegister_Any8BitMemory_Immediate8Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: Any8BitMemory,
    arg2: Immediate8Bit
)

Insert a byte integer value from r32/m8 into xmm1 at the destination element in xmm1 specified by imm8.

pub fn pinsrb_XMMRegister_Register32Bit_Immediate8Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: Register32Bit,
    arg2: Immediate8Bit
)

Insert a byte integer value from r32/m8 into xmm1 at the destination element in xmm1 specified by imm8.

pub fn pinsrd_XMMRegister_Any32BitMemory_Immediate8Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: Any32BitMemory,
    arg2: Immediate8Bit
)

Insert a dword integer value from r/m32 into the xmm1 at the destination element specified by imm8.

pub fn pinsrd_XMMRegister_Register32Bit_Immediate8Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: Register32Bit,
    arg2: Immediate8Bit
)

Insert a dword integer value from r/m32 into the xmm1 at the destination element specified by imm8.

pub fn pinsrw_MMRegister_Any16BitMemory_Immediate8Bit(
    &mut self,
    arg0: MMRegister,
    arg1: Any16BitMemory,
    arg2: Immediate8Bit
)

Insert the low word from r32 or from m16 into mm at the word position specified by imm8.

pub fn pinsrw_MMRegister_Register32Bit_Immediate8Bit(
    &mut self,
    arg0: MMRegister,
    arg1: Register32Bit,
    arg2: Immediate8Bit
)

Insert the low word from r32 or from m16 into mm at the word position specified by imm8.

pub fn pinsrw_XMMRegister_Any16BitMemory_Immediate8Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: Any16BitMemory,
    arg2: Immediate8Bit
)

Move the low word of r32 or from m16 into xmm at the word position specified by imm8.

pub fn pinsrw_XMMRegister_Register32Bit_Immediate8Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: Register32Bit,
    arg2: Immediate8Bit
)

Move the low word of r32 or from m16 into xmm at the word position specified by imm8.

pub fn pmaddubsw_MMRegister_Any64BitMemory(
    &mut self,
    arg0: MMRegister,
    arg1: Any64BitMemory
)

Multiply signed and unsigned bytes, add horizontal pair of signed words, pack saturated signed-words to mm1.

pub fn pmaddubsw_MMRegister_MMRegister(
    &mut self,
    arg0: MMRegister,
    arg1: MMRegister
)

Multiply signed and unsigned bytes, add horizontal pair of signed words, pack saturated signed-words to mm1.

pub fn pmaddubsw_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Multiply signed and unsigned bytes, add horizontal pair of signed words, pack saturated signed-words to xmm1.

pub fn pmaddubsw_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Multiply signed and unsigned bytes, add horizontal pair of signed words, pack saturated signed-words to xmm1.

pub fn pmaddwd_MMRegister_Any64BitMemory(
    &mut self,
    arg0: MMRegister,
    arg1: Any64BitMemory
)

Multiply the packed words in mm by the packed words in mm/m64, add adjacent doubleword results, and store in mm.

pub fn pmaddwd_MMRegister_MMRegister(
    &mut self,
    arg0: MMRegister,
    arg1: MMRegister
)

Multiply the packed words in mm by the packed words in mm/m64, add adjacent doubleword results, and store in mm.

pub fn pmaddwd_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Multiply the packed word integers in xmm1 by the packed word integers in xmm2/m128, add adjacent doubleword results, and store in xmm1.

pub fn pmaddwd_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Multiply the packed word integers in xmm1 by the packed word integers in xmm2/m128, add adjacent doubleword results, and store in xmm1.

pub fn pmaxsb_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Compare packed signed byte integers in xmm1 and xmm2/m128 and store packed maximum values in xmm1.

pub fn pmaxsb_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Compare packed signed byte integers in xmm1 and xmm2/m128 and store packed maximum values in xmm1.

pub fn pmaxsd_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Compare packed signed dword integers in xmm1 and xmm2/m128 and store packed maximum values in xmm1.

pub fn pmaxsd_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Compare packed signed dword integers in xmm1 and xmm2/m128 and store packed maximum values in xmm1.

pub fn pmaxsw_MMRegister_Any64BitMemory(
    &mut self,
    arg0: MMRegister,
    arg1: Any64BitMemory
)

Compare signed word integers in mm2/m64 and mm1 and return maximum values.

pub fn pmaxsw_MMRegister_MMRegister(&mut self, arg0: MMRegister, arg1: MMRegister)

Compare signed word integers in mm2/m64 and mm1 and return maximum values.

pub fn pmaxsw_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Compare signed word integers in xmm2/m128 and xmm1 and return maximum values.

pub fn pmaxsw_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Compare signed word integers in xmm2/m128 and xmm1 and return maximum values.

pub fn pmaxub_MMRegister_Any64BitMemory(
    &mut self,
    arg0: MMRegister,
    arg1: Any64BitMemory
)

Compare unsigned byte integers in mm2/m64 and mm1 and returns maximum values.

pub fn pmaxub_MMRegister_MMRegister(&mut self, arg0: MMRegister, arg1: MMRegister)

Compare unsigned byte integers in mm2/m64 and mm1 and returns maximum values.

pub fn pmaxub_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Compare unsigned byte integers in xmm2/m128 and xmm1 and returns maximum values.

pub fn pmaxub_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Compare unsigned byte integers in xmm2/m128 and xmm1 and returns maximum values.

pub fn pmaxud_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Compare packed unsigned dword integers in xmm1 and xmm2/m128 and store packed maximum values in xmm1.

pub fn pmaxud_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Compare packed unsigned dword integers in xmm1 and xmm2/m128 and store packed maximum values in xmm1.

pub fn pmaxuw_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Compare packed unsigned word integers in xmm1 and xmm2/m128 and store packed maximum values in xmm1.

pub fn pmaxuw_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Compare packed unsigned word integers in xmm1 and xmm2/m128 and store packed maximum values in xmm1.

pub fn pminsb_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Compare packed signed byte integers in xmm1 and xmm2/m128 and store packed minimum values in xmm1.

pub fn pminsb_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Compare packed signed byte integers in xmm1 and xmm2/m128 and store packed minimum values in xmm1.

pub fn pminsd_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Compare packed signed dword integers in xmm1 and xmm2/m128 and store packed minimum values in xmm1.

pub fn pminsd_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Compare packed signed dword integers in xmm1 and xmm2/m128 and store packed minimum values in xmm1.

pub fn pminsw_MMRegister_Any64BitMemory(
    &mut self,
    arg0: MMRegister,
    arg1: Any64BitMemory
)

Compare signed word integers in mm2/m64 and mm1 and return minimum values.

pub fn pminsw_MMRegister_MMRegister(&mut self, arg0: MMRegister, arg1: MMRegister)

Compare signed word integers in mm2/m64 and mm1 and return minimum values.

pub fn pminsw_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Compare signed word integers in xmm2/m128 and xmm1 and return minimum values.

pub fn pminsw_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Compare signed word integers in xmm2/m128 and xmm1 and return minimum values.

pub fn pminub_MMRegister_Any64BitMemory(
    &mut self,
    arg0: MMRegister,
    arg1: Any64BitMemory
)

Compare unsigned byte integers in mm2/m64 and mm1 and returns minimum values.

pub fn pminub_MMRegister_MMRegister(&mut self, arg0: MMRegister, arg1: MMRegister)

Compare unsigned byte integers in mm2/m64 and mm1 and returns minimum values.

pub fn pminub_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Compare unsigned byte integers in xmm2/m128 and xmm1 and returns minimum values.

pub fn pminub_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Compare unsigned byte integers in xmm2/m128 and xmm1 and returns minimum values.

pub fn pminud_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Compare packed unsigned dword integers in xmm1 and xmm2/m128 and store packed minimum values in xmm1.

pub fn pminud_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Compare packed unsigned dword integers in xmm1 and xmm2/m128 and store packed minimum values in xmm1.

pub fn pminuw_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Compare packed unsigned word integers in xmm1 and xmm2/m128 and store packed minimum values in xmm1.

pub fn pminuw_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Compare packed unsigned word integers in xmm1 and xmm2/m128 and store packed minimum values in xmm1.

pub fn pmovmskb_Register32Bit_MMRegister(
    &mut self,
    arg0: Register32Bit,
    arg1: MMRegister
)

Move a byte mask of mm to register.

The upper bits of r32 or r64 are zeroed.

pub fn pmovmskb_Register32Bit_XMMRegister(
    &mut self,
    arg0: Register32Bit,
    arg1: XMMRegister
)

Move a byte mask of xmm to register.

The upper bits of r32 or r64 are zeroed.

pub fn pmovmskb_Register64Bit_MMRegister(
    &mut self,
    arg0: Register64Bit,
    arg1: MMRegister
)

Move a byte mask of mm to register.

The upper bits of r32 or r64 are zeroed.

pub fn pmovmskb_Register64Bit_XMMRegister(
    &mut self,
    arg0: Register64Bit,
    arg1: XMMRegister
)

Move a byte mask of xmm to register.

The upper bits of r32 or r64 are zeroed.

pub fn pmovsxbd_XMMRegister_Any32BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any32BitMemory
)

Sign extend 4 packed signed 8-bit integers in the low 4 bytes of xmm2/m32 to 4 packed signed 32-bit integers in xmm1.

pub fn pmovsxbd_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Sign extend 4 packed signed 8-bit integers in the low 4 bytes of xmm2/m32 to 4 packed signed 32-bit integers in xmm1.

pub fn pmovsxbq_XMMRegister_Any16BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any16BitMemory
)

Sign extend 2 packed signed 8-bit integers in the low 2 bytes of xmm2.m16 to 2 packed signed 64-bit integers in xmm1.

pub fn pmovsxbq_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Sign extend 2 packed signed 8-bit integers in the low 2 bytes of xmm2.m16 to 2 packed signed 64-bit integers in xmm1.

pub fn pmovsxbw_XMMRegister_Any64BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any64BitMemory
)

Sign extend 8 packed signed 8-bit integers in the low 8 bytes of xmm2/m64 to 8 packed signed 16-bit integers in xmm1.

pub fn pmovsxbw_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Sign extend 8 packed signed 8-bit integers in the low 8 bytes of xmm2/m64 to 8 packed signed 16-bit integers in xmm1.

pub fn pmovsxdq_XMMRegister_Any64BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any64BitMemory
)

Sign extend 2 packed signed 32-bit integers in the low 8 bytes of xmm2/m64 to 2 packed signed 64-bit integers in xmm1.

pub fn pmovsxdq_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Sign extend 2 packed signed 32-bit integers in the low 8 bytes of xmm2/m64 to 2 packed signed 64-bit integers in xmm1.

pub fn pmovsxwd_XMMRegister_Any64BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any64BitMemory
)

Sign extend 4 packed signed 16-bit integers in the low 8 bytes of xmm2/m64 to 4 packed signed 32-bit integers in xmm1.

pub fn pmovsxwd_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Sign extend 4 packed signed 16-bit integers in the low 8 bytes of xmm2/m64 to 4 packed signed 32-bit integers in xmm1.

pub fn pmovsxwq_XMMRegister_Any32BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any32BitMemory
)

Sign extend 2 packed signed 16-bit integers in the low 4 bytes of xmm2/m32 to 2 packed signed 64-bit integers in xmm1.

pub fn pmovsxwq_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Sign extend 2 packed signed 16-bit integers in the low 4 bytes of xmm2/m32 to 2 packed signed 64-bit integers in xmm1.

pub fn pmovzxbd_XMMRegister_Any32BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any32BitMemory
)

Zero extend 4 packed 8-bit integers in the low 4 bytes of xmm2/m32 to 4 packed 32-bit integers in xmm1.

pub fn pmovzxbd_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Zero extend 4 packed 8-bit integers in the low 4 bytes of xmm2/m32 to 4 packed 32-bit integers in xmm1.

pub fn pmovzxbq_XMMRegister_Any16BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any16BitMemory
)

Zero extend 2 packed 8-bit integers in the low 2 bytes of xmm2.m16 to 2 packed 64-bit integers in xmm1.

pub fn pmovzxbq_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Zero extend 2 packed 8-bit integers in the low 2 bytes of xmm2.m16 to 2 packed 64-bit integers in xmm1.

pub fn pmovzxbw_XMMRegister_Any64BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any64BitMemory
)

Zero extend 8 packed 8-bit integers in the low 8 bytes of xmm2/m64 to 8 packed 16-bit integers in xmm1.

pub fn pmovzxbw_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Zero extend 8 packed 8-bit integers in the low 8 bytes of xmm2/m64 to 8 packed 16-bit integers in xmm1.

pub fn pmovzxdq_XMMRegister_Any64BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any64BitMemory
)

Zero extend 2 packed 32-bit integers in the low 8 bytes of xmm2/m64 to 2 packed 64-bit integers in xmm1.

pub fn pmovzxdq_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Zero extend 2 packed 32-bit integers in the low 8 bytes of xmm2/m64 to 2 packed 64-bit integers in xmm1.

pub fn pmovzxwd_XMMRegister_Any64BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any64BitMemory
)

Zero extend 4 packed 16-bit integers in the low 8 bytes of xmm2/m64 to 4 packed 32-bit integers in xmm1.

pub fn pmovzxwd_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Zero extend 4 packed 16-bit integers in the low 8 bytes of xmm2/m64 to 4 packed 32-bit integers in xmm1.

pub fn pmovzxwq_XMMRegister_Any32BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any32BitMemory
)

Zero extend 2 packed 16-bit integers in the low 4 bytes of xmm2/m32 to 2 packed 64-bit integers in xmm1.

pub fn pmovzxwq_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Zero extend 2 packed 16-bit integers in the low 4 bytes of xmm2/m32 to 2 packed 64-bit integers in xmm1.

pub fn pmuldq_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Multiply the packed signed dword integers in xmm1 and xmm2/m128 and store the quadword product in xmm1.

pub fn pmuldq_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Multiply the packed signed dword integers in xmm1 and xmm2/m128 and store the quadword product in xmm1.

pub fn pmulhrsw_MMRegister_Any64BitMemory(
    &mut self,
    arg0: MMRegister,
    arg1: Any64BitMemory
)

Multiply 16-bit signed words, scale and round signed doublewords, pack high 16 bits to mm1.

pub fn pmulhrsw_MMRegister_MMRegister(
    &mut self,
    arg0: MMRegister,
    arg1: MMRegister
)

Multiply 16-bit signed words, scale and round signed doublewords, pack high 16 bits to mm1.

pub fn pmulhrsw_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Multiply 16-bit signed words, scale and round signed doublewords, pack high 16 bits to xmm1.

pub fn pmulhrsw_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Multiply 16-bit signed words, scale and round signed doublewords, pack high 16 bits to xmm1.

pub fn pmulhuw_MMRegister_Any64BitMemory(
    &mut self,
    arg0: MMRegister,
    arg1: Any64BitMemory
)

Multiply the packed unsigned word integers in mm1 register and mm2/m64, and store the high 16 bits of the results in mm1.

pub fn pmulhuw_MMRegister_MMRegister(
    &mut self,
    arg0: MMRegister,
    arg1: MMRegister
)

Multiply the packed unsigned word integers in mm1 register and mm2/m64, and store the high 16 bits of the results in mm1.

pub fn pmulhuw_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Multiply the packed unsigned word integers in xmm1 and xmm2/m128, and store the high 16 bits of the results in xmm1.

pub fn pmulhuw_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Multiply the packed unsigned word integers in xmm1 and xmm2/m128, and store the high 16 bits of the results in xmm1.

pub fn pmulhw_MMRegister_Any64BitMemory(
    &mut self,
    arg0: MMRegister,
    arg1: Any64BitMemory
)

Multiply the packed signed word integers in mm1 register and mm2/m64, and store the high 16 bits of the results in mm1.

pub fn pmulhw_MMRegister_MMRegister(&mut self, arg0: MMRegister, arg1: MMRegister)

Multiply the packed signed word integers in mm1 register and mm2/m64, and store the high 16 bits of the results in mm1.

pub fn pmulhw_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Multiply the packed signed word integers in xmm1 and xmm2/m128, and store the high 16 bits of the results in xmm1.

pub fn pmulhw_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Multiply the packed signed word integers in xmm1 and xmm2/m128, and store the high 16 bits of the results in xmm1.

pub fn pmulld_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Multiply the packed dword signed integers in xmm1 and xmm2/m128 and store the low 32 bits of each product in xmm1.

pub fn pmulld_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Multiply the packed dword signed integers in xmm1 and xmm2/m128 and store the low 32 bits of each product in xmm1.

pub fn pmullw_MMRegister_Any64BitMemory(
    &mut self,
    arg0: MMRegister,
    arg1: Any64BitMemory
)

Multiply the packed signed word integers in mm1 register and mm2/m64, and store the low 16 bits of the results in mm1.

pub fn pmullw_MMRegister_MMRegister(&mut self, arg0: MMRegister, arg1: MMRegister)

Multiply the packed signed word integers in mm1 register and mm2/m64, and store the low 16 bits of the results in mm1.

pub fn pmullw_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Multiply the packed signed word integers in xmm1 and xmm2/m128, and store the low 16 bits of the results in xmm1.

pub fn pmullw_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Multiply the packed signed word integers in xmm1 and xmm2/m128, and store the low 16 bits of the results in xmm1.

pub fn pmuludq_MMRegister_Any64BitMemory(
    &mut self,
    arg0: MMRegister,
    arg1: Any64BitMemory
)

Multiply unsigned doubleword integer in mm1 by unsigned doubleword integer in mm2/m64, and store the quadword result in mm1.

pub fn pmuludq_MMRegister_MMRegister(
    &mut self,
    arg0: MMRegister,
    arg1: MMRegister
)

Multiply unsigned doubleword integer in mm1 by unsigned doubleword integer in mm2/m64, and store the quadword result in mm1.

pub fn pmuludq_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Multiply packed unsigned doubleword integers in xmm1 by packed unsigned doubleword integers in xmm2/m128, and store the quadword results in xmm1.

pub fn pmuludq_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Multiply packed unsigned doubleword integers in xmm1 by packed unsigned doubleword integers in xmm2/m128, and store the quadword results in xmm1.

pub fn pop_FS(&mut self)

Pop top of stack into FS and increment stack pointer by 64 bits.

pub fn pop_FS_Prefix66(&mut self)

Pop top of stack into FS and increment stack pointer by 16 bits.

pub fn pop_GS(&mut self)

Pop top of stack into GS and increment stack pointer by 64 bits.

pub fn pop_GS_Prefix66(&mut self)

Pop top of stack into GS and increment stack pointer by 16 bits.

pub fn pop_Any16BitMemory(&mut self, arg0: Any16BitMemory)

Pop top of stack into m16 and increment stack pointer.

pub fn pop_Any64BitMemory(&mut self, arg0: Any64BitMemory)

Pop top of stack into m64 and increment stack pointer.

Cannot encode 32-bit operand size.

pub fn pop_Register16Bit(&mut self, arg0: Register16Bit)

Pop top of stack into m16 and increment stack pointer.

pub fn pop_Register16Bit_1(&mut self, arg0: Register16Bit)

Pop top of stack into r16 and increment stack pointer.

pub fn pop_Register64Bit_m64(&mut self, arg0: Register64Bit)

Pop top of stack into m64 and increment stack pointer.

Cannot encode 32-bit operand size.

pub fn pop_Register64Bit_r64(&mut self, arg0: Register64Bit)

Pop top of stack into r64 and increment stack pointer.

Cannot encode 32-bit operand size.

pub fn popcnt_Register16Bit_Any16BitMemory(
    &mut self,
    arg0: Register16Bit,
    arg1: Any16BitMemory
)

POPCNT on r/m16.

pub fn popcnt_Register16Bit_Register16Bit(
    &mut self,
    arg0: Register16Bit,
    arg1: Register16Bit
)

POPCNT on r/m16.

pub fn popcnt_Register32Bit_Any32BitMemory(
    &mut self,
    arg0: Register32Bit,
    arg1: Any32BitMemory
)

POPCNT on r/m32.

pub fn popcnt_Register32Bit_Register32Bit(
    &mut self,
    arg0: Register32Bit,
    arg1: Register32Bit
)

POPCNT on r/m32.

pub fn popcnt_Register64Bit_Any64BitMemory(
    &mut self,
    arg0: Register64Bit,
    arg1: Any64BitMemory
)

POPCNT on r/m64.

pub fn popcnt_Register64Bit_Register64Bit(
    &mut self,
    arg0: Register64Bit,
    arg1: Register64Bit
)

POPCNT on r/m64.

pub fn popf(&mut self)

Pop top of stack into lower 16 bits of EFLAGS.

pub fn popfq(&mut self)

Pop top of stack and zero-extend into RFLAGS.

pub fn por_MMRegister_Any64BitMemory(
    &mut self,
    arg0: MMRegister,
    arg1: Any64BitMemory
)

Bitwise OR of mm/m64 and mm.

pub fn por_MMRegister_MMRegister(&mut self, arg0: MMRegister, arg1: MMRegister)

Bitwise OR of mm/m64 and mm.

pub fn por_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Bitwise OR of xmm2/m128 and xmm1.

pub fn por_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Bitwise OR of xmm2/m128 and xmm1.

pub fn prefetchnta_Any8BitMemory(&mut self, arg0: Any8BitMemory)

Move data from m8 closer to the processor using NTA hint.

pub fn prefetcht0_Any8BitMemory(&mut self, arg0: Any8BitMemory)

Move data from m8 closer to the processor using T0 hint.

pub fn prefetcht1_Any8BitMemory(&mut self, arg0: Any8BitMemory)

Move data from m8 closer to the processor using T1 hint.

pub fn prefetcht2_Any8BitMemory(&mut self, arg0: Any8BitMemory)

Move data from m8 closer to the processor using T2 hint.

pub fn prefetchw_Any8BitMemory(&mut self, arg0: Any8BitMemory)

Move data from m8 closer to the processor in anticipation of a write.

Introduced with AMD’s 3DNow! instructions.

pub fn psadbw_MMRegister_Any64BitMemory(
    &mut self,
    arg0: MMRegister,
    arg1: Any64BitMemory
)

Computes the absolute differences of the packed unsigned byte integers from mm2/m64 and mm1; differences are then summed to produce an unsigned word integer result.

pub fn psadbw_MMRegister_MMRegister(&mut self, arg0: MMRegister, arg1: MMRegister)

Computes the absolute differences of the packed unsigned byte integers from mm2/m64 and mm1; differences are then summed to produce an unsigned word integer result.

pub fn psadbw_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Computes the absolute differences of the packed unsigned byte integers from xmm2/m128 and xmm1; the 8 low differences and 8 high differences are then summed separately to produce two unsigned word integer results.

pub fn psadbw_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Computes the absolute differences of the packed unsigned byte integers from xmm2/m128 and xmm1; the 8 low differences and 8 high differences are then summed separately to produce two unsigned word integer results.

pub fn pshufb_MMRegister_Any64BitMemory(
    &mut self,
    arg0: MMRegister,
    arg1: Any64BitMemory
)

Shuffle bytes in mm1 according to contents of mm2/m64.

pub fn pshufb_MMRegister_MMRegister(&mut self, arg0: MMRegister, arg1: MMRegister)

Shuffle bytes in mm1 according to contents of mm2/m64.

pub fn pshufb_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Shuffle bytes in xmm1 according to contents of xmm2/m128.

pub fn pshufb_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Shuffle bytes in xmm1 according to contents of xmm2/m128.

pub fn pshufd_XMMRegister_Any128BitMemory_Immediate8Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory,
    arg2: Immediate8Bit
)

Shuffle the doublewords in xmm2/m128 based on the encoding in imm8 and store the result in xmm1.

pub fn pshufd_XMMRegister_XMMRegister_Immediate8Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Immediate8Bit
)

Shuffle the doublewords in xmm2/m128 based on the encoding in imm8 and store the result in xmm1.

pub fn pshufhw_XMMRegister_Any128BitMemory_Immediate8Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory,
    arg2: Immediate8Bit
)

Shuffle the high words in xmm2/m128 based on the encoding in imm8 and store the result in xmm1.

pub fn pshufhw_XMMRegister_XMMRegister_Immediate8Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Immediate8Bit
)

Shuffle the high words in xmm2/m128 based on the encoding in imm8 and store the result in xmm1.

pub fn pshuflw_XMMRegister_Any128BitMemory_Immediate8Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory,
    arg2: Immediate8Bit
)

Shuffle the low words in xmm2/m128 based on the encoding in imm8 and store the result in xmm1.

pub fn pshuflw_XMMRegister_XMMRegister_Immediate8Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Immediate8Bit
)

Shuffle the low words in xmm2/m128 based on the encoding in imm8 and store the result in xmm1.

pub fn pshufw_MMRegister_Any64BitMemory_Immediate8Bit(
    &mut self,
    arg0: MMRegister,
    arg1: Any64BitMemory,
    arg2: Immediate8Bit
)

Shuffle the words in mm2/m64 based on the encoding in imm8 and store the result in mm1.

pub fn pshufw_MMRegister_MMRegister_Immediate8Bit(
    &mut self,
    arg0: MMRegister,
    arg1: MMRegister,
    arg2: Immediate8Bit
)

Shuffle the words in mm2/m64 based on the encoding in imm8 and store the result in mm1.

pub fn psignb_MMRegister_Any64BitMemory(
    &mut self,
    arg0: MMRegister,
    arg1: Any64BitMemory
)

Negate/zero/preserve packed byte integers in mm1 depending on the corresponding sign in mm2/m64.

pub fn psignb_MMRegister_MMRegister(&mut self, arg0: MMRegister, arg1: MMRegister)

Negate/zero/preserve packed byte integers in mm1 depending on the corresponding sign in mm2/m64.

pub fn psignb_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Negate/zero/preserve packed byte integers in xmm1 depending on the corresponding sign in xmm2/m128.

pub fn psignb_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Negate/zero/preserve packed byte integers in xmm1 depending on the corresponding sign in xmm2/m128.

pub fn psignd_MMRegister_Any64BitMemory(
    &mut self,
    arg0: MMRegister,
    arg1: Any64BitMemory
)

Negate/zero/preserve packed doubleword integers in mm1 depending on the corresponding sign in mm2/m128.

pub fn psignd_MMRegister_MMRegister(&mut self, arg0: MMRegister, arg1: MMRegister)

Negate/zero/preserve packed doubleword integers in mm1 depending on the corresponding sign in mm2/m128.

pub fn psignd_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Negate/zero/preserve packed doubleword integers in xmm1 depending on the corresponding sign in xmm2/m128.

pub fn psignd_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Negate/zero/preserve packed doubleword integers in xmm1 depending on the corresponding sign in xmm2/m128.

pub fn psignw_MMRegister_Any64BitMemory(
    &mut self,
    arg0: MMRegister,
    arg1: Any64BitMemory
)

Negate/zero/preserve packed word integers in mm1 depending on the corresponding sign in mm2/m128.

pub fn psignw_MMRegister_MMRegister(&mut self, arg0: MMRegister, arg1: MMRegister)

Negate/zero/preserve packed word integers in mm1 depending on the corresponding sign in mm2/m128.

pub fn psignw_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Negate/zero/preserve packed word integers in xmm1 depending on the corresponding sign in xmm2/m128.

pub fn psignw_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Negate/zero/preserve packed word integers in xmm1 depending on the corresponding sign in xmm2/m128.

pub fn pslld_MMRegister_Immediate8Bit(
    &mut self,
    arg0: MMRegister,
    arg1: Immediate8Bit
)

Shift doublewords in mm left by imm8 while shifting in zero-signed.

pub fn pslld_MMRegister_Any64BitMemory(
    &mut self,
    arg0: MMRegister,
    arg1: Any64BitMemory
)

Shift doublewords in mm left by mm/m64 while shifting in zero-signed.

pub fn pslld_MMRegister_MMRegister(&mut self, arg0: MMRegister, arg1: MMRegister)

Shift doublewords in mm left by mm/m64 while shifting in zero-signed.

pub fn pslld_XMMRegister_Immediate8Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: Immediate8Bit
)

Shift doublewords in xmm1 left by imm8 while shifting in zero-signed.

pub fn pslld_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Shift doublewords in xmm1 left by xmm2/m128 while shifting in zero-signed.

pub fn pslld_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Shift doublewords in xmm1 left by xmm2/m128 while shifting in zero-signed.

pub fn pslldq_XMMRegister_Immediate8Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: Immediate8Bit
)

Shift xmm1 left by imm8 bytes while shifting in zero-signed.

pub fn psllq_MMRegister_Immediate8Bit(
    &mut self,
    arg0: MMRegister,
    arg1: Immediate8Bit
)

Shift quadword in mm left by imm8 while shifting in zero-signed.

pub fn psllq_MMRegister_Any64BitMemory(
    &mut self,
    arg0: MMRegister,
    arg1: Any64BitMemory
)

Shift quadword in mm left by mm/m64 while shifting in zero-signed.

pub fn psllq_MMRegister_MMRegister(&mut self, arg0: MMRegister, arg1: MMRegister)

Shift quadword in mm left by mm/m64 while shifting in zero-signed.

pub fn psllq_XMMRegister_Immediate8Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: Immediate8Bit
)

Shift quadwords in xmm1 left by imm8 while shifting in zero-signed.

pub fn psllq_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Shift quadwords in xmm1 left by xmm2/m128 while shifting in zero-signed.

pub fn psllq_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Shift quadwords in xmm1 left by xmm2/m128 while shifting in zero-signed.

pub fn psllw_MMRegister_Immediate8Bit(
    &mut self,
    arg0: MMRegister,
    arg1: Immediate8Bit
)

Shift words in mm left by imm8 while shifting in zero-signed.

pub fn psllw_MMRegister_Any64BitMemory(
    &mut self,
    arg0: MMRegister,
    arg1: Any64BitMemory
)

Shift words in mm left mm/m64 while shifting in zero-signed.

pub fn psllw_MMRegister_MMRegister(&mut self, arg0: MMRegister, arg1: MMRegister)

Shift words in mm left mm/m64 while shifting in zero-signed.

pub fn psllw_XMMRegister_Immediate8Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: Immediate8Bit
)

Shift words in xmm1 left by imm8 while shifting in zero-signed.

pub fn psllw_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Shift words in xmm1 left by xmm2/m128 while shifting in zero-signed.

pub fn psllw_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Shift words in xmm1 left by xmm2/m128 while shifting in zero-signed.

pub fn psrad_MMRegister_Immediate8Bit(
    &mut self,
    arg0: MMRegister,
    arg1: Immediate8Bit
)

Shift doublewords in mm right by imm8 while shifting in sign bits.

pub fn psrad_MMRegister_Any64BitMemory(
    &mut self,
    arg0: MMRegister,
    arg1: Any64BitMemory
)

Shift doublewords in mm right by mm/m64 while shifting in sign bits.

pub fn psrad_MMRegister_MMRegister(&mut self, arg0: MMRegister, arg1: MMRegister)

Shift doublewords in mm right by mm/m64 while shifting in sign bits.

pub fn psrad_XMMRegister_Immediate8Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: Immediate8Bit
)

Shift doublewords in xmm1 right by imm8 while shifting in sign bits.

pub fn psrad_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Shift doubleword in xmm1 right by xmm2/m128 while shifting in sign bits.

pub fn psrad_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Shift doubleword in xmm1 right by xmm2/m128 while shifting in sign bits.

pub fn psraw_MMRegister_Immediate8Bit(
    &mut self,
    arg0: MMRegister,
    arg1: Immediate8Bit
)

Shift words in mm right by imm8 while shifting in sign bits.

pub fn psraw_MMRegister_Any64BitMemory(
    &mut self,
    arg0: MMRegister,
    arg1: Any64BitMemory
)

Shift words in mm right by mm/m64 while shifting in sign bits.

pub fn psraw_MMRegister_MMRegister(&mut self, arg0: MMRegister, arg1: MMRegister)

Shift words in mm right by mm/m64 while shifting in sign bits.

pub fn psraw_XMMRegister_Immediate8Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: Immediate8Bit
)

Shift words in xmm1 right by imm8 while shifting in sign bits.

pub fn psraw_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Shift words in xmm1 right by xmm2/m128 while shifting in sign bits.

pub fn psraw_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Shift words in xmm1 right by xmm2/m128 while shifting in sign bits.

pub fn psrld_MMRegister_Immediate8Bit(
    &mut self,
    arg0: MMRegister,
    arg1: Immediate8Bit
)

Shift doublewords in mm right by imm8 while shifting in zero-signed.

pub fn psrld_MMRegister_Any64BitMemory(
    &mut self,
    arg0: MMRegister,
    arg1: Any64BitMemory
)

Shift doublewords in mm right by amount specified in mm/m64 while shifting in zero-signed.

pub fn psrld_MMRegister_MMRegister(&mut self, arg0: MMRegister, arg1: MMRegister)

Shift doublewords in mm right by amount specified in mm/m64 while shifting in zero-signed.

pub fn psrld_XMMRegister_Immediate8Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: Immediate8Bit
)

Shift doublewords in xmm1 right by imm8 while shifting in zero-signed.

pub fn psrld_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Shift doublewords in xmm1 right by amount specified in xmm2/m128 while shifting in zero-signed.

pub fn psrld_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Shift doublewords in xmm1 right by amount specified in xmm2/m128 while shifting in zero-signed.

pub fn psrldq_XMMRegister_Immediate8Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: Immediate8Bit
)

Shift xmm1 right by imm8 while shifting in zero-signed.

pub fn psrlq_MMRegister_Immediate8Bit(
    &mut self,
    arg0: MMRegister,
    arg1: Immediate8Bit
)

Shift mm right by imm8 while shifting in zero-signed.

pub fn psrlq_MMRegister_Any64BitMemory(
    &mut self,
    arg0: MMRegister,
    arg1: Any64BitMemory
)

Shift mm right by amount specified in mm/m64 while shifting in zero-signed.

pub fn psrlq_MMRegister_MMRegister(&mut self, arg0: MMRegister, arg1: MMRegister)

Shift mm right by amount specified in mm/m64 while shifting in zero-signed.

pub fn psrlq_XMMRegister_Immediate8Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: Immediate8Bit
)

Shift quadwords in xmm1 right by imm8 while shifting in zero-signed.

pub fn psrlq_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Shift quadwords in xmm1 right by amount specified in xmm2/m128 while shifting in zero-signed.

pub fn psrlq_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Shift quadwords in xmm1 right by amount specified in xmm2/m128 while shifting in zero-signed.

pub fn psrlw_MMRegister_Immediate8Bit(
    &mut self,
    arg0: MMRegister,
    arg1: Immediate8Bit
)

Shift words in mm right by imm8 while shifting in zero-signed.

pub fn psrlw_MMRegister_Any64BitMemory(
    &mut self,
    arg0: MMRegister,
    arg1: Any64BitMemory
)

Shift words in mm right by amount specified in mm/m64 while shifting in zero-signed.

pub fn psrlw_MMRegister_MMRegister(&mut self, arg0: MMRegister, arg1: MMRegister)

Shift words in mm right by amount specified in mm/m64 while shifting in zero-signed.

pub fn psrlw_XMMRegister_Immediate8Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: Immediate8Bit
)

Shift words in xmm1 right by imm8 while shifting in zero-signed.

pub fn psrlw_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Shift words in xmm1 right by amount specified in xmm2/m128 while shifting in zero-signed.

pub fn psrlw_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Shift words in xmm1 right by amount specified in xmm2/m128 while shifting in zero-signed.

pub fn psubb_MMRegister_Any64BitMemory(
    &mut self,
    arg0: MMRegister,
    arg1: Any64BitMemory
)

Subtract packed byte integers in mm/m64 from packed byte integers in mm.

pub fn psubb_MMRegister_MMRegister(&mut self, arg0: MMRegister, arg1: MMRegister)

Subtract packed byte integers in mm/m64 from packed byte integers in mm.

pub fn psubb_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Subtract packed byte integers in xmm2/m128 from packed byte integers in xmm1.

pub fn psubb_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Subtract packed byte integers in xmm2/m128 from packed byte integers in xmm1.

pub fn psubd_MMRegister_Any64BitMemory(
    &mut self,
    arg0: MMRegister,
    arg1: Any64BitMemory
)

Subtract packed doubleword integers in mm/m64 from packed doubleword integers in mm.

pub fn psubd_MMRegister_MMRegister(&mut self, arg0: MMRegister, arg1: MMRegister)

Subtract packed doubleword integers in mm/m64 from packed doubleword integers in mm.

pub fn psubd_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Subtract packed doubleword integers in xmm2/mem128 from packed doubleword integers in xmm1.

pub fn psubd_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Subtract packed doubleword integers in xmm2/mem128 from packed doubleword integers in xmm1.

pub fn psubq_MMRegister_Any64BitMemory(
    &mut self,
    arg0: MMRegister,
    arg1: Any64BitMemory
)

Subtract quadword integer in mm1 from mm2/m64.

pub fn psubq_MMRegister_MMRegister(&mut self, arg0: MMRegister, arg1: MMRegister)

Subtract quadword integer in mm1 from mm2/m64.

pub fn psubq_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Subtract packed quadword integers in xmm1 from xmm2/m128.

pub fn psubq_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Subtract packed quadword integers in xmm1 from xmm2/m128.

pub fn psubsb_MMRegister_Any64BitMemory(
    &mut self,
    arg0: MMRegister,
    arg1: Any64BitMemory
)

Subtract signed packed bytes in mm/m64 from signed packed bytes in mm and saturate results.

pub fn psubsb_MMRegister_MMRegister(&mut self, arg0: MMRegister, arg1: MMRegister)

Subtract signed packed bytes in mm/m64 from signed packed bytes in mm and saturate results.

pub fn psubsb_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Subtract packed signed byte integers in xmm2/m128 from packed signed byte integers in xmm1 and saturate results.

pub fn psubsb_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Subtract packed signed byte integers in xmm2/m128 from packed signed byte integers in xmm1 and saturate results.

pub fn psubsw_MMRegister_Any64BitMemory(
    &mut self,
    arg0: MMRegister,
    arg1: Any64BitMemory
)

Subtract signed packed words in mm/m64 from signed packed words in mm and saturate results.

pub fn psubsw_MMRegister_MMRegister(&mut self, arg0: MMRegister, arg1: MMRegister)

Subtract signed packed words in mm/m64 from signed packed words in mm and saturate results.

pub fn psubsw_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Subtract packed signed word integers in xmm2/m128 from packed signed word integers in xmm1 and saturate results.

pub fn psubsw_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Subtract packed signed word integers in xmm2/m128 from packed signed word integers in xmm1 and saturate results.

pub fn psubusb_MMRegister_Any64BitMemory(
    &mut self,
    arg0: MMRegister,
    arg1: Any64BitMemory
)

Subtract unsigned packed bytes in mm/m64 from unsigned packed bytes in mm and saturate result.

pub fn psubusb_MMRegister_MMRegister(
    &mut self,
    arg0: MMRegister,
    arg1: MMRegister
)

Subtract unsigned packed bytes in mm/m64 from unsigned packed bytes in mm and saturate result.

pub fn psubusb_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Subtract packed unsigned byte integers in xmm2/m128 from packed unsigned byte integers in xmm1 and saturate result.

pub fn psubusb_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Subtract packed unsigned byte integers in xmm2/m128 from packed unsigned byte integers in xmm1 and saturate result.

pub fn psubusw_MMRegister_Any64BitMemory(
    &mut self,
    arg0: MMRegister,
    arg1: Any64BitMemory
)

Subtract unsigned packed words in mm/m64 from unsigned packed words in mm and saturate result.

pub fn psubusw_MMRegister_MMRegister(
    &mut self,
    arg0: MMRegister,
    arg1: MMRegister
)

Subtract unsigned packed words in mm/m64 from unsigned packed words in mm and saturate result.

pub fn psubusw_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Subtract packed unsigned word integers in xmm2/m128 from packed unsigned word integers in xmm1 and saturate result.

pub fn psubusw_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Subtract packed unsigned word integers in xmm2/m128 from packed unsigned word integers in xmm1 and saturate result.

pub fn psubw_MMRegister_Any64BitMemory(
    &mut self,
    arg0: MMRegister,
    arg1: Any64BitMemory
)

Subtract packed word integers in mm/m64 from packed word integers in mm.

pub fn psubw_MMRegister_MMRegister(&mut self, arg0: MMRegister, arg1: MMRegister)

Subtract packed word integers in mm/m64 from packed word integers in mm.

pub fn psubw_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Subtract packed word integers in xmm2/m128 from packed word integers in xmm1.

pub fn psubw_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Subtract packed word integers in xmm2/m128 from packed word integers in xmm1.

pub fn ptest_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Set Zero Flag (ZF) if xmm2/m128 && xmm1 result is all zero-signed.

Set Carry Flag (CF) if xmm2/m128 AND NOT xmm1 result is all zero-signed.

pub fn ptest_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Set Zero Flag (ZF) if xmm2/m128 && xmm1 result is all zero-signed.

Set Carry Flag (CF) if xmm2/m128 AND NOT xmm1 result is all zero-signed.

pub fn punpckhbw_MMRegister_Any64BitMemory(
    &mut self,
    arg0: MMRegister,
    arg1: Any64BitMemory
)

Unpack and interleave high-order bytes from mm and mm/m64 into mm.

pub fn punpckhbw_MMRegister_MMRegister(
    &mut self,
    arg0: MMRegister,
    arg1: MMRegister
)

Unpack and interleave high-order bytes from mm and mm/m64 into mm.

pub fn punpckhbw_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Unpack and interleave high-order bytes from xmm1 and xmm2/m128 into xmm1.

pub fn punpckhbw_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Unpack and interleave high-order bytes from xmm1 and xmm2/m128 into xmm1.

pub fn punpckhdq_MMRegister_Any64BitMemory(
    &mut self,
    arg0: MMRegister,
    arg1: Any64BitMemory
)

Unpack and interleave high-order doublewords from mm and mm/m64 into mm.

pub fn punpckhdq_MMRegister_MMRegister(
    &mut self,
    arg0: MMRegister,
    arg1: MMRegister
)

Unpack and interleave high-order doublewords from mm and mm/m64 into mm.

pub fn punpckhdq_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Unpack and interleave high-order doublewords from xmm1 and xmm2/m128 into xmm1.

pub fn punpckhdq_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Unpack and interleave high-order doublewords from xmm1 and xmm2/m128 into xmm1.

pub fn punpckhqdq_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Unpack and interleave high-order quadwords from xmm1 and xmm2/m128 into xmm1.

pub fn punpckhqdq_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Unpack and interleave high-order quadwords from xmm1 and xmm2/m128 into xmm1.

pub fn punpckhwd_MMRegister_Any64BitMemory(
    &mut self,
    arg0: MMRegister,
    arg1: Any64BitMemory
)

Unpack and interleave high-order words from mm and mm/m64 into mm.

pub fn punpckhwd_MMRegister_MMRegister(
    &mut self,
    arg0: MMRegister,
    arg1: MMRegister
)

Unpack and interleave high-order words from mm and mm/m64 into mm.

pub fn punpckhwd_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Unpack and interleave high-order words from xmm1 and xmm2/m128 into xmm1.

pub fn punpckhwd_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Unpack and interleave high-order words from xmm1 and xmm2/m128 into xmm1.

pub fn punpcklbw_MMRegister_Any32BitMemory(
    &mut self,
    arg0: MMRegister,
    arg1: Any32BitMemory
)

Interleave low-order bytes from mm and mm/m32 into mm.

pub fn punpcklbw_MMRegister_MMRegister(
    &mut self,
    arg0: MMRegister,
    arg1: MMRegister
)

Interleave low-order bytes from mm and mm/m32 into mm.

pub fn punpcklbw_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Interleave low-order bytes from xmm1 and xmm2/m128 into xmm1.

pub fn punpcklbw_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Interleave low-order bytes from xmm1 and xmm2/m128 into xmm1.

pub fn punpckldq_MMRegister_Any32BitMemory(
    &mut self,
    arg0: MMRegister,
    arg1: Any32BitMemory
)

Interleave low-order doublewords from mm and mm/m32 into mm.

pub fn punpckldq_MMRegister_MMRegister(
    &mut self,
    arg0: MMRegister,
    arg1: MMRegister
)

Interleave low-order doublewords from mm and mm/m32 into mm.

pub fn punpckldq_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Interleave low-order doublewords from xmm1 and xmm2/m128 into xmm1.

pub fn punpckldq_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Interleave low-order doublewords from xmm1 and xmm2/m128 into xmm1.

pub fn punpcklqdq_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Interleave low-order quadword from xmm1 and xmm2/m128 into xmm1.

pub fn punpcklqdq_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Interleave low-order quadword from xmm1 and xmm2/m128 into xmm1.

pub fn punpcklwd_MMRegister_Any32BitMemory(
    &mut self,
    arg0: MMRegister,
    arg1: Any32BitMemory
)

Interleave low-order words from mm and mm/m32 into mm.

pub fn punpcklwd_MMRegister_MMRegister(
    &mut self,
    arg0: MMRegister,
    arg1: MMRegister
)

Interleave low-order words from mm and mm/m32 into mm.

pub fn punpcklwd_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Interleave low-order words from xmm1 and xmm2/m128 into xmm1.

pub fn punpcklwd_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Interleave low-order words from xmm1 and xmm2/m128 into xmm1.

pub fn push_FS(&mut self)

Push FS.

pub fn push_GS(&mut self)

Push GS.

pub fn push_Any16BitMemory(&mut self, arg0: Any16BitMemory)

Push r/m16.

pub fn push_Any64BitMemory(&mut self, arg0: Any64BitMemory)

Push r/m64.

pub fn push_Register16Bit(&mut self, arg0: Register16Bit)

Push r/m16.

pub fn push_Register16Bit_1(&mut self, arg0: Register16Bit)

Push r16.

pub fn push_Register64Bit_rm64(&mut self, arg0: Register64Bit)

Push r/m64.

pub fn push_Register64Bit_r64(&mut self, arg0: Register64Bit)

Push r64.

pub fn pushf(&mut self)

Push lower 16 bits of EFLAGS.

pub fn pushfq(&mut self)

Push RFLAGS.

pub fn pushq_Immediate16Bit(&mut self, arg0: Immediate16Bit)

Push imm16 (sign-extended to 64-bits).

pub fn pushq_Immediate32Bit(&mut self, arg0: Immediate32Bit)

Push imm32 (sign-extended to 64-bits).

pub fn pushq_Immediate8Bit(&mut self, arg0: Immediate8Bit)

Push imm8 (sign-extended to 64-bits).

pub fn pushw_Immediate16Bit(&mut self, arg0: Immediate16Bit)

Push imm16 (sign-extended to 16-bits).

pub fn pushw_Immediate8Bit(&mut self, arg0: Immediate8Bit)

Push imm8 (sign-extended to 16-bits).

pub fn pxor_MMRegister_Any64BitMemory(
    &mut self,
    arg0: MMRegister,
    arg1: Any64BitMemory
)

Bitwise XOR of mm/m64 and mm.

pub fn pxor_MMRegister_MMRegister(&mut self, arg0: MMRegister, arg1: MMRegister)

Bitwise XOR of mm/m64 and mm.

pub fn pxor_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Bitwise XOR of xmm2/m128 and xmm1.

pub fn pxor_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Bitwise XOR of xmm2/m128 and xmm1.

pub fn rcl_Any16BitMemory_CL(&mut self, arg0: Any16BitMemory)

Rotate 17 bits (Carry Flag (CF), r/m16) left CL times.

pub fn rcl_Any16BitMemory_Immediate8Bit(
    &mut self,
    arg0: Any16BitMemory,
    arg1: Immediate8Bit
)

Rotate 17 bits (Carry Flag (CF), r/m16) left imm8 times.

pub fn rcl_Any16BitMemory_One(&mut self, arg0: Any16BitMemory)

Rotate 17 bits (Carry Flag (CF), r/m16) left once.

pub fn rcl_Any32BitMemory_CL(&mut self, arg0: Any32BitMemory)

Rotate 33 bits (Carry Flag (CF), r/m32) left CL times.

pub fn rcl_Any32BitMemory_Immediate8Bit(
    &mut self,
    arg0: Any32BitMemory,
    arg1: Immediate8Bit
)

Rotate 33 bits (Carry Flag (CF), r/m32) left imm8 times.

pub fn rcl_Any32BitMemory_One(&mut self, arg0: Any32BitMemory)

Rotate 33 bits (Carry Flag (CF), r/m32) left once.

pub fn rcl_Any64BitMemory_CL(&mut self, arg0: Any64BitMemory)

Rotate 65 bits (Carry Flag (CF), r/m64) left CL times.

Uses a 6 bit count.

pub fn rcl_Any64BitMemory_Immediate8Bit(
    &mut self,
    arg0: Any64BitMemory,
    arg1: Immediate8Bit
)

Rotate 65 bits (Carry Flag (CF), r/m64) left imm8 times.

Uses a 6 bit count.

pub fn rcl_Any64BitMemory_One(&mut self, arg0: Any64BitMemory)

Rotate 65 bits (Carry Flag (CF), r/m64) left once.

Uses a 6 bit count.

pub fn rcl_Any8BitMemory_CL(&mut self, arg0: Any8BitMemory)

Rotate 9 bits (Carry Flag (CF), r/m8) left CL times.

pub fn rcl_Any8BitMemory_Immediate8Bit(
    &mut self,
    arg0: Any8BitMemory,
    arg1: Immediate8Bit
)

Rotate 9 bits (Carry Flag (CF), r/m8) left imm8 times.

pub fn rcl_Any8BitMemory_One(&mut self, arg0: Any8BitMemory)

Rotate 9 bits (Carry Flag (CF), r/m8) left once.

pub fn rcl_Register16Bit_CL(&mut self, arg0: Register16Bit)

Rotate 17 bits (Carry Flag (CF), r/m16) left CL times.

pub fn rcl_Register16Bit_Immediate8Bit(
    &mut self,
    arg0: Register16Bit,
    arg1: Immediate8Bit
)

Rotate 17 bits (Carry Flag (CF), r/m16) left imm8 times.

pub fn rcl_Register16Bit_One(&mut self, arg0: Register16Bit)

Rotate 17 bits (Carry Flag (CF), r/m16) left once.

pub fn rcl_Register32Bit_CL(&mut self, arg0: Register32Bit)

Rotate 33 bits (Carry Flag (CF), r/m32) left CL times.

pub fn rcl_Register32Bit_Immediate8Bit(
    &mut self,
    arg0: Register32Bit,
    arg1: Immediate8Bit
)

Rotate 33 bits (Carry Flag (CF), r/m32) left imm8 times.

pub fn rcl_Register32Bit_One(&mut self, arg0: Register32Bit)

Rotate 33 bits (Carry Flag (CF), r/m32) left once.

pub fn rcl_Register64Bit_CL(&mut self, arg0: Register64Bit)

Rotate 65 bits (Carry Flag (CF), r/m64) left CL times.

Uses a 6 bit count.

pub fn rcl_Register64Bit_Immediate8Bit(
    &mut self,
    arg0: Register64Bit,
    arg1: Immediate8Bit
)

Rotate 65 bits (Carry Flag (CF), r/m64) left imm8 times.

Uses a 6 bit count.

pub fn rcl_Register64Bit_One(&mut self, arg0: Register64Bit)

Rotate 65 bits (Carry Flag (CF), r/m64) left once.

Uses a 6 bit count.

pub fn rcl_Register8Bit_CL(&mut self, arg0: Register8Bit)

Rotate 9 bits (Carry Flag (CF), r/m8) left CL times.

pub fn rcl_Register8Bit_Immediate8Bit(
    &mut self,
    arg0: Register8Bit,
    arg1: Immediate8Bit
)

Rotate 9 bits (Carry Flag (CF), r/m8) left imm8 times.

pub fn rcl_Register8Bit_One(&mut self, arg0: Register8Bit)

Rotate 9 bits (Carry Flag (CF), r/m8) left once.

pub fn rcl_RegisterHigh8BitsOf16Bits_CL(
    &mut self,
    arg0: RegisterHigh8BitsOf16Bits
)

Rotate 9 bits (Carry Flag (CF), r/m8) left CL times.

pub fn rcl_RegisterHigh8BitsOf16Bits_Immediate8Bit(
    &mut self,
    arg0: RegisterHigh8BitsOf16Bits,
    arg1: Immediate8Bit
)

Rotate 9 bits (Carry Flag (CF), r/m8) left imm8 times.

pub fn rcl_RegisterHigh8BitsOf16Bits_One(
    &mut self,
    arg0: RegisterHigh8BitsOf16Bits
)

Rotate 9 bits (Carry Flag (CF), r/m8) left once.

pub fn rcpps_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Computes the approximate reciprocals of the packed single-precision floating-point values in xmm2/m128 and stores the results in xmm1.

pub fn rcpps_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Computes the approximate reciprocals of the packed single-precision floating-point values in xmm2/m128 and stores the results in xmm1.

pub fn rcpss_XMMRegister_Any32BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any32BitMemory
)

Computes the approximate reciprocal of the scalar single-precision floating-point value in xmm2/m32 and stores the result in xmm1.

pub fn rcpss_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Computes the approximate reciprocal of the scalar single-precision floating-point value in xmm2/m32 and stores the result in xmm1.

pub fn rcr_Any16BitMemory_CL(&mut self, arg0: Any16BitMemory)

Rotate 17 bits (Carry Flag (CF), r/m16) right CL times.

pub fn rcr_Any16BitMemory_Immediate8Bit(
    &mut self,
    arg0: Any16BitMemory,
    arg1: Immediate8Bit
)

Rotate 17 bits (Carry Flag (CF), r/m16) right imm8 times.

pub fn rcr_Any16BitMemory_One(&mut self, arg0: Any16BitMemory)

Rotate 17 bits (Carry Flag (CF), r/m16) right once.

pub fn rcr_Any32BitMemory_CL(&mut self, arg0: Any32BitMemory)

Rotate 33 bits (Carry Flag (CF), r/m32) right CL times.

pub fn rcr_Any32BitMemory_Immediate8Bit(
    &mut self,
    arg0: Any32BitMemory,
    arg1: Immediate8Bit
)

Rotate 33 bits (Carry Flag (CF), r/m32) right imm8 times.

pub fn rcr_Any32BitMemory_One(&mut self, arg0: Any32BitMemory)

Rotate 33 bits (Carry Flag (CF), r/m32) right once.

Uses a 6 bit count.

pub fn rcr_Any64BitMemory_CL(&mut self, arg0: Any64BitMemory)

Rotate 65 bits (Carry Flag (CF), r/m64) right CL times.

Uses a 6 bit count.

pub fn rcr_Any64BitMemory_Immediate8Bit(
    &mut self,
    arg0: Any64BitMemory,
    arg1: Immediate8Bit
)

Rotate 65 bits (Carry Flag (CF), r/m64) right imm8 times.

Uses a 6 bit count.

pub fn rcr_Any64BitMemory_One(&mut self, arg0: Any64BitMemory)

Rotate 65 bits (Carry Flag (CF), r/m64) right once.

Uses a 6 bit count.

pub fn rcr_Any8BitMemory_CL(&mut self, arg0: Any8BitMemory)

Rotate 9 bits (Carry Flag (CF), r/m8) right CL times.

pub fn rcr_Any8BitMemory_Immediate8Bit(
    &mut self,
    arg0: Any8BitMemory,
    arg1: Immediate8Bit
)

Rotate 9 bits (Carry Flag (CF), r/m8) right imm8 times.

pub fn rcr_Any8BitMemory_One(&mut self, arg0: Any8BitMemory)

Rotate 9 bits (Carry Flag (CF), r/m8) right once.

pub fn rcr_Register16Bit_CL(&mut self, arg0: Register16Bit)

Rotate 17 bits (Carry Flag (CF), r/m16) right CL times.

pub fn rcr_Register16Bit_Immediate8Bit(
    &mut self,
    arg0: Register16Bit,
    arg1: Immediate8Bit
)

Rotate 17 bits (Carry Flag (CF), r/m16) right imm8 times.

pub fn rcr_Register16Bit_One(&mut self, arg0: Register16Bit)

Rotate 17 bits (Carry Flag (CF), r/m16) right once.

pub fn rcr_Register32Bit_CL(&mut self, arg0: Register32Bit)

Rotate 33 bits (Carry Flag (CF), r/m32) right CL times.

pub fn rcr_Register32Bit_Immediate8Bit(
    &mut self,
    arg0: Register32Bit,
    arg1: Immediate8Bit
)

Rotate 33 bits (Carry Flag (CF), r/m32) right imm8 times.

pub fn rcr_Register32Bit_One(&mut self, arg0: Register32Bit)

Rotate 33 bits (Carry Flag (CF), r/m32) right once.

Uses a 6 bit count.

pub fn rcr_Register64Bit_CL(&mut self, arg0: Register64Bit)

Rotate 65 bits (Carry Flag (CF), r/m64) right CL times.

Uses a 6 bit count.

pub fn rcr_Register64Bit_Immediate8Bit(
    &mut self,
    arg0: Register64Bit,
    arg1: Immediate8Bit
)

Rotate 65 bits (Carry Flag (CF), r/m64) right imm8 times.

Uses a 6 bit count.

pub fn rcr_Register64Bit_One(&mut self, arg0: Register64Bit)

Rotate 65 bits (Carry Flag (CF), r/m64) right once.

Uses a 6 bit count.

pub fn rcr_Register8Bit_CL(&mut self, arg0: Register8Bit)

Rotate 9 bits (Carry Flag (CF), r/m8) right CL times.

pub fn rcr_Register8Bit_Immediate8Bit(
    &mut self,
    arg0: Register8Bit,
    arg1: Immediate8Bit
)

Rotate 9 bits (Carry Flag (CF), r/m8) right imm8 times.

pub fn rcr_Register8Bit_One(&mut self, arg0: Register8Bit)

Rotate 9 bits (Carry Flag (CF), r/m8) right once.

pub fn rcr_RegisterHigh8BitsOf16Bits_CL(
    &mut self,
    arg0: RegisterHigh8BitsOf16Bits
)

Rotate 9 bits (Carry Flag (CF), r/m8) right CL times.

pub fn rcr_RegisterHigh8BitsOf16Bits_Immediate8Bit(
    &mut self,
    arg0: RegisterHigh8BitsOf16Bits,
    arg1: Immediate8Bit
)

Rotate 9 bits (Carry Flag (CF), r/m8) right imm8 times.

pub fn rcr_RegisterHigh8BitsOf16Bits_One(
    &mut self,
    arg0: RegisterHigh8BitsOf16Bits
)

Rotate 9 bits (Carry Flag (CF), r/m8) right once.

pub fn rdfsbase_Register32Bit(&mut self, arg0: Register32Bit)

Load the 32-bit destination register with the FS base address.

pub fn rdfsbase_Register64Bit(&mut self, arg0: Register64Bit)

Load the 64-bit destination register with the FS base address.

pub fn rdgsbase_Register32Bit(&mut self, arg0: Register32Bit)

Load the 32-bit destination register with the GS base address.

pub fn rdgsbase_Register64Bit(&mut self, arg0: Register64Bit)

Load the 64-bit destination register with the GS base address.

pub fn rdrand_Register16Bit(&mut self, arg0: Register16Bit)

Read a 16-bit random number and store in the destination register.

pub fn rdrand_Register32Bit(&mut self, arg0: Register32Bit)

Read a 32-bit random number and store in the destination register.

pub fn rdrand_Register64Bit(&mut self, arg0: Register64Bit)

Read a 64-bit random number and store in the destination register.

pub fn rep_ins_Any16BitMemory_DX(
    &mut self,
    arg0: Option<SegmentRegister>,
    address_override_for_32_bit: bool
)

Input (E)CX words from port DX into ES:[(E)DI].

pub fn rep_ins_Any32BitMemory_DX(
    &mut self,
    arg0: Option<SegmentRegister>,
    address_override_for_32_bit: bool
)

Input (E)CX doublewords from port DX into ES:[(E)DI].

pub fn rep_ins_Any64BitMemory_DX(
    &mut self,
    arg0: Option<SegmentRegister>,
    address_override_for_32_bit: bool
)

Input RCX default size from port DX into [RDI].

pub fn rep_ins_Any8BitMemory_DX(
    &mut self,
    arg0: Option<SegmentRegister>,
    address_override_for_32_bit: bool
)

Input (E)CX bytes from port DX into ES:[(E)DI].

pub fn rep_ins_Any8BitMemory_DX_1(
    &mut self,
    arg0: Option<SegmentRegister>,
    address_override_for_32_bit: bool
)

Input RCX bytes from port DX into [RDI].

pub fn rep_lods_AL(&mut self)

Load (E)CX bytes from DS:[(E)SI] to AL.

pub fn rep_lods_AL_1(&mut self)

Load RCX bytes from [RSI] to AL.

pub fn rep_lods_AX(&mut self)

Load (E)CX words from DS:[(E)SI] to AX.

pub fn rep_lods_EAX(&mut self)

Load (E)CX doublewords from DS:[(E)SI] to EAX.

pub fn rep_lods_RAX(&mut self)

Load RCX quadwords from [RSI] to RAX.

pub fn rep_movs_Any16BitMemory_Any16BitMemory(
    &mut self,
    arg0: Option<SegmentRegister>,
    address_override_for_32_bit: bool
)

Move (E)CX words from DS:[(E)SI] to ES:[(E)DI].

pub fn rep_movs_Any32BitMemory_Any32BitMemory(
    &mut self,
    arg0: Option<SegmentRegister>,
    address_override_for_32_bit: bool
)

Move (E)CX doublewords from DS:[(E)SI] to ES:[(E)DI].

pub fn rep_movs_Any64BitMemory_Any64BitMemory(
    &mut self,
    arg0: Option<SegmentRegister>,
    address_override_for_32_bit: bool
)

Move RCX quadwords from [RSI] to [RDI].

pub fn rep_movs_Any8BitMemory_Any8BitMemory(
    &mut self,
    arg0: Option<SegmentRegister>,
    address_override_for_32_bit: bool
)

Move (E)CX bytes from DS:[(E)SI] to ES:[(E)DI].

pub fn rep_movs_Any8BitMemory_Any8BitMemory_1(
    &mut self,
    arg0: Option<SegmentRegister>,
    address_override_for_32_bit: bool
)

Move RCX bytes from [RSI] to [RDI].

pub fn rep_outs_DX_Any16BitMemory(
    &mut self,
    arg0: Option<SegmentRegister>,
    address_override_for_32_bit: bool
)

Output (E)CX words from DS:[(E)SI] to port DX.

pub fn rep_outs_DX_Any32BitMemory(
    &mut self,
    arg0: Option<SegmentRegister>,
    address_override_for_32_bit: bool
)

Output (E)CX doublewords from DS:[(E)SI] to port DX.

pub fn rep_outs_DX_Any64BitMemory(
    &mut self,
    arg0: Option<SegmentRegister>,
    address_override_for_32_bit: bool
)

Output RCX default size from [RSI] to port DX.

pub fn rep_outs_DX_Any8BitMemory(
    &mut self,
    arg0: Option<SegmentRegister>,
    address_override_for_32_bit: bool
)

Output (E)CX bytes from DS:[(E)SI] to port DX.

pub fn rep_outs_DX_Any8BitMemory_1(
    &mut self,
    arg0: Option<SegmentRegister>,
    address_override_for_32_bit: bool
)

Output RCX bytes from [RSI] to port DX.

pub fn rep_stos_Any16BitMemory(
    &mut self,
    arg0: Option<SegmentRegister>,
    address_override_for_32_bit: bool
)

Fill (E)CX words at ES:[(E)DI] with AX.

pub fn rep_stos_Any32BitMemory(
    &mut self,
    arg0: Option<SegmentRegister>,
    address_override_for_32_bit: bool
)

Fill (E)CX doublewords at ES:[(E)DI] with EAX.

pub fn rep_stos_Any64BitMemory(
    &mut self,
    arg0: Option<SegmentRegister>,
    address_override_for_32_bit: bool
)

Fill RCX quadwords at [RDI] with RAX.

pub fn rep_stos_Any8BitMemory(
    &mut self,
    arg0: Option<SegmentRegister>,
    address_override_for_32_bit: bool
)

Fill (E)CX bytes at ES:[(E)DI] with AL.

pub fn rep_stos_Any8BitMemory_1(
    &mut self,
    arg0: Option<SegmentRegister>,
    address_override_for_32_bit: bool
)

Fill RCX bytes at [RDI] with AL.

pub fn repe_cmps_Any16BitMemory_Any16BitMemory(
    &mut self,
    arg0: Option<SegmentRegister>,
    address_override_for_32_bit: bool
)

Find nonmatching words in ES:[(E)DI] and DS:[(E)SI].

pub fn repe_cmps_Any32BitMemory_Any32BitMemory(
    &mut self,
    arg0: Option<SegmentRegister>,
    address_override_for_32_bit: bool
)

Find nonmatching doublewords in ES:[(E)DI] and DS:[(E)SI].

pub fn repe_cmps_Any64BitMemory_Any64BitMemory(
    &mut self,
    arg0: Option<SegmentRegister>,
    address_override_for_32_bit: bool
)

Find non-matching quadwords in [RDI] and [RSI].

pub fn repe_cmps_Any8BitMemory_Any8BitMemory(
    &mut self,
    arg0: Option<SegmentRegister>,
    address_override_for_32_bit: bool
)

Find nonmatching bytes in ES:[(E)DI] and DS:[(E)SI].

pub fn repe_cmps_Any8BitMemory_Any8BitMemory_1(
    &mut self,
    arg0: Option<SegmentRegister>,
    address_override_for_32_bit: bool
)

Find non-matching bytes in [RDI] and [RSI].

pub fn repe_scas_Any16BitMemory(
    &mut self,
    arg0: Option<SegmentRegister>,
    address_override_for_32_bit: bool
)

Find non-AX word starting at ES:[(E)DI].

pub fn repe_scas_Any32BitMemory(
    &mut self,
    arg0: Option<SegmentRegister>,
    address_override_for_32_bit: bool
)

Find non-EAX doubleword starting at ES:[(E)DI].

pub fn repe_scas_Any64BitMemory(
    &mut self,
    arg0: Option<SegmentRegister>,
    address_override_for_32_bit: bool
)

Find non-RAX quadword starting at [RDI].

pub fn repe_scas_Any8BitMemory(
    &mut self,
    arg0: Option<SegmentRegister>,
    address_override_for_32_bit: bool
)

Find non-AL byte starting at ES:[(E)DI].

pub fn repe_scas_Any8BitMemory_1(
    &mut self,
    arg0: Option<SegmentRegister>,
    address_override_for_32_bit: bool
)

Find non-AL byte starting at [RDI].

pub fn repne_cmps_Any16BitMemory_Any16BitMemory(
    &mut self,
    arg0: Option<SegmentRegister>,
    address_override_for_32_bit: bool
)

Find matching words in ES:[(E)DI] and DS:[(E)SI].

pub fn repne_cmps_Any32BitMemory_Any32BitMemory(
    &mut self,
    arg0: Option<SegmentRegister>,
    address_override_for_32_bit: bool
)

Find matching doublewords in ES:[(E)DI] and DS:[(E)SI].

pub fn repne_cmps_Any64BitMemory_Any64BitMemory(
    &mut self,
    arg0: Option<SegmentRegister>,
    address_override_for_32_bit: bool
)

Find matching doublewords in [RDI] and [RSI].

pub fn repne_scas_Any8BitMemory_Any8BitMemory(
    &mut self,
    arg0: Option<SegmentRegister>,
    address_override_for_32_bit: bool
)

Find matching bytes in ES:[(E)DI] and DS:[(E)SI].

pub fn repne_cmps_Any8BitMemory_Any8BitMemory_1(
    &mut self,
    arg0: Option<SegmentRegister>,
    address_override_for_32_bit: bool
)

Find matching bytes in [RDI] and [RSI].

pub fn repne_scas_Any16BitMemory(
    &mut self,
    arg0: Option<SegmentRegister>,
    address_override_for_32_bit: bool
)

Find AX, starting at ES:[(E)DI].

pub fn repne_scas_Any32BitMemory(
    &mut self,
    arg0: Option<SegmentRegister>,
    address_override_for_32_bit: bool
)

Find EAX, starting at ES:[(E)DI].

pub fn repne_scas_Any64BitMemory(
    &mut self,
    arg0: Option<SegmentRegister>,
    address_override_for_32_bit: bool
)

Find RAX, starting at [RDI].

pub fn repne_scas_Any8BitMemory(
    &mut self,
    arg0: Option<SegmentRegister>,
    address_override_for_32_bit: bool
)

Find AL, starting at ES:[(E)DI].

pub fn repne_scas_Any8BitMemory_1(
    &mut self,
    arg0: Option<SegmentRegister>,
    address_override_for_32_bit: bool
)

Find AL, starting at [RDI].

pub fn ret(&mut self)

Near return to calling procedure.

pub fn ret_Far(&mut self)

Far return to calling procedure.

pub fn ret_Immediate16Bit(&mut self, arg0: Immediate16Bit)

Near return to calling procedure and pop imm16 bytes from stack.

pub fn ret_Immediate16Bit_Far(&mut self, arg0: Immediate16Bit)

Far return to calling procedure and pop imm16 bytes from stack.

pub fn rol_Any16BitMemory_CL(&mut self, arg0: Any16BitMemory)

Rotate 16 bits r/m16 left CL times.

pub fn rol_Any16BitMemory_Immediate8Bit(
    &mut self,
    arg0: Any16BitMemory,
    arg1: Immediate8Bit
)

Rotate 16 bits r/m16 left imm8 times.

pub fn rol_Any16BitMemory_One(&mut self, arg0: Any16BitMemory)

Rotate 16 bits r/m16 left once.

pub fn rol_Any32BitMemory_CL(&mut self, arg0: Any32BitMemory)

Rotate 32 bits r/m32 left CL times.

pub fn rol_Any32BitMemory_Immediate8Bit(
    &mut self,
    arg0: Any32BitMemory,
    arg1: Immediate8Bit
)

Rotate 32 bits r/m32 left imm8 times.

pub fn rol_Any32BitMemory_One(&mut self, arg0: Any32BitMemory)

Rotate 32 bits r/m32 left once.

pub fn rol_Any64BitMemory_CL(&mut self, arg0: Any64BitMemory)

Rotate 64 bits r/m64 left CL times.

Uses a 6 bit count.

pub fn rol_Any64BitMemory_Immediate8Bit(
    &mut self,
    arg0: Any64BitMemory,
    arg1: Immediate8Bit
)

Rotate 64 bits r/m64 left imm8 times.

Uses a 6 bit count.

pub fn rol_Any64BitMemory_One(&mut self, arg0: Any64BitMemory)

Rotate 64 bits r/m64 left once.

Uses a 6 bit count.

pub fn rol_Any8BitMemory_CL(&mut self, arg0: Any8BitMemory)

Rotate 8 bits r/m8 left CL times.

pub fn rol_Any8BitMemory_Immediate8Bit(
    &mut self,
    arg0: Any8BitMemory,
    arg1: Immediate8Bit
)

Rotate 8 bits r/m8 left imm8 times.

pub fn rol_Any8BitMemory_One(&mut self, arg0: Any8BitMemory)

Rotate 8 bits r/m8 left once.

pub fn rol_Register16Bit_CL(&mut self, arg0: Register16Bit)

Rotate 16 bits r/m16 left CL times.

pub fn rol_Register16Bit_Immediate8Bit(
    &mut self,
    arg0: Register16Bit,
    arg1: Immediate8Bit
)

Rotate 16 bits r/m16 left imm8 times.

pub fn rol_Register16Bit_One(&mut self, arg0: Register16Bit)

Rotate 16 bits r/m16 left once.

pub fn rol_Register32Bit_CL(&mut self, arg0: Register32Bit)

Rotate 32 bits r/m32 left CL times.

pub fn rol_Register32Bit_Immediate8Bit(
    &mut self,
    arg0: Register32Bit,
    arg1: Immediate8Bit
)

Rotate 32 bits r/m32 left imm8 times.

pub fn rol_Register32Bit_One(&mut self, arg0: Register32Bit)

Rotate 32 bits r/m32 left once.

pub fn rol_Register64Bit_CL(&mut self, arg0: Register64Bit)

Rotate 64 bits r/m64 left CL times.

Uses a 6 bit count.

pub fn rol_Register64Bit_Immediate8Bit(
    &mut self,
    arg0: Register64Bit,
    arg1: Immediate8Bit
)

Rotate 64 bits r/m64 left imm8 times.

Uses a 6 bit count.

pub fn rol_Register64Bit_One(&mut self, arg0: Register64Bit)

Rotate 64 bits r/m64 left once.

Uses a 6 bit count.

pub fn rol_Register8Bit_CL(&mut self, arg0: Register8Bit)

Rotate 8 bits r/m8 left CL times.

pub fn rol_Register8Bit_Immediate8Bit(
    &mut self,
    arg0: Register8Bit,
    arg1: Immediate8Bit
)

Rotate 8 bits r/m8 left imm8 times.

pub fn rol_Register8Bit_One(&mut self, arg0: Register8Bit)

Rotate 8 bits r/m8 left once.

pub fn rol_RegisterHigh8BitsOf16Bits_CL(
    &mut self,
    arg0: RegisterHigh8BitsOf16Bits
)

Rotate 8 bits r/m8 left CL times.

pub fn rol_RegisterHigh8BitsOf16Bits_Immediate8Bit(
    &mut self,
    arg0: RegisterHigh8BitsOf16Bits,
    arg1: Immediate8Bit
)

Rotate 8 bits r/m8 left imm8 times.

pub fn rol_RegisterHigh8BitsOf16Bits_One(
    &mut self,
    arg0: RegisterHigh8BitsOf16Bits
)

Rotate 8 bits r/m8 left once.

pub fn ror_Any16BitMemory_CL(&mut self, arg0: Any16BitMemory)

Rotate 16 bits r/m16 right CL times.

pub fn ror_Any16BitMemory_Immediate8Bit(
    &mut self,
    arg0: Any16BitMemory,
    arg1: Immediate8Bit
)

Rotate 16 bits r/m16 right imm8 times.

pub fn ror_Any16BitMemory_One(&mut self, arg0: Any16BitMemory)

Rotate 16 bits r/m16 right once.

pub fn ror_Any32BitMemory_CL(&mut self, arg0: Any32BitMemory)

Rotate 32 bits r/m32 right CL times.

pub fn ror_Any32BitMemory_Immediate8Bit(
    &mut self,
    arg0: Any32BitMemory,
    arg1: Immediate8Bit
)

Rotate 32 bits r/m32 right imm8 times.

pub fn ror_Any32BitMemory_One(&mut self, arg0: Any32BitMemory)

Rotate 32 bits r/m32 right once.

pub fn ror_Any64BitMemory_CL(&mut self, arg0: Any64BitMemory)

Rotate 64 bits r/m64 right CL times.

Uses a 6 bit count.

pub fn ror_Any64BitMemory_Immediate8Bit(
    &mut self,
    arg0: Any64BitMemory,
    arg1: Immediate8Bit
)

Rotate 64 bits r/m64 right imm8 times.

Uses a 6 bit count.

pub fn ror_Any64BitMemory_One(&mut self, arg0: Any64BitMemory)

Rotate 64 bits r/m64 right once.

Uses a 6 bit count.

pub fn ror_Any8BitMemory_CL(&mut self, arg0: Any8BitMemory)

Rotate 8 bits r/m8 right CL times.

pub fn ror_Any8BitMemory_Immediate8Bit(
    &mut self,
    arg0: Any8BitMemory,
    arg1: Immediate8Bit
)

Rotate 8 bits r/m16 right imm8 times.

pub fn ror_Any8BitMemory_One(&mut self, arg0: Any8BitMemory)

Rotate 8 bits r/m8 right once.

pub fn ror_Register16Bit_CL(&mut self, arg0: Register16Bit)

Rotate 16 bits r/m16 right CL times.

pub fn ror_Register16Bit_Immediate8Bit(
    &mut self,
    arg0: Register16Bit,
    arg1: Immediate8Bit
)

Rotate 16 bits r/m16 right imm8 times.

pub fn ror_Register16Bit_One(&mut self, arg0: Register16Bit)

Rotate 16 bits r/m16 right once.

pub fn ror_Register32Bit_CL(&mut self, arg0: Register32Bit)

Rotate 32 bits r/m32 right CL times.

pub fn ror_Register32Bit_Immediate8Bit(
    &mut self,
    arg0: Register32Bit,
    arg1: Immediate8Bit
)

Rotate 32 bits r/m32 right imm8 times.

pub fn ror_Register32Bit_One(&mut self, arg0: Register32Bit)

Rotate 32 bits r/m32 right once.

pub fn ror_Register64Bit_CL(&mut self, arg0: Register64Bit)

Rotate 64 bits r/m64 right CL times.

Uses a 6 bit count.

pub fn ror_Register64Bit_Immediate8Bit(
    &mut self,
    arg0: Register64Bit,
    arg1: Immediate8Bit
)

Rotate 64 bits r/m64 right imm8 times.

Uses a 6 bit count.

pub fn ror_Register64Bit_One(&mut self, arg0: Register64Bit)

Rotate 64 bits r/m64 right once.

Uses a 6 bit count.

pub fn ror_Register8Bit_CL(&mut self, arg0: Register8Bit)

Rotate 8 bits r/m8 right CL times.

pub fn ror_Register8Bit_Immediate8Bit(
    &mut self,
    arg0: Register8Bit,
    arg1: Immediate8Bit
)

Rotate 8 bits r/m16 right imm8 times.

pub fn ror_Register8Bit_One(&mut self, arg0: Register8Bit)

Rotate 8 bits r/m8 right once.

pub fn ror_RegisterHigh8BitsOf16Bits_CL(
    &mut self,
    arg0: RegisterHigh8BitsOf16Bits
)

Rotate 8 bits r/m8 right CL times.

pub fn ror_RegisterHigh8BitsOf16Bits_Immediate8Bit(
    &mut self,
    arg0: RegisterHigh8BitsOf16Bits,
    arg1: Immediate8Bit
)

Rotate 8 bits r/m16 right imm8 times.

pub fn ror_RegisterHigh8BitsOf16Bits_One(
    &mut self,
    arg0: RegisterHigh8BitsOf16Bits
)

Rotate 8 bits r/m8 right once.

pub fn rorx_Register32Bit_Any32BitMemory_Immediate8Bit(
    &mut self,
    arg0: Register32Bit,
    arg1: Any32BitMemory,
    arg2: Immediate8Bit
)

Rotate 32-bit r/m32 right imm8 times without affecting arithmetic flags.

pub fn rorx_Register32Bit_Register32Bit_Immediate8Bit(
    &mut self,
    arg0: Register32Bit,
    arg1: Register32Bit,
    arg2: Immediate8Bit
)

Rotate 32-bit r/m32 right imm8 times without affecting arithmetic flags.

pub fn rorx_Register64Bit_Any64BitMemory_Immediate8Bit(
    &mut self,
    arg0: Register64Bit,
    arg1: Any64BitMemory,
    arg2: Immediate8Bit
)

Rotate 64-bit r/m64 right imm8 times without affecting arithmetic flags.

pub fn rorx_Register64Bit_Register64Bit_Immediate8Bit(
    &mut self,
    arg0: Register64Bit,
    arg1: Register64Bit,
    arg2: Immediate8Bit
)

Rotate 64-bit r/m64 right imm8 times without affecting arithmetic flags.

pub fn roundpd_XMMRegister_Any128BitMemory_Immediate8Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory,
    arg2: Immediate8Bit
)

Round packed double-precision floating-point values in xmm2/m128 and place the result in xmm1.

The rounding mode is determined by imm8.

pub fn roundpd_XMMRegister_XMMRegister_Immediate8Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Immediate8Bit
)

Round packed double-precision floating-point values in xmm2/m128 and place the result in xmm1.

The rounding mode is determined by imm8.

pub fn roundps_XMMRegister_Any128BitMemory_Immediate8Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory,
    arg2: Immediate8Bit
)

Round packed single-precision floating-point values in xmm2/m128 and place the result in xmm1.

The rounding mode is determined by imm8.

pub fn roundps_XMMRegister_XMMRegister_Immediate8Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Immediate8Bit
)

Round packed single-precision floating-point values in xmm2/m128 and place the result in xmm1.

The rounding mode is determined by imm8.

pub fn roundsd_XMMRegister_Any64BitMemory_Immediate8Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: Any64BitMemory,
    arg2: Immediate8Bit
)

Round the low packed double-precision floating-point value in xmm2/m64 and place the result in xmm1.

The rounding mode is determined by imm8.

pub fn roundsd_XMMRegister_XMMRegister_Immediate8Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Immediate8Bit
)

Round the low packed double-precision floating-point value in xmm2/m64 and place the result in xmm1.

The rounding mode is determined by imm8.

pub fn roundss_XMMRegister_Any32BitMemory_Immediate8Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: Any32BitMemory,
    arg2: Immediate8Bit
)

Round the low packed single-precision floating-point value in xmm2/m32 and place the result in xmm1.

The rounding mode is determined by imm8.

pub fn roundss_XMMRegister_XMMRegister_Immediate8Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Immediate8Bit
)

Round the low packed single-precision floating-point value in xmm2/m32 and place the result in xmm1.

The rounding mode is determined by imm8.

pub fn rsqrtps_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Computes the approximate reciprocals of the square roots of the packed single-precision floating-point values in xmm2/m128 and stores the results in xmm1.

pub fn rsqrtps_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Computes the approximate reciprocals of the square roots of the packed single-precision floating-point values in xmm2/m128 and stores the results in xmm1.

pub fn rsqrtss_XMMRegister_Any32BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any32BitMemory
)

Computes the approximate reciprocal of the square root of the low single-precision floating-point value in xmm2/m32 and stores the results in xmm1.

pub fn rsqrtss_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Computes the approximate reciprocal of the square root of the low single-precision floating-point value in xmm2/m32 and stores the results in xmm1.

pub fn sahf(&mut self)

Loads the Sign Flag (SF), Zero Flag (ZF), A Flag (AF), Parity Flag (PF), and Carry Flag (CF) from AH into EFLAGS.

pub fn sal_Any16BitMemory_CL(&mut self, arg0: Any16BitMemory)

Multiply r/m16 by 2, CL times.

pub fn sal_Any16BitMemory_Immediate8Bit(
    &mut self,
    arg0: Any16BitMemory,
    arg1: Immediate8Bit
)

Multiply r/m16 by 2, imm8 times.

pub fn sal_Any16BitMemory_One(&mut self, arg0: Any16BitMemory)

Multiply r/m16 by 2, once.

pub fn sal_Any32BitMemory_CL(&mut self, arg0: Any32BitMemory)

Multiply r/m32 by 2, CL times.

pub fn sal_Any32BitMemory_Immediate8Bit(
    &mut self,
    arg0: Any32BitMemory,
    arg1: Immediate8Bit
)

Multiply r/m32 by 2, imm8 times.

pub fn sal_Any32BitMemory_One(&mut self, arg0: Any32BitMemory)

Multiply r/m32 by 2, once.

pub fn sal_Any64BitMemory_CL(&mut self, arg0: Any64BitMemory)

Multiply r/m64 by 2, CL times.

pub fn sal_Any64BitMemory_Immediate8Bit(
    &mut self,
    arg0: Any64BitMemory,
    arg1: Immediate8Bit
)

Multiply r/m64 by 2, imm8 times.

pub fn sal_Any64BitMemory_One(&mut self, arg0: Any64BitMemory)

Multiply r/m64 by 2, once.

pub fn sal_Any8BitMemory_CL(&mut self, arg0: Any8BitMemory)

Multiply r/m8 by 2, CL times.

pub fn sal_Any8BitMemory_Immediate8Bit(
    &mut self,
    arg0: Any8BitMemory,
    arg1: Immediate8Bit
)

Multiply r/m8 by 2, imm8 times.

pub fn sal_Any8BitMemory_One(&mut self, arg0: Any8BitMemory)

Multiply r/m8 by 2, once.

pub fn sal_Register16Bit_CL(&mut self, arg0: Register16Bit)

Multiply r/m16 by 2, CL times.

pub fn sal_Register16Bit_Immediate8Bit(
    &mut self,
    arg0: Register16Bit,
    arg1: Immediate8Bit
)

Multiply r/m16 by 2, imm8 times.

pub fn sal_Register16Bit_One(&mut self, arg0: Register16Bit)

Multiply r/m16 by 2, once.

pub fn sal_Register32Bit_CL(&mut self, arg0: Register32Bit)

Multiply r/m32 by 2, CL times.

pub fn sal_Register32Bit_Immediate8Bit(
    &mut self,
    arg0: Register32Bit,
    arg1: Immediate8Bit
)

Multiply r/m32 by 2, imm8 times.

pub fn sal_Register32Bit_One(&mut self, arg0: Register32Bit)

Multiply r/m32 by 2, once.

pub fn sal_Register64Bit_CL(&mut self, arg0: Register64Bit)

Multiply r/m64 by 2, CL times.

pub fn sal_Register64Bit_Immediate8Bit(
    &mut self,
    arg0: Register64Bit,
    arg1: Immediate8Bit
)

Multiply r/m64 by 2, imm8 times.

pub fn sal_Register64Bit_One(&mut self, arg0: Register64Bit)

Multiply r/m64 by 2, once.

pub fn sal_Register8Bit_CL(&mut self, arg0: Register8Bit)

Multiply r/m8 by 2, CL times.

pub fn sal_Register8Bit_Immediate8Bit(
    &mut self,
    arg0: Register8Bit,
    arg1: Immediate8Bit
)

Multiply r/m8 by 2, imm8 times.

pub fn sal_Register8Bit_One(&mut self, arg0: Register8Bit)

Multiply r/m8 by 2, once.

pub fn sal_RegisterHigh8BitsOf16Bits_CL(
    &mut self,
    arg0: RegisterHigh8BitsOf16Bits
)

Multiply r/m8 by 2, CL times.

pub fn sal_RegisterHigh8BitsOf16Bits_Immediate8Bit(
    &mut self,
    arg0: RegisterHigh8BitsOf16Bits,
    arg1: Immediate8Bit
)

Multiply r/m8 by 2, imm8 times.

pub fn sal_RegisterHigh8BitsOf16Bits_One(
    &mut self,
    arg0: RegisterHigh8BitsOf16Bits
)

Multiply r/m8 by 2, once.

pub fn sar_Any16BitMemory_CL(&mut self, arg0: Any16BitMemory)

Signed divide r/m16 by 2, CL times.

pub fn sar_Any16BitMemory_Immediate8Bit(
    &mut self,
    arg0: Any16BitMemory,
    arg1: Immediate8Bit
)

Signed divide r/m16 by 2, imm8 times.

pub fn sar_Any16BitMemory_One(&mut self, arg0: Any16BitMemory)

Signed divide r/m16 by 2, once.

pub fn sar_Any32BitMemory_CL(&mut self, arg0: Any32BitMemory)

Signed divide r/m32 by 2, CL times.

pub fn sar_Any32BitMemory_Immediate8Bit(
    &mut self,
    arg0: Any32BitMemory,
    arg1: Immediate8Bit
)

Signed divide r/m32 by 2, imm8 times.

pub fn sar_Any32BitMemory_One(&mut self, arg0: Any32BitMemory)

Signed divide r/m32 by 2, once.

pub fn sar_Any64BitMemory_CL(&mut self, arg0: Any64BitMemory)

Signed divide r/m32 by 2, CL times.

pub fn sar_Any64BitMemory_Immediate8Bit(
    &mut self,
    arg0: Any64BitMemory,
    arg1: Immediate8Bit
)

Signed divide r/m32 by 2, imm8 times.

pub fn sar_Any64BitMemory_One(&mut self, arg0: Any64BitMemory)

Signed divide r/m32 by 2, once.

pub fn sar_Any8BitMemory_CL(&mut self, arg0: Any8BitMemory)

Signed divide r/m8 by 2, CL times.

pub fn sar_Any8BitMemory_Immediate8Bit(
    &mut self,
    arg0: Any8BitMemory,
    arg1: Immediate8Bit
)

Signed divide r/m8 by 2, imm8 time.

pub fn sar_Any8BitMemory_One(&mut self, arg0: Any8BitMemory)

Signed divide r/m8 by 2, once.

pub fn sar_Register16Bit_CL(&mut self, arg0: Register16Bit)

Signed divide r/m16 by 2, CL times.

pub fn sar_Register16Bit_Immediate8Bit(
    &mut self,
    arg0: Register16Bit,
    arg1: Immediate8Bit
)

Signed divide r/m16 by 2, imm8 times.

pub fn sar_Register16Bit_One(&mut self, arg0: Register16Bit)

Signed divide r/m16 by 2, once.

pub fn sar_Register32Bit_CL(&mut self, arg0: Register32Bit)

Signed divide r/m32 by 2, CL times.

pub fn sar_Register32Bit_Immediate8Bit(
    &mut self,
    arg0: Register32Bit,
    arg1: Immediate8Bit
)

Signed divide r/m32 by 2, imm8 times.

pub fn sar_Register32Bit_One(&mut self, arg0: Register32Bit)

Signed divide r/m32 by 2, once.

pub fn sar_Register64Bit_CL(&mut self, arg0: Register64Bit)

Signed divide r/m32 by 2, CL times.

pub fn sar_Register64Bit_Immediate8Bit(
    &mut self,
    arg0: Register64Bit,
    arg1: Immediate8Bit
)

Signed divide r/m32 by 2, imm8 times.

pub fn sar_Register64Bit_One(&mut self, arg0: Register64Bit)

Signed divide r/m32 by 2, once.

pub fn sar_Register8Bit_CL(&mut self, arg0: Register8Bit)

Signed divide r/m8 by 2, CL times.

pub fn sar_Register8Bit_Immediate8Bit(
    &mut self,
    arg0: Register8Bit,
    arg1: Immediate8Bit
)

Signed divide r/m8 by 2, imm8 time.

pub fn sar_Register8Bit_One(&mut self, arg0: Register8Bit)

Signed divide r/m8 by 2, once.

pub fn sar_RegisterHigh8BitsOf16Bits_CL(
    &mut self,
    arg0: RegisterHigh8BitsOf16Bits
)

Signed divide r/m8 by 2, CL times.

pub fn sar_RegisterHigh8BitsOf16Bits_Immediate8Bit(
    &mut self,
    arg0: RegisterHigh8BitsOf16Bits,
    arg1: Immediate8Bit
)

Signed divide r/m8 by 2, imm8 time.

pub fn sar_RegisterHigh8BitsOf16Bits_One(
    &mut self,
    arg0: RegisterHigh8BitsOf16Bits
)

Signed divide r/m8 by 2, once.

pub fn sarx_Register32Bit_Any32BitMemory_Register32Bit(
    &mut self,
    arg0: Register32Bit,
    arg1: Any32BitMemory,
    arg2: Register32Bit
)

Shift r/m32 arithmetically right with count specified in r32b.

pub fn sarx_Register32Bit_Register32Bit_Register32Bit(
    &mut self,
    arg0: Register32Bit,
    arg1: Register32Bit,
    arg2: Register32Bit
)

Shift r/m32 arithmetically right with count specified in r32b.

pub fn sarx_Register64Bit_Any64BitMemory_Register64Bit(
    &mut self,
    arg0: Register64Bit,
    arg1: Any64BitMemory,
    arg2: Register64Bit
)

Shift r/m64 arithmetically right with count specified in r64b.

pub fn sarx_Register64Bit_Register64Bit_Register64Bit(
    &mut self,
    arg0: Register64Bit,
    arg1: Register64Bit,
    arg2: Register64Bit
)

Shift r/m64 arithmetically right with count specified in r64b.

pub fn sbb_AL_Immediate8Bit(&mut self, arg1: Immediate8Bit)

Subtract with borrow imm8 from AL.

pub fn sbb_AX_Immediate16Bit(&mut self, arg1: Immediate16Bit)

Subtract with borrow imm16 from AX.

pub fn sbb_EAX_Immediate32Bit(&mut self, arg1: Immediate32Bit)

Subtract with borrow imm32 from EAX.

pub fn sbb_Any16BitMemory_Immediate16Bit(
    &mut self,
    arg0: Any16BitMemory,
    arg1: Immediate16Bit
)

Subtract with borrow imm16 from r/m16.

pub fn sbb_Any16BitMemory_Immediate8Bit(
    &mut self,
    arg0: Any16BitMemory,
    arg1: Immediate8Bit
)

Subtract with borrow sign-extended imm8 from r/m16.

pub fn sbb_Any16BitMemory_Register16Bit(
    &mut self,
    arg0: Any16BitMemory,
    arg1: Register16Bit
)

Subtract with borrow r16 from r/m16.

pub fn sbb_Any32BitMemory_Immediate32Bit(
    &mut self,
    arg0: Any32BitMemory,
    arg1: Immediate32Bit
)

Subtract with borrow imm32 from r/m32.

pub fn sbb_Any32BitMemory_Immediate8Bit(
    &mut self,
    arg0: Any32BitMemory,
    arg1: Immediate8Bit
)

Subtract with borrow sign-extended imm8 from r/m32.

pub fn sbb_Any32BitMemory_Register32Bit(
    &mut self,
    arg0: Any32BitMemory,
    arg1: Register32Bit
)

Subtract with borrow r32 from r/m32.

pub fn sbb_Any64BitMemory_Immediate32Bit(
    &mut self,
    arg0: Any64BitMemory,
    arg1: Immediate32Bit
)

Subtract with borrow sign-extended imm32 to 64-bits from r/m64.

pub fn sbb_Any64BitMemory_Immediate8Bit(
    &mut self,
    arg0: Any64BitMemory,
    arg1: Immediate8Bit
)

Subtract with borrow sign-extended imm8 from r/m64.

pub fn sbb_Any64BitMemory_Register64Bit(
    &mut self,
    arg0: Any64BitMemory,
    arg1: Register64Bit
)

Subtract with borrow r64 from r/m64.

pub fn sbb_Any8BitMemory_Immediate8Bit(
    &mut self,
    arg0: Any8BitMemory,
    arg1: Immediate8Bit
)

Subtract with borrow imm8 from r/m8.

pub fn sbb_Any8BitMemory_Register8Bit(
    &mut self,
    arg0: Any8BitMemory,
    arg1: Register8Bit
)

Subtract with borrow r8 from r/m8.

pub fn sbb_Any8BitMemory_RegisterHigh8BitsOf16Bits(
    &mut self,
    arg0: Any8BitMemory,
    arg1: RegisterHigh8BitsOf16Bits
)

Subtract with borrow r8 from r/m8.

pub fn sbb_Register16Bit_Immediate16Bit(
    &mut self,
    arg0: Register16Bit,
    arg1: Immediate16Bit
)

Subtract with borrow imm16 from r/m16.

pub fn sbb_Register16Bit_Immediate8Bit(
    &mut self,
    arg0: Register16Bit,
    arg1: Immediate8Bit
)

Subtract with borrow sign-extended imm8 from r/m16.

pub fn sbb_Register16Bit_Any16BitMemory(
    &mut self,
    arg0: Register16Bit,
    arg1: Any16BitMemory
)

Subtract with borrow r/m16 from r16.

pub fn sbb_Register16Bit_Register16Bit(
    &mut self,
    arg0: Register16Bit,
    arg1: Register16Bit
)

Subtract with borrow r16 from r/m16.

pub fn sbb_Register16Bit_Register16Bit_1(
    &mut self,
    arg0: Register16Bit,
    arg1: Register16Bit
)

Subtract with borrow r/m16 from r16.

pub fn sbb_Register32Bit_Immediate32Bit(
    &mut self,
    arg0: Register32Bit,
    arg1: Immediate32Bit
)

Subtract with borrow imm32 from r/m32.

pub fn sbb_Register32Bit_Immediate8Bit(
    &mut self,
    arg0: Register32Bit,
    arg1: Immediate8Bit
)

Subtract with borrow sign-extended imm8 from r/m32.

pub fn sbb_Register32Bit_Any32BitMemory(
    &mut self,
    arg0: Register32Bit,
    arg1: Any32BitMemory
)

Subtract with borrow r/m32 from r32.

pub fn sbb_Register32Bit_Register32Bit(
    &mut self,
    arg0: Register32Bit,
    arg1: Register32Bit
)

Subtract with borrow r32 from r/m32.

pub fn sbb_Register32Bit_Register32Bit_1(
    &mut self,
    arg0: Register32Bit,
    arg1: Register32Bit
)

Subtract with borrow r/m32 from r32.

pub fn sbb_Register64Bit_Immediate32Bit(
    &mut self,
    arg0: Register64Bit,
    arg1: Immediate32Bit
)

Subtract with borrow sign-extended imm32 to 64-bits from r/m64.

pub fn sbb_Register64Bit_Immediate8Bit(
    &mut self,
    arg0: Register64Bit,
    arg1: Immediate8Bit
)

Subtract with borrow sign-extended imm8 from r/m64.

pub fn sbb_Register64Bit_Any64BitMemory(
    &mut self,
    arg0: Register64Bit,
    arg1: Any64BitMemory
)

Subtract with borrow r/m64 from r64.

pub fn sbb_Register64Bit_Register64Bit(
    &mut self,
    arg0: Register64Bit,
    arg1: Register64Bit
)

Subtract with borrow r64 from r/m64.

pub fn sbb_Register64Bit_Register64Bit_1(
    &mut self,
    arg0: Register64Bit,
    arg1: Register64Bit
)

Subtract with borrow r/m64 from r64.

pub fn sbb_Register8Bit_Immediate8Bit(
    &mut self,
    arg0: Register8Bit,
    arg1: Immediate8Bit
)

Subtract with borrow imm8 from r/m8.

pub fn sbb_Register8Bit_Any8BitMemory(
    &mut self,
    arg0: Register8Bit,
    arg1: Any8BitMemory
)

Subtract with borrow r/m8 from r8.

pub fn sbb_Register8Bit_Register8Bit(
    &mut self,
    arg0: Register8Bit,
    arg1: Register8Bit
)

Subtract with borrow r8 from r/m8.

pub fn sbb_Register8Bit_Register8Bit_1(
    &mut self,
    arg0: Register8Bit,
    arg1: Register8Bit
)

Subtract with borrow r/m8 from r8.

pub fn sbb_Register8Bit_RegisterHigh8BitsOf16Bits(
    &mut self,
    arg0: Register8Bit,
    arg1: RegisterHigh8BitsOf16Bits
)

Subtract with borrow r8 from r/m8.

pub fn sbb_Register8Bit_RegisterHigh8BitsOf16Bits_1(
    &mut self,
    arg0: Register8Bit,
    arg1: RegisterHigh8BitsOf16Bits
)

Subtract with borrow r/m8 from r8.

pub fn sbb_RAX_Immediate32Bit(&mut self, arg1: Immediate32Bit)

Subtract with borrow sign-extended imm.32 to 64-bits from RAX.

pub fn sbb_RegisterHigh8BitsOf16Bits_Immediate8Bit(
    &mut self,
    arg0: RegisterHigh8BitsOf16Bits,
    arg1: Immediate8Bit
)

Subtract with borrow imm8 from r/m8.

pub fn sbb_RegisterHigh8BitsOf16Bits_Any8BitMemory(
    &mut self,
    arg0: RegisterHigh8BitsOf16Bits,
    arg1: Any8BitMemory
)

Subtract with borrow r/m8 from r8.

pub fn sbb_RegisterHigh8BitsOf16Bits_Register8Bit(
    &mut self,
    arg0: RegisterHigh8BitsOf16Bits,
    arg1: Register8Bit
)

Subtract with borrow r8 from r/m8.

pub fn sbb_RegisterHigh8BitsOf16Bits_Register8Bit_1(
    &mut self,
    arg0: RegisterHigh8BitsOf16Bits,
    arg1: Register8Bit
)

Subtract with borrow r/m8 from r8.

pub fn sbb_RegisterHigh8BitsOf16Bits_RegisterHigh8BitsOf16Bits(
    &mut self,
    arg0: RegisterHigh8BitsOf16Bits,
    arg1: RegisterHigh8BitsOf16Bits
)

Subtract with borrow r8 from r/m8.

pub fn sbb_RegisterHigh8BitsOf16Bits_RegisterHigh8BitsOf16Bits_1(
    &mut self,
    arg0: RegisterHigh8BitsOf16Bits,
    arg1: RegisterHigh8BitsOf16Bits
)

Subtract with borrow r/m8 from r8.

pub fn scas_Any16BitMemory(&mut self, arg0: Any16BitMemory)

Compare AX with word at ES:(E)DI or RDI then set status flags.

pub fn scas_Any32BitMemory(&mut self, arg0: Any32BitMemory)

Compare EAX with doubleword at ES(E)DI or RDI then set status flags.

pub fn scas_Any64BitMemory(&mut self, arg0: Any64BitMemory)

Compare RAX with quadword at RDI or EDI then set status flags.

pub fn scas_Any8BitMemory(&mut self, arg0: Any8BitMemory)

Compare AL with byte at ES:(E)DI or RDI then set status flags.

pub fn scasb(&mut self)

Compare AL with byte at ES:(E)DI or RDI then set status flags.

pub fn scasd(&mut self)

Compare EAX with doubleword at ES:(E)DI or RDI then set status flags.

pub fn scasq(&mut self)

Compare RAX with quadword at RDI or EDI then set status flags.

pub fn scasw(&mut self)

Compare AX with word at ES:(E)DI or RDI then set status flags.

pub fn seta_Any8BitMemory(&mut self, arg0: Any8BitMemory)

Set byte if above (Carry Flag (CF) is 0 and Zero Flag (ZF) is 0).

pub fn seta_Register8Bit(&mut self, arg0: Register8Bit)

Set byte if above (Carry Flag (CF) is 0 and Zero Flag (ZF) is 0).

pub fn seta_RegisterHigh8BitsOf16Bits(&mut self, arg0: RegisterHigh8BitsOf16Bits)

Set byte if above (Carry Flag (CF) is 0 and Zero Flag (ZF) is 0).

pub fn setae_Any8BitMemory(&mut self, arg0: Any8BitMemory)

Set byte if above or equal (Carry Flag (CF) is 0).

pub fn setae_Register8Bit(&mut self, arg0: Register8Bit)

Set byte if above or equal (Carry Flag (CF) is 0).

pub fn setae_RegisterHigh8BitsOf16Bits(
    &mut self,
    arg0: RegisterHigh8BitsOf16Bits
)

Set byte if above or equal (Carry Flag (CF) is 0).

pub fn setb_Any8BitMemory(&mut self, arg0: Any8BitMemory)

Set byte if below (Carry Flag (CF) is 1).

pub fn setb_Register8Bit(&mut self, arg0: Register8Bit)

Set byte if below (Carry Flag (CF) is 1).

pub fn setb_RegisterHigh8BitsOf16Bits(&mut self, arg0: RegisterHigh8BitsOf16Bits)

Set byte if below (Carry Flag (CF) is 1).

pub fn setbe_Any8BitMemory(&mut self, arg0: Any8BitMemory)

Set byte if below or equal (Carry Flag (CF) is 1 or Zero Flag (ZF) is 1).

pub fn setbe_Register8Bit(&mut self, arg0: Register8Bit)

Set byte if below or equal (Carry Flag (CF) is 1 or Zero Flag (ZF) is 1).

pub fn setbe_RegisterHigh8BitsOf16Bits(
    &mut self,
    arg0: RegisterHigh8BitsOf16Bits
)

Set byte if below or equal (Carry Flag (CF) is 1 or Zero Flag (ZF) is 1).

pub fn setc_Any8BitMemory(&mut self, arg0: Any8BitMemory)

Set byte if carry (Carry Flag (CF) is 1).

pub fn setc_Register8Bit(&mut self, arg0: Register8Bit)

Set byte if carry (Carry Flag (CF) is 1).

pub fn setc_RegisterHigh8BitsOf16Bits(&mut self, arg0: RegisterHigh8BitsOf16Bits)

Set byte if carry (Carry Flag (CF) is 1).

pub fn sete_Any8BitMemory(&mut self, arg0: Any8BitMemory)

Set byte if equal (Zero Flag (ZF) is 1).

pub fn sete_Register8Bit(&mut self, arg0: Register8Bit)

Set byte if equal (Zero Flag (ZF) is 1).

pub fn sete_RegisterHigh8BitsOf16Bits(&mut self, arg0: RegisterHigh8BitsOf16Bits)

Set byte if equal (Zero Flag (ZF) is 1).

pub fn setg_Any8BitMemory(&mut self, arg0: Any8BitMemory)

Set byte if greater (Zero Flag (ZF) is 0 and Sign Flag (SF) == Overflow Flag (OF)).

pub fn setg_Register8Bit(&mut self, arg0: Register8Bit)

Set byte if greater (Zero Flag (ZF) is 0 and Sign Flag (SF) == Overflow Flag (OF)).

pub fn setg_RegisterHigh8BitsOf16Bits(&mut self, arg0: RegisterHigh8BitsOf16Bits)

Set byte if greater (Zero Flag (ZF) is 0 and Sign Flag (SF) == Overflow Flag (OF)).

pub fn setge_Any8BitMemory(&mut self, arg0: Any8BitMemory)

Set byte if greater or equal (Sign Flag (SF) == Overflow Flag (OF)).

pub fn setge_Register8Bit(&mut self, arg0: Register8Bit)

Set byte if greater or equal (Sign Flag (SF) == Overflow Flag (OF)).

pub fn setge_RegisterHigh8BitsOf16Bits(
    &mut self,
    arg0: RegisterHigh8BitsOf16Bits
)

Set byte if greater or equal (Sign Flag (SF) == Overflow Flag (OF)).

pub fn setl_Any8BitMemory(&mut self, arg0: Any8BitMemory)

Set byte if less (Sign Flag (SF) != Overflow Flag (OF)).

pub fn setl_Register8Bit(&mut self, arg0: Register8Bit)

Set byte if less (Sign Flag (SF) != Overflow Flag (OF)).

pub fn setl_RegisterHigh8BitsOf16Bits(&mut self, arg0: RegisterHigh8BitsOf16Bits)

Set byte if less (Sign Flag (SF) != Overflow Flag (OF)).

pub fn setle_Any8BitMemory(&mut self, arg0: Any8BitMemory)

Set byte if less or equal (Zero Flag (ZF) is 1 or Sign Flag (SF) != Overflow Flag (OF)).

pub fn setle_Register8Bit(&mut self, arg0: Register8Bit)

Set byte if less or equal (Zero Flag (ZF) is 1 or Sign Flag (SF) != Overflow Flag (OF)).

pub fn setle_RegisterHigh8BitsOf16Bits(
    &mut self,
    arg0: RegisterHigh8BitsOf16Bits
)

Set byte if less or equal (Zero Flag (ZF) is 1 or Sign Flag (SF) != Overflow Flag (OF)).

pub fn setna_Any8BitMemory(&mut self, arg0: Any8BitMemory)

Set byte if not above (Carry Flag (CF) is 1 or Zero Flag (ZF) is 1).

pub fn setna_Register8Bit(&mut self, arg0: Register8Bit)

Set byte if not above (Carry Flag (CF) is 1 or Zero Flag (ZF) is 1).

pub fn setna_RegisterHigh8BitsOf16Bits(
    &mut self,
    arg0: RegisterHigh8BitsOf16Bits
)

Set byte if not above (Carry Flag (CF) is 1 or Zero Flag (ZF) is 1).

pub fn setnae_Any8BitMemory(&mut self, arg0: Any8BitMemory)

Set byte if not above or equal (Carry Flag (CF) is 1).

pub fn setnae_Register8Bit(&mut self, arg0: Register8Bit)

Set byte if not above or equal (Carry Flag (CF) is 1).

pub fn setnae_RegisterHigh8BitsOf16Bits(
    &mut self,
    arg0: RegisterHigh8BitsOf16Bits
)

Set byte if not above or equal (Carry Flag (CF) is 1).

pub fn setnb_Any8BitMemory(&mut self, arg0: Any8BitMemory)

Set byte if not below (Carry Flag (CF) is 0).

pub fn setnb_Register8Bit(&mut self, arg0: Register8Bit)

Set byte if not below (Carry Flag (CF) is 0).

pub fn setnb_RegisterHigh8BitsOf16Bits(
    &mut self,
    arg0: RegisterHigh8BitsOf16Bits
)

Set byte if not below (Carry Flag (CF) is 0).

pub fn setnbe_Any8BitMemory(&mut self, arg0: Any8BitMemory)

Set byte if not below or equal (Carry Flag (CF) is 0 and Zero Flag (ZF) is 0).

pub fn setnbe_Register8Bit(&mut self, arg0: Register8Bit)

Set byte if not below or equal (Carry Flag (CF) is 0 and Zero Flag (ZF) is 0).

pub fn setnbe_RegisterHigh8BitsOf16Bits(
    &mut self,
    arg0: RegisterHigh8BitsOf16Bits
)

Set byte if not below or equal (Carry Flag (CF) is 0 and Zero Flag (ZF) is 0).

pub fn setnc_Any8BitMemory(&mut self, arg0: Any8BitMemory)

Set byte if not carry (Carry Flag (CF) is 0).

pub fn setnc_Register8Bit(&mut self, arg0: Register8Bit)

Set byte if not carry (Carry Flag (CF) is 0).

pub fn setnc_RegisterHigh8BitsOf16Bits(
    &mut self,
    arg0: RegisterHigh8BitsOf16Bits
)

Set byte if not carry (Carry Flag (CF) is 0).

pub fn setne_Any8BitMemory(&mut self, arg0: Any8BitMemory)

Set byte if not equal (Zero Flag (ZF) is 0).

pub fn setne_Register8Bit(&mut self, arg0: Register8Bit)

Set byte if not equal (Zero Flag (ZF) is 0).

pub fn setne_RegisterHigh8BitsOf16Bits(
    &mut self,
    arg0: RegisterHigh8BitsOf16Bits
)

Set byte if not equal (Zero Flag (ZF) is 0).

pub fn setng_Any8BitMemory(&mut self, arg0: Any8BitMemory)

Set byte if not greater (Zero Flag (ZF) is 1 or Sign Flag (SF) != Overflow Flag (OF)).

pub fn setng_Register8Bit(&mut self, arg0: Register8Bit)

Set byte if not greater (Zero Flag (ZF) is 1 or Sign Flag (SF) != Overflow Flag (OF)).

pub fn setng_RegisterHigh8BitsOf16Bits(
    &mut self,
    arg0: RegisterHigh8BitsOf16Bits
)

Set byte if not greater (Zero Flag (ZF) is 1 or Sign Flag (SF) != Overflow Flag (OF)).

pub fn setnge_Any8BitMemory(&mut self, arg0: Any8BitMemory)

Set byte if not greater or equal (Sign Flag (SF) != Overflow Flag (OF)).

pub fn setnge_Register8Bit(&mut self, arg0: Register8Bit)

Set byte if not greater or equal (Sign Flag (SF) != Overflow Flag (OF)).

pub fn setnge_RegisterHigh8BitsOf16Bits(
    &mut self,
    arg0: RegisterHigh8BitsOf16Bits
)

Set byte if not greater or equal (Sign Flag (SF) != Overflow Flag (OF)).

pub fn setnl_Any8BitMemory(&mut self, arg0: Any8BitMemory)

Set byte if not less (Sign Flag (SF) == Overflow Flag (OF)).

pub fn setnl_Register8Bit(&mut self, arg0: Register8Bit)

Set byte if not less (Sign Flag (SF) == Overflow Flag (OF)).

pub fn setnl_RegisterHigh8BitsOf16Bits(
    &mut self,
    arg0: RegisterHigh8BitsOf16Bits
)

Set byte if not less (Sign Flag (SF) == Overflow Flag (OF)).

pub fn setnle_Any8BitMemory(&mut self, arg0: Any8BitMemory)

Set byte if not less or equal (Zero Flag (ZF) is 0 and Sign Flag (SF) == Overflow Flag (OF)).

pub fn setnle_Register8Bit(&mut self, arg0: Register8Bit)

Set byte if not less or equal (Zero Flag (ZF) is 0 and Sign Flag (SF) == Overflow Flag (OF)).

pub fn setnle_RegisterHigh8BitsOf16Bits(
    &mut self,
    arg0: RegisterHigh8BitsOf16Bits
)

Set byte if not less or equal (Zero Flag (ZF) is 0 and Sign Flag (SF) == Overflow Flag (OF)).

pub fn setno_Any8BitMemory(&mut self, arg0: Any8BitMemory)

Set byte if not overflow (Overflow Flag (OF) is 0).

pub fn setno_Register8Bit(&mut self, arg0: Register8Bit)

Set byte if not overflow (Overflow Flag (OF) is 0).

pub fn setno_RegisterHigh8BitsOf16Bits(
    &mut self,
    arg0: RegisterHigh8BitsOf16Bits
)

Set byte if not overflow (Overflow Flag (OF) is 0).

pub fn setnp_Any8BitMemory(&mut self, arg0: Any8BitMemory)

Set byte if not parity (Parity Flag (PF) is 0).

pub fn setnp_Register8Bit(&mut self, arg0: Register8Bit)

Set byte if not parity (Parity Flag (PF) is 0).

pub fn setnp_RegisterHigh8BitsOf16Bits(
    &mut self,
    arg0: RegisterHigh8BitsOf16Bits
)

Set byte if not parity (Parity Flag (PF) is 0).

pub fn setns_Any8BitMemory(&mut self, arg0: Any8BitMemory)

Set byte if not sign (Sign Flag (SF) is 0).

pub fn setns_Register8Bit(&mut self, arg0: Register8Bit)

Set byte if not sign (Sign Flag (SF) is 0).

pub fn setns_RegisterHigh8BitsOf16Bits(
    &mut self,
    arg0: RegisterHigh8BitsOf16Bits
)

Set byte if not sign (Sign Flag (SF) is 0).

pub fn setnz_Any8BitMemory(&mut self, arg0: Any8BitMemory)

Set byte if not zero (Zero Flag (ZF) is 0).

pub fn setnz_Register8Bit(&mut self, arg0: Register8Bit)

Set byte if not zero (Zero Flag (ZF) is 0).

pub fn setnz_RegisterHigh8BitsOf16Bits(
    &mut self,
    arg0: RegisterHigh8BitsOf16Bits
)

Set byte if not zero (Zero Flag (ZF) is 0).

pub fn seto_Any8BitMemory(&mut self, arg0: Any8BitMemory)

Set byte if overflow (Overflow Flag (OF) is 1).

pub fn seto_Register8Bit(&mut self, arg0: Register8Bit)

Set byte if overflow (Overflow Flag (OF) is 1).

pub fn seto_RegisterHigh8BitsOf16Bits(&mut self, arg0: RegisterHigh8BitsOf16Bits)

Set byte if overflow (Overflow Flag (OF) is 1).

pub fn setp_Any8BitMemory(&mut self, arg0: Any8BitMemory)

Set byte if parity (Parity Flag (PF) is 1).

pub fn setp_Register8Bit(&mut self, arg0: Register8Bit)

Set byte if parity (Parity Flag (PF) is 1).

pub fn setp_RegisterHigh8BitsOf16Bits(&mut self, arg0: RegisterHigh8BitsOf16Bits)

Set byte if parity (Parity Flag (PF) is 1).

pub fn setpe_Any8BitMemory(&mut self, arg0: Any8BitMemory)

Set byte if parity even (Parity Flag (PF) is 1).

pub fn setpe_Register8Bit(&mut self, arg0: Register8Bit)

Set byte if parity even (Parity Flag (PF) is 1).

pub fn setpe_RegisterHigh8BitsOf16Bits(
    &mut self,
    arg0: RegisterHigh8BitsOf16Bits
)

Set byte if parity even (Parity Flag (PF) is 1).

pub fn setpo_Any8BitMemory(&mut self, arg0: Any8BitMemory)

Set byte if parity odd (Parity Flag (PF) is 0).

pub fn setpo_Register8Bit(&mut self, arg0: Register8Bit)

Set byte if parity odd (Parity Flag (PF) is 0).

pub fn setpo_RegisterHigh8BitsOf16Bits(
    &mut self,
    arg0: RegisterHigh8BitsOf16Bits
)

Set byte if parity odd (Parity Flag (PF) is 0).

pub fn sets_Any8BitMemory(&mut self, arg0: Any8BitMemory)

Set byte if sign (Sign Flag (SF) is 1).

pub fn sets_Register8Bit(&mut self, arg0: Register8Bit)

Set byte if sign (Sign Flag (SF) is 1).

pub fn sets_RegisterHigh8BitsOf16Bits(&mut self, arg0: RegisterHigh8BitsOf16Bits)

Set byte if sign (Sign Flag (SF) is 1).

pub fn setz_Any8BitMemory(&mut self, arg0: Any8BitMemory)

Set byte if zero (Zero Flag (ZF) is 1).

pub fn setz_Register8Bit(&mut self, arg0: Register8Bit)

Set byte if zero (Zero Flag (ZF) is 1).

pub fn setz_RegisterHigh8BitsOf16Bits(&mut self, arg0: RegisterHigh8BitsOf16Bits)

Set byte if zero (Zero Flag (ZF) is 1).

pub fn sfence(&mut self)

Serializes store operations.

pub fn shl_Any16BitMemory_CL(&mut self, arg0: Any16BitMemory)

Multiply r/m16 by 2, CL times.

pub fn shl_Any16BitMemory_Immediate8Bit(
    &mut self,
    arg0: Any16BitMemory,
    arg1: Immediate8Bit
)

Multiply r/m16 by 2, imm8 times.

pub fn shl_Any16BitMemory_One(&mut self, arg0: Any16BitMemory)

Multiply r/m16 by 2, once.

pub fn shl_Any32BitMemory_CL(&mut self, arg0: Any32BitMemory)

Multiply r/m32 by 2, CL times.

pub fn shl_Any32BitMemory_Immediate8Bit(
    &mut self,
    arg0: Any32BitMemory,
    arg1: Immediate8Bit
)

Multiply r/m32 by 2, imm8 times.

pub fn shl_Any32BitMemory_One(&mut self, arg0: Any32BitMemory)

Multiply r/m32 by 2, once.

pub fn shl_Any64BitMemory_CL(&mut self, arg0: Any64BitMemory)

Multiply r/m32 by 2, CL times.

pub fn shl_Any64BitMemory_Immediate8Bit(
    &mut self,
    arg0: Any64BitMemory,
    arg1: Immediate8Bit
)

Multiply r/m32 by 2, imm8 times.

pub fn shl_Any64BitMemory_One(&mut self, arg0: Any64BitMemory)

Multiply r/m64 by 2, once.

pub fn shl_Any8BitMemory_CL(&mut self, arg0: Any8BitMemory)

Multiply r/m8 by 2, CL times.

pub fn shl_Any8BitMemory_Immediate8Bit(
    &mut self,
    arg0: Any8BitMemory,
    arg1: Immediate8Bit
)

Multiply r/m8 by 2, imm8 times.

pub fn shl_Any8BitMemory_One(&mut self, arg0: Any8BitMemory)

Multiply r/m8 by 2, once.

pub fn shl_Register16Bit_CL(&mut self, arg0: Register16Bit)

Multiply r/m16 by 2, CL times.

pub fn shl_Register16Bit_Immediate8Bit(
    &mut self,
    arg0: Register16Bit,
    arg1: Immediate8Bit
)

Multiply r/m16 by 2, imm8 times.

pub fn shl_Register16Bit_One(&mut self, arg0: Register16Bit)

Multiply r/m16 by 2, once.

pub fn shl_Register32Bit_CL(&mut self, arg0: Register32Bit)

Multiply r/m32 by 2, CL times.

pub fn shl_Register32Bit_Immediate8Bit(
    &mut self,
    arg0: Register32Bit,
    arg1: Immediate8Bit
)

Multiply r/m32 by 2, imm8 times.

pub fn shl_Register32Bit_One(&mut self, arg0: Register32Bit)

Multiply r/m32 by 2, once.

pub fn shl_Register64Bit_CL(&mut self, arg0: Register64Bit)

Multiply r/m32 by 2, CL times.

pub fn shl_Register64Bit_Immediate8Bit(
    &mut self,
    arg0: Register64Bit,
    arg1: Immediate8Bit
)

Multiply r/m32 by 2, imm8 times.

pub fn shl_Register64Bit_One(&mut self, arg0: Register64Bit)

Multiply r/m64 by 2, once.

pub fn shl_Register8Bit_CL(&mut self, arg0: Register8Bit)

Multiply r/m8 by 2, CL times.

pub fn shl_Register8Bit_Immediate8Bit(
    &mut self,
    arg0: Register8Bit,
    arg1: Immediate8Bit
)

Multiply r/m8 by 2, imm8 times.

pub fn shl_Register8Bit_One(&mut self, arg0: Register8Bit)

Multiply r/m8 by 2, once.

pub fn shl_RegisterHigh8BitsOf16Bits_CL(
    &mut self,
    arg0: RegisterHigh8BitsOf16Bits
)

Multiply r/m8 by 2, CL times.

pub fn shl_RegisterHigh8BitsOf16Bits_Immediate8Bit(
    &mut self,
    arg0: RegisterHigh8BitsOf16Bits,
    arg1: Immediate8Bit
)

Multiply r/m8 by 2, imm8 times.

pub fn shl_RegisterHigh8BitsOf16Bits_One(
    &mut self,
    arg0: RegisterHigh8BitsOf16Bits
)

Multiply r/m8 by 2, once.

pub fn shld_Any16BitMemory_Register16Bit_CL(
    &mut self,
    arg0: Any16BitMemory,
    arg1: Register16Bit
)

Shift r/m16 to left CL places while shifting bits from r16 in from the right.

pub fn shld_Any16BitMemory_Register16Bit_Immediate8Bit(
    &mut self,
    arg0: Any16BitMemory,
    arg1: Register16Bit,
    arg2: Immediate8Bit
)

Shift r/m16 to left imm8 places while shifting bits from r16 in from the right.

pub fn shld_Any32BitMemory_Register32Bit_CL(
    &mut self,
    arg0: Any32BitMemory,
    arg1: Register32Bit
)

Shift r/m32 to left CL places while shifting bits from r32 in from the right.

pub fn shld_Any32BitMemory_Register32Bit_Immediate8Bit(
    &mut self,
    arg0: Any32BitMemory,
    arg1: Register32Bit,
    arg2: Immediate8Bit
)

Shift r/m32 to left imm8 places while shifting bits from r32 in from the right.

pub fn shld_Any64BitMemory_Register64Bit_CL(
    &mut self,
    arg0: Any64BitMemory,
    arg1: Register64Bit
)

Shift r/m64 to left CL places while shifting bits from r64 in from the right.

pub fn shld_Any64BitMemory_Register64Bit_Immediate8Bit(
    &mut self,
    arg0: Any64BitMemory,
    arg1: Register64Bit,
    arg2: Immediate8Bit
)

Shift r/m64 to left imm8 places while shifting bits from r64 in from the right.

pub fn shld_Register16Bit_Register16Bit_CL(
    &mut self,
    arg0: Register16Bit,
    arg1: Register16Bit
)

Shift r/m16 to left CL places while shifting bits from r16 in from the right.

pub fn shld_Register16Bit_Register16Bit_Immediate8Bit(
    &mut self,
    arg0: Register16Bit,
    arg1: Register16Bit,
    arg2: Immediate8Bit
)

Shift r/m16 to left imm8 places while shifting bits from r16 in from the right.

pub fn shld_Register32Bit_Register32Bit_CL(
    &mut self,
    arg0: Register32Bit,
    arg1: Register32Bit
)

Shift r/m32 to left CL places while shifting bits from r32 in from the right.

pub fn shld_Register32Bit_Register32Bit_Immediate8Bit(
    &mut self,
    arg0: Register32Bit,
    arg1: Register32Bit,
    arg2: Immediate8Bit
)

Shift r/m32 to left imm8 places while shifting bits from r32 in from the right.

pub fn shld_Register64Bit_Register64Bit_CL(
    &mut self,
    arg0: Register64Bit,
    arg1: Register64Bit
)

Shift r/m64 to left CL places while shifting bits from r64 in from the right.

pub fn shld_Register64Bit_Register64Bit_Immediate8Bit(
    &mut self,
    arg0: Register64Bit,
    arg1: Register64Bit,
    arg2: Immediate8Bit
)

Shift r/m64 to left imm8 places while shifting bits from r64 in from the right.

pub fn shlx_Register32Bit_Any32BitMemory_Register32Bit(
    &mut self,
    arg0: Register32Bit,
    arg1: Any32BitMemory,
    arg2: Register32Bit
)

Shift r/m32 logically left with count specified in r32b.

pub fn shlx_Register32Bit_Register32Bit_Register32Bit(
    &mut self,
    arg0: Register32Bit,
    arg1: Register32Bit,
    arg2: Register32Bit
)

Shift r/m32 logically left with count specified in r32b.

pub fn shlx_Register64Bit_Any64BitMemory_Register64Bit(
    &mut self,
    arg0: Register64Bit,
    arg1: Any64BitMemory,
    arg2: Register64Bit
)

Shift r/m64 logically left with count specified in r64b.

pub fn shlx_Register64Bit_Register64Bit_Register64Bit(
    &mut self,
    arg0: Register64Bit,
    arg1: Register64Bit,
    arg2: Register64Bit
)

Shift r/m64 logically left with count specified in r64b.

pub fn shr_Any16BitMemory_CL(&mut self, arg0: Any16BitMemory)

Unsigned divide r/m16 by 2, CL times.

pub fn shr_Any16BitMemory_Immediate8Bit(
    &mut self,
    arg0: Any16BitMemory,
    arg1: Immediate8Bit
)

Unsigned divide r/m16 by 2, imm8 times.

pub fn shr_Any16BitMemory_One(&mut self, arg0: Any16BitMemory)

Unsigned divide r/m16 by 2, once.

pub fn shr_Any32BitMemory_CL(&mut self, arg0: Any32BitMemory)

Unsigned divide r/m32 by 2, CL times.

pub fn shr_Any32BitMemory_Immediate8Bit(
    &mut self,
    arg0: Any32BitMemory,
    arg1: Immediate8Bit
)

Unsigned divide r/m32 by 2, imm8 times.

pub fn shr_Any32BitMemory_One(&mut self, arg0: Any32BitMemory)

Unsigned divide r/m32 by 2, once.

pub fn shr_Any64BitMemory_CL(&mut self, arg0: Any64BitMemory)

Unsigned divide r/m32 by 2, CL times.

pub fn shr_Any64BitMemory_Immediate8Bit(
    &mut self,
    arg0: Any64BitMemory,
    arg1: Immediate8Bit
)

Unsigned divide r/m32 by 2, imm8 times.

pub fn shr_Any64BitMemory_One(&mut self, arg0: Any64BitMemory)

Unsigned divide r/m32 by 2, once.

pub fn shr_Any8BitMemory_CL(&mut self, arg0: Any8BitMemory)

Unsigned divide r/m8 by 2, CL times.

pub fn shr_Any8BitMemory_Immediate8Bit(
    &mut self,
    arg0: Any8BitMemory,
    arg1: Immediate8Bit
)

Unsigned divide r/m8 by 2, imm8 times.

pub fn shr_Any8BitMemory_One(&mut self, arg0: Any8BitMemory)

Unsigned divide r/m8 by 2, once.

pub fn shr_Register16Bit_CL(&mut self, arg0: Register16Bit)

Unsigned divide r/m16 by 2, CL times.

pub fn shr_Register16Bit_Immediate8Bit(
    &mut self,
    arg0: Register16Bit,
    arg1: Immediate8Bit
)

Unsigned divide r/m16 by 2, imm8 times.

pub fn shr_Register16Bit_One(&mut self, arg0: Register16Bit)

Unsigned divide r/m16 by 2, once.

pub fn shr_Register32Bit_CL(&mut self, arg0: Register32Bit)

Unsigned divide r/m32 by 2, CL times.

pub fn shr_Register32Bit_Immediate8Bit(
    &mut self,
    arg0: Register32Bit,
    arg1: Immediate8Bit
)

Unsigned divide r/m32 by 2, imm8 times.

pub fn shr_Register32Bit_One(&mut self, arg0: Register32Bit)

Unsigned divide r/m32 by 2, once.

pub fn shr_Register64Bit_CL(&mut self, arg0: Register64Bit)

Unsigned divide r/m32 by 2, CL times.

pub fn shr_Register64Bit_Immediate8Bit(
    &mut self,
    arg0: Register64Bit,
    arg1: Immediate8Bit
)

Unsigned divide r/m32 by 2, imm8 times.

pub fn shr_Register64Bit_One(&mut self, arg0: Register64Bit)

Unsigned divide r/m32 by 2, once.

pub fn shr_Register8Bit_CL(&mut self, arg0: Register8Bit)

Unsigned divide r/m8 by 2, CL times.

pub fn shr_Register8Bit_Immediate8Bit(
    &mut self,
    arg0: Register8Bit,
    arg1: Immediate8Bit
)

Unsigned divide r/m8 by 2, imm8 times.

pub fn shr_Register8Bit_One(&mut self, arg0: Register8Bit)

Unsigned divide r/m8 by 2, once.

pub fn shr_RegisterHigh8BitsOf16Bits_CL(
    &mut self,
    arg0: RegisterHigh8BitsOf16Bits
)

Unsigned divide r/m8 by 2, CL times.

pub fn shr_RegisterHigh8BitsOf16Bits_Immediate8Bit(
    &mut self,
    arg0: RegisterHigh8BitsOf16Bits,
    arg1: Immediate8Bit
)

Unsigned divide r/m8 by 2, imm8 times.

pub fn shr_RegisterHigh8BitsOf16Bits_One(
    &mut self,
    arg0: RegisterHigh8BitsOf16Bits
)

Unsigned divide r/m8 by 2, once.

pub fn shrd_Any16BitMemory_Register16Bit_CL(
    &mut self,
    arg0: Any16BitMemory,
    arg1: Register16Bit
)

Shift r/m16 to right CL places while shifting bits from r16 in from the left.

pub fn shrd_Any16BitMemory_Register16Bit_Immediate8Bit(
    &mut self,
    arg0: Any16BitMemory,
    arg1: Register16Bit,
    arg2: Immediate8Bit
)

Shift r/m16 to right imm8 places while shifting bits from r16 in from the left.

pub fn shrd_Any32BitMemory_Register32Bit_CL(
    &mut self,
    arg0: Any32BitMemory,
    arg1: Register32Bit
)

Shift r/m32 to right CL places while shifting bits from r32 in from the left.

pub fn shrd_Any32BitMemory_Register32Bit_Immediate8Bit(
    &mut self,
    arg0: Any32BitMemory,
    arg1: Register32Bit,
    arg2: Immediate8Bit
)

Shift r/m32 to right imm8 places while shifting bits from r32 in from the left.

pub fn shrd_Any64BitMemory_Register64Bit_CL(
    &mut self,
    arg0: Any64BitMemory,
    arg1: Register64Bit
)

Shift r/m64 to right CL places while shifting bits from r64 in from the left.

pub fn shrd_Any64BitMemory_Register64Bit_Immediate8Bit(
    &mut self,
    arg0: Any64BitMemory,
    arg1: Register64Bit,
    arg2: Immediate8Bit
)

Shift r/m64 to right imm8 places while shifting bits from r64 in from the left.

pub fn shrd_Register16Bit_Register16Bit_CL(
    &mut self,
    arg0: Register16Bit,
    arg1: Register16Bit
)

Shift r/m16 to right CL places while shifting bits from r16 in from the left.

pub fn shrd_Register16Bit_Register16Bit_Immediate8Bit(
    &mut self,
    arg0: Register16Bit,
    arg1: Register16Bit,
    arg2: Immediate8Bit
)

Shift r/m16 to right imm8 places while shifting bits from r16 in from the left.

pub fn shrd_Register32Bit_Register32Bit_CL(
    &mut self,
    arg0: Register32Bit,
    arg1: Register32Bit
)

Shift r/m32 to right CL places while shifting bits from r32 in from the left.

pub fn shrd_Register32Bit_Register32Bit_Immediate8Bit(
    &mut self,
    arg0: Register32Bit,
    arg1: Register32Bit,
    arg2: Immediate8Bit
)

Shift r/m32 to right imm8 places while shifting bits from r32 in from the left.

pub fn shrd_Register64Bit_Register64Bit_CL(
    &mut self,
    arg0: Register64Bit,
    arg1: Register64Bit
)

Shift r/m64 to right CL places while shifting bits from r64 in from the left.

pub fn shrd_Register64Bit_Register64Bit_Immediate8Bit(
    &mut self,
    arg0: Register64Bit,
    arg1: Register64Bit,
    arg2: Immediate8Bit
)

Shift r/m64 to right imm8 places while shifting bits from r64 in from the left.

pub fn shrx_Register32Bit_Any32BitMemory_Register32Bit(
    &mut self,
    arg0: Register32Bit,
    arg1: Any32BitMemory,
    arg2: Register32Bit
)

Shift r/m32 logically right with count specified in r32b.

pub fn shrx_Register32Bit_Register32Bit_Register32Bit(
    &mut self,
    arg0: Register32Bit,
    arg1: Register32Bit,
    arg2: Register32Bit
)

Shift r/m32 logically right with count specified in r32b.

pub fn shrx_Register64Bit_Any64BitMemory_Register64Bit(
    &mut self,
    arg0: Register64Bit,
    arg1: Any64BitMemory,
    arg2: Register64Bit
)

Shift r/m64 logically right with count specified in r64b.

pub fn shrx_Register64Bit_Register64Bit_Register64Bit(
    &mut self,
    arg0: Register64Bit,
    arg1: Register64Bit,
    arg2: Register64Bit
)

Shift r/m64 logically right with count specified in r64b.

pub fn shufpd_XMMRegister_Any128BitMemory_Immediate8Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory,
    arg2: Immediate8Bit
)

Shuffle packed double-precision floating-point values selected by imm8 from xmm1 and xmm2/m128 to xmm1.

pub fn shufpd_XMMRegister_XMMRegister_Immediate8Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Immediate8Bit
)

Shuffle packed double-precision floating-point values selected by imm8 from xmm1 and xmm2/m128 to xmm1.

pub fn shufps_XMMRegister_Any128BitMemory_Immediate8Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory,
    arg2: Immediate8Bit
)

Shuffle packed single-precision floating-point values selected by imm8 from xmm1 and xmm1/m128 to xmm1.

pub fn shufps_XMMRegister_XMMRegister_Immediate8Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Immediate8Bit
)

Shuffle packed single-precision floating-point values selected by imm8 from xmm1 and xmm1/m128 to xmm1.

pub fn sqrtpd_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Computes square roots of the packed double-precision floating-point values in xmm2/m128 and stores the results in xmm1.

pub fn sqrtpd_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Computes square roots of the packed double-precision floating-point values in xmm2/m128 and stores the results in xmm1.

pub fn sqrtps_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Computes square roots of the packed single-precision floating-point values in xmm2/m128 and stores the results in xmm1.

pub fn sqrtps_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Computes square roots of the packed single-precision floating-point values in xmm2/m128 and stores the results in xmm1.

pub fn sqrtsd_XMMRegister_Any64BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any64BitMemory
)

Computes square root of the low double-precision floating-point value in xmm2/m64 and stores the results in xmm1.

pub fn sqrtsd_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Computes square root of the low double-precision floating-point value in xmm2/m64 and stores the results in xmm1.

pub fn sqrtss_XMMRegister_Any32BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any32BitMemory
)

Computes square root of the low single-precision floating-point value in xmm2/m32 and stores the results in xmm1.

pub fn sqrtss_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Computes square root of the low single-precision floating-point value in xmm2/m32 and stores the results in xmm1.

pub fn stc(&mut self)

Set Carry Flag (CF).

pub fn std(&mut self)

Set Direction Flag (DF).

pub fn sti(&mut self)

Set interrupt flag.

External, maskable interrupts are enabled at the end of the next instruction.

pub fn stmxcsr_Any32BitMemory(&mut self, arg0: Any32BitMemory)

Store contents of MXCSR register to m32.

pub fn stos_Any16BitMemory(
    &mut self,
    arg0: Option<SegmentRegister>,
    address_override_for_32_bit: bool
)

For legacy mode, store AX at address ES:(E)DI.

For 64-bit mode store AX at address RDI or EDI.

pub fn stos_Any32BitMemory(
    &mut self,
    arg0: Option<SegmentRegister>,
    address_override_for_32_bit: bool
)

For legacy mode, store EAX at address ES:(E)DI.

For 64-bit mode store EAX at address RDI or EDI.

pub fn stos_Any64BitMemory(
    &mut self,
    arg0: Option<SegmentRegister>,
    address_override_for_32_bit: bool
)

Store RAX at address RDI or EDI.

pub fn stos_Any8BitMemory(
    &mut self,
    arg0: Option<SegmentRegister>,
    address_override_for_32_bit: bool
)

For legacy mode, store AL at address ES:(E)DI.

For 64-bit mode store AL at address RDI or EDI.

pub fn stosb(&mut self)

For legacy mode, store AL at address ES:(E)DI.

For 64-bit mode store AL at address RDI or EDI.

pub fn stosd(&mut self)

For legacy mode, store EAX at address ES:(E)DI

For 64-bit mode store EAX at address RDI or EDI.

pub fn stosq(&mut self)

Store RAX at address RDI or EDI.

pub fn stosw(&mut self)

For legacy mode, store AX at address ES:(E)DI.

For 64-bit mode store AX at address RDI or EDI.

pub fn sub_AL_Immediate8Bit(&mut self, arg1: Immediate8Bit)

Subtract imm8 from AL.

pub fn sub_AX_Immediate16Bit(&mut self, arg1: Immediate16Bit)

Subtract imm16 from AX.

pub fn sub_EAX_Immediate32Bit(&mut self, arg1: Immediate32Bit)

Subtract imm32 from EAX.

pub fn sub_Any16BitMemory_Immediate16Bit(
    &mut self,
    arg0: Any16BitMemory,
    arg1: Immediate16Bit
)

Subtract imm16 from r/m16.

pub fn sub_Any16BitMemory_Immediate8Bit(
    &mut self,
    arg0: Any16BitMemory,
    arg1: Immediate8Bit
)

Subtract sign-extended imm8 from r/m16.

pub fn sub_Any16BitMemory_Register16Bit(
    &mut self,
    arg0: Any16BitMemory,
    arg1: Register16Bit
)

Subtract r16 from r/m16.

pub fn sub_Any32BitMemory_Immediate32Bit(
    &mut self,
    arg0: Any32BitMemory,
    arg1: Immediate32Bit
)

Subtract imm32 from r/m32.

pub fn sub_Any32BitMemory_Immediate8Bit(
    &mut self,
    arg0: Any32BitMemory,
    arg1: Immediate8Bit
)

Subtract sign-extended imm8 from r/m32.

pub fn sub_Any32BitMemory_Register32Bit(
    &mut self,
    arg0: Any32BitMemory,
    arg1: Register32Bit
)

Subtract r32 from r/m32.

pub fn sub_Any64BitMemory_Immediate32Bit(
    &mut self,
    arg0: Any64BitMemory,
    arg1: Immediate32Bit
)

Subtract imm32 sign-extended to 64-bits from r/m64.

pub fn sub_Any64BitMemory_Immediate8Bit(
    &mut self,
    arg0: Any64BitMemory,
    arg1: Immediate8Bit
)

Subtract sign-extended imm8 from r/m64.

pub fn sub_Any64BitMemory_Register64Bit(
    &mut self,
    arg0: Any64BitMemory,
    arg1: Register64Bit
)

Subtract r64 from r/m64.

pub fn sub_Any8BitMemory_Immediate8Bit(
    &mut self,
    arg0: Any8BitMemory,
    arg1: Immediate8Bit
)

Subtract imm8 from r/m8.

pub fn sub_Any8BitMemory_Register8Bit(
    &mut self,
    arg0: Any8BitMemory,
    arg1: Register8Bit
)

Subtract r8 from r/m8.

pub fn sub_Any8BitMemory_RegisterHigh8BitsOf16Bits(
    &mut self,
    arg0: Any8BitMemory,
    arg1: RegisterHigh8BitsOf16Bits
)

Subtract r8 from r/m8.

pub fn sub_Register16Bit_Immediate16Bit(
    &mut self,
    arg0: Register16Bit,
    arg1: Immediate16Bit
)

Subtract imm16 from r/m16.

pub fn sub_Register16Bit_Immediate8Bit(
    &mut self,
    arg0: Register16Bit,
    arg1: Immediate8Bit
)

Subtract sign-extended imm8 from r/m16.

pub fn sub_Register16Bit_Any16BitMemory(
    &mut self,
    arg0: Register16Bit,
    arg1: Any16BitMemory
)

Subtract r/m16 from r16.

pub fn sub_Register16Bit_Register16Bit(
    &mut self,
    arg0: Register16Bit,
    arg1: Register16Bit
)

Subtract r16 from r/m16.

pub fn sub_Register16Bit_Register16Bit_1(
    &mut self,
    arg0: Register16Bit,
    arg1: Register16Bit
)

Subtract r/m16 from r16.

pub fn sub_Register32Bit_Immediate32Bit(
    &mut self,
    arg0: Register32Bit,
    arg1: Immediate32Bit
)

Subtract imm32 from r/m32.

pub fn sub_Register32Bit_Immediate8Bit(
    &mut self,
    arg0: Register32Bit,
    arg1: Immediate8Bit
)

Subtract sign-extended imm8 from r/m32.

pub fn sub_Register32Bit_Any32BitMemory(
    &mut self,
    arg0: Register32Bit,
    arg1: Any32BitMemory
)

Subtract r/m32 from r32.

pub fn sub_Register32Bit_Register32Bit(
    &mut self,
    arg0: Register32Bit,
    arg1: Register32Bit
)

Subtract r32 from r/m32.

pub fn sub_Register32Bit_Register32Bit_1(
    &mut self,
    arg0: Register32Bit,
    arg1: Register32Bit
)

Subtract r/m32 from r32.

pub fn sub_Register64Bit_Immediate32Bit(
    &mut self,
    arg0: Register64Bit,
    arg1: Immediate32Bit
)

Subtract imm32 sign-extended to 64-bits from r/m64.

pub fn sub_Register64Bit_Immediate8Bit(
    &mut self,
    arg0: Register64Bit,
    arg1: Immediate8Bit
)

Subtract sign-extended imm8 from r/m64.

pub fn sub_Register64Bit_Any64BitMemory(
    &mut self,
    arg0: Register64Bit,
    arg1: Any64BitMemory
)

Subtract r/m64 from r64.

pub fn sub_Register64Bit_Register64Bit(
    &mut self,
    arg0: Register64Bit,
    arg1: Register64Bit
)

Subtract r64 from r/m64.

pub fn sub_Register64Bit_Register64Bit_1(
    &mut self,
    arg0: Register64Bit,
    arg1: Register64Bit
)

Subtract r/m64 from r64.

pub fn sub_Register8Bit_Immediate8Bit(
    &mut self,
    arg0: Register8Bit,
    arg1: Immediate8Bit
)

Subtract imm8 from r/m8.

pub fn sub_Register8Bit_Any8BitMemory(
    &mut self,
    arg0: Register8Bit,
    arg1: Any8BitMemory
)

Subtract r/m8 from r8.

pub fn sub_Register8Bit_Register8Bit(
    &mut self,
    arg0: Register8Bit,
    arg1: Register8Bit
)

Subtract r8 from r/m8.

pub fn sub_Register8Bit_Register8Bit_1(
    &mut self,
    arg0: Register8Bit,
    arg1: Register8Bit
)

Subtract r/m8 from r8.

pub fn sub_Register8Bit_RegisterHigh8BitsOf16Bits(
    &mut self,
    arg0: Register8Bit,
    arg1: RegisterHigh8BitsOf16Bits
)

Subtract r8 from r/m8.

pub fn sub_Register8Bit_RegisterHigh8BitsOf16Bits_1(
    &mut self,
    arg0: Register8Bit,
    arg1: RegisterHigh8BitsOf16Bits
)

Subtract r/m8 from r8.

pub fn sub_RAX_Immediate32Bit(&mut self, arg1: Immediate32Bit)

Subtract imm32 sign-extended to 64-bits from RAX.

pub fn sub_RegisterHigh8BitsOf16Bits_Immediate8Bit(
    &mut self,
    arg0: RegisterHigh8BitsOf16Bits,
    arg1: Immediate8Bit
)

Subtract imm8 from r/m8.

pub fn sub_RegisterHigh8BitsOf16Bits_Any8BitMemory(
    &mut self,
    arg0: RegisterHigh8BitsOf16Bits,
    arg1: Any8BitMemory
)

Subtract r/m8 from r8.

pub fn sub_RegisterHigh8BitsOf16Bits_Register8Bit(
    &mut self,
    arg0: RegisterHigh8BitsOf16Bits,
    arg1: Register8Bit
)

Subtract r8 from r/m8.

pub fn sub_RegisterHigh8BitsOf16Bits_Register8Bit_1(
    &mut self,
    arg0: RegisterHigh8BitsOf16Bits,
    arg1: Register8Bit
)

Subtract r/m8 from r8.

pub fn sub_RegisterHigh8BitsOf16Bits_RegisterHigh8BitsOf16Bits(
    &mut self,
    arg0: RegisterHigh8BitsOf16Bits,
    arg1: RegisterHigh8BitsOf16Bits
)

Subtract r8 from r/m8.

pub fn sub_RegisterHigh8BitsOf16Bits_RegisterHigh8BitsOf16Bits_1(
    &mut self,
    arg0: RegisterHigh8BitsOf16Bits,
    arg1: RegisterHigh8BitsOf16Bits
)

Subtract r/m8 from r8.

pub fn subpd_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Subtract packed double-precision floating-point values in xmm2/m128 from xmm1.

pub fn subpd_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Subtract packed double-precision floating-point values in xmm2/m128 from xmm1.

pub fn subps_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Subtract packed single-precision floating-point values in xmm2/mem from xmm1.

pub fn subps_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Subtract packed single-precision floating-point values in xmm2/mem from xmm1.

pub fn subsd_XMMRegister_Any64BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any64BitMemory
)

Subtracts the low double-precision floating-point values in xmm2/mem64 from xmm1.

pub fn subsd_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Subtracts the low double-precision floating-point values in xmm2/mem64 from xmm1.

pub fn subss_XMMRegister_Any32BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any32BitMemory
)

Subtract the lower single-precision floating-point values in xmm2/m32 from xmm1.

pub fn subss_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Subtract the lower single-precision floating-point values in xmm2/m32 from xmm1.

pub fn swapgs(&mut self)

Exchanges the current GS base register value with the value contained in MSR address 0xC0000102.

pub fn syscall(&mut self)

Fast call to privilege level 0 system procedures.

pub fn sysenter(&mut self)

Fast call to privilege level 0 system procedures.

pub fn sysexit(&mut self)

Fast return to privilege level 3 user code.

pub fn sysexit_PrefixRexW(&mut self)

Fast return to 64-bit mode privilege level 3 user code.

pub fn sysret(&mut self)

Return to compatibility mode from fast system call.

pub fn sysret_PrefixRexW(&mut self)

Return to 64-bit mode from fast system call.

pub fn test_AL_Immediate8Bit(&mut self, arg1: Immediate8Bit)

AND imm8 with AL.

The Sign Flag (SF), Zero Flag (ZF) and Parity Flag (PF) are each potentially set.

pub fn test_AX_Immediate16Bit(&mut self, arg1: Immediate16Bit)

AND imm16 with AX.

The Sign Flag (SF), Zero Flag (ZF) and Parity Flag (PF) are each potentially set.

pub fn test_EAX_Immediate32Bit(&mut self, arg1: Immediate32Bit)

AND imm32 with EAX.

The Sign Flag (SF), Zero Flag (ZF) and Parity Flag (PF) are each potentially set.

pub fn test_Any16BitMemory_Immediate16Bit(
    &mut self,
    arg0: Any16BitMemory,
    arg1: Immediate16Bit
)

AND imm16 with r/m16.

The Sign Flag (SF), Zero Flag (ZF) and Parity Flag (PF) are each potentially set.

pub fn test_Any16BitMemory_Register16Bit(
    &mut self,
    arg0: Any16BitMemory,
    arg1: Register16Bit
)

AND r16 with r/m16.

The Sign Flag (SF), Zero Flag (ZF) and Parity Flag (PF) are each potentially set.

pub fn test_Any32BitMemory_Immediate32Bit(
    &mut self,
    arg0: Any32BitMemory,
    arg1: Immediate32Bit
)

AND imm32 with r/m32.

The Sign Flag (SF), Zero Flag (ZF) and Parity Flag (PF) are each potentially set.

pub fn test_Any32BitMemory_Register32Bit(
    &mut self,
    arg0: Any32BitMemory,
    arg1: Register32Bit
)

AND r32 with r/m32.

The Sign Flag (SF), Zero Flag (ZF) and Parity Flag (PF) are each potentially set.

pub fn test_Any64BitMemory_Immediate32Bit(
    &mut self,
    arg0: Any64BitMemory,
    arg1: Immediate32Bit
)

AND imm32 sign-extended to 64-bits with r/m64.

The Sign Flag (SF), Zero Flag (ZF) and Parity Flag (PF) are each potentially set.

pub fn test_Any64BitMemory_Register64Bit(
    &mut self,
    arg0: Any64BitMemory,
    arg1: Register64Bit
)

AND r64 with r/m64.

The Sign Flag (SF), Zero Flag (ZF) and Parity Flag (PF) are each potentially set.

pub fn test_Any8BitMemory_Immediate8Bit(
    &mut self,
    arg0: Any8BitMemory,
    arg1: Immediate8Bit
)

AND imm8 with r/m8.

The Sign Flag (SF), Zero Flag (ZF) and Parity Flag (PF) are each potentially set.

pub fn test_Any8BitMemory_Register8Bit(
    &mut self,
    arg0: Any8BitMemory,
    arg1: Register8Bit
)

AND r8 with r/m8.

The Sign Flag (SF), Zero Flag (ZF) and Parity Flag (PF) are each potentially set.

pub fn test_Any8BitMemory_RegisterHigh8BitsOf16Bits(
    &mut self,
    arg0: Any8BitMemory,
    arg1: RegisterHigh8BitsOf16Bits
)

AND r8 with r/m8.

The Sign Flag (SF), Zero Flag (ZF) and Parity Flag (PF) are each potentially set.

pub fn test_Register16Bit_Immediate16Bit(
    &mut self,
    arg0: Register16Bit,
    arg1: Immediate16Bit
)

AND imm16 with r/m16.

The Sign Flag (SF), Zero Flag (ZF) and Parity Flag (PF) are each potentially set.

pub fn test_Register16Bit_Register16Bit(
    &mut self,
    arg0: Register16Bit,
    arg1: Register16Bit
)

AND r16 with r/m16.

The Sign Flag (SF), Zero Flag (ZF) and Parity Flag (PF) are each potentially set.

pub fn test_Register32Bit_Immediate32Bit(
    &mut self,
    arg0: Register32Bit,
    arg1: Immediate32Bit
)

AND imm32 with r/m32.

The Sign Flag (SF), Zero Flag (ZF) and Parity Flag (PF) are each potentially set.

pub fn test_Register32Bit_Register32Bit(
    &mut self,
    arg0: Register32Bit,
    arg1: Register32Bit
)

AND r32 with r/m32.

The Sign Flag (SF), Zero Flag (ZF) and Parity Flag (PF) are each potentially set.

pub fn test_Register64Bit_Immediate32Bit(
    &mut self,
    arg0: Register64Bit,
    arg1: Immediate32Bit
)

AND imm32 sign-extended to 64-bits with r/m64.

The Sign Flag (SF), Zero Flag (ZF) and Parity Flag (PF) are each potentially set.

pub fn test_Register64Bit_Register64Bit(
    &mut self,
    arg0: Register64Bit,
    arg1: Register64Bit
)

AND r64 with r/m64.

The Sign Flag (SF), Zero Flag (ZF) and Parity Flag (PF) are each potentially set.

pub fn test_Register8Bit_Immediate8Bit(
    &mut self,
    arg0: Register8Bit,
    arg1: Immediate8Bit
)

AND imm8 with r/m8.

The Sign Flag (SF), Zero Flag (ZF) and Parity Flag (PF) are each potentially set.

pub fn test_Register8Bit_Register8Bit(
    &mut self,
    arg0: Register8Bit,
    arg1: Register8Bit
)

AND r8 with r/m8.

The Sign Flag (SF), Zero Flag (ZF) and Parity Flag (PF) are each potentially set.

pub fn test_Register8Bit_RegisterHigh8BitsOf16Bits(
    &mut self,
    arg0: Register8Bit,
    arg1: RegisterHigh8BitsOf16Bits
)

AND r8 with r/m8.

The Sign Flag (SF), Zero Flag (ZF) and Parity Flag (PF) are each potentially set.

pub fn test_RAX_Immediate32Bit(&mut self, arg1: Immediate32Bit)

AND imm32 sign-extended to 64-bits with RAX.

The Sign Flag (SF), Zero Flag (ZF) and Parity Flag (PF) are each potentially set.

pub fn test_RegisterHigh8BitsOf16Bits_Immediate8Bit(
    &mut self,
    arg0: RegisterHigh8BitsOf16Bits,
    arg1: Immediate8Bit
)

AND imm8 with r/m8.

The Sign Flag (SF), Zero Flag (ZF) and Parity Flag (PF) are each potentially set.

pub fn test_RegisterHigh8BitsOf16Bits_Register8Bit(
    &mut self,
    arg0: RegisterHigh8BitsOf16Bits,
    arg1: Register8Bit
)

AND r8 with r/m8.

The Sign Flag (SF), Zero Flag (ZF) and Parity Flag (PF) are each potentially set.

pub fn test_RegisterHigh8BitsOf16Bits_RegisterHigh8BitsOf16Bits(
    &mut self,
    arg0: RegisterHigh8BitsOf16Bits,
    arg1: RegisterHigh8BitsOf16Bits
)

AND r8 with r/m8.

The Sign Flag (SF), Zero Flag (ZF) and Parity Flag (PF) are each potentially set.

pub fn tzcnt_Register16Bit_Any16BitMemory(
    &mut self,
    arg0: Register16Bit,
    arg1: Any16BitMemory
)

Count the number of trailing zero bits in r/m16 and return result in r16.

pub fn tzcnt_Register16Bit_Register16Bit(
    &mut self,
    arg0: Register16Bit,
    arg1: Register16Bit
)

Count the number of trailing zero bits in r/m16 and return result in r16.

pub fn tzcnt_Register32Bit_Any32BitMemory(
    &mut self,
    arg0: Register32Bit,
    arg1: Any32BitMemory
)

Count the number of trailing zero bits in r/m32 and return result in r32.

pub fn tzcnt_Register32Bit_Register32Bit(
    &mut self,
    arg0: Register32Bit,
    arg1: Register32Bit
)

Count the number of trailing zero bits in r/m32 and return result in r32.

pub fn tzcnt_Register64Bit_Any64BitMemory(
    &mut self,
    arg0: Register64Bit,
    arg1: Any64BitMemory
)

Count the number of trailing zero bits in r/m64 and return result in r64.

pub fn tzcnt_Register64Bit_Register64Bit(
    &mut self,
    arg0: Register64Bit,
    arg1: Register64Bit
)

Count the number of trailing zero bits in r/m64 and return result in r64.

pub fn ucomisd_XMMRegister_Any64BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any64BitMemory
)

Compares (unordered) the low double-precision floating-point values in xmm1 and xmm2/m64 and sets the appropriate flags in EFLAGS accordingly.

pub fn ucomisd_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Compares (unordered) the low double-precision floating-point values in xmm1 and xmm2/m64 and sets the appropriate flags in EFLAGS accordingly.

pub fn ucomiss_XMMRegister_Any32BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any32BitMemory
)

Compare lower single-precision floating-point value in xmm1 register with lower single-precision floating-point value in xmm2/mem and set the status flags accordingly.

pub fn ucomiss_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Compare lower single-precision floating-point value in xmm1 register with lower single-precision floating-point value in xmm2/mem and set the status flags accordingly.

pub fn ud2(&mut self)

Raise invalid opcode exception (‘Undefined 2’).

pub fn unpckhpd_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Unpacks and Interleaves double-precision floating-point values from high quadwords of xmm1 and xmm2/m128.

pub fn unpckhpd_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Unpacks and Interleaves double-precision floating-point values from high quadwords of xmm1 and xmm2/m128.

pub fn unpckhps_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Unpacks and Interleaves single-precision floating-point values from high quadwords of xmm1 and xmm2/mem into xmm1.

pub fn unpckhps_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Unpacks and Interleaves single-precision floating-point values from high quadwords of xmm1 and xmm2/mem into xmm1.

pub fn unpcklpd_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Unpacks and Interleaves double-precision floating-point values from low quadwords of xmm1 and xmm2/m128.

pub fn unpcklpd_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Unpacks and Interleaves double-precision floating-point values from low quadwords of xmm1 and xmm2/m128.

pub fn unpcklps_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Unpacks and Interleaves single-precision floating-point values from low quadwords of xmm1 and xmm2/mem into xmm1.

pub fn unpcklps_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Unpacks and Interleaves single-precision floating-point values from low quadwords of xmm1 and xmm2/mem into xmm1.

pub fn vaddpd_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Add packed double-precision floating-point values from xmm3/mem to xmm2 and stores result in xmm1.

pub fn vaddpd_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Add packed double-precision floating-point values from xmm3/mem to xmm2 and stores result in xmm1.

pub fn vaddpd_YMM_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory
)

Add packed double-precision floating-point values from ymm3/mem to ymm2 and stores result in ymm1.

pub fn vaddpd_YMM_YMM_YMM(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister
)

Add packed double-precision floating-point values from ymm3/mem to ymm2 and stores result in ymm1.

pub fn vaddps_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Add packed single-precision floating-point values from xmm3/mem to xmm2 and stores result in xmm1.

pub fn vaddps_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Add packed single-precision floating-point values from xmm3/mem to xmm2 and stores result in xmm1.

pub fn vaddps_YMM_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory
)

Add packed single-precision floating-point values from ymm3/mem to ymm2 and stores result in ymm1.

pub fn vaddps_YMM_YMM_YMM(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister
)

Add packed single-precision floating-point values from ymm3/mem to ymm2 and stores result in ymm1.

pub fn vaddsd_XMMRegister_XMMRegister_Any64BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any64BitMemory
)

Add the low double-precision floating-point value from xmm3/mem to xmm2 and store the result in xmm1.

pub fn vaddsd_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Add the low double-precision floating-point value from xmm3/mem to xmm2 and store the result in xmm1.

pub fn vaddss_XMMRegister_XMMRegister_Any32BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any32BitMemory
)

Add the low single-precision floating-point value from xmm3/mem to xmm2 and store the result in xmm1.

pub fn vaddss_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Add the low single-precision floating-point value from xmm3/mem to xmm2 and store the result in xmm1.

pub fn vaddsubpd_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Add/subtract packed double-precision floating-point values from xmm3/mem to xmm2 and stores result in xmm1.

pub fn vaddsubpd_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Add/subtract packed double-precision floating-point values from xmm3/mem to xmm2 and stores result in xmm1.

pub fn vaddsubpd_YMM_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory
)

Add / subtract packed double-precision floating-point values from ymm3/mem to ymm2 and stores result in ymm1.

pub fn vaddsubpd_YMM_YMM_YMM(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister
)

Add / subtract packed double-precision floating-point values from ymm3/mem to ymm2 and stores result in ymm1.

pub fn vaddsubps_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Add/subtract single-precision floating-point values from xmm3/mem to xmm2 and stores result in xmm1.

pub fn vaddsubps_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Add/subtract single-precision floating-point values from xmm3/mem to xmm2 and stores result in xmm1.

pub fn vaddsubps_YMM_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory
)

Add / subtract single-precision floating-point values from ymm3/mem to ymm2 and stores result in ymm1.

pub fn vaddsubps_YMM_YMM_YMM(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister
)

Add / subtract single-precision floating-point values from ymm3/mem to ymm2 and stores result in ymm1.

pub fn vaesdec_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Perform one round of an AES decryption flow, using the Equivalent Inverse Cipher, operating on a 128-bit data (state) from xmm2 with a 128-bit round key from xmm3/m128.

Stores the result in xmm1.

pub fn vaesdec_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Perform one round of an AES decryption flow, using the Equivalent Inverse Cipher, operating on a 128-bit data (state) from xmm2 with a 128-bit round key from xmm3/m128.

Stores the result in xmm1.

pub fn vaesdeclast_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Perform the last round of an AES decryption flow, using the Equivalent Inverse Cipher, operating on a 128-bit data (state) from xmm2 with a 128-bit round key from xmm3/m128.

Stores the result in xmm1.

pub fn vaesdeclast_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Perform the last round of an AES decryption flow, using the Equivalent Inverse Cipher, operating on a 128-bit data (state) from xmm2 with a 128-bit round key from xmm3/m128.

Stores the result in xmm1.

pub fn vaesenc_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Perform one round of an AES encryption flow, operating on a 128-bit data (state) from xmm2 with a 128-bit round key from the xmm3/m128.

Stores the result in xmm1.

pub fn vaesenc_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Perform one round of an AES encryption flow, operating on a 128-bit data (state) from xmm2 with a 128-bit round key from the xmm3/m128.

Stores the result in xmm1.

pub fn vaesenclast_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Perform the last round of an AES encryption flow, operating on a 128-bit data (state) from xmm2 with a 128 bit round key from xmm3/m128.

Stores the result in xmm1.

pub fn vaesenclast_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Perform the last round of an AES encryption flow, operating on a 128-bit data (state) from xmm2 with a 128 bit round key from xmm3/m128.

Stores the result in xmm1.

pub fn vaesimc_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Perform the InvMixColumn transformation on a 128-bit round key from xmm2/m128 and store the result in xmm1.

pub fn vaesimc_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Perform the InvMixColumn transformation on a 128-bit round key from xmm2/m128 and store the result in xmm1.

pub fn vaeskeygenassist_XMMRegister_Any128BitMemory_Immediate8Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory,
    arg2: Immediate8Bit
)

Assist in AES round key generation using 8 bits Round Constant (RCON) specified in the imm8, operating on 128 bits of data specified in xmm2/m128 and stores the result in xmm1.

pub fn vaeskeygenassist_XMMRegister_XMMRegister_Immediate8Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Immediate8Bit
)

Assist in AES round key generation using 8 bits Round Constant (RCON) specified in the imm8, operating on 128 bits of data specified in xmm2/m128 and stores the result in xmm1.

pub fn vandnpd_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Return the bitwise logical AND NOT of packed double-precision floating-point values in xmm2 and xmm3/mem.

pub fn vandnpd_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Return the bitwise logical AND NOT of packed double-precision floating-point values in xmm2 and xmm3/mem.

pub fn vandnpd_YMM_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory
)

Return the bitwise logical AND NOT of packed double-precision floating-point values in ymm2 and ymm3/mem.

pub fn vandnpd_YMM_YMM_YMM(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister
)

Return the bitwise logical AND NOT of packed double-precision floating-point values in ymm2 and ymm3/mem.

pub fn vandnps_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Return the bitwise logical AND NOT of packed single-precision floating-point values in xmm2 and xmm3/mem.

pub fn vandnps_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Return the bitwise logical AND NOT of packed single-precision floating-point values in xmm2 and xmm3/mem.

pub fn vandnps_YMM_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory
)

Return the bitwise logical AND NOT of packed single-precision floating-point values in ymm2 and ymm3/mem.

pub fn vandnps_YMM_YMM_YMM(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister
)

Return the bitwise logical AND NOT of packed single-precision floating-point values in ymm2 and ymm3/mem.

pub fn vandpd_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Return the bitwise logical AND of packed double-precision floating-point values in xmm2 and xmm3/mem.

pub fn vandpd_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Return the bitwise logical AND of packed double-precision floating-point values in xmm2 and xmm3/mem.

pub fn vandpd_YMM_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory
)

Return the bitwise logical AND of packed double-precision floating-point values in ymm2 and ymm3/mem.

pub fn vandpd_YMM_YMM_YMM(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister
)

Return the bitwise logical AND of packed double-precision floating-point values in ymm2 and ymm3/mem.

pub fn vandps_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Return the bitwise logical AND of packed single-precision floating-point values in xmm2 and xmm3/mem.

pub fn vandps_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Return the bitwise logical AND of packed single-precision floating-point values in xmm2 and xmm3/mem.

pub fn vandps_YMM_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory
)

Return the bitwise logical AND of packed single-precision floating-point values in ymm2 and ymm3/mem.

pub fn vandps_YMM_YMM_YMM(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister
)

Return the bitwise logical AND of packed single-precision floating-point values in ymm2 and ymm3/mem.

pub fn vblendpd_XMMRegister_XMMRegister_Any128BitMemory_Immediate8Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory,
    arg3: Immediate8Bit
)

Select packed double-precision floating-point values from xmm2 and xmm3/m128 from mask in imm8 and store the values in xmm1.

pub fn vblendpd_XMMRegister_XMMRegister_XMMRegister_Immediate8Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister,
    arg3: Immediate8Bit
)

Select packed double-precision floating-point values from xmm2 and xmm3/m128 from mask in imm8 and store the values in xmm1.

pub fn vblendpd_YMM_YMM_Any256BitMemory_Immediate8Bit(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory,
    arg3: Immediate8Bit
)

Select packed double-precision floating-point values from ymm2 and ymm3/m256 from mask in imm8 and store the values in ymm1.

pub fn vblendpd_YMM_YMM_YMM_Immediate8Bit(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister,
    arg3: Immediate8Bit
)

Select packed double-precision floating-point values from ymm2 and ymm3/m256 from mask in imm8 and store the values in ymm1.

pub fn vblendps_XMMRegister_XMMRegister_Any128BitMemory_Immediate8Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory,
    arg3: Immediate8Bit
)

Select packed single-precision floating-point values from xmm2 and xmm3/m128 from mask in imm8 and store the values in xmm1.

pub fn vblendps_XMMRegister_XMMRegister_XMMRegister_Immediate8Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister,
    arg3: Immediate8Bit
)

Select packed single-precision floating-point values from xmm2 and xmm3/m128 from mask in imm8 and store the values in xmm1.

pub fn vblendps_YMM_YMM_Any256BitMemory_Immediate8Bit(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory,
    arg3: Immediate8Bit
)

Select packed single-precision floating-point values from ymm2 and ymm3/m256 from mask in imm8 and store the values in ymm1.

pub fn vblendps_YMM_YMM_YMM_Immediate8Bit(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister,
    arg3: Immediate8Bit
)

Select packed single-precision floating-point values from ymm2 and ymm3/m256 from mask in imm8 and store the values in ymm1.

pub fn vblendvpd_XMMRegister_XMMRegister_Any128BitMemory_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory,
    arg3: XMMRegister
)

Conditionally copy double-precision floating-point values from xmm2 or xmm3/m128 to xmm1, based on mask bits in the mask operand, xmm4.

pub fn vblendvpd_XMMRegister_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister,
    arg3: XMMRegister
)

Conditionally copy double-precision floating-point values from xmm2 or xmm3/m128 to xmm1, based on mask bits in the mask operand, xmm4.

pub fn vblendvpd_YMM_YMM_Any256BitMemory_YMM(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory,
    arg3: YMMRegister
)

Conditionally copy double-precision floating-point values from ymm2 or ymm3/m256 to ymm1, based on mask bits in the mask operand, ymm4.

pub fn vblendvpd_YMM_YMM_YMM_YMM(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister,
    arg3: YMMRegister
)

Conditionally copy double-precision floating-point values from ymm2 or ymm3/m256 to ymm1, based on mask bits in the mask operand, ymm4.

pub fn vblendvps_XMMRegister_XMMRegister_Any128BitMemory_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory,
    arg3: XMMRegister
)

Conditionally copy single-precision floating-point values from xmm2 or xmm3/m128 to xmm1, based on mask bits in the specified mask operand, xmm4.

pub fn vblendvps_XMMRegister_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister,
    arg3: XMMRegister
)

Conditionally copy single-precision floating-point values from xmm2 or xmm3/m128 to xmm1, based on mask bits in the specified mask operand, xmm4.

pub fn vblendvps_YMM_YMM_Any256BitMemory_YMM(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory,
    arg3: YMMRegister
)

Conditionally copy single-precision floating-point values from ymm2 or ymm3/m256 to ymm1, based on mask bits in the specified mask register, ymm4.

pub fn vblendvps_YMM_YMM_YMM_YMM(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister,
    arg3: YMMRegister
)

Conditionally copy single-precision floating-point values from ymm2 or ymm3/m256 to ymm1, based on mask bits in the specified mask register, ymm4.

pub fn vbroadcastf128_YMM_Any128BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: Any128BitMemory
)

Broadcast 128 bits of floating-point data in mem to low and high 128-bits in ymm1.

pub fn vbroadcasti128_YMM_Any128BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: Any128BitMemory
)

Broadcast 128 bits of integer data in mem to low and high 128-bits in ymm1.

pub fn vbroadcastsd_YMM_Any64BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: Any64BitMemory
)

Broadcast double-precision floating-point element in mem to four locations in ymm1.

pub fn vbroadcastsd_YMM_XMMRegister(
    &mut self,
    arg0: YMMRegister,
    arg1: XMMRegister
)

Broadcast low double-precision floating-point element in the source operand to four locations in ymm1.

pub fn vbroadcastss_XMMRegister_Any32BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any32BitMemory
)

Broadcast single-precision floating-point element in mem to four locations in xmm1.

pub fn vbroadcastss_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Broadcast the low single-precision floating-point element in the source operand to four locations in xmm1.

pub fn vbroadcastss_YMM_Any32BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: Any32BitMemory
)

Broadcast single-precision floating-point element in mem to eight locations in ymm1.

pub fn vbroadcastss_YMM_XMMRegister(
    &mut self,
    arg0: YMMRegister,
    arg1: XMMRegister
)

Broadcast low single-precision floating-point element in the source operand to eight locations in ymm1.

pub fn vcmppd_XMMRegister_XMMRegister_Any128BitMemory_Immediate8Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory,
    arg3: Immediate8Bit
)

Compare packed double-precision floating-point values in xmm3/m128 and xmm2 using bits 4:0 of imm8 as a comparison predicate.

pub fn vcmppd_XMMRegister_XMMRegister_XMMRegister_Immediate8Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister,
    arg3: Immediate8Bit
)

Compare packed double-precision floating-point values in xmm3/m128 and xmm2 using bits 4:0 of imm8 as a comparison predicate.

pub fn vcmppd_YMM_YMM_Any256BitMemory_Immediate8Bit(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory,
    arg3: Immediate8Bit
)

Compare packed double-precision floating-point values in ymm3/m256 and ymm2 using bits 4:0 of imm8 as a comparison predicate.

pub fn vcmppd_YMM_YMM_YMM_Immediate8Bit(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister,
    arg3: Immediate8Bit
)

Compare packed double-precision floating-point values in ymm3/m256 and ymm2 using bits 4:0 of imm8 as a comparison predicate.

pub fn vcmpps_XMMRegister_XMMRegister_Any128BitMemory_Immediate8Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory,
    arg3: Immediate8Bit
)

Compare packed single-precision floating-point values in xmm3/m128 and xmm2 using bits 4:0 of imm8 as a comparison predicate.

pub fn vcmpps_XMMRegister_XMMRegister_XMMRegister_Immediate8Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister,
    arg3: Immediate8Bit
)

Compare packed single-precision floating-point values in xmm3/m128 and xmm2 using bits 4:0 of imm8 as a comparison predicate.

pub fn vcmpps_YMM_YMM_Any256BitMemory_Immediate8Bit(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory,
    arg3: Immediate8Bit
)

Compare packed single-precision floating-point values in ymm3/m256 and ymm2 using bits 4:0 of imm8 as a comparison predicate.

pub fn vcmpps_YMM_YMM_YMM_Immediate8Bit(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister,
    arg3: Immediate8Bit
)

Compare packed single-precision floating-point values in ymm3/m256 and ymm2 using bits 4:0 of imm8 as a comparison predicate.

pub fn vcmpsd_XMMRegister_XMMRegister_Any64BitMemory_Immediate8Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any64BitMemory,
    arg3: Immediate8Bit
)

Compare low double-precision floating-point value in xmm3/m64 and xmm2 using bits 4:0 of imm8 as comparison predicate.

pub fn vcmpsd_XMMRegister_XMMRegister_XMMRegister_Immediate8Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister,
    arg3: Immediate8Bit
)

Compare low double-precision floating-point value in xmm3/m64 and xmm2 using bits 4:0 of imm8 as comparison predicate.

pub fn vcmpss_XMMRegister_XMMRegister_Any32BitMemory_Immediate8Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any32BitMemory,
    arg3: Immediate8Bit
)

Compare low single-precision floating-point value in xmm3/m32 and xmm2 using bits 4:0 of imm8 as comparison predicate.

pub fn vcmpss_XMMRegister_XMMRegister_XMMRegister_Immediate8Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister,
    arg3: Immediate8Bit
)

Compare low single-precision floating-point value in xmm3/m32 and xmm2 using bits 4:0 of imm8 as comparison predicate.

pub fn vcomisd_XMMRegister_Any64BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any64BitMemory
)

Compare low double-precision floating-point values in xmm1 and xmm2/mem64 and sets the appropriate flags in EFLAGS accordingly.

pub fn vcomisd_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Compare low double-precision floating-point values in xmm1 and xmm2/mem64 and sets the appropriate flags in EFLAGS accordingly.

pub fn vcomiss_XMMRegister_Any32BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any32BitMemory
)

Compare low single-precision floating-point values in xmm1 and xmm2/mem32 and sets the appropriate flags in EFLAGS accordingly.

pub fn vcomiss_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Compare low single-precision floating-point values in xmm1 and xmm2/mem32 and sets the appropriate flags in EFLAGS accordingly.

pub fn vcvtdq2pd_XMMRegister_Any64BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any64BitMemory
)

Convert two packed signed doubleword integers from xmm2/mem to two packed double-precision floating-point values in xmm1.

pub fn vcvtdq2pd_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Convert two packed signed doubleword integers from xmm2/mem to two packed double-precision floating-point values in xmm1.

pub fn vcvtdq2pd_YMM_Any128BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: Any128BitMemory
)

Convert four packed signed doubleword integers from ymm2/mem to four packed double-precision floating-point values in ymm1.

pub fn vcvtdq2pd_YMM_XMMRegister(&mut self, arg0: YMMRegister, arg1: XMMRegister)

Convert four packed signed doubleword integers from ymm2/mem to four packed double-precision floating-point values in ymm1.

pub fn vcvtdq2ps_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Convert four packed signed doubleword integers from xmm2/mem to four packed single-precision floating-point values in xmm1.

pub fn vcvtdq2ps_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Convert four packed signed doubleword integers from xmm2/mem to four packed single-precision floating-point values in xmm1.

pub fn vcvtdq2ps_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: Any256BitMemory
)

Convert eight packed signed doubleword integers from ymm2/mem to eight packed single-precision floating-point values in ymm1.

pub fn vcvtdq2ps_YMM_YMM(&mut self, arg0: YMMRegister, arg1: YMMRegister)

Convert eight packed signed doubleword integers from ymm2/mem to eight packed single-precision floating-point values in ymm1.

pub fn vcvtpd2dq_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Convert two packed double-precision floating-point values in xmm2/mem to two signed doubleword integers in xmm1.

pub fn vcvtpd2dq_XMMRegister_Any256BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any256BitMemory
)

Convert four packed double-precision floating-point values in ymm2/mem to four signed doubleword integers in xmm1.

pub fn vcvtpd2dq_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Convert two packed double-precision floating-point values in xmm2/mem to two signed doubleword integers in xmm1.

pub fn vcvtpd2dq_XMMRegister_YMM(&mut self, arg0: XMMRegister, arg1: YMMRegister)

Convert four packed double-precision floating-point values in ymm2/mem to four signed doubleword integers in xmm1.

pub fn vcvtpd2ps_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Convert two packed double-precision floating-point values in xmm2/mem to two single-precision floating-point values in xmm1.

pub fn vcvtpd2ps_XMMRegister_Any256BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any256BitMemory
)

Convert four packed double-precision floating-point values in ymm2/mem to four single-precision floating-point values in xmm1.

pub fn vcvtpd2ps_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Convert two packed double-precision floating-point values in xmm2/mem to two single-precision floating-point values in xmm1.

pub fn vcvtpd2ps_XMMRegister_YMM(&mut self, arg0: XMMRegister, arg1: YMMRegister)

Convert four packed double-precision floating-point values in ymm2/mem to four single-precision floating-point values in xmm1.

pub fn vcvtph2ps_XMMRegister_Any64BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any64BitMemory
)

Convert four packed half precision (16-bit) floating-point values in xmm2/m64 to packed single-precision floating-point value in xmm1.

pub fn vcvtph2ps_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Convert four packed half precision (16-bit) floating-point values in xmm2/m64 to packed single-precision floating-point value in xmm1.

pub fn vcvtph2ps_YMM_Any128BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: Any128BitMemory
)

Convert eight packed half precision (16-bit) floating-point values in xmm2/m128 to packed single-precision floating-point value in ymm1.

pub fn vcvtph2ps_YMM_XMMRegister(&mut self, arg0: YMMRegister, arg1: XMMRegister)

Convert eight packed half precision (16-bit) floating-point values in xmm2/m128 to packed single-precision floating-point value in ymm1.

pub fn vcvtps2dq_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Convert four packed single-precision floating-point values from xmm2/mem to four packed signed doubleword values in xmm1.

pub fn vcvtps2dq_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Convert four packed single-precision floating-point values from xmm2/mem to four packed signed doubleword values in xmm1.

pub fn vcvtps2dq_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: Any256BitMemory
)

Convert eight packed single-precision floating-point values from ymm2/mem to eight packed signed doubleword values in ymm1.

pub fn vcvtps2dq_YMM_YMM(&mut self, arg0: YMMRegister, arg1: YMMRegister)

Convert eight packed single-precision floating-point values from ymm2/mem to eight packed signed doubleword values in ymm1.

pub fn vcvtps2pd_XMMRegister_Any64BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any64BitMemory
)

Convert two packed single-precision floating-point values in xmm2/mem to two packed double-precision floating-point values in xmm1.

pub fn vcvtps2pd_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Convert two packed single-precision floating-point values in xmm2/mem to two packed double-precision floating-point values in xmm1.

pub fn vcvtps2pd_YMM_Any128BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: Any128BitMemory
)

Convert four packed single-precision floating-point values in xmm2/mem to four packed double-precision floating-point values in ymm1.

pub fn vcvtps2pd_YMM_XMMRegister(&mut self, arg0: YMMRegister, arg1: XMMRegister)

Convert four packed single-precision floating-point values in xmm2/mem to four packed double-precision floating-point values in ymm1.

pub fn vcvtps2ph_Any128BitMemory_YMM_Immediate8Bit(
    &mut self,
    arg0: Any128BitMemory,
    arg1: YMMRegister,
    arg2: Immediate8Bit
)

Convert eight packed single-precision floating-point value in ymm2 to packed half-precision (16-bit) floating-point value in xmm1/mem.

imm8 provides rounding controls.

pub fn vcvtps2ph_Any64BitMemory_XMMRegister_Immediate8Bit(
    &mut self,
    arg0: Any64BitMemory,
    arg1: XMMRegister,
    arg2: Immediate8Bit
)

Convert four packed single-precision float- ing-point value in xmm2 to packed half- precision (16-bit) floating-point value in xmm1/mem.

imm8 provides rounding controls.

pub fn vcvtps2ph_XMMRegister_XMMRegister_Immediate8Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Immediate8Bit
)

Convert four packed single-precision float- ing-point value in xmm2 to packed half- precision (16-bit) floating-point value in xmm1/mem.

imm8 provides rounding controls.

pub fn vcvtps2ph_XMMRegister_YMM_Immediate8Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: YMMRegister,
    arg2: Immediate8Bit
)

Convert eight packed single-precision floating-point value in ymm2 to packed half-precision (16-bit) floating-point value in xmm1/mem.

imm8 provides rounding controls.

pub fn vcvtsd2si_Register32Bit_Any64BitMemory(
    &mut self,
    arg0: Register32Bit,
    arg1: Any64BitMemory
)

Convert one double-precision floating-point value from xmm1/m64 to one signed doubleword integer r32.

pub fn vcvtsd2si_Register32Bit_XMMRegister(
    &mut self,
    arg0: Register32Bit,
    arg1: XMMRegister
)

Convert one double-precision floating-point value from xmm1/m64 to one signed doubleword integer r32.

pub fn vcvtsd2si_Register64Bit_Any64BitMemory(
    &mut self,
    arg0: Register64Bit,
    arg1: Any64BitMemory
)

Convert one double-precision floating-point value from xmm1/m64 to one signed quadword integer sign-extended into r64.

pub fn vcvtsd2si_Register64Bit_XMMRegister(
    &mut self,
    arg0: Register64Bit,
    arg1: XMMRegister
)

Convert one double-precision floating-point value from xmm1/m64 to one signed quadword integer sign-extended into r64.

pub fn vcvtsd2ss_XMMRegister_XMMRegister_Any64BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any64BitMemory
)

Convert one double-precision floating-point value in xmm3/m64 to one single-precision floating-point value and merge with high bits in xmm2.

pub fn vcvtsd2ss_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Convert one double-precision floating-point value in xmm3/m64 to one single-precision floating-point value and merge with high bits in xmm2.

pub fn vcvtsi2sd_XMMRegister_XMMRegister_Any32BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any32BitMemory
)

Convert one signed doubleword integer from r/m32 to one double-precision floating-point value in xmm1.

pub fn vcvtsi2sd_XMMRegister_XMMRegister_Any64BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any64BitMemory
)

Convert one signed quadword integer from r/m64 to one double-precision floating-point value in xmm1.

pub fn vcvtsi2sd_XMMRegister_XMMRegister_Register32Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Register32Bit
)

Convert one signed doubleword integer from r/m32 to one double-precision floating-point value in xmm1.

pub fn vcvtsi2sd_XMMRegister_XMMRegister_Register64Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Register64Bit
)

Convert one signed quadword integer from r/m64 to one double-precision floating-point value in xmm1.

pub fn vcvtsi2ss_XMMRegister_XMMRegister_Any32BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any32BitMemory
)

Convert one signed doubleword integer from r/m32 to one single-precision floating-point value in xmm1.

pub fn vcvtsi2ss_XMMRegister_XMMRegister_Any64BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any64BitMemory
)

Convert one signed quadword integer from r/m64 to one single-precision floating-point value in xmm1.

pub fn vcvtsi2ss_XMMRegister_XMMRegister_Register32Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Register32Bit
)

Convert one signed doubleword integer from r/m32 to one single-precision floating-point value in xmm1.

pub fn vcvtsi2ss_XMMRegister_XMMRegister_Register64Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Register64Bit
)

Convert one signed quadword integer from r/m64 to one single-precision floating-point value in xmm1.

pub fn vcvtss2sd_XMMRegister_XMMRegister_Any32BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any32BitMemory
)

Convert one single-precision floating-point value in xmm3/m32 to one double-precision floating-point value and merge with high bits of xmm2.

pub fn vcvtss2sd_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Convert one single-precision floating-point value in xmm3/m32 to one double-precision floating-point value and merge with high bits of xmm2.

pub fn vcvtss2si_Register32Bit_Any32BitMemory(
    &mut self,
    arg0: Register32Bit,
    arg1: Any32BitMemory
)

Convert one single-precision floating-point value from xmm1/m32 to one signed doubleword integer in r32.

pub fn vcvtss2si_Register32Bit_XMMRegister(
    &mut self,
    arg0: Register32Bit,
    arg1: XMMRegister
)

Convert one single-precision floating-point value from xmm1/m32 to one signed doubleword integer in r32.

pub fn vcvtss2si_Register64Bit_Any32BitMemory(
    &mut self,
    arg0: Register64Bit,
    arg1: Any32BitMemory
)

Convert one single-precision floating-point value from xmm1/m32 to one signed quadword integer in r64.

pub fn vcvtss2si_Register64Bit_XMMRegister(
    &mut self,
    arg0: Register64Bit,
    arg1: XMMRegister
)

Convert one single-precision floating-point value from xmm1/m32 to one signed quadword integer in r64.

pub fn vcvttpd2dq_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Convert two packed double-precision floating-point values in xmm2/mem to two signed doubleword integers in xmm1 using truncation.

pub fn vcvttpd2dq_XMMRegister_Any256BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any256BitMemory
)

Convert four packed double-precision floating-point values in ymm2/mem to four signed doubleword integers in xmm1 using truncation.

pub fn vcvttpd2dq_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Convert two packed double-precision floating-point values in xmm2/mem to two signed doubleword integers in xmm1 using truncation.

pub fn vcvttpd2dq_XMMRegister_YMM(&mut self, arg0: XMMRegister, arg1: YMMRegister)

Convert four packed double-precision floating-point values in ymm2/mem to four signed doubleword integers in xmm1 using truncation.

pub fn vcvttps2dq_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Convert four packed single-precision floating-point values from xmm2/mem to four packed signed doubleword values in xmm1 using truncation.

pub fn vcvttps2dq_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Convert four packed single-precision floating-point values from xmm2/mem to four packed signed doubleword values in xmm1 using truncation.

pub fn vcvttps2dq_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: Any256BitMemory
)

Convert eight packed single-precision floating-point values from ymm2/mem to eight packed signed doubleword values in ymm1 using truncation.

pub fn vcvttps2dq_YMM_YMM(&mut self, arg0: YMMRegister, arg1: YMMRegister)

Convert eight packed single-precision floating-point values from ymm2/mem to eight packed signed doubleword values in ymm1 using truncation.

pub fn vcvttsd2si_Register32Bit_Any64BitMemory(
    &mut self,
    arg0: Register32Bit,
    arg1: Any64BitMemory
)

Convert one double-precision floating-point value from xmm1/m64 to one signed doubleword integer in r32 using truncation.

pub fn vcvttsd2si_Register32Bit_XMMRegister(
    &mut self,
    arg0: Register32Bit,
    arg1: XMMRegister
)

Convert one double-precision floating-point value from xmm1/m64 to one signed doubleword integer in r32 using truncation.

pub fn vcvttsd2si_Register64Bit_Any64BitMemory(
    &mut self,
    arg0: Register64Bit,
    arg1: Any64BitMemory
)

Convert one double-precision floating-point value from xmm1/m64 to one signed quadword integer in r64 using truncation.

pub fn vcvttsd2si_Register64Bit_XMMRegister(
    &mut self,
    arg0: Register64Bit,
    arg1: XMMRegister
)

Convert one double-precision floating-point value from xmm1/m64 to one signed quadword integer in r64 using truncation.

pub fn vcvttss2si_Register32Bit_Any32BitMemory(
    &mut self,
    arg0: Register32Bit,
    arg1: Any32BitMemory
)

Convert one single-precision floating-point value from xmm1/m32 to one signed doubleword integer in r32 using truncation.

pub fn vcvttss2si_Register32Bit_XMMRegister(
    &mut self,
    arg0: Register32Bit,
    arg1: XMMRegister
)

Convert one single-precision floating-point value from xmm1/m32 to one signed doubleword integer in r32 using truncation.

pub fn vcvttss2si_Register64Bit_Any32BitMemory(
    &mut self,
    arg0: Register64Bit,
    arg1: Any32BitMemory
)

Convert one single-precision floating-point value from xmm1/m32 to one signed quadword integer in r64 using truncation.

pub fn vcvttss2si_Register64Bit_XMMRegister(
    &mut self,
    arg0: Register64Bit,
    arg1: XMMRegister
)

Convert one single-precision floating-point value from xmm1/m32 to one signed quadword integer in r64 using truncation.

pub fn vdivpd_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Divide packed double-precision floating-point values in xmm2 by packed double-precision floating-point values in xmm3/mem.

pub fn vdivpd_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Divide packed double-precision floating-point values in xmm2 by packed double-precision floating-point values in xmm3/mem.

pub fn vdivpd_YMM_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory
)

Divide packed double-precision floating-point values in ymm2 by packed double-precision floating-point values in ymm3/mem.

pub fn vdivpd_YMM_YMM_YMM(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister
)

Divide packed double-precision floating-point values in ymm2 by packed double-precision floating-point values in ymm3/mem.

pub fn vdivps_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Divide packed single-precision floating-point values in xmm2 by packed double-precision floating-point values in xmm3/mem.

pub fn vdivps_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Divide packed single-precision floating-point values in xmm2 by packed double-precision floating-point values in xmm3/mem.

pub fn vdivps_YMM_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory
)

Divide packed single-precision floating-point values in ymm2 by packed double-precision floating-point values in ymm3/mem.

pub fn vdivps_YMM_YMM_YMM(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister
)

Divide packed single-precision floating-point values in ymm2 by packed double-precision floating-point values in ymm3/mem.

pub fn vdivsd_XMMRegister_XMMRegister_Any64BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any64BitMemory
)

Divide low double-precision floating-point values in xmm2 by low double-precision floating-point value in xmm3/mem.

pub fn vdivsd_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Divide low double-precision floating-point values in xmm2 by low double-precision floating-point value in xmm3/mem.

pub fn vdivss_XMMRegister_XMMRegister_Any32BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any32BitMemory
)

Divide low single-precision floating-point value in xmm2 by low single-precision floating-point value in xmm3/m32.

pub fn vdivss_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Divide low single-precision floating-point value in xmm2 by low single-precision floating-point value in xmm3/m32.

pub fn vdppd_XMMRegister_XMMRegister_Any128BitMemory_Immediate8Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory,
    arg3: Immediate8Bit
)

Selectively multiply packed double-precision floating-point values from xmm2 with packed double-precision floating-point values from xmm3, selectively add and store the packed double-precision floating-point values to xmm1.

pub fn vdppd_XMMRegister_XMMRegister_XMMRegister_Immediate8Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister,
    arg3: Immediate8Bit
)

Selectively multiply packed double-precision floating-point values from xmm2 with packed double-precision floating-point values from xmm3, selectively add and store the packed double-precision floating-point values to xmm1.

pub fn vdpps_XMMRegister_XMMRegister_Any128BitMemory_Immediate8Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory,
    arg3: Immediate8Bit
)

Multiply packed single-precision floating-point values from xmm1 with packed single-precision floating-point values from xmm2/mem, selectively add and store to xmm1.

pub fn vdpps_XMMRegister_XMMRegister_XMMRegister_Immediate8Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister,
    arg3: Immediate8Bit
)

Multiply packed single-precision floating-point values from xmm1 with packed single-precision floating-point values from xmm2/mem, selectively add and store to xmm1.

pub fn vdpps_YMM_YMM_Any256BitMemory_Immediate8Bit(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory,
    arg3: Immediate8Bit
)

Multiply packed single-precision floating-point values from ymm2 with packed single-precision floating-point values from ymm3/mem, selectively add pairs of elements and store to ymm1.

pub fn vdpps_YMM_YMM_YMM_Immediate8Bit(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister,
    arg3: Immediate8Bit
)

Multiply packed single-precision floating-point values from ymm2 with packed single-precision floating-point values from ymm3/mem, selectively add pairs of elements and store to ymm1.

pub fn verr_Any16BitMemory(&mut self, arg0: Any16BitMemory)

Set Zero Flag (ZF) is 1 if segment specified with r/m16 can be read.

pub fn verr_Register16Bit(&mut self, arg0: Register16Bit)

Set Zero Flag (ZF) is 1 if segment specified with r/m16 can be read.

pub fn verw_Any16BitMemory(&mut self, arg0: Any16BitMemory)

Set Zero Flag (ZF) is 1 if segment specified with r/m16 can be written.

pub fn verw_Register16Bit(&mut self, arg0: Register16Bit)

Set Zero Flag (ZF) is 1 if segment specified with r/m16 can be written.

pub fn vextractf128_Any128BitMemory_YMM_Immediate8Bit(
    &mut self,
    arg0: Any128BitMemory,
    arg1: YMMRegister,
    arg2: Immediate8Bit
)

Extract 128 bits of packed floating-point values from ymm2 and store results in xmm1/mem.

pub fn vextractf128_XMMRegister_YMM_Immediate8Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: YMMRegister,
    arg2: Immediate8Bit
)

Extract 128 bits of packed floating-point values from ymm2 and store results in xmm1/mem.

pub fn vextracti128_Any128BitMemory_YMM_Immediate8Bit(
    &mut self,
    arg0: Any128BitMemory,
    arg1: YMMRegister,
    arg2: Immediate8Bit
)

Extract 128 bits of integer data from ymm2 and store results in xmm1/mem.

pub fn vextracti128_XMMRegister_YMM_Immediate8Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: YMMRegister,
    arg2: Immediate8Bit
)

Extract 128 bits of integer data from ymm2 and store results in xmm1/mem.

pub fn vextractps_Any32BitMemory_XMMRegister_Immediate8Bit(
    &mut self,
    arg0: Any32BitMemory,
    arg1: XMMRegister,
    arg2: Immediate8Bit
)

Extract one single-precision floating-point value from xmm1 at the offset specified by imm8 and store the result in reg or m32.

Zero extend the results in 64-bit register if applicable.

pub fn vextractps_Register32Bit_XMMRegister_Immediate8Bit(
    &mut self,
    arg0: Register32Bit,
    arg1: XMMRegister,
    arg2: Immediate8Bit
)

Extract one single-precision floating-point value from xmm1 at the offset specified by imm8 and store the result in reg or m32.

Zero extend the results in 64-bit register if applicable.

pub fn vfmadd132pd_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Multiply packed double-precision floating-point values from xmm0 and xmm2/mem, add to xmm1 and put result in xmm0.

pub fn vfmadd132pd_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Multiply packed double-precision floating-point values from xmm0 and xmm2/mem, add to xmm1 and put result in xmm0.

pub fn vfmadd132pd_YMM_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory
)

Multiply packed double-precision floating-point values from ymm0 and ymm2/mem, add to ymm1 and put result in ymm0.

pub fn vfmadd132pd_YMM_YMM_YMM(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister
)

Multiply packed double-precision floating-point values from ymm0 and ymm2/mem, add to ymm1 and put result in ymm0.

pub fn vfmadd132ps_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Multiply packed single-precision floating-point values from xmm0 and xmm2/mem, add to xmm1 and put result in xmm0.

pub fn vfmadd132ps_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Multiply packed single-precision floating-point values from xmm0 and xmm2/mem, add to xmm1 and put result in xmm0.

pub fn vfmadd132ps_YMM_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory
)

Multiply packed single-precision floating-point values from ymm0 and ymm2/mem, add to ymm1 and put result in ymm0.

pub fn vfmadd132ps_YMM_YMM_YMM(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister
)

Multiply packed single-precision floating-point values from ymm0 and ymm2/mem, add to ymm1 and put result in ymm0.

pub fn vfmadd132sd_XMMRegister_XMMRegister_Any64BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any64BitMemory
)

Multiply scalar double-precision floating-point value from xmm0 and xmm2/mem, add to xmm1 and put result in xmm0.

pub fn vfmadd132sd_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Multiply scalar double-precision floating-point value from xmm0 and xmm2/mem, add to xmm1 and put result in xmm0.

pub fn vfmadd132ss_XMMRegister_XMMRegister_Any32BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any32BitMemory
)

Multiply scalar single-precision floating-point value from xmm0 and xmm2/mem, add to xmm1 and put result in xmm0.

pub fn vfmadd132ss_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Multiply scalar single-precision floating-point value from xmm0 and xmm2/mem, add to xmm1 and put result in xmm0.

pub fn vfmadd213pd_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Multiply packed double-precision floating-point values from xmm0 and xmm1, add to xmm2/mem and put result in xmm0.

pub fn vfmadd213pd_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Multiply packed double-precision floating-point values from xmm0 and xmm1, add to xmm2/mem and put result in xmm0.

pub fn vfmadd213pd_YMM_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory
)

Multiply packed double-precision floating-point values from ymm0 and ymm1. add to ymm2/mem and put result in ymm0.

pub fn vfmadd213pd_YMM_YMM_YMM(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister
)

Multiply packed double-precision floating-point values from ymm0 and ymm1, add to ymm2/mem and put result in ymm0.

pub fn vfmadd213ps_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Multiply packed single-precision floating-point values from xmm0 and xmm1, add to xmm2/mem and put result in xmm0.

pub fn vfmadd213ps_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Multiply packed single-precision floating-point values from xmm0 and xmm1, add to xmm2/mem and put result in xmm0.

pub fn vfmadd213ps_YMM_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory
)

Multiply packed single-precision floating-point values from ymm0 and ymm1, add to ymm2/mem and put result in ymm0.

pub fn vfmadd213ps_YMM_YMM_YMM(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister
)

Multiply packed single-precision floating-point values from ymm0 and ymm1, add to ymm2/mem and put result in ymm0.

pub fn vfmadd213sd_XMMRegister_XMMRegister_Any64BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any64BitMemory
)

Multiply scalar double-precision floating-point value from xmm0 and xmm1, add to xmm2/mem and put result in xmm0.

pub fn vfmadd213sd_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Multiply scalar double-precision floating-point value from xmm0 and xmm1, add to xmm2/mem and put result in xmm0.

pub fn vfmadd213ss_XMMRegister_XMMRegister_Any32BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any32BitMemory
)

Multiply scalar single-precision floating-point value from xmm0 and xmm1, add to xmm2/mem and put result in xmm0.

pub fn vfmadd213ss_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Multiply scalar single-precision floating-point value from xmm0 and xmm1, add to xmm2/mem and put result in xmm0.

pub fn vfmadd231pd_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Multiply packed double-precision floating-point values from xmm1 and xmm2/mem, add to xmm0 and put result in xmm0.

pub fn vfmadd231pd_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Multiply packed double-precision floating-point values from xmm1 and xmm2/mem, add to xmm0 and put result in xmm0.

pub fn vfmadd231pd_YMM_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory
)

Multiply packed double-precision floating-point values from ymm1 and ymm2/mem, add to ymm0 and put result in ymm0.

pub fn vfmadd231pd_YMM_YMM_YMM(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister
)

Multiply packed double-precision floating-point values from ymm1 and ymm2/mem, add to ymm0 and put result in ymm0.

pub fn vfmadd231ps_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Multiply packed single-precision floating-point values from xmm1 and xmm2/mem, add to xmm0 and put result in xmm0.

pub fn vfmadd231ps_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Multiply packed single-precision floating-point values from xmm1 and xmm2/mem, add to xmm0 and put result in xmm0.

pub fn vfmadd231ps_YMM_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory
)

Multiply packed single-precision floating-point values from ymm1 and ymm2/mem, add to ymm0 and put result in ymm0.

pub fn vfmadd231ps_YMM_YMM_YMM(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister
)

Multiply packed single-precision floating-point values from ymm1 and ymm2/mem, add to ymm0 and put result in ymm0.

pub fn vfmadd231sd_XMMRegister_XMMRegister_Any64BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any64BitMemory
)

Multiply scalar double-precision floating-point value from xmm1 and xmm2/mem, add to xmm0 and put result in xmm0.

pub fn vfmadd231sd_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Multiply scalar double-precision floating-point value from xmm1 and xmm2/mem, add to xmm0 and put result in xmm0.

pub fn vfmadd231ss_XMMRegister_XMMRegister_Any32BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any32BitMemory
)

Multiply scalar single-precision floating-point value from xmm1 and xmm2/mem, add to xmm0 and put result in xmm0.

pub fn vfmadd231ss_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Multiply scalar single-precision floating-point value from xmm1 and xmm2/mem, add to xmm0 and put result in xmm0.

pub fn vfmaddsub132pd_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Multiply packed double-precision floating-point values from xmm0 and xmm2/mem, add/subtract elements in xmm1 and put result in xmm0.

pub fn vfmaddsub132pd_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Multiply packed double-precision floating-point values from xmm0 and xmm2/mem, add/subtract elements in xmm1 and put result in xmm0.

pub fn vfmaddsub132pd_YMM_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory
)

Multiply packed double-precision floating-point values from ymm0 and ymm2/mem, add/subtract elements in ymm1 and put result in ymm0.

pub fn vfmaddsub132pd_YMM_YMM_YMM(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister
)

Multiply packed double-precision floating-point values from ymm0 and ymm2/mem, add/subtract elements in ymm1 and put result in ymm0.

pub fn vfmaddsub132ps_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Multiply packed single-precision floating-point values from xmm0 and xmm2/mem, add/subtract elements in xmm1 and put result in xmm0.

pub fn vfmaddsub132ps_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Multiply packed single-precision floating-point values from xmm0 and xmm2/mem, add/subtract elements in xmm1 and put result in xmm0.

pub fn vfmaddsub132ps_YMM_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory
)

Multiply packed single-precision floating-point values from ymm0 and ymm2/mem, add/subtract elements in ymm1 and put result in ymm0.

pub fn vfmaddsub132ps_YMM_YMM_YMM(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister
)

Multiply packed single-precision floating-point values from ymm0 and ymm2/mem, add/subtract elements in ymm1 and put result in ymm0.

pub fn vfmaddsub213pd_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Multiply packed double-precision floating-point values from xmm0 and xmm1, add/subtract elements in xmm2/mem and put result in xmm0.

pub fn vfmaddsub213pd_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Multiply packed double-precision floating-point values from xmm0 and xmm1, add/subtract elements in xmm2/mem and put result in xmm0.

pub fn vfmaddsub213pd_YMM_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory
)

Multiply packed double-precision floating-point values from ymm0 and ymm1. add/subtract elements in ymm2/mem and put result in ymm0.

pub fn vfmaddsub213pd_YMM_YMM_YMM(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister
)

Multiply packed double-precision floating-point values from ymm0 and ymm1. add/subtract elements in ymm2/mem and put result in ymm0.

pub fn vfmaddsub213ps_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Multiply packed single-precision floating-point values from xmm0 and xmm1, add/subtract elements in xmm2/mem and put result in xmm0.

pub fn vfmaddsub213ps_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Multiply packed single-precision floating-point values from xmm0 and xmm1, add/subtract elements in xmm2/mem and put result in xmm0.

pub fn vfmaddsub213ps_YMM_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory
)

Multiply packed single-precision floating-point values from ymm0 and ymm1, add/subtract elements in ymm2/mem and put result in ymm0.

pub fn vfmaddsub213ps_YMM_YMM_YMM(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister
)

Multiply packed single-precision floating-point values from ymm0 and ymm1, add/subtract elements in ymm2/mem and put result in ymm0.

pub fn vfmaddsub231pd_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Multiply packed double-precision floating-point values from xmm1 and xmm2/mem, add/subtract elements in xmm0 and put result in xmm0.

pub fn vfmaddsub231pd_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Multiply packed double-precision floating-point values from xmm1 and xmm2/mem, add/subtract elements in xmm0 and put result in xmm0.

pub fn vfmaddsub231pd_YMM_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory
)

Multiply packed double-precision floating-point values from ymm1 and ymm2/mem, add/subtract elements in ymm0 and put result in ymm0.

pub fn vfmaddsub231pd_YMM_YMM_YMM(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister
)

Multiply packed double-precision floating-point values from ymm1 and ymm2/mem, add/subtract elements in ymm0 and put result in ymm0.

pub fn vfmaddsub231ps_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Multiply packed single-precision floating-point values from xmm1 and xmm2/mem, add/subtract elements in xmm0 and put result in xmm0.

pub fn vfmaddsub231ps_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Multiply packed single-precision floating-point values from xmm1 and xmm2/mem, add/subtract elements in xmm0 and put result in xmm0.

pub fn vfmaddsub231ps_YMM_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory
)

Multiply packed single-precision floating-point values from ymm1 and ymm2/mem, add/subtract elements in ymm0 and put result in ymm0.

pub fn vfmaddsub231ps_YMM_YMM_YMM(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister
)

Multiply packed single-precision floating-point values from ymm1 and ymm2/mem, add/subtract elements in ymm0 and put result in ymm0.

pub fn vfmsub132pd_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Multiply packed double-precision floating-point values from xmm0 and xmm2/mem, subtract xmm1 and put result in xmm0.

pub fn vfmsub132pd_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Multiply packed double-precision floating-point values from xmm0 and xmm2/mem, subtract xmm1 and put result in xmm0.

pub fn vfmsub132pd_YMM_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory
)

Multiply packed double-precision floating-point values from ymm0 and ymm2/mem, subtract ymm1 and put result in ymm0.

pub fn vfmsub132pd_YMM_YMM_YMM(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister
)

Multiply packed double-precision floating-point values from ymm0 and ymm2/mem, subtract ymm1 and put result in ymm0.

pub fn vfmsub132ps_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Multiply packed single-precision floating-point values from xmm0 and xmm2/mem, subtract xmm1 and put result in xmm0.

pub fn vfmsub132ps_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Multiply packed single-precision floating-point values from xmm0 and xmm2/mem, subtract xmm1 and put result in xmm0.

pub fn vfmsub132ps_YMM_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory
)

Multiply packed single-precision floating-point values from ymm0 and ymm2/mem, subtract ymm1 and put result in ymm0.

pub fn vfmsub132ps_YMM_YMM_YMM(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister
)

Multiply packed single-precision floating-point values from ymm0 and ymm2/mem, subtract ymm1 and put result in ymm0.

pub fn vfmsub132sd_XMMRegister_XMMRegister_Any64BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any64BitMemory
)

Multiply scalar double-precision floating-point value from xmm0 and xmm2/mem, subtract xmm1 and put result in xmm0.

pub fn vfmsub132sd_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Multiply scalar double-precision floating-point value from xmm0 and xmm2/mem, subtract xmm1 and put result in xmm0.

pub fn vfmsub132ss_XMMRegister_XMMRegister_Any32BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any32BitMemory
)

Multiply scalar single-precision floating-point value from xmm0 and xmm2/mem, subtract xmm1 and put result in xmm0.

pub fn vfmsub132ss_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Multiply scalar single-precision floating-point value from xmm0 and xmm2/mem, subtract xmm1 and put result in xmm0.

pub fn vfmsub213pd_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Multiply packed double-precision floating-point values from xmm0 and xmm1, subtract xmm2/mem and put result in xmm0.

pub fn vfmsub213pd_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Multiply packed double-precision floating-point values from xmm0 and xmm1, subtract xmm2/mem and put result in xmm0.

pub fn vfmsub213pd_YMM_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory
)

Multiply packed double-precision floating-point values from ymm0 and ymm1. subtract ymm2/mem and put result in ymm0.

pub fn vfmsub213pd_YMM_YMM_YMM(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister
)

Multiply packed double-precision floating-point values from ymm0 and ymm1. subtract ymm2/mem and put result in ymm0.

pub fn vfmsub213ps_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Multiply packed single-precision floating-point values from xmm0 and xmm1, subtract xmm2/mem and put result in xmm0.

pub fn vfmsub213ps_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Multiply packed single-precision floating-point values from xmm0 and xmm1, subtract xmm2/mem and put result in xmm0.

pub fn vfmsub213ps_YMM_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory
)

Multiply packed single-precision floating-point values from ymm0 and ymm1, subtract ymm2/mem and put result in ymm0.

pub fn vfmsub213ps_YMM_YMM_YMM(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister
)

Multiply packed single-precision floating-point values from ymm0 and ymm1, subtract ymm2/mem and put result in ymm0.

pub fn vfmsub213sd_XMMRegister_XMMRegister_Any64BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any64BitMemory
)

Multiply scalar double-precision floating-point value from xmm0 and xmm1, subtract xmm2/mem and put result in xmm0.

pub fn vfmsub213sd_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Multiply scalar double-precision floating-point value from xmm0 and xmm1, subtract xmm2/mem and put result in xmm0.

pub fn vfmsub213ss_XMMRegister_XMMRegister_Any32BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any32BitMemory
)

Multiply scalar single-precision floating-point value from xmm0 and xmm1, subtract xmm2/mem and put result in xmm0.

pub fn vfmsub213ss_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Multiply scalar single-precision floating-point value from xmm0 and xmm1, subtract xmm2/mem and put result in xmm0.

pub fn vfmsub231pd_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Multiply packed double-precision floating-point values from xmm1 and xmm2/mem, subtract xmm0 and put result in xmm0.

pub fn vfmsub231pd_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Multiply packed double-precision floating-point values from xmm1 and xmm2/mem, subtract xmm0 and put result in xmm0.

pub fn vfmsub231pd_YMM_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory
)

Multiply packed double-precision floating-point values from ymm1 and ymm2/mem, subtract ymm0 and put result in ymm0.

pub fn vfmsub231pd_YMM_YMM_YMM(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister
)

Multiply packed double-precision floating-point values from ymm1 and ymm2/mem, subtract ymm0 and put result in ymm0.

pub fn vfmsub231ps_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Multiply packed single-precision floating-point values from xmm1 and xmm2/mem, subtract xmm0 and put result in xmm0.

pub fn vfmsub231ps_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Multiply packed single-precision floating-point values from xmm1 and xmm2/mem, subtract xmm0 and put result in xmm0.

pub fn vfmsub231ps_YMM_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory
)

Multiply packed single-precision floating-point values from ymm1 and ymm2/mem, subtract ymm0 and put result in ymm0.

pub fn vfmsub231ps_YMM_YMM_YMM(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister
)

Multiply packed single-precision floating-point values from ymm1 and ymm2/mem, subtract ymm0 and put result in ymm0.

pub fn vfmsub231sd_XMMRegister_XMMRegister_Any64BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any64BitMemory
)

Multiply scalar double-precision floating-point value from xmm1 and xmm2/mem, subtract xmm0 and put result in xmm0.

pub fn vfmsub231sd_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Multiply scalar double-precision floating-point value from xmm1 and xmm2/mem, subtract xmm0 and put result in xmm0.

pub fn vfmsub231ss_XMMRegister_XMMRegister_Any32BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any32BitMemory
)

Multiply scalar single-precision floating-point value from xmm1 and xmm2/mem, subtract xmm0 and put result in xmm0.

pub fn vfmsub231ss_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Multiply scalar single-precision floating-point value from xmm1 and xmm2/mem, subtract xmm0 and put result in xmm0.

pub fn vfmsubadd132pd_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Multiply packed double-precision floating-point values from xmm0 and xmm2/mem, subtract/add elements in xmm1 and put result in xmm0.

pub fn vfmsubadd132pd_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Multiply packed double-precision floating-point values from xmm0 and xmm2/mem, subtract/add elements in xmm1 and put result in xmm0.

pub fn vfmsubadd132pd_YMM_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory
)

Multiply packed double-precision floating-point values from ymm0 and ymm2/mem, subtract/add elements in ymm1 and put result in ymm0.

pub fn vfmsubadd132pd_YMM_YMM_YMM(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister
)

Multiply packed double-precision floating-point values from ymm0 and ymm2/mem, subtract/add elements in ymm1 and put result in ymm0.

pub fn vfmsubadd132ps_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Multiply packed single-precision floating-point values from xmm0 and xmm2/mem, subtract/add elements in xmm1 and put result in xmm0.

pub fn vfmsubadd132ps_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Multiply packed single-precision floating-point values from xmm0 and xmm2/mem, subtract/add elements in xmm1 and put result in xmm0.

pub fn vfmsubadd132ps_YMM_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory
)

Multiply packed single-precision floating-point values from ymm0 and ymm2/mem, subtract/add elements in ymm1 and put result in ymm0.

pub fn vfmsubadd132ps_YMM_YMM_YMM(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister
)

Multiply packed single-precision floating-point values from ymm0 and ymm2/mem, subtract/add elements in ymm1 and put result in ymm0.

pub fn vfmsubadd213pd_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Multiply packed double-precision floating-point values from xmm0 and xmm1, subtract/add elements in xmm2/mem and put result in xmm0.

pub fn vfmsubadd213pd_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Multiply packed double-precision floating-point values from xmm0 and xmm1, subtract/add elements in xmm2/mem and put result in xmm0.

pub fn vfmsubadd213pd_YMM_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory
)

Multiply packed double-precision floating-point values from ymm0 and ymm1, subtract/add elements in ymm2/mem and put result in ymm0.

pub fn vfmsubadd213pd_YMM_YMM_YMM(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister
)

Multiply packed double-precision floating-point values from ymm0 and ymm1, subtract/add elements in ymm2/mem and put result in ymm0.

pub fn vfmsubadd213ps_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Multiply packed single-precision floating-point values from xmm0 and xmm1, subtract/add elements in xmm2/mem and put result in xmm0.

pub fn vfmsubadd213ps_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Multiply packed single-precision floating-point values from xmm0 and xmm1, subtract/add elements in xmm2/mem and put result in xmm0.

pub fn vfmsubadd213ps_YMM_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory
)

Multiply packed single-precision floating-point values from ymm0 and ymm1, subtract/add elements in ymm2/mem and put result in ymm0.

pub fn vfmsubadd213ps_YMM_YMM_YMM(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister
)

Multiply packed single-precision floating-point values from ymm0 and ymm1, subtract/add elements in ymm2/mem and put result in ymm0.

pub fn vfmsubadd231pd_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Multiply packed double-precision floating-point values from xmm1 and xmm2/mem, subtract/add elements in xmm0 and put result in xmm0.

pub fn vfmsubadd231pd_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Multiply packed double-precision floating-point values from xmm1 and xmm2/mem, subtract/add elements in xmm0 and put result in xmm0.

pub fn vfmsubadd231pd_YMM_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory
)

Multiply packed double-precision floating-point values from ymm1 and ymm2/mem, subtract/add elements in ymm0 and put result in ymm0.

pub fn vfmsubadd231pd_YMM_YMM_YMM(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister
)

Multiply packed double-precision floating-point values from ymm1 and ymm2/mem, subtract/add elements in ymm0 and put result in ymm0.

pub fn vfmsubadd231ps_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Multiply packed single-precision floating-point values from xmm1 and xmm2/mem, subtract/add elements in xmm0 and put result in xmm0.

pub fn vfmsubadd231ps_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Multiply packed single-precision floating-point values from xmm1 and xmm2/mem, subtract/add elements in xmm0 and put result in xmm0.

pub fn vfmsubadd231ps_YMM_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory
)

Multiply packed single-precision floating-point values from ymm1 and ymm2/mem, subtract/add elements in ymm0 and put result in ymm0.

pub fn vfmsubadd231ps_YMM_YMM_YMM(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister
)

Multiply packed single-precision floating-point values from ymm1 and ymm2/mem, subtract/add elements in ymm0 and put result in ymm0.

pub fn vfnmadd132pd_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Multiply packed double-precision floating-point values from xmm0 and xmm2/mem, negate the multiplication result and add to xmm1 and put result in xmm0.

pub fn vfnmadd132pd_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Multiply packed double-precision floating-point values from xmm0 and xmm2/mem, negate the multiplication result and add to xmm1 and put result in xmm0.

pub fn vfnmadd132pd_YMM_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory
)

Multiply packed double-precision floating-point values from ymm0 and ymm2/mem, negate the multiplication result and add to ymm1 and put result in ymm0.

pub fn vfnmadd132pd_YMM_YMM_YMM(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister
)

Multiply packed double-precision floating-point values from ymm0 and ymm2/mem, negate the multiplication result and add to ymm1 and put result in ymm0.

pub fn vfnmadd132ps_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Multiply packed single-precision floating-point values from xmm0 and xmm2/mem, negate the multiplication result and add to xmm1 and put result in xmm0.

pub fn vfnmadd132ps_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Multiply packed single-precision floating-point values from xmm0 and xmm2/mem, negate the multiplication result and add to xmm1 and put result in xmm0.

pub fn vfnmadd132ps_YMM_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory
)

Multiply packed single-precision floating-point values from ymm0 and ymm2/mem, negate the multiplication result and add to ymm1 and put result in ymm0.

pub fn vfnmadd132ps_YMM_YMM_YMM(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister
)

Multiply packed single-precision floating-point values from ymm0 and ymm2/mem, negate the multiplication result and add to ymm1 and put result in ymm0.

pub fn vfnmadd132sd_XMMRegister_XMMRegister_Any64BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any64BitMemory
)

Multiply scalar double-precision floating-point value from xmm0 and xmm2/mem, negate the multiplication result and add to xmm1 and put result in xmm0.

pub fn vfnmadd132sd_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Multiply scalar double-precision floating-point value from xmm0 and xmm2/mem, negate the multiplication result and add to xmm1 and put result in xmm0.

pub fn vfnmadd132ss_XMMRegister_XMMRegister_Any32BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any32BitMemory
)

Multiply scalar single-precision floating-point value from xmm0 and xmm2/mem, negate the multiplication result and add to xmm1 and put result in xmm0.

pub fn vfnmadd132ss_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Multiply scalar single-precision floating-point value from xmm0 and xmm2/mem, negate the multiplication result and add to xmm1 and put result in xmm0.

pub fn vfnmadd213pd_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Multiply packed double-precision floating-point values from xmm0 and xmm1, negate the multiplication result and add to xmm2/mem and put result in xmm0.

pub fn vfnmadd213pd_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Multiply packed double-precision floating-point values from xmm0 and xmm1, negate the multiplication result and add to xmm2/mem and put result in xmm0.

pub fn vfnmadd213pd_YMM_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory
)

Multiply packed double-precision floating-point values from ymm0 and ymm1, negate the multiplication result and add to ymm2/mem and put result in ymm0.

pub fn vfnmadd213pd_YMM_YMM_YMM(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister
)

Multiply packed double-precision floating-point values from ymm0 and ymm1, negate the multiplication result and add to ymm2/mem and put result in ymm0.

pub fn vfnmadd213ps_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Multiply packed single-precision floating-point values from xmm0 and xmm1, negate the multiplication result and add to xmm2/mem and put result in xmm0.

pub fn vfnmadd213ps_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Multiply packed single-precision floating-point values from xmm0 and xmm1, negate the multiplication result and add to xmm2/mem and put result in xmm0.

pub fn vfnmadd213ps_YMM_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory
)

Multiply packed single-precision floating-point values from ymm0 and ymm1, negate the multiplication result and add to ymm2/mem and put result in ymm0.

pub fn vfnmadd213ps_YMM_YMM_YMM(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister
)

Multiply packed single-precision floating-point values from ymm0 and ymm1, negate the multiplication result and add to ymm2/mem and put result in ymm0.

pub fn vfnmadd213sd_XMMRegister_XMMRegister_Any64BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any64BitMemory
)

Multiply scalar double-precision floating-point value from xmm0 and xmm1, negate the multiplication result and add to xmm2/mem and put result in xmm0.

pub fn vfnmadd213sd_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Multiply scalar double-precision floating-point value from xmm0 and xmm1, negate the multiplication result and add to xmm2/mem and put result in xmm0.

pub fn vfnmadd213ss_XMMRegister_XMMRegister_Any32BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any32BitMemory
)

Multiply scalar single-precision floating-point value from xmm0 and xmm1, negate the multiplication result and add to xmm2/mem and put result in xmm0.

pub fn vfnmadd213ss_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Multiply scalar single-precision floating-point value from xmm0 and xmm1, negate the multiplication result and add to xmm2/mem and put result in xmm0.

pub fn vfnmadd231pd_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Multiply packed double-precision floating-point values from xmm1 and xmm2/mem, negate the multiplication result and add to xmm0 and put result in xmm0.

pub fn vfnmadd231pd_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Multiply packed double-precision floating-point values from xmm1 and xmm2/mem, negate the multiplication result and add to xmm0 and put result in xmm0.

pub fn vfnmadd231pd_YMM_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory
)

Multiply packed double-precision floating-point values from ymm1 and ymm2/mem, negate the multiplication result and add to ymm0 and put result in ymm0.

pub fn vfnmadd231pd_YMM_YMM_YMM(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister
)

Multiply packed double-precision floating-point values from ymm1 and ymm2/mem, negate the multiplication result and add to ymm0 and put result in ymm0.

pub fn vfnmadd231ps_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Multiply packed single-precision floating-point values from xmm1 and xmm2/mem, negate the multiplication result and add to xmm0 and put result in xmm0.

pub fn vfnmadd231ps_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Multiply packed single-precision floating-point values from xmm1 and xmm2/mem, negate the multiplication result and add to xmm0 and put result in xmm0.

pub fn vfnmadd231ps_YMM_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory
)

Multiply packed single-precision floating-point values from ymm1 and ymm2/mem, negate the multiplication result and add to ymm0 and put result in ymm0.

pub fn vfnmadd231ps_YMM_YMM_YMM(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister
)

Multiply packed single-precision floating-point values from ymm1 and ymm2/mem, negate the multiplication result and add to ymm0 and put result in ymm0.

pub fn vfnmadd231sd_XMMRegister_XMMRegister_Any64BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any64BitMemory
)

Multiply scalar double-precision floating-point value from xmm1 and xmm2/mem, negate the multiplication result and add to xmm0 and put result in xmm0.

pub fn vfnmadd231sd_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Multiply scalar double-precision floating-point value from xmm1 and xmm2/mem, negate the multiplication result and add to xmm0 and put result in xmm0.

pub fn vfnmadd231ss_XMMRegister_XMMRegister_Any32BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any32BitMemory
)

Multiply scalar single-precision floating-point value from xmm1 and xmm2/mem, negate the multiplication result and add to xmm0 and put result in xmm0.

pub fn vfnmadd231ss_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Multiply scalar single-precision floating-point value from xmm1 and xmm2/mem, negate the multiplication result and add to xmm0 and put result in xmm0.

pub fn vfnmsub132pd_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Multiply packed double-precision floating-point values from xmm0 and xmm2/mem, negate the multiplication result and subtract xmm1 and put result in xmm0.

pub fn vfnmsub132pd_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Multiply packed double-precision floating-point values from xmm0 and xmm2/mem, negate the multiplication result and subtract xmm1 and put result in xmm0.

pub fn vfnmsub132pd_YMM_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory
)

Multiply packed double-precision floating-point values from ymm0 and ymm2/mem, negate the multiplication result and subtract ymm1 and put result in ymm0.

pub fn vfnmsub132pd_YMM_YMM_YMM(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister
)

Multiply packed double-precision floating-point values from ymm0 and ymm2/mem, negate the multiplication result and subtract ymm1 and put result in ymm0.

pub fn vfnmsub132ps_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Multiply packed single-precision floating-point values from xmm0 and xmm2/mem, negate the multiplication result and subtract xmm1 and put result in xmm0.

pub fn vfnmsub132ps_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Multiply packed single-precision floating-point values from xmm0 and xmm2/mem, negate the multiplication result and subtract xmm1 and put result in xmm0.

pub fn vfnmsub132ps_YMM_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory
)

Multiply packed single-precision floating-point values from ymm0 and ymm2/mem, negate the multiplication result and subtract ymm1 and put result in ymm0.

pub fn vfnmsub132ps_YMM_YMM_YMM(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister
)

Multiply packed single-precision floating-point values from ymm0 and ymm2/mem, negate the multiplication result and subtract ymm1 and put result in ymm0.

pub fn vfnmsub132sd_XMMRegister_XMMRegister_Any64BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any64BitMemory
)

Multiply scalar double-precision floating-point value from xmm0 and xmm2/mem, negate the multiplication result and subtract xmm1 and put result in xmm0.

pub fn vfnmsub132sd_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Multiply scalar double-precision floating-point value from xmm0 and xmm2/mem, negate the multiplication result and subtract xmm1 and put result in xmm0.

pub fn vfnmsub132ss_XMMRegister_XMMRegister_Any32BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any32BitMemory
)

Multiply scalar single-precision floating-point value from xmm0 and xmm2/mem, negate the multiplication result and subtract xmm1 and put result in xmm0.

pub fn vfnmsub132ss_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Multiply scalar single-precision floating-point value from xmm0 and xmm2/mem, negate the multiplication result and subtract xmm1 and put result in xmm0.

pub fn vfnmsub213pd_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Multiply packed double-precision floating-point values from xmm0 and xmm1, negate the multiplication result and subtract xmm2/mem and put result in xmm0.

pub fn vfnmsub213pd_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Multiply packed double-precision floating-point values from xmm0 and xmm1, negate the multiplication result and subtract xmm2/mem and put result in xmm0.

pub fn vfnmsub213pd_YMM_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory
)

Multiply packed double-precision floating-point values from ymm0 and ymm1, negate the multiplication result and subtract ymm2/mem and put result in ymm0.

pub fn vfnmsub213pd_YMM_YMM_YMM(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister
)

Multiply packed double-precision floating-point values from ymm0 and ymm1, negate the multiplication result and subtract ymm2/mem and put result in ymm0.

pub fn vfnmsub213ps_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Multiply packed single-precision floating-point values from xmm0 and xmm1, negate the multiplication result and subtract xmm2/mem and put result in xmm0.

pub fn vfnmsub213ps_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Multiply packed single-precision floating-point values from xmm0 and xmm1, negate the multiplication result and subtract xmm2/mem and put result in xmm0.

pub fn vfnmsub213ps_YMM_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory
)

Multiply packed single-precision floating-point values from ymm0 and ymm1, negate the multiplication result and subtract ymm2/mem and put result in ymm0.

pub fn vfnmsub213ps_YMM_YMM_YMM(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister
)

Multiply packed single-precision floating-point values from ymm0 and ymm1, negate the multiplication result and subtract ymm2/mem and put result in ymm0.

pub fn vfnmsub213sd_XMMRegister_XMMRegister_Any64BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any64BitMemory
)

Multiply scalar double-precision floating-point value from xmm0 and xmm1, negate the multiplication result and subtract xmm2/mem and put result in xmm0.

pub fn vfnmsub213sd_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Multiply scalar double-precision floating-point value from xmm0 and xmm1, negate the multiplication result and subtract xmm2/mem and put result in xmm0.

pub fn vfnmsub213ss_XMMRegister_XMMRegister_Any32BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any32BitMemory
)

Multiply scalar single-precision floating-point value from xmm0 and xmm1, negate the multiplication result and subtract xmm2/mem and put result in xmm0.

pub fn vfnmsub213ss_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Multiply scalar single-precision floating-point value from xmm0 and xmm1, negate the multiplication result and subtract xmm2/mem and put result in xmm0.

pub fn vfnmsub231pd_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Multiply packed double-precision floating-point values from xmm1 and xmm2/mem, negate the multiplication result and subtract xmm0 and put result in xmm0.

pub fn vfnmsub231pd_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Multiply packed double-precision floating-point values from xmm1 and xmm2/mem, negate the multiplication result and subtract xmm0 and put result in xmm0.

pub fn vfnmsub231pd_YMM_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory
)

Multiply packed double-precision floating-point values from ymm1 and ymm2/mem, negate the multiplication result and subtract ymm0 and put result in ymm0.

pub fn vfnmsub231pd_YMM_YMM_YMM(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister
)

Multiply packed double-precision floating-point values from ymm1 and ymm2/mem, negate the multiplication result and subtract ymm0 and put result in ymm0.

pub fn vfnmsub231ps_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Multiply packed single-precision floating-point values from xmm1 and xmm2/mem, negate the multiplication result and subtract xmm0 and put result in xmm0.

pub fn vfnmsub231ps_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Multiply packed single-precision floating-point values from xmm1 and xmm2/mem, negate the multiplication result and subtract xmm0 and put result in xmm0.

pub fn vfnmsub231ps_YMM_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory
)

Multiply packed single-precision floating-point values from ymm1 and ymm2/mem, negate the multiplication result and subtract ymm0 and put result in ymm0.

pub fn vfnmsub231ps_YMM_YMM_YMM(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister
)

Multiply packed single-precision floating-point values from ymm1 and ymm2/mem, negate the multiplication result and subtract ymm0 and put result in ymm0.

pub fn vfnmsub231sd_XMMRegister_XMMRegister_Any64BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any64BitMemory
)

Multiply scalar double-precision floating-point value from xmm1 and xmm2/mem, negate the multiplication result and subtract xmm0 and put result in xmm0.

pub fn vfnmsub231sd_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Multiply scalar double-precision floating-point value from xmm1 and xmm2/mem, negate the multiplication result and subtract xmm0 and put result in xmm0.

pub fn vfnmsub231ss_XMMRegister_XMMRegister_Any32BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any32BitMemory
)

Multiply scalar single-precision floating-point value from xmm1 and xmm2/mem, negate the multiplication result and subtract xmm0 and put result in xmm0.

pub fn vfnmsub231ss_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Multiply scalar single-precision floating-point value from xmm1 and xmm2/mem, negate the multiplication result and subtract xmm0 and put result in xmm0.

pub fn vgatherdpd_XMMRegister_Any32BitMemory_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: Any32BitMemory,
    arg2: XMMRegister
)

Using dword indices specified in vm32x, gather double-precision FP values from memory conditioned on mask specified by xmm2.

Conditionally gathered elements are merged into xmm1.

pub fn vgatherdpd_YMM_Any32BitMemory_YMM(
    &mut self,
    arg0: YMMRegister,
    arg1: Any32BitMemory,
    arg2: YMMRegister
)

Using dword indices specified in vm32x, gather double-precision FP values from memory conditioned on mask specified by ymm2.

Conditionally gathered elements are merged into ymm1.

pub fn vgatherdps_XMMRegister_Any32BitMemory_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: Any32BitMemory,
    arg2: XMMRegister
)

Using dword indices specified in vm32x, gather single-precision FP values from memory conditioned on mask specified by xmm2.

Conditionally gathered elements are merged into xmm1.

pub fn vgatherdps_YMM_Any32BitMemory_YMM(
    &mut self,
    arg0: YMMRegister,
    arg1: Any32BitMemory,
    arg2: YMMRegister
)

Using dword indices specified in vm32x, gather single-precision FP values from memory conditioned on mask specified by ymm2.

Conditionally gathered elements are merged into ymm1.

pub fn vgatherqpd_XMMRegister_Any64BitMemory_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: Any64BitMemory,
    arg2: XMMRegister
)

Using qword indices specified in vm64x, gather double-precision FP values from memory conditioned on mask specified by xmm2.

Conditionally gathered elements are merged into xmm1.

pub fn vgatherqpd_YMM_Any64BitMemory_YMM(
    &mut self,
    arg0: YMMRegister,
    arg1: Any64BitMemory,
    arg2: YMMRegister
)

Using qword indices specified in vm64y, gather double-precision FP values from memory conditioned on mask specified by ymm2.

Conditionally gathered elements are merged into ymm1.

pub fn vgatherqps_XMMRegister_Any64BitMemory_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: Any64BitMemory,
    arg2: XMMRegister
)

Using qword indices specified in vm64x, gather single-precision FP values from memory conditioned on mask specified by xmm2.

Conditionally gathered elements are merged into xmm1.

pub fn vgatherqps_XMMRegister_Any64BitMemory_XMMRegister_1(
    &mut self,
    arg0: XMMRegister,
    arg1: Any64BitMemory,
    arg2: XMMRegister
)

Using qword indices specified in vm64x, gather single-precision FP values from memory conditioned on mask specified by xmm2.

Conditionally gathered elements are merged into xmm1.

pub fn vhaddpd_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Horizontal add packed double-precision floating-point values from xmm2 and xmm3/mem.

pub fn vhaddpd_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Horizontal add packed double-precision floating-point values from xmm2 and xmm3/mem.

pub fn vhaddpd_YMM_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory
)

Horizontal add packed double-precision floating-point values from ymm2 and ymm3/mem.

pub fn vhaddpd_YMM_YMM_YMM(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister
)

Horizontal add packed double-precision floating-point values from ymm2 and ymm3/mem.

pub fn vhaddps_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Horizontal add packed single-precision floating-point values from xmm2 and xmm3/mem.

pub fn vhaddps_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Horizontal add packed single-precision floating-point values from xmm2 and xmm3/mem.

pub fn vhaddps_YMM_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory
)

Horizontal add packed single-precision floating-point values from ymm2 and ymm3/mem.

pub fn vhaddps_YMM_YMM_YMM(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister
)

Horizontal add packed single-precision floating-point values from ymm2 and ymm3/mem.

pub fn vhsubpd_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Horizontal subtract packed double-precision floating-point values from xmm2 and xmm3/mem.

pub fn vhsubpd_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Horizontal subtract packed double-precision floating-point values from xmm2 and xmm3/mem.

pub fn vhsubpd_YMM_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory
)

Horizontal subtract packed double-precision floating-point values from ymm2 and ymm3/mem.

pub fn vhsubpd_YMM_YMM_YMM(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister
)

Horizontal subtract packed double-precision floating-point values from ymm2 and ymm3/mem.

pub fn vhsubps_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Horizontal subtract packed single-precision floating-point values from xmm2 and xmm3/mem.

pub fn vhsubps_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Horizontal subtract packed single-precision floating-point values from xmm2 and xmm3/mem.

pub fn vhsubps_YMM_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory
)

Horizontal subtract packed single-precision floating-point values from ymm2 and ymm3/mem.

pub fn vhsubps_YMM_YMM_YMM(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister
)

Horizontal subtract packed single-precision floating-point values from ymm2 and ymm3/mem.

pub fn vinsertf128_YMM_YMM_Any128BitMemory_Immediate8Bit(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any128BitMemory,
    arg3: Immediate8Bit
)

Insert a single-precision floating-point value selected by imm8 from xmm3/m128 into ymm2 at the specified destination element specified by imm8 and zero out destination elements in ymm1 as indicated in imm8.

pub fn vinsertf128_YMM_YMM_XMMRegister_Immediate8Bit(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: XMMRegister,
    arg3: Immediate8Bit
)

Insert a single-precision floating-point value selected by imm8 from xmm3/m128 into ymm2 at the specified destination element specified by imm8 and zero out destination elements in ymm1 as indicated in imm8.

pub fn vinserti128_YMM_YMM_Any128BitMemory_Immediate8Bit(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any128BitMemory,
    arg3: Immediate8Bit
)

Insert 128-bits of integer data from xmm3/mem and the remaining values from ymm2 into ymm1.

pub fn vinserti128_YMM_YMM_XMMRegister_Immediate8Bit(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: XMMRegister,
    arg3: Immediate8Bit
)

Insert 128-bits of integer data from xmm3/mem and the remaining values from ymm2 into ymm1.

pub fn vinsertps_XMMRegister_XMMRegister_Any32BitMemory_Immediate8Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any32BitMemory,
    arg3: Immediate8Bit
)

Insert a single-precision floating-point value selected by imm8 from xmm3/m32 and merge into xmm2 at the specified destination element specified by imm8 and zero out destination elements in xmm1 as indicated in imm8.

pub fn vinsertps_XMMRegister_XMMRegister_XMMRegister_Immediate8Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister,
    arg3: Immediate8Bit
)

Insert a single-precision floating-point value selected by imm8 from xmm3/m32 and merge into xmm2 at the specified destination element specified by imm8 and zero out destination elements in xmm1 as indicated in imm8.

pub fn vlddqu_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Load unaligned packed integer values from mem to xmm1.

pub fn vlddqu_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: Any256BitMemory
)

Load unaligned packed integer values from mem to ymm1.

pub fn vldmxcsr_Any32BitMemory(&mut self, arg0: Any32BitMemory)

Load MXCSR register from m32.

pub fn vmaskmovdqu_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Selectively write bytes from xmm1 to memory location using the byte mask in xmm2.

The default memory location is specified by DS:DI, EDI or RDI.

pub fn vmaskmovpd_Any128BitMemory_XMMRegister_XMMRegister(
    &mut self,
    arg0: Any128BitMemory,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Conditionally store packed double-precision values from xmm2 using mask in xmm1.

pub fn vmaskmovpd_Any256BitMemory_YMM_YMM(
    &mut self,
    arg0: Any256BitMemory,
    arg1: YMMRegister,
    arg2: YMMRegister
)

Conditionally store packed double-precision values from ymm2 using mask in ymm1.

pub fn vmaskmovpd_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Conditionally load packed double-precision values from m128 using mask in xmm2 and store in xmm1.

pub fn vmaskmovpd_YMM_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory
)

Conditionally load packed double-precision values from m256 using mask in ymm2 and store in ymm1.

pub fn vmaskmovps_Any128BitMemory_XMMRegister_XMMRegister(
    &mut self,
    arg0: Any128BitMemory,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Conditionally store packed single-precision values from xmm2 using mask in xmm1.

pub fn vmaskmovps_Any256BitMemory_YMM_YMM(
    &mut self,
    arg0: Any256BitMemory,
    arg1: YMMRegister,
    arg2: YMMRegister
)

Conditionally store packed single-precision values from ymm2 using mask in ymm1.

pub fn vmaskmovps_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Conditionally load packed single-precision values from m128 using mask in xmm2 and store in xmm1.

pub fn vmaskmovps_YMM_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory
)

Conditionally load packed single-precision values from m256 using mask in ymm2 and store in ymm1.

pub fn vmaxpd_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Return the maximum double-precision floating-point values between xmm2 and xmm3/mem.

pub fn vmaxpd_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Return the maximum double-precision floating-point values between xmm2 and xmm3/mem.

pub fn vmaxpd_YMM_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory
)

Return the maximum packed double-precision floating-point values between ymm2 and ymm3/mem.

pub fn vmaxpd_YMM_YMM_YMM(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister
)

Return the maximum packed double-precision floating-point values between ymm2 and ymm3/mem.

pub fn vmaxps_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Return the maximum single-precision floating-point values between xmm2 and xmm3/mem.

pub fn vmaxps_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Return the maximum single-precision floating-point values between xmm2 and xmm3/mem.

pub fn vmaxps_YMM_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory
)

Return the maximum single double-precision floating-point values between ymm2 and ymm3/mem.

pub fn vmaxps_YMM_YMM_YMM(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister
)

Return the maximum single double-precision floating-point values between ymm2 and ymm3/mem.

pub fn vmaxsd_XMMRegister_XMMRegister_Any64BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any64BitMemory
)

Return the maximum scalar double-precision floating-point value between xmm3/mem.4 and xmm2.

pub fn vmaxsd_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Return the maximum scalar double-precision floating-point value between xmm3/mem.4 and xmm2.

pub fn vmaxss_XMMRegister_XMMRegister_Any32BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any32BitMemory
)

Return the maximum scalar single-precision floating-point value between xmm3/mem.2 and xmm2.

pub fn vmaxss_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Return the maximum scalar single-precision floating-point value between xmm3/mem.2 and xmm2.

pub fn vminpd_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Return the minimum double-precision floating-point values between xmm2 and xmm3/mem.

pub fn vminpd_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Return the minimum double-precision floating-point values between xmm2 and xmm3/mem.

pub fn vminpd_YMM_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory
)

Return the minimum packed double-precision floating-point values between ymm2 and ymm3/mem.

pub fn vminpd_YMM_YMM_YMM(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister
)

Return the minimum packed double-precision floating-point values between ymm2 and ymm3/mem.

pub fn vminps_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Return the minimum single-precision floating-point values between xmm2 and xmm3/mem.

pub fn vminps_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Return the minimum single-precision floating-point values between xmm2 and xmm3/mem.

pub fn vminps_YMM_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory
)

Return the minimum single double-precision floating-point values between ymm2 and ymm3/mem.

pub fn vminps_YMM_YMM_YMM(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister
)

Return the minimum single double-precision floating-point values between ymm2 and ymm3/mem.

pub fn vminsd_XMMRegister_XMMRegister_Any64BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any64BitMemory
)

Return the minimum scalar double-precision floating-point value between xmm3/mem4 and xmm2.

pub fn vminsd_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Return the minimum scalar double-precision floating-point value between xmm3/mem4 and xmm2.

pub fn vminss_XMMRegister_XMMRegister_Any32BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any32BitMemory
)

Return the minimum scalar single-precision floating-point value between xmm3/mem2 and xmm2.

pub fn vminss_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Return the minimum scalar single-precision floating-point value between xmm3/mem2 and xmm2.

pub fn vmovapd_Any128BitMemory_XMMRegister(
    &mut self,
    arg0: Any128BitMemory,
    arg1: XMMRegister
)

Move aligned packed double-precision floating-point values from xmm1 to xmm2/mem.

pub fn vmovapd_Any256BitMemory_YMM(
    &mut self,
    arg0: Any256BitMemory,
    arg1: YMMRegister
)

Move aligned packed double-precision floating-point values from ymm1 to ymm2/mem.

pub fn vmovapd_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Move aligned packed double-precision floating-point values from xmm2/mem to xmm1.

pub fn vmovapd_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Move aligned packed double-precision floating-point values from xmm2/mem to xmm1.

pub fn vmovapd_XMMRegister_XMMRegister_1(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Move aligned packed double-precision floating-point values from xmm1 to xmm2/mem.

pub fn vmovapd_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: Any256BitMemory
)

Move aligned packed double-precision floating-point values from ymm2/mem to ymm1.

pub fn vmovapd_YMM_YMM(&mut self, arg0: YMMRegister, arg1: YMMRegister)

Move aligned packed double-precision floating-point values from ymm2/mem to ymm1.

pub fn vmovapd_YMM_YMM_1(&mut self, arg0: YMMRegister, arg1: YMMRegister)

Move aligned packed double-precision floating-point values from ymm1 to ymm2/mem.

pub fn vmovaps_Any128BitMemory_XMMRegister(
    &mut self,
    arg0: Any128BitMemory,
    arg1: XMMRegister
)

Move aligned packed single-precision floating-point values from xmm1 to xmm2/mem.

pub fn vmovaps_Any256BitMemory_YMM(
    &mut self,
    arg0: Any256BitMemory,
    arg1: YMMRegister
)

Move aligned packed single-precision floating-point values from ymm1 to ymm2/mem.

pub fn vmovaps_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Move aligned packed single-precision floating-point values from xmm2/mem to xmm1.

pub fn vmovaps_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Move aligned packed single-precision floating-point values from xmm2/mem to xmm1.

pub fn vmovaps_XMMRegister_XMMRegister_1(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Move aligned packed single-precision floating-point values from xmm1 to xmm2/mem.

pub fn vmovaps_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: Any256BitMemory
)

Move aligned packed single-precision floating-point values from ymm2/mem to ymm1.

pub fn vmovaps_YMM_YMM(&mut self, arg0: YMMRegister, arg1: YMMRegister)

Move aligned packed single-precision floating-point values from ymm2/mem to ymm1.

pub fn vmovaps_YMM_YMM_1(&mut self, arg0: YMMRegister, arg1: YMMRegister)

Move aligned packed single-precision floating-point values from ymm1 to ymm2/mem.

pub fn vmovd_Any32BitMemory_XMMRegister(
    &mut self,
    arg0: Any32BitMemory,
    arg1: XMMRegister
)

Move doubleword from xmm1 register to r/m32.

pub fn vmovd_Register32Bit_XMMRegister(
    &mut self,
    arg0: Register32Bit,
    arg1: XMMRegister
)

Move doubleword from xmm1 register to r/m32.

pub fn vmovd_XMMRegister_Any32BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any32BitMemory
)

Move doubleword from r/m32 to xmm1.

pub fn vmovd_XMMRegister_Register32Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: Register32Bit
)

Move doubleword from r/m32 to xmm1.

pub fn vmovddup_XMMRegister_Any64BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any64BitMemory
)

Move double-precision floating-point values from xmm2/mem and duplicate into xmm1.

pub fn vmovddup_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Move double-precision floating-point values from xmm2/mem and duplicate into xmm1.

pub fn vmovddup_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: Any256BitMemory
)

Move even index double-precision floating-point values from ymm2/mem and duplicate each element into ymm1.

pub fn vmovddup_YMM_YMM(&mut self, arg0: YMMRegister, arg1: YMMRegister)

Move even index double-precision floating-point values from ymm2/mem and duplicate each element into ymm1.

pub fn vmovdqa_Any128BitMemory_XMMRegister(
    &mut self,
    arg0: Any128BitMemory,
    arg1: XMMRegister
)

Move aligned packed integer values from xmm1 to xmm2/mem.

pub fn vmovdqa_Any256BitMemory_YMM(
    &mut self,
    arg0: Any256BitMemory,
    arg1: YMMRegister
)

Move aligned packed integer values from ymm1 to ymm2/mem.

pub fn vmovdqa_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Move aligned packed integer values from xmm2/mem to xmm1.

pub fn vmovdqa_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Move aligned packed integer values from xmm2/mem to xmm1.

pub fn vmovdqa_XMMRegister_XMMRegister_1(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Move aligned packed integer values from xmm1 to xmm2/mem.

pub fn vmovdqa_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: Any256BitMemory
)

Move aligned packed integer values from ymm2/mem to ymm1.

pub fn vmovdqa_YMM_YMM(&mut self, arg0: YMMRegister, arg1: YMMRegister)

Move aligned packed integer values from ymm2/mem to ymm1.

pub fn vmovdqa_YMM_YMM_1(&mut self, arg0: YMMRegister, arg1: YMMRegister)

Move aligned packed integer values from ymm1 to ymm2/mem.

pub fn vmovdqu_Any128BitMemory_XMMRegister(
    &mut self,
    arg0: Any128BitMemory,
    arg1: XMMRegister
)

Move unaligned packed integer values from xmm1 to xmm2/mem.

pub fn vmovdqu_Any256BitMemory_YMM(
    &mut self,
    arg0: Any256BitMemory,
    arg1: YMMRegister
)

Move unaligned packed integer values from ymm1 to ymm2/mem.

pub fn vmovdqu_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Move unaligned packed integer values from xmm2/mem to xmm1.

pub fn vmovdqu_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Move unaligned packed integer values from xmm2/mem to xmm1.

pub fn vmovdqu_XMMRegister_XMMRegister_1(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Move unaligned packed integer values from xmm1 to xmm2/mem.

pub fn vmovdqu_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: Any256BitMemory
)

Move unaligned packed integer values from ymm2/mem to ymm1.

pub fn vmovdqu_YMM_YMM(&mut self, arg0: YMMRegister, arg1: YMMRegister)

Move unaligned packed integer values from ymm2/mem to ymm1.

pub fn vmovdqu_YMM_YMM_1(&mut self, arg0: YMMRegister, arg1: YMMRegister)

Move unaligned packed integer values from ymm1 to ymm2/mem.

pub fn vmovhlps_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Merge two packed single-precision floating-point values from high quadword of xmm3 and low quadword of xmm2.

pub fn vmovhpd_Any64BitMemory_XMMRegister(
    &mut self,
    arg0: Any64BitMemory,
    arg1: XMMRegister
)

Move double-precision floating-point values from high quadword of xmm1 to m64.

pub fn vmovhpd_XMMRegister_XMMRegister_Any64BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any64BitMemory
)

Merge double-precision floating-point value from m64 and the low quadword of xmm1.

pub fn vmovhps_Any64BitMemory_XMMRegister(
    &mut self,
    arg0: Any64BitMemory,
    arg1: XMMRegister
)

Move two packed single-precision floating-point values from high quadword of xmm1to m64.

pub fn vmovhps_XMMRegister_XMMRegister_Any64BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any64BitMemory
)

Merge two packed single-precision floating-point values from m64 and the low quadword of xmm1.

pub fn vmovlhps_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Merge two packed single-precision floating-point values from low quadword of xmm3 and low quadword of xmm2.

pub fn vmovlpd_Any64BitMemory_XMMRegister(
    &mut self,
    arg0: Any64BitMemory,
    arg1: XMMRegister
)

Move double-precision floating-point values from low quadword of xmm1 to m64.

pub fn vmovlpd_XMMRegister_XMMRegister_Any64BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any64BitMemory
)

Merge double-precision floating-point value from m64 and the high quadword of xmm1.

pub fn vmovlps_Any64BitMemory_XMMRegister(
    &mut self,
    arg0: Any64BitMemory,
    arg1: XMMRegister
)

Move two packed single-precision floating-point values from low quadword of xmm1 to m64.

pub fn vmovlps_XMMRegister_XMMRegister_Any64BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any64BitMemory
)

Merge two packed single-precision floating-point values from m64 and the high quadword of xmm1.

pub fn vmovmskpd_Register32Bit_XMMRegister(
    &mut self,
    arg0: Register32Bit,
    arg1: XMMRegister
)

Extract 2-bit sign mask from xmm2 and store in register.

The upper bits of r32 or r64 are zeroed.

pub fn vmovmskpd_Register32Bit_YMM(
    &mut self,
    arg0: Register32Bit,
    arg1: YMMRegister
)

Extract 4-bit sign mask from ymm2 and store in register.

The upper bits of r32 or r64 are zeroed.

pub fn vmovmskpd_Register64Bit_XMMRegister(
    &mut self,
    arg0: Register64Bit,
    arg1: XMMRegister
)

Extract 2-bit sign mask from xmm2 and store in register.

The upper bits of r32 or r64 are zeroed.

pub fn vmovmskpd_Register64Bit_YMM(
    &mut self,
    arg0: Register64Bit,
    arg1: YMMRegister
)

Extract 4-bit sign mask from ymm2 and store in register.

The upper bits of r32 or r64 are zeroed.

pub fn vmovmskps_Register32Bit_XMMRegister(
    &mut self,
    arg0: Register32Bit,
    arg1: XMMRegister
)

Extract 4-bit sign mask from xmm2 and store in register.

The upper bits of r32 or r64 are zeroed.

pub fn vmovmskps_Register32Bit_YMM(
    &mut self,
    arg0: Register32Bit,
    arg1: YMMRegister
)

Extract 8-bit sign mask from ymm2 and store in register.

The upper bits of r32 or r64 are zeroed.

pub fn vmovmskps_Register64Bit_XMMRegister(
    &mut self,
    arg0: Register64Bit,
    arg1: XMMRegister
)

Extract 4-bit sign mask from xmm2 and store in register.

The upper bits of r32 or r64 are zeroed.

pub fn vmovmskps_Register64Bit_YMM(
    &mut self,
    arg0: Register64Bit,
    arg1: YMMRegister
)

Extract 8-bit sign mask from ymm2 and store in register.

The upper bits of r32 or r64 are zeroed.

pub fn vmovntdq_Any128BitMemory_XMMRegister(
    &mut self,
    arg0: Any128BitMemory,
    arg1: XMMRegister
)

Move packed integer values in xmm1 to m128 using non-temporal hint.

pub fn vmovntdq_Any256BitMemory_YMM(
    &mut self,
    arg0: Any256BitMemory,
    arg1: YMMRegister
)

Move packed integer values in ymm1 to m256 using non-temporal hint.

pub fn vmovntdqa_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Move double quadword from m128 to xmm using non-temporal hint if WC memory type.

pub fn vmovntdqa_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: Any256BitMemory
)

Move 256-bit data from m256 to ymm using non-temporal hint if WC memory type.

pub fn vmovntpd_Any128BitMemory_XMMRegister(
    &mut self,
    arg0: Any128BitMemory,
    arg1: XMMRegister
)

Move packed double-precision values in xmm1 to m128 using non-temporal hint.

pub fn vmovntpd_Any256BitMemory_YMM(
    &mut self,
    arg0: Any256BitMemory,
    arg1: YMMRegister
)

Move packed double-precision values in ymm1 to m256 using non-temporal hint.

pub fn vmovntps_Any128BitMemory_XMMRegister(
    &mut self,
    arg0: Any128BitMemory,
    arg1: XMMRegister
)

Move packed single-precision values xmm1 to mem using non-temporal hint.

pub fn vmovntps_Any256BitMemory_YMM(
    &mut self,
    arg0: Any256BitMemory,
    arg1: YMMRegister
)

Move packed single-precision values ymm1 to mem using non-temporal hint.

pub fn vmovq_Any64BitMemory_XMMRegister(
    &mut self,
    arg0: Any64BitMemory,
    arg1: XMMRegister
)

Move quadword from xmm1 register to r/m64.

pub fn vmovq_Any64BitMemory_XMMRegister_1(
    &mut self,
    arg0: Any64BitMemory,
    arg1: XMMRegister
)

Move quadword from xmm2 register to xmm1/m64.

pub fn vmovq_Register64Bit_XMMRegister(
    &mut self,
    arg0: Register64Bit,
    arg1: XMMRegister
)

Move quadword from xmm1 register to r/m64.

pub fn vmovq_XMMRegister_Any64BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any64BitMemory
)

Move quadword from r/m64 to xmm1.

pub fn vmovq_XMMRegister_Any64BitMemory_1(
    &mut self,
    arg0: XMMRegister,
    arg1: Any64BitMemory
)

Load quadword from m64 to xmm1.

pub fn vmovq_XMMRegister_Register64Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: Register64Bit
)

Move quadword from r/m64 to xmm1.

pub fn vmovq_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Move quadword from xmm2 to xmm1.

pub fn vmovq_XMMRegister_XMMRegister_1(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Move quadword from xmm2 register to xmm1/m64.

pub fn vmovsd_Any64BitMemory_XMMRegister(
    &mut self,
    arg0: Any64BitMemory,
    arg1: XMMRegister
)

Move scalar double-precision floating-point value from xmm1 register to m64.

pub fn vmovsd_XMMRegister_Any64BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any64BitMemory
)

Load scalar double-precision floating-point value from m64 to xmm1.

pub fn vmovsd_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Merge scalar double-precision floating-point value from xmm2 and xmm3 to xmm1.

pub fn vmovsd_XMMRegister_XMMRegister_XMMRegister_1(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Merge scalar double-precision floating-point value from xmm2 and xmm3 to xmm1.

pub fn vmovshdup_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Move odd index single-precision floating-point values from xmm2/mem and duplicate each element into xmm1.

pub fn vmovshdup_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Move odd index single-precision floating-point values from xmm2/mem and duplicate each element into xmm1.

pub fn vmovshdup_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: Any256BitMemory
)

Move odd index single-precision floating-point values from ymm2/mem and duplicate each element into ymm1.

pub fn vmovshdup_YMM_YMM(&mut self, arg0: YMMRegister, arg1: YMMRegister)

Move odd index single-precision floating-point values from ymm2/mem and duplicate each element into ymm1.

pub fn vmovsldup_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Move even index single-precision floating-point values from xmm2/mem and duplicate each element into xmm1.

pub fn vmovsldup_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Move even index single-precision floating-point values from xmm2/mem and duplicate each element into xmm1.

pub fn vmovsldup_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: Any256BitMemory
)

Move even index single-precision floating-point values from ymm2/mem and duplicate each element into ymm1.

pub fn vmovsldup_YMM_YMM(&mut self, arg0: YMMRegister, arg1: YMMRegister)

Move even index single-precision floating-point values from ymm2/mem and duplicate each element into ymm1.

pub fn vmovss_Any32BitMemory_XMMRegister(
    &mut self,
    arg0: Any32BitMemory,
    arg1: XMMRegister
)

Move scalar single-precision floating-point value from xmm1 register to m32.

pub fn vmovss_XMMRegister_Any32BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any32BitMemory
)

Load scalar single-precision floating-point value from m32 to xmm1.

pub fn vmovss_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Merge scalar single-precision floating-point value from xmm2 and xmm3 to xmm1.

pub fn vmovss_XMMRegister_XMMRegister_XMMRegister_1(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Merge scalar single-precision floating-point value from xmm2 and xmm3 to xmm1.

pub fn vmovupd_Any128BitMemory_XMMRegister(
    &mut self,
    arg0: Any128BitMemory,
    arg1: XMMRegister
)

Move unaligned packed double-precision floating-point from xmm1 to xmm2/mem.

pub fn vmovupd_Any256BitMemory_YMM(
    &mut self,
    arg0: Any256BitMemory,
    arg1: YMMRegister
)

Move unaligned packed double-precision floating-point from ymm1 to ymm2/mem.

pub fn vmovupd_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Move unaligned packed double-precision floating-point from xmm2/mem to xmm1.

pub fn vmovupd_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Move unaligned packed double-precision floating-point from xmm2/mem to xmm1.

pub fn vmovupd_XMMRegister_XMMRegister_1(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Move unaligned packed double-precision floating-point from xmm1 to xmm2/mem.

pub fn vmovupd_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: Any256BitMemory
)

Move unaligned packed double-precision floating-point from ymm2/mem to ymm1.

pub fn vmovupd_YMM_YMM(&mut self, arg0: YMMRegister, arg1: YMMRegister)

Move unaligned packed double-precision floating-point from ymm2/mem to ymm1.

pub fn vmovupd_YMM_YMM_1(&mut self, arg0: YMMRegister, arg1: YMMRegister)

Move unaligned packed double-precision floating-point from ymm1 to ymm2/mem.

pub fn vmovups_Any128BitMemory_XMMRegister(
    &mut self,
    arg0: Any128BitMemory,
    arg1: XMMRegister
)

Move unaligned packed single-precision floating-point from xmm1 to xmm2/mem.

pub fn vmovups_Any256BitMemory_YMM(
    &mut self,
    arg0: Any256BitMemory,
    arg1: YMMRegister
)

Move unaligned packed single-precision floating-point from ymm1 to ymm2/mem.

pub fn vmovups_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Move unaligned packed single-precision floating-point from xmm2/mem to xmm1.

pub fn vmovups_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Move unaligned packed single-precision floating-point from xmm2/mem to xmm1.

pub fn vmovups_XMMRegister_XMMRegister_1(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Move unaligned packed single-precision floating-point from xmm1 to xmm2/mem.

pub fn vmovups_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: Any256BitMemory
)

Move unaligned packed single-precision floating-point from ymm2/mem to ymm1.

pub fn vmovups_YMM_YMM(&mut self, arg0: YMMRegister, arg1: YMMRegister)

Move unaligned packed single-precision floating-point from ymm2/mem to ymm1.

pub fn vmovups_YMM_YMM_1(&mut self, arg0: YMMRegister, arg1: YMMRegister)

Move unaligned packed single-precision floating-point from ymm1 to ymm2/mem.

pub fn vmpsadbw_XMMRegister_XMMRegister_Any128BitMemory_Immediate8Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory,
    arg3: Immediate8Bit
)

Sums absolute 8-bit integer difference of adjacent groups of 4 byte integers in xmm2 and xmm3/m128 and writes the results in xmm1.

Starting offsets within xmm2 and xmm3/m128 are determined by imm8.

pub fn vmpsadbw_XMMRegister_XMMRegister_XMMRegister_Immediate8Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister,
    arg3: Immediate8Bit
)

Sums absolute 8-bit integer difference of adjacent groups of 4 byte integers in xmm2 and xmm3/m128 and writes the results in xmm1.

Starting offsets within xmm2 and xmm3/m128 are determined by imm8.

pub fn vmpsadbw_YMM_YMM_Any256BitMemory_Immediate8Bit(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory,
    arg3: Immediate8Bit
)

Sums absolute 8-bit integer difference of adjacent groups of 4 byte integers in xmm2 and ymm3/m128 and writes the results in ymm1.

Starting offsets within ymm2 and xmm3/m128 are determined by imm8.

pub fn vmpsadbw_YMM_YMM_YMM_Immediate8Bit(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister,
    arg3: Immediate8Bit
)

Sums absolute 8-bit integer difference of adjacent groups of 4 byte integers in xmm2 and ymm3/m128 and writes the results in ymm1.

Starting offsets within ymm2 and xmm3/m128 are determined by imm8.

pub fn vmulpd_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Multiply packed double-precision floating-point values from xmm3/mem to xmm2 and stores result in xmm1.

pub fn vmulpd_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Multiply packed double-precision floating-point values from xmm3/mem to xmm2 and stores result in xmm1.

pub fn vmulpd_YMM_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory
)

Multiply packed double-precision floating-point values from ymm3/mem to ymm2 and stores result in ymm1.

pub fn vmulpd_YMM_YMM_YMM(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister
)

Multiply packed double-precision floating-point values from ymm3/mem to ymm2 and stores result in ymm1.

pub fn vmulps_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Multiply packed single-precision floating-point values from xmm3/mem to xmm2 and stores result in xmm1.

pub fn vmulps_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Multiply packed single-precision floating-point values from xmm3/mem to xmm2 and stores result in xmm1.

pub fn vmulps_YMM_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory
)

Multiply packed single-precision floating-point values from ymm3/mem to ymm2 and stores result in ymm1.

pub fn vmulps_YMM_YMM_YMM(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister
)

Multiply packed single-precision floating-point values from ymm3/mem to ymm2 and stores result in ymm1.

pub fn vmulsd_XMMRegister_XMMRegister_Any64BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any64BitMemory
)

Multiply the low double-precision floating-point value in xmm3/mem4 by low double-precision floating-point value in xmm2.

pub fn vmulsd_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Multiply the low double-precision floating-point value in xmm3/mem4 by low double-precision floating-point value in xmm2.

pub fn vmulss_XMMRegister_XMMRegister_Any32BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any32BitMemory
)

Multiply the low single-precision floating-point value in xmm3/mem by the low single-precision floating-point value in xmm2.

pub fn vmulss_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Multiply the low single-precision floating-point value in xmm3/mem by the low single-precision floating-point value in xmm2.

pub fn vorpd_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Return the bitwise logical OR of packed double-precision floating-point values in xmm2 and xmm3/mem.

pub fn vorpd_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Return the bitwise logical OR of packed double-precision floating-point values in xmm2 and xmm3/mem.

pub fn vorpd_YMM_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory
)

Return the bitwise logical OR of packed double-precision floating-point values in ymm2 and ymm3/mem.

pub fn vorpd_YMM_YMM_YMM(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister
)

Return the bitwise logical OR of packed double-precision floating-point values in ymm2 and ymm3/mem.

pub fn vorps_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Return the bitwise logical OR of packed single-precision floating-point values in xmm2 and xmm3/mem.

pub fn vorps_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Return the bitwise logical OR of packed single-precision floating-point values in xmm2 and xmm3/mem.

pub fn vorps_YMM_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory
)

Return the bitwise logical OR of packed single-precision floating-point values in ymm2 and ymm3/mem.

pub fn vorps_YMM_YMM_YMM(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister
)

Return the bitwise logical OR of packed single-precision floating-point values in ymm2 and ymm3/mem.

pub fn vpabsb_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Compute the absolute value of bytes in xmm2/m128 and store unsigned result in xmm1.

pub fn vpabsb_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Compute the absolute value of bytes in xmm2/m128 and store unsigned result in xmm1.

pub fn vpabsb_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: Any256BitMemory
)

Compute the absolute value of bytes in ymm2/m256 and store unsigned result in ymm1.

pub fn vpabsb_YMM_YMM(&mut self, arg0: YMMRegister, arg1: YMMRegister)

Compute the absolute value of bytes in ymm2/m256 and store unsigned result in ymm1.

pub fn vpabsd_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Compute the absolute value of 32-bit integers in xmm2/m128 and store unsigned result in xmm1.

pub fn vpabsd_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Compute the absolute value of 32-bit integers in xmm2/m128 and store unsigned result in xmm1.

pub fn vpabsd_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: Any256BitMemory
)

Compute the absolute value of 32-bit integers in ymm2/m256 and store unsigned result in ymm1.

pub fn vpabsd_YMM_YMM(&mut self, arg0: YMMRegister, arg1: YMMRegister)

Compute the absolute value of 32-bit integers in ymm2/m256 and store unsigned result in ymm1.

pub fn vpabsw_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Compute the absolute value of 16-bit integers in xmm2/m128 and store unsigned result in xmm1.

pub fn vpabsw_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Compute the absolute value of 16-bit integers in xmm2/m128 and store unsigned result in xmm1.

pub fn vpabsw_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: Any256BitMemory
)

Compute the absolute value of 16-bit integers in ymm2/m256 and store unsigned result in ymm1.

pub fn vpabsw_YMM_YMM(&mut self, arg0: YMMRegister, arg1: YMMRegister)

Compute the absolute value of 16-bit integers in ymm2/m256 and store unsigned result in ymm1.

pub fn vpackssdw_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Converts 4 packed signed doubleword integers from xmm2 and from xmm3/m128 into 8 packed signed word integers in xmm1 using signed saturation.

pub fn vpackssdw_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Converts 4 packed signed doubleword integers from xmm2 and from xmm3/m128 into 8 packed signed word integers in xmm1 using signed saturation.

pub fn vpackssdw_YMM_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory
)

Converts 8 packed signed doubleword integers from ymm2 and from ymm3/m256 into 16 packed signed word integers in ymm1 using signed saturation.

pub fn vpackssdw_YMM_YMM_YMM(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister
)

Converts 8 packed signed doubleword integers from ymm2 and from ymm3/m256 into 16 packed signed word integers in ymm1 using signed saturation.

pub fn vpacksswb_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Converts 8 packed signed word integers from xmm2 and from xmm3/m128 into 16 packed signed byte integers in xmm1 using signed saturation.

pub fn vpacksswb_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Converts 8 packed signed word integers from xmm2 and from xmm3/m128 into 16 packed signed byte integers in xmm1 using signed saturation.

pub fn vpacksswb_YMM_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory
)

Converts 16 packed signed word integers from ymm2 and from ymm3/m256 into 32 packed signed byte integers in ymm1 using signed saturation.

pub fn vpacksswb_YMM_YMM_YMM(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister
)

Converts 16 packed signed word integers from ymm2 and from ymm3/m256 into 32 packed signed byte integers in ymm1 using signed saturation.

pub fn vpackusdw_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Convert 4 packed signed doubleword integers from xmm2 and 4 packed signed doubleword integers from xmm3/m128 into 8 packed unsigned word integers in xmm1 using unsigned saturation.

pub fn vpackusdw_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Convert 4 packed signed doubleword integers from xmm2 and 4 packed signed doubleword integers from xmm3/m128 into 8 packed unsigned word integers in xmm1 using unsigned saturation.

pub fn vpackusdw_YMM_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory
)

Convert 8 packed signed doubleword integers from ymm2 and 8 packed signed doubleword integers from ymm3/m128 into 16 packed unsigned word integers in ymm1 using unsigned saturation.

pub fn vpackusdw_YMM_YMM_YMM(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister
)

Convert 8 packed signed doubleword integers from ymm2 and 8 packed signed doubleword integers from ymm3/m128 into 16 packed unsigned word integers in ymm1 using unsigned saturation.

pub fn vpackuswb_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Converts 8 signed word integers from xmm2 and 8 signed word integers from xmm3/m128 into 16 unsigned byte integers in xmm1 using unsigned saturation.

pub fn vpackuswb_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Converts 8 signed word integers from xmm2 and 8 signed word integers from xmm3/m128 into 16 unsigned byte integers in xmm1 using unsigned saturation.

pub fn vpackuswb_YMM_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory
)

Converts 16 signed word integers from ymm2 And 16 signed word integers from ymm3/m256 into 32 unsigned byte integers in ymm1 using unsigned saturation.

pub fn vpackuswb_YMM_YMM_YMM(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister
)

Converts 16 signed word integers from ymm2 And 16 signed word integers from ymm3/m256 into 32 unsigned byte integers in ymm1 using unsigned saturation.

pub fn vpaddb_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Add packed byte integers from xmm3/m128 and xmm2.

pub fn vpaddb_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Add packed byte integers from xmm3/m128 and xmm2.

pub fn vpaddb_YMM_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory
)

Add packed byte integers from ymm2 and ymm3/m256 and store in ymm1.

pub fn vpaddb_YMM_YMM_YMM(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister
)

Add packed byte integers from ymm2 and ymm3/m256 and store in ymm1.

pub fn vpaddd_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Add packed doubleword integers from xmm3/m128 and xmm2.

pub fn vpaddd_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Add packed doubleword integers from xmm3/m128 and xmm2.

pub fn vpaddd_YMM_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory
)

Add packed doubleword integers from ymm2, ymm3/m256 and store in ymm1.

pub fn vpaddd_YMM_YMM_YMM(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister
)

Add packed doubleword integers from ymm2, ymm3/m256 and store in ymm1.

pub fn vpaddq_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Add packed quadword integers xmm3/m128 and xmm2.

pub fn vpaddq_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Add packed quadword integers xmm3/m128 and xmm2.

pub fn vpaddq_YMM_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory
)

Add packed quadword integers from ymm2. ymm3/m256 and store in ymm1.

pub fn vpaddq_YMM_YMM_YMM(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister
)

Add packed quadword integers from ymm2. ymm3/m256 and store in ymm1.

pub fn vpaddsb_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Add packed signed byte integers from xmm3/m128 and xmm2 saturate the results.

pub fn vpaddsb_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Add packed signed byte integers from xmm3/m128 and xmm2 saturate the results.

pub fn vpaddsb_YMM_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory
)

Add packed signed byte integers from ymm2 and ymm3/m256 and store the saturated results in ymm1.

pub fn vpaddsb_YMM_YMM_YMM(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister
)

Add packed signed byte integers from ymm2 and ymm3/m256 and store the saturated results in ymm1.

pub fn vpaddsw_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Add packed signed word integers from xmm3/m128 and xmm2 and saturate the results.

pub fn vpaddsw_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Add packed signed word integers from xmm3/m128 and xmm2 and saturate the results.

pub fn vpaddsw_YMM_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory
)

Add packed signed word integers from ymm2 and ymm3/m256 and store the saturated results in ymm1.

pub fn vpaddsw_YMM_YMM_YMM(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister
)

Add packed signed word integers from ymm2 and ymm3/m256 and store the saturated results in ymm1.

pub fn vpaddusb_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Add packed unsigned byte integers from xmm3/m128 to xmm2 and saturate the results.

pub fn vpaddusb_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Add packed unsigned byte integers from xmm3/m128 to xmm2 and saturate the results.

pub fn vpaddusb_YMM_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory
)

Add packed unsigned byte integers from ymm2 and ymm3/m256 and store the saturated results in ymm1.

pub fn vpaddusb_YMM_YMM_YMM(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister
)

Add packed unsigned byte integers from ymm2 and ymm3/m256 and store the saturated results in ymm1.

pub fn vpaddusw_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Add packed unsigned word integers from xmm3/m128 to xmm2 and saturate the results.

pub fn vpaddusw_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Add packed unsigned word integers from xmm3/m128 to xmm2 and saturate the results.

pub fn vpaddusw_YMM_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory
)

Add packed unsigned word integers from ymm2 and ymm3/m256 and store the saturated results in ymm1.

pub fn vpaddusw_YMM_YMM_YMM(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister
)

Add packed unsigned word integers from ymm2 and ymm3/m256 and store the saturated results in ymm1.

pub fn vpaddw_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Add packed word integers from xmm3/m128 and xmm2.

pub fn vpaddw_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Add packed word integers from xmm3/m128 and xmm2.

pub fn vpaddw_YMM_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory
)

Add packed word integers from ymm2, ymm3/m256 and store in ymm1.

pub fn vpaddw_YMM_YMM_YMM(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister
)

Add packed word integers from ymm2, ymm3/m256 and store in ymm1.

pub fn vpalignr_XMMRegister_XMMRegister_Any128BitMemory_Immediate8Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory,
    arg3: Immediate8Bit
)

Concatenate xmm2 and xmm3/m128, extract byte aligned result shifted to the right by constant value in imm8 and result is stored in xmm1.

pub fn vpalignr_XMMRegister_XMMRegister_XMMRegister_Immediate8Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister,
    arg3: Immediate8Bit
)

Concatenate xmm2 and xmm3/m128, extract byte aligned result shifted to the right by constant value in imm8 and result is stored in xmm1.

pub fn vpalignr_YMM_YMM_Any256BitMemory_Immediate8Bit(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory,
    arg3: Immediate8Bit
)

Concatenate pairs of 16 bytes in ymm2 and ymm3/m256 into 32-byte intermediate result, extract byte-aligned, 16-byte result shifted to the right by constant values in imm8 from each intermediate result, and two 16-byte results are stored in ymm1.

pub fn vpalignr_YMM_YMM_YMM_Immediate8Bit(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister,
    arg3: Immediate8Bit
)

Concatenate pairs of 16 bytes in ymm2 and ymm3/m256 into 32-byte intermediate result, extract byte-aligned, 16-byte result shifted to the right by constant values in imm8 from each intermediate result, and two 16-byte results are stored in ymm1.

pub fn vpand_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Bitwise AND of xmm3/m128 and xmm.

pub fn vpand_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Bitwise AND of xmm3/m128 and xmm.

pub fn vpand_YMM_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory
)

Bitwise AND of ymm2 and ymm3/m256 and store result in ymm1.

pub fn vpand_YMM_YMM_YMM(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister
)

Bitwise AND of ymm2 and ymm3/m256 and store result in ymm1.

pub fn vpandn_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Bitwise AND NOT of xmm3/m128 and xmm2.

pub fn vpandn_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Bitwise AND NOT of xmm3/m128 and xmm2.

pub fn vpandn_YMM_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory
)

Bitwise AND NOT of ymm2 and ymm3/m256 and store result in ymm1.

pub fn vpandn_YMM_YMM_YMM(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister
)

Bitwise AND NOT of ymm2 and ymm3/m256 and store result in ymm1.

pub fn vpavgb_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Average packed unsigned byte integers from xmm3/m128 and xmm2 with rounding.

pub fn vpavgb_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Average packed unsigned byte integers from xmm3/m128 and xmm2 with rounding.

pub fn vpavgb_YMM_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory
)

Average packed unsigned byte integers from ymm2 and ymm3/m256 with rounding and store to ymm1.

pub fn vpavgb_YMM_YMM_YMM(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister
)

Average packed unsigned byte integers from ymm2 and ymm3/m256 with rounding and store to ymm1.

pub fn vpavgw_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Average packed unsigned word integers from xmm3/m128 and xmm2 with rounding.

pub fn vpavgw_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Average packed unsigned word integers from xmm3/m128 and xmm2 with rounding.

pub fn vpavgw_YMM_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory
)

Average packed unsigned word integers from ymm2, ymm3/m256 with rounding to ymm1.

pub fn vpavgw_YMM_YMM_YMM(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister
)

Average packed unsigned word integers from ymm2, ymm3/m256 with rounding to ymm1.

pub fn vpblendd_XMMRegister_XMMRegister_Any128BitMemory_Immediate8Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory,
    arg3: Immediate8Bit
)

Select dwords from xmm2 and xmm3/m128 from mask specified in imm8 and store the values into xmm1.

pub fn vpblendd_XMMRegister_XMMRegister_XMMRegister_Immediate8Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister,
    arg3: Immediate8Bit
)

Select dwords from xmm2 and xmm3/m128 from mask specified in imm8 and store the values into xmm1.

pub fn vpblendd_YMM_YMM_Any256BitMemory_Immediate8Bit(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory,
    arg3: Immediate8Bit
)

Select dwords from ymm2 and ymm3/m256 from mask specified in imm8 and store the values into ymm1.

pub fn vpblendd_YMM_YMM_YMM_Immediate8Bit(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister,
    arg3: Immediate8Bit
)

Select dwords from ymm2 and ymm3/m256 from mask specified in imm8 and store the values into ymm1.

pub fn vpblendvb_XMMRegister_XMMRegister_Any128BitMemory_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory,
    arg3: XMMRegister
)

Select byte values from xmm2 and xmm3/m128 using mask bits in the specified mask register, xmm4 and store the values into xmm1.

pub fn vpblendvb_XMMRegister_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister,
    arg3: XMMRegister
)

Select byte values from xmm2 and xmm3/m128 using mask bits in the specified mask register, xmm4 and store the values into xmm1.

pub fn vpblendvb_YMM_YMM_Any256BitMemory_YMM(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory,
    arg3: YMMRegister
)

Select byte values from ymm2 and ymm3/m256 from mask specified in the high bit of each byte in ymm4 and store the values into ymm1.

pub fn vpblendvb_YMM_YMM_YMM_YMM(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister,
    arg3: YMMRegister
)

Select byte values from ymm2 and ymm3/m256 from mask specified in the high bit of each byte in ymm4 and store the values into ymm1.

pub fn vpblendw_XMMRegister_XMMRegister_Any128BitMemory_Immediate8Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory,
    arg3: Immediate8Bit
)

Select words from xmm2 and xmm3/m128 from mask specified in imm8 and store the values into xmm1.

pub fn vpblendw_XMMRegister_XMMRegister_XMMRegister_Immediate8Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister,
    arg3: Immediate8Bit
)

Select words from xmm2 and xmm3/m128 from mask specified in imm8 and store the values into xmm1.

pub fn vpblendw_YMM_YMM_Any256BitMemory_Immediate8Bit(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory,
    arg3: Immediate8Bit
)

Select words from ymm2 and ymm3/m256 from mask specified in imm8 and store the values into ymm1.

pub fn vpblendw_YMM_YMM_YMM_Immediate8Bit(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister,
    arg3: Immediate8Bit
)

Select words from ymm2 and ymm3/m256 from mask specified in imm8 and store the values into ymm1.

pub fn vpbroadcastb_XMMRegister_Any8BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any8BitMemory
)

Broadcast a byte integer in the source operand to sixteen locations in xmm1.

pub fn vpbroadcastb_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Broadcast a byte integer in the source operand to sixteen locations in xmm1.

pub fn vpbroadcastb_YMM_Any8BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: Any8BitMemory
)

Broadcast a byte integer in the source operand to thirty two locations in ymm1.

pub fn vpbroadcastb_YMM_XMMRegister(
    &mut self,
    arg0: YMMRegister,
    arg1: XMMRegister
)

Broadcast a byte integer in the source operand to thirty two locations in ymm1.

pub fn vpbroadcastd_XMMRegister_Any32BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any32BitMemory
)

Broadcast a dword integer in the source operand to four locations in xmm1.

pub fn vpbroadcastd_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Broadcast a dword integer in the source operand to four locations in xmm1.

pub fn vpbroadcastd_YMM_Any32BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: Any32BitMemory
)

Broadcast a dword integer in the source operand to eight locations in ymm1.

pub fn vpbroadcastd_YMM_XMMRegister(
    &mut self,
    arg0: YMMRegister,
    arg1: XMMRegister
)

Broadcast a dword integer in the source operand to eight locations in ymm1.

pub fn vpbroadcastq_XMMRegister_Any64BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any64BitMemory
)

Broadcast a qword element in mem to two locations in xmm1.

pub fn vpbroadcastq_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Broadcast a qword element in mem to two locations in xmm1.

pub fn vpbroadcastq_YMM_Any64BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: Any64BitMemory
)

Broadcast a qword element in mem to four locations in ymm1.

pub fn vpbroadcastq_YMM_XMMRegister(
    &mut self,
    arg0: YMMRegister,
    arg1: XMMRegister
)

Broadcast a qword element in mem to four locations in ymm1.

pub fn vpbroadcastw_XMMRegister_Any16BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any16BitMemory
)

Broadcast a word integer in the source operand to eight locations in xmm1.

pub fn vpbroadcastw_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Broadcast a word integer in the source operand to eight locations in xmm1.

pub fn vpbroadcastw_YMM_Any16BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: Any16BitMemory
)

Broadcast a word integer in the source operand to sixteen locations in ymm1.

pub fn vpbroadcastw_YMM_XMMRegister(
    &mut self,
    arg0: YMMRegister,
    arg1: XMMRegister
)

Broadcast a word integer in the source operand to sixteen locations in ymm1.

pub fn vpclmulqdq_XMMRegister_XMMRegister_Any128BitMemory_Immediate8Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory,
    arg3: Immediate8Bit
)

Carry-less multiplication of one quadword of xmm2 by one quadword of xmm3/m128.

Stores the 128-bit result in xmm1.

The immediate is used to determine which quadwords of xmm2 and xmm3/m128 should be used.

pub fn vpclmulqdq_XMMRegister_XMMRegister_XMMRegister_Immediate8Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister,
    arg3: Immediate8Bit
)

Carry-less multiplication of one quadword of xmm2 by one quadword of xmm3/m128.

Stores the 128-bit result in xmm1.

The immediate is used to determine which quadwords of xmm2 and xmm3/m128 should be used.

pub fn vpcmpeqb_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Compare packed bytes in xmm3/m128 and xmm2 for equality.

pub fn vpcmpeqb_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Compare packed bytes in xmm3/m128 and xmm2 for equality.

pub fn vpcmpeqb_YMM_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory
)

Compare packed bytes in ymm3/m256 and ymm2 for equality.

pub fn vpcmpeqb_YMM_YMM_YMM(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister
)

Compare packed bytes in ymm3/m256 and ymm2 for equality.

pub fn vpcmpeqd_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Compare packed doublewords in xmm3/m128 and xmm2 for equality.

pub fn vpcmpeqd_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Compare packed doublewords in xmm3/m128 and xmm2 for equality.

pub fn vpcmpeqd_YMM_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory
)

Compare packed doublewords in ymm3/m256 and ymm2 for equality.

pub fn vpcmpeqd_YMM_YMM_YMM(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister
)

Compare packed doublewords in ymm3/m256 and ymm2 for equality.

pub fn vpcmpeqq_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Compare packed quadwords in xmm3/m128 and xmm2 for equality.

pub fn vpcmpeqq_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Compare packed quadwords in xmm3/m128 and xmm2 for equality.

pub fn vpcmpeqq_YMM_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory
)

Compare packed quadwords in ymm3/m256 and ymm2 for equality.

pub fn vpcmpeqq_YMM_YMM_YMM(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister
)

Compare packed quadwords in ymm3/m256 and ymm2 for equality.

pub fn vpcmpeqw_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Compare packed words in xmm3/m128 and xmm2 for equality.

pub fn vpcmpeqw_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Compare packed words in xmm3/m128 and xmm2 for equality.

pub fn vpcmpeqw_YMM_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory
)

Compare packed words in ymm3/m256 and ymm2 for equality.

pub fn vpcmpeqw_YMM_YMM_YMM(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister
)

Compare packed words in ymm3/m256 and ymm2 for equality.

pub fn vpcmpestri_XMMRegister_Any128BitMemory_Immediate8Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory,
    arg2: Immediate8Bit
)

Perform a packed comparison of string data with explicit lengths, generating an index, and storing the result in ECX.

pub fn vpcmpestri_XMMRegister_XMMRegister_Immediate8Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Immediate8Bit
)

Perform a packed comparison of string data with explicit lengths, generating an index, and storing the result in ECX.

pub fn vpcmpestrm_XMMRegister_Any128BitMemory_Immediate8Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory,
    arg2: Immediate8Bit
)

Perform a packed comparison of string data with explicit lengths, generating a mask, and storing the result in XMM0.

pub fn vpcmpestrm_XMMRegister_XMMRegister_Immediate8Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Immediate8Bit
)

Perform a packed comparison of string data with explicit lengths, generating a mask, and storing the result in XMM0.

pub fn vpcmpgtb_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Compare packed signed byte integers in xmm2 and xmm3/m128 for greater than.

pub fn vpcmpgtb_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Compare packed signed byte integers in xmm2 and xmm3/m128 for greater than.

pub fn vpcmpgtb_YMM_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory
)

Compare packed signed byte integers in ymm2 and ymm3/m256 for greater than.

pub fn vpcmpgtb_YMM_YMM_YMM(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister
)

Compare packed signed byte integers in ymm2 and ymm3/m256 for greater than.

pub fn vpcmpgtd_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Compare packed signed doubleword integers in xmm2 and xmm3/m128 for greater than.

pub fn vpcmpgtd_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Compare packed signed doubleword integers in xmm2 and xmm3/m128 for greater than.

pub fn vpcmpgtd_YMM_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory
)

Compare packed signed doubleword integers in ymm2 and ymm3/m256 for greater than.

pub fn vpcmpgtd_YMM_YMM_YMM(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister
)

Compare packed signed doubleword integers in ymm2 and ymm3/m256 for greater than.

pub fn vpcmpgtq_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Compare packed signed qwords in xmm2 and xmm3/m128 for greater than.

pub fn vpcmpgtq_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Compare packed signed qwords in xmm2 and xmm3/m128 for greater than.

pub fn vpcmpgtq_YMM_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory
)

Compare packed signed qwords in ymm2 and ymm3/m256 for greater than.

pub fn vpcmpgtq_YMM_YMM_YMM(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister
)

Compare packed signed qwords in ymm2 and ymm3/m256 for greater than.

pub fn vpcmpgtw_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Compare packed signed word integers in xmm2 and xmm3/m128 for greater than.

pub fn vpcmpgtw_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Compare packed signed word integers in xmm2 and xmm3/m128 for greater than.

pub fn vpcmpgtw_YMM_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory
)

Compare packed signed word integers in ymm2 and ymm3/m256 for greater than.

pub fn vpcmpgtw_YMM_YMM_YMM(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister
)

Compare packed signed word integers in ymm2 and ymm3/m256 for greater than.

pub fn vpcmpistri_XMMRegister_Any128BitMemory_Immediate8Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory,
    arg2: Immediate8Bit
)

Perform a packed comparison of string data with implicit lengths, generating an index, and storing the result in ECX.

pub fn vpcmpistri_XMMRegister_XMMRegister_Immediate8Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Immediate8Bit
)

Perform a packed comparison of string data with implicit lengths, generating an index, and storing the result in ECX.

pub fn vpcmpistrm_XMMRegister_Any128BitMemory_Immediate8Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory,
    arg2: Immediate8Bit
)

Perform a packed comparison of string data with implicit lengths, generating a Mask, and storing the result in XMM0.

pub fn vpcmpistrm_XMMRegister_XMMRegister_Immediate8Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Immediate8Bit
)

Perform a packed comparison of string data with implicit lengths, generating a Mask, and storing the result in XMM0.

pub fn vperm2f128_YMM_YMM_Any256BitMemory_Immediate8Bit(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory,
    arg3: Immediate8Bit
)

Permute 128-bit floating-point fields in ymm2 and ymm3/mem using controls from imm8 and store result in ymm1.

pub fn vperm2f128_YMM_YMM_YMM_Immediate8Bit(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister,
    arg3: Immediate8Bit
)

Permute 128-bit floating-point fields in ymm2 and ymm3/mem using controls from imm8 and store result in ymm1.

pub fn vperm2i128_YMM_YMM_Any256BitMemory_Immediate8Bit(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory,
    arg3: Immediate8Bit
)

Permute 128-bit integer data in ymm2 and ymm3/mem using controls from imm8 and store result in ymm1.

pub fn vperm2i128_YMM_YMM_YMM_Immediate8Bit(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister,
    arg3: Immediate8Bit
)

Permute 128-bit integer data in ymm2 and ymm3/mem using controls from imm8 and store result in ymm1.

pub fn vpermd_YMM_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory
)

Permute doublewords in ymm3/m256 using indexes in ymm2 and store the result in ymm1.

pub fn vpermd_YMM_YMM_YMM(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister
)

Permute doublewords in ymm3/m256 using indexes in ymm2 and store the result in ymm1.

pub fn vpermilpd_XMMRegister_Any128BitMemory_Immediate8Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory,
    arg2: Immediate8Bit
)

Permute double-precision floating-point values in xmm2/mem using controls from imm8.

pub fn vpermilpd_XMMRegister_XMMRegister_Immediate8Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Immediate8Bit
)

Permute double-precision floating-point values in xmm2/mem using controls from imm8.

pub fn vpermilpd_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Permute double-precision floating-point values in xmm2 using controls from xmm3/mem and store result in xmm1.

pub fn vpermilpd_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Permute double-precision floating-point values in xmm2 using controls from xmm3/mem and store result in xmm1.

pub fn vpermilpd_YMM_Any256BitMemory_Immediate8Bit(
    &mut self,
    arg0: YMMRegister,
    arg1: Any256BitMemory,
    arg2: Immediate8Bit
)

Permute double-precision floating-point values in ymm2/mem using controls from imm8.

pub fn vpermilpd_YMM_YMM_Immediate8Bit(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Immediate8Bit
)

Permute double-precision floating-point values in ymm2/mem using controls from imm8.

pub fn vpermilpd_YMM_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory
)

Permute double-precision floating-point values in ymm2 using controls from ymm3/mem and store result in ymm1.

pub fn vpermilpd_YMM_YMM_YMM(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister
)

Permute double-precision floating-point values in ymm2 using controls from ymm3/mem and store result in ymm1.

pub fn vpermilps_XMMRegister_Any128BitMemory_Immediate8Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory,
    arg2: Immediate8Bit
)

Permute single-precision floating-point values in xmm2/mem using controls from imm8 and store result in xmm1.

pub fn vpermilps_XMMRegister_XMMRegister_Immediate8Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Immediate8Bit
)

Permute single-precision floating-point values in xmm2/mem using controls from imm8 and store result in xmm1.

pub fn vpermilps_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Permute single-precision floating-point values in xmm2 using controls from xmm3/mem and store result in xmm1.

pub fn vpermilps_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Permute single-precision floating-point values in xmm2 using controls from xmm3/mem and store result in xmm1.

pub fn vpermilps_YMM_Any256BitMemory_Immediate8Bit(
    &mut self,
    arg0: YMMRegister,
    arg1: Any256BitMemory,
    arg2: Immediate8Bit
)

Permute single-precision floating-point values in ymm2/mem using controls from imm8 and store result in ymm1.

pub fn vpermilps_YMM_YMM_Immediate8Bit(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Immediate8Bit
)

Permute single-precision floating-point values in ymm2/mem using controls from imm8 and store result in ymm1.

pub fn vpermilps_YMM_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory
)

Permute single-precision floating-point values in ymm2 using controls from ymm3/mem and store result in ymm1.

pub fn vpermilps_YMM_YMM_YMM(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister
)

Permute single-precision floating-point values in ymm2 using controls from ymm3/mem and store result in ymm1.

pub fn vpermpd_YMM_Any256BitMemory_Immediate8Bit(
    &mut self,
    arg0: YMMRegister,
    arg1: Any256BitMemory,
    arg2: Immediate8Bit
)

Permute double-precision floating-point elements in ymm2/m256 using indexes in imm8 and store the result in ymm1.

pub fn vpermpd_YMM_YMM_Immediate8Bit(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Immediate8Bit
)

Permute double-precision floating-point elements in ymm2/m256 using indexes in imm8 and store the result in ymm1.

pub fn vpermps_YMM_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory
)

Permute single-precision floating-point elements in ymm3/m256 using indexes in ymm2 and store the result in ymm1.

pub fn vpermps_YMM_YMM_YMM(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister
)

Permute single-precision floating-point elements in ymm3/m256 using indexes in ymm2 and store the result in ymm1.

pub fn vpermq_YMM_Any256BitMemory_Immediate8Bit(
    &mut self,
    arg0: YMMRegister,
    arg1: Any256BitMemory,
    arg2: Immediate8Bit
)

Permute qwords in ymm2/m256 using indexes in imm8 and store the result in ymm1.

pub fn vpermq_YMM_YMM_Immediate8Bit(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Immediate8Bit
)

Permute qwords in ymm2/m256 using indexes in imm8 and store the result in ymm1.

pub fn vpextrb_Any8BitMemory_XMMRegister_Immediate8Bit(
    &mut self,
    arg0: Any8BitMemory,
    arg1: XMMRegister,
    arg2: Immediate8Bit
)

Extract a byte integer value from xmm2 at the source byte offset specified by imm8 into reg or m8.

The upper bits of r64/r32 is filled with zeros.

pub fn vpextrb_Register32Bit_XMMRegister_Immediate8Bit(
    &mut self,
    arg0: Register32Bit,
    arg1: XMMRegister,
    arg2: Immediate8Bit
)

Extract a byte integer value from xmm2 at the source byte offset specified by imm8 into reg or m8.

The upper bits of r64/r32 is filled with zeros.

pub fn vpextrb_Register64Bit_XMMRegister_Immediate8Bit(
    &mut self,
    arg0: Register64Bit,
    arg1: XMMRegister,
    arg2: Immediate8Bit
)

Extract a byte integer value from xmm2 at the source byte offset specified by imm8 into reg or m8.

The upper bits of r64/r32 is filled with zeros.

pub fn vpextrd_Any32BitMemory_XMMRegister_Immediate8Bit(
    &mut self,
    arg0: Any32BitMemory,
    arg1: XMMRegister,
    arg2: Immediate8Bit
)

Extract a dword integer value from xmm2 at the source dword offset specified by imm8 into r32/m32.

pub fn vpextrd_Register32Bit_XMMRegister_Immediate8Bit(
    &mut self,
    arg0: Register32Bit,
    arg1: XMMRegister,
    arg2: Immediate8Bit
)

Extract a dword integer value from xmm2 at the source dword offset specified by imm8 into r32/m32.

pub fn vpextrq_Any64BitMemory_XMMRegister_Immediate8Bit(
    &mut self,
    arg0: Any64BitMemory,
    arg1: XMMRegister,
    arg2: Immediate8Bit
)

Extract a qword integer value from xmm2 at the source dword offset specified by imm8 into r64/m64.

pub fn vpextrq_Register64Bit_XMMRegister_Immediate8Bit(
    &mut self,
    arg0: Register64Bit,
    arg1: XMMRegister,
    arg2: Immediate8Bit
)

Extract a qword integer value from xmm2 at the source dword offset specified by imm8 into r64/m64.

pub fn vpextrw_Any16BitMemory_XMMRegister_Immediate8Bit(
    &mut self,
    arg0: Any16BitMemory,
    arg1: XMMRegister,
    arg2: Immediate8Bit
)

Extract a word integer value from xmm2 at the source word offset specified by imm8 into reg or m16.

The upper bits of r64/r32 is filled with zeros.

pub fn vpextrw_Register32Bit_XMMRegister_Immediate8Bit(
    &mut self,
    arg0: Register32Bit,
    arg1: XMMRegister,
    arg2: Immediate8Bit
)

Extract the word specified by imm8 from xmm1 and move it to reg, bits 15:0.

Zero-extend the result.

The upper bits of r64/r32 is filled with zeros.

pub fn vpextrw_Register32Bit_XMMRegister_Immediate8Bit_1(
    &mut self,
    arg0: Register32Bit,
    arg1: XMMRegister,
    arg2: Immediate8Bit
)

Extract the word specified by imm8 from xmm1 and move it to reg, bits 15:0.

Zero-extend the result.

The upper bits of r64/r32 is filled with zeros.

pub fn vpextrw_Register64Bit_XMMRegister_Immediate8Bit(
    &mut self,
    arg0: Register64Bit,
    arg1: XMMRegister,
    arg2: Immediate8Bit
)

Extract the word specified by imm8 from xmm1 and move it to reg, bits 15:0.

Zero-extend the result.

The upper bits of r64/r32 is filled with zeros.

pub fn vpextrw_Register64Bit_XMMRegister_Immediate8Bit_1(
    &mut self,
    arg0: Register64Bit,
    arg1: XMMRegister,
    arg2: Immediate8Bit
)

Extract the word specified by imm8 from xmm1 and move it to reg, bits 15:0.

Zero-extend the result.

The upper bits of r64/r32 is filled with zeros.

pub fn vpgatherdd_XMMRegister_Any32BitMemory_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: Any32BitMemory,
    arg2: XMMRegister
)

Using dword indices specified in vm32x, gather dword values from memory conditioned on mask specified by xmm2.

Conditionally gathered elements are merged into xmm1.

pub fn vpgatherdd_YMM_Any32BitMemory_YMM(
    &mut self,
    arg0: YMMRegister,
    arg1: Any32BitMemory,
    arg2: YMMRegister
)

Using dword indices specified in vm32y, gather dword from memory conditioned on mask specified by ymm2.

Conditionally gathered elements are merged into ymm1.

pub fn vpgatherdq_XMMRegister_Any32BitMemory_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: Any32BitMemory,
    arg2: XMMRegister
)

Using dword indices specified in vm32x, gather qword values from memory conditioned on mask specified by xmm2.

Conditionally gathered elements are merged into xmm1.

pub fn vpgatherdq_YMM_Any32BitMemory_YMM(
    &mut self,
    arg0: YMMRegister,
    arg1: Any32BitMemory,
    arg2: YMMRegister
)

Using dword indices specified in vm32x, gather qword values from memory conditioned on mask specified by ymm2.

Conditionally gathered elements are merged into ymm1.

pub fn vpgatherqd_XMMRegister_Any64BitMemory_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: Any64BitMemory,
    arg2: XMMRegister
)

Using qword indices specified in vm64x, gather dword values from memory conditioned on mask specified by xmm2.

Conditionally gathered elements are merged into xmm1.

pub fn vpgatherqd_XMMRegister_Any64BitMemory_XMMRegister_1(
    &mut self,
    arg0: XMMRegister,
    arg1: Any64BitMemory,
    arg2: XMMRegister
)

Using qword indices specified in vm64x, gather dword values from memory conditioned on mask specified by xmm2.

Conditionally gathered elements are merged into xmm1.

pub fn vpgatherqq_XMMRegister_Any64BitMemory_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: Any64BitMemory,
    arg2: XMMRegister
)

Using qword indices specified in vm64x, gather qword values from memory conditioned on mask specified by xmm2.

Conditionally gathered elements are merged into xmm1.

pub fn vpgatherqq_YMM_Any64BitMemory_YMM(
    &mut self,
    arg0: YMMRegister,
    arg1: Any64BitMemory,
    arg2: YMMRegister
)

Using qword indices specified in vm64y, gather qword values from memory conditioned on mask specified by ymm2.

Conditionally gathered elements are merged into ymm1.

pub fn vphaddd_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Add 32-bit integers horizontally, pack to xmm1.

pub fn vphaddd_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Add 32-bit integers horizontally, pack to xmm1.

pub fn vphaddd_YMM_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory
)

Add 32-bit signed integers horizontally, pack to ymm1.

pub fn vphaddd_YMM_YMM_YMM(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister
)

Add 32-bit signed integers horizontally, pack to ymm1.

pub fn vphaddsw_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Add 16-bit signed integers horizontally, pack saturated integers to xmm1.

pub fn vphaddsw_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Add 16-bit signed integers horizontally, pack saturated integers to xmm1.

pub fn vphaddsw_YMM_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory
)

Add 16-bit signed integers horizontally, pack saturated integers to ymm1.

pub fn vphaddsw_YMM_YMM_YMM(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister
)

Add 16-bit signed integers horizontally, pack saturated integers to ymm1.

pub fn vphaddw_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Add 16-bit integers horizontally, pack to xmm1.

pub fn vphaddw_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Add 16-bit integers horizontally, pack to xmm1.

pub fn vphaddw_YMM_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory
)

Add 16-bit signed integers horizontally, pack to ymm1.

pub fn vphaddw_YMM_YMM_YMM(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister
)

Add 16-bit signed integers horizontally, pack to ymm1.

pub fn vphminposuw_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Find the minimum unsigned word in xmm2/m128 and place its value in the low word of xmm1 and its index in the second-lowest word of xmm1.

pub fn vphminposuw_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Find the minimum unsigned word in xmm2/m128 and place its value in the low word of xmm1 and its index in the second-lowest word of xmm1.

pub fn vphsubd_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Subtract 32-bit signed integers horizontally, pack to xmm1.

pub fn vphsubd_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Subtract 32-bit signed integers horizontally, pack to xmm1.

pub fn vphsubd_YMM_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory
)

Subtract 32-bit signed integers horizontally, pack to ymm1.

pub fn vphsubd_YMM_YMM_YMM(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister
)

Subtract 32-bit signed integers horizontally, pack to ymm1.

pub fn vphsubsw_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Subtract 16-bit signed integer horizontally, pack saturated integers to xmm1.

pub fn vphsubsw_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Subtract 16-bit signed integer horizontally, pack saturated integers to xmm1.

pub fn vphsubsw_YMM_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory
)

Subtract 16-bit signed integer horizontally, pack saturated integers to ymm1.

pub fn vphsubsw_YMM_YMM_YMM(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister
)

Subtract 16-bit signed integer horizontally, pack saturated integers to ymm1.

pub fn vphsubw_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Subtract 16-bit signed integers horizontally, pack to xmm1.

pub fn vphsubw_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Subtract 16-bit signed integers horizontally, pack to xmm1.

pub fn vphsubw_YMM_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory
)

Subtract 16-bit signed integers horizontally, pack to ymm1.

pub fn vphsubw_YMM_YMM_YMM(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister
)

Subtract 16-bit signed integers horizontally, pack to ymm1.

pub fn vpinsrb_XMMRegister_XMMRegister_Any8BitMemory_Immediate8Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any8BitMemory,
    arg3: Immediate8Bit
)

Merge a byte integer value from r32/m8 and rest from xmm2 into xmm1 at the byte offset in imm8.

pub fn vpinsrb_XMMRegister_XMMRegister_Register32Bit_Immediate8Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Register32Bit,
    arg3: Immediate8Bit
)

Merge a byte integer value from r32/m8 and rest from xmm2 into xmm1 at the byte offset in imm8.

pub fn vpinsrd_XMMRegister_XMMRegister_Any32BitMemory_Immediate8Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any32BitMemory,
    arg3: Immediate8Bit
)

Insert a dword integer value from r32/m32 and rest from xmm2 into xmm1 at the dword offset in imm8.

pub fn vpinsrd_XMMRegister_XMMRegister_Register32Bit_Immediate8Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Register32Bit,
    arg3: Immediate8Bit
)

Insert a dword integer value from r32/m32 and rest from xmm2 into xmm1 at the dword offset in imm8.

pub fn vpinsrq_XMMRegister_XMMRegister_Any64BitMemory_Immediate8Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any64BitMemory,
    arg3: Immediate8Bit
)

Insert a qword integer value from r64/m64 and rest from xmm2 into xmm1 at the qword offset in imm8.

pub fn vpinsrq_XMMRegister_XMMRegister_Register64Bit_Immediate8Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Register64Bit,
    arg3: Immediate8Bit
)

Insert a qword integer value from r64/m64 and rest from xmm2 into xmm1 at the qword offset in imm8.

pub fn vpinsrw_XMMRegister_XMMRegister_Any16BitMemory_Immediate8Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any16BitMemory,
    arg3: Immediate8Bit
)

Insert a word integer value from r32/m16 and rest from xmm2 into xmm1 at the word offset in imm8.

pub fn vpinsrw_XMMRegister_XMMRegister_Register32Bit_Immediate8Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Register32Bit,
    arg3: Immediate8Bit
)

Insert a word integer value from r32/m16 and rest from xmm2 into xmm1 at the word offset in imm8.

pub fn vpmaddubsw_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Multiply signed and unsigned bytes, add horizontal pair of signed words, pack saturated signed-words to xmm1.

pub fn vpmaddubsw_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Multiply signed and unsigned bytes, add horizontal pair of signed words, pack saturated signed-words to xmm1.

pub fn vpmaddubsw_YMM_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory
)

Multiply signed and unsigned bytes, add horizontal pair of signed words, pack saturated signed-words to ymm1.

pub fn vpmaddubsw_YMM_YMM_YMM(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister
)

Multiply signed and unsigned bytes, add horizontal pair of signed words, pack saturated signed-words to ymm1.

pub fn vpmaddwd_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Multiply the packed word integers in xmm2 by the packed word integers in xmm3/m128, add adjacent doubleword results, and store in xmm1.

pub fn vpmaddwd_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Multiply the packed word integers in xmm2 by the packed word integers in xmm3/m128, add adjacent doubleword results, and store in xmm1.

pub fn vpmaddwd_YMM_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory
)

Multiply the packed word integers in ymm2 by the packed word integers in ymm3/m256, add adjacent doubleword results, and store in ymm1.

pub fn vpmaddwd_YMM_YMM_YMM(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister
)

Multiply the packed word integers in ymm2 by the packed word integers in ymm3/m256, add adjacent doubleword results, and store in ymm1.

pub fn vpmaskmovd_Any128BitMemory_XMMRegister_XMMRegister(
    &mut self,
    arg0: Any128BitMemory,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Conditionally store dword values from xmm2 using mask in xmm1.

pub fn vpmaskmovd_Any256BitMemory_YMM_YMM(
    &mut self,
    arg0: Any256BitMemory,
    arg1: YMMRegister,
    arg2: YMMRegister
)

Conditionally store dword values from ymm2 using mask in ymm1.

pub fn vpmaskmovd_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Conditionally load dword values from m128 using mask in xmm2 and store in xmm1.

pub fn vpmaskmovd_YMM_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory
)

Conditionally load dword values from m256 using mask in ymm2 and store in ymm1.

pub fn vpmaskmovq_Any128BitMemory_XMMRegister_XMMRegister(
    &mut self,
    arg0: Any128BitMemory,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Conditionally store qword values from xmm2 using mask in xmm1.

pub fn vpmaskmovq_Any256BitMemory_YMM_YMM(
    &mut self,
    arg0: Any256BitMemory,
    arg1: YMMRegister,
    arg2: YMMRegister
)

Conditionally store qword values from ymm2 using mask in ymm1.

pub fn vpmaskmovq_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Conditionally load qword values from m128 using mask in xmm2 and store in xmm1.

pub fn vpmaskmovq_YMM_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory
)

Conditionally load qword values from m256 using mask in ymm2 and store in ymm1.

pub fn vpmaxsb_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Compare packed signed byte integers in xmm2 and xmm3/m128 and store packed maximum values in xmm1.

pub fn vpmaxsb_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Compare packed signed byte integers in xmm2 and xmm3/m128 and store packed maximum values in xmm1.

pub fn vpmaxsb_YMM_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory
)

Compare packed signed byte integers in ymm2 and ymm3/m128 and store packed maximum values in ymm1.

pub fn vpmaxsb_YMM_YMM_YMM(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister
)

Compare packed signed byte integers in ymm2 and ymm3/m128 and store packed maximum values in ymm1.

pub fn vpmaxsd_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Compare packed signed dword integers in xmm2 and xmm3/m128 and store packed maximum values in xmm1.

pub fn vpmaxsd_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Compare packed signed dword integers in xmm2 and xmm3/m128 and store packed maximum values in xmm1.

pub fn vpmaxsd_YMM_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory
)

Compare packed signed dword integers in ymm2 and ymm3/m128 and store packed maximum values in ymm1.

pub fn vpmaxsd_YMM_YMM_YMM(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister
)

Compare packed signed dword integers in ymm2 and ymm3/m128 and store packed maximum values in ymm1.

pub fn vpmaxsw_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Compare packed signed word integers in xmm3/m128 and xmm2 and store packed maximum values in xmm1.

pub fn vpmaxsw_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Compare packed signed word integers in xmm3/m128 and xmm2 and store packed maximum values in xmm1.

pub fn vpmaxsw_YMM_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory
)

Compare packed signed word integers in ymm3/m128 and ymm2 and store packed maximum values in ymm1.

pub fn vpmaxsw_YMM_YMM_YMM(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister
)

Compare packed signed word integers in ymm3/m128 and ymm2 and store packed maximum values in ymm1.

pub fn vpmaxub_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Compare packed unsigned byte integers in xmm2 and xmm3/m128 and store packed maximum values in xmm1.

pub fn vpmaxub_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Compare packed unsigned byte integers in xmm2 and xmm3/m128 and store packed maximum values in xmm1.

pub fn vpmaxub_YMM_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory
)

Compare packed unsigned byte integers in ymm2 and ymm3/m256 and store packed maximum values in ymm1.

pub fn vpmaxub_YMM_YMM_YMM(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister
)

Compare packed unsigned byte integers in ymm2 and ymm3/m256 and store packed maximum values in ymm1.

pub fn vpmaxud_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Compare packed unsigned dword integers in xmm2 and xmm3/m128 and store packed maximum values in xmm1.

pub fn vpmaxud_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Compare packed unsigned dword integers in xmm2 and xmm3/m128 and store packed maximum values in xmm1.

pub fn vpmaxud_YMM_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory
)

Compare packed unsigned dword integers in ymm2 and ymm3/m256 and store packed maximum values in ymm1.

pub fn vpmaxud_YMM_YMM_YMM(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister
)

Compare packed unsigned dword integers in ymm2 and ymm3/m256 and store packed maximum values in ymm1.

pub fn vpmaxuw_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Compare packed unsigned word integers in xmm3/m128 and xmm2 and store maximum packed values in xmm1.

pub fn vpmaxuw_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Compare packed unsigned word integers in xmm3/m128 and xmm2 and store maximum packed values in xmm1.

pub fn vpmaxuw_YMM_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory
)

Compare packed unsigned word integers in ymm3/m256 and ymm2 and store maximum packed values in ymm1.

pub fn vpmaxuw_YMM_YMM_YMM(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister
)

Compare packed unsigned word integers in ymm3/m256 and ymm2 and store maximum packed values in ymm1.

pub fn vpminsb_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Compare packed signed byte integers in xmm2 and xmm3/m128 and store packed minimum values in xmm1.

pub fn vpminsb_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Compare packed signed byte integers in xmm2 and xmm3/m128 and store packed minimum values in xmm1.

pub fn vpminsb_YMM_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory
)

Compare packed signed byte integers in ymm2 and ymm3/m256 and store packed minimum values in ymm1.

pub fn vpminsb_YMM_YMM_YMM(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister
)

Compare packed signed byte integers in ymm2 and ymm3/m256 and store packed minimum values in ymm1.

pub fn vpminsd_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Compare packed signed dword integers in xmm2 and xmm3/m128 and store packed minimum values in xmm1.

pub fn vpminsd_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Compare packed signed dword integers in xmm2 and xmm3/m128 and store packed minimum values in xmm1.

pub fn vpminsd_YMM_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory
)

Compare packed signed dword integers in ymm2 and ymm3/m128 and store packed minimum values in ymm1.

pub fn vpminsd_YMM_YMM_YMM(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister
)

Compare packed signed dword integers in ymm2 and ymm3/m128 and store packed minimum values in ymm1.

pub fn vpminsw_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Compare packed signed word integers in xmm3/m128 and xmm2 and return packed minimum values in xmm1.

pub fn vpminsw_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Compare packed signed word integers in xmm3/m128 and xmm2 and return packed minimum values in xmm1.

pub fn vpminub_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Compare packed unsigned byte integers in xmm2 and xmm3/m128 and store packed minimum values in xmm1.

pub fn vpminub_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Compare packed unsigned byte integers in xmm2 and xmm3/m128 and store packed minimum values in xmm1.

pub fn vpminub_YMM_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory
)

Compare packed unsigned byte integers in ymm2 and ymm3/m256 and store packed minimum values in ymm1.

pub fn vpminub_YMM_YMM_YMM(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister
)

Compare packed unsigned byte integers in ymm2 and ymm3/m256 and store packed minimum values in ymm1.

pub fn vpminud_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Compare packed unsigned dword integers in xmm2 and xmm3/m128 and store packed minimum values in xmm1.

pub fn vpminud_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Compare packed unsigned dword integers in xmm2 and xmm3/m128 and store packed minimum values in xmm1.

pub fn vpminud_YMM_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory
)

Compare packed unsigned dword integers in ymm2 and ymm3/m256 and store packed minimum values in ymm1.

pub fn vpminud_YMM_YMM_YMM(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister
)

Compare packed unsigned dword integers in ymm2 and ymm3/m256 and store packed minimum values in ymm1.

pub fn vpminuw_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Compare packed unsigned word integers in xmm3/m128 and xmm2 and return packed minimum values in xmm1.

pub fn vpminuw_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Compare packed unsigned word integers in xmm3/m128 and xmm2 and return packed minimum values in xmm1.

pub fn vpminuw_YMM_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory
)

Compare packed unsigned word integers in ymm3/m256 and ymm2 and return packed minimum values in ymm1.

pub fn vpminuw_YMM_YMM_YMM(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister
)

Compare packed unsigned word integers in ymm3/m256 and ymm2 and return packed minimum values in ymm1.

pub fn vpmovmskb_Register32Bit_XMMRegister(
    &mut self,
    arg0: Register32Bit,
    arg1: XMMRegister
)

Move a byte mask of xmm1 to register.

The upper bits of r32 or r64 are filled with zeros.

pub fn vpmovmskb_Register32Bit_YMM(
    &mut self,
    arg0: Register32Bit,
    arg1: YMMRegister
)

Move a 32-bit mask of ymm1 to register.

The upper bits of r64 are filled with zeros.

pub fn vpmovmskb_Register64Bit_XMMRegister(
    &mut self,
    arg0: Register64Bit,
    arg1: XMMRegister
)

Move a byte mask of xmm1 to register.

The upper bits of r32 or r64 are filled with zeros.

pub fn vpmovmskb_Register64Bit_YMM(
    &mut self,
    arg0: Register64Bit,
    arg1: YMMRegister
)

Move a 32-bit mask of ymm1 to register.

The upper bits of r64 are filled with zeros.

pub fn vpmovsxbd_XMMRegister_Any32BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any32BitMemory
)

Sign extend 4 packed 8-bit integers in the low 4 bytes of xmm2/m32 to 4 packed 32-bit integers in xmm1.

pub fn vpmovsxbd_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Sign extend 4 packed 8-bit integers in the low 4 bytes of xmm2/m32 to 4 packed 32-bit integers in xmm1.

pub fn vpmovsxbd_YMM_Any64BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: Any64BitMemory
)

Sign extend 8 packed 8-bit integers in the low 8 bytes of xmm2/m64 to 8 packed 32-bit integers in ymm1.

pub fn vpmovsxbd_YMM_XMMRegister(&mut self, arg0: YMMRegister, arg1: XMMRegister)

Sign extend 8 packed 8-bit integers in the low 8 bytes of xmm2/m64 to 8 packed 32-bit integers in ymm1.

pub fn vpmovsxbq_XMMRegister_Any16BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any16BitMemory
)

Sign extend 2 packed 8-bit integers in the low 2 bytes of xmm2.m16 to 2 packed 64-bit integers in xmm1.

pub fn vpmovsxbq_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Sign extend 2 packed 8-bit integers in the low 2 bytes of xmm2.m16 to 2 packed 64-bit integers in xmm1.

pub fn vpmovsxbq_YMM_Any32BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: Any32BitMemory
)

Sign extend 4 packed 8-bit integers in the low 4 bytes of xmm2/m32 to 4 packed 64-bit integers in ymm1.

pub fn vpmovsxbq_YMM_XMMRegister(&mut self, arg0: YMMRegister, arg1: XMMRegister)

Sign extend 4 packed 8-bit integers in the low 4 bytes of xmm2/m32 to 4 packed 64-bit integers in ymm1.

pub fn vpmovsxbw_XMMRegister_Any64BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any64BitMemory
)

Sign extend 8 packed 8-bit integers in the low 8 bytes of xmm2/m64 to 8 packed 16-bit integers in xmm1.

pub fn vpmovsxbw_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Sign extend 8 packed 8-bit integers in the low 8 bytes of xmm2/m64 to 8 packed 16-bit integers in xmm1.

pub fn vpmovsxbw_YMM_Any128BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: Any128BitMemory
)

Sign extend 16 packed 8-bit integers in xmm2/m128 to 16 packed 16-bit integers in ymm1.

pub fn vpmovsxbw_YMM_XMMRegister(&mut self, arg0: YMMRegister, arg1: XMMRegister)

Sign extend 16 packed 8-bit integers in xmm2/m128 to 16 packed 16-bit integers in ymm1.

pub fn vpmovsxdq_XMMRegister_Any64BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any64BitMemory
)

Sign extend 2 packed 32-bit integers in the low 8 bytes of xmm2/m64 to 2 packed 64-bit integers in xmm1.

pub fn vpmovsxdq_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Sign extend 2 packed 32-bit integers in the low 8 bytes of xmm2/m64 to 2 packed 64-bit integers in xmm1.

pub fn vpmovsxdq_YMM_Any128BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: Any128BitMemory
)

Sign extend 4 packed 32-bit integers in the low 16 bytes of xmm2/m128 to 4 packed 64-bit integers in ymm1.

pub fn vpmovsxdq_YMM_XMMRegister(&mut self, arg0: YMMRegister, arg1: XMMRegister)

Sign extend 4 packed 32-bit integers in the low 16 bytes of xmm2/m128 to 4 packed 64-bit integers in ymm1.

pub fn vpmovsxwd_XMMRegister_Any64BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any64BitMemory
)

Sign extend 4 packed 16-bit integers in the low 8 bytes of xmm2/m64 to 4 packed 32-bit integers in xmm1.

pub fn vpmovsxwd_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Sign extend 4 packed 16-bit integers in the low 8 bytes of xmm2/m64 to 4 packed 32-bit integers in xmm1.

pub fn vpmovsxwd_YMM_Any128BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: Any128BitMemory
)

Sign extend 8 packed 16-bit integers in the low 16 bytes of xmm2/m128 to 8 packed 32-bit integers in ymm1.

pub fn vpmovsxwd_YMM_XMMRegister(&mut self, arg0: YMMRegister, arg1: XMMRegister)

Sign extend 8 packed 16-bit integers in the low 16 bytes of xmm2/m128 to 8 packed 32-bit integers in ymm1.

pub fn vpmovsxwq_XMMRegister_Any32BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any32BitMemory
)

Sign extend 2 packed 16-bit integers in the low 4 bytes of xmm2/m32 to 2 packed 64-bit integers in xmm1.

pub fn vpmovsxwq_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Sign extend 2 packed 16-bit integers in the low 4 bytes of xmm2/m32 to 2 packed 64-bit integers in xmm1.

pub fn vpmovsxwq_YMM_Any64BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: Any64BitMemory
)

Sign extend 4 packed 16-bit integers in the low 8 bytes of xmm2/m64 to 4 packed 64-bit integers in ymm1.

pub fn vpmovsxwq_YMM_XMMRegister(&mut self, arg0: YMMRegister, arg1: XMMRegister)

Sign extend 4 packed 16-bit integers in the low 8 bytes of xmm2/m64 to 4 packed 64-bit integers in ymm1.

pub fn vpmovzxbd_XMMRegister_Any32BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any32BitMemory
)

Zero extend 4 packed 8-bit integers in the low 4 bytes of xmm2/m32 to 4 packed 32-bit integers in xmm1.

pub fn vpmovzxbd_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Zero extend 4 packed 8-bit integers in the low 4 bytes of xmm2/m32 to 4 packed 32-bit integers in xmm1.

pub fn vpmovzxbd_YMM_Any64BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: Any64BitMemory
)

Zero extend 8 packed 8-bit integers in the low 8 bytes of xmm2/m64 to 8 packed 32-bit integers in ymm1.

pub fn vpmovzxbd_YMM_XMMRegister(&mut self, arg0: YMMRegister, arg1: XMMRegister)

Zero extend 8 packed 8-bit integers in the low 8 bytes of xmm2/m64 to 8 packed 32-bit integers in ymm1.

pub fn vpmovzxbq_XMMRegister_Any16BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any16BitMemory
)

Zero extend 2 packed 8-bit integers in the low 2 bytes of xmm2.m16 to 2 packed 64-bit integers in xmm1.

pub fn vpmovzxbq_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Zero extend 2 packed 8-bit integers in the low 2 bytes of xmm2.m16 to 2 packed 64-bit integers in xmm1.

pub fn vpmovzxbq_YMM_Any32BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: Any32BitMemory
)

Zero extend 4 packed 8-bit integers in the low 4 bytes of xmm2/m32 to 4 packed 64-bit integers in ymm1.

pub fn vpmovzxbq_YMM_XMMRegister(&mut self, arg0: YMMRegister, arg1: XMMRegister)

Zero extend 4 packed 8-bit integers in the low 4 bytes of xmm2/m32 to 4 packed 64-bit integers in ymm1.

pub fn vpmovzxbw_XMMRegister_Any64BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any64BitMemory
)

Zero extend 8 packed 8-bit integers in the low 8 bytes of xmm2/m64 to 8 packed 16-bit integers in xmm1.

pub fn vpmovzxbw_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Zero extend 8 packed 8-bit integers in the low 8 bytes of xmm2/m64 to 8 packed 16-bit integers in xmm1.

pub fn vpmovzxbw_YMM_Any128BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: Any128BitMemory
)

Zero extend 16 packed 8-bit integers in the low 16 bytes of xmm2/m128 to 16 packed 16-bit integers in ymm1.

pub fn vpmovzxbw_YMM_XMMRegister(&mut self, arg0: YMMRegister, arg1: XMMRegister)

Zero extend 16 packed 8-bit integers in the low 16 bytes of xmm2/m128 to 16 packed 16-bit integers in ymm1.

pub fn vpmovzxdq_XMMRegister_Any64BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any64BitMemory
)

Zero extend 2 packed 32-bit integers in the low 8 bytes of xmm2/m64 to 2 packed 64-bit integers in xmm1.

pub fn vpmovzxdq_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Zero extend 2 packed 32-bit integers in the low 8 bytes of xmm2/m64 to 2 packed 64-bit integers in xmm1.

pub fn vpmovzxdq_YMM_Any128BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: Any128BitMemory
)

Zero extend 4 packed 32-bit integers in the low 16 bytes of xmm2/m128 to 4 packed 64-bit integers in ymm1.

pub fn vpmovzxdq_YMM_XMMRegister(&mut self, arg0: YMMRegister, arg1: XMMRegister)

Zero extend 4 packed 32-bit integers in the low 16 bytes of xmm2/m128 to 4 packed 64-bit integers in ymm1.

pub fn vpmovzxwd_XMMRegister_Any64BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any64BitMemory
)

Zero extend 4 packed 16-bit integers in the low 8 bytes of xmm2/m64 to 4 packed 32-bit integers in xmm1.

pub fn vpmovzxwd_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Zero extend 4 packed 16-bit integers in the low 8 bytes of xmm2/m64 to 4 packed 32-bit integers in xmm1.

pub fn vpmovzxwd_YMM_Any128BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: Any128BitMemory
)

Zero extend 8 packed 16-bit integers in the low 16 bytes of xmm2/m128 to 8 packed 32-bit integers in ymm1.

pub fn vpmovzxwd_YMM_XMMRegister(&mut self, arg0: YMMRegister, arg1: XMMRegister)

Zero extend 8 packed 16-bit integers in the low 16 bytes of xmm2/m128 to 8 packed 32-bit integers in ymm1.

pub fn vpmovzxwq_XMMRegister_Any32BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any32BitMemory
)

Zero extend 2 packed 16-bit integers in the low 4 bytes of xmm2/m32 to 2 packed 64-bit integers in xmm1.

pub fn vpmovzxwq_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Zero extend 2 packed 16-bit integers in the low 4 bytes of xmm2/m32 to 2 packed 64-bit integers in xmm1.

pub fn vpmovzxwq_YMM_Any64BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: Any64BitMemory
)

Zero extend 4 packed 16-bit integers in the low 8 bytes of xmm2/m64 to 4 packed 64-bit integers in xmm1.

pub fn vpmovzxwq_YMM_XMMRegister(&mut self, arg0: YMMRegister, arg1: XMMRegister)

Zero extend 4 packed 16-bit integers in the low 8 bytes of xmm2/m64 to 4 packed 64-bit integers in xmm1.

pub fn vpmuldq_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Multiply packed signed doubleword integers in xmm2 by packed signed doubleword integers in xmm3/m128 and store the quadword results in xmm1.

pub fn vpmuldq_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Multiply packed signed doubleword integers in xmm2 by packed signed doubleword integers in xmm3/m128 and store the quadword results in xmm1.

pub fn vpmuldq_YMM_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory
)

Multiply packed signed doubleword integers in ymm2 by packed signed doubleword integers in ymm3/m256, and store the quadword results in ymm1.

pub fn vpmuldq_YMM_YMM_YMM(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister
)

Multiply packed signed doubleword integers in ymm2 by packed signed doubleword integers in ymm3/m256, and store the quadword results in ymm1.

pub fn vpmulhrsw_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Multiply 16-bit signed words, scale and round signed doublewords, pack high 16 bits to xmm1.

pub fn vpmulhrsw_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Multiply 16-bit signed words, scale and round signed doublewords, pack high 16 bits to xmm1.

pub fn vpmulhrsw_YMM_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory
)

Multiply 16-bit signed words, scale and round signed doublewords, pack high 16 bits to ymm1.

pub fn vpmulhrsw_YMM_YMM_YMM(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister
)

Multiply 16-bit signed words, scale and round signed doublewords, pack high 16 bits to ymm1.

pub fn vpmulhuw_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Multiply the packed unsigned word integers in xmm2 and xmm3/m128 and store the high 16 bits of the results in xmm1.

pub fn vpmulhuw_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Multiply the packed unsigned word integers in xmm2 and xmm3/m128 and store the high 16 bits of the results in xmm1.

pub fn vpmulhuw_YMM_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory
)

Multiply the packed unsigned word integers in ymm2 and ymm3/m256, and store the high 16 bits of the results in ymm1.

pub fn vpmulhuw_YMM_YMM_YMM(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister
)

Multiply the packed unsigned word integers in ymm2 and ymm3/m256, and store the high 16 bits of the results in ymm1.

pub fn vpmulhw_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Multiply the packed signed word integers in xmm2 and xmm3/m128 and store the high 16 bits of the results in xmm1.

pub fn vpmulhw_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Multiply the packed signed word integers in xmm2 and xmm3/m128 and store the high 16 bits of the results in xmm1.

pub fn vpmulhw_YMM_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory
)

Multiply the packed signed word integers in ymm2 and ymm3/m256, and store the high 16 bits of the results in ymm1.

pub fn vpmulhw_YMM_YMM_YMM(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister
)

Multiply the packed signed word integers in ymm2 and ymm3/m256, and store the high 16 bits of the results in ymm1.

pub fn vpmulld_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Multiply the packed dword signed integers in xmm2 and xmm3/m128 and store the low 32 bits of each product in xmm1.

pub fn vpmulld_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Multiply the packed dword signed integers in xmm2 and xmm3/m128 and store the low 32 bits of each product in xmm1.

pub fn vpmulld_YMM_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory
)

Multiply the packed dword signed integers in ymm2 and ymm3/m256 and store the low 32 bits of each product in ymm1.

pub fn vpmulld_YMM_YMM_YMM(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister
)

Multiply the packed dword signed integers in ymm2 and ymm3/m256 and store the low 32 bits of each product in ymm1.

pub fn vpmullw_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Multiply the packed dword signed integers in xmm2 and xmm3/m128 and store the low 32 bits of each product in xmm1.

pub fn vpmullw_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Multiply the packed dword signed integers in xmm2 and xmm3/m128 and store the low 32 bits of each product in xmm1.

pub fn vpmullw_YMM_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory
)

Multiply the packed signed word integers in ymm2 and ymm3/m256, and store the low 16 bits of the results in ymm1.

pub fn vpmullw_YMM_YMM_YMM(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister
)

Multiply the packed signed word integers in ymm2 and ymm3/m256, and store the low 16 bits of the results in ymm1.

pub fn vpmuludq_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Multiply packed unsigned doubleword integers in xmm2 by packed unsigned doubleword integers in xmm3/m128 and store the quadword results in xmm1.

pub fn vpmuludq_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Multiply packed unsigned doubleword integers in xmm2 by packed unsigned doubleword integers in xmm3/m128 and store the quadword results in xmm1.

pub fn vpmuludq_YMM_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory
)

Multiply packed unsigned doubleword integers in ymm2 by packed unsigned doubleword integers in ymm3/m256, and store the quadword results in ymm1.

pub fn vpmuludq_YMM_YMM_YMM(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister
)

Multiply packed unsigned doubleword integers in ymm2 by packed unsigned doubleword integers in ymm3/m256, and store the quadword results in ymm1.

pub fn vpor_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Bitwise OR of xmm2/m128 and xmm3.

pub fn vpor_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Bitwise OR of xmm2/m128 and xmm3.

pub fn vpor_YMM_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory
)

Bitwise OR of ymm2/m256 and ymm3.

pub fn vpor_YMM_YMM_YMM(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister
)

Bitwise OR of ymm2/m256 and ymm3.

pub fn vpsadbw_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Computes the absolute differences of the packed unsigned byte integers from xmm3 /m128 and xmm2.

The 8 low differences and 8 high differences are then summed separately to produce two unsigned word integer results.

pub fn vpsadbw_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Computes the absolute differences of the packed unsigned byte integers from xmm3 /m128 and xmm2.

The 8 low differences and 8 high differences are then summed separately to produce two unsigned word integer results.

pub fn vpsadbw_YMM_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory
)

Computes the absolute differences of the packed unsigned byte integers from ymm3/m256 and ymm2.

Then each consecutive 8 differences are summed separately to produce four unsigned word integer results.

pub fn vpsadbw_YMM_YMM_YMM(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister
)

Computes the absolute differences of the packed unsigned byte integers from ymm3/m256 and ymm2.

Then each consecutive 8 differences are summed separately to produce four unsigned word integer results.

pub fn vpshufb_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Shuffle bytes in xmm2 according to contents of xmm3/m128.

pub fn vpshufb_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Shuffle bytes in xmm2 according to contents of xmm3/m128.

pub fn vpshufb_YMM_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory
)

Shuffle bytes in ymm2 according to contents of ymm3/m256.

pub fn vpshufb_YMM_YMM_YMM(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister
)

Shuffle bytes in ymm2 according to contents of ymm3/m256.

pub fn vpshufd_XMMRegister_Any128BitMemory_Immediate8Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory,
    arg2: Immediate8Bit
)

Shuffle the doublewords in xmm2/m128 based on the encoding in imm8 and store the result in xmm1.

pub fn vpshufd_XMMRegister_XMMRegister_Immediate8Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Immediate8Bit
)

Shuffle the doublewords in xmm2/m128 based on the encoding in imm8 and store the result in xmm1.

pub fn vpshufd_YMM_Any256BitMemory_Immediate8Bit(
    &mut self,
    arg0: YMMRegister,
    arg1: Any256BitMemory,
    arg2: Immediate8Bit
)

Shuffle the doublewords in ymm2/m256 based on the encoding in imm8 and store the result in ymm1.

pub fn vpshufd_YMM_YMM_Immediate8Bit(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Immediate8Bit
)

Shuffle the doublewords in ymm2/m256 based on the encoding in imm8 and store the result in ymm1.

pub fn vpshufhw_XMMRegister_Any128BitMemory_Immediate8Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory,
    arg2: Immediate8Bit
)

Shuffle the high words in xmm2/m128 based on the encoding in imm8 and store the result in xmm1.

pub fn vpshufhw_XMMRegister_XMMRegister_Immediate8Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Immediate8Bit
)

Shuffle the high words in xmm2/m128 based on the encoding in imm8 and store the result in xmm1.

pub fn vpshufhw_YMM_Any256BitMemory_Immediate8Bit(
    &mut self,
    arg0: YMMRegister,
    arg1: Any256BitMemory,
    arg2: Immediate8Bit
)

Shuffle the high words in ymm2/m256 based on the encoding in imm8 and store the result in ymm1.

pub fn vpshufhw_YMM_YMM_Immediate8Bit(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Immediate8Bit
)

Shuffle the high words in ymm2/m256 based on the encoding in imm8 and store the result in ymm1.

pub fn vpshuflw_XMMRegister_Any128BitMemory_Immediate8Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory,
    arg2: Immediate8Bit
)

Shuffle the low words in xmm2/m128 based on the encoding in imm8 and store the result in xmm1.

pub fn vpshuflw_XMMRegister_XMMRegister_Immediate8Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Immediate8Bit
)

Shuffle the low words in xmm2/m128 based on the encoding in imm8 and store the result in xmm1.

pub fn vpshuflw_YMM_Any256BitMemory_Immediate8Bit(
    &mut self,
    arg0: YMMRegister,
    arg1: Any256BitMemory,
    arg2: Immediate8Bit
)

Shuffle the low words in ymm2/m256 based on the encoding in imm8 and store the result in ymm1.

pub fn vpshuflw_YMM_YMM_Immediate8Bit(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Immediate8Bit
)

Shuffle the low words in ymm2/m256 based on the encoding in imm8 and store the result in ymm1.

pub fn vpsignb_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Negate/zero/preserve packed byte integers in xmm2 depending on the corresponding sign in xmm3/m128.

pub fn vpsignb_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Negate/zero/preserve packed byte integers in xmm2 depending on the corresponding sign in xmm3/m128.

pub fn vpsignd_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Negate/zero/preserve packed doubleword integers in xmm2 depending on the corresponding sign in xmm3/m128.

pub fn vpsignd_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Negate/zero/preserve packed doubleword integers in xmm2 depending on the corresponding sign in xmm3/m128.

pub fn vpsignw_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Negate/zero/preserve packed word integers in xmm2 depending on the corresponding sign in xmm3/m128.

pub fn vpsignw_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Negate/zero/preserve packed word integers in xmm2 depending on the corresponding sign in xmm3/m128.

pub fn vpslld_XMMRegister_XMMRegister_Immediate8Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Immediate8Bit
)

Shift doublewords in xmm2 left by imm8 while shifting in zero-signed.

pub fn vpslld_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Shift doublewords in xmm2 left by amount specified in xmm3/m128 while shifting in zero-signed.

pub fn vpslld_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Shift doublewords in xmm2 left by amount specified in xmm3/m128 while shifting in zero-signed.

pub fn vpslld_YMM_YMM_Immediate8Bit(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Immediate8Bit
)

Shift doublewords in ymm2 left by imm8 while shifting in zero-signed.

pub fn vpslld_YMM_YMM_Any128BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any128BitMemory
)

Shift doublewords in ymm2 left by amount specified in xmm3/m128 while shifting in zero-signed.

pub fn vpslld_YMM_YMM_XMMRegister(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: XMMRegister
)

Shift doublewords in ymm2 left by amount specified in xmm3/m128 while shifting in zero-signed.

pub fn vpslldq_XMMRegister_XMMRegister_Immediate8Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Immediate8Bit
)

Shift xmm2 left by imm8 bytes while shifting in zero-signed and store result in xmm1.

pub fn vpslldq_YMM_YMM_Immediate8Bit(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Immediate8Bit
)

Shift ymm2 left by imm8 bytes while shifting in zero-signed and store result in ymm1.

pub fn vpsllq_XMMRegister_XMMRegister_Immediate8Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Immediate8Bit
)

Shift quadwords in xmm2 left by imm8 while shifting in zero-signed.

pub fn vpsllq_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Shift quadwords in xmm2 left by amount specified in xmm3/m128 while shifting in zero-signed.

pub fn vpsllq_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Shift quadwords in xmm2 left by amount specified in xmm3/m128 while shifting in zero-signed.

pub fn vpsllq_YMM_YMM_Immediate8Bit(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Immediate8Bit
)

Shift quadwords in ymm2 left by imm8 while shifting in zero-signed.

pub fn vpsllq_YMM_YMM_Any128BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any128BitMemory
)

Shift quadwords in ymm2 left by amount specified in xmm3/m128 while shifting in zero-signed.

pub fn vpsllq_YMM_YMM_XMMRegister(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: XMMRegister
)

Shift quadwords in ymm2 left by amount specified in xmm3/m128 while shifting in zero-signed.

pub fn vpsllvd_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Shift bits in doublewords in xmm2 left by amount specified in the corresponding element of xmm3/m128 while shifting in zero-signed.

pub fn vpsllvd_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Shift bits in doublewords in xmm2 left by amount specified in the corresponding element of xmm3/m128 while shifting in zero-signed.

pub fn vpsllvd_YMM_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory
)

Shift bits in doublewords in ymm2 left by amount specified in the corresponding element of ymm3/m256 while shifting in zero-signed.

pub fn vpsllvd_YMM_YMM_YMM(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister
)

Shift bits in doublewords in ymm2 left by amount specified in the corresponding element of ymm3/m256 while shifting in zero-signed.

pub fn vpsllvq_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Shift bits in quadwords in xmm2 left by amount specified in the corresponding element of xmm3/m128 while shifting in zero-signed.

pub fn vpsllvq_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Shift bits in quadwords in xmm2 left by amount specified in the corresponding element of xmm3/m128 while shifting in zero-signed.

pub fn vpsllvq_YMM_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory
)

Shift bits in quadwords in ymm2 left by amount specified in the corresponding element of ymm3/m256 while shifting in zero-signed.

pub fn vpsllvq_YMM_YMM_YMM(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister
)

Shift bits in quadwords in ymm2 left by amount specified in the corresponding element of ymm3/m256 while shifting in zero-signed.

pub fn vpsllw_XMMRegister_XMMRegister_Immediate8Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Immediate8Bit
)

Shift words in xmm2 left by imm8 while shifting in zero-signed.

pub fn vpsllw_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Shift words in xmm2 left by amount specified in xmm3/m128 while shifting in zero-signed.

pub fn vpsllw_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Shift words in xmm2 left by amount specified in xmm3/m128 while shifting in zero-signed.

pub fn vpsllw_YMM_YMM_Immediate8Bit(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Immediate8Bit
)

Shift words in ymm2 left by imm8 while shifting in zero-signed.

pub fn vpsllw_YMM_YMM_Any128BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any128BitMemory
)

Shift words in ymm2 left by amount specified in xmm3/m128 while shifting in zero-signed.

pub fn vpsllw_YMM_YMM_XMMRegister(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: XMMRegister
)

Shift words in ymm2 left by amount specified in xmm3/m128 while shifting in zero-signed.

pub fn vpsrad_XMMRegister_XMMRegister_Immediate8Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Immediate8Bit
)

Shift doublewords in xmm2 right by imm8 while shifting in sign bits.

pub fn vpsrad_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Shift doublewords in xmm2 right by amount specified in xmm3/m128 while shifting in sign bits.

pub fn vpsrad_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Shift doublewords in xmm2 right by amount specified in xmm3/m128 while shifting in sign bits.

pub fn vpsrad_YMM_YMM_Immediate8Bit(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Immediate8Bit
)

Shift doublewords in ymm2 right by imm8 while shifting in sign bits.

pub fn vpsrad_YMM_YMM_Any128BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any128BitMemory
)

Shift doublewords in ymm2 right by amount specified in xmm3/m128 while shifting in sign bits.

pub fn vpsrad_YMM_YMM_XMMRegister(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: XMMRegister
)

Shift doublewords in ymm2 right by amount specified in xmm3/m128 while shifting in sign bits.

pub fn vpsravd_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Shift bits in doublewords in xmm2 right by amount specified in the corresponding element of xmm3/m128 while shifting in the sign bits.

pub fn vpsravd_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Shift bits in doublewords in xmm2 right by amount specified in the corresponding element of xmm3/m128 while shifting in the sign bits.

pub fn vpsravd_YMM_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory
)

Shift bits in doublewords in ymm2 right by amount specified in the corresponding element of ymm3/m256 while shifting in the sign bits.

pub fn vpsravd_YMM_YMM_YMM(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister
)

Shift bits in doublewords in ymm2 right by amount specified in the corresponding element of ymm3/m256 while shifting in the sign bits.

pub fn vpsraw_XMMRegister_XMMRegister_Immediate8Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Immediate8Bit
)

Shift words in xmm2 right by imm8 while shifting in sign bits.

pub fn vpsraw_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Shift words in xmm2 right by amount specified in xmm3/m128 while shifting in sign bits.

pub fn vpsraw_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Shift words in xmm2 right by amount specified in xmm3/m128 while shifting in sign bits.

pub fn vpsraw_YMM_YMM_Immediate8Bit(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Immediate8Bit
)

Shift words in ymm2 right by imm8 while shifting in sign bits.

pub fn vpsraw_YMM_YMM_Any128BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any128BitMemory
)

Shift words in ymm2 right by amount specified in xmm3/m128 while shifting in sign bits.

pub fn vpsraw_YMM_YMM_XMMRegister(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: XMMRegister
)

Shift words in ymm2 right by amount specified in xmm3/m128 while shifting in sign bits.

pub fn vpsrld_XMMRegister_XMMRegister_Immediate8Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Immediate8Bit
)

Shift doublewords in xmm2 right by imm8 while shifting in zero-signed.

pub fn vpsrld_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Shift doublewords in xmm2 right by amount specified in xmm3/m128 while shifting in zero-signed.

pub fn vpsrld_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Shift doublewords in xmm2 right by amount specified in xmm3/m128 while shifting in zero-signed.

pub fn vpsrld_YMM_YMM_Immediate8Bit(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Immediate8Bit
)

Shift doublewords in ymm2 right by imm8 while shifting in zero-signed.

pub fn vpsrld_YMM_YMM_Any128BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any128BitMemory
)

Shift doublewords in ymm2 right by amount specified in xmm3/m128 while shifting in zero-signed.

pub fn vpsrld_YMM_YMM_XMMRegister(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: XMMRegister
)

Shift doublewords in ymm2 right by amount specified in xmm3/m128 while shifting in zero-signed.

pub fn vpsrldq_XMMRegister_XMMRegister_Immediate8Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Immediate8Bit
)

Shift xmm2 right by imm8 bytes while shifting in zero-signed.

pub fn vpsrldq_YMM_YMM_Immediate8Bit(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Immediate8Bit
)

Shift ymm1 right by imm8 bytes while shifting in zero-signed.

pub fn vpsrlq_XMMRegister_XMMRegister_Immediate8Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Immediate8Bit
)

Shift quadwords in xmm2 right by imm8 while shifting in zero-signed.

pub fn vpsrlq_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Shift quadwords in xmm2 right by amount specified in xmm3/m128 while shifting in zero-signed.

pub fn vpsrlq_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Shift quadwords in xmm2 right by amount specified in xmm3/m128 while shifting in zero-signed.

pub fn vpsrlq_YMM_YMM_Immediate8Bit(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Immediate8Bit
)

Shift quadwords in ymm2 right by imm8 while shifting in zero-signed.

pub fn vpsrlq_YMM_YMM_Any128BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any128BitMemory
)

Shift quadwords in ymm2 right by amount specified in xmm3/m128 while shifting in zero-signed.

pub fn vpsrlq_YMM_YMM_XMMRegister(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: XMMRegister
)

Shift quadwords in ymm2 right by amount specified in xmm3/m128 while shifting in zero-signed.

pub fn vpsrlvd_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Shift bits in doublewords in xmm2 right by amount specified in the corresponding element of xmm3/m128 while shifting in zero-signed.

pub fn vpsrlvd_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Shift bits in doublewords in xmm2 right by amount specified in the corresponding element of xmm3/m128 while shifting in zero-signed.

pub fn vpsrlvd_YMM_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory
)

Shift bits in doublewords in ymm2 right by amount specified in the corresponding element of ymm3/m256 while shifting in zero-signed.

pub fn vpsrlvd_YMM_YMM_YMM(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister
)

Shift bits in doublewords in ymm2 right by amount specified in the corresponding element of ymm3/m256 while shifting in zero-signed.

pub fn vpsrlvq_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Shift bits in quadwords in xmm2 right by amount specified in the corresponding element of xmm3/m128 while shifting in zero-signed.

pub fn vpsrlvq_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Shift bits in quadwords in xmm2 right by amount specified in the corresponding element of xmm3/m128 while shifting in zero-signed.

pub fn vpsrlvq_YMM_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory
)

Shift bits in quadwords in ymm2 right by amount specified in the corresponding element of ymm3/m256 while shifting in zero-signed.

pub fn vpsrlvq_YMM_YMM_YMM(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister
)

Shift bits in quadwords in ymm2 right by amount specified in the corresponding element of ymm3/m256 while shifting in zero-signed.

pub fn vpsrlw_XMMRegister_XMMRegister_Immediate8Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Immediate8Bit
)

Shift words in xmm2 right by imm8 while shifting in zero-signed.

pub fn vpsrlw_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Shift words in xmm2 right by amount specified in xmm3/m128 while shifting in zero-signed.

pub fn vpsrlw_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Shift words in xmm2 right by amount specified in xmm3/m128 while shifting in zero-signed.

pub fn vpsrlw_YMM_YMM_Immediate8Bit(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Immediate8Bit
)

Shift words in ymm2 right by imm8 while shifting in zero-signed.

pub fn vpsrlw_YMM_YMM_Any128BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any128BitMemory
)

Shift words in ymm2 right by amount specified in xmm3/m128 while shifting in zero-signed.

pub fn vpsrlw_YMM_YMM_XMMRegister(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: XMMRegister
)

Shift words in ymm2 right by amount specified in xmm3/m128 while shifting in zero-signed.

pub fn vpsubb_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Subtract packed byte integers in xmm3/m128 from xmm2.

pub fn vpsubb_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Subtract packed byte integers in xmm3/m128 from xmm2.

pub fn vpsubb_YMM_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory
)

Subtract packed byte integers in ymm3/m256 from ymm2.

pub fn vpsubb_YMM_YMM_YMM(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister
)

Subtract packed byte integers in ymm3/m256 from ymm2.

pub fn vpsubd_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Subtract packed doubleword integers in xmm3/m128 from xmm2.

pub fn vpsubd_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Subtract packed doubleword integers in xmm3/m128 from xmm2.

pub fn vpsubd_YMM_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory
)

Subtract packed doubleword integers in ymm3/m256 from ymm2.

pub fn vpsubd_YMM_YMM_YMM(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister
)

Subtract packed doubleword integers in ymm3/m256 from ymm2.

pub fn vpsubq_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Subtract packed quadword integers in xmm3/m128 from xmm2.

pub fn vpsubq_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Subtract packed quadword integers in xmm3/m128 from xmm2.

pub fn vpsubq_YMM_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory
)

Subtract packed quadword integers in ymm3/m256 from ymm2.

pub fn vpsubq_YMM_YMM_YMM(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister
)

Subtract packed quadword integers in ymm3/m256 from ymm2.

pub fn vpsubsb_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Subtract packed signed byte integers in xmm3/m128 from packed signed byte integers in xmm2 and saturate results.

pub fn vpsubsb_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Subtract packed signed byte integers in xmm3/m128 from packed signed byte integers in xmm2 and saturate results.

pub fn vpsubsb_YMM_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory
)

Subtract packed signed byte integers in ymm3/m256 from packed signed byte integers in ymm2 and saturate results.

pub fn vpsubsb_YMM_YMM_YMM(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister
)

Subtract packed signed byte integers in ymm3/m256 from packed signed byte integers in ymm2 and saturate results.

pub fn vpsubsw_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Subtract packed signed word integers in xmm3/m128 from packed signed word integers in xmm2 and saturate results.

pub fn vpsubsw_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Subtract packed signed word integers in xmm3/m128 from packed signed word integers in xmm2 and saturate results.

pub fn vpsubsw_YMM_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory
)

Subtract packed signed word integers in ymm3/m256 from packed signed word integers in ymm2 and saturate results.

pub fn vpsubsw_YMM_YMM_YMM(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister
)

Subtract packed signed word integers in ymm3/m256 from packed signed word integers in ymm2 and saturate results.

pub fn vpsubusb_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Subtract packed unsigned byte integers in xmm3/m128 from packed unsigned byte integers in xmm2 and saturate result.

pub fn vpsubusb_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Subtract packed unsigned byte integers in xmm3/m128 from packed unsigned byte integers in xmm2 and saturate result.

pub fn vpsubusb_YMM_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory
)

Subtract packed unsigned byte integers in ymm3/m256 from packed unsigned byte integers in ymm2 and saturate result.

pub fn vpsubusb_YMM_YMM_YMM(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister
)

Subtract packed unsigned byte integers in ymm3/m256 from packed unsigned byte integers in ymm2 and saturate result.

pub fn vpsubusw_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Subtract packed unsigned word integers in xmm3/m128 from packed unsigned word integers in xmm2 and saturate result.

pub fn vpsubusw_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Subtract packed unsigned word integers in xmm3/m128 from packed unsigned word integers in xmm2 and saturate result.

pub fn vpsubusw_YMM_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory
)

Subtract packed unsigned word integers in ymm3/m256 from packed unsigned word integers in ymm2 and saturate result.

pub fn vpsubusw_YMM_YMM_YMM(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister
)

Subtract packed unsigned word integers in ymm3/m256 from packed unsigned word integers in ymm2 and saturate result.

pub fn vpsubw_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Subtract packed word integers in xmm3/m128 from xmm2.

pub fn vpsubw_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Subtract packed word integers in xmm3/m128 from xmm2.

pub fn vpsubw_YMM_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory
)

Subtract packed word integers in ymm3/m256 from ymm2.

pub fn vpsubw_YMM_YMM_YMM(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister
)

Subtract packed word integers in ymm3/m256 from ymm2.

pub fn vptest_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Set Zero Flag (ZF) and Carry Flag (CF) depending on bitwise AND and ANDN of sources.

pub fn vptest_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Set Zero Flag (ZF) and Carry Flag (CF) depending on bitwise AND and ANDN of sources.

pub fn vptest_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: Any256BitMemory
)

Set Zero Flag (ZF) and Carry Flag (CF) depending on bitwise AND and ANDN of sources.

pub fn vptest_YMM_YMM(&mut self, arg0: YMMRegister, arg1: YMMRegister)

Set Zero Flag (ZF) and Carry Flag (CF) depending on bitwise AND and ANDN of sources.

pub fn vpunpckhbw_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Interleave high-order bytes from xmm2 and xmm3/m128 into xmm1.

pub fn vpunpckhbw_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Interleave high-order bytes from xmm2 and xmm3/m128 into xmm1.

pub fn vpunpckhbw_YMM_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory
)

Interleave high-order bytes from ymm2 and ymm3/m256 into ymm1.

pub fn vpunpckhbw_YMM_YMM_YMM(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister
)

Interleave high-order bytes from ymm2 and ymm3/m256 into ymm1.

pub fn vpunpckhdq_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Interleave high-order doublewords from xmm2 and xmm3/m128 into xmm1.

pub fn vpunpckhdq_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Interleave high-order doublewords from xmm2 and xmm3/m128 into xmm1.

pub fn vpunpckhdq_YMM_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory
)

Interleave high-order doublewords from ymm2 and ymm3/m256 into ymm1.

pub fn vpunpckhdq_YMM_YMM_YMM(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister
)

Interleave high-order doublewords from ymm2 and ymm3/m256 into ymm1.

pub fn vpunpckhqdq_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Interleave high-order quadword from xmm2 and xmm3/m128 into xmm1.

pub fn vpunpckhqdq_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Interleave high-order quadword from xmm2 and xmm3/m128 into xmm1.

pub fn vpunpckhqdq_YMM_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory
)

Interleave high-order quadword from ymm2 and ymm3/m256 into ymm1.

pub fn vpunpckhqdq_YMM_YMM_YMM(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister
)

Interleave high-order quadword from ymm2 and ymm3/m256 into ymm1.

pub fn vpunpckhwd_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Interleave high-order words from xmm2 and xmm3/m128 into xmm1.

pub fn vpunpckhwd_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Interleave high-order words from xmm2 and xmm3/m128 into xmm1.

pub fn vpunpckhwd_YMM_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory
)

Interleave high-order words from ymm2 and ymm3/m256 into ymm1.

pub fn vpunpckhwd_YMM_YMM_YMM(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister
)

Interleave high-order words from ymm2 and ymm3/m256 into ymm1.

pub fn vpunpcklbw_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Interleave low-order bytes from xmm2 and xmm3/m128 into xmm1.

pub fn vpunpcklbw_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Interleave low-order bytes from xmm2 and xmm3/m128 into xmm1.

pub fn vpunpcklbw_YMM_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory
)

Interleave low-order bytes from ymm2 and ymm3/m256 into ymm1.

pub fn vpunpcklbw_YMM_YMM_YMM(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister
)

Interleave low-order bytes from ymm2 and ymm3/m256 into ymm1.

pub fn vpunpckldq_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Interleave low-order doublewords from xmm2 and xmm3/m128 into xmm1.

pub fn vpunpckldq_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Interleave low-order doublewords from xmm2 and xmm3/m128 into xmm1.

pub fn vpunpckldq_YMM_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory
)

Interleave low-order doublewords from ymm2 and ymm3/m256 into ymm1.

pub fn vpunpckldq_YMM_YMM_YMM(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister
)

Interleave low-order doublewords from ymm2 and ymm3/m256 into ymm1.

pub fn vpunpcklqdq_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Interleave low-order quadword from xmm2 and xmm3/m128 into xmm1.

pub fn vpunpcklqdq_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Interleave low-order quadword from xmm2 and xmm3/m128 into xmm1.

pub fn vpunpcklqdq_YMM_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory
)

Interleave low-order quadword from ymm2 and ymm3/m256 into ymm1.

pub fn vpunpcklqdq_YMM_YMM_YMM(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister
)

Interleave low-order quadword from ymm2 and ymm3/m256 into ymm1.

pub fn vpunpcklwd_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Interleave low-order words from xmm2 and xmm3/m128 into xmm1.

pub fn vpunpcklwd_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Interleave low-order words from xmm2 and xmm3/m128 into xmm1.

pub fn vpunpcklwd_YMM_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory
)

Interleave low-order words from ymm2 and ymm3/m256 into ymm1.

pub fn vpunpcklwd_YMM_YMM_YMM(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister
)

Interleave low-order words from ymm2 and ymm3/m256 into ymm1.

pub fn vpxor_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Bitwise XOR of xmm3/m128 and xmm2.

pub fn vpxor_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Bitwise XOR of xmm3/m128 and xmm2.

pub fn vpxor_YMM_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory
)

Bitwise XOR of ymm3/m256 and ymm2.

pub fn vpxor_YMM_YMM_YMM(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister
)

Bitwise XOR of ymm3/m256 and ymm2.

pub fn vrcpps_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Computes the approximate reciprocals of packed single-precision values in xmm2/mem and stores the results in xmm1.

pub fn vrcpps_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Computes the approximate reciprocals of packed single-precision values in xmm2/mem and stores the results in xmm1.

pub fn vrcpps_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: Any256BitMemory
)

Computes the approximate reciprocals of packed single-precision values in ymm2/mem and stores the results in ymm1.

pub fn vrcpps_YMM_YMM(&mut self, arg0: YMMRegister, arg1: YMMRegister)

Computes the approximate reciprocals of packed single-precision values in ymm2/mem and stores the results in ymm1.

pub fn vrcpss_XMMRegister_XMMRegister_Any32BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any32BitMemory
)

Computes the approximate reciprocal of the scalar single-precision floating-point value in xmm3/m32 and stores the result in xmm1.

Also, upper single-precision floating-point values (bits [127:32]) from xmm2 are copied to xmm1 bits [127:32].

pub fn vrcpss_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Computes the approximate reciprocal of the scalar single-precision floating-point value in xmm3/m32 and stores the result in xmm1.

Also, upper single-precision floating-point values (bits [127:32]) from xmm2 are copied to xmm1 bits [127:32].

pub fn vroundpd_XMMRegister_Any128BitMemory_Immediate8Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory,
    arg2: Immediate8Bit
)

Round packed double-precision floating-point values in xmm2/m128 and place the result in xmm1.

The rounding mode is determined by imm8.

pub fn vroundpd_XMMRegister_XMMRegister_Immediate8Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Immediate8Bit
)

Round packed double-precision floating-point values in xmm2/m128 and place the result in xmm1.

The rounding mode is determined by imm8.

pub fn vroundpd_YMM_Any256BitMemory_Immediate8Bit(
    &mut self,
    arg0: YMMRegister,
    arg1: Any256BitMemory,
    arg2: Immediate8Bit
)

Round packed double-precision floating-point values in ymm2/m256 and place the result in ymm1.

The rounding mode is determined by imm8.

pub fn vroundpd_YMM_YMM_Immediate8Bit(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Immediate8Bit
)

Round packed double-precision floating-point values in ymm2/m256 and place the result in ymm1.

The rounding mode is determined by imm8.

pub fn vroundps_XMMRegister_Any128BitMemory_Immediate8Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory,
    arg2: Immediate8Bit
)

Round packed single-precision floating-point values in xmm2/m128 and place the result in xmm1.

The rounding mode is determined by imm8.

pub fn vroundps_XMMRegister_XMMRegister_Immediate8Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Immediate8Bit
)

Round packed single-precision floating-point values in xmm2/m128 and place the result in xmm1.

The rounding mode is determined by imm8.

pub fn vroundps_YMM_Any256BitMemory_Immediate8Bit(
    &mut self,
    arg0: YMMRegister,
    arg1: Any256BitMemory,
    arg2: Immediate8Bit
)

Round packed single-precision floating-point values in ymm2/m256 and place the result in ymm1.

The rounding mode is determined by imm8.

pub fn vroundps_YMM_YMM_Immediate8Bit(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Immediate8Bit
)

Round packed single-precision floating-point values in ymm2/m256 and place the result in ymm1.

The rounding mode is determined by imm8.

pub fn vroundsd_XMMRegister_XMMRegister_Any64BitMemory_Immediate8Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any64BitMemory,
    arg3: Immediate8Bit
)

Round the low packed double-precision floating-point value in xmm3/m64 and place the result in xmm1.

The rounding mode is determined by imm8.

Upper packed double-precision floating-point value (bits [127:64]) from xmm2 is copied to xmm1 bits [127:64].

pub fn vroundsd_XMMRegister_XMMRegister_XMMRegister_Immediate8Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister,
    arg3: Immediate8Bit
)

Round the low packed double-precision floating-point value in xmm3/m64 and place the result in xmm1.

The rounding mode is determined by imm8.

Upper packed double-precision floating-point value (bits [127:64]) from xmm2 is copied to xmm1 bits [127:64].

pub fn vroundss_XMMRegister_XMMRegister_Any32BitMemory_Immediate8Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any32BitMemory,
    arg3: Immediate8Bit
)

Round the low packed single-precision floating-point value in xmm3/m32 and place the result in xmm1.

The rounding mode is determined by imm8.

Also, upper packed single-precision floating-point values (bits [127:32]) from xmm2 are copied to xmm1 bits [127:32].

pub fn vroundss_XMMRegister_XMMRegister_XMMRegister_Immediate8Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister,
    arg3: Immediate8Bit
)

Round the low packed single-precision floating-point value in xmm3/m32 and place the result in xmm1.

The rounding mode is determined by imm8.

Also, upper packed single-precision floating-point values (bits [127:32]) from xmm2 are copied to xmm1 bits [127:32].

pub fn vrsqrtps_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Computes the approximate reciprocals of the square roots of packed single-precision values in xmm2/mem and stores the results in xmm1.

pub fn vrsqrtps_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Computes the approximate reciprocals of the square roots of packed single-precision values in xmm2/mem and stores the results in xmm1.

pub fn vrsqrtps_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: Any256BitMemory
)

Computes the approximate reciprocals of the square roots of packed single-precision values in ymm2/mem and stores the results in ymm1.

pub fn vrsqrtps_YMM_YMM(&mut self, arg0: YMMRegister, arg1: YMMRegister)

Computes the approximate reciprocals of the square roots of packed single-precision values in ymm2/mem and stores the results in ymm1.

pub fn vrsqrtss_XMMRegister_XMMRegister_Any32BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any32BitMemory
)

Computes the approximate reciprocal of the square root of the low single-precision floating-point value in xmm3/m32 and stores the results in xmm1.

Also, upper single-precision floating-point values (bits [127:32]) from xmm2 are copied to xmm1 bits [127:32].

pub fn vrsqrtss_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Computes the approximate reciprocal of the square root of the low single-precision floating-point value in xmm3/m32 and stores the results in xmm1.

Also, upper single-precision floating-point values (bits [127:32]) from xmm2 are copied to xmm1``[127:32].

pub fn vshufpd_XMMRegister_XMMRegister_Any128BitMemory_Immediate8Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory,
    arg3: Immediate8Bit
)

Shuffle Packed double-precision floating-point values selected by imm8 from xmm2 and xmm3/mem.

pub fn vshufpd_XMMRegister_XMMRegister_XMMRegister_Immediate8Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister,
    arg3: Immediate8Bit
)

Shuffle Packed double-precision floating-point values selected by imm8 from xmm2 and xmm3/mem.

pub fn vshufpd_YMM_YMM_Any256BitMemory_Immediate8Bit(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory,
    arg3: Immediate8Bit
)

Shuffle Packed double-precision floating-point values selected by imm8 from ymm2 and ymm3/mem.

pub fn vshufpd_YMM_YMM_YMM_Immediate8Bit(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister,
    arg3: Immediate8Bit
)

Shuffle Packed double-precision floating-point values selected by imm8 from ymm2 and ymm3/mem.

pub fn vshufps_XMMRegister_XMMRegister_Any128BitMemory_Immediate8Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory,
    arg3: Immediate8Bit
)

Shuffle Packed single-precision floating-point values selected by imm8 from xmm2 and xmm3/mem.

pub fn vshufps_XMMRegister_XMMRegister_XMMRegister_Immediate8Bit(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister,
    arg3: Immediate8Bit
)

Shuffle Packed single-precision floating-point values selected by imm8 from xmm2 and xmm3/mem.

pub fn vshufps_YMM_YMM_Any256BitMemory_Immediate8Bit(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory,
    arg3: Immediate8Bit
)

Shuffle Packed single-precision floating-point values selected by imm8 from ymm2 and ymm3/mem.

pub fn vshufps_YMM_YMM_YMM_Immediate8Bit(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister,
    arg3: Immediate8Bit
)

Shuffle Packed single-precision floating-point values selected by imm8 from ymm2 and ymm3/mem.

pub fn vsqrtpd_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Computes Square Roots of the packed double-precision floating-point values in xmm2/m128 and stores the result in xmm1.

pub fn vsqrtpd_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Computes Square Roots of the packed double-precision floating-point values in xmm2/m128 and stores the result in xmm1.

pub fn vsqrtpd_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: Any256BitMemory
)

Computes Square Roots of the packed double-precision floating-point values in ymm2/m256 and stores the result in ymm1.

pub fn vsqrtpd_YMM_YMM(&mut self, arg0: YMMRegister, arg1: YMMRegister)

Computes Square Roots of the packed double-precision floating-point values in ymm2/m256 and stores the result in ymm1.

pub fn vsqrtps_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Computes Square Roots of the packed single-precision floating-point values in xmm2/m128 and stores the result in xmm1.

pub fn vsqrtps_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Computes Square Roots of the packed single-precision floating-point values in xmm2/m128 and stores the result in xmm1.

pub fn vsqrtps_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: Any256BitMemory
)

Computes Square Roots of the packed single-precision floating-point values in ymm2/m256 and stores the result in ymm1.

pub fn vsqrtps_YMM_YMM(&mut self, arg0: YMMRegister, arg1: YMMRegister)

Computes Square Roots of the packed single-precision floating-point values in ymm2/m256 and stores the result in ymm1.

pub fn vsqrtsd_XMMRegister_XMMRegister_Any64BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any64BitMemory
)

Computes square root of the low double-precision floating-point value in xmm3/m64 and stores the results in xmm2.

Also, upper double-precision floating-point value (bits [127:64]) from xmm2 is copied to xmm1 bits [127:64].

pub fn vsqrtsd_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Computes square root of the low double-precision floating-point value in xmm3/m64 and stores the results in xmm2.

Also, upper double-precision floating-point value (bits [127:64]) from xmm2 is copied to xmm1 bits [127:64].

pub fn vsqrtss_XMMRegister_XMMRegister_Any32BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any32BitMemory
)

Computes square root of the low single-precision floating-point value in xmm3/m32 and stores the results in xmm1.

Also, upper single-precision floating-point values (bits [127:32]) from xmm2 are copied to xmm1 bits [127:32].

pub fn vsqrtss_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Computes square root of the low single-precision floating-point value in xmm3/m32 and stores the results in xmm1.

Also, upper single-precision floating-point values (bits [127:32]) from xmm2 are copied to xmm1 bits [127:32].

pub fn vstmxcsr_Any32BitMemory(&mut self, arg0: Any32BitMemory)

Store contents of MXCSR register to m32.

pub fn vsubpd_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Subtract packed double-precision floating-point values in xmm3/mem from xmm2 and stores result in xmm1.

pub fn vsubpd_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Subtract packed double-precision floating-point values in xmm3/mem from xmm2 and stores result in xmm1.

pub fn vsubpd_YMM_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory
)

Subtract packed double-precision floating-point values in ymm3/mem from ymm2 and stores result in ymm1.

pub fn vsubpd_YMM_YMM_YMM(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister
)

Subtract packed double-precision floating-point values in ymm3/mem from ymm2 and stores result in ymm1.

pub fn vsubps_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Subtract packed single-precision floating-point values in xmm3/mem from xmm2 and stores result in xmm1.

pub fn vsubps_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Subtract packed single-precision floating-point values in xmm3/mem from xmm2 and stores result in xmm1.

pub fn vsubps_YMM_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory
)

Subtract packed single-precision floating-point values in ymm3/mem from ymm2 and stores result in ymm1.

pub fn vsubps_YMM_YMM_YMM(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister
)

Subtract packed single-precision floating-point values in ymm3/mem from ymm2 and stores result in ymm1.

pub fn vsubsd_XMMRegister_XMMRegister_Any64BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any64BitMemory
)

Subtract the low double-precision floating-point value in xmm3/mem from xmm2 and store the result in xmm1.

pub fn vsubsd_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Subtract the low double-precision floating-point value in xmm3/mem from xmm2 and store the result in xmm1.

pub fn vsubss_XMMRegister_XMMRegister_Any32BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any32BitMemory
)

Subtract the low single-precision floating-point value in xmm3/mem from xmm2 and store the result in xmm1.

pub fn vsubss_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Subtract the low single-precision floating-point value in xmm3/mem from xmm2 and store the result in xmm1.

pub fn vtestpd_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Set Zero Flag (ZF) and Carry Flag (CF) depending on sign bit AND and ANDN of packed double-precision floating-point sources.

pub fn vtestpd_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Set Zero Flag (ZF) and Carry Flag (CF) depending on sign bit AND and ANDN of packed double-precision floating-point sources.

pub fn vtestpd_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: Any256BitMemory
)

Set Zero Flag (ZF) and Carry Flag (CF) depending on sign bit AND and ANDN of packed double-precision floating-point sources.

pub fn vtestpd_YMM_YMM(&mut self, arg0: YMMRegister, arg1: YMMRegister)

Set Zero Flag (ZF) and Carry Flag (CF) depending on sign bit AND and ANDN of packed double-precision floating-point sources.

pub fn vtestps_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Set Zero Flag (ZF) and Carry Flag (CF) depending on sign bit AND and ANDN of packed single-precision floating-point sources.

pub fn vtestps_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Set Zero Flag (ZF) and Carry Flag (CF) depending on sign bit AND and ANDN of packed single-precision floating-point sources.

pub fn vtestps_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: Any256BitMemory
)

Set Zero Flag (ZF) and Carry Flag (CF) depending on sign bit AND and ANDN of packed single-precision floating-point sources.

pub fn vtestps_YMM_YMM(&mut self, arg0: YMMRegister, arg1: YMMRegister)

Set Zero Flag (ZF) and Carry Flag (CF) depending on sign bit AND and ANDN of packed single-precision floating-point sources.

pub fn vucomisd_XMMRegister_Any64BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any64BitMemory
)

Compare low double-precision floating-point values in xmm1 and xmm2/mem64 and sets the appropriate flags in EFLAGS accordingly.

pub fn vucomisd_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Compare low double-precision floating-point values in xmm1 and xmm2/mem64 and sets the appropriate flags in EFLAGS accordingly.

pub fn vucomiss_XMMRegister_Any32BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any32BitMemory
)

Compare low single-precision floating-point values in xmm1 and xmm2/mem32 and sets the appropriate flags in EFLAGS accordingly.

pub fn vucomiss_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Compare low single-precision floating-point values in xmm1 and xmm2/mem32 and sets the appropriate flags in EFLAGS accordingly.

pub fn vunpckhpd_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Unpacks and Interleaves double-precision floating-point values from high quadwords of xmm2 and xmm3/m128.

pub fn vunpckhpd_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Unpacks and Interleaves double-precision floating-point values from high quadwords of xmm2 and xmm3/m128.

pub fn vunpckhpd_YMM_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory
)

Unpacks and Interleaves double-precision floating-point values from high quadwords of ymm2 and ymm3/m256.

pub fn vunpckhpd_YMM_YMM_YMM(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister
)

Unpacks and Interleaves double-precision floating-point values from high quadwords of ymm2 and ymm3/m256.

pub fn vunpckhps_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Unpacks and Interleaves single-precision floating-point values from high quadwords of xmm2 and xmm3/m128.

pub fn vunpckhps_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Unpacks and Interleaves single-precision floating-point values from high quadwords of xmm2 and xmm3/m128.

pub fn vunpckhps_YMM_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory
)

Unpacks and Interleaves single-precision floating-point values from high quadwords of ymm2 and ymm3/m256.

pub fn vunpckhps_YMM_YMM_YMM(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister
)

Unpacks and Interleaves single-precision floating-point values from high quadwords of ymm2 and ymm3/m256.

pub fn vunpcklpd_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Unpacks and Interleaves double-precision floating-point values low high quadwords of xmm2 and xmm3/m128.

pub fn vunpcklpd_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Unpacks and Interleaves double-precision floating-point values low high quadwords of xmm2 and xmm3/m128.

pub fn vunpcklpd_YMM_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory
)

Unpacks and Interleaves double-precision floating-point values low high quadwords of ymm2 and ymm3/m256.

pub fn vunpcklpd_YMM_YMM_YMM(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister
)

Unpacks and Interleaves double-precision floating-point values low high quadwords of ymm2 and ymm3/m256.

pub fn vunpcklps_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Unpacks and Interleaves single-precision floating-point values from low quadwords of xmm2 and xmm3/m128.

pub fn vunpcklps_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Unpacks and Interleaves single-precision floating-point values from low quadwords of xmm2 and xmm3/m128.

pub fn vunpcklps_YMM_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory
)

Unpacks and Interleaves single-precision floating-point values from low quadwords of ymm2 and ymm3/m256.

pub fn vunpcklps_YMM_YMM_YMM(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister
)

Unpacks and Interleaves single-precision floating-point values from low quadwords of ymm2 and ymm3/m256.

pub fn vxorpd_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Return the bitwise logical XOR of packed double-precision floating-point values in xmm2 and xmm3/mem.

pub fn vxorpd_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Return the bitwise logical XOR of packed double-precision floating-point values in xmm2 and xmm3/mem.

pub fn vxorpd_YMM_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory
)

Return the bitwise logical XOR of packed double-precision floating-point values in ymm2 and ymm3/mem.

pub fn vxorpd_YMM_YMM_YMM(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister
)

Return the bitwise logical XOR of packed double-precision floating-point values in ymm2 and ymm3/mem.

pub fn vxorps_XMMRegister_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: Any128BitMemory
)

Return the bitwise logical XOR of packed single-precision floating-point values in xmm2 and xmm3/mem.

pub fn vxorps_XMMRegister_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister,
    arg2: XMMRegister
)

Return the bitwise logical XOR of packed single-precision floating-point values in xmm2 and xmm3/mem.

pub fn vxorps_YMM_YMM_Any256BitMemory(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: Any256BitMemory
)

Return the bitwise logical XOR of packed single-precision floating-point values in ymm2 and ymm3/mem.

pub fn vxorps_YMM_YMM_YMM(
    &mut self,
    arg0: YMMRegister,
    arg1: YMMRegister,
    arg2: YMMRegister
)

Return the bitwise logical XOR of packed single-precision floating-point values in ymm2 and ymm3/mem.

pub fn vzeroall(&mut self)

Zero all YMM registers.

pub fn vzeroupper(&mut self)

Zero upper 128 bits of all YMM registers.

pub fn wait(&mut self)

Check pending unmasked floating-point exceptions.

pub fn wrfsbase_Register32Bit(&mut self, arg0: Register32Bit)

Load the FS base address with the 32-bit value in the source register.

pub fn wrfsbase_Register64Bit(&mut self, arg0: Register64Bit)

Load the FS base address with the 64-bit value in the source register.

pub fn wrgsbase_Register32Bit(&mut self, arg0: Register32Bit)

Load the GS base address with the 32-bit value in the source register.

pub fn wrgsbase_Register64Bit(&mut self, arg0: Register64Bit)

Load the GS base address with the 64-bit value in the source register.

pub fn xabort_Immediate8Bit(&mut self, arg0: Immediate8Bit)

Causes a Restricted Transactional Memory (RTM) abort if executing in a Restricted Transactional Memory (RTM) transaction.

pub fn xacquire(&mut self)

A hint used with an “XACQUIRE-enabled” instruction to start lock elision on the instruction memory operand address.

pub fn xadd_Any16BitMemory_Register16Bit(
    &mut self,
    arg0: Any16BitMemory,
    arg1: Register16Bit
)

Exchange r16 and r/m16; load sum into r/m16.

pub fn xadd_Any32BitMemory_Register32Bit(
    &mut self,
    arg0: Any32BitMemory,
    arg1: Register32Bit
)

Exchange r32 and r/m32; load sum into r/m32.

pub fn xadd_Any64BitMemory_Register64Bit(
    &mut self,
    arg0: Any64BitMemory,
    arg1: Register64Bit
)

Exchange r64 and r/m64; load sum into r/m64.

pub fn xadd_Any8BitMemory_Register8Bit(
    &mut self,
    arg0: Any8BitMemory,
    arg1: Register8Bit
)

Exchange r8 and r/m8; load sum into r/m8.

pub fn xadd_Any8BitMemory_RegisterHigh8BitsOf16Bits(
    &mut self,
    arg0: Any8BitMemory,
    arg1: RegisterHigh8BitsOf16Bits
)

Exchange r8 and r/m8; load sum into r/m8.

pub fn xadd_Register16Bit_Register16Bit(
    &mut self,
    arg0: Register16Bit,
    arg1: Register16Bit
)

Exchange r16 and r/m16; load sum into r/m16.

pub fn xadd_Register32Bit_Register32Bit(
    &mut self,
    arg0: Register32Bit,
    arg1: Register32Bit
)

Exchange r32 and r/m32; load sum into r/m32.

pub fn xadd_Register64Bit_Register64Bit(
    &mut self,
    arg0: Register64Bit,
    arg1: Register64Bit
)

Exchange r64 and r/m64; load sum into r/m64.

pub fn xadd_Register8Bit_Register8Bit(
    &mut self,
    arg0: Register8Bit,
    arg1: Register8Bit
)

Exchange r8 and r/m8; load sum into r/m8.

pub fn xadd_Register8Bit_RegisterHigh8BitsOf16Bits(
    &mut self,
    arg0: Register8Bit,
    arg1: RegisterHigh8BitsOf16Bits
)

Exchange r8 and r/m8; load sum into r/m8.

pub fn xadd_RegisterHigh8BitsOf16Bits_Register8Bit(
    &mut self,
    arg0: RegisterHigh8BitsOf16Bits,
    arg1: Register8Bit
)

Exchange r8 and r/m8; load sum into r/m8.

pub fn xadd_RegisterHigh8BitsOf16Bits_RegisterHigh8BitsOf16Bits(
    &mut self,
    arg0: RegisterHigh8BitsOf16Bits,
    arg1: RegisterHigh8BitsOf16Bits
)

Exchange r8 and r/m8; load sum into r/m8.

pub fn xbegin_Label(&mut self, arg0: Label)

Specifies the start of an Restricted Transactional Memory (RTM) code region.

Provides a 32-bit relative offset to compute the address of the fallback instruction address at which execution resumes following an Restricted Transactional Memory (RTM) abort.

pub fn xbegin_RelativeAddress32Bit(&mut self, arg0: RelativeAddress32Bit)

Specifies the start of an Restricted Transactional Memory (RTM) code region.

Provides a 32-bit relative offset to compute the address of the fallback instruction address at which execution resumes following an Restricted Transactional Memory (RTM) abort.

pub fn xchg_AX_Register16Bit(&mut self, arg1: Register16Bit)

Exchange r16 with AX.

pub fn xchg_EAX_Register32Bit(&mut self, arg1: Register32Bit)

Exchange r32 with EAX.

pub fn xchg_Any16BitMemory_Register16Bit(
    &mut self,
    arg0: Any16BitMemory,
    arg1: Register16Bit
)

Exchange r16 with word from r/m16.

pub fn xchg_Any32BitMemory_Register32Bit(
    &mut self,
    arg0: Any32BitMemory,
    arg1: Register32Bit
)

Exchange r32 with doubleword from r/m32.

pub fn xchg_Any64BitMemory_Register64Bit(
    &mut self,
    arg0: Any64BitMemory,
    arg1: Register64Bit
)

Exchange r64 with quadword from r/m64.

pub fn xchg_Any8BitMemory_Register8Bit(
    &mut self,
    arg0: Any8BitMemory,
    arg1: Register8Bit
)

Exchange r8 (byte register) with byte from r/m8.

pub fn xchg_Any8BitMemory_RegisterHigh8BitsOf16Bits(
    &mut self,
    arg0: Any8BitMemory,
    arg1: RegisterHigh8BitsOf16Bits
)

Exchange r8 (byte register) with byte from r/m8.

pub fn xchg_Register16Bit_AX(&mut self, arg0: Register16Bit)

Exchange AX with r16.

pub fn xchg_Register16Bit_Any16BitMemory(
    &mut self,
    arg0: Register16Bit,
    arg1: Any16BitMemory
)

Exchange word from r/m16 with r16.

pub fn xchg_Register16Bit_Register16Bit(
    &mut self,
    arg0: Register16Bit,
    arg1: Register16Bit
)

Exchange r16 with word from r/m16.

pub fn xchg_Register16Bit_Register16Bit_1(
    &mut self,
    arg0: Register16Bit,
    arg1: Register16Bit
)

Exchange word from r/m16 with r16.

pub fn xchg_Register32Bit_EAX(&mut self, arg0: Register32Bit)

Exchange EAX with r32.

pub fn xchg_Register32Bit_Any32BitMemory(
    &mut self,
    arg0: Register32Bit,
    arg1: Any32BitMemory
)

Exchange doubleword from r/m32 with r32.

pub fn xchg_Register32Bit_Register32Bit(
    &mut self,
    arg0: Register32Bit,
    arg1: Register32Bit
)

Exchange r32 with doubleword from r/m32.

pub fn xchg_Register32Bit_Register32Bit_1(
    &mut self,
    arg0: Register32Bit,
    arg1: Register32Bit
)

Exchange doubleword from r/m32 with r32.

pub fn xchg_Register64Bit_Any64BitMemory(
    &mut self,
    arg0: Register64Bit,
    arg1: Any64BitMemory
)

Exchange quadword from r/m64 with r64.

pub fn xchg_Register64Bit_Register64Bit(
    &mut self,
    arg0: Register64Bit,
    arg1: Register64Bit
)

Exchange r64 with quadword from r/m64.

pub fn xchg_Register64Bit_Register64Bit_1(
    &mut self,
    arg0: Register64Bit,
    arg1: Register64Bit
)

Exchange quadword from r/m64 with r64.

pub fn xchg_Register64Bit_RAX(&mut self, arg0: Register64Bit)

Exchange RAX with r64.

pub fn xchg_Register8Bit_Any8BitMemory(
    &mut self,
    arg0: Register8Bit,
    arg1: Any8BitMemory
)

Exchange byte from r/m8 with r8.

pub fn xchg_Register8Bit_Register8Bit(
    &mut self,
    arg0: Register8Bit,
    arg1: Register8Bit
)

Exchange r8 (byte register) with byte from r/m8.

pub fn xchg_Register8Bit_Register8Bit_1(
    &mut self,
    arg0: Register8Bit,
    arg1: Register8Bit
)

Exchange byte from r/m8 with r8 (alternate form).

pub fn xchg_Register8Bit_RegisterHigh8BitsOf16Bits(
    &mut self,
    arg0: Register8Bit,
    arg1: RegisterHigh8BitsOf16Bits
)

Exchange r8 (byte register) with byte from r/m8.

pub fn xchg_Register8Bit_RegisterHigh8BitsOf16Bits_1(
    &mut self,
    arg0: Register8Bit,
    arg1: RegisterHigh8BitsOf16Bits
)

Exchange byte from r/m8 with r8 (alternate form).

pub fn xchg_RAX_Register64Bit(&mut self, arg1: Register64Bit)

Exchange r64 with RAX.

pub fn xchg_RegisterHigh8BitsOf16Bits_Any8BitMemory(
    &mut self,
    arg0: RegisterHigh8BitsOf16Bits,
    arg1: Any8BitMemory
)

Exchange byte from r/m8 with r8.

pub fn xchg_RegisterHigh8BitsOf16Bits_Register8Bit(
    &mut self,
    arg0: RegisterHigh8BitsOf16Bits,
    arg1: Register8Bit
)

Exchange r8 (byte register) with byte from r/m8.

pub fn xchg_RegisterHigh8BitsOf16Bits_Register8Bit_1(
    &mut self,
    arg0: RegisterHigh8BitsOf16Bits,
    arg1: Register8Bit
)

Exchange byte from r/m8 with r8 (alternate form).

pub fn xchg_RegisterHigh8BitsOf16Bits_RegisterHigh8BitsOf16Bits(
    &mut self,
    arg0: RegisterHigh8BitsOf16Bits,
    arg1: RegisterHigh8BitsOf16Bits
)

Exchange r8 (byte register) with byte from r/m8.

pub fn xchg_RegisterHigh8BitsOf16Bits_RegisterHigh8BitsOf16Bits_1(
    &mut self,
    arg0: RegisterHigh8BitsOf16Bits,
    arg1: RegisterHigh8BitsOf16Bits
)

Exchange byte from r/m8 with r8 (alternate form).

pub fn xend(&mut self)

Specifies the end of an Restricted Transactional Memory (RTM) code region.

pub fn xgetbv(&mut self)

Reads an XCR specified by ECX into EDX:EAX.

pub fn xlat_Any8BitMemory(
    &mut self,
    arg0: Option<SegmentRegister>,
    address_override_for_32_bit: bool
)

Set AL to memory byte DS:[(E)BX + unsigned AL].

pub fn xlatb(&mut self)

Set AL to memory byte DS:[(E)BX + unsigned AL].

pub fn xlatb_1(&mut self)

Set AL to memory byte [RBX + unsigned AL].

pub fn xor_AL_Immediate8Bit(&mut self, arg1: Immediate8Bit)

AL XOR imm8.

pub fn xor_AX_Immediate16Bit(&mut self, arg1: Immediate16Bit)

AX XOR imm16.

pub fn xor_EAX_Immediate32Bit(&mut self, arg1: Immediate32Bit)

EAX XOR imm32.

pub fn xor_Any16BitMemory_Immediate16Bit(
    &mut self,
    arg0: Any16BitMemory,
    arg1: Immediate16Bit
)

r/m16 XOR imm16.

pub fn xor_Any16BitMemory_Immediate8Bit(
    &mut self,
    arg0: Any16BitMemory,
    arg1: Immediate8Bit
)

r/m16 XOR imm8 (sign-extended).

pub fn xor_Any16BitMemory_Register16Bit(
    &mut self,
    arg0: Any16BitMemory,
    arg1: Register16Bit
)

r/m16 XOR r16.

pub fn xor_Any32BitMemory_Immediate32Bit(
    &mut self,
    arg0: Any32BitMemory,
    arg1: Immediate32Bit
)

r/m32 XOR imm32.

pub fn xor_Any32BitMemory_Immediate8Bit(
    &mut self,
    arg0: Any32BitMemory,
    arg1: Immediate8Bit
)

r/m32 XOR imm8 (sign-extended).

pub fn xor_Any32BitMemory_Register32Bit(
    &mut self,
    arg0: Any32BitMemory,
    arg1: Register32Bit
)

r/m32 XOR r32.

pub fn xor_Any64BitMemory_Immediate32Bit(
    &mut self,
    arg0: Any64BitMemory,
    arg1: Immediate32Bit
)

r/m64 XOR imm32 (sign-extended).

pub fn xor_Any64BitMemory_Immediate8Bit(
    &mut self,
    arg0: Any64BitMemory,
    arg1: Immediate8Bit
)

r/m64 XOR imm8 (sign-extended).

pub fn xor_Any64BitMemory_Register64Bit(
    &mut self,
    arg0: Any64BitMemory,
    arg1: Register64Bit
)

r/m64 XOR r64.

pub fn xor_Any8BitMemory_Immediate8Bit(
    &mut self,
    arg0: Any8BitMemory,
    arg1: Immediate8Bit
)

r/m8 XOR imm8.

pub fn xor_Any8BitMemory_Register8Bit(
    &mut self,
    arg0: Any8BitMemory,
    arg1: Register8Bit
)

r/m8 XOR r8.

pub fn xor_Any8BitMemory_RegisterHigh8BitsOf16Bits(
    &mut self,
    arg0: Any8BitMemory,
    arg1: RegisterHigh8BitsOf16Bits
)

r/m8 XOR r8.

pub fn xor_Register16Bit_Immediate16Bit(
    &mut self,
    arg0: Register16Bit,
    arg1: Immediate16Bit
)

r/m16 XOR imm16.

pub fn xor_Register16Bit_Immediate8Bit(
    &mut self,
    arg0: Register16Bit,
    arg1: Immediate8Bit
)

r/m16 XOR imm8 (sign-extended).

pub fn xor_Register16Bit_Any16BitMemory(
    &mut self,
    arg0: Register16Bit,
    arg1: Any16BitMemory
)

r16 XOR r/m16.

pub fn xor_Register16Bit_Register16Bit(
    &mut self,
    arg0: Register16Bit,
    arg1: Register16Bit
)

r/m16 XOR r16.

pub fn xor_Register16Bit_Register16Bit_1(
    &mut self,
    arg0: Register16Bit,
    arg1: Register16Bit
)

r16 XOR r/m16.

pub fn xor_Register32Bit_Immediate32Bit(
    &mut self,
    arg0: Register32Bit,
    arg1: Immediate32Bit
)

r/m32 XOR imm32.

pub fn xor_Register32Bit_Immediate8Bit(
    &mut self,
    arg0: Register32Bit,
    arg1: Immediate8Bit
)

r/m32 XOR imm8 (sign-extended).

pub fn xor_Register32Bit_Any32BitMemory(
    &mut self,
    arg0: Register32Bit,
    arg1: Any32BitMemory
)

r32 XOR r/m32.

pub fn xor_Register32Bit_Register32Bit(
    &mut self,
    arg0: Register32Bit,
    arg1: Register32Bit
)

r/m32 XOR r32.

pub fn xor_Register32Bit_Register32Bit_1(
    &mut self,
    arg0: Register32Bit,
    arg1: Register32Bit
)

r32 XOR r/m32.

pub fn xor_Register64Bit_Immediate32Bit(
    &mut self,
    arg0: Register64Bit,
    arg1: Immediate32Bit
)

r/m64 XOR imm32 (sign-extended).

pub fn xor_Register64Bit_Immediate8Bit(
    &mut self,
    arg0: Register64Bit,
    arg1: Immediate8Bit
)

r/m64 XOR imm8 (sign-extended).

pub fn xor_Register64Bit_Any64BitMemory(
    &mut self,
    arg0: Register64Bit,
    arg1: Any64BitMemory
)

r64 XOR r/m64.

pub fn xor_Register64Bit_Register64Bit(
    &mut self,
    arg0: Register64Bit,
    arg1: Register64Bit
)

r/m64 XOR r64.

pub fn xor_Register64Bit_Register64Bit_1(
    &mut self,
    arg0: Register64Bit,
    arg1: Register64Bit
)

r64 XOR r/m64.

pub fn xor_Register8Bit_Immediate8Bit(
    &mut self,
    arg0: Register8Bit,
    arg1: Immediate8Bit
)

r/m8 XOR imm8.

pub fn xor_Register8Bit_Any8BitMemory(
    &mut self,
    arg0: Register8Bit,
    arg1: Any8BitMemory
)

r8 XOR r/m8.

pub fn xor_Register8Bit_Register8Bit(
    &mut self,
    arg0: Register8Bit,
    arg1: Register8Bit
)

r/m8 XOR r8.

pub fn xor_Register8Bit_Register8Bit_1(
    &mut self,
    arg0: Register8Bit,
    arg1: Register8Bit
)

r8 XOR r/m8.

pub fn xor_Register8Bit_RegisterHigh8BitsOf16Bits(
    &mut self,
    arg0: Register8Bit,
    arg1: RegisterHigh8BitsOf16Bits
)

r/m8 XOR r8.

pub fn xor_Register8Bit_RegisterHigh8BitsOf16Bits_1(
    &mut self,
    arg0: Register8Bit,
    arg1: RegisterHigh8BitsOf16Bits
)

r8 XOR r/m8.

pub fn xor_RAX_Immediate32Bit(&mut self, arg1: Immediate32Bit)

RAX XOR imm32 (sign-extended).

pub fn xor_RegisterHigh8BitsOf16Bits_Immediate8Bit(
    &mut self,
    arg0: RegisterHigh8BitsOf16Bits,
    arg1: Immediate8Bit
)

r/m8 XOR imm8.

pub fn xor_RegisterHigh8BitsOf16Bits_Any8BitMemory(
    &mut self,
    arg0: RegisterHigh8BitsOf16Bits,
    arg1: Any8BitMemory
)

r8 XOR r/m8.

pub fn xor_RegisterHigh8BitsOf16Bits_Register8Bit(
    &mut self,
    arg0: RegisterHigh8BitsOf16Bits,
    arg1: Register8Bit
)

r/m8 XOR r8.

pub fn xor_RegisterHigh8BitsOf16Bits_Register8Bit_1(
    &mut self,
    arg0: RegisterHigh8BitsOf16Bits,
    arg1: Register8Bit
)

r8 XOR r/m8.

pub fn xor_RegisterHigh8BitsOf16Bits_RegisterHigh8BitsOf16Bits(
    &mut self,
    arg0: RegisterHigh8BitsOf16Bits,
    arg1: RegisterHigh8BitsOf16Bits
)

r/m8 XOR r8.

pub fn xor_RegisterHigh8BitsOf16Bits_RegisterHigh8BitsOf16Bits_1(
    &mut self,
    arg0: RegisterHigh8BitsOf16Bits,
    arg1: RegisterHigh8BitsOf16Bits
)

r8 XOR r/m8.

pub fn xorpd_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Bitwise exclusive-OR of xmm2/m128 and xmm1.

pub fn xorpd_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Bitwise exclusive-OR of xmm2/m128 and xmm1.

pub fn xorps_XMMRegister_Any128BitMemory(
    &mut self,
    arg0: XMMRegister,
    arg1: Any128BitMemory
)

Bitwise exclusive-OR of xmm2/m128 and xmm1.

pub fn xorps_XMMRegister_XMMRegister(
    &mut self,
    arg0: XMMRegister,
    arg1: XMMRegister
)

Bitwise exclusive-OR of xmm2/m128 and xmm1.

pub fn xrelease(&mut self)

A hint used with an “XRELEASE-enabled” instruction to end lock elision on the instruction memory operand address.

pub fn xrstor_Any16BitMemory(&mut self, arg0: Any16BitMemory)

Restore processor extended states from memory.

The states are specified by EDX:EAX.

pub fn xrstor_Any32BitMemory(&mut self, arg0: Any32BitMemory)

Restore processor extended states from memory.

The states are specified by EDX:EAX.

pub fn xrstor_Any64BitMemory(&mut self, arg0: Any64BitMemory)

Restore processor extended states from memory.

The states are specified by EDX:EAX.

pub fn xrstor64_Any16BitMemory(&mut self, arg0: Any16BitMemory)

Restore processor extended states from memory.

The states are specified by EDX:EAX.

pub fn xrstor64_Any32BitMemory(&mut self, arg0: Any32BitMemory)

Restore processor extended states from memory.

The states are specified by EDX:EAX.

pub fn xrstor64_Any64BitMemory(&mut self, arg0: Any64BitMemory)

Restore processor extended states from memory.

The states are specified by EDX:EAX.

pub fn xsave_Any16BitMemory(&mut self, arg0: Any16BitMemory)

Save processor extended states to memory.

The states are specified by EDX:EAX.

pub fn xsave_Any32BitMemory(&mut self, arg0: Any32BitMemory)

Save processor extended states to memory.

The states are specified by EDX:EAX.

pub fn xsave_Any64BitMemory(&mut self, arg0: Any64BitMemory)

Save processor extended states to memory.

The states are specified by EDX:EAX.

pub fn xsave64_Any16BitMemory(&mut self, arg0: Any16BitMemory)

Save processor extended states to memory.

The states are specified by EDX:EAX.

pub fn xsave64_Any32BitMemory(&mut self, arg0: Any32BitMemory)

Save processor extended states to memory.

The states are specified by EDX:EAX.

pub fn xsave64_Any64BitMemory(&mut self, arg0: Any64BitMemory)

Save processor extended states to memory.

The states are specified by EDX:EAX.

pub fn xsaveopt_Any16BitMemory(&mut self, arg0: Any16BitMemory)

Save processor extended states specified in EDX:EAX to memory, optimizing the state save operation if possible.

pub fn xsaveopt_Any32BitMemory(&mut self, arg0: Any32BitMemory)

Save processor extended states specified in EDX:EAX to memory, optimizing the state save operation if possible.

pub fn xsaveopt_Any64BitMemory(&mut self, arg0: Any64BitMemory)

Save processor extended states specified in EDX:EAX to memory, optimizing the state save operation if possible.

pub fn xsaveopt64_Any16BitMemory(&mut self, arg0: Any16BitMemory)

Save processor extended states specified in EDX:EAX to memory, optimizing the state save operation if possible.

pub fn xsaveopt64_Any32BitMemory(&mut self, arg0: Any32BitMemory)

Save processor extended states specified in EDX:EAX to memory, optimizing the state save operation if possible.

pub fn xsaveopt64_Any64BitMemory(&mut self, arg0: Any64BitMemory)

Save processor extended states specified in EDX:EAX to memory, optimizing the state save operation if possible.

pub fn xtest(&mut self)

Test if executing in a transactional region.

Trait Implementations

impl<'a> Debug for InstructionStream<'a>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.