// 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 CodeAssembler32GenSTests extends CodeAssemblerTestsBase {
	CodeAssembler32GenSTests() {
		super(32);
	}

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

	@Test
	void sal_r8_r8() {
		testAssembler(c -> c.sal(dl, cl), Instruction.create(Code.SAL_RM8_CL, ICRegisters.dl, ICRegisters.cl));
	}

	@Test
	void sal_r16_r8() {
		testAssembler(c -> c.sal(dx, cl), Instruction.create(Code.SAL_RM16_CL, ICRegisters.dx, ICRegisters.cl));
	}

	@Test
	void sal_r32_r8() {
		testAssembler(c -> c.sal(edx, cl), Instruction.create(Code.SAL_RM32_CL, ICRegisters.edx, ICRegisters.cl));
	}

	@Test
	void sal_m_r8() {
		{ /* if (dst.size == MemoryOperandSize.QWORD) */
			// Skipping SAL_RM64_CL - Not supported by current bitness
		} /* else */ { /* if (dst.size == MemoryOperandSize.DWORD) */
			testAssembler(c -> c.sal(dword_ptr(0x0L).base(edx), cl), Instruction.create(Code.SAL_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.sal(word_ptr(0x0L).base(edx), cl), Instruction.create(Code.SAL_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.sal(byte_ptr(0x0L).base(edx), cl), Instruction.create(Code.SAL_RM8_CL, new MemoryOperand(ICRegisters.edx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), ICRegisters.cl));
		}
		{
			assertInvalid(() -> {
				testAssembler(c -> c.sal(zmmword_ptr(0x0L).base(edx), cl), Instruction.create(Code.SAL_RM8_CL, new MemoryOperand(ICRegisters.edx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), ICRegisters.cl));
			});
		}
	}

	@Test
	void sal_r8_i() {
		{ /* if (imm == 1) */
			testAssembler(c -> c.sal(dl, 1), Instruction.create(Code.SAL_RM8_1, ICRegisters.dl, 1));
		} /* else */ testAssembler(c -> c.sal(dl, 2), Instruction.create(Code.SAL_RM8_IMM8, ICRegisters.dl, 2));
	}

	@Test
	void sal_r16_i() {
		{ /* if (imm == 1) */
			testAssembler(c -> c.sal(dx, 1), Instruction.create(Code.SAL_RM16_1, ICRegisters.dx, 1));
		} /* else */ testAssembler(c -> c.sal(dx, 2), Instruction.create(Code.SAL_RM16_IMM8, ICRegisters.dx, 2));
	}

	@Test
	void sal_r32_i() {
		{ /* if (imm == 1) */
			testAssembler(c -> c.sal(edx, 1), Instruction.create(Code.SAL_RM32_1, ICRegisters.edx, 1));
		} /* else */ testAssembler(c -> c.sal(edx, 2), Instruction.create(Code.SAL_RM32_IMM8, ICRegisters.edx, 2));
	}

	@Test
	void sal_m_i() {
		{ /* if (imm == 1) */
			{ /* if (dst.size == MemoryOperandSize.QWORD) */
				// Skipping SAL_RM64_1 - Not supported by current bitness
			} /* else */ { /* if (dst.size == MemoryOperandSize.DWORD) */
				testAssembler(c -> c.sal(dword_ptr(0x0L).base(edx), 1), Instruction.create(Code.SAL_RM32_1, new MemoryOperand(ICRegisters.edx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), 1));
			} /* else */ { /* if (dst.size == MemoryOperandSize.WORD) */
				testAssembler(c -> c.sal(word_ptr(0x0L).base(edx), 1), Instruction.create(Code.SAL_RM16_1, new MemoryOperand(ICRegisters.edx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), 1));
			} /* else */ { /* if (dst.size == MemoryOperandSize.BYTE) */
				testAssembler(c -> c.sal(byte_ptr(0x0L).base(edx), 1), Instruction.create(Code.SAL_RM8_1, new MemoryOperand(ICRegisters.edx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), 1));
			}
			{
				assertInvalid(() -> {
					testAssembler(c -> c.sal(zmmword_ptr(0x0L).base(edx), 1), Instruction.create(Code.SAL_RM8_1, new MemoryOperand(ICRegisters.edx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), 1));
				});
			}
		} /* else */ { /* if (dst.size == MemoryOperandSize.QWORD) */
			// Skipping SAL_RM64_IMM8 - Not supported by current bitness
		} /* else */ { /* if (dst.size == MemoryOperandSize.DWORD) */
			testAssembler(c -> c.sal(dword_ptr(0x0L).base(edx), 2), Instruction.create(Code.SAL_RM32_IMM8, new MemoryOperand(ICRegisters.edx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), 2));
		} /* else */ { /* if (dst.size == MemoryOperandSize.WORD) */
			testAssembler(c -> c.sal(word_ptr(0x0L).base(edx), 2), Instruction.create(Code.SAL_RM16_IMM8, new MemoryOperand(ICRegisters.edx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), 2));
		} /* else */ { /* if (dst.size == MemoryOperandSize.BYTE) */
			testAssembler(c -> c.sal(byte_ptr(0x0L).base(edx), 2), Instruction.create(Code.SAL_RM8_IMM8, new MemoryOperand(ICRegisters.edx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), 2));
		}
		{
			assertInvalid(() -> {
				testAssembler(c -> c.sal(zmmword_ptr(0x0L).base(edx), 2), Instruction.create(Code.SAL_RM8_IMM8, new MemoryOperand(ICRegisters.edx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), 2));
			});
		}
	}

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

	@Test
	void sar_r8_r8() {
		testAssembler(c -> c.sar(dl, cl), Instruction.create(Code.SAR_RM8_CL, ICRegisters.dl, ICRegisters.cl));
	}

	@Test
	void sar_r16_r8() {
		testAssembler(c -> c.sar(dx, cl), Instruction.create(Code.SAR_RM16_CL, ICRegisters.dx, ICRegisters.cl));
	}

	@Test
	void sar_r32_r8() {
		testAssembler(c -> c.sar(edx, cl), Instruction.create(Code.SAR_RM32_CL, ICRegisters.edx, ICRegisters.cl));
	}

	@Test
	void sar_m_r8() {
		{ /* if (dst.size == MemoryOperandSize.QWORD) */
			// Skipping SAR_RM64_CL - Not supported by current bitness
		} /* else */ { /* if (dst.size == MemoryOperandSize.DWORD) */
			testAssembler(c -> c.sar(dword_ptr(0x0L).base(edx), cl), Instruction.create(Code.SAR_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.sar(word_ptr(0x0L).base(edx), cl), Instruction.create(Code.SAR_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.sar(byte_ptr(0x0L).base(edx), cl), Instruction.create(Code.SAR_RM8_CL, new MemoryOperand(ICRegisters.edx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), ICRegisters.cl));
		}
		{
			assertInvalid(() -> {
				testAssembler(c -> c.sar(zmmword_ptr(0x0L).base(edx), cl), Instruction.create(Code.SAR_RM8_CL, new MemoryOperand(ICRegisters.edx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), ICRegisters.cl));
			});
		}
	}

	@Test
	void sar_r8_i() {
		{ /* if (imm == 1) */
			testAssembler(c -> c.sar(dl, 1), Instruction.create(Code.SAR_RM8_1, ICRegisters.dl, 1));
		} /* else */ testAssembler(c -> c.sar(dl, 2), Instruction.create(Code.SAR_RM8_IMM8, ICRegisters.dl, 2));
	}

	@Test
	void sar_r16_i() {
		{ /* if (imm == 1) */
			testAssembler(c -> c.sar(dx, 1), Instruction.create(Code.SAR_RM16_1, ICRegisters.dx, 1));
		} /* else */ testAssembler(c -> c.sar(dx, 2), Instruction.create(Code.SAR_RM16_IMM8, ICRegisters.dx, 2));
	}

	@Test
	void sar_r32_i() {
		{ /* if (imm == 1) */
			testAssembler(c -> c.sar(edx, 1), Instruction.create(Code.SAR_RM32_1, ICRegisters.edx, 1));
		} /* else */ testAssembler(c -> c.sar(edx, 2), Instruction.create(Code.SAR_RM32_IMM8, ICRegisters.edx, 2));
	}

	@Test
	void sar_m_i() {
		{ /* if (imm == 1) */
			{ /* if (dst.size == MemoryOperandSize.QWORD) */
				// Skipping SAR_RM64_1 - Not supported by current bitness
			} /* else */ { /* if (dst.size == MemoryOperandSize.DWORD) */
				testAssembler(c -> c.sar(dword_ptr(0x0L).base(edx), 1), Instruction.create(Code.SAR_RM32_1, new MemoryOperand(ICRegisters.edx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), 1));
			} /* else */ { /* if (dst.size == MemoryOperandSize.WORD) */
				testAssembler(c -> c.sar(word_ptr(0x0L).base(edx), 1), Instruction.create(Code.SAR_RM16_1, new MemoryOperand(ICRegisters.edx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), 1));
			} /* else */ { /* if (dst.size == MemoryOperandSize.BYTE) */
				testAssembler(c -> c.sar(byte_ptr(0x0L).base(edx), 1), Instruction.create(Code.SAR_RM8_1, new MemoryOperand(ICRegisters.edx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), 1));
			}
			{
				assertInvalid(() -> {
					testAssembler(c -> c.sar(zmmword_ptr(0x0L).base(edx), 1), Instruction.create(Code.SAR_RM8_1, new MemoryOperand(ICRegisters.edx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), 1));
				});
			}
		} /* else */ { /* if (dst.size == MemoryOperandSize.QWORD) */
			// Skipping SAR_RM64_IMM8 - Not supported by current bitness
		} /* else */ { /* if (dst.size == MemoryOperandSize.DWORD) */
			testAssembler(c -> c.sar(dword_ptr(0x0L).base(edx), 2), Instruction.create(Code.SAR_RM32_IMM8, new MemoryOperand(ICRegisters.edx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), 2));
		} /* else */ { /* if (dst.size == MemoryOperandSize.WORD) */
			testAssembler(c -> c.sar(word_ptr(0x0L).base(edx), 2), Instruction.create(Code.SAR_RM16_IMM8, new MemoryOperand(ICRegisters.edx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), 2));
		} /* else */ { /* if (dst.size == MemoryOperandSize.BYTE) */
			testAssembler(c -> c.sar(byte_ptr(0x0L).base(edx), 2), Instruction.create(Code.SAR_RM8_IMM8, new MemoryOperand(ICRegisters.edx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), 2));
		}
		{
			assertInvalid(() -> {
				testAssembler(c -> c.sar(zmmword_ptr(0x0L).base(edx), 2), Instruction.create(Code.SAR_RM8_IMM8, new MemoryOperand(ICRegisters.edx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), 2));
			});
		}
	}

	@Test
	void sarx_r32_r32_r32() {
		testAssembler(c -> c.sarx(edx, ebx, esp), Instruction.create(Code.VEX_SARX_R32_RM32_R32, ICRegisters.edx, ICRegisters.ebx, ICRegisters.esp));
	}

	@Test
	void sarx_r32_m_r32() {
		testAssembler(c -> c.sarx(edx, dword_ptr(0x0L).base(ecx), esp), Instruction.create(Code.VEX_SARX_R32_RM32_R32, ICRegisters.edx, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), ICRegisters.esp));
	}

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

	@Test
	void sbb_r8_r8() {
		testAssembler(c -> c.sbb(dl, bl), Instruction.create(Code.SBB_RM8_R8, ICRegisters.dl, ICRegisters.bl));
	}

	@Test
	void sbb_m_r8() {
		testAssembler(c -> c.sbb(byte_ptr(0x0L).base(ecx), bl), Instruction.create(Code.SBB_RM8_R8, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), ICRegisters.bl));
	}

	@Test
	void sbb_r16_r16() {
		testAssembler(c -> c.sbb(dx, bx), Instruction.create(Code.SBB_RM16_R16, ICRegisters.dx, ICRegisters.bx));
	}

	@Test
	void sbb_m_r16() {
		testAssembler(c -> c.sbb(word_ptr(0x0L).base(ecx), bx), Instruction.create(Code.SBB_RM16_R16, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), ICRegisters.bx));
	}

	@Test
	void sbb_r32_r32() {
		testAssembler(c -> c.sbb(edx, ebx), Instruction.create(Code.SBB_RM32_R32, ICRegisters.edx, ICRegisters.ebx));
	}

	@Test
	void sbb_m_r32() {
		testAssembler(c -> c.sbb(dword_ptr(0x0L).base(ecx), ebx), Instruction.create(Code.SBB_RM32_R32, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), ICRegisters.ebx));
	}

	@Test
	void sbb_r8_m() {
		testAssembler(c -> c.sbb(dl, byte_ptr(0x0L).base(ecx)), Instruction.create(Code.SBB_R8_RM8, ICRegisters.dl, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE)));
	}

	@Test
	void sbb_r16_m() {
		testAssembler(c -> c.sbb(dx, word_ptr(0x0L).base(ecx)), Instruction.create(Code.SBB_R16_RM16, ICRegisters.dx, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE)));
	}

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

	@Test
	void sbb_r8_i() {
		{ /* if (dst.getRegister() == Register.AL) */
			testAssembler(c -> c.sbb(al, -5), Instruction.create(Code.SBB_AL_IMM8, ICRegisters.al, -5));
		} /* else */ testAssembler(c -> c.sbb(dl, -5), Instruction.create(Code.SBB_RM8_IMM8, ICRegisters.dl, -5));
	}

	@Test
	void sbb_r16_i() {
		{ /* if (dst.getRegister() == Register.AX) */
			testAssembler(c -> c.sbb(ax, 0x40B7), Instruction.create(Code.SBB_AX_IMM16, ICRegisters.ax, 0x40B7));
		} /* else */ { /* if (imm >= -0x80 && imm <= 0x7F) */
			testAssembler(c -> c.sbb(dx, -0x80), Instruction.create(Code.SBB_RM16_IMM8, ICRegisters.dx, -0x80));
			testAssembler(c -> c.sbb(dx, 0x7F), Instruction.create(Code.SBB_RM16_IMM8, ICRegisters.dx, 0x7F));
		} /* else */ testAssembler(c -> c.sbb(dx, 0x40B7), Instruction.create(Code.SBB_RM16_IMM16, ICRegisters.dx, 0x40B7));
	}

	@Test
	void sbb_r32_i() {
		{ /* if (dst.getRegister() == Register.EAX) */
			testAssembler(c -> c.sbb(eax, 0x7FFFFFFF), Instruction.create(Code.SBB_EAX_IMM32, ICRegisters.eax, 0x7FFFFFFF));
		} /* else */ { /* if (imm >= -0x80 && imm <= 0x7F) */
			testAssembler(c -> c.sbb(edx, -0x80), Instruction.create(Code.SBB_RM32_IMM8, ICRegisters.edx, -0x80));
			testAssembler(c -> c.sbb(edx, 0x7F), Instruction.create(Code.SBB_RM32_IMM8, ICRegisters.edx, 0x7F));
		} /* else */ testAssembler(c -> c.sbb(edx, 0x7FFFFFFF), Instruction.create(Code.SBB_RM32_IMM32, ICRegisters.edx, 0x7FFFFFFF));
	}

	@Test
	void sbb_m_i() {
		{ /* if (dst.size == MemoryOperandSize.QWORD) */
			{ /* if (imm >= -0x80 && imm <= 0x7F) */
				// Skipping SBB_RM64_IMM8 - Not supported by current bitness
				// Skipping SBB_RM64_IMM8 - Not supported by current bitness
			} /* else */ // Skipping SBB_RM64_IMM32 - Not supported by current bitness
		} /* else */ { /* if (dst.size == MemoryOperandSize.DWORD) */
			{ /* if (imm >= -0x80 && imm <= 0x7F) */
				testAssembler(c -> c.sbb(dword_ptr(0x0L).base(edx), -0x80), Instruction.create(Code.SBB_RM32_IMM8, new MemoryOperand(ICRegisters.edx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), -0x80));
				testAssembler(c -> c.sbb(dword_ptr(0x0L).base(edx), 0x7F), Instruction.create(Code.SBB_RM32_IMM8, new MemoryOperand(ICRegisters.edx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), 0x7F));
			} /* else */ testAssembler(c -> c.sbb(dword_ptr(0x0L).base(edx), 0x7FFFFFFF), Instruction.create(Code.SBB_RM32_IMM32, new MemoryOperand(ICRegisters.edx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), 0x7FFFFFFF));
		} /* else */ { /* if (dst.size == MemoryOperandSize.WORD) */
			{ /* if (imm >= -0x80 && imm <= 0x7F) */
				testAssembler(c -> c.sbb(word_ptr(0x0L).base(edx), -0x80), Instruction.create(Code.SBB_RM16_IMM8, new MemoryOperand(ICRegisters.edx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), -0x80));
				testAssembler(c -> c.sbb(word_ptr(0x0L).base(edx), 0x7F), Instruction.create(Code.SBB_RM16_IMM8, new MemoryOperand(ICRegisters.edx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), 0x7F));
			} /* else */ testAssembler(c -> c.sbb(word_ptr(0x0L).base(edx), 0x40B7), Instruction.create(Code.SBB_RM16_IMM16, new MemoryOperand(ICRegisters.edx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), 0x40B7));
		} /* else */ { /* if (dst.size == MemoryOperandSize.BYTE) */
			testAssembler(c -> c.sbb(byte_ptr(0x0L).base(edx), -5), Instruction.create(Code.SBB_RM8_IMM8, new MemoryOperand(ICRegisters.edx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), -5));
		}
		{
			assertInvalid(() -> {
				testAssembler(c -> c.sbb(zmmword_ptr(0x0L).base(edx), -5), Instruction.create(Code.SBB_RM8_IMM8, new MemoryOperand(ICRegisters.edx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), -5));
			});
		}
	}

	@Test
	void scasb() {
		testAssembler(c -> c.scasb(), Instruction.createScasb(32));
	}

	@Test
	void scasd() {
		testAssembler(c -> c.scasd(), Instruction.createScasd(32));
	}

	@Test
	void scasw() {
		testAssembler(c -> c.scasw(), Instruction.createScasw(32));
	}

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

	@Test
	void seta_r8() {
		testAssembler(c -> c.seta(dl), Instruction.create(Code.SETA_RM8, ICRegisters.dl));
	}

	@Test
	void seta_m() {
		testAssembler(c -> c.seta(byte_ptr(0x0L).base(ecx)), Instruction.create(Code.SETA_RM8, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE)));
	}

	@Test
	void setae_r8() {
		testAssembler(c -> c.setae(dl), Instruction.create(Code.SETAE_RM8, ICRegisters.dl));
	}

	@Test
	void setae_m() {
		testAssembler(c -> c.setae(byte_ptr(0x0L).base(ecx)), Instruction.create(Code.SETAE_RM8, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE)));
	}

	@Test
	void setb_r8() {
		testAssembler(c -> c.setb(dl), Instruction.create(Code.SETB_RM8, ICRegisters.dl));
	}

	@Test
	void setb_m() {
		testAssembler(c -> c.setb(byte_ptr(0x0L).base(ecx)), Instruction.create(Code.SETB_RM8, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE)));
	}

	@Test
	void setbe_r8() {
		testAssembler(c -> c.setbe(dl), Instruction.create(Code.SETBE_RM8, ICRegisters.dl));
	}

	@Test
	void setbe_m() {
		testAssembler(c -> c.setbe(byte_ptr(0x0L).base(ecx)), Instruction.create(Code.SETBE_RM8, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE)));
	}

	@Test
	void setc_r8() {
		testAssembler(c -> c.setc(dl), Instruction.create(Code.SETB_RM8, ICRegisters.dl));
	}

	@Test
	void setc_m() {
		testAssembler(c -> c.setc(byte_ptr(0x0L).base(ecx)), Instruction.create(Code.SETB_RM8, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE)));
	}

	@Test
	void sete_r8() {
		testAssembler(c -> c.sete(dl), Instruction.create(Code.SETE_RM8, ICRegisters.dl));
	}

	@Test
	void sete_m() {
		testAssembler(c -> c.sete(byte_ptr(0x0L).base(ecx)), Instruction.create(Code.SETE_RM8, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE)));
	}

	@Test
	void setg_r8() {
		testAssembler(c -> c.setg(dl), Instruction.create(Code.SETG_RM8, ICRegisters.dl));
	}

	@Test
	void setg_m() {
		testAssembler(c -> c.setg(byte_ptr(0x0L).base(ecx)), Instruction.create(Code.SETG_RM8, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE)));
	}

	@Test
	void setge_r8() {
		testAssembler(c -> c.setge(dl), Instruction.create(Code.SETGE_RM8, ICRegisters.dl));
	}

	@Test
	void setge_m() {
		testAssembler(c -> c.setge(byte_ptr(0x0L).base(ecx)), Instruction.create(Code.SETGE_RM8, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE)));
	}

	@Test
	void setl_r8() {
		testAssembler(c -> c.setl(dl), Instruction.create(Code.SETL_RM8, ICRegisters.dl));
	}

	@Test
	void setl_m() {
		testAssembler(c -> c.setl(byte_ptr(0x0L).base(ecx)), Instruction.create(Code.SETL_RM8, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE)));
	}

	@Test
	void setle_r8() {
		testAssembler(c -> c.setle(dl), Instruction.create(Code.SETLE_RM8, ICRegisters.dl));
	}

	@Test
	void setle_m() {
		testAssembler(c -> c.setle(byte_ptr(0x0L).base(ecx)), Instruction.create(Code.SETLE_RM8, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE)));
	}

	@Test
	void setna_r8() {
		testAssembler(c -> c.setna(dl), Instruction.create(Code.SETBE_RM8, ICRegisters.dl));
	}

	@Test
	void setna_m() {
		testAssembler(c -> c.setna(byte_ptr(0x0L).base(ecx)), Instruction.create(Code.SETBE_RM8, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE)));
	}

	@Test
	void setnae_r8() {
		testAssembler(c -> c.setnae(dl), Instruction.create(Code.SETB_RM8, ICRegisters.dl));
	}

	@Test
	void setnae_m() {
		testAssembler(c -> c.setnae(byte_ptr(0x0L).base(ecx)), Instruction.create(Code.SETB_RM8, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE)));
	}

	@Test
	void setnb_r8() {
		testAssembler(c -> c.setnb(dl), Instruction.create(Code.SETAE_RM8, ICRegisters.dl));
	}

	@Test
	void setnb_m() {
		testAssembler(c -> c.setnb(byte_ptr(0x0L).base(ecx)), Instruction.create(Code.SETAE_RM8, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE)));
	}

	@Test
	void setnbe_r8() {
		testAssembler(c -> c.setnbe(dl), Instruction.create(Code.SETA_RM8, ICRegisters.dl));
	}

	@Test
	void setnbe_m() {
		testAssembler(c -> c.setnbe(byte_ptr(0x0L).base(ecx)), Instruction.create(Code.SETA_RM8, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE)));
	}

	@Test
	void setnc_r8() {
		testAssembler(c -> c.setnc(dl), Instruction.create(Code.SETAE_RM8, ICRegisters.dl));
	}

	@Test
	void setnc_m() {
		testAssembler(c -> c.setnc(byte_ptr(0x0L).base(ecx)), Instruction.create(Code.SETAE_RM8, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE)));
	}

	@Test
	void setne_r8() {
		testAssembler(c -> c.setne(dl), Instruction.create(Code.SETNE_RM8, ICRegisters.dl));
	}

	@Test
	void setne_m() {
		testAssembler(c -> c.setne(byte_ptr(0x0L).base(ecx)), Instruction.create(Code.SETNE_RM8, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE)));
	}

	@Test
	void setng_r8() {
		testAssembler(c -> c.setng(dl), Instruction.create(Code.SETLE_RM8, ICRegisters.dl));
	}

	@Test
	void setng_m() {
		testAssembler(c -> c.setng(byte_ptr(0x0L).base(ecx)), Instruction.create(Code.SETLE_RM8, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE)));
	}

	@Test
	void setnge_r8() {
		testAssembler(c -> c.setnge(dl), Instruction.create(Code.SETL_RM8, ICRegisters.dl));
	}

	@Test
	void setnge_m() {
		testAssembler(c -> c.setnge(byte_ptr(0x0L).base(ecx)), Instruction.create(Code.SETL_RM8, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE)));
	}

	@Test
	void setnl_r8() {
		testAssembler(c -> c.setnl(dl), Instruction.create(Code.SETGE_RM8, ICRegisters.dl));
	}

	@Test
	void setnl_m() {
		testAssembler(c -> c.setnl(byte_ptr(0x0L).base(ecx)), Instruction.create(Code.SETGE_RM8, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE)));
	}

	@Test
	void setnle_r8() {
		testAssembler(c -> c.setnle(dl), Instruction.create(Code.SETG_RM8, ICRegisters.dl));
	}

	@Test
	void setnle_m() {
		testAssembler(c -> c.setnle(byte_ptr(0x0L).base(ecx)), Instruction.create(Code.SETG_RM8, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE)));
	}

	@Test
	void setno_r8() {
		testAssembler(c -> c.setno(dl), Instruction.create(Code.SETNO_RM8, ICRegisters.dl));
	}

	@Test
	void setno_m() {
		testAssembler(c -> c.setno(byte_ptr(0x0L).base(ecx)), Instruction.create(Code.SETNO_RM8, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE)));
	}

	@Test
	void setnp_r8() {
		testAssembler(c -> c.setnp(dl), Instruction.create(Code.SETNP_RM8, ICRegisters.dl));
	}

	@Test
	void setnp_m() {
		testAssembler(c -> c.setnp(byte_ptr(0x0L).base(ecx)), Instruction.create(Code.SETNP_RM8, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE)));
	}

	@Test
	void setns_r8() {
		testAssembler(c -> c.setns(dl), Instruction.create(Code.SETNS_RM8, ICRegisters.dl));
	}

	@Test
	void setns_m() {
		testAssembler(c -> c.setns(byte_ptr(0x0L).base(ecx)), Instruction.create(Code.SETNS_RM8, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE)));
	}

	@Test
	void setnz_r8() {
		testAssembler(c -> c.setnz(dl), Instruction.create(Code.SETNE_RM8, ICRegisters.dl));
	}

	@Test
	void setnz_m() {
		testAssembler(c -> c.setnz(byte_ptr(0x0L).base(ecx)), Instruction.create(Code.SETNE_RM8, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE)));
	}

	@Test
	void seto_r8() {
		testAssembler(c -> c.seto(dl), Instruction.create(Code.SETO_RM8, ICRegisters.dl));
	}

	@Test
	void seto_m() {
		testAssembler(c -> c.seto(byte_ptr(0x0L).base(ecx)), Instruction.create(Code.SETO_RM8, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE)));
	}

	@Test
	void setp_r8() {
		testAssembler(c -> c.setp(dl), Instruction.create(Code.SETP_RM8, ICRegisters.dl));
	}

	@Test
	void setp_m() {
		testAssembler(c -> c.setp(byte_ptr(0x0L).base(ecx)), Instruction.create(Code.SETP_RM8, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE)));
	}

	@Test
	void setpe_r8() {
		testAssembler(c -> c.setpe(dl), Instruction.create(Code.SETP_RM8, ICRegisters.dl));
	}

	@Test
	void setpe_m() {
		testAssembler(c -> c.setpe(byte_ptr(0x0L).base(ecx)), Instruction.create(Code.SETP_RM8, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE)));
	}

	@Test
	void setpo_r8() {
		testAssembler(c -> c.setpo(dl), Instruction.create(Code.SETNP_RM8, ICRegisters.dl));
	}

	@Test
	void setpo_m() {
		testAssembler(c -> c.setpo(byte_ptr(0x0L).base(ecx)), Instruction.create(Code.SETNP_RM8, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE)));
	}

	@Test
	void sets_r8() {
		testAssembler(c -> c.sets(dl), Instruction.create(Code.SETS_RM8, ICRegisters.dl));
	}

	@Test
	void sets_m() {
		testAssembler(c -> c.sets(byte_ptr(0x0L).base(ecx)), Instruction.create(Code.SETS_RM8, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE)));
	}

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

	@Test
	void setz_r8() {
		testAssembler(c -> c.setz(dl), Instruction.create(Code.SETE_RM8, ICRegisters.dl));
	}

	@Test
	void setz_m() {
		testAssembler(c -> c.setz(byte_ptr(0x0L).base(ecx)), Instruction.create(Code.SETE_RM8, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE)));
	}

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

	@Test
	void sgdt_m() {
		{ // skip (getBitness() == 64) not supported by this CodeAssembler bitness
		} /* else */ { /* if (getBitness() >= 32) */
			testAssembler(c -> c.sgdt(mem_ptr(0x0L).base(ecx)), Instruction.create(Code.SGDT_M1632, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE)));
		} /* else skip !(getBitness() >= 32) not supported by this CodeAssembler bitness */
	}

	@Test
	void sha1msg1_xmm_xmm() {
		testAssembler(c -> c.sha1msg1(xmm2, xmm3), Instruction.create(Code.SHA1MSG1_XMM_XMMM128, ICRegisters.xmm2, ICRegisters.xmm3));
	}

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

	@Test
	void sha1msg2_xmm_xmm() {
		testAssembler(c -> c.sha1msg2(xmm2, xmm3), Instruction.create(Code.SHA1MSG2_XMM_XMMM128, ICRegisters.xmm2, ICRegisters.xmm3));
	}

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

	@Test
	void sha1nexte_xmm_xmm() {
		testAssembler(c -> c.sha1nexte(xmm2, xmm3), Instruction.create(Code.SHA1NEXTE_XMM_XMMM128, ICRegisters.xmm2, ICRegisters.xmm3));
	}

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

	@Test
	void sha1rnds4_xmm_xmm_i() {
		testAssembler(c -> c.sha1rnds4(xmm2, xmm3, -5), Instruction.create(Code.SHA1RNDS4_XMM_XMMM128_IMM8, ICRegisters.xmm2, ICRegisters.xmm3, -5));
	}

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

	@Test
	void sha256msg1_xmm_xmm() {
		testAssembler(c -> c.sha256msg1(xmm2, xmm3), Instruction.create(Code.SHA256MSG1_XMM_XMMM128, ICRegisters.xmm2, ICRegisters.xmm3));
	}

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

	@Test
	void sha256msg2_xmm_xmm() {
		testAssembler(c -> c.sha256msg2(xmm2, xmm3), Instruction.create(Code.SHA256MSG2_XMM_XMMM128, ICRegisters.xmm2, ICRegisters.xmm3));
	}

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

	@Test
	void sha256rnds2_xmm_xmm() {
		testAssembler(c -> c.sha256rnds2(xmm2, xmm3), Instruction.create(Code.SHA256RNDS2_XMM_XMMM128, ICRegisters.xmm2, ICRegisters.xmm3));
	}

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

	@Test
	void shl_r8_r8() {
		testAssembler(c -> c.shl(dl, cl), Instruction.create(Code.SHL_RM8_CL, ICRegisters.dl, ICRegisters.cl));
	}

	@Test
	void shl_r16_r8() {
		testAssembler(c -> c.shl(dx, cl), Instruction.create(Code.SHL_RM16_CL, ICRegisters.dx, ICRegisters.cl));
	}

	@Test
	void shl_r32_r8() {
		testAssembler(c -> c.shl(edx, cl), Instruction.create(Code.SHL_RM32_CL, ICRegisters.edx, ICRegisters.cl));
	}

	@Test
	void shl_m_r8() {
		{ /* if (dst.size == MemoryOperandSize.QWORD) */
			// Skipping SHL_RM64_CL - Not supported by current bitness
		} /* else */ { /* if (dst.size == MemoryOperandSize.DWORD) */
			testAssembler(c -> c.shl(dword_ptr(0x0L).base(edx), cl), Instruction.create(Code.SHL_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.shl(word_ptr(0x0L).base(edx), cl), Instruction.create(Code.SHL_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.shl(byte_ptr(0x0L).base(edx), cl), Instruction.create(Code.SHL_RM8_CL, new MemoryOperand(ICRegisters.edx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), ICRegisters.cl));
		}
		{
			assertInvalid(() -> {
				testAssembler(c -> c.shl(zmmword_ptr(0x0L).base(edx), cl), Instruction.create(Code.SHL_RM8_CL, new MemoryOperand(ICRegisters.edx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), ICRegisters.cl));
			});
		}
	}

	@Test
	void shl_r8_i() {
		{ /* if (imm == 1) */
			testAssembler(c -> c.shl(dl, 1), Instruction.create(Code.SHL_RM8_1, ICRegisters.dl, 1));
		} /* else */ testAssembler(c -> c.shl(dl, 2), Instruction.create(Code.SHL_RM8_IMM8, ICRegisters.dl, 2));
	}

	@Test
	void shl_r16_i() {
		{ /* if (imm == 1) */
			testAssembler(c -> c.shl(dx, 1), Instruction.create(Code.SHL_RM16_1, ICRegisters.dx, 1));
		} /* else */ testAssembler(c -> c.shl(dx, 2), Instruction.create(Code.SHL_RM16_IMM8, ICRegisters.dx, 2));
	}

	@Test
	void shl_r32_i() {
		{ /* if (imm == 1) */
			testAssembler(c -> c.shl(edx, 1), Instruction.create(Code.SHL_RM32_1, ICRegisters.edx, 1));
		} /* else */ testAssembler(c -> c.shl(edx, 2), Instruction.create(Code.SHL_RM32_IMM8, ICRegisters.edx, 2));
	}

	@Test
	void shl_m_i() {
		{ /* if (imm == 1) */
			{ /* if (dst.size == MemoryOperandSize.QWORD) */
				// Skipping SHL_RM64_1 - Not supported by current bitness
			} /* else */ { /* if (dst.size == MemoryOperandSize.DWORD) */
				testAssembler(c -> c.shl(dword_ptr(0x0L).base(edx), 1), Instruction.create(Code.SHL_RM32_1, new MemoryOperand(ICRegisters.edx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), 1));
			} /* else */ { /* if (dst.size == MemoryOperandSize.WORD) */
				testAssembler(c -> c.shl(word_ptr(0x0L).base(edx), 1), Instruction.create(Code.SHL_RM16_1, new MemoryOperand(ICRegisters.edx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), 1));
			} /* else */ { /* if (dst.size == MemoryOperandSize.BYTE) */
				testAssembler(c -> c.shl(byte_ptr(0x0L).base(edx), 1), Instruction.create(Code.SHL_RM8_1, new MemoryOperand(ICRegisters.edx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), 1));
			}
			{
				assertInvalid(() -> {
					testAssembler(c -> c.shl(zmmword_ptr(0x0L).base(edx), 1), Instruction.create(Code.SHL_RM8_1, new MemoryOperand(ICRegisters.edx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), 1));
				});
			}
		} /* else */ { /* if (dst.size == MemoryOperandSize.QWORD) */
			// Skipping SHL_RM64_IMM8 - Not supported by current bitness
		} /* else */ { /* if (dst.size == MemoryOperandSize.DWORD) */
			testAssembler(c -> c.shl(dword_ptr(0x0L).base(edx), 2), Instruction.create(Code.SHL_RM32_IMM8, new MemoryOperand(ICRegisters.edx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), 2));
		} /* else */ { /* if (dst.size == MemoryOperandSize.WORD) */
			testAssembler(c -> c.shl(word_ptr(0x0L).base(edx), 2), Instruction.create(Code.SHL_RM16_IMM8, new MemoryOperand(ICRegisters.edx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), 2));
		} /* else */ { /* if (dst.size == MemoryOperandSize.BYTE) */
			testAssembler(c -> c.shl(byte_ptr(0x0L).base(edx), 2), Instruction.create(Code.SHL_RM8_IMM8, new MemoryOperand(ICRegisters.edx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), 2));
		}
		{
			assertInvalid(() -> {
				testAssembler(c -> c.shl(zmmword_ptr(0x0L).base(edx), 2), Instruction.create(Code.SHL_RM8_IMM8, new MemoryOperand(ICRegisters.edx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), 2));
			});
		}
	}

	@Test
	void shld_r16_r16_r8() {
		testAssembler(c -> c.shld(dx, bx, cl), Instruction.create(Code.SHLD_RM16_R16_CL, ICRegisters.dx, ICRegisters.bx, ICRegisters.cl));
	}

	@Test
	void shld_m_r16_r8() {
		testAssembler(c -> c.shld(word_ptr(0x0L).base(ecx), bx, cl), Instruction.create(Code.SHLD_RM16_R16_CL, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), ICRegisters.bx, ICRegisters.cl));
	}

	@Test
	void shld_r32_r32_r8() {
		testAssembler(c -> c.shld(edx, ebx, cl), Instruction.create(Code.SHLD_RM32_R32_CL, ICRegisters.edx, ICRegisters.ebx, ICRegisters.cl));
	}

	@Test
	void shld_m_r32_r8() {
		testAssembler(c -> c.shld(dword_ptr(0x0L).base(ecx), ebx, cl), Instruction.create(Code.SHLD_RM32_R32_CL, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), ICRegisters.ebx, ICRegisters.cl));
	}

	@Test
	void shld_r16_r16_i() {
		testAssembler(c -> c.shld(dx, bx, -5), Instruction.create(Code.SHLD_RM16_R16_IMM8, ICRegisters.dx, ICRegisters.bx, -5));
	}

	@Test
	void shld_m_r16_i() {
		testAssembler(c -> c.shld(word_ptr(0x0L).base(ecx), bx, -5), Instruction.create(Code.SHLD_RM16_R16_IMM8, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), ICRegisters.bx, -5));
	}

	@Test
	void shld_r32_r32_i() {
		testAssembler(c -> c.shld(edx, ebx, -5), Instruction.create(Code.SHLD_RM32_R32_IMM8, ICRegisters.edx, ICRegisters.ebx, -5));
	}

	@Test
	void shld_m_r32_i() {
		testAssembler(c -> c.shld(dword_ptr(0x0L).base(ecx), ebx, -5), Instruction.create(Code.SHLD_RM32_R32_IMM8, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), ICRegisters.ebx, -5));
	}

	@Test
	void shlx_r32_r32_r32() {
		testAssembler(c -> c.shlx(edx, ebx, esp), Instruction.create(Code.VEX_SHLX_R32_RM32_R32, ICRegisters.edx, ICRegisters.ebx, ICRegisters.esp));
	}

	@Test
	void shlx_r32_m_r32() {
		testAssembler(c -> c.shlx(edx, dword_ptr(0x0L).base(ecx), esp), Instruction.create(Code.VEX_SHLX_R32_RM32_R32, ICRegisters.edx, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), ICRegisters.esp));
	}

	@Test
	void shr_r8_r8() {
		testAssembler(c -> c.shr(dl, cl), Instruction.create(Code.SHR_RM8_CL, ICRegisters.dl, ICRegisters.cl));
	}

	@Test
	void shr_r16_r8() {
		testAssembler(c -> c.shr(dx, cl), Instruction.create(Code.SHR_RM16_CL, ICRegisters.dx, ICRegisters.cl));
	}

	@Test
	void shr_r32_r8() {
		testAssembler(c -> c.shr(edx, cl), Instruction.create(Code.SHR_RM32_CL, ICRegisters.edx, ICRegisters.cl));
	}

	@Test
	void shr_m_r8() {
		{ /* if (dst.size == MemoryOperandSize.QWORD) */
			// Skipping SHR_RM64_CL - Not supported by current bitness
		} /* else */ { /* if (dst.size == MemoryOperandSize.DWORD) */
			testAssembler(c -> c.shr(dword_ptr(0x0L).base(edx), cl), Instruction.create(Code.SHR_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.shr(word_ptr(0x0L).base(edx), cl), Instruction.create(Code.SHR_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.shr(byte_ptr(0x0L).base(edx), cl), Instruction.create(Code.SHR_RM8_CL, new MemoryOperand(ICRegisters.edx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), ICRegisters.cl));
		}
		{
			assertInvalid(() -> {
				testAssembler(c -> c.shr(zmmword_ptr(0x0L).base(edx), cl), Instruction.create(Code.SHR_RM8_CL, new MemoryOperand(ICRegisters.edx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), ICRegisters.cl));
			});
		}
	}

	@Test
	void shr_r8_i() {
		{ /* if (imm == 1) */
			testAssembler(c -> c.shr(dl, 1), Instruction.create(Code.SHR_RM8_1, ICRegisters.dl, 1));
		} /* else */ testAssembler(c -> c.shr(dl, 2), Instruction.create(Code.SHR_RM8_IMM8, ICRegisters.dl, 2));
	}

	@Test
	void shr_r16_i() {
		{ /* if (imm == 1) */
			testAssembler(c -> c.shr(dx, 1), Instruction.create(Code.SHR_RM16_1, ICRegisters.dx, 1));
		} /* else */ testAssembler(c -> c.shr(dx, 2), Instruction.create(Code.SHR_RM16_IMM8, ICRegisters.dx, 2));
	}

	@Test
	void shr_r32_i() {
		{ /* if (imm == 1) */
			testAssembler(c -> c.shr(edx, 1), Instruction.create(Code.SHR_RM32_1, ICRegisters.edx, 1));
		} /* else */ testAssembler(c -> c.shr(edx, 2), Instruction.create(Code.SHR_RM32_IMM8, ICRegisters.edx, 2));
	}

	@Test
	void shr_m_i() {
		{ /* if (imm == 1) */
			{ /* if (dst.size == MemoryOperandSize.QWORD) */
				// Skipping SHR_RM64_1 - Not supported by current bitness
			} /* else */ { /* if (dst.size == MemoryOperandSize.DWORD) */
				testAssembler(c -> c.shr(dword_ptr(0x0L).base(edx), 1), Instruction.create(Code.SHR_RM32_1, new MemoryOperand(ICRegisters.edx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), 1));
			} /* else */ { /* if (dst.size == MemoryOperandSize.WORD) */
				testAssembler(c -> c.shr(word_ptr(0x0L).base(edx), 1), Instruction.create(Code.SHR_RM16_1, new MemoryOperand(ICRegisters.edx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), 1));
			} /* else */ { /* if (dst.size == MemoryOperandSize.BYTE) */
				testAssembler(c -> c.shr(byte_ptr(0x0L).base(edx), 1), Instruction.create(Code.SHR_RM8_1, new MemoryOperand(ICRegisters.edx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), 1));
			}
			{
				assertInvalid(() -> {
					testAssembler(c -> c.shr(zmmword_ptr(0x0L).base(edx), 1), Instruction.create(Code.SHR_RM8_1, new MemoryOperand(ICRegisters.edx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), 1));
				});
			}
		} /* else */ { /* if (dst.size == MemoryOperandSize.QWORD) */
			// Skipping SHR_RM64_IMM8 - Not supported by current bitness
		} /* else */ { /* if (dst.size == MemoryOperandSize.DWORD) */
			testAssembler(c -> c.shr(dword_ptr(0x0L).base(edx), 2), Instruction.create(Code.SHR_RM32_IMM8, new MemoryOperand(ICRegisters.edx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), 2));
		} /* else */ { /* if (dst.size == MemoryOperandSize.WORD) */
			testAssembler(c -> c.shr(word_ptr(0x0L).base(edx), 2), Instruction.create(Code.SHR_RM16_IMM8, new MemoryOperand(ICRegisters.edx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), 2));
		} /* else */ { /* if (dst.size == MemoryOperandSize.BYTE) */
			testAssembler(c -> c.shr(byte_ptr(0x0L).base(edx), 2), Instruction.create(Code.SHR_RM8_IMM8, new MemoryOperand(ICRegisters.edx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), 2));
		}
		{
			assertInvalid(() -> {
				testAssembler(c -> c.shr(zmmword_ptr(0x0L).base(edx), 2), Instruction.create(Code.SHR_RM8_IMM8, new MemoryOperand(ICRegisters.edx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), 2));
			});
		}
	}

	@Test
	void shrd_r16_r16_r8() {
		testAssembler(c -> c.shrd(dx, bx, cl), Instruction.create(Code.SHRD_RM16_R16_CL, ICRegisters.dx, ICRegisters.bx, ICRegisters.cl));
	}

	@Test
	void shrd_m_r16_r8() {
		testAssembler(c -> c.shrd(word_ptr(0x0L).base(ecx), bx, cl), Instruction.create(Code.SHRD_RM16_R16_CL, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), ICRegisters.bx, ICRegisters.cl));
	}

	@Test
	void shrd_r32_r32_r8() {
		testAssembler(c -> c.shrd(edx, ebx, cl), Instruction.create(Code.SHRD_RM32_R32_CL, ICRegisters.edx, ICRegisters.ebx, ICRegisters.cl));
	}

	@Test
	void shrd_m_r32_r8() {
		testAssembler(c -> c.shrd(dword_ptr(0x0L).base(ecx), ebx, cl), Instruction.create(Code.SHRD_RM32_R32_CL, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), ICRegisters.ebx, ICRegisters.cl));
	}

	@Test
	void shrd_r16_r16_i() {
		testAssembler(c -> c.shrd(dx, bx, -5), Instruction.create(Code.SHRD_RM16_R16_IMM8, ICRegisters.dx, ICRegisters.bx, -5));
	}

	@Test
	void shrd_m_r16_i() {
		testAssembler(c -> c.shrd(word_ptr(0x0L).base(ecx), bx, -5), Instruction.create(Code.SHRD_RM16_R16_IMM8, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), ICRegisters.bx, -5));
	}

	@Test
	void shrd_r32_r32_i() {
		testAssembler(c -> c.shrd(edx, ebx, -5), Instruction.create(Code.SHRD_RM32_R32_IMM8, ICRegisters.edx, ICRegisters.ebx, -5));
	}

	@Test
	void shrd_m_r32_i() {
		testAssembler(c -> c.shrd(dword_ptr(0x0L).base(ecx), ebx, -5), Instruction.create(Code.SHRD_RM32_R32_IMM8, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), ICRegisters.ebx, -5));
	}

	@Test
	void shrx_r32_r32_r32() {
		testAssembler(c -> c.shrx(edx, ebx, esp), Instruction.create(Code.VEX_SHRX_R32_RM32_R32, ICRegisters.edx, ICRegisters.ebx, ICRegisters.esp));
	}

	@Test
	void shrx_r32_m_r32() {
		testAssembler(c -> c.shrx(edx, dword_ptr(0x0L).base(ecx), esp), Instruction.create(Code.VEX_SHRX_R32_RM32_R32, ICRegisters.edx, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), ICRegisters.esp));
	}

	@Test
	void shufpd_xmm_xmm_i() {
		testAssembler(c -> c.shufpd(xmm2, xmm3, -5), Instruction.create(Code.SHUFPD_XMM_XMMM128_IMM8, ICRegisters.xmm2, ICRegisters.xmm3, -5));
	}

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

	@Test
	void shufps_xmm_xmm_i() {
		testAssembler(c -> c.shufps(xmm2, xmm3, -5), Instruction.create(Code.SHUFPS_XMM_XMMM128_IMM8, ICRegisters.xmm2, ICRegisters.xmm3, -5));
	}

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

	@Test
	void sidt_m() {
		{ // skip (getBitness() == 64) not supported by this CodeAssembler bitness
		} /* else */ { /* if (getBitness() >= 32) */
			testAssembler(c -> c.sidt(mem_ptr(0x0L).base(ecx)), Instruction.create(Code.SIDT_M1632, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE)));
		} /* else skip !(getBitness() >= 32) not supported by this CodeAssembler bitness */
	}

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

	@Test
	void sldt_r16() {
		testAssembler(c -> c.sldt(dx), Instruction.create(Code.SLDT_RM16, ICRegisters.dx));
	}

	@Test
	void sldt_r32() {
		testAssembler(c -> c.sldt(edx), Instruction.create(Code.SLDT_R32M16, ICRegisters.edx));
	}

	@Test
	void sldt_m() {
		{ /* if (getBitness() >= 32) */
			testAssembler(c -> c.sldt(dword_ptr(0x0L).base(ecx)), Instruction.create(Code.SLDT_R32M16, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE)));
		} /* else skip !(getBitness() >= 32) not supported by this CodeAssembler bitness */
	}

	@Test
	void slwpcb_r32() {
		testAssembler(c -> c.slwpcb(edx), Instruction.create(Code.XOP_SLWPCB_R32, ICRegisters.edx));
	}

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

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

	@Test
	void smsw_r16() {
		testAssembler(c -> c.smsw(dx), Instruction.create(Code.SMSW_RM16, ICRegisters.dx));
	}

	@Test
	void smsw_r32() {
		testAssembler(c -> c.smsw(edx), Instruction.create(Code.SMSW_R32M16, ICRegisters.edx));
	}

	@Test
	void smsw_m() {
		{ /* if (getBitness() >= 32) */
			testAssembler(c -> c.smsw(dword_ptr(0x0L).base(ecx)), Instruction.create(Code.SMSW_R32M16, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE)));
		} /* else skip !(getBitness() >= 32) not supported by this CodeAssembler bitness */
	}

	@Test
	void sqrtpd_xmm_xmm() {
		testAssembler(c -> c.sqrtpd(xmm2, xmm3), Instruction.create(Code.SQRTPD_XMM_XMMM128, ICRegisters.xmm2, ICRegisters.xmm3));
	}

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

	@Test
	void sqrtps_xmm_xmm() {
		testAssembler(c -> c.sqrtps(xmm2, xmm3), Instruction.create(Code.SQRTPS_XMM_XMMM128, ICRegisters.xmm2, ICRegisters.xmm3));
	}

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

	@Test
	void sqrtsd_xmm_xmm() {
		testAssembler(c -> c.sqrtsd(xmm2, xmm3), Instruction.create(Code.SQRTSD_XMM_XMMM64, ICRegisters.xmm2, ICRegisters.xmm3));
	}

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

	@Test
	void sqrtss_xmm_xmm() {
		testAssembler(c -> c.sqrtss(xmm2, xmm3), Instruction.create(Code.SQRTSS_XMM_XMMM32, ICRegisters.xmm2, ICRegisters.xmm3));
	}

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

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

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

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

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

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

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

	@Test
	void stosb() {
		testAssembler(c -> c.stosb(), Instruction.createStosb(32));
	}

	@Test
	void stosd() {
		testAssembler(c -> c.stosd(), Instruction.createStosd(32));
	}

	@Test
	void stosw() {
		testAssembler(c -> c.stosw(), Instruction.createStosw(32));
	}

	@Test
	void str_r16() {
		testAssembler(c -> c.str(dx), Instruction.create(Code.STR_RM16, ICRegisters.dx));
	}

	@Test
	void str_r32() {
		testAssembler(c -> c.str(edx), Instruction.create(Code.STR_R32M16, ICRegisters.edx));
	}

	@Test
	void str_m() {
		{ /* if (getBitness() >= 32) */
			testAssembler(c -> c.str(dword_ptr(0x0L).base(ecx)), Instruction.create(Code.STR_R32M16, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE)));
		} /* else skip !(getBitness() >= 32) not supported by this CodeAssembler bitness */
	}

	@Test
	void sub_r8_r8() {
		testAssembler(c -> c.sub(dl, bl), Instruction.create(Code.SUB_RM8_R8, ICRegisters.dl, ICRegisters.bl));
	}

	@Test
	void sub_m_r8() {
		testAssembler(c -> c.sub(byte_ptr(0x0L).base(ecx), bl), Instruction.create(Code.SUB_RM8_R8, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), ICRegisters.bl));
	}

	@Test
	void sub_r16_r16() {
		testAssembler(c -> c.sub(dx, bx), Instruction.create(Code.SUB_RM16_R16, ICRegisters.dx, ICRegisters.bx));
	}

	@Test
	void sub_m_r16() {
		testAssembler(c -> c.sub(word_ptr(0x0L).base(ecx), bx), Instruction.create(Code.SUB_RM16_R16, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), ICRegisters.bx));
	}

	@Test
	void sub_r32_r32() {
		testAssembler(c -> c.sub(edx, ebx), Instruction.create(Code.SUB_RM32_R32, ICRegisters.edx, ICRegisters.ebx));
	}

	@Test
	void sub_m_r32() {
		testAssembler(c -> c.sub(dword_ptr(0x0L).base(ecx), ebx), Instruction.create(Code.SUB_RM32_R32, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), ICRegisters.ebx));
	}

	@Test
	void sub_r8_m() {
		testAssembler(c -> c.sub(dl, byte_ptr(0x0L).base(ecx)), Instruction.create(Code.SUB_R8_RM8, ICRegisters.dl, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE)));
	}

	@Test
	void sub_r16_m() {
		testAssembler(c -> c.sub(dx, word_ptr(0x0L).base(ecx)), Instruction.create(Code.SUB_R16_RM16, ICRegisters.dx, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE)));
	}

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

	@Test
	void sub_r8_i() {
		{ /* if (dst.getRegister() == Register.AL) */
			testAssembler(c -> c.sub(al, -5), Instruction.create(Code.SUB_AL_IMM8, ICRegisters.al, -5));
		} /* else */ testAssembler(c -> c.sub(dl, -5), Instruction.create(Code.SUB_RM8_IMM8, ICRegisters.dl, -5));
	}

	@Test
	void sub_r16_i() {
		{ /* if (dst.getRegister() == Register.AX) */
			testAssembler(c -> c.sub(ax, 0x40B7), Instruction.create(Code.SUB_AX_IMM16, ICRegisters.ax, 0x40B7));
		} /* else */ { /* if (imm >= -0x80 && imm <= 0x7F) */
			testAssembler(c -> c.sub(dx, -0x80), Instruction.create(Code.SUB_RM16_IMM8, ICRegisters.dx, -0x80));
			testAssembler(c -> c.sub(dx, 0x7F), Instruction.create(Code.SUB_RM16_IMM8, ICRegisters.dx, 0x7F));
		} /* else */ testAssembler(c -> c.sub(dx, 0x40B7), Instruction.create(Code.SUB_RM16_IMM16, ICRegisters.dx, 0x40B7));
	}

	@Test
	void sub_r32_i() {
		{ /* if (dst.getRegister() == Register.EAX) */
			testAssembler(c -> c.sub(eax, 0x7FFFFFFF), Instruction.create(Code.SUB_EAX_IMM32, ICRegisters.eax, 0x7FFFFFFF));
		} /* else */ { /* if (imm >= -0x80 && imm <= 0x7F) */
			testAssembler(c -> c.sub(edx, -0x80), Instruction.create(Code.SUB_RM32_IMM8, ICRegisters.edx, -0x80));
			testAssembler(c -> c.sub(edx, 0x7F), Instruction.create(Code.SUB_RM32_IMM8, ICRegisters.edx, 0x7F));
		} /* else */ testAssembler(c -> c.sub(edx, 0x7FFFFFFF), Instruction.create(Code.SUB_RM32_IMM32, ICRegisters.edx, 0x7FFFFFFF));
	}

	@Test
	void sub_m_i() {
		{ /* if (dst.size == MemoryOperandSize.QWORD) */
			{ /* if (imm >= -0x80 && imm <= 0x7F) */
				// Skipping SUB_RM64_IMM8 - Not supported by current bitness
				// Skipping SUB_RM64_IMM8 - Not supported by current bitness
			} /* else */ // Skipping SUB_RM64_IMM32 - Not supported by current bitness
		} /* else */ { /* if (dst.size == MemoryOperandSize.DWORD) */
			{ /* if (imm >= -0x80 && imm <= 0x7F) */
				testAssembler(c -> c.sub(dword_ptr(0x0L).base(edx), -0x80), Instruction.create(Code.SUB_RM32_IMM8, new MemoryOperand(ICRegisters.edx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), -0x80));
				testAssembler(c -> c.sub(dword_ptr(0x0L).base(edx), 0x7F), Instruction.create(Code.SUB_RM32_IMM8, new MemoryOperand(ICRegisters.edx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), 0x7F));
			} /* else */ testAssembler(c -> c.sub(dword_ptr(0x0L).base(edx), 0x7FFFFFFF), Instruction.create(Code.SUB_RM32_IMM32, new MemoryOperand(ICRegisters.edx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), 0x7FFFFFFF));
		} /* else */ { /* if (dst.size == MemoryOperandSize.WORD) */
			{ /* if (imm >= -0x80 && imm <= 0x7F) */
				testAssembler(c -> c.sub(word_ptr(0x0L).base(edx), -0x80), Instruction.create(Code.SUB_RM16_IMM8, new MemoryOperand(ICRegisters.edx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), -0x80));
				testAssembler(c -> c.sub(word_ptr(0x0L).base(edx), 0x7F), Instruction.create(Code.SUB_RM16_IMM8, new MemoryOperand(ICRegisters.edx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), 0x7F));
			} /* else */ testAssembler(c -> c.sub(word_ptr(0x0L).base(edx), 0x40B7), Instruction.create(Code.SUB_RM16_IMM16, new MemoryOperand(ICRegisters.edx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), 0x40B7));
		} /* else */ { /* if (dst.size == MemoryOperandSize.BYTE) */
			testAssembler(c -> c.sub(byte_ptr(0x0L).base(edx), -5), Instruction.create(Code.SUB_RM8_IMM8, new MemoryOperand(ICRegisters.edx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), -5));
		}
		{
			assertInvalid(() -> {
				testAssembler(c -> c.sub(zmmword_ptr(0x0L).base(edx), -5), Instruction.create(Code.SUB_RM8_IMM8, new MemoryOperand(ICRegisters.edx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), -5));
			});
		}
	}

	@Test
	void subpd_xmm_xmm() {
		testAssembler(c -> c.subpd(xmm2, xmm3), Instruction.create(Code.SUBPD_XMM_XMMM128, ICRegisters.xmm2, ICRegisters.xmm3));
	}

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

	@Test
	void subps_xmm_xmm() {
		testAssembler(c -> c.subps(xmm2, xmm3), Instruction.create(Code.SUBPS_XMM_XMMM128, ICRegisters.xmm2, ICRegisters.xmm3));
	}

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

	@Test
	void subsd_xmm_xmm() {
		testAssembler(c -> c.subsd(xmm2, xmm3), Instruction.create(Code.SUBSD_XMM_XMMM64, ICRegisters.xmm2, ICRegisters.xmm3));
	}

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

	@Test
	void subss_xmm_xmm() {
		testAssembler(c -> c.subss(xmm2, xmm3), Instruction.create(Code.SUBSS_XMM_XMMM32, ICRegisters.xmm2, ICRegisters.xmm3));
	}

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

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

	@Test
	void svldt_m() {
		testAssembler(c -> c.svldt(mem_ptr(0x0L).base(ecx)), Instruction.create(Code.SVLDT_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 svts_m() {
		testAssembler(c -> c.svts(mem_ptr(0x0L).base(ecx)), Instruction.create(Code.SVTS_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 syscall() {
		testAssembler(c -> c.syscall(), Instruction.create(Code.SYSCALL));
	}

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

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

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

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

	@Test
	void vscalefpd_ymm_ymm_ymm() {
		testAssembler(c -> c.vscalefpd(ymm2.k1(), ymm3, ymm4), applyK(Instruction.create(Code.EVEX_VSCALEFPD_YMM_K1Z_YMM_YMMM256B64, ICRegisters.ymm2, ICRegisters.ymm3, ICRegisters.ymm4), Register.K1));
	}

	@Test
	void vscalefpd_zmm_zmm_zmm() {
		testAssembler(c -> c.vscalefpd(zmm2.k1(), zmm3, zmm4), applyK(Instruction.create(Code.EVEX_VSCALEFPD_ZMM_K1Z_ZMM_ZMMM512B64_ER, ICRegisters.zmm2, ICRegisters.zmm3, ICRegisters.zmm4), Register.K1));
	}

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

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

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

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

	@Test
	void vscalefph_ymm_ymm_ymm() {
		testAssembler(c -> c.vscalefph(ymm2.k1(), ymm3, ymm4), applyK(Instruction.create(Code.EVEX_VSCALEFPH_YMM_K1Z_YMM_YMMM256B16, ICRegisters.ymm2, ICRegisters.ymm3, ICRegisters.ymm4), Register.K1));
	}

	@Test
	void vscalefph_zmm_zmm_zmm() {
		testAssembler(c -> c.vscalefph(zmm2.k1(), zmm3, zmm4), applyK(Instruction.create(Code.EVEX_VSCALEFPH_ZMM_K1Z_ZMM_ZMMM512B16_ER, ICRegisters.zmm2, ICRegisters.zmm3, ICRegisters.zmm4), Register.K1));
	}

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

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

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

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

	@Test
	void vscalefps_ymm_ymm_ymm() {
		testAssembler(c -> c.vscalefps(ymm2.k1(), ymm3, ymm4), applyK(Instruction.create(Code.EVEX_VSCALEFPS_YMM_K1Z_YMM_YMMM256B32, ICRegisters.ymm2, ICRegisters.ymm3, ICRegisters.ymm4), Register.K1));
	}

	@Test
	void vscalefps_zmm_zmm_zmm() {
		testAssembler(c -> c.vscalefps(zmm2.k1(), zmm3, zmm4), applyK(Instruction.create(Code.EVEX_VSCALEFPS_ZMM_K1Z_ZMM_ZMMM512B32_ER, ICRegisters.zmm2, ICRegisters.zmm3, ICRegisters.zmm4), Register.K1));
	}

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

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

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

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

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

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

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

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

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

	@Test
	void vscatterdpd_m_xmm() {
		testAssembler(c -> c.vscatterdpd(mem_ptr(0x0L).base(edx).index(xmm2).k1(), xmm3), applyK(Instruction.create(Code.EVEX_VSCATTERDPD_VM32X_K1_XMM, new MemoryOperand(ICRegisters.edx, ICRegisters.xmm2, 1, 0x0L, 0, false, ICRegister.NONE), ICRegisters.xmm3), Register.K1));
	}

	@Test
	void vscatterdpd_m_ymm() {
		testAssembler(c -> c.vscatterdpd(mem_ptr(0x0L).base(edx).index(xmm2).k1(), ymm3), applyK(Instruction.create(Code.EVEX_VSCATTERDPD_VM32X_K1_YMM, new MemoryOperand(ICRegisters.edx, ICRegisters.xmm2, 1, 0x0L, 0, false, ICRegister.NONE), ICRegisters.ymm3), Register.K1));
	}

	@Test
	void vscatterdpd_m_zmm() {
		testAssembler(c -> c.vscatterdpd(mem_ptr(0x0L).base(edx).index(ymm2).k1(), zmm3), applyK(Instruction.create(Code.EVEX_VSCATTERDPD_VM32Y_K1_ZMM, new MemoryOperand(ICRegisters.edx, ICRegisters.ymm2, 1, 0x0L, 0, false, ICRegister.NONE), ICRegisters.zmm3), Register.K1));
	}

	@Test
	void vscatterdps_m_xmm() {
		testAssembler(c -> c.vscatterdps(mem_ptr(0x0L).base(edx).index(xmm2).k1(), xmm3), applyK(Instruction.create(Code.EVEX_VSCATTERDPS_VM32X_K1_XMM, new MemoryOperand(ICRegisters.edx, ICRegisters.xmm2, 1, 0x0L, 0, false, ICRegister.NONE), ICRegisters.xmm3), Register.K1));
	}

	@Test
	void vscatterdps_m_ymm() {
		testAssembler(c -> c.vscatterdps(mem_ptr(0x0L).base(edx).index(ymm2).k1(), ymm3), applyK(Instruction.create(Code.EVEX_VSCATTERDPS_VM32Y_K1_YMM, new MemoryOperand(ICRegisters.edx, ICRegisters.ymm2, 1, 0x0L, 0, false, ICRegister.NONE), ICRegisters.ymm3), Register.K1));
	}

	@Test
	void vscatterdps_m_zmm() {
		testAssembler(c -> c.vscatterdps(mem_ptr(0x0L).base(edx).index(zmm2).k1(), zmm3), applyK(Instruction.create(Code.EVEX_VSCATTERDPS_VM32Z_K1_ZMM, new MemoryOperand(ICRegisters.edx, ICRegisters.zmm2, 1, 0x0L, 0, false, ICRegister.NONE), ICRegisters.zmm3), Register.K1));
	}

	@Test
	void vscatterpf0dpd_m() {
		testAssembler(c -> c.vscatterpf0dpd(mem_ptr(0x0L).base(edx).index(ymm2).k1()), applyK(Instruction.create(Code.EVEX_VSCATTERPF0DPD_VM32Y_K1, new MemoryOperand(ICRegisters.edx, ICRegisters.ymm2, 1, 0x0L, 0, false, ICRegister.NONE)), Register.K1));
	}

	@Test
	void vscatterpf0dps_m() {
		testAssembler(c -> c.vscatterpf0dps(mem_ptr(0x0L).base(edx).index(zmm2).k1()), applyK(Instruction.create(Code.EVEX_VSCATTERPF0DPS_VM32Z_K1, new MemoryOperand(ICRegisters.edx, ICRegisters.zmm2, 1, 0x0L, 0, false, ICRegister.NONE)), Register.K1));
	}

	@Test
	void vscatterpf0qpd_m() {
		testAssembler(c -> c.vscatterpf0qpd(mem_ptr(0x0L).base(edx).index(zmm2).k1()), applyK(Instruction.create(Code.EVEX_VSCATTERPF0QPD_VM64Z_K1, new MemoryOperand(ICRegisters.edx, ICRegisters.zmm2, 1, 0x0L, 0, false, ICRegister.NONE)), Register.K1));
	}

	@Test
	void vscatterpf0qps_m() {
		testAssembler(c -> c.vscatterpf0qps(mem_ptr(0x0L).base(edx).index(zmm2).k1()), applyK(Instruction.create(Code.EVEX_VSCATTERPF0QPS_VM64Z_K1, new MemoryOperand(ICRegisters.edx, ICRegisters.zmm2, 1, 0x0L, 0, false, ICRegister.NONE)), Register.K1));
	}

	@Test
	void vscatterpf1dpd_m() {
		testAssembler(c -> c.vscatterpf1dpd(mem_ptr(0x0L).base(edx).index(ymm2).k1()), applyK(Instruction.create(Code.EVEX_VSCATTERPF1DPD_VM32Y_K1, new MemoryOperand(ICRegisters.edx, ICRegisters.ymm2, 1, 0x0L, 0, false, ICRegister.NONE)), Register.K1));
	}

	@Test
	void vscatterpf1dps_m() {
		testAssembler(c -> c.vscatterpf1dps(mem_ptr(0x0L).base(edx).index(zmm2).k1()), applyK(Instruction.create(Code.EVEX_VSCATTERPF1DPS_VM32Z_K1, new MemoryOperand(ICRegisters.edx, ICRegisters.zmm2, 1, 0x0L, 0, false, ICRegister.NONE)), Register.K1));
	}

	@Test
	void vscatterpf1qpd_m() {
		testAssembler(c -> c.vscatterpf1qpd(mem_ptr(0x0L).base(edx).index(zmm2).k1()), applyK(Instruction.create(Code.EVEX_VSCATTERPF1QPD_VM64Z_K1, new MemoryOperand(ICRegisters.edx, ICRegisters.zmm2, 1, 0x0L, 0, false, ICRegister.NONE)), Register.K1));
	}

	@Test
	void vscatterpf1qps_m() {
		testAssembler(c -> c.vscatterpf1qps(mem_ptr(0x0L).base(edx).index(zmm2).k1()), applyK(Instruction.create(Code.EVEX_VSCATTERPF1QPS_VM64Z_K1, new MemoryOperand(ICRegisters.edx, ICRegisters.zmm2, 1, 0x0L, 0, false, ICRegister.NONE)), Register.K1));
	}

	@Test
	void vscatterqpd_m_xmm() {
		testAssembler(c -> c.vscatterqpd(mem_ptr(0x0L).base(edx).index(xmm2).k1(), xmm3), applyK(Instruction.create(Code.EVEX_VSCATTERQPD_VM64X_K1_XMM, new MemoryOperand(ICRegisters.edx, ICRegisters.xmm2, 1, 0x0L, 0, false, ICRegister.NONE), ICRegisters.xmm3), Register.K1));
	}

	@Test
	void vscatterqpd_m_ymm() {
		testAssembler(c -> c.vscatterqpd(mem_ptr(0x0L).base(edx).index(ymm2).k1(), ymm3), applyK(Instruction.create(Code.EVEX_VSCATTERQPD_VM64Y_K1_YMM, new MemoryOperand(ICRegisters.edx, ICRegisters.ymm2, 1, 0x0L, 0, false, ICRegister.NONE), ICRegisters.ymm3), Register.K1));
	}

	@Test
	void vscatterqpd_m_zmm() {
		testAssembler(c -> c.vscatterqpd(mem_ptr(0x0L).base(edx).index(zmm2).k1(), zmm3), applyK(Instruction.create(Code.EVEX_VSCATTERQPD_VM64Z_K1_ZMM, new MemoryOperand(ICRegisters.edx, ICRegisters.zmm2, 1, 0x0L, 0, false, ICRegister.NONE), ICRegisters.zmm3), Register.K1));
	}

	@Test
	void vscatterqps_m_xmm() {
		{ /* if (Register.isXMM(dst.index.get())) */
			testAssembler(c -> c.vscatterqps(mem_ptr(0x0L).base(edx).index(xmm2).k1(), xmm3), applyK(Instruction.create(Code.EVEX_VSCATTERQPS_VM64X_K1_XMM, new MemoryOperand(ICRegisters.edx, ICRegisters.xmm2, 1, 0x0L, 0, false, ICRegister.NONE), ICRegisters.xmm3), Register.K1));
		} /* else */ { /* if (Register.isYMM(dst.index.get())) */
			testAssembler(c -> c.vscatterqps(mem_ptr(0x0L).base(edx).index(ymm2).k1(), xmm3), applyK(Instruction.create(Code.EVEX_VSCATTERQPS_VM64Y_K1_XMM, new MemoryOperand(ICRegisters.edx, ICRegisters.ymm2, 1, 0x0L, 0, false, ICRegister.NONE), ICRegisters.xmm3), Register.K1));
		}
		{
			assertInvalid(() -> {
				testAssembler(c -> c.vscatterqps(mem_ptr(0x0L).base(edx).index(zmm0).k1(), xmm3), applyK(Instruction.create(Code.EVEX_VSCATTERQPS_VM64Y_K1_XMM, new MemoryOperand(ICRegisters.edx, ICRegisters.zmm0, 1, 0x0L, 0, false, ICRegister.NONE), ICRegisters.xmm3), Register.K1));
			});
		}
	}

	@Test
	void vscatterqps_m_ymm() {
		testAssembler(c -> c.vscatterqps(mem_ptr(0x0L).base(edx).index(zmm2).k1(), ymm3), applyK(Instruction.create(Code.EVEX_VSCATTERQPS_VM64Z_K1_YMM, new MemoryOperand(ICRegisters.edx, ICRegisters.zmm2, 1, 0x0L, 0, false, ICRegister.NONE), ICRegisters.ymm3), Register.K1));
	}

	@Test
	void vsha512msg1_ymm_xmm() {
		testAssembler(c -> c.vsha512msg1(ymm2, xmm3), Instruction.create(Code.VEX_VSHA512MSG1_YMM_XMM, ICRegisters.ymm2, ICRegisters.xmm3));
	}

	@Test
	void vsha512msg2_ymm_ymm() {
		testAssembler(c -> c.vsha512msg2(ymm2, ymm3), Instruction.create(Code.VEX_VSHA512MSG2_YMM_YMM, ICRegisters.ymm2, ICRegisters.ymm3));
	}

	@Test
	void vsha512rnds2_ymm_ymm_xmm() {
		testAssembler(c -> c.vsha512rnds2(ymm2, ymm3, xmm4), Instruction.create(Code.VEX_VSHA512RNDS2_YMM_YMM_XMM, ICRegisters.ymm2, ICRegisters.ymm3, ICRegisters.xmm4));
	}

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

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

	@Test
	void vshuff32x4_ymm_ymm_m_i() {
		testAssembler(c -> c.vshuff32x4(ymm2.k1(), ymm3, ymmword_ptr(0x0L).base(ecx), -5), applyK(Instruction.create(Code.EVEX_VSHUFF32X4_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 vshuff32x4_zmm_zmm_m_i() {
		testAssembler(c -> c.vshuff32x4(zmm2.k1(), zmm3, zmmword_ptr(0x0L).base(ecx), -5), applyK(Instruction.create(Code.EVEX_VSHUFF32X4_ZMM_K1Z_ZMM_ZMMM512B32_IMM8, ICRegisters.zmm2, ICRegisters.zmm3, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), -5), Register.K1));
	}

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

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

	@Test
	void vshuff64x2_ymm_ymm_m_i() {
		testAssembler(c -> c.vshuff64x2(ymm2.k1(), ymm3, ymmword_ptr(0x0L).base(ecx), -5), applyK(Instruction.create(Code.EVEX_VSHUFF64X2_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 vshuff64x2_zmm_zmm_m_i() {
		testAssembler(c -> c.vshuff64x2(zmm2.k1(), zmm3, zmmword_ptr(0x0L).base(ecx), -5), applyK(Instruction.create(Code.EVEX_VSHUFF64X2_ZMM_K1Z_ZMM_ZMMM512B64_IMM8, ICRegisters.zmm2, ICRegisters.zmm3, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), -5), Register.K1));
	}

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

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

	@Test
	void vshufi32x4_ymm_ymm_m_i() {
		testAssembler(c -> c.vshufi32x4(ymm2.k1(), ymm3, ymmword_ptr(0x0L).base(ecx), -5), applyK(Instruction.create(Code.EVEX_VSHUFI32X4_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 vshufi32x4_zmm_zmm_m_i() {
		testAssembler(c -> c.vshufi32x4(zmm2.k1(), zmm3, zmmword_ptr(0x0L).base(ecx), -5), applyK(Instruction.create(Code.EVEX_VSHUFI32X4_ZMM_K1Z_ZMM_ZMMM512B32_IMM8, ICRegisters.zmm2, ICRegisters.zmm3, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), -5), Register.K1));
	}

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

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

	@Test
	void vshufi64x2_ymm_ymm_m_i() {
		testAssembler(c -> c.vshufi64x2(ymm2.k1(), ymm3, ymmword_ptr(0x0L).base(ecx), -5), applyK(Instruction.create(Code.EVEX_VSHUFI64X2_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 vshufi64x2_zmm_zmm_m_i() {
		testAssembler(c -> c.vshufi64x2(zmm2.k1(), zmm3, zmmword_ptr(0x0L).base(ecx), -5), applyK(Instruction.create(Code.EVEX_VSHUFI64X2_ZMM_K1Z_ZMM_ZMMM512B64_IMM8, ICRegisters.zmm2, ICRegisters.zmm3, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), -5), Register.K1));
	}

	@Test
	void vshufpd_xmm_xmm_xmm_i() {
		{ /* if (getInstructionPreferVex()) */
			testAssembler(c -> c.vshufpd(xmm2, xmm3, xmm4, -5), Instruction.create(Code.VEX_VSHUFPD_XMM_XMM_XMMM128_IMM8, ICRegisters.xmm2, ICRegisters.xmm3, ICRegisters.xmm4, -5), TestInstrFlags.PREFER_VEX);
		} /* else */ testAssembler(c -> c.vshufpd(xmm2.k1(), xmm3, xmm4, -5), applyK(Instruction.create(Code.EVEX_VSHUFPD_XMM_K1Z_XMM_XMMM128B64_IMM8, ICRegisters.xmm2, ICRegisters.xmm3, ICRegisters.xmm4, -5), Register.K1), TestInstrFlags.PREFER_EVEX);
	}

	@Test
	void vshufpd_ymm_ymm_ymm_i() {
		{ /* if (getInstructionPreferVex()) */
			testAssembler(c -> c.vshufpd(ymm2, ymm3, ymm4, -5), Instruction.create(Code.VEX_VSHUFPD_YMM_YMM_YMMM256_IMM8, ICRegisters.ymm2, ICRegisters.ymm3, ICRegisters.ymm4, -5), TestInstrFlags.PREFER_VEX);
		} /* else */ testAssembler(c -> c.vshufpd(ymm2.k1(), ymm3, ymm4, -5), applyK(Instruction.create(Code.EVEX_VSHUFPD_YMM_K1Z_YMM_YMMM256B64_IMM8, ICRegisters.ymm2, ICRegisters.ymm3, ICRegisters.ymm4, -5), Register.K1), TestInstrFlags.PREFER_EVEX);
	}

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

	@Test
	void vshufpd_xmm_xmm_m_i() {
		{ /* if (src2.isBroadcast()) */
			testAssembler(c -> c.vshufpd(xmm2.k1(), xmm3, dword_bcst(0x0L).base(edx), -5), applyK(Instruction.create(Code.EVEX_VSHUFPD_XMM_K1Z_XMM_XMMM128B64_IMM8, ICRegisters.xmm2, ICRegisters.xmm3, new MemoryOperand(ICRegisters.edx, ICRegister.NONE, 1, 0x0L, 0, true, ICRegister.NONE), -5), Register.K1), TestInstrFlags.PREFER_EVEX | TestInstrFlags.BROADCAST);
		} /* else */ { /* if (getInstructionPreferVex()) */
			testAssembler(c -> c.vshufpd(xmm2, xmm3, xmmword_ptr(0x0L).base(ecx), -5), Instruction.create(Code.VEX_VSHUFPD_XMM_XMM_XMMM128_IMM8, ICRegisters.xmm2, ICRegisters.xmm3, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), -5), TestInstrFlags.PREFER_VEX);
		} /* else */ testAssembler(c -> c.vshufpd(xmm2.k1(), xmm3, xmmword_ptr(0x0L).base(ecx), -5), applyK(Instruction.create(Code.EVEX_VSHUFPD_XMM_K1Z_XMM_XMMM128B64_IMM8, ICRegisters.xmm2, ICRegisters.xmm3, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), -5), Register.K1), TestInstrFlags.PREFER_EVEX);
	}

	@Test
	void vshufpd_ymm_ymm_m_i() {
		{ /* if (src2.isBroadcast()) */
			testAssembler(c -> c.vshufpd(ymm2.k1(), ymm3, dword_bcst(0x0L).base(edx), -5), applyK(Instruction.create(Code.EVEX_VSHUFPD_YMM_K1Z_YMM_YMMM256B64_IMM8, ICRegisters.ymm2, ICRegisters.ymm3, new MemoryOperand(ICRegisters.edx, ICRegister.NONE, 1, 0x0L, 0, true, ICRegister.NONE), -5), Register.K1), TestInstrFlags.PREFER_EVEX | TestInstrFlags.BROADCAST);
		} /* else */ { /* if (getInstructionPreferVex()) */
			testAssembler(c -> c.vshufpd(ymm2, ymm3, ymmword_ptr(0x0L).base(ecx), -5), Instruction.create(Code.VEX_VSHUFPD_YMM_YMM_YMMM256_IMM8, ICRegisters.ymm2, ICRegisters.ymm3, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), -5), TestInstrFlags.PREFER_VEX);
		} /* else */ testAssembler(c -> c.vshufpd(ymm2.k1(), ymm3, ymmword_ptr(0x0L).base(ecx), -5), applyK(Instruction.create(Code.EVEX_VSHUFPD_YMM_K1Z_YMM_YMMM256B64_IMM8, ICRegisters.ymm2, ICRegisters.ymm3, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), -5), Register.K1), TestInstrFlags.PREFER_EVEX);
	}

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

	@Test
	void vshufps_xmm_xmm_xmm_i() {
		{ /* if (getInstructionPreferVex()) */
			testAssembler(c -> c.vshufps(xmm2, xmm3, xmm4, -5), Instruction.create(Code.VEX_VSHUFPS_XMM_XMM_XMMM128_IMM8, ICRegisters.xmm2, ICRegisters.xmm3, ICRegisters.xmm4, -5), TestInstrFlags.PREFER_VEX);
		} /* else */ testAssembler(c -> c.vshufps(xmm2.k1(), xmm3, xmm4, -5), applyK(Instruction.create(Code.EVEX_VSHUFPS_XMM_K1Z_XMM_XMMM128B32_IMM8, ICRegisters.xmm2, ICRegisters.xmm3, ICRegisters.xmm4, -5), Register.K1), TestInstrFlags.PREFER_EVEX);
	}

	@Test
	void vshufps_ymm_ymm_ymm_i() {
		{ /* if (getInstructionPreferVex()) */
			testAssembler(c -> c.vshufps(ymm2, ymm3, ymm4, -5), Instruction.create(Code.VEX_VSHUFPS_YMM_YMM_YMMM256_IMM8, ICRegisters.ymm2, ICRegisters.ymm3, ICRegisters.ymm4, -5), TestInstrFlags.PREFER_VEX);
		} /* else */ testAssembler(c -> c.vshufps(ymm2.k1(), ymm3, ymm4, -5), applyK(Instruction.create(Code.EVEX_VSHUFPS_YMM_K1Z_YMM_YMMM256B32_IMM8, ICRegisters.ymm2, ICRegisters.ymm3, ICRegisters.ymm4, -5), Register.K1), TestInstrFlags.PREFER_EVEX);
	}

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

	@Test
	void vshufps_xmm_xmm_m_i() {
		{ /* if (src2.isBroadcast()) */
			testAssembler(c -> c.vshufps(xmm2.k1(), xmm3, dword_bcst(0x0L).base(edx), -5), applyK(Instruction.create(Code.EVEX_VSHUFPS_XMM_K1Z_XMM_XMMM128B32_IMM8, ICRegisters.xmm2, ICRegisters.xmm3, new MemoryOperand(ICRegisters.edx, ICRegister.NONE, 1, 0x0L, 0, true, ICRegister.NONE), -5), Register.K1), TestInstrFlags.PREFER_EVEX | TestInstrFlags.BROADCAST);
		} /* else */ { /* if (getInstructionPreferVex()) */
			testAssembler(c -> c.vshufps(xmm2, xmm3, xmmword_ptr(0x0L).base(ecx), -5), Instruction.create(Code.VEX_VSHUFPS_XMM_XMM_XMMM128_IMM8, ICRegisters.xmm2, ICRegisters.xmm3, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), -5), TestInstrFlags.PREFER_VEX);
		} /* else */ testAssembler(c -> c.vshufps(xmm2.k1(), xmm3, xmmword_ptr(0x0L).base(ecx), -5), applyK(Instruction.create(Code.EVEX_VSHUFPS_XMM_K1Z_XMM_XMMM128B32_IMM8, ICRegisters.xmm2, ICRegisters.xmm3, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), -5), Register.K1), TestInstrFlags.PREFER_EVEX);
	}

	@Test
	void vshufps_ymm_ymm_m_i() {
		{ /* if (src2.isBroadcast()) */
			testAssembler(c -> c.vshufps(ymm2.k1(), ymm3, dword_bcst(0x0L).base(edx), -5), applyK(Instruction.create(Code.EVEX_VSHUFPS_YMM_K1Z_YMM_YMMM256B32_IMM8, ICRegisters.ymm2, ICRegisters.ymm3, new MemoryOperand(ICRegisters.edx, ICRegister.NONE, 1, 0x0L, 0, true, ICRegister.NONE), -5), Register.K1), TestInstrFlags.PREFER_EVEX | TestInstrFlags.BROADCAST);
		} /* else */ { /* if (getInstructionPreferVex()) */
			testAssembler(c -> c.vshufps(ymm2, ymm3, ymmword_ptr(0x0L).base(ecx), -5), Instruction.create(Code.VEX_VSHUFPS_YMM_YMM_YMMM256_IMM8, ICRegisters.ymm2, ICRegisters.ymm3, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), -5), TestInstrFlags.PREFER_VEX);
		} /* else */ testAssembler(c -> c.vshufps(ymm2.k1(), ymm3, ymmword_ptr(0x0L).base(ecx), -5), applyK(Instruction.create(Code.EVEX_VSHUFPS_YMM_K1Z_YMM_YMMM256B32_IMM8, ICRegisters.ymm2, ICRegisters.ymm3, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE), -5), Register.K1), TestInstrFlags.PREFER_EVEX);
	}

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

	@Test
	void vsm3msg1_xmm_xmm_xmm() {
		testAssembler(c -> c.vsm3msg1(xmm2, xmm3, xmm4), Instruction.create(Code.VEX_VSM3MSG1_XMM_XMM_XMMM128, ICRegisters.xmm2, ICRegisters.xmm3, ICRegisters.xmm4));
	}

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

	@Test
	void vsm3msg2_xmm_xmm_xmm() {
		testAssembler(c -> c.vsm3msg2(xmm2, xmm3, xmm4), Instruction.create(Code.VEX_VSM3MSG2_XMM_XMM_XMMM128, ICRegisters.xmm2, ICRegisters.xmm3, ICRegisters.xmm4));
	}

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

	@Test
	void vsm3rnds2_xmm_xmm_xmm_i() {
		testAssembler(c -> c.vsm3rnds2(xmm2, xmm3, xmm4, -5), Instruction.create(Code.VEX_VSM3RNDS2_XMM_XMM_XMMM128_IMM8, ICRegisters.xmm2, ICRegisters.xmm3, ICRegisters.xmm4, -5));
	}

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

	@Test
	void vsm4key4_xmm_xmm_xmm() {
		testAssembler(c -> c.vsm4key4(xmm2, xmm3, xmm4), Instruction.create(Code.VEX_VSM4KEY4_XMM_XMM_XMMM128, ICRegisters.xmm2, ICRegisters.xmm3, ICRegisters.xmm4));
	}

	@Test
	void vsm4key4_ymm_ymm_ymm() {
		testAssembler(c -> c.vsm4key4(ymm2, ymm3, ymm4), Instruction.create(Code.VEX_VSM4KEY4_YMM_YMM_YMMM256, ICRegisters.ymm2, ICRegisters.ymm3, ICRegisters.ymm4));
	}

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

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

	@Test
	void vsm4rnds4_xmm_xmm_xmm() {
		testAssembler(c -> c.vsm4rnds4(xmm2, xmm3, xmm4), Instruction.create(Code.VEX_VSM4RNDS4_XMM_XMM_XMMM128, ICRegisters.xmm2, ICRegisters.xmm3, ICRegisters.xmm4));
	}

	@Test
	void vsm4rnds4_ymm_ymm_ymm() {
		testAssembler(c -> c.vsm4rnds4(ymm2, ymm3, ymm4), Instruction.create(Code.VEX_VSM4RNDS4_YMM_YMM_YMMM256, ICRegisters.ymm2, ICRegisters.ymm3, ICRegisters.ymm4));
	}

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

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

	@Test
	void vsqrtpd_xmm_xmm() {
		{ /* if (getInstructionPreferVex()) */
			testAssembler(c -> c.vsqrtpd(xmm2, xmm3), Instruction.create(Code.VEX_VSQRTPD_XMM_XMMM128, ICRegisters.xmm2, ICRegisters.xmm3), TestInstrFlags.PREFER_VEX);
		} /* else */ testAssembler(c -> c.vsqrtpd(xmm2.k1(), xmm3), applyK(Instruction.create(Code.EVEX_VSQRTPD_XMM_K1Z_XMMM128B64, ICRegisters.xmm2, ICRegisters.xmm3), Register.K1), TestInstrFlags.PREFER_EVEX);
	}

	@Test
	void vsqrtpd_ymm_ymm() {
		{ /* if (getInstructionPreferVex()) */
			testAssembler(c -> c.vsqrtpd(ymm2, ymm3), Instruction.create(Code.VEX_VSQRTPD_YMM_YMMM256, ICRegisters.ymm2, ICRegisters.ymm3), TestInstrFlags.PREFER_VEX);
		} /* else */ testAssembler(c -> c.vsqrtpd(ymm2.k1(), ymm3), applyK(Instruction.create(Code.EVEX_VSQRTPD_YMM_K1Z_YMMM256B64, ICRegisters.ymm2, ICRegisters.ymm3), Register.K1), TestInstrFlags.PREFER_EVEX);
	}

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

	@Test
	void vsqrtpd_xmm_m() {
		{ /* if (src.isBroadcast()) */
			testAssembler(c -> c.vsqrtpd(xmm2.k1(), dword_bcst(0x0L).base(edx)), applyK(Instruction.create(Code.EVEX_VSQRTPD_XMM_K1Z_XMMM128B64, ICRegisters.xmm2, new MemoryOperand(ICRegisters.edx, ICRegister.NONE, 1, 0x0L, 0, true, ICRegister.NONE)), Register.K1), TestInstrFlags.PREFER_EVEX | TestInstrFlags.BROADCAST);
		} /* else */ { /* if (getInstructionPreferVex()) */
			testAssembler(c -> c.vsqrtpd(xmm2, xmmword_ptr(0x0L).base(ecx)), Instruction.create(Code.VEX_VSQRTPD_XMM_XMMM128, ICRegisters.xmm2, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE)), TestInstrFlags.PREFER_VEX);
		} /* else */ testAssembler(c -> c.vsqrtpd(xmm2.k1(), xmmword_ptr(0x0L).base(ecx)), applyK(Instruction.create(Code.EVEX_VSQRTPD_XMM_K1Z_XMMM128B64, ICRegisters.xmm2, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE)), Register.K1), TestInstrFlags.PREFER_EVEX);
	}

	@Test
	void vsqrtpd_ymm_m() {
		{ /* if (src.isBroadcast()) */
			testAssembler(c -> c.vsqrtpd(ymm2.k1(), dword_bcst(0x0L).base(edx)), applyK(Instruction.create(Code.EVEX_VSQRTPD_YMM_K1Z_YMMM256B64, ICRegisters.ymm2, new MemoryOperand(ICRegisters.edx, ICRegister.NONE, 1, 0x0L, 0, true, ICRegister.NONE)), Register.K1), TestInstrFlags.PREFER_EVEX | TestInstrFlags.BROADCAST);
		} /* else */ { /* if (getInstructionPreferVex()) */
			testAssembler(c -> c.vsqrtpd(ymm2, ymmword_ptr(0x0L).base(ecx)), Instruction.create(Code.VEX_VSQRTPD_YMM_YMMM256, ICRegisters.ymm2, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE)), TestInstrFlags.PREFER_VEX);
		} /* else */ testAssembler(c -> c.vsqrtpd(ymm2.k1(), ymmword_ptr(0x0L).base(ecx)), applyK(Instruction.create(Code.EVEX_VSQRTPD_YMM_K1Z_YMMM256B64, ICRegisters.ymm2, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE)), Register.K1), TestInstrFlags.PREFER_EVEX);
	}

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

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

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

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

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

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

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

	@Test
	void vsqrtps_xmm_xmm() {
		{ /* if (getInstructionPreferVex()) */
			testAssembler(c -> c.vsqrtps(xmm2, xmm3), Instruction.create(Code.VEX_VSQRTPS_XMM_XMMM128, ICRegisters.xmm2, ICRegisters.xmm3), TestInstrFlags.PREFER_VEX);
		} /* else */ testAssembler(c -> c.vsqrtps(xmm2.k1(), xmm3), applyK(Instruction.create(Code.EVEX_VSQRTPS_XMM_K1Z_XMMM128B32, ICRegisters.xmm2, ICRegisters.xmm3), Register.K1), TestInstrFlags.PREFER_EVEX);
	}

	@Test
	void vsqrtps_ymm_ymm() {
		{ /* if (getInstructionPreferVex()) */
			testAssembler(c -> c.vsqrtps(ymm2, ymm3), Instruction.create(Code.VEX_VSQRTPS_YMM_YMMM256, ICRegisters.ymm2, ICRegisters.ymm3), TestInstrFlags.PREFER_VEX);
		} /* else */ testAssembler(c -> c.vsqrtps(ymm2.k1(), ymm3), applyK(Instruction.create(Code.EVEX_VSQRTPS_YMM_K1Z_YMMM256B32, ICRegisters.ymm2, ICRegisters.ymm3), Register.K1), TestInstrFlags.PREFER_EVEX);
	}

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

	@Test
	void vsqrtps_xmm_m() {
		{ /* if (src.isBroadcast()) */
			testAssembler(c -> c.vsqrtps(xmm2.k1(), dword_bcst(0x0L).base(edx)), applyK(Instruction.create(Code.EVEX_VSQRTPS_XMM_K1Z_XMMM128B32, ICRegisters.xmm2, new MemoryOperand(ICRegisters.edx, ICRegister.NONE, 1, 0x0L, 0, true, ICRegister.NONE)), Register.K1), TestInstrFlags.PREFER_EVEX | TestInstrFlags.BROADCAST);
		} /* else */ { /* if (getInstructionPreferVex()) */
			testAssembler(c -> c.vsqrtps(xmm2, xmmword_ptr(0x0L).base(ecx)), Instruction.create(Code.VEX_VSQRTPS_XMM_XMMM128, ICRegisters.xmm2, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE)), TestInstrFlags.PREFER_VEX);
		} /* else */ testAssembler(c -> c.vsqrtps(xmm2.k1(), xmmword_ptr(0x0L).base(ecx)), applyK(Instruction.create(Code.EVEX_VSQRTPS_XMM_K1Z_XMMM128B32, ICRegisters.xmm2, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE)), Register.K1), TestInstrFlags.PREFER_EVEX);
	}

	@Test
	void vsqrtps_ymm_m() {
		{ /* if (src.isBroadcast()) */
			testAssembler(c -> c.vsqrtps(ymm2.k1(), dword_bcst(0x0L).base(edx)), applyK(Instruction.create(Code.EVEX_VSQRTPS_YMM_K1Z_YMMM256B32, ICRegisters.ymm2, new MemoryOperand(ICRegisters.edx, ICRegister.NONE, 1, 0x0L, 0, true, ICRegister.NONE)), Register.K1), TestInstrFlags.PREFER_EVEX | TestInstrFlags.BROADCAST);
		} /* else */ { /* if (getInstructionPreferVex()) */
			testAssembler(c -> c.vsqrtps(ymm2, ymmword_ptr(0x0L).base(ecx)), Instruction.create(Code.VEX_VSQRTPS_YMM_YMMM256, ICRegisters.ymm2, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE)), TestInstrFlags.PREFER_VEX);
		} /* else */ testAssembler(c -> c.vsqrtps(ymm2.k1(), ymmword_ptr(0x0L).base(ecx)), applyK(Instruction.create(Code.EVEX_VSQRTPS_YMM_K1Z_YMMM256B32, ICRegisters.ymm2, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE)), Register.K1), TestInstrFlags.PREFER_EVEX);
	}

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

	@Test
	void vsqrtsd_xmm_xmm_xmm() {
		{ /* if (getInstructionPreferVex()) */
			testAssembler(c -> c.vsqrtsd(xmm2, xmm3, xmm4), Instruction.create(Code.VEX_VSQRTSD_XMM_XMM_XMMM64, ICRegisters.xmm2, ICRegisters.xmm3, ICRegisters.xmm4), TestInstrFlags.PREFER_VEX);
		} /* else */ testAssembler(c -> c.vsqrtsd(xmm2.k1(), xmm3, xmm4), applyK(Instruction.create(Code.EVEX_VSQRTSD_XMM_K1Z_XMM_XMMM64_ER, ICRegisters.xmm2, ICRegisters.xmm3, ICRegisters.xmm4), Register.K1), TestInstrFlags.PREFER_EVEX);
	}

	@Test
	void vsqrtsd_xmm_xmm_m() {
		{ /* if (getInstructionPreferVex()) */
			testAssembler(c -> c.vsqrtsd(xmm2, xmm3, xmmword_ptr(0x0L).base(ecx)), Instruction.create(Code.VEX_VSQRTSD_XMM_XMM_XMMM64, ICRegisters.xmm2, ICRegisters.xmm3, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE)), TestInstrFlags.PREFER_VEX);
		} /* else */ testAssembler(c -> c.vsqrtsd(xmm2.k1(), xmm3, xmmword_ptr(0x0L).base(ecx)), applyK(Instruction.create(Code.EVEX_VSQRTSD_XMM_K1Z_XMM_XMMM64_ER, ICRegisters.xmm2, ICRegisters.xmm3, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE)), Register.K1), TestInstrFlags.PREFER_EVEX);
	}

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

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

	@Test
	void vsqrtss_xmm_xmm_xmm() {
		{ /* if (getInstructionPreferVex()) */
			testAssembler(c -> c.vsqrtss(xmm2, xmm3, xmm4), Instruction.create(Code.VEX_VSQRTSS_XMM_XMM_XMMM32, ICRegisters.xmm2, ICRegisters.xmm3, ICRegisters.xmm4), TestInstrFlags.PREFER_VEX);
		} /* else */ testAssembler(c -> c.vsqrtss(xmm2.k1(), xmm3, xmm4), applyK(Instruction.create(Code.EVEX_VSQRTSS_XMM_K1Z_XMM_XMMM32_ER, ICRegisters.xmm2, ICRegisters.xmm3, ICRegisters.xmm4), Register.K1), TestInstrFlags.PREFER_EVEX);
	}

	@Test
	void vsqrtss_xmm_xmm_m() {
		{ /* if (getInstructionPreferVex()) */
			testAssembler(c -> c.vsqrtss(xmm2, xmm3, xmmword_ptr(0x0L).base(ecx)), Instruction.create(Code.VEX_VSQRTSS_XMM_XMM_XMMM32, ICRegisters.xmm2, ICRegisters.xmm3, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE)), TestInstrFlags.PREFER_VEX);
		} /* else */ testAssembler(c -> c.vsqrtss(xmm2.k1(), xmm3, xmmword_ptr(0x0L).base(ecx)), applyK(Instruction.create(Code.EVEX_VSQRTSS_XMM_K1Z_XMM_XMMM32_ER, ICRegisters.xmm2, ICRegisters.xmm3, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE)), Register.K1), TestInstrFlags.PREFER_EVEX);
	}

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

	@Test
	void vsubpd_xmm_xmm_xmm() {
		{ /* if (getInstructionPreferVex()) */
			testAssembler(c -> c.vsubpd(xmm2, xmm3, xmm4), Instruction.create(Code.VEX_VSUBPD_XMM_XMM_XMMM128, ICRegisters.xmm2, ICRegisters.xmm3, ICRegisters.xmm4), TestInstrFlags.PREFER_VEX);
		} /* else */ testAssembler(c -> c.vsubpd(xmm2.k1(), xmm3, xmm4), applyK(Instruction.create(Code.EVEX_VSUBPD_XMM_K1Z_XMM_XMMM128B64, ICRegisters.xmm2, ICRegisters.xmm3, ICRegisters.xmm4), Register.K1), TestInstrFlags.PREFER_EVEX);
	}

	@Test
	void vsubpd_ymm_ymm_ymm() {
		{ /* if (getInstructionPreferVex()) */
			testAssembler(c -> c.vsubpd(ymm2, ymm3, ymm4), Instruction.create(Code.VEX_VSUBPD_YMM_YMM_YMMM256, ICRegisters.ymm2, ICRegisters.ymm3, ICRegisters.ymm4), TestInstrFlags.PREFER_VEX);
		} /* else */ testAssembler(c -> c.vsubpd(ymm2.k1(), ymm3, ymm4), applyK(Instruction.create(Code.EVEX_VSUBPD_YMM_K1Z_YMM_YMMM256B64, ICRegisters.ymm2, ICRegisters.ymm3, ICRegisters.ymm4), Register.K1), TestInstrFlags.PREFER_EVEX);
	}

	@Test
	void vsubpd_zmm_zmm_zmm() {
		testAssembler(c -> c.vsubpd(zmm2.k1(), zmm3, zmm4), applyK(Instruction.create(Code.EVEX_VSUBPD_ZMM_K1Z_ZMM_ZMMM512B64_ER, ICRegisters.zmm2, ICRegisters.zmm3, ICRegisters.zmm4), Register.K1));
	}

	@Test
	void vsubpd_xmm_xmm_m() {
		{ /* if (src2.isBroadcast()) */
			testAssembler(c -> c.vsubpd(xmm2.k1(), xmm3, dword_bcst(0x0L).base(edx)), applyK(Instruction.create(Code.EVEX_VSUBPD_XMM_K1Z_XMM_XMMM128B64, ICRegisters.xmm2, ICRegisters.xmm3, new MemoryOperand(ICRegisters.edx, ICRegister.NONE, 1, 0x0L, 0, true, ICRegister.NONE)), Register.K1), TestInstrFlags.PREFER_EVEX | TestInstrFlags.BROADCAST);
		} /* else */ { /* if (getInstructionPreferVex()) */
			testAssembler(c -> c.vsubpd(xmm2, xmm3, xmmword_ptr(0x0L).base(ecx)), Instruction.create(Code.VEX_VSUBPD_XMM_XMM_XMMM128, ICRegisters.xmm2, ICRegisters.xmm3, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE)), TestInstrFlags.PREFER_VEX);
		} /* else */ testAssembler(c -> c.vsubpd(xmm2.k1(), xmm3, xmmword_ptr(0x0L).base(ecx)), applyK(Instruction.create(Code.EVEX_VSUBPD_XMM_K1Z_XMM_XMMM128B64, ICRegisters.xmm2, ICRegisters.xmm3, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE)), Register.K1), TestInstrFlags.PREFER_EVEX);
	}

	@Test
	void vsubpd_ymm_ymm_m() {
		{ /* if (src2.isBroadcast()) */
			testAssembler(c -> c.vsubpd(ymm2.k1(), ymm3, dword_bcst(0x0L).base(edx)), applyK(Instruction.create(Code.EVEX_VSUBPD_YMM_K1Z_YMM_YMMM256B64, ICRegisters.ymm2, ICRegisters.ymm3, new MemoryOperand(ICRegisters.edx, ICRegister.NONE, 1, 0x0L, 0, true, ICRegister.NONE)), Register.K1), TestInstrFlags.PREFER_EVEX | TestInstrFlags.BROADCAST);
		} /* else */ { /* if (getInstructionPreferVex()) */
			testAssembler(c -> c.vsubpd(ymm2, ymm3, ymmword_ptr(0x0L).base(ecx)), Instruction.create(Code.VEX_VSUBPD_YMM_YMM_YMMM256, ICRegisters.ymm2, ICRegisters.ymm3, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE)), TestInstrFlags.PREFER_VEX);
		} /* else */ testAssembler(c -> c.vsubpd(ymm2.k1(), ymm3, ymmword_ptr(0x0L).base(ecx)), applyK(Instruction.create(Code.EVEX_VSUBPD_YMM_K1Z_YMM_YMMM256B64, ICRegisters.ymm2, ICRegisters.ymm3, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE)), Register.K1), TestInstrFlags.PREFER_EVEX);
	}

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

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

	@Test
	void vsubph_ymm_ymm_ymm() {
		testAssembler(c -> c.vsubph(ymm2.k1(), ymm3, ymm4), applyK(Instruction.create(Code.EVEX_VSUBPH_YMM_K1Z_YMM_YMMM256B16, ICRegisters.ymm2, ICRegisters.ymm3, ICRegisters.ymm4), Register.K1));
	}

	@Test
	void vsubph_zmm_zmm_zmm() {
		testAssembler(c -> c.vsubph(zmm2.k1(), zmm3, zmm4), applyK(Instruction.create(Code.EVEX_VSUBPH_ZMM_K1Z_ZMM_ZMMM512B16_ER, ICRegisters.zmm2, ICRegisters.zmm3, ICRegisters.zmm4), Register.K1));
	}

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

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

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

	@Test
	void vsubps_xmm_xmm_xmm() {
		{ /* if (getInstructionPreferVex()) */
			testAssembler(c -> c.vsubps(xmm2, xmm3, xmm4), Instruction.create(Code.VEX_VSUBPS_XMM_XMM_XMMM128, ICRegisters.xmm2, ICRegisters.xmm3, ICRegisters.xmm4), TestInstrFlags.PREFER_VEX);
		} /* else */ testAssembler(c -> c.vsubps(xmm2.k1(), xmm3, xmm4), applyK(Instruction.create(Code.EVEX_VSUBPS_XMM_K1Z_XMM_XMMM128B32, ICRegisters.xmm2, ICRegisters.xmm3, ICRegisters.xmm4), Register.K1), TestInstrFlags.PREFER_EVEX);
	}

	@Test
	void vsubps_ymm_ymm_ymm() {
		{ /* if (getInstructionPreferVex()) */
			testAssembler(c -> c.vsubps(ymm2, ymm3, ymm4), Instruction.create(Code.VEX_VSUBPS_YMM_YMM_YMMM256, ICRegisters.ymm2, ICRegisters.ymm3, ICRegisters.ymm4), TestInstrFlags.PREFER_VEX);
		} /* else */ testAssembler(c -> c.vsubps(ymm2.k1(), ymm3, ymm4), applyK(Instruction.create(Code.EVEX_VSUBPS_YMM_K1Z_YMM_YMMM256B32, ICRegisters.ymm2, ICRegisters.ymm3, ICRegisters.ymm4), Register.K1), TestInstrFlags.PREFER_EVEX);
	}

	@Test
	void vsubps_zmm_zmm_zmm() {
		testAssembler(c -> c.vsubps(zmm2.k1(), zmm3, zmm4), applyK(Instruction.create(Code.EVEX_VSUBPS_ZMM_K1Z_ZMM_ZMMM512B32_ER, ICRegisters.zmm2, ICRegisters.zmm3, ICRegisters.zmm4), Register.K1));
	}

	@Test
	void vsubps_xmm_xmm_m() {
		{ /* if (src2.isBroadcast()) */
			testAssembler(c -> c.vsubps(xmm2.k1(), xmm3, dword_bcst(0x0L).base(edx)), applyK(Instruction.create(Code.EVEX_VSUBPS_XMM_K1Z_XMM_XMMM128B32, ICRegisters.xmm2, ICRegisters.xmm3, new MemoryOperand(ICRegisters.edx, ICRegister.NONE, 1, 0x0L, 0, true, ICRegister.NONE)), Register.K1), TestInstrFlags.PREFER_EVEX | TestInstrFlags.BROADCAST);
		} /* else */ { /* if (getInstructionPreferVex()) */
			testAssembler(c -> c.vsubps(xmm2, xmm3, xmmword_ptr(0x0L).base(ecx)), Instruction.create(Code.VEX_VSUBPS_XMM_XMM_XMMM128, ICRegisters.xmm2, ICRegisters.xmm3, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE)), TestInstrFlags.PREFER_VEX);
		} /* else */ testAssembler(c -> c.vsubps(xmm2.k1(), xmm3, xmmword_ptr(0x0L).base(ecx)), applyK(Instruction.create(Code.EVEX_VSUBPS_XMM_K1Z_XMM_XMMM128B32, ICRegisters.xmm2, ICRegisters.xmm3, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE)), Register.K1), TestInstrFlags.PREFER_EVEX);
	}

	@Test
	void vsubps_ymm_ymm_m() {
		{ /* if (src2.isBroadcast()) */
			testAssembler(c -> c.vsubps(ymm2.k1(), ymm3, dword_bcst(0x0L).base(edx)), applyK(Instruction.create(Code.EVEX_VSUBPS_YMM_K1Z_YMM_YMMM256B32, ICRegisters.ymm2, ICRegisters.ymm3, new MemoryOperand(ICRegisters.edx, ICRegister.NONE, 1, 0x0L, 0, true, ICRegister.NONE)), Register.K1), TestInstrFlags.PREFER_EVEX | TestInstrFlags.BROADCAST);
		} /* else */ { /* if (getInstructionPreferVex()) */
			testAssembler(c -> c.vsubps(ymm2, ymm3, ymmword_ptr(0x0L).base(ecx)), Instruction.create(Code.VEX_VSUBPS_YMM_YMM_YMMM256, ICRegisters.ymm2, ICRegisters.ymm3, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE)), TestInstrFlags.PREFER_VEX);
		} /* else */ testAssembler(c -> c.vsubps(ymm2.k1(), ymm3, ymmword_ptr(0x0L).base(ecx)), applyK(Instruction.create(Code.EVEX_VSUBPS_YMM_K1Z_YMM_YMMM256B32, ICRegisters.ymm2, ICRegisters.ymm3, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE)), Register.K1), TestInstrFlags.PREFER_EVEX);
	}

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

	@Test
	void vsubsd_xmm_xmm_xmm() {
		{ /* if (getInstructionPreferVex()) */
			testAssembler(c -> c.vsubsd(xmm2, xmm3, xmm4), Instruction.create(Code.VEX_VSUBSD_XMM_XMM_XMMM64, ICRegisters.xmm2, ICRegisters.xmm3, ICRegisters.xmm4), TestInstrFlags.PREFER_VEX);
		} /* else */ testAssembler(c -> c.vsubsd(xmm2.k1(), xmm3, xmm4), applyK(Instruction.create(Code.EVEX_VSUBSD_XMM_K1Z_XMM_XMMM64_ER, ICRegisters.xmm2, ICRegisters.xmm3, ICRegisters.xmm4), Register.K1), TestInstrFlags.PREFER_EVEX);
	}

	@Test
	void vsubsd_xmm_xmm_m() {
		{ /* if (getInstructionPreferVex()) */
			testAssembler(c -> c.vsubsd(xmm2, xmm3, xmmword_ptr(0x0L).base(ecx)), Instruction.create(Code.VEX_VSUBSD_XMM_XMM_XMMM64, ICRegisters.xmm2, ICRegisters.xmm3, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE)), TestInstrFlags.PREFER_VEX);
		} /* else */ testAssembler(c -> c.vsubsd(xmm2.k1(), xmm3, xmmword_ptr(0x0L).base(ecx)), applyK(Instruction.create(Code.EVEX_VSUBSD_XMM_K1Z_XMM_XMMM64_ER, ICRegisters.xmm2, ICRegisters.xmm3, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE)), Register.K1), TestInstrFlags.PREFER_EVEX);
	}

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

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

	@Test
	void vsubss_xmm_xmm_xmm() {
		{ /* if (getInstructionPreferVex()) */
			testAssembler(c -> c.vsubss(xmm2, xmm3, xmm4), Instruction.create(Code.VEX_VSUBSS_XMM_XMM_XMMM32, ICRegisters.xmm2, ICRegisters.xmm3, ICRegisters.xmm4), TestInstrFlags.PREFER_VEX);
		} /* else */ testAssembler(c -> c.vsubss(xmm2.k1(), xmm3, xmm4), applyK(Instruction.create(Code.EVEX_VSUBSS_XMM_K1Z_XMM_XMMM32_ER, ICRegisters.xmm2, ICRegisters.xmm3, ICRegisters.xmm4), Register.K1), TestInstrFlags.PREFER_EVEX);
	}

	@Test
	void vsubss_xmm_xmm_m() {
		{ /* if (getInstructionPreferVex()) */
			testAssembler(c -> c.vsubss(xmm2, xmm3, xmmword_ptr(0x0L).base(ecx)), Instruction.create(Code.VEX_VSUBSS_XMM_XMM_XMMM32, ICRegisters.xmm2, ICRegisters.xmm3, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE)), TestInstrFlags.PREFER_VEX);
		} /* else */ testAssembler(c -> c.vsubss(xmm2.k1(), xmm3, xmmword_ptr(0x0L).base(ecx)), applyK(Instruction.create(Code.EVEX_VSUBSS_XMM_K1Z_XMM_XMMM32_ER, ICRegisters.xmm2, ICRegisters.xmm3, new MemoryOperand(ICRegisters.ecx, ICRegister.NONE, 1, 0x0L, 0, false, ICRegister.NONE)), Register.K1), TestInstrFlags.PREFER_EVEX);
	}

}
