// SPDX-License-Identifier: MIT
// Copyright (C) 2018-present iced project and contributors

// ⚠️This file was generated by GENERATOR!🦹‍♂️

package com.github.icedland.iced.x86.asm;

import org.junit.jupiter.api.Test;

import com.github.icedland.iced.x86.*;
import static com.github.icedland.iced.x86.asm.AsmRegisters.*;

@SuppressWarnings("cast")
final class CodeAssembler32GenRTests extends CodeAssemblerTestsBase {
	CodeAssembler32GenRTests() {
		super(32);
	}

	@Test
	void rcl_r8_r8() {
		testAssembler(c -> c.rcl(dl, cl), Instruction.create(Code.RCL_RM8_CL, ICRegisters.dl, ICRegisters.cl));
	}

	@Test
	void rcl_r16_r8() {
		testAssembler(c -> c.rcl(dx, cl), Instruction.create(Code.RCL_RM16_CL, ICRegisters.dx, ICRegisters.cl));
	}

	@Test
	void rcl_r32_r8() {
		testAssembler(c -> c.rcl(edx, cl), Instruction.create(Code.RCL_RM32_CL, ICRegisters.edx, ICRegisters.cl));
	}

	@Test
	void rcl_m_r8() {
		{ /* if (dst.size == MemoryOperandSize.QWORD) */
			// Skipping RCL_RM64_CL - Not supported by current bitness
		} /* else */ { /* if (dst.size == MemoryOperandSize.DWORD) */
			testAssembler(c -> c.rcl(dword_ptr(0x0L).base(edx), cl), Instruction.create(Code.RCL_RM32_CL, new MemoryOperand(ICRegisters.edx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), ICRegisters.cl));
		} /* else */ { /* if (dst.size == MemoryOperandSize.WORD) */
			testAssembler(c -> c.rcl(word_ptr(0x0L).base(edx), cl), Instruction.create(Code.RCL_RM16_CL, new MemoryOperand(ICRegisters.edx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), ICRegisters.cl));
		} /* else */ { /* if (dst.size == MemoryOperandSize.BYTE) */
			testAssembler(c -> c.rcl(byte_ptr(0x0L).base(edx), cl), Instruction.create(Code.RCL_RM8_CL, new MemoryOperand(ICRegisters.edx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), ICRegisters.cl));
		}
		{
			assertInvalid(() -> {
				testAssembler(c -> c.rcl(zmmword_ptr(0x0L).base(edx), cl), Instruction.create(Code.RCL_RM8_CL, new MemoryOperand(ICRegisters.edx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), ICRegisters.cl));
			});
		}
	}

	@Test
	void rcl_r8_i() {
		{ /* if (imm == 1) */
			testAssembler(c -> c.rcl(dl, 1), Instruction.create(Code.RCL_RM8_1, ICRegisters.dl, 1));
		} /* else */ testAssembler(c -> c.rcl(dl, 2), Instruction.create(Code.RCL_RM8_IMM8, ICRegisters.dl, 2));
	}

	@Test
	void rcl_r16_i() {
		{ /* if (imm == 1) */
			testAssembler(c -> c.rcl(dx, 1), Instruction.create(Code.RCL_RM16_1, ICRegisters.dx, 1));
		} /* else */ testAssembler(c -> c.rcl(dx, 2), Instruction.create(Code.RCL_RM16_IMM8, ICRegisters.dx, 2));
	}

	@Test
	void rcl_r32_i() {
		{ /* if (imm == 1) */
			testAssembler(c -> c.rcl(edx, 1), Instruction.create(Code.RCL_RM32_1, ICRegisters.edx, 1));
		} /* else */ testAssembler(c -> c.rcl(edx, 2), Instruction.create(Code.RCL_RM32_IMM8, ICRegisters.edx, 2));
	}

	@Test
	void rcl_m_i() {
		{ /* if (imm == 1) */
			{ /* if (dst.size == MemoryOperandSize.QWORD) */
				// Skipping RCL_RM64_1 - Not supported by current bitness
			} /* else */ { /* if (dst.size == MemoryOperandSize.DWORD) */
				testAssembler(c -> c.rcl(dword_ptr(0x0L).base(edx), 1), Instruction.create(Code.RCL_RM32_1, new MemoryOperand(ICRegisters.edx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), 1));
			} /* else */ { /* if (dst.size == MemoryOperandSize.WORD) */
				testAssembler(c -> c.rcl(word_ptr(0x0L).base(edx), 1), Instruction.create(Code.RCL_RM16_1, new MemoryOperand(ICRegisters.edx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), 1));
			} /* else */ { /* if (dst.size == MemoryOperandSize.BYTE) */
				testAssembler(c -> c.rcl(byte_ptr(0x0L).base(edx), 1), Instruction.create(Code.RCL_RM8_1, new MemoryOperand(ICRegisters.edx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), 1));
			}
			{
				assertInvalid(() -> {
					testAssembler(c -> c.rcl(zmmword_ptr(0x0L).base(edx), 1), Instruction.create(Code.RCL_RM8_1, new MemoryOperand(ICRegisters.edx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), 1));
				});
			}
		} /* else */ { /* if (dst.size == MemoryOperandSize.QWORD) */
			// Skipping RCL_RM64_IMM8 - Not supported by current bitness
		} /* else */ { /* if (dst.size == MemoryOperandSize.DWORD) */
			testAssembler(c -> c.rcl(dword_ptr(0x0L).base(edx), 2), Instruction.create(Code.RCL_RM32_IMM8, new MemoryOperand(ICRegisters.edx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), 2));
		} /* else */ { /* if (dst.size == MemoryOperandSize.WORD) */
			testAssembler(c -> c.rcl(word_ptr(0x0L).base(edx), 2), Instruction.create(Code.RCL_RM16_IMM8, new MemoryOperand(ICRegisters.edx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), 2));
		} /* else */ { /* if (dst.size == MemoryOperandSize.BYTE) */
			testAssembler(c -> c.rcl(byte_ptr(0x0L).base(edx), 2), Instruction.create(Code.RCL_RM8_IMM8, new MemoryOperand(ICRegisters.edx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), 2));
		}
		{
			assertInvalid(() -> {
				testAssembler(c -> c.rcl(zmmword_ptr(0x0L).base(edx), 2), Instruction.create(Code.RCL_RM8_IMM8, new MemoryOperand(ICRegisters.edx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), 2));
			});
		}
	}

	@Test
	void rcpps_xmm_xmm() {
		testAssembler(c -> c.rcpps(xmm2, xmm3), Instruction.create(Code.RCPPS_XMM_XMMM128, ICRegisters.xmm2, ICRegisters.xmm3));
	}

	@Test
	void rcpps_xmm_m() {
		testAssembler(c -> c.rcpps(xmm2, xmmword_ptr(0x0L).base(ecx)), Instruction.create(Code.RCPPS_XMM_XMMM128, ICRegisters.xmm2, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE)));
	}

	@Test
	void rcpss_xmm_xmm() {
		testAssembler(c -> c.rcpss(xmm2, xmm3), Instruction.create(Code.RCPSS_XMM_XMMM32, ICRegisters.xmm2, ICRegisters.xmm3));
	}

	@Test
	void rcpss_xmm_m() {
		testAssembler(c -> c.rcpss(xmm2, xmmword_ptr(0x0L).base(ecx)), Instruction.create(Code.RCPSS_XMM_XMMM32, ICRegisters.xmm2, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE)));
	}

	@Test
	void rcr_r8_r8() {
		testAssembler(c -> c.rcr(dl, cl), Instruction.create(Code.RCR_RM8_CL, ICRegisters.dl, ICRegisters.cl));
	}

	@Test
	void rcr_r16_r8() {
		testAssembler(c -> c.rcr(dx, cl), Instruction.create(Code.RCR_RM16_CL, ICRegisters.dx, ICRegisters.cl));
	}

	@Test
	void rcr_r32_r8() {
		testAssembler(c -> c.rcr(edx, cl), Instruction.create(Code.RCR_RM32_CL, ICRegisters.edx, ICRegisters.cl));
	}

	@Test
	void rcr_m_r8() {
		{ /* if (dst.size == MemoryOperandSize.QWORD) */
			// Skipping RCR_RM64_CL - Not supported by current bitness
		} /* else */ { /* if (dst.size == MemoryOperandSize.DWORD) */
			testAssembler(c -> c.rcr(dword_ptr(0x0L).base(edx), cl), Instruction.create(Code.RCR_RM32_CL, new MemoryOperand(ICRegisters.edx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), ICRegisters.cl));
		} /* else */ { /* if (dst.size == MemoryOperandSize.WORD) */
			testAssembler(c -> c.rcr(word_ptr(0x0L).base(edx), cl), Instruction.create(Code.RCR_RM16_CL, new MemoryOperand(ICRegisters.edx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), ICRegisters.cl));
		} /* else */ { /* if (dst.size == MemoryOperandSize.BYTE) */
			testAssembler(c -> c.rcr(byte_ptr(0x0L).base(edx), cl), Instruction.create(Code.RCR_RM8_CL, new MemoryOperand(ICRegisters.edx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), ICRegisters.cl));
		}
		{
			assertInvalid(() -> {
				testAssembler(c -> c.rcr(zmmword_ptr(0x0L).base(edx), cl), Instruction.create(Code.RCR_RM8_CL, new MemoryOperand(ICRegisters.edx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), ICRegisters.cl));
			});
		}
	}

	@Test
	void rcr_r8_i() {
		{ /* if (imm == 1) */
			testAssembler(c -> c.rcr(dl, 1), Instruction.create(Code.RCR_RM8_1, ICRegisters.dl, 1));
		} /* else */ testAssembler(c -> c.rcr(dl, 2), Instruction.create(Code.RCR_RM8_IMM8, ICRegisters.dl, 2));
	}

	@Test
	void rcr_r16_i() {
		{ /* if (imm == 1) */
			testAssembler(c -> c.rcr(dx, 1), Instruction.create(Code.RCR_RM16_1, ICRegisters.dx, 1));
		} /* else */ testAssembler(c -> c.rcr(dx, 2), Instruction.create(Code.RCR_RM16_IMM8, ICRegisters.dx, 2));
	}

	@Test
	void rcr_r32_i() {
		{ /* if (imm == 1) */
			testAssembler(c -> c.rcr(edx, 1), Instruction.create(Code.RCR_RM32_1, ICRegisters.edx, 1));
		} /* else */ testAssembler(c -> c.rcr(edx, 2), Instruction.create(Code.RCR_RM32_IMM8, ICRegisters.edx, 2));
	}

	@Test
	void rcr_m_i() {
		{ /* if (imm == 1) */
			{ /* if (dst.size == MemoryOperandSize.QWORD) */
				// Skipping RCR_RM64_1 - Not supported by current bitness
			} /* else */ { /* if (dst.size == MemoryOperandSize.DWORD) */
				testAssembler(c -> c.rcr(dword_ptr(0x0L).base(edx), 1), Instruction.create(Code.RCR_RM32_1, new MemoryOperand(ICRegisters.edx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), 1));
			} /* else */ { /* if (dst.size == MemoryOperandSize.WORD) */
				testAssembler(c -> c.rcr(word_ptr(0x0L).base(edx), 1), Instruction.create(Code.RCR_RM16_1, new MemoryOperand(ICRegisters.edx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), 1));
			} /* else */ { /* if (dst.size == MemoryOperandSize.BYTE) */
				testAssembler(c -> c.rcr(byte_ptr(0x0L).base(edx), 1), Instruction.create(Code.RCR_RM8_1, new MemoryOperand(ICRegisters.edx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), 1));
			}
			{
				assertInvalid(() -> {
					testAssembler(c -> c.rcr(zmmword_ptr(0x0L).base(edx), 1), Instruction.create(Code.RCR_RM8_1, new MemoryOperand(ICRegisters.edx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), 1));
				});
			}
		} /* else */ { /* if (dst.size == MemoryOperandSize.QWORD) */
			// Skipping RCR_RM64_IMM8 - Not supported by current bitness
		} /* else */ { /* if (dst.size == MemoryOperandSize.DWORD) */
			testAssembler(c -> c.rcr(dword_ptr(0x0L).base(edx), 2), Instruction.create(Code.RCR_RM32_IMM8, new MemoryOperand(ICRegisters.edx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), 2));
		} /* else */ { /* if (dst.size == MemoryOperandSize.WORD) */
			testAssembler(c -> c.rcr(word_ptr(0x0L).base(edx), 2), Instruction.create(Code.RCR_RM16_IMM8, new MemoryOperand(ICRegisters.edx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), 2));
		} /* else */ { /* if (dst.size == MemoryOperandSize.BYTE) */
			testAssembler(c -> c.rcr(byte_ptr(0x0L).base(edx), 2), Instruction.create(Code.RCR_RM8_IMM8, new MemoryOperand(ICRegisters.edx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), 2));
		}
		{
			assertInvalid(() -> {
				testAssembler(c -> c.rcr(zmmword_ptr(0x0L).base(edx), 2), Instruction.create(Code.RCR_RM8_IMM8, new MemoryOperand(ICRegisters.edx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), 2));
			});
		}
	}

	@Test
	void rdm() {
		testAssembler(c -> c.rdm(), Instruction.create(Code.RDM), TestInstrFlags.NONE, com.github.icedland.iced.x86.dec.DecoderOptions.CYRIX_DMI);
	}

	@Test
	void rdmsr() {
		testAssembler(c -> c.rdmsr(), Instruction.create(Code.RDMSR));
	}

	@Test
	void rdpid_r32() {
		testAssembler(c -> c.rdpid(edx), Instruction.create(Code.RDPID_R32, ICRegisters.edx));
	}

	@Test
	void rdpkru() {
		testAssembler(c -> c.rdpkru(), Instruction.create(Code.RDPKRU));
	}

	@Test
	void rdpmc() {
		testAssembler(c -> c.rdpmc(), Instruction.create(Code.RDPMC));
	}

	@Test
	void rdpru() {
		testAssembler(c -> c.rdpru(), Instruction.create(Code.RDPRU));
	}

	@Test
	void rdrand_r16() {
		testAssembler(c -> c.rdrand(dx), Instruction.create(Code.RDRAND_R16, ICRegisters.dx));
	}

	@Test
	void rdrand_r32() {
		testAssembler(c -> c.rdrand(edx), Instruction.create(Code.RDRAND_R32, ICRegisters.edx));
	}

	@Test
	void rdseed_r16() {
		testAssembler(c -> c.rdseed(dx), Instruction.create(Code.RDSEED_R16, ICRegisters.dx));
	}

	@Test
	void rdseed_r32() {
		testAssembler(c -> c.rdseed(edx), Instruction.create(Code.RDSEED_R32, ICRegisters.edx));
	}

	@Test
	void rdshr_r32() {
		testAssembler(c -> c.rdshr(edx), Instruction.create(Code.RDSHR_RM32, ICRegisters.edx), TestInstrFlags.NONE, com.github.icedland.iced.x86.dec.DecoderOptions.CYRIX);
	}

	@Test
	void rdshr_m() {
		testAssembler(c -> c.rdshr(dword_ptr(0x0L).base(ecx)), Instruction.create(Code.RDSHR_RM32, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE)), TestInstrFlags.NONE, com.github.icedland.iced.x86.dec.DecoderOptions.CYRIX);
	}

	@Test
	void rdsspd_r32() {
		testAssembler(c -> c.rdsspd(edx), Instruction.create(Code.RDSSPD_R32, ICRegisters.edx));
	}

	@Test
	void rdtsc() {
		testAssembler(c -> c.rdtsc(), Instruction.create(Code.RDTSC));
	}

	@Test
	void rdtscp() {
		testAssembler(c -> c.rdtscp(), Instruction.create(Code.RDTSCP));
	}

	@Test
	void rdudbg() {
		testAssembler(c -> c.rdudbg(), Instruction.create(Code.RDUDBG), TestInstrFlags.NONE, com.github.icedland.iced.x86.dec.DecoderOptions.UDBG);
	}

	@Test
	void reservednop_0f0d_r16_r16() {
		testAssembler(c -> c.reservednop_0f0d(dx, bx), Instruction.create(Code.RESERVEDNOP_RM16_R16_0F0D, ICRegisters.dx, ICRegisters.bx), TestInstrFlags.NONE, com.github.icedland.iced.x86.dec.DecoderOptions.FORCE_RESERVED_NOP);
	}

	@Test
	void reservednop_0f0d_m_r16() {
		testAssembler(c -> c.reservednop_0f0d(word_ptr(0x0L).base(ecx), bx), Instruction.create(Code.RESERVEDNOP_RM16_R16_0F0D, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), ICRegisters.bx), TestInstrFlags.NONE, com.github.icedland.iced.x86.dec.DecoderOptions.FORCE_RESERVED_NOP);
	}

	@Test
	void reservednop_0f0d_r32_r32() {
		testAssembler(c -> c.reservednop_0f0d(edx, ebx), Instruction.create(Code.RESERVEDNOP_RM32_R32_0F0D, ICRegisters.edx, ICRegisters.ebx), TestInstrFlags.NONE, com.github.icedland.iced.x86.dec.DecoderOptions.FORCE_RESERVED_NOP);
	}

	@Test
	void reservednop_0f0d_m_r32() {
		testAssembler(c -> c.reservednop_0f0d(dword_ptr(0x0L).base(ecx), ebx), Instruction.create(Code.RESERVEDNOP_RM32_R32_0F0D, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), ICRegisters.ebx), TestInstrFlags.NONE, com.github.icedland.iced.x86.dec.DecoderOptions.FORCE_RESERVED_NOP);
	}

	@Test
	void reservednop_0f18_r16_r16() {
		testAssembler(c -> c.reservednop_0f18(dx, bx), Instruction.create(Code.RESERVEDNOP_RM16_R16_0F18, ICRegisters.dx, ICRegisters.bx), TestInstrFlags.NONE, com.github.icedland.iced.x86.dec.DecoderOptions.FORCE_RESERVED_NOP);
	}

	@Test
	void reservednop_0f18_m_r16() {
		testAssembler(c -> c.reservednop_0f18(word_ptr(0x0L).base(ecx), bx), Instruction.create(Code.RESERVEDNOP_RM16_R16_0F18, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), ICRegisters.bx), TestInstrFlags.NONE, com.github.icedland.iced.x86.dec.DecoderOptions.FORCE_RESERVED_NOP);
	}

	@Test
	void reservednop_0f18_r32_r32() {
		testAssembler(c -> c.reservednop_0f18(edx, ebx), Instruction.create(Code.RESERVEDNOP_RM32_R32_0F18, ICRegisters.edx, ICRegisters.ebx), TestInstrFlags.NONE, com.github.icedland.iced.x86.dec.DecoderOptions.FORCE_RESERVED_NOP);
	}

	@Test
	void reservednop_0f18_m_r32() {
		testAssembler(c -> c.reservednop_0f18(dword_ptr(0x0L).base(ecx), ebx), Instruction.create(Code.RESERVEDNOP_RM32_R32_0F18, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), ICRegisters.ebx), TestInstrFlags.NONE, com.github.icedland.iced.x86.dec.DecoderOptions.FORCE_RESERVED_NOP);
	}

	@Test
	void reservednop_0f19_r16_r16() {
		testAssembler(c -> c.reservednop_0f19(dx, bx), Instruction.create(Code.RESERVEDNOP_RM16_R16_0F19, ICRegisters.dx, ICRegisters.bx), TestInstrFlags.NONE, com.github.icedland.iced.x86.dec.DecoderOptions.FORCE_RESERVED_NOP);
	}

	@Test
	void reservednop_0f19_m_r16() {
		testAssembler(c -> c.reservednop_0f19(word_ptr(0x0L).base(ecx), bx), Instruction.create(Code.RESERVEDNOP_RM16_R16_0F19, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), ICRegisters.bx), TestInstrFlags.NONE, com.github.icedland.iced.x86.dec.DecoderOptions.FORCE_RESERVED_NOP);
	}

	@Test
	void reservednop_0f19_r32_r32() {
		testAssembler(c -> c.reservednop_0f19(edx, ebx), Instruction.create(Code.RESERVEDNOP_RM32_R32_0F19, ICRegisters.edx, ICRegisters.ebx), TestInstrFlags.NONE, com.github.icedland.iced.x86.dec.DecoderOptions.FORCE_RESERVED_NOP);
	}

	@Test
	void reservednop_0f19_m_r32() {
		testAssembler(c -> c.reservednop_0f19(dword_ptr(0x0L).base(ecx), ebx), Instruction.create(Code.RESERVEDNOP_RM32_R32_0F19, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), ICRegisters.ebx), TestInstrFlags.NONE, com.github.icedland.iced.x86.dec.DecoderOptions.FORCE_RESERVED_NOP);
	}

	@Test
	void reservednop_0f1a_r16_r16() {
		testAssembler(c -> c.reservednop_0f1a(dx, bx), Instruction.create(Code.RESERVEDNOP_RM16_R16_0F1A, ICRegisters.dx, ICRegisters.bx), TestInstrFlags.NONE, com.github.icedland.iced.x86.dec.DecoderOptions.FORCE_RESERVED_NOP);
	}

	@Test
	void reservednop_0f1a_m_r16() {
		testAssembler(c -> c.reservednop_0f1a(word_ptr(0x0L).base(ecx), bx), Instruction.create(Code.RESERVEDNOP_RM16_R16_0F1A, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), ICRegisters.bx), TestInstrFlags.NONE, com.github.icedland.iced.x86.dec.DecoderOptions.FORCE_RESERVED_NOP);
	}

	@Test
	void reservednop_0f1a_r32_r32() {
		testAssembler(c -> c.reservednop_0f1a(edx, ebx), Instruction.create(Code.RESERVEDNOP_RM32_R32_0F1A, ICRegisters.edx, ICRegisters.ebx), TestInstrFlags.NONE, com.github.icedland.iced.x86.dec.DecoderOptions.FORCE_RESERVED_NOP);
	}

	@Test
	void reservednop_0f1a_m_r32() {
		testAssembler(c -> c.reservednop_0f1a(dword_ptr(0x0L).base(ecx), ebx), Instruction.create(Code.RESERVEDNOP_RM32_R32_0F1A, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), ICRegisters.ebx), TestInstrFlags.NONE, com.github.icedland.iced.x86.dec.DecoderOptions.FORCE_RESERVED_NOP);
	}

	@Test
	void reservednop_0f1b_r16_r16() {
		testAssembler(c -> c.reservednop_0f1b(dx, bx), Instruction.create(Code.RESERVEDNOP_RM16_R16_0F1B, ICRegisters.dx, ICRegisters.bx), TestInstrFlags.NONE, com.github.icedland.iced.x86.dec.DecoderOptions.FORCE_RESERVED_NOP);
	}

	@Test
	void reservednop_0f1b_m_r16() {
		testAssembler(c -> c.reservednop_0f1b(word_ptr(0x0L).base(ecx), bx), Instruction.create(Code.RESERVEDNOP_RM16_R16_0F1B, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), ICRegisters.bx), TestInstrFlags.NONE, com.github.icedland.iced.x86.dec.DecoderOptions.FORCE_RESERVED_NOP);
	}

	@Test
	void reservednop_0f1b_r32_r32() {
		testAssembler(c -> c.reservednop_0f1b(edx, ebx), Instruction.create(Code.RESERVEDNOP_RM32_R32_0F1B, ICRegisters.edx, ICRegisters.ebx), TestInstrFlags.NONE, com.github.icedland.iced.x86.dec.DecoderOptions.FORCE_RESERVED_NOP);
	}

	@Test
	void reservednop_0f1b_m_r32() {
		testAssembler(c -> c.reservednop_0f1b(dword_ptr(0x0L).base(ecx), ebx), Instruction.create(Code.RESERVEDNOP_RM32_R32_0F1B, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), ICRegisters.ebx), TestInstrFlags.NONE, com.github.icedland.iced.x86.dec.DecoderOptions.FORCE_RESERVED_NOP);
	}

	@Test
	void reservednop_0f1c_r16_r16() {
		testAssembler(c -> c.reservednop_0f1c(dx, bx), Instruction.create(Code.RESERVEDNOP_RM16_R16_0F1C, ICRegisters.dx, ICRegisters.bx), TestInstrFlags.NONE, com.github.icedland.iced.x86.dec.DecoderOptions.FORCE_RESERVED_NOP);
	}

	@Test
	void reservednop_0f1c_m_r16() {
		testAssembler(c -> c.reservednop_0f1c(word_ptr(0x0L).base(ecx), bx), Instruction.create(Code.RESERVEDNOP_RM16_R16_0F1C, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), ICRegisters.bx), TestInstrFlags.NONE, com.github.icedland.iced.x86.dec.DecoderOptions.FORCE_RESERVED_NOP);
	}

	@Test
	void reservednop_0f1c_r32_r32() {
		testAssembler(c -> c.reservednop_0f1c(edx, ebx), Instruction.create(Code.RESERVEDNOP_RM32_R32_0F1C, ICRegisters.edx, ICRegisters.ebx), TestInstrFlags.NONE, com.github.icedland.iced.x86.dec.DecoderOptions.FORCE_RESERVED_NOP);
	}

	@Test
	void reservednop_0f1c_m_r32() {
		testAssembler(c -> c.reservednop_0f1c(dword_ptr(0x0L).base(ecx), ebx), Instruction.create(Code.RESERVEDNOP_RM32_R32_0F1C, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), ICRegisters.ebx), TestInstrFlags.NONE, com.github.icedland.iced.x86.dec.DecoderOptions.FORCE_RESERVED_NOP);
	}

	@Test
	void reservednop_0f1d_r16_r16() {
		testAssembler(c -> c.reservednop_0f1d(dx, bx), Instruction.create(Code.RESERVEDNOP_RM16_R16_0F1D, ICRegisters.dx, ICRegisters.bx), TestInstrFlags.NONE, com.github.icedland.iced.x86.dec.DecoderOptions.FORCE_RESERVED_NOP);
	}

	@Test
	void reservednop_0f1d_m_r16() {
		testAssembler(c -> c.reservednop_0f1d(word_ptr(0x0L).base(ecx), bx), Instruction.create(Code.RESERVEDNOP_RM16_R16_0F1D, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), ICRegisters.bx), TestInstrFlags.NONE, com.github.icedland.iced.x86.dec.DecoderOptions.FORCE_RESERVED_NOP);
	}

	@Test
	void reservednop_0f1d_r32_r32() {
		testAssembler(c -> c.reservednop_0f1d(edx, ebx), Instruction.create(Code.RESERVEDNOP_RM32_R32_0F1D, ICRegisters.edx, ICRegisters.ebx), TestInstrFlags.NONE, com.github.icedland.iced.x86.dec.DecoderOptions.FORCE_RESERVED_NOP);
	}

	@Test
	void reservednop_0f1d_m_r32() {
		testAssembler(c -> c.reservednop_0f1d(dword_ptr(0x0L).base(ecx), ebx), Instruction.create(Code.RESERVEDNOP_RM32_R32_0F1D, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), ICRegisters.ebx), TestInstrFlags.NONE, com.github.icedland.iced.x86.dec.DecoderOptions.FORCE_RESERVED_NOP);
	}

	@Test
	void reservednop_0f1e_r16_r16() {
		testAssembler(c -> c.reservednop_0f1e(dx, bx), Instruction.create(Code.RESERVEDNOP_RM16_R16_0F1E, ICRegisters.dx, ICRegisters.bx), TestInstrFlags.NONE, com.github.icedland.iced.x86.dec.DecoderOptions.FORCE_RESERVED_NOP);
	}

	@Test
	void reservednop_0f1e_m_r16() {
		testAssembler(c -> c.reservednop_0f1e(word_ptr(0x0L).base(ecx), bx), Instruction.create(Code.RESERVEDNOP_RM16_R16_0F1E, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), ICRegisters.bx), TestInstrFlags.NONE, com.github.icedland.iced.x86.dec.DecoderOptions.FORCE_RESERVED_NOP);
	}

	@Test
	void reservednop_0f1e_r32_r32() {
		testAssembler(c -> c.reservednop_0f1e(edx, ebx), Instruction.create(Code.RESERVEDNOP_RM32_R32_0F1E, ICRegisters.edx, ICRegisters.ebx), TestInstrFlags.NONE, com.github.icedland.iced.x86.dec.DecoderOptions.FORCE_RESERVED_NOP);
	}

	@Test
	void reservednop_0f1e_m_r32() {
		testAssembler(c -> c.reservednop_0f1e(dword_ptr(0x0L).base(ecx), ebx), Instruction.create(Code.RESERVEDNOP_RM32_R32_0F1E, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), ICRegisters.ebx), TestInstrFlags.NONE, com.github.icedland.iced.x86.dec.DecoderOptions.FORCE_RESERVED_NOP);
	}

	@Test
	void reservednop_0f1f_r16_r16() {
		testAssembler(c -> c.reservednop_0f1f(dx, bx), Instruction.create(Code.RESERVEDNOP_RM16_R16_0F1F, ICRegisters.dx, ICRegisters.bx), TestInstrFlags.NONE, com.github.icedland.iced.x86.dec.DecoderOptions.FORCE_RESERVED_NOP);
	}

	@Test
	void reservednop_0f1f_m_r16() {
		testAssembler(c -> c.reservednop_0f1f(word_ptr(0x0L).base(ecx), bx), Instruction.create(Code.RESERVEDNOP_RM16_R16_0F1F, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), ICRegisters.bx), TestInstrFlags.NONE, com.github.icedland.iced.x86.dec.DecoderOptions.FORCE_RESERVED_NOP);
	}

	@Test
	void reservednop_0f1f_r32_r32() {
		testAssembler(c -> c.reservednop_0f1f(edx, ebx), Instruction.create(Code.RESERVEDNOP_RM32_R32_0F1F, ICRegisters.edx, ICRegisters.ebx), TestInstrFlags.NONE, com.github.icedland.iced.x86.dec.DecoderOptions.FORCE_RESERVED_NOP);
	}

	@Test
	void reservednop_0f1f_m_r32() {
		testAssembler(c -> c.reservednop_0f1f(dword_ptr(0x0L).base(ecx), ebx), Instruction.create(Code.RESERVEDNOP_RM32_R32_0F1F, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), ICRegisters.ebx), TestInstrFlags.NONE, com.github.icedland.iced.x86.dec.DecoderOptions.FORCE_RESERVED_NOP);
	}

	@Test
	void ret() {
		{ // skip (getBitness() == 64) not supported by this CodeAssembler bitness
		} /* else */ { /* if (getBitness() >= 32) */
			testAssembler(c -> c.ret(), Instruction.create(Code.RETND));
		} /* else skip !(getBitness() >= 32) not supported by this CodeAssembler bitness */
	}

	@Test
	void ret_i() {
		{ // skip (getBitness() == 64) not supported by this CodeAssembler bitness
		} /* else */ { /* if (getBitness() >= 32) */
			testAssembler(c -> c.ret(0x40B7), Instruction.create(Code.RETND_IMM16, 0x40B7));
		} /* else skip !(getBitness() >= 32) not supported by this CodeAssembler bitness */
	}

	@Test
	void retf() {
		{ // skip (getBitness() == 64) not supported by this CodeAssembler bitness
		} /* else */ { /* if (getBitness() >= 32) */
			testAssembler(c -> c.retf(), Instruction.create(Code.RETFD));
		} /* else skip !(getBitness() >= 32) not supported by this CodeAssembler bitness */
	}

	@Test
	void retf_i() {
		{ // skip (getBitness() == 64) not supported by this CodeAssembler bitness
		} /* else */ { /* if (getBitness() >= 32) */
			testAssembler(c -> c.retf(0x40B7), Instruction.create(Code.RETFD_IMM16, 0x40B7));
		} /* else skip !(getBitness() >= 32) not supported by this CodeAssembler bitness */
	}

	@Test
	void rol_r8_r8() {
		testAssembler(c -> c.rol(dl, cl), Instruction.create(Code.ROL_RM8_CL, ICRegisters.dl, ICRegisters.cl));
	}

	@Test
	void rol_r16_r8() {
		testAssembler(c -> c.rol(dx, cl), Instruction.create(Code.ROL_RM16_CL, ICRegisters.dx, ICRegisters.cl));
	}

	@Test
	void rol_r32_r8() {
		testAssembler(c -> c.rol(edx, cl), Instruction.create(Code.ROL_RM32_CL, ICRegisters.edx, ICRegisters.cl));
	}

	@Test
	void rol_m_r8() {
		{ /* if (dst.size == MemoryOperandSize.QWORD) */
			// Skipping ROL_RM64_CL - Not supported by current bitness
		} /* else */ { /* if (dst.size == MemoryOperandSize.DWORD) */
			testAssembler(c -> c.rol(dword_ptr(0x0L).base(edx), cl), Instruction.create(Code.ROL_RM32_CL, new MemoryOperand(ICRegisters.edx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), ICRegisters.cl));
		} /* else */ { /* if (dst.size == MemoryOperandSize.WORD) */
			testAssembler(c -> c.rol(word_ptr(0x0L).base(edx), cl), Instruction.create(Code.ROL_RM16_CL, new MemoryOperand(ICRegisters.edx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), ICRegisters.cl));
		} /* else */ { /* if (dst.size == MemoryOperandSize.BYTE) */
			testAssembler(c -> c.rol(byte_ptr(0x0L).base(edx), cl), Instruction.create(Code.ROL_RM8_CL, new MemoryOperand(ICRegisters.edx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), ICRegisters.cl));
		}
		{
			assertInvalid(() -> {
				testAssembler(c -> c.rol(zmmword_ptr(0x0L).base(edx), cl), Instruction.create(Code.ROL_RM8_CL, new MemoryOperand(ICRegisters.edx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), ICRegisters.cl));
			});
		}
	}

	@Test
	void rol_r8_i() {
		{ /* if (imm == 1) */
			testAssembler(c -> c.rol(dl, 1), Instruction.create(Code.ROL_RM8_1, ICRegisters.dl, 1));
		} /* else */ testAssembler(c -> c.rol(dl, 2), Instruction.create(Code.ROL_RM8_IMM8, ICRegisters.dl, 2));
	}

	@Test
	void rol_r16_i() {
		{ /* if (imm == 1) */
			testAssembler(c -> c.rol(dx, 1), Instruction.create(Code.ROL_RM16_1, ICRegisters.dx, 1));
		} /* else */ testAssembler(c -> c.rol(dx, 2), Instruction.create(Code.ROL_RM16_IMM8, ICRegisters.dx, 2));
	}

	@Test
	void rol_r32_i() {
		{ /* if (imm == 1) */
			testAssembler(c -> c.rol(edx, 1), Instruction.create(Code.ROL_RM32_1, ICRegisters.edx, 1));
		} /* else */ testAssembler(c -> c.rol(edx, 2), Instruction.create(Code.ROL_RM32_IMM8, ICRegisters.edx, 2));
	}

	@Test
	void rol_m_i() {
		{ /* if (imm == 1) */
			{ /* if (dst.size == MemoryOperandSize.QWORD) */
				// Skipping ROL_RM64_1 - Not supported by current bitness
			} /* else */ { /* if (dst.size == MemoryOperandSize.DWORD) */
				testAssembler(c -> c.rol(dword_ptr(0x0L).base(edx), 1), Instruction.create(Code.ROL_RM32_1, new MemoryOperand(ICRegisters.edx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), 1));
			} /* else */ { /* if (dst.size == MemoryOperandSize.WORD) */
				testAssembler(c -> c.rol(word_ptr(0x0L).base(edx), 1), Instruction.create(Code.ROL_RM16_1, new MemoryOperand(ICRegisters.edx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), 1));
			} /* else */ { /* if (dst.size == MemoryOperandSize.BYTE) */
				testAssembler(c -> c.rol(byte_ptr(0x0L).base(edx), 1), Instruction.create(Code.ROL_RM8_1, new MemoryOperand(ICRegisters.edx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), 1));
			}
			{
				assertInvalid(() -> {
					testAssembler(c -> c.rol(zmmword_ptr(0x0L).base(edx), 1), Instruction.create(Code.ROL_RM8_1, new MemoryOperand(ICRegisters.edx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), 1));
				});
			}
		} /* else */ { /* if (dst.size == MemoryOperandSize.QWORD) */
			// Skipping ROL_RM64_IMM8 - Not supported by current bitness
		} /* else */ { /* if (dst.size == MemoryOperandSize.DWORD) */
			testAssembler(c -> c.rol(dword_ptr(0x0L).base(edx), 2), Instruction.create(Code.ROL_RM32_IMM8, new MemoryOperand(ICRegisters.edx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), 2));
		} /* else */ { /* if (dst.size == MemoryOperandSize.WORD) */
			testAssembler(c -> c.rol(word_ptr(0x0L).base(edx), 2), Instruction.create(Code.ROL_RM16_IMM8, new MemoryOperand(ICRegisters.edx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), 2));
		} /* else */ { /* if (dst.size == MemoryOperandSize.BYTE) */
			testAssembler(c -> c.rol(byte_ptr(0x0L).base(edx), 2), Instruction.create(Code.ROL_RM8_IMM8, new MemoryOperand(ICRegisters.edx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), 2));
		}
		{
			assertInvalid(() -> {
				testAssembler(c -> c.rol(zmmword_ptr(0x0L).base(edx), 2), Instruction.create(Code.ROL_RM8_IMM8, new MemoryOperand(ICRegisters.edx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), 2));
			});
		}
	}

	@Test
	void ror_r8_r8() {
		testAssembler(c -> c.ror(dl, cl), Instruction.create(Code.ROR_RM8_CL, ICRegisters.dl, ICRegisters.cl));
	}

	@Test
	void ror_r16_r8() {
		testAssembler(c -> c.ror(dx, cl), Instruction.create(Code.ROR_RM16_CL, ICRegisters.dx, ICRegisters.cl));
	}

	@Test
	void ror_r32_r8() {
		testAssembler(c -> c.ror(edx, cl), Instruction.create(Code.ROR_RM32_CL, ICRegisters.edx, ICRegisters.cl));
	}

	@Test
	void ror_m_r8() {
		{ /* if (dst.size == MemoryOperandSize.QWORD) */
			// Skipping ROR_RM64_CL - Not supported by current bitness
		} /* else */ { /* if (dst.size == MemoryOperandSize.DWORD) */
			testAssembler(c -> c.ror(dword_ptr(0x0L).base(edx), cl), Instruction.create(Code.ROR_RM32_CL, new MemoryOperand(ICRegisters.edx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), ICRegisters.cl));
		} /* else */ { /* if (dst.size == MemoryOperandSize.WORD) */
			testAssembler(c -> c.ror(word_ptr(0x0L).base(edx), cl), Instruction.create(Code.ROR_RM16_CL, new MemoryOperand(ICRegisters.edx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), ICRegisters.cl));
		} /* else */ { /* if (dst.size == MemoryOperandSize.BYTE) */
			testAssembler(c -> c.ror(byte_ptr(0x0L).base(edx), cl), Instruction.create(Code.ROR_RM8_CL, new MemoryOperand(ICRegisters.edx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), ICRegisters.cl));
		}
		{
			assertInvalid(() -> {
				testAssembler(c -> c.ror(zmmword_ptr(0x0L).base(edx), cl), Instruction.create(Code.ROR_RM8_CL, new MemoryOperand(ICRegisters.edx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), ICRegisters.cl));
			});
		}
	}

	@Test
	void ror_r8_i() {
		{ /* if (imm == 1) */
			testAssembler(c -> c.ror(dl, 1), Instruction.create(Code.ROR_RM8_1, ICRegisters.dl, 1));
		} /* else */ testAssembler(c -> c.ror(dl, 2), Instruction.create(Code.ROR_RM8_IMM8, ICRegisters.dl, 2));
	}

	@Test
	void ror_r16_i() {
		{ /* if (imm == 1) */
			testAssembler(c -> c.ror(dx, 1), Instruction.create(Code.ROR_RM16_1, ICRegisters.dx, 1));
		} /* else */ testAssembler(c -> c.ror(dx, 2), Instruction.create(Code.ROR_RM16_IMM8, ICRegisters.dx, 2));
	}

	@Test
	void ror_r32_i() {
		{ /* if (imm == 1) */
			testAssembler(c -> c.ror(edx, 1), Instruction.create(Code.ROR_RM32_1, ICRegisters.edx, 1));
		} /* else */ testAssembler(c -> c.ror(edx, 2), Instruction.create(Code.ROR_RM32_IMM8, ICRegisters.edx, 2));
	}

	@Test
	void ror_m_i() {
		{ /* if (imm == 1) */
			{ /* if (dst.size == MemoryOperandSize.QWORD) */
				// Skipping ROR_RM64_1 - Not supported by current bitness
			} /* else */ { /* if (dst.size == MemoryOperandSize.DWORD) */
				testAssembler(c -> c.ror(dword_ptr(0x0L).base(edx), 1), Instruction.create(Code.ROR_RM32_1, new MemoryOperand(ICRegisters.edx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), 1));
			} /* else */ { /* if (dst.size == MemoryOperandSize.WORD) */
				testAssembler(c -> c.ror(word_ptr(0x0L).base(edx), 1), Instruction.create(Code.ROR_RM16_1, new MemoryOperand(ICRegisters.edx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), 1));
			} /* else */ { /* if (dst.size == MemoryOperandSize.BYTE) */
				testAssembler(c -> c.ror(byte_ptr(0x0L).base(edx), 1), Instruction.create(Code.ROR_RM8_1, new MemoryOperand(ICRegisters.edx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), 1));
			}
			{
				assertInvalid(() -> {
					testAssembler(c -> c.ror(zmmword_ptr(0x0L).base(edx), 1), Instruction.create(Code.ROR_RM8_1, new MemoryOperand(ICRegisters.edx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), 1));
				});
			}
		} /* else */ { /* if (dst.size == MemoryOperandSize.QWORD) */
			// Skipping ROR_RM64_IMM8 - Not supported by current bitness
		} /* else */ { /* if (dst.size == MemoryOperandSize.DWORD) */
			testAssembler(c -> c.ror(dword_ptr(0x0L).base(edx), 2), Instruction.create(Code.ROR_RM32_IMM8, new MemoryOperand(ICRegisters.edx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), 2));
		} /* else */ { /* if (dst.size == MemoryOperandSize.WORD) */
			testAssembler(c -> c.ror(word_ptr(0x0L).base(edx), 2), Instruction.create(Code.ROR_RM16_IMM8, new MemoryOperand(ICRegisters.edx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), 2));
		} /* else */ { /* if (dst.size == MemoryOperandSize.BYTE) */
			testAssembler(c -> c.ror(byte_ptr(0x0L).base(edx), 2), Instruction.create(Code.ROR_RM8_IMM8, new MemoryOperand(ICRegisters.edx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), 2));
		}
		{
			assertInvalid(() -> {
				testAssembler(c -> c.ror(zmmword_ptr(0x0L).base(edx), 2), Instruction.create(Code.ROR_RM8_IMM8, new MemoryOperand(ICRegisters.edx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), 2));
			});
		}
	}

	@Test
	void rorx_r32_r32_i() {
		testAssembler(c -> c.rorx(edx, ebx, -5), Instruction.create(Code.VEX_RORX_R32_RM32_IMM8, ICRegisters.edx, ICRegisters.ebx, -5));
	}

	@Test
	void rorx_r32_m_i() {
		testAssembler(c -> c.rorx(edx, dword_ptr(0x0L).base(ecx), -5), Instruction.create(Code.VEX_RORX_R32_RM32_IMM8, ICRegisters.edx, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), -5));
	}

	@Test
	void roundpd_xmm_xmm_i() {
		testAssembler(c -> c.roundpd(xmm2, xmm3, -5), Instruction.create(Code.ROUNDPD_XMM_XMMM128_IMM8, ICRegisters.xmm2, ICRegisters.xmm3, -5));
	}

	@Test
	void roundpd_xmm_m_i() {
		testAssembler(c -> c.roundpd(xmm2, xmmword_ptr(0x0L).base(ecx), -5), Instruction.create(Code.ROUNDPD_XMM_XMMM128_IMM8, ICRegisters.xmm2, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), -5));
	}

	@Test
	void roundps_xmm_xmm_i() {
		testAssembler(c -> c.roundps(xmm2, xmm3, -5), Instruction.create(Code.ROUNDPS_XMM_XMMM128_IMM8, ICRegisters.xmm2, ICRegisters.xmm3, -5));
	}

	@Test
	void roundps_xmm_m_i() {
		testAssembler(c -> c.roundps(xmm2, xmmword_ptr(0x0L).base(ecx), -5), Instruction.create(Code.ROUNDPS_XMM_XMMM128_IMM8, ICRegisters.xmm2, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), -5));
	}

	@Test
	void roundsd_xmm_xmm_i() {
		testAssembler(c -> c.roundsd(xmm2, xmm3, -5), Instruction.create(Code.ROUNDSD_XMM_XMMM64_IMM8, ICRegisters.xmm2, ICRegisters.xmm3, -5));
	}

	@Test
	void roundsd_xmm_m_i() {
		testAssembler(c -> c.roundsd(xmm2, xmmword_ptr(0x0L).base(ecx), -5), Instruction.create(Code.ROUNDSD_XMM_XMMM64_IMM8, ICRegisters.xmm2, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), -5));
	}

	@Test
	void roundss_xmm_xmm_i() {
		testAssembler(c -> c.roundss(xmm2, xmm3, -5), Instruction.create(Code.ROUNDSS_XMM_XMMM32_IMM8, ICRegisters.xmm2, ICRegisters.xmm3, -5));
	}

	@Test
	void roundss_xmm_m_i() {
		testAssembler(c -> c.roundss(xmm2, xmmword_ptr(0x0L).base(ecx), -5), Instruction.create(Code.ROUNDSS_XMM_XMMM32_IMM8, ICRegisters.xmm2, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), -5));
	}

	@Test
	void rsdc_seg_m() {
		testAssembler(c -> c.rsdc(ds, mem_ptr(0x0L).base(ecx)), Instruction.create(Code.RSDC_SREG_M80, ICRegisters.ds, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE)), TestInstrFlags.NONE, com.github.icedland.iced.x86.dec.DecoderOptions.CYRIX);
	}

	@Test
	void rsldt_m() {
		testAssembler(c -> c.rsldt(mem_ptr(0x0L).base(ecx)), Instruction.create(Code.RSLDT_M80, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE)), TestInstrFlags.NONE, com.github.icedland.iced.x86.dec.DecoderOptions.CYRIX);
	}

	@Test
	void rsm() {
		testAssembler(c -> c.rsm(), Instruction.create(Code.RSM));
	}

	@Test
	void rsqrtps_xmm_xmm() {
		testAssembler(c -> c.rsqrtps(xmm2, xmm3), Instruction.create(Code.RSQRTPS_XMM_XMMM128, ICRegisters.xmm2, ICRegisters.xmm3));
	}

	@Test
	void rsqrtps_xmm_m() {
		testAssembler(c -> c.rsqrtps(xmm2, xmmword_ptr(0x0L).base(ecx)), Instruction.create(Code.RSQRTPS_XMM_XMMM128, ICRegisters.xmm2, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE)));
	}

	@Test
	void rsqrtss_xmm_xmm() {
		testAssembler(c -> c.rsqrtss(xmm2, xmm3), Instruction.create(Code.RSQRTSS_XMM_XMMM32, ICRegisters.xmm2, ICRegisters.xmm3));
	}

	@Test
	void rsqrtss_xmm_m() {
		testAssembler(c -> c.rsqrtss(xmm2, xmmword_ptr(0x0L).base(ecx)), Instruction.create(Code.RSQRTSS_XMM_XMMM32, ICRegisters.xmm2, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE)));
	}

	@Test
	void rstorssp_m() {
		testAssembler(c -> c.rstorssp(mem_ptr(0x0L).base(ecx)), Instruction.create(Code.RSTORSSP_M64, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE)));
	}

	@Test
	void rsts_m() {
		testAssembler(c -> c.rsts(mem_ptr(0x0L).base(ecx)), Instruction.create(Code.RSTS_M80, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE)), TestInstrFlags.NONE, com.github.icedland.iced.x86.dec.DecoderOptions.CYRIX);
	}

	@Test
	void vrangepd_xmm_xmm_xmm_i() {
		testAssembler(c -> c.vrangepd(xmm2.k1(), xmm3, xmm4, -5), applyK(Instruction.create(Code.EVEX_VRANGEPD_XMM_K1Z_XMM_XMMM128B64_IMM8, ICRegisters.xmm2, ICRegisters.xmm3, ICRegisters.xmm4, -5), Register.K1));
	}

	@Test
	void vrangepd_ymm_ymm_ymm_i() {
		testAssembler(c -> c.vrangepd(ymm2.k1(), ymm3, ymm4, -5), applyK(Instruction.create(Code.EVEX_VRANGEPD_YMM_K1Z_YMM_YMMM256B64_IMM8, ICRegisters.ymm2, ICRegisters.ymm3, ICRegisters.ymm4, -5), Register.K1));
	}

	@Test
	void vrangepd_zmm_zmm_zmm_i() {
		testAssembler(c -> c.vrangepd(zmm2.k1(), zmm3, zmm4, -5), applyK(Instruction.create(Code.EVEX_VRANGEPD_ZMM_K1Z_ZMM_ZMMM512B64_IMM8_SAE, ICRegisters.zmm2, ICRegisters.zmm3, ICRegisters.zmm4, -5), Register.K1));
	}

	@Test
	void vrangepd_xmm_xmm_m_i() {
		testAssembler(c -> c.vrangepd(xmm2.k1(), xmm3, xmmword_ptr(0x0L).base(ecx), -5), applyK(Instruction.create(Code.EVEX_VRANGEPD_XMM_K1Z_XMM_XMMM128B64_IMM8, ICRegisters.xmm2, ICRegisters.xmm3, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), -5), Register.K1));
	}

	@Test
	void vrangepd_ymm_ymm_m_i() {
		testAssembler(c -> c.vrangepd(ymm2.k1(), ymm3, ymmword_ptr(0x0L).base(ecx), -5), applyK(Instruction.create(Code.EVEX_VRANGEPD_YMM_K1Z_YMM_YMMM256B64_IMM8, ICRegisters.ymm2, ICRegisters.ymm3, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), -5), Register.K1));
	}

	@Test
	void vrangepd_zmm_zmm_m_i() {
		testAssembler(c -> c.vrangepd(zmm2.k1(), zmm3, zmmword_ptr(0x0L).base(ecx), -5), applyK(Instruction.create(Code.EVEX_VRANGEPD_ZMM_K1Z_ZMM_ZMMM512B64_IMM8_SAE, ICRegisters.zmm2, ICRegisters.zmm3, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), -5), Register.K1));
	}

	@Test
	void vrangeps_xmm_xmm_xmm_i() {
		testAssembler(c -> c.vrangeps(xmm2.k1(), xmm3, xmm4, -5), applyK(Instruction.create(Code.EVEX_VRANGEPS_XMM_K1Z_XMM_XMMM128B32_IMM8, ICRegisters.xmm2, ICRegisters.xmm3, ICRegisters.xmm4, -5), Register.K1));
	}

	@Test
	void vrangeps_ymm_ymm_ymm_i() {
		testAssembler(c -> c.vrangeps(ymm2.k1(), ymm3, ymm4, -5), applyK(Instruction.create(Code.EVEX_VRANGEPS_YMM_K1Z_YMM_YMMM256B32_IMM8, ICRegisters.ymm2, ICRegisters.ymm3, ICRegisters.ymm4, -5), Register.K1));
	}

	@Test
	void vrangeps_zmm_zmm_zmm_i() {
		testAssembler(c -> c.vrangeps(zmm2.k1(), zmm3, zmm4, -5), applyK(Instruction.create(Code.EVEX_VRANGEPS_ZMM_K1Z_ZMM_ZMMM512B32_IMM8_SAE, ICRegisters.zmm2, ICRegisters.zmm3, ICRegisters.zmm4, -5), Register.K1));
	}

	@Test
	void vrangeps_xmm_xmm_m_i() {
		testAssembler(c -> c.vrangeps(xmm2.k1(), xmm3, xmmword_ptr(0x0L).base(ecx), -5), applyK(Instruction.create(Code.EVEX_VRANGEPS_XMM_K1Z_XMM_XMMM128B32_IMM8, ICRegisters.xmm2, ICRegisters.xmm3, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), -5), Register.K1));
	}

	@Test
	void vrangeps_ymm_ymm_m_i() {
		testAssembler(c -> c.vrangeps(ymm2.k1(), ymm3, ymmword_ptr(0x0L).base(ecx), -5), applyK(Instruction.create(Code.EVEX_VRANGEPS_YMM_K1Z_YMM_YMMM256B32_IMM8, ICRegisters.ymm2, ICRegisters.ymm3, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), -5), Register.K1));
	}

	@Test
	void vrangeps_zmm_zmm_m_i() {
		testAssembler(c -> c.vrangeps(zmm2.k1(), zmm3, zmmword_ptr(0x0L).base(ecx), -5), applyK(Instruction.create(Code.EVEX_VRANGEPS_ZMM_K1Z_ZMM_ZMMM512B32_IMM8_SAE, ICRegisters.zmm2, ICRegisters.zmm3, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), -5), Register.K1));
	}

	@Test
	void vrangesd_xmm_xmm_xmm_i() {
		testAssembler(c -> c.vrangesd(xmm2.k1(), xmm3, xmm4, -5), applyK(Instruction.create(Code.EVEX_VRANGESD_XMM_K1Z_XMM_XMMM64_IMM8_SAE, ICRegisters.xmm2, ICRegisters.xmm3, ICRegisters.xmm4, -5), Register.K1));
	}

	@Test
	void vrangesd_xmm_xmm_m_i() {
		testAssembler(c -> c.vrangesd(xmm2.k1(), xmm3, xmmword_ptr(0x0L).base(ecx), -5), applyK(Instruction.create(Code.EVEX_VRANGESD_XMM_K1Z_XMM_XMMM64_IMM8_SAE, ICRegisters.xmm2, ICRegisters.xmm3, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), -5), Register.K1));
	}

	@Test
	void vrangess_xmm_xmm_xmm_i() {
		testAssembler(c -> c.vrangess(xmm2.k1(), xmm3, xmm4, -5), applyK(Instruction.create(Code.EVEX_VRANGESS_XMM_K1Z_XMM_XMMM32_IMM8_SAE, ICRegisters.xmm2, ICRegisters.xmm3, ICRegisters.xmm4, -5), Register.K1));
	}

	@Test
	void vrangess_xmm_xmm_m_i() {
		testAssembler(c -> c.vrangess(xmm2.k1(), xmm3, xmmword_ptr(0x0L).base(ecx), -5), applyK(Instruction.create(Code.EVEX_VRANGESS_XMM_K1Z_XMM_XMMM32_IMM8_SAE, ICRegisters.xmm2, ICRegisters.xmm3, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), -5), Register.K1));
	}

	@Test
	void vrcp14pd_xmm_xmm() {
		testAssembler(c -> c.vrcp14pd(xmm2.k1(), xmm3), applyK(Instruction.create(Code.EVEX_VRCP14PD_XMM_K1Z_XMMM128B64, ICRegisters.xmm2, ICRegisters.xmm3), Register.K1));
	}

	@Test
	void vrcp14pd_ymm_ymm() {
		testAssembler(c -> c.vrcp14pd(ymm2.k1(), ymm3), applyK(Instruction.create(Code.EVEX_VRCP14PD_YMM_K1Z_YMMM256B64, ICRegisters.ymm2, ICRegisters.ymm3), Register.K1));
	}

	@Test
	void vrcp14pd_zmm_zmm() {
		testAssembler(c -> c.vrcp14pd(zmm2.k1(), zmm3), applyK(Instruction.create(Code.EVEX_VRCP14PD_ZMM_K1Z_ZMMM512B64, ICRegisters.zmm2, ICRegisters.zmm3), Register.K1));
	}

	@Test
	void vrcp14pd_xmm_m() {
		testAssembler(c -> c.vrcp14pd(xmm2.k1(), xmmword_ptr(0x0L).base(ecx)), applyK(Instruction.create(Code.EVEX_VRCP14PD_XMM_K1Z_XMMM128B64, ICRegisters.xmm2, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE)), Register.K1));
	}

	@Test
	void vrcp14pd_ymm_m() {
		testAssembler(c -> c.vrcp14pd(ymm2.k1(), ymmword_ptr(0x0L).base(ecx)), applyK(Instruction.create(Code.EVEX_VRCP14PD_YMM_K1Z_YMMM256B64, ICRegisters.ymm2, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE)), Register.K1));
	}

	@Test
	void vrcp14pd_zmm_m() {
		testAssembler(c -> c.vrcp14pd(zmm2.k1(), zmmword_ptr(0x0L).base(ecx)), applyK(Instruction.create(Code.EVEX_VRCP14PD_ZMM_K1Z_ZMMM512B64, ICRegisters.zmm2, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE)), Register.K1));
	}

	@Test
	void vrcp14ps_xmm_xmm() {
		testAssembler(c -> c.vrcp14ps(xmm2.k1(), xmm3), applyK(Instruction.create(Code.EVEX_VRCP14PS_XMM_K1Z_XMMM128B32, ICRegisters.xmm2, ICRegisters.xmm3), Register.K1));
	}

	@Test
	void vrcp14ps_ymm_ymm() {
		testAssembler(c -> c.vrcp14ps(ymm2.k1(), ymm3), applyK(Instruction.create(Code.EVEX_VRCP14PS_YMM_K1Z_YMMM256B32, ICRegisters.ymm2, ICRegisters.ymm3), Register.K1));
	}

	@Test
	void vrcp14ps_zmm_zmm() {
		testAssembler(c -> c.vrcp14ps(zmm2.k1(), zmm3), applyK(Instruction.create(Code.EVEX_VRCP14PS_ZMM_K1Z_ZMMM512B32, ICRegisters.zmm2, ICRegisters.zmm3), Register.K1));
	}

	@Test
	void vrcp14ps_xmm_m() {
		testAssembler(c -> c.vrcp14ps(xmm2.k1(), xmmword_ptr(0x0L).base(ecx)), applyK(Instruction.create(Code.EVEX_VRCP14PS_XMM_K1Z_XMMM128B32, ICRegisters.xmm2, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE)), Register.K1));
	}

	@Test
	void vrcp14ps_ymm_m() {
		testAssembler(c -> c.vrcp14ps(ymm2.k1(), ymmword_ptr(0x0L).base(ecx)), applyK(Instruction.create(Code.EVEX_VRCP14PS_YMM_K1Z_YMMM256B32, ICRegisters.ymm2, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE)), Register.K1));
	}

	@Test
	void vrcp14ps_zmm_m() {
		testAssembler(c -> c.vrcp14ps(zmm2.k1(), zmmword_ptr(0x0L).base(ecx)), applyK(Instruction.create(Code.EVEX_VRCP14PS_ZMM_K1Z_ZMMM512B32, ICRegisters.zmm2, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE)), Register.K1));
	}

	@Test
	void vrcp14sd_xmm_xmm_xmm() {
		testAssembler(c -> c.vrcp14sd(xmm2.k1(), xmm3, xmm4), applyK(Instruction.create(Code.EVEX_VRCP14SD_XMM_K1Z_XMM_XMMM64, ICRegisters.xmm2, ICRegisters.xmm3, ICRegisters.xmm4), Register.K1));
	}

	@Test
	void vrcp14sd_xmm_xmm_m() {
		testAssembler(c -> c.vrcp14sd(xmm2.k1(), xmm3, xmmword_ptr(0x0L).base(ecx)), applyK(Instruction.create(Code.EVEX_VRCP14SD_XMM_K1Z_XMM_XMMM64, ICRegisters.xmm2, ICRegisters.xmm3, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE)), Register.K1));
	}

	@Test
	void vrcp14ss_xmm_xmm_xmm() {
		testAssembler(c -> c.vrcp14ss(xmm2.k1(), xmm3, xmm4), applyK(Instruction.create(Code.EVEX_VRCP14SS_XMM_K1Z_XMM_XMMM32, ICRegisters.xmm2, ICRegisters.xmm3, ICRegisters.xmm4), Register.K1));
	}

	@Test
	void vrcp14ss_xmm_xmm_m() {
		testAssembler(c -> c.vrcp14ss(xmm2.k1(), xmm3, xmmword_ptr(0x0L).base(ecx)), applyK(Instruction.create(Code.EVEX_VRCP14SS_XMM_K1Z_XMM_XMMM32, ICRegisters.xmm2, ICRegisters.xmm3, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE)), Register.K1));
	}

	@Test
	void vrcp28pd_zmm_zmm() {
		testAssembler(c -> c.vrcp28pd(zmm2.k1(), zmm3), applyK(Instruction.create(Code.EVEX_VRCP28PD_ZMM_K1Z_ZMMM512B64_SAE, ICRegisters.zmm2, ICRegisters.zmm3), Register.K1));
	}

	@Test
	void vrcp28pd_zmm_m() {
		testAssembler(c -> c.vrcp28pd(zmm2.k1(), zmmword_ptr(0x0L).base(ecx)), applyK(Instruction.create(Code.EVEX_VRCP28PD_ZMM_K1Z_ZMMM512B64_SAE, ICRegisters.zmm2, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE)), Register.K1));
	}

	@Test
	void vrcp28ps_zmm_zmm() {
		testAssembler(c -> c.vrcp28ps(zmm2.k1(), zmm3), applyK(Instruction.create(Code.EVEX_VRCP28PS_ZMM_K1Z_ZMMM512B32_SAE, ICRegisters.zmm2, ICRegisters.zmm3), Register.K1));
	}

	@Test
	void vrcp28ps_zmm_m() {
		testAssembler(c -> c.vrcp28ps(zmm2.k1(), zmmword_ptr(0x0L).base(ecx)), applyK(Instruction.create(Code.EVEX_VRCP28PS_ZMM_K1Z_ZMMM512B32_SAE, ICRegisters.zmm2, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE)), Register.K1));
	}

	@Test
	void vrcp28sd_xmm_xmm_xmm() {
		testAssembler(c -> c.vrcp28sd(xmm2.k1(), xmm3, xmm4), applyK(Instruction.create(Code.EVEX_VRCP28SD_XMM_K1Z_XMM_XMMM64_SAE, ICRegisters.xmm2, ICRegisters.xmm3, ICRegisters.xmm4), Register.K1));
	}

	@Test
	void vrcp28sd_xmm_xmm_m() {
		testAssembler(c -> c.vrcp28sd(xmm2.k1(), xmm3, xmmword_ptr(0x0L).base(ecx)), applyK(Instruction.create(Code.EVEX_VRCP28SD_XMM_K1Z_XMM_XMMM64_SAE, ICRegisters.xmm2, ICRegisters.xmm3, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE)), Register.K1));
	}

	@Test
	void vrcp28ss_xmm_xmm_xmm() {
		testAssembler(c -> c.vrcp28ss(xmm2.k1(), xmm3, xmm4), applyK(Instruction.create(Code.EVEX_VRCP28SS_XMM_K1Z_XMM_XMMM32_SAE, ICRegisters.xmm2, ICRegisters.xmm3, ICRegisters.xmm4), Register.K1));
	}

	@Test
	void vrcp28ss_xmm_xmm_m() {
		testAssembler(c -> c.vrcp28ss(xmm2.k1(), xmm3, xmmword_ptr(0x0L).base(ecx)), applyK(Instruction.create(Code.EVEX_VRCP28SS_XMM_K1Z_XMM_XMMM32_SAE, ICRegisters.xmm2, ICRegisters.xmm3, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE)), Register.K1));
	}

	@Test
	void vrcpph_xmm_xmm() {
		testAssembler(c -> c.vrcpph(xmm2.k1(), xmm3), applyK(Instruction.create(Code.EVEX_VRCPPH_XMM_K1Z_XMMM128B16, ICRegisters.xmm2, ICRegisters.xmm3), Register.K1));
	}

	@Test
	void vrcpph_ymm_ymm() {
		testAssembler(c -> c.vrcpph(ymm2.k1(), ymm3), applyK(Instruction.create(Code.EVEX_VRCPPH_YMM_K1Z_YMMM256B16, ICRegisters.ymm2, ICRegisters.ymm3), Register.K1));
	}

	@Test
	void vrcpph_zmm_zmm() {
		testAssembler(c -> c.vrcpph(zmm2.k1(), zmm3), applyK(Instruction.create(Code.EVEX_VRCPPH_ZMM_K1Z_ZMMM512B16, ICRegisters.zmm2, ICRegisters.zmm3), Register.K1));
	}

	@Test
	void vrcpph_xmm_m() {
		testAssembler(c -> c.vrcpph(xmm2.k1(), xmmword_ptr(0x0L).base(ecx)), applyK(Instruction.create(Code.EVEX_VRCPPH_XMM_K1Z_XMMM128B16, ICRegisters.xmm2, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE)), Register.K1));
	}

	@Test
	void vrcpph_ymm_m() {
		testAssembler(c -> c.vrcpph(ymm2.k1(), ymmword_ptr(0x0L).base(ecx)), applyK(Instruction.create(Code.EVEX_VRCPPH_YMM_K1Z_YMMM256B16, ICRegisters.ymm2, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE)), Register.K1));
	}

	@Test
	void vrcpph_zmm_m() {
		testAssembler(c -> c.vrcpph(zmm2.k1(), zmmword_ptr(0x0L).base(ecx)), applyK(Instruction.create(Code.EVEX_VRCPPH_ZMM_K1Z_ZMMM512B16, ICRegisters.zmm2, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE)), Register.K1));
	}

	@Test
	void vrcpps_xmm_xmm() {
		testAssembler(c -> c.vrcpps(xmm2, xmm3), Instruction.create(Code.VEX_VRCPPS_XMM_XMMM128, ICRegisters.xmm2, ICRegisters.xmm3));
	}

	@Test
	void vrcpps_ymm_ymm() {
		testAssembler(c -> c.vrcpps(ymm2, ymm3), Instruction.create(Code.VEX_VRCPPS_YMM_YMMM256, ICRegisters.ymm2, ICRegisters.ymm3));
	}

	@Test
	void vrcpps_xmm_m() {
		testAssembler(c -> c.vrcpps(xmm2, xmmword_ptr(0x0L).base(ecx)), Instruction.create(Code.VEX_VRCPPS_XMM_XMMM128, ICRegisters.xmm2, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE)));
	}

	@Test
	void vrcpps_ymm_m() {
		testAssembler(c -> c.vrcpps(ymm2, ymmword_ptr(0x0L).base(ecx)), Instruction.create(Code.VEX_VRCPPS_YMM_YMMM256, ICRegisters.ymm2, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE)));
	}

	@Test
	void vrcpsh_xmm_xmm_xmm() {
		testAssembler(c -> c.vrcpsh(xmm2.k1(), xmm3, xmm4), applyK(Instruction.create(Code.EVEX_VRCPSH_XMM_K1Z_XMM_XMMM16, ICRegisters.xmm2, ICRegisters.xmm3, ICRegisters.xmm4), Register.K1));
	}

	@Test
	void vrcpsh_xmm_xmm_m() {
		testAssembler(c -> c.vrcpsh(xmm2.k1(), xmm3, xmmword_ptr(0x0L).base(ecx)), applyK(Instruction.create(Code.EVEX_VRCPSH_XMM_K1Z_XMM_XMMM16, ICRegisters.xmm2, ICRegisters.xmm3, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE)), Register.K1));
	}

	@Test
	void vrcpss_xmm_xmm_xmm() {
		testAssembler(c -> c.vrcpss(xmm2, xmm3, xmm4), Instruction.create(Code.VEX_VRCPSS_XMM_XMM_XMMM32, ICRegisters.xmm2, ICRegisters.xmm3, ICRegisters.xmm4));
	}

	@Test
	void vrcpss_xmm_xmm_m() {
		testAssembler(c -> c.vrcpss(xmm2, xmm3, xmmword_ptr(0x0L).base(ecx)), Instruction.create(Code.VEX_VRCPSS_XMM_XMM_XMMM32, ICRegisters.xmm2, ICRegisters.xmm3, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE)));
	}

	@Test
	void vreducepd_xmm_xmm_i() {
		testAssembler(c -> c.vreducepd(xmm2.k1(), xmm3, -5), applyK(Instruction.create(Code.EVEX_VREDUCEPD_XMM_K1Z_XMMM128B64_IMM8, ICRegisters.xmm2, ICRegisters.xmm3, -5), Register.K1));
	}

	@Test
	void vreducepd_ymm_ymm_i() {
		testAssembler(c -> c.vreducepd(ymm2.k1(), ymm3, -5), applyK(Instruction.create(Code.EVEX_VREDUCEPD_YMM_K1Z_YMMM256B64_IMM8, ICRegisters.ymm2, ICRegisters.ymm3, -5), Register.K1));
	}

	@Test
	void vreducepd_zmm_zmm_i() {
		testAssembler(c -> c.vreducepd(zmm2.k1(), zmm3, -5), applyK(Instruction.create(Code.EVEX_VREDUCEPD_ZMM_K1Z_ZMMM512B64_IMM8_SAE, ICRegisters.zmm2, ICRegisters.zmm3, -5), Register.K1));
	}

	@Test
	void vreducepd_xmm_m_i() {
		testAssembler(c -> c.vreducepd(xmm2.k1(), xmmword_ptr(0x0L).base(ecx), -5), applyK(Instruction.create(Code.EVEX_VREDUCEPD_XMM_K1Z_XMMM128B64_IMM8, ICRegisters.xmm2, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), -5), Register.K1));
	}

	@Test
	void vreducepd_ymm_m_i() {
		testAssembler(c -> c.vreducepd(ymm2.k1(), ymmword_ptr(0x0L).base(ecx), -5), applyK(Instruction.create(Code.EVEX_VREDUCEPD_YMM_K1Z_YMMM256B64_IMM8, ICRegisters.ymm2, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), -5), Register.K1));
	}

	@Test
	void vreducepd_zmm_m_i() {
		testAssembler(c -> c.vreducepd(zmm2.k1(), zmmword_ptr(0x0L).base(ecx), -5), applyK(Instruction.create(Code.EVEX_VREDUCEPD_ZMM_K1Z_ZMMM512B64_IMM8_SAE, ICRegisters.zmm2, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), -5), Register.K1));
	}

	@Test
	void vreduceph_xmm_xmm_i() {
		testAssembler(c -> c.vreduceph(xmm2.k1(), xmm3, -5), applyK(Instruction.create(Code.EVEX_VREDUCEPH_XMM_K1Z_XMMM128B16_IMM8, ICRegisters.xmm2, ICRegisters.xmm3, -5), Register.K1));
	}

	@Test
	void vreduceph_ymm_ymm_i() {
		testAssembler(c -> c.vreduceph(ymm2.k1(), ymm3, -5), applyK(Instruction.create(Code.EVEX_VREDUCEPH_YMM_K1Z_YMMM256B16_IMM8, ICRegisters.ymm2, ICRegisters.ymm3, -5), Register.K1));
	}

	@Test
	void vreduceph_zmm_zmm_i() {
		testAssembler(c -> c.vreduceph(zmm2.k1(), zmm3, -5), applyK(Instruction.create(Code.EVEX_VREDUCEPH_ZMM_K1Z_ZMMM512B16_IMM8_SAE, ICRegisters.zmm2, ICRegisters.zmm3, -5), Register.K1));
	}

	@Test
	void vreduceph_xmm_m_i() {
		testAssembler(c -> c.vreduceph(xmm2.k1(), xmmword_ptr(0x0L).base(ecx), -5), applyK(Instruction.create(Code.EVEX_VREDUCEPH_XMM_K1Z_XMMM128B16_IMM8, ICRegisters.xmm2, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), -5), Register.K1));
	}

	@Test
	void vreduceph_ymm_m_i() {
		testAssembler(c -> c.vreduceph(ymm2.k1(), ymmword_ptr(0x0L).base(ecx), -5), applyK(Instruction.create(Code.EVEX_VREDUCEPH_YMM_K1Z_YMMM256B16_IMM8, ICRegisters.ymm2, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), -5), Register.K1));
	}

	@Test
	void vreduceph_zmm_m_i() {
		testAssembler(c -> c.vreduceph(zmm2.k1(), zmmword_ptr(0x0L).base(ecx), -5), applyK(Instruction.create(Code.EVEX_VREDUCEPH_ZMM_K1Z_ZMMM512B16_IMM8_SAE, ICRegisters.zmm2, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), -5), Register.K1));
	}

	@Test
	void vreduceps_xmm_xmm_i() {
		testAssembler(c -> c.vreduceps(xmm2.k1(), xmm3, -5), applyK(Instruction.create(Code.EVEX_VREDUCEPS_XMM_K1Z_XMMM128B32_IMM8, ICRegisters.xmm2, ICRegisters.xmm3, -5), Register.K1));
	}

	@Test
	void vreduceps_ymm_ymm_i() {
		testAssembler(c -> c.vreduceps(ymm2.k1(), ymm3, -5), applyK(Instruction.create(Code.EVEX_VREDUCEPS_YMM_K1Z_YMMM256B32_IMM8, ICRegisters.ymm2, ICRegisters.ymm3, -5), Register.K1));
	}

	@Test
	void vreduceps_zmm_zmm_i() {
		testAssembler(c -> c.vreduceps(zmm2.k1(), zmm3, -5), applyK(Instruction.create(Code.EVEX_VREDUCEPS_ZMM_K1Z_ZMMM512B32_IMM8_SAE, ICRegisters.zmm2, ICRegisters.zmm3, -5), Register.K1));
	}

	@Test
	void vreduceps_xmm_m_i() {
		testAssembler(c -> c.vreduceps(xmm2.k1(), xmmword_ptr(0x0L).base(ecx), -5), applyK(Instruction.create(Code.EVEX_VREDUCEPS_XMM_K1Z_XMMM128B32_IMM8, ICRegisters.xmm2, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), -5), Register.K1));
	}

	@Test
	void vreduceps_ymm_m_i() {
		testAssembler(c -> c.vreduceps(ymm2.k1(), ymmword_ptr(0x0L).base(ecx), -5), applyK(Instruction.create(Code.EVEX_VREDUCEPS_YMM_K1Z_YMMM256B32_IMM8, ICRegisters.ymm2, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), -5), Register.K1));
	}

	@Test
	void vreduceps_zmm_m_i() {
		testAssembler(c -> c.vreduceps(zmm2.k1(), zmmword_ptr(0x0L).base(ecx), -5), applyK(Instruction.create(Code.EVEX_VREDUCEPS_ZMM_K1Z_ZMMM512B32_IMM8_SAE, ICRegisters.zmm2, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), -5), Register.K1));
	}

	@Test
	void vreducesd_xmm_xmm_xmm_i() {
		testAssembler(c -> c.vreducesd(xmm2.k1(), xmm3, xmm4, -5), applyK(Instruction.create(Code.EVEX_VREDUCESD_XMM_K1Z_XMM_XMMM64_IMM8_SAE, ICRegisters.xmm2, ICRegisters.xmm3, ICRegisters.xmm4, -5), Register.K1));
	}

	@Test
	void vreducesd_xmm_xmm_m_i() {
		testAssembler(c -> c.vreducesd(xmm2.k1(), xmm3, xmmword_ptr(0x0L).base(ecx), -5), applyK(Instruction.create(Code.EVEX_VREDUCESD_XMM_K1Z_XMM_XMMM64_IMM8_SAE, ICRegisters.xmm2, ICRegisters.xmm3, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), -5), Register.K1));
	}

	@Test
	void vreducesh_xmm_xmm_xmm_i() {
		testAssembler(c -> c.vreducesh(xmm2.k1(), xmm3, xmm4, -5), applyK(Instruction.create(Code.EVEX_VREDUCESH_XMM_K1Z_XMM_XMMM16_IMM8_SAE, ICRegisters.xmm2, ICRegisters.xmm3, ICRegisters.xmm4, -5), Register.K1));
	}

	@Test
	void vreducesh_xmm_xmm_m_i() {
		testAssembler(c -> c.vreducesh(xmm2.k1(), xmm3, xmmword_ptr(0x0L).base(ecx), -5), applyK(Instruction.create(Code.EVEX_VREDUCESH_XMM_K1Z_XMM_XMMM16_IMM8_SAE, ICRegisters.xmm2, ICRegisters.xmm3, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), -5), Register.K1));
	}

	@Test
	void vreducess_xmm_xmm_xmm_i() {
		testAssembler(c -> c.vreducess(xmm2.k1(), xmm3, xmm4, -5), applyK(Instruction.create(Code.EVEX_VREDUCESS_XMM_K1Z_XMM_XMMM32_IMM8_SAE, ICRegisters.xmm2, ICRegisters.xmm3, ICRegisters.xmm4, -5), Register.K1));
	}

	@Test
	void vreducess_xmm_xmm_m_i() {
		testAssembler(c -> c.vreducess(xmm2.k1(), xmm3, xmmword_ptr(0x0L).base(ecx), -5), applyK(Instruction.create(Code.EVEX_VREDUCESS_XMM_K1Z_XMM_XMMM32_IMM8_SAE, ICRegisters.xmm2, ICRegisters.xmm3, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), -5), Register.K1));
	}

	@Test
	void vrndscalepd_xmm_xmm_i() {
		testAssembler(c -> c.vrndscalepd(xmm2.k1(), xmm3, -5), applyK(Instruction.create(Code.EVEX_VRNDSCALEPD_XMM_K1Z_XMMM128B64_IMM8, ICRegisters.xmm2, ICRegisters.xmm3, -5), Register.K1));
	}

	@Test
	void vrndscalepd_ymm_ymm_i() {
		testAssembler(c -> c.vrndscalepd(ymm2.k1(), ymm3, -5), applyK(Instruction.create(Code.EVEX_VRNDSCALEPD_YMM_K1Z_YMMM256B64_IMM8, ICRegisters.ymm2, ICRegisters.ymm3, -5), Register.K1));
	}

	@Test
	void vrndscalepd_zmm_zmm_i() {
		testAssembler(c -> c.vrndscalepd(zmm2.k1(), zmm3, -5), applyK(Instruction.create(Code.EVEX_VRNDSCALEPD_ZMM_K1Z_ZMMM512B64_IMM8_SAE, ICRegisters.zmm2, ICRegisters.zmm3, -5), Register.K1));
	}

	@Test
	void vrndscalepd_xmm_m_i() {
		testAssembler(c -> c.vrndscalepd(xmm2.k1(), xmmword_ptr(0x0L).base(ecx), -5), applyK(Instruction.create(Code.EVEX_VRNDSCALEPD_XMM_K1Z_XMMM128B64_IMM8, ICRegisters.xmm2, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), -5), Register.K1));
	}

	@Test
	void vrndscalepd_ymm_m_i() {
		testAssembler(c -> c.vrndscalepd(ymm2.k1(), ymmword_ptr(0x0L).base(ecx), -5), applyK(Instruction.create(Code.EVEX_VRNDSCALEPD_YMM_K1Z_YMMM256B64_IMM8, ICRegisters.ymm2, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), -5), Register.K1));
	}

	@Test
	void vrndscalepd_zmm_m_i() {
		testAssembler(c -> c.vrndscalepd(zmm2.k1(), zmmword_ptr(0x0L).base(ecx), -5), applyK(Instruction.create(Code.EVEX_VRNDSCALEPD_ZMM_K1Z_ZMMM512B64_IMM8_SAE, ICRegisters.zmm2, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), -5), Register.K1));
	}

	@Test
	void vrndscaleph_xmm_xmm_i() {
		testAssembler(c -> c.vrndscaleph(xmm2.k1(), xmm3, -5), applyK(Instruction.create(Code.EVEX_VRNDSCALEPH_XMM_K1Z_XMMM128B16_IMM8, ICRegisters.xmm2, ICRegisters.xmm3, -5), Register.K1));
	}

	@Test
	void vrndscaleph_ymm_ymm_i() {
		testAssembler(c -> c.vrndscaleph(ymm2.k1(), ymm3, -5), applyK(Instruction.create(Code.EVEX_VRNDSCALEPH_YMM_K1Z_YMMM256B16_IMM8, ICRegisters.ymm2, ICRegisters.ymm3, -5), Register.K1));
	}

	@Test
	void vrndscaleph_zmm_zmm_i() {
		testAssembler(c -> c.vrndscaleph(zmm2.k1(), zmm3, -5), applyK(Instruction.create(Code.EVEX_VRNDSCALEPH_ZMM_K1Z_ZMMM512B16_IMM8_SAE, ICRegisters.zmm2, ICRegisters.zmm3, -5), Register.K1));
	}

	@Test
	void vrndscaleph_xmm_m_i() {
		testAssembler(c -> c.vrndscaleph(xmm2.k1(), xmmword_ptr(0x0L).base(ecx), -5), applyK(Instruction.create(Code.EVEX_VRNDSCALEPH_XMM_K1Z_XMMM128B16_IMM8, ICRegisters.xmm2, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), -5), Register.K1));
	}

	@Test
	void vrndscaleph_ymm_m_i() {
		testAssembler(c -> c.vrndscaleph(ymm2.k1(), ymmword_ptr(0x0L).base(ecx), -5), applyK(Instruction.create(Code.EVEX_VRNDSCALEPH_YMM_K1Z_YMMM256B16_IMM8, ICRegisters.ymm2, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), -5), Register.K1));
	}

	@Test
	void vrndscaleph_zmm_m_i() {
		testAssembler(c -> c.vrndscaleph(zmm2.k1(), zmmword_ptr(0x0L).base(ecx), -5), applyK(Instruction.create(Code.EVEX_VRNDSCALEPH_ZMM_K1Z_ZMMM512B16_IMM8_SAE, ICRegisters.zmm2, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), -5), Register.K1));
	}

	@Test
	void vrndscaleps_xmm_xmm_i() {
		testAssembler(c -> c.vrndscaleps(xmm2.k1(), xmm3, -5), applyK(Instruction.create(Code.EVEX_VRNDSCALEPS_XMM_K1Z_XMMM128B32_IMM8, ICRegisters.xmm2, ICRegisters.xmm3, -5), Register.K1));
	}

	@Test
	void vrndscaleps_ymm_ymm_i() {
		testAssembler(c -> c.vrndscaleps(ymm2.k1(), ymm3, -5), applyK(Instruction.create(Code.EVEX_VRNDSCALEPS_YMM_K1Z_YMMM256B32_IMM8, ICRegisters.ymm2, ICRegisters.ymm3, -5), Register.K1));
	}

	@Test
	void vrndscaleps_zmm_zmm_i() {
		testAssembler(c -> c.vrndscaleps(zmm2.k1(), zmm3, -5), applyK(Instruction.create(Code.EVEX_VRNDSCALEPS_ZMM_K1Z_ZMMM512B32_IMM8_SAE, ICRegisters.zmm2, ICRegisters.zmm3, -5), Register.K1));
	}

	@Test
	void vrndscaleps_xmm_m_i() {
		testAssembler(c -> c.vrndscaleps(xmm2.k1(), xmmword_ptr(0x0L).base(ecx), -5), applyK(Instruction.create(Code.EVEX_VRNDSCALEPS_XMM_K1Z_XMMM128B32_IMM8, ICRegisters.xmm2, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), -5), Register.K1));
	}

	@Test
	void vrndscaleps_ymm_m_i() {
		testAssembler(c -> c.vrndscaleps(ymm2.k1(), ymmword_ptr(0x0L).base(ecx), -5), applyK(Instruction.create(Code.EVEX_VRNDSCALEPS_YMM_K1Z_YMMM256B32_IMM8, ICRegisters.ymm2, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), -5), Register.K1));
	}

	@Test
	void vrndscaleps_zmm_m_i() {
		testAssembler(c -> c.vrndscaleps(zmm2.k1(), zmmword_ptr(0x0L).base(ecx), -5), applyK(Instruction.create(Code.EVEX_VRNDSCALEPS_ZMM_K1Z_ZMMM512B32_IMM8_SAE, ICRegisters.zmm2, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), -5), Register.K1));
	}

	@Test
	void vrndscalesd_xmm_xmm_xmm_i() {
		testAssembler(c -> c.vrndscalesd(xmm2.k1(), xmm3, xmm4, -5), applyK(Instruction.create(Code.EVEX_VRNDSCALESD_XMM_K1Z_XMM_XMMM64_IMM8_SAE, ICRegisters.xmm2, ICRegisters.xmm3, ICRegisters.xmm4, -5), Register.K1));
	}

	@Test
	void vrndscalesd_xmm_xmm_m_i() {
		testAssembler(c -> c.vrndscalesd(xmm2.k1(), xmm3, xmmword_ptr(0x0L).base(ecx), -5), applyK(Instruction.create(Code.EVEX_VRNDSCALESD_XMM_K1Z_XMM_XMMM64_IMM8_SAE, ICRegisters.xmm2, ICRegisters.xmm3, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), -5), Register.K1));
	}

	@Test
	void vrndscalesh_xmm_xmm_xmm_i() {
		testAssembler(c -> c.vrndscalesh(xmm2.k1(), xmm3, xmm4, -5), applyK(Instruction.create(Code.EVEX_VRNDSCALESH_XMM_K1Z_XMM_XMMM16_IMM8_SAE, ICRegisters.xmm2, ICRegisters.xmm3, ICRegisters.xmm4, -5), Register.K1));
	}

	@Test
	void vrndscalesh_xmm_xmm_m_i() {
		testAssembler(c -> c.vrndscalesh(xmm2.k1(), xmm3, xmmword_ptr(0x0L).base(ecx), -5), applyK(Instruction.create(Code.EVEX_VRNDSCALESH_XMM_K1Z_XMM_XMMM16_IMM8_SAE, ICRegisters.xmm2, ICRegisters.xmm3, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), -5), Register.K1));
	}

	@Test
	void vrndscaless_xmm_xmm_xmm_i() {
		testAssembler(c -> c.vrndscaless(xmm2.k1(), xmm3, xmm4, -5), applyK(Instruction.create(Code.EVEX_VRNDSCALESS_XMM_K1Z_XMM_XMMM32_IMM8_SAE, ICRegisters.xmm2, ICRegisters.xmm3, ICRegisters.xmm4, -5), Register.K1));
	}

	@Test
	void vrndscaless_xmm_xmm_m_i() {
		testAssembler(c -> c.vrndscaless(xmm2.k1(), xmm3, xmmword_ptr(0x0L).base(ecx), -5), applyK(Instruction.create(Code.EVEX_VRNDSCALESS_XMM_K1Z_XMM_XMMM32_IMM8_SAE, ICRegisters.xmm2, ICRegisters.xmm3, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), -5), Register.K1));
	}

	@Test
	void vroundpd_xmm_xmm_i() {
		testAssembler(c -> c.vroundpd(xmm2, xmm3, -5), Instruction.create(Code.VEX_VROUNDPD_XMM_XMMM128_IMM8, ICRegisters.xmm2, ICRegisters.xmm3, -5));
	}

	@Test
	void vroundpd_ymm_ymm_i() {
		testAssembler(c -> c.vroundpd(ymm2, ymm3, -5), Instruction.create(Code.VEX_VROUNDPD_YMM_YMMM256_IMM8, ICRegisters.ymm2, ICRegisters.ymm3, -5));
	}

	@Test
	void vroundpd_xmm_m_i() {
		testAssembler(c -> c.vroundpd(xmm2, xmmword_ptr(0x0L).base(ecx), -5), Instruction.create(Code.VEX_VROUNDPD_XMM_XMMM128_IMM8, ICRegisters.xmm2, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), -5));
	}

	@Test
	void vroundpd_ymm_m_i() {
		testAssembler(c -> c.vroundpd(ymm2, ymmword_ptr(0x0L).base(ecx), -5), Instruction.create(Code.VEX_VROUNDPD_YMM_YMMM256_IMM8, ICRegisters.ymm2, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), -5));
	}

	@Test
	void vroundps_xmm_xmm_i() {
		testAssembler(c -> c.vroundps(xmm2, xmm3, -5), Instruction.create(Code.VEX_VROUNDPS_XMM_XMMM128_IMM8, ICRegisters.xmm2, ICRegisters.xmm3, -5));
	}

	@Test
	void vroundps_ymm_ymm_i() {
		testAssembler(c -> c.vroundps(ymm2, ymm3, -5), Instruction.create(Code.VEX_VROUNDPS_YMM_YMMM256_IMM8, ICRegisters.ymm2, ICRegisters.ymm3, -5));
	}

	@Test
	void vroundps_xmm_m_i() {
		testAssembler(c -> c.vroundps(xmm2, xmmword_ptr(0x0L).base(ecx), -5), Instruction.create(Code.VEX_VROUNDPS_XMM_XMMM128_IMM8, ICRegisters.xmm2, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), -5));
	}

	@Test
	void vroundps_ymm_m_i() {
		testAssembler(c -> c.vroundps(ymm2, ymmword_ptr(0x0L).base(ecx), -5), Instruction.create(Code.VEX_VROUNDPS_YMM_YMMM256_IMM8, ICRegisters.ymm2, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), -5));
	}

	@Test
	void vroundsd_xmm_xmm_xmm_i() {
		testAssembler(c -> c.vroundsd(xmm2, xmm3, xmm4, -5), Instruction.create(Code.VEX_VROUNDSD_XMM_XMM_XMMM64_IMM8, ICRegisters.xmm2, ICRegisters.xmm3, ICRegisters.xmm4, -5));
	}

	@Test
	void vroundsd_xmm_xmm_m_i() {
		testAssembler(c -> c.vroundsd(xmm2, xmm3, xmmword_ptr(0x0L).base(ecx), -5), Instruction.create(Code.VEX_VROUNDSD_XMM_XMM_XMMM64_IMM8, ICRegisters.xmm2, ICRegisters.xmm3, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), -5));
	}

	@Test
	void vroundss_xmm_xmm_xmm_i() {
		testAssembler(c -> c.vroundss(xmm2, xmm3, xmm4, -5), Instruction.create(Code.VEX_VROUNDSS_XMM_XMM_XMMM32_IMM8, ICRegisters.xmm2, ICRegisters.xmm3, ICRegisters.xmm4, -5));
	}

	@Test
	void vroundss_xmm_xmm_m_i() {
		testAssembler(c -> c.vroundss(xmm2, xmm3, xmmword_ptr(0x0L).base(ecx), -5), Instruction.create(Code.VEX_VROUNDSS_XMM_XMM_XMMM32_IMM8, ICRegisters.xmm2, ICRegisters.xmm3, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), -5));
	}

	@Test
	void vrsqrt14pd_xmm_xmm() {
		testAssembler(c -> c.vrsqrt14pd(xmm2.k1(), xmm3), applyK(Instruction.create(Code.EVEX_VRSQRT14PD_XMM_K1Z_XMMM128B64, ICRegisters.xmm2, ICRegisters.xmm3), Register.K1));
	}

	@Test
	void vrsqrt14pd_ymm_ymm() {
		testAssembler(c -> c.vrsqrt14pd(ymm2.k1(), ymm3), applyK(Instruction.create(Code.EVEX_VRSQRT14PD_YMM_K1Z_YMMM256B64, ICRegisters.ymm2, ICRegisters.ymm3), Register.K1));
	}

	@Test
	void vrsqrt14pd_zmm_zmm() {
		testAssembler(c -> c.vrsqrt14pd(zmm2.k1(), zmm3), applyK(Instruction.create(Code.EVEX_VRSQRT14PD_ZMM_K1Z_ZMMM512B64, ICRegisters.zmm2, ICRegisters.zmm3), Register.K1));
	}

	@Test
	void vrsqrt14pd_xmm_m() {
		testAssembler(c -> c.vrsqrt14pd(xmm2.k1(), xmmword_ptr(0x0L).base(ecx)), applyK(Instruction.create(Code.EVEX_VRSQRT14PD_XMM_K1Z_XMMM128B64, ICRegisters.xmm2, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE)), Register.K1));
	}

	@Test
	void vrsqrt14pd_ymm_m() {
		testAssembler(c -> c.vrsqrt14pd(ymm2.k1(), ymmword_ptr(0x0L).base(ecx)), applyK(Instruction.create(Code.EVEX_VRSQRT14PD_YMM_K1Z_YMMM256B64, ICRegisters.ymm2, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE)), Register.K1));
	}

	@Test
	void vrsqrt14pd_zmm_m() {
		testAssembler(c -> c.vrsqrt14pd(zmm2.k1(), zmmword_ptr(0x0L).base(ecx)), applyK(Instruction.create(Code.EVEX_VRSQRT14PD_ZMM_K1Z_ZMMM512B64, ICRegisters.zmm2, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE)), Register.K1));
	}

	@Test
	void vrsqrt14ps_xmm_xmm() {
		testAssembler(c -> c.vrsqrt14ps(xmm2.k1(), xmm3), applyK(Instruction.create(Code.EVEX_VRSQRT14PS_XMM_K1Z_XMMM128B32, ICRegisters.xmm2, ICRegisters.xmm3), Register.K1));
	}

	@Test
	void vrsqrt14ps_ymm_ymm() {
		testAssembler(c -> c.vrsqrt14ps(ymm2.k1(), ymm3), applyK(Instruction.create(Code.EVEX_VRSQRT14PS_YMM_K1Z_YMMM256B32, ICRegisters.ymm2, ICRegisters.ymm3), Register.K1));
	}

	@Test
	void vrsqrt14ps_zmm_zmm() {
		testAssembler(c -> c.vrsqrt14ps(zmm2.k1(), zmm3), applyK(Instruction.create(Code.EVEX_VRSQRT14PS_ZMM_K1Z_ZMMM512B32, ICRegisters.zmm2, ICRegisters.zmm3), Register.K1));
	}

	@Test
	void vrsqrt14ps_xmm_m() {
		testAssembler(c -> c.vrsqrt14ps(xmm2.k1(), xmmword_ptr(0x0L).base(ecx)), applyK(Instruction.create(Code.EVEX_VRSQRT14PS_XMM_K1Z_XMMM128B32, ICRegisters.xmm2, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE)), Register.K1));
	}

	@Test
	void vrsqrt14ps_ymm_m() {
		testAssembler(c -> c.vrsqrt14ps(ymm2.k1(), ymmword_ptr(0x0L).base(ecx)), applyK(Instruction.create(Code.EVEX_VRSQRT14PS_YMM_K1Z_YMMM256B32, ICRegisters.ymm2, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE)), Register.K1));
	}

	@Test
	void vrsqrt14ps_zmm_m() {
		testAssembler(c -> c.vrsqrt14ps(zmm2.k1(), zmmword_ptr(0x0L).base(ecx)), applyK(Instruction.create(Code.EVEX_VRSQRT14PS_ZMM_K1Z_ZMMM512B32, ICRegisters.zmm2, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE)), Register.K1));
	}

	@Test
	void vrsqrt14sd_xmm_xmm_xmm() {
		testAssembler(c -> c.vrsqrt14sd(xmm2.k1(), xmm3, xmm4), applyK(Instruction.create(Code.EVEX_VRSQRT14SD_XMM_K1Z_XMM_XMMM64, ICRegisters.xmm2, ICRegisters.xmm3, ICRegisters.xmm4), Register.K1));
	}

	@Test
	void vrsqrt14sd_xmm_xmm_m() {
		testAssembler(c -> c.vrsqrt14sd(xmm2.k1(), xmm3, xmmword_ptr(0x0L).base(ecx)), applyK(Instruction.create(Code.EVEX_VRSQRT14SD_XMM_K1Z_XMM_XMMM64, ICRegisters.xmm2, ICRegisters.xmm3, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE)), Register.K1));
	}

	@Test
	void vrsqrt14ss_xmm_xmm_xmm() {
		testAssembler(c -> c.vrsqrt14ss(xmm2.k1(), xmm3, xmm4), applyK(Instruction.create(Code.EVEX_VRSQRT14SS_XMM_K1Z_XMM_XMMM32, ICRegisters.xmm2, ICRegisters.xmm3, ICRegisters.xmm4), Register.K1));
	}

	@Test
	void vrsqrt14ss_xmm_xmm_m() {
		testAssembler(c -> c.vrsqrt14ss(xmm2.k1(), xmm3, xmmword_ptr(0x0L).base(ecx)), applyK(Instruction.create(Code.EVEX_VRSQRT14SS_XMM_K1Z_XMM_XMMM32, ICRegisters.xmm2, ICRegisters.xmm3, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE)), Register.K1));
	}

	@Test
	void vrsqrt28pd_zmm_zmm() {
		testAssembler(c -> c.vrsqrt28pd(zmm2.k1(), zmm3), applyK(Instruction.create(Code.EVEX_VRSQRT28PD_ZMM_K1Z_ZMMM512B64_SAE, ICRegisters.zmm2, ICRegisters.zmm3), Register.K1));
	}

	@Test
	void vrsqrt28pd_zmm_m() {
		testAssembler(c -> c.vrsqrt28pd(zmm2.k1(), zmmword_ptr(0x0L).base(ecx)), applyK(Instruction.create(Code.EVEX_VRSQRT28PD_ZMM_K1Z_ZMMM512B64_SAE, ICRegisters.zmm2, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE)), Register.K1));
	}

	@Test
	void vrsqrt28ps_zmm_zmm() {
		testAssembler(c -> c.vrsqrt28ps(zmm2.k1(), zmm3), applyK(Instruction.create(Code.EVEX_VRSQRT28PS_ZMM_K1Z_ZMMM512B32_SAE, ICRegisters.zmm2, ICRegisters.zmm3), Register.K1));
	}

	@Test
	void vrsqrt28ps_zmm_m() {
		testAssembler(c -> c.vrsqrt28ps(zmm2.k1(), zmmword_ptr(0x0L).base(ecx)), applyK(Instruction.create(Code.EVEX_VRSQRT28PS_ZMM_K1Z_ZMMM512B32_SAE, ICRegisters.zmm2, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE)), Register.K1));
	}

	@Test
	void vrsqrt28sd_xmm_xmm_xmm() {
		testAssembler(c -> c.vrsqrt28sd(xmm2.k1(), xmm3, xmm4), applyK(Instruction.create(Code.EVEX_VRSQRT28SD_XMM_K1Z_XMM_XMMM64_SAE, ICRegisters.xmm2, ICRegisters.xmm3, ICRegisters.xmm4), Register.K1));
	}

	@Test
	void vrsqrt28sd_xmm_xmm_m() {
		testAssembler(c -> c.vrsqrt28sd(xmm2.k1(), xmm3, xmmword_ptr(0x0L).base(ecx)), applyK(Instruction.create(Code.EVEX_VRSQRT28SD_XMM_K1Z_XMM_XMMM64_SAE, ICRegisters.xmm2, ICRegisters.xmm3, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE)), Register.K1));
	}

	@Test
	void vrsqrt28ss_xmm_xmm_xmm() {
		testAssembler(c -> c.vrsqrt28ss(xmm2.k1(), xmm3, xmm4), applyK(Instruction.create(Code.EVEX_VRSQRT28SS_XMM_K1Z_XMM_XMMM32_SAE, ICRegisters.xmm2, ICRegisters.xmm3, ICRegisters.xmm4), Register.K1));
	}

	@Test
	void vrsqrt28ss_xmm_xmm_m() {
		testAssembler(c -> c.vrsqrt28ss(xmm2.k1(), xmm3, xmmword_ptr(0x0L).base(ecx)), applyK(Instruction.create(Code.EVEX_VRSQRT28SS_XMM_K1Z_XMM_XMMM32_SAE, ICRegisters.xmm2, ICRegisters.xmm3, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE)), Register.K1));
	}

	@Test
	void vrsqrtph_xmm_xmm() {
		testAssembler(c -> c.vrsqrtph(xmm2.k1(), xmm3), applyK(Instruction.create(Code.EVEX_VRSQRTPH_XMM_K1Z_XMMM128B16, ICRegisters.xmm2, ICRegisters.xmm3), Register.K1));
	}

	@Test
	void vrsqrtph_ymm_ymm() {
		testAssembler(c -> c.vrsqrtph(ymm2.k1(), ymm3), applyK(Instruction.create(Code.EVEX_VRSQRTPH_YMM_K1Z_YMMM256B16, ICRegisters.ymm2, ICRegisters.ymm3), Register.K1));
	}

	@Test
	void vrsqrtph_zmm_zmm() {
		testAssembler(c -> c.vrsqrtph(zmm2.k1(), zmm3), applyK(Instruction.create(Code.EVEX_VRSQRTPH_ZMM_K1Z_ZMMM512B16, ICRegisters.zmm2, ICRegisters.zmm3), Register.K1));
	}

	@Test
	void vrsqrtph_xmm_m() {
		testAssembler(c -> c.vrsqrtph(xmm2.k1(), xmmword_ptr(0x0L).base(ecx)), applyK(Instruction.create(Code.EVEX_VRSQRTPH_XMM_K1Z_XMMM128B16, ICRegisters.xmm2, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE)), Register.K1));
	}

	@Test
	void vrsqrtph_ymm_m() {
		testAssembler(c -> c.vrsqrtph(ymm2.k1(), ymmword_ptr(0x0L).base(ecx)), applyK(Instruction.create(Code.EVEX_VRSQRTPH_YMM_K1Z_YMMM256B16, ICRegisters.ymm2, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE)), Register.K1));
	}

	@Test
	void vrsqrtph_zmm_m() {
		testAssembler(c -> c.vrsqrtph(zmm2.k1(), zmmword_ptr(0x0L).base(ecx)), applyK(Instruction.create(Code.EVEX_VRSQRTPH_ZMM_K1Z_ZMMM512B16, ICRegisters.zmm2, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE)), Register.K1));
	}

	@Test
	void vrsqrtps_xmm_xmm() {
		testAssembler(c -> c.vrsqrtps(xmm2, xmm3), Instruction.create(Code.VEX_VRSQRTPS_XMM_XMMM128, ICRegisters.xmm2, ICRegisters.xmm3));
	}

	@Test
	void vrsqrtps_ymm_ymm() {
		testAssembler(c -> c.vrsqrtps(ymm2, ymm3), Instruction.create(Code.VEX_VRSQRTPS_YMM_YMMM256, ICRegisters.ymm2, ICRegisters.ymm3));
	}

	@Test
	void vrsqrtps_xmm_m() {
		testAssembler(c -> c.vrsqrtps(xmm2, xmmword_ptr(0x0L).base(ecx)), Instruction.create(Code.VEX_VRSQRTPS_XMM_XMMM128, ICRegisters.xmm2, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE)));
	}

	@Test
	void vrsqrtps_ymm_m() {
		testAssembler(c -> c.vrsqrtps(ymm2, ymmword_ptr(0x0L).base(ecx)), Instruction.create(Code.VEX_VRSQRTPS_YMM_YMMM256, ICRegisters.ymm2, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE)));
	}

	@Test
	void vrsqrtsh_xmm_xmm_xmm() {
		testAssembler(c -> c.vrsqrtsh(xmm2.k1(), xmm3, xmm4), applyK(Instruction.create(Code.EVEX_VRSQRTSH_XMM_K1Z_XMM_XMMM16, ICRegisters.xmm2, ICRegisters.xmm3, ICRegisters.xmm4), Register.K1));
	}

	@Test
	void vrsqrtsh_xmm_xmm_m() {
		testAssembler(c -> c.vrsqrtsh(xmm2.k1(), xmm3, xmmword_ptr(0x0L).base(ecx)), applyK(Instruction.create(Code.EVEX_VRSQRTSH_XMM_K1Z_XMM_XMMM16, ICRegisters.xmm2, ICRegisters.xmm3, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE)), Register.K1));
	}

	@Test
	void vrsqrtss_xmm_xmm_xmm() {
		testAssembler(c -> c.vrsqrtss(xmm2, xmm3, xmm4), Instruction.create(Code.VEX_VRSQRTSS_XMM_XMM_XMMM32, ICRegisters.xmm2, ICRegisters.xmm3, ICRegisters.xmm4));
	}

	@Test
	void vrsqrtss_xmm_xmm_m() {
		testAssembler(c -> c.vrsqrtss(xmm2, xmm3, xmmword_ptr(0x0L).base(ecx)), Instruction.create(Code.VEX_VRSQRTSS_XMM_XMM_XMMM32, ICRegisters.xmm2, ICRegisters.xmm3, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE)));
	}

}
