diff options
author | 2022-02-11 17:16:46 +0700 | |
---|---|---|
committer | 2022-02-13 21:26:55 +0700 | |
commit | 1fba2b4f2c27a2f4162855056f9765ee79db31e9 (patch) | |
tree | f98b63565a8b12895b0bb057c0790b88b11a7b2e /3rdparty/asmjit/test | |
parent | 3a7e08d47d4e1b0e075360e19be1763d9b29f557 (diff) |
asmjit: sync with upstream
Diffstat (limited to '3rdparty/asmjit/test')
25 files changed, 38552 insertions, 7630 deletions
diff --git a/3rdparty/asmjit/test/asmjit_bench_x86.cpp b/3rdparty/asmjit/test/asmjit_bench_x86.cpp deleted file mode 100644 index 40d90088c01..00000000000 --- a/3rdparty/asmjit/test/asmjit_bench_x86.cpp +++ /dev/null @@ -1,172 +0,0 @@ -// AsmJit - Machine code generation for C++ -// -// * Official AsmJit Home Page: https://asmjit.com -// * Official Github Repository: https://github.com/asmjit/asmjit -// -// Copyright (c) 2008-2020 The AsmJit Authors -// -// This software is provided 'as-is', without any express or implied -// warranty. In no event will the authors be held liable for any damages -// arising from the use of this software. -// -// Permission is granted to anyone to use this software for any purpose, -// including commercial applications, and to alter it and redistribute it -// freely, subject to the following restrictions: -// -// 1. The origin of this software must not be misrepresented; you must not -// claim that you wrote the original software. If you use this software -// in a product, an acknowledgment in the product documentation would be -// appreciated but is not required. -// 2. Altered source versions must be plainly marked as such, and must not be -// misrepresented as being the original software. -// 3. This notice may not be removed or altered from any source distribution. - -#include <asmjit/x86.h> -#include <stdio.h> -#include <string.h> - -#include "./asmjit_test_opcode.h" - -#ifndef ASMJIT_NO_COMPILER - #include "./asmjit_test_misc.h" -#endif - -using namespace asmjit; - -// ============================================================================ -// [Configuration] -// ============================================================================ - -static constexpr uint32_t kNumRepeats = 20; -static constexpr uint32_t kNumIterations = 1000; - -// ============================================================================ -// [BenchUtils] -// ============================================================================ - -namespace BenchUtils { - class Performance { - public: - inline Performance() noexcept { reset(); } - - inline void reset() noexcept { - tick = 0u; - best = 0xFFFFFFFFu; - } - - inline uint32_t start() noexcept { return (tick = now()); } - inline uint32_t diff() const noexcept { return now() - tick; } - - inline uint32_t end() noexcept { - tick = diff(); - if (best > tick) - best = tick; - return tick; - } - - static inline uint32_t now() noexcept { - return OSUtils::getTickCount(); - } - - uint32_t tick; - uint32_t best; - }; - - static double mbps(uint32_t time, uint64_t outputSize) noexcept { - if (!time) return 0.0; - - double bytesTotal = double(outputSize); - return (bytesTotal * 1000) / (double(time) * 1024 * 1024); - } - - template<typename EmitterT, typename FuncT> - static void bench(CodeHolder& code, uint32_t arch, const char* testName, const FuncT& func) noexcept { - EmitterT emitter; - - const char* archName = - arch == Environment::kArchX86 ? "X86" : - arch == Environment::kArchX64 ? "X64" : "???"; - - const char* emitterName = - emitter.isAssembler() ? "Assembler" : - emitter.isCompiler() ? "Compiler" : - emitter.isBuilder() ? "Builder" : "Unknown"; - - Performance perf; - uint64_t codeSize = 0; - - Environment env(arch); - - for (uint32_t r = 0; r < kNumRepeats; r++) { - perf.start(); - codeSize = 0; - for (uint32_t i = 0; i < kNumIterations; i++) { - code.init(env); - code.attach(&emitter); - - func(emitter); - codeSize += code.codeSize(); - - code.reset(); - } - perf.end(); - } - - printf("[%s] %-9s %-10s | Time:%6u [ms] | ", archName, emitterName, testName, perf.best); - if (codeSize) - printf("Speed: %7.3f [MB/s]", mbps(perf.best, codeSize)); - else - printf("Speed: N/A"); - printf("\n"); - } -} - -// ============================================================================ -// [Main] -// ============================================================================ - -#ifdef ASMJIT_BUILD_X86 -static void benchX86(uint32_t arch) noexcept { - CodeHolder code; - - BenchUtils::bench<x86::Assembler>(code, arch, "[fast]", [](x86::Assembler& a) { - asmtest::generateOpcodes(a.as<x86::Emitter>()); - }); - - BenchUtils::bench<x86::Assembler>(code, arch, "[validate]", [](x86::Assembler& a) { - a.addValidationOptions(BaseEmitter::kValidationOptionAssembler); - asmtest::generateOpcodes(a.as<x86::Emitter>()); - }); - -#ifndef ASMJIT_NO_BUILDER - BenchUtils::bench<x86::Builder>(code, arch, "[no-asm]", [](x86::Builder& cb) { - asmtest::generateOpcodes(cb.as<x86::Emitter>()); - }); - - BenchUtils::bench<x86::Builder>(code, arch, "[asm]", [](x86::Builder& cb) { - asmtest::generateOpcodes(cb.as<x86::Emitter>()); - cb.finalize(); - }); -#endif - -#ifndef ASMJIT_NO_COMPILER - BenchUtils::bench<x86::Compiler>(code, arch, "[no-asm]", [](x86::Compiler& cc) { - asmtest::generateAlphaBlend(cc); - }); - - BenchUtils::bench<x86::Compiler>(code, arch, "[asm]", [](x86::Compiler& cc) { - asmtest::generateAlphaBlend(cc); - cc.finalize(); - }); -#endif -} -#endif - -int main() { -#ifdef ASMJIT_BUILD_X86 - benchX86(Environment::kArchX86); - benchX86(Environment::kArchX64); -#endif - - return 0; -} diff --git a/3rdparty/asmjit/test/asmjit_test_assembler.cpp b/3rdparty/asmjit/test/asmjit_test_assembler.cpp new file mode 100644 index 00000000000..4b40a751fe4 --- /dev/null +++ b/3rdparty/asmjit/test/asmjit_test_assembler.cpp @@ -0,0 +1,84 @@ +// This file is part of AsmJit project <https://asmjit.com> +// +// See asmjit.h or LICENSE.md for license and copyright information +// SPDX-License-Identifier: Zlib + +#include <asmjit/core.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> + +#include "asmjit_test_assembler.h" +#include "cmdline.h" + +using namespace asmjit; + +#if !defined(ASMJIT_NO_X86) +bool testX86Assembler(const TestSettings& settings) noexcept; +bool testX64Assembler(const TestSettings& settings) noexcept; +#endif + +#if !defined(ASMJIT_NO_AARCH64) +bool testA64Assembler(const TestSettings& settings) noexcept; +#endif + +int main(int argc, char* argv[]) { + CmdLine cmdLine(argc, argv); + + TestSettings settings {}; + settings.quiet = cmdLine.hasArg("--quiet"); + settings.validate = cmdLine.hasArg("--validate"); + + printf("AsmJit Assembler Test-Suite v%u.%u.%u:\n\n", + unsigned((ASMJIT_LIBRARY_VERSION >> 16) ), + unsigned((ASMJIT_LIBRARY_VERSION >> 8) & 0xFF), + unsigned((ASMJIT_LIBRARY_VERSION ) & 0xFF)); + + printf("Usage:\n"); + printf(" --help Show usage only\n"); + printf(" --arch=<ARCH> Select architecture to run ('all' by default)\n"); + printf(" --quiet Show only assembling errors [%s]\n", settings.quiet ? "x" : " "); + printf(" --validate Use instruction validation [%s]\n", settings.validate ? "x" : " "); + printf("\n"); + + if (cmdLine.hasArg("--help")) + return 0; + + const char* arch = cmdLine.valueOf("--arch", "all"); + bool x86Failed = false; + bool x64Failed = false; + bool aarch64Failed = false; + +#if !defined(ASMJIT_NO_X86) + if ((strcmp(arch, "all") == 0 || strcmp(arch, "x86") == 0)) + x86Failed = !testX86Assembler(settings); + + if ((strcmp(arch, "all") == 0 || strcmp(arch, "x64") == 0)) + x64Failed = !testX64Assembler(settings); +#endif + +#if !defined(ASMJIT_NO_AARCH64) + if ((strcmp(arch, "all") == 0 || strcmp(arch, "aarch64") == 0)) + aarch64Failed = !testA64Assembler(settings); +#endif + + bool failed = x86Failed || x64Failed || aarch64Failed; + + if (failed) { + if (x86Failed) + printf("** X86 test suite failed **\n"); + + if (x64Failed) + printf("** X64 test suite failed **\n"); + + if (aarch64Failed) + printf("** AArch64 test suite failed **\n"); + + printf("** FAILURE **\n"); + } + else { + printf("** SUCCESS **\n"); + } + + return failed ? 1 : 0; +} diff --git a/3rdparty/asmjit/test/asmjit_test_assembler.h b/3rdparty/asmjit/test/asmjit_test_assembler.h new file mode 100644 index 00000000000..61d774bbb1d --- /dev/null +++ b/3rdparty/asmjit/test/asmjit_test_assembler.h @@ -0,0 +1,85 @@ +// This file is part of AsmJit project <https://asmjit.com> +// +// See asmjit.h or LICENSE.md for license and copyright information +// SPDX-License-Identifier: Zlib + +#ifndef ASMJIT_TEST_ASSEMBLER_H_INCLUDED +#define ASMJIT_TEST_ASSEMBLER_H_INCLUDED + +#include <asmjit/core.h> +#include <stdio.h> + +struct TestSettings { + bool quiet; + bool validate; +}; + +template<typename AssemblerType> +class AssemblerTester { +public: + asmjit::Environment env {}; + asmjit::CodeHolder code {}; + AssemblerType assembler {}; + asmjit::Label L0 {}; + const TestSettings& settings; + + size_t passed {}; + size_t count {}; + + AssemblerTester(asmjit::Arch arch, const TestSettings& settings) noexcept + : env(arch), + settings(settings) { + prepare(); + } + + void printHeader(const char* archName) noexcept { + printf("%s assembler tests:\n", archName); + } + + void printSummary() noexcept { + printf(" Passed: %zu / %zu tests\n\n", passed, count); + } + + bool didPass() const noexcept { return passed == count; } + + void prepare() noexcept { + code.reset(); + code.init(env, 0); + code.attach(&assembler); + L0 = assembler.newLabel(); + + if (settings.validate) + assembler.addDiagnosticOptions(asmjit::DiagnosticOptions::kValidateAssembler); + } + + ASMJIT_NOINLINE bool testInstruction(const char* expectedOpcode, const char* s, uint32_t err) noexcept { + count++; + + if (err) { + printf(" !! %s\n" + " <%s>\n", s, asmjit::DebugUtils::errorAsString(err)); + prepare(); + return false; + } + + asmjit::String encodedOpcode; + asmjit::Section* text = code.textSection(); + + encodedOpcode.appendHex(text->data(), text->bufferSize()); + if (encodedOpcode != expectedOpcode) { + printf(" !! [%s] <- %s\n" + " [%s] (Expected)\n", encodedOpcode.data(), s, expectedOpcode); + prepare(); + return false; + } + + if (!settings.quiet) + printf(" OK [%s] <- %s\n", encodedOpcode.data(), s); + + passed++; + prepare(); + return true; + } +}; + +#endif // ASMJIT_TEST_ASSEMBLER_H_INCLUDED diff --git a/3rdparty/asmjit/test/asmjit_test_assembler_a64.cpp b/3rdparty/asmjit/test/asmjit_test_assembler_a64.cpp new file mode 100644 index 00000000000..a1d1178532f --- /dev/null +++ b/3rdparty/asmjit/test/asmjit_test_assembler_a64.cpp @@ -0,0 +1,4006 @@ +// This file is part of AsmJit project <https://asmjit.com> +// +// See asmjit.h or LICENSE.md for license and copyright information +// SPDX-License-Identifier: Zlib + +#include <asmjit/core.h> +#if !defined(ASMJIT_NO_AARCH64) + +#include <asmjit/a64.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> + +#include "asmjit_test_assembler.h" +#include "cmdline.h" + +using namespace asmjit; + +#define TEST_INSTRUCTION(OPCODE, ...) \ + tester.testInstruction(OPCODE, #__VA_ARGS__, tester.assembler.__VA_ARGS__) + +static void ASMJIT_NOINLINE testA64AssemblerBase(AssemblerTester<a64::Assembler>& tester) noexcept { + using namespace a64; + + TEST_INSTRUCTION("4100031A", adc(w1, w2, w3)); + TEST_INSTRUCTION("4100039A", adc(x1, x2, x3)); + TEST_INSTRUCTION("E103031A", adc(w1, wzr, w3)); + TEST_INSTRUCTION("E103039A", adc(x1, xzr, x3)); + TEST_INSTRUCTION("5F00031A", adc(wzr, w2, w3)); + TEST_INSTRUCTION("5F00039A", adc(xzr, x2, x3)); + TEST_INSTRUCTION("4100033A", adcs(w1, w2, w3)); + TEST_INSTRUCTION("410003BA", adcs(x1, x2, x3)); + TEST_INSTRUCTION("4100030B", add(w1, w2, w3)); + TEST_INSTRUCTION("4100038B", add(x1, x2, x3)); + TEST_INSTRUCTION("410C030B", add(w1, w2, w3, lsl(3))); + TEST_INSTRUCTION("410C038B", add(x1, x2, x3, lsl(3))); + TEST_INSTRUCTION("FF030411", add(wsp, wsp, 256)); + TEST_INSTRUCTION("FFFF3F11", add(wsp, wsp, 0xFFF)); + TEST_INSTRUCTION("FF030491", add(sp, sp, 256)); + TEST_INSTRUCTION("FFFF3F91", add(sp, sp, 0xFFF)); + TEST_INSTRUCTION("E103030B", add(w1, wzr, w3)); + TEST_INSTRUCTION("E103038B", add(x1, xzr, x3)); + TEST_INSTRUCTION("5F00030B", add(wzr, w2, w3)); + TEST_INSTRUCTION("5F00038B", add(xzr, x2, x3)); + TEST_INSTRUCTION("83004011", add(w3, w4, 0, lsl(12))); + TEST_INSTRUCTION("83004091", add(x3, x4, 0, lsl(12))); + TEST_INSTRUCTION("83005011", add(w3, w4, 1024, lsl(12))); + TEST_INSTRUCTION("83005091", add(x3, x4, 1024, lsl(12))); + TEST_INSTRUCTION("83005011", add(w3, w4, 1024, lsl(12))); + TEST_INSTRUCTION("83005091", add(x3, x4, 1024, lsl(12))); + TEST_INSTRUCTION("FF830091", add(sp, sp, 32)); + TEST_INSTRUCTION("412C8291", addg(x1, x2, 32, 11)); + TEST_INSTRUCTION("5F2C8291", addg(sp, x2, 32, 11)); + TEST_INSTRUCTION("E12F8291", addg(x1, sp, 32, 11)); + TEST_INSTRUCTION("4100032B", adds(w1, w2, w3)); + TEST_INSTRUCTION("410003AB", adds(x1, x2, x3)); + TEST_INSTRUCTION("01000010", adr(x1, 0)); + TEST_INSTRUCTION("01080010", adr(x1, 256)); + TEST_INSTRUCTION("010000B0", adrp(x1, 4096)); + TEST_INSTRUCTION("4100030A", and_(w1, w2, w3)); + TEST_INSTRUCTION("4100038A", and_(x1, x2, x3)); + TEST_INSTRUCTION("41000012", and_(w1, w2, 1)); + TEST_INSTRUCTION("41004092", and_(x1, x2, 1)); + TEST_INSTRUCTION("410C0012", and_(w1, w2, 15)); + TEST_INSTRUCTION("410C4092", and_(x1, x2, 15)); + TEST_INSTRUCTION("3F1C0012", and_(wsp, w1, 0xFF)); + TEST_INSTRUCTION("3F1C4092", and_(sp, x1, 0xFF)); + TEST_INSTRUCTION("E103030A", and_(w1, wzr, w3)); + TEST_INSTRUCTION("E103038A", and_(x1, xzr, x3)); + TEST_INSTRUCTION("5F00030A", and_(wzr, w2, w3)); + TEST_INSTRUCTION("5F00038A", and_(xzr, x2, x3)); + TEST_INSTRUCTION("00000012", and_(w0, w0, 0x1)); + TEST_INSTRUCTION("00004092", and_(x0, x0, 0x1)); + TEST_INSTRUCTION("410C0012", and_(w1, w2, 0xf)); + TEST_INSTRUCTION("410C4092", and_(x1, x2, 0xf)); + TEST_INSTRUCTION("BFEC7C92", and_(sp, x5, 0xfffffffffffffff0)); + TEST_INSTRUCTION("4100036A", ands(w1, w2, w3)); + TEST_INSTRUCTION("410003EA", ands(x1, x2, x3)); + TEST_INSTRUCTION("E103036A", ands(w1, wzr, w3)); + TEST_INSTRUCTION("E10303EA", ands(x1, xzr, x3)); + TEST_INSTRUCTION("5F00036A", ands(wzr, w2, w3)); + TEST_INSTRUCTION("5F0003EA", ands(xzr, x2, x3)); + TEST_INSTRUCTION("00000072", ands(w0, w0, 0x1)); + TEST_INSTRUCTION("000040F2", ands(x0, x0, 0x1)); + TEST_INSTRUCTION("410C0072", ands(w1, w2, 0xf)); + TEST_INSTRUCTION("410C40F2", ands(x1, x2, 0xf)); + TEST_INSTRUCTION("417C0F13", asr(w1, w2, 15)); + TEST_INSTRUCTION("41FC4F93", asr(x1, x2, 15)); + TEST_INSTRUCTION("4128C31A", asrv(w1, w2, w3)); + TEST_INSTRUCTION("4128C39A", asrv(x1, x2, x3)); + TEST_INSTRUCTION("4F7808D5", at(Predicate::AT::kS1E0R, x15)); + TEST_INSTRUCTION("4118C1DA", autda(x1, x2)); + TEST_INSTRUCTION("E11BC1DA", autda(x1, sp)); + TEST_INSTRUCTION("411CC1DA", autdb(x1, x2)); + TEST_INSTRUCTION("E11FC1DA", autdb(x1, sp)); + TEST_INSTRUCTION("E13BC1DA", autdza(x1)); + TEST_INSTRUCTION("F43BC1DA", autdza(x20)); + TEST_INSTRUCTION("E13FC1DA", autdzb(x1)); + TEST_INSTRUCTION("F43FC1DA", autdzb(x20)); + TEST_INSTRUCTION("4110C1DA", autia(x1, x2)); + TEST_INSTRUCTION("E113C1DA", autia(x1, sp)); + TEST_INSTRUCTION("9F2103D5", autia1716()); + TEST_INSTRUCTION("BF2303D5", autiasp()); + TEST_INSTRUCTION("9F2303D5", autiaz()); + TEST_INSTRUCTION("4114C1DA", autib(x1, x2)); + TEST_INSTRUCTION("E117C1DA", autib(x1, sp)); + TEST_INSTRUCTION("DF2103D5", autib1716()); + TEST_INSTRUCTION("FF2303D5", autibsp()); + TEST_INSTRUCTION("DF2303D5", autibz()); + TEST_INSTRUCTION("E133C1DA", autiza(x1)); + TEST_INSTRUCTION("F433C1DA", autiza(x20)); + TEST_INSTRUCTION("E137C1DA", autizb(x1)); + TEST_INSTRUCTION("F437C1DA", autizb(x20)); + TEST_INSTRUCTION("5F4000D5", axflag()); + TEST_INSTRUCTION("E13F1833", bfc(w1, 8, 16)); + TEST_INSTRUCTION("E13F78B3", bfc(x1, 8, 16)); + TEST_INSTRUCTION("413C1833", bfi(w1, w2, 8, 16)); + TEST_INSTRUCTION("413C78B3", bfi(x1, x2, 8, 16)); + TEST_INSTRUCTION("41400833", bfm(w1, w2, 8, 16)); + TEST_INSTRUCTION("414048B3", bfm(x1, x2, 8, 16)); + TEST_INSTRUCTION("415C0833", bfxil(w1, w2, 8, 16)); + TEST_INSTRUCTION("415C48B3", bfxil(x1, x2, 8, 16)); + TEST_INSTRUCTION("41781F12", bic(w1, w2, 1)); + TEST_INSTRUCTION("41F87F92", bic(x1, x2, 1)); + TEST_INSTRUCTION("416C1C12", bic(w1, w2, 15)); + TEST_INSTRUCTION("41EC7C92", bic(x1, x2, 15)); + TEST_INSTRUCTION("4110230A", bic(w1, w2, w3, lsl(4))); + TEST_INSTRUCTION("4110238A", bic(x1, x2, x3, lsl(4))); + TEST_INSTRUCTION("E103230A", bic(w1, wzr, w3)); + TEST_INSTRUCTION("E103238A", bic(x1, xzr, x3)); + TEST_INSTRUCTION("41781F72", bics(w1, w2, 1)); + TEST_INSTRUCTION("41F87FF2", bics(x1, x2, 1)); + TEST_INSTRUCTION("416C1C72", bics(w1, w2, 15)); + TEST_INSTRUCTION("41EC7CF2", bics(x1, x2, 15)); + TEST_INSTRUCTION("4110236A", bics(w1, w2, w3, lsl(4))); + TEST_INSTRUCTION("411023EA", bics(x1, x2, x3, lsl(4))); + TEST_INSTRUCTION("E103236A", bics(w1, wzr, w3)); + TEST_INSTRUCTION("E10323EA", bics(x1, xzr, x3)); + TEST_INSTRUCTION("60031FD6", br(x27)); + TEST_INSTRUCTION("E0031FD6", br(xzr)); + TEST_INSTRUCTION("200020D4", brk(1)); + TEST_INSTRUCTION("627CA188", cas(w1, w2, ptr(x3))); + TEST_INSTRUCTION("627CA1C8", cas(x1, x2, ptr(x3))); + TEST_INSTRUCTION("627CE188", casa(w1, w2, ptr(x3))); + TEST_INSTRUCTION("627CE1C8", casa(x1, x2, ptr(x3))); + TEST_INSTRUCTION("627CE108", casab(w1, w2, ptr(x3))); + TEST_INSTRUCTION("627CE148", casah(w1, w2, ptr(x3))); + TEST_INSTRUCTION("62FCE188", casal(w1, w2, ptr(x3))); + TEST_INSTRUCTION("62FCE1C8", casal(x1, x2, ptr(x3))); + TEST_INSTRUCTION("62FCE108", casalb(w1, w2, ptr(x3))); + TEST_INSTRUCTION("62FCE148", casalh(w1, w2, ptr(x3))); + TEST_INSTRUCTION("627CA108", casb(w1, w2, ptr(x3))); + TEST_INSTRUCTION("627CA148", cash(w1, w2, ptr(x3))); + TEST_INSTRUCTION("62FCA188", casl(w1, w2, ptr(x3))); + TEST_INSTRUCTION("62FCA1C8", casl(x1, x2, ptr(x3))); + TEST_INSTRUCTION("62FCA108", caslb(w1, w2, ptr(x3))); + TEST_INSTRUCTION("62FCA148", caslh(w1, w2, ptr(x3))); + TEST_INSTRUCTION("687C2208", casp(w2, w3, w8, w9, ptr(x3))); + TEST_INSTRUCTION("687C2248", casp(x2, x3, x8, x9, ptr(x3))); + TEST_INSTRUCTION("687C6208", caspa(w2, w3, w8, w9, ptr(x3))); + TEST_INSTRUCTION("687C6248", caspa(x2, x3, x8, x9, ptr(x3))); + TEST_INSTRUCTION("68FC6208", caspal(w2, w3, w8, w9, ptr(x3))); + TEST_INSTRUCTION("68FC6248", caspal(x2, x3, x8, x9, ptr(x3))); + TEST_INSTRUCTION("68FC2208", caspl(w2, w3, w8, w9, ptr(x3))); + TEST_INSTRUCTION("68FC2248", caspl(x2, x3, x8, x9, ptr(x3))); + TEST_INSTRUCTION("2300423A", ccmn(w1, w2, 3, CondCode::kEQ)); + TEST_INSTRUCTION("230042BA", ccmn(x1, x2, 3, CondCode::kEQ)); + TEST_INSTRUCTION("2308423A", ccmn(w1, 2, 3, CondCode::kEQ)); + TEST_INSTRUCTION("230842BA", ccmn(x1, 2, 3, CondCode::kEQ)); + TEST_INSTRUCTION("23005F3A", ccmn(w1, wzr, 3, CondCode::kEQ)); + TEST_INSTRUCTION("23005FBA", ccmn(x1, xzr, 3, CondCode::kEQ)); + TEST_INSTRUCTION("2300427A", ccmp(w1, w2, 3, CondCode::kEQ)); + TEST_INSTRUCTION("230042FA", ccmp(x1, x2, 3, CondCode::kEQ)); + TEST_INSTRUCTION("2308427A", ccmp(w1, 2, 3, CondCode::kEQ)); + TEST_INSTRUCTION("230842FA", ccmp(x1, 2, 3, CondCode::kEQ)); + TEST_INSTRUCTION("23005F7A", ccmp(w1, wzr, 3, CondCode::kEQ)); + TEST_INSTRUCTION("23005FFA", ccmp(x1, xzr, 3, CondCode::kEQ)); + TEST_INSTRUCTION("1F4000D5", cfinv()); + TEST_INSTRUCTION("4114821A", cinc(w1, w2, CondCode::kEQ)); + TEST_INSTRUCTION("4114829A", cinc(x1, x2, CondCode::kEQ)); + TEST_INSTRUCTION("5F14821A", cinc(wzr, w2, CondCode::kEQ)); + TEST_INSTRUCTION("E1179F1A", cinc(w1, wzr, CondCode::kEQ)); + TEST_INSTRUCTION("5F14829A", cinc(xzr, x2, CondCode::kEQ)); + TEST_INSTRUCTION("E1179F9A", cinc(x1, xzr, CondCode::kEQ)); + TEST_INSTRUCTION("4110825A", cinv(w1, w2, CondCode::kEQ)); + TEST_INSTRUCTION("411082DA", cinv(x1, x2, CondCode::kEQ)); + TEST_INSTRUCTION("5F10825A", cinv(wzr, w2, CondCode::kEQ)); + TEST_INSTRUCTION("E1139F5A", cinv(w1, wzr, CondCode::kEQ)); + TEST_INSTRUCTION("5F1082DA", cinv(xzr, x2, CondCode::kEQ)); + TEST_INSTRUCTION("E1139FDA", cinv(x1, xzr, CondCode::kEQ)); + TEST_INSTRUCTION("5F3B03D5", clrex(11)); + TEST_INSTRUCTION("4114C05A", cls(w1, w2)); + TEST_INSTRUCTION("4114C0DA", cls(x1, x2)); + TEST_INSTRUCTION("E117C05A", cls(w1, wzr)); + TEST_INSTRUCTION("E117C0DA", cls(x1, xzr)); + TEST_INSTRUCTION("5F14C05A", cls(wzr, w2)); + TEST_INSTRUCTION("5F14C0DA", cls(xzr, x2)); + TEST_INSTRUCTION("4110C05A", clz(w1, w2)); + TEST_INSTRUCTION("4110C0DA", clz(x1, x2)); + TEST_INSTRUCTION("E113C05A", clz(w1, wzr)); + TEST_INSTRUCTION("E113C0DA", clz(x1, xzr)); + TEST_INSTRUCTION("5F10C05A", clz(wzr, w2)); + TEST_INSTRUCTION("5F10C0DA", clz(xzr, x2)); + TEST_INSTRUCTION("3F840031", cmn(w1, 33)); + TEST_INSTRUCTION("3FFC4331", cmn(w1, 0xFF000)); + TEST_INSTRUCTION("FF030231", cmn(wsp, 128)); + TEST_INSTRUCTION("3F8400B1", cmn(x1, 33)); + TEST_INSTRUCTION("3FFC43B1", cmn(x1, 0xFF000)); + TEST_INSTRUCTION("FF0302B1", cmn(sp, 128)); + TEST_INSTRUCTION("3F00022B", cmn(w1, w2)); + TEST_INSTRUCTION("3F0002AB", cmn(x1, x2)); + TEST_INSTRUCTION("3F08222B", cmn(w1, w2, uxtb(2))); + TEST_INSTRUCTION("3F0822AB", cmn(x1, x2, uxtb(2))); + TEST_INSTRUCTION("FF43212B", cmn(wsp, w1)); + TEST_INSTRUCTION("FF07212B", cmn(wsp, w1, uxtb(1))); + TEST_INSTRUCTION("FF6321AB", cmn(sp, x1)); + TEST_INSTRUCTION("FF6721AB", cmn(sp, x1, uxtx(1))); + TEST_INSTRUCTION("3F840071", cmp(w1, 33)); + TEST_INSTRUCTION("3FFC4371", cmp(w1, 0xFF000)); + TEST_INSTRUCTION("FF030271", cmp(wsp, 128)); + TEST_INSTRUCTION("3F8400F1", cmp(x1, 33)); + TEST_INSTRUCTION("3FFC43F1", cmp(x1, 0xFF000)); + TEST_INSTRUCTION("FF0302F1", cmp(sp, 128)); + TEST_INSTRUCTION("3F00026B", cmp(w1, w2)); + TEST_INSTRUCTION("3F0002EB", cmp(x1, x2)); + TEST_INSTRUCTION("3F08226B", cmp(w1, w2, uxtb(2))); + TEST_INSTRUCTION("3F0822EB", cmp(x1, x2, uxtb(2))); + TEST_INSTRUCTION("FF43216B", cmp(wsp, w1)); + TEST_INSTRUCTION("FF07216B", cmp(wsp, w1, uxtb(1))); + TEST_INSTRUCTION("FF6321EB", cmp(sp, x1)); + TEST_INSTRUCTION("FF6721EB", cmp(sp, x1, uxtx(1))); + TEST_INSTRUCTION("3F00C2BA", cmpp(x1, x2)); + TEST_INSTRUCTION("3F00DFBA", cmpp(x1, sp)); + TEST_INSTRUCTION("FF03C2BA", cmpp(sp, x2)); + TEST_INSTRUCTION("FF03DFBA", cmpp(sp, sp)); + TEST_INSTRUCTION("4140C31A", crc32b(w1, w2, w3)); + TEST_INSTRUCTION("5F40C31A", crc32b(wzr, w2, w3)); + TEST_INSTRUCTION("E143C31A", crc32b(w1, wzr, w3)); + TEST_INSTRUCTION("4140DF1A", crc32b(w1, w2, wzr)); + TEST_INSTRUCTION("4150C31A", crc32cb(w1, w2, w3)); + TEST_INSTRUCTION("5F50C31A", crc32cb(wzr, w2, w3)); + TEST_INSTRUCTION("E153C31A", crc32cb(w1, wzr, w3)); + TEST_INSTRUCTION("4150DF1A", crc32cb(w1, w2, wzr)); + TEST_INSTRUCTION("4154C31A", crc32ch(w1, w2, w3)); + TEST_INSTRUCTION("5F54C31A", crc32ch(wzr, w2, w3)); + TEST_INSTRUCTION("E157C31A", crc32ch(w1, wzr, w3)); + TEST_INSTRUCTION("4154DF1A", crc32ch(w1, w2, wzr)); + TEST_INSTRUCTION("4158C31A", crc32cw(w1, w2, w3)); + TEST_INSTRUCTION("5F58C31A", crc32cw(wzr, w2, w3)); + TEST_INSTRUCTION("E15BC31A", crc32cw(w1, wzr, w3)); + TEST_INSTRUCTION("4158DF1A", crc32cw(w1, w2, wzr)); + TEST_INSTRUCTION("415CC39A", crc32cx(w1, w2, x3)); + TEST_INSTRUCTION("5F5CC39A", crc32cx(wzr, w2, x3)); + TEST_INSTRUCTION("E15FC39A", crc32cx(w1, wzr, x3)); + TEST_INSTRUCTION("415CDF9A", crc32cx(w1, w2, xzr)); + TEST_INSTRUCTION("4144C31A", crc32h(w1, w2, w3)); + TEST_INSTRUCTION("5F44C31A", crc32h(wzr, w2, w3)); + TEST_INSTRUCTION("E147C31A", crc32h(w1, wzr, w3)); + TEST_INSTRUCTION("4144DF1A", crc32h(w1, w2, wzr)); + TEST_INSTRUCTION("4148C31A", crc32w(w1, w2, w3)); + TEST_INSTRUCTION("5F48C31A", crc32w(wzr, w2, w3)); + TEST_INSTRUCTION("E14BC31A", crc32w(w1, wzr, w3)); + TEST_INSTRUCTION("4148DF1A", crc32w(w1, w2, wzr)); + TEST_INSTRUCTION("414CC39A", crc32x(w1, w2, x3)); + TEST_INSTRUCTION("5F4CC39A", crc32x(wzr, w2, x3)); + TEST_INSTRUCTION("E14FC39A", crc32x(w1, wzr, x3)); + TEST_INSTRUCTION("414CDF9A", crc32x(w1, w2, xzr)); + TEST_INSTRUCTION("9F2203D5", csdb()); + TEST_INSTRUCTION("4100831A", csel(w1, w2, w3, CondCode::kEQ)); + TEST_INSTRUCTION("4100839A", csel(x1, x2, x3, CondCode::kEQ)); + TEST_INSTRUCTION("E1179F1A", cset(w1, CondCode::kEQ)); + TEST_INSTRUCTION("E1179F9A", cset(x1, CondCode::kEQ)); + TEST_INSTRUCTION("E1179F1A", cset(w1, CondCode::kEQ)); + TEST_INSTRUCTION("E1179F9A", cset(x1, CondCode::kEQ)); + TEST_INSTRUCTION("E1139F5A", csetm(w1, CondCode::kEQ)); + TEST_INSTRUCTION("E1139FDA", csetm(x1, CondCode::kEQ)); + TEST_INSTRUCTION("4104831A", csinc(w1, w2, w3, CondCode::kEQ)); + TEST_INSTRUCTION("4104839A", csinc(x1, x2, x3, CondCode::kEQ)); + TEST_INSTRUCTION("4100835A", csinv(w1, w2, w3, CondCode::kEQ)); + TEST_INSTRUCTION("410083DA", csinv(x1, x2, x3, CondCode::kEQ)); + TEST_INSTRUCTION("4104835A", csneg(w1, w2, w3, CondCode::kEQ)); + TEST_INSTRUCTION("410483DA", csneg(x1, x2, x3, CondCode::kEQ)); + TEST_INSTRUCTION("2F740BD5", dc(Predicate::DC::kZVA, x15)); + TEST_INSTRUCTION("2100B0D4", dcps1(0x8001)); + TEST_INSTRUCTION("2200B0D4", dcps2(0x8001)); + TEST_INSTRUCTION("2300B0D4", dcps3(0x8001)); + TEST_INSTRUCTION("DF2003D5", dgh()); + TEST_INSTRUCTION("BF3103D5", dmb(1)); + TEST_INSTRUCTION("E003BFD6", drps()); + TEST_INSTRUCTION("9F3103D5", dsb(1)); + TEST_INSTRUCTION("4100234A", eon(w1, w2, w3)); + TEST_INSTRUCTION("5F00234A", eon(wzr, w2, w3)); + TEST_INSTRUCTION("E103234A", eon(w1, wzr, w3)); + TEST_INSTRUCTION("41003F4A", eon(w1, w2, wzr)); + TEST_INSTRUCTION("4110234A", eon(w1, w2, w3, lsl(4))); + TEST_INSTRUCTION("410023CA", eon(x1, x2, x3)); + TEST_INSTRUCTION("5F0023CA", eon(xzr, x2, x3)); + TEST_INSTRUCTION("E10323CA", eon(x1, xzr, x3)); + TEST_INSTRUCTION("41003FCA", eon(x1, x2, xzr)); + TEST_INSTRUCTION("411023CA", eon(x1, x2, x3, lsl(4))); + TEST_INSTRUCTION("4100034A", eor(w1, w2, w3)); + TEST_INSTRUCTION("5F00034A", eor(wzr, w2, w3)); + TEST_INSTRUCTION("E103034A", eor(w1, wzr, w3)); + TEST_INSTRUCTION("41001F4A", eor(w1, w2, wzr)); + TEST_INSTRUCTION("410003CA", eor(x1, x2, x3)); + TEST_INSTRUCTION("5F0003CA", eor(xzr, x2, x3)); + TEST_INSTRUCTION("E10303CA", eor(x1, xzr, x3)); + TEST_INSTRUCTION("41001FCA", eor(x1, x2, xzr)); + TEST_INSTRUCTION("4110034A", eor(w1, w2, w3, lsl(4))); + TEST_INSTRUCTION("411003CA", eor(x1, x2, x3, lsl(4))); + TEST_INSTRUCTION("3F1C0052", eor(wsp, w1, 0xFF)); + TEST_INSTRUCTION("FF1F0052", eor(wsp, wzr, 0xFF)); + TEST_INSTRUCTION("3F1C40D2", eor(sp, x1, 0xFF)); + TEST_INSTRUCTION("FF1F40D2", eor(sp, xzr, 0xFF)); + TEST_INSTRUCTION("41001252", eor(w1, w2, 0x4000)); + TEST_INSTRUCTION("410071D2", eor(x1, x2, 0x8000)); + TEST_INSTRUCTION("E0039FD6", eret()); + TEST_INSTRUCTION("1F2203D5", esb()); + TEST_INSTRUCTION("413C8313", extr(w1, w2, w3, 15)); + TEST_INSTRUCTION("5F3C8313", extr(wzr, w2, w3, 15)); + TEST_INSTRUCTION("E13F8313", extr(w1, wzr, w3, 15)); + TEST_INSTRUCTION("413C9F13", extr(w1, w2, wzr, 15)); + TEST_INSTRUCTION("413CC393", extr(x1, x2, x3, 15)); + TEST_INSTRUCTION("5F3CC393", extr(xzr, x2, x3, 15)); + TEST_INSTRUCTION("E13FC393", extr(x1, xzr, x3, 15)); + TEST_INSTRUCTION("413CDF93", extr(x1, x2, xzr, 15)); + TEST_INSTRUCTION("4114C39A", gmi(x1, x2, x3)); + TEST_INSTRUCTION("E117C39A", gmi(x1, sp, x3)); + TEST_INSTRUCTION("200040D4", hlt(1)); + TEST_INSTRUCTION("220000D4", hvc(1)); + TEST_INSTRUCTION("2F750BD5", ic(Predicate::IC::kIVAU, x15)); + TEST_INSTRUCTION("DF3103D5", isb(1)); + TEST_INSTRUCTION("620021B8", ldadd(w1, w2, ptr(x3))); + TEST_INSTRUCTION("E20321B8", ldadd(w1, w2, ptr(sp))); + TEST_INSTRUCTION("620021F8", ldadd(x1, x2, ptr(x3))); + TEST_INSTRUCTION("E20321F8", ldadd(x1, x2, ptr(sp))); + TEST_INSTRUCTION("6200A1B8", ldadda(w1, w2, ptr(x3))); + TEST_INSTRUCTION("E203A1B8", ldadda(w1, w2, ptr(sp))); + TEST_INSTRUCTION("6200A1F8", ldadda(x1, x2, ptr(x3))); + TEST_INSTRUCTION("E203A1F8", ldadda(x1, x2, ptr(sp))); + TEST_INSTRUCTION("6200A138", ldaddab(w1, w2, ptr(x3))); + TEST_INSTRUCTION("E203A138", ldaddab(w1, w2, ptr(sp))); + TEST_INSTRUCTION("6200A178", ldaddah(w1, w2, ptr(x3))); + TEST_INSTRUCTION("E203A178", ldaddah(w1, w2, ptr(sp))); + TEST_INSTRUCTION("6200E1B8", ldaddal(w1, w2, ptr(x3))); + TEST_INSTRUCTION("E203E1B8", ldaddal(w1, w2, ptr(sp))); + TEST_INSTRUCTION("6200E1F8", ldaddal(x1, x2, ptr(x3))); + TEST_INSTRUCTION("E203E1F8", ldaddal(x1, x2, ptr(sp))); + TEST_INSTRUCTION("6200E138", ldaddalb(w1, w2, ptr(x3))); + TEST_INSTRUCTION("E203E138", ldaddalb(w1, w2, ptr(sp))); + TEST_INSTRUCTION("6200E178", ldaddalh(w1, w2, ptr(x3))); + TEST_INSTRUCTION("E203E178", ldaddalh(w1, w2, ptr(sp))); + TEST_INSTRUCTION("62002138", ldaddb(w1, w2, ptr(x3))); + TEST_INSTRUCTION("E2032138", ldaddb(w1, w2, ptr(sp))); + TEST_INSTRUCTION("62002178", ldaddh(w1, w2, ptr(x3))); + TEST_INSTRUCTION("E2032178", ldaddh(w1, w2, ptr(sp))); + TEST_INSTRUCTION("620061B8", ldaddl(w1, w2, ptr(x3))); + TEST_INSTRUCTION("E20361B8", ldaddl(w1, w2, ptr(sp))); + TEST_INSTRUCTION("620061F8", ldaddl(x1, x2, ptr(x3))); + TEST_INSTRUCTION("E20361F8", ldaddl(x1, x2, ptr(sp))); + TEST_INSTRUCTION("62006138", ldaddlb(w1, w2, ptr(x3))); + TEST_INSTRUCTION("E2036138", ldaddlb(w1, w2, ptr(sp))); + TEST_INSTRUCTION("62006178", ldaddlh(w1, w2, ptr(x3))); + TEST_INSTRUCTION("E2036178", ldaddlh(w1, w2, ptr(sp))); + TEST_INSTRUCTION("621021B8", ldclr(w1, w2, ptr(x3))); + TEST_INSTRUCTION("E21321B8", ldclr(w1, w2, ptr(sp))); + TEST_INSTRUCTION("621021F8", ldclr(x1, x2, ptr(x3))); + TEST_INSTRUCTION("E21321F8", ldclr(x1, x2, ptr(sp))); + TEST_INSTRUCTION("6210A1B8", ldclra(w1, w2, ptr(x3))); + TEST_INSTRUCTION("E213A1B8", ldclra(w1, w2, ptr(sp))); + TEST_INSTRUCTION("6210A1F8", ldclra(x1, x2, ptr(x3))); + TEST_INSTRUCTION("E213A1F8", ldclra(x1, x2, ptr(sp))); + TEST_INSTRUCTION("6210A138", ldclrab(w1, w2, ptr(x3))); + TEST_INSTRUCTION("E213A138", ldclrab(w1, w2, ptr(sp))); + TEST_INSTRUCTION("6210A178", ldclrah(w1, w2, ptr(x3))); + TEST_INSTRUCTION("E213A178", ldclrah(w1, w2, ptr(sp))); + TEST_INSTRUCTION("6210E1B8", ldclral(w1, w2, ptr(x3))); + TEST_INSTRUCTION("E213E1B8", ldclral(w1, w2, ptr(sp))); + TEST_INSTRUCTION("6210E1F8", ldclral(x1, x2, ptr(x3))); + TEST_INSTRUCTION("E213E1F8", ldclral(x1, x2, ptr(sp))); + TEST_INSTRUCTION("6210E138", ldclralb(w1, w2, ptr(x3))); + TEST_INSTRUCTION("E213E138", ldclralb(w1, w2, ptr(sp))); + TEST_INSTRUCTION("6210E178", ldclralh(w1, w2, ptr(x3))); + TEST_INSTRUCTION("E213E178", ldclralh(w1, w2, ptr(sp))); + TEST_INSTRUCTION("62102138", ldclrb(w1, w2, ptr(x3))); + TEST_INSTRUCTION("E2132138", ldclrb(w1, w2, ptr(sp))); + TEST_INSTRUCTION("62102178", ldclrh(w1, w2, ptr(x3))); + TEST_INSTRUCTION("E2132178", ldclrh(w1, w2, ptr(sp))); + TEST_INSTRUCTION("621061B8", ldclrl(w1, w2, ptr(x3))); + TEST_INSTRUCTION("E21361B8", ldclrl(w1, w2, ptr(sp))); + TEST_INSTRUCTION("621061F8", ldclrl(x1, x2, ptr(x3))); + TEST_INSTRUCTION("E21361F8", ldclrl(x1, x2, ptr(sp))); + TEST_INSTRUCTION("62106138", ldclrlb(w1, w2, ptr(x3))); + TEST_INSTRUCTION("E2136138", ldclrlb(w1, w2, ptr(sp))); + TEST_INSTRUCTION("62106178", ldclrlh(w1, w2, ptr(x3))); + TEST_INSTRUCTION("E2136178", ldclrlh(w1, w2, ptr(sp))); + TEST_INSTRUCTION("622021B8", ldeor(w1, w2, ptr(x3))); + TEST_INSTRUCTION("E22321B8", ldeor(w1, w2, ptr(sp))); + TEST_INSTRUCTION("622021F8", ldeor(x1, x2, ptr(x3))); + TEST_INSTRUCTION("E22321F8", ldeor(x1, x2, ptr(sp))); + TEST_INSTRUCTION("6220A1B8", ldeora(w1, w2, ptr(x3))); + TEST_INSTRUCTION("E223A1B8", ldeora(w1, w2, ptr(sp))); + TEST_INSTRUCTION("6220A1F8", ldeora(x1, x2, ptr(x3))); + TEST_INSTRUCTION("E223A1F8", ldeora(x1, x2, ptr(sp))); + TEST_INSTRUCTION("6220A138", ldeorab(w1, w2, ptr(x3))); + TEST_INSTRUCTION("E223A138", ldeorab(w1, w2, ptr(sp))); + TEST_INSTRUCTION("6220A178", ldeorah(w1, w2, ptr(x3))); + TEST_INSTRUCTION("E223A178", ldeorah(w1, w2, ptr(sp))); + TEST_INSTRUCTION("6220E1B8", ldeoral(w1, w2, ptr(x3))); + TEST_INSTRUCTION("E223E1B8", ldeoral(w1, w2, ptr(sp))); + TEST_INSTRUCTION("6220E1F8", ldeoral(x1, x2, ptr(x3))); + TEST_INSTRUCTION("E223E1F8", ldeoral(x1, x2, ptr(sp))); + TEST_INSTRUCTION("6220E138", ldeoralb(w1, w2, ptr(x3))); + TEST_INSTRUCTION("E223E138", ldeoralb(w1, w2, ptr(sp))); + TEST_INSTRUCTION("6220E178", ldeoralh(w1, w2, ptr(x3))); + TEST_INSTRUCTION("E223E178", ldeoralh(w1, w2, ptr(sp))); + TEST_INSTRUCTION("62202138", ldeorb(w1, w2, ptr(x3))); + TEST_INSTRUCTION("E2232138", ldeorb(w1, w2, ptr(sp))); + TEST_INSTRUCTION("62202178", ldeorh(w1, w2, ptr(x3))); + TEST_INSTRUCTION("E2232178", ldeorh(w1, w2, ptr(sp))); + TEST_INSTRUCTION("622061B8", ldeorl(w1, w2, ptr(x3))); + TEST_INSTRUCTION("E22361B8", ldeorl(w1, w2, ptr(sp))); + TEST_INSTRUCTION("622061F8", ldeorl(x1, x2, ptr(x3))); + TEST_INSTRUCTION("E22361F8", ldeorl(x1, x2, ptr(sp))); + TEST_INSTRUCTION("62206138", ldeorlb(w1, w2, ptr(x3))); + TEST_INSTRUCTION("E2236138", ldeorlb(w1, w2, ptr(sp))); + TEST_INSTRUCTION("62206178", ldeorlh(w1, w2, ptr(x3))); + TEST_INSTRUCTION("E2236178", ldeorlh(w1, w2, ptr(sp))); + TEST_INSTRUCTION("410060D9", ldg(x1, ptr(x2))); + TEST_INSTRUCTION("418060D9", ldg(x1, ptr(x2, 128))); + TEST_INSTRUCTION("E10360D9", ldg(x1, ptr(sp))); + TEST_INSTRUCTION("E18360D9", ldg(x1, ptr(sp, 128))); + TEST_INSTRUCTION("4100E0D9", ldgm(x1, ptr(x2))); + TEST_INSTRUCTION("E103E0D9", ldgm(x1, ptr(sp))); + TEST_INSTRUCTION("417CDF88", ldlar(w1, ptr(x2))); + TEST_INSTRUCTION("E17FDF88", ldlar(w1, ptr(sp))); + TEST_INSTRUCTION("417CDFC8", ldlar(x1, ptr(x2))); + TEST_INSTRUCTION("E17FDFC8", ldlar(x1, ptr(sp))); + TEST_INSTRUCTION("417CDF08", ldlarb(w1, ptr(x2))); + TEST_INSTRUCTION("E17FDF08", ldlarb(w1, ptr(sp))); + TEST_INSTRUCTION("417CDF48", ldlarh(w1, ptr(x2))); + TEST_INSTRUCTION("E17FDF48", ldlarh(w1, ptr(sp))); + TEST_INSTRUCTION("41084028", ldnp(w1, w2, ptr(x2))); + TEST_INSTRUCTION("41086028", ldnp(w1, w2, ptr(x2, -256))); + TEST_INSTRUCTION("41885F28", ldnp(w1, w2, ptr(x2, 252))); + TEST_INSTRUCTION("410840A8", ldnp(x1, x2, ptr(x2))); + TEST_INSTRUCTION("410860A8", ldnp(x1, x2, ptr(x2, -512))); + TEST_INSTRUCTION("41885FA8", ldnp(x1, x2, ptr(x2, 504))); + TEST_INSTRUCTION("41084029", ldp(w1, w2, ptr(x2))); + TEST_INSTRUCTION("41086029", ldp(w1, w2, ptr(x2, -256))); + TEST_INSTRUCTION("41885F29", ldp(w1, w2, ptr(x2, 252))); + TEST_INSTRUCTION("410840A9", ldp(x1, x2, ptr(x2))); + TEST_INSTRUCTION("410860A9", ldp(x1, x2, ptr(x2, -512))); + TEST_INSTRUCTION("41885FA9", ldp(x1, x2, ptr(x2, 504))); + TEST_INSTRUCTION("41084069", ldpsw(x1, x2, ptr(x2))); + TEST_INSTRUCTION("41086069", ldpsw(x1, x2, ptr(x2, -256))); + TEST_INSTRUCTION("41885F69", ldpsw(x1, x2, ptr(x2, 252))); + TEST_INSTRUCTION("410040B9", ldr(w1, ptr(x2))); + TEST_INSTRUCTION("413040B9", ldr(w1, ptr(x2, 48))); + TEST_INSTRUCTION("410C43B8", ldr(w1, ptr_pre(x2, 48))); + TEST_INSTRUCTION("416863B8", ldr(w1, ptr(x2, x3))); + TEST_INSTRUCTION("410040F9", ldr(x1, ptr(x2))); + TEST_INSTRUCTION("411840F9", ldr(x1, ptr(x2, 48))); + TEST_INSTRUCTION("410C43F8", ldr(x1, ptr_pre(x2, 48))); + TEST_INSTRUCTION("416863F8", ldr(x1, ptr(x2, x3))); + TEST_INSTRUCTION("FB0F5FF8", ldr(x27, ptr_pre(sp, -16))); + TEST_INSTRUCTION("FB0741F8", ldr(x27, ptr_post(sp, 16))); + TEST_INSTRUCTION("411040B8", ldr(w1, ptr(x2, 1))); // LDUR + TEST_INSTRUCTION("41D05FB8", ldr(w1, ptr(x2, -3))); // LDUR + TEST_INSTRUCTION("41705FB8", ldr(w1, ptr(x2, -9))); // LDUR + TEST_INSTRUCTION("411040F8", ldr(x1, ptr(x2, 1))); // LDUR + TEST_INSTRUCTION("413040F8", ldr(x1, ptr(x2, 3))); // LDUR + TEST_INSTRUCTION("41705FF8", ldr(x1, ptr(x2, -9))); // LDUR + TEST_INSTRUCTION("41004039", ldrb(w1, ptr(x2))); + TEST_INSTRUCTION("41C04039", ldrb(w1, ptr(x2, 48))); + TEST_INSTRUCTION("410C4338", ldrb(w1, ptr_pre(x2, 48))); + TEST_INSTRUCTION("41686338", ldrb(w1, ptr(x2, x3))); + TEST_INSTRUCTION("41044039", ldrb(w1, ptr(x2, 1))); + TEST_INSTRUCTION("41D05F38", ldrb(w1, ptr(x2, -3))); // LDURB + TEST_INSTRUCTION("41705F38", ldrb(w1, ptr(x2, -9))); // LDURB + TEST_INSTRUCTION("41004079", ldrh(w1, ptr(x2))); + TEST_INSTRUCTION("41604079", ldrh(w1, ptr(x2, 48))); + TEST_INSTRUCTION("410C4378", ldrh(w1, ptr_pre(x2, 48))); + TEST_INSTRUCTION("41686378", ldrh(w1, ptr(x2, x3))); + TEST_INSTRUCTION("41104078", ldrh(w1, ptr(x2, 1))); // LDURH + TEST_INSTRUCTION("41D05F78", ldrh(w1, ptr(x2, -3))); // LDURH + TEST_INSTRUCTION("41705F78", ldrh(w1, ptr(x2, -9))); // LDURH + TEST_INSTRUCTION("4104C039", ldrsb(w1, ptr(x2, 1))); + TEST_INSTRUCTION("41D0DF38", ldrsb(w1, ptr(x2, -3))); // LDURSB + TEST_INSTRUCTION("4170DF38", ldrsb(w1, ptr(x2, -9))); // LDURSB + TEST_INSTRUCTION("41048039", ldrsb(x1, ptr(x2, 1))); + TEST_INSTRUCTION("41D09F38", ldrsb(x1, ptr(x2, -3))); // LDURSB + TEST_INSTRUCTION("41709F38", ldrsb(x1, ptr(x2, -9))); // LDURSB + TEST_INSTRUCTION("4110C078", ldrsh(w1, ptr(x2, 1))); // LDURSH + TEST_INSTRUCTION("41D0DF78", ldrsh(w1, ptr(x2, -3))); // LDURSH + TEST_INSTRUCTION("4170DF78", ldrsh(w1, ptr(x2, -9))); // LDURSH + TEST_INSTRUCTION("41108078", ldrsh(x1, ptr(x2, 1))); // LDURSH + TEST_INSTRUCTION("41D09F78", ldrsh(x1, ptr(x2, -3))); // LDURSH + TEST_INSTRUCTION("41709F78", ldrsh(x1, ptr(x2, -9))); // LDURSH + TEST_INSTRUCTION("410080B9", ldrsw(x1, ptr(x2))); + TEST_INSTRUCTION("413080B9", ldrsw(x1, ptr(x2, 48))); + TEST_INSTRUCTION("410C83B8", ldrsw(x1, ptr_pre(x2, 48))); + TEST_INSTRUCTION("410483B8", ldrsw(x1, ptr_post(x2, 48))); + TEST_INSTRUCTION("4168A3B8", ldrsw(x1, ptr(x2, x3))); + TEST_INSTRUCTION("411080B8", ldrsw(x1, ptr(x2, 1))); // LDURSW + TEST_INSTRUCTION("413080B8", ldrsw(x1, ptr(x2, 3))); // LDURSW + TEST_INSTRUCTION("41709FB8", ldrsw(x1, ptr(x2, -9))); // LDURSW + TEST_INSTRUCTION("410420F8", ldraa(x1, ptr(x2))); + TEST_INSTRUCTION("410460F8", ldraa(x1, ptr(x2, -4096))); + TEST_INSTRUCTION("410C60F8", ldraa(x1, ptr_pre(x2, -4096))); + TEST_INSTRUCTION("41FC3FF8", ldraa(x1, ptr_pre(x2, 4088))); + TEST_INSTRUCTION("E10720F8", ldraa(x1, ptr(sp))); + TEST_INSTRUCTION("E10760F8", ldraa(x1, ptr(sp, -4096))); + TEST_INSTRUCTION("E10F60F8", ldraa(x1, ptr_pre(sp, -4096))); + TEST_INSTRUCTION("E1FF3FF8", ldraa(x1, ptr_pre(sp, 4088))); + TEST_INSTRUCTION("4104A0F8", ldrab(x1, ptr(x2))); + TEST_INSTRUCTION("4104E0F8", ldrab(x1, ptr(x2, -4096))); + TEST_INSTRUCTION("410CE0F8", ldrab(x1, ptr_pre(x2, -4096))); + TEST_INSTRUCTION("41FCBFF8", ldrab(x1, ptr_pre(x2, 4088))); + TEST_INSTRUCTION("E107A0F8", ldrab(x1, ptr(sp))); + TEST_INSTRUCTION("E107E0F8", ldrab(x1, ptr(sp, -4096))); + TEST_INSTRUCTION("E10FE0F8", ldrab(x1, ptr_pre(sp, -4096))); + TEST_INSTRUCTION("E1FFBFF8", ldrab(x1, ptr_pre(sp, 4088))); + TEST_INSTRUCTION("60DBA0B8", ldrsw(x0, ptr(x27, w0, sxtw(2)))); + TEST_INSTRUCTION("623021B8", ldset(w1, w2, ptr(x3))); + TEST_INSTRUCTION("E23321B8", ldset(w1, w2, ptr(sp))); + TEST_INSTRUCTION("623021F8", ldset(x1, x2, ptr(x3))); + TEST_INSTRUCTION("E23321F8", ldset(x1, x2, ptr(sp))); + TEST_INSTRUCTION("6230A1B8", ldseta(w1, w2, ptr(x3))); + TEST_INSTRUCTION("E233A1B8", ldseta(w1, w2, ptr(sp))); + TEST_INSTRUCTION("6230A1F8", ldseta(x1, x2, ptr(x3))); + TEST_INSTRUCTION("E233A1F8", ldseta(x1, x2, ptr(sp))); + TEST_INSTRUCTION("6230A138", ldsetab(w1, w2, ptr(x3))); + TEST_INSTRUCTION("E233A138", ldsetab(w1, w2, ptr(sp))); + TEST_INSTRUCTION("6230A178", ldsetah(w1, w2, ptr(x3))); + TEST_INSTRUCTION("E233A178", ldsetah(w1, w2, ptr(sp))); + TEST_INSTRUCTION("6230E1B8", ldsetal(w1, w2, ptr(x3))); + TEST_INSTRUCTION("E233E1B8", ldsetal(w1, w2, ptr(sp))); + TEST_INSTRUCTION("6230E1F8", ldsetal(x1, x2, ptr(x3))); + TEST_INSTRUCTION("E233E1F8", ldsetal(x1, x2, ptr(sp))); + TEST_INSTRUCTION("6230E178", ldsetalh(w1, w2, ptr(x3))); + TEST_INSTRUCTION("E233E178", ldsetalh(w1, w2, ptr(sp))); + TEST_INSTRUCTION("6230E138", ldsetalb(w1, w2, ptr(x3))); + TEST_INSTRUCTION("E233E138", ldsetalb(w1, w2, ptr(sp))); + TEST_INSTRUCTION("62302138", ldsetb(w1, w2, ptr(x3))); + TEST_INSTRUCTION("E2332138", ldsetb(w1, w2, ptr(sp))); + TEST_INSTRUCTION("62302178", ldseth(w1, w2, ptr(x3))); + TEST_INSTRUCTION("E2332178", ldseth(w1, w2, ptr(sp))); + TEST_INSTRUCTION("623061B8", ldsetl(w1, w2, ptr(x3))); + TEST_INSTRUCTION("E23361B8", ldsetl(w1, w2, ptr(sp))); + TEST_INSTRUCTION("623061F8", ldsetl(x1, x2, ptr(x3))); + TEST_INSTRUCTION("E23361F8", ldsetl(x1, x2, ptr(sp))); + TEST_INSTRUCTION("62306138", ldsetlb(w1, w2, ptr(x3))); + TEST_INSTRUCTION("E2336138", ldsetlb(w1, w2, ptr(sp))); + TEST_INSTRUCTION("62306178", ldsetlh(w1, w2, ptr(x3))); + TEST_INSTRUCTION("E2336178", ldsetlh(w1, w2, ptr(sp))); + TEST_INSTRUCTION("624021B8", ldsmax(w1, w2, ptr(x3))); + TEST_INSTRUCTION("E24321B8", ldsmax(w1, w2, ptr(sp))); + TEST_INSTRUCTION("624021F8", ldsmax(x1, x2, ptr(x3))); + TEST_INSTRUCTION("E24321F8", ldsmax(x1, x2, ptr(sp))); + TEST_INSTRUCTION("6240A1B8", ldsmaxa(w1, w2, ptr(x3))); + TEST_INSTRUCTION("E243A1B8", ldsmaxa(w1, w2, ptr(sp))); + TEST_INSTRUCTION("6240A1F8", ldsmaxa(x1, x2, ptr(x3))); + TEST_INSTRUCTION("E243A1F8", ldsmaxa(x1, x2, ptr(sp))); + TEST_INSTRUCTION("6240A138", ldsmaxab(w1, w2, ptr(x3))); + TEST_INSTRUCTION("E243A138", ldsmaxab(w1, w2, ptr(sp))); + TEST_INSTRUCTION("6240A178", ldsmaxah(w1, w2, ptr(x3))); + TEST_INSTRUCTION("E243A178", ldsmaxah(w1, w2, ptr(sp))); + TEST_INSTRUCTION("6240E1B8", ldsmaxal(w1, w2, ptr(x3))); + TEST_INSTRUCTION("E243E1B8", ldsmaxal(w1, w2, ptr(sp))); + TEST_INSTRUCTION("6240E1F8", ldsmaxal(x1, x2, ptr(x3))); + TEST_INSTRUCTION("E243E1F8", ldsmaxal(x1, x2, ptr(sp))); + TEST_INSTRUCTION("6240E138", ldsmaxalb(w1, w2, ptr(x3))); + TEST_INSTRUCTION("E243E138", ldsmaxalb(w1, w2, ptr(sp))); + TEST_INSTRUCTION("6240E178", ldsmaxalh(w1, w2, ptr(x3))); + TEST_INSTRUCTION("E243E178", ldsmaxalh(w1, w2, ptr(sp))); + TEST_INSTRUCTION("62402138", ldsmaxb(w1, w2, ptr(x3))); + TEST_INSTRUCTION("E2432138", ldsmaxb(w1, w2, ptr(sp))); + TEST_INSTRUCTION("62402178", ldsmaxh(w1, w2, ptr(x3))); + TEST_INSTRUCTION("E2432178", ldsmaxh(w1, w2, ptr(sp))); + TEST_INSTRUCTION("624061B8", ldsmaxl(w1, w2, ptr(x3))); + TEST_INSTRUCTION("E24361B8", ldsmaxl(w1, w2, ptr(sp))); + TEST_INSTRUCTION("624061F8", ldsmaxl(x1, x2, ptr(x3))); + TEST_INSTRUCTION("E24361F8", ldsmaxl(x1, x2, ptr(sp))); + TEST_INSTRUCTION("62406138", ldsmaxlb(w1, w2, ptr(x3))); + TEST_INSTRUCTION("E2436138", ldsmaxlb(w1, w2, ptr(sp))); + TEST_INSTRUCTION("62406178", ldsmaxlh(w1, w2, ptr(x3))); + TEST_INSTRUCTION("E2436178", ldsmaxlh(w1, w2, ptr(sp))); + TEST_INSTRUCTION("625021B8", ldsmin(w1, w2, ptr(x3))); + TEST_INSTRUCTION("E25321B8", ldsmin(w1, w2, ptr(sp))); + TEST_INSTRUCTION("625021F8", ldsmin(x1, x2, ptr(x3))); + TEST_INSTRUCTION("E25321F8", ldsmin(x1, x2, ptr(sp))); + TEST_INSTRUCTION("6250A1B8", ldsmina(w1, w2, ptr(x3))); + TEST_INSTRUCTION("E253A1B8", ldsmina(w1, w2, ptr(sp))); + TEST_INSTRUCTION("6250A1F8", ldsmina(x1, x2, ptr(x3))); + TEST_INSTRUCTION("E253A1F8", ldsmina(x1, x2, ptr(sp))); + TEST_INSTRUCTION("6250A138", ldsminab(w1, w2, ptr(x3))); + TEST_INSTRUCTION("E253A138", ldsminab(w1, w2, ptr(sp))); + TEST_INSTRUCTION("6250A178", ldsminah(w1, w2, ptr(x3))); + TEST_INSTRUCTION("E253A178", ldsminah(w1, w2, ptr(sp))); + TEST_INSTRUCTION("6250E1B8", ldsminal(w1, w2, ptr(x3))); + TEST_INSTRUCTION("E253E1B8", ldsminal(w1, w2, ptr(sp))); + TEST_INSTRUCTION("6250E1F8", ldsminal(x1, x2, ptr(x3))); + TEST_INSTRUCTION("E253E1F8", ldsminal(x1, x2, ptr(sp))); + TEST_INSTRUCTION("6250E138", ldsminalb(w1, w2, ptr(x3))); + TEST_INSTRUCTION("E253E138", ldsminalb(w1, w2, ptr(sp))); + TEST_INSTRUCTION("6250E178", ldsminalh(w1, w2, ptr(x3))); + TEST_INSTRUCTION("E253E178", ldsminalh(w1, w2, ptr(sp))); + TEST_INSTRUCTION("62502138", ldsminb(w1, w2, ptr(x3))); + TEST_INSTRUCTION("E2532138", ldsminb(w1, w2, ptr(sp))); + TEST_INSTRUCTION("62502178", ldsminh(w1, w2, ptr(x3))); + TEST_INSTRUCTION("E2532178", ldsminh(w1, w2, ptr(sp))); + TEST_INSTRUCTION("625061B8", ldsminl(w1, w2, ptr(x3))); + TEST_INSTRUCTION("E25361B8", ldsminl(w1, w2, ptr(sp))); + TEST_INSTRUCTION("625061F8", ldsminl(x1, x2, ptr(x3))); + TEST_INSTRUCTION("E25361F8", ldsminl(x1, x2, ptr(sp))); + TEST_INSTRUCTION("62506138", ldsminlb(w1, w2, ptr(x3))); + TEST_INSTRUCTION("E2536138", ldsminlb(w1, w2, ptr(sp))); + TEST_INSTRUCTION("62506178", ldsminlh(w1, w2, ptr(x3))); + TEST_INSTRUCTION("E2536178", ldsminlh(w1, w2, ptr(sp))); + TEST_INSTRUCTION("410840B8", ldtr(w1, ptr(x2))); + TEST_INSTRUCTION("411848B8", ldtr(w1, ptr(x2, 129))); + TEST_INSTRUCTION("E10B40B8", ldtr(w1, ptr(sp))); + TEST_INSTRUCTION("E11B48B8", ldtr(w1, ptr(sp, 129))); + TEST_INSTRUCTION("410840F8", ldtr(x1, ptr(x2))); + TEST_INSTRUCTION("411848F8", ldtr(x1, ptr(x2, 129))); + TEST_INSTRUCTION("E10B40F8", ldtr(x1, ptr(sp))); + TEST_INSTRUCTION("E11B48F8", ldtr(x1, ptr(sp, 129))); + TEST_INSTRUCTION("41084038", ldtrb(w1, ptr(x2))); + TEST_INSTRUCTION("41184838", ldtrb(w1, ptr(x2, 129))); + TEST_INSTRUCTION("E10B4038", ldtrb(w1, ptr(sp))); + TEST_INSTRUCTION("E11B4838", ldtrb(w1, ptr(sp, 129))); + TEST_INSTRUCTION("41084078", ldtrh(w1, ptr(x2))); + TEST_INSTRUCTION("41184878", ldtrh(w1, ptr(x2, 129))); + TEST_INSTRUCTION("E10B4078", ldtrh(w1, ptr(sp))); + TEST_INSTRUCTION("E11B4878", ldtrh(w1, ptr(sp, 129))); + TEST_INSTRUCTION("4108C038", ldtrsb(w1, ptr(x2))); + TEST_INSTRUCTION("4118C838", ldtrsb(w1, ptr(x2, 129))); + TEST_INSTRUCTION("E10BC038", ldtrsb(w1, ptr(sp))); + TEST_INSTRUCTION("E11BC838", ldtrsb(w1, ptr(sp, 129))); + TEST_INSTRUCTION("4108C078", ldtrsh(w1, ptr(x2))); + TEST_INSTRUCTION("4118C878", ldtrsh(w1, ptr(x2, 129))); + TEST_INSTRUCTION("E10BC078", ldtrsh(w1, ptr(sp))); + TEST_INSTRUCTION("E11BC878", ldtrsh(w1, ptr(sp, 129))); + TEST_INSTRUCTION("410880B8", ldtrsw(x1, ptr(x2))); + TEST_INSTRUCTION("411888B8", ldtrsw(x1, ptr(x2, 129))); + TEST_INSTRUCTION("E10B80B8", ldtrsw(x1, ptr(sp))); + TEST_INSTRUCTION("E11B88B8", ldtrsw(x1, ptr(sp, 129))); + TEST_INSTRUCTION("626021B8", ldumax(w1, w2, ptr(x3))); + TEST_INSTRUCTION("E26321B8", ldumax(w1, w2, ptr(sp))); + TEST_INSTRUCTION("626021F8", ldumax(x1, x2, ptr(x3))); + TEST_INSTRUCTION("E26321F8", ldumax(x1, x2, ptr(sp))); + TEST_INSTRUCTION("6260A1B8", ldumaxa(w1, w2, ptr(x3))); + TEST_INSTRUCTION("E263A1B8", ldumaxa(w1, w2, ptr(sp))); + TEST_INSTRUCTION("6260A1F8", ldumaxa(x1, x2, ptr(x3))); + TEST_INSTRUCTION("E263A1F8", ldumaxa(x1, x2, ptr(sp))); + TEST_INSTRUCTION("6260A138", ldumaxab(w1, w2, ptr(x3))); + TEST_INSTRUCTION("E263A138", ldumaxab(w1, w2, ptr(sp))); + TEST_INSTRUCTION("6260A178", ldumaxah(w1, w2, ptr(x3))); + TEST_INSTRUCTION("E263A178", ldumaxah(w1, w2, ptr(sp))); + TEST_INSTRUCTION("6260E1B8", ldumaxal(w1, w2, ptr(x3))); + TEST_INSTRUCTION("E263E1B8", ldumaxal(w1, w2, ptr(sp))); + TEST_INSTRUCTION("6260E1F8", ldumaxal(x1, x2, ptr(x3))); + TEST_INSTRUCTION("E263E1F8", ldumaxal(x1, x2, ptr(sp))); + TEST_INSTRUCTION("6260E138", ldumaxalb(w1, w2, ptr(x3))); + TEST_INSTRUCTION("E263E138", ldumaxalb(w1, w2, ptr(sp))); + TEST_INSTRUCTION("6260E178", ldumaxalh(w1, w2, ptr(x3))); + TEST_INSTRUCTION("E263E178", ldumaxalh(w1, w2, ptr(sp))); + TEST_INSTRUCTION("62602138", ldumaxb(w1, w2, ptr(x3))); + TEST_INSTRUCTION("E2632138", ldumaxb(w1, w2, ptr(sp))); + TEST_INSTRUCTION("62602178", ldumaxh(w1, w2, ptr(x3))); + TEST_INSTRUCTION("E2632178", ldumaxh(w1, w2, ptr(sp))); + TEST_INSTRUCTION("626061B8", ldumaxl(w1, w2, ptr(x3))); + TEST_INSTRUCTION("E26361B8", ldumaxl(w1, w2, ptr(sp))); + TEST_INSTRUCTION("626061F8", ldumaxl(x1, x2, ptr(x3))); + TEST_INSTRUCTION("E26361F8", ldumaxl(x1, x2, ptr(sp))); + TEST_INSTRUCTION("62606138", ldumaxlb(w1, w2, ptr(x3))); + TEST_INSTRUCTION("E2636138", ldumaxlb(w1, w2, ptr(sp))); + TEST_INSTRUCTION("62606178", ldumaxlh(w1, w2, ptr(x3))); + TEST_INSTRUCTION("E2636178", ldumaxlh(w1, w2, ptr(sp))); + TEST_INSTRUCTION("627021B8", ldumin(w1, w2, ptr(x3))); + TEST_INSTRUCTION("E27321B8", ldumin(w1, w2, ptr(sp))); + TEST_INSTRUCTION("627021F8", ldumin(x1, x2, ptr(x3))); + TEST_INSTRUCTION("E27321F8", ldumin(x1, x2, ptr(sp))); + TEST_INSTRUCTION("6270A1B8", ldumina(w1, w2, ptr(x3))); + TEST_INSTRUCTION("E273A1B8", ldumina(w1, w2, ptr(sp))); + TEST_INSTRUCTION("6270A1F8", ldumina(x1, x2, ptr(x3))); + TEST_INSTRUCTION("E273A1F8", ldumina(x1, x2, ptr(sp))); + TEST_INSTRUCTION("6270A138", lduminab(w1, w2, ptr(x3))); + TEST_INSTRUCTION("E273A138", lduminab(w1, w2, ptr(sp))); + TEST_INSTRUCTION("6270A178", lduminah(w1, w2, ptr(x3))); + TEST_INSTRUCTION("E273A178", lduminah(w1, w2, ptr(sp))); + TEST_INSTRUCTION("6270E1B8", lduminal(w1, w2, ptr(x3))); + TEST_INSTRUCTION("E273E1B8", lduminal(w1, w2, ptr(sp))); + TEST_INSTRUCTION("6270E1F8", lduminal(x1, x2, ptr(x3))); + TEST_INSTRUCTION("E273E1F8", lduminal(x1, x2, ptr(sp))); + TEST_INSTRUCTION("6270E138", lduminalb(w1, w2, ptr(x3))); + TEST_INSTRUCTION("E273E138", lduminalb(w1, w2, ptr(sp))); + TEST_INSTRUCTION("6270E178", lduminalh(w1, w2, ptr(x3))); + TEST_INSTRUCTION("E273E178", lduminalh(w1, w2, ptr(sp))); + TEST_INSTRUCTION("62702138", lduminb(w1, w2, ptr(x3))); + TEST_INSTRUCTION("E2732138", lduminb(w1, w2, ptr(sp))); + TEST_INSTRUCTION("62702178", lduminh(w1, w2, ptr(x3))); + TEST_INSTRUCTION("E2732178", lduminh(w1, w2, ptr(sp))); + TEST_INSTRUCTION("627061B8", lduminl(w1, w2, ptr(x3))); + TEST_INSTRUCTION("E27361B8", lduminl(w1, w2, ptr(sp))); + TEST_INSTRUCTION("627061F8", lduminl(x1, x2, ptr(x3))); + TEST_INSTRUCTION("E27361F8", lduminl(x1, x2, ptr(sp))); + TEST_INSTRUCTION("62706138", lduminlb(w1, w2, ptr(x3))); + TEST_INSTRUCTION("E2736138", lduminlb(w1, w2, ptr(sp))); + TEST_INSTRUCTION("62706178", lduminlh(w1, w2, ptr(x3))); + TEST_INSTRUCTION("E2736178", lduminlh(w1, w2, ptr(sp))); + TEST_INSTRUCTION("410040B8", ldur(w1, ptr(x2))); + TEST_INSTRUCTION("411048B8", ldur(w1, ptr(x2, 129))); + TEST_INSTRUCTION("E10340B8", ldur(w1, ptr(sp))); + TEST_INSTRUCTION("E11348B8", ldur(w1, ptr(sp, 129))); + TEST_INSTRUCTION("410040F8", ldur(x1, ptr(x2))); + TEST_INSTRUCTION("411048F8", ldur(x1, ptr(x2, 129))); + TEST_INSTRUCTION("E10340F8", ldur(x1, ptr(sp))); + TEST_INSTRUCTION("E11348F8", ldur(x1, ptr(sp, 129))); + TEST_INSTRUCTION("41004038", ldurb(w1, ptr(x2))); + TEST_INSTRUCTION("41104838", ldurb(w1, ptr(x2, 129))); + TEST_INSTRUCTION("E1034038", ldurb(w1, ptr(sp))); + TEST_INSTRUCTION("E1134838", ldurb(w1, ptr(sp, 129))); + TEST_INSTRUCTION("41004078", ldurh(w1, ptr(x2))); + TEST_INSTRUCTION("41104878", ldurh(w1, ptr(x2, 129))); + TEST_INSTRUCTION("E1034078", ldurh(w1, ptr(sp))); + TEST_INSTRUCTION("E1134878", ldurh(w1, ptr(sp, 129))); + TEST_INSTRUCTION("4100C038", ldursb(w1, ptr(x2))); + TEST_INSTRUCTION("4110C838", ldursb(w1, ptr(x2, 129))); + TEST_INSTRUCTION("E103C038", ldursb(w1, ptr(sp))); + TEST_INSTRUCTION("E113C838", ldursb(w1, ptr(sp, 129))); + TEST_INSTRUCTION("4100C078", ldursh(w1, ptr(x2))); + TEST_INSTRUCTION("4110C878", ldursh(w1, ptr(x2, 129))); + TEST_INSTRUCTION("E103C078", ldursh(w1, ptr(sp))); + TEST_INSTRUCTION("E113C878", ldursh(w1, ptr(sp, 129))); + TEST_INSTRUCTION("410080B8", ldursw(x1, ptr(x2))); + TEST_INSTRUCTION("411088B8", ldursw(x1, ptr(x2, 129))); + TEST_INSTRUCTION("E10380B8", ldursw(x1, ptr(sp))); + TEST_INSTRUCTION("E11388B8", ldursw(x1, ptr(sp, 129))); + TEST_INSTRUCTION("61087F88", ldxp(w1, w2, ptr(x3))); + TEST_INSTRUCTION("E10B7F88", ldxp(w1, w2, ptr(sp))); + TEST_INSTRUCTION("61087FC8", ldxp(x1, x2, ptr(x3))); + TEST_INSTRUCTION("E10B7FC8", ldxp(x1, x2, ptr(sp))); + TEST_INSTRUCTION("417C5F88", ldxr(w1, ptr(x2))); + TEST_INSTRUCTION("E17F5F88", ldxr(w1, ptr(sp))); + TEST_INSTRUCTION("417C5FC8", ldxr(x1, ptr(x2))); + TEST_INSTRUCTION("E17F5FC8", ldxr(x1, ptr(sp))); + TEST_INSTRUCTION("417C5F08", ldxrb(w1, ptr(x2))); + TEST_INSTRUCTION("E17F5F08", ldxrb(w1, ptr(sp))); + TEST_INSTRUCTION("417C5F48", ldxrh(w1, ptr(x2))); + TEST_INSTRUCTION("E17F5F48", ldxrh(w1, ptr(sp))); + TEST_INSTRUCTION("4120C31A", lsl(w1, w2, w3)); + TEST_INSTRUCTION("4120C39A", lsl(x1, x2, x3)); + TEST_INSTRUCTION("41401153", lsl(w1, w2, 15)); + TEST_INSTRUCTION("41C071D3", lsl(x1, x2, 15)); + TEST_INSTRUCTION("4120C31A", lslv(w1, w2, w3)); + TEST_INSTRUCTION("4120C39A", lslv(x1, x2, x3)); + TEST_INSTRUCTION("4124C31A", lsr(w1, w2, w3)); + TEST_INSTRUCTION("4124C39A", lsr(x1, x2, x3)); + TEST_INSTRUCTION("417C0F53", lsr(w1, w2, 15)); + TEST_INSTRUCTION("41FC4FD3", lsr(x1, x2, 15)); + TEST_INSTRUCTION("4124C31A", lsrv(w1, w2, w3)); + TEST_INSTRUCTION("4124C39A", lsrv(x1, x2, x3)); + TEST_INSTRUCTION("4110031B", madd(w1, w2, w3, w4)); + TEST_INSTRUCTION("4110039B", madd(x1, x2, x3, x4)); + TEST_INSTRUCTION("41FC031B", mneg(w1, w2, w3)); + TEST_INSTRUCTION("41FC039B", mneg(x1, x2, x3)); + TEST_INSTRUCTION("E103022A", mov(w1, w2)); + TEST_INSTRUCTION("E10302AA", mov(x1, x2)); + TEST_INSTRUCTION("01008052", mov(w1, 0)); + TEST_INSTRUCTION("01008012", mov(w1, -1)); + TEST_INSTRUCTION("21008052", mov(w1, 1)); + TEST_INSTRUCTION("41008052", mov(w1, 2)); + TEST_INSTRUCTION("61008052", mov(w1, 3)); + TEST_INSTRUCTION("81008052", mov(w1, 4)); + TEST_INSTRUCTION("A1008052", mov(w1, 5)); + TEST_INSTRUCTION("C1008052", mov(w1, 6)); + TEST_INSTRUCTION("E1008052", mov(w1, 7)); + TEST_INSTRUCTION("01018052", mov(w1, 8)); + TEST_INSTRUCTION("21018052", mov(w1, 9)); + TEST_INSTRUCTION("41018052", mov(w1, 10)); + TEST_INSTRUCTION("8146A252", mov(w1, 0x12340000)); + TEST_INSTRUCTION("81468252", mov(w1, 0x00001234)); + TEST_INSTRUCTION("61B9BD12", mov(w1, 0x1234FFFF)); + TEST_INSTRUCTION("61B99D12", mov(w1, 0xFFFF1234)); + TEST_INSTRUCTION("010080D2", mov(x1, 0)); + TEST_INSTRUCTION("01008092", mov(x1, -1)); + TEST_INSTRUCTION("8146E2D2", mov(x1, 0x1234000000000000)); + TEST_INSTRUCTION("8146C2D2", mov(x1, 0x0000123400000000)); + TEST_INSTRUCTION("8146A2D2", mov(x1, 0x0000000012340000)); + TEST_INSTRUCTION("814682D2", mov(x1, 0x0000000000001234)); + TEST_INSTRUCTION("61B9FD92", mov(x1, 0x1234FFFFFFFFFFFF)); + TEST_INSTRUCTION("61B9DD92", mov(x1, 0xFFFF1234FFFFFFFF)); + TEST_INSTRUCTION("61B9BD92", mov(x1, 0xFFFFFFFF1234FFFF)); + TEST_INSTRUCTION("61B99D92", mov(x1, 0xFFFFFFFFFFFF1234)); + TEST_INSTRUCTION("E1030011", mov(w1, wsp)); + TEST_INSTRUCTION("E1030091", mov(x1, sp)); + TEST_INSTRUCTION("3F000011", mov(wsp, w1)); + TEST_INSTRUCTION("FF3F0032", mov(wsp, 0xFFFF)); + TEST_INSTRUCTION("3F000091", mov(sp, x1)); + TEST_INSTRUCTION("FF3F40B2", mov(sp, 0xFFFF)); + TEST_INSTRUCTION("FF030011", mov(wsp, wsp)); + TEST_INSTRUCTION("FF030091", mov(sp, sp)); + TEST_INSTRUCTION("015138D5", mrs(x1, Predicate::SysReg::kAFSR0_EL1)); + TEST_INSTRUCTION("01423BD5", mrs(x1, Predicate::SysReg::kNZCV)); + TEST_INSTRUCTION("015118D5", msr(Predicate::SysReg::kAFSR0_EL1, x1)); + TEST_INSTRUCTION("01421BD5", msr(Predicate::SysReg::kNZCV, x1)); + TEST_INSTRUCTION("4190031B", msub(w1, w2, w3, w4)); + TEST_INSTRUCTION("4190039B", msub(x1, x2, x3, x4)); + TEST_INSTRUCTION("417C031B", mul(w1, w2, w3)); + TEST_INSTRUCTION("417C039B", mul(x1, x2, x3)); + TEST_INSTRUCTION("E103222A", mvn(w1, w2)); + TEST_INSTRUCTION("E10322AA", mvn(x1, x2)); + TEST_INSTRUCTION("E113222A", mvn(w1, w2, lsl(4))); + TEST_INSTRUCTION("E11322AA", mvn(x1, x2, lsl(4))); + TEST_INSTRUCTION("E103024B", neg(w1, w2)); + TEST_INSTRUCTION("E10302CB", neg(x1, x2)); + TEST_INSTRUCTION("E113024B", neg(w1, w2, lsl(4))); + TEST_INSTRUCTION("E11302CB", neg(x1, x2, lsl(4))); + TEST_INSTRUCTION("E103026B", negs(w1, w2)); + TEST_INSTRUCTION("E10302EB", negs(x1, x2)); + TEST_INSTRUCTION("E113026B", negs(w1, w2, lsl(4))); + TEST_INSTRUCTION("E11302EB", negs(x1, x2, lsl(4))); + TEST_INSTRUCTION("E103025A", ngc(w1, w2)); + TEST_INSTRUCTION("E10302DA", ngc(x1, x2)); + TEST_INSTRUCTION("E103027A", ngcs(w1, w2)); + TEST_INSTRUCTION("E10302FA", ngcs(x1, x2)); + TEST_INSTRUCTION("4100232A", orn(w1, w2, w3)); + TEST_INSTRUCTION("410023AA", orn(x1, x2, x3)); + TEST_INSTRUCTION("4110232A", orn(w1, w2, w3, lsl(4))); + TEST_INSTRUCTION("411023AA", orn(x1, x2, x3, lsl(4))); + TEST_INSTRUCTION("4100032A", orr(w1, w2, w3)); + TEST_INSTRUCTION("410003AA", orr(x1, x2, x3)); + TEST_INSTRUCTION("4110032A", orr(w1, w2, w3, lsl(4))); + TEST_INSTRUCTION("411003AA", orr(x1, x2, x3, lsl(4))); + TEST_INSTRUCTION("3F1C0032", orr(wsp, w1, 0xFF)); + TEST_INSTRUCTION("3F1C40B2", orr(sp, x1, 0xFF)); + TEST_INSTRUCTION("41001232", orr(w1, w2, 0x4000)); + TEST_INSTRUCTION("410071B2", orr(x1, x2, 0x8000)); + TEST_INSTRUCTION("E8030032", orr(w8, wzr, 0x1)); + TEST_INSTRUCTION("E80340B2", orr(x8, xzr, 0x1)); + TEST_INSTRUCTION("4108C1DA", pacda(x1, x2)); + TEST_INSTRUCTION("E10BC1DA", pacda(x1, sp)); + TEST_INSTRUCTION("410CC1DA", pacdb(x1, x2)); + TEST_INSTRUCTION("E10FC1DA", pacdb(x1, sp)); + TEST_INSTRUCTION("E12BC1DA", pacdza(x1)); + TEST_INSTRUCTION("F42BC1DA", pacdza(x20)); + TEST_INSTRUCTION("E12FC1DA", pacdzb(x1)); + TEST_INSTRUCTION("F42FC1DA", pacdzb(x20)); + TEST_INSTRUCTION("4130C39A", pacga(x1, x2, x3)); + TEST_INSTRUCTION("4130DF9A", pacga(x1, x2, sp)); + TEST_INSTRUCTION("9F3403D5", pssbb()); + TEST_INSTRUCTION("4100C05A", rbit(w1, w2)); + TEST_INSTRUCTION("4100C0DA", rbit(x1, x2)); + TEST_INSTRUCTION("4108C05A", rev(w1, w2)); + TEST_INSTRUCTION("410CC0DA", rev(x1, x2)); + TEST_INSTRUCTION("4104C05A", rev16(w1, w2)); + TEST_INSTRUCTION("4104C0DA", rev16(x1, x2)); + TEST_INSTRUCTION("4108C0DA", rev32(x1, x2)); + TEST_INSTRUCTION("410CC0DA", rev64(x1, x2)); + TEST_INSTRUCTION("412CC31A", ror(w1, w2, w3)); + TEST_INSTRUCTION("412CC39A", ror(x1, x2, x3)); + TEST_INSTRUCTION("413C8213", ror(w1, w2, 15)); + TEST_INSTRUCTION("413CC293", ror(x1, x2, 15)); + TEST_INSTRUCTION("412CC31A", rorv(w1, w2, w3)); + TEST_INSTRUCTION("412CC39A", rorv(x1, x2, x3)); + TEST_INSTRUCTION("4100035A", sbc(w1, w2, w3)); + TEST_INSTRUCTION("410003DA", sbc(x1, x2, x3)); + TEST_INSTRUCTION("4100037A", sbcs(w1, w2, w3)); + TEST_INSTRUCTION("410003FA", sbcs(x1, x2, x3)); + TEST_INSTRUCTION("41241B13", sbfiz(w1, w2, 5, 10)); + TEST_INSTRUCTION("41247B93", sbfiz(x1, x2, 5, 10)); + TEST_INSTRUCTION("41280513", sbfm(w1, w2, 5, 10)); + TEST_INSTRUCTION("41284593", sbfm(x1, x2, 5, 10)); + TEST_INSTRUCTION("41380513", sbfx(w1, w2, 5, 10)); + TEST_INSTRUCTION("41384593", sbfx(x1, x2, 5, 10)); + TEST_INSTRUCTION("410CC31A", sdiv(w1, w2, w3)); + TEST_INSTRUCTION("410CC39A", sdiv(x1, x2, x3)); + TEST_INSTRUCTION("2D08003A", setf8(w1)); + TEST_INSTRUCTION("2D48003A", setf16(w1)); + TEST_INSTRUCTION("4110239B", smaddl(x1, w2, w3, x4)); + TEST_INSTRUCTION("230000D4", smc(1)); + TEST_INSTRUCTION("41FC239B", smnegl(x1, w2, w3)); + TEST_INSTRUCTION("4190239B", smsubl(x1, w2, w3, x4)); + TEST_INSTRUCTION("417C439B", smulh(x1, x2, x3)); + TEST_INSTRUCTION("417C239B", smull(x1, w2, w3)); + TEST_INSTRUCTION("9F3003D5", ssbb()); + TEST_INSTRUCTION("4108A0D9", st2g(x1, ptr(x2))); + TEST_INSTRUCTION("4188A0D9", st2g(x1, ptr(x2, 128))); + TEST_INSTRUCTION("418CA0D9", st2g(x1, ptr_pre(x2, 128))); + TEST_INSTRUCTION("4184A0D9", st2g(x1, ptr_post(x2, 128))); + TEST_INSTRUCTION("E10BA0D9", st2g(x1, ptr(sp))); + TEST_INSTRUCTION("E18BA0D9", st2g(x1, ptr(sp, 128))); + TEST_INSTRUCTION("E18FA0D9", st2g(x1, ptr_pre(sp, 128))); + TEST_INSTRUCTION("E187A0D9", st2g(x1, ptr_post(sp, 128))); + TEST_INSTRUCTION("5F08A0D9", st2g(sp, ptr(x2))); + TEST_INSTRUCTION("5F88A0D9", st2g(sp, ptr(x2, 128))); + TEST_INSTRUCTION("5F8CA0D9", st2g(sp, ptr_pre(x2, 128))); + TEST_INSTRUCTION("5F84A0D9", st2g(sp, ptr_post(x2, 128))); + TEST_INSTRUCTION("FF0BA0D9", st2g(sp, ptr(sp))); + TEST_INSTRUCTION("FF8BA0D9", st2g(sp, ptr(sp, 128))); + TEST_INSTRUCTION("FF8FA0D9", st2g(sp, ptr_pre(sp, 128))); + TEST_INSTRUCTION("FF87A0D9", st2g(sp, ptr_post(sp, 128))); + TEST_INSTRUCTION("410820D9", stg(x1, ptr(x2))); + TEST_INSTRUCTION("418820D9", stg(x1, ptr(x2, 128))); + TEST_INSTRUCTION("418C20D9", stg(x1, ptr_pre(x2, 128))); + TEST_INSTRUCTION("418420D9", stg(x1, ptr_post(x2, 128))); + TEST_INSTRUCTION("E10B20D9", stg(x1, ptr(sp))); + TEST_INSTRUCTION("E18B20D9", stg(x1, ptr(sp, 128))); + TEST_INSTRUCTION("E18F20D9", stg(x1, ptr_pre(sp, 128))); + TEST_INSTRUCTION("E18720D9", stg(x1, ptr_post(sp, 128))); + TEST_INSTRUCTION("5F0820D9", stg(sp, ptr(x2))); + TEST_INSTRUCTION("5F8820D9", stg(sp, ptr(x2, 128))); + TEST_INSTRUCTION("5F8C20D9", stg(sp, ptr_pre(x2, 128))); + TEST_INSTRUCTION("5F8420D9", stg(sp, ptr_post(x2, 128))); + TEST_INSTRUCTION("FF0B20D9", stg(sp, ptr(sp))); + TEST_INSTRUCTION("FF8B20D9", stg(sp, ptr(sp, 128))); + TEST_INSTRUCTION("FF8F20D9", stg(sp, ptr_pre(sp, 128))); + TEST_INSTRUCTION("FF8720D9", stg(sp, ptr_post(sp, 128))); + TEST_INSTRUCTION("4100A0D9", stgm(x1, ptr(x2))); + TEST_INSTRUCTION("E103A0D9", stgm(x1, ptr(sp))); + TEST_INSTRUCTION("FF03A0D9", stgm(xzr, ptr(sp))); + TEST_INSTRUCTION("61080069", stgp(x1, x2, ptr(x3))); + TEST_INSTRUCTION("61082069", stgp(x1, x2, ptr(x3, -1024))); + TEST_INSTRUCTION("6108A069", stgp(x1, x2, ptr_pre(x3, -1024))); + TEST_INSTRUCTION("6108A068", stgp(x1, x2, ptr_post(x3, -1024))); + TEST_INSTRUCTION("61881F69", stgp(x1, x2, ptr(x3, 1008))); + TEST_INSTRUCTION("61889F69", stgp(x1, x2, ptr_pre(x3, 1008))); + TEST_INSTRUCTION("61889F68", stgp(x1, x2, ptr_post(x3, 1008))); + TEST_INSTRUCTION("E10B0069", stgp(x1, x2, ptr(sp))); + TEST_INSTRUCTION("E10B2069", stgp(x1, x2, ptr(sp, -1024))); + TEST_INSTRUCTION("E10BA069", stgp(x1, x2, ptr_pre(sp, -1024))); + TEST_INSTRUCTION("E10BA068", stgp(x1, x2, ptr_post(sp, -1024))); + TEST_INSTRUCTION("E18B1F69", stgp(x1, x2, ptr(sp, 1008))); + TEST_INSTRUCTION("E18B9F69", stgp(x1, x2, ptr_pre(sp, 1008))); + TEST_INSTRUCTION("E18B9F68", stgp(x1, x2, ptr_post(sp, 1008))); + TEST_INSTRUCTION("41080029", stp(w1, w2, ptr(x2))); + TEST_INSTRUCTION("41082029", stp(w1, w2, ptr(x2, -256))); + TEST_INSTRUCTION("41881F29", stp(w1, w2, ptr(x2, 252))); + TEST_INSTRUCTION("410800A9", stp(x1, x2, ptr(x2))); + TEST_INSTRUCTION("410820A9", stp(x1, x2, ptr(x2, -512))); + TEST_INSTRUCTION("41881FA9", stp(x1, x2, ptr(x2, 504))); + TEST_INSTRUCTION("FB0F1FF8", str(x27, ptr_pre(sp, -16))); + TEST_INSTRUCTION("411000B8", str(w1, ptr(x2, 1))); // STUR + TEST_INSTRUCTION("41D01FB8", str(w1, ptr(x2, -3))); // STUR + TEST_INSTRUCTION("41701FB8", str(w1, ptr(x2, -9))); // STUR + TEST_INSTRUCTION("411000F8", str(x1, ptr(x2, 1))); // STUR + TEST_INSTRUCTION("413000F8", str(x1, ptr(x2, 3))); // STUR + TEST_INSTRUCTION("41701FF8", str(x1, ptr(x2, -9))); // STUR + TEST_INSTRUCTION("41040039", strb(w1, ptr(x2, 1))); + TEST_INSTRUCTION("41D01F38", strb(w1, ptr(x2, -3))); // STURB + TEST_INSTRUCTION("41701F38", strb(w1, ptr(x2, -9))); // STURB + TEST_INSTRUCTION("41100078", strh(w1, ptr(x2, 1))); // STURH + TEST_INSTRUCTION("41D01F78", strh(w1, ptr(x2, -3))); // STURH + TEST_INSTRUCTION("41701F78", strh(w1, ptr(x2, -9))); // STURH + TEST_INSTRUCTION("410800B8", sttr(w1, ptr(x2))); + TEST_INSTRUCTION("411808B8", sttr(w1, ptr(x2, 129))); + TEST_INSTRUCTION("E10B00B8", sttr(w1, ptr(sp))); + TEST_INSTRUCTION("E11B08B8", sttr(w1, ptr(sp, 129))); + TEST_INSTRUCTION("410800F8", sttr(x1, ptr(x2))); + TEST_INSTRUCTION("411808F8", sttr(x1, ptr(x2, 129))); + TEST_INSTRUCTION("E10B00F8", sttr(x1, ptr(sp))); + TEST_INSTRUCTION("E11B08F8", sttr(x1, ptr(sp, 129))); + TEST_INSTRUCTION("41080038", sttrb(w1, ptr(x2))); + TEST_INSTRUCTION("41180838", sttrb(w1, ptr(x2, 129))); + TEST_INSTRUCTION("E10B0038", sttrb(w1, ptr(sp))); + TEST_INSTRUCTION("E11B0838", sttrb(w1, ptr(sp, 129))); + TEST_INSTRUCTION("41080078", sttrh(w1, ptr(x2))); + TEST_INSTRUCTION("41180878", sttrh(w1, ptr(x2, 129))); + TEST_INSTRUCTION("E10B0078", sttrh(w1, ptr(sp))); + TEST_INSTRUCTION("E11B0878", sttrh(w1, ptr(sp, 129))); + TEST_INSTRUCTION("410000B8", stur(w1, ptr(x2))); + TEST_INSTRUCTION("411008B8", stur(w1, ptr(x2, 129))); + TEST_INSTRUCTION("E10300B8", stur(w1, ptr(sp))); + TEST_INSTRUCTION("E11308B8", stur(w1, ptr(sp, 129))); + TEST_INSTRUCTION("410000F8", stur(x1, ptr(x2))); + TEST_INSTRUCTION("411008F8", stur(x1, ptr(x2, 129))); + TEST_INSTRUCTION("E10300F8", stur(x1, ptr(sp))); + TEST_INSTRUCTION("E11308F8", stur(x1, ptr(sp, 129))); + TEST_INSTRUCTION("41000038", sturb(w1, ptr(x2))); + TEST_INSTRUCTION("41100838", sturb(w1, ptr(x2, 129))); + TEST_INSTRUCTION("E1030038", sturb(w1, ptr(sp))); + TEST_INSTRUCTION("E1130838", sturb(w1, ptr(sp, 129))); + TEST_INSTRUCTION("41000078", sturh(w1, ptr(x2))); + TEST_INSTRUCTION("41100878", sturh(w1, ptr(x2, 129))); + TEST_INSTRUCTION("E1030078", sturh(w1, ptr(sp))); + TEST_INSTRUCTION("E1130878", sturh(w1, ptr(sp, 129))); + TEST_INSTRUCTION("820C2188", stxp(w1, w2, w3, ptr(x4))); + TEST_INSTRUCTION("E20F2188", stxp(w1, w2, w3, ptr(sp))); + TEST_INSTRUCTION("820C21C8", stxp(w1, x2, x3, ptr(x4))); + TEST_INSTRUCTION("E20F21C8", stxp(w1, x2, x3, ptr(sp))); + TEST_INSTRUCTION("627C0188", stxr(w1, w2, ptr(x3))); + TEST_INSTRUCTION("E27F0188", stxr(w1, w2, ptr(sp))); + TEST_INSTRUCTION("627C01C8", stxr(w1, x2, ptr(x3))); + TEST_INSTRUCTION("E27F01C8", stxr(w1, x2, ptr(sp))); + TEST_INSTRUCTION("627C0108", stxrb(w1, w2, ptr(x3))); + TEST_INSTRUCTION("E27F0108", stxrb(w1, w2, ptr(sp))); + TEST_INSTRUCTION("627C0148", stxrh(w1, w2, ptr(x3))); + TEST_INSTRUCTION("E27F0148", stxrh(w1, w2, ptr(sp))); + TEST_INSTRUCTION("4108E0D9", stz2g(x1, ptr(x2))); + TEST_INSTRUCTION("4108F0D9", stz2g(x1, ptr(x2, -4096))); + TEST_INSTRUCTION("410CF0D9", stz2g(x1, ptr_pre(x2, -4096))); + TEST_INSTRUCTION("4104F0D9", stz2g(x1, ptr_post(x2, -4096))); + TEST_INSTRUCTION("41F8EFD9", stz2g(x1, ptr(x2, 4080))); + TEST_INSTRUCTION("41FCEFD9", stz2g(x1, ptr_pre(x2, 4080))); + TEST_INSTRUCTION("41F4EFD9", stz2g(x1, ptr_post(x2, 4080))); + TEST_INSTRUCTION("E10BE0D9", stz2g(x1, ptr(sp))); + TEST_INSTRUCTION("E10BF0D9", stz2g(x1, ptr(sp, -4096))); + TEST_INSTRUCTION("E10FF0D9", stz2g(x1, ptr_pre(sp, -4096))); + TEST_INSTRUCTION("E107F0D9", stz2g(x1, ptr_post(sp, -4096))); + TEST_INSTRUCTION("E1FBEFD9", stz2g(x1, ptr(sp, 4080))); + TEST_INSTRUCTION("E1FFEFD9", stz2g(x1, ptr_pre(sp, 4080))); + TEST_INSTRUCTION("E1F7EFD9", stz2g(x1, ptr_post(sp, 4080))); + TEST_INSTRUCTION("410860D9", stzg(x1, ptr(x2))); + TEST_INSTRUCTION("418860D9", stzg(x1, ptr(x2, 128))); + TEST_INSTRUCTION("418C60D9", stzg(x1, ptr_pre(x2, 128))); + TEST_INSTRUCTION("418460D9", stzg(x1, ptr_post(x2, 128))); + TEST_INSTRUCTION("E10B60D9", stzg(x1, ptr(sp))); + TEST_INSTRUCTION("E18B60D9", stzg(x1, ptr(sp, 128))); + TEST_INSTRUCTION("E18F60D9", stzg(x1, ptr_pre(sp, 128))); + TEST_INSTRUCTION("E18760D9", stzg(x1, ptr_post(sp, 128))); + TEST_INSTRUCTION("5F0860D9", stzg(sp, ptr(x2))); + TEST_INSTRUCTION("5F8860D9", stzg(sp, ptr(x2, 128))); + TEST_INSTRUCTION("5F8C60D9", stzg(sp, ptr_pre(x2, 128))); + TEST_INSTRUCTION("5F8460D9", stzg(sp, ptr_post(x2, 128))); + TEST_INSTRUCTION("FF0B60D9", stzg(sp, ptr(sp))); + TEST_INSTRUCTION("FF8B60D9", stzg(sp, ptr(sp, 128))); + TEST_INSTRUCTION("FF8F60D9", stzg(sp, ptr_pre(sp, 128))); + TEST_INSTRUCTION("FF8760D9", stzg(sp, ptr_post(sp, 128))); + TEST_INSTRUCTION("410020D9", stzgm(x1, ptr(x2))); + TEST_INSTRUCTION("E10320D9", stzgm(x1, ptr(sp))); + TEST_INSTRUCTION("4100034B", sub(w1, w2, w3)); + TEST_INSTRUCTION("410003CB", sub(x1, x2, x3)); + TEST_INSTRUCTION("410C034B", sub(w1, w2, w3, lsl(3))); + TEST_INSTRUCTION("410C03CB", sub(x1, x2, x3, lsl(3))); + TEST_INSTRUCTION("FF030451", sub(wsp, wsp, 256)); + TEST_INSTRUCTION("FFFF3F51", sub(wsp, wsp, 0xFFF)); + TEST_INSTRUCTION("FF0304D1", sub(sp, sp, 256)); + TEST_INSTRUCTION("FFFF3FD1", sub(sp, sp, 0xFFF)); + TEST_INSTRUCTION("412C82D1", subg(x1, x2, 32, 11)); + TEST_INSTRUCTION("5F2C82D1", subg(sp, x2, 32, 11)); + TEST_INSTRUCTION("E12F82D1", subg(x1, sp, 32, 11)); + TEST_INSTRUCTION("4100C39A", subp(x1, x2, x3)); + TEST_INSTRUCTION("E103C39A", subp(x1, sp, x3)); + TEST_INSTRUCTION("4100DF9A", subp(x1, x2, sp)); + TEST_INSTRUCTION("4100C3BA", subps(x1, x2, x3)); + TEST_INSTRUCTION("E103C3BA", subps(x1, sp, x3)); + TEST_INSTRUCTION("4100DFBA", subps(x1, x2, sp)); + TEST_INSTRUCTION("4100036B", subs(w1, w2, w3)); + TEST_INSTRUCTION("410003EB", subs(x1, x2, x3)); + TEST_INSTRUCTION("410C036B", subs(w1, w2, w3, lsl(3))); + TEST_INSTRUCTION("410C03EB", subs(x1, x2, x3, lsl(3))); + TEST_INSTRUCTION("210000D4", svc(1)); + TEST_INSTRUCTION("411C0013", sxtb(w1, w2)); + TEST_INSTRUCTION("411C4093", sxtb(x1, w2)); + TEST_INSTRUCTION("413C0013", sxth(w1, w2)); + TEST_INSTRUCTION("413C4093", sxth(x1, w2)); + TEST_INSTRUCTION("417C4093", sxtw(x1, w2)); + TEST_INSTRUCTION("932309D5", sys(1, 2, 3, 4, x19)); + TEST_INSTRUCTION("AF8708D5", tlbi(Predicate::TLBI::kVALE1, x15)); + TEST_INSTRUCTION("3F000072", tst(w1, 1)); + TEST_INSTRUCTION("3F0040F2", tst(x1, 1)); + TEST_INSTRUCTION("3F00026A", tst(w1, w2)); + TEST_INSTRUCTION("3F0002EA", tst(x1, x2)); + TEST_INSTRUCTION("3F10026A", tst(w1, w2, lsl(4))); + TEST_INSTRUCTION("3F1002EA", tst(x1, x2, lsl(4))); + TEST_INSTRUCTION("00000000", udf(0)); + TEST_INSTRUCTION("01800000", udf(0x8001)); + TEST_INSTRUCTION("4108C31A", udiv(w1, w2, w3)); + TEST_INSTRUCTION("4108C39A", udiv(x1, x2, x3)); + TEST_INSTRUCTION("41241B53", ubfiz(w1, w2, 5, 10)); + TEST_INSTRUCTION("41247BD3", ubfiz(x1, x2, 5, 10)); + TEST_INSTRUCTION("41280553", ubfm(w1, w2, 5, 10)); + TEST_INSTRUCTION("412845D3", ubfm(x1, x2, 5, 10)); + TEST_INSTRUCTION("41380553", ubfx(w1, w2, 5, 10)); + TEST_INSTRUCTION("413845D3", ubfx(x1, x2, 5, 10)); + TEST_INSTRUCTION("4110A39B", umaddl(x1, w2, w3, x4)); + TEST_INSTRUCTION("41FCA39B", umnegl(x1, w2, w3)); + TEST_INSTRUCTION("4190A39B", umsubl(x1, w2, w3, x4)); + TEST_INSTRUCTION("417CC39B", umulh(x1, x2, x3)); + TEST_INSTRUCTION("417CA39B", umull(x1, w2, w3)); + TEST_INSTRUCTION("411C0053", uxtb(w1, w2)); + TEST_INSTRUCTION("413C0053", uxth(w1, w2)); + TEST_INSTRUCTION("3F4000D5", xaflag()); + TEST_INSTRUCTION("E147C1DA", xpacd(x1)); + TEST_INSTRUCTION("E143C1DA", xpaci(x1)); + TEST_INSTRUCTION("FF2003D5", xpaclri()); +} + +static void ASMJIT_NOINLINE testA64AssemblerRel(AssemblerTester<a64::Assembler>& tester) noexcept { + using namespace a64; + + // Must be a reference, because it's recreated after every `TEST_INSTRUCTION()`. + const Label& L0 = tester.L0; + + TEST_INSTRUCTION("01000010", adr(x1, L0)); + TEST_INSTRUCTION("00000014", b(L0)); + TEST_INSTRUCTION("00000014", b_al(L0)); + TEST_INSTRUCTION("00000054", b_eq(L0)); + TEST_INSTRUCTION("01000054", b_ne(L0)); + TEST_INSTRUCTION("02000054", b_hs(L0)); + TEST_INSTRUCTION("03000054", b_lo(L0)); + TEST_INSTRUCTION("04000054", b_mi(L0)); + TEST_INSTRUCTION("05000054", b_pl(L0)); + TEST_INSTRUCTION("06000054", b_vs(L0)); + TEST_INSTRUCTION("07000054", b_vc(L0)); + TEST_INSTRUCTION("08000054", b_hi(L0)); + TEST_INSTRUCTION("09000054", b_ls(L0)); + TEST_INSTRUCTION("0A000054", b_ge(L0)); + TEST_INSTRUCTION("0B000054", b_lt(L0)); + TEST_INSTRUCTION("0C000054", b_gt(L0)); + TEST_INSTRUCTION("0D000054", b_le(L0)); + TEST_INSTRUCTION("00000014", b(CondCode::kAL, L0)); + TEST_INSTRUCTION("00000054", b(CondCode::kEQ, L0)); + TEST_INSTRUCTION("01000054", b(CondCode::kNE, L0)); + TEST_INSTRUCTION("02000054", b(CondCode::kHS, L0)); + TEST_INSTRUCTION("03000054", b(CondCode::kLO, L0)); + TEST_INSTRUCTION("04000054", b(CondCode::kMI, L0)); + TEST_INSTRUCTION("05000054", b(CondCode::kPL, L0)); + TEST_INSTRUCTION("06000054", b(CondCode::kVS, L0)); + TEST_INSTRUCTION("07000054", b(CondCode::kVC, L0)); + TEST_INSTRUCTION("08000054", b(CondCode::kHI, L0)); + TEST_INSTRUCTION("09000054", b(CondCode::kLS, L0)); + TEST_INSTRUCTION("0A000054", b(CondCode::kGE, L0)); + TEST_INSTRUCTION("0B000054", b(CondCode::kLT, L0)); + TEST_INSTRUCTION("0C000054", b(CondCode::kGT, L0)); + TEST_INSTRUCTION("0D000054", b(CondCode::kLE, L0)); + + TEST_INSTRUCTION("00000094", bl(L0)); + TEST_INSTRUCTION("01000034", cbz(w1, L0)); + TEST_INSTRUCTION("010000B4", cbz(x1, L0)); + TEST_INSTRUCTION("01000035", cbnz(w1, L0)); + TEST_INSTRUCTION("010000B5", cbnz(x1, L0)); + TEST_INSTRUCTION("01001837", tbnz(w1, 3, L0)); + TEST_INSTRUCTION("010008B7", tbnz(x1, 33, L0)); + TEST_INSTRUCTION("01001836", tbz(w1, 3, L0)); + TEST_INSTRUCTION("010008B6", tbz(x1, 33, L0)); +} + +static void ASMJIT_NOINLINE testA64AssemblerSIMD(AssemblerTester<a64::Assembler>& tester) noexcept { + using namespace a64; + + TEST_INSTRUCTION("41B8200E", abs(v1.b8(), v2.b8())); + TEST_INSTRUCTION("41B8600E", abs(v1.h4(), v2.h4())); + TEST_INSTRUCTION("41B8A00E", abs(v1.s2(), v2.s2())); + TEST_INSTRUCTION("41B8E05E", abs(d1, d2)); + TEST_INSTRUCTION("41B8204E", abs(v1.b16(), v2.b16())); + TEST_INSTRUCTION("41B8604E", abs(v1.h8(), v2.h8())); + TEST_INSTRUCTION("41B8A04E", abs(v1.s4(), v2.s4())); + TEST_INSTRUCTION("41B8E04E", abs(v1.d2(), v2.d2())); + TEST_INSTRUCTION("4184230E", add(v1.b8(), v2.b8(), v3.b8())); + TEST_INSTRUCTION("4184630E", add(v1.h4(), v2.h4(), v3.h4())); + TEST_INSTRUCTION("4184A30E", add(v1.s2(), v2.s2(), v3.s2())); + TEST_INSTRUCTION("4184E35E", add(d1, d2, d3)); + TEST_INSTRUCTION("4184234E", add(v1.b16(), v2.b16(), v3.b16())); + TEST_INSTRUCTION("4184634E", add(v1.h8(), v2.h8(), v3.h8())); + TEST_INSTRUCTION("4184A34E", add(v1.s4(), v2.s4(), v3.s4())); + TEST_INSTRUCTION("4184E34E", add(v1.d2(), v2.d2(), v3.d2())); + TEST_INSTRUCTION("4140230E", addhn(v1.b8(), v2.h8(), v3.h8())); + TEST_INSTRUCTION("4140630E", addhn(v1.h4(), v2.s4(), v3.s4())); + TEST_INSTRUCTION("4140A30E", addhn(v1.s2(), v2.d2(), v3.d2())); + TEST_INSTRUCTION("4140234E", addhn2(v1.b16(), v2.h8(), v3.h8())); + TEST_INSTRUCTION("4140634E", addhn2(v1.h8(), v2.s4(), v3.s4())); + TEST_INSTRUCTION("4140A34E", addhn2(v1.s4(), v2.d2(), v3.d2())); + TEST_INSTRUCTION("41BC230E", addp(v1.b8(), v2.b8(), v3.b8())); + TEST_INSTRUCTION("41BC630E", addp(v1.h4(), v2.h4(), v3.h4())); + TEST_INSTRUCTION("41BCA30E", addp(v1.s2(), v2.s2(), v3.s2())); + TEST_INSTRUCTION("41B8F15E", addp(d1, v2.d2())); + TEST_INSTRUCTION("41BC234E", addp(v1.b16(), v2.b16(), v3.b16())); + TEST_INSTRUCTION("41BC634E", addp(v1.h8(), v2.h8(), v3.h8())); + TEST_INSTRUCTION("41BCA34E", addp(v1.s4(), v2.s4(), v3.s4())); + TEST_INSTRUCTION("41BCE34E", addp(v1.d2(), v2.d2(), v3.d2())); + TEST_INSTRUCTION("41B8310E", addv(b1, v2.b8())); + TEST_INSTRUCTION("41B8314E", addv(b1, v2.b16())); + TEST_INSTRUCTION("41B8710E", addv(h1, v2.h4())); + TEST_INSTRUCTION("41B8714E", addv(h1, v2.h8())); + TEST_INSTRUCTION("41B8B14E", addv(s1, v2.s4())); + TEST_INSTRUCTION("4158284E", aesd(v1.b16(), v2.b16())); + TEST_INSTRUCTION("4148284E", aese(v1.b16(), v2.b16())); + TEST_INSTRUCTION("4178284E", aesimc(v1.b16(), v2.b16())); + TEST_INSTRUCTION("4168284E", aesmc(v1.b16(), v2.b16())); + TEST_INSTRUCTION("411C230E", and_(v1.b8(), v2.b8(), v3.b8())); + TEST_INSTRUCTION("411C234E", and_(v1.b16(), v2.b16(), v3.b16())); + TEST_INSTRUCTION("411023CE", bcax(v1.b16(), v2.b16(), v3.b16(), v4.b16())); + TEST_INSTRUCTION("4140631E", bfcvt(h1, s2)); + TEST_INSTRUCTION("4168A10E", bfcvtn(v1.h4(), v2.s4())); + TEST_INSTRUCTION("4168A14E", bfcvtn2(v1.h8(), v2.s4())); + TEST_INSTRUCTION("41FC432E", bfdot(v1.s2(), v2.h4(), v3.h4())); + TEST_INSTRUCTION("41FC436E", bfdot(v1.s4(), v2.h8(), v3.h8())); + TEST_INSTRUCTION("41F0430F", bfdot(v1.s2(), v2.h4(), v3.h2(0))); + TEST_INSTRUCTION("41F8634F", bfdot(v1.s4(), v2.h8(), v3.h2(3))); + TEST_INSTRUCTION("41FCC32E", bfmlalb(v1.s4(), v2.h8(), v3.h8())); + TEST_INSTRUCTION("41F0C30F", bfmlalb(v1.s4(), v2.h8(), v3.h(0))); + TEST_INSTRUCTION("41F8F30F", bfmlalb(v1.s4(), v2.h8(), v3.h(7))); + TEST_INSTRUCTION("41FCC36E", bfmlalt(v1.s4(), v2.h8(), v3.h8())); + TEST_INSTRUCTION("41F0C34F", bfmlalt(v1.s4(), v2.h8(), v3.h(0))); + TEST_INSTRUCTION("41F8F34F", bfmlalt(v1.s4(), v2.h8(), v3.h(7))); + TEST_INSTRUCTION("41EC436E", bfmmla(v1.s4(), v2.h8(), v3.h8())); + TEST_INSTRUCTION("411C630E", bic(v1.b8(), v2.b8(), v3.b8())); + TEST_INSTRUCTION("411C634E", bic(v1.b16(), v2.b16(), v3.b16())); + TEST_INSTRUCTION("E197072F", bic(v1.h4(), 255)); + TEST_INSTRUCTION("E1B7072F", bic(v1.h4(), 255, lsl(8))); + TEST_INSTRUCTION("E197076F", bic(v1.h8(), 255)); + TEST_INSTRUCTION("E1B7076F", bic(v1.h8(), 255, lsl(8))); + TEST_INSTRUCTION("E117072F", bic(v1.s2(), 255)); + TEST_INSTRUCTION("E137072F", bic(v1.s2(), 255, lsl(8))); + TEST_INSTRUCTION("E117076F", bic(v1.s4(), 255)); + TEST_INSTRUCTION("E177076F", bic(v1.s4(), 255, lsl(24))); + TEST_INSTRUCTION("411CE32E", bif(v1.b8(), v2.b8(), v3.b8())); + TEST_INSTRUCTION("411CE36E", bif(v1.b16(), v2.b16(), v3.b16())); + TEST_INSTRUCTION("411CA32E", bit(v1.b8(), v2.b8(), v3.b8())); + TEST_INSTRUCTION("411CA36E", bit(v1.b16(), v2.b16(), v3.b16())); + TEST_INSTRUCTION("411C632E", bsl(v1.b8(), v2.b8(), v3.b8())); + TEST_INSTRUCTION("411C636E", bsl(v1.b16(), v2.b16(), v3.b16())); + TEST_INSTRUCTION("4148200E", cls(v1.b8(), v2.b8())); + TEST_INSTRUCTION("4148600E", cls(v1.h4(), v2.h4())); + TEST_INSTRUCTION("4148A00E", cls(v1.s2(), v2.s2())); + TEST_INSTRUCTION("4148204E", cls(v1.b16(), v2.b16())); + TEST_INSTRUCTION("4148604E", cls(v1.h8(), v2.h8())); + TEST_INSTRUCTION("4148A04E", cls(v1.s4(), v2.s4())); + TEST_INSTRUCTION("4148202E", clz(v1.b8(), v2.b8())); + TEST_INSTRUCTION("4148602E", clz(v1.h4(), v2.h4())); + TEST_INSTRUCTION("4148A02E", clz(v1.s2(), v2.s2())); + TEST_INSTRUCTION("4148206E", clz(v1.b16(), v2.b16())); + TEST_INSTRUCTION("4148606E", clz(v1.h8(), v2.h8())); + TEST_INSTRUCTION("4148A06E", clz(v1.s4(), v2.s4())); + TEST_INSTRUCTION("418C232E", cmeq(v1.b8(), v2.b8(), v3.b8())); + TEST_INSTRUCTION("418C632E", cmeq(v1.h4(), v2.h4(), v3.h4())); + TEST_INSTRUCTION("418CA32E", cmeq(v1.s2(), v2.s2(), v3.s2())); + TEST_INSTRUCTION("418CE37E", cmeq(d1, d2, d3)); + TEST_INSTRUCTION("418C236E", cmeq(v1.b16(), v2.b16(), v3.b16())); + TEST_INSTRUCTION("418C636E", cmeq(v1.h8(), v2.h8(), v3.h8())); + TEST_INSTRUCTION("418CA36E", cmeq(v1.s4(), v2.s4(), v3.s4())); + TEST_INSTRUCTION("418CE36E", cmeq(v1.d2(), v2.d2(), v3.d2())); + TEST_INSTRUCTION("4198200E", cmeq(v1.b8(), v2.b8(), 0)); + TEST_INSTRUCTION("4198600E", cmeq(v1.h4(), v2.h4(), 0)); + TEST_INSTRUCTION("4198A00E", cmeq(v1.s2(), v2.s2(), 0)); + TEST_INSTRUCTION("4198E05E", cmeq(d1, d2, 0)); + TEST_INSTRUCTION("4198204E", cmeq(v1.b16(), v2.b16(), 0)); + TEST_INSTRUCTION("4198604E", cmeq(v1.h8(), v2.h8(), 0)); + TEST_INSTRUCTION("4198A04E", cmeq(v1.s4(), v2.s4(), 0)); + TEST_INSTRUCTION("4198E04E", cmeq(v1.d2(), v2.d2(), 0)); + TEST_INSTRUCTION("413C230E", cmge(v1.b8(), v2.b8(), v3.b8())); + TEST_INSTRUCTION("413C630E", cmge(v1.h4(), v2.h4(), v3.h4())); + TEST_INSTRUCTION("413CA30E", cmge(v1.s2(), v2.s2(), v3.s2())); + TEST_INSTRUCTION("413CE35E", cmge(d1, d2, d3)); + TEST_INSTRUCTION("413C234E", cmge(v1.b16(), v2.b16(), v3.b16())); + TEST_INSTRUCTION("413C634E", cmge(v1.h8(), v2.h8(), v3.h8())); + TEST_INSTRUCTION("413CA34E", cmge(v1.s4(), v2.s4(), v3.s4())); + TEST_INSTRUCTION("413CE34E", cmge(v1.d2(), v2.d2(), v3.d2())); + TEST_INSTRUCTION("4188202E", cmge(v1.b8(), v2.b8(), 0)); + TEST_INSTRUCTION("4188602E", cmge(v1.h4(), v2.h4(), 0)); + TEST_INSTRUCTION("4188A02E", cmge(v1.s2(), v2.s2(), 0)); + TEST_INSTRUCTION("4188E07E", cmge(d1, d2, 0)); + TEST_INSTRUCTION("4188206E", cmge(v1.b16(), v2.b16(), 0)); + TEST_INSTRUCTION("4188606E", cmge(v1.h8(), v2.h8(), 0)); + TEST_INSTRUCTION("4188A06E", cmge(v1.s4(), v2.s4(), 0)); + TEST_INSTRUCTION("4188E06E", cmge(v1.d2(), v2.d2(), 0)); + TEST_INSTRUCTION("4134230E", cmgt(v1.b8(), v2.b8(), v3.b8())); + TEST_INSTRUCTION("4134630E", cmgt(v1.h4(), v2.h4(), v3.h4())); + TEST_INSTRUCTION("4134A30E", cmgt(v1.s2(), v2.s2(), v3.s2())); + TEST_INSTRUCTION("4134E35E", cmgt(d1, d2, d3)); + TEST_INSTRUCTION("4134234E", cmgt(v1.b16(), v2.b16(), v3.b16())); + TEST_INSTRUCTION("4134634E", cmgt(v1.h8(), v2.h8(), v3.h8())); + TEST_INSTRUCTION("4134A34E", cmgt(v1.s4(), v2.s4(), v3.s4())); + TEST_INSTRUCTION("4134E34E", cmgt(v1.d2(), v2.d2(), v3.d2())); + TEST_INSTRUCTION("4188200E", cmgt(v1.b8(), v2.b8(), 0)); + TEST_INSTRUCTION("4188600E", cmgt(v1.h4(), v2.h4(), 0)); + TEST_INSTRUCTION("4188A00E", cmgt(v1.s2(), v2.s2(), 0)); + TEST_INSTRUCTION("4188E05E", cmgt(d1, d2, 0)); + TEST_INSTRUCTION("4188204E", cmgt(v1.b16(), v2.b16(), 0)); + TEST_INSTRUCTION("4188604E", cmgt(v1.h8(), v2.h8(), 0)); + TEST_INSTRUCTION("4188A04E", cmgt(v1.s4(), v2.s4(), 0)); + TEST_INSTRUCTION("4188E04E", cmgt(v1.d2(), v2.d2(), 0)); + TEST_INSTRUCTION("4134232E", cmhi(v1.b8(), v2.b8(), v3.b8())); + TEST_INSTRUCTION("4134632E", cmhi(v1.h4(), v2.h4(), v3.h4())); + TEST_INSTRUCTION("4134A32E", cmhi(v1.s2(), v2.s2(), v3.s2())); + TEST_INSTRUCTION("4134E37E", cmhi(d1, d2, d3)); + TEST_INSTRUCTION("4134236E", cmhi(v1.b16(), v2.b16(), v3.b16())); + TEST_INSTRUCTION("4134636E", cmhi(v1.h8(), v2.h8(), v3.h8())); + TEST_INSTRUCTION("4134A36E", cmhi(v1.s4(), v2.s4(), v3.s4())); + TEST_INSTRUCTION("4134E36E", cmhi(v1.d2(), v2.d2(), v3.d2())); + TEST_INSTRUCTION("413C232E", cmhs(v1.b8(), v2.b8(), v3.b8())); + TEST_INSTRUCTION("413C632E", cmhs(v1.h4(), v2.h4(), v3.h4())); + TEST_INSTRUCTION("413CA32E", cmhs(v1.s2(), v2.s2(), v3.s2())); + TEST_INSTRUCTION("413CE37E", cmhs(d1, d2, d3)); + TEST_INSTRUCTION("413C236E", cmhs(v1.b16(), v2.b16(), v3.b16())); + TEST_INSTRUCTION("413C636E", cmhs(v1.h8(), v2.h8(), v3.h8())); + TEST_INSTRUCTION("413CA36E", cmhs(v1.s4(), v2.s4(), v3.s4())); + TEST_INSTRUCTION("413CE36E", cmhs(v1.d2(), v2.d2(), v3.d2())); + TEST_INSTRUCTION("4198202E", cmle(v1.b8(), v2.b8(), 0)); + TEST_INSTRUCTION("4198602E", cmle(v1.h4(), v2.h4(), 0)); + TEST_INSTRUCTION("4198A02E", cmle(v1.s2(), v2.s2(), 0)); + TEST_INSTRUCTION("4198E07E", cmle(d1, d2, 0)); + TEST_INSTRUCTION("4198206E", cmle(v1.b16(), v2.b16(), 0)); + TEST_INSTRUCTION("4198606E", cmle(v1.h8(), v2.h8(), 0)); + TEST_INSTRUCTION("4198A06E", cmle(v1.s4(), v2.s4(), 0)); + TEST_INSTRUCTION("4198E06E", cmle(v1.d2(), v2.d2(), 0)); + TEST_INSTRUCTION("41A8200E", cmlt(v1.b8(), v2.b8(), 0)); + TEST_INSTRUCTION("41A8600E", cmlt(v1.h4(), v2.h4(), 0)); + TEST_INSTRUCTION("41A8A00E", cmlt(v1.s2(), v2.s2(), 0)); + TEST_INSTRUCTION("41A8E05E", cmlt(d1, d2, 0)); + TEST_INSTRUCTION("41A8204E", cmlt(v1.b16(), v2.b16(), 0)); + TEST_INSTRUCTION("41A8604E", cmlt(v1.h8(), v2.h8(), 0)); + TEST_INSTRUCTION("41A8A04E", cmlt(v1.s4(), v2.s4(), 0)); + TEST_INSTRUCTION("41A8E04E", cmlt(v1.d2(), v2.d2(), 0)); + TEST_INSTRUCTION("418C230E", cmtst(v1.b8(), v2.b8(), v3.b8())); + TEST_INSTRUCTION("418C630E", cmtst(v1.h4(), v2.h4(), v3.h4())); + TEST_INSTRUCTION("418CA30E", cmtst(v1.s2(), v2.s2(), v3.s2())); + TEST_INSTRUCTION("418CE35E", cmtst(d1, d2, d3)); + TEST_INSTRUCTION("418C234E", cmtst(v1.b16(), v2.b16(), v3.b16())); + TEST_INSTRUCTION("418C634E", cmtst(v1.h8(), v2.h8(), v3.h8())); + TEST_INSTRUCTION("418CA34E", cmtst(v1.s4(), v2.s4(), v3.s4())); + TEST_INSTRUCTION("418CE34E", cmtst(v1.d2(), v2.d2(), v3.d2())); + TEST_INSTRUCTION("4158200E", cnt(v1.b8(), v2.b8())); + TEST_INSTRUCTION("4158204E", cnt(v1.b16(), v2.b16())); + TEST_INSTRUCTION("410C010E", dup(v1.b8(), w2)); + TEST_INSTRUCTION("410C020E", dup(v1.h4(), w2)); + TEST_INSTRUCTION("410C040E", dup(v1.s2(), w2)); + TEST_INSTRUCTION("410C014E", dup(v1.b16(), w2)); + TEST_INSTRUCTION("410C024E", dup(v1.h8(), w2)); + TEST_INSTRUCTION("410C044E", dup(v1.s4(), w2)); + TEST_INSTRUCTION("410C084E", dup(v1.d2(), x2)); + TEST_INSTRUCTION("4F04035E", dup(b15, v2.b(1))); + TEST_INSTRUCTION("4F04065E", dup(h15, v2.h(1))); + TEST_INSTRUCTION("4F040C5E", dup(s15, v2.s(1))); + TEST_INSTRUCTION("4F04185E", dup(d15, v2.d(1))); + TEST_INSTRUCTION("4F04030E", dup(v15.b8(), v2.b(1))); + TEST_INSTRUCTION("4F04060E", dup(v15.h4(), v2.h(1))); + TEST_INSTRUCTION("4F040C0E", dup(v15.s2(), v2.s(1))); + TEST_INSTRUCTION("4F04034E", dup(v15.b16(), v2.b(1))); + TEST_INSTRUCTION("4F04064E", dup(v15.h8(), v2.h(1))); + TEST_INSTRUCTION("4F040C4E", dup(v15.s4(), v2.s(1))); + TEST_INSTRUCTION("4F04184E", dup(v15.d2(), v2.d(1))); + TEST_INSTRUCTION("411C232E", eor(v1.b8(), v2.b8(), v3.b8())); + TEST_INSTRUCTION("411C236E", eor(v1.b16(), v2.b16(), v3.b16())); + TEST_INSTRUCTION("411003CE", eor3(v1.b16(), v2.b16(), v3.b16(), v4.b16())); + TEST_INSTRUCTION("4128032E", ext(v1.b8(), v2.b8(), v3.b8(), 5)); + TEST_INSTRUCTION("4128036E", ext(v1.b16(), v2.b16(), v3.b16(), 5)); + TEST_INSTRUCTION("4114C37E", fabd(h1, h2, h3)); + TEST_INSTRUCTION("41D4A37E", fabd(s1, s2, s3)); + TEST_INSTRUCTION("41D4E37E", fabd(d1, d2, d3)); + TEST_INSTRUCTION("4114C32E", fabd(v1.h4(), v2.h4(), v3.h4())); + TEST_INSTRUCTION("41D4A32E", fabd(v1.s2(), v2.s2(), v3.s2())); + TEST_INSTRUCTION("4114C36E", fabd(v1.h8(), v2.h8(), v3.h8())); + TEST_INSTRUCTION("41D4A36E", fabd(v1.s4(), v2.s4(), v3.s4())); + TEST_INSTRUCTION("41D4E36E", fabd(v1.d2(), v2.d2(), v3.d2())); + TEST_INSTRUCTION("41C0E01E", fabs(h1, h2)); + TEST_INSTRUCTION("41C0201E", fabs(s1, s2)); + TEST_INSTRUCTION("41C0601E", fabs(d1, d2)); + TEST_INSTRUCTION("41F8F80E", fabs(v1.h4(), v2.h4())); + TEST_INSTRUCTION("41F8A00E", fabs(v1.s2(), v2.s2())); + TEST_INSTRUCTION("41F8F84E", fabs(v1.h8(), v2.h8())); + TEST_INSTRUCTION("41F8A04E", fabs(v1.s4(), v2.s4())); + TEST_INSTRUCTION("41F8E04E", fabs(v1.d2(), v2.d2())); + TEST_INSTRUCTION("412C437E", facge(h1, h2, h3)); + TEST_INSTRUCTION("41EC237E", facge(s1, s2, s3)); + TEST_INSTRUCTION("41EC637E", facge(d1, d2, d3)); + TEST_INSTRUCTION("412C432E", facge(v1.h4(), v2.h4(), v3.h4())); + TEST_INSTRUCTION("41EC232E", facge(v1.s2(), v2.s2(), v3.s2())); + TEST_INSTRUCTION("412C436E", facge(v1.h8(), v2.h8(), v3.h8())); + TEST_INSTRUCTION("41EC236E", facge(v1.s4(), v2.s4(), v3.s4())); + TEST_INSTRUCTION("41EC636E", facge(v1.d2(), v2.d2(), v3.d2())); + TEST_INSTRUCTION("412CC37E", facgt(h1, h2, h3)); + TEST_INSTRUCTION("41ECA37E", facgt(s1, s2, s3)); + TEST_INSTRUCTION("41ECE37E", facgt(d1, d2, d3)); + TEST_INSTRUCTION("412CC32E", facgt(v1.h4(), v2.h4(), v3.h4())); + TEST_INSTRUCTION("41ECA32E", facgt(v1.s2(), v2.s2(), v3.s2())); + TEST_INSTRUCTION("412CC36E", facgt(v1.h8(), v2.h8(), v3.h8())); + TEST_INSTRUCTION("41ECA36E", facgt(v1.s4(), v2.s4(), v3.s4())); + TEST_INSTRUCTION("41ECE36E", facgt(v1.d2(), v2.d2(), v3.d2())); + TEST_INSTRUCTION("4128E31E", fadd(h1, h2, h3)); + TEST_INSTRUCTION("4128231E", fadd(s1, s2, s3)); + TEST_INSTRUCTION("4128631E", fadd(d1, d2, d3)); + TEST_INSTRUCTION("4114430E", fadd(v1.h4(), v2.h4(), v3.h4())); + TEST_INSTRUCTION("41D4230E", fadd(v1.s2(), v2.s2(), v3.s2())); + TEST_INSTRUCTION("4114434E", fadd(v1.h8(), v2.h8(), v3.h8())); + TEST_INSTRUCTION("41D4234E", fadd(v1.s4(), v2.s4(), v3.s4())); + TEST_INSTRUCTION("41D4634E", fadd(v1.d2(), v2.d2(), v3.d2())); + TEST_INSTRUCTION("41D8305E", faddp(h1, v2.h2())); + TEST_INSTRUCTION("41D8307E", faddp(s1, v2.s2())); + TEST_INSTRUCTION("41D8707E", faddp(d1, v2.d2())); + TEST_INSTRUCTION("4114432E", faddp(v1.h4(), v2.h4(), v3.h4())); + TEST_INSTRUCTION("41D4232E", faddp(v1.s2(), v2.s2(), v3.s2())); + TEST_INSTRUCTION("4114436E", faddp(v1.h8(), v2.h8(), v3.h8())); + TEST_INSTRUCTION("41D4236E", faddp(v1.s4(), v2.s4(), v3.s4())); + TEST_INSTRUCTION("41D4636E", faddp(v1.d2(), v2.d2(), v3.d2())); + TEST_INSTRUCTION("41E4432E", fcadd(v1.h4(), v2.h4(), v3.h4(), 90)); + TEST_INSTRUCTION("41E4832E", fcadd(v1.s2(), v2.s2(), v3.s2(), 90)); + TEST_INSTRUCTION("41E4436E", fcadd(v1.h8(), v2.h8(), v3.h8(), 90)); + TEST_INSTRUCTION("41E4836E", fcadd(v1.s4(), v2.s4(), v3.s4(), 90)); + TEST_INSTRUCTION("41E4C36E", fcadd(v1.d2(), v2.d2(), v3.d2(), 90)); + TEST_INSTRUCTION("41F4432E", fcadd(v1.h4(), v2.h4(), v3.h4(), 270)); + TEST_INSTRUCTION("41F4832E", fcadd(v1.s2(), v2.s2(), v3.s2(), 270)); + TEST_INSTRUCTION("41F4436E", fcadd(v1.h8(), v2.h8(), v3.h8(), 270)); + TEST_INSTRUCTION("41F4836E", fcadd(v1.s4(), v2.s4(), v3.s4(), 270)); + TEST_INSTRUCTION("41F4C36E", fcadd(v1.d2(), v2.d2(), v3.d2(), 270)); + TEST_INSTRUCTION("2404E21E", fccmp(h1, h2, 4, CondCode::kEQ)); + TEST_INSTRUCTION("2404221E", fccmp(s1, s2, 4, CondCode::kEQ)); + TEST_INSTRUCTION("2404621E", fccmp(d1, d2, 4, CondCode::kEQ)); + TEST_INSTRUCTION("3404E21E", fccmpe(h1, h2, 4, CondCode::kEQ)); + TEST_INSTRUCTION("3404221E", fccmpe(s1, s2, 4, CondCode::kEQ)); + TEST_INSTRUCTION("3404621E", fccmpe(d1, d2, 4, CondCode::kEQ)); + TEST_INSTRUCTION("4124435E", fcmeq(h1, h2, h3)); + TEST_INSTRUCTION("41E4235E", fcmeq(s1, s2, s3)); + TEST_INSTRUCTION("41E4635E", fcmeq(d1, d2, d3)); + TEST_INSTRUCTION("4124430E", fcmeq(v1.h4(), v2.h4(), v3.h4())); + TEST_INSTRUCTION("41E4230E", fcmeq(v1.s2(), v2.s2(), v3.s2())); + TEST_INSTRUCTION("4124434E", fcmeq(v1.h8(), v2.h8(), v3.h8())); + TEST_INSTRUCTION("41E4234E", fcmeq(v1.s4(), v2.s4(), v3.s4())); + TEST_INSTRUCTION("41E4634E", fcmeq(v1.d2(), v2.d2(), v3.d2())); + TEST_INSTRUCTION("41D8F85E", fcmeq(h1, h2, 0)); + TEST_INSTRUCTION("41D8A05E", fcmeq(s1, s2, 0)); + TEST_INSTRUCTION("41D8E05E", fcmeq(d1, d2, 0)); + TEST_INSTRUCTION("41D8F80E", fcmeq(v1.h4(), v2.h4(), 0)); + TEST_INSTRUCTION("41D8A00E", fcmeq(v1.s2(), v2.s2(), 0)); + TEST_INSTRUCTION("41D8F84E", fcmeq(v1.h8(), v2.h8(), 0)); + TEST_INSTRUCTION("41D8A04E", fcmeq(v1.s4(), v2.s4(), 0)); + TEST_INSTRUCTION("41D8E04E", fcmeq(v1.d2(), v2.d2(), 0)); + TEST_INSTRUCTION("4124437E", fcmge(h1, h2, h3)); + TEST_INSTRUCTION("41E4237E", fcmge(s1, s2, s3)); + TEST_INSTRUCTION("41E4637E", fcmge(d1, d2, d3)); + TEST_INSTRUCTION("4124432E", fcmge(v1.h4(), v2.h4(), v3.h4())); + TEST_INSTRUCTION("41E4232E", fcmge(v1.s2(), v2.s2(), v3.s2())); + TEST_INSTRUCTION("4124436E", fcmge(v1.h8(), v2.h8(), v3.h8())); + TEST_INSTRUCTION("41E4236E", fcmge(v1.s4(), v2.s4(), v3.s4())); + TEST_INSTRUCTION("41E4636E", fcmge(v1.d2(), v2.d2(), v3.d2())); + TEST_INSTRUCTION("41C8F87E", fcmge(h1, h2, 0)); + TEST_INSTRUCTION("41C8A07E", fcmge(s1, s2, 0)); + TEST_INSTRUCTION("41C8E07E", fcmge(d1, d2, 0)); + TEST_INSTRUCTION("41C8F82E", fcmge(v1.h4(), v2.h4(), 0)); + TEST_INSTRUCTION("41C8A02E", fcmge(v1.s2(), v2.s2(), 0)); + TEST_INSTRUCTION("41C8F86E", fcmge(v1.h8(), v2.h8(), 0)); + TEST_INSTRUCTION("41C8A06E", fcmge(v1.s4(), v2.s4(), 0)); + TEST_INSTRUCTION("41C8E06E", fcmge(v1.d2(), v2.d2(), 0)); + TEST_INSTRUCTION("4124C37E", fcmgt(h1, h2, h3)); + TEST_INSTRUCTION("41E4A37E", fcmgt(s1, s2, s3)); + TEST_INSTRUCTION("41E4E37E", fcmgt(d1, d2, d3)); + TEST_INSTRUCTION("4124C32E", fcmgt(v1.h4(), v2.h4(), v3.h4())); + TEST_INSTRUCTION("41E4A32E", fcmgt(v1.s2(), v2.s2(), v3.s2())); + TEST_INSTRUCTION("4124C36E", fcmgt(v1.h8(), v2.h8(), v3.h8())); + TEST_INSTRUCTION("41E4A36E", fcmgt(v1.s4(), v2.s4(), v3.s4())); + TEST_INSTRUCTION("41E4E36E", fcmgt(v1.d2(), v2.d2(), v3.d2())); + TEST_INSTRUCTION("41C8F85E", fcmgt(h1, h2, 0)); + TEST_INSTRUCTION("41C8A05E", fcmgt(s1, s2, 0)); + TEST_INSTRUCTION("41C8E05E", fcmgt(d1, d2, 0)); + TEST_INSTRUCTION("41C8F80E", fcmgt(v1.h4(), v2.h4(), 0)); + TEST_INSTRUCTION("41C8A00E", fcmgt(v1.s2(), v2.s2(), 0)); + TEST_INSTRUCTION("41C8F84E", fcmgt(v1.h8(), v2.h8(), 0)); + TEST_INSTRUCTION("41C8A04E", fcmgt(v1.s4(), v2.s4(), 0)); + TEST_INSTRUCTION("41C8E04E", fcmgt(v1.d2(), v2.d2(), 0)); + TEST_INSTRUCTION("41CC432E", fcmla(v1.h4(), v2.h4(), v3.h4(), 90)); + TEST_INSTRUCTION("41CC832E", fcmla(v1.s2(), v2.s2(), v3.s2(), 90)); + TEST_INSTRUCTION("41CC436E", fcmla(v1.h8(), v2.h8(), v3.h8(), 90)); + TEST_INSTRUCTION("41CC836E", fcmla(v1.s4(), v2.s4(), v3.s4(), 90)); + TEST_INSTRUCTION("41CCC36E", fcmla(v1.d2(), v2.d2(), v3.d2(), 90)); + TEST_INSTRUCTION("41DC432E", fcmla(v1.h4(), v2.h4(), v3.h4(), 270)); + TEST_INSTRUCTION("41DC832E", fcmla(v1.s2(), v2.s2(), v3.s2(), 270)); + TEST_INSTRUCTION("41DC436E", fcmla(v1.h8(), v2.h8(), v3.h8(), 270)); + TEST_INSTRUCTION("41DC836E", fcmla(v1.s4(), v2.s4(), v3.s4(), 270)); + TEST_INSTRUCTION("41DCC36E", fcmla(v1.d2(), v2.d2(), v3.d2(), 270)); + TEST_INSTRUCTION("4130432F", fcmla(v1.h4(), v2.h4(), v3.h(0), 90)); + TEST_INSTRUCTION("4130632F", fcmla(v1.h4(), v2.h4(), v3.h(1), 90)); + TEST_INSTRUCTION("4130436F", fcmla(v1.h8(), v2.h8(), v3.h(0), 90)); + TEST_INSTRUCTION("4138636F", fcmla(v1.h8(), v2.h8(), v3.h(3), 90)); + TEST_INSTRUCTION("4130836F", fcmla(v1.s4(), v2.s4(), v3.s(0), 90)); + TEST_INSTRUCTION("4138836F", fcmla(v1.s4(), v2.s4(), v3.s(1), 90)); + TEST_INSTRUCTION("4170432F", fcmla(v1.h4(), v2.h4(), v3.h(0), 270)); + TEST_INSTRUCTION("4170632F", fcmla(v1.h4(), v2.h4(), v3.h(1), 270)); + TEST_INSTRUCTION("4170436F", fcmla(v1.h8(), v2.h8(), v3.h(0), 270)); + TEST_INSTRUCTION("4178636F", fcmla(v1.h8(), v2.h8(), v3.h(3), 270)); + TEST_INSTRUCTION("4170836F", fcmla(v1.s4(), v2.s4(), v3.s(0), 270)); + TEST_INSTRUCTION("4178836F", fcmla(v1.s4(), v2.s4(), v3.s(1), 270)); + TEST_INSTRUCTION("41D8F87E", fcmle(h1, h2, 0)); + TEST_INSTRUCTION("41D8A07E", fcmle(s1, s2, 0)); + TEST_INSTRUCTION("41D8E07E", fcmle(d1, d2, 0)); + TEST_INSTRUCTION("41D8F82E", fcmle(v1.h4(), v2.h4(), 0)); + TEST_INSTRUCTION("41D8A02E", fcmle(v1.s2(), v2.s2(), 0)); + TEST_INSTRUCTION("41D8F86E", fcmle(v1.h8(), v2.h8(), 0)); + TEST_INSTRUCTION("41D8A06E", fcmle(v1.s4(), v2.s4(), 0)); + TEST_INSTRUCTION("41D8E06E", fcmle(v1.d2(), v2.d2(), 0)); + TEST_INSTRUCTION("41E8F85E", fcmlt(h1, h2, 0)); + TEST_INSTRUCTION("41E8A05E", fcmlt(s1, s2, 0)); + TEST_INSTRUCTION("41E8E05E", fcmlt(d1, d2, 0)); + TEST_INSTRUCTION("41E8F80E", fcmlt(v1.h4(), v2.h4(), 0)); + TEST_INSTRUCTION("41E8A00E", fcmlt(v1.s2(), v2.s2(), 0)); + TEST_INSTRUCTION("41E8F84E", fcmlt(v1.h8(), v2.h8(), 0)); + TEST_INSTRUCTION("41E8A04E", fcmlt(v1.s4(), v2.s4(), 0)); + TEST_INSTRUCTION("41E8E04E", fcmlt(v1.d2(), v2.d2(), 0)); + TEST_INSTRUCTION("2020E21E", fcmp(h1, h2)); + TEST_INSTRUCTION("2020221E", fcmp(s1, s2)); + TEST_INSTRUCTION("2020621E", fcmp(d1, d2)); + TEST_INSTRUCTION("2820E01E", fcmp(h1, 0)); + TEST_INSTRUCTION("2820201E", fcmp(s1, 0)); + TEST_INSTRUCTION("2820601E", fcmp(d1, 0)); + TEST_INSTRUCTION("3020E21E", fcmpe(h1, h2)); + TEST_INSTRUCTION("3020221E", fcmpe(s1, s2)); + TEST_INSTRUCTION("3020621E", fcmpe(d1, d2)); + TEST_INSTRUCTION("3820E01E", fcmpe(h1, 0)); + TEST_INSTRUCTION("3820201E", fcmpe(s1, 0)); + TEST_INSTRUCTION("3820601E", fcmpe(d1, 0)); + TEST_INSTRUCTION("410CE31E", fcsel(h1, h2, h3, CondCode::kEQ)); + TEST_INSTRUCTION("410C231E", fcsel(s1, s2, s3, CondCode::kEQ)); + TEST_INSTRUCTION("410C631E", fcsel(d1, d2, d3, CondCode::kEQ)); + TEST_INSTRUCTION("41C0231E", fcvt(h1, s2)); + TEST_INSTRUCTION("41C0631E", fcvt(h1, d2)); + TEST_INSTRUCTION("4140E21E", fcvt(s1, h2)); + TEST_INSTRUCTION("4140621E", fcvt(s1, d2)); + TEST_INSTRUCTION("41C0E21E", fcvt(d1, h2)); + TEST_INSTRUCTION("41C0221E", fcvt(d1, s2)); + TEST_INSTRUCTION("4100E41E", fcvtas(w1, h2)); + TEST_INSTRUCTION("4100241E", fcvtas(w1, s2)); + TEST_INSTRUCTION("4100641E", fcvtas(w1, d2)); + TEST_INSTRUCTION("4100E49E", fcvtas(x1, h2)); + TEST_INSTRUCTION("4100249E", fcvtas(x1, s2)); + TEST_INSTRUCTION("4100649E", fcvtas(x1, d2)); + TEST_INSTRUCTION("41C8795E", fcvtas(h1, h2)); + TEST_INSTRUCTION("41C8215E", fcvtas(s1, s2)); + TEST_INSTRUCTION("41C8615E", fcvtas(d1, d2)); + TEST_INSTRUCTION("41C8790E", fcvtas(v1.h4(), v2.h4())); + TEST_INSTRUCTION("41C8210E", fcvtas(v1.s2(), v2.s2())); + TEST_INSTRUCTION("41C8794E", fcvtas(v1.h8(), v2.h8())); + TEST_INSTRUCTION("41C8214E", fcvtas(v1.s4(), v2.s4())); + TEST_INSTRUCTION("41C8614E", fcvtas(v1.d2(), v2.d2())); + TEST_INSTRUCTION("4100E51E", fcvtau(w1, h2)); + TEST_INSTRUCTION("4100251E", fcvtau(w1, s2)); + TEST_INSTRUCTION("4100651E", fcvtau(w1, d2)); + TEST_INSTRUCTION("4100E59E", fcvtau(x1, h2)); + TEST_INSTRUCTION("4100259E", fcvtau(x1, s2)); + TEST_INSTRUCTION("4100659E", fcvtau(x1, d2)); + TEST_INSTRUCTION("41C8797E", fcvtau(h1, h2)); + TEST_INSTRUCTION("41C8217E", fcvtau(s1, s2)); + TEST_INSTRUCTION("41C8617E", fcvtau(d1, d2)); + TEST_INSTRUCTION("41C8792E", fcvtau(v1.h4(), v2.h4())); + TEST_INSTRUCTION("41C8212E", fcvtau(v1.s2(), v2.s2())); + TEST_INSTRUCTION("41C8796E", fcvtau(v1.h8(), v2.h8())); + TEST_INSTRUCTION("41C8216E", fcvtau(v1.s4(), v2.s4())); + TEST_INSTRUCTION("41C8616E", fcvtau(v1.d2(), v2.d2())); + TEST_INSTRUCTION("4178210E", fcvtl(v1.s4(), v2.h4())); + TEST_INSTRUCTION("4178214E", fcvtl2(v1.s4(), v2.h8())); + TEST_INSTRUCTION("4178610E", fcvtl(v1.d2(), v2.s2())); + TEST_INSTRUCTION("4178614E", fcvtl2(v1.d2(), v2.s4())); + TEST_INSTRUCTION("4100F01E", fcvtms(w1, h2)); + TEST_INSTRUCTION("4100301E", fcvtms(w1, s2)); + TEST_INSTRUCTION("4100701E", fcvtms(w1, d2)); + TEST_INSTRUCTION("4100F09E", fcvtms(x1, h2)); + TEST_INSTRUCTION("4100309E", fcvtms(x1, s2)); + TEST_INSTRUCTION("4100709E", fcvtms(x1, d2)); + TEST_INSTRUCTION("41B8795E", fcvtms(h1, h2)); + TEST_INSTRUCTION("41B8215E", fcvtms(s1, s2)); + TEST_INSTRUCTION("41B8615E", fcvtms(d1, d2)); + TEST_INSTRUCTION("41B8790E", fcvtms(v1.h4(), v2.h4())); + TEST_INSTRUCTION("41B8210E", fcvtms(v1.s2(), v2.s2())); + TEST_INSTRUCTION("41B8794E", fcvtms(v1.h8(), v2.h8())); + TEST_INSTRUCTION("41B8214E", fcvtms(v1.s4(), v2.s4())); + TEST_INSTRUCTION("41B8614E", fcvtms(v1.d2(), v2.d2())); + TEST_INSTRUCTION("4100F11E", fcvtmu(w1, h2)); + TEST_INSTRUCTION("4100311E", fcvtmu(w1, s2)); + TEST_INSTRUCTION("4100711E", fcvtmu(w1, d2)); + TEST_INSTRUCTION("4100F19E", fcvtmu(x1, h2)); + TEST_INSTRUCTION("4100319E", fcvtmu(x1, s2)); + TEST_INSTRUCTION("4100719E", fcvtmu(x1, d2)); + TEST_INSTRUCTION("41B8797E", fcvtmu(h1, h2)); + TEST_INSTRUCTION("41B8217E", fcvtmu(s1, s2)); + TEST_INSTRUCTION("41B8617E", fcvtmu(d1, d2)); + TEST_INSTRUCTION("41B8792E", fcvtmu(v1.h4(), v2.h4())); + TEST_INSTRUCTION("41B8212E", fcvtmu(v1.s2(), v2.s2())); + TEST_INSTRUCTION("41B8796E", fcvtmu(v1.h8(), v2.h8())); + TEST_INSTRUCTION("41B8216E", fcvtmu(v1.s4(), v2.s4())); + TEST_INSTRUCTION("41B8616E", fcvtmu(v1.d2(), v2.d2())); + TEST_INSTRUCTION("4168210E", fcvtn(v1.h4(), v2.s4())); + TEST_INSTRUCTION("4168214E", fcvtn2(v1.h8(), v2.s4())); + TEST_INSTRUCTION("4168610E", fcvtn(v1.s2(), v2.d2())); + TEST_INSTRUCTION("4168614E", fcvtn2(v1.s4(), v2.d2())); + TEST_INSTRUCTION("4100E01E", fcvtns(w1, h2)); + TEST_INSTRUCTION("4100201E", fcvtns(w1, s2)); + TEST_INSTRUCTION("4100601E", fcvtns(w1, d2)); + TEST_INSTRUCTION("4100E09E", fcvtns(x1, h2)); + TEST_INSTRUCTION("4100209E", fcvtns(x1, s2)); + TEST_INSTRUCTION("4100609E", fcvtns(x1, d2)); + TEST_INSTRUCTION("41A8795E", fcvtns(h1, h2)); + TEST_INSTRUCTION("41A8215E", fcvtns(s1, s2)); + TEST_INSTRUCTION("41A8615E", fcvtns(d1, d2)); + TEST_INSTRUCTION("41A8790E", fcvtns(v1.h4(), v2.h4())); + TEST_INSTRUCTION("41A8210E", fcvtns(v1.s2(), v2.s2())); + TEST_INSTRUCTION("41A8794E", fcvtns(v1.h8(), v2.h8())); + TEST_INSTRUCTION("41A8214E", fcvtns(v1.s4(), v2.s4())); + TEST_INSTRUCTION("41A8614E", fcvtns(v1.d2(), v2.d2())); + TEST_INSTRUCTION("4100E11E", fcvtnu(w1, h2)); + TEST_INSTRUCTION("4100211E", fcvtnu(w1, s2)); + TEST_INSTRUCTION("4100611E", fcvtnu(w1, d2)); + TEST_INSTRUCTION("4100E19E", fcvtnu(x1, h2)); + TEST_INSTRUCTION("4100219E", fcvtnu(x1, s2)); + TEST_INSTRUCTION("4100619E", fcvtnu(x1, d2)); + TEST_INSTRUCTION("41A8797E", fcvtnu(h1, h2)); + TEST_INSTRUCTION("41A8217E", fcvtnu(s1, s2)); + TEST_INSTRUCTION("41A8617E", fcvtnu(d1, d2)); + TEST_INSTRUCTION("41A8792E", fcvtnu(v1.h4(), v2.h4())); + TEST_INSTRUCTION("41A8212E", fcvtnu(v1.s2(), v2.s2())); + TEST_INSTRUCTION("41A8796E", fcvtnu(v1.h8(), v2.h8())); + TEST_INSTRUCTION("41A8216E", fcvtnu(v1.s4(), v2.s4())); + TEST_INSTRUCTION("41A8616E", fcvtnu(v1.d2(), v2.d2())); + TEST_INSTRUCTION("4100E81E", fcvtps(w1, h2)); + TEST_INSTRUCTION("4100281E", fcvtps(w1, s2)); + TEST_INSTRUCTION("4100681E", fcvtps(w1, d2)); + TEST_INSTRUCTION("4100E89E", fcvtps(x1, h2)); + TEST_INSTRUCTION("4100289E", fcvtps(x1, s2)); + TEST_INSTRUCTION("4100689E", fcvtps(x1, d2)); + TEST_INSTRUCTION("41A8F95E", fcvtps(h1, h2)); + TEST_INSTRUCTION("41A8A15E", fcvtps(s1, s2)); + TEST_INSTRUCTION("41A8E15E", fcvtps(d1, d2)); + TEST_INSTRUCTION("41A8F90E", fcvtps(v1.h4(), v2.h4())); + TEST_INSTRUCTION("41A8A10E", fcvtps(v1.s2(), v2.s2())); + TEST_INSTRUCTION("41A8F94E", fcvtps(v1.h8(), v2.h8())); + TEST_INSTRUCTION("41A8A14E", fcvtps(v1.s4(), v2.s4())); + TEST_INSTRUCTION("41A8E14E", fcvtps(v1.d2(), v2.d2())); + TEST_INSTRUCTION("4100E91E", fcvtpu(w1, h2)); + TEST_INSTRUCTION("4100291E", fcvtpu(w1, s2)); + TEST_INSTRUCTION("4100691E", fcvtpu(w1, d2)); + TEST_INSTRUCTION("4100E99E", fcvtpu(x1, h2)); + TEST_INSTRUCTION("4100299E", fcvtpu(x1, s2)); + TEST_INSTRUCTION("4100699E", fcvtpu(x1, d2)); + TEST_INSTRUCTION("41A8F97E", fcvtpu(h1, h2)); + TEST_INSTRUCTION("41A8A17E", fcvtpu(s1, s2)); + TEST_INSTRUCTION("41A8E17E", fcvtpu(d1, d2)); + TEST_INSTRUCTION("41A8F92E", fcvtpu(v1.h4(), v2.h4())); + TEST_INSTRUCTION("41A8A12E", fcvtpu(v1.s2(), v2.s2())); + TEST_INSTRUCTION("41A8F96E", fcvtpu(v1.h8(), v2.h8())); + TEST_INSTRUCTION("41A8A16E", fcvtpu(v1.s4(), v2.s4())); + TEST_INSTRUCTION("41A8E16E", fcvtpu(v1.d2(), v2.d2())); + TEST_INSTRUCTION("2168617E", fcvtxn(s1, d1)); + TEST_INSTRUCTION("4168612E", fcvtxn(v1.s2(), v2.d2())); + TEST_INSTRUCTION("4168616E", fcvtxn2(v1.s4(), v2.d2())); + TEST_INSTRUCTION("4100F81E", fcvtzs(w1, h2)); + TEST_INSTRUCTION("4100381E", fcvtzs(w1, s2)); + TEST_INSTRUCTION("4100781E", fcvtzs(w1, d2)); + TEST_INSTRUCTION("4100F89E", fcvtzs(x1, h2)); + TEST_INSTRUCTION("4100389E", fcvtzs(x1, s2)); + TEST_INSTRUCTION("4100789E", fcvtzs(x1, d2)); + TEST_INSTRUCTION("41B8F95E", fcvtzs(h1, h2)); + TEST_INSTRUCTION("41B8A15E", fcvtzs(s1, s2)); + TEST_INSTRUCTION("41B8E15E", fcvtzs(d1, d2)); + TEST_INSTRUCTION("41B8F90E", fcvtzs(v1.h4(), v2.h4())); + TEST_INSTRUCTION("41B8A10E", fcvtzs(v1.s2(), v2.s2())); + TEST_INSTRUCTION("41B8F94E", fcvtzs(v1.h8(), v2.h8())); + TEST_INSTRUCTION("41B8A14E", fcvtzs(v1.s4(), v2.s4())); + TEST_INSTRUCTION("41B8E14E", fcvtzs(v1.d2(), v2.d2())); + TEST_INSTRUCTION("41E0D81E", fcvtzs(w1, h2, 8)); + TEST_INSTRUCTION("41E0181E", fcvtzs(w1, s2, 8)); + TEST_INSTRUCTION("41E0581E", fcvtzs(w1, d2, 8)); + TEST_INSTRUCTION("41E0D89E", fcvtzs(x1, h2, 8)); + TEST_INSTRUCTION("41E0189E", fcvtzs(x1, s2, 8)); + TEST_INSTRUCTION("41E0589E", fcvtzs(x1, d2, 8)); + TEST_INSTRUCTION("41FC185F", fcvtzs(h1, h2, 8)); + TEST_INSTRUCTION("41FC385F", fcvtzs(s1, s2, 8)); + TEST_INSTRUCTION("41FC785F", fcvtzs(d1, d2, 8)); + TEST_INSTRUCTION("41FC180F", fcvtzs(v1.h4(), v2.h4(), 8)); + TEST_INSTRUCTION("41FC380F", fcvtzs(v1.s2(), v2.s2(), 8)); + TEST_INSTRUCTION("41FC184F", fcvtzs(v1.h8(), v2.h8(), 8)); + TEST_INSTRUCTION("41FC384F", fcvtzs(v1.s4(), v2.s4(), 8)); + TEST_INSTRUCTION("41FC784F", fcvtzs(v1.d2(), v2.d2(), 8)); + TEST_INSTRUCTION("4100F91E", fcvtzu(w1, h2)); + TEST_INSTRUCTION("4100391E", fcvtzu(w1, s2)); + TEST_INSTRUCTION("4100791E", fcvtzu(w1, d2)); + TEST_INSTRUCTION("4100F99E", fcvtzu(x1, h2)); + TEST_INSTRUCTION("4100399E", fcvtzu(x1, s2)); + TEST_INSTRUCTION("4100799E", fcvtzu(x1, d2)); + TEST_INSTRUCTION("41B8F97E", fcvtzu(h1, h2)); + TEST_INSTRUCTION("41B8A17E", fcvtzu(s1, s2)); + TEST_INSTRUCTION("41B8E17E", fcvtzu(d1, d2)); + TEST_INSTRUCTION("41B8F92E", fcvtzu(v1.h4(), v2.h4())); + TEST_INSTRUCTION("41B8A12E", fcvtzu(v1.s2(), v2.s2())); + TEST_INSTRUCTION("41B8F96E", fcvtzu(v1.h8(), v2.h8())); + TEST_INSTRUCTION("41B8A16E", fcvtzu(v1.s4(), v2.s4())); + TEST_INSTRUCTION("41B8E16E", fcvtzu(v1.d2(), v2.d2())); + TEST_INSTRUCTION("41E0D91E", fcvtzu(w1, h2, 8)); + TEST_INSTRUCTION("41E0191E", fcvtzu(w1, s2, 8)); + TEST_INSTRUCTION("41E0591E", fcvtzu(w1, d2, 8)); + TEST_INSTRUCTION("41E0D99E", fcvtzu(x1, h2, 8)); + TEST_INSTRUCTION("41E0199E", fcvtzu(x1, s2, 8)); + TEST_INSTRUCTION("41E0599E", fcvtzu(x1, d2, 8)); + TEST_INSTRUCTION("41FC187F", fcvtzu(h1, h2, 8)); + TEST_INSTRUCTION("41FC387F", fcvtzu(s1, s2, 8)); + TEST_INSTRUCTION("41FC787F", fcvtzu(d1, d2, 8)); + TEST_INSTRUCTION("41FC182F", fcvtzu(v1.h4(), v2.h4(), 8)); + TEST_INSTRUCTION("41FC382F", fcvtzu(v1.s2(), v2.s2(), 8)); + TEST_INSTRUCTION("41FC186F", fcvtzu(v1.h8(), v2.h8(), 8)); + TEST_INSTRUCTION("41FC386F", fcvtzu(v1.s4(), v2.s4(), 8)); + TEST_INSTRUCTION("41FC786F", fcvtzu(v1.d2(), v2.d2(), 8)); + TEST_INSTRUCTION("4118E31E", fdiv(h1, h2, h3)); + TEST_INSTRUCTION("4118231E", fdiv(s1, s2, s3)); + TEST_INSTRUCTION("4118631E", fdiv(d1, d2, d3)); + TEST_INSTRUCTION("413C432E", fdiv(v1.h4(), v2.h4(), v3.h4())); + TEST_INSTRUCTION("41FC232E", fdiv(v1.s2(), v2.s2(), v3.s2())); + TEST_INSTRUCTION("413C436E", fdiv(v1.h8(), v2.h8(), v3.h8())); + TEST_INSTRUCTION("41FC236E", fdiv(v1.s4(), v2.s4(), v3.s4())); + TEST_INSTRUCTION("41FC636E", fdiv(v1.d2(), v2.d2(), v3.d2())); + TEST_INSTRUCTION("41007E1E", fjcvtzs(w1, d2)); + TEST_INSTRUCTION("4110C31F", fmadd(h1, h2, h3, h4)); + TEST_INSTRUCTION("4110031F", fmadd(s1, s2, s3, s4)); + TEST_INSTRUCTION("4110431F", fmadd(d1, d2, d3, d4)); + TEST_INSTRUCTION("4148E31E", fmax(h1, h2, h3)); + TEST_INSTRUCTION("4148231E", fmax(s1, s2, s3)); + TEST_INSTRUCTION("4148631E", fmax(d1, d2, d3)); + TEST_INSTRUCTION("4134430E", fmax(v1.h4(), v2.h4(), v3.h4())); + TEST_INSTRUCTION("41F4230E", fmax(v1.s2(), v2.s2(), v3.s2())); + TEST_INSTRUCTION("4134434E", fmax(v1.h8(), v2.h8(), v3.h8())); + TEST_INSTRUCTION("41F4234E", fmax(v1.s4(), v2.s4(), v3.s4())); + TEST_INSTRUCTION("41F4634E", fmax(v1.d2(), v2.d2(), v3.d2())); + TEST_INSTRUCTION("4168E31E", fmaxnm(h1, h2, h3)); + TEST_INSTRUCTION("4168231E", fmaxnm(s1, s2, s3)); + TEST_INSTRUCTION("4168631E", fmaxnm(d1, d2, d3)); + TEST_INSTRUCTION("4104430E", fmaxnm(v1.h4(), v2.h4(), v3.h4())); + TEST_INSTRUCTION("41C4230E", fmaxnm(v1.s2(), v2.s2(), v3.s2())); + TEST_INSTRUCTION("4104434E", fmaxnm(v1.h8(), v2.h8(), v3.h8())); + TEST_INSTRUCTION("41C4234E", fmaxnm(v1.s4(), v2.s4(), v3.s4())); + TEST_INSTRUCTION("41C4634E", fmaxnm(v1.d2(), v2.d2(), v3.d2())); + TEST_INSTRUCTION("41C8305E", fmaxnmp(h1, v2.h2())); + TEST_INSTRUCTION("41C8307E", fmaxnmp(s1, v2.s2())); + TEST_INSTRUCTION("41C8707E", fmaxnmp(d1, v2.d2())); + TEST_INSTRUCTION("4104432E", fmaxnmp(v1.h4(), v2.h4(), v3.h4())); + TEST_INSTRUCTION("41C4232E", fmaxnmp(v1.s2(), v2.s2(), v3.s2())); + TEST_INSTRUCTION("4104436E", fmaxnmp(v1.h8(), v2.h8(), v3.h8())); + TEST_INSTRUCTION("41C4236E", fmaxnmp(v1.s4(), v2.s4(), v3.s4())); + TEST_INSTRUCTION("41C4636E", fmaxnmp(v1.d2(), v2.d2(), v3.d2())); + TEST_INSTRUCTION("41C8300E", fmaxnmv(h1, v2.h4())); + TEST_INSTRUCTION("41C8304E", fmaxnmv(h1, v2.h8())); + TEST_INSTRUCTION("41C8306E", fmaxnmv(s1, v2.s4())); + TEST_INSTRUCTION("41F8305E", fmaxp(h1, v2.h2())); + TEST_INSTRUCTION("41F8307E", fmaxp(s1, v2.s2())); + TEST_INSTRUCTION("41F8707E", fmaxp(d1, v2.d2())); + TEST_INSTRUCTION("4134432E", fmaxp(v1.h4(), v2.h4(), v3.h4())); + TEST_INSTRUCTION("41F4232E", fmaxp(v1.s2(), v2.s2(), v3.s2())); + TEST_INSTRUCTION("4134436E", fmaxp(v1.h8(), v2.h8(), v3.h8())); + TEST_INSTRUCTION("41F4236E", fmaxp(v1.s4(), v2.s4(), v3.s4())); + TEST_INSTRUCTION("41F4636E", fmaxp(v1.d2(), v2.d2(), v3.d2())); + TEST_INSTRUCTION("41F8300E", fmaxv(h1, v2.h4())); + TEST_INSTRUCTION("41F8304E", fmaxv(h1, v2.h8())); + TEST_INSTRUCTION("41F8306E", fmaxv(s1, v2.s4())); + TEST_INSTRUCTION("4158E31E", fmin(h1, h2, h3)); + TEST_INSTRUCTION("4158231E", fmin(s1, s2, s3)); + TEST_INSTRUCTION("4158631E", fmin(d1, d2, d3)); + TEST_INSTRUCTION("4134C30E", fmin(v1.h4(), v2.h4(), v3.h4())); + TEST_INSTRUCTION("41F4A30E", fmin(v1.s2(), v2.s2(), v3.s2())); + TEST_INSTRUCTION("4134C34E", fmin(v1.h8(), v2.h8(), v3.h8())); + TEST_INSTRUCTION("41F4A34E", fmin(v1.s4(), v2.s4(), v3.s4())); + TEST_INSTRUCTION("41F4E34E", fmin(v1.d2(), v2.d2(), v3.d2())); + TEST_INSTRUCTION("4178E31E", fminnm(h1, h2, h3)); + TEST_INSTRUCTION("4178231E", fminnm(s1, s2, s3)); + TEST_INSTRUCTION("4178631E", fminnm(d1, d2, d3)); + TEST_INSTRUCTION("4104C30E", fminnm(v1.h4(), v2.h4(), v3.h4())); + TEST_INSTRUCTION("41C4A30E", fminnm(v1.s2(), v2.s2(), v3.s2())); + TEST_INSTRUCTION("4104C34E", fminnm(v1.h8(), v2.h8(), v3.h8())); + TEST_INSTRUCTION("41C4A34E", fminnm(v1.s4(), v2.s4(), v3.s4())); + TEST_INSTRUCTION("41C4E34E", fminnm(v1.d2(), v2.d2(), v3.d2())); + TEST_INSTRUCTION("41C8B05E", fminnmp(h1, v2.h2())); + TEST_INSTRUCTION("41C8B07E", fminnmp(s1, v2.s2())); + TEST_INSTRUCTION("41C8F07E", fminnmp(d1, v2.d2())); + TEST_INSTRUCTION("4104C32E", fminnmp(v1.h4(), v2.h4(), v3.h4())); + TEST_INSTRUCTION("41C4A32E", fminnmp(v1.s2(), v2.s2(), v3.s2())); + TEST_INSTRUCTION("4104C36E", fminnmp(v1.h8(), v2.h8(), v3.h8())); + TEST_INSTRUCTION("41C4A36E", fminnmp(v1.s4(), v2.s4(), v3.s4())); + TEST_INSTRUCTION("41C4E36E", fminnmp(v1.d2(), v2.d2(), v3.d2())); + TEST_INSTRUCTION("41C8B00E", fminnmv(h1, v2.h4())); + TEST_INSTRUCTION("41C8B04E", fminnmv(h1, v2.h8())); + TEST_INSTRUCTION("41C8B06E", fminnmv(s1, v2.s4())); + TEST_INSTRUCTION("41F8B05E", fminp(h1, v2.h2())); + TEST_INSTRUCTION("41F8B07E", fminp(s1, v2.s2())); + TEST_INSTRUCTION("41F8F07E", fminp(d1, v2.d2())); + TEST_INSTRUCTION("4134C32E", fminp(v1.h4(), v2.h4(), v3.h4())); + TEST_INSTRUCTION("41F4A32E", fminp(v1.s2(), v2.s2(), v3.s2())); + TEST_INSTRUCTION("4134C36E", fminp(v1.h8(), v2.h8(), v3.h8())); + TEST_INSTRUCTION("41F4A36E", fminp(v1.s4(), v2.s4(), v3.s4())); + TEST_INSTRUCTION("41F4E36E", fminp(v1.d2(), v2.d2(), v3.d2())); + TEST_INSTRUCTION("41F8B00E", fminv(h1, v2.h4())); + TEST_INSTRUCTION("41F8B04E", fminv(h1, v2.h8())); + TEST_INSTRUCTION("41F8B06E", fminv(s1, v2.s4())); + TEST_INSTRUCTION("410C430E", fmla(v1.h4(), v2.h4(), v3.h4())); + TEST_INSTRUCTION("41CC230E", fmla(v1.s2(), v2.s2(), v3.s2())); + TEST_INSTRUCTION("410C434E", fmla(v1.h8(), v2.h8(), v3.h8())); + TEST_INSTRUCTION("41CC234E", fmla(v1.s4(), v2.s4(), v3.s4())); + TEST_INSTRUCTION("41CC634E", fmla(v1.d2(), v2.d2(), v3.d2())); + TEST_INSTRUCTION("4118335F", fmla(h1, h2, v3.h(7))); + TEST_INSTRUCTION("4118A35F", fmla(s1, s2, v3.s(3))); + TEST_INSTRUCTION("4118C35F", fmla(d1, d2, v3.d(1))); + TEST_INSTRUCTION("4118330F", fmla(v1.h4(), v2.h4(), v3.h(7))); + TEST_INSTRUCTION("4118A30F", fmla(v1.s2(), v2.s2(), v3.s(3))); + TEST_INSTRUCTION("4118334F", fmla(v1.h8(), v2.h8(), v3.h(7))); + TEST_INSTRUCTION("4118A34F", fmla(v1.s4(), v2.s4(), v3.s(3))); + TEST_INSTRUCTION("4118C34F", fmla(v1.d2(), v2.d2(), v3.d(1))); + TEST_INSTRUCTION("41EC230E", fmlal(v1.s2(), v2.h2(), v3.h2())); + TEST_INSTRUCTION("41EC234E", fmlal(v1.s4(), v2.h4(), v3.h4())); + TEST_INSTRUCTION("4100830F", fmlal(v1.s2(), v2.h2(), v3.h(0))); + TEST_INSTRUCTION("4108B30F", fmlal(v1.s2(), v2.h2(), v3.h(7))); + TEST_INSTRUCTION("4100834F", fmlal(v1.s4(), v2.h4(), v3.h(0))); + TEST_INSTRUCTION("4108B34F", fmlal(v1.s4(), v2.h4(), v3.h(7))); + TEST_INSTRUCTION("41CC232E", fmlal2(v1.s2(), v2.h2(), v3.h2())); + TEST_INSTRUCTION("41CC236E", fmlal2(v1.s4(), v2.h4(), v3.h4())); + TEST_INSTRUCTION("4180832F", fmlal2(v1.s2(), v2.h2(), v3.h(0))); + TEST_INSTRUCTION("4188B32F", fmlal2(v1.s2(), v2.h2(), v3.h(7))); + TEST_INSTRUCTION("4180836F", fmlal2(v1.s4(), v2.h4(), v3.h(0))); + TEST_INSTRUCTION("4188B36F", fmlal2(v1.s4(), v2.h4(), v3.h(7))); + TEST_INSTRUCTION("410CC30E", fmls(v1.h4(), v2.h4(), v3.h4())); + TEST_INSTRUCTION("41CCA30E", fmls(v1.s2(), v2.s2(), v3.s2())); + TEST_INSTRUCTION("410CC34E", fmls(v1.h8(), v2.h8(), v3.h8())); + TEST_INSTRUCTION("41CCA34E", fmls(v1.s4(), v2.s4(), v3.s4())); + TEST_INSTRUCTION("41CCE34E", fmls(v1.d2(), v2.d2(), v3.d2())); + TEST_INSTRUCTION("4158335F", fmls(h1, h2, v3.h(7))); + TEST_INSTRUCTION("4158A35F", fmls(s1, s2, v3.s(3))); + TEST_INSTRUCTION("4158C35F", fmls(d1, d2, v3.d(1))); + TEST_INSTRUCTION("4158330F", fmls(v1.h4(), v2.h4(), v3.h(7))); + TEST_INSTRUCTION("4158A30F", fmls(v1.s2(), v2.s2(), v3.s(3))); + TEST_INSTRUCTION("4158334F", fmls(v1.h8(), v2.h8(), v3.h(7))); + TEST_INSTRUCTION("4158A34F", fmls(v1.s4(), v2.s4(), v3.s(3))); + TEST_INSTRUCTION("4158C34F", fmls(v1.d2(), v2.d2(), v3.d(1))); + TEST_INSTRUCTION("41ECA30E", fmlsl(v1.s2(), v2.h2(), v3.h2())); + TEST_INSTRUCTION("41ECA34E", fmlsl(v1.s4(), v2.h4(), v3.h4())); + TEST_INSTRUCTION("4140830F", fmlsl(v1.s2(), v2.h2(), v3.h(0))); + TEST_INSTRUCTION("4148B30F", fmlsl(v1.s2(), v2.h2(), v3.h(7))); + TEST_INSTRUCTION("4140834F", fmlsl(v1.s4(), v2.h4(), v3.h(0))); + TEST_INSTRUCTION("4148B34F", fmlsl(v1.s4(), v2.h4(), v3.h(7))); + TEST_INSTRUCTION("41CCA32E", fmlsl2(v1.s2(), v2.h2(), v3.h2())); + TEST_INSTRUCTION("41CCA36E", fmlsl2(v1.s4(), v2.h4(), v3.h4())); + TEST_INSTRUCTION("41C0832F", fmlsl2(v1.s2(), v2.h2(), v3.h(0))); + TEST_INSTRUCTION("41C8B32F", fmlsl2(v1.s2(), v2.h2(), v3.h(7))); + TEST_INSTRUCTION("41C0836F", fmlsl2(v1.s4(), v2.h4(), v3.h(0))); + TEST_INSTRUCTION("41C8B36F", fmlsl2(v1.s4(), v2.h4(), v3.h(7))); + TEST_INSTRUCTION("4100E71E", fmov(h1, w2)); + TEST_INSTRUCTION("4100E79E", fmov(h1, x2)); + TEST_INSTRUCTION("4100271E", fmov(s1, w2)); + TEST_INSTRUCTION("4100679E", fmov(d1, x2)); + TEST_INSTRUCTION("4100AF9E", fmov(v1.d(1), x2)); + TEST_INSTRUCTION("4100E61E", fmov(w1, h2)); + TEST_INSTRUCTION("4100E69E", fmov(x1, h2)); + TEST_INSTRUCTION("4100261E", fmov(w1, s2)); + TEST_INSTRUCTION("4100669E", fmov(x1, d2)); + TEST_INSTRUCTION("4100AE9E", fmov(x1, v2.d(1))); + TEST_INSTRUCTION("0110EA1E", fmov(h1, 0.25)); + TEST_INSTRUCTION("0110EC1E", fmov(h1, 0.5)); + TEST_INSTRUCTION("0110EF1E", fmov(h1, 1.5)); + TEST_INSTRUCTION("0110E01E", fmov(h1, 2.0)); + TEST_INSTRUCTION("01D0E51E", fmov(h1, 15.0)); + TEST_INSTRUCTION("01102A1E", fmov(s1, 0.25)); + TEST_INSTRUCTION("01102C1E", fmov(s1, 0.5)); + TEST_INSTRUCTION("01102F1E", fmov(s1, 1.5)); + TEST_INSTRUCTION("0110201E", fmov(s1, 2.0)); + TEST_INSTRUCTION("01D0251E", fmov(s1, 15.0)); + TEST_INSTRUCTION("01106A1E", fmov(d1, 0.25)); + TEST_INSTRUCTION("01106C1E", fmov(d1, 0.5)); + TEST_INSTRUCTION("01106F1E", fmov(d1, 1.5)); + TEST_INSTRUCTION("0110601E", fmov(d1, 2.0)); + TEST_INSTRUCTION("01D0651E", fmov(d1, 15.0)); + TEST_INSTRUCTION("01FC030F", fmov(v1.h4(), 0.5)); + TEST_INSTRUCTION("01FC000F", fmov(v1.h4(), 2.0)); + TEST_INSTRUCTION("01FC034F", fmov(v1.h8(), 0.5)); + TEST_INSTRUCTION("01FC004F", fmov(v1.h8(), 2.0)); + TEST_INSTRUCTION("01F4030F", fmov(v1.s2(), 0.5)); + TEST_INSTRUCTION("01F4000F", fmov(v1.s2(), 2.0)); + TEST_INSTRUCTION("01F4034F", fmov(v1.s4(), 0.5)); + TEST_INSTRUCTION("01F4004F", fmov(v1.s4(), 2.0)); + TEST_INSTRUCTION("01F4036F", fmov(v1.d2(), 0.5)); + TEST_INSTRUCTION("01F4006F", fmov(v1.d2(), 2.0)); + TEST_INSTRUCTION("4190C31F", fmsub(h1, h2, h3, h4)); + TEST_INSTRUCTION("4190031F", fmsub(s1, s2, s3, s4)); + TEST_INSTRUCTION("4190431F", fmsub(d1, d2, d3, d4)); + TEST_INSTRUCTION("4108E31E", fmul(h1, h2, h3)); + TEST_INSTRUCTION("4108231E", fmul(s1, s2, s3)); + TEST_INSTRUCTION("4108631E", fmul(d1, d2, d3)); + TEST_INSTRUCTION("411C432E", fmul(v1.h4(), v2.h4(), v3.h4())); + TEST_INSTRUCTION("41DC232E", fmul(v1.s2(), v2.s2(), v3.s2())); + TEST_INSTRUCTION("411C436E", fmul(v1.h8(), v2.h8(), v3.h8())); + TEST_INSTRUCTION("41DC236E", fmul(v1.s4(), v2.s4(), v3.s4())); + TEST_INSTRUCTION("41DC636E", fmul(v1.d2(), v2.d2(), v3.d2())); + TEST_INSTRUCTION("4198335F", fmul(h1, h2, v3.h(7))); + TEST_INSTRUCTION("4198A35F", fmul(s1, s2, v3.s(3))); + TEST_INSTRUCTION("4198C35F", fmul(d1, d2, v3.d(1))); + TEST_INSTRUCTION("4198330F", fmul(v1.h4(), v2.h4(), v3.h(7))); + TEST_INSTRUCTION("4198A30F", fmul(v1.s2(), v2.s2(), v3.s(3))); + TEST_INSTRUCTION("4198334F", fmul(v1.h8(), v2.h8(), v3.h(7))); + TEST_INSTRUCTION("4198A34F", fmul(v1.s4(), v2.s4(), v3.s(3))); + TEST_INSTRUCTION("4198C34F", fmul(v1.d2(), v2.d2(), v3.d(1))); + TEST_INSTRUCTION("411C435E", fmulx(h1, h2, h3)); + TEST_INSTRUCTION("41DC235E", fmulx(s1, s2, s3)); + TEST_INSTRUCTION("41DC635E", fmulx(d1, d2, d3)); + TEST_INSTRUCTION("411C430E", fmulx(v1.h4(), v2.h4(), v3.h4())); + TEST_INSTRUCTION("41DC230E", fmulx(v1.s2(), v2.s2(), v3.s2())); + TEST_INSTRUCTION("411C434E", fmulx(v1.h8(), v2.h8(), v3.h8())); + TEST_INSTRUCTION("41DC234E", fmulx(v1.s4(), v2.s4(), v3.s4())); + TEST_INSTRUCTION("41DC634E", fmulx(v1.d2(), v2.d2(), v3.d2())); + TEST_INSTRUCTION("4198337F", fmulx(h1, h2, v3.h(7))); + TEST_INSTRUCTION("4198A37F", fmulx(s1, s2, v3.s(3))); + TEST_INSTRUCTION("4198C37F", fmulx(d1, d2, v3.d(1))); + TEST_INSTRUCTION("4198332F", fmulx(v1.h4(), v2.h4(), v3.h(7))); + TEST_INSTRUCTION("4198A32F", fmulx(v1.s2(), v2.s2(), v3.s(3))); + TEST_INSTRUCTION("4198336F", fmulx(v1.h8(), v2.h8(), v3.h(7))); + TEST_INSTRUCTION("4198A36F", fmulx(v1.s4(), v2.s4(), v3.s(3))); + TEST_INSTRUCTION("4198C36F", fmulx(v1.d2(), v2.d2(), v3.d(1))); + TEST_INSTRUCTION("4140E11E", fneg(h1, h2)); + TEST_INSTRUCTION("4140211E", fneg(s1, s2)); + TEST_INSTRUCTION("4140611E", fneg(d1, d2)); + TEST_INSTRUCTION("41F8F82E", fneg(v1.h4(), v2.h4())); + TEST_INSTRUCTION("41F8A02E", fneg(v1.s2(), v2.s2())); + TEST_INSTRUCTION("41F8F86E", fneg(v1.h8(), v2.h8())); + TEST_INSTRUCTION("41F8A06E", fneg(v1.s4(), v2.s4())); + TEST_INSTRUCTION("41F8E06E", fneg(v1.d2(), v2.d2())); + TEST_INSTRUCTION("4110E31F", fnmadd(h1, h2, h3, h4)); + TEST_INSTRUCTION("4110231F", fnmadd(s1, s2, s3, s4)); + TEST_INSTRUCTION("4110631F", fnmadd(d1, d2, d3, d4)); + TEST_INSTRUCTION("4190E31F", fnmsub(h1, h2, h3, h4)); + TEST_INSTRUCTION("4190231F", fnmsub(s1, s2, s3, s4)); + TEST_INSTRUCTION("4190631F", fnmsub(d1, d2, d3, d4)); + TEST_INSTRUCTION("4188E31E", fnmul(h1, h2, h3)); + TEST_INSTRUCTION("4188231E", fnmul(s1, s2, s3)); + TEST_INSTRUCTION("4188631E", fnmul(d1, d2, d3)); + TEST_INSTRUCTION("41D8F95E", frecpe(h1, h2)); + TEST_INSTRUCTION("41D8A15E", frecpe(s1, s2)); + TEST_INSTRUCTION("41D8E15E", frecpe(d1, d2)); + TEST_INSTRUCTION("41D8F90E", frecpe(v1.h4(), v2.h4())); + TEST_INSTRUCTION("41D8A10E", frecpe(v1.s2(), v2.s2())); + TEST_INSTRUCTION("41D8F94E", frecpe(v1.h8(), v2.h8())); + TEST_INSTRUCTION("41D8A14E", frecpe(v1.s4(), v2.s4())); + TEST_INSTRUCTION("41D8E14E", frecpe(v1.d2(), v2.d2())); + TEST_INSTRUCTION("413C435E", frecps(h1, h2, h3)); + TEST_INSTRUCTION("41FC235E", frecps(s1, s2, s3)); + TEST_INSTRUCTION("41FC635E", frecps(d1, d2, d3)); + TEST_INSTRUCTION("413C430E", frecps(v1.h4(), v2.h4(), v3.h4())); + TEST_INSTRUCTION("41FC230E", frecps(v1.s2(), v2.s2(), v3.s2())); + TEST_INSTRUCTION("413C434E", frecps(v1.h8(), v2.h8(), v3.h8())); + TEST_INSTRUCTION("41FC234E", frecps(v1.s4(), v2.s4(), v3.s4())); + TEST_INSTRUCTION("41FC634E", frecps(v1.d2(), v2.d2(), v3.d2())); + TEST_INSTRUCTION("41F8F95E", frecpx(h1, h2)); + TEST_INSTRUCTION("41F8A15E", frecpx(s1, s2)); + TEST_INSTRUCTION("41F8E15E", frecpx(d1, d2)); + TEST_INSTRUCTION("41C0281E", frint32x(s1, s2)); + TEST_INSTRUCTION("41C0681E", frint32x(d1, d2)); + TEST_INSTRUCTION("41E8212E", frint32x(v1.s2(), v2.s2())); + TEST_INSTRUCTION("41E8216E", frint32x(v1.s4(), v2.s4())); + TEST_INSTRUCTION("41E8616E", frint32x(v1.d2(), v2.d2())); + TEST_INSTRUCTION("4140281E", frint32z(s1, s2)); + TEST_INSTRUCTION("4140681E", frint32z(d1, d2)); + TEST_INSTRUCTION("41E8210E", frint32z(v1.s2(), v2.s2())); + TEST_INSTRUCTION("41E8214E", frint32z(v1.s4(), v2.s4())); + TEST_INSTRUCTION("41E8614E", frint32z(v1.d2(), v2.d2())); + TEST_INSTRUCTION("41C0291E", frint64x(s1, s2)); + TEST_INSTRUCTION("41C0691E", frint64x(d1, d2)); + TEST_INSTRUCTION("41F8212E", frint64x(v1.s2(), v2.s2())); + TEST_INSTRUCTION("41F8216E", frint64x(v1.s4(), v2.s4())); + TEST_INSTRUCTION("41F8616E", frint64x(v1.d2(), v2.d2())); + TEST_INSTRUCTION("4140291E", frint64z(s1, s2)); + TEST_INSTRUCTION("4140691E", frint64z(d1, d2)); + TEST_INSTRUCTION("41F8210E", frint64z(v1.s2(), v2.s2())); + TEST_INSTRUCTION("41F8214E", frint64z(v1.s4(), v2.s4())); + TEST_INSTRUCTION("41F8614E", frint64z(v1.d2(), v2.d2())); + TEST_INSTRUCTION("4140E61E", frinta(h1, h2)); + TEST_INSTRUCTION("4140261E", frinta(s1, s2)); + TEST_INSTRUCTION("4140661E", frinta(d1, d2)); + TEST_INSTRUCTION("4188792E", frinta(v1.h4(), v2.h4())); + TEST_INSTRUCTION("4188212E", frinta(v1.s2(), v2.s2())); + TEST_INSTRUCTION("4188796E", frinta(v1.h8(), v2.h8())); + TEST_INSTRUCTION("4188216E", frinta(v1.s4(), v2.s4())); + TEST_INSTRUCTION("4188616E", frinta(v1.d2(), v2.d2())); + TEST_INSTRUCTION("41C0E71E", frinti(h1, h2)); + TEST_INSTRUCTION("41C0271E", frinti(s1, s2)); + TEST_INSTRUCTION("41C0671E", frinti(d1, d2)); + TEST_INSTRUCTION("4198F92E", frinti(v1.h4(), v2.h4())); + TEST_INSTRUCTION("4198A12E", frinti(v1.s2(), v2.s2())); + TEST_INSTRUCTION("4198F96E", frinti(v1.h8(), v2.h8())); + TEST_INSTRUCTION("4198A16E", frinti(v1.s4(), v2.s4())); + TEST_INSTRUCTION("4198E16E", frinti(v1.d2(), v2.d2())); + TEST_INSTRUCTION("4140E51E", frintm(h1, h2)); + TEST_INSTRUCTION("4140251E", frintm(s1, s2)); + TEST_INSTRUCTION("4140651E", frintm(d1, d2)); + TEST_INSTRUCTION("4198790E", frintm(v1.h4(), v2.h4())); + TEST_INSTRUCTION("4198210E", frintm(v1.s2(), v2.s2())); + TEST_INSTRUCTION("4198794E", frintm(v1.h8(), v2.h8())); + TEST_INSTRUCTION("4198214E", frintm(v1.s4(), v2.s4())); + TEST_INSTRUCTION("4198614E", frintm(v1.d2(), v2.d2())); + TEST_INSTRUCTION("4140E41E", frintn(h1, h2)); + TEST_INSTRUCTION("4140241E", frintn(s1, s2)); + TEST_INSTRUCTION("4140641E", frintn(d1, d2)); + TEST_INSTRUCTION("4188790E", frintn(v1.h4(), v2.h4())); + TEST_INSTRUCTION("4188210E", frintn(v1.s2(), v2.s2())); + TEST_INSTRUCTION("4188794E", frintn(v1.h8(), v2.h8())); + TEST_INSTRUCTION("4188214E", frintn(v1.s4(), v2.s4())); + TEST_INSTRUCTION("4188614E", frintn(v1.d2(), v2.d2())); + TEST_INSTRUCTION("41C0E41E", frintp(h1, h2)); + TEST_INSTRUCTION("41C0241E", frintp(s1, s2)); + TEST_INSTRUCTION("41C0641E", frintp(d1, d2)); + TEST_INSTRUCTION("4188F90E", frintp(v1.h4(), v2.h4())); + TEST_INSTRUCTION("4188A10E", frintp(v1.s2(), v2.s2())); + TEST_INSTRUCTION("4188F94E", frintp(v1.h8(), v2.h8())); + TEST_INSTRUCTION("4188A14E", frintp(v1.s4(), v2.s4())); + TEST_INSTRUCTION("4188E14E", frintp(v1.d2(), v2.d2())); + TEST_INSTRUCTION("4140E71E", frintx(h1, h2)); + TEST_INSTRUCTION("4140271E", frintx(s1, s2)); + TEST_INSTRUCTION("4140671E", frintx(d1, d2)); + TEST_INSTRUCTION("4198792E", frintx(v1.h4(), v2.h4())); + TEST_INSTRUCTION("4198212E", frintx(v1.s2(), v2.s2())); + TEST_INSTRUCTION("4198796E", frintx(v1.h8(), v2.h8())); + TEST_INSTRUCTION("4198216E", frintx(v1.s4(), v2.s4())); + TEST_INSTRUCTION("4198616E", frintx(v1.d2(), v2.d2())); + TEST_INSTRUCTION("41C0E51E", frintz(h1, h2)); + TEST_INSTRUCTION("41C0251E", frintz(s1, s2)); + TEST_INSTRUCTION("41C0651E", frintz(d1, d2)); + TEST_INSTRUCTION("4198F90E", frintz(v1.h4(), v2.h4())); + TEST_INSTRUCTION("4198A10E", frintz(v1.s2(), v2.s2())); + TEST_INSTRUCTION("4198F94E", frintz(v1.h8(), v2.h8())); + TEST_INSTRUCTION("4198A14E", frintz(v1.s4(), v2.s4())); + TEST_INSTRUCTION("4198E14E", frintz(v1.d2(), v2.d2())); + TEST_INSTRUCTION("41D8F97E", frsqrte(h1, h2)); + TEST_INSTRUCTION("41D8A17E", frsqrte(s1, s2)); + TEST_INSTRUCTION("41D8E17E", frsqrte(d1, d2)); + TEST_INSTRUCTION("41D8F92E", frsqrte(v1.h4(), v2.h4())); + TEST_INSTRUCTION("41D8A12E", frsqrte(v1.s2(), v2.s2())); + TEST_INSTRUCTION("41D8F96E", frsqrte(v1.h8(), v2.h8())); + TEST_INSTRUCTION("41D8A16E", frsqrte(v1.s4(), v2.s4())); + TEST_INSTRUCTION("41D8E16E", frsqrte(v1.d2(), v2.d2())); + TEST_INSTRUCTION("413CC35E", frsqrts(h1, h2, h3)); + TEST_INSTRUCTION("41FCA35E", frsqrts(s1, s2, s3)); + TEST_INSTRUCTION("41FCE35E", frsqrts(d1, d2, d3)); + TEST_INSTRUCTION("413CC30E", frsqrts(v1.h4(), v2.h4(), v3.h4())); + TEST_INSTRUCTION("41FCA30E", frsqrts(v1.s2(), v2.s2(), v3.s2())); + TEST_INSTRUCTION("413CC34E", frsqrts(v1.h8(), v2.h8(), v3.h8())); + TEST_INSTRUCTION("41FCA34E", frsqrts(v1.s4(), v2.s4(), v3.s4())); + TEST_INSTRUCTION("41FCE34E", frsqrts(v1.d2(), v2.d2(), v3.d2())); + TEST_INSTRUCTION("41C0E11E", fsqrt(h1, h2)); + TEST_INSTRUCTION("41C0211E", fsqrt(s1, s2)); + TEST_INSTRUCTION("41C0611E", fsqrt(d1, d2)); + TEST_INSTRUCTION("41F8F92E", fsqrt(v1.h4(), v2.h4())); + TEST_INSTRUCTION("41F8A12E", fsqrt(v1.s2(), v2.s2())); + TEST_INSTRUCTION("41F8F96E", fsqrt(v1.h8(), v2.h8())); + TEST_INSTRUCTION("41F8A16E", fsqrt(v1.s4(), v2.s4())); + TEST_INSTRUCTION("41F8E16E", fsqrt(v1.d2(), v2.d2())); + TEST_INSTRUCTION("4138E31E", fsub(h1, h2, h3)); + TEST_INSTRUCTION("4138231E", fsub(s1, s2, s3)); + TEST_INSTRUCTION("4138631E", fsub(d1, d2, d3)); + TEST_INSTRUCTION("4114C30E", fsub(v1.h4(), v2.h4(), v3.h4())); + TEST_INSTRUCTION("41D4A30E", fsub(v1.s2(), v2.s2(), v3.s2())); + TEST_INSTRUCTION("4114C34E", fsub(v1.h8(), v2.h8(), v3.h8())); + TEST_INSTRUCTION("41D4A34E", fsub(v1.s4(), v2.s4(), v3.s4())); + TEST_INSTRUCTION("41D4E34E", fsub(v1.d2(), v2.d2(), v3.d2())); + TEST_INSTRUCTION("411C014E", ins(v1.b(0), w2)); + TEST_INSTRUCTION("411C074E", ins(v1.b(3), w2)); + TEST_INSTRUCTION("411C0D4E", ins(v1.b(6), w2)); + TEST_INSTRUCTION("411C134E", ins(v1.b(9), w2)); + TEST_INSTRUCTION("411C1F4E", ins(v1.b(15), w2)); + TEST_INSTRUCTION("411C024E", ins(v1.h(0), w2)); + TEST_INSTRUCTION("411C0E4E", ins(v1.h(3), w2)); + TEST_INSTRUCTION("411C1E4E", ins(v1.h(7), w2)); + TEST_INSTRUCTION("411C044E", ins(v1.s(0), w2)); + TEST_INSTRUCTION("411C0C4E", ins(v1.s(1), w2)); + TEST_INSTRUCTION("411C144E", ins(v1.s(2), w2)); + TEST_INSTRUCTION("411C1C4E", ins(v1.s(3), w2)); + TEST_INSTRUCTION("411C084E", ins(v1.d(0), x2)); + TEST_INSTRUCTION("411C184E", ins(v1.d(1), x2)); + TEST_INSTRUCTION("417C016E", ins(v1.b(0), v2.b(15))); + TEST_INSTRUCTION("4174036E", ins(v1.b(1), v2.b(14))); + TEST_INSTRUCTION("4174026E", ins(v1.h(0), v2.h(7))); + TEST_INSTRUCTION("4164066E", ins(v1.h(1), v2.h(6))); + TEST_INSTRUCTION("4164046E", ins(v1.s(0), v2.s(3))); + TEST_INSTRUCTION("41440C6E", ins(v1.s(1), v2.s(2))); + TEST_INSTRUCTION("4144086E", ins(v1.d(0), v2.d(1))); + TEST_INSTRUCTION("4104186E", ins(v1.d(1), v2.d(0))); + TEST_INSTRUCTION("4100400D", ld1(v1.b(0), ptr(x2))); + TEST_INSTRUCTION("4100DF0D", ld1(v1.b(0), ptr_post(x2, 1))); + TEST_INSTRUCTION("4100CB0D", ld1(v1.b(0), ptr_post(x2, x11))); + TEST_INSTRUCTION("4140400D", ld1(v1.h(0), ptr(x2))); + TEST_INSTRUCTION("4140DF0D", ld1(v1.h(0), ptr_post(x2, 2))); + TEST_INSTRUCTION("4140CB0D", ld1(v1.h(0), ptr_post(x2, x11))); + TEST_INSTRUCTION("4180400D", ld1(v1.s(0), ptr(x2))); + TEST_INSTRUCTION("4180DF0D", ld1(v1.s(0), ptr_post(x2, 4))); + TEST_INSTRUCTION("4180CB0D", ld1(v1.s(0), ptr_post(x2, x11))); + TEST_INSTRUCTION("4184400D", ld1(v1.d(0), ptr(x2))); + TEST_INSTRUCTION("4184DF0D", ld1(v1.d(0), ptr_post(x2, 8))); + TEST_INSTRUCTION("4184CB0D", ld1(v1.d(0), ptr_post(x2, x11))); + TEST_INSTRUCTION("411C404D", ld1(v1.b(15), ptr(x2))); + TEST_INSTRUCTION("411CDF4D", ld1(v1.b(15), ptr_post(x2, 1))); + TEST_INSTRUCTION("411CCB4D", ld1(v1.b(15), ptr_post(x2, x11))); + TEST_INSTRUCTION("4158404D", ld1(v1.h(7), ptr(x2))); + TEST_INSTRUCTION("4158DF4D", ld1(v1.h(7), ptr_post(x2, 2))); + TEST_INSTRUCTION("4158CB4D", ld1(v1.h(7), ptr_post(x2, x11))); + TEST_INSTRUCTION("4190404D", ld1(v1.s(3), ptr(x2))); + TEST_INSTRUCTION("4190DF4D", ld1(v1.s(3), ptr_post(x2, 4))); + TEST_INSTRUCTION("4190CB4D", ld1(v1.s(3), ptr_post(x2, x11))); + TEST_INSTRUCTION("4184404D", ld1(v1.d(1), ptr(x2))); + TEST_INSTRUCTION("4184DF4D", ld1(v1.d(1), ptr_post(x2, 8))); + TEST_INSTRUCTION("4184CB4D", ld1(v1.d(1), ptr_post(x2, x11))); + TEST_INSTRUCTION("4170400C", ld1(v1.b8(), ptr(x2))); + TEST_INSTRUCTION("4170DF0C", ld1(v1.b8(), ptr_post(x2, 8))); + TEST_INSTRUCTION("4170404C", ld1(v1.b16(), ptr(x2))); + TEST_INSTRUCTION("4170DF4C", ld1(v1.b16(), ptr_post(x2, 16))); + TEST_INSTRUCTION("61A0400C", ld1(v1.b8(), v2.b8(), ptr(x3))); + TEST_INSTRUCTION("61A0DF0C", ld1(v1.b8(), v2.b8(), ptr_post(x3, 16))); + TEST_INSTRUCTION("61A0404C", ld1(v1.b16(), v2.b16(), ptr(x3))); + TEST_INSTRUCTION("61A0DF4C", ld1(v1.b16(), v2.b16(), ptr_post(x3, 32))); + TEST_INSTRUCTION("8160400C", ld1(v1.b8(), v2.b8(), v3.b8(), ptr(x4))); + TEST_INSTRUCTION("8160DF0C", ld1(v1.b8(), v2.b8(), v3.b8(), ptr_post(x4, 24))); + TEST_INSTRUCTION("8160404C", ld1(v1.b16(), v2.b16(), v3.b16(), ptr(x4))); + TEST_INSTRUCTION("8160DF4C", ld1(v1.b16(), v2.b16(), v3.b16(), ptr_post(x4, 48))); + TEST_INSTRUCTION("A120400C", ld1(v1.b8(), v2.b8(), v3.b8(), v4.b8(), ptr(x5))); + TEST_INSTRUCTION("A120DF0C", ld1(v1.b8(), v2.b8(), v3.b8(), v4.b8(), ptr_post(x5, 32))); + TEST_INSTRUCTION("A120404C", ld1(v1.b16(), v2.b16(), v3.b16(), v4.b16(), ptr(x5))); + TEST_INSTRUCTION("A120DF4C", ld1(v1.b16(), v2.b16(), v3.b16(), v4.b16(), ptr_post(x5, 64))); + TEST_INSTRUCTION("4174400C", ld1(v1.h4(), ptr(x2))); + TEST_INSTRUCTION("4174DF0C", ld1(v1.h4(), ptr_post(x2, 8))); + TEST_INSTRUCTION("4174404C", ld1(v1.h8(), ptr(x2))); + TEST_INSTRUCTION("4174DF4C", ld1(v1.h8(), ptr_post(x2, 16))); + TEST_INSTRUCTION("61A4400C", ld1(v1.h4(), v2.h4(), ptr(x3))); + TEST_INSTRUCTION("61A4DF0C", ld1(v1.h4(), v2.h4(), ptr_post(x3, 16))); + TEST_INSTRUCTION("61A4404C", ld1(v1.h8(), v2.h8(), ptr(x3))); + TEST_INSTRUCTION("61A4DF4C", ld1(v1.h8(), v2.h8(), ptr_post(x3, 32))); + TEST_INSTRUCTION("8164400C", ld1(v1.h4(), v2.h4(), v3.h4(), ptr(x4))); + TEST_INSTRUCTION("8164DF0C", ld1(v1.h4(), v2.h4(), v3.h4(), ptr_post(x4, 24))); + TEST_INSTRUCTION("8164404C", ld1(v1.h8(), v2.h8(), v3.h8(), ptr(x4))); + TEST_INSTRUCTION("8164DF4C", ld1(v1.h8(), v2.h8(), v3.h8(), ptr_post(x4, 48))); + TEST_INSTRUCTION("A124400C", ld1(v1.h4(), v2.h4(), v3.h4(), v4.h4(), ptr(x5))); + TEST_INSTRUCTION("A124DF0C", ld1(v1.h4(), v2.h4(), v3.h4(), v4.h4(), ptr_post(x5, 32))); + TEST_INSTRUCTION("A124404C", ld1(v1.h8(), v2.h8(), v3.h8(), v4.h8(), ptr(x5))); + TEST_INSTRUCTION("A124DF4C", ld1(v1.h8(), v2.h8(), v3.h8(), v4.h8(), ptr_post(x5, 64))); + TEST_INSTRUCTION("4178400C", ld1(v1.s2(), ptr(x2))); + TEST_INSTRUCTION("4178DF0C", ld1(v1.s2(), ptr_post(x2, 8))); + TEST_INSTRUCTION("4178404C", ld1(v1.s4(), ptr(x2))); + TEST_INSTRUCTION("4178DF4C", ld1(v1.s4(), ptr_post(x2, 16))); + TEST_INSTRUCTION("61A8400C", ld1(v1.s2(), v2.s2(), ptr(x3))); + TEST_INSTRUCTION("61A8DF0C", ld1(v1.s2(), v2.s2(), ptr_post(x3, 16))); + TEST_INSTRUCTION("61A8404C", ld1(v1.s4(), v2.s4(), ptr(x3))); + TEST_INSTRUCTION("61A8DF4C", ld1(v1.s4(), v2.s4(), ptr_post(x3, 32))); + TEST_INSTRUCTION("8168400C", ld1(v1.s2(), v2.s2(), v3.s2(), ptr(x4))); + TEST_INSTRUCTION("8168DF0C", ld1(v1.s2(), v2.s2(), v3.s2(), ptr_post(x4, 24))); + TEST_INSTRUCTION("8168404C", ld1(v1.s4(), v2.s4(), v3.s4(), ptr(x4))); + TEST_INSTRUCTION("8168DF4C", ld1(v1.s4(), v2.s4(), v3.s4(), ptr_post(x4, 48))); + TEST_INSTRUCTION("A128400C", ld1(v1.s2(), v2.s2(), v3.s2(), v4.s2(), ptr(x5))); + TEST_INSTRUCTION("A128DF0C", ld1(v1.s2(), v2.s2(), v3.s2(), v4.s2(), ptr_post(x5, 32))); + TEST_INSTRUCTION("A128404C", ld1(v1.s4(), v2.s4(), v3.s4(), v4.s4(), ptr(x5))); + TEST_INSTRUCTION("A128DF4C", ld1(v1.s4(), v2.s4(), v3.s4(), v4.s4(), ptr_post(x5, 64))); + TEST_INSTRUCTION("417C404C", ld1(v1.d2(), ptr(x2))); + TEST_INSTRUCTION("417CDF4C", ld1(v1.d2(), ptr_post(x2, 16))); + TEST_INSTRUCTION("61AC404C", ld1(v1.d2(), v2.d2(), ptr(x3))); + TEST_INSTRUCTION("61ACDF4C", ld1(v1.d2(), v2.d2(), ptr_post(x3, 32))); + TEST_INSTRUCTION("816C404C", ld1(v1.d2(), v2.d2(), v3.d2(), ptr(x4))); + TEST_INSTRUCTION("816CDF4C", ld1(v1.d2(), v2.d2(), v3.d2(), ptr_post(x4, 48))); + TEST_INSTRUCTION("A12C404C", ld1(v1.d2(), v2.d2(), v3.d2(), v4.d2(), ptr(x5))); + TEST_INSTRUCTION("A12CDF4C", ld1(v1.d2(), v2.d2(), v3.d2(), v4.d2(), ptr_post(x5, 64))); + TEST_INSTRUCTION("41C0400D", ld1r(v1.b8(), ptr(x2))); + TEST_INSTRUCTION("41C0DF0D", ld1r(v1.b8(), ptr_post(x2, 1))); + TEST_INSTRUCTION("41C0CB0D", ld1r(v1.b8(), ptr_post(x2, x11))); + TEST_INSTRUCTION("41C0404D", ld1r(v1.b16(), ptr(x2))); + TEST_INSTRUCTION("41C0DF4D", ld1r(v1.b16(), ptr_post(x2, 1))); + TEST_INSTRUCTION("41C0CB4D", ld1r(v1.b16(), ptr_post(x2, x11))); + TEST_INSTRUCTION("41C4400D", ld1r(v1.h4(), ptr(x2))); + TEST_INSTRUCTION("41C4DF0D", ld1r(v1.h4(), ptr_post(x2, 2))); + TEST_INSTRUCTION("41C4CB0D", ld1r(v1.h4(), ptr_post(x2, x11))); + TEST_INSTRUCTION("41C4404D", ld1r(v1.h8(), ptr(x2))); + TEST_INSTRUCTION("41C4DF4D", ld1r(v1.h8(), ptr_post(x2, 2))); + TEST_INSTRUCTION("41C4CB4D", ld1r(v1.h8(), ptr_post(x2, x11))); + TEST_INSTRUCTION("41C8400D", ld1r(v1.s2(), ptr(x2))); + TEST_INSTRUCTION("41C8DF0D", ld1r(v1.s2(), ptr_post(x2, 4))); + TEST_INSTRUCTION("41C8CB0D", ld1r(v1.s2(), ptr_post(x2, x11))); + TEST_INSTRUCTION("41C8404D", ld1r(v1.s4(), ptr(x2))); + TEST_INSTRUCTION("41C8DF4D", ld1r(v1.s4(), ptr_post(x2, 4))); + TEST_INSTRUCTION("41C8CB4D", ld1r(v1.s4(), ptr_post(x2, x11))); + TEST_INSTRUCTION("41CC404D", ld1r(v1.d2(), ptr(x2))); + TEST_INSTRUCTION("41CCDF4D", ld1r(v1.d2(), ptr_post(x2, 8))); + TEST_INSTRUCTION("41CCCB4D", ld1r(v1.d2(), ptr_post(x2, x11))); + TEST_INSTRUCTION("6100600D", ld2(v1.b(0), v2.b(0), ptr(x3))); + TEST_INSTRUCTION("6100FF0D", ld2(v1.b(0), v2.b(0), ptr_post(x3, 2))); + TEST_INSTRUCTION("6100EB0D", ld2(v1.b(0), v2.b(0), ptr_post(x3, x11))); + TEST_INSTRUCTION("6140600D", ld2(v1.h(0), v2.h(0), ptr(x3))); + TEST_INSTRUCTION("6140FF0D", ld2(v1.h(0), v2.h(0), ptr_post(x3, 4))); + TEST_INSTRUCTION("6140EB0D", ld2(v1.h(0), v2.h(0), ptr_post(x3, x11))); + TEST_INSTRUCTION("6180600D", ld2(v1.s(0), v2.s(0), ptr(x3))); + TEST_INSTRUCTION("6180FF0D", ld2(v1.s(0), v2.s(0), ptr_post(x3, 8))); + TEST_INSTRUCTION("6180EB0D", ld2(v1.s(0), v2.s(0), ptr_post(x3, x11))); + TEST_INSTRUCTION("6184600D", ld2(v1.d(0), v2.d(0), ptr(x3))); + TEST_INSTRUCTION("6184FF0D", ld2(v1.d(0), v2.d(0), ptr_post(x3, 16))); + TEST_INSTRUCTION("6184EB0D", ld2(v1.d(0), v2.d(0), ptr_post(x3, x11))); + TEST_INSTRUCTION("611C604D", ld2(v1.b(15), v2.b(15), ptr(x3))); + TEST_INSTRUCTION("611CFF4D", ld2(v1.b(15), v2.b(15), ptr_post(x3, 2))); + TEST_INSTRUCTION("611CEB4D", ld2(v1.b(15), v2.b(15), ptr_post(x3, x11))); + TEST_INSTRUCTION("6158604D", ld2(v1.h(7), v2.h(7), ptr(x3))); + TEST_INSTRUCTION("6158FF4D", ld2(v1.h(7), v2.h(7), ptr_post(x3, 4))); + TEST_INSTRUCTION("6158EB4D", ld2(v1.h(7), v2.h(7), ptr_post(x3, x11))); + TEST_INSTRUCTION("6190604D", ld2(v1.s(3), v2.s(3), ptr(x3))); + TEST_INSTRUCTION("6190FF4D", ld2(v1.s(3), v2.s(3), ptr_post(x3, 8))); + TEST_INSTRUCTION("6190EB4D", ld2(v1.s(3), v2.s(3), ptr_post(x3, x11))); + TEST_INSTRUCTION("6184604D", ld2(v1.d(1), v2.d(1), ptr(x3))); + TEST_INSTRUCTION("6184FF4D", ld2(v1.d(1), v2.d(1), ptr_post(x3, 16))); + TEST_INSTRUCTION("6184EB4D", ld2(v1.d(1), v2.d(1), ptr_post(x3, x11))); + TEST_INSTRUCTION("6180400C", ld2(v1.b8(), v2.b8(), ptr(x3))); + TEST_INSTRUCTION("6180DF0C", ld2(v1.b8(), v2.b8(), ptr_post(x3, 16))); + TEST_INSTRUCTION("6180CB0C", ld2(v1.b8(), v2.b8(), ptr_post(x3, x11))); + TEST_INSTRUCTION("6180404C", ld2(v1.b16(), v2.b16(), ptr(x3))); + TEST_INSTRUCTION("6180DF4C", ld2(v1.b16(), v2.b16(), ptr_post(x3, 32))); + TEST_INSTRUCTION("6180CB4C", ld2(v1.b16(), v2.b16(), ptr_post(x3, x11))); + TEST_INSTRUCTION("6184400C", ld2(v1.h4(), v2.h4(), ptr(x3))); + TEST_INSTRUCTION("6184DF0C", ld2(v1.h4(), v2.h4(), ptr_post(x3, 16))); + TEST_INSTRUCTION("6184CB0C", ld2(v1.h4(), v2.h4(), ptr_post(x3, x11))); + TEST_INSTRUCTION("6184404C", ld2(v1.h8(), v2.h8(), ptr(x3))); + TEST_INSTRUCTION("6184DF4C", ld2(v1.h8(), v2.h8(), ptr_post(x3, 32))); + TEST_INSTRUCTION("6184CB4C", ld2(v1.h8(), v2.h8(), ptr_post(x3, x11))); + TEST_INSTRUCTION("6188400C", ld2(v1.s2(), v2.s2(), ptr(x3))); + TEST_INSTRUCTION("6188DF0C", ld2(v1.s2(), v2.s2(), ptr_post(x3, 16))); + TEST_INSTRUCTION("6188CB0C", ld2(v1.s2(), v2.s2(), ptr_post(x3, x11))); + TEST_INSTRUCTION("6188404C", ld2(v1.s4(), v2.s4(), ptr(x3))); + TEST_INSTRUCTION("6188DF4C", ld2(v1.s4(), v2.s4(), ptr_post(x3, 32))); + TEST_INSTRUCTION("6188CB4C", ld2(v1.s4(), v2.s4(), ptr_post(x3, x11))); + TEST_INSTRUCTION("618C404C", ld2(v1.d2(), v2.d2(), ptr(x3))); + TEST_INSTRUCTION("618CDF4C", ld2(v1.d2(), v2.d2(), ptr_post(x3, 32))); + TEST_INSTRUCTION("618CCB4C", ld2(v1.d2(), v2.d2(), ptr_post(x3, x11))); + TEST_INSTRUCTION("61C0600D", ld2r(v1.b8(), v2.b8(), ptr(x3))); + TEST_INSTRUCTION("61C0FF0D", ld2r(v1.b8(), v2.b8(), ptr_post(x3, 2))); + TEST_INSTRUCTION("61C0EB0D", ld2r(v1.b8(), v2.b8(), ptr_post(x3, x11))); + TEST_INSTRUCTION("61C0604D", ld2r(v1.b16(), v2.b16(), ptr(x3))); + TEST_INSTRUCTION("61C0FF4D", ld2r(v1.b16(), v2.b16(), ptr_post(x3, 2))); + TEST_INSTRUCTION("61C0EB4D", ld2r(v1.b16(), v2.b16(), ptr_post(x3, x11))); + TEST_INSTRUCTION("61C4600D", ld2r(v1.h4(), v2.h4(), ptr(x3))); + TEST_INSTRUCTION("61C4FF0D", ld2r(v1.h4(), v2.h4(), ptr_post(x3, 4))); + TEST_INSTRUCTION("61C4EB0D", ld2r(v1.h4(), v2.h4(), ptr_post(x3, x11))); + TEST_INSTRUCTION("61C4604D", ld2r(v1.h8(), v2.h8(), ptr(x3))); + TEST_INSTRUCTION("61C4FF4D", ld2r(v1.h8(), v2.h8(), ptr_post(x3, 4))); + TEST_INSTRUCTION("61C4EB4D", ld2r(v1.h8(), v2.h8(), ptr_post(x3, x11))); + TEST_INSTRUCTION("61C8600D", ld2r(v1.s2(), v2.s2(), ptr(x3))); + TEST_INSTRUCTION("61C8FF0D", ld2r(v1.s2(), v2.s2(), ptr_post(x3, 8))); + TEST_INSTRUCTION("61C8EB0D", ld2r(v1.s2(), v2.s2(), ptr_post(x3, x11))); + TEST_INSTRUCTION("61C8604D", ld2r(v1.s4(), v2.s4(), ptr(x3))); + TEST_INSTRUCTION("61C8FF4D", ld2r(v1.s4(), v2.s4(), ptr_post(x3, 8))); + TEST_INSTRUCTION("61C8EB4D", ld2r(v1.s4(), v2.s4(), ptr_post(x3, x11))); + TEST_INSTRUCTION("61CC604D", ld2r(v1.d2(), v2.d2(), ptr(x3))); + TEST_INSTRUCTION("61CCFF4D", ld2r(v1.d2(), v2.d2(), ptr_post(x3, 16))); + TEST_INSTRUCTION("61CCEB4D", ld2r(v1.d2(), v2.d2(), ptr_post(x3, x11))); + TEST_INSTRUCTION("8120400D", ld3(v1.b(0), v2.b(0), v3.b(0), ptr(x4))); + TEST_INSTRUCTION("8120DF0D", ld3(v1.b(0), v2.b(0), v3.b(0), ptr_post(x4, 3))); + TEST_INSTRUCTION("8120CB0D", ld3(v1.b(0), v2.b(0), v3.b(0), ptr_post(x4, x11))); + TEST_INSTRUCTION("8160400D", ld3(v1.h(0), v2.h(0), v3.h(0), ptr(x4))); + TEST_INSTRUCTION("8160DF0D", ld3(v1.h(0), v2.h(0), v3.h(0), ptr_post(x4, 6))); + TEST_INSTRUCTION("8160CB0D", ld3(v1.h(0), v2.h(0), v3.h(0), ptr_post(x4, x11))); + TEST_INSTRUCTION("81A0400D", ld3(v1.s(0), v2.s(0), v3.s(0), ptr(x4))); + TEST_INSTRUCTION("81A0DF0D", ld3(v1.s(0), v2.s(0), v3.s(0), ptr_post(x4, 12))); + TEST_INSTRUCTION("81A0CB0D", ld3(v1.s(0), v2.s(0), v3.s(0), ptr_post(x4, x11))); + TEST_INSTRUCTION("81A4400D", ld3(v1.d(0), v2.d(0), v3.d(0), ptr(x4))); + TEST_INSTRUCTION("81A4DF0D", ld3(v1.d(0), v2.d(0), v3.d(0), ptr_post(x4, 24))); + TEST_INSTRUCTION("81A4CB0D", ld3(v1.d(0), v2.d(0), v3.d(0), ptr_post(x4, x11))); + TEST_INSTRUCTION("813C404D", ld3(v1.b(15), v2.b(15), v3.b(15), ptr(x4))); + TEST_INSTRUCTION("813CDF4D", ld3(v1.b(15), v2.b(15), v3.b(15), ptr_post(x4, 3))); + TEST_INSTRUCTION("813CCB4D", ld3(v1.b(15), v2.b(15), v3.b(15), ptr_post(x4, x11))); + TEST_INSTRUCTION("8178404D", ld3(v1.h(7), v2.h(7), v3.h(7), ptr(x4))); + TEST_INSTRUCTION("8178DF4D", ld3(v1.h(7), v2.h(7), v3.h(7), ptr_post(x4, 6))); + TEST_INSTRUCTION("8178CB4D", ld3(v1.h(7), v2.h(7), v3.h(7), ptr_post(x4, x11))); + TEST_INSTRUCTION("81B0404D", ld3(v1.s(3), v2.s(3), v3.s(3), ptr(x4))); + TEST_INSTRUCTION("81B0DF4D", ld3(v1.s(3), v2.s(3), v3.s(3), ptr_post(x4, 12))); + TEST_INSTRUCTION("81B0CB4D", ld3(v1.s(3), v2.s(3), v3.s(3), ptr_post(x4, x11))); + TEST_INSTRUCTION("81A4404D", ld3(v1.d(1), v2.d(1), v3.d(1), ptr(x4))); + TEST_INSTRUCTION("81A4DF4D", ld3(v1.d(1), v2.d(1), v3.d(1), ptr_post(x4, 24))); + TEST_INSTRUCTION("81A4CB4D", ld3(v1.d(1), v2.d(1), v3.d(1), ptr_post(x4, x11))); + TEST_INSTRUCTION("8140400C", ld3(v1.b8(), v2.b8(), v3.b8(), ptr(x4))); + TEST_INSTRUCTION("8140DF0C", ld3(v1.b8(), v2.b8(), v3.b8(), ptr_post(x4, 24))); + TEST_INSTRUCTION("8140CB0C", ld3(v1.b8(), v2.b8(), v3.b8(), ptr_post(x4, x11))); + TEST_INSTRUCTION("8140404C", ld3(v1.b16(), v2.b16(), v3.b16(), ptr(x4))); + TEST_INSTRUCTION("8140DF4C", ld3(v1.b16(), v2.b16(), v3.b16(), ptr_post(x4, 48))); + TEST_INSTRUCTION("8140CB4C", ld3(v1.b16(), v2.b16(), v3.b16(), ptr_post(x4, x11))); + TEST_INSTRUCTION("8144400C", ld3(v1.h4(), v2.h4(), v3.h4(), ptr(x4))); + TEST_INSTRUCTION("8144DF0C", ld3(v1.h4(), v2.h4(), v3.h4(), ptr_post(x4, 24))); + TEST_INSTRUCTION("8144CB0C", ld3(v1.h4(), v2.h4(), v3.h4(), ptr_post(x4, x11))); + TEST_INSTRUCTION("8144404C", ld3(v1.h8(), v2.h8(), v3.h8(), ptr(x4))); + TEST_INSTRUCTION("8144DF4C", ld3(v1.h8(), v2.h8(), v3.h8(), ptr_post(x4, 48))); + TEST_INSTRUCTION("8144CB4C", ld3(v1.h8(), v2.h8(), v3.h8(), ptr_post(x4, x11))); + TEST_INSTRUCTION("8148400C", ld3(v1.s2(), v2.s2(), v3.s2(), ptr(x4))); + TEST_INSTRUCTION("8148DF0C", ld3(v1.s2(), v2.s2(), v3.s2(), ptr_post(x4, 24))); + TEST_INSTRUCTION("8148CB0C", ld3(v1.s2(), v2.s2(), v3.s2(), ptr_post(x4, x11))); + TEST_INSTRUCTION("8148404C", ld3(v1.s4(), v2.s4(), v3.s4(), ptr(x4))); + TEST_INSTRUCTION("8148DF4C", ld3(v1.s4(), v2.s4(), v3.s4(), ptr_post(x4, 48))); + TEST_INSTRUCTION("8148CB4C", ld3(v1.s4(), v2.s4(), v3.s4(), ptr_post(x4, x11))); + TEST_INSTRUCTION("814C404C", ld3(v1.d2(), v2.d2(), v3.d2(), ptr(x4))); + TEST_INSTRUCTION("814CDF4C", ld3(v1.d2(), v2.d2(), v3.d2(), ptr_post(x4, 48))); + TEST_INSTRUCTION("814CCB4C", ld3(v1.d2(), v2.d2(), v3.d2(), ptr_post(x4, x11))); + TEST_INSTRUCTION("81E0400D", ld3r(v1.b8(), v2.b8(), v3.b8(), ptr(x4))); + TEST_INSTRUCTION("81E0DF0D", ld3r(v1.b8(), v2.b8(), v3.b8(), ptr_post(x4, 3))); + TEST_INSTRUCTION("81E0CB0D", ld3r(v1.b8(), v2.b8(), v3.b8(), ptr_post(x4, x11))); + TEST_INSTRUCTION("81E0404D", ld3r(v1.b16(), v2.b16(), v3.b16(), ptr(x4))); + TEST_INSTRUCTION("81E0DF4D", ld3r(v1.b16(), v2.b16(), v3.b16(), ptr_post(x4, 3))); + TEST_INSTRUCTION("81E0CB4D", ld3r(v1.b16(), v2.b16(), v3.b16(), ptr_post(x4, x11))); + TEST_INSTRUCTION("81E4400D", ld3r(v1.h4(), v2.h4(), v3.h4(), ptr(x4))); + TEST_INSTRUCTION("81E4DF0D", ld3r(v1.h4(), v2.h4(), v3.h4(), ptr_post(x4, 6))); + TEST_INSTRUCTION("81E4CB0D", ld3r(v1.h4(), v2.h4(), v3.h4(), ptr_post(x4, x11))); + TEST_INSTRUCTION("81E4404D", ld3r(v1.h8(), v2.h8(), v3.h8(), ptr(x4))); + TEST_INSTRUCTION("81E4DF4D", ld3r(v1.h8(), v2.h8(), v3.h8(), ptr_post(x4, 6))); + TEST_INSTRUCTION("81E4CB4D", ld3r(v1.h8(), v2.h8(), v3.h8(), ptr_post(x4, x11))); + TEST_INSTRUCTION("81E8400D", ld3r(v1.s2(), v2.s2(), v3.s2(), ptr(x4))); + TEST_INSTRUCTION("81E8DF0D", ld3r(v1.s2(), v2.s2(), v3.s2(), ptr_post(x4, 12))); + TEST_INSTRUCTION("81E8CB0D", ld3r(v1.s2(), v2.s2(), v3.s2(), ptr_post(x4, x11))); + TEST_INSTRUCTION("81E8404D", ld3r(v1.s4(), v2.s4(), v3.s4(), ptr(x4))); + TEST_INSTRUCTION("81E8DF4D", ld3r(v1.s4(), v2.s4(), v3.s4(), ptr_post(x4, 12))); + TEST_INSTRUCTION("81E8CB4D", ld3r(v1.s4(), v2.s4(), v3.s4(), ptr_post(x4, x11))); + TEST_INSTRUCTION("81EC404D", ld3r(v1.d2(), v2.d2(), v3.d2(), ptr(x4))); + TEST_INSTRUCTION("81ECDF4D", ld3r(v1.d2(), v2.d2(), v3.d2(), ptr_post(x4, 24))); + TEST_INSTRUCTION("81ECCB4D", ld3r(v1.d2(), v2.d2(), v3.d2(), ptr_post(x4, x11))); + TEST_INSTRUCTION("A120600D", ld4(v1.b(0), v2.b(0), v3.b(0), v4.b(0), ptr(x5))); + TEST_INSTRUCTION("A120FF0D", ld4(v1.b(0), v2.b(0), v3.b(0), v4.b(0), ptr_post(x5, 4))); + TEST_INSTRUCTION("A120EB0D", ld4(v1.b(0), v2.b(0), v3.b(0), v4.b(0), ptr_post(x5, x11))); + TEST_INSTRUCTION("A160600D", ld4(v1.h(0), v2.h(0), v3.h(0), v4.h(0), ptr(x5))); + TEST_INSTRUCTION("A160FF0D", ld4(v1.h(0), v2.h(0), v3.h(0), v4.h(0), ptr_post(x5, 8))); + TEST_INSTRUCTION("A160EB0D", ld4(v1.h(0), v2.h(0), v3.h(0), v4.h(0), ptr_post(x5, x11))); + TEST_INSTRUCTION("A1A0600D", ld4(v1.s(0), v2.s(0), v3.s(0), v4.s(0), ptr(x5))); + TEST_INSTRUCTION("A1A0FF0D", ld4(v1.s(0), v2.s(0), v3.s(0), v4.s(0), ptr_post(x5, 16))); + TEST_INSTRUCTION("A1A0EB0D", ld4(v1.s(0), v2.s(0), v3.s(0), v4.s(0), ptr_post(x5, x11))); + TEST_INSTRUCTION("A1A4600D", ld4(v1.d(0), v2.d(0), v3.d(0), v4.d(0), ptr(x5))); + TEST_INSTRUCTION("A1A4FF0D", ld4(v1.d(0), v2.d(0), v3.d(0), v4.d(0), ptr_post(x5, 32))); + TEST_INSTRUCTION("A1A4EB0D", ld4(v1.d(0), v2.d(0), v3.d(0), v4.d(0), ptr_post(x5, x11))); + TEST_INSTRUCTION("A13C604D", ld4(v1.b(15), v2.b(15), v3.b(15), v4.b(15), ptr(x5))); + TEST_INSTRUCTION("A13CFF4D", ld4(v1.b(15), v2.b(15), v3.b(15), v4.b(15), ptr_post(x5, 4))); + TEST_INSTRUCTION("A13CEB4D", ld4(v1.b(15), v2.b(15), v3.b(15), v4.b(15), ptr_post(x5, x11))); + TEST_INSTRUCTION("A178604D", ld4(v1.h(7), v2.h(7), v3.h(7), v4.h(7), ptr(x5))); + TEST_INSTRUCTION("A178FF4D", ld4(v1.h(7), v2.h(7), v3.h(7), v4.h(7), ptr_post(x5, 8))); + TEST_INSTRUCTION("A178EB4D", ld4(v1.h(7), v2.h(7), v3.h(7), v4.h(7), ptr_post(x5, x11))); + TEST_INSTRUCTION("A1B0604D", ld4(v1.s(3), v2.s(3), v3.s(3), v4.s(3), ptr(x5))); + TEST_INSTRUCTION("A1B0FF4D", ld4(v1.s(3), v2.s(3), v3.s(3), v4.s(3), ptr_post(x5, 16))); + TEST_INSTRUCTION("A1B0EB4D", ld4(v1.s(3), v2.s(3), v3.s(3), v4.s(3), ptr_post(x5, x11))); + TEST_INSTRUCTION("A1A4604D", ld4(v1.d(1), v2.d(1), v3.d(1), v4.d(1), ptr(x5))); + TEST_INSTRUCTION("A1A4FF4D", ld4(v1.d(1), v2.d(1), v3.d(1), v4.d(1), ptr_post(x5, 32))); + TEST_INSTRUCTION("A1A4EB4D", ld4(v1.d(1), v2.d(1), v3.d(1), v4.d(1), ptr_post(x5, x11))); + TEST_INSTRUCTION("A100400C", ld4(v1.b8(), v2.b8(), v3.b8(), v4.b8(), ptr(x5))); + TEST_INSTRUCTION("A100DF0C", ld4(v1.b8(), v2.b8(), v3.b8(), v4.b8(), ptr_post(x5, 32))); + TEST_INSTRUCTION("A100CB0C", ld4(v1.b8(), v2.b8(), v3.b8(), v4.b8(), ptr_post(x5, x11))); + TEST_INSTRUCTION("A100404C", ld4(v1.b16(), v2.b16(), v3.b16(), v4.b16(), ptr(x5))); + TEST_INSTRUCTION("A100DF4C", ld4(v1.b16(), v2.b16(), v3.b16(), v4.b16(), ptr_post(x5, 64))); + TEST_INSTRUCTION("A100CB4C", ld4(v1.b16(), v2.b16(), v3.b16(), v4.b16(), ptr_post(x5, x11))); + TEST_INSTRUCTION("A104400C", ld4(v1.h4(), v2.h4(), v3.h4(), v4.h4(), ptr(x5))); + TEST_INSTRUCTION("A104DF0C", ld4(v1.h4(), v2.h4(), v3.h4(), v4.h4(), ptr_post(x5, 32))); + TEST_INSTRUCTION("A104CB0C", ld4(v1.h4(), v2.h4(), v3.h4(), v4.h4(), ptr_post(x5, x11))); + TEST_INSTRUCTION("A104404C", ld4(v1.h8(), v2.h8(), v3.h8(), v4.h8(), ptr(x5))); + TEST_INSTRUCTION("A104DF4C", ld4(v1.h8(), v2.h8(), v3.h8(), v4.h8(), ptr_post(x5, 64))); + TEST_INSTRUCTION("A104CB4C", ld4(v1.h8(), v2.h8(), v3.h8(), v4.h8(), ptr_post(x5, x11))); + TEST_INSTRUCTION("A108400C", ld4(v1.s2(), v2.s2(), v3.s2(), v4.s2(), ptr(x5))); + TEST_INSTRUCTION("A108DF0C", ld4(v1.s2(), v2.s2(), v3.s2(), v4.s2(), ptr_post(x5, 32))); + TEST_INSTRUCTION("A108CB0C", ld4(v1.s2(), v2.s2(), v3.s2(), v4.s2(), ptr_post(x5, x11))); + TEST_INSTRUCTION("A108404C", ld4(v1.s4(), v2.s4(), v3.s4(), v4.s4(), ptr(x5))); + TEST_INSTRUCTION("A108DF4C", ld4(v1.s4(), v2.s4(), v3.s4(), v4.s4(), ptr_post(x5, 64))); + TEST_INSTRUCTION("A108CB4C", ld4(v1.s4(), v2.s4(), v3.s4(), v4.s4(), ptr_post(x5, x11))); + TEST_INSTRUCTION("A10C404C", ld4(v1.d2(), v2.d2(), v3.d2(), v4.d2(), ptr(x5))); + TEST_INSTRUCTION("A10CDF4C", ld4(v1.d2(), v2.d2(), v3.d2(), v4.d2(), ptr_post(x5, 64))); + TEST_INSTRUCTION("A10CCB4C", ld4(v1.d2(), v2.d2(), v3.d2(), v4.d2(), ptr_post(x5, x11))); + TEST_INSTRUCTION("A1E0600D", ld4r(v1.b8(), v2.b8(), v3.b8(), v4.b8(), ptr(x5))); + TEST_INSTRUCTION("A1E0FF0D", ld4r(v1.b8(), v2.b8(), v3.b8(), v4.b8(), ptr_post(x5, 4))); + TEST_INSTRUCTION("A1E0EB0D", ld4r(v1.b8(), v2.b8(), v3.b8(), v4.b8(), ptr_post(x5, x11))); + TEST_INSTRUCTION("A1E0604D", ld4r(v1.b16(), v2.b16(), v3.b16(), v4.b16(), ptr(x5))); + TEST_INSTRUCTION("A1E0FF4D", ld4r(v1.b16(), v2.b16(), v3.b16(), v4.b16(), ptr_post(x5, 4))); + TEST_INSTRUCTION("A1E0EB4D", ld4r(v1.b16(), v2.b16(), v3.b16(), v4.b16(), ptr_post(x5, x11))); + TEST_INSTRUCTION("A1E4600D", ld4r(v1.h4(), v2.h4(), v3.h4(), v4.h4(), ptr(x5))); + TEST_INSTRUCTION("A1E4FF0D", ld4r(v1.h4(), v2.h4(), v3.h4(), v4.h4(), ptr_post(x5, 8))); + TEST_INSTRUCTION("A1E4EB0D", ld4r(v1.h4(), v2.h4(), v3.h4(), v4.h4(), ptr_post(x5, x11))); + TEST_INSTRUCTION("A1E4604D", ld4r(v1.h8(), v2.h8(), v3.h8(), v4.h8(), ptr(x5))); + TEST_INSTRUCTION("A1E4FF4D", ld4r(v1.h8(), v2.h8(), v3.h8(), v4.h8(), ptr_post(x5, 8))); + TEST_INSTRUCTION("A1E4EB4D", ld4r(v1.h8(), v2.h8(), v3.h8(), v4.h8(), ptr_post(x5, x11))); + TEST_INSTRUCTION("A1E8600D", ld4r(v1.s2(), v2.s2(), v3.s2(), v4.s2(), ptr(x5))); + TEST_INSTRUCTION("A1E8FF0D", ld4r(v1.s2(), v2.s2(), v3.s2(), v4.s2(), ptr_post(x5, 16))); + TEST_INSTRUCTION("A1E8EB0D", ld4r(v1.s2(), v2.s2(), v3.s2(), v4.s2(), ptr_post(x5, x11))); + TEST_INSTRUCTION("A1E8604D", ld4r(v1.s4(), v2.s4(), v3.s4(), v4.s4(), ptr(x5))); + TEST_INSTRUCTION("A1E8FF4D", ld4r(v1.s4(), v2.s4(), v3.s4(), v4.s4(), ptr_post(x5, 16))); + TEST_INSTRUCTION("A1E8EB4D", ld4r(v1.s4(), v2.s4(), v3.s4(), v4.s4(), ptr_post(x5, x11))); + TEST_INSTRUCTION("A1EC604D", ld4r(v1.d2(), v2.d2(), v3.d2(), v4.d2(), ptr(x5))); + TEST_INSTRUCTION("A1ECFF4D", ld4r(v1.d2(), v2.d2(), v3.d2(), v4.d2(), ptr_post(x5, 32))); + TEST_INSTRUCTION("A1ECEB4D", ld4r(v1.d2(), v2.d2(), v3.d2(), v4.d2(), ptr_post(x5, x11))); + TEST_INSTRUCTION("8109402C", ldnp(s1, s2, ptr(x12))); + TEST_INSTRUCTION("8189402C", ldnp(s1, s2, ptr(x12, 4))); + TEST_INSTRUCTION("8109702C", ldnp(s1, s2, ptr(x12, -128))); + TEST_INSTRUCTION("E10B402C", ldnp(s1, s2, ptr(sp))); + TEST_INSTRUCTION("E18B402C", ldnp(s1, s2, ptr(sp, 4))); + TEST_INSTRUCTION("E10B502C", ldnp(s1, s2, ptr(sp, 128))); + TEST_INSTRUCTION("8109406C", ldnp(d1, d2, ptr(x12))); + TEST_INSTRUCTION("8189406C", ldnp(d1, d2, ptr(x12, 8))); + TEST_INSTRUCTION("8109786C", ldnp(d1, d2, ptr(x12, -128))); + TEST_INSTRUCTION("E10B406C", ldnp(d1, d2, ptr(sp))); + TEST_INSTRUCTION("E18B406C", ldnp(d1, d2, ptr(sp, 8))); + TEST_INSTRUCTION("E10B486C", ldnp(d1, d2, ptr(sp, 128))); + TEST_INSTRUCTION("810940AC", ldnp(q1, q2, ptr(x12))); + TEST_INSTRUCTION("818940AC", ldnp(q1, q2, ptr(x12, 16))); + TEST_INSTRUCTION("81097CAC", ldnp(q1, q2, ptr(x12, -128))); + TEST_INSTRUCTION("E10B40AC", ldnp(q1, q2, ptr(sp))); + TEST_INSTRUCTION("E18B40AC", ldnp(q1, q2, ptr(sp, 16))); + TEST_INSTRUCTION("E10B44AC", ldnp(q1, q2, ptr(sp, 128))); + TEST_INSTRUCTION("8109402D", ldp(s1, s2, ptr(x12))); + TEST_INSTRUCTION("8189402D", ldp(s1, s2, ptr(x12, 4))); + TEST_INSTRUCTION("8109702D", ldp(s1, s2, ptr(x12, -128))); + TEST_INSTRUCTION("8189C02D", ldp(s1, s2, ptr_pre(x12, 4))); + TEST_INSTRUCTION("8189C02C", ldp(s1, s2, ptr_post(x12, 4))); + TEST_INSTRUCTION("E10B402D", ldp(s1, s2, ptr(sp))); + TEST_INSTRUCTION("E18B402D", ldp(s1, s2, ptr(sp, 4))); + TEST_INSTRUCTION("E10B502D", ldp(s1, s2, ptr(sp, 128))); + TEST_INSTRUCTION("E18BC02C", ldp(s1, s2, ptr_post(sp, 4))); + TEST_INSTRUCTION("E18BC02D", ldp(s1, s2, ptr_pre(sp, 4))); + TEST_INSTRUCTION("8109406D", ldp(d1, d2, ptr(x12))); + TEST_INSTRUCTION("8189406D", ldp(d1, d2, ptr(x12, 8))); + TEST_INSTRUCTION("8109786D", ldp(d1, d2, ptr(x12, -128))); + TEST_INSTRUCTION("8189C06D", ldp(d1, d2, ptr_pre(x12, 8))); + TEST_INSTRUCTION("8189C06C", ldp(d1, d2, ptr_post(x12, 8))); + TEST_INSTRUCTION("E10B406D", ldp(d1, d2, ptr(sp))); + TEST_INSTRUCTION("E18B406D", ldp(d1, d2, ptr(sp, 8))); + TEST_INSTRUCTION("E10B486D", ldp(d1, d2, ptr(sp, 128))); + TEST_INSTRUCTION("E18BC06D", ldp(d1, d2, ptr_pre(sp, 8))); + TEST_INSTRUCTION("E18BC06C", ldp(d1, d2, ptr_post(sp, 8))); + TEST_INSTRUCTION("810940AD", ldp(q1, q2, ptr(x12))); + TEST_INSTRUCTION("818940AD", ldp(q1, q2, ptr(x12, 16))); + TEST_INSTRUCTION("81097CAD", ldp(q1, q2, ptr(x12, -128))); + TEST_INSTRUCTION("8189C0AD", ldp(q1, q2, ptr_pre(x12, 16))); + TEST_INSTRUCTION("8189C0AC", ldp(q1, q2, ptr_post(x12, 16))); + TEST_INSTRUCTION("E10B40AD", ldp(q1, q2, ptr(sp))); + TEST_INSTRUCTION("E18B40AD", ldp(q1, q2, ptr(sp, 16))); + TEST_INSTRUCTION("E10B44AD", ldp(q1, q2, ptr(sp, 128))); + TEST_INSTRUCTION("E18BC0AD", ldp(q1, q2, ptr_pre(sp, 16))); + TEST_INSTRUCTION("E18BC0AC", ldp(q1, q2, ptr_post(sp, 16))); + TEST_INSTRUCTION("4100403D", ldr(b1, ptr(x2))); + TEST_INSTRUCTION("4114403C", ldr(b1, ptr_post(x2, 1))); + TEST_INSTRUCTION("4104403D", ldr(b1, ptr(x2, 1))); + TEST_INSTRUCTION("411C403C", ldr(b1, ptr_pre(x2, 1))); + TEST_INSTRUCTION("4114483C", ldr(b1, ptr_post(x2, 129))); + TEST_INSTRUCTION("4100407D", ldr(h1, ptr(x2))); + TEST_INSTRUCTION("4124407C", ldr(h1, ptr_post(x2, 2))); + TEST_INSTRUCTION("4104407D", ldr(h1, ptr(x2, 2))); + TEST_INSTRUCTION("412C407C", ldr(h1, ptr_pre(x2, 2))); + TEST_INSTRUCTION("4124487C", ldr(h1, ptr_post(x2, 130))); + TEST_INSTRUCTION("410040BD", ldr(s1, ptr(x2))); + TEST_INSTRUCTION("414440BC", ldr(s1, ptr_post(x2, 4))); + TEST_INSTRUCTION("410440BD", ldr(s1, ptr(x2, 4))); + TEST_INSTRUCTION("414C40BC", ldr(s1, ptr_pre(x2, 4))); + TEST_INSTRUCTION("414448BC", ldr(s1, ptr_post(x2, 132))); + TEST_INSTRUCTION("410040FD", ldr(d1, ptr(x2))); + TEST_INSTRUCTION("418440FC", ldr(d1, ptr_post(x2, 8))); + TEST_INSTRUCTION("410440FD", ldr(d1, ptr(x2, 8))); + TEST_INSTRUCTION("418C40FC", ldr(d1, ptr_pre(x2, 8))); + TEST_INSTRUCTION("414448FC", ldr(d1, ptr_post(x2, 132))); + TEST_INSTRUCTION("4168633C", ldr(b1, ptr(x2, x3))); + TEST_INSTRUCTION("4148633C", ldr(b1, ptr(x2, w3, uxtw(0)))); + TEST_INSTRUCTION("41C8633C", ldr(b1, ptr(x2, w3, sxtw(0)))); + TEST_INSTRUCTION("4168637C", ldr(h1, ptr(x2, x3))); + TEST_INSTRUCTION("4178637C", ldr(h1, ptr(x2, x3, lsl(1)))); + TEST_INSTRUCTION("4148637C", ldr(h1, ptr(x2, w3, uxtw(0)))); + TEST_INSTRUCTION("4158637C", ldr(h1, ptr(x2, w3, uxtw(1)))); + TEST_INSTRUCTION("41C8637C", ldr(h1, ptr(x2, w3, sxtw(0)))); + TEST_INSTRUCTION("41D8637C", ldr(h1, ptr(x2, w3, sxtw(1)))); + TEST_INSTRUCTION("416863BC", ldr(s1, ptr(x2, x3))); + TEST_INSTRUCTION("417863BC", ldr(s1, ptr(x2, x3, lsl(2)))); + TEST_INSTRUCTION("414863BC", ldr(s1, ptr(x2, w3, uxtw(0)))); + TEST_INSTRUCTION("415863BC", ldr(s1, ptr(x2, w3, uxtw(2)))); + TEST_INSTRUCTION("41C863BC", ldr(s1, ptr(x2, w3, sxtw(0)))); + TEST_INSTRUCTION("41D863BC", ldr(s1, ptr(x2, w3, sxtw(2)))); + TEST_INSTRUCTION("416863FC", ldr(d1, ptr(x2, x3))); + TEST_INSTRUCTION("417863FC", ldr(d1, ptr(x2, x3, lsl(3)))); + TEST_INSTRUCTION("414863FC", ldr(d1, ptr(x2, w3, uxtw(0)))); + TEST_INSTRUCTION("415863FC", ldr(d1, ptr(x2, w3, uxtw(3)))); + TEST_INSTRUCTION("41C863FC", ldr(d1, ptr(x2, w3, sxtw(0)))); + TEST_INSTRUCTION("41D863FC", ldr(d1, ptr(x2, w3, sxtw(3)))); + TEST_INSTRUCTION("4104403D", ldr(b1, ptr(x2, 1))); + TEST_INSTRUCTION("41F05F3C", ldr(b1, ptr(x2, -1))); // LDUR + TEST_INSTRUCTION("4110407C", ldr(h1, ptr(x2, 1))); // LDUR + TEST_INSTRUCTION("41F05F7C", ldr(h1, ptr(x2, -1))); // LDUR + TEST_INSTRUCTION("411040BC", ldr(s1, ptr(x2, 1))); // LDUR + TEST_INSTRUCTION("41F05FBC", ldr(s1, ptr(x2, -1))); // LDUR + TEST_INSTRUCTION("411040FC", ldr(d1, ptr(x2, 1))); // LDUR + TEST_INSTRUCTION("41F05FFC", ldr(d1, ptr(x2, -1))); // LDUR + TEST_INSTRUCTION("8101403C", ldur(b1, ptr(x12))); + TEST_INSTRUCTION("8131403C", ldur(b1, ptr(x12, 3))); + TEST_INSTRUCTION("8131463C", ldur(b1, ptr(x12, 99))); + TEST_INSTRUCTION("81F14F3C", ldur(b1, ptr(x12, 255))); + TEST_INSTRUCTION("8101503C", ldur(b1, ptr(x12, -256))); + TEST_INSTRUCTION("E103403C", ldur(b1, ptr(sp))); + TEST_INSTRUCTION("E153483C", ldur(b1, ptr(sp, 133))); + TEST_INSTRUCTION("8101407C", ldur(h1, ptr(x12))); + TEST_INSTRUCTION("8131407C", ldur(h1, ptr(x12, 3))); + TEST_INSTRUCTION("8131467C", ldur(h1, ptr(x12, 99))); + TEST_INSTRUCTION("81F14F7C", ldur(h1, ptr(x12, 255))); + TEST_INSTRUCTION("8101507C", ldur(h1, ptr(x12, -256))); + TEST_INSTRUCTION("E103407C", ldur(h1, ptr(sp))); + TEST_INSTRUCTION("E153487C", ldur(h1, ptr(sp, 133))); + TEST_INSTRUCTION("810140BC", ldur(s1, ptr(x12))); + TEST_INSTRUCTION("813140BC", ldur(s1, ptr(x12, 3))); + TEST_INSTRUCTION("813146BC", ldur(s1, ptr(x12, 99))); + TEST_INSTRUCTION("81F14FBC", ldur(s1, ptr(x12, 255))); + TEST_INSTRUCTION("810150BC", ldur(s1, ptr(x12, -256))); + TEST_INSTRUCTION("E10340BC", ldur(s1, ptr(sp))); + TEST_INSTRUCTION("E15348BC", ldur(s1, ptr(sp, 133))); + TEST_INSTRUCTION("810140FC", ldur(d1, ptr(x12))); + TEST_INSTRUCTION("813140FC", ldur(d1, ptr(x12, 3))); + TEST_INSTRUCTION("813146FC", ldur(d1, ptr(x12, 99))); + TEST_INSTRUCTION("81F14FFC", ldur(d1, ptr(x12, 255))); + TEST_INSTRUCTION("810150FC", ldur(d1, ptr(x12, -256))); + TEST_INSTRUCTION("E10340FC", ldur(d1, ptr(sp))); + TEST_INSTRUCTION("E15348FC", ldur(d1, ptr(sp, 133))); + TEST_INSTRUCTION("8101C03C", ldur(q1, ptr(x12))); + TEST_INSTRUCTION("8131C03C", ldur(q1, ptr(x12, 3))); + TEST_INSTRUCTION("8131C63C", ldur(q1, ptr(x12, 99))); + TEST_INSTRUCTION("81F1CF3C", ldur(q1, ptr(x12, 255))); + TEST_INSTRUCTION("8101D03C", ldur(q1, ptr(x12, -256))); + TEST_INSTRUCTION("E103C03C", ldur(q1, ptr(sp))); + TEST_INSTRUCTION("E153C83C", ldur(q1, ptr(sp, 133))); + TEST_INSTRUCTION("4194230E", mla(v1.b8(), v2.b8(), v3.b8())); + TEST_INSTRUCTION("4194630E", mla(v1.h4(), v2.h4(), v3.h4())); + TEST_INSTRUCTION("4194A30E", mla(v1.s2(), v2.s2(), v3.s2())); + TEST_INSTRUCTION("4194234E", mla(v1.b16(), v2.b16(), v3.b16())); + TEST_INSTRUCTION("4194634E", mla(v1.h8(), v2.h8(), v3.h8())); + TEST_INSTRUCTION("4194A34E", mla(v1.s4(), v2.s4(), v3.s4())); + TEST_INSTRUCTION("4100432F", mla(v1.h4(), v2.h4(), v3.h(0))); + TEST_INSTRUCTION("4100532F", mla(v1.h4(), v2.h4(), v3.h(1))); + TEST_INSTRUCTION("4100632F", mla(v1.h4(), v2.h4(), v3.h(2))); + TEST_INSTRUCTION("4100732F", mla(v1.h4(), v2.h4(), v3.h(3))); + TEST_INSTRUCTION("4108436F", mla(v1.h8(), v2.h8(), v3.h(4))); + TEST_INSTRUCTION("4108536F", mla(v1.h8(), v2.h8(), v3.h(5))); + TEST_INSTRUCTION("4108636F", mla(v1.h8(), v2.h8(), v3.h(6))); + TEST_INSTRUCTION("4108736F", mla(v1.h8(), v2.h8(), v3.h(7))); + TEST_INSTRUCTION("4100832F", mla(v1.s2(), v2.s2(), v3.s(0))); + TEST_INSTRUCTION("4100A32F", mla(v1.s2(), v2.s2(), v3.s(1))); + TEST_INSTRUCTION("4108836F", mla(v1.s4(), v2.s4(), v3.s(2))); + TEST_INSTRUCTION("4108A36F", mla(v1.s4(), v2.s4(), v3.s(3))); + TEST_INSTRUCTION("4194232E", mls(v1.b8(), v2.b8(), v3.b8())); + TEST_INSTRUCTION("4194632E", mls(v1.h4(), v2.h4(), v3.h4())); + TEST_INSTRUCTION("4194A32E", mls(v1.s2(), v2.s2(), v3.s2())); + TEST_INSTRUCTION("4194236E", mls(v1.b16(), v2.b16(), v3.b16())); + TEST_INSTRUCTION("4194636E", mls(v1.h8(), v2.h8(), v3.h8())); + TEST_INSTRUCTION("4194A36E", mls(v1.s4(), v2.s4(), v3.s4())); + TEST_INSTRUCTION("4140432F", mls(v1.h4(), v2.h4(), v3.h(0))); + TEST_INSTRUCTION("4140532F", mls(v1.h4(), v2.h4(), v3.h(1))); + TEST_INSTRUCTION("4140632F", mls(v1.h4(), v2.h4(), v3.h(2))); + TEST_INSTRUCTION("4140732F", mls(v1.h4(), v2.h4(), v3.h(3))); + TEST_INSTRUCTION("4148436F", mls(v1.h8(), v2.h8(), v3.h(4))); + TEST_INSTRUCTION("4148536F", mls(v1.h8(), v2.h8(), v3.h(5))); + TEST_INSTRUCTION("4148636F", mls(v1.h8(), v2.h8(), v3.h(6))); + TEST_INSTRUCTION("4148736F", mls(v1.h8(), v2.h8(), v3.h(7))); + TEST_INSTRUCTION("4140832F", mls(v1.s2(), v2.s2(), v3.s(0))); + TEST_INSTRUCTION("4140A32F", mls(v1.s2(), v2.s2(), v3.s(1))); + TEST_INSTRUCTION("4148836F", mls(v1.s4(), v2.s4(), v3.s(2))); + TEST_INSTRUCTION("4148A36F", mls(v1.s4(), v2.s4(), v3.s(3))); + TEST_INSTRUCTION("4F04035E", mov(b15, v2.b(1))); + TEST_INSTRUCTION("4F04065E", mov(h15, v2.h(1))); + TEST_INSTRUCTION("4F040C5E", mov(s15, v2.s(1))); + TEST_INSTRUCTION("4F04185E", mov(d15, v2.d(1))); + TEST_INSTRUCTION("411C014E", mov(v1.b(0), w2)); + TEST_INSTRUCTION("411C074E", mov(v1.b(3), w2)); + TEST_INSTRUCTION("411C0D4E", mov(v1.b(6), w2)); + TEST_INSTRUCTION("411C134E", mov(v1.b(9), w2)); + TEST_INSTRUCTION("411C1F4E", mov(v1.b(15), w2)); + TEST_INSTRUCTION("411C024E", mov(v1.h(0), w2)); + TEST_INSTRUCTION("411C0E4E", mov(v1.h(3), w2)); + TEST_INSTRUCTION("411C1E4E", mov(v1.h(7), w2)); + TEST_INSTRUCTION("411C044E", mov(v1.s(0), w2)); + TEST_INSTRUCTION("411C0C4E", mov(v1.s(1), w2)); + TEST_INSTRUCTION("411C144E", mov(v1.s(2), w2)); + TEST_INSTRUCTION("411C1C4E", mov(v1.s(3), w2)); + TEST_INSTRUCTION("411C084E", mov(v1.d(0), x2)); + TEST_INSTRUCTION("411C184E", mov(v1.d(1), x2)); + TEST_INSTRUCTION("417C016E", mov(v1.b(0), v2.b(15))); + TEST_INSTRUCTION("4174036E", mov(v1.b(1), v2.b(14))); + TEST_INSTRUCTION("4174026E", mov(v1.h(0), v2.h(7))); + TEST_INSTRUCTION("4164066E", mov(v1.h(1), v2.h(6))); + TEST_INSTRUCTION("4164046E", mov(v1.s(0), v2.s(3))); + TEST_INSTRUCTION("41440C6E", mov(v1.s(1), v2.s(2))); + TEST_INSTRUCTION("4144086E", mov(v1.d(0), v2.d(1))); + TEST_INSTRUCTION("4104186E", mov(v1.d(1), v2.d(0))); + TEST_INSTRUCTION("41E5010F", movi(v1.b8(), 42)); + TEST_INSTRUCTION("4185010F", movi(v1.h4(), 42)); + TEST_INSTRUCTION("4105010F", movi(v1.s2(), 42)); + TEST_INSTRUCTION("C1E5022F", movi(d1, 0x00FF0000FFFFFF00u)); + TEST_INSTRUCTION("41E5014F", movi(v1.b16(), 42)); + TEST_INSTRUCTION("4185014F", movi(v1.h8(), 42)); + TEST_INSTRUCTION("4105014F", movi(v1.s4(), 42)); + TEST_INSTRUCTION("E167074F", movi(v1.s4(), 0xFF, lsl(24))); + TEST_INSTRUCTION("E1D7074F", movi(v1.s4(), 0xFF, msl(16))); + TEST_INSTRUCTION("C1E5026F", movi(v1.d2(), 0x00FF0000FFFFFF00u)); + TEST_INSTRUCTION("419C230E", mul(v1.b8(), v2.b8(), v3.b8())); + TEST_INSTRUCTION("419C630E", mul(v1.h4(), v2.h4(), v3.h4())); + TEST_INSTRUCTION("419CA30E", mul(v1.s2(), v2.s2(), v3.s2())); + TEST_INSTRUCTION("419C234E", mul(v1.b16(), v2.b16(), v3.b16())); + TEST_INSTRUCTION("419C634E", mul(v1.h8(), v2.h8(), v3.h8())); + TEST_INSTRUCTION("419CA34E", mul(v1.s4(), v2.s4(), v3.s4())); + TEST_INSTRUCTION("4158202E", mvn(v1.b8(), v2.b8())); + TEST_INSTRUCTION("4158206E", mvn(v1.b16(), v2.b16())); + TEST_INSTRUCTION("4185012F", mvni(v1.h4(), 42)); + TEST_INSTRUCTION("4105012F", mvni(v1.s2(), 42)); + TEST_INSTRUCTION("4185016F", mvni(v1.h8(), 42)); + TEST_INSTRUCTION("4105016F", mvni(v1.s4(), 42)); + TEST_INSTRUCTION("41B8202E", neg(v1.b8(), v2.b8())); + TEST_INSTRUCTION("41B8602E", neg(v1.h4(), v2.h4())); + TEST_INSTRUCTION("41B8A02E", neg(v1.s2(), v2.s2())); + TEST_INSTRUCTION("41B8E07E", neg(d1, d2)); + TEST_INSTRUCTION("41B8206E", neg(v1.b16(), v2.b16())); + TEST_INSTRUCTION("41B8606E", neg(v1.h8(), v2.h8())); + TEST_INSTRUCTION("41B8A06E", neg(v1.s4(), v2.s4())); + TEST_INSTRUCTION("41B8E06E", neg(v1.d2(), v2.d2())); + TEST_INSTRUCTION("4158202E", not_(v1.b8(), v2.b8())); + TEST_INSTRUCTION("4158206E", not_(v1.b16(), v2.b16())); + TEST_INSTRUCTION("411CE30E", orn(v1.b8(), v2.b8(), v3.b8())); + TEST_INSTRUCTION("411CE34E", orn(v1.b16(), v2.b16(), v3.b16())); + TEST_INSTRUCTION("411CA30E", orr(v1.b8(), v2.b8(), v3.b8())); + TEST_INSTRUCTION("411CA34E", orr(v1.b16(), v2.b16(), v3.b16())); + TEST_INSTRUCTION("E197070F", orr(v1.h4(), 255)); + TEST_INSTRUCTION("E1B7070F", orr(v1.h4(), 255, lsl(8))); + TEST_INSTRUCTION("E197074F", orr(v1.h8(), 255)); + TEST_INSTRUCTION("E1B7074F", orr(v1.h8(), 255, lsl(8))); + TEST_INSTRUCTION("E117070F", orr(v1.s2(), 255)); + TEST_INSTRUCTION("E137070F", orr(v1.s2(), 255, lsl(8))); + TEST_INSTRUCTION("E117074F", orr(v1.s4(), 255)); + TEST_INSTRUCTION("E177074F", orr(v1.s4(), 255, lsl(24))); + TEST_INSTRUCTION("419C232E", pmul(v1.b8(), v2.b8(), v3.b8())); + TEST_INSTRUCTION("419C236E", pmul(v1.b16(), v2.b16(), v3.b16())); + TEST_INSTRUCTION("41E0230E", pmull(v1.h8(), v2.b8(), v3.b8())); + TEST_INSTRUCTION("41E0E30E", pmull(q1, d2, d3)); + TEST_INSTRUCTION("41E0234E", pmull2(v1.h8(), v2.b16(), v3.b16())); + TEST_INSTRUCTION("41E0E34E", pmull2(q1, v2.d2(), v3.d2())); + TEST_INSTRUCTION("4140232E", raddhn(v1.b8(), v2.h8(), v3.h8())); + TEST_INSTRUCTION("4140632E", raddhn(v1.h4(), v2.s4(), v3.s4())); + TEST_INSTRUCTION("4140A32E", raddhn(v1.s2(), v2.d2(), v3.d2())); + TEST_INSTRUCTION("4140236E", raddhn2(v1.b16(), v2.h8(), v3.h8())); + TEST_INSTRUCTION("4140636E", raddhn2(v1.h8(), v2.s4(), v3.s4())); + TEST_INSTRUCTION("4140A36E", raddhn2(v1.s4(), v2.d2(), v3.d2())); + TEST_INSTRUCTION("418C63CE", rax1(v1.d2(), v2.d2(), v3.d2())); + TEST_INSTRUCTION("4158602E", rbit(v1.b8(), v2.b8())); + TEST_INSTRUCTION("4158606E", rbit(v1.b16(), v2.b16())); + TEST_INSTRUCTION("4118200E", rev16(v1.b8(), v2.b8())); + TEST_INSTRUCTION("4118204E", rev16(v1.b16(), v2.b16())); + TEST_INSTRUCTION("4108202E", rev32(v1.b8(), v2.b8())); + TEST_INSTRUCTION("4108206E", rev32(v1.b16(), v2.b16())); + TEST_INSTRUCTION("4108602E", rev32(v1.h4(), v2.h4())); + TEST_INSTRUCTION("4108606E", rev32(v1.h8(), v2.h8())); + TEST_INSTRUCTION("4108200E", rev64(v1.b8(), v2.b8())); + TEST_INSTRUCTION("4108204E", rev64(v1.b16(), v2.b16())); + TEST_INSTRUCTION("4108600E", rev64(v1.h4(), v2.h4())); + TEST_INSTRUCTION("4108604E", rev64(v1.h8(), v2.h8())); + TEST_INSTRUCTION("4108A00E", rev64(v1.s2(), v2.s2())); + TEST_INSTRUCTION("4108A04E", rev64(v1.s4(), v2.s4())); + TEST_INSTRUCTION("418C090F", rshrn(v1.b8(), v2.h8(), 7)); + TEST_INSTRUCTION("418C110F", rshrn(v1.h4(), v2.s4(), 15)); + TEST_INSTRUCTION("418C210F", rshrn(v1.s2(), v2.d2(), 31)); + TEST_INSTRUCTION("418C094F", rshrn2(v1.b16(), v2.h8(), 7)); + TEST_INSTRUCTION("418C114F", rshrn2(v1.h8(), v2.s4(), 15)); + TEST_INSTRUCTION("418C214F", rshrn2(v1.s4(), v2.d2(), 31)); + TEST_INSTRUCTION("4160232E", rsubhn(v1.b8(), v2.h8(), v3.h8())); + TEST_INSTRUCTION("4160632E", rsubhn(v1.h4(), v2.s4(), v3.s4())); + TEST_INSTRUCTION("4160A32E", rsubhn(v1.s2(), v2.d2(), v3.d2())); + TEST_INSTRUCTION("4160236E", rsubhn2(v1.b16(), v2.h8(), v3.h8())); + TEST_INSTRUCTION("4160636E", rsubhn2(v1.h8(), v2.s4(), v3.s4())); + TEST_INSTRUCTION("4160A36E", rsubhn2(v1.s4(), v2.d2(), v3.d2())); + TEST_INSTRUCTION("417C230E", saba(v1.b8(), v2.b8(), v3.b8())); + TEST_INSTRUCTION("417C630E", saba(v1.h4(), v2.h4(), v3.h4())); + TEST_INSTRUCTION("417CA30E", saba(v1.s2(), v2.s2(), v3.s2())); + TEST_INSTRUCTION("417C234E", saba(v1.b16(), v2.b16(), v3.b16())); + TEST_INSTRUCTION("417C634E", saba(v1.h8(), v2.h8(), v3.h8())); + TEST_INSTRUCTION("417CA34E", saba(v1.s4(), v2.s4(), v3.s4())); + TEST_INSTRUCTION("4150230E", sabal(v1.h8(), v2.b8(), v3.b8())); + TEST_INSTRUCTION("4150630E", sabal(v1.s4(), v2.h4(), v3.h4())); + TEST_INSTRUCTION("4150A30E", sabal(v1.d2(), v2.s2(), v3.s2())); + TEST_INSTRUCTION("4150234E", sabal2(v1.h8(), v2.b16(), v3.b16())); + TEST_INSTRUCTION("4150634E", sabal2(v1.s4(), v2.h8(), v3.h8())); + TEST_INSTRUCTION("4150A34E", sabal2(v1.d2(), v2.s4(), v3.s4())); + TEST_INSTRUCTION("4174230E", sabd(v1.b8(), v2.b8(), v3.b8())); + TEST_INSTRUCTION("4174630E", sabd(v1.h4(), v2.h4(), v3.h4())); + TEST_INSTRUCTION("4174A30E", sabd(v1.s2(), v2.s2(), v3.s2())); + TEST_INSTRUCTION("4174234E", sabd(v1.b16(), v2.b16(), v3.b16())); + TEST_INSTRUCTION("4174634E", sabd(v1.h8(), v2.h8(), v3.h8())); + TEST_INSTRUCTION("4174A34E", sabd(v1.s4(), v2.s4(), v3.s4())); + TEST_INSTRUCTION("4170230E", sabdl(v1.h8(), v2.b8(), v3.b8())); + TEST_INSTRUCTION("4170630E", sabdl(v1.s4(), v2.h4(), v3.h4())); + TEST_INSTRUCTION("4170A30E", sabdl(v1.d2(), v2.s2(), v3.s2())); + TEST_INSTRUCTION("4170234E", sabdl2(v1.h8(), v2.b16(), v3.b16())); + TEST_INSTRUCTION("4170634E", sabdl2(v1.s4(), v2.h8(), v3.h8())); + TEST_INSTRUCTION("4170A34E", sabdl2(v1.d2(), v2.s4(), v3.s4())); + TEST_INSTRUCTION("4168200E", sadalp(v1.h4(), v2.b8())); + TEST_INSTRUCTION("4168600E", sadalp(v1.s2(), v2.h4())); + TEST_INSTRUCTION("4168A00E", sadalp(d1, v2.s2())); + TEST_INSTRUCTION("4168204E", sadalp(v1.h8(), v2.b16())); + TEST_INSTRUCTION("4168604E", sadalp(v1.s4(), v2.h8())); + TEST_INSTRUCTION("4168A04E", sadalp(v1.d2(), v2.s4())); + TEST_INSTRUCTION("4100230E", saddl(v1.h8(), v2.b8(), v3.b8())); + TEST_INSTRUCTION("4100630E", saddl(v1.s4(), v2.h4(), v3.h4())); + TEST_INSTRUCTION("4100A30E", saddl(v1.d2(), v2.s2(), v3.s2())); + TEST_INSTRUCTION("4100234E", saddl2(v1.h8(), v2.b16(), v3.b16())); + TEST_INSTRUCTION("4100634E", saddl2(v1.s4(), v2.h8(), v3.h8())); + TEST_INSTRUCTION("4100A34E", saddl2(v1.d2(), v2.s4(), v3.s4())); + TEST_INSTRUCTION("4128200E", saddlp(v1.h4(), v2.b8())); + TEST_INSTRUCTION("4128600E", saddlp(v1.s2(), v2.h4())); + TEST_INSTRUCTION("4128A00E", saddlp(d1, v2.s2())); + TEST_INSTRUCTION("4128204E", saddlp(v1.h8(), v2.b16())); + TEST_INSTRUCTION("4128604E", saddlp(v1.s4(), v2.h8())); + TEST_INSTRUCTION("4128A04E", saddlp(v1.d2(), v2.s4())); + TEST_INSTRUCTION("4138300E", saddlv(h1, v2.b8())); + TEST_INSTRUCTION("4138304E", saddlv(h1, v2.b16())); + TEST_INSTRUCTION("4138700E", saddlv(s1, v2.h4())); + TEST_INSTRUCTION("4138704E", saddlv(s1, v2.h8())); + TEST_INSTRUCTION("4138B04E", saddlv(d1, v2.s4())); + TEST_INSTRUCTION("4110230E", saddw(v1.h8(), v2.h8(), v3.b8())); + TEST_INSTRUCTION("4110630E", saddw(v1.s4(), v2.s4(), v3.h4())); + TEST_INSTRUCTION("4110A30E", saddw(v1.d2(), v2.d2(), v3.s2())); + TEST_INSTRUCTION("4110234E", saddw2(v1.h8(), v2.h8(), v3.b16())); + TEST_INSTRUCTION("4110634E", saddw2(v1.s4(), v2.s4(), v3.h8())); + TEST_INSTRUCTION("4110A34E", saddw2(v1.d2(), v2.d2(), v3.s4())); + TEST_INSTRUCTION("4100E21E", scvtf(h1, w2)); + TEST_INSTRUCTION("4100221E", scvtf(s1, w2)); + TEST_INSTRUCTION("4100621E", scvtf(d1, w2)); + TEST_INSTRUCTION("4100E29E", scvtf(h1, x2)); + TEST_INSTRUCTION("4100229E", scvtf(s1, x2)); + TEST_INSTRUCTION("4100629E", scvtf(d1, x2)); + TEST_INSTRUCTION("41D8795E", scvtf(h1, h2)); + TEST_INSTRUCTION("41D8215E", scvtf(s1, s2)); + TEST_INSTRUCTION("41D8615E", scvtf(d1, d2)); + TEST_INSTRUCTION("41D8790E", scvtf(v1.h4(), v2.h4())); + TEST_INSTRUCTION("41D8210E", scvtf(v1.s2(), v2.s2())); + TEST_INSTRUCTION("41D8794E", scvtf(v1.h8(), v2.h8())); + TEST_INSTRUCTION("41D8214E", scvtf(v1.s4(), v2.s4())); + TEST_INSTRUCTION("41D8614E", scvtf(v1.d2(), v2.d2())); + TEST_INSTRUCTION("41E0C21E", scvtf(h1, w2, 8)); + TEST_INSTRUCTION("41E0021E", scvtf(s1, w2, 8)); + TEST_INSTRUCTION("41E0421E", scvtf(d1, w2, 8)); + TEST_INSTRUCTION("41E0C29E", scvtf(h1, x2, 8)); + TEST_INSTRUCTION("41E0029E", scvtf(s1, x2, 8)); + TEST_INSTRUCTION("41E0429E", scvtf(d1, x2, 8)); + TEST_INSTRUCTION("41E4185F", scvtf(h1, h2, 8)); + TEST_INSTRUCTION("41E4385F", scvtf(s1, s2, 8)); + TEST_INSTRUCTION("41E4785F", scvtf(d1, d2, 8)); + TEST_INSTRUCTION("41E4180F", scvtf(v1.h4(), v2.h4(), 8)); + TEST_INSTRUCTION("41E4380F", scvtf(v1.s2(), v2.s2(), 8)); + TEST_INSTRUCTION("41E4184F", scvtf(v1.h8(), v2.h8(), 8)); + TEST_INSTRUCTION("41E4384F", scvtf(v1.s4(), v2.s4(), 8)); + TEST_INSTRUCTION("41E4784F", scvtf(v1.d2(), v2.d2(), 8)); + TEST_INSTRUCTION("4194830E", sdot(v1.s2(), v2.b8(), v3.b8())); + TEST_INSTRUCTION("4194834E", sdot(v1.s4(), v2.b16(), v3.b16())); + TEST_INSTRUCTION("41E0830F", sdot(v1.s2(), v2.b8(), v3.b4(0))); + TEST_INSTRUCTION("41E0A30F", sdot(v1.s2(), v2.b8(), v3.b4(1))); + TEST_INSTRUCTION("41E8830F", sdot(v1.s2(), v2.b8(), v3.b4(2))); + TEST_INSTRUCTION("41E8A30F", sdot(v1.s2(), v2.b8(), v3.b4(3))); + TEST_INSTRUCTION("41E0834F", sdot(v1.s4(), v2.b16(), v3.b4(0))); + TEST_INSTRUCTION("41E0A34F", sdot(v1.s4(), v2.b16(), v3.b4(1))); + TEST_INSTRUCTION("41E8834F", sdot(v1.s4(), v2.b16(), v3.b4(2))); + TEST_INSTRUCTION("41E8A34F", sdot(v1.s4(), v2.b16(), v3.b4(3))); + TEST_INSTRUCTION("4100035E", sha1c(q1, s2, v3.s4())); + TEST_INSTRUCTION("4108285E", sha1h(s1, s2)); + TEST_INSTRUCTION("4120035E", sha1m(q1, s2, v3.s4())); + TEST_INSTRUCTION("4110035E", sha1p(q1, s2, v3.s4())); + TEST_INSTRUCTION("4130035E", sha1su0(v1.s4(), v2.s4(), v3.s4())); + TEST_INSTRUCTION("4118285E", sha1su1(v1.s4(), v2.s4())); + TEST_INSTRUCTION("4140035E", sha256h(q1, q2, v3.s4())); + TEST_INSTRUCTION("4150035E", sha256h2(q1, q2, v3.s4())); + TEST_INSTRUCTION("4128285E", sha256su0(v1.s4(), v2.s4())); + TEST_INSTRUCTION("4160035E", sha256su1(v1.s4(), v2.s4(), v3.s4())); + TEST_INSTRUCTION("4104230E", shadd(v1.b8(), v2.b8(), v3.b8())); + TEST_INSTRUCTION("4104630E", shadd(v1.h4(), v2.h4(), v3.h4())); + TEST_INSTRUCTION("4104A30E", shadd(v1.s2(), v2.s2(), v3.s2())); + TEST_INSTRUCTION("4104234E", shadd(v1.b16(), v2.b16(), v3.b16())); + TEST_INSTRUCTION("4104634E", shadd(v1.h8(), v2.h8(), v3.h8())); + TEST_INSTRUCTION("4104A34E", shadd(v1.s4(), v2.s4(), v3.s4())); + TEST_INSTRUCTION("41540F0F", shl(v1.b8(), v2.b8(), 7)); + TEST_INSTRUCTION("41541F0F", shl(v1.h4(), v2.h4(), 15)); + TEST_INSTRUCTION("41543F0F", shl(v1.s2(), v2.s2(), 31)); + TEST_INSTRUCTION("41547F5F", shl(d1, d2, 63)); + TEST_INSTRUCTION("41540F4F", shl(v1.b16(), v2.b16(), 7)); + TEST_INSTRUCTION("41541F4F", shl(v1.h8(), v2.h8(), 15)); + TEST_INSTRUCTION("41543F4F", shl(v1.s4(), v2.s4(), 31)); + TEST_INSTRUCTION("41547F4F", shl(v1.d2(), v2.d2(), 63)); + TEST_INSTRUCTION("4138212E", shll(v1.h8(), v2.b8(), 8)); + TEST_INSTRUCTION("4138612E", shll(v1.s4(), v2.h4(), 16)); + TEST_INSTRUCTION("4138A12E", shll(v1.d2(), v2.s2(), 32)); + TEST_INSTRUCTION("4138216E", shll2(v1.h8(), v2.b16(), 8)); + TEST_INSTRUCTION("4138616E", shll2(v1.s4(), v2.h8(), 16)); + TEST_INSTRUCTION("4138A16E", shll2(v1.d2(), v2.s4(), 32)); + TEST_INSTRUCTION("4184090F", shrn(v1.b8(), v2.h8(), 7)); + TEST_INSTRUCTION("4184110F", shrn(v1.h4(), v2.s4(), 15)); + TEST_INSTRUCTION("4184210F", shrn(v1.s2(), v2.d2(), 31)); + TEST_INSTRUCTION("4184094F", shrn2(v1.b16(), v2.h8(), 7)); + TEST_INSTRUCTION("4184114F", shrn2(v1.h8(), v2.s4(), 15)); + TEST_INSTRUCTION("4184214F", shrn2(v1.s4(), v2.d2(), 31)); + TEST_INSTRUCTION("4124230E", shsub(v1.b8(), v2.b8(), v3.b8())); + TEST_INSTRUCTION("4124630E", shsub(v1.h4(), v2.h4(), v3.h4())); + TEST_INSTRUCTION("4124A30E", shsub(v1.s2(), v2.s2(), v3.s2())); + TEST_INSTRUCTION("4124234E", shsub(v1.b16(), v2.b16(), v3.b16())); + TEST_INSTRUCTION("4124634E", shsub(v1.h8(), v2.h8(), v3.h8())); + TEST_INSTRUCTION("4124A34E", shsub(v1.s4(), v2.s4(), v3.s4())); + TEST_INSTRUCTION("41540F2F", sli(v1.b8(), v2.b8(), 7)); + TEST_INSTRUCTION("41541F2F", sli(v1.h4(), v2.h4(), 15)); + TEST_INSTRUCTION("41543F2F", sli(v1.s2(), v2.s2(), 31)); + TEST_INSTRUCTION("41547F7F", sli(d1, d2, 63)); + TEST_INSTRUCTION("41540F6F", sli(v1.b16(), v2.b16(), 7)); + TEST_INSTRUCTION("41541F6F", sli(v1.h8(), v2.h8(), 15)); + TEST_INSTRUCTION("41543F6F", sli(v1.s4(), v2.s4(), 31)); + TEST_INSTRUCTION("41547F6F", sli(v1.d2(), v2.d2(), 63)); + TEST_INSTRUCTION("41C063CE", sm3partw1(v1.s4(), v2.s4(), v3.s4())); + TEST_INSTRUCTION("41C463CE", sm3partw2(v1.s4(), v2.s4(), v3.s4())); + TEST_INSTRUCTION("411043CE", sm3ss1(v1.s4(), v2.s4(), v3.s4(), v4.s4())); + TEST_INSTRUCTION("418044CE", sm3tt1a(v1.s4(), v2.s4(), v4.s(0))); + TEST_INSTRUCTION("41B044CE", sm3tt1a(v1.s4(), v2.s4(), v4.s(3))); + TEST_INSTRUCTION("418444CE", sm3tt1b(v1.s4(), v2.s4(), v4.s(0))); + TEST_INSTRUCTION("41B444CE", sm3tt1b(v1.s4(), v2.s4(), v4.s(3))); + TEST_INSTRUCTION("418844CE", sm3tt2a(v1.s4(), v2.s4(), v4.s(0))); + TEST_INSTRUCTION("41B844CE", sm3tt2a(v1.s4(), v2.s4(), v4.s(3))); + TEST_INSTRUCTION("418C44CE", sm3tt2b(v1.s4(), v2.s4(), v4.s(0))); + TEST_INSTRUCTION("41BC44CE", sm3tt2b(v1.s4(), v2.s4(), v4.s(3))); + TEST_INSTRUCTION("4184C0CE", sm4e(v1.s4(), v2.s4())); + TEST_INSTRUCTION("41C863CE", sm4ekey(v1.s4(), v2.s4(), v3.s4())); + TEST_INSTRUCTION("4164230E", smax(v1.b8(), v2.b8(), v3.b8())); + TEST_INSTRUCTION("4164630E", smax(v1.h4(), v2.h4(), v3.h4())); + TEST_INSTRUCTION("4164A30E", smax(v1.s2(), v2.s2(), v3.s2())); + TEST_INSTRUCTION("4164234E", smax(v1.b16(), v2.b16(), v3.b16())); + TEST_INSTRUCTION("4164634E", smax(v1.h8(), v2.h8(), v3.h8())); + TEST_INSTRUCTION("4164A34E", smax(v1.s4(), v2.s4(), v3.s4())); + TEST_INSTRUCTION("41A4230E", smaxp(v1.b8(), v2.b8(), v3.b8())); + TEST_INSTRUCTION("41A4630E", smaxp(v1.h4(), v2.h4(), v3.h4())); + TEST_INSTRUCTION("41A4A30E", smaxp(v1.s2(), v2.s2(), v3.s2())); + TEST_INSTRUCTION("41A4234E", smaxp(v1.b16(), v2.b16(), v3.b16())); + TEST_INSTRUCTION("41A4634E", smaxp(v1.h8(), v2.h8(), v3.h8())); + TEST_INSTRUCTION("41A4A34E", smaxp(v1.s4(), v2.s4(), v3.s4())); + TEST_INSTRUCTION("41A8300E", smaxv(b1, v2.b8())); + TEST_INSTRUCTION("41A8304E", smaxv(b1, v2.b16())); + TEST_INSTRUCTION("41A8700E", smaxv(h1, v2.h4())); + TEST_INSTRUCTION("41A8704E", smaxv(h1, v2.h8())); + TEST_INSTRUCTION("41A8B04E", smaxv(s1, v2.s4())); + TEST_INSTRUCTION("416C230E", smin(v1.b8(), v2.b8(), v3.b8())); + TEST_INSTRUCTION("416C630E", smin(v1.h4(), v2.h4(), v3.h4())); + TEST_INSTRUCTION("416CA30E", smin(v1.s2(), v2.s2(), v3.s2())); + TEST_INSTRUCTION("416C234E", smin(v1.b16(), v2.b16(), v3.b16())); + TEST_INSTRUCTION("416C634E", smin(v1.h8(), v2.h8(), v3.h8())); + TEST_INSTRUCTION("416CA34E", smin(v1.s4(), v2.s4(), v3.s4())); + TEST_INSTRUCTION("41AC230E", sminp(v1.b8(), v2.b8(), v3.b8())); + TEST_INSTRUCTION("41AC630E", sminp(v1.h4(), v2.h4(), v3.h4())); + TEST_INSTRUCTION("41ACA30E", sminp(v1.s2(), v2.s2(), v3.s2())); + TEST_INSTRUCTION("41AC234E", sminp(v1.b16(), v2.b16(), v3.b16())); + TEST_INSTRUCTION("41AC634E", sminp(v1.h8(), v2.h8(), v3.h8())); + TEST_INSTRUCTION("41ACA34E", sminp(v1.s4(), v2.s4(), v3.s4())); + TEST_INSTRUCTION("41A8310E", sminv(b1, v2.b8())); + TEST_INSTRUCTION("41A8314E", sminv(b1, v2.b16())); + TEST_INSTRUCTION("41A8710E", sminv(h1, v2.h4())); + TEST_INSTRUCTION("41A8714E", sminv(h1, v2.h8())); + TEST_INSTRUCTION("41A8B14E", sminv(s1, v2.s4())); + TEST_INSTRUCTION("4180230E", smlal(v1.h8(), v2.b8(), v3.b8())); + TEST_INSTRUCTION("4180630E", smlal(v1.s4(), v2.h4(), v3.h4())); + TEST_INSTRUCTION("4180A30E", smlal(v1.d2(), v2.s2(), v3.s2())); + TEST_INSTRUCTION("4120730F", smlal(v1.s4(), v2.h4(), v3.h(3))); + TEST_INSTRUCTION("4128A30F", smlal(v1.d2(), v2.s2(), v3.s(3))); + TEST_INSTRUCTION("4180234E", smlal2(v1.h8(), v2.b16(), v3.b16())); + TEST_INSTRUCTION("4180634E", smlal2(v1.s4(), v2.h8(), v3.h8())); + TEST_INSTRUCTION("4180A34E", smlal2(v1.d2(), v2.s4(), v3.s4())); + TEST_INSTRUCTION("4120734F", smlal2(v1.s4(), v2.h8(), v3.h(3))); + TEST_INSTRUCTION("4128A34F", smlal2(v1.d2(), v2.s4(), v3.s(3))); + TEST_INSTRUCTION("41A0230E", smlsl(v1.h8(), v2.b8(), v3.b8())); + TEST_INSTRUCTION("41A0630E", smlsl(v1.s4(), v2.h4(), v3.h4())); + TEST_INSTRUCTION("41A0A30E", smlsl(v1.d2(), v2.s2(), v3.s2())); + TEST_INSTRUCTION("4160730F", smlsl(v1.s4(), v2.h4(), v3.h(3))); + TEST_INSTRUCTION("4168A30F", smlsl(v1.d2(), v2.s2(), v3.s(3))); + TEST_INSTRUCTION("41A0234E", smlsl2(v1.h8(), v2.b16(), v3.b16())); + TEST_INSTRUCTION("41A0634E", smlsl2(v1.s4(), v2.h8(), v3.h8())); + TEST_INSTRUCTION("41A0A34E", smlsl2(v1.d2(), v2.s4(), v3.s4())); + TEST_INSTRUCTION("4160734F", smlsl2(v1.s4(), v2.h8(), v3.h(3))); + TEST_INSTRUCTION("4168A34F", smlsl2(v1.d2(), v2.s4(), v3.s(3))); + TEST_INSTRUCTION("41A4834E", smmla(v1.s4(), v2.b16(), v3.b16())); + TEST_INSTRUCTION("412C010E", smov(w1, v2.b(0))); + TEST_INSTRUCTION("412C1F0E", smov(w1, v2.b(15))); + TEST_INSTRUCTION("412C020E", smov(w1, v2.h(0))); + TEST_INSTRUCTION("412C1E0E", smov(w1, v2.h(7))); + TEST_INSTRUCTION("412C014E", smov(x1, v2.b(0))); + TEST_INSTRUCTION("412C1F4E", smov(x1, v2.b(15))); + TEST_INSTRUCTION("412C024E", smov(x1, v2.h(0))); + TEST_INSTRUCTION("412C1E4E", smov(x1, v2.h(7))); + TEST_INSTRUCTION("412C044E", smov(x1, v2.s(0))); + TEST_INSTRUCTION("412C1C4E", smov(x1, v2.s(3))); + TEST_INSTRUCTION("41C0230E", smull(v1.h8(), v2.b8(), v3.b8())); + TEST_INSTRUCTION("41C0630E", smull(v1.s4(), v2.h4(), v3.h4())); + TEST_INSTRUCTION("41C0A30E", smull(v1.d2(), v2.s2(), v3.s2())); + TEST_INSTRUCTION("41A0730F", smull(v1.s4(), v2.h4(), v3.h(3))); + TEST_INSTRUCTION("41A8A30F", smull(v1.d2(), v2.s2(), v3.s(3))); + TEST_INSTRUCTION("41C0234E", smull2(v1.h8(), v2.b16(), v3.b16())); + TEST_INSTRUCTION("41C0634E", smull2(v1.s4(), v2.h8(), v3.h8())); + TEST_INSTRUCTION("41C0A34E", smull2(v1.d2(), v2.s4(), v3.s4())); + TEST_INSTRUCTION("41A0734F", smull2(v1.s4(), v2.h8(), v3.h(3))); + TEST_INSTRUCTION("41A8A34F", smull2(v1.d2(), v2.s4(), v3.s(3))); + TEST_INSTRUCTION("4178205E", sqabs(b1, b2)); + TEST_INSTRUCTION("4178605E", sqabs(h1, h2)); + TEST_INSTRUCTION("4178A05E", sqabs(s1, s2)); + TEST_INSTRUCTION("4178E05E", sqabs(d1, d2)); + TEST_INSTRUCTION("4178200E", sqabs(v1.b8(), v2.b8())); + TEST_INSTRUCTION("4178600E", sqabs(v1.h4(), v2.h4())); + TEST_INSTRUCTION("4178A00E", sqabs(v1.s2(), v2.s2())); + TEST_INSTRUCTION("4178204E", sqabs(v1.b16(), v2.b16())); + TEST_INSTRUCTION("4178604E", sqabs(v1.h8(), v2.h8())); + TEST_INSTRUCTION("4178A04E", sqabs(v1.s4(), v2.s4())); + TEST_INSTRUCTION("4178E04E", sqabs(v1.d2(), v2.d2())); + TEST_INSTRUCTION("410C235E", sqadd(b1, b2, b3)); + TEST_INSTRUCTION("410C635E", sqadd(h1, h2, h3)); + TEST_INSTRUCTION("410CA35E", sqadd(s1, s2, s3)); + TEST_INSTRUCTION("410CE35E", sqadd(d1, d2, d3)); + TEST_INSTRUCTION("410C230E", sqadd(v1.b8(), v2.b8(), v3.b8())); + TEST_INSTRUCTION("410C630E", sqadd(v1.h4(), v2.h4(), v3.h4())); + TEST_INSTRUCTION("410CA30E", sqadd(v1.s2(), v2.s2(), v3.s2())); + TEST_INSTRUCTION("410C234E", sqadd(v1.b16(), v2.b16(), v3.b16())); + TEST_INSTRUCTION("410C634E", sqadd(v1.h8(), v2.h8(), v3.h8())); + TEST_INSTRUCTION("410CA34E", sqadd(v1.s4(), v2.s4(), v3.s4())); + TEST_INSTRUCTION("410CE34E", sqadd(v1.d2(), v2.d2(), v3.d2())); + TEST_INSTRUCTION("4190635E", sqdmlal(s1, h2, h3)); + TEST_INSTRUCTION("4190A35E", sqdmlal(d1, s2, s3)); + TEST_INSTRUCTION("4190630E", sqdmlal(v1.s4(), v2.h4(), v3.h4())); + TEST_INSTRUCTION("4190A30E", sqdmlal(v1.d2(), v2.s2(), v3.s2())); + TEST_INSTRUCTION("4130730F", sqdmlal(v1.s4(), v2.h4(), v3.h(3))); + TEST_INSTRUCTION("4138A30F", sqdmlal(v1.d2(), v2.s2(), v3.s(3))); + TEST_INSTRUCTION("4190634E", sqdmlal2(v1.s4(), v2.h8(), v3.h8())); + TEST_INSTRUCTION("4190A34E", sqdmlal2(v1.d2(), v2.s4(), v3.s4())); + TEST_INSTRUCTION("4130734F", sqdmlal2(v1.s4(), v2.h8(), v3.h(3))); + TEST_INSTRUCTION("4138A34F", sqdmlal2(v1.d2(), v2.s4(), v3.s(3))); + TEST_INSTRUCTION("41B0635E", sqdmlsl(s1, h2, h3)); + TEST_INSTRUCTION("41B0A35E", sqdmlsl(d1, s2, s3)); + TEST_INSTRUCTION("41B0630E", sqdmlsl(v1.s4(), v2.h4(), v3.h4())); + TEST_INSTRUCTION("41B0A30E", sqdmlsl(v1.d2(), v2.s2(), v3.s2())); + TEST_INSTRUCTION("4170730F", sqdmlsl(v1.s4(), v2.h4(), v3.h(3))); + TEST_INSTRUCTION("4178A30F", sqdmlsl(v1.d2(), v2.s2(), v3.s(3))); + TEST_INSTRUCTION("41B0634E", sqdmlsl2(v1.s4(), v2.h8(), v3.h8())); + TEST_INSTRUCTION("41B0A34E", sqdmlsl2(v1.d2(), v2.s4(), v3.s4())); + TEST_INSTRUCTION("4170734F", sqdmlsl2(v1.s4(), v2.h8(), v3.h(3))); + TEST_INSTRUCTION("4178A34F", sqdmlsl2(v1.d2(), v2.s4(), v3.s(3))); + TEST_INSTRUCTION("41B4635E", sqdmulh(h1, h2, h3)); + TEST_INSTRUCTION("41B4A35E", sqdmulh(s1, s2, s3)); + TEST_INSTRUCTION("41B4630E", sqdmulh(v1.h4(), v2.h4(), v3.h4())); + TEST_INSTRUCTION("41B4A30E", sqdmulh(v1.s2(), v2.s2(), v3.s2())); + TEST_INSTRUCTION("41B4634E", sqdmulh(v1.h8(), v2.h8(), v3.h8())); + TEST_INSTRUCTION("41B4A34E", sqdmulh(v1.s4(), v2.s4(), v3.s4())); + TEST_INSTRUCTION("41C0730F", sqdmulh(v1.h4(), v2.h4(), v3.h(3))); + TEST_INSTRUCTION("41C8A30F", sqdmulh(v1.s2(), v2.s2(), v3.s(3))); + TEST_INSTRUCTION("41C0734F", sqdmulh(v1.h8(), v2.h8(), v3.h(3))); + TEST_INSTRUCTION("41C8A34F", sqdmulh(v1.s4(), v2.s4(), v3.s(3))); + TEST_INSTRUCTION("41D0635E", sqdmull(s1, h2, h3)); + TEST_INSTRUCTION("41D0A35E", sqdmull(d1, s2, s3)); + TEST_INSTRUCTION("41D0630E", sqdmull(v1.s4(), v2.h4(), v3.h4())); + TEST_INSTRUCTION("41D0A30E", sqdmull(v1.d2(), v2.s2(), v3.s2())); + TEST_INSTRUCTION("41B0730F", sqdmull(v1.s4(), v2.h4(), v3.h(3))); + TEST_INSTRUCTION("41B8A30F", sqdmull(v1.d2(), v2.s2(), v3.s(3))); + TEST_INSTRUCTION("41D0634E", sqdmull2(v1.s4(), v2.h8(), v3.h8())); + TEST_INSTRUCTION("41D0A34E", sqdmull2(v1.d2(), v2.s4(), v3.s4())); + TEST_INSTRUCTION("41B0734F", sqdmull2(v1.s4(), v2.h8(), v3.h(3))); + TEST_INSTRUCTION("41B8A34F", sqdmull2(v1.d2(), v2.s4(), v3.s(3))); + TEST_INSTRUCTION("4178207E", sqneg(b1, b2)); + TEST_INSTRUCTION("4178607E", sqneg(h1, h2)); + TEST_INSTRUCTION("4178A07E", sqneg(s1, s2)); + TEST_INSTRUCTION("4178E07E", sqneg(d1, d2)); + TEST_INSTRUCTION("4178202E", sqneg(v1.b8(), v2.b8())); + TEST_INSTRUCTION("4178602E", sqneg(v1.h4(), v2.h4())); + TEST_INSTRUCTION("4178A02E", sqneg(v1.s2(), v2.s2())); + TEST_INSTRUCTION("4178206E", sqneg(v1.b16(), v2.b16())); + TEST_INSTRUCTION("4178606E", sqneg(v1.h8(), v2.h8())); + TEST_INSTRUCTION("4178A06E", sqneg(v1.s4(), v2.s4())); + TEST_INSTRUCTION("4178E06E", sqneg(v1.d2(), v2.d2())); + TEST_INSTRUCTION("4184437E", sqrdmlah(h1, h2, h3)); + TEST_INSTRUCTION("4184837E", sqrdmlah(s1, s2, s3)); + TEST_INSTRUCTION("4184432E", sqrdmlah(v1.h4(), v2.h4(), v3.h4())); + TEST_INSTRUCTION("4184832E", sqrdmlah(v1.s2(), v2.s2(), v3.s2())); + TEST_INSTRUCTION("41D0732F", sqrdmlah(v1.h4(), v2.h4(), v3.h(3))); + TEST_INSTRUCTION("41D8A32F", sqrdmlah(v1.s2(), v2.s2(), v3.s(3))); + TEST_INSTRUCTION("4184436E", sqrdmlah(v1.h8(), v2.h8(), v3.h8())); + TEST_INSTRUCTION("4184836E", sqrdmlah(v1.s4(), v2.s4(), v3.s4())); + TEST_INSTRUCTION("41D0736F", sqrdmlah(v1.h8(), v2.h8(), v3.h(3))); + TEST_INSTRUCTION("41D8A36F", sqrdmlah(v1.s4(), v2.s4(), v3.s(3))); + TEST_INSTRUCTION("418C437E", sqrdmlsh(h1, h2, h3)); + TEST_INSTRUCTION("418C837E", sqrdmlsh(s1, s2, s3)); + TEST_INSTRUCTION("418C432E", sqrdmlsh(v1.h4(), v2.h4(), v3.h4())); + TEST_INSTRUCTION("418C832E", sqrdmlsh(v1.s2(), v2.s2(), v3.s2())); + TEST_INSTRUCTION("41F0732F", sqrdmlsh(v1.h4(), v2.h4(), v3.h(3))); + TEST_INSTRUCTION("41F8A32F", sqrdmlsh(v1.s2(), v2.s2(), v3.s(3))); + TEST_INSTRUCTION("418C436E", sqrdmlsh(v1.h8(), v2.h8(), v3.h8())); + TEST_INSTRUCTION("418C836E", sqrdmlsh(v1.s4(), v2.s4(), v3.s4())); + TEST_INSTRUCTION("41F0736F", sqrdmlsh(v1.h8(), v2.h8(), v3.h(3))); + TEST_INSTRUCTION("41F8A36F", sqrdmlsh(v1.s4(), v2.s4(), v3.s(3))); + TEST_INSTRUCTION("41B4637E", sqrdmulh(h1, h2, h3)); + TEST_INSTRUCTION("41B4A37E", sqrdmulh(s1, s2, s3)); + TEST_INSTRUCTION("41B4632E", sqrdmulh(v1.h4(), v2.h4(), v3.h4())); + TEST_INSTRUCTION("41B4A32E", sqrdmulh(v1.s2(), v2.s2(), v3.s2())); + TEST_INSTRUCTION("41D0730F", sqrdmulh(v1.h4(), v2.h4(), v3.h(3))); + TEST_INSTRUCTION("41D8A30F", sqrdmulh(v1.s2(), v2.s2(), v3.s(3))); + TEST_INSTRUCTION("41B4636E", sqrdmulh(v1.h8(), v2.h8(), v3.h8())); + TEST_INSTRUCTION("41B4A36E", sqrdmulh(v1.s4(), v2.s4(), v3.s4())); + TEST_INSTRUCTION("41D0734F", sqrdmulh(v1.h8(), v2.h8(), v3.h(3))); + TEST_INSTRUCTION("41D8A34F", sqrdmulh(v1.s4(), v2.s4(), v3.s(3))); + TEST_INSTRUCTION("415C235E", sqrshl(b1, b2, b3)); + TEST_INSTRUCTION("415C635E", sqrshl(h1, h2, h3)); + TEST_INSTRUCTION("415CA35E", sqrshl(s1, s2, s3)); + TEST_INSTRUCTION("415C230E", sqrshl(v1.b8(), v2.b8(), v3.b8())); + TEST_INSTRUCTION("415C630E", sqrshl(v1.h4(), v2.h4(), v3.h4())); + TEST_INSTRUCTION("415CA30E", sqrshl(v1.s2(), v2.s2(), v3.s2())); + TEST_INSTRUCTION("415CE35E", sqrshl(d1, d2, d3)); + TEST_INSTRUCTION("415C234E", sqrshl(v1.b16(), v2.b16(), v3.b16())); + TEST_INSTRUCTION("415C634E", sqrshl(v1.h8(), v2.h8(), v3.h8())); + TEST_INSTRUCTION("415CA34E", sqrshl(v1.s4(), v2.s4(), v3.s4())); + TEST_INSTRUCTION("415CE34E", sqrshl(v1.d2(), v2.d2(), v3.d2())); + TEST_INSTRUCTION("419C085F", sqrshrn(b1, h2, 8)); + TEST_INSTRUCTION("419C105F", sqrshrn(h1, s2, 16)); + TEST_INSTRUCTION("419C205F", sqrshrn(s1, d2, 32)); + TEST_INSTRUCTION("419C080F", sqrshrn(v1.b8(), v2.h8(), 8)); + TEST_INSTRUCTION("419C100F", sqrshrn(v1.h4(), v2.s4(), 16)); + TEST_INSTRUCTION("419C200F", sqrshrn(v1.s2(), v2.d2(), 32)); + TEST_INSTRUCTION("419C084F", sqrshrn2(v1.b16(), v2.h8(), 8)); + TEST_INSTRUCTION("419C104F", sqrshrn2(v1.h8(), v2.s4(), 16)); + TEST_INSTRUCTION("419C204F", sqrshrn2(v1.s4(), v2.d2(), 32)); + TEST_INSTRUCTION("418C087F", sqrshrun(b1, h2, 8)); + TEST_INSTRUCTION("418C107F", sqrshrun(h1, s2, 16)); + TEST_INSTRUCTION("418C207F", sqrshrun(s1, d2, 32)); + TEST_INSTRUCTION("418C082F", sqrshrun(v1.b8(), v2.h8(), 8)); + TEST_INSTRUCTION("418C102F", sqrshrun(v1.h4(), v2.s4(), 16)); + TEST_INSTRUCTION("418C202F", sqrshrun(v1.s2(), v2.d2(), 32)); + TEST_INSTRUCTION("418C086F", sqrshrun2(v1.b16(), v2.h8(), 8)); + TEST_INSTRUCTION("418C106F", sqrshrun2(v1.h8(), v2.s4(), 16)); + TEST_INSTRUCTION("418C206F", sqrshrun2(v1.s4(), v2.d2(), 32)); + TEST_INSTRUCTION("4174095F", sqshl(b1, b2, 1)); + TEST_INSTRUCTION("4174125F", sqshl(h1, h2, 2)); + TEST_INSTRUCTION("4174235F", sqshl(s1, s2, 3)); + TEST_INSTRUCTION("41740F0F", sqshl(v1.b8(), v2.b8(), 7)); + TEST_INSTRUCTION("41741F0F", sqshl(v1.h4(), v2.h4(), 15)); + TEST_INSTRUCTION("41743F0F", sqshl(v1.s2(), v2.s2(), 31)); + TEST_INSTRUCTION("41747F5F", sqshl(d1, d2, 63)); + TEST_INSTRUCTION("41740F4F", sqshl(v1.b16(), v2.b16(), 7)); + TEST_INSTRUCTION("41741F4F", sqshl(v1.h8(), v2.h8(), 15)); + TEST_INSTRUCTION("41743F4F", sqshl(v1.s4(), v2.s4(), 31)); + TEST_INSTRUCTION("41747F4F", sqshl(v1.d2(), v2.d2(), 63)); + TEST_INSTRUCTION("414C235E", sqshl(b1, b2, b3)); + TEST_INSTRUCTION("414C635E", sqshl(h1, h2, h3)); + TEST_INSTRUCTION("414CA35E", sqshl(s1, s2, s3)); + TEST_INSTRUCTION("414C230E", sqshl(v1.b8(), v2.b8(), v3.b8())); + TEST_INSTRUCTION("414C630E", sqshl(v1.h4(), v2.h4(), v3.h4())); + TEST_INSTRUCTION("414CA30E", sqshl(v1.s2(), v2.s2(), v3.s2())); + TEST_INSTRUCTION("414CE35E", sqshl(d1, d2, d3)); + TEST_INSTRUCTION("414C234E", sqshl(v1.b16(), v2.b16(), v3.b16())); + TEST_INSTRUCTION("414C634E", sqshl(v1.h8(), v2.h8(), v3.h8())); + TEST_INSTRUCTION("414CA34E", sqshl(v1.s4(), v2.s4(), v3.s4())); + TEST_INSTRUCTION("414CE34E", sqshl(v1.d2(), v2.d2(), v3.d2())); + TEST_INSTRUCTION("4164097F", sqshlu(b1, b2, 1)); + TEST_INSTRUCTION("4164127F", sqshlu(h1, h2, 2)); + TEST_INSTRUCTION("4164237F", sqshlu(s1, s2, 3)); + TEST_INSTRUCTION("41640F2F", sqshlu(v1.b8(), v2.b8(), 7)); + TEST_INSTRUCTION("41641F2F", sqshlu(v1.h4(), v2.h4(), 15)); + TEST_INSTRUCTION("41643F2F", sqshlu(v1.s2(), v2.s2(), 31)); + TEST_INSTRUCTION("41647F7F", sqshlu(d1, d2, 63)); + TEST_INSTRUCTION("41640F6F", sqshlu(v1.b16(), v2.b16(), 7)); + TEST_INSTRUCTION("41641F6F", sqshlu(v1.h8(), v2.h8(), 15)); + TEST_INSTRUCTION("41643F6F", sqshlu(v1.s4(), v2.s4(), 31)); + TEST_INSTRUCTION("41647F6F", sqshlu(v1.d2(), v2.d2(), 63)); + TEST_INSTRUCTION("4194085F", sqshrn(b1, h2, 8)); + TEST_INSTRUCTION("4194105F", sqshrn(h1, s2, 16)); + TEST_INSTRUCTION("4194205F", sqshrn(s1, d2, 32)); + TEST_INSTRUCTION("4194080F", sqshrn(v1.b8(), v2.h8(), 8)); + TEST_INSTRUCTION("4194100F", sqshrn(v1.h4(), v2.s4(), 16)); + TEST_INSTRUCTION("4194200F", sqshrn(v1.s2(), v2.d2(), 32)); + TEST_INSTRUCTION("4194084F", sqshrn2(v1.b16(), v2.h8(), 8)); + TEST_INSTRUCTION("4194104F", sqshrn2(v1.h8(), v2.s4(), 16)); + TEST_INSTRUCTION("4194204F", sqshrn2(v1.s4(), v2.d2(), 32)); + TEST_INSTRUCTION("4184087F", sqshrun(b1, h2, 8)); + TEST_INSTRUCTION("4184107F", sqshrun(h1, s2, 16)); + TEST_INSTRUCTION("4184207F", sqshrun(s1, d2, 32)); + TEST_INSTRUCTION("4184082F", sqshrun(v1.b8(), v2.h8(), 8)); + TEST_INSTRUCTION("4184102F", sqshrun(v1.h4(), v2.s4(), 16)); + TEST_INSTRUCTION("4184202F", sqshrun(v1.s2(), v2.d2(), 32)); + TEST_INSTRUCTION("4184086F", sqshrun2(v1.b16(), v2.h8(), 8)); + TEST_INSTRUCTION("4184106F", sqshrun2(v1.h8(), v2.s4(), 16)); + TEST_INSTRUCTION("4184206F", sqshrun2(v1.s4(), v2.d2(), 32)); + TEST_INSTRUCTION("412C235E", sqsub(b1, b2, b3)); + TEST_INSTRUCTION("412C635E", sqsub(h1, h2, h3)); + TEST_INSTRUCTION("412CA35E", sqsub(s1, s2, s3)); + TEST_INSTRUCTION("412CE35E", sqsub(d1, d2, d3)); + TEST_INSTRUCTION("412C230E", sqsub(v1.b8(), v2.b8(), v3.b8())); + TEST_INSTRUCTION("412C630E", sqsub(v1.h4(), v2.h4(), v3.h4())); + TEST_INSTRUCTION("412CA30E", sqsub(v1.s2(), v2.s2(), v3.s2())); + TEST_INSTRUCTION("412C234E", sqsub(v1.b16(), v2.b16(), v3.b16())); + TEST_INSTRUCTION("412C634E", sqsub(v1.h8(), v2.h8(), v3.h8())); + TEST_INSTRUCTION("412CA34E", sqsub(v1.s4(), v2.s4(), v3.s4())); + TEST_INSTRUCTION("412CE34E", sqsub(v1.d2(), v2.d2(), v3.d2())); + TEST_INSTRUCTION("4148215E", sqxtn(b1, h2)); + TEST_INSTRUCTION("4148615E", sqxtn(h1, s2)); + TEST_INSTRUCTION("4148A15E", sqxtn(s1, d2)); + TEST_INSTRUCTION("4148210E", sqxtn(v1.b8(), v2.h8())); + TEST_INSTRUCTION("4148610E", sqxtn(v1.h4(), v2.s4())); + TEST_INSTRUCTION("4148A10E", sqxtn(v1.s2(), v2.d2())); + TEST_INSTRUCTION("4148214E", sqxtn2(v1.b16(), v2.h8())); + TEST_INSTRUCTION("4148614E", sqxtn2(v1.h8(), v2.s4())); + TEST_INSTRUCTION("4148A14E", sqxtn2(v1.s4(), v2.d2())); + TEST_INSTRUCTION("4128217E", sqxtun(b1, h2)); + TEST_INSTRUCTION("4128617E", sqxtun(h1, s2)); + TEST_INSTRUCTION("4128A17E", sqxtun(s1, d2)); + TEST_INSTRUCTION("4128212E", sqxtun(v1.b8(), v2.h8())); + TEST_INSTRUCTION("4128612E", sqxtun(v1.h4(), v2.s4())); + TEST_INSTRUCTION("4128A12E", sqxtun(v1.s2(), v2.d2())); + TEST_INSTRUCTION("4128216E", sqxtun2(v1.b16(), v2.h8())); + TEST_INSTRUCTION("4128616E", sqxtun2(v1.h8(), v2.s4())); + TEST_INSTRUCTION("4128A16E", sqxtun2(v1.s4(), v2.d2())); + TEST_INSTRUCTION("4114230E", srhadd(v1.b8(), v2.b8(), v3.b8())); + TEST_INSTRUCTION("4114630E", srhadd(v1.h4(), v2.h4(), v3.h4())); + TEST_INSTRUCTION("4114A30E", srhadd(v1.s2(), v2.s2(), v3.s2())); + TEST_INSTRUCTION("4114234E", srhadd(v1.b16(), v2.b16(), v3.b16())); + TEST_INSTRUCTION("4114634E", srhadd(v1.h8(), v2.h8(), v3.h8())); + TEST_INSTRUCTION("4114A34E", srhadd(v1.s4(), v2.s4(), v3.s4())); + TEST_INSTRUCTION("4144092F", sri(v1.b8(), v2.b8(), 7)); + TEST_INSTRUCTION("4144112F", sri(v1.h4(), v2.h4(), 15)); + TEST_INSTRUCTION("4144212F", sri(v1.s2(), v2.s2(), 31)); + TEST_INSTRUCTION("4144417F", sri(d1, d2, 63)); + TEST_INSTRUCTION("4144096F", sri(v1.b16(), v2.b16(), 7)); + TEST_INSTRUCTION("4144116F", sri(v1.h8(), v2.h8(), 15)); + TEST_INSTRUCTION("4144216F", sri(v1.s4(), v2.s4(), 31)); + TEST_INSTRUCTION("4144416F", sri(v1.d2(), v2.d2(), 63)); + TEST_INSTRUCTION("4154230E", srshl(v1.b8(), v2.b8(), v3.b8())); + TEST_INSTRUCTION("4154630E", srshl(v1.h4(), v2.h4(), v3.h4())); + TEST_INSTRUCTION("4154A30E", srshl(v1.s2(), v2.s2(), v3.s2())); + TEST_INSTRUCTION("4154E35E", srshl(d1, d2, d3)); + TEST_INSTRUCTION("4154234E", srshl(v1.b16(), v2.b16(), v3.b16())); + TEST_INSTRUCTION("4154634E", srshl(v1.h8(), v2.h8(), v3.h8())); + TEST_INSTRUCTION("4154A34E", srshl(v1.s4(), v2.s4(), v3.s4())); + TEST_INSTRUCTION("4154E34E", srshl(v1.d2(), v2.d2(), v3.d2())); + TEST_INSTRUCTION("4124090F", srshr(v1.b8(), v2.b8(), 7)); + TEST_INSTRUCTION("4124110F", srshr(v1.h4(), v2.h4(), 15)); + TEST_INSTRUCTION("4124210F", srshr(v1.s2(), v2.s2(), 31)); + TEST_INSTRUCTION("4124415F", srshr(d1, d2, 63)); + TEST_INSTRUCTION("4124094F", srshr(v1.b16(), v2.b16(), 7)); + TEST_INSTRUCTION("4124114F", srshr(v1.h8(), v2.h8(), 15)); + TEST_INSTRUCTION("4124214F", srshr(v1.s4(), v2.s4(), 31)); + TEST_INSTRUCTION("4124414F", srshr(v1.d2(), v2.d2(), 63)); + TEST_INSTRUCTION("4134090F", srsra(v1.b8(), v2.b8(), 7)); + TEST_INSTRUCTION("4134110F", srsra(v1.h4(), v2.h4(), 15)); + TEST_INSTRUCTION("4134210F", srsra(v1.s2(), v2.s2(), 31)); + TEST_INSTRUCTION("4134415F", srsra(d1, d2, 63)); + TEST_INSTRUCTION("4134094F", srsra(v1.b16(), v2.b16(), 7)); + TEST_INSTRUCTION("4134114F", srsra(v1.h8(), v2.h8(), 15)); + TEST_INSTRUCTION("4134214F", srsra(v1.s4(), v2.s4(), 31)); + TEST_INSTRUCTION("4134414F", srsra(v1.d2(), v2.d2(), 63)); + TEST_INSTRUCTION("4144230E", sshl(v1.b8(), v2.b8(), v3.b8())); + TEST_INSTRUCTION("4144630E", sshl(v1.h4(), v2.h4(), v3.h4())); + TEST_INSTRUCTION("4144A30E", sshl(v1.s2(), v2.s2(), v3.s2())); + TEST_INSTRUCTION("4144E35E", sshl(d1, d2, d3)); + TEST_INSTRUCTION("4144234E", sshl(v1.b16(), v2.b16(), v3.b16())); + TEST_INSTRUCTION("4144634E", sshl(v1.h8(), v2.h8(), v3.h8())); + TEST_INSTRUCTION("4144A34E", sshl(v1.s4(), v2.s4(), v3.s4())); + TEST_INSTRUCTION("4144E34E", sshl(v1.d2(), v2.d2(), v3.d2())); + TEST_INSTRUCTION("41A40F0F", sshll(v1.h8(), v2.b8(), 7)); + TEST_INSTRUCTION("41A41F0F", sshll(v1.s4(), v2.h4(), 15)); + TEST_INSTRUCTION("41A43F0F", sshll(v1.d2(), v2.s2(), 31)); + TEST_INSTRUCTION("41A40F4F", sshll2(v1.h8(), v2.b16(), 7)); + TEST_INSTRUCTION("41A41F4F", sshll2(v1.s4(), v2.h8(), 15)); + TEST_INSTRUCTION("41A43F4F", sshll2(v1.s2(), v2.s4(), 31)); + TEST_INSTRUCTION("4104090F", sshr(v1.b8(), v2.b8(), 7)); + TEST_INSTRUCTION("4104110F", sshr(v1.h4(), v2.h4(), 15)); + TEST_INSTRUCTION("4104210F", sshr(v1.s2(), v2.s2(), 31)); + TEST_INSTRUCTION("4104415F", sshr(d1, d2, 63)); + TEST_INSTRUCTION("4104094F", sshr(v1.b16(), v2.b16(), 7)); + TEST_INSTRUCTION("4104114F", sshr(v1.h8(), v2.h8(), 15)); + TEST_INSTRUCTION("4104214F", sshr(v1.s4(), v2.s4(), 31)); + TEST_INSTRUCTION("4104414F", sshr(v1.d2(), v2.d2(), 63)); + TEST_INSTRUCTION("4114090F", ssra(v1.b8(), v2.b8(), 7)); + TEST_INSTRUCTION("4114110F", ssra(v1.h4(), v2.h4(), 15)); + TEST_INSTRUCTION("4114210F", ssra(v1.s2(), v2.s2(), 31)); + TEST_INSTRUCTION("4114415F", ssra(d1, d2, 63)); + TEST_INSTRUCTION("4114094F", ssra(v1.b16(), v2.b16(), 7)); + TEST_INSTRUCTION("4114114F", ssra(v1.h8(), v2.h8(), 15)); + TEST_INSTRUCTION("4114214F", ssra(v1.s4(), v2.s4(), 31)); + TEST_INSTRUCTION("4114414F", ssra(v1.d2(), v2.d2(), 63)); + TEST_INSTRUCTION("4120230E", ssubl(v1.h8(), v2.b8(), v3.b8())); + TEST_INSTRUCTION("4120630E", ssubl(v1.s4(), v2.h4(), v3.h4())); + TEST_INSTRUCTION("4120A30E", ssubl(v1.d2(), v2.s2(), v3.s2())); + TEST_INSTRUCTION("4120234E", ssubl2(v1.h8(), v2.b16(), v3.b16())); + TEST_INSTRUCTION("4120634E", ssubl2(v1.s4(), v2.h8(), v3.h8())); + TEST_INSTRUCTION("4120A34E", ssubl2(v1.d2(), v2.s4(), v3.s4())); + TEST_INSTRUCTION("4130230E", ssubw(v1.h8(), v2.h8(), v3.b8())); + TEST_INSTRUCTION("4130630E", ssubw(v1.s4(), v2.s4(), v3.h4())); + TEST_INSTRUCTION("4130A30E", ssubw(v1.d2(), v2.d2(), v3.s2())); + TEST_INSTRUCTION("4130234E", ssubw2(v1.h8(), v2.h8(), v3.b16())); + TEST_INSTRUCTION("4130634E", ssubw2(v1.s4(), v2.s4(), v3.h8())); + TEST_INSTRUCTION("4130A34E", ssubw2(v1.d2(), v2.d2(), v3.s4())); + TEST_INSTRUCTION("4100000D", st1(v1.b(0), ptr(x2))); + TEST_INSTRUCTION("41009F0D", st1(v1.b(0), ptr_post(x2, 1))); + TEST_INSTRUCTION("4140000D", st1(v1.h(0), ptr(x2))); + TEST_INSTRUCTION("41409F0D", st1(v1.h(0), ptr_post(x2, 2))); + TEST_INSTRUCTION("4180000D", st1(v1.s(0), ptr(x2))); + TEST_INSTRUCTION("41809F0D", st1(v1.s(0), ptr_post(x2, 4))); + TEST_INSTRUCTION("4184000D", st1(v1.d(0), ptr(x2))); + TEST_INSTRUCTION("41849F0D", st1(v1.d(0), ptr_post(x2, 8))); + TEST_INSTRUCTION("411C004D", st1(v1.b(15), ptr(x2))); + TEST_INSTRUCTION("411C9F4D", st1(v1.b(15), ptr_post(x2, 1))); + TEST_INSTRUCTION("4158004D", st1(v1.h(7), ptr(x2))); + TEST_INSTRUCTION("41589F4D", st1(v1.h(7), ptr_post(x2, 2))); + TEST_INSTRUCTION("4190004D", st1(v1.s(3), ptr(x2))); + TEST_INSTRUCTION("41909F4D", st1(v1.s(3), ptr_post(x2, 4))); + TEST_INSTRUCTION("4184004D", st1(v1.d(1), ptr(x2))); + TEST_INSTRUCTION("41849F4D", st1(v1.d(1), ptr_post(x2, 8))); + TEST_INSTRUCTION("4170000C", st1(v1.b8(), ptr(x2))); + TEST_INSTRUCTION("41709F0C", st1(v1.b8(), ptr_post(x2, 8))); + TEST_INSTRUCTION("4170004C", st1(v1.b16(), ptr(x2))); + TEST_INSTRUCTION("41709F4C", st1(v1.b16(), ptr_post(x2, 16))); + TEST_INSTRUCTION("61A0000C", st1(v1.b8(), v2.b8(), ptr(x3))); + TEST_INSTRUCTION("61A09F0C", st1(v1.b8(), v2.b8(), ptr_post(x3, 16))); + TEST_INSTRUCTION("61A0004C", st1(v1.b16(), v2.b16(), ptr(x3))); + TEST_INSTRUCTION("61A09F4C", st1(v1.b16(), v2.b16(), ptr_post(x3, 32))); + TEST_INSTRUCTION("8160000C", st1(v1.b8(), v2.b8(), v3.b8(), ptr(x4))); + TEST_INSTRUCTION("81609F0C", st1(v1.b8(), v2.b8(), v3.b8(), ptr_post(x4, 24))); + TEST_INSTRUCTION("8160004C", st1(v1.b16(), v2.b16(), v3.b16(), ptr(x4))); + TEST_INSTRUCTION("81609F4C", st1(v1.b16(), v2.b16(), v3.b16(), ptr_post(x4, 48))); + TEST_INSTRUCTION("A120000C", st1(v1.b8(), v2.b8(), v3.b8(), v4.b8(), ptr(x5))); + TEST_INSTRUCTION("A1209F0C", st1(v1.b8(), v2.b8(), v3.b8(), v4.b8(), ptr_post(x5, 32))); + TEST_INSTRUCTION("A120004C", st1(v1.b16(), v2.b16(), v3.b16(), v4.b16(), ptr(x5))); + TEST_INSTRUCTION("A1209F4C", st1(v1.b16(), v2.b16(), v3.b16(), v4.b16(), ptr_post(x5, 64))); + TEST_INSTRUCTION("4174000C", st1(v1.h4(), ptr(x2))); + TEST_INSTRUCTION("41749F0C", st1(v1.h4(), ptr_post(x2, 8))); + TEST_INSTRUCTION("4174004C", st1(v1.h8(), ptr(x2))); + TEST_INSTRUCTION("41749F4C", st1(v1.h8(), ptr_post(x2, 16))); + TEST_INSTRUCTION("61A4000C", st1(v1.h4(), v2.h4(), ptr(x3))); + TEST_INSTRUCTION("61A49F0C", st1(v1.h4(), v2.h4(), ptr_post(x3, 16))); + TEST_INSTRUCTION("61A4004C", st1(v1.h8(), v2.h8(), ptr(x3))); + TEST_INSTRUCTION("61A49F4C", st1(v1.h8(), v2.h8(), ptr_post(x3, 32))); + TEST_INSTRUCTION("8164000C", st1(v1.h4(), v2.h4(), v3.h4(), ptr(x4))); + TEST_INSTRUCTION("81649F0C", st1(v1.h4(), v2.h4(), v3.h4(), ptr_post(x4, 24))); + TEST_INSTRUCTION("8164004C", st1(v1.h8(), v2.h8(), v3.h8(), ptr(x4))); + TEST_INSTRUCTION("81649F4C", st1(v1.h8(), v2.h8(), v3.h8(), ptr_post(x4, 48))); + TEST_INSTRUCTION("A124000C", st1(v1.h4(), v2.h4(), v3.h4(), v4.h4(), ptr(x5))); + TEST_INSTRUCTION("A1249F0C", st1(v1.h4(), v2.h4(), v3.h4(), v4.h4(), ptr_post(x5, 32))); + TEST_INSTRUCTION("A124004C", st1(v1.h8(), v2.h8(), v3.h8(), v4.h8(), ptr(x5))); + TEST_INSTRUCTION("A1249F4C", st1(v1.h8(), v2.h8(), v3.h8(), v4.h8(), ptr_post(x5, 64))); + TEST_INSTRUCTION("4178000C", st1(v1.s2(), ptr(x2))); + TEST_INSTRUCTION("41789F0C", st1(v1.s2(), ptr_post(x2, 8))); + TEST_INSTRUCTION("4178004C", st1(v1.s4(), ptr(x2))); + TEST_INSTRUCTION("41789F4C", st1(v1.s4(), ptr_post(x2, 16))); + TEST_INSTRUCTION("61A8000C", st1(v1.s2(), v2.s2(), ptr(x3))); + TEST_INSTRUCTION("61A89F0C", st1(v1.s2(), v2.s2(), ptr_post(x3, 16))); + TEST_INSTRUCTION("61A8004C", st1(v1.s4(), v2.s4(), ptr(x3))); + TEST_INSTRUCTION("61A89F4C", st1(v1.s4(), v2.s4(), ptr_post(x3, 32))); + TEST_INSTRUCTION("8168000C", st1(v1.s2(), v2.s2(), v3.s2(), ptr(x4))); + TEST_INSTRUCTION("81689F0C", st1(v1.s2(), v2.s2(), v3.s2(), ptr_post(x4, 24))); + TEST_INSTRUCTION("8168004C", st1(v1.s4(), v2.s4(), v3.s4(), ptr(x4))); + TEST_INSTRUCTION("81689F4C", st1(v1.s4(), v2.s4(), v3.s4(), ptr_post(x4, 48))); + TEST_INSTRUCTION("A128000C", st1(v1.s2(), v2.s2(), v3.s2(), v4.s2(), ptr(x5))); + TEST_INSTRUCTION("A1289F0C", st1(v1.s2(), v2.s2(), v3.s2(), v4.s2(), ptr_post(x5, 32))); + TEST_INSTRUCTION("A128004C", st1(v1.s4(), v2.s4(), v3.s4(), v4.s4(), ptr(x5))); + TEST_INSTRUCTION("A1289F4C", st1(v1.s4(), v2.s4(), v3.s4(), v4.s4(), ptr_post(x5, 64))); + TEST_INSTRUCTION("417C004C", st1(v1.d2(), ptr(x2))); + TEST_INSTRUCTION("417C9F4C", st1(v1.d2(), ptr_post(x2, 16))); + TEST_INSTRUCTION("61AC004C", st1(v1.d2(), v2.d2(), ptr(x3))); + TEST_INSTRUCTION("61AC9F4C", st1(v1.d2(), v2.d2(), ptr_post(x3, 32))); + TEST_INSTRUCTION("816C004C", st1(v1.d2(), v2.d2(), v3.d2(), ptr(x4))); + TEST_INSTRUCTION("816C9F4C", st1(v1.d2(), v2.d2(), v3.d2(), ptr_post(x4, 48))); + TEST_INSTRUCTION("A12C004C", st1(v1.d2(), v2.d2(), v3.d2(), v4.d2(), ptr(x5))); + TEST_INSTRUCTION("A12C9F4C", st1(v1.d2(), v2.d2(), v3.d2(), v4.d2(), ptr_post(x5, 64))); + TEST_INSTRUCTION("6100200D", st2(v1.b(0), v2.b(0), ptr(x3))); + TEST_INSTRUCTION("6100BF0D", st2(v1.b(0), v2.b(0), ptr_post(x3, 2))); + TEST_INSTRUCTION("6100AB0D", st2(v1.b(0), v2.b(0), ptr_post(x3, x11))); + TEST_INSTRUCTION("6140200D", st2(v1.h(0), v2.h(0), ptr(x3))); + TEST_INSTRUCTION("6140BF0D", st2(v1.h(0), v2.h(0), ptr_post(x3, 4))); + TEST_INSTRUCTION("6140AB0D", st2(v1.h(0), v2.h(0), ptr_post(x3, x11))); + TEST_INSTRUCTION("6180200D", st2(v1.s(0), v2.s(0), ptr(x3))); + TEST_INSTRUCTION("6180BF0D", st2(v1.s(0), v2.s(0), ptr_post(x3, 8))); + TEST_INSTRUCTION("6180AB0D", st2(v1.s(0), v2.s(0), ptr_post(x3, x11))); + TEST_INSTRUCTION("6184200D", st2(v1.d(0), v2.d(0), ptr(x3))); + TEST_INSTRUCTION("6184BF0D", st2(v1.d(0), v2.d(0), ptr_post(x3, 16))); + TEST_INSTRUCTION("6184AB0D", st2(v1.d(0), v2.d(0), ptr_post(x3, x11))); + TEST_INSTRUCTION("611C204D", st2(v1.b(15), v2.b(15), ptr(x3))); + TEST_INSTRUCTION("611CBF4D", st2(v1.b(15), v2.b(15), ptr_post(x3, 2))); + TEST_INSTRUCTION("611CAB4D", st2(v1.b(15), v2.b(15), ptr_post(x3, x11))); + TEST_INSTRUCTION("6158204D", st2(v1.h(7), v2.h(7), ptr(x3))); + TEST_INSTRUCTION("6158BF4D", st2(v1.h(7), v2.h(7), ptr_post(x3, 4))); + TEST_INSTRUCTION("6158AB4D", st2(v1.h(7), v2.h(7), ptr_post(x3, x11))); + TEST_INSTRUCTION("6190204D", st2(v1.s(3), v2.s(3), ptr(x3))); + TEST_INSTRUCTION("6190BF4D", st2(v1.s(3), v2.s(3), ptr_post(x3, 8))); + TEST_INSTRUCTION("6190AB4D", st2(v1.s(3), v2.s(3), ptr_post(x3, x11))); + TEST_INSTRUCTION("6184204D", st2(v1.d(1), v2.d(1), ptr(x3))); + TEST_INSTRUCTION("6184BF4D", st2(v1.d(1), v2.d(1), ptr_post(x3, 16))); + TEST_INSTRUCTION("6184AB4D", st2(v1.d(1), v2.d(1), ptr_post(x3, x11))); + TEST_INSTRUCTION("6180000C", st2(v1.b8(), v2.b8(), ptr(x3))); + TEST_INSTRUCTION("61809F0C", st2(v1.b8(), v2.b8(), ptr_post(x3, 16))); + TEST_INSTRUCTION("61808B0C", st2(v1.b8(), v2.b8(), ptr_post(x3, x11))); + TEST_INSTRUCTION("6180004C", st2(v1.b16(), v2.b16(), ptr(x3))); + TEST_INSTRUCTION("61809F4C", st2(v1.b16(), v2.b16(), ptr_post(x3, 32))); + TEST_INSTRUCTION("61808B4C", st2(v1.b16(), v2.b16(), ptr_post(x3, x11))); + TEST_INSTRUCTION("6184000C", st2(v1.h4(), v2.h4(), ptr(x3))); + TEST_INSTRUCTION("61849F0C", st2(v1.h4(), v2.h4(), ptr_post(x3, 16))); + TEST_INSTRUCTION("61848B0C", st2(v1.h4(), v2.h4(), ptr_post(x3, x11))); + TEST_INSTRUCTION("6184004C", st2(v1.h8(), v2.h8(), ptr(x3))); + TEST_INSTRUCTION("61849F4C", st2(v1.h8(), v2.h8(), ptr_post(x3, 32))); + TEST_INSTRUCTION("61848B4C", st2(v1.h8(), v2.h8(), ptr_post(x3, x11))); + TEST_INSTRUCTION("6188000C", st2(v1.s2(), v2.s2(), ptr(x3))); + TEST_INSTRUCTION("61889F0C", st2(v1.s2(), v2.s2(), ptr_post(x3, 16))); + TEST_INSTRUCTION("61888B0C", st2(v1.s2(), v2.s2(), ptr_post(x3, x11))); + TEST_INSTRUCTION("6188004C", st2(v1.s4(), v2.s4(), ptr(x3))); + TEST_INSTRUCTION("61889F4C", st2(v1.s4(), v2.s4(), ptr_post(x3, 32))); + TEST_INSTRUCTION("61888B4C", st2(v1.s4(), v2.s4(), ptr_post(x3, x11))); + TEST_INSTRUCTION("618C004C", st2(v1.d2(), v2.d2(), ptr(x3))); + TEST_INSTRUCTION("618C9F4C", st2(v1.d2(), v2.d2(), ptr_post(x3, 32))); + TEST_INSTRUCTION("618C8B4C", st2(v1.d2(), v2.d2(), ptr_post(x3, x11))); + TEST_INSTRUCTION("8120000D", st3(v1.b(0), v2.b(0), v3.b(0), ptr(x4))); + TEST_INSTRUCTION("81209F0D", st3(v1.b(0), v2.b(0), v3.b(0), ptr_post(x4, 3))); + TEST_INSTRUCTION("81208B0D", st3(v1.b(0), v2.b(0), v3.b(0), ptr_post(x4, x11))); + TEST_INSTRUCTION("8160000D", st3(v1.h(0), v2.h(0), v3.h(0), ptr(x4))); + TEST_INSTRUCTION("81609F0D", st3(v1.h(0), v2.h(0), v3.h(0), ptr_post(x4, 6))); + TEST_INSTRUCTION("81608B0D", st3(v1.h(0), v2.h(0), v3.h(0), ptr_post(x4, x11))); + TEST_INSTRUCTION("81A0000D", st3(v1.s(0), v2.s(0), v3.s(0), ptr(x4))); + TEST_INSTRUCTION("81A09F0D", st3(v1.s(0), v2.s(0), v3.s(0), ptr_post(x4, 12))); + TEST_INSTRUCTION("81A08B0D", st3(v1.s(0), v2.s(0), v3.s(0), ptr_post(x4, x11))); + TEST_INSTRUCTION("81A4000D", st3(v1.d(0), v2.d(0), v3.d(0), ptr(x4))); + TEST_INSTRUCTION("81A49F0D", st3(v1.d(0), v2.d(0), v3.d(0), ptr_post(x4, 24))); + TEST_INSTRUCTION("81A48B0D", st3(v1.d(0), v2.d(0), v3.d(0), ptr_post(x4, x11))); + TEST_INSTRUCTION("813C004D", st3(v1.b(15), v2.b(15), v3.b(15), ptr(x4))); + TEST_INSTRUCTION("813C9F4D", st3(v1.b(15), v2.b(15), v3.b(15), ptr_post(x4, 3))); + TEST_INSTRUCTION("813C8B4D", st3(v1.b(15), v2.b(15), v3.b(15), ptr_post(x4, x11))); + TEST_INSTRUCTION("8178004D", st3(v1.h(7), v2.h(7), v3.h(7), ptr(x4))); + TEST_INSTRUCTION("81789F4D", st3(v1.h(7), v2.h(7), v3.h(7), ptr_post(x4, 6))); + TEST_INSTRUCTION("81788B4D", st3(v1.h(7), v2.h(7), v3.h(7), ptr_post(x4, x11))); + TEST_INSTRUCTION("81B0004D", st3(v1.s(3), v2.s(3), v3.s(3), ptr(x4))); + TEST_INSTRUCTION("81B09F4D", st3(v1.s(3), v2.s(3), v3.s(3), ptr_post(x4, 12))); + TEST_INSTRUCTION("81B08B4D", st3(v1.s(3), v2.s(3), v3.s(3), ptr_post(x4, x11))); + TEST_INSTRUCTION("81A4004D", st3(v1.d(1), v2.d(1), v3.d(1), ptr(x4))); + TEST_INSTRUCTION("81A49F4D", st3(v1.d(1), v2.d(1), v3.d(1), ptr_post(x4, 24))); + TEST_INSTRUCTION("81A48B4D", st3(v1.d(1), v2.d(1), v3.d(1), ptr_post(x4, x11))); + TEST_INSTRUCTION("8140000C", st3(v1.b8(), v2.b8(), v3.b8(), ptr(x4))); + TEST_INSTRUCTION("81409F0C", st3(v1.b8(), v2.b8(), v3.b8(), ptr_post(x4, 24))); + TEST_INSTRUCTION("81408B0C", st3(v1.b8(), v2.b8(), v3.b8(), ptr_post(x4, x11))); + TEST_INSTRUCTION("8140004C", st3(v1.b16(), v2.b16(), v3.b16(), ptr(x4))); + TEST_INSTRUCTION("81409F4C", st3(v1.b16(), v2.b16(), v3.b16(), ptr_post(x4, 48))); + TEST_INSTRUCTION("81408B4C", st3(v1.b16(), v2.b16(), v3.b16(), ptr_post(x4, x11))); + TEST_INSTRUCTION("8144000C", st3(v1.h4(), v2.h4(), v3.h4(), ptr(x4))); + TEST_INSTRUCTION("81449F0C", st3(v1.h4(), v2.h4(), v3.h4(), ptr_post(x4, 24))); + TEST_INSTRUCTION("81448B0C", st3(v1.h4(), v2.h4(), v3.h4(), ptr_post(x4, x11))); + TEST_INSTRUCTION("8144004C", st3(v1.h8(), v2.h8(), v3.h8(), ptr(x4))); + TEST_INSTRUCTION("81449F4C", st3(v1.h8(), v2.h8(), v3.h8(), ptr_post(x4, 48))); + TEST_INSTRUCTION("81448B4C", st3(v1.h8(), v2.h8(), v3.h8(), ptr_post(x4, x11))); + TEST_INSTRUCTION("8148000C", st3(v1.s2(), v2.s2(), v3.s2(), ptr(x4))); + TEST_INSTRUCTION("81489F0C", st3(v1.s2(), v2.s2(), v3.s2(), ptr_post(x4, 24))); + TEST_INSTRUCTION("81488B0C", st3(v1.s2(), v2.s2(), v3.s2(), ptr_post(x4, x11))); + TEST_INSTRUCTION("8148004C", st3(v1.s4(), v2.s4(), v3.s4(), ptr(x4))); + TEST_INSTRUCTION("81489F4C", st3(v1.s4(), v2.s4(), v3.s4(), ptr_post(x4, 48))); + TEST_INSTRUCTION("81488B4C", st3(v1.s4(), v2.s4(), v3.s4(), ptr_post(x4, x11))); + TEST_INSTRUCTION("814C004C", st3(v1.d2(), v2.d2(), v3.d2(), ptr(x4))); + TEST_INSTRUCTION("814C9F4C", st3(v1.d2(), v2.d2(), v3.d2(), ptr_post(x4, 48))); + TEST_INSTRUCTION("814C8B4C", st3(v1.d2(), v2.d2(), v3.d2(), ptr_post(x4, x11))); + TEST_INSTRUCTION("A120200D", st4(v1.b(0), v2.b(0), v3.b(0), v4.b(0), ptr(x5))); + TEST_INSTRUCTION("A120BF0D", st4(v1.b(0), v2.b(0), v3.b(0), v4.b(0), ptr_post(x5, 4))); + TEST_INSTRUCTION("A120AB0D", st4(v1.b(0), v2.b(0), v3.b(0), v4.b(0), ptr_post(x5, x11))); + TEST_INSTRUCTION("A160200D", st4(v1.h(0), v2.h(0), v3.h(0), v4.h(0), ptr(x5))); + TEST_INSTRUCTION("A160BF0D", st4(v1.h(0), v2.h(0), v3.h(0), v4.h(0), ptr_post(x5, 8))); + TEST_INSTRUCTION("A160AB0D", st4(v1.h(0), v2.h(0), v3.h(0), v4.h(0), ptr_post(x5, x11))); + TEST_INSTRUCTION("A1A0200D", st4(v1.s(0), v2.s(0), v3.s(0), v4.s(0), ptr(x5))); + TEST_INSTRUCTION("A1A0BF0D", st4(v1.s(0), v2.s(0), v3.s(0), v4.s(0), ptr_post(x5, 16))); + TEST_INSTRUCTION("A1A0AB0D", st4(v1.s(0), v2.s(0), v3.s(0), v4.s(0), ptr_post(x5, x11))); + TEST_INSTRUCTION("A1A4200D", st4(v1.d(0), v2.d(0), v3.d(0), v4.d(0), ptr(x5))); + TEST_INSTRUCTION("A1A4BF0D", st4(v1.d(0), v2.d(0), v3.d(0), v4.d(0), ptr_post(x5, 32))); + TEST_INSTRUCTION("A1A4AB0D", st4(v1.d(0), v2.d(0), v3.d(0), v4.d(0), ptr_post(x5, x11))); + TEST_INSTRUCTION("A13C204D", st4(v1.b(15), v2.b(15), v3.b(15), v4.b(15), ptr(x5))); + TEST_INSTRUCTION("A13CBF4D", st4(v1.b(15), v2.b(15), v3.b(15), v4.b(15), ptr_post(x5, 4))); + TEST_INSTRUCTION("A13CAB4D", st4(v1.b(15), v2.b(15), v3.b(15), v4.b(15), ptr_post(x5, x11))); + TEST_INSTRUCTION("A178204D", st4(v1.h(7), v2.h(7), v3.h(7), v4.h(7), ptr(x5))); + TEST_INSTRUCTION("A178BF4D", st4(v1.h(7), v2.h(7), v3.h(7), v4.h(7), ptr_post(x5, 8))); + TEST_INSTRUCTION("A178AB4D", st4(v1.h(7), v2.h(7), v3.h(7), v4.h(7), ptr_post(x5, x11))); + TEST_INSTRUCTION("A1B0204D", st4(v1.s(3), v2.s(3), v3.s(3), v4.s(3), ptr(x5))); + TEST_INSTRUCTION("A1B0BF4D", st4(v1.s(3), v2.s(3), v3.s(3), v4.s(3), ptr_post(x5, 16))); + TEST_INSTRUCTION("A1B0AB4D", st4(v1.s(3), v2.s(3), v3.s(3), v4.s(3), ptr_post(x5, x11))); + TEST_INSTRUCTION("A1A4204D", st4(v1.d(1), v2.d(1), v3.d(1), v4.d(1), ptr(x5))); + TEST_INSTRUCTION("A1A4BF4D", st4(v1.d(1), v2.d(1), v3.d(1), v4.d(1), ptr_post(x5, 32))); + TEST_INSTRUCTION("A1A4AB4D", st4(v1.d(1), v2.d(1), v3.d(1), v4.d(1), ptr_post(x5, x11))); + TEST_INSTRUCTION("A100000C", st4(v1.b8(), v2.b8(), v3.b8(), v4.b8(), ptr(x5))); + TEST_INSTRUCTION("A1009F0C", st4(v1.b8(), v2.b8(), v3.b8(), v4.b8(), ptr_post(x5, 32))); + TEST_INSTRUCTION("A1008B0C", st4(v1.b8(), v2.b8(), v3.b8(), v4.b8(), ptr_post(x5, x11))); + TEST_INSTRUCTION("A100004C", st4(v1.b16(), v2.b16(), v3.b16(), v4.b16(), ptr(x5))); + TEST_INSTRUCTION("A1009F4C", st4(v1.b16(), v2.b16(), v3.b16(), v4.b16(), ptr_post(x5, 64))); + TEST_INSTRUCTION("A1008B4C", st4(v1.b16(), v2.b16(), v3.b16(), v4.b16(), ptr_post(x5, x11))); + TEST_INSTRUCTION("A104000C", st4(v1.h4(), v2.h4(), v3.h4(), v4.h4(), ptr(x5))); + TEST_INSTRUCTION("A1049F0C", st4(v1.h4(), v2.h4(), v3.h4(), v4.h4(), ptr_post(x5, 32))); + TEST_INSTRUCTION("A1048B0C", st4(v1.h4(), v2.h4(), v3.h4(), v4.h4(), ptr_post(x5, x11))); + TEST_INSTRUCTION("A104004C", st4(v1.h8(), v2.h8(), v3.h8(), v4.h8(), ptr(x5))); + TEST_INSTRUCTION("A1049F4C", st4(v1.h8(), v2.h8(), v3.h8(), v4.h8(), ptr_post(x5, 64))); + TEST_INSTRUCTION("A1048B4C", st4(v1.h8(), v2.h8(), v3.h8(), v4.h8(), ptr_post(x5, x11))); + TEST_INSTRUCTION("A108000C", st4(v1.s2(), v2.s2(), v3.s2(), v4.s2(), ptr(x5))); + TEST_INSTRUCTION("A1089F0C", st4(v1.s2(), v2.s2(), v3.s2(), v4.s2(), ptr_post(x5, 32))); + TEST_INSTRUCTION("A1088B0C", st4(v1.s2(), v2.s2(), v3.s2(), v4.s2(), ptr_post(x5, x11))); + TEST_INSTRUCTION("A108004C", st4(v1.s4(), v2.s4(), v3.s4(), v4.s4(), ptr(x5))); + TEST_INSTRUCTION("A1089F4C", st4(v1.s4(), v2.s4(), v3.s4(), v4.s4(), ptr_post(x5, 64))); + TEST_INSTRUCTION("A1088B4C", st4(v1.s4(), v2.s4(), v3.s4(), v4.s4(), ptr_post(x5, x11))); + TEST_INSTRUCTION("A10C004C", st4(v1.d2(), v2.d2(), v3.d2(), v4.d2(), ptr(x5))); + TEST_INSTRUCTION("A10C9F4C", st4(v1.d2(), v2.d2(), v3.d2(), v4.d2(), ptr_post(x5, 64))); + TEST_INSTRUCTION("A10C8B4C", st4(v1.d2(), v2.d2(), v3.d2(), v4.d2(), ptr_post(x5, x11))); + TEST_INSTRUCTION("8109002C", stnp(s1, s2, ptr(x12))); + TEST_INSTRUCTION("8189002C", stnp(s1, s2, ptr(x12, 4))); + TEST_INSTRUCTION("8109302C", stnp(s1, s2, ptr(x12, -128))); + TEST_INSTRUCTION("E10B002C", stnp(s1, s2, ptr(sp))); + TEST_INSTRUCTION("E18B002C", stnp(s1, s2, ptr(sp, 4))); + TEST_INSTRUCTION("E10B102C", stnp(s1, s2, ptr(sp, 128))); + TEST_INSTRUCTION("8109006C", stnp(d1, d2, ptr(x12))); + TEST_INSTRUCTION("8189006C", stnp(d1, d2, ptr(x12, 8))); + TEST_INSTRUCTION("8109386C", stnp(d1, d2, ptr(x12, -128))); + TEST_INSTRUCTION("E10B006C", stnp(d1, d2, ptr(sp))); + TEST_INSTRUCTION("E18B006C", stnp(d1, d2, ptr(sp, 8))); + TEST_INSTRUCTION("E10B086C", stnp(d1, d2, ptr(sp, 128))); + TEST_INSTRUCTION("810900AC", stnp(q1, q2, ptr(x12))); + TEST_INSTRUCTION("818900AC", stnp(q1, q2, ptr(x12, 16))); + TEST_INSTRUCTION("81093CAC", stnp(q1, q2, ptr(x12, -128))); + TEST_INSTRUCTION("E10B00AC", stnp(q1, q2, ptr(sp))); + TEST_INSTRUCTION("E18B00AC", stnp(q1, q2, ptr(sp, 16))); + TEST_INSTRUCTION("E10B04AC", stnp(q1, q2, ptr(sp, 128))); + TEST_INSTRUCTION("8109002D", stp(s1, s2, ptr(x12))); + TEST_INSTRUCTION("8189002D", stp(s1, s2, ptr(x12, 4))); + TEST_INSTRUCTION("8109302D", stp(s1, s2, ptr(x12, -128))); + TEST_INSTRUCTION("8189802D", stp(s1, s2, ptr_pre(x12, 4))); + TEST_INSTRUCTION("8189802C", stp(s1, s2, ptr_post(x12, 4))); + TEST_INSTRUCTION("E10B002D", stp(s1, s2, ptr(sp))); + TEST_INSTRUCTION("E18B002D", stp(s1, s2, ptr(sp, 4))); + TEST_INSTRUCTION("E10B102D", stp(s1, s2, ptr(sp, 128))); + TEST_INSTRUCTION("E18B802D", stp(s1, s2, ptr_pre(sp, 4))); + TEST_INSTRUCTION("E18B802C", stp(s1, s2, ptr_post(sp, 4))); + TEST_INSTRUCTION("8109006D", stp(d1, d2, ptr(x12))); + TEST_INSTRUCTION("8189006D", stp(d1, d2, ptr(x12, 8))); + TEST_INSTRUCTION("8109386D", stp(d1, d2, ptr(x12, -128))); + TEST_INSTRUCTION("8189806D", stp(d1, d2, ptr_pre(x12, 8))); + TEST_INSTRUCTION("8189806C", stp(d1, d2, ptr_post(x12, 8))); + TEST_INSTRUCTION("E10B006D", stp(d1, d2, ptr(sp))); + TEST_INSTRUCTION("E18B006D", stp(d1, d2, ptr(sp, 8))); + TEST_INSTRUCTION("E10B086D", stp(d1, d2, ptr(sp, 128))); + TEST_INSTRUCTION("E18B806D", stp(d1, d2, ptr_pre(sp, 8))); + TEST_INSTRUCTION("E18B806C", stp(d1, d2, ptr_post(sp, 8))); + TEST_INSTRUCTION("810900AD", stp(q1, q2, ptr(x12))); + TEST_INSTRUCTION("818900AD", stp(q1, q2, ptr(x12, 16))); + TEST_INSTRUCTION("81093CAD", stp(q1, q2, ptr(x12, -128))); + TEST_INSTRUCTION("818980AD", stp(q1, q2, ptr_pre(x12, 16))); + TEST_INSTRUCTION("818980AC", stp(q1, q2, ptr_post(x12, 16))); + TEST_INSTRUCTION("E10B00AD", stp(q1, q2, ptr(sp))); + TEST_INSTRUCTION("E18B00AD", stp(q1, q2, ptr(sp, 16))); + TEST_INSTRUCTION("E10B04AD", stp(q1, q2, ptr(sp, 128))); + TEST_INSTRUCTION("E18B80AD", stp(q1, q2, ptr_pre(sp, 16))); + TEST_INSTRUCTION("E18B80AC", stp(q1, q2, ptr_post(sp, 16))); + TEST_INSTRUCTION("4100003D", str(b1, ptr(x2))); + TEST_INSTRUCTION("4114003C", str(b1, ptr_post(x2, 1))); + TEST_INSTRUCTION("4104003D", str(b1, ptr(x2, 1))); + TEST_INSTRUCTION("411C003C", str(b1, ptr_pre(x2, 1))); + TEST_INSTRUCTION("4114083C", str(b1, ptr_post(x2, 129))); + TEST_INSTRUCTION("4100007D", str(h1, ptr(x2))); + TEST_INSTRUCTION("4124007C", str(h1, ptr_post(x2, 2))); + TEST_INSTRUCTION("4104007D", str(h1, ptr(x2, 2))); + TEST_INSTRUCTION("412C007C", str(h1, ptr_pre(x2, 2))); + TEST_INSTRUCTION("4124087C", str(h1, ptr_post(x2, 130))); + TEST_INSTRUCTION("410000BD", str(s1, ptr(x2))); + TEST_INSTRUCTION("414400BC", str(s1, ptr_post(x2, 4))); + TEST_INSTRUCTION("410400BD", str(s1, ptr(x2, 4))); + TEST_INSTRUCTION("414C00BC", str(s1, ptr_pre(x2, 4))); + TEST_INSTRUCTION("414408BC", str(s1, ptr_post(x2, 132))); + TEST_INSTRUCTION("410000FD", str(d1, ptr(x2))); + TEST_INSTRUCTION("418400FC", str(d1, ptr_post(x2, 8))); + TEST_INSTRUCTION("410400FD", str(d1, ptr(x2, 8))); + TEST_INSTRUCTION("418C00FC", str(d1, ptr_pre(x2, 8))); + TEST_INSTRUCTION("414408FC", str(d1, ptr_post(x2, 132))); + TEST_INSTRUCTION("4168233C", str(b1, ptr(x2, x3))); + TEST_INSTRUCTION("4148233C", str(b1, ptr(x2, w3, uxtw(0)))); + TEST_INSTRUCTION("41C8233C", str(b1, ptr(x2, w3, sxtw(0)))); + TEST_INSTRUCTION("4168237C", str(h1, ptr(x2, x3))); + TEST_INSTRUCTION("4178237C", str(h1, ptr(x2, x3, lsl(1)))); + TEST_INSTRUCTION("4148237C", str(h1, ptr(x2, w3, uxtw(0)))); + TEST_INSTRUCTION("4158237C", str(h1, ptr(x2, w3, uxtw(1)))); + TEST_INSTRUCTION("41C8237C", str(h1, ptr(x2, w3, sxtw(0)))); + TEST_INSTRUCTION("41D8237C", str(h1, ptr(x2, w3, sxtw(1)))); + TEST_INSTRUCTION("416823BC", str(s1, ptr(x2, x3))); + TEST_INSTRUCTION("417823BC", str(s1, ptr(x2, x3, lsl(2)))); + TEST_INSTRUCTION("414823BC", str(s1, ptr(x2, w3, uxtw(0)))); + TEST_INSTRUCTION("415823BC", str(s1, ptr(x2, w3, uxtw(2)))); + TEST_INSTRUCTION("41C823BC", str(s1, ptr(x2, w3, sxtw(0)))); + TEST_INSTRUCTION("41D823BC", str(s1, ptr(x2, w3, sxtw(2)))); + TEST_INSTRUCTION("416823FC", str(d1, ptr(x2, x3))); + TEST_INSTRUCTION("417823FC", str(d1, ptr(x2, x3, lsl(3)))); + TEST_INSTRUCTION("414823FC", str(d1, ptr(x2, w3, uxtw(0)))); + TEST_INSTRUCTION("415823FC", str(d1, ptr(x2, w3, uxtw(3)))); + TEST_INSTRUCTION("41C823FC", str(d1, ptr(x2, w3, sxtw(0)))); + TEST_INSTRUCTION("41D823FC", str(d1, ptr(x2, w3, sxtw(3)))); + TEST_INSTRUCTION("4104003D", str(b1, ptr(x2, 1))); + TEST_INSTRUCTION("41F01F3C", str(b1, ptr(x2, -1))); // STUR + TEST_INSTRUCTION("4110007C", str(h1, ptr(x2, 1))); // STUR + TEST_INSTRUCTION("41F01F7C", str(h1, ptr(x2, -1))); // STUR + TEST_INSTRUCTION("411000BC", str(s1, ptr(x2, 1))); // STUR + TEST_INSTRUCTION("41F01FBC", str(s1, ptr(x2, -1))); // STUR + TEST_INSTRUCTION("411000FC", str(d1, ptr(x2, 1))); // STUR + TEST_INSTRUCTION("41F01FFC", str(d1, ptr(x2, -1))); // STUR + TEST_INSTRUCTION("8101003C", stur(b1, ptr(x12))); + TEST_INSTRUCTION("8131003C", stur(b1, ptr(x12, 3))); + TEST_INSTRUCTION("8131063C", stur(b1, ptr(x12, 99))); + TEST_INSTRUCTION("81F10F3C", stur(b1, ptr(x12, 255))); + TEST_INSTRUCTION("8101103C", stur(b1, ptr(x12, -256))); + TEST_INSTRUCTION("E103003C", stur(b1, ptr(sp))); + TEST_INSTRUCTION("E153083C", stur(b1, ptr(sp, 133))); + TEST_INSTRUCTION("8101007C", stur(h1, ptr(x12))); + TEST_INSTRUCTION("8131007C", stur(h1, ptr(x12, 3))); + TEST_INSTRUCTION("8131067C", stur(h1, ptr(x12, 99))); + TEST_INSTRUCTION("81F10F7C", stur(h1, ptr(x12, 255))); + TEST_INSTRUCTION("8101107C", stur(h1, ptr(x12, -256))); + TEST_INSTRUCTION("E103007C", stur(h1, ptr(sp))); + TEST_INSTRUCTION("E153087C", stur(h1, ptr(sp, 133))); + TEST_INSTRUCTION("810100BC", stur(s1, ptr(x12))); + TEST_INSTRUCTION("813100BC", stur(s1, ptr(x12, 3))); + TEST_INSTRUCTION("813106BC", stur(s1, ptr(x12, 99))); + TEST_INSTRUCTION("81F10FBC", stur(s1, ptr(x12, 255))); + TEST_INSTRUCTION("810110BC", stur(s1, ptr(x12, -256))); + TEST_INSTRUCTION("E10300BC", stur(s1, ptr(sp))); + TEST_INSTRUCTION("E15308BC", stur(s1, ptr(sp, 133))); + TEST_INSTRUCTION("810100FC", stur(d1, ptr(x12))); + TEST_INSTRUCTION("813100FC", stur(d1, ptr(x12, 3))); + TEST_INSTRUCTION("813106FC", stur(d1, ptr(x12, 99))); + TEST_INSTRUCTION("81F10FFC", stur(d1, ptr(x12, 255))); + TEST_INSTRUCTION("810110FC", stur(d1, ptr(x12, -256))); + TEST_INSTRUCTION("E10300FC", stur(d1, ptr(sp))); + TEST_INSTRUCTION("E15308FC", stur(d1, ptr(sp, 133))); + TEST_INSTRUCTION("8101803C", stur(q1, ptr(x12))); + TEST_INSTRUCTION("8131803C", stur(q1, ptr(x12, 3))); + TEST_INSTRUCTION("8131863C", stur(q1, ptr(x12, 99))); + TEST_INSTRUCTION("81F18F3C", stur(q1, ptr(x12, 255))); + TEST_INSTRUCTION("8101903C", stur(q1, ptr(x12, -256))); + TEST_INSTRUCTION("E103803C", stur(q1, ptr(sp))); + TEST_INSTRUCTION("E153883C", stur(q1, ptr(sp, 133))); + TEST_INSTRUCTION("4184232E", sub(v1.b8(), v2.b8(), v3.b8())); + TEST_INSTRUCTION("4184632E", sub(v1.h4(), v2.h4(), v3.h4())); + TEST_INSTRUCTION("4184A32E", sub(v1.s2(), v2.s2(), v3.s2())); + TEST_INSTRUCTION("4184E37E", sub(d1, d2, d3)); + TEST_INSTRUCTION("4184236E", sub(v1.b16(), v2.b16(), v3.b16())); + TEST_INSTRUCTION("4184636E", sub(v1.h8(), v2.h8(), v3.h8())); + TEST_INSTRUCTION("4184A36E", sub(v1.s4(), v2.s4(), v3.s4())); + TEST_INSTRUCTION("4184E36E", sub(v1.d2(), v2.d2(), v3.d2())); + TEST_INSTRUCTION("4160230E", subhn(v1.b8(), v2.h8(), v3.h8())); + TEST_INSTRUCTION("4160630E", subhn(v1.h4(), v2.s4(), v3.s4())); + TEST_INSTRUCTION("4160A30E", subhn(v1.s2(), v2.d2(), v3.d2())); + TEST_INSTRUCTION("4160234E", subhn2(v1.b16(), v2.h8(), v3.h8())); + TEST_INSTRUCTION("4160634E", subhn2(v1.h8(), v2.s4(), v3.s4())); + TEST_INSTRUCTION("4160A34E", subhn2(v1.s4(), v2.d2(), v3.d2())); + TEST_INSTRUCTION("41F0030F", sudot(v1.s2(), v2.b8(), v3.b4(0))); + TEST_INSTRUCTION("41F0230F", sudot(v1.s2(), v2.b8(), v3.b4(1))); + TEST_INSTRUCTION("41F8030F", sudot(v1.s2(), v2.b8(), v3.b4(2))); + TEST_INSTRUCTION("41F8230F", sudot(v1.s2(), v2.b8(), v3.b4(3))); + TEST_INSTRUCTION("41F0034F", sudot(v1.s4(), v2.b16(), v3.b4(0))); + TEST_INSTRUCTION("41F0234F", sudot(v1.s4(), v2.b16(), v3.b4(1))); + TEST_INSTRUCTION("41F8034F", sudot(v1.s4(), v2.b16(), v3.b4(2))); + TEST_INSTRUCTION("41F8234F", sudot(v1.s4(), v2.b16(), v3.b4(3))); + TEST_INSTRUCTION("4138205E", suqadd(b1, b2)); + TEST_INSTRUCTION("4138605E", suqadd(h1, h2)); + TEST_INSTRUCTION("4138A05E", suqadd(s1, s2)); + TEST_INSTRUCTION("4138E05E", suqadd(d1, d2)); + TEST_INSTRUCTION("4138200E", suqadd(v1.b8(), v2.b8())); + TEST_INSTRUCTION("4138600E", suqadd(v1.h4(), v2.h4())); + TEST_INSTRUCTION("4138A00E", suqadd(v1.s2(), v2.s2())); + TEST_INSTRUCTION("4138204E", suqadd(v1.b16(), v2.b16())); + TEST_INSTRUCTION("4138604E", suqadd(v1.h8(), v2.h8())); + TEST_INSTRUCTION("4138A04E", suqadd(v1.s4(), v2.s4())); + TEST_INSTRUCTION("4138E04E", suqadd(v1.d2(), v2.d2())); + TEST_INSTRUCTION("41A4080F", sxtl(v1.h8(), v2.b8())); + TEST_INSTRUCTION("41A4100F", sxtl(v1.s4(), v2.h4())); + TEST_INSTRUCTION("41A4200F", sxtl(v1.d2(), v2.s2())); + TEST_INSTRUCTION("41A4084F", sxtl2(v1.h8(), v2.b16())); + TEST_INSTRUCTION("41A4104F", sxtl2(v1.s4(), v2.h8())); + TEST_INSTRUCTION("41A4204F", sxtl2(v1.d2(), v2.s4())); + TEST_INSTRUCTION("4100030E", tbl(v1.b8(), v2.b16(), v3.b8())); + TEST_INSTRUCTION("4120040E", tbl(v1.b8(), v2.b16(), v3.b16(), v4.b8())); + TEST_INSTRUCTION("4140050E", tbl(v1.b8(), v2.b16(), v3.b16(), v4.b16(), v5.b8())); + TEST_INSTRUCTION("4160060E", tbl(v1.b8(), v2.b16(), v3.b16(), v4.b16(), v5.b16(), v6.b8())); + TEST_INSTRUCTION("4100034E", tbl(v1.b16(), v2.b16(), v3.b16())); + TEST_INSTRUCTION("4120044E", tbl(v1.b16(), v2.b16(), v3.b16(), v4.b16())); + TEST_INSTRUCTION("4140054E", tbl(v1.b16(), v2.b16(), v3.b16(), v4.b16(), v5.b16())); + TEST_INSTRUCTION("4160064E", tbl(v1.b16(), v2.b16(), v3.b16(), v4.b16(), v5.b16(), v6.b16())); + TEST_INSTRUCTION("4110030E", tbx(v1.b8(), v2.b16(), v3.b8())); + TEST_INSTRUCTION("4130040E", tbx(v1.b8(), v2.b16(), v3.b16(), v4.b8())); + TEST_INSTRUCTION("4150050E", tbx(v1.b8(), v2.b16(), v3.b16(), v4.b16(), v5.b8())); + TEST_INSTRUCTION("4170060E", tbx(v1.b8(), v2.b16(), v3.b16(), v4.b16(), v5.b16(), v6.b8())); + TEST_INSTRUCTION("4110034E", tbx(v1.b16(), v2.b16(), v3.b16())); + TEST_INSTRUCTION("4130044E", tbx(v1.b16(), v2.b16(), v3.b16(), v4.b16())); + TEST_INSTRUCTION("4150054E", tbx(v1.b16(), v2.b16(), v3.b16(), v4.b16(), v5.b16())); + TEST_INSTRUCTION("4170064E", tbx(v1.b16(), v2.b16(), v3.b16(), v4.b16(), v5.b16(), v6.b16())); + TEST_INSTRUCTION("4128030E", trn1(v1.b8(), v2.b8(), v3.b8())); + TEST_INSTRUCTION("4128430E", trn1(v1.h4(), v2.h4(), v3.h4())); + TEST_INSTRUCTION("4128830E", trn1(v1.s2(), v2.s2(), v3.s2())); + TEST_INSTRUCTION("4128034E", trn1(v1.b16(), v2.b16(), v3.b16())); + TEST_INSTRUCTION("4128434E", trn1(v1.h8(), v2.h8(), v3.h8())); + TEST_INSTRUCTION("4128834E", trn1(v1.s4(), v2.s4(), v3.s4())); + TEST_INSTRUCTION("4128C34E", trn1(v1.d2(), v2.d2(), v3.d2())); + TEST_INSTRUCTION("4168030E", trn2(v1.b8(), v2.b8(), v3.b8())); + TEST_INSTRUCTION("4168430E", trn2(v1.h4(), v2.h4(), v3.h4())); + TEST_INSTRUCTION("4168830E", trn2(v1.s2(), v2.s2(), v3.s2())); + TEST_INSTRUCTION("4168034E", trn2(v1.b16(), v2.b16(), v3.b16())); + TEST_INSTRUCTION("4168434E", trn2(v1.h8(), v2.h8(), v3.h8())); + TEST_INSTRUCTION("4168834E", trn2(v1.s4(), v2.s4(), v3.s4())); + TEST_INSTRUCTION("4168C34E", trn2(v1.d2(), v2.d2(), v3.d2())); + TEST_INSTRUCTION("417C232E", uaba(v1.b8(), v2.b8(), v3.b8())); + TEST_INSTRUCTION("417C632E", uaba(v1.h4(), v2.h4(), v3.h4())); + TEST_INSTRUCTION("417CA32E", uaba(v1.s2(), v2.s2(), v3.s2())); + TEST_INSTRUCTION("417C236E", uaba(v1.b16(), v2.b16(), v3.b16())); + TEST_INSTRUCTION("417C636E", uaba(v1.h8(), v2.h8(), v3.h8())); + TEST_INSTRUCTION("417CA36E", uaba(v1.s4(), v2.s4(), v3.s4())); + TEST_INSTRUCTION("4150232E", uabal(v1.h8(), v2.b8(), v3.b8())); + TEST_INSTRUCTION("4150632E", uabal(v1.s4(), v2.h4(), v3.h4())); + TEST_INSTRUCTION("4150A32E", uabal(v1.d2(), v2.s2(), v3.s2())); + TEST_INSTRUCTION("4150236E", uabal2(v1.h8(), v2.b16(), v3.b16())); + TEST_INSTRUCTION("4150636E", uabal2(v1.s4(), v2.h8(), v3.h8())); + TEST_INSTRUCTION("4150A36E", uabal2(v1.d2(), v2.s4(), v3.s4())); + TEST_INSTRUCTION("4174232E", uabd(v1.b8(), v2.b8(), v3.b8())); + TEST_INSTRUCTION("4174632E", uabd(v1.h4(), v2.h4(), v3.h4())); + TEST_INSTRUCTION("4174A32E", uabd(v1.s2(), v2.s2(), v3.s2())); + TEST_INSTRUCTION("4174236E", uabd(v1.b16(), v2.b16(), v3.b16())); + TEST_INSTRUCTION("4174636E", uabd(v1.h8(), v2.h8(), v3.h8())); + TEST_INSTRUCTION("4174A36E", uabd(v1.s4(), v2.s4(), v3.s4())); + TEST_INSTRUCTION("4170232E", uabdl(v1.h8(), v2.b8(), v3.b8())); + TEST_INSTRUCTION("4170632E", uabdl(v1.s4(), v2.h4(), v3.h4())); + TEST_INSTRUCTION("4170A32E", uabdl(v1.d2(), v2.s2(), v3.s2())); + TEST_INSTRUCTION("4170236E", uabdl2(v1.h8(), v2.b16(), v3.b16())); + TEST_INSTRUCTION("4170636E", uabdl2(v1.s4(), v2.h8(), v3.h8())); + TEST_INSTRUCTION("4170A36E", uabdl2(v1.d2(), v2.s4(), v3.s4())); + TEST_INSTRUCTION("4168202E", uadalp(v1.h4(), v2.b8())); + TEST_INSTRUCTION("4168602E", uadalp(v1.s2(), v2.h4())); + TEST_INSTRUCTION("4168A02E", uadalp(d1, v2.s2())); + TEST_INSTRUCTION("4168206E", uadalp(v1.h8(), v2.b16())); + TEST_INSTRUCTION("4168606E", uadalp(v1.s4(), v2.h8())); + TEST_INSTRUCTION("4168A06E", uadalp(v1.d2(), v2.s4())); + TEST_INSTRUCTION("4100232E", uaddl(v1.h8(), v2.b8(), v3.b8())); + TEST_INSTRUCTION("4100632E", uaddl(v1.s4(), v2.h4(), v3.h4())); + TEST_INSTRUCTION("4100A32E", uaddl(v1.d2(), v2.s2(), v3.s2())); + TEST_INSTRUCTION("4100236E", uaddl2(v1.h8(), v2.b16(), v3.b16())); + TEST_INSTRUCTION("4100636E", uaddl2(v1.s4(), v2.h8(), v3.h8())); + TEST_INSTRUCTION("4100A36E", uaddl2(v1.d2(), v2.s4(), v3.s4())); + TEST_INSTRUCTION("4128202E", uaddlp(v1.h4(), v2.b8())); + TEST_INSTRUCTION("4128602E", uaddlp(v1.s2(), v2.h4())); + TEST_INSTRUCTION("4128A02E", uaddlp(d1, v2.s2())); + TEST_INSTRUCTION("4128206E", uaddlp(v1.h8(), v2.b16())); + TEST_INSTRUCTION("4128606E", uaddlp(v1.s4(), v2.h8())); + TEST_INSTRUCTION("4128A06E", uaddlp(v1.d2(), v2.s4())); + TEST_INSTRUCTION("4138302E", uaddlv(h1, v2.b8())); + TEST_INSTRUCTION("4138306E", uaddlv(h1, v2.b16())); + TEST_INSTRUCTION("4138702E", uaddlv(s1, v2.h4())); + TEST_INSTRUCTION("4138706E", uaddlv(s1, v2.h8())); + TEST_INSTRUCTION("4138B06E", uaddlv(d1, v2.s4())); + TEST_INSTRUCTION("4110232E", uaddw(v1.h8(), v2.h8(), v3.b8())); + TEST_INSTRUCTION("4110632E", uaddw(v1.s4(), v2.s4(), v3.h4())); + TEST_INSTRUCTION("4110A32E", uaddw(v1.d2(), v2.d2(), v3.s2())); + TEST_INSTRUCTION("4110236E", uaddw2(v1.h8(), v2.h8(), v3.b16())); + TEST_INSTRUCTION("4110636E", uaddw2(v1.s4(), v2.s4(), v3.h8())); + TEST_INSTRUCTION("4110A36E", uaddw2(v1.d2(), v2.d2(), v3.s4())); + TEST_INSTRUCTION("4100E31E", ucvtf(h1, w2)); + TEST_INSTRUCTION("4100231E", ucvtf(s1, w2)); + TEST_INSTRUCTION("4100631E", ucvtf(d1, w2)); + TEST_INSTRUCTION("4100E39E", ucvtf(h1, x2)); + TEST_INSTRUCTION("4100239E", ucvtf(s1, x2)); + TEST_INSTRUCTION("4100639E", ucvtf(d1, x2)); + TEST_INSTRUCTION("41D8797E", ucvtf(h1, h2)); + TEST_INSTRUCTION("41D8217E", ucvtf(s1, s2)); + TEST_INSTRUCTION("41D8617E", ucvtf(d1, d2)); + TEST_INSTRUCTION("41D8792E", ucvtf(v1.h4(), v2.h4())); + TEST_INSTRUCTION("41D8212E", ucvtf(v1.s2(), v2.s2())); + TEST_INSTRUCTION("41D8796E", ucvtf(v1.h8(), v2.h8())); + TEST_INSTRUCTION("41D8216E", ucvtf(v1.s4(), v2.s4())); + TEST_INSTRUCTION("41D8616E", ucvtf(v1.d2(), v2.d2())); + TEST_INSTRUCTION("41E0C31E", ucvtf(h1, w2, 8)); + TEST_INSTRUCTION("41E0031E", ucvtf(s1, w2, 8)); + TEST_INSTRUCTION("41E0431E", ucvtf(d1, w2, 8)); + TEST_INSTRUCTION("41E0C39E", ucvtf(h1, x2, 8)); + TEST_INSTRUCTION("41E0039E", ucvtf(s1, x2, 8)); + TEST_INSTRUCTION("41E0439E", ucvtf(d1, x2, 8)); + TEST_INSTRUCTION("41E4187F", ucvtf(h1, h2, 8)); + TEST_INSTRUCTION("41E4387F", ucvtf(s1, s2, 8)); + TEST_INSTRUCTION("41E4787F", ucvtf(d1, d2, 8)); + TEST_INSTRUCTION("41E4182F", ucvtf(v1.h4(), v2.h4(), 8)); + TEST_INSTRUCTION("41E4382F", ucvtf(v1.s2(), v2.s2(), 8)); + TEST_INSTRUCTION("41E4186F", ucvtf(v1.h8(), v2.h8(), 8)); + TEST_INSTRUCTION("41E4386F", ucvtf(v1.s4(), v2.s4(), 8)); + TEST_INSTRUCTION("41E4786F", ucvtf(v1.d2(), v2.d2(), 8)); + TEST_INSTRUCTION("4194832E", udot(v1.s2(), v2.b8(), v3.b8())); + TEST_INSTRUCTION("4194836E", udot(v1.s4(), v2.b16(), v3.b16())); + TEST_INSTRUCTION("41E0832F", udot(v1.s2(), v2.b8(), v3.b4(0))); + TEST_INSTRUCTION("41E0A32F", udot(v1.s2(), v2.b8(), v3.b4(1))); + TEST_INSTRUCTION("41E8832F", udot(v1.s2(), v2.b8(), v3.b4(2))); + TEST_INSTRUCTION("41E8A32F", udot(v1.s2(), v2.b8(), v3.b4(3))); + TEST_INSTRUCTION("41E0836F", udot(v1.s4(), v2.b16(), v3.b4(0))); + TEST_INSTRUCTION("41E0A36F", udot(v1.s4(), v2.b16(), v3.b4(1))); + TEST_INSTRUCTION("41E8836F", udot(v1.s4(), v2.b16(), v3.b4(2))); + TEST_INSTRUCTION("41E8A36F", udot(v1.s4(), v2.b16(), v3.b4(3))); + TEST_INSTRUCTION("4104232E", uhadd(v1.b8(), v2.b8(), v3.b8())); + TEST_INSTRUCTION("4104632E", uhadd(v1.h4(), v2.h4(), v3.h4())); + TEST_INSTRUCTION("4104A32E", uhadd(v1.s2(), v2.s2(), v3.s2())); + TEST_INSTRUCTION("4104236E", uhadd(v1.b16(), v2.b16(), v3.b16())); + TEST_INSTRUCTION("4104636E", uhadd(v1.h8(), v2.h8(), v3.h8())); + TEST_INSTRUCTION("4104A36E", uhadd(v1.s4(), v2.s4(), v3.s4())); + TEST_INSTRUCTION("4124232E", uhsub(v1.b8(), v2.b8(), v3.b8())); + TEST_INSTRUCTION("4124632E", uhsub(v1.h4(), v2.h4(), v3.h4())); + TEST_INSTRUCTION("4124A32E", uhsub(v1.s2(), v2.s2(), v3.s2())); + TEST_INSTRUCTION("4124236E", uhsub(v1.b16(), v2.b16(), v3.b16())); + TEST_INSTRUCTION("4124636E", uhsub(v1.h8(), v2.h8(), v3.h8())); + TEST_INSTRUCTION("4124A36E", uhsub(v1.s4(), v2.s4(), v3.s4())); + TEST_INSTRUCTION("4164232E", umax(v1.b8(), v2.b8(), v3.b8())); + TEST_INSTRUCTION("4164632E", umax(v1.h4(), v2.h4(), v3.h4())); + TEST_INSTRUCTION("4164A32E", umax(v1.s2(), v2.s2(), v3.s2())); + TEST_INSTRUCTION("4164236E", umax(v1.b16(), v2.b16(), v3.b16())); + TEST_INSTRUCTION("4164636E", umax(v1.h8(), v2.h8(), v3.h8())); + TEST_INSTRUCTION("4164A36E", umax(v1.s4(), v2.s4(), v3.s4())); + TEST_INSTRUCTION("41A4232E", umaxp(v1.b8(), v2.b8(), v3.b8())); + TEST_INSTRUCTION("41A4632E", umaxp(v1.h4(), v2.h4(), v3.h4())); + TEST_INSTRUCTION("41A4A32E", umaxp(v1.s2(), v2.s2(), v3.s2())); + TEST_INSTRUCTION("41A4236E", umaxp(v1.b16(), v2.b16(), v3.b16())); + TEST_INSTRUCTION("41A4636E", umaxp(v1.h8(), v2.h8(), v3.h8())); + TEST_INSTRUCTION("41A4A36E", umaxp(v1.s4(), v2.s4(), v3.s4())); + TEST_INSTRUCTION("41A8302E", umaxv(b1, v2.b8())); + TEST_INSTRUCTION("41A8306E", umaxv(b1, v2.b16())); + TEST_INSTRUCTION("41A8702E", umaxv(h1, v2.h4())); + TEST_INSTRUCTION("41A8706E", umaxv(h1, v2.h8())); + TEST_INSTRUCTION("41A8B06E", umaxv(s1, v2.s4())); + TEST_INSTRUCTION("416C232E", umin(v1.b8(), v2.b8(), v3.b8())); + TEST_INSTRUCTION("416C632E", umin(v1.h4(), v2.h4(), v3.h4())); + TEST_INSTRUCTION("416CA32E", umin(v1.s2(), v2.s2(), v3.s2())); + TEST_INSTRUCTION("416C236E", umin(v1.b16(), v2.b16(), v3.b16())); + TEST_INSTRUCTION("416C636E", umin(v1.h8(), v2.h8(), v3.h8())); + TEST_INSTRUCTION("416CA36E", umin(v1.s4(), v2.s4(), v3.s4())); + TEST_INSTRUCTION("41AC232E", uminp(v1.b8(), v2.b8(), v3.b8())); + TEST_INSTRUCTION("41AC632E", uminp(v1.h4(), v2.h4(), v3.h4())); + TEST_INSTRUCTION("41ACA32E", uminp(v1.s2(), v2.s2(), v3.s2())); + TEST_INSTRUCTION("41AC236E", uminp(v1.b16(), v2.b16(), v3.b16())); + TEST_INSTRUCTION("41AC636E", uminp(v1.h8(), v2.h8(), v3.h8())); + TEST_INSTRUCTION("41ACA36E", uminp(v1.s4(), v2.s4(), v3.s4())); + TEST_INSTRUCTION("41A8312E", uminv(b1, v2.b8())); + TEST_INSTRUCTION("41A8316E", uminv(b1, v2.b16())); + TEST_INSTRUCTION("41A8712E", uminv(h1, v2.h4())); + TEST_INSTRUCTION("41A8716E", uminv(h1, v2.h8())); + TEST_INSTRUCTION("41A8B16E", uminv(s1, v2.s4())); + TEST_INSTRUCTION("4180232E", umlal(v1.h8(), v2.b8(), v3.b8())); + TEST_INSTRUCTION("4180632E", umlal(v1.s4(), v2.h4(), v3.h4())); + TEST_INSTRUCTION("4180A32E", umlal(v1.d2(), v2.s2(), v3.s2())); + TEST_INSTRUCTION("4120732F", umlal(v1.s4(), v2.h4(), v3.h(3))); + TEST_INSTRUCTION("4128A32F", umlal(v1.d2(), v2.s2(), v3.s(3))); + TEST_INSTRUCTION("4180236E", umlal2(v1.h8(), v2.b16(), v3.b16())); + TEST_INSTRUCTION("4180636E", umlal2(v1.s4(), v2.h8(), v3.h8())); + TEST_INSTRUCTION("4180A36E", umlal2(v1.d2(), v2.s4(), v3.s4())); + TEST_INSTRUCTION("4120736F", umlal2(v1.s4(), v2.h8(), v3.h(3))); + TEST_INSTRUCTION("4128A36F", umlal2(v1.d2(), v2.s4(), v3.s(3))); + TEST_INSTRUCTION("41A0232E", umlsl(v1.h8(), v2.b8(), v3.b8())); + TEST_INSTRUCTION("41A0632E", umlsl(v1.s4(), v2.h4(), v3.h4())); + TEST_INSTRUCTION("41A0A32E", umlsl(v1.d2(), v2.s2(), v3.s2())); + TEST_INSTRUCTION("4160732F", umlsl(v1.s4(), v2.h4(), v3.h(3))); + TEST_INSTRUCTION("4168A32F", umlsl(v1.d2(), v2.s2(), v3.s(3))); + TEST_INSTRUCTION("41A0236E", umlsl2(v1.h8(), v2.b16(), v3.b16())); + TEST_INSTRUCTION("41A0636E", umlsl2(v1.s4(), v2.h8(), v3.h8())); + TEST_INSTRUCTION("41A0A36E", umlsl2(v1.d2(), v2.s4(), v3.s4())); + TEST_INSTRUCTION("4160736F", umlsl2(v1.s4(), v2.h8(), v3.h(3))); + TEST_INSTRUCTION("4168A36F", umlsl2(v1.d2(), v2.s4(), v3.s(3))); + TEST_INSTRUCTION("41A4836E", ummla(v1.s4(), v2.b16(), v3.b16())); + TEST_INSTRUCTION("413C010E", umov(w1, v2.b(0))); + TEST_INSTRUCTION("413C1F0E", umov(w1, v2.b(15))); + TEST_INSTRUCTION("413C020E", umov(w1, v2.h(0))); + TEST_INSTRUCTION("413C1E0E", umov(w1, v2.h(7))); + TEST_INSTRUCTION("413C040E", umov(w1, v2.s(0))); + TEST_INSTRUCTION("413C1C0E", umov(w1, v2.s(3))); + TEST_INSTRUCTION("413C084E", umov(x1, v2.d(0))); + TEST_INSTRUCTION("413C184E", umov(x1, v2.d(1))); + TEST_INSTRUCTION("41C0232E", umull(v1.h8(), v2.b8(), v3.b8())); + TEST_INSTRUCTION("41C0632E", umull(v1.s4(), v2.h4(), v3.h4())); + TEST_INSTRUCTION("41C0A32E", umull(v1.d2(), v2.s2(), v3.s2())); + TEST_INSTRUCTION("41A0732F", umull(v1.s4(), v2.h4(), v3.h(3))); + TEST_INSTRUCTION("41A8A32F", umull(v1.d2(), v2.s2(), v3.s(3))); + TEST_INSTRUCTION("41C0236E", umull2(v1.h8(), v2.b16(), v3.b16())); + TEST_INSTRUCTION("41C0636E", umull2(v1.s4(), v2.h8(), v3.h8())); + TEST_INSTRUCTION("41C0A36E", umull2(v1.d2(), v2.s4(), v3.s4())); + TEST_INSTRUCTION("41A0736F", umull2(v1.s4(), v2.h8(), v3.h(3))); + TEST_INSTRUCTION("41A8A36F", umull2(v1.d2(), v2.s4(), v3.s(3))); + TEST_INSTRUCTION("410C237E", uqadd(b1, b2, b3)); + TEST_INSTRUCTION("410C637E", uqadd(h1, h2, h3)); + TEST_INSTRUCTION("410CA37E", uqadd(s1, s2, s3)); + TEST_INSTRUCTION("410CE37E", uqadd(d1, d2, d3)); + TEST_INSTRUCTION("410C232E", uqadd(v1.b8(), v2.b8(), v3.b8())); + TEST_INSTRUCTION("410C632E", uqadd(v1.h4(), v2.h4(), v3.h4())); + TEST_INSTRUCTION("410CA32E", uqadd(v1.s2(), v2.s2(), v3.s2())); + TEST_INSTRUCTION("410C236E", uqadd(v1.b16(), v2.b16(), v3.b16())); + TEST_INSTRUCTION("410C636E", uqadd(v1.h8(), v2.h8(), v3.h8())); + TEST_INSTRUCTION("410CA36E", uqadd(v1.s4(), v2.s4(), v3.s4())); + TEST_INSTRUCTION("410CE36E", uqadd(v1.d2(), v2.d2(), v3.d2())); + TEST_INSTRUCTION("415C237E", uqrshl(b1, b2, b3)); + TEST_INSTRUCTION("415C637E", uqrshl(h1, h2, h3)); + TEST_INSTRUCTION("415CA37E", uqrshl(s1, s2, s3)); + TEST_INSTRUCTION("415C232E", uqrshl(v1.b8(), v2.b8(), v3.b8())); + TEST_INSTRUCTION("415C632E", uqrshl(v1.h4(), v2.h4(), v3.h4())); + TEST_INSTRUCTION("415CA32E", uqrshl(v1.s2(), v2.s2(), v3.s2())); + TEST_INSTRUCTION("415CE37E", uqrshl(d1, d2, d3)); + TEST_INSTRUCTION("415C236E", uqrshl(v1.b16(), v2.b16(), v3.b16())); + TEST_INSTRUCTION("415C636E", uqrshl(v1.h8(), v2.h8(), v3.h8())); + TEST_INSTRUCTION("415CA36E", uqrshl(v1.s4(), v2.s4(), v3.s4())); + TEST_INSTRUCTION("415CE36E", uqrshl(v1.d2(), v2.d2(), v3.d2())); + TEST_INSTRUCTION("419C087F", uqrshrn(b1, h2, 8)); + TEST_INSTRUCTION("419C107F", uqrshrn(h1, s2, 16)); + TEST_INSTRUCTION("419C207F", uqrshrn(s1, d2, 32)); + TEST_INSTRUCTION("419C082F", uqrshrn(v1.b8(), v2.h8(), 8)); + TEST_INSTRUCTION("419C102F", uqrshrn(v1.h4(), v2.s4(), 16)); + TEST_INSTRUCTION("419C202F", uqrshrn(v1.s2(), v2.d2(), 32)); + TEST_INSTRUCTION("419C086F", uqrshrn2(v1.b16(), v2.h8(), 8)); + TEST_INSTRUCTION("419C106F", uqrshrn2(v1.h8(), v2.s4(), 16)); + TEST_INSTRUCTION("419C206F", uqrshrn2(v1.s4(), v2.d2(), 32)); + TEST_INSTRUCTION("4174097F", uqshl(b1, b2, 1)); + TEST_INSTRUCTION("4174127F", uqshl(h1, h2, 2)); + TEST_INSTRUCTION("4174237F", uqshl(s1, s2, 3)); + TEST_INSTRUCTION("41740F2F", uqshl(v1.b8(), v2.b8(), 7)); + TEST_INSTRUCTION("41741F2F", uqshl(v1.h4(), v2.h4(), 15)); + TEST_INSTRUCTION("41743F2F", uqshl(v1.s2(), v2.s2(), 31)); + TEST_INSTRUCTION("41747F7F", uqshl(d1, d2, 63)); + TEST_INSTRUCTION("41740F6F", uqshl(v1.b16(), v2.b16(), 7)); + TEST_INSTRUCTION("41741F6F", uqshl(v1.h8(), v2.h8(), 15)); + TEST_INSTRUCTION("41743F6F", uqshl(v1.s4(), v2.s4(), 31)); + TEST_INSTRUCTION("41747F6F", uqshl(v1.d2(), v2.d2(), 63)); + TEST_INSTRUCTION("414C237E", uqshl(b1, b2, b3)); + TEST_INSTRUCTION("414C637E", uqshl(h1, h2, h3)); + TEST_INSTRUCTION("414CA37E", uqshl(s1, s2, s3)); + TEST_INSTRUCTION("414C232E", uqshl(v1.b8(), v2.b8(), v3.b8())); + TEST_INSTRUCTION("414C632E", uqshl(v1.h4(), v2.h4(), v3.h4())); + TEST_INSTRUCTION("414CA32E", uqshl(v1.s2(), v2.s2(), v3.s2())); + TEST_INSTRUCTION("414CE37E", uqshl(d1, d2, d3)); + TEST_INSTRUCTION("414C236E", uqshl(v1.b16(), v2.b16(), v3.b16())); + TEST_INSTRUCTION("414C636E", uqshl(v1.h8(), v2.h8(), v3.h8())); + TEST_INSTRUCTION("414CA36E", uqshl(v1.s4(), v2.s4(), v3.s4())); + TEST_INSTRUCTION("414CE36E", uqshl(v1.d2(), v2.d2(), v3.d2())); + TEST_INSTRUCTION("4194087F", uqshrn(b1, h2, 8)); + TEST_INSTRUCTION("4194107F", uqshrn(h1, s2, 16)); + TEST_INSTRUCTION("4194207F", uqshrn(s1, d2, 32)); + TEST_INSTRUCTION("4194082F", uqshrn(v1.b8(), v2.h8(), 8)); + TEST_INSTRUCTION("4194102F", uqshrn(v1.h4(), v2.s4(), 16)); + TEST_INSTRUCTION("4194202F", uqshrn(v1.s2(), v2.d2(), 32)); + TEST_INSTRUCTION("4194086F", uqshrn2(v1.b16(), v2.h8(), 8)); + TEST_INSTRUCTION("4194106F", uqshrn2(v1.h8(), v2.s4(), 16)); + TEST_INSTRUCTION("4194206F", uqshrn2(v1.s4(), v2.d2(), 32)); + TEST_INSTRUCTION("412C237E", uqsub(b1, b2, b3)); + TEST_INSTRUCTION("412C637E", uqsub(h1, h2, h3)); + TEST_INSTRUCTION("412CA37E", uqsub(s1, s2, s3)); + TEST_INSTRUCTION("412CE37E", uqsub(d1, d2, d3)); + TEST_INSTRUCTION("412C232E", uqsub(v1.b8(), v2.b8(), v3.b8())); + TEST_INSTRUCTION("412C632E", uqsub(v1.h4(), v2.h4(), v3.h4())); + TEST_INSTRUCTION("412CA32E", uqsub(v1.s2(), v2.s2(), v3.s2())); + TEST_INSTRUCTION("412C236E", uqsub(v1.b16(), v2.b16(), v3.b16())); + TEST_INSTRUCTION("412C636E", uqsub(v1.h8(), v2.h8(), v3.h8())); + TEST_INSTRUCTION("412CA36E", uqsub(v1.s4(), v2.s4(), v3.s4())); + TEST_INSTRUCTION("412CE36E", uqsub(v1.d2(), v2.d2(), v3.d2())); + TEST_INSTRUCTION("4148217E", uqxtn(b1, h2)); + TEST_INSTRUCTION("4148617E", uqxtn(h1, s2)); + TEST_INSTRUCTION("4148A17E", uqxtn(s1, d2)); + TEST_INSTRUCTION("4148212E", uqxtn(v1.b8(), v2.h8())); + TEST_INSTRUCTION("4148612E", uqxtn(v1.h4(), v2.s4())); + TEST_INSTRUCTION("4148A12E", uqxtn(v1.s2(), v2.d2())); + TEST_INSTRUCTION("4148216E", uqxtn2(v1.b16(), v2.h8())); + TEST_INSTRUCTION("4148616E", uqxtn2(v1.h8(), v2.s4())); + TEST_INSTRUCTION("4148A16E", uqxtn2(v1.s4(), v2.d2())); + TEST_INSTRUCTION("41C8A10E", urecpe(v1.s2(), v2.s2())); + TEST_INSTRUCTION("41C8A14E", urecpe(v1.s4(), v2.s4())); + TEST_INSTRUCTION("4114232E", urhadd(v1.b8(), v2.b8(), v3.b8())); + TEST_INSTRUCTION("4114632E", urhadd(v1.h4(), v2.h4(), v3.h4())); + TEST_INSTRUCTION("4114A32E", urhadd(v1.s2(), v2.s2(), v3.s2())); + TEST_INSTRUCTION("4114236E", urhadd(v1.b16(), v2.b16(), v3.b16())); + TEST_INSTRUCTION("4114636E", urhadd(v1.h8(), v2.h8(), v3.h8())); + TEST_INSTRUCTION("4114A36E", urhadd(v1.s4(), v2.s4(), v3.s4())); + TEST_INSTRUCTION("4154232E", urshl(v1.b8(), v2.b8(), v3.b8())); + TEST_INSTRUCTION("4154632E", urshl(v1.h4(), v2.h4(), v3.h4())); + TEST_INSTRUCTION("4154A32E", urshl(v1.s2(), v2.s2(), v3.s2())); + TEST_INSTRUCTION("4154E37E", urshl(d1, d2, d3)); + TEST_INSTRUCTION("4154236E", urshl(v1.b16(), v2.b16(), v3.b16())); + TEST_INSTRUCTION("4154636E", urshl(v1.h8(), v2.h8(), v3.h8())); + TEST_INSTRUCTION("4154A36E", urshl(v1.s4(), v2.s4(), v3.s4())); + TEST_INSTRUCTION("4154E36E", urshl(v1.d2(), v2.d2(), v3.d2())); + TEST_INSTRUCTION("4124092F", urshr(v1.b8(), v2.b8(), 7)); + TEST_INSTRUCTION("4124112F", urshr(v1.h4(), v2.h4(), 15)); + TEST_INSTRUCTION("4124212F", urshr(v1.s2(), v2.s2(), 31)); + TEST_INSTRUCTION("4124417F", urshr(d1, d2, 63)); + TEST_INSTRUCTION("4124096F", urshr(v1.b16(), v2.b16(), 7)); + TEST_INSTRUCTION("4124116F", urshr(v1.h8(), v2.h8(), 15)); + TEST_INSTRUCTION("4124216F", urshr(v1.s4(), v2.s4(), 31)); + TEST_INSTRUCTION("4124416F", urshr(v1.d2(), v2.d2(), 63)); + TEST_INSTRUCTION("41C8A12E", ursqrte(v1.s2(), v2.s2())); + TEST_INSTRUCTION("41C8A16E", ursqrte(v1.s4(), v2.s4())); + TEST_INSTRUCTION("4134092F", ursra(v1.b8(), v2.b8(), 7)); + TEST_INSTRUCTION("4134112F", ursra(v1.h4(), v2.h4(), 15)); + TEST_INSTRUCTION("4134212F", ursra(v1.s2(), v2.s2(), 31)); + TEST_INSTRUCTION("4134417F", ursra(d1, d2, 63)); + TEST_INSTRUCTION("4134096F", ursra(v1.b16(), v2.b16(), 7)); + TEST_INSTRUCTION("4134116F", ursra(v1.h8(), v2.h8(), 15)); + TEST_INSTRUCTION("4134216F", ursra(v1.s4(), v2.s4(), 31)); + TEST_INSTRUCTION("4134416F", ursra(v1.d2(), v2.d2(), 63)); + TEST_INSTRUCTION("419C830E", usdot(v1.s2(), v2.b8(), v3.b8())); + TEST_INSTRUCTION("419C834E", usdot(v1.s4(), v2.b16(), v3.b16())); + TEST_INSTRUCTION("41F0830F", usdot(v1.s2(), v2.b8(), v3.b4(0))); + TEST_INSTRUCTION("41F0A30F", usdot(v1.s2(), v2.b8(), v3.b4(1))); + TEST_INSTRUCTION("41F8830F", usdot(v1.s2(), v2.b8(), v3.b4(2))); + TEST_INSTRUCTION("41F8A30F", usdot(v1.s2(), v2.b8(), v3.b4(3))); + TEST_INSTRUCTION("41F0834F", usdot(v1.s4(), v2.b16(), v3.b4(0))); + TEST_INSTRUCTION("41F0A34F", usdot(v1.s4(), v2.b16(), v3.b4(1))); + TEST_INSTRUCTION("41F8834F", usdot(v1.s4(), v2.b16(), v3.b4(2))); + TEST_INSTRUCTION("41F8A34F", usdot(v1.s4(), v2.b16(), v3.b4(3))); + TEST_INSTRUCTION("4144232E", ushl(v1.b8(), v2.b8(), v3.b8())); + TEST_INSTRUCTION("4144632E", ushl(v1.h4(), v2.h4(), v3.h4())); + TEST_INSTRUCTION("4144A32E", ushl(v1.s2(), v2.s2(), v3.s2())); + TEST_INSTRUCTION("4144E37E", ushl(d1, d2, d3)); + TEST_INSTRUCTION("4144236E", ushl(v1.b16(), v2.b16(), v3.b16())); + TEST_INSTRUCTION("4144636E", ushl(v1.h8(), v2.h8(), v3.h8())); + TEST_INSTRUCTION("4144A36E", ushl(v1.s4(), v2.s4(), v3.s4())); + TEST_INSTRUCTION("4144E36E", ushl(v1.d2(), v2.d2(), v3.d2())); + TEST_INSTRUCTION("41A40F2F", ushll(v1.h8(), v2.b8(), 7)); + TEST_INSTRUCTION("41A41F2F", ushll(v1.s4(), v2.h4(), 15)); + TEST_INSTRUCTION("41A43F2F", ushll(v1.d2(), v2.s2(), 31)); + TEST_INSTRUCTION("41A40F6F", ushll2(v1.h8(), v2.b16(), 7)); + TEST_INSTRUCTION("41A41F6F", ushll2(v1.s4(), v2.h8(), 15)); + TEST_INSTRUCTION("41A43F6F", ushll2(v1.s2(), v2.s4(), 31)); + TEST_INSTRUCTION("4104092F", ushr(v1.b8(), v2.b8(), 7)); + TEST_INSTRUCTION("4104112F", ushr(v1.h4(), v2.h4(), 15)); + TEST_INSTRUCTION("4104212F", ushr(v1.s2(), v2.s2(), 31)); + TEST_INSTRUCTION("4104417F", ushr(d1, d2, 63)); + TEST_INSTRUCTION("4104096F", ushr(v1.b16(), v2.b16(), 7)); + TEST_INSTRUCTION("4104116F", ushr(v1.h8(), v2.h8(), 15)); + TEST_INSTRUCTION("4104216F", ushr(v1.s4(), v2.s4(), 31)); + TEST_INSTRUCTION("4104416F", ushr(v1.d2(), v2.d2(), 63)); + TEST_INSTRUCTION("41AC834E", usmmla(v1.s4(), v2.b16(), v3.b16())); + TEST_INSTRUCTION("4138207E", usqadd(b1, b2)); + TEST_INSTRUCTION("4138607E", usqadd(h1, h2)); + TEST_INSTRUCTION("4138A07E", usqadd(s1, s2)); + TEST_INSTRUCTION("4138E07E", usqadd(d1, d2)); + TEST_INSTRUCTION("4138202E", usqadd(v1.b8(), v2.b8())); + TEST_INSTRUCTION("4138602E", usqadd(v1.h4(), v2.h4())); + TEST_INSTRUCTION("4138A02E", usqadd(v1.s2(), v2.s2())); + TEST_INSTRUCTION("4138206E", usqadd(v1.b16(), v2.b16())); + TEST_INSTRUCTION("4138606E", usqadd(v1.h8(), v2.h8())); + TEST_INSTRUCTION("4138A06E", usqadd(v1.s4(), v2.s4())); + TEST_INSTRUCTION("4138E06E", usqadd(v1.d2(), v2.d2())); + TEST_INSTRUCTION("4114092F", usra(v1.b8(), v2.b8(), 7)); + TEST_INSTRUCTION("4114112F", usra(v1.h4(), v2.h4(), 15)); + TEST_INSTRUCTION("4114212F", usra(v1.s2(), v2.s2(), 31)); + TEST_INSTRUCTION("4114417F", usra(d1, d2, 63)); + TEST_INSTRUCTION("4114096F", usra(v1.b16(), v2.b16(), 7)); + TEST_INSTRUCTION("4114116F", usra(v1.h8(), v2.h8(), 15)); + TEST_INSTRUCTION("4114216F", usra(v1.s4(), v2.s4(), 31)); + TEST_INSTRUCTION("4114416F", usra(v1.d2(), v2.d2(), 63)); + TEST_INSTRUCTION("4120232E", usubl(v1.h8(), v2.b8(), v3.b8())); + TEST_INSTRUCTION("4120632E", usubl(v1.s4(), v2.h4(), v3.h4())); + TEST_INSTRUCTION("4120A32E", usubl(v1.d2(), v2.s2(), v3.s2())); + TEST_INSTRUCTION("4120236E", usubl2(v1.h8(), v2.b16(), v3.b16())); + TEST_INSTRUCTION("4120636E", usubl2(v1.s4(), v2.h8(), v3.h8())); + TEST_INSTRUCTION("4120A36E", usubl2(v1.d2(), v2.s4(), v3.s4())); + TEST_INSTRUCTION("4130232E", usubw(v1.h8(), v2.h8(), v3.b8())); + TEST_INSTRUCTION("4130632E", usubw(v1.s4(), v2.s4(), v3.h4())); + TEST_INSTRUCTION("4130A32E", usubw(v1.d2(), v2.d2(), v3.s2())); + TEST_INSTRUCTION("4130236E", usubw2(v1.h8(), v2.h8(), v3.b16())); + TEST_INSTRUCTION("4130636E", usubw2(v1.s4(), v2.s4(), v3.h8())); + TEST_INSTRUCTION("4130A36E", usubw2(v1.d2(), v2.d2(), v3.s4())); + TEST_INSTRUCTION("41A4082F", uxtl(v1.h8(), v2.b8())); + TEST_INSTRUCTION("41A4102F", uxtl(v1.s4(), v2.h4())); + TEST_INSTRUCTION("41A4202F", uxtl(v1.d2(), v2.s2())); + TEST_INSTRUCTION("41A4086F", uxtl2(v1.h8(), v2.b16())); + TEST_INSTRUCTION("41A4106F", uxtl2(v1.s4(), v2.h8())); + TEST_INSTRUCTION("41A4206F", uxtl2(v1.d2(), v2.s4())); + TEST_INSTRUCTION("4118030E", uzp1(v1.b8(), v2.b8(), v3.b8())); + TEST_INSTRUCTION("4118430E", uzp1(v1.h4(), v2.h4(), v3.h4())); + TEST_INSTRUCTION("4118830E", uzp1(v1.s2(), v2.s2(), v3.s2())); + TEST_INSTRUCTION("4118034E", uzp1(v1.b16(), v2.b16(), v3.b16())); + TEST_INSTRUCTION("4118434E", uzp1(v1.h8(), v2.h8(), v3.h8())); + TEST_INSTRUCTION("4118834E", uzp1(v1.s4(), v2.s4(), v3.s4())); + TEST_INSTRUCTION("4118C34E", uzp1(v1.d2(), v2.d2(), v3.d2())); + TEST_INSTRUCTION("4158030E", uzp2(v1.b8(), v2.b8(), v3.b8())); + TEST_INSTRUCTION("4158430E", uzp2(v1.h4(), v2.h4(), v3.h4())); + TEST_INSTRUCTION("4158830E", uzp2(v1.s2(), v2.s2(), v3.s2())); + TEST_INSTRUCTION("4158034E", uzp2(v1.b16(), v2.b16(), v3.b16())); + TEST_INSTRUCTION("4158434E", uzp2(v1.h8(), v2.h8(), v3.h8())); + TEST_INSTRUCTION("4158834E", uzp2(v1.s4(), v2.s4(), v3.s4())); + TEST_INSTRUCTION("4158C34E", uzp2(v1.d2(), v2.d2(), v3.d2())); + TEST_INSTRUCTION("4128210E", xtn(v1.b8(), v2.h8())); + TEST_INSTRUCTION("4128610E", xtn(v1.h4(), v2.s4())); + TEST_INSTRUCTION("4128A10E", xtn(v1.s2(), v2.d2())); + TEST_INSTRUCTION("4128214E", xtn2(v1.b16(), v2.h8())); + TEST_INSTRUCTION("4128614E", xtn2(v1.h8(), v2.s4())); + TEST_INSTRUCTION("4128A14E", xtn2(v1.s4(), v2.d2())); + TEST_INSTRUCTION("4138030E", zip1(v1.b8(), v2.b8(), v3.b8())); + TEST_INSTRUCTION("4138430E", zip1(v1.h4(), v2.h4(), v3.h4())); + TEST_INSTRUCTION("4138830E", zip1(v1.s2(), v2.s2(), v3.s2())); + TEST_INSTRUCTION("4138034E", zip1(v1.b16(), v2.b16(), v3.b16())); + TEST_INSTRUCTION("4138434E", zip1(v1.h8(), v2.h8(), v3.h8())); + TEST_INSTRUCTION("4138834E", zip1(v1.s4(), v2.s4(), v3.s4())); + TEST_INSTRUCTION("4138C34E", zip1(v1.d2(), v2.d2(), v3.d2())); + TEST_INSTRUCTION("4178030E", zip2(v1.b8(), v2.b8(), v3.b8())); + TEST_INSTRUCTION("4178430E", zip2(v1.h4(), v2.h4(), v3.h4())); + TEST_INSTRUCTION("4178830E", zip2(v1.s2(), v2.s2(), v3.s2())); + TEST_INSTRUCTION("4178034E", zip2(v1.b16(), v2.b16(), v3.b16())); + TEST_INSTRUCTION("4178434E", zip2(v1.h8(), v2.h8(), v3.h8())); + TEST_INSTRUCTION("4178834E", zip2(v1.s4(), v2.s4(), v3.s4())); + TEST_INSTRUCTION("4178C34E", zip2(v1.d2(), v2.d2(), v3.d2())); +} + +static void ASMJIT_NOINLINE testA64AssemblerExtras(AssemblerTester<a64::Assembler>& tester) noexcept { + using namespace a64; + + // AsmJit additions - AArch64 assembler accepts variety of immediates in + // MOVI instruction that it encodes by changing the size of its operands. + TEST_INSTRUCTION("C1E7074F", movi(v1.b16(), 0xFE)); + TEST_INSTRUCTION("C1E7074F", movi(v1.h8(), 0xFEFE)); + TEST_INSTRUCTION("C1E7074F", movi(v1.s4(), 0xFEFEFEFE)); + TEST_INSTRUCTION("C1E7074F", movi(v1.d2(), 0xFEFEFEFEFEFEFEFE)); + TEST_INSTRUCTION("C1A7074F", movi(v1.h8(), 0xFE, lsl(8))); + TEST_INSTRUCTION("C1A7074F", movi(v1.h8(), 0xFE00)); + TEST_INSTRUCTION("C1A7074F", movi(v1.s4(), 0xFE00FE00)); + TEST_INSTRUCTION("C1A7074F", movi(v1.d2(), 0xFE00FE00FE00FE00)); + TEST_INSTRUCTION("C147074F", movi(v1.s4(), 0xFE, lsl(16))); + TEST_INSTRUCTION("C147074F", movi(v1.s4(), 0x00FE0000)); + TEST_INSTRUCTION("C147074F", movi(v1.d2(), 0x00FE000000FE0000)); + TEST_INSTRUCTION("C167074F", movi(v1.s4(), 0xFE, lsl(24))); + TEST_INSTRUCTION("C167074F", movi(v1.s4(), 0xFE000000)); + TEST_INSTRUCTION("C167074F", movi(v1.d2(), 0xFE000000FE000000)); +} + +bool testA64Assembler(const TestSettings& settings) noexcept { + using namespace a64; + + AssemblerTester<Assembler> tester(Arch::kAArch64, settings); + tester.printHeader("AArch64"); + + testA64AssemblerBase(tester); + testA64AssemblerRel(tester); + testA64AssemblerSIMD(tester); + testA64AssemblerExtras(tester); + + tester.printSummary(); + return tester.didPass(); +} + +#undef TEST_INSTRUCTION + +#endif // !ASMJIT_NO_AARCH64 diff --git a/3rdparty/asmjit/test/asmjit_test_assembler_x64.cpp b/3rdparty/asmjit/test/asmjit_test_assembler_x64.cpp new file mode 100644 index 00000000000..bedf7964541 --- /dev/null +++ b/3rdparty/asmjit/test/asmjit_test_assembler_x64.cpp @@ -0,0 +1,17833 @@ +// This file is part of AsmJit project <https://asmjit.com> +// +// See asmjit.h or LICENSE.md for license and copyright information +// SPDX-License-Identifier: Zlib + +#include <asmjit/core.h> +#if !defined(ASMJIT_NO_X86) + +#include <asmjit/x86.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> + +#include "asmjit_test_assembler.h" +#include "cmdline.h" + +using namespace asmjit; + +#define TEST_INSTRUCTION(OPCODE, ...) \ + tester.testInstruction(OPCODE, #__VA_ARGS__, tester.assembler.__VA_ARGS__) + +static void ASMJIT_NOINLINE testX64AssemblerBase(AssemblerTester<x86::Assembler>& tester) noexcept { + using namespace x86; + + TEST_INSTRUCTION("80D101" , adc(cl, 1)); + TEST_INSTRUCTION("80D501" , adc(ch, 1)); + TEST_INSTRUCTION("8094118000000001" , adc(byte_ptr(rcx, rdx, 0, 128), 1)); + TEST_INSTRUCTION("6683D101" , adc(cx, 1)); + TEST_INSTRUCTION("668394118000000001" , adc(word_ptr(rcx, rdx, 0, 128), 1)); + TEST_INSTRUCTION("83D101" , adc(ecx, 1)); + TEST_INSTRUCTION("8394118000000001" , adc(dword_ptr(rcx, rdx, 0, 128), 1)); + TEST_INSTRUCTION("4811D1" , adc(rcx, rdx)); + TEST_INSTRUCTION("4883D101" , adc(rcx, 1)); + TEST_INSTRUCTION("48119C1180000000" , adc(ptr(rcx, rdx, 0, 128), rbx)); + TEST_INSTRUCTION("48119C1180000000" , adc(qword_ptr(rcx, rdx, 0, 128), rbx)); + TEST_INSTRUCTION("488394118000000001" , adc(qword_ptr(rcx, rdx, 0, 128), 1)); + TEST_INSTRUCTION("10D1" , adc(cl, dl)); + TEST_INSTRUCTION("10F1" , adc(cl, dh)); + TEST_INSTRUCTION("10D5" , adc(ch, dl)); + TEST_INSTRUCTION("10F5" , adc(ch, dh)); + TEST_INSTRUCTION("109C1180000000" , adc(ptr(rcx, rdx, 0, 128), bl)); + TEST_INSTRUCTION("10BC1180000000" , adc(ptr(rcx, rdx, 0, 128), bh)); + TEST_INSTRUCTION("109C1180000000" , adc(byte_ptr(rcx, rdx, 0, 128), bl)); + TEST_INSTRUCTION("10BC1180000000" , adc(byte_ptr(rcx, rdx, 0, 128), bh)); + TEST_INSTRUCTION("6611D1" , adc(cx, dx)); + TEST_INSTRUCTION("66119C1180000000" , adc(ptr(rcx, rdx, 0, 128), bx)); + TEST_INSTRUCTION("66119C1180000000" , adc(word_ptr(rcx, rdx, 0, 128), bx)); + TEST_INSTRUCTION("11D1" , adc(ecx, edx)); + TEST_INSTRUCTION("119C1180000000" , adc(ptr(rcx, rdx, 0, 128), ebx)); + TEST_INSTRUCTION("119C1180000000" , adc(dword_ptr(rcx, rdx, 0, 128), ebx)); + TEST_INSTRUCTION("128C1A80000000" , adc(cl, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("128C1A80000000" , adc(cl, byte_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("12AC1A80000000" , adc(ch, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("12AC1A80000000" , adc(ch, byte_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("66138C1A80000000" , adc(cx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("66138C1A80000000" , adc(cx, word_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("138C1A80000000" , adc(ecx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("138C1A80000000" , adc(ecx, dword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("48138C1A80000000" , adc(rcx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("48138C1A80000000" , adc(rcx, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F38F6CA" , adcx(ecx, edx)); + TEST_INSTRUCTION("660F38F68C1A80000000" , adcx(ecx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F38F68C1A80000000" , adcx(ecx, dword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("66480F38F6CA" , adcx(rcx, rdx)); + TEST_INSTRUCTION("66480F38F68C1A80000000" , adcx(rcx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("66480F38F68C1A80000000" , adcx(rcx, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("80C101" , add(cl, 1)); + TEST_INSTRUCTION("80C501" , add(ch, 1)); + TEST_INSTRUCTION("8084118000000001" , add(byte_ptr(rcx, rdx, 0, 128), 1)); + TEST_INSTRUCTION("6683C101" , add(cx, 1)); + TEST_INSTRUCTION("668384118000000001" , add(word_ptr(rcx, rdx, 0, 128), 1)); + TEST_INSTRUCTION("83C101" , add(ecx, 1)); + TEST_INSTRUCTION("8384118000000001" , add(dword_ptr(rcx, rdx, 0, 128), 1)); + TEST_INSTRUCTION("4801D1" , add(rcx, rdx)); + TEST_INSTRUCTION("4883C101" , add(rcx, 1)); + TEST_INSTRUCTION("48019C1180000000" , add(ptr(rcx, rdx, 0, 128), rbx)); + TEST_INSTRUCTION("48019C1180000000" , add(qword_ptr(rcx, rdx, 0, 128), rbx)); + TEST_INSTRUCTION("488384118000000001" , add(qword_ptr(rcx, rdx, 0, 128), 1)); + TEST_INSTRUCTION("00D1" , add(cl, dl)); + TEST_INSTRUCTION("00F1" , add(cl, dh)); + TEST_INSTRUCTION("00D5" , add(ch, dl)); + TEST_INSTRUCTION("00F5" , add(ch, dh)); + TEST_INSTRUCTION("009C1180000000" , add(ptr(rcx, rdx, 0, 128), bl)); + TEST_INSTRUCTION("00BC1180000000" , add(ptr(rcx, rdx, 0, 128), bh)); + TEST_INSTRUCTION("009C1180000000" , add(byte_ptr(rcx, rdx, 0, 128), bl)); + TEST_INSTRUCTION("00BC1180000000" , add(byte_ptr(rcx, rdx, 0, 128), bh)); + TEST_INSTRUCTION("6601D1" , add(cx, dx)); + TEST_INSTRUCTION("66019C1180000000" , add(ptr(rcx, rdx, 0, 128), bx)); + TEST_INSTRUCTION("66019C1180000000" , add(word_ptr(rcx, rdx, 0, 128), bx)); + TEST_INSTRUCTION("01D1" , add(ecx, edx)); + TEST_INSTRUCTION("019C1180000000" , add(ptr(rcx, rdx, 0, 128), ebx)); + TEST_INSTRUCTION("019C1180000000" , add(dword_ptr(rcx, rdx, 0, 128), ebx)); + TEST_INSTRUCTION("028C1A80000000" , add(cl, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("028C1A80000000" , add(cl, byte_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("02AC1A80000000" , add(ch, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("02AC1A80000000" , add(ch, byte_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("66038C1A80000000" , add(cx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("66038C1A80000000" , add(cx, word_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("038C1A80000000" , add(ecx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("038C1A80000000" , add(ecx, dword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("48038C1A80000000" , add(rcx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("48038C1A80000000" , add(rcx, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("F30F38F6CA" , adox(ecx, edx)); + TEST_INSTRUCTION("F30F38F68C1A80000000" , adox(ecx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("F30F38F68C1A80000000" , adox(ecx, dword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("F3480F38F6CA" , adox(rcx, rdx)); + TEST_INSTRUCTION("F3480F38F68C1A80000000" , adox(rcx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("F3480F38F68C1A80000000" , adox(rcx, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("80E101" , and_(cl, 1)); + TEST_INSTRUCTION("80E501" , and_(ch, 1)); + TEST_INSTRUCTION("6683E101" , and_(cx, 1)); + TEST_INSTRUCTION("83E101" , and_(ecx, 1)); + TEST_INSTRUCTION("4883E101" , and_(rcx, 1)); + TEST_INSTRUCTION("80A4118000000001" , and_(byte_ptr(rcx, rdx, 0, 128), 1)); + TEST_INSTRUCTION("6683A4118000000001" , and_(word_ptr(rcx, rdx, 0, 128), 1)); + TEST_INSTRUCTION("83A4118000000001" , and_(dword_ptr(rcx, rdx, 0, 128), 1)); + TEST_INSTRUCTION("4883A4118000000001" , and_(qword_ptr(rcx, rdx, 0, 128), 1)); + TEST_INSTRUCTION("4821D1" , and_(rcx, rdx)); + TEST_INSTRUCTION("48238C1A80000000" , and_(rcx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("48238C1A80000000" , and_(rcx, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("48219C1180000000" , and_(ptr(rcx, rdx, 0, 128), rbx)); + TEST_INSTRUCTION("48219C1180000000" , and_(qword_ptr(rcx, rdx, 0, 128), rbx)); + TEST_INSTRUCTION("20D1" , and_(cl, dl)); + TEST_INSTRUCTION("20F1" , and_(cl, dh)); + TEST_INSTRUCTION("20D5" , and_(ch, dl)); + TEST_INSTRUCTION("20F5" , and_(ch, dh)); + TEST_INSTRUCTION("209C1180000000" , and_(ptr(rcx, rdx, 0, 128), bl)); + TEST_INSTRUCTION("20BC1180000000" , and_(ptr(rcx, rdx, 0, 128), bh)); + TEST_INSTRUCTION("209C1180000000" , and_(byte_ptr(rcx, rdx, 0, 128), bl)); + TEST_INSTRUCTION("20BC1180000000" , and_(byte_ptr(rcx, rdx, 0, 128), bh)); + TEST_INSTRUCTION("6621D1" , and_(cx, dx)); + TEST_INSTRUCTION("66219C1180000000" , and_(ptr(rcx, rdx, 0, 128), bx)); + TEST_INSTRUCTION("66219C1180000000" , and_(word_ptr(rcx, rdx, 0, 128), bx)); + TEST_INSTRUCTION("21D1" , and_(ecx, edx)); + TEST_INSTRUCTION("219C1180000000" , and_(ptr(rcx, rdx, 0, 128), ebx)); + TEST_INSTRUCTION("219C1180000000" , and_(dword_ptr(rcx, rdx, 0, 128), ebx)); + TEST_INSTRUCTION("228C1A80000000" , and_(cl, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("228C1A80000000" , and_(cl, byte_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("22AC1A80000000" , and_(ch, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("22AC1A80000000" , and_(ch, byte_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("66238C1A80000000" , and_(cx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("66238C1A80000000" , and_(cx, word_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("238C1A80000000" , and_(ecx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("238C1A80000000" , and_(ecx, dword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C4E268F2CB" , andn(ecx, edx, ebx)); + TEST_INSTRUCTION("C4E268F28C2B80000000" , andn(ecx, edx, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E268F28C2B80000000" , andn(ecx, edx, dword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E2E8F2CB" , andn(rcx, rdx, rbx)); + TEST_INSTRUCTION("C4E2E8F28C2B80000000" , andn(rcx, rdx, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E2E8F28C2B80000000" , andn(rcx, rdx, qword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E260F7CA" , bextr(ecx, edx, ebx)); + TEST_INSTRUCTION("C4E258F78C1A80000000" , bextr(ecx, ptr(rdx, rbx, 0, 128), esp)); + TEST_INSTRUCTION("C4E258F78C1A80000000" , bextr(ecx, dword_ptr(rdx, rbx, 0, 128), esp)); + TEST_INSTRUCTION("C4E2E0F7CA" , bextr(rcx, rdx, rbx)); + TEST_INSTRUCTION("C4E2D8F78C1A80000000" , bextr(rcx, ptr(rdx, rbx, 0, 128), rsp)); + TEST_INSTRUCTION("C4E2D8F78C1A80000000" , bextr(rcx, qword_ptr(rdx, rbx, 0, 128), rsp)); + TEST_INSTRUCTION("8FE97001CA" , blcfill(ecx, edx)); + TEST_INSTRUCTION("8FE970018C1A80000000" , blcfill(ecx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("8FE970018C1A80000000" , blcfill(ecx, dword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("8FE9F001CA" , blcfill(rcx, rdx)); + TEST_INSTRUCTION("8FE9F0018C1A80000000" , blcfill(rcx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("8FE9F0018C1A80000000" , blcfill(rcx, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("8FE97002F2" , blci(ecx, edx)); + TEST_INSTRUCTION("8FE97002B41A80000000" , blci(ecx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("8FE97002B41A80000000" , blci(ecx, dword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("8FE9F002F2" , blci(rcx, rdx)); + TEST_INSTRUCTION("8FE9F002B41A80000000" , blci(rcx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("8FE9F002B41A80000000" , blci(rcx, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("8FE97001EA" , blcic(ecx, edx)); + TEST_INSTRUCTION("8FE97001AC1A80000000" , blcic(ecx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("8FE97001AC1A80000000" , blcic(ecx, dword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("8FE9F001EA" , blcic(rcx, rdx)); + TEST_INSTRUCTION("8FE9F001AC1A80000000" , blcic(rcx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("8FE9F001AC1A80000000" , blcic(rcx, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("8FE97002CA" , blcmsk(ecx, edx)); + TEST_INSTRUCTION("8FE970028C1A80000000" , blcmsk(ecx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("8FE970028C1A80000000" , blcmsk(ecx, dword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("8FE9F002CA" , blcmsk(rcx, rdx)); + TEST_INSTRUCTION("8FE9F0028C1A80000000" , blcmsk(rcx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("8FE9F0028C1A80000000" , blcmsk(rcx, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("8FE97001DA" , blcs(ecx, edx)); + TEST_INSTRUCTION("8FE970019C1A80000000" , blcs(ecx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("8FE970019C1A80000000" , blcs(ecx, dword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("8FE9F001DA" , blcs(rcx, rdx)); + TEST_INSTRUCTION("8FE9F0019C1A80000000" , blcs(rcx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("8FE9F0019C1A80000000" , blcs(rcx, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("8FE97001D2" , blsfill(ecx, edx)); + TEST_INSTRUCTION("8FE97001941A80000000" , blsfill(ecx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("8FE97001941A80000000" , blsfill(ecx, dword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("8FE9F001D2" , blsfill(rcx, rdx)); + TEST_INSTRUCTION("8FE9F001941A80000000" , blsfill(rcx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("8FE9F001941A80000000" , blsfill(rcx, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C4E270F3DA" , blsi(ecx, edx)); + TEST_INSTRUCTION("C4E270F39C1A80000000" , blsi(ecx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C4E270F39C1A80000000" , blsi(ecx, dword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C4E2F0F3DA" , blsi(rcx, rdx)); + TEST_INSTRUCTION("C4E2F0F39C1A80000000" , blsi(rcx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C4E2F0F39C1A80000000" , blsi(rcx, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("8FE97001F2" , blsic(ecx, edx)); + TEST_INSTRUCTION("8FE97001B41A80000000" , blsic(ecx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("8FE97001B41A80000000" , blsic(ecx, dword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("8FE9F001F2" , blsic(rcx, rdx)); + TEST_INSTRUCTION("8FE9F001B41A80000000" , blsic(rcx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("8FE9F001B41A80000000" , blsic(rcx, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C4E270F3D2" , blsmsk(ecx, edx)); + TEST_INSTRUCTION("C4E270F3941A80000000" , blsmsk(ecx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C4E270F3941A80000000" , blsmsk(ecx, dword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C4E2F0F3D2" , blsmsk(rcx, rdx)); + TEST_INSTRUCTION("C4E2F0F3941A80000000" , blsmsk(rcx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C4E2F0F3941A80000000" , blsmsk(rcx, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C4E270F3CA" , blsr(ecx, edx)); + TEST_INSTRUCTION("C4E270F38C1A80000000" , blsr(ecx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C4E270F38C1A80000000" , blsr(ecx, dword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C4E2F0F3CA" , blsr(rcx, rdx)); + TEST_INSTRUCTION("C4E2F0F38C1A80000000" , blsr(rcx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C4E2F0F38C1A80000000" , blsr(rcx, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("F30F1ACA" , bndcl(bnd1, rdx)); + TEST_INSTRUCTION("F30F1A8C1A80000000" , bndcl(bnd1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("F30F1A8C1A80000000" , bndcl(bnd1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("F20F1BCA" , bndcn(bnd1, rdx)); + TEST_INSTRUCTION("F20F1B8C1A80000000" , bndcn(bnd1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("F20F1B8C1A80000000" , bndcn(bnd1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("F20F1ACA" , bndcu(bnd1, rdx)); + TEST_INSTRUCTION("F20F1A8C1A80000000" , bndcu(bnd1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("F20F1A8C1A80000000" , bndcu(bnd1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F1A8C1A80000000" , bndldx(bnd1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("F30F1B8C1A80000000" , bndmk(bnd1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F1ACA" , bndmov(bnd1, bnd2)); + TEST_INSTRUCTION("660F1A8C1A80000000" , bndmov(bnd1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F1B9C1180000000" , bndmov(ptr(rcx, rdx, 0, 128), bnd3)); + TEST_INSTRUCTION("0F1B9C1180000000" , bndstx(ptr(rcx, rdx, 0, 128), bnd3)); + TEST_INSTRUCTION("660FBCCA" , bsf(cx, dx)); + TEST_INSTRUCTION("660FBC8C1A80000000" , bsf(cx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660FBC8C1A80000000" , bsf(cx, word_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0FBCCA" , bsf(ecx, edx)); + TEST_INSTRUCTION("0FBC8C1A80000000" , bsf(ecx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0FBC8C1A80000000" , bsf(ecx, dword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("480FBCCA" , bsf(rcx, rdx)); + TEST_INSTRUCTION("480FBC8C1A80000000" , bsf(rcx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("480FBC8C1A80000000" , bsf(rcx, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660FBDCA" , bsr(cx, dx)); + TEST_INSTRUCTION("660FBD8C1A80000000" , bsr(cx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660FBD8C1A80000000" , bsr(cx, word_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0FBDCA" , bsr(ecx, edx)); + TEST_INSTRUCTION("0FBD8C1A80000000" , bsr(ecx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0FBD8C1A80000000" , bsr(ecx, dword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("480FBDCA" , bsr(rcx, rdx)); + TEST_INSTRUCTION("480FBD8C1A80000000" , bsr(rcx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("480FBD8C1A80000000" , bsr(rcx, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660FC9" , bswap(cx)); + TEST_INSTRUCTION("0FC9" , bswap(ecx)); + TEST_INSTRUCTION("480FC9" , bswap(rcx)); + TEST_INSTRUCTION("660FBAE101" , bt(cx, 1)); + TEST_INSTRUCTION("0FBAE101" , bt(ecx, 1)); + TEST_INSTRUCTION("480FBAE101" , bt(rcx, 1)); + TEST_INSTRUCTION("660FBAA4118000000001" , bt(word_ptr(rcx, rdx, 0, 128), 1)); + TEST_INSTRUCTION("0FBAA4118000000001" , bt(dword_ptr(rcx, rdx, 0, 128), 1)); + TEST_INSTRUCTION("480FBAA4118000000001" , bt(qword_ptr(rcx, rdx, 0, 128), 1)); + TEST_INSTRUCTION("660FA3D1" , bt(cx, dx)); + TEST_INSTRUCTION("660FA39C1180000000" , bt(ptr(rcx, rdx, 0, 128), bx)); + TEST_INSTRUCTION("660FA39C1180000000" , bt(word_ptr(rcx, rdx, 0, 128), bx)); + TEST_INSTRUCTION("0FA3D1" , bt(ecx, edx)); + TEST_INSTRUCTION("0FA39C1180000000" , bt(ptr(rcx, rdx, 0, 128), ebx)); + TEST_INSTRUCTION("0FA39C1180000000" , bt(dword_ptr(rcx, rdx, 0, 128), ebx)); + TEST_INSTRUCTION("480FA3D1" , bt(rcx, rdx)); + TEST_INSTRUCTION("480FA39C1180000000" , bt(ptr(rcx, rdx, 0, 128), rbx)); + TEST_INSTRUCTION("480FA39C1180000000" , bt(qword_ptr(rcx, rdx, 0, 128), rbx)); + TEST_INSTRUCTION("660FBAF901" , btc(cx, 1)); + TEST_INSTRUCTION("0FBAF901" , btc(ecx, 1)); + TEST_INSTRUCTION("480FBAF901" , btc(rcx, 1)); + TEST_INSTRUCTION("660FBABC118000000001" , btc(word_ptr(rcx, rdx, 0, 128), 1)); + TEST_INSTRUCTION("0FBABC118000000001" , btc(dword_ptr(rcx, rdx, 0, 128), 1)); + TEST_INSTRUCTION("480FBABC118000000001" , btc(qword_ptr(rcx, rdx, 0, 128), 1)); + TEST_INSTRUCTION("660FBBD1" , btc(cx, dx)); + TEST_INSTRUCTION("660FBB9C1180000000" , btc(ptr(rcx, rdx, 0, 128), bx)); + TEST_INSTRUCTION("660FBB9C1180000000" , btc(word_ptr(rcx, rdx, 0, 128), bx)); + TEST_INSTRUCTION("0FBBD1" , btc(ecx, edx)); + TEST_INSTRUCTION("0FBB9C1180000000" , btc(ptr(rcx, rdx, 0, 128), ebx)); + TEST_INSTRUCTION("0FBB9C1180000000" , btc(dword_ptr(rcx, rdx, 0, 128), ebx)); + TEST_INSTRUCTION("480FBBD1" , btc(rcx, rdx)); + TEST_INSTRUCTION("480FBB9C1180000000" , btc(ptr(rcx, rdx, 0, 128), rbx)); + TEST_INSTRUCTION("480FBB9C1180000000" , btc(qword_ptr(rcx, rdx, 0, 128), rbx)); + TEST_INSTRUCTION("660FBAF101" , btr(cx, 1)); + TEST_INSTRUCTION("0FBAF101" , btr(ecx, 1)); + TEST_INSTRUCTION("480FBAF101" , btr(rcx, 1)); + TEST_INSTRUCTION("660FBAB4118000000001" , btr(word_ptr(rcx, rdx, 0, 128), 1)); + TEST_INSTRUCTION("0FBAB4118000000001" , btr(dword_ptr(rcx, rdx, 0, 128), 1)); + TEST_INSTRUCTION("480FBAB4118000000001" , btr(qword_ptr(rcx, rdx, 0, 128), 1)); + TEST_INSTRUCTION("660FB3D1" , btr(cx, dx)); + TEST_INSTRUCTION("660FB39C1180000000" , btr(ptr(rcx, rdx, 0, 128), bx)); + TEST_INSTRUCTION("660FB39C1180000000" , btr(word_ptr(rcx, rdx, 0, 128), bx)); + TEST_INSTRUCTION("0FB3D1" , btr(ecx, edx)); + TEST_INSTRUCTION("0FB39C1180000000" , btr(ptr(rcx, rdx, 0, 128), ebx)); + TEST_INSTRUCTION("0FB39C1180000000" , btr(dword_ptr(rcx, rdx, 0, 128), ebx)); + TEST_INSTRUCTION("480FB3D1" , btr(rcx, rdx)); + TEST_INSTRUCTION("480FB39C1180000000" , btr(ptr(rcx, rdx, 0, 128), rbx)); + TEST_INSTRUCTION("480FB39C1180000000" , btr(qword_ptr(rcx, rdx, 0, 128), rbx)); + TEST_INSTRUCTION("660FBAE901" , bts(cx, 1)); + TEST_INSTRUCTION("0FBAE901" , bts(ecx, 1)); + TEST_INSTRUCTION("480FBAE901" , bts(rcx, 1)); + TEST_INSTRUCTION("660FBAAC118000000001" , bts(word_ptr(rcx, rdx, 0, 128), 1)); + TEST_INSTRUCTION("0FBAAC118000000001" , bts(dword_ptr(rcx, rdx, 0, 128), 1)); + TEST_INSTRUCTION("480FBAAC118000000001" , bts(qword_ptr(rcx, rdx, 0, 128), 1)); + TEST_INSTRUCTION("660FABD1" , bts(cx, dx)); + TEST_INSTRUCTION("660FAB9C1180000000" , bts(ptr(rcx, rdx, 0, 128), bx)); + TEST_INSTRUCTION("660FAB9C1180000000" , bts(word_ptr(rcx, rdx, 0, 128), bx)); + TEST_INSTRUCTION("0FABD1" , bts(ecx, edx)); + TEST_INSTRUCTION("0FAB9C1180000000" , bts(ptr(rcx, rdx, 0, 128), ebx)); + TEST_INSTRUCTION("0FAB9C1180000000" , bts(dword_ptr(rcx, rdx, 0, 128), ebx)); + TEST_INSTRUCTION("480FABD1" , bts(rcx, rdx)); + TEST_INSTRUCTION("480FAB9C1180000000" , bts(ptr(rcx, rdx, 0, 128), rbx)); + TEST_INSTRUCTION("480FAB9C1180000000" , bts(qword_ptr(rcx, rdx, 0, 128), rbx)); + TEST_INSTRUCTION("C4E260F5CA" , bzhi(ecx, edx, ebx)); + TEST_INSTRUCTION("C4E258F58C1A80000000" , bzhi(ecx, ptr(rdx, rbx, 0, 128), esp)); + TEST_INSTRUCTION("C4E258F58C1A80000000" , bzhi(ecx, dword_ptr(rdx, rbx, 0, 128), esp)); + TEST_INSTRUCTION("C4E2E0F5CA" , bzhi(rcx, rdx, rbx)); + TEST_INSTRUCTION("C4E2D8F58C1A80000000" , bzhi(rcx, ptr(rdx, rbx, 0, 128), rsp)); + TEST_INSTRUCTION("C4E2D8F58C1A80000000" , bzhi(rcx, qword_ptr(rdx, rbx, 0, 128), rsp)); + TEST_INSTRUCTION("6698" , cbw(ax)); + TEST_INSTRUCTION("99" , cdq(edx, eax)); + TEST_INSTRUCTION("4898" , cdqe(rax)); + TEST_INSTRUCTION("0F01CA" , clac()); + TEST_INSTRUCTION("F8" , clc()); + TEST_INSTRUCTION("FC" , cld()); + TEST_INSTRUCTION("0F1C841180000000" , cldemote(ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("0FAEBC1180000000" , clflush(ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("660FAEBC1180000000" , clflushopt(ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("0F01DD" , clgi()); + TEST_INSTRUCTION("FA" , cli()); + TEST_INSTRUCTION("F30FAEB41180000000" , clrssbsy(ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("F30FAEB41180000000" , clrssbsy(qword_ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("0F06" , clts()); + TEST_INSTRUCTION("F30F01EE" , clui()); + TEST_INSTRUCTION("660FAEB41180000000" , clwb(ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("0F01FC" , clzero(ptr(rax))); + TEST_INSTRUCTION("0F01FC" , clzero(zmmword_ptr(rax))); + TEST_INSTRUCTION("F5" , cmc()); + TEST_INSTRUCTION("660F47CA" , cmova(cx, dx)); + TEST_INSTRUCTION("660F478C1A80000000" , cmova(cx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F478C1A80000000" , cmova(cx, word_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F47CA" , cmova(ecx, edx)); + TEST_INSTRUCTION("0F478C1A80000000" , cmova(ecx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F478C1A80000000" , cmova(ecx, dword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("480F47CA" , cmova(rcx, rdx)); + TEST_INSTRUCTION("480F478C1A80000000" , cmova(rcx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("480F478C1A80000000" , cmova(rcx, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F43CA" , cmovae(cx, dx)); + TEST_INSTRUCTION("660F438C1A80000000" , cmovae(cx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F438C1A80000000" , cmovae(cx, word_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F43CA" , cmovae(ecx, edx)); + TEST_INSTRUCTION("0F438C1A80000000" , cmovae(ecx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F438C1A80000000" , cmovae(ecx, dword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("480F43CA" , cmovae(rcx, rdx)); + TEST_INSTRUCTION("480F438C1A80000000" , cmovae(rcx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("480F438C1A80000000" , cmovae(rcx, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F42CA" , cmovb(cx, dx)); + TEST_INSTRUCTION("660F428C1A80000000" , cmovb(cx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F428C1A80000000" , cmovb(cx, word_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F42CA" , cmovb(ecx, edx)); + TEST_INSTRUCTION("0F428C1A80000000" , cmovb(ecx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F428C1A80000000" , cmovb(ecx, dword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("480F42CA" , cmovb(rcx, rdx)); + TEST_INSTRUCTION("480F428C1A80000000" , cmovb(rcx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("480F428C1A80000000" , cmovb(rcx, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F46CA" , cmovbe(cx, dx)); + TEST_INSTRUCTION("660F468C1A80000000" , cmovbe(cx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F468C1A80000000" , cmovbe(cx, word_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F46CA" , cmovbe(ecx, edx)); + TEST_INSTRUCTION("0F468C1A80000000" , cmovbe(ecx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F468C1A80000000" , cmovbe(ecx, dword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("480F46CA" , cmovbe(rcx, rdx)); + TEST_INSTRUCTION("480F468C1A80000000" , cmovbe(rcx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("480F468C1A80000000" , cmovbe(rcx, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F42CA" , cmovc(cx, dx)); + TEST_INSTRUCTION("660F428C1A80000000" , cmovc(cx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F428C1A80000000" , cmovc(cx, word_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F42CA" , cmovc(ecx, edx)); + TEST_INSTRUCTION("0F428C1A80000000" , cmovc(ecx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F428C1A80000000" , cmovc(ecx, dword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("480F42CA" , cmovc(rcx, rdx)); + TEST_INSTRUCTION("480F428C1A80000000" , cmovc(rcx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("480F428C1A80000000" , cmovc(rcx, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F44CA" , cmove(cx, dx)); + TEST_INSTRUCTION("660F448C1A80000000" , cmove(cx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F448C1A80000000" , cmove(cx, word_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F44CA" , cmove(ecx, edx)); + TEST_INSTRUCTION("0F448C1A80000000" , cmove(ecx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F448C1A80000000" , cmove(ecx, dword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("480F44CA" , cmove(rcx, rdx)); + TEST_INSTRUCTION("480F448C1A80000000" , cmove(rcx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("480F448C1A80000000" , cmove(rcx, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F4FCA" , cmovg(cx, dx)); + TEST_INSTRUCTION("660F4F8C1A80000000" , cmovg(cx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F4F8C1A80000000" , cmovg(cx, word_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F4FCA" , cmovg(ecx, edx)); + TEST_INSTRUCTION("0F4F8C1A80000000" , cmovg(ecx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F4F8C1A80000000" , cmovg(ecx, dword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("480F4FCA" , cmovg(rcx, rdx)); + TEST_INSTRUCTION("480F4F8C1A80000000" , cmovg(rcx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("480F4F8C1A80000000" , cmovg(rcx, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F4DCA" , cmovge(cx, dx)); + TEST_INSTRUCTION("660F4D8C1A80000000" , cmovge(cx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F4D8C1A80000000" , cmovge(cx, word_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F4DCA" , cmovge(ecx, edx)); + TEST_INSTRUCTION("0F4D8C1A80000000" , cmovge(ecx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F4D8C1A80000000" , cmovge(ecx, dword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("480F4DCA" , cmovge(rcx, rdx)); + TEST_INSTRUCTION("480F4D8C1A80000000" , cmovge(rcx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("480F4D8C1A80000000" , cmovge(rcx, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F4CCA" , cmovl(cx, dx)); + TEST_INSTRUCTION("660F4C8C1A80000000" , cmovl(cx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F4C8C1A80000000" , cmovl(cx, word_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F4CCA" , cmovl(ecx, edx)); + TEST_INSTRUCTION("0F4C8C1A80000000" , cmovl(ecx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F4C8C1A80000000" , cmovl(ecx, dword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("480F4CCA" , cmovl(rcx, rdx)); + TEST_INSTRUCTION("480F4C8C1A80000000" , cmovl(rcx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("480F4C8C1A80000000" , cmovl(rcx, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F4ECA" , cmovle(cx, dx)); + TEST_INSTRUCTION("660F4E8C1A80000000" , cmovle(cx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F4E8C1A80000000" , cmovle(cx, word_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F4ECA" , cmovle(ecx, edx)); + TEST_INSTRUCTION("0F4E8C1A80000000" , cmovle(ecx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F4E8C1A80000000" , cmovle(ecx, dword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("480F4ECA" , cmovle(rcx, rdx)); + TEST_INSTRUCTION("480F4E8C1A80000000" , cmovle(rcx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("480F4E8C1A80000000" , cmovle(rcx, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F46CA" , cmovna(cx, dx)); + TEST_INSTRUCTION("660F468C1A80000000" , cmovna(cx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F468C1A80000000" , cmovna(cx, word_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F46CA" , cmovna(ecx, edx)); + TEST_INSTRUCTION("0F468C1A80000000" , cmovna(ecx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F468C1A80000000" , cmovna(ecx, dword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("480F46CA" , cmovna(rcx, rdx)); + TEST_INSTRUCTION("480F468C1A80000000" , cmovna(rcx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("480F468C1A80000000" , cmovna(rcx, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F42CA" , cmovnae(cx, dx)); + TEST_INSTRUCTION("660F428C1A80000000" , cmovnae(cx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F428C1A80000000" , cmovnae(cx, word_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F42CA" , cmovnae(ecx, edx)); + TEST_INSTRUCTION("0F428C1A80000000" , cmovnae(ecx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F428C1A80000000" , cmovnae(ecx, dword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("480F42CA" , cmovnae(rcx, rdx)); + TEST_INSTRUCTION("480F428C1A80000000" , cmovnae(rcx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("480F428C1A80000000" , cmovnae(rcx, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F43CA" , cmovnb(cx, dx)); + TEST_INSTRUCTION("660F438C1A80000000" , cmovnb(cx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F438C1A80000000" , cmovnb(cx, word_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F43CA" , cmovnb(ecx, edx)); + TEST_INSTRUCTION("0F438C1A80000000" , cmovnb(ecx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F438C1A80000000" , cmovnb(ecx, dword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("480F43CA" , cmovnb(rcx, rdx)); + TEST_INSTRUCTION("480F438C1A80000000" , cmovnb(rcx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("480F438C1A80000000" , cmovnb(rcx, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F47CA" , cmovnbe(cx, dx)); + TEST_INSTRUCTION("660F478C1A80000000" , cmovnbe(cx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F478C1A80000000" , cmovnbe(cx, word_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F47CA" , cmovnbe(ecx, edx)); + TEST_INSTRUCTION("0F478C1A80000000" , cmovnbe(ecx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F478C1A80000000" , cmovnbe(ecx, dword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("480F47CA" , cmovnbe(rcx, rdx)); + TEST_INSTRUCTION("480F478C1A80000000" , cmovnbe(rcx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("480F478C1A80000000" , cmovnbe(rcx, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F43CA" , cmovnc(cx, dx)); + TEST_INSTRUCTION("660F438C1A80000000" , cmovnc(cx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F438C1A80000000" , cmovnc(cx, word_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F43CA" , cmovnc(ecx, edx)); + TEST_INSTRUCTION("0F438C1A80000000" , cmovnc(ecx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F438C1A80000000" , cmovnc(ecx, dword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("480F43CA" , cmovnc(rcx, rdx)); + TEST_INSTRUCTION("480F438C1A80000000" , cmovnc(rcx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("480F438C1A80000000" , cmovnc(rcx, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F45CA" , cmovne(cx, dx)); + TEST_INSTRUCTION("660F458C1A80000000" , cmovne(cx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F458C1A80000000" , cmovne(cx, word_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F45CA" , cmovne(ecx, edx)); + TEST_INSTRUCTION("0F458C1A80000000" , cmovne(ecx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F458C1A80000000" , cmovne(ecx, dword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("480F45CA" , cmovne(rcx, rdx)); + TEST_INSTRUCTION("480F458C1A80000000" , cmovne(rcx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("480F458C1A80000000" , cmovne(rcx, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F4ECA" , cmovng(cx, dx)); + TEST_INSTRUCTION("660F4E8C1A80000000" , cmovng(cx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F4E8C1A80000000" , cmovng(cx, word_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F4ECA" , cmovng(ecx, edx)); + TEST_INSTRUCTION("0F4E8C1A80000000" , cmovng(ecx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F4E8C1A80000000" , cmovng(ecx, dword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("480F4ECA" , cmovng(rcx, rdx)); + TEST_INSTRUCTION("480F4E8C1A80000000" , cmovng(rcx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("480F4E8C1A80000000" , cmovng(rcx, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F4CCA" , cmovnge(cx, dx)); + TEST_INSTRUCTION("660F4C8C1A80000000" , cmovnge(cx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F4C8C1A80000000" , cmovnge(cx, word_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F4CCA" , cmovnge(ecx, edx)); + TEST_INSTRUCTION("0F4C8C1A80000000" , cmovnge(ecx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F4C8C1A80000000" , cmovnge(ecx, dword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("480F4CCA" , cmovnge(rcx, rdx)); + TEST_INSTRUCTION("480F4C8C1A80000000" , cmovnge(rcx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("480F4C8C1A80000000" , cmovnge(rcx, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F4DCA" , cmovnl(cx, dx)); + TEST_INSTRUCTION("660F4D8C1A80000000" , cmovnl(cx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F4D8C1A80000000" , cmovnl(cx, word_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F4DCA" , cmovnl(ecx, edx)); + TEST_INSTRUCTION("0F4D8C1A80000000" , cmovnl(ecx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F4D8C1A80000000" , cmovnl(ecx, dword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("480F4DCA" , cmovnl(rcx, rdx)); + TEST_INSTRUCTION("480F4D8C1A80000000" , cmovnl(rcx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("480F4D8C1A80000000" , cmovnl(rcx, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F4FCA" , cmovnle(cx, dx)); + TEST_INSTRUCTION("660F4F8C1A80000000" , cmovnle(cx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F4F8C1A80000000" , cmovnle(cx, word_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F4FCA" , cmovnle(ecx, edx)); + TEST_INSTRUCTION("0F4F8C1A80000000" , cmovnle(ecx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F4F8C1A80000000" , cmovnle(ecx, dword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("480F4FCA" , cmovnle(rcx, rdx)); + TEST_INSTRUCTION("480F4F8C1A80000000" , cmovnle(rcx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("480F4F8C1A80000000" , cmovnle(rcx, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F41CA" , cmovno(cx, dx)); + TEST_INSTRUCTION("660F418C1A80000000" , cmovno(cx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F418C1A80000000" , cmovno(cx, word_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F41CA" , cmovno(ecx, edx)); + TEST_INSTRUCTION("0F418C1A80000000" , cmovno(ecx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F418C1A80000000" , cmovno(ecx, dword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("480F41CA" , cmovno(rcx, rdx)); + TEST_INSTRUCTION("480F418C1A80000000" , cmovno(rcx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("480F418C1A80000000" , cmovno(rcx, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F4BCA" , cmovnp(cx, dx)); + TEST_INSTRUCTION("660F4B8C1A80000000" , cmovnp(cx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F4B8C1A80000000" , cmovnp(cx, word_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F4BCA" , cmovnp(ecx, edx)); + TEST_INSTRUCTION("0F4B8C1A80000000" , cmovnp(ecx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F4B8C1A80000000" , cmovnp(ecx, dword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("480F4BCA" , cmovnp(rcx, rdx)); + TEST_INSTRUCTION("480F4B8C1A80000000" , cmovnp(rcx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("480F4B8C1A80000000" , cmovnp(rcx, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F49CA" , cmovns(cx, dx)); + TEST_INSTRUCTION("660F498C1A80000000" , cmovns(cx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F498C1A80000000" , cmovns(cx, word_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F49CA" , cmovns(ecx, edx)); + TEST_INSTRUCTION("0F498C1A80000000" , cmovns(ecx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F498C1A80000000" , cmovns(ecx, dword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("480F49CA" , cmovns(rcx, rdx)); + TEST_INSTRUCTION("480F498C1A80000000" , cmovns(rcx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("480F498C1A80000000" , cmovns(rcx, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F45CA" , cmovnz(cx, dx)); + TEST_INSTRUCTION("660F458C1A80000000" , cmovnz(cx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F458C1A80000000" , cmovnz(cx, word_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F45CA" , cmovnz(ecx, edx)); + TEST_INSTRUCTION("0F458C1A80000000" , cmovnz(ecx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F458C1A80000000" , cmovnz(ecx, dword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("480F45CA" , cmovnz(rcx, rdx)); + TEST_INSTRUCTION("480F458C1A80000000" , cmovnz(rcx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("480F458C1A80000000" , cmovnz(rcx, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F40CA" , cmovo(cx, dx)); + TEST_INSTRUCTION("660F408C1A80000000" , cmovo(cx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F408C1A80000000" , cmovo(cx, word_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F40CA" , cmovo(ecx, edx)); + TEST_INSTRUCTION("0F408C1A80000000" , cmovo(ecx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F408C1A80000000" , cmovo(ecx, dword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("480F40CA" , cmovo(rcx, rdx)); + TEST_INSTRUCTION("480F408C1A80000000" , cmovo(rcx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("480F408C1A80000000" , cmovo(rcx, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F4ACA" , cmovp(cx, dx)); + TEST_INSTRUCTION("660F4A8C1A80000000" , cmovp(cx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F4A8C1A80000000" , cmovp(cx, word_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F4ACA" , cmovp(ecx, edx)); + TEST_INSTRUCTION("0F4A8C1A80000000" , cmovp(ecx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F4A8C1A80000000" , cmovp(ecx, dword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("480F4ACA" , cmovp(rcx, rdx)); + TEST_INSTRUCTION("480F4A8C1A80000000" , cmovp(rcx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("480F4A8C1A80000000" , cmovp(rcx, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F4ACA" , cmovpe(cx, dx)); + TEST_INSTRUCTION("660F4A8C1A80000000" , cmovpe(cx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F4A8C1A80000000" , cmovpe(cx, word_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F4ACA" , cmovpe(ecx, edx)); + TEST_INSTRUCTION("0F4A8C1A80000000" , cmovpe(ecx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F4A8C1A80000000" , cmovpe(ecx, dword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("480F4ACA" , cmovpe(rcx, rdx)); + TEST_INSTRUCTION("480F4A8C1A80000000" , cmovpe(rcx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("480F4A8C1A80000000" , cmovpe(rcx, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F4BCA" , cmovpo(cx, dx)); + TEST_INSTRUCTION("660F4B8C1A80000000" , cmovpo(cx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F4B8C1A80000000" , cmovpo(cx, word_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F4BCA" , cmovpo(ecx, edx)); + TEST_INSTRUCTION("0F4B8C1A80000000" , cmovpo(ecx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F4B8C1A80000000" , cmovpo(ecx, dword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("480F4BCA" , cmovpo(rcx, rdx)); + TEST_INSTRUCTION("480F4B8C1A80000000" , cmovpo(rcx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("480F4B8C1A80000000" , cmovpo(rcx, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F48CA" , cmovs(cx, dx)); + TEST_INSTRUCTION("660F488C1A80000000" , cmovs(cx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F488C1A80000000" , cmovs(cx, word_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F48CA" , cmovs(ecx, edx)); + TEST_INSTRUCTION("0F488C1A80000000" , cmovs(ecx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F488C1A80000000" , cmovs(ecx, dword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("480F48CA" , cmovs(rcx, rdx)); + TEST_INSTRUCTION("480F488C1A80000000" , cmovs(rcx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("480F488C1A80000000" , cmovs(rcx, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F44CA" , cmovz(cx, dx)); + TEST_INSTRUCTION("660F448C1A80000000" , cmovz(cx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F448C1A80000000" , cmovz(cx, word_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F44CA" , cmovz(ecx, edx)); + TEST_INSTRUCTION("0F448C1A80000000" , cmovz(ecx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F448C1A80000000" , cmovz(ecx, dword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("480F44CA" , cmovz(rcx, rdx)); + TEST_INSTRUCTION("480F448C1A80000000" , cmovz(rcx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("480F448C1A80000000" , cmovz(rcx, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("80F901" , cmp(cl, 1)); + TEST_INSTRUCTION("80FD01" , cmp(ch, 1)); + TEST_INSTRUCTION("80BC118000000001" , cmp(byte_ptr(rcx, rdx, 0, 128), 1)); + TEST_INSTRUCTION("6683F901" , cmp(cx, 1)); + TEST_INSTRUCTION("6683BC118000000001" , cmp(word_ptr(rcx, rdx, 0, 128), 1)); + TEST_INSTRUCTION("83F901" , cmp(ecx, 1)); + TEST_INSTRUCTION("83BC118000000001" , cmp(dword_ptr(rcx, rdx, 0, 128), 1)); + TEST_INSTRUCTION("4839D1" , cmp(rcx, rdx)); + TEST_INSTRUCTION("4883F901" , cmp(rcx, 1)); + TEST_INSTRUCTION("48399C1180000000" , cmp(ptr(rcx, rdx, 0, 128), rbx)); + TEST_INSTRUCTION("48399C1180000000" , cmp(qword_ptr(rcx, rdx, 0, 128), rbx)); + TEST_INSTRUCTION("4883BC118000000001" , cmp(qword_ptr(rcx, rdx, 0, 128), 1)); + TEST_INSTRUCTION("38D1" , cmp(cl, dl)); + TEST_INSTRUCTION("38F1" , cmp(cl, dh)); + TEST_INSTRUCTION("38D5" , cmp(ch, dl)); + TEST_INSTRUCTION("38F5" , cmp(ch, dh)); + TEST_INSTRUCTION("389C1180000000" , cmp(ptr(rcx, rdx, 0, 128), bl)); + TEST_INSTRUCTION("38BC1180000000" , cmp(ptr(rcx, rdx, 0, 128), bh)); + TEST_INSTRUCTION("389C1180000000" , cmp(byte_ptr(rcx, rdx, 0, 128), bl)); + TEST_INSTRUCTION("38BC1180000000" , cmp(byte_ptr(rcx, rdx, 0, 128), bh)); + TEST_INSTRUCTION("6639D1" , cmp(cx, dx)); + TEST_INSTRUCTION("66399C1180000000" , cmp(ptr(rcx, rdx, 0, 128), bx)); + TEST_INSTRUCTION("66399C1180000000" , cmp(word_ptr(rcx, rdx, 0, 128), bx)); + TEST_INSTRUCTION("39D1" , cmp(ecx, edx)); + TEST_INSTRUCTION("399C1180000000" , cmp(ptr(rcx, rdx, 0, 128), ebx)); + TEST_INSTRUCTION("399C1180000000" , cmp(dword_ptr(rcx, rdx, 0, 128), ebx)); + TEST_INSTRUCTION("3A8C1A80000000" , cmp(cl, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("3A8C1A80000000" , cmp(cl, byte_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("3AAC1A80000000" , cmp(ch, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("3AAC1A80000000" , cmp(ch, byte_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("663B8C1A80000000" , cmp(cx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("663B8C1A80000000" , cmp(cx, word_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("3B8C1A80000000" , cmp(ecx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("3B8C1A80000000" , cmp(ecx, dword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("483B8C1A80000000" , cmp(rcx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("483B8C1A80000000" , cmp(rcx, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("A6" , cmps(byte_ptr(rsi), byte_ptr(rdi))); + TEST_INSTRUCTION("66A7" , cmps(word_ptr(rsi), word_ptr(rdi))); + TEST_INSTRUCTION("A7" , cmps(dword_ptr(rsi), dword_ptr(rdi))); + TEST_INSTRUCTION("48A7" , cmps(qword_ptr(rsi), qword_ptr(rdi))); + TEST_INSTRUCTION("0FB0D1" , cmpxchg(cl, dl, al)); + TEST_INSTRUCTION("0FB0F1" , cmpxchg(cl, dh, al)); + TEST_INSTRUCTION("0FB0D5" , cmpxchg(ch, dl, al)); + TEST_INSTRUCTION("0FB0F5" , cmpxchg(ch, dh, al)); + TEST_INSTRUCTION("0FB09C1180000000" , cmpxchg(ptr(rcx, rdx, 0, 128), bl, al)); + TEST_INSTRUCTION("0FB0BC1180000000" , cmpxchg(ptr(rcx, rdx, 0, 128), bh, al)); + TEST_INSTRUCTION("0FB09C1180000000" , cmpxchg(byte_ptr(rcx, rdx, 0, 128), bl, al)); + TEST_INSTRUCTION("0FB0BC1180000000" , cmpxchg(byte_ptr(rcx, rdx, 0, 128), bh, al)); + TEST_INSTRUCTION("660FB1D1" , cmpxchg(cx, dx, ax)); + TEST_INSTRUCTION("660FB19C1180000000" , cmpxchg(ptr(rcx, rdx, 0, 128), bx, ax)); + TEST_INSTRUCTION("660FB19C1180000000" , cmpxchg(word_ptr(rcx, rdx, 0, 128), bx, ax)); + TEST_INSTRUCTION("0FB1D1" , cmpxchg(ecx, edx, eax)); + TEST_INSTRUCTION("0FB19C1180000000" , cmpxchg(ptr(rcx, rdx, 0, 128), ebx, eax)); + TEST_INSTRUCTION("0FB19C1180000000" , cmpxchg(dword_ptr(rcx, rdx, 0, 128), ebx, eax)); + TEST_INSTRUCTION("480FB1D1" , cmpxchg(rcx, rdx, rax)); + TEST_INSTRUCTION("480FB19C1180000000" , cmpxchg(ptr(rcx, rdx, 0, 128), rbx, rax)); + TEST_INSTRUCTION("480FB19C1180000000" , cmpxchg(qword_ptr(rcx, rdx, 0, 128), rbx, rax)); + TEST_INSTRUCTION("480FC78C1180000000" , cmpxchg16b(ptr(rcx, rdx, 0, 128), rdx, rax, rcx, rbx)); + TEST_INSTRUCTION("480FC78C1180000000" , cmpxchg16b(xmmword_ptr(rcx, rdx, 0, 128), rdx, rax, rcx, rbx)); + TEST_INSTRUCTION("0FC78C1180000000" , cmpxchg8b(ptr(rcx, rdx, 0, 128), edx, eax, ecx, ebx)); + TEST_INSTRUCTION("0FC78C1180000000" , cmpxchg8b(qword_ptr(rcx, rdx, 0, 128), edx, eax, ecx, ebx)); + TEST_INSTRUCTION("0FA2" , cpuid(eax, ebx, ecx, edx)); + TEST_INSTRUCTION("4899" , cqo(rdx, rax)); + TEST_INSTRUCTION("F20F38F0CA" , crc32(ecx, dl)); + TEST_INSTRUCTION("F20F38F0CE" , crc32(ecx, dh)); + TEST_INSTRUCTION("66F20F38F1CA" , crc32(ecx, dx)); + TEST_INSTRUCTION("F20F38F1CA" , crc32(ecx, edx)); + TEST_INSTRUCTION("F20F38F08C1A80000000" , crc32(ecx, byte_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("66F20F38F18C1A80000000" , crc32(ecx, word_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("F20F38F18C1A80000000" , crc32(ecx, dword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("F2480F38F0CA" , crc32(rcx, dl)); + TEST_INSTRUCTION("F2480F38F1CA" , crc32(rcx, rdx)); + TEST_INSTRUCTION("F2480F38F08C1A80000000" , crc32(rcx, byte_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("F2480F38F18C1A80000000" , crc32(rcx, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("6699" , cwd(dx, ax)); + TEST_INSTRUCTION("98" , cwde(eax)); + TEST_INSTRUCTION("FEC9" , dec(cl)); + TEST_INSTRUCTION("FECD" , dec(ch)); + TEST_INSTRUCTION("66FFC9" , dec(cx)); + TEST_INSTRUCTION("FFC9" , dec(ecx)); + TEST_INSTRUCTION("48FFC9" , dec(rcx)); + TEST_INSTRUCTION("FE8C1180000000" , dec(byte_ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("66FF8C1180000000" , dec(word_ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("FF8C1180000000" , dec(dword_ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("48FF8C1180000000" , dec(qword_ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("F6F1" , div(ax, cl)); + TEST_INSTRUCTION("F6F5" , div(ax, ch)); + TEST_INSTRUCTION("F6B41180000000" , div(ax, ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("F6B41180000000" , div(ax, byte_ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("66F7F1" , div(dx, ax, cx)); + TEST_INSTRUCTION("66F7B41180000000" , div(dx, ax, ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("66F7B41180000000" , div(dx, ax, word_ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("F7F1" , div(edx, eax, ecx)); + TEST_INSTRUCTION("F7B41180000000" , div(edx, eax, ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("F7B41180000000" , div(edx, eax, dword_ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("48F7F1" , div(rdx, rax, rcx)); + TEST_INSTRUCTION("48F7B41180000000" , div(rdx, rax, ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("48F7B41180000000" , div(rdx, rax, qword_ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("F30F1EFB" , endbr32()); + TEST_INSTRUCTION("F30F1EFA" , endbr64()); + TEST_INSTRUCTION("F20F38F88C1A80000000" , enqcmd(zmmword_ptr(rcx), zmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("F30F38F88C1A80000000" , enqcmds(zmmword_ptr(rcx), zmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C8010002" , enter(1, 2)); + TEST_INSTRUCTION("0FAE8C1180000000" , fxrstor(ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("480FAE8C1180000000" , fxrstor64(ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("0FAE841180000000" , fxsave(ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("480FAE841180000000" , fxsave64(ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("D9F4" , fxtract()); + TEST_INSTRUCTION("0F37" , getsec()); + TEST_INSTRUCTION("F4" , hlt()); + TEST_INSTRUCTION("F30F3AF0C001" , hreset(1, eax)); + TEST_INSTRUCTION("F6F9" , idiv(ax, cl)); + TEST_INSTRUCTION("F6FD" , idiv(ax, ch)); + TEST_INSTRUCTION("F6BC1180000000" , idiv(ax, ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("F6BC1180000000" , idiv(ax, byte_ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("66F7F9" , idiv(dx, ax, cx)); + TEST_INSTRUCTION("66F7BC1180000000" , idiv(dx, ax, ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("66F7BC1180000000" , idiv(dx, ax, word_ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("F7F9" , idiv(edx, eax, ecx)); + TEST_INSTRUCTION("F7BC1180000000" , idiv(edx, eax, ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("F7BC1180000000" , idiv(edx, eax, dword_ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("48F7F9" , idiv(rdx, rax, rcx)); + TEST_INSTRUCTION("48F7BC1180000000" , idiv(rdx, rax, ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("48F7BC1180000000" , idiv(rdx, rax, qword_ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("F6E9" , imul(ax, cl)); + TEST_INSTRUCTION("F6ED" , imul(ax, ch)); + TEST_INSTRUCTION("660FAF841180000000" , imul(ax, ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("F6AC1180000000" , imul(ax, byte_ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("66F7E9" , imul(dx, ax, cx)); + TEST_INSTRUCTION("66F7AC1180000000" , imul(dx, ax, ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("66F7AC1180000000" , imul(dx, ax, word_ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("F7E9" , imul(edx, eax, ecx)); + TEST_INSTRUCTION("F7AC1180000000" , imul(edx, eax, ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("F7AC1180000000" , imul(edx, eax, dword_ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("48F7E9" , imul(rdx, rax, rcx)); + TEST_INSTRUCTION("48F7AC1180000000" , imul(rdx, rax, ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("48F7AC1180000000" , imul(rdx, rax, qword_ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("660FAFCA" , imul(cx, dx)); + TEST_INSTRUCTION("666BC901" , imul(cx, 1)); + TEST_INSTRUCTION("660FAF8C1A80000000" , imul(cx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660FAF8C1A80000000" , imul(cx, word_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0FAFCA" , imul(ecx, edx)); + TEST_INSTRUCTION("6BC901" , imul(ecx, 1)); + TEST_INSTRUCTION("0FAF8C1A80000000" , imul(ecx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0FAF8C1A80000000" , imul(ecx, dword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("480FAFCA" , imul(rcx, rdx)); + TEST_INSTRUCTION("486BC901" , imul(rcx, 1)); + TEST_INSTRUCTION("480FAF8C1A80000000" , imul(rcx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("480FAF8C1A80000000" , imul(rcx, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("666BCA01" , imul(cx, dx, 1)); + TEST_INSTRUCTION("666B8C1A8000000001" , imul(cx, ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("666B8C1A8000000001" , imul(cx, word_ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("6BCA01" , imul(ecx, edx, 1)); + TEST_INSTRUCTION("6B8C1A8000000001" , imul(ecx, ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("6B8C1A8000000001" , imul(ecx, dword_ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("486BCA01" , imul(rcx, rdx, 1)); + TEST_INSTRUCTION("486B8C1A8000000001" , imul(rcx, ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("486B8C1A8000000001" , imul(rcx, qword_ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("EC" , in(al, dx)); + TEST_INSTRUCTION("E401" , in(al, 1)); + TEST_INSTRUCTION("66ED" , in(ax, dx)); + TEST_INSTRUCTION("66E501" , in(ax, 1)); + TEST_INSTRUCTION("ED" , in(eax, dx)); + TEST_INSTRUCTION("E501" , in(eax, 1)); + TEST_INSTRUCTION("FEC1" , inc(cl)); + TEST_INSTRUCTION("FEC5" , inc(ch)); + TEST_INSTRUCTION("66FFC1" , inc(cx)); + TEST_INSTRUCTION("FFC1" , inc(ecx)); + TEST_INSTRUCTION("48FFC1" , inc(rcx)); + TEST_INSTRUCTION("FE841180000000" , inc(byte_ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("66FF841180000000" , inc(word_ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("FF841180000000" , inc(dword_ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("48FF841180000000" , inc(qword_ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("F30FAEE9" , incsspd(ecx)); + TEST_INSTRUCTION("F3480FAEE9" , incsspq(rcx)); + TEST_INSTRUCTION("6C" , ins(byte_ptr(rdi), dx)); + TEST_INSTRUCTION("666D" , ins(word_ptr(rdi), dx)); + TEST_INSTRUCTION("6D" , ins(dword_ptr(rdi), dx)); + TEST_INSTRUCTION("CD01" , int_(1)); + TEST_INSTRUCTION("CC" , int3()); + TEST_INSTRUCTION("0F08" , invd()); + TEST_INSTRUCTION("660F38808C1A80000000" , invept(rcx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F38808C1A80000000" , invept(rcx, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F01BC1180000000" , invlpg(ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("670F01DF" , invlpga(eax, ecx)); + TEST_INSTRUCTION("0F01DF" , invlpga(rax, ecx)); + TEST_INSTRUCTION("660F38828C1A80000000" , invpcid(rcx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F38828C1A80000000" , invpcid(rcx, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F38818C1A80000000" , invvpid(rcx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F38818C1A80000000" , invvpid(rcx, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("66CF" , iret()); + TEST_INSTRUCTION("CF" , iretd()); + TEST_INSTRUCTION("48CF" , iretq()); + TEST_INSTRUCTION("C5ED4ACB" , kaddb(k1, k2, k3)); + TEST_INSTRUCTION("C4E1ED4ACB" , kaddd(k1, k2, k3)); + TEST_INSTRUCTION("C4E1EC4ACB" , kaddq(k1, k2, k3)); + TEST_INSTRUCTION("C5EC4ACB" , kaddw(k1, k2, k3)); + TEST_INSTRUCTION("C5ED41CB" , kandb(k1, k2, k3)); + TEST_INSTRUCTION("C4E1ED41CB" , kandd(k1, k2, k3)); + TEST_INSTRUCTION("C5ED42CB" , kandnb(k1, k2, k3)); + TEST_INSTRUCTION("C4E1ED42CB" , kandnd(k1, k2, k3)); + TEST_INSTRUCTION("C4E1EC42CB" , kandnq(k1, k2, k3)); + TEST_INSTRUCTION("C5EC42CB" , kandnw(k1, k2, k3)); + TEST_INSTRUCTION("C4E1EC41CB" , kandq(k1, k2, k3)); + TEST_INSTRUCTION("C5EC41CB" , kandw(k1, k2, k3)); + TEST_INSTRUCTION("C5F992CA" , kmovb(k1, edx)); + TEST_INSTRUCTION("C5F990CA" , kmovb(k1, k2)); + TEST_INSTRUCTION("C5F9908C1A80000000" , kmovb(k1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C5F9908C1A80000000" , kmovb(k1, byte_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C5F993CA" , kmovb(ecx, k2)); + TEST_INSTRUCTION("C5F9919C1180000000" , kmovb(ptr(rcx, rdx, 0, 128), k3)); + TEST_INSTRUCTION("C5F9919C1180000000" , kmovb(byte_ptr(rcx, rdx, 0, 128), k3)); + TEST_INSTRUCTION("C5FB92CA" , kmovd(k1, edx)); + TEST_INSTRUCTION("C4E1F990CA" , kmovd(k1, k2)); + TEST_INSTRUCTION("C4E1F9908C1A80000000" , kmovd(k1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C4E1F9908C1A80000000" , kmovd(k1, dword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C5FB93CA" , kmovd(ecx, k2)); + TEST_INSTRUCTION("C4E1F9919C1180000000" , kmovd(ptr(rcx, rdx, 0, 128), k3)); + TEST_INSTRUCTION("C4E1F9919C1180000000" , kmovd(dword_ptr(rcx, rdx, 0, 128), k3)); + TEST_INSTRUCTION("C4E1FB92CA" , kmovq(k1, rdx)); + TEST_INSTRUCTION("C4E1F890CA" , kmovq(k1, k2)); + TEST_INSTRUCTION("C4E1F8908C1A80000000" , kmovq(k1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C4E1F8908C1A80000000" , kmovq(k1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C4E1FB93CA" , kmovq(rcx, k2)); + TEST_INSTRUCTION("C4E1F8919C1180000000" , kmovq(ptr(rcx, rdx, 0, 128), k3)); + TEST_INSTRUCTION("C4E1F8919C1180000000" , kmovq(qword_ptr(rcx, rdx, 0, 128), k3)); + TEST_INSTRUCTION("C5F892CA" , kmovw(k1, edx)); + TEST_INSTRUCTION("C5F890CA" , kmovw(k1, k2)); + TEST_INSTRUCTION("C5F8908C1A80000000" , kmovw(k1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C5F8908C1A80000000" , kmovw(k1, word_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C5F893CA" , kmovw(ecx, k2)); + TEST_INSTRUCTION("C5F8919C1180000000" , kmovw(ptr(rcx, rdx, 0, 128), k3)); + TEST_INSTRUCTION("C5F8919C1180000000" , kmovw(word_ptr(rcx, rdx, 0, 128), k3)); + TEST_INSTRUCTION("C5F944CA" , knotb(k1, k2)); + TEST_INSTRUCTION("C4E1F944CA" , knotd(k1, k2)); + TEST_INSTRUCTION("C4E1F844CA" , knotq(k1, k2)); + TEST_INSTRUCTION("C5F844CA" , knotw(k1, k2)); + TEST_INSTRUCTION("C5ED45CB" , korb(k1, k2, k3)); + TEST_INSTRUCTION("C4E1ED45CB" , kord(k1, k2, k3)); + TEST_INSTRUCTION("C4E1EC45CB" , korq(k1, k2, k3)); + TEST_INSTRUCTION("C5F998CA" , kortestb(k1, k2)); + TEST_INSTRUCTION("C4E1F998CA" , kortestd(k1, k2)); + TEST_INSTRUCTION("C4E1F898CA" , kortestq(k1, k2)); + TEST_INSTRUCTION("C5F898CA" , kortestw(k1, k2)); + TEST_INSTRUCTION("C5EC45CB" , korw(k1, k2, k3)); + TEST_INSTRUCTION("C4E37932CA01" , kshiftlb(k1, k2, 1)); + TEST_INSTRUCTION("C4E37933CA01" , kshiftld(k1, k2, 1)); + TEST_INSTRUCTION("C4E3F933CA01" , kshiftlq(k1, k2, 1)); + TEST_INSTRUCTION("C4E3F932CA01" , kshiftlw(k1, k2, 1)); + TEST_INSTRUCTION("C4E37930CA01" , kshiftrb(k1, k2, 1)); + TEST_INSTRUCTION("C4E37931CA01" , kshiftrd(k1, k2, 1)); + TEST_INSTRUCTION("C4E3F931CA01" , kshiftrq(k1, k2, 1)); + TEST_INSTRUCTION("C4E3F930CA01" , kshiftrw(k1, k2, 1)); + TEST_INSTRUCTION("C5F999CA" , ktestb(k1, k2)); + TEST_INSTRUCTION("C4E1F999CA" , ktestd(k1, k2)); + TEST_INSTRUCTION("C4E1F899CA" , ktestq(k1, k2)); + TEST_INSTRUCTION("C5F899CA" , ktestw(k1, k2)); + TEST_INSTRUCTION("C5ED4BCB" , kunpckbw(k1, k2, k3)); + TEST_INSTRUCTION("C4E1EC4BCB" , kunpckdq(k1, k2, k3)); + TEST_INSTRUCTION("C5EC4BCB" , kunpckwd(k1, k2, k3)); + TEST_INSTRUCTION("C5ED46CB" , kxnorb(k1, k2, k3)); + TEST_INSTRUCTION("C4E1ED46CB" , kxnord(k1, k2, k3)); + TEST_INSTRUCTION("C4E1EC46CB" , kxnorq(k1, k2, k3)); + TEST_INSTRUCTION("C5EC46CB" , kxnorw(k1, k2, k3)); + TEST_INSTRUCTION("C5ED47CB" , kxorb(k1, k2, k3)); + TEST_INSTRUCTION("C4E1ED47CB" , kxord(k1, k2, k3)); + TEST_INSTRUCTION("C4E1EC47CB" , kxorq(k1, k2, k3)); + TEST_INSTRUCTION("C5EC47CB" , kxorw(k1, k2, k3)); + TEST_INSTRUCTION("9F" , lahf(ah)); + TEST_INSTRUCTION("660F02CA" , lar(cx, dx)); + TEST_INSTRUCTION("660F028C1A80000000" , lar(cx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F028C1A80000000" , lar(cx, word_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F02CA" , lar(ecx, edx)); + TEST_INSTRUCTION("0F028C1A80000000" , lar(ecx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F028C1A80000000" , lar(ecx, word_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("48FF9C1180000000" , lcall(ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("66FF9C1180000000" , lcall(dword_ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("FF9C1180000000" , lcall(fword_ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("48FF9C1180000000" , lcall(tbyte_ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("0FAE941180000000" , ldmxcsr(ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("0FAE941180000000" , ldmxcsr(dword_ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("668D8C1A80000000" , lea(cx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("8D8C1A80000000" , lea(ecx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("488D8C1A80000000" , lea(rcx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C9" , leave()); + TEST_INSTRUCTION("0FAEE8" , lfence()); + TEST_INSTRUCTION("660FB48C1A80000000" , lfs(cx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660FB48C1A80000000" , lfs(cx, dword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0FB48C1A80000000" , lfs(ecx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0FB48C1A80000000" , lfs(ecx, fword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("480FB48C1A80000000" , lfs(rcx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("480FB48C1A80000000" , lfs(rcx, tbyte_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F01941180000000" , lgdt(ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("660FB58C1A80000000" , lgs(cx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660FB58C1A80000000" , lgs(cx, dword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0FB58C1A80000000" , lgs(ecx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0FB58C1A80000000" , lgs(ecx, fword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("480FB58C1A80000000" , lgs(rcx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("480FB58C1A80000000" , lgs(rcx, tbyte_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F019C1180000000" , lidt(ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("48FFAC1180000000" , ljmp(ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("66FFAC1180000000" , ljmp(dword_ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("FFAC1180000000" , ljmp(fword_ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("48FFAC1180000000" , ljmp(tbyte_ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("0F00D1" , lldt(cx)); + TEST_INSTRUCTION("0F00941180000000" , lldt(ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("0F00941180000000" , lldt(word_ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("8FE97812C1" , llwpcb(ecx)); + TEST_INSTRUCTION("8FE9F812C1" , llwpcb(rcx)); + TEST_INSTRUCTION("0F01F1" , lmsw(cx)); + TEST_INSTRUCTION("0F01B41180000000" , lmsw(ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("0F01B41180000000" , lmsw(word_ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("AC" , lods(al, ptr(rsi))); + TEST_INSTRUCTION("AC" , lods(al, byte_ptr(rsi))); + TEST_INSTRUCTION("66AD" , lods(ax, ptr(rsi))); + TEST_INSTRUCTION("66AD" , lods(ax, word_ptr(rsi))); + TEST_INSTRUCTION("AD" , lods(eax, ptr(rsi))); + TEST_INSTRUCTION("AD" , lods(eax, dword_ptr(rsi))); + TEST_INSTRUCTION("48AD" , lods(rax, ptr(rsi))); + TEST_INSTRUCTION("48AD" , lods(rax, qword_ptr(rsi))); + TEST_INSTRUCTION("660F03CA" , lsl(cx, dx)); + TEST_INSTRUCTION("660F038C1A80000000" , lsl(cx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F038C1A80000000" , lsl(cx, word_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F03CA" , lsl(ecx, edx)); + TEST_INSTRUCTION("0F038C1A80000000" , lsl(ecx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F038C1A80000000" , lsl(ecx, word_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("480F03CA" , lsl(rcx, edx)); + TEST_INSTRUCTION("480F038C1A80000000" , lsl(rcx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("480F038C1A80000000" , lsl(rcx, word_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660FB28C1A80000000" , lss(cx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660FB28C1A80000000" , lss(cx, dword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0FB28C1A80000000" , lss(ecx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0FB28C1A80000000" , lss(ecx, fword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("480FB28C1A80000000" , lss(rcx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("480FB28C1A80000000" , lss(rcx, tbyte_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F00D9" , ltr(cx)); + TEST_INSTRUCTION("0F009C1180000000" , ltr(ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("0F009C1180000000" , ltr(word_ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("8FEA7012C201000000" , lwpins(ecx, edx, 1)); + TEST_INSTRUCTION("8FEA7012841A8000000001000000" , lwpins(ecx, ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("8FEA7012841A8000000001000000" , lwpins(ecx, dword_ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("8FEAF012C201000000" , lwpins(rcx, edx, 1)); + TEST_INSTRUCTION("8FEAF012841A8000000001000000" , lwpins(rcx, ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("8FEAF012841A8000000001000000" , lwpins(rcx, dword_ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("8FEA7012CA01000000" , lwpval(ecx, edx, 1)); + TEST_INSTRUCTION("8FEA70128C1A8000000001000000" , lwpval(ecx, ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("8FEA70128C1A8000000001000000" , lwpval(ecx, dword_ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("8FEAF012CA01000000" , lwpval(rcx, edx, 1)); + TEST_INSTRUCTION("8FEAF0128C1A8000000001000000" , lwpval(rcx, ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("8FEAF0128C1A8000000001000000" , lwpval(rcx, dword_ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("66F30FBDCA" , lzcnt(cx, dx)); + TEST_INSTRUCTION("66F30FBD8C1A80000000" , lzcnt(cx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("66F30FBD8C1A80000000" , lzcnt(cx, word_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("F30FBDCA" , lzcnt(ecx, edx)); + TEST_INSTRUCTION("F30FBD8C1A80000000" , lzcnt(ecx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("F30FBD8C1A80000000" , lzcnt(ecx, dword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("F3480FBDCA" , lzcnt(rcx, rdx)); + TEST_INSTRUCTION("F3480FBD8C1A80000000" , lzcnt(rcx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("F3480FBD8C1A80000000" , lzcnt(rcx, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("F30F01FA" , mcommit()); + TEST_INSTRUCTION("0FAEF0" , mfence()); + TEST_INSTRUCTION("0F01C8" , monitor(ptr(rax), ecx, edx)); + TEST_INSTRUCTION("0F01FA" , monitorx(ptr(rax), ecx, edx)); + TEST_INSTRUCTION("88D1" , mov(cl, dl)); + TEST_INSTRUCTION("88F1" , mov(cl, dh)); + TEST_INSTRUCTION("88D5" , mov(ch, dl)); + TEST_INSTRUCTION("88F5" , mov(ch, dh)); + TEST_INSTRUCTION("889C1180000000" , mov(ptr(rcx, rdx, 0, 128), bl)); + TEST_INSTRUCTION("88BC1180000000" , mov(ptr(rcx, rdx, 0, 128), bh)); + TEST_INSTRUCTION("889C1180000000" , mov(byte_ptr(rcx, rdx, 0, 128), bl)); + TEST_INSTRUCTION("88BC1180000000" , mov(byte_ptr(rcx, rdx, 0, 128), bh)); + TEST_INSTRUCTION("6689D1" , mov(cx, dx)); + TEST_INSTRUCTION("668EE2" , mov(fs, dx)); + TEST_INSTRUCTION("66899C1180000000" , mov(ptr(rcx, rdx, 0, 128), bx)); + TEST_INSTRUCTION("66899C1180000000" , mov(word_ptr(rcx, rdx, 0, 128), bx)); + TEST_INSTRUCTION("89D1" , mov(ecx, edx)); + TEST_INSTRUCTION("8EE2" , mov(fs, edx)); + TEST_INSTRUCTION("899C1180000000" , mov(ptr(rcx, rdx, 0, 128), ebx)); + TEST_INSTRUCTION("899C1180000000" , mov(dword_ptr(rcx, rdx, 0, 128), ebx)); + TEST_INSTRUCTION("4889D1" , mov(rcx, rdx)); + TEST_INSTRUCTION("488EE2" , mov(fs, rdx)); + TEST_INSTRUCTION("0F22CA" , mov(cr1, rdx)); + TEST_INSTRUCTION("0F23CA" , mov(dr1, rdx)); + TEST_INSTRUCTION("48899C1180000000" , mov(ptr(rcx, rdx, 0, 128), rbx)); + TEST_INSTRUCTION("48899C1180000000" , mov(qword_ptr(rcx, rdx, 0, 128), rbx)); + TEST_INSTRUCTION("B101" , mov(cl, 1)); + TEST_INSTRUCTION("B501" , mov(ch, 1)); + TEST_INSTRUCTION("C684118000000001" , mov(byte_ptr(rcx, rdx, 0, 128), 1)); + TEST_INSTRUCTION("66B90100" , mov(cx, 1)); + TEST_INSTRUCTION("66C78411800000000100" , mov(word_ptr(rcx, rdx, 0, 128), 1)); + TEST_INSTRUCTION("B901000000" , mov(ecx, 1)); + TEST_INSTRUCTION("C784118000000001000000" , mov(dword_ptr(rcx, rdx, 0, 128), 1)); + TEST_INSTRUCTION("48C7C101000000" , mov(rcx, 1)); + TEST_INSTRUCTION("48C784118000000001000000" , mov(qword_ptr(rcx, rdx, 0, 128), 1)); + TEST_INSTRUCTION("488CE1" , mov(rcx, fs)); + TEST_INSTRUCTION("0F20D1" , mov(rcx, cr2)); + TEST_INSTRUCTION("0F21D1" , mov(rcx, dr2)); + TEST_INSTRUCTION("488B8C1A80000000" , mov(rcx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("488B8C1A80000000" , mov(rcx, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("8A8C1A80000000" , mov(cl, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("8A8C1A80000000" , mov(cl, byte_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("8AAC1A80000000" , mov(ch, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("8AAC1A80000000" , mov(ch, byte_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("668CE1" , mov(cx, fs)); + TEST_INSTRUCTION("668B8C1A80000000" , mov(cx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("668B8C1A80000000" , mov(cx, word_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("8CE1" , mov(ecx, fs)); + TEST_INSTRUCTION("8B8C1A80000000" , mov(ecx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("8B8C1A80000000" , mov(ecx, dword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("8CA41180000000" , mov(ptr(rcx, rdx, 0, 128), fs)); + TEST_INSTRUCTION("668CA41180000000" , mov(word_ptr(rcx, rdx, 0, 128), fs)); + TEST_INSTRUCTION("8EA41A80000000" , mov(fs, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("668EA41A80000000" , mov(fs, word_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("48B90100000000000000" , movabs(rcx, 1)); + TEST_INSTRUCTION("660F38F08C1A80000000" , movbe(cx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F38F08C1A80000000" , movbe(cx, word_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F38F08C1A80000000" , movbe(ecx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F38F08C1A80000000" , movbe(ecx, dword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("480F38F08C1A80000000" , movbe(rcx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("480F38F08C1A80000000" , movbe(rcx, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F38F19C1180000000" , movbe(ptr(rcx, rdx, 0, 128), bx)); + TEST_INSTRUCTION("660F38F19C1180000000" , movbe(word_ptr(rcx, rdx, 0, 128), bx)); + TEST_INSTRUCTION("0F38F19C1180000000" , movbe(ptr(rcx, rdx, 0, 128), ebx)); + TEST_INSTRUCTION("0F38F19C1180000000" , movbe(dword_ptr(rcx, rdx, 0, 128), ebx)); + TEST_INSTRUCTION("480F38F19C1180000000" , movbe(ptr(rcx, rdx, 0, 128), rbx)); + TEST_INSTRUCTION("480F38F19C1180000000" , movbe(qword_ptr(rcx, rdx, 0, 128), rbx)); + TEST_INSTRUCTION("660F38F88C1A80000000" , movdir64b(zmmword_ptr(rcx), zmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F38F99C1180000000" , movdiri(ptr(rcx, rdx, 0, 128), ebx)); + TEST_INSTRUCTION("0F38F99C1180000000" , movdiri(dword_ptr(rcx, rdx, 0, 128), ebx)); + TEST_INSTRUCTION("480F38F99C1180000000" , movdiri(ptr(rcx, rdx, 0, 128), rbx)); + TEST_INSTRUCTION("480F38F99C1180000000" , movdiri(qword_ptr(rcx, rdx, 0, 128), rbx)); + TEST_INSTRUCTION("0FC39C1180000000" , movnti(ptr(rcx, rdx, 0, 128), ebx)); + TEST_INSTRUCTION("0FC39C1180000000" , movnti(dword_ptr(rcx, rdx, 0, 128), ebx)); + TEST_INSTRUCTION("480FC39C1180000000" , movnti(ptr(rcx, rdx, 0, 128), rbx)); + TEST_INSTRUCTION("480FC39C1180000000" , movnti(qword_ptr(rcx, rdx, 0, 128), rbx)); + TEST_INSTRUCTION("A4" , movs(byte_ptr(rdi), byte_ptr(rsi))); + TEST_INSTRUCTION("66A5" , movs(word_ptr(rdi), word_ptr(rsi))); + TEST_INSTRUCTION("A5" , movs(dword_ptr(rdi), dword_ptr(rsi))); + TEST_INSTRUCTION("48A5" , movs(qword_ptr(rdi), qword_ptr(rsi))); + TEST_INSTRUCTION("660FBECA" , movsx(cx, dl)); + TEST_INSTRUCTION("660FBECE" , movsx(cx, dh)); + TEST_INSTRUCTION("660FBE8C1A80000000" , movsx(cx, byte_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0FBECA" , movsx(ecx, dl)); + TEST_INSTRUCTION("0FBECE" , movsx(ecx, dh)); + TEST_INSTRUCTION("0FBFCA" , movsx(ecx, dx)); + TEST_INSTRUCTION("0FBE8C1A80000000" , movsx(ecx, byte_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0FBF8C1A80000000" , movsx(ecx, word_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("480FBECA" , movsx(rcx, dl)); + TEST_INSTRUCTION("480FBFCA" , movsx(rcx, dx)); + TEST_INSTRUCTION("480FBE8C1A80000000" , movsx(rcx, byte_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("480FBF8C1A80000000" , movsx(rcx, word_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("6663CA" , movsxd(cx, dx)); + TEST_INSTRUCTION("66638C1A80000000" , movsxd(cx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("66638C1A80000000" , movsxd(cx, word_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("63CA" , movsxd(ecx, edx)); + TEST_INSTRUCTION("638C1A80000000" , movsxd(ecx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("638C1A80000000" , movsxd(ecx, dword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("4863CA" , movsxd(rcx, edx)); + TEST_INSTRUCTION("48638C1A80000000" , movsxd(rcx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("48638C1A80000000" , movsxd(rcx, dword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660FB6CA" , movzx(cx, dl)); + TEST_INSTRUCTION("660FB6CE" , movzx(cx, dh)); + TEST_INSTRUCTION("660FB68C1A80000000" , movzx(cx, byte_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0FB6CA" , movzx(ecx, dl)); + TEST_INSTRUCTION("0FB6CE" , movzx(ecx, dh)); + TEST_INSTRUCTION("0FB7CA" , movzx(ecx, dx)); + TEST_INSTRUCTION("0FB68C1A80000000" , movzx(ecx, byte_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0FB78C1A80000000" , movzx(ecx, word_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("480FB6CA" , movzx(rcx, dl)); + TEST_INSTRUCTION("480FB7CA" , movzx(rcx, dx)); + TEST_INSTRUCTION("480FB68C1A80000000" , movzx(rcx, byte_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("480FB78C1A80000000" , movzx(rcx, word_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("F6E1" , mul(ax, cl)); + TEST_INSTRUCTION("F6E5" , mul(ax, ch)); + TEST_INSTRUCTION("F6A41180000000" , mul(ax, ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("F6A41180000000" , mul(ax, byte_ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("66F7E1" , mul(dx, ax, cx)); + TEST_INSTRUCTION("66F7A41180000000" , mul(dx, ax, ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("66F7A41180000000" , mul(dx, ax, word_ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("F7E1" , mul(edx, eax, ecx)); + TEST_INSTRUCTION("F7A41180000000" , mul(edx, eax, ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("F7A41180000000" , mul(edx, eax, dword_ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("48F7E1" , mul(rdx, rax, rcx)); + TEST_INSTRUCTION("48F7A41180000000" , mul(rdx, rax, ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("48F7A41180000000" , mul(rdx, rax, qword_ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("C4E26BF6CB" , mulx(ecx, edx, ebx, edx)); + TEST_INSTRUCTION("C4E26BF68C2B80000000" , mulx(ecx, edx, ptr(rbx, rbp, 0, 128), edx)); + TEST_INSTRUCTION("C4E26BF68C2B80000000" , mulx(ecx, edx, dword_ptr(rbx, rbp, 0, 128), edx)); + TEST_INSTRUCTION("C4E2EBF6CB" , mulx(rcx, rdx, rbx, rdx)); + TEST_INSTRUCTION("C4E2EBF68C2B80000000" , mulx(rcx, rdx, ptr(rbx, rbp, 0, 128), rdx)); + TEST_INSTRUCTION("C4E2EBF68C2B80000000" , mulx(rcx, rdx, qword_ptr(rbx, rbp, 0, 128), rdx)); + TEST_INSTRUCTION("0F01C9" , mwait(eax, ecx)); + TEST_INSTRUCTION("0F01FB" , mwaitx(eax, ecx, ebx)); + TEST_INSTRUCTION("F6D9" , neg(cl)); + TEST_INSTRUCTION("F6DD" , neg(ch)); + TEST_INSTRUCTION("66F7D9" , neg(cx)); + TEST_INSTRUCTION("F7D9" , neg(ecx)); + TEST_INSTRUCTION("48F7D9" , neg(rcx)); + TEST_INSTRUCTION("F69C1180000000" , neg(byte_ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("66F79C1180000000" , neg(word_ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("F79C1180000000" , neg(dword_ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("48F79C1180000000" , neg(qword_ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("90" , nop()); + TEST_INSTRUCTION("660F1FC1" , nop(cx)); + TEST_INSTRUCTION("0F1FC1" , nop(ecx)); + TEST_INSTRUCTION("480F1FC1" , nop(rcx)); + TEST_INSTRUCTION("660F1F841180000000" , nop(word_ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("0F1F841180000000" , nop(dword_ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("480F1F841180000000" , nop(qword_ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("660F1FD1" , nop(cx, dx)); + TEST_INSTRUCTION("660F1F9C1180000000" , nop(ptr(rcx, rdx, 0, 128), bx)); + TEST_INSTRUCTION("660F1F9C1180000000" , nop(word_ptr(rcx, rdx, 0, 128), bx)); + TEST_INSTRUCTION("0F1FD1" , nop(ecx, edx)); + TEST_INSTRUCTION("0F1F9C1180000000" , nop(ptr(rcx, rdx, 0, 128), ebx)); + TEST_INSTRUCTION("0F1F9C1180000000" , nop(dword_ptr(rcx, rdx, 0, 128), ebx)); + TEST_INSTRUCTION("480F1FD1" , nop(rcx, rdx)); + TEST_INSTRUCTION("480F1F9C1180000000" , nop(ptr(rcx, rdx, 0, 128), rbx)); + TEST_INSTRUCTION("480F1F9C1180000000" , nop(qword_ptr(rcx, rdx, 0, 128), rbx)); + TEST_INSTRUCTION("F6D1" , not_(cl)); + TEST_INSTRUCTION("F6D5" , not_(ch)); + TEST_INSTRUCTION("66F7D1" , not_(cx)); + TEST_INSTRUCTION("F7D1" , not_(ecx)); + TEST_INSTRUCTION("48F7D1" , not_(rcx)); + TEST_INSTRUCTION("F6941180000000" , not_(byte_ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("66F7941180000000" , not_(word_ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("F7941180000000" , not_(dword_ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("48F7941180000000" , not_(qword_ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("80C901" , or_(cl, 1)); + TEST_INSTRUCTION("80CD01" , or_(ch, 1)); + TEST_INSTRUCTION("808C118000000001" , or_(byte_ptr(rcx, rdx, 0, 128), 1)); + TEST_INSTRUCTION("6683C901" , or_(cx, 1)); + TEST_INSTRUCTION("66838C118000000001" , or_(word_ptr(rcx, rdx, 0, 128), 1)); + TEST_INSTRUCTION("83C901" , or_(ecx, 1)); + TEST_INSTRUCTION("838C118000000001" , or_(dword_ptr(rcx, rdx, 0, 128), 1)); + TEST_INSTRUCTION("4809D1" , or_(rcx, rdx)); + TEST_INSTRUCTION("4883C901" , or_(rcx, 1)); + TEST_INSTRUCTION("48099C1180000000" , or_(ptr(rcx, rdx, 0, 128), rbx)); + TEST_INSTRUCTION("48099C1180000000" , or_(qword_ptr(rcx, rdx, 0, 128), rbx)); + TEST_INSTRUCTION("48838C118000000001" , or_(qword_ptr(rcx, rdx, 0, 128), 1)); + TEST_INSTRUCTION("08D1" , or_(cl, dl)); + TEST_INSTRUCTION("08F1" , or_(cl, dh)); + TEST_INSTRUCTION("08D5" , or_(ch, dl)); + TEST_INSTRUCTION("08F5" , or_(ch, dh)); + TEST_INSTRUCTION("089C1180000000" , or_(ptr(rcx, rdx, 0, 128), bl)); + TEST_INSTRUCTION("08BC1180000000" , or_(ptr(rcx, rdx, 0, 128), bh)); + TEST_INSTRUCTION("089C1180000000" , or_(byte_ptr(rcx, rdx, 0, 128), bl)); + TEST_INSTRUCTION("08BC1180000000" , or_(byte_ptr(rcx, rdx, 0, 128), bh)); + TEST_INSTRUCTION("6609D1" , or_(cx, dx)); + TEST_INSTRUCTION("66099C1180000000" , or_(ptr(rcx, rdx, 0, 128), bx)); + TEST_INSTRUCTION("66099C1180000000" , or_(word_ptr(rcx, rdx, 0, 128), bx)); + TEST_INSTRUCTION("09D1" , or_(ecx, edx)); + TEST_INSTRUCTION("099C1180000000" , or_(ptr(rcx, rdx, 0, 128), ebx)); + TEST_INSTRUCTION("099C1180000000" , or_(dword_ptr(rcx, rdx, 0, 128), ebx)); + TEST_INSTRUCTION("0A8C1A80000000" , or_(cl, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0A8C1A80000000" , or_(cl, byte_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0AAC1A80000000" , or_(ch, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0AAC1A80000000" , or_(ch, byte_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660B8C1A80000000" , or_(cx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660B8C1A80000000" , or_(cx, word_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0B8C1A80000000" , or_(ecx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0B8C1A80000000" , or_(ecx, dword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("480B8C1A80000000" , or_(rcx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("480B8C1A80000000" , or_(rcx, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("EE" , out(dx, al)); + TEST_INSTRUCTION("66EF" , out(dx, ax)); + TEST_INSTRUCTION("EF" , out(dx, eax)); + TEST_INSTRUCTION("E601" , out(1, al)); + TEST_INSTRUCTION("66E701" , out(1, ax)); + TEST_INSTRUCTION("E701" , out(1, eax)); + TEST_INSTRUCTION("6E" , outs(dx, byte_ptr(rsi))); + TEST_INSTRUCTION("666F" , outs(dx, word_ptr(rsi))); + TEST_INSTRUCTION("6F" , outs(dx, dword_ptr(rsi))); + TEST_INSTRUCTION("F390" , pause()); + TEST_INSTRUCTION("0F01C5" , pconfig()); + TEST_INSTRUCTION("C4E26BF5CB" , pdep(ecx, edx, ebx)); + TEST_INSTRUCTION("C4E26BF58C2B80000000" , pdep(ecx, edx, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E26BF58C2B80000000" , pdep(ecx, edx, dword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E2EBF5CB" , pdep(rcx, rdx, rbx)); + TEST_INSTRUCTION("C4E2EBF58C2B80000000" , pdep(rcx, rdx, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E2EBF58C2B80000000" , pdep(rcx, rdx, qword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E26AF5CB" , pext(ecx, edx, ebx)); + TEST_INSTRUCTION("C4E26AF58C2B80000000" , pext(ecx, edx, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E26AF58C2B80000000" , pext(ecx, edx, dword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E2EAF5CB" , pext(rcx, rdx, rbx)); + TEST_INSTRUCTION("C4E2EAF58C2B80000000" , pext(rcx, rdx, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E2EAF58C2B80000000" , pext(rcx, rdx, qword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("6659" , pop(cx)); + TEST_INSTRUCTION("59" , pop(rcx)); + TEST_INSTRUCTION("668F841180000000" , pop(word_ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("8F841180000000" , pop(qword_ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("0FA1" , pop(fs)); + TEST_INSTRUCTION("66F30FB8CA" , popcnt(cx, dx)); + TEST_INSTRUCTION("66F30FB88C1A80000000" , popcnt(cx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("66F30FB88C1A80000000" , popcnt(cx, word_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("F30FB8CA" , popcnt(ecx, edx)); + TEST_INSTRUCTION("F30FB88C1A80000000" , popcnt(ecx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("F30FB88C1A80000000" , popcnt(ecx, dword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("F3480FB8CA" , popcnt(rcx, rdx)); + TEST_INSTRUCTION("F3480FB88C1A80000000" , popcnt(rcx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("F3480FB88C1A80000000" , popcnt(rcx, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("669D" , popf()); + TEST_INSTRUCTION("9D" , popfq()); + TEST_INSTRUCTION("0F0D841180000000" , prefetch(ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("0F18841180000000" , prefetchnta(ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("0F188C1180000000" , prefetcht0(ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("0F18941180000000" , prefetcht1(ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("0F189C1180000000" , prefetcht2(ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("0F0D8C1180000000" , prefetchw(ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("0F0D941180000000" , prefetchwt1(ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("F30F01FF" , psmash()); + TEST_INSTRUCTION("F30FAEE1" , ptwrite(ecx)); + TEST_INSTRUCTION("F3480FAEE1" , ptwrite(rcx)); + TEST_INSTRUCTION("F30FAEA41180000000" , ptwrite(ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("F30FAEA41180000000" , ptwrite(dword_ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("F3480FAEA41180000000" , ptwrite(qword_ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("6651" , push(cx)); + TEST_INSTRUCTION("51" , push(rcx)); + TEST_INSTRUCTION("6A01" , push(1)); + TEST_INSTRUCTION("66FFB41180000000" , push(word_ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("FFB41180000000" , push(qword_ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("0FA0" , push(fs)); + TEST_INSTRUCTION("669C" , pushf()); + TEST_INSTRUCTION("9C" , pushfq()); + TEST_INSTRUCTION("F20F01FF" , pvalidate()); + TEST_INSTRUCTION("D2D1" , rcl(cl, cl)); + TEST_INSTRUCTION("D0D1" , rcl(cl, 1)); + TEST_INSTRUCTION("D2D5" , rcl(ch, cl)); + TEST_INSTRUCTION("D0D5" , rcl(ch, 1)); + TEST_INSTRUCTION("66D3D1" , rcl(cx, cl)); + TEST_INSTRUCTION("66D1D1" , rcl(cx, 1)); + TEST_INSTRUCTION("D3D1" , rcl(ecx, cl)); + TEST_INSTRUCTION("D1D1" , rcl(ecx, 1)); + TEST_INSTRUCTION("48D3D1" , rcl(rcx, cl)); + TEST_INSTRUCTION("48D1D1" , rcl(rcx, 1)); + TEST_INSTRUCTION("D2941180000000" , rcl(byte_ptr(rcx, rdx, 0, 128), cl)); + TEST_INSTRUCTION("D0941180000000" , rcl(byte_ptr(rcx, rdx, 0, 128), 1)); + TEST_INSTRUCTION("66D3941180000000" , rcl(word_ptr(rcx, rdx, 0, 128), cl)); + TEST_INSTRUCTION("66D1941180000000" , rcl(word_ptr(rcx, rdx, 0, 128), 1)); + TEST_INSTRUCTION("D3941180000000" , rcl(dword_ptr(rcx, rdx, 0, 128), cl)); + TEST_INSTRUCTION("D1941180000000" , rcl(dword_ptr(rcx, rdx, 0, 128), 1)); + TEST_INSTRUCTION("48D3941180000000" , rcl(qword_ptr(rcx, rdx, 0, 128), cl)); + TEST_INSTRUCTION("48D1941180000000" , rcl(qword_ptr(rcx, rdx, 0, 128), 1)); + TEST_INSTRUCTION("D2D9" , rcr(cl, cl)); + TEST_INSTRUCTION("D0D9" , rcr(cl, 1)); + TEST_INSTRUCTION("D2DD" , rcr(ch, cl)); + TEST_INSTRUCTION("D0DD" , rcr(ch, 1)); + TEST_INSTRUCTION("66D3D9" , rcr(cx, cl)); + TEST_INSTRUCTION("66D1D9" , rcr(cx, 1)); + TEST_INSTRUCTION("D3D9" , rcr(ecx, cl)); + TEST_INSTRUCTION("D1D9" , rcr(ecx, 1)); + TEST_INSTRUCTION("48D3D9" , rcr(rcx, cl)); + TEST_INSTRUCTION("48D1D9" , rcr(rcx, 1)); + TEST_INSTRUCTION("D29C1180000000" , rcr(byte_ptr(rcx, rdx, 0, 128), cl)); + TEST_INSTRUCTION("D09C1180000000" , rcr(byte_ptr(rcx, rdx, 0, 128), 1)); + TEST_INSTRUCTION("66D39C1180000000" , rcr(word_ptr(rcx, rdx, 0, 128), cl)); + TEST_INSTRUCTION("66D19C1180000000" , rcr(word_ptr(rcx, rdx, 0, 128), 1)); + TEST_INSTRUCTION("D39C1180000000" , rcr(dword_ptr(rcx, rdx, 0, 128), cl)); + TEST_INSTRUCTION("D19C1180000000" , rcr(dword_ptr(rcx, rdx, 0, 128), 1)); + TEST_INSTRUCTION("48D39C1180000000" , rcr(qword_ptr(rcx, rdx, 0, 128), cl)); + TEST_INSTRUCTION("48D19C1180000000" , rcr(qword_ptr(rcx, rdx, 0, 128), 1)); + TEST_INSTRUCTION("F30FAEC1" , rdfsbase(ecx)); + TEST_INSTRUCTION("F3480FAEC1" , rdfsbase(rcx)); + TEST_INSTRUCTION("F30FAEC9" , rdgsbase(ecx)); + TEST_INSTRUCTION("F3480FAEC9" , rdgsbase(rcx)); + TEST_INSTRUCTION("0F32" , rdmsr(edx, eax, ecx)); + TEST_INSTRUCTION("F30FC7F9" , rdpid(rcx)); + TEST_INSTRUCTION("0F01EE" , rdpkru(edx, eax, ecx)); + TEST_INSTRUCTION("0F33" , rdpmc(edx, eax, ecx)); + TEST_INSTRUCTION("0F01FD" , rdpru(edx, eax, ecx)); + TEST_INSTRUCTION("660FC7F1" , rdrand(cx)); + TEST_INSTRUCTION("0FC7F1" , rdrand(ecx)); + TEST_INSTRUCTION("480FC7F1" , rdrand(rcx)); + TEST_INSTRUCTION("660FC7F9" , rdseed(cx)); + TEST_INSTRUCTION("0FC7F9" , rdseed(ecx)); + TEST_INSTRUCTION("480FC7F9" , rdseed(rcx)); + TEST_INSTRUCTION("F30F1EC9" , rdsspd(ecx)); + TEST_INSTRUCTION("F3480F1EC9" , rdsspq(rcx)); + TEST_INSTRUCTION("0F31" , rdtsc(edx, eax)); + TEST_INSTRUCTION("0F01F9" , rdtscp(edx, eax, ecx)); + TEST_INSTRUCTION("C3" , ret()); + TEST_INSTRUCTION("C20100" , ret(1)); + TEST_INSTRUCTION("CB" , retf()); + TEST_INSTRUCTION("CA0100" , retf(1)); + TEST_INSTRUCTION("F30F01FE" , rmpadjust()); + TEST_INSTRUCTION("F20F01FE" , rmpupdate()); + TEST_INSTRUCTION("D2C1" , rol(cl, cl)); + TEST_INSTRUCTION("D0C1" , rol(cl, 1)); + TEST_INSTRUCTION("D2C5" , rol(ch, cl)); + TEST_INSTRUCTION("D0C5" , rol(ch, 1)); + TEST_INSTRUCTION("66D3C1" , rol(cx, cl)); + TEST_INSTRUCTION("66D1C1" , rol(cx, 1)); + TEST_INSTRUCTION("D3C1" , rol(ecx, cl)); + TEST_INSTRUCTION("D1C1" , rol(ecx, 1)); + TEST_INSTRUCTION("48D3C1" , rol(rcx, cl)); + TEST_INSTRUCTION("48D1C1" , rol(rcx, 1)); + TEST_INSTRUCTION("D2841180000000" , rol(byte_ptr(rcx, rdx, 0, 128), cl)); + TEST_INSTRUCTION("D0841180000000" , rol(byte_ptr(rcx, rdx, 0, 128), 1)); + TEST_INSTRUCTION("66D3841180000000" , rol(word_ptr(rcx, rdx, 0, 128), cl)); + TEST_INSTRUCTION("66D1841180000000" , rol(word_ptr(rcx, rdx, 0, 128), 1)); + TEST_INSTRUCTION("D3841180000000" , rol(dword_ptr(rcx, rdx, 0, 128), cl)); + TEST_INSTRUCTION("D1841180000000" , rol(dword_ptr(rcx, rdx, 0, 128), 1)); + TEST_INSTRUCTION("48D3841180000000" , rol(qword_ptr(rcx, rdx, 0, 128), cl)); + TEST_INSTRUCTION("48D1841180000000" , rol(qword_ptr(rcx, rdx, 0, 128), 1)); + TEST_INSTRUCTION("D2C9" , ror(cl, cl)); + TEST_INSTRUCTION("D0C9" , ror(cl, 1)); + TEST_INSTRUCTION("D2CD" , ror(ch, cl)); + TEST_INSTRUCTION("D0CD" , ror(ch, 1)); + TEST_INSTRUCTION("66D3C9" , ror(cx, cl)); + TEST_INSTRUCTION("66D1C9" , ror(cx, 1)); + TEST_INSTRUCTION("D3C9" , ror(ecx, cl)); + TEST_INSTRUCTION("D1C9" , ror(ecx, 1)); + TEST_INSTRUCTION("48D3C9" , ror(rcx, cl)); + TEST_INSTRUCTION("48D1C9" , ror(rcx, 1)); + TEST_INSTRUCTION("D28C1180000000" , ror(byte_ptr(rcx, rdx, 0, 128), cl)); + TEST_INSTRUCTION("D08C1180000000" , ror(byte_ptr(rcx, rdx, 0, 128), 1)); + TEST_INSTRUCTION("66D38C1180000000" , ror(word_ptr(rcx, rdx, 0, 128), cl)); + TEST_INSTRUCTION("66D18C1180000000" , ror(word_ptr(rcx, rdx, 0, 128), 1)); + TEST_INSTRUCTION("D38C1180000000" , ror(dword_ptr(rcx, rdx, 0, 128), cl)); + TEST_INSTRUCTION("D18C1180000000" , ror(dword_ptr(rcx, rdx, 0, 128), 1)); + TEST_INSTRUCTION("48D38C1180000000" , ror(qword_ptr(rcx, rdx, 0, 128), cl)); + TEST_INSTRUCTION("48D18C1180000000" , ror(qword_ptr(rcx, rdx, 0, 128), 1)); + TEST_INSTRUCTION("C4E37BF0CA01" , rorx(ecx, edx, 1)); + TEST_INSTRUCTION("C4E37BF08C1A8000000001" , rorx(ecx, ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("C4E37BF08C1A8000000001" , rorx(ecx, dword_ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("C4E3FBF0CA01" , rorx(rcx, rdx, 1)); + TEST_INSTRUCTION("C4E3FBF08C1A8000000001" , rorx(rcx, ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("C4E3FBF08C1A8000000001" , rorx(rcx, qword_ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("9E" , sahf(ah)); + TEST_INSTRUCTION("D2E1" , sal(cl, cl)); + TEST_INSTRUCTION("D0E1" , sal(cl, 1)); + TEST_INSTRUCTION("D2E5" , sal(ch, cl)); + TEST_INSTRUCTION("D0E5" , sal(ch, 1)); + TEST_INSTRUCTION("66D3E1" , sal(cx, cl)); + TEST_INSTRUCTION("66D1E1" , sal(cx, 1)); + TEST_INSTRUCTION("D3E1" , sal(ecx, cl)); + TEST_INSTRUCTION("D1E1" , sal(ecx, 1)); + TEST_INSTRUCTION("48D3E1" , sal(rcx, cl)); + TEST_INSTRUCTION("48D1E1" , sal(rcx, 1)); + TEST_INSTRUCTION("D2A41180000000" , sal(byte_ptr(rcx, rdx, 0, 128), cl)); + TEST_INSTRUCTION("D0A41180000000" , sal(byte_ptr(rcx, rdx, 0, 128), 1)); + TEST_INSTRUCTION("66D3A41180000000" , sal(word_ptr(rcx, rdx, 0, 128), cl)); + TEST_INSTRUCTION("66D1A41180000000" , sal(word_ptr(rcx, rdx, 0, 128), 1)); + TEST_INSTRUCTION("D3A41180000000" , sal(dword_ptr(rcx, rdx, 0, 128), cl)); + TEST_INSTRUCTION("D1A41180000000" , sal(dword_ptr(rcx, rdx, 0, 128), 1)); + TEST_INSTRUCTION("48D3A41180000000" , sal(qword_ptr(rcx, rdx, 0, 128), cl)); + TEST_INSTRUCTION("48D1A41180000000" , sal(qword_ptr(rcx, rdx, 0, 128), 1)); + TEST_INSTRUCTION("D2F9" , sar(cl, cl)); + TEST_INSTRUCTION("D0F9" , sar(cl, 1)); + TEST_INSTRUCTION("D2FD" , sar(ch, cl)); + TEST_INSTRUCTION("D0FD" , sar(ch, 1)); + TEST_INSTRUCTION("66D3F9" , sar(cx, cl)); + TEST_INSTRUCTION("66D1F9" , sar(cx, 1)); + TEST_INSTRUCTION("D3F9" , sar(ecx, cl)); + TEST_INSTRUCTION("D1F9" , sar(ecx, 1)); + TEST_INSTRUCTION("48D3F9" , sar(rcx, cl)); + TEST_INSTRUCTION("48D1F9" , sar(rcx, 1)); + TEST_INSTRUCTION("D2BC1180000000" , sar(byte_ptr(rcx, rdx, 0, 128), cl)); + TEST_INSTRUCTION("D0BC1180000000" , sar(byte_ptr(rcx, rdx, 0, 128), 1)); + TEST_INSTRUCTION("66D3BC1180000000" , sar(word_ptr(rcx, rdx, 0, 128), cl)); + TEST_INSTRUCTION("66D1BC1180000000" , sar(word_ptr(rcx, rdx, 0, 128), 1)); + TEST_INSTRUCTION("D3BC1180000000" , sar(dword_ptr(rcx, rdx, 0, 128), cl)); + TEST_INSTRUCTION("D1BC1180000000" , sar(dword_ptr(rcx, rdx, 0, 128), 1)); + TEST_INSTRUCTION("48D3BC1180000000" , sar(qword_ptr(rcx, rdx, 0, 128), cl)); + TEST_INSTRUCTION("48D1BC1180000000" , sar(qword_ptr(rcx, rdx, 0, 128), 1)); + TEST_INSTRUCTION("C4E262F7CA" , sarx(ecx, edx, ebx)); + TEST_INSTRUCTION("C4E25AF78C1A80000000" , sarx(ecx, ptr(rdx, rbx, 0, 128), esp)); + TEST_INSTRUCTION("C4E25AF78C1A80000000" , sarx(ecx, dword_ptr(rdx, rbx, 0, 128), esp)); + TEST_INSTRUCTION("C4E2E2F7CA" , sarx(rcx, rdx, rbx)); + TEST_INSTRUCTION("C4E2DAF78C1A80000000" , sarx(rcx, ptr(rdx, rbx, 0, 128), rsp)); + TEST_INSTRUCTION("C4E2DAF78C1A80000000" , sarx(rcx, qword_ptr(rdx, rbx, 0, 128), rsp)); + TEST_INSTRUCTION("F30F01EA" , saveprevssp()); + TEST_INSTRUCTION("80D901" , sbb(cl, 1)); + TEST_INSTRUCTION("80DD01" , sbb(ch, 1)); + TEST_INSTRUCTION("809C118000000001" , sbb(byte_ptr(rcx, rdx, 0, 128), 1)); + TEST_INSTRUCTION("6683D901" , sbb(cx, 1)); + TEST_INSTRUCTION("66839C118000000001" , sbb(word_ptr(rcx, rdx, 0, 128), 1)); + TEST_INSTRUCTION("83D901" , sbb(ecx, 1)); + TEST_INSTRUCTION("839C118000000001" , sbb(dword_ptr(rcx, rdx, 0, 128), 1)); + TEST_INSTRUCTION("4819D1" , sbb(rcx, rdx)); + TEST_INSTRUCTION("4883D901" , sbb(rcx, 1)); + TEST_INSTRUCTION("48199C1180000000" , sbb(ptr(rcx, rdx, 0, 128), rbx)); + TEST_INSTRUCTION("48199C1180000000" , sbb(qword_ptr(rcx, rdx, 0, 128), rbx)); + TEST_INSTRUCTION("48839C118000000001" , sbb(qword_ptr(rcx, rdx, 0, 128), 1)); + TEST_INSTRUCTION("18D1" , sbb(cl, dl)); + TEST_INSTRUCTION("18F1" , sbb(cl, dh)); + TEST_INSTRUCTION("18D5" , sbb(ch, dl)); + TEST_INSTRUCTION("18F5" , sbb(ch, dh)); + TEST_INSTRUCTION("189C1180000000" , sbb(ptr(rcx, rdx, 0, 128), bl)); + TEST_INSTRUCTION("18BC1180000000" , sbb(ptr(rcx, rdx, 0, 128), bh)); + TEST_INSTRUCTION("189C1180000000" , sbb(byte_ptr(rcx, rdx, 0, 128), bl)); + TEST_INSTRUCTION("18BC1180000000" , sbb(byte_ptr(rcx, rdx, 0, 128), bh)); + TEST_INSTRUCTION("6619D1" , sbb(cx, dx)); + TEST_INSTRUCTION("66199C1180000000" , sbb(ptr(rcx, rdx, 0, 128), bx)); + TEST_INSTRUCTION("66199C1180000000" , sbb(word_ptr(rcx, rdx, 0, 128), bx)); + TEST_INSTRUCTION("19D1" , sbb(ecx, edx)); + TEST_INSTRUCTION("199C1180000000" , sbb(ptr(rcx, rdx, 0, 128), ebx)); + TEST_INSTRUCTION("199C1180000000" , sbb(dword_ptr(rcx, rdx, 0, 128), ebx)); + TEST_INSTRUCTION("1A8C1A80000000" , sbb(cl, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("1A8C1A80000000" , sbb(cl, byte_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("1AAC1A80000000" , sbb(ch, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("1AAC1A80000000" , sbb(ch, byte_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("661B8C1A80000000" , sbb(cx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("661B8C1A80000000" , sbb(cx, word_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("1B8C1A80000000" , sbb(ecx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("1B8C1A80000000" , sbb(ecx, dword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("481B8C1A80000000" , sbb(rcx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("481B8C1A80000000" , sbb(rcx, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("AE" , scas(al, ptr(rdi))); + TEST_INSTRUCTION("AE" , scas(al, byte_ptr(rdi))); + TEST_INSTRUCTION("66AF" , scas(ax, ptr(rdi))); + TEST_INSTRUCTION("66AF" , scas(ax, word_ptr(rdi))); + TEST_INSTRUCTION("AF" , scas(eax, ptr(rdi))); + TEST_INSTRUCTION("AF" , scas(eax, dword_ptr(rdi))); + TEST_INSTRUCTION("48AF" , scas(rax, ptr(rdi))); + TEST_INSTRUCTION("48AF" , scas(rax, qword_ptr(rdi))); + TEST_INSTRUCTION("F30FC7F1" , senduipi(rcx)); + TEST_INSTRUCTION("0F01E8" , serialize()); + TEST_INSTRUCTION("0F97C1" , seta(cl)); + TEST_INSTRUCTION("0F97C5" , seta(ch)); + TEST_INSTRUCTION("0F97841180000000" , seta(ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("0F97841180000000" , seta(byte_ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("0F93C1" , setae(cl)); + TEST_INSTRUCTION("0F93C5" , setae(ch)); + TEST_INSTRUCTION("0F93841180000000" , setae(ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("0F93841180000000" , setae(byte_ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("0F92C1" , setb(cl)); + TEST_INSTRUCTION("0F92C5" , setb(ch)); + TEST_INSTRUCTION("0F92841180000000" , setb(ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("0F92841180000000" , setb(byte_ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("0F96C1" , setbe(cl)); + TEST_INSTRUCTION("0F96C5" , setbe(ch)); + TEST_INSTRUCTION("0F96841180000000" , setbe(ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("0F96841180000000" , setbe(byte_ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("0F92C1" , setc(cl)); + TEST_INSTRUCTION("0F92C5" , setc(ch)); + TEST_INSTRUCTION("0F92841180000000" , setc(ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("0F92841180000000" , setc(byte_ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("0F94C1" , sete(cl)); + TEST_INSTRUCTION("0F94C5" , sete(ch)); + TEST_INSTRUCTION("0F94841180000000" , sete(ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("0F94841180000000" , sete(byte_ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("0F9FC1" , setg(cl)); + TEST_INSTRUCTION("0F9FC5" , setg(ch)); + TEST_INSTRUCTION("0F9F841180000000" , setg(ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("0F9F841180000000" , setg(byte_ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("0F9DC1" , setge(cl)); + TEST_INSTRUCTION("0F9DC5" , setge(ch)); + TEST_INSTRUCTION("0F9D841180000000" , setge(ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("0F9D841180000000" , setge(byte_ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("0F9CC1" , setl(cl)); + TEST_INSTRUCTION("0F9CC5" , setl(ch)); + TEST_INSTRUCTION("0F9C841180000000" , setl(ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("0F9C841180000000" , setl(byte_ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("0F9EC1" , setle(cl)); + TEST_INSTRUCTION("0F9EC5" , setle(ch)); + TEST_INSTRUCTION("0F9E841180000000" , setle(ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("0F9E841180000000" , setle(byte_ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("0F96C1" , setna(cl)); + TEST_INSTRUCTION("0F96C5" , setna(ch)); + TEST_INSTRUCTION("0F96841180000000" , setna(ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("0F96841180000000" , setna(byte_ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("0F92C1" , setnae(cl)); + TEST_INSTRUCTION("0F92C5" , setnae(ch)); + TEST_INSTRUCTION("0F92841180000000" , setnae(ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("0F92841180000000" , setnae(byte_ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("0F93C1" , setnb(cl)); + TEST_INSTRUCTION("0F93C5" , setnb(ch)); + TEST_INSTRUCTION("0F93841180000000" , setnb(ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("0F93841180000000" , setnb(byte_ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("0F97C1" , setnbe(cl)); + TEST_INSTRUCTION("0F97C5" , setnbe(ch)); + TEST_INSTRUCTION("0F97841180000000" , setnbe(ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("0F97841180000000" , setnbe(byte_ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("0F93C1" , setnc(cl)); + TEST_INSTRUCTION("0F93C5" , setnc(ch)); + TEST_INSTRUCTION("0F93841180000000" , setnc(ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("0F93841180000000" , setnc(byte_ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("0F95C1" , setne(cl)); + TEST_INSTRUCTION("0F95C5" , setne(ch)); + TEST_INSTRUCTION("0F95841180000000" , setne(ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("0F95841180000000" , setne(byte_ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("0F9EC1" , setng(cl)); + TEST_INSTRUCTION("0F9EC5" , setng(ch)); + TEST_INSTRUCTION("0F9E841180000000" , setng(ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("0F9E841180000000" , setng(byte_ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("0F9CC1" , setnge(cl)); + TEST_INSTRUCTION("0F9CC5" , setnge(ch)); + TEST_INSTRUCTION("0F9C841180000000" , setnge(ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("0F9C841180000000" , setnge(byte_ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("0F9DC1" , setnl(cl)); + TEST_INSTRUCTION("0F9DC5" , setnl(ch)); + TEST_INSTRUCTION("0F9D841180000000" , setnl(ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("0F9D841180000000" , setnl(byte_ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("0F9FC1" , setnle(cl)); + TEST_INSTRUCTION("0F9FC5" , setnle(ch)); + TEST_INSTRUCTION("0F9F841180000000" , setnle(ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("0F9F841180000000" , setnle(byte_ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("0F91C1" , setno(cl)); + TEST_INSTRUCTION("0F91C5" , setno(ch)); + TEST_INSTRUCTION("0F91841180000000" , setno(ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("0F91841180000000" , setno(byte_ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("0F9BC1" , setnp(cl)); + TEST_INSTRUCTION("0F9BC5" , setnp(ch)); + TEST_INSTRUCTION("0F9B841180000000" , setnp(ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("0F9B841180000000" , setnp(byte_ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("0F99C1" , setns(cl)); + TEST_INSTRUCTION("0F99C5" , setns(ch)); + TEST_INSTRUCTION("0F99841180000000" , setns(ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("0F99841180000000" , setns(byte_ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("0F95C1" , setnz(cl)); + TEST_INSTRUCTION("0F95C5" , setnz(ch)); + TEST_INSTRUCTION("0F95841180000000" , setnz(ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("0F95841180000000" , setnz(byte_ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("0F90C1" , seto(cl)); + TEST_INSTRUCTION("0F90C5" , seto(ch)); + TEST_INSTRUCTION("0F90841180000000" , seto(ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("0F90841180000000" , seto(byte_ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("0F9AC1" , setp(cl)); + TEST_INSTRUCTION("0F9AC5" , setp(ch)); + TEST_INSTRUCTION("0F9A841180000000" , setp(ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("0F9A841180000000" , setp(byte_ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("0F9AC1" , setpe(cl)); + TEST_INSTRUCTION("0F9AC5" , setpe(ch)); + TEST_INSTRUCTION("0F9A841180000000" , setpe(ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("0F9A841180000000" , setpe(byte_ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("0F9BC1" , setpo(cl)); + TEST_INSTRUCTION("0F9BC5" , setpo(ch)); + TEST_INSTRUCTION("0F9B841180000000" , setpo(ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("0F9B841180000000" , setpo(byte_ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("0F98C1" , sets(cl)); + TEST_INSTRUCTION("0F98C5" , sets(ch)); + TEST_INSTRUCTION("0F98841180000000" , sets(ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("0F98841180000000" , sets(byte_ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("F30F01E8" , setssbsy()); + TEST_INSTRUCTION("0F94C1" , setz(cl)); + TEST_INSTRUCTION("0F94C5" , setz(ch)); + TEST_INSTRUCTION("0F94841180000000" , setz(ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("0F94841180000000" , setz(byte_ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("0FAEF8" , sfence()); + TEST_INSTRUCTION("0F01841180000000" , sgdt(ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("D2E1" , shl(cl, cl)); + TEST_INSTRUCTION("D0E1" , shl(cl, 1)); + TEST_INSTRUCTION("D2E5" , shl(ch, cl)); + TEST_INSTRUCTION("D0E5" , shl(ch, 1)); + TEST_INSTRUCTION("66D3E1" , shl(cx, cl)); + TEST_INSTRUCTION("66D1E1" , shl(cx, 1)); + TEST_INSTRUCTION("D3E1" , shl(ecx, cl)); + TEST_INSTRUCTION("D1E1" , shl(ecx, 1)); + TEST_INSTRUCTION("48D3E1" , shl(rcx, cl)); + TEST_INSTRUCTION("48D1E1" , shl(rcx, 1)); + TEST_INSTRUCTION("D2A41180000000" , shl(byte_ptr(rcx, rdx, 0, 128), cl)); + TEST_INSTRUCTION("D0A41180000000" , shl(byte_ptr(rcx, rdx, 0, 128), 1)); + TEST_INSTRUCTION("66D3A41180000000" , shl(word_ptr(rcx, rdx, 0, 128), cl)); + TEST_INSTRUCTION("66D1A41180000000" , shl(word_ptr(rcx, rdx, 0, 128), 1)); + TEST_INSTRUCTION("D3A41180000000" , shl(dword_ptr(rcx, rdx, 0, 128), cl)); + TEST_INSTRUCTION("D1A41180000000" , shl(dword_ptr(rcx, rdx, 0, 128), 1)); + TEST_INSTRUCTION("48D3A41180000000" , shl(qword_ptr(rcx, rdx, 0, 128), cl)); + TEST_INSTRUCTION("48D1A41180000000" , shl(qword_ptr(rcx, rdx, 0, 128), 1)); + TEST_INSTRUCTION("660FA5D1" , shld(cx, dx, cl)); + TEST_INSTRUCTION("660FA4D101" , shld(cx, dx, 1)); + TEST_INSTRUCTION("660FA59C1180000000" , shld(ptr(rcx, rdx, 0, 128), bx, cl)); + TEST_INSTRUCTION("660FA49C118000000001" , shld(ptr(rcx, rdx, 0, 128), bx, 1)); + TEST_INSTRUCTION("660FA59C1180000000" , shld(word_ptr(rcx, rdx, 0, 128), bx, cl)); + TEST_INSTRUCTION("660FA49C118000000001" , shld(word_ptr(rcx, rdx, 0, 128), bx, 1)); + TEST_INSTRUCTION("0FA5D1" , shld(ecx, edx, cl)); + TEST_INSTRUCTION("0FA4D101" , shld(ecx, edx, 1)); + TEST_INSTRUCTION("0FA59C1180000000" , shld(ptr(rcx, rdx, 0, 128), ebx, cl)); + TEST_INSTRUCTION("0FA49C118000000001" , shld(ptr(rcx, rdx, 0, 128), ebx, 1)); + TEST_INSTRUCTION("0FA59C1180000000" , shld(dword_ptr(rcx, rdx, 0, 128), ebx, cl)); + TEST_INSTRUCTION("0FA49C118000000001" , shld(dword_ptr(rcx, rdx, 0, 128), ebx, 1)); + TEST_INSTRUCTION("480FA5D1" , shld(rcx, rdx, cl)); + TEST_INSTRUCTION("480FA4D101" , shld(rcx, rdx, 1)); + TEST_INSTRUCTION("480FA59C1180000000" , shld(ptr(rcx, rdx, 0, 128), rbx, cl)); + TEST_INSTRUCTION("480FA49C118000000001" , shld(ptr(rcx, rdx, 0, 128), rbx, 1)); + TEST_INSTRUCTION("480FA59C1180000000" , shld(qword_ptr(rcx, rdx, 0, 128), rbx, cl)); + TEST_INSTRUCTION("480FA49C118000000001" , shld(qword_ptr(rcx, rdx, 0, 128), rbx, 1)); + TEST_INSTRUCTION("C4E261F7CA" , shlx(ecx, edx, ebx)); + TEST_INSTRUCTION("C4E259F78C1A80000000" , shlx(ecx, ptr(rdx, rbx, 0, 128), esp)); + TEST_INSTRUCTION("C4E259F78C1A80000000" , shlx(ecx, dword_ptr(rdx, rbx, 0, 128), esp)); + TEST_INSTRUCTION("C4E2E1F7CA" , shlx(rcx, rdx, rbx)); + TEST_INSTRUCTION("C4E2D9F78C1A80000000" , shlx(rcx, ptr(rdx, rbx, 0, 128), rsp)); + TEST_INSTRUCTION("C4E2D9F78C1A80000000" , shlx(rcx, qword_ptr(rdx, rbx, 0, 128), rsp)); + TEST_INSTRUCTION("D2E9" , shr(cl, cl)); + TEST_INSTRUCTION("D0E9" , shr(cl, 1)); + TEST_INSTRUCTION("D2ED" , shr(ch, cl)); + TEST_INSTRUCTION("D0ED" , shr(ch, 1)); + TEST_INSTRUCTION("66D3E9" , shr(cx, cl)); + TEST_INSTRUCTION("66D1E9" , shr(cx, 1)); + TEST_INSTRUCTION("D3E9" , shr(ecx, cl)); + TEST_INSTRUCTION("D1E9" , shr(ecx, 1)); + TEST_INSTRUCTION("48D3E9" , shr(rcx, cl)); + TEST_INSTRUCTION("48D1E9" , shr(rcx, 1)); + TEST_INSTRUCTION("D2AC1180000000" , shr(byte_ptr(rcx, rdx, 0, 128), cl)); + TEST_INSTRUCTION("D0AC1180000000" , shr(byte_ptr(rcx, rdx, 0, 128), 1)); + TEST_INSTRUCTION("66D3AC1180000000" , shr(word_ptr(rcx, rdx, 0, 128), cl)); + TEST_INSTRUCTION("66D1AC1180000000" , shr(word_ptr(rcx, rdx, 0, 128), 1)); + TEST_INSTRUCTION("D3AC1180000000" , shr(dword_ptr(rcx, rdx, 0, 128), cl)); + TEST_INSTRUCTION("D1AC1180000000" , shr(dword_ptr(rcx, rdx, 0, 128), 1)); + TEST_INSTRUCTION("48D3AC1180000000" , shr(qword_ptr(rcx, rdx, 0, 128), cl)); + TEST_INSTRUCTION("48D1AC1180000000" , shr(qword_ptr(rcx, rdx, 0, 128), 1)); + TEST_INSTRUCTION("660FADD1" , shrd(cx, dx, cl)); + TEST_INSTRUCTION("660FACD101" , shrd(cx, dx, 1)); + TEST_INSTRUCTION("660FAD9C1180000000" , shrd(ptr(rcx, rdx, 0, 128), bx, cl)); + TEST_INSTRUCTION("660FAC9C118000000001" , shrd(ptr(rcx, rdx, 0, 128), bx, 1)); + TEST_INSTRUCTION("660FAD9C1180000000" , shrd(word_ptr(rcx, rdx, 0, 128), bx, cl)); + TEST_INSTRUCTION("660FAC9C118000000001" , shrd(word_ptr(rcx, rdx, 0, 128), bx, 1)); + TEST_INSTRUCTION("0FADD1" , shrd(ecx, edx, cl)); + TEST_INSTRUCTION("0FACD101" , shrd(ecx, edx, 1)); + TEST_INSTRUCTION("0FAD9C1180000000" , shrd(ptr(rcx, rdx, 0, 128), ebx, cl)); + TEST_INSTRUCTION("0FAC9C118000000001" , shrd(ptr(rcx, rdx, 0, 128), ebx, 1)); + TEST_INSTRUCTION("0FAD9C1180000000" , shrd(dword_ptr(rcx, rdx, 0, 128), ebx, cl)); + TEST_INSTRUCTION("0FAC9C118000000001" , shrd(dword_ptr(rcx, rdx, 0, 128), ebx, 1)); + TEST_INSTRUCTION("480FADD1" , shrd(rcx, rdx, cl)); + TEST_INSTRUCTION("480FACD101" , shrd(rcx, rdx, 1)); + TEST_INSTRUCTION("480FAD9C1180000000" , shrd(ptr(rcx, rdx, 0, 128), rbx, cl)); + TEST_INSTRUCTION("480FAC9C118000000001" , shrd(ptr(rcx, rdx, 0, 128), rbx, 1)); + TEST_INSTRUCTION("480FAD9C1180000000" , shrd(qword_ptr(rcx, rdx, 0, 128), rbx, cl)); + TEST_INSTRUCTION("480FAC9C118000000001" , shrd(qword_ptr(rcx, rdx, 0, 128), rbx, 1)); + TEST_INSTRUCTION("C4E263F7CA" , shrx(ecx, edx, ebx)); + TEST_INSTRUCTION("C4E25BF78C1A80000000" , shrx(ecx, ptr(rdx, rbx, 0, 128), esp)); + TEST_INSTRUCTION("C4E25BF78C1A80000000" , shrx(ecx, dword_ptr(rdx, rbx, 0, 128), esp)); + TEST_INSTRUCTION("C4E2E3F7CA" , shrx(rcx, rdx, rbx)); + TEST_INSTRUCTION("C4E2DBF78C1A80000000" , shrx(rcx, ptr(rdx, rbx, 0, 128), rsp)); + TEST_INSTRUCTION("C4E2DBF78C1A80000000" , shrx(rcx, qword_ptr(rdx, rbx, 0, 128), rsp)); + TEST_INSTRUCTION("0F018C1180000000" , sidt(ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("0F01DE" , skinit(eax)); + TEST_INSTRUCTION("660F00C1" , sldt(cx)); + TEST_INSTRUCTION("0F00C1" , sldt(ecx)); + TEST_INSTRUCTION("480F00C1" , sldt(rcx)); + TEST_INSTRUCTION("0F00841180000000" , sldt(ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("0F00841180000000" , sldt(word_ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("8FE97812C9" , slwpcb(ecx)); + TEST_INSTRUCTION("8FE9F812C9" , slwpcb(rcx)); + TEST_INSTRUCTION("660F01E1" , smsw(cx)); + TEST_INSTRUCTION("0F01E1" , smsw(ecx)); + TEST_INSTRUCTION("480F01E1" , smsw(rcx)); + TEST_INSTRUCTION("0F01A41180000000" , smsw(ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("0F01A41180000000" , smsw(word_ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("0F01CB" , stac()); + TEST_INSTRUCTION("F9" , stc()); + TEST_INSTRUCTION("FD" , std()); + TEST_INSTRUCTION("0F01DC" , stgi()); + TEST_INSTRUCTION("FB" , sti()); + TEST_INSTRUCTION("0FAE9C1180000000" , stmxcsr(ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("0FAE9C1180000000" , stmxcsr(dword_ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("AA" , stos(ptr(rdi), al)); + TEST_INSTRUCTION("AA" , stos(byte_ptr(rdi), al)); + TEST_INSTRUCTION("66AB" , stos(ptr(rdi), ax)); + TEST_INSTRUCTION("66AB" , stos(word_ptr(rdi), ax)); + TEST_INSTRUCTION("AB" , stos(ptr(rdi), eax)); + TEST_INSTRUCTION("AB" , stos(dword_ptr(rdi), eax)); + TEST_INSTRUCTION("48AB" , stos(ptr(rdi), rax)); + TEST_INSTRUCTION("48AB" , stos(qword_ptr(rdi), rax)); + TEST_INSTRUCTION("660F00C9" , str(cx)); + TEST_INSTRUCTION("0F00C9" , str(ecx)); + TEST_INSTRUCTION("480F00C9" , str(rcx)); + TEST_INSTRUCTION("0F008C1180000000" , str(ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("0F008C1180000000" , str(word_ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("F30F01EF" , stui()); + TEST_INSTRUCTION("80E901" , sub(cl, 1)); + TEST_INSTRUCTION("80ED01" , sub(ch, 1)); + TEST_INSTRUCTION("80AC118000000001" , sub(byte_ptr(rcx, rdx, 0, 128), 1)); + TEST_INSTRUCTION("6683E901" , sub(cx, 1)); + TEST_INSTRUCTION("6683AC118000000001" , sub(word_ptr(rcx, rdx, 0, 128), 1)); + TEST_INSTRUCTION("83E901" , sub(ecx, 1)); + TEST_INSTRUCTION("83AC118000000001" , sub(dword_ptr(rcx, rdx, 0, 128), 1)); + TEST_INSTRUCTION("4829D1" , sub(rcx, rdx)); + TEST_INSTRUCTION("4883E901" , sub(rcx, 1)); + TEST_INSTRUCTION("48299C1180000000" , sub(ptr(rcx, rdx, 0, 128), rbx)); + TEST_INSTRUCTION("48299C1180000000" , sub(qword_ptr(rcx, rdx, 0, 128), rbx)); + TEST_INSTRUCTION("4883AC118000000001" , sub(qword_ptr(rcx, rdx, 0, 128), 1)); + TEST_INSTRUCTION("28D1" , sub(cl, dl)); + TEST_INSTRUCTION("28F1" , sub(cl, dh)); + TEST_INSTRUCTION("28D5" , sub(ch, dl)); + TEST_INSTRUCTION("28F5" , sub(ch, dh)); + TEST_INSTRUCTION("289C1180000000" , sub(ptr(rcx, rdx, 0, 128), bl)); + TEST_INSTRUCTION("28BC1180000000" , sub(ptr(rcx, rdx, 0, 128), bh)); + TEST_INSTRUCTION("289C1180000000" , sub(byte_ptr(rcx, rdx, 0, 128), bl)); + TEST_INSTRUCTION("28BC1180000000" , sub(byte_ptr(rcx, rdx, 0, 128), bh)); + TEST_INSTRUCTION("6629D1" , sub(cx, dx)); + TEST_INSTRUCTION("66299C1180000000" , sub(ptr(rcx, rdx, 0, 128), bx)); + TEST_INSTRUCTION("66299C1180000000" , sub(word_ptr(rcx, rdx, 0, 128), bx)); + TEST_INSTRUCTION("29D1" , sub(ecx, edx)); + TEST_INSTRUCTION("299C1180000000" , sub(ptr(rcx, rdx, 0, 128), ebx)); + TEST_INSTRUCTION("299C1180000000" , sub(dword_ptr(rcx, rdx, 0, 128), ebx)); + TEST_INSTRUCTION("2A8C1A80000000" , sub(cl, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("2A8C1A80000000" , sub(cl, byte_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("2AAC1A80000000" , sub(ch, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("2AAC1A80000000" , sub(ch, byte_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("662B8C1A80000000" , sub(cx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("662B8C1A80000000" , sub(cx, word_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("2B8C1A80000000" , sub(ecx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("2B8C1A80000000" , sub(ecx, dword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("482B8C1A80000000" , sub(rcx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("482B8C1A80000000" , sub(rcx, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F01F8" , swapgs()); + TEST_INSTRUCTION("0F05" , syscall()); + TEST_INSTRUCTION("0F34" , sysenter()); + TEST_INSTRUCTION("0F35" , sysexit()); + TEST_INSTRUCTION("480F35" , sysexitq()); + TEST_INSTRUCTION("0F07" , sysret()); + TEST_INSTRUCTION("480F07" , sysretq()); + TEST_INSTRUCTION("8FE97001FA" , t1mskc(ecx, edx)); + TEST_INSTRUCTION("8FE97001BC1A80000000" , t1mskc(ecx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("8FE97001BC1A80000000" , t1mskc(ecx, dword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("8FE9F001FA" , t1mskc(rcx, rdx)); + TEST_INSTRUCTION("8FE9F001BC1A80000000" , t1mskc(rcx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("8FE9F001BC1A80000000" , t1mskc(rcx, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("F6C101" , test(cl, 1)); + TEST_INSTRUCTION("F6C501" , test(ch, 1)); + TEST_INSTRUCTION("F684118000000001" , test(byte_ptr(rcx, rdx, 0, 128), 1)); + TEST_INSTRUCTION("66F7C10100" , test(cx, 1)); + TEST_INSTRUCTION("66F78411800000000100" , test(word_ptr(rcx, rdx, 0, 128), 1)); + TEST_INSTRUCTION("F7C101000000" , test(ecx, 1)); + TEST_INSTRUCTION("F784118000000001000000" , test(dword_ptr(rcx, rdx, 0, 128), 1)); + TEST_INSTRUCTION("4885D1" , test(rcx, rdx)); + TEST_INSTRUCTION("48F7C101000000" , test(rcx, 1)); + TEST_INSTRUCTION("48859C1180000000" , test(ptr(rcx, rdx, 0, 128), rbx)); + TEST_INSTRUCTION("48859C1180000000" , test(qword_ptr(rcx, rdx, 0, 128), rbx)); + TEST_INSTRUCTION("48F784118000000001000000" , test(qword_ptr(rcx, rdx, 0, 128), 1)); + TEST_INSTRUCTION("84D1" , test(cl, dl)); + TEST_INSTRUCTION("84F1" , test(cl, dh)); + TEST_INSTRUCTION("84D5" , test(ch, dl)); + TEST_INSTRUCTION("84F5" , test(ch, dh)); + TEST_INSTRUCTION("849C1180000000" , test(ptr(rcx, rdx, 0, 128), bl)); + TEST_INSTRUCTION("84BC1180000000" , test(ptr(rcx, rdx, 0, 128), bh)); + TEST_INSTRUCTION("849C1180000000" , test(byte_ptr(rcx, rdx, 0, 128), bl)); + TEST_INSTRUCTION("84BC1180000000" , test(byte_ptr(rcx, rdx, 0, 128), bh)); + TEST_INSTRUCTION("6685D1" , test(cx, dx)); + TEST_INSTRUCTION("66859C1180000000" , test(ptr(rcx, rdx, 0, 128), bx)); + TEST_INSTRUCTION("66859C1180000000" , test(word_ptr(rcx, rdx, 0, 128), bx)); + TEST_INSTRUCTION("85D1" , test(ecx, edx)); + TEST_INSTRUCTION("859C1180000000" , test(ptr(rcx, rdx, 0, 128), ebx)); + TEST_INSTRUCTION("859C1180000000" , test(dword_ptr(rcx, rdx, 0, 128), ebx)); + TEST_INSTRUCTION("F30F01ED" , testui()); + TEST_INSTRUCTION("660FAEF1" , tpause(ecx, edx, eax)); + TEST_INSTRUCTION("66F30FBCCA" , tzcnt(cx, dx)); + TEST_INSTRUCTION("66F30FBC8C1A80000000" , tzcnt(cx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("66F30FBC8C1A80000000" , tzcnt(cx, word_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("F30FBCCA" , tzcnt(ecx, edx)); + TEST_INSTRUCTION("F30FBC8C1A80000000" , tzcnt(ecx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("F30FBC8C1A80000000" , tzcnt(ecx, dword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("F3480FBCCA" , tzcnt(rcx, rdx)); + TEST_INSTRUCTION("F3480FBC8C1A80000000" , tzcnt(rcx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("F3480FBC8C1A80000000" , tzcnt(rcx, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("8FE97001E2" , tzmsk(ecx, edx)); + TEST_INSTRUCTION("8FE97001A41A80000000" , tzmsk(ecx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("8FE97001A41A80000000" , tzmsk(ecx, dword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("8FE9F001E2" , tzmsk(rcx, rdx)); + TEST_INSTRUCTION("8FE9F001A41A80000000" , tzmsk(rcx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("8FE9F001A41A80000000" , tzmsk(rcx, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0FFFCA" , ud0(ecx, edx)); + TEST_INSTRUCTION("0FFF8C1A80000000" , ud0(ecx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0FFF8C1A80000000" , ud0(ecx, dword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0FB9CA" , ud1(ecx, edx)); + TEST_INSTRUCTION("0FB98C1A80000000" , ud1(ecx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0FB98C1A80000000" , ud1(ecx, dword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F0B" , ud2()); + TEST_INSTRUCTION("F30F01EC" , uiret()); + TEST_INSTRUCTION("F30FAEF1" , umonitor(ptr(rcx))); + TEST_INSTRUCTION("F20FAEF1" , umwait(ecx, edx, eax)); + TEST_INSTRUCTION("0F00E1" , verr(cx)); + TEST_INSTRUCTION("0F00A41180000000" , verr(ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("0F00A41180000000" , verr(word_ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("0F00E9" , verw(cx)); + TEST_INSTRUCTION("0F00AC1180000000" , verw(ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("0F00AC1180000000" , verw(word_ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("0F01C1" , vmcall()); + TEST_INSTRUCTION("660FC7B41180000000" , vmclear(ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("660FC7B41180000000" , vmclear(qword_ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("0F01D4" , vmfunc()); + TEST_INSTRUCTION("0F01C2" , vmlaunch()); + TEST_INSTRUCTION("0F01DA" , vmload(rax)); + TEST_INSTRUCTION("0F01D9" , vmmcall()); + TEST_INSTRUCTION("0FC7B41180000000" , vmptrld(ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("0FC7B41180000000" , vmptrld(qword_ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("0FC7BC1180000000" , vmptrst(ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("0FC7BC1180000000" , vmptrst(qword_ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("0F78D1" , vmread(rcx, rdx)); + TEST_INSTRUCTION("0F789C1180000000" , vmread(ptr(rcx, rdx, 0, 128), rbx)); + TEST_INSTRUCTION("0F789C1180000000" , vmread(qword_ptr(rcx, rdx, 0, 128), rbx)); + TEST_INSTRUCTION("0F01C3" , vmresume()); + TEST_INSTRUCTION("0F01D8" , vmrun(rax)); + TEST_INSTRUCTION("0F01DB" , vmsave(rax)); + TEST_INSTRUCTION("0F79CA" , vmwrite(rcx, rdx)); + TEST_INSTRUCTION("0F798C1A80000000" , vmwrite(rcx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F798C1A80000000" , vmwrite(rcx, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("F30FC7B41180000000" , vmxon(ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("F30FC7B41180000000" , vmxon(qword_ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("0F09" , wbinvd()); + TEST_INSTRUCTION("F30F09" , wbnoinvd()); + TEST_INSTRUCTION("F30FAED1" , wrfsbase(ecx)); + TEST_INSTRUCTION("F3480FAED1" , wrfsbase(rcx)); + TEST_INSTRUCTION("F30FAED9" , wrgsbase(ecx)); + TEST_INSTRUCTION("F3480FAED9" , wrgsbase(rcx)); + TEST_INSTRUCTION("0F30" , wrmsr(edx, eax, ecx)); + TEST_INSTRUCTION("0F38F6D1" , wrssd(ecx, edx)); + TEST_INSTRUCTION("0F38F69C1180000000" , wrssd(ptr(rcx, rdx, 0, 128), ebx)); + TEST_INSTRUCTION("0F38F69C1180000000" , wrssd(dword_ptr(rcx, rdx, 0, 128), ebx)); + TEST_INSTRUCTION("480F38F6D1" , wrssq(rcx, rdx)); + TEST_INSTRUCTION("480F38F69C1180000000" , wrssq(ptr(rcx, rdx, 0, 128), rbx)); + TEST_INSTRUCTION("480F38F69C1180000000" , wrssq(qword_ptr(rcx, rdx, 0, 128), rbx)); + TEST_INSTRUCTION("660F38F5D1" , wrussd(ecx, edx)); + TEST_INSTRUCTION("660F38F59C1180000000" , wrussd(ptr(rcx, rdx, 0, 128), ebx)); + TEST_INSTRUCTION("660F38F59C1180000000" , wrussd(dword_ptr(rcx, rdx, 0, 128), ebx)); + TEST_INSTRUCTION("66480F38F5D1" , wrussq(rcx, rdx)); + TEST_INSTRUCTION("66480F38F59C1180000000" , wrussq(ptr(rcx, rdx, 0, 128), rbx)); + TEST_INSTRUCTION("66480F38F59C1180000000" , wrussq(qword_ptr(rcx, rdx, 0, 128), rbx)); + TEST_INSTRUCTION("C6F801" , xabort(1)); + TEST_INSTRUCTION("0FC0D1" , xadd(cl, dl)); + TEST_INSTRUCTION("0FC0F1" , xadd(cl, dh)); + TEST_INSTRUCTION("0FC0D5" , xadd(ch, dl)); + TEST_INSTRUCTION("0FC0F5" , xadd(ch, dh)); + TEST_INSTRUCTION("0FC09C1180000000" , xadd(ptr(rcx, rdx, 0, 128), bl)); + TEST_INSTRUCTION("0FC0BC1180000000" , xadd(ptr(rcx, rdx, 0, 128), bh)); + TEST_INSTRUCTION("0FC09C1180000000" , xadd(byte_ptr(rcx, rdx, 0, 128), bl)); + TEST_INSTRUCTION("0FC0BC1180000000" , xadd(byte_ptr(rcx, rdx, 0, 128), bh)); + TEST_INSTRUCTION("660FC1D1" , xadd(cx, dx)); + TEST_INSTRUCTION("660FC19C1180000000" , xadd(ptr(rcx, rdx, 0, 128), bx)); + TEST_INSTRUCTION("660FC19C1180000000" , xadd(word_ptr(rcx, rdx, 0, 128), bx)); + TEST_INSTRUCTION("0FC1D1" , xadd(ecx, edx)); + TEST_INSTRUCTION("0FC19C1180000000" , xadd(ptr(rcx, rdx, 0, 128), ebx)); + TEST_INSTRUCTION("0FC19C1180000000" , xadd(dword_ptr(rcx, rdx, 0, 128), ebx)); + TEST_INSTRUCTION("480FC1D1" , xadd(rcx, rdx)); + TEST_INSTRUCTION("480FC19C1180000000" , xadd(ptr(rcx, rdx, 0, 128), rbx)); + TEST_INSTRUCTION("480FC19C1180000000" , xadd(qword_ptr(rcx, rdx, 0, 128), rbx)); + TEST_INSTRUCTION("86D1" , xchg(cl, dl)); + TEST_INSTRUCTION("86F1" , xchg(cl, dh)); + TEST_INSTRUCTION("86D5" , xchg(ch, dl)); + TEST_INSTRUCTION("86F5" , xchg(ch, dh)); + TEST_INSTRUCTION("869C1180000000" , xchg(ptr(rcx, rdx, 0, 128), bl)); + TEST_INSTRUCTION("86BC1180000000" , xchg(ptr(rcx, rdx, 0, 128), bh)); + TEST_INSTRUCTION("869C1180000000" , xchg(byte_ptr(rcx, rdx, 0, 128), bl)); + TEST_INSTRUCTION("86BC1180000000" , xchg(byte_ptr(rcx, rdx, 0, 128), bh)); + TEST_INSTRUCTION("6687D1" , xchg(cx, dx)); + TEST_INSTRUCTION("66879C1180000000" , xchg(ptr(rcx, rdx, 0, 128), bx)); + TEST_INSTRUCTION("66879C1180000000" , xchg(word_ptr(rcx, rdx, 0, 128), bx)); + TEST_INSTRUCTION("87D1" , xchg(ecx, edx)); + TEST_INSTRUCTION("879C1180000000" , xchg(ptr(rcx, rdx, 0, 128), ebx)); + TEST_INSTRUCTION("879C1180000000" , xchg(dword_ptr(rcx, rdx, 0, 128), ebx)); + TEST_INSTRUCTION("4887D1" , xchg(rcx, rdx)); + TEST_INSTRUCTION("48879C1180000000" , xchg(ptr(rcx, rdx, 0, 128), rbx)); + TEST_INSTRUCTION("48879C1180000000" , xchg(qword_ptr(rcx, rdx, 0, 128), rbx)); + TEST_INSTRUCTION("868C1A80000000" , xchg(cl, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("868C1A80000000" , xchg(cl, byte_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("86AC1A80000000" , xchg(ch, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("86AC1A80000000" , xchg(ch, byte_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("66878C1A80000000" , xchg(cx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("66878C1A80000000" , xchg(cx, word_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("878C1A80000000" , xchg(ecx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("878C1A80000000" , xchg(ecx, dword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("48878C1A80000000" , xchg(rcx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("48878C1A80000000" , xchg(rcx, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F01D5" , xend()); + TEST_INSTRUCTION("0F01D0" , xgetbv(edx, eax, ecx)); + TEST_INSTRUCTION("D7" , xlatb()); + TEST_INSTRUCTION("80F101" , xor_(cl, 1)); + TEST_INSTRUCTION("80F501" , xor_(ch, 1)); + TEST_INSTRUCTION("80B4118000000001" , xor_(byte_ptr(rcx, rdx, 0, 128), 1)); + TEST_INSTRUCTION("6683F101" , xor_(cx, 1)); + TEST_INSTRUCTION("6683B4118000000001" , xor_(word_ptr(rcx, rdx, 0, 128), 1)); + TEST_INSTRUCTION("83F101" , xor_(ecx, 1)); + TEST_INSTRUCTION("83B4118000000001" , xor_(dword_ptr(rcx, rdx, 0, 128), 1)); + TEST_INSTRUCTION("4831D1" , xor_(rcx, rdx)); + TEST_INSTRUCTION("4883F101" , xor_(rcx, 1)); + TEST_INSTRUCTION("48319C1180000000" , xor_(ptr(rcx, rdx, 0, 128), rbx)); + TEST_INSTRUCTION("48319C1180000000" , xor_(qword_ptr(rcx, rdx, 0, 128), rbx)); + TEST_INSTRUCTION("4883B4118000000001" , xor_(qword_ptr(rcx, rdx, 0, 128), 1)); + TEST_INSTRUCTION("30D1" , xor_(cl, dl)); + TEST_INSTRUCTION("30F1" , xor_(cl, dh)); + TEST_INSTRUCTION("30D5" , xor_(ch, dl)); + TEST_INSTRUCTION("30F5" , xor_(ch, dh)); + TEST_INSTRUCTION("309C1180000000" , xor_(ptr(rcx, rdx, 0, 128), bl)); + TEST_INSTRUCTION("30BC1180000000" , xor_(ptr(rcx, rdx, 0, 128), bh)); + TEST_INSTRUCTION("309C1180000000" , xor_(byte_ptr(rcx, rdx, 0, 128), bl)); + TEST_INSTRUCTION("30BC1180000000" , xor_(byte_ptr(rcx, rdx, 0, 128), bh)); + TEST_INSTRUCTION("6631D1" , xor_(cx, dx)); + TEST_INSTRUCTION("66319C1180000000" , xor_(ptr(rcx, rdx, 0, 128), bx)); + TEST_INSTRUCTION("66319C1180000000" , xor_(word_ptr(rcx, rdx, 0, 128), bx)); + TEST_INSTRUCTION("31D1" , xor_(ecx, edx)); + TEST_INSTRUCTION("319C1180000000" , xor_(ptr(rcx, rdx, 0, 128), ebx)); + TEST_INSTRUCTION("319C1180000000" , xor_(dword_ptr(rcx, rdx, 0, 128), ebx)); + TEST_INSTRUCTION("328C1A80000000" , xor_(cl, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("328C1A80000000" , xor_(cl, byte_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("32AC1A80000000" , xor_(ch, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("32AC1A80000000" , xor_(ch, byte_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("66338C1A80000000" , xor_(cx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("66338C1A80000000" , xor_(cx, word_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("338C1A80000000" , xor_(ecx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("338C1A80000000" , xor_(ecx, dword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("48338C1A80000000" , xor_(rcx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("48338C1A80000000" , xor_(rcx, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("F20F01E9" , xresldtrk()); + TEST_INSTRUCTION("0FAEAC1180000000" , xrstor(ptr(rcx, rdx, 0, 128), edx, eax)); + TEST_INSTRUCTION("480FAEAC1180000000" , xrstor64(ptr(rcx, rdx, 0, 128), edx, eax)); + TEST_INSTRUCTION("0FC79C1180000000" , xrstors(ptr(rcx, rdx, 0, 128), edx, eax)); + TEST_INSTRUCTION("480FC79C1180000000" , xrstors64(ptr(rcx, rdx, 0, 128), edx, eax)); + TEST_INSTRUCTION("0FAEA41180000000" , xsave(ptr(rcx, rdx, 0, 128), edx, eax)); + TEST_INSTRUCTION("480FAEA41180000000" , xsave64(ptr(rcx, rdx, 0, 128), edx, eax)); + TEST_INSTRUCTION("0FC7A41180000000" , xsavec(ptr(rcx, rdx, 0, 128), edx, eax)); + TEST_INSTRUCTION("480FC7A41180000000" , xsavec64(ptr(rcx, rdx, 0, 128), edx, eax)); + TEST_INSTRUCTION("0FAEB41180000000" , xsaveopt(ptr(rcx, rdx, 0, 128), edx, eax)); + TEST_INSTRUCTION("480FAEB41180000000" , xsaveopt64(ptr(rcx, rdx, 0, 128), edx, eax)); + TEST_INSTRUCTION("0FC7AC1180000000" , xsaves(ptr(rcx, rdx, 0, 128), edx, eax)); + TEST_INSTRUCTION("480FC7AC1180000000" , xsaves64(ptr(rcx, rdx, 0, 128), edx, eax)); + TEST_INSTRUCTION("0F01D1" , xsetbv(edx, eax, ecx)); + TEST_INSTRUCTION("F20F01E8" , xsusldtrk()); + TEST_INSTRUCTION("0F01D6" , xtest()); +} + +static void ASMJIT_NOINLINE testX64AssemblerMMX_SSE(AssemblerTester<x86::Assembler>& tester) noexcept { + using namespace x86; + + TEST_INSTRUCTION("660F58CA" , addpd(xmm1, xmm2)); + TEST_INSTRUCTION("660F588C1A80000000" , addpd(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F588C1A80000000" , addpd(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F58CA" , addps(xmm1, xmm2)); + TEST_INSTRUCTION("0F588C1A80000000" , addps(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F588C1A80000000" , addps(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("F20F58CA" , addsd(xmm1, xmm2)); + TEST_INSTRUCTION("F20F588C1A80000000" , addsd(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("F20F588C1A80000000" , addsd(xmm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("F30F58CA" , addss(xmm1, xmm2)); + TEST_INSTRUCTION("F30F588C1A80000000" , addss(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("F30F588C1A80000000" , addss(xmm1, dword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660FD0CA" , addsubpd(xmm1, xmm2)); + TEST_INSTRUCTION("660FD08C1A80000000" , addsubpd(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660FD08C1A80000000" , addsubpd(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("F20FD0CA" , addsubps(xmm1, xmm2)); + TEST_INSTRUCTION("F20FD08C1A80000000" , addsubps(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("F20FD08C1A80000000" , addsubps(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F38DECA" , aesdec(xmm1, xmm2)); + TEST_INSTRUCTION("660F38DE8C1A80000000" , aesdec(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F38DE8C1A80000000" , aesdec(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F38DFCA" , aesdeclast(xmm1, xmm2)); + TEST_INSTRUCTION("660F38DF8C1A80000000" , aesdeclast(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F38DF8C1A80000000" , aesdeclast(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F38DCCA" , aesenc(xmm1, xmm2)); + TEST_INSTRUCTION("660F38DC8C1A80000000" , aesenc(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F38DC8C1A80000000" , aesenc(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F38DDCA" , aesenclast(xmm1, xmm2)); + TEST_INSTRUCTION("660F38DD8C1A80000000" , aesenclast(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F38DD8C1A80000000" , aesenclast(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F38DBCA" , aesimc(xmm1, xmm2)); + TEST_INSTRUCTION("660F38DB8C1A80000000" , aesimc(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F38DB8C1A80000000" , aesimc(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F3ADFCA01" , aeskeygenassist(xmm1, xmm2, 1)); + TEST_INSTRUCTION("660F3ADF8C1A8000000001" , aeskeygenassist(xmm1, ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("660F3ADF8C1A8000000001" , aeskeygenassist(xmm1, xmmword_ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("660F55CA" , andnpd(xmm1, xmm2)); + TEST_INSTRUCTION("660F558C1A80000000" , andnpd(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F558C1A80000000" , andnpd(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F55CA" , andnps(xmm1, xmm2)); + TEST_INSTRUCTION("0F558C1A80000000" , andnps(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F558C1A80000000" , andnps(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F54CA" , andpd(xmm1, xmm2)); + TEST_INSTRUCTION("660F548C1A80000000" , andpd(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F548C1A80000000" , andpd(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F54CA" , andps(xmm1, xmm2)); + TEST_INSTRUCTION("0F548C1A80000000" , andps(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F548C1A80000000" , andps(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F3A0DCA01" , blendpd(xmm1, xmm2, 1)); + TEST_INSTRUCTION("660F3A0D8C1A8000000001" , blendpd(xmm1, ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("660F3A0D8C1A8000000001" , blendpd(xmm1, xmmword_ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("660F3A0CCA01" , blendps(xmm1, xmm2, 1)); + TEST_INSTRUCTION("660F3A0C8C1A8000000001" , blendps(xmm1, ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("660F3A0C8C1A8000000001" , blendps(xmm1, xmmword_ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("660F3815CA" , blendvpd(xmm1, xmm2, xmm0)); + TEST_INSTRUCTION("660F38158C1A80000000" , blendvpd(xmm1, ptr(rdx, rbx, 0, 128), xmm0)); + TEST_INSTRUCTION("660F38158C1A80000000" , blendvpd(xmm1, xmmword_ptr(rdx, rbx, 0, 128), xmm0)); + TEST_INSTRUCTION("660F3814CA" , blendvps(xmm1, xmm2, xmm0)); + TEST_INSTRUCTION("660F38148C1A80000000" , blendvps(xmm1, ptr(rdx, rbx, 0, 128), xmm0)); + TEST_INSTRUCTION("660F38148C1A80000000" , blendvps(xmm1, xmmword_ptr(rdx, rbx, 0, 128), xmm0)); + TEST_INSTRUCTION("660FC2CA01" , cmppd(xmm1, xmm2, 1)); + TEST_INSTRUCTION("660FC28C1A8000000001" , cmppd(xmm1, ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("660FC28C1A8000000001" , cmppd(xmm1, xmmword_ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("0FC2CA01" , cmpps(xmm1, xmm2, 1)); + TEST_INSTRUCTION("0FC28C1A8000000001" , cmpps(xmm1, ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("0FC28C1A8000000001" , cmpps(xmm1, xmmword_ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("F20FC2CA01" , cmpsd(xmm1, xmm2, 1)); + TEST_INSTRUCTION("F20FC28C1A8000000001" , cmpsd(xmm1, ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("F20FC28C1A8000000001" , cmpsd(xmm1, qword_ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("F30FC2CA01" , cmpss(xmm1, xmm2, 1)); + TEST_INSTRUCTION("F30FC28C1A8000000001" , cmpss(xmm1, ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("F30FC28C1A8000000001" , cmpss(xmm1, dword_ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("660F2FCA" , comisd(xmm1, xmm2)); + TEST_INSTRUCTION("660F2F8C1A80000000" , comisd(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F2F8C1A80000000" , comisd(xmm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F2FCA" , comiss(xmm1, xmm2)); + TEST_INSTRUCTION("0F2F8C1A80000000" , comiss(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F2F8C1A80000000" , comiss(xmm1, dword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("F30FE6CA" , cvtdq2pd(xmm1, xmm2)); + TEST_INSTRUCTION("F30FE68C1A80000000" , cvtdq2pd(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("F30FE68C1A80000000" , cvtdq2pd(xmm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F5BCA" , cvtdq2ps(xmm1, xmm2)); + TEST_INSTRUCTION("0F5B8C1A80000000" , cvtdq2ps(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F5B8C1A80000000" , cvtdq2ps(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("F20FE6CA" , cvtpd2dq(xmm1, xmm2)); + TEST_INSTRUCTION("F20FE68C1A80000000" , cvtpd2dq(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("F20FE68C1A80000000" , cvtpd2dq(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F2DCA" , cvtpd2pi(mm1, xmm2)); + TEST_INSTRUCTION("660F2D8C1A80000000" , cvtpd2pi(mm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F2D8C1A80000000" , cvtpd2pi(mm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F5ACA" , cvtpd2ps(xmm1, xmm2)); + TEST_INSTRUCTION("660F5A8C1A80000000" , cvtpd2ps(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F5A8C1A80000000" , cvtpd2ps(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F2ACA" , cvtpi2pd(xmm1, mm2)); + TEST_INSTRUCTION("660F2A8C1A80000000" , cvtpi2pd(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F2A8C1A80000000" , cvtpi2pd(xmm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F2ACA" , cvtpi2ps(xmm1, mm2)); + TEST_INSTRUCTION("0F2A8C1A80000000" , cvtpi2ps(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F2A8C1A80000000" , cvtpi2ps(xmm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F5BCA" , cvtps2dq(xmm1, xmm2)); + TEST_INSTRUCTION("660F5B8C1A80000000" , cvtps2dq(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F5B8C1A80000000" , cvtps2dq(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F5ACA" , cvtps2pd(xmm1, xmm2)); + TEST_INSTRUCTION("0F5A8C1A80000000" , cvtps2pd(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F5A8C1A80000000" , cvtps2pd(xmm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F2DCA" , cvtps2pi(mm1, xmm2)); + TEST_INSTRUCTION("0F2D8C1A80000000" , cvtps2pi(mm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F2D8C1A80000000" , cvtps2pi(mm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("F20F2DCA" , cvtsd2si(ecx, xmm2)); + TEST_INSTRUCTION("F20F2D8C1A80000000" , cvtsd2si(ecx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("F20F2D8C1A80000000" , cvtsd2si(ecx, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("F2480F2DCA" , cvtsd2si(rcx, xmm2)); + TEST_INSTRUCTION("F2480F2D8C1A80000000" , cvtsd2si(rcx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("F2480F2D8C1A80000000" , cvtsd2si(rcx, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("F20F5ACA" , cvtsd2ss(xmm1, xmm2)); + TEST_INSTRUCTION("F20F5A8C1A80000000" , cvtsd2ss(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("F20F5A8C1A80000000" , cvtsd2ss(xmm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("F20F2ACA" , cvtsi2sd(xmm1, edx)); + TEST_INSTRUCTION("F2480F2ACA" , cvtsi2sd(xmm1, rdx)); + TEST_INSTRUCTION("F20F2A8C1A80000000" , cvtsi2sd(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("F20F2A8C1A80000000" , cvtsi2sd(xmm1, dword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("F2480F2A8C1A80000000" , cvtsi2sd(xmm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("F30F2ACA" , cvtsi2ss(xmm1, edx)); + TEST_INSTRUCTION("F3480F2ACA" , cvtsi2ss(xmm1, rdx)); + TEST_INSTRUCTION("F30F2A8C1A80000000" , cvtsi2ss(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("F30F2A8C1A80000000" , cvtsi2ss(xmm1, dword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("F3480F2A8C1A80000000" , cvtsi2ss(xmm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("F30F5ACA" , cvtss2sd(xmm1, xmm2)); + TEST_INSTRUCTION("F30F5A8C1A80000000" , cvtss2sd(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("F30F5A8C1A80000000" , cvtss2sd(xmm1, dword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("F30F2DCA" , cvtss2si(ecx, xmm2)); + TEST_INSTRUCTION("F30F2D8C1A80000000" , cvtss2si(ecx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("F30F2D8C1A80000000" , cvtss2si(ecx, dword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("F3480F2DCA" , cvtss2si(rcx, xmm2)); + TEST_INSTRUCTION("F3480F2D8C1A80000000" , cvtss2si(rcx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("F3480F2D8C1A80000000" , cvtss2si(rcx, dword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660FE6CA" , cvttpd2dq(xmm1, xmm2)); + TEST_INSTRUCTION("660FE68C1A80000000" , cvttpd2dq(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660FE68C1A80000000" , cvttpd2dq(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F2CCA" , cvttpd2pi(mm1, xmm2)); + TEST_INSTRUCTION("660F2C8C1A80000000" , cvttpd2pi(mm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F2C8C1A80000000" , cvttpd2pi(mm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("F30F5BCA" , cvttps2dq(xmm1, xmm2)); + TEST_INSTRUCTION("F30F5B8C1A80000000" , cvttps2dq(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("F30F5B8C1A80000000" , cvttps2dq(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F2CCA" , cvttps2pi(mm1, xmm2)); + TEST_INSTRUCTION("0F2C8C1A80000000" , cvttps2pi(mm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F2C8C1A80000000" , cvttps2pi(mm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("F20F2CCA" , cvttsd2si(ecx, xmm2)); + TEST_INSTRUCTION("F20F2C8C1A80000000" , cvttsd2si(ecx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("F20F2C8C1A80000000" , cvttsd2si(ecx, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("F2480F2CCA" , cvttsd2si(rcx, xmm2)); + TEST_INSTRUCTION("F2480F2C8C1A80000000" , cvttsd2si(rcx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("F2480F2C8C1A80000000" , cvttsd2si(rcx, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("F30F2CCA" , cvttss2si(ecx, xmm2)); + TEST_INSTRUCTION("F30F2C8C1A80000000" , cvttss2si(ecx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("F30F2C8C1A80000000" , cvttss2si(ecx, dword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("F3480F2CCA" , cvttss2si(rcx, xmm2)); + TEST_INSTRUCTION("F3480F2C8C1A80000000" , cvttss2si(rcx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("F3480F2C8C1A80000000" , cvttss2si(rcx, dword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F5ECA" , divpd(xmm1, xmm2)); + TEST_INSTRUCTION("660F5E8C1A80000000" , divpd(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F5E8C1A80000000" , divpd(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F5ECA" , divps(xmm1, xmm2)); + TEST_INSTRUCTION("0F5E8C1A80000000" , divps(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F5E8C1A80000000" , divps(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("F20F5ECA" , divsd(xmm1, xmm2)); + TEST_INSTRUCTION("F20F5E8C1A80000000" , divsd(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("F20F5E8C1A80000000" , divsd(xmm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("F30F5ECA" , divss(xmm1, xmm2)); + TEST_INSTRUCTION("F30F5E8C1A80000000" , divss(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("F30F5E8C1A80000000" , divss(xmm1, dword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F3A41CA01" , dppd(xmm1, xmm2, 1)); + TEST_INSTRUCTION("660F3A418C1A8000000001" , dppd(xmm1, ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("660F3A418C1A8000000001" , dppd(xmm1, xmmword_ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("660F3A40CA01" , dpps(xmm1, xmm2, 1)); + TEST_INSTRUCTION("660F3A408C1A8000000001" , dpps(xmm1, ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("660F3A408C1A8000000001" , dpps(xmm1, xmmword_ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("0F77" , emms()); + TEST_INSTRUCTION("660F3A17D101" , extractps(ecx, xmm2, 1)); + TEST_INSTRUCTION("660F3A179C118000000001" , extractps(ptr(rcx, rdx, 0, 128), xmm3, 1)); + TEST_INSTRUCTION("660F3A179C118000000001" , extractps(dword_ptr(rcx, rdx, 0, 128), xmm3, 1)); + TEST_INSTRUCTION("660F78C10102" , extrq(xmm1, 1, 2)); + TEST_INSTRUCTION("660F79CA" , extrq(xmm1, xmm2)); + TEST_INSTRUCTION("660F3ACFCA01" , gf2p8affineinvqb(xmm1, xmm2, 1)); + TEST_INSTRUCTION("660F3ACF8C1A8000000001" , gf2p8affineinvqb(xmm1, ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("660F3ACF8C1A8000000001" , gf2p8affineinvqb(xmm1, xmmword_ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("660F3ACECA01" , gf2p8affineqb(xmm1, xmm2, 1)); + TEST_INSTRUCTION("660F3ACE8C1A8000000001" , gf2p8affineqb(xmm1, ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("660F3ACE8C1A8000000001" , gf2p8affineqb(xmm1, xmmword_ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("660F38CFCA" , gf2p8mulb(xmm1, xmm2)); + TEST_INSTRUCTION("660F38CF8C1A80000000" , gf2p8mulb(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F38CF8C1A80000000" , gf2p8mulb(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F7CCA" , haddpd(xmm1, xmm2)); + TEST_INSTRUCTION("660F7C8C1A80000000" , haddpd(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F7C8C1A80000000" , haddpd(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("F20F7CCA" , haddps(xmm1, xmm2)); + TEST_INSTRUCTION("F20F7C8C1A80000000" , haddps(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("F20F7C8C1A80000000" , haddps(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F7DCA" , hsubpd(xmm1, xmm2)); + TEST_INSTRUCTION("660F7D8C1A80000000" , hsubpd(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F7D8C1A80000000" , hsubpd(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("F20F7DCA" , hsubps(xmm1, xmm2)); + TEST_INSTRUCTION("F20F7D8C1A80000000" , hsubps(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("F20F7D8C1A80000000" , hsubps(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F3A21CA01" , insertps(xmm1, xmm2, 1)); + TEST_INSTRUCTION("660F3A218C1A8000000001" , insertps(xmm1, ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("660F3A218C1A8000000001" , insertps(xmm1, dword_ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("F20F79CA" , insertq(xmm1, xmm2)); + TEST_INSTRUCTION("F20F78CA0102" , insertq(xmm1, xmm2, 1, 2)); + TEST_INSTRUCTION("F20FF08C1A80000000" , lddqu(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("F20FF08C1A80000000" , lddqu(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660FF7CA" , maskmovdqu(xmm1, xmm2, ptr(rdi))); + TEST_INSTRUCTION("660FF7CA" , maskmovdqu(xmm1, xmm2, xmmword_ptr(rdi))); + TEST_INSTRUCTION("0FF7CA" , maskmovq(mm1, mm2, ptr(rdi))); + TEST_INSTRUCTION("0FF7CA" , maskmovq(mm1, mm2, qword_ptr(rdi))); + TEST_INSTRUCTION("660F5FCA" , maxpd(xmm1, xmm2)); + TEST_INSTRUCTION("660F5F8C1A80000000" , maxpd(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F5F8C1A80000000" , maxpd(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F5FCA" , maxps(xmm1, xmm2)); + TEST_INSTRUCTION("0F5F8C1A80000000" , maxps(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F5F8C1A80000000" , maxps(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("F20F5FCA" , maxsd(xmm1, xmm2)); + TEST_INSTRUCTION("F20F5F8C1A80000000" , maxsd(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("F20F5F8C1A80000000" , maxsd(xmm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("F30F5FCA" , maxss(xmm1, xmm2)); + TEST_INSTRUCTION("F30F5F8C1A80000000" , maxss(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("F30F5F8C1A80000000" , maxss(xmm1, dword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F5DCA" , minpd(xmm1, xmm2)); + TEST_INSTRUCTION("660F5D8C1A80000000" , minpd(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F5D8C1A80000000" , minpd(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F5DCA" , minps(xmm1, xmm2)); + TEST_INSTRUCTION("0F5D8C1A80000000" , minps(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F5D8C1A80000000" , minps(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("F20F5DCA" , minsd(xmm1, xmm2)); + TEST_INSTRUCTION("F20F5D8C1A80000000" , minsd(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("F20F5D8C1A80000000" , minsd(xmm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("F30F5DCA" , minss(xmm1, xmm2)); + TEST_INSTRUCTION("F30F5D8C1A80000000" , minss(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("F30F5D8C1A80000000" , minss(xmm1, dword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F28CA" , movapd(xmm1, xmm2)); + TEST_INSTRUCTION("660F288C1A80000000" , movapd(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F288C1A80000000" , movapd(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F299C1180000000" , movapd(ptr(rcx, rdx, 0, 128), xmm3)); + TEST_INSTRUCTION("660F299C1180000000" , movapd(xmmword_ptr(rcx, rdx, 0, 128), xmm3)); + TEST_INSTRUCTION("0F28CA" , movaps(xmm1, xmm2)); + TEST_INSTRUCTION("0F288C1A80000000" , movaps(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F288C1A80000000" , movaps(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F299C1180000000" , movaps(ptr(rcx, rdx, 0, 128), xmm3)); + TEST_INSTRUCTION("0F299C1180000000" , movaps(xmmword_ptr(rcx, rdx, 0, 128), xmm3)); + TEST_INSTRUCTION("660F6ECA" , movd(xmm1, edx)); + TEST_INSTRUCTION("660F6E8C1A80000000" , movd(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F6E8C1A80000000" , movd(xmm1, dword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F6ECA" , movd(mm1, edx)); + TEST_INSTRUCTION("0F6E8C1A80000000" , movd(mm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F6E8C1A80000000" , movd(mm1, dword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F7ED1" , movd(ecx, xmm2)); + TEST_INSTRUCTION("0F7ED1" , movd(ecx, mm2)); + TEST_INSTRUCTION("660F7E9C1180000000" , movd(ptr(rcx, rdx, 0, 128), xmm3)); + TEST_INSTRUCTION("0F7E9C1180000000" , movd(ptr(rcx, rdx, 0, 128), mm3)); + TEST_INSTRUCTION("660F7E9C1180000000" , movd(dword_ptr(rcx, rdx, 0, 128), xmm3)); + TEST_INSTRUCTION("0F7E9C1180000000" , movd(dword_ptr(rcx, rdx, 0, 128), mm3)); + TEST_INSTRUCTION("F20F12CA" , movddup(xmm1, xmm2)); + TEST_INSTRUCTION("F20F128C1A80000000" , movddup(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("F20F128C1A80000000" , movddup(xmm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("F20FD6CA" , movdq2q(mm1, xmm2)); + TEST_INSTRUCTION("660F6FCA" , movdqa(xmm1, xmm2)); + TEST_INSTRUCTION("660F6F8C1A80000000" , movdqa(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F6F8C1A80000000" , movdqa(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F7F9C1180000000" , movdqa(ptr(rcx, rdx, 0, 128), xmm3)); + TEST_INSTRUCTION("660F7F9C1180000000" , movdqa(xmmword_ptr(rcx, rdx, 0, 128), xmm3)); + TEST_INSTRUCTION("F30F6FCA" , movdqu(xmm1, xmm2)); + TEST_INSTRUCTION("F30F6F8C1A80000000" , movdqu(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("F30F6F8C1A80000000" , movdqu(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("F30F7F9C1180000000" , movdqu(ptr(rcx, rdx, 0, 128), xmm3)); + TEST_INSTRUCTION("F30F7F9C1180000000" , movdqu(xmmword_ptr(rcx, rdx, 0, 128), xmm3)); + TEST_INSTRUCTION("0F12CA" , movhlps(xmm1, xmm2)); + TEST_INSTRUCTION("660F179C1180000000" , movhpd(ptr(rcx, rdx, 0, 128), xmm3)); + TEST_INSTRUCTION("660F179C1180000000" , movhpd(qword_ptr(rcx, rdx, 0, 128), xmm3)); + TEST_INSTRUCTION("660F168C1A80000000" , movhpd(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F168C1A80000000" , movhpd(xmm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F179C1180000000" , movhps(ptr(rcx, rdx, 0, 128), xmm3)); + TEST_INSTRUCTION("0F179C1180000000" , movhps(qword_ptr(rcx, rdx, 0, 128), xmm3)); + TEST_INSTRUCTION("0F168C1A80000000" , movhps(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F168C1A80000000" , movhps(xmm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F16CA" , movlhps(xmm1, xmm2)); + TEST_INSTRUCTION("660F139C1180000000" , movlpd(ptr(rcx, rdx, 0, 128), xmm3)); + TEST_INSTRUCTION("660F139C1180000000" , movlpd(qword_ptr(rcx, rdx, 0, 128), xmm3)); + TEST_INSTRUCTION("660F128C1A80000000" , movlpd(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F128C1A80000000" , movlpd(xmm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F139C1180000000" , movlps(ptr(rcx, rdx, 0, 128), xmm3)); + TEST_INSTRUCTION("0F139C1180000000" , movlps(qword_ptr(rcx, rdx, 0, 128), xmm3)); + TEST_INSTRUCTION("0F128C1A80000000" , movlps(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F128C1A80000000" , movlps(xmm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F50CA" , movmskpd(ecx, xmm2)); + TEST_INSTRUCTION("0F50CA" , movmskps(ecx, xmm2)); + TEST_INSTRUCTION("660FE79C1180000000" , movntdq(ptr(rcx, rdx, 0, 128), xmm3)); + TEST_INSTRUCTION("660FE79C1180000000" , movntdq(xmmword_ptr(rcx, rdx, 0, 128), xmm3)); + TEST_INSTRUCTION("660F382A8C1A80000000" , movntdqa(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F382A8C1A80000000" , movntdqa(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F2B9C1180000000" , movntpd(ptr(rcx, rdx, 0, 128), xmm3)); + TEST_INSTRUCTION("660F2B9C1180000000" , movntpd(xmmword_ptr(rcx, rdx, 0, 128), xmm3)); + TEST_INSTRUCTION("0F2B9C1180000000" , movntps(ptr(rcx, rdx, 0, 128), xmm3)); + TEST_INSTRUCTION("0F2B9C1180000000" , movntps(xmmword_ptr(rcx, rdx, 0, 128), xmm3)); + TEST_INSTRUCTION("0FE79C1180000000" , movntq(ptr(rcx, rdx, 0, 128), mm3)); + TEST_INSTRUCTION("0FE79C1180000000" , movntq(qword_ptr(rcx, rdx, 0, 128), mm3)); + TEST_INSTRUCTION("F20F2B9C1180000000" , movntsd(ptr(rcx, rdx, 0, 128), xmm3)); + TEST_INSTRUCTION("F20F2B9C1180000000" , movntsd(qword_ptr(rcx, rdx, 0, 128), xmm3)); + TEST_INSTRUCTION("F30F2B9C1180000000" , movntss(ptr(rcx, rdx, 0, 128), xmm3)); + TEST_INSTRUCTION("F30F2B9C1180000000" , movntss(dword_ptr(rcx, rdx, 0, 128), xmm3)); + TEST_INSTRUCTION("480F6ECA" , movq(mm1, rdx)); + TEST_INSTRUCTION("0F6FCA" , movq(mm1, mm2)); + TEST_INSTRUCTION("0F6F8C1A80000000" , movq(mm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F6F8C1A80000000" , movq(mm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("66480F7ED1" , movq(rcx, xmm2)); + TEST_INSTRUCTION("480F7ED1" , movq(rcx, mm2)); + TEST_INSTRUCTION("660FD69C1180000000" , movq(ptr(rcx, rdx, 0, 128), xmm3)); + TEST_INSTRUCTION("0F7F9C1180000000" , movq(ptr(rcx, rdx, 0, 128), mm3)); + TEST_INSTRUCTION("660FD69C1180000000" , movq(qword_ptr(rcx, rdx, 0, 128), xmm3)); + TEST_INSTRUCTION("0F7F9C1180000000" , movq(qword_ptr(rcx, rdx, 0, 128), mm3)); + TEST_INSTRUCTION("66480F6ECA" , movq(xmm1, rdx)); + TEST_INSTRUCTION("F30F7E8C1A80000000" , movq(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("F30F7E8C1A80000000" , movq(xmm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("F30F7ECA" , movq(xmm1, xmm2)); + TEST_INSTRUCTION("F30FD6CA" , movq2dq(xmm1, mm2)); + TEST_INSTRUCTION("F20F10CA" , movsd(xmm1, xmm2)); + TEST_INSTRUCTION("F20F108C1A80000000" , movsd(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("F20F108C1A80000000" , movsd(xmm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("F20F119C1180000000" , movsd(ptr(rcx, rdx, 0, 128), xmm3)); + TEST_INSTRUCTION("F20F119C1180000000" , movsd(qword_ptr(rcx, rdx, 0, 128), xmm3)); + TEST_INSTRUCTION("F30F16CA" , movshdup(xmm1, xmm2)); + TEST_INSTRUCTION("F30F168C1A80000000" , movshdup(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("F30F168C1A80000000" , movshdup(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("F30F12CA" , movsldup(xmm1, xmm2)); + TEST_INSTRUCTION("F30F128C1A80000000" , movsldup(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("F30F128C1A80000000" , movsldup(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("F30F10CA" , movss(xmm1, xmm2)); + TEST_INSTRUCTION("F30F108C1A80000000" , movss(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("F30F108C1A80000000" , movss(xmm1, dword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("F30F119C1180000000" , movss(ptr(rcx, rdx, 0, 128), xmm3)); + TEST_INSTRUCTION("F30F119C1180000000" , movss(dword_ptr(rcx, rdx, 0, 128), xmm3)); + TEST_INSTRUCTION("660F10CA" , movupd(xmm1, xmm2)); + TEST_INSTRUCTION("660F108C1A80000000" , movupd(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F108C1A80000000" , movupd(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F119C1180000000" , movupd(ptr(rcx, rdx, 0, 128), xmm3)); + TEST_INSTRUCTION("660F119C1180000000" , movupd(xmmword_ptr(rcx, rdx, 0, 128), xmm3)); + TEST_INSTRUCTION("0F10CA" , movups(xmm1, xmm2)); + TEST_INSTRUCTION("0F108C1A80000000" , movups(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F108C1A80000000" , movups(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F119C1180000000" , movups(ptr(rcx, rdx, 0, 128), xmm3)); + TEST_INSTRUCTION("0F119C1180000000" , movups(xmmword_ptr(rcx, rdx, 0, 128), xmm3)); + TEST_INSTRUCTION("660F3A42CA01" , mpsadbw(xmm1, xmm2, 1)); + TEST_INSTRUCTION("660F3A428C1A8000000001" , mpsadbw(xmm1, ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("660F3A428C1A8000000001" , mpsadbw(xmm1, xmmword_ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("660F59CA" , mulpd(xmm1, xmm2)); + TEST_INSTRUCTION("660F598C1A80000000" , mulpd(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F598C1A80000000" , mulpd(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F59CA" , mulps(xmm1, xmm2)); + TEST_INSTRUCTION("0F598C1A80000000" , mulps(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F598C1A80000000" , mulps(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("F20F59CA" , mulsd(xmm1, xmm2)); + TEST_INSTRUCTION("F20F598C1A80000000" , mulsd(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("F20F598C1A80000000" , mulsd(xmm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("F30F59CA" , mulss(xmm1, xmm2)); + TEST_INSTRUCTION("F30F598C1A80000000" , mulss(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("F30F598C1A80000000" , mulss(xmm1, dword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F56CA" , orpd(xmm1, xmm2)); + TEST_INSTRUCTION("660F568C1A80000000" , orpd(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F568C1A80000000" , orpd(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F56CA" , orps(xmm1, xmm2)); + TEST_INSTRUCTION("0F568C1A80000000" , orps(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F568C1A80000000" , orps(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F381CCA" , pabsb(mm1, mm2)); + TEST_INSTRUCTION("0F381C8C1A80000000" , pabsb(mm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F381C8C1A80000000" , pabsb(mm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F381CCA" , pabsb(xmm1, xmm2)); + TEST_INSTRUCTION("660F381C8C1A80000000" , pabsb(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F381C8C1A80000000" , pabsb(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F381ECA" , pabsd(mm1, mm2)); + TEST_INSTRUCTION("0F381E8C1A80000000" , pabsd(mm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F381E8C1A80000000" , pabsd(mm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F381ECA" , pabsd(xmm1, xmm2)); + TEST_INSTRUCTION("660F381E8C1A80000000" , pabsd(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F381E8C1A80000000" , pabsd(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F381DCA" , pabsw(mm1, mm2)); + TEST_INSTRUCTION("0F381D8C1A80000000" , pabsw(mm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F381D8C1A80000000" , pabsw(mm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F381DCA" , pabsw(xmm1, xmm2)); + TEST_INSTRUCTION("660F381D8C1A80000000" , pabsw(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F381D8C1A80000000" , pabsw(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F6BCA" , packssdw(mm1, mm2)); + TEST_INSTRUCTION("0F6B8C1A80000000" , packssdw(mm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F6B8C1A80000000" , packssdw(mm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F6BCA" , packssdw(xmm1, xmm2)); + TEST_INSTRUCTION("660F6B8C1A80000000" , packssdw(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F6B8C1A80000000" , packssdw(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F63CA" , packsswb(mm1, mm2)); + TEST_INSTRUCTION("0F638C1A80000000" , packsswb(mm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F638C1A80000000" , packsswb(mm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F63CA" , packsswb(xmm1, xmm2)); + TEST_INSTRUCTION("660F638C1A80000000" , packsswb(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F638C1A80000000" , packsswb(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F382BCA" , packusdw(xmm1, xmm2)); + TEST_INSTRUCTION("660F382B8C1A80000000" , packusdw(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F382B8C1A80000000" , packusdw(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F67CA" , packuswb(mm1, mm2)); + TEST_INSTRUCTION("0F678C1A80000000" , packuswb(mm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F678C1A80000000" , packuswb(mm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F67CA" , packuswb(xmm1, xmm2)); + TEST_INSTRUCTION("660F678C1A80000000" , packuswb(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F678C1A80000000" , packuswb(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0FFCCA" , paddb(mm1, mm2)); + TEST_INSTRUCTION("0FFC8C1A80000000" , paddb(mm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0FFC8C1A80000000" , paddb(mm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660FFCCA" , paddb(xmm1, xmm2)); + TEST_INSTRUCTION("660FFC8C1A80000000" , paddb(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660FFC8C1A80000000" , paddb(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0FFECA" , paddd(mm1, mm2)); + TEST_INSTRUCTION("0FFE8C1A80000000" , paddd(mm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0FFE8C1A80000000" , paddd(mm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660FFECA" , paddd(xmm1, xmm2)); + TEST_INSTRUCTION("660FFE8C1A80000000" , paddd(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660FFE8C1A80000000" , paddd(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0FD4CA" , paddq(mm1, mm2)); + TEST_INSTRUCTION("0FD48C1A80000000" , paddq(mm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0FD48C1A80000000" , paddq(mm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660FD4CA" , paddq(xmm1, xmm2)); + TEST_INSTRUCTION("660FD48C1A80000000" , paddq(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660FD48C1A80000000" , paddq(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0FECCA" , paddsb(mm1, mm2)); + TEST_INSTRUCTION("0FEC8C1A80000000" , paddsb(mm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0FEC8C1A80000000" , paddsb(mm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660FECCA" , paddsb(xmm1, xmm2)); + TEST_INSTRUCTION("660FEC8C1A80000000" , paddsb(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660FEC8C1A80000000" , paddsb(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0FEDCA" , paddsw(mm1, mm2)); + TEST_INSTRUCTION("0FED8C1A80000000" , paddsw(mm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0FED8C1A80000000" , paddsw(mm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660FEDCA" , paddsw(xmm1, xmm2)); + TEST_INSTRUCTION("660FED8C1A80000000" , paddsw(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660FED8C1A80000000" , paddsw(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0FDCCA" , paddusb(mm1, mm2)); + TEST_INSTRUCTION("0FDC8C1A80000000" , paddusb(mm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0FDC8C1A80000000" , paddusb(mm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660FDCCA" , paddusb(xmm1, xmm2)); + TEST_INSTRUCTION("660FDC8C1A80000000" , paddusb(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660FDC8C1A80000000" , paddusb(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0FDDCA" , paddusw(mm1, mm2)); + TEST_INSTRUCTION("0FDD8C1A80000000" , paddusw(mm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0FDD8C1A80000000" , paddusw(mm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660FDDCA" , paddusw(xmm1, xmm2)); + TEST_INSTRUCTION("660FDD8C1A80000000" , paddusw(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660FDD8C1A80000000" , paddusw(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0FFDCA" , paddw(mm1, mm2)); + TEST_INSTRUCTION("0FFD8C1A80000000" , paddw(mm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0FFD8C1A80000000" , paddw(mm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660FFDCA" , paddw(xmm1, xmm2)); + TEST_INSTRUCTION("660FFD8C1A80000000" , paddw(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660FFD8C1A80000000" , paddw(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F3A0FCA01" , palignr(mm1, mm2, 1)); + TEST_INSTRUCTION("0F3A0F8C1A8000000001" , palignr(mm1, ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("0F3A0F8C1A8000000001" , palignr(mm1, qword_ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("660F3A0FCA01" , palignr(xmm1, xmm2, 1)); + TEST_INSTRUCTION("660F3A0F8C1A8000000001" , palignr(xmm1, ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("660F3A0F8C1A8000000001" , palignr(xmm1, xmmword_ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("0FDBCA" , pand(mm1, mm2)); + TEST_INSTRUCTION("0FDB8C1A80000000" , pand(mm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0FDB8C1A80000000" , pand(mm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660FDBCA" , pand(xmm1, xmm2)); + TEST_INSTRUCTION("660FDB8C1A80000000" , pand(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660FDB8C1A80000000" , pand(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0FDFCA" , pandn(mm1, mm2)); + TEST_INSTRUCTION("0FDF8C1A80000000" , pandn(mm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0FDF8C1A80000000" , pandn(mm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660FDFCA" , pandn(xmm1, xmm2)); + TEST_INSTRUCTION("660FDF8C1A80000000" , pandn(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660FDF8C1A80000000" , pandn(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0FE0CA" , pavgb(mm1, mm2)); + TEST_INSTRUCTION("0FE08C1A80000000" , pavgb(mm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0FE08C1A80000000" , pavgb(mm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660FE0CA" , pavgb(xmm1, xmm2)); + TEST_INSTRUCTION("660FE08C1A80000000" , pavgb(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660FE08C1A80000000" , pavgb(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F0FCABF" , pavgusb(mm1, mm2)); + TEST_INSTRUCTION("0F0F8C1A80000000BF" , pavgusb(mm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F0F8C1A80000000BF" , pavgusb(mm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0FE3CA" , pavgw(mm1, mm2)); + TEST_INSTRUCTION("0FE38C1A80000000" , pavgw(mm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0FE38C1A80000000" , pavgw(mm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660FE3CA" , pavgw(xmm1, xmm2)); + TEST_INSTRUCTION("660FE38C1A80000000" , pavgw(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660FE38C1A80000000" , pavgw(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F3810CA" , pblendvb(xmm1, xmm2, xmm0)); + TEST_INSTRUCTION("660F38108C1A80000000" , pblendvb(xmm1, ptr(rdx, rbx, 0, 128), xmm0)); + TEST_INSTRUCTION("660F38108C1A80000000" , pblendvb(xmm1, xmmword_ptr(rdx, rbx, 0, 128), xmm0)); + TEST_INSTRUCTION("660F3A0ECA01" , pblendw(xmm1, xmm2, 1)); + TEST_INSTRUCTION("660F3A0E8C1A8000000001" , pblendw(xmm1, ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("660F3A0E8C1A8000000001" , pblendw(xmm1, xmmword_ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("660F3A44CA01" , pclmulqdq(xmm1, xmm2, 1)); + TEST_INSTRUCTION("660F3A448C1A8000000001" , pclmulqdq(xmm1, ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("660F3A448C1A8000000001" , pclmulqdq(xmm1, xmmword_ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("0F74CA" , pcmpeqb(mm1, mm2)); + TEST_INSTRUCTION("0F748C1A80000000" , pcmpeqb(mm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F748C1A80000000" , pcmpeqb(mm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F74CA" , pcmpeqb(xmm1, xmm2)); + TEST_INSTRUCTION("660F748C1A80000000" , pcmpeqb(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F748C1A80000000" , pcmpeqb(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F76CA" , pcmpeqd(mm1, mm2)); + TEST_INSTRUCTION("0F768C1A80000000" , pcmpeqd(mm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F768C1A80000000" , pcmpeqd(mm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F76CA" , pcmpeqd(xmm1, xmm2)); + TEST_INSTRUCTION("660F768C1A80000000" , pcmpeqd(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F768C1A80000000" , pcmpeqd(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F3829CA" , pcmpeqq(xmm1, xmm2)); + TEST_INSTRUCTION("660F38298C1A80000000" , pcmpeqq(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F38298C1A80000000" , pcmpeqq(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F75CA" , pcmpeqw(mm1, mm2)); + TEST_INSTRUCTION("0F758C1A80000000" , pcmpeqw(mm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F758C1A80000000" , pcmpeqw(mm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F75CA" , pcmpeqw(xmm1, xmm2)); + TEST_INSTRUCTION("660F758C1A80000000" , pcmpeqw(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F758C1A80000000" , pcmpeqw(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F3A61CA01" , pcmpestri(xmm1, xmm2, 1, ecx, eax, edx)); + TEST_INSTRUCTION("660F3A618C1A8000000001" , pcmpestri(xmm1, ptr(rdx, rbx, 0, 128), 1, ecx, eax, edx)); + TEST_INSTRUCTION("660F3A618C1A8000000001" , pcmpestri(xmm1, xmmword_ptr(rdx, rbx, 0, 128), 1, ecx, eax, edx)); + TEST_INSTRUCTION("660F3A60CA01" , pcmpestrm(xmm1, xmm2, 1, xmm0, eax, edx)); + TEST_INSTRUCTION("660F3A608C1A8000000001" , pcmpestrm(xmm1, ptr(rdx, rbx, 0, 128), 1, xmm0, eax, edx)); + TEST_INSTRUCTION("660F3A608C1A8000000001" , pcmpestrm(xmm1, xmmword_ptr(rdx, rbx, 0, 128), 1, xmm0, eax, edx)); + TEST_INSTRUCTION("0F64CA" , pcmpgtb(mm1, mm2)); + TEST_INSTRUCTION("0F648C1A80000000" , pcmpgtb(mm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F648C1A80000000" , pcmpgtb(mm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F64CA" , pcmpgtb(xmm1, xmm2)); + TEST_INSTRUCTION("660F648C1A80000000" , pcmpgtb(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F648C1A80000000" , pcmpgtb(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F66CA" , pcmpgtd(mm1, mm2)); + TEST_INSTRUCTION("0F668C1A80000000" , pcmpgtd(mm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F668C1A80000000" , pcmpgtd(mm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F66CA" , pcmpgtd(xmm1, xmm2)); + TEST_INSTRUCTION("660F668C1A80000000" , pcmpgtd(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F668C1A80000000" , pcmpgtd(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F3837CA" , pcmpgtq(xmm1, xmm2)); + TEST_INSTRUCTION("660F38378C1A80000000" , pcmpgtq(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F38378C1A80000000" , pcmpgtq(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F65CA" , pcmpgtw(mm1, mm2)); + TEST_INSTRUCTION("0F658C1A80000000" , pcmpgtw(mm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F658C1A80000000" , pcmpgtw(mm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F65CA" , pcmpgtw(xmm1, xmm2)); + TEST_INSTRUCTION("660F658C1A80000000" , pcmpgtw(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F658C1A80000000" , pcmpgtw(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F3A63CA01" , pcmpistri(xmm1, xmm2, 1, ecx)); + TEST_INSTRUCTION("660F3A638C1A8000000001" , pcmpistri(xmm1, ptr(rdx, rbx, 0, 128), 1, ecx)); + TEST_INSTRUCTION("660F3A638C1A8000000001" , pcmpistri(xmm1, xmmword_ptr(rdx, rbx, 0, 128), 1, ecx)); + TEST_INSTRUCTION("660F3A62CA01" , pcmpistrm(xmm1, xmm2, 1, xmm0)); + TEST_INSTRUCTION("660F3A628C1A8000000001" , pcmpistrm(xmm1, ptr(rdx, rbx, 0, 128), 1, xmm0)); + TEST_INSTRUCTION("660F3A628C1A8000000001" , pcmpistrm(xmm1, xmmword_ptr(rdx, rbx, 0, 128), 1, xmm0)); + TEST_INSTRUCTION("660F3A14D101" , pextrb(ecx, xmm2, 1)); + TEST_INSTRUCTION("660F3A149C118000000001" , pextrb(ptr(rcx, rdx, 0, 128), xmm3, 1)); + TEST_INSTRUCTION("660F3A149C118000000001" , pextrb(byte_ptr(rcx, rdx, 0, 128), xmm3, 1)); + TEST_INSTRUCTION("660F3A16D101" , pextrd(ecx, xmm2, 1)); + TEST_INSTRUCTION("660F3A169C118000000001" , pextrd(ptr(rcx, rdx, 0, 128), xmm3, 1)); + TEST_INSTRUCTION("660F3A169C118000000001" , pextrd(dword_ptr(rcx, rdx, 0, 128), xmm3, 1)); + TEST_INSTRUCTION("66480F3A16D101" , pextrq(rcx, xmm2, 1)); + TEST_INSTRUCTION("66480F3A169C118000000001" , pextrq(ptr(rcx, rdx, 0, 128), xmm3, 1)); + TEST_INSTRUCTION("66480F3A169C118000000001" , pextrq(qword_ptr(rcx, rdx, 0, 128), xmm3, 1)); + TEST_INSTRUCTION("660FC5CA01" , pextrw(ecx, xmm2, 1)); + TEST_INSTRUCTION("0FC5CA01" , pextrw(ecx, mm2, 1)); + TEST_INSTRUCTION("660F3A159C118000000001" , pextrw(ptr(rcx, rdx, 0, 128), xmm3, 1)); + TEST_INSTRUCTION("660F3A159C118000000001" , pextrw(word_ptr(rcx, rdx, 0, 128), xmm3, 1)); + TEST_INSTRUCTION("0F0FCA1D" , pf2id(mm1, mm2)); + TEST_INSTRUCTION("0F0F8C1A800000001D" , pf2id(mm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F0F8C1A800000001D" , pf2id(mm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F0FCA1C" , pf2iw(mm1, mm2)); + TEST_INSTRUCTION("0F0F8C1A800000001C" , pf2iw(mm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F0F8C1A800000001C" , pf2iw(mm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F0FCAAE" , pfacc(mm1, mm2)); + TEST_INSTRUCTION("0F0F8C1A80000000AE" , pfacc(mm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F0F8C1A80000000AE" , pfacc(mm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F0FCA9E" , pfadd(mm1, mm2)); + TEST_INSTRUCTION("0F0F8C1A800000009E" , pfadd(mm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F0F8C1A800000009E" , pfadd(mm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F0FCAB0" , pfcmpeq(mm1, mm2)); + TEST_INSTRUCTION("0F0F8C1A80000000B0" , pfcmpeq(mm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F0F8C1A80000000B0" , pfcmpeq(mm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F0FCA90" , pfcmpge(mm1, mm2)); + TEST_INSTRUCTION("0F0F8C1A8000000090" , pfcmpge(mm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F0F8C1A8000000090" , pfcmpge(mm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F0FCAA0" , pfcmpgt(mm1, mm2)); + TEST_INSTRUCTION("0F0F8C1A80000000A0" , pfcmpgt(mm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F0F8C1A80000000A0" , pfcmpgt(mm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F0FCAA4" , pfmax(mm1, mm2)); + TEST_INSTRUCTION("0F0F8C1A80000000A4" , pfmax(mm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F0F8C1A80000000A4" , pfmax(mm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F0FCA94" , pfmin(mm1, mm2)); + TEST_INSTRUCTION("0F0F8C1A8000000094" , pfmin(mm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F0F8C1A8000000094" , pfmin(mm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F0FCAB4" , pfmul(mm1, mm2)); + TEST_INSTRUCTION("0F0F8C1A80000000B4" , pfmul(mm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F0F8C1A80000000B4" , pfmul(mm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F0FCA8A" , pfnacc(mm1, mm2)); + TEST_INSTRUCTION("0F0F8C1A800000008A" , pfnacc(mm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F0F8C1A800000008A" , pfnacc(mm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F0FCA8E" , pfpnacc(mm1, mm2)); + TEST_INSTRUCTION("0F0F8C1A800000008E" , pfpnacc(mm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F0F8C1A800000008E" , pfpnacc(mm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F0FCA96" , pfrcp(mm1, mm2)); + TEST_INSTRUCTION("0F0F8C1A8000000096" , pfrcp(mm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F0F8C1A8000000096" , pfrcp(mm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F0FCAA6" , pfrcpit1(mm1, mm2)); + TEST_INSTRUCTION("0F0F8C1A80000000A6" , pfrcpit1(mm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F0F8C1A80000000A6" , pfrcpit1(mm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F0FCAB6" , pfrcpit2(mm1, mm2)); + TEST_INSTRUCTION("0F0F8C1A80000000B6" , pfrcpit2(mm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F0F8C1A80000000B6" , pfrcpit2(mm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F0FCA86" , pfrcpv(mm1, mm2)); + TEST_INSTRUCTION("0F0F8C1A8000000086" , pfrcpv(mm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F0F8C1A8000000086" , pfrcpv(mm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F0FCAA7" , pfrsqit1(mm1, mm2)); + TEST_INSTRUCTION("0F0F8C1A80000000A7" , pfrsqit1(mm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F0F8C1A80000000A7" , pfrsqit1(mm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F0FCA97" , pfrsqrt(mm1, mm2)); + TEST_INSTRUCTION("0F0F8C1A8000000097" , pfrsqrt(mm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F0F8C1A8000000097" , pfrsqrt(mm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F0FCA87" , pfrsqrtv(mm1, mm2)); + TEST_INSTRUCTION("0F0F8C1A8000000087" , pfrsqrtv(mm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F0F8C1A8000000087" , pfrsqrtv(mm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F0FCA9A" , pfsub(mm1, mm2)); + TEST_INSTRUCTION("0F0F8C1A800000009A" , pfsub(mm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F0F8C1A800000009A" , pfsub(mm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F0FCAAA" , pfsubr(mm1, mm2)); + TEST_INSTRUCTION("0F0F8C1A80000000AA" , pfsubr(mm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F0F8C1A80000000AA" , pfsubr(mm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F3802CA" , phaddd(mm1, mm2)); + TEST_INSTRUCTION("0F38028C1A80000000" , phaddd(mm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F38028C1A80000000" , phaddd(mm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F3802CA" , phaddd(xmm1, xmm2)); + TEST_INSTRUCTION("660F38028C1A80000000" , phaddd(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F38028C1A80000000" , phaddd(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F3803CA" , phaddsw(mm1, mm2)); + TEST_INSTRUCTION("0F38038C1A80000000" , phaddsw(mm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F38038C1A80000000" , phaddsw(mm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F3803CA" , phaddsw(xmm1, xmm2)); + TEST_INSTRUCTION("660F38038C1A80000000" , phaddsw(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F38038C1A80000000" , phaddsw(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F3801CA" , phaddw(mm1, mm2)); + TEST_INSTRUCTION("0F38018C1A80000000" , phaddw(mm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F38018C1A80000000" , phaddw(mm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F3801CA" , phaddw(xmm1, xmm2)); + TEST_INSTRUCTION("660F38018C1A80000000" , phaddw(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F38018C1A80000000" , phaddw(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F3841CA" , phminposuw(xmm1, xmm2)); + TEST_INSTRUCTION("660F38418C1A80000000" , phminposuw(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F38418C1A80000000" , phminposuw(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F3806CA" , phsubd(mm1, mm2)); + TEST_INSTRUCTION("0F38068C1A80000000" , phsubd(mm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F38068C1A80000000" , phsubd(mm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F3806CA" , phsubd(xmm1, xmm2)); + TEST_INSTRUCTION("660F38068C1A80000000" , phsubd(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F38068C1A80000000" , phsubd(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F3807CA" , phsubsw(mm1, mm2)); + TEST_INSTRUCTION("0F38078C1A80000000" , phsubsw(mm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F38078C1A80000000" , phsubsw(mm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F3807CA" , phsubsw(xmm1, xmm2)); + TEST_INSTRUCTION("660F38078C1A80000000" , phsubsw(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F38078C1A80000000" , phsubsw(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F3805CA" , phsubw(mm1, mm2)); + TEST_INSTRUCTION("0F38058C1A80000000" , phsubw(mm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F38058C1A80000000" , phsubw(mm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F3805CA" , phsubw(xmm1, xmm2)); + TEST_INSTRUCTION("660F38058C1A80000000" , phsubw(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F38058C1A80000000" , phsubw(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F0FCA0D" , pi2fd(mm1, mm2)); + TEST_INSTRUCTION("0F0F8C1A800000000D" , pi2fd(mm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F0F8C1A800000000D" , pi2fd(mm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F0FCA0C" , pi2fw(mm1, mm2)); + TEST_INSTRUCTION("0F0F8C1A800000000C" , pi2fw(mm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F0F8C1A800000000C" , pi2fw(mm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F3A20CA01" , pinsrb(xmm1, edx, 1)); + TEST_INSTRUCTION("660F3A208C1A8000000001" , pinsrb(xmm1, ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("660F3A208C1A8000000001" , pinsrb(xmm1, byte_ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("660F3A22CA01" , pinsrd(xmm1, edx, 1)); + TEST_INSTRUCTION("660F3A228C1A8000000001" , pinsrd(xmm1, ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("660F3A228C1A8000000001" , pinsrd(xmm1, dword_ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("66480F3A22CA01" , pinsrq(xmm1, rdx, 1)); + TEST_INSTRUCTION("66480F3A228C1A8000000001" , pinsrq(xmm1, ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("66480F3A228C1A8000000001" , pinsrq(xmm1, qword_ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("660FC4CA01" , pinsrw(xmm1, edx, 1)); + TEST_INSTRUCTION("660FC48C1A8000000001" , pinsrw(xmm1, ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("660FC48C1A8000000001" , pinsrw(xmm1, word_ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("0FC4CA01" , pinsrw(mm1, edx, 1)); + TEST_INSTRUCTION("0FC48C1A8000000001" , pinsrw(mm1, ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("0FC48C1A8000000001" , pinsrw(mm1, word_ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("0F3804CA" , pmaddubsw(mm1, mm2)); + TEST_INSTRUCTION("0F38048C1A80000000" , pmaddubsw(mm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F38048C1A80000000" , pmaddubsw(mm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F3804CA" , pmaddubsw(xmm1, xmm2)); + TEST_INSTRUCTION("660F38048C1A80000000" , pmaddubsw(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F38048C1A80000000" , pmaddubsw(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0FF5CA" , pmaddwd(mm1, mm2)); + TEST_INSTRUCTION("0FF58C1A80000000" , pmaddwd(mm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0FF58C1A80000000" , pmaddwd(mm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660FF5CA" , pmaddwd(xmm1, xmm2)); + TEST_INSTRUCTION("660FF58C1A80000000" , pmaddwd(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660FF58C1A80000000" , pmaddwd(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F383CCA" , pmaxsb(xmm1, xmm2)); + TEST_INSTRUCTION("660F383C8C1A80000000" , pmaxsb(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F383C8C1A80000000" , pmaxsb(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F383DCA" , pmaxsd(xmm1, xmm2)); + TEST_INSTRUCTION("660F383D8C1A80000000" , pmaxsd(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F383D8C1A80000000" , pmaxsd(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0FEECA" , pmaxsw(mm1, mm2)); + TEST_INSTRUCTION("0FEE8C1A80000000" , pmaxsw(mm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0FEE8C1A80000000" , pmaxsw(mm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660FEECA" , pmaxsw(xmm1, xmm2)); + TEST_INSTRUCTION("660FEE8C1A80000000" , pmaxsw(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660FEE8C1A80000000" , pmaxsw(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0FDECA" , pmaxub(mm1, mm2)); + TEST_INSTRUCTION("0FDE8C1A80000000" , pmaxub(mm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0FDE8C1A80000000" , pmaxub(mm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660FDECA" , pmaxub(xmm1, xmm2)); + TEST_INSTRUCTION("660FDE8C1A80000000" , pmaxub(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660FDE8C1A80000000" , pmaxub(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F383FCA" , pmaxud(xmm1, xmm2)); + TEST_INSTRUCTION("660F383F8C1A80000000" , pmaxud(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F383F8C1A80000000" , pmaxud(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F383ECA" , pmaxuw(xmm1, xmm2)); + TEST_INSTRUCTION("660F383E8C1A80000000" , pmaxuw(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F383E8C1A80000000" , pmaxuw(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F3838CA" , pminsb(xmm1, xmm2)); + TEST_INSTRUCTION("660F38388C1A80000000" , pminsb(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F38388C1A80000000" , pminsb(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F3839CA" , pminsd(xmm1, xmm2)); + TEST_INSTRUCTION("660F38398C1A80000000" , pminsd(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F38398C1A80000000" , pminsd(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0FEACA" , pminsw(mm1, mm2)); + TEST_INSTRUCTION("0FEA8C1A80000000" , pminsw(mm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0FEA8C1A80000000" , pminsw(mm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660FEACA" , pminsw(xmm1, xmm2)); + TEST_INSTRUCTION("660FEA8C1A80000000" , pminsw(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660FEA8C1A80000000" , pminsw(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0FDACA" , pminub(mm1, mm2)); + TEST_INSTRUCTION("0FDA8C1A80000000" , pminub(mm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0FDA8C1A80000000" , pminub(mm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660FDACA" , pminub(xmm1, xmm2)); + TEST_INSTRUCTION("660FDA8C1A80000000" , pminub(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660FDA8C1A80000000" , pminub(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F383BCA" , pminud(xmm1, xmm2)); + TEST_INSTRUCTION("660F383B8C1A80000000" , pminud(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F383B8C1A80000000" , pminud(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F383ACA" , pminuw(xmm1, xmm2)); + TEST_INSTRUCTION("660F383A8C1A80000000" , pminuw(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F383A8C1A80000000" , pminuw(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660FD7CA" , pmovmskb(ecx, xmm2)); + TEST_INSTRUCTION("0FD7CA" , pmovmskb(ecx, mm2)); + TEST_INSTRUCTION("660F3821CA" , pmovsxbd(xmm1, xmm2)); + TEST_INSTRUCTION("660F38218C1A80000000" , pmovsxbd(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F38218C1A80000000" , pmovsxbd(xmm1, dword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F3822CA" , pmovsxbq(xmm1, xmm2)); + TEST_INSTRUCTION("660F38228C1A80000000" , pmovsxbq(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F38228C1A80000000" , pmovsxbq(xmm1, word_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F3820CA" , pmovsxbw(xmm1, xmm2)); + TEST_INSTRUCTION("660F38208C1A80000000" , pmovsxbw(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F38208C1A80000000" , pmovsxbw(xmm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F3825CA" , pmovsxdq(xmm1, xmm2)); + TEST_INSTRUCTION("660F38258C1A80000000" , pmovsxdq(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F38258C1A80000000" , pmovsxdq(xmm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F3823CA" , pmovsxwd(xmm1, xmm2)); + TEST_INSTRUCTION("660F38238C1A80000000" , pmovsxwd(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F38238C1A80000000" , pmovsxwd(xmm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F3824CA" , pmovsxwq(xmm1, xmm2)); + TEST_INSTRUCTION("660F38248C1A80000000" , pmovsxwq(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F38248C1A80000000" , pmovsxwq(xmm1, dword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F3831CA" , pmovzxbd(xmm1, xmm2)); + TEST_INSTRUCTION("660F38318C1A80000000" , pmovzxbd(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F38318C1A80000000" , pmovzxbd(xmm1, dword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F3832CA" , pmovzxbq(xmm1, xmm2)); + TEST_INSTRUCTION("660F38328C1A80000000" , pmovzxbq(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F38328C1A80000000" , pmovzxbq(xmm1, word_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F3830CA" , pmovzxbw(xmm1, xmm2)); + TEST_INSTRUCTION("660F38308C1A80000000" , pmovzxbw(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F38308C1A80000000" , pmovzxbw(xmm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F3835CA" , pmovzxdq(xmm1, xmm2)); + TEST_INSTRUCTION("660F38358C1A80000000" , pmovzxdq(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F38358C1A80000000" , pmovzxdq(xmm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F3833CA" , pmovzxwd(xmm1, xmm2)); + TEST_INSTRUCTION("660F38338C1A80000000" , pmovzxwd(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F38338C1A80000000" , pmovzxwd(xmm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F3834CA" , pmovzxwq(xmm1, xmm2)); + TEST_INSTRUCTION("660F38348C1A80000000" , pmovzxwq(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F38348C1A80000000" , pmovzxwq(xmm1, dword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F3828CA" , pmuldq(xmm1, xmm2)); + TEST_INSTRUCTION("660F38288C1A80000000" , pmuldq(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F38288C1A80000000" , pmuldq(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F380BCA" , pmulhrsw(mm1, mm2)); + TEST_INSTRUCTION("0F380B8C1A80000000" , pmulhrsw(mm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F380B8C1A80000000" , pmulhrsw(mm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F380BCA" , pmulhrsw(xmm1, xmm2)); + TEST_INSTRUCTION("660F380B8C1A80000000" , pmulhrsw(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F380B8C1A80000000" , pmulhrsw(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F0FCAB7" , pmulhrw(mm1, mm2)); + TEST_INSTRUCTION("0F0F8C1A80000000B7" , pmulhrw(mm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F0F8C1A80000000B7" , pmulhrw(mm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0FE4CA" , pmulhuw(mm1, mm2)); + TEST_INSTRUCTION("0FE48C1A80000000" , pmulhuw(mm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0FE48C1A80000000" , pmulhuw(mm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660FE4CA" , pmulhuw(xmm1, xmm2)); + TEST_INSTRUCTION("660FE48C1A80000000" , pmulhuw(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660FE48C1A80000000" , pmulhuw(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0FE5CA" , pmulhw(mm1, mm2)); + TEST_INSTRUCTION("0FE58C1A80000000" , pmulhw(mm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0FE58C1A80000000" , pmulhw(mm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660FE5CA" , pmulhw(xmm1, xmm2)); + TEST_INSTRUCTION("660FE58C1A80000000" , pmulhw(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660FE58C1A80000000" , pmulhw(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F3840CA" , pmulld(xmm1, xmm2)); + TEST_INSTRUCTION("660F38408C1A80000000" , pmulld(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F38408C1A80000000" , pmulld(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0FD5CA" , pmullw(mm1, mm2)); + TEST_INSTRUCTION("0FD58C1A80000000" , pmullw(mm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0FD58C1A80000000" , pmullw(mm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660FD5CA" , pmullw(xmm1, xmm2)); + TEST_INSTRUCTION("660FD58C1A80000000" , pmullw(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660FD58C1A80000000" , pmullw(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0FF4CA" , pmuludq(mm1, mm2)); + TEST_INSTRUCTION("0FF48C1A80000000" , pmuludq(mm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0FF48C1A80000000" , pmuludq(mm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660FF4CA" , pmuludq(xmm1, xmm2)); + TEST_INSTRUCTION("660FF48C1A80000000" , pmuludq(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660FF48C1A80000000" , pmuludq(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0FEBCA" , por(mm1, mm2)); + TEST_INSTRUCTION("0FEB8C1A80000000" , por(mm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0FEB8C1A80000000" , por(mm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660FEBCA" , por(xmm1, xmm2)); + TEST_INSTRUCTION("660FEB8C1A80000000" , por(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660FEB8C1A80000000" , por(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0FF6CA" , psadbw(mm1, mm2)); + TEST_INSTRUCTION("0FF68C1A80000000" , psadbw(mm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0FF68C1A80000000" , psadbw(mm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660FF6CA" , psadbw(xmm1, xmm2)); + TEST_INSTRUCTION("660FF68C1A80000000" , psadbw(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660FF68C1A80000000" , psadbw(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F3800CA" , pshufb(mm1, mm2)); + TEST_INSTRUCTION("0F38008C1A80000000" , pshufb(mm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F38008C1A80000000" , pshufb(mm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F3800CA" , pshufb(xmm1, xmm2)); + TEST_INSTRUCTION("660F38008C1A80000000" , pshufb(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F38008C1A80000000" , pshufb(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F70CA01" , pshufd(xmm1, xmm2, 1)); + TEST_INSTRUCTION("660F708C1A8000000001" , pshufd(xmm1, ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("660F708C1A8000000001" , pshufd(xmm1, xmmword_ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("F30F70CA01" , pshufhw(xmm1, xmm2, 1)); + TEST_INSTRUCTION("F30F708C1A8000000001" , pshufhw(xmm1, ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("F30F708C1A8000000001" , pshufhw(xmm1, xmmword_ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("F20F70CA01" , pshuflw(xmm1, xmm2, 1)); + TEST_INSTRUCTION("F20F708C1A8000000001" , pshuflw(xmm1, ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("F20F708C1A8000000001" , pshuflw(xmm1, xmmword_ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("0F70CA01" , pshufw(mm1, mm2, 1)); + TEST_INSTRUCTION("0F708C1A8000000001" , pshufw(mm1, ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("0F708C1A8000000001" , pshufw(mm1, qword_ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("0F3808CA" , psignb(mm1, mm2)); + TEST_INSTRUCTION("0F38088C1A80000000" , psignb(mm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F38088C1A80000000" , psignb(mm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F3808CA" , psignb(xmm1, xmm2)); + TEST_INSTRUCTION("660F38088C1A80000000" , psignb(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F38088C1A80000000" , psignb(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F380ACA" , psignd(mm1, mm2)); + TEST_INSTRUCTION("0F380A8C1A80000000" , psignd(mm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F380A8C1A80000000" , psignd(mm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F380ACA" , psignd(xmm1, xmm2)); + TEST_INSTRUCTION("660F380A8C1A80000000" , psignd(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F380A8C1A80000000" , psignd(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F3809CA" , psignw(mm1, mm2)); + TEST_INSTRUCTION("0F38098C1A80000000" , psignw(mm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F38098C1A80000000" , psignw(mm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F3809CA" , psignw(xmm1, xmm2)); + TEST_INSTRUCTION("660F38098C1A80000000" , psignw(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F38098C1A80000000" , psignw(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0FF2CA" , pslld(mm1, mm2)); + TEST_INSTRUCTION("0F72F101" , pslld(mm1, 1)); + TEST_INSTRUCTION("0FF28C1A80000000" , pslld(mm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0FF28C1A80000000" , pslld(mm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660FF2CA" , pslld(xmm1, xmm2)); + TEST_INSTRUCTION("660F72F101" , pslld(xmm1, 1)); + TEST_INSTRUCTION("660FF28C1A80000000" , pslld(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660FF28C1A80000000" , pslld(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F73F901" , pslldq(xmm1, 1)); + TEST_INSTRUCTION("0FF3CA" , psllq(mm1, mm2)); + TEST_INSTRUCTION("0F73F101" , psllq(mm1, 1)); + TEST_INSTRUCTION("0FF38C1A80000000" , psllq(mm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0FF38C1A80000000" , psllq(mm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660FF3CA" , psllq(xmm1, xmm2)); + TEST_INSTRUCTION("660F73F101" , psllq(xmm1, 1)); + TEST_INSTRUCTION("660FF38C1A80000000" , psllq(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660FF38C1A80000000" , psllq(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0FF1CA" , psllw(mm1, mm2)); + TEST_INSTRUCTION("0F71F101" , psllw(mm1, 1)); + TEST_INSTRUCTION("0FF18C1A80000000" , psllw(mm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0FF18C1A80000000" , psllw(mm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660FF1CA" , psllw(xmm1, xmm2)); + TEST_INSTRUCTION("660F71F101" , psllw(xmm1, 1)); + TEST_INSTRUCTION("660FF18C1A80000000" , psllw(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660FF18C1A80000000" , psllw(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0FE2CA" , psrad(mm1, mm2)); + TEST_INSTRUCTION("0F72E101" , psrad(mm1, 1)); + TEST_INSTRUCTION("0FE28C1A80000000" , psrad(mm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0FE28C1A80000000" , psrad(mm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660FE2CA" , psrad(xmm1, xmm2)); + TEST_INSTRUCTION("660F72E101" , psrad(xmm1, 1)); + TEST_INSTRUCTION("660FE28C1A80000000" , psrad(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660FE28C1A80000000" , psrad(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0FE1CA" , psraw(mm1, mm2)); + TEST_INSTRUCTION("0F71E101" , psraw(mm1, 1)); + TEST_INSTRUCTION("0FE18C1A80000000" , psraw(mm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0FE18C1A80000000" , psraw(mm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660FE1CA" , psraw(xmm1, xmm2)); + TEST_INSTRUCTION("660F71E101" , psraw(xmm1, 1)); + TEST_INSTRUCTION("660FE18C1A80000000" , psraw(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660FE18C1A80000000" , psraw(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0FD2CA" , psrld(mm1, mm2)); + TEST_INSTRUCTION("0F72D101" , psrld(mm1, 1)); + TEST_INSTRUCTION("0FD28C1A80000000" , psrld(mm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0FD28C1A80000000" , psrld(mm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660FD2CA" , psrld(xmm1, xmm2)); + TEST_INSTRUCTION("660F72D101" , psrld(xmm1, 1)); + TEST_INSTRUCTION("660FD28C1A80000000" , psrld(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660FD28C1A80000000" , psrld(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F73D901" , psrldq(xmm1, 1)); + TEST_INSTRUCTION("0FD3CA" , psrlq(mm1, mm2)); + TEST_INSTRUCTION("0F73D101" , psrlq(mm1, 1)); + TEST_INSTRUCTION("0FD38C1A80000000" , psrlq(mm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0FD38C1A80000000" , psrlq(mm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660FD3CA" , psrlq(xmm1, xmm2)); + TEST_INSTRUCTION("660F73D101" , psrlq(xmm1, 1)); + TEST_INSTRUCTION("660FD38C1A80000000" , psrlq(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660FD38C1A80000000" , psrlq(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0FD1CA" , psrlw(mm1, mm2)); + TEST_INSTRUCTION("0F71D101" , psrlw(mm1, 1)); + TEST_INSTRUCTION("0FD18C1A80000000" , psrlw(mm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0FD18C1A80000000" , psrlw(mm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660FD1CA" , psrlw(xmm1, xmm2)); + TEST_INSTRUCTION("660F71D101" , psrlw(xmm1, 1)); + TEST_INSTRUCTION("660FD18C1A80000000" , psrlw(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660FD18C1A80000000" , psrlw(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0FF8CA" , psubb(mm1, mm2)); + TEST_INSTRUCTION("0FF88C1A80000000" , psubb(mm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0FF88C1A80000000" , psubb(mm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660FF8CA" , psubb(xmm1, xmm2)); + TEST_INSTRUCTION("660FF88C1A80000000" , psubb(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660FF88C1A80000000" , psubb(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0FFACA" , psubd(mm1, mm2)); + TEST_INSTRUCTION("0FFA8C1A80000000" , psubd(mm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0FFA8C1A80000000" , psubd(mm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660FFACA" , psubd(xmm1, xmm2)); + TEST_INSTRUCTION("660FFA8C1A80000000" , psubd(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660FFA8C1A80000000" , psubd(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0FFBCA" , psubq(mm1, mm2)); + TEST_INSTRUCTION("0FFB8C1A80000000" , psubq(mm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0FFB8C1A80000000" , psubq(mm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660FFBCA" , psubq(xmm1, xmm2)); + TEST_INSTRUCTION("660FFB8C1A80000000" , psubq(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660FFB8C1A80000000" , psubq(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0FE8CA" , psubsb(mm1, mm2)); + TEST_INSTRUCTION("0FE88C1A80000000" , psubsb(mm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0FE88C1A80000000" , psubsb(mm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660FE8CA" , psubsb(xmm1, xmm2)); + TEST_INSTRUCTION("660FE88C1A80000000" , psubsb(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660FE88C1A80000000" , psubsb(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0FE9CA" , psubsw(mm1, mm2)); + TEST_INSTRUCTION("0FE98C1A80000000" , psubsw(mm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0FE98C1A80000000" , psubsw(mm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660FE9CA" , psubsw(xmm1, xmm2)); + TEST_INSTRUCTION("660FE98C1A80000000" , psubsw(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660FE98C1A80000000" , psubsw(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0FD8CA" , psubusb(mm1, mm2)); + TEST_INSTRUCTION("0FD88C1A80000000" , psubusb(mm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0FD88C1A80000000" , psubusb(mm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660FD8CA" , psubusb(xmm1, xmm2)); + TEST_INSTRUCTION("660FD88C1A80000000" , psubusb(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660FD88C1A80000000" , psubusb(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0FD9CA" , psubusw(mm1, mm2)); + TEST_INSTRUCTION("0FD98C1A80000000" , psubusw(mm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0FD98C1A80000000" , psubusw(mm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660FD9CA" , psubusw(xmm1, xmm2)); + TEST_INSTRUCTION("660FD98C1A80000000" , psubusw(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660FD98C1A80000000" , psubusw(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0FF9CA" , psubw(mm1, mm2)); + TEST_INSTRUCTION("0FF98C1A80000000" , psubw(mm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0FF98C1A80000000" , psubw(mm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660FF9CA" , psubw(xmm1, xmm2)); + TEST_INSTRUCTION("660FF98C1A80000000" , psubw(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660FF98C1A80000000" , psubw(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F0FCABB" , pswapd(mm1, mm2)); + TEST_INSTRUCTION("0F0F8C1A80000000BB" , pswapd(mm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F0F8C1A80000000BB" , pswapd(mm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F3817CA" , ptest(xmm1, xmm2)); + TEST_INSTRUCTION("660F38178C1A80000000" , ptest(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F38178C1A80000000" , ptest(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F68CA" , punpckhbw(mm1, mm2)); + TEST_INSTRUCTION("0F688C1A80000000" , punpckhbw(mm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F688C1A80000000" , punpckhbw(mm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F68CA" , punpckhbw(xmm1, xmm2)); + TEST_INSTRUCTION("660F688C1A80000000" , punpckhbw(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F688C1A80000000" , punpckhbw(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F6ACA" , punpckhdq(mm1, mm2)); + TEST_INSTRUCTION("0F6A8C1A80000000" , punpckhdq(mm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F6A8C1A80000000" , punpckhdq(mm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F6ACA" , punpckhdq(xmm1, xmm2)); + TEST_INSTRUCTION("660F6A8C1A80000000" , punpckhdq(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F6A8C1A80000000" , punpckhdq(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F6DCA" , punpckhqdq(xmm1, xmm2)); + TEST_INSTRUCTION("660F6D8C1A80000000" , punpckhqdq(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F6D8C1A80000000" , punpckhqdq(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F69CA" , punpckhwd(mm1, mm2)); + TEST_INSTRUCTION("0F698C1A80000000" , punpckhwd(mm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F698C1A80000000" , punpckhwd(mm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F69CA" , punpckhwd(xmm1, xmm2)); + TEST_INSTRUCTION("660F698C1A80000000" , punpckhwd(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F698C1A80000000" , punpckhwd(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F60CA" , punpcklbw(mm1, mm2)); + TEST_INSTRUCTION("0F608C1A80000000" , punpcklbw(mm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F608C1A80000000" , punpcklbw(mm1, dword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F60CA" , punpcklbw(xmm1, xmm2)); + TEST_INSTRUCTION("660F608C1A80000000" , punpcklbw(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F608C1A80000000" , punpcklbw(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F62CA" , punpckldq(mm1, mm2)); + TEST_INSTRUCTION("0F628C1A80000000" , punpckldq(mm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F628C1A80000000" , punpckldq(mm1, dword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F62CA" , punpckldq(xmm1, xmm2)); + TEST_INSTRUCTION("660F628C1A80000000" , punpckldq(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F628C1A80000000" , punpckldq(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F6CCA" , punpcklqdq(xmm1, xmm2)); + TEST_INSTRUCTION("660F6C8C1A80000000" , punpcklqdq(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F6C8C1A80000000" , punpcklqdq(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F61CA" , punpcklwd(mm1, mm2)); + TEST_INSTRUCTION("0F618C1A80000000" , punpcklwd(mm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F618C1A80000000" , punpcklwd(mm1, dword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F61CA" , punpcklwd(xmm1, xmm2)); + TEST_INSTRUCTION("660F618C1A80000000" , punpcklwd(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F618C1A80000000" , punpcklwd(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0FEFCA" , pxor(mm1, mm2)); + TEST_INSTRUCTION("0FEF8C1A80000000" , pxor(mm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0FEF8C1A80000000" , pxor(mm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660FEFCA" , pxor(xmm1, xmm2)); + TEST_INSTRUCTION("660FEF8C1A80000000" , pxor(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660FEF8C1A80000000" , pxor(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F53CA" , rcpps(xmm1, xmm2)); + TEST_INSTRUCTION("0F538C1A80000000" , rcpps(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F538C1A80000000" , rcpps(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("F30F53CA" , rcpss(xmm1, xmm2)); + TEST_INSTRUCTION("F30F538C1A80000000" , rcpss(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("F30F538C1A80000000" , rcpss(xmm1, dword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F3A09CA01" , roundpd(xmm1, xmm2, 1)); + TEST_INSTRUCTION("660F3A098C1A8000000001" , roundpd(xmm1, ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("660F3A098C1A8000000001" , roundpd(xmm1, xmmword_ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("660F3A08CA01" , roundps(xmm1, xmm2, 1)); + TEST_INSTRUCTION("660F3A088C1A8000000001" , roundps(xmm1, ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("660F3A088C1A8000000001" , roundps(xmm1, xmmword_ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("660F3A0BCA01" , roundsd(xmm1, xmm2, 1)); + TEST_INSTRUCTION("660F3A0B8C1A8000000001" , roundsd(xmm1, ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("660F3A0B8C1A8000000001" , roundsd(xmm1, qword_ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("660F3A0ACA01" , roundss(xmm1, xmm2, 1)); + TEST_INSTRUCTION("660F3A0A8C1A8000000001" , roundss(xmm1, ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("660F3A0A8C1A8000000001" , roundss(xmm1, dword_ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("0F52CA" , rsqrtps(xmm1, xmm2)); + TEST_INSTRUCTION("0F528C1A80000000" , rsqrtps(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F528C1A80000000" , rsqrtps(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("F30F52CA" , rsqrtss(xmm1, xmm2)); + TEST_INSTRUCTION("F30F528C1A80000000" , rsqrtss(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("F30F528C1A80000000" , rsqrtss(xmm1, dword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("F30F01AC1180000000" , rstorssp(ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("F30F01AC1180000000" , rstorssp(qword_ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("0F38C9CA" , sha1msg1(xmm1, xmm2)); + TEST_INSTRUCTION("0F38C98C1A80000000" , sha1msg1(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F38C98C1A80000000" , sha1msg1(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F38CACA" , sha1msg2(xmm1, xmm2)); + TEST_INSTRUCTION("0F38CA8C1A80000000" , sha1msg2(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F38CA8C1A80000000" , sha1msg2(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F38C8CA" , sha1nexte(xmm1, xmm2)); + TEST_INSTRUCTION("0F38C88C1A80000000" , sha1nexte(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F38C88C1A80000000" , sha1nexte(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F3ACCCA01" , sha1rnds4(xmm1, xmm2, 1)); + TEST_INSTRUCTION("0F3ACC8C1A8000000001" , sha1rnds4(xmm1, ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("0F3ACC8C1A8000000001" , sha1rnds4(xmm1, xmmword_ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("0F38CCCA" , sha256msg1(xmm1, xmm2)); + TEST_INSTRUCTION("0F38CC8C1A80000000" , sha256msg1(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F38CC8C1A80000000" , sha256msg1(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F38CDCA" , sha256msg2(xmm1, xmm2)); + TEST_INSTRUCTION("0F38CD8C1A80000000" , sha256msg2(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F38CD8C1A80000000" , sha256msg2(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F38CBCA" , sha256rnds2(xmm1, xmm2, xmm0)); + TEST_INSTRUCTION("0F38CB8C1A80000000" , sha256rnds2(xmm1, ptr(rdx, rbx, 0, 128), xmm0)); + TEST_INSTRUCTION("0F38CB8C1A80000000" , sha256rnds2(xmm1, xmmword_ptr(rdx, rbx, 0, 128), xmm0)); + TEST_INSTRUCTION("660FC6CA01" , shufpd(xmm1, xmm2, 1)); + TEST_INSTRUCTION("660FC68C1A8000000001" , shufpd(xmm1, ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("660FC68C1A8000000001" , shufpd(xmm1, xmmword_ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("0FC6CA01" , shufps(xmm1, xmm2, 1)); + TEST_INSTRUCTION("0FC68C1A8000000001" , shufps(xmm1, ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("0FC68C1A8000000001" , shufps(xmm1, xmmword_ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("660F51CA" , sqrtpd(xmm1, xmm2)); + TEST_INSTRUCTION("660F518C1A80000000" , sqrtpd(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F518C1A80000000" , sqrtpd(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F51CA" , sqrtps(xmm1, xmm2)); + TEST_INSTRUCTION("0F518C1A80000000" , sqrtps(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F518C1A80000000" , sqrtps(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("F20F51CA" , sqrtsd(xmm1, xmm2)); + TEST_INSTRUCTION("F20F518C1A80000000" , sqrtsd(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("F20F518C1A80000000" , sqrtsd(xmm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("F30F51CA" , sqrtss(xmm1, xmm2)); + TEST_INSTRUCTION("F30F518C1A80000000" , sqrtss(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("F30F518C1A80000000" , sqrtss(xmm1, dword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F5CCA" , subpd(xmm1, xmm2)); + TEST_INSTRUCTION("660F5C8C1A80000000" , subpd(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F5C8C1A80000000" , subpd(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F5CCA" , subps(xmm1, xmm2)); + TEST_INSTRUCTION("0F5C8C1A80000000" , subps(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F5C8C1A80000000" , subps(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("F20F5CCA" , subsd(xmm1, xmm2)); + TEST_INSTRUCTION("F20F5C8C1A80000000" , subsd(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("F20F5C8C1A80000000" , subsd(xmm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("F30F5CCA" , subss(xmm1, xmm2)); + TEST_INSTRUCTION("F30F5C8C1A80000000" , subss(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("F30F5C8C1A80000000" , subss(xmm1, dword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F2ECA" , ucomisd(xmm1, xmm2)); + TEST_INSTRUCTION("660F2E8C1A80000000" , ucomisd(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F2E8C1A80000000" , ucomisd(xmm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F2ECA" , ucomiss(xmm1, xmm2)); + TEST_INSTRUCTION("0F2E8C1A80000000" , ucomiss(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F2E8C1A80000000" , ucomiss(xmm1, dword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F15CA" , unpckhpd(xmm1, xmm2)); + TEST_INSTRUCTION("660F158C1A80000000" , unpckhpd(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F158C1A80000000" , unpckhpd(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F15CA" , unpckhps(xmm1, xmm2)); + TEST_INSTRUCTION("0F158C1A80000000" , unpckhps(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F158C1A80000000" , unpckhps(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F14CA" , unpcklpd(xmm1, xmm2)); + TEST_INSTRUCTION("660F148C1A80000000" , unpcklpd(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F148C1A80000000" , unpcklpd(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F14CA" , unpcklps(xmm1, xmm2)); + TEST_INSTRUCTION("0F148C1A80000000" , unpcklps(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F148C1A80000000" , unpcklps(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F57CA" , xorpd(xmm1, xmm2)); + TEST_INSTRUCTION("660F578C1A80000000" , xorpd(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("660F578C1A80000000" , xorpd(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F57CA" , xorps(xmm1, xmm2)); + TEST_INSTRUCTION("0F578C1A80000000" , xorps(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("0F578C1A80000000" , xorps(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); +} + +static void ASMJIT_NOINLINE testX64AssemblerAVX(AssemblerTester<x86::Assembler>& tester) noexcept { + using namespace x86; + + TEST_INSTRUCTION("62F25F489A4C1A08" , v4fmaddps(zmm1, zmm4, zmm5, zmm6, zmm7, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F25F489A4C1A08" , v4fmaddps(zmm1, zmm4, zmm5, zmm6, zmm7, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F25F089B4C1A08" , v4fmaddss(xmm1, xmm4, xmm5, xmm6, xmm7, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F25F089B4C1A08" , v4fmaddss(xmm1, xmm4, xmm5, xmm6, xmm7, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F25F48AA4C1A08" , v4fnmaddps(zmm1, zmm4, zmm5, zmm6, zmm7, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F25F48AA4C1A08" , v4fnmaddps(zmm1, zmm4, zmm5, zmm6, zmm7, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F25F08AB4C1A08" , v4fnmaddss(xmm1, xmm4, xmm5, xmm6, xmm7, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F25F08AB4C1A08" , v4fnmaddss(xmm1, xmm4, xmm5, xmm6, xmm7, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C5E958CB" , vaddpd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5E9588C2B80000000" , vaddpd(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5E9588C2B80000000" , vaddpd(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5ED58CB" , vaddpd(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C5ED588C2B80000000" , vaddpd(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5ED588C2B80000000" , vaddpd(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F1ED4858CB" , vaddpd(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F1ED48584C2B02" , vaddpd(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F1ED48584C2B02" , vaddpd(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5E858CB" , vaddps(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5E8588C2B80000000" , vaddps(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5E8588C2B80000000" , vaddps(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5EC58CB" , vaddps(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C5EC588C2B80000000" , vaddps(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5EC588C2B80000000" , vaddps(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16C4858CB" , vaddps(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F16C48584C2B02" , vaddps(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16C48584C2B02" , vaddps(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5EB58CB" , vaddsd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5EB588C2B80000000" , vaddsd(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5EB588C2B80000000" , vaddsd(xmm1, xmm2, qword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5EA58CB" , vaddss(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5EA588C2B80000000" , vaddss(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5EA588C2B80000000" , vaddss(xmm1, xmm2, dword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5E9D0CB" , vaddsubpd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5E9D08C2B80000000" , vaddsubpd(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5E9D08C2B80000000" , vaddsubpd(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5EDD0CB" , vaddsubpd(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C5EDD08C2B80000000" , vaddsubpd(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5EDD08C2B80000000" , vaddsubpd(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5EBD0CB" , vaddsubps(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5EBD08C2B80000000" , vaddsubps(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5EBD08C2B80000000" , vaddsubps(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5EFD0CB" , vaddsubps(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C5EFD08C2B80000000" , vaddsubps(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5EFD08C2B80000000" , vaddsubps(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E269DECB" , vaesdec(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E269DE8C2B80000000" , vaesdec(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E269DE8C2B80000000" , vaesdec(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E26DDECB" , vaesdec(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C4E26DDE8C2B80000000" , vaesdec(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E26DDE8C2B80000000" , vaesdec(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D48DECB" , vaesdec(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F26D48DE4C2B02" , vaesdec(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D48DE4C2B02" , vaesdec(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E269DFCB" , vaesdeclast(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E269DF8C2B80000000" , vaesdeclast(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E269DF8C2B80000000" , vaesdeclast(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E26DDFCB" , vaesdeclast(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C4E26DDF8C2B80000000" , vaesdeclast(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E26DDF8C2B80000000" , vaesdeclast(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D48DFCB" , vaesdeclast(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F26D48DF4C2B02" , vaesdeclast(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D48DF4C2B02" , vaesdeclast(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E269DCCB" , vaesenc(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E269DC8C2B80000000" , vaesenc(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E269DC8C2B80000000" , vaesenc(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E26DDCCB" , vaesenc(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C4E26DDC8C2B80000000" , vaesenc(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E26DDC8C2B80000000" , vaesenc(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D48DCCB" , vaesenc(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F26D48DC4C2B02" , vaesenc(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D48DC4C2B02" , vaesenc(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E269DDCB" , vaesenclast(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E269DD8C2B80000000" , vaesenclast(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E269DD8C2B80000000" , vaesenclast(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E26DDDCB" , vaesenclast(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C4E26DDD8C2B80000000" , vaesenclast(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E26DDD8C2B80000000" , vaesenclast(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D48DDCB" , vaesenclast(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F26D48DD4C2B02" , vaesenclast(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D48DD4C2B02" , vaesenclast(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E279DBCA" , vaesimc(xmm1, xmm2)); + TEST_INSTRUCTION("C4E279DB8C1A80000000" , vaesimc(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C4E279DB8C1A80000000" , vaesimc(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C4E379DFCA01" , vaeskeygenassist(xmm1, xmm2, 1)); + TEST_INSTRUCTION("C4E379DF8C1A8000000001" , vaeskeygenassist(xmm1, ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("C4E379DF8C1A8000000001" , vaeskeygenassist(xmm1, xmmword_ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("62F36D0803CB01" , valignd(xmm1, xmm2, xmm3, 1)); + TEST_INSTRUCTION("62F36D08034C2B0801" , valignd(xmm1, xmm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D08034C2B0801" , valignd(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D2803CB01" , valignd(ymm1, ymm2, ymm3, 1)); + TEST_INSTRUCTION("62F36D28034C2B0401" , valignd(ymm1, ymm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D28034C2B0401" , valignd(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D4803CB01" , valignd(zmm1, zmm2, zmm3, 1)); + TEST_INSTRUCTION("62F36D48034C2B0201" , valignd(zmm1, zmm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D48034C2B0201" , valignd(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED0803CB01" , valignq(xmm1, xmm2, xmm3, 1)); + TEST_INSTRUCTION("62F3ED08034C2B0801" , valignq(xmm1, xmm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED08034C2B0801" , valignq(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED2803CB01" , valignq(ymm1, ymm2, ymm3, 1)); + TEST_INSTRUCTION("62F3ED28034C2B0401" , valignq(ymm1, ymm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED28034C2B0401" , valignq(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED4803CB01" , valignq(zmm1, zmm2, zmm3, 1)); + TEST_INSTRUCTION("62F3ED48034C2B0201" , valignq(zmm1, zmm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED48034C2B0201" , valignq(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("C5E955CB" , vandnpd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5E9558C2B80000000" , vandnpd(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5E9558C2B80000000" , vandnpd(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5ED55CB" , vandnpd(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C5ED558C2B80000000" , vandnpd(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5ED558C2B80000000" , vandnpd(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F1ED4855CB" , vandnpd(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F1ED48554C2B02" , vandnpd(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F1ED48554C2B02" , vandnpd(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5E855CB" , vandnps(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5E8558C2B80000000" , vandnps(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5E8558C2B80000000" , vandnps(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5EC55CB" , vandnps(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C5EC558C2B80000000" , vandnps(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5EC558C2B80000000" , vandnps(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16C4855CB" , vandnps(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F16C48554C2B02" , vandnps(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16C48554C2B02" , vandnps(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5E954CB" , vandpd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5E9548C2B80000000" , vandpd(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5E9548C2B80000000" , vandpd(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5ED54CB" , vandpd(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C5ED548C2B80000000" , vandpd(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5ED548C2B80000000" , vandpd(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F1ED4854CB" , vandpd(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F1ED48544C2B02" , vandpd(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F1ED48544C2B02" , vandpd(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5E854CB" , vandps(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5E8548C2B80000000" , vandps(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5E8548C2B80000000" , vandps(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5EC54CB" , vandps(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C5EC548C2B80000000" , vandps(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5EC548C2B80000000" , vandps(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16C4854CB" , vandps(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F16C48544C2B02" , vandps(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16C48544C2B02" , vandps(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED0865CB" , vblendmpd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("62F2ED08654C2B08" , vblendmpd(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED08654C2B08" , vblendmpd(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED2865CB" , vblendmpd(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("62F2ED28654C2B04" , vblendmpd(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED28654C2B04" , vblendmpd(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED4865CB" , vblendmpd(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F2ED48654C2B02" , vblendmpd(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED48654C2B02" , vblendmpd(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D0865CB" , vblendmps(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("62F26D08654C2B08" , vblendmps(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D08654C2B08" , vblendmps(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D2865CB" , vblendmps(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("62F26D28654C2B04" , vblendmps(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D28654C2B04" , vblendmps(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D4865CB" , vblendmps(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F26D48654C2B02" , vblendmps(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D48654C2B02" , vblendmps(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E3690DCB01" , vblendpd(xmm1, xmm2, xmm3, 1)); + TEST_INSTRUCTION("C4E3690D8C2B8000000001" , vblendpd(xmm1, xmm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("C4E3690D8C2B8000000001" , vblendpd(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("C4E36D0DCB01" , vblendpd(ymm1, ymm2, ymm3, 1)); + TEST_INSTRUCTION("C4E36D0D8C2B8000000001" , vblendpd(ymm1, ymm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("C4E36D0D8C2B8000000001" , vblendpd(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("C4E3690CCB01" , vblendps(xmm1, xmm2, xmm3, 1)); + TEST_INSTRUCTION("C4E3690C8C2B8000000001" , vblendps(xmm1, xmm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("C4E3690C8C2B8000000001" , vblendps(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("C4E36D0CCB01" , vblendps(ymm1, ymm2, ymm3, 1)); + TEST_INSTRUCTION("C4E36D0C8C2B8000000001" , vblendps(ymm1, ymm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("C4E36D0C8C2B8000000001" , vblendps(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("C4E3694BCB40" , vblendvpd(xmm1, xmm2, xmm3, xmm4)); + TEST_INSTRUCTION("C4E3694B8C2B8000000060" , vblendvpd(xmm1, xmm2, ptr(rbx, rbp, 0, 128), xmm6)); + TEST_INSTRUCTION("C4E3694B8C2B8000000060" , vblendvpd(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128), xmm6)); + TEST_INSTRUCTION("C4E36D4BCB40" , vblendvpd(ymm1, ymm2, ymm3, ymm4)); + TEST_INSTRUCTION("C4E36D4B8C2B8000000060" , vblendvpd(ymm1, ymm2, ptr(rbx, rbp, 0, 128), ymm6)); + TEST_INSTRUCTION("C4E36D4B8C2B8000000060" , vblendvpd(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128), ymm6)); + TEST_INSTRUCTION("C4E3694ACB40" , vblendvps(xmm1, xmm2, xmm3, xmm4)); + TEST_INSTRUCTION("C4E3694A8C2B8000000060" , vblendvps(xmm1, xmm2, ptr(rbx, rbp, 0, 128), xmm6)); + TEST_INSTRUCTION("C4E3694A8C2B8000000060" , vblendvps(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128), xmm6)); + TEST_INSTRUCTION("C4E36D4ACB40" , vblendvps(ymm1, ymm2, ymm3, ymm4)); + TEST_INSTRUCTION("C4E36D4A8C2B8000000060" , vblendvps(ymm1, ymm2, ptr(rbx, rbp, 0, 128), ymm6)); + TEST_INSTRUCTION("C4E36D4A8C2B8000000060" , vblendvps(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128), ymm6)); + TEST_INSTRUCTION("C4E27D1A8C1A80000000" , vbroadcastf128(ymm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C4E27D1A8C1A80000000" , vbroadcastf128(ymm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F27D2819CA" , vbroadcastf32x2(ymm1, xmm2)); + TEST_INSTRUCTION("62F27D28194C1A10" , vbroadcastf32x2(ymm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F27D28194C1A10" , vbroadcastf32x2(ymm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F27D4819CA" , vbroadcastf32x2(zmm1, xmm2)); + TEST_INSTRUCTION("62F27D48194C1A10" , vbroadcastf32x2(zmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F27D48194C1A10" , vbroadcastf32x2(zmm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F27D281A4C1A08" , vbroadcastf32x4(ymm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F27D281A4C1A08" , vbroadcastf32x4(ymm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F27D481A4C1A08" , vbroadcastf32x4(zmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F27D481A4C1A08" , vbroadcastf32x4(zmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F27D481B4C1A04" , vbroadcastf32x8(zmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F27D481B4C1A04" , vbroadcastf32x8(zmm1, ymmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F2FD281A4C1A08" , vbroadcastf64x2(ymm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F2FD281A4C1A08" , vbroadcastf64x2(ymm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F2FD481A4C1A08" , vbroadcastf64x2(zmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F2FD481A4C1A08" , vbroadcastf64x2(zmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F2FD481B4C1A04" , vbroadcastf64x4(zmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F2FD481B4C1A04" , vbroadcastf64x4(zmm1, ymmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C4E27D5A8C1A80000000" , vbroadcasti128(ymm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C4E27D5A8C1A80000000" , vbroadcasti128(ymm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F27D0859CA" , vbroadcasti32x2(xmm1, xmm2)); + TEST_INSTRUCTION("62F27D08594C1A10" , vbroadcasti32x2(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F27D08594C1A10" , vbroadcasti32x2(xmm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F27D2859CA" , vbroadcasti32x2(ymm1, xmm2)); + TEST_INSTRUCTION("62F27D28594C1A10" , vbroadcasti32x2(ymm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F27D28594C1A10" , vbroadcasti32x2(ymm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F27D4859CA" , vbroadcasti32x2(zmm1, xmm2)); + TEST_INSTRUCTION("62F27D48594C1A10" , vbroadcasti32x2(zmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F27D48594C1A10" , vbroadcasti32x2(zmm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F27D285A4C1A08" , vbroadcasti32x4(ymm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F27D285A4C1A08" , vbroadcasti32x4(ymm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F27D485A4C1A08" , vbroadcasti32x4(zmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F27D485A4C1A08" , vbroadcasti32x4(zmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F27D485B4C1A04" , vbroadcasti32x8(zmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F27D485B4C1A04" , vbroadcasti32x8(zmm1, ymmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F2FD285A4C1A08" , vbroadcasti64x2(ymm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F2FD285A4C1A08" , vbroadcasti64x2(ymm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F2FD485A4C1A08" , vbroadcasti64x2(zmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F2FD485A4C1A08" , vbroadcasti64x2(zmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F2FD485B4C1A04" , vbroadcasti64x4(zmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F2FD485B4C1A04" , vbroadcasti64x4(zmm1, ymmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C4E27D19CA" , vbroadcastsd(ymm1, xmm2)); + TEST_INSTRUCTION("C4E27D198C1A80000000" , vbroadcastsd(ymm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C4E27D198C1A80000000" , vbroadcastsd(ymm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F2FD4819CA" , vbroadcastsd(zmm1, xmm2)); + TEST_INSTRUCTION("62F2FD48194C1A10" , vbroadcastsd(zmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F2FD48194C1A10" , vbroadcastsd(zmm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C4E27918CA" , vbroadcastss(xmm1, xmm2)); + TEST_INSTRUCTION("C4E279188C1A80000000" , vbroadcastss(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C4E279188C1A80000000" , vbroadcastss(xmm1, dword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C4E27D18CA" , vbroadcastss(ymm1, xmm2)); + TEST_INSTRUCTION("C4E27D188C1A80000000" , vbroadcastss(ymm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C4E27D188C1A80000000" , vbroadcastss(ymm1, dword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F27D4818CA" , vbroadcastss(zmm1, xmm2)); + TEST_INSTRUCTION("62F27D48184C1A20" , vbroadcastss(zmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F27D48184C1A20" , vbroadcastss(zmm1, dword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C5E9C2CB01" , vcmppd(xmm1, xmm2, xmm3, 1)); + TEST_INSTRUCTION("C5E9C28C2B8000000001" , vcmppd(xmm1, xmm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("C5E9C28C2B8000000001" , vcmppd(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F1ED08C2CB01" , vcmppd(k1, xmm2, xmm3, 1)); + TEST_INSTRUCTION("62F1ED08C24C2B0801" , vcmppd(k1, xmm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F1ED08C24C2B0801" , vcmppd(k1, xmm2, xmmword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("C5EDC2CB01" , vcmppd(ymm1, ymm2, ymm3, 1)); + TEST_INSTRUCTION("C5EDC28C2B8000000001" , vcmppd(ymm1, ymm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("C5EDC28C2B8000000001" , vcmppd(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F1ED28C2CB01" , vcmppd(k1, ymm2, ymm3, 1)); + TEST_INSTRUCTION("62F1ED28C24C2B0401" , vcmppd(k1, ymm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F1ED28C24C2B0401" , vcmppd(k1, ymm2, ymmword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F1ED48C2CB01" , vcmppd(k1, zmm2, zmm3, 1)); + TEST_INSTRUCTION("62F1ED48C24C2B0201" , vcmppd(k1, zmm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F1ED48C24C2B0201" , vcmppd(k1, zmm2, zmmword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("C5E8C2CB01" , vcmpps(xmm1, xmm2, xmm3, 1)); + TEST_INSTRUCTION("C5E8C28C2B8000000001" , vcmpps(xmm1, xmm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("C5E8C28C2B8000000001" , vcmpps(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F16C08C2CB01" , vcmpps(k1, xmm2, xmm3, 1)); + TEST_INSTRUCTION("62F16C08C24C2B0801" , vcmpps(k1, xmm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F16C08C24C2B0801" , vcmpps(k1, xmm2, xmmword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("C5ECC2CB01" , vcmpps(ymm1, ymm2, ymm3, 1)); + TEST_INSTRUCTION("C5ECC28C2B8000000001" , vcmpps(ymm1, ymm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("C5ECC28C2B8000000001" , vcmpps(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F16C28C2CB01" , vcmpps(k1, ymm2, ymm3, 1)); + TEST_INSTRUCTION("62F16C28C24C2B0401" , vcmpps(k1, ymm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F16C28C24C2B0401" , vcmpps(k1, ymm2, ymmword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F16C48C2CB01" , vcmpps(k1, zmm2, zmm3, 1)); + TEST_INSTRUCTION("62F16C48C24C2B0201" , vcmpps(k1, zmm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F16C48C24C2B0201" , vcmpps(k1, zmm2, zmmword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("C5EBC2CB01" , vcmpsd(xmm1, xmm2, xmm3, 1)); + TEST_INSTRUCTION("C5EBC28C2B8000000001" , vcmpsd(xmm1, xmm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("C5EBC28C2B8000000001" , vcmpsd(xmm1, xmm2, qword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F1EF08C2CB01" , vcmpsd(k1, xmm2, xmm3, 1)); + TEST_INSTRUCTION("62F1EF08C24C2B1001" , vcmpsd(k1, xmm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F1EF08C24C2B1001" , vcmpsd(k1, xmm2, qword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("C5EAC2CB01" , vcmpss(xmm1, xmm2, xmm3, 1)); + TEST_INSTRUCTION("C5EAC28C2B8000000001" , vcmpss(xmm1, xmm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("C5EAC28C2B8000000001" , vcmpss(xmm1, xmm2, dword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F16E08C2CB01" , vcmpss(k1, xmm2, xmm3, 1)); + TEST_INSTRUCTION("62F16E08C24C2B2001" , vcmpss(k1, xmm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F16E08C24C2B2001" , vcmpss(k1, xmm2, dword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("C5F92FCA" , vcomisd(xmm1, xmm2)); + TEST_INSTRUCTION("C5F92F8C1A80000000" , vcomisd(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C5F92F8C1A80000000" , vcomisd(xmm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C5F82FCA" , vcomiss(xmm1, xmm2)); + TEST_INSTRUCTION("C5F82F8C1A80000000" , vcomiss(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C5F82F8C1A80000000" , vcomiss(xmm1, dword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F2FD088AD1" , vcompresspd(xmm1, xmm2)); + TEST_INSTRUCTION("62F2FD088A5C1110" , vcompresspd(ptr(rcx, rdx, 0, 128), xmm3)); + TEST_INSTRUCTION("62F2FD088A5C1110" , vcompresspd(xmmword_ptr(rcx, rdx, 0, 128), xmm3)); + TEST_INSTRUCTION("62F2FD288AD1" , vcompresspd(ymm1, ymm2)); + TEST_INSTRUCTION("62F2FD288A5C1110" , vcompresspd(ptr(rcx, rdx, 0, 128), ymm3)); + TEST_INSTRUCTION("62F2FD288A5C1110" , vcompresspd(ymmword_ptr(rcx, rdx, 0, 128), ymm3)); + TEST_INSTRUCTION("62F2FD488AD1" , vcompresspd(zmm1, zmm2)); + TEST_INSTRUCTION("62F2FD488A5C1110" , vcompresspd(ptr(rcx, rdx, 0, 128), zmm3)); + TEST_INSTRUCTION("62F2FD488A5C1110" , vcompresspd(zmmword_ptr(rcx, rdx, 0, 128), zmm3)); + TEST_INSTRUCTION("62F27D088AD1" , vcompressps(xmm1, xmm2)); + TEST_INSTRUCTION("62F27D088A5C1120" , vcompressps(ptr(rcx, rdx, 0, 128), xmm3)); + TEST_INSTRUCTION("62F27D088A5C1120" , vcompressps(xmmword_ptr(rcx, rdx, 0, 128), xmm3)); + TEST_INSTRUCTION("62F27D288AD1" , vcompressps(ymm1, ymm2)); + TEST_INSTRUCTION("62F27D288A5C1120" , vcompressps(ptr(rcx, rdx, 0, 128), ymm3)); + TEST_INSTRUCTION("62F27D288A5C1120" , vcompressps(ymmword_ptr(rcx, rdx, 0, 128), ymm3)); + TEST_INSTRUCTION("62F27D488AD1" , vcompressps(zmm1, zmm2)); + TEST_INSTRUCTION("62F27D488A5C1120" , vcompressps(ptr(rcx, rdx, 0, 128), zmm3)); + TEST_INSTRUCTION("62F27D488A5C1120" , vcompressps(zmmword_ptr(rcx, rdx, 0, 128), zmm3)); + TEST_INSTRUCTION("C5FAE6CA" , vcvtdq2pd(xmm1, xmm2)); + TEST_INSTRUCTION("C5FAE68C1A80000000" , vcvtdq2pd(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C5FAE68C1A80000000" , vcvtdq2pd(xmm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C5FEE6CA" , vcvtdq2pd(ymm1, xmm2)); + TEST_INSTRUCTION("C5FEE68C1A80000000" , vcvtdq2pd(ymm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C5FEE68C1A80000000" , vcvtdq2pd(ymm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F17E48E6CA" , vcvtdq2pd(zmm1, ymm2)); + TEST_INSTRUCTION("62F17E48E64C1A04" , vcvtdq2pd(zmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F17E48E64C1A04" , vcvtdq2pd(zmm1, ymmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C5F85BCA" , vcvtdq2ps(xmm1, xmm2)); + TEST_INSTRUCTION("C5F85B8C1A80000000" , vcvtdq2ps(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C5F85B8C1A80000000" , vcvtdq2ps(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C5FC5BCA" , vcvtdq2ps(ymm1, ymm2)); + TEST_INSTRUCTION("C5FC5B8C1A80000000" , vcvtdq2ps(ymm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C5FC5B8C1A80000000" , vcvtdq2ps(ymm1, ymmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F17C485BCA" , vcvtdq2ps(zmm1, zmm2)); + TEST_INSTRUCTION("62F17C485B4C1A02" , vcvtdq2ps(zmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F17C485B4C1A02" , vcvtdq2ps(zmm1, zmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F26F0872CB" , vcvtne2ps2bf16(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("62F26F08724C2B08" , vcvtne2ps2bf16(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26F08724C2B08" , vcvtne2ps2bf16(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26F2872CB" , vcvtne2ps2bf16(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("62F26F28724C2B04" , vcvtne2ps2bf16(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26F28724C2B04" , vcvtne2ps2bf16(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26F4872CB" , vcvtne2ps2bf16(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F26F48724C2B02" , vcvtne2ps2bf16(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26F48724C2B02" , vcvtne2ps2bf16(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F27E0872CA" , vcvtneps2bf16(xmm1, xmm2)); + TEST_INSTRUCTION("62F27E2872CA" , vcvtneps2bf16(xmm1, ymm2)); + TEST_INSTRUCTION("62F27E08724C1A08" , vcvtneps2bf16(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F27E28724C1A04" , vcvtneps2bf16(xmm1, ymmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F27E4872CA" , vcvtneps2bf16(ymm1, zmm2)); + TEST_INSTRUCTION("62F27E48724C1A02" , vcvtneps2bf16(ymm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F27E48724C1A02" , vcvtneps2bf16(ymm1, zmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C5FBE6CA" , vcvtpd2dq(xmm1, xmm2)); + TEST_INSTRUCTION("C5FFE6CA" , vcvtpd2dq(xmm1, ymm2)); + TEST_INSTRUCTION("C5FBE68C1A80000000" , vcvtpd2dq(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C5FFE68C1A80000000" , vcvtpd2dq(xmm1, ymmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F1FF48E6CA" , vcvtpd2dq(ymm1, zmm2)); + TEST_INSTRUCTION("62F1FF48E64C1A02" , vcvtpd2dq(ymm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F1FF48E64C1A02" , vcvtpd2dq(ymm1, zmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C5F95ACA" , vcvtpd2ps(xmm1, xmm2)); + TEST_INSTRUCTION("C5FD5ACA" , vcvtpd2ps(xmm1, ymm2)); + TEST_INSTRUCTION("C5F95A8C1A80000000" , vcvtpd2ps(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C5FD5A8C1A80000000" , vcvtpd2ps(xmm1, ymmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F1FD485ACA" , vcvtpd2ps(ymm1, zmm2)); + TEST_INSTRUCTION("62F1FD485A4C1A02" , vcvtpd2ps(ymm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F1FD485A4C1A02" , vcvtpd2ps(ymm1, zmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F1FD087BCA" , vcvtpd2qq(xmm1, xmm2)); + TEST_INSTRUCTION("62F1FD087B4C1A08" , vcvtpd2qq(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F1FD087B4C1A08" , vcvtpd2qq(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F1FD287BCA" , vcvtpd2qq(ymm1, ymm2)); + TEST_INSTRUCTION("62F1FD287B4C1A04" , vcvtpd2qq(ymm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F1FD287B4C1A04" , vcvtpd2qq(ymm1, ymmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F1FD487BCA" , vcvtpd2qq(zmm1, zmm2)); + TEST_INSTRUCTION("62F1FD487B4C1A02" , vcvtpd2qq(zmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F1FD487B4C1A02" , vcvtpd2qq(zmm1, zmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F1FC0879CA" , vcvtpd2udq(xmm1, xmm2)); + TEST_INSTRUCTION("62F1FC2879CA" , vcvtpd2udq(xmm1, ymm2)); + TEST_INSTRUCTION("62F1FC08794C1A08" , vcvtpd2udq(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F1FC28794C1A04" , vcvtpd2udq(xmm1, ymmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F1FC4879CA" , vcvtpd2udq(ymm1, zmm2)); + TEST_INSTRUCTION("62F1FC48794C1A02" , vcvtpd2udq(ymm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F1FC48794C1A02" , vcvtpd2udq(ymm1, zmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F1FD0879CA" , vcvtpd2uqq(xmm1, xmm2)); + TEST_INSTRUCTION("62F1FD08794C1A08" , vcvtpd2uqq(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F1FD08794C1A08" , vcvtpd2uqq(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F1FD2879CA" , vcvtpd2uqq(ymm1, ymm2)); + TEST_INSTRUCTION("62F1FD28794C1A04" , vcvtpd2uqq(ymm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F1FD28794C1A04" , vcvtpd2uqq(ymm1, ymmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F1FD4879CA" , vcvtpd2uqq(zmm1, zmm2)); + TEST_INSTRUCTION("62F1FD48794C1A02" , vcvtpd2uqq(zmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F1FD48794C1A02" , vcvtpd2uqq(zmm1, zmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C4E27913CA" , vcvtph2ps(xmm1, xmm2)); + TEST_INSTRUCTION("C4E279138C1A80000000" , vcvtph2ps(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C4E279138C1A80000000" , vcvtph2ps(xmm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C4E27D13CA" , vcvtph2ps(ymm1, xmm2)); + TEST_INSTRUCTION("C4E27D138C1A80000000" , vcvtph2ps(ymm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C4E27D138C1A80000000" , vcvtph2ps(ymm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F27D4813CA" , vcvtph2ps(zmm1, ymm2)); + TEST_INSTRUCTION("62F27D48134C1A04" , vcvtph2ps(zmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F27D48134C1A04" , vcvtph2ps(zmm1, ymmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C5F95BCA" , vcvtps2dq(xmm1, xmm2)); + TEST_INSTRUCTION("C5F95B8C1A80000000" , vcvtps2dq(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C5F95B8C1A80000000" , vcvtps2dq(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C5FD5BCA" , vcvtps2dq(ymm1, ymm2)); + TEST_INSTRUCTION("C5FD5B8C1A80000000" , vcvtps2dq(ymm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C5FD5B8C1A80000000" , vcvtps2dq(ymm1, ymmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F17D485BCA" , vcvtps2dq(zmm1, zmm2)); + TEST_INSTRUCTION("62F17D485B4C1A02" , vcvtps2dq(zmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F17D485B4C1A02" , vcvtps2dq(zmm1, zmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C5F85ACA" , vcvtps2pd(xmm1, xmm2)); + TEST_INSTRUCTION("C5F85A8C1A80000000" , vcvtps2pd(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C5F85A8C1A80000000" , vcvtps2pd(xmm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C5FC5ACA" , vcvtps2pd(ymm1, xmm2)); + TEST_INSTRUCTION("C5FC5A8C1A80000000" , vcvtps2pd(ymm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C5FC5A8C1A80000000" , vcvtps2pd(ymm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F17C485ACA" , vcvtps2pd(zmm1, ymm2)); + TEST_INSTRUCTION("62F17C485A4C1A04" , vcvtps2pd(zmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F17C485A4C1A04" , vcvtps2pd(zmm1, ymmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C4E3791DD101" , vcvtps2ph(xmm1, xmm2, 1)); + TEST_INSTRUCTION("C4E3791D9C118000000001" , vcvtps2ph(ptr(rcx, rdx, 0, 128), xmm3, 1)); + TEST_INSTRUCTION("C4E3791D9C118000000001" , vcvtps2ph(qword_ptr(rcx, rdx, 0, 128), xmm3, 1)); + TEST_INSTRUCTION("C4E37D1DD101" , vcvtps2ph(xmm1, ymm2, 1)); + TEST_INSTRUCTION("C4E37D1D9C118000000001" , vcvtps2ph(ptr(rcx, rdx, 0, 128), ymm3, 1)); + TEST_INSTRUCTION("C4E37D1D9C118000000001" , vcvtps2ph(xmmword_ptr(rcx, rdx, 0, 128), ymm3, 1)); + TEST_INSTRUCTION("62F37D481DD101" , vcvtps2ph(ymm1, zmm2, 1)); + TEST_INSTRUCTION("62F37D481D5C110401" , vcvtps2ph(ptr(rcx, rdx, 0, 128), zmm3, 1)); + TEST_INSTRUCTION("62F37D481D5C110401" , vcvtps2ph(ymmword_ptr(rcx, rdx, 0, 128), zmm3, 1)); + TEST_INSTRUCTION("62F17D087BCA" , vcvtps2qq(xmm1, xmm2)); + TEST_INSTRUCTION("62F17D087B4C1A10" , vcvtps2qq(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F17D087B4C1A10" , vcvtps2qq(xmm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F17D287BCA" , vcvtps2qq(ymm1, xmm2)); + TEST_INSTRUCTION("62F17D287B4C1A08" , vcvtps2qq(ymm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F17D287B4C1A08" , vcvtps2qq(ymm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F17D487BCA" , vcvtps2qq(zmm1, ymm2)); + TEST_INSTRUCTION("62F17D487B4C1A04" , vcvtps2qq(zmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F17D487B4C1A04" , vcvtps2qq(zmm1, ymmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F17C0879CA" , vcvtps2udq(xmm1, xmm2)); + TEST_INSTRUCTION("62F17C08794C1A08" , vcvtps2udq(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F17C08794C1A08" , vcvtps2udq(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F17C2879CA" , vcvtps2udq(ymm1, ymm2)); + TEST_INSTRUCTION("62F17C28794C1A04" , vcvtps2udq(ymm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F17C28794C1A04" , vcvtps2udq(ymm1, ymmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F17C4879CA" , vcvtps2udq(zmm1, zmm2)); + TEST_INSTRUCTION("62F17C48794C1A02" , vcvtps2udq(zmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F17C48794C1A02" , vcvtps2udq(zmm1, zmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F17D0879CA" , vcvtps2uqq(xmm1, xmm2)); + TEST_INSTRUCTION("62F17D08794C1A10" , vcvtps2uqq(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F17D08794C1A10" , vcvtps2uqq(xmm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F17D2879CA" , vcvtps2uqq(ymm1, xmm2)); + TEST_INSTRUCTION("62F17D28794C1A08" , vcvtps2uqq(ymm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F17D28794C1A08" , vcvtps2uqq(ymm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F17D4879CA" , vcvtps2uqq(zmm1, ymm2)); + TEST_INSTRUCTION("62F17D48794C1A04" , vcvtps2uqq(zmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F17D48794C1A04" , vcvtps2uqq(zmm1, ymmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F1FE08E6CA" , vcvtqq2pd(xmm1, xmm2)); + TEST_INSTRUCTION("62F1FE08E64C1A08" , vcvtqq2pd(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F1FE08E64C1A08" , vcvtqq2pd(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F1FE28E6CA" , vcvtqq2pd(ymm1, ymm2)); + TEST_INSTRUCTION("62F1FE28E64C1A04" , vcvtqq2pd(ymm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F1FE28E64C1A04" , vcvtqq2pd(ymm1, ymmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F1FE48E6CA" , vcvtqq2pd(zmm1, zmm2)); + TEST_INSTRUCTION("62F1FE48E64C1A02" , vcvtqq2pd(zmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F1FE48E64C1A02" , vcvtqq2pd(zmm1, zmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F1FC085BCA" , vcvtqq2ps(xmm1, xmm2)); + TEST_INSTRUCTION("62F1FC285BCA" , vcvtqq2ps(xmm1, ymm2)); + TEST_INSTRUCTION("62F1FC085B4C1A08" , vcvtqq2ps(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F1FC285B4C1A04" , vcvtqq2ps(xmm1, ymmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F1FC485BCA" , vcvtqq2ps(ymm1, zmm2)); + TEST_INSTRUCTION("62F1FC485B4C1A02" , vcvtqq2ps(ymm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F1FC485B4C1A02" , vcvtqq2ps(ymm1, zmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C5FB2DCA" , vcvtsd2si(ecx, xmm2)); + TEST_INSTRUCTION("C5FB2D8C1A80000000" , vcvtsd2si(ecx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C5FB2D8C1A80000000" , vcvtsd2si(ecx, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C4E1FB2DCA" , vcvtsd2si(rcx, xmm2)); + TEST_INSTRUCTION("C4E1FB2D8C1A80000000" , vcvtsd2si(rcx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C4E1FB2D8C1A80000000" , vcvtsd2si(rcx, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C5EB5ACB" , vcvtsd2ss(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5EB5A8C2B80000000" , vcvtsd2ss(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5EB5A8C2B80000000" , vcvtsd2ss(xmm1, xmm2, qword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F17F0879CA" , vcvtsd2usi(ecx, xmm2)); + TEST_INSTRUCTION("62F17F08794C1A10" , vcvtsd2usi(ecx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F17F08794C1A10" , vcvtsd2usi(ecx, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F1FF0879CA" , vcvtsd2usi(rcx, xmm2)); + TEST_INSTRUCTION("62F1FF08794C1A10" , vcvtsd2usi(rcx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F1FF08794C1A10" , vcvtsd2usi(rcx, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C5EB2ACB" , vcvtsi2sd(xmm1, xmm2, ebx)); + TEST_INSTRUCTION("C4E1EB2ACB" , vcvtsi2sd(xmm1, xmm2, rbx)); + TEST_INSTRUCTION("C5EB2A8C2B80000000" , vcvtsi2sd(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5EB2A8C2B80000000" , vcvtsi2sd(xmm1, xmm2, dword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E1EB2A8C2B80000000" , vcvtsi2sd(xmm1, xmm2, qword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5EA2ACB" , vcvtsi2ss(xmm1, xmm2, ebx)); + TEST_INSTRUCTION("C4E1EA2ACB" , vcvtsi2ss(xmm1, xmm2, rbx)); + TEST_INSTRUCTION("C5EA2A8C2B80000000" , vcvtsi2ss(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5EA2A8C2B80000000" , vcvtsi2ss(xmm1, xmm2, dword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E1EA2A8C2B80000000" , vcvtsi2ss(xmm1, xmm2, qword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5EA5ACB" , vcvtss2sd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5EA5A8C2B80000000" , vcvtss2sd(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5EA5A8C2B80000000" , vcvtss2sd(xmm1, xmm2, dword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5FA2DCA" , vcvtss2si(ecx, xmm2)); + TEST_INSTRUCTION("C5FA2D8C1A80000000" , vcvtss2si(ecx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C5FA2D8C1A80000000" , vcvtss2si(ecx, dword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C4E1FA2DCA" , vcvtss2si(rcx, xmm2)); + TEST_INSTRUCTION("C4E1FA2D8C1A80000000" , vcvtss2si(rcx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C4E1FA2D8C1A80000000" , vcvtss2si(rcx, dword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F17E0879CA" , vcvtss2usi(ecx, xmm2)); + TEST_INSTRUCTION("62F17E08794C1A20" , vcvtss2usi(ecx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F17E08794C1A20" , vcvtss2usi(ecx, dword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F1FE0879CA" , vcvtss2usi(rcx, xmm2)); + TEST_INSTRUCTION("62F1FE08794C1A20" , vcvtss2usi(rcx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F1FE08794C1A20" , vcvtss2usi(rcx, dword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C5F9E6CA" , vcvttpd2dq(xmm1, xmm2)); + TEST_INSTRUCTION("C5FDE6CA" , vcvttpd2dq(xmm1, ymm2)); + TEST_INSTRUCTION("C5F9E68C1A80000000" , vcvttpd2dq(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C5FDE68C1A80000000" , vcvttpd2dq(xmm1, ymmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F1FD48E6CA" , vcvttpd2dq(ymm1, zmm2)); + TEST_INSTRUCTION("62F1FD48E64C1A02" , vcvttpd2dq(ymm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F1FD48E64C1A02" , vcvttpd2dq(ymm1, zmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F1FD087ACA" , vcvttpd2qq(xmm1, xmm2)); + TEST_INSTRUCTION("62F1FD087A4C1A08" , vcvttpd2qq(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F1FD087A4C1A08" , vcvttpd2qq(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F1FD287ACA" , vcvttpd2qq(ymm1, ymm2)); + TEST_INSTRUCTION("62F1FD287A4C1A04" , vcvttpd2qq(ymm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F1FD287A4C1A04" , vcvttpd2qq(ymm1, ymmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F1FD487ACA" , vcvttpd2qq(zmm1, zmm2)); + TEST_INSTRUCTION("62F1FD487A4C1A02" , vcvttpd2qq(zmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F1FD487A4C1A02" , vcvttpd2qq(zmm1, zmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F1FC0878CA" , vcvttpd2udq(xmm1, xmm2)); + TEST_INSTRUCTION("62F1FC2878CA" , vcvttpd2udq(xmm1, ymm2)); + TEST_INSTRUCTION("62F1FC08784C1A08" , vcvttpd2udq(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F1FC28784C1A04" , vcvttpd2udq(xmm1, ymmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F1FC4878CA" , vcvttpd2udq(ymm1, zmm2)); + TEST_INSTRUCTION("62F1FC48784C1A02" , vcvttpd2udq(ymm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F1FC48784C1A02" , vcvttpd2udq(ymm1, zmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F1FD0878CA" , vcvttpd2uqq(xmm1, xmm2)); + TEST_INSTRUCTION("62F1FD08784C1A08" , vcvttpd2uqq(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F1FD08784C1A08" , vcvttpd2uqq(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F1FD2878CA" , vcvttpd2uqq(ymm1, ymm2)); + TEST_INSTRUCTION("62F1FD28784C1A04" , vcvttpd2uqq(ymm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F1FD28784C1A04" , vcvttpd2uqq(ymm1, ymmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F1FD4878CA" , vcvttpd2uqq(zmm1, zmm2)); + TEST_INSTRUCTION("62F1FD48784C1A02" , vcvttpd2uqq(zmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F1FD48784C1A02" , vcvttpd2uqq(zmm1, zmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C5FA5BCA" , vcvttps2dq(xmm1, xmm2)); + TEST_INSTRUCTION("C5FA5B8C1A80000000" , vcvttps2dq(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C5FA5B8C1A80000000" , vcvttps2dq(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C5FE5BCA" , vcvttps2dq(ymm1, ymm2)); + TEST_INSTRUCTION("C5FE5B8C1A80000000" , vcvttps2dq(ymm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C5FE5B8C1A80000000" , vcvttps2dq(ymm1, ymmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F17E485BCA" , vcvttps2dq(zmm1, zmm2)); + TEST_INSTRUCTION("62F17E485B4C1A02" , vcvttps2dq(zmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F17E485B4C1A02" , vcvttps2dq(zmm1, zmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F17D087ACA" , vcvttps2qq(xmm1, xmm2)); + TEST_INSTRUCTION("62F17D087A4C1A10" , vcvttps2qq(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F17D087A4C1A10" , vcvttps2qq(xmm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F17D287ACA" , vcvttps2qq(ymm1, xmm2)); + TEST_INSTRUCTION("62F17D287A4C1A08" , vcvttps2qq(ymm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F17D287A4C1A08" , vcvttps2qq(ymm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F17D487ACA" , vcvttps2qq(zmm1, ymm2)); + TEST_INSTRUCTION("62F17D487A4C1A04" , vcvttps2qq(zmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F17D487A4C1A04" , vcvttps2qq(zmm1, ymmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F17C0878CA" , vcvttps2udq(xmm1, xmm2)); + TEST_INSTRUCTION("62F17C08784C1A08" , vcvttps2udq(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F17C08784C1A08" , vcvttps2udq(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F17C2878CA" , vcvttps2udq(ymm1, ymm2)); + TEST_INSTRUCTION("62F17C28784C1A04" , vcvttps2udq(ymm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F17C28784C1A04" , vcvttps2udq(ymm1, ymmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F17C4878CA" , vcvttps2udq(zmm1, zmm2)); + TEST_INSTRUCTION("62F17C48784C1A02" , vcvttps2udq(zmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F17C48784C1A02" , vcvttps2udq(zmm1, zmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F17D0878CA" , vcvttps2uqq(xmm1, xmm2)); + TEST_INSTRUCTION("62F17D08784C1A10" , vcvttps2uqq(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F17D08784C1A10" , vcvttps2uqq(xmm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F17D2878CA" , vcvttps2uqq(ymm1, xmm2)); + TEST_INSTRUCTION("62F17D28784C1A08" , vcvttps2uqq(ymm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F17D28784C1A08" , vcvttps2uqq(ymm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F17D4878CA" , vcvttps2uqq(zmm1, ymm2)); + TEST_INSTRUCTION("62F17D48784C1A04" , vcvttps2uqq(zmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F17D48784C1A04" , vcvttps2uqq(zmm1, ymmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C5FB2CCA" , vcvttsd2si(ecx, xmm2)); + TEST_INSTRUCTION("C5FB2C8C1A80000000" , vcvttsd2si(ecx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C5FB2C8C1A80000000" , vcvttsd2si(ecx, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C4E1FB2CCA" , vcvttsd2si(rcx, xmm2)); + TEST_INSTRUCTION("C4E1FB2C8C1A80000000" , vcvttsd2si(rcx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C4E1FB2C8C1A80000000" , vcvttsd2si(rcx, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F17F0878CA" , vcvttsd2usi(ecx, xmm2)); + TEST_INSTRUCTION("62F17F08784C1A10" , vcvttsd2usi(ecx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F17F08784C1A10" , vcvttsd2usi(ecx, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F1FF0878CA" , vcvttsd2usi(rcx, xmm2)); + TEST_INSTRUCTION("62F1FF08784C1A10" , vcvttsd2usi(rcx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F1FF08784C1A10" , vcvttsd2usi(rcx, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C5FA2CCA" , vcvttss2si(ecx, xmm2)); + TEST_INSTRUCTION("C5FA2C8C1A80000000" , vcvttss2si(ecx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C5FA2C8C1A80000000" , vcvttss2si(ecx, dword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C4E1FA2CCA" , vcvttss2si(rcx, xmm2)); + TEST_INSTRUCTION("C4E1FA2C8C1A80000000" , vcvttss2si(rcx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C4E1FA2C8C1A80000000" , vcvttss2si(rcx, dword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F17E0878CA" , vcvttss2usi(ecx, xmm2)); + TEST_INSTRUCTION("62F17E08784C1A20" , vcvttss2usi(ecx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F17E08784C1A20" , vcvttss2usi(ecx, dword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F1FE0878CA" , vcvttss2usi(rcx, xmm2)); + TEST_INSTRUCTION("62F1FE08784C1A20" , vcvttss2usi(rcx, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F1FE08784C1A20" , vcvttss2usi(rcx, dword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F17E087ACA" , vcvtudq2pd(xmm1, xmm2)); + TEST_INSTRUCTION("62F17E087A4C1A10" , vcvtudq2pd(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F17E087A4C1A10" , vcvtudq2pd(xmm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F17E287ACA" , vcvtudq2pd(ymm1, xmm2)); + TEST_INSTRUCTION("62F17E287A4C1A08" , vcvtudq2pd(ymm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F17E287A4C1A08" , vcvtudq2pd(ymm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F17E487ACA" , vcvtudq2pd(zmm1, ymm2)); + TEST_INSTRUCTION("62F17E487A4C1A04" , vcvtudq2pd(zmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F17E487A4C1A04" , vcvtudq2pd(zmm1, ymmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F17F087ACA" , vcvtudq2ps(xmm1, xmm2)); + TEST_INSTRUCTION("62F17F087A4C1A08" , vcvtudq2ps(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F17F087A4C1A08" , vcvtudq2ps(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F17F287ACA" , vcvtudq2ps(ymm1, ymm2)); + TEST_INSTRUCTION("62F17F287A4C1A04" , vcvtudq2ps(ymm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F17F287A4C1A04" , vcvtudq2ps(ymm1, ymmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F17F487ACA" , vcvtudq2ps(zmm1, zmm2)); + TEST_INSTRUCTION("62F17F487A4C1A02" , vcvtudq2ps(zmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F17F487A4C1A02" , vcvtudq2ps(zmm1, zmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F1FE087ACA" , vcvtuqq2pd(xmm1, xmm2)); + TEST_INSTRUCTION("62F1FE087A4C1A08" , vcvtuqq2pd(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F1FE087A4C1A08" , vcvtuqq2pd(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F1FE287ACA" , vcvtuqq2pd(ymm1, ymm2)); + TEST_INSTRUCTION("62F1FE287A4C1A04" , vcvtuqq2pd(ymm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F1FE287A4C1A04" , vcvtuqq2pd(ymm1, ymmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F1FE487ACA" , vcvtuqq2pd(zmm1, zmm2)); + TEST_INSTRUCTION("62F1FE487A4C1A02" , vcvtuqq2pd(zmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F1FE487A4C1A02" , vcvtuqq2pd(zmm1, zmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F1FF087ACA" , vcvtuqq2ps(xmm1, xmm2)); + TEST_INSTRUCTION("62F1FF287ACA" , vcvtuqq2ps(xmm1, ymm2)); + TEST_INSTRUCTION("62F1FF087A4C1A08" , vcvtuqq2ps(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F1FF287A4C1A04" , vcvtuqq2ps(xmm1, ymmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F1FF487ACA" , vcvtuqq2ps(ymm1, zmm2)); + TEST_INSTRUCTION("62F1FF487A4C1A02" , vcvtuqq2ps(ymm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F1FF487A4C1A02" , vcvtuqq2ps(ymm1, zmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F16F087BCB" , vcvtusi2sd(xmm1, xmm2, ebx)); + TEST_INSTRUCTION("62F1EF087BCB" , vcvtusi2sd(xmm1, xmm2, rbx)); + TEST_INSTRUCTION("62F16F087B4C2B20" , vcvtusi2sd(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16F087B4C2B20" , vcvtusi2sd(xmm1, xmm2, dword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F1EF087B4C2B10" , vcvtusi2sd(xmm1, xmm2, qword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16E087BCB" , vcvtusi2ss(xmm1, xmm2, ebx)); + TEST_INSTRUCTION("62F1EE087BCB" , vcvtusi2ss(xmm1, xmm2, rbx)); + TEST_INSTRUCTION("62F16E087B4C2B20" , vcvtusi2ss(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16E087B4C2B20" , vcvtusi2ss(xmm1, xmm2, dword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F1EE087B4C2B10" , vcvtusi2ss(xmm1, xmm2, qword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F36D0842CB01" , vdbpsadbw(xmm1, xmm2, xmm3, 1)); + TEST_INSTRUCTION("62F36D08424C2B0801" , vdbpsadbw(xmm1, xmm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D08424C2B0801" , vdbpsadbw(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D2842CB01" , vdbpsadbw(ymm1, ymm2, ymm3, 1)); + TEST_INSTRUCTION("62F36D28424C2B0401" , vdbpsadbw(ymm1, ymm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D28424C2B0401" , vdbpsadbw(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D4842CB01" , vdbpsadbw(zmm1, zmm2, zmm3, 1)); + TEST_INSTRUCTION("62F36D48424C2B0201" , vdbpsadbw(zmm1, zmm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D48424C2B0201" , vdbpsadbw(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("C5E95ECB" , vdivpd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5E95E8C2B80000000" , vdivpd(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5E95E8C2B80000000" , vdivpd(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5ED5ECB" , vdivpd(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C5ED5E8C2B80000000" , vdivpd(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5ED5E8C2B80000000" , vdivpd(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F1ED485ECB" , vdivpd(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F1ED485E4C2B02" , vdivpd(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F1ED485E4C2B02" , vdivpd(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5E85ECB" , vdivps(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5E85E8C2B80000000" , vdivps(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5E85E8C2B80000000" , vdivps(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5EC5ECB" , vdivps(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C5EC5E8C2B80000000" , vdivps(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5EC5E8C2B80000000" , vdivps(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16C485ECB" , vdivps(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F16C485E4C2B02" , vdivps(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16C485E4C2B02" , vdivps(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5EB5ECB" , vdivsd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5EB5E8C2B80000000" , vdivsd(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5EB5E8C2B80000000" , vdivsd(xmm1, xmm2, qword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5EA5ECB" , vdivss(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5EA5E8C2B80000000" , vdivss(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5EA5E8C2B80000000" , vdivss(xmm1, xmm2, dword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26E0852CB" , vdpbf16ps(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("62F26E08524C2B08" , vdpbf16ps(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26E08524C2B08" , vdpbf16ps(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26E2852CB" , vdpbf16ps(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("62F26E28524C2B04" , vdpbf16ps(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26E28524C2B04" , vdpbf16ps(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26E4852CB" , vdpbf16ps(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F26E48524C2B02" , vdpbf16ps(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26E48524C2B02" , vdpbf16ps(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E36941CB01" , vdppd(xmm1, xmm2, xmm3, 1)); + TEST_INSTRUCTION("C4E369418C2B8000000001" , vdppd(xmm1, xmm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("C4E369418C2B8000000001" , vdppd(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("C4E36940CB01" , vdpps(xmm1, xmm2, xmm3, 1)); + TEST_INSTRUCTION("C4E369408C2B8000000001" , vdpps(xmm1, xmm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("C4E369408C2B8000000001" , vdpps(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("C4E36D40CB01" , vdpps(ymm1, ymm2, ymm3, 1)); + TEST_INSTRUCTION("C4E36D408C2B8000000001" , vdpps(ymm1, ymm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("C4E36D408C2B8000000001" , vdpps(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F2FD48C8CA" , vexp2pd(zmm1, zmm2)); + TEST_INSTRUCTION("62F2FD48C84C1A02" , vexp2pd(zmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F2FD48C84C1A02" , vexp2pd(zmm1, zmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F27D48C8CA" , vexp2ps(zmm1, zmm2)); + TEST_INSTRUCTION("62F27D48C84C1A02" , vexp2ps(zmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F27D48C84C1A02" , vexp2ps(zmm1, zmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F2FD0888CA" , vexpandpd(xmm1, xmm2)); + TEST_INSTRUCTION("62F2FD08884C1A10" , vexpandpd(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F2FD08884C1A10" , vexpandpd(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F2FD2888CA" , vexpandpd(ymm1, ymm2)); + TEST_INSTRUCTION("62F2FD28884C1A10" , vexpandpd(ymm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F2FD28884C1A10" , vexpandpd(ymm1, ymmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F2FD4888CA" , vexpandpd(zmm1, zmm2)); + TEST_INSTRUCTION("62F2FD48884C1A10" , vexpandpd(zmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F2FD48884C1A10" , vexpandpd(zmm1, zmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F27D0888CA" , vexpandps(xmm1, xmm2)); + TEST_INSTRUCTION("62F27D08884C1A20" , vexpandps(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F27D08884C1A20" , vexpandps(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F27D2888CA" , vexpandps(ymm1, ymm2)); + TEST_INSTRUCTION("62F27D28884C1A20" , vexpandps(ymm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F27D28884C1A20" , vexpandps(ymm1, ymmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F27D4888CA" , vexpandps(zmm1, zmm2)); + TEST_INSTRUCTION("62F27D48884C1A20" , vexpandps(zmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F27D48884C1A20" , vexpandps(zmm1, zmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C4E37D19D101" , vextractf128(xmm1, ymm2, 1)); + TEST_INSTRUCTION("C4E37D199C118000000001" , vextractf128(ptr(rcx, rdx, 0, 128), ymm3, 1)); + TEST_INSTRUCTION("C4E37D199C118000000001" , vextractf128(xmmword_ptr(rcx, rdx, 0, 128), ymm3, 1)); + TEST_INSTRUCTION("62F37D2819D101" , vextractf32x4(xmm1, ymm2, 1)); + TEST_INSTRUCTION("62F37D4819D101" , vextractf32x4(xmm1, zmm2, 1)); + TEST_INSTRUCTION("62F37D28195C110801" , vextractf32x4(ptr(rcx, rdx, 0, 128), ymm3, 1)); + TEST_INSTRUCTION("62F37D48195C110801" , vextractf32x4(ptr(rcx, rdx, 0, 128), zmm3, 1)); + TEST_INSTRUCTION("62F37D28195C110801" , vextractf32x4(xmmword_ptr(rcx, rdx, 0, 128), ymm3, 1)); + TEST_INSTRUCTION("62F37D48195C110801" , vextractf32x4(xmmword_ptr(rcx, rdx, 0, 128), zmm3, 1)); + TEST_INSTRUCTION("62F37D481BD101" , vextractf32x8(ymm1, zmm2, 1)); + TEST_INSTRUCTION("62F37D481B5C110401" , vextractf32x8(ptr(rcx, rdx, 0, 128), zmm3, 1)); + TEST_INSTRUCTION("62F37D481B5C110401" , vextractf32x8(ymmword_ptr(rcx, rdx, 0, 128), zmm3, 1)); + TEST_INSTRUCTION("62F3FD2819D101" , vextractf64x2(xmm1, ymm2, 1)); + TEST_INSTRUCTION("62F3FD4819D101" , vextractf64x2(xmm1, zmm2, 1)); + TEST_INSTRUCTION("62F3FD28195C110801" , vextractf64x2(ptr(rcx, rdx, 0, 128), ymm3, 1)); + TEST_INSTRUCTION("62F3FD48195C110801" , vextractf64x2(ptr(rcx, rdx, 0, 128), zmm3, 1)); + TEST_INSTRUCTION("62F3FD28195C110801" , vextractf64x2(xmmword_ptr(rcx, rdx, 0, 128), ymm3, 1)); + TEST_INSTRUCTION("62F3FD48195C110801" , vextractf64x2(xmmword_ptr(rcx, rdx, 0, 128), zmm3, 1)); + TEST_INSTRUCTION("62F3FD481BD101" , vextractf64x4(ymm1, zmm2, 1)); + TEST_INSTRUCTION("62F3FD481B5C110401" , vextractf64x4(ptr(rcx, rdx, 0, 128), zmm3, 1)); + TEST_INSTRUCTION("62F3FD481B5C110401" , vextractf64x4(ymmword_ptr(rcx, rdx, 0, 128), zmm3, 1)); + TEST_INSTRUCTION("C4E37D39D101" , vextracti128(xmm1, ymm2, 1)); + TEST_INSTRUCTION("C4E37D399C118000000001" , vextracti128(ptr(rcx, rdx, 0, 128), ymm3, 1)); + TEST_INSTRUCTION("C4E37D399C118000000001" , vextracti128(xmmword_ptr(rcx, rdx, 0, 128), ymm3, 1)); + TEST_INSTRUCTION("62F37D2839D101" , vextracti32x4(xmm1, ymm2, 1)); + TEST_INSTRUCTION("62F37D4839D101" , vextracti32x4(xmm1, zmm2, 1)); + TEST_INSTRUCTION("62F37D28395C110801" , vextracti32x4(ptr(rcx, rdx, 0, 128), ymm3, 1)); + TEST_INSTRUCTION("62F37D48395C110801" , vextracti32x4(ptr(rcx, rdx, 0, 128), zmm3, 1)); + TEST_INSTRUCTION("62F37D28395C110801" , vextracti32x4(xmmword_ptr(rcx, rdx, 0, 128), ymm3, 1)); + TEST_INSTRUCTION("62F37D48395C110801" , vextracti32x4(xmmword_ptr(rcx, rdx, 0, 128), zmm3, 1)); + TEST_INSTRUCTION("62F37D483BD101" , vextracti32x8(ymm1, zmm2, 1)); + TEST_INSTRUCTION("62F37D483B5C110401" , vextracti32x8(ptr(rcx, rdx, 0, 128), zmm3, 1)); + TEST_INSTRUCTION("62F37D483B5C110401" , vextracti32x8(ymmword_ptr(rcx, rdx, 0, 128), zmm3, 1)); + TEST_INSTRUCTION("62F3FD2839D101" , vextracti64x2(xmm1, ymm2, 1)); + TEST_INSTRUCTION("62F3FD4839D101" , vextracti64x2(xmm1, zmm2, 1)); + TEST_INSTRUCTION("62F3FD28395C110801" , vextracti64x2(ptr(rcx, rdx, 0, 128), ymm3, 1)); + TEST_INSTRUCTION("62F3FD48395C110801" , vextracti64x2(ptr(rcx, rdx, 0, 128), zmm3, 1)); + TEST_INSTRUCTION("62F3FD28395C110801" , vextracti64x2(xmmword_ptr(rcx, rdx, 0, 128), ymm3, 1)); + TEST_INSTRUCTION("62F3FD48395C110801" , vextracti64x2(xmmword_ptr(rcx, rdx, 0, 128), zmm3, 1)); + TEST_INSTRUCTION("62F3FD483BD101" , vextracti64x4(ymm1, zmm2, 1)); + TEST_INSTRUCTION("62F3FD483B5C110401" , vextracti64x4(ptr(rcx, rdx, 0, 128), zmm3, 1)); + TEST_INSTRUCTION("62F3FD483B5C110401" , vextracti64x4(ymmword_ptr(rcx, rdx, 0, 128), zmm3, 1)); + TEST_INSTRUCTION("C4E37917D101" , vextractps(ecx, xmm2, 1)); + TEST_INSTRUCTION("C4E379179C118000000001" , vextractps(ptr(rcx, rdx, 0, 128), xmm3, 1)); + TEST_INSTRUCTION("C4E379179C118000000001" , vextractps(dword_ptr(rcx, rdx, 0, 128), xmm3, 1)); + TEST_INSTRUCTION("62F3ED0854CB01" , vfixupimmpd(xmm1, xmm2, xmm3, 1)); + TEST_INSTRUCTION("62F3ED08544C2B0801" , vfixupimmpd(xmm1, xmm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED08544C2B0801" , vfixupimmpd(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED2854CB01" , vfixupimmpd(ymm1, ymm2, ymm3, 1)); + TEST_INSTRUCTION("62F3ED28544C2B0401" , vfixupimmpd(ymm1, ymm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED28544C2B0401" , vfixupimmpd(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED4854CB01" , vfixupimmpd(zmm1, zmm2, zmm3, 1)); + TEST_INSTRUCTION("62F3ED48544C2B0201" , vfixupimmpd(zmm1, zmm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED48544C2B0201" , vfixupimmpd(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D0854CB01" , vfixupimmps(xmm1, xmm2, xmm3, 1)); + TEST_INSTRUCTION("62F36D08544C2B0801" , vfixupimmps(xmm1, xmm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D08544C2B0801" , vfixupimmps(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D2854CB01" , vfixupimmps(ymm1, ymm2, ymm3, 1)); + TEST_INSTRUCTION("62F36D28544C2B0401" , vfixupimmps(ymm1, ymm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D28544C2B0401" , vfixupimmps(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D4854CB01" , vfixupimmps(zmm1, zmm2, zmm3, 1)); + TEST_INSTRUCTION("62F36D48544C2B0201" , vfixupimmps(zmm1, zmm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D48544C2B0201" , vfixupimmps(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED0855CB01" , vfixupimmsd(xmm1, xmm2, xmm3, 1)); + TEST_INSTRUCTION("62F3ED08554C2B1001" , vfixupimmsd(xmm1, xmm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED08554C2B1001" , vfixupimmsd(xmm1, xmm2, qword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D0855CB01" , vfixupimmss(xmm1, xmm2, xmm3, 1)); + TEST_INSTRUCTION("62F36D08554C2B2001" , vfixupimmss(xmm1, xmm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D08554C2B2001" , vfixupimmss(xmm1, xmm2, dword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("C4E2E998CB" , vfmadd132pd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E2E9988C2B80000000" , vfmadd132pd(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E2E9988C2B80000000" , vfmadd132pd(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E2ED98CB" , vfmadd132pd(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C4E2ED988C2B80000000" , vfmadd132pd(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E2ED988C2B80000000" , vfmadd132pd(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED4898CB" , vfmadd132pd(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F2ED48984C2B02" , vfmadd132pd(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED48984C2B02" , vfmadd132pd(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E26998CB" , vfmadd132ps(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E269988C2B80000000" , vfmadd132ps(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E269988C2B80000000" , vfmadd132ps(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E26D98CB" , vfmadd132ps(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C4E26D988C2B80000000" , vfmadd132ps(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E26D988C2B80000000" , vfmadd132ps(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D4898CB" , vfmadd132ps(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F26D48984C2B02" , vfmadd132ps(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D48984C2B02" , vfmadd132ps(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E2E999CB" , vfmadd132sd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E2E9998C2B80000000" , vfmadd132sd(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E2E9998C2B80000000" , vfmadd132sd(xmm1, xmm2, qword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E26999CB" , vfmadd132ss(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E269998C2B80000000" , vfmadd132ss(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E269998C2B80000000" , vfmadd132ss(xmm1, xmm2, dword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E2E9A8CB" , vfmadd213pd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E2E9A88C2B80000000" , vfmadd213pd(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E2E9A88C2B80000000" , vfmadd213pd(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E2EDA8CB" , vfmadd213pd(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C4E2EDA88C2B80000000" , vfmadd213pd(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E2EDA88C2B80000000" , vfmadd213pd(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED48A8CB" , vfmadd213pd(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F2ED48A84C2B02" , vfmadd213pd(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED48A84C2B02" , vfmadd213pd(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E269A8CB" , vfmadd213ps(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E269A88C2B80000000" , vfmadd213ps(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E269A88C2B80000000" , vfmadd213ps(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E26DA8CB" , vfmadd213ps(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C4E26DA88C2B80000000" , vfmadd213ps(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E26DA88C2B80000000" , vfmadd213ps(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D48A8CB" , vfmadd213ps(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F26D48A84C2B02" , vfmadd213ps(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D48A84C2B02" , vfmadd213ps(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E2E9A9CB" , vfmadd213sd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E2E9A98C2B80000000" , vfmadd213sd(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E2E9A98C2B80000000" , vfmadd213sd(xmm1, xmm2, qword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E269A9CB" , vfmadd213ss(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E269A98C2B80000000" , vfmadd213ss(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E269A98C2B80000000" , vfmadd213ss(xmm1, xmm2, dword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E2E9B8CB" , vfmadd231pd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E2E9B88C2B80000000" , vfmadd231pd(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E2E9B88C2B80000000" , vfmadd231pd(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E2EDB8CB" , vfmadd231pd(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C4E2EDB88C2B80000000" , vfmadd231pd(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E2EDB88C2B80000000" , vfmadd231pd(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED48B8CB" , vfmadd231pd(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F2ED48B84C2B02" , vfmadd231pd(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED48B84C2B02" , vfmadd231pd(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E269B8CB" , vfmadd231ps(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E269B88C2B80000000" , vfmadd231ps(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E269B88C2B80000000" , vfmadd231ps(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E26DB8CB" , vfmadd231ps(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C4E26DB88C2B80000000" , vfmadd231ps(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E26DB88C2B80000000" , vfmadd231ps(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D48B8CB" , vfmadd231ps(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F26D48B84C2B02" , vfmadd231ps(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D48B84C2B02" , vfmadd231ps(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E2E9B9CB" , vfmadd231sd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E2E9B98C2B80000000" , vfmadd231sd(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E2E9B98C2B80000000" , vfmadd231sd(xmm1, xmm2, qword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E269B9CB" , vfmadd231ss(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E269B98C2B80000000" , vfmadd231ss(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E269B98C2B80000000" , vfmadd231ss(xmm1, xmm2, dword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E3E969CC30" , vfmaddpd(xmm1, xmm2, xmm3, xmm4)); + TEST_INSTRUCTION("C4E3E9698C358000000030" , vfmaddpd(xmm1, xmm2, xmm3, ptr(rbp, rsi, 0, 128))); + TEST_INSTRUCTION("C4E3E9698C358000000030" , vfmaddpd(xmm1, xmm2, xmm3, xmmword_ptr(rbp, rsi, 0, 128))); + TEST_INSTRUCTION("C4E369698C2B8000000060" , vfmaddpd(xmm1, xmm2, ptr(rbx, rbp, 0, 128), xmm6)); + TEST_INSTRUCTION("C4E369698C2B8000000060" , vfmaddpd(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128), xmm6)); + TEST_INSTRUCTION("C4E3ED69CC30" , vfmaddpd(ymm1, ymm2, ymm3, ymm4)); + TEST_INSTRUCTION("C4E3ED698C358000000030" , vfmaddpd(ymm1, ymm2, ymm3, ptr(rbp, rsi, 0, 128))); + TEST_INSTRUCTION("C4E3ED698C358000000030" , vfmaddpd(ymm1, ymm2, ymm3, ymmword_ptr(rbp, rsi, 0, 128))); + TEST_INSTRUCTION("C4E36D698C2B8000000060" , vfmaddpd(ymm1, ymm2, ptr(rbx, rbp, 0, 128), ymm6)); + TEST_INSTRUCTION("C4E36D698C2B8000000060" , vfmaddpd(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128), ymm6)); + TEST_INSTRUCTION("C4E3E968CC30" , vfmaddps(xmm1, xmm2, xmm3, xmm4)); + TEST_INSTRUCTION("C4E3E9688C358000000030" , vfmaddps(xmm1, xmm2, xmm3, ptr(rbp, rsi, 0, 128))); + TEST_INSTRUCTION("C4E3E9688C358000000030" , vfmaddps(xmm1, xmm2, xmm3, xmmword_ptr(rbp, rsi, 0, 128))); + TEST_INSTRUCTION("C4E369688C2B8000000060" , vfmaddps(xmm1, xmm2, ptr(rbx, rbp, 0, 128), xmm6)); + TEST_INSTRUCTION("C4E369688C2B8000000060" , vfmaddps(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128), xmm6)); + TEST_INSTRUCTION("C4E3ED68CC30" , vfmaddps(ymm1, ymm2, ymm3, ymm4)); + TEST_INSTRUCTION("C4E3ED688C358000000030" , vfmaddps(ymm1, ymm2, ymm3, ptr(rbp, rsi, 0, 128))); + TEST_INSTRUCTION("C4E3ED688C358000000030" , vfmaddps(ymm1, ymm2, ymm3, ymmword_ptr(rbp, rsi, 0, 128))); + TEST_INSTRUCTION("C4E36D688C2B8000000060" , vfmaddps(ymm1, ymm2, ptr(rbx, rbp, 0, 128), ymm6)); + TEST_INSTRUCTION("C4E36D688C2B8000000060" , vfmaddps(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128), ymm6)); + TEST_INSTRUCTION("C4E3E96BCC30" , vfmaddsd(xmm1, xmm2, xmm3, xmm4)); + TEST_INSTRUCTION("C4E3E96B8C358000000030" , vfmaddsd(xmm1, xmm2, xmm3, ptr(rbp, rsi, 0, 128))); + TEST_INSTRUCTION("C4E3E96B8C358000000030" , vfmaddsd(xmm1, xmm2, xmm3, qword_ptr(rbp, rsi, 0, 128))); + TEST_INSTRUCTION("C4E3696B8C2B8000000060" , vfmaddsd(xmm1, xmm2, ptr(rbx, rbp, 0, 128), xmm6)); + TEST_INSTRUCTION("C4E3696B8C2B8000000060" , vfmaddsd(xmm1, xmm2, qword_ptr(rbx, rbp, 0, 128), xmm6)); + TEST_INSTRUCTION("C4E3E96ACC30" , vfmaddss(xmm1, xmm2, xmm3, xmm4)); + TEST_INSTRUCTION("C4E3E96A8C358000000030" , vfmaddss(xmm1, xmm2, xmm3, ptr(rbp, rsi, 0, 128))); + TEST_INSTRUCTION("C4E3E96A8C358000000030" , vfmaddss(xmm1, xmm2, xmm3, dword_ptr(rbp, rsi, 0, 128))); + TEST_INSTRUCTION("C4E3696A8C2B8000000060" , vfmaddss(xmm1, xmm2, ptr(rbx, rbp, 0, 128), xmm6)); + TEST_INSTRUCTION("C4E3696A8C2B8000000060" , vfmaddss(xmm1, xmm2, dword_ptr(rbx, rbp, 0, 128), xmm6)); + TEST_INSTRUCTION("C4E2E996CB" , vfmaddsub132pd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E2E9968C2B80000000" , vfmaddsub132pd(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E2E9968C2B80000000" , vfmaddsub132pd(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E2ED96CB" , vfmaddsub132pd(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C4E2ED968C2B80000000" , vfmaddsub132pd(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E2ED968C2B80000000" , vfmaddsub132pd(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED4896CB" , vfmaddsub132pd(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F2ED48964C2B02" , vfmaddsub132pd(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED48964C2B02" , vfmaddsub132pd(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E26996CB" , vfmaddsub132ps(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E269968C2B80000000" , vfmaddsub132ps(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E269968C2B80000000" , vfmaddsub132ps(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E26D96CB" , vfmaddsub132ps(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C4E26D968C2B80000000" , vfmaddsub132ps(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E26D968C2B80000000" , vfmaddsub132ps(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D4896CB" , vfmaddsub132ps(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F26D48964C2B02" , vfmaddsub132ps(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D48964C2B02" , vfmaddsub132ps(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E2E9A6CB" , vfmaddsub213pd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E2E9A68C2B80000000" , vfmaddsub213pd(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E2E9A68C2B80000000" , vfmaddsub213pd(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E2EDA6CB" , vfmaddsub213pd(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C4E2EDA68C2B80000000" , vfmaddsub213pd(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E2EDA68C2B80000000" , vfmaddsub213pd(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED48A6CB" , vfmaddsub213pd(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F2ED48A64C2B02" , vfmaddsub213pd(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED48A64C2B02" , vfmaddsub213pd(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E269A6CB" , vfmaddsub213ps(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E269A68C2B80000000" , vfmaddsub213ps(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E269A68C2B80000000" , vfmaddsub213ps(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E26DA6CB" , vfmaddsub213ps(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C4E26DA68C2B80000000" , vfmaddsub213ps(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E26DA68C2B80000000" , vfmaddsub213ps(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D48A6CB" , vfmaddsub213ps(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F26D48A64C2B02" , vfmaddsub213ps(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D48A64C2B02" , vfmaddsub213ps(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E2E9B6CB" , vfmaddsub231pd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E2E9B68C2B80000000" , vfmaddsub231pd(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E2E9B68C2B80000000" , vfmaddsub231pd(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E2EDB6CB" , vfmaddsub231pd(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C4E2EDB68C2B80000000" , vfmaddsub231pd(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E2EDB68C2B80000000" , vfmaddsub231pd(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED48B6CB" , vfmaddsub231pd(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F2ED48B64C2B02" , vfmaddsub231pd(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED48B64C2B02" , vfmaddsub231pd(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E269B6CB" , vfmaddsub231ps(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E269B68C2B80000000" , vfmaddsub231ps(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E269B68C2B80000000" , vfmaddsub231ps(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E26DB6CB" , vfmaddsub231ps(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C4E26DB68C2B80000000" , vfmaddsub231ps(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E26DB68C2B80000000" , vfmaddsub231ps(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D48B6CB" , vfmaddsub231ps(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F26D48B64C2B02" , vfmaddsub231ps(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D48B64C2B02" , vfmaddsub231ps(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E3E95DCC30" , vfmaddsubpd(xmm1, xmm2, xmm3, xmm4)); + TEST_INSTRUCTION("C4E3E95D8C358000000030" , vfmaddsubpd(xmm1, xmm2, xmm3, ptr(rbp, rsi, 0, 128))); + TEST_INSTRUCTION("C4E3E95D8C358000000030" , vfmaddsubpd(xmm1, xmm2, xmm3, xmmword_ptr(rbp, rsi, 0, 128))); + TEST_INSTRUCTION("C4E3695D8C2B8000000060" , vfmaddsubpd(xmm1, xmm2, ptr(rbx, rbp, 0, 128), xmm6)); + TEST_INSTRUCTION("C4E3695D8C2B8000000060" , vfmaddsubpd(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128), xmm6)); + TEST_INSTRUCTION("C4E3ED5DCC30" , vfmaddsubpd(ymm1, ymm2, ymm3, ymm4)); + TEST_INSTRUCTION("C4E3ED5D8C358000000030" , vfmaddsubpd(ymm1, ymm2, ymm3, ptr(rbp, rsi, 0, 128))); + TEST_INSTRUCTION("C4E3ED5D8C358000000030" , vfmaddsubpd(ymm1, ymm2, ymm3, ymmword_ptr(rbp, rsi, 0, 128))); + TEST_INSTRUCTION("C4E36D5D8C2B8000000060" , vfmaddsubpd(ymm1, ymm2, ptr(rbx, rbp, 0, 128), ymm6)); + TEST_INSTRUCTION("C4E36D5D8C2B8000000060" , vfmaddsubpd(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128), ymm6)); + TEST_INSTRUCTION("C4E3E95CCC30" , vfmaddsubps(xmm1, xmm2, xmm3, xmm4)); + TEST_INSTRUCTION("C4E3E95C8C358000000030" , vfmaddsubps(xmm1, xmm2, xmm3, ptr(rbp, rsi, 0, 128))); + TEST_INSTRUCTION("C4E3E95C8C358000000030" , vfmaddsubps(xmm1, xmm2, xmm3, xmmword_ptr(rbp, rsi, 0, 128))); + TEST_INSTRUCTION("C4E3695C8C2B8000000060" , vfmaddsubps(xmm1, xmm2, ptr(rbx, rbp, 0, 128), xmm6)); + TEST_INSTRUCTION("C4E3695C8C2B8000000060" , vfmaddsubps(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128), xmm6)); + TEST_INSTRUCTION("C4E3ED5CCC30" , vfmaddsubps(ymm1, ymm2, ymm3, ymm4)); + TEST_INSTRUCTION("C4E3ED5C8C358000000030" , vfmaddsubps(ymm1, ymm2, ymm3, ptr(rbp, rsi, 0, 128))); + TEST_INSTRUCTION("C4E3ED5C8C358000000030" , vfmaddsubps(ymm1, ymm2, ymm3, ymmword_ptr(rbp, rsi, 0, 128))); + TEST_INSTRUCTION("C4E36D5C8C2B8000000060" , vfmaddsubps(ymm1, ymm2, ptr(rbx, rbp, 0, 128), ymm6)); + TEST_INSTRUCTION("C4E36D5C8C2B8000000060" , vfmaddsubps(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128), ymm6)); + TEST_INSTRUCTION("C4E2E99ACB" , vfmsub132pd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E2E99A8C2B80000000" , vfmsub132pd(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E2E99A8C2B80000000" , vfmsub132pd(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E2ED9ACB" , vfmsub132pd(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C4E2ED9A8C2B80000000" , vfmsub132pd(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E2ED9A8C2B80000000" , vfmsub132pd(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED489ACB" , vfmsub132pd(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F2ED489A4C2B02" , vfmsub132pd(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED489A4C2B02" , vfmsub132pd(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E2699ACB" , vfmsub132ps(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E2699A8C2B80000000" , vfmsub132ps(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E2699A8C2B80000000" , vfmsub132ps(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E26D9ACB" , vfmsub132ps(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C4E26D9A8C2B80000000" , vfmsub132ps(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E26D9A8C2B80000000" , vfmsub132ps(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D489ACB" , vfmsub132ps(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F26D489A4C2B02" , vfmsub132ps(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D489A4C2B02" , vfmsub132ps(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E2E99BCB" , vfmsub132sd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E2E99B8C2B80000000" , vfmsub132sd(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E2E99B8C2B80000000" , vfmsub132sd(xmm1, xmm2, qword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E2699BCB" , vfmsub132ss(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E2699B8C2B80000000" , vfmsub132ss(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E2699B8C2B80000000" , vfmsub132ss(xmm1, xmm2, dword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E2E9AACB" , vfmsub213pd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E2E9AA8C2B80000000" , vfmsub213pd(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E2E9AA8C2B80000000" , vfmsub213pd(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E2EDAACB" , vfmsub213pd(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C4E2EDAA8C2B80000000" , vfmsub213pd(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E2EDAA8C2B80000000" , vfmsub213pd(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED48AACB" , vfmsub213pd(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F2ED48AA4C2B02" , vfmsub213pd(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED48AA4C2B02" , vfmsub213pd(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E269AACB" , vfmsub213ps(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E269AA8C2B80000000" , vfmsub213ps(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E269AA8C2B80000000" , vfmsub213ps(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E26DAACB" , vfmsub213ps(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C4E26DAA8C2B80000000" , vfmsub213ps(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E26DAA8C2B80000000" , vfmsub213ps(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D48AACB" , vfmsub213ps(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F26D48AA4C2B02" , vfmsub213ps(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D48AA4C2B02" , vfmsub213ps(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E2E9ABCB" , vfmsub213sd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E2E9AB8C2B80000000" , vfmsub213sd(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E2E9AB8C2B80000000" , vfmsub213sd(xmm1, xmm2, qword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E269ABCB" , vfmsub213ss(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E269AB8C2B80000000" , vfmsub213ss(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E269AB8C2B80000000" , vfmsub213ss(xmm1, xmm2, dword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E2E9BACB" , vfmsub231pd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E2E9BA8C2B80000000" , vfmsub231pd(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E2E9BA8C2B80000000" , vfmsub231pd(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E2EDBACB" , vfmsub231pd(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C4E2EDBA8C2B80000000" , vfmsub231pd(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E2EDBA8C2B80000000" , vfmsub231pd(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED48BACB" , vfmsub231pd(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F2ED48BA4C2B02" , vfmsub231pd(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED48BA4C2B02" , vfmsub231pd(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E269BACB" , vfmsub231ps(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E269BA8C2B80000000" , vfmsub231ps(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E269BA8C2B80000000" , vfmsub231ps(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E26DBACB" , vfmsub231ps(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C4E26DBA8C2B80000000" , vfmsub231ps(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E26DBA8C2B80000000" , vfmsub231ps(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D48BACB" , vfmsub231ps(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F26D48BA4C2B02" , vfmsub231ps(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D48BA4C2B02" , vfmsub231ps(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E2E9BBCB" , vfmsub231sd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E2E9BB8C2B80000000" , vfmsub231sd(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E2E9BB8C2B80000000" , vfmsub231sd(xmm1, xmm2, qword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E269BBCB" , vfmsub231ss(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E269BB8C2B80000000" , vfmsub231ss(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E269BB8C2B80000000" , vfmsub231ss(xmm1, xmm2, dword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E2E997CB" , vfmsubadd132pd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E2E9978C2B80000000" , vfmsubadd132pd(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E2E9978C2B80000000" , vfmsubadd132pd(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E2ED97CB" , vfmsubadd132pd(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C4E2ED978C2B80000000" , vfmsubadd132pd(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E2ED978C2B80000000" , vfmsubadd132pd(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED4897CB" , vfmsubadd132pd(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F2ED48974C2B02" , vfmsubadd132pd(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED48974C2B02" , vfmsubadd132pd(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E26997CB" , vfmsubadd132ps(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E269978C2B80000000" , vfmsubadd132ps(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E269978C2B80000000" , vfmsubadd132ps(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E26D97CB" , vfmsubadd132ps(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C4E26D978C2B80000000" , vfmsubadd132ps(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E26D978C2B80000000" , vfmsubadd132ps(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D4897CB" , vfmsubadd132ps(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F26D48974C2B02" , vfmsubadd132ps(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D48974C2B02" , vfmsubadd132ps(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E2E9A7CB" , vfmsubadd213pd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E2E9A78C2B80000000" , vfmsubadd213pd(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E2E9A78C2B80000000" , vfmsubadd213pd(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E2EDA7CB" , vfmsubadd213pd(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C4E2EDA78C2B80000000" , vfmsubadd213pd(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E2EDA78C2B80000000" , vfmsubadd213pd(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED48A7CB" , vfmsubadd213pd(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F2ED48A74C2B02" , vfmsubadd213pd(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED48A74C2B02" , vfmsubadd213pd(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E269A7CB" , vfmsubadd213ps(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E269A78C2B80000000" , vfmsubadd213ps(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E269A78C2B80000000" , vfmsubadd213ps(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E26DA7CB" , vfmsubadd213ps(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C4E26DA78C2B80000000" , vfmsubadd213ps(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E26DA78C2B80000000" , vfmsubadd213ps(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D48A7CB" , vfmsubadd213ps(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F26D48A74C2B02" , vfmsubadd213ps(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D48A74C2B02" , vfmsubadd213ps(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E2E9B7CB" , vfmsubadd231pd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E2E9B78C2B80000000" , vfmsubadd231pd(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E2E9B78C2B80000000" , vfmsubadd231pd(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E2EDB7CB" , vfmsubadd231pd(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C4E2EDB78C2B80000000" , vfmsubadd231pd(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E2EDB78C2B80000000" , vfmsubadd231pd(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED48B7CB" , vfmsubadd231pd(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F2ED48B74C2B02" , vfmsubadd231pd(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED48B74C2B02" , vfmsubadd231pd(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E269B7CB" , vfmsubadd231ps(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E269B78C2B80000000" , vfmsubadd231ps(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E269B78C2B80000000" , vfmsubadd231ps(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E26DB7CB" , vfmsubadd231ps(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C4E26DB78C2B80000000" , vfmsubadd231ps(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E26DB78C2B80000000" , vfmsubadd231ps(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D48B7CB" , vfmsubadd231ps(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F26D48B74C2B02" , vfmsubadd231ps(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D48B74C2B02" , vfmsubadd231ps(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E3E95FCC30" , vfmsubaddpd(xmm1, xmm2, xmm3, xmm4)); + TEST_INSTRUCTION("C4E3E95F8C358000000030" , vfmsubaddpd(xmm1, xmm2, xmm3, ptr(rbp, rsi, 0, 128))); + TEST_INSTRUCTION("C4E3E95F8C358000000030" , vfmsubaddpd(xmm1, xmm2, xmm3, xmmword_ptr(rbp, rsi, 0, 128))); + TEST_INSTRUCTION("C4E3695F8C2B8000000060" , vfmsubaddpd(xmm1, xmm2, ptr(rbx, rbp, 0, 128), xmm6)); + TEST_INSTRUCTION("C4E3695F8C2B8000000060" , vfmsubaddpd(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128), xmm6)); + TEST_INSTRUCTION("C4E3ED5FCC30" , vfmsubaddpd(ymm1, ymm2, ymm3, ymm4)); + TEST_INSTRUCTION("C4E3ED5F8C358000000030" , vfmsubaddpd(ymm1, ymm2, ymm3, ptr(rbp, rsi, 0, 128))); + TEST_INSTRUCTION("C4E3ED5F8C358000000030" , vfmsubaddpd(ymm1, ymm2, ymm3, ymmword_ptr(rbp, rsi, 0, 128))); + TEST_INSTRUCTION("C4E36D5F8C2B8000000060" , vfmsubaddpd(ymm1, ymm2, ptr(rbx, rbp, 0, 128), ymm6)); + TEST_INSTRUCTION("C4E36D5F8C2B8000000060" , vfmsubaddpd(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128), ymm6)); + TEST_INSTRUCTION("C4E3E95ECC30" , vfmsubaddps(xmm1, xmm2, xmm3, xmm4)); + TEST_INSTRUCTION("C4E3E95E8C358000000030" , vfmsubaddps(xmm1, xmm2, xmm3, ptr(rbp, rsi, 0, 128))); + TEST_INSTRUCTION("C4E3E95E8C358000000030" , vfmsubaddps(xmm1, xmm2, xmm3, xmmword_ptr(rbp, rsi, 0, 128))); + TEST_INSTRUCTION("C4E3695E8C2B8000000060" , vfmsubaddps(xmm1, xmm2, ptr(rbx, rbp, 0, 128), xmm6)); + TEST_INSTRUCTION("C4E3695E8C2B8000000060" , vfmsubaddps(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128), xmm6)); + TEST_INSTRUCTION("C4E3ED5ECC30" , vfmsubaddps(ymm1, ymm2, ymm3, ymm4)); + TEST_INSTRUCTION("C4E3ED5E8C358000000030" , vfmsubaddps(ymm1, ymm2, ymm3, ptr(rbp, rsi, 0, 128))); + TEST_INSTRUCTION("C4E3ED5E8C358000000030" , vfmsubaddps(ymm1, ymm2, ymm3, ymmword_ptr(rbp, rsi, 0, 128))); + TEST_INSTRUCTION("C4E36D5E8C2B8000000060" , vfmsubaddps(ymm1, ymm2, ptr(rbx, rbp, 0, 128), ymm6)); + TEST_INSTRUCTION("C4E36D5E8C2B8000000060" , vfmsubaddps(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128), ymm6)); + TEST_INSTRUCTION("C4E3E96DCC30" , vfmsubpd(xmm1, xmm2, xmm3, xmm4)); + TEST_INSTRUCTION("C4E3E96D8C358000000030" , vfmsubpd(xmm1, xmm2, xmm3, ptr(rbp, rsi, 0, 128))); + TEST_INSTRUCTION("C4E3E96D8C358000000030" , vfmsubpd(xmm1, xmm2, xmm3, xmmword_ptr(rbp, rsi, 0, 128))); + TEST_INSTRUCTION("C4E3696D8C2B8000000060" , vfmsubpd(xmm1, xmm2, ptr(rbx, rbp, 0, 128), xmm6)); + TEST_INSTRUCTION("C4E3696D8C2B8000000060" , vfmsubpd(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128), xmm6)); + TEST_INSTRUCTION("C4E3ED6DCC30" , vfmsubpd(ymm1, ymm2, ymm3, ymm4)); + TEST_INSTRUCTION("C4E3ED6D8C358000000030" , vfmsubpd(ymm1, ymm2, ymm3, ptr(rbp, rsi, 0, 128))); + TEST_INSTRUCTION("C4E3ED6D8C358000000030" , vfmsubpd(ymm1, ymm2, ymm3, ymmword_ptr(rbp, rsi, 0, 128))); + TEST_INSTRUCTION("C4E36D6D8C2B8000000060" , vfmsubpd(ymm1, ymm2, ptr(rbx, rbp, 0, 128), ymm6)); + TEST_INSTRUCTION("C4E36D6D8C2B8000000060" , vfmsubpd(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128), ymm6)); + TEST_INSTRUCTION("C4E3E96CCC30" , vfmsubps(xmm1, xmm2, xmm3, xmm4)); + TEST_INSTRUCTION("C4E3E96C8C358000000030" , vfmsubps(xmm1, xmm2, xmm3, ptr(rbp, rsi, 0, 128))); + TEST_INSTRUCTION("C4E3E96C8C358000000030" , vfmsubps(xmm1, xmm2, xmm3, xmmword_ptr(rbp, rsi, 0, 128))); + TEST_INSTRUCTION("C4E3696C8C2B8000000060" , vfmsubps(xmm1, xmm2, ptr(rbx, rbp, 0, 128), xmm6)); + TEST_INSTRUCTION("C4E3696C8C2B8000000060" , vfmsubps(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128), xmm6)); + TEST_INSTRUCTION("C4E3ED6CCC30" , vfmsubps(ymm1, ymm2, ymm3, ymm4)); + TEST_INSTRUCTION("C4E3ED6C8C358000000030" , vfmsubps(ymm1, ymm2, ymm3, ptr(rbp, rsi, 0, 128))); + TEST_INSTRUCTION("C4E3ED6C8C358000000030" , vfmsubps(ymm1, ymm2, ymm3, ymmword_ptr(rbp, rsi, 0, 128))); + TEST_INSTRUCTION("C4E36D6C8C2B8000000060" , vfmsubps(ymm1, ymm2, ptr(rbx, rbp, 0, 128), ymm6)); + TEST_INSTRUCTION("C4E36D6C8C2B8000000060" , vfmsubps(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128), ymm6)); + TEST_INSTRUCTION("C4E3E96FCC30" , vfmsubsd(xmm1, xmm2, xmm3, xmm4)); + TEST_INSTRUCTION("C4E3E96F8C358000000030" , vfmsubsd(xmm1, xmm2, xmm3, ptr(rbp, rsi, 0, 128))); + TEST_INSTRUCTION("C4E3E96F8C358000000030" , vfmsubsd(xmm1, xmm2, xmm3, qword_ptr(rbp, rsi, 0, 128))); + TEST_INSTRUCTION("C4E3696F8C2B8000000060" , vfmsubsd(xmm1, xmm2, ptr(rbx, rbp, 0, 128), xmm6)); + TEST_INSTRUCTION("C4E3696F8C2B8000000060" , vfmsubsd(xmm1, xmm2, qword_ptr(rbx, rbp, 0, 128), xmm6)); + TEST_INSTRUCTION("C4E3E96ECC30" , vfmsubss(xmm1, xmm2, xmm3, xmm4)); + TEST_INSTRUCTION("C4E3E96E8C358000000030" , vfmsubss(xmm1, xmm2, xmm3, ptr(rbp, rsi, 0, 128))); + TEST_INSTRUCTION("C4E3E96E8C358000000030" , vfmsubss(xmm1, xmm2, xmm3, dword_ptr(rbp, rsi, 0, 128))); + TEST_INSTRUCTION("C4E3696E8C2B8000000060" , vfmsubss(xmm1, xmm2, ptr(rbx, rbp, 0, 128), xmm6)); + TEST_INSTRUCTION("C4E3696E8C2B8000000060" , vfmsubss(xmm1, xmm2, dword_ptr(rbx, rbp, 0, 128), xmm6)); + TEST_INSTRUCTION("C4E2E99CCB" , vfnmadd132pd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E2E99C8C2B80000000" , vfnmadd132pd(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E2E99C8C2B80000000" , vfnmadd132pd(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E2ED9CCB" , vfnmadd132pd(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C4E2ED9C8C2B80000000" , vfnmadd132pd(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E2ED9C8C2B80000000" , vfnmadd132pd(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED489CCB" , vfnmadd132pd(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F2ED489C4C2B02" , vfnmadd132pd(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED489C4C2B02" , vfnmadd132pd(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E2699CCB" , vfnmadd132ps(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E2699C8C2B80000000" , vfnmadd132ps(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E2699C8C2B80000000" , vfnmadd132ps(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E26D9CCB" , vfnmadd132ps(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C4E26D9C8C2B80000000" , vfnmadd132ps(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E26D9C8C2B80000000" , vfnmadd132ps(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D489CCB" , vfnmadd132ps(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F26D489C4C2B02" , vfnmadd132ps(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D489C4C2B02" , vfnmadd132ps(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E2E99DCB" , vfnmadd132sd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E2E99D8C2B80000000" , vfnmadd132sd(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E2E99D8C2B80000000" , vfnmadd132sd(xmm1, xmm2, qword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E2699DCB" , vfnmadd132ss(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E2699D8C2B80000000" , vfnmadd132ss(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E2699D8C2B80000000" , vfnmadd132ss(xmm1, xmm2, dword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E2E9ACCB" , vfnmadd213pd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E2E9AC8C2B80000000" , vfnmadd213pd(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E2E9AC8C2B80000000" , vfnmadd213pd(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E2EDACCB" , vfnmadd213pd(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C4E2EDAC8C2B80000000" , vfnmadd213pd(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E2EDAC8C2B80000000" , vfnmadd213pd(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED48ACCB" , vfnmadd213pd(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F2ED48AC4C2B02" , vfnmadd213pd(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED48AC4C2B02" , vfnmadd213pd(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E269ACCB" , vfnmadd213ps(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E269AC8C2B80000000" , vfnmadd213ps(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E269AC8C2B80000000" , vfnmadd213ps(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E26DACCB" , vfnmadd213ps(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C4E26DAC8C2B80000000" , vfnmadd213ps(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E26DAC8C2B80000000" , vfnmadd213ps(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D48ACCB" , vfnmadd213ps(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F26D48AC4C2B02" , vfnmadd213ps(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D48AC4C2B02" , vfnmadd213ps(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E2E9ADCB" , vfnmadd213sd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E2E9AD8C2B80000000" , vfnmadd213sd(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E2E9AD8C2B80000000" , vfnmadd213sd(xmm1, xmm2, qword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E269ADCB" , vfnmadd213ss(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E269AD8C2B80000000" , vfnmadd213ss(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E269AD8C2B80000000" , vfnmadd213ss(xmm1, xmm2, dword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E2E9BCCB" , vfnmadd231pd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E2E9BC8C2B80000000" , vfnmadd231pd(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E2E9BC8C2B80000000" , vfnmadd231pd(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E2EDBCCB" , vfnmadd231pd(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C4E2EDBC8C2B80000000" , vfnmadd231pd(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E2EDBC8C2B80000000" , vfnmadd231pd(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED48BCCB" , vfnmadd231pd(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F2ED48BC4C2B02" , vfnmadd231pd(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED48BC4C2B02" , vfnmadd231pd(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E269BCCB" , vfnmadd231ps(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E269BC8C2B80000000" , vfnmadd231ps(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E269BC8C2B80000000" , vfnmadd231ps(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E26DBCCB" , vfnmadd231ps(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C4E26DBC8C2B80000000" , vfnmadd231ps(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E26DBC8C2B80000000" , vfnmadd231ps(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D48BCCB" , vfnmadd231ps(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F26D48BC4C2B02" , vfnmadd231ps(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D48BC4C2B02" , vfnmadd231ps(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E2E9BDCB" , vfnmadd231sd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E2E9BD8C2B80000000" , vfnmadd231sd(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E2E9BD8C2B80000000" , vfnmadd231sd(xmm1, xmm2, qword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E269BDCB" , vfnmadd231ss(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E269BD8C2B80000000" , vfnmadd231ss(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E269BD8C2B80000000" , vfnmadd231ss(xmm1, xmm2, dword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E3E979CC30" , vfnmaddpd(xmm1, xmm2, xmm3, xmm4)); + TEST_INSTRUCTION("C4E3E9798C358000000030" , vfnmaddpd(xmm1, xmm2, xmm3, ptr(rbp, rsi, 0, 128))); + TEST_INSTRUCTION("C4E3E9798C358000000030" , vfnmaddpd(xmm1, xmm2, xmm3, xmmword_ptr(rbp, rsi, 0, 128))); + TEST_INSTRUCTION("C4E369798C2B8000000060" , vfnmaddpd(xmm1, xmm2, ptr(rbx, rbp, 0, 128), xmm6)); + TEST_INSTRUCTION("C4E369798C2B8000000060" , vfnmaddpd(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128), xmm6)); + TEST_INSTRUCTION("C4E3ED79CC30" , vfnmaddpd(ymm1, ymm2, ymm3, ymm4)); + TEST_INSTRUCTION("C4E3ED798C358000000030" , vfnmaddpd(ymm1, ymm2, ymm3, ptr(rbp, rsi, 0, 128))); + TEST_INSTRUCTION("C4E3ED798C358000000030" , vfnmaddpd(ymm1, ymm2, ymm3, ymmword_ptr(rbp, rsi, 0, 128))); + TEST_INSTRUCTION("C4E36D798C2B8000000060" , vfnmaddpd(ymm1, ymm2, ptr(rbx, rbp, 0, 128), ymm6)); + TEST_INSTRUCTION("C4E36D798C2B8000000060" , vfnmaddpd(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128), ymm6)); + TEST_INSTRUCTION("C4E3E978CC30" , vfnmaddps(xmm1, xmm2, xmm3, xmm4)); + TEST_INSTRUCTION("C4E3E9788C358000000030" , vfnmaddps(xmm1, xmm2, xmm3, ptr(rbp, rsi, 0, 128))); + TEST_INSTRUCTION("C4E3E9788C358000000030" , vfnmaddps(xmm1, xmm2, xmm3, xmmword_ptr(rbp, rsi, 0, 128))); + TEST_INSTRUCTION("C4E369788C2B8000000060" , vfnmaddps(xmm1, xmm2, ptr(rbx, rbp, 0, 128), xmm6)); + TEST_INSTRUCTION("C4E369788C2B8000000060" , vfnmaddps(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128), xmm6)); + TEST_INSTRUCTION("C4E3ED78CC30" , vfnmaddps(ymm1, ymm2, ymm3, ymm4)); + TEST_INSTRUCTION("C4E3ED788C358000000030" , vfnmaddps(ymm1, ymm2, ymm3, ptr(rbp, rsi, 0, 128))); + TEST_INSTRUCTION("C4E3ED788C358000000030" , vfnmaddps(ymm1, ymm2, ymm3, ymmword_ptr(rbp, rsi, 0, 128))); + TEST_INSTRUCTION("C4E36D788C2B8000000060" , vfnmaddps(ymm1, ymm2, ptr(rbx, rbp, 0, 128), ymm6)); + TEST_INSTRUCTION("C4E36D788C2B8000000060" , vfnmaddps(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128), ymm6)); + TEST_INSTRUCTION("C4E3E97BCC30" , vfnmaddsd(xmm1, xmm2, xmm3, xmm4)); + TEST_INSTRUCTION("C4E3E97B8C358000000030" , vfnmaddsd(xmm1, xmm2, xmm3, ptr(rbp, rsi, 0, 128))); + TEST_INSTRUCTION("C4E3E97B8C358000000030" , vfnmaddsd(xmm1, xmm2, xmm3, qword_ptr(rbp, rsi, 0, 128))); + TEST_INSTRUCTION("C4E3697B8C2B8000000060" , vfnmaddsd(xmm1, xmm2, ptr(rbx, rbp, 0, 128), xmm6)); + TEST_INSTRUCTION("C4E3697B8C2B8000000060" , vfnmaddsd(xmm1, xmm2, qword_ptr(rbx, rbp, 0, 128), xmm6)); + TEST_INSTRUCTION("C4E3E97ACC30" , vfnmaddss(xmm1, xmm2, xmm3, xmm4)); + TEST_INSTRUCTION("C4E3E97A8C358000000030" , vfnmaddss(xmm1, xmm2, xmm3, ptr(rbp, rsi, 0, 128))); + TEST_INSTRUCTION("C4E3E97A8C358000000030" , vfnmaddss(xmm1, xmm2, xmm3, dword_ptr(rbp, rsi, 0, 128))); + TEST_INSTRUCTION("C4E3697A8C2B8000000060" , vfnmaddss(xmm1, xmm2, ptr(rbx, rbp, 0, 128), xmm6)); + TEST_INSTRUCTION("C4E3697A8C2B8000000060" , vfnmaddss(xmm1, xmm2, dword_ptr(rbx, rbp, 0, 128), xmm6)); + TEST_INSTRUCTION("C4E2E99ECB" , vfnmsub132pd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E2E99E8C2B80000000" , vfnmsub132pd(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E2E99E8C2B80000000" , vfnmsub132pd(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E2ED9ECB" , vfnmsub132pd(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C4E2ED9E8C2B80000000" , vfnmsub132pd(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E2ED9E8C2B80000000" , vfnmsub132pd(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED489ECB" , vfnmsub132pd(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F2ED489E4C2B02" , vfnmsub132pd(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED489E4C2B02" , vfnmsub132pd(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E2699ECB" , vfnmsub132ps(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E2699E8C2B80000000" , vfnmsub132ps(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E2699E8C2B80000000" , vfnmsub132ps(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E26D9ECB" , vfnmsub132ps(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C4E26D9E8C2B80000000" , vfnmsub132ps(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E26D9E8C2B80000000" , vfnmsub132ps(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D489ECB" , vfnmsub132ps(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F26D489E4C2B02" , vfnmsub132ps(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D489E4C2B02" , vfnmsub132ps(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E2E99FCB" , vfnmsub132sd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E2E99F8C2B80000000" , vfnmsub132sd(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E2E99F8C2B80000000" , vfnmsub132sd(xmm1, xmm2, qword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E2699FCB" , vfnmsub132ss(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E2699F8C2B80000000" , vfnmsub132ss(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E2699F8C2B80000000" , vfnmsub132ss(xmm1, xmm2, dword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E2E9AECB" , vfnmsub213pd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E2E9AE8C2B80000000" , vfnmsub213pd(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E2E9AE8C2B80000000" , vfnmsub213pd(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E2EDAECB" , vfnmsub213pd(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C4E2EDAE8C2B80000000" , vfnmsub213pd(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E2EDAE8C2B80000000" , vfnmsub213pd(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED48AECB" , vfnmsub213pd(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F2ED48AE4C2B02" , vfnmsub213pd(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED48AE4C2B02" , vfnmsub213pd(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E269AECB" , vfnmsub213ps(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E269AE8C2B80000000" , vfnmsub213ps(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E269AE8C2B80000000" , vfnmsub213ps(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E26DAECB" , vfnmsub213ps(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C4E26DAE8C2B80000000" , vfnmsub213ps(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E26DAE8C2B80000000" , vfnmsub213ps(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D48AECB" , vfnmsub213ps(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F26D48AE4C2B02" , vfnmsub213ps(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D48AE4C2B02" , vfnmsub213ps(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E2E9AFCB" , vfnmsub213sd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E2E9AF8C2B80000000" , vfnmsub213sd(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E2E9AF8C2B80000000" , vfnmsub213sd(xmm1, xmm2, qword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E269AFCB" , vfnmsub213ss(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E269AF8C2B80000000" , vfnmsub213ss(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E269AF8C2B80000000" , vfnmsub213ss(xmm1, xmm2, dword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E2E9BECB" , vfnmsub231pd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E2E9BE8C2B80000000" , vfnmsub231pd(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E2E9BE8C2B80000000" , vfnmsub231pd(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E2EDBECB" , vfnmsub231pd(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C4E2EDBE8C2B80000000" , vfnmsub231pd(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E2EDBE8C2B80000000" , vfnmsub231pd(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED48BECB" , vfnmsub231pd(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F2ED48BE4C2B02" , vfnmsub231pd(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED48BE4C2B02" , vfnmsub231pd(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E269BECB" , vfnmsub231ps(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E269BE8C2B80000000" , vfnmsub231ps(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E269BE8C2B80000000" , vfnmsub231ps(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E26DBECB" , vfnmsub231ps(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C4E26DBE8C2B80000000" , vfnmsub231ps(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E26DBE8C2B80000000" , vfnmsub231ps(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D48BECB" , vfnmsub231ps(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F26D48BE4C2B02" , vfnmsub231ps(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D48BE4C2B02" , vfnmsub231ps(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E2E9BFCB" , vfnmsub231sd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E2E9BF8C2B80000000" , vfnmsub231sd(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E2E9BF8C2B80000000" , vfnmsub231sd(xmm1, xmm2, qword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E269BFCB" , vfnmsub231ss(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E269BF8C2B80000000" , vfnmsub231ss(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E269BF8C2B80000000" , vfnmsub231ss(xmm1, xmm2, dword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E3E97DCC30" , vfnmsubpd(xmm1, xmm2, xmm3, xmm4)); + TEST_INSTRUCTION("C4E3E97D8C358000000030" , vfnmsubpd(xmm1, xmm2, xmm3, ptr(rbp, rsi, 0, 128))); + TEST_INSTRUCTION("C4E3E97D8C358000000030" , vfnmsubpd(xmm1, xmm2, xmm3, xmmword_ptr(rbp, rsi, 0, 128))); + TEST_INSTRUCTION("C4E3697D8C2B8000000060" , vfnmsubpd(xmm1, xmm2, ptr(rbx, rbp, 0, 128), xmm6)); + TEST_INSTRUCTION("C4E3697D8C2B8000000060" , vfnmsubpd(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128), xmm6)); + TEST_INSTRUCTION("C4E3ED7DCC30" , vfnmsubpd(ymm1, ymm2, ymm3, ymm4)); + TEST_INSTRUCTION("C4E3ED7D8C358000000030" , vfnmsubpd(ymm1, ymm2, ymm3, ptr(rbp, rsi, 0, 128))); + TEST_INSTRUCTION("C4E3ED7D8C358000000030" , vfnmsubpd(ymm1, ymm2, ymm3, ymmword_ptr(rbp, rsi, 0, 128))); + TEST_INSTRUCTION("C4E36D7D8C2B8000000060" , vfnmsubpd(ymm1, ymm2, ptr(rbx, rbp, 0, 128), ymm6)); + TEST_INSTRUCTION("C4E36D7D8C2B8000000060" , vfnmsubpd(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128), ymm6)); + TEST_INSTRUCTION("C4E3E97CCC30" , vfnmsubps(xmm1, xmm2, xmm3, xmm4)); + TEST_INSTRUCTION("C4E3E97C8C358000000030" , vfnmsubps(xmm1, xmm2, xmm3, ptr(rbp, rsi, 0, 128))); + TEST_INSTRUCTION("C4E3E97C8C358000000030" , vfnmsubps(xmm1, xmm2, xmm3, xmmword_ptr(rbp, rsi, 0, 128))); + TEST_INSTRUCTION("C4E3697C8C2B8000000060" , vfnmsubps(xmm1, xmm2, ptr(rbx, rbp, 0, 128), xmm6)); + TEST_INSTRUCTION("C4E3697C8C2B8000000060" , vfnmsubps(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128), xmm6)); + TEST_INSTRUCTION("C4E3ED7CCC30" , vfnmsubps(ymm1, ymm2, ymm3, ymm4)); + TEST_INSTRUCTION("C4E3ED7C8C358000000030" , vfnmsubps(ymm1, ymm2, ymm3, ptr(rbp, rsi, 0, 128))); + TEST_INSTRUCTION("C4E3ED7C8C358000000030" , vfnmsubps(ymm1, ymm2, ymm3, ymmword_ptr(rbp, rsi, 0, 128))); + TEST_INSTRUCTION("C4E36D7C8C2B8000000060" , vfnmsubps(ymm1, ymm2, ptr(rbx, rbp, 0, 128), ymm6)); + TEST_INSTRUCTION("C4E36D7C8C2B8000000060" , vfnmsubps(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128), ymm6)); + TEST_INSTRUCTION("C4E3E97FCC30" , vfnmsubsd(xmm1, xmm2, xmm3, xmm4)); + TEST_INSTRUCTION("C4E3E97F8C358000000030" , vfnmsubsd(xmm1, xmm2, xmm3, ptr(rbp, rsi, 0, 128))); + TEST_INSTRUCTION("C4E3E97F8C358000000030" , vfnmsubsd(xmm1, xmm2, xmm3, qword_ptr(rbp, rsi, 0, 128))); + TEST_INSTRUCTION("C4E3697F8C2B8000000060" , vfnmsubsd(xmm1, xmm2, ptr(rbx, rbp, 0, 128), xmm6)); + TEST_INSTRUCTION("C4E3697F8C2B8000000060" , vfnmsubsd(xmm1, xmm2, qword_ptr(rbx, rbp, 0, 128), xmm6)); + TEST_INSTRUCTION("C4E3E97ECC30" , vfnmsubss(xmm1, xmm2, xmm3, xmm4)); + TEST_INSTRUCTION("C4E3E97E8C358000000030" , vfnmsubss(xmm1, xmm2, xmm3, ptr(rbp, rsi, 0, 128))); + TEST_INSTRUCTION("C4E3E97E8C358000000030" , vfnmsubss(xmm1, xmm2, xmm3, dword_ptr(rbp, rsi, 0, 128))); + TEST_INSTRUCTION("C4E3697E8C2B8000000060" , vfnmsubss(xmm1, xmm2, ptr(rbx, rbp, 0, 128), xmm6)); + TEST_INSTRUCTION("C4E3697E8C2B8000000060" , vfnmsubss(xmm1, xmm2, dword_ptr(rbx, rbp, 0, 128), xmm6)); + TEST_INSTRUCTION("62F3FD0866CA01" , vfpclasspd(k1, xmm2, 1)); + TEST_INSTRUCTION("62F3FD2866CA01" , vfpclasspd(k1, ymm2, 1)); + TEST_INSTRUCTION("62F3FD4866CA01" , vfpclasspd(k1, zmm2, 1)); + TEST_INSTRUCTION("62F3FD08664C1A0801" , vfpclasspd(k1, xmmword_ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("62F3FD28664C1A0401" , vfpclasspd(k1, ymmword_ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("62F3FD48664C1A0201" , vfpclasspd(k1, zmmword_ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("62F37D0866CA01" , vfpclassps(k1, xmm2, 1)); + TEST_INSTRUCTION("62F37D2866CA01" , vfpclassps(k1, ymm2, 1)); + TEST_INSTRUCTION("62F37D4866CA01" , vfpclassps(k1, zmm2, 1)); + TEST_INSTRUCTION("62F37D08664C1A0801" , vfpclassps(k1, xmmword_ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("62F37D28664C1A0401" , vfpclassps(k1, ymmword_ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("62F37D48664C1A0201" , vfpclassps(k1, zmmword_ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("62F3FD0867CA01" , vfpclasssd(k1, xmm2, 1)); + TEST_INSTRUCTION("62F3FD08674C1A1001" , vfpclasssd(k1, ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("62F3FD08674C1A1001" , vfpclasssd(k1, qword_ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("62F37D0867CA01" , vfpclassss(k1, xmm2, 1)); + TEST_INSTRUCTION("62F37D08674C1A2001" , vfpclassss(k1, ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("62F37D08674C1A2001" , vfpclassss(k1, dword_ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("8FE97881CA" , vfrczpd(xmm1, xmm2)); + TEST_INSTRUCTION("8FE978818C1A80000000" , vfrczpd(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("8FE978818C1A80000000" , vfrczpd(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("8FE97C81CA" , vfrczpd(ymm1, ymm2)); + TEST_INSTRUCTION("8FE97C818C1A80000000" , vfrczpd(ymm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("8FE97C818C1A80000000" , vfrczpd(ymm1, ymmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("8FE97880CA" , vfrczps(xmm1, xmm2)); + TEST_INSTRUCTION("8FE978808C1A80000000" , vfrczps(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("8FE978808C1A80000000" , vfrczps(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("8FE97C80CA" , vfrczps(ymm1, ymm2)); + TEST_INSTRUCTION("8FE97C808C1A80000000" , vfrczps(ymm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("8FE97C808C1A80000000" , vfrczps(ymm1, ymmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("8FE97883CA" , vfrczsd(xmm1, xmm2)); + TEST_INSTRUCTION("8FE978838C1A80000000" , vfrczsd(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("8FE978838C1A80000000" , vfrczsd(xmm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("8FE97882CA" , vfrczss(xmm1, xmm2)); + TEST_INSTRUCTION("8FE978828C1A80000000" , vfrczss(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("8FE978828C1A80000000" , vfrczss(xmm1, dword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C4E2D9928C1A80000000" , vgatherdpd(xmm1, ptr(rdx, xmm3, 0, 128), xmm4)); + TEST_INSTRUCTION("C4E2DD928C1A80000000" , vgatherdpd(ymm1, ptr(rdx, xmm3, 0, 128), ymm4)); + TEST_INSTRUCTION("62F2FD09924C1A10" , k(k1).vgatherdpd(xmm1, ptr(rdx, xmm3, 0, 128))); + TEST_INSTRUCTION("62F2FD29924C1A10" , k(k1).vgatherdpd(ymm1, ptr(rdx, xmm3, 0, 128))); + TEST_INSTRUCTION("62F2FD49924C1A10" , k(k1).vgatherdpd(zmm1, ptr(rdx, ymm3, 0, 128))); + TEST_INSTRUCTION("C4E259928C1A80000000" , vgatherdps(xmm1, ptr(rdx, xmm3, 0, 128), xmm4)); + TEST_INSTRUCTION("C4E25D928C1A80000000" , vgatherdps(ymm1, ptr(rdx, ymm3, 0, 128), ymm4)); + TEST_INSTRUCTION("62F27D09924C1A20" , k(k1).vgatherdps(xmm1, ptr(rdx, xmm3, 0, 128))); + TEST_INSTRUCTION("62F27D29924C1A20" , k(k1).vgatherdps(ymm1, ptr(rdx, ymm3, 0, 128))); + TEST_INSTRUCTION("62F27D49924C1A20" , k(k1).vgatherdps(zmm1, ptr(rdx, zmm3, 0, 128))); + TEST_INSTRUCTION("62F2FD49C64C1110" , k(k1).vgatherpf0dpd(ptr(rcx, ymm2, 0, 128))); + TEST_INSTRUCTION("62F27D49C64C1120" , k(k1).vgatherpf0dps(ptr(rcx, zmm2, 0, 128))); + TEST_INSTRUCTION("62F2FD49C74C1110" , k(k1).vgatherpf0qpd(ptr(rcx, zmm2, 0, 128))); + TEST_INSTRUCTION("62F27D49C74C1120" , k(k1).vgatherpf0qps(ptr(rcx, zmm2, 0, 128))); + TEST_INSTRUCTION("62F2FD49C6541110" , k(k1).vgatherpf1dpd(ptr(rcx, ymm2, 0, 128))); + TEST_INSTRUCTION("62F27D49C6541120" , k(k1).vgatherpf1dps(ptr(rcx, zmm2, 0, 128))); + TEST_INSTRUCTION("62F2FD49C7541110" , k(k1).vgatherpf1qpd(ptr(rcx, zmm2, 0, 128))); + TEST_INSTRUCTION("62F27D49C7541120" , k(k1).vgatherpf1qps(ptr(rcx, zmm2, 0, 128))); + TEST_INSTRUCTION("C4E2D9938C1A80000000" , vgatherqpd(xmm1, ptr(rdx, xmm3, 0, 128), xmm4)); + TEST_INSTRUCTION("C4E2DD938C1A80000000" , vgatherqpd(ymm1, ptr(rdx, ymm3, 0, 128), ymm4)); + TEST_INSTRUCTION("62F2FD09934C1A10" , k(k1).vgatherqpd(xmm1, ptr(rdx, xmm3, 0, 128))); + TEST_INSTRUCTION("62F2FD29934C1A10" , k(k1).vgatherqpd(ymm1, ptr(rdx, ymm3, 0, 128))); + TEST_INSTRUCTION("62F2FD49934C1A10" , k(k1).vgatherqpd(zmm1, ptr(rdx, zmm3, 0, 128))); + TEST_INSTRUCTION("C4E259938C1A80000000" , vgatherqps(xmm1, ptr(rdx, xmm3, 0, 128), xmm4)); + TEST_INSTRUCTION("C4E25D938C1A80000000" , vgatherqps(xmm1, ptr(rdx, ymm3, 0, 128), xmm4)); + TEST_INSTRUCTION("62F27D09934C1A20" , k(k1).vgatherqps(xmm1, ptr(rdx, xmm3, 0, 128))); + TEST_INSTRUCTION("62F27D29934C1A20" , k(k1).vgatherqps(xmm1, ptr(rdx, ymm3, 0, 128))); + TEST_INSTRUCTION("62F27D49934C1A20" , k(k1).vgatherqps(ymm1, ptr(rdx, zmm3, 0, 128))); + TEST_INSTRUCTION("62F2FD0842CA" , vgetexppd(xmm1, xmm2)); + TEST_INSTRUCTION("62F2FD08424C1A08" , vgetexppd(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F2FD08424C1A08" , vgetexppd(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F2FD2842CA" , vgetexppd(ymm1, ymm2)); + TEST_INSTRUCTION("62F2FD28424C1A04" , vgetexppd(ymm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F2FD28424C1A04" , vgetexppd(ymm1, ymmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F2FD4842CA" , vgetexppd(zmm1, zmm2)); + TEST_INSTRUCTION("62F2FD48424C1A02" , vgetexppd(zmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F2FD48424C1A02" , vgetexppd(zmm1, zmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F27D0842CA" , vgetexpps(xmm1, xmm2)); + TEST_INSTRUCTION("62F27D08424C1A08" , vgetexpps(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F27D08424C1A08" , vgetexpps(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F27D2842CA" , vgetexpps(ymm1, ymm2)); + TEST_INSTRUCTION("62F27D28424C1A04" , vgetexpps(ymm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F27D28424C1A04" , vgetexpps(ymm1, ymmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F27D4842CA" , vgetexpps(zmm1, zmm2)); + TEST_INSTRUCTION("62F27D48424C1A02" , vgetexpps(zmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F27D48424C1A02" , vgetexpps(zmm1, zmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F2ED0843CB" , vgetexpsd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("62F2ED08434C2B10" , vgetexpsd(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED08434C2B10" , vgetexpsd(xmm1, xmm2, qword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D0843CB" , vgetexpss(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("62F26D08434C2B20" , vgetexpss(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D08434C2B20" , vgetexpss(xmm1, xmm2, dword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F3FD0826CA01" , vgetmantpd(xmm1, xmm2, 1)); + TEST_INSTRUCTION("62F3FD08264C1A0801" , vgetmantpd(xmm1, ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("62F3FD08264C1A0801" , vgetmantpd(xmm1, xmmword_ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("62F3FD2826CA01" , vgetmantpd(ymm1, ymm2, 1)); + TEST_INSTRUCTION("62F3FD28264C1A0401" , vgetmantpd(ymm1, ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("62F3FD28264C1A0401" , vgetmantpd(ymm1, ymmword_ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("62F3FD4826CA01" , vgetmantpd(zmm1, zmm2, 1)); + TEST_INSTRUCTION("62F3FD48264C1A0201" , vgetmantpd(zmm1, ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("62F3FD48264C1A0201" , vgetmantpd(zmm1, zmmword_ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("62F37D0826CA01" , vgetmantps(xmm1, xmm2, 1)); + TEST_INSTRUCTION("62F37D08264C1A0801" , vgetmantps(xmm1, ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("62F37D08264C1A0801" , vgetmantps(xmm1, xmmword_ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("62F37D2826CA01" , vgetmantps(ymm1, ymm2, 1)); + TEST_INSTRUCTION("62F37D28264C1A0401" , vgetmantps(ymm1, ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("62F37D28264C1A0401" , vgetmantps(ymm1, ymmword_ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("62F37D4826CA01" , vgetmantps(zmm1, zmm2, 1)); + TEST_INSTRUCTION("62F37D48264C1A0201" , vgetmantps(zmm1, ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("62F37D48264C1A0201" , vgetmantps(zmm1, zmmword_ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED0827CB01" , vgetmantsd(xmm1, xmm2, xmm3, 1)); + TEST_INSTRUCTION("62F3ED08274C2B1001" , vgetmantsd(xmm1, xmm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED08274C2B1001" , vgetmantsd(xmm1, xmm2, qword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D0827CB01" , vgetmantss(xmm1, xmm2, xmm3, 1)); + TEST_INSTRUCTION("62F36D08274C2B2001" , vgetmantss(xmm1, xmm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D08274C2B2001" , vgetmantss(xmm1, xmm2, dword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("C4E3E9CFCB01" , vgf2p8affineinvqb(xmm1, xmm2, xmm3, 1)); + TEST_INSTRUCTION("C4E3E9CF8C2B8000000001" , vgf2p8affineinvqb(xmm1, xmm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("C4E3E9CF8C2B8000000001" , vgf2p8affineinvqb(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("C4E3EDCFCB01" , vgf2p8affineinvqb(ymm1, ymm2, ymm3, 1)); + TEST_INSTRUCTION("C4E3EDCF8C2B8000000001" , vgf2p8affineinvqb(ymm1, ymm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("C4E3EDCF8C2B8000000001" , vgf2p8affineinvqb(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED48CFCB01" , vgf2p8affineinvqb(zmm1, zmm2, zmm3, 1)); + TEST_INSTRUCTION("62F3ED48CF4C2B0201" , vgf2p8affineinvqb(zmm1, zmm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED48CF4C2B0201" , vgf2p8affineinvqb(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("C4E3E9CECB01" , vgf2p8affineqb(xmm1, xmm2, xmm3, 1)); + TEST_INSTRUCTION("C4E3E9CE8C2B8000000001" , vgf2p8affineqb(xmm1, xmm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("C4E3E9CE8C2B8000000001" , vgf2p8affineqb(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("C4E3EDCECB01" , vgf2p8affineqb(ymm1, ymm2, ymm3, 1)); + TEST_INSTRUCTION("C4E3EDCE8C2B8000000001" , vgf2p8affineqb(ymm1, ymm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("C4E3EDCE8C2B8000000001" , vgf2p8affineqb(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED48CECB01" , vgf2p8affineqb(zmm1, zmm2, zmm3, 1)); + TEST_INSTRUCTION("62F3ED48CE4C2B0201" , vgf2p8affineqb(zmm1, zmm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED48CE4C2B0201" , vgf2p8affineqb(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("C4E269CFCB" , vgf2p8mulb(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E269CF8C2B80000000" , vgf2p8mulb(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E269CF8C2B80000000" , vgf2p8mulb(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E26DCFCB" , vgf2p8mulb(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C4E26DCF8C2B80000000" , vgf2p8mulb(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E26DCF8C2B80000000" , vgf2p8mulb(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D48CFCB" , vgf2p8mulb(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F26D48CF4C2B02" , vgf2p8mulb(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D48CF4C2B02" , vgf2p8mulb(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5E97CCB" , vhaddpd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5E97C8C2B80000000" , vhaddpd(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5E97C8C2B80000000" , vhaddpd(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5ED7CCB" , vhaddpd(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C5ED7C8C2B80000000" , vhaddpd(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5ED7C8C2B80000000" , vhaddpd(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5EB7CCB" , vhaddps(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5EB7C8C2B80000000" , vhaddps(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5EB7C8C2B80000000" , vhaddps(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5EF7CCB" , vhaddps(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C5EF7C8C2B80000000" , vhaddps(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5EF7C8C2B80000000" , vhaddps(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5E97DCB" , vhsubpd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5E97D8C2B80000000" , vhsubpd(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5E97D8C2B80000000" , vhsubpd(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5ED7DCB" , vhsubpd(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C5ED7D8C2B80000000" , vhsubpd(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5ED7D8C2B80000000" , vhsubpd(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5EB7DCB" , vhsubps(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5EB7D8C2B80000000" , vhsubps(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5EB7D8C2B80000000" , vhsubps(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5EF7DCB" , vhsubps(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C5EF7D8C2B80000000" , vhsubps(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5EF7D8C2B80000000" , vhsubps(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E36D18CB01" , vinsertf128(ymm1, ymm2, xmm3, 1)); + TEST_INSTRUCTION("C4E36D188C2B8000000001" , vinsertf128(ymm1, ymm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("C4E36D188C2B8000000001" , vinsertf128(ymm1, ymm2, xmmword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D2818CB01" , vinsertf32x4(ymm1, ymm2, xmm3, 1)); + TEST_INSTRUCTION("62F36D28184C2B0801" , vinsertf32x4(ymm1, ymm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D28184C2B0801" , vinsertf32x4(ymm1, ymm2, xmmword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D4818CB01" , vinsertf32x4(zmm1, zmm2, xmm3, 1)); + TEST_INSTRUCTION("62F36D48184C2B0801" , vinsertf32x4(zmm1, zmm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D48184C2B0801" , vinsertf32x4(zmm1, zmm2, xmmword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D481ACB01" , vinsertf32x8(zmm1, zmm2, ymm3, 1)); + TEST_INSTRUCTION("62F36D481A4C2B0401" , vinsertf32x8(zmm1, zmm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D481A4C2B0401" , vinsertf32x8(zmm1, zmm2, ymmword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED2818CB01" , vinsertf64x2(ymm1, ymm2, xmm3, 1)); + TEST_INSTRUCTION("62F3ED28184C2B0801" , vinsertf64x2(ymm1, ymm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED28184C2B0801" , vinsertf64x2(ymm1, ymm2, xmmword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED4818CB01" , vinsertf64x2(zmm1, zmm2, xmm3, 1)); + TEST_INSTRUCTION("62F3ED48184C2B0801" , vinsertf64x2(zmm1, zmm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED48184C2B0801" , vinsertf64x2(zmm1, zmm2, xmmword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED481ACB01" , vinsertf64x4(zmm1, zmm2, ymm3, 1)); + TEST_INSTRUCTION("62F3ED481A4C2B0401" , vinsertf64x4(zmm1, zmm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED481A4C2B0401" , vinsertf64x4(zmm1, zmm2, ymmword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("C4E36D38CB01" , vinserti128(ymm1, ymm2, xmm3, 1)); + TEST_INSTRUCTION("C4E36D388C2B8000000001" , vinserti128(ymm1, ymm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("C4E36D388C2B8000000001" , vinserti128(ymm1, ymm2, xmmword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D2838CB01" , vinserti32x4(ymm1, ymm2, xmm3, 1)); + TEST_INSTRUCTION("62F36D28384C2B0801" , vinserti32x4(ymm1, ymm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D28384C2B0801" , vinserti32x4(ymm1, ymm2, xmmword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D4838CB01" , vinserti32x4(zmm1, zmm2, xmm3, 1)); + TEST_INSTRUCTION("62F36D48384C2B0801" , vinserti32x4(zmm1, zmm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D48384C2B0801" , vinserti32x4(zmm1, zmm2, xmmword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D483ACB01" , vinserti32x8(zmm1, zmm2, ymm3, 1)); + TEST_INSTRUCTION("62F36D483A4C2B0401" , vinserti32x8(zmm1, zmm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D483A4C2B0401" , vinserti32x8(zmm1, zmm2, ymmword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED2838CB01" , vinserti64x2(ymm1, ymm2, xmm3, 1)); + TEST_INSTRUCTION("62F3ED28384C2B0801" , vinserti64x2(ymm1, ymm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED28384C2B0801" , vinserti64x2(ymm1, ymm2, xmmword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED4838CB01" , vinserti64x2(zmm1, zmm2, xmm3, 1)); + TEST_INSTRUCTION("62F3ED48384C2B0801" , vinserti64x2(zmm1, zmm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED48384C2B0801" , vinserti64x2(zmm1, zmm2, xmmword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED483ACB01" , vinserti64x4(zmm1, zmm2, ymm3, 1)); + TEST_INSTRUCTION("62F3ED483A4C2B0401" , vinserti64x4(zmm1, zmm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED483A4C2B0401" , vinserti64x4(zmm1, zmm2, ymmword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("C4E36921CB01" , vinsertps(xmm1, xmm2, xmm3, 1)); + TEST_INSTRUCTION("C4E369218C2B8000000001" , vinsertps(xmm1, xmm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("C4E369218C2B8000000001" , vinsertps(xmm1, xmm2, dword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("C5FBF08C1A80000000" , vlddqu(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C5FBF08C1A80000000" , vlddqu(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C5FFF08C1A80000000" , vlddqu(ymm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C5FFF08C1A80000000" , vlddqu(ymm1, ymmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C5F8AE941180000000" , vldmxcsr(ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("C5F8AE941180000000" , vldmxcsr(dword_ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("C5F9F7CA" , vmaskmovdqu(xmm1, xmm2, ptr(rdi))); + TEST_INSTRUCTION("C5F9F7CA" , vmaskmovdqu(xmm1, xmm2, xmmword_ptr(rdi))); + TEST_INSTRUCTION("C4E2612FA41180000000" , vmaskmovpd(ptr(rcx, rdx, 0, 128), xmm3, xmm4)); + TEST_INSTRUCTION("C4E2612FA41180000000" , vmaskmovpd(xmmword_ptr(rcx, rdx, 0, 128), xmm3, xmm4)); + TEST_INSTRUCTION("C4E2652FA41180000000" , vmaskmovpd(ptr(rcx, rdx, 0, 128), ymm3, ymm4)); + TEST_INSTRUCTION("C4E2652FA41180000000" , vmaskmovpd(ymmword_ptr(rcx, rdx, 0, 128), ymm3, ymm4)); + TEST_INSTRUCTION("C4E2692D8C2B80000000" , vmaskmovpd(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E2692D8C2B80000000" , vmaskmovpd(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E26D2D8C2B80000000" , vmaskmovpd(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E26D2D8C2B80000000" , vmaskmovpd(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E2612EA41180000000" , vmaskmovps(ptr(rcx, rdx, 0, 128), xmm3, xmm4)); + TEST_INSTRUCTION("C4E2612EA41180000000" , vmaskmovps(xmmword_ptr(rcx, rdx, 0, 128), xmm3, xmm4)); + TEST_INSTRUCTION("C4E2652EA41180000000" , vmaskmovps(ptr(rcx, rdx, 0, 128), ymm3, ymm4)); + TEST_INSTRUCTION("C4E2652EA41180000000" , vmaskmovps(ymmword_ptr(rcx, rdx, 0, 128), ymm3, ymm4)); + TEST_INSTRUCTION("C4E2692C8C2B80000000" , vmaskmovps(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E2692C8C2B80000000" , vmaskmovps(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E26D2C8C2B80000000" , vmaskmovps(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E26D2C8C2B80000000" , vmaskmovps(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5E95FCB" , vmaxpd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5E95F8C2B80000000" , vmaxpd(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5E95F8C2B80000000" , vmaxpd(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5ED5FCB" , vmaxpd(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C5ED5F8C2B80000000" , vmaxpd(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5ED5F8C2B80000000" , vmaxpd(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F1ED485FCB" , vmaxpd(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F1ED485F4C2B02" , vmaxpd(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F1ED485F4C2B02" , vmaxpd(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5E85FCB" , vmaxps(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5E85F8C2B80000000" , vmaxps(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5E85F8C2B80000000" , vmaxps(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5EC5FCB" , vmaxps(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C5EC5F8C2B80000000" , vmaxps(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5EC5F8C2B80000000" , vmaxps(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16C485FCB" , vmaxps(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F16C485F4C2B02" , vmaxps(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16C485F4C2B02" , vmaxps(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5EB5FCB" , vmaxsd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5EB5F8C2B80000000" , vmaxsd(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5EB5F8C2B80000000" , vmaxsd(xmm1, xmm2, qword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5EA5FCB" , vmaxss(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5EA5F8C2B80000000" , vmaxss(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5EA5F8C2B80000000" , vmaxss(xmm1, xmm2, dword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5E95DCB" , vminpd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5E95D8C2B80000000" , vminpd(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5E95D8C2B80000000" , vminpd(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5ED5DCB" , vminpd(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C5ED5D8C2B80000000" , vminpd(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5ED5D8C2B80000000" , vminpd(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F1ED485DCB" , vminpd(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F1ED485D4C2B02" , vminpd(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F1ED485D4C2B02" , vminpd(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5E85DCB" , vminps(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5E85D8C2B80000000" , vminps(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5E85D8C2B80000000" , vminps(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5EC5DCB" , vminps(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C5EC5D8C2B80000000" , vminps(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5EC5D8C2B80000000" , vminps(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16C485DCB" , vminps(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F16C485D4C2B02" , vminps(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16C485D4C2B02" , vminps(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5EB5DCB" , vminsd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5EB5D8C2B80000000" , vminsd(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5EB5D8C2B80000000" , vminsd(xmm1, xmm2, qword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5EA5DCB" , vminss(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5EA5D8C2B80000000" , vminss(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5EA5D8C2B80000000" , vminss(xmm1, xmm2, dword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5F928CA" , vmovapd(xmm1, xmm2)); + TEST_INSTRUCTION("C5F9288C1A80000000" , vmovapd(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C5F9288C1A80000000" , vmovapd(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C5F9299C1180000000" , vmovapd(ptr(rcx, rdx, 0, 128), xmm3)); + TEST_INSTRUCTION("C5F9299C1180000000" , vmovapd(xmmword_ptr(rcx, rdx, 0, 128), xmm3)); + TEST_INSTRUCTION("C5FD28CA" , vmovapd(ymm1, ymm2)); + TEST_INSTRUCTION("C5FD288C1A80000000" , vmovapd(ymm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C5FD288C1A80000000" , vmovapd(ymm1, ymmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C5FD299C1180000000" , vmovapd(ptr(rcx, rdx, 0, 128), ymm3)); + TEST_INSTRUCTION("C5FD299C1180000000" , vmovapd(ymmword_ptr(rcx, rdx, 0, 128), ymm3)); + TEST_INSTRUCTION("62F1FD4828CA" , vmovapd(zmm1, zmm2)); + TEST_INSTRUCTION("62F1FD48284C1A02" , vmovapd(zmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F1FD48284C1A02" , vmovapd(zmm1, zmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F1FD48295C1102" , vmovapd(ptr(rcx, rdx, 0, 128), zmm3)); + TEST_INSTRUCTION("62F1FD48295C1102" , vmovapd(zmmword_ptr(rcx, rdx, 0, 128), zmm3)); + TEST_INSTRUCTION("C5F828CA" , vmovaps(xmm1, xmm2)); + TEST_INSTRUCTION("C5F8288C1A80000000" , vmovaps(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C5F8288C1A80000000" , vmovaps(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C5F8299C1180000000" , vmovaps(ptr(rcx, rdx, 0, 128), xmm3)); + TEST_INSTRUCTION("C5F8299C1180000000" , vmovaps(xmmword_ptr(rcx, rdx, 0, 128), xmm3)); + TEST_INSTRUCTION("C5FC28CA" , vmovaps(ymm1, ymm2)); + TEST_INSTRUCTION("C5FC288C1A80000000" , vmovaps(ymm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C5FC288C1A80000000" , vmovaps(ymm1, ymmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C5FC299C1180000000" , vmovaps(ptr(rcx, rdx, 0, 128), ymm3)); + TEST_INSTRUCTION("C5FC299C1180000000" , vmovaps(ymmword_ptr(rcx, rdx, 0, 128), ymm3)); + TEST_INSTRUCTION("62F17C4828CA" , vmovaps(zmm1, zmm2)); + TEST_INSTRUCTION("62F17C48284C1A02" , vmovaps(zmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F17C48284C1A02" , vmovaps(zmm1, zmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F17C48295C1102" , vmovaps(ptr(rcx, rdx, 0, 128), zmm3)); + TEST_INSTRUCTION("62F17C48295C1102" , vmovaps(zmmword_ptr(rcx, rdx, 0, 128), zmm3)); + TEST_INSTRUCTION("C5F97ED1" , vmovd(ecx, xmm2)); + TEST_INSTRUCTION("C5F97E9C1180000000" , vmovd(ptr(rcx, rdx, 0, 128), xmm3)); + TEST_INSTRUCTION("C5F97E9C1180000000" , vmovd(dword_ptr(rcx, rdx, 0, 128), xmm3)); + TEST_INSTRUCTION("C5F96ECA" , vmovd(xmm1, edx)); + TEST_INSTRUCTION("C5F96E8C1A80000000" , vmovd(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C5F96E8C1A80000000" , vmovd(xmm1, dword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C5FB12CA" , vmovddup(xmm1, xmm2)); + TEST_INSTRUCTION("C5FB128C1A80000000" , vmovddup(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C5FB128C1A80000000" , vmovddup(xmm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C5FF12CA" , vmovddup(ymm1, ymm2)); + TEST_INSTRUCTION("C5FF128C1A80000000" , vmovddup(ymm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C5FF128C1A80000000" , vmovddup(ymm1, ymmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F1FF4812CA" , vmovddup(zmm1, zmm2)); + TEST_INSTRUCTION("62F1FF48124C1A02" , vmovddup(zmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F1FF48124C1A02" , vmovddup(zmm1, zmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C5F96FCA" , vmovdqa(xmm1, xmm2)); + TEST_INSTRUCTION("C5F96F8C1A80000000" , vmovdqa(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C5F96F8C1A80000000" , vmovdqa(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C5F97F9C1180000000" , vmovdqa(ptr(rcx, rdx, 0, 128), xmm3)); + TEST_INSTRUCTION("C5F97F9C1180000000" , vmovdqa(xmmword_ptr(rcx, rdx, 0, 128), xmm3)); + TEST_INSTRUCTION("C5FD6FCA" , vmovdqa(ymm1, ymm2)); + TEST_INSTRUCTION("C5FD6F8C1A80000000" , vmovdqa(ymm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C5FD6F8C1A80000000" , vmovdqa(ymm1, ymmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C5FD7F9C1180000000" , vmovdqa(ptr(rcx, rdx, 0, 128), ymm3)); + TEST_INSTRUCTION("C5FD7F9C1180000000" , vmovdqa(ymmword_ptr(rcx, rdx, 0, 128), ymm3)); + TEST_INSTRUCTION("62F17D086FCA" , vmovdqa32(xmm1, xmm2)); + TEST_INSTRUCTION("62F17D086F4C1A08" , vmovdqa32(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F17D086F4C1A08" , vmovdqa32(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F17D087F5C1108" , vmovdqa32(ptr(rcx, rdx, 0, 128), xmm3)); + TEST_INSTRUCTION("62F17D087F5C1108" , vmovdqa32(xmmword_ptr(rcx, rdx, 0, 128), xmm3)); + TEST_INSTRUCTION("62F17D286FCA" , vmovdqa32(ymm1, ymm2)); + TEST_INSTRUCTION("62F17D286F4C1A04" , vmovdqa32(ymm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F17D286F4C1A04" , vmovdqa32(ymm1, ymmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F17D287F5C1104" , vmovdqa32(ptr(rcx, rdx, 0, 128), ymm3)); + TEST_INSTRUCTION("62F17D287F5C1104" , vmovdqa32(ymmword_ptr(rcx, rdx, 0, 128), ymm3)); + TEST_INSTRUCTION("62F17D486FCA" , vmovdqa32(zmm1, zmm2)); + TEST_INSTRUCTION("62F17D486F4C1A02" , vmovdqa32(zmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F17D486F4C1A02" , vmovdqa32(zmm1, zmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F17D487F5C1102" , vmovdqa32(ptr(rcx, rdx, 0, 128), zmm3)); + TEST_INSTRUCTION("62F17D487F5C1102" , vmovdqa32(zmmword_ptr(rcx, rdx, 0, 128), zmm3)); + TEST_INSTRUCTION("62F1FD086FCA" , vmovdqa64(xmm1, xmm2)); + TEST_INSTRUCTION("62F1FD086F4C1A08" , vmovdqa64(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F1FD086F4C1A08" , vmovdqa64(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F1FD087F5C1108" , vmovdqa64(ptr(rcx, rdx, 0, 128), xmm3)); + TEST_INSTRUCTION("62F1FD087F5C1108" , vmovdqa64(xmmword_ptr(rcx, rdx, 0, 128), xmm3)); + TEST_INSTRUCTION("62F1FD286FCA" , vmovdqa64(ymm1, ymm2)); + TEST_INSTRUCTION("62F1FD286F4C1A04" , vmovdqa64(ymm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F1FD286F4C1A04" , vmovdqa64(ymm1, ymmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F1FD287F5C1104" , vmovdqa64(ptr(rcx, rdx, 0, 128), ymm3)); + TEST_INSTRUCTION("62F1FD287F5C1104" , vmovdqa64(ymmword_ptr(rcx, rdx, 0, 128), ymm3)); + TEST_INSTRUCTION("62F1FD486FCA" , vmovdqa64(zmm1, zmm2)); + TEST_INSTRUCTION("62F1FD486F4C1A02" , vmovdqa64(zmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F1FD486F4C1A02" , vmovdqa64(zmm1, zmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F1FD487F5C1102" , vmovdqa64(ptr(rcx, rdx, 0, 128), zmm3)); + TEST_INSTRUCTION("62F1FD487F5C1102" , vmovdqa64(zmmword_ptr(rcx, rdx, 0, 128), zmm3)); + TEST_INSTRUCTION("C5FA6FCA" , vmovdqu(xmm1, xmm2)); + TEST_INSTRUCTION("C5FA6F8C1A80000000" , vmovdqu(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C5FA6F8C1A80000000" , vmovdqu(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C5FA7F9C1180000000" , vmovdqu(ptr(rcx, rdx, 0, 128), xmm3)); + TEST_INSTRUCTION("C5FA7F9C1180000000" , vmovdqu(xmmword_ptr(rcx, rdx, 0, 128), xmm3)); + TEST_INSTRUCTION("C5FE6FCA" , vmovdqu(ymm1, ymm2)); + TEST_INSTRUCTION("C5FE6F8C1A80000000" , vmovdqu(ymm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C5FE6F8C1A80000000" , vmovdqu(ymm1, ymmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C5FE7F9C1180000000" , vmovdqu(ptr(rcx, rdx, 0, 128), ymm3)); + TEST_INSTRUCTION("C5FE7F9C1180000000" , vmovdqu(ymmword_ptr(rcx, rdx, 0, 128), ymm3)); + TEST_INSTRUCTION("62F1FF086FCA" , vmovdqu16(xmm1, xmm2)); + TEST_INSTRUCTION("62F1FF086F4C1A08" , vmovdqu16(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F1FF086F4C1A08" , vmovdqu16(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F1FF087F5C1108" , vmovdqu16(ptr(rcx, rdx, 0, 128), xmm3)); + TEST_INSTRUCTION("62F1FF087F5C1108" , vmovdqu16(xmmword_ptr(rcx, rdx, 0, 128), xmm3)); + TEST_INSTRUCTION("62F1FF286FCA" , vmovdqu16(ymm1, ymm2)); + TEST_INSTRUCTION("62F1FF286F4C1A04" , vmovdqu16(ymm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F1FF286F4C1A04" , vmovdqu16(ymm1, ymmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F1FF287F5C1104" , vmovdqu16(ptr(rcx, rdx, 0, 128), ymm3)); + TEST_INSTRUCTION("62F1FF287F5C1104" , vmovdqu16(ymmword_ptr(rcx, rdx, 0, 128), ymm3)); + TEST_INSTRUCTION("62F1FF486FCA" , vmovdqu16(zmm1, zmm2)); + TEST_INSTRUCTION("62F1FF486F4C1A02" , vmovdqu16(zmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F1FF486F4C1A02" , vmovdqu16(zmm1, zmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F1FF487F5C1102" , vmovdqu16(ptr(rcx, rdx, 0, 128), zmm3)); + TEST_INSTRUCTION("62F1FF487F5C1102" , vmovdqu16(zmmword_ptr(rcx, rdx, 0, 128), zmm3)); + TEST_INSTRUCTION("62F17E086FCA" , vmovdqu32(xmm1, xmm2)); + TEST_INSTRUCTION("62F17E086F4C1A08" , vmovdqu32(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F17E086F4C1A08" , vmovdqu32(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F17E087F5C1108" , vmovdqu32(ptr(rcx, rdx, 0, 128), xmm3)); + TEST_INSTRUCTION("62F17E087F5C1108" , vmovdqu32(xmmword_ptr(rcx, rdx, 0, 128), xmm3)); + TEST_INSTRUCTION("62F17E286FCA" , vmovdqu32(ymm1, ymm2)); + TEST_INSTRUCTION("62F17E286F4C1A04" , vmovdqu32(ymm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F17E286F4C1A04" , vmovdqu32(ymm1, ymmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F17E287F5C1104" , vmovdqu32(ptr(rcx, rdx, 0, 128), ymm3)); + TEST_INSTRUCTION("62F17E287F5C1104" , vmovdqu32(ymmword_ptr(rcx, rdx, 0, 128), ymm3)); + TEST_INSTRUCTION("62F17E486FCA" , vmovdqu32(zmm1, zmm2)); + TEST_INSTRUCTION("62F17E486F4C1A02" , vmovdqu32(zmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F17E486F4C1A02" , vmovdqu32(zmm1, zmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F17E487F5C1102" , vmovdqu32(ptr(rcx, rdx, 0, 128), zmm3)); + TEST_INSTRUCTION("62F17E487F5C1102" , vmovdqu32(zmmword_ptr(rcx, rdx, 0, 128), zmm3)); + TEST_INSTRUCTION("62F1FE086FCA" , vmovdqu64(xmm1, xmm2)); + TEST_INSTRUCTION("62F1FE086F4C1A08" , vmovdqu64(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F1FE086F4C1A08" , vmovdqu64(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F1FE087F5C1108" , vmovdqu64(ptr(rcx, rdx, 0, 128), xmm3)); + TEST_INSTRUCTION("62F1FE087F5C1108" , vmovdqu64(xmmword_ptr(rcx, rdx, 0, 128), xmm3)); + TEST_INSTRUCTION("62F1FE286FCA" , vmovdqu64(ymm1, ymm2)); + TEST_INSTRUCTION("62F1FE286F4C1A04" , vmovdqu64(ymm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F1FE286F4C1A04" , vmovdqu64(ymm1, ymmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F1FE287F5C1104" , vmovdqu64(ptr(rcx, rdx, 0, 128), ymm3)); + TEST_INSTRUCTION("62F1FE287F5C1104" , vmovdqu64(ymmword_ptr(rcx, rdx, 0, 128), ymm3)); + TEST_INSTRUCTION("62F1FE486FCA" , vmovdqu64(zmm1, zmm2)); + TEST_INSTRUCTION("62F1FE486F4C1A02" , vmovdqu64(zmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F1FE486F4C1A02" , vmovdqu64(zmm1, zmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F1FE487F5C1102" , vmovdqu64(ptr(rcx, rdx, 0, 128), zmm3)); + TEST_INSTRUCTION("62F1FE487F5C1102" , vmovdqu64(zmmword_ptr(rcx, rdx, 0, 128), zmm3)); + TEST_INSTRUCTION("62F17F086FCA" , vmovdqu8(xmm1, xmm2)); + TEST_INSTRUCTION("62F17F086F4C1A08" , vmovdqu8(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F17F086F4C1A08" , vmovdqu8(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F17F087F5C1108" , vmovdqu8(ptr(rcx, rdx, 0, 128), xmm3)); + TEST_INSTRUCTION("62F17F087F5C1108" , vmovdqu8(xmmword_ptr(rcx, rdx, 0, 128), xmm3)); + TEST_INSTRUCTION("62F17F286FCA" , vmovdqu8(ymm1, ymm2)); + TEST_INSTRUCTION("62F17F286F4C1A04" , vmovdqu8(ymm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F17F286F4C1A04" , vmovdqu8(ymm1, ymmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F17F287F5C1104" , vmovdqu8(ptr(rcx, rdx, 0, 128), ymm3)); + TEST_INSTRUCTION("62F17F287F5C1104" , vmovdqu8(ymmword_ptr(rcx, rdx, 0, 128), ymm3)); + TEST_INSTRUCTION("62F17F486FCA" , vmovdqu8(zmm1, zmm2)); + TEST_INSTRUCTION("62F17F486F4C1A02" , vmovdqu8(zmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F17F486F4C1A02" , vmovdqu8(zmm1, zmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F17F487F5C1102" , vmovdqu8(ptr(rcx, rdx, 0, 128), zmm3)); + TEST_INSTRUCTION("62F17F487F5C1102" , vmovdqu8(zmmword_ptr(rcx, rdx, 0, 128), zmm3)); + TEST_INSTRUCTION("C5E812CB" , vmovhlps(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5F9179C1180000000" , vmovhpd(ptr(rcx, rdx, 0, 128), xmm3)); + TEST_INSTRUCTION("C5F9179C1180000000" , vmovhpd(qword_ptr(rcx, rdx, 0, 128), xmm3)); + TEST_INSTRUCTION("C5E9168C2B80000000" , vmovhpd(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5E9168C2B80000000" , vmovhpd(xmm1, xmm2, qword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5F8179C1180000000" , vmovhps(ptr(rcx, rdx, 0, 128), xmm3)); + TEST_INSTRUCTION("C5F8179C1180000000" , vmovhps(qword_ptr(rcx, rdx, 0, 128), xmm3)); + TEST_INSTRUCTION("C5E8168C2B80000000" , vmovhps(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5E8168C2B80000000" , vmovhps(xmm1, xmm2, qword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5E816CB" , vmovlhps(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5F9139C1180000000" , vmovlpd(ptr(rcx, rdx, 0, 128), xmm3)); + TEST_INSTRUCTION("C5F9139C1180000000" , vmovlpd(qword_ptr(rcx, rdx, 0, 128), xmm3)); + TEST_INSTRUCTION("C5E9128C2B80000000" , vmovlpd(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5E9128C2B80000000" , vmovlpd(xmm1, xmm2, qword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5F8139C1180000000" , vmovlps(ptr(rcx, rdx, 0, 128), xmm3)); + TEST_INSTRUCTION("C5F8139C1180000000" , vmovlps(qword_ptr(rcx, rdx, 0, 128), xmm3)); + TEST_INSTRUCTION("C5E8128C2B80000000" , vmovlps(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5E8128C2B80000000" , vmovlps(xmm1, xmm2, qword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5F950CA" , vmovmskpd(ecx, xmm2)); + TEST_INSTRUCTION("C5FD50CA" , vmovmskpd(ecx, ymm2)); + TEST_INSTRUCTION("C5F850CA" , vmovmskps(ecx, xmm2)); + TEST_INSTRUCTION("C5FC50CA" , vmovmskps(ecx, ymm2)); + TEST_INSTRUCTION("C5F9E79C1180000000" , vmovntdq(ptr(rcx, rdx, 0, 128), xmm3)); + TEST_INSTRUCTION("C5F9E79C1180000000" , vmovntdq(xmmword_ptr(rcx, rdx, 0, 128), xmm3)); + TEST_INSTRUCTION("C5FDE79C1180000000" , vmovntdq(ptr(rcx, rdx, 0, 128), ymm3)); + TEST_INSTRUCTION("C5FDE79C1180000000" , vmovntdq(ymmword_ptr(rcx, rdx, 0, 128), ymm3)); + TEST_INSTRUCTION("62F17D48E75C1102" , vmovntdq(ptr(rcx, rdx, 0, 128), zmm3)); + TEST_INSTRUCTION("62F17D48E75C1102" , vmovntdq(zmmword_ptr(rcx, rdx, 0, 128), zmm3)); + TEST_INSTRUCTION("C4E2792A8C1A80000000" , vmovntdqa(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C4E2792A8C1A80000000" , vmovntdqa(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C4E27D2A8C1A80000000" , vmovntdqa(ymm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C4E27D2A8C1A80000000" , vmovntdqa(ymm1, ymmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F27D482A4C1A02" , vmovntdqa(zmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F27D482A4C1A02" , vmovntdqa(zmm1, zmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C5F92B9C1180000000" , vmovntpd(ptr(rcx, rdx, 0, 128), xmm3)); + TEST_INSTRUCTION("C5F92B9C1180000000" , vmovntpd(xmmword_ptr(rcx, rdx, 0, 128), xmm3)); + TEST_INSTRUCTION("C5FD2B9C1180000000" , vmovntpd(ptr(rcx, rdx, 0, 128), ymm3)); + TEST_INSTRUCTION("C5FD2B9C1180000000" , vmovntpd(ymmword_ptr(rcx, rdx, 0, 128), ymm3)); + TEST_INSTRUCTION("62F1FD482B5C1102" , vmovntpd(ptr(rcx, rdx, 0, 128), zmm3)); + TEST_INSTRUCTION("62F1FD482B5C1102" , vmovntpd(zmmword_ptr(rcx, rdx, 0, 128), zmm3)); + TEST_INSTRUCTION("C5F82B9C1180000000" , vmovntps(ptr(rcx, rdx, 0, 128), xmm3)); + TEST_INSTRUCTION("C5F82B9C1180000000" , vmovntps(xmmword_ptr(rcx, rdx, 0, 128), xmm3)); + TEST_INSTRUCTION("C5FC2B9C1180000000" , vmovntps(ptr(rcx, rdx, 0, 128), ymm3)); + TEST_INSTRUCTION("C5FC2B9C1180000000" , vmovntps(ymmword_ptr(rcx, rdx, 0, 128), ymm3)); + TEST_INSTRUCTION("62F17C482B5C1102" , vmovntps(ptr(rcx, rdx, 0, 128), zmm3)); + TEST_INSTRUCTION("62F17C482B5C1102" , vmovntps(zmmword_ptr(rcx, rdx, 0, 128), zmm3)); + TEST_INSTRUCTION("C4E1F97ED1" , vmovq(rcx, xmm2)); + TEST_INSTRUCTION("C5F9D69C1180000000" , vmovq(ptr(rcx, rdx, 0, 128), xmm3)); + TEST_INSTRUCTION("C5F9D69C1180000000" , vmovq(qword_ptr(rcx, rdx, 0, 128), xmm3)); + TEST_INSTRUCTION("C4E1F96ECA" , vmovq(xmm1, rdx)); + TEST_INSTRUCTION("C5FA7ECA" , vmovq(xmm1, xmm2)); + TEST_INSTRUCTION("C5FA7E8C1A80000000" , vmovq(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C5FA7E8C1A80000000" , vmovq(xmm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C5FB119C1180000000" , vmovsd(ptr(rcx, rdx, 0, 128), xmm3)); + TEST_INSTRUCTION("C5FB119C1180000000" , vmovsd(qword_ptr(rcx, rdx, 0, 128), xmm3)); + TEST_INSTRUCTION("C5FB108C1A80000000" , vmovsd(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C5FB108C1A80000000" , vmovsd(xmm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C5EB10CB" , vmovsd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5FA16CA" , vmovshdup(xmm1, xmm2)); + TEST_INSTRUCTION("C5FA168C1A80000000" , vmovshdup(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C5FA168C1A80000000" , vmovshdup(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C5FE16CA" , vmovshdup(ymm1, ymm2)); + TEST_INSTRUCTION("C5FE168C1A80000000" , vmovshdup(ymm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C5FE168C1A80000000" , vmovshdup(ymm1, ymmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F17E4816CA" , vmovshdup(zmm1, zmm2)); + TEST_INSTRUCTION("62F17E48164C1A02" , vmovshdup(zmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F17E48164C1A02" , vmovshdup(zmm1, zmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C5FA12CA" , vmovsldup(xmm1, xmm2)); + TEST_INSTRUCTION("C5FA128C1A80000000" , vmovsldup(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C5FA128C1A80000000" , vmovsldup(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C5FE12CA" , vmovsldup(ymm1, ymm2)); + TEST_INSTRUCTION("C5FE128C1A80000000" , vmovsldup(ymm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C5FE128C1A80000000" , vmovsldup(ymm1, ymmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F17E4812CA" , vmovsldup(zmm1, zmm2)); + TEST_INSTRUCTION("62F17E48124C1A02" , vmovsldup(zmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F17E48124C1A02" , vmovsldup(zmm1, zmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C5FA119C1180000000" , vmovss(ptr(rcx, rdx, 0, 128), xmm3)); + TEST_INSTRUCTION("C5FA119C1180000000" , vmovss(dword_ptr(rcx, rdx, 0, 128), xmm3)); + TEST_INSTRUCTION("C5FA108C1A80000000" , vmovss(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C5FA108C1A80000000" , vmovss(xmm1, dword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C5EA10CB" , vmovss(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5F910CA" , vmovupd(xmm1, xmm2)); + TEST_INSTRUCTION("C5F9108C1A80000000" , vmovupd(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C5F9108C1A80000000" , vmovupd(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C5F9119C1180000000" , vmovupd(ptr(rcx, rdx, 0, 128), xmm3)); + TEST_INSTRUCTION("C5F9119C1180000000" , vmovupd(xmmword_ptr(rcx, rdx, 0, 128), xmm3)); + TEST_INSTRUCTION("C5FD10CA" , vmovupd(ymm1, ymm2)); + TEST_INSTRUCTION("C5FD108C1A80000000" , vmovupd(ymm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C5FD108C1A80000000" , vmovupd(ymm1, ymmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C5FD119C1180000000" , vmovupd(ptr(rcx, rdx, 0, 128), ymm3)); + TEST_INSTRUCTION("C5FD119C1180000000" , vmovupd(ymmword_ptr(rcx, rdx, 0, 128), ymm3)); + TEST_INSTRUCTION("62F1FD4810CA" , vmovupd(zmm1, zmm2)); + TEST_INSTRUCTION("62F1FD48104C1A02" , vmovupd(zmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F1FD48104C1A02" , vmovupd(zmm1, zmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F1FD48115C1102" , vmovupd(ptr(rcx, rdx, 0, 128), zmm3)); + TEST_INSTRUCTION("62F1FD48115C1102" , vmovupd(zmmword_ptr(rcx, rdx, 0, 128), zmm3)); + TEST_INSTRUCTION("C5F810CA" , vmovups(xmm1, xmm2)); + TEST_INSTRUCTION("C5F8108C1A80000000" , vmovups(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C5F8108C1A80000000" , vmovups(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C5F8119C1180000000" , vmovups(ptr(rcx, rdx, 0, 128), xmm3)); + TEST_INSTRUCTION("C5F8119C1180000000" , vmovups(xmmword_ptr(rcx, rdx, 0, 128), xmm3)); + TEST_INSTRUCTION("C5FC10CA" , vmovups(ymm1, ymm2)); + TEST_INSTRUCTION("C5FC108C1A80000000" , vmovups(ymm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C5FC108C1A80000000" , vmovups(ymm1, ymmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C5FC119C1180000000" , vmovups(ptr(rcx, rdx, 0, 128), ymm3)); + TEST_INSTRUCTION("C5FC119C1180000000" , vmovups(ymmword_ptr(rcx, rdx, 0, 128), ymm3)); + TEST_INSTRUCTION("62F17C4810CA" , vmovups(zmm1, zmm2)); + TEST_INSTRUCTION("62F17C48104C1A02" , vmovups(zmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F17C48104C1A02" , vmovups(zmm1, zmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F17C48115C1102" , vmovups(ptr(rcx, rdx, 0, 128), zmm3)); + TEST_INSTRUCTION("62F17C48115C1102" , vmovups(zmmword_ptr(rcx, rdx, 0, 128), zmm3)); + TEST_INSTRUCTION("C4E36942CB01" , vmpsadbw(xmm1, xmm2, xmm3, 1)); + TEST_INSTRUCTION("C4E369428C2B8000000001" , vmpsadbw(xmm1, xmm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("C4E369428C2B8000000001" , vmpsadbw(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("C4E36D42CB01" , vmpsadbw(ymm1, ymm2, ymm3, 1)); + TEST_INSTRUCTION("C4E36D428C2B8000000001" , vmpsadbw(ymm1, ymm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("C4E36D428C2B8000000001" , vmpsadbw(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("C5E959CB" , vmulpd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5E9598C2B80000000" , vmulpd(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5E9598C2B80000000" , vmulpd(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5ED59CB" , vmulpd(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C5ED598C2B80000000" , vmulpd(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5ED598C2B80000000" , vmulpd(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F1ED4859CB" , vmulpd(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F1ED48594C2B02" , vmulpd(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F1ED48594C2B02" , vmulpd(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5E859CB" , vmulps(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5E8598C2B80000000" , vmulps(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5E8598C2B80000000" , vmulps(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5EC59CB" , vmulps(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C5EC598C2B80000000" , vmulps(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5EC598C2B80000000" , vmulps(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16C4859CB" , vmulps(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F16C48594C2B02" , vmulps(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16C48594C2B02" , vmulps(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5EB59CB" , vmulsd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5EB598C2B80000000" , vmulsd(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5EB598C2B80000000" , vmulsd(xmm1, xmm2, qword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5EA59CB" , vmulss(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5EA598C2B80000000" , vmulss(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5EA598C2B80000000" , vmulss(xmm1, xmm2, dword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5E956CB" , vorpd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5E9568C2B80000000" , vorpd(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5E9568C2B80000000" , vorpd(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5ED56CB" , vorpd(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C5ED568C2B80000000" , vorpd(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5ED568C2B80000000" , vorpd(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F1ED4856CB" , vorpd(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F1ED48564C2B02" , vorpd(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F1ED48564C2B02" , vorpd(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5E856CB" , vorps(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5E8568C2B80000000" , vorps(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5E8568C2B80000000" , vorps(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5EC56CB" , vorps(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C5EC568C2B80000000" , vorps(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5EC568C2B80000000" , vorps(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16C4856CB" , vorps(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F16C48564C2B02" , vorps(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16C48564C2B02" , vorps(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F25F0868D1" , vp2intersectd(k2, k3, xmm4, xmm1)); + TEST_INSTRUCTION("62F25F0868541108" , vp2intersectd(k2, k3, xmm4, ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("62F25F0868541108" , vp2intersectd(k2, k3, xmm4, xmmword_ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("62F25F2868D1" , vp2intersectd(k2, k3, ymm4, ymm1)); + TEST_INSTRUCTION("62F25F2868541104" , vp2intersectd(k2, k3, ymm4, ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("62F25F2868541104" , vp2intersectd(k2, k3, ymm4, ymmword_ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("62F25F4868D1" , vp2intersectd(k2, k3, zmm4, zmm1)); + TEST_INSTRUCTION("62F25F4868541102" , vp2intersectd(k2, k3, zmm4, ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("62F25F4868541102" , vp2intersectd(k2, k3, zmm4, zmmword_ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("62F2DF0868D1" , vp2intersectq(k2, k3, xmm4, xmm1)); + TEST_INSTRUCTION("62F2DF0868541108" , vp2intersectq(k2, k3, xmm4, ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("62F2DF0868541108" , vp2intersectq(k2, k3, xmm4, xmmword_ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("62F2DF2868D1" , vp2intersectq(k2, k3, ymm4, ymm1)); + TEST_INSTRUCTION("62F2DF2868541104" , vp2intersectq(k2, k3, ymm4, ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("62F2DF2868541104" , vp2intersectq(k2, k3, ymm4, ymmword_ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("62F2DF4868D1" , vp2intersectq(k2, k3, zmm4, zmm1)); + TEST_INSTRUCTION("62F2DF4868541102" , vp2intersectq(k2, k3, zmm4, ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("62F2DF4868541102" , vp2intersectq(k2, k3, zmm4, zmmword_ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("62F25F48524C1A08" , vp4dpwssd(zmm1, zmm4, zmm5, zmm6, zmm7, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F25F48524C1A08" , vp4dpwssd(zmm1, zmm4, zmm5, zmm6, zmm7, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F25F48534C1A08" , vp4dpwssds(zmm1, zmm4, zmm5, zmm6, zmm7, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F25F48534C1A08" , vp4dpwssds(zmm1, zmm4, zmm5, zmm6, zmm7, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C4E2791CCA" , vpabsb(xmm1, xmm2)); + TEST_INSTRUCTION("C4E2791C8C1A80000000" , vpabsb(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C4E2791C8C1A80000000" , vpabsb(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C4E27D1CCA" , vpabsb(ymm1, ymm2)); + TEST_INSTRUCTION("C4E27D1C8C1A80000000" , vpabsb(ymm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C4E27D1C8C1A80000000" , vpabsb(ymm1, ymmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F27D481CCA" , vpabsb(zmm1, zmm2)); + TEST_INSTRUCTION("62F27D481C4C1A02" , vpabsb(zmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F27D481C4C1A02" , vpabsb(zmm1, zmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C4E2791ECA" , vpabsd(xmm1, xmm2)); + TEST_INSTRUCTION("C4E2791E8C1A80000000" , vpabsd(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C4E2791E8C1A80000000" , vpabsd(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C4E27D1ECA" , vpabsd(ymm1, ymm2)); + TEST_INSTRUCTION("C4E27D1E8C1A80000000" , vpabsd(ymm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C4E27D1E8C1A80000000" , vpabsd(ymm1, ymmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F27D481ECA" , vpabsd(zmm1, zmm2)); + TEST_INSTRUCTION("62F27D481E4C1A02" , vpabsd(zmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F27D481E4C1A02" , vpabsd(zmm1, zmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F2FD081FCA" , vpabsq(xmm1, xmm2)); + TEST_INSTRUCTION("62F2FD081F4C1A08" , vpabsq(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F2FD081F4C1A08" , vpabsq(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F2FD281FCA" , vpabsq(ymm1, ymm2)); + TEST_INSTRUCTION("62F2FD281F4C1A04" , vpabsq(ymm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F2FD281F4C1A04" , vpabsq(ymm1, ymmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F2FD481FCA" , vpabsq(zmm1, zmm2)); + TEST_INSTRUCTION("62F2FD481F4C1A02" , vpabsq(zmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F2FD481F4C1A02" , vpabsq(zmm1, zmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C4E2791DCA" , vpabsw(xmm1, xmm2)); + TEST_INSTRUCTION("C4E2791D8C1A80000000" , vpabsw(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C4E2791D8C1A80000000" , vpabsw(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C4E27D1DCA" , vpabsw(ymm1, ymm2)); + TEST_INSTRUCTION("C4E27D1D8C1A80000000" , vpabsw(ymm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C4E27D1D8C1A80000000" , vpabsw(ymm1, ymmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F27D481DCA" , vpabsw(zmm1, zmm2)); + TEST_INSTRUCTION("62F27D481D4C1A02" , vpabsw(zmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F27D481D4C1A02" , vpabsw(zmm1, zmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C5E96BCB" , vpackssdw(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5E96B8C2B80000000" , vpackssdw(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5E96B8C2B80000000" , vpackssdw(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5ED6BCB" , vpackssdw(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C5ED6B8C2B80000000" , vpackssdw(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5ED6B8C2B80000000" , vpackssdw(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16D486BCB" , vpackssdw(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F16D486B4C2B02" , vpackssdw(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16D486B4C2B02" , vpackssdw(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5E963CB" , vpacksswb(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5E9638C2B80000000" , vpacksswb(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5E9638C2B80000000" , vpacksswb(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5ED63CB" , vpacksswb(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C5ED638C2B80000000" , vpacksswb(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5ED638C2B80000000" , vpacksswb(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16D4863CB" , vpacksswb(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F16D48634C2B02" , vpacksswb(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16D48634C2B02" , vpacksswb(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E2692BCB" , vpackusdw(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E2692B8C2B80000000" , vpackusdw(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E2692B8C2B80000000" , vpackusdw(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E26D2BCB" , vpackusdw(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C4E26D2B8C2B80000000" , vpackusdw(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E26D2B8C2B80000000" , vpackusdw(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D482BCB" , vpackusdw(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F26D482B4C2B02" , vpackusdw(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D482B4C2B02" , vpackusdw(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5E967CB" , vpackuswb(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5E9678C2B80000000" , vpackuswb(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5E9678C2B80000000" , vpackuswb(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5ED67CB" , vpackuswb(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C5ED678C2B80000000" , vpackuswb(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5ED678C2B80000000" , vpackuswb(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16D4867CB" , vpackuswb(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F16D48674C2B02" , vpackuswb(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16D48674C2B02" , vpackuswb(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5E9FCCB" , vpaddb(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5E9FC8C2B80000000" , vpaddb(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5E9FC8C2B80000000" , vpaddb(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5EDFCCB" , vpaddb(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C5EDFC8C2B80000000" , vpaddb(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5EDFC8C2B80000000" , vpaddb(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16D48FCCB" , vpaddb(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F16D48FC4C2B02" , vpaddb(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16D48FC4C2B02" , vpaddb(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5E9FECB" , vpaddd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5E9FE8C2B80000000" , vpaddd(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5E9FE8C2B80000000" , vpaddd(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5EDFECB" , vpaddd(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C5EDFE8C2B80000000" , vpaddd(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5EDFE8C2B80000000" , vpaddd(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16D48FECB" , vpaddd(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F16D48FE4C2B02" , vpaddd(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16D48FE4C2B02" , vpaddd(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5E9D4CB" , vpaddq(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5E9D48C2B80000000" , vpaddq(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5E9D48C2B80000000" , vpaddq(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5EDD4CB" , vpaddq(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C5EDD48C2B80000000" , vpaddq(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5EDD48C2B80000000" , vpaddq(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F1ED48D4CB" , vpaddq(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F1ED48D44C2B02" , vpaddq(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F1ED48D44C2B02" , vpaddq(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5E9ECCB" , vpaddsb(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5E9EC8C2B80000000" , vpaddsb(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5E9EC8C2B80000000" , vpaddsb(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5EDECCB" , vpaddsb(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C5EDEC8C2B80000000" , vpaddsb(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5EDEC8C2B80000000" , vpaddsb(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16D48ECCB" , vpaddsb(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F16D48EC4C2B02" , vpaddsb(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16D48EC4C2B02" , vpaddsb(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5E9EDCB" , vpaddsw(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5E9ED8C2B80000000" , vpaddsw(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5E9ED8C2B80000000" , vpaddsw(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5EDEDCB" , vpaddsw(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C5EDED8C2B80000000" , vpaddsw(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5EDED8C2B80000000" , vpaddsw(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16D48EDCB" , vpaddsw(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F16D48ED4C2B02" , vpaddsw(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16D48ED4C2B02" , vpaddsw(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5E9DCCB" , vpaddusb(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5E9DC8C2B80000000" , vpaddusb(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5E9DC8C2B80000000" , vpaddusb(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5EDDCCB" , vpaddusb(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C5EDDC8C2B80000000" , vpaddusb(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5EDDC8C2B80000000" , vpaddusb(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16D48DCCB" , vpaddusb(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F16D48DC4C2B02" , vpaddusb(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16D48DC4C2B02" , vpaddusb(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5E9DDCB" , vpaddusw(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5E9DD8C2B80000000" , vpaddusw(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5E9DD8C2B80000000" , vpaddusw(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5EDDDCB" , vpaddusw(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C5EDDD8C2B80000000" , vpaddusw(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5EDDD8C2B80000000" , vpaddusw(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16D48DDCB" , vpaddusw(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F16D48DD4C2B02" , vpaddusw(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16D48DD4C2B02" , vpaddusw(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5E9FDCB" , vpaddw(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5E9FD8C2B80000000" , vpaddw(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5E9FD8C2B80000000" , vpaddw(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5EDFDCB" , vpaddw(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C5EDFD8C2B80000000" , vpaddw(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5EDFD8C2B80000000" , vpaddw(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16D48FDCB" , vpaddw(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F16D48FD4C2B02" , vpaddw(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16D48FD4C2B02" , vpaddw(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E3690FCB01" , vpalignr(xmm1, xmm2, xmm3, 1)); + TEST_INSTRUCTION("C4E3690F8C2B8000000001" , vpalignr(xmm1, xmm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("C4E3690F8C2B8000000001" , vpalignr(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("C4E36D0FCB01" , vpalignr(ymm1, ymm2, ymm3, 1)); + TEST_INSTRUCTION("C4E36D0F8C2B8000000001" , vpalignr(ymm1, ymm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("C4E36D0F8C2B8000000001" , vpalignr(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D480FCB01" , vpalignr(zmm1, zmm2, zmm3, 1)); + TEST_INSTRUCTION("62F36D480F4C2B0201" , vpalignr(zmm1, zmm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D480F4C2B0201" , vpalignr(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("C5E9DBCB" , vpand(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5E9DB8C2B80000000" , vpand(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5E9DB8C2B80000000" , vpand(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5EDDBCB" , vpand(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C5EDDB8C2B80000000" , vpand(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5EDDB8C2B80000000" , vpand(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16D08DBCB" , vpandd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("62F16D08DB4C2B08" , vpandd(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16D08DB4C2B08" , vpandd(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16D28DBCB" , vpandd(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("62F16D28DB4C2B04" , vpandd(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16D28DB4C2B04" , vpandd(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16D48DBCB" , vpandd(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F16D48DB4C2B02" , vpandd(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16D48DB4C2B02" , vpandd(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5E9DFCB" , vpandn(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5E9DF8C2B80000000" , vpandn(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5E9DF8C2B80000000" , vpandn(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5EDDFCB" , vpandn(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C5EDDF8C2B80000000" , vpandn(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5EDDF8C2B80000000" , vpandn(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16D08DFCB" , vpandnd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("62F16D08DF4C2B08" , vpandnd(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16D08DF4C2B08" , vpandnd(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16D28DFCB" , vpandnd(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("62F16D28DF4C2B04" , vpandnd(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16D28DF4C2B04" , vpandnd(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16D48DFCB" , vpandnd(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F16D48DF4C2B02" , vpandnd(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16D48DF4C2B02" , vpandnd(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F1ED08DFCB" , vpandnq(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("62F1ED08DF4C2B08" , vpandnq(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F1ED08DF4C2B08" , vpandnq(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F1ED28DFCB" , vpandnq(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("62F1ED28DF4C2B04" , vpandnq(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F1ED28DF4C2B04" , vpandnq(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F1ED48DFCB" , vpandnq(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F1ED48DF4C2B02" , vpandnq(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F1ED48DF4C2B02" , vpandnq(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F1ED08DBCB" , vpandq(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("62F1ED08DB4C2B08" , vpandq(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F1ED08DB4C2B08" , vpandq(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F1ED28DBCB" , vpandq(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("62F1ED28DB4C2B04" , vpandq(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F1ED28DB4C2B04" , vpandq(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F1ED48DBCB" , vpandq(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F1ED48DB4C2B02" , vpandq(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F1ED48DB4C2B02" , vpandq(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5E9E0CB" , vpavgb(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5E9E08C2B80000000" , vpavgb(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5E9E08C2B80000000" , vpavgb(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5EDE0CB" , vpavgb(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C5EDE08C2B80000000" , vpavgb(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5EDE08C2B80000000" , vpavgb(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16D48E0CB" , vpavgb(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F16D48E04C2B02" , vpavgb(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16D48E04C2B02" , vpavgb(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5E9E3CB" , vpavgw(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5E9E38C2B80000000" , vpavgw(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5E9E38C2B80000000" , vpavgw(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5EDE3CB" , vpavgw(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C5EDE38C2B80000000" , vpavgw(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5EDE38C2B80000000" , vpavgw(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16D48E3CB" , vpavgw(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F16D48E34C2B02" , vpavgw(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16D48E34C2B02" , vpavgw(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E36902CB01" , vpblendd(xmm1, xmm2, xmm3, 1)); + TEST_INSTRUCTION("C4E369028C2B8000000001" , vpblendd(xmm1, xmm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("C4E369028C2B8000000001" , vpblendd(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("C4E36D02CB01" , vpblendd(ymm1, ymm2, ymm3, 1)); + TEST_INSTRUCTION("C4E36D028C2B8000000001" , vpblendd(ymm1, ymm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("C4E36D028C2B8000000001" , vpblendd(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F26D0866CB" , vpblendmb(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("62F26D08664C2B08" , vpblendmb(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D08664C2B08" , vpblendmb(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D2866CB" , vpblendmb(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("62F26D28664C2B04" , vpblendmb(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D28664C2B04" , vpblendmb(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D4866CB" , vpblendmb(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F26D48664C2B02" , vpblendmb(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D48664C2B02" , vpblendmb(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D0864CB" , vpblendmd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("62F26D08644C2B08" , vpblendmd(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D08644C2B08" , vpblendmd(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D2864CB" , vpblendmd(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("62F26D28644C2B04" , vpblendmd(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D28644C2B04" , vpblendmd(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D4864CB" , vpblendmd(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F26D48644C2B02" , vpblendmd(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D48644C2B02" , vpblendmd(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED0864CB" , vpblendmq(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("62F2ED08644C2B08" , vpblendmq(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED08644C2B08" , vpblendmq(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED2864CB" , vpblendmq(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("62F2ED28644C2B04" , vpblendmq(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED28644C2B04" , vpblendmq(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED4864CB" , vpblendmq(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F2ED48644C2B02" , vpblendmq(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED48644C2B02" , vpblendmq(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED0866CB" , vpblendmw(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("62F2ED08664C2B08" , vpblendmw(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED08664C2B08" , vpblendmw(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED2866CB" , vpblendmw(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("62F2ED28664C2B04" , vpblendmw(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED28664C2B04" , vpblendmw(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED4866CB" , vpblendmw(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F2ED48664C2B02" , vpblendmw(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED48664C2B02" , vpblendmw(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E3694CCB40" , vpblendvb(xmm1, xmm2, xmm3, xmm4)); + TEST_INSTRUCTION("C4E3694C8C2B8000000060" , vpblendvb(xmm1, xmm2, ptr(rbx, rbp, 0, 128), xmm6)); + TEST_INSTRUCTION("C4E3694C8C2B8000000060" , vpblendvb(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128), xmm6)); + TEST_INSTRUCTION("C4E36D4CCB40" , vpblendvb(ymm1, ymm2, ymm3, ymm4)); + TEST_INSTRUCTION("C4E36D4C8C2B8000000060" , vpblendvb(ymm1, ymm2, ptr(rbx, rbp, 0, 128), ymm6)); + TEST_INSTRUCTION("C4E36D4C8C2B8000000060" , vpblendvb(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128), ymm6)); + TEST_INSTRUCTION("C4E3690ECB01" , vpblendw(xmm1, xmm2, xmm3, 1)); + TEST_INSTRUCTION("C4E3690E8C2B8000000001" , vpblendw(xmm1, xmm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("C4E3690E8C2B8000000001" , vpblendw(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("C4E36D0ECB01" , vpblendw(ymm1, ymm2, ymm3, 1)); + TEST_INSTRUCTION("C4E36D0E8C2B8000000001" , vpblendw(ymm1, ymm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("C4E36D0E8C2B8000000001" , vpblendw(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F27D087ACA" , vpbroadcastb(xmm1, edx)); + TEST_INSTRUCTION("C4E27978CA" , vpbroadcastb(xmm1, xmm2)); + TEST_INSTRUCTION("C4E279788C1A80000000" , vpbroadcastb(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C4E279788C1A80000000" , vpbroadcastb(xmm1, byte_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F27D287ACA" , vpbroadcastb(ymm1, edx)); + TEST_INSTRUCTION("C4E27D78CA" , vpbroadcastb(ymm1, xmm2)); + TEST_INSTRUCTION("C4E27D788C1A80000000" , vpbroadcastb(ymm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C4E27D788C1A80000000" , vpbroadcastb(ymm1, byte_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F27D487ACA" , vpbroadcastb(zmm1, edx)); + TEST_INSTRUCTION("62F27D4878CA" , vpbroadcastb(zmm1, xmm2)); + TEST_INSTRUCTION("62F27D48788C1A80000000" , vpbroadcastb(zmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F27D48788C1A80000000" , vpbroadcastb(zmm1, byte_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F27D087CCA" , vpbroadcastd(xmm1, edx)); + TEST_INSTRUCTION("C4E27958CA" , vpbroadcastd(xmm1, xmm2)); + TEST_INSTRUCTION("C4E279588C1A80000000" , vpbroadcastd(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C4E279588C1A80000000" , vpbroadcastd(xmm1, dword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F27D287CCA" , vpbroadcastd(ymm1, edx)); + TEST_INSTRUCTION("C4E27D58CA" , vpbroadcastd(ymm1, xmm2)); + TEST_INSTRUCTION("C4E27D588C1A80000000" , vpbroadcastd(ymm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C4E27D588C1A80000000" , vpbroadcastd(ymm1, dword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F27D487CCA" , vpbroadcastd(zmm1, edx)); + TEST_INSTRUCTION("62F27D4858CA" , vpbroadcastd(zmm1, xmm2)); + TEST_INSTRUCTION("62F27D48584C1A20" , vpbroadcastd(zmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F27D48584C1A20" , vpbroadcastd(zmm1, dword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F2FE082ACA" , vpbroadcastmb2q(xmm1, k2)); + TEST_INSTRUCTION("62F2FE282ACA" , vpbroadcastmb2q(ymm1, k2)); + TEST_INSTRUCTION("62F2FE482ACA" , vpbroadcastmb2q(zmm1, k2)); + TEST_INSTRUCTION("62F27E083ACA" , vpbroadcastmw2d(xmm1, k2)); + TEST_INSTRUCTION("62F27E283ACA" , vpbroadcastmw2d(ymm1, k2)); + TEST_INSTRUCTION("62F27E483ACA" , vpbroadcastmw2d(zmm1, k2)); + TEST_INSTRUCTION("62F2FD087CCA" , vpbroadcastq(xmm1, rdx)); + TEST_INSTRUCTION("C4E27959CA" , vpbroadcastq(xmm1, xmm2)); + TEST_INSTRUCTION("C4E279598C1A80000000" , vpbroadcastq(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C4E279598C1A80000000" , vpbroadcastq(xmm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F2FD287CCA" , vpbroadcastq(ymm1, rdx)); + TEST_INSTRUCTION("C4E27D59CA" , vpbroadcastq(ymm1, xmm2)); + TEST_INSTRUCTION("C4E27D598C1A80000000" , vpbroadcastq(ymm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C4E27D598C1A80000000" , vpbroadcastq(ymm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F2FD487CCA" , vpbroadcastq(zmm1, rdx)); + TEST_INSTRUCTION("62F2FD4859CA" , vpbroadcastq(zmm1, xmm2)); + TEST_INSTRUCTION("62F2FD48594C1A10" , vpbroadcastq(zmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F2FD48594C1A10" , vpbroadcastq(zmm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F27D087BCA" , vpbroadcastw(xmm1, edx)); + TEST_INSTRUCTION("C4E27979CA" , vpbroadcastw(xmm1, xmm2)); + TEST_INSTRUCTION("C4E279798C1A80000000" , vpbroadcastw(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C4E279798C1A80000000" , vpbroadcastw(xmm1, word_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F27D287BCA" , vpbroadcastw(ymm1, edx)); + TEST_INSTRUCTION("C4E27D79CA" , vpbroadcastw(ymm1, xmm2)); + TEST_INSTRUCTION("C4E27D798C1A80000000" , vpbroadcastw(ymm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C4E27D798C1A80000000" , vpbroadcastw(ymm1, word_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F27D487BCA" , vpbroadcastw(zmm1, edx)); + TEST_INSTRUCTION("62F27D4879CA" , vpbroadcastw(zmm1, xmm2)); + TEST_INSTRUCTION("62F27D48794C1A40" , vpbroadcastw(zmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F27D48794C1A40" , vpbroadcastw(zmm1, word_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C4E36944CB01" , vpclmulqdq(xmm1, xmm2, xmm3, 1)); + TEST_INSTRUCTION("C4E369448C2B8000000001" , vpclmulqdq(xmm1, xmm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("C4E369448C2B8000000001" , vpclmulqdq(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("C4E36D44CB01" , vpclmulqdq(ymm1, ymm2, ymm3, 1)); + TEST_INSTRUCTION("C4E36D448C2B8000000001" , vpclmulqdq(ymm1, ymm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("C4E36D448C2B8000000001" , vpclmulqdq(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D4844CB01" , vpclmulqdq(zmm1, zmm2, zmm3, 1)); + TEST_INSTRUCTION("62F36D48444C2B0201" , vpclmulqdq(zmm1, zmm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D48444C2B0201" , vpclmulqdq(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("8FE868A2CB40" , vpcmov(xmm1, xmm2, xmm3, xmm4)); + TEST_INSTRUCTION("8FE8E8A28C358000000030" , vpcmov(xmm1, xmm2, xmm3, ptr(rbp, rsi, 0, 128))); + TEST_INSTRUCTION("8FE8E8A28C358000000030" , vpcmov(xmm1, xmm2, xmm3, xmmword_ptr(rbp, rsi, 0, 128))); + TEST_INSTRUCTION("8FE868A28C2B8000000060" , vpcmov(xmm1, xmm2, ptr(rbx, rbp, 0, 128), xmm6)); + TEST_INSTRUCTION("8FE868A28C2B8000000060" , vpcmov(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128), xmm6)); + TEST_INSTRUCTION("8FE86CA2CB40" , vpcmov(ymm1, ymm2, ymm3, ymm4)); + TEST_INSTRUCTION("8FE8ECA28C358000000030" , vpcmov(ymm1, ymm2, ymm3, ptr(rbp, rsi, 0, 128))); + TEST_INSTRUCTION("8FE8ECA28C358000000030" , vpcmov(ymm1, ymm2, ymm3, ymmword_ptr(rbp, rsi, 0, 128))); + TEST_INSTRUCTION("8FE86CA28C2B8000000060" , vpcmov(ymm1, ymm2, ptr(rbx, rbp, 0, 128), ymm6)); + TEST_INSTRUCTION("8FE86CA28C2B8000000060" , vpcmov(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128), ymm6)); + TEST_INSTRUCTION("62F36D083FCB01" , vpcmpb(k1, xmm2, xmm3, 1)); + TEST_INSTRUCTION("62F36D083F4C2B0801" , vpcmpb(k1, xmm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D083F4C2B0801" , vpcmpb(k1, xmm2, xmmword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D283FCB01" , vpcmpb(k1, ymm2, ymm3, 1)); + TEST_INSTRUCTION("62F36D283F4C2B0401" , vpcmpb(k1, ymm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D283F4C2B0401" , vpcmpb(k1, ymm2, ymmword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D483FCB01" , vpcmpb(k1, zmm2, zmm3, 1)); + TEST_INSTRUCTION("62F36D483F4C2B0201" , vpcmpb(k1, zmm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D483F4C2B0201" , vpcmpb(k1, zmm2, zmmword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D081FCB01" , vpcmpd(k1, xmm2, xmm3, 1)); + TEST_INSTRUCTION("62F36D081F4C2B0801" , vpcmpd(k1, xmm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D081F4C2B0801" , vpcmpd(k1, xmm2, xmmword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D281FCB01" , vpcmpd(k1, ymm2, ymm3, 1)); + TEST_INSTRUCTION("62F36D281F4C2B0401" , vpcmpd(k1, ymm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D281F4C2B0401" , vpcmpd(k1, ymm2, ymmword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D481FCB01" , vpcmpd(k1, zmm2, zmm3, 1)); + TEST_INSTRUCTION("62F36D481F4C2B0201" , vpcmpd(k1, zmm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D481F4C2B0201" , vpcmpd(k1, zmm2, zmmword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("C5E974CB" , vpcmpeqb(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5E9748C2B80000000" , vpcmpeqb(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5E9748C2B80000000" , vpcmpeqb(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16D0874CB" , vpcmpeqb(k1, xmm2, xmm3)); + TEST_INSTRUCTION("62F16D08744C2B08" , vpcmpeqb(k1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16D08744C2B08" , vpcmpeqb(k1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5ED74CB" , vpcmpeqb(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C5ED748C2B80000000" , vpcmpeqb(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5ED748C2B80000000" , vpcmpeqb(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16D2874CB" , vpcmpeqb(k1, ymm2, ymm3)); + TEST_INSTRUCTION("62F16D28744C2B04" , vpcmpeqb(k1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16D28744C2B04" , vpcmpeqb(k1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16D4874CB" , vpcmpeqb(k1, zmm2, zmm3)); + TEST_INSTRUCTION("62F16D48744C2B02" , vpcmpeqb(k1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16D48744C2B02" , vpcmpeqb(k1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5E976CB" , vpcmpeqd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5E9768C2B80000000" , vpcmpeqd(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5E9768C2B80000000" , vpcmpeqd(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16D0876CB" , vpcmpeqd(k1, xmm2, xmm3)); + TEST_INSTRUCTION("62F16D08764C2B08" , vpcmpeqd(k1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16D08764C2B08" , vpcmpeqd(k1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5ED76CB" , vpcmpeqd(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C5ED768C2B80000000" , vpcmpeqd(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5ED768C2B80000000" , vpcmpeqd(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16D2876CB" , vpcmpeqd(k1, ymm2, ymm3)); + TEST_INSTRUCTION("62F16D28764C2B04" , vpcmpeqd(k1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16D28764C2B04" , vpcmpeqd(k1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16D4876CB" , vpcmpeqd(k1, zmm2, zmm3)); + TEST_INSTRUCTION("62F16D48764C2B02" , vpcmpeqd(k1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16D48764C2B02" , vpcmpeqd(k1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E26929CB" , vpcmpeqq(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E269298C2B80000000" , vpcmpeqq(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E269298C2B80000000" , vpcmpeqq(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED0829CB" , vpcmpeqq(k1, xmm2, xmm3)); + TEST_INSTRUCTION("62F2ED08294C2B08" , vpcmpeqq(k1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED08294C2B08" , vpcmpeqq(k1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E26D29CB" , vpcmpeqq(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C4E26D298C2B80000000" , vpcmpeqq(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E26D298C2B80000000" , vpcmpeqq(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED2829CB" , vpcmpeqq(k1, ymm2, ymm3)); + TEST_INSTRUCTION("62F2ED28294C2B04" , vpcmpeqq(k1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED28294C2B04" , vpcmpeqq(k1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED4829CB" , vpcmpeqq(k1, zmm2, zmm3)); + TEST_INSTRUCTION("62F2ED48294C2B02" , vpcmpeqq(k1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED48294C2B02" , vpcmpeqq(k1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5E975CB" , vpcmpeqw(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5E9758C2B80000000" , vpcmpeqw(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5E9758C2B80000000" , vpcmpeqw(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16D0875CB" , vpcmpeqw(k1, xmm2, xmm3)); + TEST_INSTRUCTION("62F16D08754C2B08" , vpcmpeqw(k1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16D08754C2B08" , vpcmpeqw(k1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5ED75CB" , vpcmpeqw(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C5ED758C2B80000000" , vpcmpeqw(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5ED758C2B80000000" , vpcmpeqw(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16D2875CB" , vpcmpeqw(k1, ymm2, ymm3)); + TEST_INSTRUCTION("62F16D28754C2B04" , vpcmpeqw(k1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16D28754C2B04" , vpcmpeqw(k1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16D4875CB" , vpcmpeqw(k1, zmm2, zmm3)); + TEST_INSTRUCTION("62F16D48754C2B02" , vpcmpeqw(k1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16D48754C2B02" , vpcmpeqw(k1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E37961CA01" , vpcmpestri(xmm1, xmm2, 1, ecx, eax, edx)); + TEST_INSTRUCTION("C4E379618C1A8000000001" , vpcmpestri(xmm1, ptr(rdx, rbx, 0, 128), 1, ecx, eax, edx)); + TEST_INSTRUCTION("C4E379618C1A8000000001" , vpcmpestri(xmm1, xmmword_ptr(rdx, rbx, 0, 128), 1, ecx, eax, edx)); + TEST_INSTRUCTION("C4E37960CA01" , vpcmpestrm(xmm1, xmm2, 1, xmm0, eax, edx)); + TEST_INSTRUCTION("C4E379608C1A8000000001" , vpcmpestrm(xmm1, ptr(rdx, rbx, 0, 128), 1, xmm0, eax, edx)); + TEST_INSTRUCTION("C4E379608C1A8000000001" , vpcmpestrm(xmm1, xmmword_ptr(rdx, rbx, 0, 128), 1, xmm0, eax, edx)); + TEST_INSTRUCTION("C5E964CB" , vpcmpgtb(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5E9648C2B80000000" , vpcmpgtb(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5E9648C2B80000000" , vpcmpgtb(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16D0864CB" , vpcmpgtb(k1, xmm2, xmm3)); + TEST_INSTRUCTION("62F16D08644C2B08" , vpcmpgtb(k1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16D08644C2B08" , vpcmpgtb(k1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5ED64CB" , vpcmpgtb(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C5ED648C2B80000000" , vpcmpgtb(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5ED648C2B80000000" , vpcmpgtb(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16D2864CB" , vpcmpgtb(k1, ymm2, ymm3)); + TEST_INSTRUCTION("62F16D28644C2B04" , vpcmpgtb(k1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16D28644C2B04" , vpcmpgtb(k1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16D4864CB" , vpcmpgtb(k1, zmm2, zmm3)); + TEST_INSTRUCTION("62F16D48644C2B02" , vpcmpgtb(k1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16D48644C2B02" , vpcmpgtb(k1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5E966CB" , vpcmpgtd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5E9668C2B80000000" , vpcmpgtd(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5E9668C2B80000000" , vpcmpgtd(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16D0866CB" , vpcmpgtd(k1, xmm2, xmm3)); + TEST_INSTRUCTION("62F16D08664C2B08" , vpcmpgtd(k1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16D08664C2B08" , vpcmpgtd(k1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5ED66CB" , vpcmpgtd(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C5ED668C2B80000000" , vpcmpgtd(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5ED668C2B80000000" , vpcmpgtd(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16D2866CB" , vpcmpgtd(k1, ymm2, ymm3)); + TEST_INSTRUCTION("62F16D28664C2B04" , vpcmpgtd(k1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16D28664C2B04" , vpcmpgtd(k1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16D4866CB" , vpcmpgtd(k1, zmm2, zmm3)); + TEST_INSTRUCTION("62F16D48664C2B02" , vpcmpgtd(k1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16D48664C2B02" , vpcmpgtd(k1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E26937CB" , vpcmpgtq(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E269378C2B80000000" , vpcmpgtq(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E269378C2B80000000" , vpcmpgtq(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED0837CB" , vpcmpgtq(k1, xmm2, xmm3)); + TEST_INSTRUCTION("62F2ED08374C2B08" , vpcmpgtq(k1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED08374C2B08" , vpcmpgtq(k1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E26D37CB" , vpcmpgtq(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C4E26D378C2B80000000" , vpcmpgtq(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E26D378C2B80000000" , vpcmpgtq(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED2837CB" , vpcmpgtq(k1, ymm2, ymm3)); + TEST_INSTRUCTION("62F2ED28374C2B04" , vpcmpgtq(k1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED28374C2B04" , vpcmpgtq(k1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED4837CB" , vpcmpgtq(k1, zmm2, zmm3)); + TEST_INSTRUCTION("62F2ED48374C2B02" , vpcmpgtq(k1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED48374C2B02" , vpcmpgtq(k1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5E965CB" , vpcmpgtw(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5E9658C2B80000000" , vpcmpgtw(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5E9658C2B80000000" , vpcmpgtw(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16D0865CB" , vpcmpgtw(k1, xmm2, xmm3)); + TEST_INSTRUCTION("62F16D08654C2B08" , vpcmpgtw(k1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16D08654C2B08" , vpcmpgtw(k1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5ED65CB" , vpcmpgtw(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C5ED658C2B80000000" , vpcmpgtw(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5ED658C2B80000000" , vpcmpgtw(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16D2865CB" , vpcmpgtw(k1, ymm2, ymm3)); + TEST_INSTRUCTION("62F16D28654C2B04" , vpcmpgtw(k1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16D28654C2B04" , vpcmpgtw(k1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16D4865CB" , vpcmpgtw(k1, zmm2, zmm3)); + TEST_INSTRUCTION("62F16D48654C2B02" , vpcmpgtw(k1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16D48654C2B02" , vpcmpgtw(k1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E37963CA01" , vpcmpistri(xmm1, xmm2, 1, ecx)); + TEST_INSTRUCTION("C4E379638C1A8000000001" , vpcmpistri(xmm1, ptr(rdx, rbx, 0, 128), 1, ecx)); + TEST_INSTRUCTION("C4E379638C1A8000000001" , vpcmpistri(xmm1, xmmword_ptr(rdx, rbx, 0, 128), 1, ecx)); + TEST_INSTRUCTION("C4E37962CA01" , vpcmpistrm(xmm1, xmm2, 1, xmm0)); + TEST_INSTRUCTION("C4E379628C1A8000000001" , vpcmpistrm(xmm1, ptr(rdx, rbx, 0, 128), 1, xmm0)); + TEST_INSTRUCTION("C4E379628C1A8000000001" , vpcmpistrm(xmm1, xmmword_ptr(rdx, rbx, 0, 128), 1, xmm0)); + TEST_INSTRUCTION("62F3ED081FCB01" , vpcmpq(k1, xmm2, xmm3, 1)); + TEST_INSTRUCTION("62F3ED081F4C2B0801" , vpcmpq(k1, xmm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED081F4C2B0801" , vpcmpq(k1, xmm2, xmmword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED281FCB01" , vpcmpq(k1, ymm2, ymm3, 1)); + TEST_INSTRUCTION("62F3ED281F4C2B0401" , vpcmpq(k1, ymm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED281F4C2B0401" , vpcmpq(k1, ymm2, ymmword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED481FCB01" , vpcmpq(k1, zmm2, zmm3, 1)); + TEST_INSTRUCTION("62F3ED481F4C2B0201" , vpcmpq(k1, zmm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED481F4C2B0201" , vpcmpq(k1, zmm2, zmmword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D083ECB01" , vpcmpub(k1, xmm2, xmm3, 1)); + TEST_INSTRUCTION("62F36D083E4C2B0801" , vpcmpub(k1, xmm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D083E4C2B0801" , vpcmpub(k1, xmm2, xmmword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D283ECB01" , vpcmpub(k1, ymm2, ymm3, 1)); + TEST_INSTRUCTION("62F36D283E4C2B0401" , vpcmpub(k1, ymm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D283E4C2B0401" , vpcmpub(k1, ymm2, ymmword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D483ECB01" , vpcmpub(k1, zmm2, zmm3, 1)); + TEST_INSTRUCTION("62F36D483E4C2B0201" , vpcmpub(k1, zmm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D483E4C2B0201" , vpcmpub(k1, zmm2, zmmword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D081ECB01" , vpcmpud(k1, xmm2, xmm3, 1)); + TEST_INSTRUCTION("62F36D081E4C2B0801" , vpcmpud(k1, xmm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D081E4C2B0801" , vpcmpud(k1, xmm2, xmmword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D281ECB01" , vpcmpud(k1, ymm2, ymm3, 1)); + TEST_INSTRUCTION("62F36D281E4C2B0401" , vpcmpud(k1, ymm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D281E4C2B0401" , vpcmpud(k1, ymm2, ymmword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D481ECB01" , vpcmpud(k1, zmm2, zmm3, 1)); + TEST_INSTRUCTION("62F36D481E4C2B0201" , vpcmpud(k1, zmm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D481E4C2B0201" , vpcmpud(k1, zmm2, zmmword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED081ECB01" , vpcmpuq(k1, xmm2, xmm3, 1)); + TEST_INSTRUCTION("62F3ED081E4C2B0801" , vpcmpuq(k1, xmm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED081E4C2B0801" , vpcmpuq(k1, xmm2, xmmword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED281ECB01" , vpcmpuq(k1, ymm2, ymm3, 1)); + TEST_INSTRUCTION("62F3ED281E4C2B0401" , vpcmpuq(k1, ymm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED281E4C2B0401" , vpcmpuq(k1, ymm2, ymmword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED481ECB01" , vpcmpuq(k1, zmm2, zmm3, 1)); + TEST_INSTRUCTION("62F3ED481E4C2B0201" , vpcmpuq(k1, zmm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED481E4C2B0201" , vpcmpuq(k1, zmm2, zmmword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED083ECB01" , vpcmpuw(k1, xmm2, xmm3, 1)); + TEST_INSTRUCTION("62F3ED083E4C2B0801" , vpcmpuw(k1, xmm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED083E4C2B0801" , vpcmpuw(k1, xmm2, xmmword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED283ECB01" , vpcmpuw(k1, ymm2, ymm3, 1)); + TEST_INSTRUCTION("62F3ED283E4C2B0401" , vpcmpuw(k1, ymm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED283E4C2B0401" , vpcmpuw(k1, ymm2, ymmword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED483ECB01" , vpcmpuw(k1, zmm2, zmm3, 1)); + TEST_INSTRUCTION("62F3ED483E4C2B0201" , vpcmpuw(k1, zmm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED483E4C2B0201" , vpcmpuw(k1, zmm2, zmmword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED083FCB01" , vpcmpw(k1, xmm2, xmm3, 1)); + TEST_INSTRUCTION("62F3ED083F4C2B0801" , vpcmpw(k1, xmm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED083F4C2B0801" , vpcmpw(k1, xmm2, xmmword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED283FCB01" , vpcmpw(k1, ymm2, ymm3, 1)); + TEST_INSTRUCTION("62F3ED283F4C2B0401" , vpcmpw(k1, ymm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED283F4C2B0401" , vpcmpw(k1, ymm2, ymmword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED483FCB01" , vpcmpw(k1, zmm2, zmm3, 1)); + TEST_INSTRUCTION("62F3ED483F4C2B0201" , vpcmpw(k1, zmm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED483F4C2B0201" , vpcmpw(k1, zmm2, zmmword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("8FE868CCCB01" , vpcomb(xmm1, xmm2, xmm3, 1)); + TEST_INSTRUCTION("8FE868CC8C2B8000000001" , vpcomb(xmm1, xmm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("8FE868CC8C2B8000000001" , vpcomb(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("8FE868CECB01" , vpcomd(xmm1, xmm2, xmm3, 1)); + TEST_INSTRUCTION("8FE868CE8C2B8000000001" , vpcomd(xmm1, xmm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("8FE868CE8C2B8000000001" , vpcomd(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F27D0863D1" , vpcompressb(xmm1, xmm2)); + TEST_INSTRUCTION("62F27D08639C1180000000" , vpcompressb(ptr(rcx, rdx, 0, 128), xmm3)); + TEST_INSTRUCTION("62F27D08639C1180000000" , vpcompressb(xmmword_ptr(rcx, rdx, 0, 128), xmm3)); + TEST_INSTRUCTION("62F27D2863D1" , vpcompressb(ymm1, ymm2)); + TEST_INSTRUCTION("62F27D28639C1180000000" , vpcompressb(ptr(rcx, rdx, 0, 128), ymm3)); + TEST_INSTRUCTION("62F27D28639C1180000000" , vpcompressb(ymmword_ptr(rcx, rdx, 0, 128), ymm3)); + TEST_INSTRUCTION("62F27D4863D1" , vpcompressb(zmm1, zmm2)); + TEST_INSTRUCTION("62F27D48639C1180000000" , vpcompressb(ptr(rcx, rdx, 0, 128), zmm3)); + TEST_INSTRUCTION("62F27D48639C1180000000" , vpcompressb(zmmword_ptr(rcx, rdx, 0, 128), zmm3)); + TEST_INSTRUCTION("62F27D088BD1" , vpcompressd(xmm1, xmm2)); + TEST_INSTRUCTION("62F27D088B5C1120" , vpcompressd(ptr(rcx, rdx, 0, 128), xmm3)); + TEST_INSTRUCTION("62F27D088B5C1120" , vpcompressd(xmmword_ptr(rcx, rdx, 0, 128), xmm3)); + TEST_INSTRUCTION("62F27D288BD1" , vpcompressd(ymm1, ymm2)); + TEST_INSTRUCTION("62F27D288B5C1120" , vpcompressd(ptr(rcx, rdx, 0, 128), ymm3)); + TEST_INSTRUCTION("62F27D288B5C1120" , vpcompressd(ymmword_ptr(rcx, rdx, 0, 128), ymm3)); + TEST_INSTRUCTION("62F27D488BD1" , vpcompressd(zmm1, zmm2)); + TEST_INSTRUCTION("62F27D488B5C1120" , vpcompressd(ptr(rcx, rdx, 0, 128), zmm3)); + TEST_INSTRUCTION("62F27D488B5C1120" , vpcompressd(zmmword_ptr(rcx, rdx, 0, 128), zmm3)); + TEST_INSTRUCTION("62F2FD088BD1" , vpcompressq(xmm1, xmm2)); + TEST_INSTRUCTION("62F2FD088B5C1110" , vpcompressq(ptr(rcx, rdx, 0, 128), xmm3)); + TEST_INSTRUCTION("62F2FD088B5C1110" , vpcompressq(xmmword_ptr(rcx, rdx, 0, 128), xmm3)); + TEST_INSTRUCTION("62F2FD288BD1" , vpcompressq(ymm1, ymm2)); + TEST_INSTRUCTION("62F2FD288B5C1110" , vpcompressq(ptr(rcx, rdx, 0, 128), ymm3)); + TEST_INSTRUCTION("62F2FD288B5C1110" , vpcompressq(ymmword_ptr(rcx, rdx, 0, 128), ymm3)); + TEST_INSTRUCTION("62F2FD488BD1" , vpcompressq(zmm1, zmm2)); + TEST_INSTRUCTION("62F2FD488B5C1110" , vpcompressq(ptr(rcx, rdx, 0, 128), zmm3)); + TEST_INSTRUCTION("62F2FD488B5C1110" , vpcompressq(zmmword_ptr(rcx, rdx, 0, 128), zmm3)); + TEST_INSTRUCTION("62F2FD0863D1" , vpcompressw(xmm1, xmm2)); + TEST_INSTRUCTION("62F2FD08635C1140" , vpcompressw(ptr(rcx, rdx, 0, 128), xmm3)); + TEST_INSTRUCTION("62F2FD08635C1140" , vpcompressw(xmmword_ptr(rcx, rdx, 0, 128), xmm3)); + TEST_INSTRUCTION("62F2FD2863D1" , vpcompressw(ymm1, ymm2)); + TEST_INSTRUCTION("62F2FD28635C1140" , vpcompressw(ptr(rcx, rdx, 0, 128), ymm3)); + TEST_INSTRUCTION("62F2FD28635C1140" , vpcompressw(ymmword_ptr(rcx, rdx, 0, 128), ymm3)); + TEST_INSTRUCTION("62F2FD4863D1" , vpcompressw(zmm1, zmm2)); + TEST_INSTRUCTION("62F2FD48635C1140" , vpcompressw(ptr(rcx, rdx, 0, 128), zmm3)); + TEST_INSTRUCTION("62F2FD48635C1140" , vpcompressw(zmmword_ptr(rcx, rdx, 0, 128), zmm3)); + TEST_INSTRUCTION("8FE868CFCB01" , vpcomq(xmm1, xmm2, xmm3, 1)); + TEST_INSTRUCTION("8FE868CF8C2B8000000001" , vpcomq(xmm1, xmm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("8FE868CF8C2B8000000001" , vpcomq(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("8FE868ECCB01" , vpcomub(xmm1, xmm2, xmm3, 1)); + TEST_INSTRUCTION("8FE868EC8C2B8000000001" , vpcomub(xmm1, xmm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("8FE868EC8C2B8000000001" , vpcomub(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("8FE868EECB01" , vpcomud(xmm1, xmm2, xmm3, 1)); + TEST_INSTRUCTION("8FE868EE8C2B8000000001" , vpcomud(xmm1, xmm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("8FE868EE8C2B8000000001" , vpcomud(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("8FE868EFCB01" , vpcomuq(xmm1, xmm2, xmm3, 1)); + TEST_INSTRUCTION("8FE868EF8C2B8000000001" , vpcomuq(xmm1, xmm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("8FE868EF8C2B8000000001" , vpcomuq(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("8FE868EDCB01" , vpcomuw(xmm1, xmm2, xmm3, 1)); + TEST_INSTRUCTION("8FE868ED8C2B8000000001" , vpcomuw(xmm1, xmm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("8FE868ED8C2B8000000001" , vpcomuw(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("8FE868CDCB01" , vpcomw(xmm1, xmm2, xmm3, 1)); + TEST_INSTRUCTION("8FE868CD8C2B8000000001" , vpcomw(xmm1, xmm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("8FE868CD8C2B8000000001" , vpcomw(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F27D08C4CA" , vpconflictd(xmm1, xmm2)); + TEST_INSTRUCTION("62F27D08C44C1A08" , vpconflictd(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F27D08C44C1A08" , vpconflictd(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F27D28C4CA" , vpconflictd(ymm1, ymm2)); + TEST_INSTRUCTION("62F27D28C44C1A04" , vpconflictd(ymm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F27D28C44C1A04" , vpconflictd(ymm1, ymmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F27D48C4CA" , vpconflictd(zmm1, zmm2)); + TEST_INSTRUCTION("62F27D48C44C1A02" , vpconflictd(zmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F27D48C44C1A02" , vpconflictd(zmm1, zmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F2FD08C4CA" , vpconflictq(xmm1, xmm2)); + TEST_INSTRUCTION("62F2FD08C44C1A08" , vpconflictq(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F2FD08C44C1A08" , vpconflictq(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F2FD28C4CA" , vpconflictq(ymm1, ymm2)); + TEST_INSTRUCTION("62F2FD28C44C1A04" , vpconflictq(ymm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F2FD28C44C1A04" , vpconflictq(ymm1, ymmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F2FD48C4CA" , vpconflictq(zmm1, zmm2)); + TEST_INSTRUCTION("62F2FD48C44C1A02" , vpconflictq(zmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F2FD48C44C1A02" , vpconflictq(zmm1, zmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F26D0850CB" , vpdpbusd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("62F26D08504C2B08" , vpdpbusd(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D08504C2B08" , vpdpbusd(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D2850CB" , vpdpbusd(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("62F26D28504C2B04" , vpdpbusd(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D28504C2B04" , vpdpbusd(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D4850CB" , vpdpbusd(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F26D48504C2B02" , vpdpbusd(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D48504C2B02" , vpdpbusd(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D0851CB" , vpdpbusds(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("62F26D08514C2B08" , vpdpbusds(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D08514C2B08" , vpdpbusds(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D2851CB" , vpdpbusds(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("62F26D28514C2B04" , vpdpbusds(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D28514C2B04" , vpdpbusds(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D4851CB" , vpdpbusds(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F26D48514C2B02" , vpdpbusds(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D48514C2B02" , vpdpbusds(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D0852CB" , vpdpwssd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("62F26D08524C2B08" , vpdpwssd(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D08524C2B08" , vpdpwssd(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D2852CB" , vpdpwssd(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("62F26D28524C2B04" , vpdpwssd(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D28524C2B04" , vpdpwssd(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D4852CB" , vpdpwssd(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F26D48524C2B02" , vpdpwssd(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D48524C2B02" , vpdpwssd(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D0853CB" , vpdpwssds(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("62F26D08534C2B08" , vpdpwssds(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D08534C2B08" , vpdpwssds(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D2853CB" , vpdpwssds(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("62F26D28534C2B04" , vpdpwssds(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D28534C2B04" , vpdpwssds(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D4853CB" , vpdpwssds(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F26D48534C2B02" , vpdpwssds(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D48534C2B02" , vpdpwssds(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E36D06CB01" , vperm2f128(ymm1, ymm2, ymm3, 1)); + TEST_INSTRUCTION("C4E36D068C2B8000000001" , vperm2f128(ymm1, ymm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("C4E36D068C2B8000000001" , vperm2f128(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("C4E36D46CB01" , vperm2i128(ymm1, ymm2, ymm3, 1)); + TEST_INSTRUCTION("C4E36D468C2B8000000001" , vperm2i128(ymm1, ymm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("C4E36D468C2B8000000001" , vperm2i128(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F26D088DCB" , vpermb(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("62F26D088D4C2B08" , vpermb(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D088D4C2B08" , vpermb(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D288DCB" , vpermb(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("62F26D288D4C2B04" , vpermb(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D288D4C2B04" , vpermb(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D488DCB" , vpermb(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F26D488D4C2B02" , vpermb(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D488D4C2B02" , vpermb(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E26D36CB" , vpermd(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C4E26D368C2B80000000" , vpermd(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E26D368C2B80000000" , vpermd(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D4836CB" , vpermd(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F26D48364C2B02" , vpermd(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D48364C2B02" , vpermd(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D0875CB" , vpermi2b(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("62F26D08754C2B08" , vpermi2b(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D08754C2B08" , vpermi2b(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D2875CB" , vpermi2b(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("62F26D28754C2B04" , vpermi2b(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D28754C2B04" , vpermi2b(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D4875CB" , vpermi2b(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F26D48754C2B02" , vpermi2b(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D48754C2B02" , vpermi2b(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D0876CB" , vpermi2d(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("62F26D08764C2B08" , vpermi2d(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D08764C2B08" , vpermi2d(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D2876CB" , vpermi2d(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("62F26D28764C2B04" , vpermi2d(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D28764C2B04" , vpermi2d(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D4876CB" , vpermi2d(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F26D48764C2B02" , vpermi2d(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D48764C2B02" , vpermi2d(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED0877CB" , vpermi2pd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("62F2ED08774C2B08" , vpermi2pd(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED08774C2B08" , vpermi2pd(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED2877CB" , vpermi2pd(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("62F2ED28774C2B04" , vpermi2pd(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED28774C2B04" , vpermi2pd(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED4877CB" , vpermi2pd(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F2ED48774C2B02" , vpermi2pd(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED48774C2B02" , vpermi2pd(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D0877CB" , vpermi2ps(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("62F26D08774C2B08" , vpermi2ps(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D08774C2B08" , vpermi2ps(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D2877CB" , vpermi2ps(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("62F26D28774C2B04" , vpermi2ps(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D28774C2B04" , vpermi2ps(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D4877CB" , vpermi2ps(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F26D48774C2B02" , vpermi2ps(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D48774C2B02" , vpermi2ps(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED0876CB" , vpermi2q(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("62F2ED08764C2B08" , vpermi2q(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED08764C2B08" , vpermi2q(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED2876CB" , vpermi2q(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("62F2ED28764C2B04" , vpermi2q(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED28764C2B04" , vpermi2q(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED4876CB" , vpermi2q(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F2ED48764C2B02" , vpermi2q(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED48764C2B02" , vpermi2q(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED0875CB" , vpermi2w(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("62F2ED08754C2B08" , vpermi2w(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED08754C2B08" , vpermi2w(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED2875CB" , vpermi2w(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("62F2ED28754C2B04" , vpermi2w(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED28754C2B04" , vpermi2w(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED4875CB" , vpermi2w(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F2ED48754C2B02" , vpermi2w(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED48754C2B02" , vpermi2w(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E36949CB41" , vpermil2pd(xmm1, xmm2, xmm3, xmm4, 1)); + TEST_INSTRUCTION("C4E369498C2B8000000061" , vpermil2pd(xmm1, xmm2, ptr(rbx, rbp, 0, 128), xmm6, 1)); + TEST_INSTRUCTION("C4E369498C2B8000000061" , vpermil2pd(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128), xmm6, 1)); + TEST_INSTRUCTION("C4E3E9498C358000000031" , vpermil2pd(xmm1, xmm2, xmm3, ptr(rbp, rsi, 0, 128), 1)); + TEST_INSTRUCTION("C4E3E9498C358000000031" , vpermil2pd(xmm1, xmm2, xmm3, xmmword_ptr(rbp, rsi, 0, 128), 1)); + TEST_INSTRUCTION("C4E36D49CB41" , vpermil2pd(ymm1, ymm2, ymm3, ymm4, 1)); + TEST_INSTRUCTION("C4E36D498C2B8000000061" , vpermil2pd(ymm1, ymm2, ptr(rbx, rbp, 0, 128), ymm6, 1)); + TEST_INSTRUCTION("C4E36D498C2B8000000061" , vpermil2pd(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128), ymm6, 1)); + TEST_INSTRUCTION("C4E3ED498C358000000031" , vpermil2pd(ymm1, ymm2, ymm3, ptr(rbp, rsi, 0, 128), 1)); + TEST_INSTRUCTION("C4E3ED498C358000000031" , vpermil2pd(ymm1, ymm2, ymm3, ymmword_ptr(rbp, rsi, 0, 128), 1)); + TEST_INSTRUCTION("C4E36948CB41" , vpermil2ps(xmm1, xmm2, xmm3, xmm4, 1)); + TEST_INSTRUCTION("C4E369488C2B8000000061" , vpermil2ps(xmm1, xmm2, ptr(rbx, rbp, 0, 128), xmm6, 1)); + TEST_INSTRUCTION("C4E369488C2B8000000061" , vpermil2ps(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128), xmm6, 1)); + TEST_INSTRUCTION("C4E3E9488C358000000031" , vpermil2ps(xmm1, xmm2, xmm3, ptr(rbp, rsi, 0, 128), 1)); + TEST_INSTRUCTION("C4E3E9488C358000000031" , vpermil2ps(xmm1, xmm2, xmm3, xmmword_ptr(rbp, rsi, 0, 128), 1)); + TEST_INSTRUCTION("C4E36D48CB41" , vpermil2ps(ymm1, ymm2, ymm3, ymm4, 1)); + TEST_INSTRUCTION("C4E36D488C2B8000000061" , vpermil2ps(ymm1, ymm2, ptr(rbx, rbp, 0, 128), ymm6, 1)); + TEST_INSTRUCTION("C4E36D488C2B8000000061" , vpermil2ps(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128), ymm6, 1)); + TEST_INSTRUCTION("C4E3ED488C358000000031" , vpermil2ps(ymm1, ymm2, ymm3, ptr(rbp, rsi, 0, 128), 1)); + TEST_INSTRUCTION("C4E3ED488C358000000031" , vpermil2ps(ymm1, ymm2, ymm3, ymmword_ptr(rbp, rsi, 0, 128), 1)); + TEST_INSTRUCTION("C4E2690DCB" , vpermilpd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E37905CA01" , vpermilpd(xmm1, xmm2, 1)); + TEST_INSTRUCTION("C4E2690D8C2B80000000" , vpermilpd(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E2690D8C2B80000000" , vpermilpd(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E379058C1A8000000001" , vpermilpd(xmm1, ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("C4E379058C1A8000000001" , vpermilpd(xmm1, xmmword_ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("C4E26D0DCB" , vpermilpd(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C4E37D05CA01" , vpermilpd(ymm1, ymm2, 1)); + TEST_INSTRUCTION("C4E26D0D8C2B80000000" , vpermilpd(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E26D0D8C2B80000000" , vpermilpd(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E37D058C1A8000000001" , vpermilpd(ymm1, ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("C4E37D058C1A8000000001" , vpermilpd(ymm1, ymmword_ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("62F2ED480DCB" , vpermilpd(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F3FD4805CA01" , vpermilpd(zmm1, zmm2, 1)); + TEST_INSTRUCTION("62F2ED480D4C2B02" , vpermilpd(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED480D4C2B02" , vpermilpd(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F3FD48054C1A0201" , vpermilpd(zmm1, ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("62F3FD48054C1A0201" , vpermilpd(zmm1, zmmword_ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("C4E2690CCB" , vpermilps(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E37904CA01" , vpermilps(xmm1, xmm2, 1)); + TEST_INSTRUCTION("C4E2690C8C2B80000000" , vpermilps(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E2690C8C2B80000000" , vpermilps(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E379048C1A8000000001" , vpermilps(xmm1, ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("C4E379048C1A8000000001" , vpermilps(xmm1, xmmword_ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("C4E26D0CCB" , vpermilps(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C4E37D04CA01" , vpermilps(ymm1, ymm2, 1)); + TEST_INSTRUCTION("C4E26D0C8C2B80000000" , vpermilps(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E26D0C8C2B80000000" , vpermilps(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E37D048C1A8000000001" , vpermilps(ymm1, ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("C4E37D048C1A8000000001" , vpermilps(ymm1, ymmword_ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("62F26D480CCB" , vpermilps(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F37D4804CA01" , vpermilps(zmm1, zmm2, 1)); + TEST_INSTRUCTION("62F26D480C4C2B02" , vpermilps(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D480C4C2B02" , vpermilps(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F37D48044C1A0201" , vpermilps(zmm1, ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("62F37D48044C1A0201" , vpermilps(zmm1, zmmword_ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("C4E3FD01CA01" , vpermpd(ymm1, ymm2, 1)); + TEST_INSTRUCTION("C4E3FD018C1A8000000001" , vpermpd(ymm1, ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("C4E3FD018C1A8000000001" , vpermpd(ymm1, ymmword_ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("62F2ED2816CB" , vpermpd(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("62F2ED28164C2B04" , vpermpd(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED28164C2B04" , vpermpd(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED4816CB" , vpermpd(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F3FD4801CA01" , vpermpd(zmm1, zmm2, 1)); + TEST_INSTRUCTION("62F2ED48164C2B02" , vpermpd(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED48164C2B02" , vpermpd(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F3FD48014C1A0201" , vpermpd(zmm1, ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("62F3FD48014C1A0201" , vpermpd(zmm1, zmmword_ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("C4E26D16CB" , vpermps(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C4E26D168C2B80000000" , vpermps(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E26D168C2B80000000" , vpermps(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D4816CB" , vpermps(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F26D48164C2B02" , vpermps(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D48164C2B02" , vpermps(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E3FD00CA01" , vpermq(ymm1, ymm2, 1)); + TEST_INSTRUCTION("C4E3FD008C1A8000000001" , vpermq(ymm1, ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("C4E3FD008C1A8000000001" , vpermq(ymm1, ymmword_ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("62F2ED2836CB" , vpermq(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("62F2ED28364C2B04" , vpermq(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED28364C2B04" , vpermq(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED4836CB" , vpermq(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F3FD4800CA01" , vpermq(zmm1, zmm2, 1)); + TEST_INSTRUCTION("62F2ED48364C2B02" , vpermq(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED48364C2B02" , vpermq(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F3FD48004C1A0201" , vpermq(zmm1, ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("62F3FD48004C1A0201" , vpermq(zmm1, zmmword_ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("62F26D087DCB" , vpermt2b(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("62F26D087D4C2B08" , vpermt2b(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D087D4C2B08" , vpermt2b(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D287DCB" , vpermt2b(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("62F26D287D4C2B04" , vpermt2b(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D287D4C2B04" , vpermt2b(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D487DCB" , vpermt2b(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F26D487D4C2B02" , vpermt2b(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D487D4C2B02" , vpermt2b(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D087ECB" , vpermt2d(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("62F26D087E4C2B08" , vpermt2d(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D087E4C2B08" , vpermt2d(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D287ECB" , vpermt2d(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("62F26D287E4C2B04" , vpermt2d(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D287E4C2B04" , vpermt2d(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D487ECB" , vpermt2d(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F26D487E4C2B02" , vpermt2d(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D487E4C2B02" , vpermt2d(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED087FCB" , vpermt2pd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("62F2ED087F4C2B08" , vpermt2pd(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED087F4C2B08" , vpermt2pd(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED287FCB" , vpermt2pd(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("62F2ED287F4C2B04" , vpermt2pd(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED287F4C2B04" , vpermt2pd(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED487FCB" , vpermt2pd(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F2ED487F4C2B02" , vpermt2pd(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED487F4C2B02" , vpermt2pd(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D087FCB" , vpermt2ps(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("62F26D087F4C2B08" , vpermt2ps(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D087F4C2B08" , vpermt2ps(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D287FCB" , vpermt2ps(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("62F26D287F4C2B04" , vpermt2ps(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D287F4C2B04" , vpermt2ps(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D487FCB" , vpermt2ps(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F26D487F4C2B02" , vpermt2ps(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D487F4C2B02" , vpermt2ps(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED087ECB" , vpermt2q(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("62F2ED087E4C2B08" , vpermt2q(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED087E4C2B08" , vpermt2q(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED287ECB" , vpermt2q(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("62F2ED287E4C2B04" , vpermt2q(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED287E4C2B04" , vpermt2q(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED487ECB" , vpermt2q(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F2ED487E4C2B02" , vpermt2q(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED487E4C2B02" , vpermt2q(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED087DCB" , vpermt2w(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("62F2ED087D4C2B08" , vpermt2w(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED087D4C2B08" , vpermt2w(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED287DCB" , vpermt2w(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("62F2ED287D4C2B04" , vpermt2w(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED287D4C2B04" , vpermt2w(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED487DCB" , vpermt2w(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F2ED487D4C2B02" , vpermt2w(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED487D4C2B02" , vpermt2w(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED088DCB" , vpermw(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("62F2ED088D4C2B08" , vpermw(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED088D4C2B08" , vpermw(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED288DCB" , vpermw(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("62F2ED288D4C2B04" , vpermw(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED288D4C2B04" , vpermw(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED488DCB" , vpermw(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F2ED488D4C2B02" , vpermw(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED488D4C2B02" , vpermw(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F27D0862CA" , vpexpandb(xmm1, xmm2)); + TEST_INSTRUCTION("62F27D08628C1A80000000" , vpexpandb(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F27D08628C1A80000000" , vpexpandb(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F27D2862CA" , vpexpandb(ymm1, ymm2)); + TEST_INSTRUCTION("62F27D28628C1A80000000" , vpexpandb(ymm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F27D28628C1A80000000" , vpexpandb(ymm1, ymmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F27D4862CA" , vpexpandb(zmm1, zmm2)); + TEST_INSTRUCTION("62F27D48628C1A80000000" , vpexpandb(zmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F27D48628C1A80000000" , vpexpandb(zmm1, zmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F27D0889CA" , vpexpandd(xmm1, xmm2)); + TEST_INSTRUCTION("62F27D08894C1A20" , vpexpandd(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F27D08894C1A20" , vpexpandd(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F27D2889CA" , vpexpandd(ymm1, ymm2)); + TEST_INSTRUCTION("62F27D28894C1A20" , vpexpandd(ymm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F27D28894C1A20" , vpexpandd(ymm1, ymmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F27D4889CA" , vpexpandd(zmm1, zmm2)); + TEST_INSTRUCTION("62F27D48894C1A20" , vpexpandd(zmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F27D48894C1A20" , vpexpandd(zmm1, zmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F2FD0889CA" , vpexpandq(xmm1, xmm2)); + TEST_INSTRUCTION("62F2FD08894C1A10" , vpexpandq(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F2FD08894C1A10" , vpexpandq(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F2FD2889CA" , vpexpandq(ymm1, ymm2)); + TEST_INSTRUCTION("62F2FD28894C1A10" , vpexpandq(ymm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F2FD28894C1A10" , vpexpandq(ymm1, ymmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F2FD4889CA" , vpexpandq(zmm1, zmm2)); + TEST_INSTRUCTION("62F2FD48894C1A10" , vpexpandq(zmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F2FD48894C1A10" , vpexpandq(zmm1, zmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F2FD0862CA" , vpexpandw(xmm1, xmm2)); + TEST_INSTRUCTION("62F2FD08624C1A40" , vpexpandw(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F2FD08624C1A40" , vpexpandw(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F2FD2862CA" , vpexpandw(ymm1, ymm2)); + TEST_INSTRUCTION("62F2FD28624C1A40" , vpexpandw(ymm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F2FD28624C1A40" , vpexpandw(ymm1, ymmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F2FD4862CA" , vpexpandw(zmm1, zmm2)); + TEST_INSTRUCTION("62F2FD48624C1A40" , vpexpandw(zmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F2FD48624C1A40" , vpexpandw(zmm1, zmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C4E37914D101" , vpextrb(ecx, xmm2, 1)); + TEST_INSTRUCTION("C4E379149C118000000001" , vpextrb(ptr(rcx, rdx, 0, 128), xmm3, 1)); + TEST_INSTRUCTION("C4E379149C118000000001" , vpextrb(byte_ptr(rcx, rdx, 0, 128), xmm3, 1)); + TEST_INSTRUCTION("C4E37916D101" , vpextrd(ecx, xmm2, 1)); + TEST_INSTRUCTION("C4E379169C118000000001" , vpextrd(ptr(rcx, rdx, 0, 128), xmm3, 1)); + TEST_INSTRUCTION("C4E379169C118000000001" , vpextrd(dword_ptr(rcx, rdx, 0, 128), xmm3, 1)); + TEST_INSTRUCTION("C4E3F916D101" , vpextrq(rcx, xmm2, 1)); + TEST_INSTRUCTION("C4E3F9169C118000000001" , vpextrq(ptr(rcx, rdx, 0, 128), xmm3, 1)); + TEST_INSTRUCTION("C4E3F9169C118000000001" , vpextrq(qword_ptr(rcx, rdx, 0, 128), xmm3, 1)); + TEST_INSTRUCTION("C5F9C5CA01" , vpextrw(ecx, xmm2, 1)); + TEST_INSTRUCTION("C4E379159C118000000001" , vpextrw(ptr(rcx, rdx, 0, 128), xmm3, 1)); + TEST_INSTRUCTION("C4E379159C118000000001" , vpextrw(word_ptr(rcx, rdx, 0, 128), xmm3, 1)); + TEST_INSTRUCTION("C4E259908C1A80000000" , vpgatherdd(xmm1, ptr(rdx, xmm3, 0, 128), xmm4)); + TEST_INSTRUCTION("C4E25D908C1A80000000" , vpgatherdd(ymm1, ptr(rdx, ymm3, 0, 128), ymm4)); + TEST_INSTRUCTION("62F27D09904C1A20" , k(k1).vpgatherdd(xmm1, ptr(rdx, xmm3, 0, 128))); + TEST_INSTRUCTION("62F27D29904C1A20" , k(k1).vpgatherdd(ymm1, ptr(rdx, ymm3, 0, 128))); + TEST_INSTRUCTION("62F27D49904C1A20" , k(k1).vpgatherdd(zmm1, ptr(rdx, zmm3, 0, 128))); + TEST_INSTRUCTION("C4E2D9908C1A80000000" , vpgatherdq(xmm1, ptr(rdx, xmm3, 0, 128), xmm4)); + TEST_INSTRUCTION("C4E2DD908C1A80000000" , vpgatherdq(ymm1, ptr(rdx, xmm3, 0, 128), ymm4)); + TEST_INSTRUCTION("62F2FD09904C1A10" , k(k1).vpgatherdq(xmm1, ptr(rdx, xmm3, 0, 128))); + TEST_INSTRUCTION("62F2FD29904C1A10" , k(k1).vpgatherdq(ymm1, ptr(rdx, xmm3, 0, 128))); + TEST_INSTRUCTION("62F2FD49904C1A10" , k(k1).vpgatherdq(zmm1, ptr(rdx, ymm3, 0, 128))); + TEST_INSTRUCTION("C4E259918C1A80000000" , vpgatherqd(xmm1, ptr(rdx, xmm3, 0, 128), xmm4)); + TEST_INSTRUCTION("C4E25D918C1A80000000" , vpgatherqd(xmm1, ptr(rdx, ymm3, 0, 128), xmm4)); + TEST_INSTRUCTION("62F27D09914C1A20" , k(k1).vpgatherqd(xmm1, ptr(rdx, xmm3, 0, 128))); + TEST_INSTRUCTION("62F27D29914C1A20" , k(k1).vpgatherqd(xmm1, ptr(rdx, ymm3, 0, 128))); + TEST_INSTRUCTION("62F27D49914C1A20" , k(k1).vpgatherqd(ymm1, ptr(rdx, zmm3, 0, 128))); + TEST_INSTRUCTION("C4E2D9918C1A80000000" , vpgatherqq(xmm1, ptr(rdx, xmm3, 0, 128), xmm4)); + TEST_INSTRUCTION("C4E2DD918C1A80000000" , vpgatherqq(ymm1, ptr(rdx, ymm3, 0, 128), ymm4)); + TEST_INSTRUCTION("62F2FD09914C1A10" , k(k1).vpgatherqq(xmm1, ptr(rdx, xmm3, 0, 128))); + TEST_INSTRUCTION("62F2FD29914C1A10" , k(k1).vpgatherqq(ymm1, ptr(rdx, ymm3, 0, 128))); + TEST_INSTRUCTION("62F2FD49914C1A10" , k(k1).vpgatherqq(zmm1, ptr(rdx, zmm3, 0, 128))); + TEST_INSTRUCTION("8FE978C2CA" , vphaddbd(xmm1, xmm2)); + TEST_INSTRUCTION("8FE978C28C1A80000000" , vphaddbd(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("8FE978C28C1A80000000" , vphaddbd(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("8FE978C3CA" , vphaddbq(xmm1, xmm2)); + TEST_INSTRUCTION("8FE978C38C1A80000000" , vphaddbq(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("8FE978C38C1A80000000" , vphaddbq(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("8FE978C1CA" , vphaddbw(xmm1, xmm2)); + TEST_INSTRUCTION("8FE978C18C1A80000000" , vphaddbw(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("8FE978C18C1A80000000" , vphaddbw(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C4E26902CB" , vphaddd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E269028C2B80000000" , vphaddd(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E269028C2B80000000" , vphaddd(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E26D02CB" , vphaddd(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C4E26D028C2B80000000" , vphaddd(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E26D028C2B80000000" , vphaddd(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("8FE978CBCA" , vphadddq(xmm1, xmm2)); + TEST_INSTRUCTION("8FE978CB8C1A80000000" , vphadddq(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("8FE978CB8C1A80000000" , vphadddq(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C4E26903CB" , vphaddsw(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E269038C2B80000000" , vphaddsw(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E269038C2B80000000" , vphaddsw(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E26D03CB" , vphaddsw(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C4E26D038C2B80000000" , vphaddsw(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E26D038C2B80000000" , vphaddsw(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("8FE978D2CA" , vphaddubd(xmm1, xmm2)); + TEST_INSTRUCTION("8FE978D28C1A80000000" , vphaddubd(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("8FE978D28C1A80000000" , vphaddubd(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("8FE978D3CA" , vphaddubq(xmm1, xmm2)); + TEST_INSTRUCTION("8FE978D38C1A80000000" , vphaddubq(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("8FE978D38C1A80000000" , vphaddubq(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("8FE978D1CA" , vphaddubw(xmm1, xmm2)); + TEST_INSTRUCTION("8FE978D18C1A80000000" , vphaddubw(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("8FE978D18C1A80000000" , vphaddubw(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("8FE978DBCA" , vphaddudq(xmm1, xmm2)); + TEST_INSTRUCTION("8FE978DB8C1A80000000" , vphaddudq(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("8FE978DB8C1A80000000" , vphaddudq(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("8FE978D6CA" , vphadduwd(xmm1, xmm2)); + TEST_INSTRUCTION("8FE978D68C1A80000000" , vphadduwd(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("8FE978D68C1A80000000" , vphadduwd(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("8FE978D7CA" , vphadduwq(xmm1, xmm2)); + TEST_INSTRUCTION("8FE978D78C1A80000000" , vphadduwq(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("8FE978D78C1A80000000" , vphadduwq(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C4E26901CB" , vphaddw(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E269018C2B80000000" , vphaddw(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E269018C2B80000000" , vphaddw(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E26D01CB" , vphaddw(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C4E26D018C2B80000000" , vphaddw(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E26D018C2B80000000" , vphaddw(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("8FE978C6CA" , vphaddwd(xmm1, xmm2)); + TEST_INSTRUCTION("8FE978C68C1A80000000" , vphaddwd(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("8FE978C68C1A80000000" , vphaddwd(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("8FE978C7CA" , vphaddwq(xmm1, xmm2)); + TEST_INSTRUCTION("8FE978C78C1A80000000" , vphaddwq(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("8FE978C78C1A80000000" , vphaddwq(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C4E27941CA" , vphminposuw(xmm1, xmm2)); + TEST_INSTRUCTION("C4E279418C1A80000000" , vphminposuw(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C4E279418C1A80000000" , vphminposuw(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("8FE978E1CA" , vphsubbw(xmm1, xmm2)); + TEST_INSTRUCTION("8FE978E18C1A80000000" , vphsubbw(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("8FE978E18C1A80000000" , vphsubbw(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C4E26906CB" , vphsubd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E269068C2B80000000" , vphsubd(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E269068C2B80000000" , vphsubd(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E26D06CB" , vphsubd(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C4E26D068C2B80000000" , vphsubd(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E26D068C2B80000000" , vphsubd(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("8FE978E3CA" , vphsubdq(xmm1, xmm2)); + TEST_INSTRUCTION("8FE978E38C1A80000000" , vphsubdq(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("8FE978E38C1A80000000" , vphsubdq(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C4E26907CB" , vphsubsw(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E269078C2B80000000" , vphsubsw(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E269078C2B80000000" , vphsubsw(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E26D07CB" , vphsubsw(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C4E26D078C2B80000000" , vphsubsw(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E26D078C2B80000000" , vphsubsw(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E26905CB" , vphsubw(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E269058C2B80000000" , vphsubw(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E269058C2B80000000" , vphsubw(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E26D05CB" , vphsubw(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C4E26D058C2B80000000" , vphsubw(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E26D058C2B80000000" , vphsubw(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("8FE978E2CA" , vphsubwd(xmm1, xmm2)); + TEST_INSTRUCTION("8FE978E28C1A80000000" , vphsubwd(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("8FE978E28C1A80000000" , vphsubwd(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C4E36920CB01" , vpinsrb(xmm1, xmm2, ebx, 1)); + TEST_INSTRUCTION("C4E369208C2B8000000001" , vpinsrb(xmm1, xmm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("C4E369208C2B8000000001" , vpinsrb(xmm1, xmm2, byte_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("C4E36922CB01" , vpinsrd(xmm1, xmm2, ebx, 1)); + TEST_INSTRUCTION("C4E369228C2B8000000001" , vpinsrd(xmm1, xmm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("C4E369228C2B8000000001" , vpinsrd(xmm1, xmm2, dword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("C4E3E922CB01" , vpinsrq(xmm1, xmm2, rbx, 1)); + TEST_INSTRUCTION("C4E3E9228C2B8000000001" , vpinsrq(xmm1, xmm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("C4E3E9228C2B8000000001" , vpinsrq(xmm1, xmm2, qword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("C5E9C4CB01" , vpinsrw(xmm1, xmm2, ebx, 1)); + TEST_INSTRUCTION("C5E9C48C2B8000000001" , vpinsrw(xmm1, xmm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("C5E9C48C2B8000000001" , vpinsrw(xmm1, xmm2, word_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F27D0844CA" , vplzcntd(xmm1, xmm2)); + TEST_INSTRUCTION("62F27D08444C1A08" , vplzcntd(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F27D08444C1A08" , vplzcntd(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F27D2844CA" , vplzcntd(ymm1, ymm2)); + TEST_INSTRUCTION("62F27D28444C1A04" , vplzcntd(ymm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F27D28444C1A04" , vplzcntd(ymm1, ymmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F27D4844CA" , vplzcntd(zmm1, zmm2)); + TEST_INSTRUCTION("62F27D48444C1A02" , vplzcntd(zmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F27D48444C1A02" , vplzcntd(zmm1, zmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F2FD0844CA" , vplzcntq(xmm1, xmm2)); + TEST_INSTRUCTION("62F2FD08444C1A08" , vplzcntq(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F2FD08444C1A08" , vplzcntq(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F2FD2844CA" , vplzcntq(ymm1, ymm2)); + TEST_INSTRUCTION("62F2FD28444C1A04" , vplzcntq(ymm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F2FD28444C1A04" , vplzcntq(ymm1, ymmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F2FD4844CA" , vplzcntq(zmm1, zmm2)); + TEST_INSTRUCTION("62F2FD48444C1A02" , vplzcntq(zmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F2FD48444C1A02" , vplzcntq(zmm1, zmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("8FE8689ECB40" , vpmacsdd(xmm1, xmm2, xmm3, xmm4)); + TEST_INSTRUCTION("8FE8689E8C2B8000000060" , vpmacsdd(xmm1, xmm2, ptr(rbx, rbp, 0, 128), xmm6)); + TEST_INSTRUCTION("8FE8689E8C2B8000000060" , vpmacsdd(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128), xmm6)); + TEST_INSTRUCTION("8FE8689FCB40" , vpmacsdqh(xmm1, xmm2, xmm3, xmm4)); + TEST_INSTRUCTION("8FE8689F8C2B8000000060" , vpmacsdqh(xmm1, xmm2, ptr(rbx, rbp, 0, 128), xmm6)); + TEST_INSTRUCTION("8FE8689F8C2B8000000060" , vpmacsdqh(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128), xmm6)); + TEST_INSTRUCTION("8FE86897CB40" , vpmacsdql(xmm1, xmm2, xmm3, xmm4)); + TEST_INSTRUCTION("8FE868978C2B8000000060" , vpmacsdql(xmm1, xmm2, ptr(rbx, rbp, 0, 128), xmm6)); + TEST_INSTRUCTION("8FE868978C2B8000000060" , vpmacsdql(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128), xmm6)); + TEST_INSTRUCTION("8FE8688ECB40" , vpmacssdd(xmm1, xmm2, xmm3, xmm4)); + TEST_INSTRUCTION("8FE8688E8C2B8000000060" , vpmacssdd(xmm1, xmm2, ptr(rbx, rbp, 0, 128), xmm6)); + TEST_INSTRUCTION("8FE8688E8C2B8000000060" , vpmacssdd(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128), xmm6)); + TEST_INSTRUCTION("8FE8688FCB40" , vpmacssdqh(xmm1, xmm2, xmm3, xmm4)); + TEST_INSTRUCTION("8FE8688F8C2B8000000060" , vpmacssdqh(xmm1, xmm2, ptr(rbx, rbp, 0, 128), xmm6)); + TEST_INSTRUCTION("8FE8688F8C2B8000000060" , vpmacssdqh(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128), xmm6)); + TEST_INSTRUCTION("8FE86887CB40" , vpmacssdql(xmm1, xmm2, xmm3, xmm4)); + TEST_INSTRUCTION("8FE868878C2B8000000060" , vpmacssdql(xmm1, xmm2, ptr(rbx, rbp, 0, 128), xmm6)); + TEST_INSTRUCTION("8FE868878C2B8000000060" , vpmacssdql(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128), xmm6)); + TEST_INSTRUCTION("8FE86886CB40" , vpmacsswd(xmm1, xmm2, xmm3, xmm4)); + TEST_INSTRUCTION("8FE868868C2B8000000060" , vpmacsswd(xmm1, xmm2, ptr(rbx, rbp, 0, 128), xmm6)); + TEST_INSTRUCTION("8FE868868C2B8000000060" , vpmacsswd(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128), xmm6)); + TEST_INSTRUCTION("8FE86885CB40" , vpmacssww(xmm1, xmm2, xmm3, xmm4)); + TEST_INSTRUCTION("8FE868858C2B8000000060" , vpmacssww(xmm1, xmm2, ptr(rbx, rbp, 0, 128), xmm6)); + TEST_INSTRUCTION("8FE868858C2B8000000060" , vpmacssww(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128), xmm6)); + TEST_INSTRUCTION("8FE86896CB40" , vpmacswd(xmm1, xmm2, xmm3, xmm4)); + TEST_INSTRUCTION("8FE868968C2B8000000060" , vpmacswd(xmm1, xmm2, ptr(rbx, rbp, 0, 128), xmm6)); + TEST_INSTRUCTION("8FE868968C2B8000000060" , vpmacswd(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128), xmm6)); + TEST_INSTRUCTION("8FE86895CB40" , vpmacsww(xmm1, xmm2, xmm3, xmm4)); + TEST_INSTRUCTION("8FE868958C2B8000000060" , vpmacsww(xmm1, xmm2, ptr(rbx, rbp, 0, 128), xmm6)); + TEST_INSTRUCTION("8FE868958C2B8000000060" , vpmacsww(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128), xmm6)); + TEST_INSTRUCTION("8FE868A6CB40" , vpmadcsswd(xmm1, xmm2, xmm3, xmm4)); + TEST_INSTRUCTION("8FE868A68C2B8000000060" , vpmadcsswd(xmm1, xmm2, ptr(rbx, rbp, 0, 128), xmm6)); + TEST_INSTRUCTION("8FE868A68C2B8000000060" , vpmadcsswd(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128), xmm6)); + TEST_INSTRUCTION("8FE868B6CB40" , vpmadcswd(xmm1, xmm2, xmm3, xmm4)); + TEST_INSTRUCTION("8FE868B68C2B8000000060" , vpmadcswd(xmm1, xmm2, ptr(rbx, rbp, 0, 128), xmm6)); + TEST_INSTRUCTION("8FE868B68C2B8000000060" , vpmadcswd(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128), xmm6)); + TEST_INSTRUCTION("62F2ED08B5CB" , vpmadd52huq(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("62F2ED08B54C2B08" , vpmadd52huq(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED08B54C2B08" , vpmadd52huq(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED28B5CB" , vpmadd52huq(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("62F2ED28B54C2B04" , vpmadd52huq(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED28B54C2B04" , vpmadd52huq(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED48B5CB" , vpmadd52huq(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F2ED48B54C2B02" , vpmadd52huq(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED48B54C2B02" , vpmadd52huq(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED08B4CB" , vpmadd52luq(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("62F2ED08B44C2B08" , vpmadd52luq(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED08B44C2B08" , vpmadd52luq(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED28B4CB" , vpmadd52luq(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("62F2ED28B44C2B04" , vpmadd52luq(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED28B44C2B04" , vpmadd52luq(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED48B4CB" , vpmadd52luq(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F2ED48B44C2B02" , vpmadd52luq(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED48B44C2B02" , vpmadd52luq(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E26904CB" , vpmaddubsw(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E269048C2B80000000" , vpmaddubsw(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E269048C2B80000000" , vpmaddubsw(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E26D04CB" , vpmaddubsw(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C4E26D048C2B80000000" , vpmaddubsw(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E26D048C2B80000000" , vpmaddubsw(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D4804CB" , vpmaddubsw(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F26D48044C2B02" , vpmaddubsw(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D48044C2B02" , vpmaddubsw(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5E9F5CB" , vpmaddwd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5E9F58C2B80000000" , vpmaddwd(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5E9F58C2B80000000" , vpmaddwd(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5EDF5CB" , vpmaddwd(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C5EDF58C2B80000000" , vpmaddwd(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5EDF58C2B80000000" , vpmaddwd(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16D48F5CB" , vpmaddwd(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F16D48F54C2B02" , vpmaddwd(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16D48F54C2B02" , vpmaddwd(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E2618EA41180000000" , vpmaskmovd(ptr(rcx, rdx, 0, 128), xmm3, xmm4)); + TEST_INSTRUCTION("C4E2618EA41180000000" , vpmaskmovd(xmmword_ptr(rcx, rdx, 0, 128), xmm3, xmm4)); + TEST_INSTRUCTION("C4E2658EA41180000000" , vpmaskmovd(ptr(rcx, rdx, 0, 128), ymm3, ymm4)); + TEST_INSTRUCTION("C4E2658EA41180000000" , vpmaskmovd(ymmword_ptr(rcx, rdx, 0, 128), ymm3, ymm4)); + TEST_INSTRUCTION("C4E2698C8C2B80000000" , vpmaskmovd(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E2698C8C2B80000000" , vpmaskmovd(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E26D8C8C2B80000000" , vpmaskmovd(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E26D8C8C2B80000000" , vpmaskmovd(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E2E18EA41180000000" , vpmaskmovq(ptr(rcx, rdx, 0, 128), xmm3, xmm4)); + TEST_INSTRUCTION("C4E2E18EA41180000000" , vpmaskmovq(xmmword_ptr(rcx, rdx, 0, 128), xmm3, xmm4)); + TEST_INSTRUCTION("C4E2E58EA41180000000" , vpmaskmovq(ptr(rcx, rdx, 0, 128), ymm3, ymm4)); + TEST_INSTRUCTION("C4E2E58EA41180000000" , vpmaskmovq(ymmword_ptr(rcx, rdx, 0, 128), ymm3, ymm4)); + TEST_INSTRUCTION("C4E2E98C8C2B80000000" , vpmaskmovq(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E2E98C8C2B80000000" , vpmaskmovq(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E2ED8C8C2B80000000" , vpmaskmovq(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E2ED8C8C2B80000000" , vpmaskmovq(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E2693CCB" , vpmaxsb(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E2693C8C2B80000000" , vpmaxsb(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E2693C8C2B80000000" , vpmaxsb(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E26D3CCB" , vpmaxsb(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C4E26D3C8C2B80000000" , vpmaxsb(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E26D3C8C2B80000000" , vpmaxsb(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D483CCB" , vpmaxsb(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F26D483C4C2B02" , vpmaxsb(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D483C4C2B02" , vpmaxsb(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E2693DCB" , vpmaxsd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E2693D8C2B80000000" , vpmaxsd(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E2693D8C2B80000000" , vpmaxsd(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E26D3DCB" , vpmaxsd(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C4E26D3D8C2B80000000" , vpmaxsd(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E26D3D8C2B80000000" , vpmaxsd(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D483DCB" , vpmaxsd(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F26D483D4C2B02" , vpmaxsd(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D483D4C2B02" , vpmaxsd(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED083DCB" , vpmaxsq(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("62F2ED083D4C2B08" , vpmaxsq(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED083D4C2B08" , vpmaxsq(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED283DCB" , vpmaxsq(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("62F2ED283D4C2B04" , vpmaxsq(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED283D4C2B04" , vpmaxsq(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED483DCB" , vpmaxsq(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F2ED483D4C2B02" , vpmaxsq(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED483D4C2B02" , vpmaxsq(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5E9EECB" , vpmaxsw(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5E9EE8C2B80000000" , vpmaxsw(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5E9EE8C2B80000000" , vpmaxsw(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5EDEECB" , vpmaxsw(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C5EDEE8C2B80000000" , vpmaxsw(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5EDEE8C2B80000000" , vpmaxsw(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16D48EECB" , vpmaxsw(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F16D48EE4C2B02" , vpmaxsw(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16D48EE4C2B02" , vpmaxsw(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5E9DECB" , vpmaxub(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5E9DE8C2B80000000" , vpmaxub(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5E9DE8C2B80000000" , vpmaxub(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5EDDECB" , vpmaxub(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C5EDDE8C2B80000000" , vpmaxub(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5EDDE8C2B80000000" , vpmaxub(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16D48DECB" , vpmaxub(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F16D48DE4C2B02" , vpmaxub(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16D48DE4C2B02" , vpmaxub(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E2693FCB" , vpmaxud(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E2693F8C2B80000000" , vpmaxud(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E2693F8C2B80000000" , vpmaxud(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E26D3FCB" , vpmaxud(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C4E26D3F8C2B80000000" , vpmaxud(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E26D3F8C2B80000000" , vpmaxud(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D483FCB" , vpmaxud(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F26D483F4C2B02" , vpmaxud(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D483F4C2B02" , vpmaxud(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED083FCB" , vpmaxuq(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("62F2ED083F4C2B08" , vpmaxuq(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED083F4C2B08" , vpmaxuq(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED283FCB" , vpmaxuq(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("62F2ED283F4C2B04" , vpmaxuq(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED283F4C2B04" , vpmaxuq(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED483FCB" , vpmaxuq(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F2ED483F4C2B02" , vpmaxuq(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED483F4C2B02" , vpmaxuq(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E2693ECB" , vpmaxuw(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E2693E8C2B80000000" , vpmaxuw(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E2693E8C2B80000000" , vpmaxuw(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E26D3ECB" , vpmaxuw(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C4E26D3E8C2B80000000" , vpmaxuw(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E26D3E8C2B80000000" , vpmaxuw(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D483ECB" , vpmaxuw(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F26D483E4C2B02" , vpmaxuw(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D483E4C2B02" , vpmaxuw(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E26938CB" , vpminsb(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E269388C2B80000000" , vpminsb(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E269388C2B80000000" , vpminsb(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E26D38CB" , vpminsb(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C4E26D388C2B80000000" , vpminsb(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E26D388C2B80000000" , vpminsb(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D4838CB" , vpminsb(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F26D48384C2B02" , vpminsb(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D48384C2B02" , vpminsb(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E26939CB" , vpminsd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E269398C2B80000000" , vpminsd(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E269398C2B80000000" , vpminsd(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E26D39CB" , vpminsd(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C4E26D398C2B80000000" , vpminsd(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E26D398C2B80000000" , vpminsd(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D4839CB" , vpminsd(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F26D48394C2B02" , vpminsd(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D48394C2B02" , vpminsd(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED0839CB" , vpminsq(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("62F2ED08394C2B08" , vpminsq(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED08394C2B08" , vpminsq(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED2839CB" , vpminsq(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("62F2ED28394C2B04" , vpminsq(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED28394C2B04" , vpminsq(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED4839CB" , vpminsq(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F2ED48394C2B02" , vpminsq(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED48394C2B02" , vpminsq(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5E9EACB" , vpminsw(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5E9EA8C2B80000000" , vpminsw(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5E9EA8C2B80000000" , vpminsw(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5EDEACB" , vpminsw(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C5EDEA8C2B80000000" , vpminsw(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5EDEA8C2B80000000" , vpminsw(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16D48EACB" , vpminsw(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F16D48EA4C2B02" , vpminsw(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16D48EA4C2B02" , vpminsw(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5E9DACB" , vpminub(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5E9DA8C2B80000000" , vpminub(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5E9DA8C2B80000000" , vpminub(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5EDDACB" , vpminub(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C5EDDA8C2B80000000" , vpminub(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5EDDA8C2B80000000" , vpminub(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16D48DACB" , vpminub(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F16D48DA4C2B02" , vpminub(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16D48DA4C2B02" , vpminub(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E2693BCB" , vpminud(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E2693B8C2B80000000" , vpminud(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E2693B8C2B80000000" , vpminud(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E26D3BCB" , vpminud(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C4E26D3B8C2B80000000" , vpminud(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E26D3B8C2B80000000" , vpminud(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D483BCB" , vpminud(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F26D483B4C2B02" , vpminud(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D483B4C2B02" , vpminud(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED083BCB" , vpminuq(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("62F2ED083B4C2B08" , vpminuq(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED083B4C2B08" , vpminuq(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED283BCB" , vpminuq(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("62F2ED283B4C2B04" , vpminuq(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED283B4C2B04" , vpminuq(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED483BCB" , vpminuq(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F2ED483B4C2B02" , vpminuq(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED483B4C2B02" , vpminuq(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E2693ACB" , vpminuw(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E2693A8C2B80000000" , vpminuw(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E2693A8C2B80000000" , vpminuw(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E26D3ACB" , vpminuw(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C4E26D3A8C2B80000000" , vpminuw(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E26D3A8C2B80000000" , vpminuw(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D483ACB" , vpminuw(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F26D483A4C2B02" , vpminuw(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D483A4C2B02" , vpminuw(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F27E0829CA" , vpmovb2m(k1, xmm2)); + TEST_INSTRUCTION("62F27E2829CA" , vpmovb2m(k1, ymm2)); + TEST_INSTRUCTION("62F27E4829CA" , vpmovb2m(k1, zmm2)); + TEST_INSTRUCTION("62F27E0839CA" , vpmovd2m(k1, xmm2)); + TEST_INSTRUCTION("62F27E2839CA" , vpmovd2m(k1, ymm2)); + TEST_INSTRUCTION("62F27E4839CA" , vpmovd2m(k1, zmm2)); + TEST_INSTRUCTION("62F27E0831D1" , vpmovdb(xmm1, xmm2)); + TEST_INSTRUCTION("62F27E08315C1120" , vpmovdb(ptr(rcx, rdx, 0, 128), xmm3)); + TEST_INSTRUCTION("62F27E08315C1120" , vpmovdb(dword_ptr(rcx, rdx, 0, 128), xmm3)); + TEST_INSTRUCTION("62F27E2831D1" , vpmovdb(xmm1, ymm2)); + TEST_INSTRUCTION("62F27E28315C1110" , vpmovdb(ptr(rcx, rdx, 0, 128), ymm3)); + TEST_INSTRUCTION("62F27E28315C1110" , vpmovdb(qword_ptr(rcx, rdx, 0, 128), ymm3)); + TEST_INSTRUCTION("62F27E4831D1" , vpmovdb(xmm1, zmm2)); + TEST_INSTRUCTION("62F27E48315C1108" , vpmovdb(ptr(rcx, rdx, 0, 128), zmm3)); + TEST_INSTRUCTION("62F27E48315C1108" , vpmovdb(xmmword_ptr(rcx, rdx, 0, 128), zmm3)); + TEST_INSTRUCTION("62F27E0833D1" , vpmovdw(xmm1, xmm2)); + TEST_INSTRUCTION("62F27E08335C1110" , vpmovdw(ptr(rcx, rdx, 0, 128), xmm3)); + TEST_INSTRUCTION("62F27E08335C1110" , vpmovdw(qword_ptr(rcx, rdx, 0, 128), xmm3)); + TEST_INSTRUCTION("62F27E2833D1" , vpmovdw(xmm1, ymm2)); + TEST_INSTRUCTION("62F27E28335C1108" , vpmovdw(ptr(rcx, rdx, 0, 128), ymm3)); + TEST_INSTRUCTION("62F27E28335C1108" , vpmovdw(xmmword_ptr(rcx, rdx, 0, 128), ymm3)); + TEST_INSTRUCTION("62F27E4833D1" , vpmovdw(ymm1, zmm2)); + TEST_INSTRUCTION("62F27E48335C1104" , vpmovdw(ptr(rcx, rdx, 0, 128), zmm3)); + TEST_INSTRUCTION("62F27E48335C1104" , vpmovdw(ymmword_ptr(rcx, rdx, 0, 128), zmm3)); + TEST_INSTRUCTION("62F27E0828CA" , vpmovm2b(xmm1, k2)); + TEST_INSTRUCTION("62F27E2828CA" , vpmovm2b(ymm1, k2)); + TEST_INSTRUCTION("62F27E4828CA" , vpmovm2b(zmm1, k2)); + TEST_INSTRUCTION("62F27E0838CA" , vpmovm2d(xmm1, k2)); + TEST_INSTRUCTION("62F27E2838CA" , vpmovm2d(ymm1, k2)); + TEST_INSTRUCTION("62F27E4838CA" , vpmovm2d(zmm1, k2)); + TEST_INSTRUCTION("62F2FE0838CA" , vpmovm2q(xmm1, k2)); + TEST_INSTRUCTION("62F2FE2838CA" , vpmovm2q(ymm1, k2)); + TEST_INSTRUCTION("62F2FE4838CA" , vpmovm2q(zmm1, k2)); + TEST_INSTRUCTION("62F2FE0828CA" , vpmovm2w(xmm1, k2)); + TEST_INSTRUCTION("62F2FE2828CA" , vpmovm2w(ymm1, k2)); + TEST_INSTRUCTION("62F2FE4828CA" , vpmovm2w(zmm1, k2)); + TEST_INSTRUCTION("C5F9D7CA" , vpmovmskb(ecx, xmm2)); + TEST_INSTRUCTION("C5FDD7CA" , vpmovmskb(ecx, ymm2)); + TEST_INSTRUCTION("62F2FE0839CA" , vpmovq2m(k1, xmm2)); + TEST_INSTRUCTION("62F2FE2839CA" , vpmovq2m(k1, ymm2)); + TEST_INSTRUCTION("62F2FE4839CA" , vpmovq2m(k1, zmm2)); + TEST_INSTRUCTION("62F27E0832D1" , vpmovqb(xmm1, xmm2)); + TEST_INSTRUCTION("62F27E08325C1140" , vpmovqb(ptr(rcx, rdx, 0, 128), xmm3)); + TEST_INSTRUCTION("62F27E08325C1140" , vpmovqb(word_ptr(rcx, rdx, 0, 128), xmm3)); + TEST_INSTRUCTION("62F27E2832D1" , vpmovqb(xmm1, ymm2)); + TEST_INSTRUCTION("62F27E28325C1120" , vpmovqb(ptr(rcx, rdx, 0, 128), ymm3)); + TEST_INSTRUCTION("62F27E28325C1120" , vpmovqb(dword_ptr(rcx, rdx, 0, 128), ymm3)); + TEST_INSTRUCTION("62F27E4832D1" , vpmovqb(xmm1, zmm2)); + TEST_INSTRUCTION("62F27E48325C1110" , vpmovqb(ptr(rcx, rdx, 0, 128), zmm3)); + TEST_INSTRUCTION("62F27E48325C1110" , vpmovqb(qword_ptr(rcx, rdx, 0, 128), zmm3)); + TEST_INSTRUCTION("62F27E0835D1" , vpmovqd(xmm1, xmm2)); + TEST_INSTRUCTION("62F27E08355C1110" , vpmovqd(ptr(rcx, rdx, 0, 128), xmm3)); + TEST_INSTRUCTION("62F27E08355C1110" , vpmovqd(qword_ptr(rcx, rdx, 0, 128), xmm3)); + TEST_INSTRUCTION("62F27E2835D1" , vpmovqd(xmm1, ymm2)); + TEST_INSTRUCTION("62F27E28355C1108" , vpmovqd(ptr(rcx, rdx, 0, 128), ymm3)); + TEST_INSTRUCTION("62F27E28355C1108" , vpmovqd(xmmword_ptr(rcx, rdx, 0, 128), ymm3)); + TEST_INSTRUCTION("62F27E4835D1" , vpmovqd(ymm1, zmm2)); + TEST_INSTRUCTION("62F27E48355C1104" , vpmovqd(ptr(rcx, rdx, 0, 128), zmm3)); + TEST_INSTRUCTION("62F27E48355C1104" , vpmovqd(ymmword_ptr(rcx, rdx, 0, 128), zmm3)); + TEST_INSTRUCTION("62F27E0834D1" , vpmovqw(xmm1, xmm2)); + TEST_INSTRUCTION("62F27E08345C1120" , vpmovqw(ptr(rcx, rdx, 0, 128), xmm3)); + TEST_INSTRUCTION("62F27E08345C1120" , vpmovqw(dword_ptr(rcx, rdx, 0, 128), xmm3)); + TEST_INSTRUCTION("62F27E2834D1" , vpmovqw(xmm1, ymm2)); + TEST_INSTRUCTION("62F27E28345C1110" , vpmovqw(ptr(rcx, rdx, 0, 128), ymm3)); + TEST_INSTRUCTION("62F27E28345C1110" , vpmovqw(qword_ptr(rcx, rdx, 0, 128), ymm3)); + TEST_INSTRUCTION("62F27E4834D1" , vpmovqw(xmm1, zmm2)); + TEST_INSTRUCTION("62F27E48345C1108" , vpmovqw(ptr(rcx, rdx, 0, 128), zmm3)); + TEST_INSTRUCTION("62F27E48345C1108" , vpmovqw(xmmword_ptr(rcx, rdx, 0, 128), zmm3)); + TEST_INSTRUCTION("62F27E0821D1" , vpmovsdb(xmm1, xmm2)); + TEST_INSTRUCTION("62F27E08215C1120" , vpmovsdb(ptr(rcx, rdx, 0, 128), xmm3)); + TEST_INSTRUCTION("62F27E08215C1120" , vpmovsdb(dword_ptr(rcx, rdx, 0, 128), xmm3)); + TEST_INSTRUCTION("62F27E2821D1" , vpmovsdb(xmm1, ymm2)); + TEST_INSTRUCTION("62F27E28215C1110" , vpmovsdb(ptr(rcx, rdx, 0, 128), ymm3)); + TEST_INSTRUCTION("62F27E28215C1110" , vpmovsdb(qword_ptr(rcx, rdx, 0, 128), ymm3)); + TEST_INSTRUCTION("62F27E4821D1" , vpmovsdb(xmm1, zmm2)); + TEST_INSTRUCTION("62F27E48215C1108" , vpmovsdb(ptr(rcx, rdx, 0, 128), zmm3)); + TEST_INSTRUCTION("62F27E48215C1108" , vpmovsdb(xmmword_ptr(rcx, rdx, 0, 128), zmm3)); + TEST_INSTRUCTION("62F27E0823D1" , vpmovsdw(xmm1, xmm2)); + TEST_INSTRUCTION("62F27E08235C1110" , vpmovsdw(ptr(rcx, rdx, 0, 128), xmm3)); + TEST_INSTRUCTION("62F27E08235C1110" , vpmovsdw(qword_ptr(rcx, rdx, 0, 128), xmm3)); + TEST_INSTRUCTION("62F27E2823D1" , vpmovsdw(xmm1, ymm2)); + TEST_INSTRUCTION("62F27E28235C1108" , vpmovsdw(ptr(rcx, rdx, 0, 128), ymm3)); + TEST_INSTRUCTION("62F27E28235C1108" , vpmovsdw(xmmword_ptr(rcx, rdx, 0, 128), ymm3)); + TEST_INSTRUCTION("62F27E4823D1" , vpmovsdw(ymm1, zmm2)); + TEST_INSTRUCTION("62F27E48235C1104" , vpmovsdw(ptr(rcx, rdx, 0, 128), zmm3)); + TEST_INSTRUCTION("62F27E48235C1104" , vpmovsdw(ymmword_ptr(rcx, rdx, 0, 128), zmm3)); + TEST_INSTRUCTION("62F27E0822D1" , vpmovsqb(xmm1, xmm2)); + TEST_INSTRUCTION("62F27E08225C1140" , vpmovsqb(ptr(rcx, rdx, 0, 128), xmm3)); + TEST_INSTRUCTION("62F27E08225C1140" , vpmovsqb(word_ptr(rcx, rdx, 0, 128), xmm3)); + TEST_INSTRUCTION("62F27E2822D1" , vpmovsqb(xmm1, ymm2)); + TEST_INSTRUCTION("62F27E28225C1120" , vpmovsqb(ptr(rcx, rdx, 0, 128), ymm3)); + TEST_INSTRUCTION("62F27E28225C1120" , vpmovsqb(dword_ptr(rcx, rdx, 0, 128), ymm3)); + TEST_INSTRUCTION("62F27E4822D1" , vpmovsqb(xmm1, zmm2)); + TEST_INSTRUCTION("62F27E48225C1110" , vpmovsqb(ptr(rcx, rdx, 0, 128), zmm3)); + TEST_INSTRUCTION("62F27E48225C1110" , vpmovsqb(qword_ptr(rcx, rdx, 0, 128), zmm3)); + TEST_INSTRUCTION("62F27E0825D1" , vpmovsqd(xmm1, xmm2)); + TEST_INSTRUCTION("62F27E08255C1110" , vpmovsqd(ptr(rcx, rdx, 0, 128), xmm3)); + TEST_INSTRUCTION("62F27E08255C1110" , vpmovsqd(qword_ptr(rcx, rdx, 0, 128), xmm3)); + TEST_INSTRUCTION("62F27E2825D1" , vpmovsqd(xmm1, ymm2)); + TEST_INSTRUCTION("62F27E28255C1108" , vpmovsqd(ptr(rcx, rdx, 0, 128), ymm3)); + TEST_INSTRUCTION("62F27E28255C1108" , vpmovsqd(xmmword_ptr(rcx, rdx, 0, 128), ymm3)); + TEST_INSTRUCTION("62F27E4825D1" , vpmovsqd(ymm1, zmm2)); + TEST_INSTRUCTION("62F27E48255C1104" , vpmovsqd(ptr(rcx, rdx, 0, 128), zmm3)); + TEST_INSTRUCTION("62F27E48255C1104" , vpmovsqd(ymmword_ptr(rcx, rdx, 0, 128), zmm3)); + TEST_INSTRUCTION("62F27E0824D1" , vpmovsqw(xmm1, xmm2)); + TEST_INSTRUCTION("62F27E08245C1120" , vpmovsqw(ptr(rcx, rdx, 0, 128), xmm3)); + TEST_INSTRUCTION("62F27E08245C1120" , vpmovsqw(dword_ptr(rcx, rdx, 0, 128), xmm3)); + TEST_INSTRUCTION("62F27E2824D1" , vpmovsqw(xmm1, ymm2)); + TEST_INSTRUCTION("62F27E28245C1110" , vpmovsqw(ptr(rcx, rdx, 0, 128), ymm3)); + TEST_INSTRUCTION("62F27E28245C1110" , vpmovsqw(qword_ptr(rcx, rdx, 0, 128), ymm3)); + TEST_INSTRUCTION("62F27E4824D1" , vpmovsqw(xmm1, zmm2)); + TEST_INSTRUCTION("62F27E48245C1108" , vpmovsqw(ptr(rcx, rdx, 0, 128), zmm3)); + TEST_INSTRUCTION("62F27E48245C1108" , vpmovsqw(xmmword_ptr(rcx, rdx, 0, 128), zmm3)); + TEST_INSTRUCTION("62F27E0820D1" , vpmovswb(xmm1, xmm2)); + TEST_INSTRUCTION("62F27E08205C1110" , vpmovswb(ptr(rcx, rdx, 0, 128), xmm3)); + TEST_INSTRUCTION("62F27E08205C1110" , vpmovswb(qword_ptr(rcx, rdx, 0, 128), xmm3)); + TEST_INSTRUCTION("62F27E2820D1" , vpmovswb(xmm1, ymm2)); + TEST_INSTRUCTION("62F27E28205C1108" , vpmovswb(ptr(rcx, rdx, 0, 128), ymm3)); + TEST_INSTRUCTION("62F27E28205C1108" , vpmovswb(xmmword_ptr(rcx, rdx, 0, 128), ymm3)); + TEST_INSTRUCTION("62F27E4820D1" , vpmovswb(ymm1, zmm2)); + TEST_INSTRUCTION("62F27E48205C1104" , vpmovswb(ptr(rcx, rdx, 0, 128), zmm3)); + TEST_INSTRUCTION("62F27E48205C1104" , vpmovswb(ymmword_ptr(rcx, rdx, 0, 128), zmm3)); + TEST_INSTRUCTION("C4E27921CA" , vpmovsxbd(xmm1, xmm2)); + TEST_INSTRUCTION("C4E279218C1A80000000" , vpmovsxbd(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C4E279218C1A80000000" , vpmovsxbd(xmm1, dword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C4E27D21CA" , vpmovsxbd(ymm1, xmm2)); + TEST_INSTRUCTION("C4E27D218C1A80000000" , vpmovsxbd(ymm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C4E27D218C1A80000000" , vpmovsxbd(ymm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F27D4821CA" , vpmovsxbd(zmm1, xmm2)); + TEST_INSTRUCTION("62F27D48214C1A08" , vpmovsxbd(zmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F27D48214C1A08" , vpmovsxbd(zmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C4E27922CA" , vpmovsxbq(xmm1, xmm2)); + TEST_INSTRUCTION("C4E279228C1A80000000" , vpmovsxbq(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C4E279228C1A80000000" , vpmovsxbq(xmm1, word_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C4E27D22CA" , vpmovsxbq(ymm1, xmm2)); + TEST_INSTRUCTION("C4E27D228C1A80000000" , vpmovsxbq(ymm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C4E27D228C1A80000000" , vpmovsxbq(ymm1, dword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F27D4822CA" , vpmovsxbq(zmm1, xmm2)); + TEST_INSTRUCTION("62F27D48224C1A10" , vpmovsxbq(zmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F27D48224C1A10" , vpmovsxbq(zmm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C4E27920CA" , vpmovsxbw(xmm1, xmm2)); + TEST_INSTRUCTION("C4E279208C1A80000000" , vpmovsxbw(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C4E279208C1A80000000" , vpmovsxbw(xmm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C4E27D20CA" , vpmovsxbw(ymm1, xmm2)); + TEST_INSTRUCTION("C4E27D208C1A80000000" , vpmovsxbw(ymm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C4E27D208C1A80000000" , vpmovsxbw(ymm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F27D4820CA" , vpmovsxbw(zmm1, ymm2)); + TEST_INSTRUCTION("62F27D48204C1A04" , vpmovsxbw(zmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F27D48204C1A04" , vpmovsxbw(zmm1, ymmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C4E27925CA" , vpmovsxdq(xmm1, xmm2)); + TEST_INSTRUCTION("C4E279258C1A80000000" , vpmovsxdq(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C4E279258C1A80000000" , vpmovsxdq(xmm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C4E27D25CA" , vpmovsxdq(ymm1, xmm2)); + TEST_INSTRUCTION("C4E27D258C1A80000000" , vpmovsxdq(ymm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C4E27D258C1A80000000" , vpmovsxdq(ymm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F27D4825CA" , vpmovsxdq(zmm1, ymm2)); + TEST_INSTRUCTION("62F27D48254C1A04" , vpmovsxdq(zmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F27D48254C1A04" , vpmovsxdq(zmm1, ymmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C4E27923CA" , vpmovsxwd(xmm1, xmm2)); + TEST_INSTRUCTION("C4E279238C1A80000000" , vpmovsxwd(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C4E279238C1A80000000" , vpmovsxwd(xmm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C4E27D23CA" , vpmovsxwd(ymm1, xmm2)); + TEST_INSTRUCTION("C4E27D238C1A80000000" , vpmovsxwd(ymm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C4E27D238C1A80000000" , vpmovsxwd(ymm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F27D4823CA" , vpmovsxwd(zmm1, ymm2)); + TEST_INSTRUCTION("62F27D48234C1A04" , vpmovsxwd(zmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F27D48234C1A04" , vpmovsxwd(zmm1, ymmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C4E27924CA" , vpmovsxwq(xmm1, xmm2)); + TEST_INSTRUCTION("C4E279248C1A80000000" , vpmovsxwq(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C4E279248C1A80000000" , vpmovsxwq(xmm1, dword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C4E27D24CA" , vpmovsxwq(ymm1, xmm2)); + TEST_INSTRUCTION("C4E27D248C1A80000000" , vpmovsxwq(ymm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C4E27D248C1A80000000" , vpmovsxwq(ymm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F27D4824CA" , vpmovsxwq(zmm1, xmm2)); + TEST_INSTRUCTION("62F27D48244C1A08" , vpmovsxwq(zmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F27D48244C1A08" , vpmovsxwq(zmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F27E0811D1" , vpmovusdb(xmm1, xmm2)); + TEST_INSTRUCTION("62F27E08115C1120" , vpmovusdb(ptr(rcx, rdx, 0, 128), xmm3)); + TEST_INSTRUCTION("62F27E08115C1120" , vpmovusdb(dword_ptr(rcx, rdx, 0, 128), xmm3)); + TEST_INSTRUCTION("62F27E2811D1" , vpmovusdb(xmm1, ymm2)); + TEST_INSTRUCTION("62F27E28115C1110" , vpmovusdb(ptr(rcx, rdx, 0, 128), ymm3)); + TEST_INSTRUCTION("62F27E28115C1110" , vpmovusdb(qword_ptr(rcx, rdx, 0, 128), ymm3)); + TEST_INSTRUCTION("62F27E4811D1" , vpmovusdb(xmm1, zmm2)); + TEST_INSTRUCTION("62F27E48115C1108" , vpmovusdb(ptr(rcx, rdx, 0, 128), zmm3)); + TEST_INSTRUCTION("62F27E48115C1108" , vpmovusdb(xmmword_ptr(rcx, rdx, 0, 128), zmm3)); + TEST_INSTRUCTION("62F27E0813D1" , vpmovusdw(xmm1, xmm2)); + TEST_INSTRUCTION("62F27E08135C1110" , vpmovusdw(ptr(rcx, rdx, 0, 128), xmm3)); + TEST_INSTRUCTION("62F27E08135C1110" , vpmovusdw(qword_ptr(rcx, rdx, 0, 128), xmm3)); + TEST_INSTRUCTION("62F27E2813D1" , vpmovusdw(xmm1, ymm2)); + TEST_INSTRUCTION("62F27E28135C1108" , vpmovusdw(ptr(rcx, rdx, 0, 128), ymm3)); + TEST_INSTRUCTION("62F27E28135C1108" , vpmovusdw(xmmword_ptr(rcx, rdx, 0, 128), ymm3)); + TEST_INSTRUCTION("62F27E4813D1" , vpmovusdw(ymm1, zmm2)); + TEST_INSTRUCTION("62F27E48135C1104" , vpmovusdw(ptr(rcx, rdx, 0, 128), zmm3)); + TEST_INSTRUCTION("62F27E48135C1104" , vpmovusdw(ymmword_ptr(rcx, rdx, 0, 128), zmm3)); + TEST_INSTRUCTION("62F27E0812D1" , vpmovusqb(xmm1, xmm2)); + TEST_INSTRUCTION("62F27E08125C1140" , vpmovusqb(ptr(rcx, rdx, 0, 128), xmm3)); + TEST_INSTRUCTION("62F27E08125C1140" , vpmovusqb(word_ptr(rcx, rdx, 0, 128), xmm3)); + TEST_INSTRUCTION("62F27E2812D1" , vpmovusqb(xmm1, ymm2)); + TEST_INSTRUCTION("62F27E28125C1120" , vpmovusqb(ptr(rcx, rdx, 0, 128), ymm3)); + TEST_INSTRUCTION("62F27E28125C1120" , vpmovusqb(dword_ptr(rcx, rdx, 0, 128), ymm3)); + TEST_INSTRUCTION("62F27E4812D1" , vpmovusqb(xmm1, zmm2)); + TEST_INSTRUCTION("62F27E48125C1110" , vpmovusqb(ptr(rcx, rdx, 0, 128), zmm3)); + TEST_INSTRUCTION("62F27E48125C1110" , vpmovusqb(qword_ptr(rcx, rdx, 0, 128), zmm3)); + TEST_INSTRUCTION("62F27E0815D1" , vpmovusqd(xmm1, xmm2)); + TEST_INSTRUCTION("62F27E08155C1110" , vpmovusqd(ptr(rcx, rdx, 0, 128), xmm3)); + TEST_INSTRUCTION("62F27E08155C1110" , vpmovusqd(qword_ptr(rcx, rdx, 0, 128), xmm3)); + TEST_INSTRUCTION("62F27E2815D1" , vpmovusqd(xmm1, ymm2)); + TEST_INSTRUCTION("62F27E28155C1108" , vpmovusqd(ptr(rcx, rdx, 0, 128), ymm3)); + TEST_INSTRUCTION("62F27E28155C1108" , vpmovusqd(xmmword_ptr(rcx, rdx, 0, 128), ymm3)); + TEST_INSTRUCTION("62F27E4815D1" , vpmovusqd(ymm1, zmm2)); + TEST_INSTRUCTION("62F27E48155C1104" , vpmovusqd(ptr(rcx, rdx, 0, 128), zmm3)); + TEST_INSTRUCTION("62F27E48155C1104" , vpmovusqd(ymmword_ptr(rcx, rdx, 0, 128), zmm3)); + TEST_INSTRUCTION("62F27E0814D1" , vpmovusqw(xmm1, xmm2)); + TEST_INSTRUCTION("62F27E08145C1120" , vpmovusqw(ptr(rcx, rdx, 0, 128), xmm3)); + TEST_INSTRUCTION("62F27E08145C1120" , vpmovusqw(dword_ptr(rcx, rdx, 0, 128), xmm3)); + TEST_INSTRUCTION("62F27E2814D1" , vpmovusqw(xmm1, ymm2)); + TEST_INSTRUCTION("62F27E28145C1110" , vpmovusqw(ptr(rcx, rdx, 0, 128), ymm3)); + TEST_INSTRUCTION("62F27E28145C1110" , vpmovusqw(qword_ptr(rcx, rdx, 0, 128), ymm3)); + TEST_INSTRUCTION("62F27E4814D1" , vpmovusqw(xmm1, zmm2)); + TEST_INSTRUCTION("62F27E48145C1108" , vpmovusqw(ptr(rcx, rdx, 0, 128), zmm3)); + TEST_INSTRUCTION("62F27E48145C1108" , vpmovusqw(xmmword_ptr(rcx, rdx, 0, 128), zmm3)); + TEST_INSTRUCTION("62F27E0810D1" , vpmovuswb(xmm1, xmm2)); + TEST_INSTRUCTION("62F27E08105C1110" , vpmovuswb(ptr(rcx, rdx, 0, 128), xmm3)); + TEST_INSTRUCTION("62F27E08105C1110" , vpmovuswb(qword_ptr(rcx, rdx, 0, 128), xmm3)); + TEST_INSTRUCTION("62F27E2810D1" , vpmovuswb(xmm1, ymm2)); + TEST_INSTRUCTION("62F27E28105C1108" , vpmovuswb(ptr(rcx, rdx, 0, 128), ymm3)); + TEST_INSTRUCTION("62F27E28105C1108" , vpmovuswb(xmmword_ptr(rcx, rdx, 0, 128), ymm3)); + TEST_INSTRUCTION("62F27E4810D1" , vpmovuswb(ymm1, zmm2)); + TEST_INSTRUCTION("62F27E48105C1104" , vpmovuswb(ptr(rcx, rdx, 0, 128), zmm3)); + TEST_INSTRUCTION("62F27E48105C1104" , vpmovuswb(ymmword_ptr(rcx, rdx, 0, 128), zmm3)); + TEST_INSTRUCTION("62F2FE0829CA" , vpmovw2m(k1, xmm2)); + TEST_INSTRUCTION("62F2FE2829CA" , vpmovw2m(k1, ymm2)); + TEST_INSTRUCTION("62F2FE4829CA" , vpmovw2m(k1, zmm2)); + TEST_INSTRUCTION("62F27E0830D1" , vpmovwb(xmm1, xmm2)); + TEST_INSTRUCTION("62F27E08305C1110" , vpmovwb(ptr(rcx, rdx, 0, 128), xmm3)); + TEST_INSTRUCTION("62F27E08305C1110" , vpmovwb(qword_ptr(rcx, rdx, 0, 128), xmm3)); + TEST_INSTRUCTION("62F27E2830D1" , vpmovwb(xmm1, ymm2)); + TEST_INSTRUCTION("62F27E28305C1108" , vpmovwb(ptr(rcx, rdx, 0, 128), ymm3)); + TEST_INSTRUCTION("62F27E28305C1108" , vpmovwb(xmmword_ptr(rcx, rdx, 0, 128), ymm3)); + TEST_INSTRUCTION("62F27E4830D1" , vpmovwb(ymm1, zmm2)); + TEST_INSTRUCTION("62F27E48305C1104" , vpmovwb(ptr(rcx, rdx, 0, 128), zmm3)); + TEST_INSTRUCTION("62F27E48305C1104" , vpmovwb(ymmword_ptr(rcx, rdx, 0, 128), zmm3)); + TEST_INSTRUCTION("C4E27931CA" , vpmovzxbd(xmm1, xmm2)); + TEST_INSTRUCTION("C4E279318C1A80000000" , vpmovzxbd(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C4E279318C1A80000000" , vpmovzxbd(xmm1, dword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C4E27D31CA" , vpmovzxbd(ymm1, xmm2)); + TEST_INSTRUCTION("C4E27D318C1A80000000" , vpmovzxbd(ymm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C4E27D318C1A80000000" , vpmovzxbd(ymm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F27D4831CA" , vpmovzxbd(zmm1, xmm2)); + TEST_INSTRUCTION("62F27D48314C1A08" , vpmovzxbd(zmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F27D48314C1A08" , vpmovzxbd(zmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C4E27932CA" , vpmovzxbq(xmm1, xmm2)); + TEST_INSTRUCTION("C4E279328C1A80000000" , vpmovzxbq(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C4E279328C1A80000000" , vpmovzxbq(xmm1, word_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C4E27D32CA" , vpmovzxbq(ymm1, xmm2)); + TEST_INSTRUCTION("C4E27D328C1A80000000" , vpmovzxbq(ymm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C4E27D328C1A80000000" , vpmovzxbq(ymm1, dword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F27D4832CA" , vpmovzxbq(zmm1, xmm2)); + TEST_INSTRUCTION("62F27D48324C1A10" , vpmovzxbq(zmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F27D48324C1A10" , vpmovzxbq(zmm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C4E27930CA" , vpmovzxbw(xmm1, xmm2)); + TEST_INSTRUCTION("C4E279308C1A80000000" , vpmovzxbw(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C4E279308C1A80000000" , vpmovzxbw(xmm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C4E27D30CA" , vpmovzxbw(ymm1, xmm2)); + TEST_INSTRUCTION("C4E27D308C1A80000000" , vpmovzxbw(ymm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C4E27D308C1A80000000" , vpmovzxbw(ymm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F27D4830CA" , vpmovzxbw(zmm1, ymm2)); + TEST_INSTRUCTION("62F27D48304C1A04" , vpmovzxbw(zmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F27D48304C1A04" , vpmovzxbw(zmm1, ymmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C4E27935CA" , vpmovzxdq(xmm1, xmm2)); + TEST_INSTRUCTION("C4E279358C1A80000000" , vpmovzxdq(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C4E279358C1A80000000" , vpmovzxdq(xmm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C4E27D35CA" , vpmovzxdq(ymm1, xmm2)); + TEST_INSTRUCTION("C4E27D358C1A80000000" , vpmovzxdq(ymm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C4E27D358C1A80000000" , vpmovzxdq(ymm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F27D4835CA" , vpmovzxdq(zmm1, ymm2)); + TEST_INSTRUCTION("62F27D48354C1A04" , vpmovzxdq(zmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F27D48354C1A04" , vpmovzxdq(zmm1, ymmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C4E27933CA" , vpmovzxwd(xmm1, xmm2)); + TEST_INSTRUCTION("C4E279338C1A80000000" , vpmovzxwd(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C4E279338C1A80000000" , vpmovzxwd(xmm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C4E27D33CA" , vpmovzxwd(ymm1, xmm2)); + TEST_INSTRUCTION("C4E27D338C1A80000000" , vpmovzxwd(ymm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C4E27D338C1A80000000" , vpmovzxwd(ymm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F27D4833CA" , vpmovzxwd(zmm1, ymm2)); + TEST_INSTRUCTION("62F27D48334C1A04" , vpmovzxwd(zmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F27D48334C1A04" , vpmovzxwd(zmm1, ymmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C4E27934CA" , vpmovzxwq(xmm1, xmm2)); + TEST_INSTRUCTION("C4E279348C1A80000000" , vpmovzxwq(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C4E279348C1A80000000" , vpmovzxwq(xmm1, dword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C4E27D34CA" , vpmovzxwq(ymm1, xmm2)); + TEST_INSTRUCTION("C4E27D348C1A80000000" , vpmovzxwq(ymm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C4E27D348C1A80000000" , vpmovzxwq(ymm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F27D4834CA" , vpmovzxwq(zmm1, xmm2)); + TEST_INSTRUCTION("62F27D48344C1A08" , vpmovzxwq(zmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F27D48344C1A08" , vpmovzxwq(zmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C4E26928CB" , vpmuldq(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E269288C2B80000000" , vpmuldq(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E269288C2B80000000" , vpmuldq(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E26D28CB" , vpmuldq(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C4E26D288C2B80000000" , vpmuldq(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E26D288C2B80000000" , vpmuldq(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED4828CB" , vpmuldq(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F2ED48284C2B02" , vpmuldq(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED48284C2B02" , vpmuldq(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E2690BCB" , vpmulhrsw(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E2690B8C2B80000000" , vpmulhrsw(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E2690B8C2B80000000" , vpmulhrsw(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E26D0BCB" , vpmulhrsw(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C4E26D0B8C2B80000000" , vpmulhrsw(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E26D0B8C2B80000000" , vpmulhrsw(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D480BCB" , vpmulhrsw(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F26D480B4C2B02" , vpmulhrsw(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D480B4C2B02" , vpmulhrsw(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5E9E4CB" , vpmulhuw(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5E9E48C2B80000000" , vpmulhuw(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5E9E48C2B80000000" , vpmulhuw(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5EDE4CB" , vpmulhuw(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C5EDE48C2B80000000" , vpmulhuw(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5EDE48C2B80000000" , vpmulhuw(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16D48E4CB" , vpmulhuw(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F16D48E44C2B02" , vpmulhuw(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16D48E44C2B02" , vpmulhuw(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5E9E5CB" , vpmulhw(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5E9E58C2B80000000" , vpmulhw(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5E9E58C2B80000000" , vpmulhw(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5EDE5CB" , vpmulhw(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C5EDE58C2B80000000" , vpmulhw(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5EDE58C2B80000000" , vpmulhw(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16D48E5CB" , vpmulhw(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F16D48E54C2B02" , vpmulhw(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16D48E54C2B02" , vpmulhw(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E26940CB" , vpmulld(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E269408C2B80000000" , vpmulld(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E269408C2B80000000" , vpmulld(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E26D40CB" , vpmulld(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C4E26D408C2B80000000" , vpmulld(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E26D408C2B80000000" , vpmulld(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D4840CB" , vpmulld(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F26D48404C2B02" , vpmulld(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D48404C2B02" , vpmulld(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED0840CB" , vpmullq(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("62F2ED08404C2B08" , vpmullq(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED08404C2B08" , vpmullq(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED2840CB" , vpmullq(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("62F2ED28404C2B04" , vpmullq(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED28404C2B04" , vpmullq(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED4840CB" , vpmullq(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F2ED48404C2B02" , vpmullq(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED48404C2B02" , vpmullq(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5E9D5CB" , vpmullw(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5E9D58C2B80000000" , vpmullw(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5E9D58C2B80000000" , vpmullw(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5EDD5CB" , vpmullw(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C5EDD58C2B80000000" , vpmullw(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5EDD58C2B80000000" , vpmullw(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16D48D5CB" , vpmullw(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F16D48D54C2B02" , vpmullw(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16D48D54C2B02" , vpmullw(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED0883CB" , vpmultishiftqb(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("62F2ED08834C2B08" , vpmultishiftqb(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED08834C2B08" , vpmultishiftqb(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED2883CB" , vpmultishiftqb(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("62F2ED28834C2B04" , vpmultishiftqb(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED28834C2B04" , vpmultishiftqb(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED4883CB" , vpmultishiftqb(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F2ED48834C2B02" , vpmultishiftqb(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED48834C2B02" , vpmultishiftqb(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5E9F4CB" , vpmuludq(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5E9F48C2B80000000" , vpmuludq(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5E9F48C2B80000000" , vpmuludq(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5EDF4CB" , vpmuludq(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C5EDF48C2B80000000" , vpmuludq(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5EDF48C2B80000000" , vpmuludq(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F1ED48F4CB" , vpmuludq(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F1ED48F44C2B02" , vpmuludq(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F1ED48F44C2B02" , vpmuludq(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F27D0854CA" , vpopcntb(xmm1, xmm2)); + TEST_INSTRUCTION("62F27D08544C1A08" , vpopcntb(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F27D08544C1A08" , vpopcntb(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F27D2854CA" , vpopcntb(ymm1, ymm2)); + TEST_INSTRUCTION("62F27D28544C1A04" , vpopcntb(ymm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F27D28544C1A04" , vpopcntb(ymm1, ymmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F27D4854CA" , vpopcntb(zmm1, zmm2)); + TEST_INSTRUCTION("62F27D48544C1A02" , vpopcntb(zmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F27D48544C1A02" , vpopcntb(zmm1, zmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F27D0855CA" , vpopcntd(xmm1, xmm2)); + TEST_INSTRUCTION("62F27D08554C1A08" , vpopcntd(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F27D08554C1A08" , vpopcntd(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F27D2855CA" , vpopcntd(ymm1, ymm2)); + TEST_INSTRUCTION("62F27D28554C1A04" , vpopcntd(ymm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F27D28554C1A04" , vpopcntd(ymm1, ymmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F27D4855CA" , vpopcntd(zmm1, zmm2)); + TEST_INSTRUCTION("62F27D48554C1A02" , vpopcntd(zmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F27D48554C1A02" , vpopcntd(zmm1, zmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F2FD0855CA" , vpopcntq(xmm1, xmm2)); + TEST_INSTRUCTION("62F2FD08554C1A08" , vpopcntq(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F2FD08554C1A08" , vpopcntq(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F2FD2855CA" , vpopcntq(ymm1, ymm2)); + TEST_INSTRUCTION("62F2FD28554C1A04" , vpopcntq(ymm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F2FD28554C1A04" , vpopcntq(ymm1, ymmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F2FD4855CA" , vpopcntq(zmm1, zmm2)); + TEST_INSTRUCTION("62F2FD48554C1A02" , vpopcntq(zmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F2FD48554C1A02" , vpopcntq(zmm1, zmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F2FD0854CA" , vpopcntw(xmm1, xmm2)); + TEST_INSTRUCTION("62F2FD08544C1A08" , vpopcntw(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F2FD08544C1A08" , vpopcntw(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F2FD2854CA" , vpopcntw(ymm1, ymm2)); + TEST_INSTRUCTION("62F2FD28544C1A04" , vpopcntw(ymm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F2FD28544C1A04" , vpopcntw(ymm1, ymmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F2FD4854CA" , vpopcntw(zmm1, zmm2)); + TEST_INSTRUCTION("62F2FD48544C1A02" , vpopcntw(zmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F2FD48544C1A02" , vpopcntw(zmm1, zmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C5E9EBCB" , vpor(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5E9EB8C2B80000000" , vpor(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5E9EB8C2B80000000" , vpor(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5EDEBCB" , vpor(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C5EDEB8C2B80000000" , vpor(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5EDEB8C2B80000000" , vpor(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16D08EBCB" , vpord(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("62F16D08EB4C2B08" , vpord(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16D08EB4C2B08" , vpord(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16D28EBCB" , vpord(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("62F16D28EB4C2B04" , vpord(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16D28EB4C2B04" , vpord(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16D48EBCB" , vpord(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F16D48EB4C2B02" , vpord(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16D48EB4C2B02" , vpord(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F1ED08EBCB" , vporq(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("62F1ED08EB4C2B08" , vporq(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F1ED08EB4C2B08" , vporq(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F1ED28EBCB" , vporq(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("62F1ED28EB4C2B04" , vporq(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F1ED28EB4C2B04" , vporq(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F1ED48EBCB" , vporq(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F1ED48EB4C2B02" , vporq(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F1ED48EB4C2B02" , vporq(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("8FE868A3CB40" , vpperm(xmm1, xmm2, xmm3, xmm4)); + TEST_INSTRUCTION("8FE8E8A38C358000000030" , vpperm(xmm1, xmm2, xmm3, ptr(rbp, rsi, 0, 128))); + TEST_INSTRUCTION("8FE8E8A38C358000000030" , vpperm(xmm1, xmm2, xmm3, xmmword_ptr(rbp, rsi, 0, 128))); + TEST_INSTRUCTION("8FE868A38C2B8000000060" , vpperm(xmm1, xmm2, ptr(rbx, rbp, 0, 128), xmm6)); + TEST_INSTRUCTION("8FE868A38C2B8000000060" , vpperm(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128), xmm6)); + TEST_INSTRUCTION("62F1750872CA01" , vprold(xmm1, xmm2, 1)); + TEST_INSTRUCTION("62F17508724C1A0801" , vprold(xmm1, ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("62F17508724C1A0801" , vprold(xmm1, xmmword_ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("62F1752872CA01" , vprold(ymm1, ymm2, 1)); + TEST_INSTRUCTION("62F17528724C1A0401" , vprold(ymm1, ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("62F17528724C1A0401" , vprold(ymm1, ymmword_ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("62F1754872CA01" , vprold(zmm1, zmm2, 1)); + TEST_INSTRUCTION("62F17548724C1A0201" , vprold(zmm1, ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("62F17548724C1A0201" , vprold(zmm1, zmmword_ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("62F1F50872CA01" , vprolq(xmm1, xmm2, 1)); + TEST_INSTRUCTION("62F1F508724C1A0801" , vprolq(xmm1, ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("62F1F508724C1A0801" , vprolq(xmm1, xmmword_ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("62F1F52872CA01" , vprolq(ymm1, ymm2, 1)); + TEST_INSTRUCTION("62F1F528724C1A0401" , vprolq(ymm1, ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("62F1F528724C1A0401" , vprolq(ymm1, ymmword_ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("62F1F54872CA01" , vprolq(zmm1, zmm2, 1)); + TEST_INSTRUCTION("62F1F548724C1A0201" , vprolq(zmm1, ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("62F1F548724C1A0201" , vprolq(zmm1, zmmword_ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("62F26D0815CB" , vprolvd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("62F26D08154C2B08" , vprolvd(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D08154C2B08" , vprolvd(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D2815CB" , vprolvd(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("62F26D28154C2B04" , vprolvd(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D28154C2B04" , vprolvd(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D4815CB" , vprolvd(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F26D48154C2B02" , vprolvd(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D48154C2B02" , vprolvd(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED0815CB" , vprolvq(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("62F2ED08154C2B08" , vprolvq(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED08154C2B08" , vprolvq(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED2815CB" , vprolvq(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("62F2ED28154C2B04" , vprolvq(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED28154C2B04" , vprolvq(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED4815CB" , vprolvq(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F2ED48154C2B02" , vprolvq(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED48154C2B02" , vprolvq(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F1750872C201" , vprord(xmm1, xmm2, 1)); + TEST_INSTRUCTION("62F1750872441A0801" , vprord(xmm1, ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("62F1750872441A0801" , vprord(xmm1, xmmword_ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("62F1752872C201" , vprord(ymm1, ymm2, 1)); + TEST_INSTRUCTION("62F1752872441A0401" , vprord(ymm1, ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("62F1752872441A0401" , vprord(ymm1, ymmword_ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("62F1754872C201" , vprord(zmm1, zmm2, 1)); + TEST_INSTRUCTION("62F1754872441A0201" , vprord(zmm1, ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("62F1754872441A0201" , vprord(zmm1, zmmword_ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("62F1F50872C201" , vprorq(xmm1, xmm2, 1)); + TEST_INSTRUCTION("62F1F50872441A0801" , vprorq(xmm1, ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("62F1F50872441A0801" , vprorq(xmm1, xmmword_ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("62F1F52872C201" , vprorq(ymm1, ymm2, 1)); + TEST_INSTRUCTION("62F1F52872441A0401" , vprorq(ymm1, ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("62F1F52872441A0401" , vprorq(ymm1, ymmword_ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("62F1F54872C201" , vprorq(zmm1, zmm2, 1)); + TEST_INSTRUCTION("62F1F54872441A0201" , vprorq(zmm1, ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("62F1F54872441A0201" , vprorq(zmm1, zmmword_ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("62F26D0814CB" , vprorvd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("62F26D08144C2B08" , vprorvd(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D08144C2B08" , vprorvd(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D2814CB" , vprorvd(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("62F26D28144C2B04" , vprorvd(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D28144C2B04" , vprorvd(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D4814CB" , vprorvd(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F26D48144C2B02" , vprorvd(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D48144C2B02" , vprorvd(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED0814CB" , vprorvq(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("62F2ED08144C2B08" , vprorvq(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED08144C2B08" , vprorvq(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED2814CB" , vprorvq(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("62F2ED28144C2B04" , vprorvq(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED28144C2B04" , vprorvq(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED4814CB" , vprorvq(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F2ED48144C2B02" , vprorvq(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED48144C2B02" , vprorvq(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("8FE96090CA" , vprotb(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("8FE878C0CA01" , vprotb(xmm1, xmm2, 1)); + TEST_INSTRUCTION("8FE9E8908C2B80000000" , vprotb(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("8FE9E8908C2B80000000" , vprotb(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("8FE958908C1A80000000" , vprotb(xmm1, ptr(rdx, rbx, 0, 128), xmm4)); + TEST_INSTRUCTION("8FE878C08C1A8000000001" , vprotb(xmm1, ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("8FE958908C1A80000000" , vprotb(xmm1, xmmword_ptr(rdx, rbx, 0, 128), xmm4)); + TEST_INSTRUCTION("8FE878C08C1A8000000001" , vprotb(xmm1, xmmword_ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("8FE96092CA" , vprotd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("8FE878C2CA01" , vprotd(xmm1, xmm2, 1)); + TEST_INSTRUCTION("8FE9E8928C2B80000000" , vprotd(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("8FE9E8928C2B80000000" , vprotd(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("8FE958928C1A80000000" , vprotd(xmm1, ptr(rdx, rbx, 0, 128), xmm4)); + TEST_INSTRUCTION("8FE878C28C1A8000000001" , vprotd(xmm1, ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("8FE958928C1A80000000" , vprotd(xmm1, xmmword_ptr(rdx, rbx, 0, 128), xmm4)); + TEST_INSTRUCTION("8FE878C28C1A8000000001" , vprotd(xmm1, xmmword_ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("8FE96093CA" , vprotq(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("8FE878C3CA01" , vprotq(xmm1, xmm2, 1)); + TEST_INSTRUCTION("8FE9E8938C2B80000000" , vprotq(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("8FE9E8938C2B80000000" , vprotq(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("8FE958938C1A80000000" , vprotq(xmm1, ptr(rdx, rbx, 0, 128), xmm4)); + TEST_INSTRUCTION("8FE878C38C1A8000000001" , vprotq(xmm1, ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("8FE958938C1A80000000" , vprotq(xmm1, xmmword_ptr(rdx, rbx, 0, 128), xmm4)); + TEST_INSTRUCTION("8FE878C38C1A8000000001" , vprotq(xmm1, xmmword_ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("8FE96091CA" , vprotw(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("8FE878C1CA01" , vprotw(xmm1, xmm2, 1)); + TEST_INSTRUCTION("8FE9E8918C2B80000000" , vprotw(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("8FE9E8918C2B80000000" , vprotw(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("8FE958918C1A80000000" , vprotw(xmm1, ptr(rdx, rbx, 0, 128), xmm4)); + TEST_INSTRUCTION("8FE878C18C1A8000000001" , vprotw(xmm1, ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("8FE958918C1A80000000" , vprotw(xmm1, xmmword_ptr(rdx, rbx, 0, 128), xmm4)); + TEST_INSTRUCTION("8FE878C18C1A8000000001" , vprotw(xmm1, xmmword_ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("C5E9F6CB" , vpsadbw(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5E9F68C2B80000000" , vpsadbw(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5E9F68C2B80000000" , vpsadbw(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5EDF6CB" , vpsadbw(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C5EDF68C2B80000000" , vpsadbw(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5EDF68C2B80000000" , vpsadbw(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16D48F6CB" , vpsadbw(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F16D48F64C2B02" , vpsadbw(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16D48F64C2B02" , vpsadbw(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F27D09A05C1120" , k(k1).vpscatterdd(ptr(rcx, xmm2, 0, 128), xmm3)); + TEST_INSTRUCTION("62F27D29A05C1120" , k(k1).vpscatterdd(ptr(rcx, ymm2, 0, 128), ymm3)); + TEST_INSTRUCTION("62F27D49A05C1120" , k(k1).vpscatterdd(ptr(rcx, zmm2, 0, 128), zmm3)); + TEST_INSTRUCTION("62F2FD09A05C1110" , k(k1).vpscatterdq(ptr(rcx, xmm2, 0, 128), xmm3)); + TEST_INSTRUCTION("62F2FD29A05C1110" , k(k1).vpscatterdq(ptr(rcx, xmm2, 0, 128), ymm3)); + TEST_INSTRUCTION("62F2FD49A05C1110" , k(k1).vpscatterdq(ptr(rcx, ymm2, 0, 128), zmm3)); + TEST_INSTRUCTION("62F27D09A15C1120" , k(k1).vpscatterqd(ptr(rcx, xmm2, 0, 128), xmm3)); + TEST_INSTRUCTION("62F27D29A15C1120" , k(k1).vpscatterqd(ptr(rcx, ymm2, 0, 128), xmm3)); + TEST_INSTRUCTION("62F27D49A15C1120" , k(k1).vpscatterqd(ptr(rcx, zmm2, 0, 128), ymm3)); + TEST_INSTRUCTION("62F2FD09A15C1110" , k(k1).vpscatterqq(ptr(rcx, xmm2, 0, 128), xmm3)); + TEST_INSTRUCTION("62F2FD29A15C1110" , k(k1).vpscatterqq(ptr(rcx, ymm2, 0, 128), ymm3)); + TEST_INSTRUCTION("62F2FD49A15C1110" , k(k1).vpscatterqq(ptr(rcx, zmm2, 0, 128), zmm3)); + TEST_INSTRUCTION("8FE96098CA" , vpshab(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("8FE9E8988C2B80000000" , vpshab(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("8FE9E8988C2B80000000" , vpshab(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("8FE958988C1A80000000" , vpshab(xmm1, ptr(rdx, rbx, 0, 128), xmm4)); + TEST_INSTRUCTION("8FE958988C1A80000000" , vpshab(xmm1, xmmword_ptr(rdx, rbx, 0, 128), xmm4)); + TEST_INSTRUCTION("8FE9609ACA" , vpshad(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("8FE9E89A8C2B80000000" , vpshad(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("8FE9E89A8C2B80000000" , vpshad(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("8FE9589A8C1A80000000" , vpshad(xmm1, ptr(rdx, rbx, 0, 128), xmm4)); + TEST_INSTRUCTION("8FE9589A8C1A80000000" , vpshad(xmm1, xmmword_ptr(rdx, rbx, 0, 128), xmm4)); + TEST_INSTRUCTION("8FE9609BCA" , vpshaq(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("8FE9E89B8C2B80000000" , vpshaq(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("8FE9E89B8C2B80000000" , vpshaq(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("8FE9589B8C1A80000000" , vpshaq(xmm1, ptr(rdx, rbx, 0, 128), xmm4)); + TEST_INSTRUCTION("8FE9589B8C1A80000000" , vpshaq(xmm1, xmmword_ptr(rdx, rbx, 0, 128), xmm4)); + TEST_INSTRUCTION("8FE96099CA" , vpshaw(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("8FE9E8998C2B80000000" , vpshaw(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("8FE9E8998C2B80000000" , vpshaw(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("8FE958998C1A80000000" , vpshaw(xmm1, ptr(rdx, rbx, 0, 128), xmm4)); + TEST_INSTRUCTION("8FE958998C1A80000000" , vpshaw(xmm1, xmmword_ptr(rdx, rbx, 0, 128), xmm4)); + TEST_INSTRUCTION("8FE96094CA" , vpshlb(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("8FE9E8948C2B80000000" , vpshlb(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("8FE9E8948C2B80000000" , vpshlb(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("8FE958948C1A80000000" , vpshlb(xmm1, ptr(rdx, rbx, 0, 128), xmm4)); + TEST_INSTRUCTION("8FE958948C1A80000000" , vpshlb(xmm1, xmmword_ptr(rdx, rbx, 0, 128), xmm4)); + TEST_INSTRUCTION("8FE96096CA" , vpshld(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("8FE9E8968C2B80000000" , vpshld(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("8FE9E8968C2B80000000" , vpshld(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("8FE958968C1A80000000" , vpshld(xmm1, ptr(rdx, rbx, 0, 128), xmm4)); + TEST_INSTRUCTION("8FE958968C1A80000000" , vpshld(xmm1, xmmword_ptr(rdx, rbx, 0, 128), xmm4)); + TEST_INSTRUCTION("62F36D0871CB01" , vpshldd(xmm1, xmm2, xmm3, 1)); + TEST_INSTRUCTION("62F36D08714C2B0801" , vpshldd(xmm1, xmm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D08714C2B0801" , vpshldd(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D2871CB01" , vpshldd(ymm1, ymm2, ymm3, 1)); + TEST_INSTRUCTION("62F36D28714C2B0401" , vpshldd(ymm1, ymm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D28714C2B0401" , vpshldd(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D4871CB01" , vpshldd(zmm1, zmm2, zmm3, 1)); + TEST_INSTRUCTION("62F36D48714C2B0201" , vpshldd(zmm1, zmm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D48714C2B0201" , vpshldd(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED0871CB01" , vpshldq(xmm1, xmm2, xmm3, 1)); + TEST_INSTRUCTION("62F3ED08714C2B0801" , vpshldq(xmm1, xmm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED08714C2B0801" , vpshldq(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED2871CB01" , vpshldq(ymm1, ymm2, ymm3, 1)); + TEST_INSTRUCTION("62F3ED28714C2B0401" , vpshldq(ymm1, ymm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED28714C2B0401" , vpshldq(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED4871CB01" , vpshldq(zmm1, zmm2, zmm3, 1)); + TEST_INSTRUCTION("62F3ED48714C2B0201" , vpshldq(zmm1, zmm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED48714C2B0201" , vpshldq(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F26D0871CB" , vpshldvd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("62F26D08714C2B08" , vpshldvd(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D08714C2B08" , vpshldvd(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D2871CB" , vpshldvd(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("62F26D28714C2B04" , vpshldvd(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D28714C2B04" , vpshldvd(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D4871CB" , vpshldvd(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F26D48714C2B02" , vpshldvd(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D48714C2B02" , vpshldvd(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED0871CB" , vpshldvq(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("62F2ED08714C2B08" , vpshldvq(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED08714C2B08" , vpshldvq(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED2871CB" , vpshldvq(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("62F2ED28714C2B04" , vpshldvq(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED28714C2B04" , vpshldvq(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED4871CB" , vpshldvq(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F2ED48714C2B02" , vpshldvq(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED48714C2B02" , vpshldvq(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED0870CB" , vpshldvw(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("62F2ED08704C2B08" , vpshldvw(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED08704C2B08" , vpshldvw(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED2870CB" , vpshldvw(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("62F2ED28704C2B04" , vpshldvw(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED28704C2B04" , vpshldvw(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED4870CB" , vpshldvw(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F2ED48704C2B02" , vpshldvw(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED48704C2B02" , vpshldvw(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F3ED0870CB01" , vpshldw(xmm1, xmm2, xmm3, 1)); + TEST_INSTRUCTION("62F3ED08704C2B0801" , vpshldw(xmm1, xmm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED08704C2B0801" , vpshldw(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED2870CB01" , vpshldw(ymm1, ymm2, ymm3, 1)); + TEST_INSTRUCTION("62F3ED28704C2B0401" , vpshldw(ymm1, ymm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED28704C2B0401" , vpshldw(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED4870CB01" , vpshldw(zmm1, zmm2, zmm3, 1)); + TEST_INSTRUCTION("62F3ED48704C2B0201" , vpshldw(zmm1, zmm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED48704C2B0201" , vpshldw(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("8FE96097CA" , vpshlq(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("8FE9E8978C2B80000000" , vpshlq(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("8FE9E8978C2B80000000" , vpshlq(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("8FE958978C1A80000000" , vpshlq(xmm1, ptr(rdx, rbx, 0, 128), xmm4)); + TEST_INSTRUCTION("8FE958978C1A80000000" , vpshlq(xmm1, xmmword_ptr(rdx, rbx, 0, 128), xmm4)); + TEST_INSTRUCTION("8FE96095CA" , vpshlw(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("8FE9E8958C2B80000000" , vpshlw(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("8FE9E8958C2B80000000" , vpshlw(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("8FE958958C1A80000000" , vpshlw(xmm1, ptr(rdx, rbx, 0, 128), xmm4)); + TEST_INSTRUCTION("8FE958958C1A80000000" , vpshlw(xmm1, xmmword_ptr(rdx, rbx, 0, 128), xmm4)); + TEST_INSTRUCTION("62F36D0873CB01" , vpshrdd(xmm1, xmm2, xmm3, 1)); + TEST_INSTRUCTION("62F36D08734C2B0801" , vpshrdd(xmm1, xmm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D08734C2B0801" , vpshrdd(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D2873CB01" , vpshrdd(ymm1, ymm2, ymm3, 1)); + TEST_INSTRUCTION("62F36D28734C2B0401" , vpshrdd(ymm1, ymm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D28734C2B0401" , vpshrdd(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D4873CB01" , vpshrdd(zmm1, zmm2, zmm3, 1)); + TEST_INSTRUCTION("62F36D48734C2B0201" , vpshrdd(zmm1, zmm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D48734C2B0201" , vpshrdd(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED0873CB01" , vpshrdq(xmm1, xmm2, xmm3, 1)); + TEST_INSTRUCTION("62F3ED08734C2B0801" , vpshrdq(xmm1, xmm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED08734C2B0801" , vpshrdq(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED2873CB01" , vpshrdq(ymm1, ymm2, ymm3, 1)); + TEST_INSTRUCTION("62F3ED28734C2B0401" , vpshrdq(ymm1, ymm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED28734C2B0401" , vpshrdq(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED4873CB01" , vpshrdq(zmm1, zmm2, zmm3, 1)); + TEST_INSTRUCTION("62F3ED48734C2B0201" , vpshrdq(zmm1, zmm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED48734C2B0201" , vpshrdq(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F26D0873CB" , vpshrdvd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("62F26D08734C2B08" , vpshrdvd(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D08734C2B08" , vpshrdvd(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D2873CB" , vpshrdvd(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("62F26D28734C2B04" , vpshrdvd(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D28734C2B04" , vpshrdvd(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D4873CB" , vpshrdvd(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F26D48734C2B02" , vpshrdvd(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D48734C2B02" , vpshrdvd(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED0873CB" , vpshrdvq(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("62F2ED08734C2B08" , vpshrdvq(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED08734C2B08" , vpshrdvq(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED2873CB" , vpshrdvq(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("62F2ED28734C2B04" , vpshrdvq(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED28734C2B04" , vpshrdvq(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED4873CB" , vpshrdvq(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F2ED48734C2B02" , vpshrdvq(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED48734C2B02" , vpshrdvq(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED0872CB" , vpshrdvw(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("62F2ED08724C2B08" , vpshrdvw(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED08724C2B08" , vpshrdvw(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED2872CB" , vpshrdvw(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("62F2ED28724C2B04" , vpshrdvw(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED28724C2B04" , vpshrdvw(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED4872CB" , vpshrdvw(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F2ED48724C2B02" , vpshrdvw(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED48724C2B02" , vpshrdvw(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F3ED0872CB01" , vpshrdw(xmm1, xmm2, xmm3, 1)); + TEST_INSTRUCTION("62F3ED08724C2B0801" , vpshrdw(xmm1, xmm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED08724C2B0801" , vpshrdw(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED2872CB01" , vpshrdw(ymm1, ymm2, ymm3, 1)); + TEST_INSTRUCTION("62F3ED28724C2B0401" , vpshrdw(ymm1, ymm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED28724C2B0401" , vpshrdw(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED4872CB01" , vpshrdw(zmm1, zmm2, zmm3, 1)); + TEST_INSTRUCTION("62F3ED48724C2B0201" , vpshrdw(zmm1, zmm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED48724C2B0201" , vpshrdw(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("C4E26900CB" , vpshufb(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E269008C2B80000000" , vpshufb(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E269008C2B80000000" , vpshufb(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E26D00CB" , vpshufb(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C4E26D008C2B80000000" , vpshufb(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E26D008C2B80000000" , vpshufb(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D4800CB" , vpshufb(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F26D48004C2B02" , vpshufb(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D48004C2B02" , vpshufb(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D088FCB" , vpshufbitqmb(k1, xmm2, xmm3)); + TEST_INSTRUCTION("62F26D088F4C2B08" , vpshufbitqmb(k1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D088F4C2B08" , vpshufbitqmb(k1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D288FCB" , vpshufbitqmb(k1, ymm2, ymm3)); + TEST_INSTRUCTION("62F26D288F4C2B04" , vpshufbitqmb(k1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D288F4C2B04" , vpshufbitqmb(k1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D488FCB" , vpshufbitqmb(k1, zmm2, zmm3)); + TEST_INSTRUCTION("62F26D488F4C2B02" , vpshufbitqmb(k1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D488F4C2B02" , vpshufbitqmb(k1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5F970CA01" , vpshufd(xmm1, xmm2, 1)); + TEST_INSTRUCTION("C5F9708C1A8000000001" , vpshufd(xmm1, ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("C5F9708C1A8000000001" , vpshufd(xmm1, xmmword_ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("C5FD70CA01" , vpshufd(ymm1, ymm2, 1)); + TEST_INSTRUCTION("C5FD708C1A8000000001" , vpshufd(ymm1, ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("C5FD708C1A8000000001" , vpshufd(ymm1, ymmword_ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("62F17D4870CA01" , vpshufd(zmm1, zmm2, 1)); + TEST_INSTRUCTION("62F17D48704C1A0201" , vpshufd(zmm1, ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("62F17D48704C1A0201" , vpshufd(zmm1, zmmword_ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("C5FA70CA01" , vpshufhw(xmm1, xmm2, 1)); + TEST_INSTRUCTION("C5FA708C1A8000000001" , vpshufhw(xmm1, ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("C5FA708C1A8000000001" , vpshufhw(xmm1, xmmword_ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("C5FE70CA01" , vpshufhw(ymm1, ymm2, 1)); + TEST_INSTRUCTION("C5FE708C1A8000000001" , vpshufhw(ymm1, ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("C5FE708C1A8000000001" , vpshufhw(ymm1, ymmword_ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("62F17E4870CA01" , vpshufhw(zmm1, zmm2, 1)); + TEST_INSTRUCTION("62F17E48704C1A0201" , vpshufhw(zmm1, ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("62F17E48704C1A0201" , vpshufhw(zmm1, zmmword_ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("C5FB70CA01" , vpshuflw(xmm1, xmm2, 1)); + TEST_INSTRUCTION("C5FB708C1A8000000001" , vpshuflw(xmm1, ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("C5FB708C1A8000000001" , vpshuflw(xmm1, xmmword_ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("C5FF70CA01" , vpshuflw(ymm1, ymm2, 1)); + TEST_INSTRUCTION("C5FF708C1A8000000001" , vpshuflw(ymm1, ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("C5FF708C1A8000000001" , vpshuflw(ymm1, ymmword_ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("62F17F4870CA01" , vpshuflw(zmm1, zmm2, 1)); + TEST_INSTRUCTION("62F17F48704C1A0201" , vpshuflw(zmm1, ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("62F17F48704C1A0201" , vpshuflw(zmm1, zmmword_ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("C4E26908CB" , vpsignb(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E269088C2B80000000" , vpsignb(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E269088C2B80000000" , vpsignb(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E26D08CB" , vpsignb(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C4E26D088C2B80000000" , vpsignb(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E26D088C2B80000000" , vpsignb(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E2690ACB" , vpsignd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E2690A8C2B80000000" , vpsignd(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E2690A8C2B80000000" , vpsignd(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E26D0ACB" , vpsignd(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C4E26D0A8C2B80000000" , vpsignd(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E26D0A8C2B80000000" , vpsignd(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E26909CB" , vpsignw(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E269098C2B80000000" , vpsignw(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E269098C2B80000000" , vpsignw(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E26D09CB" , vpsignw(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C4E26D098C2B80000000" , vpsignw(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E26D098C2B80000000" , vpsignw(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5E9F2CB" , vpslld(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5F172F201" , vpslld(xmm1, xmm2, 1)); + TEST_INSTRUCTION("C5E9F28C2B80000000" , vpslld(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5E9F28C2B80000000" , vpslld(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5EDF2CB" , vpslld(ymm1, ymm2, xmm3)); + TEST_INSTRUCTION("C5F572F201" , vpslld(ymm1, ymm2, 1)); + TEST_INSTRUCTION("C5EDF28C2B80000000" , vpslld(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5EDF28C2B80000000" , vpslld(ymm1, ymm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F1750872741A0801" , vpslld(xmm1, ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("62F1750872741A0801" , vpslld(xmm1, xmmword_ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("62F1752872741A0401" , vpslld(ymm1, ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("62F1752872741A0401" , vpslld(ymm1, ymmword_ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("62F16D48F2CB" , vpslld(zmm1, zmm2, xmm3)); + TEST_INSTRUCTION("62F1754872F201" , vpslld(zmm1, zmm2, 1)); + TEST_INSTRUCTION("62F16D48F24C2B08" , vpslld(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16D48F24C2B08" , vpslld(zmm1, zmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F1754872741A0201" , vpslld(zmm1, ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("62F1754872741A0201" , vpslld(zmm1, zmmword_ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("C5F173FA01" , vpslldq(xmm1, xmm2, 1)); + TEST_INSTRUCTION("62F17508737C1A0801" , vpslldq(xmm1, ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("62F17508737C1A0801" , vpslldq(xmm1, xmmword_ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("C5F573FA01" , vpslldq(ymm1, ymm2, 1)); + TEST_INSTRUCTION("62F17528737C1A0401" , vpslldq(ymm1, ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("62F17528737C1A0401" , vpslldq(ymm1, ymmword_ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("62F1754873FA01" , vpslldq(zmm1, zmm2, 1)); + TEST_INSTRUCTION("62F17548737C1A0201" , vpslldq(zmm1, ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("62F17548737C1A0201" , vpslldq(zmm1, zmmword_ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("C5E9F3CB" , vpsllq(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5F173F201" , vpsllq(xmm1, xmm2, 1)); + TEST_INSTRUCTION("C5E9F38C2B80000000" , vpsllq(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5E9F38C2B80000000" , vpsllq(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5EDF3CB" , vpsllq(ymm1, ymm2, xmm3)); + TEST_INSTRUCTION("C5F573F201" , vpsllq(ymm1, ymm2, 1)); + TEST_INSTRUCTION("C5EDF38C2B80000000" , vpsllq(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5EDF38C2B80000000" , vpsllq(ymm1, ymm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F1F50873741A0801" , vpsllq(xmm1, ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("62F1F50873741A0801" , vpsllq(xmm1, xmmword_ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("62F1F52873741A0401" , vpsllq(ymm1, ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("62F1F52873741A0401" , vpsllq(ymm1, ymmword_ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("62F1ED48F3CB" , vpsllq(zmm1, zmm2, xmm3)); + TEST_INSTRUCTION("62F1F54873F201" , vpsllq(zmm1, zmm2, 1)); + TEST_INSTRUCTION("62F1ED48F34C2B08" , vpsllq(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F1ED48F34C2B08" , vpsllq(zmm1, zmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F1F54873741A0201" , vpsllq(zmm1, ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("62F1F54873741A0201" , vpsllq(zmm1, zmmword_ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("C4E26947CB" , vpsllvd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E269478C2B80000000" , vpsllvd(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E269478C2B80000000" , vpsllvd(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E26D47CB" , vpsllvd(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C4E26D478C2B80000000" , vpsllvd(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E26D478C2B80000000" , vpsllvd(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D4847CB" , vpsllvd(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F26D48474C2B02" , vpsllvd(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D48474C2B02" , vpsllvd(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E2E947CB" , vpsllvq(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E2E9478C2B80000000" , vpsllvq(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E2E9478C2B80000000" , vpsllvq(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E2ED47CB" , vpsllvq(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C4E2ED478C2B80000000" , vpsllvq(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E2ED478C2B80000000" , vpsllvq(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED4847CB" , vpsllvq(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F2ED48474C2B02" , vpsllvq(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED48474C2B02" , vpsllvq(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED0812CB" , vpsllvw(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("62F2ED08124C2B08" , vpsllvw(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED08124C2B08" , vpsllvw(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED2812CB" , vpsllvw(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("62F2ED28124C2B04" , vpsllvw(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED28124C2B04" , vpsllvw(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED4812CB" , vpsllvw(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F2ED48124C2B02" , vpsllvw(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED48124C2B02" , vpsllvw(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5E9F1CB" , vpsllw(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5F171F201" , vpsllw(xmm1, xmm2, 1)); + TEST_INSTRUCTION("C5E9F18C2B80000000" , vpsllw(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5E9F18C2B80000000" , vpsllw(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5EDF1CB" , vpsllw(ymm1, ymm2, xmm3)); + TEST_INSTRUCTION("C5F571F201" , vpsllw(ymm1, ymm2, 1)); + TEST_INSTRUCTION("C5EDF18C2B80000000" , vpsllw(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5EDF18C2B80000000" , vpsllw(ymm1, ymm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F1750871741A0801" , vpsllw(xmm1, ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("62F1750871741A0801" , vpsllw(xmm1, xmmword_ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("62F1752871741A0401" , vpsllw(ymm1, ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("62F1752871741A0401" , vpsllw(ymm1, ymmword_ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("62F16D48F1CB" , vpsllw(zmm1, zmm2, xmm3)); + TEST_INSTRUCTION("62F1754871F201" , vpsllw(zmm1, zmm2, 1)); + TEST_INSTRUCTION("62F16D48F14C2B08" , vpsllw(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16D48F14C2B08" , vpsllw(zmm1, zmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F1754871741A0201" , vpsllw(zmm1, ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("62F1754871741A0201" , vpsllw(zmm1, zmmword_ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("C5E9E2CB" , vpsrad(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5F172E201" , vpsrad(xmm1, xmm2, 1)); + TEST_INSTRUCTION("C5E9E28C2B80000000" , vpsrad(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5E9E28C2B80000000" , vpsrad(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5EDE2CB" , vpsrad(ymm1, ymm2, xmm3)); + TEST_INSTRUCTION("C5F572E201" , vpsrad(ymm1, ymm2, 1)); + TEST_INSTRUCTION("C5EDE28C2B80000000" , vpsrad(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5EDE28C2B80000000" , vpsrad(ymm1, ymm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F1750872641A0801" , vpsrad(xmm1, ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("62F1750872641A0801" , vpsrad(xmm1, xmmword_ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("62F1752872641A0401" , vpsrad(ymm1, ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("62F1752872641A0401" , vpsrad(ymm1, ymmword_ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("62F16D48E2CB" , vpsrad(zmm1, zmm2, xmm3)); + TEST_INSTRUCTION("62F1754872E201" , vpsrad(zmm1, zmm2, 1)); + TEST_INSTRUCTION("62F16D48E24C2B08" , vpsrad(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16D48E24C2B08" , vpsrad(zmm1, zmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F1754872641A0201" , vpsrad(zmm1, ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("62F1754872641A0201" , vpsrad(zmm1, zmmword_ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("62F1ED08E2CB" , vpsraq(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("62F1F50872E201" , vpsraq(xmm1, xmm2, 1)); + TEST_INSTRUCTION("62F1ED08E24C2B08" , vpsraq(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F1ED08E24C2B08" , vpsraq(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F1F50872641A0801" , vpsraq(xmm1, ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("62F1F50872641A0801" , vpsraq(xmm1, xmmword_ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("62F1ED28E2CB" , vpsraq(ymm1, ymm2, xmm3)); + TEST_INSTRUCTION("62F1F52872E201" , vpsraq(ymm1, ymm2, 1)); + TEST_INSTRUCTION("62F1ED28E24C2B08" , vpsraq(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F1ED28E24C2B08" , vpsraq(ymm1, ymm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F1F52872641A0401" , vpsraq(ymm1, ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("62F1F52872641A0401" , vpsraq(ymm1, ymmword_ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("62F1ED48E2CB" , vpsraq(zmm1, zmm2, xmm3)); + TEST_INSTRUCTION("62F1F54872E201" , vpsraq(zmm1, zmm2, 1)); + TEST_INSTRUCTION("62F1ED48E24C2B08" , vpsraq(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F1ED48E24C2B08" , vpsraq(zmm1, zmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F1F54872641A0201" , vpsraq(zmm1, ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("62F1F54872641A0201" , vpsraq(zmm1, zmmword_ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("C4E26946CB" , vpsravd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E269468C2B80000000" , vpsravd(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E269468C2B80000000" , vpsravd(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E26D46CB" , vpsravd(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C4E26D468C2B80000000" , vpsravd(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E26D468C2B80000000" , vpsravd(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D4846CB" , vpsravd(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F26D48464C2B02" , vpsravd(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D48464C2B02" , vpsravd(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED0846CB" , vpsravq(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("62F2ED08464C2B08" , vpsravq(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED08464C2B08" , vpsravq(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED2846CB" , vpsravq(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("62F2ED28464C2B04" , vpsravq(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED28464C2B04" , vpsravq(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED4846CB" , vpsravq(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F2ED48464C2B02" , vpsravq(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED48464C2B02" , vpsravq(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED0811CB" , vpsravw(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("62F2ED08114C2B08" , vpsravw(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED08114C2B08" , vpsravw(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED2811CB" , vpsravw(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("62F2ED28114C2B04" , vpsravw(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED28114C2B04" , vpsravw(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED4811CB" , vpsravw(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F2ED48114C2B02" , vpsravw(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED48114C2B02" , vpsravw(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5E9E1CB" , vpsraw(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5F171E201" , vpsraw(xmm1, xmm2, 1)); + TEST_INSTRUCTION("C5E9E18C2B80000000" , vpsraw(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5E9E18C2B80000000" , vpsraw(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5EDE1CB" , vpsraw(ymm1, ymm2, xmm3)); + TEST_INSTRUCTION("C5F571E201" , vpsraw(ymm1, ymm2, 1)); + TEST_INSTRUCTION("C5EDE18C2B80000000" , vpsraw(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5EDE18C2B80000000" , vpsraw(ymm1, ymm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F1750871641A0801" , vpsraw(xmm1, ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("62F1750871641A0801" , vpsraw(xmm1, xmmword_ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("62F1752871641A0401" , vpsraw(ymm1, ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("62F1752871641A0401" , vpsraw(ymm1, ymmword_ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("62F16D48E1CB" , vpsraw(zmm1, zmm2, xmm3)); + TEST_INSTRUCTION("62F1754871E201" , vpsraw(zmm1, zmm2, 1)); + TEST_INSTRUCTION("62F16D48E14C2B08" , vpsraw(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16D48E14C2B08" , vpsraw(zmm1, zmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F1754871641A0201" , vpsraw(zmm1, ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("62F1754871641A0201" , vpsraw(zmm1, zmmword_ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("C5E9D2CB" , vpsrld(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5F172D201" , vpsrld(xmm1, xmm2, 1)); + TEST_INSTRUCTION("C5E9D28C2B80000000" , vpsrld(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5E9D28C2B80000000" , vpsrld(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5EDD2CB" , vpsrld(ymm1, ymm2, xmm3)); + TEST_INSTRUCTION("C5F572D201" , vpsrld(ymm1, ymm2, 1)); + TEST_INSTRUCTION("C5EDD28C2B80000000" , vpsrld(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5EDD28C2B80000000" , vpsrld(ymm1, ymm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F1750872541A0801" , vpsrld(xmm1, ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("62F1750872541A0801" , vpsrld(xmm1, xmmword_ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("62F1752872541A0401" , vpsrld(ymm1, ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("62F1752872541A0401" , vpsrld(ymm1, ymmword_ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("62F16D48D2CB" , vpsrld(zmm1, zmm2, xmm3)); + TEST_INSTRUCTION("62F1754872D201" , vpsrld(zmm1, zmm2, 1)); + TEST_INSTRUCTION("62F16D48D24C2B08" , vpsrld(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16D48D24C2B08" , vpsrld(zmm1, zmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F1754872541A0201" , vpsrld(zmm1, ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("62F1754872541A0201" , vpsrld(zmm1, zmmword_ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("C5F173DA01" , vpsrldq(xmm1, xmm2, 1)); + TEST_INSTRUCTION("62F17508735C1A0801" , vpsrldq(xmm1, ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("62F17508735C1A0801" , vpsrldq(xmm1, xmmword_ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("C5F573DA01" , vpsrldq(ymm1, ymm2, 1)); + TEST_INSTRUCTION("62F17528735C1A0401" , vpsrldq(ymm1, ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("62F17528735C1A0401" , vpsrldq(ymm1, ymmword_ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("62F1754873DA01" , vpsrldq(zmm1, zmm2, 1)); + TEST_INSTRUCTION("62F17548735C1A0201" , vpsrldq(zmm1, ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("62F17548735C1A0201" , vpsrldq(zmm1, zmmword_ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("C5E9D3CB" , vpsrlq(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5F173D201" , vpsrlq(xmm1, xmm2, 1)); + TEST_INSTRUCTION("C5E9D38C2B80000000" , vpsrlq(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5E9D38C2B80000000" , vpsrlq(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5EDD3CB" , vpsrlq(ymm1, ymm2, xmm3)); + TEST_INSTRUCTION("C5F573D201" , vpsrlq(ymm1, ymm2, 1)); + TEST_INSTRUCTION("C5EDD38C2B80000000" , vpsrlq(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5EDD38C2B80000000" , vpsrlq(ymm1, ymm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F1F50873541A0801" , vpsrlq(xmm1, ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("62F1F50873541A0801" , vpsrlq(xmm1, xmmword_ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("62F1F52873541A0401" , vpsrlq(ymm1, ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("62F1F52873541A0401" , vpsrlq(ymm1, ymmword_ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("62F1ED48D3CB" , vpsrlq(zmm1, zmm2, xmm3)); + TEST_INSTRUCTION("62F1F54873D201" , vpsrlq(zmm1, zmm2, 1)); + TEST_INSTRUCTION("62F1ED48D34C2B08" , vpsrlq(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F1ED48D34C2B08" , vpsrlq(zmm1, zmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F1F54873541A0201" , vpsrlq(zmm1, ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("62F1F54873541A0201" , vpsrlq(zmm1, zmmword_ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("C4E26945CB" , vpsrlvd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E269458C2B80000000" , vpsrlvd(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E269458C2B80000000" , vpsrlvd(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E26D45CB" , vpsrlvd(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C4E26D458C2B80000000" , vpsrlvd(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E26D458C2B80000000" , vpsrlvd(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D4845CB" , vpsrlvd(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F26D48454C2B02" , vpsrlvd(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D48454C2B02" , vpsrlvd(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E2E945CB" , vpsrlvq(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E2E9458C2B80000000" , vpsrlvq(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E2E9458C2B80000000" , vpsrlvq(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E2ED45CB" , vpsrlvq(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C4E2ED458C2B80000000" , vpsrlvq(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E2ED458C2B80000000" , vpsrlvq(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED4845CB" , vpsrlvq(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F2ED48454C2B02" , vpsrlvq(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED48454C2B02" , vpsrlvq(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED0810CB" , vpsrlvw(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("62F2ED08104C2B08" , vpsrlvw(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED08104C2B08" , vpsrlvw(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED2810CB" , vpsrlvw(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("62F2ED28104C2B04" , vpsrlvw(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED28104C2B04" , vpsrlvw(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED4810CB" , vpsrlvw(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F2ED48104C2B02" , vpsrlvw(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED48104C2B02" , vpsrlvw(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5E9D1CB" , vpsrlw(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5F171D201" , vpsrlw(xmm1, xmm2, 1)); + TEST_INSTRUCTION("C5E9D18C2B80000000" , vpsrlw(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5E9D18C2B80000000" , vpsrlw(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5EDD1CB" , vpsrlw(ymm1, ymm2, xmm3)); + TEST_INSTRUCTION("C5F571D201" , vpsrlw(ymm1, ymm2, 1)); + TEST_INSTRUCTION("C5EDD18C2B80000000" , vpsrlw(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5EDD18C2B80000000" , vpsrlw(ymm1, ymm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F1750871541A0801" , vpsrlw(xmm1, ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("62F1750871541A0801" , vpsrlw(xmm1, xmmword_ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("62F1752871541A0401" , vpsrlw(ymm1, ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("62F1752871541A0401" , vpsrlw(ymm1, ymmword_ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("62F16D48D1CB" , vpsrlw(zmm1, zmm2, xmm3)); + TEST_INSTRUCTION("62F1754871D201" , vpsrlw(zmm1, zmm2, 1)); + TEST_INSTRUCTION("62F16D48D14C2B08" , vpsrlw(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16D48D14C2B08" , vpsrlw(zmm1, zmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F1754871541A0201" , vpsrlw(zmm1, ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("62F1754871541A0201" , vpsrlw(zmm1, zmmword_ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("C5E9F8CB" , vpsubb(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5E9F88C2B80000000" , vpsubb(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5E9F88C2B80000000" , vpsubb(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5EDF8CB" , vpsubb(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C5EDF88C2B80000000" , vpsubb(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5EDF88C2B80000000" , vpsubb(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16D48F8CB" , vpsubb(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F16D48F84C2B02" , vpsubb(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16D48F84C2B02" , vpsubb(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5E9FACB" , vpsubd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5E9FA8C2B80000000" , vpsubd(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5E9FA8C2B80000000" , vpsubd(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5EDFACB" , vpsubd(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C5EDFA8C2B80000000" , vpsubd(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5EDFA8C2B80000000" , vpsubd(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16D48FACB" , vpsubd(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F16D48FA4C2B02" , vpsubd(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16D48FA4C2B02" , vpsubd(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5E9FBCB" , vpsubq(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5E9FB8C2B80000000" , vpsubq(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5E9FB8C2B80000000" , vpsubq(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5EDFBCB" , vpsubq(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C5EDFB8C2B80000000" , vpsubq(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5EDFB8C2B80000000" , vpsubq(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F1ED48FBCB" , vpsubq(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F1ED48FB4C2B02" , vpsubq(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F1ED48FB4C2B02" , vpsubq(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5E9E8CB" , vpsubsb(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5E9E88C2B80000000" , vpsubsb(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5E9E88C2B80000000" , vpsubsb(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5EDE8CB" , vpsubsb(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C5EDE88C2B80000000" , vpsubsb(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5EDE88C2B80000000" , vpsubsb(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16D48E8CB" , vpsubsb(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F16D48E84C2B02" , vpsubsb(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16D48E84C2B02" , vpsubsb(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5E9E9CB" , vpsubsw(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5E9E98C2B80000000" , vpsubsw(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5E9E98C2B80000000" , vpsubsw(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5EDE9CB" , vpsubsw(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C5EDE98C2B80000000" , vpsubsw(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5EDE98C2B80000000" , vpsubsw(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16D48E9CB" , vpsubsw(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F16D48E94C2B02" , vpsubsw(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16D48E94C2B02" , vpsubsw(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5E9D8CB" , vpsubusb(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5E9D88C2B80000000" , vpsubusb(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5E9D88C2B80000000" , vpsubusb(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5EDD8CB" , vpsubusb(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C5EDD88C2B80000000" , vpsubusb(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5EDD88C2B80000000" , vpsubusb(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16D48D8CB" , vpsubusb(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F16D48D84C2B02" , vpsubusb(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16D48D84C2B02" , vpsubusb(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5E9D9CB" , vpsubusw(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5E9D98C2B80000000" , vpsubusw(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5E9D98C2B80000000" , vpsubusw(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5EDD9CB" , vpsubusw(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C5EDD98C2B80000000" , vpsubusw(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5EDD98C2B80000000" , vpsubusw(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16D48D9CB" , vpsubusw(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F16D48D94C2B02" , vpsubusw(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16D48D94C2B02" , vpsubusw(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5E9F9CB" , vpsubw(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5E9F98C2B80000000" , vpsubw(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5E9F98C2B80000000" , vpsubw(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5EDF9CB" , vpsubw(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C5EDF98C2B80000000" , vpsubw(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5EDF98C2B80000000" , vpsubw(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16D48F9CB" , vpsubw(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F16D48F94C2B02" , vpsubw(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16D48F94C2B02" , vpsubw(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F36D0825CB01" , vpternlogd(xmm1, xmm2, xmm3, 1)); + TEST_INSTRUCTION("62F36D08254C2B0801" , vpternlogd(xmm1, xmm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D08254C2B0801" , vpternlogd(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D2825CB01" , vpternlogd(ymm1, ymm2, ymm3, 1)); + TEST_INSTRUCTION("62F36D28254C2B0401" , vpternlogd(ymm1, ymm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D28254C2B0401" , vpternlogd(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D4825CB01" , vpternlogd(zmm1, zmm2, zmm3, 1)); + TEST_INSTRUCTION("62F36D48254C2B0201" , vpternlogd(zmm1, zmm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D48254C2B0201" , vpternlogd(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED0825CB01" , vpternlogq(xmm1, xmm2, xmm3, 1)); + TEST_INSTRUCTION("62F3ED08254C2B0801" , vpternlogq(xmm1, xmm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED08254C2B0801" , vpternlogq(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED2825CB01" , vpternlogq(ymm1, ymm2, ymm3, 1)); + TEST_INSTRUCTION("62F3ED28254C2B0401" , vpternlogq(ymm1, ymm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED28254C2B0401" , vpternlogq(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED4825CB01" , vpternlogq(zmm1, zmm2, zmm3, 1)); + TEST_INSTRUCTION("62F3ED48254C2B0201" , vpternlogq(zmm1, zmm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED48254C2B0201" , vpternlogq(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("C4E27917CA" , vptest(xmm1, xmm2)); + TEST_INSTRUCTION("C4E279178C1A80000000" , vptest(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C4E279178C1A80000000" , vptest(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C4E27D17CA" , vptest(ymm1, ymm2)); + TEST_INSTRUCTION("C4E27D178C1A80000000" , vptest(ymm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C4E27D178C1A80000000" , vptest(ymm1, ymmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F26D0826CB" , vptestmb(k1, xmm2, xmm3)); + TEST_INSTRUCTION("62F26D08264C2B08" , vptestmb(k1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D08264C2B08" , vptestmb(k1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D2826CB" , vptestmb(k1, ymm2, ymm3)); + TEST_INSTRUCTION("62F26D28264C2B04" , vptestmb(k1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D28264C2B04" , vptestmb(k1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D4826CB" , vptestmb(k1, zmm2, zmm3)); + TEST_INSTRUCTION("62F26D48264C2B02" , vptestmb(k1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D48264C2B02" , vptestmb(k1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D0827CB" , vptestmd(k1, xmm2, xmm3)); + TEST_INSTRUCTION("62F26D08274C2B08" , vptestmd(k1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D08274C2B08" , vptestmd(k1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D2827CB" , vptestmd(k1, ymm2, ymm3)); + TEST_INSTRUCTION("62F26D28274C2B04" , vptestmd(k1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D28274C2B04" , vptestmd(k1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D4827CB" , vptestmd(k1, zmm2, zmm3)); + TEST_INSTRUCTION("62F26D48274C2B02" , vptestmd(k1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D48274C2B02" , vptestmd(k1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED0827CB" , vptestmq(k1, xmm2, xmm3)); + TEST_INSTRUCTION("62F2ED08274C2B08" , vptestmq(k1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED08274C2B08" , vptestmq(k1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED2827CB" , vptestmq(k1, ymm2, ymm3)); + TEST_INSTRUCTION("62F2ED28274C2B04" , vptestmq(k1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED28274C2B04" , vptestmq(k1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED4827CB" , vptestmq(k1, zmm2, zmm3)); + TEST_INSTRUCTION("62F2ED48274C2B02" , vptestmq(k1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED48274C2B02" , vptestmq(k1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED0826CB" , vptestmw(k1, xmm2, xmm3)); + TEST_INSTRUCTION("62F2ED08264C2B08" , vptestmw(k1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED08264C2B08" , vptestmw(k1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED2826CB" , vptestmw(k1, ymm2, ymm3)); + TEST_INSTRUCTION("62F2ED28264C2B04" , vptestmw(k1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED28264C2B04" , vptestmw(k1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED4826CB" , vptestmw(k1, zmm2, zmm3)); + TEST_INSTRUCTION("62F2ED48264C2B02" , vptestmw(k1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED48264C2B02" , vptestmw(k1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26E0826CB" , vptestnmb(k1, xmm2, xmm3)); + TEST_INSTRUCTION("62F26E08264C2B08" , vptestnmb(k1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26E08264C2B08" , vptestnmb(k1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26E2826CB" , vptestnmb(k1, ymm2, ymm3)); + TEST_INSTRUCTION("62F26E28264C2B04" , vptestnmb(k1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26E28264C2B04" , vptestnmb(k1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26E4826CB" , vptestnmb(k1, zmm2, zmm3)); + TEST_INSTRUCTION("62F26E48264C2B02" , vptestnmb(k1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26E48264C2B02" , vptestnmb(k1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26E0827CB" , vptestnmd(k1, xmm2, xmm3)); + TEST_INSTRUCTION("62F26E08274C2B08" , vptestnmd(k1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26E08274C2B08" , vptestnmd(k1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26E2827CB" , vptestnmd(k1, ymm2, ymm3)); + TEST_INSTRUCTION("62F26E28274C2B04" , vptestnmd(k1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26E28274C2B04" , vptestnmd(k1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26E4827CB" , vptestnmd(k1, zmm2, zmm3)); + TEST_INSTRUCTION("62F26E48274C2B02" , vptestnmd(k1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26E48274C2B02" , vptestnmd(k1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2EE0827CB" , vptestnmq(k1, xmm2, xmm3)); + TEST_INSTRUCTION("62F2EE08274C2B08" , vptestnmq(k1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2EE08274C2B08" , vptestnmq(k1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2EE2827CB" , vptestnmq(k1, ymm2, ymm3)); + TEST_INSTRUCTION("62F2EE28274C2B04" , vptestnmq(k1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2EE28274C2B04" , vptestnmq(k1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2EE4827CB" , vptestnmq(k1, zmm2, zmm3)); + TEST_INSTRUCTION("62F2EE48274C2B02" , vptestnmq(k1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2EE48274C2B02" , vptestnmq(k1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2EE0826CB" , vptestnmw(k1, xmm2, xmm3)); + TEST_INSTRUCTION("62F2EE08264C2B08" , vptestnmw(k1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2EE08264C2B08" , vptestnmw(k1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2EE2826CB" , vptestnmw(k1, ymm2, ymm3)); + TEST_INSTRUCTION("62F2EE28264C2B04" , vptestnmw(k1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2EE28264C2B04" , vptestnmw(k1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2EE4826CB" , vptestnmw(k1, zmm2, zmm3)); + TEST_INSTRUCTION("62F2EE48264C2B02" , vptestnmw(k1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2EE48264C2B02" , vptestnmw(k1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5E968CB" , vpunpckhbw(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5E9688C2B80000000" , vpunpckhbw(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5E9688C2B80000000" , vpunpckhbw(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5ED68CB" , vpunpckhbw(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C5ED688C2B80000000" , vpunpckhbw(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5ED688C2B80000000" , vpunpckhbw(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16D4868CB" , vpunpckhbw(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F16D48684C2B02" , vpunpckhbw(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16D48684C2B02" , vpunpckhbw(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5E96ACB" , vpunpckhdq(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5E96A8C2B80000000" , vpunpckhdq(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5E96A8C2B80000000" , vpunpckhdq(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5ED6ACB" , vpunpckhdq(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C5ED6A8C2B80000000" , vpunpckhdq(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5ED6A8C2B80000000" , vpunpckhdq(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16D486ACB" , vpunpckhdq(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F16D486A4C2B02" , vpunpckhdq(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16D486A4C2B02" , vpunpckhdq(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5E96DCB" , vpunpckhqdq(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5E96D8C2B80000000" , vpunpckhqdq(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5E96D8C2B80000000" , vpunpckhqdq(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5ED6DCB" , vpunpckhqdq(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C5ED6D8C2B80000000" , vpunpckhqdq(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5ED6D8C2B80000000" , vpunpckhqdq(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F1ED486DCB" , vpunpckhqdq(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F1ED486D4C2B02" , vpunpckhqdq(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F1ED486D4C2B02" , vpunpckhqdq(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5E969CB" , vpunpckhwd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5E9698C2B80000000" , vpunpckhwd(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5E9698C2B80000000" , vpunpckhwd(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5ED69CB" , vpunpckhwd(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C5ED698C2B80000000" , vpunpckhwd(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5ED698C2B80000000" , vpunpckhwd(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16D4869CB" , vpunpckhwd(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F16D48694C2B02" , vpunpckhwd(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16D48694C2B02" , vpunpckhwd(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5E960CB" , vpunpcklbw(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5E9608C2B80000000" , vpunpcklbw(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5E9608C2B80000000" , vpunpcklbw(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5ED60CB" , vpunpcklbw(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C5ED608C2B80000000" , vpunpcklbw(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5ED608C2B80000000" , vpunpcklbw(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16D4860CB" , vpunpcklbw(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F16D48604C2B02" , vpunpcklbw(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16D48604C2B02" , vpunpcklbw(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5E962CB" , vpunpckldq(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5E9628C2B80000000" , vpunpckldq(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5E9628C2B80000000" , vpunpckldq(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5ED62CB" , vpunpckldq(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C5ED628C2B80000000" , vpunpckldq(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5ED628C2B80000000" , vpunpckldq(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16D4862CB" , vpunpckldq(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F16D48624C2B02" , vpunpckldq(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16D48624C2B02" , vpunpckldq(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5E96CCB" , vpunpcklqdq(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5E96C8C2B80000000" , vpunpcklqdq(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5E96C8C2B80000000" , vpunpcklqdq(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5ED6CCB" , vpunpcklqdq(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C5ED6C8C2B80000000" , vpunpcklqdq(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5ED6C8C2B80000000" , vpunpcklqdq(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F1ED486CCB" , vpunpcklqdq(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F1ED486C4C2B02" , vpunpcklqdq(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F1ED486C4C2B02" , vpunpcklqdq(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5E961CB" , vpunpcklwd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5E9618C2B80000000" , vpunpcklwd(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5E9618C2B80000000" , vpunpcklwd(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5ED61CB" , vpunpcklwd(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C5ED618C2B80000000" , vpunpcklwd(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5ED618C2B80000000" , vpunpcklwd(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16D4861CB" , vpunpcklwd(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F16D48614C2B02" , vpunpcklwd(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16D48614C2B02" , vpunpcklwd(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5E9EFCB" , vpxor(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5E9EF8C2B80000000" , vpxor(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5E9EF8C2B80000000" , vpxor(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5EDEFCB" , vpxor(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C5EDEF8C2B80000000" , vpxor(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5EDEF8C2B80000000" , vpxor(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16D08EFCB" , vpxord(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("62F16D08EF4C2B08" , vpxord(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16D08EF4C2B08" , vpxord(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16D28EFCB" , vpxord(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("62F16D28EF4C2B04" , vpxord(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16D28EF4C2B04" , vpxord(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16D48EFCB" , vpxord(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F16D48EF4C2B02" , vpxord(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16D48EF4C2B02" , vpxord(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F1ED08EFCB" , vpxorq(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("62F1ED08EF4C2B08" , vpxorq(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F1ED08EF4C2B08" , vpxorq(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F1ED28EFCB" , vpxorq(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("62F1ED28EF4C2B04" , vpxorq(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F1ED28EF4C2B04" , vpxorq(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F1ED48EFCB" , vpxorq(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F1ED48EF4C2B02" , vpxorq(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F1ED48EF4C2B02" , vpxorq(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F3ED0850CB01" , vrangepd(xmm1, xmm2, xmm3, 1)); + TEST_INSTRUCTION("62F3ED08504C2B0801" , vrangepd(xmm1, xmm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED08504C2B0801" , vrangepd(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED2850CB01" , vrangepd(ymm1, ymm2, ymm3, 1)); + TEST_INSTRUCTION("62F3ED28504C2B0401" , vrangepd(ymm1, ymm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED28504C2B0401" , vrangepd(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED4850CB01" , vrangepd(zmm1, zmm2, zmm3, 1)); + TEST_INSTRUCTION("62F3ED48504C2B0201" , vrangepd(zmm1, zmm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED48504C2B0201" , vrangepd(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D0850CB01" , vrangeps(xmm1, xmm2, xmm3, 1)); + TEST_INSTRUCTION("62F36D08504C2B0801" , vrangeps(xmm1, xmm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D08504C2B0801" , vrangeps(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D2850CB01" , vrangeps(ymm1, ymm2, ymm3, 1)); + TEST_INSTRUCTION("62F36D28504C2B0401" , vrangeps(ymm1, ymm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D28504C2B0401" , vrangeps(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D4850CB01" , vrangeps(zmm1, zmm2, zmm3, 1)); + TEST_INSTRUCTION("62F36D48504C2B0201" , vrangeps(zmm1, zmm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D48504C2B0201" , vrangeps(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED0851CB01" , vrangesd(xmm1, xmm2, xmm3, 1)); + TEST_INSTRUCTION("62F3ED08514C2B1001" , vrangesd(xmm1, xmm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED08514C2B1001" , vrangesd(xmm1, xmm2, qword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D0851CB01" , vrangess(xmm1, xmm2, xmm3, 1)); + TEST_INSTRUCTION("62F36D08514C2B2001" , vrangess(xmm1, xmm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D08514C2B2001" , vrangess(xmm1, xmm2, dword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F2FD084CCA" , vrcp14pd(xmm1, xmm2)); + TEST_INSTRUCTION("62F2FD084C4C1A08" , vrcp14pd(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F2FD084C4C1A08" , vrcp14pd(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F2FD284CCA" , vrcp14pd(ymm1, ymm2)); + TEST_INSTRUCTION("62F2FD284C4C1A04" , vrcp14pd(ymm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F2FD284C4C1A04" , vrcp14pd(ymm1, ymmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F2FD484CCA" , vrcp14pd(zmm1, zmm2)); + TEST_INSTRUCTION("62F2FD484C4C1A02" , vrcp14pd(zmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F2FD484C4C1A02" , vrcp14pd(zmm1, zmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F27D084CCA" , vrcp14ps(xmm1, xmm2)); + TEST_INSTRUCTION("62F27D084C4C1A08" , vrcp14ps(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F27D084C4C1A08" , vrcp14ps(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F27D284CCA" , vrcp14ps(ymm1, ymm2)); + TEST_INSTRUCTION("62F27D284C4C1A04" , vrcp14ps(ymm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F27D284C4C1A04" , vrcp14ps(ymm1, ymmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F27D484CCA" , vrcp14ps(zmm1, zmm2)); + TEST_INSTRUCTION("62F27D484C4C1A02" , vrcp14ps(zmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F27D484C4C1A02" , vrcp14ps(zmm1, zmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F2ED084DCB" , vrcp14sd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("62F2ED084D4C2B10" , vrcp14sd(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED084D4C2B10" , vrcp14sd(xmm1, xmm2, qword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D084DCB" , vrcp14ss(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("62F26D084D4C2B20" , vrcp14ss(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D084D4C2B20" , vrcp14ss(xmm1, xmm2, dword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2FD48CACA" , vrcp28pd(zmm1, zmm2)); + TEST_INSTRUCTION("62F2FD48CA4C1A02" , vrcp28pd(zmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F2FD48CA4C1A02" , vrcp28pd(zmm1, zmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F27D48CACA" , vrcp28ps(zmm1, zmm2)); + TEST_INSTRUCTION("62F27D48CA4C1A02" , vrcp28ps(zmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F27D48CA4C1A02" , vrcp28ps(zmm1, zmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F2ED08CBCB" , vrcp28sd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("62F2ED08CB4C2B10" , vrcp28sd(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED08CB4C2B10" , vrcp28sd(xmm1, xmm2, qword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D08CBCB" , vrcp28ss(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("62F26D08CB4C2B20" , vrcp28ss(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D08CB4C2B20" , vrcp28ss(xmm1, xmm2, dword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5F853CA" , vrcpps(xmm1, xmm2)); + TEST_INSTRUCTION("C5F8538C1A80000000" , vrcpps(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C5F8538C1A80000000" , vrcpps(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C5FC53CA" , vrcpps(ymm1, ymm2)); + TEST_INSTRUCTION("C5FC538C1A80000000" , vrcpps(ymm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C5FC538C1A80000000" , vrcpps(ymm1, ymmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C5EA53CB" , vrcpss(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5EA538C2B80000000" , vrcpss(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5EA538C2B80000000" , vrcpss(xmm1, xmm2, dword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F3FD0856CA01" , vreducepd(xmm1, xmm2, 1)); + TEST_INSTRUCTION("62F3FD08564C1A0801" , vreducepd(xmm1, ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("62F3FD08564C1A0801" , vreducepd(xmm1, xmmword_ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("62F3FD2856CA01" , vreducepd(ymm1, ymm2, 1)); + TEST_INSTRUCTION("62F3FD28564C1A0401" , vreducepd(ymm1, ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("62F3FD28564C1A0401" , vreducepd(ymm1, ymmword_ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("62F3FD4856CA01" , vreducepd(zmm1, zmm2, 1)); + TEST_INSTRUCTION("62F3FD48564C1A0201" , vreducepd(zmm1, ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("62F3FD48564C1A0201" , vreducepd(zmm1, zmmword_ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("62F37D0856CA01" , vreduceps(xmm1, xmm2, 1)); + TEST_INSTRUCTION("62F37D08564C1A0801" , vreduceps(xmm1, ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("62F37D08564C1A0801" , vreduceps(xmm1, xmmword_ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("62F37D2856CA01" , vreduceps(ymm1, ymm2, 1)); + TEST_INSTRUCTION("62F37D28564C1A0401" , vreduceps(ymm1, ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("62F37D28564C1A0401" , vreduceps(ymm1, ymmword_ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("62F37D4856CA01" , vreduceps(zmm1, zmm2, 1)); + TEST_INSTRUCTION("62F37D48564C1A0201" , vreduceps(zmm1, ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("62F37D48564C1A0201" , vreduceps(zmm1, zmmword_ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED0857CB01" , vreducesd(xmm1, xmm2, xmm3, 1)); + TEST_INSTRUCTION("62F3ED08574C2B1001" , vreducesd(xmm1, xmm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED08574C2B1001" , vreducesd(xmm1, xmm2, qword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D0857CB01" , vreducess(xmm1, xmm2, xmm3, 1)); + TEST_INSTRUCTION("62F36D08574C2B2001" , vreducess(xmm1, xmm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D08574C2B2001" , vreducess(xmm1, xmm2, dword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F3FD0809CA01" , vrndscalepd(xmm1, xmm2, 1)); + TEST_INSTRUCTION("62F3FD08094C1A0801" , vrndscalepd(xmm1, ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("62F3FD08094C1A0801" , vrndscalepd(xmm1, xmmword_ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("62F3FD2809CA01" , vrndscalepd(ymm1, ymm2, 1)); + TEST_INSTRUCTION("62F3FD28094C1A0401" , vrndscalepd(ymm1, ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("62F3FD28094C1A0401" , vrndscalepd(ymm1, ymmword_ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("62F3FD4809CA01" , vrndscalepd(zmm1, zmm2, 1)); + TEST_INSTRUCTION("62F3FD48094C1A0201" , vrndscalepd(zmm1, ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("62F3FD48094C1A0201" , vrndscalepd(zmm1, zmmword_ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("62F37D0808CA01" , vrndscaleps(xmm1, xmm2, 1)); + TEST_INSTRUCTION("62F37D08084C1A0801" , vrndscaleps(xmm1, ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("62F37D08084C1A0801" , vrndscaleps(xmm1, xmmword_ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("62F37D2808CA01" , vrndscaleps(ymm1, ymm2, 1)); + TEST_INSTRUCTION("62F37D28084C1A0401" , vrndscaleps(ymm1, ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("62F37D28084C1A0401" , vrndscaleps(ymm1, ymmword_ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("62F37D4808CA01" , vrndscaleps(zmm1, zmm2, 1)); + TEST_INSTRUCTION("62F37D48084C1A0201" , vrndscaleps(zmm1, ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("62F37D48084C1A0201" , vrndscaleps(zmm1, zmmword_ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED080BCB01" , vrndscalesd(xmm1, xmm2, xmm3, 1)); + TEST_INSTRUCTION("62F3ED080B4C2B1001" , vrndscalesd(xmm1, xmm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED080B4C2B1001" , vrndscalesd(xmm1, xmm2, qword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D080ACB01" , vrndscaless(xmm1, xmm2, xmm3, 1)); + TEST_INSTRUCTION("62F36D080A4C2B2001" , vrndscaless(xmm1, xmm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D080A4C2B2001" , vrndscaless(xmm1, xmm2, dword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("C4E37909CA01" , vroundpd(xmm1, xmm2, 1)); + TEST_INSTRUCTION("C4E379098C1A8000000001" , vroundpd(xmm1, ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("C4E379098C1A8000000001" , vroundpd(xmm1, xmmword_ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("C4E37D09CA01" , vroundpd(ymm1, ymm2, 1)); + TEST_INSTRUCTION("C4E37D098C1A8000000001" , vroundpd(ymm1, ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("C4E37D098C1A8000000001" , vroundpd(ymm1, ymmword_ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("C4E37908CA01" , vroundps(xmm1, xmm2, 1)); + TEST_INSTRUCTION("C4E379088C1A8000000001" , vroundps(xmm1, ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("C4E379088C1A8000000001" , vroundps(xmm1, xmmword_ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("C4E37D08CA01" , vroundps(ymm1, ymm2, 1)); + TEST_INSTRUCTION("C4E37D088C1A8000000001" , vroundps(ymm1, ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("C4E37D088C1A8000000001" , vroundps(ymm1, ymmword_ptr(rdx, rbx, 0, 128), 1)); + TEST_INSTRUCTION("C4E3690BCB01" , vroundsd(xmm1, xmm2, xmm3, 1)); + TEST_INSTRUCTION("C4E3690B8C2B8000000001" , vroundsd(xmm1, xmm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("C4E3690B8C2B8000000001" , vroundsd(xmm1, xmm2, qword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("C4E3690ACB01" , vroundss(xmm1, xmm2, xmm3, 1)); + TEST_INSTRUCTION("C4E3690A8C2B8000000001" , vroundss(xmm1, xmm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("C4E3690A8C2B8000000001" , vroundss(xmm1, xmm2, dword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F2FD084ECA" , vrsqrt14pd(xmm1, xmm2)); + TEST_INSTRUCTION("62F2FD084E4C1A08" , vrsqrt14pd(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F2FD084E4C1A08" , vrsqrt14pd(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F2FD284ECA" , vrsqrt14pd(ymm1, ymm2)); + TEST_INSTRUCTION("62F2FD284E4C1A04" , vrsqrt14pd(ymm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F2FD284E4C1A04" , vrsqrt14pd(ymm1, ymmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F2FD484ECA" , vrsqrt14pd(zmm1, zmm2)); + TEST_INSTRUCTION("62F2FD484E4C1A02" , vrsqrt14pd(zmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F2FD484E4C1A02" , vrsqrt14pd(zmm1, zmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F27D084ECA" , vrsqrt14ps(xmm1, xmm2)); + TEST_INSTRUCTION("62F27D084E4C1A08" , vrsqrt14ps(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F27D084E4C1A08" , vrsqrt14ps(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F27D284ECA" , vrsqrt14ps(ymm1, ymm2)); + TEST_INSTRUCTION("62F27D284E4C1A04" , vrsqrt14ps(ymm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F27D284E4C1A04" , vrsqrt14ps(ymm1, ymmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F27D484ECA" , vrsqrt14ps(zmm1, zmm2)); + TEST_INSTRUCTION("62F27D484E4C1A02" , vrsqrt14ps(zmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F27D484E4C1A02" , vrsqrt14ps(zmm1, zmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F2ED084FCB" , vrsqrt14sd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("62F2ED084F4C2B10" , vrsqrt14sd(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED084F4C2B10" , vrsqrt14sd(xmm1, xmm2, qword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D084FCB" , vrsqrt14ss(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("62F26D084F4C2B20" , vrsqrt14ss(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D084F4C2B20" , vrsqrt14ss(xmm1, xmm2, dword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2FD48CCCA" , vrsqrt28pd(zmm1, zmm2)); + TEST_INSTRUCTION("62F2FD48CC4C1A02" , vrsqrt28pd(zmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F2FD48CC4C1A02" , vrsqrt28pd(zmm1, zmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F27D48CCCA" , vrsqrt28ps(zmm1, zmm2)); + TEST_INSTRUCTION("62F27D48CC4C1A02" , vrsqrt28ps(zmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F27D48CC4C1A02" , vrsqrt28ps(zmm1, zmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F2ED08CDCB" , vrsqrt28sd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("62F2ED08CD4C2B10" , vrsqrt28sd(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED08CD4C2B10" , vrsqrt28sd(xmm1, xmm2, qword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D08CDCB" , vrsqrt28ss(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("62F26D08CD4C2B20" , vrsqrt28ss(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D08CD4C2B20" , vrsqrt28ss(xmm1, xmm2, dword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5F852CA" , vrsqrtps(xmm1, xmm2)); + TEST_INSTRUCTION("C5F8528C1A80000000" , vrsqrtps(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C5F8528C1A80000000" , vrsqrtps(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C5FC52CA" , vrsqrtps(ymm1, ymm2)); + TEST_INSTRUCTION("C5FC528C1A80000000" , vrsqrtps(ymm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C5FC528C1A80000000" , vrsqrtps(ymm1, ymmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C5EA52CB" , vrsqrtss(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5EA528C2B80000000" , vrsqrtss(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5EA528C2B80000000" , vrsqrtss(xmm1, xmm2, dword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED082CCB" , vscalefpd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("62F2ED082C4C2B08" , vscalefpd(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED082C4C2B08" , vscalefpd(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED282CCB" , vscalefpd(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("62F2ED282C4C2B04" , vscalefpd(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED282C4C2B04" , vscalefpd(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED482CCB" , vscalefpd(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F2ED482C4C2B02" , vscalefpd(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED482C4C2B02" , vscalefpd(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D082CCB" , vscalefps(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("62F26D082C4C2B08" , vscalefps(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D082C4C2B08" , vscalefps(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D282CCB" , vscalefps(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("62F26D282C4C2B04" , vscalefps(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D282C4C2B04" , vscalefps(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D482CCB" , vscalefps(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F26D482C4C2B02" , vscalefps(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D482C4C2B02" , vscalefps(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED082DCB" , vscalefsd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("62F2ED082D4C2B10" , vscalefsd(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2ED082D4C2B10" , vscalefsd(xmm1, xmm2, qword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D082DCB" , vscalefss(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("62F26D082D4C2B20" , vscalefss(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F26D082D4C2B20" , vscalefss(xmm1, xmm2, dword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F2FD09A25C1110" , k(k1).vscatterdpd(ptr(rcx, xmm2, 0, 128), xmm3)); + TEST_INSTRUCTION("62F2FD29A25C1110" , k(k1).vscatterdpd(ptr(rcx, xmm2, 0, 128), ymm3)); + TEST_INSTRUCTION("62F2FD49A25C1110" , k(k1).vscatterdpd(ptr(rcx, ymm2, 0, 128), zmm3)); + TEST_INSTRUCTION("62F27D09A25C1120" , k(k1).vscatterdps(ptr(rcx, xmm2, 0, 128), xmm3)); + TEST_INSTRUCTION("62F27D29A25C1120" , k(k1).vscatterdps(ptr(rcx, ymm2, 0, 128), ymm3)); + TEST_INSTRUCTION("62F27D49A25C1120" , k(k1).vscatterdps(ptr(rcx, zmm2, 0, 128), zmm3)); + TEST_INSTRUCTION("62F2FD49C66C1110" , k(k1).vscatterpf0dpd(ptr(rcx, ymm2, 0, 128))); + TEST_INSTRUCTION("62F27D49C66C1120" , k(k1).vscatterpf0dps(ptr(rcx, zmm2, 0, 128))); + TEST_INSTRUCTION("62F2FD49C76C1110" , k(k1).vscatterpf0qpd(ptr(rcx, zmm2, 0, 128))); + TEST_INSTRUCTION("62F27D49C76C1120" , k(k1).vscatterpf0qps(ptr(rcx, zmm2, 0, 128))); + TEST_INSTRUCTION("62F2FD49C6741110" , k(k1).vscatterpf1dpd(ptr(rcx, ymm2, 0, 128))); + TEST_INSTRUCTION("62F27D49C6741120" , k(k1).vscatterpf1dps(ptr(rcx, zmm2, 0, 128))); + TEST_INSTRUCTION("62F2FD49C7741110" , k(k1).vscatterpf1qpd(ptr(rcx, zmm2, 0, 128))); + TEST_INSTRUCTION("62F27D49C7741120" , k(k1).vscatterpf1qps(ptr(rcx, zmm2, 0, 128))); + TEST_INSTRUCTION("62F2FD09A35C1110" , k(k1).vscatterqpd(ptr(rcx, xmm2, 0, 128), xmm3)); + TEST_INSTRUCTION("62F2FD29A35C1110" , k(k1).vscatterqpd(ptr(rcx, ymm2, 0, 128), ymm3)); + TEST_INSTRUCTION("62F2FD49A35C1110" , k(k1).vscatterqpd(ptr(rcx, zmm2, 0, 128), zmm3)); + TEST_INSTRUCTION("62F27D09A35C1120" , k(k1).vscatterqps(ptr(rcx, xmm2, 0, 128), xmm3)); + TEST_INSTRUCTION("62F27D29A35C1120" , k(k1).vscatterqps(ptr(rcx, ymm2, 0, 128), xmm3)); + TEST_INSTRUCTION("62F27D49A35C1120" , k(k1).vscatterqps(ptr(rcx, zmm2, 0, 128), ymm3)); + TEST_INSTRUCTION("62F36D2823CB01" , vshuff32x4(ymm1, ymm2, ymm3, 1)); + TEST_INSTRUCTION("62F36D28234C2B0401" , vshuff32x4(ymm1, ymm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D28234C2B0401" , vshuff32x4(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D4823CB01" , vshuff32x4(zmm1, zmm2, zmm3, 1)); + TEST_INSTRUCTION("62F36D48234C2B0201" , vshuff32x4(zmm1, zmm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D48234C2B0201" , vshuff32x4(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED2823CB01" , vshuff64x2(ymm1, ymm2, ymm3, 1)); + TEST_INSTRUCTION("62F3ED28234C2B0401" , vshuff64x2(ymm1, ymm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED28234C2B0401" , vshuff64x2(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED4823CB01" , vshuff64x2(zmm1, zmm2, zmm3, 1)); + TEST_INSTRUCTION("62F3ED48234C2B0201" , vshuff64x2(zmm1, zmm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED48234C2B0201" , vshuff64x2(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D2843CB01" , vshufi32x4(ymm1, ymm2, ymm3, 1)); + TEST_INSTRUCTION("62F36D28434C2B0401" , vshufi32x4(ymm1, ymm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D28434C2B0401" , vshufi32x4(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D4843CB01" , vshufi32x4(zmm1, zmm2, zmm3, 1)); + TEST_INSTRUCTION("62F36D48434C2B0201" , vshufi32x4(zmm1, zmm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D48434C2B0201" , vshufi32x4(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED2843CB01" , vshufi64x2(ymm1, ymm2, ymm3, 1)); + TEST_INSTRUCTION("62F3ED28434C2B0401" , vshufi64x2(ymm1, ymm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED28434C2B0401" , vshufi64x2(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED4843CB01" , vshufi64x2(zmm1, zmm2, zmm3, 1)); + TEST_INSTRUCTION("62F3ED48434C2B0201" , vshufi64x2(zmm1, zmm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED48434C2B0201" , vshufi64x2(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("C5E9C6CB01" , vshufpd(xmm1, xmm2, xmm3, 1)); + TEST_INSTRUCTION("C5E9C68C2B8000000001" , vshufpd(xmm1, xmm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("C5E9C68C2B8000000001" , vshufpd(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("C5EDC6CB01" , vshufpd(ymm1, ymm2, ymm3, 1)); + TEST_INSTRUCTION("C5EDC68C2B8000000001" , vshufpd(ymm1, ymm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("C5EDC68C2B8000000001" , vshufpd(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F1ED48C6CB01" , vshufpd(zmm1, zmm2, zmm3, 1)); + TEST_INSTRUCTION("62F1ED48C64C2B0201" , vshufpd(zmm1, zmm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F1ED48C64C2B0201" , vshufpd(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("C5E8C6CB01" , vshufps(xmm1, xmm2, xmm3, 1)); + TEST_INSTRUCTION("C5E8C68C2B8000000001" , vshufps(xmm1, xmm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("C5E8C68C2B8000000001" , vshufps(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("C5ECC6CB01" , vshufps(ymm1, ymm2, ymm3, 1)); + TEST_INSTRUCTION("C5ECC68C2B8000000001" , vshufps(ymm1, ymm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("C5ECC68C2B8000000001" , vshufps(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F16C48C6CB01" , vshufps(zmm1, zmm2, zmm3, 1)); + TEST_INSTRUCTION("62F16C48C64C2B0201" , vshufps(zmm1, zmm2, ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("62F16C48C64C2B0201" , vshufps(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128), 1)); + TEST_INSTRUCTION("C5F951CA" , vsqrtpd(xmm1, xmm2)); + TEST_INSTRUCTION("C5F9518C1A80000000" , vsqrtpd(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C5F9518C1A80000000" , vsqrtpd(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C5FD51CA" , vsqrtpd(ymm1, ymm2)); + TEST_INSTRUCTION("C5FD518C1A80000000" , vsqrtpd(ymm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C5FD518C1A80000000" , vsqrtpd(ymm1, ymmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F1FD4851CA" , vsqrtpd(zmm1, zmm2)); + TEST_INSTRUCTION("62F1FD48514C1A02" , vsqrtpd(zmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F1FD48514C1A02" , vsqrtpd(zmm1, zmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C5F851CA" , vsqrtps(xmm1, xmm2)); + TEST_INSTRUCTION("C5F8518C1A80000000" , vsqrtps(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C5F8518C1A80000000" , vsqrtps(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C5FC51CA" , vsqrtps(ymm1, ymm2)); + TEST_INSTRUCTION("C5FC518C1A80000000" , vsqrtps(ymm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C5FC518C1A80000000" , vsqrtps(ymm1, ymmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F17C4851CA" , vsqrtps(zmm1, zmm2)); + TEST_INSTRUCTION("62F17C48514C1A02" , vsqrtps(zmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("62F17C48514C1A02" , vsqrtps(zmm1, zmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C5EB51CB" , vsqrtsd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5EB518C2B80000000" , vsqrtsd(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5EB518C2B80000000" , vsqrtsd(xmm1, xmm2, qword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5EA51CB" , vsqrtss(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5EA518C2B80000000" , vsqrtss(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5EA518C2B80000000" , vsqrtss(xmm1, xmm2, dword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5F8AE9C1180000000" , vstmxcsr(ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("C5F8AE9C1180000000" , vstmxcsr(dword_ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("C5E95CCB" , vsubpd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5E95C8C2B80000000" , vsubpd(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5E95C8C2B80000000" , vsubpd(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5ED5CCB" , vsubpd(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C5ED5C8C2B80000000" , vsubpd(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5ED5C8C2B80000000" , vsubpd(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F1ED485CCB" , vsubpd(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F1ED485C4C2B02" , vsubpd(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F1ED485C4C2B02" , vsubpd(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5E85CCB" , vsubps(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5E85C8C2B80000000" , vsubps(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5E85C8C2B80000000" , vsubps(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5EC5CCB" , vsubps(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C5EC5C8C2B80000000" , vsubps(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5EC5C8C2B80000000" , vsubps(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16C485CCB" , vsubps(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F16C485C4C2B02" , vsubps(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16C485C4C2B02" , vsubps(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5EB5CCB" , vsubsd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5EB5C8C2B80000000" , vsubsd(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5EB5C8C2B80000000" , vsubsd(xmm1, xmm2, qword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5EA5CCB" , vsubss(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5EA5C8C2B80000000" , vsubss(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5EA5C8C2B80000000" , vsubss(xmm1, xmm2, dword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C4E2790FCA" , vtestpd(xmm1, xmm2)); + TEST_INSTRUCTION("C4E2790F8C1A80000000" , vtestpd(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C4E2790F8C1A80000000" , vtestpd(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C4E27D0FCA" , vtestpd(ymm1, ymm2)); + TEST_INSTRUCTION("C4E27D0F8C1A80000000" , vtestpd(ymm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C4E27D0F8C1A80000000" , vtestpd(ymm1, ymmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C4E2790ECA" , vtestps(xmm1, xmm2)); + TEST_INSTRUCTION("C4E2790E8C1A80000000" , vtestps(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C4E2790E8C1A80000000" , vtestps(xmm1, xmmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C4E27D0ECA" , vtestps(ymm1, ymm2)); + TEST_INSTRUCTION("C4E27D0E8C1A80000000" , vtestps(ymm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C4E27D0E8C1A80000000" , vtestps(ymm1, ymmword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C5F92ECA" , vucomisd(xmm1, xmm2)); + TEST_INSTRUCTION("C5F92E8C1A80000000" , vucomisd(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C5F92E8C1A80000000" , vucomisd(xmm1, qword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C5F82ECA" , vucomiss(xmm1, xmm2)); + TEST_INSTRUCTION("C5F82E8C1A80000000" , vucomiss(xmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C5F82E8C1A80000000" , vucomiss(xmm1, dword_ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C5E915CB" , vunpckhpd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5E9158C2B80000000" , vunpckhpd(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5E9158C2B80000000" , vunpckhpd(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5ED15CB" , vunpckhpd(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C5ED158C2B80000000" , vunpckhpd(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5ED158C2B80000000" , vunpckhpd(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F1ED4815CB" , vunpckhpd(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F1ED48154C2B02" , vunpckhpd(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F1ED48154C2B02" , vunpckhpd(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5E815CB" , vunpckhps(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5E8158C2B80000000" , vunpckhps(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5E8158C2B80000000" , vunpckhps(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5EC15CB" , vunpckhps(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C5EC158C2B80000000" , vunpckhps(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5EC158C2B80000000" , vunpckhps(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16C4815CB" , vunpckhps(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F16C48154C2B02" , vunpckhps(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16C48154C2B02" , vunpckhps(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5E914CB" , vunpcklpd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5E9148C2B80000000" , vunpcklpd(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5E9148C2B80000000" , vunpcklpd(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5ED14CB" , vunpcklpd(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C5ED148C2B80000000" , vunpcklpd(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5ED148C2B80000000" , vunpcklpd(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F1ED4814CB" , vunpcklpd(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F1ED48144C2B02" , vunpcklpd(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F1ED48144C2B02" , vunpcklpd(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5E814CB" , vunpcklps(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5E8148C2B80000000" , vunpcklps(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5E8148C2B80000000" , vunpcklps(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5EC14CB" , vunpcklps(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C5EC148C2B80000000" , vunpcklps(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5EC148C2B80000000" , vunpcklps(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16C4814CB" , vunpcklps(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F16C48144C2B02" , vunpcklps(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16C48144C2B02" , vunpcklps(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5E957CB" , vxorpd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5E9578C2B80000000" , vxorpd(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5E9578C2B80000000" , vxorpd(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5ED57CB" , vxorpd(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C5ED578C2B80000000" , vxorpd(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5ED578C2B80000000" , vxorpd(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F1ED4857CB" , vxorpd(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F1ED48574C2B02" , vxorpd(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F1ED48574C2B02" , vxorpd(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5E857CB" , vxorps(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5E8578C2B80000000" , vxorps(xmm1, xmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5E8578C2B80000000" , vxorps(xmm1, xmm2, xmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5EC57CB" , vxorps(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C5EC578C2B80000000" , vxorps(ymm1, ymm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5EC578C2B80000000" , vxorps(ymm1, ymm2, ymmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16C4857CB" , vxorps(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F16C48574C2B02" , vxorps(zmm1, zmm2, ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("62F16C48574C2B02" , vxorps(zmm1, zmm2, zmmword_ptr(rbx, rbp, 0, 128))); + TEST_INSTRUCTION("C5FC77" , vzeroall()); + TEST_INSTRUCTION("C5F877" , vzeroupper()); +} + +static void ASMJIT_NOINLINE testX64AssemblerAVX512_FP16(AssemblerTester<x86::Assembler>& tester) noexcept { + using namespace x86; + + TEST_INSTRUCTION("62F5560810F4" , vmovsh(xmm6, xmm5, xmm4)); + TEST_INSTRUCTION("62F57E0F10B4F400000010" , k(k7).vmovsh(xmm6, word_ptr(rsp, rsi, 3, 268435456))); + TEST_INSTRUCTION("62F57E081031" , vmovsh(xmm6, word_ptr(rcx))); + TEST_INSTRUCTION("62F57E0810717F" , vmovsh(xmm6, word_ptr(rcx, 254))); + TEST_INSTRUCTION("62F57E8F107280" , k(k7).z().vmovsh(xmm6, word_ptr(rdx, -256))); + TEST_INSTRUCTION("62F57E0F11B4F400000010" , k(k7).vmovsh(word_ptr(rsp, rsi, 3, 268435456), xmm6)); + TEST_INSTRUCTION("62F57E081131" , vmovsh(word_ptr(rcx), xmm6)); + TEST_INSTRUCTION("62F57E0811717F" , vmovsh(word_ptr(rcx, 254), xmm6)); + TEST_INSTRUCTION("62F57E0F117280" , k(k7).vmovsh(word_ptr(rdx, -256), xmm6)); + TEST_INSTRUCTION("62F57D086EF2" , vmovw(xmm6, edx)); + TEST_INSTRUCTION("62F57D087EF2" , vmovw(edx, xmm6)); + TEST_INSTRUCTION("62F57D086EB4F400000010" , vmovw(xmm6, word_ptr(rsp, rsi, 3, 268435456))); + TEST_INSTRUCTION("62F57D086E31" , vmovw(xmm6, word_ptr(rcx))); + TEST_INSTRUCTION("62F57D086E717F" , vmovw(xmm6, word_ptr(rcx, 254))); + TEST_INSTRUCTION("62F57D086E717F" , vmovw(xmm6, word_ptr(rcx, 254))); + TEST_INSTRUCTION("62F57D086E7280" , vmovw(xmm6, word_ptr(rdx, -256))); + TEST_INSTRUCTION("62F57D087EB4F400000010" , vmovw(word_ptr(rsp, esi, 3, 268435456), xmm6)); + TEST_INSTRUCTION("62F57D087E31" , vmovw(word_ptr(rcx), xmm6)); + TEST_INSTRUCTION("62F57D087E717F" , vmovw(word_ptr(rcx, 254), xmm6)); + TEST_INSTRUCTION("62F57D087E7280" , vmovw(word_ptr(rdx, -256), xmm6)); +} + +// Tests generated from 'llvm/test/MC/X86/intel-syntax-avx512.s' file. +static void ASMJIT_NOINLINE testX64AssemblerAVX512_LLVM(AssemblerTester<x86::Assembler>& tester) noexcept { + using namespace x86; + + TEST_INSTRUCTION("62F174485808" , vaddps(zmm1, zmm1, zmmword_ptr(rax))); + TEST_INSTRUCTION("62F1F54858CA" , vaddpd(zmm1, zmm1, zmm2)); + TEST_INSTRUCTION("62F1F54D58CA" , k(k5).vaddpd(zmm1, zmm1, zmm2)); + TEST_INSTRUCTION("62F1F5CD58CA" , k(k5).z().vaddpd(zmm1, zmm1, zmm2)); + TEST_INSTRUCTION("62F1F5CD58CA" , k(k5).z().vaddpd(zmm1, zmm1, zmm2)); + TEST_INSTRUCTION("62F1F51858CA" , rn_sae().vaddpd(zmm1, zmm1, zmm2)); + TEST_INSTRUCTION("62F1F55858CA" , ru_sae().vaddpd(zmm1, zmm1, zmm2)); + TEST_INSTRUCTION("62F1F53858CA" , rd_sae().vaddpd(zmm1, zmm1, zmm2)); + TEST_INSTRUCTION("62F1F57858CA" , rz_sae().vaddpd(zmm1, zmm1, zmm2)); + TEST_INSTRUCTION("62919D48C2D2AB" , vcmppd(k2, zmm12, zmm26, 171)); + TEST_INSTRUCTION("62919D4BC2D2AB" , k(k3).vcmppd(k2, zmm12, zmm26, 171)); + TEST_INSTRUCTION("62919D18C2D2AB" , sae().vcmppd(k2, zmm12, zmm26, 171)); + TEST_INSTRUCTION("62919D48C2D27B" , vcmppd(k2, zmm12, zmm26, 123)); + TEST_INSTRUCTION("62919D18C2D27B" , sae().vcmppd(k2, zmm12, zmm26, 123)); + TEST_INSTRUCTION("62F19D48C2117B" , vcmppd(k2, zmm12, zmmword_ptr(rcx), 123)); + TEST_INSTRUCTION("62B19D48C294F0230100007B" , vcmppd(k2, zmm12, zmmword_ptr(rax, r14, 3, 291), 123)); + TEST_INSTRUCTION("62F19D58C2117B" , vcmppd(k2, zmm12, qword_ptr(rcx)._1to8(), 123)); + TEST_INSTRUCTION("62F19D48C2527F7B" , vcmppd(k2, zmm12, zmmword_ptr(rdx, 8128), 123)); + TEST_INSTRUCTION("62F19D48C292002000007B" , vcmppd(k2, zmm12, zmmword_ptr(rdx, 8192), 123)); + TEST_INSTRUCTION("62F19D48C252807B" , vcmppd(k2, zmm12, zmmword_ptr(rdx, -8192), 123)); + TEST_INSTRUCTION("62F19D48C292C0DFFFFF7B" , vcmppd(k2, zmm12, zmmword_ptr(rdx, -8256), 123)); + TEST_INSTRUCTION("62F19D58C2527F7B" , vcmppd(k2, zmm12, qword_ptr(rdx, 1016)._1to8(), 123)); + TEST_INSTRUCTION("62F19D58C292000400007B" , vcmppd(k2, zmm12, qword_ptr(rdx, 1024)._1to8(), 123)); + TEST_INSTRUCTION("62F19D58C252807B" , vcmppd(k2, zmm12, qword_ptr(rdx, -1024)._1to8(), 123)); + TEST_INSTRUCTION("62F19D58C292F8FBFFFF7B" , vcmppd(k2, zmm12, qword_ptr(rdx, -1032)._1to8(), 123)); + TEST_INSTRUCTION("62B17440C2D6AB" , vcmpps(k2, zmm17, zmm22, 171)); + TEST_INSTRUCTION("62B17443C2D6AB" , k(k3).vcmpps(k2, zmm17, zmm22, 171)); + TEST_INSTRUCTION("62B17410C2D6AB" , sae().vcmpps(k2, zmm17, zmm22, 171)); + TEST_INSTRUCTION("62B17440C2D67B" , vcmpps(k2, zmm17, zmm22, 123)); + TEST_INSTRUCTION("62B17410C2D67B" , sae().vcmpps(k2, zmm17, zmm22, 123)); + TEST_INSTRUCTION("62F17440C2117B" , vcmpps(k2, zmm17, zmmword_ptr(rcx), 123)); + TEST_INSTRUCTION("62B17440C294F0230100007B" , vcmpps(k2, zmm17, zmmword_ptr(rax, r14, 3, 291), 123)); + TEST_INSTRUCTION("62F17450C2117B" , vcmpps(k2, zmm17, dword_ptr(rcx)._1to16(), 123)); + TEST_INSTRUCTION("62F17440C2527F7B" , vcmpps(k2, zmm17, zmmword_ptr(rdx, 8128), 123)); + TEST_INSTRUCTION("62F17440C292002000007B" , vcmpps(k2, zmm17, zmmword_ptr(rdx, 8192), 123)); + TEST_INSTRUCTION("62F17440C252807B" , vcmpps(k2, zmm17, zmmword_ptr(rdx, -8192), 123)); + TEST_INSTRUCTION("62F17440C292C0DFFFFF7B" , vcmpps(k2, zmm17, zmmword_ptr(rdx, -8256), 123)); + TEST_INSTRUCTION("62F17450C2527F7B" , vcmpps(k2, zmm17, dword_ptr(rdx, 508)._1to16(), 123)); + TEST_INSTRUCTION("62F17450C292000200007B" , vcmpps(k2, zmm17, dword_ptr(rdx, 512)._1to16(), 123)); + TEST_INSTRUCTION("62F17450C252807B" , vcmpps(k2, zmm17, dword_ptr(rdx, -512)._1to16(), 123)); + TEST_INSTRUCTION("62F17450C292FCFDFFFF7B" , vcmpps(k2, zmm17, dword_ptr(rdx, -516)._1to16(), 123)); + TEST_INSTRUCTION("62136D0055FCAB" , vfixupimmss(xmm15, xmm18, xmm28, 171)); + TEST_INSTRUCTION("62136D0555FCAB" , k(k5).vfixupimmss(xmm15, xmm18, xmm28, 171)); + TEST_INSTRUCTION("62136D8555FCAB" , k(k5).z().vfixupimmss(xmm15, xmm18, xmm28, 171)); + TEST_INSTRUCTION("62136D1055FCAB" , sae().vfixupimmss(xmm15, xmm18, xmm28, 171)); + TEST_INSTRUCTION("62136D0055FC7B" , vfixupimmss(xmm15, xmm18, xmm28, 123)); + TEST_INSTRUCTION("62136D1055FC7B" , sae().vfixupimmss(xmm15, xmm18, xmm28, 123)); + TEST_INSTRUCTION("62736D0055397B" , vfixupimmss(xmm15, xmm18, dword_ptr(rcx), 123)); + TEST_INSTRUCTION("62336D0055BCF0230100007B" , vfixupimmss(xmm15, xmm18, dword_ptr(rax, r14, 3, 291), 123)); + TEST_INSTRUCTION("62736D00557A7F7B" , vfixupimmss(xmm15, xmm18, dword_ptr(rdx, 508), 123)); + TEST_INSTRUCTION("62736D0055BA000200007B" , vfixupimmss(xmm15, xmm18, dword_ptr(rdx, 512), 123)); + TEST_INSTRUCTION("62736D00557A807B" , vfixupimmss(xmm15, xmm18, dword_ptr(rdx, -512), 123)); + TEST_INSTRUCTION("62736D0055BAFCFDFFFF7B" , vfixupimmss(xmm15, xmm18, dword_ptr(rdx, -516), 123)); + TEST_INSTRUCTION("6273AD0055EDAB" , vfixupimmsd(xmm13, xmm26, xmm5, 171)); + TEST_INSTRUCTION("6273AD0655EDAB" , k(k6).vfixupimmsd(xmm13, xmm26, xmm5, 171)); + TEST_INSTRUCTION("6273AD8655EDAB" , k(k6).z().vfixupimmsd(xmm13, xmm26, xmm5, 171)); + TEST_INSTRUCTION("6273AD1055EDAB" , sae().vfixupimmsd(xmm13, xmm26, xmm5, 171)); + TEST_INSTRUCTION("6273AD0055ED7B" , vfixupimmsd(xmm13, xmm26, xmm5, 123)); + TEST_INSTRUCTION("6273AD1055ED7B" , sae().vfixupimmsd(xmm13, xmm26, xmm5, 123)); + TEST_INSTRUCTION("6273AD0055297B" , vfixupimmsd(xmm13, xmm26, qword_ptr(rcx), 123)); + TEST_INSTRUCTION("6233AD0055ACF0230100007B" , vfixupimmsd(xmm13, xmm26, qword_ptr(rax, r14, 3, 291), 123)); + TEST_INSTRUCTION("6273AD00556A7F7B" , vfixupimmsd(xmm13, xmm26, qword_ptr(rdx, 1016), 123)); + TEST_INSTRUCTION("6273AD0055AA000400007B" , vfixupimmsd(xmm13, xmm26, qword_ptr(rdx, 1024), 123)); + TEST_INSTRUCTION("6273AD00556A807B" , vfixupimmsd(xmm13, xmm26, qword_ptr(rdx, -1024), 123)); + TEST_INSTRUCTION("6273AD0055AAF8FBFFFF7B" , vfixupimmsd(xmm13, xmm26, qword_ptr(rdx, -1032), 123)); + TEST_INSTRUCTION("62E1FD082F39" , vcomisd(xmm23, qword_ptr(rcx))); + TEST_INSTRUCTION("62E17C082F01" , vcomiss(xmm16, dword_ptr(rcx))); + TEST_INSTRUCTION("62717E0A1129" , k(k2).vmovss(dword_ptr(rcx), xmm13)); + TEST_INSTRUCTION("C4217A11ACF034120000" , vmovss(dword_ptr(rax, r14, 3, 4660), xmm13)); + TEST_INSTRUCTION("C57A11AAFC010000" , vmovss(dword_ptr(rdx, 508), xmm13)); + TEST_INSTRUCTION("C57A11AA00020000" , vmovss(dword_ptr(rdx, 512), xmm13)); + TEST_INSTRUCTION("C57A11AA00FEFFFF" , vmovss(dword_ptr(rdx, -512), xmm13)); + TEST_INSTRUCTION("C57A11AAFCFDFFFF" , vmovss(dword_ptr(rdx, -516), xmm13)); + TEST_INSTRUCTION("C5FA11AAFC010000" , vmovss(dword_ptr(rdx, 508), xmm5)); + TEST_INSTRUCTION("C5FA11AA00020000" , vmovss(dword_ptr(rdx, 512), xmm5)); + TEST_INSTRUCTION("C5FA11AA00FEFFFF" , vmovss(dword_ptr(rdx, -512), xmm5)); + TEST_INSTRUCTION("C5FA11AAFCFDFFFF" , vmovss(dword_ptr(rdx, -516), xmm5)); + TEST_INSTRUCTION("C57A1129" , vmovss(dword_ptr(rcx), xmm13)); + TEST_INSTRUCTION("C5FA1011" , vmovss(xmm2, dword_ptr(rcx))); + TEST_INSTRUCTION("62F17E0C1011" , k(k4).vmovss(xmm2, dword_ptr(rcx))); + TEST_INSTRUCTION("62F17E8C1011" , k(k4).z().vmovss(xmm2, dword_ptr(rcx))); + TEST_INSTRUCTION("6261FF081009" , vmovsd(xmm25, qword_ptr(rcx))); + TEST_INSTRUCTION("6261FF0B1009" , k(k3).vmovsd(xmm25, qword_ptr(rcx))); + TEST_INSTRUCTION("6261FF8B1009" , k(k3).z().vmovsd(xmm25, qword_ptr(rcx))); + TEST_INSTRUCTION("6221FF08108CF023010000" , vmovsd(xmm25, qword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("6261FF08104A7F" , vmovsd(xmm25, qword_ptr(rdx, 1016))); + TEST_INSTRUCTION("6261FF08108A00040000" , vmovsd(xmm25, qword_ptr(rdx, 1024))); + TEST_INSTRUCTION("6261FF08104A80" , vmovsd(xmm25, qword_ptr(rdx, -1024))); + TEST_INSTRUCTION("6261FF08108AF8FBFFFF" , vmovsd(xmm25, qword_ptr(rdx, -1032))); + TEST_INSTRUCTION("6271A54058C6" , vaddpd(zmm8, zmm27, zmm6)); + TEST_INSTRUCTION("6271A54758C6" , k(k7).vaddpd(zmm8, zmm27, zmm6)); + TEST_INSTRUCTION("6271A5C758C6" , k(k7).z().vaddpd(zmm8, zmm27, zmm6)); + TEST_INSTRUCTION("6271A51058C6" , rn_sae().vaddpd(zmm8, zmm27, zmm6)); + TEST_INSTRUCTION("6271A55058C6" , ru_sae().vaddpd(zmm8, zmm27, zmm6)); + TEST_INSTRUCTION("6271A53058C6" , rd_sae().vaddpd(zmm8, zmm27, zmm6)); + TEST_INSTRUCTION("6271A57058C6" , rz_sae().vaddpd(zmm8, zmm27, zmm6)); + TEST_INSTRUCTION("6271A5405801" , vaddpd(zmm8, zmm27, zmmword_ptr(rcx))); + TEST_INSTRUCTION("6231A5405884F023010000" , vaddpd(zmm8, zmm27, zmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("6271A5505801" , vaddpd(zmm8, zmm27, qword_ptr(rcx)._1to8())); + TEST_INSTRUCTION("6271A54058427F" , vaddpd(zmm8, zmm27, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("6271A540588200200000" , vaddpd(zmm8, zmm27, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("6271A540584280" , vaddpd(zmm8, zmm27, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("6271A5405882C0DFFFFF" , vaddpd(zmm8, zmm27, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("6271A55058427F" , vaddpd(zmm8, zmm27, qword_ptr(rdx, 1016)._1to8())); + TEST_INSTRUCTION("6271A550588200040000" , vaddpd(zmm8, zmm27, qword_ptr(rdx, 1024)._1to8())); + TEST_INSTRUCTION("6271A550584280" , vaddpd(zmm8, zmm27, qword_ptr(rdx, -1024)._1to8())); + TEST_INSTRUCTION("6271A5505882F8FBFFFF" , vaddpd(zmm8, zmm27, qword_ptr(rdx, -1032)._1to8())); + TEST_INSTRUCTION("62E1144858D2" , vaddps(zmm18, zmm13, zmm2)); + TEST_INSTRUCTION("62E1144C58D2" , k(k4).vaddps(zmm18, zmm13, zmm2)); + TEST_INSTRUCTION("62E114CC58D2" , k(k4).z().vaddps(zmm18, zmm13, zmm2)); + TEST_INSTRUCTION("62E1141858D2" , rn_sae().vaddps(zmm18, zmm13, zmm2)); + TEST_INSTRUCTION("62E1145858D2" , ru_sae().vaddps(zmm18, zmm13, zmm2)); + TEST_INSTRUCTION("62E1143858D2" , rd_sae().vaddps(zmm18, zmm13, zmm2)); + TEST_INSTRUCTION("62E1147858D2" , rz_sae().vaddps(zmm18, zmm13, zmm2)); + TEST_INSTRUCTION("62E114485811" , vaddps(zmm18, zmm13, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62A114485894F023010000" , vaddps(zmm18, zmm13, zmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62E114585811" , vaddps(zmm18, zmm13, dword_ptr(rcx)._1to16())); + TEST_INSTRUCTION("62E1144858527F" , vaddps(zmm18, zmm13, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62E11448589200200000" , vaddps(zmm18, zmm13, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62E11448585280" , vaddps(zmm18, zmm13, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62E114485892C0DFFFFF" , vaddps(zmm18, zmm13, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62E1145858527F" , vaddps(zmm18, zmm13, dword_ptr(rdx, 508)._1to16())); + TEST_INSTRUCTION("62E11458589200020000" , vaddps(zmm18, zmm13, dword_ptr(rdx, 512)._1to16())); + TEST_INSTRUCTION("62E11458585280" , vaddps(zmm18, zmm13, dword_ptr(rdx, -512)._1to16())); + TEST_INSTRUCTION("62E114585892FCFDFFFF" , vaddps(zmm18, zmm13, dword_ptr(rdx, -516)._1to16())); + TEST_INSTRUCTION("62D1F70058D8" , vaddsd(xmm3, xmm17, xmm8)); + TEST_INSTRUCTION("62D1F70358D8" , k(k3).vaddsd(xmm3, xmm17, xmm8)); + TEST_INSTRUCTION("62D1F78358D8" , k(k3).z().vaddsd(xmm3, xmm17, xmm8)); + TEST_INSTRUCTION("62D1F71058D8" , rn_sae().vaddsd(xmm3, xmm17, xmm8)); + TEST_INSTRUCTION("62D1F75058D8" , ru_sae().vaddsd(xmm3, xmm17, xmm8)); + TEST_INSTRUCTION("62D1F73058D8" , rd_sae().vaddsd(xmm3, xmm17, xmm8)); + TEST_INSTRUCTION("62D1F77058D8" , rz_sae().vaddsd(xmm3, xmm17, xmm8)); + TEST_INSTRUCTION("62F1F7005819" , vaddsd(xmm3, xmm17, qword_ptr(rcx))); + TEST_INSTRUCTION("62B1F700589CF023010000" , vaddsd(xmm3, xmm17, qword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62F1F700585A7F" , vaddsd(xmm3, xmm17, qword_ptr(rdx, 1016))); + TEST_INSTRUCTION("62F1F700589A00040000" , vaddsd(xmm3, xmm17, qword_ptr(rdx, 1024))); + TEST_INSTRUCTION("62F1F700585A80" , vaddsd(xmm3, xmm17, qword_ptr(rdx, -1024))); + TEST_INSTRUCTION("62F1F700589AF8FBFFFF" , vaddsd(xmm3, xmm17, qword_ptr(rdx, -1032))); + TEST_INSTRUCTION("62B1560858FB" , vaddss(xmm7, xmm5, xmm19)); + TEST_INSTRUCTION("62B1560A58FB" , k(k2).vaddss(xmm7, xmm5, xmm19)); + TEST_INSTRUCTION("62B1568A58FB" , k(k2).z().vaddss(xmm7, xmm5, xmm19)); + TEST_INSTRUCTION("62B1561858FB" , rn_sae().vaddss(xmm7, xmm5, xmm19)); + TEST_INSTRUCTION("62B1565858FB" , ru_sae().vaddss(xmm7, xmm5, xmm19)); + TEST_INSTRUCTION("62B1563858FB" , rd_sae().vaddss(xmm7, xmm5, xmm19)); + TEST_INSTRUCTION("62B1567858FB" , rz_sae().vaddss(xmm7, xmm5, xmm19)); + TEST_INSTRUCTION("C5D25839" , vaddss(xmm7, xmm5, dword_ptr(rcx))); + TEST_INSTRUCTION("C4A15258BCF023010000" , vaddss(xmm7, xmm5, dword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("C5D258BAFC010000" , vaddss(xmm7, xmm5, dword_ptr(rdx, 508))); + TEST_INSTRUCTION("C5D258BA00020000" , vaddss(xmm7, xmm5, dword_ptr(rdx, 512))); + TEST_INSTRUCTION("C5D258BA00FEFFFF" , vaddss(xmm7, xmm5, dword_ptr(rdx, -512))); + TEST_INSTRUCTION("C5D258BAFCFDFFFF" , vaddss(xmm7, xmm5, dword_ptr(rdx, -516))); + TEST_INSTRUCTION("62136D4003CAAB" , valignd(zmm9, zmm18, zmm26, 171)); + TEST_INSTRUCTION("62136D4403CAAB" , k(k4).valignd(zmm9, zmm18, zmm26, 171)); + TEST_INSTRUCTION("62136DC403CAAB" , k(k4).z().valignd(zmm9, zmm18, zmm26, 171)); + TEST_INSTRUCTION("62136D4003CA7B" , valignd(zmm9, zmm18, zmm26, 123)); + TEST_INSTRUCTION("62736D4003097B" , valignd(zmm9, zmm18, zmmword_ptr(rcx), 123)); + TEST_INSTRUCTION("62336D40038CF0230100007B" , valignd(zmm9, zmm18, zmmword_ptr(rax, r14, 3, 291), 123)); + TEST_INSTRUCTION("62736D5003097B" , valignd(zmm9, zmm18, dword_ptr(rcx)._1to16(), 123)); + TEST_INSTRUCTION("62736D40034A7F7B" , valignd(zmm9, zmm18, zmmword_ptr(rdx, 8128), 123)); + TEST_INSTRUCTION("62736D40038A002000007B" , valignd(zmm9, zmm18, zmmword_ptr(rdx, 8192), 123)); + TEST_INSTRUCTION("62736D40034A807B" , valignd(zmm9, zmm18, zmmword_ptr(rdx, -8192), 123)); + TEST_INSTRUCTION("62736D40038AC0DFFFFF7B" , valignd(zmm9, zmm18, zmmword_ptr(rdx, -8256), 123)); + TEST_INSTRUCTION("62736D50034A7F7B" , valignd(zmm9, zmm18, dword_ptr(rdx, 508)._1to16(), 123)); + TEST_INSTRUCTION("62736D50038A000200007B" , valignd(zmm9, zmm18, dword_ptr(rdx, 512)._1to16(), 123)); + TEST_INSTRUCTION("62736D50034A807B" , valignd(zmm9, zmm18, dword_ptr(rdx, -512)._1to16(), 123)); + TEST_INSTRUCTION("62736D50038AFCFDFFFF7B" , valignd(zmm9, zmm18, dword_ptr(rdx, -516)._1to16(), 123)); + TEST_INSTRUCTION("62529D4065C4" , vblendmpd(zmm8, zmm28, zmm12)); + TEST_INSTRUCTION("62529D4165C4" , k(k1).vblendmpd(zmm8, zmm28, zmm12)); + TEST_INSTRUCTION("62529DC165C4" , k(k1).z().vblendmpd(zmm8, zmm28, zmm12)); + TEST_INSTRUCTION("62729D406501" , vblendmpd(zmm8, zmm28, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62329D406584F023010000" , vblendmpd(zmm8, zmm28, zmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62729D506501" , vblendmpd(zmm8, zmm28, qword_ptr(rcx)._1to8())); + TEST_INSTRUCTION("62729D4065427F" , vblendmpd(zmm8, zmm28, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62729D40658200200000" , vblendmpd(zmm8, zmm28, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62729D40654280" , vblendmpd(zmm8, zmm28, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62729D406582C0DFFFFF" , vblendmpd(zmm8, zmm28, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62729D5065427F" , vblendmpd(zmm8, zmm28, qword_ptr(rdx, 1016)._1to8())); + TEST_INSTRUCTION("62729D50658200040000" , vblendmpd(zmm8, zmm28, qword_ptr(rdx, 1024)._1to8())); + TEST_INSTRUCTION("62729D50654280" , vblendmpd(zmm8, zmm28, qword_ptr(rdx, -1024)._1to8())); + TEST_INSTRUCTION("62729D506582F8FBFFFF" , vblendmpd(zmm8, zmm28, qword_ptr(rdx, -1032)._1to8())); + TEST_INSTRUCTION("62721D4065FC" , vblendmps(zmm15, zmm28, zmm4)); + TEST_INSTRUCTION("62721D4365FC" , k(k3).vblendmps(zmm15, zmm28, zmm4)); + TEST_INSTRUCTION("62721DC365FC" , k(k3).z().vblendmps(zmm15, zmm28, zmm4)); + TEST_INSTRUCTION("62721D406539" , vblendmps(zmm15, zmm28, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62321D4065BCF023010000" , vblendmps(zmm15, zmm28, zmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62721D506539" , vblendmps(zmm15, zmm28, dword_ptr(rcx)._1to16())); + TEST_INSTRUCTION("62721D40657A7F" , vblendmps(zmm15, zmm28, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62721D4065BA00200000" , vblendmps(zmm15, zmm28, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62721D40657A80" , vblendmps(zmm15, zmm28, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62721D4065BAC0DFFFFF" , vblendmps(zmm15, zmm28, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62721D50657A7F" , vblendmps(zmm15, zmm28, dword_ptr(rdx, 508)._1to16())); + TEST_INSTRUCTION("62721D5065BA00020000" , vblendmps(zmm15, zmm28, dword_ptr(rdx, 512)._1to16())); + TEST_INSTRUCTION("62721D50657A80" , vblendmps(zmm15, zmm28, dword_ptr(rdx, -512)._1to16())); + TEST_INSTRUCTION("62721D5065BAFCFDFFFF" , vblendmps(zmm15, zmm28, dword_ptr(rdx, -516)._1to16())); + TEST_INSTRUCTION("62F27D481A19" , vbroadcastf32x4(zmm3, xmmword_ptr(rcx))); + TEST_INSTRUCTION("62F27D4F1A19" , k(k7).vbroadcastf32x4(zmm3, xmmword_ptr(rcx))); + TEST_INSTRUCTION("62F27DCF1A19" , k(k7).z().vbroadcastf32x4(zmm3, xmmword_ptr(rcx))); + TEST_INSTRUCTION("62B27D481A9CF023010000" , vbroadcastf32x4(zmm3, xmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62F27D481A5A7F" , vbroadcastf32x4(zmm3, xmmword_ptr(rdx, 2032))); + TEST_INSTRUCTION("62F27D481A9A00080000" , vbroadcastf32x4(zmm3, xmmword_ptr(rdx, 2048))); + TEST_INSTRUCTION("62F27D481A5A80" , vbroadcastf32x4(zmm3, xmmword_ptr(rdx, -2048))); + TEST_INSTRUCTION("62F27D481A9AF0F7FFFF" , vbroadcastf32x4(zmm3, xmmword_ptr(rdx, -2064))); + TEST_INSTRUCTION("6262FD481B09" , vbroadcastf64x4(zmm25, ymmword_ptr(rcx))); + TEST_INSTRUCTION("6262FD4E1B09" , k(k6).vbroadcastf64x4(zmm25, ymmword_ptr(rcx))); + TEST_INSTRUCTION("6262FDCE1B09" , k(k6).z().vbroadcastf64x4(zmm25, ymmword_ptr(rcx))); + TEST_INSTRUCTION("6222FD481B8CF023010000" , vbroadcastf64x4(zmm25, ymmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("6262FD481B4A7F" , vbroadcastf64x4(zmm25, ymmword_ptr(rdx, 4064))); + TEST_INSTRUCTION("6262FD481B8A00100000" , vbroadcastf64x4(zmm25, ymmword_ptr(rdx, 4096))); + TEST_INSTRUCTION("6262FD481B4A80" , vbroadcastf64x4(zmm25, ymmword_ptr(rdx, -4096))); + TEST_INSTRUCTION("6262FD481B8AE0EFFFFF" , vbroadcastf64x4(zmm25, ymmword_ptr(rdx, -4128))); + TEST_INSTRUCTION("62627D485A31" , vbroadcasti32x4(zmm30, xmmword_ptr(rcx))); + TEST_INSTRUCTION("62627D4B5A31" , k(k3).vbroadcasti32x4(zmm30, xmmword_ptr(rcx))); + TEST_INSTRUCTION("62627DCB5A31" , k(k3).z().vbroadcasti32x4(zmm30, xmmword_ptr(rcx))); + TEST_INSTRUCTION("62227D485AB4F023010000" , vbroadcasti32x4(zmm30, xmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62627D485A727F" , vbroadcasti32x4(zmm30, xmmword_ptr(rdx, 2032))); + TEST_INSTRUCTION("62627D485AB200080000" , vbroadcasti32x4(zmm30, xmmword_ptr(rdx, 2048))); + TEST_INSTRUCTION("62627D485A7280" , vbroadcasti32x4(zmm30, xmmword_ptr(rdx, -2048))); + TEST_INSTRUCTION("62627D485AB2F0F7FFFF" , vbroadcasti32x4(zmm30, xmmword_ptr(rdx, -2064))); + TEST_INSTRUCTION("6272FD485B29" , vbroadcasti64x4(zmm13, ymmword_ptr(rcx))); + TEST_INSTRUCTION("6272FD4C5B29" , k(k4).vbroadcasti64x4(zmm13, ymmword_ptr(rcx))); + TEST_INSTRUCTION("6272FDCC5B29" , k(k4).z().vbroadcasti64x4(zmm13, ymmword_ptr(rcx))); + TEST_INSTRUCTION("6232FD485BACF023010000" , vbroadcasti64x4(zmm13, ymmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("6272FD485B6A7F" , vbroadcasti64x4(zmm13, ymmword_ptr(rdx, 4064))); + TEST_INSTRUCTION("6272FD485BAA00100000" , vbroadcasti64x4(zmm13, ymmword_ptr(rdx, 4096))); + TEST_INSTRUCTION("6272FD485B6A80" , vbroadcasti64x4(zmm13, ymmword_ptr(rdx, -4096))); + TEST_INSTRUCTION("6272FD485BAAE0EFFFFF" , vbroadcasti64x4(zmm13, ymmword_ptr(rdx, -4128))); + TEST_INSTRUCTION("6262FD481931" , vbroadcastsd(zmm30, qword_ptr(rcx))); + TEST_INSTRUCTION("6262FD4C1931" , k(k4).vbroadcastsd(zmm30, qword_ptr(rcx))); + TEST_INSTRUCTION("6262FDCC1931" , k(k4).z().vbroadcastsd(zmm30, qword_ptr(rcx))); + TEST_INSTRUCTION("6222FD4819B4F023010000" , vbroadcastsd(zmm30, qword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("6262FD4819727F" , vbroadcastsd(zmm30, qword_ptr(rdx, 1016))); + TEST_INSTRUCTION("6262FD4819B200040000" , vbroadcastsd(zmm30, qword_ptr(rdx, 1024))); + TEST_INSTRUCTION("6262FD48197280" , vbroadcastsd(zmm30, qword_ptr(rdx, -1024))); + TEST_INSTRUCTION("6262FD4819B2F8FBFFFF" , vbroadcastsd(zmm30, qword_ptr(rdx, -1032))); + TEST_INSTRUCTION("62A2FD4819EE" , vbroadcastsd(zmm21, xmm22)); + TEST_INSTRUCTION("62A2FD4F19EE" , k(k7).vbroadcastsd(zmm21, xmm22)); + TEST_INSTRUCTION("62A2FDCF19EE" , k(k7).z().vbroadcastsd(zmm21, xmm22)); + TEST_INSTRUCTION("62F27D481819" , vbroadcastss(zmm3, dword_ptr(rcx))); + TEST_INSTRUCTION("62F27D4C1819" , k(k4).vbroadcastss(zmm3, dword_ptr(rcx))); + TEST_INSTRUCTION("62F27DCC1819" , k(k4).z().vbroadcastss(zmm3, dword_ptr(rcx))); + TEST_INSTRUCTION("62B27D48189CF023010000" , vbroadcastss(zmm3, dword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62F27D48185A7F" , vbroadcastss(zmm3, dword_ptr(rdx, 508))); + TEST_INSTRUCTION("62F27D48189A00020000" , vbroadcastss(zmm3, dword_ptr(rdx, 512))); + TEST_INSTRUCTION("62F27D48185A80" , vbroadcastss(zmm3, dword_ptr(rdx, -512))); + TEST_INSTRUCTION("62F27D48189AFCFDFFFF" , vbroadcastss(zmm3, dword_ptr(rdx, -516))); + TEST_INSTRUCTION("62A27D4818D2" , vbroadcastss(zmm18, xmm18)); + TEST_INSTRUCTION("62A27D4A18D2" , k(k2).vbroadcastss(zmm18, xmm18)); + TEST_INSTRUCTION("62A27DCA18D2" , k(k2).z().vbroadcastss(zmm18, xmm18)); + TEST_INSTRUCTION("62919D48C2D2AB" , vcmppd(k2, zmm12, zmm26, 171)); + TEST_INSTRUCTION("62919D4BC2D2AB" , k(k3).vcmppd(k2, zmm12, zmm26, 171)); + TEST_INSTRUCTION("62919D18C2D2AB" , sae().vcmppd(k2, zmm12, zmm26, 171)); + TEST_INSTRUCTION("62919D48C2D27B" , vcmppd(k2, zmm12, zmm26, 123)); + TEST_INSTRUCTION("62919D18C2D27B" , sae().vcmppd(k2, zmm12, zmm26, 123)); + TEST_INSTRUCTION("62F19D48C2117B" , vcmppd(k2, zmm12, zmmword_ptr(rcx), 123)); + TEST_INSTRUCTION("62B19D48C294F0230100007B" , vcmppd(k2, zmm12, zmmword_ptr(rax, r14, 3, 291), 123)); + TEST_INSTRUCTION("62F19D58C2117B" , vcmppd(k2, zmm12, qword_ptr(rcx)._1to8(), 123)); + TEST_INSTRUCTION("62F19D48C2527F7B" , vcmppd(k2, zmm12, zmmword_ptr(rdx, 8128), 123)); + TEST_INSTRUCTION("62F19D48C292002000007B" , vcmppd(k2, zmm12, zmmword_ptr(rdx, 8192), 123)); + TEST_INSTRUCTION("62F19D48C252807B" , vcmppd(k2, zmm12, zmmword_ptr(rdx, -8192), 123)); + TEST_INSTRUCTION("62F19D48C292C0DFFFFF7B" , vcmppd(k2, zmm12, zmmword_ptr(rdx, -8256), 123)); + TEST_INSTRUCTION("62F19D58C2527F7B" , vcmppd(k2, zmm12, qword_ptr(rdx, 1016)._1to8(), 123)); + TEST_INSTRUCTION("62F19D58C292000400007B" , vcmppd(k2, zmm12, qword_ptr(rdx, 1024)._1to8(), 123)); + TEST_INSTRUCTION("62F19D58C252807B" , vcmppd(k2, zmm12, qword_ptr(rdx, -1024)._1to8(), 123)); + TEST_INSTRUCTION("62F19D58C292F8FBFFFF7B" , vcmppd(k2, zmm12, qword_ptr(rdx, -1032)._1to8(), 123)); + TEST_INSTRUCTION("62B17440C2D6AB" , vcmpps(k2, zmm17, zmm22, 171)); + TEST_INSTRUCTION("62B17443C2D6AB" , k(k3).vcmpps(k2, zmm17, zmm22, 171)); + TEST_INSTRUCTION("62B17410C2D6AB" , sae().vcmpps(k2, zmm17, zmm22, 171)); + TEST_INSTRUCTION("62B17440C2D67B" , vcmpps(k2, zmm17, zmm22, 123)); + TEST_INSTRUCTION("62B17410C2D67B" , sae().vcmpps(k2, zmm17, zmm22, 123)); + TEST_INSTRUCTION("62F17440C2117B" , vcmpps(k2, zmm17, zmmword_ptr(rcx), 123)); + TEST_INSTRUCTION("62B17440C294F0230100007B" , vcmpps(k2, zmm17, zmmword_ptr(rax, r14, 3, 291), 123)); + TEST_INSTRUCTION("62F17450C2117B" , vcmpps(k2, zmm17, dword_ptr(rcx)._1to16(), 123)); + TEST_INSTRUCTION("62F17440C2527F7B" , vcmpps(k2, zmm17, zmmword_ptr(rdx, 8128), 123)); + TEST_INSTRUCTION("62F17440C292002000007B" , vcmpps(k2, zmm17, zmmword_ptr(rdx, 8192), 123)); + TEST_INSTRUCTION("62F17440C252807B" , vcmpps(k2, zmm17, zmmword_ptr(rdx, -8192), 123)); + TEST_INSTRUCTION("62F17440C292C0DFFFFF7B" , vcmpps(k2, zmm17, zmmword_ptr(rdx, -8256), 123)); + TEST_INSTRUCTION("62F17450C2527F7B" , vcmpps(k2, zmm17, dword_ptr(rdx, 508)._1to16(), 123)); + TEST_INSTRUCTION("62F17450C292000200007B" , vcmpps(k2, zmm17, dword_ptr(rdx, 512)._1to16(), 123)); + TEST_INSTRUCTION("62F17450C252807B" , vcmpps(k2, zmm17, dword_ptr(rdx, -512)._1to16(), 123)); + TEST_INSTRUCTION("62F17450C292FCFDFFFF7B" , vcmpps(k2, zmm17, dword_ptr(rdx, -516)._1to16(), 123)); + TEST_INSTRUCTION("62F1E700C2ECAB" , vcmpsd(k5, xmm19, xmm4, 171)); + TEST_INSTRUCTION("62F1E701C2ECAB" , k(k1).vcmpsd(k5, xmm19, xmm4, 171)); + TEST_INSTRUCTION("62F1E710C2ECAB" , sae().vcmpsd(k5, xmm19, xmm4, 171)); + TEST_INSTRUCTION("62F1E700C2EC7B" , vcmpsd(k5, xmm19, xmm4, 123)); + TEST_INSTRUCTION("62F1E710C2EC7B" , sae().vcmpsd(k5, xmm19, xmm4, 123)); + TEST_INSTRUCTION("62F1E700C2297B" , vcmpsd(k5, xmm19, qword_ptr(rcx), 123)); + TEST_INSTRUCTION("62B1E700C2ACF0230100007B" , vcmpsd(k5, xmm19, qword_ptr(rax, r14, 3, 291), 123)); + TEST_INSTRUCTION("62F1E700C26A7F7B" , vcmpsd(k5, xmm19, qword_ptr(rdx, 1016), 123)); + TEST_INSTRUCTION("62F1E700C2AA000400007B" , vcmpsd(k5, xmm19, qword_ptr(rdx, 1024), 123)); + TEST_INSTRUCTION("62F1E700C26A807B" , vcmpsd(k5, xmm19, qword_ptr(rdx, -1024), 123)); + TEST_INSTRUCTION("62F1E700C2AAF8FBFFFF7B" , vcmpsd(k5, xmm19, qword_ptr(rdx, -1032), 123)); + TEST_INSTRUCTION("62D10608C2E4AB" , vcmpss(k4, xmm15, xmm12, 171)); + TEST_INSTRUCTION("62D1060DC2E4AB" , k(k5).vcmpss(k4, xmm15, xmm12, 171)); + TEST_INSTRUCTION("62D10618C2E4AB" , sae().vcmpss(k4, xmm15, xmm12, 171)); + TEST_INSTRUCTION("62D10608C2E47B" , vcmpss(k4, xmm15, xmm12, 123)); + TEST_INSTRUCTION("62D10618C2E47B" , sae().vcmpss(k4, xmm15, xmm12, 123)); + TEST_INSTRUCTION("62F10608C2217B" , vcmpss(k4, xmm15, dword_ptr(rcx), 123)); + TEST_INSTRUCTION("62B10608C2A4F0230100007B" , vcmpss(k4, xmm15, dword_ptr(rax, r14, 3, 291), 123)); + TEST_INSTRUCTION("62F10608C2627F7B" , vcmpss(k4, xmm15, dword_ptr(rdx, 508), 123)); + TEST_INSTRUCTION("62F10608C2A2000200007B" , vcmpss(k4, xmm15, dword_ptr(rdx, 512), 123)); + TEST_INSTRUCTION("62F10608C262807B" , vcmpss(k4, xmm15, dword_ptr(rdx, -512), 123)); + TEST_INSTRUCTION("62F10608C2A2FCFDFFFF7B" , vcmpss(k4, xmm15, dword_ptr(rdx, -516), 123)); + TEST_INSTRUCTION("62A1FD082FFD" , vcomisd(xmm23, xmm21)); + TEST_INSTRUCTION("62A1FD182FFD" , sae().vcomisd(xmm23, xmm21)); + TEST_INSTRUCTION("62E1FD082F39" , vcomisd(xmm23, qword_ptr(rcx))); + TEST_INSTRUCTION("62A1FD082FBCF023010000" , vcomisd(xmm23, qword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62E1FD082F7A7F" , vcomisd(xmm23, qword_ptr(rdx, 1016))); + TEST_INSTRUCTION("62E1FD082FBA00040000" , vcomisd(xmm23, qword_ptr(rdx, 1024))); + TEST_INSTRUCTION("62E1FD082F7A80" , vcomisd(xmm23, qword_ptr(rdx, -1024))); + TEST_INSTRUCTION("62E1FD082FBAF8FBFFFF" , vcomisd(xmm23, qword_ptr(rdx, -1032))); + TEST_INSTRUCTION("62117C082FF4" , vcomiss(xmm14, xmm28)); + TEST_INSTRUCTION("62117C182FF4" , sae().vcomiss(xmm14, xmm28)); + TEST_INSTRUCTION("C5782F31" , vcomiss(xmm14, dword_ptr(rcx))); + TEST_INSTRUCTION("C421782FB4F023010000" , vcomiss(xmm14, dword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("C5782FB2FC010000" , vcomiss(xmm14, dword_ptr(rdx, 508))); + TEST_INSTRUCTION("C5782FB200020000" , vcomiss(xmm14, dword_ptr(rdx, 512))); + TEST_INSTRUCTION("C5782FB200FEFFFF" , vcomiss(xmm14, dword_ptr(rdx, -512))); + TEST_INSTRUCTION("C5782FB2FCFDFFFF" , vcomiss(xmm14, dword_ptr(rdx, -516))); + TEST_INSTRUCTION("6272FD488A09" , vcompresspd(zmmword_ptr(rcx), zmm9)); + TEST_INSTRUCTION("6272FD4C8A09" , k(k4).vcompresspd(zmmword_ptr(rcx), zmm9)); + TEST_INSTRUCTION("6232FD488A8CF023010000" , vcompresspd(zmmword_ptr(rax, r14, 3, 291), zmm9)); + TEST_INSTRUCTION("6272FD488A4A7F" , vcompresspd(zmmword_ptr(rdx, 1016), zmm9)); + TEST_INSTRUCTION("6272FD488A8A00040000" , vcompresspd(zmmword_ptr(rdx, 1024), zmm9)); + TEST_INSTRUCTION("6272FD488A4A80" , vcompresspd(zmmword_ptr(rdx, -1024), zmm9)); + TEST_INSTRUCTION("6272FD488A8AF8FBFFFF" , vcompresspd(zmmword_ptr(rdx, -1032), zmm9)); + TEST_INSTRUCTION("62D2FD488AE0" , vcompresspd(zmm8, zmm4)); + TEST_INSTRUCTION("62D2FD4E8AE0" , k(k6).vcompresspd(zmm8, zmm4)); + TEST_INSTRUCTION("62D2FDCE8AE0" , k(k6).z().vcompresspd(zmm8, zmm4)); + TEST_INSTRUCTION("62727D488A11" , vcompressps(zmmword_ptr(rcx), zmm10)); + TEST_INSTRUCTION("62727D4F8A11" , k(k7).vcompressps(zmmword_ptr(rcx), zmm10)); + TEST_INSTRUCTION("62327D488A94F023010000" , vcompressps(zmmword_ptr(rax, r14, 3, 291), zmm10)); + TEST_INSTRUCTION("62727D488A527F" , vcompressps(zmmword_ptr(rdx, 508), zmm10)); + TEST_INSTRUCTION("62727D488A9200020000" , vcompressps(zmmword_ptr(rdx, 512), zmm10)); + TEST_INSTRUCTION("62727D488A5280" , vcompressps(zmmword_ptr(rdx, -512), zmm10)); + TEST_INSTRUCTION("62727D488A92FCFDFFFF" , vcompressps(zmmword_ptr(rdx, -516), zmm10)); + TEST_INSTRUCTION("62727D488AF4" , vcompressps(zmm4, zmm14)); + TEST_INSTRUCTION("62727D4A8AF4" , k(k2).vcompressps(zmm4, zmm14)); + TEST_INSTRUCTION("62727DCA8AF4" , k(k2).z().vcompressps(zmm4, zmm14)); + TEST_INSTRUCTION("62817E48E6F0" , vcvtdq2pd(zmm22, ymm24)); + TEST_INSTRUCTION("62817E4CE6F0" , k(k4).vcvtdq2pd(zmm22, ymm24)); + TEST_INSTRUCTION("62817ECCE6F0" , k(k4).z().vcvtdq2pd(zmm22, ymm24)); + TEST_INSTRUCTION("62E17E48E631" , vcvtdq2pd(zmm22, ymmword_ptr(rcx))); + TEST_INSTRUCTION("62A17E48E6B4F023010000" , vcvtdq2pd(zmm22, ymmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62E17E58E631" , vcvtdq2pd(zmm22, dword_ptr(rcx)._1to8())); + TEST_INSTRUCTION("62E17E48E6727F" , vcvtdq2pd(zmm22, ymmword_ptr(rdx, 4064))); + TEST_INSTRUCTION("62E17E48E6B200100000" , vcvtdq2pd(zmm22, ymmword_ptr(rdx, 4096))); + TEST_INSTRUCTION("62E17E48E67280" , vcvtdq2pd(zmm22, ymmword_ptr(rdx, -4096))); + TEST_INSTRUCTION("62E17E48E6B2E0EFFFFF" , vcvtdq2pd(zmm22, ymmword_ptr(rdx, -4128))); + TEST_INSTRUCTION("62E17E58E6727F" , vcvtdq2pd(zmm22, dword_ptr(rdx, 508)._1to8())); + TEST_INSTRUCTION("62E17E58E6B200020000" , vcvtdq2pd(zmm22, dword_ptr(rdx, 512)._1to8())); + TEST_INSTRUCTION("62E17E58E67280" , vcvtdq2pd(zmm22, dword_ptr(rdx, -512)._1to8())); + TEST_INSTRUCTION("62E17E58E6B2FCFDFFFF" , vcvtdq2pd(zmm22, dword_ptr(rdx, -516)._1to8())); + TEST_INSTRUCTION("62917C485BF9" , vcvtdq2ps(zmm7, zmm25)); + TEST_INSTRUCTION("62917C4D5BF9" , k(k5).vcvtdq2ps(zmm7, zmm25)); + TEST_INSTRUCTION("62917CCD5BF9" , k(k5).z().vcvtdq2ps(zmm7, zmm25)); + TEST_INSTRUCTION("62917C185BF9" , rn_sae().vcvtdq2ps(zmm7, zmm25)); + TEST_INSTRUCTION("62917C585BF9" , ru_sae().vcvtdq2ps(zmm7, zmm25)); + TEST_INSTRUCTION("62917C385BF9" , rd_sae().vcvtdq2ps(zmm7, zmm25)); + TEST_INSTRUCTION("62917C785BF9" , rz_sae().vcvtdq2ps(zmm7, zmm25)); + TEST_INSTRUCTION("62F17C485B39" , vcvtdq2ps(zmm7, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62B17C485BBCF023010000" , vcvtdq2ps(zmm7, zmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62F17C585B39" , vcvtdq2ps(zmm7, dword_ptr(rcx)._1to16())); + TEST_INSTRUCTION("62F17C485B7A7F" , vcvtdq2ps(zmm7, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62F17C485BBA00200000" , vcvtdq2ps(zmm7, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62F17C485B7A80" , vcvtdq2ps(zmm7, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62F17C485BBAC0DFFFFF" , vcvtdq2ps(zmm7, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62F17C585B7A7F" , vcvtdq2ps(zmm7, dword_ptr(rdx, 508)._1to16())); + TEST_INSTRUCTION("62F17C585BBA00020000" , vcvtdq2ps(zmm7, dword_ptr(rdx, 512)._1to16())); + TEST_INSTRUCTION("62F17C585B7A80" , vcvtdq2ps(zmm7, dword_ptr(rdx, -512)._1to16())); + TEST_INSTRUCTION("62F17C585BBAFCFDFFFF" , vcvtdq2ps(zmm7, dword_ptr(rdx, -516)._1to16())); + TEST_INSTRUCTION("6241FF48E6C7" , vcvtpd2dq(ymm24, zmm15)); + TEST_INSTRUCTION("6241FF4BE6C7" , k(k3).vcvtpd2dq(ymm24, zmm15)); + TEST_INSTRUCTION("6241FFCBE6C7" , k(k3).z().vcvtpd2dq(ymm24, zmm15)); + TEST_INSTRUCTION("6241FF18E6C7" , rn_sae().vcvtpd2dq(ymm24, zmm15)); + TEST_INSTRUCTION("6241FF58E6C7" , ru_sae().vcvtpd2dq(ymm24, zmm15)); + TEST_INSTRUCTION("6241FF38E6C7" , rd_sae().vcvtpd2dq(ymm24, zmm15)); + TEST_INSTRUCTION("6241FF78E6C7" , rz_sae().vcvtpd2dq(ymm24, zmm15)); + TEST_INSTRUCTION("6261FF48E601" , vcvtpd2dq(ymm24, zmmword_ptr(rcx))); + TEST_INSTRUCTION("6221FF48E684F023010000" , vcvtpd2dq(ymm24, zmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("6261FF58E601" , vcvtpd2dq(ymm24, qword_ptr(rcx)._1to8())); + TEST_INSTRUCTION("6261FF48E6427F" , vcvtpd2dq(ymm24, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("6261FF48E68200200000" , vcvtpd2dq(ymm24, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("6261FF48E64280" , vcvtpd2dq(ymm24, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("6261FF48E682C0DFFFFF" , vcvtpd2dq(ymm24, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("6261FF58E6427F" , vcvtpd2dq(ymm24, qword_ptr(rdx, 1016)._1to8())); + TEST_INSTRUCTION("6261FF58E68200040000" , vcvtpd2dq(ymm24, qword_ptr(rdx, 1024)._1to8())); + TEST_INSTRUCTION("6261FF58E64280" , vcvtpd2dq(ymm24, qword_ptr(rdx, -1024)._1to8())); + TEST_INSTRUCTION("6261FF58E682F8FBFFFF" , vcvtpd2dq(ymm24, qword_ptr(rdx, -1032)._1to8())); + TEST_INSTRUCTION("62B1FD485AEF" , vcvtpd2ps(ymm5, zmm23)); + TEST_INSTRUCTION("62B1FD4D5AEF" , k(k5).vcvtpd2ps(ymm5, zmm23)); + TEST_INSTRUCTION("62B1FDCD5AEF" , k(k5).z().vcvtpd2ps(ymm5, zmm23)); + TEST_INSTRUCTION("62B1FD185AEF" , rn_sae().vcvtpd2ps(ymm5, zmm23)); + TEST_INSTRUCTION("62B1FD585AEF" , ru_sae().vcvtpd2ps(ymm5, zmm23)); + TEST_INSTRUCTION("62B1FD385AEF" , rd_sae().vcvtpd2ps(ymm5, zmm23)); + TEST_INSTRUCTION("62B1FD785AEF" , rz_sae().vcvtpd2ps(ymm5, zmm23)); + TEST_INSTRUCTION("62F1FD485A29" , vcvtpd2ps(ymm5, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62B1FD485AACF023010000" , vcvtpd2ps(ymm5, zmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62F1FD585A29" , vcvtpd2ps(ymm5, qword_ptr(rcx)._1to8())); + TEST_INSTRUCTION("62F1FD485A6A7F" , vcvtpd2ps(ymm5, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62F1FD485AAA00200000" , vcvtpd2ps(ymm5, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62F1FD485A6A80" , vcvtpd2ps(ymm5, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62F1FD485AAAC0DFFFFF" , vcvtpd2ps(ymm5, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62F1FD585A6A7F" , vcvtpd2ps(ymm5, qword_ptr(rdx, 1016)._1to8())); + TEST_INSTRUCTION("62F1FD585AAA00040000" , vcvtpd2ps(ymm5, qword_ptr(rdx, 1024)._1to8())); + TEST_INSTRUCTION("62F1FD585A6A80" , vcvtpd2ps(ymm5, qword_ptr(rdx, -1024)._1to8())); + TEST_INSTRUCTION("62F1FD585AAAF8FBFFFF" , vcvtpd2ps(ymm5, qword_ptr(rdx, -1032)._1to8())); + TEST_INSTRUCTION("6231FC4879FB" , vcvtpd2udq(ymm15, zmm19)); + TEST_INSTRUCTION("6231FC4F79FB" , k(k7).vcvtpd2udq(ymm15, zmm19)); + TEST_INSTRUCTION("6231FCCF79FB" , k(k7).z().vcvtpd2udq(ymm15, zmm19)); + TEST_INSTRUCTION("6231FC1879FB" , rn_sae().vcvtpd2udq(ymm15, zmm19)); + TEST_INSTRUCTION("6231FC5879FB" , ru_sae().vcvtpd2udq(ymm15, zmm19)); + TEST_INSTRUCTION("6231FC3879FB" , rd_sae().vcvtpd2udq(ymm15, zmm19)); + TEST_INSTRUCTION("6231FC7879FB" , rz_sae().vcvtpd2udq(ymm15, zmm19)); + TEST_INSTRUCTION("6271FC487939" , vcvtpd2udq(ymm15, zmmword_ptr(rcx))); + TEST_INSTRUCTION("6231FC4879BCF023010000" , vcvtpd2udq(ymm15, zmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("6271FC587939" , vcvtpd2udq(ymm15, qword_ptr(rcx)._1to8())); + TEST_INSTRUCTION("6271FC48797A7F" , vcvtpd2udq(ymm15, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("6271FC4879BA00200000" , vcvtpd2udq(ymm15, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("6271FC48797A80" , vcvtpd2udq(ymm15, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("6271FC4879BAC0DFFFFF" , vcvtpd2udq(ymm15, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("6271FC58797A7F" , vcvtpd2udq(ymm15, qword_ptr(rdx, 1016)._1to8())); + TEST_INSTRUCTION("6271FC5879BA00040000" , vcvtpd2udq(ymm15, qword_ptr(rdx, 1024)._1to8())); + TEST_INSTRUCTION("6271FC58797A80" , vcvtpd2udq(ymm15, qword_ptr(rdx, -1024)._1to8())); + TEST_INSTRUCTION("6271FC5879BAF8FBFFFF" , vcvtpd2udq(ymm15, qword_ptr(rdx, -1032)._1to8())); + TEST_INSTRUCTION("62127D4813EB" , vcvtph2ps(zmm13, ymm27)); + TEST_INSTRUCTION("62127D4B13EB" , k(k3).vcvtph2ps(zmm13, ymm27)); + TEST_INSTRUCTION("62127DCB13EB" , k(k3).z().vcvtph2ps(zmm13, ymm27)); + TEST_INSTRUCTION("62127D1813EB" , sae().vcvtph2ps(zmm13, ymm27)); + TEST_INSTRUCTION("62727D481329" , vcvtph2ps(zmm13, ymmword_ptr(rcx))); + TEST_INSTRUCTION("62327D4813ACF023010000" , vcvtph2ps(zmm13, ymmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62727D48136A7F" , vcvtph2ps(zmm13, ymmword_ptr(rdx, 4064))); + TEST_INSTRUCTION("62727D4813AA00100000" , vcvtph2ps(zmm13, ymmword_ptr(rdx, 4096))); + TEST_INSTRUCTION("62727D48136A80" , vcvtph2ps(zmm13, ymmword_ptr(rdx, -4096))); + TEST_INSTRUCTION("62727D4813AAE0EFFFFF" , vcvtph2ps(zmm13, ymmword_ptr(rdx, -4128))); + TEST_INSTRUCTION("62117D485BE0" , vcvtps2dq(zmm12, zmm24)); + TEST_INSTRUCTION("62117D4C5BE0" , k(k4).vcvtps2dq(zmm12, zmm24)); + TEST_INSTRUCTION("62117DCC5BE0" , k(k4).z().vcvtps2dq(zmm12, zmm24)); + TEST_INSTRUCTION("62117D185BE0" , rn_sae().vcvtps2dq(zmm12, zmm24)); + TEST_INSTRUCTION("62117D585BE0" , ru_sae().vcvtps2dq(zmm12, zmm24)); + TEST_INSTRUCTION("62117D385BE0" , rd_sae().vcvtps2dq(zmm12, zmm24)); + TEST_INSTRUCTION("62117D785BE0" , rz_sae().vcvtps2dq(zmm12, zmm24)); + TEST_INSTRUCTION("62717D485B21" , vcvtps2dq(zmm12, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62317D485BA4F023010000" , vcvtps2dq(zmm12, zmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62717D585B21" , vcvtps2dq(zmm12, dword_ptr(rcx)._1to16())); + TEST_INSTRUCTION("62717D485B627F" , vcvtps2dq(zmm12, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62717D485BA200200000" , vcvtps2dq(zmm12, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62717D485B6280" , vcvtps2dq(zmm12, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62717D485BA2C0DFFFFF" , vcvtps2dq(zmm12, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62717D585B627F" , vcvtps2dq(zmm12, dword_ptr(rdx, 508)._1to16())); + TEST_INSTRUCTION("62717D585BA200020000" , vcvtps2dq(zmm12, dword_ptr(rdx, 512)._1to16())); + TEST_INSTRUCTION("62717D585B6280" , vcvtps2dq(zmm12, dword_ptr(rdx, -512)._1to16())); + TEST_INSTRUCTION("62717D585BA2FCFDFFFF" , vcvtps2dq(zmm12, dword_ptr(rdx, -516)._1to16())); + TEST_INSTRUCTION("62717C485AEE" , vcvtps2pd(zmm13, ymm6)); + TEST_INSTRUCTION("62717C4B5AEE" , k(k3).vcvtps2pd(zmm13, ymm6)); + TEST_INSTRUCTION("62717CCB5AEE" , k(k3).z().vcvtps2pd(zmm13, ymm6)); + TEST_INSTRUCTION("62717C185AEE" , sae().vcvtps2pd(zmm13, ymm6)); + TEST_INSTRUCTION("62717C485A29" , vcvtps2pd(zmm13, ymmword_ptr(rcx))); + TEST_INSTRUCTION("62317C485AACF023010000" , vcvtps2pd(zmm13, ymmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62717C585A29" , vcvtps2pd(zmm13, dword_ptr(rcx)._1to8())); + TEST_INSTRUCTION("62717C485A6A7F" , vcvtps2pd(zmm13, ymmword_ptr(rdx, 4064))); + TEST_INSTRUCTION("62717C485AAA00100000" , vcvtps2pd(zmm13, ymmword_ptr(rdx, 4096))); + TEST_INSTRUCTION("62717C485A6A80" , vcvtps2pd(zmm13, ymmword_ptr(rdx, -4096))); + TEST_INSTRUCTION("62717C485AAAE0EFFFFF" , vcvtps2pd(zmm13, ymmword_ptr(rdx, -4128))); + TEST_INSTRUCTION("62717C585A6A7F" , vcvtps2pd(zmm13, dword_ptr(rdx, 508)._1to8())); + TEST_INSTRUCTION("62717C585AAA00020000" , vcvtps2pd(zmm13, dword_ptr(rdx, 512)._1to8())); + TEST_INSTRUCTION("62717C585A6A80" , vcvtps2pd(zmm13, dword_ptr(rdx, -512)._1to8())); + TEST_INSTRUCTION("62717C585AAAFCFDFFFF" , vcvtps2pd(zmm13, dword_ptr(rdx, -516)._1to8())); + TEST_INSTRUCTION("62537D481DF3AB" , vcvtps2ph(ymm11, zmm14, 171)); + TEST_INSTRUCTION("62537D4E1DF3AB" , k(k6).vcvtps2ph(ymm11, zmm14, 171)); + TEST_INSTRUCTION("62537DCE1DF3AB" , k(k6).z().vcvtps2ph(ymm11, zmm14, 171)); + TEST_INSTRUCTION("62537D181DF3AB" , sae().vcvtps2ph(ymm11, zmm14, 171)); + TEST_INSTRUCTION("62537D481DF37B" , vcvtps2ph(ymm11, zmm14, 123)); + TEST_INSTRUCTION("62537D181DF37B" , sae().vcvtps2ph(ymm11, zmm14, 123)); + TEST_INSTRUCTION("62117C4879E2" , vcvtps2udq(zmm12, zmm26)); + TEST_INSTRUCTION("62117C4C79E2" , k(k4).vcvtps2udq(zmm12, zmm26)); + TEST_INSTRUCTION("62117CCC79E2" , k(k4).z().vcvtps2udq(zmm12, zmm26)); + TEST_INSTRUCTION("62117C1879E2" , rn_sae().vcvtps2udq(zmm12, zmm26)); + TEST_INSTRUCTION("62117C5879E2" , ru_sae().vcvtps2udq(zmm12, zmm26)); + TEST_INSTRUCTION("62117C3879E2" , rd_sae().vcvtps2udq(zmm12, zmm26)); + TEST_INSTRUCTION("62117C7879E2" , rz_sae().vcvtps2udq(zmm12, zmm26)); + TEST_INSTRUCTION("62717C487921" , vcvtps2udq(zmm12, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62317C4879A4F023010000" , vcvtps2udq(zmm12, zmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62717C587921" , vcvtps2udq(zmm12, dword_ptr(rcx)._1to16())); + TEST_INSTRUCTION("62717C4879627F" , vcvtps2udq(zmm12, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62717C4879A200200000" , vcvtps2udq(zmm12, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62717C48796280" , vcvtps2udq(zmm12, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62717C4879A2C0DFFFFF" , vcvtps2udq(zmm12, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62717C5879627F" , vcvtps2udq(zmm12, dword_ptr(rdx, 508)._1to16())); + TEST_INSTRUCTION("62717C5879A200020000" , vcvtps2udq(zmm12, dword_ptr(rdx, 512)._1to16())); + TEST_INSTRUCTION("62717C58796280" , vcvtps2udq(zmm12, dword_ptr(rdx, -512)._1to16())); + TEST_INSTRUCTION("62717C5879A2FCFDFFFF" , vcvtps2udq(zmm12, dword_ptr(rdx, -516)._1to16())); + TEST_INSTRUCTION("62F17F182DC7" , rn_sae().vcvtsd2si(eax, xmm7)); + TEST_INSTRUCTION("62F17F582DC7" , ru_sae().vcvtsd2si(eax, xmm7)); + TEST_INSTRUCTION("62F17F382DC7" , rd_sae().vcvtsd2si(eax, xmm7)); + TEST_INSTRUCTION("62F17F782DC7" , rz_sae().vcvtsd2si(eax, xmm7)); + TEST_INSTRUCTION("62F17F182DEF" , rn_sae().vcvtsd2si(ebp, xmm7)); + TEST_INSTRUCTION("62F17F582DEF" , ru_sae().vcvtsd2si(ebp, xmm7)); + TEST_INSTRUCTION("62F17F382DEF" , rd_sae().vcvtsd2si(ebp, xmm7)); + TEST_INSTRUCTION("62F17F782DEF" , rz_sae().vcvtsd2si(ebp, xmm7)); + TEST_INSTRUCTION("62717F182DEF" , rn_sae().vcvtsd2si(r13d, xmm7)); + TEST_INSTRUCTION("62717F582DEF" , ru_sae().vcvtsd2si(r13d, xmm7)); + TEST_INSTRUCTION("62717F382DEF" , rd_sae().vcvtsd2si(r13d, xmm7)); + TEST_INSTRUCTION("62717F782DEF" , rz_sae().vcvtsd2si(r13d, xmm7)); + TEST_INSTRUCTION("62D1FF182DC2" , rn_sae().vcvtsd2si(rax, xmm10)); + TEST_INSTRUCTION("62D1FF582DC2" , ru_sae().vcvtsd2si(rax, xmm10)); + TEST_INSTRUCTION("62D1FF382DC2" , rd_sae().vcvtsd2si(rax, xmm10)); + TEST_INSTRUCTION("62D1FF782DC2" , rz_sae().vcvtsd2si(rax, xmm10)); + TEST_INSTRUCTION("6251FF182DC2" , rn_sae().vcvtsd2si(r8, xmm10)); + TEST_INSTRUCTION("6251FF582DC2" , ru_sae().vcvtsd2si(r8, xmm10)); + TEST_INSTRUCTION("6251FF382DC2" , rd_sae().vcvtsd2si(r8, xmm10)); + TEST_INSTRUCTION("6251FF782DC2" , rz_sae().vcvtsd2si(r8, xmm10)); + TEST_INSTRUCTION("62C1B7085ACC" , vcvtsd2ss(xmm17, xmm9, xmm12)); + TEST_INSTRUCTION("62C1B70E5ACC" , k(k6).vcvtsd2ss(xmm17, xmm9, xmm12)); + TEST_INSTRUCTION("62C1B78E5ACC" , k(k6).z().vcvtsd2ss(xmm17, xmm9, xmm12)); + TEST_INSTRUCTION("62C1B7185ACC" , rn_sae().vcvtsd2ss(xmm17, xmm9, xmm12)); + TEST_INSTRUCTION("62C1B7585ACC" , ru_sae().vcvtsd2ss(xmm17, xmm9, xmm12)); + TEST_INSTRUCTION("62C1B7385ACC" , rd_sae().vcvtsd2ss(xmm17, xmm9, xmm12)); + TEST_INSTRUCTION("62C1B7785ACC" , rz_sae().vcvtsd2ss(xmm17, xmm9, xmm12)); + TEST_INSTRUCTION("62E1B7085A09" , vcvtsd2ss(xmm17, xmm9, qword_ptr(rcx))); + TEST_INSTRUCTION("62A1B7085A8CF023010000" , vcvtsd2ss(xmm17, xmm9, qword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62E1B7085A4A7F" , vcvtsd2ss(xmm17, xmm9, qword_ptr(rdx, 1016))); + TEST_INSTRUCTION("62E1B7085A8A00040000" , vcvtsd2ss(xmm17, xmm9, qword_ptr(rdx, 1024))); + TEST_INSTRUCTION("62E1B7085A4A80" , vcvtsd2ss(xmm17, xmm9, qword_ptr(rdx, -1024))); + TEST_INSTRUCTION("62E1B7085A8AF8FBFFFF" , vcvtsd2ss(xmm17, xmm9, qword_ptr(rdx, -1032))); + TEST_INSTRUCTION("C5AB2AF8" , vcvtsi2sd(xmm7, xmm10, eax)); + TEST_INSTRUCTION("C5AB2AFD" , vcvtsi2sd(xmm7, xmm10, ebp)); + TEST_INSTRUCTION("C4C12B2AFD" , vcvtsi2sd(xmm7, xmm10, r13d)); + TEST_INSTRUCTION("C5AB2A39" , vcvtsi2sd(xmm7, xmm10, dword_ptr(rcx))); + TEST_INSTRUCTION("C4A12B2ABCF023010000" , vcvtsi2sd(xmm7, xmm10, dword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("C5AB2ABAFC010000" , vcvtsi2sd(xmm7, xmm10, dword_ptr(rdx, 508))); + TEST_INSTRUCTION("C5AB2ABA00020000" , vcvtsi2sd(xmm7, xmm10, dword_ptr(rdx, 512))); + TEST_INSTRUCTION("C5AB2ABA00FEFFFF" , vcvtsi2sd(xmm7, xmm10, dword_ptr(rdx, -512))); + TEST_INSTRUCTION("C5AB2ABAFCFDFFFF" , vcvtsi2sd(xmm7, xmm10, dword_ptr(rdx, -516))); + TEST_INSTRUCTION("62619F082AE8" , vcvtsi2sd(xmm29, xmm12, rax)); + TEST_INSTRUCTION("62619F182AE8" , rn_sae().vcvtsi2sd(xmm29, xmm12, rax)); + TEST_INSTRUCTION("62619F582AE8" , ru_sae().vcvtsi2sd(xmm29, xmm12, rax)); + TEST_INSTRUCTION("62619F382AE8" , rd_sae().vcvtsi2sd(xmm29, xmm12, rax)); + TEST_INSTRUCTION("62619F782AE8" , rz_sae().vcvtsi2sd(xmm29, xmm12, rax)); + TEST_INSTRUCTION("62419F082AE8" , vcvtsi2sd(xmm29, xmm12, r8)); + TEST_INSTRUCTION("62419F182AE8" , rn_sae().vcvtsi2sd(xmm29, xmm12, r8)); + TEST_INSTRUCTION("62419F582AE8" , ru_sae().vcvtsi2sd(xmm29, xmm12, r8)); + TEST_INSTRUCTION("62419F382AE8" , rd_sae().vcvtsi2sd(xmm29, xmm12, r8)); + TEST_INSTRUCTION("62419F782AE8" , rz_sae().vcvtsi2sd(xmm29, xmm12, r8)); + TEST_INSTRUCTION("62619F082A29" , vcvtsi2sd(xmm29, xmm12, qword_ptr(rcx))); + TEST_INSTRUCTION("62219F082AACF023010000" , vcvtsi2sd(xmm29, xmm12, qword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62619F082A6A7F" , vcvtsi2sd(xmm29, xmm12, qword_ptr(rdx, 1016))); + TEST_INSTRUCTION("62619F082AAA00040000" , vcvtsi2sd(xmm29, xmm12, qword_ptr(rdx, 1024))); + TEST_INSTRUCTION("62619F082A6A80" , vcvtsi2sd(xmm29, xmm12, qword_ptr(rdx, -1024))); + TEST_INSTRUCTION("62619F082AAAF8FBFFFF" , vcvtsi2sd(xmm29, xmm12, qword_ptr(rdx, -1032))); + TEST_INSTRUCTION("C52A2AF8" , vcvtsi2ss(xmm15, xmm10, eax)); + TEST_INSTRUCTION("62712E182AF8" , rn_sae().vcvtsi2ss(xmm15, xmm10, eax)); + TEST_INSTRUCTION("62712E582AF8" , ru_sae().vcvtsi2ss(xmm15, xmm10, eax)); + TEST_INSTRUCTION("62712E382AF8" , rd_sae().vcvtsi2ss(xmm15, xmm10, eax)); + TEST_INSTRUCTION("62712E782AF8" , rz_sae().vcvtsi2ss(xmm15, xmm10, eax)); + TEST_INSTRUCTION("C52A2AFD" , vcvtsi2ss(xmm15, xmm10, ebp)); + TEST_INSTRUCTION("62712E182AFD" , rn_sae().vcvtsi2ss(xmm15, xmm10, ebp)); + TEST_INSTRUCTION("62712E582AFD" , ru_sae().vcvtsi2ss(xmm15, xmm10, ebp)); + TEST_INSTRUCTION("62712E382AFD" , rd_sae().vcvtsi2ss(xmm15, xmm10, ebp)); + TEST_INSTRUCTION("62712E782AFD" , rz_sae().vcvtsi2ss(xmm15, xmm10, ebp)); + TEST_INSTRUCTION("C4412A2AFD" , vcvtsi2ss(xmm15, xmm10, r13d)); + TEST_INSTRUCTION("62512E182AFD" , rn_sae().vcvtsi2ss(xmm15, xmm10, r13d)); + TEST_INSTRUCTION("62512E582AFD" , ru_sae().vcvtsi2ss(xmm15, xmm10, r13d)); + TEST_INSTRUCTION("62512E382AFD" , rd_sae().vcvtsi2ss(xmm15, xmm10, r13d)); + TEST_INSTRUCTION("62512E782AFD" , rz_sae().vcvtsi2ss(xmm15, xmm10, r13d)); + TEST_INSTRUCTION("C52A2A39" , vcvtsi2ss(xmm15, xmm10, dword_ptr(rcx))); + TEST_INSTRUCTION("C4212A2ABCF023010000" , vcvtsi2ss(xmm15, xmm10, dword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("C52A2ABAFC010000" , vcvtsi2ss(xmm15, xmm10, dword_ptr(rdx, 508))); + TEST_INSTRUCTION("C52A2ABA00020000" , vcvtsi2ss(xmm15, xmm10, dword_ptr(rdx, 512))); + TEST_INSTRUCTION("C52A2ABA00FEFFFF" , vcvtsi2ss(xmm15, xmm10, dword_ptr(rdx, -512))); + TEST_INSTRUCTION("C52A2ABAFCFDFFFF" , vcvtsi2ss(xmm15, xmm10, dword_ptr(rdx, -516))); + TEST_INSTRUCTION("62E1AE082AC0" , vcvtsi2ss(xmm16, xmm10, rax)); + TEST_INSTRUCTION("62E1AE182AC0" , rn_sae().vcvtsi2ss(xmm16, xmm10, rax)); + TEST_INSTRUCTION("62E1AE582AC0" , ru_sae().vcvtsi2ss(xmm16, xmm10, rax)); + TEST_INSTRUCTION("62E1AE382AC0" , rd_sae().vcvtsi2ss(xmm16, xmm10, rax)); + TEST_INSTRUCTION("62E1AE782AC0" , rz_sae().vcvtsi2ss(xmm16, xmm10, rax)); + TEST_INSTRUCTION("62C1AE082AC0" , vcvtsi2ss(xmm16, xmm10, r8)); + TEST_INSTRUCTION("62C1AE182AC0" , rn_sae().vcvtsi2ss(xmm16, xmm10, r8)); + TEST_INSTRUCTION("62C1AE582AC0" , ru_sae().vcvtsi2ss(xmm16, xmm10, r8)); + TEST_INSTRUCTION("62C1AE382AC0" , rd_sae().vcvtsi2ss(xmm16, xmm10, r8)); + TEST_INSTRUCTION("62C1AE782AC0" , rz_sae().vcvtsi2ss(xmm16, xmm10, r8)); + TEST_INSTRUCTION("62E1AE082A01" , vcvtsi2ss(xmm16, xmm10, qword_ptr(rcx))); + TEST_INSTRUCTION("62A1AE082A84F023010000" , vcvtsi2ss(xmm16, xmm10, qword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62E1AE082A427F" , vcvtsi2ss(xmm16, xmm10, qword_ptr(rdx, 1016))); + TEST_INSTRUCTION("62E1AE082A8200040000" , vcvtsi2ss(xmm16, xmm10, qword_ptr(rdx, 1024))); + TEST_INSTRUCTION("62E1AE082A4280" , vcvtsi2ss(xmm16, xmm10, qword_ptr(rdx, -1024))); + TEST_INSTRUCTION("62E1AE082A82F8FBFFFF" , vcvtsi2ss(xmm16, xmm10, qword_ptr(rdx, -1032))); + TEST_INSTRUCTION("62614E085AE6" , vcvtss2sd(xmm28, xmm6, xmm6)); + TEST_INSTRUCTION("62614E0B5AE6" , k(k3).vcvtss2sd(xmm28, xmm6, xmm6)); + TEST_INSTRUCTION("62614E8B5AE6" , k(k3).z().vcvtss2sd(xmm28, xmm6, xmm6)); + TEST_INSTRUCTION("62614E185AE6" , sae().vcvtss2sd(xmm28, xmm6, xmm6)); + TEST_INSTRUCTION("62614E085A21" , vcvtss2sd(xmm28, xmm6, dword_ptr(rcx))); + TEST_INSTRUCTION("62214E085AA4F023010000" , vcvtss2sd(xmm28, xmm6, dword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62614E085A627F" , vcvtss2sd(xmm28, xmm6, dword_ptr(rdx, 508))); + TEST_INSTRUCTION("62614E085AA200020000" , vcvtss2sd(xmm28, xmm6, dword_ptr(rdx, 512))); + TEST_INSTRUCTION("62614E085A6280" , vcvtss2sd(xmm28, xmm6, dword_ptr(rdx, -512))); + TEST_INSTRUCTION("62614E085AA2FCFDFFFF" , vcvtss2sd(xmm28, xmm6, dword_ptr(rdx, -516))); + TEST_INSTRUCTION("62B17E182DC6" , rn_sae().vcvtss2si(eax, xmm22)); + TEST_INSTRUCTION("62B17E582DC6" , ru_sae().vcvtss2si(eax, xmm22)); + TEST_INSTRUCTION("62B17E382DC6" , rd_sae().vcvtss2si(eax, xmm22)); + TEST_INSTRUCTION("62B17E782DC6" , rz_sae().vcvtss2si(eax, xmm22)); + TEST_INSTRUCTION("62B17E182DEE" , rn_sae().vcvtss2si(ebp, xmm22)); + TEST_INSTRUCTION("62B17E582DEE" , ru_sae().vcvtss2si(ebp, xmm22)); + TEST_INSTRUCTION("62B17E382DEE" , rd_sae().vcvtss2si(ebp, xmm22)); + TEST_INSTRUCTION("62B17E782DEE" , rz_sae().vcvtss2si(ebp, xmm22)); + TEST_INSTRUCTION("62317E182DEE" , rn_sae().vcvtss2si(r13d, xmm22)); + TEST_INSTRUCTION("62317E582DEE" , ru_sae().vcvtss2si(r13d, xmm22)); + TEST_INSTRUCTION("62317E382DEE" , rd_sae().vcvtss2si(r13d, xmm22)); + TEST_INSTRUCTION("62317E782DEE" , rz_sae().vcvtss2si(r13d, xmm22)); + TEST_INSTRUCTION("6291FE182DC5" , rn_sae().vcvtss2si(rax, xmm29)); + TEST_INSTRUCTION("6291FE582DC5" , ru_sae().vcvtss2si(rax, xmm29)); + TEST_INSTRUCTION("6291FE382DC5" , rd_sae().vcvtss2si(rax, xmm29)); + TEST_INSTRUCTION("6291FE782DC5" , rz_sae().vcvtss2si(rax, xmm29)); + TEST_INSTRUCTION("6211FE182DC5" , rn_sae().vcvtss2si(r8, xmm29)); + TEST_INSTRUCTION("6211FE582DC5" , ru_sae().vcvtss2si(r8, xmm29)); + TEST_INSTRUCTION("6211FE382DC5" , rd_sae().vcvtss2si(r8, xmm29)); + TEST_INSTRUCTION("6211FE782DC5" , rz_sae().vcvtss2si(r8, xmm29)); + TEST_INSTRUCTION("6241FD48E6D9" , vcvttpd2dq(ymm27, zmm9)); + TEST_INSTRUCTION("6241FD4DE6D9" , k(k5).vcvttpd2dq(ymm27, zmm9)); + TEST_INSTRUCTION("6241FDCDE6D9" , k(k5).z().vcvttpd2dq(ymm27, zmm9)); + TEST_INSTRUCTION("6241FD18E6D9" , sae().vcvttpd2dq(ymm27, zmm9)); + TEST_INSTRUCTION("6261FD48E619" , vcvttpd2dq(ymm27, zmmword_ptr(rcx))); + TEST_INSTRUCTION("6221FD48E69CF023010000" , vcvttpd2dq(ymm27, zmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("6261FD58E619" , vcvttpd2dq(ymm27, qword_ptr(rcx)._1to8())); + TEST_INSTRUCTION("6261FD48E65A7F" , vcvttpd2dq(ymm27, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("6261FD48E69A00200000" , vcvttpd2dq(ymm27, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("6261FD48E65A80" , vcvttpd2dq(ymm27, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("6261FD48E69AC0DFFFFF" , vcvttpd2dq(ymm27, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("6261FD58E65A7F" , vcvttpd2dq(ymm27, qword_ptr(rdx, 1016)._1to8())); + TEST_INSTRUCTION("6261FD58E69A00040000" , vcvttpd2dq(ymm27, qword_ptr(rdx, 1024)._1to8())); + TEST_INSTRUCTION("6261FD58E65A80" , vcvttpd2dq(ymm27, qword_ptr(rdx, -1024)._1to8())); + TEST_INSTRUCTION("6261FD58E69AF8FBFFFF" , vcvttpd2dq(ymm27, qword_ptr(rdx, -1032)._1to8())); + TEST_INSTRUCTION("62117E485BF1" , vcvttps2dq(zmm14, zmm25)); + TEST_INSTRUCTION("62117E4B5BF1" , k(k3).vcvttps2dq(zmm14, zmm25)); + TEST_INSTRUCTION("62117ECB5BF1" , k(k3).z().vcvttps2dq(zmm14, zmm25)); + TEST_INSTRUCTION("62117E185BF1" , sae().vcvttps2dq(zmm14, zmm25)); + TEST_INSTRUCTION("62717E485B31" , vcvttps2dq(zmm14, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62317E485BB4F023010000" , vcvttps2dq(zmm14, zmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62717E585B31" , vcvttps2dq(zmm14, dword_ptr(rcx)._1to16())); + TEST_INSTRUCTION("62717E485B727F" , vcvttps2dq(zmm14, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62717E485BB200200000" , vcvttps2dq(zmm14, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62717E485B7280" , vcvttps2dq(zmm14, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62717E485BB2C0DFFFFF" , vcvttps2dq(zmm14, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62717E585B727F" , vcvttps2dq(zmm14, dword_ptr(rdx, 508)._1to16())); + TEST_INSTRUCTION("62717E585BB200020000" , vcvttps2dq(zmm14, dword_ptr(rdx, 512)._1to16())); + TEST_INSTRUCTION("62717E585B7280" , vcvttps2dq(zmm14, dword_ptr(rdx, -512)._1to16())); + TEST_INSTRUCTION("62717E585BB2FCFDFFFF" , vcvttps2dq(zmm14, dword_ptr(rdx, -516)._1to16())); + TEST_INSTRUCTION("62F17F182CC3" , sae().vcvttsd2si(eax, xmm3)); + TEST_INSTRUCTION("62F17F182CEB" , sae().vcvttsd2si(ebp, xmm3)); + TEST_INSTRUCTION("62717F182CEB" , sae().vcvttsd2si(r13d, xmm3)); + TEST_INSTRUCTION("62F1FF182CC1" , sae().vcvttsd2si(rax, xmm1)); + TEST_INSTRUCTION("6271FF182CC1" , sae().vcvttsd2si(r8, xmm1)); + TEST_INSTRUCTION("62D17E182CC6" , sae().vcvttss2si(eax, xmm14)); + TEST_INSTRUCTION("62D17E182CEE" , sae().vcvttss2si(ebp, xmm14)); + TEST_INSTRUCTION("62517E182CEE" , sae().vcvttss2si(r13d, xmm14)); + TEST_INSTRUCTION("62B1FE182CC5" , sae().vcvttss2si(rax, xmm21)); + TEST_INSTRUCTION("6231FE182CC5" , sae().vcvttss2si(r8, xmm21)); + TEST_INSTRUCTION("62C17E487AD6" , vcvtudq2pd(zmm18, ymm14)); + TEST_INSTRUCTION("62C17E4B7AD6" , k(k3).vcvtudq2pd(zmm18, ymm14)); + TEST_INSTRUCTION("62C17ECB7AD6" , k(k3).z().vcvtudq2pd(zmm18, ymm14)); + TEST_INSTRUCTION("62E17E487A11" , vcvtudq2pd(zmm18, ymmword_ptr(rcx))); + TEST_INSTRUCTION("62A17E487A94F023010000" , vcvtudq2pd(zmm18, ymmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62E17E587A11" , vcvtudq2pd(zmm18, dword_ptr(rcx)._1to8())); + TEST_INSTRUCTION("62E17E487A527F" , vcvtudq2pd(zmm18, ymmword_ptr(rdx, 4064))); + TEST_INSTRUCTION("62E17E487A9200100000" , vcvtudq2pd(zmm18, ymmword_ptr(rdx, 4096))); + TEST_INSTRUCTION("62E17E487A5280" , vcvtudq2pd(zmm18, ymmword_ptr(rdx, -4096))); + TEST_INSTRUCTION("62E17E487A92E0EFFFFF" , vcvtudq2pd(zmm18, ymmword_ptr(rdx, -4128))); + TEST_INSTRUCTION("62E17E587A527F" , vcvtudq2pd(zmm18, dword_ptr(rdx, 508)._1to8())); + TEST_INSTRUCTION("62E17E587A9200020000" , vcvtudq2pd(zmm18, dword_ptr(rdx, 512)._1to8())); + TEST_INSTRUCTION("62E17E587A5280" , vcvtudq2pd(zmm18, dword_ptr(rdx, -512)._1to8())); + TEST_INSTRUCTION("62E17E587A92FCFDFFFF" , vcvtudq2pd(zmm18, dword_ptr(rdx, -516)._1to8())); + TEST_INSTRUCTION("62E17F487AD7" , vcvtudq2ps(zmm18, zmm7)); + TEST_INSTRUCTION("62E17F4A7AD7" , k(k2).vcvtudq2ps(zmm18, zmm7)); + TEST_INSTRUCTION("62E17FCA7AD7" , k(k2).z().vcvtudq2ps(zmm18, zmm7)); + TEST_INSTRUCTION("62E17F187AD7" , rn_sae().vcvtudq2ps(zmm18, zmm7)); + TEST_INSTRUCTION("62E17F587AD7" , ru_sae().vcvtudq2ps(zmm18, zmm7)); + TEST_INSTRUCTION("62E17F387AD7" , rd_sae().vcvtudq2ps(zmm18, zmm7)); + TEST_INSTRUCTION("62E17F787AD7" , rz_sae().vcvtudq2ps(zmm18, zmm7)); + TEST_INSTRUCTION("62E17F487A11" , vcvtudq2ps(zmm18, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62A17F487A94F023010000" , vcvtudq2ps(zmm18, zmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62E17F587A11" , vcvtudq2ps(zmm18, dword_ptr(rcx)._1to16())); + TEST_INSTRUCTION("62E17F487A527F" , vcvtudq2ps(zmm18, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62E17F487A9200200000" , vcvtudq2ps(zmm18, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62E17F487A5280" , vcvtudq2ps(zmm18, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62E17F487A92C0DFFFFF" , vcvtudq2ps(zmm18, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62E17F587A527F" , vcvtudq2ps(zmm18, dword_ptr(rdx, 508)._1to16())); + TEST_INSTRUCTION("62E17F587A9200020000" , vcvtudq2ps(zmm18, dword_ptr(rdx, 512)._1to16())); + TEST_INSTRUCTION("62E17F587A5280" , vcvtudq2ps(zmm18, dword_ptr(rdx, -512)._1to16())); + TEST_INSTRUCTION("62E17F587A92FCFDFFFF" , vcvtudq2ps(zmm18, dword_ptr(rdx, -516)._1to16())); + TEST_INSTRUCTION("62C1CD485ED3" , vdivpd(zmm18, zmm6, zmm11)); + TEST_INSTRUCTION("62C1CD4C5ED3" , k(k4).vdivpd(zmm18, zmm6, zmm11)); + TEST_INSTRUCTION("62C1CDCC5ED3" , k(k4).z().vdivpd(zmm18, zmm6, zmm11)); + TEST_INSTRUCTION("62C1CD185ED3" , rn_sae().vdivpd(zmm18, zmm6, zmm11)); + TEST_INSTRUCTION("62C1CD585ED3" , ru_sae().vdivpd(zmm18, zmm6, zmm11)); + TEST_INSTRUCTION("62C1CD385ED3" , rd_sae().vdivpd(zmm18, zmm6, zmm11)); + TEST_INSTRUCTION("62C1CD785ED3" , rz_sae().vdivpd(zmm18, zmm6, zmm11)); + TEST_INSTRUCTION("62E1CD485E11" , vdivpd(zmm18, zmm6, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62A1CD485E94F023010000" , vdivpd(zmm18, zmm6, zmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62E1CD585E11" , vdivpd(zmm18, zmm6, qword_ptr(rcx)._1to8())); + TEST_INSTRUCTION("62E1CD485E527F" , vdivpd(zmm18, zmm6, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62E1CD485E9200200000" , vdivpd(zmm18, zmm6, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62E1CD485E5280" , vdivpd(zmm18, zmm6, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62E1CD485E92C0DFFFFF" , vdivpd(zmm18, zmm6, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62E1CD585E527F" , vdivpd(zmm18, zmm6, qword_ptr(rdx, 1016)._1to8())); + TEST_INSTRUCTION("62E1CD585E9200040000" , vdivpd(zmm18, zmm6, qword_ptr(rdx, 1024)._1to8())); + TEST_INSTRUCTION("62E1CD585E5280" , vdivpd(zmm18, zmm6, qword_ptr(rdx, -1024)._1to8())); + TEST_INSTRUCTION("62E1CD585E92F8FBFFFF" , vdivpd(zmm18, zmm6, qword_ptr(rdx, -1032)._1to8())); + TEST_INSTRUCTION("628144405EFC" , vdivps(zmm23, zmm23, zmm28)); + TEST_INSTRUCTION("628144425EFC" , k(k2).vdivps(zmm23, zmm23, zmm28)); + TEST_INSTRUCTION("628144C25EFC" , k(k2).z().vdivps(zmm23, zmm23, zmm28)); + TEST_INSTRUCTION("628144105EFC" , rn_sae().vdivps(zmm23, zmm23, zmm28)); + TEST_INSTRUCTION("628144505EFC" , ru_sae().vdivps(zmm23, zmm23, zmm28)); + TEST_INSTRUCTION("628144305EFC" , rd_sae().vdivps(zmm23, zmm23, zmm28)); + TEST_INSTRUCTION("628144705EFC" , rz_sae().vdivps(zmm23, zmm23, zmm28)); + TEST_INSTRUCTION("62E144405E39" , vdivps(zmm23, zmm23, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62A144405EBCF023010000" , vdivps(zmm23, zmm23, zmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62E144505E39" , vdivps(zmm23, zmm23, dword_ptr(rcx)._1to16())); + TEST_INSTRUCTION("62E144405E7A7F" , vdivps(zmm23, zmm23, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62E144405EBA00200000" , vdivps(zmm23, zmm23, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62E144405E7A80" , vdivps(zmm23, zmm23, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62E144405EBAC0DFFFFF" , vdivps(zmm23, zmm23, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62E144505E7A7F" , vdivps(zmm23, zmm23, dword_ptr(rdx, 508)._1to16())); + TEST_INSTRUCTION("62E144505EBA00020000" , vdivps(zmm23, zmm23, dword_ptr(rdx, 512)._1to16())); + TEST_INSTRUCTION("62E144505E7A80" , vdivps(zmm23, zmm23, dword_ptr(rdx, -512)._1to16())); + TEST_INSTRUCTION("62E144505EBAFCFDFFFF" , vdivps(zmm23, zmm23, dword_ptr(rdx, -516)._1to16())); + TEST_INSTRUCTION("622197085EEE" , vdivsd(xmm29, xmm13, xmm22)); + TEST_INSTRUCTION("6221970B5EEE" , k(k3).vdivsd(xmm29, xmm13, xmm22)); + TEST_INSTRUCTION("6221978B5EEE" , k(k3).z().vdivsd(xmm29, xmm13, xmm22)); + TEST_INSTRUCTION("622197185EEE" , rn_sae().vdivsd(xmm29, xmm13, xmm22)); + TEST_INSTRUCTION("622197585EEE" , ru_sae().vdivsd(xmm29, xmm13, xmm22)); + TEST_INSTRUCTION("622197385EEE" , rd_sae().vdivsd(xmm29, xmm13, xmm22)); + TEST_INSTRUCTION("622197785EEE" , rz_sae().vdivsd(xmm29, xmm13, xmm22)); + TEST_INSTRUCTION("626197085E29" , vdivsd(xmm29, xmm13, qword_ptr(rcx))); + TEST_INSTRUCTION("622197085EACF023010000" , vdivsd(xmm29, xmm13, qword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("626197085E6A7F" , vdivsd(xmm29, xmm13, qword_ptr(rdx, 1016))); + TEST_INSTRUCTION("626197085EAA00040000" , vdivsd(xmm29, xmm13, qword_ptr(rdx, 1024))); + TEST_INSTRUCTION("626197085E6A80" , vdivsd(xmm29, xmm13, qword_ptr(rdx, -1024))); + TEST_INSTRUCTION("626197085EAAF8FBFFFF" , vdivsd(xmm29, xmm13, qword_ptr(rdx, -1032))); + TEST_INSTRUCTION("62A14E085EE9" , vdivss(xmm21, xmm6, xmm17)); + TEST_INSTRUCTION("62A14E0D5EE9" , k(k5).vdivss(xmm21, xmm6, xmm17)); + TEST_INSTRUCTION("62A14E8D5EE9" , k(k5).z().vdivss(xmm21, xmm6, xmm17)); + TEST_INSTRUCTION("62A14E185EE9" , rn_sae().vdivss(xmm21, xmm6, xmm17)); + TEST_INSTRUCTION("62A14E585EE9" , ru_sae().vdivss(xmm21, xmm6, xmm17)); + TEST_INSTRUCTION("62A14E385EE9" , rd_sae().vdivss(xmm21, xmm6, xmm17)); + TEST_INSTRUCTION("62A14E785EE9" , rz_sae().vdivss(xmm21, xmm6, xmm17)); + TEST_INSTRUCTION("62E14E085E29" , vdivss(xmm21, xmm6, dword_ptr(rcx))); + TEST_INSTRUCTION("62A14E085EACF023010000" , vdivss(xmm21, xmm6, dword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62E14E085E6A7F" , vdivss(xmm21, xmm6, dword_ptr(rdx, 508))); + TEST_INSTRUCTION("62E14E085EAA00020000" , vdivss(xmm21, xmm6, dword_ptr(rdx, 512))); + TEST_INSTRUCTION("62E14E085E6A80" , vdivss(xmm21, xmm6, dword_ptr(rdx, -512))); + TEST_INSTRUCTION("62E14E085EAAFCFDFFFF" , vdivss(xmm21, xmm6, dword_ptr(rdx, -516))); + TEST_INSTRUCTION("6262FD488801" , vexpandpd(zmm24, zmmword_ptr(rcx))); + TEST_INSTRUCTION("6262FD4C8801" , k(k4).vexpandpd(zmm24, zmmword_ptr(rcx))); + TEST_INSTRUCTION("6262FDCC8801" , k(k4).z().vexpandpd(zmm24, zmmword_ptr(rcx))); + TEST_INSTRUCTION("6222FD488884F023010000" , vexpandpd(zmm24, zmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("6262FD4888427F" , vexpandpd(zmm24, zmmword_ptr(rdx, 1016))); + TEST_INSTRUCTION("6262FD48888200040000" , vexpandpd(zmm24, zmmword_ptr(rdx, 1024))); + TEST_INSTRUCTION("6262FD48884280" , vexpandpd(zmm24, zmmword_ptr(rdx, -1024))); + TEST_INSTRUCTION("6262FD488882F8FBFFFF" , vexpandpd(zmm24, zmmword_ptr(rdx, -1032))); + TEST_INSTRUCTION("62C2FD4888FF" , vexpandpd(zmm23, zmm15)); + TEST_INSTRUCTION("62C2FD4D88FF" , k(k5).vexpandpd(zmm23, zmm15)); + TEST_INSTRUCTION("62C2FDCD88FF" , k(k5).z().vexpandpd(zmm23, zmm15)); + TEST_INSTRUCTION("62F27D488821" , vexpandps(zmm4, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62F27D4E8821" , k(k6).vexpandps(zmm4, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62F27DCE8821" , k(k6).z().vexpandps(zmm4, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62B27D4888A4F023010000" , vexpandps(zmm4, zmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62F27D4888627F" , vexpandps(zmm4, zmmword_ptr(rdx, 508))); + TEST_INSTRUCTION("62F27D4888A200020000" , vexpandps(zmm4, zmmword_ptr(rdx, 512))); + TEST_INSTRUCTION("62F27D48886280" , vexpandps(zmm4, zmmword_ptr(rdx, -512))); + TEST_INSTRUCTION("62F27D4888A2FCFDFFFF" , vexpandps(zmm4, zmmword_ptr(rdx, -516))); + TEST_INSTRUCTION("62527D4888F1" , vexpandps(zmm14, zmm9)); + TEST_INSTRUCTION("62527D4A88F1" , k(k2).vexpandps(zmm14, zmm9)); + TEST_INSTRUCTION("62527DCA88F1" , k(k2).z().vexpandps(zmm14, zmm9)); + TEST_INSTRUCTION("62C37D4819EFAB" , vextractf32x4(xmm15, zmm21, 171)); + TEST_INSTRUCTION("62C37D4919EFAB" , k(k1).vextractf32x4(xmm15, zmm21, 171)); + TEST_INSTRUCTION("62C37DC919EFAB" , k(k1).z().vextractf32x4(xmm15, zmm21, 171)); + TEST_INSTRUCTION("62C37D4819EF7B" , vextractf32x4(xmm15, zmm21, 123)); + TEST_INSTRUCTION("6243FD481BC3AB" , vextractf64x4(ymm11, zmm24, 171)); + TEST_INSTRUCTION("6243FD4D1BC3AB" , k(k5).vextractf64x4(ymm11, zmm24, 171)); + TEST_INSTRUCTION("6243FDCD1BC3AB" , k(k5).z().vextractf64x4(ymm11, zmm24, 171)); + TEST_INSTRUCTION("6243FD481BC37B" , vextractf64x4(ymm11, zmm24, 123)); + TEST_INSTRUCTION("62C37D4839C5AB" , vextracti32x4(xmm13, zmm16, 171)); + TEST_INSTRUCTION("62C37D4D39C5AB" , k(k5).vextracti32x4(xmm13, zmm16, 171)); + TEST_INSTRUCTION("62C37DCD39C5AB" , k(k5).z().vextracti32x4(xmm13, zmm16, 171)); + TEST_INSTRUCTION("62C37D4839C57B" , vextracti32x4(xmm13, zmm16, 123)); + TEST_INSTRUCTION("62C3FD483BC5AB" , vextracti64x4(ymm13, zmm16, 171)); + TEST_INSTRUCTION("62C3FD4B3BC5AB" , k(k3).vextracti64x4(ymm13, zmm16, 171)); + TEST_INSTRUCTION("62C3FDCB3BC5AB" , k(k3).z().vextracti64x4(ymm13, zmm16, 171)); + TEST_INSTRUCTION("62C3FD483BC57B" , vextracti64x4(ymm13, zmm16, 123)); + TEST_INSTRUCTION("62637D0817C0AB" , vextractps(eax, xmm24, 171)); + TEST_INSTRUCTION("62637D0817C07B" , vextractps(eax, xmm24, 123)); + TEST_INSTRUCTION("62437D0817C07B" , vextractps(r8d, xmm24, 123)); + TEST_INSTRUCTION("62637D0817017B" , vextractps(dword_ptr(rcx), xmm24, 123)); + TEST_INSTRUCTION("62237D081784F0230100007B" , vextractps(dword_ptr(rax, r14, 3, 291), xmm24, 123)); + TEST_INSTRUCTION("62637D0817427F7B" , vextractps(dword_ptr(rdx, 508), xmm24, 123)); + TEST_INSTRUCTION("62637D081782000200007B" , vextractps(dword_ptr(rdx, 512), xmm24, 123)); + TEST_INSTRUCTION("62637D081742807B" , vextractps(dword_ptr(rdx, -512), xmm24, 123)); + TEST_INSTRUCTION("62637D081782FCFDFFFF7B" , vextractps(dword_ptr(rdx, -516), xmm24, 123)); + TEST_INSTRUCTION("6222FD4098D5" , vfmadd132pd(zmm26, zmm16, zmm21)); + TEST_INSTRUCTION("6222FD4598D5" , k(k5).vfmadd132pd(zmm26, zmm16, zmm21)); + TEST_INSTRUCTION("6222FDC598D5" , k(k5).z().vfmadd132pd(zmm26, zmm16, zmm21)); + TEST_INSTRUCTION("6222FD1098D5" , rn_sae().vfmadd132pd(zmm26, zmm16, zmm21)); + TEST_INSTRUCTION("6222FD5098D5" , ru_sae().vfmadd132pd(zmm26, zmm16, zmm21)); + TEST_INSTRUCTION("6222FD3098D5" , rd_sae().vfmadd132pd(zmm26, zmm16, zmm21)); + TEST_INSTRUCTION("6222FD7098D5" , rz_sae().vfmadd132pd(zmm26, zmm16, zmm21)); + TEST_INSTRUCTION("6262FD409811" , vfmadd132pd(zmm26, zmm16, zmmword_ptr(rcx))); + TEST_INSTRUCTION("6222FD409894F023010000" , vfmadd132pd(zmm26, zmm16, zmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("6262FD509811" , vfmadd132pd(zmm26, zmm16, qword_ptr(rcx)._1to8())); + TEST_INSTRUCTION("6262FD4098527F" , vfmadd132pd(zmm26, zmm16, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("6262FD40989200200000" , vfmadd132pd(zmm26, zmm16, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("6262FD40985280" , vfmadd132pd(zmm26, zmm16, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("6262FD409892C0DFFFFF" , vfmadd132pd(zmm26, zmm16, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("6262FD5098527F" , vfmadd132pd(zmm26, zmm16, qword_ptr(rdx, 1016)._1to8())); + TEST_INSTRUCTION("6262FD50989200040000" , vfmadd132pd(zmm26, zmm16, qword_ptr(rdx, 1024)._1to8())); + TEST_INSTRUCTION("6262FD50985280" , vfmadd132pd(zmm26, zmm16, qword_ptr(rdx, -1024)._1to8())); + TEST_INSTRUCTION("6262FD509892F8FBFFFF" , vfmadd132pd(zmm26, zmm16, qword_ptr(rdx, -1032)._1to8())); + TEST_INSTRUCTION("62925D4098C9" , vfmadd132ps(zmm1, zmm20, zmm25)); + TEST_INSTRUCTION("62925D4198C9" , k(k1).vfmadd132ps(zmm1, zmm20, zmm25)); + TEST_INSTRUCTION("62925DC198C9" , k(k1).z().vfmadd132ps(zmm1, zmm20, zmm25)); + TEST_INSTRUCTION("62925D1098C9" , rn_sae().vfmadd132ps(zmm1, zmm20, zmm25)); + TEST_INSTRUCTION("62925D5098C9" , ru_sae().vfmadd132ps(zmm1, zmm20, zmm25)); + TEST_INSTRUCTION("62925D3098C9" , rd_sae().vfmadd132ps(zmm1, zmm20, zmm25)); + TEST_INSTRUCTION("62925D7098C9" , rz_sae().vfmadd132ps(zmm1, zmm20, zmm25)); + TEST_INSTRUCTION("62F25D409809" , vfmadd132ps(zmm1, zmm20, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62B25D40988CF023010000" , vfmadd132ps(zmm1, zmm20, zmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62F25D509809" , vfmadd132ps(zmm1, zmm20, dword_ptr(rcx)._1to16())); + TEST_INSTRUCTION("62F25D40984A7F" , vfmadd132ps(zmm1, zmm20, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62F25D40988A00200000" , vfmadd132ps(zmm1, zmm20, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62F25D40984A80" , vfmadd132ps(zmm1, zmm20, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62F25D40988AC0DFFFFF" , vfmadd132ps(zmm1, zmm20, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62F25D50984A7F" , vfmadd132ps(zmm1, zmm20, dword_ptr(rdx, 508)._1to16())); + TEST_INSTRUCTION("62F25D50988A00020000" , vfmadd132ps(zmm1, zmm20, dword_ptr(rdx, 512)._1to16())); + TEST_INSTRUCTION("62F25D50984A80" , vfmadd132ps(zmm1, zmm20, dword_ptr(rdx, -512)._1to16())); + TEST_INSTRUCTION("62F25D50988AFCFDFFFF" , vfmadd132ps(zmm1, zmm20, dword_ptr(rdx, -516)._1to16())); + TEST_INSTRUCTION("6262F50099E3" , vfmadd132sd(xmm28, xmm17, xmm3)); + TEST_INSTRUCTION("6262F50299E3" , k(k2).vfmadd132sd(xmm28, xmm17, xmm3)); + TEST_INSTRUCTION("6262F58299E3" , k(k2).z().vfmadd132sd(xmm28, xmm17, xmm3)); + TEST_INSTRUCTION("6262F51099E3" , rn_sae().vfmadd132sd(xmm28, xmm17, xmm3)); + TEST_INSTRUCTION("6262F55099E3" , ru_sae().vfmadd132sd(xmm28, xmm17, xmm3)); + TEST_INSTRUCTION("6262F53099E3" , rd_sae().vfmadd132sd(xmm28, xmm17, xmm3)); + TEST_INSTRUCTION("6262F57099E3" , rz_sae().vfmadd132sd(xmm28, xmm17, xmm3)); + TEST_INSTRUCTION("6262F5009921" , vfmadd132sd(xmm28, xmm17, qword_ptr(rcx))); + TEST_INSTRUCTION("6222F50099A4F023010000" , vfmadd132sd(xmm28, xmm17, qword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("6262F50099627F" , vfmadd132sd(xmm28, xmm17, qword_ptr(rdx, 1016))); + TEST_INSTRUCTION("6262F50099A200040000" , vfmadd132sd(xmm28, xmm17, qword_ptr(rdx, 1024))); + TEST_INSTRUCTION("6262F500996280" , vfmadd132sd(xmm28, xmm17, qword_ptr(rdx, -1024))); + TEST_INSTRUCTION("6262F50099A2F8FBFFFF" , vfmadd132sd(xmm28, xmm17, qword_ptr(rdx, -1032))); + TEST_INSTRUCTION("6222750099F6" , vfmadd132ss(xmm30, xmm17, xmm22)); + TEST_INSTRUCTION("6222750399F6" , k(k3).vfmadd132ss(xmm30, xmm17, xmm22)); + TEST_INSTRUCTION("6222758399F6" , k(k3).z().vfmadd132ss(xmm30, xmm17, xmm22)); + TEST_INSTRUCTION("6222751099F6" , rn_sae().vfmadd132ss(xmm30, xmm17, xmm22)); + TEST_INSTRUCTION("6222755099F6" , ru_sae().vfmadd132ss(xmm30, xmm17, xmm22)); + TEST_INSTRUCTION("6222753099F6" , rd_sae().vfmadd132ss(xmm30, xmm17, xmm22)); + TEST_INSTRUCTION("6222757099F6" , rz_sae().vfmadd132ss(xmm30, xmm17, xmm22)); + TEST_INSTRUCTION("626275009931" , vfmadd132ss(xmm30, xmm17, dword_ptr(rcx))); + TEST_INSTRUCTION("6222750099B4F023010000" , vfmadd132ss(xmm30, xmm17, dword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("6262750099727F" , vfmadd132ss(xmm30, xmm17, dword_ptr(rdx, 508))); + TEST_INSTRUCTION("6262750099B200020000" , vfmadd132ss(xmm30, xmm17, dword_ptr(rdx, 512))); + TEST_INSTRUCTION("62627500997280" , vfmadd132ss(xmm30, xmm17, dword_ptr(rdx, -512))); + TEST_INSTRUCTION("6262750099B2FCFDFFFF" , vfmadd132ss(xmm30, xmm17, dword_ptr(rdx, -516))); + TEST_INSTRUCTION("6282FD40A8D1" , vfmadd213pd(zmm18, zmm16, zmm25)); + TEST_INSTRUCTION("6282FD43A8D1" , k(k3).vfmadd213pd(zmm18, zmm16, zmm25)); + TEST_INSTRUCTION("6282FDC3A8D1" , k(k3).z().vfmadd213pd(zmm18, zmm16, zmm25)); + TEST_INSTRUCTION("6282FD10A8D1" , rn_sae().vfmadd213pd(zmm18, zmm16, zmm25)); + TEST_INSTRUCTION("6282FD50A8D1" , ru_sae().vfmadd213pd(zmm18, zmm16, zmm25)); + TEST_INSTRUCTION("6282FD30A8D1" , rd_sae().vfmadd213pd(zmm18, zmm16, zmm25)); + TEST_INSTRUCTION("6282FD70A8D1" , rz_sae().vfmadd213pd(zmm18, zmm16, zmm25)); + TEST_INSTRUCTION("62E2FD40A811" , vfmadd213pd(zmm18, zmm16, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62A2FD40A894F023010000" , vfmadd213pd(zmm18, zmm16, zmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62E2FD50A811" , vfmadd213pd(zmm18, zmm16, qword_ptr(rcx)._1to8())); + TEST_INSTRUCTION("62E2FD40A8527F" , vfmadd213pd(zmm18, zmm16, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62E2FD40A89200200000" , vfmadd213pd(zmm18, zmm16, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62E2FD40A85280" , vfmadd213pd(zmm18, zmm16, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62E2FD40A892C0DFFFFF" , vfmadd213pd(zmm18, zmm16, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62E2FD50A8527F" , vfmadd213pd(zmm18, zmm16, qword_ptr(rdx, 1016)._1to8())); + TEST_INSTRUCTION("62E2FD50A89200040000" , vfmadd213pd(zmm18, zmm16, qword_ptr(rdx, 1024)._1to8())); + TEST_INSTRUCTION("62E2FD50A85280" , vfmadd213pd(zmm18, zmm16, qword_ptr(rdx, -1024)._1to8())); + TEST_INSTRUCTION("62E2FD50A892F8FBFFFF" , vfmadd213pd(zmm18, zmm16, qword_ptr(rdx, -1032)._1to8())); + TEST_INSTRUCTION("62C26540A8E6" , vfmadd213ps(zmm20, zmm19, zmm14)); + TEST_INSTRUCTION("62C26544A8E6" , k(k4).vfmadd213ps(zmm20, zmm19, zmm14)); + TEST_INSTRUCTION("62C265C4A8E6" , k(k4).z().vfmadd213ps(zmm20, zmm19, zmm14)); + TEST_INSTRUCTION("62C26510A8E6" , rn_sae().vfmadd213ps(zmm20, zmm19, zmm14)); + TEST_INSTRUCTION("62C26550A8E6" , ru_sae().vfmadd213ps(zmm20, zmm19, zmm14)); + TEST_INSTRUCTION("62C26530A8E6" , rd_sae().vfmadd213ps(zmm20, zmm19, zmm14)); + TEST_INSTRUCTION("62C26570A8E6" , rz_sae().vfmadd213ps(zmm20, zmm19, zmm14)); + TEST_INSTRUCTION("62E26540A821" , vfmadd213ps(zmm20, zmm19, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62A26540A8A4F023010000" , vfmadd213ps(zmm20, zmm19, zmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62E26550A821" , vfmadd213ps(zmm20, zmm19, dword_ptr(rcx)._1to16())); + TEST_INSTRUCTION("62E26540A8627F" , vfmadd213ps(zmm20, zmm19, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62E26540A8A200200000" , vfmadd213ps(zmm20, zmm19, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62E26540A86280" , vfmadd213ps(zmm20, zmm19, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62E26540A8A2C0DFFFFF" , vfmadd213ps(zmm20, zmm19, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62E26550A8627F" , vfmadd213ps(zmm20, zmm19, dword_ptr(rdx, 508)._1to16())); + TEST_INSTRUCTION("62E26550A8A200020000" , vfmadd213ps(zmm20, zmm19, dword_ptr(rdx, 512)._1to16())); + TEST_INSTRUCTION("62E26550A86280" , vfmadd213ps(zmm20, zmm19, dword_ptr(rdx, -512)._1to16())); + TEST_INSTRUCTION("62E26550A8A2FCFDFFFF" , vfmadd213ps(zmm20, zmm19, dword_ptr(rdx, -516)._1to16())); + TEST_INSTRUCTION("6242AD00A9C5" , vfmadd213sd(xmm24, xmm26, xmm13)); + TEST_INSTRUCTION("6242AD03A9C5" , k(k3).vfmadd213sd(xmm24, xmm26, xmm13)); + TEST_INSTRUCTION("6242AD83A9C5" , k(k3).z().vfmadd213sd(xmm24, xmm26, xmm13)); + TEST_INSTRUCTION("6242AD10A9C5" , rn_sae().vfmadd213sd(xmm24, xmm26, xmm13)); + TEST_INSTRUCTION("6242AD50A9C5" , ru_sae().vfmadd213sd(xmm24, xmm26, xmm13)); + TEST_INSTRUCTION("6242AD30A9C5" , rd_sae().vfmadd213sd(xmm24, xmm26, xmm13)); + TEST_INSTRUCTION("6242AD70A9C5" , rz_sae().vfmadd213sd(xmm24, xmm26, xmm13)); + TEST_INSTRUCTION("6262AD00A901" , vfmadd213sd(xmm24, xmm26, qword_ptr(rcx))); + TEST_INSTRUCTION("6222AD00A984F023010000" , vfmadd213sd(xmm24, xmm26, qword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("6262AD00A9427F" , vfmadd213sd(xmm24, xmm26, qword_ptr(rdx, 1016))); + TEST_INSTRUCTION("6262AD00A98200040000" , vfmadd213sd(xmm24, xmm26, qword_ptr(rdx, 1024))); + TEST_INSTRUCTION("6262AD00A94280" , vfmadd213sd(xmm24, xmm26, qword_ptr(rdx, -1024))); + TEST_INSTRUCTION("6262AD00A982F8FBFFFF" , vfmadd213sd(xmm24, xmm26, qword_ptr(rdx, -1032))); + TEST_INSTRUCTION("62224D00A9F0" , vfmadd213ss(xmm30, xmm22, xmm16)); + TEST_INSTRUCTION("62224D01A9F0" , k(k1).vfmadd213ss(xmm30, xmm22, xmm16)); + TEST_INSTRUCTION("62224D81A9F0" , k(k1).z().vfmadd213ss(xmm30, xmm22, xmm16)); + TEST_INSTRUCTION("62224D10A9F0" , rn_sae().vfmadd213ss(xmm30, xmm22, xmm16)); + TEST_INSTRUCTION("62224D50A9F0" , ru_sae().vfmadd213ss(xmm30, xmm22, xmm16)); + TEST_INSTRUCTION("62224D30A9F0" , rd_sae().vfmadd213ss(xmm30, xmm22, xmm16)); + TEST_INSTRUCTION("62224D70A9F0" , rz_sae().vfmadd213ss(xmm30, xmm22, xmm16)); + TEST_INSTRUCTION("62624D00A931" , vfmadd213ss(xmm30, xmm22, dword_ptr(rcx))); + TEST_INSTRUCTION("62224D00A9B4F023010000" , vfmadd213ss(xmm30, xmm22, dword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62624D00A9727F" , vfmadd213ss(xmm30, xmm22, dword_ptr(rdx, 508))); + TEST_INSTRUCTION("62624D00A9B200020000" , vfmadd213ss(xmm30, xmm22, dword_ptr(rdx, 512))); + TEST_INSTRUCTION("62624D00A97280" , vfmadd213ss(xmm30, xmm22, dword_ptr(rdx, -512))); + TEST_INSTRUCTION("62624D00A9B2FCFDFFFF" , vfmadd213ss(xmm30, xmm22, dword_ptr(rdx, -516))); + TEST_INSTRUCTION("6242CD48B8F1" , vfmadd231pd(zmm30, zmm6, zmm9)); + TEST_INSTRUCTION("6242CD4CB8F1" , k(k4).vfmadd231pd(zmm30, zmm6, zmm9)); + TEST_INSTRUCTION("6242CDCCB8F1" , k(k4).z().vfmadd231pd(zmm30, zmm6, zmm9)); + TEST_INSTRUCTION("6242CD18B8F1" , rn_sae().vfmadd231pd(zmm30, zmm6, zmm9)); + TEST_INSTRUCTION("6242CD58B8F1" , ru_sae().vfmadd231pd(zmm30, zmm6, zmm9)); + TEST_INSTRUCTION("6242CD38B8F1" , rd_sae().vfmadd231pd(zmm30, zmm6, zmm9)); + TEST_INSTRUCTION("6242CD78B8F1" , rz_sae().vfmadd231pd(zmm30, zmm6, zmm9)); + TEST_INSTRUCTION("6262CD48B831" , vfmadd231pd(zmm30, zmm6, zmmword_ptr(rcx))); + TEST_INSTRUCTION("6222CD48B8B4F023010000" , vfmadd231pd(zmm30, zmm6, zmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("6262CD58B831" , vfmadd231pd(zmm30, zmm6, qword_ptr(rcx)._1to8())); + TEST_INSTRUCTION("6262CD48B8727F" , vfmadd231pd(zmm30, zmm6, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("6262CD48B8B200200000" , vfmadd231pd(zmm30, zmm6, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("6262CD48B87280" , vfmadd231pd(zmm30, zmm6, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("6262CD48B8B2C0DFFFFF" , vfmadd231pd(zmm30, zmm6, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("6262CD58B8727F" , vfmadd231pd(zmm30, zmm6, qword_ptr(rdx, 1016)._1to8())); + TEST_INSTRUCTION("6262CD58B8B200040000" , vfmadd231pd(zmm30, zmm6, qword_ptr(rdx, 1024)._1to8())); + TEST_INSTRUCTION("6262CD58B87280" , vfmadd231pd(zmm30, zmm6, qword_ptr(rdx, -1024)._1to8())); + TEST_INSTRUCTION("6262CD58B8B2F8FBFFFF" , vfmadd231pd(zmm30, zmm6, qword_ptr(rdx, -1032)._1to8())); + TEST_INSTRUCTION("62021D40B8D9" , vfmadd231ps(zmm27, zmm28, zmm25)); + TEST_INSTRUCTION("62021D43B8D9" , k(k3).vfmadd231ps(zmm27, zmm28, zmm25)); + TEST_INSTRUCTION("62021DC3B8D9" , k(k3).z().vfmadd231ps(zmm27, zmm28, zmm25)); + TEST_INSTRUCTION("62021D10B8D9" , rn_sae().vfmadd231ps(zmm27, zmm28, zmm25)); + TEST_INSTRUCTION("62021D50B8D9" , ru_sae().vfmadd231ps(zmm27, zmm28, zmm25)); + TEST_INSTRUCTION("62021D30B8D9" , rd_sae().vfmadd231ps(zmm27, zmm28, zmm25)); + TEST_INSTRUCTION("62021D70B8D9" , rz_sae().vfmadd231ps(zmm27, zmm28, zmm25)); + TEST_INSTRUCTION("62621D40B819" , vfmadd231ps(zmm27, zmm28, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62221D40B89CF023010000" , vfmadd231ps(zmm27, zmm28, zmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62621D50B819" , vfmadd231ps(zmm27, zmm28, dword_ptr(rcx)._1to16())); + TEST_INSTRUCTION("62621D40B85A7F" , vfmadd231ps(zmm27, zmm28, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62621D40B89A00200000" , vfmadd231ps(zmm27, zmm28, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62621D40B85A80" , vfmadd231ps(zmm27, zmm28, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62621D40B89AC0DFFFFF" , vfmadd231ps(zmm27, zmm28, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62621D50B85A7F" , vfmadd231ps(zmm27, zmm28, dword_ptr(rdx, 508)._1to16())); + TEST_INSTRUCTION("62621D50B89A00020000" , vfmadd231ps(zmm27, zmm28, dword_ptr(rdx, 512)._1to16())); + TEST_INSTRUCTION("62621D50B85A80" , vfmadd231ps(zmm27, zmm28, dword_ptr(rdx, -512)._1to16())); + TEST_INSTRUCTION("62621D50B89AFCFDFFFF" , vfmadd231ps(zmm27, zmm28, dword_ptr(rdx, -516)._1to16())); + TEST_INSTRUCTION("C4C2F1B9E6" , vfmadd231sd(xmm4, xmm1, xmm14)); + TEST_INSTRUCTION("62D2F509B9E6" , k(k1).vfmadd231sd(xmm4, xmm1, xmm14)); + TEST_INSTRUCTION("62D2F589B9E6" , k(k1).z().vfmadd231sd(xmm4, xmm1, xmm14)); + TEST_INSTRUCTION("62D2F518B9E6" , rn_sae().vfmadd231sd(xmm4, xmm1, xmm14)); + TEST_INSTRUCTION("62D2F558B9E6" , ru_sae().vfmadd231sd(xmm4, xmm1, xmm14)); + TEST_INSTRUCTION("62D2F538B9E6" , rd_sae().vfmadd231sd(xmm4, xmm1, xmm14)); + TEST_INSTRUCTION("62D2F578B9E6" , rz_sae().vfmadd231sd(xmm4, xmm1, xmm14)); + TEST_INSTRUCTION("C4E2F1B921" , vfmadd231sd(xmm4, xmm1, qword_ptr(rcx))); + TEST_INSTRUCTION("C4A2F1B9A4F023010000" , vfmadd231sd(xmm4, xmm1, qword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("C4E2F1B9A2F8030000" , vfmadd231sd(xmm4, xmm1, qword_ptr(rdx, 1016))); + TEST_INSTRUCTION("C4E2F1B9A200040000" , vfmadd231sd(xmm4, xmm1, qword_ptr(rdx, 1024))); + TEST_INSTRUCTION("C4E2F1B9A200FCFFFF" , vfmadd231sd(xmm4, xmm1, qword_ptr(rdx, -1024))); + TEST_INSTRUCTION("C4E2F1B9A2F8FBFFFF" , vfmadd231sd(xmm4, xmm1, qword_ptr(rdx, -1032))); + TEST_INSTRUCTION("62420508B9EA" , vfmadd231ss(xmm29, xmm15, xmm10)); + TEST_INSTRUCTION("6242050CB9EA" , k(k4).vfmadd231ss(xmm29, xmm15, xmm10)); + TEST_INSTRUCTION("6242058CB9EA" , k(k4).z().vfmadd231ss(xmm29, xmm15, xmm10)); + TEST_INSTRUCTION("62420518B9EA" , rn_sae().vfmadd231ss(xmm29, xmm15, xmm10)); + TEST_INSTRUCTION("62420558B9EA" , ru_sae().vfmadd231ss(xmm29, xmm15, xmm10)); + TEST_INSTRUCTION("62420538B9EA" , rd_sae().vfmadd231ss(xmm29, xmm15, xmm10)); + TEST_INSTRUCTION("62420578B9EA" , rz_sae().vfmadd231ss(xmm29, xmm15, xmm10)); + TEST_INSTRUCTION("62620508B929" , vfmadd231ss(xmm29, xmm15, dword_ptr(rcx))); + TEST_INSTRUCTION("62220508B9ACF023010000" , vfmadd231ss(xmm29, xmm15, dword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62620508B96A7F" , vfmadd231ss(xmm29, xmm15, dword_ptr(rdx, 508))); + TEST_INSTRUCTION("62620508B9AA00020000" , vfmadd231ss(xmm29, xmm15, dword_ptr(rdx, 512))); + TEST_INSTRUCTION("62620508B96A80" , vfmadd231ss(xmm29, xmm15, dword_ptr(rdx, -512))); + TEST_INSTRUCTION("62620508B9AAFCFDFFFF" , vfmadd231ss(xmm29, xmm15, dword_ptr(rdx, -516))); + TEST_INSTRUCTION("62A2B54096E5" , vfmaddsub132pd(zmm20, zmm25, zmm21)); + TEST_INSTRUCTION("62A2B54296E5" , k(k2).vfmaddsub132pd(zmm20, zmm25, zmm21)); + TEST_INSTRUCTION("62A2B5C296E5" , k(k2).z().vfmaddsub132pd(zmm20, zmm25, zmm21)); + TEST_INSTRUCTION("62A2B51096E5" , rn_sae().vfmaddsub132pd(zmm20, zmm25, zmm21)); + TEST_INSTRUCTION("62A2B55096E5" , ru_sae().vfmaddsub132pd(zmm20, zmm25, zmm21)); + TEST_INSTRUCTION("62A2B53096E5" , rd_sae().vfmaddsub132pd(zmm20, zmm25, zmm21)); + TEST_INSTRUCTION("62A2B57096E5" , rz_sae().vfmaddsub132pd(zmm20, zmm25, zmm21)); + TEST_INSTRUCTION("62E2B5409621" , vfmaddsub132pd(zmm20, zmm25, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62A2B54096A4F023010000" , vfmaddsub132pd(zmm20, zmm25, zmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62E2B5509621" , vfmaddsub132pd(zmm20, zmm25, qword_ptr(rcx)._1to8())); + TEST_INSTRUCTION("62E2B54096627F" , vfmaddsub132pd(zmm20, zmm25, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62E2B54096A200200000" , vfmaddsub132pd(zmm20, zmm25, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62E2B540966280" , vfmaddsub132pd(zmm20, zmm25, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62E2B54096A2C0DFFFFF" , vfmaddsub132pd(zmm20, zmm25, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62E2B55096627F" , vfmaddsub132pd(zmm20, zmm25, qword_ptr(rdx, 1016)._1to8())); + TEST_INSTRUCTION("62E2B55096A200040000" , vfmaddsub132pd(zmm20, zmm25, qword_ptr(rdx, 1024)._1to8())); + TEST_INSTRUCTION("62E2B550966280" , vfmaddsub132pd(zmm20, zmm25, qword_ptr(rdx, -1024)._1to8())); + TEST_INSTRUCTION("62E2B55096A2F8FBFFFF" , vfmaddsub132pd(zmm20, zmm25, qword_ptr(rdx, -1032)._1to8())); + TEST_INSTRUCTION("6232354896D4" , vfmaddsub132ps(zmm10, zmm9, zmm20)); + TEST_INSTRUCTION("6232354B96D4" , k(k3).vfmaddsub132ps(zmm10, zmm9, zmm20)); + TEST_INSTRUCTION("623235CB96D4" , k(k3).z().vfmaddsub132ps(zmm10, zmm9, zmm20)); + TEST_INSTRUCTION("6232351896D4" , rn_sae().vfmaddsub132ps(zmm10, zmm9, zmm20)); + TEST_INSTRUCTION("6232355896D4" , ru_sae().vfmaddsub132ps(zmm10, zmm9, zmm20)); + TEST_INSTRUCTION("6232353896D4" , rd_sae().vfmaddsub132ps(zmm10, zmm9, zmm20)); + TEST_INSTRUCTION("6232357896D4" , rz_sae().vfmaddsub132ps(zmm10, zmm9, zmm20)); + TEST_INSTRUCTION("627235489611" , vfmaddsub132ps(zmm10, zmm9, zmmword_ptr(rcx))); + TEST_INSTRUCTION("623235489694F023010000" , vfmaddsub132ps(zmm10, zmm9, zmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("627235589611" , vfmaddsub132ps(zmm10, zmm9, dword_ptr(rcx)._1to16())); + TEST_INSTRUCTION("6272354896527F" , vfmaddsub132ps(zmm10, zmm9, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62723548969200200000" , vfmaddsub132ps(zmm10, zmm9, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62723548965280" , vfmaddsub132ps(zmm10, zmm9, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("627235489692C0DFFFFF" , vfmaddsub132ps(zmm10, zmm9, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("6272355896527F" , vfmaddsub132ps(zmm10, zmm9, dword_ptr(rdx, 508)._1to16())); + TEST_INSTRUCTION("62723558969200020000" , vfmaddsub132ps(zmm10, zmm9, dword_ptr(rdx, 512)._1to16())); + TEST_INSTRUCTION("62723558965280" , vfmaddsub132ps(zmm10, zmm9, dword_ptr(rdx, -512)._1to16())); + TEST_INSTRUCTION("627235589692FCFDFFFF" , vfmaddsub132ps(zmm10, zmm9, dword_ptr(rdx, -516)._1to16())); + TEST_INSTRUCTION("6242CD48A6D2" , vfmaddsub213pd(zmm26, zmm6, zmm10)); + TEST_INSTRUCTION("6242CD4EA6D2" , k(k6).vfmaddsub213pd(zmm26, zmm6, zmm10)); + TEST_INSTRUCTION("6242CDCEA6D2" , k(k6).z().vfmaddsub213pd(zmm26, zmm6, zmm10)); + TEST_INSTRUCTION("6242CD18A6D2" , rn_sae().vfmaddsub213pd(zmm26, zmm6, zmm10)); + TEST_INSTRUCTION("6242CD58A6D2" , ru_sae().vfmaddsub213pd(zmm26, zmm6, zmm10)); + TEST_INSTRUCTION("6242CD38A6D2" , rd_sae().vfmaddsub213pd(zmm26, zmm6, zmm10)); + TEST_INSTRUCTION("6242CD78A6D2" , rz_sae().vfmaddsub213pd(zmm26, zmm6, zmm10)); + TEST_INSTRUCTION("6262CD48A611" , vfmaddsub213pd(zmm26, zmm6, zmmword_ptr(rcx))); + TEST_INSTRUCTION("6222CD48A694F023010000" , vfmaddsub213pd(zmm26, zmm6, zmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("6262CD58A611" , vfmaddsub213pd(zmm26, zmm6, qword_ptr(rcx)._1to8())); + TEST_INSTRUCTION("6262CD48A6527F" , vfmaddsub213pd(zmm26, zmm6, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("6262CD48A69200200000" , vfmaddsub213pd(zmm26, zmm6, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("6262CD48A65280" , vfmaddsub213pd(zmm26, zmm6, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("6262CD48A692C0DFFFFF" , vfmaddsub213pd(zmm26, zmm6, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("6262CD58A6527F" , vfmaddsub213pd(zmm26, zmm6, qword_ptr(rdx, 1016)._1to8())); + TEST_INSTRUCTION("6262CD58A69200040000" , vfmaddsub213pd(zmm26, zmm6, qword_ptr(rdx, 1024)._1to8())); + TEST_INSTRUCTION("6262CD58A65280" , vfmaddsub213pd(zmm26, zmm6, qword_ptr(rdx, -1024)._1to8())); + TEST_INSTRUCTION("6262CD58A692F8FBFFFF" , vfmaddsub213pd(zmm26, zmm6, qword_ptr(rdx, -1032)._1to8())); + TEST_INSTRUCTION("62823D40A6CC" , vfmaddsub213ps(zmm17, zmm24, zmm28)); + TEST_INSTRUCTION("62823D46A6CC" , k(k6).vfmaddsub213ps(zmm17, zmm24, zmm28)); + TEST_INSTRUCTION("62823DC6A6CC" , k(k6).z().vfmaddsub213ps(zmm17, zmm24, zmm28)); + TEST_INSTRUCTION("62823D10A6CC" , rn_sae().vfmaddsub213ps(zmm17, zmm24, zmm28)); + TEST_INSTRUCTION("62823D50A6CC" , ru_sae().vfmaddsub213ps(zmm17, zmm24, zmm28)); + TEST_INSTRUCTION("62823D30A6CC" , rd_sae().vfmaddsub213ps(zmm17, zmm24, zmm28)); + TEST_INSTRUCTION("62823D70A6CC" , rz_sae().vfmaddsub213ps(zmm17, zmm24, zmm28)); + TEST_INSTRUCTION("62E23D40A609" , vfmaddsub213ps(zmm17, zmm24, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62A23D40A68CF023010000" , vfmaddsub213ps(zmm17, zmm24, zmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62E23D50A609" , vfmaddsub213ps(zmm17, zmm24, dword_ptr(rcx)._1to16())); + TEST_INSTRUCTION("62E23D40A64A7F" , vfmaddsub213ps(zmm17, zmm24, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62E23D40A68A00200000" , vfmaddsub213ps(zmm17, zmm24, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62E23D40A64A80" , vfmaddsub213ps(zmm17, zmm24, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62E23D40A68AC0DFFFFF" , vfmaddsub213ps(zmm17, zmm24, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62E23D50A64A7F" , vfmaddsub213ps(zmm17, zmm24, dword_ptr(rdx, 508)._1to16())); + TEST_INSTRUCTION("62E23D50A68A00020000" , vfmaddsub213ps(zmm17, zmm24, dword_ptr(rdx, 512)._1to16())); + TEST_INSTRUCTION("62E23D50A64A80" , vfmaddsub213ps(zmm17, zmm24, dword_ptr(rdx, -512)._1to16())); + TEST_INSTRUCTION("62E23D50A68AFCFDFFFF" , vfmaddsub213ps(zmm17, zmm24, dword_ptr(rdx, -516)._1to16())); + TEST_INSTRUCTION("6212A540B6C8" , vfmaddsub231pd(zmm9, zmm27, zmm24)); + TEST_INSTRUCTION("6212A547B6C8" , k(k7).vfmaddsub231pd(zmm9, zmm27, zmm24)); + TEST_INSTRUCTION("6212A5C7B6C8" , k(k7).z().vfmaddsub231pd(zmm9, zmm27, zmm24)); + TEST_INSTRUCTION("6212A510B6C8" , rn_sae().vfmaddsub231pd(zmm9, zmm27, zmm24)); + TEST_INSTRUCTION("6212A550B6C8" , ru_sae().vfmaddsub231pd(zmm9, zmm27, zmm24)); + TEST_INSTRUCTION("6212A530B6C8" , rd_sae().vfmaddsub231pd(zmm9, zmm27, zmm24)); + TEST_INSTRUCTION("6212A570B6C8" , rz_sae().vfmaddsub231pd(zmm9, zmm27, zmm24)); + TEST_INSTRUCTION("6272A540B609" , vfmaddsub231pd(zmm9, zmm27, zmmword_ptr(rcx))); + TEST_INSTRUCTION("6232A540B68CF023010000" , vfmaddsub231pd(zmm9, zmm27, zmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("6272A550B609" , vfmaddsub231pd(zmm9, zmm27, qword_ptr(rcx)._1to8())); + TEST_INSTRUCTION("6272A540B64A7F" , vfmaddsub231pd(zmm9, zmm27, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("6272A540B68A00200000" , vfmaddsub231pd(zmm9, zmm27, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("6272A540B64A80" , vfmaddsub231pd(zmm9, zmm27, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("6272A540B68AC0DFFFFF" , vfmaddsub231pd(zmm9, zmm27, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("6272A550B64A7F" , vfmaddsub231pd(zmm9, zmm27, qword_ptr(rdx, 1016)._1to8())); + TEST_INSTRUCTION("6272A550B68A00040000" , vfmaddsub231pd(zmm9, zmm27, qword_ptr(rdx, 1024)._1to8())); + TEST_INSTRUCTION("6272A550B64A80" , vfmaddsub231pd(zmm9, zmm27, qword_ptr(rdx, -1024)._1to8())); + TEST_INSTRUCTION("6272A550B68AF8FBFFFF" , vfmaddsub231pd(zmm9, zmm27, qword_ptr(rdx, -1032)._1to8())); + TEST_INSTRUCTION("62325540B6FB" , vfmaddsub231ps(zmm15, zmm21, zmm19)); + TEST_INSTRUCTION("62325546B6FB" , k(k6).vfmaddsub231ps(zmm15, zmm21, zmm19)); + TEST_INSTRUCTION("623255C6B6FB" , k(k6).z().vfmaddsub231ps(zmm15, zmm21, zmm19)); + TEST_INSTRUCTION("62325510B6FB" , rn_sae().vfmaddsub231ps(zmm15, zmm21, zmm19)); + TEST_INSTRUCTION("62325550B6FB" , ru_sae().vfmaddsub231ps(zmm15, zmm21, zmm19)); + TEST_INSTRUCTION("62325530B6FB" , rd_sae().vfmaddsub231ps(zmm15, zmm21, zmm19)); + TEST_INSTRUCTION("62325570B6FB" , rz_sae().vfmaddsub231ps(zmm15, zmm21, zmm19)); + TEST_INSTRUCTION("62725540B639" , vfmaddsub231ps(zmm15, zmm21, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62325540B6BCF023010000" , vfmaddsub231ps(zmm15, zmm21, zmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62725550B639" , vfmaddsub231ps(zmm15, zmm21, dword_ptr(rcx)._1to16())); + TEST_INSTRUCTION("62725540B67A7F" , vfmaddsub231ps(zmm15, zmm21, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62725540B6BA00200000" , vfmaddsub231ps(zmm15, zmm21, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62725540B67A80" , vfmaddsub231ps(zmm15, zmm21, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62725540B6BAC0DFFFFF" , vfmaddsub231ps(zmm15, zmm21, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62725550B67A7F" , vfmaddsub231ps(zmm15, zmm21, dword_ptr(rdx, 508)._1to16())); + TEST_INSTRUCTION("62725550B6BA00020000" , vfmaddsub231ps(zmm15, zmm21, dword_ptr(rdx, 512)._1to16())); + TEST_INSTRUCTION("62725550B67A80" , vfmaddsub231ps(zmm15, zmm21, dword_ptr(rdx, -512)._1to16())); + TEST_INSTRUCTION("62725550B6BAFCFDFFFF" , vfmaddsub231ps(zmm15, zmm21, dword_ptr(rdx, -516)._1to16())); + TEST_INSTRUCTION("62829D489AF3" , vfmsub132pd(zmm22, zmm12, zmm27)); + TEST_INSTRUCTION("62829D4A9AF3" , k(k2).vfmsub132pd(zmm22, zmm12, zmm27)); + TEST_INSTRUCTION("62829DCA9AF3" , k(k2).z().vfmsub132pd(zmm22, zmm12, zmm27)); + TEST_INSTRUCTION("62829D189AF3" , rn_sae().vfmsub132pd(zmm22, zmm12, zmm27)); + TEST_INSTRUCTION("62829D589AF3" , ru_sae().vfmsub132pd(zmm22, zmm12, zmm27)); + TEST_INSTRUCTION("62829D389AF3" , rd_sae().vfmsub132pd(zmm22, zmm12, zmm27)); + TEST_INSTRUCTION("62829D789AF3" , rz_sae().vfmsub132pd(zmm22, zmm12, zmm27)); + TEST_INSTRUCTION("62E29D489A31" , vfmsub132pd(zmm22, zmm12, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62A29D489AB4F023010000" , vfmsub132pd(zmm22, zmm12, zmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62E29D589A31" , vfmsub132pd(zmm22, zmm12, qword_ptr(rcx)._1to8())); + TEST_INSTRUCTION("62E29D489A727F" , vfmsub132pd(zmm22, zmm12, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62E29D489AB200200000" , vfmsub132pd(zmm22, zmm12, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62E29D489A7280" , vfmsub132pd(zmm22, zmm12, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62E29D489AB2C0DFFFFF" , vfmsub132pd(zmm22, zmm12, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62E29D589A727F" , vfmsub132pd(zmm22, zmm12, qword_ptr(rdx, 1016)._1to8())); + TEST_INSTRUCTION("62E29D589AB200040000" , vfmsub132pd(zmm22, zmm12, qword_ptr(rdx, 1024)._1to8())); + TEST_INSTRUCTION("62E29D589A7280" , vfmsub132pd(zmm22, zmm12, qword_ptr(rdx, -1024)._1to8())); + TEST_INSTRUCTION("62E29D589AB2F8FBFFFF" , vfmsub132pd(zmm22, zmm12, qword_ptr(rdx, -1032)._1to8())); + TEST_INSTRUCTION("62B215489AC8" , vfmsub132ps(zmm1, zmm13, zmm16)); + TEST_INSTRUCTION("62B2154C9AC8" , k(k4).vfmsub132ps(zmm1, zmm13, zmm16)); + TEST_INSTRUCTION("62B215CC9AC8" , k(k4).z().vfmsub132ps(zmm1, zmm13, zmm16)); + TEST_INSTRUCTION("62B215189AC8" , rn_sae().vfmsub132ps(zmm1, zmm13, zmm16)); + TEST_INSTRUCTION("62B215589AC8" , ru_sae().vfmsub132ps(zmm1, zmm13, zmm16)); + TEST_INSTRUCTION("62B215389AC8" , rd_sae().vfmsub132ps(zmm1, zmm13, zmm16)); + TEST_INSTRUCTION("62B215789AC8" , rz_sae().vfmsub132ps(zmm1, zmm13, zmm16)); + TEST_INSTRUCTION("62F215489A09" , vfmsub132ps(zmm1, zmm13, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62B215489A8CF023010000" , vfmsub132ps(zmm1, zmm13, zmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62F215589A09" , vfmsub132ps(zmm1, zmm13, dword_ptr(rcx)._1to16())); + TEST_INSTRUCTION("62F215489A4A7F" , vfmsub132ps(zmm1, zmm13, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62F215489A8A00200000" , vfmsub132ps(zmm1, zmm13, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62F215489A4A80" , vfmsub132ps(zmm1, zmm13, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62F215489A8AC0DFFFFF" , vfmsub132ps(zmm1, zmm13, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62F215589A4A7F" , vfmsub132ps(zmm1, zmm13, dword_ptr(rdx, 508)._1to16())); + TEST_INSTRUCTION("62F215589A8A00020000" , vfmsub132ps(zmm1, zmm13, dword_ptr(rdx, 512)._1to16())); + TEST_INSTRUCTION("62F215589A4A80" , vfmsub132ps(zmm1, zmm13, dword_ptr(rdx, -512)._1to16())); + TEST_INSTRUCTION("62F215589A8AFCFDFFFF" , vfmsub132ps(zmm1, zmm13, dword_ptr(rdx, -516)._1to16())); + TEST_INSTRUCTION("6212BD089BE3" , vfmsub132sd(xmm12, xmm8, xmm27)); + TEST_INSTRUCTION("6212BD0B9BE3" , k(k3).vfmsub132sd(xmm12, xmm8, xmm27)); + TEST_INSTRUCTION("6212BD8B9BE3" , k(k3).z().vfmsub132sd(xmm12, xmm8, xmm27)); + TEST_INSTRUCTION("6212BD189BE3" , rn_sae().vfmsub132sd(xmm12, xmm8, xmm27)); + TEST_INSTRUCTION("6212BD589BE3" , ru_sae().vfmsub132sd(xmm12, xmm8, xmm27)); + TEST_INSTRUCTION("6212BD389BE3" , rd_sae().vfmsub132sd(xmm12, xmm8, xmm27)); + TEST_INSTRUCTION("6212BD789BE3" , rz_sae().vfmsub132sd(xmm12, xmm8, xmm27)); + TEST_INSTRUCTION("C462B99B21" , vfmsub132sd(xmm12, xmm8, qword_ptr(rcx))); + TEST_INSTRUCTION("C422B99BA4F023010000" , vfmsub132sd(xmm12, xmm8, qword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("C462B99BA2F8030000" , vfmsub132sd(xmm12, xmm8, qword_ptr(rdx, 1016))); + TEST_INSTRUCTION("C462B99BA200040000" , vfmsub132sd(xmm12, xmm8, qword_ptr(rdx, 1024))); + TEST_INSTRUCTION("C462B99BA200FCFFFF" , vfmsub132sd(xmm12, xmm8, qword_ptr(rdx, -1024))); + TEST_INSTRUCTION("C462B99BA2F8FBFFFF" , vfmsub132sd(xmm12, xmm8, qword_ptr(rdx, -1032))); + TEST_INSTRUCTION("62024D009BF3" , vfmsub132ss(xmm30, xmm22, xmm27)); + TEST_INSTRUCTION("62024D039BF3" , k(k3).vfmsub132ss(xmm30, xmm22, xmm27)); + TEST_INSTRUCTION("62024D839BF3" , k(k3).z().vfmsub132ss(xmm30, xmm22, xmm27)); + TEST_INSTRUCTION("62024D109BF3" , rn_sae().vfmsub132ss(xmm30, xmm22, xmm27)); + TEST_INSTRUCTION("62024D509BF3" , ru_sae().vfmsub132ss(xmm30, xmm22, xmm27)); + TEST_INSTRUCTION("62024D309BF3" , rd_sae().vfmsub132ss(xmm30, xmm22, xmm27)); + TEST_INSTRUCTION("62024D709BF3" , rz_sae().vfmsub132ss(xmm30, xmm22, xmm27)); + TEST_INSTRUCTION("62624D009B31" , vfmsub132ss(xmm30, xmm22, dword_ptr(rcx))); + TEST_INSTRUCTION("62224D009BB4F023010000" , vfmsub132ss(xmm30, xmm22, dword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62624D009B727F" , vfmsub132ss(xmm30, xmm22, dword_ptr(rdx, 508))); + TEST_INSTRUCTION("62624D009BB200020000" , vfmsub132ss(xmm30, xmm22, dword_ptr(rdx, 512))); + TEST_INSTRUCTION("62624D009B7280" , vfmsub132ss(xmm30, xmm22, dword_ptr(rdx, -512))); + TEST_INSTRUCTION("62624D009BB2FCFDFFFF" , vfmsub132ss(xmm30, xmm22, dword_ptr(rdx, -516))); + TEST_INSTRUCTION("62F2AD48AAEC" , vfmsub213pd(zmm5, zmm10, zmm4)); + TEST_INSTRUCTION("62F2AD49AAEC" , k(k1).vfmsub213pd(zmm5, zmm10, zmm4)); + TEST_INSTRUCTION("62F2ADC9AAEC" , k(k1).z().vfmsub213pd(zmm5, zmm10, zmm4)); + TEST_INSTRUCTION("62F2AD18AAEC" , rn_sae().vfmsub213pd(zmm5, zmm10, zmm4)); + TEST_INSTRUCTION("62F2AD58AAEC" , ru_sae().vfmsub213pd(zmm5, zmm10, zmm4)); + TEST_INSTRUCTION("62F2AD38AAEC" , rd_sae().vfmsub213pd(zmm5, zmm10, zmm4)); + TEST_INSTRUCTION("62F2AD78AAEC" , rz_sae().vfmsub213pd(zmm5, zmm10, zmm4)); + TEST_INSTRUCTION("62F2AD48AA29" , vfmsub213pd(zmm5, zmm10, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62B2AD48AAACF023010000" , vfmsub213pd(zmm5, zmm10, zmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62F2AD58AA29" , vfmsub213pd(zmm5, zmm10, qword_ptr(rcx)._1to8())); + TEST_INSTRUCTION("62F2AD48AA6A7F" , vfmsub213pd(zmm5, zmm10, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62F2AD48AAAA00200000" , vfmsub213pd(zmm5, zmm10, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62F2AD48AA6A80" , vfmsub213pd(zmm5, zmm10, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62F2AD48AAAAC0DFFFFF" , vfmsub213pd(zmm5, zmm10, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62F2AD58AA6A7F" , vfmsub213pd(zmm5, zmm10, qword_ptr(rdx, 1016)._1to8())); + TEST_INSTRUCTION("62F2AD58AAAA00040000" , vfmsub213pd(zmm5, zmm10, qword_ptr(rdx, 1024)._1to8())); + TEST_INSTRUCTION("62F2AD58AA6A80" , vfmsub213pd(zmm5, zmm10, qword_ptr(rdx, -1024)._1to8())); + TEST_INSTRUCTION("62F2AD58AAAAF8FBFFFF" , vfmsub213pd(zmm5, zmm10, qword_ptr(rdx, -1032)._1to8())); + TEST_INSTRUCTION("62C24D40AAF2" , vfmsub213ps(zmm22, zmm22, zmm10)); + TEST_INSTRUCTION("62C24D46AAF2" , k(k6).vfmsub213ps(zmm22, zmm22, zmm10)); + TEST_INSTRUCTION("62C24DC6AAF2" , k(k6).z().vfmsub213ps(zmm22, zmm22, zmm10)); + TEST_INSTRUCTION("62C24D10AAF2" , rn_sae().vfmsub213ps(zmm22, zmm22, zmm10)); + TEST_INSTRUCTION("62C24D50AAF2" , ru_sae().vfmsub213ps(zmm22, zmm22, zmm10)); + TEST_INSTRUCTION("62C24D30AAF2" , rd_sae().vfmsub213ps(zmm22, zmm22, zmm10)); + TEST_INSTRUCTION("62C24D70AAF2" , rz_sae().vfmsub213ps(zmm22, zmm22, zmm10)); + TEST_INSTRUCTION("62E24D40AA31" , vfmsub213ps(zmm22, zmm22, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62A24D40AAB4F023010000" , vfmsub213ps(zmm22, zmm22, zmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62E24D50AA31" , vfmsub213ps(zmm22, zmm22, dword_ptr(rcx)._1to16())); + TEST_INSTRUCTION("62E24D40AA727F" , vfmsub213ps(zmm22, zmm22, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62E24D40AAB200200000" , vfmsub213ps(zmm22, zmm22, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62E24D40AA7280" , vfmsub213ps(zmm22, zmm22, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62E24D40AAB2C0DFFFFF" , vfmsub213ps(zmm22, zmm22, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62E24D50AA727F" , vfmsub213ps(zmm22, zmm22, dword_ptr(rdx, 508)._1to16())); + TEST_INSTRUCTION("62E24D50AAB200020000" , vfmsub213ps(zmm22, zmm22, dword_ptr(rdx, 512)._1to16())); + TEST_INSTRUCTION("62E24D50AA7280" , vfmsub213ps(zmm22, zmm22, dword_ptr(rdx, -512)._1to16())); + TEST_INSTRUCTION("62E24D50AAB2FCFDFFFF" , vfmsub213ps(zmm22, zmm22, dword_ptr(rdx, -516)._1to16())); + TEST_INSTRUCTION("C4C2B9ABF4" , vfmsub213sd(xmm6, xmm8, xmm12)); + TEST_INSTRUCTION("62D2BD09ABF4" , k(k1).vfmsub213sd(xmm6, xmm8, xmm12)); + TEST_INSTRUCTION("62D2BD89ABF4" , k(k1).z().vfmsub213sd(xmm6, xmm8, xmm12)); + TEST_INSTRUCTION("62D2BD18ABF4" , rn_sae().vfmsub213sd(xmm6, xmm8, xmm12)); + TEST_INSTRUCTION("62D2BD58ABF4" , ru_sae().vfmsub213sd(xmm6, xmm8, xmm12)); + TEST_INSTRUCTION("62D2BD38ABF4" , rd_sae().vfmsub213sd(xmm6, xmm8, xmm12)); + TEST_INSTRUCTION("62D2BD78ABF4" , rz_sae().vfmsub213sd(xmm6, xmm8, xmm12)); + TEST_INSTRUCTION("C4E2B9AB31" , vfmsub213sd(xmm6, xmm8, qword_ptr(rcx))); + TEST_INSTRUCTION("C4A2B9ABB4F023010000" , vfmsub213sd(xmm6, xmm8, qword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("C4E2B9ABB2F8030000" , vfmsub213sd(xmm6, xmm8, qword_ptr(rdx, 1016))); + TEST_INSTRUCTION("C4E2B9ABB200040000" , vfmsub213sd(xmm6, xmm8, qword_ptr(rdx, 1024))); + TEST_INSTRUCTION("C4E2B9ABB200FCFFFF" , vfmsub213sd(xmm6, xmm8, qword_ptr(rdx, -1024))); + TEST_INSTRUCTION("C4E2B9ABB2F8FBFFFF" , vfmsub213sd(xmm6, xmm8, qword_ptr(rdx, -1032))); + TEST_INSTRUCTION("62021508ABF2" , vfmsub213ss(xmm30, xmm13, xmm26)); + TEST_INSTRUCTION("62021509ABF2" , k(k1).vfmsub213ss(xmm30, xmm13, xmm26)); + TEST_INSTRUCTION("62021589ABF2" , k(k1).z().vfmsub213ss(xmm30, xmm13, xmm26)); + TEST_INSTRUCTION("62021518ABF2" , rn_sae().vfmsub213ss(xmm30, xmm13, xmm26)); + TEST_INSTRUCTION("62021558ABF2" , ru_sae().vfmsub213ss(xmm30, xmm13, xmm26)); + TEST_INSTRUCTION("62021538ABF2" , rd_sae().vfmsub213ss(xmm30, xmm13, xmm26)); + TEST_INSTRUCTION("62021578ABF2" , rz_sae().vfmsub213ss(xmm30, xmm13, xmm26)); + TEST_INSTRUCTION("62621508AB31" , vfmsub213ss(xmm30, xmm13, dword_ptr(rcx))); + TEST_INSTRUCTION("62221508ABB4F023010000" , vfmsub213ss(xmm30, xmm13, dword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62621508AB727F" , vfmsub213ss(xmm30, xmm13, dword_ptr(rdx, 508))); + TEST_INSTRUCTION("62621508ABB200020000" , vfmsub213ss(xmm30, xmm13, dword_ptr(rdx, 512))); + TEST_INSTRUCTION("62621508AB7280" , vfmsub213ss(xmm30, xmm13, dword_ptr(rdx, -512))); + TEST_INSTRUCTION("62621508ABB2FCFDFFFF" , vfmsub213ss(xmm30, xmm13, dword_ptr(rdx, -516))); + TEST_INSTRUCTION("62D29D48BAEB" , vfmsub231pd(zmm5, zmm12, zmm11)); + TEST_INSTRUCTION("62D29D4ABAEB" , k(k2).vfmsub231pd(zmm5, zmm12, zmm11)); + TEST_INSTRUCTION("62D29DCABAEB" , k(k2).z().vfmsub231pd(zmm5, zmm12, zmm11)); + TEST_INSTRUCTION("62D29D18BAEB" , rn_sae().vfmsub231pd(zmm5, zmm12, zmm11)); + TEST_INSTRUCTION("62D29D58BAEB" , ru_sae().vfmsub231pd(zmm5, zmm12, zmm11)); + TEST_INSTRUCTION("62D29D38BAEB" , rd_sae().vfmsub231pd(zmm5, zmm12, zmm11)); + TEST_INSTRUCTION("62D29D78BAEB" , rz_sae().vfmsub231pd(zmm5, zmm12, zmm11)); + TEST_INSTRUCTION("62F29D48BA29" , vfmsub231pd(zmm5, zmm12, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62B29D48BAACF023010000" , vfmsub231pd(zmm5, zmm12, zmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62F29D58BA29" , vfmsub231pd(zmm5, zmm12, qword_ptr(rcx)._1to8())); + TEST_INSTRUCTION("62F29D48BA6A7F" , vfmsub231pd(zmm5, zmm12, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62F29D48BAAA00200000" , vfmsub231pd(zmm5, zmm12, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62F29D48BA6A80" , vfmsub231pd(zmm5, zmm12, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62F29D48BAAAC0DFFFFF" , vfmsub231pd(zmm5, zmm12, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62F29D58BA6A7F" , vfmsub231pd(zmm5, zmm12, qword_ptr(rdx, 1016)._1to8())); + TEST_INSTRUCTION("62F29D58BAAA00040000" , vfmsub231pd(zmm5, zmm12, qword_ptr(rdx, 1024)._1to8())); + TEST_INSTRUCTION("62F29D58BA6A80" , vfmsub231pd(zmm5, zmm12, qword_ptr(rdx, -1024)._1to8())); + TEST_INSTRUCTION("62F29D58BAAAF8FBFFFF" , vfmsub231pd(zmm5, zmm12, qword_ptr(rdx, -1032)._1to8())); + TEST_INSTRUCTION("62925540BAF3" , vfmsub231ps(zmm6, zmm21, zmm27)); + TEST_INSTRUCTION("62925543BAF3" , k(k3).vfmsub231ps(zmm6, zmm21, zmm27)); + TEST_INSTRUCTION("629255C3BAF3" , k(k3).z().vfmsub231ps(zmm6, zmm21, zmm27)); + TEST_INSTRUCTION("62925510BAF3" , rn_sae().vfmsub231ps(zmm6, zmm21, zmm27)); + TEST_INSTRUCTION("62925550BAF3" , ru_sae().vfmsub231ps(zmm6, zmm21, zmm27)); + TEST_INSTRUCTION("62925530BAF3" , rd_sae().vfmsub231ps(zmm6, zmm21, zmm27)); + TEST_INSTRUCTION("62925570BAF3" , rz_sae().vfmsub231ps(zmm6, zmm21, zmm27)); + TEST_INSTRUCTION("62F25540BA31" , vfmsub231ps(zmm6, zmm21, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62B25540BAB4F023010000" , vfmsub231ps(zmm6, zmm21, zmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62F25550BA31" , vfmsub231ps(zmm6, zmm21, dword_ptr(rcx)._1to16())); + TEST_INSTRUCTION("62F25540BA727F" , vfmsub231ps(zmm6, zmm21, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62F25540BAB200200000" , vfmsub231ps(zmm6, zmm21, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62F25540BA7280" , vfmsub231ps(zmm6, zmm21, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62F25540BAB2C0DFFFFF" , vfmsub231ps(zmm6, zmm21, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62F25550BA727F" , vfmsub231ps(zmm6, zmm21, dword_ptr(rdx, 508)._1to16())); + TEST_INSTRUCTION("62F25550BAB200020000" , vfmsub231ps(zmm6, zmm21, dword_ptr(rdx, 512)._1to16())); + TEST_INSTRUCTION("62F25550BA7280" , vfmsub231ps(zmm6, zmm21, dword_ptr(rdx, -512)._1to16())); + TEST_INSTRUCTION("62F25550BAB2FCFDFFFF" , vfmsub231ps(zmm6, zmm21, dword_ptr(rdx, -516)._1to16())); + TEST_INSTRUCTION("C4E2A1BBDE" , vfmsub231sd(xmm3, xmm11, xmm6)); + TEST_INSTRUCTION("62F2A50FBBDE" , k(k7).vfmsub231sd(xmm3, xmm11, xmm6)); + TEST_INSTRUCTION("62F2A58FBBDE" , k(k7).z().vfmsub231sd(xmm3, xmm11, xmm6)); + TEST_INSTRUCTION("62F2A518BBDE" , rn_sae().vfmsub231sd(xmm3, xmm11, xmm6)); + TEST_INSTRUCTION("62F2A558BBDE" , ru_sae().vfmsub231sd(xmm3, xmm11, xmm6)); + TEST_INSTRUCTION("62F2A538BBDE" , rd_sae().vfmsub231sd(xmm3, xmm11, xmm6)); + TEST_INSTRUCTION("62F2A578BBDE" , rz_sae().vfmsub231sd(xmm3, xmm11, xmm6)); + TEST_INSTRUCTION("C4E2A1BB19" , vfmsub231sd(xmm3, xmm11, qword_ptr(rcx))); + TEST_INSTRUCTION("C4A2A1BB9CF023010000" , vfmsub231sd(xmm3, xmm11, qword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("C4E2A1BB9AF8030000" , vfmsub231sd(xmm3, xmm11, qword_ptr(rdx, 1016))); + TEST_INSTRUCTION("C4E2A1BB9A00040000" , vfmsub231sd(xmm3, xmm11, qword_ptr(rdx, 1024))); + TEST_INSTRUCTION("C4E2A1BB9A00FCFFFF" , vfmsub231sd(xmm3, xmm11, qword_ptr(rdx, -1024))); + TEST_INSTRUCTION("C4E2A1BB9AF8FBFFFF" , vfmsub231sd(xmm3, xmm11, qword_ptr(rdx, -1032))); + TEST_INSTRUCTION("62626508BBED" , vfmsub231ss(xmm29, xmm3, xmm5)); + TEST_INSTRUCTION("6262650EBBED" , k(k6).vfmsub231ss(xmm29, xmm3, xmm5)); + TEST_INSTRUCTION("6262658EBBED" , k(k6).z().vfmsub231ss(xmm29, xmm3, xmm5)); + TEST_INSTRUCTION("62626518BBED" , rn_sae().vfmsub231ss(xmm29, xmm3, xmm5)); + TEST_INSTRUCTION("62626558BBED" , ru_sae().vfmsub231ss(xmm29, xmm3, xmm5)); + TEST_INSTRUCTION("62626538BBED" , rd_sae().vfmsub231ss(xmm29, xmm3, xmm5)); + TEST_INSTRUCTION("62626578BBED" , rz_sae().vfmsub231ss(xmm29, xmm3, xmm5)); + TEST_INSTRUCTION("62626508BB29" , vfmsub231ss(xmm29, xmm3, dword_ptr(rcx))); + TEST_INSTRUCTION("62226508BBACF023010000" , vfmsub231ss(xmm29, xmm3, dword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62626508BB6A7F" , vfmsub231ss(xmm29, xmm3, dword_ptr(rdx, 508))); + TEST_INSTRUCTION("62626508BBAA00020000" , vfmsub231ss(xmm29, xmm3, dword_ptr(rdx, 512))); + TEST_INSTRUCTION("62626508BB6A80" , vfmsub231ss(xmm29, xmm3, dword_ptr(rdx, -512))); + TEST_INSTRUCTION("62626508BBAAFCFDFFFF" , vfmsub231ss(xmm29, xmm3, dword_ptr(rdx, -516))); + TEST_INSTRUCTION("62A29D4097EA" , vfmsubadd132pd(zmm21, zmm28, zmm18)); + TEST_INSTRUCTION("62A29D4797EA" , k(k7).vfmsubadd132pd(zmm21, zmm28, zmm18)); + TEST_INSTRUCTION("62A29DC797EA" , k(k7).z().vfmsubadd132pd(zmm21, zmm28, zmm18)); + TEST_INSTRUCTION("62A29D1097EA" , rn_sae().vfmsubadd132pd(zmm21, zmm28, zmm18)); + TEST_INSTRUCTION("62A29D5097EA" , ru_sae().vfmsubadd132pd(zmm21, zmm28, zmm18)); + TEST_INSTRUCTION("62A29D3097EA" , rd_sae().vfmsubadd132pd(zmm21, zmm28, zmm18)); + TEST_INSTRUCTION("62A29D7097EA" , rz_sae().vfmsubadd132pd(zmm21, zmm28, zmm18)); + TEST_INSTRUCTION("62E29D409729" , vfmsubadd132pd(zmm21, zmm28, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62A29D4097ACF023010000" , vfmsubadd132pd(zmm21, zmm28, zmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62E29D509729" , vfmsubadd132pd(zmm21, zmm28, qword_ptr(rcx)._1to8())); + TEST_INSTRUCTION("62E29D40976A7F" , vfmsubadd132pd(zmm21, zmm28, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62E29D4097AA00200000" , vfmsubadd132pd(zmm21, zmm28, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62E29D40976A80" , vfmsubadd132pd(zmm21, zmm28, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62E29D4097AAC0DFFFFF" , vfmsubadd132pd(zmm21, zmm28, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62E29D50976A7F" , vfmsubadd132pd(zmm21, zmm28, qword_ptr(rdx, 1016)._1to8())); + TEST_INSTRUCTION("62E29D5097AA00040000" , vfmsubadd132pd(zmm21, zmm28, qword_ptr(rdx, 1024)._1to8())); + TEST_INSTRUCTION("62E29D50976A80" , vfmsubadd132pd(zmm21, zmm28, qword_ptr(rdx, -1024)._1to8())); + TEST_INSTRUCTION("62E29D5097AAF8FBFFFF" , vfmsubadd132pd(zmm21, zmm28, qword_ptr(rdx, -1032)._1to8())); + TEST_INSTRUCTION("62B2154897D5" , vfmsubadd132ps(zmm2, zmm13, zmm21)); + TEST_INSTRUCTION("62B2154F97D5" , k(k7).vfmsubadd132ps(zmm2, zmm13, zmm21)); + TEST_INSTRUCTION("62B215CF97D5" , k(k7).z().vfmsubadd132ps(zmm2, zmm13, zmm21)); + TEST_INSTRUCTION("62B2151897D5" , rn_sae().vfmsubadd132ps(zmm2, zmm13, zmm21)); + TEST_INSTRUCTION("62B2155897D5" , ru_sae().vfmsubadd132ps(zmm2, zmm13, zmm21)); + TEST_INSTRUCTION("62B2153897D5" , rd_sae().vfmsubadd132ps(zmm2, zmm13, zmm21)); + TEST_INSTRUCTION("62B2157897D5" , rz_sae().vfmsubadd132ps(zmm2, zmm13, zmm21)); + TEST_INSTRUCTION("62F215489711" , vfmsubadd132ps(zmm2, zmm13, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62B215489794F023010000" , vfmsubadd132ps(zmm2, zmm13, zmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62F215589711" , vfmsubadd132ps(zmm2, zmm13, dword_ptr(rcx)._1to16())); + TEST_INSTRUCTION("62F2154897527F" , vfmsubadd132ps(zmm2, zmm13, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62F21548979200200000" , vfmsubadd132ps(zmm2, zmm13, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62F21548975280" , vfmsubadd132ps(zmm2, zmm13, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62F215489792C0DFFFFF" , vfmsubadd132ps(zmm2, zmm13, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62F2155897527F" , vfmsubadd132ps(zmm2, zmm13, dword_ptr(rdx, 508)._1to16())); + TEST_INSTRUCTION("62F21558979200020000" , vfmsubadd132ps(zmm2, zmm13, dword_ptr(rdx, 512)._1to16())); + TEST_INSTRUCTION("62F21558975280" , vfmsubadd132ps(zmm2, zmm13, dword_ptr(rdx, -512)._1to16())); + TEST_INSTRUCTION("62F215589792FCFDFFFF" , vfmsubadd132ps(zmm2, zmm13, dword_ptr(rdx, -516)._1to16())); + TEST_INSTRUCTION("62F2C540A7D2" , vfmsubadd213pd(zmm2, zmm23, zmm2)); + TEST_INSTRUCTION("62F2C546A7D2" , k(k6).vfmsubadd213pd(zmm2, zmm23, zmm2)); + TEST_INSTRUCTION("62F2C5C6A7D2" , k(k6).z().vfmsubadd213pd(zmm2, zmm23, zmm2)); + TEST_INSTRUCTION("62F2C510A7D2" , rn_sae().vfmsubadd213pd(zmm2, zmm23, zmm2)); + TEST_INSTRUCTION("62F2C550A7D2" , ru_sae().vfmsubadd213pd(zmm2, zmm23, zmm2)); + TEST_INSTRUCTION("62F2C530A7D2" , rd_sae().vfmsubadd213pd(zmm2, zmm23, zmm2)); + TEST_INSTRUCTION("62F2C570A7D2" , rz_sae().vfmsubadd213pd(zmm2, zmm23, zmm2)); + TEST_INSTRUCTION("62F2C540A711" , vfmsubadd213pd(zmm2, zmm23, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62B2C540A794F023010000" , vfmsubadd213pd(zmm2, zmm23, zmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62F2C550A711" , vfmsubadd213pd(zmm2, zmm23, qword_ptr(rcx)._1to8())); + TEST_INSTRUCTION("62F2C540A7527F" , vfmsubadd213pd(zmm2, zmm23, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62F2C540A79200200000" , vfmsubadd213pd(zmm2, zmm23, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62F2C540A75280" , vfmsubadd213pd(zmm2, zmm23, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62F2C540A792C0DFFFFF" , vfmsubadd213pd(zmm2, zmm23, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62F2C550A7527F" , vfmsubadd213pd(zmm2, zmm23, qword_ptr(rdx, 1016)._1to8())); + TEST_INSTRUCTION("62F2C550A79200040000" , vfmsubadd213pd(zmm2, zmm23, qword_ptr(rdx, 1024)._1to8())); + TEST_INSTRUCTION("62F2C550A75280" , vfmsubadd213pd(zmm2, zmm23, qword_ptr(rdx, -1024)._1to8())); + TEST_INSTRUCTION("62F2C550A792F8FBFFFF" , vfmsubadd213pd(zmm2, zmm23, qword_ptr(rdx, -1032)._1to8())); + TEST_INSTRUCTION("62C21D48A7F6" , vfmsubadd213ps(zmm22, zmm12, zmm14)); + TEST_INSTRUCTION("62C21D4EA7F6" , k(k6).vfmsubadd213ps(zmm22, zmm12, zmm14)); + TEST_INSTRUCTION("62C21DCEA7F6" , k(k6).z().vfmsubadd213ps(zmm22, zmm12, zmm14)); + TEST_INSTRUCTION("62C21D18A7F6" , rn_sae().vfmsubadd213ps(zmm22, zmm12, zmm14)); + TEST_INSTRUCTION("62C21D58A7F6" , ru_sae().vfmsubadd213ps(zmm22, zmm12, zmm14)); + TEST_INSTRUCTION("62C21D38A7F6" , rd_sae().vfmsubadd213ps(zmm22, zmm12, zmm14)); + TEST_INSTRUCTION("62C21D78A7F6" , rz_sae().vfmsubadd213ps(zmm22, zmm12, zmm14)); + TEST_INSTRUCTION("62E21D48A731" , vfmsubadd213ps(zmm22, zmm12, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62A21D48A7B4F023010000" , vfmsubadd213ps(zmm22, zmm12, zmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62E21D58A731" , vfmsubadd213ps(zmm22, zmm12, dword_ptr(rcx)._1to16())); + TEST_INSTRUCTION("62E21D48A7727F" , vfmsubadd213ps(zmm22, zmm12, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62E21D48A7B200200000" , vfmsubadd213ps(zmm22, zmm12, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62E21D48A77280" , vfmsubadd213ps(zmm22, zmm12, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62E21D48A7B2C0DFFFFF" , vfmsubadd213ps(zmm22, zmm12, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62E21D58A7727F" , vfmsubadd213ps(zmm22, zmm12, dword_ptr(rdx, 508)._1to16())); + TEST_INSTRUCTION("62E21D58A7B200020000" , vfmsubadd213ps(zmm22, zmm12, dword_ptr(rdx, 512)._1to16())); + TEST_INSTRUCTION("62E21D58A77280" , vfmsubadd213ps(zmm22, zmm12, dword_ptr(rdx, -512)._1to16())); + TEST_INSTRUCTION("62E21D58A7B2FCFDFFFF" , vfmsubadd213ps(zmm22, zmm12, dword_ptr(rdx, -516)._1to16())); + TEST_INSTRUCTION("62A2A540B7C5" , vfmsubadd231pd(zmm16, zmm27, zmm21)); + TEST_INSTRUCTION("62A2A542B7C5" , k(k2).vfmsubadd231pd(zmm16, zmm27, zmm21)); + TEST_INSTRUCTION("62A2A5C2B7C5" , k(k2).z().vfmsubadd231pd(zmm16, zmm27, zmm21)); + TEST_INSTRUCTION("62A2A510B7C5" , rn_sae().vfmsubadd231pd(zmm16, zmm27, zmm21)); + TEST_INSTRUCTION("62A2A550B7C5" , ru_sae().vfmsubadd231pd(zmm16, zmm27, zmm21)); + TEST_INSTRUCTION("62A2A530B7C5" , rd_sae().vfmsubadd231pd(zmm16, zmm27, zmm21)); + TEST_INSTRUCTION("62A2A570B7C5" , rz_sae().vfmsubadd231pd(zmm16, zmm27, zmm21)); + TEST_INSTRUCTION("62E2A540B701" , vfmsubadd231pd(zmm16, zmm27, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62A2A540B784F023010000" , vfmsubadd231pd(zmm16, zmm27, zmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62E2A550B701" , vfmsubadd231pd(zmm16, zmm27, qword_ptr(rcx)._1to8())); + TEST_INSTRUCTION("62E2A540B7427F" , vfmsubadd231pd(zmm16, zmm27, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62E2A540B78200200000" , vfmsubadd231pd(zmm16, zmm27, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62E2A540B74280" , vfmsubadd231pd(zmm16, zmm27, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62E2A540B782C0DFFFFF" , vfmsubadd231pd(zmm16, zmm27, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62E2A550B7427F" , vfmsubadd231pd(zmm16, zmm27, qword_ptr(rdx, 1016)._1to8())); + TEST_INSTRUCTION("62E2A550B78200040000" , vfmsubadd231pd(zmm16, zmm27, qword_ptr(rdx, 1024)._1to8())); + TEST_INSTRUCTION("62E2A550B74280" , vfmsubadd231pd(zmm16, zmm27, qword_ptr(rdx, -1024)._1to8())); + TEST_INSTRUCTION("62E2A550B782F8FBFFFF" , vfmsubadd231pd(zmm16, zmm27, qword_ptr(rdx, -1032)._1to8())); + TEST_INSTRUCTION("62726540B7C1" , vfmsubadd231ps(zmm8, zmm19, zmm1)); + TEST_INSTRUCTION("62726542B7C1" , k(k2).vfmsubadd231ps(zmm8, zmm19, zmm1)); + TEST_INSTRUCTION("627265C2B7C1" , k(k2).z().vfmsubadd231ps(zmm8, zmm19, zmm1)); + TEST_INSTRUCTION("62726510B7C1" , rn_sae().vfmsubadd231ps(zmm8, zmm19, zmm1)); + TEST_INSTRUCTION("62726550B7C1" , ru_sae().vfmsubadd231ps(zmm8, zmm19, zmm1)); + TEST_INSTRUCTION("62726530B7C1" , rd_sae().vfmsubadd231ps(zmm8, zmm19, zmm1)); + TEST_INSTRUCTION("62726570B7C1" , rz_sae().vfmsubadd231ps(zmm8, zmm19, zmm1)); + TEST_INSTRUCTION("62726540B701" , vfmsubadd231ps(zmm8, zmm19, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62326540B784F023010000" , vfmsubadd231ps(zmm8, zmm19, zmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62726550B701" , vfmsubadd231ps(zmm8, zmm19, dword_ptr(rcx)._1to16())); + TEST_INSTRUCTION("62726540B7427F" , vfmsubadd231ps(zmm8, zmm19, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62726540B78200200000" , vfmsubadd231ps(zmm8, zmm19, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62726540B74280" , vfmsubadd231ps(zmm8, zmm19, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62726540B782C0DFFFFF" , vfmsubadd231ps(zmm8, zmm19, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62726550B7427F" , vfmsubadd231ps(zmm8, zmm19, dword_ptr(rdx, 508)._1to16())); + TEST_INSTRUCTION("62726550B78200020000" , vfmsubadd231ps(zmm8, zmm19, dword_ptr(rdx, 512)._1to16())); + TEST_INSTRUCTION("62726550B74280" , vfmsubadd231ps(zmm8, zmm19, dword_ptr(rdx, -512)._1to16())); + TEST_INSTRUCTION("62726550B782FCFDFFFF" , vfmsubadd231ps(zmm8, zmm19, dword_ptr(rdx, -516)._1to16())); + TEST_INSTRUCTION("62728D489CE1" , vfnmadd132pd(zmm12, zmm14, zmm1)); + TEST_INSTRUCTION("62728D4F9CE1" , k(k7).vfnmadd132pd(zmm12, zmm14, zmm1)); + TEST_INSTRUCTION("62728DCF9CE1" , k(k7).z().vfnmadd132pd(zmm12, zmm14, zmm1)); + TEST_INSTRUCTION("62728D189CE1" , rn_sae().vfnmadd132pd(zmm12, zmm14, zmm1)); + TEST_INSTRUCTION("62728D589CE1" , ru_sae().vfnmadd132pd(zmm12, zmm14, zmm1)); + TEST_INSTRUCTION("62728D389CE1" , rd_sae().vfnmadd132pd(zmm12, zmm14, zmm1)); + TEST_INSTRUCTION("62728D789CE1" , rz_sae().vfnmadd132pd(zmm12, zmm14, zmm1)); + TEST_INSTRUCTION("62728D489C21" , vfnmadd132pd(zmm12, zmm14, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62328D489CA4F023010000" , vfnmadd132pd(zmm12, zmm14, zmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62728D589C21" , vfnmadd132pd(zmm12, zmm14, qword_ptr(rcx)._1to8())); + TEST_INSTRUCTION("62728D489C627F" , vfnmadd132pd(zmm12, zmm14, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62728D489CA200200000" , vfnmadd132pd(zmm12, zmm14, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62728D489C6280" , vfnmadd132pd(zmm12, zmm14, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62728D489CA2C0DFFFFF" , vfnmadd132pd(zmm12, zmm14, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62728D589C627F" , vfnmadd132pd(zmm12, zmm14, qword_ptr(rdx, 1016)._1to8())); + TEST_INSTRUCTION("62728D589CA200040000" , vfnmadd132pd(zmm12, zmm14, qword_ptr(rdx, 1024)._1to8())); + TEST_INSTRUCTION("62728D589C6280" , vfnmadd132pd(zmm12, zmm14, qword_ptr(rdx, -1024)._1to8())); + TEST_INSTRUCTION("62728D589CA2F8FBFFFF" , vfnmadd132pd(zmm12, zmm14, qword_ptr(rdx, -1032)._1to8())); + TEST_INSTRUCTION("62C27D409CEA" , vfnmadd132ps(zmm21, zmm16, zmm10)); + TEST_INSTRUCTION("62C27D459CEA" , k(k5).vfnmadd132ps(zmm21, zmm16, zmm10)); + TEST_INSTRUCTION("62C27DC59CEA" , k(k5).z().vfnmadd132ps(zmm21, zmm16, zmm10)); + TEST_INSTRUCTION("62C27D109CEA" , rn_sae().vfnmadd132ps(zmm21, zmm16, zmm10)); + TEST_INSTRUCTION("62C27D509CEA" , ru_sae().vfnmadd132ps(zmm21, zmm16, zmm10)); + TEST_INSTRUCTION("62C27D309CEA" , rd_sae().vfnmadd132ps(zmm21, zmm16, zmm10)); + TEST_INSTRUCTION("62C27D709CEA" , rz_sae().vfnmadd132ps(zmm21, zmm16, zmm10)); + TEST_INSTRUCTION("62E27D409C29" , vfnmadd132ps(zmm21, zmm16, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62A27D409CACF023010000" , vfnmadd132ps(zmm21, zmm16, zmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62E27D509C29" , vfnmadd132ps(zmm21, zmm16, dword_ptr(rcx)._1to16())); + TEST_INSTRUCTION("62E27D409C6A7F" , vfnmadd132ps(zmm21, zmm16, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62E27D409CAA00200000" , vfnmadd132ps(zmm21, zmm16, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62E27D409C6A80" , vfnmadd132ps(zmm21, zmm16, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62E27D409CAAC0DFFFFF" , vfnmadd132ps(zmm21, zmm16, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62E27D509C6A7F" , vfnmadd132ps(zmm21, zmm16, dword_ptr(rdx, 508)._1to16())); + TEST_INSTRUCTION("62E27D509CAA00020000" , vfnmadd132ps(zmm21, zmm16, dword_ptr(rdx, 512)._1to16())); + TEST_INSTRUCTION("62E27D509C6A80" , vfnmadd132ps(zmm21, zmm16, dword_ptr(rdx, -512)._1to16())); + TEST_INSTRUCTION("62E27D509CAAFCFDFFFF" , vfnmadd132ps(zmm21, zmm16, dword_ptr(rdx, -516)._1to16())); + TEST_INSTRUCTION("62C2E5089DDB" , vfnmadd132sd(xmm19, xmm3, xmm11)); + TEST_INSTRUCTION("62C2E50A9DDB" , k(k2).vfnmadd132sd(xmm19, xmm3, xmm11)); + TEST_INSTRUCTION("62C2E58A9DDB" , k(k2).z().vfnmadd132sd(xmm19, xmm3, xmm11)); + TEST_INSTRUCTION("62C2E5189DDB" , rn_sae().vfnmadd132sd(xmm19, xmm3, xmm11)); + TEST_INSTRUCTION("62C2E5589DDB" , ru_sae().vfnmadd132sd(xmm19, xmm3, xmm11)); + TEST_INSTRUCTION("62C2E5389DDB" , rd_sae().vfnmadd132sd(xmm19, xmm3, xmm11)); + TEST_INSTRUCTION("62C2E5789DDB" , rz_sae().vfnmadd132sd(xmm19, xmm3, xmm11)); + TEST_INSTRUCTION("62E2E5089D19" , vfnmadd132sd(xmm19, xmm3, qword_ptr(rcx))); + TEST_INSTRUCTION("62A2E5089D9CF023010000" , vfnmadd132sd(xmm19, xmm3, qword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62E2E5089D5A7F" , vfnmadd132sd(xmm19, xmm3, qword_ptr(rdx, 1016))); + TEST_INSTRUCTION("62E2E5089D9A00040000" , vfnmadd132sd(xmm19, xmm3, qword_ptr(rdx, 1024))); + TEST_INSTRUCTION("62E2E5089D5A80" , vfnmadd132sd(xmm19, xmm3, qword_ptr(rdx, -1024))); + TEST_INSTRUCTION("62E2E5089D9AF8FBFFFF" , vfnmadd132sd(xmm19, xmm3, qword_ptr(rdx, -1032))); + TEST_INSTRUCTION("622275089DCF" , vfnmadd132ss(xmm25, xmm1, xmm23)); + TEST_INSTRUCTION("6222750B9DCF" , k(k3).vfnmadd132ss(xmm25, xmm1, xmm23)); + TEST_INSTRUCTION("6222758B9DCF" , k(k3).z().vfnmadd132ss(xmm25, xmm1, xmm23)); + TEST_INSTRUCTION("622275189DCF" , rn_sae().vfnmadd132ss(xmm25, xmm1, xmm23)); + TEST_INSTRUCTION("622275589DCF" , ru_sae().vfnmadd132ss(xmm25, xmm1, xmm23)); + TEST_INSTRUCTION("622275389DCF" , rd_sae().vfnmadd132ss(xmm25, xmm1, xmm23)); + TEST_INSTRUCTION("622275789DCF" , rz_sae().vfnmadd132ss(xmm25, xmm1, xmm23)); + TEST_INSTRUCTION("626275089D09" , vfnmadd132ss(xmm25, xmm1, dword_ptr(rcx))); + TEST_INSTRUCTION("622275089D8CF023010000" , vfnmadd132ss(xmm25, xmm1, dword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("626275089D4A7F" , vfnmadd132ss(xmm25, xmm1, dword_ptr(rdx, 508))); + TEST_INSTRUCTION("626275089D8A00020000" , vfnmadd132ss(xmm25, xmm1, dword_ptr(rdx, 512))); + TEST_INSTRUCTION("626275089D4A80" , vfnmadd132ss(xmm25, xmm1, dword_ptr(rdx, -512))); + TEST_INSTRUCTION("626275089D8AFCFDFFFF" , vfnmadd132ss(xmm25, xmm1, dword_ptr(rdx, -516))); + TEST_INSTRUCTION("62C2FD40ACC9" , vfnmadd213pd(zmm17, zmm16, zmm9)); + TEST_INSTRUCTION("62C2FD44ACC9" , k(k4).vfnmadd213pd(zmm17, zmm16, zmm9)); + TEST_INSTRUCTION("62C2FDC4ACC9" , k(k4).z().vfnmadd213pd(zmm17, zmm16, zmm9)); + TEST_INSTRUCTION("62C2FD10ACC9" , rn_sae().vfnmadd213pd(zmm17, zmm16, zmm9)); + TEST_INSTRUCTION("62C2FD50ACC9" , ru_sae().vfnmadd213pd(zmm17, zmm16, zmm9)); + TEST_INSTRUCTION("62C2FD30ACC9" , rd_sae().vfnmadd213pd(zmm17, zmm16, zmm9)); + TEST_INSTRUCTION("62C2FD70ACC9" , rz_sae().vfnmadd213pd(zmm17, zmm16, zmm9)); + TEST_INSTRUCTION("62E2FD40AC09" , vfnmadd213pd(zmm17, zmm16, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62A2FD40AC8CF023010000" , vfnmadd213pd(zmm17, zmm16, zmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62E2FD50AC09" , vfnmadd213pd(zmm17, zmm16, qword_ptr(rcx)._1to8())); + TEST_INSTRUCTION("62E2FD40AC4A7F" , vfnmadd213pd(zmm17, zmm16, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62E2FD40AC8A00200000" , vfnmadd213pd(zmm17, zmm16, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62E2FD40AC4A80" , vfnmadd213pd(zmm17, zmm16, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62E2FD40AC8AC0DFFFFF" , vfnmadd213pd(zmm17, zmm16, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62E2FD50AC4A7F" , vfnmadd213pd(zmm17, zmm16, qword_ptr(rdx, 1016)._1to8())); + TEST_INSTRUCTION("62E2FD50AC8A00040000" , vfnmadd213pd(zmm17, zmm16, qword_ptr(rdx, 1024)._1to8())); + TEST_INSTRUCTION("62E2FD50AC4A80" , vfnmadd213pd(zmm17, zmm16, qword_ptr(rdx, -1024)._1to8())); + TEST_INSTRUCTION("62E2FD50AC8AF8FBFFFF" , vfnmadd213pd(zmm17, zmm16, qword_ptr(rdx, -1032)._1to8())); + TEST_INSTRUCTION("62622D48ACD6" , vfnmadd213ps(zmm26, zmm10, zmm6)); + TEST_INSTRUCTION("62622D4EACD6" , k(k6).vfnmadd213ps(zmm26, zmm10, zmm6)); + TEST_INSTRUCTION("62622DCEACD6" , k(k6).z().vfnmadd213ps(zmm26, zmm10, zmm6)); + TEST_INSTRUCTION("62622D18ACD6" , rn_sae().vfnmadd213ps(zmm26, zmm10, zmm6)); + TEST_INSTRUCTION("62622D58ACD6" , ru_sae().vfnmadd213ps(zmm26, zmm10, zmm6)); + TEST_INSTRUCTION("62622D38ACD6" , rd_sae().vfnmadd213ps(zmm26, zmm10, zmm6)); + TEST_INSTRUCTION("62622D78ACD6" , rz_sae().vfnmadd213ps(zmm26, zmm10, zmm6)); + TEST_INSTRUCTION("62622D48AC11" , vfnmadd213ps(zmm26, zmm10, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62222D48AC94F023010000" , vfnmadd213ps(zmm26, zmm10, zmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62622D58AC11" , vfnmadd213ps(zmm26, zmm10, dword_ptr(rcx)._1to16())); + TEST_INSTRUCTION("62622D48AC527F" , vfnmadd213ps(zmm26, zmm10, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62622D48AC9200200000" , vfnmadd213ps(zmm26, zmm10, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62622D48AC5280" , vfnmadd213ps(zmm26, zmm10, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62622D48AC92C0DFFFFF" , vfnmadd213ps(zmm26, zmm10, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62622D58AC527F" , vfnmadd213ps(zmm26, zmm10, dword_ptr(rdx, 508)._1to16())); + TEST_INSTRUCTION("62622D58AC9200020000" , vfnmadd213ps(zmm26, zmm10, dword_ptr(rdx, 512)._1to16())); + TEST_INSTRUCTION("62622D58AC5280" , vfnmadd213ps(zmm26, zmm10, dword_ptr(rdx, -512)._1to16())); + TEST_INSTRUCTION("62622D58AC92FCFDFFFF" , vfnmadd213ps(zmm26, zmm10, dword_ptr(rdx, -516)._1to16())); + TEST_INSTRUCTION("6272A500ADEA" , vfnmadd213sd(xmm13, xmm27, xmm2)); + TEST_INSTRUCTION("6272A507ADEA" , k(k7).vfnmadd213sd(xmm13, xmm27, xmm2)); + TEST_INSTRUCTION("6272A587ADEA" , k(k7).z().vfnmadd213sd(xmm13, xmm27, xmm2)); + TEST_INSTRUCTION("6272A510ADEA" , rn_sae().vfnmadd213sd(xmm13, xmm27, xmm2)); + TEST_INSTRUCTION("6272A550ADEA" , ru_sae().vfnmadd213sd(xmm13, xmm27, xmm2)); + TEST_INSTRUCTION("6272A530ADEA" , rd_sae().vfnmadd213sd(xmm13, xmm27, xmm2)); + TEST_INSTRUCTION("6272A570ADEA" , rz_sae().vfnmadd213sd(xmm13, xmm27, xmm2)); + TEST_INSTRUCTION("6272A500AD29" , vfnmadd213sd(xmm13, xmm27, qword_ptr(rcx))); + TEST_INSTRUCTION("6232A500ADACF023010000" , vfnmadd213sd(xmm13, xmm27, qword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("6272A500AD6A7F" , vfnmadd213sd(xmm13, xmm27, qword_ptr(rdx, 1016))); + TEST_INSTRUCTION("6272A500ADAA00040000" , vfnmadd213sd(xmm13, xmm27, qword_ptr(rdx, 1024))); + TEST_INSTRUCTION("6272A500AD6A80" , vfnmadd213sd(xmm13, xmm27, qword_ptr(rdx, -1024))); + TEST_INSTRUCTION("6272A500ADAAF8FBFFFF" , vfnmadd213sd(xmm13, xmm27, qword_ptr(rdx, -1032))); + TEST_INSTRUCTION("62024508ADEC" , vfnmadd213ss(xmm29, xmm7, xmm28)); + TEST_INSTRUCTION("6202450AADEC" , k(k2).vfnmadd213ss(xmm29, xmm7, xmm28)); + TEST_INSTRUCTION("6202458AADEC" , k(k2).z().vfnmadd213ss(xmm29, xmm7, xmm28)); + TEST_INSTRUCTION("62024518ADEC" , rn_sae().vfnmadd213ss(xmm29, xmm7, xmm28)); + TEST_INSTRUCTION("62024558ADEC" , ru_sae().vfnmadd213ss(xmm29, xmm7, xmm28)); + TEST_INSTRUCTION("62024538ADEC" , rd_sae().vfnmadd213ss(xmm29, xmm7, xmm28)); + TEST_INSTRUCTION("62024578ADEC" , rz_sae().vfnmadd213ss(xmm29, xmm7, xmm28)); + TEST_INSTRUCTION("62624508AD29" , vfnmadd213ss(xmm29, xmm7, dword_ptr(rcx))); + TEST_INSTRUCTION("62224508ADACF023010000" , vfnmadd213ss(xmm29, xmm7, dword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62624508AD6A7F" , vfnmadd213ss(xmm29, xmm7, dword_ptr(rdx, 508))); + TEST_INSTRUCTION("62624508ADAA00020000" , vfnmadd213ss(xmm29, xmm7, dword_ptr(rdx, 512))); + TEST_INSTRUCTION("62624508AD6A80" , vfnmadd213ss(xmm29, xmm7, dword_ptr(rdx, -512))); + TEST_INSTRUCTION("62624508ADAAFCFDFFFF" , vfnmadd213ss(xmm29, xmm7, dword_ptr(rdx, -516))); + TEST_INSTRUCTION("6232A548BCE0" , vfnmadd231pd(zmm12, zmm11, zmm16)); + TEST_INSTRUCTION("6232A54EBCE0" , k(k6).vfnmadd231pd(zmm12, zmm11, zmm16)); + TEST_INSTRUCTION("6232A5CEBCE0" , k(k6).z().vfnmadd231pd(zmm12, zmm11, zmm16)); + TEST_INSTRUCTION("6232A518BCE0" , rn_sae().vfnmadd231pd(zmm12, zmm11, zmm16)); + TEST_INSTRUCTION("6232A558BCE0" , ru_sae().vfnmadd231pd(zmm12, zmm11, zmm16)); + TEST_INSTRUCTION("6232A538BCE0" , rd_sae().vfnmadd231pd(zmm12, zmm11, zmm16)); + TEST_INSTRUCTION("6232A578BCE0" , rz_sae().vfnmadd231pd(zmm12, zmm11, zmm16)); + TEST_INSTRUCTION("6272A548BC21" , vfnmadd231pd(zmm12, zmm11, zmmword_ptr(rcx))); + TEST_INSTRUCTION("6232A548BCA4F023010000" , vfnmadd231pd(zmm12, zmm11, zmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("6272A558BC21" , vfnmadd231pd(zmm12, zmm11, qword_ptr(rcx)._1to8())); + TEST_INSTRUCTION("6272A548BC627F" , vfnmadd231pd(zmm12, zmm11, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("6272A548BCA200200000" , vfnmadd231pd(zmm12, zmm11, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("6272A548BC6280" , vfnmadd231pd(zmm12, zmm11, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("6272A548BCA2C0DFFFFF" , vfnmadd231pd(zmm12, zmm11, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("6272A558BC627F" , vfnmadd231pd(zmm12, zmm11, qword_ptr(rdx, 1016)._1to8())); + TEST_INSTRUCTION("6272A558BCA200040000" , vfnmadd231pd(zmm12, zmm11, qword_ptr(rdx, 1024)._1to8())); + TEST_INSTRUCTION("6272A558BC6280" , vfnmadd231pd(zmm12, zmm11, qword_ptr(rdx, -1024)._1to8())); + TEST_INSTRUCTION("6272A558BCA2F8FBFFFF" , vfnmadd231pd(zmm12, zmm11, qword_ptr(rdx, -1032)._1to8())); + TEST_INSTRUCTION("62124548BCF0" , vfnmadd231ps(zmm14, zmm7, zmm24)); + TEST_INSTRUCTION("6212454DBCF0" , k(k5).vfnmadd231ps(zmm14, zmm7, zmm24)); + TEST_INSTRUCTION("621245CDBCF0" , k(k5).z().vfnmadd231ps(zmm14, zmm7, zmm24)); + TEST_INSTRUCTION("62124518BCF0" , rn_sae().vfnmadd231ps(zmm14, zmm7, zmm24)); + TEST_INSTRUCTION("62124558BCF0" , ru_sae().vfnmadd231ps(zmm14, zmm7, zmm24)); + TEST_INSTRUCTION("62124538BCF0" , rd_sae().vfnmadd231ps(zmm14, zmm7, zmm24)); + TEST_INSTRUCTION("62124578BCF0" , rz_sae().vfnmadd231ps(zmm14, zmm7, zmm24)); + TEST_INSTRUCTION("62724548BC31" , vfnmadd231ps(zmm14, zmm7, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62324548BCB4F023010000" , vfnmadd231ps(zmm14, zmm7, zmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62724558BC31" , vfnmadd231ps(zmm14, zmm7, dword_ptr(rcx)._1to16())); + TEST_INSTRUCTION("62724548BC727F" , vfnmadd231ps(zmm14, zmm7, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62724548BCB200200000" , vfnmadd231ps(zmm14, zmm7, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62724548BC7280" , vfnmadd231ps(zmm14, zmm7, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62724548BCB2C0DFFFFF" , vfnmadd231ps(zmm14, zmm7, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62724558BC727F" , vfnmadd231ps(zmm14, zmm7, dword_ptr(rdx, 508)._1to16())); + TEST_INSTRUCTION("62724558BCB200020000" , vfnmadd231ps(zmm14, zmm7, dword_ptr(rdx, 512)._1to16())); + TEST_INSTRUCTION("62724558BC7280" , vfnmadd231ps(zmm14, zmm7, dword_ptr(rdx, -512)._1to16())); + TEST_INSTRUCTION("62724558BCB2FCFDFFFF" , vfnmadd231ps(zmm14, zmm7, dword_ptr(rdx, -516)._1to16())); + TEST_INSTRUCTION("62B2A508BDF2" , vfnmadd231sd(xmm6, xmm11, xmm18)); + TEST_INSTRUCTION("62B2A50BBDF2" , k(k3).vfnmadd231sd(xmm6, xmm11, xmm18)); + TEST_INSTRUCTION("62B2A58BBDF2" , k(k3).z().vfnmadd231sd(xmm6, xmm11, xmm18)); + TEST_INSTRUCTION("62B2A518BDF2" , rn_sae().vfnmadd231sd(xmm6, xmm11, xmm18)); + TEST_INSTRUCTION("62B2A558BDF2" , ru_sae().vfnmadd231sd(xmm6, xmm11, xmm18)); + TEST_INSTRUCTION("62B2A538BDF2" , rd_sae().vfnmadd231sd(xmm6, xmm11, xmm18)); + TEST_INSTRUCTION("62B2A578BDF2" , rz_sae().vfnmadd231sd(xmm6, xmm11, xmm18)); + TEST_INSTRUCTION("C4E2A1BD31" , vfnmadd231sd(xmm6, xmm11, qword_ptr(rcx))); + TEST_INSTRUCTION("C4A2A1BDB4F023010000" , vfnmadd231sd(xmm6, xmm11, qword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("C4E2A1BDB2F8030000" , vfnmadd231sd(xmm6, xmm11, qword_ptr(rdx, 1016))); + TEST_INSTRUCTION("C4E2A1BDB200040000" , vfnmadd231sd(xmm6, xmm11, qword_ptr(rdx, 1024))); + TEST_INSTRUCTION("C4E2A1BDB200FCFFFF" , vfnmadd231sd(xmm6, xmm11, qword_ptr(rdx, -1024))); + TEST_INSTRUCTION("C4E2A1BDB2F8FBFFFF" , vfnmadd231sd(xmm6, xmm11, qword_ptr(rdx, -1032))); + TEST_INSTRUCTION("62226D08BDD9" , vfnmadd231ss(xmm27, xmm2, xmm17)); + TEST_INSTRUCTION("62226D09BDD9" , k(k1).vfnmadd231ss(xmm27, xmm2, xmm17)); + TEST_INSTRUCTION("62226D89BDD9" , k(k1).z().vfnmadd231ss(xmm27, xmm2, xmm17)); + TEST_INSTRUCTION("62226D18BDD9" , rn_sae().vfnmadd231ss(xmm27, xmm2, xmm17)); + TEST_INSTRUCTION("62226D58BDD9" , ru_sae().vfnmadd231ss(xmm27, xmm2, xmm17)); + TEST_INSTRUCTION("62226D38BDD9" , rd_sae().vfnmadd231ss(xmm27, xmm2, xmm17)); + TEST_INSTRUCTION("62226D78BDD9" , rz_sae().vfnmadd231ss(xmm27, xmm2, xmm17)); + TEST_INSTRUCTION("62626D08BD19" , vfnmadd231ss(xmm27, xmm2, dword_ptr(rcx))); + TEST_INSTRUCTION("62226D08BD9CF023010000" , vfnmadd231ss(xmm27, xmm2, dword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62626D08BD5A7F" , vfnmadd231ss(xmm27, xmm2, dword_ptr(rdx, 508))); + TEST_INSTRUCTION("62626D08BD9A00020000" , vfnmadd231ss(xmm27, xmm2, dword_ptr(rdx, 512))); + TEST_INSTRUCTION("62626D08BD5A80" , vfnmadd231ss(xmm27, xmm2, dword_ptr(rdx, -512))); + TEST_INSTRUCTION("62626D08BD9AFCFDFFFF" , vfnmadd231ss(xmm27, xmm2, dword_ptr(rdx, -516))); + TEST_INSTRUCTION("6262D5489EE6" , vfnmsub132pd(zmm28, zmm5, zmm6)); + TEST_INSTRUCTION("6262D54A9EE6" , k(k2).vfnmsub132pd(zmm28, zmm5, zmm6)); + TEST_INSTRUCTION("6262D5CA9EE6" , k(k2).z().vfnmsub132pd(zmm28, zmm5, zmm6)); + TEST_INSTRUCTION("6262D5189EE6" , rn_sae().vfnmsub132pd(zmm28, zmm5, zmm6)); + TEST_INSTRUCTION("6262D5589EE6" , ru_sae().vfnmsub132pd(zmm28, zmm5, zmm6)); + TEST_INSTRUCTION("6262D5389EE6" , rd_sae().vfnmsub132pd(zmm28, zmm5, zmm6)); + TEST_INSTRUCTION("6262D5789EE6" , rz_sae().vfnmsub132pd(zmm28, zmm5, zmm6)); + TEST_INSTRUCTION("6262D5489E21" , vfnmsub132pd(zmm28, zmm5, zmmword_ptr(rcx))); + TEST_INSTRUCTION("6222D5489EA4F023010000" , vfnmsub132pd(zmm28, zmm5, zmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("6262D5589E21" , vfnmsub132pd(zmm28, zmm5, qword_ptr(rcx)._1to8())); + TEST_INSTRUCTION("6262D5489E627F" , vfnmsub132pd(zmm28, zmm5, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("6262D5489EA200200000" , vfnmsub132pd(zmm28, zmm5, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("6262D5489E6280" , vfnmsub132pd(zmm28, zmm5, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("6262D5489EA2C0DFFFFF" , vfnmsub132pd(zmm28, zmm5, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("6262D5589E627F" , vfnmsub132pd(zmm28, zmm5, qword_ptr(rdx, 1016)._1to8())); + TEST_INSTRUCTION("6262D5589EA200040000" , vfnmsub132pd(zmm28, zmm5, qword_ptr(rdx, 1024)._1to8())); + TEST_INSTRUCTION("6262D5589E6280" , vfnmsub132pd(zmm28, zmm5, qword_ptr(rdx, -1024)._1to8())); + TEST_INSTRUCTION("6262D5589EA2F8FBFFFF" , vfnmsub132pd(zmm28, zmm5, qword_ptr(rdx, -1032)._1to8())); + TEST_INSTRUCTION("62F26D409EE6" , vfnmsub132ps(zmm4, zmm18, zmm6)); + TEST_INSTRUCTION("62F26D429EE6" , k(k2).vfnmsub132ps(zmm4, zmm18, zmm6)); + TEST_INSTRUCTION("62F26DC29EE6" , k(k2).z().vfnmsub132ps(zmm4, zmm18, zmm6)); + TEST_INSTRUCTION("62F26D109EE6" , rn_sae().vfnmsub132ps(zmm4, zmm18, zmm6)); + TEST_INSTRUCTION("62F26D509EE6" , ru_sae().vfnmsub132ps(zmm4, zmm18, zmm6)); + TEST_INSTRUCTION("62F26D309EE6" , rd_sae().vfnmsub132ps(zmm4, zmm18, zmm6)); + TEST_INSTRUCTION("62F26D709EE6" , rz_sae().vfnmsub132ps(zmm4, zmm18, zmm6)); + TEST_INSTRUCTION("62F26D409E21" , vfnmsub132ps(zmm4, zmm18, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62B26D409EA4F023010000" , vfnmsub132ps(zmm4, zmm18, zmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62F26D509E21" , vfnmsub132ps(zmm4, zmm18, dword_ptr(rcx)._1to16())); + TEST_INSTRUCTION("62F26D409E627F" , vfnmsub132ps(zmm4, zmm18, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62F26D409EA200200000" , vfnmsub132ps(zmm4, zmm18, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62F26D409E6280" , vfnmsub132ps(zmm4, zmm18, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62F26D409EA2C0DFFFFF" , vfnmsub132ps(zmm4, zmm18, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62F26D509E627F" , vfnmsub132ps(zmm4, zmm18, dword_ptr(rdx, 508)._1to16())); + TEST_INSTRUCTION("62F26D509EA200020000" , vfnmsub132ps(zmm4, zmm18, dword_ptr(rdx, 512)._1to16())); + TEST_INSTRUCTION("62F26D509E6280" , vfnmsub132ps(zmm4, zmm18, dword_ptr(rdx, -512)._1to16())); + TEST_INSTRUCTION("62F26D509EA2FCFDFFFF" , vfnmsub132ps(zmm4, zmm18, dword_ptr(rdx, -516)._1to16())); + TEST_INSTRUCTION("6242A5089FD5" , vfnmsub132sd(xmm26, xmm11, xmm13)); + TEST_INSTRUCTION("6242A50E9FD5" , k(k6).vfnmsub132sd(xmm26, xmm11, xmm13)); + TEST_INSTRUCTION("6242A58E9FD5" , k(k6).z().vfnmsub132sd(xmm26, xmm11, xmm13)); + TEST_INSTRUCTION("6242A5189FD5" , rn_sae().vfnmsub132sd(xmm26, xmm11, xmm13)); + TEST_INSTRUCTION("6242A5589FD5" , ru_sae().vfnmsub132sd(xmm26, xmm11, xmm13)); + TEST_INSTRUCTION("6242A5389FD5" , rd_sae().vfnmsub132sd(xmm26, xmm11, xmm13)); + TEST_INSTRUCTION("6242A5789FD5" , rz_sae().vfnmsub132sd(xmm26, xmm11, xmm13)); + TEST_INSTRUCTION("6262A5089F11" , vfnmsub132sd(xmm26, xmm11, qword_ptr(rcx))); + TEST_INSTRUCTION("6222A5089F94F023010000" , vfnmsub132sd(xmm26, xmm11, qword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("6262A5089F527F" , vfnmsub132sd(xmm26, xmm11, qword_ptr(rdx, 1016))); + TEST_INSTRUCTION("6262A5089F9200040000" , vfnmsub132sd(xmm26, xmm11, qword_ptr(rdx, 1024))); + TEST_INSTRUCTION("6262A5089F5280" , vfnmsub132sd(xmm26, xmm11, qword_ptr(rdx, -1024))); + TEST_INSTRUCTION("6262A5089F92F8FBFFFF" , vfnmsub132sd(xmm26, xmm11, qword_ptr(rdx, -1032))); + TEST_INSTRUCTION("62824D009FF8" , vfnmsub132ss(xmm23, xmm22, xmm24)); + TEST_INSTRUCTION("62824D069FF8" , k(k6).vfnmsub132ss(xmm23, xmm22, xmm24)); + TEST_INSTRUCTION("62824D869FF8" , k(k6).z().vfnmsub132ss(xmm23, xmm22, xmm24)); + TEST_INSTRUCTION("62824D109FF8" , rn_sae().vfnmsub132ss(xmm23, xmm22, xmm24)); + TEST_INSTRUCTION("62824D509FF8" , ru_sae().vfnmsub132ss(xmm23, xmm22, xmm24)); + TEST_INSTRUCTION("62824D309FF8" , rd_sae().vfnmsub132ss(xmm23, xmm22, xmm24)); + TEST_INSTRUCTION("62824D709FF8" , rz_sae().vfnmsub132ss(xmm23, xmm22, xmm24)); + TEST_INSTRUCTION("62E24D009F39" , vfnmsub132ss(xmm23, xmm22, dword_ptr(rcx))); + TEST_INSTRUCTION("62A24D009FBCF023010000" , vfnmsub132ss(xmm23, xmm22, dword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62E24D009F7A7F" , vfnmsub132ss(xmm23, xmm22, dword_ptr(rdx, 508))); + TEST_INSTRUCTION("62E24D009FBA00020000" , vfnmsub132ss(xmm23, xmm22, dword_ptr(rdx, 512))); + TEST_INSTRUCTION("62E24D009F7A80" , vfnmsub132ss(xmm23, xmm22, dword_ptr(rdx, -512))); + TEST_INSTRUCTION("62E24D009FBAFCFDFFFF" , vfnmsub132ss(xmm23, xmm22, dword_ptr(rdx, -516))); + TEST_INSTRUCTION("62C2ED40AEFB" , vfnmsub213pd(zmm23, zmm18, zmm11)); + TEST_INSTRUCTION("62C2ED42AEFB" , k(k2).vfnmsub213pd(zmm23, zmm18, zmm11)); + TEST_INSTRUCTION("62C2EDC2AEFB" , k(k2).z().vfnmsub213pd(zmm23, zmm18, zmm11)); + TEST_INSTRUCTION("62C2ED10AEFB" , rn_sae().vfnmsub213pd(zmm23, zmm18, zmm11)); + TEST_INSTRUCTION("62C2ED50AEFB" , ru_sae().vfnmsub213pd(zmm23, zmm18, zmm11)); + TEST_INSTRUCTION("62C2ED30AEFB" , rd_sae().vfnmsub213pd(zmm23, zmm18, zmm11)); + TEST_INSTRUCTION("62C2ED70AEFB" , rz_sae().vfnmsub213pd(zmm23, zmm18, zmm11)); + TEST_INSTRUCTION("62E2ED40AE39" , vfnmsub213pd(zmm23, zmm18, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62A2ED40AEBCF023010000" , vfnmsub213pd(zmm23, zmm18, zmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62E2ED50AE39" , vfnmsub213pd(zmm23, zmm18, qword_ptr(rcx)._1to8())); + TEST_INSTRUCTION("62E2ED40AE7A7F" , vfnmsub213pd(zmm23, zmm18, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62E2ED40AEBA00200000" , vfnmsub213pd(zmm23, zmm18, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62E2ED40AE7A80" , vfnmsub213pd(zmm23, zmm18, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62E2ED40AEBAC0DFFFFF" , vfnmsub213pd(zmm23, zmm18, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62E2ED50AE7A7F" , vfnmsub213pd(zmm23, zmm18, qword_ptr(rdx, 1016)._1to8())); + TEST_INSTRUCTION("62E2ED50AEBA00040000" , vfnmsub213pd(zmm23, zmm18, qword_ptr(rdx, 1024)._1to8())); + TEST_INSTRUCTION("62E2ED50AE7A80" , vfnmsub213pd(zmm23, zmm18, qword_ptr(rdx, -1024)._1to8())); + TEST_INSTRUCTION("62E2ED50AEBAF8FBFFFF" , vfnmsub213pd(zmm23, zmm18, qword_ptr(rdx, -1032)._1to8())); + TEST_INSTRUCTION("62E21548AEEA" , vfnmsub213ps(zmm21, zmm13, zmm2)); + TEST_INSTRUCTION("62E2154BAEEA" , k(k3).vfnmsub213ps(zmm21, zmm13, zmm2)); + TEST_INSTRUCTION("62E215CBAEEA" , k(k3).z().vfnmsub213ps(zmm21, zmm13, zmm2)); + TEST_INSTRUCTION("62E21518AEEA" , rn_sae().vfnmsub213ps(zmm21, zmm13, zmm2)); + TEST_INSTRUCTION("62E21558AEEA" , ru_sae().vfnmsub213ps(zmm21, zmm13, zmm2)); + TEST_INSTRUCTION("62E21538AEEA" , rd_sae().vfnmsub213ps(zmm21, zmm13, zmm2)); + TEST_INSTRUCTION("62E21578AEEA" , rz_sae().vfnmsub213ps(zmm21, zmm13, zmm2)); + TEST_INSTRUCTION("62E21548AE29" , vfnmsub213ps(zmm21, zmm13, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62A21548AEACF023010000" , vfnmsub213ps(zmm21, zmm13, zmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62E21558AE29" , vfnmsub213ps(zmm21, zmm13, dword_ptr(rcx)._1to16())); + TEST_INSTRUCTION("62E21548AE6A7F" , vfnmsub213ps(zmm21, zmm13, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62E21548AEAA00200000" , vfnmsub213ps(zmm21, zmm13, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62E21548AE6A80" , vfnmsub213ps(zmm21, zmm13, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62E21548AEAAC0DFFFFF" , vfnmsub213ps(zmm21, zmm13, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62E21558AE6A7F" , vfnmsub213ps(zmm21, zmm13, dword_ptr(rdx, 508)._1to16())); + TEST_INSTRUCTION("62E21558AEAA00020000" , vfnmsub213ps(zmm21, zmm13, dword_ptr(rdx, 512)._1to16())); + TEST_INSTRUCTION("62E21558AE6A80" , vfnmsub213ps(zmm21, zmm13, dword_ptr(rdx, -512)._1to16())); + TEST_INSTRUCTION("62E21558AEAAFCFDFFFF" , vfnmsub213ps(zmm21, zmm13, dword_ptr(rdx, -516)._1to16())); + TEST_INSTRUCTION("6202C500AFEC" , vfnmsub213sd(xmm29, xmm23, xmm28)); + TEST_INSTRUCTION("6202C503AFEC" , k(k3).vfnmsub213sd(xmm29, xmm23, xmm28)); + TEST_INSTRUCTION("6202C583AFEC" , k(k3).z().vfnmsub213sd(xmm29, xmm23, xmm28)); + TEST_INSTRUCTION("6202C510AFEC" , rn_sae().vfnmsub213sd(xmm29, xmm23, xmm28)); + TEST_INSTRUCTION("6202C550AFEC" , ru_sae().vfnmsub213sd(xmm29, xmm23, xmm28)); + TEST_INSTRUCTION("6202C530AFEC" , rd_sae().vfnmsub213sd(xmm29, xmm23, xmm28)); + TEST_INSTRUCTION("6202C570AFEC" , rz_sae().vfnmsub213sd(xmm29, xmm23, xmm28)); + TEST_INSTRUCTION("6262C500AF29" , vfnmsub213sd(xmm29, xmm23, qword_ptr(rcx))); + TEST_INSTRUCTION("6222C500AFACF023010000" , vfnmsub213sd(xmm29, xmm23, qword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("6262C500AF6A7F" , vfnmsub213sd(xmm29, xmm23, qword_ptr(rdx, 1016))); + TEST_INSTRUCTION("6262C500AFAA00040000" , vfnmsub213sd(xmm29, xmm23, qword_ptr(rdx, 1024))); + TEST_INSTRUCTION("6262C500AF6A80" , vfnmsub213sd(xmm29, xmm23, qword_ptr(rdx, -1024))); + TEST_INSTRUCTION("6262C500AFAAF8FBFFFF" , vfnmsub213sd(xmm29, xmm23, qword_ptr(rdx, -1032))); + TEST_INSTRUCTION("62521D00AFF4" , vfnmsub213ss(xmm14, xmm28, xmm12)); + TEST_INSTRUCTION("62521D04AFF4" , k(k4).vfnmsub213ss(xmm14, xmm28, xmm12)); + TEST_INSTRUCTION("62521D84AFF4" , k(k4).z().vfnmsub213ss(xmm14, xmm28, xmm12)); + TEST_INSTRUCTION("62521D10AFF4" , rn_sae().vfnmsub213ss(xmm14, xmm28, xmm12)); + TEST_INSTRUCTION("62521D50AFF4" , ru_sae().vfnmsub213ss(xmm14, xmm28, xmm12)); + TEST_INSTRUCTION("62521D30AFF4" , rd_sae().vfnmsub213ss(xmm14, xmm28, xmm12)); + TEST_INSTRUCTION("62521D70AFF4" , rz_sae().vfnmsub213ss(xmm14, xmm28, xmm12)); + TEST_INSTRUCTION("62721D00AF31" , vfnmsub213ss(xmm14, xmm28, dword_ptr(rcx))); + TEST_INSTRUCTION("62321D00AFB4F023010000" , vfnmsub213ss(xmm14, xmm28, dword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62721D00AF727F" , vfnmsub213ss(xmm14, xmm28, dword_ptr(rdx, 508))); + TEST_INSTRUCTION("62721D00AFB200020000" , vfnmsub213ss(xmm14, xmm28, dword_ptr(rdx, 512))); + TEST_INSTRUCTION("62721D00AF7280" , vfnmsub213ss(xmm14, xmm28, dword_ptr(rdx, -512))); + TEST_INSTRUCTION("62721D00AFB2FCFDFFFF" , vfnmsub213ss(xmm14, xmm28, dword_ptr(rdx, -516))); + TEST_INSTRUCTION("6202DD48BEE8" , vfnmsub231pd(zmm29, zmm4, zmm24)); + TEST_INSTRUCTION("6202DD4FBEE8" , k(k7).vfnmsub231pd(zmm29, zmm4, zmm24)); + TEST_INSTRUCTION("6202DDCFBEE8" , k(k7).z().vfnmsub231pd(zmm29, zmm4, zmm24)); + TEST_INSTRUCTION("6202DD18BEE8" , rn_sae().vfnmsub231pd(zmm29, zmm4, zmm24)); + TEST_INSTRUCTION("6202DD58BEE8" , ru_sae().vfnmsub231pd(zmm29, zmm4, zmm24)); + TEST_INSTRUCTION("6202DD38BEE8" , rd_sae().vfnmsub231pd(zmm29, zmm4, zmm24)); + TEST_INSTRUCTION("6202DD78BEE8" , rz_sae().vfnmsub231pd(zmm29, zmm4, zmm24)); + TEST_INSTRUCTION("6262DD48BE29" , vfnmsub231pd(zmm29, zmm4, zmmword_ptr(rcx))); + TEST_INSTRUCTION("6222DD48BEACF023010000" , vfnmsub231pd(zmm29, zmm4, zmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("6262DD58BE29" , vfnmsub231pd(zmm29, zmm4, qword_ptr(rcx)._1to8())); + TEST_INSTRUCTION("6262DD48BE6A7F" , vfnmsub231pd(zmm29, zmm4, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("6262DD48BEAA00200000" , vfnmsub231pd(zmm29, zmm4, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("6262DD48BE6A80" , vfnmsub231pd(zmm29, zmm4, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("6262DD48BEAAC0DFFFFF" , vfnmsub231pd(zmm29, zmm4, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("6262DD58BE6A7F" , vfnmsub231pd(zmm29, zmm4, qword_ptr(rdx, 1016)._1to8())); + TEST_INSTRUCTION("6262DD58BEAA00040000" , vfnmsub231pd(zmm29, zmm4, qword_ptr(rdx, 1024)._1to8())); + TEST_INSTRUCTION("6262DD58BE6A80" , vfnmsub231pd(zmm29, zmm4, qword_ptr(rdx, -1024)._1to8())); + TEST_INSTRUCTION("6262DD58BEAAF8FBFFFF" , vfnmsub231pd(zmm29, zmm4, qword_ptr(rdx, -1032)._1to8())); + TEST_INSTRUCTION("62524D48BEC5" , vfnmsub231ps(zmm8, zmm6, zmm13)); + TEST_INSTRUCTION("62524D4ABEC5" , k(k2).vfnmsub231ps(zmm8, zmm6, zmm13)); + TEST_INSTRUCTION("62524DCABEC5" , k(k2).z().vfnmsub231ps(zmm8, zmm6, zmm13)); + TEST_INSTRUCTION("62524D18BEC5" , rn_sae().vfnmsub231ps(zmm8, zmm6, zmm13)); + TEST_INSTRUCTION("62524D58BEC5" , ru_sae().vfnmsub231ps(zmm8, zmm6, zmm13)); + TEST_INSTRUCTION("62524D38BEC5" , rd_sae().vfnmsub231ps(zmm8, zmm6, zmm13)); + TEST_INSTRUCTION("62524D78BEC5" , rz_sae().vfnmsub231ps(zmm8, zmm6, zmm13)); + TEST_INSTRUCTION("62724D48BE01" , vfnmsub231ps(zmm8, zmm6, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62324D48BE84F023010000" , vfnmsub231ps(zmm8, zmm6, zmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62724D58BE01" , vfnmsub231ps(zmm8, zmm6, dword_ptr(rcx)._1to16())); + TEST_INSTRUCTION("62724D48BE427F" , vfnmsub231ps(zmm8, zmm6, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62724D48BE8200200000" , vfnmsub231ps(zmm8, zmm6, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62724D48BE4280" , vfnmsub231ps(zmm8, zmm6, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62724D48BE82C0DFFFFF" , vfnmsub231ps(zmm8, zmm6, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62724D58BE427F" , vfnmsub231ps(zmm8, zmm6, dword_ptr(rdx, 508)._1to16())); + TEST_INSTRUCTION("62724D58BE8200020000" , vfnmsub231ps(zmm8, zmm6, dword_ptr(rdx, 512)._1to16())); + TEST_INSTRUCTION("62724D58BE4280" , vfnmsub231ps(zmm8, zmm6, dword_ptr(rdx, -512)._1to16())); + TEST_INSTRUCTION("62724D58BE82FCFDFFFF" , vfnmsub231ps(zmm8, zmm6, dword_ptr(rdx, -516)._1to16())); + TEST_INSTRUCTION("62D2DD00BFF6" , vfnmsub231sd(xmm6, xmm20, xmm14)); + TEST_INSTRUCTION("62D2DD01BFF6" , k(k1).vfnmsub231sd(xmm6, xmm20, xmm14)); + TEST_INSTRUCTION("62D2DD81BFF6" , k(k1).z().vfnmsub231sd(xmm6, xmm20, xmm14)); + TEST_INSTRUCTION("62D2DD10BFF6" , rn_sae().vfnmsub231sd(xmm6, xmm20, xmm14)); + TEST_INSTRUCTION("62D2DD50BFF6" , ru_sae().vfnmsub231sd(xmm6, xmm20, xmm14)); + TEST_INSTRUCTION("62D2DD30BFF6" , rd_sae().vfnmsub231sd(xmm6, xmm20, xmm14)); + TEST_INSTRUCTION("62D2DD70BFF6" , rz_sae().vfnmsub231sd(xmm6, xmm20, xmm14)); + TEST_INSTRUCTION("62F2DD00BF31" , vfnmsub231sd(xmm6, xmm20, qword_ptr(rcx))); + TEST_INSTRUCTION("62B2DD00BFB4F023010000" , vfnmsub231sd(xmm6, xmm20, qword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62F2DD00BF727F" , vfnmsub231sd(xmm6, xmm20, qword_ptr(rdx, 1016))); + TEST_INSTRUCTION("62F2DD00BFB200040000" , vfnmsub231sd(xmm6, xmm20, qword_ptr(rdx, 1024))); + TEST_INSTRUCTION("62F2DD00BF7280" , vfnmsub231sd(xmm6, xmm20, qword_ptr(rdx, -1024))); + TEST_INSTRUCTION("62F2DD00BFB2F8FBFFFF" , vfnmsub231sd(xmm6, xmm20, qword_ptr(rdx, -1032))); + TEST_INSTRUCTION("62421508BFD2" , vfnmsub231ss(xmm26, xmm13, xmm10)); + TEST_INSTRUCTION("6242150CBFD2" , k(k4).vfnmsub231ss(xmm26, xmm13, xmm10)); + TEST_INSTRUCTION("6242158CBFD2" , k(k4).z().vfnmsub231ss(xmm26, xmm13, xmm10)); + TEST_INSTRUCTION("62421518BFD2" , rn_sae().vfnmsub231ss(xmm26, xmm13, xmm10)); + TEST_INSTRUCTION("62421558BFD2" , ru_sae().vfnmsub231ss(xmm26, xmm13, xmm10)); + TEST_INSTRUCTION("62421538BFD2" , rd_sae().vfnmsub231ss(xmm26, xmm13, xmm10)); + TEST_INSTRUCTION("62421578BFD2" , rz_sae().vfnmsub231ss(xmm26, xmm13, xmm10)); + TEST_INSTRUCTION("62621508BF11" , vfnmsub231ss(xmm26, xmm13, dword_ptr(rcx))); + TEST_INSTRUCTION("62221508BF94F023010000" , vfnmsub231ss(xmm26, xmm13, dword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62621508BF527F" , vfnmsub231ss(xmm26, xmm13, dword_ptr(rdx, 508))); + TEST_INSTRUCTION("62621508BF9200020000" , vfnmsub231ss(xmm26, xmm13, dword_ptr(rdx, 512))); + TEST_INSTRUCTION("62621508BF5280" , vfnmsub231ss(xmm26, xmm13, dword_ptr(rdx, -512))); + TEST_INSTRUCTION("62621508BF92FCFDFFFF" , vfnmsub231ss(xmm26, xmm13, dword_ptr(rdx, -516))); + TEST_INSTRUCTION("6212FD4842F1" , vgetexppd(zmm14, zmm25)); + TEST_INSTRUCTION("6212FD4D42F1" , k(k5).vgetexppd(zmm14, zmm25)); + TEST_INSTRUCTION("6212FDCD42F1" , k(k5).z().vgetexppd(zmm14, zmm25)); + TEST_INSTRUCTION("6212FD1842F1" , sae().vgetexppd(zmm14, zmm25)); + TEST_INSTRUCTION("6272FD484231" , vgetexppd(zmm14, zmmword_ptr(rcx))); + TEST_INSTRUCTION("6232FD4842B4F023010000" , vgetexppd(zmm14, zmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("6272FD584231" , vgetexppd(zmm14, qword_ptr(rcx)._1to8())); + TEST_INSTRUCTION("6272FD4842727F" , vgetexppd(zmm14, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("6272FD4842B200200000" , vgetexppd(zmm14, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("6272FD48427280" , vgetexppd(zmm14, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("6272FD4842B2C0DFFFFF" , vgetexppd(zmm14, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("6272FD5842727F" , vgetexppd(zmm14, qword_ptr(rdx, 1016)._1to8())); + TEST_INSTRUCTION("6272FD5842B200040000" , vgetexppd(zmm14, qword_ptr(rdx, 1024)._1to8())); + TEST_INSTRUCTION("6272FD58427280" , vgetexppd(zmm14, qword_ptr(rdx, -1024)._1to8())); + TEST_INSTRUCTION("6272FD5842B2F8FBFFFF" , vgetexppd(zmm14, qword_ptr(rdx, -1032)._1to8())); + TEST_INSTRUCTION("62F27D4842CE" , vgetexpps(zmm1, zmm6)); + TEST_INSTRUCTION("62F27D4B42CE" , k(k3).vgetexpps(zmm1, zmm6)); + TEST_INSTRUCTION("62F27DCB42CE" , k(k3).z().vgetexpps(zmm1, zmm6)); + TEST_INSTRUCTION("62F27D1842CE" , sae().vgetexpps(zmm1, zmm6)); + TEST_INSTRUCTION("62F27D484209" , vgetexpps(zmm1, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62B27D48428CF023010000" , vgetexpps(zmm1, zmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62F27D584209" , vgetexpps(zmm1, dword_ptr(rcx)._1to16())); + TEST_INSTRUCTION("62F27D48424A7F" , vgetexpps(zmm1, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62F27D48428A00200000" , vgetexpps(zmm1, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62F27D48424A80" , vgetexpps(zmm1, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62F27D48428AC0DFFFFF" , vgetexpps(zmm1, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62F27D58424A7F" , vgetexpps(zmm1, dword_ptr(rdx, 508)._1to16())); + TEST_INSTRUCTION("62F27D58428A00020000" , vgetexpps(zmm1, dword_ptr(rdx, 512)._1to16())); + TEST_INSTRUCTION("62F27D58424A80" , vgetexpps(zmm1, dword_ptr(rdx, -512)._1to16())); + TEST_INSTRUCTION("62F27D58428AFCFDFFFF" , vgetexpps(zmm1, dword_ptr(rdx, -516)._1to16())); + TEST_INSTRUCTION("62F2C50843D2" , vgetexpsd(xmm2, xmm7, xmm2)); + TEST_INSTRUCTION("62F2C50D43D2" , k(k5).vgetexpsd(xmm2, xmm7, xmm2)); + TEST_INSTRUCTION("62F2C58D43D2" , k(k5).z().vgetexpsd(xmm2, xmm7, xmm2)); + TEST_INSTRUCTION("62F2C51843D2" , sae().vgetexpsd(xmm2, xmm7, xmm2)); + TEST_INSTRUCTION("62F2C5084311" , vgetexpsd(xmm2, xmm7, qword_ptr(rcx))); + TEST_INSTRUCTION("62B2C5084394F023010000" , vgetexpsd(xmm2, xmm7, qword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62F2C50843527F" , vgetexpsd(xmm2, xmm7, qword_ptr(rdx, 1016))); + TEST_INSTRUCTION("62F2C508439200040000" , vgetexpsd(xmm2, xmm7, qword_ptr(rdx, 1024))); + TEST_INSTRUCTION("62F2C508435280" , vgetexpsd(xmm2, xmm7, qword_ptr(rdx, -1024))); + TEST_INSTRUCTION("62F2C5084392F8FBFFFF" , vgetexpsd(xmm2, xmm7, qword_ptr(rdx, -1032))); + TEST_INSTRUCTION("6282750843E2" , vgetexpss(xmm20, xmm1, xmm26)); + TEST_INSTRUCTION("6282750F43E2" , k(k7).vgetexpss(xmm20, xmm1, xmm26)); + TEST_INSTRUCTION("6282758F43E2" , k(k7).z().vgetexpss(xmm20, xmm1, xmm26)); + TEST_INSTRUCTION("6282751843E2" , sae().vgetexpss(xmm20, xmm1, xmm26)); + TEST_INSTRUCTION("62E275084321" , vgetexpss(xmm20, xmm1, dword_ptr(rcx))); + TEST_INSTRUCTION("62A2750843A4F023010000" , vgetexpss(xmm20, xmm1, dword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62E2750843627F" , vgetexpss(xmm20, xmm1, dword_ptr(rdx, 508))); + TEST_INSTRUCTION("62E2750843A200020000" , vgetexpss(xmm20, xmm1, dword_ptr(rdx, 512))); + TEST_INSTRUCTION("62E27508436280" , vgetexpss(xmm20, xmm1, dword_ptr(rdx, -512))); + TEST_INSTRUCTION("62E2750843A2FCFDFFFF" , vgetexpss(xmm20, xmm1, dword_ptr(rdx, -516))); + TEST_INSTRUCTION("6293FD4826D2AB" , vgetmantpd(zmm2, zmm26, 171)); + TEST_INSTRUCTION("6293FD4F26D2AB" , k(k7).vgetmantpd(zmm2, zmm26, 171)); + TEST_INSTRUCTION("6293FDCF26D2AB" , k(k7).z().vgetmantpd(zmm2, zmm26, 171)); + TEST_INSTRUCTION("6293FD1826D2AB" , sae().vgetmantpd(zmm2, zmm26, 171)); + TEST_INSTRUCTION("6293FD4826D27B" , vgetmantpd(zmm2, zmm26, 123)); + TEST_INSTRUCTION("6293FD1826D27B" , sae().vgetmantpd(zmm2, zmm26, 123)); + TEST_INSTRUCTION("62F3FD4826117B" , vgetmantpd(zmm2, zmmword_ptr(rcx), 123)); + TEST_INSTRUCTION("62B3FD482694F0230100007B" , vgetmantpd(zmm2, zmmword_ptr(rax, r14, 3, 291), 123)); + TEST_INSTRUCTION("62F3FD5826117B" , vgetmantpd(zmm2, qword_ptr(rcx)._1to8(), 123)); + TEST_INSTRUCTION("62F3FD4826527F7B" , vgetmantpd(zmm2, zmmword_ptr(rdx, 8128), 123)); + TEST_INSTRUCTION("62F3FD482692002000007B" , vgetmantpd(zmm2, zmmword_ptr(rdx, 8192), 123)); + TEST_INSTRUCTION("62F3FD482652807B" , vgetmantpd(zmm2, zmmword_ptr(rdx, -8192), 123)); + TEST_INSTRUCTION("62F3FD482692C0DFFFFF7B" , vgetmantpd(zmm2, zmmword_ptr(rdx, -8256), 123)); + TEST_INSTRUCTION("62F3FD5826527F7B" , vgetmantpd(zmm2, qword_ptr(rdx, 1016)._1to8(), 123)); + TEST_INSTRUCTION("62F3FD582692000400007B" , vgetmantpd(zmm2, qword_ptr(rdx, 1024)._1to8(), 123)); + TEST_INSTRUCTION("62F3FD582652807B" , vgetmantpd(zmm2, qword_ptr(rdx, -1024)._1to8(), 123)); + TEST_INSTRUCTION("62F3FD582692F8FBFFFF7B" , vgetmantpd(zmm2, qword_ptr(rdx, -1032)._1to8(), 123)); + TEST_INSTRUCTION("62837D4826F4AB" , vgetmantps(zmm22, zmm28, 171)); + TEST_INSTRUCTION("62837D4B26F4AB" , k(k3).vgetmantps(zmm22, zmm28, 171)); + TEST_INSTRUCTION("62837DCB26F4AB" , k(k3).z().vgetmantps(zmm22, zmm28, 171)); + TEST_INSTRUCTION("62837D1826F4AB" , sae().vgetmantps(zmm22, zmm28, 171)); + TEST_INSTRUCTION("62837D4826F47B" , vgetmantps(zmm22, zmm28, 123)); + TEST_INSTRUCTION("62837D1826F47B" , sae().vgetmantps(zmm22, zmm28, 123)); + TEST_INSTRUCTION("62E37D4826317B" , vgetmantps(zmm22, zmmword_ptr(rcx), 123)); + TEST_INSTRUCTION("62A37D4826B4F0230100007B" , vgetmantps(zmm22, zmmword_ptr(rax, r14, 3, 291), 123)); + TEST_INSTRUCTION("62E37D5826317B" , vgetmantps(zmm22, dword_ptr(rcx)._1to16(), 123)); + TEST_INSTRUCTION("62E37D4826727F7B" , vgetmantps(zmm22, zmmword_ptr(rdx, 8128), 123)); + TEST_INSTRUCTION("62E37D4826B2002000007B" , vgetmantps(zmm22, zmmword_ptr(rdx, 8192), 123)); + TEST_INSTRUCTION("62E37D482672807B" , vgetmantps(zmm22, zmmword_ptr(rdx, -8192), 123)); + TEST_INSTRUCTION("62E37D4826B2C0DFFFFF7B" , vgetmantps(zmm22, zmmword_ptr(rdx, -8256), 123)); + TEST_INSTRUCTION("62E37D5826727F7B" , vgetmantps(zmm22, dword_ptr(rdx, 508)._1to16(), 123)); + TEST_INSTRUCTION("62E37D5826B2000200007B" , vgetmantps(zmm22, dword_ptr(rdx, 512)._1to16(), 123)); + TEST_INSTRUCTION("62E37D582672807B" , vgetmantps(zmm22, dword_ptr(rdx, -512)._1to16(), 123)); + TEST_INSTRUCTION("62E37D5826B2FCFDFFFF7B" , vgetmantps(zmm22, dword_ptr(rdx, -516)._1to16(), 123)); + TEST_INSTRUCTION("62D3A50027D8AB" , vgetmantsd(xmm3, xmm27, xmm8, 171)); + TEST_INSTRUCTION("62D3A50627D8AB" , k(k6).vgetmantsd(xmm3, xmm27, xmm8, 171)); + TEST_INSTRUCTION("62D3A58627D8AB" , k(k6).z().vgetmantsd(xmm3, xmm27, xmm8, 171)); + TEST_INSTRUCTION("62D3A51027D8AB" , sae().vgetmantsd(xmm3, xmm27, xmm8, 171)); + TEST_INSTRUCTION("62D3A50027D87B" , vgetmantsd(xmm3, xmm27, xmm8, 123)); + TEST_INSTRUCTION("62D3A51027D87B" , sae().vgetmantsd(xmm3, xmm27, xmm8, 123)); + TEST_INSTRUCTION("62F3A50027197B" , vgetmantsd(xmm3, xmm27, qword_ptr(rcx), 123)); + TEST_INSTRUCTION("62B3A500279CF0230100007B" , vgetmantsd(xmm3, xmm27, qword_ptr(rax, r14, 3, 291), 123)); + TEST_INSTRUCTION("62F3A500275A7F7B" , vgetmantsd(xmm3, xmm27, qword_ptr(rdx, 1016), 123)); + TEST_INSTRUCTION("62F3A500279A000400007B" , vgetmantsd(xmm3, xmm27, qword_ptr(rdx, 1024), 123)); + TEST_INSTRUCTION("62F3A500275A807B" , vgetmantsd(xmm3, xmm27, qword_ptr(rdx, -1024), 123)); + TEST_INSTRUCTION("62F3A500279AF8FBFFFF7B" , vgetmantsd(xmm3, xmm27, qword_ptr(rdx, -1032), 123)); + TEST_INSTRUCTION("62D36D0827DCAB" , vgetmantss(xmm3, xmm2, xmm12, 171)); + TEST_INSTRUCTION("62D36D0F27DCAB" , k(k7).vgetmantss(xmm3, xmm2, xmm12, 171)); + TEST_INSTRUCTION("62D36D8F27DCAB" , k(k7).z().vgetmantss(xmm3, xmm2, xmm12, 171)); + TEST_INSTRUCTION("62D36D1827DCAB" , sae().vgetmantss(xmm3, xmm2, xmm12, 171)); + TEST_INSTRUCTION("62D36D0827DC7B" , vgetmantss(xmm3, xmm2, xmm12, 123)); + TEST_INSTRUCTION("62D36D1827DC7B" , sae().vgetmantss(xmm3, xmm2, xmm12, 123)); + TEST_INSTRUCTION("62F36D0827197B" , vgetmantss(xmm3, xmm2, dword_ptr(rcx), 123)); + TEST_INSTRUCTION("62B36D08279CF0230100007B" , vgetmantss(xmm3, xmm2, dword_ptr(rax, r14, 3, 291), 123)); + TEST_INSTRUCTION("62F36D08275A7F7B" , vgetmantss(xmm3, xmm2, dword_ptr(rdx, 508), 123)); + TEST_INSTRUCTION("62F36D08279A000200007B" , vgetmantss(xmm3, xmm2, dword_ptr(rdx, 512), 123)); + TEST_INSTRUCTION("62F36D08275A807B" , vgetmantss(xmm3, xmm2, dword_ptr(rdx, -512), 123)); + TEST_INSTRUCTION("62F36D08279AFCFDFFFF7B" , vgetmantss(xmm3, xmm2, dword_ptr(rdx, -516), 123)); + TEST_INSTRUCTION("62732D4018DBAB" , vinsertf32x4(zmm11, zmm26, xmm3, 171)); + TEST_INSTRUCTION("62732D4118DBAB" , k(k1).vinsertf32x4(zmm11, zmm26, xmm3, 171)); + TEST_INSTRUCTION("62732DC118DBAB" , k(k1).z().vinsertf32x4(zmm11, zmm26, xmm3, 171)); + TEST_INSTRUCTION("62732D4018DB7B" , vinsertf32x4(zmm11, zmm26, xmm3, 123)); + TEST_INSTRUCTION("62732D4018197B" , vinsertf32x4(zmm11, zmm26, xmmword_ptr(rcx), 123)); + TEST_INSTRUCTION("62332D40189CF0230100007B" , vinsertf32x4(zmm11, zmm26, xmmword_ptr(rax, r14, 3, 291), 123)); + TEST_INSTRUCTION("62732D40185A7F7B" , vinsertf32x4(zmm11, zmm26, xmmword_ptr(rdx, 2032), 123)); + TEST_INSTRUCTION("62732D40189A000800007B" , vinsertf32x4(zmm11, zmm26, xmmword_ptr(rdx, 2048), 123)); + TEST_INSTRUCTION("62732D40185A807B" , vinsertf32x4(zmm11, zmm26, xmmword_ptr(rdx, -2048), 123)); + TEST_INSTRUCTION("62732D40189AF0F7FFFF7B" , vinsertf32x4(zmm11, zmm26, xmmword_ptr(rdx, -2064), 123)); + TEST_INSTRUCTION("62F3D5481ACFAB" , vinsertf64x4(zmm1, zmm5, ymm7, 171)); + TEST_INSTRUCTION("62F3D5491ACFAB" , k(k1).vinsertf64x4(zmm1, zmm5, ymm7, 171)); + TEST_INSTRUCTION("62F3D5C91ACFAB" , k(k1).z().vinsertf64x4(zmm1, zmm5, ymm7, 171)); + TEST_INSTRUCTION("62F3D5481ACF7B" , vinsertf64x4(zmm1, zmm5, ymm7, 123)); + TEST_INSTRUCTION("62F3D5481A097B" , vinsertf64x4(zmm1, zmm5, ymmword_ptr(rcx), 123)); + TEST_INSTRUCTION("62B3D5481A8CF0230100007B" , vinsertf64x4(zmm1, zmm5, ymmword_ptr(rax, r14, 3, 291), 123)); + TEST_INSTRUCTION("62F3D5481A4A7F7B" , vinsertf64x4(zmm1, zmm5, ymmword_ptr(rdx, 4064), 123)); + TEST_INSTRUCTION("62F3D5481A8A001000007B" , vinsertf64x4(zmm1, zmm5, ymmword_ptr(rdx, 4096), 123)); + TEST_INSTRUCTION("62F3D5481A4A807B" , vinsertf64x4(zmm1, zmm5, ymmword_ptr(rdx, -4096), 123)); + TEST_INSTRUCTION("62F3D5481A8AE0EFFFFF7B" , vinsertf64x4(zmm1, zmm5, ymmword_ptr(rdx, -4128), 123)); + TEST_INSTRUCTION("62C3154838CAAB" , vinserti32x4(zmm17, zmm13, xmm10, 171)); + TEST_INSTRUCTION("62C3154E38CAAB" , k(k6).vinserti32x4(zmm17, zmm13, xmm10, 171)); + TEST_INSTRUCTION("62C315CE38CAAB" , k(k6).z().vinserti32x4(zmm17, zmm13, xmm10, 171)); + TEST_INSTRUCTION("62C3154838CA7B" , vinserti32x4(zmm17, zmm13, xmm10, 123)); + TEST_INSTRUCTION("62E3154838097B" , vinserti32x4(zmm17, zmm13, xmmword_ptr(rcx), 123)); + TEST_INSTRUCTION("62A31548388CF0230100007B" , vinserti32x4(zmm17, zmm13, xmmword_ptr(rax, r14, 3, 291), 123)); + TEST_INSTRUCTION("62E31548384A7F7B" , vinserti32x4(zmm17, zmm13, xmmword_ptr(rdx, 2032), 123)); + TEST_INSTRUCTION("62E31548388A000800007B" , vinserti32x4(zmm17, zmm13, xmmword_ptr(rdx, 2048), 123)); + TEST_INSTRUCTION("62E31548384A807B" , vinserti32x4(zmm17, zmm13, xmmword_ptr(rdx, -2048), 123)); + TEST_INSTRUCTION("62E31548388AF0F7FFFF7B" , vinserti32x4(zmm17, zmm13, xmmword_ptr(rdx, -2064), 123)); + TEST_INSTRUCTION("62F3B5403AE4AB" , vinserti64x4(zmm4, zmm25, ymm4, 171)); + TEST_INSTRUCTION("62F3B5413AE4AB" , k(k1).vinserti64x4(zmm4, zmm25, ymm4, 171)); + TEST_INSTRUCTION("62F3B5C13AE4AB" , k(k1).z().vinserti64x4(zmm4, zmm25, ymm4, 171)); + TEST_INSTRUCTION("62F3B5403AE47B" , vinserti64x4(zmm4, zmm25, ymm4, 123)); + TEST_INSTRUCTION("62F3B5403A217B" , vinserti64x4(zmm4, zmm25, ymmword_ptr(rcx), 123)); + TEST_INSTRUCTION("62B3B5403AA4F0230100007B" , vinserti64x4(zmm4, zmm25, ymmword_ptr(rax, r14, 3, 291), 123)); + TEST_INSTRUCTION("62F3B5403A627F7B" , vinserti64x4(zmm4, zmm25, ymmword_ptr(rdx, 4064), 123)); + TEST_INSTRUCTION("62F3B5403AA2001000007B" , vinserti64x4(zmm4, zmm25, ymmword_ptr(rdx, 4096), 123)); + TEST_INSTRUCTION("62F3B5403A62807B" , vinserti64x4(zmm4, zmm25, ymmword_ptr(rdx, -4096), 123)); + TEST_INSTRUCTION("62F3B5403AA2E0EFFFFF7B" , vinserti64x4(zmm4, zmm25, ymmword_ptr(rdx, -4128), 123)); + TEST_INSTRUCTION("6263750021F5AB" , vinsertps(xmm30, xmm17, xmm5, 171)); + TEST_INSTRUCTION("6263750021F57B" , vinsertps(xmm30, xmm17, xmm5, 123)); + TEST_INSTRUCTION("6263750021317B" , vinsertps(xmm30, xmm17, dword_ptr(rcx), 123)); + TEST_INSTRUCTION("6223750021B4F0230100007B" , vinsertps(xmm30, xmm17, dword_ptr(rax, r14, 3, 291), 123)); + TEST_INSTRUCTION("6263750021727F7B" , vinsertps(xmm30, xmm17, dword_ptr(rdx, 508), 123)); + TEST_INSTRUCTION("6263750021B2000200007B" , vinsertps(xmm30, xmm17, dword_ptr(rdx, 512), 123)); + TEST_INSTRUCTION("626375002172807B" , vinsertps(xmm30, xmm17, dword_ptr(rdx, -512), 123)); + TEST_INSTRUCTION("6263750021B2FCFDFFFF7B" , vinsertps(xmm30, xmm17, dword_ptr(rdx, -516), 123)); + TEST_INSTRUCTION("62219D405FF4" , vmaxpd(zmm30, zmm28, zmm20)); + TEST_INSTRUCTION("62219D415FF4" , k(k1).vmaxpd(zmm30, zmm28, zmm20)); + TEST_INSTRUCTION("62219DC15FF4" , k(k1).z().vmaxpd(zmm30, zmm28, zmm20)); + TEST_INSTRUCTION("62219D105FF4" , sae().vmaxpd(zmm30, zmm28, zmm20)); + TEST_INSTRUCTION("62619D405F31" , vmaxpd(zmm30, zmm28, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62219D405FB4F023010000" , vmaxpd(zmm30, zmm28, zmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62619D505F31" , vmaxpd(zmm30, zmm28, qword_ptr(rcx)._1to8())); + TEST_INSTRUCTION("62619D405F727F" , vmaxpd(zmm30, zmm28, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62619D405FB200200000" , vmaxpd(zmm30, zmm28, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62619D405F7280" , vmaxpd(zmm30, zmm28, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62619D405FB2C0DFFFFF" , vmaxpd(zmm30, zmm28, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62619D505F727F" , vmaxpd(zmm30, zmm28, qword_ptr(rdx, 1016)._1to8())); + TEST_INSTRUCTION("62619D505FB200040000" , vmaxpd(zmm30, zmm28, qword_ptr(rdx, 1024)._1to8())); + TEST_INSTRUCTION("62619D505F7280" , vmaxpd(zmm30, zmm28, qword_ptr(rdx, -1024)._1to8())); + TEST_INSTRUCTION("62619D505FB2F8FBFFFF" , vmaxpd(zmm30, zmm28, qword_ptr(rdx, -1032)._1to8())); + TEST_INSTRUCTION("62214C485FCC" , vmaxps(zmm25, zmm6, zmm20)); + TEST_INSTRUCTION("62214C495FCC" , k(k1).vmaxps(zmm25, zmm6, zmm20)); + TEST_INSTRUCTION("62214CC95FCC" , k(k1).z().vmaxps(zmm25, zmm6, zmm20)); + TEST_INSTRUCTION("62214C185FCC" , sae().vmaxps(zmm25, zmm6, zmm20)); + TEST_INSTRUCTION("62614C485F09" , vmaxps(zmm25, zmm6, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62214C485F8CF023010000" , vmaxps(zmm25, zmm6, zmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62614C585F09" , vmaxps(zmm25, zmm6, dword_ptr(rcx)._1to16())); + TEST_INSTRUCTION("62614C485F4A7F" , vmaxps(zmm25, zmm6, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62614C485F8A00200000" , vmaxps(zmm25, zmm6, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62614C485F4A80" , vmaxps(zmm25, zmm6, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62614C485F8AC0DFFFFF" , vmaxps(zmm25, zmm6, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62614C585F4A7F" , vmaxps(zmm25, zmm6, dword_ptr(rdx, 508)._1to16())); + TEST_INSTRUCTION("62614C585F8A00020000" , vmaxps(zmm25, zmm6, dword_ptr(rdx, 512)._1to16())); + TEST_INSTRUCTION("62614C585F4A80" , vmaxps(zmm25, zmm6, dword_ptr(rdx, -512)._1to16())); + TEST_INSTRUCTION("62614C585F8AFCFDFFFF" , vmaxps(zmm25, zmm6, dword_ptr(rdx, -516)._1to16())); + TEST_INSTRUCTION("6281E7005FE1" , vmaxsd(xmm20, xmm19, xmm25)); + TEST_INSTRUCTION("6281E7035FE1" , k(k3).vmaxsd(xmm20, xmm19, xmm25)); + TEST_INSTRUCTION("6281E7835FE1" , k(k3).z().vmaxsd(xmm20, xmm19, xmm25)); + TEST_INSTRUCTION("6281E7105FE1" , sae().vmaxsd(xmm20, xmm19, xmm25)); + TEST_INSTRUCTION("62E1E7005F21" , vmaxsd(xmm20, xmm19, qword_ptr(rcx))); + TEST_INSTRUCTION("62A1E7005FA4F023010000" , vmaxsd(xmm20, xmm19, qword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62E1E7005F627F" , vmaxsd(xmm20, xmm19, qword_ptr(rdx, 1016))); + TEST_INSTRUCTION("62E1E7005FA200040000" , vmaxsd(xmm20, xmm19, qword_ptr(rdx, 1024))); + TEST_INSTRUCTION("62E1E7005F6280" , vmaxsd(xmm20, xmm19, qword_ptr(rdx, -1024))); + TEST_INSTRUCTION("62E1E7005FA2F8FBFFFF" , vmaxsd(xmm20, xmm19, qword_ptr(rdx, -1032))); + TEST_INSTRUCTION("C55A5FC6" , vmaxss(xmm8, xmm4, xmm6)); + TEST_INSTRUCTION("62715E0C5FC6" , k(k4).vmaxss(xmm8, xmm4, xmm6)); + TEST_INSTRUCTION("62715E8C5FC6" , k(k4).z().vmaxss(xmm8, xmm4, xmm6)); + TEST_INSTRUCTION("62715E185FC6" , sae().vmaxss(xmm8, xmm4, xmm6)); + TEST_INSTRUCTION("C55A5F01" , vmaxss(xmm8, xmm4, dword_ptr(rcx))); + TEST_INSTRUCTION("C4215A5F84F023010000" , vmaxss(xmm8, xmm4, dword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("C55A5F82FC010000" , vmaxss(xmm8, xmm4, dword_ptr(rdx, 508))); + TEST_INSTRUCTION("C55A5F8200020000" , vmaxss(xmm8, xmm4, dword_ptr(rdx, 512))); + TEST_INSTRUCTION("C55A5F8200FEFFFF" , vmaxss(xmm8, xmm4, dword_ptr(rdx, -512))); + TEST_INSTRUCTION("C55A5F82FCFDFFFF" , vmaxss(xmm8, xmm4, dword_ptr(rdx, -516))); + TEST_INSTRUCTION("62B1CD485DF6" , vminpd(zmm6, zmm6, zmm22)); + TEST_INSTRUCTION("62B1CD4F5DF6" , k(k7).vminpd(zmm6, zmm6, zmm22)); + TEST_INSTRUCTION("62B1CDCF5DF6" , k(k7).z().vminpd(zmm6, zmm6, zmm22)); + TEST_INSTRUCTION("62B1CD185DF6" , sae().vminpd(zmm6, zmm6, zmm22)); + TEST_INSTRUCTION("62F1CD485D31" , vminpd(zmm6, zmm6, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62B1CD485DB4F023010000" , vminpd(zmm6, zmm6, zmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62F1CD585D31" , vminpd(zmm6, zmm6, qword_ptr(rcx)._1to8())); + TEST_INSTRUCTION("62F1CD485D727F" , vminpd(zmm6, zmm6, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62F1CD485DB200200000" , vminpd(zmm6, zmm6, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62F1CD485D7280" , vminpd(zmm6, zmm6, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62F1CD485DB2C0DFFFFF" , vminpd(zmm6, zmm6, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62F1CD585D727F" , vminpd(zmm6, zmm6, qword_ptr(rdx, 1016)._1to8())); + TEST_INSTRUCTION("62F1CD585DB200040000" , vminpd(zmm6, zmm6, qword_ptr(rdx, 1024)._1to8())); + TEST_INSTRUCTION("62F1CD585D7280" , vminpd(zmm6, zmm6, qword_ptr(rdx, -1024)._1to8())); + TEST_INSTRUCTION("62F1CD585DB2F8FBFFFF" , vminpd(zmm6, zmm6, qword_ptr(rdx, -1032)._1to8())); + TEST_INSTRUCTION("62F164485DDF" , vminps(zmm3, zmm3, zmm7)); + TEST_INSTRUCTION("62F1644B5DDF" , k(k3).vminps(zmm3, zmm3, zmm7)); + TEST_INSTRUCTION("62F164CB5DDF" , k(k3).z().vminps(zmm3, zmm3, zmm7)); + TEST_INSTRUCTION("62F164185DDF" , sae().vminps(zmm3, zmm3, zmm7)); + TEST_INSTRUCTION("62F164485D19" , vminps(zmm3, zmm3, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62B164485D9CF023010000" , vminps(zmm3, zmm3, zmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62F164585D19" , vminps(zmm3, zmm3, dword_ptr(rcx)._1to16())); + TEST_INSTRUCTION("62F164485D5A7F" , vminps(zmm3, zmm3, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62F164485D9A00200000" , vminps(zmm3, zmm3, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62F164485D5A80" , vminps(zmm3, zmm3, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62F164485D9AC0DFFFFF" , vminps(zmm3, zmm3, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62F164585D5A7F" , vminps(zmm3, zmm3, dword_ptr(rdx, 508)._1to16())); + TEST_INSTRUCTION("62F164585D9A00020000" , vminps(zmm3, zmm3, dword_ptr(rdx, 512)._1to16())); + TEST_INSTRUCTION("62F164585D5A80" , vminps(zmm3, zmm3, dword_ptr(rdx, -512)._1to16())); + TEST_INSTRUCTION("62F164585D9AFCFDFFFF" , vminps(zmm3, zmm3, dword_ptr(rdx, -516)._1to16())); + TEST_INSTRUCTION("6291B7005DEA" , vminsd(xmm5, xmm25, xmm26)); + TEST_INSTRUCTION("6291B7035DEA" , k(k3).vminsd(xmm5, xmm25, xmm26)); + TEST_INSTRUCTION("6291B7835DEA" , k(k3).z().vminsd(xmm5, xmm25, xmm26)); + TEST_INSTRUCTION("6291B7105DEA" , sae().vminsd(xmm5, xmm25, xmm26)); + TEST_INSTRUCTION("62F1B7005D29" , vminsd(xmm5, xmm25, qword_ptr(rcx))); + TEST_INSTRUCTION("62B1B7005DACF023010000" , vminsd(xmm5, xmm25, qword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62F1B7005D6A7F" , vminsd(xmm5, xmm25, qword_ptr(rdx, 1016))); + TEST_INSTRUCTION("62F1B7005DAA00040000" , vminsd(xmm5, xmm25, qword_ptr(rdx, 1024))); + TEST_INSTRUCTION("62F1B7005D6A80" , vminsd(xmm5, xmm25, qword_ptr(rdx, -1024))); + TEST_INSTRUCTION("62F1B7005DAAF8FBFFFF" , vminsd(xmm5, xmm25, qword_ptr(rdx, -1032))); + TEST_INSTRUCTION("623176005DD3" , vminss(xmm10, xmm17, xmm19)); + TEST_INSTRUCTION("623176055DD3" , k(k5).vminss(xmm10, xmm17, xmm19)); + TEST_INSTRUCTION("623176855DD3" , k(k5).z().vminss(xmm10, xmm17, xmm19)); + TEST_INSTRUCTION("623176105DD3" , sae().vminss(xmm10, xmm17, xmm19)); + TEST_INSTRUCTION("627176005D11" , vminss(xmm10, xmm17, dword_ptr(rcx))); + TEST_INSTRUCTION("623176005D94F023010000" , vminss(xmm10, xmm17, dword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("627176005D527F" , vminss(xmm10, xmm17, dword_ptr(rdx, 508))); + TEST_INSTRUCTION("627176005D9200020000" , vminss(xmm10, xmm17, dword_ptr(rdx, 512))); + TEST_INSTRUCTION("627176005D5280" , vminss(xmm10, xmm17, dword_ptr(rdx, -512))); + TEST_INSTRUCTION("627176005D92FCFDFFFF" , vminss(xmm10, xmm17, dword_ptr(rdx, -516))); + TEST_INSTRUCTION("62D1FD4828FE" , vmovapd(zmm7, zmm14)); + TEST_INSTRUCTION("62D1FD4D28FE" , k(k5).vmovapd(zmm7, zmm14)); + TEST_INSTRUCTION("62D1FDCD28FE" , k(k5).z().vmovapd(zmm7, zmm14)); + TEST_INSTRUCTION("62F1FD482839" , vmovapd(zmm7, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62B1FD4828BCF023010000" , vmovapd(zmm7, zmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62F1FD48287A7F" , vmovapd(zmm7, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62F1FD4828BA00200000" , vmovapd(zmm7, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62F1FD48287A80" , vmovapd(zmm7, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62F1FD4828BAC0DFFFFF" , vmovapd(zmm7, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62D17C4828E9" , vmovaps(zmm5, zmm9)); + TEST_INSTRUCTION("62D17C4928E9" , k(k1).vmovaps(zmm5, zmm9)); + TEST_INSTRUCTION("62D17CC928E9" , k(k1).z().vmovaps(zmm5, zmm9)); + TEST_INSTRUCTION("62F17C482829" , vmovaps(zmm5, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62B17C4828ACF023010000" , vmovaps(zmm5, zmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62F17C48286A7F" , vmovaps(zmm5, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62F17C4828AA00200000" , vmovaps(zmm5, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62F17C48286A80" , vmovaps(zmm5, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62F17C4828AAC0DFFFFF" , vmovaps(zmm5, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62617D086ED0" , vmovd(xmm26, eax)); + TEST_INSTRUCTION("62617D086ED5" , vmovd(xmm26, ebp)); + TEST_INSTRUCTION("62417D086ED5" , vmovd(xmm26, r13d)); + TEST_INSTRUCTION("62617D086E11" , vmovd(xmm26, dword_ptr(rcx))); + TEST_INSTRUCTION("62217D086E94F023010000" , vmovd(xmm26, dword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62617D086E527F" , vmovd(xmm26, dword_ptr(rdx, 508))); + TEST_INSTRUCTION("62617D086E9200020000" , vmovd(xmm26, dword_ptr(rdx, 512))); + TEST_INSTRUCTION("62617D086E5280" , vmovd(xmm26, dword_ptr(rdx, -512))); + TEST_INSTRUCTION("62617D086E92FCFDFFFF" , vmovd(xmm26, dword_ptr(rdx, -516))); + TEST_INSTRUCTION("C5F97E29" , vmovd(dword_ptr(rcx), xmm5)); + TEST_INSTRUCTION("C4A1797EACF023010000" , vmovd(dword_ptr(rax, r14, 3, 291), xmm5)); + TEST_INSTRUCTION("C5F97EAAFC010000" , vmovd(dword_ptr(rdx, 508), xmm5)); + TEST_INSTRUCTION("C5F97EAA00020000" , vmovd(dword_ptr(rdx, 512), xmm5)); + TEST_INSTRUCTION("C5F97EAA00FEFFFF" , vmovd(dword_ptr(rdx, -512), xmm5)); + TEST_INSTRUCTION("C5F97EAAFCFDFFFF" , vmovd(dword_ptr(rdx, -516), xmm5)); + TEST_INSTRUCTION("6291FF4812ED" , vmovddup(zmm5, zmm29)); + TEST_INSTRUCTION("6291FF4C12ED" , k(k4).vmovddup(zmm5, zmm29)); + TEST_INSTRUCTION("6291FFCC12ED" , k(k4).z().vmovddup(zmm5, zmm29)); + TEST_INSTRUCTION("62F1FF481229" , vmovddup(zmm5, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62B1FF4812ACF023010000" , vmovddup(zmm5, zmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62F1FF48126A7F" , vmovddup(zmm5, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62F1FF4812AA00200000" , vmovddup(zmm5, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62F1FF48126A80" , vmovddup(zmm5, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62F1FF4812AAC0DFFFFF" , vmovddup(zmm5, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62A17D486FF2" , vmovdqa32(zmm22, zmm18)); + TEST_INSTRUCTION("62A17D4E6FF2" , k(k6).vmovdqa32(zmm22, zmm18)); + TEST_INSTRUCTION("62A17DCE6FF2" , k(k6).z().vmovdqa32(zmm22, zmm18)); + TEST_INSTRUCTION("62E17D486F31" , vmovdqa32(zmm22, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62A17D486FB4F023010000" , vmovdqa32(zmm22, zmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62E17D486F727F" , vmovdqa32(zmm22, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62E17D486FB200200000" , vmovdqa32(zmm22, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62E17D486F7280" , vmovdqa32(zmm22, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62E17D486FB2C0DFFFFF" , vmovdqa32(zmm22, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62C1FD486FF4" , vmovdqa64(zmm22, zmm12)); + TEST_INSTRUCTION("62C1FD4D6FF4" , k(k5).vmovdqa64(zmm22, zmm12)); + TEST_INSTRUCTION("62C1FDCD6FF4" , k(k5).z().vmovdqa64(zmm22, zmm12)); + TEST_INSTRUCTION("62E1FD486F31" , vmovdqa64(zmm22, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62A1FD486FB4F023010000" , vmovdqa64(zmm22, zmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62E1FD486F727F" , vmovdqa64(zmm22, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62E1FD486FB200200000" , vmovdqa64(zmm22, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62E1FD486F7280" , vmovdqa64(zmm22, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62E1FD486FB2C0DFFFFF" , vmovdqa64(zmm22, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62917E486FE8" , vmovdqu32(zmm5, zmm24)); + TEST_INSTRUCTION("62917E4D6FE8" , k(k5).vmovdqu32(zmm5, zmm24)); + TEST_INSTRUCTION("62917ECD6FE8" , k(k5).z().vmovdqu32(zmm5, zmm24)); + TEST_INSTRUCTION("62F17E486F29" , vmovdqu32(zmm5, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62B17E486FACF023010000" , vmovdqu32(zmm5, zmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62F17E486F6A7F" , vmovdqu32(zmm5, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62F17E486FAA00200000" , vmovdqu32(zmm5, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62F17E486F6A80" , vmovdqu32(zmm5, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62F17E486FAAC0DFFFFF" , vmovdqu32(zmm5, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62D1FE486FF7" , vmovdqu64(zmm6, zmm15)); + TEST_INSTRUCTION("62D1FE4B6FF7" , k(k3).vmovdqu64(zmm6, zmm15)); + TEST_INSTRUCTION("62D1FECB6FF7" , k(k3).z().vmovdqu64(zmm6, zmm15)); + TEST_INSTRUCTION("62F1FE486F31" , vmovdqu64(zmm6, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62B1FE486FB4F023010000" , vmovdqu64(zmm6, zmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62F1FE486F727F" , vmovdqu64(zmm6, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62F1FE486FB200200000" , vmovdqu64(zmm6, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62F1FE486F7280" , vmovdqu64(zmm6, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62F1FE486FB2C0DFFFFF" , vmovdqu64(zmm6, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62A1740812D7" , vmovhlps(xmm18, xmm1, xmm23)); + TEST_INSTRUCTION("62E19D001619" , vmovhpd(xmm19, xmm28, qword_ptr(rcx))); + TEST_INSTRUCTION("62A19D00169CF023010000" , vmovhpd(xmm19, xmm28, qword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62E19D00165A7F" , vmovhpd(xmm19, xmm28, qword_ptr(rdx, 1016))); + TEST_INSTRUCTION("62E19D00169A00040000" , vmovhpd(xmm19, xmm28, qword_ptr(rdx, 1024))); + TEST_INSTRUCTION("62E19D00165A80" , vmovhpd(xmm19, xmm28, qword_ptr(rdx, -1024))); + TEST_INSTRUCTION("62E19D00169AF8FBFFFF" , vmovhpd(xmm19, xmm28, qword_ptr(rdx, -1032))); + TEST_INSTRUCTION("C5791739" , vmovhpd(qword_ptr(rcx), xmm15)); + TEST_INSTRUCTION("C4217917BCF023010000" , vmovhpd(qword_ptr(rax, r14, 3, 291), xmm15)); + TEST_INSTRUCTION("C57917BAF8030000" , vmovhpd(qword_ptr(rdx, 1016), xmm15)); + TEST_INSTRUCTION("C57917BA00040000" , vmovhpd(qword_ptr(rdx, 1024), xmm15)); + TEST_INSTRUCTION("C57917BA00FCFFFF" , vmovhpd(qword_ptr(rdx, -1024), xmm15)); + TEST_INSTRUCTION("C57917BAF8FBFFFF" , vmovhpd(qword_ptr(rdx, -1032), xmm15)); + TEST_INSTRUCTION("62E174001621" , vmovhps(xmm20, xmm17, qword_ptr(rcx))); + TEST_INSTRUCTION("62A1740016A4F023010000" , vmovhps(xmm20, xmm17, qword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62E1740016627F" , vmovhps(xmm20, xmm17, qword_ptr(rdx, 1016))); + TEST_INSTRUCTION("62E1740016A200040000" , vmovhps(xmm20, xmm17, qword_ptr(rdx, 1024))); + TEST_INSTRUCTION("62E17400166280" , vmovhps(xmm20, xmm17, qword_ptr(rdx, -1024))); + TEST_INSTRUCTION("62E1740016A2F8FBFFFF" , vmovhps(xmm20, xmm17, qword_ptr(rdx, -1032))); + TEST_INSTRUCTION("62E17C081711" , vmovhps(qword_ptr(rcx), xmm18)); + TEST_INSTRUCTION("62A17C081794F023010000" , vmovhps(qword_ptr(rax, r14, 3, 291), xmm18)); + TEST_INSTRUCTION("62E17C0817527F" , vmovhps(qword_ptr(rdx, 1016), xmm18)); + TEST_INSTRUCTION("62E17C08179200040000" , vmovhps(qword_ptr(rdx, 1024), xmm18)); + TEST_INSTRUCTION("62E17C08175280" , vmovhps(qword_ptr(rdx, -1024), xmm18)); + TEST_INSTRUCTION("62E17C081792F8FBFFFF" , vmovhps(qword_ptr(rdx, -1032), xmm18)); + TEST_INSTRUCTION("6211140816EC" , vmovlhps(xmm13, xmm13, xmm28)); + TEST_INSTRUCTION("6261CD081229" , vmovlpd(xmm29, xmm6, qword_ptr(rcx))); + TEST_INSTRUCTION("6221CD0812ACF023010000" , vmovlpd(xmm29, xmm6, qword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("6261CD08126A7F" , vmovlpd(xmm29, xmm6, qword_ptr(rdx, 1016))); + TEST_INSTRUCTION("6261CD0812AA00040000" , vmovlpd(xmm29, xmm6, qword_ptr(rdx, 1024))); + TEST_INSTRUCTION("6261CD08126A80" , vmovlpd(xmm29, xmm6, qword_ptr(rdx, -1024))); + TEST_INSTRUCTION("6261CD0812AAF8FBFFFF" , vmovlpd(xmm29, xmm6, qword_ptr(rdx, -1032))); + TEST_INSTRUCTION("C5791339" , vmovlpd(qword_ptr(rcx), xmm15)); + TEST_INSTRUCTION("C4217913BCF023010000" , vmovlpd(qword_ptr(rax, r14, 3, 291), xmm15)); + TEST_INSTRUCTION("C57913BAF8030000" , vmovlpd(qword_ptr(rdx, 1016), xmm15)); + TEST_INSTRUCTION("C57913BA00040000" , vmovlpd(qword_ptr(rdx, 1024), xmm15)); + TEST_INSTRUCTION("C57913BA00FCFFFF" , vmovlpd(qword_ptr(rdx, -1024), xmm15)); + TEST_INSTRUCTION("C57913BAF8FBFFFF" , vmovlpd(qword_ptr(rdx, -1032), xmm15)); + TEST_INSTRUCTION("62F15C001239" , vmovlps(xmm7, xmm20, qword_ptr(rcx))); + TEST_INSTRUCTION("62B15C0012BCF023010000" , vmovlps(xmm7, xmm20, qword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62F15C00127A7F" , vmovlps(xmm7, xmm20, qword_ptr(rdx, 1016))); + TEST_INSTRUCTION("62F15C0012BA00040000" , vmovlps(xmm7, xmm20, qword_ptr(rdx, 1024))); + TEST_INSTRUCTION("62F15C00127A80" , vmovlps(xmm7, xmm20, qword_ptr(rdx, -1024))); + TEST_INSTRUCTION("62F15C0012BAF8FBFFFF" , vmovlps(xmm7, xmm20, qword_ptr(rdx, -1032))); + TEST_INSTRUCTION("62617C081319" , vmovlps(qword_ptr(rcx), xmm27)); + TEST_INSTRUCTION("62217C08139CF023010000" , vmovlps(qword_ptr(rax, r14, 3, 291), xmm27)); + TEST_INSTRUCTION("62617C08135A7F" , vmovlps(qword_ptr(rdx, 1016), xmm27)); + TEST_INSTRUCTION("62617C08139A00040000" , vmovlps(qword_ptr(rdx, 1024), xmm27)); + TEST_INSTRUCTION("62617C08135A80" , vmovlps(qword_ptr(rdx, -1024), xmm27)); + TEST_INSTRUCTION("62617C08139AF8FBFFFF" , vmovlps(qword_ptr(rdx, -1032), xmm27)); + TEST_INSTRUCTION("62617D48E701" , vmovntdq(zmmword_ptr(rcx), zmm24)); + TEST_INSTRUCTION("62217D48E784F023010000" , vmovntdq(zmmword_ptr(rax, r14, 3, 291), zmm24)); + TEST_INSTRUCTION("62617D48E7427F" , vmovntdq(zmmword_ptr(rdx, 8128), zmm24)); + TEST_INSTRUCTION("62617D48E78200200000" , vmovntdq(zmmword_ptr(rdx, 8192), zmm24)); + TEST_INSTRUCTION("62617D48E74280" , vmovntdq(zmmword_ptr(rdx, -8192), zmm24)); + TEST_INSTRUCTION("62617D48E782C0DFFFFF" , vmovntdq(zmmword_ptr(rdx, -8256), zmm24)); + TEST_INSTRUCTION("62E27D482A09" , vmovntdqa(zmm17, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62A27D482A8CF023010000" , vmovntdqa(zmm17, zmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62E27D482A4A7F" , vmovntdqa(zmm17, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62E27D482A8A00200000" , vmovntdqa(zmm17, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62E27D482A4A80" , vmovntdqa(zmm17, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62E27D482A8AC0DFFFFF" , vmovntdqa(zmm17, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62E1FD482B09" , vmovntpd(zmmword_ptr(rcx), zmm17)); + TEST_INSTRUCTION("62A1FD482B8CF023010000" , vmovntpd(zmmword_ptr(rax, r14, 3, 291), zmm17)); + TEST_INSTRUCTION("62E1FD482B4A7F" , vmovntpd(zmmword_ptr(rdx, 8128), zmm17)); + TEST_INSTRUCTION("62E1FD482B8A00200000" , vmovntpd(zmmword_ptr(rdx, 8192), zmm17)); + TEST_INSTRUCTION("62E1FD482B4A80" , vmovntpd(zmmword_ptr(rdx, -8192), zmm17)); + TEST_INSTRUCTION("62E1FD482B8AC0DFFFFF" , vmovntpd(zmmword_ptr(rdx, -8256), zmm17)); + TEST_INSTRUCTION("62F17C482B29" , vmovntps(zmmword_ptr(rcx), zmm5)); + TEST_INSTRUCTION("62B17C482BACF023010000" , vmovntps(zmmword_ptr(rax, r14, 3, 291), zmm5)); + TEST_INSTRUCTION("62F17C482B6A7F" , vmovntps(zmmword_ptr(rdx, 8128), zmm5)); + TEST_INSTRUCTION("62F17C482BAA00200000" , vmovntps(zmmword_ptr(rdx, 8192), zmm5)); + TEST_INSTRUCTION("62F17C482B6A80" , vmovntps(zmmword_ptr(rdx, -8192), zmm5)); + TEST_INSTRUCTION("62F17C482BAAC0DFFFFF" , vmovntps(zmmword_ptr(rdx, -8256), zmm5)); + TEST_INSTRUCTION("6261FF081009" , vmovsd(xmm25, qword_ptr(rcx))); + TEST_INSTRUCTION("6261FF0B1009" , k(k3).vmovsd(xmm25, qword_ptr(rcx))); + TEST_INSTRUCTION("6261FF8B1009" , k(k3).z().vmovsd(xmm25, qword_ptr(rcx))); + TEST_INSTRUCTION("6221FF08108CF023010000" , vmovsd(xmm25, qword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("6261FF08104A7F" , vmovsd(xmm25, qword_ptr(rdx, 1016))); + TEST_INSTRUCTION("6261FF08108A00040000" , vmovsd(xmm25, qword_ptr(rdx, 1024))); + TEST_INSTRUCTION("6261FF08104A80" , vmovsd(xmm25, qword_ptr(rdx, -1024))); + TEST_INSTRUCTION("6261FF08108AF8FBFFFF" , vmovsd(xmm25, qword_ptr(rdx, -1032))); + TEST_INSTRUCTION("6261FF081109" , vmovsd(qword_ptr(rcx), xmm25)); + TEST_INSTRUCTION("6261FF0A1109" , k(k2).vmovsd(qword_ptr(rcx), xmm25)); + TEST_INSTRUCTION("6221FF08118CF023010000" , vmovsd(qword_ptr(rax, r14, 3, 291), xmm25)); + TEST_INSTRUCTION("6261FF08114A7F" , vmovsd(qword_ptr(rdx, 1016), xmm25)); + TEST_INSTRUCTION("6261FF08118A00040000" , vmovsd(qword_ptr(rdx, 1024), xmm25)); + TEST_INSTRUCTION("6261FF08114A80" , vmovsd(qword_ptr(rdx, -1024), xmm25)); + TEST_INSTRUCTION("6261FF08118AF8FBFFFF" , vmovsd(qword_ptr(rdx, -1032), xmm25)); + TEST_INSTRUCTION("6221E70810DB" , vmovsd(xmm27, xmm3, xmm19)); + TEST_INSTRUCTION("6221E70B10DB" , k(k3).vmovsd(xmm27, xmm3, xmm19)); + TEST_INSTRUCTION("6221E78B10DB" , k(k3).z().vmovsd(xmm27, xmm3, xmm19)); + TEST_INSTRUCTION("62817E4816C3" , vmovshdup(zmm16, zmm27)); + TEST_INSTRUCTION("62817E4C16C3" , k(k4).vmovshdup(zmm16, zmm27)); + TEST_INSTRUCTION("62817ECC16C3" , k(k4).z().vmovshdup(zmm16, zmm27)); + TEST_INSTRUCTION("62E17E481601" , vmovshdup(zmm16, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62A17E481684F023010000" , vmovshdup(zmm16, zmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62E17E4816427F" , vmovshdup(zmm16, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62E17E48168200200000" , vmovshdup(zmm16, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62E17E48164280" , vmovshdup(zmm16, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62E17E481682C0DFFFFF" , vmovshdup(zmm16, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62517E4812EE" , vmovsldup(zmm13, zmm14)); + TEST_INSTRUCTION("62517E4E12EE" , k(k6).vmovsldup(zmm13, zmm14)); + TEST_INSTRUCTION("62517ECE12EE" , k(k6).z().vmovsldup(zmm13, zmm14)); + TEST_INSTRUCTION("62717E481229" , vmovsldup(zmm13, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62317E4812ACF023010000" , vmovsldup(zmm13, zmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62717E48126A7F" , vmovsldup(zmm13, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62717E4812AA00200000" , vmovsldup(zmm13, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62717E48126A80" , vmovsldup(zmm13, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62717E4812AAC0DFFFFF" , vmovsldup(zmm13, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("C5FA1011" , vmovss(xmm2, dword_ptr(rcx))); + TEST_INSTRUCTION("62F17E0C1011" , k(k4).vmovss(xmm2, dword_ptr(rcx))); + TEST_INSTRUCTION("62F17E8C1011" , k(k4).z().vmovss(xmm2, dword_ptr(rcx))); + TEST_INSTRUCTION("C4A17A1094F023010000" , vmovss(xmm2, dword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("C5FA1092FC010000" , vmovss(xmm2, dword_ptr(rdx, 508))); + TEST_INSTRUCTION("C5FA109200020000" , vmovss(xmm2, dword_ptr(rdx, 512))); + TEST_INSTRUCTION("C5FA109200FEFFFF" , vmovss(xmm2, dword_ptr(rdx, -512))); + TEST_INSTRUCTION("C5FA1092FCFDFFFF" , vmovss(xmm2, dword_ptr(rdx, -516))); + TEST_INSTRUCTION("C5FA1129" , vmovss(dword_ptr(rcx), xmm5)); + TEST_INSTRUCTION("62F17E0E1129" , k(k6).vmovss(dword_ptr(rcx), xmm5)); + TEST_INSTRUCTION("C4A17A11ACF023010000" , vmovss(dword_ptr(rax, r14, 3, 291), xmm5)); + TEST_INSTRUCTION("C5FA11AAFC010000" , vmovss(dword_ptr(rdx, 508), xmm5)); + TEST_INSTRUCTION("C5FA11AA00020000" , vmovss(dword_ptr(rdx, 512), xmm5)); + TEST_INSTRUCTION("C5FA11AA00FEFFFF" , vmovss(dword_ptr(rdx, -512), xmm5)); + TEST_INSTRUCTION("C5FA11AAFCFDFFFF" , vmovss(dword_ptr(rdx, -516), xmm5)); + TEST_INSTRUCTION("6201360810E2" , vmovss(xmm28, xmm9, xmm26)); + TEST_INSTRUCTION("6201360C10E2" , k(k4).vmovss(xmm28, xmm9, xmm26)); + TEST_INSTRUCTION("6201368C10E2" , k(k4).z().vmovss(xmm28, xmm9, xmm26)); + TEST_INSTRUCTION("6241FD4810D9" , vmovupd(zmm27, zmm9)); + TEST_INSTRUCTION("6241FD4A10D9" , k(k2).vmovupd(zmm27, zmm9)); + TEST_INSTRUCTION("6241FDCA10D9" , k(k2).z().vmovupd(zmm27, zmm9)); + TEST_INSTRUCTION("6261FD481019" , vmovupd(zmm27, zmmword_ptr(rcx))); + TEST_INSTRUCTION("6221FD48109CF023010000" , vmovupd(zmm27, zmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("6261FD48105A7F" , vmovupd(zmm27, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("6261FD48109A00200000" , vmovupd(zmm27, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("6261FD48105A80" , vmovupd(zmm27, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("6261FD48109AC0DFFFFF" , vmovupd(zmm27, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62A17C4810F6" , vmovups(zmm22, zmm22)); + TEST_INSTRUCTION("62A17C4B10F6" , k(k3).vmovups(zmm22, zmm22)); + TEST_INSTRUCTION("62A17CCB10F6" , k(k3).z().vmovups(zmm22, zmm22)); + TEST_INSTRUCTION("62E17C481031" , vmovups(zmm22, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62A17C4810B4F023010000" , vmovups(zmm22, zmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62E17C4810727F" , vmovups(zmm22, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62E17C4810B200200000" , vmovups(zmm22, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62E17C48107280" , vmovups(zmm22, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62E17C4810B2C0DFFFFF" , vmovups(zmm22, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("6221DD4859C7" , vmulpd(zmm24, zmm4, zmm23)); + TEST_INSTRUCTION("6221DD4E59C7" , k(k6).vmulpd(zmm24, zmm4, zmm23)); + TEST_INSTRUCTION("6221DDCE59C7" , k(k6).z().vmulpd(zmm24, zmm4, zmm23)); + TEST_INSTRUCTION("6221DD1859C7" , rn_sae().vmulpd(zmm24, zmm4, zmm23)); + TEST_INSTRUCTION("6221DD5859C7" , ru_sae().vmulpd(zmm24, zmm4, zmm23)); + TEST_INSTRUCTION("6221DD3859C7" , rd_sae().vmulpd(zmm24, zmm4, zmm23)); + TEST_INSTRUCTION("6221DD7859C7" , rz_sae().vmulpd(zmm24, zmm4, zmm23)); + TEST_INSTRUCTION("6261DD485901" , vmulpd(zmm24, zmm4, zmmword_ptr(rcx))); + TEST_INSTRUCTION("6221DD485984F023010000" , vmulpd(zmm24, zmm4, zmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("6261DD585901" , vmulpd(zmm24, zmm4, qword_ptr(rcx)._1to8())); + TEST_INSTRUCTION("6261DD4859427F" , vmulpd(zmm24, zmm4, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("6261DD48598200200000" , vmulpd(zmm24, zmm4, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("6261DD48594280" , vmulpd(zmm24, zmm4, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("6261DD485982C0DFFFFF" , vmulpd(zmm24, zmm4, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("6261DD5859427F" , vmulpd(zmm24, zmm4, qword_ptr(rdx, 1016)._1to8())); + TEST_INSTRUCTION("6261DD58598200040000" , vmulpd(zmm24, zmm4, qword_ptr(rdx, 1024)._1to8())); + TEST_INSTRUCTION("6261DD58594280" , vmulpd(zmm24, zmm4, qword_ptr(rdx, -1024)._1to8())); + TEST_INSTRUCTION("6261DD585982F8FBFFFF" , vmulpd(zmm24, zmm4, qword_ptr(rdx, -1032)._1to8())); + TEST_INSTRUCTION("62914C4859D8" , vmulps(zmm3, zmm6, zmm24)); + TEST_INSTRUCTION("62914C4C59D8" , k(k4).vmulps(zmm3, zmm6, zmm24)); + TEST_INSTRUCTION("62914CCC59D8" , k(k4).z().vmulps(zmm3, zmm6, zmm24)); + TEST_INSTRUCTION("62914C1859D8" , rn_sae().vmulps(zmm3, zmm6, zmm24)); + TEST_INSTRUCTION("62914C5859D8" , ru_sae().vmulps(zmm3, zmm6, zmm24)); + TEST_INSTRUCTION("62914C3859D8" , rd_sae().vmulps(zmm3, zmm6, zmm24)); + TEST_INSTRUCTION("62914C7859D8" , rz_sae().vmulps(zmm3, zmm6, zmm24)); + TEST_INSTRUCTION("62F14C485919" , vmulps(zmm3, zmm6, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62B14C48599CF023010000" , vmulps(zmm3, zmm6, zmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62F14C585919" , vmulps(zmm3, zmm6, dword_ptr(rcx)._1to16())); + TEST_INSTRUCTION("62F14C48595A7F" , vmulps(zmm3, zmm6, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62F14C48599A00200000" , vmulps(zmm3, zmm6, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62F14C48595A80" , vmulps(zmm3, zmm6, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62F14C48599AC0DFFFFF" , vmulps(zmm3, zmm6, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62F14C58595A7F" , vmulps(zmm3, zmm6, dword_ptr(rdx, 508)._1to16())); + TEST_INSTRUCTION("62F14C58599A00020000" , vmulps(zmm3, zmm6, dword_ptr(rdx, 512)._1to16())); + TEST_INSTRUCTION("62F14C58595A80" , vmulps(zmm3, zmm6, dword_ptr(rdx, -512)._1to16())); + TEST_INSTRUCTION("62F14C58599AFCFDFFFF" , vmulps(zmm3, zmm6, dword_ptr(rdx, -516)._1to16())); + TEST_INSTRUCTION("6231DF0859EA" , vmulsd(xmm13, xmm4, xmm18)); + TEST_INSTRUCTION("6231DF0A59EA" , k(k2).vmulsd(xmm13, xmm4, xmm18)); + TEST_INSTRUCTION("6231DF8A59EA" , k(k2).z().vmulsd(xmm13, xmm4, xmm18)); + TEST_INSTRUCTION("6231DF1859EA" , rn_sae().vmulsd(xmm13, xmm4, xmm18)); + TEST_INSTRUCTION("6231DF5859EA" , ru_sae().vmulsd(xmm13, xmm4, xmm18)); + TEST_INSTRUCTION("6231DF3859EA" , rd_sae().vmulsd(xmm13, xmm4, xmm18)); + TEST_INSTRUCTION("6231DF7859EA" , rz_sae().vmulsd(xmm13, xmm4, xmm18)); + TEST_INSTRUCTION("C55B5929" , vmulsd(xmm13, xmm4, qword_ptr(rcx))); + TEST_INSTRUCTION("C4215B59ACF023010000" , vmulsd(xmm13, xmm4, qword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("C55B59AAF8030000" , vmulsd(xmm13, xmm4, qword_ptr(rdx, 1016))); + TEST_INSTRUCTION("C55B59AA00040000" , vmulsd(xmm13, xmm4, qword_ptr(rdx, 1024))); + TEST_INSTRUCTION("C55B59AA00FCFFFF" , vmulsd(xmm13, xmm4, qword_ptr(rdx, -1024))); + TEST_INSTRUCTION("C55B59AAF8FBFFFF" , vmulsd(xmm13, xmm4, qword_ptr(rdx, -1032))); + TEST_INSTRUCTION("62C12E0859F6" , vmulss(xmm22, xmm10, xmm14)); + TEST_INSTRUCTION("62C12E0C59F6" , k(k4).vmulss(xmm22, xmm10, xmm14)); + TEST_INSTRUCTION("62C12E8C59F6" , k(k4).z().vmulss(xmm22, xmm10, xmm14)); + TEST_INSTRUCTION("62C12E1859F6" , rn_sae().vmulss(xmm22, xmm10, xmm14)); + TEST_INSTRUCTION("62C12E5859F6" , ru_sae().vmulss(xmm22, xmm10, xmm14)); + TEST_INSTRUCTION("62C12E3859F6" , rd_sae().vmulss(xmm22, xmm10, xmm14)); + TEST_INSTRUCTION("62C12E7859F6" , rz_sae().vmulss(xmm22, xmm10, xmm14)); + TEST_INSTRUCTION("62E12E085931" , vmulss(xmm22, xmm10, dword_ptr(rcx))); + TEST_INSTRUCTION("62A12E0859B4F023010000" , vmulss(xmm22, xmm10, dword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62E12E0859727F" , vmulss(xmm22, xmm10, dword_ptr(rdx, 508))); + TEST_INSTRUCTION("62E12E0859B200020000" , vmulss(xmm22, xmm10, dword_ptr(rdx, 512))); + TEST_INSTRUCTION("62E12E08597280" , vmulss(xmm22, xmm10, dword_ptr(rdx, -512))); + TEST_INSTRUCTION("62E12E0859B2FCFDFFFF" , vmulss(xmm22, xmm10, dword_ptr(rdx, -516))); + TEST_INSTRUCTION("62527D481EFE" , vpabsd(zmm15, zmm14)); + TEST_INSTRUCTION("62527D4E1EFE" , k(k6).vpabsd(zmm15, zmm14)); + TEST_INSTRUCTION("62527DCE1EFE" , k(k6).z().vpabsd(zmm15, zmm14)); + TEST_INSTRUCTION("62727D481E39" , vpabsd(zmm15, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62327D481EBCF023010000" , vpabsd(zmm15, zmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62727D581E39" , vpabsd(zmm15, dword_ptr(rcx)._1to16())); + TEST_INSTRUCTION("62727D481E7A7F" , vpabsd(zmm15, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62727D481EBA00200000" , vpabsd(zmm15, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62727D481E7A80" , vpabsd(zmm15, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62727D481EBAC0DFFFFF" , vpabsd(zmm15, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62727D581E7A7F" , vpabsd(zmm15, dword_ptr(rdx, 508)._1to16())); + TEST_INSTRUCTION("62727D581EBA00020000" , vpabsd(zmm15, dword_ptr(rdx, 512)._1to16())); + TEST_INSTRUCTION("62727D581E7A80" , vpabsd(zmm15, dword_ptr(rdx, -512)._1to16())); + TEST_INSTRUCTION("62727D581EBAFCFDFFFF" , vpabsd(zmm15, dword_ptr(rdx, -516)._1to16())); + TEST_INSTRUCTION("6292FD481FE8" , vpabsq(zmm5, zmm24)); + TEST_INSTRUCTION("6292FD4E1FE8" , k(k6).vpabsq(zmm5, zmm24)); + TEST_INSTRUCTION("6292FDCE1FE8" , k(k6).z().vpabsq(zmm5, zmm24)); + TEST_INSTRUCTION("62F2FD481F29" , vpabsq(zmm5, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62B2FD481FACF023010000" , vpabsq(zmm5, zmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62F2FD581F29" , vpabsq(zmm5, qword_ptr(rcx)._1to8())); + TEST_INSTRUCTION("62F2FD481F6A7F" , vpabsq(zmm5, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62F2FD481FAA00200000" , vpabsq(zmm5, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62F2FD481F6A80" , vpabsq(zmm5, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62F2FD481FAAC0DFFFFF" , vpabsq(zmm5, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62F2FD581F6A7F" , vpabsq(zmm5, qword_ptr(rdx, 1016)._1to8())); + TEST_INSTRUCTION("62F2FD581FAA00040000" , vpabsq(zmm5, qword_ptr(rdx, 1024)._1to8())); + TEST_INSTRUCTION("62F2FD581F6A80" , vpabsq(zmm5, qword_ptr(rdx, -1024)._1to8())); + TEST_INSTRUCTION("62F2FD581FAAF8FBFFFF" , vpabsq(zmm5, qword_ptr(rdx, -1032)._1to8())); + TEST_INSTRUCTION("62215548FED4" , vpaddd(zmm26, zmm5, zmm20)); + TEST_INSTRUCTION("62215549FED4" , k(k1).vpaddd(zmm26, zmm5, zmm20)); + TEST_INSTRUCTION("622155C9FED4" , k(k1).z().vpaddd(zmm26, zmm5, zmm20)); + TEST_INSTRUCTION("62615548FE11" , vpaddd(zmm26, zmm5, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62215548FE94F023010000" , vpaddd(zmm26, zmm5, zmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62615558FE11" , vpaddd(zmm26, zmm5, dword_ptr(rcx)._1to16())); + TEST_INSTRUCTION("62615548FE527F" , vpaddd(zmm26, zmm5, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62615548FE9200200000" , vpaddd(zmm26, zmm5, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62615548FE5280" , vpaddd(zmm26, zmm5, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62615548FE92C0DFFFFF" , vpaddd(zmm26, zmm5, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62615558FE527F" , vpaddd(zmm26, zmm5, dword_ptr(rdx, 508)._1to16())); + TEST_INSTRUCTION("62615558FE9200020000" , vpaddd(zmm26, zmm5, dword_ptr(rdx, 512)._1to16())); + TEST_INSTRUCTION("62615558FE5280" , vpaddd(zmm26, zmm5, dword_ptr(rdx, -512)._1to16())); + TEST_INSTRUCTION("62615558FE92FCFDFFFF" , vpaddd(zmm26, zmm5, dword_ptr(rdx, -516)._1to16())); + TEST_INSTRUCTION("6251B540D4C6" , vpaddq(zmm8, zmm25, zmm14)); + TEST_INSTRUCTION("6251B543D4C6" , k(k3).vpaddq(zmm8, zmm25, zmm14)); + TEST_INSTRUCTION("6251B5C3D4C6" , k(k3).z().vpaddq(zmm8, zmm25, zmm14)); + TEST_INSTRUCTION("6271B540D401" , vpaddq(zmm8, zmm25, zmmword_ptr(rcx))); + TEST_INSTRUCTION("6231B540D484F023010000" , vpaddq(zmm8, zmm25, zmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("6271B550D401" , vpaddq(zmm8, zmm25, qword_ptr(rcx)._1to8())); + TEST_INSTRUCTION("6271B540D4427F" , vpaddq(zmm8, zmm25, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("6271B540D48200200000" , vpaddq(zmm8, zmm25, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("6271B540D44280" , vpaddq(zmm8, zmm25, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("6271B540D482C0DFFFFF" , vpaddq(zmm8, zmm25, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("6271B550D4427F" , vpaddq(zmm8, zmm25, qword_ptr(rdx, 1016)._1to8())); + TEST_INSTRUCTION("6271B550D48200040000" , vpaddq(zmm8, zmm25, qword_ptr(rdx, 1024)._1to8())); + TEST_INSTRUCTION("6271B550D44280" , vpaddq(zmm8, zmm25, qword_ptr(rdx, -1024)._1to8())); + TEST_INSTRUCTION("6271B550D482F8FBFFFF" , vpaddq(zmm8, zmm25, qword_ptr(rdx, -1032)._1to8())); + TEST_INSTRUCTION("62814D40DBD9" , vpandd(zmm19, zmm22, zmm25)); + TEST_INSTRUCTION("62814D41DBD9" , k(k1).vpandd(zmm19, zmm22, zmm25)); + TEST_INSTRUCTION("62814DC1DBD9" , k(k1).z().vpandd(zmm19, zmm22, zmm25)); + TEST_INSTRUCTION("62E14D40DB19" , vpandd(zmm19, zmm22, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62A14D40DB9CF023010000" , vpandd(zmm19, zmm22, zmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62E14D50DB19" , vpandd(zmm19, zmm22, dword_ptr(rcx)._1to16())); + TEST_INSTRUCTION("62E14D40DB5A7F" , vpandd(zmm19, zmm22, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62E14D40DB9A00200000" , vpandd(zmm19, zmm22, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62E14D40DB5A80" , vpandd(zmm19, zmm22, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62E14D40DB9AC0DFFFFF" , vpandd(zmm19, zmm22, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62E14D50DB5A7F" , vpandd(zmm19, zmm22, dword_ptr(rdx, 508)._1to16())); + TEST_INSTRUCTION("62E14D50DB9A00020000" , vpandd(zmm19, zmm22, dword_ptr(rdx, 512)._1to16())); + TEST_INSTRUCTION("62E14D50DB5A80" , vpandd(zmm19, zmm22, dword_ptr(rdx, -512)._1to16())); + TEST_INSTRUCTION("62E14D50DB9AFCFDFFFF" , vpandd(zmm19, zmm22, dword_ptr(rdx, -516)._1to16())); + TEST_INSTRUCTION("62411D40DFF7" , vpandnd(zmm30, zmm28, zmm15)); + TEST_INSTRUCTION("62411D43DFF7" , k(k3).vpandnd(zmm30, zmm28, zmm15)); + TEST_INSTRUCTION("62411DC3DFF7" , k(k3).z().vpandnd(zmm30, zmm28, zmm15)); + TEST_INSTRUCTION("62611D40DF31" , vpandnd(zmm30, zmm28, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62211D40DFB4F023010000" , vpandnd(zmm30, zmm28, zmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62611D50DF31" , vpandnd(zmm30, zmm28, dword_ptr(rcx)._1to16())); + TEST_INSTRUCTION("62611D40DF727F" , vpandnd(zmm30, zmm28, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62611D40DFB200200000" , vpandnd(zmm30, zmm28, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62611D40DF7280" , vpandnd(zmm30, zmm28, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62611D40DFB2C0DFFFFF" , vpandnd(zmm30, zmm28, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62611D50DF727F" , vpandnd(zmm30, zmm28, dword_ptr(rdx, 508)._1to16())); + TEST_INSTRUCTION("62611D50DFB200020000" , vpandnd(zmm30, zmm28, dword_ptr(rdx, 512)._1to16())); + TEST_INSTRUCTION("62611D50DF7280" , vpandnd(zmm30, zmm28, dword_ptr(rdx, -512)._1to16())); + TEST_INSTRUCTION("62611D50DFB2FCFDFFFF" , vpandnd(zmm30, zmm28, dword_ptr(rdx, -516)._1to16())); + TEST_INSTRUCTION("62A1C548DFE3" , vpandnq(zmm20, zmm7, zmm19)); + TEST_INSTRUCTION("62A1C54DDFE3" , k(k5).vpandnq(zmm20, zmm7, zmm19)); + TEST_INSTRUCTION("62A1C5CDDFE3" , k(k5).z().vpandnq(zmm20, zmm7, zmm19)); + TEST_INSTRUCTION("62E1C548DF21" , vpandnq(zmm20, zmm7, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62A1C548DFA4F023010000" , vpandnq(zmm20, zmm7, zmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62E1C558DF21" , vpandnq(zmm20, zmm7, qword_ptr(rcx)._1to8())); + TEST_INSTRUCTION("62E1C548DF627F" , vpandnq(zmm20, zmm7, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62E1C548DFA200200000" , vpandnq(zmm20, zmm7, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62E1C548DF6280" , vpandnq(zmm20, zmm7, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62E1C548DFA2C0DFFFFF" , vpandnq(zmm20, zmm7, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62E1C558DF627F" , vpandnq(zmm20, zmm7, qword_ptr(rdx, 1016)._1to8())); + TEST_INSTRUCTION("62E1C558DFA200040000" , vpandnq(zmm20, zmm7, qword_ptr(rdx, 1024)._1to8())); + TEST_INSTRUCTION("62E1C558DF6280" , vpandnq(zmm20, zmm7, qword_ptr(rdx, -1024)._1to8())); + TEST_INSTRUCTION("62E1C558DFA2F8FBFFFF" , vpandnq(zmm20, zmm7, qword_ptr(rdx, -1032)._1to8())); + TEST_INSTRUCTION("6281DD48DBCA" , vpandq(zmm17, zmm4, zmm26)); + TEST_INSTRUCTION("6281DD4FDBCA" , k(k7).vpandq(zmm17, zmm4, zmm26)); + TEST_INSTRUCTION("6281DDCFDBCA" , k(k7).z().vpandq(zmm17, zmm4, zmm26)); + TEST_INSTRUCTION("62E1DD48DB09" , vpandq(zmm17, zmm4, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62A1DD48DB8CF023010000" , vpandq(zmm17, zmm4, zmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62E1DD58DB09" , vpandq(zmm17, zmm4, qword_ptr(rcx)._1to8())); + TEST_INSTRUCTION("62E1DD48DB4A7F" , vpandq(zmm17, zmm4, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62E1DD48DB8A00200000" , vpandq(zmm17, zmm4, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62E1DD48DB4A80" , vpandq(zmm17, zmm4, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62E1DD48DB8AC0DFFFFF" , vpandq(zmm17, zmm4, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62E1DD58DB4A7F" , vpandq(zmm17, zmm4, qword_ptr(rdx, 1016)._1to8())); + TEST_INSTRUCTION("62E1DD58DB8A00040000" , vpandq(zmm17, zmm4, qword_ptr(rdx, 1024)._1to8())); + TEST_INSTRUCTION("62E1DD58DB4A80" , vpandq(zmm17, zmm4, qword_ptr(rdx, -1024)._1to8())); + TEST_INSTRUCTION("62E1DD58DB8AF8FBFFFF" , vpandq(zmm17, zmm4, qword_ptr(rdx, -1032)._1to8())); + TEST_INSTRUCTION("62D2354064EB" , vpblendmd(zmm5, zmm25, zmm11)); + TEST_INSTRUCTION("62D2354364EB" , k(k3).vpblendmd(zmm5, zmm25, zmm11)); + TEST_INSTRUCTION("62D235C364EB" , k(k3).z().vpblendmd(zmm5, zmm25, zmm11)); + TEST_INSTRUCTION("62F235406429" , vpblendmd(zmm5, zmm25, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62B2354064ACF023010000" , vpblendmd(zmm5, zmm25, zmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62F235506429" , vpblendmd(zmm5, zmm25, dword_ptr(rcx)._1to16())); + TEST_INSTRUCTION("62F23540646A7F" , vpblendmd(zmm5, zmm25, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62F2354064AA00200000" , vpblendmd(zmm5, zmm25, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62F23540646A80" , vpblendmd(zmm5, zmm25, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62F2354064AAC0DFFFFF" , vpblendmd(zmm5, zmm25, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62F23550646A7F" , vpblendmd(zmm5, zmm25, dword_ptr(rdx, 508)._1to16())); + TEST_INSTRUCTION("62F2355064AA00020000" , vpblendmd(zmm5, zmm25, dword_ptr(rdx, 512)._1to16())); + TEST_INSTRUCTION("62F23550646A80" , vpblendmd(zmm5, zmm25, dword_ptr(rdx, -512)._1to16())); + TEST_INSTRUCTION("62F2355064AAFCFDFFFF" , vpblendmd(zmm5, zmm25, dword_ptr(rdx, -516)._1to16())); + TEST_INSTRUCTION("62627D485811" , vpbroadcastd(zmm26, dword_ptr(rcx))); + TEST_INSTRUCTION("62627D4A5811" , k(k2).vpbroadcastd(zmm26, dword_ptr(rcx))); + TEST_INSTRUCTION("62627DCA5811" , k(k2).z().vpbroadcastd(zmm26, dword_ptr(rcx))); + TEST_INSTRUCTION("62227D485894F023010000" , vpbroadcastd(zmm26, dword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62627D4858527F" , vpbroadcastd(zmm26, dword_ptr(rdx, 508))); + TEST_INSTRUCTION("62627D48589200020000" , vpbroadcastd(zmm26, dword_ptr(rdx, 512))); + TEST_INSTRUCTION("62627D48585280" , vpbroadcastd(zmm26, dword_ptr(rdx, -512))); + TEST_INSTRUCTION("62627D485892FCFDFFFF" , vpbroadcastd(zmm26, dword_ptr(rdx, -516))); + TEST_INSTRUCTION("62327D4858D6" , vpbroadcastd(zmm10, xmm22)); + TEST_INSTRUCTION("62327D4F58D6" , k(k7).vpbroadcastd(zmm10, xmm22)); + TEST_INSTRUCTION("62327DCF58D6" , k(k7).z().vpbroadcastd(zmm10, xmm22)); + TEST_INSTRUCTION("62727D487CD8" , vpbroadcastd(zmm11, eax)); + TEST_INSTRUCTION("62727D4E7CD8" , k(k6).vpbroadcastd(zmm11, eax)); + TEST_INSTRUCTION("62727DCE7CD8" , k(k6).z().vpbroadcastd(zmm11, eax)); + TEST_INSTRUCTION("62727D487CDD" , vpbroadcastd(zmm11, ebp)); + TEST_INSTRUCTION("62527D487CDD" , vpbroadcastd(zmm11, r13d)); + TEST_INSTRUCTION("6262FD485909" , vpbroadcastq(zmm25, qword_ptr(rcx))); + TEST_INSTRUCTION("6262FD4A5909" , k(k2).vpbroadcastq(zmm25, qword_ptr(rcx))); + TEST_INSTRUCTION("6262FDCA5909" , k(k2).z().vpbroadcastq(zmm25, qword_ptr(rcx))); + TEST_INSTRUCTION("6222FD48598CF023010000" , vpbroadcastq(zmm25, qword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("6262FD48594A7F" , vpbroadcastq(zmm25, qword_ptr(rdx, 1016))); + TEST_INSTRUCTION("6262FD48598A00040000" , vpbroadcastq(zmm25, qword_ptr(rdx, 1024))); + TEST_INSTRUCTION("6262FD48594A80" , vpbroadcastq(zmm25, qword_ptr(rdx, -1024))); + TEST_INSTRUCTION("6262FD48598AF8FBFFFF" , vpbroadcastq(zmm25, qword_ptr(rdx, -1032))); + TEST_INSTRUCTION("62F2FD4859DD" , vpbroadcastq(zmm3, xmm5)); + TEST_INSTRUCTION("62F2FD4D59DD" , k(k5).vpbroadcastq(zmm3, xmm5)); + TEST_INSTRUCTION("62F2FDCD59DD" , k(k5).z().vpbroadcastq(zmm3, xmm5)); + TEST_INSTRUCTION("62F2FD487CC8" , vpbroadcastq(zmm1, rax)); + TEST_INSTRUCTION("62F2FD4E7CC8" , k(k6).vpbroadcastq(zmm1, rax)); + TEST_INSTRUCTION("62F2FDCE7CC8" , k(k6).z().vpbroadcastq(zmm1, rax)); + TEST_INSTRUCTION("62D2FD487CC8" , vpbroadcastq(zmm1, r8)); + TEST_INSTRUCTION("62D335401FEAAB" , vpcmpd(k5, zmm25, zmm10, 171)); + TEST_INSTRUCTION("62D335431FEAAB" , k(k3).vpcmpd(k5, zmm25, zmm10, 171)); + TEST_INSTRUCTION("62D335401FEA7B" , vpcmpd(k5, zmm25, zmm10, 123)); + TEST_INSTRUCTION("62F335401F297B" , vpcmpd(k5, zmm25, zmmword_ptr(rcx), 123)); + TEST_INSTRUCTION("62B335401FACF0230100007B" , vpcmpd(k5, zmm25, zmmword_ptr(rax, r14, 3, 291), 123)); + TEST_INSTRUCTION("62F335501F297B" , vpcmpd(k5, zmm25, dword_ptr(rcx)._1to16(), 123)); + TEST_INSTRUCTION("62F335401F6A7F7B" , vpcmpd(k5, zmm25, zmmword_ptr(rdx, 8128), 123)); + TEST_INSTRUCTION("62F335401FAA002000007B" , vpcmpd(k5, zmm25, zmmword_ptr(rdx, 8192), 123)); + TEST_INSTRUCTION("62F335401F6A807B" , vpcmpd(k5, zmm25, zmmword_ptr(rdx, -8192), 123)); + TEST_INSTRUCTION("62F335401FAAC0DFFFFF7B" , vpcmpd(k5, zmm25, zmmword_ptr(rdx, -8256), 123)); + TEST_INSTRUCTION("62F335501F6A7F7B" , vpcmpd(k5, zmm25, dword_ptr(rdx, 508)._1to16(), 123)); + TEST_INSTRUCTION("62F335501FAA000200007B" , vpcmpd(k5, zmm25, dword_ptr(rdx, 512)._1to16(), 123)); + TEST_INSTRUCTION("62F335501F6A807B" , vpcmpd(k5, zmm25, dword_ptr(rdx, -512)._1to16(), 123)); + TEST_INSTRUCTION("62F335501FAAFCFDFFFF7B" , vpcmpd(k5, zmm25, dword_ptr(rdx, -516)._1to16(), 123)); + TEST_INSTRUCTION("62D16D4876EA" , vpcmpeqd(k5, zmm2, zmm10)); + TEST_INSTRUCTION("62D16D4F76EA" , k(k7).vpcmpeqd(k5, zmm2, zmm10)); + TEST_INSTRUCTION("62F16D487629" , vpcmpeqd(k5, zmm2, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62B16D4876ACF023010000" , vpcmpeqd(k5, zmm2, zmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62F16D587629" , vpcmpeqd(k5, zmm2, dword_ptr(rcx)._1to16())); + TEST_INSTRUCTION("62F16D48766A7F" , vpcmpeqd(k5, zmm2, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62F16D4876AA00200000" , vpcmpeqd(k5, zmm2, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62F16D48766A80" , vpcmpeqd(k5, zmm2, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62F16D4876AAC0DFFFFF" , vpcmpeqd(k5, zmm2, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62F16D58766A7F" , vpcmpeqd(k5, zmm2, dword_ptr(rdx, 508)._1to16())); + TEST_INSTRUCTION("62F16D5876AA00020000" , vpcmpeqd(k5, zmm2, dword_ptr(rdx, 512)._1to16())); + TEST_INSTRUCTION("62F16D58766A80" , vpcmpeqd(k5, zmm2, dword_ptr(rdx, -512)._1to16())); + TEST_INSTRUCTION("62F16D5876AAFCFDFFFF" , vpcmpeqd(k5, zmm2, dword_ptr(rdx, -516)._1to16())); + TEST_INSTRUCTION("62F2CD4029DA" , vpcmpeqq(k3, zmm22, zmm2)); + TEST_INSTRUCTION("62F2CD4629DA" , k(k6).vpcmpeqq(k3, zmm22, zmm2)); + TEST_INSTRUCTION("62F2CD402919" , vpcmpeqq(k3, zmm22, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62B2CD40299CF023010000" , vpcmpeqq(k3, zmm22, zmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62F2CD502919" , vpcmpeqq(k3, zmm22, qword_ptr(rcx)._1to8())); + TEST_INSTRUCTION("62F2CD40295A7F" , vpcmpeqq(k3, zmm22, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62F2CD40299A00200000" , vpcmpeqq(k3, zmm22, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62F2CD40295A80" , vpcmpeqq(k3, zmm22, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62F2CD40299AC0DFFFFF" , vpcmpeqq(k3, zmm22, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62F2CD50295A7F" , vpcmpeqq(k3, zmm22, qword_ptr(rdx, 1016)._1to8())); + TEST_INSTRUCTION("62F2CD50299A00040000" , vpcmpeqq(k3, zmm22, qword_ptr(rdx, 1024)._1to8())); + TEST_INSTRUCTION("62F2CD50295A80" , vpcmpeqq(k3, zmm22, qword_ptr(rdx, -1024)._1to8())); + TEST_INSTRUCTION("62F2CD50299AF8FBFFFF" , vpcmpeqq(k3, zmm22, qword_ptr(rdx, -1032)._1to8())); + TEST_INSTRUCTION("62D1554066E8" , vpcmpgtd(k5, zmm21, zmm8)); + TEST_INSTRUCTION("62D1554566E8" , k(k5).vpcmpgtd(k5, zmm21, zmm8)); + TEST_INSTRUCTION("62F155406629" , vpcmpgtd(k5, zmm21, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62B1554066ACF023010000" , vpcmpgtd(k5, zmm21, zmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62F155506629" , vpcmpgtd(k5, zmm21, dword_ptr(rcx)._1to16())); + TEST_INSTRUCTION("62F15540666A7F" , vpcmpgtd(k5, zmm21, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62F1554066AA00200000" , vpcmpgtd(k5, zmm21, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62F15540666A80" , vpcmpgtd(k5, zmm21, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62F1554066AAC0DFFFFF" , vpcmpgtd(k5, zmm21, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62F15550666A7F" , vpcmpgtd(k5, zmm21, dword_ptr(rdx, 508)._1to16())); + TEST_INSTRUCTION("62F1555066AA00020000" , vpcmpgtd(k5, zmm21, dword_ptr(rdx, 512)._1to16())); + TEST_INSTRUCTION("62F15550666A80" , vpcmpgtd(k5, zmm21, dword_ptr(rdx, -512)._1to16())); + TEST_INSTRUCTION("62F1555066AAFCFDFFFF" , vpcmpgtd(k5, zmm21, dword_ptr(rdx, -516)._1to16())); + TEST_INSTRUCTION("62B2DD4037D1" , vpcmpgtq(k2, zmm20, zmm17)); + TEST_INSTRUCTION("62B2DD4337D1" , k(k3).vpcmpgtq(k2, zmm20, zmm17)); + TEST_INSTRUCTION("62F2DD403711" , vpcmpgtq(k2, zmm20, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62B2DD403794F023010000" , vpcmpgtq(k2, zmm20, zmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62F2DD503711" , vpcmpgtq(k2, zmm20, qword_ptr(rcx)._1to8())); + TEST_INSTRUCTION("62F2DD4037527F" , vpcmpgtq(k2, zmm20, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62F2DD40379200200000" , vpcmpgtq(k2, zmm20, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62F2DD40375280" , vpcmpgtq(k2, zmm20, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62F2DD403792C0DFFFFF" , vpcmpgtq(k2, zmm20, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62F2DD5037527F" , vpcmpgtq(k2, zmm20, qword_ptr(rdx, 1016)._1to8())); + TEST_INSTRUCTION("62F2DD50379200040000" , vpcmpgtq(k2, zmm20, qword_ptr(rdx, 1024)._1to8())); + TEST_INSTRUCTION("62F2DD50375280" , vpcmpgtq(k2, zmm20, qword_ptr(rdx, -1024)._1to8())); + TEST_INSTRUCTION("62F2DD503792F8FBFFFF" , vpcmpgtq(k2, zmm20, qword_ptr(rdx, -1032)._1to8())); + TEST_INSTRUCTION("62939D401FECAB" , vpcmpq(k5, zmm28, zmm28, 171)); + TEST_INSTRUCTION("62939D431FECAB" , k(k3).vpcmpq(k5, zmm28, zmm28, 171)); + TEST_INSTRUCTION("62939D401FEC7B" , vpcmpq(k5, zmm28, zmm28, 123)); + TEST_INSTRUCTION("62F39D401F297B" , vpcmpq(k5, zmm28, zmmword_ptr(rcx), 123)); + TEST_INSTRUCTION("62B39D401FACF0230100007B" , vpcmpq(k5, zmm28, zmmword_ptr(rax, r14, 3, 291), 123)); + TEST_INSTRUCTION("62F39D501F297B" , vpcmpq(k5, zmm28, qword_ptr(rcx)._1to8(), 123)); + TEST_INSTRUCTION("62F39D401F6A7F7B" , vpcmpq(k5, zmm28, zmmword_ptr(rdx, 8128), 123)); + TEST_INSTRUCTION("62F39D401FAA002000007B" , vpcmpq(k5, zmm28, zmmword_ptr(rdx, 8192), 123)); + TEST_INSTRUCTION("62F39D401F6A807B" , vpcmpq(k5, zmm28, zmmword_ptr(rdx, -8192), 123)); + TEST_INSTRUCTION("62F39D401FAAC0DFFFFF7B" , vpcmpq(k5, zmm28, zmmword_ptr(rdx, -8256), 123)); + TEST_INSTRUCTION("62F39D501F6A7F7B" , vpcmpq(k5, zmm28, qword_ptr(rdx, 1016)._1to8(), 123)); + TEST_INSTRUCTION("62F39D501FAA000400007B" , vpcmpq(k5, zmm28, qword_ptr(rdx, 1024)._1to8(), 123)); + TEST_INSTRUCTION("62F39D501F6A807B" , vpcmpq(k5, zmm28, qword_ptr(rdx, -1024)._1to8(), 123)); + TEST_INSTRUCTION("62F39D501FAAF8FBFFFF7B" , vpcmpq(k5, zmm28, qword_ptr(rdx, -1032)._1to8(), 123)); + TEST_INSTRUCTION("62F335401ED7AB" , vpcmpud(k2, zmm25, zmm7, 171)); + TEST_INSTRUCTION("62F335411ED7AB" , k(k1).vpcmpud(k2, zmm25, zmm7, 171)); + TEST_INSTRUCTION("62F335401ED77B" , vpcmpud(k2, zmm25, zmm7, 123)); + TEST_INSTRUCTION("62F335401E117B" , vpcmpud(k2, zmm25, zmmword_ptr(rcx), 123)); + TEST_INSTRUCTION("62B335401E94F0230100007B" , vpcmpud(k2, zmm25, zmmword_ptr(rax, r14, 3, 291), 123)); + TEST_INSTRUCTION("62F335501E117B" , vpcmpud(k2, zmm25, dword_ptr(rcx)._1to16(), 123)); + TEST_INSTRUCTION("62F335401E527F7B" , vpcmpud(k2, zmm25, zmmword_ptr(rdx, 8128), 123)); + TEST_INSTRUCTION("62F335401E92002000007B" , vpcmpud(k2, zmm25, zmmword_ptr(rdx, 8192), 123)); + TEST_INSTRUCTION("62F335401E52807B" , vpcmpud(k2, zmm25, zmmword_ptr(rdx, -8192), 123)); + TEST_INSTRUCTION("62F335401E92C0DFFFFF7B" , vpcmpud(k2, zmm25, zmmword_ptr(rdx, -8256), 123)); + TEST_INSTRUCTION("62F335501E527F7B" , vpcmpud(k2, zmm25, dword_ptr(rdx, 508)._1to16(), 123)); + TEST_INSTRUCTION("62F335501E92000200007B" , vpcmpud(k2, zmm25, dword_ptr(rdx, 512)._1to16(), 123)); + TEST_INSTRUCTION("62F335501E52807B" , vpcmpud(k2, zmm25, dword_ptr(rdx, -512)._1to16(), 123)); + TEST_INSTRUCTION("62F335501E92FCFDFFFF7B" , vpcmpud(k2, zmm25, dword_ptr(rdx, -516)._1to16(), 123)); + TEST_INSTRUCTION("62D38D481ED8AB" , vpcmpuq(k3, zmm14, zmm8, 171)); + TEST_INSTRUCTION("62D38D4A1ED8AB" , k(k2).vpcmpuq(k3, zmm14, zmm8, 171)); + TEST_INSTRUCTION("62D38D481ED87B" , vpcmpuq(k3, zmm14, zmm8, 123)); + TEST_INSTRUCTION("62F38D481E197B" , vpcmpuq(k3, zmm14, zmmword_ptr(rcx), 123)); + TEST_INSTRUCTION("62B38D481E9CF0230100007B" , vpcmpuq(k3, zmm14, zmmword_ptr(rax, r14, 3, 291), 123)); + TEST_INSTRUCTION("62F38D581E197B" , vpcmpuq(k3, zmm14, qword_ptr(rcx)._1to8(), 123)); + TEST_INSTRUCTION("62F38D481E5A7F7B" , vpcmpuq(k3, zmm14, zmmword_ptr(rdx, 8128), 123)); + TEST_INSTRUCTION("62F38D481E9A002000007B" , vpcmpuq(k3, zmm14, zmmword_ptr(rdx, 8192), 123)); + TEST_INSTRUCTION("62F38D481E5A807B" , vpcmpuq(k3, zmm14, zmmword_ptr(rdx, -8192), 123)); + TEST_INSTRUCTION("62F38D481E9AC0DFFFFF7B" , vpcmpuq(k3, zmm14, zmmword_ptr(rdx, -8256), 123)); + TEST_INSTRUCTION("62F38D581E5A7F7B" , vpcmpuq(k3, zmm14, qword_ptr(rdx, 1016)._1to8(), 123)); + TEST_INSTRUCTION("62F38D581E9A000400007B" , vpcmpuq(k3, zmm14, qword_ptr(rdx, 1024)._1to8(), 123)); + TEST_INSTRUCTION("62F38D581E5A807B" , vpcmpuq(k3, zmm14, qword_ptr(rdx, -1024)._1to8(), 123)); + TEST_INSTRUCTION("62F38D581E9AF8FBFFFF7B" , vpcmpuq(k3, zmm14, qword_ptr(rdx, -1032)._1to8(), 123)); + TEST_INSTRUCTION("62228D4864D9" , vpblendmq(zmm27, zmm14, zmm17)); + TEST_INSTRUCTION("62228D4D64D9" , k(k5).vpblendmq(zmm27, zmm14, zmm17)); + TEST_INSTRUCTION("62228DCD64D9" , k(k5).z().vpblendmq(zmm27, zmm14, zmm17)); + TEST_INSTRUCTION("62628D486419" , vpblendmq(zmm27, zmm14, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62228D48649CF023010000" , vpblendmq(zmm27, zmm14, zmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62628D586419" , vpblendmq(zmm27, zmm14, qword_ptr(rcx)._1to8())); + TEST_INSTRUCTION("62628D48645A7F" , vpblendmq(zmm27, zmm14, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62628D48649A00200000" , vpblendmq(zmm27, zmm14, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62628D48645A80" , vpblendmq(zmm27, zmm14, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62628D48649AC0DFFFFF" , vpblendmq(zmm27, zmm14, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62628D58645A7F" , vpblendmq(zmm27, zmm14, qword_ptr(rdx, 1016)._1to8())); + TEST_INSTRUCTION("62628D58649A00040000" , vpblendmq(zmm27, zmm14, qword_ptr(rdx, 1024)._1to8())); + TEST_INSTRUCTION("62628D58645A80" , vpblendmq(zmm27, zmm14, qword_ptr(rdx, -1024)._1to8())); + TEST_INSTRUCTION("62628D58649AF8FBFFFF" , vpblendmq(zmm27, zmm14, qword_ptr(rdx, -1032)._1to8())); + TEST_INSTRUCTION("62E27D488B39" , vpcompressd(zmmword_ptr(rcx), zmm23)); + TEST_INSTRUCTION("62E27D4F8B39" , k(k7).vpcompressd(zmmword_ptr(rcx), zmm23)); + TEST_INSTRUCTION("62A27D488BBCF023010000" , vpcompressd(zmmword_ptr(rax, r14, 3, 291), zmm23)); + TEST_INSTRUCTION("62E27D488B7A7F" , vpcompressd(zmmword_ptr(rdx, 508), zmm23)); + TEST_INSTRUCTION("62E27D488BBA00020000" , vpcompressd(zmmword_ptr(rdx, 512), zmm23)); + TEST_INSTRUCTION("62E27D488B7A80" , vpcompressd(zmmword_ptr(rdx, -512), zmm23)); + TEST_INSTRUCTION("62E27D488BBAFCFDFFFF" , vpcompressd(zmmword_ptr(rdx, -516), zmm23)); + TEST_INSTRUCTION("62A27D488BD0" , vpcompressd(zmm16, zmm18)); + TEST_INSTRUCTION("62A27D4A8BD0" , k(k2).vpcompressd(zmm16, zmm18)); + TEST_INSTRUCTION("62A27DCA8BD0" , k(k2).z().vpcompressd(zmm16, zmm18)); + TEST_INSTRUCTION("62C21D4036F1" , vpermd(zmm22, zmm28, zmm9)); + TEST_INSTRUCTION("62C21D4136F1" , k(k1).vpermd(zmm22, zmm28, zmm9)); + TEST_INSTRUCTION("62C21DC136F1" , k(k1).z().vpermd(zmm22, zmm28, zmm9)); + TEST_INSTRUCTION("62E21D403631" , vpermd(zmm22, zmm28, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62A21D4036B4F023010000" , vpermd(zmm22, zmm28, zmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62E21D503631" , vpermd(zmm22, zmm28, dword_ptr(rcx)._1to16())); + TEST_INSTRUCTION("62E21D4036727F" , vpermd(zmm22, zmm28, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62E21D4036B200200000" , vpermd(zmm22, zmm28, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62E21D40367280" , vpermd(zmm22, zmm28, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62E21D4036B2C0DFFFFF" , vpermd(zmm22, zmm28, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62E21D5036727F" , vpermd(zmm22, zmm28, dword_ptr(rdx, 508)._1to16())); + TEST_INSTRUCTION("62E21D5036B200020000" , vpermd(zmm22, zmm28, dword_ptr(rdx, 512)._1to16())); + TEST_INSTRUCTION("62E21D50367280" , vpermd(zmm22, zmm28, dword_ptr(rdx, -512)._1to16())); + TEST_INSTRUCTION("62E21D5036B2FCFDFFFF" , vpermd(zmm22, zmm28, dword_ptr(rdx, -516)._1to16())); + TEST_INSTRUCTION("62E3FD4805DCAB" , vpermilpd(zmm19, zmm4, 171)); + TEST_INSTRUCTION("62E3FD4905DCAB" , k(k1).vpermilpd(zmm19, zmm4, 171)); + TEST_INSTRUCTION("62E3FDC905DCAB" , k(k1).z().vpermilpd(zmm19, zmm4, 171)); + TEST_INSTRUCTION("62E3FD4805DC7B" , vpermilpd(zmm19, zmm4, 123)); + TEST_INSTRUCTION("62E3FD4805197B" , vpermilpd(zmm19, zmmword_ptr(rcx), 123)); + TEST_INSTRUCTION("62A3FD48059CF0230100007B" , vpermilpd(zmm19, zmmword_ptr(rax, r14, 3, 291), 123)); + TEST_INSTRUCTION("62E3FD5805197B" , vpermilpd(zmm19, qword_ptr(rcx)._1to8(), 123)); + TEST_INSTRUCTION("62E3FD48055A7F7B" , vpermilpd(zmm19, zmmword_ptr(rdx, 8128), 123)); + TEST_INSTRUCTION("62E3FD48059A002000007B" , vpermilpd(zmm19, zmmword_ptr(rdx, 8192), 123)); + TEST_INSTRUCTION("62E3FD48055A807B" , vpermilpd(zmm19, zmmword_ptr(rdx, -8192), 123)); + TEST_INSTRUCTION("62E3FD48059AC0DFFFFF7B" , vpermilpd(zmm19, zmmword_ptr(rdx, -8256), 123)); + TEST_INSTRUCTION("62E3FD58055A7F7B" , vpermilpd(zmm19, qword_ptr(rdx, 1016)._1to8(), 123)); + TEST_INSTRUCTION("62E3FD58059A000400007B" , vpermilpd(zmm19, qword_ptr(rdx, 1024)._1to8(), 123)); + TEST_INSTRUCTION("62E3FD58055A807B" , vpermilpd(zmm19, qword_ptr(rdx, -1024)._1to8(), 123)); + TEST_INSTRUCTION("62E3FD58059AF8FBFFFF7B" , vpermilpd(zmm19, qword_ptr(rdx, -1032)._1to8(), 123)); + TEST_INSTRUCTION("62B2AD400DCD" , vpermilpd(zmm1, zmm26, zmm21)); + TEST_INSTRUCTION("62B2AD420DCD" , k(k2).vpermilpd(zmm1, zmm26, zmm21)); + TEST_INSTRUCTION("62B2ADC20DCD" , k(k2).z().vpermilpd(zmm1, zmm26, zmm21)); + TEST_INSTRUCTION("62F2AD400D09" , vpermilpd(zmm1, zmm26, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62B2AD400D8CF023010000" , vpermilpd(zmm1, zmm26, zmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62F2AD500D09" , vpermilpd(zmm1, zmm26, qword_ptr(rcx)._1to8())); + TEST_INSTRUCTION("62F2AD400D4A7F" , vpermilpd(zmm1, zmm26, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62F2AD400D8A00200000" , vpermilpd(zmm1, zmm26, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62F2AD400D4A80" , vpermilpd(zmm1, zmm26, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62F2AD400D8AC0DFFFFF" , vpermilpd(zmm1, zmm26, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62F2AD500D4A7F" , vpermilpd(zmm1, zmm26, qword_ptr(rdx, 1016)._1to8())); + TEST_INSTRUCTION("62F2AD500D8A00040000" , vpermilpd(zmm1, zmm26, qword_ptr(rdx, 1024)._1to8())); + TEST_INSTRUCTION("62F2AD500D4A80" , vpermilpd(zmm1, zmm26, qword_ptr(rdx, -1024)._1to8())); + TEST_INSTRUCTION("62F2AD500D8AF8FBFFFF" , vpermilpd(zmm1, zmm26, qword_ptr(rdx, -1032)._1to8())); + TEST_INSTRUCTION("62B37D4804D6AB" , vpermilps(zmm2, zmm22, 171)); + TEST_INSTRUCTION("62B37D4A04D6AB" , k(k2).vpermilps(zmm2, zmm22, 171)); + TEST_INSTRUCTION("62B37DCA04D6AB" , k(k2).z().vpermilps(zmm2, zmm22, 171)); + TEST_INSTRUCTION("62B37D4804D67B" , vpermilps(zmm2, zmm22, 123)); + TEST_INSTRUCTION("62F37D4804117B" , vpermilps(zmm2, zmmword_ptr(rcx), 123)); + TEST_INSTRUCTION("62B37D480494F0230100007B" , vpermilps(zmm2, zmmword_ptr(rax, r14, 3, 291), 123)); + TEST_INSTRUCTION("62F37D5804117B" , vpermilps(zmm2, dword_ptr(rcx)._1to16(), 123)); + TEST_INSTRUCTION("62F37D4804527F7B" , vpermilps(zmm2, zmmword_ptr(rdx, 8128), 123)); + TEST_INSTRUCTION("62F37D480492002000007B" , vpermilps(zmm2, zmmword_ptr(rdx, 8192), 123)); + TEST_INSTRUCTION("62F37D480452807B" , vpermilps(zmm2, zmmword_ptr(rdx, -8192), 123)); + TEST_INSTRUCTION("62F37D480492C0DFFFFF7B" , vpermilps(zmm2, zmmword_ptr(rdx, -8256), 123)); + TEST_INSTRUCTION("62F37D5804527F7B" , vpermilps(zmm2, dword_ptr(rdx, 508)._1to16(), 123)); + TEST_INSTRUCTION("62F37D580492000200007B" , vpermilps(zmm2, dword_ptr(rdx, 512)._1to16(), 123)); + TEST_INSTRUCTION("62F37D580452807B" , vpermilps(zmm2, dword_ptr(rdx, -512)._1to16(), 123)); + TEST_INSTRUCTION("62F37D580492FCFDFFFF7B" , vpermilps(zmm2, dword_ptr(rdx, -516)._1to16(), 123)); + TEST_INSTRUCTION("62725D400CEA" , vpermilps(zmm13, zmm20, zmm2)); + TEST_INSTRUCTION("62725D410CEA" , k(k1).vpermilps(zmm13, zmm20, zmm2)); + TEST_INSTRUCTION("62725DC10CEA" , k(k1).z().vpermilps(zmm13, zmm20, zmm2)); + TEST_INSTRUCTION("62725D400C29" , vpermilps(zmm13, zmm20, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62325D400CACF023010000" , vpermilps(zmm13, zmm20, zmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62725D500C29" , vpermilps(zmm13, zmm20, dword_ptr(rcx)._1to16())); + TEST_INSTRUCTION("62725D400C6A7F" , vpermilps(zmm13, zmm20, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62725D400CAA00200000" , vpermilps(zmm13, zmm20, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62725D400C6A80" , vpermilps(zmm13, zmm20, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62725D400CAAC0DFFFFF" , vpermilps(zmm13, zmm20, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62725D500C6A7F" , vpermilps(zmm13, zmm20, dword_ptr(rdx, 508)._1to16())); + TEST_INSTRUCTION("62725D500CAA00020000" , vpermilps(zmm13, zmm20, dword_ptr(rdx, 512)._1to16())); + TEST_INSTRUCTION("62725D500C6A80" , vpermilps(zmm13, zmm20, dword_ptr(rdx, -512)._1to16())); + TEST_INSTRUCTION("62725D500CAAFCFDFFFF" , vpermilps(zmm13, zmm20, dword_ptr(rdx, -516)._1to16())); + TEST_INSTRUCTION("6293FD4801DBAB" , vpermpd(zmm3, zmm27, 171)); + TEST_INSTRUCTION("6293FD4A01DBAB" , k(k2).vpermpd(zmm3, zmm27, 171)); + TEST_INSTRUCTION("6293FDCA01DBAB" , k(k2).z().vpermpd(zmm3, zmm27, 171)); + TEST_INSTRUCTION("6293FD4801DB7B" , vpermpd(zmm3, zmm27, 123)); + TEST_INSTRUCTION("62F3FD4801197B" , vpermpd(zmm3, zmmword_ptr(rcx), 123)); + TEST_INSTRUCTION("62B3FD48019CF0230100007B" , vpermpd(zmm3, zmmword_ptr(rax, r14, 3, 291), 123)); + TEST_INSTRUCTION("62F3FD5801197B" , vpermpd(zmm3, qword_ptr(rcx)._1to8(), 123)); + TEST_INSTRUCTION("62F3FD48015A7F7B" , vpermpd(zmm3, zmmword_ptr(rdx, 8128), 123)); + TEST_INSTRUCTION("62F3FD48019A002000007B" , vpermpd(zmm3, zmmword_ptr(rdx, 8192), 123)); + TEST_INSTRUCTION("62F3FD48015A807B" , vpermpd(zmm3, zmmword_ptr(rdx, -8192), 123)); + TEST_INSTRUCTION("62F3FD48019AC0DFFFFF7B" , vpermpd(zmm3, zmmword_ptr(rdx, -8256), 123)); + TEST_INSTRUCTION("62F3FD58015A7F7B" , vpermpd(zmm3, qword_ptr(rdx, 1016)._1to8(), 123)); + TEST_INSTRUCTION("62F3FD58019A000400007B" , vpermpd(zmm3, qword_ptr(rdx, 1024)._1to8(), 123)); + TEST_INSTRUCTION("62F3FD58015A807B" , vpermpd(zmm3, qword_ptr(rdx, -1024)._1to8(), 123)); + TEST_INSTRUCTION("62F3FD58019AF8FBFFFF7B" , vpermpd(zmm3, qword_ptr(rdx, -1032)._1to8(), 123)); + TEST_INSTRUCTION("62926D4816E0" , vpermps(zmm4, zmm2, zmm24)); + TEST_INSTRUCTION("62926D4C16E0" , k(k4).vpermps(zmm4, zmm2, zmm24)); + TEST_INSTRUCTION("62926DCC16E0" , k(k4).z().vpermps(zmm4, zmm2, zmm24)); + TEST_INSTRUCTION("62F26D481621" , vpermps(zmm4, zmm2, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62B26D4816A4F023010000" , vpermps(zmm4, zmm2, zmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62F26D581621" , vpermps(zmm4, zmm2, dword_ptr(rcx)._1to16())); + TEST_INSTRUCTION("62F26D4816627F" , vpermps(zmm4, zmm2, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62F26D4816A200200000" , vpermps(zmm4, zmm2, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62F26D48166280" , vpermps(zmm4, zmm2, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62F26D4816A2C0DFFFFF" , vpermps(zmm4, zmm2, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62F26D5816627F" , vpermps(zmm4, zmm2, dword_ptr(rdx, 508)._1to16())); + TEST_INSTRUCTION("62F26D5816A200020000" , vpermps(zmm4, zmm2, dword_ptr(rdx, 512)._1to16())); + TEST_INSTRUCTION("62F26D58166280" , vpermps(zmm4, zmm2, dword_ptr(rdx, -512)._1to16())); + TEST_INSTRUCTION("62F26D5816A2FCFDFFFF" , vpermps(zmm4, zmm2, dword_ptr(rdx, -516)._1to16())); + TEST_INSTRUCTION("6263FD4800CCAB" , vpermq(zmm25, zmm4, 171)); + TEST_INSTRUCTION("6263FD4E00CCAB" , k(k6).vpermq(zmm25, zmm4, 171)); + TEST_INSTRUCTION("6263FDCE00CCAB" , k(k6).z().vpermq(zmm25, zmm4, 171)); + TEST_INSTRUCTION("6263FD4800CC7B" , vpermq(zmm25, zmm4, 123)); + TEST_INSTRUCTION("6263FD4800097B" , vpermq(zmm25, zmmword_ptr(rcx), 123)); + TEST_INSTRUCTION("6223FD48008CF0230100007B" , vpermq(zmm25, zmmword_ptr(rax, r14, 3, 291), 123)); + TEST_INSTRUCTION("6263FD5800097B" , vpermq(zmm25, qword_ptr(rcx)._1to8(), 123)); + TEST_INSTRUCTION("6263FD48004A7F7B" , vpermq(zmm25, zmmword_ptr(rdx, 8128), 123)); + TEST_INSTRUCTION("6263FD48008A002000007B" , vpermq(zmm25, zmmword_ptr(rdx, 8192), 123)); + TEST_INSTRUCTION("6263FD48004A807B" , vpermq(zmm25, zmmword_ptr(rdx, -8192), 123)); + TEST_INSTRUCTION("6263FD48008AC0DFFFFF7B" , vpermq(zmm25, zmmword_ptr(rdx, -8256), 123)); + TEST_INSTRUCTION("6263FD58004A7F7B" , vpermq(zmm25, qword_ptr(rdx, 1016)._1to8(), 123)); + TEST_INSTRUCTION("6263FD58008A000400007B" , vpermq(zmm25, qword_ptr(rdx, 1024)._1to8(), 123)); + TEST_INSTRUCTION("6263FD58004A807B" , vpermq(zmm25, qword_ptr(rdx, -1024)._1to8(), 123)); + TEST_INSTRUCTION("6263FD58008AF8FBFFFF7B" , vpermq(zmm25, qword_ptr(rdx, -1032)._1to8(), 123)); + TEST_INSTRUCTION("62F27D488909" , vpexpandd(zmm1, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62F27D4F8909" , k(k7).vpexpandd(zmm1, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62F27DCF8909" , k(k7).z().vpexpandd(zmm1, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62B27D48898CF023010000" , vpexpandd(zmm1, zmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62F27D48894A7F" , vpexpandd(zmm1, zmmword_ptr(rdx, 508))); + TEST_INSTRUCTION("62F27D48898A00020000" , vpexpandd(zmm1, zmmword_ptr(rdx, 512))); + TEST_INSTRUCTION("62F27D48894A80" , vpexpandd(zmm1, zmmword_ptr(rdx, -512))); + TEST_INSTRUCTION("62F27D48898AFCFDFFFF" , vpexpandd(zmm1, zmmword_ptr(rdx, -516))); + TEST_INSTRUCTION("62827D4889D9" , vpexpandd(zmm19, zmm25)); + TEST_INSTRUCTION("62827D4D89D9" , k(k5).vpexpandd(zmm19, zmm25)); + TEST_INSTRUCTION("62827DCD89D9" , k(k5).z().vpexpandd(zmm19, zmm25)); + TEST_INSTRUCTION("6262FD488901" , vpexpandq(zmm24, zmmword_ptr(rcx))); + TEST_INSTRUCTION("6262FD4F8901" , k(k7).vpexpandq(zmm24, zmmword_ptr(rcx))); + TEST_INSTRUCTION("6262FDCF8901" , k(k7).z().vpexpandq(zmm24, zmmword_ptr(rcx))); + TEST_INSTRUCTION("6222FD488984F023010000" , vpexpandq(zmm24, zmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("6262FD4889427F" , vpexpandq(zmm24, zmmword_ptr(rdx, 1016))); + TEST_INSTRUCTION("6262FD48898200040000" , vpexpandq(zmm24, zmmword_ptr(rdx, 1024))); + TEST_INSTRUCTION("6262FD48894280" , vpexpandq(zmm24, zmmword_ptr(rdx, -1024))); + TEST_INSTRUCTION("6262FD488982F8FBFFFF" , vpexpandq(zmm24, zmmword_ptr(rdx, -1032))); + TEST_INSTRUCTION("6252FD4889F8" , vpexpandq(zmm15, zmm8)); + TEST_INSTRUCTION("6252FD4F89F8" , k(k7).vpexpandq(zmm15, zmm8)); + TEST_INSTRUCTION("6252FDCF89F8" , k(k7).z().vpexpandq(zmm15, zmm8)); + TEST_INSTRUCTION("62B23D483DF0" , vpmaxsd(zmm6, zmm8, zmm16)); + TEST_INSTRUCTION("62B23D4B3DF0" , k(k3).vpmaxsd(zmm6, zmm8, zmm16)); + TEST_INSTRUCTION("62B23DCB3DF0" , k(k3).z().vpmaxsd(zmm6, zmm8, zmm16)); + TEST_INSTRUCTION("62F23D483D31" , vpmaxsd(zmm6, zmm8, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62B23D483DB4F023010000" , vpmaxsd(zmm6, zmm8, zmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62F23D583D31" , vpmaxsd(zmm6, zmm8, dword_ptr(rcx)._1to16())); + TEST_INSTRUCTION("62F23D483D727F" , vpmaxsd(zmm6, zmm8, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62F23D483DB200200000" , vpmaxsd(zmm6, zmm8, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62F23D483D7280" , vpmaxsd(zmm6, zmm8, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62F23D483DB2C0DFFFFF" , vpmaxsd(zmm6, zmm8, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62F23D583D727F" , vpmaxsd(zmm6, zmm8, dword_ptr(rdx, 508)._1to16())); + TEST_INSTRUCTION("62F23D583DB200020000" , vpmaxsd(zmm6, zmm8, dword_ptr(rdx, 512)._1to16())); + TEST_INSTRUCTION("62F23D583D7280" , vpmaxsd(zmm6, zmm8, dword_ptr(rdx, -512)._1to16())); + TEST_INSTRUCTION("62F23D583DB2FCFDFFFF" , vpmaxsd(zmm6, zmm8, dword_ptr(rdx, -516)._1to16())); + TEST_INSTRUCTION("62F2CD483DF1" , vpmaxsq(zmm6, zmm6, zmm1)); + TEST_INSTRUCTION("62F2CD4F3DF1" , k(k7).vpmaxsq(zmm6, zmm6, zmm1)); + TEST_INSTRUCTION("62F2CDCF3DF1" , k(k7).z().vpmaxsq(zmm6, zmm6, zmm1)); + TEST_INSTRUCTION("62F2CD483D31" , vpmaxsq(zmm6, zmm6, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62B2CD483DB4F023010000" , vpmaxsq(zmm6, zmm6, zmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62F2CD583D31" , vpmaxsq(zmm6, zmm6, qword_ptr(rcx)._1to8())); + TEST_INSTRUCTION("62F2CD483D727F" , vpmaxsq(zmm6, zmm6, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62F2CD483DB200200000" , vpmaxsq(zmm6, zmm6, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62F2CD483D7280" , vpmaxsq(zmm6, zmm6, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62F2CD483DB2C0DFFFFF" , vpmaxsq(zmm6, zmm6, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62F2CD583D727F" , vpmaxsq(zmm6, zmm6, qword_ptr(rdx, 1016)._1to8())); + TEST_INSTRUCTION("62F2CD583DB200040000" , vpmaxsq(zmm6, zmm6, qword_ptr(rdx, 1024)._1to8())); + TEST_INSTRUCTION("62F2CD583D7280" , vpmaxsq(zmm6, zmm6, qword_ptr(rdx, -1024)._1to8())); + TEST_INSTRUCTION("62F2CD583DB2F8FBFFFF" , vpmaxsq(zmm6, zmm6, qword_ptr(rdx, -1032)._1to8())); + TEST_INSTRUCTION("628245483FC9" , vpmaxud(zmm17, zmm7, zmm25)); + TEST_INSTRUCTION("6282454D3FC9" , k(k5).vpmaxud(zmm17, zmm7, zmm25)); + TEST_INSTRUCTION("628245CD3FC9" , k(k5).z().vpmaxud(zmm17, zmm7, zmm25)); + TEST_INSTRUCTION("62E245483F09" , vpmaxud(zmm17, zmm7, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62A245483F8CF023010000" , vpmaxud(zmm17, zmm7, zmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62E245583F09" , vpmaxud(zmm17, zmm7, dword_ptr(rcx)._1to16())); + TEST_INSTRUCTION("62E245483F4A7F" , vpmaxud(zmm17, zmm7, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62E245483F8A00200000" , vpmaxud(zmm17, zmm7, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62E245483F4A80" , vpmaxud(zmm17, zmm7, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62E245483F8AC0DFFFFF" , vpmaxud(zmm17, zmm7, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62E245583F4A7F" , vpmaxud(zmm17, zmm7, dword_ptr(rdx, 508)._1to16())); + TEST_INSTRUCTION("62E245583F8A00020000" , vpmaxud(zmm17, zmm7, dword_ptr(rdx, 512)._1to16())); + TEST_INSTRUCTION("62E245583F4A80" , vpmaxud(zmm17, zmm7, dword_ptr(rdx, -512)._1to16())); + TEST_INSTRUCTION("62E245583F8AFCFDFFFF" , vpmaxud(zmm17, zmm7, dword_ptr(rdx, -516)._1to16())); + TEST_INSTRUCTION("6202CD403FF1" , vpmaxuq(zmm30, zmm22, zmm25)); + TEST_INSTRUCTION("6202CD413FF1" , k(k1).vpmaxuq(zmm30, zmm22, zmm25)); + TEST_INSTRUCTION("6202CDC13FF1" , k(k1).z().vpmaxuq(zmm30, zmm22, zmm25)); + TEST_INSTRUCTION("6262CD403F31" , vpmaxuq(zmm30, zmm22, zmmword_ptr(rcx))); + TEST_INSTRUCTION("6222CD403FB4F023010000" , vpmaxuq(zmm30, zmm22, zmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("6262CD503F31" , vpmaxuq(zmm30, zmm22, qword_ptr(rcx)._1to8())); + TEST_INSTRUCTION("6262CD403F727F" , vpmaxuq(zmm30, zmm22, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("6262CD403FB200200000" , vpmaxuq(zmm30, zmm22, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("6262CD403F7280" , vpmaxuq(zmm30, zmm22, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("6262CD403FB2C0DFFFFF" , vpmaxuq(zmm30, zmm22, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("6262CD503F727F" , vpmaxuq(zmm30, zmm22, qword_ptr(rdx, 1016)._1to8())); + TEST_INSTRUCTION("6262CD503FB200040000" , vpmaxuq(zmm30, zmm22, qword_ptr(rdx, 1024)._1to8())); + TEST_INSTRUCTION("6262CD503F7280" , vpmaxuq(zmm30, zmm22, qword_ptr(rdx, -1024)._1to8())); + TEST_INSTRUCTION("6262CD503FB2F8FBFFFF" , vpmaxuq(zmm30, zmm22, qword_ptr(rdx, -1032)._1to8())); + TEST_INSTRUCTION("62927D4039D0" , vpminsd(zmm2, zmm16, zmm24)); + TEST_INSTRUCTION("62927D4339D0" , k(k3).vpminsd(zmm2, zmm16, zmm24)); + TEST_INSTRUCTION("62927DC339D0" , k(k3).z().vpminsd(zmm2, zmm16, zmm24)); + TEST_INSTRUCTION("62F27D403911" , vpminsd(zmm2, zmm16, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62B27D403994F023010000" , vpminsd(zmm2, zmm16, zmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62F27D503911" , vpminsd(zmm2, zmm16, dword_ptr(rcx)._1to16())); + TEST_INSTRUCTION("62F27D4039527F" , vpminsd(zmm2, zmm16, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62F27D40399200200000" , vpminsd(zmm2, zmm16, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62F27D40395280" , vpminsd(zmm2, zmm16, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62F27D403992C0DFFFFF" , vpminsd(zmm2, zmm16, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62F27D5039527F" , vpminsd(zmm2, zmm16, dword_ptr(rdx, 508)._1to16())); + TEST_INSTRUCTION("62F27D50399200020000" , vpminsd(zmm2, zmm16, dword_ptr(rdx, 512)._1to16())); + TEST_INSTRUCTION("62F27D50395280" , vpminsd(zmm2, zmm16, dword_ptr(rdx, -512)._1to16())); + TEST_INSTRUCTION("62F27D503992FCFDFFFF" , vpminsd(zmm2, zmm16, dword_ptr(rdx, -516)._1to16())); + TEST_INSTRUCTION("62A2FD4039E1" , vpminsq(zmm20, zmm16, zmm17)); + TEST_INSTRUCTION("62A2FD4639E1" , k(k6).vpminsq(zmm20, zmm16, zmm17)); + TEST_INSTRUCTION("62A2FDC639E1" , k(k6).z().vpminsq(zmm20, zmm16, zmm17)); + TEST_INSTRUCTION("62E2FD403921" , vpminsq(zmm20, zmm16, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62A2FD4039A4F023010000" , vpminsq(zmm20, zmm16, zmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62E2FD503921" , vpminsq(zmm20, zmm16, qword_ptr(rcx)._1to8())); + TEST_INSTRUCTION("62E2FD4039627F" , vpminsq(zmm20, zmm16, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62E2FD4039A200200000" , vpminsq(zmm20, zmm16, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62E2FD40396280" , vpminsq(zmm20, zmm16, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62E2FD4039A2C0DFFFFF" , vpminsq(zmm20, zmm16, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62E2FD5039627F" , vpminsq(zmm20, zmm16, qword_ptr(rdx, 1016)._1to8())); + TEST_INSTRUCTION("62E2FD5039A200040000" , vpminsq(zmm20, zmm16, qword_ptr(rdx, 1024)._1to8())); + TEST_INSTRUCTION("62E2FD50396280" , vpminsq(zmm20, zmm16, qword_ptr(rdx, -1024)._1to8())); + TEST_INSTRUCTION("62E2FD5039A2F8FBFFFF" , vpminsq(zmm20, zmm16, qword_ptr(rdx, -1032)._1to8())); + TEST_INSTRUCTION("62B245403BDC" , vpminud(zmm3, zmm23, zmm20)); + TEST_INSTRUCTION("62B245433BDC" , k(k3).vpminud(zmm3, zmm23, zmm20)); + TEST_INSTRUCTION("62B245C33BDC" , k(k3).z().vpminud(zmm3, zmm23, zmm20)); + TEST_INSTRUCTION("62F245403B19" , vpminud(zmm3, zmm23, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62B245403B9CF023010000" , vpminud(zmm3, zmm23, zmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62F245503B19" , vpminud(zmm3, zmm23, dword_ptr(rcx)._1to16())); + TEST_INSTRUCTION("62F245403B5A7F" , vpminud(zmm3, zmm23, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62F245403B9A00200000" , vpminud(zmm3, zmm23, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62F245403B5A80" , vpminud(zmm3, zmm23, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62F245403B9AC0DFFFFF" , vpminud(zmm3, zmm23, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62F245503B5A7F" , vpminud(zmm3, zmm23, dword_ptr(rdx, 508)._1to16())); + TEST_INSTRUCTION("62F245503B9A00020000" , vpminud(zmm3, zmm23, dword_ptr(rdx, 512)._1to16())); + TEST_INSTRUCTION("62F245503B5A80" , vpminud(zmm3, zmm23, dword_ptr(rdx, -512)._1to16())); + TEST_INSTRUCTION("62F245503B9AFCFDFFFF" , vpminud(zmm3, zmm23, dword_ptr(rdx, -516)._1to16())); + TEST_INSTRUCTION("6272AD403BDF" , vpminuq(zmm11, zmm26, zmm7)); + TEST_INSTRUCTION("6272AD453BDF" , k(k5).vpminuq(zmm11, zmm26, zmm7)); + TEST_INSTRUCTION("6272ADC53BDF" , k(k5).z().vpminuq(zmm11, zmm26, zmm7)); + TEST_INSTRUCTION("6272AD403B19" , vpminuq(zmm11, zmm26, zmmword_ptr(rcx))); + TEST_INSTRUCTION("6232AD403B9CF023010000" , vpminuq(zmm11, zmm26, zmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("6272AD503B19" , vpminuq(zmm11, zmm26, qword_ptr(rcx)._1to8())); + TEST_INSTRUCTION("6272AD403B5A7F" , vpminuq(zmm11, zmm26, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("6272AD403B9A00200000" , vpminuq(zmm11, zmm26, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("6272AD403B5A80" , vpminuq(zmm11, zmm26, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("6272AD403B9AC0DFFFFF" , vpminuq(zmm11, zmm26, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("6272AD503B5A7F" , vpminuq(zmm11, zmm26, qword_ptr(rdx, 1016)._1to8())); + TEST_INSTRUCTION("6272AD503B9A00040000" , vpminuq(zmm11, zmm26, qword_ptr(rdx, 1024)._1to8())); + TEST_INSTRUCTION("6272AD503B5A80" , vpminuq(zmm11, zmm26, qword_ptr(rdx, -1024)._1to8())); + TEST_INSTRUCTION("6272AD503B9AF8FBFFFF" , vpminuq(zmm11, zmm26, qword_ptr(rdx, -1032)._1to8())); + TEST_INSTRUCTION("62627D4821DF" , vpmovsxbd(zmm27, xmm7)); + TEST_INSTRUCTION("62627D4D21DF" , k(k5).vpmovsxbd(zmm27, xmm7)); + TEST_INSTRUCTION("62627DCD21DF" , k(k5).z().vpmovsxbd(zmm27, xmm7)); + TEST_INSTRUCTION("62627D482119" , vpmovsxbd(zmm27, xmmword_ptr(rcx))); + TEST_INSTRUCTION("62227D48219CF023010000" , vpmovsxbd(zmm27, xmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62627D48215A7F" , vpmovsxbd(zmm27, xmmword_ptr(rdx, 2032))); + TEST_INSTRUCTION("62627D48219A00080000" , vpmovsxbd(zmm27, xmmword_ptr(rdx, 2048))); + TEST_INSTRUCTION("62627D48215A80" , vpmovsxbd(zmm27, xmmword_ptr(rdx, -2048))); + TEST_INSTRUCTION("62627D48219AF0F7FFFF" , vpmovsxbd(zmm27, xmmword_ptr(rdx, -2064))); + TEST_INSTRUCTION("62527D4822DB" , vpmovsxbq(zmm11, xmm11)); + TEST_INSTRUCTION("62527D4D22DB" , k(k5).vpmovsxbq(zmm11, xmm11)); + TEST_INSTRUCTION("62527DCD22DB" , k(k5).z().vpmovsxbq(zmm11, xmm11)); + TEST_INSTRUCTION("62727D482219" , vpmovsxbq(zmm11, qword_ptr(rcx))); + TEST_INSTRUCTION("62327D48229CF023010000" , vpmovsxbq(zmm11, qword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62727D48225A7F" , vpmovsxbq(zmm11, qword_ptr(rdx, 1016))); + TEST_INSTRUCTION("62727D48229A00040000" , vpmovsxbq(zmm11, qword_ptr(rdx, 1024))); + TEST_INSTRUCTION("62727D48225A80" , vpmovsxbq(zmm11, qword_ptr(rdx, -1024))); + TEST_INSTRUCTION("62727D48229AF8FBFFFF" , vpmovsxbq(zmm11, qword_ptr(rdx, -1032))); + TEST_INSTRUCTION("62027D4825D5" , vpmovsxdq(zmm26, ymm29)); + TEST_INSTRUCTION("62027D4925D5" , k(k1).vpmovsxdq(zmm26, ymm29)); + TEST_INSTRUCTION("62027DC925D5" , k(k1).z().vpmovsxdq(zmm26, ymm29)); + TEST_INSTRUCTION("62627D482511" , vpmovsxdq(zmm26, ymmword_ptr(rcx))); + TEST_INSTRUCTION("62227D482594F023010000" , vpmovsxdq(zmm26, ymmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62627D4825527F" , vpmovsxdq(zmm26, ymmword_ptr(rdx, 4064))); + TEST_INSTRUCTION("62627D48259200100000" , vpmovsxdq(zmm26, ymmword_ptr(rdx, 4096))); + TEST_INSTRUCTION("62627D48255280" , vpmovsxdq(zmm26, ymmword_ptr(rdx, -4096))); + TEST_INSTRUCTION("62627D482592E0EFFFFF" , vpmovsxdq(zmm26, ymmword_ptr(rdx, -4128))); + TEST_INSTRUCTION("62C27D4823FB" , vpmovsxwd(zmm23, ymm11)); + TEST_INSTRUCTION("62C27D4A23FB" , k(k2).vpmovsxwd(zmm23, ymm11)); + TEST_INSTRUCTION("62C27DCA23FB" , k(k2).z().vpmovsxwd(zmm23, ymm11)); + TEST_INSTRUCTION("62E27D482339" , vpmovsxwd(zmm23, ymmword_ptr(rcx))); + TEST_INSTRUCTION("62A27D4823BCF023010000" , vpmovsxwd(zmm23, ymmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62E27D48237A7F" , vpmovsxwd(zmm23, ymmword_ptr(rdx, 4064))); + TEST_INSTRUCTION("62E27D4823BA00100000" , vpmovsxwd(zmm23, ymmword_ptr(rdx, 4096))); + TEST_INSTRUCTION("62E27D48237A80" , vpmovsxwd(zmm23, ymmword_ptr(rdx, -4096))); + TEST_INSTRUCTION("62E27D4823BAE0EFFFFF" , vpmovsxwd(zmm23, ymmword_ptr(rdx, -4128))); + TEST_INSTRUCTION("62027D4824C9" , vpmovsxwq(zmm25, xmm25)); + TEST_INSTRUCTION("62027D4C24C9" , k(k4).vpmovsxwq(zmm25, xmm25)); + TEST_INSTRUCTION("62027DCC24C9" , k(k4).z().vpmovsxwq(zmm25, xmm25)); + TEST_INSTRUCTION("62627D482409" , vpmovsxwq(zmm25, xmmword_ptr(rcx))); + TEST_INSTRUCTION("62227D48248CF023010000" , vpmovsxwq(zmm25, xmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62627D48244A7F" , vpmovsxwq(zmm25, xmmword_ptr(rdx, 2032))); + TEST_INSTRUCTION("62627D48248A00080000" , vpmovsxwq(zmm25, xmmword_ptr(rdx, 2048))); + TEST_INSTRUCTION("62627D48244A80" , vpmovsxwq(zmm25, xmmword_ptr(rdx, -2048))); + TEST_INSTRUCTION("62627D48248AF0F7FFFF" , vpmovsxwq(zmm25, xmmword_ptr(rdx, -2064))); + TEST_INSTRUCTION("62827D4831D1" , vpmovzxbd(zmm18, xmm25)); + TEST_INSTRUCTION("62827D4F31D1" , k(k7).vpmovzxbd(zmm18, xmm25)); + TEST_INSTRUCTION("62827DCF31D1" , k(k7).z().vpmovzxbd(zmm18, xmm25)); + TEST_INSTRUCTION("62E27D483111" , vpmovzxbd(zmm18, xmmword_ptr(rcx))); + TEST_INSTRUCTION("62A27D483194F023010000" , vpmovzxbd(zmm18, xmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62E27D4831527F" , vpmovzxbd(zmm18, xmmword_ptr(rdx, 2032))); + TEST_INSTRUCTION("62E27D48319200080000" , vpmovzxbd(zmm18, xmmword_ptr(rdx, 2048))); + TEST_INSTRUCTION("62E27D48315280" , vpmovzxbd(zmm18, xmmword_ptr(rdx, -2048))); + TEST_INSTRUCTION("62E27D483192F0F7FFFF" , vpmovzxbd(zmm18, xmmword_ptr(rdx, -2064))); + TEST_INSTRUCTION("62D27D4832EF" , vpmovzxbq(zmm5, xmm15)); + TEST_INSTRUCTION("62D27D4932EF" , k(k1).vpmovzxbq(zmm5, xmm15)); + TEST_INSTRUCTION("62D27DC932EF" , k(k1).z().vpmovzxbq(zmm5, xmm15)); + TEST_INSTRUCTION("62F27D483229" , vpmovzxbq(zmm5, qword_ptr(rcx))); + TEST_INSTRUCTION("62B27D4832ACF023010000" , vpmovzxbq(zmm5, qword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62F27D48326A7F" , vpmovzxbq(zmm5, qword_ptr(rdx, 1016))); + TEST_INSTRUCTION("62F27D4832AA00040000" , vpmovzxbq(zmm5, qword_ptr(rdx, 1024))); + TEST_INSTRUCTION("62F27D48326A80" , vpmovzxbq(zmm5, qword_ptr(rdx, -1024))); + TEST_INSTRUCTION("62F27D4832AAF8FBFFFF" , vpmovzxbq(zmm5, qword_ptr(rdx, -1032))); + TEST_INSTRUCTION("62E27D4835E4" , vpmovzxdq(zmm20, ymm4)); + TEST_INSTRUCTION("62E27D4B35E4" , k(k3).vpmovzxdq(zmm20, ymm4)); + TEST_INSTRUCTION("62E27DCB35E4" , k(k3).z().vpmovzxdq(zmm20, ymm4)); + TEST_INSTRUCTION("62E27D483521" , vpmovzxdq(zmm20, ymmword_ptr(rcx))); + TEST_INSTRUCTION("62A27D4835A4F023010000" , vpmovzxdq(zmm20, ymmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62E27D4835627F" , vpmovzxdq(zmm20, ymmword_ptr(rdx, 4064))); + TEST_INSTRUCTION("62E27D4835A200100000" , vpmovzxdq(zmm20, ymmword_ptr(rdx, 4096))); + TEST_INSTRUCTION("62E27D48356280" , vpmovzxdq(zmm20, ymmword_ptr(rdx, -4096))); + TEST_INSTRUCTION("62E27D4835A2E0EFFFFF" , vpmovzxdq(zmm20, ymmword_ptr(rdx, -4128))); + TEST_INSTRUCTION("62727D4833C6" , vpmovzxwd(zmm8, ymm6)); + TEST_INSTRUCTION("62727D4F33C6" , k(k7).vpmovzxwd(zmm8, ymm6)); + TEST_INSTRUCTION("62727DCF33C6" , k(k7).z().vpmovzxwd(zmm8, ymm6)); + TEST_INSTRUCTION("62727D483301" , vpmovzxwd(zmm8, ymmword_ptr(rcx))); + TEST_INSTRUCTION("62327D483384F023010000" , vpmovzxwd(zmm8, ymmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62727D4833427F" , vpmovzxwd(zmm8, ymmword_ptr(rdx, 4064))); + TEST_INSTRUCTION("62727D48338200100000" , vpmovzxwd(zmm8, ymmword_ptr(rdx, 4096))); + TEST_INSTRUCTION("62727D48334280" , vpmovzxwd(zmm8, ymmword_ptr(rdx, -4096))); + TEST_INSTRUCTION("62727D483382E0EFFFFF" , vpmovzxwd(zmm8, ymmword_ptr(rdx, -4128))); + TEST_INSTRUCTION("62D27D4834EF" , vpmovzxwq(zmm5, xmm15)); + TEST_INSTRUCTION("62D27D4F34EF" , k(k7).vpmovzxwq(zmm5, xmm15)); + TEST_INSTRUCTION("62D27DCF34EF" , k(k7).z().vpmovzxwq(zmm5, xmm15)); + TEST_INSTRUCTION("62F27D483429" , vpmovzxwq(zmm5, xmmword_ptr(rcx))); + TEST_INSTRUCTION("62B27D4834ACF023010000" , vpmovzxwq(zmm5, xmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62F27D48346A7F" , vpmovzxwq(zmm5, xmmword_ptr(rdx, 2032))); + TEST_INSTRUCTION("62F27D4834AA00080000" , vpmovzxwq(zmm5, xmmword_ptr(rdx, 2048))); + TEST_INSTRUCTION("62F27D48346A80" , vpmovzxwq(zmm5, xmmword_ptr(rdx, -2048))); + TEST_INSTRUCTION("62F27D4834AAF0F7FFFF" , vpmovzxwq(zmm5, xmmword_ptr(rdx, -2064))); + TEST_INSTRUCTION("6242B54828E9" , vpmuldq(zmm29, zmm9, zmm9)); + TEST_INSTRUCTION("6242B54D28E9" , k(k5).vpmuldq(zmm29, zmm9, zmm9)); + TEST_INSTRUCTION("6242B5CD28E9" , k(k5).z().vpmuldq(zmm29, zmm9, zmm9)); + TEST_INSTRUCTION("6262B5482829" , vpmuldq(zmm29, zmm9, zmmword_ptr(rcx))); + TEST_INSTRUCTION("6222B54828ACF023010000" , vpmuldq(zmm29, zmm9, zmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("6262B5582829" , vpmuldq(zmm29, zmm9, qword_ptr(rcx)._1to8())); + TEST_INSTRUCTION("6262B548286A7F" , vpmuldq(zmm29, zmm9, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("6262B54828AA00200000" , vpmuldq(zmm29, zmm9, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("6262B548286A80" , vpmuldq(zmm29, zmm9, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("6262B54828AAC0DFFFFF" , vpmuldq(zmm29, zmm9, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("6262B558286A7F" , vpmuldq(zmm29, zmm9, qword_ptr(rdx, 1016)._1to8())); + TEST_INSTRUCTION("6262B55828AA00040000" , vpmuldq(zmm29, zmm9, qword_ptr(rdx, 1024)._1to8())); + TEST_INSTRUCTION("6262B558286A80" , vpmuldq(zmm29, zmm9, qword_ptr(rdx, -1024)._1to8())); + TEST_INSTRUCTION("6262B55828AAF8FBFFFF" , vpmuldq(zmm29, zmm9, qword_ptr(rdx, -1032)._1to8())); + TEST_INSTRUCTION("6272654840E2" , vpmulld(zmm12, zmm3, zmm2)); + TEST_INSTRUCTION("6272654E40E2" , k(k6).vpmulld(zmm12, zmm3, zmm2)); + TEST_INSTRUCTION("627265CE40E2" , k(k6).z().vpmulld(zmm12, zmm3, zmm2)); + TEST_INSTRUCTION("627265484021" , vpmulld(zmm12, zmm3, zmmword_ptr(rcx))); + TEST_INSTRUCTION("6232654840A4F023010000" , vpmulld(zmm12, zmm3, zmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("627265584021" , vpmulld(zmm12, zmm3, dword_ptr(rcx)._1to16())); + TEST_INSTRUCTION("6272654840627F" , vpmulld(zmm12, zmm3, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("6272654840A200200000" , vpmulld(zmm12, zmm3, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62726548406280" , vpmulld(zmm12, zmm3, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("6272654840A2C0DFFFFF" , vpmulld(zmm12, zmm3, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("6272655840627F" , vpmulld(zmm12, zmm3, dword_ptr(rdx, 508)._1to16())); + TEST_INSTRUCTION("6272655840A200020000" , vpmulld(zmm12, zmm3, dword_ptr(rdx, 512)._1to16())); + TEST_INSTRUCTION("62726558406280" , vpmulld(zmm12, zmm3, dword_ptr(rdx, -512)._1to16())); + TEST_INSTRUCTION("6272655840A2FCFDFFFF" , vpmulld(zmm12, zmm3, dword_ptr(rdx, -516)._1to16())); + TEST_INSTRUCTION("62C1D548F4F9" , vpmuludq(zmm23, zmm5, zmm9)); + TEST_INSTRUCTION("62C1D54CF4F9" , k(k4).vpmuludq(zmm23, zmm5, zmm9)); + TEST_INSTRUCTION("62C1D5CCF4F9" , k(k4).z().vpmuludq(zmm23, zmm5, zmm9)); + TEST_INSTRUCTION("62E1D548F439" , vpmuludq(zmm23, zmm5, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62A1D548F4BCF023010000" , vpmuludq(zmm23, zmm5, zmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62E1D558F439" , vpmuludq(zmm23, zmm5, qword_ptr(rcx)._1to8())); + TEST_INSTRUCTION("62E1D548F47A7F" , vpmuludq(zmm23, zmm5, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62E1D548F4BA00200000" , vpmuludq(zmm23, zmm5, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62E1D548F47A80" , vpmuludq(zmm23, zmm5, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62E1D548F4BAC0DFFFFF" , vpmuludq(zmm23, zmm5, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62E1D558F47A7F" , vpmuludq(zmm23, zmm5, qword_ptr(rdx, 1016)._1to8())); + TEST_INSTRUCTION("62E1D558F4BA00040000" , vpmuludq(zmm23, zmm5, qword_ptr(rdx, 1024)._1to8())); + TEST_INSTRUCTION("62E1D558F47A80" , vpmuludq(zmm23, zmm5, qword_ptr(rdx, -1024)._1to8())); + TEST_INSTRUCTION("62E1D558F4BAF8FBFFFF" , vpmuludq(zmm23, zmm5, qword_ptr(rdx, -1032)._1to8())); + TEST_INSTRUCTION("62A16D48EBFC" , vpord(zmm23, zmm2, zmm20)); + TEST_INSTRUCTION("62A16D4AEBFC" , k(k2).vpord(zmm23, zmm2, zmm20)); + TEST_INSTRUCTION("62A16DCAEBFC" , k(k2).z().vpord(zmm23, zmm2, zmm20)); + TEST_INSTRUCTION("62E16D48EB39" , vpord(zmm23, zmm2, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62A16D48EBBCF023010000" , vpord(zmm23, zmm2, zmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62E16D58EB39" , vpord(zmm23, zmm2, dword_ptr(rcx)._1to16())); + TEST_INSTRUCTION("62E16D48EB7A7F" , vpord(zmm23, zmm2, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62E16D48EBBA00200000" , vpord(zmm23, zmm2, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62E16D48EB7A80" , vpord(zmm23, zmm2, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62E16D48EBBAC0DFFFFF" , vpord(zmm23, zmm2, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62E16D58EB7A7F" , vpord(zmm23, zmm2, dword_ptr(rdx, 508)._1to16())); + TEST_INSTRUCTION("62E16D58EBBA00020000" , vpord(zmm23, zmm2, dword_ptr(rdx, 512)._1to16())); + TEST_INSTRUCTION("62E16D58EB7A80" , vpord(zmm23, zmm2, dword_ptr(rdx, -512)._1to16())); + TEST_INSTRUCTION("62E16D58EBBAFCFDFFFF" , vpord(zmm23, zmm2, dword_ptr(rdx, -516)._1to16())); + TEST_INSTRUCTION("62F1AD48EBCE" , vporq(zmm1, zmm10, zmm6)); + TEST_INSTRUCTION("62F1AD4AEBCE" , k(k2).vporq(zmm1, zmm10, zmm6)); + TEST_INSTRUCTION("62F1ADCAEBCE" , k(k2).z().vporq(zmm1, zmm10, zmm6)); + TEST_INSTRUCTION("62F1AD48EB09" , vporq(zmm1, zmm10, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62B1AD48EB8CF023010000" , vporq(zmm1, zmm10, zmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62F1AD58EB09" , vporq(zmm1, zmm10, qword_ptr(rcx)._1to8())); + TEST_INSTRUCTION("62F1AD48EB4A7F" , vporq(zmm1, zmm10, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62F1AD48EB8A00200000" , vporq(zmm1, zmm10, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62F1AD48EB4A80" , vporq(zmm1, zmm10, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62F1AD48EB8AC0DFFFFF" , vporq(zmm1, zmm10, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62F1AD58EB4A7F" , vporq(zmm1, zmm10, qword_ptr(rdx, 1016)._1to8())); + TEST_INSTRUCTION("62F1AD58EB8A00040000" , vporq(zmm1, zmm10, qword_ptr(rdx, 1024)._1to8())); + TEST_INSTRUCTION("62F1AD58EB4A80" , vporq(zmm1, zmm10, qword_ptr(rdx, -1024)._1to8())); + TEST_INSTRUCTION("62F1AD58EB8AF8FBFFFF" , vporq(zmm1, zmm10, qword_ptr(rdx, -1032)._1to8())); + TEST_INSTRUCTION("62817D4870D9AB" , vpshufd(zmm19, zmm25, 171)); + TEST_INSTRUCTION("62817D4E70D9AB" , k(k6).vpshufd(zmm19, zmm25, 171)); + TEST_INSTRUCTION("62817DCE70D9AB" , k(k6).z().vpshufd(zmm19, zmm25, 171)); + TEST_INSTRUCTION("62817D4870D97B" , vpshufd(zmm19, zmm25, 123)); + TEST_INSTRUCTION("62E17D4870197B" , vpshufd(zmm19, zmmword_ptr(rcx), 123)); + TEST_INSTRUCTION("62A17D48709CF0230100007B" , vpshufd(zmm19, zmmword_ptr(rax, r14, 3, 291), 123)); + TEST_INSTRUCTION("62E17D5870197B" , vpshufd(zmm19, dword_ptr(rcx)._1to16(), 123)); + TEST_INSTRUCTION("62E17D48705A7F7B" , vpshufd(zmm19, zmmword_ptr(rdx, 8128), 123)); + TEST_INSTRUCTION("62E17D48709A002000007B" , vpshufd(zmm19, zmmword_ptr(rdx, 8192), 123)); + TEST_INSTRUCTION("62E17D48705A807B" , vpshufd(zmm19, zmmword_ptr(rdx, -8192), 123)); + TEST_INSTRUCTION("62E17D48709AC0DFFFFF7B" , vpshufd(zmm19, zmmword_ptr(rdx, -8256), 123)); + TEST_INSTRUCTION("62E17D58705A7F7B" , vpshufd(zmm19, dword_ptr(rdx, 508)._1to16(), 123)); + TEST_INSTRUCTION("62E17D58709A000200007B" , vpshufd(zmm19, dword_ptr(rdx, 512)._1to16(), 123)); + TEST_INSTRUCTION("62E17D58705A807B" , vpshufd(zmm19, dword_ptr(rdx, -512)._1to16(), 123)); + TEST_INSTRUCTION("62E17D58709AFCFDFFFF7B" , vpshufd(zmm19, dword_ptr(rdx, -516)._1to16(), 123)); + TEST_INSTRUCTION("62E14D48F2CB" , vpslld(zmm17, zmm6, xmm3)); + TEST_INSTRUCTION("62E14D4BF2CB" , k(k3).vpslld(zmm17, zmm6, xmm3)); + TEST_INSTRUCTION("62E14DCBF2CB" , k(k3).z().vpslld(zmm17, zmm6, xmm3)); + TEST_INSTRUCTION("62E14D48F209" , vpslld(zmm17, zmm6, xmmword_ptr(rcx))); + TEST_INSTRUCTION("62A14D48F28CF023010000" , vpslld(zmm17, zmm6, xmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62E14D48F24A7F" , vpslld(zmm17, zmm6, xmmword_ptr(rdx, 2032))); + TEST_INSTRUCTION("62E14D48F28A00080000" , vpslld(zmm17, zmm6, xmmword_ptr(rdx, 2048))); + TEST_INSTRUCTION("62E14D48F24A80" , vpslld(zmm17, zmm6, xmmword_ptr(rdx, -2048))); + TEST_INSTRUCTION("62E14D48F28AF0F7FFFF" , vpslld(zmm17, zmm6, xmmword_ptr(rdx, -2064))); + TEST_INSTRUCTION("6221F540F3D7" , vpsllq(zmm26, zmm17, xmm23)); + TEST_INSTRUCTION("6221F546F3D7" , k(k6).vpsllq(zmm26, zmm17, xmm23)); + TEST_INSTRUCTION("6221F5C6F3D7" , k(k6).z().vpsllq(zmm26, zmm17, xmm23)); + TEST_INSTRUCTION("6261F540F311" , vpsllq(zmm26, zmm17, xmmword_ptr(rcx))); + TEST_INSTRUCTION("6221F540F394F023010000" , vpsllq(zmm26, zmm17, xmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("6261F540F3527F" , vpsllq(zmm26, zmm17, xmmword_ptr(rdx, 2032))); + TEST_INSTRUCTION("6261F540F39200080000" , vpsllq(zmm26, zmm17, xmmword_ptr(rdx, 2048))); + TEST_INSTRUCTION("6261F540F35280" , vpsllq(zmm26, zmm17, xmmword_ptr(rdx, -2048))); + TEST_INSTRUCTION("6261F540F392F0F7FFFF" , vpsllq(zmm26, zmm17, xmmword_ptr(rdx, -2064))); + TEST_INSTRUCTION("62321D4847D6" , vpsllvd(zmm10, zmm12, zmm22)); + TEST_INSTRUCTION("62321D4E47D6" , k(k6).vpsllvd(zmm10, zmm12, zmm22)); + TEST_INSTRUCTION("62321DCE47D6" , k(k6).z().vpsllvd(zmm10, zmm12, zmm22)); + TEST_INSTRUCTION("62721D484711" , vpsllvd(zmm10, zmm12, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62321D484794F023010000" , vpsllvd(zmm10, zmm12, zmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62721D584711" , vpsllvd(zmm10, zmm12, dword_ptr(rcx)._1to16())); + TEST_INSTRUCTION("62721D4847527F" , vpsllvd(zmm10, zmm12, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62721D48479200200000" , vpsllvd(zmm10, zmm12, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62721D48475280" , vpsllvd(zmm10, zmm12, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62721D484792C0DFFFFF" , vpsllvd(zmm10, zmm12, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62721D5847527F" , vpsllvd(zmm10, zmm12, dword_ptr(rdx, 508)._1to16())); + TEST_INSTRUCTION("62721D58479200020000" , vpsllvd(zmm10, zmm12, dword_ptr(rdx, 512)._1to16())); + TEST_INSTRUCTION("62721D58475280" , vpsllvd(zmm10, zmm12, dword_ptr(rdx, -512)._1to16())); + TEST_INSTRUCTION("62721D584792FCFDFFFF" , vpsllvd(zmm10, zmm12, dword_ptr(rdx, -516)._1to16())); + TEST_INSTRUCTION("6282D54847C2" , vpsllvq(zmm16, zmm5, zmm26)); + TEST_INSTRUCTION("6282D54D47C2" , k(k5).vpsllvq(zmm16, zmm5, zmm26)); + TEST_INSTRUCTION("6282D5CD47C2" , k(k5).z().vpsllvq(zmm16, zmm5, zmm26)); + TEST_INSTRUCTION("62E2D5484701" , vpsllvq(zmm16, zmm5, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62A2D5484784F023010000" , vpsllvq(zmm16, zmm5, zmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62E2D5584701" , vpsllvq(zmm16, zmm5, qword_ptr(rcx)._1to8())); + TEST_INSTRUCTION("62E2D54847427F" , vpsllvq(zmm16, zmm5, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62E2D548478200200000" , vpsllvq(zmm16, zmm5, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62E2D548474280" , vpsllvq(zmm16, zmm5, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62E2D5484782C0DFFFFF" , vpsllvq(zmm16, zmm5, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62E2D55847427F" , vpsllvq(zmm16, zmm5, qword_ptr(rdx, 1016)._1to8())); + TEST_INSTRUCTION("62E2D558478200040000" , vpsllvq(zmm16, zmm5, qword_ptr(rdx, 1024)._1to8())); + TEST_INSTRUCTION("62E2D558474280" , vpsllvq(zmm16, zmm5, qword_ptr(rdx, -1024)._1to8())); + TEST_INSTRUCTION("62E2D5584782F8FBFFFF" , vpsllvq(zmm16, zmm5, qword_ptr(rdx, -1032)._1to8())); + TEST_INSTRUCTION("62E10D48E2D6" , vpsrad(zmm18, zmm14, xmm6)); + TEST_INSTRUCTION("62E10D49E2D6" , k(k1).vpsrad(zmm18, zmm14, xmm6)); + TEST_INSTRUCTION("62E10DC9E2D6" , k(k1).z().vpsrad(zmm18, zmm14, xmm6)); + TEST_INSTRUCTION("62E10D48E211" , vpsrad(zmm18, zmm14, xmmword_ptr(rcx))); + TEST_INSTRUCTION("62A10D48E294F023010000" , vpsrad(zmm18, zmm14, xmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62E10D48E2527F" , vpsrad(zmm18, zmm14, xmmword_ptr(rdx, 2032))); + TEST_INSTRUCTION("62E10D48E29200080000" , vpsrad(zmm18, zmm14, xmmword_ptr(rdx, 2048))); + TEST_INSTRUCTION("62E10D48E25280" , vpsrad(zmm18, zmm14, xmmword_ptr(rdx, -2048))); + TEST_INSTRUCTION("62E10D48E292F0F7FFFF" , vpsrad(zmm18, zmm14, xmmword_ptr(rdx, -2064))); + TEST_INSTRUCTION("62A1F540E2EE" , vpsraq(zmm21, zmm17, xmm22)); + TEST_INSTRUCTION("62A1F543E2EE" , k(k3).vpsraq(zmm21, zmm17, xmm22)); + TEST_INSTRUCTION("62A1F5C3E2EE" , k(k3).z().vpsraq(zmm21, zmm17, xmm22)); + TEST_INSTRUCTION("62E1F540E229" , vpsraq(zmm21, zmm17, xmmword_ptr(rcx))); + TEST_INSTRUCTION("62A1F540E2ACF023010000" , vpsraq(zmm21, zmm17, xmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62E1F540E26A7F" , vpsraq(zmm21, zmm17, xmmword_ptr(rdx, 2032))); + TEST_INSTRUCTION("62E1F540E2AA00080000" , vpsraq(zmm21, zmm17, xmmword_ptr(rdx, 2048))); + TEST_INSTRUCTION("62E1F540E26A80" , vpsraq(zmm21, zmm17, xmmword_ptr(rdx, -2048))); + TEST_INSTRUCTION("62E1F540E2AAF0F7FFFF" , vpsraq(zmm21, zmm17, xmmword_ptr(rdx, -2064))); + TEST_INSTRUCTION("6222154046E9" , vpsravd(zmm29, zmm29, zmm17)); + TEST_INSTRUCTION("6222154246E9" , k(k2).vpsravd(zmm29, zmm29, zmm17)); + TEST_INSTRUCTION("622215C246E9" , k(k2).z().vpsravd(zmm29, zmm29, zmm17)); + TEST_INSTRUCTION("626215404629" , vpsravd(zmm29, zmm29, zmmword_ptr(rcx))); + TEST_INSTRUCTION("6222154046ACF023010000" , vpsravd(zmm29, zmm29, zmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("626215504629" , vpsravd(zmm29, zmm29, dword_ptr(rcx)._1to16())); + TEST_INSTRUCTION("62621540466A7F" , vpsravd(zmm29, zmm29, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("6262154046AA00200000" , vpsravd(zmm29, zmm29, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62621540466A80" , vpsravd(zmm29, zmm29, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("6262154046AAC0DFFFFF" , vpsravd(zmm29, zmm29, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62621550466A7F" , vpsravd(zmm29, zmm29, dword_ptr(rdx, 508)._1to16())); + TEST_INSTRUCTION("6262155046AA00020000" , vpsravd(zmm29, zmm29, dword_ptr(rdx, 512)._1to16())); + TEST_INSTRUCTION("62621550466A80" , vpsravd(zmm29, zmm29, dword_ptr(rdx, -512)._1to16())); + TEST_INSTRUCTION("6262155046AAFCFDFFFF" , vpsravd(zmm29, zmm29, dword_ptr(rdx, -516)._1to16())); + TEST_INSTRUCTION("62E2DD4046F2" , vpsravq(zmm22, zmm20, zmm2)); + TEST_INSTRUCTION("62E2DD4246F2" , k(k2).vpsravq(zmm22, zmm20, zmm2)); + TEST_INSTRUCTION("62E2DDC246F2" , k(k2).z().vpsravq(zmm22, zmm20, zmm2)); + TEST_INSTRUCTION("62E2DD404631" , vpsravq(zmm22, zmm20, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62A2DD4046B4F023010000" , vpsravq(zmm22, zmm20, zmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62E2DD504631" , vpsravq(zmm22, zmm20, qword_ptr(rcx)._1to8())); + TEST_INSTRUCTION("62E2DD4046727F" , vpsravq(zmm22, zmm20, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62E2DD4046B200200000" , vpsravq(zmm22, zmm20, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62E2DD40467280" , vpsravq(zmm22, zmm20, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62E2DD4046B2C0DFFFFF" , vpsravq(zmm22, zmm20, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62E2DD5046727F" , vpsravq(zmm22, zmm20, qword_ptr(rdx, 1016)._1to8())); + TEST_INSTRUCTION("62E2DD5046B200040000" , vpsravq(zmm22, zmm20, qword_ptr(rdx, 1024)._1to8())); + TEST_INSTRUCTION("62E2DD50467280" , vpsravq(zmm22, zmm20, qword_ptr(rdx, -1024)._1to8())); + TEST_INSTRUCTION("62E2DD5046B2F8FBFFFF" , vpsravq(zmm22, zmm20, qword_ptr(rdx, -1032)._1to8())); + TEST_INSTRUCTION("62917540D2C9" , vpsrld(zmm1, zmm17, xmm25)); + TEST_INSTRUCTION("62917544D2C9" , k(k4).vpsrld(zmm1, zmm17, xmm25)); + TEST_INSTRUCTION("629175C4D2C9" , k(k4).z().vpsrld(zmm1, zmm17, xmm25)); + TEST_INSTRUCTION("62F17540D209" , vpsrld(zmm1, zmm17, xmmword_ptr(rcx))); + TEST_INSTRUCTION("62B17540D28CF023010000" , vpsrld(zmm1, zmm17, xmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62F17540D24A7F" , vpsrld(zmm1, zmm17, xmmword_ptr(rdx, 2032))); + TEST_INSTRUCTION("62F17540D28A00080000" , vpsrld(zmm1, zmm17, xmmword_ptr(rdx, 2048))); + TEST_INSTRUCTION("62F17540D24A80" , vpsrld(zmm1, zmm17, xmmword_ptr(rdx, -2048))); + TEST_INSTRUCTION("62F17540D28AF0F7FFFF" , vpsrld(zmm1, zmm17, xmmword_ptr(rdx, -2064))); + TEST_INSTRUCTION("6271A548D3CB" , vpsrlq(zmm9, zmm11, xmm3)); + TEST_INSTRUCTION("6271A54DD3CB" , k(k5).vpsrlq(zmm9, zmm11, xmm3)); + TEST_INSTRUCTION("6271A5CDD3CB" , k(k5).z().vpsrlq(zmm9, zmm11, xmm3)); + TEST_INSTRUCTION("6271A548D309" , vpsrlq(zmm9, zmm11, xmmword_ptr(rcx))); + TEST_INSTRUCTION("6231A548D38CF023010000" , vpsrlq(zmm9, zmm11, xmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("6271A548D34A7F" , vpsrlq(zmm9, zmm11, xmmword_ptr(rdx, 2032))); + TEST_INSTRUCTION("6271A548D38A00080000" , vpsrlq(zmm9, zmm11, xmmword_ptr(rdx, 2048))); + TEST_INSTRUCTION("6271A548D34A80" , vpsrlq(zmm9, zmm11, xmmword_ptr(rdx, -2048))); + TEST_INSTRUCTION("6271A548D38AF0F7FFFF" , vpsrlq(zmm9, zmm11, xmmword_ptr(rdx, -2064))); + TEST_INSTRUCTION("62120D4845C4" , vpsrlvd(zmm8, zmm14, zmm28)); + TEST_INSTRUCTION("62120D4C45C4" , k(k4).vpsrlvd(zmm8, zmm14, zmm28)); + TEST_INSTRUCTION("62120DCC45C4" , k(k4).z().vpsrlvd(zmm8, zmm14, zmm28)); + TEST_INSTRUCTION("62720D484501" , vpsrlvd(zmm8, zmm14, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62320D484584F023010000" , vpsrlvd(zmm8, zmm14, zmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62720D584501" , vpsrlvd(zmm8, zmm14, dword_ptr(rcx)._1to16())); + TEST_INSTRUCTION("62720D4845427F" , vpsrlvd(zmm8, zmm14, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62720D48458200200000" , vpsrlvd(zmm8, zmm14, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62720D48454280" , vpsrlvd(zmm8, zmm14, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62720D484582C0DFFFFF" , vpsrlvd(zmm8, zmm14, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62720D5845427F" , vpsrlvd(zmm8, zmm14, dword_ptr(rdx, 508)._1to16())); + TEST_INSTRUCTION("62720D58458200020000" , vpsrlvd(zmm8, zmm14, dword_ptr(rdx, 512)._1to16())); + TEST_INSTRUCTION("62720D58454280" , vpsrlvd(zmm8, zmm14, dword_ptr(rdx, -512)._1to16())); + TEST_INSTRUCTION("62720D584582FCFDFFFF" , vpsrlvd(zmm8, zmm14, dword_ptr(rdx, -516)._1to16())); + TEST_INSTRUCTION("6282C54845E2" , vpsrlvq(zmm20, zmm7, zmm26)); + TEST_INSTRUCTION("6282C54D45E2" , k(k5).vpsrlvq(zmm20, zmm7, zmm26)); + TEST_INSTRUCTION("6282C5CD45E2" , k(k5).z().vpsrlvq(zmm20, zmm7, zmm26)); + TEST_INSTRUCTION("62E2C5484521" , vpsrlvq(zmm20, zmm7, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62A2C54845A4F023010000" , vpsrlvq(zmm20, zmm7, zmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62E2C5584521" , vpsrlvq(zmm20, zmm7, qword_ptr(rcx)._1to8())); + TEST_INSTRUCTION("62E2C54845627F" , vpsrlvq(zmm20, zmm7, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62E2C54845A200200000" , vpsrlvq(zmm20, zmm7, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62E2C548456280" , vpsrlvq(zmm20, zmm7, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62E2C54845A2C0DFFFFF" , vpsrlvq(zmm20, zmm7, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62E2C55845627F" , vpsrlvq(zmm20, zmm7, qword_ptr(rdx, 1016)._1to8())); + TEST_INSTRUCTION("62E2C55845A200040000" , vpsrlvq(zmm20, zmm7, qword_ptr(rdx, 1024)._1to8())); + TEST_INSTRUCTION("62E2C558456280" , vpsrlvq(zmm20, zmm7, qword_ptr(rdx, -1024)._1to8())); + TEST_INSTRUCTION("62E2C55845A2F8FBFFFF" , vpsrlvq(zmm20, zmm7, qword_ptr(rdx, -1032)._1to8())); + TEST_INSTRUCTION("62F1654872D5AB" , vpsrld(zmm3, zmm5, 171)); + TEST_INSTRUCTION("62F1654C72D5AB" , k(k4).vpsrld(zmm3, zmm5, 171)); + TEST_INSTRUCTION("62F165CC72D5AB" , k(k4).z().vpsrld(zmm3, zmm5, 171)); + TEST_INSTRUCTION("62F1654872D57B" , vpsrld(zmm3, zmm5, 123)); + TEST_INSTRUCTION("62F1654872117B" , vpsrld(zmm3, zmmword_ptr(rcx), 123)); + TEST_INSTRUCTION("62B165487294F0230100007B" , vpsrld(zmm3, zmmword_ptr(rax, r14, 3, 291), 123)); + TEST_INSTRUCTION("62F1655872117B" , vpsrld(zmm3, dword_ptr(rcx)._1to16(), 123)); + TEST_INSTRUCTION("62F1654872527F7B" , vpsrld(zmm3, zmmword_ptr(rdx, 8128), 123)); + TEST_INSTRUCTION("62F165487292002000007B" , vpsrld(zmm3, zmmword_ptr(rdx, 8192), 123)); + TEST_INSTRUCTION("62F165487252807B" , vpsrld(zmm3, zmmword_ptr(rdx, -8192), 123)); + TEST_INSTRUCTION("62F165487292C0DFFFFF7B" , vpsrld(zmm3, zmmword_ptr(rdx, -8256), 123)); + TEST_INSTRUCTION("62F1655872527F7B" , vpsrld(zmm3, dword_ptr(rdx, 508)._1to16(), 123)); + TEST_INSTRUCTION("62F165587292000200007B" , vpsrld(zmm3, dword_ptr(rdx, 512)._1to16(), 123)); + TEST_INSTRUCTION("62F165587252807B" , vpsrld(zmm3, dword_ptr(rdx, -512)._1to16(), 123)); + TEST_INSTRUCTION("62F165587292FCFDFFFF7B" , vpsrld(zmm3, dword_ptr(rdx, -516)._1to16(), 123)); + TEST_INSTRUCTION("6291ED4073D1AB" , vpsrlq(zmm18, zmm25, 171)); + TEST_INSTRUCTION("6291ED4173D1AB" , k(k1).vpsrlq(zmm18, zmm25, 171)); + TEST_INSTRUCTION("6291EDC173D1AB" , k(k1).z().vpsrlq(zmm18, zmm25, 171)); + TEST_INSTRUCTION("6291ED4073D17B" , vpsrlq(zmm18, zmm25, 123)); + TEST_INSTRUCTION("62F1ED4073117B" , vpsrlq(zmm18, zmmword_ptr(rcx), 123)); + TEST_INSTRUCTION("62B1ED407394F0230100007B" , vpsrlq(zmm18, zmmword_ptr(rax, r14, 3, 291), 123)); + TEST_INSTRUCTION("62F1ED5073117B" , vpsrlq(zmm18, qword_ptr(rcx)._1to8(), 123)); + TEST_INSTRUCTION("62F1ED4073527F7B" , vpsrlq(zmm18, zmmword_ptr(rdx, 8128), 123)); + TEST_INSTRUCTION("62F1ED407392002000007B" , vpsrlq(zmm18, zmmword_ptr(rdx, 8192), 123)); + TEST_INSTRUCTION("62F1ED407352807B" , vpsrlq(zmm18, zmmword_ptr(rdx, -8192), 123)); + TEST_INSTRUCTION("62F1ED407392C0DFFFFF7B" , vpsrlq(zmm18, zmmword_ptr(rdx, -8256), 123)); + TEST_INSTRUCTION("62F1ED5073527F7B" , vpsrlq(zmm18, qword_ptr(rdx, 1016)._1to8(), 123)); + TEST_INSTRUCTION("62F1ED507392000400007B" , vpsrlq(zmm18, qword_ptr(rdx, 1024)._1to8(), 123)); + TEST_INSTRUCTION("62F1ED507352807B" , vpsrlq(zmm18, qword_ptr(rdx, -1024)._1to8(), 123)); + TEST_INSTRUCTION("62F1ED507392F8FBFFFF7B" , vpsrlq(zmm18, qword_ptr(rdx, -1032)._1to8(), 123)); + TEST_INSTRUCTION("62F11D40FAFF" , vpsubd(zmm7, zmm28, zmm7)); + TEST_INSTRUCTION("62F11D43FAFF" , k(k3).vpsubd(zmm7, zmm28, zmm7)); + TEST_INSTRUCTION("62F11DC3FAFF" , k(k3).z().vpsubd(zmm7, zmm28, zmm7)); + TEST_INSTRUCTION("62F11D40FA39" , vpsubd(zmm7, zmm28, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62B11D40FABCF023010000" , vpsubd(zmm7, zmm28, zmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62F11D50FA39" , vpsubd(zmm7, zmm28, dword_ptr(rcx)._1to16())); + TEST_INSTRUCTION("62F11D40FA7A7F" , vpsubd(zmm7, zmm28, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62F11D40FABA00200000" , vpsubd(zmm7, zmm28, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62F11D40FA7A80" , vpsubd(zmm7, zmm28, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62F11D40FABAC0DFFFFF" , vpsubd(zmm7, zmm28, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62F11D50FA7A7F" , vpsubd(zmm7, zmm28, dword_ptr(rdx, 508)._1to16())); + TEST_INSTRUCTION("62F11D50FABA00020000" , vpsubd(zmm7, zmm28, dword_ptr(rdx, 512)._1to16())); + TEST_INSTRUCTION("62F11D50FA7A80" , vpsubd(zmm7, zmm28, dword_ptr(rdx, -512)._1to16())); + TEST_INSTRUCTION("62F11D50FABAFCFDFFFF" , vpsubd(zmm7, zmm28, dword_ptr(rdx, -516)._1to16())); + TEST_INSTRUCTION("62219D40FBE9" , vpsubq(zmm29, zmm28, zmm17)); + TEST_INSTRUCTION("62219D42FBE9" , k(k2).vpsubq(zmm29, zmm28, zmm17)); + TEST_INSTRUCTION("62219DC2FBE9" , k(k2).z().vpsubq(zmm29, zmm28, zmm17)); + TEST_INSTRUCTION("62619D40FB29" , vpsubq(zmm29, zmm28, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62219D40FBACF023010000" , vpsubq(zmm29, zmm28, zmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62619D50FB29" , vpsubq(zmm29, zmm28, qword_ptr(rcx)._1to8())); + TEST_INSTRUCTION("62619D40FB6A7F" , vpsubq(zmm29, zmm28, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62619D40FBAA00200000" , vpsubq(zmm29, zmm28, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62619D40FB6A80" , vpsubq(zmm29, zmm28, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62619D40FBAAC0DFFFFF" , vpsubq(zmm29, zmm28, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62619D50FB6A7F" , vpsubq(zmm29, zmm28, qword_ptr(rdx, 1016)._1to8())); + TEST_INSTRUCTION("62619D50FBAA00040000" , vpsubq(zmm29, zmm28, qword_ptr(rdx, 1024)._1to8())); + TEST_INSTRUCTION("62619D50FB6A80" , vpsubq(zmm29, zmm28, qword_ptr(rdx, -1024)._1to8())); + TEST_INSTRUCTION("62619D50FBAAF8FBFFFF" , vpsubq(zmm29, zmm28, qword_ptr(rdx, -1032)._1to8())); + TEST_INSTRUCTION("62B21D4827D0" , vptestmd(k2, zmm12, zmm16)); + TEST_INSTRUCTION("62B21D4927D0" , k(k1).vptestmd(k2, zmm12, zmm16)); + TEST_INSTRUCTION("62F21D482711" , vptestmd(k2, zmm12, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62B21D482794F023010000" , vptestmd(k2, zmm12, zmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62F21D582711" , vptestmd(k2, zmm12, dword_ptr(rcx)._1to16())); + TEST_INSTRUCTION("62F21D4827527F" , vptestmd(k2, zmm12, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62F21D48279200200000" , vptestmd(k2, zmm12, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62F21D48275280" , vptestmd(k2, zmm12, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62F21D482792C0DFFFFF" , vptestmd(k2, zmm12, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62F21D5827527F" , vptestmd(k2, zmm12, dword_ptr(rdx, 508)._1to16())); + TEST_INSTRUCTION("62F21D58279200020000" , vptestmd(k2, zmm12, dword_ptr(rdx, 512)._1to16())); + TEST_INSTRUCTION("62F21D58275280" , vptestmd(k2, zmm12, dword_ptr(rdx, -512)._1to16())); + TEST_INSTRUCTION("62F21D582792FCFDFFFF" , vptestmd(k2, zmm12, dword_ptr(rdx, -516)._1to16())); + TEST_INSTRUCTION("62B2CD4827ED" , vptestmq(k5, zmm6, zmm21)); + TEST_INSTRUCTION("62B2CD4D27ED" , k(k5).vptestmq(k5, zmm6, zmm21)); + TEST_INSTRUCTION("62F2CD482729" , vptestmq(k5, zmm6, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62B2CD4827ACF023010000" , vptestmq(k5, zmm6, zmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62F2CD582729" , vptestmq(k5, zmm6, qword_ptr(rcx)._1to8())); + TEST_INSTRUCTION("62F2CD48276A7F" , vptestmq(k5, zmm6, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62F2CD4827AA00200000" , vptestmq(k5, zmm6, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62F2CD48276A80" , vptestmq(k5, zmm6, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62F2CD4827AAC0DFFFFF" , vptestmq(k5, zmm6, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62F2CD58276A7F" , vptestmq(k5, zmm6, qword_ptr(rdx, 1016)._1to8())); + TEST_INSTRUCTION("62F2CD5827AA00040000" , vptestmq(k5, zmm6, qword_ptr(rdx, 1024)._1to8())); + TEST_INSTRUCTION("62F2CD58276A80" , vptestmq(k5, zmm6, qword_ptr(rdx, -1024)._1to8())); + TEST_INSTRUCTION("62F2CD5827AAF8FBFFFF" , vptestmq(k5, zmm6, qword_ptr(rdx, -1032)._1to8())); + TEST_INSTRUCTION("62D15D486AF5" , vpunpckhdq(zmm6, zmm4, zmm13)); + TEST_INSTRUCTION("62D15D4D6AF5" , k(k5).vpunpckhdq(zmm6, zmm4, zmm13)); + TEST_INSTRUCTION("62D15DCD6AF5" , k(k5).z().vpunpckhdq(zmm6, zmm4, zmm13)); + TEST_INSTRUCTION("62F15D486A31" , vpunpckhdq(zmm6, zmm4, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62B15D486AB4F023010000" , vpunpckhdq(zmm6, zmm4, zmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62F15D586A31" , vpunpckhdq(zmm6, zmm4, dword_ptr(rcx)._1to16())); + TEST_INSTRUCTION("62F15D486A727F" , vpunpckhdq(zmm6, zmm4, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62F15D486AB200200000" , vpunpckhdq(zmm6, zmm4, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62F15D486A7280" , vpunpckhdq(zmm6, zmm4, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62F15D486AB2C0DFFFFF" , vpunpckhdq(zmm6, zmm4, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62F15D586A727F" , vpunpckhdq(zmm6, zmm4, dword_ptr(rdx, 508)._1to16())); + TEST_INSTRUCTION("62F15D586AB200020000" , vpunpckhdq(zmm6, zmm4, dword_ptr(rdx, 512)._1to16())); + TEST_INSTRUCTION("62F15D586A7280" , vpunpckhdq(zmm6, zmm4, dword_ptr(rdx, -512)._1to16())); + TEST_INSTRUCTION("62F15D586AB2FCFDFFFF" , vpunpckhdq(zmm6, zmm4, dword_ptr(rdx, -516)._1to16())); + TEST_INSTRUCTION("622185486DD8" , vpunpckhqdq(zmm27, zmm15, zmm16)); + TEST_INSTRUCTION("6221854B6DD8" , k(k3).vpunpckhqdq(zmm27, zmm15, zmm16)); + TEST_INSTRUCTION("622185CB6DD8" , k(k3).z().vpunpckhqdq(zmm27, zmm15, zmm16)); + TEST_INSTRUCTION("626185486D19" , vpunpckhqdq(zmm27, zmm15, zmmword_ptr(rcx))); + TEST_INSTRUCTION("622185486D9CF023010000" , vpunpckhqdq(zmm27, zmm15, zmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("626185586D19" , vpunpckhqdq(zmm27, zmm15, qword_ptr(rcx)._1to8())); + TEST_INSTRUCTION("626185486D5A7F" , vpunpckhqdq(zmm27, zmm15, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("626185486D9A00200000" , vpunpckhqdq(zmm27, zmm15, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("626185486D5A80" , vpunpckhqdq(zmm27, zmm15, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("626185486D9AC0DFFFFF" , vpunpckhqdq(zmm27, zmm15, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("626185586D5A7F" , vpunpckhqdq(zmm27, zmm15, qword_ptr(rdx, 1016)._1to8())); + TEST_INSTRUCTION("626185586D9A00040000" , vpunpckhqdq(zmm27, zmm15, qword_ptr(rdx, 1024)._1to8())); + TEST_INSTRUCTION("626185586D5A80" , vpunpckhqdq(zmm27, zmm15, qword_ptr(rdx, -1024)._1to8())); + TEST_INSTRUCTION("626185586D9AF8FBFFFF" , vpunpckhqdq(zmm27, zmm15, qword_ptr(rdx, -1032)._1to8())); + TEST_INSTRUCTION("6221654862C1" , vpunpckldq(zmm24, zmm3, zmm17)); + TEST_INSTRUCTION("6221654B62C1" , k(k3).vpunpckldq(zmm24, zmm3, zmm17)); + TEST_INSTRUCTION("622165CB62C1" , k(k3).z().vpunpckldq(zmm24, zmm3, zmm17)); + TEST_INSTRUCTION("626165486201" , vpunpckldq(zmm24, zmm3, zmmword_ptr(rcx))); + TEST_INSTRUCTION("622165486284F023010000" , vpunpckldq(zmm24, zmm3, zmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("626165586201" , vpunpckldq(zmm24, zmm3, dword_ptr(rcx)._1to16())); + TEST_INSTRUCTION("6261654862427F" , vpunpckldq(zmm24, zmm3, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62616548628200200000" , vpunpckldq(zmm24, zmm3, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62616548624280" , vpunpckldq(zmm24, zmm3, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("626165486282C0DFFFFF" , vpunpckldq(zmm24, zmm3, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("6261655862427F" , vpunpckldq(zmm24, zmm3, dword_ptr(rdx, 508)._1to16())); + TEST_INSTRUCTION("62616558628200020000" , vpunpckldq(zmm24, zmm3, dword_ptr(rdx, 512)._1to16())); + TEST_INSTRUCTION("62616558624280" , vpunpckldq(zmm24, zmm3, dword_ptr(rdx, -512)._1to16())); + TEST_INSTRUCTION("626165586282FCFDFFFF" , vpunpckldq(zmm24, zmm3, dword_ptr(rdx, -516)._1to16())); + TEST_INSTRUCTION("62B1DD486CD9" , vpunpcklqdq(zmm3, zmm4, zmm17)); + TEST_INSTRUCTION("62B1DD496CD9" , k(k1).vpunpcklqdq(zmm3, zmm4, zmm17)); + TEST_INSTRUCTION("62B1DDC96CD9" , k(k1).z().vpunpcklqdq(zmm3, zmm4, zmm17)); + TEST_INSTRUCTION("62F1DD486C19" , vpunpcklqdq(zmm3, zmm4, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62B1DD486C9CF023010000" , vpunpcklqdq(zmm3, zmm4, zmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62F1DD586C19" , vpunpcklqdq(zmm3, zmm4, qword_ptr(rcx)._1to8())); + TEST_INSTRUCTION("62F1DD486C5A7F" , vpunpcklqdq(zmm3, zmm4, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62F1DD486C9A00200000" , vpunpcklqdq(zmm3, zmm4, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62F1DD486C5A80" , vpunpcklqdq(zmm3, zmm4, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62F1DD486C9AC0DFFFFF" , vpunpcklqdq(zmm3, zmm4, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62F1DD586C5A7F" , vpunpcklqdq(zmm3, zmm4, qword_ptr(rdx, 1016)._1to8())); + TEST_INSTRUCTION("62F1DD586C9A00040000" , vpunpcklqdq(zmm3, zmm4, qword_ptr(rdx, 1024)._1to8())); + TEST_INSTRUCTION("62F1DD586C5A80" , vpunpcklqdq(zmm3, zmm4, qword_ptr(rdx, -1024)._1to8())); + TEST_INSTRUCTION("62F1DD586C9AF8FBFFFF" , vpunpcklqdq(zmm3, zmm4, qword_ptr(rdx, -1032)._1to8())); + TEST_INSTRUCTION("62111D48EFC0" , vpxord(zmm8, zmm12, zmm24)); + TEST_INSTRUCTION("62111D4EEFC0" , k(k6).vpxord(zmm8, zmm12, zmm24)); + TEST_INSTRUCTION("62111DCEEFC0" , k(k6).z().vpxord(zmm8, zmm12, zmm24)); + TEST_INSTRUCTION("62711D48EF01" , vpxord(zmm8, zmm12, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62311D48EF84F023010000" , vpxord(zmm8, zmm12, zmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62711D58EF01" , vpxord(zmm8, zmm12, dword_ptr(rcx)._1to16())); + TEST_INSTRUCTION("62711D48EF427F" , vpxord(zmm8, zmm12, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62711D48EF8200200000" , vpxord(zmm8, zmm12, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62711D48EF4280" , vpxord(zmm8, zmm12, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62711D48EF82C0DFFFFF" , vpxord(zmm8, zmm12, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62711D58EF427F" , vpxord(zmm8, zmm12, dword_ptr(rdx, 508)._1to16())); + TEST_INSTRUCTION("62711D58EF8200020000" , vpxord(zmm8, zmm12, dword_ptr(rdx, 512)._1to16())); + TEST_INSTRUCTION("62711D58EF4280" , vpxord(zmm8, zmm12, dword_ptr(rdx, -512)._1to16())); + TEST_INSTRUCTION("62711D58EF82FCFDFFFF" , vpxord(zmm8, zmm12, dword_ptr(rdx, -516)._1to16())); + TEST_INSTRUCTION("62D1CD40EFFA" , vpxorq(zmm7, zmm22, zmm10)); + TEST_INSTRUCTION("62D1CD46EFFA" , k(k6).vpxorq(zmm7, zmm22, zmm10)); + TEST_INSTRUCTION("62D1CDC6EFFA" , k(k6).z().vpxorq(zmm7, zmm22, zmm10)); + TEST_INSTRUCTION("62F1CD40EF39" , vpxorq(zmm7, zmm22, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62B1CD40EFBCF023010000" , vpxorq(zmm7, zmm22, zmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62F1CD50EF39" , vpxorq(zmm7, zmm22, qword_ptr(rcx)._1to8())); + TEST_INSTRUCTION("62F1CD40EF7A7F" , vpxorq(zmm7, zmm22, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62F1CD40EFBA00200000" , vpxorq(zmm7, zmm22, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62F1CD40EF7A80" , vpxorq(zmm7, zmm22, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62F1CD40EFBAC0DFFFFF" , vpxorq(zmm7, zmm22, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62F1CD50EF7A7F" , vpxorq(zmm7, zmm22, qword_ptr(rdx, 1016)._1to8())); + TEST_INSTRUCTION("62F1CD50EFBA00040000" , vpxorq(zmm7, zmm22, qword_ptr(rdx, 1024)._1to8())); + TEST_INSTRUCTION("62F1CD50EF7A80" , vpxorq(zmm7, zmm22, qword_ptr(rdx, -1024)._1to8())); + TEST_INSTRUCTION("62F1CD50EFBAF8FBFFFF" , vpxorq(zmm7, zmm22, qword_ptr(rdx, -1032)._1to8())); + TEST_INSTRUCTION("6272FD484CEC" , vrcp14pd(zmm13, zmm4)); + TEST_INSTRUCTION("6272FD4D4CEC" , k(k5).vrcp14pd(zmm13, zmm4)); + TEST_INSTRUCTION("6272FDCD4CEC" , k(k5).z().vrcp14pd(zmm13, zmm4)); + TEST_INSTRUCTION("6272FD484C29" , vrcp14pd(zmm13, zmmword_ptr(rcx))); + TEST_INSTRUCTION("6232FD484CACF023010000" , vrcp14pd(zmm13, zmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("6272FD584C29" , vrcp14pd(zmm13, qword_ptr(rcx)._1to8())); + TEST_INSTRUCTION("6272FD484C6A7F" , vrcp14pd(zmm13, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("6272FD484CAA00200000" , vrcp14pd(zmm13, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("6272FD484C6A80" , vrcp14pd(zmm13, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("6272FD484CAAC0DFFFFF" , vrcp14pd(zmm13, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("6272FD584C6A7F" , vrcp14pd(zmm13, qword_ptr(rdx, 1016)._1to8())); + TEST_INSTRUCTION("6272FD584CAA00040000" , vrcp14pd(zmm13, qword_ptr(rdx, 1024)._1to8())); + TEST_INSTRUCTION("6272FD584C6A80" , vrcp14pd(zmm13, qword_ptr(rdx, -1024)._1to8())); + TEST_INSTRUCTION("6272FD584CAAF8FBFFFF" , vrcp14pd(zmm13, qword_ptr(rdx, -1032)._1to8())); + TEST_INSTRUCTION("62127D484CD1" , vrcp14ps(zmm10, zmm25)); + TEST_INSTRUCTION("62127D494CD1" , k(k1).vrcp14ps(zmm10, zmm25)); + TEST_INSTRUCTION("62127DC94CD1" , k(k1).z().vrcp14ps(zmm10, zmm25)); + TEST_INSTRUCTION("62727D484C11" , vrcp14ps(zmm10, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62327D484C94F023010000" , vrcp14ps(zmm10, zmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62727D584C11" , vrcp14ps(zmm10, dword_ptr(rcx)._1to16())); + TEST_INSTRUCTION("62727D484C527F" , vrcp14ps(zmm10, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62727D484C9200200000" , vrcp14ps(zmm10, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62727D484C5280" , vrcp14ps(zmm10, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62727D484C92C0DFFFFF" , vrcp14ps(zmm10, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62727D584C527F" , vrcp14ps(zmm10, dword_ptr(rdx, 508)._1to16())); + TEST_INSTRUCTION("62727D584C9200020000" , vrcp14ps(zmm10, dword_ptr(rdx, 512)._1to16())); + TEST_INSTRUCTION("62727D584C5280" , vrcp14ps(zmm10, dword_ptr(rdx, -512)._1to16())); + TEST_INSTRUCTION("62727D584C92FCFDFFFF" , vrcp14ps(zmm10, dword_ptr(rdx, -516)._1to16())); + TEST_INSTRUCTION("6252CD004DE6" , vrcp14sd(xmm12, xmm22, xmm14)); + TEST_INSTRUCTION("6252CD024DE6" , k(k2).vrcp14sd(xmm12, xmm22, xmm14)); + TEST_INSTRUCTION("6252CD824DE6" , k(k2).z().vrcp14sd(xmm12, xmm22, xmm14)); + TEST_INSTRUCTION("6272CD004D21" , vrcp14sd(xmm12, xmm22, qword_ptr(rcx))); + TEST_INSTRUCTION("6232CD004DA4F023010000" , vrcp14sd(xmm12, xmm22, qword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("6272CD004D627F" , vrcp14sd(xmm12, xmm22, qword_ptr(rdx, 1016))); + TEST_INSTRUCTION("6272CD004DA200040000" , vrcp14sd(xmm12, xmm22, qword_ptr(rdx, 1024))); + TEST_INSTRUCTION("6272CD004D6280" , vrcp14sd(xmm12, xmm22, qword_ptr(rdx, -1024))); + TEST_INSTRUCTION("6272CD004DA2F8FBFFFF" , vrcp14sd(xmm12, xmm22, qword_ptr(rdx, -1032))); + TEST_INSTRUCTION("62723D084DC3" , vrcp14ss(xmm8, xmm8, xmm3)); + TEST_INSTRUCTION("62723D0F4DC3" , k(k7).vrcp14ss(xmm8, xmm8, xmm3)); + TEST_INSTRUCTION("62723D8F4DC3" , k(k7).z().vrcp14ss(xmm8, xmm8, xmm3)); + TEST_INSTRUCTION("62723D084D01" , vrcp14ss(xmm8, xmm8, dword_ptr(rcx))); + TEST_INSTRUCTION("62323D084D84F023010000" , vrcp14ss(xmm8, xmm8, dword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62723D084D427F" , vrcp14ss(xmm8, xmm8, dword_ptr(rdx, 508))); + TEST_INSTRUCTION("62723D084D8200020000" , vrcp14ss(xmm8, xmm8, dword_ptr(rdx, 512))); + TEST_INSTRUCTION("62723D084D4280" , vrcp14ss(xmm8, xmm8, dword_ptr(rdx, -512))); + TEST_INSTRUCTION("62723D084D82FCFDFFFF" , vrcp14ss(xmm8, xmm8, dword_ptr(rdx, -516))); + TEST_INSTRUCTION("62C2FD484EDE" , vrsqrt14pd(zmm19, zmm14)); + TEST_INSTRUCTION("62C2FD494EDE" , k(k1).vrsqrt14pd(zmm19, zmm14)); + TEST_INSTRUCTION("62C2FDC94EDE" , k(k1).z().vrsqrt14pd(zmm19, zmm14)); + TEST_INSTRUCTION("62E2FD484E19" , vrsqrt14pd(zmm19, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62A2FD484E9CF023010000" , vrsqrt14pd(zmm19, zmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62E2FD584E19" , vrsqrt14pd(zmm19, qword_ptr(rcx)._1to8())); + TEST_INSTRUCTION("62E2FD484E5A7F" , vrsqrt14pd(zmm19, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62E2FD484E9A00200000" , vrsqrt14pd(zmm19, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62E2FD484E5A80" , vrsqrt14pd(zmm19, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62E2FD484E9AC0DFFFFF" , vrsqrt14pd(zmm19, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62E2FD584E5A7F" , vrsqrt14pd(zmm19, qword_ptr(rdx, 1016)._1to8())); + TEST_INSTRUCTION("62E2FD584E9A00040000" , vrsqrt14pd(zmm19, qword_ptr(rdx, 1024)._1to8())); + TEST_INSTRUCTION("62E2FD584E5A80" , vrsqrt14pd(zmm19, qword_ptr(rdx, -1024)._1to8())); + TEST_INSTRUCTION("62E2FD584E9AF8FBFFFF" , vrsqrt14pd(zmm19, qword_ptr(rdx, -1032)._1to8())); + TEST_INSTRUCTION("62C27D484EC1" , vrsqrt14ps(zmm16, zmm9)); + TEST_INSTRUCTION("62C27D4D4EC1" , k(k5).vrsqrt14ps(zmm16, zmm9)); + TEST_INSTRUCTION("62C27DCD4EC1" , k(k5).z().vrsqrt14ps(zmm16, zmm9)); + TEST_INSTRUCTION("62E27D484E01" , vrsqrt14ps(zmm16, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62A27D484E84F023010000" , vrsqrt14ps(zmm16, zmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62E27D584E01" , vrsqrt14ps(zmm16, dword_ptr(rcx)._1to16())); + TEST_INSTRUCTION("62E27D484E427F" , vrsqrt14ps(zmm16, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62E27D484E8200200000" , vrsqrt14ps(zmm16, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62E27D484E4280" , vrsqrt14ps(zmm16, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62E27D484E82C0DFFFFF" , vrsqrt14ps(zmm16, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62E27D584E427F" , vrsqrt14ps(zmm16, dword_ptr(rdx, 508)._1to16())); + TEST_INSTRUCTION("62E27D584E8200020000" , vrsqrt14ps(zmm16, dword_ptr(rdx, 512)._1to16())); + TEST_INSTRUCTION("62E27D584E4280" , vrsqrt14ps(zmm16, dword_ptr(rdx, -512)._1to16())); + TEST_INSTRUCTION("62E27D584E82FCFDFFFF" , vrsqrt14ps(zmm16, dword_ptr(rdx, -516)._1to16())); + TEST_INSTRUCTION("6242CD084FD2" , vrsqrt14sd(xmm26, xmm6, xmm10)); + TEST_INSTRUCTION("6242CD0D4FD2" , k(k5).vrsqrt14sd(xmm26, xmm6, xmm10)); + TEST_INSTRUCTION("6242CD8D4FD2" , k(k5).z().vrsqrt14sd(xmm26, xmm6, xmm10)); + TEST_INSTRUCTION("6262CD084F11" , vrsqrt14sd(xmm26, xmm6, qword_ptr(rcx))); + TEST_INSTRUCTION("6222CD084F94F023010000" , vrsqrt14sd(xmm26, xmm6, qword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("6262CD084F527F" , vrsqrt14sd(xmm26, xmm6, qword_ptr(rdx, 1016))); + TEST_INSTRUCTION("6262CD084F9200040000" , vrsqrt14sd(xmm26, xmm6, qword_ptr(rdx, 1024))); + TEST_INSTRUCTION("6262CD084F5280" , vrsqrt14sd(xmm26, xmm6, qword_ptr(rdx, -1024))); + TEST_INSTRUCTION("6262CD084F92F8FBFFFF" , vrsqrt14sd(xmm26, xmm6, qword_ptr(rdx, -1032))); + TEST_INSTRUCTION("62520D084FF1" , vrsqrt14ss(xmm14, xmm14, xmm9)); + TEST_INSTRUCTION("62520D094FF1" , k(k1).vrsqrt14ss(xmm14, xmm14, xmm9)); + TEST_INSTRUCTION("62520D894FF1" , k(k1).z().vrsqrt14ss(xmm14, xmm14, xmm9)); + TEST_INSTRUCTION("62720D084F31" , vrsqrt14ss(xmm14, xmm14, dword_ptr(rcx))); + TEST_INSTRUCTION("62320D084FB4F023010000" , vrsqrt14ss(xmm14, xmm14, dword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62720D084F727F" , vrsqrt14ss(xmm14, xmm14, dword_ptr(rdx, 508))); + TEST_INSTRUCTION("62720D084FB200020000" , vrsqrt14ss(xmm14, xmm14, dword_ptr(rdx, 512))); + TEST_INSTRUCTION("62720D084F7280" , vrsqrt14ss(xmm14, xmm14, dword_ptr(rdx, -512))); + TEST_INSTRUCTION("62720D084FB2FCFDFFFF" , vrsqrt14ss(xmm14, xmm14, dword_ptr(rdx, -516))); + TEST_INSTRUCTION("6221BD48C6E6AB" , vshufpd(zmm28, zmm8, zmm22, 171)); + TEST_INSTRUCTION("6221BD4AC6E6AB" , k(k2).vshufpd(zmm28, zmm8, zmm22, 171)); + TEST_INSTRUCTION("6221BDCAC6E6AB" , k(k2).z().vshufpd(zmm28, zmm8, zmm22, 171)); + TEST_INSTRUCTION("6221BD48C6E67B" , vshufpd(zmm28, zmm8, zmm22, 123)); + TEST_INSTRUCTION("6261BD48C6217B" , vshufpd(zmm28, zmm8, zmmword_ptr(rcx), 123)); + TEST_INSTRUCTION("6221BD48C6A4F0230100007B" , vshufpd(zmm28, zmm8, zmmword_ptr(rax, r14, 3, 291), 123)); + TEST_INSTRUCTION("6261BD58C6217B" , vshufpd(zmm28, zmm8, qword_ptr(rcx)._1to8(), 123)); + TEST_INSTRUCTION("6261BD48C6627F7B" , vshufpd(zmm28, zmm8, zmmword_ptr(rdx, 8128), 123)); + TEST_INSTRUCTION("6261BD48C6A2002000007B" , vshufpd(zmm28, zmm8, zmmword_ptr(rdx, 8192), 123)); + TEST_INSTRUCTION("6261BD48C662807B" , vshufpd(zmm28, zmm8, zmmword_ptr(rdx, -8192), 123)); + TEST_INSTRUCTION("6261BD48C6A2C0DFFFFF7B" , vshufpd(zmm28, zmm8, zmmword_ptr(rdx, -8256), 123)); + TEST_INSTRUCTION("6261BD58C6627F7B" , vshufpd(zmm28, zmm8, qword_ptr(rdx, 1016)._1to8(), 123)); + TEST_INSTRUCTION("6261BD58C6A2000400007B" , vshufpd(zmm28, zmm8, qword_ptr(rdx, 1024)._1to8(), 123)); + TEST_INSTRUCTION("6261BD58C662807B" , vshufpd(zmm28, zmm8, qword_ptr(rdx, -1024)._1to8(), 123)); + TEST_INSTRUCTION("6261BD58C6A2F8FBFFFF7B" , vshufpd(zmm28, zmm8, qword_ptr(rdx, -1032)._1to8(), 123)); + TEST_INSTRUCTION("62D14C48C6E9AB" , vshufps(zmm5, zmm6, zmm9, 171)); + TEST_INSTRUCTION("62D14C4EC6E9AB" , k(k6).vshufps(zmm5, zmm6, zmm9, 171)); + TEST_INSTRUCTION("62D14CCEC6E9AB" , k(k6).z().vshufps(zmm5, zmm6, zmm9, 171)); + TEST_INSTRUCTION("62D14C48C6E97B" , vshufps(zmm5, zmm6, zmm9, 123)); + TEST_INSTRUCTION("62F14C48C6297B" , vshufps(zmm5, zmm6, zmmword_ptr(rcx), 123)); + TEST_INSTRUCTION("62B14C48C6ACF0230100007B" , vshufps(zmm5, zmm6, zmmword_ptr(rax, r14, 3, 291), 123)); + TEST_INSTRUCTION("62F14C58C6297B" , vshufps(zmm5, zmm6, dword_ptr(rcx)._1to16(), 123)); + TEST_INSTRUCTION("62F14C48C66A7F7B" , vshufps(zmm5, zmm6, zmmword_ptr(rdx, 8128), 123)); + TEST_INSTRUCTION("62F14C48C6AA002000007B" , vshufps(zmm5, zmm6, zmmword_ptr(rdx, 8192), 123)); + TEST_INSTRUCTION("62F14C48C66A807B" , vshufps(zmm5, zmm6, zmmword_ptr(rdx, -8192), 123)); + TEST_INSTRUCTION("62F14C48C6AAC0DFFFFF7B" , vshufps(zmm5, zmm6, zmmword_ptr(rdx, -8256), 123)); + TEST_INSTRUCTION("62F14C58C66A7F7B" , vshufps(zmm5, zmm6, dword_ptr(rdx, 508)._1to16(), 123)); + TEST_INSTRUCTION("62F14C58C6AA000200007B" , vshufps(zmm5, zmm6, dword_ptr(rdx, 512)._1to16(), 123)); + TEST_INSTRUCTION("62F14C58C66A807B" , vshufps(zmm5, zmm6, dword_ptr(rdx, -512)._1to16(), 123)); + TEST_INSTRUCTION("62F14C58C6AAFCFDFFFF7B" , vshufps(zmm5, zmm6, dword_ptr(rdx, -516)._1to16(), 123)); + TEST_INSTRUCTION("62A1FD4851DB" , vsqrtpd(zmm19, zmm19)); + TEST_INSTRUCTION("62A1FD4D51DB" , k(k5).vsqrtpd(zmm19, zmm19)); + TEST_INSTRUCTION("62A1FDCD51DB" , k(k5).z().vsqrtpd(zmm19, zmm19)); + TEST_INSTRUCTION("62A1FD1851DB" , rn_sae().vsqrtpd(zmm19, zmm19)); + TEST_INSTRUCTION("62A1FD5851DB" , ru_sae().vsqrtpd(zmm19, zmm19)); + TEST_INSTRUCTION("62A1FD3851DB" , rd_sae().vsqrtpd(zmm19, zmm19)); + TEST_INSTRUCTION("62A1FD7851DB" , rz_sae().vsqrtpd(zmm19, zmm19)); + TEST_INSTRUCTION("62E1FD485119" , vsqrtpd(zmm19, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62A1FD48519CF023010000" , vsqrtpd(zmm19, zmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62E1FD585119" , vsqrtpd(zmm19, qword_ptr(rcx)._1to8())); + TEST_INSTRUCTION("62E1FD48515A7F" , vsqrtpd(zmm19, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62E1FD48519A00200000" , vsqrtpd(zmm19, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62E1FD48515A80" , vsqrtpd(zmm19, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62E1FD48519AC0DFFFFF" , vsqrtpd(zmm19, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62E1FD58515A7F" , vsqrtpd(zmm19, qword_ptr(rdx, 1016)._1to8())); + TEST_INSTRUCTION("62E1FD58519A00040000" , vsqrtpd(zmm19, qword_ptr(rdx, 1024)._1to8())); + TEST_INSTRUCTION("62E1FD58515A80" , vsqrtpd(zmm19, qword_ptr(rdx, -1024)._1to8())); + TEST_INSTRUCTION("62E1FD58519AF8FBFFFF" , vsqrtpd(zmm19, qword_ptr(rdx, -1032)._1to8())); + TEST_INSTRUCTION("62017C4851E5" , vsqrtps(zmm28, zmm29)); + TEST_INSTRUCTION("62017C4B51E5" , k(k3).vsqrtps(zmm28, zmm29)); + TEST_INSTRUCTION("62017CCB51E5" , k(k3).z().vsqrtps(zmm28, zmm29)); + TEST_INSTRUCTION("62017C1851E5" , rn_sae().vsqrtps(zmm28, zmm29)); + TEST_INSTRUCTION("62017C5851E5" , ru_sae().vsqrtps(zmm28, zmm29)); + TEST_INSTRUCTION("62017C3851E5" , rd_sae().vsqrtps(zmm28, zmm29)); + TEST_INSTRUCTION("62017C7851E5" , rz_sae().vsqrtps(zmm28, zmm29)); + TEST_INSTRUCTION("62617C485121" , vsqrtps(zmm28, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62217C4851A4F023010000" , vsqrtps(zmm28, zmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62617C585121" , vsqrtps(zmm28, dword_ptr(rcx)._1to16())); + TEST_INSTRUCTION("62617C4851627F" , vsqrtps(zmm28, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62617C4851A200200000" , vsqrtps(zmm28, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62617C48516280" , vsqrtps(zmm28, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62617C4851A2C0DFFFFF" , vsqrtps(zmm28, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62617C5851627F" , vsqrtps(zmm28, dword_ptr(rdx, 508)._1to16())); + TEST_INSTRUCTION("62617C5851A200020000" , vsqrtps(zmm28, dword_ptr(rdx, 512)._1to16())); + TEST_INSTRUCTION("62617C58516280" , vsqrtps(zmm28, dword_ptr(rdx, -512)._1to16())); + TEST_INSTRUCTION("62617C5851A2FCFDFFFF" , vsqrtps(zmm28, dword_ptr(rdx, -516)._1to16())); + TEST_INSTRUCTION("C4C16B51F4" , vsqrtsd(xmm6, xmm2, xmm12)); + TEST_INSTRUCTION("62D1EF0F51F4" , k(k7).vsqrtsd(xmm6, xmm2, xmm12)); + TEST_INSTRUCTION("62D1EF8F51F4" , k(k7).z().vsqrtsd(xmm6, xmm2, xmm12)); + TEST_INSTRUCTION("62D1EF1851F4" , rn_sae().vsqrtsd(xmm6, xmm2, xmm12)); + TEST_INSTRUCTION("62D1EF5851F4" , ru_sae().vsqrtsd(xmm6, xmm2, xmm12)); + TEST_INSTRUCTION("62D1EF3851F4" , rd_sae().vsqrtsd(xmm6, xmm2, xmm12)); + TEST_INSTRUCTION("62D1EF7851F4" , rz_sae().vsqrtsd(xmm6, xmm2, xmm12)); + TEST_INSTRUCTION("C5EB5131" , vsqrtsd(xmm6, xmm2, qword_ptr(rcx))); + TEST_INSTRUCTION("C4A16B51B4F023010000" , vsqrtsd(xmm6, xmm2, qword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("C5EB51B2F8030000" , vsqrtsd(xmm6, xmm2, qword_ptr(rdx, 1016))); + TEST_INSTRUCTION("C5EB51B200040000" , vsqrtsd(xmm6, xmm2, qword_ptr(rdx, 1024))); + TEST_INSTRUCTION("C5EB51B200FCFFFF" , vsqrtsd(xmm6, xmm2, qword_ptr(rdx, -1024))); + TEST_INSTRUCTION("C5EB51B2F8FBFFFF" , vsqrtsd(xmm6, xmm2, qword_ptr(rdx, -1032))); + TEST_INSTRUCTION("62C1660051F0" , vsqrtss(xmm22, xmm19, xmm8)); + TEST_INSTRUCTION("62C1660151F0" , k(k1).vsqrtss(xmm22, xmm19, xmm8)); + TEST_INSTRUCTION("62C1668151F0" , k(k1).z().vsqrtss(xmm22, xmm19, xmm8)); + TEST_INSTRUCTION("62C1661051F0" , rn_sae().vsqrtss(xmm22, xmm19, xmm8)); + TEST_INSTRUCTION("62C1665051F0" , ru_sae().vsqrtss(xmm22, xmm19, xmm8)); + TEST_INSTRUCTION("62C1663051F0" , rd_sae().vsqrtss(xmm22, xmm19, xmm8)); + TEST_INSTRUCTION("62C1667051F0" , rz_sae().vsqrtss(xmm22, xmm19, xmm8)); + TEST_INSTRUCTION("62E166005131" , vsqrtss(xmm22, xmm19, dword_ptr(rcx))); + TEST_INSTRUCTION("62A1660051B4F023010000" , vsqrtss(xmm22, xmm19, dword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62E1660051727F" , vsqrtss(xmm22, xmm19, dword_ptr(rdx, 508))); + TEST_INSTRUCTION("62E1660051B200020000" , vsqrtss(xmm22, xmm19, dword_ptr(rdx, 512))); + TEST_INSTRUCTION("62E16600517280" , vsqrtss(xmm22, xmm19, dword_ptr(rdx, -512))); + TEST_INSTRUCTION("62E1660051B2FCFDFFFF" , vsqrtss(xmm22, xmm19, dword_ptr(rdx, -516))); + TEST_INSTRUCTION("62519D485CC9" , vsubpd(zmm9, zmm12, zmm9)); + TEST_INSTRUCTION("62519D4F5CC9" , k(k7).vsubpd(zmm9, zmm12, zmm9)); + TEST_INSTRUCTION("62519DCF5CC9" , k(k7).z().vsubpd(zmm9, zmm12, zmm9)); + TEST_INSTRUCTION("62519D185CC9" , rn_sae().vsubpd(zmm9, zmm12, zmm9)); + TEST_INSTRUCTION("62519D585CC9" , ru_sae().vsubpd(zmm9, zmm12, zmm9)); + TEST_INSTRUCTION("62519D385CC9" , rd_sae().vsubpd(zmm9, zmm12, zmm9)); + TEST_INSTRUCTION("62519D785CC9" , rz_sae().vsubpd(zmm9, zmm12, zmm9)); + TEST_INSTRUCTION("62719D485C09" , vsubpd(zmm9, zmm12, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62319D485C8CF023010000" , vsubpd(zmm9, zmm12, zmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62719D585C09" , vsubpd(zmm9, zmm12, qword_ptr(rcx)._1to8())); + TEST_INSTRUCTION("62719D485C4A7F" , vsubpd(zmm9, zmm12, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62719D485C8A00200000" , vsubpd(zmm9, zmm12, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62719D485C4A80" , vsubpd(zmm9, zmm12, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62719D485C8AC0DFFFFF" , vsubpd(zmm9, zmm12, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62719D585C4A7F" , vsubpd(zmm9, zmm12, qword_ptr(rdx, 1016)._1to8())); + TEST_INSTRUCTION("62719D585C8A00040000" , vsubpd(zmm9, zmm12, qword_ptr(rdx, 1024)._1to8())); + TEST_INSTRUCTION("62719D585C4A80" , vsubpd(zmm9, zmm12, qword_ptr(rdx, -1024)._1to8())); + TEST_INSTRUCTION("62719D585C8AF8FBFFFF" , vsubpd(zmm9, zmm12, qword_ptr(rdx, -1032)._1to8())); + TEST_INSTRUCTION("623124405CF5" , vsubps(zmm14, zmm27, zmm21)); + TEST_INSTRUCTION("623124455CF5" , k(k5).vsubps(zmm14, zmm27, zmm21)); + TEST_INSTRUCTION("623124C55CF5" , k(k5).z().vsubps(zmm14, zmm27, zmm21)); + TEST_INSTRUCTION("623124105CF5" , rn_sae().vsubps(zmm14, zmm27, zmm21)); + TEST_INSTRUCTION("623124505CF5" , ru_sae().vsubps(zmm14, zmm27, zmm21)); + TEST_INSTRUCTION("623124305CF5" , rd_sae().vsubps(zmm14, zmm27, zmm21)); + TEST_INSTRUCTION("623124705CF5" , rz_sae().vsubps(zmm14, zmm27, zmm21)); + TEST_INSTRUCTION("627124405C31" , vsubps(zmm14, zmm27, zmmword_ptr(rcx))); + TEST_INSTRUCTION("623124405CB4F023010000" , vsubps(zmm14, zmm27, zmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("627124505C31" , vsubps(zmm14, zmm27, dword_ptr(rcx)._1to16())); + TEST_INSTRUCTION("627124405C727F" , vsubps(zmm14, zmm27, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("627124405CB200200000" , vsubps(zmm14, zmm27, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("627124405C7280" , vsubps(zmm14, zmm27, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("627124405CB2C0DFFFFF" , vsubps(zmm14, zmm27, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("627124505C727F" , vsubps(zmm14, zmm27, dword_ptr(rdx, 508)._1to16())); + TEST_INSTRUCTION("627124505CB200020000" , vsubps(zmm14, zmm27, dword_ptr(rdx, 512)._1to16())); + TEST_INSTRUCTION("627124505C7280" , vsubps(zmm14, zmm27, dword_ptr(rdx, -512)._1to16())); + TEST_INSTRUCTION("627124505CB2FCFDFFFF" , vsubps(zmm14, zmm27, dword_ptr(rdx, -516)._1to16())); + TEST_INSTRUCTION("62C1A7005CE7" , vsubsd(xmm20, xmm27, xmm15)); + TEST_INSTRUCTION("62C1A7055CE7" , k(k5).vsubsd(xmm20, xmm27, xmm15)); + TEST_INSTRUCTION("62C1A7855CE7" , k(k5).z().vsubsd(xmm20, xmm27, xmm15)); + TEST_INSTRUCTION("62C1A7105CE7" , rn_sae().vsubsd(xmm20, xmm27, xmm15)); + TEST_INSTRUCTION("62C1A7505CE7" , ru_sae().vsubsd(xmm20, xmm27, xmm15)); + TEST_INSTRUCTION("62C1A7305CE7" , rd_sae().vsubsd(xmm20, xmm27, xmm15)); + TEST_INSTRUCTION("62C1A7705CE7" , rz_sae().vsubsd(xmm20, xmm27, xmm15)); + TEST_INSTRUCTION("62E1A7005C21" , vsubsd(xmm20, xmm27, qword_ptr(rcx))); + TEST_INSTRUCTION("62A1A7005CA4F023010000" , vsubsd(xmm20, xmm27, qword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62E1A7005C627F" , vsubsd(xmm20, xmm27, qword_ptr(rdx, 1016))); + TEST_INSTRUCTION("62E1A7005CA200040000" , vsubsd(xmm20, xmm27, qword_ptr(rdx, 1024))); + TEST_INSTRUCTION("62E1A7005C6280" , vsubsd(xmm20, xmm27, qword_ptr(rdx, -1024))); + TEST_INSTRUCTION("62E1A7005CA2F8FBFFFF" , vsubsd(xmm20, xmm27, qword_ptr(rdx, -1032))); + TEST_INSTRUCTION("62D136005CE9" , vsubss(xmm5, xmm25, xmm9)); + TEST_INSTRUCTION("62D136035CE9" , k(k3).vsubss(xmm5, xmm25, xmm9)); + TEST_INSTRUCTION("62D136835CE9" , k(k3).z().vsubss(xmm5, xmm25, xmm9)); + TEST_INSTRUCTION("62D136105CE9" , rn_sae().vsubss(xmm5, xmm25, xmm9)); + TEST_INSTRUCTION("62D136505CE9" , ru_sae().vsubss(xmm5, xmm25, xmm9)); + TEST_INSTRUCTION("62D136305CE9" , rd_sae().vsubss(xmm5, xmm25, xmm9)); + TEST_INSTRUCTION("62D136705CE9" , rz_sae().vsubss(xmm5, xmm25, xmm9)); + TEST_INSTRUCTION("62F136005C29" , vsubss(xmm5, xmm25, dword_ptr(rcx))); + TEST_INSTRUCTION("62B136005CACF023010000" , vsubss(xmm5, xmm25, dword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62F136005C6A7F" , vsubss(xmm5, xmm25, dword_ptr(rdx, 508))); + TEST_INSTRUCTION("62F136005CAA00020000" , vsubss(xmm5, xmm25, dword_ptr(rdx, 512))); + TEST_INSTRUCTION("62F136005C6A80" , vsubss(xmm5, xmm25, dword_ptr(rdx, -512))); + TEST_INSTRUCTION("62F136005CAAFCFDFFFF" , vsubss(xmm5, xmm25, dword_ptr(rdx, -516))); + TEST_INSTRUCTION("C441792EDA" , vucomisd(xmm11, xmm10)); + TEST_INSTRUCTION("6251FD182EDA" , sae().vucomisd(xmm11, xmm10)); + TEST_INSTRUCTION("C5792E19" , vucomisd(xmm11, qword_ptr(rcx))); + TEST_INSTRUCTION("C421792E9CF023010000" , vucomisd(xmm11, qword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("C5792E9AF8030000" , vucomisd(xmm11, qword_ptr(rdx, 1016))); + TEST_INSTRUCTION("C5792E9A00040000" , vucomisd(xmm11, qword_ptr(rdx, 1024))); + TEST_INSTRUCTION("C5792E9A00FCFFFF" , vucomisd(xmm11, qword_ptr(rdx, -1024))); + TEST_INSTRUCTION("C5792E9AF8FBFFFF" , vucomisd(xmm11, qword_ptr(rdx, -1032))); + TEST_INSTRUCTION("62C17C082EF3" , vucomiss(xmm22, xmm11)); + TEST_INSTRUCTION("62C17C182EF3" , sae().vucomiss(xmm22, xmm11)); + TEST_INSTRUCTION("62E17C082E31" , vucomiss(xmm22, dword_ptr(rcx))); + TEST_INSTRUCTION("62A17C082EB4F023010000" , vucomiss(xmm22, dword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62E17C082E727F" , vucomiss(xmm22, dword_ptr(rdx, 508))); + TEST_INSTRUCTION("62E17C082EB200020000" , vucomiss(xmm22, dword_ptr(rdx, 512))); + TEST_INSTRUCTION("62E17C082E7280" , vucomiss(xmm22, dword_ptr(rdx, -512))); + TEST_INSTRUCTION("62E17C082EB2FCFDFFFF" , vucomiss(xmm22, dword_ptr(rdx, -516))); + TEST_INSTRUCTION("6201E54015CA" , vunpckhpd(zmm25, zmm19, zmm26)); + TEST_INSTRUCTION("6201E54515CA" , k(k5).vunpckhpd(zmm25, zmm19, zmm26)); + TEST_INSTRUCTION("6201E5C515CA" , k(k5).z().vunpckhpd(zmm25, zmm19, zmm26)); + TEST_INSTRUCTION("6261E5401509" , vunpckhpd(zmm25, zmm19, zmmword_ptr(rcx))); + TEST_INSTRUCTION("6221E540158CF023010000" , vunpckhpd(zmm25, zmm19, zmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("6261E5501509" , vunpckhpd(zmm25, zmm19, qword_ptr(rcx)._1to8())); + TEST_INSTRUCTION("6261E540154A7F" , vunpckhpd(zmm25, zmm19, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("6261E540158A00200000" , vunpckhpd(zmm25, zmm19, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("6261E540154A80" , vunpckhpd(zmm25, zmm19, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("6261E540158AC0DFFFFF" , vunpckhpd(zmm25, zmm19, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("6261E550154A7F" , vunpckhpd(zmm25, zmm19, qword_ptr(rdx, 1016)._1to8())); + TEST_INSTRUCTION("6261E550158A00040000" , vunpckhpd(zmm25, zmm19, qword_ptr(rdx, 1024)._1to8())); + TEST_INSTRUCTION("6261E550154A80" , vunpckhpd(zmm25, zmm19, qword_ptr(rdx, -1024)._1to8())); + TEST_INSTRUCTION("6261E550158AF8FBFFFF" , vunpckhpd(zmm25, zmm19, qword_ptr(rdx, -1032)._1to8())); + TEST_INSTRUCTION("62B10C4815E8" , vunpckhps(zmm5, zmm14, zmm16)); + TEST_INSTRUCTION("62B10C4E15E8" , k(k6).vunpckhps(zmm5, zmm14, zmm16)); + TEST_INSTRUCTION("62B10CCE15E8" , k(k6).z().vunpckhps(zmm5, zmm14, zmm16)); + TEST_INSTRUCTION("62F10C481529" , vunpckhps(zmm5, zmm14, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62B10C4815ACF023010000" , vunpckhps(zmm5, zmm14, zmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62F10C581529" , vunpckhps(zmm5, zmm14, dword_ptr(rcx)._1to16())); + TEST_INSTRUCTION("62F10C48156A7F" , vunpckhps(zmm5, zmm14, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62F10C4815AA00200000" , vunpckhps(zmm5, zmm14, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62F10C48156A80" , vunpckhps(zmm5, zmm14, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62F10C4815AAC0DFFFFF" , vunpckhps(zmm5, zmm14, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62F10C58156A7F" , vunpckhps(zmm5, zmm14, dword_ptr(rdx, 508)._1to16())); + TEST_INSTRUCTION("62F10C5815AA00020000" , vunpckhps(zmm5, zmm14, dword_ptr(rdx, 512)._1to16())); + TEST_INSTRUCTION("62F10C58156A80" , vunpckhps(zmm5, zmm14, dword_ptr(rdx, -512)._1to16())); + TEST_INSTRUCTION("62F10C5815AAFCFDFFFF" , vunpckhps(zmm5, zmm14, dword_ptr(rdx, -516)._1to16())); + TEST_INSTRUCTION("62A1954014D5" , vunpcklpd(zmm18, zmm29, zmm21)); + TEST_INSTRUCTION("62A1954614D5" , k(k6).vunpcklpd(zmm18, zmm29, zmm21)); + TEST_INSTRUCTION("62A195C614D5" , k(k6).z().vunpcklpd(zmm18, zmm29, zmm21)); + TEST_INSTRUCTION("62E195401411" , vunpcklpd(zmm18, zmm29, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62A195401494F023010000" , vunpcklpd(zmm18, zmm29, zmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62E195501411" , vunpcklpd(zmm18, zmm29, qword_ptr(rcx)._1to8())); + TEST_INSTRUCTION("62E1954014527F" , vunpcklpd(zmm18, zmm29, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62E19540149200200000" , vunpcklpd(zmm18, zmm29, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62E19540145280" , vunpcklpd(zmm18, zmm29, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62E195401492C0DFFFFF" , vunpcklpd(zmm18, zmm29, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62E1955014527F" , vunpcklpd(zmm18, zmm29, qword_ptr(rdx, 1016)._1to8())); + TEST_INSTRUCTION("62E19550149200040000" , vunpcklpd(zmm18, zmm29, qword_ptr(rdx, 1024)._1to8())); + TEST_INSTRUCTION("62E19550145280" , vunpcklpd(zmm18, zmm29, qword_ptr(rdx, -1024)._1to8())); + TEST_INSTRUCTION("62E195501492F8FBFFFF" , vunpcklpd(zmm18, zmm29, qword_ptr(rdx, -1032)._1to8())); + TEST_INSTRUCTION("62F1644814CA" , vunpcklps(zmm1, zmm3, zmm2)); + TEST_INSTRUCTION("62F1644B14CA" , k(k3).vunpcklps(zmm1, zmm3, zmm2)); + TEST_INSTRUCTION("62F164CB14CA" , k(k3).z().vunpcklps(zmm1, zmm3, zmm2)); + TEST_INSTRUCTION("62F164481409" , vunpcklps(zmm1, zmm3, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62B16448148CF023010000" , vunpcklps(zmm1, zmm3, zmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62F164581409" , vunpcklps(zmm1, zmm3, dword_ptr(rcx)._1to16())); + TEST_INSTRUCTION("62F16448144A7F" , vunpcklps(zmm1, zmm3, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62F16448148A00200000" , vunpcklps(zmm1, zmm3, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62F16448144A80" , vunpcklps(zmm1, zmm3, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62F16448148AC0DFFFFF" , vunpcklps(zmm1, zmm3, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62F16458144A7F" , vunpcklps(zmm1, zmm3, dword_ptr(rdx, 508)._1to16())); + TEST_INSTRUCTION("62F16458148A00020000" , vunpcklps(zmm1, zmm3, dword_ptr(rdx, 512)._1to16())); + TEST_INSTRUCTION("62F16458144A80" , vunpcklps(zmm1, zmm3, dword_ptr(rdx, -512)._1to16())); + TEST_INSTRUCTION("62F16458148AFCFDFFFF" , vunpcklps(zmm1, zmm3, dword_ptr(rdx, -516)._1to16())); + TEST_INSTRUCTION("62330D4825E4AB" , vpternlogd(zmm12, zmm14, zmm20, 171)); + TEST_INSTRUCTION("62330D4F25E4AB" , k(k7).vpternlogd(zmm12, zmm14, zmm20, 171)); + TEST_INSTRUCTION("62330DCF25E4AB" , k(k7).z().vpternlogd(zmm12, zmm14, zmm20, 171)); + TEST_INSTRUCTION("62330D4825E47B" , vpternlogd(zmm12, zmm14, zmm20, 123)); + TEST_INSTRUCTION("62730D4825217B" , vpternlogd(zmm12, zmm14, zmmword_ptr(rcx), 123)); + TEST_INSTRUCTION("62330D4825A4F0230100007B" , vpternlogd(zmm12, zmm14, zmmword_ptr(rax, r14, 3, 291), 123)); + TEST_INSTRUCTION("62730D5825217B" , vpternlogd(zmm12, zmm14, dword_ptr(rcx)._1to16(), 123)); + TEST_INSTRUCTION("62730D4825627F7B" , vpternlogd(zmm12, zmm14, zmmword_ptr(rdx, 8128), 123)); + TEST_INSTRUCTION("62730D4825A2002000007B" , vpternlogd(zmm12, zmm14, zmmword_ptr(rdx, 8192), 123)); + TEST_INSTRUCTION("62730D482562807B" , vpternlogd(zmm12, zmm14, zmmword_ptr(rdx, -8192), 123)); + TEST_INSTRUCTION("62730D4825A2C0DFFFFF7B" , vpternlogd(zmm12, zmm14, zmmword_ptr(rdx, -8256), 123)); + TEST_INSTRUCTION("62730D5825627F7B" , vpternlogd(zmm12, zmm14, dword_ptr(rdx, 508)._1to16(), 123)); + TEST_INSTRUCTION("62730D5825A2000200007B" , vpternlogd(zmm12, zmm14, dword_ptr(rdx, 512)._1to16(), 123)); + TEST_INSTRUCTION("62730D582562807B" , vpternlogd(zmm12, zmm14, dword_ptr(rdx, -512)._1to16(), 123)); + TEST_INSTRUCTION("62730D5825A2FCFDFFFF7B" , vpternlogd(zmm12, zmm14, dword_ptr(rdx, -516)._1to16(), 123)); + TEST_INSTRUCTION("6233ED4825FDAB" , vpternlogq(zmm15, zmm2, zmm21, 171)); + TEST_INSTRUCTION("6233ED4B25FDAB" , k(k3).vpternlogq(zmm15, zmm2, zmm21, 171)); + TEST_INSTRUCTION("6233EDCB25FDAB" , k(k3).z().vpternlogq(zmm15, zmm2, zmm21, 171)); + TEST_INSTRUCTION("6233ED4825FD7B" , vpternlogq(zmm15, zmm2, zmm21, 123)); + TEST_INSTRUCTION("6273ED4825397B" , vpternlogq(zmm15, zmm2, zmmword_ptr(rcx), 123)); + TEST_INSTRUCTION("6233ED4825BCF0230100007B" , vpternlogq(zmm15, zmm2, zmmword_ptr(rax, r14, 3, 291), 123)); + TEST_INSTRUCTION("6273ED5825397B" , vpternlogq(zmm15, zmm2, qword_ptr(rcx)._1to8(), 123)); + TEST_INSTRUCTION("6273ED48257A7F7B" , vpternlogq(zmm15, zmm2, zmmword_ptr(rdx, 8128), 123)); + TEST_INSTRUCTION("6273ED4825BA002000007B" , vpternlogq(zmm15, zmm2, zmmword_ptr(rdx, 8192), 123)); + TEST_INSTRUCTION("6273ED48257A807B" , vpternlogq(zmm15, zmm2, zmmword_ptr(rdx, -8192), 123)); + TEST_INSTRUCTION("6273ED4825BAC0DFFFFF7B" , vpternlogq(zmm15, zmm2, zmmword_ptr(rdx, -8256), 123)); + TEST_INSTRUCTION("6273ED58257A7F7B" , vpternlogq(zmm15, zmm2, qword_ptr(rdx, 1016)._1to8(), 123)); + TEST_INSTRUCTION("6273ED5825BA000400007B" , vpternlogq(zmm15, zmm2, qword_ptr(rdx, 1024)._1to8(), 123)); + TEST_INSTRUCTION("6273ED58257A807B" , vpternlogq(zmm15, zmm2, qword_ptr(rdx, -1024)._1to8(), 123)); + TEST_INSTRUCTION("6273ED5825BAF8FBFFFF7B" , vpternlogq(zmm15, zmm2, qword_ptr(rdx, -1032)._1to8(), 123)); + TEST_INSTRUCTION("62F27E4832D3" , vpmovqb(xmm3, zmm2)); + TEST_INSTRUCTION("62F27E4932D3" , k(k1).vpmovqb(xmm3, zmm2)); + TEST_INSTRUCTION("62F27EC932D3" , k(k1).z().vpmovqb(xmm3, zmm2)); + TEST_INSTRUCTION("62027E4822EE" , vpmovsqb(xmm30, zmm29)); + TEST_INSTRUCTION("62027E4D22EE" , k(k5).vpmovsqb(xmm30, zmm29)); + TEST_INSTRUCTION("62027ECD22EE" , k(k5).z().vpmovsqb(xmm30, zmm29)); + TEST_INSTRUCTION("62027E4812E0" , vpmovusqb(xmm24, zmm28)); + TEST_INSTRUCTION("62027E4F12E0" , k(k7).vpmovusqb(xmm24, zmm28)); + TEST_INSTRUCTION("62027ECF12E0" , k(k7).z().vpmovusqb(xmm24, zmm28)); + TEST_INSTRUCTION("62E27E4834D6" , vpmovqw(xmm6, zmm18)); + TEST_INSTRUCTION("62E27E4934D6" , k(k1).vpmovqw(xmm6, zmm18)); + TEST_INSTRUCTION("62E27EC934D6" , k(k1).z().vpmovqw(xmm6, zmm18)); + TEST_INSTRUCTION("62827E4824DB" , vpmovsqw(xmm27, zmm19)); + TEST_INSTRUCTION("62827E4E24DB" , k(k6).vpmovsqw(xmm27, zmm19)); + TEST_INSTRUCTION("62827ECE24DB" , k(k6).z().vpmovsqw(xmm27, zmm19)); + TEST_INSTRUCTION("62127E4814D4" , vpmovusqw(xmm28, zmm10)); + TEST_INSTRUCTION("62127E4F14D4" , k(k7).vpmovusqw(xmm28, zmm10)); + TEST_INSTRUCTION("62127ECF14D4" , k(k7).z().vpmovusqw(xmm28, zmm10)); + TEST_INSTRUCTION("62627E4835CE" , vpmovqd(ymm6, zmm25)); + TEST_INSTRUCTION("62627E4D35CE" , k(k5).vpmovqd(ymm6, zmm25)); + TEST_INSTRUCTION("62627ECD35CE" , k(k5).z().vpmovqd(ymm6, zmm25)); + TEST_INSTRUCTION("62D27E4825D7" , vpmovsqd(ymm15, zmm2)); + TEST_INSTRUCTION("62D27E4A25D7" , k(k2).vpmovsqd(ymm15, zmm2)); + TEST_INSTRUCTION("62D27ECA25D7" , k(k2).z().vpmovsqd(ymm15, zmm2)); + TEST_INSTRUCTION("62D27E4815E0" , vpmovusqd(ymm8, zmm4)); + TEST_INSTRUCTION("62D27E4C15E0" , k(k4).vpmovusqd(ymm8, zmm4)); + TEST_INSTRUCTION("62D27ECC15E0" , k(k4).z().vpmovusqd(ymm8, zmm4)); + TEST_INSTRUCTION("62F27E4831EA" , vpmovdb(xmm2, zmm5)); + TEST_INSTRUCTION("62F27E4D31EA" , k(k5).vpmovdb(xmm2, zmm5)); + TEST_INSTRUCTION("62F27ECD31EA" , k(k5).z().vpmovdb(xmm2, zmm5)); + TEST_INSTRUCTION("62B27E4821D5" , vpmovsdb(xmm21, zmm2)); + TEST_INSTRUCTION("62B27E4C21D5" , k(k4).vpmovsdb(xmm21, zmm2)); + TEST_INSTRUCTION("62B27ECC21D5" , k(k4).z().vpmovsdb(xmm21, zmm2)); + TEST_INSTRUCTION("62B27E4811D4" , vpmovusdb(xmm20, zmm2)); + TEST_INSTRUCTION("62B27E4B11D4" , k(k3).vpmovusdb(xmm20, zmm2)); + TEST_INSTRUCTION("62B27ECB11D4" , k(k3).z().vpmovusdb(xmm20, zmm2)); + TEST_INSTRUCTION("62227E4833EE" , vpmovdw(ymm22, zmm29)); + TEST_INSTRUCTION("62227E4D33EE" , k(k5).vpmovdw(ymm22, zmm29)); + TEST_INSTRUCTION("62227ECD33EE" , k(k5).z().vpmovdw(ymm22, zmm29)); + TEST_INSTRUCTION("62127E4823F1" , vpmovsdw(ymm25, zmm14)); + TEST_INSTRUCTION("62127E4C23F1" , k(k4).vpmovsdw(ymm25, zmm14)); + TEST_INSTRUCTION("62127ECC23F1" , k(k4).z().vpmovsdw(ymm25, zmm14)); + TEST_INSTRUCTION("62D27E4813F8" , vpmovusdw(ymm8, zmm7)); + TEST_INSTRUCTION("62D27E4913F8" , k(k1).vpmovusdw(ymm8, zmm7)); + TEST_INSTRUCTION("62D27EC913F8" , k(k1).z().vpmovusdw(ymm8, zmm7)); + TEST_INSTRUCTION("62F33D4023F3AB" , vshuff32x4(zmm6, zmm24, zmm3, 171)); + TEST_INSTRUCTION("62F33D4223F3AB" , k(k2).vshuff32x4(zmm6, zmm24, zmm3, 171)); + TEST_INSTRUCTION("62F33DC223F3AB" , k(k2).z().vshuff32x4(zmm6, zmm24, zmm3, 171)); + TEST_INSTRUCTION("62F33D4023F37B" , vshuff32x4(zmm6, zmm24, zmm3, 123)); + TEST_INSTRUCTION("62F33D4023317B" , vshuff32x4(zmm6, zmm24, zmmword_ptr(rcx), 123)); + TEST_INSTRUCTION("62B33D4023B4F0230100007B" , vshuff32x4(zmm6, zmm24, zmmword_ptr(rax, r14, 3, 291), 123)); + TEST_INSTRUCTION("62F33D5023317B" , vshuff32x4(zmm6, zmm24, dword_ptr(rcx)._1to16(), 123)); + TEST_INSTRUCTION("62F33D4023727F7B" , vshuff32x4(zmm6, zmm24, zmmword_ptr(rdx, 8128), 123)); + TEST_INSTRUCTION("62F33D4023B2002000007B" , vshuff32x4(zmm6, zmm24, zmmword_ptr(rdx, 8192), 123)); + TEST_INSTRUCTION("62F33D402372807B" , vshuff32x4(zmm6, zmm24, zmmword_ptr(rdx, -8192), 123)); + TEST_INSTRUCTION("62F33D4023B2C0DFFFFF7B" , vshuff32x4(zmm6, zmm24, zmmword_ptr(rdx, -8256), 123)); + TEST_INSTRUCTION("62F33D5023727F7B" , vshuff32x4(zmm6, zmm24, dword_ptr(rdx, 508)._1to16(), 123)); + TEST_INSTRUCTION("62F33D5023B2000200007B" , vshuff32x4(zmm6, zmm24, dword_ptr(rdx, 512)._1to16(), 123)); + TEST_INSTRUCTION("62F33D502372807B" , vshuff32x4(zmm6, zmm24, dword_ptr(rdx, -512)._1to16(), 123)); + TEST_INSTRUCTION("62F33D5023B2FCFDFFFF7B" , vshuff32x4(zmm6, zmm24, dword_ptr(rdx, -516)._1to16(), 123)); + TEST_INSTRUCTION("6253B54023FBAB" , vshuff64x2(zmm15, zmm25, zmm11, 171)); + TEST_INSTRUCTION("6253B54223FBAB" , k(k2).vshuff64x2(zmm15, zmm25, zmm11, 171)); + TEST_INSTRUCTION("6253B5C223FBAB" , k(k2).z().vshuff64x2(zmm15, zmm25, zmm11, 171)); + TEST_INSTRUCTION("6253B54023FB7B" , vshuff64x2(zmm15, zmm25, zmm11, 123)); + TEST_INSTRUCTION("6273B54023397B" , vshuff64x2(zmm15, zmm25, zmmword_ptr(rcx), 123)); + TEST_INSTRUCTION("6233B54023BCF0230100007B" , vshuff64x2(zmm15, zmm25, zmmword_ptr(rax, r14, 3, 291), 123)); + TEST_INSTRUCTION("6273B55023397B" , vshuff64x2(zmm15, zmm25, qword_ptr(rcx)._1to8(), 123)); + TEST_INSTRUCTION("6273B540237A7F7B" , vshuff64x2(zmm15, zmm25, zmmword_ptr(rdx, 8128), 123)); + TEST_INSTRUCTION("6273B54023BA002000007B" , vshuff64x2(zmm15, zmm25, zmmword_ptr(rdx, 8192), 123)); + TEST_INSTRUCTION("6273B540237A807B" , vshuff64x2(zmm15, zmm25, zmmword_ptr(rdx, -8192), 123)); + TEST_INSTRUCTION("6273B54023BAC0DFFFFF7B" , vshuff64x2(zmm15, zmm25, zmmword_ptr(rdx, -8256), 123)); + TEST_INSTRUCTION("6273B550237A7F7B" , vshuff64x2(zmm15, zmm25, qword_ptr(rdx, 1016)._1to8(), 123)); + TEST_INSTRUCTION("6273B55023BA000400007B" , vshuff64x2(zmm15, zmm25, qword_ptr(rdx, 1024)._1to8(), 123)); + TEST_INSTRUCTION("6273B550237A807B" , vshuff64x2(zmm15, zmm25, qword_ptr(rdx, -1024)._1to8(), 123)); + TEST_INSTRUCTION("6273B55023BAF8FBFFFF7B" , vshuff64x2(zmm15, zmm25, qword_ptr(rdx, -1032)._1to8(), 123)); + TEST_INSTRUCTION("62931D4043C9AB" , vshufi32x4(zmm1, zmm28, zmm25, 171)); + TEST_INSTRUCTION("62931D4443C9AB" , k(k4).vshufi32x4(zmm1, zmm28, zmm25, 171)); + TEST_INSTRUCTION("62931DC443C9AB" , k(k4).z().vshufi32x4(zmm1, zmm28, zmm25, 171)); + TEST_INSTRUCTION("62931D4043C97B" , vshufi32x4(zmm1, zmm28, zmm25, 123)); + TEST_INSTRUCTION("62F31D4043097B" , vshufi32x4(zmm1, zmm28, zmmword_ptr(rcx), 123)); + TEST_INSTRUCTION("62B31D40438CF0230100007B" , vshufi32x4(zmm1, zmm28, zmmword_ptr(rax, r14, 3, 291), 123)); + TEST_INSTRUCTION("62F31D5043097B" , vshufi32x4(zmm1, zmm28, dword_ptr(rcx)._1to16(), 123)); + TEST_INSTRUCTION("62F31D40434A7F7B" , vshufi32x4(zmm1, zmm28, zmmword_ptr(rdx, 8128), 123)); + TEST_INSTRUCTION("62F31D40438A002000007B" , vshufi32x4(zmm1, zmm28, zmmword_ptr(rdx, 8192), 123)); + TEST_INSTRUCTION("62F31D40434A807B" , vshufi32x4(zmm1, zmm28, zmmword_ptr(rdx, -8192), 123)); + TEST_INSTRUCTION("62F31D40438AC0DFFFFF7B" , vshufi32x4(zmm1, zmm28, zmmword_ptr(rdx, -8256), 123)); + TEST_INSTRUCTION("62F31D50434A7F7B" , vshufi32x4(zmm1, zmm28, dword_ptr(rdx, 508)._1to16(), 123)); + TEST_INSTRUCTION("62F31D50438A000200007B" , vshufi32x4(zmm1, zmm28, dword_ptr(rdx, 512)._1to16(), 123)); + TEST_INSTRUCTION("62F31D50434A807B" , vshufi32x4(zmm1, zmm28, dword_ptr(rdx, -512)._1to16(), 123)); + TEST_INSTRUCTION("62F31D50438AFCFDFFFF7B" , vshufi32x4(zmm1, zmm28, dword_ptr(rdx, -516)._1to16(), 123)); + TEST_INSTRUCTION("62B3FD4043DBAB" , vshufi64x2(zmm3, zmm16, zmm19, 171)); + TEST_INSTRUCTION("62B3FD4743DBAB" , k(k7).vshufi64x2(zmm3, zmm16, zmm19, 171)); + TEST_INSTRUCTION("62B3FDC743DBAB" , k(k7).z().vshufi64x2(zmm3, zmm16, zmm19, 171)); + TEST_INSTRUCTION("62B3FD4043DB7B" , vshufi64x2(zmm3, zmm16, zmm19, 123)); + TEST_INSTRUCTION("62F3FD4043197B" , vshufi64x2(zmm3, zmm16, zmmword_ptr(rcx), 123)); + TEST_INSTRUCTION("62B3FD40439CF0230100007B" , vshufi64x2(zmm3, zmm16, zmmword_ptr(rax, r14, 3, 291), 123)); + TEST_INSTRUCTION("62F3FD5043197B" , vshufi64x2(zmm3, zmm16, qword_ptr(rcx)._1to8(), 123)); + TEST_INSTRUCTION("62F3FD40435A7F7B" , vshufi64x2(zmm3, zmm16, zmmword_ptr(rdx, 8128), 123)); + TEST_INSTRUCTION("62F3FD40439A002000007B" , vshufi64x2(zmm3, zmm16, zmmword_ptr(rdx, 8192), 123)); + TEST_INSTRUCTION("62F3FD40435A807B" , vshufi64x2(zmm3, zmm16, zmmword_ptr(rdx, -8192), 123)); + TEST_INSTRUCTION("62F3FD40439AC0DFFFFF7B" , vshufi64x2(zmm3, zmm16, zmmword_ptr(rdx, -8256), 123)); + TEST_INSTRUCTION("62F3FD50435A7F7B" , vshufi64x2(zmm3, zmm16, qword_ptr(rdx, 1016)._1to8(), 123)); + TEST_INSTRUCTION("62F3FD50439A000400007B" , vshufi64x2(zmm3, zmm16, qword_ptr(rdx, 1024)._1to8(), 123)); + TEST_INSTRUCTION("62F3FD50435A807B" , vshufi64x2(zmm3, zmm16, qword_ptr(rdx, -1024)._1to8(), 123)); + TEST_INSTRUCTION("62F3FD50439AF8FBFFFF7B" , vshufi64x2(zmm3, zmm16, qword_ptr(rdx, -1032)._1to8(), 123)); + TEST_INSTRUCTION("62A2C54036EE" , vpermq(zmm21, zmm23, zmm22)); + TEST_INSTRUCTION("62A2C54136EE" , k(k1).vpermq(zmm21, zmm23, zmm22)); + TEST_INSTRUCTION("62A2C5C136EE" , k(k1).z().vpermq(zmm21, zmm23, zmm22)); + TEST_INSTRUCTION("62E2C5403629" , vpermq(zmm21, zmm23, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62A2C54036ACF023010000" , vpermq(zmm21, zmm23, zmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62E2C5503629" , vpermq(zmm21, zmm23, qword_ptr(rcx)._1to8())); + TEST_INSTRUCTION("62E2C540366A7F" , vpermq(zmm21, zmm23, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62E2C54036AA00200000" , vpermq(zmm21, zmm23, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62E2C540366A80" , vpermq(zmm21, zmm23, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62E2C54036AAC0DFFFFF" , vpermq(zmm21, zmm23, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62E2C550366A7F" , vpermq(zmm21, zmm23, qword_ptr(rdx, 1016)._1to8())); + TEST_INSTRUCTION("62E2C55036AA00040000" , vpermq(zmm21, zmm23, qword_ptr(rdx, 1024)._1to8())); + TEST_INSTRUCTION("62E2C550366A80" , vpermq(zmm21, zmm23, qword_ptr(rdx, -1024)._1to8())); + TEST_INSTRUCTION("62E2C55036AAF8FBFFFF" , vpermq(zmm21, zmm23, qword_ptr(rdx, -1032)._1to8())); + TEST_INSTRUCTION("6222954016D2" , vpermpd(zmm26, zmm29, zmm18)); + TEST_INSTRUCTION("6222954616D2" , k(k6).vpermpd(zmm26, zmm29, zmm18)); + TEST_INSTRUCTION("622295C616D2" , k(k6).z().vpermpd(zmm26, zmm29, zmm18)); + TEST_INSTRUCTION("626295401611" , vpermpd(zmm26, zmm29, zmmword_ptr(rcx))); + TEST_INSTRUCTION("622295401694F023010000" , vpermpd(zmm26, zmm29, zmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("626295501611" , vpermpd(zmm26, zmm29, qword_ptr(rcx)._1to8())); + TEST_INSTRUCTION("6262954016527F" , vpermpd(zmm26, zmm29, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62629540169200200000" , vpermpd(zmm26, zmm29, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62629540165280" , vpermpd(zmm26, zmm29, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("626295401692C0DFFFFF" , vpermpd(zmm26, zmm29, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("6262955016527F" , vpermpd(zmm26, zmm29, qword_ptr(rdx, 1016)._1to8())); + TEST_INSTRUCTION("62629550169200040000" , vpermpd(zmm26, zmm29, qword_ptr(rdx, 1024)._1to8())); + TEST_INSTRUCTION("62629550165280" , vpermpd(zmm26, zmm29, qword_ptr(rdx, -1024)._1to8())); + TEST_INSTRUCTION("626295501692F8FBFFFF" , vpermpd(zmm26, zmm29, qword_ptr(rdx, -1032)._1to8())); + TEST_INSTRUCTION("62724D487EEE" , vpermt2d(zmm13, zmm6, zmm6)); + TEST_INSTRUCTION("62724D4E7EEE" , k(k6).vpermt2d(zmm13, zmm6, zmm6)); + TEST_INSTRUCTION("62724DCE7EEE" , k(k6).z().vpermt2d(zmm13, zmm6, zmm6)); + TEST_INSTRUCTION("62724D487E29" , vpermt2d(zmm13, zmm6, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62324D487EACF023010000" , vpermt2d(zmm13, zmm6, zmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62724D587E29" , vpermt2d(zmm13, zmm6, dword_ptr(rcx)._1to16())); + TEST_INSTRUCTION("62724D487E6A7F" , vpermt2d(zmm13, zmm6, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62724D487EAA00200000" , vpermt2d(zmm13, zmm6, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62724D487E6A80" , vpermt2d(zmm13, zmm6, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62724D487EAAC0DFFFFF" , vpermt2d(zmm13, zmm6, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62724D587E6A7F" , vpermt2d(zmm13, zmm6, dword_ptr(rdx, 508)._1to16())); + TEST_INSTRUCTION("62724D587EAA00020000" , vpermt2d(zmm13, zmm6, dword_ptr(rdx, 512)._1to16())); + TEST_INSTRUCTION("62724D587E6A80" , vpermt2d(zmm13, zmm6, dword_ptr(rdx, -512)._1to16())); + TEST_INSTRUCTION("62724D587EAAFCFDFFFF" , vpermt2d(zmm13, zmm6, dword_ptr(rdx, -516)._1to16())); + TEST_INSTRUCTION("62A29D487EE8" , vpermt2q(zmm21, zmm12, zmm16)); + TEST_INSTRUCTION("62A29D4A7EE8" , k(k2).vpermt2q(zmm21, zmm12, zmm16)); + TEST_INSTRUCTION("62A29DCA7EE8" , k(k2).z().vpermt2q(zmm21, zmm12, zmm16)); + TEST_INSTRUCTION("62E29D487E29" , vpermt2q(zmm21, zmm12, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62A29D487EACF023010000" , vpermt2q(zmm21, zmm12, zmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62E29D587E29" , vpermt2q(zmm21, zmm12, qword_ptr(rcx)._1to8())); + TEST_INSTRUCTION("62E29D487E6A7F" , vpermt2q(zmm21, zmm12, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62E29D487EAA00200000" , vpermt2q(zmm21, zmm12, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62E29D487E6A80" , vpermt2q(zmm21, zmm12, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62E29D487EAAC0DFFFFF" , vpermt2q(zmm21, zmm12, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62E29D587E6A7F" , vpermt2q(zmm21, zmm12, qword_ptr(rdx, 1016)._1to8())); + TEST_INSTRUCTION("62E29D587EAA00040000" , vpermt2q(zmm21, zmm12, qword_ptr(rdx, 1024)._1to8())); + TEST_INSTRUCTION("62E29D587E6A80" , vpermt2q(zmm21, zmm12, qword_ptr(rdx, -1024)._1to8())); + TEST_INSTRUCTION("62E29D587EAAF8FBFFFF" , vpermt2q(zmm21, zmm12, qword_ptr(rdx, -1032)._1to8())); + TEST_INSTRUCTION("62721D407FDA" , vpermt2ps(zmm11, zmm28, zmm2)); + TEST_INSTRUCTION("62721D417FDA" , k(k1).vpermt2ps(zmm11, zmm28, zmm2)); + TEST_INSTRUCTION("62721DC17FDA" , k(k1).z().vpermt2ps(zmm11, zmm28, zmm2)); + TEST_INSTRUCTION("62721D407F19" , vpermt2ps(zmm11, zmm28, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62321D407F9CF023010000" , vpermt2ps(zmm11, zmm28, zmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62721D507F19" , vpermt2ps(zmm11, zmm28, dword_ptr(rcx)._1to16())); + TEST_INSTRUCTION("62721D407F5A7F" , vpermt2ps(zmm11, zmm28, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62721D407F9A00200000" , vpermt2ps(zmm11, zmm28, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62721D407F5A80" , vpermt2ps(zmm11, zmm28, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62721D407F9AC0DFFFFF" , vpermt2ps(zmm11, zmm28, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62721D507F5A7F" , vpermt2ps(zmm11, zmm28, dword_ptr(rdx, 508)._1to16())); + TEST_INSTRUCTION("62721D507F9A00020000" , vpermt2ps(zmm11, zmm28, dword_ptr(rdx, 512)._1to16())); + TEST_INSTRUCTION("62721D507F5A80" , vpermt2ps(zmm11, zmm28, dword_ptr(rdx, -512)._1to16())); + TEST_INSTRUCTION("62721D507F9AFCFDFFFF" , vpermt2ps(zmm11, zmm28, dword_ptr(rdx, -516)._1to16())); + TEST_INSTRUCTION("62D2A5407FDB" , vpermt2pd(zmm3, zmm27, zmm11)); + TEST_INSTRUCTION("62D2A5427FDB" , k(k2).vpermt2pd(zmm3, zmm27, zmm11)); + TEST_INSTRUCTION("62D2A5C27FDB" , k(k2).z().vpermt2pd(zmm3, zmm27, zmm11)); + TEST_INSTRUCTION("62F2A5407F19" , vpermt2pd(zmm3, zmm27, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62B2A5407F9CF023010000" , vpermt2pd(zmm3, zmm27, zmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62F2A5507F19" , vpermt2pd(zmm3, zmm27, qword_ptr(rcx)._1to8())); + TEST_INSTRUCTION("62F2A5407F5A7F" , vpermt2pd(zmm3, zmm27, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62F2A5407F9A00200000" , vpermt2pd(zmm3, zmm27, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62F2A5407F5A80" , vpermt2pd(zmm3, zmm27, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62F2A5407F9AC0DFFFFF" , vpermt2pd(zmm3, zmm27, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62F2A5507F5A7F" , vpermt2pd(zmm3, zmm27, qword_ptr(rdx, 1016)._1to8())); + TEST_INSTRUCTION("62F2A5507F9A00040000" , vpermt2pd(zmm3, zmm27, qword_ptr(rdx, 1024)._1to8())); + TEST_INSTRUCTION("62F2A5507F5A80" , vpermt2pd(zmm3, zmm27, qword_ptr(rdx, -1024)._1to8())); + TEST_INSTRUCTION("62F2A5507F9AF8FBFFFF" , vpermt2pd(zmm3, zmm27, qword_ptr(rdx, -1032)._1to8())); + TEST_INSTRUCTION("6223DD4803E7AB" , valignq(zmm28, zmm4, zmm23, 171)); + TEST_INSTRUCTION("6223DD4B03E7AB" , k(k3).valignq(zmm28, zmm4, zmm23, 171)); + TEST_INSTRUCTION("6223DDCB03E7AB" , k(k3).z().valignq(zmm28, zmm4, zmm23, 171)); + TEST_INSTRUCTION("6223DD4803E77B" , valignq(zmm28, zmm4, zmm23, 123)); + TEST_INSTRUCTION("6263DD4803217B" , valignq(zmm28, zmm4, zmmword_ptr(rcx), 123)); + TEST_INSTRUCTION("6223DD4803A4F0230100007B" , valignq(zmm28, zmm4, zmmword_ptr(rax, r14, 3, 291), 123)); + TEST_INSTRUCTION("6263DD5803217B" , valignq(zmm28, zmm4, qword_ptr(rcx)._1to8(), 123)); + TEST_INSTRUCTION("6263DD4803627F7B" , valignq(zmm28, zmm4, zmmword_ptr(rdx, 8128), 123)); + TEST_INSTRUCTION("6263DD4803A2002000007B" , valignq(zmm28, zmm4, zmmword_ptr(rdx, 8192), 123)); + TEST_INSTRUCTION("6263DD480362807B" , valignq(zmm28, zmm4, zmmword_ptr(rdx, -8192), 123)); + TEST_INSTRUCTION("6263DD4803A2C0DFFFFF7B" , valignq(zmm28, zmm4, zmmword_ptr(rdx, -8256), 123)); + TEST_INSTRUCTION("6263DD5803627F7B" , valignq(zmm28, zmm4, qword_ptr(rdx, 1016)._1to8(), 123)); + TEST_INSTRUCTION("6263DD5803A2000400007B" , valignq(zmm28, zmm4, qword_ptr(rdx, 1024)._1to8(), 123)); + TEST_INSTRUCTION("6263DD580362807B" , valignq(zmm28, zmm4, qword_ptr(rdx, -1024)._1to8(), 123)); + TEST_INSTRUCTION("6263DD5803A2F8FBFFFF7B" , valignq(zmm28, zmm4, qword_ptr(rdx, -1032)._1to8(), 123)); + TEST_INSTRUCTION("62917F0879C6" , vcvtsd2usi(eax, xmm30)); + TEST_INSTRUCTION("62917F1879C6" , rn_sae().vcvtsd2usi(eax, xmm30)); + TEST_INSTRUCTION("62917F5879C6" , ru_sae().vcvtsd2usi(eax, xmm30)); + TEST_INSTRUCTION("62917F3879C6" , rd_sae().vcvtsd2usi(eax, xmm30)); + TEST_INSTRUCTION("62917F7879C6" , rz_sae().vcvtsd2usi(eax, xmm30)); + TEST_INSTRUCTION("62F17F087901" , vcvtsd2usi(eax, qword_ptr(rcx))); + TEST_INSTRUCTION("62B17F087984F023010000" , vcvtsd2usi(eax, qword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62F17F0879427F" , vcvtsd2usi(eax, qword_ptr(rdx, 1016))); + TEST_INSTRUCTION("62F17F08798200040000" , vcvtsd2usi(eax, qword_ptr(rdx, 1024))); + TEST_INSTRUCTION("62F17F08794280" , vcvtsd2usi(eax, qword_ptr(rdx, -1024))); + TEST_INSTRUCTION("62F17F087982F8FBFFFF" , vcvtsd2usi(eax, qword_ptr(rdx, -1032))); + TEST_INSTRUCTION("62917F0879EE" , vcvtsd2usi(ebp, xmm30)); + TEST_INSTRUCTION("62917F1879EE" , rn_sae().vcvtsd2usi(ebp, xmm30)); + TEST_INSTRUCTION("62917F5879EE" , ru_sae().vcvtsd2usi(ebp, xmm30)); + TEST_INSTRUCTION("62917F3879EE" , rd_sae().vcvtsd2usi(ebp, xmm30)); + TEST_INSTRUCTION("62917F7879EE" , rz_sae().vcvtsd2usi(ebp, xmm30)); + TEST_INSTRUCTION("62F17F087929" , vcvtsd2usi(ebp, qword_ptr(rcx))); + TEST_INSTRUCTION("62B17F0879ACF023010000" , vcvtsd2usi(ebp, qword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62F17F08796A7F" , vcvtsd2usi(ebp, qword_ptr(rdx, 1016))); + TEST_INSTRUCTION("62F17F0879AA00040000" , vcvtsd2usi(ebp, qword_ptr(rdx, 1024))); + TEST_INSTRUCTION("62F17F08796A80" , vcvtsd2usi(ebp, qword_ptr(rdx, -1024))); + TEST_INSTRUCTION("62F17F0879AAF8FBFFFF" , vcvtsd2usi(ebp, qword_ptr(rdx, -1032))); + TEST_INSTRUCTION("62117F0879EE" , vcvtsd2usi(r13d, xmm30)); + TEST_INSTRUCTION("62117F1879EE" , rn_sae().vcvtsd2usi(r13d, xmm30)); + TEST_INSTRUCTION("62117F5879EE" , ru_sae().vcvtsd2usi(r13d, xmm30)); + TEST_INSTRUCTION("62117F3879EE" , rd_sae().vcvtsd2usi(r13d, xmm30)); + TEST_INSTRUCTION("62117F7879EE" , rz_sae().vcvtsd2usi(r13d, xmm30)); + TEST_INSTRUCTION("62717F087929" , vcvtsd2usi(r13d, qword_ptr(rcx))); + TEST_INSTRUCTION("62317F0879ACF023010000" , vcvtsd2usi(r13d, qword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62717F08796A7F" , vcvtsd2usi(r13d, qword_ptr(rdx, 1016))); + TEST_INSTRUCTION("62717F0879AA00040000" , vcvtsd2usi(r13d, qword_ptr(rdx, 1024))); + TEST_INSTRUCTION("62717F08796A80" , vcvtsd2usi(r13d, qword_ptr(rdx, -1024))); + TEST_INSTRUCTION("62717F0879AAF8FBFFFF" , vcvtsd2usi(r13d, qword_ptr(rdx, -1032))); + TEST_INSTRUCTION("62B1FF0879C2" , vcvtsd2usi(rax, xmm18)); + TEST_INSTRUCTION("62B1FF1879C2" , rn_sae().vcvtsd2usi(rax, xmm18)); + TEST_INSTRUCTION("62B1FF5879C2" , ru_sae().vcvtsd2usi(rax, xmm18)); + TEST_INSTRUCTION("62B1FF3879C2" , rd_sae().vcvtsd2usi(rax, xmm18)); + TEST_INSTRUCTION("62B1FF7879C2" , rz_sae().vcvtsd2usi(rax, xmm18)); + TEST_INSTRUCTION("62F1FF087901" , vcvtsd2usi(rax, qword_ptr(rcx))); + TEST_INSTRUCTION("62B1FF087984F023010000" , vcvtsd2usi(rax, qword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62F1FF0879427F" , vcvtsd2usi(rax, qword_ptr(rdx, 1016))); + TEST_INSTRUCTION("62F1FF08798200040000" , vcvtsd2usi(rax, qword_ptr(rdx, 1024))); + TEST_INSTRUCTION("62F1FF08794280" , vcvtsd2usi(rax, qword_ptr(rdx, -1024))); + TEST_INSTRUCTION("62F1FF087982F8FBFFFF" , vcvtsd2usi(rax, qword_ptr(rdx, -1032))); + TEST_INSTRUCTION("6231FF0879C2" , vcvtsd2usi(r8, xmm18)); + TEST_INSTRUCTION("6231FF1879C2" , rn_sae().vcvtsd2usi(r8, xmm18)); + TEST_INSTRUCTION("6231FF5879C2" , ru_sae().vcvtsd2usi(r8, xmm18)); + TEST_INSTRUCTION("6231FF3879C2" , rd_sae().vcvtsd2usi(r8, xmm18)); + TEST_INSTRUCTION("6231FF7879C2" , rz_sae().vcvtsd2usi(r8, xmm18)); + TEST_INSTRUCTION("6271FF087901" , vcvtsd2usi(r8, qword_ptr(rcx))); + TEST_INSTRUCTION("6231FF087984F023010000" , vcvtsd2usi(r8, qword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("6271FF0879427F" , vcvtsd2usi(r8, qword_ptr(rdx, 1016))); + TEST_INSTRUCTION("6271FF08798200040000" , vcvtsd2usi(r8, qword_ptr(rdx, 1024))); + TEST_INSTRUCTION("6271FF08794280" , vcvtsd2usi(r8, qword_ptr(rdx, -1024))); + TEST_INSTRUCTION("6271FF087982F8FBFFFF" , vcvtsd2usi(r8, qword_ptr(rdx, -1032))); + TEST_INSTRUCTION("62917E0879C4" , vcvtss2usi(eax, xmm28)); + TEST_INSTRUCTION("62917E1879C4" , rn_sae().vcvtss2usi(eax, xmm28)); + TEST_INSTRUCTION("62917E5879C4" , ru_sae().vcvtss2usi(eax, xmm28)); + TEST_INSTRUCTION("62917E3879C4" , rd_sae().vcvtss2usi(eax, xmm28)); + TEST_INSTRUCTION("62917E7879C4" , rz_sae().vcvtss2usi(eax, xmm28)); + TEST_INSTRUCTION("62F17E087901" , vcvtss2usi(eax, dword_ptr(rcx))); + TEST_INSTRUCTION("62B17E087984F023010000" , vcvtss2usi(eax, dword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62F17E0879427F" , vcvtss2usi(eax, dword_ptr(rdx, 508))); + TEST_INSTRUCTION("62F17E08798200020000" , vcvtss2usi(eax, dword_ptr(rdx, 512))); + TEST_INSTRUCTION("62F17E08794280" , vcvtss2usi(eax, dword_ptr(rdx, -512))); + TEST_INSTRUCTION("62F17E087982FCFDFFFF" , vcvtss2usi(eax, dword_ptr(rdx, -516))); + TEST_INSTRUCTION("62917E0879EC" , vcvtss2usi(ebp, xmm28)); + TEST_INSTRUCTION("62917E1879EC" , rn_sae().vcvtss2usi(ebp, xmm28)); + TEST_INSTRUCTION("62917E5879EC" , ru_sae().vcvtss2usi(ebp, xmm28)); + TEST_INSTRUCTION("62917E3879EC" , rd_sae().vcvtss2usi(ebp, xmm28)); + TEST_INSTRUCTION("62917E7879EC" , rz_sae().vcvtss2usi(ebp, xmm28)); + TEST_INSTRUCTION("62F17E087929" , vcvtss2usi(ebp, dword_ptr(rcx))); + TEST_INSTRUCTION("62B17E0879ACF023010000" , vcvtss2usi(ebp, dword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62F17E08796A7F" , vcvtss2usi(ebp, dword_ptr(rdx, 508))); + TEST_INSTRUCTION("62F17E0879AA00020000" , vcvtss2usi(ebp, dword_ptr(rdx, 512))); + TEST_INSTRUCTION("62F17E08796A80" , vcvtss2usi(ebp, dword_ptr(rdx, -512))); + TEST_INSTRUCTION("62F17E0879AAFCFDFFFF" , vcvtss2usi(ebp, dword_ptr(rdx, -516))); + TEST_INSTRUCTION("62117E0879EC" , vcvtss2usi(r13d, xmm28)); + TEST_INSTRUCTION("62117E1879EC" , rn_sae().vcvtss2usi(r13d, xmm28)); + TEST_INSTRUCTION("62117E5879EC" , ru_sae().vcvtss2usi(r13d, xmm28)); + TEST_INSTRUCTION("62117E3879EC" , rd_sae().vcvtss2usi(r13d, xmm28)); + TEST_INSTRUCTION("62117E7879EC" , rz_sae().vcvtss2usi(r13d, xmm28)); + TEST_INSTRUCTION("62717E087929" , vcvtss2usi(r13d, dword_ptr(rcx))); + TEST_INSTRUCTION("62317E0879ACF023010000" , vcvtss2usi(r13d, dword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62717E08796A7F" , vcvtss2usi(r13d, dword_ptr(rdx, 508))); + TEST_INSTRUCTION("62717E0879AA00020000" , vcvtss2usi(r13d, dword_ptr(rdx, 512))); + TEST_INSTRUCTION("62717E08796A80" , vcvtss2usi(r13d, dword_ptr(rdx, -512))); + TEST_INSTRUCTION("62717E0879AAFCFDFFFF" , vcvtss2usi(r13d, dword_ptr(rdx, -516))); + TEST_INSTRUCTION("62B1FE0879C7" , vcvtss2usi(rax, xmm23)); + TEST_INSTRUCTION("62B1FE1879C7" , rn_sae().vcvtss2usi(rax, xmm23)); + TEST_INSTRUCTION("62B1FE5879C7" , ru_sae().vcvtss2usi(rax, xmm23)); + TEST_INSTRUCTION("62B1FE3879C7" , rd_sae().vcvtss2usi(rax, xmm23)); + TEST_INSTRUCTION("62B1FE7879C7" , rz_sae().vcvtss2usi(rax, xmm23)); + TEST_INSTRUCTION("62F1FE087901" , vcvtss2usi(rax, dword_ptr(rcx))); + TEST_INSTRUCTION("62B1FE087984F023010000" , vcvtss2usi(rax, dword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62F1FE0879427F" , vcvtss2usi(rax, dword_ptr(rdx, 508))); + TEST_INSTRUCTION("62F1FE08798200020000" , vcvtss2usi(rax, dword_ptr(rdx, 512))); + TEST_INSTRUCTION("62F1FE08794280" , vcvtss2usi(rax, dword_ptr(rdx, -512))); + TEST_INSTRUCTION("62F1FE087982FCFDFFFF" , vcvtss2usi(rax, dword_ptr(rdx, -516))); + TEST_INSTRUCTION("6231FE0879C7" , vcvtss2usi(r8, xmm23)); + TEST_INSTRUCTION("6231FE1879C7" , rn_sae().vcvtss2usi(r8, xmm23)); + TEST_INSTRUCTION("6231FE5879C7" , ru_sae().vcvtss2usi(r8, xmm23)); + TEST_INSTRUCTION("6231FE3879C7" , rd_sae().vcvtss2usi(r8, xmm23)); + TEST_INSTRUCTION("6231FE7879C7" , rz_sae().vcvtss2usi(r8, xmm23)); + TEST_INSTRUCTION("6271FE087901" , vcvtss2usi(r8, dword_ptr(rcx))); + TEST_INSTRUCTION("6231FE087984F023010000" , vcvtss2usi(r8, dword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("6271FE0879427F" , vcvtss2usi(r8, dword_ptr(rdx, 508))); + TEST_INSTRUCTION("6271FE08798200020000" , vcvtss2usi(r8, dword_ptr(rdx, 512))); + TEST_INSTRUCTION("6271FE08794280" , vcvtss2usi(r8, dword_ptr(rdx, -512))); + TEST_INSTRUCTION("6271FE087982FCFDFFFF" , vcvtss2usi(r8, dword_ptr(rdx, -516))); + TEST_INSTRUCTION("62E177087BD8" , vcvtusi2sd(xmm19, xmm1, eax)); + TEST_INSTRUCTION("62E177087BDD" , vcvtusi2sd(xmm19, xmm1, ebp)); + TEST_INSTRUCTION("62C177087BDD" , vcvtusi2sd(xmm19, xmm1, r13d)); + TEST_INSTRUCTION("62E177087B19" , vcvtusi2sd(xmm19, xmm1, dword_ptr(rcx))); + TEST_INSTRUCTION("62A177087B9CF023010000" , vcvtusi2sd(xmm19, xmm1, dword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62E177087B5A7F" , vcvtusi2sd(xmm19, xmm1, dword_ptr(rdx, 508))); + TEST_INSTRUCTION("62E177087B9A00020000" , vcvtusi2sd(xmm19, xmm1, dword_ptr(rdx, 512))); + TEST_INSTRUCTION("62E177087B5A80" , vcvtusi2sd(xmm19, xmm1, dword_ptr(rdx, -512))); + TEST_INSTRUCTION("62E177087B9AFCFDFFFF" , vcvtusi2sd(xmm19, xmm1, dword_ptr(rdx, -516))); + TEST_INSTRUCTION("6271AF007BF0" , vcvtusi2sd(xmm14, xmm26, rax)); + TEST_INSTRUCTION("6271AF107BF0" , rn_sae().vcvtusi2sd(xmm14, xmm26, rax)); + TEST_INSTRUCTION("6271AF507BF0" , ru_sae().vcvtusi2sd(xmm14, xmm26, rax)); + TEST_INSTRUCTION("6271AF307BF0" , rd_sae().vcvtusi2sd(xmm14, xmm26, rax)); + TEST_INSTRUCTION("6271AF707BF0" , rz_sae().vcvtusi2sd(xmm14, xmm26, rax)); + TEST_INSTRUCTION("6251AF007BF0" , vcvtusi2sd(xmm14, xmm26, r8)); + TEST_INSTRUCTION("6251AF107BF0" , rn_sae().vcvtusi2sd(xmm14, xmm26, r8)); + TEST_INSTRUCTION("6251AF507BF0" , ru_sae().vcvtusi2sd(xmm14, xmm26, r8)); + TEST_INSTRUCTION("6251AF307BF0" , rd_sae().vcvtusi2sd(xmm14, xmm26, r8)); + TEST_INSTRUCTION("6251AF707BF0" , rz_sae().vcvtusi2sd(xmm14, xmm26, r8)); + TEST_INSTRUCTION("6271AF007B31" , vcvtusi2sd(xmm14, xmm26, qword_ptr(rcx))); + TEST_INSTRUCTION("6231AF007BB4F023010000" , vcvtusi2sd(xmm14, xmm26, qword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("6271AF007B727F" , vcvtusi2sd(xmm14, xmm26, qword_ptr(rdx, 1016))); + TEST_INSTRUCTION("6271AF007BB200040000" , vcvtusi2sd(xmm14, xmm26, qword_ptr(rdx, 1024))); + TEST_INSTRUCTION("6271AF007B7280" , vcvtusi2sd(xmm14, xmm26, qword_ptr(rdx, -1024))); + TEST_INSTRUCTION("6271AF007BB2F8FBFFFF" , vcvtusi2sd(xmm14, xmm26, qword_ptr(rdx, -1032))); + TEST_INSTRUCTION("62F12E007BE8" , vcvtusi2ss(xmm5, xmm26, eax)); + TEST_INSTRUCTION("62F12E107BE8" , rn_sae().vcvtusi2ss(xmm5, xmm26, eax)); + TEST_INSTRUCTION("62F12E507BE8" , ru_sae().vcvtusi2ss(xmm5, xmm26, eax)); + TEST_INSTRUCTION("62F12E307BE8" , rd_sae().vcvtusi2ss(xmm5, xmm26, eax)); + TEST_INSTRUCTION("62F12E707BE8" , rz_sae().vcvtusi2ss(xmm5, xmm26, eax)); + TEST_INSTRUCTION("62F12E007BED" , vcvtusi2ss(xmm5, xmm26, ebp)); + TEST_INSTRUCTION("62F12E107BED" , rn_sae().vcvtusi2ss(xmm5, xmm26, ebp)); + TEST_INSTRUCTION("62F12E507BED" , ru_sae().vcvtusi2ss(xmm5, xmm26, ebp)); + TEST_INSTRUCTION("62F12E307BED" , rd_sae().vcvtusi2ss(xmm5, xmm26, ebp)); + TEST_INSTRUCTION("62F12E707BED" , rz_sae().vcvtusi2ss(xmm5, xmm26, ebp)); + TEST_INSTRUCTION("62D12E007BED" , vcvtusi2ss(xmm5, xmm26, r13d)); + TEST_INSTRUCTION("62D12E107BED" , rn_sae().vcvtusi2ss(xmm5, xmm26, r13d)); + TEST_INSTRUCTION("62D12E507BED" , ru_sae().vcvtusi2ss(xmm5, xmm26, r13d)); + TEST_INSTRUCTION("62D12E307BED" , rd_sae().vcvtusi2ss(xmm5, xmm26, r13d)); + TEST_INSTRUCTION("62D12E707BED" , rz_sae().vcvtusi2ss(xmm5, xmm26, r13d)); + TEST_INSTRUCTION("62F12E007B29" , vcvtusi2ss(xmm5, xmm26, dword_ptr(rcx))); + TEST_INSTRUCTION("62B12E007BACF023010000" , vcvtusi2ss(xmm5, xmm26, dword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62F12E007B6A7F" , vcvtusi2ss(xmm5, xmm26, dword_ptr(rdx, 508))); + TEST_INSTRUCTION("62F12E007BAA00020000" , vcvtusi2ss(xmm5, xmm26, dword_ptr(rdx, 512))); + TEST_INSTRUCTION("62F12E007B6A80" , vcvtusi2ss(xmm5, xmm26, dword_ptr(rdx, -512))); + TEST_INSTRUCTION("62F12E007BAAFCFDFFFF" , vcvtusi2ss(xmm5, xmm26, dword_ptr(rdx, -516))); + TEST_INSTRUCTION("6271CE007BF0" , vcvtusi2ss(xmm14, xmm22, rax)); + TEST_INSTRUCTION("6271CE107BF0" , rn_sae().vcvtusi2ss(xmm14, xmm22, rax)); + TEST_INSTRUCTION("6271CE507BF0" , ru_sae().vcvtusi2ss(xmm14, xmm22, rax)); + TEST_INSTRUCTION("6271CE307BF0" , rd_sae().vcvtusi2ss(xmm14, xmm22, rax)); + TEST_INSTRUCTION("6271CE707BF0" , rz_sae().vcvtusi2ss(xmm14, xmm22, rax)); + TEST_INSTRUCTION("6251CE007BF0" , vcvtusi2ss(xmm14, xmm22, r8)); + TEST_INSTRUCTION("6251CE107BF0" , rn_sae().vcvtusi2ss(xmm14, xmm22, r8)); + TEST_INSTRUCTION("6251CE507BF0" , ru_sae().vcvtusi2ss(xmm14, xmm22, r8)); + TEST_INSTRUCTION("6251CE307BF0" , rd_sae().vcvtusi2ss(xmm14, xmm22, r8)); + TEST_INSTRUCTION("6251CE707BF0" , rz_sae().vcvtusi2ss(xmm14, xmm22, r8)); + TEST_INSTRUCTION("6271CE007B31" , vcvtusi2ss(xmm14, xmm22, qword_ptr(rcx))); + TEST_INSTRUCTION("6231CE007BB4F023010000" , vcvtusi2ss(xmm14, xmm22, qword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("6271CE007B727F" , vcvtusi2ss(xmm14, xmm22, qword_ptr(rdx, 1016))); + TEST_INSTRUCTION("6271CE007BB200040000" , vcvtusi2ss(xmm14, xmm22, qword_ptr(rdx, 1024))); + TEST_INSTRUCTION("6271CE007B7280" , vcvtusi2ss(xmm14, xmm22, qword_ptr(rdx, -1024))); + TEST_INSTRUCTION("6271CE007BB2F8FBFFFF" , vcvtusi2ss(xmm14, xmm22, qword_ptr(rdx, -1032))); + TEST_INSTRUCTION("6202AD402CD4" , vscalefpd(zmm26, zmm26, zmm28)); + TEST_INSTRUCTION("6202AD452CD4" , k(k5).vscalefpd(zmm26, zmm26, zmm28)); + TEST_INSTRUCTION("6202ADC52CD4" , k(k5).z().vscalefpd(zmm26, zmm26, zmm28)); + TEST_INSTRUCTION("6202AD102CD4" , rn_sae().vscalefpd(zmm26, zmm26, zmm28)); + TEST_INSTRUCTION("6202AD502CD4" , ru_sae().vscalefpd(zmm26, zmm26, zmm28)); + TEST_INSTRUCTION("6202AD302CD4" , rd_sae().vscalefpd(zmm26, zmm26, zmm28)); + TEST_INSTRUCTION("6202AD702CD4" , rz_sae().vscalefpd(zmm26, zmm26, zmm28)); + TEST_INSTRUCTION("6262AD402C11" , vscalefpd(zmm26, zmm26, zmmword_ptr(rcx))); + TEST_INSTRUCTION("6222AD402C94F023010000" , vscalefpd(zmm26, zmm26, zmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("6262AD502C11" , vscalefpd(zmm26, zmm26, qword_ptr(rcx)._1to8())); + TEST_INSTRUCTION("6262AD402C527F" , vscalefpd(zmm26, zmm26, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("6262AD402C9200200000" , vscalefpd(zmm26, zmm26, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("6262AD402C5280" , vscalefpd(zmm26, zmm26, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("6262AD402C92C0DFFFFF" , vscalefpd(zmm26, zmm26, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("6262AD502C527F" , vscalefpd(zmm26, zmm26, qword_ptr(rdx, 1016)._1to8())); + TEST_INSTRUCTION("6262AD502C9200040000" , vscalefpd(zmm26, zmm26, qword_ptr(rdx, 1024)._1to8())); + TEST_INSTRUCTION("6262AD502C5280" , vscalefpd(zmm26, zmm26, qword_ptr(rdx, -1024)._1to8())); + TEST_INSTRUCTION("6262AD502C92F8FBFFFF" , vscalefpd(zmm26, zmm26, qword_ptr(rdx, -1032)._1to8())); + TEST_INSTRUCTION("62A24D482CDA" , vscalefps(zmm19, zmm6, zmm18)); + TEST_INSTRUCTION("62A24D4E2CDA" , k(k6).vscalefps(zmm19, zmm6, zmm18)); + TEST_INSTRUCTION("62A24DCE2CDA" , k(k6).z().vscalefps(zmm19, zmm6, zmm18)); + TEST_INSTRUCTION("62A24D182CDA" , rn_sae().vscalefps(zmm19, zmm6, zmm18)); + TEST_INSTRUCTION("62A24D582CDA" , ru_sae().vscalefps(zmm19, zmm6, zmm18)); + TEST_INSTRUCTION("62A24D382CDA" , rd_sae().vscalefps(zmm19, zmm6, zmm18)); + TEST_INSTRUCTION("62A24D782CDA" , rz_sae().vscalefps(zmm19, zmm6, zmm18)); + TEST_INSTRUCTION("62E24D482C19" , vscalefps(zmm19, zmm6, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62A24D482C9CF023010000" , vscalefps(zmm19, zmm6, zmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62E24D582C19" , vscalefps(zmm19, zmm6, dword_ptr(rcx)._1to16())); + TEST_INSTRUCTION("62E24D482C5A7F" , vscalefps(zmm19, zmm6, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62E24D482C9A00200000" , vscalefps(zmm19, zmm6, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62E24D482C5A80" , vscalefps(zmm19, zmm6, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62E24D482C9AC0DFFFFF" , vscalefps(zmm19, zmm6, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62E24D582C5A7F" , vscalefps(zmm19, zmm6, dword_ptr(rdx, 508)._1to16())); + TEST_INSTRUCTION("62E24D582C9A00020000" , vscalefps(zmm19, zmm6, dword_ptr(rdx, 512)._1to16())); + TEST_INSTRUCTION("62E24D582C5A80" , vscalefps(zmm19, zmm6, dword_ptr(rdx, -512)._1to16())); + TEST_INSTRUCTION("62E24D582C9AFCFDFFFF" , vscalefps(zmm19, zmm6, dword_ptr(rdx, -516)._1to16())); + TEST_INSTRUCTION("62A2CD002DED" , vscalefsd(xmm21, xmm22, xmm21)); + TEST_INSTRUCTION("62A2CD022DED" , k(k2).vscalefsd(xmm21, xmm22, xmm21)); + TEST_INSTRUCTION("62A2CD822DED" , k(k2).z().vscalefsd(xmm21, xmm22, xmm21)); + TEST_INSTRUCTION("62A2CD102DED" , rn_sae().vscalefsd(xmm21, xmm22, xmm21)); + TEST_INSTRUCTION("62A2CD502DED" , ru_sae().vscalefsd(xmm21, xmm22, xmm21)); + TEST_INSTRUCTION("62A2CD302DED" , rd_sae().vscalefsd(xmm21, xmm22, xmm21)); + TEST_INSTRUCTION("62A2CD702DED" , rz_sae().vscalefsd(xmm21, xmm22, xmm21)); + TEST_INSTRUCTION("62E2CD002D29" , vscalefsd(xmm21, xmm22, qword_ptr(rcx))); + TEST_INSTRUCTION("62A2CD002DACF023010000" , vscalefsd(xmm21, xmm22, qword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62E2CD002D6A7F" , vscalefsd(xmm21, xmm22, qword_ptr(rdx, 1016))); + TEST_INSTRUCTION("62E2CD002DAA00040000" , vscalefsd(xmm21, xmm22, qword_ptr(rdx, 1024))); + TEST_INSTRUCTION("62E2CD002D6A80" , vscalefsd(xmm21, xmm22, qword_ptr(rdx, -1024))); + TEST_INSTRUCTION("62E2CD002DAAF8FBFFFF" , vscalefsd(xmm21, xmm22, qword_ptr(rdx, -1032))); + TEST_INSTRUCTION("623205082DEF" , vscalefss(xmm13, xmm15, xmm23)); + TEST_INSTRUCTION("6232050B2DEF" , k(k3).vscalefss(xmm13, xmm15, xmm23)); + TEST_INSTRUCTION("6232058B2DEF" , k(k3).z().vscalefss(xmm13, xmm15, xmm23)); + TEST_INSTRUCTION("623205182DEF" , rn_sae().vscalefss(xmm13, xmm15, xmm23)); + TEST_INSTRUCTION("623205582DEF" , ru_sae().vscalefss(xmm13, xmm15, xmm23)); + TEST_INSTRUCTION("623205382DEF" , rd_sae().vscalefss(xmm13, xmm15, xmm23)); + TEST_INSTRUCTION("623205782DEF" , rz_sae().vscalefss(xmm13, xmm15, xmm23)); + TEST_INSTRUCTION("627205082D29" , vscalefss(xmm13, xmm15, dword_ptr(rcx))); + TEST_INSTRUCTION("623205082DACF023010000" , vscalefss(xmm13, xmm15, dword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("627205082D6A7F" , vscalefss(xmm13, xmm15, dword_ptr(rdx, 508))); + TEST_INSTRUCTION("627205082DAA00020000" , vscalefss(xmm13, xmm15, dword_ptr(rdx, 512))); + TEST_INSTRUCTION("627205082D6A80" , vscalefss(xmm13, xmm15, dword_ptr(rdx, -512))); + TEST_INSTRUCTION("627205082DAAFCFDFFFF" , vscalefss(xmm13, xmm15, dword_ptr(rdx, -516))); + TEST_INSTRUCTION("62732D4054FAAB" , vfixupimmps(zmm15, zmm26, zmm2, 171)); + TEST_INSTRUCTION("62732D4454FAAB" , k(k4).vfixupimmps(zmm15, zmm26, zmm2, 171)); + TEST_INSTRUCTION("62732DC454FAAB" , k(k4).z().vfixupimmps(zmm15, zmm26, zmm2, 171)); + TEST_INSTRUCTION("62732D1054FAAB" , sae().vfixupimmps(zmm15, zmm26, zmm2, 171)); + TEST_INSTRUCTION("62732D4054FA7B" , vfixupimmps(zmm15, zmm26, zmm2, 123)); + TEST_INSTRUCTION("62732D1054FA7B" , sae().vfixupimmps(zmm15, zmm26, zmm2, 123)); + TEST_INSTRUCTION("62732D4054397B" , vfixupimmps(zmm15, zmm26, zmmword_ptr(rcx), 123)); + TEST_INSTRUCTION("62332D4054BCF0230100007B" , vfixupimmps(zmm15, zmm26, zmmword_ptr(rax, r14, 3, 291), 123)); + TEST_INSTRUCTION("62732D5054397B" , vfixupimmps(zmm15, zmm26, dword_ptr(rcx)._1to16(), 123)); + TEST_INSTRUCTION("62732D40547A7F7B" , vfixupimmps(zmm15, zmm26, zmmword_ptr(rdx, 8128), 123)); + TEST_INSTRUCTION("62732D4054BA002000007B" , vfixupimmps(zmm15, zmm26, zmmword_ptr(rdx, 8192), 123)); + TEST_INSTRUCTION("62732D40547A807B" , vfixupimmps(zmm15, zmm26, zmmword_ptr(rdx, -8192), 123)); + TEST_INSTRUCTION("62732D4054BAC0DFFFFF7B" , vfixupimmps(zmm15, zmm26, zmmword_ptr(rdx, -8256), 123)); + TEST_INSTRUCTION("62732D50547A7F7B" , vfixupimmps(zmm15, zmm26, dword_ptr(rdx, 508)._1to16(), 123)); + TEST_INSTRUCTION("62732D5054BA000200007B" , vfixupimmps(zmm15, zmm26, dword_ptr(rdx, 512)._1to16(), 123)); + TEST_INSTRUCTION("62732D50547A807B" , vfixupimmps(zmm15, zmm26, dword_ptr(rdx, -512)._1to16(), 123)); + TEST_INSTRUCTION("62732D5054BAFCFDFFFF7B" , vfixupimmps(zmm15, zmm26, dword_ptr(rdx, -516)._1to16(), 123)); + TEST_INSTRUCTION("6233D54054CBAB" , vfixupimmpd(zmm9, zmm21, zmm19, 171)); + TEST_INSTRUCTION("6233D54254CBAB" , k(k2).vfixupimmpd(zmm9, zmm21, zmm19, 171)); + TEST_INSTRUCTION("6233D5C254CBAB" , k(k2).z().vfixupimmpd(zmm9, zmm21, zmm19, 171)); + TEST_INSTRUCTION("6233D51054CBAB" , sae().vfixupimmpd(zmm9, zmm21, zmm19, 171)); + TEST_INSTRUCTION("6233D54054CB7B" , vfixupimmpd(zmm9, zmm21, zmm19, 123)); + TEST_INSTRUCTION("6233D51054CB7B" , sae().vfixupimmpd(zmm9, zmm21, zmm19, 123)); + TEST_INSTRUCTION("6273D54054097B" , vfixupimmpd(zmm9, zmm21, zmmword_ptr(rcx), 123)); + TEST_INSTRUCTION("6233D540548CF0230100007B" , vfixupimmpd(zmm9, zmm21, zmmword_ptr(rax, r14, 3, 291), 123)); + TEST_INSTRUCTION("6273D55054097B" , vfixupimmpd(zmm9, zmm21, qword_ptr(rcx)._1to8(), 123)); + TEST_INSTRUCTION("6273D540544A7F7B" , vfixupimmpd(zmm9, zmm21, zmmword_ptr(rdx, 8128), 123)); + TEST_INSTRUCTION("6273D540548A002000007B" , vfixupimmpd(zmm9, zmm21, zmmword_ptr(rdx, 8192), 123)); + TEST_INSTRUCTION("6273D540544A807B" , vfixupimmpd(zmm9, zmm21, zmmword_ptr(rdx, -8192), 123)); + TEST_INSTRUCTION("6273D540548AC0DFFFFF7B" , vfixupimmpd(zmm9, zmm21, zmmword_ptr(rdx, -8256), 123)); + TEST_INSTRUCTION("6273D550544A7F7B" , vfixupimmpd(zmm9, zmm21, qword_ptr(rdx, 1016)._1to8(), 123)); + TEST_INSTRUCTION("6273D550548A000400007B" , vfixupimmpd(zmm9, zmm21, qword_ptr(rdx, 1024)._1to8(), 123)); + TEST_INSTRUCTION("6273D550544A807B" , vfixupimmpd(zmm9, zmm21, qword_ptr(rdx, -1024)._1to8(), 123)); + TEST_INSTRUCTION("6273D550548AF8FBFFFF7B" , vfixupimmpd(zmm9, zmm21, qword_ptr(rdx, -1032)._1to8(), 123)); + TEST_INSTRUCTION("62136D0055FCAB" , vfixupimmss(xmm15, xmm18, xmm28, 171)); + TEST_INSTRUCTION("62136D0555FCAB" , k(k5).vfixupimmss(xmm15, xmm18, xmm28, 171)); + TEST_INSTRUCTION("62136D8555FCAB" , k(k5).z().vfixupimmss(xmm15, xmm18, xmm28, 171)); + TEST_INSTRUCTION("62136D1055FCAB" , sae().vfixupimmss(xmm15, xmm18, xmm28, 171)); + TEST_INSTRUCTION("62136D0055FC7B" , vfixupimmss(xmm15, xmm18, xmm28, 123)); + TEST_INSTRUCTION("62136D1055FC7B" , sae().vfixupimmss(xmm15, xmm18, xmm28, 123)); + TEST_INSTRUCTION("62736D0055397B" , vfixupimmss(xmm15, xmm18, dword_ptr(rcx), 123)); + TEST_INSTRUCTION("62336D0055BCF0230100007B" , vfixupimmss(xmm15, xmm18, dword_ptr(rax, r14, 3, 291), 123)); + TEST_INSTRUCTION("62736D00557A7F7B" , vfixupimmss(xmm15, xmm18, dword_ptr(rdx, 508), 123)); + TEST_INSTRUCTION("62736D0055BA000200007B" , vfixupimmss(xmm15, xmm18, dword_ptr(rdx, 512), 123)); + TEST_INSTRUCTION("62736D00557A807B" , vfixupimmss(xmm15, xmm18, dword_ptr(rdx, -512), 123)); + TEST_INSTRUCTION("62736D0055BAFCFDFFFF7B" , vfixupimmss(xmm15, xmm18, dword_ptr(rdx, -516), 123)); + TEST_INSTRUCTION("6273AD0055EDAB" , vfixupimmsd(xmm13, xmm26, xmm5, 171)); + TEST_INSTRUCTION("6273AD0655EDAB" , k(k6).vfixupimmsd(xmm13, xmm26, xmm5, 171)); + TEST_INSTRUCTION("6273AD8655EDAB" , k(k6).z().vfixupimmsd(xmm13, xmm26, xmm5, 171)); + TEST_INSTRUCTION("6273AD1055EDAB" , sae().vfixupimmsd(xmm13, xmm26, xmm5, 171)); + TEST_INSTRUCTION("6273AD0055ED7B" , vfixupimmsd(xmm13, xmm26, xmm5, 123)); + TEST_INSTRUCTION("6273AD1055ED7B" , sae().vfixupimmsd(xmm13, xmm26, xmm5, 123)); + TEST_INSTRUCTION("6273AD0055297B" , vfixupimmsd(xmm13, xmm26, qword_ptr(rcx), 123)); + TEST_INSTRUCTION("6233AD0055ACF0230100007B" , vfixupimmsd(xmm13, xmm26, qword_ptr(rax, r14, 3, 291), 123)); + TEST_INSTRUCTION("6273AD00556A7F7B" , vfixupimmsd(xmm13, xmm26, qword_ptr(rdx, 1016), 123)); + TEST_INSTRUCTION("6273AD0055AA000400007B" , vfixupimmsd(xmm13, xmm26, qword_ptr(rdx, 1024), 123)); + TEST_INSTRUCTION("6273AD00556A807B" , vfixupimmsd(xmm13, xmm26, qword_ptr(rdx, -1024), 123)); + TEST_INSTRUCTION("6273AD0055AAF8FBFFFF7B" , vfixupimmsd(xmm13, xmm26, qword_ptr(rdx, -1032), 123)); + TEST_INSTRUCTION("6291154072F0AB" , vpslld(zmm29, zmm24, 171)); + TEST_INSTRUCTION("6291154672F0AB" , k(k6).vpslld(zmm29, zmm24, 171)); + TEST_INSTRUCTION("629115C672F0AB" , k(k6).z().vpslld(zmm29, zmm24, 171)); + TEST_INSTRUCTION("6291154072F07B" , vpslld(zmm29, zmm24, 123)); + TEST_INSTRUCTION("62F1154072317B" , vpslld(zmm29, zmmword_ptr(rcx), 123)); + TEST_INSTRUCTION("62B1154072B4F0230100007B" , vpslld(zmm29, zmmword_ptr(rax, r14, 3, 291), 123)); + TEST_INSTRUCTION("62F1155072317B" , vpslld(zmm29, dword_ptr(rcx)._1to16(), 123)); + TEST_INSTRUCTION("62F1154072727F7B" , vpslld(zmm29, zmmword_ptr(rdx, 8128), 123)); + TEST_INSTRUCTION("62F1154072B2002000007B" , vpslld(zmm29, zmmword_ptr(rdx, 8192), 123)); + TEST_INSTRUCTION("62F115407272807B" , vpslld(zmm29, zmmword_ptr(rdx, -8192), 123)); + TEST_INSTRUCTION("62F1154072B2C0DFFFFF7B" , vpslld(zmm29, zmmword_ptr(rdx, -8256), 123)); + TEST_INSTRUCTION("62F1155072727F7B" , vpslld(zmm29, dword_ptr(rdx, 508)._1to16(), 123)); + TEST_INSTRUCTION("62F1155072B2000200007B" , vpslld(zmm29, dword_ptr(rdx, 512)._1to16(), 123)); + TEST_INSTRUCTION("62F115507272807B" , vpslld(zmm29, dword_ptr(rdx, -512)._1to16(), 123)); + TEST_INSTRUCTION("62F1155072B2FCFDFFFF7B" , vpslld(zmm29, dword_ptr(rdx, -516)._1to16(), 123)); + TEST_INSTRUCTION("62D1CD4873F3AB" , vpsllq(zmm6, zmm11, 171)); + TEST_INSTRUCTION("62D1CD4A73F3AB" , k(k2).vpsllq(zmm6, zmm11, 171)); + TEST_INSTRUCTION("62D1CDCA73F3AB" , k(k2).z().vpsllq(zmm6, zmm11, 171)); + TEST_INSTRUCTION("62D1CD4873F37B" , vpsllq(zmm6, zmm11, 123)); + TEST_INSTRUCTION("62F1CD4873317B" , vpsllq(zmm6, zmmword_ptr(rcx), 123)); + TEST_INSTRUCTION("62B1CD4873B4F0230100007B" , vpsllq(zmm6, zmmword_ptr(rax, r14, 3, 291), 123)); + TEST_INSTRUCTION("62F1CD5873317B" , vpsllq(zmm6, qword_ptr(rcx)._1to8(), 123)); + TEST_INSTRUCTION("62F1CD4873727F7B" , vpsllq(zmm6, zmmword_ptr(rdx, 8128), 123)); + TEST_INSTRUCTION("62F1CD4873B2002000007B" , vpsllq(zmm6, zmmword_ptr(rdx, 8192), 123)); + TEST_INSTRUCTION("62F1CD487372807B" , vpsllq(zmm6, zmmword_ptr(rdx, -8192), 123)); + TEST_INSTRUCTION("62F1CD4873B2C0DFFFFF7B" , vpsllq(zmm6, zmmword_ptr(rdx, -8256), 123)); + TEST_INSTRUCTION("62F1CD5873727F7B" , vpsllq(zmm6, qword_ptr(rdx, 1016)._1to8(), 123)); + TEST_INSTRUCTION("62F1CD5873B2000400007B" , vpsllq(zmm6, qword_ptr(rdx, 1024)._1to8(), 123)); + TEST_INSTRUCTION("62F1CD587372807B" , vpsllq(zmm6, qword_ptr(rdx, -1024)._1to8(), 123)); + TEST_INSTRUCTION("62F1CD5873B2F8FBFFFF7B" , vpsllq(zmm6, qword_ptr(rdx, -1032)._1to8(), 123)); + TEST_INSTRUCTION("62F1254072E5AB" , vpsrad(zmm27, zmm5, 171)); + TEST_INSTRUCTION("62F1254572E5AB" , k(k5).vpsrad(zmm27, zmm5, 171)); + TEST_INSTRUCTION("62F125C572E5AB" , k(k5).z().vpsrad(zmm27, zmm5, 171)); + TEST_INSTRUCTION("62F1254072E57B" , vpsrad(zmm27, zmm5, 123)); + TEST_INSTRUCTION("62F1254072217B" , vpsrad(zmm27, zmmword_ptr(rcx), 123)); + TEST_INSTRUCTION("62B1254072A4F0230100007B" , vpsrad(zmm27, zmmword_ptr(rax, r14, 3, 291), 123)); + TEST_INSTRUCTION("62F1255072217B" , vpsrad(zmm27, dword_ptr(rcx)._1to16(), 123)); + TEST_INSTRUCTION("62F1254072627F7B" , vpsrad(zmm27, zmmword_ptr(rdx, 8128), 123)); + TEST_INSTRUCTION("62F1254072A2002000007B" , vpsrad(zmm27, zmmword_ptr(rdx, 8192), 123)); + TEST_INSTRUCTION("62F125407262807B" , vpsrad(zmm27, zmmword_ptr(rdx, -8192), 123)); + TEST_INSTRUCTION("62F1254072A2C0DFFFFF7B" , vpsrad(zmm27, zmmword_ptr(rdx, -8256), 123)); + TEST_INSTRUCTION("62F1255072627F7B" , vpsrad(zmm27, dword_ptr(rdx, 508)._1to16(), 123)); + TEST_INSTRUCTION("62F1255072A2000200007B" , vpsrad(zmm27, dword_ptr(rdx, 512)._1to16(), 123)); + TEST_INSTRUCTION("62F125507262807B" , vpsrad(zmm27, dword_ptr(rdx, -512)._1to16(), 123)); + TEST_INSTRUCTION("62F1255072A2FCFDFFFF7B" , vpsrad(zmm27, dword_ptr(rdx, -516)._1to16(), 123)); + TEST_INSTRUCTION("62F1954072E5AB" , vpsraq(zmm29, zmm5, 171)); + TEST_INSTRUCTION("62F1954472E5AB" , k(k4).vpsraq(zmm29, zmm5, 171)); + TEST_INSTRUCTION("62F195C472E5AB" , k(k4).z().vpsraq(zmm29, zmm5, 171)); + TEST_INSTRUCTION("62F1954072E57B" , vpsraq(zmm29, zmm5, 123)); + TEST_INSTRUCTION("62F1954072217B" , vpsraq(zmm29, zmmword_ptr(rcx), 123)); + TEST_INSTRUCTION("62B1954072A4F0230100007B" , vpsraq(zmm29, zmmword_ptr(rax, r14, 3, 291), 123)); + TEST_INSTRUCTION("62F1955072217B" , vpsraq(zmm29, qword_ptr(rcx)._1to8(), 123)); + TEST_INSTRUCTION("62F1954072627F7B" , vpsraq(zmm29, zmmword_ptr(rdx, 8128), 123)); + TEST_INSTRUCTION("62F1954072A2002000007B" , vpsraq(zmm29, zmmword_ptr(rdx, 8192), 123)); + TEST_INSTRUCTION("62F195407262807B" , vpsraq(zmm29, zmmword_ptr(rdx, -8192), 123)); + TEST_INSTRUCTION("62F1954072A2C0DFFFFF7B" , vpsraq(zmm29, zmmword_ptr(rdx, -8256), 123)); + TEST_INSTRUCTION("62F1955072627F7B" , vpsraq(zmm29, qword_ptr(rdx, 1016)._1to8(), 123)); + TEST_INSTRUCTION("62F1955072A2000400007B" , vpsraq(zmm29, qword_ptr(rdx, 1024)._1to8(), 123)); + TEST_INSTRUCTION("62F195507262807B" , vpsraq(zmm29, qword_ptr(rdx, -1024)._1to8(), 123)); + TEST_INSTRUCTION("62F1955072A2F8FBFFFF7B" , vpsraq(zmm29, qword_ptr(rdx, -1032)._1to8(), 123)); + TEST_INSTRUCTION("62B2154015F0" , vprolvd(zmm6, zmm29, zmm16)); + TEST_INSTRUCTION("62B2154215F0" , k(k2).vprolvd(zmm6, zmm29, zmm16)); + TEST_INSTRUCTION("62B215C215F0" , k(k2).z().vprolvd(zmm6, zmm29, zmm16)); + TEST_INSTRUCTION("62F215401531" , vprolvd(zmm6, zmm29, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62B2154015B4F023010000" , vprolvd(zmm6, zmm29, zmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62F215501531" , vprolvd(zmm6, zmm29, dword_ptr(rcx)._1to16())); + TEST_INSTRUCTION("62F2154015727F" , vprolvd(zmm6, zmm29, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62F2154015B200200000" , vprolvd(zmm6, zmm29, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62F21540157280" , vprolvd(zmm6, zmm29, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62F2154015B2C0DFFFFF" , vprolvd(zmm6, zmm29, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62F2155015727F" , vprolvd(zmm6, zmm29, dword_ptr(rdx, 508)._1to16())); + TEST_INSTRUCTION("62F2155015B200020000" , vprolvd(zmm6, zmm29, dword_ptr(rdx, 512)._1to16())); + TEST_INSTRUCTION("62F21550157280" , vprolvd(zmm6, zmm29, dword_ptr(rdx, -512)._1to16())); + TEST_INSTRUCTION("62F2155015B2FCFDFFFF" , vprolvd(zmm6, zmm29, dword_ptr(rdx, -516)._1to16())); + TEST_INSTRUCTION("62F12D4872CDAB" , vprold(zmm10, zmm5, 171)); + TEST_INSTRUCTION("62F12D4F72CDAB" , k(k7).vprold(zmm10, zmm5, 171)); + TEST_INSTRUCTION("62F12DCF72CDAB" , k(k7).z().vprold(zmm10, zmm5, 171)); + TEST_INSTRUCTION("62F12D4872CD7B" , vprold(zmm10, zmm5, 123)); + TEST_INSTRUCTION("62F12D4872097B" , vprold(zmm10, zmmword_ptr(rcx), 123)); + TEST_INSTRUCTION("62B12D48728CF0230100007B" , vprold(zmm10, zmmword_ptr(rax, r14, 3, 291), 123)); + TEST_INSTRUCTION("62F12D5872097B" , vprold(zmm10, dword_ptr(rcx)._1to16(), 123)); + TEST_INSTRUCTION("62F12D48724A7F7B" , vprold(zmm10, zmmword_ptr(rdx, 8128), 123)); + TEST_INSTRUCTION("62F12D48728A002000007B" , vprold(zmm10, zmmword_ptr(rdx, 8192), 123)); + TEST_INSTRUCTION("62F12D48724A807B" , vprold(zmm10, zmmword_ptr(rdx, -8192), 123)); + TEST_INSTRUCTION("62F12D48728AC0DFFFFF7B" , vprold(zmm10, zmmword_ptr(rdx, -8256), 123)); + TEST_INSTRUCTION("62F12D58724A7F7B" , vprold(zmm10, dword_ptr(rdx, 508)._1to16(), 123)); + TEST_INSTRUCTION("62F12D58728A000200007B" , vprold(zmm10, dword_ptr(rdx, 512)._1to16(), 123)); + TEST_INSTRUCTION("62F12D58724A807B" , vprold(zmm10, dword_ptr(rdx, -512)._1to16(), 123)); + TEST_INSTRUCTION("62F12D58728AFCFDFFFF7B" , vprold(zmm10, dword_ptr(rdx, -516)._1to16(), 123)); + TEST_INSTRUCTION("6262DD4815DE" , vprolvq(zmm27, zmm4, zmm6)); + TEST_INSTRUCTION("6262DD4D15DE" , k(k5).vprolvq(zmm27, zmm4, zmm6)); + TEST_INSTRUCTION("6262DDCD15DE" , k(k5).z().vprolvq(zmm27, zmm4, zmm6)); + TEST_INSTRUCTION("6262DD481519" , vprolvq(zmm27, zmm4, zmmword_ptr(rcx))); + TEST_INSTRUCTION("6222DD48159CF023010000" , vprolvq(zmm27, zmm4, zmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("6262DD581519" , vprolvq(zmm27, zmm4, qword_ptr(rcx)._1to8())); + TEST_INSTRUCTION("6262DD48155A7F" , vprolvq(zmm27, zmm4, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("6262DD48159A00200000" , vprolvq(zmm27, zmm4, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("6262DD48155A80" , vprolvq(zmm27, zmm4, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("6262DD48159AC0DFFFFF" , vprolvq(zmm27, zmm4, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("6262DD58155A7F" , vprolvq(zmm27, zmm4, qword_ptr(rdx, 1016)._1to8())); + TEST_INSTRUCTION("6262DD58159A00040000" , vprolvq(zmm27, zmm4, qword_ptr(rdx, 1024)._1to8())); + TEST_INSTRUCTION("6262DD58155A80" , vprolvq(zmm27, zmm4, qword_ptr(rdx, -1024)._1to8())); + TEST_INSTRUCTION("6262DD58159AF8FBFFFF" , vprolvq(zmm27, zmm4, qword_ptr(rdx, -1032)._1to8())); + TEST_INSTRUCTION("62B1E54072CAAB" , vprolq(zmm19, zmm18, 171)); + TEST_INSTRUCTION("62B1E54372CAAB" , k(k3).vprolq(zmm19, zmm18, 171)); + TEST_INSTRUCTION("62B1E5C372CAAB" , k(k3).z().vprolq(zmm19, zmm18, 171)); + TEST_INSTRUCTION("62B1E54072CA7B" , vprolq(zmm19, zmm18, 123)); + TEST_INSTRUCTION("62F1E54072097B" , vprolq(zmm19, zmmword_ptr(rcx), 123)); + TEST_INSTRUCTION("62B1E540728CF0230100007B" , vprolq(zmm19, zmmword_ptr(rax, r14, 3, 291), 123)); + TEST_INSTRUCTION("62F1E55072097B" , vprolq(zmm19, qword_ptr(rcx)._1to8(), 123)); + TEST_INSTRUCTION("62F1E540724A7F7B" , vprolq(zmm19, zmmword_ptr(rdx, 8128), 123)); + TEST_INSTRUCTION("62F1E540728A002000007B" , vprolq(zmm19, zmmword_ptr(rdx, 8192), 123)); + TEST_INSTRUCTION("62F1E540724A807B" , vprolq(zmm19, zmmword_ptr(rdx, -8192), 123)); + TEST_INSTRUCTION("62F1E540728AC0DFFFFF7B" , vprolq(zmm19, zmmword_ptr(rdx, -8256), 123)); + TEST_INSTRUCTION("62F1E550724A7F7B" , vprolq(zmm19, qword_ptr(rdx, 1016)._1to8(), 123)); + TEST_INSTRUCTION("62F1E550728A000400007B" , vprolq(zmm19, qword_ptr(rdx, 1024)._1to8(), 123)); + TEST_INSTRUCTION("62F1E550724A807B" , vprolq(zmm19, qword_ptr(rdx, -1024)._1to8(), 123)); + TEST_INSTRUCTION("62F1E550728AF8FBFFFF7B" , vprolq(zmm19, qword_ptr(rdx, -1032)._1to8(), 123)); + TEST_INSTRUCTION("62125D4014DC" , vprorvd(zmm11, zmm20, zmm28)); + TEST_INSTRUCTION("62125D4214DC" , k(k2).vprorvd(zmm11, zmm20, zmm28)); + TEST_INSTRUCTION("62125DC214DC" , k(k2).z().vprorvd(zmm11, zmm20, zmm28)); + TEST_INSTRUCTION("62725D401419" , vprorvd(zmm11, zmm20, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62325D40149CF023010000" , vprorvd(zmm11, zmm20, zmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62725D501419" , vprorvd(zmm11, zmm20, dword_ptr(rcx)._1to16())); + TEST_INSTRUCTION("62725D40145A7F" , vprorvd(zmm11, zmm20, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62725D40149A00200000" , vprorvd(zmm11, zmm20, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62725D40145A80" , vprorvd(zmm11, zmm20, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62725D40149AC0DFFFFF" , vprorvd(zmm11, zmm20, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62725D50145A7F" , vprorvd(zmm11, zmm20, dword_ptr(rdx, 508)._1to16())); + TEST_INSTRUCTION("62725D50149A00020000" , vprorvd(zmm11, zmm20, dword_ptr(rdx, 512)._1to16())); + TEST_INSTRUCTION("62725D50145A80" , vprorvd(zmm11, zmm20, dword_ptr(rdx, -512)._1to16())); + TEST_INSTRUCTION("62725D50149AFCFDFFFF" , vprorvd(zmm11, zmm20, dword_ptr(rdx, -516)._1to16())); + TEST_INSTRUCTION("62D1354872C2AB" , vprord(zmm9, zmm10, 171)); + TEST_INSTRUCTION("62D1354F72C2AB" , k(k7).vprord(zmm9, zmm10, 171)); + TEST_INSTRUCTION("62D135CF72C2AB" , k(k7).z().vprord(zmm9, zmm10, 171)); + TEST_INSTRUCTION("62D1354872C27B" , vprord(zmm9, zmm10, 123)); + TEST_INSTRUCTION("62F1354872017B" , vprord(zmm9, zmmword_ptr(rcx), 123)); + TEST_INSTRUCTION("62B135487284F0230100007B" , vprord(zmm9, zmmword_ptr(rax, r14, 3, 291), 123)); + TEST_INSTRUCTION("62F1355872017B" , vprord(zmm9, dword_ptr(rcx)._1to16(), 123)); + TEST_INSTRUCTION("62F1354872427F7B" , vprord(zmm9, zmmword_ptr(rdx, 8128), 123)); + TEST_INSTRUCTION("62F135487282002000007B" , vprord(zmm9, zmmword_ptr(rdx, 8192), 123)); + TEST_INSTRUCTION("62F135487242807B" , vprord(zmm9, zmmword_ptr(rdx, -8192), 123)); + TEST_INSTRUCTION("62F135487282C0DFFFFF7B" , vprord(zmm9, zmmword_ptr(rdx, -8256), 123)); + TEST_INSTRUCTION("62F1355872427F7B" , vprord(zmm9, dword_ptr(rdx, 508)._1to16(), 123)); + TEST_INSTRUCTION("62F135587282000200007B" , vprord(zmm9, dword_ptr(rdx, 512)._1to16(), 123)); + TEST_INSTRUCTION("62F135587242807B" , vprord(zmm9, dword_ptr(rdx, -512)._1to16(), 123)); + TEST_INSTRUCTION("62F135587282FCFDFFFF7B" , vprord(zmm9, dword_ptr(rdx, -516)._1to16(), 123)); + TEST_INSTRUCTION("6272BD4014F1" , vprorvq(zmm14, zmm24, zmm1)); + TEST_INSTRUCTION("6272BD4714F1" , k(k7).vprorvq(zmm14, zmm24, zmm1)); + TEST_INSTRUCTION("6272BDC714F1" , k(k7).z().vprorvq(zmm14, zmm24, zmm1)); + TEST_INSTRUCTION("6272BD401431" , vprorvq(zmm14, zmm24, zmmword_ptr(rcx))); + TEST_INSTRUCTION("6232BD4014B4F023010000" , vprorvq(zmm14, zmm24, zmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("6272BD501431" , vprorvq(zmm14, zmm24, qword_ptr(rcx)._1to8())); + TEST_INSTRUCTION("6272BD4014727F" , vprorvq(zmm14, zmm24, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("6272BD4014B200200000" , vprorvq(zmm14, zmm24, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("6272BD40147280" , vprorvq(zmm14, zmm24, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("6272BD4014B2C0DFFFFF" , vprorvq(zmm14, zmm24, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("6272BD5014727F" , vprorvq(zmm14, zmm24, qword_ptr(rdx, 1016)._1to8())); + TEST_INSTRUCTION("6272BD5014B200040000" , vprorvq(zmm14, zmm24, qword_ptr(rdx, 1024)._1to8())); + TEST_INSTRUCTION("6272BD50147280" , vprorvq(zmm14, zmm24, qword_ptr(rdx, -1024)._1to8())); + TEST_INSTRUCTION("6272BD5014B2F8FBFFFF" , vprorvq(zmm14, zmm24, qword_ptr(rdx, -1032)._1to8())); + TEST_INSTRUCTION("6291D54072C1AB" , vprorq(zmm21, zmm25, 171)); + TEST_INSTRUCTION("6291D54672C1AB" , k(k6).vprorq(zmm21, zmm25, 171)); + TEST_INSTRUCTION("6291D5C672C1AB" , k(k6).z().vprorq(zmm21, zmm25, 171)); + TEST_INSTRUCTION("6291D54072C17B" , vprorq(zmm21, zmm25, 123)); + TEST_INSTRUCTION("62F1D54072017B" , vprorq(zmm21, zmmword_ptr(rcx), 123)); + TEST_INSTRUCTION("62B1D5407284F0230100007B" , vprorq(zmm21, zmmword_ptr(rax, r14, 3, 291), 123)); + TEST_INSTRUCTION("62F1D55072017B" , vprorq(zmm21, qword_ptr(rcx)._1to8(), 123)); + TEST_INSTRUCTION("62F1D54072427F7B" , vprorq(zmm21, zmmword_ptr(rdx, 8128), 123)); + TEST_INSTRUCTION("62F1D5407282002000007B" , vprorq(zmm21, zmmword_ptr(rdx, 8192), 123)); + TEST_INSTRUCTION("62F1D5407242807B" , vprorq(zmm21, zmmword_ptr(rdx, -8192), 123)); + TEST_INSTRUCTION("62F1D5407282C0DFFFFF7B" , vprorq(zmm21, zmmword_ptr(rdx, -8256), 123)); + TEST_INSTRUCTION("62F1D55072427F7B" , vprorq(zmm21, qword_ptr(rdx, 1016)._1to8(), 123)); + TEST_INSTRUCTION("62F1D5507282000400007B" , vprorq(zmm21, qword_ptr(rdx, 1024)._1to8(), 123)); + TEST_INSTRUCTION("62F1D5507242807B" , vprorq(zmm21, qword_ptr(rdx, -1024)._1to8(), 123)); + TEST_INSTRUCTION("62F1D5507282F8FBFFFF7B" , vprorq(zmm21, qword_ptr(rdx, -1032)._1to8(), 123)); + TEST_INSTRUCTION("62E3FD4809F7AB" , vrndscalepd(zmm22, zmm7, 171)); + TEST_INSTRUCTION("62E3FD4909F7AB" , k(k1).vrndscalepd(zmm22, zmm7, 171)); + TEST_INSTRUCTION("62E3FDC909F7AB" , k(k1).z().vrndscalepd(zmm22, zmm7, 171)); + TEST_INSTRUCTION("62E3FD1809F7AB" , sae().vrndscalepd(zmm22, zmm7, 171)); + TEST_INSTRUCTION("62E3FD4809F77B" , vrndscalepd(zmm22, zmm7, 123)); + TEST_INSTRUCTION("62E3FD1809F77B" , sae().vrndscalepd(zmm22, zmm7, 123)); + TEST_INSTRUCTION("62E3FD4809317B" , vrndscalepd(zmm22, zmmword_ptr(rcx), 123)); + TEST_INSTRUCTION("62A3FD4809B4F0230100007B" , vrndscalepd(zmm22, zmmword_ptr(rax, r14, 3, 291), 123)); + TEST_INSTRUCTION("62E3FD5809317B" , vrndscalepd(zmm22, qword_ptr(rcx)._1to8(), 123)); + TEST_INSTRUCTION("62E3FD4809727F7B" , vrndscalepd(zmm22, zmmword_ptr(rdx, 8128), 123)); + TEST_INSTRUCTION("62E3FD4809B2002000007B" , vrndscalepd(zmm22, zmmword_ptr(rdx, 8192), 123)); + TEST_INSTRUCTION("62E3FD480972807B" , vrndscalepd(zmm22, zmmword_ptr(rdx, -8192), 123)); + TEST_INSTRUCTION("62E3FD4809B2C0DFFFFF7B" , vrndscalepd(zmm22, zmmword_ptr(rdx, -8256), 123)); + TEST_INSTRUCTION("62E3FD5809727F7B" , vrndscalepd(zmm22, qword_ptr(rdx, 1016)._1to8(), 123)); + TEST_INSTRUCTION("62E3FD5809B2000400007B" , vrndscalepd(zmm22, qword_ptr(rdx, 1024)._1to8(), 123)); + TEST_INSTRUCTION("62E3FD580972807B" , vrndscalepd(zmm22, qword_ptr(rdx, -1024)._1to8(), 123)); + TEST_INSTRUCTION("62E3FD5809B2F8FBFFFF7B" , vrndscalepd(zmm22, qword_ptr(rdx, -1032)._1to8(), 123)); + TEST_INSTRUCTION("62737D4808EFAB" , vrndscaleps(zmm13, zmm7, 171)); + TEST_INSTRUCTION("62737D4908EFAB" , k(k1).vrndscaleps(zmm13, zmm7, 171)); + TEST_INSTRUCTION("62737DC908EFAB" , k(k1).z().vrndscaleps(zmm13, zmm7, 171)); + TEST_INSTRUCTION("62737D1808EFAB" , sae().vrndscaleps(zmm13, zmm7, 171)); + TEST_INSTRUCTION("62737D4808EF7B" , vrndscaleps(zmm13, zmm7, 123)); + TEST_INSTRUCTION("62737D1808EF7B" , sae().vrndscaleps(zmm13, zmm7, 123)); + TEST_INSTRUCTION("62737D4808297B" , vrndscaleps(zmm13, zmmword_ptr(rcx), 123)); + TEST_INSTRUCTION("62337D4808ACF0230100007B" , vrndscaleps(zmm13, zmmword_ptr(rax, r14, 3, 291), 123)); + TEST_INSTRUCTION("62737D5808297B" , vrndscaleps(zmm13, dword_ptr(rcx)._1to16(), 123)); + TEST_INSTRUCTION("62737D48086A7F7B" , vrndscaleps(zmm13, zmmword_ptr(rdx, 8128), 123)); + TEST_INSTRUCTION("62737D4808AA002000007B" , vrndscaleps(zmm13, zmmword_ptr(rdx, 8192), 123)); + TEST_INSTRUCTION("62737D48086A807B" , vrndscaleps(zmm13, zmmword_ptr(rdx, -8192), 123)); + TEST_INSTRUCTION("62737D4808AAC0DFFFFF7B" , vrndscaleps(zmm13, zmmword_ptr(rdx, -8256), 123)); + TEST_INSTRUCTION("62737D58086A7F7B" , vrndscaleps(zmm13, dword_ptr(rdx, 508)._1to16(), 123)); + TEST_INSTRUCTION("62737D5808AA000200007B" , vrndscaleps(zmm13, dword_ptr(rdx, 512)._1to16(), 123)); + TEST_INSTRUCTION("62737D58086A807B" , vrndscaleps(zmm13, dword_ptr(rdx, -512)._1to16(), 123)); + TEST_INSTRUCTION("62737D5808AAFCFDFFFF7B" , vrndscaleps(zmm13, dword_ptr(rdx, -516)._1to16(), 123)); + TEST_INSTRUCTION("62439D080BCFAB" , vrndscalesd(xmm25, xmm12, xmm15, 171)); + TEST_INSTRUCTION("62439D0E0BCFAB" , k(k6).vrndscalesd(xmm25, xmm12, xmm15, 171)); + TEST_INSTRUCTION("62439D8E0BCFAB" , k(k6).z().vrndscalesd(xmm25, xmm12, xmm15, 171)); + TEST_INSTRUCTION("62439D180BCFAB" , sae().vrndscalesd(xmm25, xmm12, xmm15, 171)); + TEST_INSTRUCTION("62439D080BCF7B" , vrndscalesd(xmm25, xmm12, xmm15, 123)); + TEST_INSTRUCTION("62439D180BCF7B" , sae().vrndscalesd(xmm25, xmm12, xmm15, 123)); + TEST_INSTRUCTION("62639D080B097B" , vrndscalesd(xmm25, xmm12, qword_ptr(rcx), 123)); + TEST_INSTRUCTION("62239D080B8CF0230100007B" , vrndscalesd(xmm25, xmm12, qword_ptr(rax, r14, 3, 291), 123)); + TEST_INSTRUCTION("62639D080B4A7F7B" , vrndscalesd(xmm25, xmm12, qword_ptr(rdx, 1016), 123)); + TEST_INSTRUCTION("62639D080B8A000400007B" , vrndscalesd(xmm25, xmm12, qword_ptr(rdx, 1024), 123)); + TEST_INSTRUCTION("62639D080B4A807B" , vrndscalesd(xmm25, xmm12, qword_ptr(rdx, -1024), 123)); + TEST_INSTRUCTION("62639D080B8AF8FBFFFF7B" , vrndscalesd(xmm25, xmm12, qword_ptr(rdx, -1032), 123)); + TEST_INSTRUCTION("623325080AD9AB" , vrndscaless(xmm11, xmm11, xmm17, 171)); + TEST_INSTRUCTION("6233250B0AD9AB" , k(k3).vrndscaless(xmm11, xmm11, xmm17, 171)); + TEST_INSTRUCTION("6233258B0AD9AB" , k(k3).z().vrndscaless(xmm11, xmm11, xmm17, 171)); + TEST_INSTRUCTION("623325180AD9AB" , sae().vrndscaless(xmm11, xmm11, xmm17, 171)); + TEST_INSTRUCTION("623325080AD97B" , vrndscaless(xmm11, xmm11, xmm17, 123)); + TEST_INSTRUCTION("623325180AD97B" , sae().vrndscaless(xmm11, xmm11, xmm17, 123)); + TEST_INSTRUCTION("627325080A197B" , vrndscaless(xmm11, xmm11, dword_ptr(rcx), 123)); + TEST_INSTRUCTION("623325080A9CF0230100007B" , vrndscaless(xmm11, xmm11, dword_ptr(rax, r14, 3, 291), 123)); + TEST_INSTRUCTION("627325080A5A7F7B" , vrndscaless(xmm11, xmm11, dword_ptr(rdx, 508), 123)); + TEST_INSTRUCTION("627325080A9A000200007B" , vrndscaless(xmm11, xmm11, dword_ptr(rdx, 512), 123)); + TEST_INSTRUCTION("627325080A5A807B" , vrndscaless(xmm11, xmm11, dword_ptr(rdx, -512), 123)); + TEST_INSTRUCTION("627325080A9AFCFDFFFF7B" , vrndscaless(xmm11, xmm11, dword_ptr(rdx, -516), 123)); + TEST_INSTRUCTION("6272FD488B19" , vpcompressq(zmmword_ptr(rcx), zmm11)); + TEST_INSTRUCTION("6272FD4F8B19" , k(k7).vpcompressq(zmmword_ptr(rcx), zmm11)); + TEST_INSTRUCTION("6232FD488B9CF023010000" , vpcompressq(zmmword_ptr(rax, r14, 3, 291), zmm11)); + TEST_INSTRUCTION("6272FD488B5A7F" , vpcompressq(zmmword_ptr(rdx, 1016), zmm11)); + TEST_INSTRUCTION("6272FD488B9A00040000" , vpcompressq(zmmword_ptr(rdx, 1024), zmm11)); + TEST_INSTRUCTION("6272FD488B5A80" , vpcompressq(zmmword_ptr(rdx, -1024), zmm11)); + TEST_INSTRUCTION("6272FD488B9AF8FBFFFF" , vpcompressq(zmmword_ptr(rdx, -1032), zmm11)); + TEST_INSTRUCTION("62A2FD488BD9" , vpcompressq(zmm17, zmm19)); + TEST_INSTRUCTION("62A2FD4A8BD9" , k(k2).vpcompressq(zmm17, zmm19)); + TEST_INSTRUCTION("62A2FDCA8BD9" , k(k2).z().vpcompressq(zmm17, zmm19)); + TEST_INSTRUCTION("C5D441D6" , kandw(k2, k5, k6)); + TEST_INSTRUCTION("C5CC42E7" , kandnw(k4, k6, k7)); + TEST_INSTRUCTION("C5CC45E7" , korw(k4, k6, k7)); + TEST_INSTRUCTION("C5D446DD" , kxnorw(k3, k5, k5)); + TEST_INSTRUCTION("C5CC47D7" , kxorw(k2, k6, k7)); + TEST_INSTRUCTION("C5F844DE" , knotw(k3, k6)); + TEST_INSTRUCTION("C5F898D6" , kortestw(k2, k6)); + TEST_INSTRUCTION("C4E3F930E4AB" , kshiftrw(k4, k4, 171)); + TEST_INSTRUCTION("C4E3F930E47B" , kshiftrw(k4, k4, 123)); + TEST_INSTRUCTION("C4E3F932D5AB" , kshiftlw(k2, k5, 171)); + TEST_INSTRUCTION("C4E3F932D57B" , kshiftlw(k2, k5, 123)); + TEST_INSTRUCTION("C5F890E5" , kmovw(k4, k5)); + TEST_INSTRUCTION("C5F89021" , kmovw(k4, word_ptr(rcx))); + TEST_INSTRUCTION("C4A17890A4F023010000" , kmovw(k4, word_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("C5F89121" , kmovw(word_ptr(rcx), k4)); + TEST_INSTRUCTION("C4A17891A4F023010000" , kmovw(word_ptr(rax, r14, 3, 291), k4)); + TEST_INSTRUCTION("C5F892D8" , kmovw(k3, eax)); + TEST_INSTRUCTION("C5F892DD" , kmovw(k3, ebp)); + TEST_INSTRUCTION("C4C17892DD" , kmovw(k3, r13d)); + TEST_INSTRUCTION("C5F893C2" , kmovw(eax, k2)); + TEST_INSTRUCTION("C5F893EA" , kmovw(ebp, k2)); + TEST_INSTRUCTION("C57893EA" , kmovw(r13d, k2)); + TEST_INSTRUCTION("C5D54BEE" , kunpckbw(k5, k5, k6)); + TEST_INSTRUCTION("62E37D481D19AB" , vcvtps2ph(ymmword_ptr(rcx), zmm19, 171)); + TEST_INSTRUCTION("62E37D4E1D19AB" , k(k6).vcvtps2ph(ymmword_ptr(rcx), zmm19, 171)); + TEST_INSTRUCTION("62E37D481D197B" , vcvtps2ph(ymmword_ptr(rcx), zmm19, 123)); + TEST_INSTRUCTION("62A37D481D9CF0230100007B" , vcvtps2ph(ymmword_ptr(rax, r14, 3, 291), zmm19, 123)); + TEST_INSTRUCTION("62E37D481D5A7F7B" , vcvtps2ph(ymmword_ptr(rdx, 4064), zmm19, 123)); + TEST_INSTRUCTION("62E37D481D9A001000007B" , vcvtps2ph(ymmword_ptr(rdx, 4096), zmm19, 123)); + TEST_INSTRUCTION("62E37D481D5A807B" , vcvtps2ph(ymmword_ptr(rdx, -4096), zmm19, 123)); + TEST_INSTRUCTION("62E37D481D9AE0EFFFFF7B" , vcvtps2ph(ymmword_ptr(rdx, -4128), zmm19, 123)); + TEST_INSTRUCTION("62E37D481921AB" , vextractf32x4(xmmword_ptr(rcx), zmm20, 171)); + TEST_INSTRUCTION("62E37D4F1921AB" , k(k7).vextractf32x4(xmmword_ptr(rcx), zmm20, 171)); + TEST_INSTRUCTION("62E37D4819217B" , vextractf32x4(xmmword_ptr(rcx), zmm20, 123)); + TEST_INSTRUCTION("62A37D4819A4F0230100007B" , vextractf32x4(xmmword_ptr(rax, r14, 3, 291), zmm20, 123)); + TEST_INSTRUCTION("62E37D4819627F7B" , vextractf32x4(xmmword_ptr(rdx, 2032), zmm20, 123)); + TEST_INSTRUCTION("62E37D4819A2000800007B" , vextractf32x4(xmmword_ptr(rdx, 2048), zmm20, 123)); + TEST_INSTRUCTION("62E37D481962807B" , vextractf32x4(xmmword_ptr(rdx, -2048), zmm20, 123)); + TEST_INSTRUCTION("62E37D4819A2F0F7FFFF7B" , vextractf32x4(xmmword_ptr(rdx, -2064), zmm20, 123)); + TEST_INSTRUCTION("62F3FD481B29AB" , vextractf64x4(ymmword_ptr(rcx), zmm5, 171)); + TEST_INSTRUCTION("62F3FD4C1B29AB" , k(k4).vextractf64x4(ymmword_ptr(rcx), zmm5, 171)); + TEST_INSTRUCTION("62F3FD481B297B" , vextractf64x4(ymmword_ptr(rcx), zmm5, 123)); + TEST_INSTRUCTION("62B3FD481BACF0230100007B" , vextractf64x4(ymmword_ptr(rax, r14, 3, 291), zmm5, 123)); + TEST_INSTRUCTION("62F3FD481B6A7F7B" , vextractf64x4(ymmword_ptr(rdx, 4064), zmm5, 123)); + TEST_INSTRUCTION("62F3FD481BAA001000007B" , vextractf64x4(ymmword_ptr(rdx, 4096), zmm5, 123)); + TEST_INSTRUCTION("62F3FD481B6A807B" , vextractf64x4(ymmword_ptr(rdx, -4096), zmm5, 123)); + TEST_INSTRUCTION("62F3FD481BAAE0EFFFFF7B" , vextractf64x4(ymmword_ptr(rdx, -4128), zmm5, 123)); + TEST_INSTRUCTION("62637D483929AB" , vextracti32x4(xmmword_ptr(rcx), zmm29, 171)); + TEST_INSTRUCTION("62637D4A3929AB" , k(k2).vextracti32x4(xmmword_ptr(rcx), zmm29, 171)); + TEST_INSTRUCTION("62637D4839297B" , vextracti32x4(xmmword_ptr(rcx), zmm29, 123)); + TEST_INSTRUCTION("62237D4839ACF0230100007B" , vextracti32x4(xmmword_ptr(rax, r14, 3, 291), zmm29, 123)); + TEST_INSTRUCTION("62637D48396A7F7B" , vextracti32x4(xmmword_ptr(rdx, 2032), zmm29, 123)); + TEST_INSTRUCTION("62637D4839AA000800007B" , vextracti32x4(xmmword_ptr(rdx, 2048), zmm29, 123)); + TEST_INSTRUCTION("62637D48396A807B" , vextracti32x4(xmmword_ptr(rdx, -2048), zmm29, 123)); + TEST_INSTRUCTION("62637D4839AAF0F7FFFF7B" , vextracti32x4(xmmword_ptr(rdx, -2064), zmm29, 123)); + TEST_INSTRUCTION("6263FD483B31AB" , vextracti64x4(ymmword_ptr(rcx), zmm30, 171)); + TEST_INSTRUCTION("6263FD4C3B31AB" , k(k4).vextracti64x4(ymmword_ptr(rcx), zmm30, 171)); + TEST_INSTRUCTION("6263FD483B317B" , vextracti64x4(ymmword_ptr(rcx), zmm30, 123)); + TEST_INSTRUCTION("6223FD483BB4F0230100007B" , vextracti64x4(ymmword_ptr(rax, r14, 3, 291), zmm30, 123)); + TEST_INSTRUCTION("6263FD483B727F7B" , vextracti64x4(ymmword_ptr(rdx, 4064), zmm30, 123)); + TEST_INSTRUCTION("6263FD483BB2001000007B" , vextracti64x4(ymmword_ptr(rdx, 4096), zmm30, 123)); + TEST_INSTRUCTION("6263FD483B72807B" , vextracti64x4(ymmword_ptr(rdx, -4096), zmm30, 123)); + TEST_INSTRUCTION("6263FD483BB2E0EFFFFF7B" , vextracti64x4(ymmword_ptr(rdx, -4128), zmm30, 123)); + TEST_INSTRUCTION("62E1FD482911" , vmovapd(zmmword_ptr(rcx), zmm18)); + TEST_INSTRUCTION("62E1FD4E2911" , k(k6).vmovapd(zmmword_ptr(rcx), zmm18)); + TEST_INSTRUCTION("62A1FD482994F023010000" , vmovapd(zmmword_ptr(rax, r14, 3, 291), zmm18)); + TEST_INSTRUCTION("62E1FD4829527F" , vmovapd(zmmword_ptr(rdx, 8128), zmm18)); + TEST_INSTRUCTION("62E1FD48299200200000" , vmovapd(zmmword_ptr(rdx, 8192), zmm18)); + TEST_INSTRUCTION("62E1FD48295280" , vmovapd(zmmword_ptr(rdx, -8192), zmm18)); + TEST_INSTRUCTION("62E1FD482992C0DFFFFF" , vmovapd(zmmword_ptr(rdx, -8256), zmm18)); + TEST_INSTRUCTION("62717C482909" , vmovaps(zmmword_ptr(rcx), zmm9)); + TEST_INSTRUCTION("62717C4B2909" , k(k3).vmovaps(zmmword_ptr(rcx), zmm9)); + TEST_INSTRUCTION("62317C48298CF023010000" , vmovaps(zmmword_ptr(rax, r14, 3, 291), zmm9)); + TEST_INSTRUCTION("62717C48294A7F" , vmovaps(zmmword_ptr(rdx, 8128), zmm9)); + TEST_INSTRUCTION("62717C48298A00200000" , vmovaps(zmmword_ptr(rdx, 8192), zmm9)); + TEST_INSTRUCTION("62717C48294A80" , vmovaps(zmmword_ptr(rdx, -8192), zmm9)); + TEST_INSTRUCTION("62717C48298AC0DFFFFF" , vmovaps(zmmword_ptr(rdx, -8256), zmm9)); + TEST_INSTRUCTION("62E17D487F11" , vmovdqa32(zmmword_ptr(rcx), zmm18)); + TEST_INSTRUCTION("62E17D4C7F11" , k(k4).vmovdqa32(zmmword_ptr(rcx), zmm18)); + TEST_INSTRUCTION("62A17D487F94F023010000" , vmovdqa32(zmmword_ptr(rax, r14, 3, 291), zmm18)); + TEST_INSTRUCTION("62E17D487F527F" , vmovdqa32(zmmword_ptr(rdx, 8128), zmm18)); + TEST_INSTRUCTION("62E17D487F9200200000" , vmovdqa32(zmmword_ptr(rdx, 8192), zmm18)); + TEST_INSTRUCTION("62E17D487F5280" , vmovdqa32(zmmword_ptr(rdx, -8192), zmm18)); + TEST_INSTRUCTION("62E17D487F92C0DFFFFF" , vmovdqa32(zmmword_ptr(rdx, -8256), zmm18)); + TEST_INSTRUCTION("62E1FD487F19" , vmovdqa64(zmmword_ptr(rcx), zmm19)); + TEST_INSTRUCTION("62E1FD4D7F19" , k(k5).vmovdqa64(zmmword_ptr(rcx), zmm19)); + TEST_INSTRUCTION("62A1FD487F9CF023010000" , vmovdqa64(zmmword_ptr(rax, r14, 3, 291), zmm19)); + TEST_INSTRUCTION("62E1FD487F5A7F" , vmovdqa64(zmmword_ptr(rdx, 8128), zmm19)); + TEST_INSTRUCTION("62E1FD487F9A00200000" , vmovdqa64(zmmword_ptr(rdx, 8192), zmm19)); + TEST_INSTRUCTION("62E1FD487F5A80" , vmovdqa64(zmmword_ptr(rdx, -8192), zmm19)); + TEST_INSTRUCTION("62E1FD487F9AC0DFFFFF" , vmovdqa64(zmmword_ptr(rdx, -8256), zmm19)); + TEST_INSTRUCTION("62E17E487F31" , vmovdqu32(zmmword_ptr(rcx), zmm22)); + TEST_INSTRUCTION("62E17E497F31" , k(k1).vmovdqu32(zmmword_ptr(rcx), zmm22)); + TEST_INSTRUCTION("62A17E487FB4F023010000" , vmovdqu32(zmmword_ptr(rax, r14, 3, 291), zmm22)); + TEST_INSTRUCTION("62E17E487F727F" , vmovdqu32(zmmword_ptr(rdx, 8128), zmm22)); + TEST_INSTRUCTION("62E17E487FB200200000" , vmovdqu32(zmmword_ptr(rdx, 8192), zmm22)); + TEST_INSTRUCTION("62E17E487F7280" , vmovdqu32(zmmword_ptr(rdx, -8192), zmm22)); + TEST_INSTRUCTION("62E17E487FB2C0DFFFFF" , vmovdqu32(zmmword_ptr(rdx, -8256), zmm22)); + TEST_INSTRUCTION("6261FE487F01" , vmovdqu64(zmmword_ptr(rcx), zmm24)); + TEST_INSTRUCTION("6261FE4D7F01" , k(k5).vmovdqu64(zmmword_ptr(rcx), zmm24)); + TEST_INSTRUCTION("6221FE487F84F023010000" , vmovdqu64(zmmword_ptr(rax, r14, 3, 291), zmm24)); + TEST_INSTRUCTION("6261FE487F427F" , vmovdqu64(zmmword_ptr(rdx, 8128), zmm24)); + TEST_INSTRUCTION("6261FE487F8200200000" , vmovdqu64(zmmword_ptr(rdx, 8192), zmm24)); + TEST_INSTRUCTION("6261FE487F4280" , vmovdqu64(zmmword_ptr(rdx, -8192), zmm24)); + TEST_INSTRUCTION("6261FE487F82C0DFFFFF" , vmovdqu64(zmmword_ptr(rdx, -8256), zmm24)); + TEST_INSTRUCTION("6271FD481111" , vmovupd(zmmword_ptr(rcx), zmm10)); + TEST_INSTRUCTION("6271FD4F1111" , k(k7).vmovupd(zmmword_ptr(rcx), zmm10)); + TEST_INSTRUCTION("6231FD481194F023010000" , vmovupd(zmmword_ptr(rax, r14, 3, 291), zmm10)); + TEST_INSTRUCTION("6271FD4811527F" , vmovupd(zmmword_ptr(rdx, 8128), zmm10)); + TEST_INSTRUCTION("6271FD48119200200000" , vmovupd(zmmword_ptr(rdx, 8192), zmm10)); + TEST_INSTRUCTION("6271FD48115280" , vmovupd(zmmword_ptr(rdx, -8192), zmm10)); + TEST_INSTRUCTION("6271FD481192C0DFFFFF" , vmovupd(zmmword_ptr(rdx, -8256), zmm10)); + TEST_INSTRUCTION("62617C481101" , vmovups(zmmword_ptr(rcx), zmm24)); + TEST_INSTRUCTION("62617C4F1101" , k(k7).vmovups(zmmword_ptr(rcx), zmm24)); + TEST_INSTRUCTION("62217C481184F023010000" , vmovups(zmmword_ptr(rax, r14, 3, 291), zmm24)); + TEST_INSTRUCTION("62617C4811427F" , vmovups(zmmword_ptr(rdx, 8128), zmm24)); + TEST_INSTRUCTION("62617C48118200200000" , vmovups(zmmword_ptr(rdx, 8192), zmm24)); + TEST_INSTRUCTION("62617C48114280" , vmovups(zmmword_ptr(rdx, -8192), zmm24)); + TEST_INSTRUCTION("62617C481182C0DFFFFF" , vmovups(zmmword_ptr(rdx, -8256), zmm24)); + TEST_INSTRUCTION("62F27E483219" , vpmovqb(qword_ptr(rcx), zmm3)); + TEST_INSTRUCTION("62F27E4F3219" , k(k7).vpmovqb(qword_ptr(rcx), zmm3)); + TEST_INSTRUCTION("62B27E48329CF023010000" , vpmovqb(qword_ptr(rax, r14, 3, 291), zmm3)); + TEST_INSTRUCTION("62F27E48325A7F" , vpmovqb(qword_ptr(rdx, 1016), zmm3)); + TEST_INSTRUCTION("62F27E48329A00040000" , vpmovqb(qword_ptr(rdx, 1024), zmm3)); + TEST_INSTRUCTION("62F27E48325A80" , vpmovqb(qword_ptr(rdx, -1024), zmm3)); + TEST_INSTRUCTION("62F27E48329AF8FBFFFF" , vpmovqb(qword_ptr(rdx, -1032), zmm3)); + TEST_INSTRUCTION("62E27E482201" , vpmovsqb(qword_ptr(rcx), zmm16)); + TEST_INSTRUCTION("62E27E4A2201" , k(k2).vpmovsqb(qword_ptr(rcx), zmm16)); + TEST_INSTRUCTION("62A27E482284F023010000" , vpmovsqb(qword_ptr(rax, r14, 3, 291), zmm16)); + TEST_INSTRUCTION("62E27E4822427F" , vpmovsqb(qword_ptr(rdx, 1016), zmm16)); + TEST_INSTRUCTION("62E27E48228200040000" , vpmovsqb(qword_ptr(rdx, 1024), zmm16)); + TEST_INSTRUCTION("62E27E48224280" , vpmovsqb(qword_ptr(rdx, -1024), zmm16)); + TEST_INSTRUCTION("62E27E482282F8FBFFFF" , vpmovsqb(qword_ptr(rdx, -1032), zmm16)); + TEST_INSTRUCTION("62627E481221" , vpmovusqb(qword_ptr(rcx), zmm28)); + TEST_INSTRUCTION("62627E491221" , k(k1).vpmovusqb(qword_ptr(rcx), zmm28)); + TEST_INSTRUCTION("62227E4812A4F023010000" , vpmovusqb(qword_ptr(rax, r14, 3, 291), zmm28)); + TEST_INSTRUCTION("62627E4812627F" , vpmovusqb(qword_ptr(rdx, 1016), zmm28)); + TEST_INSTRUCTION("62627E4812A200040000" , vpmovusqb(qword_ptr(rdx, 1024), zmm28)); + TEST_INSTRUCTION("62627E48126280" , vpmovusqb(qword_ptr(rdx, -1024), zmm28)); + TEST_INSTRUCTION("62627E4812A2F8FBFFFF" , vpmovusqb(qword_ptr(rdx, -1032), zmm28)); + TEST_INSTRUCTION("62F27E483439" , vpmovqw(xmmword_ptr(rcx), zmm7)); + TEST_INSTRUCTION("62F27E4E3439" , k(k6).vpmovqw(xmmword_ptr(rcx), zmm7)); + TEST_INSTRUCTION("62B27E4834BCF023010000" , vpmovqw(xmmword_ptr(rax, r14, 3, 291), zmm7)); + TEST_INSTRUCTION("62F27E48347A7F" , vpmovqw(xmmword_ptr(rdx, 2032), zmm7)); + TEST_INSTRUCTION("62F27E4834BA00080000" , vpmovqw(xmmword_ptr(rdx, 2048), zmm7)); + TEST_INSTRUCTION("62F27E48347A80" , vpmovqw(xmmword_ptr(rdx, -2048), zmm7)); + TEST_INSTRUCTION("62F27E4834BAF0F7FFFF" , vpmovqw(xmmword_ptr(rdx, -2064), zmm7)); + TEST_INSTRUCTION("62F27E482409" , vpmovsqw(xmmword_ptr(rcx), zmm1)); + TEST_INSTRUCTION("62F27E4D2409" , k(k5).vpmovsqw(xmmword_ptr(rcx), zmm1)); + TEST_INSTRUCTION("62B27E48248CF023010000" , vpmovsqw(xmmword_ptr(rax, r14, 3, 291), zmm1)); + TEST_INSTRUCTION("62F27E48244A7F" , vpmovsqw(xmmword_ptr(rdx, 2032), zmm1)); + TEST_INSTRUCTION("62F27E48248A00080000" , vpmovsqw(xmmword_ptr(rdx, 2048), zmm1)); + TEST_INSTRUCTION("62F27E48244A80" , vpmovsqw(xmmword_ptr(rdx, -2048), zmm1)); + TEST_INSTRUCTION("62F27E48248AF0F7FFFF" , vpmovsqw(xmmword_ptr(rdx, -2064), zmm1)); + TEST_INSTRUCTION("62627E481409" , vpmovusqw(xmmword_ptr(rcx), zmm25)); + TEST_INSTRUCTION("62627E4B1409" , k(k3).vpmovusqw(xmmword_ptr(rcx), zmm25)); + TEST_INSTRUCTION("62227E48148CF023010000" , vpmovusqw(xmmword_ptr(rax, r14, 3, 291), zmm25)); + TEST_INSTRUCTION("62627E48144A7F" , vpmovusqw(xmmword_ptr(rdx, 2032), zmm25)); + TEST_INSTRUCTION("62627E48148A00080000" , vpmovusqw(xmmword_ptr(rdx, 2048), zmm25)); + TEST_INSTRUCTION("62627E48144A80" , vpmovusqw(xmmword_ptr(rdx, -2048), zmm25)); + TEST_INSTRUCTION("62627E48148AF0F7FFFF" , vpmovusqw(xmmword_ptr(rdx, -2064), zmm25)); + TEST_INSTRUCTION("62627E483521" , vpmovqd(ymmword_ptr(rcx), zmm28)); + TEST_INSTRUCTION("62627E4D3521" , k(k5).vpmovqd(ymmword_ptr(rcx), zmm28)); + TEST_INSTRUCTION("62227E4835A4F023010000" , vpmovqd(ymmword_ptr(rax, r14, 3, 291), zmm28)); + TEST_INSTRUCTION("62627E4835627F" , vpmovqd(ymmword_ptr(rdx, 4064), zmm28)); + TEST_INSTRUCTION("62627E4835A200100000" , vpmovqd(ymmword_ptr(rdx, 4096), zmm28)); + TEST_INSTRUCTION("62627E48356280" , vpmovqd(ymmword_ptr(rdx, -4096), zmm28)); + TEST_INSTRUCTION("62627E4835A2E0EFFFFF" , vpmovqd(ymmword_ptr(rdx, -4128), zmm28)); + TEST_INSTRUCTION("62727E482509" , vpmovsqd(ymmword_ptr(rcx), zmm9)); + TEST_INSTRUCTION("62727E4F2509" , k(k7).vpmovsqd(ymmword_ptr(rcx), zmm9)); + TEST_INSTRUCTION("62327E48258CF023010000" , vpmovsqd(ymmword_ptr(rax, r14, 3, 291), zmm9)); + TEST_INSTRUCTION("62727E48254A7F" , vpmovsqd(ymmword_ptr(rdx, 4064), zmm9)); + TEST_INSTRUCTION("62727E48258A00100000" , vpmovsqd(ymmword_ptr(rdx, 4096), zmm9)); + TEST_INSTRUCTION("62727E48254A80" , vpmovsqd(ymmword_ptr(rdx, -4096), zmm9)); + TEST_INSTRUCTION("62727E48258AE0EFFFFF" , vpmovsqd(ymmword_ptr(rdx, -4128), zmm9)); + TEST_INSTRUCTION("62E27E481531" , vpmovusqd(ymmword_ptr(rcx), zmm22)); + TEST_INSTRUCTION("62E27E491531" , k(k1).vpmovusqd(ymmword_ptr(rcx), zmm22)); + TEST_INSTRUCTION("62A27E4815B4F023010000" , vpmovusqd(ymmword_ptr(rax, r14, 3, 291), zmm22)); + TEST_INSTRUCTION("62E27E4815727F" , vpmovusqd(ymmword_ptr(rdx, 4064), zmm22)); + TEST_INSTRUCTION("62E27E4815B200100000" , vpmovusqd(ymmword_ptr(rdx, 4096), zmm22)); + TEST_INSTRUCTION("62E27E48157280" , vpmovusqd(ymmword_ptr(rdx, -4096), zmm22)); + TEST_INSTRUCTION("62E27E4815B2E0EFFFFF" , vpmovusqd(ymmword_ptr(rdx, -4128), zmm22)); + TEST_INSTRUCTION("62727E483121" , vpmovdb(xmmword_ptr(rcx), zmm12)); + TEST_INSTRUCTION("62727E4B3121" , k(k3).vpmovdb(xmmword_ptr(rcx), zmm12)); + TEST_INSTRUCTION("62327E4831A4F023010000" , vpmovdb(xmmword_ptr(rax, r14, 3, 291), zmm12)); + TEST_INSTRUCTION("62727E4831627F" , vpmovdb(xmmword_ptr(rdx, 2032), zmm12)); + TEST_INSTRUCTION("62727E4831A200080000" , vpmovdb(xmmword_ptr(rdx, 2048), zmm12)); + TEST_INSTRUCTION("62727E48316280" , vpmovdb(xmmword_ptr(rdx, -2048), zmm12)); + TEST_INSTRUCTION("62727E4831A2F0F7FFFF" , vpmovdb(xmmword_ptr(rdx, -2064), zmm12)); + TEST_INSTRUCTION("62F27E482131" , vpmovsdb(xmmword_ptr(rcx), zmm6)); + TEST_INSTRUCTION("62F27E492131" , k(k1).vpmovsdb(xmmword_ptr(rcx), zmm6)); + TEST_INSTRUCTION("62B27E4821B4F023010000" , vpmovsdb(xmmword_ptr(rax, r14, 3, 291), zmm6)); + TEST_INSTRUCTION("62F27E4821727F" , vpmovsdb(xmmword_ptr(rdx, 2032), zmm6)); + TEST_INSTRUCTION("62F27E4821B200080000" , vpmovsdb(xmmword_ptr(rdx, 2048), zmm6)); + TEST_INSTRUCTION("62F27E48217280" , vpmovsdb(xmmword_ptr(rdx, -2048), zmm6)); + TEST_INSTRUCTION("62F27E4821B2F0F7FFFF" , vpmovsdb(xmmword_ptr(rdx, -2064), zmm6)); + TEST_INSTRUCTION("62E27E481139" , vpmovusdb(xmmword_ptr(rcx), zmm23)); + TEST_INSTRUCTION("62E27E4B1139" , k(k3).vpmovusdb(xmmword_ptr(rcx), zmm23)); + TEST_INSTRUCTION("62A27E4811BCF023010000" , vpmovusdb(xmmword_ptr(rax, r14, 3, 291), zmm23)); + TEST_INSTRUCTION("62E27E48117A7F" , vpmovusdb(xmmword_ptr(rdx, 2032), zmm23)); + TEST_INSTRUCTION("62E27E4811BA00080000" , vpmovusdb(xmmword_ptr(rdx, 2048), zmm23)); + TEST_INSTRUCTION("62E27E48117A80" , vpmovusdb(xmmword_ptr(rdx, -2048), zmm23)); + TEST_INSTRUCTION("62E27E4811BAF0F7FFFF" , vpmovusdb(xmmword_ptr(rdx, -2064), zmm23)); + TEST_INSTRUCTION("62F27E483339" , vpmovdw(ymmword_ptr(rcx), zmm7)); + TEST_INSTRUCTION("62F27E4F3339" , k(k7).vpmovdw(ymmword_ptr(rcx), zmm7)); + TEST_INSTRUCTION("62B27E4833BCF023010000" , vpmovdw(ymmword_ptr(rax, r14, 3, 291), zmm7)); + TEST_INSTRUCTION("62F27E48337A7F" , vpmovdw(ymmword_ptr(rdx, 4064), zmm7)); + TEST_INSTRUCTION("62F27E4833BA00100000" , vpmovdw(ymmword_ptr(rdx, 4096), zmm7)); + TEST_INSTRUCTION("62F27E48337A80" , vpmovdw(ymmword_ptr(rdx, -4096), zmm7)); + TEST_INSTRUCTION("62F27E4833BAE0EFFFFF" , vpmovdw(ymmword_ptr(rdx, -4128), zmm7)); + TEST_INSTRUCTION("62727E482331" , vpmovsdw(ymmword_ptr(rcx), zmm14)); + TEST_INSTRUCTION("62727E4E2331" , k(k6).vpmovsdw(ymmword_ptr(rcx), zmm14)); + TEST_INSTRUCTION("62327E4823B4F023010000" , vpmovsdw(ymmword_ptr(rax, r14, 3, 291), zmm14)); + TEST_INSTRUCTION("62727E4823727F" , vpmovsdw(ymmword_ptr(rdx, 4064), zmm14)); + TEST_INSTRUCTION("62727E4823B200100000" , vpmovsdw(ymmword_ptr(rdx, 4096), zmm14)); + TEST_INSTRUCTION("62727E48237280" , vpmovsdw(ymmword_ptr(rdx, -4096), zmm14)); + TEST_INSTRUCTION("62727E4823B2E0EFFFFF" , vpmovsdw(ymmword_ptr(rdx, -4128), zmm14)); + TEST_INSTRUCTION("62F27E481329" , vpmovusdw(ymmword_ptr(rcx), zmm5)); + TEST_INSTRUCTION("62F27E4B1329" , k(k3).vpmovusdw(ymmword_ptr(rcx), zmm5)); + TEST_INSTRUCTION("62B27E4813ACF023010000" , vpmovusdw(ymmword_ptr(rax, r14, 3, 291), zmm5)); + TEST_INSTRUCTION("62F27E48136A7F" , vpmovusdw(ymmword_ptr(rdx, 4064), zmm5)); + TEST_INSTRUCTION("62F27E4813AA00100000" , vpmovusdw(ymmword_ptr(rdx, 4096), zmm5)); + TEST_INSTRUCTION("62F27E48136A80" , vpmovusdw(ymmword_ptr(rdx, -4096), zmm5)); + TEST_INSTRUCTION("62F27E4813AAE0EFFFFF" , vpmovusdw(ymmword_ptr(rdx, -4128), zmm5)); + TEST_INSTRUCTION("62A1FC4878C4" , vcvttpd2udq(ymm16, zmm20)); + TEST_INSTRUCTION("62A1FC4F78C4" , k(k7).vcvttpd2udq(ymm16, zmm20)); + TEST_INSTRUCTION("62A1FCCF78C4" , k(k7).z().vcvttpd2udq(ymm16, zmm20)); + TEST_INSTRUCTION("62A1FC1878C4" , sae().vcvttpd2udq(ymm16, zmm20)); + TEST_INSTRUCTION("62E1FC487801" , vcvttpd2udq(ymm16, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62A1FC487884F023010000" , vcvttpd2udq(ymm16, zmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62E1FC587801" , vcvttpd2udq(ymm16, qword_ptr(rcx)._1to8())); + TEST_INSTRUCTION("62E1FC4878427F" , vcvttpd2udq(ymm16, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62E1FC48788200200000" , vcvttpd2udq(ymm16, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62E1FC48784280" , vcvttpd2udq(ymm16, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62E1FC487882C0DFFFFF" , vcvttpd2udq(ymm16, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62E1FC5878427F" , vcvttpd2udq(ymm16, qword_ptr(rdx, 1016)._1to8())); + TEST_INSTRUCTION("62E1FC58788200040000" , vcvttpd2udq(ymm16, qword_ptr(rdx, 1024)._1to8())); + TEST_INSTRUCTION("62E1FC58784280" , vcvttpd2udq(ymm16, qword_ptr(rdx, -1024)._1to8())); + TEST_INSTRUCTION("62E1FC587882F8FBFFFF" , vcvttpd2udq(ymm16, qword_ptr(rdx, -1032)._1to8())); + TEST_INSTRUCTION("62117C4878F4" , vcvttps2udq(zmm14, zmm28)); + TEST_INSTRUCTION("62117C4978F4" , k(k1).vcvttps2udq(zmm14, zmm28)); + TEST_INSTRUCTION("62117CC978F4" , k(k1).z().vcvttps2udq(zmm14, zmm28)); + TEST_INSTRUCTION("62117C1878F4" , sae().vcvttps2udq(zmm14, zmm28)); + TEST_INSTRUCTION("62717C487831" , vcvttps2udq(zmm14, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62317C4878B4F023010000" , vcvttps2udq(zmm14, zmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62717C587831" , vcvttps2udq(zmm14, dword_ptr(rcx)._1to16())); + TEST_INSTRUCTION("62717C4878727F" , vcvttps2udq(zmm14, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62717C4878B200200000" , vcvttps2udq(zmm14, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62717C48787280" , vcvttps2udq(zmm14, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62717C4878B2C0DFFFFF" , vcvttps2udq(zmm14, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62717C5878727F" , vcvttps2udq(zmm14, dword_ptr(rdx, 508)._1to16())); + TEST_INSTRUCTION("62717C5878B200020000" , vcvttps2udq(zmm14, dword_ptr(rdx, 512)._1to16())); + TEST_INSTRUCTION("62717C58787280" , vcvttps2udq(zmm14, dword_ptr(rdx, -512)._1to16())); + TEST_INSTRUCTION("62717C5878B2FCFDFFFF" , vcvttps2udq(zmm14, dword_ptr(rdx, -516)._1to16())); + TEST_INSTRUCTION("62B17F0878C5" , vcvttsd2usi(eax, xmm21)); + TEST_INSTRUCTION("62B17F1878C5" , sae().vcvttsd2usi(eax, xmm21)); + TEST_INSTRUCTION("62F17F087801" , vcvttsd2usi(eax, qword_ptr(rcx))); + TEST_INSTRUCTION("62B17F087884F023010000" , vcvttsd2usi(eax, qword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62F17F0878427F" , vcvttsd2usi(eax, qword_ptr(rdx, 1016))); + TEST_INSTRUCTION("62F17F08788200040000" , vcvttsd2usi(eax, qword_ptr(rdx, 1024))); + TEST_INSTRUCTION("62F17F08784280" , vcvttsd2usi(eax, qword_ptr(rdx, -1024))); + TEST_INSTRUCTION("62F17F087882F8FBFFFF" , vcvttsd2usi(eax, qword_ptr(rdx, -1032))); + TEST_INSTRUCTION("62B17F0878ED" , vcvttsd2usi(ebp, xmm21)); + TEST_INSTRUCTION("62B17F1878ED" , sae().vcvttsd2usi(ebp, xmm21)); + TEST_INSTRUCTION("62F17F087829" , vcvttsd2usi(ebp, qword_ptr(rcx))); + TEST_INSTRUCTION("62B17F0878ACF023010000" , vcvttsd2usi(ebp, qword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62F17F08786A7F" , vcvttsd2usi(ebp, qword_ptr(rdx, 1016))); + TEST_INSTRUCTION("62F17F0878AA00040000" , vcvttsd2usi(ebp, qword_ptr(rdx, 1024))); + TEST_INSTRUCTION("62F17F08786A80" , vcvttsd2usi(ebp, qword_ptr(rdx, -1024))); + TEST_INSTRUCTION("62F17F0878AAF8FBFFFF" , vcvttsd2usi(ebp, qword_ptr(rdx, -1032))); + TEST_INSTRUCTION("62317F0878ED" , vcvttsd2usi(r13d, xmm21)); + TEST_INSTRUCTION("62317F1878ED" , sae().vcvttsd2usi(r13d, xmm21)); + TEST_INSTRUCTION("62717F087829" , vcvttsd2usi(r13d, qword_ptr(rcx))); + TEST_INSTRUCTION("62317F0878ACF023010000" , vcvttsd2usi(r13d, qword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62717F08786A7F" , vcvttsd2usi(r13d, qword_ptr(rdx, 1016))); + TEST_INSTRUCTION("62717F0878AA00040000" , vcvttsd2usi(r13d, qword_ptr(rdx, 1024))); + TEST_INSTRUCTION("62717F08786A80" , vcvttsd2usi(r13d, qword_ptr(rdx, -1024))); + TEST_INSTRUCTION("62717F0878AAF8FBFFFF" , vcvttsd2usi(r13d, qword_ptr(rdx, -1032))); + TEST_INSTRUCTION("62F1FF0878C7" , vcvttsd2usi(rax, xmm7)); + TEST_INSTRUCTION("62F1FF1878C7" , sae().vcvttsd2usi(rax, xmm7)); + TEST_INSTRUCTION("62F1FF087801" , vcvttsd2usi(rax, qword_ptr(rcx))); + TEST_INSTRUCTION("62B1FF087884F023010000" , vcvttsd2usi(rax, qword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62F1FF0878427F" , vcvttsd2usi(rax, qword_ptr(rdx, 1016))); + TEST_INSTRUCTION("62F1FF08788200040000" , vcvttsd2usi(rax, qword_ptr(rdx, 1024))); + TEST_INSTRUCTION("62F1FF08784280" , vcvttsd2usi(rax, qword_ptr(rdx, -1024))); + TEST_INSTRUCTION("62F1FF087882F8FBFFFF" , vcvttsd2usi(rax, qword_ptr(rdx, -1032))); + TEST_INSTRUCTION("6271FF0878C7" , vcvttsd2usi(r8, xmm7)); + TEST_INSTRUCTION("6271FF1878C7" , sae().vcvttsd2usi(r8, xmm7)); + TEST_INSTRUCTION("6271FF087801" , vcvttsd2usi(r8, qword_ptr(rcx))); + TEST_INSTRUCTION("6231FF087884F023010000" , vcvttsd2usi(r8, qword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("6271FF0878427F" , vcvttsd2usi(r8, qword_ptr(rdx, 1016))); + TEST_INSTRUCTION("6271FF08788200040000" , vcvttsd2usi(r8, qword_ptr(rdx, 1024))); + TEST_INSTRUCTION("6271FF08784280" , vcvttsd2usi(r8, qword_ptr(rdx, -1024))); + TEST_INSTRUCTION("6271FF087882F8FBFFFF" , vcvttsd2usi(r8, qword_ptr(rdx, -1032))); + TEST_INSTRUCTION("62B17E0878C2" , vcvttss2usi(eax, xmm18)); + TEST_INSTRUCTION("62B17E1878C2" , sae().vcvttss2usi(eax, xmm18)); + TEST_INSTRUCTION("62F17E087801" , vcvttss2usi(eax, dword_ptr(rcx))); + TEST_INSTRUCTION("62B17E087884F023010000" , vcvttss2usi(eax, dword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62F17E0878427F" , vcvttss2usi(eax, dword_ptr(rdx, 508))); + TEST_INSTRUCTION("62F17E08788200020000" , vcvttss2usi(eax, dword_ptr(rdx, 512))); + TEST_INSTRUCTION("62F17E08784280" , vcvttss2usi(eax, dword_ptr(rdx, -512))); + TEST_INSTRUCTION("62F17E087882FCFDFFFF" , vcvttss2usi(eax, dword_ptr(rdx, -516))); + TEST_INSTRUCTION("62B17E0878EA" , vcvttss2usi(ebp, xmm18)); + TEST_INSTRUCTION("62B17E1878EA" , sae().vcvttss2usi(ebp, xmm18)); + TEST_INSTRUCTION("62F17E087829" , vcvttss2usi(ebp, dword_ptr(rcx))); + TEST_INSTRUCTION("62B17E0878ACF023010000" , vcvttss2usi(ebp, dword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62F17E08786A7F" , vcvttss2usi(ebp, dword_ptr(rdx, 508))); + TEST_INSTRUCTION("62F17E0878AA00020000" , vcvttss2usi(ebp, dword_ptr(rdx, 512))); + TEST_INSTRUCTION("62F17E08786A80" , vcvttss2usi(ebp, dword_ptr(rdx, -512))); + TEST_INSTRUCTION("62F17E0878AAFCFDFFFF" , vcvttss2usi(ebp, dword_ptr(rdx, -516))); + TEST_INSTRUCTION("62317E0878EA" , vcvttss2usi(r13d, xmm18)); + TEST_INSTRUCTION("62317E1878EA" , sae().vcvttss2usi(r13d, xmm18)); + TEST_INSTRUCTION("62717E087829" , vcvttss2usi(r13d, dword_ptr(rcx))); + TEST_INSTRUCTION("62317E0878ACF023010000" , vcvttss2usi(r13d, dword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62717E08786A7F" , vcvttss2usi(r13d, dword_ptr(rdx, 508))); + TEST_INSTRUCTION("62717E0878AA00020000" , vcvttss2usi(r13d, dword_ptr(rdx, 512))); + TEST_INSTRUCTION("62717E08786A80" , vcvttss2usi(r13d, dword_ptr(rdx, -512))); + TEST_INSTRUCTION("62717E0878AAFCFDFFFF" , vcvttss2usi(r13d, dword_ptr(rdx, -516))); + TEST_INSTRUCTION("6291FE0878C3" , vcvttss2usi(rax, xmm27)); + TEST_INSTRUCTION("6291FE1878C3" , sae().vcvttss2usi(rax, xmm27)); + TEST_INSTRUCTION("62F1FE087801" , vcvttss2usi(rax, dword_ptr(rcx))); + TEST_INSTRUCTION("62B1FE087884F023010000" , vcvttss2usi(rax, dword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62F1FE0878427F" , vcvttss2usi(rax, dword_ptr(rdx, 508))); + TEST_INSTRUCTION("62F1FE08788200020000" , vcvttss2usi(rax, dword_ptr(rdx, 512))); + TEST_INSTRUCTION("62F1FE08784280" , vcvttss2usi(rax, dword_ptr(rdx, -512))); + TEST_INSTRUCTION("62F1FE087882FCFDFFFF" , vcvttss2usi(rax, dword_ptr(rdx, -516))); + TEST_INSTRUCTION("6211FE0878C3" , vcvttss2usi(r8, xmm27)); + TEST_INSTRUCTION("6211FE1878C3" , sae().vcvttss2usi(r8, xmm27)); + TEST_INSTRUCTION("6271FE087801" , vcvttss2usi(r8, dword_ptr(rcx))); + TEST_INSTRUCTION("6231FE087884F023010000" , vcvttss2usi(r8, dword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("6271FE0878427F" , vcvttss2usi(r8, dword_ptr(rdx, 508))); + TEST_INSTRUCTION("6271FE08788200020000" , vcvttss2usi(r8, dword_ptr(rdx, 512))); + TEST_INSTRUCTION("6271FE08784280" , vcvttss2usi(r8, dword_ptr(rdx, -512))); + TEST_INSTRUCTION("6271FE087882FCFDFFFF" , vcvttss2usi(r8, dword_ptr(rdx, -516))); + TEST_INSTRUCTION("62721D4076D4" , vpermi2d(zmm10, zmm28, zmm4)); + TEST_INSTRUCTION("62721D4576D4" , k(k5).vpermi2d(zmm10, zmm28, zmm4)); + TEST_INSTRUCTION("62721DC576D4" , k(k5).z().vpermi2d(zmm10, zmm28, zmm4)); + TEST_INSTRUCTION("62721D407611" , vpermi2d(zmm10, zmm28, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62321D407694F023010000" , vpermi2d(zmm10, zmm28, zmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62721D507611" , vpermi2d(zmm10, zmm28, dword_ptr(rcx)._1to16())); + TEST_INSTRUCTION("62721D4076527F" , vpermi2d(zmm10, zmm28, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62721D40769200200000" , vpermi2d(zmm10, zmm28, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62721D40765280" , vpermi2d(zmm10, zmm28, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62721D407692C0DFFFFF" , vpermi2d(zmm10, zmm28, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62721D5076527F" , vpermi2d(zmm10, zmm28, dword_ptr(rdx, 508)._1to16())); + TEST_INSTRUCTION("62721D50769200020000" , vpermi2d(zmm10, zmm28, dword_ptr(rdx, 512)._1to16())); + TEST_INSTRUCTION("62721D50765280" , vpermi2d(zmm10, zmm28, dword_ptr(rdx, -512)._1to16())); + TEST_INSTRUCTION("62721D507692FCFDFFFF" , vpermi2d(zmm10, zmm28, dword_ptr(rdx, -516)._1to16())); + TEST_INSTRUCTION("62829D4076D4" , vpermi2q(zmm18, zmm28, zmm28)); + TEST_INSTRUCTION("62829D4276D4" , k(k2).vpermi2q(zmm18, zmm28, zmm28)); + TEST_INSTRUCTION("62829DC276D4" , k(k2).z().vpermi2q(zmm18, zmm28, zmm28)); + TEST_INSTRUCTION("62E29D407611" , vpermi2q(zmm18, zmm28, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62A29D407694F023010000" , vpermi2q(zmm18, zmm28, zmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62E29D507611" , vpermi2q(zmm18, zmm28, qword_ptr(rcx)._1to8())); + TEST_INSTRUCTION("62E29D4076527F" , vpermi2q(zmm18, zmm28, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62E29D40769200200000" , vpermi2q(zmm18, zmm28, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62E29D40765280" , vpermi2q(zmm18, zmm28, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62E29D407692C0DFFFFF" , vpermi2q(zmm18, zmm28, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62E29D5076527F" , vpermi2q(zmm18, zmm28, qword_ptr(rdx, 1016)._1to8())); + TEST_INSTRUCTION("62E29D50769200040000" , vpermi2q(zmm18, zmm28, qword_ptr(rdx, 1024)._1to8())); + TEST_INSTRUCTION("62E29D50765280" , vpermi2q(zmm18, zmm28, qword_ptr(rdx, -1024)._1to8())); + TEST_INSTRUCTION("62E29D507692F8FBFFFF" , vpermi2q(zmm18, zmm28, qword_ptr(rdx, -1032)._1to8())); + TEST_INSTRUCTION("6242454077C0" , vpermi2ps(zmm24, zmm23, zmm8)); + TEST_INSTRUCTION("6242454277C0" , k(k2).vpermi2ps(zmm24, zmm23, zmm8)); + TEST_INSTRUCTION("624245C277C0" , k(k2).z().vpermi2ps(zmm24, zmm23, zmm8)); + TEST_INSTRUCTION("626245407701" , vpermi2ps(zmm24, zmm23, zmmword_ptr(rcx))); + TEST_INSTRUCTION("622245407784F023010000" , vpermi2ps(zmm24, zmm23, zmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("626245507701" , vpermi2ps(zmm24, zmm23, dword_ptr(rcx)._1to16())); + TEST_INSTRUCTION("6262454077427F" , vpermi2ps(zmm24, zmm23, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62624540778200200000" , vpermi2ps(zmm24, zmm23, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62624540774280" , vpermi2ps(zmm24, zmm23, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("626245407782C0DFFFFF" , vpermi2ps(zmm24, zmm23, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("6262455077427F" , vpermi2ps(zmm24, zmm23, dword_ptr(rdx, 508)._1to16())); + TEST_INSTRUCTION("62624550778200020000" , vpermi2ps(zmm24, zmm23, dword_ptr(rdx, 512)._1to16())); + TEST_INSTRUCTION("62624550774280" , vpermi2ps(zmm24, zmm23, dword_ptr(rdx, -512)._1to16())); + TEST_INSTRUCTION("626245507782FCFDFFFF" , vpermi2ps(zmm24, zmm23, dword_ptr(rdx, -516)._1to16())); + TEST_INSTRUCTION("62A2D54877E4" , vpermi2pd(zmm20, zmm5, zmm20)); + TEST_INSTRUCTION("62A2D54B77E4" , k(k3).vpermi2pd(zmm20, zmm5, zmm20)); + TEST_INSTRUCTION("62A2D5CB77E4" , k(k3).z().vpermi2pd(zmm20, zmm5, zmm20)); + TEST_INSTRUCTION("62E2D5487721" , vpermi2pd(zmm20, zmm5, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62A2D54877A4F023010000" , vpermi2pd(zmm20, zmm5, zmmword_ptr(rax, r14, 3, 291))); + TEST_INSTRUCTION("62E2D5587721" , vpermi2pd(zmm20, zmm5, qword_ptr(rcx)._1to8())); + TEST_INSTRUCTION("62E2D54877627F" , vpermi2pd(zmm20, zmm5, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62E2D54877A200200000" , vpermi2pd(zmm20, zmm5, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62E2D548776280" , vpermi2pd(zmm20, zmm5, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62E2D54877A2C0DFFFFF" , vpermi2pd(zmm20, zmm5, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62E2D55877627F" , vpermi2pd(zmm20, zmm5, qword_ptr(rdx, 1016)._1to8())); + TEST_INSTRUCTION("62E2D55877A200040000" , vpermi2pd(zmm20, zmm5, qword_ptr(rdx, 1024)._1to8())); + TEST_INSTRUCTION("62E2D558776280" , vpermi2pd(zmm20, zmm5, qword_ptr(rdx, -1024)._1to8())); + TEST_INSTRUCTION("62E2D55877A2F8FBFFFF" , vpermi2pd(zmm20, zmm5, qword_ptr(rdx, -1032)._1to8())); + TEST_INSTRUCTION("62E1A54858CA" , vaddpd(zmm17, zmm11, zmm2)); + TEST_INSTRUCTION("62E1A54958CA" , k(k1).vaddpd(zmm17, zmm11, zmm2)); + TEST_INSTRUCTION("62E1A5C958CA" , k(k1).z().vaddpd(zmm17, zmm11, zmm2)); + TEST_INSTRUCTION("62E1A51858CA" , rn_sae().vaddpd(zmm17, zmm11, zmm2)); + TEST_INSTRUCTION("62E1A55858CA" , ru_sae().vaddpd(zmm17, zmm11, zmm2)); + TEST_INSTRUCTION("62E1A53858CA" , rd_sae().vaddpd(zmm17, zmm11, zmm2)); + TEST_INSTRUCTION("62E1A57858CA" , rz_sae().vaddpd(zmm17, zmm11, zmm2)); + TEST_INSTRUCTION("62E1A5485809" , vaddpd(zmm17, zmm11, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62A1A548588CF034120000" , vaddpd(zmm17, zmm11, zmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62E1A5585809" , vaddpd(zmm17, zmm11, qword_ptr(rcx)._1to8())); + TEST_INSTRUCTION("62E1A548584A7F" , vaddpd(zmm17, zmm11, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62E1A548588A00200000" , vaddpd(zmm17, zmm11, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62E1A548584A80" , vaddpd(zmm17, zmm11, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62E1A548588AC0DFFFFF" , vaddpd(zmm17, zmm11, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62E1A558584A7F" , vaddpd(zmm17, zmm11, qword_ptr(rdx, 1016)._1to8())); + TEST_INSTRUCTION("62E1A558588A00040000" , vaddpd(zmm17, zmm11, qword_ptr(rdx, 1024)._1to8())); + TEST_INSTRUCTION("62E1A558584A80" , vaddpd(zmm17, zmm11, qword_ptr(rdx, -1024)._1to8())); + TEST_INSTRUCTION("62E1A558588AF8FBFFFF" , vaddpd(zmm17, zmm11, qword_ptr(rdx, -1032)._1to8())); + TEST_INSTRUCTION("62F14C4858DD" , vaddps(zmm3, zmm6, zmm5)); + TEST_INSTRUCTION("62F14C4958DD" , k(k1).vaddps(zmm3, zmm6, zmm5)); + TEST_INSTRUCTION("62F14CC958DD" , k(k1).z().vaddps(zmm3, zmm6, zmm5)); + TEST_INSTRUCTION("62F14C1858DD" , rn_sae().vaddps(zmm3, zmm6, zmm5)); + TEST_INSTRUCTION("62F14C5858DD" , ru_sae().vaddps(zmm3, zmm6, zmm5)); + TEST_INSTRUCTION("62F14C3858DD" , rd_sae().vaddps(zmm3, zmm6, zmm5)); + TEST_INSTRUCTION("62F14C7858DD" , rz_sae().vaddps(zmm3, zmm6, zmm5)); + TEST_INSTRUCTION("62F14C485819" , vaddps(zmm3, zmm6, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62B14C48589CF034120000" , vaddps(zmm3, zmm6, zmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62F14C585819" , vaddps(zmm3, zmm6, dword_ptr(rcx)._1to16())); + TEST_INSTRUCTION("62F14C48585A7F" , vaddps(zmm3, zmm6, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62F14C48589A00200000" , vaddps(zmm3, zmm6, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62F14C48585A80" , vaddps(zmm3, zmm6, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62F14C48589AC0DFFFFF" , vaddps(zmm3, zmm6, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62F14C58585A7F" , vaddps(zmm3, zmm6, dword_ptr(rdx, 508)._1to16())); + TEST_INSTRUCTION("62F14C58589A00020000" , vaddps(zmm3, zmm6, dword_ptr(rdx, 512)._1to16())); + TEST_INSTRUCTION("62F14C58585A80" , vaddps(zmm3, zmm6, dword_ptr(rdx, -512)._1to16())); + TEST_INSTRUCTION("62F14C58589AFCFDFFFF" , vaddps(zmm3, zmm6, dword_ptr(rdx, -516)._1to16())); + TEST_INSTRUCTION("6291EF0058CB" , vaddsd(xmm1, xmm18, xmm27)); + TEST_INSTRUCTION("6291EF0358CB" , k(k3).vaddsd(xmm1, xmm18, xmm27)); + TEST_INSTRUCTION("6291EF8358CB" , k(k3).z().vaddsd(xmm1, xmm18, xmm27)); + TEST_INSTRUCTION("6291EF1058CB" , rn_sae().vaddsd(xmm1, xmm18, xmm27)); + TEST_INSTRUCTION("6291EF5058CB" , ru_sae().vaddsd(xmm1, xmm18, xmm27)); + TEST_INSTRUCTION("6291EF3058CB" , rd_sae().vaddsd(xmm1, xmm18, xmm27)); + TEST_INSTRUCTION("6291EF7058CB" , rz_sae().vaddsd(xmm1, xmm18, xmm27)); + TEST_INSTRUCTION("62F1EF005809" , vaddsd(xmm1, xmm18, qword_ptr(rcx))); + TEST_INSTRUCTION("62B1EF00588CF034120000" , vaddsd(xmm1, xmm18, qword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62F1EF00584A7F" , vaddsd(xmm1, xmm18, qword_ptr(rdx, 1016))); + TEST_INSTRUCTION("62F1EF00588A00040000" , vaddsd(xmm1, xmm18, qword_ptr(rdx, 1024))); + TEST_INSTRUCTION("62F1EF00584A80" , vaddsd(xmm1, xmm18, qword_ptr(rdx, -1024))); + TEST_INSTRUCTION("62F1EF00588AF8FBFFFF" , vaddsd(xmm1, xmm18, qword_ptr(rdx, -1032))); + TEST_INSTRUCTION("62C10E0858CF" , vaddss(xmm17, xmm14, xmm15)); + TEST_INSTRUCTION("62C10E0C58CF" , k(k4).vaddss(xmm17, xmm14, xmm15)); + TEST_INSTRUCTION("62C10E8C58CF" , k(k4).z().vaddss(xmm17, xmm14, xmm15)); + TEST_INSTRUCTION("62C10E1858CF" , rn_sae().vaddss(xmm17, xmm14, xmm15)); + TEST_INSTRUCTION("62C10E5858CF" , ru_sae().vaddss(xmm17, xmm14, xmm15)); + TEST_INSTRUCTION("62C10E3858CF" , rd_sae().vaddss(xmm17, xmm14, xmm15)); + TEST_INSTRUCTION("62C10E7858CF" , rz_sae().vaddss(xmm17, xmm14, xmm15)); + TEST_INSTRUCTION("62E10E085809" , vaddss(xmm17, xmm14, dword_ptr(rcx))); + TEST_INSTRUCTION("62A10E08588CF034120000" , vaddss(xmm17, xmm14, dword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62E10E08584A7F" , vaddss(xmm17, xmm14, dword_ptr(rdx, 508))); + TEST_INSTRUCTION("62E10E08588A00020000" , vaddss(xmm17, xmm14, dword_ptr(rdx, 512))); + TEST_INSTRUCTION("62E10E08584A80" , vaddss(xmm17, xmm14, dword_ptr(rdx, -512))); + TEST_INSTRUCTION("62E10E08588AFCFDFFFF" , vaddss(xmm17, xmm14, dword_ptr(rdx, -516))); + TEST_INSTRUCTION("6273454803FDAB" , valignd(zmm15, zmm7, zmm5, 171)); + TEST_INSTRUCTION("6273454A03FDAB" , k(k2).valignd(zmm15, zmm7, zmm5, 171)); + TEST_INSTRUCTION("627345CA03FDAB" , k(k2).z().valignd(zmm15, zmm7, zmm5, 171)); + TEST_INSTRUCTION("6273454803FD7B" , valignd(zmm15, zmm7, zmm5, 123)); + TEST_INSTRUCTION("6273454803397B" , valignd(zmm15, zmm7, zmmword_ptr(rcx), 123)); + TEST_INSTRUCTION("6233454803BCF0341200007B" , valignd(zmm15, zmm7, zmmword_ptr(rax, r14, 3, 4660), 123)); + TEST_INSTRUCTION("6273455803397B" , valignd(zmm15, zmm7, dword_ptr(rcx)._1to16(), 123)); + TEST_INSTRUCTION("62734548037A7F7B" , valignd(zmm15, zmm7, zmmword_ptr(rdx, 8128), 123)); + TEST_INSTRUCTION("6273454803BA002000007B" , valignd(zmm15, zmm7, zmmword_ptr(rdx, 8192), 123)); + TEST_INSTRUCTION("62734548037A807B" , valignd(zmm15, zmm7, zmmword_ptr(rdx, -8192), 123)); + TEST_INSTRUCTION("6273454803BAC0DFFFFF7B" , valignd(zmm15, zmm7, zmmword_ptr(rdx, -8256), 123)); + TEST_INSTRUCTION("62734558037A7F7B" , valignd(zmm15, zmm7, dword_ptr(rdx, 508)._1to16(), 123)); + TEST_INSTRUCTION("6273455803BA000200007B" , valignd(zmm15, zmm7, dword_ptr(rdx, 512)._1to16(), 123)); + TEST_INSTRUCTION("62734558037A807B" , valignd(zmm15, zmm7, dword_ptr(rdx, -512)._1to16(), 123)); + TEST_INSTRUCTION("6273455803BAFCFDFFFF7B" , valignd(zmm15, zmm7, dword_ptr(rdx, -516)._1to16(), 123)); + TEST_INSTRUCTION("62C2ED4865F8" , vblendmpd(zmm23, zmm2, zmm8)); + TEST_INSTRUCTION("62C2ED4F65F8" , k(k7).vblendmpd(zmm23, zmm2, zmm8)); + TEST_INSTRUCTION("62C2EDCF65F8" , k(k7).z().vblendmpd(zmm23, zmm2, zmm8)); + TEST_INSTRUCTION("62E2ED486539" , vblendmpd(zmm23, zmm2, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62A2ED4865BCF034120000" , vblendmpd(zmm23, zmm2, zmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62E2ED586539" , vblendmpd(zmm23, zmm2, qword_ptr(rcx)._1to8())); + TEST_INSTRUCTION("62E2ED48657A7F" , vblendmpd(zmm23, zmm2, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62E2ED4865BA00200000" , vblendmpd(zmm23, zmm2, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62E2ED48657A80" , vblendmpd(zmm23, zmm2, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62E2ED4865BAC0DFFFFF" , vblendmpd(zmm23, zmm2, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62E2ED58657A7F" , vblendmpd(zmm23, zmm2, qword_ptr(rdx, 1016)._1to8())); + TEST_INSTRUCTION("62E2ED5865BA00040000" , vblendmpd(zmm23, zmm2, qword_ptr(rdx, 1024)._1to8())); + TEST_INSTRUCTION("62E2ED58657A80" , vblendmpd(zmm23, zmm2, qword_ptr(rdx, -1024)._1to8())); + TEST_INSTRUCTION("62E2ED5865BAF8FBFFFF" , vblendmpd(zmm23, zmm2, qword_ptr(rdx, -1032)._1to8())); + TEST_INSTRUCTION("62E2354865FF" , vblendmps(zmm23, zmm9, zmm7)); + TEST_INSTRUCTION("62E2354F65FF" , k(k7).vblendmps(zmm23, zmm9, zmm7)); + TEST_INSTRUCTION("62E235CF65FF" , k(k7).z().vblendmps(zmm23, zmm9, zmm7)); + TEST_INSTRUCTION("62E235486539" , vblendmps(zmm23, zmm9, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62A2354865BCF034120000" , vblendmps(zmm23, zmm9, zmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62E235586539" , vblendmps(zmm23, zmm9, dword_ptr(rcx)._1to16())); + TEST_INSTRUCTION("62E23548657A7F" , vblendmps(zmm23, zmm9, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62E2354865BA00200000" , vblendmps(zmm23, zmm9, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62E23548657A80" , vblendmps(zmm23, zmm9, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62E2354865BAC0DFFFFF" , vblendmps(zmm23, zmm9, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62E23558657A7F" , vblendmps(zmm23, zmm9, dword_ptr(rdx, 508)._1to16())); + TEST_INSTRUCTION("62E2355865BA00020000" , vblendmps(zmm23, zmm9, dword_ptr(rdx, 512)._1to16())); + TEST_INSTRUCTION("62E23558657A80" , vblendmps(zmm23, zmm9, dword_ptr(rdx, -512)._1to16())); + TEST_INSTRUCTION("62E2355865BAFCFDFFFF" , vblendmps(zmm23, zmm9, dword_ptr(rdx, -516)._1to16())); + TEST_INSTRUCTION("62727D481A39" , vbroadcastf32x4(zmm15, xmmword_ptr(rcx))); + TEST_INSTRUCTION("62727D4B1A39" , k(k3).vbroadcastf32x4(zmm15, xmmword_ptr(rcx))); + TEST_INSTRUCTION("62727DCB1A39" , k(k3).z().vbroadcastf32x4(zmm15, xmmword_ptr(rcx))); + TEST_INSTRUCTION("62327D481ABCF034120000" , vbroadcastf32x4(zmm15, xmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62727D481A7A7F" , vbroadcastf32x4(zmm15, xmmword_ptr(rdx, 2032))); + TEST_INSTRUCTION("62727D481ABA00080000" , vbroadcastf32x4(zmm15, xmmword_ptr(rdx, 2048))); + TEST_INSTRUCTION("62727D481A7A80" , vbroadcastf32x4(zmm15, xmmword_ptr(rdx, -2048))); + TEST_INSTRUCTION("62727D481ABAF0F7FFFF" , vbroadcastf32x4(zmm15, xmmword_ptr(rdx, -2064))); + TEST_INSTRUCTION("6262FD481B11" , vbroadcastf64x4(zmm26, ymmword_ptr(rcx))); + TEST_INSTRUCTION("6262FD491B11" , k(k1).vbroadcastf64x4(zmm26, ymmword_ptr(rcx))); + TEST_INSTRUCTION("6262FDC91B11" , k(k1).z().vbroadcastf64x4(zmm26, ymmword_ptr(rcx))); + TEST_INSTRUCTION("6222FD481B94F034120000" , vbroadcastf64x4(zmm26, ymmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("6262FD481B527F" , vbroadcastf64x4(zmm26, ymmword_ptr(rdx, 4064))); + TEST_INSTRUCTION("6262FD481B9200100000" , vbroadcastf64x4(zmm26, ymmword_ptr(rdx, 4096))); + TEST_INSTRUCTION("6262FD481B5280" , vbroadcastf64x4(zmm26, ymmword_ptr(rdx, -4096))); + TEST_INSTRUCTION("6262FD481B92E0EFFFFF" , vbroadcastf64x4(zmm26, ymmword_ptr(rdx, -4128))); + TEST_INSTRUCTION("62F27D485A11" , vbroadcasti32x4(zmm2, xmmword_ptr(rcx))); + TEST_INSTRUCTION("62F27D4D5A11" , k(k5).vbroadcasti32x4(zmm2, xmmword_ptr(rcx))); + TEST_INSTRUCTION("62F27DCD5A11" , k(k5).z().vbroadcasti32x4(zmm2, xmmword_ptr(rcx))); + TEST_INSTRUCTION("62B27D485A94F034120000" , vbroadcasti32x4(zmm2, xmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62F27D485A527F" , vbroadcasti32x4(zmm2, xmmword_ptr(rdx, 2032))); + TEST_INSTRUCTION("62F27D485A9200080000" , vbroadcasti32x4(zmm2, xmmword_ptr(rdx, 2048))); + TEST_INSTRUCTION("62F27D485A5280" , vbroadcasti32x4(zmm2, xmmword_ptr(rdx, -2048))); + TEST_INSTRUCTION("62F27D485A92F0F7FFFF" , vbroadcasti32x4(zmm2, xmmword_ptr(rdx, -2064))); + TEST_INSTRUCTION("62E2FD485B09" , vbroadcasti64x4(zmm17, ymmword_ptr(rcx))); + TEST_INSTRUCTION("62E2FD4A5B09" , k(k2).vbroadcasti64x4(zmm17, ymmword_ptr(rcx))); + TEST_INSTRUCTION("62E2FDCA5B09" , k(k2).z().vbroadcasti64x4(zmm17, ymmword_ptr(rcx))); + TEST_INSTRUCTION("62A2FD485B8CF034120000" , vbroadcasti64x4(zmm17, ymmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62E2FD485B4A7F" , vbroadcasti64x4(zmm17, ymmword_ptr(rdx, 4064))); + TEST_INSTRUCTION("62E2FD485B8A00100000" , vbroadcasti64x4(zmm17, ymmword_ptr(rdx, 4096))); + TEST_INSTRUCTION("62E2FD485B4A80" , vbroadcasti64x4(zmm17, ymmword_ptr(rdx, -4096))); + TEST_INSTRUCTION("62E2FD485B8AE0EFFFFF" , vbroadcasti64x4(zmm17, ymmword_ptr(rdx, -4128))); + TEST_INSTRUCTION("6262FD481919" , vbroadcastsd(zmm27, qword_ptr(rcx))); + TEST_INSTRUCTION("6262FD4F1919" , k(k7).vbroadcastsd(zmm27, qword_ptr(rcx))); + TEST_INSTRUCTION("6262FDCF1919" , k(k7).z().vbroadcastsd(zmm27, qword_ptr(rcx))); + TEST_INSTRUCTION("6222FD48199CF034120000" , vbroadcastsd(zmm27, qword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("6262FD48195A7F" , vbroadcastsd(zmm27, qword_ptr(rdx, 1016))); + TEST_INSTRUCTION("6262FD48199A00040000" , vbroadcastsd(zmm27, qword_ptr(rdx, 1024))); + TEST_INSTRUCTION("6262FD48195A80" , vbroadcastsd(zmm27, qword_ptr(rdx, -1024))); + TEST_INSTRUCTION("6262FD48199AF8FBFFFF" , vbroadcastsd(zmm27, qword_ptr(rdx, -1032))); + TEST_INSTRUCTION("6282FD4819D9" , vbroadcastsd(zmm19, xmm25)); + TEST_INSTRUCTION("6282FD4B19D9" , k(k3).vbroadcastsd(zmm19, xmm25)); + TEST_INSTRUCTION("6282FDCB19D9" , k(k3).z().vbroadcastsd(zmm19, xmm25)); + TEST_INSTRUCTION("62F27D481811" , vbroadcastss(zmm2, dword_ptr(rcx))); + TEST_INSTRUCTION("62F27D491811" , k(k1).vbroadcastss(zmm2, dword_ptr(rcx))); + TEST_INSTRUCTION("62F27DC91811" , k(k1).z().vbroadcastss(zmm2, dword_ptr(rcx))); + TEST_INSTRUCTION("62B27D481894F034120000" , vbroadcastss(zmm2, dword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62F27D4818527F" , vbroadcastss(zmm2, dword_ptr(rdx, 508))); + TEST_INSTRUCTION("62F27D48189200020000" , vbroadcastss(zmm2, dword_ptr(rdx, 512))); + TEST_INSTRUCTION("62F27D48185280" , vbroadcastss(zmm2, dword_ptr(rdx, -512))); + TEST_INSTRUCTION("62F27D481892FCFDFFFF" , vbroadcastss(zmm2, dword_ptr(rdx, -516))); + TEST_INSTRUCTION("62C27D4818FF" , vbroadcastss(zmm23, xmm15)); + TEST_INSTRUCTION("62C27D4C18FF" , k(k4).vbroadcastss(zmm23, xmm15)); + TEST_INSTRUCTION("62C27DCC18FF" , k(k4).z().vbroadcastss(zmm23, xmm15)); + TEST_INSTRUCTION("62B18548C2E8AB" , vcmppd(k5, zmm15, zmm16, 171)); + TEST_INSTRUCTION("62B1854DC2E8AB" , k(k5).vcmppd(k5, zmm15, zmm16, 171)); + TEST_INSTRUCTION("62B18518C2E8AB" , sae().vcmppd(k5, zmm15, zmm16, 171)); + TEST_INSTRUCTION("62B18548C2E87B" , vcmppd(k5, zmm15, zmm16, 123)); + TEST_INSTRUCTION("62B18518C2E87B" , sae().vcmppd(k5, zmm15, zmm16, 123)); + TEST_INSTRUCTION("62F18548C2297B" , vcmppd(k5, zmm15, zmmword_ptr(rcx), 123)); + TEST_INSTRUCTION("62B18548C2ACF0341200007B" , vcmppd(k5, zmm15, zmmword_ptr(rax, r14, 3, 4660), 123)); + TEST_INSTRUCTION("62F18558C2297B" , vcmppd(k5, zmm15, qword_ptr(rcx)._1to8(), 123)); + TEST_INSTRUCTION("62F18548C26A7F7B" , vcmppd(k5, zmm15, zmmword_ptr(rdx, 8128), 123)); + TEST_INSTRUCTION("62F18548C2AA002000007B" , vcmppd(k5, zmm15, zmmword_ptr(rdx, 8192), 123)); + TEST_INSTRUCTION("62F18548C26A807B" , vcmppd(k5, zmm15, zmmword_ptr(rdx, -8192), 123)); + TEST_INSTRUCTION("62F18548C2AAC0DFFFFF7B" , vcmppd(k5, zmm15, zmmword_ptr(rdx, -8256), 123)); + TEST_INSTRUCTION("62F18558C26A7F7B" , vcmppd(k5, zmm15, qword_ptr(rdx, 1016)._1to8(), 123)); + TEST_INSTRUCTION("62F18558C2AA000400007B" , vcmppd(k5, zmm15, qword_ptr(rdx, 1024)._1to8(), 123)); + TEST_INSTRUCTION("62F18558C26A807B" , vcmppd(k5, zmm15, qword_ptr(rdx, -1024)._1to8(), 123)); + TEST_INSTRUCTION("62F18558C2AAF8FBFFFF7B" , vcmppd(k5, zmm15, qword_ptr(rdx, -1032)._1to8(), 123)); + TEST_INSTRUCTION("62916448C2D5AB" , vcmpps(k2, zmm3, zmm29, 171)); + TEST_INSTRUCTION("6291644DC2D5AB" , k(k5).vcmpps(k2, zmm3, zmm29, 171)); + TEST_INSTRUCTION("62916418C2D5AB" , sae().vcmpps(k2, zmm3, zmm29, 171)); + TEST_INSTRUCTION("62916448C2D57B" , vcmpps(k2, zmm3, zmm29, 123)); + TEST_INSTRUCTION("62916418C2D57B" , sae().vcmpps(k2, zmm3, zmm29, 123)); + TEST_INSTRUCTION("62F16448C2117B" , vcmpps(k2, zmm3, zmmword_ptr(rcx), 123)); + TEST_INSTRUCTION("62B16448C294F0341200007B" , vcmpps(k2, zmm3, zmmword_ptr(rax, r14, 3, 4660), 123)); + TEST_INSTRUCTION("62F16458C2117B" , vcmpps(k2, zmm3, dword_ptr(rcx)._1to16(), 123)); + TEST_INSTRUCTION("62F16448C2527F7B" , vcmpps(k2, zmm3, zmmword_ptr(rdx, 8128), 123)); + TEST_INSTRUCTION("62F16448C292002000007B" , vcmpps(k2, zmm3, zmmword_ptr(rdx, 8192), 123)); + TEST_INSTRUCTION("62F16448C252807B" , vcmpps(k2, zmm3, zmmword_ptr(rdx, -8192), 123)); + TEST_INSTRUCTION("62F16448C292C0DFFFFF7B" , vcmpps(k2, zmm3, zmmword_ptr(rdx, -8256), 123)); + TEST_INSTRUCTION("62F16458C2527F7B" , vcmpps(k2, zmm3, dword_ptr(rdx, 508)._1to16(), 123)); + TEST_INSTRUCTION("62F16458C292000200007B" , vcmpps(k2, zmm3, dword_ptr(rdx, 512)._1to16(), 123)); + TEST_INSTRUCTION("62F16458C252807B" , vcmpps(k2, zmm3, dword_ptr(rdx, -512)._1to16(), 123)); + TEST_INSTRUCTION("62F16458C292FCFDFFFF7B" , vcmpps(k2, zmm3, dword_ptr(rdx, -516)._1to16(), 123)); + TEST_INSTRUCTION("62F1D708C2E6AB" , vcmpsd(k4, xmm5, xmm6, 171)); + TEST_INSTRUCTION("62F1D70DC2E6AB" , k(k5).vcmpsd(k4, xmm5, xmm6, 171)); + TEST_INSTRUCTION("62F1D718C2E6AB" , sae().vcmpsd(k4, xmm5, xmm6, 171)); + TEST_INSTRUCTION("62F1D708C2E67B" , vcmpsd(k4, xmm5, xmm6, 123)); + TEST_INSTRUCTION("62F1D718C2E67B" , sae().vcmpsd(k4, xmm5, xmm6, 123)); + TEST_INSTRUCTION("62F1D708C2217B" , vcmpsd(k4, xmm5, qword_ptr(rcx), 123)); + TEST_INSTRUCTION("62B1D708C2A4F0341200007B" , vcmpsd(k4, xmm5, qword_ptr(rax, r14, 3, 4660), 123)); + TEST_INSTRUCTION("62F1D708C2627F7B" , vcmpsd(k4, xmm5, qword_ptr(rdx, 1016), 123)); + TEST_INSTRUCTION("62F1D708C2A2000400007B" , vcmpsd(k4, xmm5, qword_ptr(rdx, 1024), 123)); + TEST_INSTRUCTION("62F1D708C262807B" , vcmpsd(k4, xmm5, qword_ptr(rdx, -1024), 123)); + TEST_INSTRUCTION("62F1D708C2A2F8FBFFFF7B" , vcmpsd(k4, xmm5, qword_ptr(rdx, -1032), 123)); + TEST_INSTRUCTION("62916600C2D0AB" , vcmpss(k2, xmm19, xmm24, 171)); + TEST_INSTRUCTION("62916601C2D0AB" , k(k1).vcmpss(k2, xmm19, xmm24, 171)); + TEST_INSTRUCTION("62916610C2D0AB" , sae().vcmpss(k2, xmm19, xmm24, 171)); + TEST_INSTRUCTION("62916600C2D07B" , vcmpss(k2, xmm19, xmm24, 123)); + TEST_INSTRUCTION("62916610C2D07B" , sae().vcmpss(k2, xmm19, xmm24, 123)); + TEST_INSTRUCTION("62F16600C2117B" , vcmpss(k2, xmm19, dword_ptr(rcx), 123)); + TEST_INSTRUCTION("62B16600C294F0341200007B" , vcmpss(k2, xmm19, dword_ptr(rax, r14, 3, 4660), 123)); + TEST_INSTRUCTION("62F16600C2527F7B" , vcmpss(k2, xmm19, dword_ptr(rdx, 508), 123)); + TEST_INSTRUCTION("62F16600C292000200007B" , vcmpss(k2, xmm19, dword_ptr(rdx, 512), 123)); + TEST_INSTRUCTION("62F16600C252807B" , vcmpss(k2, xmm19, dword_ptr(rdx, -512), 123)); + TEST_INSTRUCTION("62F16600C292FCFDFFFF7B" , vcmpss(k2, xmm19, dword_ptr(rdx, -516), 123)); + TEST_INSTRUCTION("C441792FEB" , vcomisd(xmm13, xmm11)); + TEST_INSTRUCTION("6251FD182FEB" , sae().vcomisd(xmm13, xmm11)); + TEST_INSTRUCTION("C5792F29" , vcomisd(xmm13, qword_ptr(rcx))); + TEST_INSTRUCTION("C421792FACF034120000" , vcomisd(xmm13, qword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("C5792FAAF8030000" , vcomisd(xmm13, qword_ptr(rdx, 1016))); + TEST_INSTRUCTION("C5792FAA00040000" , vcomisd(xmm13, qword_ptr(rdx, 1024))); + TEST_INSTRUCTION("C5792FAA00FCFFFF" , vcomisd(xmm13, qword_ptr(rdx, -1024))); + TEST_INSTRUCTION("C5792FAAF8FBFFFF" , vcomisd(xmm13, qword_ptr(rdx, -1032))); + TEST_INSTRUCTION("C441782FC7" , vcomiss(xmm8, xmm15)); + TEST_INSTRUCTION("62517C182FC7" , sae().vcomiss(xmm8, xmm15)); + TEST_INSTRUCTION("C5782F01" , vcomiss(xmm8, dword_ptr(rcx))); + TEST_INSTRUCTION("C421782F84F034120000" , vcomiss(xmm8, dword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("C5782F82FC010000" , vcomiss(xmm8, dword_ptr(rdx, 508))); + TEST_INSTRUCTION("C5782F8200020000" , vcomiss(xmm8, dword_ptr(rdx, 512))); + TEST_INSTRUCTION("C5782F8200FEFFFF" , vcomiss(xmm8, dword_ptr(rdx, -512))); + TEST_INSTRUCTION("C5782F82FCFDFFFF" , vcomiss(xmm8, dword_ptr(rdx, -516))); + TEST_INSTRUCTION("6262FD488A31" , vcompresspd(zmmword_ptr(rcx), zmm30)); + TEST_INSTRUCTION("6262FD4F8A31" , k(k7).vcompresspd(zmmword_ptr(rcx), zmm30)); + TEST_INSTRUCTION("6222FD488AB4F034120000" , vcompresspd(zmmword_ptr(rax, r14, 3, 4660), zmm30)); + TEST_INSTRUCTION("6262FD488A727F" , vcompresspd(zmmword_ptr(rdx, 1016), zmm30)); + TEST_INSTRUCTION("6262FD488AB200040000" , vcompresspd(zmmword_ptr(rdx, 1024), zmm30)); + TEST_INSTRUCTION("6262FD488A7280" , vcompresspd(zmmword_ptr(rdx, -1024), zmm30)); + TEST_INSTRUCTION("6262FD488AB2F8FBFFFF" , vcompresspd(zmmword_ptr(rdx, -1032), zmm30)); + TEST_INSTRUCTION("6262FD488AC9" , vcompresspd(zmm1, zmm25)); + TEST_INSTRUCTION("6262FD4C8AC9" , k(k4).vcompresspd(zmm1, zmm25)); + TEST_INSTRUCTION("6262FDCC8AC9" , k(k4).z().vcompresspd(zmm1, zmm25)); + TEST_INSTRUCTION("62727D488A11" , vcompressps(zmmword_ptr(rcx), zmm10)); + TEST_INSTRUCTION("62727D4C8A11" , k(k4).vcompressps(zmmword_ptr(rcx), zmm10)); + TEST_INSTRUCTION("62327D488A94F034120000" , vcompressps(zmmword_ptr(rax, r14, 3, 4660), zmm10)); + TEST_INSTRUCTION("62727D488A527F" , vcompressps(zmmword_ptr(rdx, 508), zmm10)); + TEST_INSTRUCTION("62727D488A9200020000" , vcompressps(zmmword_ptr(rdx, 512), zmm10)); + TEST_INSTRUCTION("62727D488A5280" , vcompressps(zmmword_ptr(rdx, -512), zmm10)); + TEST_INSTRUCTION("62727D488A92FCFDFFFF" , vcompressps(zmmword_ptr(rdx, -516), zmm10)); + TEST_INSTRUCTION("62B27D488AFB" , vcompressps(zmm19, zmm7)); + TEST_INSTRUCTION("62B27D4B8AFB" , k(k3).vcompressps(zmm19, zmm7)); + TEST_INSTRUCTION("62B27DCB8AFB" , k(k3).z().vcompressps(zmm19, zmm7)); + TEST_INSTRUCTION("62217E48E6E4" , vcvtdq2pd(zmm28, ymm20)); + TEST_INSTRUCTION("62217E4AE6E4" , k(k2).vcvtdq2pd(zmm28, ymm20)); + TEST_INSTRUCTION("62217ECAE6E4" , k(k2).z().vcvtdq2pd(zmm28, ymm20)); + TEST_INSTRUCTION("62617E48E621" , vcvtdq2pd(zmm28, ymmword_ptr(rcx))); + TEST_INSTRUCTION("62217E48E6A4F034120000" , vcvtdq2pd(zmm28, ymmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62617E58E621" , vcvtdq2pd(zmm28, dword_ptr(rcx)._1to8())); + TEST_INSTRUCTION("62617E48E6627F" , vcvtdq2pd(zmm28, ymmword_ptr(rdx, 4064))); + TEST_INSTRUCTION("62617E48E6A200100000" , vcvtdq2pd(zmm28, ymmword_ptr(rdx, 4096))); + TEST_INSTRUCTION("62617E48E66280" , vcvtdq2pd(zmm28, ymmword_ptr(rdx, -4096))); + TEST_INSTRUCTION("62617E48E6A2E0EFFFFF" , vcvtdq2pd(zmm28, ymmword_ptr(rdx, -4128))); + TEST_INSTRUCTION("62617E58E6627F" , vcvtdq2pd(zmm28, dword_ptr(rdx, 508)._1to8())); + TEST_INSTRUCTION("62617E58E6A200020000" , vcvtdq2pd(zmm28, dword_ptr(rdx, 512)._1to8())); + TEST_INSTRUCTION("62617E58E66280" , vcvtdq2pd(zmm28, dword_ptr(rdx, -512)._1to8())); + TEST_INSTRUCTION("62617E58E6A2FCFDFFFF" , vcvtdq2pd(zmm28, dword_ptr(rdx, -516)._1to8())); + TEST_INSTRUCTION("62E17C485BDC" , vcvtdq2ps(zmm19, zmm4)); + TEST_INSTRUCTION("62E17C4D5BDC" , k(k5).vcvtdq2ps(zmm19, zmm4)); + TEST_INSTRUCTION("62E17CCD5BDC" , k(k5).z().vcvtdq2ps(zmm19, zmm4)); + TEST_INSTRUCTION("62E17C185BDC" , rn_sae().vcvtdq2ps(zmm19, zmm4)); + TEST_INSTRUCTION("62E17C585BDC" , ru_sae().vcvtdq2ps(zmm19, zmm4)); + TEST_INSTRUCTION("62E17C385BDC" , rd_sae().vcvtdq2ps(zmm19, zmm4)); + TEST_INSTRUCTION("62E17C785BDC" , rz_sae().vcvtdq2ps(zmm19, zmm4)); + TEST_INSTRUCTION("62E17C485B19" , vcvtdq2ps(zmm19, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62A17C485B9CF034120000" , vcvtdq2ps(zmm19, zmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62E17C585B19" , vcvtdq2ps(zmm19, dword_ptr(rcx)._1to16())); + TEST_INSTRUCTION("62E17C485B5A7F" , vcvtdq2ps(zmm19, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62E17C485B9A00200000" , vcvtdq2ps(zmm19, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62E17C485B5A80" , vcvtdq2ps(zmm19, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62E17C485B9AC0DFFFFF" , vcvtdq2ps(zmm19, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62E17C585B5A7F" , vcvtdq2ps(zmm19, dword_ptr(rdx, 508)._1to16())); + TEST_INSTRUCTION("62E17C585B9A00020000" , vcvtdq2ps(zmm19, dword_ptr(rdx, 512)._1to16())); + TEST_INSTRUCTION("62E17C585B5A80" , vcvtdq2ps(zmm19, dword_ptr(rdx, -512)._1to16())); + TEST_INSTRUCTION("62E17C585B9AFCFDFFFF" , vcvtdq2ps(zmm19, dword_ptr(rdx, -516)._1to16())); + TEST_INSTRUCTION("62F1FF48E6F2" , vcvtpd2dq(ymm6, zmm2)); + TEST_INSTRUCTION("62F1FF4EE6F2" , k(k6).vcvtpd2dq(ymm6, zmm2)); + TEST_INSTRUCTION("62F1FFCEE6F2" , k(k6).z().vcvtpd2dq(ymm6, zmm2)); + TEST_INSTRUCTION("62F1FF18E6F2" , rn_sae().vcvtpd2dq(ymm6, zmm2)); + TEST_INSTRUCTION("62F1FF58E6F2" , ru_sae().vcvtpd2dq(ymm6, zmm2)); + TEST_INSTRUCTION("62F1FF38E6F2" , rd_sae().vcvtpd2dq(ymm6, zmm2)); + TEST_INSTRUCTION("62F1FF78E6F2" , rz_sae().vcvtpd2dq(ymm6, zmm2)); + TEST_INSTRUCTION("62F1FF48E631" , vcvtpd2dq(ymm6, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62B1FF48E6B4F034120000" , vcvtpd2dq(ymm6, zmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62F1FF58E631" , vcvtpd2dq(ymm6, qword_ptr(rcx)._1to8())); + TEST_INSTRUCTION("62F1FF48E6727F" , vcvtpd2dq(ymm6, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62F1FF48E6B200200000" , vcvtpd2dq(ymm6, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62F1FF48E67280" , vcvtpd2dq(ymm6, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62F1FF48E6B2C0DFFFFF" , vcvtpd2dq(ymm6, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62F1FF58E6727F" , vcvtpd2dq(ymm6, qword_ptr(rdx, 1016)._1to8())); + TEST_INSTRUCTION("62F1FF58E6B200040000" , vcvtpd2dq(ymm6, qword_ptr(rdx, 1024)._1to8())); + TEST_INSTRUCTION("62F1FF58E67280" , vcvtpd2dq(ymm6, qword_ptr(rdx, -1024)._1to8())); + TEST_INSTRUCTION("62F1FF58E6B2F8FBFFFF" , vcvtpd2dq(ymm6, qword_ptr(rdx, -1032)._1to8())); + TEST_INSTRUCTION("62C1FD485AC2" , vcvtpd2ps(ymm16, zmm10)); + TEST_INSTRUCTION("62C1FD4A5AC2" , k(k2).vcvtpd2ps(ymm16, zmm10)); + TEST_INSTRUCTION("62C1FDCA5AC2" , k(k2).z().vcvtpd2ps(ymm16, zmm10)); + TEST_INSTRUCTION("62C1FD185AC2" , rn_sae().vcvtpd2ps(ymm16, zmm10)); + TEST_INSTRUCTION("62C1FD585AC2" , ru_sae().vcvtpd2ps(ymm16, zmm10)); + TEST_INSTRUCTION("62C1FD385AC2" , rd_sae().vcvtpd2ps(ymm16, zmm10)); + TEST_INSTRUCTION("62C1FD785AC2" , rz_sae().vcvtpd2ps(ymm16, zmm10)); + TEST_INSTRUCTION("62E1FD485A01" , vcvtpd2ps(ymm16, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62A1FD485A84F034120000" , vcvtpd2ps(ymm16, zmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62E1FD585A01" , vcvtpd2ps(ymm16, qword_ptr(rcx)._1to8())); + TEST_INSTRUCTION("62E1FD485A427F" , vcvtpd2ps(ymm16, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62E1FD485A8200200000" , vcvtpd2ps(ymm16, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62E1FD485A4280" , vcvtpd2ps(ymm16, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62E1FD485A82C0DFFFFF" , vcvtpd2ps(ymm16, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62E1FD585A427F" , vcvtpd2ps(ymm16, qword_ptr(rdx, 1016)._1to8())); + TEST_INSTRUCTION("62E1FD585A8200040000" , vcvtpd2ps(ymm16, qword_ptr(rdx, 1024)._1to8())); + TEST_INSTRUCTION("62E1FD585A4280" , vcvtpd2ps(ymm16, qword_ptr(rdx, -1024)._1to8())); + TEST_INSTRUCTION("62E1FD585A82F8FBFFFF" , vcvtpd2ps(ymm16, qword_ptr(rdx, -1032)._1to8())); + TEST_INSTRUCTION("6201FC4879C9" , vcvtpd2udq(ymm25, zmm25)); + TEST_INSTRUCTION("6201FC4979C9" , k(k1).vcvtpd2udq(ymm25, zmm25)); + TEST_INSTRUCTION("6201FCC979C9" , k(k1).z().vcvtpd2udq(ymm25, zmm25)); + TEST_INSTRUCTION("6201FC1879C9" , rn_sae().vcvtpd2udq(ymm25, zmm25)); + TEST_INSTRUCTION("6201FC5879C9" , ru_sae().vcvtpd2udq(ymm25, zmm25)); + TEST_INSTRUCTION("6201FC3879C9" , rd_sae().vcvtpd2udq(ymm25, zmm25)); + TEST_INSTRUCTION("6201FC7879C9" , rz_sae().vcvtpd2udq(ymm25, zmm25)); + TEST_INSTRUCTION("6261FC487909" , vcvtpd2udq(ymm25, zmmword_ptr(rcx))); + TEST_INSTRUCTION("6221FC48798CF034120000" , vcvtpd2udq(ymm25, zmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("6261FC587909" , vcvtpd2udq(ymm25, qword_ptr(rcx)._1to8())); + TEST_INSTRUCTION("6261FC48794A7F" , vcvtpd2udq(ymm25, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("6261FC48798A00200000" , vcvtpd2udq(ymm25, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("6261FC48794A80" , vcvtpd2udq(ymm25, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("6261FC48798AC0DFFFFF" , vcvtpd2udq(ymm25, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("6261FC58794A7F" , vcvtpd2udq(ymm25, qword_ptr(rdx, 1016)._1to8())); + TEST_INSTRUCTION("6261FC58798A00040000" , vcvtpd2udq(ymm25, qword_ptr(rdx, 1024)._1to8())); + TEST_INSTRUCTION("6261FC58794A80" , vcvtpd2udq(ymm25, qword_ptr(rdx, -1024)._1to8())); + TEST_INSTRUCTION("6261FC58798AF8FBFFFF" , vcvtpd2udq(ymm25, qword_ptr(rdx, -1032)._1to8())); + TEST_INSTRUCTION("62327D4813CD" , vcvtph2ps(zmm9, ymm21)); + TEST_INSTRUCTION("62327D4B13CD" , k(k3).vcvtph2ps(zmm9, ymm21)); + TEST_INSTRUCTION("62327DCB13CD" , k(k3).z().vcvtph2ps(zmm9, ymm21)); + TEST_INSTRUCTION("62327D1813CD" , sae().vcvtph2ps(zmm9, ymm21)); + TEST_INSTRUCTION("62727D481309" , vcvtph2ps(zmm9, ymmword_ptr(rcx))); + TEST_INSTRUCTION("62327D48138CF034120000" , vcvtph2ps(zmm9, ymmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62727D48134A7F" , vcvtph2ps(zmm9, ymmword_ptr(rdx, 4064))); + TEST_INSTRUCTION("62727D48138A00100000" , vcvtph2ps(zmm9, ymmword_ptr(rdx, 4096))); + TEST_INSTRUCTION("62727D48134A80" , vcvtph2ps(zmm9, ymmword_ptr(rdx, -4096))); + TEST_INSTRUCTION("62727D48138AE0EFFFFF" , vcvtph2ps(zmm9, ymmword_ptr(rdx, -4128))); + TEST_INSTRUCTION("62E17D485BC6" , vcvtps2dq(zmm16, zmm6)); + TEST_INSTRUCTION("62E17D4A5BC6" , k(k2).vcvtps2dq(zmm16, zmm6)); + TEST_INSTRUCTION("62E17DCA5BC6" , k(k2).z().vcvtps2dq(zmm16, zmm6)); + TEST_INSTRUCTION("62E17D185BC6" , rn_sae().vcvtps2dq(zmm16, zmm6)); + TEST_INSTRUCTION("62E17D585BC6" , ru_sae().vcvtps2dq(zmm16, zmm6)); + TEST_INSTRUCTION("62E17D385BC6" , rd_sae().vcvtps2dq(zmm16, zmm6)); + TEST_INSTRUCTION("62E17D785BC6" , rz_sae().vcvtps2dq(zmm16, zmm6)); + TEST_INSTRUCTION("62E17D485B01" , vcvtps2dq(zmm16, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62A17D485B84F034120000" , vcvtps2dq(zmm16, zmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62E17D585B01" , vcvtps2dq(zmm16, dword_ptr(rcx)._1to16())); + TEST_INSTRUCTION("62E17D485B427F" , vcvtps2dq(zmm16, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62E17D485B8200200000" , vcvtps2dq(zmm16, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62E17D485B4280" , vcvtps2dq(zmm16, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62E17D485B82C0DFFFFF" , vcvtps2dq(zmm16, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62E17D585B427F" , vcvtps2dq(zmm16, dword_ptr(rdx, 508)._1to16())); + TEST_INSTRUCTION("62E17D585B8200020000" , vcvtps2dq(zmm16, dword_ptr(rdx, 512)._1to16())); + TEST_INSTRUCTION("62E17D585B4280" , vcvtps2dq(zmm16, dword_ptr(rdx, -512)._1to16())); + TEST_INSTRUCTION("62E17D585B82FCFDFFFF" , vcvtps2dq(zmm16, dword_ptr(rdx, -516)._1to16())); + TEST_INSTRUCTION("62117C485AD8" , vcvtps2pd(zmm11, ymm24)); + TEST_INSTRUCTION("62117C4B5AD8" , k(k3).vcvtps2pd(zmm11, ymm24)); + TEST_INSTRUCTION("62117CCB5AD8" , k(k3).z().vcvtps2pd(zmm11, ymm24)); + TEST_INSTRUCTION("62117C185AD8" , sae().vcvtps2pd(zmm11, ymm24)); + TEST_INSTRUCTION("62717C485A19" , vcvtps2pd(zmm11, ymmword_ptr(rcx))); + TEST_INSTRUCTION("62317C485A9CF034120000" , vcvtps2pd(zmm11, ymmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62717C585A19" , vcvtps2pd(zmm11, dword_ptr(rcx)._1to8())); + TEST_INSTRUCTION("62717C485A5A7F" , vcvtps2pd(zmm11, ymmword_ptr(rdx, 4064))); + TEST_INSTRUCTION("62717C485A9A00100000" , vcvtps2pd(zmm11, ymmword_ptr(rdx, 4096))); + TEST_INSTRUCTION("62717C485A5A80" , vcvtps2pd(zmm11, ymmword_ptr(rdx, -4096))); + TEST_INSTRUCTION("62717C485A9AE0EFFFFF" , vcvtps2pd(zmm11, ymmword_ptr(rdx, -4128))); + TEST_INSTRUCTION("62717C585A5A7F" , vcvtps2pd(zmm11, dword_ptr(rdx, 508)._1to8())); + TEST_INSTRUCTION("62717C585A9A00020000" , vcvtps2pd(zmm11, dword_ptr(rdx, 512)._1to8())); + TEST_INSTRUCTION("62717C585A5A80" , vcvtps2pd(zmm11, dword_ptr(rdx, -512)._1to8())); + TEST_INSTRUCTION("62717C585A9AFCFDFFFF" , vcvtps2pd(zmm11, dword_ptr(rdx, -516)._1to8())); + TEST_INSTRUCTION("62C37D481DF1AB" , vcvtps2ph(ymm9, zmm22, 171)); + TEST_INSTRUCTION("62C37D4F1DF1AB" , k(k7).vcvtps2ph(ymm9, zmm22, 171)); + TEST_INSTRUCTION("62C37DCF1DF1AB" , k(k7).z().vcvtps2ph(ymm9, zmm22, 171)); + TEST_INSTRUCTION("62C37D181DF1AB" , sae().vcvtps2ph(ymm9, zmm22, 171)); + TEST_INSTRUCTION("62C37D481DF17B" , vcvtps2ph(ymm9, zmm22, 123)); + TEST_INSTRUCTION("62C37D181DF17B" , sae().vcvtps2ph(ymm9, zmm22, 123)); + TEST_INSTRUCTION("62F17C4879EC" , vcvtps2udq(zmm5, zmm4)); + TEST_INSTRUCTION("62F17C4D79EC" , k(k5).vcvtps2udq(zmm5, zmm4)); + TEST_INSTRUCTION("62F17CCD79EC" , k(k5).z().vcvtps2udq(zmm5, zmm4)); + TEST_INSTRUCTION("62F17C1879EC" , rn_sae().vcvtps2udq(zmm5, zmm4)); + TEST_INSTRUCTION("62F17C5879EC" , ru_sae().vcvtps2udq(zmm5, zmm4)); + TEST_INSTRUCTION("62F17C3879EC" , rd_sae().vcvtps2udq(zmm5, zmm4)); + TEST_INSTRUCTION("62F17C7879EC" , rz_sae().vcvtps2udq(zmm5, zmm4)); + TEST_INSTRUCTION("62F17C487929" , vcvtps2udq(zmm5, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62B17C4879ACF034120000" , vcvtps2udq(zmm5, zmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62F17C587929" , vcvtps2udq(zmm5, dword_ptr(rcx)._1to16())); + TEST_INSTRUCTION("62F17C48796A7F" , vcvtps2udq(zmm5, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62F17C4879AA00200000" , vcvtps2udq(zmm5, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62F17C48796A80" , vcvtps2udq(zmm5, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62F17C4879AAC0DFFFFF" , vcvtps2udq(zmm5, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62F17C58796A7F" , vcvtps2udq(zmm5, dword_ptr(rdx, 508)._1to16())); + TEST_INSTRUCTION("62F17C5879AA00020000" , vcvtps2udq(zmm5, dword_ptr(rdx, 512)._1to16())); + TEST_INSTRUCTION("62F17C58796A80" , vcvtps2udq(zmm5, dword_ptr(rdx, -512)._1to16())); + TEST_INSTRUCTION("62F17C5879AAFCFDFFFF" , vcvtps2udq(zmm5, dword_ptr(rdx, -516)._1to16())); + TEST_INSTRUCTION("62F17F182DC4" , rn_sae().vcvtsd2si(eax, xmm4)); + TEST_INSTRUCTION("62F17F582DC4" , ru_sae().vcvtsd2si(eax, xmm4)); + TEST_INSTRUCTION("62F17F382DC4" , rd_sae().vcvtsd2si(eax, xmm4)); + TEST_INSTRUCTION("62F17F782DC4" , rz_sae().vcvtsd2si(eax, xmm4)); + TEST_INSTRUCTION("62F17F182DEC" , rn_sae().vcvtsd2si(ebp, xmm4)); + TEST_INSTRUCTION("62F17F582DEC" , ru_sae().vcvtsd2si(ebp, xmm4)); + TEST_INSTRUCTION("62F17F382DEC" , rd_sae().vcvtsd2si(ebp, xmm4)); + TEST_INSTRUCTION("62F17F782DEC" , rz_sae().vcvtsd2si(ebp, xmm4)); + TEST_INSTRUCTION("62717F182DEC" , rn_sae().vcvtsd2si(r13d, xmm4)); + TEST_INSTRUCTION("62717F582DEC" , ru_sae().vcvtsd2si(r13d, xmm4)); + TEST_INSTRUCTION("62717F382DEC" , rd_sae().vcvtsd2si(r13d, xmm4)); + TEST_INSTRUCTION("62717F782DEC" , rz_sae().vcvtsd2si(r13d, xmm4)); + TEST_INSTRUCTION("6291FF182DC3" , rn_sae().vcvtsd2si(rax, xmm27)); + TEST_INSTRUCTION("6291FF582DC3" , ru_sae().vcvtsd2si(rax, xmm27)); + TEST_INSTRUCTION("6291FF382DC3" , rd_sae().vcvtsd2si(rax, xmm27)); + TEST_INSTRUCTION("6291FF782DC3" , rz_sae().vcvtsd2si(rax, xmm27)); + TEST_INSTRUCTION("6211FF182DC3" , rn_sae().vcvtsd2si(r8, xmm27)); + TEST_INSTRUCTION("6211FF582DC3" , ru_sae().vcvtsd2si(r8, xmm27)); + TEST_INSTRUCTION("6211FF382DC3" , rd_sae().vcvtsd2si(r8, xmm27)); + TEST_INSTRUCTION("6211FF782DC3" , rz_sae().vcvtsd2si(r8, xmm27)); + TEST_INSTRUCTION("C5B32AE0" , vcvtsi2sd(xmm4, xmm9, eax)); + TEST_INSTRUCTION("C5B32AE5" , vcvtsi2sd(xmm4, xmm9, ebp)); + TEST_INSTRUCTION("C4C1332AE5" , vcvtsi2sd(xmm4, xmm9, r13d)); + TEST_INSTRUCTION("C5B32A21" , vcvtsi2sd(xmm4, xmm9, dword_ptr(rcx))); + TEST_INSTRUCTION("C4A1332AA4F034120000" , vcvtsi2sd(xmm4, xmm9, dword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("C5B32AA2FC010000" , vcvtsi2sd(xmm4, xmm9, dword_ptr(rdx, 508))); + TEST_INSTRUCTION("C5B32AA200020000" , vcvtsi2sd(xmm4, xmm9, dword_ptr(rdx, 512))); + TEST_INSTRUCTION("C5B32AA200FEFFFF" , vcvtsi2sd(xmm4, xmm9, dword_ptr(rdx, -512))); + TEST_INSTRUCTION("C5B32AA2FCFDFFFF" , vcvtsi2sd(xmm4, xmm9, dword_ptr(rdx, -516))); + TEST_INSTRUCTION("6261F7002AC0" , vcvtsi2sd(xmm24, xmm17, rax)); + TEST_INSTRUCTION("6261F7102AC0" , rn_sae().vcvtsi2sd(xmm24, xmm17, rax)); + TEST_INSTRUCTION("6261F7502AC0" , ru_sae().vcvtsi2sd(xmm24, xmm17, rax)); + TEST_INSTRUCTION("6261F7302AC0" , rd_sae().vcvtsi2sd(xmm24, xmm17, rax)); + TEST_INSTRUCTION("6261F7702AC0" , rz_sae().vcvtsi2sd(xmm24, xmm17, rax)); + TEST_INSTRUCTION("6241F7002AC0" , vcvtsi2sd(xmm24, xmm17, r8)); + TEST_INSTRUCTION("6241F7102AC0" , rn_sae().vcvtsi2sd(xmm24, xmm17, r8)); + TEST_INSTRUCTION("6241F7502AC0" , ru_sae().vcvtsi2sd(xmm24, xmm17, r8)); + TEST_INSTRUCTION("6241F7302AC0" , rd_sae().vcvtsi2sd(xmm24, xmm17, r8)); + TEST_INSTRUCTION("6241F7702AC0" , rz_sae().vcvtsi2sd(xmm24, xmm17, r8)); + TEST_INSTRUCTION("6261F7002A01" , vcvtsi2sd(xmm24, xmm17, qword_ptr(rcx))); + TEST_INSTRUCTION("6221F7002A84F034120000" , vcvtsi2sd(xmm24, xmm17, qword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("6261F7002A427F" , vcvtsi2sd(xmm24, xmm17, qword_ptr(rdx, 1016))); + TEST_INSTRUCTION("6261F7002A8200040000" , vcvtsi2sd(xmm24, xmm17, qword_ptr(rdx, 1024))); + TEST_INSTRUCTION("6261F7002A4280" , vcvtsi2sd(xmm24, xmm17, qword_ptr(rdx, -1024))); + TEST_INSTRUCTION("6261F7002A82F8FBFFFF" , vcvtsi2sd(xmm24, xmm17, qword_ptr(rdx, -1032))); + TEST_INSTRUCTION("62611E002AC8" , vcvtsi2ss(xmm25, xmm28, eax)); + TEST_INSTRUCTION("62611E102AC8" , rn_sae().vcvtsi2ss(xmm25, xmm28, eax)); + TEST_INSTRUCTION("62611E502AC8" , ru_sae().vcvtsi2ss(xmm25, xmm28, eax)); + TEST_INSTRUCTION("62611E302AC8" , rd_sae().vcvtsi2ss(xmm25, xmm28, eax)); + TEST_INSTRUCTION("62611E702AC8" , rz_sae().vcvtsi2ss(xmm25, xmm28, eax)); + TEST_INSTRUCTION("62611E002ACD" , vcvtsi2ss(xmm25, xmm28, ebp)); + TEST_INSTRUCTION("62611E102ACD" , rn_sae().vcvtsi2ss(xmm25, xmm28, ebp)); + TEST_INSTRUCTION("62611E502ACD" , ru_sae().vcvtsi2ss(xmm25, xmm28, ebp)); + TEST_INSTRUCTION("62611E302ACD" , rd_sae().vcvtsi2ss(xmm25, xmm28, ebp)); + TEST_INSTRUCTION("62611E702ACD" , rz_sae().vcvtsi2ss(xmm25, xmm28, ebp)); + TEST_INSTRUCTION("62411E002ACD" , vcvtsi2ss(xmm25, xmm28, r13d)); + TEST_INSTRUCTION("62411E102ACD" , rn_sae().vcvtsi2ss(xmm25, xmm28, r13d)); + TEST_INSTRUCTION("62411E502ACD" , ru_sae().vcvtsi2ss(xmm25, xmm28, r13d)); + TEST_INSTRUCTION("62411E302ACD" , rd_sae().vcvtsi2ss(xmm25, xmm28, r13d)); + TEST_INSTRUCTION("62411E702ACD" , rz_sae().vcvtsi2ss(xmm25, xmm28, r13d)); + TEST_INSTRUCTION("62611E002A09" , vcvtsi2ss(xmm25, xmm28, dword_ptr(rcx))); + TEST_INSTRUCTION("62211E002A8CF034120000" , vcvtsi2ss(xmm25, xmm28, dword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62611E002A4A7F" , vcvtsi2ss(xmm25, xmm28, dword_ptr(rdx, 508))); + TEST_INSTRUCTION("62611E002A8A00020000" , vcvtsi2ss(xmm25, xmm28, dword_ptr(rdx, 512))); + TEST_INSTRUCTION("62611E002A4A80" , vcvtsi2ss(xmm25, xmm28, dword_ptr(rdx, -512))); + TEST_INSTRUCTION("62611E002A8AFCFDFFFF" , vcvtsi2ss(xmm25, xmm28, dword_ptr(rdx, -516))); + TEST_INSTRUCTION("C4E1BA2AE0" , vcvtsi2ss(xmm4, xmm8, rax)); + TEST_INSTRUCTION("62F1BE182AE0" , rn_sae().vcvtsi2ss(xmm4, xmm8, rax)); + TEST_INSTRUCTION("62F1BE582AE0" , ru_sae().vcvtsi2ss(xmm4, xmm8, rax)); + TEST_INSTRUCTION("62F1BE382AE0" , rd_sae().vcvtsi2ss(xmm4, xmm8, rax)); + TEST_INSTRUCTION("62F1BE782AE0" , rz_sae().vcvtsi2ss(xmm4, xmm8, rax)); + TEST_INSTRUCTION("C4C1BA2AE0" , vcvtsi2ss(xmm4, xmm8, r8)); + TEST_INSTRUCTION("62D1BE182AE0" , rn_sae().vcvtsi2ss(xmm4, xmm8, r8)); + TEST_INSTRUCTION("62D1BE582AE0" , ru_sae().vcvtsi2ss(xmm4, xmm8, r8)); + TEST_INSTRUCTION("62D1BE382AE0" , rd_sae().vcvtsi2ss(xmm4, xmm8, r8)); + TEST_INSTRUCTION("62D1BE782AE0" , rz_sae().vcvtsi2ss(xmm4, xmm8, r8)); + TEST_INSTRUCTION("C4E1BA2A21" , vcvtsi2ss(xmm4, xmm8, qword_ptr(rcx))); + TEST_INSTRUCTION("C4A1BA2AA4F034120000" , vcvtsi2ss(xmm4, xmm8, qword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("C4E1BA2AA2F8030000" , vcvtsi2ss(xmm4, xmm8, qword_ptr(rdx, 1016))); + TEST_INSTRUCTION("C4E1BA2AA200040000" , vcvtsi2ss(xmm4, xmm8, qword_ptr(rdx, 1024))); + TEST_INSTRUCTION("C4E1BA2AA200FCFFFF" , vcvtsi2ss(xmm4, xmm8, qword_ptr(rdx, -1024))); + TEST_INSTRUCTION("C4E1BA2AA2F8FBFFFF" , vcvtsi2ss(xmm4, xmm8, qword_ptr(rdx, -1032))); + TEST_INSTRUCTION("62D17E182DC0" , rn_sae().vcvtss2si(eax, xmm8)); + TEST_INSTRUCTION("62D17E582DC0" , ru_sae().vcvtss2si(eax, xmm8)); + TEST_INSTRUCTION("62D17E382DC0" , rd_sae().vcvtss2si(eax, xmm8)); + TEST_INSTRUCTION("62D17E782DC0" , rz_sae().vcvtss2si(eax, xmm8)); + TEST_INSTRUCTION("62D17E182DE8" , rn_sae().vcvtss2si(ebp, xmm8)); + TEST_INSTRUCTION("62D17E582DE8" , ru_sae().vcvtss2si(ebp, xmm8)); + TEST_INSTRUCTION("62D17E382DE8" , rd_sae().vcvtss2si(ebp, xmm8)); + TEST_INSTRUCTION("62D17E782DE8" , rz_sae().vcvtss2si(ebp, xmm8)); + TEST_INSTRUCTION("62517E182DE8" , rn_sae().vcvtss2si(r13d, xmm8)); + TEST_INSTRUCTION("62517E582DE8" , ru_sae().vcvtss2si(r13d, xmm8)); + TEST_INSTRUCTION("62517E382DE8" , rd_sae().vcvtss2si(r13d, xmm8)); + TEST_INSTRUCTION("62517E782DE8" , rz_sae().vcvtss2si(r13d, xmm8)); + TEST_INSTRUCTION("62F1FE182DC6" , rn_sae().vcvtss2si(rax, xmm6)); + TEST_INSTRUCTION("62F1FE582DC6" , ru_sae().vcvtss2si(rax, xmm6)); + TEST_INSTRUCTION("62F1FE382DC6" , rd_sae().vcvtss2si(rax, xmm6)); + TEST_INSTRUCTION("62F1FE782DC6" , rz_sae().vcvtss2si(rax, xmm6)); + TEST_INSTRUCTION("6271FE182DC6" , rn_sae().vcvtss2si(r8, xmm6)); + TEST_INSTRUCTION("6271FE582DC6" , ru_sae().vcvtss2si(r8, xmm6)); + TEST_INSTRUCTION("6271FE382DC6" , rd_sae().vcvtss2si(r8, xmm6)); + TEST_INSTRUCTION("6271FE782DC6" , rz_sae().vcvtss2si(r8, xmm6)); + TEST_INSTRUCTION("62F1FD48E6E1" , vcvttpd2dq(ymm4, zmm1)); + TEST_INSTRUCTION("62F1FD4EE6E1" , k(k6).vcvttpd2dq(ymm4, zmm1)); + TEST_INSTRUCTION("62F1FDCEE6E1" , k(k6).z().vcvttpd2dq(ymm4, zmm1)); + TEST_INSTRUCTION("62F1FD18E6E1" , sae().vcvttpd2dq(ymm4, zmm1)); + TEST_INSTRUCTION("62F1FD48E621" , vcvttpd2dq(ymm4, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62B1FD48E6A4F034120000" , vcvttpd2dq(ymm4, zmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62F1FD58E621" , vcvttpd2dq(ymm4, qword_ptr(rcx)._1to8())); + TEST_INSTRUCTION("62F1FD48E6627F" , vcvttpd2dq(ymm4, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62F1FD48E6A200200000" , vcvttpd2dq(ymm4, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62F1FD48E66280" , vcvttpd2dq(ymm4, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62F1FD48E6A2C0DFFFFF" , vcvttpd2dq(ymm4, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62F1FD58E6627F" , vcvttpd2dq(ymm4, qword_ptr(rdx, 1016)._1to8())); + TEST_INSTRUCTION("62F1FD58E6A200040000" , vcvttpd2dq(ymm4, qword_ptr(rdx, 1024)._1to8())); + TEST_INSTRUCTION("62F1FD58E66280" , vcvttpd2dq(ymm4, qword_ptr(rdx, -1024)._1to8())); + TEST_INSTRUCTION("62F1FD58E6A2F8FBFFFF" , vcvttpd2dq(ymm4, qword_ptr(rdx, -1032)._1to8())); + TEST_INSTRUCTION("62817E485BFC" , vcvttps2dq(zmm23, zmm28)); + TEST_INSTRUCTION("62817E4B5BFC" , k(k3).vcvttps2dq(zmm23, zmm28)); + TEST_INSTRUCTION("62817ECB5BFC" , k(k3).z().vcvttps2dq(zmm23, zmm28)); + TEST_INSTRUCTION("62817E185BFC" , sae().vcvttps2dq(zmm23, zmm28)); + TEST_INSTRUCTION("62E17E485B39" , vcvttps2dq(zmm23, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62A17E485BBCF034120000" , vcvttps2dq(zmm23, zmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62E17E585B39" , vcvttps2dq(zmm23, dword_ptr(rcx)._1to16())); + TEST_INSTRUCTION("62E17E485B7A7F" , vcvttps2dq(zmm23, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62E17E485BBA00200000" , vcvttps2dq(zmm23, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62E17E485B7A80" , vcvttps2dq(zmm23, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62E17E485BBAC0DFFFFF" , vcvttps2dq(zmm23, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62E17E585B7A7F" , vcvttps2dq(zmm23, dword_ptr(rdx, 508)._1to16())); + TEST_INSTRUCTION("62E17E585BBA00020000" , vcvttps2dq(zmm23, dword_ptr(rdx, 512)._1to16())); + TEST_INSTRUCTION("62E17E585B7A80" , vcvttps2dq(zmm23, dword_ptr(rdx, -512)._1to16())); + TEST_INSTRUCTION("62E17E585BBAFCFDFFFF" , vcvttps2dq(zmm23, dword_ptr(rdx, -516)._1to16())); + TEST_INSTRUCTION("62F17F182CC5" , sae().vcvttsd2si(eax, xmm5)); + TEST_INSTRUCTION("62F17F182CED" , sae().vcvttsd2si(ebp, xmm5)); + TEST_INSTRUCTION("62717F182CED" , sae().vcvttsd2si(r13d, xmm5)); + TEST_INSTRUCTION("62F1FF182CC7" , sae().vcvttsd2si(rax, xmm7)); + TEST_INSTRUCTION("6271FF182CC7" , sae().vcvttsd2si(r8, xmm7)); + TEST_INSTRUCTION("62F17E182CC4" , sae().vcvttss2si(eax, xmm4)); + TEST_INSTRUCTION("62F17E182CEC" , sae().vcvttss2si(ebp, xmm4)); + TEST_INSTRUCTION("62717E182CEC" , sae().vcvttss2si(r13d, xmm4)); + TEST_INSTRUCTION("6291FE182CC3" , sae().vcvttss2si(rax, xmm27)); + TEST_INSTRUCTION("6211FE182CC3" , sae().vcvttss2si(r8, xmm27)); + TEST_INSTRUCTION("62817E487AD4" , vcvtudq2pd(zmm18, ymm28)); + TEST_INSTRUCTION("62817E497AD4" , k(k1).vcvtudq2pd(zmm18, ymm28)); + TEST_INSTRUCTION("62817EC97AD4" , k(k1).z().vcvtudq2pd(zmm18, ymm28)); + TEST_INSTRUCTION("62E17E487A11" , vcvtudq2pd(zmm18, ymmword_ptr(rcx))); + TEST_INSTRUCTION("62A17E487A94F034120000" , vcvtudq2pd(zmm18, ymmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62E17E587A11" , vcvtudq2pd(zmm18, dword_ptr(rcx)._1to8())); + TEST_INSTRUCTION("62E17E487A527F" , vcvtudq2pd(zmm18, ymmword_ptr(rdx, 4064))); + TEST_INSTRUCTION("62E17E487A9200100000" , vcvtudq2pd(zmm18, ymmword_ptr(rdx, 4096))); + TEST_INSTRUCTION("62E17E487A5280" , vcvtudq2pd(zmm18, ymmword_ptr(rdx, -4096))); + TEST_INSTRUCTION("62E17E487A92E0EFFFFF" , vcvtudq2pd(zmm18, ymmword_ptr(rdx, -4128))); + TEST_INSTRUCTION("62E17E587A527F" , vcvtudq2pd(zmm18, dword_ptr(rdx, 508)._1to8())); + TEST_INSTRUCTION("62E17E587A9200020000" , vcvtudq2pd(zmm18, dword_ptr(rdx, 512)._1to8())); + TEST_INSTRUCTION("62E17E587A5280" , vcvtudq2pd(zmm18, dword_ptr(rdx, -512)._1to8())); + TEST_INSTRUCTION("62E17E587A92FCFDFFFF" , vcvtudq2pd(zmm18, dword_ptr(rdx, -516)._1to8())); + TEST_INSTRUCTION("62917F487AF8" , vcvtudq2ps(zmm7, zmm24)); + TEST_INSTRUCTION("62917F4F7AF8" , k(k7).vcvtudq2ps(zmm7, zmm24)); + TEST_INSTRUCTION("62917FCF7AF8" , k(k7).z().vcvtudq2ps(zmm7, zmm24)); + TEST_INSTRUCTION("62917F187AF8" , rn_sae().vcvtudq2ps(zmm7, zmm24)); + TEST_INSTRUCTION("62917F587AF8" , ru_sae().vcvtudq2ps(zmm7, zmm24)); + TEST_INSTRUCTION("62917F387AF8" , rd_sae().vcvtudq2ps(zmm7, zmm24)); + TEST_INSTRUCTION("62917F787AF8" , rz_sae().vcvtudq2ps(zmm7, zmm24)); + TEST_INSTRUCTION("62F17F487A39" , vcvtudq2ps(zmm7, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62B17F487ABCF034120000" , vcvtudq2ps(zmm7, zmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62F17F587A39" , vcvtudq2ps(zmm7, dword_ptr(rcx)._1to16())); + TEST_INSTRUCTION("62F17F487A7A7F" , vcvtudq2ps(zmm7, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62F17F487ABA00200000" , vcvtudq2ps(zmm7, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62F17F487A7A80" , vcvtudq2ps(zmm7, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62F17F487ABAC0DFFFFF" , vcvtudq2ps(zmm7, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62F17F587A7A7F" , vcvtudq2ps(zmm7, dword_ptr(rdx, 508)._1to16())); + TEST_INSTRUCTION("62F17F587ABA00020000" , vcvtudq2ps(zmm7, dword_ptr(rdx, 512)._1to16())); + TEST_INSTRUCTION("62F17F587A7A80" , vcvtudq2ps(zmm7, dword_ptr(rdx, -512)._1to16())); + TEST_INSTRUCTION("62F17F587ABAFCFDFFFF" , vcvtudq2ps(zmm7, dword_ptr(rdx, -516)._1to16())); + TEST_INSTRUCTION("62A1DD485ED3" , vdivpd(zmm18, zmm4, zmm19)); + TEST_INSTRUCTION("62A1DD4D5ED3" , k(k5).vdivpd(zmm18, zmm4, zmm19)); + TEST_INSTRUCTION("62A1DDCD5ED3" , k(k5).z().vdivpd(zmm18, zmm4, zmm19)); + TEST_INSTRUCTION("62A1DD185ED3" , rn_sae().vdivpd(zmm18, zmm4, zmm19)); + TEST_INSTRUCTION("62A1DD585ED3" , ru_sae().vdivpd(zmm18, zmm4, zmm19)); + TEST_INSTRUCTION("62A1DD385ED3" , rd_sae().vdivpd(zmm18, zmm4, zmm19)); + TEST_INSTRUCTION("62A1DD785ED3" , rz_sae().vdivpd(zmm18, zmm4, zmm19)); + TEST_INSTRUCTION("62E1DD485E11" , vdivpd(zmm18, zmm4, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62A1DD485E94F034120000" , vdivpd(zmm18, zmm4, zmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62E1DD585E11" , vdivpd(zmm18, zmm4, qword_ptr(rcx)._1to8())); + TEST_INSTRUCTION("62E1DD485E527F" , vdivpd(zmm18, zmm4, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62E1DD485E9200200000" , vdivpd(zmm18, zmm4, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62E1DD485E5280" , vdivpd(zmm18, zmm4, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62E1DD485E92C0DFFFFF" , vdivpd(zmm18, zmm4, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62E1DD585E527F" , vdivpd(zmm18, zmm4, qword_ptr(rdx, 1016)._1to8())); + TEST_INSTRUCTION("62E1DD585E9200040000" , vdivpd(zmm18, zmm4, qword_ptr(rdx, 1024)._1to8())); + TEST_INSTRUCTION("62E1DD585E5280" , vdivpd(zmm18, zmm4, qword_ptr(rdx, -1024)._1to8())); + TEST_INSTRUCTION("62E1DD585E92F8FBFFFF" , vdivpd(zmm18, zmm4, qword_ptr(rdx, -1032)._1to8())); + TEST_INSTRUCTION("62F114405EF4" , vdivps(zmm6, zmm29, zmm4)); + TEST_INSTRUCTION("62F114465EF4" , k(k6).vdivps(zmm6, zmm29, zmm4)); + TEST_INSTRUCTION("62F114C65EF4" , k(k6).z().vdivps(zmm6, zmm29, zmm4)); + TEST_INSTRUCTION("62F114105EF4" , rn_sae().vdivps(zmm6, zmm29, zmm4)); + TEST_INSTRUCTION("62F114505EF4" , ru_sae().vdivps(zmm6, zmm29, zmm4)); + TEST_INSTRUCTION("62F114305EF4" , rd_sae().vdivps(zmm6, zmm29, zmm4)); + TEST_INSTRUCTION("62F114705EF4" , rz_sae().vdivps(zmm6, zmm29, zmm4)); + TEST_INSTRUCTION("62F114405E31" , vdivps(zmm6, zmm29, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62B114405EB4F034120000" , vdivps(zmm6, zmm29, zmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62F114505E31" , vdivps(zmm6, zmm29, dword_ptr(rcx)._1to16())); + TEST_INSTRUCTION("62F114405E727F" , vdivps(zmm6, zmm29, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62F114405EB200200000" , vdivps(zmm6, zmm29, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62F114405E7280" , vdivps(zmm6, zmm29, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62F114405EB2C0DFFFFF" , vdivps(zmm6, zmm29, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62F114505E727F" , vdivps(zmm6, zmm29, dword_ptr(rdx, 508)._1to16())); + TEST_INSTRUCTION("62F114505EB200020000" , vdivps(zmm6, zmm29, dword_ptr(rdx, 512)._1to16())); + TEST_INSTRUCTION("62F114505E7280" , vdivps(zmm6, zmm29, dword_ptr(rdx, -512)._1to16())); + TEST_INSTRUCTION("62F114505EB2FCFDFFFF" , vdivps(zmm6, zmm29, dword_ptr(rdx, -516)._1to16())); + TEST_INSTRUCTION("6231DF085EFE" , vdivsd(xmm15, xmm4, xmm22)); + TEST_INSTRUCTION("6231DF0B5EFE" , k(k3).vdivsd(xmm15, xmm4, xmm22)); + TEST_INSTRUCTION("6231DF8B5EFE" , k(k3).z().vdivsd(xmm15, xmm4, xmm22)); + TEST_INSTRUCTION("6231DF185EFE" , rn_sae().vdivsd(xmm15, xmm4, xmm22)); + TEST_INSTRUCTION("6231DF585EFE" , ru_sae().vdivsd(xmm15, xmm4, xmm22)); + TEST_INSTRUCTION("6231DF385EFE" , rd_sae().vdivsd(xmm15, xmm4, xmm22)); + TEST_INSTRUCTION("6231DF785EFE" , rz_sae().vdivsd(xmm15, xmm4, xmm22)); + TEST_INSTRUCTION("C55B5E39" , vdivsd(xmm15, xmm4, qword_ptr(rcx))); + TEST_INSTRUCTION("C4215B5EBCF034120000" , vdivsd(xmm15, xmm4, qword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("C55B5EBAF8030000" , vdivsd(xmm15, xmm4, qword_ptr(rdx, 1016))); + TEST_INSTRUCTION("C55B5EBA00040000" , vdivsd(xmm15, xmm4, qword_ptr(rdx, 1024))); + TEST_INSTRUCTION("C55B5EBA00FCFFFF" , vdivsd(xmm15, xmm4, qword_ptr(rdx, -1024))); + TEST_INSTRUCTION("C55B5EBAF8FBFFFF" , vdivsd(xmm15, xmm4, qword_ptr(rdx, -1032))); + TEST_INSTRUCTION("62216E085EDC" , vdivss(xmm27, xmm2, xmm20)); + TEST_INSTRUCTION("62216E0D5EDC" , k(k5).vdivss(xmm27, xmm2, xmm20)); + TEST_INSTRUCTION("62216E8D5EDC" , k(k5).z().vdivss(xmm27, xmm2, xmm20)); + TEST_INSTRUCTION("62216E185EDC" , rn_sae().vdivss(xmm27, xmm2, xmm20)); + TEST_INSTRUCTION("62216E585EDC" , ru_sae().vdivss(xmm27, xmm2, xmm20)); + TEST_INSTRUCTION("62216E385EDC" , rd_sae().vdivss(xmm27, xmm2, xmm20)); + TEST_INSTRUCTION("62216E785EDC" , rz_sae().vdivss(xmm27, xmm2, xmm20)); + TEST_INSTRUCTION("62616E085E19" , vdivss(xmm27, xmm2, dword_ptr(rcx))); + TEST_INSTRUCTION("62216E085E9CF034120000" , vdivss(xmm27, xmm2, dword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62616E085E5A7F" , vdivss(xmm27, xmm2, dword_ptr(rdx, 508))); + TEST_INSTRUCTION("62616E085E9A00020000" , vdivss(xmm27, xmm2, dword_ptr(rdx, 512))); + TEST_INSTRUCTION("62616E085E5A80" , vdivss(xmm27, xmm2, dword_ptr(rdx, -512))); + TEST_INSTRUCTION("62616E085E9AFCFDFFFF" , vdivss(xmm27, xmm2, dword_ptr(rdx, -516))); + TEST_INSTRUCTION("62F2FD488821" , vexpandpd(zmm4, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62F2FD4F8821" , k(k7).vexpandpd(zmm4, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62F2FDCF8821" , k(k7).z().vexpandpd(zmm4, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62B2FD4888A4F034120000" , vexpandpd(zmm4, zmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62F2FD4888627F" , vexpandpd(zmm4, zmmword_ptr(rdx, 1016))); + TEST_INSTRUCTION("62F2FD4888A200040000" , vexpandpd(zmm4, zmmword_ptr(rdx, 1024))); + TEST_INSTRUCTION("62F2FD48886280" , vexpandpd(zmm4, zmmword_ptr(rdx, -1024))); + TEST_INSTRUCTION("62F2FD4888A2F8FBFFFF" , vexpandpd(zmm4, zmmword_ptr(rdx, -1032))); + TEST_INSTRUCTION("62C2FD4888D1" , vexpandpd(zmm18, zmm9)); + TEST_INSTRUCTION("62C2FD4A88D1" , k(k2).vexpandpd(zmm18, zmm9)); + TEST_INSTRUCTION("62C2FDCA88D1" , k(k2).z().vexpandpd(zmm18, zmm9)); + TEST_INSTRUCTION("62627D488821" , vexpandps(zmm28, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62627D4F8821" , k(k7).vexpandps(zmm28, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62627DCF8821" , k(k7).z().vexpandps(zmm28, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62227D4888A4F034120000" , vexpandps(zmm28, zmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62627D4888627F" , vexpandps(zmm28, zmmword_ptr(rdx, 508))); + TEST_INSTRUCTION("62627D4888A200020000" , vexpandps(zmm28, zmmword_ptr(rdx, 512))); + TEST_INSTRUCTION("62627D48886280" , vexpandps(zmm28, zmmword_ptr(rdx, -512))); + TEST_INSTRUCTION("62627D4888A2FCFDFFFF" , vexpandps(zmm28, zmmword_ptr(rdx, -516))); + TEST_INSTRUCTION("62A27D4888CA" , vexpandps(zmm17, zmm18)); + TEST_INSTRUCTION("62A27D4988CA" , k(k1).vexpandps(zmm17, zmm18)); + TEST_INSTRUCTION("62A27DC988CA" , k(k1).z().vexpandps(zmm17, zmm18)); + TEST_INSTRUCTION("62337D4819D5AB" , vextractf32x4(xmm21, zmm10, 171)); + TEST_INSTRUCTION("62337D4A19D5AB" , k(k2).vextractf32x4(xmm21, zmm10, 171)); + TEST_INSTRUCTION("62337DCA19D5AB" , k(k2).z().vextractf32x4(xmm21, zmm10, 171)); + TEST_INSTRUCTION("62337D4819D57B" , vextractf32x4(xmm21, zmm10, 123)); + TEST_INSTRUCTION("62D3FD481BEEAB" , vextractf64x4(ymm14, zmm5, 171)); + TEST_INSTRUCTION("62D3FD4B1BEEAB" , k(k3).vextractf64x4(ymm14, zmm5, 171)); + TEST_INSTRUCTION("62D3FDCB1BEEAB" , k(k3).z().vextractf64x4(ymm14, zmm5, 171)); + TEST_INSTRUCTION("62D3FD481BEE7B" , vextractf64x4(ymm14, zmm5, 123)); + TEST_INSTRUCTION("62137D4839E5AB" , vextracti32x4(xmm29, zmm12, 171)); + TEST_INSTRUCTION("62137D4D39E5AB" , k(k5).vextracti32x4(xmm29, zmm12, 171)); + TEST_INSTRUCTION("62137DCD39E5AB" , k(k5).z().vextracti32x4(xmm29, zmm12, 171)); + TEST_INSTRUCTION("62137D4839E57B" , vextracti32x4(xmm29, zmm12, 123)); + TEST_INSTRUCTION("62E3FD483BF5AB" , vextracti64x4(ymm5, zmm22, 171)); + TEST_INSTRUCTION("62E3FD4E3BF5AB" , k(k6).vextracti64x4(ymm5, zmm22, 171)); + TEST_INSTRUCTION("62E3FDCE3BF5AB" , k(k6).z().vextracti64x4(ymm5, zmm22, 171)); + TEST_INSTRUCTION("62E3FD483BF57B" , vextracti64x4(ymm5, zmm22, 123)); + TEST_INSTRUCTION("62C2854898FB" , vfmadd132pd(zmm23, zmm15, zmm11)); + TEST_INSTRUCTION("62C2854F98FB" , k(k7).vfmadd132pd(zmm23, zmm15, zmm11)); + TEST_INSTRUCTION("62C285CF98FB" , k(k7).z().vfmadd132pd(zmm23, zmm15, zmm11)); + TEST_INSTRUCTION("62C2851898FB" , rn_sae().vfmadd132pd(zmm23, zmm15, zmm11)); + TEST_INSTRUCTION("62C2855898FB" , ru_sae().vfmadd132pd(zmm23, zmm15, zmm11)); + TEST_INSTRUCTION("62C2853898FB" , rd_sae().vfmadd132pd(zmm23, zmm15, zmm11)); + TEST_INSTRUCTION("62C2857898FB" , rz_sae().vfmadd132pd(zmm23, zmm15, zmm11)); + TEST_INSTRUCTION("62E285489839" , vfmadd132pd(zmm23, zmm15, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62A2854898BCF034120000" , vfmadd132pd(zmm23, zmm15, zmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62E285589839" , vfmadd132pd(zmm23, zmm15, qword_ptr(rcx)._1to8())); + TEST_INSTRUCTION("62E28548987A7F" , vfmadd132pd(zmm23, zmm15, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62E2854898BA00200000" , vfmadd132pd(zmm23, zmm15, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62E28548987A80" , vfmadd132pd(zmm23, zmm15, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62E2854898BAC0DFFFFF" , vfmadd132pd(zmm23, zmm15, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62E28558987A7F" , vfmadd132pd(zmm23, zmm15, qword_ptr(rdx, 1016)._1to8())); + TEST_INSTRUCTION("62E2855898BA00040000" , vfmadd132pd(zmm23, zmm15, qword_ptr(rdx, 1024)._1to8())); + TEST_INSTRUCTION("62E28558987A80" , vfmadd132pd(zmm23, zmm15, qword_ptr(rdx, -1024)._1to8())); + TEST_INSTRUCTION("62E2855898BAF8FBFFFF" , vfmadd132pd(zmm23, zmm15, qword_ptr(rdx, -1032)._1to8())); + TEST_INSTRUCTION("62A2354098D9" , vfmadd132ps(zmm19, zmm25, zmm17)); + TEST_INSTRUCTION("62A2354698D9" , k(k6).vfmadd132ps(zmm19, zmm25, zmm17)); + TEST_INSTRUCTION("62A235C698D9" , k(k6).z().vfmadd132ps(zmm19, zmm25, zmm17)); + TEST_INSTRUCTION("62A2351098D9" , rn_sae().vfmadd132ps(zmm19, zmm25, zmm17)); + TEST_INSTRUCTION("62A2355098D9" , ru_sae().vfmadd132ps(zmm19, zmm25, zmm17)); + TEST_INSTRUCTION("62A2353098D9" , rd_sae().vfmadd132ps(zmm19, zmm25, zmm17)); + TEST_INSTRUCTION("62A2357098D9" , rz_sae().vfmadd132ps(zmm19, zmm25, zmm17)); + TEST_INSTRUCTION("62E235409819" , vfmadd132ps(zmm19, zmm25, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62A23540989CF034120000" , vfmadd132ps(zmm19, zmm25, zmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62E235509819" , vfmadd132ps(zmm19, zmm25, dword_ptr(rcx)._1to16())); + TEST_INSTRUCTION("62E23540985A7F" , vfmadd132ps(zmm19, zmm25, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62E23540989A00200000" , vfmadd132ps(zmm19, zmm25, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62E23540985A80" , vfmadd132ps(zmm19, zmm25, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62E23540989AC0DFFFFF" , vfmadd132ps(zmm19, zmm25, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62E23550985A7F" , vfmadd132ps(zmm19, zmm25, dword_ptr(rdx, 508)._1to16())); + TEST_INSTRUCTION("62E23550989A00020000" , vfmadd132ps(zmm19, zmm25, dword_ptr(rdx, 512)._1to16())); + TEST_INSTRUCTION("62E23550985A80" , vfmadd132ps(zmm19, zmm25, dword_ptr(rdx, -512)._1to16())); + TEST_INSTRUCTION("62E23550989AFCFDFFFF" , vfmadd132ps(zmm19, zmm25, dword_ptr(rdx, -516)._1to16())); + TEST_INSTRUCTION("62C2CD0099D3" , vfmadd132sd(xmm18, xmm22, xmm11)); + TEST_INSTRUCTION("62C2CD0699D3" , k(k6).vfmadd132sd(xmm18, xmm22, xmm11)); + TEST_INSTRUCTION("62C2CD8699D3" , k(k6).z().vfmadd132sd(xmm18, xmm22, xmm11)); + TEST_INSTRUCTION("62C2CD1099D3" , rn_sae().vfmadd132sd(xmm18, xmm22, xmm11)); + TEST_INSTRUCTION("62C2CD5099D3" , ru_sae().vfmadd132sd(xmm18, xmm22, xmm11)); + TEST_INSTRUCTION("62C2CD3099D3" , rd_sae().vfmadd132sd(xmm18, xmm22, xmm11)); + TEST_INSTRUCTION("62C2CD7099D3" , rz_sae().vfmadd132sd(xmm18, xmm22, xmm11)); + TEST_INSTRUCTION("62E2CD009911" , vfmadd132sd(xmm18, xmm22, qword_ptr(rcx))); + TEST_INSTRUCTION("62A2CD009994F034120000" , vfmadd132sd(xmm18, xmm22, qword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62E2CD0099527F" , vfmadd132sd(xmm18, xmm22, qword_ptr(rdx, 1016))); + TEST_INSTRUCTION("62E2CD00999200040000" , vfmadd132sd(xmm18, xmm22, qword_ptr(rdx, 1024))); + TEST_INSTRUCTION("62E2CD00995280" , vfmadd132sd(xmm18, xmm22, qword_ptr(rdx, -1024))); + TEST_INSTRUCTION("62E2CD009992F8FBFFFF" , vfmadd132sd(xmm18, xmm22, qword_ptr(rdx, -1032))); + TEST_INSTRUCTION("62625D0099D7" , vfmadd132ss(xmm26, xmm20, xmm7)); + TEST_INSTRUCTION("62625D0799D7" , k(k7).vfmadd132ss(xmm26, xmm20, xmm7)); + TEST_INSTRUCTION("62625D8799D7" , k(k7).z().vfmadd132ss(xmm26, xmm20, xmm7)); + TEST_INSTRUCTION("62625D1099D7" , rn_sae().vfmadd132ss(xmm26, xmm20, xmm7)); + TEST_INSTRUCTION("62625D5099D7" , ru_sae().vfmadd132ss(xmm26, xmm20, xmm7)); + TEST_INSTRUCTION("62625D3099D7" , rd_sae().vfmadd132ss(xmm26, xmm20, xmm7)); + TEST_INSTRUCTION("62625D7099D7" , rz_sae().vfmadd132ss(xmm26, xmm20, xmm7)); + TEST_INSTRUCTION("62625D009911" , vfmadd132ss(xmm26, xmm20, dword_ptr(rcx))); + TEST_INSTRUCTION("62225D009994F034120000" , vfmadd132ss(xmm26, xmm20, dword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62625D0099527F" , vfmadd132ss(xmm26, xmm20, dword_ptr(rdx, 508))); + TEST_INSTRUCTION("62625D00999200020000" , vfmadd132ss(xmm26, xmm20, dword_ptr(rdx, 512))); + TEST_INSTRUCTION("62625D00995280" , vfmadd132ss(xmm26, xmm20, dword_ptr(rdx, -512))); + TEST_INSTRUCTION("62625D009992FCFDFFFF" , vfmadd132ss(xmm26, xmm20, dword_ptr(rdx, -516))); + TEST_INSTRUCTION("62F2F540A8F1" , vfmadd213pd(zmm6, zmm17, zmm1)); + TEST_INSTRUCTION("62F2F546A8F1" , k(k6).vfmadd213pd(zmm6, zmm17, zmm1)); + TEST_INSTRUCTION("62F2F5C6A8F1" , k(k6).z().vfmadd213pd(zmm6, zmm17, zmm1)); + TEST_INSTRUCTION("62F2F510A8F1" , rn_sae().vfmadd213pd(zmm6, zmm17, zmm1)); + TEST_INSTRUCTION("62F2F550A8F1" , ru_sae().vfmadd213pd(zmm6, zmm17, zmm1)); + TEST_INSTRUCTION("62F2F530A8F1" , rd_sae().vfmadd213pd(zmm6, zmm17, zmm1)); + TEST_INSTRUCTION("62F2F570A8F1" , rz_sae().vfmadd213pd(zmm6, zmm17, zmm1)); + TEST_INSTRUCTION("62F2F540A831" , vfmadd213pd(zmm6, zmm17, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62B2F540A8B4F034120000" , vfmadd213pd(zmm6, zmm17, zmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62F2F550A831" , vfmadd213pd(zmm6, zmm17, qword_ptr(rcx)._1to8())); + TEST_INSTRUCTION("62F2F540A8727F" , vfmadd213pd(zmm6, zmm17, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62F2F540A8B200200000" , vfmadd213pd(zmm6, zmm17, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62F2F540A87280" , vfmadd213pd(zmm6, zmm17, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62F2F540A8B2C0DFFFFF" , vfmadd213pd(zmm6, zmm17, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62F2F550A8727F" , vfmadd213pd(zmm6, zmm17, qword_ptr(rdx, 1016)._1to8())); + TEST_INSTRUCTION("62F2F550A8B200040000" , vfmadd213pd(zmm6, zmm17, qword_ptr(rdx, 1024)._1to8())); + TEST_INSTRUCTION("62F2F550A87280" , vfmadd213pd(zmm6, zmm17, qword_ptr(rdx, -1024)._1to8())); + TEST_INSTRUCTION("62F2F550A8B2F8FBFFFF" , vfmadd213pd(zmm6, zmm17, qword_ptr(rdx, -1032)._1to8())); + TEST_INSTRUCTION("62923D40A8E8" , vfmadd213ps(zmm5, zmm24, zmm24)); + TEST_INSTRUCTION("62923D46A8E8" , k(k6).vfmadd213ps(zmm5, zmm24, zmm24)); + TEST_INSTRUCTION("62923DC6A8E8" , k(k6).z().vfmadd213ps(zmm5, zmm24, zmm24)); + TEST_INSTRUCTION("62923D10A8E8" , rn_sae().vfmadd213ps(zmm5, zmm24, zmm24)); + TEST_INSTRUCTION("62923D50A8E8" , ru_sae().vfmadd213ps(zmm5, zmm24, zmm24)); + TEST_INSTRUCTION("62923D30A8E8" , rd_sae().vfmadd213ps(zmm5, zmm24, zmm24)); + TEST_INSTRUCTION("62923D70A8E8" , rz_sae().vfmadd213ps(zmm5, zmm24, zmm24)); + TEST_INSTRUCTION("62F23D40A829" , vfmadd213ps(zmm5, zmm24, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62B23D40A8ACF034120000" , vfmadd213ps(zmm5, zmm24, zmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62F23D50A829" , vfmadd213ps(zmm5, zmm24, dword_ptr(rcx)._1to16())); + TEST_INSTRUCTION("62F23D40A86A7F" , vfmadd213ps(zmm5, zmm24, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62F23D40A8AA00200000" , vfmadd213ps(zmm5, zmm24, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62F23D40A86A80" , vfmadd213ps(zmm5, zmm24, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62F23D40A8AAC0DFFFFF" , vfmadd213ps(zmm5, zmm24, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62F23D50A86A7F" , vfmadd213ps(zmm5, zmm24, dword_ptr(rdx, 508)._1to16())); + TEST_INSTRUCTION("62F23D50A8AA00020000" , vfmadd213ps(zmm5, zmm24, dword_ptr(rdx, 512)._1to16())); + TEST_INSTRUCTION("62F23D50A86A80" , vfmadd213ps(zmm5, zmm24, dword_ptr(rdx, -512)._1to16())); + TEST_INSTRUCTION("62F23D50A8AAFCFDFFFF" , vfmadd213ps(zmm5, zmm24, dword_ptr(rdx, -516)._1to16())); + TEST_INSTRUCTION("62028D08A9F4" , vfmadd213sd(xmm30, xmm14, xmm28)); + TEST_INSTRUCTION("62028D0DA9F4" , k(k5).vfmadd213sd(xmm30, xmm14, xmm28)); + TEST_INSTRUCTION("62028D8DA9F4" , k(k5).z().vfmadd213sd(xmm30, xmm14, xmm28)); + TEST_INSTRUCTION("62028D18A9F4" , rn_sae().vfmadd213sd(xmm30, xmm14, xmm28)); + TEST_INSTRUCTION("62028D58A9F4" , ru_sae().vfmadd213sd(xmm30, xmm14, xmm28)); + TEST_INSTRUCTION("62028D38A9F4" , rd_sae().vfmadd213sd(xmm30, xmm14, xmm28)); + TEST_INSTRUCTION("62028D78A9F4" , rz_sae().vfmadd213sd(xmm30, xmm14, xmm28)); + TEST_INSTRUCTION("62628D08A931" , vfmadd213sd(xmm30, xmm14, qword_ptr(rcx))); + TEST_INSTRUCTION("62228D08A9B4F034120000" , vfmadd213sd(xmm30, xmm14, qword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62628D08A9727F" , vfmadd213sd(xmm30, xmm14, qword_ptr(rdx, 1016))); + TEST_INSTRUCTION("62628D08A9B200040000" , vfmadd213sd(xmm30, xmm14, qword_ptr(rdx, 1024))); + TEST_INSTRUCTION("62628D08A97280" , vfmadd213sd(xmm30, xmm14, qword_ptr(rdx, -1024))); + TEST_INSTRUCTION("62628D08A9B2F8FBFFFF" , vfmadd213sd(xmm30, xmm14, qword_ptr(rdx, -1032))); + TEST_INSTRUCTION("62823500A9D1" , vfmadd213ss(xmm18, xmm25, xmm25)); + TEST_INSTRUCTION("62823501A9D1" , k(k1).vfmadd213ss(xmm18, xmm25, xmm25)); + TEST_INSTRUCTION("62823581A9D1" , k(k1).z().vfmadd213ss(xmm18, xmm25, xmm25)); + TEST_INSTRUCTION("62823510A9D1" , rn_sae().vfmadd213ss(xmm18, xmm25, xmm25)); + TEST_INSTRUCTION("62823550A9D1" , ru_sae().vfmadd213ss(xmm18, xmm25, xmm25)); + TEST_INSTRUCTION("62823530A9D1" , rd_sae().vfmadd213ss(xmm18, xmm25, xmm25)); + TEST_INSTRUCTION("62823570A9D1" , rz_sae().vfmadd213ss(xmm18, xmm25, xmm25)); + TEST_INSTRUCTION("62E23500A911" , vfmadd213ss(xmm18, xmm25, dword_ptr(rcx))); + TEST_INSTRUCTION("62A23500A994F034120000" , vfmadd213ss(xmm18, xmm25, dword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62E23500A9527F" , vfmadd213ss(xmm18, xmm25, dword_ptr(rdx, 508))); + TEST_INSTRUCTION("62E23500A99200020000" , vfmadd213ss(xmm18, xmm25, dword_ptr(rdx, 512))); + TEST_INSTRUCTION("62E23500A95280" , vfmadd213ss(xmm18, xmm25, dword_ptr(rdx, -512))); + TEST_INSTRUCTION("62E23500A992FCFDFFFF" , vfmadd213ss(xmm18, xmm25, dword_ptr(rdx, -516))); + TEST_INSTRUCTION("62B29548B8EB" , vfmadd231pd(zmm5, zmm13, zmm19)); + TEST_INSTRUCTION("62B29549B8EB" , k(k1).vfmadd231pd(zmm5, zmm13, zmm19)); + TEST_INSTRUCTION("62B295C9B8EB" , k(k1).z().vfmadd231pd(zmm5, zmm13, zmm19)); + TEST_INSTRUCTION("62B29518B8EB" , rn_sae().vfmadd231pd(zmm5, zmm13, zmm19)); + TEST_INSTRUCTION("62B29558B8EB" , ru_sae().vfmadd231pd(zmm5, zmm13, zmm19)); + TEST_INSTRUCTION("62B29538B8EB" , rd_sae().vfmadd231pd(zmm5, zmm13, zmm19)); + TEST_INSTRUCTION("62B29578B8EB" , rz_sae().vfmadd231pd(zmm5, zmm13, zmm19)); + TEST_INSTRUCTION("62F29548B829" , vfmadd231pd(zmm5, zmm13, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62B29548B8ACF034120000" , vfmadd231pd(zmm5, zmm13, zmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62F29558B829" , vfmadd231pd(zmm5, zmm13, qword_ptr(rcx)._1to8())); + TEST_INSTRUCTION("62F29548B86A7F" , vfmadd231pd(zmm5, zmm13, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62F29548B8AA00200000" , vfmadd231pd(zmm5, zmm13, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62F29548B86A80" , vfmadd231pd(zmm5, zmm13, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62F29548B8AAC0DFFFFF" , vfmadd231pd(zmm5, zmm13, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62F29558B86A7F" , vfmadd231pd(zmm5, zmm13, qword_ptr(rdx, 1016)._1to8())); + TEST_INSTRUCTION("62F29558B8AA00040000" , vfmadd231pd(zmm5, zmm13, qword_ptr(rdx, 1024)._1to8())); + TEST_INSTRUCTION("62F29558B86A80" , vfmadd231pd(zmm5, zmm13, qword_ptr(rdx, -1024)._1to8())); + TEST_INSTRUCTION("62F29558B8AAF8FBFFFF" , vfmadd231pd(zmm5, zmm13, qword_ptr(rdx, -1032)._1to8())); + TEST_INSTRUCTION("62B27548B8D2" , vfmadd231ps(zmm2, zmm1, zmm18)); + TEST_INSTRUCTION("62B2754AB8D2" , k(k2).vfmadd231ps(zmm2, zmm1, zmm18)); + TEST_INSTRUCTION("62B275CAB8D2" , k(k2).z().vfmadd231ps(zmm2, zmm1, zmm18)); + TEST_INSTRUCTION("62B27518B8D2" , rn_sae().vfmadd231ps(zmm2, zmm1, zmm18)); + TEST_INSTRUCTION("62B27558B8D2" , ru_sae().vfmadd231ps(zmm2, zmm1, zmm18)); + TEST_INSTRUCTION("62B27538B8D2" , rd_sae().vfmadd231ps(zmm2, zmm1, zmm18)); + TEST_INSTRUCTION("62B27578B8D2" , rz_sae().vfmadd231ps(zmm2, zmm1, zmm18)); + TEST_INSTRUCTION("62F27548B811" , vfmadd231ps(zmm2, zmm1, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62B27548B894F034120000" , vfmadd231ps(zmm2, zmm1, zmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62F27558B811" , vfmadd231ps(zmm2, zmm1, dword_ptr(rcx)._1to16())); + TEST_INSTRUCTION("62F27548B8527F" , vfmadd231ps(zmm2, zmm1, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62F27548B89200200000" , vfmadd231ps(zmm2, zmm1, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62F27548B85280" , vfmadd231ps(zmm2, zmm1, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62F27548B892C0DFFFFF" , vfmadd231ps(zmm2, zmm1, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62F27558B8527F" , vfmadd231ps(zmm2, zmm1, dword_ptr(rdx, 508)._1to16())); + TEST_INSTRUCTION("62F27558B89200020000" , vfmadd231ps(zmm2, zmm1, dword_ptr(rdx, 512)._1to16())); + TEST_INSTRUCTION("62F27558B85280" , vfmadd231ps(zmm2, zmm1, dword_ptr(rdx, -512)._1to16())); + TEST_INSTRUCTION("62F27558B892FCFDFFFF" , vfmadd231ps(zmm2, zmm1, dword_ptr(rdx, -516)._1to16())); + TEST_INSTRUCTION("C4C289B9F6" , vfmadd231sd(xmm6, xmm14, xmm14)); + TEST_INSTRUCTION("62D28D0AB9F6" , k(k2).vfmadd231sd(xmm6, xmm14, xmm14)); + TEST_INSTRUCTION("62D28D8AB9F6" , k(k2).z().vfmadd231sd(xmm6, xmm14, xmm14)); + TEST_INSTRUCTION("62D28D18B9F6" , rn_sae().vfmadd231sd(xmm6, xmm14, xmm14)); + TEST_INSTRUCTION("62D28D58B9F6" , ru_sae().vfmadd231sd(xmm6, xmm14, xmm14)); + TEST_INSTRUCTION("62D28D38B9F6" , rd_sae().vfmadd231sd(xmm6, xmm14, xmm14)); + TEST_INSTRUCTION("62D28D78B9F6" , rz_sae().vfmadd231sd(xmm6, xmm14, xmm14)); + TEST_INSTRUCTION("C4E289B931" , vfmadd231sd(xmm6, xmm14, qword_ptr(rcx))); + TEST_INSTRUCTION("C4A289B9B4F034120000" , vfmadd231sd(xmm6, xmm14, qword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("C4E289B9B2F8030000" , vfmadd231sd(xmm6, xmm14, qword_ptr(rdx, 1016))); + TEST_INSTRUCTION("C4E289B9B200040000" , vfmadd231sd(xmm6, xmm14, qword_ptr(rdx, 1024))); + TEST_INSTRUCTION("C4E289B9B200FCFFFF" , vfmadd231sd(xmm6, xmm14, qword_ptr(rdx, -1024))); + TEST_INSTRUCTION("C4E289B9B2F8FBFFFF" , vfmadd231sd(xmm6, xmm14, qword_ptr(rdx, -1032))); + TEST_INSTRUCTION("62220D08B9D3" , vfmadd231ss(xmm26, xmm14, xmm19)); + TEST_INSTRUCTION("62220D0CB9D3" , k(k4).vfmadd231ss(xmm26, xmm14, xmm19)); + TEST_INSTRUCTION("62220D8CB9D3" , k(k4).z().vfmadd231ss(xmm26, xmm14, xmm19)); + TEST_INSTRUCTION("62220D18B9D3" , rn_sae().vfmadd231ss(xmm26, xmm14, xmm19)); + TEST_INSTRUCTION("62220D58B9D3" , ru_sae().vfmadd231ss(xmm26, xmm14, xmm19)); + TEST_INSTRUCTION("62220D38B9D3" , rd_sae().vfmadd231ss(xmm26, xmm14, xmm19)); + TEST_INSTRUCTION("62220D78B9D3" , rz_sae().vfmadd231ss(xmm26, xmm14, xmm19)); + TEST_INSTRUCTION("62620D08B911" , vfmadd231ss(xmm26, xmm14, dword_ptr(rcx))); + TEST_INSTRUCTION("62220D08B994F034120000" , vfmadd231ss(xmm26, xmm14, dword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62620D08B9527F" , vfmadd231ss(xmm26, xmm14, dword_ptr(rdx, 508))); + TEST_INSTRUCTION("62620D08B99200020000" , vfmadd231ss(xmm26, xmm14, dword_ptr(rdx, 512))); + TEST_INSTRUCTION("62620D08B95280" , vfmadd231ss(xmm26, xmm14, dword_ptr(rdx, -512))); + TEST_INSTRUCTION("62620D08B992FCFDFFFF" , vfmadd231ss(xmm26, xmm14, dword_ptr(rdx, -516))); + TEST_INSTRUCTION("62E2CD4896E2" , vfmaddsub132pd(zmm20, zmm6, zmm2)); + TEST_INSTRUCTION("62E2CD4E96E2" , k(k6).vfmaddsub132pd(zmm20, zmm6, zmm2)); + TEST_INSTRUCTION("62E2CDCE96E2" , k(k6).z().vfmaddsub132pd(zmm20, zmm6, zmm2)); + TEST_INSTRUCTION("62E2CD1896E2" , rn_sae().vfmaddsub132pd(zmm20, zmm6, zmm2)); + TEST_INSTRUCTION("62E2CD5896E2" , ru_sae().vfmaddsub132pd(zmm20, zmm6, zmm2)); + TEST_INSTRUCTION("62E2CD3896E2" , rd_sae().vfmaddsub132pd(zmm20, zmm6, zmm2)); + TEST_INSTRUCTION("62E2CD7896E2" , rz_sae().vfmaddsub132pd(zmm20, zmm6, zmm2)); + TEST_INSTRUCTION("62E2CD489621" , vfmaddsub132pd(zmm20, zmm6, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62A2CD4896A4F034120000" , vfmaddsub132pd(zmm20, zmm6, zmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62E2CD589621" , vfmaddsub132pd(zmm20, zmm6, qword_ptr(rcx)._1to8())); + TEST_INSTRUCTION("62E2CD4896627F" , vfmaddsub132pd(zmm20, zmm6, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62E2CD4896A200200000" , vfmaddsub132pd(zmm20, zmm6, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62E2CD48966280" , vfmaddsub132pd(zmm20, zmm6, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62E2CD4896A2C0DFFFFF" , vfmaddsub132pd(zmm20, zmm6, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62E2CD5896627F" , vfmaddsub132pd(zmm20, zmm6, qword_ptr(rdx, 1016)._1to8())); + TEST_INSTRUCTION("62E2CD5896A200040000" , vfmaddsub132pd(zmm20, zmm6, qword_ptr(rdx, 1024)._1to8())); + TEST_INSTRUCTION("62E2CD58966280" , vfmaddsub132pd(zmm20, zmm6, qword_ptr(rdx, -1024)._1to8())); + TEST_INSTRUCTION("62E2CD5896A2F8FBFFFF" , vfmaddsub132pd(zmm20, zmm6, qword_ptr(rdx, -1032)._1to8())); + TEST_INSTRUCTION("6242454896EC" , vfmaddsub132ps(zmm29, zmm7, zmm12)); + TEST_INSTRUCTION("6242454F96EC" , k(k7).vfmaddsub132ps(zmm29, zmm7, zmm12)); + TEST_INSTRUCTION("624245CF96EC" , k(k7).z().vfmaddsub132ps(zmm29, zmm7, zmm12)); + TEST_INSTRUCTION("6242451896EC" , rn_sae().vfmaddsub132ps(zmm29, zmm7, zmm12)); + TEST_INSTRUCTION("6242455896EC" , ru_sae().vfmaddsub132ps(zmm29, zmm7, zmm12)); + TEST_INSTRUCTION("6242453896EC" , rd_sae().vfmaddsub132ps(zmm29, zmm7, zmm12)); + TEST_INSTRUCTION("6242457896EC" , rz_sae().vfmaddsub132ps(zmm29, zmm7, zmm12)); + TEST_INSTRUCTION("626245489629" , vfmaddsub132ps(zmm29, zmm7, zmmword_ptr(rcx))); + TEST_INSTRUCTION("6222454896ACF034120000" , vfmaddsub132ps(zmm29, zmm7, zmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("626245589629" , vfmaddsub132ps(zmm29, zmm7, dword_ptr(rcx)._1to16())); + TEST_INSTRUCTION("62624548966A7F" , vfmaddsub132ps(zmm29, zmm7, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("6262454896AA00200000" , vfmaddsub132ps(zmm29, zmm7, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62624548966A80" , vfmaddsub132ps(zmm29, zmm7, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("6262454896AAC0DFFFFF" , vfmaddsub132ps(zmm29, zmm7, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62624558966A7F" , vfmaddsub132ps(zmm29, zmm7, dword_ptr(rdx, 508)._1to16())); + TEST_INSTRUCTION("6262455896AA00020000" , vfmaddsub132ps(zmm29, zmm7, dword_ptr(rdx, 512)._1to16())); + TEST_INSTRUCTION("62624558966A80" , vfmaddsub132ps(zmm29, zmm7, dword_ptr(rdx, -512)._1to16())); + TEST_INSTRUCTION("6262455896AAFCFDFFFF" , vfmaddsub132ps(zmm29, zmm7, dword_ptr(rdx, -516)._1to16())); + TEST_INSTRUCTION("6242DD40A6DF" , vfmaddsub213pd(zmm27, zmm20, zmm15)); + TEST_INSTRUCTION("6242DD43A6DF" , k(k3).vfmaddsub213pd(zmm27, zmm20, zmm15)); + TEST_INSTRUCTION("6242DDC3A6DF" , k(k3).z().vfmaddsub213pd(zmm27, zmm20, zmm15)); + TEST_INSTRUCTION("6242DD10A6DF" , rn_sae().vfmaddsub213pd(zmm27, zmm20, zmm15)); + TEST_INSTRUCTION("6242DD50A6DF" , ru_sae().vfmaddsub213pd(zmm27, zmm20, zmm15)); + TEST_INSTRUCTION("6242DD30A6DF" , rd_sae().vfmaddsub213pd(zmm27, zmm20, zmm15)); + TEST_INSTRUCTION("6242DD70A6DF" , rz_sae().vfmaddsub213pd(zmm27, zmm20, zmm15)); + TEST_INSTRUCTION("6262DD40A619" , vfmaddsub213pd(zmm27, zmm20, zmmword_ptr(rcx))); + TEST_INSTRUCTION("6222DD40A69CF034120000" , vfmaddsub213pd(zmm27, zmm20, zmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("6262DD50A619" , vfmaddsub213pd(zmm27, zmm20, qword_ptr(rcx)._1to8())); + TEST_INSTRUCTION("6262DD40A65A7F" , vfmaddsub213pd(zmm27, zmm20, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("6262DD40A69A00200000" , vfmaddsub213pd(zmm27, zmm20, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("6262DD40A65A80" , vfmaddsub213pd(zmm27, zmm20, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("6262DD40A69AC0DFFFFF" , vfmaddsub213pd(zmm27, zmm20, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("6262DD50A65A7F" , vfmaddsub213pd(zmm27, zmm20, qword_ptr(rdx, 1016)._1to8())); + TEST_INSTRUCTION("6262DD50A69A00040000" , vfmaddsub213pd(zmm27, zmm20, qword_ptr(rdx, 1024)._1to8())); + TEST_INSTRUCTION("6262DD50A65A80" , vfmaddsub213pd(zmm27, zmm20, qword_ptr(rdx, -1024)._1to8())); + TEST_INSTRUCTION("6262DD50A69AF8FBFFFF" , vfmaddsub213pd(zmm27, zmm20, qword_ptr(rdx, -1032)._1to8())); + TEST_INSTRUCTION("62C21548A6F2" , vfmaddsub213ps(zmm22, zmm13, zmm10)); + TEST_INSTRUCTION("62C2154DA6F2" , k(k5).vfmaddsub213ps(zmm22, zmm13, zmm10)); + TEST_INSTRUCTION("62C215CDA6F2" , k(k5).z().vfmaddsub213ps(zmm22, zmm13, zmm10)); + TEST_INSTRUCTION("62C21518A6F2" , rn_sae().vfmaddsub213ps(zmm22, zmm13, zmm10)); + TEST_INSTRUCTION("62C21558A6F2" , ru_sae().vfmaddsub213ps(zmm22, zmm13, zmm10)); + TEST_INSTRUCTION("62C21538A6F2" , rd_sae().vfmaddsub213ps(zmm22, zmm13, zmm10)); + TEST_INSTRUCTION("62C21578A6F2" , rz_sae().vfmaddsub213ps(zmm22, zmm13, zmm10)); + TEST_INSTRUCTION("62E21548A631" , vfmaddsub213ps(zmm22, zmm13, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62A21548A6B4F034120000" , vfmaddsub213ps(zmm22, zmm13, zmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62E21558A631" , vfmaddsub213ps(zmm22, zmm13, dword_ptr(rcx)._1to16())); + TEST_INSTRUCTION("62E21548A6727F" , vfmaddsub213ps(zmm22, zmm13, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62E21548A6B200200000" , vfmaddsub213ps(zmm22, zmm13, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62E21548A67280" , vfmaddsub213ps(zmm22, zmm13, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62E21548A6B2C0DFFFFF" , vfmaddsub213ps(zmm22, zmm13, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62E21558A6727F" , vfmaddsub213ps(zmm22, zmm13, dword_ptr(rdx, 508)._1to16())); + TEST_INSTRUCTION("62E21558A6B200020000" , vfmaddsub213ps(zmm22, zmm13, dword_ptr(rdx, 512)._1to16())); + TEST_INSTRUCTION("62E21558A67280" , vfmaddsub213ps(zmm22, zmm13, dword_ptr(rdx, -512)._1to16())); + TEST_INSTRUCTION("62E21558A6B2FCFDFFFF" , vfmaddsub213ps(zmm22, zmm13, dword_ptr(rdx, -516)._1to16())); + TEST_INSTRUCTION("6292B540B6E4" , vfmaddsub231pd(zmm4, zmm25, zmm28)); + TEST_INSTRUCTION("6292B546B6E4" , k(k6).vfmaddsub231pd(zmm4, zmm25, zmm28)); + TEST_INSTRUCTION("6292B5C6B6E4" , k(k6).z().vfmaddsub231pd(zmm4, zmm25, zmm28)); + TEST_INSTRUCTION("6292B510B6E4" , rn_sae().vfmaddsub231pd(zmm4, zmm25, zmm28)); + TEST_INSTRUCTION("6292B550B6E4" , ru_sae().vfmaddsub231pd(zmm4, zmm25, zmm28)); + TEST_INSTRUCTION("6292B530B6E4" , rd_sae().vfmaddsub231pd(zmm4, zmm25, zmm28)); + TEST_INSTRUCTION("6292B570B6E4" , rz_sae().vfmaddsub231pd(zmm4, zmm25, zmm28)); + TEST_INSTRUCTION("62F2B540B621" , vfmaddsub231pd(zmm4, zmm25, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62B2B540B6A4F034120000" , vfmaddsub231pd(zmm4, zmm25, zmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62F2B550B621" , vfmaddsub231pd(zmm4, zmm25, qword_ptr(rcx)._1to8())); + TEST_INSTRUCTION("62F2B540B6627F" , vfmaddsub231pd(zmm4, zmm25, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62F2B540B6A200200000" , vfmaddsub231pd(zmm4, zmm25, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62F2B540B66280" , vfmaddsub231pd(zmm4, zmm25, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62F2B540B6A2C0DFFFFF" , vfmaddsub231pd(zmm4, zmm25, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62F2B550B6627F" , vfmaddsub231pd(zmm4, zmm25, qword_ptr(rdx, 1016)._1to8())); + TEST_INSTRUCTION("62F2B550B6A200040000" , vfmaddsub231pd(zmm4, zmm25, qword_ptr(rdx, 1024)._1to8())); + TEST_INSTRUCTION("62F2B550B66280" , vfmaddsub231pd(zmm4, zmm25, qword_ptr(rdx, -1024)._1to8())); + TEST_INSTRUCTION("62F2B550B6A2F8FBFFFF" , vfmaddsub231pd(zmm4, zmm25, qword_ptr(rdx, -1032)._1to8())); + TEST_INSTRUCTION("62D24D40B6FA" , vfmaddsub231ps(zmm7, zmm22, zmm10)); + TEST_INSTRUCTION("62D24D46B6FA" , k(k6).vfmaddsub231ps(zmm7, zmm22, zmm10)); + TEST_INSTRUCTION("62D24DC6B6FA" , k(k6).z().vfmaddsub231ps(zmm7, zmm22, zmm10)); + TEST_INSTRUCTION("62D24D10B6FA" , rn_sae().vfmaddsub231ps(zmm7, zmm22, zmm10)); + TEST_INSTRUCTION("62D24D50B6FA" , ru_sae().vfmaddsub231ps(zmm7, zmm22, zmm10)); + TEST_INSTRUCTION("62D24D30B6FA" , rd_sae().vfmaddsub231ps(zmm7, zmm22, zmm10)); + TEST_INSTRUCTION("62D24D70B6FA" , rz_sae().vfmaddsub231ps(zmm7, zmm22, zmm10)); + TEST_INSTRUCTION("62F24D40B639" , vfmaddsub231ps(zmm7, zmm22, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62B24D40B6BCF034120000" , vfmaddsub231ps(zmm7, zmm22, zmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62F24D50B639" , vfmaddsub231ps(zmm7, zmm22, dword_ptr(rcx)._1to16())); + TEST_INSTRUCTION("62F24D40B67A7F" , vfmaddsub231ps(zmm7, zmm22, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62F24D40B6BA00200000" , vfmaddsub231ps(zmm7, zmm22, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62F24D40B67A80" , vfmaddsub231ps(zmm7, zmm22, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62F24D40B6BAC0DFFFFF" , vfmaddsub231ps(zmm7, zmm22, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62F24D50B67A7F" , vfmaddsub231ps(zmm7, zmm22, dword_ptr(rdx, 508)._1to16())); + TEST_INSTRUCTION("62F24D50B6BA00020000" , vfmaddsub231ps(zmm7, zmm22, dword_ptr(rdx, 512)._1to16())); + TEST_INSTRUCTION("62F24D50B67A80" , vfmaddsub231ps(zmm7, zmm22, dword_ptr(rdx, -512)._1to16())); + TEST_INSTRUCTION("62F24D50B6BAFCFDFFFF" , vfmaddsub231ps(zmm7, zmm22, dword_ptr(rdx, -516)._1to16())); + TEST_INSTRUCTION("622295409ACB" , vfmsub132pd(zmm25, zmm29, zmm19)); + TEST_INSTRUCTION("622295449ACB" , k(k4).vfmsub132pd(zmm25, zmm29, zmm19)); + TEST_INSTRUCTION("622295C49ACB" , k(k4).z().vfmsub132pd(zmm25, zmm29, zmm19)); + TEST_INSTRUCTION("622295109ACB" , rn_sae().vfmsub132pd(zmm25, zmm29, zmm19)); + TEST_INSTRUCTION("622295509ACB" , ru_sae().vfmsub132pd(zmm25, zmm29, zmm19)); + TEST_INSTRUCTION("622295309ACB" , rd_sae().vfmsub132pd(zmm25, zmm29, zmm19)); + TEST_INSTRUCTION("622295709ACB" , rz_sae().vfmsub132pd(zmm25, zmm29, zmm19)); + TEST_INSTRUCTION("626295409A09" , vfmsub132pd(zmm25, zmm29, zmmword_ptr(rcx))); + TEST_INSTRUCTION("622295409A8CF034120000" , vfmsub132pd(zmm25, zmm29, zmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("626295509A09" , vfmsub132pd(zmm25, zmm29, qword_ptr(rcx)._1to8())); + TEST_INSTRUCTION("626295409A4A7F" , vfmsub132pd(zmm25, zmm29, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("626295409A8A00200000" , vfmsub132pd(zmm25, zmm29, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("626295409A4A80" , vfmsub132pd(zmm25, zmm29, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("626295409A8AC0DFFFFF" , vfmsub132pd(zmm25, zmm29, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("626295509A4A7F" , vfmsub132pd(zmm25, zmm29, qword_ptr(rdx, 1016)._1to8())); + TEST_INSTRUCTION("626295509A8A00040000" , vfmsub132pd(zmm25, zmm29, qword_ptr(rdx, 1024)._1to8())); + TEST_INSTRUCTION("626295509A4A80" , vfmsub132pd(zmm25, zmm29, qword_ptr(rdx, -1024)._1to8())); + TEST_INSTRUCTION("626295509A8AF8FBFFFF" , vfmsub132pd(zmm25, zmm29, qword_ptr(rdx, -1032)._1to8())); + TEST_INSTRUCTION("62224D489ADA" , vfmsub132ps(zmm27, zmm6, zmm18)); + TEST_INSTRUCTION("62224D4C9ADA" , k(k4).vfmsub132ps(zmm27, zmm6, zmm18)); + TEST_INSTRUCTION("62224DCC9ADA" , k(k4).z().vfmsub132ps(zmm27, zmm6, zmm18)); + TEST_INSTRUCTION("62224D189ADA" , rn_sae().vfmsub132ps(zmm27, zmm6, zmm18)); + TEST_INSTRUCTION("62224D589ADA" , ru_sae().vfmsub132ps(zmm27, zmm6, zmm18)); + TEST_INSTRUCTION("62224D389ADA" , rd_sae().vfmsub132ps(zmm27, zmm6, zmm18)); + TEST_INSTRUCTION("62224D789ADA" , rz_sae().vfmsub132ps(zmm27, zmm6, zmm18)); + TEST_INSTRUCTION("62624D489A19" , vfmsub132ps(zmm27, zmm6, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62224D489A9CF034120000" , vfmsub132ps(zmm27, zmm6, zmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62624D589A19" , vfmsub132ps(zmm27, zmm6, dword_ptr(rcx)._1to16())); + TEST_INSTRUCTION("62624D489A5A7F" , vfmsub132ps(zmm27, zmm6, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62624D489A9A00200000" , vfmsub132ps(zmm27, zmm6, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62624D489A5A80" , vfmsub132ps(zmm27, zmm6, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62624D489A9AC0DFFFFF" , vfmsub132ps(zmm27, zmm6, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62624D589A5A7F" , vfmsub132ps(zmm27, zmm6, dword_ptr(rdx, 508)._1to16())); + TEST_INSTRUCTION("62624D589A9A00020000" , vfmsub132ps(zmm27, zmm6, dword_ptr(rdx, 512)._1to16())); + TEST_INSTRUCTION("62624D589A5A80" , vfmsub132ps(zmm27, zmm6, dword_ptr(rdx, -512)._1to16())); + TEST_INSTRUCTION("62624D589A9AFCFDFFFF" , vfmsub132ps(zmm27, zmm6, dword_ptr(rdx, -516)._1to16())); + TEST_INSTRUCTION("6282DD009BFC" , vfmsub132sd(xmm23, xmm20, xmm28)); + TEST_INSTRUCTION("6282DD019BFC" , k(k1).vfmsub132sd(xmm23, xmm20, xmm28)); + TEST_INSTRUCTION("6282DD819BFC" , k(k1).z().vfmsub132sd(xmm23, xmm20, xmm28)); + TEST_INSTRUCTION("6282DD109BFC" , rn_sae().vfmsub132sd(xmm23, xmm20, xmm28)); + TEST_INSTRUCTION("6282DD509BFC" , ru_sae().vfmsub132sd(xmm23, xmm20, xmm28)); + TEST_INSTRUCTION("6282DD309BFC" , rd_sae().vfmsub132sd(xmm23, xmm20, xmm28)); + TEST_INSTRUCTION("6282DD709BFC" , rz_sae().vfmsub132sd(xmm23, xmm20, xmm28)); + TEST_INSTRUCTION("62E2DD009B39" , vfmsub132sd(xmm23, xmm20, qword_ptr(rcx))); + TEST_INSTRUCTION("62A2DD009BBCF034120000" , vfmsub132sd(xmm23, xmm20, qword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62E2DD009B7A7F" , vfmsub132sd(xmm23, xmm20, qword_ptr(rdx, 1016))); + TEST_INSTRUCTION("62E2DD009BBA00040000" , vfmsub132sd(xmm23, xmm20, qword_ptr(rdx, 1024))); + TEST_INSTRUCTION("62E2DD009B7A80" , vfmsub132sd(xmm23, xmm20, qword_ptr(rdx, -1024))); + TEST_INSTRUCTION("62E2DD009BBAF8FBFFFF" , vfmsub132sd(xmm23, xmm20, qword_ptr(rdx, -1032))); + TEST_INSTRUCTION("620235089BD1" , vfmsub132ss(xmm26, xmm9, xmm25)); + TEST_INSTRUCTION("6202350F9BD1" , k(k7).vfmsub132ss(xmm26, xmm9, xmm25)); + TEST_INSTRUCTION("6202358F9BD1" , k(k7).z().vfmsub132ss(xmm26, xmm9, xmm25)); + TEST_INSTRUCTION("620235189BD1" , rn_sae().vfmsub132ss(xmm26, xmm9, xmm25)); + TEST_INSTRUCTION("620235589BD1" , ru_sae().vfmsub132ss(xmm26, xmm9, xmm25)); + TEST_INSTRUCTION("620235389BD1" , rd_sae().vfmsub132ss(xmm26, xmm9, xmm25)); + TEST_INSTRUCTION("620235789BD1" , rz_sae().vfmsub132ss(xmm26, xmm9, xmm25)); + TEST_INSTRUCTION("626235089B11" , vfmsub132ss(xmm26, xmm9, dword_ptr(rcx))); + TEST_INSTRUCTION("622235089B94F034120000" , vfmsub132ss(xmm26, xmm9, dword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("626235089B527F" , vfmsub132ss(xmm26, xmm9, dword_ptr(rdx, 508))); + TEST_INSTRUCTION("626235089B9200020000" , vfmsub132ss(xmm26, xmm9, dword_ptr(rdx, 512))); + TEST_INSTRUCTION("626235089B5280" , vfmsub132ss(xmm26, xmm9, dword_ptr(rdx, -512))); + TEST_INSTRUCTION("626235089B92FCFDFFFF" , vfmsub132ss(xmm26, xmm9, dword_ptr(rdx, -516))); + TEST_INSTRUCTION("62B2ED40AAFB" , vfmsub213pd(zmm7, zmm18, zmm19)); + TEST_INSTRUCTION("62B2ED44AAFB" , k(k4).vfmsub213pd(zmm7, zmm18, zmm19)); + TEST_INSTRUCTION("62B2EDC4AAFB" , k(k4).z().vfmsub213pd(zmm7, zmm18, zmm19)); + TEST_INSTRUCTION("62B2ED10AAFB" , rn_sae().vfmsub213pd(zmm7, zmm18, zmm19)); + TEST_INSTRUCTION("62B2ED50AAFB" , ru_sae().vfmsub213pd(zmm7, zmm18, zmm19)); + TEST_INSTRUCTION("62B2ED30AAFB" , rd_sae().vfmsub213pd(zmm7, zmm18, zmm19)); + TEST_INSTRUCTION("62B2ED70AAFB" , rz_sae().vfmsub213pd(zmm7, zmm18, zmm19)); + TEST_INSTRUCTION("62F2ED40AA39" , vfmsub213pd(zmm7, zmm18, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62B2ED40AABCF034120000" , vfmsub213pd(zmm7, zmm18, zmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62F2ED50AA39" , vfmsub213pd(zmm7, zmm18, qword_ptr(rcx)._1to8())); + TEST_INSTRUCTION("62F2ED40AA7A7F" , vfmsub213pd(zmm7, zmm18, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62F2ED40AABA00200000" , vfmsub213pd(zmm7, zmm18, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62F2ED40AA7A80" , vfmsub213pd(zmm7, zmm18, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62F2ED40AABAC0DFFFFF" , vfmsub213pd(zmm7, zmm18, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62F2ED50AA7A7F" , vfmsub213pd(zmm7, zmm18, qword_ptr(rdx, 1016)._1to8())); + TEST_INSTRUCTION("62F2ED50AABA00040000" , vfmsub213pd(zmm7, zmm18, qword_ptr(rdx, 1024)._1to8())); + TEST_INSTRUCTION("62F2ED50AA7A80" , vfmsub213pd(zmm7, zmm18, qword_ptr(rdx, -1024)._1to8())); + TEST_INSTRUCTION("62F2ED50AABAF8FBFFFF" , vfmsub213pd(zmm7, zmm18, qword_ptr(rdx, -1032)._1to8())); + TEST_INSTRUCTION("62727D40AACE" , vfmsub213ps(zmm9, zmm16, zmm6)); + TEST_INSTRUCTION("62727D46AACE" , k(k6).vfmsub213ps(zmm9, zmm16, zmm6)); + TEST_INSTRUCTION("62727DC6AACE" , k(k6).z().vfmsub213ps(zmm9, zmm16, zmm6)); + TEST_INSTRUCTION("62727D10AACE" , rn_sae().vfmsub213ps(zmm9, zmm16, zmm6)); + TEST_INSTRUCTION("62727D50AACE" , ru_sae().vfmsub213ps(zmm9, zmm16, zmm6)); + TEST_INSTRUCTION("62727D30AACE" , rd_sae().vfmsub213ps(zmm9, zmm16, zmm6)); + TEST_INSTRUCTION("62727D70AACE" , rz_sae().vfmsub213ps(zmm9, zmm16, zmm6)); + TEST_INSTRUCTION("62727D40AA09" , vfmsub213ps(zmm9, zmm16, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62327D40AA8CF034120000" , vfmsub213ps(zmm9, zmm16, zmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62727D50AA09" , vfmsub213ps(zmm9, zmm16, dword_ptr(rcx)._1to16())); + TEST_INSTRUCTION("62727D40AA4A7F" , vfmsub213ps(zmm9, zmm16, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62727D40AA8A00200000" , vfmsub213ps(zmm9, zmm16, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62727D40AA4A80" , vfmsub213ps(zmm9, zmm16, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62727D40AA8AC0DFFFFF" , vfmsub213ps(zmm9, zmm16, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62727D50AA4A7F" , vfmsub213ps(zmm9, zmm16, dword_ptr(rdx, 508)._1to16())); + TEST_INSTRUCTION("62727D50AA8A00020000" , vfmsub213ps(zmm9, zmm16, dword_ptr(rdx, 512)._1to16())); + TEST_INSTRUCTION("62727D50AA4A80" , vfmsub213ps(zmm9, zmm16, dword_ptr(rdx, -512)._1to16())); + TEST_INSTRUCTION("62727D50AA8AFCFDFFFF" , vfmsub213ps(zmm9, zmm16, dword_ptr(rdx, -516)._1to16())); + TEST_INSTRUCTION("6232ED00ABE4" , vfmsub213sd(xmm12, xmm18, xmm20)); + TEST_INSTRUCTION("6232ED04ABE4" , k(k4).vfmsub213sd(xmm12, xmm18, xmm20)); + TEST_INSTRUCTION("6232ED84ABE4" , k(k4).z().vfmsub213sd(xmm12, xmm18, xmm20)); + TEST_INSTRUCTION("6232ED10ABE4" , rn_sae().vfmsub213sd(xmm12, xmm18, xmm20)); + TEST_INSTRUCTION("6232ED50ABE4" , ru_sae().vfmsub213sd(xmm12, xmm18, xmm20)); + TEST_INSTRUCTION("6232ED30ABE4" , rd_sae().vfmsub213sd(xmm12, xmm18, xmm20)); + TEST_INSTRUCTION("6232ED70ABE4" , rz_sae().vfmsub213sd(xmm12, xmm18, xmm20)); + TEST_INSTRUCTION("6272ED00AB21" , vfmsub213sd(xmm12, xmm18, qword_ptr(rcx))); + TEST_INSTRUCTION("6232ED00ABA4F034120000" , vfmsub213sd(xmm12, xmm18, qword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("6272ED00AB627F" , vfmsub213sd(xmm12, xmm18, qword_ptr(rdx, 1016))); + TEST_INSTRUCTION("6272ED00ABA200040000" , vfmsub213sd(xmm12, xmm18, qword_ptr(rdx, 1024))); + TEST_INSTRUCTION("6272ED00AB6280" , vfmsub213sd(xmm12, xmm18, qword_ptr(rdx, -1024))); + TEST_INSTRUCTION("6272ED00ABA2F8FBFFFF" , vfmsub213sd(xmm12, xmm18, qword_ptr(rdx, -1032))); + TEST_INSTRUCTION("C4C271ABD1" , vfmsub213ss(xmm2, xmm1, xmm9)); + TEST_INSTRUCTION("62D2750FABD1" , k(k7).vfmsub213ss(xmm2, xmm1, xmm9)); + TEST_INSTRUCTION("62D2758FABD1" , k(k7).z().vfmsub213ss(xmm2, xmm1, xmm9)); + TEST_INSTRUCTION("62D27518ABD1" , rn_sae().vfmsub213ss(xmm2, xmm1, xmm9)); + TEST_INSTRUCTION("62D27558ABD1" , ru_sae().vfmsub213ss(xmm2, xmm1, xmm9)); + TEST_INSTRUCTION("62D27538ABD1" , rd_sae().vfmsub213ss(xmm2, xmm1, xmm9)); + TEST_INSTRUCTION("62D27578ABD1" , rz_sae().vfmsub213ss(xmm2, xmm1, xmm9)); + TEST_INSTRUCTION("C4E271AB11" , vfmsub213ss(xmm2, xmm1, dword_ptr(rcx))); + TEST_INSTRUCTION("C4A271AB94F034120000" , vfmsub213ss(xmm2, xmm1, dword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("C4E271AB92FC010000" , vfmsub213ss(xmm2, xmm1, dword_ptr(rdx, 508))); + TEST_INSTRUCTION("C4E271AB9200020000" , vfmsub213ss(xmm2, xmm1, dword_ptr(rdx, 512))); + TEST_INSTRUCTION("C4E271AB9200FEFFFF" , vfmsub213ss(xmm2, xmm1, dword_ptr(rdx, -512))); + TEST_INSTRUCTION("C4E271AB92FCFDFFFF" , vfmsub213ss(xmm2, xmm1, dword_ptr(rdx, -516))); + TEST_INSTRUCTION("62C2ED48BACE" , vfmsub231pd(zmm17, zmm2, zmm14)); + TEST_INSTRUCTION("62C2ED4ABACE" , k(k2).vfmsub231pd(zmm17, zmm2, zmm14)); + TEST_INSTRUCTION("62C2EDCABACE" , k(k2).z().vfmsub231pd(zmm17, zmm2, zmm14)); + TEST_INSTRUCTION("62C2ED18BACE" , rn_sae().vfmsub231pd(zmm17, zmm2, zmm14)); + TEST_INSTRUCTION("62C2ED58BACE" , ru_sae().vfmsub231pd(zmm17, zmm2, zmm14)); + TEST_INSTRUCTION("62C2ED38BACE" , rd_sae().vfmsub231pd(zmm17, zmm2, zmm14)); + TEST_INSTRUCTION("62C2ED78BACE" , rz_sae().vfmsub231pd(zmm17, zmm2, zmm14)); + TEST_INSTRUCTION("62E2ED48BA09" , vfmsub231pd(zmm17, zmm2, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62A2ED48BA8CF034120000" , vfmsub231pd(zmm17, zmm2, zmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62E2ED58BA09" , vfmsub231pd(zmm17, zmm2, qword_ptr(rcx)._1to8())); + TEST_INSTRUCTION("62E2ED48BA4A7F" , vfmsub231pd(zmm17, zmm2, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62E2ED48BA8A00200000" , vfmsub231pd(zmm17, zmm2, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62E2ED48BA4A80" , vfmsub231pd(zmm17, zmm2, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62E2ED48BA8AC0DFFFFF" , vfmsub231pd(zmm17, zmm2, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62E2ED58BA4A7F" , vfmsub231pd(zmm17, zmm2, qword_ptr(rdx, 1016)._1to8())); + TEST_INSTRUCTION("62E2ED58BA8A00040000" , vfmsub231pd(zmm17, zmm2, qword_ptr(rdx, 1024)._1to8())); + TEST_INSTRUCTION("62E2ED58BA4A80" , vfmsub231pd(zmm17, zmm2, qword_ptr(rdx, -1024)._1to8())); + TEST_INSTRUCTION("62E2ED58BA8AF8FBFFFF" , vfmsub231pd(zmm17, zmm2, qword_ptr(rdx, -1032)._1to8())); + TEST_INSTRUCTION("62B25D48BAEC" , vfmsub231ps(zmm5, zmm4, zmm20)); + TEST_INSTRUCTION("62B25D49BAEC" , k(k1).vfmsub231ps(zmm5, zmm4, zmm20)); + TEST_INSTRUCTION("62B25DC9BAEC" , k(k1).z().vfmsub231ps(zmm5, zmm4, zmm20)); + TEST_INSTRUCTION("62B25D18BAEC" , rn_sae().vfmsub231ps(zmm5, zmm4, zmm20)); + TEST_INSTRUCTION("62B25D58BAEC" , ru_sae().vfmsub231ps(zmm5, zmm4, zmm20)); + TEST_INSTRUCTION("62B25D38BAEC" , rd_sae().vfmsub231ps(zmm5, zmm4, zmm20)); + TEST_INSTRUCTION("62B25D78BAEC" , rz_sae().vfmsub231ps(zmm5, zmm4, zmm20)); + TEST_INSTRUCTION("62F25D48BA29" , vfmsub231ps(zmm5, zmm4, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62B25D48BAACF034120000" , vfmsub231ps(zmm5, zmm4, zmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62F25D58BA29" , vfmsub231ps(zmm5, zmm4, dword_ptr(rcx)._1to16())); + TEST_INSTRUCTION("62F25D48BA6A7F" , vfmsub231ps(zmm5, zmm4, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62F25D48BAAA00200000" , vfmsub231ps(zmm5, zmm4, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62F25D48BA6A80" , vfmsub231ps(zmm5, zmm4, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62F25D48BAAAC0DFFFFF" , vfmsub231ps(zmm5, zmm4, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62F25D58BA6A7F" , vfmsub231ps(zmm5, zmm4, dword_ptr(rdx, 508)._1to16())); + TEST_INSTRUCTION("62F25D58BAAA00020000" , vfmsub231ps(zmm5, zmm4, dword_ptr(rdx, 512)._1to16())); + TEST_INSTRUCTION("62F25D58BA6A80" , vfmsub231ps(zmm5, zmm4, dword_ptr(rdx, -512)._1to16())); + TEST_INSTRUCTION("62F25D58BAAAFCFDFFFF" , vfmsub231ps(zmm5, zmm4, dword_ptr(rdx, -516)._1to16())); + TEST_INSTRUCTION("C4E2E9BBFE" , vfmsub231sd(xmm7, xmm2, xmm6)); + TEST_INSTRUCTION("62F2ED0CBBFE" , k(k4).vfmsub231sd(xmm7, xmm2, xmm6)); + TEST_INSTRUCTION("62F2ED8CBBFE" , k(k4).z().vfmsub231sd(xmm7, xmm2, xmm6)); + TEST_INSTRUCTION("62F2ED18BBFE" , rn_sae().vfmsub231sd(xmm7, xmm2, xmm6)); + TEST_INSTRUCTION("62F2ED58BBFE" , ru_sae().vfmsub231sd(xmm7, xmm2, xmm6)); + TEST_INSTRUCTION("62F2ED38BBFE" , rd_sae().vfmsub231sd(xmm7, xmm2, xmm6)); + TEST_INSTRUCTION("62F2ED78BBFE" , rz_sae().vfmsub231sd(xmm7, xmm2, xmm6)); + TEST_INSTRUCTION("C4E2E9BB39" , vfmsub231sd(xmm7, xmm2, qword_ptr(rcx))); + TEST_INSTRUCTION("C4A2E9BBBCF034120000" , vfmsub231sd(xmm7, xmm2, qword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("C4E2E9BBBAF8030000" , vfmsub231sd(xmm7, xmm2, qword_ptr(rdx, 1016))); + TEST_INSTRUCTION("C4E2E9BBBA00040000" , vfmsub231sd(xmm7, xmm2, qword_ptr(rdx, 1024))); + TEST_INSTRUCTION("C4E2E9BBBA00FCFFFF" , vfmsub231sd(xmm7, xmm2, qword_ptr(rdx, -1024))); + TEST_INSTRUCTION("C4E2E9BBBAF8FBFFFF" , vfmsub231sd(xmm7, xmm2, qword_ptr(rdx, -1032))); + TEST_INSTRUCTION("62A26D00BBD2" , vfmsub231ss(xmm18, xmm18, xmm18)); + TEST_INSTRUCTION("62A26D07BBD2" , k(k7).vfmsub231ss(xmm18, xmm18, xmm18)); + TEST_INSTRUCTION("62A26D87BBD2" , k(k7).z().vfmsub231ss(xmm18, xmm18, xmm18)); + TEST_INSTRUCTION("62A26D10BBD2" , rn_sae().vfmsub231ss(xmm18, xmm18, xmm18)); + TEST_INSTRUCTION("62A26D50BBD2" , ru_sae().vfmsub231ss(xmm18, xmm18, xmm18)); + TEST_INSTRUCTION("62A26D30BBD2" , rd_sae().vfmsub231ss(xmm18, xmm18, xmm18)); + TEST_INSTRUCTION("62A26D70BBD2" , rz_sae().vfmsub231ss(xmm18, xmm18, xmm18)); + TEST_INSTRUCTION("62E26D00BB11" , vfmsub231ss(xmm18, xmm18, dword_ptr(rcx))); + TEST_INSTRUCTION("62A26D00BB94F034120000" , vfmsub231ss(xmm18, xmm18, dword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62E26D00BB527F" , vfmsub231ss(xmm18, xmm18, dword_ptr(rdx, 508))); + TEST_INSTRUCTION("62E26D00BB9200020000" , vfmsub231ss(xmm18, xmm18, dword_ptr(rdx, 512))); + TEST_INSTRUCTION("62E26D00BB5280" , vfmsub231ss(xmm18, xmm18, dword_ptr(rdx, -512))); + TEST_INSTRUCTION("62E26D00BB92FCFDFFFF" , vfmsub231ss(xmm18, xmm18, dword_ptr(rdx, -516))); + TEST_INSTRUCTION("62E2DD4897EF" , vfmsubadd132pd(zmm21, zmm4, zmm7)); + TEST_INSTRUCTION("62E2DD4D97EF" , k(k5).vfmsubadd132pd(zmm21, zmm4, zmm7)); + TEST_INSTRUCTION("62E2DDCD97EF" , k(k5).z().vfmsubadd132pd(zmm21, zmm4, zmm7)); + TEST_INSTRUCTION("62E2DD1897EF" , rn_sae().vfmsubadd132pd(zmm21, zmm4, zmm7)); + TEST_INSTRUCTION("62E2DD5897EF" , ru_sae().vfmsubadd132pd(zmm21, zmm4, zmm7)); + TEST_INSTRUCTION("62E2DD3897EF" , rd_sae().vfmsubadd132pd(zmm21, zmm4, zmm7)); + TEST_INSTRUCTION("62E2DD7897EF" , rz_sae().vfmsubadd132pd(zmm21, zmm4, zmm7)); + TEST_INSTRUCTION("62E2DD489729" , vfmsubadd132pd(zmm21, zmm4, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62A2DD4897ACF034120000" , vfmsubadd132pd(zmm21, zmm4, zmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62E2DD589729" , vfmsubadd132pd(zmm21, zmm4, qword_ptr(rcx)._1to8())); + TEST_INSTRUCTION("62E2DD48976A7F" , vfmsubadd132pd(zmm21, zmm4, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62E2DD4897AA00200000" , vfmsubadd132pd(zmm21, zmm4, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62E2DD48976A80" , vfmsubadd132pd(zmm21, zmm4, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62E2DD4897AAC0DFFFFF" , vfmsubadd132pd(zmm21, zmm4, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62E2DD58976A7F" , vfmsubadd132pd(zmm21, zmm4, qword_ptr(rdx, 1016)._1to8())); + TEST_INSTRUCTION("62E2DD5897AA00040000" , vfmsubadd132pd(zmm21, zmm4, qword_ptr(rdx, 1024)._1to8())); + TEST_INSTRUCTION("62E2DD58976A80" , vfmsubadd132pd(zmm21, zmm4, qword_ptr(rdx, -1024)._1to8())); + TEST_INSTRUCTION("62E2DD5897AAF8FBFFFF" , vfmsubadd132pd(zmm21, zmm4, qword_ptr(rdx, -1032)._1to8())); + TEST_INSTRUCTION("62B23D4097F0" , vfmsubadd132ps(zmm6, zmm24, zmm16)); + TEST_INSTRUCTION("62B23D4797F0" , k(k7).vfmsubadd132ps(zmm6, zmm24, zmm16)); + TEST_INSTRUCTION("62B23DC797F0" , k(k7).z().vfmsubadd132ps(zmm6, zmm24, zmm16)); + TEST_INSTRUCTION("62B23D1097F0" , rn_sae().vfmsubadd132ps(zmm6, zmm24, zmm16)); + TEST_INSTRUCTION("62B23D5097F0" , ru_sae().vfmsubadd132ps(zmm6, zmm24, zmm16)); + TEST_INSTRUCTION("62B23D3097F0" , rd_sae().vfmsubadd132ps(zmm6, zmm24, zmm16)); + TEST_INSTRUCTION("62B23D7097F0" , rz_sae().vfmsubadd132ps(zmm6, zmm24, zmm16)); + TEST_INSTRUCTION("62F23D409731" , vfmsubadd132ps(zmm6, zmm24, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62B23D4097B4F034120000" , vfmsubadd132ps(zmm6, zmm24, zmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62F23D509731" , vfmsubadd132ps(zmm6, zmm24, dword_ptr(rcx)._1to16())); + TEST_INSTRUCTION("62F23D4097727F" , vfmsubadd132ps(zmm6, zmm24, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62F23D4097B200200000" , vfmsubadd132ps(zmm6, zmm24, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62F23D40977280" , vfmsubadd132ps(zmm6, zmm24, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62F23D4097B2C0DFFFFF" , vfmsubadd132ps(zmm6, zmm24, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62F23D5097727F" , vfmsubadd132ps(zmm6, zmm24, dword_ptr(rdx, 508)._1to16())); + TEST_INSTRUCTION("62F23D5097B200020000" , vfmsubadd132ps(zmm6, zmm24, dword_ptr(rdx, 512)._1to16())); + TEST_INSTRUCTION("62F23D50977280" , vfmsubadd132ps(zmm6, zmm24, dword_ptr(rdx, -512)._1to16())); + TEST_INSTRUCTION("62F23D5097B2FCFDFFFF" , vfmsubadd132ps(zmm6, zmm24, dword_ptr(rdx, -516)._1to16())); + TEST_INSTRUCTION("6252CD40A7DB" , vfmsubadd213pd(zmm11, zmm22, zmm11)); + TEST_INSTRUCTION("6252CD44A7DB" , k(k4).vfmsubadd213pd(zmm11, zmm22, zmm11)); + TEST_INSTRUCTION("6252CDC4A7DB" , k(k4).z().vfmsubadd213pd(zmm11, zmm22, zmm11)); + TEST_INSTRUCTION("6252CD10A7DB" , rn_sae().vfmsubadd213pd(zmm11, zmm22, zmm11)); + TEST_INSTRUCTION("6252CD50A7DB" , ru_sae().vfmsubadd213pd(zmm11, zmm22, zmm11)); + TEST_INSTRUCTION("6252CD30A7DB" , rd_sae().vfmsubadd213pd(zmm11, zmm22, zmm11)); + TEST_INSTRUCTION("6252CD70A7DB" , rz_sae().vfmsubadd213pd(zmm11, zmm22, zmm11)); + TEST_INSTRUCTION("6272CD40A719" , vfmsubadd213pd(zmm11, zmm22, zmmword_ptr(rcx))); + TEST_INSTRUCTION("6232CD40A79CF034120000" , vfmsubadd213pd(zmm11, zmm22, zmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("6272CD50A719" , vfmsubadd213pd(zmm11, zmm22, qword_ptr(rcx)._1to8())); + TEST_INSTRUCTION("6272CD40A75A7F" , vfmsubadd213pd(zmm11, zmm22, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("6272CD40A79A00200000" , vfmsubadd213pd(zmm11, zmm22, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("6272CD40A75A80" , vfmsubadd213pd(zmm11, zmm22, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("6272CD40A79AC0DFFFFF" , vfmsubadd213pd(zmm11, zmm22, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("6272CD50A75A7F" , vfmsubadd213pd(zmm11, zmm22, qword_ptr(rdx, 1016)._1to8())); + TEST_INSTRUCTION("6272CD50A79A00040000" , vfmsubadd213pd(zmm11, zmm22, qword_ptr(rdx, 1024)._1to8())); + TEST_INSTRUCTION("6272CD50A75A80" , vfmsubadd213pd(zmm11, zmm22, qword_ptr(rdx, -1024)._1to8())); + TEST_INSTRUCTION("6272CD50A79AF8FBFFFF" , vfmsubadd213pd(zmm11, zmm22, qword_ptr(rdx, -1032)._1to8())); + TEST_INSTRUCTION("62523548A7E2" , vfmsubadd213ps(zmm12, zmm9, zmm10)); + TEST_INSTRUCTION("6252354FA7E2" , k(k7).vfmsubadd213ps(zmm12, zmm9, zmm10)); + TEST_INSTRUCTION("625235CFA7E2" , k(k7).z().vfmsubadd213ps(zmm12, zmm9, zmm10)); + TEST_INSTRUCTION("62523518A7E2" , rn_sae().vfmsubadd213ps(zmm12, zmm9, zmm10)); + TEST_INSTRUCTION("62523558A7E2" , ru_sae().vfmsubadd213ps(zmm12, zmm9, zmm10)); + TEST_INSTRUCTION("62523538A7E2" , rd_sae().vfmsubadd213ps(zmm12, zmm9, zmm10)); + TEST_INSTRUCTION("62523578A7E2" , rz_sae().vfmsubadd213ps(zmm12, zmm9, zmm10)); + TEST_INSTRUCTION("62723548A721" , vfmsubadd213ps(zmm12, zmm9, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62323548A7A4F034120000" , vfmsubadd213ps(zmm12, zmm9, zmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62723558A721" , vfmsubadd213ps(zmm12, zmm9, dword_ptr(rcx)._1to16())); + TEST_INSTRUCTION("62723548A7627F" , vfmsubadd213ps(zmm12, zmm9, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62723548A7A200200000" , vfmsubadd213ps(zmm12, zmm9, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62723548A76280" , vfmsubadd213ps(zmm12, zmm9, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62723548A7A2C0DFFFFF" , vfmsubadd213ps(zmm12, zmm9, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62723558A7627F" , vfmsubadd213ps(zmm12, zmm9, dword_ptr(rdx, 508)._1to16())); + TEST_INSTRUCTION("62723558A7A200020000" , vfmsubadd213ps(zmm12, zmm9, dword_ptr(rdx, 512)._1to16())); + TEST_INSTRUCTION("62723558A76280" , vfmsubadd213ps(zmm12, zmm9, dword_ptr(rdx, -512)._1to16())); + TEST_INSTRUCTION("62723558A7A2FCFDFFFF" , vfmsubadd213ps(zmm12, zmm9, dword_ptr(rdx, -516)._1to16())); + TEST_INSTRUCTION("62C2ED48B7E9" , vfmsubadd231pd(zmm21, zmm2, zmm9)); + TEST_INSTRUCTION("62C2ED4EB7E9" , k(k6).vfmsubadd231pd(zmm21, zmm2, zmm9)); + TEST_INSTRUCTION("62C2EDCEB7E9" , k(k6).z().vfmsubadd231pd(zmm21, zmm2, zmm9)); + TEST_INSTRUCTION("62C2ED18B7E9" , rn_sae().vfmsubadd231pd(zmm21, zmm2, zmm9)); + TEST_INSTRUCTION("62C2ED58B7E9" , ru_sae().vfmsubadd231pd(zmm21, zmm2, zmm9)); + TEST_INSTRUCTION("62C2ED38B7E9" , rd_sae().vfmsubadd231pd(zmm21, zmm2, zmm9)); + TEST_INSTRUCTION("62C2ED78B7E9" , rz_sae().vfmsubadd231pd(zmm21, zmm2, zmm9)); + TEST_INSTRUCTION("62E2ED48B729" , vfmsubadd231pd(zmm21, zmm2, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62A2ED48B7ACF034120000" , vfmsubadd231pd(zmm21, zmm2, zmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62E2ED58B729" , vfmsubadd231pd(zmm21, zmm2, qword_ptr(rcx)._1to8())); + TEST_INSTRUCTION("62E2ED48B76A7F" , vfmsubadd231pd(zmm21, zmm2, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62E2ED48B7AA00200000" , vfmsubadd231pd(zmm21, zmm2, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62E2ED48B76A80" , vfmsubadd231pd(zmm21, zmm2, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62E2ED48B7AAC0DFFFFF" , vfmsubadd231pd(zmm21, zmm2, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62E2ED58B76A7F" , vfmsubadd231pd(zmm21, zmm2, qword_ptr(rdx, 1016)._1to8())); + TEST_INSTRUCTION("62E2ED58B7AA00040000" , vfmsubadd231pd(zmm21, zmm2, qword_ptr(rdx, 1024)._1to8())); + TEST_INSTRUCTION("62E2ED58B76A80" , vfmsubadd231pd(zmm21, zmm2, qword_ptr(rdx, -1024)._1to8())); + TEST_INSTRUCTION("62E2ED58B7AAF8FBFFFF" , vfmsubadd231pd(zmm21, zmm2, qword_ptr(rdx, -1032)._1to8())); + TEST_INSTRUCTION("62025540B7D8" , vfmsubadd231ps(zmm27, zmm21, zmm24)); + TEST_INSTRUCTION("62025546B7D8" , k(k6).vfmsubadd231ps(zmm27, zmm21, zmm24)); + TEST_INSTRUCTION("620255C6B7D8" , k(k6).z().vfmsubadd231ps(zmm27, zmm21, zmm24)); + TEST_INSTRUCTION("62025510B7D8" , rn_sae().vfmsubadd231ps(zmm27, zmm21, zmm24)); + TEST_INSTRUCTION("62025550B7D8" , ru_sae().vfmsubadd231ps(zmm27, zmm21, zmm24)); + TEST_INSTRUCTION("62025530B7D8" , rd_sae().vfmsubadd231ps(zmm27, zmm21, zmm24)); + TEST_INSTRUCTION("62025570B7D8" , rz_sae().vfmsubadd231ps(zmm27, zmm21, zmm24)); + TEST_INSTRUCTION("62625540B719" , vfmsubadd231ps(zmm27, zmm21, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62225540B79CF034120000" , vfmsubadd231ps(zmm27, zmm21, zmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62625550B719" , vfmsubadd231ps(zmm27, zmm21, dword_ptr(rcx)._1to16())); + TEST_INSTRUCTION("62625540B75A7F" , vfmsubadd231ps(zmm27, zmm21, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62625540B79A00200000" , vfmsubadd231ps(zmm27, zmm21, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62625540B75A80" , vfmsubadd231ps(zmm27, zmm21, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62625540B79AC0DFFFFF" , vfmsubadd231ps(zmm27, zmm21, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62625550B75A7F" , vfmsubadd231ps(zmm27, zmm21, dword_ptr(rdx, 508)._1to16())); + TEST_INSTRUCTION("62625550B79A00020000" , vfmsubadd231ps(zmm27, zmm21, dword_ptr(rdx, 512)._1to16())); + TEST_INSTRUCTION("62625550B75A80" , vfmsubadd231ps(zmm27, zmm21, dword_ptr(rdx, -512)._1to16())); + TEST_INSTRUCTION("62625550B79AFCFDFFFF" , vfmsubadd231ps(zmm27, zmm21, dword_ptr(rdx, -516)._1to16())); + TEST_INSTRUCTION("623295409CDB" , vfnmadd132pd(zmm11, zmm29, zmm19)); + TEST_INSTRUCTION("623295429CDB" , k(k2).vfnmadd132pd(zmm11, zmm29, zmm19)); + TEST_INSTRUCTION("623295C29CDB" , k(k2).z().vfnmadd132pd(zmm11, zmm29, zmm19)); + TEST_INSTRUCTION("623295109CDB" , rn_sae().vfnmadd132pd(zmm11, zmm29, zmm19)); + TEST_INSTRUCTION("623295509CDB" , ru_sae().vfnmadd132pd(zmm11, zmm29, zmm19)); + TEST_INSTRUCTION("623295309CDB" , rd_sae().vfnmadd132pd(zmm11, zmm29, zmm19)); + TEST_INSTRUCTION("623295709CDB" , rz_sae().vfnmadd132pd(zmm11, zmm29, zmm19)); + TEST_INSTRUCTION("627295409C19" , vfnmadd132pd(zmm11, zmm29, zmmword_ptr(rcx))); + TEST_INSTRUCTION("623295409C9CF034120000" , vfnmadd132pd(zmm11, zmm29, zmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("627295509C19" , vfnmadd132pd(zmm11, zmm29, qword_ptr(rcx)._1to8())); + TEST_INSTRUCTION("627295409C5A7F" , vfnmadd132pd(zmm11, zmm29, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("627295409C9A00200000" , vfnmadd132pd(zmm11, zmm29, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("627295409C5A80" , vfnmadd132pd(zmm11, zmm29, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("627295409C9AC0DFFFFF" , vfnmadd132pd(zmm11, zmm29, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("627295509C5A7F" , vfnmadd132pd(zmm11, zmm29, qword_ptr(rdx, 1016)._1to8())); + TEST_INSTRUCTION("627295509C9A00040000" , vfnmadd132pd(zmm11, zmm29, qword_ptr(rdx, 1024)._1to8())); + TEST_INSTRUCTION("627295509C5A80" , vfnmadd132pd(zmm11, zmm29, qword_ptr(rdx, -1024)._1to8())); + TEST_INSTRUCTION("627295509C9AF8FBFFFF" , vfnmadd132pd(zmm11, zmm29, qword_ptr(rdx, -1032)._1to8())); + TEST_INSTRUCTION("62C265489CCF" , vfnmadd132ps(zmm17, zmm3, zmm15)); + TEST_INSTRUCTION("62C2654D9CCF" , k(k5).vfnmadd132ps(zmm17, zmm3, zmm15)); + TEST_INSTRUCTION("62C265CD9CCF" , k(k5).z().vfnmadd132ps(zmm17, zmm3, zmm15)); + TEST_INSTRUCTION("62C265189CCF" , rn_sae().vfnmadd132ps(zmm17, zmm3, zmm15)); + TEST_INSTRUCTION("62C265589CCF" , ru_sae().vfnmadd132ps(zmm17, zmm3, zmm15)); + TEST_INSTRUCTION("62C265389CCF" , rd_sae().vfnmadd132ps(zmm17, zmm3, zmm15)); + TEST_INSTRUCTION("62C265789CCF" , rz_sae().vfnmadd132ps(zmm17, zmm3, zmm15)); + TEST_INSTRUCTION("62E265489C09" , vfnmadd132ps(zmm17, zmm3, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62A265489C8CF034120000" , vfnmadd132ps(zmm17, zmm3, zmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62E265589C09" , vfnmadd132ps(zmm17, zmm3, dword_ptr(rcx)._1to16())); + TEST_INSTRUCTION("62E265489C4A7F" , vfnmadd132ps(zmm17, zmm3, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62E265489C8A00200000" , vfnmadd132ps(zmm17, zmm3, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62E265489C4A80" , vfnmadd132ps(zmm17, zmm3, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62E265489C8AC0DFFFFF" , vfnmadd132ps(zmm17, zmm3, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62E265589C4A7F" , vfnmadd132ps(zmm17, zmm3, dword_ptr(rdx, 508)._1to16())); + TEST_INSTRUCTION("62E265589C8A00020000" , vfnmadd132ps(zmm17, zmm3, dword_ptr(rdx, 512)._1to16())); + TEST_INSTRUCTION("62E265589C4A80" , vfnmadd132ps(zmm17, zmm3, dword_ptr(rdx, -512)._1to16())); + TEST_INSTRUCTION("62E265589C8AFCFDFFFF" , vfnmadd132ps(zmm17, zmm3, dword_ptr(rdx, -516)._1to16())); + TEST_INSTRUCTION("62F2BD009DD1" , vfnmadd132sd(xmm2, xmm24, xmm1)); + TEST_INSTRUCTION("62F2BD049DD1" , k(k4).vfnmadd132sd(xmm2, xmm24, xmm1)); + TEST_INSTRUCTION("62F2BD849DD1" , k(k4).z().vfnmadd132sd(xmm2, xmm24, xmm1)); + TEST_INSTRUCTION("62F2BD109DD1" , rn_sae().vfnmadd132sd(xmm2, xmm24, xmm1)); + TEST_INSTRUCTION("62F2BD509DD1" , ru_sae().vfnmadd132sd(xmm2, xmm24, xmm1)); + TEST_INSTRUCTION("62F2BD309DD1" , rd_sae().vfnmadd132sd(xmm2, xmm24, xmm1)); + TEST_INSTRUCTION("62F2BD709DD1" , rz_sae().vfnmadd132sd(xmm2, xmm24, xmm1)); + TEST_INSTRUCTION("62F2BD009D11" , vfnmadd132sd(xmm2, xmm24, qword_ptr(rcx))); + TEST_INSTRUCTION("62B2BD009D94F034120000" , vfnmadd132sd(xmm2, xmm24, qword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62F2BD009D527F" , vfnmadd132sd(xmm2, xmm24, qword_ptr(rdx, 1016))); + TEST_INSTRUCTION("62F2BD009D9200040000" , vfnmadd132sd(xmm2, xmm24, qword_ptr(rdx, 1024))); + TEST_INSTRUCTION("62F2BD009D5280" , vfnmadd132sd(xmm2, xmm24, qword_ptr(rdx, -1024))); + TEST_INSTRUCTION("62F2BD009D92F8FBFFFF" , vfnmadd132sd(xmm2, xmm24, qword_ptr(rdx, -1032))); + TEST_INSTRUCTION("625265009DED" , vfnmadd132ss(xmm13, xmm19, xmm13)); + TEST_INSTRUCTION("625265049DED" , k(k4).vfnmadd132ss(xmm13, xmm19, xmm13)); + TEST_INSTRUCTION("625265849DED" , k(k4).z().vfnmadd132ss(xmm13, xmm19, xmm13)); + TEST_INSTRUCTION("625265109DED" , rn_sae().vfnmadd132ss(xmm13, xmm19, xmm13)); + TEST_INSTRUCTION("625265509DED" , ru_sae().vfnmadd132ss(xmm13, xmm19, xmm13)); + TEST_INSTRUCTION("625265309DED" , rd_sae().vfnmadd132ss(xmm13, xmm19, xmm13)); + TEST_INSTRUCTION("625265709DED" , rz_sae().vfnmadd132ss(xmm13, xmm19, xmm13)); + TEST_INSTRUCTION("627265009D29" , vfnmadd132ss(xmm13, xmm19, dword_ptr(rcx))); + TEST_INSTRUCTION("623265009DACF034120000" , vfnmadd132ss(xmm13, xmm19, dword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("627265009D6A7F" , vfnmadd132ss(xmm13, xmm19, dword_ptr(rdx, 508))); + TEST_INSTRUCTION("627265009DAA00020000" , vfnmadd132ss(xmm13, xmm19, dword_ptr(rdx, 512))); + TEST_INSTRUCTION("627265009D6A80" , vfnmadd132ss(xmm13, xmm19, dword_ptr(rdx, -512))); + TEST_INSTRUCTION("627265009DAAFCFDFFFF" , vfnmadd132ss(xmm13, xmm19, dword_ptr(rdx, -516))); + TEST_INSTRUCTION("6232F548ACFE" , vfnmadd213pd(zmm15, zmm1, zmm22)); + TEST_INSTRUCTION("6232F54BACFE" , k(k3).vfnmadd213pd(zmm15, zmm1, zmm22)); + TEST_INSTRUCTION("6232F5CBACFE" , k(k3).z().vfnmadd213pd(zmm15, zmm1, zmm22)); + TEST_INSTRUCTION("6232F518ACFE" , rn_sae().vfnmadd213pd(zmm15, zmm1, zmm22)); + TEST_INSTRUCTION("6232F558ACFE" , ru_sae().vfnmadd213pd(zmm15, zmm1, zmm22)); + TEST_INSTRUCTION("6232F538ACFE" , rd_sae().vfnmadd213pd(zmm15, zmm1, zmm22)); + TEST_INSTRUCTION("6232F578ACFE" , rz_sae().vfnmadd213pd(zmm15, zmm1, zmm22)); + TEST_INSTRUCTION("6272F548AC39" , vfnmadd213pd(zmm15, zmm1, zmmword_ptr(rcx))); + TEST_INSTRUCTION("6232F548ACBCF034120000" , vfnmadd213pd(zmm15, zmm1, zmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("6272F558AC39" , vfnmadd213pd(zmm15, zmm1, qword_ptr(rcx)._1to8())); + TEST_INSTRUCTION("6272F548AC7A7F" , vfnmadd213pd(zmm15, zmm1, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("6272F548ACBA00200000" , vfnmadd213pd(zmm15, zmm1, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("6272F548AC7A80" , vfnmadd213pd(zmm15, zmm1, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("6272F548ACBAC0DFFFFF" , vfnmadd213pd(zmm15, zmm1, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("6272F558AC7A7F" , vfnmadd213pd(zmm15, zmm1, qword_ptr(rdx, 1016)._1to8())); + TEST_INSTRUCTION("6272F558ACBA00040000" , vfnmadd213pd(zmm15, zmm1, qword_ptr(rdx, 1024)._1to8())); + TEST_INSTRUCTION("6272F558AC7A80" , vfnmadd213pd(zmm15, zmm1, qword_ptr(rdx, -1024)._1to8())); + TEST_INSTRUCTION("6272F558ACBAF8FBFFFF" , vfnmadd213pd(zmm15, zmm1, qword_ptr(rdx, -1032)._1to8())); + TEST_INSTRUCTION("62725D48ACDC" , vfnmadd213ps(zmm11, zmm4, zmm4)); + TEST_INSTRUCTION("62725D4CACDC" , k(k4).vfnmadd213ps(zmm11, zmm4, zmm4)); + TEST_INSTRUCTION("62725DCCACDC" , k(k4).z().vfnmadd213ps(zmm11, zmm4, zmm4)); + TEST_INSTRUCTION("62725D18ACDC" , rn_sae().vfnmadd213ps(zmm11, zmm4, zmm4)); + TEST_INSTRUCTION("62725D58ACDC" , ru_sae().vfnmadd213ps(zmm11, zmm4, zmm4)); + TEST_INSTRUCTION("62725D38ACDC" , rd_sae().vfnmadd213ps(zmm11, zmm4, zmm4)); + TEST_INSTRUCTION("62725D78ACDC" , rz_sae().vfnmadd213ps(zmm11, zmm4, zmm4)); + TEST_INSTRUCTION("62725D48AC19" , vfnmadd213ps(zmm11, zmm4, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62325D48AC9CF034120000" , vfnmadd213ps(zmm11, zmm4, zmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62725D58AC19" , vfnmadd213ps(zmm11, zmm4, dword_ptr(rcx)._1to16())); + TEST_INSTRUCTION("62725D48AC5A7F" , vfnmadd213ps(zmm11, zmm4, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62725D48AC9A00200000" , vfnmadd213ps(zmm11, zmm4, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62725D48AC5A80" , vfnmadd213ps(zmm11, zmm4, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62725D48AC9AC0DFFFFF" , vfnmadd213ps(zmm11, zmm4, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62725D58AC5A7F" , vfnmadd213ps(zmm11, zmm4, dword_ptr(rdx, 508)._1to16())); + TEST_INSTRUCTION("62725D58AC9A00020000" , vfnmadd213ps(zmm11, zmm4, dword_ptr(rdx, 512)._1to16())); + TEST_INSTRUCTION("62725D58AC5A80" , vfnmadd213ps(zmm11, zmm4, dword_ptr(rdx, -512)._1to16())); + TEST_INSTRUCTION("62725D58AC9AFCFDFFFF" , vfnmadd213ps(zmm11, zmm4, dword_ptr(rdx, -516)._1to16())); + TEST_INSTRUCTION("62428D08ADF3" , vfnmadd213sd(xmm30, xmm14, xmm11)); + TEST_INSTRUCTION("62428D0CADF3" , k(k4).vfnmadd213sd(xmm30, xmm14, xmm11)); + TEST_INSTRUCTION("62428D8CADF3" , k(k4).z().vfnmadd213sd(xmm30, xmm14, xmm11)); + TEST_INSTRUCTION("62428D18ADF3" , rn_sae().vfnmadd213sd(xmm30, xmm14, xmm11)); + TEST_INSTRUCTION("62428D58ADF3" , ru_sae().vfnmadd213sd(xmm30, xmm14, xmm11)); + TEST_INSTRUCTION("62428D38ADF3" , rd_sae().vfnmadd213sd(xmm30, xmm14, xmm11)); + TEST_INSTRUCTION("62428D78ADF3" , rz_sae().vfnmadd213sd(xmm30, xmm14, xmm11)); + TEST_INSTRUCTION("62628D08AD31" , vfnmadd213sd(xmm30, xmm14, qword_ptr(rcx))); + TEST_INSTRUCTION("62228D08ADB4F034120000" , vfnmadd213sd(xmm30, xmm14, qword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62628D08AD727F" , vfnmadd213sd(xmm30, xmm14, qword_ptr(rdx, 1016))); + TEST_INSTRUCTION("62628D08ADB200040000" , vfnmadd213sd(xmm30, xmm14, qword_ptr(rdx, 1024))); + TEST_INSTRUCTION("62628D08AD7280" , vfnmadd213sd(xmm30, xmm14, qword_ptr(rdx, -1024))); + TEST_INSTRUCTION("62628D08ADB2F8FBFFFF" , vfnmadd213sd(xmm30, xmm14, qword_ptr(rdx, -1032))); + TEST_INSTRUCTION("62226508ADE4" , vfnmadd213ss(xmm28, xmm3, xmm20)); + TEST_INSTRUCTION("6222650BADE4" , k(k3).vfnmadd213ss(xmm28, xmm3, xmm20)); + TEST_INSTRUCTION("6222658BADE4" , k(k3).z().vfnmadd213ss(xmm28, xmm3, xmm20)); + TEST_INSTRUCTION("62226518ADE4" , rn_sae().vfnmadd213ss(xmm28, xmm3, xmm20)); + TEST_INSTRUCTION("62226558ADE4" , ru_sae().vfnmadd213ss(xmm28, xmm3, xmm20)); + TEST_INSTRUCTION("62226538ADE4" , rd_sae().vfnmadd213ss(xmm28, xmm3, xmm20)); + TEST_INSTRUCTION("62226578ADE4" , rz_sae().vfnmadd213ss(xmm28, xmm3, xmm20)); + TEST_INSTRUCTION("62626508AD21" , vfnmadd213ss(xmm28, xmm3, dword_ptr(rcx))); + TEST_INSTRUCTION("62226508ADA4F034120000" , vfnmadd213ss(xmm28, xmm3, dword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62626508AD627F" , vfnmadd213ss(xmm28, xmm3, dword_ptr(rdx, 508))); + TEST_INSTRUCTION("62626508ADA200020000" , vfnmadd213ss(xmm28, xmm3, dword_ptr(rdx, 512))); + TEST_INSTRUCTION("62626508AD6280" , vfnmadd213ss(xmm28, xmm3, dword_ptr(rdx, -512))); + TEST_INSTRUCTION("62626508ADA2FCFDFFFF" , vfnmadd213ss(xmm28, xmm3, dword_ptr(rdx, -516))); + TEST_INSTRUCTION("6232D548BCFE" , vfnmadd231pd(zmm15, zmm5, zmm22)); + TEST_INSTRUCTION("6232D54FBCFE" , k(k7).vfnmadd231pd(zmm15, zmm5, zmm22)); + TEST_INSTRUCTION("6232D5CFBCFE" , k(k7).z().vfnmadd231pd(zmm15, zmm5, zmm22)); + TEST_INSTRUCTION("6232D518BCFE" , rn_sae().vfnmadd231pd(zmm15, zmm5, zmm22)); + TEST_INSTRUCTION("6232D558BCFE" , ru_sae().vfnmadd231pd(zmm15, zmm5, zmm22)); + TEST_INSTRUCTION("6232D538BCFE" , rd_sae().vfnmadd231pd(zmm15, zmm5, zmm22)); + TEST_INSTRUCTION("6232D578BCFE" , rz_sae().vfnmadd231pd(zmm15, zmm5, zmm22)); + TEST_INSTRUCTION("6272D548BC39" , vfnmadd231pd(zmm15, zmm5, zmmword_ptr(rcx))); + TEST_INSTRUCTION("6232D548BCBCF034120000" , vfnmadd231pd(zmm15, zmm5, zmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("6272D558BC39" , vfnmadd231pd(zmm15, zmm5, qword_ptr(rcx)._1to8())); + TEST_INSTRUCTION("6272D548BC7A7F" , vfnmadd231pd(zmm15, zmm5, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("6272D548BCBA00200000" , vfnmadd231pd(zmm15, zmm5, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("6272D548BC7A80" , vfnmadd231pd(zmm15, zmm5, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("6272D548BCBAC0DFFFFF" , vfnmadd231pd(zmm15, zmm5, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("6272D558BC7A7F" , vfnmadd231pd(zmm15, zmm5, qword_ptr(rdx, 1016)._1to8())); + TEST_INSTRUCTION("6272D558BCBA00040000" , vfnmadd231pd(zmm15, zmm5, qword_ptr(rdx, 1024)._1to8())); + TEST_INSTRUCTION("6272D558BC7A80" , vfnmadd231pd(zmm15, zmm5, qword_ptr(rdx, -1024)._1to8())); + TEST_INSTRUCTION("6272D558BCBAF8FBFFFF" , vfnmadd231pd(zmm15, zmm5, qword_ptr(rdx, -1032)._1to8())); + TEST_INSTRUCTION("62521D40BCE9" , vfnmadd231ps(zmm13, zmm28, zmm9)); + TEST_INSTRUCTION("62521D43BCE9" , k(k3).vfnmadd231ps(zmm13, zmm28, zmm9)); + TEST_INSTRUCTION("62521DC3BCE9" , k(k3).z().vfnmadd231ps(zmm13, zmm28, zmm9)); + TEST_INSTRUCTION("62521D10BCE9" , rn_sae().vfnmadd231ps(zmm13, zmm28, zmm9)); + TEST_INSTRUCTION("62521D50BCE9" , ru_sae().vfnmadd231ps(zmm13, zmm28, zmm9)); + TEST_INSTRUCTION("62521D30BCE9" , rd_sae().vfnmadd231ps(zmm13, zmm28, zmm9)); + TEST_INSTRUCTION("62521D70BCE9" , rz_sae().vfnmadd231ps(zmm13, zmm28, zmm9)); + TEST_INSTRUCTION("62721D40BC29" , vfnmadd231ps(zmm13, zmm28, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62321D40BCACF034120000" , vfnmadd231ps(zmm13, zmm28, zmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62721D50BC29" , vfnmadd231ps(zmm13, zmm28, dword_ptr(rcx)._1to16())); + TEST_INSTRUCTION("62721D40BC6A7F" , vfnmadd231ps(zmm13, zmm28, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62721D40BCAA00200000" , vfnmadd231ps(zmm13, zmm28, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62721D40BC6A80" , vfnmadd231ps(zmm13, zmm28, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62721D40BCAAC0DFFFFF" , vfnmadd231ps(zmm13, zmm28, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62721D50BC6A7F" , vfnmadd231ps(zmm13, zmm28, dword_ptr(rdx, 508)._1to16())); + TEST_INSTRUCTION("62721D50BCAA00020000" , vfnmadd231ps(zmm13, zmm28, dword_ptr(rdx, 512)._1to16())); + TEST_INSTRUCTION("62721D50BC6A80" , vfnmadd231ps(zmm13, zmm28, dword_ptr(rdx, -512)._1to16())); + TEST_INSTRUCTION("62721D50BCAAFCFDFFFF" , vfnmadd231ps(zmm13, zmm28, dword_ptr(rdx, -516)._1to16())); + TEST_INSTRUCTION("C462D1BDF5" , vfnmadd231sd(xmm14, xmm5, xmm5)); + TEST_INSTRUCTION("6272D50FBDF5" , k(k7).vfnmadd231sd(xmm14, xmm5, xmm5)); + TEST_INSTRUCTION("6272D58FBDF5" , k(k7).z().vfnmadd231sd(xmm14, xmm5, xmm5)); + TEST_INSTRUCTION("6272D518BDF5" , rn_sae().vfnmadd231sd(xmm14, xmm5, xmm5)); + TEST_INSTRUCTION("6272D558BDF5" , ru_sae().vfnmadd231sd(xmm14, xmm5, xmm5)); + TEST_INSTRUCTION("6272D538BDF5" , rd_sae().vfnmadd231sd(xmm14, xmm5, xmm5)); + TEST_INSTRUCTION("6272D578BDF5" , rz_sae().vfnmadd231sd(xmm14, xmm5, xmm5)); + TEST_INSTRUCTION("C462D1BD31" , vfnmadd231sd(xmm14, xmm5, qword_ptr(rcx))); + TEST_INSTRUCTION("C422D1BDB4F034120000" , vfnmadd231sd(xmm14, xmm5, qword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("C462D1BDB2F8030000" , vfnmadd231sd(xmm14, xmm5, qword_ptr(rdx, 1016))); + TEST_INSTRUCTION("C462D1BDB200040000" , vfnmadd231sd(xmm14, xmm5, qword_ptr(rdx, 1024))); + TEST_INSTRUCTION("C462D1BDB200FCFFFF" , vfnmadd231sd(xmm14, xmm5, qword_ptr(rdx, -1024))); + TEST_INSTRUCTION("C462D1BDB2F8FBFFFF" , vfnmadd231sd(xmm14, xmm5, qword_ptr(rdx, -1032))); + TEST_INSTRUCTION("62027D00BDC9" , vfnmadd231ss(xmm25, xmm16, xmm25)); + TEST_INSTRUCTION("62027D06BDC9" , k(k6).vfnmadd231ss(xmm25, xmm16, xmm25)); + TEST_INSTRUCTION("62027D86BDC9" , k(k6).z().vfnmadd231ss(xmm25, xmm16, xmm25)); + TEST_INSTRUCTION("62027D10BDC9" , rn_sae().vfnmadd231ss(xmm25, xmm16, xmm25)); + TEST_INSTRUCTION("62027D50BDC9" , ru_sae().vfnmadd231ss(xmm25, xmm16, xmm25)); + TEST_INSTRUCTION("62027D30BDC9" , rd_sae().vfnmadd231ss(xmm25, xmm16, xmm25)); + TEST_INSTRUCTION("62027D70BDC9" , rz_sae().vfnmadd231ss(xmm25, xmm16, xmm25)); + TEST_INSTRUCTION("62627D00BD09" , vfnmadd231ss(xmm25, xmm16, dword_ptr(rcx))); + TEST_INSTRUCTION("62227D00BD8CF034120000" , vfnmadd231ss(xmm25, xmm16, dword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62627D00BD4A7F" , vfnmadd231ss(xmm25, xmm16, dword_ptr(rdx, 508))); + TEST_INSTRUCTION("62627D00BD8A00020000" , vfnmadd231ss(xmm25, xmm16, dword_ptr(rdx, 512))); + TEST_INSTRUCTION("62627D00BD4A80" , vfnmadd231ss(xmm25, xmm16, dword_ptr(rdx, -512))); + TEST_INSTRUCTION("62627D00BD8AFCFDFFFF" , vfnmadd231ss(xmm25, xmm16, dword_ptr(rdx, -516))); + TEST_INSTRUCTION("6242BD489ED9" , vfnmsub132pd(zmm27, zmm8, zmm9)); + TEST_INSTRUCTION("6242BD4C9ED9" , k(k4).vfnmsub132pd(zmm27, zmm8, zmm9)); + TEST_INSTRUCTION("6242BDCC9ED9" , k(k4).z().vfnmsub132pd(zmm27, zmm8, zmm9)); + TEST_INSTRUCTION("6242BD189ED9" , rn_sae().vfnmsub132pd(zmm27, zmm8, zmm9)); + TEST_INSTRUCTION("6242BD589ED9" , ru_sae().vfnmsub132pd(zmm27, zmm8, zmm9)); + TEST_INSTRUCTION("6242BD389ED9" , rd_sae().vfnmsub132pd(zmm27, zmm8, zmm9)); + TEST_INSTRUCTION("6242BD789ED9" , rz_sae().vfnmsub132pd(zmm27, zmm8, zmm9)); + TEST_INSTRUCTION("6262BD489E19" , vfnmsub132pd(zmm27, zmm8, zmmword_ptr(rcx))); + TEST_INSTRUCTION("6222BD489E9CF034120000" , vfnmsub132pd(zmm27, zmm8, zmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("6262BD589E19" , vfnmsub132pd(zmm27, zmm8, qword_ptr(rcx)._1to8())); + TEST_INSTRUCTION("6262BD489E5A7F" , vfnmsub132pd(zmm27, zmm8, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("6262BD489E9A00200000" , vfnmsub132pd(zmm27, zmm8, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("6262BD489E5A80" , vfnmsub132pd(zmm27, zmm8, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("6262BD489E9AC0DFFFFF" , vfnmsub132pd(zmm27, zmm8, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("6262BD589E5A7F" , vfnmsub132pd(zmm27, zmm8, qword_ptr(rdx, 1016)._1to8())); + TEST_INSTRUCTION("6262BD589E9A00040000" , vfnmsub132pd(zmm27, zmm8, qword_ptr(rdx, 1024)._1to8())); + TEST_INSTRUCTION("6262BD589E5A80" , vfnmsub132pd(zmm27, zmm8, qword_ptr(rdx, -1024)._1to8())); + TEST_INSTRUCTION("6262BD589E9AF8FBFFFF" , vfnmsub132pd(zmm27, zmm8, qword_ptr(rdx, -1032)._1to8())); + TEST_INSTRUCTION("624225489ED1" , vfnmsub132ps(zmm26, zmm11, zmm9)); + TEST_INSTRUCTION("6242254C9ED1" , k(k4).vfnmsub132ps(zmm26, zmm11, zmm9)); + TEST_INSTRUCTION("624225CC9ED1" , k(k4).z().vfnmsub132ps(zmm26, zmm11, zmm9)); + TEST_INSTRUCTION("624225189ED1" , rn_sae().vfnmsub132ps(zmm26, zmm11, zmm9)); + TEST_INSTRUCTION("624225589ED1" , ru_sae().vfnmsub132ps(zmm26, zmm11, zmm9)); + TEST_INSTRUCTION("624225389ED1" , rd_sae().vfnmsub132ps(zmm26, zmm11, zmm9)); + TEST_INSTRUCTION("624225789ED1" , rz_sae().vfnmsub132ps(zmm26, zmm11, zmm9)); + TEST_INSTRUCTION("626225489E11" , vfnmsub132ps(zmm26, zmm11, zmmword_ptr(rcx))); + TEST_INSTRUCTION("622225489E94F034120000" , vfnmsub132ps(zmm26, zmm11, zmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("626225589E11" , vfnmsub132ps(zmm26, zmm11, dword_ptr(rcx)._1to16())); + TEST_INSTRUCTION("626225489E527F" , vfnmsub132ps(zmm26, zmm11, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("626225489E9200200000" , vfnmsub132ps(zmm26, zmm11, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("626225489E5280" , vfnmsub132ps(zmm26, zmm11, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("626225489E92C0DFFFFF" , vfnmsub132ps(zmm26, zmm11, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("626225589E527F" , vfnmsub132ps(zmm26, zmm11, dword_ptr(rdx, 508)._1to16())); + TEST_INSTRUCTION("626225589E9200020000" , vfnmsub132ps(zmm26, zmm11, dword_ptr(rdx, 512)._1to16())); + TEST_INSTRUCTION("626225589E5280" , vfnmsub132ps(zmm26, zmm11, dword_ptr(rdx, -512)._1to16())); + TEST_INSTRUCTION("626225589E92FCFDFFFF" , vfnmsub132ps(zmm26, zmm11, dword_ptr(rdx, -516)._1to16())); + TEST_INSTRUCTION("62B2BD089FDB" , vfnmsub132sd(xmm3, xmm8, xmm19)); + TEST_INSTRUCTION("62B2BD0B9FDB" , k(k3).vfnmsub132sd(xmm3, xmm8, xmm19)); + TEST_INSTRUCTION("62B2BD8B9FDB" , k(k3).z().vfnmsub132sd(xmm3, xmm8, xmm19)); + TEST_INSTRUCTION("62B2BD189FDB" , rn_sae().vfnmsub132sd(xmm3, xmm8, xmm19)); + TEST_INSTRUCTION("62B2BD589FDB" , ru_sae().vfnmsub132sd(xmm3, xmm8, xmm19)); + TEST_INSTRUCTION("62B2BD389FDB" , rd_sae().vfnmsub132sd(xmm3, xmm8, xmm19)); + TEST_INSTRUCTION("62B2BD789FDB" , rz_sae().vfnmsub132sd(xmm3, xmm8, xmm19)); + TEST_INSTRUCTION("C4E2B99F19" , vfnmsub132sd(xmm3, xmm8, qword_ptr(rcx))); + TEST_INSTRUCTION("C4A2B99F9CF034120000" , vfnmsub132sd(xmm3, xmm8, qword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("C4E2B99F9AF8030000" , vfnmsub132sd(xmm3, xmm8, qword_ptr(rdx, 1016))); + TEST_INSTRUCTION("C4E2B99F9A00040000" , vfnmsub132sd(xmm3, xmm8, qword_ptr(rdx, 1024))); + TEST_INSTRUCTION("C4E2B99F9A00FCFFFF" , vfnmsub132sd(xmm3, xmm8, qword_ptr(rdx, -1024))); + TEST_INSTRUCTION("C4E2B99F9AF8FBFFFF" , vfnmsub132sd(xmm3, xmm8, qword_ptr(rdx, -1032))); + TEST_INSTRUCTION("62E275009FDE" , vfnmsub132ss(xmm19, xmm17, xmm6)); + TEST_INSTRUCTION("62E275019FDE" , k(k1).vfnmsub132ss(xmm19, xmm17, xmm6)); + TEST_INSTRUCTION("62E275819FDE" , k(k1).z().vfnmsub132ss(xmm19, xmm17, xmm6)); + TEST_INSTRUCTION("62E275109FDE" , rn_sae().vfnmsub132ss(xmm19, xmm17, xmm6)); + TEST_INSTRUCTION("62E275509FDE" , ru_sae().vfnmsub132ss(xmm19, xmm17, xmm6)); + TEST_INSTRUCTION("62E275309FDE" , rd_sae().vfnmsub132ss(xmm19, xmm17, xmm6)); + TEST_INSTRUCTION("62E275709FDE" , rz_sae().vfnmsub132ss(xmm19, xmm17, xmm6)); + TEST_INSTRUCTION("62E275009F19" , vfnmsub132ss(xmm19, xmm17, dword_ptr(rcx))); + TEST_INSTRUCTION("62A275009F9CF034120000" , vfnmsub132ss(xmm19, xmm17, dword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62E275009F5A7F" , vfnmsub132ss(xmm19, xmm17, dword_ptr(rdx, 508))); + TEST_INSTRUCTION("62E275009F9A00020000" , vfnmsub132ss(xmm19, xmm17, dword_ptr(rdx, 512))); + TEST_INSTRUCTION("62E275009F5A80" , vfnmsub132ss(xmm19, xmm17, dword_ptr(rdx, -512))); + TEST_INSTRUCTION("62E275009F9AFCFDFFFF" , vfnmsub132ss(xmm19, xmm17, dword_ptr(rdx, -516))); + TEST_INSTRUCTION("62F2BD48AEFF" , vfnmsub213pd(zmm7, zmm8, zmm7)); + TEST_INSTRUCTION("62F2BD4DAEFF" , k(k5).vfnmsub213pd(zmm7, zmm8, zmm7)); + TEST_INSTRUCTION("62F2BDCDAEFF" , k(k5).z().vfnmsub213pd(zmm7, zmm8, zmm7)); + TEST_INSTRUCTION("62F2BD18AEFF" , rn_sae().vfnmsub213pd(zmm7, zmm8, zmm7)); + TEST_INSTRUCTION("62F2BD58AEFF" , ru_sae().vfnmsub213pd(zmm7, zmm8, zmm7)); + TEST_INSTRUCTION("62F2BD38AEFF" , rd_sae().vfnmsub213pd(zmm7, zmm8, zmm7)); + TEST_INSTRUCTION("62F2BD78AEFF" , rz_sae().vfnmsub213pd(zmm7, zmm8, zmm7)); + TEST_INSTRUCTION("62F2BD48AE39" , vfnmsub213pd(zmm7, zmm8, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62B2BD48AEBCF034120000" , vfnmsub213pd(zmm7, zmm8, zmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62F2BD58AE39" , vfnmsub213pd(zmm7, zmm8, qword_ptr(rcx)._1to8())); + TEST_INSTRUCTION("62F2BD48AE7A7F" , vfnmsub213pd(zmm7, zmm8, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62F2BD48AEBA00200000" , vfnmsub213pd(zmm7, zmm8, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62F2BD48AE7A80" , vfnmsub213pd(zmm7, zmm8, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62F2BD48AEBAC0DFFFFF" , vfnmsub213pd(zmm7, zmm8, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62F2BD58AE7A7F" , vfnmsub213pd(zmm7, zmm8, qword_ptr(rdx, 1016)._1to8())); + TEST_INSTRUCTION("62F2BD58AEBA00040000" , vfnmsub213pd(zmm7, zmm8, qword_ptr(rdx, 1024)._1to8())); + TEST_INSTRUCTION("62F2BD58AE7A80" , vfnmsub213pd(zmm7, zmm8, qword_ptr(rdx, -1024)._1to8())); + TEST_INSTRUCTION("62F2BD58AEBAF8FBFFFF" , vfnmsub213pd(zmm7, zmm8, qword_ptr(rdx, -1032)._1to8())); + TEST_INSTRUCTION("62423D40AEEE" , vfnmsub213ps(zmm29, zmm24, zmm14)); + TEST_INSTRUCTION("62423D47AEEE" , k(k7).vfnmsub213ps(zmm29, zmm24, zmm14)); + TEST_INSTRUCTION("62423DC7AEEE" , k(k7).z().vfnmsub213ps(zmm29, zmm24, zmm14)); + TEST_INSTRUCTION("62423D10AEEE" , rn_sae().vfnmsub213ps(zmm29, zmm24, zmm14)); + TEST_INSTRUCTION("62423D50AEEE" , ru_sae().vfnmsub213ps(zmm29, zmm24, zmm14)); + TEST_INSTRUCTION("62423D30AEEE" , rd_sae().vfnmsub213ps(zmm29, zmm24, zmm14)); + TEST_INSTRUCTION("62423D70AEEE" , rz_sae().vfnmsub213ps(zmm29, zmm24, zmm14)); + TEST_INSTRUCTION("62623D40AE29" , vfnmsub213ps(zmm29, zmm24, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62223D40AEACF034120000" , vfnmsub213ps(zmm29, zmm24, zmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62623D50AE29" , vfnmsub213ps(zmm29, zmm24, dword_ptr(rcx)._1to16())); + TEST_INSTRUCTION("62623D40AE6A7F" , vfnmsub213ps(zmm29, zmm24, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62623D40AEAA00200000" , vfnmsub213ps(zmm29, zmm24, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62623D40AE6A80" , vfnmsub213ps(zmm29, zmm24, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62623D40AEAAC0DFFFFF" , vfnmsub213ps(zmm29, zmm24, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62623D50AE6A7F" , vfnmsub213ps(zmm29, zmm24, dword_ptr(rdx, 508)._1to16())); + TEST_INSTRUCTION("62623D50AEAA00020000" , vfnmsub213ps(zmm29, zmm24, dword_ptr(rdx, 512)._1to16())); + TEST_INSTRUCTION("62623D50AE6A80" , vfnmsub213ps(zmm29, zmm24, dword_ptr(rdx, -512)._1to16())); + TEST_INSTRUCTION("62623D50AEAAFCFDFFFF" , vfnmsub213ps(zmm29, zmm24, dword_ptr(rdx, -516)._1to16())); + TEST_INSTRUCTION("6222BD08AFCF" , vfnmsub213sd(xmm25, xmm8, xmm23)); + TEST_INSTRUCTION("6222BD09AFCF" , k(k1).vfnmsub213sd(xmm25, xmm8, xmm23)); + TEST_INSTRUCTION("6222BD89AFCF" , k(k1).z().vfnmsub213sd(xmm25, xmm8, xmm23)); + TEST_INSTRUCTION("6222BD18AFCF" , rn_sae().vfnmsub213sd(xmm25, xmm8, xmm23)); + TEST_INSTRUCTION("6222BD58AFCF" , ru_sae().vfnmsub213sd(xmm25, xmm8, xmm23)); + TEST_INSTRUCTION("6222BD38AFCF" , rd_sae().vfnmsub213sd(xmm25, xmm8, xmm23)); + TEST_INSTRUCTION("6222BD78AFCF" , rz_sae().vfnmsub213sd(xmm25, xmm8, xmm23)); + TEST_INSTRUCTION("6262BD08AF09" , vfnmsub213sd(xmm25, xmm8, qword_ptr(rcx))); + TEST_INSTRUCTION("6222BD08AF8CF034120000" , vfnmsub213sd(xmm25, xmm8, qword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("6262BD08AF4A7F" , vfnmsub213sd(xmm25, xmm8, qword_ptr(rdx, 1016))); + TEST_INSTRUCTION("6262BD08AF8A00040000" , vfnmsub213sd(xmm25, xmm8, qword_ptr(rdx, 1024))); + TEST_INSTRUCTION("6262BD08AF4A80" , vfnmsub213sd(xmm25, xmm8, qword_ptr(rdx, -1024))); + TEST_INSTRUCTION("6262BD08AF8AF8FBFFFF" , vfnmsub213sd(xmm25, xmm8, qword_ptr(rdx, -1032))); + TEST_INSTRUCTION("62425D00AFC7" , vfnmsub213ss(xmm24, xmm20, xmm15)); + TEST_INSTRUCTION("62425D06AFC7" , k(k6).vfnmsub213ss(xmm24, xmm20, xmm15)); + TEST_INSTRUCTION("62425D86AFC7" , k(k6).z().vfnmsub213ss(xmm24, xmm20, xmm15)); + TEST_INSTRUCTION("62425D10AFC7" , rn_sae().vfnmsub213ss(xmm24, xmm20, xmm15)); + TEST_INSTRUCTION("62425D50AFC7" , ru_sae().vfnmsub213ss(xmm24, xmm20, xmm15)); + TEST_INSTRUCTION("62425D30AFC7" , rd_sae().vfnmsub213ss(xmm24, xmm20, xmm15)); + TEST_INSTRUCTION("62425D70AFC7" , rz_sae().vfnmsub213ss(xmm24, xmm20, xmm15)); + TEST_INSTRUCTION("62625D00AF01" , vfnmsub213ss(xmm24, xmm20, dword_ptr(rcx))); + TEST_INSTRUCTION("62225D00AF84F034120000" , vfnmsub213ss(xmm24, xmm20, dword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62625D00AF427F" , vfnmsub213ss(xmm24, xmm20, dword_ptr(rdx, 508))); + TEST_INSTRUCTION("62625D00AF8200020000" , vfnmsub213ss(xmm24, xmm20, dword_ptr(rdx, 512))); + TEST_INSTRUCTION("62625D00AF4280" , vfnmsub213ss(xmm24, xmm20, dword_ptr(rdx, -512))); + TEST_INSTRUCTION("62625D00AF82FCFDFFFF" , vfnmsub213ss(xmm24, xmm20, dword_ptr(rdx, -516))); + TEST_INSTRUCTION("62D2AD48BECC" , vfnmsub231pd(zmm1, zmm10, zmm12)); + TEST_INSTRUCTION("62D2AD4DBECC" , k(k5).vfnmsub231pd(zmm1, zmm10, zmm12)); + TEST_INSTRUCTION("62D2ADCDBECC" , k(k5).z().vfnmsub231pd(zmm1, zmm10, zmm12)); + TEST_INSTRUCTION("62D2AD18BECC" , rn_sae().vfnmsub231pd(zmm1, zmm10, zmm12)); + TEST_INSTRUCTION("62D2AD58BECC" , ru_sae().vfnmsub231pd(zmm1, zmm10, zmm12)); + TEST_INSTRUCTION("62D2AD38BECC" , rd_sae().vfnmsub231pd(zmm1, zmm10, zmm12)); + TEST_INSTRUCTION("62D2AD78BECC" , rz_sae().vfnmsub231pd(zmm1, zmm10, zmm12)); + TEST_INSTRUCTION("62F2AD48BE09" , vfnmsub231pd(zmm1, zmm10, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62B2AD48BE8CF034120000" , vfnmsub231pd(zmm1, zmm10, zmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62F2AD58BE09" , vfnmsub231pd(zmm1, zmm10, qword_ptr(rcx)._1to8())); + TEST_INSTRUCTION("62F2AD48BE4A7F" , vfnmsub231pd(zmm1, zmm10, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62F2AD48BE8A00200000" , vfnmsub231pd(zmm1, zmm10, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62F2AD48BE4A80" , vfnmsub231pd(zmm1, zmm10, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62F2AD48BE8AC0DFFFFF" , vfnmsub231pd(zmm1, zmm10, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62F2AD58BE4A7F" , vfnmsub231pd(zmm1, zmm10, qword_ptr(rdx, 1016)._1to8())); + TEST_INSTRUCTION("62F2AD58BE8A00040000" , vfnmsub231pd(zmm1, zmm10, qword_ptr(rdx, 1024)._1to8())); + TEST_INSTRUCTION("62F2AD58BE4A80" , vfnmsub231pd(zmm1, zmm10, qword_ptr(rdx, -1024)._1to8())); + TEST_INSTRUCTION("62F2AD58BE8AF8FBFFFF" , vfnmsub231pd(zmm1, zmm10, qword_ptr(rdx, -1032)._1to8())); + TEST_INSTRUCTION("62A22D40BECB" , vfnmsub231ps(zmm17, zmm26, zmm19)); + TEST_INSTRUCTION("62A22D44BECB" , k(k4).vfnmsub231ps(zmm17, zmm26, zmm19)); + TEST_INSTRUCTION("62A22DC4BECB" , k(k4).z().vfnmsub231ps(zmm17, zmm26, zmm19)); + TEST_INSTRUCTION("62A22D10BECB" , rn_sae().vfnmsub231ps(zmm17, zmm26, zmm19)); + TEST_INSTRUCTION("62A22D50BECB" , ru_sae().vfnmsub231ps(zmm17, zmm26, zmm19)); + TEST_INSTRUCTION("62A22D30BECB" , rd_sae().vfnmsub231ps(zmm17, zmm26, zmm19)); + TEST_INSTRUCTION("62A22D70BECB" , rz_sae().vfnmsub231ps(zmm17, zmm26, zmm19)); + TEST_INSTRUCTION("62E22D40BE09" , vfnmsub231ps(zmm17, zmm26, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62A22D40BE8CF034120000" , vfnmsub231ps(zmm17, zmm26, zmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62E22D50BE09" , vfnmsub231ps(zmm17, zmm26, dword_ptr(rcx)._1to16())); + TEST_INSTRUCTION("62E22D40BE4A7F" , vfnmsub231ps(zmm17, zmm26, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62E22D40BE8A00200000" , vfnmsub231ps(zmm17, zmm26, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62E22D40BE4A80" , vfnmsub231ps(zmm17, zmm26, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62E22D40BE8AC0DFFFFF" , vfnmsub231ps(zmm17, zmm26, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62E22D50BE4A7F" , vfnmsub231ps(zmm17, zmm26, dword_ptr(rdx, 508)._1to16())); + TEST_INSTRUCTION("62E22D50BE8A00020000" , vfnmsub231ps(zmm17, zmm26, dword_ptr(rdx, 512)._1to16())); + TEST_INSTRUCTION("62E22D50BE4A80" , vfnmsub231ps(zmm17, zmm26, dword_ptr(rdx, -512)._1to16())); + TEST_INSTRUCTION("62E22D50BE8AFCFDFFFF" , vfnmsub231ps(zmm17, zmm26, dword_ptr(rdx, -516)._1to16())); + TEST_INSTRUCTION("6282CD08BFDA" , vfnmsub231sd(xmm19, xmm6, xmm26)); + TEST_INSTRUCTION("6282CD0FBFDA" , k(k7).vfnmsub231sd(xmm19, xmm6, xmm26)); + TEST_INSTRUCTION("6282CD8FBFDA" , k(k7).z().vfnmsub231sd(xmm19, xmm6, xmm26)); + TEST_INSTRUCTION("6282CD18BFDA" , rn_sae().vfnmsub231sd(xmm19, xmm6, xmm26)); + TEST_INSTRUCTION("6282CD58BFDA" , ru_sae().vfnmsub231sd(xmm19, xmm6, xmm26)); + TEST_INSTRUCTION("6282CD38BFDA" , rd_sae().vfnmsub231sd(xmm19, xmm6, xmm26)); + TEST_INSTRUCTION("6282CD78BFDA" , rz_sae().vfnmsub231sd(xmm19, xmm6, xmm26)); + TEST_INSTRUCTION("62E2CD08BF19" , vfnmsub231sd(xmm19, xmm6, qword_ptr(rcx))); + TEST_INSTRUCTION("62A2CD08BF9CF034120000" , vfnmsub231sd(xmm19, xmm6, qword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62E2CD08BF5A7F" , vfnmsub231sd(xmm19, xmm6, qword_ptr(rdx, 1016))); + TEST_INSTRUCTION("62E2CD08BF9A00040000" , vfnmsub231sd(xmm19, xmm6, qword_ptr(rdx, 1024))); + TEST_INSTRUCTION("62E2CD08BF5A80" , vfnmsub231sd(xmm19, xmm6, qword_ptr(rdx, -1024))); + TEST_INSTRUCTION("62E2CD08BF9AF8FBFFFF" , vfnmsub231sd(xmm19, xmm6, qword_ptr(rdx, -1032))); + TEST_INSTRUCTION("62726D00BFE9" , vfnmsub231ss(xmm13, xmm18, xmm1)); + TEST_INSTRUCTION("62726D05BFE9" , k(k5).vfnmsub231ss(xmm13, xmm18, xmm1)); + TEST_INSTRUCTION("62726D85BFE9" , k(k5).z().vfnmsub231ss(xmm13, xmm18, xmm1)); + TEST_INSTRUCTION("62726D10BFE9" , rn_sae().vfnmsub231ss(xmm13, xmm18, xmm1)); + TEST_INSTRUCTION("62726D50BFE9" , ru_sae().vfnmsub231ss(xmm13, xmm18, xmm1)); + TEST_INSTRUCTION("62726D30BFE9" , rd_sae().vfnmsub231ss(xmm13, xmm18, xmm1)); + TEST_INSTRUCTION("62726D70BFE9" , rz_sae().vfnmsub231ss(xmm13, xmm18, xmm1)); + TEST_INSTRUCTION("62726D00BF29" , vfnmsub231ss(xmm13, xmm18, dword_ptr(rcx))); + TEST_INSTRUCTION("62326D00BFACF034120000" , vfnmsub231ss(xmm13, xmm18, dword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62726D00BF6A7F" , vfnmsub231ss(xmm13, xmm18, dword_ptr(rdx, 508))); + TEST_INSTRUCTION("62726D00BFAA00020000" , vfnmsub231ss(xmm13, xmm18, dword_ptr(rdx, 512))); + TEST_INSTRUCTION("62726D00BF6A80" , vfnmsub231ss(xmm13, xmm18, dword_ptr(rdx, -512))); + TEST_INSTRUCTION("62726D00BFAAFCFDFFFF" , vfnmsub231ss(xmm13, xmm18, dword_ptr(rdx, -516))); + TEST_INSTRUCTION("6292FD4842F1" , vgetexppd(zmm6, zmm25)); + TEST_INSTRUCTION("6292FD4B42F1" , k(k3).vgetexppd(zmm6, zmm25)); + TEST_INSTRUCTION("6292FDCB42F1" , k(k3).z().vgetexppd(zmm6, zmm25)); + TEST_INSTRUCTION("6292FD1842F1" , sae().vgetexppd(zmm6, zmm25)); + TEST_INSTRUCTION("62F2FD484231" , vgetexppd(zmm6, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62B2FD4842B4F034120000" , vgetexppd(zmm6, zmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62F2FD584231" , vgetexppd(zmm6, qword_ptr(rcx)._1to8())); + TEST_INSTRUCTION("62F2FD4842727F" , vgetexppd(zmm6, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62F2FD4842B200200000" , vgetexppd(zmm6, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62F2FD48427280" , vgetexppd(zmm6, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62F2FD4842B2C0DFFFFF" , vgetexppd(zmm6, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62F2FD5842727F" , vgetexppd(zmm6, qword_ptr(rdx, 1016)._1to8())); + TEST_INSTRUCTION("62F2FD5842B200040000" , vgetexppd(zmm6, qword_ptr(rdx, 1024)._1to8())); + TEST_INSTRUCTION("62F2FD58427280" , vgetexppd(zmm6, qword_ptr(rdx, -1024)._1to8())); + TEST_INSTRUCTION("62F2FD5842B2F8FBFFFF" , vgetexppd(zmm6, qword_ptr(rdx, -1032)._1to8())); + TEST_INSTRUCTION("62B27D4842F8" , vgetexpps(zmm7, zmm16)); + TEST_INSTRUCTION("62B27D4A42F8" , k(k2).vgetexpps(zmm7, zmm16)); + TEST_INSTRUCTION("62B27DCA42F8" , k(k2).z().vgetexpps(zmm7, zmm16)); + TEST_INSTRUCTION("62B27D1842F8" , sae().vgetexpps(zmm7, zmm16)); + TEST_INSTRUCTION("62F27D484239" , vgetexpps(zmm7, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62B27D4842BCF034120000" , vgetexpps(zmm7, zmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62F27D584239" , vgetexpps(zmm7, dword_ptr(rcx)._1to16())); + TEST_INSTRUCTION("62F27D48427A7F" , vgetexpps(zmm7, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62F27D4842BA00200000" , vgetexpps(zmm7, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62F27D48427A80" , vgetexpps(zmm7, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62F27D4842BAC0DFFFFF" , vgetexpps(zmm7, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62F27D58427A7F" , vgetexpps(zmm7, dword_ptr(rdx, 508)._1to16())); + TEST_INSTRUCTION("62F27D5842BA00020000" , vgetexpps(zmm7, dword_ptr(rdx, 512)._1to16())); + TEST_INSTRUCTION("62F27D58427A80" , vgetexpps(zmm7, dword_ptr(rdx, -512)._1to16())); + TEST_INSTRUCTION("62F27D5842BAFCFDFFFF" , vgetexpps(zmm7, dword_ptr(rdx, -516)._1to16())); + TEST_INSTRUCTION("62728D0843D5" , vgetexpsd(xmm10, xmm14, xmm5)); + TEST_INSTRUCTION("62728D0C43D5" , k(k4).vgetexpsd(xmm10, xmm14, xmm5)); + TEST_INSTRUCTION("62728D8C43D5" , k(k4).z().vgetexpsd(xmm10, xmm14, xmm5)); + TEST_INSTRUCTION("62728D1843D5" , sae().vgetexpsd(xmm10, xmm14, xmm5)); + TEST_INSTRUCTION("62728D084311" , vgetexpsd(xmm10, xmm14, qword_ptr(rcx))); + TEST_INSTRUCTION("62328D084394F034120000" , vgetexpsd(xmm10, xmm14, qword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62728D0843527F" , vgetexpsd(xmm10, xmm14, qword_ptr(rdx, 1016))); + TEST_INSTRUCTION("62728D08439200040000" , vgetexpsd(xmm10, xmm14, qword_ptr(rdx, 1024))); + TEST_INSTRUCTION("62728D08435280" , vgetexpsd(xmm10, xmm14, qword_ptr(rdx, -1024))); + TEST_INSTRUCTION("62728D084392F8FBFFFF" , vgetexpsd(xmm10, xmm14, qword_ptr(rdx, -1032))); + TEST_INSTRUCTION("62A2550043C7" , vgetexpss(xmm16, xmm21, xmm23)); + TEST_INSTRUCTION("62A2550243C7" , k(k2).vgetexpss(xmm16, xmm21, xmm23)); + TEST_INSTRUCTION("62A2558243C7" , k(k2).z().vgetexpss(xmm16, xmm21, xmm23)); + TEST_INSTRUCTION("62A2551043C7" , sae().vgetexpss(xmm16, xmm21, xmm23)); + TEST_INSTRUCTION("62E255004301" , vgetexpss(xmm16, xmm21, dword_ptr(rcx))); + TEST_INSTRUCTION("62A255004384F034120000" , vgetexpss(xmm16, xmm21, dword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62E2550043427F" , vgetexpss(xmm16, xmm21, dword_ptr(rdx, 508))); + TEST_INSTRUCTION("62E25500438200020000" , vgetexpss(xmm16, xmm21, dword_ptr(rdx, 512))); + TEST_INSTRUCTION("62E25500434280" , vgetexpss(xmm16, xmm21, dword_ptr(rdx, -512))); + TEST_INSTRUCTION("62E255004382FCFDFFFF" , vgetexpss(xmm16, xmm21, dword_ptr(rdx, -516))); + TEST_INSTRUCTION("6253FD4826CAAB" , vgetmantpd(zmm9, zmm10, 171)); + TEST_INSTRUCTION("6253FD4D26CAAB" , k(k5).vgetmantpd(zmm9, zmm10, 171)); + TEST_INSTRUCTION("6253FDCD26CAAB" , k(k5).z().vgetmantpd(zmm9, zmm10, 171)); + TEST_INSTRUCTION("6253FD1826CAAB" , sae().vgetmantpd(zmm9, zmm10, 171)); + TEST_INSTRUCTION("6253FD4826CA7B" , vgetmantpd(zmm9, zmm10, 123)); + TEST_INSTRUCTION("6253FD1826CA7B" , sae().vgetmantpd(zmm9, zmm10, 123)); + TEST_INSTRUCTION("6273FD4826097B" , vgetmantpd(zmm9, zmmword_ptr(rcx), 123)); + TEST_INSTRUCTION("6233FD48268CF0341200007B" , vgetmantpd(zmm9, zmmword_ptr(rax, r14, 3, 4660), 123)); + TEST_INSTRUCTION("6273FD5826097B" , vgetmantpd(zmm9, qword_ptr(rcx)._1to8(), 123)); + TEST_INSTRUCTION("6273FD48264A7F7B" , vgetmantpd(zmm9, zmmword_ptr(rdx, 8128), 123)); + TEST_INSTRUCTION("6273FD48268A002000007B" , vgetmantpd(zmm9, zmmword_ptr(rdx, 8192), 123)); + TEST_INSTRUCTION("6273FD48264A807B" , vgetmantpd(zmm9, zmmword_ptr(rdx, -8192), 123)); + TEST_INSTRUCTION("6273FD48268AC0DFFFFF7B" , vgetmantpd(zmm9, zmmword_ptr(rdx, -8256), 123)); + TEST_INSTRUCTION("6273FD58264A7F7B" , vgetmantpd(zmm9, qword_ptr(rdx, 1016)._1to8(), 123)); + TEST_INSTRUCTION("6273FD58268A000400007B" , vgetmantpd(zmm9, qword_ptr(rdx, 1024)._1to8(), 123)); + TEST_INSTRUCTION("6273FD58264A807B" , vgetmantpd(zmm9, qword_ptr(rdx, -1024)._1to8(), 123)); + TEST_INSTRUCTION("6273FD58268AF8FBFFFF7B" , vgetmantpd(zmm9, qword_ptr(rdx, -1032)._1to8(), 123)); + TEST_INSTRUCTION("62037D4826E9AB" , vgetmantps(zmm29, zmm25, 171)); + TEST_INSTRUCTION("62037D4B26E9AB" , k(k3).vgetmantps(zmm29, zmm25, 171)); + TEST_INSTRUCTION("62037DCB26E9AB" , k(k3).z().vgetmantps(zmm29, zmm25, 171)); + TEST_INSTRUCTION("62037D1826E9AB" , sae().vgetmantps(zmm29, zmm25, 171)); + TEST_INSTRUCTION("62037D4826E97B" , vgetmantps(zmm29, zmm25, 123)); + TEST_INSTRUCTION("62037D1826E97B" , sae().vgetmantps(zmm29, zmm25, 123)); + TEST_INSTRUCTION("62637D4826297B" , vgetmantps(zmm29, zmmword_ptr(rcx), 123)); + TEST_INSTRUCTION("62237D4826ACF0341200007B" , vgetmantps(zmm29, zmmword_ptr(rax, r14, 3, 4660), 123)); + TEST_INSTRUCTION("62637D5826297B" , vgetmantps(zmm29, dword_ptr(rcx)._1to16(), 123)); + TEST_INSTRUCTION("62637D48266A7F7B" , vgetmantps(zmm29, zmmword_ptr(rdx, 8128), 123)); + TEST_INSTRUCTION("62637D4826AA002000007B" , vgetmantps(zmm29, zmmword_ptr(rdx, 8192), 123)); + TEST_INSTRUCTION("62637D48266A807B" , vgetmantps(zmm29, zmmword_ptr(rdx, -8192), 123)); + TEST_INSTRUCTION("62637D4826AAC0DFFFFF7B" , vgetmantps(zmm29, zmmword_ptr(rdx, -8256), 123)); + TEST_INSTRUCTION("62637D58266A7F7B" , vgetmantps(zmm29, dword_ptr(rdx, 508)._1to16(), 123)); + TEST_INSTRUCTION("62637D5826AA000200007B" , vgetmantps(zmm29, dword_ptr(rdx, 512)._1to16(), 123)); + TEST_INSTRUCTION("62637D58266A807B" , vgetmantps(zmm29, dword_ptr(rdx, -512)._1to16(), 123)); + TEST_INSTRUCTION("62637D5826AAFCFDFFFF7B" , vgetmantps(zmm29, dword_ptr(rdx, -516)._1to16(), 123)); + TEST_INSTRUCTION("62A3E50827E1AB" , vgetmantsd(xmm20, xmm3, xmm17, 171)); + TEST_INSTRUCTION("62A3E50F27E1AB" , k(k7).vgetmantsd(xmm20, xmm3, xmm17, 171)); + TEST_INSTRUCTION("62A3E58F27E1AB" , k(k7).z().vgetmantsd(xmm20, xmm3, xmm17, 171)); + TEST_INSTRUCTION("62A3E51827E1AB" , sae().vgetmantsd(xmm20, xmm3, xmm17, 171)); + TEST_INSTRUCTION("62A3E50827E17B" , vgetmantsd(xmm20, xmm3, xmm17, 123)); + TEST_INSTRUCTION("62A3E51827E17B" , sae().vgetmantsd(xmm20, xmm3, xmm17, 123)); + TEST_INSTRUCTION("62E3E50827217B" , vgetmantsd(xmm20, xmm3, qword_ptr(rcx), 123)); + TEST_INSTRUCTION("62A3E50827A4F0341200007B" , vgetmantsd(xmm20, xmm3, qword_ptr(rax, r14, 3, 4660), 123)); + TEST_INSTRUCTION("62E3E50827627F7B" , vgetmantsd(xmm20, xmm3, qword_ptr(rdx, 1016), 123)); + TEST_INSTRUCTION("62E3E50827A2000400007B" , vgetmantsd(xmm20, xmm3, qword_ptr(rdx, 1024), 123)); + TEST_INSTRUCTION("62E3E5082762807B" , vgetmantsd(xmm20, xmm3, qword_ptr(rdx, -1024), 123)); + TEST_INSTRUCTION("62E3E50827A2F8FBFFFF7B" , vgetmantsd(xmm20, xmm3, qword_ptr(rdx, -1032), 123)); + TEST_INSTRUCTION("62731D0827EEAB" , vgetmantss(xmm13, xmm12, xmm6, 171)); + TEST_INSTRUCTION("62731D0A27EEAB" , k(k2).vgetmantss(xmm13, xmm12, xmm6, 171)); + TEST_INSTRUCTION("62731D8A27EEAB" , k(k2).z().vgetmantss(xmm13, xmm12, xmm6, 171)); + TEST_INSTRUCTION("62731D1827EEAB" , sae().vgetmantss(xmm13, xmm12, xmm6, 171)); + TEST_INSTRUCTION("62731D0827EE7B" , vgetmantss(xmm13, xmm12, xmm6, 123)); + TEST_INSTRUCTION("62731D1827EE7B" , sae().vgetmantss(xmm13, xmm12, xmm6, 123)); + TEST_INSTRUCTION("62731D0827297B" , vgetmantss(xmm13, xmm12, dword_ptr(rcx), 123)); + TEST_INSTRUCTION("62331D0827ACF0341200007B" , vgetmantss(xmm13, xmm12, dword_ptr(rax, r14, 3, 4660), 123)); + TEST_INSTRUCTION("62731D08276A7F7B" , vgetmantss(xmm13, xmm12, dword_ptr(rdx, 508), 123)); + TEST_INSTRUCTION("62731D0827AA000200007B" , vgetmantss(xmm13, xmm12, dword_ptr(rdx, 512), 123)); + TEST_INSTRUCTION("62731D08276A807B" , vgetmantss(xmm13, xmm12, dword_ptr(rdx, -512), 123)); + TEST_INSTRUCTION("62731D0827AAFCFDFFFF7B" , vgetmantss(xmm13, xmm12, dword_ptr(rdx, -516), 123)); + TEST_INSTRUCTION("62337D4018C6AB" , vinsertf32x4(zmm8, zmm16, xmm22, 171)); + TEST_INSTRUCTION("62337D4518C6AB" , k(k5).vinsertf32x4(zmm8, zmm16, xmm22, 171)); + TEST_INSTRUCTION("62337DC518C6AB" , k(k5).z().vinsertf32x4(zmm8, zmm16, xmm22, 171)); + TEST_INSTRUCTION("62337D4018C67B" , vinsertf32x4(zmm8, zmm16, xmm22, 123)); + TEST_INSTRUCTION("62737D4018017B" , vinsertf32x4(zmm8, zmm16, xmmword_ptr(rcx), 123)); + TEST_INSTRUCTION("62337D401884F0341200007B" , vinsertf32x4(zmm8, zmm16, xmmword_ptr(rax, r14, 3, 4660), 123)); + TEST_INSTRUCTION("62737D4018427F7B" , vinsertf32x4(zmm8, zmm16, xmmword_ptr(rdx, 2032), 123)); + TEST_INSTRUCTION("62737D401882000800007B" , vinsertf32x4(zmm8, zmm16, xmmword_ptr(rdx, 2048), 123)); + TEST_INSTRUCTION("62737D401842807B" , vinsertf32x4(zmm8, zmm16, xmmword_ptr(rdx, -2048), 123)); + TEST_INSTRUCTION("62737D401882F0F7FFFF7B" , vinsertf32x4(zmm8, zmm16, xmmword_ptr(rdx, -2064), 123)); + TEST_INSTRUCTION("62C3B5481AF4AB" , vinsertf64x4(zmm22, zmm9, ymm12, 171)); + TEST_INSTRUCTION("62C3B54E1AF4AB" , k(k6).vinsertf64x4(zmm22, zmm9, ymm12, 171)); + TEST_INSTRUCTION("62C3B5CE1AF4AB" , k(k6).z().vinsertf64x4(zmm22, zmm9, ymm12, 171)); + TEST_INSTRUCTION("62C3B5481AF47B" , vinsertf64x4(zmm22, zmm9, ymm12, 123)); + TEST_INSTRUCTION("62E3B5481A317B" , vinsertf64x4(zmm22, zmm9, ymmword_ptr(rcx), 123)); + TEST_INSTRUCTION("62A3B5481AB4F0341200007B" , vinsertf64x4(zmm22, zmm9, ymmword_ptr(rax, r14, 3, 4660), 123)); + TEST_INSTRUCTION("62E3B5481A727F7B" , vinsertf64x4(zmm22, zmm9, ymmword_ptr(rdx, 4064), 123)); + TEST_INSTRUCTION("62E3B5481AB2001000007B" , vinsertf64x4(zmm22, zmm9, ymmword_ptr(rdx, 4096), 123)); + TEST_INSTRUCTION("62E3B5481A72807B" , vinsertf64x4(zmm22, zmm9, ymmword_ptr(rdx, -4096), 123)); + TEST_INSTRUCTION("62E3B5481AB2E0EFFFFF7B" , vinsertf64x4(zmm22, zmm9, ymmword_ptr(rdx, -4128), 123)); + TEST_INSTRUCTION("62935D4838F8AB" , vinserti32x4(zmm7, zmm4, xmm24, 171)); + TEST_INSTRUCTION("62935D4F38F8AB" , k(k7).vinserti32x4(zmm7, zmm4, xmm24, 171)); + TEST_INSTRUCTION("62935DCF38F8AB" , k(k7).z().vinserti32x4(zmm7, zmm4, xmm24, 171)); + TEST_INSTRUCTION("62935D4838F87B" , vinserti32x4(zmm7, zmm4, xmm24, 123)); + TEST_INSTRUCTION("62F35D4838397B" , vinserti32x4(zmm7, zmm4, xmmword_ptr(rcx), 123)); + TEST_INSTRUCTION("62B35D4838BCF0341200007B" , vinserti32x4(zmm7, zmm4, xmmword_ptr(rax, r14, 3, 4660), 123)); + TEST_INSTRUCTION("62F35D48387A7F7B" , vinserti32x4(zmm7, zmm4, xmmword_ptr(rdx, 2032), 123)); + TEST_INSTRUCTION("62F35D4838BA000800007B" , vinserti32x4(zmm7, zmm4, xmmword_ptr(rdx, 2048), 123)); + TEST_INSTRUCTION("62F35D48387A807B" , vinserti32x4(zmm7, zmm4, xmmword_ptr(rdx, -2048), 123)); + TEST_INSTRUCTION("62F35D4838BAF0F7FFFF7B" , vinserti32x4(zmm7, zmm4, xmmword_ptr(rdx, -2064), 123)); + TEST_INSTRUCTION("62A3D5483AD7AB" , vinserti64x4(zmm18, zmm5, ymm23, 171)); + TEST_INSTRUCTION("62A3D54A3AD7AB" , k(k2).vinserti64x4(zmm18, zmm5, ymm23, 171)); + TEST_INSTRUCTION("62A3D5CA3AD7AB" , k(k2).z().vinserti64x4(zmm18, zmm5, ymm23, 171)); + TEST_INSTRUCTION("62A3D5483AD77B" , vinserti64x4(zmm18, zmm5, ymm23, 123)); + TEST_INSTRUCTION("62E3D5483A117B" , vinserti64x4(zmm18, zmm5, ymmword_ptr(rcx), 123)); + TEST_INSTRUCTION("62A3D5483A94F0341200007B" , vinserti64x4(zmm18, zmm5, ymmword_ptr(rax, r14, 3, 4660), 123)); + TEST_INSTRUCTION("62E3D5483A527F7B" , vinserti64x4(zmm18, zmm5, ymmword_ptr(rdx, 4064), 123)); + TEST_INSTRUCTION("62E3D5483A92001000007B" , vinserti64x4(zmm18, zmm5, ymmword_ptr(rdx, 4096), 123)); + TEST_INSTRUCTION("62E3D5483A52807B" , vinserti64x4(zmm18, zmm5, ymmword_ptr(rdx, -4096), 123)); + TEST_INSTRUCTION("62E3D5483A92E0EFFFFF7B" , vinserti64x4(zmm18, zmm5, ymmword_ptr(rdx, -4128), 123)); + TEST_INSTRUCTION("62034D0821C4AB" , vinsertps(xmm24, xmm6, xmm28, 171)); + TEST_INSTRUCTION("62034D0821C47B" , vinsertps(xmm24, xmm6, xmm28, 123)); + TEST_INSTRUCTION("62634D0821017B" , vinsertps(xmm24, xmm6, dword_ptr(rcx), 123)); + TEST_INSTRUCTION("62234D082184F0341200007B" , vinsertps(xmm24, xmm6, dword_ptr(rax, r14, 3, 4660), 123)); + TEST_INSTRUCTION("62634D0821427F7B" , vinsertps(xmm24, xmm6, dword_ptr(rdx, 508), 123)); + TEST_INSTRUCTION("62634D082182000200007B" , vinsertps(xmm24, xmm6, dword_ptr(rdx, 512), 123)); + TEST_INSTRUCTION("62634D082142807B" , vinsertps(xmm24, xmm6, dword_ptr(rdx, -512), 123)); + TEST_INSTRUCTION("62634D082182FCFDFFFF7B" , vinsertps(xmm24, xmm6, dword_ptr(rdx, -516), 123)); + TEST_INSTRUCTION("62319D485FCD" , vmaxpd(zmm9, zmm12, zmm21)); + TEST_INSTRUCTION("62319D4E5FCD" , k(k6).vmaxpd(zmm9, zmm12, zmm21)); + TEST_INSTRUCTION("62319DCE5FCD" , k(k6).z().vmaxpd(zmm9, zmm12, zmm21)); + TEST_INSTRUCTION("62319D185FCD" , sae().vmaxpd(zmm9, zmm12, zmm21)); + TEST_INSTRUCTION("62719D485F09" , vmaxpd(zmm9, zmm12, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62319D485F8CF034120000" , vmaxpd(zmm9, zmm12, zmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62719D585F09" , vmaxpd(zmm9, zmm12, qword_ptr(rcx)._1to8())); + TEST_INSTRUCTION("62719D485F4A7F" , vmaxpd(zmm9, zmm12, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62719D485F8A00200000" , vmaxpd(zmm9, zmm12, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62719D485F4A80" , vmaxpd(zmm9, zmm12, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62719D485F8AC0DFFFFF" , vmaxpd(zmm9, zmm12, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62719D585F4A7F" , vmaxpd(zmm9, zmm12, qword_ptr(rdx, 1016)._1to8())); + TEST_INSTRUCTION("62719D585F8A00040000" , vmaxpd(zmm9, zmm12, qword_ptr(rdx, 1024)._1to8())); + TEST_INSTRUCTION("62719D585F4A80" , vmaxpd(zmm9, zmm12, qword_ptr(rdx, -1024)._1to8())); + TEST_INSTRUCTION("62719D585F8AF8FBFFFF" , vmaxpd(zmm9, zmm12, qword_ptr(rdx, -1032)._1to8())); + TEST_INSTRUCTION("62813C405FC8" , vmaxps(zmm17, zmm24, zmm24)); + TEST_INSTRUCTION("62813C445FC8" , k(k4).vmaxps(zmm17, zmm24, zmm24)); + TEST_INSTRUCTION("62813CC45FC8" , k(k4).z().vmaxps(zmm17, zmm24, zmm24)); + TEST_INSTRUCTION("62813C105FC8" , sae().vmaxps(zmm17, zmm24, zmm24)); + TEST_INSTRUCTION("62E13C405F09" , vmaxps(zmm17, zmm24, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62A13C405F8CF034120000" , vmaxps(zmm17, zmm24, zmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62E13C505F09" , vmaxps(zmm17, zmm24, dword_ptr(rcx)._1to16())); + TEST_INSTRUCTION("62E13C405F4A7F" , vmaxps(zmm17, zmm24, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62E13C405F8A00200000" , vmaxps(zmm17, zmm24, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62E13C405F4A80" , vmaxps(zmm17, zmm24, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62E13C405F8AC0DFFFFF" , vmaxps(zmm17, zmm24, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62E13C505F4A7F" , vmaxps(zmm17, zmm24, dword_ptr(rdx, 508)._1to16())); + TEST_INSTRUCTION("62E13C505F8A00020000" , vmaxps(zmm17, zmm24, dword_ptr(rdx, 512)._1to16())); + TEST_INSTRUCTION("62E13C505F4A80" , vmaxps(zmm17, zmm24, dword_ptr(rdx, -512)._1to16())); + TEST_INSTRUCTION("62E13C505F8AFCFDFFFF" , vmaxps(zmm17, zmm24, dword_ptr(rdx, -516)._1to16())); + TEST_INSTRUCTION("62A1D7005FF8" , vmaxsd(xmm23, xmm21, xmm16)); + TEST_INSTRUCTION("62A1D7035FF8" , k(k3).vmaxsd(xmm23, xmm21, xmm16)); + TEST_INSTRUCTION("62A1D7835FF8" , k(k3).z().vmaxsd(xmm23, xmm21, xmm16)); + TEST_INSTRUCTION("62A1D7105FF8" , sae().vmaxsd(xmm23, xmm21, xmm16)); + TEST_INSTRUCTION("62E1D7005F39" , vmaxsd(xmm23, xmm21, qword_ptr(rcx))); + TEST_INSTRUCTION("62A1D7005FBCF034120000" , vmaxsd(xmm23, xmm21, qword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62E1D7005F7A7F" , vmaxsd(xmm23, xmm21, qword_ptr(rdx, 1016))); + TEST_INSTRUCTION("62E1D7005FBA00040000" , vmaxsd(xmm23, xmm21, qword_ptr(rdx, 1024))); + TEST_INSTRUCTION("62E1D7005F7A80" , vmaxsd(xmm23, xmm21, qword_ptr(rdx, -1024))); + TEST_INSTRUCTION("62E1D7005FBAF8FBFFFF" , vmaxsd(xmm23, xmm21, qword_ptr(rdx, -1032))); + TEST_INSTRUCTION("62A176005FF0" , vmaxss(xmm22, xmm17, xmm16)); + TEST_INSTRUCTION("62A176075FF0" , k(k7).vmaxss(xmm22, xmm17, xmm16)); + TEST_INSTRUCTION("62A176875FF0" , k(k7).z().vmaxss(xmm22, xmm17, xmm16)); + TEST_INSTRUCTION("62A176105FF0" , sae().vmaxss(xmm22, xmm17, xmm16)); + TEST_INSTRUCTION("62E176005F31" , vmaxss(xmm22, xmm17, dword_ptr(rcx))); + TEST_INSTRUCTION("62A176005FB4F034120000" , vmaxss(xmm22, xmm17, dword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62E176005F727F" , vmaxss(xmm22, xmm17, dword_ptr(rdx, 508))); + TEST_INSTRUCTION("62E176005FB200020000" , vmaxss(xmm22, xmm17, dword_ptr(rdx, 512))); + TEST_INSTRUCTION("62E176005F7280" , vmaxss(xmm22, xmm17, dword_ptr(rdx, -512))); + TEST_INSTRUCTION("62E176005FB2FCFDFFFF" , vmaxss(xmm22, xmm17, dword_ptr(rdx, -516))); + TEST_INSTRUCTION("6211B5405DD3" , vminpd(zmm10, zmm25, zmm27)); + TEST_INSTRUCTION("6211B5445DD3" , k(k4).vminpd(zmm10, zmm25, zmm27)); + TEST_INSTRUCTION("6211B5C45DD3" , k(k4).z().vminpd(zmm10, zmm25, zmm27)); + TEST_INSTRUCTION("6211B5105DD3" , sae().vminpd(zmm10, zmm25, zmm27)); + TEST_INSTRUCTION("6271B5405D11" , vminpd(zmm10, zmm25, zmmword_ptr(rcx))); + TEST_INSTRUCTION("6231B5405D94F034120000" , vminpd(zmm10, zmm25, zmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("6271B5505D11" , vminpd(zmm10, zmm25, qword_ptr(rcx)._1to8())); + TEST_INSTRUCTION("6271B5405D527F" , vminpd(zmm10, zmm25, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("6271B5405D9200200000" , vminpd(zmm10, zmm25, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("6271B5405D5280" , vminpd(zmm10, zmm25, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("6271B5405D92C0DFFFFF" , vminpd(zmm10, zmm25, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("6271B5505D527F" , vminpd(zmm10, zmm25, qword_ptr(rdx, 1016)._1to8())); + TEST_INSTRUCTION("6271B5505D9200040000" , vminpd(zmm10, zmm25, qword_ptr(rdx, 1024)._1to8())); + TEST_INSTRUCTION("6271B5505D5280" , vminpd(zmm10, zmm25, qword_ptr(rdx, -1024)._1to8())); + TEST_INSTRUCTION("6271B5505D92F8FBFFFF" , vminpd(zmm10, zmm25, qword_ptr(rdx, -1032)._1to8())); + TEST_INSTRUCTION("62B10C485DD8" , vminps(zmm3, zmm14, zmm16)); + TEST_INSTRUCTION("62B10C4F5DD8" , k(k7).vminps(zmm3, zmm14, zmm16)); + TEST_INSTRUCTION("62B10CCF5DD8" , k(k7).z().vminps(zmm3, zmm14, zmm16)); + TEST_INSTRUCTION("62B10C185DD8" , sae().vminps(zmm3, zmm14, zmm16)); + TEST_INSTRUCTION("62F10C485D19" , vminps(zmm3, zmm14, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62B10C485D9CF034120000" , vminps(zmm3, zmm14, zmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62F10C585D19" , vminps(zmm3, zmm14, dword_ptr(rcx)._1to16())); + TEST_INSTRUCTION("62F10C485D5A7F" , vminps(zmm3, zmm14, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62F10C485D9A00200000" , vminps(zmm3, zmm14, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62F10C485D5A80" , vminps(zmm3, zmm14, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62F10C485D9AC0DFFFFF" , vminps(zmm3, zmm14, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62F10C585D5A7F" , vminps(zmm3, zmm14, dword_ptr(rdx, 508)._1to16())); + TEST_INSTRUCTION("62F10C585D9A00020000" , vminps(zmm3, zmm14, dword_ptr(rdx, 512)._1to16())); + TEST_INSTRUCTION("62F10C585D5A80" , vminps(zmm3, zmm14, dword_ptr(rdx, -512)._1to16())); + TEST_INSTRUCTION("62F10C585D9AFCFDFFFF" , vminps(zmm3, zmm14, dword_ptr(rdx, -516)._1to16())); + TEST_INSTRUCTION("6211F7085DD4" , vminsd(xmm10, xmm1, xmm28)); + TEST_INSTRUCTION("6211F70A5DD4" , k(k2).vminsd(xmm10, xmm1, xmm28)); + TEST_INSTRUCTION("6211F78A5DD4" , k(k2).z().vminsd(xmm10, xmm1, xmm28)); + TEST_INSTRUCTION("6211F7185DD4" , sae().vminsd(xmm10, xmm1, xmm28)); + TEST_INSTRUCTION("C5735D11" , vminsd(xmm10, xmm1, qword_ptr(rcx))); + TEST_INSTRUCTION("C421735D94F034120000" , vminsd(xmm10, xmm1, qword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("C5735D92F8030000" , vminsd(xmm10, xmm1, qword_ptr(rdx, 1016))); + TEST_INSTRUCTION("C5735D9200040000" , vminsd(xmm10, xmm1, qword_ptr(rdx, 1024))); + TEST_INSTRUCTION("C5735D9200FCFFFF" , vminsd(xmm10, xmm1, qword_ptr(rdx, -1024))); + TEST_INSTRUCTION("C5735D92F8FBFFFF" , vminsd(xmm10, xmm1, qword_ptr(rdx, -1032))); + TEST_INSTRUCTION("624156085DE0" , vminss(xmm28, xmm5, xmm8)); + TEST_INSTRUCTION("6241560C5DE0" , k(k4).vminss(xmm28, xmm5, xmm8)); + TEST_INSTRUCTION("6241568C5DE0" , k(k4).z().vminss(xmm28, xmm5, xmm8)); + TEST_INSTRUCTION("624156185DE0" , sae().vminss(xmm28, xmm5, xmm8)); + TEST_INSTRUCTION("626156085D21" , vminss(xmm28, xmm5, dword_ptr(rcx))); + TEST_INSTRUCTION("622156085DA4F034120000" , vminss(xmm28, xmm5, dword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("626156085D627F" , vminss(xmm28, xmm5, dword_ptr(rdx, 508))); + TEST_INSTRUCTION("626156085DA200020000" , vminss(xmm28, xmm5, dword_ptr(rdx, 512))); + TEST_INSTRUCTION("626156085D6280" , vminss(xmm28, xmm5, dword_ptr(rdx, -512))); + TEST_INSTRUCTION("626156085DA2FCFDFFFF" , vminss(xmm28, xmm5, dword_ptr(rdx, -516))); + TEST_INSTRUCTION("62C1FD4828F9" , vmovapd(zmm23, zmm9)); + TEST_INSTRUCTION("62C1FD4D28F9" , k(k5).vmovapd(zmm23, zmm9)); + TEST_INSTRUCTION("62C1FDCD28F9" , k(k5).z().vmovapd(zmm23, zmm9)); + TEST_INSTRUCTION("62E1FD482839" , vmovapd(zmm23, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62A1FD4828BCF034120000" , vmovapd(zmm23, zmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62E1FD48287A7F" , vmovapd(zmm23, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62E1FD4828BA00200000" , vmovapd(zmm23, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62E1FD48287A80" , vmovapd(zmm23, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62E1FD4828BAC0DFFFFF" , vmovapd(zmm23, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62417C4828D3" , vmovaps(zmm26, zmm11)); + TEST_INSTRUCTION("62417C4F28D3" , k(k7).vmovaps(zmm26, zmm11)); + TEST_INSTRUCTION("62417CCF28D3" , k(k7).z().vmovaps(zmm26, zmm11)); + TEST_INSTRUCTION("62617C482811" , vmovaps(zmm26, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62217C482894F034120000" , vmovaps(zmm26, zmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62617C4828527F" , vmovaps(zmm26, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62617C48289200200000" , vmovaps(zmm26, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62617C48285280" , vmovaps(zmm26, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62617C482892C0DFFFFF" , vmovaps(zmm26, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("C5796EF0" , vmovd(xmm14, eax)); + TEST_INSTRUCTION("C5796EF5" , vmovd(xmm14, ebp)); + TEST_INSTRUCTION("C441796EF5" , vmovd(xmm14, r13d)); + TEST_INSTRUCTION("C5796E31" , vmovd(xmm14, dword_ptr(rcx))); + TEST_INSTRUCTION("C421796EB4F034120000" , vmovd(xmm14, dword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("C5796EB2FC010000" , vmovd(xmm14, dword_ptr(rdx, 508))); + TEST_INSTRUCTION("C5796EB200020000" , vmovd(xmm14, dword_ptr(rdx, 512))); + TEST_INSTRUCTION("C5796EB200FEFFFF" , vmovd(xmm14, dword_ptr(rdx, -512))); + TEST_INSTRUCTION("C5796EB2FCFDFFFF" , vmovd(xmm14, dword_ptr(rdx, -516))); + TEST_INSTRUCTION("C5797E31" , vmovd(dword_ptr(rcx), xmm14)); + TEST_INSTRUCTION("C421797EB4F034120000" , vmovd(dword_ptr(rax, r14, 3, 4660), xmm14)); + TEST_INSTRUCTION("C5797EB2FC010000" , vmovd(dword_ptr(rdx, 508), xmm14)); + TEST_INSTRUCTION("C5797EB200020000" , vmovd(dword_ptr(rdx, 512), xmm14)); + TEST_INSTRUCTION("C5797EB200FEFFFF" , vmovd(dword_ptr(rdx, -512), xmm14)); + TEST_INSTRUCTION("C5797EB2FCFDFFFF" , vmovd(dword_ptr(rdx, -516), xmm14)); + TEST_INSTRUCTION("62D1FF4812CA" , vmovddup(zmm1, zmm10)); + TEST_INSTRUCTION("62D1FF4B12CA" , k(k3).vmovddup(zmm1, zmm10)); + TEST_INSTRUCTION("62D1FFCB12CA" , k(k3).z().vmovddup(zmm1, zmm10)); + TEST_INSTRUCTION("62F1FF481209" , vmovddup(zmm1, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62B1FF48128CF034120000" , vmovddup(zmm1, zmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62F1FF48124A7F" , vmovddup(zmm1, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62F1FF48128A00200000" , vmovddup(zmm1, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62F1FF48124A80" , vmovddup(zmm1, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62F1FF48128AC0DFFFFF" , vmovddup(zmm1, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62817D486FF5" , vmovdqa32(zmm22, zmm29)); + TEST_INSTRUCTION("62817D4D6FF5" , k(k5).vmovdqa32(zmm22, zmm29)); + TEST_INSTRUCTION("62817DCD6FF5" , k(k5).z().vmovdqa32(zmm22, zmm29)); + TEST_INSTRUCTION("62E17D486F31" , vmovdqa32(zmm22, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62A17D486FB4F034120000" , vmovdqa32(zmm22, zmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62E17D486F727F" , vmovdqa32(zmm22, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62E17D486FB200200000" , vmovdqa32(zmm22, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62E17D486F7280" , vmovdqa32(zmm22, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62E17D486FB2C0DFFFFF" , vmovdqa32(zmm22, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("6271FD486FCF" , vmovdqa64(zmm9, zmm7)); + TEST_INSTRUCTION("6271FD4A6FCF" , k(k2).vmovdqa64(zmm9, zmm7)); + TEST_INSTRUCTION("6271FDCA6FCF" , k(k2).z().vmovdqa64(zmm9, zmm7)); + TEST_INSTRUCTION("6271FD486F09" , vmovdqa64(zmm9, zmmword_ptr(rcx))); + TEST_INSTRUCTION("6231FD486F8CF034120000" , vmovdqa64(zmm9, zmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("6271FD486F4A7F" , vmovdqa64(zmm9, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("6271FD486F8A00200000" , vmovdqa64(zmm9, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("6271FD486F4A80" , vmovdqa64(zmm9, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("6271FD486F8AC0DFFFFF" , vmovdqa64(zmm9, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62B17E486FEE" , vmovdqu32(zmm5, zmm22)); + TEST_INSTRUCTION("62B17E4D6FEE" , k(k5).vmovdqu32(zmm5, zmm22)); + TEST_INSTRUCTION("62B17ECD6FEE" , k(k5).z().vmovdqu32(zmm5, zmm22)); + TEST_INSTRUCTION("62F17E486F29" , vmovdqu32(zmm5, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62B17E486FACF034120000" , vmovdqu32(zmm5, zmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62F17E486F6A7F" , vmovdqu32(zmm5, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62F17E486FAA00200000" , vmovdqu32(zmm5, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62F17E486F6A80" , vmovdqu32(zmm5, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62F17E486FAAC0DFFFFF" , vmovdqu32(zmm5, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("6261FE486FE5" , vmovdqu64(zmm28, zmm5)); + TEST_INSTRUCTION("6261FE4B6FE5" , k(k3).vmovdqu64(zmm28, zmm5)); + TEST_INSTRUCTION("6261FECB6FE5" , k(k3).z().vmovdqu64(zmm28, zmm5)); + TEST_INSTRUCTION("6261FE486F21" , vmovdqu64(zmm28, zmmword_ptr(rcx))); + TEST_INSTRUCTION("6221FE486FA4F034120000" , vmovdqu64(zmm28, zmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("6261FE486F627F" , vmovdqu64(zmm28, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("6261FE486FA200200000" , vmovdqu64(zmm28, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("6261FE486F6280" , vmovdqu64(zmm28, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("6261FE486FA2C0DFFFFF" , vmovdqu64(zmm28, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62817C0012F1" , vmovhlps(xmm22, xmm16, xmm25)); + TEST_INSTRUCTION("6261F5081609" , vmovhpd(xmm25, xmm1, qword_ptr(rcx))); + TEST_INSTRUCTION("6221F508168CF034120000" , vmovhpd(xmm25, xmm1, qword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("6261F508164A7F" , vmovhpd(xmm25, xmm1, qword_ptr(rdx, 1016))); + TEST_INSTRUCTION("6261F508168A00040000" , vmovhpd(xmm25, xmm1, qword_ptr(rdx, 1024))); + TEST_INSTRUCTION("6261F508164A80" , vmovhpd(xmm25, xmm1, qword_ptr(rdx, -1024))); + TEST_INSTRUCTION("6261F508168AF8FBFFFF" , vmovhpd(xmm25, xmm1, qword_ptr(rdx, -1032))); + TEST_INSTRUCTION("C5791709" , vmovhpd(qword_ptr(rcx), xmm9)); + TEST_INSTRUCTION("C42179178CF034120000" , vmovhpd(qword_ptr(rax, r14, 3, 4660), xmm9)); + TEST_INSTRUCTION("C579178AF8030000" , vmovhpd(qword_ptr(rdx, 1016), xmm9)); + TEST_INSTRUCTION("C579178A00040000" , vmovhpd(qword_ptr(rdx, 1024), xmm9)); + TEST_INSTRUCTION("C579178A00FCFFFF" , vmovhpd(qword_ptr(rdx, -1024), xmm9)); + TEST_INSTRUCTION("C579178AF8FBFFFF" , vmovhpd(qword_ptr(rdx, -1032), xmm9)); + TEST_INSTRUCTION("626174001621" , vmovhps(xmm28, xmm17, qword_ptr(rcx))); + TEST_INSTRUCTION("6221740016A4F034120000" , vmovhps(xmm28, xmm17, qword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("6261740016627F" , vmovhps(xmm28, xmm17, qword_ptr(rdx, 1016))); + TEST_INSTRUCTION("6261740016A200040000" , vmovhps(xmm28, xmm17, qword_ptr(rdx, 1024))); + TEST_INSTRUCTION("62617400166280" , vmovhps(xmm28, xmm17, qword_ptr(rdx, -1024))); + TEST_INSTRUCTION("6261740016A2F8FBFFFF" , vmovhps(xmm28, xmm17, qword_ptr(rdx, -1032))); + TEST_INSTRUCTION("C5781729" , vmovhps(qword_ptr(rcx), xmm13)); + TEST_INSTRUCTION("C4217817ACF034120000" , vmovhps(qword_ptr(rax, r14, 3, 4660), xmm13)); + TEST_INSTRUCTION("C57817AAF8030000" , vmovhps(qword_ptr(rdx, 1016), xmm13)); + TEST_INSTRUCTION("C57817AA00040000" , vmovhps(qword_ptr(rdx, 1024), xmm13)); + TEST_INSTRUCTION("C57817AA00FCFFFF" , vmovhps(qword_ptr(rdx, -1024), xmm13)); + TEST_INSTRUCTION("C57817AAF8FBFFFF" , vmovhps(qword_ptr(rdx, -1032), xmm13)); + TEST_INSTRUCTION("C59816F6" , vmovlhps(xmm6, xmm12, xmm6)); + TEST_INSTRUCTION("62E1DD001209" , vmovlpd(xmm17, xmm20, qword_ptr(rcx))); + TEST_INSTRUCTION("62A1DD00128CF034120000" , vmovlpd(xmm17, xmm20, qword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62E1DD00124A7F" , vmovlpd(xmm17, xmm20, qword_ptr(rdx, 1016))); + TEST_INSTRUCTION("62E1DD00128A00040000" , vmovlpd(xmm17, xmm20, qword_ptr(rdx, 1024))); + TEST_INSTRUCTION("62E1DD00124A80" , vmovlpd(xmm17, xmm20, qword_ptr(rdx, -1024))); + TEST_INSTRUCTION("62E1DD00128AF8FBFFFF" , vmovlpd(xmm17, xmm20, qword_ptr(rdx, -1032))); + TEST_INSTRUCTION("C5F91339" , vmovlpd(qword_ptr(rcx), xmm7)); + TEST_INSTRUCTION("C4A17913BCF034120000" , vmovlpd(qword_ptr(rax, r14, 3, 4660), xmm7)); + TEST_INSTRUCTION("C5F913BAF8030000" , vmovlpd(qword_ptr(rdx, 1016), xmm7)); + TEST_INSTRUCTION("C5F913BA00040000" , vmovlpd(qword_ptr(rdx, 1024), xmm7)); + TEST_INSTRUCTION("C5F913BA00FCFFFF" , vmovlpd(qword_ptr(rdx, -1024), xmm7)); + TEST_INSTRUCTION("C5F913BAF8FBFFFF" , vmovlpd(qword_ptr(rdx, -1032), xmm7)); + TEST_INSTRUCTION("C5201219" , vmovlps(xmm11, xmm11, qword_ptr(rcx))); + TEST_INSTRUCTION("C42120129CF034120000" , vmovlps(xmm11, xmm11, qword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("C520129AF8030000" , vmovlps(xmm11, xmm11, qword_ptr(rdx, 1016))); + TEST_INSTRUCTION("C520129A00040000" , vmovlps(xmm11, xmm11, qword_ptr(rdx, 1024))); + TEST_INSTRUCTION("C520129A00FCFFFF" , vmovlps(xmm11, xmm11, qword_ptr(rdx, -1024))); + TEST_INSTRUCTION("C520129AF8FBFFFF" , vmovlps(xmm11, xmm11, qword_ptr(rdx, -1032))); + TEST_INSTRUCTION("62E17C081329" , vmovlps(qword_ptr(rcx), xmm21)); + TEST_INSTRUCTION("62A17C0813ACF034120000" , vmovlps(qword_ptr(rax, r14, 3, 4660), xmm21)); + TEST_INSTRUCTION("62E17C08136A7F" , vmovlps(qword_ptr(rdx, 1016), xmm21)); + TEST_INSTRUCTION("62E17C0813AA00040000" , vmovlps(qword_ptr(rdx, 1024), xmm21)); + TEST_INSTRUCTION("62E17C08136A80" , vmovlps(qword_ptr(rdx, -1024), xmm21)); + TEST_INSTRUCTION("62E17C0813AAF8FBFFFF" , vmovlps(qword_ptr(rdx, -1032), xmm21)); + TEST_INSTRUCTION("62E17D48E721" , vmovntdq(zmmword_ptr(rcx), zmm20)); + TEST_INSTRUCTION("62A17D48E7A4F034120000" , vmovntdq(zmmword_ptr(rax, r14, 3, 4660), zmm20)); + TEST_INSTRUCTION("62E17D48E7627F" , vmovntdq(zmmword_ptr(rdx, 8128), zmm20)); + TEST_INSTRUCTION("62E17D48E7A200200000" , vmovntdq(zmmword_ptr(rdx, 8192), zmm20)); + TEST_INSTRUCTION("62E17D48E76280" , vmovntdq(zmmword_ptr(rdx, -8192), zmm20)); + TEST_INSTRUCTION("62E17D48E7A2C0DFFFFF" , vmovntdq(zmmword_ptr(rdx, -8256), zmm20)); + TEST_INSTRUCTION("62727D482A11" , vmovntdqa(zmm10, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62327D482A94F034120000" , vmovntdqa(zmm10, zmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62727D482A527F" , vmovntdqa(zmm10, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62727D482A9200200000" , vmovntdqa(zmm10, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62727D482A5280" , vmovntdqa(zmm10, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62727D482A92C0DFFFFF" , vmovntdqa(zmm10, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62E1FD482B29" , vmovntpd(zmmword_ptr(rcx), zmm21)); + TEST_INSTRUCTION("62A1FD482BACF034120000" , vmovntpd(zmmword_ptr(rax, r14, 3, 4660), zmm21)); + TEST_INSTRUCTION("62E1FD482B6A7F" , vmovntpd(zmmword_ptr(rdx, 8128), zmm21)); + TEST_INSTRUCTION("62E1FD482BAA00200000" , vmovntpd(zmmword_ptr(rdx, 8192), zmm21)); + TEST_INSTRUCTION("62E1FD482B6A80" , vmovntpd(zmmword_ptr(rdx, -8192), zmm21)); + TEST_INSTRUCTION("62E1FD482BAAC0DFFFFF" , vmovntpd(zmmword_ptr(rdx, -8256), zmm21)); + TEST_INSTRUCTION("62E17C482B39" , vmovntps(zmmword_ptr(rcx), zmm23)); + TEST_INSTRUCTION("62A17C482BBCF034120000" , vmovntps(zmmword_ptr(rax, r14, 3, 4660), zmm23)); + TEST_INSTRUCTION("62E17C482B7A7F" , vmovntps(zmmword_ptr(rdx, 8128), zmm23)); + TEST_INSTRUCTION("62E17C482BBA00200000" , vmovntps(zmmword_ptr(rdx, 8192), zmm23)); + TEST_INSTRUCTION("62E17C482B7A80" , vmovntps(zmmword_ptr(rdx, -8192), zmm23)); + TEST_INSTRUCTION("62E17C482BBAC0DFFFFF" , vmovntps(zmmword_ptr(rdx, -8256), zmm23)); + TEST_INSTRUCTION("6261FD086EC0" , vmovq(xmm24, rax)); + TEST_INSTRUCTION("6241FD086EC0" , vmovq(xmm24, r8)); + TEST_INSTRUCTION("C5FB1029" , vmovsd(xmm5, qword_ptr(rcx))); + TEST_INSTRUCTION("62F1FF0B1029" , k(k3).vmovsd(xmm5, qword_ptr(rcx))); + TEST_INSTRUCTION("62F1FF8B1029" , k(k3).z().vmovsd(xmm5, qword_ptr(rcx))); + TEST_INSTRUCTION("C4A17B10ACF034120000" , vmovsd(xmm5, qword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("C5FB10AAF8030000" , vmovsd(xmm5, qword_ptr(rdx, 1016))); + TEST_INSTRUCTION("C5FB10AA00040000" , vmovsd(xmm5, qword_ptr(rdx, 1024))); + TEST_INSTRUCTION("C5FB10AA00FCFFFF" , vmovsd(xmm5, qword_ptr(rdx, -1024))); + TEST_INSTRUCTION("C5FB10AAF8FBFFFF" , vmovsd(xmm5, qword_ptr(rdx, -1032))); + TEST_INSTRUCTION("62E1FF081109" , vmovsd(qword_ptr(rcx), xmm17)); + TEST_INSTRUCTION("62E1FF0B1109" , k(k3).vmovsd(qword_ptr(rcx), xmm17)); + TEST_INSTRUCTION("62A1FF08118CF034120000" , vmovsd(qword_ptr(rax, r14, 3, 4660), xmm17)); + TEST_INSTRUCTION("62E1FF08114A7F" , vmovsd(qword_ptr(rdx, 1016), xmm17)); + TEST_INSTRUCTION("62E1FF08118A00040000" , vmovsd(qword_ptr(rdx, 1024), xmm17)); + TEST_INSTRUCTION("62E1FF08114A80" , vmovsd(qword_ptr(rdx, -1024), xmm17)); + TEST_INSTRUCTION("62E1FF08118AF8FBFFFF" , vmovsd(qword_ptr(rdx, -1032), xmm17)); + TEST_INSTRUCTION("62C1970010EC" , vmovsd(xmm21, xmm29, xmm12)); + TEST_INSTRUCTION("62C1970710EC" , k(k7).vmovsd(xmm21, xmm29, xmm12)); + TEST_INSTRUCTION("62C1978710EC" , k(k7).z().vmovsd(xmm21, xmm29, xmm12)); + TEST_INSTRUCTION("62A17E4816D4" , vmovshdup(zmm18, zmm20)); + TEST_INSTRUCTION("62A17E4D16D4" , k(k5).vmovshdup(zmm18, zmm20)); + TEST_INSTRUCTION("62A17ECD16D4" , k(k5).z().vmovshdup(zmm18, zmm20)); + TEST_INSTRUCTION("62E17E481611" , vmovshdup(zmm18, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62A17E481694F034120000" , vmovshdup(zmm18, zmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62E17E4816527F" , vmovshdup(zmm18, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62E17E48169200200000" , vmovshdup(zmm18, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62E17E48165280" , vmovshdup(zmm18, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62E17E481692C0DFFFFF" , vmovshdup(zmm18, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62717E4812CD" , vmovsldup(zmm9, zmm5)); + TEST_INSTRUCTION("62717E4F12CD" , k(k7).vmovsldup(zmm9, zmm5)); + TEST_INSTRUCTION("62717ECF12CD" , k(k7).z().vmovsldup(zmm9, zmm5)); + TEST_INSTRUCTION("62717E481209" , vmovsldup(zmm9, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62317E48128CF034120000" , vmovsldup(zmm9, zmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62717E48124A7F" , vmovsldup(zmm9, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62717E48128A00200000" , vmovsldup(zmm9, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62717E48124A80" , vmovsldup(zmm9, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62717E48128AC0DFFFFF" , vmovsldup(zmm9, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("C5FA1009" , vmovss(xmm1, dword_ptr(rcx))); + TEST_INSTRUCTION("62F17E0C1009" , k(k4).vmovss(xmm1, dword_ptr(rcx))); + TEST_INSTRUCTION("62F17E8C1009" , k(k4).z().vmovss(xmm1, dword_ptr(rcx))); + TEST_INSTRUCTION("C4A17A108CF034120000" , vmovss(xmm1, dword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("C5FA108AFC010000" , vmovss(xmm1, dword_ptr(rdx, 508))); + TEST_INSTRUCTION("C5FA108A00020000" , vmovss(xmm1, dword_ptr(rdx, 512))); + TEST_INSTRUCTION("C5FA108A00FEFFFF" , vmovss(xmm1, dword_ptr(rdx, -512))); + TEST_INSTRUCTION("C5FA108AFCFDFFFF" , vmovss(xmm1, dword_ptr(rdx, -516))); + TEST_INSTRUCTION("C57A1129" , vmovss(dword_ptr(rcx), xmm13)); + TEST_INSTRUCTION("62717E0A1129" , k(k2).vmovss(dword_ptr(rcx), xmm13)); + TEST_INSTRUCTION("C4217A11ACF034120000" , vmovss(dword_ptr(rax, r14, 3, 4660), xmm13)); + TEST_INSTRUCTION("C57A11AAFC010000" , vmovss(dword_ptr(rdx, 508), xmm13)); + TEST_INSTRUCTION("C57A11AA00020000" , vmovss(dword_ptr(rdx, 512), xmm13)); + TEST_INSTRUCTION("C57A11AA00FEFFFF" , vmovss(dword_ptr(rdx, -512), xmm13)); + TEST_INSTRUCTION("C57A11AAFCFDFFFF" , vmovss(dword_ptr(rdx, -516), xmm13)); + TEST_INSTRUCTION("62C1260010D6" , vmovss(xmm18, xmm27, xmm14)); + TEST_INSTRUCTION("62C1260210D6" , k(k2).vmovss(xmm18, xmm27, xmm14)); + TEST_INSTRUCTION("62C1268210D6" , k(k2).z().vmovss(xmm18, xmm27, xmm14)); + TEST_INSTRUCTION("62E1FD4810C6" , vmovupd(zmm16, zmm6)); + TEST_INSTRUCTION("62E1FD4A10C6" , k(k2).vmovupd(zmm16, zmm6)); + TEST_INSTRUCTION("62E1FDCA10C6" , k(k2).z().vmovupd(zmm16, zmm6)); + TEST_INSTRUCTION("62E1FD481001" , vmovupd(zmm16, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62A1FD481084F034120000" , vmovupd(zmm16, zmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62E1FD4810427F" , vmovupd(zmm16, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62E1FD48108200200000" , vmovupd(zmm16, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62E1FD48104280" , vmovupd(zmm16, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62E1FD481082C0DFFFFF" , vmovupd(zmm16, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62E17C4810F4" , vmovups(zmm22, zmm4)); + TEST_INSTRUCTION("62E17C4F10F4" , k(k7).vmovups(zmm22, zmm4)); + TEST_INSTRUCTION("62E17CCF10F4" , k(k7).z().vmovups(zmm22, zmm4)); + TEST_INSTRUCTION("62E17C481031" , vmovups(zmm22, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62A17C4810B4F034120000" , vmovups(zmm22, zmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62E17C4810727F" , vmovups(zmm22, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62E17C4810B200200000" , vmovups(zmm22, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62E17C48107280" , vmovups(zmm22, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62E17C4810B2C0DFFFFF" , vmovups(zmm22, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("6261B54059C5" , vmulpd(zmm24, zmm25, zmm5)); + TEST_INSTRUCTION("6261B54459C5" , k(k4).vmulpd(zmm24, zmm25, zmm5)); + TEST_INSTRUCTION("6261B5C459C5" , k(k4).z().vmulpd(zmm24, zmm25, zmm5)); + TEST_INSTRUCTION("6261B51059C5" , rn_sae().vmulpd(zmm24, zmm25, zmm5)); + TEST_INSTRUCTION("6261B55059C5" , ru_sae().vmulpd(zmm24, zmm25, zmm5)); + TEST_INSTRUCTION("6261B53059C5" , rd_sae().vmulpd(zmm24, zmm25, zmm5)); + TEST_INSTRUCTION("6261B57059C5" , rz_sae().vmulpd(zmm24, zmm25, zmm5)); + TEST_INSTRUCTION("6261B5405901" , vmulpd(zmm24, zmm25, zmmword_ptr(rcx))); + TEST_INSTRUCTION("6221B5405984F034120000" , vmulpd(zmm24, zmm25, zmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("6261B5505901" , vmulpd(zmm24, zmm25, qword_ptr(rcx)._1to8())); + TEST_INSTRUCTION("6261B54059427F" , vmulpd(zmm24, zmm25, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("6261B540598200200000" , vmulpd(zmm24, zmm25, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("6261B540594280" , vmulpd(zmm24, zmm25, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("6261B5405982C0DFFFFF" , vmulpd(zmm24, zmm25, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("6261B55059427F" , vmulpd(zmm24, zmm25, qword_ptr(rdx, 1016)._1to8())); + TEST_INSTRUCTION("6261B550598200040000" , vmulpd(zmm24, zmm25, qword_ptr(rdx, 1024)._1to8())); + TEST_INSTRUCTION("6261B550594280" , vmulpd(zmm24, zmm25, qword_ptr(rdx, -1024)._1to8())); + TEST_INSTRUCTION("6261B5505982F8FBFFFF" , vmulpd(zmm24, zmm25, qword_ptr(rdx, -1032)._1to8())); + TEST_INSTRUCTION("62F1244059F3" , vmulps(zmm6, zmm27, zmm3)); + TEST_INSTRUCTION("62F1244559F3" , k(k5).vmulps(zmm6, zmm27, zmm3)); + TEST_INSTRUCTION("62F124C559F3" , k(k5).z().vmulps(zmm6, zmm27, zmm3)); + TEST_INSTRUCTION("62F1241059F3" , rn_sae().vmulps(zmm6, zmm27, zmm3)); + TEST_INSTRUCTION("62F1245059F3" , ru_sae().vmulps(zmm6, zmm27, zmm3)); + TEST_INSTRUCTION("62F1243059F3" , rd_sae().vmulps(zmm6, zmm27, zmm3)); + TEST_INSTRUCTION("62F1247059F3" , rz_sae().vmulps(zmm6, zmm27, zmm3)); + TEST_INSTRUCTION("62F124405931" , vmulps(zmm6, zmm27, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62B1244059B4F034120000" , vmulps(zmm6, zmm27, zmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62F124505931" , vmulps(zmm6, zmm27, dword_ptr(rcx)._1to16())); + TEST_INSTRUCTION("62F1244059727F" , vmulps(zmm6, zmm27, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62F1244059B200200000" , vmulps(zmm6, zmm27, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62F12440597280" , vmulps(zmm6, zmm27, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62F1244059B2C0DFFFFF" , vmulps(zmm6, zmm27, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62F1245059727F" , vmulps(zmm6, zmm27, dword_ptr(rdx, 508)._1to16())); + TEST_INSTRUCTION("62F1245059B200020000" , vmulps(zmm6, zmm27, dword_ptr(rdx, 512)._1to16())); + TEST_INSTRUCTION("62F12450597280" , vmulps(zmm6, zmm27, dword_ptr(rdx, -512)._1to16())); + TEST_INSTRUCTION("62F1245059B2FCFDFFFF" , vmulps(zmm6, zmm27, dword_ptr(rdx, -516)._1to16())); + TEST_INSTRUCTION("62A1970059FE" , vmulsd(xmm23, xmm29, xmm22)); + TEST_INSTRUCTION("62A1970559FE" , k(k5).vmulsd(xmm23, xmm29, xmm22)); + TEST_INSTRUCTION("62A1978559FE" , k(k5).z().vmulsd(xmm23, xmm29, xmm22)); + TEST_INSTRUCTION("62A1971059FE" , rn_sae().vmulsd(xmm23, xmm29, xmm22)); + TEST_INSTRUCTION("62A1975059FE" , ru_sae().vmulsd(xmm23, xmm29, xmm22)); + TEST_INSTRUCTION("62A1973059FE" , rd_sae().vmulsd(xmm23, xmm29, xmm22)); + TEST_INSTRUCTION("62A1977059FE" , rz_sae().vmulsd(xmm23, xmm29, xmm22)); + TEST_INSTRUCTION("62E197005939" , vmulsd(xmm23, xmm29, qword_ptr(rcx))); + TEST_INSTRUCTION("62A1970059BCF034120000" , vmulsd(xmm23, xmm29, qword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62E19700597A7F" , vmulsd(xmm23, xmm29, qword_ptr(rdx, 1016))); + TEST_INSTRUCTION("62E1970059BA00040000" , vmulsd(xmm23, xmm29, qword_ptr(rdx, 1024))); + TEST_INSTRUCTION("62E19700597A80" , vmulsd(xmm23, xmm29, qword_ptr(rdx, -1024))); + TEST_INSTRUCTION("62E1970059BAF8FBFFFF" , vmulsd(xmm23, xmm29, qword_ptr(rdx, -1032))); + TEST_INSTRUCTION("62412E0059C8" , vmulss(xmm25, xmm26, xmm8)); + TEST_INSTRUCTION("62412E0559C8" , k(k5).vmulss(xmm25, xmm26, xmm8)); + TEST_INSTRUCTION("62412E8559C8" , k(k5).z().vmulss(xmm25, xmm26, xmm8)); + TEST_INSTRUCTION("62412E1059C8" , rn_sae().vmulss(xmm25, xmm26, xmm8)); + TEST_INSTRUCTION("62412E5059C8" , ru_sae().vmulss(xmm25, xmm26, xmm8)); + TEST_INSTRUCTION("62412E3059C8" , rd_sae().vmulss(xmm25, xmm26, xmm8)); + TEST_INSTRUCTION("62412E7059C8" , rz_sae().vmulss(xmm25, xmm26, xmm8)); + TEST_INSTRUCTION("62612E005909" , vmulss(xmm25, xmm26, dword_ptr(rcx))); + TEST_INSTRUCTION("62212E00598CF034120000" , vmulss(xmm25, xmm26, dword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62612E00594A7F" , vmulss(xmm25, xmm26, dword_ptr(rdx, 508))); + TEST_INSTRUCTION("62612E00598A00020000" , vmulss(xmm25, xmm26, dword_ptr(rdx, 512))); + TEST_INSTRUCTION("62612E00594A80" , vmulss(xmm25, xmm26, dword_ptr(rdx, -512))); + TEST_INSTRUCTION("62612E00598AFCFDFFFF" , vmulss(xmm25, xmm26, dword_ptr(rdx, -516))); + TEST_INSTRUCTION("62927D481EE5" , vpabsd(zmm4, zmm29)); + TEST_INSTRUCTION("62927D4C1EE5" , k(k4).vpabsd(zmm4, zmm29)); + TEST_INSTRUCTION("62927DCC1EE5" , k(k4).z().vpabsd(zmm4, zmm29)); + TEST_INSTRUCTION("62F27D481E21" , vpabsd(zmm4, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62B27D481EA4F034120000" , vpabsd(zmm4, zmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62F27D581E21" , vpabsd(zmm4, dword_ptr(rcx)._1to16())); + TEST_INSTRUCTION("62F27D481E627F" , vpabsd(zmm4, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62F27D481EA200200000" , vpabsd(zmm4, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62F27D481E6280" , vpabsd(zmm4, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62F27D481EA2C0DFFFFF" , vpabsd(zmm4, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62F27D581E627F" , vpabsd(zmm4, dword_ptr(rdx, 508)._1to16())); + TEST_INSTRUCTION("62F27D581EA200020000" , vpabsd(zmm4, dword_ptr(rdx, 512)._1to16())); + TEST_INSTRUCTION("62F27D581E6280" , vpabsd(zmm4, dword_ptr(rdx, -512)._1to16())); + TEST_INSTRUCTION("62F27D581EA2FCFDFFFF" , vpabsd(zmm4, dword_ptr(rdx, -516)._1to16())); + TEST_INSTRUCTION("62E2FD481FCB" , vpabsq(zmm17, zmm3)); + TEST_INSTRUCTION("62E2FD4A1FCB" , k(k2).vpabsq(zmm17, zmm3)); + TEST_INSTRUCTION("62E2FDCA1FCB" , k(k2).z().vpabsq(zmm17, zmm3)); + TEST_INSTRUCTION("62E2FD481F09" , vpabsq(zmm17, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62A2FD481F8CF034120000" , vpabsq(zmm17, zmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62E2FD581F09" , vpabsq(zmm17, qword_ptr(rcx)._1to8())); + TEST_INSTRUCTION("62E2FD481F4A7F" , vpabsq(zmm17, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62E2FD481F8A00200000" , vpabsq(zmm17, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62E2FD481F4A80" , vpabsq(zmm17, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62E2FD481F8AC0DFFFFF" , vpabsq(zmm17, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62E2FD581F4A7F" , vpabsq(zmm17, qword_ptr(rdx, 1016)._1to8())); + TEST_INSTRUCTION("62E2FD581F8A00040000" , vpabsq(zmm17, qword_ptr(rdx, 1024)._1to8())); + TEST_INSTRUCTION("62E2FD581F4A80" , vpabsq(zmm17, qword_ptr(rdx, -1024)._1to8())); + TEST_INSTRUCTION("62E2FD581F8AF8FBFFFF" , vpabsq(zmm17, qword_ptr(rdx, -1032)._1to8())); + TEST_INSTRUCTION("62513D48FED3" , vpaddd(zmm10, zmm8, zmm11)); + TEST_INSTRUCTION("62513D4FFED3" , k(k7).vpaddd(zmm10, zmm8, zmm11)); + TEST_INSTRUCTION("62513DCFFED3" , k(k7).z().vpaddd(zmm10, zmm8, zmm11)); + TEST_INSTRUCTION("62713D48FE11" , vpaddd(zmm10, zmm8, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62313D48FE94F034120000" , vpaddd(zmm10, zmm8, zmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62713D58FE11" , vpaddd(zmm10, zmm8, dword_ptr(rcx)._1to16())); + TEST_INSTRUCTION("62713D48FE527F" , vpaddd(zmm10, zmm8, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62713D48FE9200200000" , vpaddd(zmm10, zmm8, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62713D48FE5280" , vpaddd(zmm10, zmm8, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62713D48FE92C0DFFFFF" , vpaddd(zmm10, zmm8, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62713D58FE527F" , vpaddd(zmm10, zmm8, dword_ptr(rdx, 508)._1to16())); + TEST_INSTRUCTION("62713D58FE9200020000" , vpaddd(zmm10, zmm8, dword_ptr(rdx, 512)._1to16())); + TEST_INSTRUCTION("62713D58FE5280" , vpaddd(zmm10, zmm8, dword_ptr(rdx, -512)._1to16())); + TEST_INSTRUCTION("62713D58FE92FCFDFFFF" , vpaddd(zmm10, zmm8, dword_ptr(rdx, -516)._1to16())); + TEST_INSTRUCTION("6291DD48D4F2" , vpaddq(zmm6, zmm4, zmm26)); + TEST_INSTRUCTION("6291DD4BD4F2" , k(k3).vpaddq(zmm6, zmm4, zmm26)); + TEST_INSTRUCTION("6291DDCBD4F2" , k(k3).z().vpaddq(zmm6, zmm4, zmm26)); + TEST_INSTRUCTION("62F1DD48D431" , vpaddq(zmm6, zmm4, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62B1DD48D4B4F034120000" , vpaddq(zmm6, zmm4, zmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62F1DD58D431" , vpaddq(zmm6, zmm4, qword_ptr(rcx)._1to8())); + TEST_INSTRUCTION("62F1DD48D4727F" , vpaddq(zmm6, zmm4, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62F1DD48D4B200200000" , vpaddq(zmm6, zmm4, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62F1DD48D47280" , vpaddq(zmm6, zmm4, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62F1DD48D4B2C0DFFFFF" , vpaddq(zmm6, zmm4, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62F1DD58D4727F" , vpaddq(zmm6, zmm4, qword_ptr(rdx, 1016)._1to8())); + TEST_INSTRUCTION("62F1DD58D4B200040000" , vpaddq(zmm6, zmm4, qword_ptr(rdx, 1024)._1to8())); + TEST_INSTRUCTION("62F1DD58D47280" , vpaddq(zmm6, zmm4, qword_ptr(rdx, -1024)._1to8())); + TEST_INSTRUCTION("62F1DD58D4B2F8FBFFFF" , vpaddq(zmm6, zmm4, qword_ptr(rdx, -1032)._1to8())); + TEST_INSTRUCTION("62B11540DBC8" , vpandd(zmm1, zmm29, zmm16)); + TEST_INSTRUCTION("62B11542DBC8" , k(k2).vpandd(zmm1, zmm29, zmm16)); + TEST_INSTRUCTION("62B115C2DBC8" , k(k2).z().vpandd(zmm1, zmm29, zmm16)); + TEST_INSTRUCTION("62F11540DB09" , vpandd(zmm1, zmm29, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62B11540DB8CF034120000" , vpandd(zmm1, zmm29, zmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62F11550DB09" , vpandd(zmm1, zmm29, dword_ptr(rcx)._1to16())); + TEST_INSTRUCTION("62F11540DB4A7F" , vpandd(zmm1, zmm29, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62F11540DB8A00200000" , vpandd(zmm1, zmm29, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62F11540DB4A80" , vpandd(zmm1, zmm29, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62F11540DB8AC0DFFFFF" , vpandd(zmm1, zmm29, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62F11550DB4A7F" , vpandd(zmm1, zmm29, dword_ptr(rdx, 508)._1to16())); + TEST_INSTRUCTION("62F11550DB8A00020000" , vpandd(zmm1, zmm29, dword_ptr(rdx, 512)._1to16())); + TEST_INSTRUCTION("62F11550DB4A80" , vpandd(zmm1, zmm29, dword_ptr(rdx, -512)._1to16())); + TEST_INSTRUCTION("62F11550DB8AFCFDFFFF" , vpandd(zmm1, zmm29, dword_ptr(rdx, -516)._1to16())); + TEST_INSTRUCTION("62A17540DFF0" , vpandnd(zmm22, zmm17, zmm16)); + TEST_INSTRUCTION("62A17545DFF0" , k(k5).vpandnd(zmm22, zmm17, zmm16)); + TEST_INSTRUCTION("62A175C5DFF0" , k(k5).z().vpandnd(zmm22, zmm17, zmm16)); + TEST_INSTRUCTION("62E17540DF31" , vpandnd(zmm22, zmm17, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62A17540DFB4F034120000" , vpandnd(zmm22, zmm17, zmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62E17550DF31" , vpandnd(zmm22, zmm17, dword_ptr(rcx)._1to16())); + TEST_INSTRUCTION("62E17540DF727F" , vpandnd(zmm22, zmm17, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62E17540DFB200200000" , vpandnd(zmm22, zmm17, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62E17540DF7280" , vpandnd(zmm22, zmm17, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62E17540DFB2C0DFFFFF" , vpandnd(zmm22, zmm17, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62E17550DF727F" , vpandnd(zmm22, zmm17, dword_ptr(rdx, 508)._1to16())); + TEST_INSTRUCTION("62E17550DFB200020000" , vpandnd(zmm22, zmm17, dword_ptr(rdx, 512)._1to16())); + TEST_INSTRUCTION("62E17550DF7280" , vpandnd(zmm22, zmm17, dword_ptr(rdx, -512)._1to16())); + TEST_INSTRUCTION("62E17550DFB2FCFDFFFF" , vpandnd(zmm22, zmm17, dword_ptr(rdx, -516)._1to16())); + TEST_INSTRUCTION("6261DD48DFCA" , vpandnq(zmm25, zmm4, zmm2)); + TEST_INSTRUCTION("6261DD4BDFCA" , k(k3).vpandnq(zmm25, zmm4, zmm2)); + TEST_INSTRUCTION("6261DDCBDFCA" , k(k3).z().vpandnq(zmm25, zmm4, zmm2)); + TEST_INSTRUCTION("6261DD48DF09" , vpandnq(zmm25, zmm4, zmmword_ptr(rcx))); + TEST_INSTRUCTION("6221DD48DF8CF034120000" , vpandnq(zmm25, zmm4, zmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("6261DD58DF09" , vpandnq(zmm25, zmm4, qword_ptr(rcx)._1to8())); + TEST_INSTRUCTION("6261DD48DF4A7F" , vpandnq(zmm25, zmm4, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("6261DD48DF8A00200000" , vpandnq(zmm25, zmm4, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("6261DD48DF4A80" , vpandnq(zmm25, zmm4, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("6261DD48DF8AC0DFFFFF" , vpandnq(zmm25, zmm4, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("6261DD58DF4A7F" , vpandnq(zmm25, zmm4, qword_ptr(rdx, 1016)._1to8())); + TEST_INSTRUCTION("6261DD58DF8A00040000" , vpandnq(zmm25, zmm4, qword_ptr(rdx, 1024)._1to8())); + TEST_INSTRUCTION("6261DD58DF4A80" , vpandnq(zmm25, zmm4, qword_ptr(rdx, -1024)._1to8())); + TEST_INSTRUCTION("6261DD58DF8AF8FBFFFF" , vpandnq(zmm25, zmm4, qword_ptr(rdx, -1032)._1to8())); + TEST_INSTRUCTION("62419D48DBD9" , vpandq(zmm27, zmm12, zmm9)); + TEST_INSTRUCTION("62419D4ADBD9" , k(k2).vpandq(zmm27, zmm12, zmm9)); + TEST_INSTRUCTION("62419DCADBD9" , k(k2).z().vpandq(zmm27, zmm12, zmm9)); + TEST_INSTRUCTION("62619D48DB19" , vpandq(zmm27, zmm12, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62219D48DB9CF034120000" , vpandq(zmm27, zmm12, zmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62619D58DB19" , vpandq(zmm27, zmm12, qword_ptr(rcx)._1to8())); + TEST_INSTRUCTION("62619D48DB5A7F" , vpandq(zmm27, zmm12, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62619D48DB9A00200000" , vpandq(zmm27, zmm12, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62619D48DB5A80" , vpandq(zmm27, zmm12, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62619D48DB9AC0DFFFFF" , vpandq(zmm27, zmm12, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62619D58DB5A7F" , vpandq(zmm27, zmm12, qword_ptr(rdx, 1016)._1to8())); + TEST_INSTRUCTION("62619D58DB9A00040000" , vpandq(zmm27, zmm12, qword_ptr(rdx, 1024)._1to8())); + TEST_INSTRUCTION("62619D58DB5A80" , vpandq(zmm27, zmm12, qword_ptr(rdx, -1024)._1to8())); + TEST_INSTRUCTION("62619D58DB9AF8FBFFFF" , vpandq(zmm27, zmm12, qword_ptr(rdx, -1032)._1to8())); + TEST_INSTRUCTION("62C23D4064FC" , vpblendmd(zmm23, zmm24, zmm12)); + TEST_INSTRUCTION("62C23D4164FC" , k(k1).vpblendmd(zmm23, zmm24, zmm12)); + TEST_INSTRUCTION("62C23DC164FC" , k(k1).z().vpblendmd(zmm23, zmm24, zmm12)); + TEST_INSTRUCTION("62E23D406439" , vpblendmd(zmm23, zmm24, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62A23D4064BCF034120000" , vpblendmd(zmm23, zmm24, zmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62E23D506439" , vpblendmd(zmm23, zmm24, dword_ptr(rcx)._1to16())); + TEST_INSTRUCTION("62E23D40647A7F" , vpblendmd(zmm23, zmm24, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62E23D4064BA00200000" , vpblendmd(zmm23, zmm24, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62E23D40647A80" , vpblendmd(zmm23, zmm24, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62E23D4064BAC0DFFFFF" , vpblendmd(zmm23, zmm24, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62E23D50647A7F" , vpblendmd(zmm23, zmm24, dword_ptr(rdx, 508)._1to16())); + TEST_INSTRUCTION("62E23D5064BA00020000" , vpblendmd(zmm23, zmm24, dword_ptr(rdx, 512)._1to16())); + TEST_INSTRUCTION("62E23D50647A80" , vpblendmd(zmm23, zmm24, dword_ptr(rdx, -512)._1to16())); + TEST_INSTRUCTION("62E23D5064BAFCFDFFFF" , vpblendmd(zmm23, zmm24, dword_ptr(rdx, -516)._1to16())); + TEST_INSTRUCTION("62E27D485819" , vpbroadcastd(zmm19, dword_ptr(rcx))); + TEST_INSTRUCTION("62E27D4D5819" , k(k5).vpbroadcastd(zmm19, dword_ptr(rcx))); + TEST_INSTRUCTION("62E27DCD5819" , k(k5).z().vpbroadcastd(zmm19, dword_ptr(rcx))); + TEST_INSTRUCTION("62A27D48589CF034120000" , vpbroadcastd(zmm19, dword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62E27D48585A7F" , vpbroadcastd(zmm19, dword_ptr(rdx, 508))); + TEST_INSTRUCTION("62E27D48589A00020000" , vpbroadcastd(zmm19, dword_ptr(rdx, 512))); + TEST_INSTRUCTION("62E27D48585A80" , vpbroadcastd(zmm19, dword_ptr(rdx, -512))); + TEST_INSTRUCTION("62E27D48589AFCFDFFFF" , vpbroadcastd(zmm19, dword_ptr(rdx, -516))); + TEST_INSTRUCTION("62F27D4858D9" , vpbroadcastd(zmm3, xmm1)); + TEST_INSTRUCTION("62F27D4E58D9" , k(k6).vpbroadcastd(zmm3, xmm1)); + TEST_INSTRUCTION("62F27DCE58D9" , k(k6).z().vpbroadcastd(zmm3, xmm1)); + TEST_INSTRUCTION("62727D487CC0" , vpbroadcastd(zmm8, eax)); + TEST_INSTRUCTION("62727D4B7CC0" , k(k3).vpbroadcastd(zmm8, eax)); + TEST_INSTRUCTION("62727DCB7CC0" , k(k3).z().vpbroadcastd(zmm8, eax)); + TEST_INSTRUCTION("62727D487CC5" , vpbroadcastd(zmm8, ebp)); + TEST_INSTRUCTION("62527D487CC5" , vpbroadcastd(zmm8, r13d)); + TEST_INSTRUCTION("6272FD485931" , vpbroadcastq(zmm14, qword_ptr(rcx))); + TEST_INSTRUCTION("6272FD4D5931" , k(k5).vpbroadcastq(zmm14, qword_ptr(rcx))); + TEST_INSTRUCTION("6272FDCD5931" , k(k5).z().vpbroadcastq(zmm14, qword_ptr(rcx))); + TEST_INSTRUCTION("6232FD4859B4F034120000" , vpbroadcastq(zmm14, qword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("6272FD4859727F" , vpbroadcastq(zmm14, qword_ptr(rdx, 1016))); + TEST_INSTRUCTION("6272FD4859B200040000" , vpbroadcastq(zmm14, qword_ptr(rdx, 1024))); + TEST_INSTRUCTION("6272FD48597280" , vpbroadcastq(zmm14, qword_ptr(rdx, -1024))); + TEST_INSTRUCTION("6272FD4859B2F8FBFFFF" , vpbroadcastq(zmm14, qword_ptr(rdx, -1032))); + TEST_INSTRUCTION("6272FD4859C4" , vpbroadcastq(zmm8, xmm4)); + TEST_INSTRUCTION("6272FD4B59C4" , k(k3).vpbroadcastq(zmm8, xmm4)); + TEST_INSTRUCTION("6272FDCB59C4" , k(k3).z().vpbroadcastq(zmm8, xmm4)); + TEST_INSTRUCTION("62F2FD487CE8" , vpbroadcastq(zmm5, rax)); + TEST_INSTRUCTION("62F2FD4E7CE8" , k(k6).vpbroadcastq(zmm5, rax)); + TEST_INSTRUCTION("62F2FDCE7CE8" , k(k6).z().vpbroadcastq(zmm5, rax)); + TEST_INSTRUCTION("62D2FD487CE8" , vpbroadcastq(zmm5, r8)); + TEST_INSTRUCTION("62B335401FD6AB" , vpcmpd(k2, zmm25, zmm22, 171)); + TEST_INSTRUCTION("62B335431FD6AB" , k(k3).vpcmpd(k2, zmm25, zmm22, 171)); + TEST_INSTRUCTION("62B335401FD67B" , vpcmpd(k2, zmm25, zmm22, 123)); + TEST_INSTRUCTION("62F335401F117B" , vpcmpd(k2, zmm25, zmmword_ptr(rcx), 123)); + TEST_INSTRUCTION("62B335401F94F0341200007B" , vpcmpd(k2, zmm25, zmmword_ptr(rax, r14, 3, 4660), 123)); + TEST_INSTRUCTION("62F335501F117B" , vpcmpd(k2, zmm25, dword_ptr(rcx)._1to16(), 123)); + TEST_INSTRUCTION("62F335401F527F7B" , vpcmpd(k2, zmm25, zmmword_ptr(rdx, 8128), 123)); + TEST_INSTRUCTION("62F335401F92002000007B" , vpcmpd(k2, zmm25, zmmword_ptr(rdx, 8192), 123)); + TEST_INSTRUCTION("62F335401F52807B" , vpcmpd(k2, zmm25, zmmword_ptr(rdx, -8192), 123)); + TEST_INSTRUCTION("62F335401F92C0DFFFFF7B" , vpcmpd(k2, zmm25, zmmword_ptr(rdx, -8256), 123)); + TEST_INSTRUCTION("62F335501F527F7B" , vpcmpd(k2, zmm25, dword_ptr(rdx, 508)._1to16(), 123)); + TEST_INSTRUCTION("62F335501F92000200007B" , vpcmpd(k2, zmm25, dword_ptr(rdx, 512)._1to16(), 123)); + TEST_INSTRUCTION("62F335501F52807B" , vpcmpd(k2, zmm25, dword_ptr(rdx, -512)._1to16(), 123)); + TEST_INSTRUCTION("62F335501F92FCFDFFFF7B" , vpcmpd(k2, zmm25, dword_ptr(rdx, -516)._1to16(), 123)); + TEST_INSTRUCTION("62B13D4876ED" , vpcmpeqd(k5, zmm8, zmm21)); + TEST_INSTRUCTION("62B13D4C76ED" , k(k4).vpcmpeqd(k5, zmm8, zmm21)); + TEST_INSTRUCTION("62F13D487629" , vpcmpeqd(k5, zmm8, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62B13D4876ACF034120000" , vpcmpeqd(k5, zmm8, zmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62F13D587629" , vpcmpeqd(k5, zmm8, dword_ptr(rcx)._1to16())); + TEST_INSTRUCTION("62F13D48766A7F" , vpcmpeqd(k5, zmm8, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62F13D4876AA00200000" , vpcmpeqd(k5, zmm8, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62F13D48766A80" , vpcmpeqd(k5, zmm8, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62F13D4876AAC0DFFFFF" , vpcmpeqd(k5, zmm8, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62F13D58766A7F" , vpcmpeqd(k5, zmm8, dword_ptr(rdx, 508)._1to16())); + TEST_INSTRUCTION("62F13D5876AA00020000" , vpcmpeqd(k5, zmm8, dword_ptr(rdx, 512)._1to16())); + TEST_INSTRUCTION("62F13D58766A80" , vpcmpeqd(k5, zmm8, dword_ptr(rdx, -512)._1to16())); + TEST_INSTRUCTION("62F13D5876AAFCFDFFFF" , vpcmpeqd(k5, zmm8, dword_ptr(rdx, -516)._1to16())); + TEST_INSTRUCTION("62D28D4829E1" , vpcmpeqq(k4, zmm14, zmm9)); + TEST_INSTRUCTION("62D28D4E29E1" , k(k6).vpcmpeqq(k4, zmm14, zmm9)); + TEST_INSTRUCTION("62F28D482921" , vpcmpeqq(k4, zmm14, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62B28D4829A4F034120000" , vpcmpeqq(k4, zmm14, zmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62F28D582921" , vpcmpeqq(k4, zmm14, qword_ptr(rcx)._1to8())); + TEST_INSTRUCTION("62F28D4829627F" , vpcmpeqq(k4, zmm14, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62F28D4829A200200000" , vpcmpeqq(k4, zmm14, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62F28D48296280" , vpcmpeqq(k4, zmm14, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62F28D4829A2C0DFFFFF" , vpcmpeqq(k4, zmm14, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62F28D5829627F" , vpcmpeqq(k4, zmm14, qword_ptr(rdx, 1016)._1to8())); + TEST_INSTRUCTION("62F28D5829A200040000" , vpcmpeqq(k4, zmm14, qword_ptr(rdx, 1024)._1to8())); + TEST_INSTRUCTION("62F28D58296280" , vpcmpeqq(k4, zmm14, qword_ptr(rdx, -1024)._1to8())); + TEST_INSTRUCTION("62F28D5829A2F8FBFFFF" , vpcmpeqq(k4, zmm14, qword_ptr(rdx, -1032)._1to8())); + TEST_INSTRUCTION("62D13D4866E0" , vpcmpgtd(k4, zmm8, zmm8)); + TEST_INSTRUCTION("62D13D4F66E0" , k(k7).vpcmpgtd(k4, zmm8, zmm8)); + TEST_INSTRUCTION("62F13D486621" , vpcmpgtd(k4, zmm8, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62B13D4866A4F034120000" , vpcmpgtd(k4, zmm8, zmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62F13D586621" , vpcmpgtd(k4, zmm8, dword_ptr(rcx)._1to16())); + TEST_INSTRUCTION("62F13D4866627F" , vpcmpgtd(k4, zmm8, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62F13D4866A200200000" , vpcmpgtd(k4, zmm8, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62F13D48666280" , vpcmpgtd(k4, zmm8, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62F13D4866A2C0DFFFFF" , vpcmpgtd(k4, zmm8, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62F13D5866627F" , vpcmpgtd(k4, zmm8, dword_ptr(rdx, 508)._1to16())); + TEST_INSTRUCTION("62F13D5866A200020000" , vpcmpgtd(k4, zmm8, dword_ptr(rdx, 512)._1to16())); + TEST_INSTRUCTION("62F13D58666280" , vpcmpgtd(k4, zmm8, dword_ptr(rdx, -512)._1to16())); + TEST_INSTRUCTION("62F13D5866A2FCFDFFFF" , vpcmpgtd(k4, zmm8, dword_ptr(rdx, -516)._1to16())); + TEST_INSTRUCTION("62929D4837DA" , vpcmpgtq(k3, zmm12, zmm26)); + TEST_INSTRUCTION("62929D4C37DA" , k(k4).vpcmpgtq(k3, zmm12, zmm26)); + TEST_INSTRUCTION("62F29D483719" , vpcmpgtq(k3, zmm12, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62B29D48379CF034120000" , vpcmpgtq(k3, zmm12, zmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62F29D583719" , vpcmpgtq(k3, zmm12, qword_ptr(rcx)._1to8())); + TEST_INSTRUCTION("62F29D48375A7F" , vpcmpgtq(k3, zmm12, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62F29D48379A00200000" , vpcmpgtq(k3, zmm12, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62F29D48375A80" , vpcmpgtq(k3, zmm12, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62F29D48379AC0DFFFFF" , vpcmpgtq(k3, zmm12, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62F29D58375A7F" , vpcmpgtq(k3, zmm12, qword_ptr(rdx, 1016)._1to8())); + TEST_INSTRUCTION("62F29D58379A00040000" , vpcmpgtq(k3, zmm12, qword_ptr(rdx, 1024)._1to8())); + TEST_INSTRUCTION("62F29D58375A80" , vpcmpgtq(k3, zmm12, qword_ptr(rdx, -1024)._1to8())); + TEST_INSTRUCTION("62F29D58379AF8FBFFFF" , vpcmpgtq(k3, zmm12, qword_ptr(rdx, -1032)._1to8())); + TEST_INSTRUCTION("62D3B5401FDFAB" , vpcmpq(k3, zmm25, zmm15, 171)); + TEST_INSTRUCTION("62D3B5441FDFAB" , k(k4).vpcmpq(k3, zmm25, zmm15, 171)); + TEST_INSTRUCTION("62D3B5401FDF7B" , vpcmpq(k3, zmm25, zmm15, 123)); + TEST_INSTRUCTION("62F3B5401F197B" , vpcmpq(k3, zmm25, zmmword_ptr(rcx), 123)); + TEST_INSTRUCTION("62B3B5401F9CF0341200007B" , vpcmpq(k3, zmm25, zmmword_ptr(rax, r14, 3, 4660), 123)); + TEST_INSTRUCTION("62F3B5501F197B" , vpcmpq(k3, zmm25, qword_ptr(rcx)._1to8(), 123)); + TEST_INSTRUCTION("62F3B5401F5A7F7B" , vpcmpq(k3, zmm25, zmmword_ptr(rdx, 8128), 123)); + TEST_INSTRUCTION("62F3B5401F9A002000007B" , vpcmpq(k3, zmm25, zmmword_ptr(rdx, 8192), 123)); + TEST_INSTRUCTION("62F3B5401F5A807B" , vpcmpq(k3, zmm25, zmmword_ptr(rdx, -8192), 123)); + TEST_INSTRUCTION("62F3B5401F9AC0DFFFFF7B" , vpcmpq(k3, zmm25, zmmword_ptr(rdx, -8256), 123)); + TEST_INSTRUCTION("62F3B5501F5A7F7B" , vpcmpq(k3, zmm25, qword_ptr(rdx, 1016)._1to8(), 123)); + TEST_INSTRUCTION("62F3B5501F9A000400007B" , vpcmpq(k3, zmm25, qword_ptr(rdx, 1024)._1to8(), 123)); + TEST_INSTRUCTION("62F3B5501F5A807B" , vpcmpq(k3, zmm25, qword_ptr(rdx, -1024)._1to8(), 123)); + TEST_INSTRUCTION("62F3B5501F9AF8FBFFFF7B" , vpcmpq(k3, zmm25, qword_ptr(rdx, -1032)._1to8(), 123)); + TEST_INSTRUCTION("62F315401EDDAB" , vpcmpud(k3, zmm29, zmm5, 171)); + TEST_INSTRUCTION("62F315471EDDAB" , k(k7).vpcmpud(k3, zmm29, zmm5, 171)); + TEST_INSTRUCTION("62F315401EDD7B" , vpcmpud(k3, zmm29, zmm5, 123)); + TEST_INSTRUCTION("62F315401E197B" , vpcmpud(k3, zmm29, zmmword_ptr(rcx), 123)); + TEST_INSTRUCTION("62B315401E9CF0341200007B" , vpcmpud(k3, zmm29, zmmword_ptr(rax, r14, 3, 4660), 123)); + TEST_INSTRUCTION("62F315501E197B" , vpcmpud(k3, zmm29, dword_ptr(rcx)._1to16(), 123)); + TEST_INSTRUCTION("62F315401E5A7F7B" , vpcmpud(k3, zmm29, zmmword_ptr(rdx, 8128), 123)); + TEST_INSTRUCTION("62F315401E9A002000007B" , vpcmpud(k3, zmm29, zmmword_ptr(rdx, 8192), 123)); + TEST_INSTRUCTION("62F315401E5A807B" , vpcmpud(k3, zmm29, zmmword_ptr(rdx, -8192), 123)); + TEST_INSTRUCTION("62F315401E9AC0DFFFFF7B" , vpcmpud(k3, zmm29, zmmword_ptr(rdx, -8256), 123)); + TEST_INSTRUCTION("62F315501E5A7F7B" , vpcmpud(k3, zmm29, dword_ptr(rdx, 508)._1to16(), 123)); + TEST_INSTRUCTION("62F315501E9A000200007B" , vpcmpud(k3, zmm29, dword_ptr(rdx, 512)._1to16(), 123)); + TEST_INSTRUCTION("62F315501E5A807B" , vpcmpud(k3, zmm29, dword_ptr(rdx, -512)._1to16(), 123)); + TEST_INSTRUCTION("62F315501E9AFCFDFFFF7B" , vpcmpud(k3, zmm29, dword_ptr(rdx, -516)._1to16(), 123)); + TEST_INSTRUCTION("62D38D481ED4AB" , vpcmpuq(k2, zmm14, zmm12, 171)); + TEST_INSTRUCTION("62D38D4B1ED4AB" , k(k3).vpcmpuq(k2, zmm14, zmm12, 171)); + TEST_INSTRUCTION("62D38D481ED47B" , vpcmpuq(k2, zmm14, zmm12, 123)); + TEST_INSTRUCTION("62F38D481E117B" , vpcmpuq(k2, zmm14, zmmword_ptr(rcx), 123)); + TEST_INSTRUCTION("62B38D481E94F0341200007B" , vpcmpuq(k2, zmm14, zmmword_ptr(rax, r14, 3, 4660), 123)); + TEST_INSTRUCTION("62F38D581E117B" , vpcmpuq(k2, zmm14, qword_ptr(rcx)._1to8(), 123)); + TEST_INSTRUCTION("62F38D481E527F7B" , vpcmpuq(k2, zmm14, zmmword_ptr(rdx, 8128), 123)); + TEST_INSTRUCTION("62F38D481E92002000007B" , vpcmpuq(k2, zmm14, zmmword_ptr(rdx, 8192), 123)); + TEST_INSTRUCTION("62F38D481E52807B" , vpcmpuq(k2, zmm14, zmmword_ptr(rdx, -8192), 123)); + TEST_INSTRUCTION("62F38D481E92C0DFFFFF7B" , vpcmpuq(k2, zmm14, zmmword_ptr(rdx, -8256), 123)); + TEST_INSTRUCTION("62F38D581E527F7B" , vpcmpuq(k2, zmm14, qword_ptr(rdx, 1016)._1to8(), 123)); + TEST_INSTRUCTION("62F38D581E92000400007B" , vpcmpuq(k2, zmm14, qword_ptr(rdx, 1024)._1to8(), 123)); + TEST_INSTRUCTION("62F38D581E52807B" , vpcmpuq(k2, zmm14, qword_ptr(rdx, -1024)._1to8(), 123)); + TEST_INSTRUCTION("62F38D581E92F8FBFFFF7B" , vpcmpuq(k2, zmm14, qword_ptr(rdx, -1032)._1to8(), 123)); + TEST_INSTRUCTION("6262ED4064C5" , vpblendmq(zmm24, zmm18, zmm5)); + TEST_INSTRUCTION("6262ED4364C5" , k(k3).vpblendmq(zmm24, zmm18, zmm5)); + TEST_INSTRUCTION("6262EDC364C5" , k(k3).z().vpblendmq(zmm24, zmm18, zmm5)); + TEST_INSTRUCTION("6262ED406401" , vpblendmq(zmm24, zmm18, zmmword_ptr(rcx))); + TEST_INSTRUCTION("6222ED406484F034120000" , vpblendmq(zmm24, zmm18, zmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("6262ED506401" , vpblendmq(zmm24, zmm18, qword_ptr(rcx)._1to8())); + TEST_INSTRUCTION("6262ED4064427F" , vpblendmq(zmm24, zmm18, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("6262ED40648200200000" , vpblendmq(zmm24, zmm18, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("6262ED40644280" , vpblendmq(zmm24, zmm18, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("6262ED406482C0DFFFFF" , vpblendmq(zmm24, zmm18, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("6262ED5064427F" , vpblendmq(zmm24, zmm18, qword_ptr(rdx, 1016)._1to8())); + TEST_INSTRUCTION("6262ED50648200040000" , vpblendmq(zmm24, zmm18, qword_ptr(rdx, 1024)._1to8())); + TEST_INSTRUCTION("6262ED50644280" , vpblendmq(zmm24, zmm18, qword_ptr(rdx, -1024)._1to8())); + TEST_INSTRUCTION("6262ED506482F8FBFFFF" , vpblendmq(zmm24, zmm18, qword_ptr(rdx, -1032)._1to8())); + TEST_INSTRUCTION("62E27D488B21" , vpcompressd(zmmword_ptr(rcx), zmm20)); + TEST_INSTRUCTION("62E27D4E8B21" , k(k6).vpcompressd(zmmword_ptr(rcx), zmm20)); + TEST_INSTRUCTION("62A27D488BA4F034120000" , vpcompressd(zmmword_ptr(rax, r14, 3, 4660), zmm20)); + TEST_INSTRUCTION("62E27D488B627F" , vpcompressd(zmmword_ptr(rdx, 508), zmm20)); + TEST_INSTRUCTION("62E27D488BA200020000" , vpcompressd(zmmword_ptr(rdx, 512), zmm20)); + TEST_INSTRUCTION("62E27D488B6280" , vpcompressd(zmmword_ptr(rdx, -512), zmm20)); + TEST_INSTRUCTION("62E27D488BA2FCFDFFFF" , vpcompressd(zmmword_ptr(rdx, -516), zmm20)); + TEST_INSTRUCTION("62127D488BE0" , vpcompressd(zmm24, zmm12)); + TEST_INSTRUCTION("62127D4D8BE0" , k(k5).vpcompressd(zmm24, zmm12)); + TEST_INSTRUCTION("62127DCD8BE0" , k(k5).z().vpcompressd(zmm24, zmm12)); + TEST_INSTRUCTION("62422D4836C8" , vpermd(zmm25, zmm10, zmm8)); + TEST_INSTRUCTION("62422D4E36C8" , k(k6).vpermd(zmm25, zmm10, zmm8)); + TEST_INSTRUCTION("62422DCE36C8" , k(k6).z().vpermd(zmm25, zmm10, zmm8)); + TEST_INSTRUCTION("62622D483609" , vpermd(zmm25, zmm10, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62222D48368CF034120000" , vpermd(zmm25, zmm10, zmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62622D583609" , vpermd(zmm25, zmm10, dword_ptr(rcx)._1to16())); + TEST_INSTRUCTION("62622D48364A7F" , vpermd(zmm25, zmm10, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62622D48368A00200000" , vpermd(zmm25, zmm10, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62622D48364A80" , vpermd(zmm25, zmm10, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62622D48368AC0DFFFFF" , vpermd(zmm25, zmm10, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62622D58364A7F" , vpermd(zmm25, zmm10, dword_ptr(rdx, 508)._1to16())); + TEST_INSTRUCTION("62622D58368A00020000" , vpermd(zmm25, zmm10, dword_ptr(rdx, 512)._1to16())); + TEST_INSTRUCTION("62622D58364A80" , vpermd(zmm25, zmm10, dword_ptr(rdx, -512)._1to16())); + TEST_INSTRUCTION("62622D58368AFCFDFFFF" , vpermd(zmm25, zmm10, dword_ptr(rdx, -516)._1to16())); + TEST_INSTRUCTION("6253FD4805F8AB" , vpermilpd(zmm15, zmm8, 171)); + TEST_INSTRUCTION("6253FD4E05F8AB" , k(k6).vpermilpd(zmm15, zmm8, 171)); + TEST_INSTRUCTION("6253FDCE05F8AB" , k(k6).z().vpermilpd(zmm15, zmm8, 171)); + TEST_INSTRUCTION("6253FD4805F87B" , vpermilpd(zmm15, zmm8, 123)); + TEST_INSTRUCTION("6273FD4805397B" , vpermilpd(zmm15, zmmword_ptr(rcx), 123)); + TEST_INSTRUCTION("6233FD4805BCF0341200007B" , vpermilpd(zmm15, zmmword_ptr(rax, r14, 3, 4660), 123)); + TEST_INSTRUCTION("6273FD5805397B" , vpermilpd(zmm15, qword_ptr(rcx)._1to8(), 123)); + TEST_INSTRUCTION("6273FD48057A7F7B" , vpermilpd(zmm15, zmmword_ptr(rdx, 8128), 123)); + TEST_INSTRUCTION("6273FD4805BA002000007B" , vpermilpd(zmm15, zmmword_ptr(rdx, 8192), 123)); + TEST_INSTRUCTION("6273FD48057A807B" , vpermilpd(zmm15, zmmword_ptr(rdx, -8192), 123)); + TEST_INSTRUCTION("6273FD4805BAC0DFFFFF7B" , vpermilpd(zmm15, zmmword_ptr(rdx, -8256), 123)); + TEST_INSTRUCTION("6273FD58057A7F7B" , vpermilpd(zmm15, qword_ptr(rdx, 1016)._1to8(), 123)); + TEST_INSTRUCTION("6273FD5805BA000400007B" , vpermilpd(zmm15, qword_ptr(rdx, 1024)._1to8(), 123)); + TEST_INSTRUCTION("6273FD58057A807B" , vpermilpd(zmm15, qword_ptr(rdx, -1024)._1to8(), 123)); + TEST_INSTRUCTION("6273FD5805BAF8FBFFFF7B" , vpermilpd(zmm15, qword_ptr(rdx, -1032)._1to8(), 123)); + TEST_INSTRUCTION("62C2AD400DF8" , vpermilpd(zmm23, zmm26, zmm8)); + TEST_INSTRUCTION("62C2AD410DF8" , k(k1).vpermilpd(zmm23, zmm26, zmm8)); + TEST_INSTRUCTION("62C2ADC10DF8" , k(k1).z().vpermilpd(zmm23, zmm26, zmm8)); + TEST_INSTRUCTION("62E2AD400D39" , vpermilpd(zmm23, zmm26, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62A2AD400DBCF034120000" , vpermilpd(zmm23, zmm26, zmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62E2AD500D39" , vpermilpd(zmm23, zmm26, qword_ptr(rcx)._1to8())); + TEST_INSTRUCTION("62E2AD400D7A7F" , vpermilpd(zmm23, zmm26, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62E2AD400DBA00200000" , vpermilpd(zmm23, zmm26, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62E2AD400D7A80" , vpermilpd(zmm23, zmm26, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62E2AD400DBAC0DFFFFF" , vpermilpd(zmm23, zmm26, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62E2AD500D7A7F" , vpermilpd(zmm23, zmm26, qword_ptr(rdx, 1016)._1to8())); + TEST_INSTRUCTION("62E2AD500DBA00040000" , vpermilpd(zmm23, zmm26, qword_ptr(rdx, 1024)._1to8())); + TEST_INSTRUCTION("62E2AD500D7A80" , vpermilpd(zmm23, zmm26, qword_ptr(rdx, -1024)._1to8())); + TEST_INSTRUCTION("62E2AD500DBAF8FBFFFF" , vpermilpd(zmm23, zmm26, qword_ptr(rdx, -1032)._1to8())); + TEST_INSTRUCTION("62637D4804CFAB" , vpermilps(zmm25, zmm7, 171)); + TEST_INSTRUCTION("62637D4A04CFAB" , k(k2).vpermilps(zmm25, zmm7, 171)); + TEST_INSTRUCTION("62637DCA04CFAB" , k(k2).z().vpermilps(zmm25, zmm7, 171)); + TEST_INSTRUCTION("62637D4804CF7B" , vpermilps(zmm25, zmm7, 123)); + TEST_INSTRUCTION("62637D4804097B" , vpermilps(zmm25, zmmword_ptr(rcx), 123)); + TEST_INSTRUCTION("62237D48048CF0341200007B" , vpermilps(zmm25, zmmword_ptr(rax, r14, 3, 4660), 123)); + TEST_INSTRUCTION("62637D5804097B" , vpermilps(zmm25, dword_ptr(rcx)._1to16(), 123)); + TEST_INSTRUCTION("62637D48044A7F7B" , vpermilps(zmm25, zmmword_ptr(rdx, 8128), 123)); + TEST_INSTRUCTION("62637D48048A002000007B" , vpermilps(zmm25, zmmword_ptr(rdx, 8192), 123)); + TEST_INSTRUCTION("62637D48044A807B" , vpermilps(zmm25, zmmword_ptr(rdx, -8192), 123)); + TEST_INSTRUCTION("62637D48048AC0DFFFFF7B" , vpermilps(zmm25, zmmword_ptr(rdx, -8256), 123)); + TEST_INSTRUCTION("62637D58044A7F7B" , vpermilps(zmm25, dword_ptr(rdx, 508)._1to16(), 123)); + TEST_INSTRUCTION("62637D58048A000200007B" , vpermilps(zmm25, dword_ptr(rdx, 512)._1to16(), 123)); + TEST_INSTRUCTION("62637D58044A807B" , vpermilps(zmm25, dword_ptr(rdx, -512)._1to16(), 123)); + TEST_INSTRUCTION("62637D58048AFCFDFFFF7B" , vpermilps(zmm25, dword_ptr(rdx, -516)._1to16(), 123)); + TEST_INSTRUCTION("62B22D400CD9" , vpermilps(zmm3, zmm26, zmm17)); + TEST_INSTRUCTION("62B22D430CD9" , k(k3).vpermilps(zmm3, zmm26, zmm17)); + TEST_INSTRUCTION("62B22DC30CD9" , k(k3).z().vpermilps(zmm3, zmm26, zmm17)); + TEST_INSTRUCTION("62F22D400C19" , vpermilps(zmm3, zmm26, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62B22D400C9CF034120000" , vpermilps(zmm3, zmm26, zmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62F22D500C19" , vpermilps(zmm3, zmm26, dword_ptr(rcx)._1to16())); + TEST_INSTRUCTION("62F22D400C5A7F" , vpermilps(zmm3, zmm26, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62F22D400C9A00200000" , vpermilps(zmm3, zmm26, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62F22D400C5A80" , vpermilps(zmm3, zmm26, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62F22D400C9AC0DFFFFF" , vpermilps(zmm3, zmm26, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62F22D500C5A7F" , vpermilps(zmm3, zmm26, dword_ptr(rdx, 508)._1to16())); + TEST_INSTRUCTION("62F22D500C9A00020000" , vpermilps(zmm3, zmm26, dword_ptr(rdx, 512)._1to16())); + TEST_INSTRUCTION("62F22D500C5A80" , vpermilps(zmm3, zmm26, dword_ptr(rdx, -512)._1to16())); + TEST_INSTRUCTION("62F22D500C9AFCFDFFFF" , vpermilps(zmm3, zmm26, dword_ptr(rdx, -516)._1to16())); + TEST_INSTRUCTION("6243FD4801E7AB" , vpermpd(zmm28, zmm15, 171)); + TEST_INSTRUCTION("6243FD4C01E7AB" , k(k4).vpermpd(zmm28, zmm15, 171)); + TEST_INSTRUCTION("6243FDCC01E7AB" , k(k4).z().vpermpd(zmm28, zmm15, 171)); + TEST_INSTRUCTION("6243FD4801E77B" , vpermpd(zmm28, zmm15, 123)); + TEST_INSTRUCTION("6263FD4801217B" , vpermpd(zmm28, zmmword_ptr(rcx), 123)); + TEST_INSTRUCTION("6223FD4801A4F0341200007B" , vpermpd(zmm28, zmmword_ptr(rax, r14, 3, 4660), 123)); + TEST_INSTRUCTION("6263FD5801217B" , vpermpd(zmm28, qword_ptr(rcx)._1to8(), 123)); + TEST_INSTRUCTION("6263FD4801627F7B" , vpermpd(zmm28, zmmword_ptr(rdx, 8128), 123)); + TEST_INSTRUCTION("6263FD4801A2002000007B" , vpermpd(zmm28, zmmword_ptr(rdx, 8192), 123)); + TEST_INSTRUCTION("6263FD480162807B" , vpermpd(zmm28, zmmword_ptr(rdx, -8192), 123)); + TEST_INSTRUCTION("6263FD4801A2C0DFFFFF7B" , vpermpd(zmm28, zmmword_ptr(rdx, -8256), 123)); + TEST_INSTRUCTION("6263FD5801627F7B" , vpermpd(zmm28, qword_ptr(rdx, 1016)._1to8(), 123)); + TEST_INSTRUCTION("6263FD5801A2000400007B" , vpermpd(zmm28, qword_ptr(rdx, 1024)._1to8(), 123)); + TEST_INSTRUCTION("6263FD580162807B" , vpermpd(zmm28, qword_ptr(rdx, -1024)._1to8(), 123)); + TEST_INSTRUCTION("6263FD5801A2F8FBFFFF7B" , vpermpd(zmm28, qword_ptr(rdx, -1032)._1to8(), 123)); + TEST_INSTRUCTION("62A24D4816F5" , vpermps(zmm22, zmm6, zmm21)); + TEST_INSTRUCTION("62A24D4D16F5" , k(k5).vpermps(zmm22, zmm6, zmm21)); + TEST_INSTRUCTION("62A24DCD16F5" , k(k5).z().vpermps(zmm22, zmm6, zmm21)); + TEST_INSTRUCTION("62E24D481631" , vpermps(zmm22, zmm6, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62A24D4816B4F034120000" , vpermps(zmm22, zmm6, zmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62E24D581631" , vpermps(zmm22, zmm6, dword_ptr(rcx)._1to16())); + TEST_INSTRUCTION("62E24D4816727F" , vpermps(zmm22, zmm6, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62E24D4816B200200000" , vpermps(zmm22, zmm6, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62E24D48167280" , vpermps(zmm22, zmm6, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62E24D4816B2C0DFFFFF" , vpermps(zmm22, zmm6, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62E24D5816727F" , vpermps(zmm22, zmm6, dword_ptr(rdx, 508)._1to16())); + TEST_INSTRUCTION("62E24D5816B200020000" , vpermps(zmm22, zmm6, dword_ptr(rdx, 512)._1to16())); + TEST_INSTRUCTION("62E24D58167280" , vpermps(zmm22, zmm6, dword_ptr(rdx, -512)._1to16())); + TEST_INSTRUCTION("62E24D5816B2FCFDFFFF" , vpermps(zmm22, zmm6, dword_ptr(rdx, -516)._1to16())); + TEST_INSTRUCTION("6223FD4800C7AB" , vpermq(zmm24, zmm23, 171)); + TEST_INSTRUCTION("6223FD4B00C7AB" , k(k3).vpermq(zmm24, zmm23, 171)); + TEST_INSTRUCTION("6223FDCB00C7AB" , k(k3).z().vpermq(zmm24, zmm23, 171)); + TEST_INSTRUCTION("6223FD4800C77B" , vpermq(zmm24, zmm23, 123)); + TEST_INSTRUCTION("6263FD4800017B" , vpermq(zmm24, zmmword_ptr(rcx), 123)); + TEST_INSTRUCTION("6223FD480084F0341200007B" , vpermq(zmm24, zmmword_ptr(rax, r14, 3, 4660), 123)); + TEST_INSTRUCTION("6263FD5800017B" , vpermq(zmm24, qword_ptr(rcx)._1to8(), 123)); + TEST_INSTRUCTION("6263FD4800427F7B" , vpermq(zmm24, zmmword_ptr(rdx, 8128), 123)); + TEST_INSTRUCTION("6263FD480082002000007B" , vpermq(zmm24, zmmword_ptr(rdx, 8192), 123)); + TEST_INSTRUCTION("6263FD480042807B" , vpermq(zmm24, zmmword_ptr(rdx, -8192), 123)); + TEST_INSTRUCTION("6263FD480082C0DFFFFF7B" , vpermq(zmm24, zmmword_ptr(rdx, -8256), 123)); + TEST_INSTRUCTION("6263FD5800427F7B" , vpermq(zmm24, qword_ptr(rdx, 1016)._1to8(), 123)); + TEST_INSTRUCTION("6263FD580082000400007B" , vpermq(zmm24, qword_ptr(rdx, 1024)._1to8(), 123)); + TEST_INSTRUCTION("6263FD580042807B" , vpermq(zmm24, qword_ptr(rdx, -1024)._1to8(), 123)); + TEST_INSTRUCTION("6263FD580082F8FBFFFF7B" , vpermq(zmm24, qword_ptr(rdx, -1032)._1to8(), 123)); + TEST_INSTRUCTION("62E27D488911" , vpexpandd(zmm18, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62E27D4A8911" , k(k2).vpexpandd(zmm18, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62E27DCA8911" , k(k2).z().vpexpandd(zmm18, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62A27D488994F034120000" , vpexpandd(zmm18, zmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62E27D4889527F" , vpexpandd(zmm18, zmmword_ptr(rdx, 508))); + TEST_INSTRUCTION("62E27D48899200020000" , vpexpandd(zmm18, zmmword_ptr(rdx, 512))); + TEST_INSTRUCTION("62E27D48895280" , vpexpandd(zmm18, zmmword_ptr(rdx, -512))); + TEST_INSTRUCTION("62E27D488992FCFDFFFF" , vpexpandd(zmm18, zmmword_ptr(rdx, -516))); + TEST_INSTRUCTION("62127D4889E4" , vpexpandd(zmm12, zmm28)); + TEST_INSTRUCTION("62127D4E89E4" , k(k6).vpexpandd(zmm12, zmm28)); + TEST_INSTRUCTION("62127DCE89E4" , k(k6).z().vpexpandd(zmm12, zmm28)); + TEST_INSTRUCTION("62F2FD488909" , vpexpandq(zmm1, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62F2FD4F8909" , k(k7).vpexpandq(zmm1, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62F2FDCF8909" , k(k7).z().vpexpandq(zmm1, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62B2FD48898CF034120000" , vpexpandq(zmm1, zmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62F2FD48894A7F" , vpexpandq(zmm1, zmmword_ptr(rdx, 1016))); + TEST_INSTRUCTION("62F2FD48898A00040000" , vpexpandq(zmm1, zmmword_ptr(rdx, 1024))); + TEST_INSTRUCTION("62F2FD48894A80" , vpexpandq(zmm1, zmmword_ptr(rdx, -1024))); + TEST_INSTRUCTION("62F2FD48898AF8FBFFFF" , vpexpandq(zmm1, zmmword_ptr(rdx, -1032))); + TEST_INSTRUCTION("6282FD4889CA" , vpexpandq(zmm17, zmm26)); + TEST_INSTRUCTION("6282FD4F89CA" , k(k7).vpexpandq(zmm17, zmm26)); + TEST_INSTRUCTION("6282FDCF89CA" , k(k7).z().vpexpandq(zmm17, zmm26)); + TEST_INSTRUCTION("624215483DF1" , vpmaxsd(zmm30, zmm13, zmm9)); + TEST_INSTRUCTION("6242154F3DF1" , k(k7).vpmaxsd(zmm30, zmm13, zmm9)); + TEST_INSTRUCTION("624215CF3DF1" , k(k7).z().vpmaxsd(zmm30, zmm13, zmm9)); + TEST_INSTRUCTION("626215483D31" , vpmaxsd(zmm30, zmm13, zmmword_ptr(rcx))); + TEST_INSTRUCTION("622215483DB4F034120000" , vpmaxsd(zmm30, zmm13, zmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("626215583D31" , vpmaxsd(zmm30, zmm13, dword_ptr(rcx)._1to16())); + TEST_INSTRUCTION("626215483D727F" , vpmaxsd(zmm30, zmm13, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("626215483DB200200000" , vpmaxsd(zmm30, zmm13, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("626215483D7280" , vpmaxsd(zmm30, zmm13, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("626215483DB2C0DFFFFF" , vpmaxsd(zmm30, zmm13, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("626215583D727F" , vpmaxsd(zmm30, zmm13, dword_ptr(rdx, 508)._1to16())); + TEST_INSTRUCTION("626215583DB200020000" , vpmaxsd(zmm30, zmm13, dword_ptr(rdx, 512)._1to16())); + TEST_INSTRUCTION("626215583D7280" , vpmaxsd(zmm30, zmm13, dword_ptr(rdx, -512)._1to16())); + TEST_INSTRUCTION("626215583DB2FCFDFFFF" , vpmaxsd(zmm30, zmm13, dword_ptr(rdx, -516)._1to16())); + TEST_INSTRUCTION("62F2C5483DDD" , vpmaxsq(zmm3, zmm7, zmm5)); + TEST_INSTRUCTION("62F2C54B3DDD" , k(k3).vpmaxsq(zmm3, zmm7, zmm5)); + TEST_INSTRUCTION("62F2C5CB3DDD" , k(k3).z().vpmaxsq(zmm3, zmm7, zmm5)); + TEST_INSTRUCTION("62F2C5483D19" , vpmaxsq(zmm3, zmm7, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62B2C5483D9CF034120000" , vpmaxsq(zmm3, zmm7, zmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62F2C5583D19" , vpmaxsq(zmm3, zmm7, qword_ptr(rcx)._1to8())); + TEST_INSTRUCTION("62F2C5483D5A7F" , vpmaxsq(zmm3, zmm7, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62F2C5483D9A00200000" , vpmaxsq(zmm3, zmm7, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62F2C5483D5A80" , vpmaxsq(zmm3, zmm7, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62F2C5483D9AC0DFFFFF" , vpmaxsq(zmm3, zmm7, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62F2C5583D5A7F" , vpmaxsq(zmm3, zmm7, qword_ptr(rdx, 1016)._1to8())); + TEST_INSTRUCTION("62F2C5583D9A00040000" , vpmaxsq(zmm3, zmm7, qword_ptr(rdx, 1024)._1to8())); + TEST_INSTRUCTION("62F2C5583D5A80" , vpmaxsq(zmm3, zmm7, qword_ptr(rdx, -1024)._1to8())); + TEST_INSTRUCTION("62F2C5583D9AF8FBFFFF" , vpmaxsq(zmm3, zmm7, qword_ptr(rdx, -1032)._1to8())); + TEST_INSTRUCTION("62C225403FF4" , vpmaxud(zmm22, zmm27, zmm12)); + TEST_INSTRUCTION("62C225473FF4" , k(k7).vpmaxud(zmm22, zmm27, zmm12)); + TEST_INSTRUCTION("62C225C73FF4" , k(k7).z().vpmaxud(zmm22, zmm27, zmm12)); + TEST_INSTRUCTION("62E225403F31" , vpmaxud(zmm22, zmm27, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62A225403FB4F034120000" , vpmaxud(zmm22, zmm27, zmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62E225503F31" , vpmaxud(zmm22, zmm27, dword_ptr(rcx)._1to16())); + TEST_INSTRUCTION("62E225403F727F" , vpmaxud(zmm22, zmm27, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62E225403FB200200000" , vpmaxud(zmm22, zmm27, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62E225403F7280" , vpmaxud(zmm22, zmm27, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62E225403FB2C0DFFFFF" , vpmaxud(zmm22, zmm27, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62E225503F727F" , vpmaxud(zmm22, zmm27, dword_ptr(rdx, 508)._1to16())); + TEST_INSTRUCTION("62E225503FB200020000" , vpmaxud(zmm22, zmm27, dword_ptr(rdx, 512)._1to16())); + TEST_INSTRUCTION("62E225503F7280" , vpmaxud(zmm22, zmm27, dword_ptr(rdx, -512)._1to16())); + TEST_INSTRUCTION("62E225503FB2FCFDFFFF" , vpmaxud(zmm22, zmm27, dword_ptr(rdx, -516)._1to16())); + TEST_INSTRUCTION("62D2B5483FCC" , vpmaxuq(zmm1, zmm9, zmm12)); + TEST_INSTRUCTION("62D2B54A3FCC" , k(k2).vpmaxuq(zmm1, zmm9, zmm12)); + TEST_INSTRUCTION("62D2B5CA3FCC" , k(k2).z().vpmaxuq(zmm1, zmm9, zmm12)); + TEST_INSTRUCTION("62F2B5483F09" , vpmaxuq(zmm1, zmm9, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62B2B5483F8CF034120000" , vpmaxuq(zmm1, zmm9, zmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62F2B5583F09" , vpmaxuq(zmm1, zmm9, qword_ptr(rcx)._1to8())); + TEST_INSTRUCTION("62F2B5483F4A7F" , vpmaxuq(zmm1, zmm9, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62F2B5483F8A00200000" , vpmaxuq(zmm1, zmm9, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62F2B5483F4A80" , vpmaxuq(zmm1, zmm9, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62F2B5483F8AC0DFFFFF" , vpmaxuq(zmm1, zmm9, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62F2B5583F4A7F" , vpmaxuq(zmm1, zmm9, qword_ptr(rdx, 1016)._1to8())); + TEST_INSTRUCTION("62F2B5583F8A00040000" , vpmaxuq(zmm1, zmm9, qword_ptr(rdx, 1024)._1to8())); + TEST_INSTRUCTION("62F2B5583F4A80" , vpmaxuq(zmm1, zmm9, qword_ptr(rdx, -1024)._1to8())); + TEST_INSTRUCTION("62F2B5583F8AF8FBFFFF" , vpmaxuq(zmm1, zmm9, qword_ptr(rdx, -1032)._1to8())); + TEST_INSTRUCTION("62E2754039DA" , vpminsd(zmm19, zmm17, zmm2)); + TEST_INSTRUCTION("62E2754739DA" , k(k7).vpminsd(zmm19, zmm17, zmm2)); + TEST_INSTRUCTION("62E275C739DA" , k(k7).z().vpminsd(zmm19, zmm17, zmm2)); + TEST_INSTRUCTION("62E275403919" , vpminsd(zmm19, zmm17, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62A27540399CF034120000" , vpminsd(zmm19, zmm17, zmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62E275503919" , vpminsd(zmm19, zmm17, dword_ptr(rcx)._1to16())); + TEST_INSTRUCTION("62E27540395A7F" , vpminsd(zmm19, zmm17, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62E27540399A00200000" , vpminsd(zmm19, zmm17, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62E27540395A80" , vpminsd(zmm19, zmm17, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62E27540399AC0DFFFFF" , vpminsd(zmm19, zmm17, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62E27550395A7F" , vpminsd(zmm19, zmm17, dword_ptr(rdx, 508)._1to16())); + TEST_INSTRUCTION("62E27550399A00020000" , vpminsd(zmm19, zmm17, dword_ptr(rdx, 512)._1to16())); + TEST_INSTRUCTION("62E27550395A80" , vpminsd(zmm19, zmm17, dword_ptr(rdx, -512)._1to16())); + TEST_INSTRUCTION("62E27550399AFCFDFFFF" , vpminsd(zmm19, zmm17, dword_ptr(rdx, -516)._1to16())); + TEST_INSTRUCTION("62A2F54839EE" , vpminsq(zmm21, zmm1, zmm22)); + TEST_INSTRUCTION("62A2F54E39EE" , k(k6).vpminsq(zmm21, zmm1, zmm22)); + TEST_INSTRUCTION("62A2F5CE39EE" , k(k6).z().vpminsq(zmm21, zmm1, zmm22)); + TEST_INSTRUCTION("62E2F5483929" , vpminsq(zmm21, zmm1, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62A2F54839ACF034120000" , vpminsq(zmm21, zmm1, zmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62E2F5583929" , vpminsq(zmm21, zmm1, qword_ptr(rcx)._1to8())); + TEST_INSTRUCTION("62E2F548396A7F" , vpminsq(zmm21, zmm1, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62E2F54839AA00200000" , vpminsq(zmm21, zmm1, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62E2F548396A80" , vpminsq(zmm21, zmm1, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62E2F54839AAC0DFFFFF" , vpminsq(zmm21, zmm1, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62E2F558396A7F" , vpminsq(zmm21, zmm1, qword_ptr(rdx, 1016)._1to8())); + TEST_INSTRUCTION("62E2F55839AA00040000" , vpminsq(zmm21, zmm1, qword_ptr(rdx, 1024)._1to8())); + TEST_INSTRUCTION("62E2F558396A80" , vpminsq(zmm21, zmm1, qword_ptr(rdx, -1024)._1to8())); + TEST_INSTRUCTION("62E2F55839AAF8FBFFFF" , vpminsq(zmm21, zmm1, qword_ptr(rdx, -1032)._1to8())); + TEST_INSTRUCTION("62F24D403BE3" , vpminud(zmm4, zmm22, zmm3)); + TEST_INSTRUCTION("62F24D443BE3" , k(k4).vpminud(zmm4, zmm22, zmm3)); + TEST_INSTRUCTION("62F24DC43BE3" , k(k4).z().vpminud(zmm4, zmm22, zmm3)); + TEST_INSTRUCTION("62F24D403B21" , vpminud(zmm4, zmm22, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62B24D403BA4F034120000" , vpminud(zmm4, zmm22, zmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62F24D503B21" , vpminud(zmm4, zmm22, dword_ptr(rcx)._1to16())); + TEST_INSTRUCTION("62F24D403B627F" , vpminud(zmm4, zmm22, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62F24D403BA200200000" , vpminud(zmm4, zmm22, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62F24D403B6280" , vpminud(zmm4, zmm22, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62F24D403BA2C0DFFFFF" , vpminud(zmm4, zmm22, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62F24D503B627F" , vpminud(zmm4, zmm22, dword_ptr(rdx, 508)._1to16())); + TEST_INSTRUCTION("62F24D503BA200020000" , vpminud(zmm4, zmm22, dword_ptr(rdx, 512)._1to16())); + TEST_INSTRUCTION("62F24D503B6280" , vpminud(zmm4, zmm22, dword_ptr(rdx, -512)._1to16())); + TEST_INSTRUCTION("62F24D503BA2FCFDFFFF" , vpminud(zmm4, zmm22, dword_ptr(rdx, -516)._1to16())); + TEST_INSTRUCTION("6202AD403BCB" , vpminuq(zmm25, zmm26, zmm27)); + TEST_INSTRUCTION("6202AD463BCB" , k(k6).vpminuq(zmm25, zmm26, zmm27)); + TEST_INSTRUCTION("6202ADC63BCB" , k(k6).z().vpminuq(zmm25, zmm26, zmm27)); + TEST_INSTRUCTION("6262AD403B09" , vpminuq(zmm25, zmm26, zmmword_ptr(rcx))); + TEST_INSTRUCTION("6222AD403B8CF034120000" , vpminuq(zmm25, zmm26, zmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("6262AD503B09" , vpminuq(zmm25, zmm26, qword_ptr(rcx)._1to8())); + TEST_INSTRUCTION("6262AD403B4A7F" , vpminuq(zmm25, zmm26, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("6262AD403B8A00200000" , vpminuq(zmm25, zmm26, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("6262AD403B4A80" , vpminuq(zmm25, zmm26, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("6262AD403B8AC0DFFFFF" , vpminuq(zmm25, zmm26, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("6262AD503B4A7F" , vpminuq(zmm25, zmm26, qword_ptr(rdx, 1016)._1to8())); + TEST_INSTRUCTION("6262AD503B8A00040000" , vpminuq(zmm25, zmm26, qword_ptr(rdx, 1024)._1to8())); + TEST_INSTRUCTION("6262AD503B4A80" , vpminuq(zmm25, zmm26, qword_ptr(rdx, -1024)._1to8())); + TEST_INSTRUCTION("6262AD503B8AF8FBFFFF" , vpminuq(zmm25, zmm26, qword_ptr(rdx, -1032)._1to8())); + TEST_INSTRUCTION("62427D4821CA" , vpmovsxbd(zmm25, xmm10)); + TEST_INSTRUCTION("62427D4921CA" , k(k1).vpmovsxbd(zmm25, xmm10)); + TEST_INSTRUCTION("62427DC921CA" , k(k1).z().vpmovsxbd(zmm25, xmm10)); + TEST_INSTRUCTION("62627D482109" , vpmovsxbd(zmm25, xmmword_ptr(rcx))); + TEST_INSTRUCTION("62227D48218CF034120000" , vpmovsxbd(zmm25, xmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62627D48214A7F" , vpmovsxbd(zmm25, xmmword_ptr(rdx, 2032))); + TEST_INSTRUCTION("62627D48218A00080000" , vpmovsxbd(zmm25, xmmword_ptr(rdx, 2048))); + TEST_INSTRUCTION("62627D48214A80" , vpmovsxbd(zmm25, xmmword_ptr(rdx, -2048))); + TEST_INSTRUCTION("62627D48218AF0F7FFFF" , vpmovsxbd(zmm25, xmmword_ptr(rdx, -2064))); + TEST_INSTRUCTION("62527D4822F6" , vpmovsxbq(zmm14, xmm14)); + TEST_INSTRUCTION("62527D4D22F6" , k(k5).vpmovsxbq(zmm14, xmm14)); + TEST_INSTRUCTION("62527DCD22F6" , k(k5).z().vpmovsxbq(zmm14, xmm14)); + TEST_INSTRUCTION("62727D482231" , vpmovsxbq(zmm14, qword_ptr(rcx))); + TEST_INSTRUCTION("62327D4822B4F034120000" , vpmovsxbq(zmm14, qword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62727D4822727F" , vpmovsxbq(zmm14, qword_ptr(rdx, 1016))); + TEST_INSTRUCTION("62727D4822B200040000" , vpmovsxbq(zmm14, qword_ptr(rdx, 1024))); + TEST_INSTRUCTION("62727D48227280" , vpmovsxbq(zmm14, qword_ptr(rdx, -1024))); + TEST_INSTRUCTION("62727D4822B2F8FBFFFF" , vpmovsxbq(zmm14, qword_ptr(rdx, -1032))); + TEST_INSTRUCTION("62527D4825D9" , vpmovsxdq(zmm11, ymm9)); + TEST_INSTRUCTION("62527D4E25D9" , k(k6).vpmovsxdq(zmm11, ymm9)); + TEST_INSTRUCTION("62527DCE25D9" , k(k6).z().vpmovsxdq(zmm11, ymm9)); + TEST_INSTRUCTION("62727D482519" , vpmovsxdq(zmm11, ymmword_ptr(rcx))); + TEST_INSTRUCTION("62327D48259CF034120000" , vpmovsxdq(zmm11, ymmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62727D48255A7F" , vpmovsxdq(zmm11, ymmword_ptr(rdx, 4064))); + TEST_INSTRUCTION("62727D48259A00100000" , vpmovsxdq(zmm11, ymmword_ptr(rdx, 4096))); + TEST_INSTRUCTION("62727D48255A80" , vpmovsxdq(zmm11, ymmword_ptr(rdx, -4096))); + TEST_INSTRUCTION("62727D48259AE0EFFFFF" , vpmovsxdq(zmm11, ymmword_ptr(rdx, -4128))); + TEST_INSTRUCTION("62527D4823E3" , vpmovsxwd(zmm12, ymm11)); + TEST_INSTRUCTION("62527D4A23E3" , k(k2).vpmovsxwd(zmm12, ymm11)); + TEST_INSTRUCTION("62527DCA23E3" , k(k2).z().vpmovsxwd(zmm12, ymm11)); + TEST_INSTRUCTION("62727D482321" , vpmovsxwd(zmm12, ymmword_ptr(rcx))); + TEST_INSTRUCTION("62327D4823A4F034120000" , vpmovsxwd(zmm12, ymmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62727D4823627F" , vpmovsxwd(zmm12, ymmword_ptr(rdx, 4064))); + TEST_INSTRUCTION("62727D4823A200100000" , vpmovsxwd(zmm12, ymmword_ptr(rdx, 4096))); + TEST_INSTRUCTION("62727D48236280" , vpmovsxwd(zmm12, ymmword_ptr(rdx, -4096))); + TEST_INSTRUCTION("62727D4823A2E0EFFFFF" , vpmovsxwd(zmm12, ymmword_ptr(rdx, -4128))); + TEST_INSTRUCTION("62527D4824DE" , vpmovsxwq(zmm11, xmm14)); + TEST_INSTRUCTION("62527D4D24DE" , k(k5).vpmovsxwq(zmm11, xmm14)); + TEST_INSTRUCTION("62527DCD24DE" , k(k5).z().vpmovsxwq(zmm11, xmm14)); + TEST_INSTRUCTION("62727D482419" , vpmovsxwq(zmm11, xmmword_ptr(rcx))); + TEST_INSTRUCTION("62327D48249CF034120000" , vpmovsxwq(zmm11, xmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62727D48245A7F" , vpmovsxwq(zmm11, xmmword_ptr(rdx, 2032))); + TEST_INSTRUCTION("62727D48249A00080000" , vpmovsxwq(zmm11, xmmword_ptr(rdx, 2048))); + TEST_INSTRUCTION("62727D48245A80" , vpmovsxwq(zmm11, xmmword_ptr(rdx, -2048))); + TEST_INSTRUCTION("62727D48249AF0F7FFFF" , vpmovsxwq(zmm11, xmmword_ptr(rdx, -2064))); + TEST_INSTRUCTION("62027D4831C9" , vpmovzxbd(zmm25, xmm25)); + TEST_INSTRUCTION("62027D4C31C9" , k(k4).vpmovzxbd(zmm25, xmm25)); + TEST_INSTRUCTION("62027DCC31C9" , k(k4).z().vpmovzxbd(zmm25, xmm25)); + TEST_INSTRUCTION("62627D483109" , vpmovzxbd(zmm25, xmmword_ptr(rcx))); + TEST_INSTRUCTION("62227D48318CF034120000" , vpmovzxbd(zmm25, xmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62627D48314A7F" , vpmovzxbd(zmm25, xmmword_ptr(rdx, 2032))); + TEST_INSTRUCTION("62627D48318A00080000" , vpmovzxbd(zmm25, xmmword_ptr(rdx, 2048))); + TEST_INSTRUCTION("62627D48314A80" , vpmovzxbd(zmm25, xmmword_ptr(rdx, -2048))); + TEST_INSTRUCTION("62627D48318AF0F7FFFF" , vpmovzxbd(zmm25, xmmword_ptr(rdx, -2064))); + TEST_INSTRUCTION("62A27D4832FC" , vpmovzxbq(zmm23, xmm20)); + TEST_INSTRUCTION("62A27D4B32FC" , k(k3).vpmovzxbq(zmm23, xmm20)); + TEST_INSTRUCTION("62A27DCB32FC" , k(k3).z().vpmovzxbq(zmm23, xmm20)); + TEST_INSTRUCTION("62E27D483239" , vpmovzxbq(zmm23, qword_ptr(rcx))); + TEST_INSTRUCTION("62A27D4832BCF034120000" , vpmovzxbq(zmm23, qword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62E27D48327A7F" , vpmovzxbq(zmm23, qword_ptr(rdx, 1016))); + TEST_INSTRUCTION("62E27D4832BA00040000" , vpmovzxbq(zmm23, qword_ptr(rdx, 1024))); + TEST_INSTRUCTION("62E27D48327A80" , vpmovzxbq(zmm23, qword_ptr(rdx, -1024))); + TEST_INSTRUCTION("62E27D4832BAF8FBFFFF" , vpmovzxbq(zmm23, qword_ptr(rdx, -1032))); + TEST_INSTRUCTION("62327D4835CE" , vpmovzxdq(zmm9, ymm22)); + TEST_INSTRUCTION("62327D4B35CE" , k(k3).vpmovzxdq(zmm9, ymm22)); + TEST_INSTRUCTION("62327DCB35CE" , k(k3).z().vpmovzxdq(zmm9, ymm22)); + TEST_INSTRUCTION("62727D483509" , vpmovzxdq(zmm9, ymmword_ptr(rcx))); + TEST_INSTRUCTION("62327D48358CF034120000" , vpmovzxdq(zmm9, ymmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62727D48354A7F" , vpmovzxdq(zmm9, ymmword_ptr(rdx, 4064))); + TEST_INSTRUCTION("62727D48358A00100000" , vpmovzxdq(zmm9, ymmword_ptr(rdx, 4096))); + TEST_INSTRUCTION("62727D48354A80" , vpmovzxdq(zmm9, ymmword_ptr(rdx, -4096))); + TEST_INSTRUCTION("62727D48358AE0EFFFFF" , vpmovzxdq(zmm9, ymmword_ptr(rdx, -4128))); + TEST_INSTRUCTION("62927D4833F5" , vpmovzxwd(zmm6, ymm29)); + TEST_INSTRUCTION("62927D4C33F5" , k(k4).vpmovzxwd(zmm6, ymm29)); + TEST_INSTRUCTION("62927DCC33F5" , k(k4).z().vpmovzxwd(zmm6, ymm29)); + TEST_INSTRUCTION("62F27D483331" , vpmovzxwd(zmm6, ymmword_ptr(rcx))); + TEST_INSTRUCTION("62B27D4833B4F034120000" , vpmovzxwd(zmm6, ymmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62F27D4833727F" , vpmovzxwd(zmm6, ymmword_ptr(rdx, 4064))); + TEST_INSTRUCTION("62F27D4833B200100000" , vpmovzxwd(zmm6, ymmword_ptr(rdx, 4096))); + TEST_INSTRUCTION("62F27D48337280" , vpmovzxwd(zmm6, ymmword_ptr(rdx, -4096))); + TEST_INSTRUCTION("62F27D4833B2E0EFFFFF" , vpmovzxwd(zmm6, ymmword_ptr(rdx, -4128))); + TEST_INSTRUCTION("62327D4834E2" , vpmovzxwq(zmm12, xmm18)); + TEST_INSTRUCTION("62327D4E34E2" , k(k6).vpmovzxwq(zmm12, xmm18)); + TEST_INSTRUCTION("62327DCE34E2" , k(k6).z().vpmovzxwq(zmm12, xmm18)); + TEST_INSTRUCTION("62727D483421" , vpmovzxwq(zmm12, xmmword_ptr(rcx))); + TEST_INSTRUCTION("62327D4834A4F034120000" , vpmovzxwq(zmm12, xmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62727D4834627F" , vpmovzxwq(zmm12, xmmword_ptr(rdx, 2032))); + TEST_INSTRUCTION("62727D4834A200080000" , vpmovzxwq(zmm12, xmmword_ptr(rdx, 2048))); + TEST_INSTRUCTION("62727D48346280" , vpmovzxwq(zmm12, xmmword_ptr(rdx, -2048))); + TEST_INSTRUCTION("62727D4834A2F0F7FFFF" , vpmovzxwq(zmm12, xmmword_ptr(rdx, -2064))); + TEST_INSTRUCTION("62D2CD4028EC" , vpmuldq(zmm5, zmm22, zmm12)); + TEST_INSTRUCTION("62D2CD4428EC" , k(k4).vpmuldq(zmm5, zmm22, zmm12)); + TEST_INSTRUCTION("62D2CDC428EC" , k(k4).z().vpmuldq(zmm5, zmm22, zmm12)); + TEST_INSTRUCTION("62F2CD402829" , vpmuldq(zmm5, zmm22, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62B2CD4028ACF034120000" , vpmuldq(zmm5, zmm22, zmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62F2CD502829" , vpmuldq(zmm5, zmm22, qword_ptr(rcx)._1to8())); + TEST_INSTRUCTION("62F2CD40286A7F" , vpmuldq(zmm5, zmm22, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62F2CD4028AA00200000" , vpmuldq(zmm5, zmm22, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62F2CD40286A80" , vpmuldq(zmm5, zmm22, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62F2CD4028AAC0DFFFFF" , vpmuldq(zmm5, zmm22, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62F2CD50286A7F" , vpmuldq(zmm5, zmm22, qword_ptr(rdx, 1016)._1to8())); + TEST_INSTRUCTION("62F2CD5028AA00040000" , vpmuldq(zmm5, zmm22, qword_ptr(rdx, 1024)._1to8())); + TEST_INSTRUCTION("62F2CD50286A80" , vpmuldq(zmm5, zmm22, qword_ptr(rdx, -1024)._1to8())); + TEST_INSTRUCTION("62F2CD5028AAF8FBFFFF" , vpmuldq(zmm5, zmm22, qword_ptr(rdx, -1032)._1to8())); + TEST_INSTRUCTION("62723D4040E2" , vpmulld(zmm12, zmm24, zmm2)); + TEST_INSTRUCTION("62723D4640E2" , k(k6).vpmulld(zmm12, zmm24, zmm2)); + TEST_INSTRUCTION("62723DC640E2" , k(k6).z().vpmulld(zmm12, zmm24, zmm2)); + TEST_INSTRUCTION("62723D404021" , vpmulld(zmm12, zmm24, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62323D4040A4F034120000" , vpmulld(zmm12, zmm24, zmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62723D504021" , vpmulld(zmm12, zmm24, dword_ptr(rcx)._1to16())); + TEST_INSTRUCTION("62723D4040627F" , vpmulld(zmm12, zmm24, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62723D4040A200200000" , vpmulld(zmm12, zmm24, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62723D40406280" , vpmulld(zmm12, zmm24, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62723D4040A2C0DFFFFF" , vpmulld(zmm12, zmm24, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62723D5040627F" , vpmulld(zmm12, zmm24, dword_ptr(rdx, 508)._1to16())); + TEST_INSTRUCTION("62723D5040A200020000" , vpmulld(zmm12, zmm24, dword_ptr(rdx, 512)._1to16())); + TEST_INSTRUCTION("62723D50406280" , vpmulld(zmm12, zmm24, dword_ptr(rdx, -512)._1to16())); + TEST_INSTRUCTION("62723D5040A2FCFDFFFF" , vpmulld(zmm12, zmm24, dword_ptr(rdx, -516)._1to16())); + TEST_INSTRUCTION("6251ED48F4C2" , vpmuludq(zmm8, zmm2, zmm10)); + TEST_INSTRUCTION("6251ED4FF4C2" , k(k7).vpmuludq(zmm8, zmm2, zmm10)); + TEST_INSTRUCTION("6251EDCFF4C2" , k(k7).z().vpmuludq(zmm8, zmm2, zmm10)); + TEST_INSTRUCTION("6271ED48F401" , vpmuludq(zmm8, zmm2, zmmword_ptr(rcx))); + TEST_INSTRUCTION("6231ED48F484F034120000" , vpmuludq(zmm8, zmm2, zmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("6271ED58F401" , vpmuludq(zmm8, zmm2, qword_ptr(rcx)._1to8())); + TEST_INSTRUCTION("6271ED48F4427F" , vpmuludq(zmm8, zmm2, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("6271ED48F48200200000" , vpmuludq(zmm8, zmm2, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("6271ED48F44280" , vpmuludq(zmm8, zmm2, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("6271ED48F482C0DFFFFF" , vpmuludq(zmm8, zmm2, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("6271ED58F4427F" , vpmuludq(zmm8, zmm2, qword_ptr(rdx, 1016)._1to8())); + TEST_INSTRUCTION("6271ED58F48200040000" , vpmuludq(zmm8, zmm2, qword_ptr(rdx, 1024)._1to8())); + TEST_INSTRUCTION("6271ED58F44280" , vpmuludq(zmm8, zmm2, qword_ptr(rdx, -1024)._1to8())); + TEST_INSTRUCTION("6271ED58F482F8FBFFFF" , vpmuludq(zmm8, zmm2, qword_ptr(rdx, -1032)._1to8())); + TEST_INSTRUCTION("62412D48EBEF" , vpord(zmm29, zmm10, zmm15)); + TEST_INSTRUCTION("62412D4CEBEF" , k(k4).vpord(zmm29, zmm10, zmm15)); + TEST_INSTRUCTION("62412DCCEBEF" , k(k4).z().vpord(zmm29, zmm10, zmm15)); + TEST_INSTRUCTION("62612D48EB29" , vpord(zmm29, zmm10, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62212D48EBACF034120000" , vpord(zmm29, zmm10, zmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62612D58EB29" , vpord(zmm29, zmm10, dword_ptr(rcx)._1to16())); + TEST_INSTRUCTION("62612D48EB6A7F" , vpord(zmm29, zmm10, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62612D48EBAA00200000" , vpord(zmm29, zmm10, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62612D48EB6A80" , vpord(zmm29, zmm10, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62612D48EBAAC0DFFFFF" , vpord(zmm29, zmm10, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62612D58EB6A7F" , vpord(zmm29, zmm10, dword_ptr(rdx, 508)._1to16())); + TEST_INSTRUCTION("62612D58EBAA00020000" , vpord(zmm29, zmm10, dword_ptr(rdx, 512)._1to16())); + TEST_INSTRUCTION("62612D58EB6A80" , vpord(zmm29, zmm10, dword_ptr(rdx, -512)._1to16())); + TEST_INSTRUCTION("62612D58EBAAFCFDFFFF" , vpord(zmm29, zmm10, dword_ptr(rdx, -516)._1to16())); + TEST_INSTRUCTION("6291C540EBDA" , vporq(zmm3, zmm23, zmm26)); + TEST_INSTRUCTION("6291C544EBDA" , k(k4).vporq(zmm3, zmm23, zmm26)); + TEST_INSTRUCTION("6291C5C4EBDA" , k(k4).z().vporq(zmm3, zmm23, zmm26)); + TEST_INSTRUCTION("62F1C540EB19" , vporq(zmm3, zmm23, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62B1C540EB9CF034120000" , vporq(zmm3, zmm23, zmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62F1C550EB19" , vporq(zmm3, zmm23, qword_ptr(rcx)._1to8())); + TEST_INSTRUCTION("62F1C540EB5A7F" , vporq(zmm3, zmm23, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62F1C540EB9A00200000" , vporq(zmm3, zmm23, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62F1C540EB5A80" , vporq(zmm3, zmm23, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62F1C540EB9AC0DFFFFF" , vporq(zmm3, zmm23, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62F1C550EB5A7F" , vporq(zmm3, zmm23, qword_ptr(rdx, 1016)._1to8())); + TEST_INSTRUCTION("62F1C550EB9A00040000" , vporq(zmm3, zmm23, qword_ptr(rdx, 1024)._1to8())); + TEST_INSTRUCTION("62F1C550EB5A80" , vporq(zmm3, zmm23, qword_ptr(rdx, -1024)._1to8())); + TEST_INSTRUCTION("62F1C550EB9AF8FBFFFF" , vporq(zmm3, zmm23, qword_ptr(rdx, -1032)._1to8())); + TEST_INSTRUCTION("62D17D4870FCAB" , vpshufd(zmm7, zmm12, 171)); + TEST_INSTRUCTION("62D17D4970FCAB" , k(k1).vpshufd(zmm7, zmm12, 171)); + TEST_INSTRUCTION("62D17DC970FCAB" , k(k1).z().vpshufd(zmm7, zmm12, 171)); + TEST_INSTRUCTION("62D17D4870FC7B" , vpshufd(zmm7, zmm12, 123)); + TEST_INSTRUCTION("62F17D4870397B" , vpshufd(zmm7, zmmword_ptr(rcx), 123)); + TEST_INSTRUCTION("62B17D4870BCF0341200007B" , vpshufd(zmm7, zmmword_ptr(rax, r14, 3, 4660), 123)); + TEST_INSTRUCTION("62F17D5870397B" , vpshufd(zmm7, dword_ptr(rcx)._1to16(), 123)); + TEST_INSTRUCTION("62F17D48707A7F7B" , vpshufd(zmm7, zmmword_ptr(rdx, 8128), 123)); + TEST_INSTRUCTION("62F17D4870BA002000007B" , vpshufd(zmm7, zmmword_ptr(rdx, 8192), 123)); + TEST_INSTRUCTION("62F17D48707A807B" , vpshufd(zmm7, zmmword_ptr(rdx, -8192), 123)); + TEST_INSTRUCTION("62F17D4870BAC0DFFFFF7B" , vpshufd(zmm7, zmmword_ptr(rdx, -8256), 123)); + TEST_INSTRUCTION("62F17D58707A7F7B" , vpshufd(zmm7, dword_ptr(rdx, 508)._1to16(), 123)); + TEST_INSTRUCTION("62F17D5870BA000200007B" , vpshufd(zmm7, dword_ptr(rdx, 512)._1to16(), 123)); + TEST_INSTRUCTION("62F17D58707A807B" , vpshufd(zmm7, dword_ptr(rdx, -512)._1to16(), 123)); + TEST_INSTRUCTION("62F17D5870BAFCFDFFFF7B" , vpshufd(zmm7, dword_ptr(rdx, -516)._1to16(), 123)); + TEST_INSTRUCTION("62D14D40F2FE" , vpslld(zmm7, zmm22, xmm14)); + TEST_INSTRUCTION("62D14D44F2FE" , k(k4).vpslld(zmm7, zmm22, xmm14)); + TEST_INSTRUCTION("62D14DC4F2FE" , k(k4).z().vpslld(zmm7, zmm22, xmm14)); + TEST_INSTRUCTION("62F14D40F239" , vpslld(zmm7, zmm22, xmmword_ptr(rcx))); + TEST_INSTRUCTION("62B14D40F2BCF034120000" , vpslld(zmm7, zmm22, xmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62F14D40F27A7F" , vpslld(zmm7, zmm22, xmmword_ptr(rdx, 2032))); + TEST_INSTRUCTION("62F14D40F2BA00080000" , vpslld(zmm7, zmm22, xmmword_ptr(rdx, 2048))); + TEST_INSTRUCTION("62F14D40F27A80" , vpslld(zmm7, zmm22, xmmword_ptr(rdx, -2048))); + TEST_INSTRUCTION("62F14D40F2BAF0F7FFFF" , vpslld(zmm7, zmm22, xmmword_ptr(rdx, -2064))); + TEST_INSTRUCTION("6201ED48F3EB" , vpsllq(zmm29, zmm2, xmm27)); + TEST_INSTRUCTION("6201ED4DF3EB" , k(k5).vpsllq(zmm29, zmm2, xmm27)); + TEST_INSTRUCTION("6201EDCDF3EB" , k(k5).z().vpsllq(zmm29, zmm2, xmm27)); + TEST_INSTRUCTION("6261ED48F329" , vpsllq(zmm29, zmm2, xmmword_ptr(rcx))); + TEST_INSTRUCTION("6221ED48F3ACF034120000" , vpsllq(zmm29, zmm2, xmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("6261ED48F36A7F" , vpsllq(zmm29, zmm2, xmmword_ptr(rdx, 2032))); + TEST_INSTRUCTION("6261ED48F3AA00080000" , vpsllq(zmm29, zmm2, xmmword_ptr(rdx, 2048))); + TEST_INSTRUCTION("6261ED48F36A80" , vpsllq(zmm29, zmm2, xmmword_ptr(rdx, -2048))); + TEST_INSTRUCTION("6261ED48F3AAF0F7FFFF" , vpsllq(zmm29, zmm2, xmmword_ptr(rdx, -2064))); + TEST_INSTRUCTION("6242654847EF" , vpsllvd(zmm29, zmm3, zmm15)); + TEST_INSTRUCTION("6242654F47EF" , k(k7).vpsllvd(zmm29, zmm3, zmm15)); + TEST_INSTRUCTION("624265CF47EF" , k(k7).z().vpsllvd(zmm29, zmm3, zmm15)); + TEST_INSTRUCTION("626265484729" , vpsllvd(zmm29, zmm3, zmmword_ptr(rcx))); + TEST_INSTRUCTION("6222654847ACF034120000" , vpsllvd(zmm29, zmm3, zmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("626265584729" , vpsllvd(zmm29, zmm3, dword_ptr(rcx)._1to16())); + TEST_INSTRUCTION("62626548476A7F" , vpsllvd(zmm29, zmm3, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("6262654847AA00200000" , vpsllvd(zmm29, zmm3, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62626548476A80" , vpsllvd(zmm29, zmm3, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("6262654847AAC0DFFFFF" , vpsllvd(zmm29, zmm3, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62626558476A7F" , vpsllvd(zmm29, zmm3, dword_ptr(rdx, 508)._1to16())); + TEST_INSTRUCTION("6262655847AA00020000" , vpsllvd(zmm29, zmm3, dword_ptr(rdx, 512)._1to16())); + TEST_INSTRUCTION("62626558476A80" , vpsllvd(zmm29, zmm3, dword_ptr(rdx, -512)._1to16())); + TEST_INSTRUCTION("6262655847AAFCFDFFFF" , vpsllvd(zmm29, zmm3, dword_ptr(rdx, -516)._1to16())); + TEST_INSTRUCTION("62D2954047E5" , vpsllvq(zmm4, zmm29, zmm13)); + TEST_INSTRUCTION("62D2954547E5" , k(k5).vpsllvq(zmm4, zmm29, zmm13)); + TEST_INSTRUCTION("62D295C547E5" , k(k5).z().vpsllvq(zmm4, zmm29, zmm13)); + TEST_INSTRUCTION("62F295404721" , vpsllvq(zmm4, zmm29, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62B2954047A4F034120000" , vpsllvq(zmm4, zmm29, zmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62F295504721" , vpsllvq(zmm4, zmm29, qword_ptr(rcx)._1to8())); + TEST_INSTRUCTION("62F2954047627F" , vpsllvq(zmm4, zmm29, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62F2954047A200200000" , vpsllvq(zmm4, zmm29, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62F29540476280" , vpsllvq(zmm4, zmm29, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62F2954047A2C0DFFFFF" , vpsllvq(zmm4, zmm29, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62F2955047627F" , vpsllvq(zmm4, zmm29, qword_ptr(rdx, 1016)._1to8())); + TEST_INSTRUCTION("62F2955047A200040000" , vpsllvq(zmm4, zmm29, qword_ptr(rdx, 1024)._1to8())); + TEST_INSTRUCTION("62F29550476280" , vpsllvq(zmm4, zmm29, qword_ptr(rdx, -1024)._1to8())); + TEST_INSTRUCTION("62F2955047A2F8FBFFFF" , vpsllvq(zmm4, zmm29, qword_ptr(rdx, -1032)._1to8())); + TEST_INSTRUCTION("62812D48E2D9" , vpsrad(zmm19, zmm10, xmm25)); + TEST_INSTRUCTION("62812D4AE2D9" , k(k2).vpsrad(zmm19, zmm10, xmm25)); + TEST_INSTRUCTION("62812DCAE2D9" , k(k2).z().vpsrad(zmm19, zmm10, xmm25)); + TEST_INSTRUCTION("62E12D48E219" , vpsrad(zmm19, zmm10, xmmword_ptr(rcx))); + TEST_INSTRUCTION("62A12D48E29CF034120000" , vpsrad(zmm19, zmm10, xmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62E12D48E25A7F" , vpsrad(zmm19, zmm10, xmmword_ptr(rdx, 2032))); + TEST_INSTRUCTION("62E12D48E29A00080000" , vpsrad(zmm19, zmm10, xmmword_ptr(rdx, 2048))); + TEST_INSTRUCTION("62E12D48E25A80" , vpsrad(zmm19, zmm10, xmmword_ptr(rdx, -2048))); + TEST_INSTRUCTION("62E12D48E29AF0F7FFFF" , vpsrad(zmm19, zmm10, xmmword_ptr(rdx, -2064))); + TEST_INSTRUCTION("62A1C540E2FA" , vpsraq(zmm23, zmm23, xmm18)); + TEST_INSTRUCTION("62A1C544E2FA" , k(k4).vpsraq(zmm23, zmm23, xmm18)); + TEST_INSTRUCTION("62A1C5C4E2FA" , k(k4).z().vpsraq(zmm23, zmm23, xmm18)); + TEST_INSTRUCTION("62E1C540E239" , vpsraq(zmm23, zmm23, xmmword_ptr(rcx))); + TEST_INSTRUCTION("62A1C540E2BCF034120000" , vpsraq(zmm23, zmm23, xmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62E1C540E27A7F" , vpsraq(zmm23, zmm23, xmmword_ptr(rdx, 2032))); + TEST_INSTRUCTION("62E1C540E2BA00080000" , vpsraq(zmm23, zmm23, xmmword_ptr(rdx, 2048))); + TEST_INSTRUCTION("62E1C540E27A80" , vpsraq(zmm23, zmm23, xmmword_ptr(rdx, -2048))); + TEST_INSTRUCTION("62E1C540E2BAF0F7FFFF" , vpsraq(zmm23, zmm23, xmmword_ptr(rdx, -2064))); + TEST_INSTRUCTION("62E2554846CE" , vpsravd(zmm17, zmm5, zmm6)); + TEST_INSTRUCTION("62E2554E46CE" , k(k6).vpsravd(zmm17, zmm5, zmm6)); + TEST_INSTRUCTION("62E255CE46CE" , k(k6).z().vpsravd(zmm17, zmm5, zmm6)); + TEST_INSTRUCTION("62E255484609" , vpsravd(zmm17, zmm5, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62A25548468CF034120000" , vpsravd(zmm17, zmm5, zmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62E255584609" , vpsravd(zmm17, zmm5, dword_ptr(rcx)._1to16())); + TEST_INSTRUCTION("62E25548464A7F" , vpsravd(zmm17, zmm5, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62E25548468A00200000" , vpsravd(zmm17, zmm5, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62E25548464A80" , vpsravd(zmm17, zmm5, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62E25548468AC0DFFFFF" , vpsravd(zmm17, zmm5, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62E25558464A7F" , vpsravd(zmm17, zmm5, dword_ptr(rdx, 508)._1to16())); + TEST_INSTRUCTION("62E25558468A00020000" , vpsravd(zmm17, zmm5, dword_ptr(rdx, 512)._1to16())); + TEST_INSTRUCTION("62E25558464A80" , vpsravd(zmm17, zmm5, dword_ptr(rdx, -512)._1to16())); + TEST_INSTRUCTION("62E25558468AFCFDFFFF" , vpsravd(zmm17, zmm5, dword_ptr(rdx, -516)._1to16())); + TEST_INSTRUCTION("6292BD4846DA" , vpsravq(zmm3, zmm8, zmm26)); + TEST_INSTRUCTION("6292BD4946DA" , k(k1).vpsravq(zmm3, zmm8, zmm26)); + TEST_INSTRUCTION("6292BDC946DA" , k(k1).z().vpsravq(zmm3, zmm8, zmm26)); + TEST_INSTRUCTION("62F2BD484619" , vpsravq(zmm3, zmm8, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62B2BD48469CF034120000" , vpsravq(zmm3, zmm8, zmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62F2BD584619" , vpsravq(zmm3, zmm8, qword_ptr(rcx)._1to8())); + TEST_INSTRUCTION("62F2BD48465A7F" , vpsravq(zmm3, zmm8, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62F2BD48469A00200000" , vpsravq(zmm3, zmm8, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62F2BD48465A80" , vpsravq(zmm3, zmm8, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62F2BD48469AC0DFFFFF" , vpsravq(zmm3, zmm8, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62F2BD58465A7F" , vpsravq(zmm3, zmm8, qword_ptr(rdx, 1016)._1to8())); + TEST_INSTRUCTION("62F2BD58469A00040000" , vpsravq(zmm3, zmm8, qword_ptr(rdx, 1024)._1to8())); + TEST_INSTRUCTION("62F2BD58465A80" , vpsravq(zmm3, zmm8, qword_ptr(rdx, -1024)._1to8())); + TEST_INSTRUCTION("62F2BD58469AF8FBFFFF" , vpsravq(zmm3, zmm8, qword_ptr(rdx, -1032)._1to8())); + TEST_INSTRUCTION("62216540D2CF" , vpsrld(zmm25, zmm19, xmm23)); + TEST_INSTRUCTION("62216546D2CF" , k(k6).vpsrld(zmm25, zmm19, xmm23)); + TEST_INSTRUCTION("622165C6D2CF" , k(k6).z().vpsrld(zmm25, zmm19, xmm23)); + TEST_INSTRUCTION("62616540D209" , vpsrld(zmm25, zmm19, xmmword_ptr(rcx))); + TEST_INSTRUCTION("62216540D28CF034120000" , vpsrld(zmm25, zmm19, xmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62616540D24A7F" , vpsrld(zmm25, zmm19, xmmword_ptr(rdx, 2032))); + TEST_INSTRUCTION("62616540D28A00080000" , vpsrld(zmm25, zmm19, xmmword_ptr(rdx, 2048))); + TEST_INSTRUCTION("62616540D24A80" , vpsrld(zmm25, zmm19, xmmword_ptr(rdx, -2048))); + TEST_INSTRUCTION("62616540D28AF0F7FFFF" , vpsrld(zmm25, zmm19, xmmword_ptr(rdx, -2064))); + TEST_INSTRUCTION("62A1AD48D3DD" , vpsrlq(zmm19, zmm10, xmm21)); + TEST_INSTRUCTION("62A1AD4CD3DD" , k(k4).vpsrlq(zmm19, zmm10, xmm21)); + TEST_INSTRUCTION("62A1ADCCD3DD" , k(k4).z().vpsrlq(zmm19, zmm10, xmm21)); + TEST_INSTRUCTION("62E1AD48D319" , vpsrlq(zmm19, zmm10, xmmword_ptr(rcx))); + TEST_INSTRUCTION("62A1AD48D39CF034120000" , vpsrlq(zmm19, zmm10, xmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62E1AD48D35A7F" , vpsrlq(zmm19, zmm10, xmmword_ptr(rdx, 2032))); + TEST_INSTRUCTION("62E1AD48D39A00080000" , vpsrlq(zmm19, zmm10, xmmword_ptr(rdx, 2048))); + TEST_INSTRUCTION("62E1AD48D35A80" , vpsrlq(zmm19, zmm10, xmmword_ptr(rdx, -2048))); + TEST_INSTRUCTION("62E1AD48D39AF0F7FFFF" , vpsrlq(zmm19, zmm10, xmmword_ptr(rdx, -2064))); + TEST_INSTRUCTION("62D25D4845D3" , vpsrlvd(zmm2, zmm4, zmm11)); + TEST_INSTRUCTION("62D25D4F45D3" , k(k7).vpsrlvd(zmm2, zmm4, zmm11)); + TEST_INSTRUCTION("62D25DCF45D3" , k(k7).z().vpsrlvd(zmm2, zmm4, zmm11)); + TEST_INSTRUCTION("62F25D484511" , vpsrlvd(zmm2, zmm4, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62B25D484594F034120000" , vpsrlvd(zmm2, zmm4, zmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62F25D584511" , vpsrlvd(zmm2, zmm4, dword_ptr(rcx)._1to16())); + TEST_INSTRUCTION("62F25D4845527F" , vpsrlvd(zmm2, zmm4, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62F25D48459200200000" , vpsrlvd(zmm2, zmm4, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62F25D48455280" , vpsrlvd(zmm2, zmm4, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62F25D484592C0DFFFFF" , vpsrlvd(zmm2, zmm4, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62F25D5845527F" , vpsrlvd(zmm2, zmm4, dword_ptr(rdx, 508)._1to16())); + TEST_INSTRUCTION("62F25D58459200020000" , vpsrlvd(zmm2, zmm4, dword_ptr(rdx, 512)._1to16())); + TEST_INSTRUCTION("62F25D58455280" , vpsrlvd(zmm2, zmm4, dword_ptr(rdx, -512)._1to16())); + TEST_INSTRUCTION("62F25D584592FCFDFFFF" , vpsrlvd(zmm2, zmm4, dword_ptr(rdx, -516)._1to16())); + TEST_INSTRUCTION("62529D4045C7" , vpsrlvq(zmm8, zmm28, zmm15)); + TEST_INSTRUCTION("62529D4545C7" , k(k5).vpsrlvq(zmm8, zmm28, zmm15)); + TEST_INSTRUCTION("62529DC545C7" , k(k5).z().vpsrlvq(zmm8, zmm28, zmm15)); + TEST_INSTRUCTION("62729D404501" , vpsrlvq(zmm8, zmm28, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62329D404584F034120000" , vpsrlvq(zmm8, zmm28, zmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62729D504501" , vpsrlvq(zmm8, zmm28, qword_ptr(rcx)._1to8())); + TEST_INSTRUCTION("62729D4045427F" , vpsrlvq(zmm8, zmm28, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62729D40458200200000" , vpsrlvq(zmm8, zmm28, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62729D40454280" , vpsrlvq(zmm8, zmm28, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62729D404582C0DFFFFF" , vpsrlvq(zmm8, zmm28, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62729D5045427F" , vpsrlvq(zmm8, zmm28, qword_ptr(rdx, 1016)._1to8())); + TEST_INSTRUCTION("62729D50458200040000" , vpsrlvq(zmm8, zmm28, qword_ptr(rdx, 1024)._1to8())); + TEST_INSTRUCTION("62729D50454280" , vpsrlvq(zmm8, zmm28, qword_ptr(rdx, -1024)._1to8())); + TEST_INSTRUCTION("62729D504582F8FBFFFF" , vpsrlvq(zmm8, zmm28, qword_ptr(rdx, -1032)._1to8())); + TEST_INSTRUCTION("62D1254872D1AB" , vpsrld(zmm11, zmm9, 171)); + TEST_INSTRUCTION("62D1254E72D1AB" , k(k6).vpsrld(zmm11, zmm9, 171)); + TEST_INSTRUCTION("62D125CE72D1AB" , k(k6).z().vpsrld(zmm11, zmm9, 171)); + TEST_INSTRUCTION("62D1254872D17B" , vpsrld(zmm11, zmm9, 123)); + TEST_INSTRUCTION("62F1254872117B" , vpsrld(zmm11, zmmword_ptr(rcx), 123)); + TEST_INSTRUCTION("62B125487294F0341200007B" , vpsrld(zmm11, zmmword_ptr(rax, r14, 3, 4660), 123)); + TEST_INSTRUCTION("62F1255872117B" , vpsrld(zmm11, dword_ptr(rcx)._1to16(), 123)); + TEST_INSTRUCTION("62F1254872527F7B" , vpsrld(zmm11, zmmword_ptr(rdx, 8128), 123)); + TEST_INSTRUCTION("62F125487292002000007B" , vpsrld(zmm11, zmmword_ptr(rdx, 8192), 123)); + TEST_INSTRUCTION("62F125487252807B" , vpsrld(zmm11, zmmword_ptr(rdx, -8192), 123)); + TEST_INSTRUCTION("62F125487292C0DFFFFF7B" , vpsrld(zmm11, zmmword_ptr(rdx, -8256), 123)); + TEST_INSTRUCTION("62F1255872527F7B" , vpsrld(zmm11, dword_ptr(rdx, 508)._1to16(), 123)); + TEST_INSTRUCTION("62F125587292000200007B" , vpsrld(zmm11, dword_ptr(rdx, 512)._1to16(), 123)); + TEST_INSTRUCTION("62F125587252807B" , vpsrld(zmm11, dword_ptr(rdx, -512)._1to16(), 123)); + TEST_INSTRUCTION("62F125587292FCFDFFFF7B" , vpsrld(zmm11, dword_ptr(rdx, -516)._1to16(), 123)); + TEST_INSTRUCTION("62D1CD4873D6AB" , vpsrlq(zmm6, zmm14, 171)); + TEST_INSTRUCTION("62D1CD4D73D6AB" , k(k5).vpsrlq(zmm6, zmm14, 171)); + TEST_INSTRUCTION("62D1CDCD73D6AB" , k(k5).z().vpsrlq(zmm6, zmm14, 171)); + TEST_INSTRUCTION("62D1CD4873D67B" , vpsrlq(zmm6, zmm14, 123)); + TEST_INSTRUCTION("62F1CD4873117B" , vpsrlq(zmm6, zmmword_ptr(rcx), 123)); + TEST_INSTRUCTION("62B1CD487394F0341200007B" , vpsrlq(zmm6, zmmword_ptr(rax, r14, 3, 4660), 123)); + TEST_INSTRUCTION("62F1CD5873117B" , vpsrlq(zmm6, qword_ptr(rcx)._1to8(), 123)); + TEST_INSTRUCTION("62F1CD4873527F7B" , vpsrlq(zmm6, zmmword_ptr(rdx, 8128), 123)); + TEST_INSTRUCTION("62F1CD487392002000007B" , vpsrlq(zmm6, zmmword_ptr(rdx, 8192), 123)); + TEST_INSTRUCTION("62F1CD487352807B" , vpsrlq(zmm6, zmmword_ptr(rdx, -8192), 123)); + TEST_INSTRUCTION("62F1CD487392C0DFFFFF7B" , vpsrlq(zmm6, zmmword_ptr(rdx, -8256), 123)); + TEST_INSTRUCTION("62F1CD5873527F7B" , vpsrlq(zmm6, qword_ptr(rdx, 1016)._1to8(), 123)); + TEST_INSTRUCTION("62F1CD587392000400007B" , vpsrlq(zmm6, qword_ptr(rdx, 1024)._1to8(), 123)); + TEST_INSTRUCTION("62F1CD587352807B" , vpsrlq(zmm6, qword_ptr(rdx, -1024)._1to8(), 123)); + TEST_INSTRUCTION("62F1CD587392F8FBFFFF7B" , vpsrlq(zmm6, qword_ptr(rdx, -1032)._1to8(), 123)); + TEST_INSTRUCTION("62210D48FAD7" , vpsubd(zmm26, zmm14, zmm23)); + TEST_INSTRUCTION("62210D4FFAD7" , k(k7).vpsubd(zmm26, zmm14, zmm23)); + TEST_INSTRUCTION("62210DCFFAD7" , k(k7).z().vpsubd(zmm26, zmm14, zmm23)); + TEST_INSTRUCTION("62610D48FA11" , vpsubd(zmm26, zmm14, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62210D48FA94F034120000" , vpsubd(zmm26, zmm14, zmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62610D58FA11" , vpsubd(zmm26, zmm14, dword_ptr(rcx)._1to16())); + TEST_INSTRUCTION("62610D48FA527F" , vpsubd(zmm26, zmm14, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62610D48FA9200200000" , vpsubd(zmm26, zmm14, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62610D48FA5280" , vpsubd(zmm26, zmm14, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62610D48FA92C0DFFFFF" , vpsubd(zmm26, zmm14, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62610D58FA527F" , vpsubd(zmm26, zmm14, dword_ptr(rdx, 508)._1to16())); + TEST_INSTRUCTION("62610D58FA9200020000" , vpsubd(zmm26, zmm14, dword_ptr(rdx, 512)._1to16())); + TEST_INSTRUCTION("62610D58FA5280" , vpsubd(zmm26, zmm14, dword_ptr(rdx, -512)._1to16())); + TEST_INSTRUCTION("62610D58FA92FCFDFFFF" , vpsubd(zmm26, zmm14, dword_ptr(rdx, -516)._1to16())); + TEST_INSTRUCTION("62A1BD48FBC7" , vpsubq(zmm16, zmm8, zmm23)); + TEST_INSTRUCTION("62A1BD4FFBC7" , k(k7).vpsubq(zmm16, zmm8, zmm23)); + TEST_INSTRUCTION("62A1BDCFFBC7" , k(k7).z().vpsubq(zmm16, zmm8, zmm23)); + TEST_INSTRUCTION("62E1BD48FB01" , vpsubq(zmm16, zmm8, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62A1BD48FB84F034120000" , vpsubq(zmm16, zmm8, zmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62E1BD58FB01" , vpsubq(zmm16, zmm8, qword_ptr(rcx)._1to8())); + TEST_INSTRUCTION("62E1BD48FB427F" , vpsubq(zmm16, zmm8, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62E1BD48FB8200200000" , vpsubq(zmm16, zmm8, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62E1BD48FB4280" , vpsubq(zmm16, zmm8, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62E1BD48FB82C0DFFFFF" , vpsubq(zmm16, zmm8, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62E1BD58FB427F" , vpsubq(zmm16, zmm8, qword_ptr(rdx, 1016)._1to8())); + TEST_INSTRUCTION("62E1BD58FB8200040000" , vpsubq(zmm16, zmm8, qword_ptr(rdx, 1024)._1to8())); + TEST_INSTRUCTION("62E1BD58FB4280" , vpsubq(zmm16, zmm8, qword_ptr(rdx, -1024)._1to8())); + TEST_INSTRUCTION("62E1BD58FB82F8FBFFFF" , vpsubq(zmm16, zmm8, qword_ptr(rdx, -1032)._1to8())); + TEST_INSTRUCTION("62923D4027D0" , vptestmd(k2, zmm24, zmm24)); + TEST_INSTRUCTION("62923D4227D0" , k(k2).vptestmd(k2, zmm24, zmm24)); + TEST_INSTRUCTION("62F23D402711" , vptestmd(k2, zmm24, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62B23D402794F034120000" , vptestmd(k2, zmm24, zmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62F23D502711" , vptestmd(k2, zmm24, dword_ptr(rcx)._1to16())); + TEST_INSTRUCTION("62F23D4027527F" , vptestmd(k2, zmm24, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62F23D40279200200000" , vptestmd(k2, zmm24, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62F23D40275280" , vptestmd(k2, zmm24, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62F23D402792C0DFFFFF" , vptestmd(k2, zmm24, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62F23D5027527F" , vptestmd(k2, zmm24, dword_ptr(rdx, 508)._1to16())); + TEST_INSTRUCTION("62F23D50279200020000" , vptestmd(k2, zmm24, dword_ptr(rdx, 512)._1to16())); + TEST_INSTRUCTION("62F23D50275280" , vptestmd(k2, zmm24, dword_ptr(rdx, -512)._1to16())); + TEST_INSTRUCTION("62F23D502792FCFDFFFF" , vptestmd(k2, zmm24, dword_ptr(rdx, -516)._1to16())); + TEST_INSTRUCTION("62B2854827E4" , vptestmq(k4, zmm15, zmm20)); + TEST_INSTRUCTION("62B2854A27E4" , k(k2).vptestmq(k4, zmm15, zmm20)); + TEST_INSTRUCTION("62F285482721" , vptestmq(k4, zmm15, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62B2854827A4F034120000" , vptestmq(k4, zmm15, zmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62F285582721" , vptestmq(k4, zmm15, qword_ptr(rcx)._1to8())); + TEST_INSTRUCTION("62F2854827627F" , vptestmq(k4, zmm15, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62F2854827A200200000" , vptestmq(k4, zmm15, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62F28548276280" , vptestmq(k4, zmm15, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62F2854827A2C0DFFFFF" , vptestmq(k4, zmm15, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62F2855827627F" , vptestmq(k4, zmm15, qword_ptr(rdx, 1016)._1to8())); + TEST_INSTRUCTION("62F2855827A200040000" , vptestmq(k4, zmm15, qword_ptr(rdx, 1024)._1to8())); + TEST_INSTRUCTION("62F28558276280" , vptestmq(k4, zmm15, qword_ptr(rdx, -1024)._1to8())); + TEST_INSTRUCTION("62F2855827A2F8FBFFFF" , vptestmq(k4, zmm15, qword_ptr(rdx, -1032)._1to8())); + TEST_INSTRUCTION("62714D486ADF" , vpunpckhdq(zmm11, zmm6, zmm7)); + TEST_INSTRUCTION("62714D4B6ADF" , k(k3).vpunpckhdq(zmm11, zmm6, zmm7)); + TEST_INSTRUCTION("62714DCB6ADF" , k(k3).z().vpunpckhdq(zmm11, zmm6, zmm7)); + TEST_INSTRUCTION("62714D486A19" , vpunpckhdq(zmm11, zmm6, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62314D486A9CF034120000" , vpunpckhdq(zmm11, zmm6, zmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62714D586A19" , vpunpckhdq(zmm11, zmm6, dword_ptr(rcx)._1to16())); + TEST_INSTRUCTION("62714D486A5A7F" , vpunpckhdq(zmm11, zmm6, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62714D486A9A00200000" , vpunpckhdq(zmm11, zmm6, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62714D486A5A80" , vpunpckhdq(zmm11, zmm6, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62714D486A9AC0DFFFFF" , vpunpckhdq(zmm11, zmm6, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62714D586A5A7F" , vpunpckhdq(zmm11, zmm6, dword_ptr(rdx, 508)._1to16())); + TEST_INSTRUCTION("62714D586A9A00020000" , vpunpckhdq(zmm11, zmm6, dword_ptr(rdx, 512)._1to16())); + TEST_INSTRUCTION("62714D586A5A80" , vpunpckhdq(zmm11, zmm6, dword_ptr(rdx, -512)._1to16())); + TEST_INSTRUCTION("62714D586A9AFCFDFFFF" , vpunpckhdq(zmm11, zmm6, dword_ptr(rdx, -516)._1to16())); + TEST_INSTRUCTION("6211CD486DC2" , vpunpckhqdq(zmm8, zmm6, zmm26)); + TEST_INSTRUCTION("6211CD4E6DC2" , k(k6).vpunpckhqdq(zmm8, zmm6, zmm26)); + TEST_INSTRUCTION("6211CDCE6DC2" , k(k6).z().vpunpckhqdq(zmm8, zmm6, zmm26)); + TEST_INSTRUCTION("6271CD486D01" , vpunpckhqdq(zmm8, zmm6, zmmword_ptr(rcx))); + TEST_INSTRUCTION("6231CD486D84F034120000" , vpunpckhqdq(zmm8, zmm6, zmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("6271CD586D01" , vpunpckhqdq(zmm8, zmm6, qword_ptr(rcx)._1to8())); + TEST_INSTRUCTION("6271CD486D427F" , vpunpckhqdq(zmm8, zmm6, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("6271CD486D8200200000" , vpunpckhqdq(zmm8, zmm6, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("6271CD486D4280" , vpunpckhqdq(zmm8, zmm6, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("6271CD486D82C0DFFFFF" , vpunpckhqdq(zmm8, zmm6, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("6271CD586D427F" , vpunpckhqdq(zmm8, zmm6, qword_ptr(rdx, 1016)._1to8())); + TEST_INSTRUCTION("6271CD586D8200040000" , vpunpckhqdq(zmm8, zmm6, qword_ptr(rdx, 1024)._1to8())); + TEST_INSTRUCTION("6271CD586D4280" , vpunpckhqdq(zmm8, zmm6, qword_ptr(rdx, -1024)._1to8())); + TEST_INSTRUCTION("6271CD586D82F8FBFFFF" , vpunpckhqdq(zmm8, zmm6, qword_ptr(rdx, -1032)._1to8())); + TEST_INSTRUCTION("62C16D4062C5" , vpunpckldq(zmm16, zmm18, zmm13)); + TEST_INSTRUCTION("62C16D4762C5" , k(k7).vpunpckldq(zmm16, zmm18, zmm13)); + TEST_INSTRUCTION("62C16DC762C5" , k(k7).z().vpunpckldq(zmm16, zmm18, zmm13)); + TEST_INSTRUCTION("62E16D406201" , vpunpckldq(zmm16, zmm18, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62A16D406284F034120000" , vpunpckldq(zmm16, zmm18, zmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62E16D506201" , vpunpckldq(zmm16, zmm18, dword_ptr(rcx)._1to16())); + TEST_INSTRUCTION("62E16D4062427F" , vpunpckldq(zmm16, zmm18, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62E16D40628200200000" , vpunpckldq(zmm16, zmm18, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62E16D40624280" , vpunpckldq(zmm16, zmm18, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62E16D406282C0DFFFFF" , vpunpckldq(zmm16, zmm18, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62E16D5062427F" , vpunpckldq(zmm16, zmm18, dword_ptr(rdx, 508)._1to16())); + TEST_INSTRUCTION("62E16D50628200020000" , vpunpckldq(zmm16, zmm18, dword_ptr(rdx, 512)._1to16())); + TEST_INSTRUCTION("62E16D50624280" , vpunpckldq(zmm16, zmm18, dword_ptr(rdx, -512)._1to16())); + TEST_INSTRUCTION("62E16D506282FCFDFFFF" , vpunpckldq(zmm16, zmm18, dword_ptr(rdx, -516)._1to16())); + TEST_INSTRUCTION("62C1FD406CC9" , vpunpcklqdq(zmm17, zmm16, zmm9)); + TEST_INSTRUCTION("62C1FD456CC9" , k(k5).vpunpcklqdq(zmm17, zmm16, zmm9)); + TEST_INSTRUCTION("62C1FDC56CC9" , k(k5).z().vpunpcklqdq(zmm17, zmm16, zmm9)); + TEST_INSTRUCTION("62E1FD406C09" , vpunpcklqdq(zmm17, zmm16, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62A1FD406C8CF034120000" , vpunpcklqdq(zmm17, zmm16, zmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62E1FD506C09" , vpunpcklqdq(zmm17, zmm16, qword_ptr(rcx)._1to8())); + TEST_INSTRUCTION("62E1FD406C4A7F" , vpunpcklqdq(zmm17, zmm16, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62E1FD406C8A00200000" , vpunpcklqdq(zmm17, zmm16, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62E1FD406C4A80" , vpunpcklqdq(zmm17, zmm16, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62E1FD406C8AC0DFFFFF" , vpunpcklqdq(zmm17, zmm16, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62E1FD506C4A7F" , vpunpcklqdq(zmm17, zmm16, qword_ptr(rdx, 1016)._1to8())); + TEST_INSTRUCTION("62E1FD506C8A00040000" , vpunpcklqdq(zmm17, zmm16, qword_ptr(rdx, 1024)._1to8())); + TEST_INSTRUCTION("62E1FD506C4A80" , vpunpcklqdq(zmm17, zmm16, qword_ptr(rdx, -1024)._1to8())); + TEST_INSTRUCTION("62E1FD506C8AF8FBFFFF" , vpunpcklqdq(zmm17, zmm16, qword_ptr(rdx, -1032)._1to8())); + TEST_INSTRUCTION("62916548EFE9" , vpxord(zmm5, zmm3, zmm25)); + TEST_INSTRUCTION("6291654BEFE9" , k(k3).vpxord(zmm5, zmm3, zmm25)); + TEST_INSTRUCTION("629165CBEFE9" , k(k3).z().vpxord(zmm5, zmm3, zmm25)); + TEST_INSTRUCTION("62F16548EF29" , vpxord(zmm5, zmm3, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62B16548EFACF034120000" , vpxord(zmm5, zmm3, zmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62F16558EF29" , vpxord(zmm5, zmm3, dword_ptr(rcx)._1to16())); + TEST_INSTRUCTION("62F16548EF6A7F" , vpxord(zmm5, zmm3, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62F16548EFAA00200000" , vpxord(zmm5, zmm3, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62F16548EF6A80" , vpxord(zmm5, zmm3, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62F16548EFAAC0DFFFFF" , vpxord(zmm5, zmm3, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62F16558EF6A7F" , vpxord(zmm5, zmm3, dword_ptr(rdx, 508)._1to16())); + TEST_INSTRUCTION("62F16558EFAA00020000" , vpxord(zmm5, zmm3, dword_ptr(rdx, 512)._1to16())); + TEST_INSTRUCTION("62F16558EF6A80" , vpxord(zmm5, zmm3, dword_ptr(rdx, -512)._1to16())); + TEST_INSTRUCTION("62F16558EFAAFCFDFFFF" , vpxord(zmm5, zmm3, dword_ptr(rdx, -516)._1to16())); + TEST_INSTRUCTION("6231DD48EFD2" , vpxorq(zmm10, zmm4, zmm18)); + TEST_INSTRUCTION("6231DD4CEFD2" , k(k4).vpxorq(zmm10, zmm4, zmm18)); + TEST_INSTRUCTION("6231DDCCEFD2" , k(k4).z().vpxorq(zmm10, zmm4, zmm18)); + TEST_INSTRUCTION("6271DD48EF11" , vpxorq(zmm10, zmm4, zmmword_ptr(rcx))); + TEST_INSTRUCTION("6231DD48EF94F034120000" , vpxorq(zmm10, zmm4, zmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("6271DD58EF11" , vpxorq(zmm10, zmm4, qword_ptr(rcx)._1to8())); + TEST_INSTRUCTION("6271DD48EF527F" , vpxorq(zmm10, zmm4, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("6271DD48EF9200200000" , vpxorq(zmm10, zmm4, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("6271DD48EF5280" , vpxorq(zmm10, zmm4, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("6271DD48EF92C0DFFFFF" , vpxorq(zmm10, zmm4, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("6271DD58EF527F" , vpxorq(zmm10, zmm4, qword_ptr(rdx, 1016)._1to8())); + TEST_INSTRUCTION("6271DD58EF9200040000" , vpxorq(zmm10, zmm4, qword_ptr(rdx, 1024)._1to8())); + TEST_INSTRUCTION("6271DD58EF5280" , vpxorq(zmm10, zmm4, qword_ptr(rdx, -1024)._1to8())); + TEST_INSTRUCTION("6271DD58EF92F8FBFFFF" , vpxorq(zmm10, zmm4, qword_ptr(rdx, -1032)._1to8())); + TEST_INSTRUCTION("6242FD484CD2" , vrcp14pd(zmm26, zmm10)); + TEST_INSTRUCTION("6242FD4E4CD2" , k(k6).vrcp14pd(zmm26, zmm10)); + TEST_INSTRUCTION("6242FDCE4CD2" , k(k6).z().vrcp14pd(zmm26, zmm10)); + TEST_INSTRUCTION("6262FD484C11" , vrcp14pd(zmm26, zmmword_ptr(rcx))); + TEST_INSTRUCTION("6222FD484C94F034120000" , vrcp14pd(zmm26, zmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("6262FD584C11" , vrcp14pd(zmm26, qword_ptr(rcx)._1to8())); + TEST_INSTRUCTION("6262FD484C527F" , vrcp14pd(zmm26, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("6262FD484C9200200000" , vrcp14pd(zmm26, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("6262FD484C5280" , vrcp14pd(zmm26, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("6262FD484C92C0DFFFFF" , vrcp14pd(zmm26, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("6262FD584C527F" , vrcp14pd(zmm26, qword_ptr(rdx, 1016)._1to8())); + TEST_INSTRUCTION("6262FD584C9200040000" , vrcp14pd(zmm26, qword_ptr(rdx, 1024)._1to8())); + TEST_INSTRUCTION("6262FD584C5280" , vrcp14pd(zmm26, qword_ptr(rdx, -1024)._1to8())); + TEST_INSTRUCTION("6262FD584C92F8FBFFFF" , vrcp14pd(zmm26, qword_ptr(rdx, -1032)._1to8())); + TEST_INSTRUCTION("62927D484CDB" , vrcp14ps(zmm3, zmm27)); + TEST_INSTRUCTION("62927D4D4CDB" , k(k5).vrcp14ps(zmm3, zmm27)); + TEST_INSTRUCTION("62927DCD4CDB" , k(k5).z().vrcp14ps(zmm3, zmm27)); + TEST_INSTRUCTION("62F27D484C19" , vrcp14ps(zmm3, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62B27D484C9CF034120000" , vrcp14ps(zmm3, zmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62F27D584C19" , vrcp14ps(zmm3, dword_ptr(rcx)._1to16())); + TEST_INSTRUCTION("62F27D484C5A7F" , vrcp14ps(zmm3, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62F27D484C9A00200000" , vrcp14ps(zmm3, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62F27D484C5A80" , vrcp14ps(zmm3, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62F27D484C9AC0DFFFFF" , vrcp14ps(zmm3, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62F27D584C5A7F" , vrcp14ps(zmm3, dword_ptr(rdx, 508)._1to16())); + TEST_INSTRUCTION("62F27D584C9A00020000" , vrcp14ps(zmm3, dword_ptr(rdx, 512)._1to16())); + TEST_INSTRUCTION("62F27D584C5A80" , vrcp14ps(zmm3, dword_ptr(rdx, -512)._1to16())); + TEST_INSTRUCTION("62F27D584C9AFCFDFFFF" , vrcp14ps(zmm3, dword_ptr(rdx, -516)._1to16())); + TEST_INSTRUCTION("6272CD084DF7" , vrcp14sd(xmm14, xmm6, xmm7)); + TEST_INSTRUCTION("6272CD094DF7" , k(k1).vrcp14sd(xmm14, xmm6, xmm7)); + TEST_INSTRUCTION("6272CD894DF7" , k(k1).z().vrcp14sd(xmm14, xmm6, xmm7)); + TEST_INSTRUCTION("6272CD084D31" , vrcp14sd(xmm14, xmm6, qword_ptr(rcx))); + TEST_INSTRUCTION("6232CD084DB4F034120000" , vrcp14sd(xmm14, xmm6, qword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("6272CD084D727F" , vrcp14sd(xmm14, xmm6, qword_ptr(rdx, 1016))); + TEST_INSTRUCTION("6272CD084DB200040000" , vrcp14sd(xmm14, xmm6, qword_ptr(rdx, 1024))); + TEST_INSTRUCTION("6272CD084D7280" , vrcp14sd(xmm14, xmm6, qword_ptr(rdx, -1024))); + TEST_INSTRUCTION("6272CD084DB2F8FBFFFF" , vrcp14sd(xmm14, xmm6, qword_ptr(rdx, -1032))); + TEST_INSTRUCTION("622275084DCD" , vrcp14ss(xmm25, xmm1, xmm21)); + TEST_INSTRUCTION("6222750A4DCD" , k(k2).vrcp14ss(xmm25, xmm1, xmm21)); + TEST_INSTRUCTION("6222758A4DCD" , k(k2).z().vrcp14ss(xmm25, xmm1, xmm21)); + TEST_INSTRUCTION("626275084D09" , vrcp14ss(xmm25, xmm1, dword_ptr(rcx))); + TEST_INSTRUCTION("622275084D8CF034120000" , vrcp14ss(xmm25, xmm1, dword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("626275084D4A7F" , vrcp14ss(xmm25, xmm1, dword_ptr(rdx, 508))); + TEST_INSTRUCTION("626275084D8A00020000" , vrcp14ss(xmm25, xmm1, dword_ptr(rdx, 512))); + TEST_INSTRUCTION("626275084D4A80" , vrcp14ss(xmm25, xmm1, dword_ptr(rdx, -512))); + TEST_INSTRUCTION("626275084D8AFCFDFFFF" , vrcp14ss(xmm25, xmm1, dword_ptr(rdx, -516))); + TEST_INSTRUCTION("6272FD484EF4" , vrsqrt14pd(zmm14, zmm4)); + TEST_INSTRUCTION("6272FD4F4EF4" , k(k7).vrsqrt14pd(zmm14, zmm4)); + TEST_INSTRUCTION("6272FDCF4EF4" , k(k7).z().vrsqrt14pd(zmm14, zmm4)); + TEST_INSTRUCTION("6272FD484E31" , vrsqrt14pd(zmm14, zmmword_ptr(rcx))); + TEST_INSTRUCTION("6232FD484EB4F034120000" , vrsqrt14pd(zmm14, zmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("6272FD584E31" , vrsqrt14pd(zmm14, qword_ptr(rcx)._1to8())); + TEST_INSTRUCTION("6272FD484E727F" , vrsqrt14pd(zmm14, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("6272FD484EB200200000" , vrsqrt14pd(zmm14, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("6272FD484E7280" , vrsqrt14pd(zmm14, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("6272FD484EB2C0DFFFFF" , vrsqrt14pd(zmm14, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("6272FD584E727F" , vrsqrt14pd(zmm14, qword_ptr(rdx, 1016)._1to8())); + TEST_INSTRUCTION("6272FD584EB200040000" , vrsqrt14pd(zmm14, qword_ptr(rdx, 1024)._1to8())); + TEST_INSTRUCTION("6272FD584E7280" , vrsqrt14pd(zmm14, qword_ptr(rdx, -1024)._1to8())); + TEST_INSTRUCTION("6272FD584EB2F8FBFFFF" , vrsqrt14pd(zmm14, qword_ptr(rdx, -1032)._1to8())); + TEST_INSTRUCTION("62927D484ED9" , vrsqrt14ps(zmm3, zmm25)); + TEST_INSTRUCTION("62927D4B4ED9" , k(k3).vrsqrt14ps(zmm3, zmm25)); + TEST_INSTRUCTION("62927DCB4ED9" , k(k3).z().vrsqrt14ps(zmm3, zmm25)); + TEST_INSTRUCTION("62F27D484E19" , vrsqrt14ps(zmm3, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62B27D484E9CF034120000" , vrsqrt14ps(zmm3, zmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62F27D584E19" , vrsqrt14ps(zmm3, dword_ptr(rcx)._1to16())); + TEST_INSTRUCTION("62F27D484E5A7F" , vrsqrt14ps(zmm3, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62F27D484E9A00200000" , vrsqrt14ps(zmm3, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62F27D484E5A80" , vrsqrt14ps(zmm3, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62F27D484E9AC0DFFFFF" , vrsqrt14ps(zmm3, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62F27D584E5A7F" , vrsqrt14ps(zmm3, dword_ptr(rdx, 508)._1to16())); + TEST_INSTRUCTION("62F27D584E9A00020000" , vrsqrt14ps(zmm3, dword_ptr(rdx, 512)._1to16())); + TEST_INSTRUCTION("62F27D584E5A80" , vrsqrt14ps(zmm3, dword_ptr(rdx, -512)._1to16())); + TEST_INSTRUCTION("62F27D584E9AFCFDFFFF" , vrsqrt14ps(zmm3, dword_ptr(rdx, -516)._1to16())); + TEST_INSTRUCTION("62F2D5004FCB" , vrsqrt14sd(xmm1, xmm21, xmm3)); + TEST_INSTRUCTION("62F2D5024FCB" , k(k2).vrsqrt14sd(xmm1, xmm21, xmm3)); + TEST_INSTRUCTION("62F2D5824FCB" , k(k2).z().vrsqrt14sd(xmm1, xmm21, xmm3)); + TEST_INSTRUCTION("62F2D5004F09" , vrsqrt14sd(xmm1, xmm21, qword_ptr(rcx))); + TEST_INSTRUCTION("62B2D5004F8CF034120000" , vrsqrt14sd(xmm1, xmm21, qword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62F2D5004F4A7F" , vrsqrt14sd(xmm1, xmm21, qword_ptr(rdx, 1016))); + TEST_INSTRUCTION("62F2D5004F8A00040000" , vrsqrt14sd(xmm1, xmm21, qword_ptr(rdx, 1024))); + TEST_INSTRUCTION("62F2D5004F4A80" , vrsqrt14sd(xmm1, xmm21, qword_ptr(rdx, -1024))); + TEST_INSTRUCTION("62F2D5004F8AF8FBFFFF" , vrsqrt14sd(xmm1, xmm21, qword_ptr(rdx, -1032))); + TEST_INSTRUCTION("62A22D004FDA" , vrsqrt14ss(xmm19, xmm26, xmm18)); + TEST_INSTRUCTION("62A22D034FDA" , k(k3).vrsqrt14ss(xmm19, xmm26, xmm18)); + TEST_INSTRUCTION("62A22D834FDA" , k(k3).z().vrsqrt14ss(xmm19, xmm26, xmm18)); + TEST_INSTRUCTION("62E22D004F19" , vrsqrt14ss(xmm19, xmm26, dword_ptr(rcx))); + TEST_INSTRUCTION("62A22D004F9CF034120000" , vrsqrt14ss(xmm19, xmm26, dword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62E22D004F5A7F" , vrsqrt14ss(xmm19, xmm26, dword_ptr(rdx, 508))); + TEST_INSTRUCTION("62E22D004F9A00020000" , vrsqrt14ss(xmm19, xmm26, dword_ptr(rdx, 512))); + TEST_INSTRUCTION("62E22D004F5A80" , vrsqrt14ss(xmm19, xmm26, dword_ptr(rdx, -512))); + TEST_INSTRUCTION("62E22D004F9AFCFDFFFF" , vrsqrt14ss(xmm19, xmm26, dword_ptr(rdx, -516))); + TEST_INSTRUCTION("6291AD48C6C9AB" , vshufpd(zmm1, zmm10, zmm25, 171)); + TEST_INSTRUCTION("6291AD4BC6C9AB" , k(k3).vshufpd(zmm1, zmm10, zmm25, 171)); + TEST_INSTRUCTION("6291ADCBC6C9AB" , k(k3).z().vshufpd(zmm1, zmm10, zmm25, 171)); + TEST_INSTRUCTION("6291AD48C6C97B" , vshufpd(zmm1, zmm10, zmm25, 123)); + TEST_INSTRUCTION("62F1AD48C6097B" , vshufpd(zmm1, zmm10, zmmword_ptr(rcx), 123)); + TEST_INSTRUCTION("62B1AD48C68CF0341200007B" , vshufpd(zmm1, zmm10, zmmword_ptr(rax, r14, 3, 4660), 123)); + TEST_INSTRUCTION("62F1AD58C6097B" , vshufpd(zmm1, zmm10, qword_ptr(rcx)._1to8(), 123)); + TEST_INSTRUCTION("62F1AD48C64A7F7B" , vshufpd(zmm1, zmm10, zmmword_ptr(rdx, 8128), 123)); + TEST_INSTRUCTION("62F1AD48C68A002000007B" , vshufpd(zmm1, zmm10, zmmword_ptr(rdx, 8192), 123)); + TEST_INSTRUCTION("62F1AD48C64A807B" , vshufpd(zmm1, zmm10, zmmword_ptr(rdx, -8192), 123)); + TEST_INSTRUCTION("62F1AD48C68AC0DFFFFF7B" , vshufpd(zmm1, zmm10, zmmword_ptr(rdx, -8256), 123)); + TEST_INSTRUCTION("62F1AD58C64A7F7B" , vshufpd(zmm1, zmm10, qword_ptr(rdx, 1016)._1to8(), 123)); + TEST_INSTRUCTION("62F1AD58C68A000400007B" , vshufpd(zmm1, zmm10, qword_ptr(rdx, 1024)._1to8(), 123)); + TEST_INSTRUCTION("62F1AD58C64A807B" , vshufpd(zmm1, zmm10, qword_ptr(rdx, -1024)._1to8(), 123)); + TEST_INSTRUCTION("62F1AD58C68AF8FBFFFF7B" , vshufpd(zmm1, zmm10, qword_ptr(rdx, -1032)._1to8(), 123)); + TEST_INSTRUCTION("62917448C6C9AB" , vshufps(zmm1, zmm1, zmm25, 171)); + TEST_INSTRUCTION("62917449C6C9AB" , k(k1).vshufps(zmm1, zmm1, zmm25, 171)); + TEST_INSTRUCTION("629174C9C6C9AB" , k(k1).z().vshufps(zmm1, zmm1, zmm25, 171)); + TEST_INSTRUCTION("62917448C6C97B" , vshufps(zmm1, zmm1, zmm25, 123)); + TEST_INSTRUCTION("62F17448C6097B" , vshufps(zmm1, zmm1, zmmword_ptr(rcx), 123)); + TEST_INSTRUCTION("62B17448C68CF0341200007B" , vshufps(zmm1, zmm1, zmmword_ptr(rax, r14, 3, 4660), 123)); + TEST_INSTRUCTION("62F17458C6097B" , vshufps(zmm1, zmm1, dword_ptr(rcx)._1to16(), 123)); + TEST_INSTRUCTION("62F17448C64A7F7B" , vshufps(zmm1, zmm1, zmmword_ptr(rdx, 8128), 123)); + TEST_INSTRUCTION("62F17448C68A002000007B" , vshufps(zmm1, zmm1, zmmword_ptr(rdx, 8192), 123)); + TEST_INSTRUCTION("62F17448C64A807B" , vshufps(zmm1, zmm1, zmmword_ptr(rdx, -8192), 123)); + TEST_INSTRUCTION("62F17448C68AC0DFFFFF7B" , vshufps(zmm1, zmm1, zmmword_ptr(rdx, -8256), 123)); + TEST_INSTRUCTION("62F17458C64A7F7B" , vshufps(zmm1, zmm1, dword_ptr(rdx, 508)._1to16(), 123)); + TEST_INSTRUCTION("62F17458C68A000200007B" , vshufps(zmm1, zmm1, dword_ptr(rdx, 512)._1to16(), 123)); + TEST_INSTRUCTION("62F17458C64A807B" , vshufps(zmm1, zmm1, dword_ptr(rdx, -512)._1to16(), 123)); + TEST_INSTRUCTION("62F17458C68AFCFDFFFF7B" , vshufps(zmm1, zmm1, dword_ptr(rdx, -516)._1to16(), 123)); + TEST_INSTRUCTION("6271FD4851CD" , vsqrtpd(zmm9, zmm5)); + TEST_INSTRUCTION("6271FD4A51CD" , k(k2).vsqrtpd(zmm9, zmm5)); + TEST_INSTRUCTION("6271FDCA51CD" , k(k2).z().vsqrtpd(zmm9, zmm5)); + TEST_INSTRUCTION("6271FD1851CD" , rn_sae().vsqrtpd(zmm9, zmm5)); + TEST_INSTRUCTION("6271FD5851CD" , ru_sae().vsqrtpd(zmm9, zmm5)); + TEST_INSTRUCTION("6271FD3851CD" , rd_sae().vsqrtpd(zmm9, zmm5)); + TEST_INSTRUCTION("6271FD7851CD" , rz_sae().vsqrtpd(zmm9, zmm5)); + TEST_INSTRUCTION("6271FD485109" , vsqrtpd(zmm9, zmmword_ptr(rcx))); + TEST_INSTRUCTION("6231FD48518CF034120000" , vsqrtpd(zmm9, zmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("6271FD585109" , vsqrtpd(zmm9, qword_ptr(rcx)._1to8())); + TEST_INSTRUCTION("6271FD48514A7F" , vsqrtpd(zmm9, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("6271FD48518A00200000" , vsqrtpd(zmm9, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("6271FD48514A80" , vsqrtpd(zmm9, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("6271FD48518AC0DFFFFF" , vsqrtpd(zmm9, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("6271FD58514A7F" , vsqrtpd(zmm9, qword_ptr(rdx, 1016)._1to8())); + TEST_INSTRUCTION("6271FD58518A00040000" , vsqrtpd(zmm9, qword_ptr(rdx, 1024)._1to8())); + TEST_INSTRUCTION("6271FD58514A80" , vsqrtpd(zmm9, qword_ptr(rdx, -1024)._1to8())); + TEST_INSTRUCTION("6271FD58518AF8FBFFFF" , vsqrtpd(zmm9, qword_ptr(rdx, -1032)._1to8())); + TEST_INSTRUCTION("62B17C4851E7" , vsqrtps(zmm4, zmm23)); + TEST_INSTRUCTION("62B17C4E51E7" , k(k6).vsqrtps(zmm4, zmm23)); + TEST_INSTRUCTION("62B17CCE51E7" , k(k6).z().vsqrtps(zmm4, zmm23)); + TEST_INSTRUCTION("62B17C1851E7" , rn_sae().vsqrtps(zmm4, zmm23)); + TEST_INSTRUCTION("62B17C5851E7" , ru_sae().vsqrtps(zmm4, zmm23)); + TEST_INSTRUCTION("62B17C3851E7" , rd_sae().vsqrtps(zmm4, zmm23)); + TEST_INSTRUCTION("62B17C7851E7" , rz_sae().vsqrtps(zmm4, zmm23)); + TEST_INSTRUCTION("62F17C485121" , vsqrtps(zmm4, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62B17C4851A4F034120000" , vsqrtps(zmm4, zmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62F17C585121" , vsqrtps(zmm4, dword_ptr(rcx)._1to16())); + TEST_INSTRUCTION("62F17C4851627F" , vsqrtps(zmm4, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62F17C4851A200200000" , vsqrtps(zmm4, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62F17C48516280" , vsqrtps(zmm4, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62F17C4851A2C0DFFFFF" , vsqrtps(zmm4, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62F17C5851627F" , vsqrtps(zmm4, dword_ptr(rdx, 508)._1to16())); + TEST_INSTRUCTION("62F17C5851A200020000" , vsqrtps(zmm4, dword_ptr(rdx, 512)._1to16())); + TEST_INSTRUCTION("62F17C58516280" , vsqrtps(zmm4, dword_ptr(rdx, -512)._1to16())); + TEST_INSTRUCTION("62F17C5851A2FCFDFFFF" , vsqrtps(zmm4, dword_ptr(rdx, -516)._1to16())); + TEST_INSTRUCTION("6271BF0051C5" , vsqrtsd(xmm8, xmm24, xmm5)); + TEST_INSTRUCTION("6271BF0351C5" , k(k3).vsqrtsd(xmm8, xmm24, xmm5)); + TEST_INSTRUCTION("6271BF8351C5" , k(k3).z().vsqrtsd(xmm8, xmm24, xmm5)); + TEST_INSTRUCTION("6271BF1051C5" , rn_sae().vsqrtsd(xmm8, xmm24, xmm5)); + TEST_INSTRUCTION("6271BF5051C5" , ru_sae().vsqrtsd(xmm8, xmm24, xmm5)); + TEST_INSTRUCTION("6271BF3051C5" , rd_sae().vsqrtsd(xmm8, xmm24, xmm5)); + TEST_INSTRUCTION("6271BF7051C5" , rz_sae().vsqrtsd(xmm8, xmm24, xmm5)); + TEST_INSTRUCTION("6271BF005101" , vsqrtsd(xmm8, xmm24, qword_ptr(rcx))); + TEST_INSTRUCTION("6231BF005184F034120000" , vsqrtsd(xmm8, xmm24, qword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("6271BF0051427F" , vsqrtsd(xmm8, xmm24, qword_ptr(rdx, 1016))); + TEST_INSTRUCTION("6271BF00518200040000" , vsqrtsd(xmm8, xmm24, qword_ptr(rdx, 1024))); + TEST_INSTRUCTION("6271BF00514280" , vsqrtsd(xmm8, xmm24, qword_ptr(rdx, -1024))); + TEST_INSTRUCTION("6271BF005182F8FBFFFF" , vsqrtsd(xmm8, xmm24, qword_ptr(rdx, -1032))); + TEST_INSTRUCTION("62410E0851CB" , vsqrtss(xmm25, xmm14, xmm11)); + TEST_INSTRUCTION("62410E0F51CB" , k(k7).vsqrtss(xmm25, xmm14, xmm11)); + TEST_INSTRUCTION("62410E8F51CB" , k(k7).z().vsqrtss(xmm25, xmm14, xmm11)); + TEST_INSTRUCTION("62410E1851CB" , rn_sae().vsqrtss(xmm25, xmm14, xmm11)); + TEST_INSTRUCTION("62410E5851CB" , ru_sae().vsqrtss(xmm25, xmm14, xmm11)); + TEST_INSTRUCTION("62410E3851CB" , rd_sae().vsqrtss(xmm25, xmm14, xmm11)); + TEST_INSTRUCTION("62410E7851CB" , rz_sae().vsqrtss(xmm25, xmm14, xmm11)); + TEST_INSTRUCTION("62610E085109" , vsqrtss(xmm25, xmm14, dword_ptr(rcx))); + TEST_INSTRUCTION("62210E08518CF034120000" , vsqrtss(xmm25, xmm14, dword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62610E08514A7F" , vsqrtss(xmm25, xmm14, dword_ptr(rdx, 508))); + TEST_INSTRUCTION("62610E08518A00020000" , vsqrtss(xmm25, xmm14, dword_ptr(rdx, 512))); + TEST_INSTRUCTION("62610E08514A80" , vsqrtss(xmm25, xmm14, dword_ptr(rdx, -512))); + TEST_INSTRUCTION("62610E08518AFCFDFFFF" , vsqrtss(xmm25, xmm14, dword_ptr(rdx, -516))); + TEST_INSTRUCTION("62C19D405CE8" , vsubpd(zmm21, zmm28, zmm8)); + TEST_INSTRUCTION("62C19D415CE8" , k(k1).vsubpd(zmm21, zmm28, zmm8)); + TEST_INSTRUCTION("62C19DC15CE8" , k(k1).z().vsubpd(zmm21, zmm28, zmm8)); + TEST_INSTRUCTION("62C19D105CE8" , rn_sae().vsubpd(zmm21, zmm28, zmm8)); + TEST_INSTRUCTION("62C19D505CE8" , ru_sae().vsubpd(zmm21, zmm28, zmm8)); + TEST_INSTRUCTION("62C19D305CE8" , rd_sae().vsubpd(zmm21, zmm28, zmm8)); + TEST_INSTRUCTION("62C19D705CE8" , rz_sae().vsubpd(zmm21, zmm28, zmm8)); + TEST_INSTRUCTION("62E19D405C29" , vsubpd(zmm21, zmm28, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62A19D405CACF034120000" , vsubpd(zmm21, zmm28, zmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62E19D505C29" , vsubpd(zmm21, zmm28, qword_ptr(rcx)._1to8())); + TEST_INSTRUCTION("62E19D405C6A7F" , vsubpd(zmm21, zmm28, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62E19D405CAA00200000" , vsubpd(zmm21, zmm28, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62E19D405C6A80" , vsubpd(zmm21, zmm28, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62E19D405CAAC0DFFFFF" , vsubpd(zmm21, zmm28, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62E19D505C6A7F" , vsubpd(zmm21, zmm28, qword_ptr(rdx, 1016)._1to8())); + TEST_INSTRUCTION("62E19D505CAA00040000" , vsubpd(zmm21, zmm28, qword_ptr(rdx, 1024)._1to8())); + TEST_INSTRUCTION("62E19D505C6A80" , vsubpd(zmm21, zmm28, qword_ptr(rdx, -1024)._1to8())); + TEST_INSTRUCTION("62E19D505CAAF8FBFFFF" , vsubpd(zmm21, zmm28, qword_ptr(rdx, -1032)._1to8())); + TEST_INSTRUCTION("62E12C485CDD" , vsubps(zmm19, zmm10, zmm5)); + TEST_INSTRUCTION("62E12C4F5CDD" , k(k7).vsubps(zmm19, zmm10, zmm5)); + TEST_INSTRUCTION("62E12CCF5CDD" , k(k7).z().vsubps(zmm19, zmm10, zmm5)); + TEST_INSTRUCTION("62E12C185CDD" , rn_sae().vsubps(zmm19, zmm10, zmm5)); + TEST_INSTRUCTION("62E12C585CDD" , ru_sae().vsubps(zmm19, zmm10, zmm5)); + TEST_INSTRUCTION("62E12C385CDD" , rd_sae().vsubps(zmm19, zmm10, zmm5)); + TEST_INSTRUCTION("62E12C785CDD" , rz_sae().vsubps(zmm19, zmm10, zmm5)); + TEST_INSTRUCTION("62E12C485C19" , vsubps(zmm19, zmm10, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62A12C485C9CF034120000" , vsubps(zmm19, zmm10, zmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62E12C585C19" , vsubps(zmm19, zmm10, dword_ptr(rcx)._1to16())); + TEST_INSTRUCTION("62E12C485C5A7F" , vsubps(zmm19, zmm10, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62E12C485C9A00200000" , vsubps(zmm19, zmm10, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62E12C485C5A80" , vsubps(zmm19, zmm10, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62E12C485C9AC0DFFFFF" , vsubps(zmm19, zmm10, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62E12C585C5A7F" , vsubps(zmm19, zmm10, dword_ptr(rdx, 508)._1to16())); + TEST_INSTRUCTION("62E12C585C9A00020000" , vsubps(zmm19, zmm10, dword_ptr(rdx, 512)._1to16())); + TEST_INSTRUCTION("62E12C585C5A80" , vsubps(zmm19, zmm10, dword_ptr(rdx, -512)._1to16())); + TEST_INSTRUCTION("62E12C585C9AFCFDFFFF" , vsubps(zmm19, zmm10, dword_ptr(rdx, -516)._1to16())); + TEST_INSTRUCTION("6241C7005CC5" , vsubsd(xmm24, xmm23, xmm13)); + TEST_INSTRUCTION("6241C7075CC5" , k(k7).vsubsd(xmm24, xmm23, xmm13)); + TEST_INSTRUCTION("6241C7875CC5" , k(k7).z().vsubsd(xmm24, xmm23, xmm13)); + TEST_INSTRUCTION("6241C7105CC5" , rn_sae().vsubsd(xmm24, xmm23, xmm13)); + TEST_INSTRUCTION("6241C7505CC5" , ru_sae().vsubsd(xmm24, xmm23, xmm13)); + TEST_INSTRUCTION("6241C7305CC5" , rd_sae().vsubsd(xmm24, xmm23, xmm13)); + TEST_INSTRUCTION("6241C7705CC5" , rz_sae().vsubsd(xmm24, xmm23, xmm13)); + TEST_INSTRUCTION("6261C7005C01" , vsubsd(xmm24, xmm23, qword_ptr(rcx))); + TEST_INSTRUCTION("6221C7005C84F034120000" , vsubsd(xmm24, xmm23, qword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("6261C7005C427F" , vsubsd(xmm24, xmm23, qword_ptr(rdx, 1016))); + TEST_INSTRUCTION("6261C7005C8200040000" , vsubsd(xmm24, xmm23, qword_ptr(rdx, 1024))); + TEST_INSTRUCTION("6261C7005C4280" , vsubsd(xmm24, xmm23, qword_ptr(rdx, -1024))); + TEST_INSTRUCTION("6261C7005C82F8FBFFFF" , vsubsd(xmm24, xmm23, qword_ptr(rdx, -1032))); + TEST_INSTRUCTION("62215E005CD8" , vsubss(xmm27, xmm20, xmm16)); + TEST_INSTRUCTION("62215E065CD8" , k(k6).vsubss(xmm27, xmm20, xmm16)); + TEST_INSTRUCTION("62215E865CD8" , k(k6).z().vsubss(xmm27, xmm20, xmm16)); + TEST_INSTRUCTION("62215E105CD8" , rn_sae().vsubss(xmm27, xmm20, xmm16)); + TEST_INSTRUCTION("62215E505CD8" , ru_sae().vsubss(xmm27, xmm20, xmm16)); + TEST_INSTRUCTION("62215E305CD8" , rd_sae().vsubss(xmm27, xmm20, xmm16)); + TEST_INSTRUCTION("62215E705CD8" , rz_sae().vsubss(xmm27, xmm20, xmm16)); + TEST_INSTRUCTION("62615E005C19" , vsubss(xmm27, xmm20, dword_ptr(rcx))); + TEST_INSTRUCTION("62215E005C9CF034120000" , vsubss(xmm27, xmm20, dword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62615E005C5A7F" , vsubss(xmm27, xmm20, dword_ptr(rdx, 508))); + TEST_INSTRUCTION("62615E005C9A00020000" , vsubss(xmm27, xmm20, dword_ptr(rdx, 512))); + TEST_INSTRUCTION("62615E005C5A80" , vsubss(xmm27, xmm20, dword_ptr(rdx, -512))); + TEST_INSTRUCTION("62615E005C9AFCFDFFFF" , vsubss(xmm27, xmm20, dword_ptr(rdx, -516))); + TEST_INSTRUCTION("62A1FD082EEB" , vucomisd(xmm21, xmm19)); + TEST_INSTRUCTION("62A1FD182EEB" , sae().vucomisd(xmm21, xmm19)); + TEST_INSTRUCTION("62E1FD082E29" , vucomisd(xmm21, qword_ptr(rcx))); + TEST_INSTRUCTION("62A1FD082EACF034120000" , vucomisd(xmm21, qword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62E1FD082E6A7F" , vucomisd(xmm21, qword_ptr(rdx, 1016))); + TEST_INSTRUCTION("62E1FD082EAA00040000" , vucomisd(xmm21, qword_ptr(rdx, 1024))); + TEST_INSTRUCTION("62E1FD082E6A80" , vucomisd(xmm21, qword_ptr(rdx, -1024))); + TEST_INSTRUCTION("62E1FD082EAAF8FBFFFF" , vucomisd(xmm21, qword_ptr(rdx, -1032))); + TEST_INSTRUCTION("62017C082EDD" , vucomiss(xmm27, xmm29)); + TEST_INSTRUCTION("62017C182EDD" , sae().vucomiss(xmm27, xmm29)); + TEST_INSTRUCTION("62617C082E19" , vucomiss(xmm27, dword_ptr(rcx))); + TEST_INSTRUCTION("62217C082E9CF034120000" , vucomiss(xmm27, dword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62617C082E5A7F" , vucomiss(xmm27, dword_ptr(rdx, 508))); + TEST_INSTRUCTION("62617C082E9A00020000" , vucomiss(xmm27, dword_ptr(rdx, 512))); + TEST_INSTRUCTION("62617C082E5A80" , vucomiss(xmm27, dword_ptr(rdx, -512))); + TEST_INSTRUCTION("62617C082E9AFCFDFFFF" , vucomiss(xmm27, dword_ptr(rdx, -516))); + TEST_INSTRUCTION("62D1C54015F4" , vunpckhpd(zmm6, zmm23, zmm12)); + TEST_INSTRUCTION("62D1C54715F4" , k(k7).vunpckhpd(zmm6, zmm23, zmm12)); + TEST_INSTRUCTION("62D1C5C715F4" , k(k7).z().vunpckhpd(zmm6, zmm23, zmm12)); + TEST_INSTRUCTION("62F1C5401531" , vunpckhpd(zmm6, zmm23, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62B1C54015B4F034120000" , vunpckhpd(zmm6, zmm23, zmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62F1C5501531" , vunpckhpd(zmm6, zmm23, qword_ptr(rcx)._1to8())); + TEST_INSTRUCTION("62F1C54015727F" , vunpckhpd(zmm6, zmm23, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62F1C54015B200200000" , vunpckhpd(zmm6, zmm23, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62F1C540157280" , vunpckhpd(zmm6, zmm23, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62F1C54015B2C0DFFFFF" , vunpckhpd(zmm6, zmm23, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62F1C55015727F" , vunpckhpd(zmm6, zmm23, qword_ptr(rdx, 1016)._1to8())); + TEST_INSTRUCTION("62F1C55015B200040000" , vunpckhpd(zmm6, zmm23, qword_ptr(rdx, 1024)._1to8())); + TEST_INSTRUCTION("62F1C550157280" , vunpckhpd(zmm6, zmm23, qword_ptr(rdx, -1024)._1to8())); + TEST_INSTRUCTION("62F1C55015B2F8FBFFFF" , vunpckhpd(zmm6, zmm23, qword_ptr(rdx, -1032)._1to8())); + TEST_INSTRUCTION("62616C4815EC" , vunpckhps(zmm29, zmm2, zmm4)); + TEST_INSTRUCTION("62616C4C15EC" , k(k4).vunpckhps(zmm29, zmm2, zmm4)); + TEST_INSTRUCTION("62616CCC15EC" , k(k4).z().vunpckhps(zmm29, zmm2, zmm4)); + TEST_INSTRUCTION("62616C481529" , vunpckhps(zmm29, zmm2, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62216C4815ACF034120000" , vunpckhps(zmm29, zmm2, zmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62616C581529" , vunpckhps(zmm29, zmm2, dword_ptr(rcx)._1to16())); + TEST_INSTRUCTION("62616C48156A7F" , vunpckhps(zmm29, zmm2, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62616C4815AA00200000" , vunpckhps(zmm29, zmm2, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62616C48156A80" , vunpckhps(zmm29, zmm2, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62616C4815AAC0DFFFFF" , vunpckhps(zmm29, zmm2, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62616C58156A7F" , vunpckhps(zmm29, zmm2, dword_ptr(rdx, 508)._1to16())); + TEST_INSTRUCTION("62616C5815AA00020000" , vunpckhps(zmm29, zmm2, dword_ptr(rdx, 512)._1to16())); + TEST_INSTRUCTION("62616C58156A80" , vunpckhps(zmm29, zmm2, dword_ptr(rdx, -512)._1to16())); + TEST_INSTRUCTION("62616C5815AAFCFDFFFF" , vunpckhps(zmm29, zmm2, dword_ptr(rdx, -516)._1to16())); + TEST_INSTRUCTION("62C19D4014D0" , vunpcklpd(zmm18, zmm28, zmm8)); + TEST_INSTRUCTION("62C19D4114D0" , k(k1).vunpcklpd(zmm18, zmm28, zmm8)); + TEST_INSTRUCTION("62C19DC114D0" , k(k1).z().vunpcklpd(zmm18, zmm28, zmm8)); + TEST_INSTRUCTION("62E19D401411" , vunpcklpd(zmm18, zmm28, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62A19D401494F034120000" , vunpcklpd(zmm18, zmm28, zmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62E19D501411" , vunpcklpd(zmm18, zmm28, qword_ptr(rcx)._1to8())); + TEST_INSTRUCTION("62E19D4014527F" , vunpcklpd(zmm18, zmm28, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62E19D40149200200000" , vunpcklpd(zmm18, zmm28, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62E19D40145280" , vunpcklpd(zmm18, zmm28, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62E19D401492C0DFFFFF" , vunpcklpd(zmm18, zmm28, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62E19D5014527F" , vunpcklpd(zmm18, zmm28, qword_ptr(rdx, 1016)._1to8())); + TEST_INSTRUCTION("62E19D50149200040000" , vunpcklpd(zmm18, zmm28, qword_ptr(rdx, 1024)._1to8())); + TEST_INSTRUCTION("62E19D50145280" , vunpcklpd(zmm18, zmm28, qword_ptr(rdx, -1024)._1to8())); + TEST_INSTRUCTION("62E19D501492F8FBFFFF" , vunpcklpd(zmm18, zmm28, qword_ptr(rdx, -1032)._1to8())); + TEST_INSTRUCTION("62610C4814CE" , vunpcklps(zmm25, zmm14, zmm6)); + TEST_INSTRUCTION("62610C4E14CE" , k(k6).vunpcklps(zmm25, zmm14, zmm6)); + TEST_INSTRUCTION("62610CCE14CE" , k(k6).z().vunpcklps(zmm25, zmm14, zmm6)); + TEST_INSTRUCTION("62610C481409" , vunpcklps(zmm25, zmm14, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62210C48148CF034120000" , vunpcklps(zmm25, zmm14, zmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62610C581409" , vunpcklps(zmm25, zmm14, dword_ptr(rcx)._1to16())); + TEST_INSTRUCTION("62610C48144A7F" , vunpcklps(zmm25, zmm14, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62610C48148A00200000" , vunpcklps(zmm25, zmm14, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62610C48144A80" , vunpcklps(zmm25, zmm14, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62610C48148AC0DFFFFF" , vunpcklps(zmm25, zmm14, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62610C58144A7F" , vunpcklps(zmm25, zmm14, dword_ptr(rdx, 508)._1to16())); + TEST_INSTRUCTION("62610C58148A00020000" , vunpcklps(zmm25, zmm14, dword_ptr(rdx, 512)._1to16())); + TEST_INSTRUCTION("62610C58144A80" , vunpcklps(zmm25, zmm14, dword_ptr(rdx, -512)._1to16())); + TEST_INSTRUCTION("62610C58148AFCFDFFFF" , vunpcklps(zmm25, zmm14, dword_ptr(rdx, -516)._1to16())); + TEST_INSTRUCTION("6253154825D2AB" , vpternlogd(zmm10, zmm13, zmm10, 171)); + TEST_INSTRUCTION("6253154F25D2AB" , k(k7).vpternlogd(zmm10, zmm13, zmm10, 171)); + TEST_INSTRUCTION("625315CF25D2AB" , k(k7).z().vpternlogd(zmm10, zmm13, zmm10, 171)); + TEST_INSTRUCTION("6253154825D27B" , vpternlogd(zmm10, zmm13, zmm10, 123)); + TEST_INSTRUCTION("6273154825117B" , vpternlogd(zmm10, zmm13, zmmword_ptr(rcx), 123)); + TEST_INSTRUCTION("623315482594F0341200007B" , vpternlogd(zmm10, zmm13, zmmword_ptr(rax, r14, 3, 4660), 123)); + TEST_INSTRUCTION("6273155825117B" , vpternlogd(zmm10, zmm13, dword_ptr(rcx)._1to16(), 123)); + TEST_INSTRUCTION("6273154825527F7B" , vpternlogd(zmm10, zmm13, zmmword_ptr(rdx, 8128), 123)); + TEST_INSTRUCTION("627315482592002000007B" , vpternlogd(zmm10, zmm13, zmmword_ptr(rdx, 8192), 123)); + TEST_INSTRUCTION("627315482552807B" , vpternlogd(zmm10, zmm13, zmmword_ptr(rdx, -8192), 123)); + TEST_INSTRUCTION("627315482592C0DFFFFF7B" , vpternlogd(zmm10, zmm13, zmmword_ptr(rdx, -8256), 123)); + TEST_INSTRUCTION("6273155825527F7B" , vpternlogd(zmm10, zmm13, dword_ptr(rdx, 508)._1to16(), 123)); + TEST_INSTRUCTION("627315582592000200007B" , vpternlogd(zmm10, zmm13, dword_ptr(rdx, 512)._1to16(), 123)); + TEST_INSTRUCTION("627315582552807B" , vpternlogd(zmm10, zmm13, dword_ptr(rdx, -512)._1to16(), 123)); + TEST_INSTRUCTION("627315582592FCFDFFFF7B" , vpternlogd(zmm10, zmm13, dword_ptr(rdx, -516)._1to16(), 123)); + TEST_INSTRUCTION("62C39D4825C5AB" , vpternlogq(zmm16, zmm12, zmm13, 171)); + TEST_INSTRUCTION("62C39D4A25C5AB" , k(k2).vpternlogq(zmm16, zmm12, zmm13, 171)); + TEST_INSTRUCTION("62C39DCA25C5AB" , k(k2).z().vpternlogq(zmm16, zmm12, zmm13, 171)); + TEST_INSTRUCTION("62C39D4825C57B" , vpternlogq(zmm16, zmm12, zmm13, 123)); + TEST_INSTRUCTION("62E39D4825017B" , vpternlogq(zmm16, zmm12, zmmword_ptr(rcx), 123)); + TEST_INSTRUCTION("62A39D482584F0341200007B" , vpternlogq(zmm16, zmm12, zmmword_ptr(rax, r14, 3, 4660), 123)); + TEST_INSTRUCTION("62E39D5825017B" , vpternlogq(zmm16, zmm12, qword_ptr(rcx)._1to8(), 123)); + TEST_INSTRUCTION("62E39D4825427F7B" , vpternlogq(zmm16, zmm12, zmmword_ptr(rdx, 8128), 123)); + TEST_INSTRUCTION("62E39D482582002000007B" , vpternlogq(zmm16, zmm12, zmmword_ptr(rdx, 8192), 123)); + TEST_INSTRUCTION("62E39D482542807B" , vpternlogq(zmm16, zmm12, zmmword_ptr(rdx, -8192), 123)); + TEST_INSTRUCTION("62E39D482582C0DFFFFF7B" , vpternlogq(zmm16, zmm12, zmmword_ptr(rdx, -8256), 123)); + TEST_INSTRUCTION("62E39D5825427F7B" , vpternlogq(zmm16, zmm12, qword_ptr(rdx, 1016)._1to8(), 123)); + TEST_INSTRUCTION("62E39D582582000400007B" , vpternlogq(zmm16, zmm12, qword_ptr(rdx, 1024)._1to8(), 123)); + TEST_INSTRUCTION("62E39D582542807B" , vpternlogq(zmm16, zmm12, qword_ptr(rdx, -1024)._1to8(), 123)); + TEST_INSTRUCTION("62E39D582582F8FBFFFF7B" , vpternlogq(zmm16, zmm12, qword_ptr(rdx, -1032)._1to8(), 123)); + TEST_INSTRUCTION("62327E4832F7" , vpmovqb(xmm23, zmm14)); + TEST_INSTRUCTION("62327E4A32F7" , k(k2).vpmovqb(xmm23, zmm14)); + TEST_INSTRUCTION("62327ECA32F7" , k(k2).z().vpmovqb(xmm23, zmm14)); + TEST_INSTRUCTION("62227E4822CC" , vpmovsqb(xmm20, zmm25)); + TEST_INSTRUCTION("62227E4922CC" , k(k1).vpmovsqb(xmm20, zmm25)); + TEST_INSTRUCTION("62227EC922CC" , k(k1).z().vpmovsqb(xmm20, zmm25)); + TEST_INSTRUCTION("62D27E4812D0" , vpmovusqb(xmm8, zmm2)); + TEST_INSTRUCTION("62D27E4C12D0" , k(k4).vpmovusqb(xmm8, zmm2)); + TEST_INSTRUCTION("62D27ECC12D0" , k(k4).z().vpmovusqb(xmm8, zmm2)); + TEST_INSTRUCTION("62A27E4834DD" , vpmovqw(xmm21, zmm19)); + TEST_INSTRUCTION("62A27E4A34DD" , k(k2).vpmovqw(xmm21, zmm19)); + TEST_INSTRUCTION("62A27ECA34DD" , k(k2).z().vpmovqw(xmm21, zmm19)); + TEST_INSTRUCTION("62B27E4824E0" , vpmovsqw(xmm16, zmm4)); + TEST_INSTRUCTION("62B27E4E24E0" , k(k6).vpmovsqw(xmm16, zmm4)); + TEST_INSTRUCTION("62B27ECE24E0" , k(k6).z().vpmovsqw(xmm16, zmm4)); + TEST_INSTRUCTION("62927E4814CD" , vpmovusqw(xmm29, zmm1)); + TEST_INSTRUCTION("62927E4A14CD" , k(k2).vpmovusqw(xmm29, zmm1)); + TEST_INSTRUCTION("62927ECA14CD" , k(k2).z().vpmovusqw(xmm29, zmm1)); + TEST_INSTRUCTION("62027E4835EC" , vpmovqd(ymm28, zmm29)); + TEST_INSTRUCTION("62027E4A35EC" , k(k2).vpmovqd(ymm28, zmm29)); + TEST_INSTRUCTION("62027ECA35EC" , k(k2).z().vpmovqd(ymm28, zmm29)); + TEST_INSTRUCTION("62327E4825CE" , vpmovsqd(ymm22, zmm9)); + TEST_INSTRUCTION("62327E4C25CE" , k(k4).vpmovsqd(ymm22, zmm9)); + TEST_INSTRUCTION("62327ECC25CE" , k(k4).z().vpmovsqd(ymm22, zmm9)); + TEST_INSTRUCTION("62627E4815D2" , vpmovusqd(ymm2, zmm26)); + TEST_INSTRUCTION("62627E4F15D2" , k(k7).vpmovusqd(ymm2, zmm26)); + TEST_INSTRUCTION("62627ECF15D2" , k(k7).z().vpmovusqd(ymm2, zmm26)); + TEST_INSTRUCTION("62727E4831D9" , vpmovdb(xmm1, zmm11)); + TEST_INSTRUCTION("62727E4F31D9" , k(k7).vpmovdb(xmm1, zmm11)); + TEST_INSTRUCTION("62727ECF31D9" , k(k7).z().vpmovdb(xmm1, zmm11)); + TEST_INSTRUCTION("62927E4821CB" , vpmovsdb(xmm27, zmm1)); + TEST_INSTRUCTION("62927E4F21CB" , k(k7).vpmovsdb(xmm27, zmm1)); + TEST_INSTRUCTION("62927ECF21CB" , k(k7).z().vpmovsdb(xmm27, zmm1)); + TEST_INSTRUCTION("62E27E4811DB" , vpmovusdb(xmm3, zmm19)); + TEST_INSTRUCTION("62E27E4A11DB" , k(k2).vpmovusdb(xmm3, zmm19)); + TEST_INSTRUCTION("62E27ECA11DB" , k(k2).z().vpmovusdb(xmm3, zmm19)); + TEST_INSTRUCTION("62527E4833D1" , vpmovdw(ymm9, zmm10)); + TEST_INSTRUCTION("62527E4C33D1" , k(k4).vpmovdw(ymm9, zmm10)); + TEST_INSTRUCTION("62527ECC33D1" , k(k4).z().vpmovdw(ymm9, zmm10)); + TEST_INSTRUCTION("62027E4823C0" , vpmovsdw(ymm24, zmm24)); + TEST_INSTRUCTION("62027E4E23C0" , k(k6).vpmovsdw(ymm24, zmm24)); + TEST_INSTRUCTION("62027ECE23C0" , k(k6).z().vpmovsdw(ymm24, zmm24)); + TEST_INSTRUCTION("62C27E4813CF" , vpmovusdw(ymm15, zmm17)); + TEST_INSTRUCTION("62C27E4F13CF" , k(k7).vpmovusdw(ymm15, zmm17)); + TEST_INSTRUCTION("62C27ECF13CF" , k(k7).z().vpmovusdw(ymm15, zmm17)); + TEST_INSTRUCTION("62E3254823CCAB" , vshuff32x4(zmm17, zmm11, zmm4, 171)); + TEST_INSTRUCTION("62E3254E23CCAB" , k(k6).vshuff32x4(zmm17, zmm11, zmm4, 171)); + TEST_INSTRUCTION("62E325CE23CCAB" , k(k6).z().vshuff32x4(zmm17, zmm11, zmm4, 171)); + TEST_INSTRUCTION("62E3254823CC7B" , vshuff32x4(zmm17, zmm11, zmm4, 123)); + TEST_INSTRUCTION("62E3254823097B" , vshuff32x4(zmm17, zmm11, zmmword_ptr(rcx), 123)); + TEST_INSTRUCTION("62A32548238CF0341200007B" , vshuff32x4(zmm17, zmm11, zmmword_ptr(rax, r14, 3, 4660), 123)); + TEST_INSTRUCTION("62E3255823097B" , vshuff32x4(zmm17, zmm11, dword_ptr(rcx)._1to16(), 123)); + TEST_INSTRUCTION("62E32548234A7F7B" , vshuff32x4(zmm17, zmm11, zmmword_ptr(rdx, 8128), 123)); + TEST_INSTRUCTION("62E32548238A002000007B" , vshuff32x4(zmm17, zmm11, zmmword_ptr(rdx, 8192), 123)); + TEST_INSTRUCTION("62E32548234A807B" , vshuff32x4(zmm17, zmm11, zmmword_ptr(rdx, -8192), 123)); + TEST_INSTRUCTION("62E32548238AC0DFFFFF7B" , vshuff32x4(zmm17, zmm11, zmmword_ptr(rdx, -8256), 123)); + TEST_INSTRUCTION("62E32558234A7F7B" , vshuff32x4(zmm17, zmm11, dword_ptr(rdx, 508)._1to16(), 123)); + TEST_INSTRUCTION("62E32558238A000200007B" , vshuff32x4(zmm17, zmm11, dword_ptr(rdx, 512)._1to16(), 123)); + TEST_INSTRUCTION("62E32558234A807B" , vshuff32x4(zmm17, zmm11, dword_ptr(rdx, -512)._1to16(), 123)); + TEST_INSTRUCTION("62E32558238AFCFDFFFF7B" , vshuff32x4(zmm17, zmm11, dword_ptr(rdx, -516)._1to16(), 123)); + TEST_INSTRUCTION("62939D4823F0AB" , vshuff64x2(zmm6, zmm12, zmm24, 171)); + TEST_INSTRUCTION("62939D4B23F0AB" , k(k3).vshuff64x2(zmm6, zmm12, zmm24, 171)); + TEST_INSTRUCTION("62939DCB23F0AB" , k(k3).z().vshuff64x2(zmm6, zmm12, zmm24, 171)); + TEST_INSTRUCTION("62939D4823F07B" , vshuff64x2(zmm6, zmm12, zmm24, 123)); + TEST_INSTRUCTION("62F39D4823317B" , vshuff64x2(zmm6, zmm12, zmmword_ptr(rcx), 123)); + TEST_INSTRUCTION("62B39D4823B4F0341200007B" , vshuff64x2(zmm6, zmm12, zmmword_ptr(rax, r14, 3, 4660), 123)); + TEST_INSTRUCTION("62F39D5823317B" , vshuff64x2(zmm6, zmm12, qword_ptr(rcx)._1to8(), 123)); + TEST_INSTRUCTION("62F39D4823727F7B" , vshuff64x2(zmm6, zmm12, zmmword_ptr(rdx, 8128), 123)); + TEST_INSTRUCTION("62F39D4823B2002000007B" , vshuff64x2(zmm6, zmm12, zmmword_ptr(rdx, 8192), 123)); + TEST_INSTRUCTION("62F39D482372807B" , vshuff64x2(zmm6, zmm12, zmmword_ptr(rdx, -8192), 123)); + TEST_INSTRUCTION("62F39D4823B2C0DFFFFF7B" , vshuff64x2(zmm6, zmm12, zmmword_ptr(rdx, -8256), 123)); + TEST_INSTRUCTION("62F39D5823727F7B" , vshuff64x2(zmm6, zmm12, qword_ptr(rdx, 1016)._1to8(), 123)); + TEST_INSTRUCTION("62F39D5823B2000400007B" , vshuff64x2(zmm6, zmm12, qword_ptr(rdx, 1024)._1to8(), 123)); + TEST_INSTRUCTION("62F39D582372807B" , vshuff64x2(zmm6, zmm12, qword_ptr(rdx, -1024)._1to8(), 123)); + TEST_INSTRUCTION("62F39D5823B2F8FBFFFF7B" , vshuff64x2(zmm6, zmm12, qword_ptr(rdx, -1032)._1to8(), 123)); + TEST_INSTRUCTION("62F33D4043DDAB" , vshufi32x4(zmm3, zmm24, zmm5, 171)); + TEST_INSTRUCTION("62F33D4443DDAB" , k(k4).vshufi32x4(zmm3, zmm24, zmm5, 171)); + TEST_INSTRUCTION("62F33DC443DDAB" , k(k4).z().vshufi32x4(zmm3, zmm24, zmm5, 171)); + TEST_INSTRUCTION("62F33D4043DD7B" , vshufi32x4(zmm3, zmm24, zmm5, 123)); + TEST_INSTRUCTION("62F33D4043197B" , vshufi32x4(zmm3, zmm24, zmmword_ptr(rcx), 123)); + TEST_INSTRUCTION("62B33D40439CF0341200007B" , vshufi32x4(zmm3, zmm24, zmmword_ptr(rax, r14, 3, 4660), 123)); + TEST_INSTRUCTION("62F33D5043197B" , vshufi32x4(zmm3, zmm24, dword_ptr(rcx)._1to16(), 123)); + TEST_INSTRUCTION("62F33D40435A7F7B" , vshufi32x4(zmm3, zmm24, zmmword_ptr(rdx, 8128), 123)); + TEST_INSTRUCTION("62F33D40439A002000007B" , vshufi32x4(zmm3, zmm24, zmmword_ptr(rdx, 8192), 123)); + TEST_INSTRUCTION("62F33D40435A807B" , vshufi32x4(zmm3, zmm24, zmmword_ptr(rdx, -8192), 123)); + TEST_INSTRUCTION("62F33D40439AC0DFFFFF7B" , vshufi32x4(zmm3, zmm24, zmmword_ptr(rdx, -8256), 123)); + TEST_INSTRUCTION("62F33D50435A7F7B" , vshufi32x4(zmm3, zmm24, dword_ptr(rdx, 508)._1to16(), 123)); + TEST_INSTRUCTION("62F33D50439A000200007B" , vshufi32x4(zmm3, zmm24, dword_ptr(rdx, 512)._1to16(), 123)); + TEST_INSTRUCTION("62F33D50435A807B" , vshufi32x4(zmm3, zmm24, dword_ptr(rdx, -512)._1to16(), 123)); + TEST_INSTRUCTION("62F33D50439AFCFDFFFF7B" , vshufi32x4(zmm3, zmm24, dword_ptr(rdx, -516)._1to16(), 123)); + TEST_INSTRUCTION("62438D4843F1AB" , vshufi64x2(zmm30, zmm14, zmm9, 171)); + TEST_INSTRUCTION("62438D4943F1AB" , k(k1).vshufi64x2(zmm30, zmm14, zmm9, 171)); + TEST_INSTRUCTION("62438DC943F1AB" , k(k1).z().vshufi64x2(zmm30, zmm14, zmm9, 171)); + TEST_INSTRUCTION("62438D4843F17B" , vshufi64x2(zmm30, zmm14, zmm9, 123)); + TEST_INSTRUCTION("62638D4843317B" , vshufi64x2(zmm30, zmm14, zmmword_ptr(rcx), 123)); + TEST_INSTRUCTION("62238D4843B4F0341200007B" , vshufi64x2(zmm30, zmm14, zmmword_ptr(rax, r14, 3, 4660), 123)); + TEST_INSTRUCTION("62638D5843317B" , vshufi64x2(zmm30, zmm14, qword_ptr(rcx)._1to8(), 123)); + TEST_INSTRUCTION("62638D4843727F7B" , vshufi64x2(zmm30, zmm14, zmmword_ptr(rdx, 8128), 123)); + TEST_INSTRUCTION("62638D4843B2002000007B" , vshufi64x2(zmm30, zmm14, zmmword_ptr(rdx, 8192), 123)); + TEST_INSTRUCTION("62638D484372807B" , vshufi64x2(zmm30, zmm14, zmmword_ptr(rdx, -8192), 123)); + TEST_INSTRUCTION("62638D4843B2C0DFFFFF7B" , vshufi64x2(zmm30, zmm14, zmmword_ptr(rdx, -8256), 123)); + TEST_INSTRUCTION("62638D5843727F7B" , vshufi64x2(zmm30, zmm14, qword_ptr(rdx, 1016)._1to8(), 123)); + TEST_INSTRUCTION("62638D5843B2000400007B" , vshufi64x2(zmm30, zmm14, qword_ptr(rdx, 1024)._1to8(), 123)); + TEST_INSTRUCTION("62638D584372807B" , vshufi64x2(zmm30, zmm14, qword_ptr(rdx, -1024)._1to8(), 123)); + TEST_INSTRUCTION("62638D5843B2F8FBFFFF7B" , vshufi64x2(zmm30, zmm14, qword_ptr(rdx, -1032)._1to8(), 123)); + TEST_INSTRUCTION("62A2CD4036D3" , vpermq(zmm18, zmm22, zmm19)); + TEST_INSTRUCTION("62A2CD4736D3" , k(k7).vpermq(zmm18, zmm22, zmm19)); + TEST_INSTRUCTION("62A2CDC736D3" , k(k7).z().vpermq(zmm18, zmm22, zmm19)); + TEST_INSTRUCTION("62E2CD403611" , vpermq(zmm18, zmm22, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62A2CD403694F034120000" , vpermq(zmm18, zmm22, zmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62E2CD503611" , vpermq(zmm18, zmm22, qword_ptr(rcx)._1to8())); + TEST_INSTRUCTION("62E2CD4036527F" , vpermq(zmm18, zmm22, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62E2CD40369200200000" , vpermq(zmm18, zmm22, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62E2CD40365280" , vpermq(zmm18, zmm22, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62E2CD403692C0DFFFFF" , vpermq(zmm18, zmm22, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62E2CD5036527F" , vpermq(zmm18, zmm22, qword_ptr(rdx, 1016)._1to8())); + TEST_INSTRUCTION("62E2CD50369200040000" , vpermq(zmm18, zmm22, qword_ptr(rdx, 1024)._1to8())); + TEST_INSTRUCTION("62E2CD50365280" , vpermq(zmm18, zmm22, qword_ptr(rdx, -1024)._1to8())); + TEST_INSTRUCTION("62E2CD503692F8FBFFFF" , vpermq(zmm18, zmm22, qword_ptr(rdx, -1032)._1to8())); + TEST_INSTRUCTION("62629D4816DA" , vpermpd(zmm27, zmm12, zmm2)); + TEST_INSTRUCTION("62629D4B16DA" , k(k3).vpermpd(zmm27, zmm12, zmm2)); + TEST_INSTRUCTION("62629DCB16DA" , k(k3).z().vpermpd(zmm27, zmm12, zmm2)); + TEST_INSTRUCTION("62629D481619" , vpermpd(zmm27, zmm12, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62229D48169CF034120000" , vpermpd(zmm27, zmm12, zmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62629D581619" , vpermpd(zmm27, zmm12, qword_ptr(rcx)._1to8())); + TEST_INSTRUCTION("62629D48165A7F" , vpermpd(zmm27, zmm12, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62629D48169A00200000" , vpermpd(zmm27, zmm12, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62629D48165A80" , vpermpd(zmm27, zmm12, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62629D48169AC0DFFFFF" , vpermpd(zmm27, zmm12, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62629D58165A7F" , vpermpd(zmm27, zmm12, qword_ptr(rdx, 1016)._1to8())); + TEST_INSTRUCTION("62629D58169A00040000" , vpermpd(zmm27, zmm12, qword_ptr(rdx, 1024)._1to8())); + TEST_INSTRUCTION("62629D58165A80" , vpermpd(zmm27, zmm12, qword_ptr(rdx, -1024)._1to8())); + TEST_INSTRUCTION("62629D58169AF8FBFFFF" , vpermpd(zmm27, zmm12, qword_ptr(rdx, -1032)._1to8())); + TEST_INSTRUCTION("628205487ED9" , vpermt2d(zmm19, zmm15, zmm25)); + TEST_INSTRUCTION("6282054A7ED9" , k(k2).vpermt2d(zmm19, zmm15, zmm25)); + TEST_INSTRUCTION("628205CA7ED9" , k(k2).z().vpermt2d(zmm19, zmm15, zmm25)); + TEST_INSTRUCTION("62E205487E19" , vpermt2d(zmm19, zmm15, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62A205487E9CF034120000" , vpermt2d(zmm19, zmm15, zmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62E205587E19" , vpermt2d(zmm19, zmm15, dword_ptr(rcx)._1to16())); + TEST_INSTRUCTION("62E205487E5A7F" , vpermt2d(zmm19, zmm15, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62E205487E9A00200000" , vpermt2d(zmm19, zmm15, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62E205487E5A80" , vpermt2d(zmm19, zmm15, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62E205487E9AC0DFFFFF" , vpermt2d(zmm19, zmm15, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62E205587E5A7F" , vpermt2d(zmm19, zmm15, dword_ptr(rdx, 508)._1to16())); + TEST_INSTRUCTION("62E205587E9A00020000" , vpermt2d(zmm19, zmm15, dword_ptr(rdx, 512)._1to16())); + TEST_INSTRUCTION("62E205587E5A80" , vpermt2d(zmm19, zmm15, dword_ptr(rdx, -512)._1to16())); + TEST_INSTRUCTION("62E205587E9AFCFDFFFF" , vpermt2d(zmm19, zmm15, dword_ptr(rdx, -516)._1to16())); + TEST_INSTRUCTION("62F2D5407ED4" , vpermt2q(zmm2, zmm21, zmm4)); + TEST_INSTRUCTION("62F2D5477ED4" , k(k7).vpermt2q(zmm2, zmm21, zmm4)); + TEST_INSTRUCTION("62F2D5C77ED4" , k(k7).z().vpermt2q(zmm2, zmm21, zmm4)); + TEST_INSTRUCTION("62F2D5407E11" , vpermt2q(zmm2, zmm21, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62B2D5407E94F034120000" , vpermt2q(zmm2, zmm21, zmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62F2D5507E11" , vpermt2q(zmm2, zmm21, qword_ptr(rcx)._1to8())); + TEST_INSTRUCTION("62F2D5407E527F" , vpermt2q(zmm2, zmm21, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62F2D5407E9200200000" , vpermt2q(zmm2, zmm21, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62F2D5407E5280" , vpermt2q(zmm2, zmm21, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62F2D5407E92C0DFFFFF" , vpermt2q(zmm2, zmm21, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62F2D5507E527F" , vpermt2q(zmm2, zmm21, qword_ptr(rdx, 1016)._1to8())); + TEST_INSTRUCTION("62F2D5507E9200040000" , vpermt2q(zmm2, zmm21, qword_ptr(rdx, 1024)._1to8())); + TEST_INSTRUCTION("62F2D5507E5280" , vpermt2q(zmm2, zmm21, qword_ptr(rdx, -1024)._1to8())); + TEST_INSTRUCTION("62F2D5507E92F8FBFFFF" , vpermt2q(zmm2, zmm21, qword_ptr(rdx, -1032)._1to8())); + TEST_INSTRUCTION("62F205487FFF" , vpermt2ps(zmm7, zmm15, zmm7)); + TEST_INSTRUCTION("62F2054F7FFF" , k(k7).vpermt2ps(zmm7, zmm15, zmm7)); + TEST_INSTRUCTION("62F205CF7FFF" , k(k7).z().vpermt2ps(zmm7, zmm15, zmm7)); + TEST_INSTRUCTION("62F205487F39" , vpermt2ps(zmm7, zmm15, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62B205487FBCF034120000" , vpermt2ps(zmm7, zmm15, zmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62F205587F39" , vpermt2ps(zmm7, zmm15, dword_ptr(rcx)._1to16())); + TEST_INSTRUCTION("62F205487F7A7F" , vpermt2ps(zmm7, zmm15, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62F205487FBA00200000" , vpermt2ps(zmm7, zmm15, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62F205487F7A80" , vpermt2ps(zmm7, zmm15, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62F205487FBAC0DFFFFF" , vpermt2ps(zmm7, zmm15, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62F205587F7A7F" , vpermt2ps(zmm7, zmm15, dword_ptr(rdx, 508)._1to16())); + TEST_INSTRUCTION("62F205587FBA00020000" , vpermt2ps(zmm7, zmm15, dword_ptr(rdx, 512)._1to16())); + TEST_INSTRUCTION("62F205587F7A80" , vpermt2ps(zmm7, zmm15, dword_ptr(rdx, -512)._1to16())); + TEST_INSTRUCTION("62F205587FBAFCFDFFFF" , vpermt2ps(zmm7, zmm15, dword_ptr(rdx, -516)._1to16())); + TEST_INSTRUCTION("6212CD407FE1" , vpermt2pd(zmm12, zmm22, zmm25)); + TEST_INSTRUCTION("6212CD417FE1" , k(k1).vpermt2pd(zmm12, zmm22, zmm25)); + TEST_INSTRUCTION("6212CDC17FE1" , k(k1).z().vpermt2pd(zmm12, zmm22, zmm25)); + TEST_INSTRUCTION("6272CD407F21" , vpermt2pd(zmm12, zmm22, zmmword_ptr(rcx))); + TEST_INSTRUCTION("6232CD407FA4F034120000" , vpermt2pd(zmm12, zmm22, zmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("6272CD507F21" , vpermt2pd(zmm12, zmm22, qword_ptr(rcx)._1to8())); + TEST_INSTRUCTION("6272CD407F627F" , vpermt2pd(zmm12, zmm22, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("6272CD407FA200200000" , vpermt2pd(zmm12, zmm22, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("6272CD407F6280" , vpermt2pd(zmm12, zmm22, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("6272CD407FA2C0DFFFFF" , vpermt2pd(zmm12, zmm22, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("6272CD507F627F" , vpermt2pd(zmm12, zmm22, qword_ptr(rdx, 1016)._1to8())); + TEST_INSTRUCTION("6272CD507FA200040000" , vpermt2pd(zmm12, zmm22, qword_ptr(rdx, 1024)._1to8())); + TEST_INSTRUCTION("6272CD507F6280" , vpermt2pd(zmm12, zmm22, qword_ptr(rdx, -1024)._1to8())); + TEST_INSTRUCTION("6272CD507FA2F8FBFFFF" , vpermt2pd(zmm12, zmm22, qword_ptr(rdx, -1032)._1to8())); + TEST_INSTRUCTION("6223F54003C8AB" , valignq(zmm25, zmm17, zmm16, 171)); + TEST_INSTRUCTION("6223F54703C8AB" , k(k7).valignq(zmm25, zmm17, zmm16, 171)); + TEST_INSTRUCTION("6223F5C703C8AB" , k(k7).z().valignq(zmm25, zmm17, zmm16, 171)); + TEST_INSTRUCTION("6223F54003C87B" , valignq(zmm25, zmm17, zmm16, 123)); + TEST_INSTRUCTION("6263F54003097B" , valignq(zmm25, zmm17, zmmword_ptr(rcx), 123)); + TEST_INSTRUCTION("6223F540038CF0341200007B" , valignq(zmm25, zmm17, zmmword_ptr(rax, r14, 3, 4660), 123)); + TEST_INSTRUCTION("6263F55003097B" , valignq(zmm25, zmm17, qword_ptr(rcx)._1to8(), 123)); + TEST_INSTRUCTION("6263F540034A7F7B" , valignq(zmm25, zmm17, zmmword_ptr(rdx, 8128), 123)); + TEST_INSTRUCTION("6263F540038A002000007B" , valignq(zmm25, zmm17, zmmword_ptr(rdx, 8192), 123)); + TEST_INSTRUCTION("6263F540034A807B" , valignq(zmm25, zmm17, zmmword_ptr(rdx, -8192), 123)); + TEST_INSTRUCTION("6263F540038AC0DFFFFF7B" , valignq(zmm25, zmm17, zmmword_ptr(rdx, -8256), 123)); + TEST_INSTRUCTION("6263F550034A7F7B" , valignq(zmm25, zmm17, qword_ptr(rdx, 1016)._1to8(), 123)); + TEST_INSTRUCTION("6263F550038A000400007B" , valignq(zmm25, zmm17, qword_ptr(rdx, 1024)._1to8(), 123)); + TEST_INSTRUCTION("6263F550034A807B" , valignq(zmm25, zmm17, qword_ptr(rdx, -1024)._1to8(), 123)); + TEST_INSTRUCTION("6263F550038AF8FBFFFF7B" , valignq(zmm25, zmm17, qword_ptr(rdx, -1032)._1to8(), 123)); + TEST_INSTRUCTION("62D17F0879C3" , vcvtsd2usi(eax, xmm11)); + TEST_INSTRUCTION("62D17F1879C3" , rn_sae().vcvtsd2usi(eax, xmm11)); + TEST_INSTRUCTION("62D17F5879C3" , ru_sae().vcvtsd2usi(eax, xmm11)); + TEST_INSTRUCTION("62D17F3879C3" , rd_sae().vcvtsd2usi(eax, xmm11)); + TEST_INSTRUCTION("62D17F7879C3" , rz_sae().vcvtsd2usi(eax, xmm11)); + TEST_INSTRUCTION("62F17F087901" , vcvtsd2usi(eax, qword_ptr(rcx))); + TEST_INSTRUCTION("62B17F087984F034120000" , vcvtsd2usi(eax, qword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62F17F0879427F" , vcvtsd2usi(eax, qword_ptr(rdx, 1016))); + TEST_INSTRUCTION("62F17F08798200040000" , vcvtsd2usi(eax, qword_ptr(rdx, 1024))); + TEST_INSTRUCTION("62F17F08794280" , vcvtsd2usi(eax, qword_ptr(rdx, -1024))); + TEST_INSTRUCTION("62F17F087982F8FBFFFF" , vcvtsd2usi(eax, qword_ptr(rdx, -1032))); + TEST_INSTRUCTION("62D17F0879EB" , vcvtsd2usi(ebp, xmm11)); + TEST_INSTRUCTION("62D17F1879EB" , rn_sae().vcvtsd2usi(ebp, xmm11)); + TEST_INSTRUCTION("62D17F5879EB" , ru_sae().vcvtsd2usi(ebp, xmm11)); + TEST_INSTRUCTION("62D17F3879EB" , rd_sae().vcvtsd2usi(ebp, xmm11)); + TEST_INSTRUCTION("62D17F7879EB" , rz_sae().vcvtsd2usi(ebp, xmm11)); + TEST_INSTRUCTION("62F17F087929" , vcvtsd2usi(ebp, qword_ptr(rcx))); + TEST_INSTRUCTION("62B17F0879ACF034120000" , vcvtsd2usi(ebp, qword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62F17F08796A7F" , vcvtsd2usi(ebp, qword_ptr(rdx, 1016))); + TEST_INSTRUCTION("62F17F0879AA00040000" , vcvtsd2usi(ebp, qword_ptr(rdx, 1024))); + TEST_INSTRUCTION("62F17F08796A80" , vcvtsd2usi(ebp, qword_ptr(rdx, -1024))); + TEST_INSTRUCTION("62F17F0879AAF8FBFFFF" , vcvtsd2usi(ebp, qword_ptr(rdx, -1032))); + TEST_INSTRUCTION("62517F0879EB" , vcvtsd2usi(r13d, xmm11)); + TEST_INSTRUCTION("62517F1879EB" , rn_sae().vcvtsd2usi(r13d, xmm11)); + TEST_INSTRUCTION("62517F5879EB" , ru_sae().vcvtsd2usi(r13d, xmm11)); + TEST_INSTRUCTION("62517F3879EB" , rd_sae().vcvtsd2usi(r13d, xmm11)); + TEST_INSTRUCTION("62517F7879EB" , rz_sae().vcvtsd2usi(r13d, xmm11)); + TEST_INSTRUCTION("62717F087929" , vcvtsd2usi(r13d, qword_ptr(rcx))); + TEST_INSTRUCTION("62317F0879ACF034120000" , vcvtsd2usi(r13d, qword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62717F08796A7F" , vcvtsd2usi(r13d, qword_ptr(rdx, 1016))); + TEST_INSTRUCTION("62717F0879AA00040000" , vcvtsd2usi(r13d, qword_ptr(rdx, 1024))); + TEST_INSTRUCTION("62717F08796A80" , vcvtsd2usi(r13d, qword_ptr(rdx, -1024))); + TEST_INSTRUCTION("62717F0879AAF8FBFFFF" , vcvtsd2usi(r13d, qword_ptr(rdx, -1032))); + TEST_INSTRUCTION("62D1FF0879C5" , vcvtsd2usi(rax, xmm13)); + TEST_INSTRUCTION("62D1FF1879C5" , rn_sae().vcvtsd2usi(rax, xmm13)); + TEST_INSTRUCTION("62D1FF5879C5" , ru_sae().vcvtsd2usi(rax, xmm13)); + TEST_INSTRUCTION("62D1FF3879C5" , rd_sae().vcvtsd2usi(rax, xmm13)); + TEST_INSTRUCTION("62D1FF7879C5" , rz_sae().vcvtsd2usi(rax, xmm13)); + TEST_INSTRUCTION("62F1FF087901" , vcvtsd2usi(rax, qword_ptr(rcx))); + TEST_INSTRUCTION("62B1FF087984F034120000" , vcvtsd2usi(rax, qword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62F1FF0879427F" , vcvtsd2usi(rax, qword_ptr(rdx, 1016))); + TEST_INSTRUCTION("62F1FF08798200040000" , vcvtsd2usi(rax, qword_ptr(rdx, 1024))); + TEST_INSTRUCTION("62F1FF08794280" , vcvtsd2usi(rax, qword_ptr(rdx, -1024))); + TEST_INSTRUCTION("62F1FF087982F8FBFFFF" , vcvtsd2usi(rax, qword_ptr(rdx, -1032))); + TEST_INSTRUCTION("6251FF0879C5" , vcvtsd2usi(r8, xmm13)); + TEST_INSTRUCTION("6251FF1879C5" , rn_sae().vcvtsd2usi(r8, xmm13)); + TEST_INSTRUCTION("6251FF5879C5" , ru_sae().vcvtsd2usi(r8, xmm13)); + TEST_INSTRUCTION("6251FF3879C5" , rd_sae().vcvtsd2usi(r8, xmm13)); + TEST_INSTRUCTION("6251FF7879C5" , rz_sae().vcvtsd2usi(r8, xmm13)); + TEST_INSTRUCTION("6271FF087901" , vcvtsd2usi(r8, qword_ptr(rcx))); + TEST_INSTRUCTION("6231FF087984F034120000" , vcvtsd2usi(r8, qword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("6271FF0879427F" , vcvtsd2usi(r8, qword_ptr(rdx, 1016))); + TEST_INSTRUCTION("6271FF08798200040000" , vcvtsd2usi(r8, qword_ptr(rdx, 1024))); + TEST_INSTRUCTION("6271FF08794280" , vcvtsd2usi(r8, qword_ptr(rdx, -1024))); + TEST_INSTRUCTION("6271FF087982F8FBFFFF" , vcvtsd2usi(r8, qword_ptr(rdx, -1032))); + TEST_INSTRUCTION("62F17E0879C1" , vcvtss2usi(eax, xmm1)); + TEST_INSTRUCTION("62F17E1879C1" , rn_sae().vcvtss2usi(eax, xmm1)); + TEST_INSTRUCTION("62F17E5879C1" , ru_sae().vcvtss2usi(eax, xmm1)); + TEST_INSTRUCTION("62F17E3879C1" , rd_sae().vcvtss2usi(eax, xmm1)); + TEST_INSTRUCTION("62F17E7879C1" , rz_sae().vcvtss2usi(eax, xmm1)); + TEST_INSTRUCTION("62F17E087901" , vcvtss2usi(eax, dword_ptr(rcx))); + TEST_INSTRUCTION("62B17E087984F034120000" , vcvtss2usi(eax, dword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62F17E0879427F" , vcvtss2usi(eax, dword_ptr(rdx, 508))); + TEST_INSTRUCTION("62F17E08798200020000" , vcvtss2usi(eax, dword_ptr(rdx, 512))); + TEST_INSTRUCTION("62F17E08794280" , vcvtss2usi(eax, dword_ptr(rdx, -512))); + TEST_INSTRUCTION("62F17E087982FCFDFFFF" , vcvtss2usi(eax, dword_ptr(rdx, -516))); + TEST_INSTRUCTION("62F17E0879E9" , vcvtss2usi(ebp, xmm1)); + TEST_INSTRUCTION("62F17E1879E9" , rn_sae().vcvtss2usi(ebp, xmm1)); + TEST_INSTRUCTION("62F17E5879E9" , ru_sae().vcvtss2usi(ebp, xmm1)); + TEST_INSTRUCTION("62F17E3879E9" , rd_sae().vcvtss2usi(ebp, xmm1)); + TEST_INSTRUCTION("62F17E7879E9" , rz_sae().vcvtss2usi(ebp, xmm1)); + TEST_INSTRUCTION("62F17E087929" , vcvtss2usi(ebp, dword_ptr(rcx))); + TEST_INSTRUCTION("62B17E0879ACF034120000" , vcvtss2usi(ebp, dword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62F17E08796A7F" , vcvtss2usi(ebp, dword_ptr(rdx, 508))); + TEST_INSTRUCTION("62F17E0879AA00020000" , vcvtss2usi(ebp, dword_ptr(rdx, 512))); + TEST_INSTRUCTION("62F17E08796A80" , vcvtss2usi(ebp, dword_ptr(rdx, -512))); + TEST_INSTRUCTION("62F17E0879AAFCFDFFFF" , vcvtss2usi(ebp, dword_ptr(rdx, -516))); + TEST_INSTRUCTION("62717E0879E9" , vcvtss2usi(r13d, xmm1)); + TEST_INSTRUCTION("62717E1879E9" , rn_sae().vcvtss2usi(r13d, xmm1)); + TEST_INSTRUCTION("62717E5879E9" , ru_sae().vcvtss2usi(r13d, xmm1)); + TEST_INSTRUCTION("62717E3879E9" , rd_sae().vcvtss2usi(r13d, xmm1)); + TEST_INSTRUCTION("62717E7879E9" , rz_sae().vcvtss2usi(r13d, xmm1)); + TEST_INSTRUCTION("62717E087929" , vcvtss2usi(r13d, dword_ptr(rcx))); + TEST_INSTRUCTION("62317E0879ACF034120000" , vcvtss2usi(r13d, dword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62717E08796A7F" , vcvtss2usi(r13d, dword_ptr(rdx, 508))); + TEST_INSTRUCTION("62717E0879AA00020000" , vcvtss2usi(r13d, dword_ptr(rdx, 512))); + TEST_INSTRUCTION("62717E08796A80" , vcvtss2usi(r13d, dword_ptr(rdx, -512))); + TEST_INSTRUCTION("62717E0879AAFCFDFFFF" , vcvtss2usi(r13d, dword_ptr(rdx, -516))); + TEST_INSTRUCTION("62F1FE0879C3" , vcvtss2usi(rax, xmm3)); + TEST_INSTRUCTION("62F1FE1879C3" , rn_sae().vcvtss2usi(rax, xmm3)); + TEST_INSTRUCTION("62F1FE5879C3" , ru_sae().vcvtss2usi(rax, xmm3)); + TEST_INSTRUCTION("62F1FE3879C3" , rd_sae().vcvtss2usi(rax, xmm3)); + TEST_INSTRUCTION("62F1FE7879C3" , rz_sae().vcvtss2usi(rax, xmm3)); + TEST_INSTRUCTION("62F1FE087901" , vcvtss2usi(rax, dword_ptr(rcx))); + TEST_INSTRUCTION("62B1FE087984F034120000" , vcvtss2usi(rax, dword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62F1FE0879427F" , vcvtss2usi(rax, dword_ptr(rdx, 508))); + TEST_INSTRUCTION("62F1FE08798200020000" , vcvtss2usi(rax, dword_ptr(rdx, 512))); + TEST_INSTRUCTION("62F1FE08794280" , vcvtss2usi(rax, dword_ptr(rdx, -512))); + TEST_INSTRUCTION("62F1FE087982FCFDFFFF" , vcvtss2usi(rax, dword_ptr(rdx, -516))); + TEST_INSTRUCTION("6271FE0879C3" , vcvtss2usi(r8, xmm3)); + TEST_INSTRUCTION("6271FE1879C3" , rn_sae().vcvtss2usi(r8, xmm3)); + TEST_INSTRUCTION("6271FE5879C3" , ru_sae().vcvtss2usi(r8, xmm3)); + TEST_INSTRUCTION("6271FE3879C3" , rd_sae().vcvtss2usi(r8, xmm3)); + TEST_INSTRUCTION("6271FE7879C3" , rz_sae().vcvtss2usi(r8, xmm3)); + TEST_INSTRUCTION("6271FE087901" , vcvtss2usi(r8, dword_ptr(rcx))); + TEST_INSTRUCTION("6231FE087984F034120000" , vcvtss2usi(r8, dword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("6271FE0879427F" , vcvtss2usi(r8, dword_ptr(rdx, 508))); + TEST_INSTRUCTION("6271FE08798200020000" , vcvtss2usi(r8, dword_ptr(rdx, 512))); + TEST_INSTRUCTION("6271FE08794280" , vcvtss2usi(r8, dword_ptr(rdx, -512))); + TEST_INSTRUCTION("6271FE087982FCFDFFFF" , vcvtss2usi(r8, dword_ptr(rdx, -516))); + TEST_INSTRUCTION("626177007BD0" , vcvtusi2sd(xmm26, xmm17, eax)); + TEST_INSTRUCTION("626177007BD5" , vcvtusi2sd(xmm26, xmm17, ebp)); + TEST_INSTRUCTION("624177007BD5" , vcvtusi2sd(xmm26, xmm17, r13d)); + TEST_INSTRUCTION("626177007B11" , vcvtusi2sd(xmm26, xmm17, dword_ptr(rcx))); + TEST_INSTRUCTION("622177007B94F034120000" , vcvtusi2sd(xmm26, xmm17, dword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("626177007B527F" , vcvtusi2sd(xmm26, xmm17, dword_ptr(rdx, 508))); + TEST_INSTRUCTION("626177007B9200020000" , vcvtusi2sd(xmm26, xmm17, dword_ptr(rdx, 512))); + TEST_INSTRUCTION("626177007B5280" , vcvtusi2sd(xmm26, xmm17, dword_ptr(rdx, -512))); + TEST_INSTRUCTION("626177007B92FCFDFFFF" , vcvtusi2sd(xmm26, xmm17, dword_ptr(rdx, -516))); + TEST_INSTRUCTION("6271CF087BD8" , vcvtusi2sd(xmm11, xmm6, rax)); + TEST_INSTRUCTION("6271CF187BD8" , rn_sae().vcvtusi2sd(xmm11, xmm6, rax)); + TEST_INSTRUCTION("6271CF587BD8" , ru_sae().vcvtusi2sd(xmm11, xmm6, rax)); + TEST_INSTRUCTION("6271CF387BD8" , rd_sae().vcvtusi2sd(xmm11, xmm6, rax)); + TEST_INSTRUCTION("6271CF787BD8" , rz_sae().vcvtusi2sd(xmm11, xmm6, rax)); + TEST_INSTRUCTION("6251CF087BD8" , vcvtusi2sd(xmm11, xmm6, r8)); + TEST_INSTRUCTION("6251CF187BD8" , rn_sae().vcvtusi2sd(xmm11, xmm6, r8)); + TEST_INSTRUCTION("6251CF587BD8" , ru_sae().vcvtusi2sd(xmm11, xmm6, r8)); + TEST_INSTRUCTION("6251CF387BD8" , rd_sae().vcvtusi2sd(xmm11, xmm6, r8)); + TEST_INSTRUCTION("6251CF787BD8" , rz_sae().vcvtusi2sd(xmm11, xmm6, r8)); + TEST_INSTRUCTION("6271CF087B19" , vcvtusi2sd(xmm11, xmm6, qword_ptr(rcx))); + TEST_INSTRUCTION("6231CF087B9CF034120000" , vcvtusi2sd(xmm11, xmm6, qword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("6271CF087B5A7F" , vcvtusi2sd(xmm11, xmm6, qword_ptr(rdx, 1016))); + TEST_INSTRUCTION("6271CF087B9A00040000" , vcvtusi2sd(xmm11, xmm6, qword_ptr(rdx, 1024))); + TEST_INSTRUCTION("6271CF087B5A80" , vcvtusi2sd(xmm11, xmm6, qword_ptr(rdx, -1024))); + TEST_INSTRUCTION("6271CF087B9AF8FBFFFF" , vcvtusi2sd(xmm11, xmm6, qword_ptr(rdx, -1032))); + TEST_INSTRUCTION("627146087BC8" , vcvtusi2ss(xmm9, xmm7, eax)); + TEST_INSTRUCTION("627146187BC8" , rn_sae().vcvtusi2ss(xmm9, xmm7, eax)); + TEST_INSTRUCTION("627146587BC8" , ru_sae().vcvtusi2ss(xmm9, xmm7, eax)); + TEST_INSTRUCTION("627146387BC8" , rd_sae().vcvtusi2ss(xmm9, xmm7, eax)); + TEST_INSTRUCTION("627146787BC8" , rz_sae().vcvtusi2ss(xmm9, xmm7, eax)); + TEST_INSTRUCTION("627146087BCD" , vcvtusi2ss(xmm9, xmm7, ebp)); + TEST_INSTRUCTION("627146187BCD" , rn_sae().vcvtusi2ss(xmm9, xmm7, ebp)); + TEST_INSTRUCTION("627146587BCD" , ru_sae().vcvtusi2ss(xmm9, xmm7, ebp)); + TEST_INSTRUCTION("627146387BCD" , rd_sae().vcvtusi2ss(xmm9, xmm7, ebp)); + TEST_INSTRUCTION("627146787BCD" , rz_sae().vcvtusi2ss(xmm9, xmm7, ebp)); + TEST_INSTRUCTION("625146087BCD" , vcvtusi2ss(xmm9, xmm7, r13d)); + TEST_INSTRUCTION("625146187BCD" , rn_sae().vcvtusi2ss(xmm9, xmm7, r13d)); + TEST_INSTRUCTION("625146587BCD" , ru_sae().vcvtusi2ss(xmm9, xmm7, r13d)); + TEST_INSTRUCTION("625146387BCD" , rd_sae().vcvtusi2ss(xmm9, xmm7, r13d)); + TEST_INSTRUCTION("625146787BCD" , rz_sae().vcvtusi2ss(xmm9, xmm7, r13d)); + TEST_INSTRUCTION("627146087B09" , vcvtusi2ss(xmm9, xmm7, dword_ptr(rcx))); + TEST_INSTRUCTION("623146087B8CF034120000" , vcvtusi2ss(xmm9, xmm7, dword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("627146087B4A7F" , vcvtusi2ss(xmm9, xmm7, dword_ptr(rdx, 508))); + TEST_INSTRUCTION("627146087B8A00020000" , vcvtusi2ss(xmm9, xmm7, dword_ptr(rdx, 512))); + TEST_INSTRUCTION("627146087B4A80" , vcvtusi2ss(xmm9, xmm7, dword_ptr(rdx, -512))); + TEST_INSTRUCTION("627146087B8AFCFDFFFF" , vcvtusi2ss(xmm9, xmm7, dword_ptr(rdx, -516))); + TEST_INSTRUCTION("62E1AE087BE8" , vcvtusi2ss(xmm21, xmm10, rax)); + TEST_INSTRUCTION("62E1AE187BE8" , rn_sae().vcvtusi2ss(xmm21, xmm10, rax)); + TEST_INSTRUCTION("62E1AE587BE8" , ru_sae().vcvtusi2ss(xmm21, xmm10, rax)); + TEST_INSTRUCTION("62E1AE387BE8" , rd_sae().vcvtusi2ss(xmm21, xmm10, rax)); + TEST_INSTRUCTION("62E1AE787BE8" , rz_sae().vcvtusi2ss(xmm21, xmm10, rax)); + TEST_INSTRUCTION("62C1AE087BE8" , vcvtusi2ss(xmm21, xmm10, r8)); + TEST_INSTRUCTION("62C1AE187BE8" , rn_sae().vcvtusi2ss(xmm21, xmm10, r8)); + TEST_INSTRUCTION("62C1AE587BE8" , ru_sae().vcvtusi2ss(xmm21, xmm10, r8)); + TEST_INSTRUCTION("62C1AE387BE8" , rd_sae().vcvtusi2ss(xmm21, xmm10, r8)); + TEST_INSTRUCTION("62C1AE787BE8" , rz_sae().vcvtusi2ss(xmm21, xmm10, r8)); + TEST_INSTRUCTION("62E1AE087B29" , vcvtusi2ss(xmm21, xmm10, qword_ptr(rcx))); + TEST_INSTRUCTION("62A1AE087BACF034120000" , vcvtusi2ss(xmm21, xmm10, qword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62E1AE087B6A7F" , vcvtusi2ss(xmm21, xmm10, qword_ptr(rdx, 1016))); + TEST_INSTRUCTION("62E1AE087BAA00040000" , vcvtusi2ss(xmm21, xmm10, qword_ptr(rdx, 1024))); + TEST_INSTRUCTION("62E1AE087B6A80" , vcvtusi2ss(xmm21, xmm10, qword_ptr(rdx, -1024))); + TEST_INSTRUCTION("62E1AE087BAAF8FBFFFF" , vcvtusi2ss(xmm21, xmm10, qword_ptr(rdx, -1032))); + TEST_INSTRUCTION("62B2DD482CF8" , vscalefpd(zmm7, zmm4, zmm16)); + TEST_INSTRUCTION("62B2DD4D2CF8" , k(k5).vscalefpd(zmm7, zmm4, zmm16)); + TEST_INSTRUCTION("62B2DDCD2CF8" , k(k5).z().vscalefpd(zmm7, zmm4, zmm16)); + TEST_INSTRUCTION("62B2DD182CF8" , rn_sae().vscalefpd(zmm7, zmm4, zmm16)); + TEST_INSTRUCTION("62B2DD582CF8" , ru_sae().vscalefpd(zmm7, zmm4, zmm16)); + TEST_INSTRUCTION("62B2DD382CF8" , rd_sae().vscalefpd(zmm7, zmm4, zmm16)); + TEST_INSTRUCTION("62B2DD782CF8" , rz_sae().vscalefpd(zmm7, zmm4, zmm16)); + TEST_INSTRUCTION("62F2DD482C39" , vscalefpd(zmm7, zmm4, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62B2DD482CBCF034120000" , vscalefpd(zmm7, zmm4, zmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62F2DD582C39" , vscalefpd(zmm7, zmm4, qword_ptr(rcx)._1to8())); + TEST_INSTRUCTION("62F2DD482C7A7F" , vscalefpd(zmm7, zmm4, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62F2DD482CBA00200000" , vscalefpd(zmm7, zmm4, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62F2DD482C7A80" , vscalefpd(zmm7, zmm4, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62F2DD482CBAC0DFFFFF" , vscalefpd(zmm7, zmm4, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62F2DD582C7A7F" , vscalefpd(zmm7, zmm4, qword_ptr(rdx, 1016)._1to8())); + TEST_INSTRUCTION("62F2DD582CBA00040000" , vscalefpd(zmm7, zmm4, qword_ptr(rdx, 1024)._1to8())); + TEST_INSTRUCTION("62F2DD582C7A80" , vscalefpd(zmm7, zmm4, qword_ptr(rdx, -1024)._1to8())); + TEST_INSTRUCTION("62F2DD582CBAF8FBFFFF" , vscalefpd(zmm7, zmm4, qword_ptr(rdx, -1032)._1to8())); + TEST_INSTRUCTION("62B225482CE3" , vscalefps(zmm4, zmm11, zmm19)); + TEST_INSTRUCTION("62B2254A2CE3" , k(k2).vscalefps(zmm4, zmm11, zmm19)); + TEST_INSTRUCTION("62B225CA2CE3" , k(k2).z().vscalefps(zmm4, zmm11, zmm19)); + TEST_INSTRUCTION("62B225182CE3" , rn_sae().vscalefps(zmm4, zmm11, zmm19)); + TEST_INSTRUCTION("62B225582CE3" , ru_sae().vscalefps(zmm4, zmm11, zmm19)); + TEST_INSTRUCTION("62B225382CE3" , rd_sae().vscalefps(zmm4, zmm11, zmm19)); + TEST_INSTRUCTION("62B225782CE3" , rz_sae().vscalefps(zmm4, zmm11, zmm19)); + TEST_INSTRUCTION("62F225482C21" , vscalefps(zmm4, zmm11, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62B225482CA4F034120000" , vscalefps(zmm4, zmm11, zmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62F225582C21" , vscalefps(zmm4, zmm11, dword_ptr(rcx)._1to16())); + TEST_INSTRUCTION("62F225482C627F" , vscalefps(zmm4, zmm11, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62F225482CA200200000" , vscalefps(zmm4, zmm11, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62F225482C6280" , vscalefps(zmm4, zmm11, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62F225482CA2C0DFFFFF" , vscalefps(zmm4, zmm11, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62F225582C627F" , vscalefps(zmm4, zmm11, dword_ptr(rdx, 508)._1to16())); + TEST_INSTRUCTION("62F225582CA200020000" , vscalefps(zmm4, zmm11, dword_ptr(rdx, 512)._1to16())); + TEST_INSTRUCTION("62F225582C6280" , vscalefps(zmm4, zmm11, dword_ptr(rdx, -512)._1to16())); + TEST_INSTRUCTION("62F225582CA2FCFDFFFF" , vscalefps(zmm4, zmm11, dword_ptr(rdx, -516)._1to16())); + TEST_INSTRUCTION("6222E5002DEE" , vscalefsd(xmm29, xmm19, xmm22)); + TEST_INSTRUCTION("6222E5042DEE" , k(k4).vscalefsd(xmm29, xmm19, xmm22)); + TEST_INSTRUCTION("6222E5842DEE" , k(k4).z().vscalefsd(xmm29, xmm19, xmm22)); + TEST_INSTRUCTION("6222E5102DEE" , rn_sae().vscalefsd(xmm29, xmm19, xmm22)); + TEST_INSTRUCTION("6222E5502DEE" , ru_sae().vscalefsd(xmm29, xmm19, xmm22)); + TEST_INSTRUCTION("6222E5302DEE" , rd_sae().vscalefsd(xmm29, xmm19, xmm22)); + TEST_INSTRUCTION("6222E5702DEE" , rz_sae().vscalefsd(xmm29, xmm19, xmm22)); + TEST_INSTRUCTION("6262E5002D29" , vscalefsd(xmm29, xmm19, qword_ptr(rcx))); + TEST_INSTRUCTION("6222E5002DACF034120000" , vscalefsd(xmm29, xmm19, qword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("6262E5002D6A7F" , vscalefsd(xmm29, xmm19, qword_ptr(rdx, 1016))); + TEST_INSTRUCTION("6262E5002DAA00040000" , vscalefsd(xmm29, xmm19, qword_ptr(rdx, 1024))); + TEST_INSTRUCTION("6262E5002D6A80" , vscalefsd(xmm29, xmm19, qword_ptr(rdx, -1024))); + TEST_INSTRUCTION("6262E5002DAAF8FBFFFF" , vscalefsd(xmm29, xmm19, qword_ptr(rdx, -1032))); + TEST_INSTRUCTION("62E21D082DE6" , vscalefss(xmm20, xmm12, xmm6)); + TEST_INSTRUCTION("62E21D0A2DE6" , k(k2).vscalefss(xmm20, xmm12, xmm6)); + TEST_INSTRUCTION("62E21D8A2DE6" , k(k2).z().vscalefss(xmm20, xmm12, xmm6)); + TEST_INSTRUCTION("62E21D182DE6" , rn_sae().vscalefss(xmm20, xmm12, xmm6)); + TEST_INSTRUCTION("62E21D582DE6" , ru_sae().vscalefss(xmm20, xmm12, xmm6)); + TEST_INSTRUCTION("62E21D382DE6" , rd_sae().vscalefss(xmm20, xmm12, xmm6)); + TEST_INSTRUCTION("62E21D782DE6" , rz_sae().vscalefss(xmm20, xmm12, xmm6)); + TEST_INSTRUCTION("62E21D082D21" , vscalefss(xmm20, xmm12, dword_ptr(rcx))); + TEST_INSTRUCTION("62A21D082DA4F034120000" , vscalefss(xmm20, xmm12, dword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62E21D082D627F" , vscalefss(xmm20, xmm12, dword_ptr(rdx, 508))); + TEST_INSTRUCTION("62E21D082DA200020000" , vscalefss(xmm20, xmm12, dword_ptr(rdx, 512))); + TEST_INSTRUCTION("62E21D082D6280" , vscalefss(xmm20, xmm12, dword_ptr(rdx, -512))); + TEST_INSTRUCTION("62E21D082DA2FCFDFFFF" , vscalefss(xmm20, xmm12, dword_ptr(rdx, -516))); + TEST_INSTRUCTION("62F33D4854E7AB" , vfixupimmps(zmm4, zmm8, zmm7, 171)); + TEST_INSTRUCTION("62F33D4F54E7AB" , k(k7).vfixupimmps(zmm4, zmm8, zmm7, 171)); + TEST_INSTRUCTION("62F33DCF54E7AB" , k(k7).z().vfixupimmps(zmm4, zmm8, zmm7, 171)); + TEST_INSTRUCTION("62F33D1854E7AB" , sae().vfixupimmps(zmm4, zmm8, zmm7, 171)); + TEST_INSTRUCTION("62F33D4854E77B" , vfixupimmps(zmm4, zmm8, zmm7, 123)); + TEST_INSTRUCTION("62F33D1854E77B" , sae().vfixupimmps(zmm4, zmm8, zmm7, 123)); + TEST_INSTRUCTION("62F33D4854217B" , vfixupimmps(zmm4, zmm8, zmmword_ptr(rcx), 123)); + TEST_INSTRUCTION("62B33D4854A4F0341200007B" , vfixupimmps(zmm4, zmm8, zmmword_ptr(rax, r14, 3, 4660), 123)); + TEST_INSTRUCTION("62F33D5854217B" , vfixupimmps(zmm4, zmm8, dword_ptr(rcx)._1to16(), 123)); + TEST_INSTRUCTION("62F33D4854627F7B" , vfixupimmps(zmm4, zmm8, zmmword_ptr(rdx, 8128), 123)); + TEST_INSTRUCTION("62F33D4854A2002000007B" , vfixupimmps(zmm4, zmm8, zmmword_ptr(rdx, 8192), 123)); + TEST_INSTRUCTION("62F33D485462807B" , vfixupimmps(zmm4, zmm8, zmmword_ptr(rdx, -8192), 123)); + TEST_INSTRUCTION("62F33D4854A2C0DFFFFF7B" , vfixupimmps(zmm4, zmm8, zmmword_ptr(rdx, -8256), 123)); + TEST_INSTRUCTION("62F33D5854627F7B" , vfixupimmps(zmm4, zmm8, dword_ptr(rdx, 508)._1to16(), 123)); + TEST_INSTRUCTION("62F33D5854A2000200007B" , vfixupimmps(zmm4, zmm8, dword_ptr(rdx, 512)._1to16(), 123)); + TEST_INSTRUCTION("62F33D585462807B" , vfixupimmps(zmm4, zmm8, dword_ptr(rdx, -512)._1to16(), 123)); + TEST_INSTRUCTION("62F33D5854A2FCFDFFFF7B" , vfixupimmps(zmm4, zmm8, dword_ptr(rdx, -516)._1to16(), 123)); + TEST_INSTRUCTION("6273D54854FDAB" , vfixupimmpd(zmm15, zmm5, zmm5, 171)); + TEST_INSTRUCTION("6273D54D54FDAB" , k(k5).vfixupimmpd(zmm15, zmm5, zmm5, 171)); + TEST_INSTRUCTION("6273D5CD54FDAB" , k(k5).z().vfixupimmpd(zmm15, zmm5, zmm5, 171)); + TEST_INSTRUCTION("6273D51854FDAB" , sae().vfixupimmpd(zmm15, zmm5, zmm5, 171)); + TEST_INSTRUCTION("6273D54854FD7B" , vfixupimmpd(zmm15, zmm5, zmm5, 123)); + TEST_INSTRUCTION("6273D51854FD7B" , sae().vfixupimmpd(zmm15, zmm5, zmm5, 123)); + TEST_INSTRUCTION("6273D54854397B" , vfixupimmpd(zmm15, zmm5, zmmword_ptr(rcx), 123)); + TEST_INSTRUCTION("6233D54854BCF0341200007B" , vfixupimmpd(zmm15, zmm5, zmmword_ptr(rax, r14, 3, 4660), 123)); + TEST_INSTRUCTION("6273D55854397B" , vfixupimmpd(zmm15, zmm5, qword_ptr(rcx)._1to8(), 123)); + TEST_INSTRUCTION("6273D548547A7F7B" , vfixupimmpd(zmm15, zmm5, zmmword_ptr(rdx, 8128), 123)); + TEST_INSTRUCTION("6273D54854BA002000007B" , vfixupimmpd(zmm15, zmm5, zmmword_ptr(rdx, 8192), 123)); + TEST_INSTRUCTION("6273D548547A807B" , vfixupimmpd(zmm15, zmm5, zmmword_ptr(rdx, -8192), 123)); + TEST_INSTRUCTION("6273D54854BAC0DFFFFF7B" , vfixupimmpd(zmm15, zmm5, zmmword_ptr(rdx, -8256), 123)); + TEST_INSTRUCTION("6273D558547A7F7B" , vfixupimmpd(zmm15, zmm5, qword_ptr(rdx, 1016)._1to8(), 123)); + TEST_INSTRUCTION("6273D55854BA000400007B" , vfixupimmpd(zmm15, zmm5, qword_ptr(rdx, 1024)._1to8(), 123)); + TEST_INSTRUCTION("6273D558547A807B" , vfixupimmpd(zmm15, zmm5, qword_ptr(rdx, -1024)._1to8(), 123)); + TEST_INSTRUCTION("6273D55854BAF8FBFFFF7B" , vfixupimmpd(zmm15, zmm5, qword_ptr(rdx, -1032)._1to8(), 123)); + TEST_INSTRUCTION("62633D0055CFAB" , vfixupimmss(xmm25, xmm24, xmm7, 171)); + TEST_INSTRUCTION("62633D0455CFAB" , k(k4).vfixupimmss(xmm25, xmm24, xmm7, 171)); + TEST_INSTRUCTION("62633D8455CFAB" , k(k4).z().vfixupimmss(xmm25, xmm24, xmm7, 171)); + TEST_INSTRUCTION("62633D1055CFAB" , sae().vfixupimmss(xmm25, xmm24, xmm7, 171)); + TEST_INSTRUCTION("62633D0055CF7B" , vfixupimmss(xmm25, xmm24, xmm7, 123)); + TEST_INSTRUCTION("62633D1055CF7B" , sae().vfixupimmss(xmm25, xmm24, xmm7, 123)); + TEST_INSTRUCTION("62633D0055097B" , vfixupimmss(xmm25, xmm24, dword_ptr(rcx), 123)); + TEST_INSTRUCTION("62233D00558CF0341200007B" , vfixupimmss(xmm25, xmm24, dword_ptr(rax, r14, 3, 4660), 123)); + TEST_INSTRUCTION("62633D00554A7F7B" , vfixupimmss(xmm25, xmm24, dword_ptr(rdx, 508), 123)); + TEST_INSTRUCTION("62633D00558A000200007B" , vfixupimmss(xmm25, xmm24, dword_ptr(rdx, 512), 123)); + TEST_INSTRUCTION("62633D00554A807B" , vfixupimmss(xmm25, xmm24, dword_ptr(rdx, -512), 123)); + TEST_INSTRUCTION("62633D00558AFCFDFFFF7B" , vfixupimmss(xmm25, xmm24, dword_ptr(rdx, -516), 123)); + TEST_INSTRUCTION("62239D0855C0AB" , vfixupimmsd(xmm24, xmm12, xmm16, 171)); + TEST_INSTRUCTION("62239D0A55C0AB" , k(k2).vfixupimmsd(xmm24, xmm12, xmm16, 171)); + TEST_INSTRUCTION("62239D8A55C0AB" , k(k2).z().vfixupimmsd(xmm24, xmm12, xmm16, 171)); + TEST_INSTRUCTION("62239D1855C0AB" , sae().vfixupimmsd(xmm24, xmm12, xmm16, 171)); + TEST_INSTRUCTION("62239D0855C07B" , vfixupimmsd(xmm24, xmm12, xmm16, 123)); + TEST_INSTRUCTION("62239D1855C07B" , sae().vfixupimmsd(xmm24, xmm12, xmm16, 123)); + TEST_INSTRUCTION("62639D0855017B" , vfixupimmsd(xmm24, xmm12, qword_ptr(rcx), 123)); + TEST_INSTRUCTION("62239D085584F0341200007B" , vfixupimmsd(xmm24, xmm12, qword_ptr(rax, r14, 3, 4660), 123)); + TEST_INSTRUCTION("62639D0855427F7B" , vfixupimmsd(xmm24, xmm12, qword_ptr(rdx, 1016), 123)); + TEST_INSTRUCTION("62639D085582000400007B" , vfixupimmsd(xmm24, xmm12, qword_ptr(rdx, 1024), 123)); + TEST_INSTRUCTION("62639D085542807B" , vfixupimmsd(xmm24, xmm12, qword_ptr(rdx, -1024), 123)); + TEST_INSTRUCTION("62639D085582F8FBFFFF7B" , vfixupimmsd(xmm24, xmm12, qword_ptr(rdx, -1032), 123)); + TEST_INSTRUCTION("62F1254072F5AB" , vpslld(zmm27, zmm5, 171)); + TEST_INSTRUCTION("62F1254172F5AB" , k(k1).vpslld(zmm27, zmm5, 171)); + TEST_INSTRUCTION("62F125C172F5AB" , k(k1).z().vpslld(zmm27, zmm5, 171)); + TEST_INSTRUCTION("62F1254072F57B" , vpslld(zmm27, zmm5, 123)); + TEST_INSTRUCTION("62F1254072317B" , vpslld(zmm27, zmmword_ptr(rcx), 123)); + TEST_INSTRUCTION("62B1254072B4F0341200007B" , vpslld(zmm27, zmmword_ptr(rax, r14, 3, 4660), 123)); + TEST_INSTRUCTION("62F1255072317B" , vpslld(zmm27, dword_ptr(rcx)._1to16(), 123)); + TEST_INSTRUCTION("62F1254072727F7B" , vpslld(zmm27, zmmword_ptr(rdx, 8128), 123)); + TEST_INSTRUCTION("62F1254072B2002000007B" , vpslld(zmm27, zmmword_ptr(rdx, 8192), 123)); + TEST_INSTRUCTION("62F125407272807B" , vpslld(zmm27, zmmword_ptr(rdx, -8192), 123)); + TEST_INSTRUCTION("62F1254072B2C0DFFFFF7B" , vpslld(zmm27, zmmword_ptr(rdx, -8256), 123)); + TEST_INSTRUCTION("62F1255072727F7B" , vpslld(zmm27, dword_ptr(rdx, 508)._1to16(), 123)); + TEST_INSTRUCTION("62F1255072B2000200007B" , vpslld(zmm27, dword_ptr(rdx, 512)._1to16(), 123)); + TEST_INSTRUCTION("62F125507272807B" , vpslld(zmm27, dword_ptr(rdx, -512)._1to16(), 123)); + TEST_INSTRUCTION("62F1255072B2FCFDFFFF7B" , vpslld(zmm27, dword_ptr(rdx, -516)._1to16(), 123)); + TEST_INSTRUCTION("62F1DD4873F6AB" , vpsllq(zmm4, zmm6, 171)); + TEST_INSTRUCTION("62F1DD4C73F6AB" , k(k4).vpsllq(zmm4, zmm6, 171)); + TEST_INSTRUCTION("62F1DDCC73F6AB" , k(k4).z().vpsllq(zmm4, zmm6, 171)); + TEST_INSTRUCTION("62F1DD4873F67B" , vpsllq(zmm4, zmm6, 123)); + TEST_INSTRUCTION("62F1DD4873317B" , vpsllq(zmm4, zmmword_ptr(rcx), 123)); + TEST_INSTRUCTION("62B1DD4873B4F0341200007B" , vpsllq(zmm4, zmmword_ptr(rax, r14, 3, 4660), 123)); + TEST_INSTRUCTION("62F1DD5873317B" , vpsllq(zmm4, qword_ptr(rcx)._1to8(), 123)); + TEST_INSTRUCTION("62F1DD4873727F7B" , vpsllq(zmm4, zmmword_ptr(rdx, 8128), 123)); + TEST_INSTRUCTION("62F1DD4873B2002000007B" , vpsllq(zmm4, zmmword_ptr(rdx, 8192), 123)); + TEST_INSTRUCTION("62F1DD487372807B" , vpsllq(zmm4, zmmword_ptr(rdx, -8192), 123)); + TEST_INSTRUCTION("62F1DD4873B2C0DFFFFF7B" , vpsllq(zmm4, zmmword_ptr(rdx, -8256), 123)); + TEST_INSTRUCTION("62F1DD5873727F7B" , vpsllq(zmm4, qword_ptr(rdx, 1016)._1to8(), 123)); + TEST_INSTRUCTION("62F1DD5873B2000400007B" , vpsllq(zmm4, qword_ptr(rdx, 1024)._1to8(), 123)); + TEST_INSTRUCTION("62F1DD587372807B" , vpsllq(zmm4, qword_ptr(rdx, -1024)._1to8(), 123)); + TEST_INSTRUCTION("62F1DD5873B2F8FBFFFF7B" , vpsllq(zmm4, qword_ptr(rdx, -1032)._1to8(), 123)); + TEST_INSTRUCTION("62B13D4872E4AB" , vpsrad(zmm8, zmm20, 171)); + TEST_INSTRUCTION("62B13D4A72E4AB" , k(k2).vpsrad(zmm8, zmm20, 171)); + TEST_INSTRUCTION("62B13DCA72E4AB" , k(k2).z().vpsrad(zmm8, zmm20, 171)); + TEST_INSTRUCTION("62B13D4872E47B" , vpsrad(zmm8, zmm20, 123)); + TEST_INSTRUCTION("62F13D4872217B" , vpsrad(zmm8, zmmword_ptr(rcx), 123)); + TEST_INSTRUCTION("62B13D4872A4F0341200007B" , vpsrad(zmm8, zmmword_ptr(rax, r14, 3, 4660), 123)); + TEST_INSTRUCTION("62F13D5872217B" , vpsrad(zmm8, dword_ptr(rcx)._1to16(), 123)); + TEST_INSTRUCTION("62F13D4872627F7B" , vpsrad(zmm8, zmmword_ptr(rdx, 8128), 123)); + TEST_INSTRUCTION("62F13D4872A2002000007B" , vpsrad(zmm8, zmmword_ptr(rdx, 8192), 123)); + TEST_INSTRUCTION("62F13D487262807B" , vpsrad(zmm8, zmmword_ptr(rdx, -8192), 123)); + TEST_INSTRUCTION("62F13D4872A2C0DFFFFF7B" , vpsrad(zmm8, zmmword_ptr(rdx, -8256), 123)); + TEST_INSTRUCTION("62F13D5872627F7B" , vpsrad(zmm8, dword_ptr(rdx, 508)._1to16(), 123)); + TEST_INSTRUCTION("62F13D5872A2000200007B" , vpsrad(zmm8, dword_ptr(rdx, 512)._1to16(), 123)); + TEST_INSTRUCTION("62F13D587262807B" , vpsrad(zmm8, dword_ptr(rdx, -512)._1to16(), 123)); + TEST_INSTRUCTION("62F13D5872A2FCFDFFFF7B" , vpsrad(zmm8, dword_ptr(rdx, -516)._1to16(), 123)); + TEST_INSTRUCTION("62B1E54872E2AB" , vpsraq(zmm3, zmm18, 171)); + TEST_INSTRUCTION("62B1E54E72E2AB" , k(k6).vpsraq(zmm3, zmm18, 171)); + TEST_INSTRUCTION("62B1E5CE72E2AB" , k(k6).z().vpsraq(zmm3, zmm18, 171)); + TEST_INSTRUCTION("62B1E54872E27B" , vpsraq(zmm3, zmm18, 123)); + TEST_INSTRUCTION("62F1E54872217B" , vpsraq(zmm3, zmmword_ptr(rcx), 123)); + TEST_INSTRUCTION("62B1E54872A4F0341200007B" , vpsraq(zmm3, zmmword_ptr(rax, r14, 3, 4660), 123)); + TEST_INSTRUCTION("62F1E55872217B" , vpsraq(zmm3, qword_ptr(rcx)._1to8(), 123)); + TEST_INSTRUCTION("62F1E54872627F7B" , vpsraq(zmm3, zmmword_ptr(rdx, 8128), 123)); + TEST_INSTRUCTION("62F1E54872A2002000007B" , vpsraq(zmm3, zmmword_ptr(rdx, 8192), 123)); + TEST_INSTRUCTION("62F1E5487262807B" , vpsraq(zmm3, zmmword_ptr(rdx, -8192), 123)); + TEST_INSTRUCTION("62F1E54872A2C0DFFFFF7B" , vpsraq(zmm3, zmmword_ptr(rdx, -8256), 123)); + TEST_INSTRUCTION("62F1E55872627F7B" , vpsraq(zmm3, qword_ptr(rdx, 1016)._1to8(), 123)); + TEST_INSTRUCTION("62F1E55872A2000400007B" , vpsraq(zmm3, qword_ptr(rdx, 1024)._1to8(), 123)); + TEST_INSTRUCTION("62F1E5587262807B" , vpsraq(zmm3, qword_ptr(rdx, -1024)._1to8(), 123)); + TEST_INSTRUCTION("62F1E55872A2F8FBFFFF7B" , vpsraq(zmm3, qword_ptr(rdx, -1032)._1to8(), 123)); + TEST_INSTRUCTION("6242754815E2" , vprolvd(zmm28, zmm1, zmm10)); + TEST_INSTRUCTION("6242754E15E2" , k(k6).vprolvd(zmm28, zmm1, zmm10)); + TEST_INSTRUCTION("624275CE15E2" , k(k6).z().vprolvd(zmm28, zmm1, zmm10)); + TEST_INSTRUCTION("626275481521" , vprolvd(zmm28, zmm1, zmmword_ptr(rcx))); + TEST_INSTRUCTION("6222754815A4F034120000" , vprolvd(zmm28, zmm1, zmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("626275581521" , vprolvd(zmm28, zmm1, dword_ptr(rcx)._1to16())); + TEST_INSTRUCTION("6262754815627F" , vprolvd(zmm28, zmm1, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("6262754815A200200000" , vprolvd(zmm28, zmm1, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62627548156280" , vprolvd(zmm28, zmm1, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("6262754815A2C0DFFFFF" , vprolvd(zmm28, zmm1, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("6262755815627F" , vprolvd(zmm28, zmm1, dword_ptr(rdx, 508)._1to16())); + TEST_INSTRUCTION("6262755815A200020000" , vprolvd(zmm28, zmm1, dword_ptr(rdx, 512)._1to16())); + TEST_INSTRUCTION("62627558156280" , vprolvd(zmm28, zmm1, dword_ptr(rdx, -512)._1to16())); + TEST_INSTRUCTION("6262755815A2FCFDFFFF" , vprolvd(zmm28, zmm1, dword_ptr(rdx, -516)._1to16())); + TEST_INSTRUCTION("6291654072CBAB" , vprold(zmm19, zmm27, 171)); + TEST_INSTRUCTION("6291654472CBAB" , k(k4).vprold(zmm19, zmm27, 171)); + TEST_INSTRUCTION("629165C472CBAB" , k(k4).z().vprold(zmm19, zmm27, 171)); + TEST_INSTRUCTION("6291654072CB7B" , vprold(zmm19, zmm27, 123)); + TEST_INSTRUCTION("62F1654072097B" , vprold(zmm19, zmmword_ptr(rcx), 123)); + TEST_INSTRUCTION("62B16540728CF0341200007B" , vprold(zmm19, zmmword_ptr(rax, r14, 3, 4660), 123)); + TEST_INSTRUCTION("62F1655072097B" , vprold(zmm19, dword_ptr(rcx)._1to16(), 123)); + TEST_INSTRUCTION("62F16540724A7F7B" , vprold(zmm19, zmmword_ptr(rdx, 8128), 123)); + TEST_INSTRUCTION("62F16540728A002000007B" , vprold(zmm19, zmmword_ptr(rdx, 8192), 123)); + TEST_INSTRUCTION("62F16540724A807B" , vprold(zmm19, zmmword_ptr(rdx, -8192), 123)); + TEST_INSTRUCTION("62F16540728AC0DFFFFF7B" , vprold(zmm19, zmmword_ptr(rdx, -8256), 123)); + TEST_INSTRUCTION("62F16550724A7F7B" , vprold(zmm19, dword_ptr(rdx, 508)._1to16(), 123)); + TEST_INSTRUCTION("62F16550728A000200007B" , vprold(zmm19, dword_ptr(rdx, 512)._1to16(), 123)); + TEST_INSTRUCTION("62F16550724A807B" , vprold(zmm19, dword_ptr(rdx, -512)._1to16(), 123)); + TEST_INSTRUCTION("62F16550728AFCFDFFFF7B" , vprold(zmm19, dword_ptr(rdx, -516)._1to16(), 123)); + TEST_INSTRUCTION("6222F54815CE" , vprolvq(zmm25, zmm1, zmm22)); + TEST_INSTRUCTION("6222F54F15CE" , k(k7).vprolvq(zmm25, zmm1, zmm22)); + TEST_INSTRUCTION("6222F5CF15CE" , k(k7).z().vprolvq(zmm25, zmm1, zmm22)); + TEST_INSTRUCTION("6262F5481509" , vprolvq(zmm25, zmm1, zmmword_ptr(rcx))); + TEST_INSTRUCTION("6222F548158CF034120000" , vprolvq(zmm25, zmm1, zmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("6262F5581509" , vprolvq(zmm25, zmm1, qword_ptr(rcx)._1to8())); + TEST_INSTRUCTION("6262F548154A7F" , vprolvq(zmm25, zmm1, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("6262F548158A00200000" , vprolvq(zmm25, zmm1, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("6262F548154A80" , vprolvq(zmm25, zmm1, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("6262F548158AC0DFFFFF" , vprolvq(zmm25, zmm1, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("6262F558154A7F" , vprolvq(zmm25, zmm1, qword_ptr(rdx, 1016)._1to8())); + TEST_INSTRUCTION("6262F558158A00040000" , vprolvq(zmm25, zmm1, qword_ptr(rdx, 1024)._1to8())); + TEST_INSTRUCTION("6262F558154A80" , vprolvq(zmm25, zmm1, qword_ptr(rdx, -1024)._1to8())); + TEST_INSTRUCTION("6262F558158AF8FBFFFF" , vprolvq(zmm25, zmm1, qword_ptr(rdx, -1032)._1to8())); + TEST_INSTRUCTION("62D1F54072CAAB" , vprolq(zmm17, zmm10, 171)); + TEST_INSTRUCTION("62D1F54472CAAB" , k(k4).vprolq(zmm17, zmm10, 171)); + TEST_INSTRUCTION("62D1F5C472CAAB" , k(k4).z().vprolq(zmm17, zmm10, 171)); + TEST_INSTRUCTION("62D1F54072CA7B" , vprolq(zmm17, zmm10, 123)); + TEST_INSTRUCTION("62F1F54072097B" , vprolq(zmm17, zmmword_ptr(rcx), 123)); + TEST_INSTRUCTION("62B1F540728CF0341200007B" , vprolq(zmm17, zmmword_ptr(rax, r14, 3, 4660), 123)); + TEST_INSTRUCTION("62F1F55072097B" , vprolq(zmm17, qword_ptr(rcx)._1to8(), 123)); + TEST_INSTRUCTION("62F1F540724A7F7B" , vprolq(zmm17, zmmword_ptr(rdx, 8128), 123)); + TEST_INSTRUCTION("62F1F540728A002000007B" , vprolq(zmm17, zmmword_ptr(rdx, 8192), 123)); + TEST_INSTRUCTION("62F1F540724A807B" , vprolq(zmm17, zmmword_ptr(rdx, -8192), 123)); + TEST_INSTRUCTION("62F1F540728AC0DFFFFF7B" , vprolq(zmm17, zmmword_ptr(rdx, -8256), 123)); + TEST_INSTRUCTION("62F1F550724A7F7B" , vprolq(zmm17, qword_ptr(rdx, 1016)._1to8(), 123)); + TEST_INSTRUCTION("62F1F550728A000400007B" , vprolq(zmm17, qword_ptr(rdx, 1024)._1to8(), 123)); + TEST_INSTRUCTION("62F1F550724A807B" , vprolq(zmm17, qword_ptr(rdx, -1024)._1to8(), 123)); + TEST_INSTRUCTION("62F1F550728AF8FBFFFF7B" , vprolq(zmm17, qword_ptr(rdx, -1032)._1to8(), 123)); + TEST_INSTRUCTION("62D23D4814CD" , vprorvd(zmm1, zmm8, zmm13)); + TEST_INSTRUCTION("62D23D4A14CD" , k(k2).vprorvd(zmm1, zmm8, zmm13)); + TEST_INSTRUCTION("62D23DCA14CD" , k(k2).z().vprorvd(zmm1, zmm8, zmm13)); + TEST_INSTRUCTION("62F23D481409" , vprorvd(zmm1, zmm8, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62B23D48148CF034120000" , vprorvd(zmm1, zmm8, zmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62F23D581409" , vprorvd(zmm1, zmm8, dword_ptr(rcx)._1to16())); + TEST_INSTRUCTION("62F23D48144A7F" , vprorvd(zmm1, zmm8, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62F23D48148A00200000" , vprorvd(zmm1, zmm8, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62F23D48144A80" , vprorvd(zmm1, zmm8, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62F23D48148AC0DFFFFF" , vprorvd(zmm1, zmm8, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62F23D58144A7F" , vprorvd(zmm1, zmm8, dword_ptr(rdx, 508)._1to16())); + TEST_INSTRUCTION("62F23D58148A00020000" , vprorvd(zmm1, zmm8, dword_ptr(rdx, 512)._1to16())); + TEST_INSTRUCTION("62F23D58144A80" , vprorvd(zmm1, zmm8, dword_ptr(rdx, -512)._1to16())); + TEST_INSTRUCTION("62F23D58148AFCFDFFFF" , vprorvd(zmm1, zmm8, dword_ptr(rdx, -516)._1to16())); + TEST_INSTRUCTION("62D1454872C7AB" , vprord(zmm7, zmm15, 171)); + TEST_INSTRUCTION("62D1454972C7AB" , k(k1).vprord(zmm7, zmm15, 171)); + TEST_INSTRUCTION("62D145C972C7AB" , k(k1).z().vprord(zmm7, zmm15, 171)); + TEST_INSTRUCTION("62D1454872C77B" , vprord(zmm7, zmm15, 123)); + TEST_INSTRUCTION("62F1454872017B" , vprord(zmm7, zmmword_ptr(rcx), 123)); + TEST_INSTRUCTION("62B145487284F0341200007B" , vprord(zmm7, zmmword_ptr(rax, r14, 3, 4660), 123)); + TEST_INSTRUCTION("62F1455872017B" , vprord(zmm7, dword_ptr(rcx)._1to16(), 123)); + TEST_INSTRUCTION("62F1454872427F7B" , vprord(zmm7, zmmword_ptr(rdx, 8128), 123)); + TEST_INSTRUCTION("62F145487282002000007B" , vprord(zmm7, zmmword_ptr(rdx, 8192), 123)); + TEST_INSTRUCTION("62F145487242807B" , vprord(zmm7, zmmword_ptr(rdx, -8192), 123)); + TEST_INSTRUCTION("62F145487282C0DFFFFF7B" , vprord(zmm7, zmmword_ptr(rdx, -8256), 123)); + TEST_INSTRUCTION("62F1455872427F7B" , vprord(zmm7, dword_ptr(rdx, 508)._1to16(), 123)); + TEST_INSTRUCTION("62F145587282000200007B" , vprord(zmm7, dword_ptr(rdx, 512)._1to16(), 123)); + TEST_INSTRUCTION("62F145587242807B" , vprord(zmm7, dword_ptr(rdx, -512)._1to16(), 123)); + TEST_INSTRUCTION("62F145587282FCFDFFFF7B" , vprord(zmm7, dword_ptr(rdx, -516)._1to16(), 123)); + TEST_INSTRUCTION("6282C54014E8" , vprorvq(zmm21, zmm23, zmm24)); + TEST_INSTRUCTION("6282C54714E8" , k(k7).vprorvq(zmm21, zmm23, zmm24)); + TEST_INSTRUCTION("6282C5C714E8" , k(k7).z().vprorvq(zmm21, zmm23, zmm24)); + TEST_INSTRUCTION("62E2C5401429" , vprorvq(zmm21, zmm23, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62A2C54014ACF034120000" , vprorvq(zmm21, zmm23, zmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62E2C5501429" , vprorvq(zmm21, zmm23, qword_ptr(rcx)._1to8())); + TEST_INSTRUCTION("62E2C540146A7F" , vprorvq(zmm21, zmm23, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62E2C54014AA00200000" , vprorvq(zmm21, zmm23, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62E2C540146A80" , vprorvq(zmm21, zmm23, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62E2C54014AAC0DFFFFF" , vprorvq(zmm21, zmm23, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62E2C550146A7F" , vprorvq(zmm21, zmm23, qword_ptr(rdx, 1016)._1to8())); + TEST_INSTRUCTION("62E2C55014AA00040000" , vprorvq(zmm21, zmm23, qword_ptr(rdx, 1024)._1to8())); + TEST_INSTRUCTION("62E2C550146A80" , vprorvq(zmm21, zmm23, qword_ptr(rdx, -1024)._1to8())); + TEST_INSTRUCTION("62E2C55014AAF8FBFFFF" , vprorvq(zmm21, zmm23, qword_ptr(rdx, -1032)._1to8())); + TEST_INSTRUCTION("6291FD4072C3AB" , vprorq(zmm16, zmm27, 171)); + TEST_INSTRUCTION("6291FD4372C3AB" , k(k3).vprorq(zmm16, zmm27, 171)); + TEST_INSTRUCTION("6291FDC372C3AB" , k(k3).z().vprorq(zmm16, zmm27, 171)); + TEST_INSTRUCTION("6291FD4072C37B" , vprorq(zmm16, zmm27, 123)); + TEST_INSTRUCTION("62F1FD4072017B" , vprorq(zmm16, zmmword_ptr(rcx), 123)); + TEST_INSTRUCTION("62B1FD407284F0341200007B" , vprorq(zmm16, zmmword_ptr(rax, r14, 3, 4660), 123)); + TEST_INSTRUCTION("62F1FD5072017B" , vprorq(zmm16, qword_ptr(rcx)._1to8(), 123)); + TEST_INSTRUCTION("62F1FD4072427F7B" , vprorq(zmm16, zmmword_ptr(rdx, 8128), 123)); + TEST_INSTRUCTION("62F1FD407282002000007B" , vprorq(zmm16, zmmword_ptr(rdx, 8192), 123)); + TEST_INSTRUCTION("62F1FD407242807B" , vprorq(zmm16, zmmword_ptr(rdx, -8192), 123)); + TEST_INSTRUCTION("62F1FD407282C0DFFFFF7B" , vprorq(zmm16, zmmword_ptr(rdx, -8256), 123)); + TEST_INSTRUCTION("62F1FD5072427F7B" , vprorq(zmm16, qword_ptr(rdx, 1016)._1to8(), 123)); + TEST_INSTRUCTION("62F1FD507282000400007B" , vprorq(zmm16, qword_ptr(rdx, 1024)._1to8(), 123)); + TEST_INSTRUCTION("62F1FD507242807B" , vprorq(zmm16, qword_ptr(rdx, -1024)._1to8(), 123)); + TEST_INSTRUCTION("62F1FD507282F8FBFFFF7B" , vprorq(zmm16, qword_ptr(rdx, -1032)._1to8(), 123)); + TEST_INSTRUCTION("6213FD4809EAAB" , vrndscalepd(zmm13, zmm26, 171)); + TEST_INSTRUCTION("6213FD4A09EAAB" , k(k2).vrndscalepd(zmm13, zmm26, 171)); + TEST_INSTRUCTION("6213FDCA09EAAB" , k(k2).z().vrndscalepd(zmm13, zmm26, 171)); + TEST_INSTRUCTION("6213FD1809EAAB" , sae().vrndscalepd(zmm13, zmm26, 171)); + TEST_INSTRUCTION("6213FD4809EA7B" , vrndscalepd(zmm13, zmm26, 123)); + TEST_INSTRUCTION("6213FD1809EA7B" , sae().vrndscalepd(zmm13, zmm26, 123)); + TEST_INSTRUCTION("6273FD4809297B" , vrndscalepd(zmm13, zmmword_ptr(rcx), 123)); + TEST_INSTRUCTION("6233FD4809ACF0341200007B" , vrndscalepd(zmm13, zmmword_ptr(rax, r14, 3, 4660), 123)); + TEST_INSTRUCTION("6273FD5809297B" , vrndscalepd(zmm13, qword_ptr(rcx)._1to8(), 123)); + TEST_INSTRUCTION("6273FD48096A7F7B" , vrndscalepd(zmm13, zmmword_ptr(rdx, 8128), 123)); + TEST_INSTRUCTION("6273FD4809AA002000007B" , vrndscalepd(zmm13, zmmword_ptr(rdx, 8192), 123)); + TEST_INSTRUCTION("6273FD48096A807B" , vrndscalepd(zmm13, zmmword_ptr(rdx, -8192), 123)); + TEST_INSTRUCTION("6273FD4809AAC0DFFFFF7B" , vrndscalepd(zmm13, zmmword_ptr(rdx, -8256), 123)); + TEST_INSTRUCTION("6273FD58096A7F7B" , vrndscalepd(zmm13, qword_ptr(rdx, 1016)._1to8(), 123)); + TEST_INSTRUCTION("6273FD5809AA000400007B" , vrndscalepd(zmm13, qword_ptr(rdx, 1024)._1to8(), 123)); + TEST_INSTRUCTION("6273FD58096A807B" , vrndscalepd(zmm13, qword_ptr(rdx, -1024)._1to8(), 123)); + TEST_INSTRUCTION("6273FD5809AAF8FBFFFF7B" , vrndscalepd(zmm13, qword_ptr(rdx, -1032)._1to8(), 123)); + TEST_INSTRUCTION("62637D4808C7AB" , vrndscaleps(zmm24, zmm7, 171)); + TEST_INSTRUCTION("62637D4908C7AB" , k(k1).vrndscaleps(zmm24, zmm7, 171)); + TEST_INSTRUCTION("62637DC908C7AB" , k(k1).z().vrndscaleps(zmm24, zmm7, 171)); + TEST_INSTRUCTION("62637D1808C7AB" , sae().vrndscaleps(zmm24, zmm7, 171)); + TEST_INSTRUCTION("62637D4808C77B" , vrndscaleps(zmm24, zmm7, 123)); + TEST_INSTRUCTION("62637D1808C77B" , sae().vrndscaleps(zmm24, zmm7, 123)); + TEST_INSTRUCTION("62637D4808017B" , vrndscaleps(zmm24, zmmword_ptr(rcx), 123)); + TEST_INSTRUCTION("62237D480884F0341200007B" , vrndscaleps(zmm24, zmmword_ptr(rax, r14, 3, 4660), 123)); + TEST_INSTRUCTION("62637D5808017B" , vrndscaleps(zmm24, dword_ptr(rcx)._1to16(), 123)); + TEST_INSTRUCTION("62637D4808427F7B" , vrndscaleps(zmm24, zmmword_ptr(rdx, 8128), 123)); + TEST_INSTRUCTION("62637D480882002000007B" , vrndscaleps(zmm24, zmmword_ptr(rdx, 8192), 123)); + TEST_INSTRUCTION("62637D480842807B" , vrndscaleps(zmm24, zmmword_ptr(rdx, -8192), 123)); + TEST_INSTRUCTION("62637D480882C0DFFFFF7B" , vrndscaleps(zmm24, zmmword_ptr(rdx, -8256), 123)); + TEST_INSTRUCTION("62637D5808427F7B" , vrndscaleps(zmm24, dword_ptr(rdx, 508)._1to16(), 123)); + TEST_INSTRUCTION("62637D580882000200007B" , vrndscaleps(zmm24, dword_ptr(rdx, 512)._1to16(), 123)); + TEST_INSTRUCTION("62637D580842807B" , vrndscaleps(zmm24, dword_ptr(rdx, -512)._1to16(), 123)); + TEST_INSTRUCTION("62637D580882FCFDFFFF7B" , vrndscaleps(zmm24, dword_ptr(rdx, -516)._1to16(), 123)); + TEST_INSTRUCTION("6223C5080BD2AB" , vrndscalesd(xmm26, xmm7, xmm18, 171)); + TEST_INSTRUCTION("6223C5090BD2AB" , k(k1).vrndscalesd(xmm26, xmm7, xmm18, 171)); + TEST_INSTRUCTION("6223C5890BD2AB" , k(k1).z().vrndscalesd(xmm26, xmm7, xmm18, 171)); + TEST_INSTRUCTION("6223C5180BD2AB" , sae().vrndscalesd(xmm26, xmm7, xmm18, 171)); + TEST_INSTRUCTION("6223C5080BD27B" , vrndscalesd(xmm26, xmm7, xmm18, 123)); + TEST_INSTRUCTION("6223C5180BD27B" , sae().vrndscalesd(xmm26, xmm7, xmm18, 123)); + TEST_INSTRUCTION("6263C5080B117B" , vrndscalesd(xmm26, xmm7, qword_ptr(rcx), 123)); + TEST_INSTRUCTION("6223C5080B94F0341200007B" , vrndscalesd(xmm26, xmm7, qword_ptr(rax, r14, 3, 4660), 123)); + TEST_INSTRUCTION("6263C5080B527F7B" , vrndscalesd(xmm26, xmm7, qword_ptr(rdx, 1016), 123)); + TEST_INSTRUCTION("6263C5080B92000400007B" , vrndscalesd(xmm26, xmm7, qword_ptr(rdx, 1024), 123)); + TEST_INSTRUCTION("6263C5080B52807B" , vrndscalesd(xmm26, xmm7, qword_ptr(rdx, -1024), 123)); + TEST_INSTRUCTION("6263C5080B92F8FBFFFF7B" , vrndscalesd(xmm26, xmm7, qword_ptr(rdx, -1032), 123)); + TEST_INSTRUCTION("62F345000AFEAB" , vrndscaless(xmm7, xmm23, xmm6, 171)); + TEST_INSTRUCTION("62F345040AFEAB" , k(k4).vrndscaless(xmm7, xmm23, xmm6, 171)); + TEST_INSTRUCTION("62F345840AFEAB" , k(k4).z().vrndscaless(xmm7, xmm23, xmm6, 171)); + TEST_INSTRUCTION("62F345100AFEAB" , sae().vrndscaless(xmm7, xmm23, xmm6, 171)); + TEST_INSTRUCTION("62F345000AFE7B" , vrndscaless(xmm7, xmm23, xmm6, 123)); + TEST_INSTRUCTION("62F345100AFE7B" , sae().vrndscaless(xmm7, xmm23, xmm6, 123)); + TEST_INSTRUCTION("62F345000A397B" , vrndscaless(xmm7, xmm23, dword_ptr(rcx), 123)); + TEST_INSTRUCTION("62B345000ABCF0341200007B" , vrndscaless(xmm7, xmm23, dword_ptr(rax, r14, 3, 4660), 123)); + TEST_INSTRUCTION("62F345000A7A7F7B" , vrndscaless(xmm7, xmm23, dword_ptr(rdx, 508), 123)); + TEST_INSTRUCTION("62F345000ABA000200007B" , vrndscaless(xmm7, xmm23, dword_ptr(rdx, 512), 123)); + TEST_INSTRUCTION("62F345000A7A807B" , vrndscaless(xmm7, xmm23, dword_ptr(rdx, -512), 123)); + TEST_INSTRUCTION("62F345000ABAFCFDFFFF7B" , vrndscaless(xmm7, xmm23, dword_ptr(rdx, -516), 123)); + TEST_INSTRUCTION("62E2FD488B19" , vpcompressq(zmmword_ptr(rcx), zmm19)); + TEST_INSTRUCTION("62E2FD4B8B19" , k(k3).vpcompressq(zmmword_ptr(rcx), zmm19)); + TEST_INSTRUCTION("62A2FD488B9CF034120000" , vpcompressq(zmmword_ptr(rax, r14, 3, 4660), zmm19)); + TEST_INSTRUCTION("62E2FD488B5A7F" , vpcompressq(zmmword_ptr(rdx, 1016), zmm19)); + TEST_INSTRUCTION("62E2FD488B9A00040000" , vpcompressq(zmmword_ptr(rdx, 1024), zmm19)); + TEST_INSTRUCTION("62E2FD488B5A80" , vpcompressq(zmmword_ptr(rdx, -1024), zmm19)); + TEST_INSTRUCTION("62E2FD488B9AF8FBFFFF" , vpcompressq(zmmword_ptr(rdx, -1032), zmm19)); + TEST_INSTRUCTION("6252FD488BC4" , vpcompressq(zmm12, zmm8)); + TEST_INSTRUCTION("6252FD4E8BC4" , k(k6).vpcompressq(zmm12, zmm8)); + TEST_INSTRUCTION("6252FDCE8BC4" , k(k6).z().vpcompressq(zmm12, zmm8)); + TEST_INSTRUCTION("C5DC41EE" , kandw(k5, k4, k6)); + TEST_INSTRUCTION("C5DC42EE" , kandnw(k5, k4, k6)); + TEST_INSTRUCTION("C5E445D5" , korw(k2, k3, k5)); + TEST_INSTRUCTION("C5CC46D7" , kxnorw(k2, k6, k7)); + TEST_INSTRUCTION("C5DC47DE" , kxorw(k3, k4, k6)); + TEST_INSTRUCTION("C5F844E3" , knotw(k4, k3)); + TEST_INSTRUCTION("C5F898DE" , kortestw(k3, k6)); + TEST_INSTRUCTION("C4E3F930DDAB" , kshiftrw(k3, k5, 171)); + TEST_INSTRUCTION("C4E3F930DD7B" , kshiftrw(k3, k5, 123)); + TEST_INSTRUCTION("C4E3F932DBAB" , kshiftlw(k3, k3, 171)); + TEST_INSTRUCTION("C4E3F932DB7B" , kshiftlw(k3, k3, 123)); + TEST_INSTRUCTION("C5F890D5" , kmovw(k2, k5)); + TEST_INSTRUCTION("C5F89011" , kmovw(k2, word_ptr(rcx))); + TEST_INSTRUCTION("C4A1789094F034120000" , kmovw(k2, word_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("C5F89129" , kmovw(word_ptr(rcx), k5)); + TEST_INSTRUCTION("C4A17891ACF034120000" , kmovw(word_ptr(rax, r14, 3, 4660), k5)); + TEST_INSTRUCTION("C5F892D8" , kmovw(k3, eax)); + TEST_INSTRUCTION("C5F892DD" , kmovw(k3, ebp)); + TEST_INSTRUCTION("C4C17892DD" , kmovw(k3, r13d)); + TEST_INSTRUCTION("C5F893C3" , kmovw(eax, k3)); + TEST_INSTRUCTION("C5F893EB" , kmovw(ebp, k3)); + TEST_INSTRUCTION("C57893EB" , kmovw(r13d, k3)); + TEST_INSTRUCTION("C5E54BD7" , kunpckbw(k2, k3, k7)); + TEST_INSTRUCTION("62F37D481D31AB" , vcvtps2ph(ymmword_ptr(rcx), zmm6, 171)); + TEST_INSTRUCTION("62F37D491D31AB" , k(k1).vcvtps2ph(ymmword_ptr(rcx), zmm6, 171)); + TEST_INSTRUCTION("62F37D481D317B" , vcvtps2ph(ymmword_ptr(rcx), zmm6, 123)); + TEST_INSTRUCTION("62B37D481DB4F0341200007B" , vcvtps2ph(ymmword_ptr(rax, r14, 3, 4660), zmm6, 123)); + TEST_INSTRUCTION("62F37D481D727F7B" , vcvtps2ph(ymmword_ptr(rdx, 4064), zmm6, 123)); + TEST_INSTRUCTION("62F37D481DB2001000007B" , vcvtps2ph(ymmword_ptr(rdx, 4096), zmm6, 123)); + TEST_INSTRUCTION("62F37D481D72807B" , vcvtps2ph(ymmword_ptr(rdx, -4096), zmm6, 123)); + TEST_INSTRUCTION("62F37D481DB2E0EFFFFF7B" , vcvtps2ph(ymmword_ptr(rdx, -4128), zmm6, 123)); + TEST_INSTRUCTION("62E37D481931AB" , vextractf32x4(xmmword_ptr(rcx), zmm22, 171)); + TEST_INSTRUCTION("62E37D4B1931AB" , k(k3).vextractf32x4(xmmword_ptr(rcx), zmm22, 171)); + TEST_INSTRUCTION("62E37D4819317B" , vextractf32x4(xmmword_ptr(rcx), zmm22, 123)); + TEST_INSTRUCTION("62A37D4819B4F0341200007B" , vextractf32x4(xmmword_ptr(rax, r14, 3, 4660), zmm22, 123)); + TEST_INSTRUCTION("62E37D4819727F7B" , vextractf32x4(xmmword_ptr(rdx, 2032), zmm22, 123)); + TEST_INSTRUCTION("62E37D4819B2000800007B" , vextractf32x4(xmmword_ptr(rdx, 2048), zmm22, 123)); + TEST_INSTRUCTION("62E37D481972807B" , vextractf32x4(xmmword_ptr(rdx, -2048), zmm22, 123)); + TEST_INSTRUCTION("62E37D4819B2F0F7FFFF7B" , vextractf32x4(xmmword_ptr(rdx, -2064), zmm22, 123)); + TEST_INSTRUCTION("6273FD481B21AB" , vextractf64x4(ymmword_ptr(rcx), zmm12, 171)); + TEST_INSTRUCTION("6273FD4F1B21AB" , k(k7).vextractf64x4(ymmword_ptr(rcx), zmm12, 171)); + TEST_INSTRUCTION("6273FD481B217B" , vextractf64x4(ymmword_ptr(rcx), zmm12, 123)); + TEST_INSTRUCTION("6233FD481BA4F0341200007B" , vextractf64x4(ymmword_ptr(rax, r14, 3, 4660), zmm12, 123)); + TEST_INSTRUCTION("6273FD481B627F7B" , vextractf64x4(ymmword_ptr(rdx, 4064), zmm12, 123)); + TEST_INSTRUCTION("6273FD481BA2001000007B" , vextractf64x4(ymmword_ptr(rdx, 4096), zmm12, 123)); + TEST_INSTRUCTION("6273FD481B62807B" , vextractf64x4(ymmword_ptr(rdx, -4096), zmm12, 123)); + TEST_INSTRUCTION("6273FD481BA2E0EFFFFF7B" , vextractf64x4(ymmword_ptr(rdx, -4128), zmm12, 123)); + TEST_INSTRUCTION("62F37D483909AB" , vextracti32x4(xmmword_ptr(rcx), zmm1, 171)); + TEST_INSTRUCTION("62F37D4B3909AB" , k(k3).vextracti32x4(xmmword_ptr(rcx), zmm1, 171)); + TEST_INSTRUCTION("62F37D4839097B" , vextracti32x4(xmmword_ptr(rcx), zmm1, 123)); + TEST_INSTRUCTION("62B37D48398CF0341200007B" , vextracti32x4(xmmword_ptr(rax, r14, 3, 4660), zmm1, 123)); + TEST_INSTRUCTION("62F37D48394A7F7B" , vextracti32x4(xmmword_ptr(rdx, 2032), zmm1, 123)); + TEST_INSTRUCTION("62F37D48398A000800007B" , vextracti32x4(xmmword_ptr(rdx, 2048), zmm1, 123)); + TEST_INSTRUCTION("62F37D48394A807B" , vextracti32x4(xmmword_ptr(rdx, -2048), zmm1, 123)); + TEST_INSTRUCTION("62F37D48398AF0F7FFFF7B" , vextracti32x4(xmmword_ptr(rdx, -2064), zmm1, 123)); + TEST_INSTRUCTION("62F3FD483B11AB" , vextracti64x4(ymmword_ptr(rcx), zmm2, 171)); + TEST_INSTRUCTION("62F3FD4A3B11AB" , k(k2).vextracti64x4(ymmword_ptr(rcx), zmm2, 171)); + TEST_INSTRUCTION("62F3FD483B117B" , vextracti64x4(ymmword_ptr(rcx), zmm2, 123)); + TEST_INSTRUCTION("62B3FD483B94F0341200007B" , vextracti64x4(ymmword_ptr(rax, r14, 3, 4660), zmm2, 123)); + TEST_INSTRUCTION("62F3FD483B527F7B" , vextracti64x4(ymmword_ptr(rdx, 4064), zmm2, 123)); + TEST_INSTRUCTION("62F3FD483B92001000007B" , vextracti64x4(ymmword_ptr(rdx, 4096), zmm2, 123)); + TEST_INSTRUCTION("62F3FD483B52807B" , vextracti64x4(ymmword_ptr(rdx, -4096), zmm2, 123)); + TEST_INSTRUCTION("62F3FD483B92E0EFFFFF7B" , vextracti64x4(ymmword_ptr(rdx, -4128), zmm2, 123)); + TEST_INSTRUCTION("6261FD482919" , vmovapd(zmmword_ptr(rcx), zmm27)); + TEST_INSTRUCTION("6261FD492919" , k(k1).vmovapd(zmmword_ptr(rcx), zmm27)); + TEST_INSTRUCTION("6221FD48299CF034120000" , vmovapd(zmmword_ptr(rax, r14, 3, 4660), zmm27)); + TEST_INSTRUCTION("6261FD48295A7F" , vmovapd(zmmword_ptr(rdx, 8128), zmm27)); + TEST_INSTRUCTION("6261FD48299A00200000" , vmovapd(zmmword_ptr(rdx, 8192), zmm27)); + TEST_INSTRUCTION("6261FD48295A80" , vmovapd(zmmword_ptr(rdx, -8192), zmm27)); + TEST_INSTRUCTION("6261FD48299AC0DFFFFF" , vmovapd(zmmword_ptr(rdx, -8256), zmm27)); + TEST_INSTRUCTION("62E17C482909" , vmovaps(zmmword_ptr(rcx), zmm17)); + TEST_INSTRUCTION("62E17C4D2909" , k(k5).vmovaps(zmmword_ptr(rcx), zmm17)); + TEST_INSTRUCTION("62A17C48298CF034120000" , vmovaps(zmmword_ptr(rax, r14, 3, 4660), zmm17)); + TEST_INSTRUCTION("62E17C48294A7F" , vmovaps(zmmword_ptr(rdx, 8128), zmm17)); + TEST_INSTRUCTION("62E17C48298A00200000" , vmovaps(zmmword_ptr(rdx, 8192), zmm17)); + TEST_INSTRUCTION("62E17C48294A80" , vmovaps(zmmword_ptr(rdx, -8192), zmm17)); + TEST_INSTRUCTION("62E17C48298AC0DFFFFF" , vmovaps(zmmword_ptr(rdx, -8256), zmm17)); + TEST_INSTRUCTION("62F17D487F19" , vmovdqa32(zmmword_ptr(rcx), zmm3)); + TEST_INSTRUCTION("62F17D497F19" , k(k1).vmovdqa32(zmmword_ptr(rcx), zmm3)); + TEST_INSTRUCTION("62B17D487F9CF034120000" , vmovdqa32(zmmword_ptr(rax, r14, 3, 4660), zmm3)); + TEST_INSTRUCTION("62F17D487F5A7F" , vmovdqa32(zmmword_ptr(rdx, 8128), zmm3)); + TEST_INSTRUCTION("62F17D487F9A00200000" , vmovdqa32(zmmword_ptr(rdx, 8192), zmm3)); + TEST_INSTRUCTION("62F17D487F5A80" , vmovdqa32(zmmword_ptr(rdx, -8192), zmm3)); + TEST_INSTRUCTION("62F17D487F9AC0DFFFFF" , vmovdqa32(zmmword_ptr(rdx, -8256), zmm3)); + TEST_INSTRUCTION("62E1FD487F11" , vmovdqa64(zmmword_ptr(rcx), zmm18)); + TEST_INSTRUCTION("62E1FD497F11" , k(k1).vmovdqa64(zmmword_ptr(rcx), zmm18)); + TEST_INSTRUCTION("62A1FD487F94F034120000" , vmovdqa64(zmmword_ptr(rax, r14, 3, 4660), zmm18)); + TEST_INSTRUCTION("62E1FD487F527F" , vmovdqa64(zmmword_ptr(rdx, 8128), zmm18)); + TEST_INSTRUCTION("62E1FD487F9200200000" , vmovdqa64(zmmword_ptr(rdx, 8192), zmm18)); + TEST_INSTRUCTION("62E1FD487F5280" , vmovdqa64(zmmword_ptr(rdx, -8192), zmm18)); + TEST_INSTRUCTION("62E1FD487F92C0DFFFFF" , vmovdqa64(zmmword_ptr(rdx, -8256), zmm18)); + TEST_INSTRUCTION("62F17E487F11" , vmovdqu32(zmmword_ptr(rcx), zmm2)); + TEST_INSTRUCTION("62F17E4F7F11" , k(k7).vmovdqu32(zmmword_ptr(rcx), zmm2)); + TEST_INSTRUCTION("62B17E487F94F034120000" , vmovdqu32(zmmword_ptr(rax, r14, 3, 4660), zmm2)); + TEST_INSTRUCTION("62F17E487F527F" , vmovdqu32(zmmword_ptr(rdx, 8128), zmm2)); + TEST_INSTRUCTION("62F17E487F9200200000" , vmovdqu32(zmmword_ptr(rdx, 8192), zmm2)); + TEST_INSTRUCTION("62F17E487F5280" , vmovdqu32(zmmword_ptr(rdx, -8192), zmm2)); + TEST_INSTRUCTION("62F17E487F92C0DFFFFF" , vmovdqu32(zmmword_ptr(rdx, -8256), zmm2)); + TEST_INSTRUCTION("62F1FE487F39" , vmovdqu64(zmmword_ptr(rcx), zmm7)); + TEST_INSTRUCTION("62F1FE497F39" , k(k1).vmovdqu64(zmmword_ptr(rcx), zmm7)); + TEST_INSTRUCTION("62B1FE487FBCF034120000" , vmovdqu64(zmmword_ptr(rax, r14, 3, 4660), zmm7)); + TEST_INSTRUCTION("62F1FE487F7A7F" , vmovdqu64(zmmword_ptr(rdx, 8128), zmm7)); + TEST_INSTRUCTION("62F1FE487FBA00200000" , vmovdqu64(zmmword_ptr(rdx, 8192), zmm7)); + TEST_INSTRUCTION("62F1FE487F7A80" , vmovdqu64(zmmword_ptr(rdx, -8192), zmm7)); + TEST_INSTRUCTION("62F1FE487FBAC0DFFFFF" , vmovdqu64(zmmword_ptr(rdx, -8256), zmm7)); + TEST_INSTRUCTION("6271FD481101" , vmovupd(zmmword_ptr(rcx), zmm8)); + TEST_INSTRUCTION("6271FD4C1101" , k(k4).vmovupd(zmmword_ptr(rcx), zmm8)); + TEST_INSTRUCTION("6231FD481184F034120000" , vmovupd(zmmword_ptr(rax, r14, 3, 4660), zmm8)); + TEST_INSTRUCTION("6271FD4811427F" , vmovupd(zmmword_ptr(rdx, 8128), zmm8)); + TEST_INSTRUCTION("6271FD48118200200000" , vmovupd(zmmword_ptr(rdx, 8192), zmm8)); + TEST_INSTRUCTION("6271FD48114280" , vmovupd(zmmword_ptr(rdx, -8192), zmm8)); + TEST_INSTRUCTION("6271FD481182C0DFFFFF" , vmovupd(zmmword_ptr(rdx, -8256), zmm8)); + TEST_INSTRUCTION("62F17C481121" , vmovups(zmmword_ptr(rcx), zmm4)); + TEST_INSTRUCTION("62F17C491121" , k(k1).vmovups(zmmword_ptr(rcx), zmm4)); + TEST_INSTRUCTION("62B17C4811A4F034120000" , vmovups(zmmword_ptr(rax, r14, 3, 4660), zmm4)); + TEST_INSTRUCTION("62F17C4811627F" , vmovups(zmmword_ptr(rdx, 8128), zmm4)); + TEST_INSTRUCTION("62F17C4811A200200000" , vmovups(zmmword_ptr(rdx, 8192), zmm4)); + TEST_INSTRUCTION("62F17C48116280" , vmovups(zmmword_ptr(rdx, -8192), zmm4)); + TEST_INSTRUCTION("62F17C4811A2C0DFFFFF" , vmovups(zmmword_ptr(rdx, -8256), zmm4)); + TEST_INSTRUCTION("62727E483231" , vpmovqb(qword_ptr(rcx), zmm14)); + TEST_INSTRUCTION("62727E4A3231" , k(k2).vpmovqb(qword_ptr(rcx), zmm14)); + TEST_INSTRUCTION("62327E4832B4F034120000" , vpmovqb(qword_ptr(rax, r14, 3, 4660), zmm14)); + TEST_INSTRUCTION("62727E4832727F" , vpmovqb(qword_ptr(rdx, 1016), zmm14)); + TEST_INSTRUCTION("62727E4832B200040000" , vpmovqb(qword_ptr(rdx, 1024), zmm14)); + TEST_INSTRUCTION("62727E48327280" , vpmovqb(qword_ptr(rdx, -1024), zmm14)); + TEST_INSTRUCTION("62727E4832B2F8FBFFFF" , vpmovqb(qword_ptr(rdx, -1032), zmm14)); + TEST_INSTRUCTION("62E27E482211" , vpmovsqb(qword_ptr(rcx), zmm18)); + TEST_INSTRUCTION("62E27E4E2211" , k(k6).vpmovsqb(qword_ptr(rcx), zmm18)); + TEST_INSTRUCTION("62A27E482294F034120000" , vpmovsqb(qword_ptr(rax, r14, 3, 4660), zmm18)); + TEST_INSTRUCTION("62E27E4822527F" , vpmovsqb(qword_ptr(rdx, 1016), zmm18)); + TEST_INSTRUCTION("62E27E48229200040000" , vpmovsqb(qword_ptr(rdx, 1024), zmm18)); + TEST_INSTRUCTION("62E27E48225280" , vpmovsqb(qword_ptr(rdx, -1024), zmm18)); + TEST_INSTRUCTION("62E27E482292F8FBFFFF" , vpmovsqb(qword_ptr(rdx, -1032), zmm18)); + TEST_INSTRUCTION("62727E481229" , vpmovusqb(qword_ptr(rcx), zmm13)); + TEST_INSTRUCTION("62727E4A1229" , k(k2).vpmovusqb(qword_ptr(rcx), zmm13)); + TEST_INSTRUCTION("62327E4812ACF034120000" , vpmovusqb(qword_ptr(rax, r14, 3, 4660), zmm13)); + TEST_INSTRUCTION("62727E48126A7F" , vpmovusqb(qword_ptr(rdx, 1016), zmm13)); + TEST_INSTRUCTION("62727E4812AA00040000" , vpmovusqb(qword_ptr(rdx, 1024), zmm13)); + TEST_INSTRUCTION("62727E48126A80" , vpmovusqb(qword_ptr(rdx, -1024), zmm13)); + TEST_INSTRUCTION("62727E4812AAF8FBFFFF" , vpmovusqb(qword_ptr(rdx, -1032), zmm13)); + TEST_INSTRUCTION("62E27E483431" , vpmovqw(xmmword_ptr(rcx), zmm22)); + TEST_INSTRUCTION("62E27E4E3431" , k(k6).vpmovqw(xmmword_ptr(rcx), zmm22)); + TEST_INSTRUCTION("62A27E4834B4F034120000" , vpmovqw(xmmword_ptr(rax, r14, 3, 4660), zmm22)); + TEST_INSTRUCTION("62E27E4834727F" , vpmovqw(xmmword_ptr(rdx, 2032), zmm22)); + TEST_INSTRUCTION("62E27E4834B200080000" , vpmovqw(xmmword_ptr(rdx, 2048), zmm22)); + TEST_INSTRUCTION("62E27E48347280" , vpmovqw(xmmword_ptr(rdx, -2048), zmm22)); + TEST_INSTRUCTION("62E27E4834B2F0F7FFFF" , vpmovqw(xmmword_ptr(rdx, -2064), zmm22)); + TEST_INSTRUCTION("62627E482411" , vpmovsqw(xmmword_ptr(rcx), zmm26)); + TEST_INSTRUCTION("62627E4A2411" , k(k2).vpmovsqw(xmmword_ptr(rcx), zmm26)); + TEST_INSTRUCTION("62227E482494F034120000" , vpmovsqw(xmmword_ptr(rax, r14, 3, 4660), zmm26)); + TEST_INSTRUCTION("62627E4824527F" , vpmovsqw(xmmword_ptr(rdx, 2032), zmm26)); + TEST_INSTRUCTION("62627E48249200080000" , vpmovsqw(xmmword_ptr(rdx, 2048), zmm26)); + TEST_INSTRUCTION("62627E48245280" , vpmovsqw(xmmword_ptr(rdx, -2048), zmm26)); + TEST_INSTRUCTION("62627E482492F0F7FFFF" , vpmovsqw(xmmword_ptr(rdx, -2064), zmm26)); + TEST_INSTRUCTION("62F27E481431" , vpmovusqw(xmmword_ptr(rcx), zmm6)); + TEST_INSTRUCTION("62F27E4F1431" , k(k7).vpmovusqw(xmmword_ptr(rcx), zmm6)); + TEST_INSTRUCTION("62B27E4814B4F034120000" , vpmovusqw(xmmword_ptr(rax, r14, 3, 4660), zmm6)); + TEST_INSTRUCTION("62F27E4814727F" , vpmovusqw(xmmword_ptr(rdx, 2032), zmm6)); + TEST_INSTRUCTION("62F27E4814B200080000" , vpmovusqw(xmmword_ptr(rdx, 2048), zmm6)); + TEST_INSTRUCTION("62F27E48147280" , vpmovusqw(xmmword_ptr(rdx, -2048), zmm6)); + TEST_INSTRUCTION("62F27E4814B2F0F7FFFF" , vpmovusqw(xmmword_ptr(rdx, -2064), zmm6)); + TEST_INSTRUCTION("62727E483511" , vpmovqd(ymmword_ptr(rcx), zmm10)); + TEST_INSTRUCTION("62727E4D3511" , k(k5).vpmovqd(ymmword_ptr(rcx), zmm10)); + TEST_INSTRUCTION("62327E483594F034120000" , vpmovqd(ymmword_ptr(rax, r14, 3, 4660), zmm10)); + TEST_INSTRUCTION("62727E4835527F" , vpmovqd(ymmword_ptr(rdx, 4064), zmm10)); + TEST_INSTRUCTION("62727E48359200100000" , vpmovqd(ymmword_ptr(rdx, 4096), zmm10)); + TEST_INSTRUCTION("62727E48355280" , vpmovqd(ymmword_ptr(rdx, -4096), zmm10)); + TEST_INSTRUCTION("62727E483592E0EFFFFF" , vpmovqd(ymmword_ptr(rdx, -4128), zmm10)); + TEST_INSTRUCTION("62E27E482511" , vpmovsqd(ymmword_ptr(rcx), zmm18)); + TEST_INSTRUCTION("62E27E4D2511" , k(k5).vpmovsqd(ymmword_ptr(rcx), zmm18)); + TEST_INSTRUCTION("62A27E482594F034120000" , vpmovsqd(ymmword_ptr(rax, r14, 3, 4660), zmm18)); + TEST_INSTRUCTION("62E27E4825527F" , vpmovsqd(ymmword_ptr(rdx, 4064), zmm18)); + TEST_INSTRUCTION("62E27E48259200100000" , vpmovsqd(ymmword_ptr(rdx, 4096), zmm18)); + TEST_INSTRUCTION("62E27E48255280" , vpmovsqd(ymmword_ptr(rdx, -4096), zmm18)); + TEST_INSTRUCTION("62E27E482592E0EFFFFF" , vpmovsqd(ymmword_ptr(rdx, -4128), zmm18)); + TEST_INSTRUCTION("62E27E481509" , vpmovusqd(ymmword_ptr(rcx), zmm17)); + TEST_INSTRUCTION("62E27E4C1509" , k(k4).vpmovusqd(ymmword_ptr(rcx), zmm17)); + TEST_INSTRUCTION("62A27E48158CF034120000" , vpmovusqd(ymmword_ptr(rax, r14, 3, 4660), zmm17)); + TEST_INSTRUCTION("62E27E48154A7F" , vpmovusqd(ymmword_ptr(rdx, 4064), zmm17)); + TEST_INSTRUCTION("62E27E48158A00100000" , vpmovusqd(ymmword_ptr(rdx, 4096), zmm17)); + TEST_INSTRUCTION("62E27E48154A80" , vpmovusqd(ymmword_ptr(rdx, -4096), zmm17)); + TEST_INSTRUCTION("62E27E48158AE0EFFFFF" , vpmovusqd(ymmword_ptr(rdx, -4128), zmm17)); + TEST_INSTRUCTION("62627E483129" , vpmovdb(xmmword_ptr(rcx), zmm29)); + TEST_INSTRUCTION("62627E4C3129" , k(k4).vpmovdb(xmmword_ptr(rcx), zmm29)); + TEST_INSTRUCTION("62227E4831ACF034120000" , vpmovdb(xmmword_ptr(rax, r14, 3, 4660), zmm29)); + TEST_INSTRUCTION("62627E48316A7F" , vpmovdb(xmmword_ptr(rdx, 2032), zmm29)); + TEST_INSTRUCTION("62627E4831AA00080000" , vpmovdb(xmmword_ptr(rdx, 2048), zmm29)); + TEST_INSTRUCTION("62627E48316A80" , vpmovdb(xmmword_ptr(rdx, -2048), zmm29)); + TEST_INSTRUCTION("62627E4831AAF0F7FFFF" , vpmovdb(xmmword_ptr(rdx, -2064), zmm29)); + TEST_INSTRUCTION("62627E482121" , vpmovsdb(xmmword_ptr(rcx), zmm28)); + TEST_INSTRUCTION("62627E4D2121" , k(k5).vpmovsdb(xmmword_ptr(rcx), zmm28)); + TEST_INSTRUCTION("62227E4821A4F034120000" , vpmovsdb(xmmword_ptr(rax, r14, 3, 4660), zmm28)); + TEST_INSTRUCTION("62627E4821627F" , vpmovsdb(xmmword_ptr(rdx, 2032), zmm28)); + TEST_INSTRUCTION("62627E4821A200080000" , vpmovsdb(xmmword_ptr(rdx, 2048), zmm28)); + TEST_INSTRUCTION("62627E48216280" , vpmovsdb(xmmword_ptr(rdx, -2048), zmm28)); + TEST_INSTRUCTION("62627E4821A2F0F7FFFF" , vpmovsdb(xmmword_ptr(rdx, -2064), zmm28)); + TEST_INSTRUCTION("62627E481131" , vpmovusdb(xmmword_ptr(rcx), zmm30)); + TEST_INSTRUCTION("62627E491131" , k(k1).vpmovusdb(xmmword_ptr(rcx), zmm30)); + TEST_INSTRUCTION("62227E4811B4F034120000" , vpmovusdb(xmmword_ptr(rax, r14, 3, 4660), zmm30)); + TEST_INSTRUCTION("62627E4811727F" , vpmovusdb(xmmword_ptr(rdx, 2032), zmm30)); + TEST_INSTRUCTION("62627E4811B200080000" , vpmovusdb(xmmword_ptr(rdx, 2048), zmm30)); + TEST_INSTRUCTION("62627E48117280" , vpmovusdb(xmmword_ptr(rdx, -2048), zmm30)); + TEST_INSTRUCTION("62627E4811B2F0F7FFFF" , vpmovusdb(xmmword_ptr(rdx, -2064), zmm30)); + TEST_INSTRUCTION("62F27E483329" , vpmovdw(ymmword_ptr(rcx), zmm5)); + TEST_INSTRUCTION("62F27E4F3329" , k(k7).vpmovdw(ymmword_ptr(rcx), zmm5)); + TEST_INSTRUCTION("62B27E4833ACF034120000" , vpmovdw(ymmword_ptr(rax, r14, 3, 4660), zmm5)); + TEST_INSTRUCTION("62F27E48336A7F" , vpmovdw(ymmword_ptr(rdx, 4064), zmm5)); + TEST_INSTRUCTION("62F27E4833AA00100000" , vpmovdw(ymmword_ptr(rdx, 4096), zmm5)); + TEST_INSTRUCTION("62F27E48336A80" , vpmovdw(ymmword_ptr(rdx, -4096), zmm5)); + TEST_INSTRUCTION("62F27E4833AAE0EFFFFF" , vpmovdw(ymmword_ptr(rdx, -4128), zmm5)); + TEST_INSTRUCTION("62E27E482311" , vpmovsdw(ymmword_ptr(rcx), zmm18)); + TEST_INSTRUCTION("62E27E4F2311" , k(k7).vpmovsdw(ymmword_ptr(rcx), zmm18)); + TEST_INSTRUCTION("62A27E482394F034120000" , vpmovsdw(ymmword_ptr(rax, r14, 3, 4660), zmm18)); + TEST_INSTRUCTION("62E27E4823527F" , vpmovsdw(ymmword_ptr(rdx, 4064), zmm18)); + TEST_INSTRUCTION("62E27E48239200100000" , vpmovsdw(ymmword_ptr(rdx, 4096), zmm18)); + TEST_INSTRUCTION("62E27E48235280" , vpmovsdw(ymmword_ptr(rdx, -4096), zmm18)); + TEST_INSTRUCTION("62E27E482392E0EFFFFF" , vpmovsdw(ymmword_ptr(rdx, -4128), zmm18)); + TEST_INSTRUCTION("62F27E481329" , vpmovusdw(ymmword_ptr(rcx), zmm5)); + TEST_INSTRUCTION("62F27E4C1329" , k(k4).vpmovusdw(ymmword_ptr(rcx), zmm5)); + TEST_INSTRUCTION("62B27E4813ACF034120000" , vpmovusdw(ymmword_ptr(rax, r14, 3, 4660), zmm5)); + TEST_INSTRUCTION("62F27E48136A7F" , vpmovusdw(ymmword_ptr(rdx, 4064), zmm5)); + TEST_INSTRUCTION("62F27E4813AA00100000" , vpmovusdw(ymmword_ptr(rdx, 4096), zmm5)); + TEST_INSTRUCTION("62F27E48136A80" , vpmovusdw(ymmword_ptr(rdx, -4096), zmm5)); + TEST_INSTRUCTION("62F27E4813AAE0EFFFFF" , vpmovusdw(ymmword_ptr(rdx, -4128), zmm5)); + TEST_INSTRUCTION("62C1FC4878E6" , vcvttpd2udq(ymm20, zmm14)); + TEST_INSTRUCTION("62C1FC4B78E6" , k(k3).vcvttpd2udq(ymm20, zmm14)); + TEST_INSTRUCTION("62C1FCCB78E6" , k(k3).z().vcvttpd2udq(ymm20, zmm14)); + TEST_INSTRUCTION("62C1FC1878E6" , sae().vcvttpd2udq(ymm20, zmm14)); + TEST_INSTRUCTION("62E1FC487821" , vcvttpd2udq(ymm20, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62A1FC4878A4F034120000" , vcvttpd2udq(ymm20, zmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62E1FC587821" , vcvttpd2udq(ymm20, qword_ptr(rcx)._1to8())); + TEST_INSTRUCTION("62E1FC4878627F" , vcvttpd2udq(ymm20, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62E1FC4878A200200000" , vcvttpd2udq(ymm20, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62E1FC48786280" , vcvttpd2udq(ymm20, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62E1FC4878A2C0DFFFFF" , vcvttpd2udq(ymm20, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62E1FC5878627F" , vcvttpd2udq(ymm20, qword_ptr(rdx, 1016)._1to8())); + TEST_INSTRUCTION("62E1FC5878A200040000" , vcvttpd2udq(ymm20, qword_ptr(rdx, 1024)._1to8())); + TEST_INSTRUCTION("62E1FC58786280" , vcvttpd2udq(ymm20, qword_ptr(rdx, -1024)._1to8())); + TEST_INSTRUCTION("62E1FC5878A2F8FBFFFF" , vcvttpd2udq(ymm20, qword_ptr(rdx, -1032)._1to8())); + TEST_INSTRUCTION("62B17C4878EC" , vcvttps2udq(zmm5, zmm20)); + TEST_INSTRUCTION("62B17C4A78EC" , k(k2).vcvttps2udq(zmm5, zmm20)); + TEST_INSTRUCTION("62B17CCA78EC" , k(k2).z().vcvttps2udq(zmm5, zmm20)); + TEST_INSTRUCTION("62B17C1878EC" , sae().vcvttps2udq(zmm5, zmm20)); + TEST_INSTRUCTION("62F17C487829" , vcvttps2udq(zmm5, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62B17C4878ACF034120000" , vcvttps2udq(zmm5, zmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62F17C587829" , vcvttps2udq(zmm5, dword_ptr(rcx)._1to16())); + TEST_INSTRUCTION("62F17C48786A7F" , vcvttps2udq(zmm5, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62F17C4878AA00200000" , vcvttps2udq(zmm5, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62F17C48786A80" , vcvttps2udq(zmm5, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62F17C4878AAC0DFFFFF" , vcvttps2udq(zmm5, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62F17C58786A7F" , vcvttps2udq(zmm5, dword_ptr(rdx, 508)._1to16())); + TEST_INSTRUCTION("62F17C5878AA00020000" , vcvttps2udq(zmm5, dword_ptr(rdx, 512)._1to16())); + TEST_INSTRUCTION("62F17C58786A80" , vcvttps2udq(zmm5, dword_ptr(rdx, -512)._1to16())); + TEST_INSTRUCTION("62F17C5878AAFCFDFFFF" , vcvttps2udq(zmm5, dword_ptr(rdx, -516)._1to16())); + TEST_INSTRUCTION("62B17F0878C7" , vcvttsd2usi(eax, xmm23)); + TEST_INSTRUCTION("62B17F1878C7" , sae().vcvttsd2usi(eax, xmm23)); + TEST_INSTRUCTION("62F17F087801" , vcvttsd2usi(eax, qword_ptr(rcx))); + TEST_INSTRUCTION("62B17F087884F034120000" , vcvttsd2usi(eax, qword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62F17F0878427F" , vcvttsd2usi(eax, qword_ptr(rdx, 1016))); + TEST_INSTRUCTION("62F17F08788200040000" , vcvttsd2usi(eax, qword_ptr(rdx, 1024))); + TEST_INSTRUCTION("62F17F08784280" , vcvttsd2usi(eax, qword_ptr(rdx, -1024))); + TEST_INSTRUCTION("62F17F087882F8FBFFFF" , vcvttsd2usi(eax, qword_ptr(rdx, -1032))); + TEST_INSTRUCTION("62B17F0878EF" , vcvttsd2usi(ebp, xmm23)); + TEST_INSTRUCTION("62B17F1878EF" , sae().vcvttsd2usi(ebp, xmm23)); + TEST_INSTRUCTION("62F17F087829" , vcvttsd2usi(ebp, qword_ptr(rcx))); + TEST_INSTRUCTION("62B17F0878ACF034120000" , vcvttsd2usi(ebp, qword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62F17F08786A7F" , vcvttsd2usi(ebp, qword_ptr(rdx, 1016))); + TEST_INSTRUCTION("62F17F0878AA00040000" , vcvttsd2usi(ebp, qword_ptr(rdx, 1024))); + TEST_INSTRUCTION("62F17F08786A80" , vcvttsd2usi(ebp, qword_ptr(rdx, -1024))); + TEST_INSTRUCTION("62F17F0878AAF8FBFFFF" , vcvttsd2usi(ebp, qword_ptr(rdx, -1032))); + TEST_INSTRUCTION("62317F0878EF" , vcvttsd2usi(r13d, xmm23)); + TEST_INSTRUCTION("62317F1878EF" , sae().vcvttsd2usi(r13d, xmm23)); + TEST_INSTRUCTION("62717F087829" , vcvttsd2usi(r13d, qword_ptr(rcx))); + TEST_INSTRUCTION("62317F0878ACF034120000" , vcvttsd2usi(r13d, qword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62717F08786A7F" , vcvttsd2usi(r13d, qword_ptr(rdx, 1016))); + TEST_INSTRUCTION("62717F0878AA00040000" , vcvttsd2usi(r13d, qword_ptr(rdx, 1024))); + TEST_INSTRUCTION("62717F08786A80" , vcvttsd2usi(r13d, qword_ptr(rdx, -1024))); + TEST_INSTRUCTION("62717F0878AAF8FBFFFF" , vcvttsd2usi(r13d, qword_ptr(rdx, -1032))); + TEST_INSTRUCTION("62B1FF0878C3" , vcvttsd2usi(rax, xmm19)); + TEST_INSTRUCTION("62B1FF1878C3" , sae().vcvttsd2usi(rax, xmm19)); + TEST_INSTRUCTION("62F1FF087801" , vcvttsd2usi(rax, qword_ptr(rcx))); + TEST_INSTRUCTION("62B1FF087884F034120000" , vcvttsd2usi(rax, qword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62F1FF0878427F" , vcvttsd2usi(rax, qword_ptr(rdx, 1016))); + TEST_INSTRUCTION("62F1FF08788200040000" , vcvttsd2usi(rax, qword_ptr(rdx, 1024))); + TEST_INSTRUCTION("62F1FF08784280" , vcvttsd2usi(rax, qword_ptr(rdx, -1024))); + TEST_INSTRUCTION("62F1FF087882F8FBFFFF" , vcvttsd2usi(rax, qword_ptr(rdx, -1032))); + TEST_INSTRUCTION("6231FF0878C3" , vcvttsd2usi(r8, xmm19)); + TEST_INSTRUCTION("6231FF1878C3" , sae().vcvttsd2usi(r8, xmm19)); + TEST_INSTRUCTION("6271FF087801" , vcvttsd2usi(r8, qword_ptr(rcx))); + TEST_INSTRUCTION("6231FF087884F034120000" , vcvttsd2usi(r8, qword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("6271FF0878427F" , vcvttsd2usi(r8, qword_ptr(rdx, 1016))); + TEST_INSTRUCTION("6271FF08788200040000" , vcvttsd2usi(r8, qword_ptr(rdx, 1024))); + TEST_INSTRUCTION("6271FF08784280" , vcvttsd2usi(r8, qword_ptr(rdx, -1024))); + TEST_INSTRUCTION("6271FF087882F8FBFFFF" , vcvttsd2usi(r8, qword_ptr(rdx, -1032))); + TEST_INSTRUCTION("62B17E0878C5" , vcvttss2usi(eax, xmm21)); + TEST_INSTRUCTION("62B17E1878C5" , sae().vcvttss2usi(eax, xmm21)); + TEST_INSTRUCTION("62F17E087801" , vcvttss2usi(eax, dword_ptr(rcx))); + TEST_INSTRUCTION("62B17E087884F034120000" , vcvttss2usi(eax, dword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62F17E0878427F" , vcvttss2usi(eax, dword_ptr(rdx, 508))); + TEST_INSTRUCTION("62F17E08788200020000" , vcvttss2usi(eax, dword_ptr(rdx, 512))); + TEST_INSTRUCTION("62F17E08784280" , vcvttss2usi(eax, dword_ptr(rdx, -512))); + TEST_INSTRUCTION("62F17E087882FCFDFFFF" , vcvttss2usi(eax, dword_ptr(rdx, -516))); + TEST_INSTRUCTION("62B17E0878ED" , vcvttss2usi(ebp, xmm21)); + TEST_INSTRUCTION("62B17E1878ED" , sae().vcvttss2usi(ebp, xmm21)); + TEST_INSTRUCTION("62F17E087829" , vcvttss2usi(ebp, dword_ptr(rcx))); + TEST_INSTRUCTION("62B17E0878ACF034120000" , vcvttss2usi(ebp, dword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62F17E08786A7F" , vcvttss2usi(ebp, dword_ptr(rdx, 508))); + TEST_INSTRUCTION("62F17E0878AA00020000" , vcvttss2usi(ebp, dword_ptr(rdx, 512))); + TEST_INSTRUCTION("62F17E08786A80" , vcvttss2usi(ebp, dword_ptr(rdx, -512))); + TEST_INSTRUCTION("62F17E0878AAFCFDFFFF" , vcvttss2usi(ebp, dword_ptr(rdx, -516))); + TEST_INSTRUCTION("62317E0878ED" , vcvttss2usi(r13d, xmm21)); + TEST_INSTRUCTION("62317E1878ED" , sae().vcvttss2usi(r13d, xmm21)); + TEST_INSTRUCTION("62717E087829" , vcvttss2usi(r13d, dword_ptr(rcx))); + TEST_INSTRUCTION("62317E0878ACF034120000" , vcvttss2usi(r13d, dword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62717E08786A7F" , vcvttss2usi(r13d, dword_ptr(rdx, 508))); + TEST_INSTRUCTION("62717E0878AA00020000" , vcvttss2usi(r13d, dword_ptr(rdx, 512))); + TEST_INSTRUCTION("62717E08786A80" , vcvttss2usi(r13d, dword_ptr(rdx, -512))); + TEST_INSTRUCTION("62717E0878AAFCFDFFFF" , vcvttss2usi(r13d, dword_ptr(rdx, -516))); + TEST_INSTRUCTION("62F1FE0878C7" , vcvttss2usi(rax, xmm7)); + TEST_INSTRUCTION("62F1FE1878C7" , sae().vcvttss2usi(rax, xmm7)); + TEST_INSTRUCTION("62F1FE087801" , vcvttss2usi(rax, dword_ptr(rcx))); + TEST_INSTRUCTION("62B1FE087884F034120000" , vcvttss2usi(rax, dword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62F1FE0878427F" , vcvttss2usi(rax, dword_ptr(rdx, 508))); + TEST_INSTRUCTION("62F1FE08788200020000" , vcvttss2usi(rax, dword_ptr(rdx, 512))); + TEST_INSTRUCTION("62F1FE08784280" , vcvttss2usi(rax, dword_ptr(rdx, -512))); + TEST_INSTRUCTION("62F1FE087882FCFDFFFF" , vcvttss2usi(rax, dword_ptr(rdx, -516))); + TEST_INSTRUCTION("6271FE0878C7" , vcvttss2usi(r8, xmm7)); + TEST_INSTRUCTION("6271FE1878C7" , sae().vcvttss2usi(r8, xmm7)); + TEST_INSTRUCTION("6271FE087801" , vcvttss2usi(r8, dword_ptr(rcx))); + TEST_INSTRUCTION("6231FE087884F034120000" , vcvttss2usi(r8, dword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("6271FE0878427F" , vcvttss2usi(r8, dword_ptr(rdx, 508))); + TEST_INSTRUCTION("6271FE08788200020000" , vcvttss2usi(r8, dword_ptr(rdx, 512))); + TEST_INSTRUCTION("6271FE08784280" , vcvttss2usi(r8, dword_ptr(rdx, -512))); + TEST_INSTRUCTION("6271FE087882FCFDFFFF" , vcvttss2usi(r8, dword_ptr(rdx, -516))); + TEST_INSTRUCTION("6252654876C9" , vpermi2d(zmm9, zmm3, zmm9)); + TEST_INSTRUCTION("6252654976C9" , k(k1).vpermi2d(zmm9, zmm3, zmm9)); + TEST_INSTRUCTION("625265C976C9" , k(k1).z().vpermi2d(zmm9, zmm3, zmm9)); + TEST_INSTRUCTION("627265487609" , vpermi2d(zmm9, zmm3, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62326548768CF034120000" , vpermi2d(zmm9, zmm3, zmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("627265587609" , vpermi2d(zmm9, zmm3, dword_ptr(rcx)._1to16())); + TEST_INSTRUCTION("62726548764A7F" , vpermi2d(zmm9, zmm3, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62726548768A00200000" , vpermi2d(zmm9, zmm3, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62726548764A80" , vpermi2d(zmm9, zmm3, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62726548768AC0DFFFFF" , vpermi2d(zmm9, zmm3, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62726558764A7F" , vpermi2d(zmm9, zmm3, dword_ptr(rdx, 508)._1to16())); + TEST_INSTRUCTION("62726558768A00020000" , vpermi2d(zmm9, zmm3, dword_ptr(rdx, 512)._1to16())); + TEST_INSTRUCTION("62726558764A80" , vpermi2d(zmm9, zmm3, dword_ptr(rdx, -512)._1to16())); + TEST_INSTRUCTION("62726558768AFCFDFFFF" , vpermi2d(zmm9, zmm3, dword_ptr(rdx, -516)._1to16())); + TEST_INSTRUCTION("6282CD4076E9" , vpermi2q(zmm21, zmm22, zmm25)); + TEST_INSTRUCTION("6282CD4276E9" , k(k2).vpermi2q(zmm21, zmm22, zmm25)); + TEST_INSTRUCTION("6282CDC276E9" , k(k2).z().vpermi2q(zmm21, zmm22, zmm25)); + TEST_INSTRUCTION("62E2CD407629" , vpermi2q(zmm21, zmm22, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62A2CD4076ACF034120000" , vpermi2q(zmm21, zmm22, zmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62E2CD507629" , vpermi2q(zmm21, zmm22, qword_ptr(rcx)._1to8())); + TEST_INSTRUCTION("62E2CD40766A7F" , vpermi2q(zmm21, zmm22, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62E2CD4076AA00200000" , vpermi2q(zmm21, zmm22, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62E2CD40766A80" , vpermi2q(zmm21, zmm22, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62E2CD4076AAC0DFFFFF" , vpermi2q(zmm21, zmm22, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62E2CD50766A7F" , vpermi2q(zmm21, zmm22, qword_ptr(rdx, 1016)._1to8())); + TEST_INSTRUCTION("62E2CD5076AA00040000" , vpermi2q(zmm21, zmm22, qword_ptr(rdx, 1024)._1to8())); + TEST_INSTRUCTION("62E2CD50766A80" , vpermi2q(zmm21, zmm22, qword_ptr(rdx, -1024)._1to8())); + TEST_INSTRUCTION("62E2CD5076AAF8FBFFFF" , vpermi2q(zmm21, zmm22, qword_ptr(rdx, -1032)._1to8())); + TEST_INSTRUCTION("62622D4077D1" , vpermi2ps(zmm26, zmm26, zmm1)); + TEST_INSTRUCTION("62622D4577D1" , k(k5).vpermi2ps(zmm26, zmm26, zmm1)); + TEST_INSTRUCTION("62622DC577D1" , k(k5).z().vpermi2ps(zmm26, zmm26, zmm1)); + TEST_INSTRUCTION("62622D407711" , vpermi2ps(zmm26, zmm26, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62222D407794F034120000" , vpermi2ps(zmm26, zmm26, zmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62622D507711" , vpermi2ps(zmm26, zmm26, dword_ptr(rcx)._1to16())); + TEST_INSTRUCTION("62622D4077527F" , vpermi2ps(zmm26, zmm26, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62622D40779200200000" , vpermi2ps(zmm26, zmm26, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62622D40775280" , vpermi2ps(zmm26, zmm26, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62622D407792C0DFFFFF" , vpermi2ps(zmm26, zmm26, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62622D5077527F" , vpermi2ps(zmm26, zmm26, dword_ptr(rdx, 508)._1to16())); + TEST_INSTRUCTION("62622D50779200020000" , vpermi2ps(zmm26, zmm26, dword_ptr(rdx, 512)._1to16())); + TEST_INSTRUCTION("62622D50775280" , vpermi2ps(zmm26, zmm26, dword_ptr(rdx, -512)._1to16())); + TEST_INSTRUCTION("62622D507792FCFDFFFF" , vpermi2ps(zmm26, zmm26, dword_ptr(rdx, -516)._1to16())); + TEST_INSTRUCTION("62A2A54077ED" , vpermi2pd(zmm21, zmm27, zmm21)); + TEST_INSTRUCTION("62A2A54477ED" , k(k4).vpermi2pd(zmm21, zmm27, zmm21)); + TEST_INSTRUCTION("62A2A5C477ED" , k(k4).z().vpermi2pd(zmm21, zmm27, zmm21)); + TEST_INSTRUCTION("62E2A5407729" , vpermi2pd(zmm21, zmm27, zmmword_ptr(rcx))); + TEST_INSTRUCTION("62A2A54077ACF034120000" , vpermi2pd(zmm21, zmm27, zmmword_ptr(rax, r14, 3, 4660))); + TEST_INSTRUCTION("62E2A5507729" , vpermi2pd(zmm21, zmm27, qword_ptr(rcx)._1to8())); + TEST_INSTRUCTION("62E2A540776A7F" , vpermi2pd(zmm21, zmm27, zmmword_ptr(rdx, 8128))); + TEST_INSTRUCTION("62E2A54077AA00200000" , vpermi2pd(zmm21, zmm27, zmmword_ptr(rdx, 8192))); + TEST_INSTRUCTION("62E2A540776A80" , vpermi2pd(zmm21, zmm27, zmmword_ptr(rdx, -8192))); + TEST_INSTRUCTION("62E2A54077AAC0DFFFFF" , vpermi2pd(zmm21, zmm27, zmmword_ptr(rdx, -8256))); + TEST_INSTRUCTION("62E2A550776A7F" , vpermi2pd(zmm21, zmm27, qword_ptr(rdx, 1016)._1to8())); + TEST_INSTRUCTION("62E2A55077AA00040000" , vpermi2pd(zmm21, zmm27, qword_ptr(rdx, 1024)._1to8())); + TEST_INSTRUCTION("62E2A550776A80" , vpermi2pd(zmm21, zmm27, qword_ptr(rdx, -1024)._1to8())); + TEST_INSTRUCTION("62E2A55077AAF8FBFFFF" , vpermi2pd(zmm21, zmm27, qword_ptr(rdx, -1032)._1to8())); + TEST_INSTRUCTION("62D2FD4192B4C67B000000" , k(k1).vgatherdpd(zmm6, zmmword_ptr(r14, ymm16, 3, 123))); + TEST_INSTRUCTION("62D2FD4192740120" , k(k1).vgatherdpd(zmm6, zmmword_ptr(r9, ymm16, 0, 256))); + TEST_INSTRUCTION("62F2FD4192B48100040000" , k(k1).vgatherdpd(zmm6, zmmword_ptr(rcx, ymm16, 2, 1024))); + TEST_INSTRUCTION("62527D41928CDE7B000000" , k(k1).vgatherdps(zmm9, zmmword_ptr(r14, zmm19, 3, 123))); + TEST_INSTRUCTION("62527D41924C1940" , k(k1).vgatherdps(zmm9, zmmword_ptr(r9, zmm19, 0, 256))); + TEST_INSTRUCTION("62727D41928C9900040000" , k(k1).vgatherdps(zmm9, zmmword_ptr(rcx, zmm19, 2, 1024))); + TEST_INSTRUCTION("6242FD4993ACD67B000000" , k(k1).vgatherqpd(zmm29, zmmword_ptr(r14, zmm2, 3, 123))); + TEST_INSTRUCTION("6242FD49936C1120" , k(k1).vgatherqpd(zmm29, zmmword_ptr(r9, zmm2, 0, 256))); + TEST_INSTRUCTION("6262FD4993AC9100040000" , k(k1).vgatherqpd(zmm29, zmmword_ptr(rcx, zmm2, 2, 1024))); + TEST_INSTRUCTION("62C27D499394E67B000000" , k(k1).vgatherqps(ymm18, ymmword_ptr(r14, zmm4, 3, 123))); + TEST_INSTRUCTION("62C27D4993542140" , k(k1).vgatherqps(ymm18, ymmword_ptr(r9, zmm4, 0, 256))); + TEST_INSTRUCTION("62E27D499394A100040000" , k(k1).vgatherqps(ymm18, ymmword_ptr(rcx, zmm4, 2, 1024))); + TEST_INSTRUCTION("62827D49908CDE7B000000" , k(k1).vpgatherdd(zmm17, zmmword_ptr(r14, zmm11, 3, 123))); + TEST_INSTRUCTION("62827D49904C1940" , k(k1).vpgatherdd(zmm17, zmmword_ptr(r9, zmm11, 0, 256))); + TEST_INSTRUCTION("62A27D49908C9900040000" , k(k1).vpgatherdd(zmm17, zmmword_ptr(rcx, zmm11, 2, 1024))); + TEST_INSTRUCTION("6212FD499084F67B000000" , k(k1).vpgatherdq(zmm8, zmmword_ptr(r14, ymm14, 3, 123))); + TEST_INSTRUCTION("6212FD4990443120" , k(k1).vpgatherdq(zmm8, zmmword_ptr(r9, ymm14, 0, 256))); + TEST_INSTRUCTION("6232FD499084B100040000" , k(k1).vpgatherdq(zmm8, zmmword_ptr(rcx, ymm14, 2, 1024))); + TEST_INSTRUCTION("62D27D41919CCE7B000000" , k(k1).vpgatherqd(ymm3, ymmword_ptr(r14, zmm17, 3, 123))); + TEST_INSTRUCTION("62D27D41915C0940" , k(k1).vpgatherqd(ymm3, ymmword_ptr(r9, zmm17, 0, 256))); + TEST_INSTRUCTION("62F27D41919C8900040000" , k(k1).vpgatherqd(ymm3, ymmword_ptr(rcx, zmm17, 2, 1024))); + TEST_INSTRUCTION("62C2FD41918CEE7B000000" , k(k1).vpgatherqq(zmm17, zmmword_ptr(r14, zmm21, 3, 123))); + TEST_INSTRUCTION("62C2FD41914C2920" , k(k1).vpgatherqq(zmm17, zmmword_ptr(r9, zmm21, 0, 256))); + TEST_INSTRUCTION("62E2FD41918CA900040000" , k(k1).vpgatherqq(zmm17, zmmword_ptr(rcx, zmm21, 2, 1024))); + TEST_INSTRUCTION("62C27D41A09CC67B000000" , k(k1).vpscatterdd(zmmword_ptr(r14, zmm16, 3, 123), zmm19)); + TEST_INSTRUCTION("62C27D41A09CC67B000000" , k(k1).vpscatterdd(zmmword_ptr(r14, zmm16, 3, 123), zmm19)); + TEST_INSTRUCTION("62C27D41A05C0140" , k(k1).vpscatterdd(zmmword_ptr(r9, zmm16, 0, 256), zmm19)); + TEST_INSTRUCTION("62E27D41A09C8100040000" , k(k1).vpscatterdd(zmmword_ptr(rcx, zmm16, 2, 1024), zmm19)); + TEST_INSTRUCTION("62D2FD49A0ACF67B000000" , k(k1).vpscatterdq(zmmword_ptr(r14, ymm6, 3, 123), zmm5)); + TEST_INSTRUCTION("62D2FD49A0ACF67B000000" , k(k1).vpscatterdq(zmmword_ptr(r14, ymm6, 3, 123), zmm5)); + TEST_INSTRUCTION("62D2FD49A06C3120" , k(k1).vpscatterdq(zmmword_ptr(r9, ymm6, 0, 256), zmm5)); + TEST_INSTRUCTION("62F2FD49A0ACB100040000" , k(k1).vpscatterdq(zmmword_ptr(rcx, ymm6, 2, 1024), zmm5)); + TEST_INSTRUCTION("62C27D49A1A4D67B000000" , k(k1).vpscatterqd(ymmword_ptr(r14, zmm2, 3, 123), ymm20)); + TEST_INSTRUCTION("62C27D49A1A4D67B000000" , k(k1).vpscatterqd(ymmword_ptr(r14, zmm2, 3, 123), ymm20)); + TEST_INSTRUCTION("62C27D49A1641140" , k(k1).vpscatterqd(ymmword_ptr(r9, zmm2, 0, 256), ymm20)); + TEST_INSTRUCTION("62E27D49A1A49100040000" , k(k1).vpscatterqd(ymmword_ptr(rcx, zmm2, 2, 1024), ymm20)); + TEST_INSTRUCTION("6252FD41A1B4E67B000000" , k(k1).vpscatterqq(zmmword_ptr(r14, zmm20, 3, 123), zmm14)); + TEST_INSTRUCTION("6252FD41A1B4E67B000000" , k(k1).vpscatterqq(zmmword_ptr(r14, zmm20, 3, 123), zmm14)); + TEST_INSTRUCTION("6252FD41A1742120" , k(k1).vpscatterqq(zmmword_ptr(r9, zmm20, 0, 256), zmm14)); + TEST_INSTRUCTION("6272FD41A1B4A100040000" , k(k1).vpscatterqq(zmmword_ptr(rcx, zmm20, 2, 1024), zmm14)); + TEST_INSTRUCTION("6282FD41A294C67B000000" , k(k1).vscatterdpd(zmmword_ptr(r14, ymm24, 3, 123), zmm18)); + TEST_INSTRUCTION("6282FD41A294C67B000000" , k(k1).vscatterdpd(zmmword_ptr(r14, ymm24, 3, 123), zmm18)); + TEST_INSTRUCTION("6282FD41A2540120" , k(k1).vscatterdpd(zmmword_ptr(r9, ymm24, 0, 256), zmm18)); + TEST_INSTRUCTION("62A2FD41A2948100040000" , k(k1).vscatterdpd(zmmword_ptr(rcx, ymm24, 2, 1024), zmm18)); + TEST_INSTRUCTION("62C27D41A28CDE7B000000" , k(k1).vscatterdps(zmmword_ptr(r14, zmm19, 3, 123), zmm17)); + TEST_INSTRUCTION("62C27D41A28CDE7B000000" , k(k1).vscatterdps(zmmword_ptr(r14, zmm19, 3, 123), zmm17)); + TEST_INSTRUCTION("62C27D41A24C1940" , k(k1).vscatterdps(zmmword_ptr(r9, zmm19, 0, 256), zmm17)); + TEST_INSTRUCTION("62E27D41A28C9900040000" , k(k1).vscatterdps(zmmword_ptr(rcx, zmm19, 2, 1024), zmm17)); + TEST_INSTRUCTION("6282FD41A3B4E67B000000" , k(k1).vscatterqpd(zmmword_ptr(r14, zmm28, 3, 123), zmm22)); + TEST_INSTRUCTION("6282FD41A3B4E67B000000" , k(k1).vscatterqpd(zmmword_ptr(r14, zmm28, 3, 123), zmm22)); + TEST_INSTRUCTION("6282FD41A3742120" , k(k1).vscatterqpd(zmmword_ptr(r9, zmm28, 0, 256), zmm22)); + TEST_INSTRUCTION("62A2FD41A3B4A100040000" , k(k1).vscatterqpd(zmmword_ptr(rcx, zmm28, 2, 1024), zmm22)); + TEST_INSTRUCTION("62927D41A3B4DE7B000000" , k(k1).vscatterqps(ymmword_ptr(r14, zmm27, 3, 123), ymm6)); + TEST_INSTRUCTION("62927D41A3B4DE7B000000" , k(k1).vscatterqps(ymmword_ptr(r14, zmm27, 3, 123), ymm6)); + TEST_INSTRUCTION("62927D41A3741940" , k(k1).vscatterqps(ymmword_ptr(r9, zmm27, 0, 256), ymm6)); + TEST_INSTRUCTION("62B27D41A3B49900040000" , k(k1).vscatterqps(ymmword_ptr(rcx, zmm27, 2, 1024), ymm6)); + TEST_INSTRUCTION("6282FD41A294DE85FFFFFF" , k(k1).vscatterdpd(zmmword_ptr(r14, ymm27, 3, -123), zmm18)); + TEST_INSTRUCTION("6282FD41A294DE85FFFFFF" , k(k1).vscatterdpd(zmmword_ptr(r14, ymm27, 3, -123), zmm18)); + TEST_INSTRUCTION("6282FD41A2541920" , k(k1).vscatterdpd(zmmword_ptr(r9, ymm27, 0, 256), zmm18)); + TEST_INSTRUCTION("62A2FD41A2949900040000" , k(k1).vscatterdpd(zmmword_ptr(rcx, ymm27, 2, 1024), zmm18)); + TEST_INSTRUCTION("62D27D41A28CCE85FFFFFF" , k(k1).vscatterdps(zmmword_ptr(r14, zmm17, 3, -123), zmm1)); + TEST_INSTRUCTION("62D27D41A28CCE85FFFFFF" , k(k1).vscatterdps(zmmword_ptr(r14, zmm17, 3, -123), zmm1)); + TEST_INSTRUCTION("62D27D41A24C0940" , k(k1).vscatterdps(zmmword_ptr(r9, zmm17, 0, 256), zmm1)); + TEST_INSTRUCTION("62F27D41A28C8900040000" , k(k1).vscatterdps(zmmword_ptr(rcx, zmm17, 2, 1024), zmm1)); + TEST_INSTRUCTION("6212FD41A384CE85FFFFFF" , k(k1).vscatterqpd(zmmword_ptr(r14, zmm25, 3, -123), zmm8)); + TEST_INSTRUCTION("6212FD41A384CE85FFFFFF" , k(k1).vscatterqpd(zmmword_ptr(r14, zmm25, 3, -123), zmm8)); + TEST_INSTRUCTION("6212FD41A3440920" , k(k1).vscatterqpd(zmmword_ptr(r9, zmm25, 0, 256), zmm8)); + TEST_INSTRUCTION("6232FD41A3848900040000" , k(k1).vscatterqpd(zmmword_ptr(rcx, zmm25, 2, 1024), zmm8)); + TEST_INSTRUCTION("62127D49A3ACD685FFFFFF" , k(k1).vscatterqps(ymmword_ptr(r14, zmm10, 3, -123), ymm13)); + TEST_INSTRUCTION("62127D49A3ACD685FFFFFF" , k(k1).vscatterqps(ymmword_ptr(r14, zmm10, 3, -123), ymm13)); + TEST_INSTRUCTION("62127D49A36C1140" , k(k1).vscatterqps(ymmword_ptr(r9, zmm10, 0, 256), ymm13)); + TEST_INSTRUCTION("62327D49A3AC9100040000" , k(k1).vscatterqps(ymmword_ptr(rcx, zmm10, 2, 1024), ymm13)); + TEST_INSTRUCTION("6242FD4992B4EE85FFFFFF" , k(k1).vgatherdpd(zmm30, zmmword_ptr(r14, ymm5, 3, -123))); + TEST_INSTRUCTION("6242FD4992742920" , k(k1).vgatherdpd(zmm30, zmmword_ptr(r9, ymm5, 0, 256))); + TEST_INSTRUCTION("6262FD4992B4A900040000" , k(k1).vgatherdpd(zmm30, zmmword_ptr(rcx, ymm5, 2, 1024))); + TEST_INSTRUCTION("62127D419284D685FFFFFF" , k(k1).vgatherdps(zmm8, zmmword_ptr(r14, zmm26, 3, -123))); + TEST_INSTRUCTION("62127D4192441140" , k(k1).vgatherdps(zmm8, zmmword_ptr(r9, zmm26, 0, 256))); + TEST_INSTRUCTION("62327D4192849100040000" , k(k1).vgatherdps(zmm8, zmmword_ptr(rcx, zmm26, 2, 1024))); + TEST_INSTRUCTION("6202FD49939CEE85FFFFFF" , k(k1).vgatherqpd(zmm27, zmmword_ptr(r14, zmm13, 3, -123))); + TEST_INSTRUCTION("6202FD49935C2920" , k(k1).vgatherqpd(zmm27, zmmword_ptr(r9, zmm13, 0, 256))); + TEST_INSTRUCTION("6222FD49939CA900040000" , k(k1).vgatherqpd(zmm27, zmmword_ptr(rcx, zmm13, 2, 1024))); + TEST_INSTRUCTION("62027D49939CF685FFFFFF" , k(k1).vgatherqps(ymm27, ymmword_ptr(r14, zmm14, 3, -123))); + TEST_INSTRUCTION("62027D49935C3140" , k(k1).vgatherqps(ymm27, ymmword_ptr(r9, zmm14, 0, 256))); + TEST_INSTRUCTION("62227D49939CB100040000" , k(k1).vgatherqps(ymm27, ymmword_ptr(rcx, zmm14, 2, 1024))); + TEST_INSTRUCTION("62D27D4190BCC685FFFFFF" , k(k1).vpgatherdd(zmm7, zmmword_ptr(r14, zmm16, 3, -123))); + TEST_INSTRUCTION("62D27D41907C0140" , k(k1).vpgatherdd(zmm7, zmmword_ptr(r9, zmm16, 0, 256))); + TEST_INSTRUCTION("62F27D4190BC8100040000" , k(k1).vpgatherdd(zmm7, zmmword_ptr(rcx, zmm16, 2, 1024))); + TEST_INSTRUCTION("6242FD49908CFE85FFFFFF" , k(k1).vpgatherdq(zmm25, zmmword_ptr(r14, ymm7, 3, -123))); + TEST_INSTRUCTION("6242FD49904C3920" , k(k1).vpgatherdq(zmm25, zmmword_ptr(r9, ymm7, 0, 256))); + TEST_INSTRUCTION("6262FD49908CB900040000" , k(k1).vpgatherdq(zmm25, zmmword_ptr(rcx, ymm7, 2, 1024))); + TEST_INSTRUCTION("62C27D41919CCE85FFFFFF" , k(k1).vpgatherqd(ymm19, ymmword_ptr(r14, zmm17, 3, -123))); + TEST_INSTRUCTION("62C27D41915C0940" , k(k1).vpgatherqd(ymm19, ymmword_ptr(r9, zmm17, 0, 256))); + TEST_INSTRUCTION("62E27D41919C8900040000" , k(k1).vpgatherqd(ymm19, ymmword_ptr(rcx, zmm17, 2, 1024))); + TEST_INSTRUCTION("6212FD499194EE85FFFFFF" , k(k1).vpgatherqq(zmm10, zmmword_ptr(r14, zmm13, 3, -123))); + TEST_INSTRUCTION("6212FD4991542920" , k(k1).vpgatherqq(zmm10, zmmword_ptr(r9, zmm13, 0, 256))); + TEST_INSTRUCTION("6232FD499194A900040000" , k(k1).vpgatherqq(zmm10, zmmword_ptr(rcx, zmm13, 2, 1024))); + TEST_INSTRUCTION("62C27D49A0BCE685FFFFFF" , k(k1).vpscatterdd(zmmword_ptr(r14, zmm4, 3, -123), zmm23)); + TEST_INSTRUCTION("62C27D49A0BCE685FFFFFF" , k(k1).vpscatterdd(zmmword_ptr(r14, zmm4, 3, -123), zmm23)); + TEST_INSTRUCTION("62C27D49A07C2140" , k(k1).vpscatterdd(zmmword_ptr(r9, zmm4, 0, 256), zmm23)); + TEST_INSTRUCTION("62E27D49A0BCA100040000" , k(k1).vpscatterdd(zmmword_ptr(rcx, zmm4, 2, 1024), zmm23)); + TEST_INSTRUCTION("6292FD41A08CCE85FFFFFF" , k(k1).vpscatterdq(zmmword_ptr(r14, ymm25, 3, -123), zmm1)); + TEST_INSTRUCTION("6292FD41A08CCE85FFFFFF" , k(k1).vpscatterdq(zmmword_ptr(r14, ymm25, 3, -123), zmm1)); + TEST_INSTRUCTION("6292FD41A04C0920" , k(k1).vpscatterdq(zmmword_ptr(r9, ymm25, 0, 256), zmm1)); + TEST_INSTRUCTION("62B2FD41A08C8900040000" , k(k1).vpscatterdq(zmmword_ptr(rcx, ymm25, 2, 1024), zmm1)); + TEST_INSTRUCTION("62C27D41A1BCF685FFFFFF" , k(k1).vpscatterqd(ymmword_ptr(r14, zmm22, 3, -123), ymm23)); + TEST_INSTRUCTION("62C27D41A1BCF685FFFFFF" , k(k1).vpscatterqd(ymmword_ptr(r14, zmm22, 3, -123), ymm23)); + TEST_INSTRUCTION("62C27D41A17C3140" , k(k1).vpscatterqd(ymmword_ptr(r9, zmm22, 0, 256), ymm23)); + TEST_INSTRUCTION("62E27D41A1BCB100040000" , k(k1).vpscatterqd(ymmword_ptr(rcx, zmm22, 2, 1024), ymm23)); + TEST_INSTRUCTION("6292FD49A194C685FFFFFF" , k(k1).vpscatterqq(zmmword_ptr(r14, zmm8, 3, -123), zmm2)); + TEST_INSTRUCTION("6292FD49A194C685FFFFFF" , k(k1).vpscatterqq(zmmword_ptr(r14, zmm8, 3, -123), zmm2)); + TEST_INSTRUCTION("6292FD49A1540120" , k(k1).vpscatterqq(zmmword_ptr(r9, zmm8, 0, 256), zmm2)); + TEST_INSTRUCTION("62B2FD49A1948100040000" , k(k1).vpscatterqq(zmmword_ptr(rcx, zmm8, 2, 1024), zmm2)); + +} + +static void ASMJIT_NOINLINE testX64AssemblerAMX(AssemblerTester<x86::Assembler>& tester) noexcept { + using namespace x86; + + TEST_INSTRUCTION("C4E27849841180000000" , ldtilecfg(ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("C4E27849841180000000" , ldtilecfg(zmmword_ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("C4E27949841180000000" , sttilecfg(ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("C4E27949841180000000" , sttilecfg(zmmword_ptr(rcx, rdx, 0, 128))); + TEST_INSTRUCTION("C4E2625CCA" , tdpbf16ps(tmm1, tmm2, tmm3)); + TEST_INSTRUCTION("C4E2635ECA" , tdpbssd(tmm1, tmm2, tmm3)); + TEST_INSTRUCTION("C4E2625ECA" , tdpbsud(tmm1, tmm2, tmm3)); + TEST_INSTRUCTION("C4E2615ECA" , tdpbusd(tmm1, tmm2, tmm3)); + TEST_INSTRUCTION("C4E2605ECA" , tdpbuud(tmm1, tmm2, tmm3)); + TEST_INSTRUCTION("C4E27B4B8C1A80000000" , tileloadd(tmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C4E2794B8C1A80000000" , tileloaddt1(tmm1, ptr(rdx, rbx, 0, 128))); + TEST_INSTRUCTION("C4E27849C0" , tilerelease()); + TEST_INSTRUCTION("C4E27A4B9C1180000000" , tilestored(ptr(rcx, rdx, 0, 128), tmm3)); + TEST_INSTRUCTION("C4E27B49C8" , tilezero(tmm1)); +} + +static void ASMJIT_NOINLINE testX64AssemblerExtras(AssemblerTester<x86::Assembler>& tester) noexcept { + using namespace x86; + + // Extended X64 tests. + TEST_INSTRUCTION("01CB" , add(ebx, ecx)); + TEST_INSTRUCTION("83C001" , add(eax, 1)); + TEST_INSTRUCTION("0504030201" , add(eax, 0x01020304)); + TEST_INSTRUCTION("66050201" , add(ax, 0x0102)); + TEST_INSTRUCTION("6603849004030201" , add(ax, ptr(rax, rdx, 2, 0x01020304))); + TEST_INSTRUCTION("8D042500000000" , lea(eax, ptr(0))); + TEST_INSTRUCTION("488D042500000000" , lea(rax, ptr(0))); + TEST_INSTRUCTION("488D0433" , lea(rax, ptr(rbx, rsi))); + TEST_INSTRUCTION("488D043B" , lea(rax, ptr(rbx, rdi))); + TEST_INSTRUCTION("488D840000400000" , lea(rax, ptr(rax, rax, 0, 0x4000))); + TEST_INSTRUCTION("48BB8877665544332211" , mov(rbx, 0x001122334455667788)); + TEST_INSTRUCTION("48BB0000000000000000" , long_().mov(rbx, 0)); + TEST_INSTRUCTION("B8E8030000" , mov(eax, 1000)); + TEST_INSTRUCTION("0F20C0" , mov(rax, cr0)); + TEST_INSTRUCTION("440F20C0" , mov(rax, cr8)); + TEST_INSTRUCTION("488B0500000000" , mov(rax, ptr(rip))); + TEST_INSTRUCTION("4A8B0460" , mov(rax, ptr(rax, r12, 1))); + TEST_INSTRUCTION("4A8B0468" , mov(rax, ptr(rax, r13, 1))); + TEST_INSTRUCTION("4A8B846000010000" , mov(rax, ptr(rax, r12, 1, 256))); + TEST_INSTRUCTION("89042544332211" , mov(ptr_abs(0x11223344), eax)); + TEST_INSTRUCTION("891C2544332211" , mov(ptr_abs(0x11223344), ebx)); + TEST_INSTRUCTION("A38877665544332211" , mov(ptr_abs(0x1122334455667788), eax)); + TEST_INSTRUCTION("A34433221100000000" , movabs(ptr(0x0000000011223344), eax)); + TEST_INSTRUCTION("A38877665544332211" , movabs(ptr(0x1122334455667788), eax)); + TEST_INSTRUCTION("48A1EFCDAB8967452301" , movabs(rax, ptr(0x123456789ABCDEF))); + TEST_INSTRUCTION("0FBE07" , movsx(eax, byte_ptr(rdi))); + TEST_INSTRUCTION("480FBE07" , movsx(rax, byte_ptr(rdi))); + TEST_INSTRUCTION("0FBF07" , movsx(eax, word_ptr(rdi))); + TEST_INSTRUCTION("480FBF07" , movsx(rax, word_ptr(rdi))); + TEST_INSTRUCTION("486307" , movsxd(rax, ptr(rdi))); + TEST_INSTRUCTION("486307" , movsxd(rax, dword_ptr(rdi))); + TEST_INSTRUCTION("6663C3" , movsxd(ax, bx)); + TEST_INSTRUCTION("63C3" , movsxd(eax, ebx)); + TEST_INSTRUCTION("4863C3" , movsxd(rax, ebx)); + TEST_INSTRUCTION("0FB6C6" , movzx(eax, dh)); + TEST_INSTRUCTION("0FB607" , movzx(eax, byte_ptr(rdi))); + TEST_INSTRUCTION("480FB607" , movzx(rax, byte_ptr(rdi))); + TEST_INSTRUCTION("440FB6FA" , movzx(r15d, dl)); + TEST_INSTRUCTION("440FB6FD" , movzx(r15d, bpl)); + TEST_INSTRUCTION("0FB707" , movzx(eax, word_ptr(rdi))); + TEST_INSTRUCTION("480FB707" , movzx(rax, word_ptr(rdi))); + TEST_INSTRUCTION("411351FD" , adc(edx, dword_ptr(r9, -3))); + TEST_INSTRUCTION("F6D8" , neg(al)); + TEST_INSTRUCTION("F6DC" , neg(ah)); + TEST_INSTRUCTION("40F6DE" , neg(sil)); + TEST_INSTRUCTION("F7D8" , neg(eax)); + TEST_INSTRUCTION("F7D0" , not_(eax)); + TEST_INSTRUCTION("0F95C3" , setnz(bl)); + TEST_INSTRUCTION("0F94C7" , setz(bh)); + TEST_INSTRUCTION("400F94C0" , rex().setz(al)); + TEST_INSTRUCTION("410F94C7" , setz(r15b)); + TEST_INSTRUCTION("F600FF" , test(byte_ptr(rax), 0xFF)); + TEST_INSTRUCTION("66F700FF00" , test(word_ptr(rax), 0xFF)); + TEST_INSTRUCTION("F700FF000000" , test(dword_ptr(rax), 0xFF)); + TEST_INSTRUCTION("48F700FF000000" , test(qword_ptr(rax), 0xFF)); + TEST_INSTRUCTION("A836" , test(al, 0x36)); + TEST_INSTRUCTION("F6C436" , test(ah, 0x36)); + TEST_INSTRUCTION("50" , push(rax)); + TEST_INSTRUCTION("51" , push(rcx)); + TEST_INSTRUCTION("52" , push(rdx)); + TEST_INSTRUCTION("53" , push(rbx)); + TEST_INSTRUCTION("54" , push(rsp)); + TEST_INSTRUCTION("55" , push(rbp)); + TEST_INSTRUCTION("56" , push(rsi)); + TEST_INSTRUCTION("57" , push(rdi)); + TEST_INSTRUCTION("4150" , push(r8)); + TEST_INSTRUCTION("4151" , push(r9)); + TEST_INSTRUCTION("4152" , push(r10)); + TEST_INSTRUCTION("4153" , push(r11)); + TEST_INSTRUCTION("4154" , push(r12)); + TEST_INSTRUCTION("4155" , push(r13)); + TEST_INSTRUCTION("4156" , push(r14)); + TEST_INSTRUCTION("4157" , push(r15)); + TEST_INSTRUCTION("0FA0" , push(fs)); + TEST_INSTRUCTION("0FA8" , push(gs)); + TEST_INSTRUCTION("400FA0" , rex().push(fs)); + TEST_INSTRUCTION("400FA8" , rex().push(gs)); + TEST_INSTRUCTION("C8010002" , enter(1, 2)); + TEST_INSTRUCTION("40C8010002" , rex().enter(1, 2)); + TEST_INSTRUCTION("FF10" , call(ptr(rax))); + TEST_INSTRUCTION("FF10" , call(qword_ptr(rax))); + TEST_INSTRUCTION("6690" , xchg(ax, ax)); + TEST_INSTRUCTION("87C0" , xchg(eax, eax)); + TEST_INSTRUCTION("90" , xchg(rax, rax)); + TEST_INSTRUCTION("40863424" , xchg(ptr(rsp), sil)); + TEST_INSTRUCTION("40863C24" , xchg(ptr(rsp), dil)); + + TEST_INSTRUCTION("F00118" , lock().add(ptr(rax), ebx)); + TEST_INSTRUCTION("F0480FC138" , lock().xadd(ptr(rax), rdi)); + TEST_INSTRUCTION("F2F0480108" , xacquire().lock().add(qword_ptr(rax), rcx)); + TEST_INSTRUCTION("F3F0480108" , xrelease().lock().add(qword_ptr(rax), rcx)); + + // MOD RM & MR tests. + TEST_INSTRUCTION("01CB" , mod_mr().add(ebx, ecx)); + TEST_INSTRUCTION("03D9" , mod_rm().add(ebx, ecx)); + TEST_INSTRUCTION("88C4" , mod_mr().mov(ah, al)); + TEST_INSTRUCTION("88C6" , mod_mr().mov(dh, al)); + TEST_INSTRUCTION("89D8" , mod_mr().mov(eax, ebx)); + TEST_INSTRUCTION("8AE0" , mod_rm().mov(ah, al)); + TEST_INSTRUCTION("8AF0" , mod_rm().mov(dh, al)); + TEST_INSTRUCTION("8BC3" , mod_rm().mov(eax, ebx)); + + // HRESET. + TEST_INSTRUCTION("F30F3AF0C001" , hreset(1)); + + // FPU. + TEST_INSTRUCTION("9B" , fwait()); + TEST_INSTRUCTION("D800" , fadd(dword_ptr(rax))); + TEST_INSTRUCTION("DC00" , fadd(qword_ptr(rax))); + + // AVX & AVX512. + TEST_INSTRUCTION("62F17D086EC0" , evex().vmovd(xmm0, eax)); + TEST_INSTRUCTION("62F1FD086EC0" , evex().vmovq(xmm0, rax)); + TEST_INSTRUCTION("62F17D087EC0" , evex().vmovd(eax, xmm0)); + TEST_INSTRUCTION("62F1FD087EC0" , evex().vmovq(rax, xmm0)); + TEST_INSTRUCTION("6271B5D95808" , k(k1).z().vaddpd(zmm9, zmm9, ptr(rax)._1to8())); + TEST_INSTRUCTION("62F1748858C2" , z().vaddps(xmm0, xmm1, xmm2)); + TEST_INSTRUCTION("6201951058F4" , rn_sae().vaddpd(zmm30, zmm29, zmm28)); + TEST_INSTRUCTION("6201953058F4" , rd_sae().vaddpd(zmm30, zmm29, zmm28)); + TEST_INSTRUCTION("6201955058F4" , ru_sae().vaddpd(zmm30, zmm29, zmm28)); + TEST_INSTRUCTION("6201957058F4" , rz_sae().vaddpd(zmm30, zmm29, zmm28)); + TEST_INSTRUCTION("62F16C4FC25498040F" , k(k7).vcmpps(k2, zmm2, zmmword_ptr(rax, rbx, 2, 256), 15)); + TEST_INSTRUCTION("62F16C1FC25498400F" , k(k7).vcmpps(k2, xmm2, dword_ptr(rax, rbx, 2, 256)._1to4(), 15)); + TEST_INSTRUCTION("62F16C3FC25498400F" , k(k7).vcmpps(k2, ymm2, dword_ptr(rax, rbx, 2, 256)._1to8(), 15)); + TEST_INSTRUCTION("62F16C5FC25498400F" , k(k7).vcmpps(k2, zmm2, dword_ptr(rax, rbx, 2, 256)._1to16(), 15)); + TEST_INSTRUCTION("62F1FD18C2C100" , sae().vcmppd(k0, zmm0, zmm1, 0x00)); + TEST_INSTRUCTION("6201FD182EF5" , sae().vucomisd(xmm30, xmm29)); + TEST_INSTRUCTION("62017C182EF5" , sae().vucomiss(xmm30, xmm29)); + TEST_INSTRUCTION("C4E2FD91040500000000" , vpgatherqq(ymm0, ptr(0, ymm0), ymm0)); + TEST_INSTRUCTION("C4E2E9920C00" , vgatherdpd(xmm1, ptr(rax, xmm0), xmm2)); + TEST_INSTRUCTION("C4E26990440D00" , vpgatherdd(xmm0, ptr(rbp, xmm1), xmm2)); + TEST_INSTRUCTION("C4C26990040C" , vpgatherdd(xmm0, ptr(r12, xmm1), xmm2)); + TEST_INSTRUCTION("C4C26990440D00" , vpgatherdd(xmm0, ptr(r13, xmm1), xmm2)); + TEST_INSTRUCTION("62F26D48CF4C1101" , vgf2p8mulb(zmm1, zmm2, zmmword_ptr(rcx, rdx, 0, 64))); + TEST_INSTRUCTION("62F3ED48CE4C11010F" , vgf2p8affineqb(zmm1, zmm2, zmmword_ptr(rcx, rdx, 0, 64), 15)); + TEST_INSTRUCTION("62F3ED48CF4C11010F" , vgf2p8affineinvqb(zmm1, zmm2, zmmword_ptr(rcx, rdx, 0, 64), 15)); + TEST_INSTRUCTION("6292472068F0" , vp2intersectd(k6, k7, ymm23, ymm24)); + TEST_INSTRUCTION("62B2472068B4F500000010" , vp2intersectd(k6, k7, ymm23, ptr(rbp, r14, 3, 268435456))); + TEST_INSTRUCTION("62F24730683500000000" , vp2intersectd(k6, k7, ymm23, dword_ptr(rip)._1to8())); + TEST_INSTRUCTION("62F2472068742DE0" , vp2intersectd(k6, k7, ymm23, ymmword_ptr(rbp, rbp, 0, -1024))); + TEST_INSTRUCTION("62F2472068717F" , vp2intersectd(k6, k7, ymm23, ymmword_ptr(rcx, 4064))); + + // AVX_VNNI & AVX512_VNNI. + TEST_INSTRUCTION("C4E25550F4" , vex().vpdpbusd(ymm6, ymm5, ymm4)); + TEST_INSTRUCTION("62F2552850F4" , vpdpbusd(ymm6, ymm5, ymm4)); + + // SVM. + TEST_INSTRUCTION("670F01DF" , invlpga(eax, ecx)); + TEST_INSTRUCTION("0F01DF" , invlpga(rax, ecx)); +} + +bool testX64Assembler(const TestSettings& settings) noexcept { + using namespace x86; + + AssemblerTester<Assembler> tester(Arch::kX64, settings); + tester.printHeader("X64"); + + TEST_INSTRUCTION("62919D18C2D2AB" , sae().vcmppd(k2, zmm12, zmm26, 171)); + + testX64AssemblerBase(tester); + testX64AssemblerMMX_SSE(tester); + testX64AssemblerAVX(tester); + testX64AssemblerAVX512_FP16(tester); + testX64AssemblerAVX512_LLVM(tester); + testX64AssemblerAMX(tester); + testX64AssemblerExtras(tester); + + tester.printSummary(); + return tester.didPass(); +} + +#undef TEST_INSTRUCTION + +#endif // !ASMJIT_NO_X86 diff --git a/3rdparty/asmjit/test/asmjit_test_assembler_x86.cpp b/3rdparty/asmjit/test/asmjit_test_assembler_x86.cpp new file mode 100644 index 00000000000..a5ea03ae525 --- /dev/null +++ b/3rdparty/asmjit/test/asmjit_test_assembler_x86.cpp @@ -0,0 +1,8300 @@ +// This file is part of AsmJit project <https://asmjit.com> +// +// See asmjit.h or LICENSE.md for license and copyright information +// SPDX-License-Identifier: Zlib + +#include <asmjit/core.h> +#if !defined(ASMJIT_NO_X86) + +#include <asmjit/x86.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> + +#include "asmjit_test_assembler.h" +#include "cmdline.h" + +using namespace asmjit; + +#define TEST_INSTRUCTION(OPCODE, ...) \ + tester.testInstruction(OPCODE, #__VA_ARGS__, tester.assembler.__VA_ARGS__) + +static void ASMJIT_NOINLINE testX86AssemblerBase(AssemblerTester<x86::Assembler>& tester) noexcept { + using namespace x86; + + TEST_INSTRUCTION("37" , aaa(ax)); + TEST_INSTRUCTION("D501" , aad(ax, 1)); + TEST_INSTRUCTION("D401" , aam(ax, 1)); + TEST_INSTRUCTION("3F" , aas(ax)); + TEST_INSTRUCTION("80D101" , adc(cl, 1)); + TEST_INSTRUCTION("80D501" , adc(ch, 1)); + TEST_INSTRUCTION("8094118000000001" , adc(byte_ptr(ecx, edx, 0, 128), 1)); + TEST_INSTRUCTION("6683D101" , adc(cx, 1)); + TEST_INSTRUCTION("668394118000000001" , adc(word_ptr(ecx, edx, 0, 128), 1)); + TEST_INSTRUCTION("83D101" , adc(ecx, 1)); + TEST_INSTRUCTION("8394118000000001" , adc(dword_ptr(ecx, edx, 0, 128), 1)); + TEST_INSTRUCTION("10D1" , adc(cl, dl)); + TEST_INSTRUCTION("10F1" , adc(cl, dh)); + TEST_INSTRUCTION("10D5" , adc(ch, dl)); + TEST_INSTRUCTION("10F5" , adc(ch, dh)); + TEST_INSTRUCTION("109C1180000000" , adc(ptr(ecx, edx, 0, 128), bl)); + TEST_INSTRUCTION("10BC1180000000" , adc(ptr(ecx, edx, 0, 128), bh)); + TEST_INSTRUCTION("109C1180000000" , adc(byte_ptr(ecx, edx, 0, 128), bl)); + TEST_INSTRUCTION("10BC1180000000" , adc(byte_ptr(ecx, edx, 0, 128), bh)); + TEST_INSTRUCTION("6611D1" , adc(cx, dx)); + TEST_INSTRUCTION("66119C1180000000" , adc(ptr(ecx, edx, 0, 128), bx)); + TEST_INSTRUCTION("66119C1180000000" , adc(word_ptr(ecx, edx, 0, 128), bx)); + TEST_INSTRUCTION("11D1" , adc(ecx, edx)); + TEST_INSTRUCTION("119C1180000000" , adc(ptr(ecx, edx, 0, 128), ebx)); + TEST_INSTRUCTION("119C1180000000" , adc(dword_ptr(ecx, edx, 0, 128), ebx)); + TEST_INSTRUCTION("128C1A80000000" , adc(cl, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("128C1A80000000" , adc(cl, byte_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("12AC1A80000000" , adc(ch, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("12AC1A80000000" , adc(ch, byte_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("66138C1A80000000" , adc(cx, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("66138C1A80000000" , adc(cx, word_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("138C1A80000000" , adc(ecx, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("138C1A80000000" , adc(ecx, dword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F38F6CA" , adcx(ecx, edx)); + TEST_INSTRUCTION("660F38F68C1A80000000" , adcx(ecx, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F38F68C1A80000000" , adcx(ecx, dword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("80C101" , add(cl, 1)); + TEST_INSTRUCTION("80C501" , add(ch, 1)); + TEST_INSTRUCTION("8084118000000001" , add(byte_ptr(ecx, edx, 0, 128), 1)); + TEST_INSTRUCTION("6683C101" , add(cx, 1)); + TEST_INSTRUCTION("668384118000000001" , add(word_ptr(ecx, edx, 0, 128), 1)); + TEST_INSTRUCTION("83C101" , add(ecx, 1)); + TEST_INSTRUCTION("8384118000000001" , add(dword_ptr(ecx, edx, 0, 128), 1)); + TEST_INSTRUCTION("00D1" , add(cl, dl)); + TEST_INSTRUCTION("00F1" , add(cl, dh)); + TEST_INSTRUCTION("00D5" , add(ch, dl)); + TEST_INSTRUCTION("00F5" , add(ch, dh)); + TEST_INSTRUCTION("009C1180000000" , add(ptr(ecx, edx, 0, 128), bl)); + TEST_INSTRUCTION("00BC1180000000" , add(ptr(ecx, edx, 0, 128), bh)); + TEST_INSTRUCTION("009C1180000000" , add(byte_ptr(ecx, edx, 0, 128), bl)); + TEST_INSTRUCTION("00BC1180000000" , add(byte_ptr(ecx, edx, 0, 128), bh)); + TEST_INSTRUCTION("6601D1" , add(cx, dx)); + TEST_INSTRUCTION("66019C1180000000" , add(ptr(ecx, edx, 0, 128), bx)); + TEST_INSTRUCTION("66019C1180000000" , add(word_ptr(ecx, edx, 0, 128), bx)); + TEST_INSTRUCTION("01D1" , add(ecx, edx)); + TEST_INSTRUCTION("019C1180000000" , add(ptr(ecx, edx, 0, 128), ebx)); + TEST_INSTRUCTION("019C1180000000" , add(dword_ptr(ecx, edx, 0, 128), ebx)); + TEST_INSTRUCTION("028C1A80000000" , add(cl, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("028C1A80000000" , add(cl, byte_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("02AC1A80000000" , add(ch, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("02AC1A80000000" , add(ch, byte_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("66038C1A80000000" , add(cx, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("66038C1A80000000" , add(cx, word_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("038C1A80000000" , add(ecx, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("038C1A80000000" , add(ecx, dword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("80E101" , and_(cl, 1)); + TEST_INSTRUCTION("80E501" , and_(ch, 1)); + TEST_INSTRUCTION("6683E101" , and_(cx, 1)); + TEST_INSTRUCTION("83E101" , and_(ecx, 1)); + TEST_INSTRUCTION("80A4118000000001" , and_(byte_ptr(ecx, edx, 0, 128), 1)); + TEST_INSTRUCTION("6683A4118000000001" , and_(word_ptr(ecx, edx, 0, 128), 1)); + TEST_INSTRUCTION("83A4118000000001" , and_(dword_ptr(ecx, edx, 0, 128), 1)); + TEST_INSTRUCTION("20D1" , and_(cl, dl)); + TEST_INSTRUCTION("20F1" , and_(cl, dh)); + TEST_INSTRUCTION("20D5" , and_(ch, dl)); + TEST_INSTRUCTION("20F5" , and_(ch, dh)); + TEST_INSTRUCTION("209C1180000000" , and_(ptr(ecx, edx, 0, 128), bl)); + TEST_INSTRUCTION("20BC1180000000" , and_(ptr(ecx, edx, 0, 128), bh)); + TEST_INSTRUCTION("209C1180000000" , and_(byte_ptr(ecx, edx, 0, 128), bl)); + TEST_INSTRUCTION("20BC1180000000" , and_(byte_ptr(ecx, edx, 0, 128), bh)); + TEST_INSTRUCTION("6621D1" , and_(cx, dx)); + TEST_INSTRUCTION("66219C1180000000" , and_(ptr(ecx, edx, 0, 128), bx)); + TEST_INSTRUCTION("66219C1180000000" , and_(word_ptr(ecx, edx, 0, 128), bx)); + TEST_INSTRUCTION("21D1" , and_(ecx, edx)); + TEST_INSTRUCTION("219C1180000000" , and_(ptr(ecx, edx, 0, 128), ebx)); + TEST_INSTRUCTION("219C1180000000" , and_(dword_ptr(ecx, edx, 0, 128), ebx)); + TEST_INSTRUCTION("228C1A80000000" , and_(cl, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("228C1A80000000" , and_(cl, byte_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("22AC1A80000000" , and_(ch, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("22AC1A80000000" , and_(ch, byte_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("66238C1A80000000" , and_(cx, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("66238C1A80000000" , and_(cx, word_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("238C1A80000000" , and_(ecx, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("238C1A80000000" , and_(ecx, dword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C4E268F2CB" , andn(ecx, edx, ebx)); + TEST_INSTRUCTION("C4E268F28C2B80000000" , andn(ecx, edx, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E268F28C2B80000000" , andn(ecx, edx, dword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("63D1" , arpl(cx, dx)); + TEST_INSTRUCTION("639C1180000000" , arpl(ptr(ecx, edx, 0, 128), bx)); + TEST_INSTRUCTION("639C1180000000" , arpl(word_ptr(ecx, edx, 0, 128), bx)); + TEST_INSTRUCTION("C4E260F7CA" , bextr(ecx, edx, ebx)); + TEST_INSTRUCTION("C4E258F78C1A80000000" , bextr(ecx, ptr(edx, ebx, 0, 128), esp)); + TEST_INSTRUCTION("C4E258F78C1A80000000" , bextr(ecx, dword_ptr(edx, ebx, 0, 128), esp)); + TEST_INSTRUCTION("8FE97001CA" , blcfill(ecx, edx)); + TEST_INSTRUCTION("8FE970018C1A80000000" , blcfill(ecx, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("8FE970018C1A80000000" , blcfill(ecx, dword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("8FE97002F2" , blci(ecx, edx)); + TEST_INSTRUCTION("8FE97002B41A80000000" , blci(ecx, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("8FE97002B41A80000000" , blci(ecx, dword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("8FE97001EA" , blcic(ecx, edx)); + TEST_INSTRUCTION("8FE97001AC1A80000000" , blcic(ecx, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("8FE97001AC1A80000000" , blcic(ecx, dword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("8FE97002CA" , blcmsk(ecx, edx)); + TEST_INSTRUCTION("8FE970028C1A80000000" , blcmsk(ecx, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("8FE970028C1A80000000" , blcmsk(ecx, dword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("8FE97001DA" , blcs(ecx, edx)); + TEST_INSTRUCTION("8FE970019C1A80000000" , blcs(ecx, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("8FE970019C1A80000000" , blcs(ecx, dword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("8FE97001D2" , blsfill(ecx, edx)); + TEST_INSTRUCTION("8FE97001941A80000000" , blsfill(ecx, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("8FE97001941A80000000" , blsfill(ecx, dword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C4E270F3DA" , blsi(ecx, edx)); + TEST_INSTRUCTION("C4E270F39C1A80000000" , blsi(ecx, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C4E270F39C1A80000000" , blsi(ecx, dword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("8FE97001F2" , blsic(ecx, edx)); + TEST_INSTRUCTION("8FE97001B41A80000000" , blsic(ecx, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("8FE97001B41A80000000" , blsic(ecx, dword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C4E270F3D2" , blsmsk(ecx, edx)); + TEST_INSTRUCTION("C4E270F3941A80000000" , blsmsk(ecx, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C4E270F3941A80000000" , blsmsk(ecx, dword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C4E270F3CA" , blsr(ecx, edx)); + TEST_INSTRUCTION("C4E270F38C1A80000000" , blsr(ecx, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C4E270F38C1A80000000" , blsr(ecx, dword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("F30F1ACA" , bndcl(bnd1, edx)); + TEST_INSTRUCTION("F30F1A8C1A80000000" , bndcl(bnd1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("F30F1A8C1A80000000" , bndcl(bnd1, dword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("F20F1BCA" , bndcn(bnd1, edx)); + TEST_INSTRUCTION("F20F1B8C1A80000000" , bndcn(bnd1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("F20F1B8C1A80000000" , bndcn(bnd1, dword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("F20F1ACA" , bndcu(bnd1, edx)); + TEST_INSTRUCTION("F20F1A8C1A80000000" , bndcu(bnd1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("F20F1A8C1A80000000" , bndcu(bnd1, dword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F1A8C1A80000000" , bndldx(bnd1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("F30F1B8C1A80000000" , bndmk(bnd1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F1ACA" , bndmov(bnd1, bnd2)); + TEST_INSTRUCTION("660F1A8C1A80000000" , bndmov(bnd1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F1B9C1180000000" , bndmov(ptr(ecx, edx, 0, 128), bnd3)); + TEST_INSTRUCTION("0F1B9C1180000000" , bndstx(ptr(ecx, edx, 0, 128), bnd3)); + TEST_INSTRUCTION("66628C1A80000000" , bound(cx, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("66628C1A80000000" , bound(cx, dword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("628C1A80000000" , bound(ecx, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("628C1A80000000" , bound(ecx, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660FBCCA" , bsf(cx, dx)); + TEST_INSTRUCTION("660FBC8C1A80000000" , bsf(cx, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660FBC8C1A80000000" , bsf(cx, word_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0FBCCA" , bsf(ecx, edx)); + TEST_INSTRUCTION("0FBC8C1A80000000" , bsf(ecx, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0FBC8C1A80000000" , bsf(ecx, dword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660FBDCA" , bsr(cx, dx)); + TEST_INSTRUCTION("660FBD8C1A80000000" , bsr(cx, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660FBD8C1A80000000" , bsr(cx, word_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0FBDCA" , bsr(ecx, edx)); + TEST_INSTRUCTION("0FBD8C1A80000000" , bsr(ecx, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0FBD8C1A80000000" , bsr(ecx, dword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660FC9" , bswap(cx)); + TEST_INSTRUCTION("0FC9" , bswap(ecx)); + TEST_INSTRUCTION("660FBAE101" , bt(cx, 1)); + TEST_INSTRUCTION("0FBAE101" , bt(ecx, 1)); + TEST_INSTRUCTION("660FBAA4118000000001" , bt(word_ptr(ecx, edx, 0, 128), 1)); + TEST_INSTRUCTION("0FBAA4118000000001" , bt(dword_ptr(ecx, edx, 0, 128), 1)); + TEST_INSTRUCTION("660FA3D1" , bt(cx, dx)); + TEST_INSTRUCTION("660FA39C1180000000" , bt(ptr(ecx, edx, 0, 128), bx)); + TEST_INSTRUCTION("660FA39C1180000000" , bt(word_ptr(ecx, edx, 0, 128), bx)); + TEST_INSTRUCTION("0FA3D1" , bt(ecx, edx)); + TEST_INSTRUCTION("0FA39C1180000000" , bt(ptr(ecx, edx, 0, 128), ebx)); + TEST_INSTRUCTION("0FA39C1180000000" , bt(dword_ptr(ecx, edx, 0, 128), ebx)); + TEST_INSTRUCTION("660FBAF901" , btc(cx, 1)); + TEST_INSTRUCTION("0FBAF901" , btc(ecx, 1)); + TEST_INSTRUCTION("660FBABC118000000001" , btc(word_ptr(ecx, edx, 0, 128), 1)); + TEST_INSTRUCTION("0FBABC118000000001" , btc(dword_ptr(ecx, edx, 0, 128), 1)); + TEST_INSTRUCTION("660FBBD1" , btc(cx, dx)); + TEST_INSTRUCTION("660FBB9C1180000000" , btc(ptr(ecx, edx, 0, 128), bx)); + TEST_INSTRUCTION("660FBB9C1180000000" , btc(word_ptr(ecx, edx, 0, 128), bx)); + TEST_INSTRUCTION("0FBBD1" , btc(ecx, edx)); + TEST_INSTRUCTION("0FBB9C1180000000" , btc(ptr(ecx, edx, 0, 128), ebx)); + TEST_INSTRUCTION("0FBB9C1180000000" , btc(dword_ptr(ecx, edx, 0, 128), ebx)); + TEST_INSTRUCTION("660FBAF101" , btr(cx, 1)); + TEST_INSTRUCTION("0FBAF101" , btr(ecx, 1)); + TEST_INSTRUCTION("660FBAB4118000000001" , btr(word_ptr(ecx, edx, 0, 128), 1)); + TEST_INSTRUCTION("0FBAB4118000000001" , btr(dword_ptr(ecx, edx, 0, 128), 1)); + TEST_INSTRUCTION("660FB3D1" , btr(cx, dx)); + TEST_INSTRUCTION("660FB39C1180000000" , btr(ptr(ecx, edx, 0, 128), bx)); + TEST_INSTRUCTION("660FB39C1180000000" , btr(word_ptr(ecx, edx, 0, 128), bx)); + TEST_INSTRUCTION("0FB3D1" , btr(ecx, edx)); + TEST_INSTRUCTION("0FB39C1180000000" , btr(ptr(ecx, edx, 0, 128), ebx)); + TEST_INSTRUCTION("0FB39C1180000000" , btr(dword_ptr(ecx, edx, 0, 128), ebx)); + TEST_INSTRUCTION("660FBAE901" , bts(cx, 1)); + TEST_INSTRUCTION("0FBAE901" , bts(ecx, 1)); + TEST_INSTRUCTION("660FBAAC118000000001" , bts(word_ptr(ecx, edx, 0, 128), 1)); + TEST_INSTRUCTION("0FBAAC118000000001" , bts(dword_ptr(ecx, edx, 0, 128), 1)); + TEST_INSTRUCTION("660FABD1" , bts(cx, dx)); + TEST_INSTRUCTION("660FAB9C1180000000" , bts(ptr(ecx, edx, 0, 128), bx)); + TEST_INSTRUCTION("660FAB9C1180000000" , bts(word_ptr(ecx, edx, 0, 128), bx)); + TEST_INSTRUCTION("0FABD1" , bts(ecx, edx)); + TEST_INSTRUCTION("0FAB9C1180000000" , bts(ptr(ecx, edx, 0, 128), ebx)); + TEST_INSTRUCTION("0FAB9C1180000000" , bts(dword_ptr(ecx, edx, 0, 128), ebx)); + TEST_INSTRUCTION("C4E260F5CA" , bzhi(ecx, edx, ebx)); + TEST_INSTRUCTION("C4E258F58C1A80000000" , bzhi(ecx, ptr(edx, ebx, 0, 128), esp)); + TEST_INSTRUCTION("C4E258F58C1A80000000" , bzhi(ecx, dword_ptr(edx, ebx, 0, 128), esp)); + TEST_INSTRUCTION("6698" , cbw(ax)); + TEST_INSTRUCTION("99" , cdq(edx, eax)); + TEST_INSTRUCTION("0F01CA" , clac()); + TEST_INSTRUCTION("F8" , clc()); + TEST_INSTRUCTION("FC" , cld()); + TEST_INSTRUCTION("0F1C841180000000" , cldemote(ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("0FAEBC1180000000" , clflush(ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("660FAEBC1180000000" , clflushopt(ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("0F01DD" , clgi()); + TEST_INSTRUCTION("FA" , cli()); + TEST_INSTRUCTION("F30FAEB41180000000" , clrssbsy(ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("F30FAEB41180000000" , clrssbsy(qword_ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("0F06" , clts()); + TEST_INSTRUCTION("660FAEB41180000000" , clwb(ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("0F01FC" , clzero(ptr(eax))); + TEST_INSTRUCTION("0F01FC" , clzero(zmmword_ptr(eax))); + TEST_INSTRUCTION("F5" , cmc()); + TEST_INSTRUCTION("660F47CA" , cmova(cx, dx)); + TEST_INSTRUCTION("660F478C1A80000000" , cmova(cx, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F478C1A80000000" , cmova(cx, word_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F47CA" , cmova(ecx, edx)); + TEST_INSTRUCTION("0F478C1A80000000" , cmova(ecx, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F478C1A80000000" , cmova(ecx, dword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F43CA" , cmovae(cx, dx)); + TEST_INSTRUCTION("660F438C1A80000000" , cmovae(cx, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F438C1A80000000" , cmovae(cx, word_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F43CA" , cmovae(ecx, edx)); + TEST_INSTRUCTION("0F438C1A80000000" , cmovae(ecx, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F438C1A80000000" , cmovae(ecx, dword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F42CA" , cmovb(cx, dx)); + TEST_INSTRUCTION("660F428C1A80000000" , cmovb(cx, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F428C1A80000000" , cmovb(cx, word_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F42CA" , cmovb(ecx, edx)); + TEST_INSTRUCTION("0F428C1A80000000" , cmovb(ecx, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F428C1A80000000" , cmovb(ecx, dword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F46CA" , cmovbe(cx, dx)); + TEST_INSTRUCTION("660F468C1A80000000" , cmovbe(cx, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F468C1A80000000" , cmovbe(cx, word_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F46CA" , cmovbe(ecx, edx)); + TEST_INSTRUCTION("0F468C1A80000000" , cmovbe(ecx, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F468C1A80000000" , cmovbe(ecx, dword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F42CA" , cmovc(cx, dx)); + TEST_INSTRUCTION("660F428C1A80000000" , cmovc(cx, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F428C1A80000000" , cmovc(cx, word_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F42CA" , cmovc(ecx, edx)); + TEST_INSTRUCTION("0F428C1A80000000" , cmovc(ecx, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F428C1A80000000" , cmovc(ecx, dword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F44CA" , cmove(cx, dx)); + TEST_INSTRUCTION("660F448C1A80000000" , cmove(cx, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F448C1A80000000" , cmove(cx, word_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F44CA" , cmove(ecx, edx)); + TEST_INSTRUCTION("0F448C1A80000000" , cmove(ecx, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F448C1A80000000" , cmove(ecx, dword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F4FCA" , cmovg(cx, dx)); + TEST_INSTRUCTION("660F4F8C1A80000000" , cmovg(cx, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F4F8C1A80000000" , cmovg(cx, word_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F4FCA" , cmovg(ecx, edx)); + TEST_INSTRUCTION("0F4F8C1A80000000" , cmovg(ecx, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F4F8C1A80000000" , cmovg(ecx, dword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F4DCA" , cmovge(cx, dx)); + TEST_INSTRUCTION("660F4D8C1A80000000" , cmovge(cx, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F4D8C1A80000000" , cmovge(cx, word_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F4DCA" , cmovge(ecx, edx)); + TEST_INSTRUCTION("0F4D8C1A80000000" , cmovge(ecx, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F4D8C1A80000000" , cmovge(ecx, dword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F4CCA" , cmovl(cx, dx)); + TEST_INSTRUCTION("660F4C8C1A80000000" , cmovl(cx, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F4C8C1A80000000" , cmovl(cx, word_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F4CCA" , cmovl(ecx, edx)); + TEST_INSTRUCTION("0F4C8C1A80000000" , cmovl(ecx, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F4C8C1A80000000" , cmovl(ecx, dword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F4ECA" , cmovle(cx, dx)); + TEST_INSTRUCTION("660F4E8C1A80000000" , cmovle(cx, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F4E8C1A80000000" , cmovle(cx, word_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F4ECA" , cmovle(ecx, edx)); + TEST_INSTRUCTION("0F4E8C1A80000000" , cmovle(ecx, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F4E8C1A80000000" , cmovle(ecx, dword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F46CA" , cmovna(cx, dx)); + TEST_INSTRUCTION("660F468C1A80000000" , cmovna(cx, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F468C1A80000000" , cmovna(cx, word_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F46CA" , cmovna(ecx, edx)); + TEST_INSTRUCTION("0F468C1A80000000" , cmovna(ecx, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F468C1A80000000" , cmovna(ecx, dword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F42CA" , cmovnae(cx, dx)); + TEST_INSTRUCTION("660F428C1A80000000" , cmovnae(cx, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F428C1A80000000" , cmovnae(cx, word_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F42CA" , cmovnae(ecx, edx)); + TEST_INSTRUCTION("0F428C1A80000000" , cmovnae(ecx, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F428C1A80000000" , cmovnae(ecx, dword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F43CA" , cmovnb(cx, dx)); + TEST_INSTRUCTION("660F438C1A80000000" , cmovnb(cx, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F438C1A80000000" , cmovnb(cx, word_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F43CA" , cmovnb(ecx, edx)); + TEST_INSTRUCTION("0F438C1A80000000" , cmovnb(ecx, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F438C1A80000000" , cmovnb(ecx, dword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F47CA" , cmovnbe(cx, dx)); + TEST_INSTRUCTION("660F478C1A80000000" , cmovnbe(cx, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F478C1A80000000" , cmovnbe(cx, word_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F47CA" , cmovnbe(ecx, edx)); + TEST_INSTRUCTION("0F478C1A80000000" , cmovnbe(ecx, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F478C1A80000000" , cmovnbe(ecx, dword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F43CA" , cmovnc(cx, dx)); + TEST_INSTRUCTION("660F438C1A80000000" , cmovnc(cx, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F438C1A80000000" , cmovnc(cx, word_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F43CA" , cmovnc(ecx, edx)); + TEST_INSTRUCTION("0F438C1A80000000" , cmovnc(ecx, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F438C1A80000000" , cmovnc(ecx, dword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F45CA" , cmovne(cx, dx)); + TEST_INSTRUCTION("660F458C1A80000000" , cmovne(cx, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F458C1A80000000" , cmovne(cx, word_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F45CA" , cmovne(ecx, edx)); + TEST_INSTRUCTION("0F458C1A80000000" , cmovne(ecx, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F458C1A80000000" , cmovne(ecx, dword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F4ECA" , cmovng(cx, dx)); + TEST_INSTRUCTION("660F4E8C1A80000000" , cmovng(cx, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F4E8C1A80000000" , cmovng(cx, word_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F4ECA" , cmovng(ecx, edx)); + TEST_INSTRUCTION("0F4E8C1A80000000" , cmovng(ecx, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F4E8C1A80000000" , cmovng(ecx, dword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F4CCA" , cmovnge(cx, dx)); + TEST_INSTRUCTION("660F4C8C1A80000000" , cmovnge(cx, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F4C8C1A80000000" , cmovnge(cx, word_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F4CCA" , cmovnge(ecx, edx)); + TEST_INSTRUCTION("0F4C8C1A80000000" , cmovnge(ecx, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F4C8C1A80000000" , cmovnge(ecx, dword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F4DCA" , cmovnl(cx, dx)); + TEST_INSTRUCTION("660F4D8C1A80000000" , cmovnl(cx, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F4D8C1A80000000" , cmovnl(cx, word_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F4DCA" , cmovnl(ecx, edx)); + TEST_INSTRUCTION("0F4D8C1A80000000" , cmovnl(ecx, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F4D8C1A80000000" , cmovnl(ecx, dword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F4FCA" , cmovnle(cx, dx)); + TEST_INSTRUCTION("660F4F8C1A80000000" , cmovnle(cx, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F4F8C1A80000000" , cmovnle(cx, word_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F4FCA" , cmovnle(ecx, edx)); + TEST_INSTRUCTION("0F4F8C1A80000000" , cmovnle(ecx, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F4F8C1A80000000" , cmovnle(ecx, dword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F41CA" , cmovno(cx, dx)); + TEST_INSTRUCTION("660F418C1A80000000" , cmovno(cx, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F418C1A80000000" , cmovno(cx, word_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F41CA" , cmovno(ecx, edx)); + TEST_INSTRUCTION("0F418C1A80000000" , cmovno(ecx, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F418C1A80000000" , cmovno(ecx, dword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F4BCA" , cmovnp(cx, dx)); + TEST_INSTRUCTION("660F4B8C1A80000000" , cmovnp(cx, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F4B8C1A80000000" , cmovnp(cx, word_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F4BCA" , cmovnp(ecx, edx)); + TEST_INSTRUCTION("0F4B8C1A80000000" , cmovnp(ecx, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F4B8C1A80000000" , cmovnp(ecx, dword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F49CA" , cmovns(cx, dx)); + TEST_INSTRUCTION("660F498C1A80000000" , cmovns(cx, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F498C1A80000000" , cmovns(cx, word_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F49CA" , cmovns(ecx, edx)); + TEST_INSTRUCTION("0F498C1A80000000" , cmovns(ecx, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F498C1A80000000" , cmovns(ecx, dword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F45CA" , cmovnz(cx, dx)); + TEST_INSTRUCTION("660F458C1A80000000" , cmovnz(cx, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F458C1A80000000" , cmovnz(cx, word_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F45CA" , cmovnz(ecx, edx)); + TEST_INSTRUCTION("0F458C1A80000000" , cmovnz(ecx, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F458C1A80000000" , cmovnz(ecx, dword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F40CA" , cmovo(cx, dx)); + TEST_INSTRUCTION("660F408C1A80000000" , cmovo(cx, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F408C1A80000000" , cmovo(cx, word_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F40CA" , cmovo(ecx, edx)); + TEST_INSTRUCTION("0F408C1A80000000" , cmovo(ecx, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F408C1A80000000" , cmovo(ecx, dword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F4ACA" , cmovp(cx, dx)); + TEST_INSTRUCTION("660F4A8C1A80000000" , cmovp(cx, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F4A8C1A80000000" , cmovp(cx, word_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F4ACA" , cmovp(ecx, edx)); + TEST_INSTRUCTION("0F4A8C1A80000000" , cmovp(ecx, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F4A8C1A80000000" , cmovp(ecx, dword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F4ACA" , cmovpe(cx, dx)); + TEST_INSTRUCTION("660F4A8C1A80000000" , cmovpe(cx, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F4A8C1A80000000" , cmovpe(cx, word_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F4ACA" , cmovpe(ecx, edx)); + TEST_INSTRUCTION("0F4A8C1A80000000" , cmovpe(ecx, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F4A8C1A80000000" , cmovpe(ecx, dword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F4BCA" , cmovpo(cx, dx)); + TEST_INSTRUCTION("660F4B8C1A80000000" , cmovpo(cx, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F4B8C1A80000000" , cmovpo(cx, word_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F4BCA" , cmovpo(ecx, edx)); + TEST_INSTRUCTION("0F4B8C1A80000000" , cmovpo(ecx, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F4B8C1A80000000" , cmovpo(ecx, dword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F48CA" , cmovs(cx, dx)); + TEST_INSTRUCTION("660F488C1A80000000" , cmovs(cx, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F488C1A80000000" , cmovs(cx, word_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F48CA" , cmovs(ecx, edx)); + TEST_INSTRUCTION("0F488C1A80000000" , cmovs(ecx, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F488C1A80000000" , cmovs(ecx, dword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F44CA" , cmovz(cx, dx)); + TEST_INSTRUCTION("660F448C1A80000000" , cmovz(cx, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F448C1A80000000" , cmovz(cx, word_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F44CA" , cmovz(ecx, edx)); + TEST_INSTRUCTION("0F448C1A80000000" , cmovz(ecx, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F448C1A80000000" , cmovz(ecx, dword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("80F901" , cmp(cl, 1)); + TEST_INSTRUCTION("80FD01" , cmp(ch, 1)); + TEST_INSTRUCTION("80BC118000000001" , cmp(byte_ptr(ecx, edx, 0, 128), 1)); + TEST_INSTRUCTION("6683F901" , cmp(cx, 1)); + TEST_INSTRUCTION("6683BC118000000001" , cmp(word_ptr(ecx, edx, 0, 128), 1)); + TEST_INSTRUCTION("83F901" , cmp(ecx, 1)); + TEST_INSTRUCTION("83BC118000000001" , cmp(dword_ptr(ecx, edx, 0, 128), 1)); + TEST_INSTRUCTION("38D1" , cmp(cl, dl)); + TEST_INSTRUCTION("38F1" , cmp(cl, dh)); + TEST_INSTRUCTION("38D5" , cmp(ch, dl)); + TEST_INSTRUCTION("38F5" , cmp(ch, dh)); + TEST_INSTRUCTION("389C1180000000" , cmp(ptr(ecx, edx, 0, 128), bl)); + TEST_INSTRUCTION("38BC1180000000" , cmp(ptr(ecx, edx, 0, 128), bh)); + TEST_INSTRUCTION("389C1180000000" , cmp(byte_ptr(ecx, edx, 0, 128), bl)); + TEST_INSTRUCTION("38BC1180000000" , cmp(byte_ptr(ecx, edx, 0, 128), bh)); + TEST_INSTRUCTION("6639D1" , cmp(cx, dx)); + TEST_INSTRUCTION("66399C1180000000" , cmp(ptr(ecx, edx, 0, 128), bx)); + TEST_INSTRUCTION("66399C1180000000" , cmp(word_ptr(ecx, edx, 0, 128), bx)); + TEST_INSTRUCTION("39D1" , cmp(ecx, edx)); + TEST_INSTRUCTION("399C1180000000" , cmp(ptr(ecx, edx, 0, 128), ebx)); + TEST_INSTRUCTION("399C1180000000" , cmp(dword_ptr(ecx, edx, 0, 128), ebx)); + TEST_INSTRUCTION("3A8C1A80000000" , cmp(cl, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("3A8C1A80000000" , cmp(cl, byte_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("3AAC1A80000000" , cmp(ch, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("3AAC1A80000000" , cmp(ch, byte_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("663B8C1A80000000" , cmp(cx, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("663B8C1A80000000" , cmp(cx, word_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("3B8C1A80000000" , cmp(ecx, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("3B8C1A80000000" , cmp(ecx, dword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("A6" , cmps(byte_ptr(esi), byte_ptr(edi))); + TEST_INSTRUCTION("66A7" , cmps(word_ptr(esi), word_ptr(edi))); + TEST_INSTRUCTION("A7" , cmps(dword_ptr(esi), dword_ptr(edi))); + TEST_INSTRUCTION("0FB0D1" , cmpxchg(cl, dl, al)); + TEST_INSTRUCTION("0FB0F1" , cmpxchg(cl, dh, al)); + TEST_INSTRUCTION("0FB0D5" , cmpxchg(ch, dl, al)); + TEST_INSTRUCTION("0FB0F5" , cmpxchg(ch, dh, al)); + TEST_INSTRUCTION("0FB09C1180000000" , cmpxchg(ptr(ecx, edx, 0, 128), bl, al)); + TEST_INSTRUCTION("0FB0BC1180000000" , cmpxchg(ptr(ecx, edx, 0, 128), bh, al)); + TEST_INSTRUCTION("0FB09C1180000000" , cmpxchg(byte_ptr(ecx, edx, 0, 128), bl, al)); + TEST_INSTRUCTION("0FB0BC1180000000" , cmpxchg(byte_ptr(ecx, edx, 0, 128), bh, al)); + TEST_INSTRUCTION("660FB1D1" , cmpxchg(cx, dx, ax)); + TEST_INSTRUCTION("660FB19C1180000000" , cmpxchg(ptr(ecx, edx, 0, 128), bx, ax)); + TEST_INSTRUCTION("660FB19C1180000000" , cmpxchg(word_ptr(ecx, edx, 0, 128), bx, ax)); + TEST_INSTRUCTION("0FB1D1" , cmpxchg(ecx, edx, eax)); + TEST_INSTRUCTION("0FB19C1180000000" , cmpxchg(ptr(ecx, edx, 0, 128), ebx, eax)); + TEST_INSTRUCTION("0FB19C1180000000" , cmpxchg(dword_ptr(ecx, edx, 0, 128), ebx, eax)); + TEST_INSTRUCTION("0FC78C1180000000" , cmpxchg8b(ptr(ecx, edx, 0, 128), edx, eax, ecx, ebx)); + TEST_INSTRUCTION("0FC78C1180000000" , cmpxchg8b(qword_ptr(ecx, edx, 0, 128), edx, eax, ecx, ebx)); + TEST_INSTRUCTION("0FA2" , cpuid(eax, ebx, ecx, edx)); + TEST_INSTRUCTION("F20F38F0CA" , crc32(ecx, dl)); + TEST_INSTRUCTION("F20F38F0CE" , crc32(ecx, dh)); + TEST_INSTRUCTION("66F20F38F1CA" , crc32(ecx, dx)); + TEST_INSTRUCTION("F20F38F1CA" , crc32(ecx, edx)); + TEST_INSTRUCTION("F20F38F08C1A80000000" , crc32(ecx, byte_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("66F20F38F18C1A80000000" , crc32(ecx, word_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("F20F38F18C1A80000000" , crc32(ecx, dword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("6699" , cwd(dx, ax)); + TEST_INSTRUCTION("98" , cwde(eax)); + TEST_INSTRUCTION("27" , daa(ax)); + TEST_INSTRUCTION("2F" , das(ax)); + TEST_INSTRUCTION("6649" , dec(cx)); + TEST_INSTRUCTION("49" , dec(ecx)); + TEST_INSTRUCTION("FEC9" , dec(cl)); + TEST_INSTRUCTION("FECD" , dec(ch)); + TEST_INSTRUCTION("FE8C1180000000" , dec(byte_ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("66FF8C1180000000" , dec(word_ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("FF8C1180000000" , dec(dword_ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("F6F1" , div(ax, cl)); + TEST_INSTRUCTION("F6F5" , div(ax, ch)); + TEST_INSTRUCTION("F6B41180000000" , div(ax, ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("F6B41180000000" , div(ax, byte_ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("66F7F1" , div(dx, ax, cx)); + TEST_INSTRUCTION("66F7B41180000000" , div(dx, ax, ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("66F7B41180000000" , div(dx, ax, word_ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("F7F1" , div(edx, eax, ecx)); + TEST_INSTRUCTION("F7B41180000000" , div(edx, eax, ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("F7B41180000000" , div(edx, eax, dword_ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("0F77" , emms()); + TEST_INSTRUCTION("F30F1EFB" , endbr32()); + TEST_INSTRUCTION("F30F1EFA" , endbr64()); + TEST_INSTRUCTION("F20F38F88C1A80000000" , enqcmd(zmmword_ptr(ecx), zmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("F30F38F88C1A80000000" , enqcmds(zmmword_ptr(ecx), zmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C8010002" , enter(1, 2)); + TEST_INSTRUCTION("0FAE8C1180000000" , fxrstor(ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("0FAE841180000000" , fxsave(ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("D9F4" , fxtract()); + TEST_INSTRUCTION("0F37" , getsec()); + TEST_INSTRUCTION("F4" , hlt()); + TEST_INSTRUCTION("F30F3AF0C001" , hreset(1, eax)); + TEST_INSTRUCTION("F6F9" , idiv(ax, cl)); + TEST_INSTRUCTION("F6FD" , idiv(ax, ch)); + TEST_INSTRUCTION("F6BC1180000000" , idiv(ax, ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("F6BC1180000000" , idiv(ax, byte_ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("66F7F9" , idiv(dx, ax, cx)); + TEST_INSTRUCTION("66F7BC1180000000" , idiv(dx, ax, ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("66F7BC1180000000" , idiv(dx, ax, word_ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("F7F9" , idiv(edx, eax, ecx)); + TEST_INSTRUCTION("F7BC1180000000" , idiv(edx, eax, ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("F7BC1180000000" , idiv(edx, eax, dword_ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("F6E9" , imul(ax, cl)); + TEST_INSTRUCTION("F6ED" , imul(ax, ch)); + TEST_INSTRUCTION("660FAF841180000000" , imul(ax, ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("F6AC1180000000" , imul(ax, byte_ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("66F7E9" , imul(dx, ax, cx)); + TEST_INSTRUCTION("66F7AC1180000000" , imul(dx, ax, ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("66F7AC1180000000" , imul(dx, ax, word_ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("F7E9" , imul(edx, eax, ecx)); + TEST_INSTRUCTION("F7AC1180000000" , imul(edx, eax, ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("F7AC1180000000" , imul(edx, eax, dword_ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("660FAFCA" , imul(cx, dx)); + TEST_INSTRUCTION("666BC901" , imul(cx, 1)); + TEST_INSTRUCTION("660FAF8C1A80000000" , imul(cx, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660FAF8C1A80000000" , imul(cx, word_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0FAFCA" , imul(ecx, edx)); + TEST_INSTRUCTION("6BC901" , imul(ecx, 1)); + TEST_INSTRUCTION("0FAF8C1A80000000" , imul(ecx, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0FAF8C1A80000000" , imul(ecx, dword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("666BCA01" , imul(cx, dx, 1)); + TEST_INSTRUCTION("666B8C1A8000000001" , imul(cx, ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("666B8C1A8000000001" , imul(cx, word_ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("6BCA01" , imul(ecx, edx, 1)); + TEST_INSTRUCTION("6B8C1A8000000001" , imul(ecx, ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("6B8C1A8000000001" , imul(ecx, dword_ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("EC" , in(al, dx)); + TEST_INSTRUCTION("E401" , in(al, 1)); + TEST_INSTRUCTION("66ED" , in(ax, dx)); + TEST_INSTRUCTION("66E501" , in(ax, 1)); + TEST_INSTRUCTION("ED" , in(eax, dx)); + TEST_INSTRUCTION("E501" , in(eax, 1)); + TEST_INSTRUCTION("6641" , inc(cx)); + TEST_INSTRUCTION("41" , inc(ecx)); + TEST_INSTRUCTION("FEC1" , inc(cl)); + TEST_INSTRUCTION("FEC5" , inc(ch)); + TEST_INSTRUCTION("FE841180000000" , inc(byte_ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("66FF841180000000" , inc(word_ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("FF841180000000" , inc(dword_ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("F30FAEE9" , incsspd(ecx)); + TEST_INSTRUCTION("6C" , ins(byte_ptr(edi), dx)); + TEST_INSTRUCTION("666D" , ins(word_ptr(edi), dx)); + TEST_INSTRUCTION("6D" , ins(dword_ptr(edi), dx)); + TEST_INSTRUCTION("CD01" , int_(1)); + TEST_INSTRUCTION("CC" , int3()); + TEST_INSTRUCTION("CE" , into()); + TEST_INSTRUCTION("0F08" , invd()); + TEST_INSTRUCTION("660F38808C1A80000000" , invept(ecx, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F38808C1A80000000" , invept(ecx, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F01BC1180000000" , invlpg(ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("0F01DF" , invlpga(eax, ecx)); + TEST_INSTRUCTION("660F38828C1A80000000" , invpcid(ecx, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F38828C1A80000000" , invpcid(ecx, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F38818C1A80000000" , invvpid(ecx, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F38818C1A80000000" , invvpid(ecx, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("66CF" , iret()); + TEST_INSTRUCTION("CF" , iretd()); + TEST_INSTRUCTION("9F" , lahf(ah)); + TEST_INSTRUCTION("660F02CA" , lar(cx, dx)); + TEST_INSTRUCTION("660F028C1A80000000" , lar(cx, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F028C1A80000000" , lar(cx, word_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F02CA" , lar(ecx, edx)); + TEST_INSTRUCTION("0F028C1A80000000" , lar(ecx, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F028C1A80000000" , lar(ecx, word_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("9A020000000100" , lcall(1, 2)); + TEST_INSTRUCTION("FF9C1180000000" , lcall(ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("66FF9C1180000000" , lcall(dword_ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("FF9C1180000000" , lcall(fword_ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("0FAE941180000000" , ldmxcsr(ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("0FAE941180000000" , ldmxcsr(dword_ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("66C58C1A80000000" , lds(cx, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("66C58C1A80000000" , lds(cx, dword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C58C1A80000000" , lds(ecx, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C58C1A80000000" , lds(ecx, fword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("668D8C1A80000000" , lea(cx, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("8D8C1A80000000" , lea(ecx, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C9" , leave()); + TEST_INSTRUCTION("66C48C1A80000000" , les(cx, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("66C48C1A80000000" , les(cx, dword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C48C1A80000000" , les(ecx, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C48C1A80000000" , les(ecx, fword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0FAEE8" , lfence()); + TEST_INSTRUCTION("660FB48C1A80000000" , lfs(cx, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660FB48C1A80000000" , lfs(cx, dword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0FB48C1A80000000" , lfs(ecx, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0FB48C1A80000000" , lfs(ecx, fword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F01941180000000" , lgdt(ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("660FB58C1A80000000" , lgs(cx, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660FB58C1A80000000" , lgs(cx, dword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0FB58C1A80000000" , lgs(ecx, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0FB58C1A80000000" , lgs(ecx, fword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F019C1180000000" , lidt(ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("EA020000000100" , ljmp(1, 2)); + TEST_INSTRUCTION("FFAC1180000000" , ljmp(ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("66FFAC1180000000" , ljmp(dword_ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("FFAC1180000000" , ljmp(fword_ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("0F00D1" , lldt(cx)); + TEST_INSTRUCTION("0F00941180000000" , lldt(ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("0F00941180000000" , lldt(word_ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("8FE97812C1" , llwpcb(ecx)); + TEST_INSTRUCTION("0F01F1" , lmsw(cx)); + TEST_INSTRUCTION("0F01B41180000000" , lmsw(ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("0F01B41180000000" , lmsw(word_ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("AC" , lods(al, ptr(esi))); + TEST_INSTRUCTION("AC" , lods(al, byte_ptr(esi))); + TEST_INSTRUCTION("66AD" , lods(ax, ptr(esi))); + TEST_INSTRUCTION("66AD" , lods(ax, word_ptr(esi))); + TEST_INSTRUCTION("AD" , lods(eax, ptr(esi))); + TEST_INSTRUCTION("AD" , lods(eax, dword_ptr(esi))); + TEST_INSTRUCTION("660F03CA" , lsl(cx, dx)); + TEST_INSTRUCTION("660F038C1A80000000" , lsl(cx, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F038C1A80000000" , lsl(cx, word_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F03CA" , lsl(ecx, edx)); + TEST_INSTRUCTION("0F038C1A80000000" , lsl(ecx, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F038C1A80000000" , lsl(ecx, word_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660FB28C1A80000000" , lss(cx, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660FB28C1A80000000" , lss(cx, dword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0FB28C1A80000000" , lss(ecx, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0FB28C1A80000000" , lss(ecx, fword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F00D9" , ltr(cx)); + TEST_INSTRUCTION("0F009C1180000000" , ltr(ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("0F009C1180000000" , ltr(word_ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("8FEA7012C201000000" , lwpins(ecx, edx, 1)); + TEST_INSTRUCTION("8FEA7012841A8000000001000000" , lwpins(ecx, ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("8FEA7012841A8000000001000000" , lwpins(ecx, dword_ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("8FEA7012CA01000000" , lwpval(ecx, edx, 1)); + TEST_INSTRUCTION("8FEA70128C1A8000000001000000" , lwpval(ecx, ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("8FEA70128C1A8000000001000000" , lwpval(ecx, dword_ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("66F30FBDCA" , lzcnt(cx, dx)); + TEST_INSTRUCTION("66F30FBD8C1A80000000" , lzcnt(cx, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("66F30FBD8C1A80000000" , lzcnt(cx, word_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("F30FBDCA" , lzcnt(ecx, edx)); + TEST_INSTRUCTION("F30FBD8C1A80000000" , lzcnt(ecx, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("F30FBD8C1A80000000" , lzcnt(ecx, dword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("F30F01FA" , mcommit()); + TEST_INSTRUCTION("0FAEF0" , mfence()); + TEST_INSTRUCTION("0F01C8" , monitor(ptr(eax), ecx, edx)); + TEST_INSTRUCTION("0F01FA" , monitorx(ptr(eax), ecx, edx)); + TEST_INSTRUCTION("88D1" , mov(cl, dl)); + TEST_INSTRUCTION("88F1" , mov(cl, dh)); + TEST_INSTRUCTION("88D5" , mov(ch, dl)); + TEST_INSTRUCTION("88F5" , mov(ch, dh)); + TEST_INSTRUCTION("889C1180000000" , mov(ptr(ecx, edx, 0, 128), bl)); + TEST_INSTRUCTION("88BC1180000000" , mov(ptr(ecx, edx, 0, 128), bh)); + TEST_INSTRUCTION("889C1180000000" , mov(byte_ptr(ecx, edx, 0, 128), bl)); + TEST_INSTRUCTION("88BC1180000000" , mov(byte_ptr(ecx, edx, 0, 128), bh)); + TEST_INSTRUCTION("6689D1" , mov(cx, dx)); + TEST_INSTRUCTION("668EE2" , mov(fs, dx)); + TEST_INSTRUCTION("66899C1180000000" , mov(ptr(ecx, edx, 0, 128), bx)); + TEST_INSTRUCTION("66899C1180000000" , mov(word_ptr(ecx, edx, 0, 128), bx)); + TEST_INSTRUCTION("89D1" , mov(ecx, edx)); + TEST_INSTRUCTION("8EE2" , mov(fs, edx)); + TEST_INSTRUCTION("899C1180000000" , mov(ptr(ecx, edx, 0, 128), ebx)); + TEST_INSTRUCTION("899C1180000000" , mov(dword_ptr(ecx, edx, 0, 128), ebx)); + TEST_INSTRUCTION("B101" , mov(cl, 1)); + TEST_INSTRUCTION("B501" , mov(ch, 1)); + TEST_INSTRUCTION("C684118000000001" , mov(byte_ptr(ecx, edx, 0, 128), 1)); + TEST_INSTRUCTION("66B90100" , mov(cx, 1)); + TEST_INSTRUCTION("66C78411800000000100" , mov(word_ptr(ecx, edx, 0, 128), 1)); + TEST_INSTRUCTION("B901000000" , mov(ecx, 1)); + TEST_INSTRUCTION("C784118000000001000000" , mov(dword_ptr(ecx, edx, 0, 128), 1)); + TEST_INSTRUCTION("8A8C1A80000000" , mov(cl, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("8A8C1A80000000" , mov(cl, byte_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("8AAC1A80000000" , mov(ch, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("8AAC1A80000000" , mov(ch, byte_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("668CE1" , mov(cx, fs)); + TEST_INSTRUCTION("668B8C1A80000000" , mov(cx, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("668B8C1A80000000" , mov(cx, word_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("8CE1" , mov(ecx, fs)); + TEST_INSTRUCTION("8B8C1A80000000" , mov(ecx, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("8B8C1A80000000" , mov(ecx, dword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("8CA41180000000" , mov(ptr(ecx, edx, 0, 128), fs)); + TEST_INSTRUCTION("668CA41180000000" , mov(word_ptr(ecx, edx, 0, 128), fs)); + TEST_INSTRUCTION("8EA41A80000000" , mov(fs, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("668EA41A80000000" , mov(fs, word_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F20D1" , mov(ecx, cr2)); + TEST_INSTRUCTION("0F21D1" , mov(ecx, dr2)); + TEST_INSTRUCTION("0F22CA" , mov(cr1, edx)); + TEST_INSTRUCTION("0F23CA" , mov(dr1, edx)); + TEST_INSTRUCTION("660F38F08C1A80000000" , movbe(cx, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F38F08C1A80000000" , movbe(cx, word_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F38F08C1A80000000" , movbe(ecx, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F38F08C1A80000000" , movbe(ecx, dword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F38F19C1180000000" , movbe(ptr(ecx, edx, 0, 128), bx)); + TEST_INSTRUCTION("660F38F19C1180000000" , movbe(word_ptr(ecx, edx, 0, 128), bx)); + TEST_INSTRUCTION("0F38F19C1180000000" , movbe(ptr(ecx, edx, 0, 128), ebx)); + TEST_INSTRUCTION("0F38F19C1180000000" , movbe(dword_ptr(ecx, edx, 0, 128), ebx)); + TEST_INSTRUCTION("660F38F88C1A80000000" , movdir64b(zmmword_ptr(ecx), zmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F38F99C1180000000" , movdiri(ptr(ecx, edx, 0, 128), ebx)); + TEST_INSTRUCTION("0F38F99C1180000000" , movdiri(dword_ptr(ecx, edx, 0, 128), ebx)); + TEST_INSTRUCTION("0FC39C1180000000" , movnti(ptr(ecx, edx, 0, 128), ebx)); + TEST_INSTRUCTION("0FC39C1180000000" , movnti(dword_ptr(ecx, edx, 0, 128), ebx)); + TEST_INSTRUCTION("A4" , movs(byte_ptr(edi), byte_ptr(esi))); + TEST_INSTRUCTION("66A5" , movs(word_ptr(edi), word_ptr(esi))); + TEST_INSTRUCTION("A5" , movs(dword_ptr(edi), dword_ptr(esi))); + TEST_INSTRUCTION("660FBECA" , movsx(cx, dl)); + TEST_INSTRUCTION("660FBECE" , movsx(cx, dh)); + TEST_INSTRUCTION("660FBE8C1A80000000" , movsx(cx, byte_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0FBECA" , movsx(ecx, dl)); + TEST_INSTRUCTION("0FBECE" , movsx(ecx, dh)); + TEST_INSTRUCTION("0FBFCA" , movsx(ecx, dx)); + TEST_INSTRUCTION("0FBE8C1A80000000" , movsx(ecx, byte_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0FBF8C1A80000000" , movsx(ecx, word_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660FB6CA" , movzx(cx, dl)); + TEST_INSTRUCTION("660FB6CE" , movzx(cx, dh)); + TEST_INSTRUCTION("660FB68C1A80000000" , movzx(cx, byte_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0FB6CA" , movzx(ecx, dl)); + TEST_INSTRUCTION("0FB6CE" , movzx(ecx, dh)); + TEST_INSTRUCTION("0FB7CA" , movzx(ecx, dx)); + TEST_INSTRUCTION("0FB68C1A80000000" , movzx(ecx, byte_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0FB78C1A80000000" , movzx(ecx, word_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("F6E1" , mul(ax, cl)); + TEST_INSTRUCTION("F6E5" , mul(ax, ch)); + TEST_INSTRUCTION("F6A41180000000" , mul(ax, ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("F6A41180000000" , mul(ax, byte_ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("66F7E1" , mul(dx, ax, cx)); + TEST_INSTRUCTION("66F7A41180000000" , mul(dx, ax, ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("66F7A41180000000" , mul(dx, ax, word_ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("F7E1" , mul(edx, eax, ecx)); + TEST_INSTRUCTION("F7A41180000000" , mul(edx, eax, ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("F7A41180000000" , mul(edx, eax, dword_ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("C4E26BF6CB" , mulx(ecx, edx, ebx, edx)); + TEST_INSTRUCTION("C4E26BF68C2B80000000" , mulx(ecx, edx, ptr(ebx, ebp, 0, 128), edx)); + TEST_INSTRUCTION("C4E26BF68C2B80000000" , mulx(ecx, edx, dword_ptr(ebx, ebp, 0, 128), edx)); + TEST_INSTRUCTION("0F01C9" , mwait(eax, ecx)); + TEST_INSTRUCTION("0F01FB" , mwaitx(eax, ecx, ebx)); + TEST_INSTRUCTION("F6D9" , neg(cl)); + TEST_INSTRUCTION("F6DD" , neg(ch)); + TEST_INSTRUCTION("66F7D9" , neg(cx)); + TEST_INSTRUCTION("F7D9" , neg(ecx)); + TEST_INSTRUCTION("F69C1180000000" , neg(byte_ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("66F79C1180000000" , neg(word_ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("F79C1180000000" , neg(dword_ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("90" , nop()); + TEST_INSTRUCTION("660F1FC1" , nop(cx)); + TEST_INSTRUCTION("0F1FC1" , nop(ecx)); + TEST_INSTRUCTION("660F1F841180000000" , nop(word_ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("0F1F841180000000" , nop(dword_ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("660F1FD1" , nop(cx, dx)); + TEST_INSTRUCTION("660F1F9C1180000000" , nop(ptr(ecx, edx, 0, 128), bx)); + TEST_INSTRUCTION("660F1F9C1180000000" , nop(word_ptr(ecx, edx, 0, 128), bx)); + TEST_INSTRUCTION("0F1FD1" , nop(ecx, edx)); + TEST_INSTRUCTION("0F1F9C1180000000" , nop(ptr(ecx, edx, 0, 128), ebx)); + TEST_INSTRUCTION("0F1F9C1180000000" , nop(dword_ptr(ecx, edx, 0, 128), ebx)); + TEST_INSTRUCTION("F6D1" , not_(cl)); + TEST_INSTRUCTION("F6D5" , not_(ch)); + TEST_INSTRUCTION("66F7D1" , not_(cx)); + TEST_INSTRUCTION("F7D1" , not_(ecx)); + TEST_INSTRUCTION("F6941180000000" , not_(byte_ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("66F7941180000000" , not_(word_ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("F7941180000000" , not_(dword_ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("80C901" , or_(cl, 1)); + TEST_INSTRUCTION("80CD01" , or_(ch, 1)); + TEST_INSTRUCTION("808C118000000001" , or_(byte_ptr(ecx, edx, 0, 128), 1)); + TEST_INSTRUCTION("6683C901" , or_(cx, 1)); + TEST_INSTRUCTION("66838C118000000001" , or_(word_ptr(ecx, edx, 0, 128), 1)); + TEST_INSTRUCTION("83C901" , or_(ecx, 1)); + TEST_INSTRUCTION("838C118000000001" , or_(dword_ptr(ecx, edx, 0, 128), 1)); + TEST_INSTRUCTION("08D1" , or_(cl, dl)); + TEST_INSTRUCTION("08F1" , or_(cl, dh)); + TEST_INSTRUCTION("08D5" , or_(ch, dl)); + TEST_INSTRUCTION("08F5" , or_(ch, dh)); + TEST_INSTRUCTION("089C1180000000" , or_(ptr(ecx, edx, 0, 128), bl)); + TEST_INSTRUCTION("08BC1180000000" , or_(ptr(ecx, edx, 0, 128), bh)); + TEST_INSTRUCTION("089C1180000000" , or_(byte_ptr(ecx, edx, 0, 128), bl)); + TEST_INSTRUCTION("08BC1180000000" , or_(byte_ptr(ecx, edx, 0, 128), bh)); + TEST_INSTRUCTION("6609D1" , or_(cx, dx)); + TEST_INSTRUCTION("66099C1180000000" , or_(ptr(ecx, edx, 0, 128), bx)); + TEST_INSTRUCTION("66099C1180000000" , or_(word_ptr(ecx, edx, 0, 128), bx)); + TEST_INSTRUCTION("09D1" , or_(ecx, edx)); + TEST_INSTRUCTION("099C1180000000" , or_(ptr(ecx, edx, 0, 128), ebx)); + TEST_INSTRUCTION("099C1180000000" , or_(dword_ptr(ecx, edx, 0, 128), ebx)); + TEST_INSTRUCTION("0A8C1A80000000" , or_(cl, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0A8C1A80000000" , or_(cl, byte_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0AAC1A80000000" , or_(ch, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0AAC1A80000000" , or_(ch, byte_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660B8C1A80000000" , or_(cx, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660B8C1A80000000" , or_(cx, word_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0B8C1A80000000" , or_(ecx, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0B8C1A80000000" , or_(ecx, dword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("EE" , out(dx, al)); + TEST_INSTRUCTION("66EF" , out(dx, ax)); + TEST_INSTRUCTION("EF" , out(dx, eax)); + TEST_INSTRUCTION("E601" , out(1, al)); + TEST_INSTRUCTION("66E701" , out(1, ax)); + TEST_INSTRUCTION("E701" , out(1, eax)); + TEST_INSTRUCTION("6E" , outs(dx, byte_ptr(esi))); + TEST_INSTRUCTION("666F" , outs(dx, word_ptr(esi))); + TEST_INSTRUCTION("6F" , outs(dx, dword_ptr(esi))); + TEST_INSTRUCTION("F390" , pause()); + TEST_INSTRUCTION("0F01C5" , pconfig()); + TEST_INSTRUCTION("C4E26BF5CB" , pdep(ecx, edx, ebx)); + TEST_INSTRUCTION("C4E26BF58C2B80000000" , pdep(ecx, edx, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E26BF58C2B80000000" , pdep(ecx, edx, dword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E26AF5CB" , pext(ecx, edx, ebx)); + TEST_INSTRUCTION("C4E26AF58C2B80000000" , pext(ecx, edx, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E26AF58C2B80000000" , pext(ecx, edx, dword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("6659" , pop(cx)); + TEST_INSTRUCTION("668F841180000000" , pop(word_ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("59" , pop(ecx)); + TEST_INSTRUCTION("8F841180000000" , pop(dword_ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("0FA1" , pop(fs)); + TEST_INSTRUCTION("6661" , popa()); + TEST_INSTRUCTION("61" , popad()); + TEST_INSTRUCTION("66F30FB8CA" , popcnt(cx, dx)); + TEST_INSTRUCTION("66F30FB88C1A80000000" , popcnt(cx, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("66F30FB88C1A80000000" , popcnt(cx, word_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("F30FB8CA" , popcnt(ecx, edx)); + TEST_INSTRUCTION("F30FB88C1A80000000" , popcnt(ecx, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("F30FB88C1A80000000" , popcnt(ecx, dword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("669D" , popf()); + TEST_INSTRUCTION("9D" , popfd()); + TEST_INSTRUCTION("0F0D841180000000" , prefetch(ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("0F18841180000000" , prefetchnta(ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("0F188C1180000000" , prefetcht0(ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("0F18941180000000" , prefetcht1(ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("0F189C1180000000" , prefetcht2(ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("0F0D8C1180000000" , prefetchw(ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("0F0D941180000000" , prefetchwt1(ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("F30FAEE1" , ptwrite(ecx)); + TEST_INSTRUCTION("F30FAEA41180000000" , ptwrite(ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("F30FAEA41180000000" , ptwrite(dword_ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("6651" , push(cx)); + TEST_INSTRUCTION("6A01" , push(1)); + TEST_INSTRUCTION("66FFB41180000000" , push(word_ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("51" , push(ecx)); + TEST_INSTRUCTION("FFB41180000000" , push(dword_ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("0FA0" , push(fs)); + TEST_INSTRUCTION("6660" , pusha()); + TEST_INSTRUCTION("60" , pushad()); + TEST_INSTRUCTION("669C" , pushf()); + TEST_INSTRUCTION("9C" , pushfd()); + TEST_INSTRUCTION("F20F01FF" , pvalidate()); + TEST_INSTRUCTION("D2D1" , rcl(cl, cl)); + TEST_INSTRUCTION("D0D1" , rcl(cl, 1)); + TEST_INSTRUCTION("D2D5" , rcl(ch, cl)); + TEST_INSTRUCTION("D0D5" , rcl(ch, 1)); + TEST_INSTRUCTION("66D3D1" , rcl(cx, cl)); + TEST_INSTRUCTION("66D1D1" , rcl(cx, 1)); + TEST_INSTRUCTION("D3D1" , rcl(ecx, cl)); + TEST_INSTRUCTION("D1D1" , rcl(ecx, 1)); + TEST_INSTRUCTION("D2941180000000" , rcl(byte_ptr(ecx, edx, 0, 128), cl)); + TEST_INSTRUCTION("D0941180000000" , rcl(byte_ptr(ecx, edx, 0, 128), 1)); + TEST_INSTRUCTION("66D3941180000000" , rcl(word_ptr(ecx, edx, 0, 128), cl)); + TEST_INSTRUCTION("66D1941180000000" , rcl(word_ptr(ecx, edx, 0, 128), 1)); + TEST_INSTRUCTION("D3941180000000" , rcl(dword_ptr(ecx, edx, 0, 128), cl)); + TEST_INSTRUCTION("D1941180000000" , rcl(dword_ptr(ecx, edx, 0, 128), 1)); + TEST_INSTRUCTION("D2D9" , rcr(cl, cl)); + TEST_INSTRUCTION("D0D9" , rcr(cl, 1)); + TEST_INSTRUCTION("D2DD" , rcr(ch, cl)); + TEST_INSTRUCTION("D0DD" , rcr(ch, 1)); + TEST_INSTRUCTION("66D3D9" , rcr(cx, cl)); + TEST_INSTRUCTION("66D1D9" , rcr(cx, 1)); + TEST_INSTRUCTION("D3D9" , rcr(ecx, cl)); + TEST_INSTRUCTION("D1D9" , rcr(ecx, 1)); + TEST_INSTRUCTION("D29C1180000000" , rcr(byte_ptr(ecx, edx, 0, 128), cl)); + TEST_INSTRUCTION("D09C1180000000" , rcr(byte_ptr(ecx, edx, 0, 128), 1)); + TEST_INSTRUCTION("66D39C1180000000" , rcr(word_ptr(ecx, edx, 0, 128), cl)); + TEST_INSTRUCTION("66D19C1180000000" , rcr(word_ptr(ecx, edx, 0, 128), 1)); + TEST_INSTRUCTION("D39C1180000000" , rcr(dword_ptr(ecx, edx, 0, 128), cl)); + TEST_INSTRUCTION("D19C1180000000" , rcr(dword_ptr(ecx, edx, 0, 128), 1)); + TEST_INSTRUCTION("0F32" , rdmsr(edx, eax, ecx)); + TEST_INSTRUCTION("F30FC7F9" , rdpid(ecx)); + TEST_INSTRUCTION("0F01EE" , rdpkru(edx, eax, ecx)); + TEST_INSTRUCTION("0F33" , rdpmc(edx, eax, ecx)); + TEST_INSTRUCTION("0F01FD" , rdpru(edx, eax, ecx)); + TEST_INSTRUCTION("660FC7F1" , rdrand(cx)); + TEST_INSTRUCTION("0FC7F1" , rdrand(ecx)); + TEST_INSTRUCTION("660FC7F9" , rdseed(cx)); + TEST_INSTRUCTION("0FC7F9" , rdseed(ecx)); + TEST_INSTRUCTION("F30F1EC9" , rdsspd(ecx)); + TEST_INSTRUCTION("0F31" , rdtsc(edx, eax)); + TEST_INSTRUCTION("0F01F9" , rdtscp(edx, eax, ecx)); + TEST_INSTRUCTION("C3" , ret()); + TEST_INSTRUCTION("C20100" , ret(1)); + TEST_INSTRUCTION("CB" , retf()); + TEST_INSTRUCTION("CA0100" , retf(1)); + TEST_INSTRUCTION("D2C1" , rol(cl, cl)); + TEST_INSTRUCTION("D0C1" , rol(cl, 1)); + TEST_INSTRUCTION("D2C5" , rol(ch, cl)); + TEST_INSTRUCTION("D0C5" , rol(ch, 1)); + TEST_INSTRUCTION("66D3C1" , rol(cx, cl)); + TEST_INSTRUCTION("66D1C1" , rol(cx, 1)); + TEST_INSTRUCTION("D3C1" , rol(ecx, cl)); + TEST_INSTRUCTION("D1C1" , rol(ecx, 1)); + TEST_INSTRUCTION("D2841180000000" , rol(byte_ptr(ecx, edx, 0, 128), cl)); + TEST_INSTRUCTION("D0841180000000" , rol(byte_ptr(ecx, edx, 0, 128), 1)); + TEST_INSTRUCTION("66D3841180000000" , rol(word_ptr(ecx, edx, 0, 128), cl)); + TEST_INSTRUCTION("66D1841180000000" , rol(word_ptr(ecx, edx, 0, 128), 1)); + TEST_INSTRUCTION("D3841180000000" , rol(dword_ptr(ecx, edx, 0, 128), cl)); + TEST_INSTRUCTION("D1841180000000" , rol(dword_ptr(ecx, edx, 0, 128), 1)); + TEST_INSTRUCTION("D2C9" , ror(cl, cl)); + TEST_INSTRUCTION("D0C9" , ror(cl, 1)); + TEST_INSTRUCTION("D2CD" , ror(ch, cl)); + TEST_INSTRUCTION("D0CD" , ror(ch, 1)); + TEST_INSTRUCTION("66D3C9" , ror(cx, cl)); + TEST_INSTRUCTION("66D1C9" , ror(cx, 1)); + TEST_INSTRUCTION("D3C9" , ror(ecx, cl)); + TEST_INSTRUCTION("D1C9" , ror(ecx, 1)); + TEST_INSTRUCTION("D28C1180000000" , ror(byte_ptr(ecx, edx, 0, 128), cl)); + TEST_INSTRUCTION("D08C1180000000" , ror(byte_ptr(ecx, edx, 0, 128), 1)); + TEST_INSTRUCTION("66D38C1180000000" , ror(word_ptr(ecx, edx, 0, 128), cl)); + TEST_INSTRUCTION("66D18C1180000000" , ror(word_ptr(ecx, edx, 0, 128), 1)); + TEST_INSTRUCTION("D38C1180000000" , ror(dword_ptr(ecx, edx, 0, 128), cl)); + TEST_INSTRUCTION("D18C1180000000" , ror(dword_ptr(ecx, edx, 0, 128), 1)); + TEST_INSTRUCTION("C4E37BF0CA01" , rorx(ecx, edx, 1)); + TEST_INSTRUCTION("C4E37BF08C1A8000000001" , rorx(ecx, ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("C4E37BF08C1A8000000001" , rorx(ecx, dword_ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("0FAA" , rsm()); + TEST_INSTRUCTION("F30F01AC1180000000" , rstorssp(ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("F30F01AC1180000000" , rstorssp(qword_ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("9E" , sahf(ah)); + TEST_INSTRUCTION("D2E1" , sal(cl, cl)); + TEST_INSTRUCTION("D0E1" , sal(cl, 1)); + TEST_INSTRUCTION("D2E5" , sal(ch, cl)); + TEST_INSTRUCTION("D0E5" , sal(ch, 1)); + TEST_INSTRUCTION("66D3E1" , sal(cx, cl)); + TEST_INSTRUCTION("66D1E1" , sal(cx, 1)); + TEST_INSTRUCTION("D3E1" , sal(ecx, cl)); + TEST_INSTRUCTION("D1E1" , sal(ecx, 1)); + TEST_INSTRUCTION("D2A41180000000" , sal(byte_ptr(ecx, edx, 0, 128), cl)); + TEST_INSTRUCTION("D0A41180000000" , sal(byte_ptr(ecx, edx, 0, 128), 1)); + TEST_INSTRUCTION("66D3A41180000000" , sal(word_ptr(ecx, edx, 0, 128), cl)); + TEST_INSTRUCTION("66D1A41180000000" , sal(word_ptr(ecx, edx, 0, 128), 1)); + TEST_INSTRUCTION("D3A41180000000" , sal(dword_ptr(ecx, edx, 0, 128), cl)); + TEST_INSTRUCTION("D1A41180000000" , sal(dword_ptr(ecx, edx, 0, 128), 1)); + TEST_INSTRUCTION("D2F9" , sar(cl, cl)); + TEST_INSTRUCTION("D0F9" , sar(cl, 1)); + TEST_INSTRUCTION("D2FD" , sar(ch, cl)); + TEST_INSTRUCTION("D0FD" , sar(ch, 1)); + TEST_INSTRUCTION("66D3F9" , sar(cx, cl)); + TEST_INSTRUCTION("66D1F9" , sar(cx, 1)); + TEST_INSTRUCTION("D3F9" , sar(ecx, cl)); + TEST_INSTRUCTION("D1F9" , sar(ecx, 1)); + TEST_INSTRUCTION("D2BC1180000000" , sar(byte_ptr(ecx, edx, 0, 128), cl)); + TEST_INSTRUCTION("D0BC1180000000" , sar(byte_ptr(ecx, edx, 0, 128), 1)); + TEST_INSTRUCTION("66D3BC1180000000" , sar(word_ptr(ecx, edx, 0, 128), cl)); + TEST_INSTRUCTION("66D1BC1180000000" , sar(word_ptr(ecx, edx, 0, 128), 1)); + TEST_INSTRUCTION("D3BC1180000000" , sar(dword_ptr(ecx, edx, 0, 128), cl)); + TEST_INSTRUCTION("D1BC1180000000" , sar(dword_ptr(ecx, edx, 0, 128), 1)); + TEST_INSTRUCTION("C4E262F7CA" , sarx(ecx, edx, ebx)); + TEST_INSTRUCTION("C4E25AF78C1A80000000" , sarx(ecx, ptr(edx, ebx, 0, 128), esp)); + TEST_INSTRUCTION("C4E25AF78C1A80000000" , sarx(ecx, dword_ptr(edx, ebx, 0, 128), esp)); + TEST_INSTRUCTION("F30F01EA" , saveprevssp()); + TEST_INSTRUCTION("80D901" , sbb(cl, 1)); + TEST_INSTRUCTION("80DD01" , sbb(ch, 1)); + TEST_INSTRUCTION("809C118000000001" , sbb(byte_ptr(ecx, edx, 0, 128), 1)); + TEST_INSTRUCTION("6683D901" , sbb(cx, 1)); + TEST_INSTRUCTION("66839C118000000001" , sbb(word_ptr(ecx, edx, 0, 128), 1)); + TEST_INSTRUCTION("83D901" , sbb(ecx, 1)); + TEST_INSTRUCTION("839C118000000001" , sbb(dword_ptr(ecx, edx, 0, 128), 1)); + TEST_INSTRUCTION("18D1" , sbb(cl, dl)); + TEST_INSTRUCTION("18F1" , sbb(cl, dh)); + TEST_INSTRUCTION("18D5" , sbb(ch, dl)); + TEST_INSTRUCTION("18F5" , sbb(ch, dh)); + TEST_INSTRUCTION("189C1180000000" , sbb(ptr(ecx, edx, 0, 128), bl)); + TEST_INSTRUCTION("18BC1180000000" , sbb(ptr(ecx, edx, 0, 128), bh)); + TEST_INSTRUCTION("189C1180000000" , sbb(byte_ptr(ecx, edx, 0, 128), bl)); + TEST_INSTRUCTION("18BC1180000000" , sbb(byte_ptr(ecx, edx, 0, 128), bh)); + TEST_INSTRUCTION("6619D1" , sbb(cx, dx)); + TEST_INSTRUCTION("66199C1180000000" , sbb(ptr(ecx, edx, 0, 128), bx)); + TEST_INSTRUCTION("66199C1180000000" , sbb(word_ptr(ecx, edx, 0, 128), bx)); + TEST_INSTRUCTION("19D1" , sbb(ecx, edx)); + TEST_INSTRUCTION("199C1180000000" , sbb(ptr(ecx, edx, 0, 128), ebx)); + TEST_INSTRUCTION("199C1180000000" , sbb(dword_ptr(ecx, edx, 0, 128), ebx)); + TEST_INSTRUCTION("1A8C1A80000000" , sbb(cl, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("1A8C1A80000000" , sbb(cl, byte_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("1AAC1A80000000" , sbb(ch, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("1AAC1A80000000" , sbb(ch, byte_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("661B8C1A80000000" , sbb(cx, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("661B8C1A80000000" , sbb(cx, word_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("1B8C1A80000000" , sbb(ecx, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("1B8C1A80000000" , sbb(ecx, dword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("AE" , scas(al, ptr(edi))); + TEST_INSTRUCTION("AE" , scas(al, byte_ptr(edi))); + TEST_INSTRUCTION("66AF" , scas(ax, ptr(edi))); + TEST_INSTRUCTION("66AF" , scas(ax, word_ptr(edi))); + TEST_INSTRUCTION("AF" , scas(eax, ptr(edi))); + TEST_INSTRUCTION("AF" , scas(eax, dword_ptr(edi))); + TEST_INSTRUCTION("0F01E8" , serialize()); + TEST_INSTRUCTION("0F97C1" , seta(cl)); + TEST_INSTRUCTION("0F97C5" , seta(ch)); + TEST_INSTRUCTION("0F97841180000000" , seta(ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("0F97841180000000" , seta(byte_ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("0F93C1" , setae(cl)); + TEST_INSTRUCTION("0F93C5" , setae(ch)); + TEST_INSTRUCTION("0F93841180000000" , setae(ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("0F93841180000000" , setae(byte_ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("0F92C1" , setb(cl)); + TEST_INSTRUCTION("0F92C5" , setb(ch)); + TEST_INSTRUCTION("0F92841180000000" , setb(ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("0F92841180000000" , setb(byte_ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("0F96C1" , setbe(cl)); + TEST_INSTRUCTION("0F96C5" , setbe(ch)); + TEST_INSTRUCTION("0F96841180000000" , setbe(ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("0F96841180000000" , setbe(byte_ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("0F92C1" , setc(cl)); + TEST_INSTRUCTION("0F92C5" , setc(ch)); + TEST_INSTRUCTION("0F92841180000000" , setc(ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("0F92841180000000" , setc(byte_ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("0F94C1" , sete(cl)); + TEST_INSTRUCTION("0F94C5" , sete(ch)); + TEST_INSTRUCTION("0F94841180000000" , sete(ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("0F94841180000000" , sete(byte_ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("0F9FC1" , setg(cl)); + TEST_INSTRUCTION("0F9FC5" , setg(ch)); + TEST_INSTRUCTION("0F9F841180000000" , setg(ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("0F9F841180000000" , setg(byte_ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("0F9DC1" , setge(cl)); + TEST_INSTRUCTION("0F9DC5" , setge(ch)); + TEST_INSTRUCTION("0F9D841180000000" , setge(ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("0F9D841180000000" , setge(byte_ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("0F9CC1" , setl(cl)); + TEST_INSTRUCTION("0F9CC5" , setl(ch)); + TEST_INSTRUCTION("0F9C841180000000" , setl(ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("0F9C841180000000" , setl(byte_ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("0F9EC1" , setle(cl)); + TEST_INSTRUCTION("0F9EC5" , setle(ch)); + TEST_INSTRUCTION("0F9E841180000000" , setle(ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("0F9E841180000000" , setle(byte_ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("0F96C1" , setna(cl)); + TEST_INSTRUCTION("0F96C5" , setna(ch)); + TEST_INSTRUCTION("0F96841180000000" , setna(ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("0F96841180000000" , setna(byte_ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("0F92C1" , setnae(cl)); + TEST_INSTRUCTION("0F92C5" , setnae(ch)); + TEST_INSTRUCTION("0F92841180000000" , setnae(ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("0F92841180000000" , setnae(byte_ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("0F93C1" , setnb(cl)); + TEST_INSTRUCTION("0F93C5" , setnb(ch)); + TEST_INSTRUCTION("0F93841180000000" , setnb(ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("0F93841180000000" , setnb(byte_ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("0F97C1" , setnbe(cl)); + TEST_INSTRUCTION("0F97C5" , setnbe(ch)); + TEST_INSTRUCTION("0F97841180000000" , setnbe(ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("0F97841180000000" , setnbe(byte_ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("0F93C1" , setnc(cl)); + TEST_INSTRUCTION("0F93C5" , setnc(ch)); + TEST_INSTRUCTION("0F93841180000000" , setnc(ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("0F93841180000000" , setnc(byte_ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("0F95C1" , setne(cl)); + TEST_INSTRUCTION("0F95C5" , setne(ch)); + TEST_INSTRUCTION("0F95841180000000" , setne(ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("0F95841180000000" , setne(byte_ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("0F9EC1" , setng(cl)); + TEST_INSTRUCTION("0F9EC5" , setng(ch)); + TEST_INSTRUCTION("0F9E841180000000" , setng(ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("0F9E841180000000" , setng(byte_ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("0F9CC1" , setnge(cl)); + TEST_INSTRUCTION("0F9CC5" , setnge(ch)); + TEST_INSTRUCTION("0F9C841180000000" , setnge(ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("0F9C841180000000" , setnge(byte_ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("0F9DC1" , setnl(cl)); + TEST_INSTRUCTION("0F9DC5" , setnl(ch)); + TEST_INSTRUCTION("0F9D841180000000" , setnl(ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("0F9D841180000000" , setnl(byte_ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("0F9FC1" , setnle(cl)); + TEST_INSTRUCTION("0F9FC5" , setnle(ch)); + TEST_INSTRUCTION("0F9F841180000000" , setnle(ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("0F9F841180000000" , setnle(byte_ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("0F91C1" , setno(cl)); + TEST_INSTRUCTION("0F91C5" , setno(ch)); + TEST_INSTRUCTION("0F91841180000000" , setno(ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("0F91841180000000" , setno(byte_ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("0F9BC1" , setnp(cl)); + TEST_INSTRUCTION("0F9BC5" , setnp(ch)); + TEST_INSTRUCTION("0F9B841180000000" , setnp(ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("0F9B841180000000" , setnp(byte_ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("0F99C1" , setns(cl)); + TEST_INSTRUCTION("0F99C5" , setns(ch)); + TEST_INSTRUCTION("0F99841180000000" , setns(ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("0F99841180000000" , setns(byte_ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("0F95C1" , setnz(cl)); + TEST_INSTRUCTION("0F95C5" , setnz(ch)); + TEST_INSTRUCTION("0F95841180000000" , setnz(ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("0F95841180000000" , setnz(byte_ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("0F90C1" , seto(cl)); + TEST_INSTRUCTION("0F90C5" , seto(ch)); + TEST_INSTRUCTION("0F90841180000000" , seto(ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("0F90841180000000" , seto(byte_ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("0F9AC1" , setp(cl)); + TEST_INSTRUCTION("0F9AC5" , setp(ch)); + TEST_INSTRUCTION("0F9A841180000000" , setp(ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("0F9A841180000000" , setp(byte_ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("0F9AC1" , setpe(cl)); + TEST_INSTRUCTION("0F9AC5" , setpe(ch)); + TEST_INSTRUCTION("0F9A841180000000" , setpe(ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("0F9A841180000000" , setpe(byte_ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("0F9BC1" , setpo(cl)); + TEST_INSTRUCTION("0F9BC5" , setpo(ch)); + TEST_INSTRUCTION("0F9B841180000000" , setpo(ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("0F9B841180000000" , setpo(byte_ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("0F98C1" , sets(cl)); + TEST_INSTRUCTION("0F98C5" , sets(ch)); + TEST_INSTRUCTION("0F98841180000000" , sets(ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("0F98841180000000" , sets(byte_ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("F30F01E8" , setssbsy()); + TEST_INSTRUCTION("0F94C1" , setz(cl)); + TEST_INSTRUCTION("0F94C5" , setz(ch)); + TEST_INSTRUCTION("0F94841180000000" , setz(ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("0F94841180000000" , setz(byte_ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("0FAEF8" , sfence()); + TEST_INSTRUCTION("0F01841180000000" , sgdt(ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("D2E1" , shl(cl, cl)); + TEST_INSTRUCTION("D0E1" , shl(cl, 1)); + TEST_INSTRUCTION("D2E5" , shl(ch, cl)); + TEST_INSTRUCTION("D0E5" , shl(ch, 1)); + TEST_INSTRUCTION("66D3E1" , shl(cx, cl)); + TEST_INSTRUCTION("66D1E1" , shl(cx, 1)); + TEST_INSTRUCTION("D3E1" , shl(ecx, cl)); + TEST_INSTRUCTION("D1E1" , shl(ecx, 1)); + TEST_INSTRUCTION("D2A41180000000" , shl(byte_ptr(ecx, edx, 0, 128), cl)); + TEST_INSTRUCTION("D0A41180000000" , shl(byte_ptr(ecx, edx, 0, 128), 1)); + TEST_INSTRUCTION("66D3A41180000000" , shl(word_ptr(ecx, edx, 0, 128), cl)); + TEST_INSTRUCTION("66D1A41180000000" , shl(word_ptr(ecx, edx, 0, 128), 1)); + TEST_INSTRUCTION("D3A41180000000" , shl(dword_ptr(ecx, edx, 0, 128), cl)); + TEST_INSTRUCTION("D1A41180000000" , shl(dword_ptr(ecx, edx, 0, 128), 1)); + TEST_INSTRUCTION("660FA5D1" , shld(cx, dx, cl)); + TEST_INSTRUCTION("660FA4D101" , shld(cx, dx, 1)); + TEST_INSTRUCTION("660FA59C1180000000" , shld(ptr(ecx, edx, 0, 128), bx, cl)); + TEST_INSTRUCTION("660FA49C118000000001" , shld(ptr(ecx, edx, 0, 128), bx, 1)); + TEST_INSTRUCTION("660FA59C1180000000" , shld(word_ptr(ecx, edx, 0, 128), bx, cl)); + TEST_INSTRUCTION("660FA49C118000000001" , shld(word_ptr(ecx, edx, 0, 128), bx, 1)); + TEST_INSTRUCTION("0FA5D1" , shld(ecx, edx, cl)); + TEST_INSTRUCTION("0FA4D101" , shld(ecx, edx, 1)); + TEST_INSTRUCTION("0FA59C1180000000" , shld(ptr(ecx, edx, 0, 128), ebx, cl)); + TEST_INSTRUCTION("0FA49C118000000001" , shld(ptr(ecx, edx, 0, 128), ebx, 1)); + TEST_INSTRUCTION("0FA59C1180000000" , shld(dword_ptr(ecx, edx, 0, 128), ebx, cl)); + TEST_INSTRUCTION("0FA49C118000000001" , shld(dword_ptr(ecx, edx, 0, 128), ebx, 1)); + TEST_INSTRUCTION("C4E261F7CA" , shlx(ecx, edx, ebx)); + TEST_INSTRUCTION("C4E259F78C1A80000000" , shlx(ecx, ptr(edx, ebx, 0, 128), esp)); + TEST_INSTRUCTION("C4E259F78C1A80000000" , shlx(ecx, dword_ptr(edx, ebx, 0, 128), esp)); + TEST_INSTRUCTION("D2E9" , shr(cl, cl)); + TEST_INSTRUCTION("D0E9" , shr(cl, 1)); + TEST_INSTRUCTION("D2ED" , shr(ch, cl)); + TEST_INSTRUCTION("D0ED" , shr(ch, 1)); + TEST_INSTRUCTION("66D3E9" , shr(cx, cl)); + TEST_INSTRUCTION("66D1E9" , shr(cx, 1)); + TEST_INSTRUCTION("D3E9" , shr(ecx, cl)); + TEST_INSTRUCTION("D1E9" , shr(ecx, 1)); + TEST_INSTRUCTION("D2AC1180000000" , shr(byte_ptr(ecx, edx, 0, 128), cl)); + TEST_INSTRUCTION("D0AC1180000000" , shr(byte_ptr(ecx, edx, 0, 128), 1)); + TEST_INSTRUCTION("66D3AC1180000000" , shr(word_ptr(ecx, edx, 0, 128), cl)); + TEST_INSTRUCTION("66D1AC1180000000" , shr(word_ptr(ecx, edx, 0, 128), 1)); + TEST_INSTRUCTION("D3AC1180000000" , shr(dword_ptr(ecx, edx, 0, 128), cl)); + TEST_INSTRUCTION("D1AC1180000000" , shr(dword_ptr(ecx, edx, 0, 128), 1)); + TEST_INSTRUCTION("660FADD1" , shrd(cx, dx, cl)); + TEST_INSTRUCTION("660FACD101" , shrd(cx, dx, 1)); + TEST_INSTRUCTION("660FAD9C1180000000" , shrd(ptr(ecx, edx, 0, 128), bx, cl)); + TEST_INSTRUCTION("660FAC9C118000000001" , shrd(ptr(ecx, edx, 0, 128), bx, 1)); + TEST_INSTRUCTION("660FAD9C1180000000" , shrd(word_ptr(ecx, edx, 0, 128), bx, cl)); + TEST_INSTRUCTION("660FAC9C118000000001" , shrd(word_ptr(ecx, edx, 0, 128), bx, 1)); + TEST_INSTRUCTION("0FADD1" , shrd(ecx, edx, cl)); + TEST_INSTRUCTION("0FACD101" , shrd(ecx, edx, 1)); + TEST_INSTRUCTION("0FAD9C1180000000" , shrd(ptr(ecx, edx, 0, 128), ebx, cl)); + TEST_INSTRUCTION("0FAC9C118000000001" , shrd(ptr(ecx, edx, 0, 128), ebx, 1)); + TEST_INSTRUCTION("0FAD9C1180000000" , shrd(dword_ptr(ecx, edx, 0, 128), ebx, cl)); + TEST_INSTRUCTION("0FAC9C118000000001" , shrd(dword_ptr(ecx, edx, 0, 128), ebx, 1)); + TEST_INSTRUCTION("C4E263F7CA" , shrx(ecx, edx, ebx)); + TEST_INSTRUCTION("C4E25BF78C1A80000000" , shrx(ecx, ptr(edx, ebx, 0, 128), esp)); + TEST_INSTRUCTION("C4E25BF78C1A80000000" , shrx(ecx, dword_ptr(edx, ebx, 0, 128), esp)); + TEST_INSTRUCTION("0F018C1180000000" , sidt(ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("0F01DE" , skinit(eax)); + TEST_INSTRUCTION("660F00C1" , sldt(cx)); + TEST_INSTRUCTION("0F00C1" , sldt(ecx)); + TEST_INSTRUCTION("0F00841180000000" , sldt(ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("0F00841180000000" , sldt(word_ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("8FE97812C9" , slwpcb(ecx)); + TEST_INSTRUCTION("660F01E1" , smsw(cx)); + TEST_INSTRUCTION("0F01E1" , smsw(ecx)); + TEST_INSTRUCTION("0F01A41180000000" , smsw(ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("0F01A41180000000" , smsw(word_ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("0F01CB" , stac()); + TEST_INSTRUCTION("F9" , stc()); + TEST_INSTRUCTION("FD" , std()); + TEST_INSTRUCTION("0F01DC" , stgi()); + TEST_INSTRUCTION("FB" , sti()); + TEST_INSTRUCTION("0FAE9C1180000000" , stmxcsr(ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("0FAE9C1180000000" , stmxcsr(dword_ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("AA" , stos(ptr(edi), al)); + TEST_INSTRUCTION("AA" , stos(byte_ptr(edi), al)); + TEST_INSTRUCTION("66AB" , stos(ptr(edi), ax)); + TEST_INSTRUCTION("66AB" , stos(word_ptr(edi), ax)); + TEST_INSTRUCTION("AB" , stos(ptr(edi), eax)); + TEST_INSTRUCTION("AB" , stos(dword_ptr(edi), eax)); + TEST_INSTRUCTION("660F00C9" , str(cx)); + TEST_INSTRUCTION("0F00C9" , str(ecx)); + TEST_INSTRUCTION("0F008C1180000000" , str(ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("0F008C1180000000" , str(word_ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("80E901" , sub(cl, 1)); + TEST_INSTRUCTION("80ED01" , sub(ch, 1)); + TEST_INSTRUCTION("80AC118000000001" , sub(byte_ptr(ecx, edx, 0, 128), 1)); + TEST_INSTRUCTION("6683E901" , sub(cx, 1)); + TEST_INSTRUCTION("6683AC118000000001" , sub(word_ptr(ecx, edx, 0, 128), 1)); + TEST_INSTRUCTION("83E901" , sub(ecx, 1)); + TEST_INSTRUCTION("83AC118000000001" , sub(dword_ptr(ecx, edx, 0, 128), 1)); + TEST_INSTRUCTION("28D1" , sub(cl, dl)); + TEST_INSTRUCTION("28F1" , sub(cl, dh)); + TEST_INSTRUCTION("28D5" , sub(ch, dl)); + TEST_INSTRUCTION("28F5" , sub(ch, dh)); + TEST_INSTRUCTION("289C1180000000" , sub(ptr(ecx, edx, 0, 128), bl)); + TEST_INSTRUCTION("28BC1180000000" , sub(ptr(ecx, edx, 0, 128), bh)); + TEST_INSTRUCTION("289C1180000000" , sub(byte_ptr(ecx, edx, 0, 128), bl)); + TEST_INSTRUCTION("28BC1180000000" , sub(byte_ptr(ecx, edx, 0, 128), bh)); + TEST_INSTRUCTION("6629D1" , sub(cx, dx)); + TEST_INSTRUCTION("66299C1180000000" , sub(ptr(ecx, edx, 0, 128), bx)); + TEST_INSTRUCTION("66299C1180000000" , sub(word_ptr(ecx, edx, 0, 128), bx)); + TEST_INSTRUCTION("29D1" , sub(ecx, edx)); + TEST_INSTRUCTION("299C1180000000" , sub(ptr(ecx, edx, 0, 128), ebx)); + TEST_INSTRUCTION("299C1180000000" , sub(dword_ptr(ecx, edx, 0, 128), ebx)); + TEST_INSTRUCTION("2A8C1A80000000" , sub(cl, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("2A8C1A80000000" , sub(cl, byte_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("2AAC1A80000000" , sub(ch, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("2AAC1A80000000" , sub(ch, byte_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("662B8C1A80000000" , sub(cx, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("662B8C1A80000000" , sub(cx, word_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("2B8C1A80000000" , sub(ecx, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("2B8C1A80000000" , sub(ecx, dword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F34" , sysenter()); + TEST_INSTRUCTION("0F35" , sysexit()); + TEST_INSTRUCTION("8FE97001FA" , t1mskc(ecx, edx)); + TEST_INSTRUCTION("8FE97001BC1A80000000" , t1mskc(ecx, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("8FE97001BC1A80000000" , t1mskc(ecx, dword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("F6C101" , test(cl, 1)); + TEST_INSTRUCTION("F6C501" , test(ch, 1)); + TEST_INSTRUCTION("F684118000000001" , test(byte_ptr(ecx, edx, 0, 128), 1)); + TEST_INSTRUCTION("66F7C10100" , test(cx, 1)); + TEST_INSTRUCTION("66F78411800000000100" , test(word_ptr(ecx, edx, 0, 128), 1)); + TEST_INSTRUCTION("F7C101000000" , test(ecx, 1)); + TEST_INSTRUCTION("F784118000000001000000" , test(dword_ptr(ecx, edx, 0, 128), 1)); + TEST_INSTRUCTION("84D1" , test(cl, dl)); + TEST_INSTRUCTION("84F1" , test(cl, dh)); + TEST_INSTRUCTION("84D5" , test(ch, dl)); + TEST_INSTRUCTION("84F5" , test(ch, dh)); + TEST_INSTRUCTION("849C1180000000" , test(ptr(ecx, edx, 0, 128), bl)); + TEST_INSTRUCTION("84BC1180000000" , test(ptr(ecx, edx, 0, 128), bh)); + TEST_INSTRUCTION("849C1180000000" , test(byte_ptr(ecx, edx, 0, 128), bl)); + TEST_INSTRUCTION("84BC1180000000" , test(byte_ptr(ecx, edx, 0, 128), bh)); + TEST_INSTRUCTION("6685D1" , test(cx, dx)); + TEST_INSTRUCTION("66859C1180000000" , test(ptr(ecx, edx, 0, 128), bx)); + TEST_INSTRUCTION("66859C1180000000" , test(word_ptr(ecx, edx, 0, 128), bx)); + TEST_INSTRUCTION("85D1" , test(ecx, edx)); + TEST_INSTRUCTION("859C1180000000" , test(ptr(ecx, edx, 0, 128), ebx)); + TEST_INSTRUCTION("859C1180000000" , test(dword_ptr(ecx, edx, 0, 128), ebx)); + TEST_INSTRUCTION("660FAEF1" , tpause(ecx, edx, eax)); + TEST_INSTRUCTION("66F30FBCCA" , tzcnt(cx, dx)); + TEST_INSTRUCTION("66F30FBC8C1A80000000" , tzcnt(cx, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("66F30FBC8C1A80000000" , tzcnt(cx, word_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("F30FBCCA" , tzcnt(ecx, edx)); + TEST_INSTRUCTION("F30FBC8C1A80000000" , tzcnt(ecx, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("F30FBC8C1A80000000" , tzcnt(ecx, dword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("8FE97001E2" , tzmsk(ecx, edx)); + TEST_INSTRUCTION("8FE97001A41A80000000" , tzmsk(ecx, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("8FE97001A41A80000000" , tzmsk(ecx, dword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0FFFCA" , ud0(ecx, edx)); + TEST_INSTRUCTION("0FFF8C1A80000000" , ud0(ecx, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0FFF8C1A80000000" , ud0(ecx, dword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0FB9CA" , ud1(ecx, edx)); + TEST_INSTRUCTION("0FB98C1A80000000" , ud1(ecx, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0FB98C1A80000000" , ud1(ecx, dword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F0B" , ud2()); + TEST_INSTRUCTION("F30FAEF1" , umonitor(ptr(ecx))); + TEST_INSTRUCTION("F20FAEF1" , umwait(ecx, edx, eax)); + TEST_INSTRUCTION("0F00E1" , verr(cx)); + TEST_INSTRUCTION("0F00A41180000000" , verr(ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("0F00A41180000000" , verr(word_ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("0F00E9" , verw(cx)); + TEST_INSTRUCTION("0F00AC1180000000" , verw(ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("0F00AC1180000000" , verw(word_ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("0F01C1" , vmcall()); + TEST_INSTRUCTION("660FC7B41180000000" , vmclear(ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("660FC7B41180000000" , vmclear(qword_ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("0F01D4" , vmfunc()); + TEST_INSTRUCTION("0F01C2" , vmlaunch()); + TEST_INSTRUCTION("0F01DA" , vmload(eax)); + TEST_INSTRUCTION("0F01D9" , vmmcall()); + TEST_INSTRUCTION("0FC7B41180000000" , vmptrld(ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("0FC7B41180000000" , vmptrld(qword_ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("0FC7BC1180000000" , vmptrst(ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("0FC7BC1180000000" , vmptrst(qword_ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("0F78D1" , vmread(ecx, edx)); + TEST_INSTRUCTION("0F789C1180000000" , vmread(ptr(ecx, edx, 0, 128), ebx)); + TEST_INSTRUCTION("0F789C1180000000" , vmread(dword_ptr(ecx, edx, 0, 128), ebx)); + TEST_INSTRUCTION("0F01C3" , vmresume()); + TEST_INSTRUCTION("0F01D8" , vmrun(eax)); + TEST_INSTRUCTION("0F01DB" , vmsave(eax)); + TEST_INSTRUCTION("0F79CA" , vmwrite(ecx, edx)); + TEST_INSTRUCTION("0F798C1A80000000" , vmwrite(ecx, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F798C1A80000000" , vmwrite(ecx, dword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("F30FC7B41180000000" , vmxon(ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("F30FC7B41180000000" , vmxon(qword_ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("0F09" , wbinvd()); + TEST_INSTRUCTION("F30F09" , wbnoinvd()); + TEST_INSTRUCTION("0F30" , wrmsr(edx, eax, ecx)); + TEST_INSTRUCTION("0F38F6D1" , wrssd(ecx, edx)); + TEST_INSTRUCTION("0F38F69C1180000000" , wrssd(ptr(ecx, edx, 0, 128), ebx)); + TEST_INSTRUCTION("0F38F69C1180000000" , wrssd(dword_ptr(ecx, edx, 0, 128), ebx)); + TEST_INSTRUCTION("660F38F5D1" , wrussd(ecx, edx)); + TEST_INSTRUCTION("660F38F59C1180000000" , wrussd(ptr(ecx, edx, 0, 128), ebx)); + TEST_INSTRUCTION("660F38F59C1180000000" , wrussd(dword_ptr(ecx, edx, 0, 128), ebx)); + TEST_INSTRUCTION("C6F801" , xabort(1)); + TEST_INSTRUCTION("0FC0D1" , xadd(cl, dl)); + TEST_INSTRUCTION("0FC0F1" , xadd(cl, dh)); + TEST_INSTRUCTION("0FC0D5" , xadd(ch, dl)); + TEST_INSTRUCTION("0FC0F5" , xadd(ch, dh)); + TEST_INSTRUCTION("0FC09C1180000000" , xadd(ptr(ecx, edx, 0, 128), bl)); + TEST_INSTRUCTION("0FC0BC1180000000" , xadd(ptr(ecx, edx, 0, 128), bh)); + TEST_INSTRUCTION("0FC09C1180000000" , xadd(byte_ptr(ecx, edx, 0, 128), bl)); + TEST_INSTRUCTION("0FC0BC1180000000" , xadd(byte_ptr(ecx, edx, 0, 128), bh)); + TEST_INSTRUCTION("660FC1D1" , xadd(cx, dx)); + TEST_INSTRUCTION("660FC19C1180000000" , xadd(ptr(ecx, edx, 0, 128), bx)); + TEST_INSTRUCTION("660FC19C1180000000" , xadd(word_ptr(ecx, edx, 0, 128), bx)); + TEST_INSTRUCTION("0FC1D1" , xadd(ecx, edx)); + TEST_INSTRUCTION("0FC19C1180000000" , xadd(ptr(ecx, edx, 0, 128), ebx)); + TEST_INSTRUCTION("0FC19C1180000000" , xadd(dword_ptr(ecx, edx, 0, 128), ebx)); + TEST_INSTRUCTION("86D1" , xchg(cl, dl)); + TEST_INSTRUCTION("86F1" , xchg(cl, dh)); + TEST_INSTRUCTION("86D5" , xchg(ch, dl)); + TEST_INSTRUCTION("86F5" , xchg(ch, dh)); + TEST_INSTRUCTION("869C1180000000" , xchg(ptr(ecx, edx, 0, 128), bl)); + TEST_INSTRUCTION("86BC1180000000" , xchg(ptr(ecx, edx, 0, 128), bh)); + TEST_INSTRUCTION("869C1180000000" , xchg(byte_ptr(ecx, edx, 0, 128), bl)); + TEST_INSTRUCTION("86BC1180000000" , xchg(byte_ptr(ecx, edx, 0, 128), bh)); + TEST_INSTRUCTION("6687D1" , xchg(cx, dx)); + TEST_INSTRUCTION("66879C1180000000" , xchg(ptr(ecx, edx, 0, 128), bx)); + TEST_INSTRUCTION("66879C1180000000" , xchg(word_ptr(ecx, edx, 0, 128), bx)); + TEST_INSTRUCTION("87D1" , xchg(ecx, edx)); + TEST_INSTRUCTION("879C1180000000" , xchg(ptr(ecx, edx, 0, 128), ebx)); + TEST_INSTRUCTION("879C1180000000" , xchg(dword_ptr(ecx, edx, 0, 128), ebx)); + TEST_INSTRUCTION("868C1A80000000" , xchg(cl, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("868C1A80000000" , xchg(cl, byte_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("86AC1A80000000" , xchg(ch, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("86AC1A80000000" , xchg(ch, byte_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("66878C1A80000000" , xchg(cx, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("66878C1A80000000" , xchg(cx, word_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("878C1A80000000" , xchg(ecx, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("878C1A80000000" , xchg(ecx, dword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F01D5" , xend()); + TEST_INSTRUCTION("0F01D0" , xgetbv(edx, eax, ecx)); + TEST_INSTRUCTION("D7" , xlatb()); + TEST_INSTRUCTION("80F101" , xor_(cl, 1)); + TEST_INSTRUCTION("80F501" , xor_(ch, 1)); + TEST_INSTRUCTION("80B4118000000001" , xor_(byte_ptr(ecx, edx, 0, 128), 1)); + TEST_INSTRUCTION("6683F101" , xor_(cx, 1)); + TEST_INSTRUCTION("6683B4118000000001" , xor_(word_ptr(ecx, edx, 0, 128), 1)); + TEST_INSTRUCTION("83F101" , xor_(ecx, 1)); + TEST_INSTRUCTION("83B4118000000001" , xor_(dword_ptr(ecx, edx, 0, 128), 1)); + TEST_INSTRUCTION("30D1" , xor_(cl, dl)); + TEST_INSTRUCTION("30F1" , xor_(cl, dh)); + TEST_INSTRUCTION("30D5" , xor_(ch, dl)); + TEST_INSTRUCTION("30F5" , xor_(ch, dh)); + TEST_INSTRUCTION("309C1180000000" , xor_(ptr(ecx, edx, 0, 128), bl)); + TEST_INSTRUCTION("30BC1180000000" , xor_(ptr(ecx, edx, 0, 128), bh)); + TEST_INSTRUCTION("309C1180000000" , xor_(byte_ptr(ecx, edx, 0, 128), bl)); + TEST_INSTRUCTION("30BC1180000000" , xor_(byte_ptr(ecx, edx, 0, 128), bh)); + TEST_INSTRUCTION("6631D1" , xor_(cx, dx)); + TEST_INSTRUCTION("66319C1180000000" , xor_(ptr(ecx, edx, 0, 128), bx)); + TEST_INSTRUCTION("66319C1180000000" , xor_(word_ptr(ecx, edx, 0, 128), bx)); + TEST_INSTRUCTION("31D1" , xor_(ecx, edx)); + TEST_INSTRUCTION("319C1180000000" , xor_(ptr(ecx, edx, 0, 128), ebx)); + TEST_INSTRUCTION("319C1180000000" , xor_(dword_ptr(ecx, edx, 0, 128), ebx)); + TEST_INSTRUCTION("328C1A80000000" , xor_(cl, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("328C1A80000000" , xor_(cl, byte_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("32AC1A80000000" , xor_(ch, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("32AC1A80000000" , xor_(ch, byte_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("66338C1A80000000" , xor_(cx, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("66338C1A80000000" , xor_(cx, word_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("338C1A80000000" , xor_(ecx, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("338C1A80000000" , xor_(ecx, dword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("F20F01E9" , xresldtrk()); + TEST_INSTRUCTION("0FAEAC1180000000" , xrstor(ptr(ecx, edx, 0, 128), edx, eax)); + TEST_INSTRUCTION("0FC79C1180000000" , xrstors(ptr(ecx, edx, 0, 128), edx, eax)); + TEST_INSTRUCTION("0FAEA41180000000" , xsave(ptr(ecx, edx, 0, 128), edx, eax)); + TEST_INSTRUCTION("0FC7A41180000000" , xsavec(ptr(ecx, edx, 0, 128), edx, eax)); + TEST_INSTRUCTION("0FAEB41180000000" , xsaveopt(ptr(ecx, edx, 0, 128), edx, eax)); + TEST_INSTRUCTION("0FC7AC1180000000" , xsaves(ptr(ecx, edx, 0, 128), edx, eax)); + TEST_INSTRUCTION("0F01D1" , xsetbv(edx, eax, ecx)); + TEST_INSTRUCTION("F20F01E8" , xsusldtrk()); + TEST_INSTRUCTION("0F01D6" , xtest()); +} + +static void ASMJIT_NOINLINE testX86AssemblerMMX_SSE(AssemblerTester<x86::Assembler>& tester) noexcept { + using namespace x86; + + TEST_INSTRUCTION("660F58CA" , addpd(xmm1, xmm2)); + TEST_INSTRUCTION("660F588C1A80000000" , addpd(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F588C1A80000000" , addpd(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F58CA" , addps(xmm1, xmm2)); + TEST_INSTRUCTION("0F588C1A80000000" , addps(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F588C1A80000000" , addps(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("F20F58CA" , addsd(xmm1, xmm2)); + TEST_INSTRUCTION("F20F588C1A80000000" , addsd(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("F20F588C1A80000000" , addsd(xmm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("F30F58CA" , addss(xmm1, xmm2)); + TEST_INSTRUCTION("F30F588C1A80000000" , addss(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("F30F588C1A80000000" , addss(xmm1, dword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660FD0CA" , addsubpd(xmm1, xmm2)); + TEST_INSTRUCTION("660FD08C1A80000000" , addsubpd(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660FD08C1A80000000" , addsubpd(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("F20FD0CA" , addsubps(xmm1, xmm2)); + TEST_INSTRUCTION("F20FD08C1A80000000" , addsubps(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("F20FD08C1A80000000" , addsubps(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("F30F38F6CA" , adox(ecx, edx)); + TEST_INSTRUCTION("F30F38F68C1A80000000" , adox(ecx, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("F30F38F68C1A80000000" , adox(ecx, dword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F38DECA" , aesdec(xmm1, xmm2)); + TEST_INSTRUCTION("660F38DE8C1A80000000" , aesdec(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F38DE8C1A80000000" , aesdec(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F38DFCA" , aesdeclast(xmm1, xmm2)); + TEST_INSTRUCTION("660F38DF8C1A80000000" , aesdeclast(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F38DF8C1A80000000" , aesdeclast(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F38DCCA" , aesenc(xmm1, xmm2)); + TEST_INSTRUCTION("660F38DC8C1A80000000" , aesenc(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F38DC8C1A80000000" , aesenc(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F38DDCA" , aesenclast(xmm1, xmm2)); + TEST_INSTRUCTION("660F38DD8C1A80000000" , aesenclast(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F38DD8C1A80000000" , aesenclast(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F38DBCA" , aesimc(xmm1, xmm2)); + TEST_INSTRUCTION("660F38DB8C1A80000000" , aesimc(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F38DB8C1A80000000" , aesimc(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F3ADFCA01" , aeskeygenassist(xmm1, xmm2, 1)); + TEST_INSTRUCTION("660F3ADF8C1A8000000001" , aeskeygenassist(xmm1, ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("660F3ADF8C1A8000000001" , aeskeygenassist(xmm1, xmmword_ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("660F55CA" , andnpd(xmm1, xmm2)); + TEST_INSTRUCTION("660F558C1A80000000" , andnpd(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F558C1A80000000" , andnpd(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F55CA" , andnps(xmm1, xmm2)); + TEST_INSTRUCTION("0F558C1A80000000" , andnps(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F558C1A80000000" , andnps(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F54CA" , andpd(xmm1, xmm2)); + TEST_INSTRUCTION("660F548C1A80000000" , andpd(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F548C1A80000000" , andpd(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F54CA" , andps(xmm1, xmm2)); + TEST_INSTRUCTION("0F548C1A80000000" , andps(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F548C1A80000000" , andps(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F3A0DCA01" , blendpd(xmm1, xmm2, 1)); + TEST_INSTRUCTION("660F3A0D8C1A8000000001" , blendpd(xmm1, ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("660F3A0D8C1A8000000001" , blendpd(xmm1, xmmword_ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("660F3A0CCA01" , blendps(xmm1, xmm2, 1)); + TEST_INSTRUCTION("660F3A0C8C1A8000000001" , blendps(xmm1, ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("660F3A0C8C1A8000000001" , blendps(xmm1, xmmword_ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("660F3815CA" , blendvpd(xmm1, xmm2, xmm0)); + TEST_INSTRUCTION("660F38158C1A80000000" , blendvpd(xmm1, ptr(edx, ebx, 0, 128), xmm0)); + TEST_INSTRUCTION("660F38158C1A80000000" , blendvpd(xmm1, xmmword_ptr(edx, ebx, 0, 128), xmm0)); + TEST_INSTRUCTION("660F3814CA" , blendvps(xmm1, xmm2, xmm0)); + TEST_INSTRUCTION("660F38148C1A80000000" , blendvps(xmm1, ptr(edx, ebx, 0, 128), xmm0)); + TEST_INSTRUCTION("660F38148C1A80000000" , blendvps(xmm1, xmmword_ptr(edx, ebx, 0, 128), xmm0)); + TEST_INSTRUCTION("660FC2CA01" , cmppd(xmm1, xmm2, 1)); + TEST_INSTRUCTION("660FC28C1A8000000001" , cmppd(xmm1, ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("660FC28C1A8000000001" , cmppd(xmm1, xmmword_ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("0FC2CA01" , cmpps(xmm1, xmm2, 1)); + TEST_INSTRUCTION("0FC28C1A8000000001" , cmpps(xmm1, ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("0FC28C1A8000000001" , cmpps(xmm1, xmmword_ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("F20FC2CA01" , cmpsd(xmm1, xmm2, 1)); + TEST_INSTRUCTION("F20FC28C1A8000000001" , cmpsd(xmm1, ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("F20FC28C1A8000000001" , cmpsd(xmm1, qword_ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("F30FC2CA01" , cmpss(xmm1, xmm2, 1)); + TEST_INSTRUCTION("F30FC28C1A8000000001" , cmpss(xmm1, ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("F30FC28C1A8000000001" , cmpss(xmm1, dword_ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("660F2FCA" , comisd(xmm1, xmm2)); + TEST_INSTRUCTION("660F2F8C1A80000000" , comisd(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F2F8C1A80000000" , comisd(xmm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F2FCA" , comiss(xmm1, xmm2)); + TEST_INSTRUCTION("0F2F8C1A80000000" , comiss(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F2F8C1A80000000" , comiss(xmm1, dword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("F30FE6CA" , cvtdq2pd(xmm1, xmm2)); + TEST_INSTRUCTION("F30FE68C1A80000000" , cvtdq2pd(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("F30FE68C1A80000000" , cvtdq2pd(xmm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F5BCA" , cvtdq2ps(xmm1, xmm2)); + TEST_INSTRUCTION("0F5B8C1A80000000" , cvtdq2ps(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F5B8C1A80000000" , cvtdq2ps(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("F20FE6CA" , cvtpd2dq(xmm1, xmm2)); + TEST_INSTRUCTION("F20FE68C1A80000000" , cvtpd2dq(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("F20FE68C1A80000000" , cvtpd2dq(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F2DCA" , cvtpd2pi(mm1, xmm2)); + TEST_INSTRUCTION("660F2D8C1A80000000" , cvtpd2pi(mm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F2D8C1A80000000" , cvtpd2pi(mm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F5ACA" , cvtpd2ps(xmm1, xmm2)); + TEST_INSTRUCTION("660F5A8C1A80000000" , cvtpd2ps(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F5A8C1A80000000" , cvtpd2ps(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F2ACA" , cvtpi2pd(xmm1, mm2)); + TEST_INSTRUCTION("660F2A8C1A80000000" , cvtpi2pd(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F2A8C1A80000000" , cvtpi2pd(xmm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F2ACA" , cvtpi2ps(xmm1, mm2)); + TEST_INSTRUCTION("0F2A8C1A80000000" , cvtpi2ps(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F2A8C1A80000000" , cvtpi2ps(xmm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F5BCA" , cvtps2dq(xmm1, xmm2)); + TEST_INSTRUCTION("660F5B8C1A80000000" , cvtps2dq(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F5B8C1A80000000" , cvtps2dq(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F5ACA" , cvtps2pd(xmm1, xmm2)); + TEST_INSTRUCTION("0F5A8C1A80000000" , cvtps2pd(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F5A8C1A80000000" , cvtps2pd(xmm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F2DCA" , cvtps2pi(mm1, xmm2)); + TEST_INSTRUCTION("0F2D8C1A80000000" , cvtps2pi(mm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F2D8C1A80000000" , cvtps2pi(mm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("F20F2DCA" , cvtsd2si(ecx, xmm2)); + TEST_INSTRUCTION("F20F2D8C1A80000000" , cvtsd2si(ecx, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("F20F2D8C1A80000000" , cvtsd2si(ecx, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("F20F5ACA" , cvtsd2ss(xmm1, xmm2)); + TEST_INSTRUCTION("F20F5A8C1A80000000" , cvtsd2ss(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("F20F5A8C1A80000000" , cvtsd2ss(xmm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("F20F2ACA" , cvtsi2sd(xmm1, edx)); + TEST_INSTRUCTION("F20F2A8C1A80000000" , cvtsi2sd(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("F20F2A8C1A80000000" , cvtsi2sd(xmm1, dword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("F30F2ACA" , cvtsi2ss(xmm1, edx)); + TEST_INSTRUCTION("F30F2A8C1A80000000" , cvtsi2ss(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("F30F2A8C1A80000000" , cvtsi2ss(xmm1, dword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("F30F5ACA" , cvtss2sd(xmm1, xmm2)); + TEST_INSTRUCTION("F30F5A8C1A80000000" , cvtss2sd(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("F30F5A8C1A80000000" , cvtss2sd(xmm1, dword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("F30F2DCA" , cvtss2si(ecx, xmm2)); + TEST_INSTRUCTION("F30F2D8C1A80000000" , cvtss2si(ecx, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("F30F2D8C1A80000000" , cvtss2si(ecx, dword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660FE6CA" , cvttpd2dq(xmm1, xmm2)); + TEST_INSTRUCTION("660FE68C1A80000000" , cvttpd2dq(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660FE68C1A80000000" , cvttpd2dq(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F2CCA" , cvttpd2pi(mm1, xmm2)); + TEST_INSTRUCTION("660F2C8C1A80000000" , cvttpd2pi(mm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F2C8C1A80000000" , cvttpd2pi(mm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("F30F5BCA" , cvttps2dq(xmm1, xmm2)); + TEST_INSTRUCTION("F30F5B8C1A80000000" , cvttps2dq(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("F30F5B8C1A80000000" , cvttps2dq(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F2CCA" , cvttps2pi(mm1, xmm2)); + TEST_INSTRUCTION("0F2C8C1A80000000" , cvttps2pi(mm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F2C8C1A80000000" , cvttps2pi(mm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("F20F2CCA" , cvttsd2si(ecx, xmm2)); + TEST_INSTRUCTION("F20F2C8C1A80000000" , cvttsd2si(ecx, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("F20F2C8C1A80000000" , cvttsd2si(ecx, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("F30F2CCA" , cvttss2si(ecx, xmm2)); + TEST_INSTRUCTION("F30F2C8C1A80000000" , cvttss2si(ecx, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("F30F2C8C1A80000000" , cvttss2si(ecx, dword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F5ECA" , divpd(xmm1, xmm2)); + TEST_INSTRUCTION("660F5E8C1A80000000" , divpd(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F5E8C1A80000000" , divpd(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F5ECA" , divps(xmm1, xmm2)); + TEST_INSTRUCTION("0F5E8C1A80000000" , divps(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F5E8C1A80000000" , divps(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("F20F5ECA" , divsd(xmm1, xmm2)); + TEST_INSTRUCTION("F20F5E8C1A80000000" , divsd(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("F20F5E8C1A80000000" , divsd(xmm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("F30F5ECA" , divss(xmm1, xmm2)); + TEST_INSTRUCTION("F30F5E8C1A80000000" , divss(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("F30F5E8C1A80000000" , divss(xmm1, dword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F3A41CA01" , dppd(xmm1, xmm2, 1)); + TEST_INSTRUCTION("660F3A418C1A8000000001" , dppd(xmm1, ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("660F3A418C1A8000000001" , dppd(xmm1, xmmword_ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("660F3A40CA01" , dpps(xmm1, xmm2, 1)); + TEST_INSTRUCTION("660F3A408C1A8000000001" , dpps(xmm1, ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("660F3A408C1A8000000001" , dpps(xmm1, xmmword_ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("660F3A17D101" , extractps(ecx, xmm2, 1)); + TEST_INSTRUCTION("660F3A179C118000000001" , extractps(ptr(ecx, edx, 0, 128), xmm3, 1)); + TEST_INSTRUCTION("660F3A179C118000000001" , extractps(dword_ptr(ecx, edx, 0, 128), xmm3, 1)); + TEST_INSTRUCTION("660F78C10102" , extrq(xmm1, 1, 2)); + TEST_INSTRUCTION("660F79CA" , extrq(xmm1, xmm2)); + TEST_INSTRUCTION("660F3ACFCA01" , gf2p8affineinvqb(xmm1, xmm2, 1)); + TEST_INSTRUCTION("660F3ACF8C1A8000000001" , gf2p8affineinvqb(xmm1, ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("660F3ACF8C1A8000000001" , gf2p8affineinvqb(xmm1, xmmword_ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("660F3ACECA01" , gf2p8affineqb(xmm1, xmm2, 1)); + TEST_INSTRUCTION("660F3ACE8C1A8000000001" , gf2p8affineqb(xmm1, ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("660F3ACE8C1A8000000001" , gf2p8affineqb(xmm1, xmmword_ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("660F38CFCA" , gf2p8mulb(xmm1, xmm2)); + TEST_INSTRUCTION("660F38CF8C1A80000000" , gf2p8mulb(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F38CF8C1A80000000" , gf2p8mulb(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F7CCA" , haddpd(xmm1, xmm2)); + TEST_INSTRUCTION("660F7C8C1A80000000" , haddpd(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F7C8C1A80000000" , haddpd(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("F20F7CCA" , haddps(xmm1, xmm2)); + TEST_INSTRUCTION("F20F7C8C1A80000000" , haddps(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("F20F7C8C1A80000000" , haddps(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F7DCA" , hsubpd(xmm1, xmm2)); + TEST_INSTRUCTION("660F7D8C1A80000000" , hsubpd(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F7D8C1A80000000" , hsubpd(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("F20F7DCA" , hsubps(xmm1, xmm2)); + TEST_INSTRUCTION("F20F7D8C1A80000000" , hsubps(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("F20F7D8C1A80000000" , hsubps(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F3A21CA01" , insertps(xmm1, xmm2, 1)); + TEST_INSTRUCTION("660F3A218C1A8000000001" , insertps(xmm1, ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("660F3A218C1A8000000001" , insertps(xmm1, dword_ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("F20F79CA" , insertq(xmm1, xmm2)); + TEST_INSTRUCTION("F20F78CA0102" , insertq(xmm1, xmm2, 1, 2)); + TEST_INSTRUCTION("F20FF08C1A80000000" , lddqu(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("F20FF08C1A80000000" , lddqu(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660FF7CA" , maskmovdqu(xmm1, xmm2, ptr(edi))); + TEST_INSTRUCTION("660FF7CA" , maskmovdqu(xmm1, xmm2, xmmword_ptr(edi))); + TEST_INSTRUCTION("0FF7CA" , maskmovq(mm1, mm2, ptr(edi))); + TEST_INSTRUCTION("0FF7CA" , maskmovq(mm1, mm2, qword_ptr(edi))); + TEST_INSTRUCTION("660F5FCA" , maxpd(xmm1, xmm2)); + TEST_INSTRUCTION("660F5F8C1A80000000" , maxpd(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F5F8C1A80000000" , maxpd(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F5FCA" , maxps(xmm1, xmm2)); + TEST_INSTRUCTION("0F5F8C1A80000000" , maxps(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F5F8C1A80000000" , maxps(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("F20F5FCA" , maxsd(xmm1, xmm2)); + TEST_INSTRUCTION("F20F5F8C1A80000000" , maxsd(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("F20F5F8C1A80000000" , maxsd(xmm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("F30F5FCA" , maxss(xmm1, xmm2)); + TEST_INSTRUCTION("F30F5F8C1A80000000" , maxss(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("F30F5F8C1A80000000" , maxss(xmm1, dword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F5DCA" , minpd(xmm1, xmm2)); + TEST_INSTRUCTION("660F5D8C1A80000000" , minpd(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F5D8C1A80000000" , minpd(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F5DCA" , minps(xmm1, xmm2)); + TEST_INSTRUCTION("0F5D8C1A80000000" , minps(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F5D8C1A80000000" , minps(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("F20F5DCA" , minsd(xmm1, xmm2)); + TEST_INSTRUCTION("F20F5D8C1A80000000" , minsd(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("F20F5D8C1A80000000" , minsd(xmm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("F30F5DCA" , minss(xmm1, xmm2)); + TEST_INSTRUCTION("F30F5D8C1A80000000" , minss(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("F30F5D8C1A80000000" , minss(xmm1, dword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F28CA" , movapd(xmm1, xmm2)); + TEST_INSTRUCTION("660F288C1A80000000" , movapd(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F288C1A80000000" , movapd(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F299C1180000000" , movapd(ptr(ecx, edx, 0, 128), xmm3)); + TEST_INSTRUCTION("660F299C1180000000" , movapd(xmmword_ptr(ecx, edx, 0, 128), xmm3)); + TEST_INSTRUCTION("0F28CA" , movaps(xmm1, xmm2)); + TEST_INSTRUCTION("0F288C1A80000000" , movaps(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F288C1A80000000" , movaps(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F299C1180000000" , movaps(ptr(ecx, edx, 0, 128), xmm3)); + TEST_INSTRUCTION("0F299C1180000000" , movaps(xmmword_ptr(ecx, edx, 0, 128), xmm3)); + TEST_INSTRUCTION("660F6ECA" , movd(xmm1, edx)); + TEST_INSTRUCTION("660F6E8C1A80000000" , movd(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F6E8C1A80000000" , movd(xmm1, dword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F6ECA" , movd(mm1, edx)); + TEST_INSTRUCTION("0F6E8C1A80000000" , movd(mm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F6E8C1A80000000" , movd(mm1, dword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F7ED1" , movd(ecx, xmm2)); + TEST_INSTRUCTION("0F7ED1" , movd(ecx, mm2)); + TEST_INSTRUCTION("660F7E9C1180000000" , movd(ptr(ecx, edx, 0, 128), xmm3)); + TEST_INSTRUCTION("0F7E9C1180000000" , movd(ptr(ecx, edx, 0, 128), mm3)); + TEST_INSTRUCTION("660F7E9C1180000000" , movd(dword_ptr(ecx, edx, 0, 128), xmm3)); + TEST_INSTRUCTION("0F7E9C1180000000" , movd(dword_ptr(ecx, edx, 0, 128), mm3)); + TEST_INSTRUCTION("F20F12CA" , movddup(xmm1, xmm2)); + TEST_INSTRUCTION("F20F128C1A80000000" , movddup(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("F20F128C1A80000000" , movddup(xmm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("F20FD6CA" , movdq2q(mm1, xmm2)); + TEST_INSTRUCTION("660F6FCA" , movdqa(xmm1, xmm2)); + TEST_INSTRUCTION("660F6F8C1A80000000" , movdqa(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F6F8C1A80000000" , movdqa(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F7F9C1180000000" , movdqa(ptr(ecx, edx, 0, 128), xmm3)); + TEST_INSTRUCTION("660F7F9C1180000000" , movdqa(xmmword_ptr(ecx, edx, 0, 128), xmm3)); + TEST_INSTRUCTION("F30F6FCA" , movdqu(xmm1, xmm2)); + TEST_INSTRUCTION("F30F6F8C1A80000000" , movdqu(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("F30F6F8C1A80000000" , movdqu(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("F30F7F9C1180000000" , movdqu(ptr(ecx, edx, 0, 128), xmm3)); + TEST_INSTRUCTION("F30F7F9C1180000000" , movdqu(xmmword_ptr(ecx, edx, 0, 128), xmm3)); + TEST_INSTRUCTION("0F12CA" , movhlps(xmm1, xmm2)); + TEST_INSTRUCTION("660F179C1180000000" , movhpd(ptr(ecx, edx, 0, 128), xmm3)); + TEST_INSTRUCTION("660F179C1180000000" , movhpd(qword_ptr(ecx, edx, 0, 128), xmm3)); + TEST_INSTRUCTION("660F168C1A80000000" , movhpd(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F168C1A80000000" , movhpd(xmm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F179C1180000000" , movhps(ptr(ecx, edx, 0, 128), xmm3)); + TEST_INSTRUCTION("0F179C1180000000" , movhps(qword_ptr(ecx, edx, 0, 128), xmm3)); + TEST_INSTRUCTION("0F168C1A80000000" , movhps(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F168C1A80000000" , movhps(xmm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F16CA" , movlhps(xmm1, xmm2)); + TEST_INSTRUCTION("660F139C1180000000" , movlpd(ptr(ecx, edx, 0, 128), xmm3)); + TEST_INSTRUCTION("660F139C1180000000" , movlpd(qword_ptr(ecx, edx, 0, 128), xmm3)); + TEST_INSTRUCTION("660F128C1A80000000" , movlpd(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F128C1A80000000" , movlpd(xmm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F139C1180000000" , movlps(ptr(ecx, edx, 0, 128), xmm3)); + TEST_INSTRUCTION("0F139C1180000000" , movlps(qword_ptr(ecx, edx, 0, 128), xmm3)); + TEST_INSTRUCTION("0F128C1A80000000" , movlps(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F128C1A80000000" , movlps(xmm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F50CA" , movmskpd(ecx, xmm2)); + TEST_INSTRUCTION("0F50CA" , movmskps(ecx, xmm2)); + TEST_INSTRUCTION("660FE79C1180000000" , movntdq(ptr(ecx, edx, 0, 128), xmm3)); + TEST_INSTRUCTION("660FE79C1180000000" , movntdq(xmmword_ptr(ecx, edx, 0, 128), xmm3)); + TEST_INSTRUCTION("660F382A8C1A80000000" , movntdqa(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F382A8C1A80000000" , movntdqa(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F2B9C1180000000" , movntpd(ptr(ecx, edx, 0, 128), xmm3)); + TEST_INSTRUCTION("660F2B9C1180000000" , movntpd(xmmword_ptr(ecx, edx, 0, 128), xmm3)); + TEST_INSTRUCTION("0F2B9C1180000000" , movntps(ptr(ecx, edx, 0, 128), xmm3)); + TEST_INSTRUCTION("0F2B9C1180000000" , movntps(xmmword_ptr(ecx, edx, 0, 128), xmm3)); + TEST_INSTRUCTION("0FE79C1180000000" , movntq(ptr(ecx, edx, 0, 128), mm3)); + TEST_INSTRUCTION("0FE79C1180000000" , movntq(qword_ptr(ecx, edx, 0, 128), mm3)); + TEST_INSTRUCTION("F20F2B9C1180000000" , movntsd(ptr(ecx, edx, 0, 128), xmm3)); + TEST_INSTRUCTION("F20F2B9C1180000000" , movntsd(qword_ptr(ecx, edx, 0, 128), xmm3)); + TEST_INSTRUCTION("F30F2B9C1180000000" , movntss(ptr(ecx, edx, 0, 128), xmm3)); + TEST_INSTRUCTION("F30F2B9C1180000000" , movntss(dword_ptr(ecx, edx, 0, 128), xmm3)); + TEST_INSTRUCTION("0F6FCA" , movq(mm1, mm2)); + TEST_INSTRUCTION("0F6F8C1A80000000" , movq(mm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F6F8C1A80000000" , movq(mm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660FD69C1180000000" , movq(ptr(ecx, edx, 0, 128), xmm3)); + TEST_INSTRUCTION("0F7F9C1180000000" , movq(ptr(ecx, edx, 0, 128), mm3)); + TEST_INSTRUCTION("660FD69C1180000000" , movq(qword_ptr(ecx, edx, 0, 128), xmm3)); + TEST_INSTRUCTION("0F7F9C1180000000" , movq(qword_ptr(ecx, edx, 0, 128), mm3)); + TEST_INSTRUCTION("F30F7ECA" , movq(xmm1, xmm2)); + TEST_INSTRUCTION("F30F7E8C1A80000000" , movq(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("F30F7E8C1A80000000" , movq(xmm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("F30FD6CA" , movq2dq(xmm1, mm2)); + TEST_INSTRUCTION("F20F10CA" , movsd(xmm1, xmm2)); + TEST_INSTRUCTION("F20F108C1A80000000" , movsd(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("F20F108C1A80000000" , movsd(xmm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("F20F119C1180000000" , movsd(ptr(ecx, edx, 0, 128), xmm3)); + TEST_INSTRUCTION("F20F119C1180000000" , movsd(qword_ptr(ecx, edx, 0, 128), xmm3)); + TEST_INSTRUCTION("F30F16CA" , movshdup(xmm1, xmm2)); + TEST_INSTRUCTION("F30F168C1A80000000" , movshdup(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("F30F168C1A80000000" , movshdup(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("F30F12CA" , movsldup(xmm1, xmm2)); + TEST_INSTRUCTION("F30F128C1A80000000" , movsldup(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("F30F128C1A80000000" , movsldup(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("F30F10CA" , movss(xmm1, xmm2)); + TEST_INSTRUCTION("F30F108C1A80000000" , movss(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("F30F108C1A80000000" , movss(xmm1, dword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("F30F119C1180000000" , movss(ptr(ecx, edx, 0, 128), xmm3)); + TEST_INSTRUCTION("F30F119C1180000000" , movss(dword_ptr(ecx, edx, 0, 128), xmm3)); + TEST_INSTRUCTION("660F10CA" , movupd(xmm1, xmm2)); + TEST_INSTRUCTION("660F108C1A80000000" , movupd(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F108C1A80000000" , movupd(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F119C1180000000" , movupd(ptr(ecx, edx, 0, 128), xmm3)); + TEST_INSTRUCTION("660F119C1180000000" , movupd(xmmword_ptr(ecx, edx, 0, 128), xmm3)); + TEST_INSTRUCTION("0F10CA" , movups(xmm1, xmm2)); + TEST_INSTRUCTION("0F108C1A80000000" , movups(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F108C1A80000000" , movups(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F119C1180000000" , movups(ptr(ecx, edx, 0, 128), xmm3)); + TEST_INSTRUCTION("0F119C1180000000" , movups(xmmword_ptr(ecx, edx, 0, 128), xmm3)); + TEST_INSTRUCTION("660F3A42CA01" , mpsadbw(xmm1, xmm2, 1)); + TEST_INSTRUCTION("660F3A428C1A8000000001" , mpsadbw(xmm1, ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("660F3A428C1A8000000001" , mpsadbw(xmm1, xmmword_ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("660F59CA" , mulpd(xmm1, xmm2)); + TEST_INSTRUCTION("660F598C1A80000000" , mulpd(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F598C1A80000000" , mulpd(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F59CA" , mulps(xmm1, xmm2)); + TEST_INSTRUCTION("0F598C1A80000000" , mulps(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F598C1A80000000" , mulps(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("F20F59CA" , mulsd(xmm1, xmm2)); + TEST_INSTRUCTION("F20F598C1A80000000" , mulsd(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("F20F598C1A80000000" , mulsd(xmm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("F30F59CA" , mulss(xmm1, xmm2)); + TEST_INSTRUCTION("F30F598C1A80000000" , mulss(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("F30F598C1A80000000" , mulss(xmm1, dword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F56CA" , orpd(xmm1, xmm2)); + TEST_INSTRUCTION("660F568C1A80000000" , orpd(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F568C1A80000000" , orpd(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F56CA" , orps(xmm1, xmm2)); + TEST_INSTRUCTION("0F568C1A80000000" , orps(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F568C1A80000000" , orps(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F381CCA" , pabsb(mm1, mm2)); + TEST_INSTRUCTION("0F381C8C1A80000000" , pabsb(mm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F381C8C1A80000000" , pabsb(mm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F381CCA" , pabsb(xmm1, xmm2)); + TEST_INSTRUCTION("660F381C8C1A80000000" , pabsb(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F381C8C1A80000000" , pabsb(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F381ECA" , pabsd(mm1, mm2)); + TEST_INSTRUCTION("0F381E8C1A80000000" , pabsd(mm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F381E8C1A80000000" , pabsd(mm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F381ECA" , pabsd(xmm1, xmm2)); + TEST_INSTRUCTION("660F381E8C1A80000000" , pabsd(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F381E8C1A80000000" , pabsd(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F381DCA" , pabsw(mm1, mm2)); + TEST_INSTRUCTION("0F381D8C1A80000000" , pabsw(mm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F381D8C1A80000000" , pabsw(mm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F381DCA" , pabsw(xmm1, xmm2)); + TEST_INSTRUCTION("660F381D8C1A80000000" , pabsw(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F381D8C1A80000000" , pabsw(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F6BCA" , packssdw(mm1, mm2)); + TEST_INSTRUCTION("0F6B8C1A80000000" , packssdw(mm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F6B8C1A80000000" , packssdw(mm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F6BCA" , packssdw(xmm1, xmm2)); + TEST_INSTRUCTION("660F6B8C1A80000000" , packssdw(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F6B8C1A80000000" , packssdw(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F63CA" , packsswb(mm1, mm2)); + TEST_INSTRUCTION("0F638C1A80000000" , packsswb(mm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F638C1A80000000" , packsswb(mm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F63CA" , packsswb(xmm1, xmm2)); + TEST_INSTRUCTION("660F638C1A80000000" , packsswb(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F638C1A80000000" , packsswb(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F382BCA" , packusdw(xmm1, xmm2)); + TEST_INSTRUCTION("660F382B8C1A80000000" , packusdw(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F382B8C1A80000000" , packusdw(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F67CA" , packuswb(mm1, mm2)); + TEST_INSTRUCTION("0F678C1A80000000" , packuswb(mm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F678C1A80000000" , packuswb(mm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F67CA" , packuswb(xmm1, xmm2)); + TEST_INSTRUCTION("660F678C1A80000000" , packuswb(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F678C1A80000000" , packuswb(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0FFCCA" , paddb(mm1, mm2)); + TEST_INSTRUCTION("0FFC8C1A80000000" , paddb(mm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0FFC8C1A80000000" , paddb(mm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660FFCCA" , paddb(xmm1, xmm2)); + TEST_INSTRUCTION("660FFC8C1A80000000" , paddb(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660FFC8C1A80000000" , paddb(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0FFECA" , paddd(mm1, mm2)); + TEST_INSTRUCTION("0FFE8C1A80000000" , paddd(mm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0FFE8C1A80000000" , paddd(mm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660FFECA" , paddd(xmm1, xmm2)); + TEST_INSTRUCTION("660FFE8C1A80000000" , paddd(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660FFE8C1A80000000" , paddd(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0FD4CA" , paddq(mm1, mm2)); + TEST_INSTRUCTION("0FD48C1A80000000" , paddq(mm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0FD48C1A80000000" , paddq(mm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660FD4CA" , paddq(xmm1, xmm2)); + TEST_INSTRUCTION("660FD48C1A80000000" , paddq(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660FD48C1A80000000" , paddq(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0FECCA" , paddsb(mm1, mm2)); + TEST_INSTRUCTION("0FEC8C1A80000000" , paddsb(mm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0FEC8C1A80000000" , paddsb(mm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660FECCA" , paddsb(xmm1, xmm2)); + TEST_INSTRUCTION("660FEC8C1A80000000" , paddsb(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660FEC8C1A80000000" , paddsb(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0FEDCA" , paddsw(mm1, mm2)); + TEST_INSTRUCTION("0FED8C1A80000000" , paddsw(mm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0FED8C1A80000000" , paddsw(mm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660FEDCA" , paddsw(xmm1, xmm2)); + TEST_INSTRUCTION("660FED8C1A80000000" , paddsw(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660FED8C1A80000000" , paddsw(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0FDCCA" , paddusb(mm1, mm2)); + TEST_INSTRUCTION("0FDC8C1A80000000" , paddusb(mm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0FDC8C1A80000000" , paddusb(mm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660FDCCA" , paddusb(xmm1, xmm2)); + TEST_INSTRUCTION("660FDC8C1A80000000" , paddusb(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660FDC8C1A80000000" , paddusb(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0FDDCA" , paddusw(mm1, mm2)); + TEST_INSTRUCTION("0FDD8C1A80000000" , paddusw(mm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0FDD8C1A80000000" , paddusw(mm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660FDDCA" , paddusw(xmm1, xmm2)); + TEST_INSTRUCTION("660FDD8C1A80000000" , paddusw(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660FDD8C1A80000000" , paddusw(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0FFDCA" , paddw(mm1, mm2)); + TEST_INSTRUCTION("0FFD8C1A80000000" , paddw(mm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0FFD8C1A80000000" , paddw(mm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660FFDCA" , paddw(xmm1, xmm2)); + TEST_INSTRUCTION("660FFD8C1A80000000" , paddw(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660FFD8C1A80000000" , paddw(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F3A0FCA01" , palignr(mm1, mm2, 1)); + TEST_INSTRUCTION("0F3A0F8C1A8000000001" , palignr(mm1, ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("0F3A0F8C1A8000000001" , palignr(mm1, qword_ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("660F3A0FCA01" , palignr(xmm1, xmm2, 1)); + TEST_INSTRUCTION("660F3A0F8C1A8000000001" , palignr(xmm1, ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("660F3A0F8C1A8000000001" , palignr(xmm1, xmmword_ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("0FDBCA" , pand(mm1, mm2)); + TEST_INSTRUCTION("0FDB8C1A80000000" , pand(mm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0FDB8C1A80000000" , pand(mm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660FDBCA" , pand(xmm1, xmm2)); + TEST_INSTRUCTION("660FDB8C1A80000000" , pand(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660FDB8C1A80000000" , pand(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0FDFCA" , pandn(mm1, mm2)); + TEST_INSTRUCTION("0FDF8C1A80000000" , pandn(mm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0FDF8C1A80000000" , pandn(mm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660FDFCA" , pandn(xmm1, xmm2)); + TEST_INSTRUCTION("660FDF8C1A80000000" , pandn(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660FDF8C1A80000000" , pandn(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0FE0CA" , pavgb(mm1, mm2)); + TEST_INSTRUCTION("0FE08C1A80000000" , pavgb(mm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0FE08C1A80000000" , pavgb(mm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660FE0CA" , pavgb(xmm1, xmm2)); + TEST_INSTRUCTION("660FE08C1A80000000" , pavgb(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660FE08C1A80000000" , pavgb(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F0FCABF" , pavgusb(mm1, mm2)); + TEST_INSTRUCTION("0F0F8C1A80000000BF" , pavgusb(mm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F0F8C1A80000000BF" , pavgusb(mm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0FE3CA" , pavgw(mm1, mm2)); + TEST_INSTRUCTION("0FE38C1A80000000" , pavgw(mm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0FE38C1A80000000" , pavgw(mm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660FE3CA" , pavgw(xmm1, xmm2)); + TEST_INSTRUCTION("660FE38C1A80000000" , pavgw(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660FE38C1A80000000" , pavgw(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F3810CA" , pblendvb(xmm1, xmm2, xmm0)); + TEST_INSTRUCTION("660F38108C1A80000000" , pblendvb(xmm1, ptr(edx, ebx, 0, 128), xmm0)); + TEST_INSTRUCTION("660F38108C1A80000000" , pblendvb(xmm1, xmmword_ptr(edx, ebx, 0, 128), xmm0)); + TEST_INSTRUCTION("660F3A0ECA01" , pblendw(xmm1, xmm2, 1)); + TEST_INSTRUCTION("660F3A0E8C1A8000000001" , pblendw(xmm1, ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("660F3A0E8C1A8000000001" , pblendw(xmm1, xmmword_ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("660F3A44CA01" , pclmulqdq(xmm1, xmm2, 1)); + TEST_INSTRUCTION("660F3A448C1A8000000001" , pclmulqdq(xmm1, ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("660F3A448C1A8000000001" , pclmulqdq(xmm1, xmmword_ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("0F74CA" , pcmpeqb(mm1, mm2)); + TEST_INSTRUCTION("0F748C1A80000000" , pcmpeqb(mm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F748C1A80000000" , pcmpeqb(mm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F74CA" , pcmpeqb(xmm1, xmm2)); + TEST_INSTRUCTION("660F748C1A80000000" , pcmpeqb(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F748C1A80000000" , pcmpeqb(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F76CA" , pcmpeqd(mm1, mm2)); + TEST_INSTRUCTION("0F768C1A80000000" , pcmpeqd(mm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F768C1A80000000" , pcmpeqd(mm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F76CA" , pcmpeqd(xmm1, xmm2)); + TEST_INSTRUCTION("660F768C1A80000000" , pcmpeqd(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F768C1A80000000" , pcmpeqd(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F3829CA" , pcmpeqq(xmm1, xmm2)); + TEST_INSTRUCTION("660F38298C1A80000000" , pcmpeqq(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F38298C1A80000000" , pcmpeqq(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F75CA" , pcmpeqw(mm1, mm2)); + TEST_INSTRUCTION("0F758C1A80000000" , pcmpeqw(mm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F758C1A80000000" , pcmpeqw(mm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F75CA" , pcmpeqw(xmm1, xmm2)); + TEST_INSTRUCTION("660F758C1A80000000" , pcmpeqw(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F758C1A80000000" , pcmpeqw(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F3A61CA01" , pcmpestri(xmm1, xmm2, 1, ecx, eax, edx)); + TEST_INSTRUCTION("660F3A618C1A8000000001" , pcmpestri(xmm1, ptr(edx, ebx, 0, 128), 1, ecx, eax, edx)); + TEST_INSTRUCTION("660F3A618C1A8000000001" , pcmpestri(xmm1, xmmword_ptr(edx, ebx, 0, 128), 1, ecx, eax, edx)); + TEST_INSTRUCTION("660F3A60CA01" , pcmpestrm(xmm1, xmm2, 1, xmm0, eax, edx)); + TEST_INSTRUCTION("660F3A608C1A8000000001" , pcmpestrm(xmm1, ptr(edx, ebx, 0, 128), 1, xmm0, eax, edx)); + TEST_INSTRUCTION("660F3A608C1A8000000001" , pcmpestrm(xmm1, xmmword_ptr(edx, ebx, 0, 128), 1, xmm0, eax, edx)); + TEST_INSTRUCTION("0F64CA" , pcmpgtb(mm1, mm2)); + TEST_INSTRUCTION("0F648C1A80000000" , pcmpgtb(mm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F648C1A80000000" , pcmpgtb(mm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F64CA" , pcmpgtb(xmm1, xmm2)); + TEST_INSTRUCTION("660F648C1A80000000" , pcmpgtb(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F648C1A80000000" , pcmpgtb(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F66CA" , pcmpgtd(mm1, mm2)); + TEST_INSTRUCTION("0F668C1A80000000" , pcmpgtd(mm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F668C1A80000000" , pcmpgtd(mm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F66CA" , pcmpgtd(xmm1, xmm2)); + TEST_INSTRUCTION("660F668C1A80000000" , pcmpgtd(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F668C1A80000000" , pcmpgtd(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F3837CA" , pcmpgtq(xmm1, xmm2)); + TEST_INSTRUCTION("660F38378C1A80000000" , pcmpgtq(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F38378C1A80000000" , pcmpgtq(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F65CA" , pcmpgtw(mm1, mm2)); + TEST_INSTRUCTION("0F658C1A80000000" , pcmpgtw(mm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F658C1A80000000" , pcmpgtw(mm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F65CA" , pcmpgtw(xmm1, xmm2)); + TEST_INSTRUCTION("660F658C1A80000000" , pcmpgtw(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F658C1A80000000" , pcmpgtw(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F3A63CA01" , pcmpistri(xmm1, xmm2, 1, ecx)); + TEST_INSTRUCTION("660F3A638C1A8000000001" , pcmpistri(xmm1, ptr(edx, ebx, 0, 128), 1, ecx)); + TEST_INSTRUCTION("660F3A638C1A8000000001" , pcmpistri(xmm1, xmmword_ptr(edx, ebx, 0, 128), 1, ecx)); + TEST_INSTRUCTION("660F3A62CA01" , pcmpistrm(xmm1, xmm2, 1, xmm0)); + TEST_INSTRUCTION("660F3A628C1A8000000001" , pcmpistrm(xmm1, ptr(edx, ebx, 0, 128), 1, xmm0)); + TEST_INSTRUCTION("660F3A628C1A8000000001" , pcmpistrm(xmm1, xmmword_ptr(edx, ebx, 0, 128), 1, xmm0)); + TEST_INSTRUCTION("660F3A14D101" , pextrb(ecx, xmm2, 1)); + TEST_INSTRUCTION("660F3A149C118000000001" , pextrb(ptr(ecx, edx, 0, 128), xmm3, 1)); + TEST_INSTRUCTION("660F3A149C118000000001" , pextrb(byte_ptr(ecx, edx, 0, 128), xmm3, 1)); + TEST_INSTRUCTION("660F3A16D101" , pextrd(ecx, xmm2, 1)); + TEST_INSTRUCTION("660F3A169C118000000001" , pextrd(ptr(ecx, edx, 0, 128), xmm3, 1)); + TEST_INSTRUCTION("660F3A169C118000000001" , pextrd(dword_ptr(ecx, edx, 0, 128), xmm3, 1)); + TEST_INSTRUCTION("660FC5CA01" , pextrw(ecx, xmm2, 1)); + TEST_INSTRUCTION("0FC5CA01" , pextrw(ecx, mm2, 1)); + TEST_INSTRUCTION("660F3A159C118000000001" , pextrw(ptr(ecx, edx, 0, 128), xmm3, 1)); + TEST_INSTRUCTION("660F3A159C118000000001" , pextrw(word_ptr(ecx, edx, 0, 128), xmm3, 1)); + TEST_INSTRUCTION("0F0FCA1D" , pf2id(mm1, mm2)); + TEST_INSTRUCTION("0F0F8C1A800000001D" , pf2id(mm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F0F8C1A800000001D" , pf2id(mm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F0FCA1C" , pf2iw(mm1, mm2)); + TEST_INSTRUCTION("0F0F8C1A800000001C" , pf2iw(mm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F0F8C1A800000001C" , pf2iw(mm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F0FCAAE" , pfacc(mm1, mm2)); + TEST_INSTRUCTION("0F0F8C1A80000000AE" , pfacc(mm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F0F8C1A80000000AE" , pfacc(mm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F0FCA9E" , pfadd(mm1, mm2)); + TEST_INSTRUCTION("0F0F8C1A800000009E" , pfadd(mm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F0F8C1A800000009E" , pfadd(mm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F0FCAB0" , pfcmpeq(mm1, mm2)); + TEST_INSTRUCTION("0F0F8C1A80000000B0" , pfcmpeq(mm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F0F8C1A80000000B0" , pfcmpeq(mm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F0FCA90" , pfcmpge(mm1, mm2)); + TEST_INSTRUCTION("0F0F8C1A8000000090" , pfcmpge(mm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F0F8C1A8000000090" , pfcmpge(mm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F0FCAA0" , pfcmpgt(mm1, mm2)); + TEST_INSTRUCTION("0F0F8C1A80000000A0" , pfcmpgt(mm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F0F8C1A80000000A0" , pfcmpgt(mm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F0FCAA4" , pfmax(mm1, mm2)); + TEST_INSTRUCTION("0F0F8C1A80000000A4" , pfmax(mm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F0F8C1A80000000A4" , pfmax(mm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F0FCA94" , pfmin(mm1, mm2)); + TEST_INSTRUCTION("0F0F8C1A8000000094" , pfmin(mm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F0F8C1A8000000094" , pfmin(mm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F0FCAB4" , pfmul(mm1, mm2)); + TEST_INSTRUCTION("0F0F8C1A80000000B4" , pfmul(mm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F0F8C1A80000000B4" , pfmul(mm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F0FCA8A" , pfnacc(mm1, mm2)); + TEST_INSTRUCTION("0F0F8C1A800000008A" , pfnacc(mm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F0F8C1A800000008A" , pfnacc(mm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F0FCA8E" , pfpnacc(mm1, mm2)); + TEST_INSTRUCTION("0F0F8C1A800000008E" , pfpnacc(mm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F0F8C1A800000008E" , pfpnacc(mm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F0FCA96" , pfrcp(mm1, mm2)); + TEST_INSTRUCTION("0F0F8C1A8000000096" , pfrcp(mm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F0F8C1A8000000096" , pfrcp(mm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F0FCAA6" , pfrcpit1(mm1, mm2)); + TEST_INSTRUCTION("0F0F8C1A80000000A6" , pfrcpit1(mm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F0F8C1A80000000A6" , pfrcpit1(mm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F0FCAB6" , pfrcpit2(mm1, mm2)); + TEST_INSTRUCTION("0F0F8C1A80000000B6" , pfrcpit2(mm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F0F8C1A80000000B6" , pfrcpit2(mm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F0FCA86" , pfrcpv(mm1, mm2)); + TEST_INSTRUCTION("0F0F8C1A8000000086" , pfrcpv(mm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F0F8C1A8000000086" , pfrcpv(mm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F0FCAA7" , pfrsqit1(mm1, mm2)); + TEST_INSTRUCTION("0F0F8C1A80000000A7" , pfrsqit1(mm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F0F8C1A80000000A7" , pfrsqit1(mm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F0FCA97" , pfrsqrt(mm1, mm2)); + TEST_INSTRUCTION("0F0F8C1A8000000097" , pfrsqrt(mm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F0F8C1A8000000097" , pfrsqrt(mm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F0FCA87" , pfrsqrtv(mm1, mm2)); + TEST_INSTRUCTION("0F0F8C1A8000000087" , pfrsqrtv(mm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F0F8C1A8000000087" , pfrsqrtv(mm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F0FCA9A" , pfsub(mm1, mm2)); + TEST_INSTRUCTION("0F0F8C1A800000009A" , pfsub(mm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F0F8C1A800000009A" , pfsub(mm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F0FCAAA" , pfsubr(mm1, mm2)); + TEST_INSTRUCTION("0F0F8C1A80000000AA" , pfsubr(mm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F0F8C1A80000000AA" , pfsubr(mm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F3802CA" , phaddd(mm1, mm2)); + TEST_INSTRUCTION("0F38028C1A80000000" , phaddd(mm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F38028C1A80000000" , phaddd(mm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F3802CA" , phaddd(xmm1, xmm2)); + TEST_INSTRUCTION("660F38028C1A80000000" , phaddd(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F38028C1A80000000" , phaddd(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F3803CA" , phaddsw(mm1, mm2)); + TEST_INSTRUCTION("0F38038C1A80000000" , phaddsw(mm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F38038C1A80000000" , phaddsw(mm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F3803CA" , phaddsw(xmm1, xmm2)); + TEST_INSTRUCTION("660F38038C1A80000000" , phaddsw(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F38038C1A80000000" , phaddsw(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F3801CA" , phaddw(mm1, mm2)); + TEST_INSTRUCTION("0F38018C1A80000000" , phaddw(mm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F38018C1A80000000" , phaddw(mm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F3801CA" , phaddw(xmm1, xmm2)); + TEST_INSTRUCTION("660F38018C1A80000000" , phaddw(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F38018C1A80000000" , phaddw(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F3841CA" , phminposuw(xmm1, xmm2)); + TEST_INSTRUCTION("660F38418C1A80000000" , phminposuw(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F38418C1A80000000" , phminposuw(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F3806CA" , phsubd(mm1, mm2)); + TEST_INSTRUCTION("0F38068C1A80000000" , phsubd(mm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F38068C1A80000000" , phsubd(mm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F3806CA" , phsubd(xmm1, xmm2)); + TEST_INSTRUCTION("660F38068C1A80000000" , phsubd(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F38068C1A80000000" , phsubd(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F3807CA" , phsubsw(mm1, mm2)); + TEST_INSTRUCTION("0F38078C1A80000000" , phsubsw(mm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F38078C1A80000000" , phsubsw(mm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F3807CA" , phsubsw(xmm1, xmm2)); + TEST_INSTRUCTION("660F38078C1A80000000" , phsubsw(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F38078C1A80000000" , phsubsw(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F3805CA" , phsubw(mm1, mm2)); + TEST_INSTRUCTION("0F38058C1A80000000" , phsubw(mm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F38058C1A80000000" , phsubw(mm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F3805CA" , phsubw(xmm1, xmm2)); + TEST_INSTRUCTION("660F38058C1A80000000" , phsubw(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F38058C1A80000000" , phsubw(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F0FCA0D" , pi2fd(mm1, mm2)); + TEST_INSTRUCTION("0F0F8C1A800000000D" , pi2fd(mm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F0F8C1A800000000D" , pi2fd(mm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F0FCA0C" , pi2fw(mm1, mm2)); + TEST_INSTRUCTION("0F0F8C1A800000000C" , pi2fw(mm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F0F8C1A800000000C" , pi2fw(mm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F3A20CA01" , pinsrb(xmm1, edx, 1)); + TEST_INSTRUCTION("660F3A208C1A8000000001" , pinsrb(xmm1, ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("660F3A208C1A8000000001" , pinsrb(xmm1, byte_ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("660F3A22CA01" , pinsrd(xmm1, edx, 1)); + TEST_INSTRUCTION("660F3A228C1A8000000001" , pinsrd(xmm1, ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("660F3A228C1A8000000001" , pinsrd(xmm1, dword_ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("660FC4CA01" , pinsrw(xmm1, edx, 1)); + TEST_INSTRUCTION("660FC48C1A8000000001" , pinsrw(xmm1, ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("660FC48C1A8000000001" , pinsrw(xmm1, word_ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("0FC4CA01" , pinsrw(mm1, edx, 1)); + TEST_INSTRUCTION("0FC48C1A8000000001" , pinsrw(mm1, ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("0FC48C1A8000000001" , pinsrw(mm1, word_ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("0F3804CA" , pmaddubsw(mm1, mm2)); + TEST_INSTRUCTION("0F38048C1A80000000" , pmaddubsw(mm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F38048C1A80000000" , pmaddubsw(mm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F3804CA" , pmaddubsw(xmm1, xmm2)); + TEST_INSTRUCTION("660F38048C1A80000000" , pmaddubsw(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F38048C1A80000000" , pmaddubsw(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0FF5CA" , pmaddwd(mm1, mm2)); + TEST_INSTRUCTION("0FF58C1A80000000" , pmaddwd(mm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0FF58C1A80000000" , pmaddwd(mm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660FF5CA" , pmaddwd(xmm1, xmm2)); + TEST_INSTRUCTION("660FF58C1A80000000" , pmaddwd(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660FF58C1A80000000" , pmaddwd(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F383CCA" , pmaxsb(xmm1, xmm2)); + TEST_INSTRUCTION("660F383C8C1A80000000" , pmaxsb(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F383C8C1A80000000" , pmaxsb(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F383DCA" , pmaxsd(xmm1, xmm2)); + TEST_INSTRUCTION("660F383D8C1A80000000" , pmaxsd(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F383D8C1A80000000" , pmaxsd(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0FEECA" , pmaxsw(mm1, mm2)); + TEST_INSTRUCTION("0FEE8C1A80000000" , pmaxsw(mm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0FEE8C1A80000000" , pmaxsw(mm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660FEECA" , pmaxsw(xmm1, xmm2)); + TEST_INSTRUCTION("660FEE8C1A80000000" , pmaxsw(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660FEE8C1A80000000" , pmaxsw(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0FDECA" , pmaxub(mm1, mm2)); + TEST_INSTRUCTION("0FDE8C1A80000000" , pmaxub(mm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0FDE8C1A80000000" , pmaxub(mm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660FDECA" , pmaxub(xmm1, xmm2)); + TEST_INSTRUCTION("660FDE8C1A80000000" , pmaxub(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660FDE8C1A80000000" , pmaxub(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F383FCA" , pmaxud(xmm1, xmm2)); + TEST_INSTRUCTION("660F383F8C1A80000000" , pmaxud(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F383F8C1A80000000" , pmaxud(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F383ECA" , pmaxuw(xmm1, xmm2)); + TEST_INSTRUCTION("660F383E8C1A80000000" , pmaxuw(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F383E8C1A80000000" , pmaxuw(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F3838CA" , pminsb(xmm1, xmm2)); + TEST_INSTRUCTION("660F38388C1A80000000" , pminsb(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F38388C1A80000000" , pminsb(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F3839CA" , pminsd(xmm1, xmm2)); + TEST_INSTRUCTION("660F38398C1A80000000" , pminsd(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F38398C1A80000000" , pminsd(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0FEACA" , pminsw(mm1, mm2)); + TEST_INSTRUCTION("0FEA8C1A80000000" , pminsw(mm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0FEA8C1A80000000" , pminsw(mm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660FEACA" , pminsw(xmm1, xmm2)); + TEST_INSTRUCTION("660FEA8C1A80000000" , pminsw(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660FEA8C1A80000000" , pminsw(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0FDACA" , pminub(mm1, mm2)); + TEST_INSTRUCTION("0FDA8C1A80000000" , pminub(mm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0FDA8C1A80000000" , pminub(mm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660FDACA" , pminub(xmm1, xmm2)); + TEST_INSTRUCTION("660FDA8C1A80000000" , pminub(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660FDA8C1A80000000" , pminub(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F383BCA" , pminud(xmm1, xmm2)); + TEST_INSTRUCTION("660F383B8C1A80000000" , pminud(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F383B8C1A80000000" , pminud(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F383ACA" , pminuw(xmm1, xmm2)); + TEST_INSTRUCTION("660F383A8C1A80000000" , pminuw(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F383A8C1A80000000" , pminuw(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660FD7CA" , pmovmskb(ecx, xmm2)); + TEST_INSTRUCTION("0FD7CA" , pmovmskb(ecx, mm2)); + TEST_INSTRUCTION("660F3821CA" , pmovsxbd(xmm1, xmm2)); + TEST_INSTRUCTION("660F38218C1A80000000" , pmovsxbd(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F38218C1A80000000" , pmovsxbd(xmm1, dword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F3822CA" , pmovsxbq(xmm1, xmm2)); + TEST_INSTRUCTION("660F38228C1A80000000" , pmovsxbq(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F38228C1A80000000" , pmovsxbq(xmm1, word_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F3820CA" , pmovsxbw(xmm1, xmm2)); + TEST_INSTRUCTION("660F38208C1A80000000" , pmovsxbw(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F38208C1A80000000" , pmovsxbw(xmm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F3825CA" , pmovsxdq(xmm1, xmm2)); + TEST_INSTRUCTION("660F38258C1A80000000" , pmovsxdq(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F38258C1A80000000" , pmovsxdq(xmm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F3823CA" , pmovsxwd(xmm1, xmm2)); + TEST_INSTRUCTION("660F38238C1A80000000" , pmovsxwd(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F38238C1A80000000" , pmovsxwd(xmm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F3824CA" , pmovsxwq(xmm1, xmm2)); + TEST_INSTRUCTION("660F38248C1A80000000" , pmovsxwq(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F38248C1A80000000" , pmovsxwq(xmm1, dword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F3831CA" , pmovzxbd(xmm1, xmm2)); + TEST_INSTRUCTION("660F38318C1A80000000" , pmovzxbd(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F38318C1A80000000" , pmovzxbd(xmm1, dword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F3832CA" , pmovzxbq(xmm1, xmm2)); + TEST_INSTRUCTION("660F38328C1A80000000" , pmovzxbq(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F38328C1A80000000" , pmovzxbq(xmm1, word_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F3830CA" , pmovzxbw(xmm1, xmm2)); + TEST_INSTRUCTION("660F38308C1A80000000" , pmovzxbw(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F38308C1A80000000" , pmovzxbw(xmm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F3835CA" , pmovzxdq(xmm1, xmm2)); + TEST_INSTRUCTION("660F38358C1A80000000" , pmovzxdq(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F38358C1A80000000" , pmovzxdq(xmm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F3833CA" , pmovzxwd(xmm1, xmm2)); + TEST_INSTRUCTION("660F38338C1A80000000" , pmovzxwd(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F38338C1A80000000" , pmovzxwd(xmm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F3834CA" , pmovzxwq(xmm1, xmm2)); + TEST_INSTRUCTION("660F38348C1A80000000" , pmovzxwq(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F38348C1A80000000" , pmovzxwq(xmm1, dword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F3828CA" , pmuldq(xmm1, xmm2)); + TEST_INSTRUCTION("660F38288C1A80000000" , pmuldq(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F38288C1A80000000" , pmuldq(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F380BCA" , pmulhrsw(mm1, mm2)); + TEST_INSTRUCTION("0F380B8C1A80000000" , pmulhrsw(mm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F380B8C1A80000000" , pmulhrsw(mm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F380BCA" , pmulhrsw(xmm1, xmm2)); + TEST_INSTRUCTION("660F380B8C1A80000000" , pmulhrsw(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F380B8C1A80000000" , pmulhrsw(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F0FCAB7" , pmulhrw(mm1, mm2)); + TEST_INSTRUCTION("0F0F8C1A80000000B7" , pmulhrw(mm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F0F8C1A80000000B7" , pmulhrw(mm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0FE4CA" , pmulhuw(mm1, mm2)); + TEST_INSTRUCTION("0FE48C1A80000000" , pmulhuw(mm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0FE48C1A80000000" , pmulhuw(mm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660FE4CA" , pmulhuw(xmm1, xmm2)); + TEST_INSTRUCTION("660FE48C1A80000000" , pmulhuw(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660FE48C1A80000000" , pmulhuw(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0FE5CA" , pmulhw(mm1, mm2)); + TEST_INSTRUCTION("0FE58C1A80000000" , pmulhw(mm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0FE58C1A80000000" , pmulhw(mm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660FE5CA" , pmulhw(xmm1, xmm2)); + TEST_INSTRUCTION("660FE58C1A80000000" , pmulhw(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660FE58C1A80000000" , pmulhw(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F3840CA" , pmulld(xmm1, xmm2)); + TEST_INSTRUCTION("660F38408C1A80000000" , pmulld(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F38408C1A80000000" , pmulld(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0FD5CA" , pmullw(mm1, mm2)); + TEST_INSTRUCTION("0FD58C1A80000000" , pmullw(mm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0FD58C1A80000000" , pmullw(mm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660FD5CA" , pmullw(xmm1, xmm2)); + TEST_INSTRUCTION("660FD58C1A80000000" , pmullw(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660FD58C1A80000000" , pmullw(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0FF4CA" , pmuludq(mm1, mm2)); + TEST_INSTRUCTION("0FF48C1A80000000" , pmuludq(mm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0FF48C1A80000000" , pmuludq(mm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660FF4CA" , pmuludq(xmm1, xmm2)); + TEST_INSTRUCTION("660FF48C1A80000000" , pmuludq(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660FF48C1A80000000" , pmuludq(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0FEBCA" , por(mm1, mm2)); + TEST_INSTRUCTION("0FEB8C1A80000000" , por(mm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0FEB8C1A80000000" , por(mm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660FEBCA" , por(xmm1, xmm2)); + TEST_INSTRUCTION("660FEB8C1A80000000" , por(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660FEB8C1A80000000" , por(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0FF6CA" , psadbw(mm1, mm2)); + TEST_INSTRUCTION("0FF68C1A80000000" , psadbw(mm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0FF68C1A80000000" , psadbw(mm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660FF6CA" , psadbw(xmm1, xmm2)); + TEST_INSTRUCTION("660FF68C1A80000000" , psadbw(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660FF68C1A80000000" , psadbw(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F3800CA" , pshufb(mm1, mm2)); + TEST_INSTRUCTION("0F38008C1A80000000" , pshufb(mm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F38008C1A80000000" , pshufb(mm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F3800CA" , pshufb(xmm1, xmm2)); + TEST_INSTRUCTION("660F38008C1A80000000" , pshufb(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F38008C1A80000000" , pshufb(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F70CA01" , pshufd(xmm1, xmm2, 1)); + TEST_INSTRUCTION("660F708C1A8000000001" , pshufd(xmm1, ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("660F708C1A8000000001" , pshufd(xmm1, xmmword_ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("F30F70CA01" , pshufhw(xmm1, xmm2, 1)); + TEST_INSTRUCTION("F30F708C1A8000000001" , pshufhw(xmm1, ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("F30F708C1A8000000001" , pshufhw(xmm1, xmmword_ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("F20F70CA01" , pshuflw(xmm1, xmm2, 1)); + TEST_INSTRUCTION("F20F708C1A8000000001" , pshuflw(xmm1, ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("F20F708C1A8000000001" , pshuflw(xmm1, xmmword_ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("0F70CA01" , pshufw(mm1, mm2, 1)); + TEST_INSTRUCTION("0F708C1A8000000001" , pshufw(mm1, ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("0F708C1A8000000001" , pshufw(mm1, qword_ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("0F3808CA" , psignb(mm1, mm2)); + TEST_INSTRUCTION("0F38088C1A80000000" , psignb(mm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F38088C1A80000000" , psignb(mm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F3808CA" , psignb(xmm1, xmm2)); + TEST_INSTRUCTION("660F38088C1A80000000" , psignb(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F38088C1A80000000" , psignb(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F380ACA" , psignd(mm1, mm2)); + TEST_INSTRUCTION("0F380A8C1A80000000" , psignd(mm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F380A8C1A80000000" , psignd(mm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F380ACA" , psignd(xmm1, xmm2)); + TEST_INSTRUCTION("660F380A8C1A80000000" , psignd(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F380A8C1A80000000" , psignd(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F3809CA" , psignw(mm1, mm2)); + TEST_INSTRUCTION("0F38098C1A80000000" , psignw(mm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F38098C1A80000000" , psignw(mm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F3809CA" , psignw(xmm1, xmm2)); + TEST_INSTRUCTION("660F38098C1A80000000" , psignw(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F38098C1A80000000" , psignw(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0FF2CA" , pslld(mm1, mm2)); + TEST_INSTRUCTION("0F72F101" , pslld(mm1, 1)); + TEST_INSTRUCTION("0FF28C1A80000000" , pslld(mm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0FF28C1A80000000" , pslld(mm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660FF2CA" , pslld(xmm1, xmm2)); + TEST_INSTRUCTION("660F72F101" , pslld(xmm1, 1)); + TEST_INSTRUCTION("660FF28C1A80000000" , pslld(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660FF28C1A80000000" , pslld(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F73F901" , pslldq(xmm1, 1)); + TEST_INSTRUCTION("0FF3CA" , psllq(mm1, mm2)); + TEST_INSTRUCTION("0F73F101" , psllq(mm1, 1)); + TEST_INSTRUCTION("0FF38C1A80000000" , psllq(mm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0FF38C1A80000000" , psllq(mm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660FF3CA" , psllq(xmm1, xmm2)); + TEST_INSTRUCTION("660F73F101" , psllq(xmm1, 1)); + TEST_INSTRUCTION("660FF38C1A80000000" , psllq(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660FF38C1A80000000" , psllq(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0FF1CA" , psllw(mm1, mm2)); + TEST_INSTRUCTION("0F71F101" , psllw(mm1, 1)); + TEST_INSTRUCTION("0FF18C1A80000000" , psllw(mm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0FF18C1A80000000" , psllw(mm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660FF1CA" , psllw(xmm1, xmm2)); + TEST_INSTRUCTION("660F71F101" , psllw(xmm1, 1)); + TEST_INSTRUCTION("660FF18C1A80000000" , psllw(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660FF18C1A80000000" , psllw(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0FE2CA" , psrad(mm1, mm2)); + TEST_INSTRUCTION("0F72E101" , psrad(mm1, 1)); + TEST_INSTRUCTION("0FE28C1A80000000" , psrad(mm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0FE28C1A80000000" , psrad(mm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660FE2CA" , psrad(xmm1, xmm2)); + TEST_INSTRUCTION("660F72E101" , psrad(xmm1, 1)); + TEST_INSTRUCTION("660FE28C1A80000000" , psrad(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660FE28C1A80000000" , psrad(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0FE1CA" , psraw(mm1, mm2)); + TEST_INSTRUCTION("0F71E101" , psraw(mm1, 1)); + TEST_INSTRUCTION("0FE18C1A80000000" , psraw(mm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0FE18C1A80000000" , psraw(mm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660FE1CA" , psraw(xmm1, xmm2)); + TEST_INSTRUCTION("660F71E101" , psraw(xmm1, 1)); + TEST_INSTRUCTION("660FE18C1A80000000" , psraw(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660FE18C1A80000000" , psraw(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0FD2CA" , psrld(mm1, mm2)); + TEST_INSTRUCTION("0F72D101" , psrld(mm1, 1)); + TEST_INSTRUCTION("0FD28C1A80000000" , psrld(mm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0FD28C1A80000000" , psrld(mm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660FD2CA" , psrld(xmm1, xmm2)); + TEST_INSTRUCTION("660F72D101" , psrld(xmm1, 1)); + TEST_INSTRUCTION("660FD28C1A80000000" , psrld(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660FD28C1A80000000" , psrld(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F73D901" , psrldq(xmm1, 1)); + TEST_INSTRUCTION("0FD3CA" , psrlq(mm1, mm2)); + TEST_INSTRUCTION("0F73D101" , psrlq(mm1, 1)); + TEST_INSTRUCTION("0FD38C1A80000000" , psrlq(mm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0FD38C1A80000000" , psrlq(mm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660FD3CA" , psrlq(xmm1, xmm2)); + TEST_INSTRUCTION("660F73D101" , psrlq(xmm1, 1)); + TEST_INSTRUCTION("660FD38C1A80000000" , psrlq(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660FD38C1A80000000" , psrlq(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0FD1CA" , psrlw(mm1, mm2)); + TEST_INSTRUCTION("0F71D101" , psrlw(mm1, 1)); + TEST_INSTRUCTION("0FD18C1A80000000" , psrlw(mm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0FD18C1A80000000" , psrlw(mm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660FD1CA" , psrlw(xmm1, xmm2)); + TEST_INSTRUCTION("660F71D101" , psrlw(xmm1, 1)); + TEST_INSTRUCTION("660FD18C1A80000000" , psrlw(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660FD18C1A80000000" , psrlw(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0FF8CA" , psubb(mm1, mm2)); + TEST_INSTRUCTION("0FF88C1A80000000" , psubb(mm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0FF88C1A80000000" , psubb(mm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660FF8CA" , psubb(xmm1, xmm2)); + TEST_INSTRUCTION("660FF88C1A80000000" , psubb(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660FF88C1A80000000" , psubb(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0FFACA" , psubd(mm1, mm2)); + TEST_INSTRUCTION("0FFA8C1A80000000" , psubd(mm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0FFA8C1A80000000" , psubd(mm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660FFACA" , psubd(xmm1, xmm2)); + TEST_INSTRUCTION("660FFA8C1A80000000" , psubd(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660FFA8C1A80000000" , psubd(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0FFBCA" , psubq(mm1, mm2)); + TEST_INSTRUCTION("0FFB8C1A80000000" , psubq(mm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0FFB8C1A80000000" , psubq(mm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660FFBCA" , psubq(xmm1, xmm2)); + TEST_INSTRUCTION("660FFB8C1A80000000" , psubq(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660FFB8C1A80000000" , psubq(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0FE8CA" , psubsb(mm1, mm2)); + TEST_INSTRUCTION("0FE88C1A80000000" , psubsb(mm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0FE88C1A80000000" , psubsb(mm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660FE8CA" , psubsb(xmm1, xmm2)); + TEST_INSTRUCTION("660FE88C1A80000000" , psubsb(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660FE88C1A80000000" , psubsb(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0FE9CA" , psubsw(mm1, mm2)); + TEST_INSTRUCTION("0FE98C1A80000000" , psubsw(mm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0FE98C1A80000000" , psubsw(mm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660FE9CA" , psubsw(xmm1, xmm2)); + TEST_INSTRUCTION("660FE98C1A80000000" , psubsw(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660FE98C1A80000000" , psubsw(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0FD8CA" , psubusb(mm1, mm2)); + TEST_INSTRUCTION("0FD88C1A80000000" , psubusb(mm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0FD88C1A80000000" , psubusb(mm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660FD8CA" , psubusb(xmm1, xmm2)); + TEST_INSTRUCTION("660FD88C1A80000000" , psubusb(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660FD88C1A80000000" , psubusb(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0FD9CA" , psubusw(mm1, mm2)); + TEST_INSTRUCTION("0FD98C1A80000000" , psubusw(mm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0FD98C1A80000000" , psubusw(mm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660FD9CA" , psubusw(xmm1, xmm2)); + TEST_INSTRUCTION("660FD98C1A80000000" , psubusw(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660FD98C1A80000000" , psubusw(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0FF9CA" , psubw(mm1, mm2)); + TEST_INSTRUCTION("0FF98C1A80000000" , psubw(mm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0FF98C1A80000000" , psubw(mm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660FF9CA" , psubw(xmm1, xmm2)); + TEST_INSTRUCTION("660FF98C1A80000000" , psubw(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660FF98C1A80000000" , psubw(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F0FCABB" , pswapd(mm1, mm2)); + TEST_INSTRUCTION("0F0F8C1A80000000BB" , pswapd(mm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F0F8C1A80000000BB" , pswapd(mm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F3817CA" , ptest(xmm1, xmm2)); + TEST_INSTRUCTION("660F38178C1A80000000" , ptest(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F38178C1A80000000" , ptest(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F68CA" , punpckhbw(mm1, mm2)); + TEST_INSTRUCTION("0F688C1A80000000" , punpckhbw(mm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F688C1A80000000" , punpckhbw(mm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F68CA" , punpckhbw(xmm1, xmm2)); + TEST_INSTRUCTION("660F688C1A80000000" , punpckhbw(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F688C1A80000000" , punpckhbw(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F6ACA" , punpckhdq(mm1, mm2)); + TEST_INSTRUCTION("0F6A8C1A80000000" , punpckhdq(mm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F6A8C1A80000000" , punpckhdq(mm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F6ACA" , punpckhdq(xmm1, xmm2)); + TEST_INSTRUCTION("660F6A8C1A80000000" , punpckhdq(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F6A8C1A80000000" , punpckhdq(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F6DCA" , punpckhqdq(xmm1, xmm2)); + TEST_INSTRUCTION("660F6D8C1A80000000" , punpckhqdq(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F6D8C1A80000000" , punpckhqdq(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F69CA" , punpckhwd(mm1, mm2)); + TEST_INSTRUCTION("0F698C1A80000000" , punpckhwd(mm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F698C1A80000000" , punpckhwd(mm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F69CA" , punpckhwd(xmm1, xmm2)); + TEST_INSTRUCTION("660F698C1A80000000" , punpckhwd(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F698C1A80000000" , punpckhwd(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F60CA" , punpcklbw(mm1, mm2)); + TEST_INSTRUCTION("0F608C1A80000000" , punpcklbw(mm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F608C1A80000000" , punpcklbw(mm1, dword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F60CA" , punpcklbw(xmm1, xmm2)); + TEST_INSTRUCTION("660F608C1A80000000" , punpcklbw(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F608C1A80000000" , punpcklbw(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F62CA" , punpckldq(mm1, mm2)); + TEST_INSTRUCTION("0F628C1A80000000" , punpckldq(mm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F628C1A80000000" , punpckldq(mm1, dword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F62CA" , punpckldq(xmm1, xmm2)); + TEST_INSTRUCTION("660F628C1A80000000" , punpckldq(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F628C1A80000000" , punpckldq(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F6CCA" , punpcklqdq(xmm1, xmm2)); + TEST_INSTRUCTION("660F6C8C1A80000000" , punpcklqdq(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F6C8C1A80000000" , punpcklqdq(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F61CA" , punpcklwd(mm1, mm2)); + TEST_INSTRUCTION("0F618C1A80000000" , punpcklwd(mm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F618C1A80000000" , punpcklwd(mm1, dword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F61CA" , punpcklwd(xmm1, xmm2)); + TEST_INSTRUCTION("660F618C1A80000000" , punpcklwd(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F618C1A80000000" , punpcklwd(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0FEFCA" , pxor(mm1, mm2)); + TEST_INSTRUCTION("0FEF8C1A80000000" , pxor(mm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0FEF8C1A80000000" , pxor(mm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660FEFCA" , pxor(xmm1, xmm2)); + TEST_INSTRUCTION("660FEF8C1A80000000" , pxor(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660FEF8C1A80000000" , pxor(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F53CA" , rcpps(xmm1, xmm2)); + TEST_INSTRUCTION("0F538C1A80000000" , rcpps(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F538C1A80000000" , rcpps(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("F30F53CA" , rcpss(xmm1, xmm2)); + TEST_INSTRUCTION("F30F538C1A80000000" , rcpss(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("F30F538C1A80000000" , rcpss(xmm1, dword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F3A09CA01" , roundpd(xmm1, xmm2, 1)); + TEST_INSTRUCTION("660F3A098C1A8000000001" , roundpd(xmm1, ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("660F3A098C1A8000000001" , roundpd(xmm1, xmmword_ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("660F3A08CA01" , roundps(xmm1, xmm2, 1)); + TEST_INSTRUCTION("660F3A088C1A8000000001" , roundps(xmm1, ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("660F3A088C1A8000000001" , roundps(xmm1, xmmword_ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("660F3A0BCA01" , roundsd(xmm1, xmm2, 1)); + TEST_INSTRUCTION("660F3A0B8C1A8000000001" , roundsd(xmm1, ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("660F3A0B8C1A8000000001" , roundsd(xmm1, qword_ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("660F3A0ACA01" , roundss(xmm1, xmm2, 1)); + TEST_INSTRUCTION("660F3A0A8C1A8000000001" , roundss(xmm1, ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("660F3A0A8C1A8000000001" , roundss(xmm1, dword_ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("0F52CA" , rsqrtps(xmm1, xmm2)); + TEST_INSTRUCTION("0F528C1A80000000" , rsqrtps(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F528C1A80000000" , rsqrtps(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("F30F52CA" , rsqrtss(xmm1, xmm2)); + TEST_INSTRUCTION("F30F528C1A80000000" , rsqrtss(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("F30F528C1A80000000" , rsqrtss(xmm1, dword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F38C9CA" , sha1msg1(xmm1, xmm2)); + TEST_INSTRUCTION("0F38C98C1A80000000" , sha1msg1(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F38C98C1A80000000" , sha1msg1(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F38CACA" , sha1msg2(xmm1, xmm2)); + TEST_INSTRUCTION("0F38CA8C1A80000000" , sha1msg2(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F38CA8C1A80000000" , sha1msg2(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F38C8CA" , sha1nexte(xmm1, xmm2)); + TEST_INSTRUCTION("0F38C88C1A80000000" , sha1nexte(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F38C88C1A80000000" , sha1nexte(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F3ACCCA01" , sha1rnds4(xmm1, xmm2, 1)); + TEST_INSTRUCTION("0F3ACC8C1A8000000001" , sha1rnds4(xmm1, ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("0F3ACC8C1A8000000001" , sha1rnds4(xmm1, xmmword_ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("0F38CCCA" , sha256msg1(xmm1, xmm2)); + TEST_INSTRUCTION("0F38CC8C1A80000000" , sha256msg1(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F38CC8C1A80000000" , sha256msg1(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F38CDCA" , sha256msg2(xmm1, xmm2)); + TEST_INSTRUCTION("0F38CD8C1A80000000" , sha256msg2(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F38CD8C1A80000000" , sha256msg2(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F38CBCA" , sha256rnds2(xmm1, xmm2, xmm0)); + TEST_INSTRUCTION("0F38CB8C1A80000000" , sha256rnds2(xmm1, ptr(edx, ebx, 0, 128), xmm0)); + TEST_INSTRUCTION("0F38CB8C1A80000000" , sha256rnds2(xmm1, xmmword_ptr(edx, ebx, 0, 128), xmm0)); + TEST_INSTRUCTION("660FC6CA01" , shufpd(xmm1, xmm2, 1)); + TEST_INSTRUCTION("660FC68C1A8000000001" , shufpd(xmm1, ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("660FC68C1A8000000001" , shufpd(xmm1, xmmword_ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("0FC6CA01" , shufps(xmm1, xmm2, 1)); + TEST_INSTRUCTION("0FC68C1A8000000001" , shufps(xmm1, ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("0FC68C1A8000000001" , shufps(xmm1, xmmword_ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("660F51CA" , sqrtpd(xmm1, xmm2)); + TEST_INSTRUCTION("660F518C1A80000000" , sqrtpd(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F518C1A80000000" , sqrtpd(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F51CA" , sqrtps(xmm1, xmm2)); + TEST_INSTRUCTION("0F518C1A80000000" , sqrtps(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F518C1A80000000" , sqrtps(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("F20F51CA" , sqrtsd(xmm1, xmm2)); + TEST_INSTRUCTION("F20F518C1A80000000" , sqrtsd(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("F20F518C1A80000000" , sqrtsd(xmm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("F30F51CA" , sqrtss(xmm1, xmm2)); + TEST_INSTRUCTION("F30F518C1A80000000" , sqrtss(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("F30F518C1A80000000" , sqrtss(xmm1, dword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F5CCA" , subpd(xmm1, xmm2)); + TEST_INSTRUCTION("660F5C8C1A80000000" , subpd(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F5C8C1A80000000" , subpd(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F5CCA" , subps(xmm1, xmm2)); + TEST_INSTRUCTION("0F5C8C1A80000000" , subps(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F5C8C1A80000000" , subps(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("F20F5CCA" , subsd(xmm1, xmm2)); + TEST_INSTRUCTION("F20F5C8C1A80000000" , subsd(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("F20F5C8C1A80000000" , subsd(xmm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("F30F5CCA" , subss(xmm1, xmm2)); + TEST_INSTRUCTION("F30F5C8C1A80000000" , subss(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("F30F5C8C1A80000000" , subss(xmm1, dword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F2ECA" , ucomisd(xmm1, xmm2)); + TEST_INSTRUCTION("660F2E8C1A80000000" , ucomisd(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F2E8C1A80000000" , ucomisd(xmm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F2ECA" , ucomiss(xmm1, xmm2)); + TEST_INSTRUCTION("0F2E8C1A80000000" , ucomiss(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F2E8C1A80000000" , ucomiss(xmm1, dword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F15CA" , unpckhpd(xmm1, xmm2)); + TEST_INSTRUCTION("660F158C1A80000000" , unpckhpd(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F158C1A80000000" , unpckhpd(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F15CA" , unpckhps(xmm1, xmm2)); + TEST_INSTRUCTION("0F158C1A80000000" , unpckhps(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F158C1A80000000" , unpckhps(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F14CA" , unpcklpd(xmm1, xmm2)); + TEST_INSTRUCTION("660F148C1A80000000" , unpcklpd(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F148C1A80000000" , unpcklpd(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F14CA" , unpcklps(xmm1, xmm2)); + TEST_INSTRUCTION("0F148C1A80000000" , unpcklps(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F148C1A80000000" , unpcklps(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F57CA" , xorpd(xmm1, xmm2)); + TEST_INSTRUCTION("660F578C1A80000000" , xorpd(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("660F578C1A80000000" , xorpd(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F57CA" , xorps(xmm1, xmm2)); + TEST_INSTRUCTION("0F578C1A80000000" , xorps(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("0F578C1A80000000" , xorps(xmm1, xmmword_ptr(edx, ebx, 0, 128))); +} + +static void ASMJIT_NOINLINE testX86AssemblerAVX(AssemblerTester<x86::Assembler>& tester) noexcept { + using namespace x86; + + TEST_INSTRUCTION("C5ED4ACB" , kaddb(k1, k2, k3)); + TEST_INSTRUCTION("C4E1ED4ACB" , kaddd(k1, k2, k3)); + TEST_INSTRUCTION("C4E1EC4ACB" , kaddq(k1, k2, k3)); + TEST_INSTRUCTION("C5EC4ACB" , kaddw(k1, k2, k3)); + TEST_INSTRUCTION("C5ED41CB" , kandb(k1, k2, k3)); + TEST_INSTRUCTION("C4E1ED41CB" , kandd(k1, k2, k3)); + TEST_INSTRUCTION("C5ED42CB" , kandnb(k1, k2, k3)); + TEST_INSTRUCTION("C4E1ED42CB" , kandnd(k1, k2, k3)); + TEST_INSTRUCTION("C4E1EC42CB" , kandnq(k1, k2, k3)); + TEST_INSTRUCTION("C5EC42CB" , kandnw(k1, k2, k3)); + TEST_INSTRUCTION("C4E1EC41CB" , kandq(k1, k2, k3)); + TEST_INSTRUCTION("C5EC41CB" , kandw(k1, k2, k3)); + TEST_INSTRUCTION("C5F992CA" , kmovb(k1, edx)); + TEST_INSTRUCTION("C5F990CA" , kmovb(k1, k2)); + TEST_INSTRUCTION("C5F9908C1A80000000" , kmovb(k1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C5F9908C1A80000000" , kmovb(k1, byte_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C5F993CA" , kmovb(ecx, k2)); + TEST_INSTRUCTION("C5F9919C1180000000" , kmovb(ptr(ecx, edx, 0, 128), k3)); + TEST_INSTRUCTION("C5F9919C1180000000" , kmovb(byte_ptr(ecx, edx, 0, 128), k3)); + TEST_INSTRUCTION("C5FB92CA" , kmovd(k1, edx)); + TEST_INSTRUCTION("C4E1F990CA" , kmovd(k1, k2)); + TEST_INSTRUCTION("C4E1F9908C1A80000000" , kmovd(k1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C4E1F9908C1A80000000" , kmovd(k1, dword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C5FB93CA" , kmovd(ecx, k2)); + TEST_INSTRUCTION("C4E1F9919C1180000000" , kmovd(ptr(ecx, edx, 0, 128), k3)); + TEST_INSTRUCTION("C4E1F9919C1180000000" , kmovd(dword_ptr(ecx, edx, 0, 128), k3)); + TEST_INSTRUCTION("C4E1F890CA" , kmovq(k1, k2)); + TEST_INSTRUCTION("C4E1F8908C1A80000000" , kmovq(k1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C4E1F8908C1A80000000" , kmovq(k1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C4E1F8919C1180000000" , kmovq(ptr(ecx, edx, 0, 128), k3)); + TEST_INSTRUCTION("C4E1F8919C1180000000" , kmovq(qword_ptr(ecx, edx, 0, 128), k3)); + TEST_INSTRUCTION("C5F892CA" , kmovw(k1, edx)); + TEST_INSTRUCTION("C5F890CA" , kmovw(k1, k2)); + TEST_INSTRUCTION("C5F8908C1A80000000" , kmovw(k1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C5F8908C1A80000000" , kmovw(k1, word_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C5F893CA" , kmovw(ecx, k2)); + TEST_INSTRUCTION("C5F8919C1180000000" , kmovw(ptr(ecx, edx, 0, 128), k3)); + TEST_INSTRUCTION("C5F8919C1180000000" , kmovw(word_ptr(ecx, edx, 0, 128), k3)); + TEST_INSTRUCTION("C5F944CA" , knotb(k1, k2)); + TEST_INSTRUCTION("C4E1F944CA" , knotd(k1, k2)); + TEST_INSTRUCTION("C4E1F844CA" , knotq(k1, k2)); + TEST_INSTRUCTION("C5F844CA" , knotw(k1, k2)); + TEST_INSTRUCTION("C5ED45CB" , korb(k1, k2, k3)); + TEST_INSTRUCTION("C4E1ED45CB" , kord(k1, k2, k3)); + TEST_INSTRUCTION("C4E1EC45CB" , korq(k1, k2, k3)); + TEST_INSTRUCTION("C5F998CA" , kortestb(k1, k2)); + TEST_INSTRUCTION("C4E1F998CA" , kortestd(k1, k2)); + TEST_INSTRUCTION("C4E1F898CA" , kortestq(k1, k2)); + TEST_INSTRUCTION("C5F898CA" , kortestw(k1, k2)); + TEST_INSTRUCTION("C5EC45CB" , korw(k1, k2, k3)); + TEST_INSTRUCTION("C4E37932CA01" , kshiftlb(k1, k2, 1)); + TEST_INSTRUCTION("C4E37933CA01" , kshiftld(k1, k2, 1)); + TEST_INSTRUCTION("C4E3F933CA01" , kshiftlq(k1, k2, 1)); + TEST_INSTRUCTION("C4E3F932CA01" , kshiftlw(k1, k2, 1)); + TEST_INSTRUCTION("C4E37930CA01" , kshiftrb(k1, k2, 1)); + TEST_INSTRUCTION("C4E37931CA01" , kshiftrd(k1, k2, 1)); + TEST_INSTRUCTION("C4E3F931CA01" , kshiftrq(k1, k2, 1)); + TEST_INSTRUCTION("C4E3F930CA01" , kshiftrw(k1, k2, 1)); + TEST_INSTRUCTION("C5F999CA" , ktestb(k1, k2)); + TEST_INSTRUCTION("C4E1F999CA" , ktestd(k1, k2)); + TEST_INSTRUCTION("C4E1F899CA" , ktestq(k1, k2)); + TEST_INSTRUCTION("C5F899CA" , ktestw(k1, k2)); + TEST_INSTRUCTION("C5ED4BCB" , kunpckbw(k1, k2, k3)); + TEST_INSTRUCTION("C4E1EC4BCB" , kunpckdq(k1, k2, k3)); + TEST_INSTRUCTION("C5EC4BCB" , kunpckwd(k1, k2, k3)); + TEST_INSTRUCTION("C5ED46CB" , kxnorb(k1, k2, k3)); + TEST_INSTRUCTION("C4E1ED46CB" , kxnord(k1, k2, k3)); + TEST_INSTRUCTION("C4E1EC46CB" , kxnorq(k1, k2, k3)); + TEST_INSTRUCTION("C5EC46CB" , kxnorw(k1, k2, k3)); + TEST_INSTRUCTION("C5ED47CB" , kxorb(k1, k2, k3)); + TEST_INSTRUCTION("C4E1ED47CB" , kxord(k1, k2, k3)); + TEST_INSTRUCTION("C4E1EC47CB" , kxorq(k1, k2, k3)); + TEST_INSTRUCTION("C5EC47CB" , kxorw(k1, k2, k3)); + TEST_INSTRUCTION("62F25F489A4C1A08" , v4fmaddps(zmm1, zmm4, zmm5, zmm6, zmm7, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F25F489A4C1A08" , v4fmaddps(zmm1, zmm4, zmm5, zmm6, zmm7, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F25F089B4C1A08" , v4fmaddss(xmm1, xmm4, xmm5, xmm6, xmm7, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F25F089B4C1A08" , v4fmaddss(xmm1, xmm4, xmm5, xmm6, xmm7, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F25F48AA4C1A08" , v4fnmaddps(zmm1, zmm4, zmm5, zmm6, zmm7, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F25F48AA4C1A08" , v4fnmaddps(zmm1, zmm4, zmm5, zmm6, zmm7, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F25F08AB4C1A08" , v4fnmaddss(xmm1, xmm4, xmm5, xmm6, xmm7, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F25F08AB4C1A08" , v4fnmaddss(xmm1, xmm4, xmm5, xmm6, xmm7, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C5E958CB" , vaddpd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5E9588C2B80000000" , vaddpd(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5E9588C2B80000000" , vaddpd(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5ED58CB" , vaddpd(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C5ED588C2B80000000" , vaddpd(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5ED588C2B80000000" , vaddpd(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F1ED4858CB" , vaddpd(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F1ED48584C2B02" , vaddpd(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F1ED48584C2B02" , vaddpd(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5E858CB" , vaddps(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5E8588C2B80000000" , vaddps(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5E8588C2B80000000" , vaddps(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5EC58CB" , vaddps(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C5EC588C2B80000000" , vaddps(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5EC588C2B80000000" , vaddps(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16C4858CB" , vaddps(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F16C48584C2B02" , vaddps(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16C48584C2B02" , vaddps(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5EB58CB" , vaddsd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5EB588C2B80000000" , vaddsd(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5EB588C2B80000000" , vaddsd(xmm1, xmm2, qword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5EA58CB" , vaddss(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5EA588C2B80000000" , vaddss(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5EA588C2B80000000" , vaddss(xmm1, xmm2, dword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5E9D0CB" , vaddsubpd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5E9D08C2B80000000" , vaddsubpd(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5E9D08C2B80000000" , vaddsubpd(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5EDD0CB" , vaddsubpd(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C5EDD08C2B80000000" , vaddsubpd(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5EDD08C2B80000000" , vaddsubpd(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5EBD0CB" , vaddsubps(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5EBD08C2B80000000" , vaddsubps(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5EBD08C2B80000000" , vaddsubps(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5EFD0CB" , vaddsubps(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C5EFD08C2B80000000" , vaddsubps(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5EFD08C2B80000000" , vaddsubps(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E269DECB" , vaesdec(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E269DE8C2B80000000" , vaesdec(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E269DE8C2B80000000" , vaesdec(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E26DDECB" , vaesdec(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C4E26DDE8C2B80000000" , vaesdec(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E26DDE8C2B80000000" , vaesdec(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D48DECB" , vaesdec(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F26D48DE4C2B02" , vaesdec(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D48DE4C2B02" , vaesdec(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E269DFCB" , vaesdeclast(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E269DF8C2B80000000" , vaesdeclast(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E269DF8C2B80000000" , vaesdeclast(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E26DDFCB" , vaesdeclast(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C4E26DDF8C2B80000000" , vaesdeclast(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E26DDF8C2B80000000" , vaesdeclast(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D48DFCB" , vaesdeclast(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F26D48DF4C2B02" , vaesdeclast(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D48DF4C2B02" , vaesdeclast(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E269DCCB" , vaesenc(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E269DC8C2B80000000" , vaesenc(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E269DC8C2B80000000" , vaesenc(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E26DDCCB" , vaesenc(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C4E26DDC8C2B80000000" , vaesenc(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E26DDC8C2B80000000" , vaesenc(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D48DCCB" , vaesenc(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F26D48DC4C2B02" , vaesenc(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D48DC4C2B02" , vaesenc(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E269DDCB" , vaesenclast(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E269DD8C2B80000000" , vaesenclast(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E269DD8C2B80000000" , vaesenclast(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E26DDDCB" , vaesenclast(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C4E26DDD8C2B80000000" , vaesenclast(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E26DDD8C2B80000000" , vaesenclast(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D48DDCB" , vaesenclast(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F26D48DD4C2B02" , vaesenclast(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D48DD4C2B02" , vaesenclast(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E279DBCA" , vaesimc(xmm1, xmm2)); + TEST_INSTRUCTION("C4E279DB8C1A80000000" , vaesimc(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C4E279DB8C1A80000000" , vaesimc(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C4E379DFCA01" , vaeskeygenassist(xmm1, xmm2, 1)); + TEST_INSTRUCTION("C4E379DF8C1A8000000001" , vaeskeygenassist(xmm1, ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("C4E379DF8C1A8000000001" , vaeskeygenassist(xmm1, xmmword_ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("62F36D0803CB01" , valignd(xmm1, xmm2, xmm3, 1)); + TEST_INSTRUCTION("62F36D08034C2B0801" , valignd(xmm1, xmm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D08034C2B0801" , valignd(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D2803CB01" , valignd(ymm1, ymm2, ymm3, 1)); + TEST_INSTRUCTION("62F36D28034C2B0401" , valignd(ymm1, ymm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D28034C2B0401" , valignd(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D4803CB01" , valignd(zmm1, zmm2, zmm3, 1)); + TEST_INSTRUCTION("62F36D48034C2B0201" , valignd(zmm1, zmm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D48034C2B0201" , valignd(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED0803CB01" , valignq(xmm1, xmm2, xmm3, 1)); + TEST_INSTRUCTION("62F3ED08034C2B0801" , valignq(xmm1, xmm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED08034C2B0801" , valignq(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED2803CB01" , valignq(ymm1, ymm2, ymm3, 1)); + TEST_INSTRUCTION("62F3ED28034C2B0401" , valignq(ymm1, ymm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED28034C2B0401" , valignq(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED4803CB01" , valignq(zmm1, zmm2, zmm3, 1)); + TEST_INSTRUCTION("62F3ED48034C2B0201" , valignq(zmm1, zmm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED48034C2B0201" , valignq(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("C5E955CB" , vandnpd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5E9558C2B80000000" , vandnpd(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5E9558C2B80000000" , vandnpd(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5ED55CB" , vandnpd(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C5ED558C2B80000000" , vandnpd(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5ED558C2B80000000" , vandnpd(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F1ED4855CB" , vandnpd(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F1ED48554C2B02" , vandnpd(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F1ED48554C2B02" , vandnpd(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5E855CB" , vandnps(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5E8558C2B80000000" , vandnps(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5E8558C2B80000000" , vandnps(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5EC55CB" , vandnps(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C5EC558C2B80000000" , vandnps(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5EC558C2B80000000" , vandnps(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16C4855CB" , vandnps(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F16C48554C2B02" , vandnps(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16C48554C2B02" , vandnps(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5E954CB" , vandpd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5E9548C2B80000000" , vandpd(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5E9548C2B80000000" , vandpd(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5ED54CB" , vandpd(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C5ED548C2B80000000" , vandpd(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5ED548C2B80000000" , vandpd(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F1ED4854CB" , vandpd(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F1ED48544C2B02" , vandpd(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F1ED48544C2B02" , vandpd(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5E854CB" , vandps(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5E8548C2B80000000" , vandps(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5E8548C2B80000000" , vandps(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5EC54CB" , vandps(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C5EC548C2B80000000" , vandps(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5EC548C2B80000000" , vandps(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16C4854CB" , vandps(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F16C48544C2B02" , vandps(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16C48544C2B02" , vandps(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED0865CB" , vblendmpd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("62F2ED08654C2B08" , vblendmpd(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED08654C2B08" , vblendmpd(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED2865CB" , vblendmpd(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("62F2ED28654C2B04" , vblendmpd(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED28654C2B04" , vblendmpd(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED4865CB" , vblendmpd(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F2ED48654C2B02" , vblendmpd(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED48654C2B02" , vblendmpd(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D0865CB" , vblendmps(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("62F26D08654C2B08" , vblendmps(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D08654C2B08" , vblendmps(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D2865CB" , vblendmps(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("62F26D28654C2B04" , vblendmps(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D28654C2B04" , vblendmps(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D4865CB" , vblendmps(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F26D48654C2B02" , vblendmps(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D48654C2B02" , vblendmps(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E3690DCB01" , vblendpd(xmm1, xmm2, xmm3, 1)); + TEST_INSTRUCTION("C4E3690D8C2B8000000001" , vblendpd(xmm1, xmm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("C4E3690D8C2B8000000001" , vblendpd(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("C4E36D0DCB01" , vblendpd(ymm1, ymm2, ymm3, 1)); + TEST_INSTRUCTION("C4E36D0D8C2B8000000001" , vblendpd(ymm1, ymm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("C4E36D0D8C2B8000000001" , vblendpd(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("C4E3690CCB01" , vblendps(xmm1, xmm2, xmm3, 1)); + TEST_INSTRUCTION("C4E3690C8C2B8000000001" , vblendps(xmm1, xmm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("C4E3690C8C2B8000000001" , vblendps(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("C4E36D0CCB01" , vblendps(ymm1, ymm2, ymm3, 1)); + TEST_INSTRUCTION("C4E36D0C8C2B8000000001" , vblendps(ymm1, ymm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("C4E36D0C8C2B8000000001" , vblendps(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("C4E3694BCB40" , vblendvpd(xmm1, xmm2, xmm3, xmm4)); + TEST_INSTRUCTION("C4E3694B8C2B8000000060" , vblendvpd(xmm1, xmm2, ptr(ebx, ebp, 0, 128), xmm6)); + TEST_INSTRUCTION("C4E3694B8C2B8000000060" , vblendvpd(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128), xmm6)); + TEST_INSTRUCTION("C4E36D4BCB40" , vblendvpd(ymm1, ymm2, ymm3, ymm4)); + TEST_INSTRUCTION("C4E36D4B8C2B8000000060" , vblendvpd(ymm1, ymm2, ptr(ebx, ebp, 0, 128), ymm6)); + TEST_INSTRUCTION("C4E36D4B8C2B8000000060" , vblendvpd(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128), ymm6)); + TEST_INSTRUCTION("C4E3694ACB40" , vblendvps(xmm1, xmm2, xmm3, xmm4)); + TEST_INSTRUCTION("C4E3694A8C2B8000000060" , vblendvps(xmm1, xmm2, ptr(ebx, ebp, 0, 128), xmm6)); + TEST_INSTRUCTION("C4E3694A8C2B8000000060" , vblendvps(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128), xmm6)); + TEST_INSTRUCTION("C4E36D4ACB40" , vblendvps(ymm1, ymm2, ymm3, ymm4)); + TEST_INSTRUCTION("C4E36D4A8C2B8000000060" , vblendvps(ymm1, ymm2, ptr(ebx, ebp, 0, 128), ymm6)); + TEST_INSTRUCTION("C4E36D4A8C2B8000000060" , vblendvps(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128), ymm6)); + TEST_INSTRUCTION("C4E27D1A8C1A80000000" , vbroadcastf128(ymm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C4E27D1A8C1A80000000" , vbroadcastf128(ymm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F27D2819CA" , vbroadcastf32x2(ymm1, xmm2)); + TEST_INSTRUCTION("62F27D28194C1A10" , vbroadcastf32x2(ymm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F27D28194C1A10" , vbroadcastf32x2(ymm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F27D4819CA" , vbroadcastf32x2(zmm1, xmm2)); + TEST_INSTRUCTION("62F27D48194C1A10" , vbroadcastf32x2(zmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F27D48194C1A10" , vbroadcastf32x2(zmm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F27D281A4C1A08" , vbroadcastf32x4(ymm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F27D281A4C1A08" , vbroadcastf32x4(ymm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F27D481A4C1A08" , vbroadcastf32x4(zmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F27D481A4C1A08" , vbroadcastf32x4(zmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F27D481B4C1A04" , vbroadcastf32x8(zmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F27D481B4C1A04" , vbroadcastf32x8(zmm1, ymmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F2FD281A4C1A08" , vbroadcastf64x2(ymm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F2FD281A4C1A08" , vbroadcastf64x2(ymm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F2FD481A4C1A08" , vbroadcastf64x2(zmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F2FD481A4C1A08" , vbroadcastf64x2(zmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F2FD481B4C1A04" , vbroadcastf64x4(zmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F2FD481B4C1A04" , vbroadcastf64x4(zmm1, ymmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C4E27D5A8C1A80000000" , vbroadcasti128(ymm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C4E27D5A8C1A80000000" , vbroadcasti128(ymm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F27D0859CA" , vbroadcasti32x2(xmm1, xmm2)); + TEST_INSTRUCTION("62F27D08594C1A10" , vbroadcasti32x2(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F27D08594C1A10" , vbroadcasti32x2(xmm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F27D2859CA" , vbroadcasti32x2(ymm1, xmm2)); + TEST_INSTRUCTION("62F27D28594C1A10" , vbroadcasti32x2(ymm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F27D28594C1A10" , vbroadcasti32x2(ymm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F27D4859CA" , vbroadcasti32x2(zmm1, xmm2)); + TEST_INSTRUCTION("62F27D48594C1A10" , vbroadcasti32x2(zmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F27D48594C1A10" , vbroadcasti32x2(zmm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F27D285A4C1A08" , vbroadcasti32x4(ymm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F27D285A4C1A08" , vbroadcasti32x4(ymm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F27D485A4C1A08" , vbroadcasti32x4(zmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F27D485A4C1A08" , vbroadcasti32x4(zmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F27D485B4C1A04" , vbroadcasti32x8(zmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F27D485B4C1A04" , vbroadcasti32x8(zmm1, ymmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F2FD285A4C1A08" , vbroadcasti64x2(ymm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F2FD285A4C1A08" , vbroadcasti64x2(ymm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F2FD485A4C1A08" , vbroadcasti64x2(zmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F2FD485A4C1A08" , vbroadcasti64x2(zmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F2FD485B4C1A04" , vbroadcasti64x4(zmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F2FD485B4C1A04" , vbroadcasti64x4(zmm1, ymmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C4E27D19CA" , vbroadcastsd(ymm1, xmm2)); + TEST_INSTRUCTION("C4E27D198C1A80000000" , vbroadcastsd(ymm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C4E27D198C1A80000000" , vbroadcastsd(ymm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F2FD4819CA" , vbroadcastsd(zmm1, xmm2)); + TEST_INSTRUCTION("62F2FD48194C1A10" , vbroadcastsd(zmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F2FD48194C1A10" , vbroadcastsd(zmm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C4E27918CA" , vbroadcastss(xmm1, xmm2)); + TEST_INSTRUCTION("C4E279188C1A80000000" , vbroadcastss(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C4E279188C1A80000000" , vbroadcastss(xmm1, dword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C4E27D18CA" , vbroadcastss(ymm1, xmm2)); + TEST_INSTRUCTION("C4E27D188C1A80000000" , vbroadcastss(ymm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C4E27D188C1A80000000" , vbroadcastss(ymm1, dword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F27D4818CA" , vbroadcastss(zmm1, xmm2)); + TEST_INSTRUCTION("62F27D48184C1A20" , vbroadcastss(zmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F27D48184C1A20" , vbroadcastss(zmm1, dword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C5E9C2CB01" , vcmppd(xmm1, xmm2, xmm3, 1)); + TEST_INSTRUCTION("C5E9C28C2B8000000001" , vcmppd(xmm1, xmm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("C5E9C28C2B8000000001" , vcmppd(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F1ED08C2CB01" , vcmppd(k1, xmm2, xmm3, 1)); + TEST_INSTRUCTION("62F1ED08C24C2B0801" , vcmppd(k1, xmm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F1ED08C24C2B0801" , vcmppd(k1, xmm2, xmmword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("C5EDC2CB01" , vcmppd(ymm1, ymm2, ymm3, 1)); + TEST_INSTRUCTION("C5EDC28C2B8000000001" , vcmppd(ymm1, ymm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("C5EDC28C2B8000000001" , vcmppd(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F1ED28C2CB01" , vcmppd(k1, ymm2, ymm3, 1)); + TEST_INSTRUCTION("62F1ED28C24C2B0401" , vcmppd(k1, ymm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F1ED28C24C2B0401" , vcmppd(k1, ymm2, ymmword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F1ED48C2CB01" , vcmppd(k1, zmm2, zmm3, 1)); + TEST_INSTRUCTION("62F1ED48C24C2B0201" , vcmppd(k1, zmm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F1ED48C24C2B0201" , vcmppd(k1, zmm2, zmmword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("C5E8C2CB01" , vcmpps(xmm1, xmm2, xmm3, 1)); + TEST_INSTRUCTION("C5E8C28C2B8000000001" , vcmpps(xmm1, xmm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("C5E8C28C2B8000000001" , vcmpps(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F16C08C2CB01" , vcmpps(k1, xmm2, xmm3, 1)); + TEST_INSTRUCTION("62F16C08C24C2B0801" , vcmpps(k1, xmm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F16C08C24C2B0801" , vcmpps(k1, xmm2, xmmword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("C5ECC2CB01" , vcmpps(ymm1, ymm2, ymm3, 1)); + TEST_INSTRUCTION("C5ECC28C2B8000000001" , vcmpps(ymm1, ymm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("C5ECC28C2B8000000001" , vcmpps(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F16C28C2CB01" , vcmpps(k1, ymm2, ymm3, 1)); + TEST_INSTRUCTION("62F16C28C24C2B0401" , vcmpps(k1, ymm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F16C28C24C2B0401" , vcmpps(k1, ymm2, ymmword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F16C48C2CB01" , vcmpps(k1, zmm2, zmm3, 1)); + TEST_INSTRUCTION("62F16C48C24C2B0201" , vcmpps(k1, zmm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F16C48C24C2B0201" , vcmpps(k1, zmm2, zmmword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("C5EBC2CB01" , vcmpsd(xmm1, xmm2, xmm3, 1)); + TEST_INSTRUCTION("C5EBC28C2B8000000001" , vcmpsd(xmm1, xmm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("C5EBC28C2B8000000001" , vcmpsd(xmm1, xmm2, qword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F1EF08C2CB01" , vcmpsd(k1, xmm2, xmm3, 1)); + TEST_INSTRUCTION("62F1EF08C24C2B1001" , vcmpsd(k1, xmm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F1EF08C24C2B1001" , vcmpsd(k1, xmm2, qword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("C5EAC2CB01" , vcmpss(xmm1, xmm2, xmm3, 1)); + TEST_INSTRUCTION("C5EAC28C2B8000000001" , vcmpss(xmm1, xmm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("C5EAC28C2B8000000001" , vcmpss(xmm1, xmm2, dword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F16E08C2CB01" , vcmpss(k1, xmm2, xmm3, 1)); + TEST_INSTRUCTION("62F16E08C24C2B2001" , vcmpss(k1, xmm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F16E08C24C2B2001" , vcmpss(k1, xmm2, dword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("C5F92FCA" , vcomisd(xmm1, xmm2)); + TEST_INSTRUCTION("C5F92F8C1A80000000" , vcomisd(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C5F92F8C1A80000000" , vcomisd(xmm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C5F82FCA" , vcomiss(xmm1, xmm2)); + TEST_INSTRUCTION("C5F82F8C1A80000000" , vcomiss(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C5F82F8C1A80000000" , vcomiss(xmm1, dword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F2FD088AD1" , vcompresspd(xmm1, xmm2)); + TEST_INSTRUCTION("62F2FD088A5C1110" , vcompresspd(ptr(ecx, edx, 0, 128), xmm3)); + TEST_INSTRUCTION("62F2FD088A5C1110" , vcompresspd(xmmword_ptr(ecx, edx, 0, 128), xmm3)); + TEST_INSTRUCTION("62F2FD288AD1" , vcompresspd(ymm1, ymm2)); + TEST_INSTRUCTION("62F2FD288A5C1110" , vcompresspd(ptr(ecx, edx, 0, 128), ymm3)); + TEST_INSTRUCTION("62F2FD288A5C1110" , vcompresspd(ymmword_ptr(ecx, edx, 0, 128), ymm3)); + TEST_INSTRUCTION("62F2FD488AD1" , vcompresspd(zmm1, zmm2)); + TEST_INSTRUCTION("62F2FD488A5C1110" , vcompresspd(ptr(ecx, edx, 0, 128), zmm3)); + TEST_INSTRUCTION("62F2FD488A5C1110" , vcompresspd(zmmword_ptr(ecx, edx, 0, 128), zmm3)); + TEST_INSTRUCTION("62F27D088AD1" , vcompressps(xmm1, xmm2)); + TEST_INSTRUCTION("62F27D088A5C1120" , vcompressps(ptr(ecx, edx, 0, 128), xmm3)); + TEST_INSTRUCTION("62F27D088A5C1120" , vcompressps(xmmword_ptr(ecx, edx, 0, 128), xmm3)); + TEST_INSTRUCTION("62F27D288AD1" , vcompressps(ymm1, ymm2)); + TEST_INSTRUCTION("62F27D288A5C1120" , vcompressps(ptr(ecx, edx, 0, 128), ymm3)); + TEST_INSTRUCTION("62F27D288A5C1120" , vcompressps(ymmword_ptr(ecx, edx, 0, 128), ymm3)); + TEST_INSTRUCTION("62F27D488AD1" , vcompressps(zmm1, zmm2)); + TEST_INSTRUCTION("62F27D488A5C1120" , vcompressps(ptr(ecx, edx, 0, 128), zmm3)); + TEST_INSTRUCTION("62F27D488A5C1120" , vcompressps(zmmword_ptr(ecx, edx, 0, 128), zmm3)); + TEST_INSTRUCTION("C5FAE6CA" , vcvtdq2pd(xmm1, xmm2)); + TEST_INSTRUCTION("C5FAE68C1A80000000" , vcvtdq2pd(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C5FAE68C1A80000000" , vcvtdq2pd(xmm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C5FEE6CA" , vcvtdq2pd(ymm1, xmm2)); + TEST_INSTRUCTION("C5FEE68C1A80000000" , vcvtdq2pd(ymm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C5FEE68C1A80000000" , vcvtdq2pd(ymm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F17E48E6CA" , vcvtdq2pd(zmm1, ymm2)); + TEST_INSTRUCTION("62F17E48E64C1A04" , vcvtdq2pd(zmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F17E48E64C1A04" , vcvtdq2pd(zmm1, ymmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C5F85BCA" , vcvtdq2ps(xmm1, xmm2)); + TEST_INSTRUCTION("C5F85B8C1A80000000" , vcvtdq2ps(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C5F85B8C1A80000000" , vcvtdq2ps(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C5FC5BCA" , vcvtdq2ps(ymm1, ymm2)); + TEST_INSTRUCTION("C5FC5B8C1A80000000" , vcvtdq2ps(ymm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C5FC5B8C1A80000000" , vcvtdq2ps(ymm1, ymmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F17C485BCA" , vcvtdq2ps(zmm1, zmm2)); + TEST_INSTRUCTION("62F17C485B4C1A02" , vcvtdq2ps(zmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F17C485B4C1A02" , vcvtdq2ps(zmm1, zmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F26F0872CB" , vcvtne2ps2bf16(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("62F26F08724C2B08" , vcvtne2ps2bf16(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26F08724C2B08" , vcvtne2ps2bf16(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26F2872CB" , vcvtne2ps2bf16(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("62F26F28724C2B04" , vcvtne2ps2bf16(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26F28724C2B04" , vcvtne2ps2bf16(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26F4872CB" , vcvtne2ps2bf16(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F26F48724C2B02" , vcvtne2ps2bf16(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26F48724C2B02" , vcvtne2ps2bf16(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F27E0872CA" , vcvtneps2bf16(xmm1, xmm2)); + TEST_INSTRUCTION("62F27E2872CA" , vcvtneps2bf16(xmm1, ymm2)); + TEST_INSTRUCTION("62F27E08724C1A08" , vcvtneps2bf16(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F27E28724C1A04" , vcvtneps2bf16(xmm1, ymmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F27E4872CA" , vcvtneps2bf16(ymm1, zmm2)); + TEST_INSTRUCTION("62F27E48724C1A02" , vcvtneps2bf16(ymm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F27E48724C1A02" , vcvtneps2bf16(ymm1, zmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C5FBE6CA" , vcvtpd2dq(xmm1, xmm2)); + TEST_INSTRUCTION("C5FFE6CA" , vcvtpd2dq(xmm1, ymm2)); + TEST_INSTRUCTION("C5FBE68C1A80000000" , vcvtpd2dq(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C5FFE68C1A80000000" , vcvtpd2dq(xmm1, ymmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F1FF48E6CA" , vcvtpd2dq(ymm1, zmm2)); + TEST_INSTRUCTION("62F1FF48E64C1A02" , vcvtpd2dq(ymm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F1FF48E64C1A02" , vcvtpd2dq(ymm1, zmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C5F95ACA" , vcvtpd2ps(xmm1, xmm2)); + TEST_INSTRUCTION("C5FD5ACA" , vcvtpd2ps(xmm1, ymm2)); + TEST_INSTRUCTION("C5F95A8C1A80000000" , vcvtpd2ps(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C5FD5A8C1A80000000" , vcvtpd2ps(xmm1, ymmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F1FD485ACA" , vcvtpd2ps(ymm1, zmm2)); + TEST_INSTRUCTION("62F1FD485A4C1A02" , vcvtpd2ps(ymm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F1FD485A4C1A02" , vcvtpd2ps(ymm1, zmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F1FD087BCA" , vcvtpd2qq(xmm1, xmm2)); + TEST_INSTRUCTION("62F1FD087B4C1A08" , vcvtpd2qq(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F1FD087B4C1A08" , vcvtpd2qq(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F1FD287BCA" , vcvtpd2qq(ymm1, ymm2)); + TEST_INSTRUCTION("62F1FD287B4C1A04" , vcvtpd2qq(ymm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F1FD287B4C1A04" , vcvtpd2qq(ymm1, ymmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F1FD487BCA" , vcvtpd2qq(zmm1, zmm2)); + TEST_INSTRUCTION("62F1FD487B4C1A02" , vcvtpd2qq(zmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F1FD487B4C1A02" , vcvtpd2qq(zmm1, zmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F1FC0879CA" , vcvtpd2udq(xmm1, xmm2)); + TEST_INSTRUCTION("62F1FC2879CA" , vcvtpd2udq(xmm1, ymm2)); + TEST_INSTRUCTION("62F1FC08794C1A08" , vcvtpd2udq(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F1FC28794C1A04" , vcvtpd2udq(xmm1, ymmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F1FC4879CA" , vcvtpd2udq(ymm1, zmm2)); + TEST_INSTRUCTION("62F1FC48794C1A02" , vcvtpd2udq(ymm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F1FC48794C1A02" , vcvtpd2udq(ymm1, zmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F1FD0879CA" , vcvtpd2uqq(xmm1, xmm2)); + TEST_INSTRUCTION("62F1FD08794C1A08" , vcvtpd2uqq(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F1FD08794C1A08" , vcvtpd2uqq(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F1FD2879CA" , vcvtpd2uqq(ymm1, ymm2)); + TEST_INSTRUCTION("62F1FD28794C1A04" , vcvtpd2uqq(ymm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F1FD28794C1A04" , vcvtpd2uqq(ymm1, ymmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F1FD4879CA" , vcvtpd2uqq(zmm1, zmm2)); + TEST_INSTRUCTION("62F1FD48794C1A02" , vcvtpd2uqq(zmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F1FD48794C1A02" , vcvtpd2uqq(zmm1, zmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C4E27913CA" , vcvtph2ps(xmm1, xmm2)); + TEST_INSTRUCTION("C4E279138C1A80000000" , vcvtph2ps(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C4E279138C1A80000000" , vcvtph2ps(xmm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C4E27D13CA" , vcvtph2ps(ymm1, xmm2)); + TEST_INSTRUCTION("C4E27D138C1A80000000" , vcvtph2ps(ymm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C4E27D138C1A80000000" , vcvtph2ps(ymm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F27D4813CA" , vcvtph2ps(zmm1, ymm2)); + TEST_INSTRUCTION("62F27D48134C1A04" , vcvtph2ps(zmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F27D48134C1A04" , vcvtph2ps(zmm1, ymmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C5F95BCA" , vcvtps2dq(xmm1, xmm2)); + TEST_INSTRUCTION("C5F95B8C1A80000000" , vcvtps2dq(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C5F95B8C1A80000000" , vcvtps2dq(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C5FD5BCA" , vcvtps2dq(ymm1, ymm2)); + TEST_INSTRUCTION("C5FD5B8C1A80000000" , vcvtps2dq(ymm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C5FD5B8C1A80000000" , vcvtps2dq(ymm1, ymmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F17D485BCA" , vcvtps2dq(zmm1, zmm2)); + TEST_INSTRUCTION("62F17D485B4C1A02" , vcvtps2dq(zmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F17D485B4C1A02" , vcvtps2dq(zmm1, zmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C5F85ACA" , vcvtps2pd(xmm1, xmm2)); + TEST_INSTRUCTION("C5F85A8C1A80000000" , vcvtps2pd(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C5F85A8C1A80000000" , vcvtps2pd(xmm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C5FC5ACA" , vcvtps2pd(ymm1, xmm2)); + TEST_INSTRUCTION("C5FC5A8C1A80000000" , vcvtps2pd(ymm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C5FC5A8C1A80000000" , vcvtps2pd(ymm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F17C485ACA" , vcvtps2pd(zmm1, ymm2)); + TEST_INSTRUCTION("62F17C485A4C1A04" , vcvtps2pd(zmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F17C485A4C1A04" , vcvtps2pd(zmm1, ymmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C4E3791DD101" , vcvtps2ph(xmm1, xmm2, 1)); + TEST_INSTRUCTION("C4E3791D9C118000000001" , vcvtps2ph(ptr(ecx, edx, 0, 128), xmm3, 1)); + TEST_INSTRUCTION("C4E3791D9C118000000001" , vcvtps2ph(qword_ptr(ecx, edx, 0, 128), xmm3, 1)); + TEST_INSTRUCTION("C4E37D1DD101" , vcvtps2ph(xmm1, ymm2, 1)); + TEST_INSTRUCTION("C4E37D1D9C118000000001" , vcvtps2ph(ptr(ecx, edx, 0, 128), ymm3, 1)); + TEST_INSTRUCTION("C4E37D1D9C118000000001" , vcvtps2ph(xmmword_ptr(ecx, edx, 0, 128), ymm3, 1)); + TEST_INSTRUCTION("62F37D481DD101" , vcvtps2ph(ymm1, zmm2, 1)); + TEST_INSTRUCTION("62F37D481D5C110401" , vcvtps2ph(ptr(ecx, edx, 0, 128), zmm3, 1)); + TEST_INSTRUCTION("62F37D481D5C110401" , vcvtps2ph(ymmword_ptr(ecx, edx, 0, 128), zmm3, 1)); + TEST_INSTRUCTION("62F17D087BCA" , vcvtps2qq(xmm1, xmm2)); + TEST_INSTRUCTION("62F17D087B4C1A10" , vcvtps2qq(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F17D087B4C1A10" , vcvtps2qq(xmm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F17D287BCA" , vcvtps2qq(ymm1, xmm2)); + TEST_INSTRUCTION("62F17D287B4C1A08" , vcvtps2qq(ymm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F17D287B4C1A08" , vcvtps2qq(ymm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F17D487BCA" , vcvtps2qq(zmm1, ymm2)); + TEST_INSTRUCTION("62F17D487B4C1A04" , vcvtps2qq(zmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F17D487B4C1A04" , vcvtps2qq(zmm1, ymmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F17C0879CA" , vcvtps2udq(xmm1, xmm2)); + TEST_INSTRUCTION("62F17C08794C1A08" , vcvtps2udq(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F17C08794C1A08" , vcvtps2udq(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F17C2879CA" , vcvtps2udq(ymm1, ymm2)); + TEST_INSTRUCTION("62F17C28794C1A04" , vcvtps2udq(ymm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F17C28794C1A04" , vcvtps2udq(ymm1, ymmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F17C4879CA" , vcvtps2udq(zmm1, zmm2)); + TEST_INSTRUCTION("62F17C48794C1A02" , vcvtps2udq(zmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F17C48794C1A02" , vcvtps2udq(zmm1, zmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F17D0879CA" , vcvtps2uqq(xmm1, xmm2)); + TEST_INSTRUCTION("62F17D08794C1A10" , vcvtps2uqq(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F17D08794C1A10" , vcvtps2uqq(xmm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F17D2879CA" , vcvtps2uqq(ymm1, xmm2)); + TEST_INSTRUCTION("62F17D28794C1A08" , vcvtps2uqq(ymm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F17D28794C1A08" , vcvtps2uqq(ymm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F17D4879CA" , vcvtps2uqq(zmm1, ymm2)); + TEST_INSTRUCTION("62F17D48794C1A04" , vcvtps2uqq(zmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F17D48794C1A04" , vcvtps2uqq(zmm1, ymmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F1FE08E6CA" , vcvtqq2pd(xmm1, xmm2)); + TEST_INSTRUCTION("62F1FE08E64C1A08" , vcvtqq2pd(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F1FE08E64C1A08" , vcvtqq2pd(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F1FE28E6CA" , vcvtqq2pd(ymm1, ymm2)); + TEST_INSTRUCTION("62F1FE28E64C1A04" , vcvtqq2pd(ymm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F1FE28E64C1A04" , vcvtqq2pd(ymm1, ymmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F1FE48E6CA" , vcvtqq2pd(zmm1, zmm2)); + TEST_INSTRUCTION("62F1FE48E64C1A02" , vcvtqq2pd(zmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F1FE48E64C1A02" , vcvtqq2pd(zmm1, zmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F1FC085BCA" , vcvtqq2ps(xmm1, xmm2)); + TEST_INSTRUCTION("62F1FC285BCA" , vcvtqq2ps(xmm1, ymm2)); + TEST_INSTRUCTION("62F1FC085B4C1A08" , vcvtqq2ps(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F1FC285B4C1A04" , vcvtqq2ps(xmm1, ymmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F1FC485BCA" , vcvtqq2ps(ymm1, zmm2)); + TEST_INSTRUCTION("62F1FC485B4C1A02" , vcvtqq2ps(ymm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F1FC485B4C1A02" , vcvtqq2ps(ymm1, zmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C5FB2DCA" , vcvtsd2si(ecx, xmm2)); + TEST_INSTRUCTION("C5FB2D8C1A80000000" , vcvtsd2si(ecx, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C5FB2D8C1A80000000" , vcvtsd2si(ecx, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C5EB5ACB" , vcvtsd2ss(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5EB5A8C2B80000000" , vcvtsd2ss(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5EB5A8C2B80000000" , vcvtsd2ss(xmm1, xmm2, qword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F17F0879CA" , vcvtsd2usi(ecx, xmm2)); + TEST_INSTRUCTION("62F17F08794C1A10" , vcvtsd2usi(ecx, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F17F08794C1A10" , vcvtsd2usi(ecx, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C5EB2ACB" , vcvtsi2sd(xmm1, xmm2, ebx)); + TEST_INSTRUCTION("C5EB2A8C2B80000000" , vcvtsi2sd(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5EB2A8C2B80000000" , vcvtsi2sd(xmm1, xmm2, dword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E1EB2A8C2B80000000" , vcvtsi2sd(xmm1, xmm2, qword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5EA2ACB" , vcvtsi2ss(xmm1, xmm2, ebx)); + TEST_INSTRUCTION("C5EA2A8C2B80000000" , vcvtsi2ss(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5EA2A8C2B80000000" , vcvtsi2ss(xmm1, xmm2, dword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E1EA2A8C2B80000000" , vcvtsi2ss(xmm1, xmm2, qword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5EA5ACB" , vcvtss2sd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5EA5A8C2B80000000" , vcvtss2sd(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5EA5A8C2B80000000" , vcvtss2sd(xmm1, xmm2, dword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5FA2DCA" , vcvtss2si(ecx, xmm2)); + TEST_INSTRUCTION("C5FA2D8C1A80000000" , vcvtss2si(ecx, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C5FA2D8C1A80000000" , vcvtss2si(ecx, dword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F17E0879CA" , vcvtss2usi(ecx, xmm2)); + TEST_INSTRUCTION("62F17E08794C1A20" , vcvtss2usi(ecx, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F17E08794C1A20" , vcvtss2usi(ecx, dword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C5F9E6CA" , vcvttpd2dq(xmm1, xmm2)); + TEST_INSTRUCTION("C5FDE6CA" , vcvttpd2dq(xmm1, ymm2)); + TEST_INSTRUCTION("C5F9E68C1A80000000" , vcvttpd2dq(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C5FDE68C1A80000000" , vcvttpd2dq(xmm1, ymmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F1FD48E6CA" , vcvttpd2dq(ymm1, zmm2)); + TEST_INSTRUCTION("62F1FD48E64C1A02" , vcvttpd2dq(ymm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F1FD48E64C1A02" , vcvttpd2dq(ymm1, zmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F1FD087ACA" , vcvttpd2qq(xmm1, xmm2)); + TEST_INSTRUCTION("62F1FD087A4C1A08" , vcvttpd2qq(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F1FD087A4C1A08" , vcvttpd2qq(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F1FD287ACA" , vcvttpd2qq(ymm1, ymm2)); + TEST_INSTRUCTION("62F1FD287A4C1A04" , vcvttpd2qq(ymm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F1FD287A4C1A04" , vcvttpd2qq(ymm1, ymmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F1FD487ACA" , vcvttpd2qq(zmm1, zmm2)); + TEST_INSTRUCTION("62F1FD487A4C1A02" , vcvttpd2qq(zmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F1FD487A4C1A02" , vcvttpd2qq(zmm1, zmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F1FC0878CA" , vcvttpd2udq(xmm1, xmm2)); + TEST_INSTRUCTION("62F1FC2878CA" , vcvttpd2udq(xmm1, ymm2)); + TEST_INSTRUCTION("62F1FC08784C1A08" , vcvttpd2udq(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F1FC28784C1A04" , vcvttpd2udq(xmm1, ymmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F1FC4878CA" , vcvttpd2udq(ymm1, zmm2)); + TEST_INSTRUCTION("62F1FC48784C1A02" , vcvttpd2udq(ymm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F1FC48784C1A02" , vcvttpd2udq(ymm1, zmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F1FD0878CA" , vcvttpd2uqq(xmm1, xmm2)); + TEST_INSTRUCTION("62F1FD08784C1A08" , vcvttpd2uqq(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F1FD08784C1A08" , vcvttpd2uqq(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F1FD2878CA" , vcvttpd2uqq(ymm1, ymm2)); + TEST_INSTRUCTION("62F1FD28784C1A04" , vcvttpd2uqq(ymm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F1FD28784C1A04" , vcvttpd2uqq(ymm1, ymmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F1FD4878CA" , vcvttpd2uqq(zmm1, zmm2)); + TEST_INSTRUCTION("62F1FD48784C1A02" , vcvttpd2uqq(zmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F1FD48784C1A02" , vcvttpd2uqq(zmm1, zmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C5FA5BCA" , vcvttps2dq(xmm1, xmm2)); + TEST_INSTRUCTION("C5FA5B8C1A80000000" , vcvttps2dq(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C5FA5B8C1A80000000" , vcvttps2dq(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C5FE5BCA" , vcvttps2dq(ymm1, ymm2)); + TEST_INSTRUCTION("C5FE5B8C1A80000000" , vcvttps2dq(ymm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C5FE5B8C1A80000000" , vcvttps2dq(ymm1, ymmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F17E485BCA" , vcvttps2dq(zmm1, zmm2)); + TEST_INSTRUCTION("62F17E485B4C1A02" , vcvttps2dq(zmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F17E485B4C1A02" , vcvttps2dq(zmm1, zmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F17D087ACA" , vcvttps2qq(xmm1, xmm2)); + TEST_INSTRUCTION("62F17D087A4C1A10" , vcvttps2qq(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F17D087A4C1A10" , vcvttps2qq(xmm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F17D287ACA" , vcvttps2qq(ymm1, xmm2)); + TEST_INSTRUCTION("62F17D287A4C1A08" , vcvttps2qq(ymm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F17D287A4C1A08" , vcvttps2qq(ymm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F17D487ACA" , vcvttps2qq(zmm1, ymm2)); + TEST_INSTRUCTION("62F17D487A4C1A04" , vcvttps2qq(zmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F17D487A4C1A04" , vcvttps2qq(zmm1, ymmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F17C0878CA" , vcvttps2udq(xmm1, xmm2)); + TEST_INSTRUCTION("62F17C08784C1A08" , vcvttps2udq(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F17C08784C1A08" , vcvttps2udq(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F17C2878CA" , vcvttps2udq(ymm1, ymm2)); + TEST_INSTRUCTION("62F17C28784C1A04" , vcvttps2udq(ymm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F17C28784C1A04" , vcvttps2udq(ymm1, ymmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F17C4878CA" , vcvttps2udq(zmm1, zmm2)); + TEST_INSTRUCTION("62F17C48784C1A02" , vcvttps2udq(zmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F17C48784C1A02" , vcvttps2udq(zmm1, zmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F17D0878CA" , vcvttps2uqq(xmm1, xmm2)); + TEST_INSTRUCTION("62F17D08784C1A10" , vcvttps2uqq(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F17D08784C1A10" , vcvttps2uqq(xmm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F17D2878CA" , vcvttps2uqq(ymm1, xmm2)); + TEST_INSTRUCTION("62F17D28784C1A08" , vcvttps2uqq(ymm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F17D28784C1A08" , vcvttps2uqq(ymm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F17D4878CA" , vcvttps2uqq(zmm1, ymm2)); + TEST_INSTRUCTION("62F17D48784C1A04" , vcvttps2uqq(zmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F17D48784C1A04" , vcvttps2uqq(zmm1, ymmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C5FB2CCA" , vcvttsd2si(ecx, xmm2)); + TEST_INSTRUCTION("C5FB2C8C1A80000000" , vcvttsd2si(ecx, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C5FB2C8C1A80000000" , vcvttsd2si(ecx, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F17F0878CA" , vcvttsd2usi(ecx, xmm2)); + TEST_INSTRUCTION("62F17F08784C1A10" , vcvttsd2usi(ecx, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F17F08784C1A10" , vcvttsd2usi(ecx, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C5FA2CCA" , vcvttss2si(ecx, xmm2)); + TEST_INSTRUCTION("C5FA2C8C1A80000000" , vcvttss2si(ecx, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C5FA2C8C1A80000000" , vcvttss2si(ecx, dword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F17E0878CA" , vcvttss2usi(ecx, xmm2)); + TEST_INSTRUCTION("62F17E08784C1A20" , vcvttss2usi(ecx, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F17E08784C1A20" , vcvttss2usi(ecx, dword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F17E087ACA" , vcvtudq2pd(xmm1, xmm2)); + TEST_INSTRUCTION("62F17E087A4C1A10" , vcvtudq2pd(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F17E087A4C1A10" , vcvtudq2pd(xmm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F17E287ACA" , vcvtudq2pd(ymm1, xmm2)); + TEST_INSTRUCTION("62F17E287A4C1A08" , vcvtudq2pd(ymm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F17E287A4C1A08" , vcvtudq2pd(ymm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F17E487ACA" , vcvtudq2pd(zmm1, ymm2)); + TEST_INSTRUCTION("62F17E487A4C1A04" , vcvtudq2pd(zmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F17E487A4C1A04" , vcvtudq2pd(zmm1, ymmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F17F087ACA" , vcvtudq2ps(xmm1, xmm2)); + TEST_INSTRUCTION("62F17F087A4C1A08" , vcvtudq2ps(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F17F087A4C1A08" , vcvtudq2ps(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F17F287ACA" , vcvtudq2ps(ymm1, ymm2)); + TEST_INSTRUCTION("62F17F287A4C1A04" , vcvtudq2ps(ymm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F17F287A4C1A04" , vcvtudq2ps(ymm1, ymmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F17F487ACA" , vcvtudq2ps(zmm1, zmm2)); + TEST_INSTRUCTION("62F17F487A4C1A02" , vcvtudq2ps(zmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F17F487A4C1A02" , vcvtudq2ps(zmm1, zmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F1FE087ACA" , vcvtuqq2pd(xmm1, xmm2)); + TEST_INSTRUCTION("62F1FE087A4C1A08" , vcvtuqq2pd(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F1FE087A4C1A08" , vcvtuqq2pd(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F1FE287ACA" , vcvtuqq2pd(ymm1, ymm2)); + TEST_INSTRUCTION("62F1FE287A4C1A04" , vcvtuqq2pd(ymm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F1FE287A4C1A04" , vcvtuqq2pd(ymm1, ymmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F1FE487ACA" , vcvtuqq2pd(zmm1, zmm2)); + TEST_INSTRUCTION("62F1FE487A4C1A02" , vcvtuqq2pd(zmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F1FE487A4C1A02" , vcvtuqq2pd(zmm1, zmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F1FF087ACA" , vcvtuqq2ps(xmm1, xmm2)); + TEST_INSTRUCTION("62F1FF287ACA" , vcvtuqq2ps(xmm1, ymm2)); + TEST_INSTRUCTION("62F1FF087A4C1A08" , vcvtuqq2ps(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F1FF287A4C1A04" , vcvtuqq2ps(xmm1, ymmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F1FF487ACA" , vcvtuqq2ps(ymm1, zmm2)); + TEST_INSTRUCTION("62F1FF487A4C1A02" , vcvtuqq2ps(ymm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F1FF487A4C1A02" , vcvtuqq2ps(ymm1, zmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F16F087BCB" , vcvtusi2sd(xmm1, xmm2, ebx)); + TEST_INSTRUCTION("62F16F087B4C2B20" , vcvtusi2sd(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16F087B4C2B20" , vcvtusi2sd(xmm1, xmm2, dword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F1EF087B4C2B10" , vcvtusi2sd(xmm1, xmm2, qword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16E087BCB" , vcvtusi2ss(xmm1, xmm2, ebx)); + TEST_INSTRUCTION("62F16E087B4C2B20" , vcvtusi2ss(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16E087B4C2B20" , vcvtusi2ss(xmm1, xmm2, dword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F1EE087B4C2B10" , vcvtusi2ss(xmm1, xmm2, qword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F36D0842CB01" , vdbpsadbw(xmm1, xmm2, xmm3, 1)); + TEST_INSTRUCTION("62F36D08424C2B0801" , vdbpsadbw(xmm1, xmm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D08424C2B0801" , vdbpsadbw(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D2842CB01" , vdbpsadbw(ymm1, ymm2, ymm3, 1)); + TEST_INSTRUCTION("62F36D28424C2B0401" , vdbpsadbw(ymm1, ymm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D28424C2B0401" , vdbpsadbw(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D4842CB01" , vdbpsadbw(zmm1, zmm2, zmm3, 1)); + TEST_INSTRUCTION("62F36D48424C2B0201" , vdbpsadbw(zmm1, zmm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D48424C2B0201" , vdbpsadbw(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("C5E95ECB" , vdivpd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5E95E8C2B80000000" , vdivpd(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5E95E8C2B80000000" , vdivpd(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5ED5ECB" , vdivpd(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C5ED5E8C2B80000000" , vdivpd(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5ED5E8C2B80000000" , vdivpd(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F1ED485ECB" , vdivpd(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F1ED485E4C2B02" , vdivpd(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F1ED485E4C2B02" , vdivpd(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5E85ECB" , vdivps(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5E85E8C2B80000000" , vdivps(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5E85E8C2B80000000" , vdivps(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5EC5ECB" , vdivps(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C5EC5E8C2B80000000" , vdivps(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5EC5E8C2B80000000" , vdivps(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16C485ECB" , vdivps(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F16C485E4C2B02" , vdivps(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16C485E4C2B02" , vdivps(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5EB5ECB" , vdivsd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5EB5E8C2B80000000" , vdivsd(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5EB5E8C2B80000000" , vdivsd(xmm1, xmm2, qword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5EA5ECB" , vdivss(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5EA5E8C2B80000000" , vdivss(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5EA5E8C2B80000000" , vdivss(xmm1, xmm2, dword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26E0852CB" , vdpbf16ps(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("62F26E08524C2B08" , vdpbf16ps(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26E08524C2B08" , vdpbf16ps(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26E2852CB" , vdpbf16ps(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("62F26E28524C2B04" , vdpbf16ps(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26E28524C2B04" , vdpbf16ps(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26E4852CB" , vdpbf16ps(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F26E48524C2B02" , vdpbf16ps(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26E48524C2B02" , vdpbf16ps(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E36941CB01" , vdppd(xmm1, xmm2, xmm3, 1)); + TEST_INSTRUCTION("C4E369418C2B8000000001" , vdppd(xmm1, xmm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("C4E369418C2B8000000001" , vdppd(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("C4E36940CB01" , vdpps(xmm1, xmm2, xmm3, 1)); + TEST_INSTRUCTION("C4E369408C2B8000000001" , vdpps(xmm1, xmm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("C4E369408C2B8000000001" , vdpps(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("C4E36D40CB01" , vdpps(ymm1, ymm2, ymm3, 1)); + TEST_INSTRUCTION("C4E36D408C2B8000000001" , vdpps(ymm1, ymm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("C4E36D408C2B8000000001" , vdpps(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F2FD48C8CA" , vexp2pd(zmm1, zmm2)); + TEST_INSTRUCTION("62F2FD48C84C1A02" , vexp2pd(zmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F2FD48C84C1A02" , vexp2pd(zmm1, zmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F27D48C8CA" , vexp2ps(zmm1, zmm2)); + TEST_INSTRUCTION("62F27D48C84C1A02" , vexp2ps(zmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F27D48C84C1A02" , vexp2ps(zmm1, zmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F2FD0888CA" , vexpandpd(xmm1, xmm2)); + TEST_INSTRUCTION("62F2FD08884C1A10" , vexpandpd(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F2FD08884C1A10" , vexpandpd(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F2FD2888CA" , vexpandpd(ymm1, ymm2)); + TEST_INSTRUCTION("62F2FD28884C1A10" , vexpandpd(ymm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F2FD28884C1A10" , vexpandpd(ymm1, ymmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F2FD4888CA" , vexpandpd(zmm1, zmm2)); + TEST_INSTRUCTION("62F2FD48884C1A10" , vexpandpd(zmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F2FD48884C1A10" , vexpandpd(zmm1, zmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F27D0888CA" , vexpandps(xmm1, xmm2)); + TEST_INSTRUCTION("62F27D08884C1A20" , vexpandps(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F27D08884C1A20" , vexpandps(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F27D2888CA" , vexpandps(ymm1, ymm2)); + TEST_INSTRUCTION("62F27D28884C1A20" , vexpandps(ymm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F27D28884C1A20" , vexpandps(ymm1, ymmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F27D4888CA" , vexpandps(zmm1, zmm2)); + TEST_INSTRUCTION("62F27D48884C1A20" , vexpandps(zmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F27D48884C1A20" , vexpandps(zmm1, zmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C4E37D19D101" , vextractf128(xmm1, ymm2, 1)); + TEST_INSTRUCTION("C4E37D199C118000000001" , vextractf128(ptr(ecx, edx, 0, 128), ymm3, 1)); + TEST_INSTRUCTION("C4E37D199C118000000001" , vextractf128(xmmword_ptr(ecx, edx, 0, 128), ymm3, 1)); + TEST_INSTRUCTION("62F37D2819D101" , vextractf32x4(xmm1, ymm2, 1)); + TEST_INSTRUCTION("62F37D4819D101" , vextractf32x4(xmm1, zmm2, 1)); + TEST_INSTRUCTION("62F37D28195C110801" , vextractf32x4(ptr(ecx, edx, 0, 128), ymm3, 1)); + TEST_INSTRUCTION("62F37D48195C110801" , vextractf32x4(ptr(ecx, edx, 0, 128), zmm3, 1)); + TEST_INSTRUCTION("62F37D28195C110801" , vextractf32x4(xmmword_ptr(ecx, edx, 0, 128), ymm3, 1)); + TEST_INSTRUCTION("62F37D48195C110801" , vextractf32x4(xmmword_ptr(ecx, edx, 0, 128), zmm3, 1)); + TEST_INSTRUCTION("62F37D481BD101" , vextractf32x8(ymm1, zmm2, 1)); + TEST_INSTRUCTION("62F37D481B5C110401" , vextractf32x8(ptr(ecx, edx, 0, 128), zmm3, 1)); + TEST_INSTRUCTION("62F37D481B5C110401" , vextractf32x8(ymmword_ptr(ecx, edx, 0, 128), zmm3, 1)); + TEST_INSTRUCTION("62F3FD2819D101" , vextractf64x2(xmm1, ymm2, 1)); + TEST_INSTRUCTION("62F3FD4819D101" , vextractf64x2(xmm1, zmm2, 1)); + TEST_INSTRUCTION("62F3FD28195C110801" , vextractf64x2(ptr(ecx, edx, 0, 128), ymm3, 1)); + TEST_INSTRUCTION("62F3FD48195C110801" , vextractf64x2(ptr(ecx, edx, 0, 128), zmm3, 1)); + TEST_INSTRUCTION("62F3FD28195C110801" , vextractf64x2(xmmword_ptr(ecx, edx, 0, 128), ymm3, 1)); + TEST_INSTRUCTION("62F3FD48195C110801" , vextractf64x2(xmmword_ptr(ecx, edx, 0, 128), zmm3, 1)); + TEST_INSTRUCTION("62F3FD481BD101" , vextractf64x4(ymm1, zmm2, 1)); + TEST_INSTRUCTION("62F3FD481B5C110401" , vextractf64x4(ptr(ecx, edx, 0, 128), zmm3, 1)); + TEST_INSTRUCTION("62F3FD481B5C110401" , vextractf64x4(ymmword_ptr(ecx, edx, 0, 128), zmm3, 1)); + TEST_INSTRUCTION("C4E37D39D101" , vextracti128(xmm1, ymm2, 1)); + TEST_INSTRUCTION("C4E37D399C118000000001" , vextracti128(ptr(ecx, edx, 0, 128), ymm3, 1)); + TEST_INSTRUCTION("C4E37D399C118000000001" , vextracti128(xmmword_ptr(ecx, edx, 0, 128), ymm3, 1)); + TEST_INSTRUCTION("62F37D2839D101" , vextracti32x4(xmm1, ymm2, 1)); + TEST_INSTRUCTION("62F37D4839D101" , vextracti32x4(xmm1, zmm2, 1)); + TEST_INSTRUCTION("62F37D28395C110801" , vextracti32x4(ptr(ecx, edx, 0, 128), ymm3, 1)); + TEST_INSTRUCTION("62F37D48395C110801" , vextracti32x4(ptr(ecx, edx, 0, 128), zmm3, 1)); + TEST_INSTRUCTION("62F37D28395C110801" , vextracti32x4(xmmword_ptr(ecx, edx, 0, 128), ymm3, 1)); + TEST_INSTRUCTION("62F37D48395C110801" , vextracti32x4(xmmword_ptr(ecx, edx, 0, 128), zmm3, 1)); + TEST_INSTRUCTION("62F37D483BD101" , vextracti32x8(ymm1, zmm2, 1)); + TEST_INSTRUCTION("62F37D483B5C110401" , vextracti32x8(ptr(ecx, edx, 0, 128), zmm3, 1)); + TEST_INSTRUCTION("62F37D483B5C110401" , vextracti32x8(ymmword_ptr(ecx, edx, 0, 128), zmm3, 1)); + TEST_INSTRUCTION("62F3FD2839D101" , vextracti64x2(xmm1, ymm2, 1)); + TEST_INSTRUCTION("62F3FD4839D101" , vextracti64x2(xmm1, zmm2, 1)); + TEST_INSTRUCTION("62F3FD28395C110801" , vextracti64x2(ptr(ecx, edx, 0, 128), ymm3, 1)); + TEST_INSTRUCTION("62F3FD48395C110801" , vextracti64x2(ptr(ecx, edx, 0, 128), zmm3, 1)); + TEST_INSTRUCTION("62F3FD28395C110801" , vextracti64x2(xmmword_ptr(ecx, edx, 0, 128), ymm3, 1)); + TEST_INSTRUCTION("62F3FD48395C110801" , vextracti64x2(xmmword_ptr(ecx, edx, 0, 128), zmm3, 1)); + TEST_INSTRUCTION("62F3FD483BD101" , vextracti64x4(ymm1, zmm2, 1)); + TEST_INSTRUCTION("62F3FD483B5C110401" , vextracti64x4(ptr(ecx, edx, 0, 128), zmm3, 1)); + TEST_INSTRUCTION("62F3FD483B5C110401" , vextracti64x4(ymmword_ptr(ecx, edx, 0, 128), zmm3, 1)); + TEST_INSTRUCTION("C4E37917D101" , vextractps(ecx, xmm2, 1)); + TEST_INSTRUCTION("C4E379179C118000000001" , vextractps(ptr(ecx, edx, 0, 128), xmm3, 1)); + TEST_INSTRUCTION("C4E379179C118000000001" , vextractps(dword_ptr(ecx, edx, 0, 128), xmm3, 1)); + TEST_INSTRUCTION("62F3ED0854CB01" , vfixupimmpd(xmm1, xmm2, xmm3, 1)); + TEST_INSTRUCTION("62F3ED08544C2B0801" , vfixupimmpd(xmm1, xmm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED08544C2B0801" , vfixupimmpd(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED2854CB01" , vfixupimmpd(ymm1, ymm2, ymm3, 1)); + TEST_INSTRUCTION("62F3ED28544C2B0401" , vfixupimmpd(ymm1, ymm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED28544C2B0401" , vfixupimmpd(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED4854CB01" , vfixupimmpd(zmm1, zmm2, zmm3, 1)); + TEST_INSTRUCTION("62F3ED48544C2B0201" , vfixupimmpd(zmm1, zmm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED48544C2B0201" , vfixupimmpd(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D0854CB01" , vfixupimmps(xmm1, xmm2, xmm3, 1)); + TEST_INSTRUCTION("62F36D08544C2B0801" , vfixupimmps(xmm1, xmm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D08544C2B0801" , vfixupimmps(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D2854CB01" , vfixupimmps(ymm1, ymm2, ymm3, 1)); + TEST_INSTRUCTION("62F36D28544C2B0401" , vfixupimmps(ymm1, ymm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D28544C2B0401" , vfixupimmps(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D4854CB01" , vfixupimmps(zmm1, zmm2, zmm3, 1)); + TEST_INSTRUCTION("62F36D48544C2B0201" , vfixupimmps(zmm1, zmm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D48544C2B0201" , vfixupimmps(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED0855CB01" , vfixupimmsd(xmm1, xmm2, xmm3, 1)); + TEST_INSTRUCTION("62F3ED08554C2B1001" , vfixupimmsd(xmm1, xmm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED08554C2B1001" , vfixupimmsd(xmm1, xmm2, qword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D0855CB01" , vfixupimmss(xmm1, xmm2, xmm3, 1)); + TEST_INSTRUCTION("62F36D08554C2B2001" , vfixupimmss(xmm1, xmm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D08554C2B2001" , vfixupimmss(xmm1, xmm2, dword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("C4E2E998CB" , vfmadd132pd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E2E9988C2B80000000" , vfmadd132pd(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E2E9988C2B80000000" , vfmadd132pd(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E2ED98CB" , vfmadd132pd(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C4E2ED988C2B80000000" , vfmadd132pd(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E2ED988C2B80000000" , vfmadd132pd(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED4898CB" , vfmadd132pd(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F2ED48984C2B02" , vfmadd132pd(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED48984C2B02" , vfmadd132pd(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E26998CB" , vfmadd132ps(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E269988C2B80000000" , vfmadd132ps(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E269988C2B80000000" , vfmadd132ps(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E26D98CB" , vfmadd132ps(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C4E26D988C2B80000000" , vfmadd132ps(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E26D988C2B80000000" , vfmadd132ps(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D4898CB" , vfmadd132ps(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F26D48984C2B02" , vfmadd132ps(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D48984C2B02" , vfmadd132ps(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E2E999CB" , vfmadd132sd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E2E9998C2B80000000" , vfmadd132sd(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E2E9998C2B80000000" , vfmadd132sd(xmm1, xmm2, qword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E26999CB" , vfmadd132ss(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E269998C2B80000000" , vfmadd132ss(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E269998C2B80000000" , vfmadd132ss(xmm1, xmm2, dword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E2E9A8CB" , vfmadd213pd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E2E9A88C2B80000000" , vfmadd213pd(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E2E9A88C2B80000000" , vfmadd213pd(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E2EDA8CB" , vfmadd213pd(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C4E2EDA88C2B80000000" , vfmadd213pd(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E2EDA88C2B80000000" , vfmadd213pd(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED48A8CB" , vfmadd213pd(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F2ED48A84C2B02" , vfmadd213pd(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED48A84C2B02" , vfmadd213pd(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E269A8CB" , vfmadd213ps(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E269A88C2B80000000" , vfmadd213ps(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E269A88C2B80000000" , vfmadd213ps(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E26DA8CB" , vfmadd213ps(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C4E26DA88C2B80000000" , vfmadd213ps(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E26DA88C2B80000000" , vfmadd213ps(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D48A8CB" , vfmadd213ps(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F26D48A84C2B02" , vfmadd213ps(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D48A84C2B02" , vfmadd213ps(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E2E9A9CB" , vfmadd213sd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E2E9A98C2B80000000" , vfmadd213sd(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E2E9A98C2B80000000" , vfmadd213sd(xmm1, xmm2, qword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E269A9CB" , vfmadd213ss(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E269A98C2B80000000" , vfmadd213ss(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E269A98C2B80000000" , vfmadd213ss(xmm1, xmm2, dword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E2E9B8CB" , vfmadd231pd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E2E9B88C2B80000000" , vfmadd231pd(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E2E9B88C2B80000000" , vfmadd231pd(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E2EDB8CB" , vfmadd231pd(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C4E2EDB88C2B80000000" , vfmadd231pd(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E2EDB88C2B80000000" , vfmadd231pd(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED48B8CB" , vfmadd231pd(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F2ED48B84C2B02" , vfmadd231pd(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED48B84C2B02" , vfmadd231pd(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E269B8CB" , vfmadd231ps(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E269B88C2B80000000" , vfmadd231ps(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E269B88C2B80000000" , vfmadd231ps(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E26DB8CB" , vfmadd231ps(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C4E26DB88C2B80000000" , vfmadd231ps(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E26DB88C2B80000000" , vfmadd231ps(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D48B8CB" , vfmadd231ps(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F26D48B84C2B02" , vfmadd231ps(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D48B84C2B02" , vfmadd231ps(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E2E9B9CB" , vfmadd231sd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E2E9B98C2B80000000" , vfmadd231sd(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E2E9B98C2B80000000" , vfmadd231sd(xmm1, xmm2, qword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E269B9CB" , vfmadd231ss(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E269B98C2B80000000" , vfmadd231ss(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E269B98C2B80000000" , vfmadd231ss(xmm1, xmm2, dword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E3E969CC30" , vfmaddpd(xmm1, xmm2, xmm3, xmm4)); + TEST_INSTRUCTION("C4E3E9698C358000000030" , vfmaddpd(xmm1, xmm2, xmm3, ptr(ebp, esi, 0, 128))); + TEST_INSTRUCTION("C4E3E9698C358000000030" , vfmaddpd(xmm1, xmm2, xmm3, xmmword_ptr(ebp, esi, 0, 128))); + TEST_INSTRUCTION("C4E369698C2B8000000060" , vfmaddpd(xmm1, xmm2, ptr(ebx, ebp, 0, 128), xmm6)); + TEST_INSTRUCTION("C4E369698C2B8000000060" , vfmaddpd(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128), xmm6)); + TEST_INSTRUCTION("C4E3ED69CC30" , vfmaddpd(ymm1, ymm2, ymm3, ymm4)); + TEST_INSTRUCTION("C4E3ED698C358000000030" , vfmaddpd(ymm1, ymm2, ymm3, ptr(ebp, esi, 0, 128))); + TEST_INSTRUCTION("C4E3ED698C358000000030" , vfmaddpd(ymm1, ymm2, ymm3, ymmword_ptr(ebp, esi, 0, 128))); + TEST_INSTRUCTION("C4E36D698C2B8000000060" , vfmaddpd(ymm1, ymm2, ptr(ebx, ebp, 0, 128), ymm6)); + TEST_INSTRUCTION("C4E36D698C2B8000000060" , vfmaddpd(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128), ymm6)); + TEST_INSTRUCTION("C4E3E968CC30" , vfmaddps(xmm1, xmm2, xmm3, xmm4)); + TEST_INSTRUCTION("C4E3E9688C358000000030" , vfmaddps(xmm1, xmm2, xmm3, ptr(ebp, esi, 0, 128))); + TEST_INSTRUCTION("C4E3E9688C358000000030" , vfmaddps(xmm1, xmm2, xmm3, xmmword_ptr(ebp, esi, 0, 128))); + TEST_INSTRUCTION("C4E369688C2B8000000060" , vfmaddps(xmm1, xmm2, ptr(ebx, ebp, 0, 128), xmm6)); + TEST_INSTRUCTION("C4E369688C2B8000000060" , vfmaddps(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128), xmm6)); + TEST_INSTRUCTION("C4E3ED68CC30" , vfmaddps(ymm1, ymm2, ymm3, ymm4)); + TEST_INSTRUCTION("C4E3ED688C358000000030" , vfmaddps(ymm1, ymm2, ymm3, ptr(ebp, esi, 0, 128))); + TEST_INSTRUCTION("C4E3ED688C358000000030" , vfmaddps(ymm1, ymm2, ymm3, ymmword_ptr(ebp, esi, 0, 128))); + TEST_INSTRUCTION("C4E36D688C2B8000000060" , vfmaddps(ymm1, ymm2, ptr(ebx, ebp, 0, 128), ymm6)); + TEST_INSTRUCTION("C4E36D688C2B8000000060" , vfmaddps(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128), ymm6)); + TEST_INSTRUCTION("C4E3E96BCC30" , vfmaddsd(xmm1, xmm2, xmm3, xmm4)); + TEST_INSTRUCTION("C4E3E96B8C358000000030" , vfmaddsd(xmm1, xmm2, xmm3, ptr(ebp, esi, 0, 128))); + TEST_INSTRUCTION("C4E3E96B8C358000000030" , vfmaddsd(xmm1, xmm2, xmm3, qword_ptr(ebp, esi, 0, 128))); + TEST_INSTRUCTION("C4E3696B8C2B8000000060" , vfmaddsd(xmm1, xmm2, ptr(ebx, ebp, 0, 128), xmm6)); + TEST_INSTRUCTION("C4E3696B8C2B8000000060" , vfmaddsd(xmm1, xmm2, qword_ptr(ebx, ebp, 0, 128), xmm6)); + TEST_INSTRUCTION("C4E3E96ACC30" , vfmaddss(xmm1, xmm2, xmm3, xmm4)); + TEST_INSTRUCTION("C4E3E96A8C358000000030" , vfmaddss(xmm1, xmm2, xmm3, ptr(ebp, esi, 0, 128))); + TEST_INSTRUCTION("C4E3E96A8C358000000030" , vfmaddss(xmm1, xmm2, xmm3, dword_ptr(ebp, esi, 0, 128))); + TEST_INSTRUCTION("C4E3696A8C2B8000000060" , vfmaddss(xmm1, xmm2, ptr(ebx, ebp, 0, 128), xmm6)); + TEST_INSTRUCTION("C4E3696A8C2B8000000060" , vfmaddss(xmm1, xmm2, dword_ptr(ebx, ebp, 0, 128), xmm6)); + TEST_INSTRUCTION("C4E2E996CB" , vfmaddsub132pd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E2E9968C2B80000000" , vfmaddsub132pd(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E2E9968C2B80000000" , vfmaddsub132pd(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E2ED96CB" , vfmaddsub132pd(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C4E2ED968C2B80000000" , vfmaddsub132pd(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E2ED968C2B80000000" , vfmaddsub132pd(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED4896CB" , vfmaddsub132pd(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F2ED48964C2B02" , vfmaddsub132pd(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED48964C2B02" , vfmaddsub132pd(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E26996CB" , vfmaddsub132ps(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E269968C2B80000000" , vfmaddsub132ps(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E269968C2B80000000" , vfmaddsub132ps(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E26D96CB" , vfmaddsub132ps(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C4E26D968C2B80000000" , vfmaddsub132ps(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E26D968C2B80000000" , vfmaddsub132ps(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D4896CB" , vfmaddsub132ps(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F26D48964C2B02" , vfmaddsub132ps(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D48964C2B02" , vfmaddsub132ps(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E2E9A6CB" , vfmaddsub213pd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E2E9A68C2B80000000" , vfmaddsub213pd(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E2E9A68C2B80000000" , vfmaddsub213pd(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E2EDA6CB" , vfmaddsub213pd(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C4E2EDA68C2B80000000" , vfmaddsub213pd(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E2EDA68C2B80000000" , vfmaddsub213pd(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED48A6CB" , vfmaddsub213pd(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F2ED48A64C2B02" , vfmaddsub213pd(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED48A64C2B02" , vfmaddsub213pd(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E269A6CB" , vfmaddsub213ps(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E269A68C2B80000000" , vfmaddsub213ps(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E269A68C2B80000000" , vfmaddsub213ps(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E26DA6CB" , vfmaddsub213ps(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C4E26DA68C2B80000000" , vfmaddsub213ps(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E26DA68C2B80000000" , vfmaddsub213ps(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D48A6CB" , vfmaddsub213ps(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F26D48A64C2B02" , vfmaddsub213ps(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D48A64C2B02" , vfmaddsub213ps(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E2E9B6CB" , vfmaddsub231pd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E2E9B68C2B80000000" , vfmaddsub231pd(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E2E9B68C2B80000000" , vfmaddsub231pd(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E2EDB6CB" , vfmaddsub231pd(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C4E2EDB68C2B80000000" , vfmaddsub231pd(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E2EDB68C2B80000000" , vfmaddsub231pd(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED48B6CB" , vfmaddsub231pd(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F2ED48B64C2B02" , vfmaddsub231pd(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED48B64C2B02" , vfmaddsub231pd(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E269B6CB" , vfmaddsub231ps(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E269B68C2B80000000" , vfmaddsub231ps(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E269B68C2B80000000" , vfmaddsub231ps(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E26DB6CB" , vfmaddsub231ps(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C4E26DB68C2B80000000" , vfmaddsub231ps(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E26DB68C2B80000000" , vfmaddsub231ps(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D48B6CB" , vfmaddsub231ps(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F26D48B64C2B02" , vfmaddsub231ps(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D48B64C2B02" , vfmaddsub231ps(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E3E95DCC30" , vfmaddsubpd(xmm1, xmm2, xmm3, xmm4)); + TEST_INSTRUCTION("C4E3E95D8C358000000030" , vfmaddsubpd(xmm1, xmm2, xmm3, ptr(ebp, esi, 0, 128))); + TEST_INSTRUCTION("C4E3E95D8C358000000030" , vfmaddsubpd(xmm1, xmm2, xmm3, xmmword_ptr(ebp, esi, 0, 128))); + TEST_INSTRUCTION("C4E3695D8C2B8000000060" , vfmaddsubpd(xmm1, xmm2, ptr(ebx, ebp, 0, 128), xmm6)); + TEST_INSTRUCTION("C4E3695D8C2B8000000060" , vfmaddsubpd(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128), xmm6)); + TEST_INSTRUCTION("C4E3ED5DCC30" , vfmaddsubpd(ymm1, ymm2, ymm3, ymm4)); + TEST_INSTRUCTION("C4E3ED5D8C358000000030" , vfmaddsubpd(ymm1, ymm2, ymm3, ptr(ebp, esi, 0, 128))); + TEST_INSTRUCTION("C4E3ED5D8C358000000030" , vfmaddsubpd(ymm1, ymm2, ymm3, ymmword_ptr(ebp, esi, 0, 128))); + TEST_INSTRUCTION("C4E36D5D8C2B8000000060" , vfmaddsubpd(ymm1, ymm2, ptr(ebx, ebp, 0, 128), ymm6)); + TEST_INSTRUCTION("C4E36D5D8C2B8000000060" , vfmaddsubpd(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128), ymm6)); + TEST_INSTRUCTION("C4E3E95CCC30" , vfmaddsubps(xmm1, xmm2, xmm3, xmm4)); + TEST_INSTRUCTION("C4E3E95C8C358000000030" , vfmaddsubps(xmm1, xmm2, xmm3, ptr(ebp, esi, 0, 128))); + TEST_INSTRUCTION("C4E3E95C8C358000000030" , vfmaddsubps(xmm1, xmm2, xmm3, xmmword_ptr(ebp, esi, 0, 128))); + TEST_INSTRUCTION("C4E3695C8C2B8000000060" , vfmaddsubps(xmm1, xmm2, ptr(ebx, ebp, 0, 128), xmm6)); + TEST_INSTRUCTION("C4E3695C8C2B8000000060" , vfmaddsubps(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128), xmm6)); + TEST_INSTRUCTION("C4E3ED5CCC30" , vfmaddsubps(ymm1, ymm2, ymm3, ymm4)); + TEST_INSTRUCTION("C4E3ED5C8C358000000030" , vfmaddsubps(ymm1, ymm2, ymm3, ptr(ebp, esi, 0, 128))); + TEST_INSTRUCTION("C4E3ED5C8C358000000030" , vfmaddsubps(ymm1, ymm2, ymm3, ymmword_ptr(ebp, esi, 0, 128))); + TEST_INSTRUCTION("C4E36D5C8C2B8000000060" , vfmaddsubps(ymm1, ymm2, ptr(ebx, ebp, 0, 128), ymm6)); + TEST_INSTRUCTION("C4E36D5C8C2B8000000060" , vfmaddsubps(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128), ymm6)); + TEST_INSTRUCTION("C4E2E99ACB" , vfmsub132pd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E2E99A8C2B80000000" , vfmsub132pd(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E2E99A8C2B80000000" , vfmsub132pd(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E2ED9ACB" , vfmsub132pd(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C4E2ED9A8C2B80000000" , vfmsub132pd(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E2ED9A8C2B80000000" , vfmsub132pd(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED489ACB" , vfmsub132pd(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F2ED489A4C2B02" , vfmsub132pd(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED489A4C2B02" , vfmsub132pd(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E2699ACB" , vfmsub132ps(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E2699A8C2B80000000" , vfmsub132ps(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E2699A8C2B80000000" , vfmsub132ps(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E26D9ACB" , vfmsub132ps(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C4E26D9A8C2B80000000" , vfmsub132ps(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E26D9A8C2B80000000" , vfmsub132ps(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D489ACB" , vfmsub132ps(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F26D489A4C2B02" , vfmsub132ps(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D489A4C2B02" , vfmsub132ps(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E2E99BCB" , vfmsub132sd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E2E99B8C2B80000000" , vfmsub132sd(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E2E99B8C2B80000000" , vfmsub132sd(xmm1, xmm2, qword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E2699BCB" , vfmsub132ss(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E2699B8C2B80000000" , vfmsub132ss(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E2699B8C2B80000000" , vfmsub132ss(xmm1, xmm2, dword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E2E9AACB" , vfmsub213pd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E2E9AA8C2B80000000" , vfmsub213pd(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E2E9AA8C2B80000000" , vfmsub213pd(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E2EDAACB" , vfmsub213pd(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C4E2EDAA8C2B80000000" , vfmsub213pd(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E2EDAA8C2B80000000" , vfmsub213pd(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED48AACB" , vfmsub213pd(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F2ED48AA4C2B02" , vfmsub213pd(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED48AA4C2B02" , vfmsub213pd(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E269AACB" , vfmsub213ps(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E269AA8C2B80000000" , vfmsub213ps(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E269AA8C2B80000000" , vfmsub213ps(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E26DAACB" , vfmsub213ps(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C4E26DAA8C2B80000000" , vfmsub213ps(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E26DAA8C2B80000000" , vfmsub213ps(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D48AACB" , vfmsub213ps(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F26D48AA4C2B02" , vfmsub213ps(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D48AA4C2B02" , vfmsub213ps(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E2E9ABCB" , vfmsub213sd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E2E9AB8C2B80000000" , vfmsub213sd(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E2E9AB8C2B80000000" , vfmsub213sd(xmm1, xmm2, qword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E269ABCB" , vfmsub213ss(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E269AB8C2B80000000" , vfmsub213ss(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E269AB8C2B80000000" , vfmsub213ss(xmm1, xmm2, dword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E2E9BACB" , vfmsub231pd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E2E9BA8C2B80000000" , vfmsub231pd(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E2E9BA8C2B80000000" , vfmsub231pd(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E2EDBACB" , vfmsub231pd(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C4E2EDBA8C2B80000000" , vfmsub231pd(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E2EDBA8C2B80000000" , vfmsub231pd(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED48BACB" , vfmsub231pd(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F2ED48BA4C2B02" , vfmsub231pd(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED48BA4C2B02" , vfmsub231pd(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E269BACB" , vfmsub231ps(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E269BA8C2B80000000" , vfmsub231ps(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E269BA8C2B80000000" , vfmsub231ps(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E26DBACB" , vfmsub231ps(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C4E26DBA8C2B80000000" , vfmsub231ps(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E26DBA8C2B80000000" , vfmsub231ps(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D48BACB" , vfmsub231ps(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F26D48BA4C2B02" , vfmsub231ps(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D48BA4C2B02" , vfmsub231ps(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E2E9BBCB" , vfmsub231sd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E2E9BB8C2B80000000" , vfmsub231sd(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E2E9BB8C2B80000000" , vfmsub231sd(xmm1, xmm2, qword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E269BBCB" , vfmsub231ss(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E269BB8C2B80000000" , vfmsub231ss(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E269BB8C2B80000000" , vfmsub231ss(xmm1, xmm2, dword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E2E997CB" , vfmsubadd132pd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E2E9978C2B80000000" , vfmsubadd132pd(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E2E9978C2B80000000" , vfmsubadd132pd(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E2ED97CB" , vfmsubadd132pd(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C4E2ED978C2B80000000" , vfmsubadd132pd(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E2ED978C2B80000000" , vfmsubadd132pd(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED4897CB" , vfmsubadd132pd(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F2ED48974C2B02" , vfmsubadd132pd(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED48974C2B02" , vfmsubadd132pd(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E26997CB" , vfmsubadd132ps(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E269978C2B80000000" , vfmsubadd132ps(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E269978C2B80000000" , vfmsubadd132ps(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E26D97CB" , vfmsubadd132ps(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C4E26D978C2B80000000" , vfmsubadd132ps(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E26D978C2B80000000" , vfmsubadd132ps(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D4897CB" , vfmsubadd132ps(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F26D48974C2B02" , vfmsubadd132ps(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D48974C2B02" , vfmsubadd132ps(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E2E9A7CB" , vfmsubadd213pd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E2E9A78C2B80000000" , vfmsubadd213pd(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E2E9A78C2B80000000" , vfmsubadd213pd(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E2EDA7CB" , vfmsubadd213pd(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C4E2EDA78C2B80000000" , vfmsubadd213pd(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E2EDA78C2B80000000" , vfmsubadd213pd(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED48A7CB" , vfmsubadd213pd(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F2ED48A74C2B02" , vfmsubadd213pd(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED48A74C2B02" , vfmsubadd213pd(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E269A7CB" , vfmsubadd213ps(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E269A78C2B80000000" , vfmsubadd213ps(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E269A78C2B80000000" , vfmsubadd213ps(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E26DA7CB" , vfmsubadd213ps(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C4E26DA78C2B80000000" , vfmsubadd213ps(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E26DA78C2B80000000" , vfmsubadd213ps(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D48A7CB" , vfmsubadd213ps(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F26D48A74C2B02" , vfmsubadd213ps(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D48A74C2B02" , vfmsubadd213ps(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E2E9B7CB" , vfmsubadd231pd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E2E9B78C2B80000000" , vfmsubadd231pd(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E2E9B78C2B80000000" , vfmsubadd231pd(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E2EDB7CB" , vfmsubadd231pd(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C4E2EDB78C2B80000000" , vfmsubadd231pd(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E2EDB78C2B80000000" , vfmsubadd231pd(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED48B7CB" , vfmsubadd231pd(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F2ED48B74C2B02" , vfmsubadd231pd(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED48B74C2B02" , vfmsubadd231pd(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E269B7CB" , vfmsubadd231ps(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E269B78C2B80000000" , vfmsubadd231ps(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E269B78C2B80000000" , vfmsubadd231ps(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E26DB7CB" , vfmsubadd231ps(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C4E26DB78C2B80000000" , vfmsubadd231ps(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E26DB78C2B80000000" , vfmsubadd231ps(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D48B7CB" , vfmsubadd231ps(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F26D48B74C2B02" , vfmsubadd231ps(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D48B74C2B02" , vfmsubadd231ps(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E3E95FCC30" , vfmsubaddpd(xmm1, xmm2, xmm3, xmm4)); + TEST_INSTRUCTION("C4E3E95F8C358000000030" , vfmsubaddpd(xmm1, xmm2, xmm3, ptr(ebp, esi, 0, 128))); + TEST_INSTRUCTION("C4E3E95F8C358000000030" , vfmsubaddpd(xmm1, xmm2, xmm3, xmmword_ptr(ebp, esi, 0, 128))); + TEST_INSTRUCTION("C4E3695F8C2B8000000060" , vfmsubaddpd(xmm1, xmm2, ptr(ebx, ebp, 0, 128), xmm6)); + TEST_INSTRUCTION("C4E3695F8C2B8000000060" , vfmsubaddpd(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128), xmm6)); + TEST_INSTRUCTION("C4E3ED5FCC30" , vfmsubaddpd(ymm1, ymm2, ymm3, ymm4)); + TEST_INSTRUCTION("C4E3ED5F8C358000000030" , vfmsubaddpd(ymm1, ymm2, ymm3, ptr(ebp, esi, 0, 128))); + TEST_INSTRUCTION("C4E3ED5F8C358000000030" , vfmsubaddpd(ymm1, ymm2, ymm3, ymmword_ptr(ebp, esi, 0, 128))); + TEST_INSTRUCTION("C4E36D5F8C2B8000000060" , vfmsubaddpd(ymm1, ymm2, ptr(ebx, ebp, 0, 128), ymm6)); + TEST_INSTRUCTION("C4E36D5F8C2B8000000060" , vfmsubaddpd(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128), ymm6)); + TEST_INSTRUCTION("C4E3E95ECC30" , vfmsubaddps(xmm1, xmm2, xmm3, xmm4)); + TEST_INSTRUCTION("C4E3E95E8C358000000030" , vfmsubaddps(xmm1, xmm2, xmm3, ptr(ebp, esi, 0, 128))); + TEST_INSTRUCTION("C4E3E95E8C358000000030" , vfmsubaddps(xmm1, xmm2, xmm3, xmmword_ptr(ebp, esi, 0, 128))); + TEST_INSTRUCTION("C4E3695E8C2B8000000060" , vfmsubaddps(xmm1, xmm2, ptr(ebx, ebp, 0, 128), xmm6)); + TEST_INSTRUCTION("C4E3695E8C2B8000000060" , vfmsubaddps(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128), xmm6)); + TEST_INSTRUCTION("C4E3ED5ECC30" , vfmsubaddps(ymm1, ymm2, ymm3, ymm4)); + TEST_INSTRUCTION("C4E3ED5E8C358000000030" , vfmsubaddps(ymm1, ymm2, ymm3, ptr(ebp, esi, 0, 128))); + TEST_INSTRUCTION("C4E3ED5E8C358000000030" , vfmsubaddps(ymm1, ymm2, ymm3, ymmword_ptr(ebp, esi, 0, 128))); + TEST_INSTRUCTION("C4E36D5E8C2B8000000060" , vfmsubaddps(ymm1, ymm2, ptr(ebx, ebp, 0, 128), ymm6)); + TEST_INSTRUCTION("C4E36D5E8C2B8000000060" , vfmsubaddps(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128), ymm6)); + TEST_INSTRUCTION("C4E3E96DCC30" , vfmsubpd(xmm1, xmm2, xmm3, xmm4)); + TEST_INSTRUCTION("C4E3E96D8C358000000030" , vfmsubpd(xmm1, xmm2, xmm3, ptr(ebp, esi, 0, 128))); + TEST_INSTRUCTION("C4E3E96D8C358000000030" , vfmsubpd(xmm1, xmm2, xmm3, xmmword_ptr(ebp, esi, 0, 128))); + TEST_INSTRUCTION("C4E3696D8C2B8000000060" , vfmsubpd(xmm1, xmm2, ptr(ebx, ebp, 0, 128), xmm6)); + TEST_INSTRUCTION("C4E3696D8C2B8000000060" , vfmsubpd(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128), xmm6)); + TEST_INSTRUCTION("C4E3ED6DCC30" , vfmsubpd(ymm1, ymm2, ymm3, ymm4)); + TEST_INSTRUCTION("C4E3ED6D8C358000000030" , vfmsubpd(ymm1, ymm2, ymm3, ptr(ebp, esi, 0, 128))); + TEST_INSTRUCTION("C4E3ED6D8C358000000030" , vfmsubpd(ymm1, ymm2, ymm3, ymmword_ptr(ebp, esi, 0, 128))); + TEST_INSTRUCTION("C4E36D6D8C2B8000000060" , vfmsubpd(ymm1, ymm2, ptr(ebx, ebp, 0, 128), ymm6)); + TEST_INSTRUCTION("C4E36D6D8C2B8000000060" , vfmsubpd(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128), ymm6)); + TEST_INSTRUCTION("C4E3E96CCC30" , vfmsubps(xmm1, xmm2, xmm3, xmm4)); + TEST_INSTRUCTION("C4E3E96C8C358000000030" , vfmsubps(xmm1, xmm2, xmm3, ptr(ebp, esi, 0, 128))); + TEST_INSTRUCTION("C4E3E96C8C358000000030" , vfmsubps(xmm1, xmm2, xmm3, xmmword_ptr(ebp, esi, 0, 128))); + TEST_INSTRUCTION("C4E3696C8C2B8000000060" , vfmsubps(xmm1, xmm2, ptr(ebx, ebp, 0, 128), xmm6)); + TEST_INSTRUCTION("C4E3696C8C2B8000000060" , vfmsubps(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128), xmm6)); + TEST_INSTRUCTION("C4E3ED6CCC30" , vfmsubps(ymm1, ymm2, ymm3, ymm4)); + TEST_INSTRUCTION("C4E3ED6C8C358000000030" , vfmsubps(ymm1, ymm2, ymm3, ptr(ebp, esi, 0, 128))); + TEST_INSTRUCTION("C4E3ED6C8C358000000030" , vfmsubps(ymm1, ymm2, ymm3, ymmword_ptr(ebp, esi, 0, 128))); + TEST_INSTRUCTION("C4E36D6C8C2B8000000060" , vfmsubps(ymm1, ymm2, ptr(ebx, ebp, 0, 128), ymm6)); + TEST_INSTRUCTION("C4E36D6C8C2B8000000060" , vfmsubps(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128), ymm6)); + TEST_INSTRUCTION("C4E3E96FCC30" , vfmsubsd(xmm1, xmm2, xmm3, xmm4)); + TEST_INSTRUCTION("C4E3E96F8C358000000030" , vfmsubsd(xmm1, xmm2, xmm3, ptr(ebp, esi, 0, 128))); + TEST_INSTRUCTION("C4E3E96F8C358000000030" , vfmsubsd(xmm1, xmm2, xmm3, qword_ptr(ebp, esi, 0, 128))); + TEST_INSTRUCTION("C4E3696F8C2B8000000060" , vfmsubsd(xmm1, xmm2, ptr(ebx, ebp, 0, 128), xmm6)); + TEST_INSTRUCTION("C4E3696F8C2B8000000060" , vfmsubsd(xmm1, xmm2, qword_ptr(ebx, ebp, 0, 128), xmm6)); + TEST_INSTRUCTION("C4E3E96ECC30" , vfmsubss(xmm1, xmm2, xmm3, xmm4)); + TEST_INSTRUCTION("C4E3E96E8C358000000030" , vfmsubss(xmm1, xmm2, xmm3, ptr(ebp, esi, 0, 128))); + TEST_INSTRUCTION("C4E3E96E8C358000000030" , vfmsubss(xmm1, xmm2, xmm3, dword_ptr(ebp, esi, 0, 128))); + TEST_INSTRUCTION("C4E3696E8C2B8000000060" , vfmsubss(xmm1, xmm2, ptr(ebx, ebp, 0, 128), xmm6)); + TEST_INSTRUCTION("C4E3696E8C2B8000000060" , vfmsubss(xmm1, xmm2, dword_ptr(ebx, ebp, 0, 128), xmm6)); + TEST_INSTRUCTION("C4E2E99CCB" , vfnmadd132pd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E2E99C8C2B80000000" , vfnmadd132pd(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E2E99C8C2B80000000" , vfnmadd132pd(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E2ED9CCB" , vfnmadd132pd(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C4E2ED9C8C2B80000000" , vfnmadd132pd(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E2ED9C8C2B80000000" , vfnmadd132pd(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED489CCB" , vfnmadd132pd(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F2ED489C4C2B02" , vfnmadd132pd(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED489C4C2B02" , vfnmadd132pd(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E2699CCB" , vfnmadd132ps(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E2699C8C2B80000000" , vfnmadd132ps(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E2699C8C2B80000000" , vfnmadd132ps(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E26D9CCB" , vfnmadd132ps(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C4E26D9C8C2B80000000" , vfnmadd132ps(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E26D9C8C2B80000000" , vfnmadd132ps(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D489CCB" , vfnmadd132ps(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F26D489C4C2B02" , vfnmadd132ps(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D489C4C2B02" , vfnmadd132ps(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E2E99DCB" , vfnmadd132sd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E2E99D8C2B80000000" , vfnmadd132sd(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E2E99D8C2B80000000" , vfnmadd132sd(xmm1, xmm2, qword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E2699DCB" , vfnmadd132ss(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E2699D8C2B80000000" , vfnmadd132ss(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E2699D8C2B80000000" , vfnmadd132ss(xmm1, xmm2, dword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E2E9ACCB" , vfnmadd213pd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E2E9AC8C2B80000000" , vfnmadd213pd(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E2E9AC8C2B80000000" , vfnmadd213pd(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E2EDACCB" , vfnmadd213pd(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C4E2EDAC8C2B80000000" , vfnmadd213pd(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E2EDAC8C2B80000000" , vfnmadd213pd(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED48ACCB" , vfnmadd213pd(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F2ED48AC4C2B02" , vfnmadd213pd(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED48AC4C2B02" , vfnmadd213pd(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E269ACCB" , vfnmadd213ps(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E269AC8C2B80000000" , vfnmadd213ps(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E269AC8C2B80000000" , vfnmadd213ps(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E26DACCB" , vfnmadd213ps(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C4E26DAC8C2B80000000" , vfnmadd213ps(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E26DAC8C2B80000000" , vfnmadd213ps(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D48ACCB" , vfnmadd213ps(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F26D48AC4C2B02" , vfnmadd213ps(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D48AC4C2B02" , vfnmadd213ps(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E2E9ADCB" , vfnmadd213sd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E2E9AD8C2B80000000" , vfnmadd213sd(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E2E9AD8C2B80000000" , vfnmadd213sd(xmm1, xmm2, qword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E269ADCB" , vfnmadd213ss(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E269AD8C2B80000000" , vfnmadd213ss(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E269AD8C2B80000000" , vfnmadd213ss(xmm1, xmm2, dword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E2E9BCCB" , vfnmadd231pd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E2E9BC8C2B80000000" , vfnmadd231pd(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E2E9BC8C2B80000000" , vfnmadd231pd(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E2EDBCCB" , vfnmadd231pd(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C4E2EDBC8C2B80000000" , vfnmadd231pd(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E2EDBC8C2B80000000" , vfnmadd231pd(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED48BCCB" , vfnmadd231pd(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F2ED48BC4C2B02" , vfnmadd231pd(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED48BC4C2B02" , vfnmadd231pd(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E269BCCB" , vfnmadd231ps(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E269BC8C2B80000000" , vfnmadd231ps(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E269BC8C2B80000000" , vfnmadd231ps(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E26DBCCB" , vfnmadd231ps(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C4E26DBC8C2B80000000" , vfnmadd231ps(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E26DBC8C2B80000000" , vfnmadd231ps(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D48BCCB" , vfnmadd231ps(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F26D48BC4C2B02" , vfnmadd231ps(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D48BC4C2B02" , vfnmadd231ps(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E2E9BDCB" , vfnmadd231sd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E2E9BD8C2B80000000" , vfnmadd231sd(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E2E9BD8C2B80000000" , vfnmadd231sd(xmm1, xmm2, qword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E269BDCB" , vfnmadd231ss(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E269BD8C2B80000000" , vfnmadd231ss(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E269BD8C2B80000000" , vfnmadd231ss(xmm1, xmm2, dword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E3E979CC30" , vfnmaddpd(xmm1, xmm2, xmm3, xmm4)); + TEST_INSTRUCTION("C4E3E9798C358000000030" , vfnmaddpd(xmm1, xmm2, xmm3, ptr(ebp, esi, 0, 128))); + TEST_INSTRUCTION("C4E3E9798C358000000030" , vfnmaddpd(xmm1, xmm2, xmm3, xmmword_ptr(ebp, esi, 0, 128))); + TEST_INSTRUCTION("C4E369798C2B8000000060" , vfnmaddpd(xmm1, xmm2, ptr(ebx, ebp, 0, 128), xmm6)); + TEST_INSTRUCTION("C4E369798C2B8000000060" , vfnmaddpd(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128), xmm6)); + TEST_INSTRUCTION("C4E3ED79CC30" , vfnmaddpd(ymm1, ymm2, ymm3, ymm4)); + TEST_INSTRUCTION("C4E3ED798C358000000030" , vfnmaddpd(ymm1, ymm2, ymm3, ptr(ebp, esi, 0, 128))); + TEST_INSTRUCTION("C4E3ED798C358000000030" , vfnmaddpd(ymm1, ymm2, ymm3, ymmword_ptr(ebp, esi, 0, 128))); + TEST_INSTRUCTION("C4E36D798C2B8000000060" , vfnmaddpd(ymm1, ymm2, ptr(ebx, ebp, 0, 128), ymm6)); + TEST_INSTRUCTION("C4E36D798C2B8000000060" , vfnmaddpd(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128), ymm6)); + TEST_INSTRUCTION("C4E3E978CC30" , vfnmaddps(xmm1, xmm2, xmm3, xmm4)); + TEST_INSTRUCTION("C4E3E9788C358000000030" , vfnmaddps(xmm1, xmm2, xmm3, ptr(ebp, esi, 0, 128))); + TEST_INSTRUCTION("C4E3E9788C358000000030" , vfnmaddps(xmm1, xmm2, xmm3, xmmword_ptr(ebp, esi, 0, 128))); + TEST_INSTRUCTION("C4E369788C2B8000000060" , vfnmaddps(xmm1, xmm2, ptr(ebx, ebp, 0, 128), xmm6)); + TEST_INSTRUCTION("C4E369788C2B8000000060" , vfnmaddps(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128), xmm6)); + TEST_INSTRUCTION("C4E3ED78CC30" , vfnmaddps(ymm1, ymm2, ymm3, ymm4)); + TEST_INSTRUCTION("C4E3ED788C358000000030" , vfnmaddps(ymm1, ymm2, ymm3, ptr(ebp, esi, 0, 128))); + TEST_INSTRUCTION("C4E3ED788C358000000030" , vfnmaddps(ymm1, ymm2, ymm3, ymmword_ptr(ebp, esi, 0, 128))); + TEST_INSTRUCTION("C4E36D788C2B8000000060" , vfnmaddps(ymm1, ymm2, ptr(ebx, ebp, 0, 128), ymm6)); + TEST_INSTRUCTION("C4E36D788C2B8000000060" , vfnmaddps(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128), ymm6)); + TEST_INSTRUCTION("C4E3E97BCC30" , vfnmaddsd(xmm1, xmm2, xmm3, xmm4)); + TEST_INSTRUCTION("C4E3E97B8C358000000030" , vfnmaddsd(xmm1, xmm2, xmm3, ptr(ebp, esi, 0, 128))); + TEST_INSTRUCTION("C4E3E97B8C358000000030" , vfnmaddsd(xmm1, xmm2, xmm3, qword_ptr(ebp, esi, 0, 128))); + TEST_INSTRUCTION("C4E3697B8C2B8000000060" , vfnmaddsd(xmm1, xmm2, ptr(ebx, ebp, 0, 128), xmm6)); + TEST_INSTRUCTION("C4E3697B8C2B8000000060" , vfnmaddsd(xmm1, xmm2, qword_ptr(ebx, ebp, 0, 128), xmm6)); + TEST_INSTRUCTION("C4E3E97ACC30" , vfnmaddss(xmm1, xmm2, xmm3, xmm4)); + TEST_INSTRUCTION("C4E3E97A8C358000000030" , vfnmaddss(xmm1, xmm2, xmm3, ptr(ebp, esi, 0, 128))); + TEST_INSTRUCTION("C4E3E97A8C358000000030" , vfnmaddss(xmm1, xmm2, xmm3, dword_ptr(ebp, esi, 0, 128))); + TEST_INSTRUCTION("C4E3697A8C2B8000000060" , vfnmaddss(xmm1, xmm2, ptr(ebx, ebp, 0, 128), xmm6)); + TEST_INSTRUCTION("C4E3697A8C2B8000000060" , vfnmaddss(xmm1, xmm2, dword_ptr(ebx, ebp, 0, 128), xmm6)); + TEST_INSTRUCTION("C4E2E99ECB" , vfnmsub132pd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E2E99E8C2B80000000" , vfnmsub132pd(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E2E99E8C2B80000000" , vfnmsub132pd(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E2ED9ECB" , vfnmsub132pd(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C4E2ED9E8C2B80000000" , vfnmsub132pd(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E2ED9E8C2B80000000" , vfnmsub132pd(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED489ECB" , vfnmsub132pd(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F2ED489E4C2B02" , vfnmsub132pd(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED489E4C2B02" , vfnmsub132pd(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E2699ECB" , vfnmsub132ps(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E2699E8C2B80000000" , vfnmsub132ps(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E2699E8C2B80000000" , vfnmsub132ps(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E26D9ECB" , vfnmsub132ps(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C4E26D9E8C2B80000000" , vfnmsub132ps(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E26D9E8C2B80000000" , vfnmsub132ps(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D489ECB" , vfnmsub132ps(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F26D489E4C2B02" , vfnmsub132ps(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D489E4C2B02" , vfnmsub132ps(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E2E99FCB" , vfnmsub132sd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E2E99F8C2B80000000" , vfnmsub132sd(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E2E99F8C2B80000000" , vfnmsub132sd(xmm1, xmm2, qword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E2699FCB" , vfnmsub132ss(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E2699F8C2B80000000" , vfnmsub132ss(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E2699F8C2B80000000" , vfnmsub132ss(xmm1, xmm2, dword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E2E9AECB" , vfnmsub213pd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E2E9AE8C2B80000000" , vfnmsub213pd(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E2E9AE8C2B80000000" , vfnmsub213pd(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E2EDAECB" , vfnmsub213pd(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C4E2EDAE8C2B80000000" , vfnmsub213pd(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E2EDAE8C2B80000000" , vfnmsub213pd(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED48AECB" , vfnmsub213pd(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F2ED48AE4C2B02" , vfnmsub213pd(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED48AE4C2B02" , vfnmsub213pd(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E269AECB" , vfnmsub213ps(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E269AE8C2B80000000" , vfnmsub213ps(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E269AE8C2B80000000" , vfnmsub213ps(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E26DAECB" , vfnmsub213ps(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C4E26DAE8C2B80000000" , vfnmsub213ps(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E26DAE8C2B80000000" , vfnmsub213ps(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D48AECB" , vfnmsub213ps(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F26D48AE4C2B02" , vfnmsub213ps(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D48AE4C2B02" , vfnmsub213ps(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E2E9AFCB" , vfnmsub213sd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E2E9AF8C2B80000000" , vfnmsub213sd(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E2E9AF8C2B80000000" , vfnmsub213sd(xmm1, xmm2, qword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E269AFCB" , vfnmsub213ss(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E269AF8C2B80000000" , vfnmsub213ss(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E269AF8C2B80000000" , vfnmsub213ss(xmm1, xmm2, dword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E2E9BECB" , vfnmsub231pd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E2E9BE8C2B80000000" , vfnmsub231pd(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E2E9BE8C2B80000000" , vfnmsub231pd(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E2EDBECB" , vfnmsub231pd(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C4E2EDBE8C2B80000000" , vfnmsub231pd(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E2EDBE8C2B80000000" , vfnmsub231pd(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED48BECB" , vfnmsub231pd(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F2ED48BE4C2B02" , vfnmsub231pd(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED48BE4C2B02" , vfnmsub231pd(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E269BECB" , vfnmsub231ps(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E269BE8C2B80000000" , vfnmsub231ps(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E269BE8C2B80000000" , vfnmsub231ps(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E26DBECB" , vfnmsub231ps(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C4E26DBE8C2B80000000" , vfnmsub231ps(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E26DBE8C2B80000000" , vfnmsub231ps(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D48BECB" , vfnmsub231ps(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F26D48BE4C2B02" , vfnmsub231ps(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D48BE4C2B02" , vfnmsub231ps(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E2E9BFCB" , vfnmsub231sd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E2E9BF8C2B80000000" , vfnmsub231sd(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E2E9BF8C2B80000000" , vfnmsub231sd(xmm1, xmm2, qword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E269BFCB" , vfnmsub231ss(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E269BF8C2B80000000" , vfnmsub231ss(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E269BF8C2B80000000" , vfnmsub231ss(xmm1, xmm2, dword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E3E97DCC30" , vfnmsubpd(xmm1, xmm2, xmm3, xmm4)); + TEST_INSTRUCTION("C4E3E97D8C358000000030" , vfnmsubpd(xmm1, xmm2, xmm3, ptr(ebp, esi, 0, 128))); + TEST_INSTRUCTION("C4E3E97D8C358000000030" , vfnmsubpd(xmm1, xmm2, xmm3, xmmword_ptr(ebp, esi, 0, 128))); + TEST_INSTRUCTION("C4E3697D8C2B8000000060" , vfnmsubpd(xmm1, xmm2, ptr(ebx, ebp, 0, 128), xmm6)); + TEST_INSTRUCTION("C4E3697D8C2B8000000060" , vfnmsubpd(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128), xmm6)); + TEST_INSTRUCTION("C4E3ED7DCC30" , vfnmsubpd(ymm1, ymm2, ymm3, ymm4)); + TEST_INSTRUCTION("C4E3ED7D8C358000000030" , vfnmsubpd(ymm1, ymm2, ymm3, ptr(ebp, esi, 0, 128))); + TEST_INSTRUCTION("C4E3ED7D8C358000000030" , vfnmsubpd(ymm1, ymm2, ymm3, ymmword_ptr(ebp, esi, 0, 128))); + TEST_INSTRUCTION("C4E36D7D8C2B8000000060" , vfnmsubpd(ymm1, ymm2, ptr(ebx, ebp, 0, 128), ymm6)); + TEST_INSTRUCTION("C4E36D7D8C2B8000000060" , vfnmsubpd(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128), ymm6)); + TEST_INSTRUCTION("C4E3E97CCC30" , vfnmsubps(xmm1, xmm2, xmm3, xmm4)); + TEST_INSTRUCTION("C4E3E97C8C358000000030" , vfnmsubps(xmm1, xmm2, xmm3, ptr(ebp, esi, 0, 128))); + TEST_INSTRUCTION("C4E3E97C8C358000000030" , vfnmsubps(xmm1, xmm2, xmm3, xmmword_ptr(ebp, esi, 0, 128))); + TEST_INSTRUCTION("C4E3697C8C2B8000000060" , vfnmsubps(xmm1, xmm2, ptr(ebx, ebp, 0, 128), xmm6)); + TEST_INSTRUCTION("C4E3697C8C2B8000000060" , vfnmsubps(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128), xmm6)); + TEST_INSTRUCTION("C4E3ED7CCC30" , vfnmsubps(ymm1, ymm2, ymm3, ymm4)); + TEST_INSTRUCTION("C4E3ED7C8C358000000030" , vfnmsubps(ymm1, ymm2, ymm3, ptr(ebp, esi, 0, 128))); + TEST_INSTRUCTION("C4E3ED7C8C358000000030" , vfnmsubps(ymm1, ymm2, ymm3, ymmword_ptr(ebp, esi, 0, 128))); + TEST_INSTRUCTION("C4E36D7C8C2B8000000060" , vfnmsubps(ymm1, ymm2, ptr(ebx, ebp, 0, 128), ymm6)); + TEST_INSTRUCTION("C4E36D7C8C2B8000000060" , vfnmsubps(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128), ymm6)); + TEST_INSTRUCTION("C4E3E97FCC30" , vfnmsubsd(xmm1, xmm2, xmm3, xmm4)); + TEST_INSTRUCTION("C4E3E97F8C358000000030" , vfnmsubsd(xmm1, xmm2, xmm3, ptr(ebp, esi, 0, 128))); + TEST_INSTRUCTION("C4E3E97F8C358000000030" , vfnmsubsd(xmm1, xmm2, xmm3, qword_ptr(ebp, esi, 0, 128))); + TEST_INSTRUCTION("C4E3697F8C2B8000000060" , vfnmsubsd(xmm1, xmm2, ptr(ebx, ebp, 0, 128), xmm6)); + TEST_INSTRUCTION("C4E3697F8C2B8000000060" , vfnmsubsd(xmm1, xmm2, qword_ptr(ebx, ebp, 0, 128), xmm6)); + TEST_INSTRUCTION("C4E3E97ECC30" , vfnmsubss(xmm1, xmm2, xmm3, xmm4)); + TEST_INSTRUCTION("C4E3E97E8C358000000030" , vfnmsubss(xmm1, xmm2, xmm3, ptr(ebp, esi, 0, 128))); + TEST_INSTRUCTION("C4E3E97E8C358000000030" , vfnmsubss(xmm1, xmm2, xmm3, dword_ptr(ebp, esi, 0, 128))); + TEST_INSTRUCTION("C4E3697E8C2B8000000060" , vfnmsubss(xmm1, xmm2, ptr(ebx, ebp, 0, 128), xmm6)); + TEST_INSTRUCTION("C4E3697E8C2B8000000060" , vfnmsubss(xmm1, xmm2, dword_ptr(ebx, ebp, 0, 128), xmm6)); + TEST_INSTRUCTION("62F3FD0866CA01" , vfpclasspd(k1, xmm2, 1)); + TEST_INSTRUCTION("62F3FD2866CA01" , vfpclasspd(k1, ymm2, 1)); + TEST_INSTRUCTION("62F3FD4866CA01" , vfpclasspd(k1, zmm2, 1)); + TEST_INSTRUCTION("62F3FD08664C1A0801" , vfpclasspd(k1, xmmword_ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("62F3FD28664C1A0401" , vfpclasspd(k1, ymmword_ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("62F3FD48664C1A0201" , vfpclasspd(k1, zmmword_ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("62F37D0866CA01" , vfpclassps(k1, xmm2, 1)); + TEST_INSTRUCTION("62F37D2866CA01" , vfpclassps(k1, ymm2, 1)); + TEST_INSTRUCTION("62F37D4866CA01" , vfpclassps(k1, zmm2, 1)); + TEST_INSTRUCTION("62F37D08664C1A0801" , vfpclassps(k1, xmmword_ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("62F37D28664C1A0401" , vfpclassps(k1, ymmword_ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("62F37D48664C1A0201" , vfpclassps(k1, zmmword_ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("62F3FD0867CA01" , vfpclasssd(k1, xmm2, 1)); + TEST_INSTRUCTION("62F3FD08674C1A1001" , vfpclasssd(k1, ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("62F3FD08674C1A1001" , vfpclasssd(k1, qword_ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("62F37D0867CA01" , vfpclassss(k1, xmm2, 1)); + TEST_INSTRUCTION("62F37D08674C1A2001" , vfpclassss(k1, ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("62F37D08674C1A2001" , vfpclassss(k1, dword_ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("8FE97881CA" , vfrczpd(xmm1, xmm2)); + TEST_INSTRUCTION("8FE978818C1A80000000" , vfrczpd(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("8FE978818C1A80000000" , vfrczpd(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("8FE97C81CA" , vfrczpd(ymm1, ymm2)); + TEST_INSTRUCTION("8FE97C818C1A80000000" , vfrczpd(ymm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("8FE97C818C1A80000000" , vfrczpd(ymm1, ymmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("8FE97880CA" , vfrczps(xmm1, xmm2)); + TEST_INSTRUCTION("8FE978808C1A80000000" , vfrczps(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("8FE978808C1A80000000" , vfrczps(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("8FE97C80CA" , vfrczps(ymm1, ymm2)); + TEST_INSTRUCTION("8FE97C808C1A80000000" , vfrczps(ymm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("8FE97C808C1A80000000" , vfrczps(ymm1, ymmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("8FE97883CA" , vfrczsd(xmm1, xmm2)); + TEST_INSTRUCTION("8FE978838C1A80000000" , vfrczsd(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("8FE978838C1A80000000" , vfrczsd(xmm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("8FE97882CA" , vfrczss(xmm1, xmm2)); + TEST_INSTRUCTION("8FE978828C1A80000000" , vfrczss(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("8FE978828C1A80000000" , vfrczss(xmm1, dword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C4E2D9928C1A80000000" , vgatherdpd(xmm1, ptr(edx, xmm3, 0, 128), xmm4)); + TEST_INSTRUCTION("C4E2DD928C1A80000000" , vgatherdpd(ymm1, ptr(edx, xmm3, 0, 128), ymm4)); + TEST_INSTRUCTION("62F2FD09924C1A10" , k(k1).vgatherdpd(xmm1, ptr(edx, xmm3, 0, 128))); + TEST_INSTRUCTION("62F2FD29924C1A10" , k(k1).vgatherdpd(ymm1, ptr(edx, xmm3, 0, 128))); + TEST_INSTRUCTION("62F2FD49924C1A10" , k(k1).vgatherdpd(zmm1, ptr(edx, ymm3, 0, 128))); + TEST_INSTRUCTION("C4E259928C1A80000000" , vgatherdps(xmm1, ptr(edx, xmm3, 0, 128), xmm4)); + TEST_INSTRUCTION("C4E25D928C1A80000000" , vgatherdps(ymm1, ptr(edx, ymm3, 0, 128), ymm4)); + TEST_INSTRUCTION("62F27D09924C1A20" , k(k1).vgatherdps(xmm1, ptr(edx, xmm3, 0, 128))); + TEST_INSTRUCTION("62F27D29924C1A20" , k(k1).vgatherdps(ymm1, ptr(edx, ymm3, 0, 128))); + TEST_INSTRUCTION("62F27D49924C1A20" , k(k1).vgatherdps(zmm1, ptr(edx, zmm3, 0, 128))); + TEST_INSTRUCTION("62F2FD49C64C1110" , k(k1).vgatherpf0dpd(ptr(ecx, ymm2, 0, 128))); + TEST_INSTRUCTION("62F27D49C64C1120" , k(k1).vgatherpf0dps(ptr(ecx, zmm2, 0, 128))); + TEST_INSTRUCTION("62F2FD49C74C1110" , k(k1).vgatherpf0qpd(ptr(ecx, zmm2, 0, 128))); + TEST_INSTRUCTION("62F27D49C74C1120" , k(k1).vgatherpf0qps(ptr(ecx, zmm2, 0, 128))); + TEST_INSTRUCTION("62F2FD49C6541110" , k(k1).vgatherpf1dpd(ptr(ecx, ymm2, 0, 128))); + TEST_INSTRUCTION("62F27D49C6541120" , k(k1).vgatherpf1dps(ptr(ecx, zmm2, 0, 128))); + TEST_INSTRUCTION("62F2FD49C7541110" , k(k1).vgatherpf1qpd(ptr(ecx, zmm2, 0, 128))); + TEST_INSTRUCTION("62F27D49C7541120" , k(k1).vgatherpf1qps(ptr(ecx, zmm2, 0, 128))); + TEST_INSTRUCTION("C4E2D9938C1A80000000" , vgatherqpd(xmm1, ptr(edx, xmm3, 0, 128), xmm4)); + TEST_INSTRUCTION("C4E2DD938C1A80000000" , vgatherqpd(ymm1, ptr(edx, ymm3, 0, 128), ymm4)); + TEST_INSTRUCTION("62F2FD09934C1A10" , k(k1).vgatherqpd(xmm1, ptr(edx, xmm3, 0, 128))); + TEST_INSTRUCTION("62F2FD29934C1A10" , k(k1).vgatherqpd(ymm1, ptr(edx, ymm3, 0, 128))); + TEST_INSTRUCTION("62F2FD49934C1A10" , k(k1).vgatherqpd(zmm1, ptr(edx, zmm3, 0, 128))); + TEST_INSTRUCTION("C4E259938C1A80000000" , vgatherqps(xmm1, ptr(edx, xmm3, 0, 128), xmm4)); + TEST_INSTRUCTION("C4E25D938C1A80000000" , vgatherqps(xmm1, ptr(edx, ymm3, 0, 128), xmm4)); + TEST_INSTRUCTION("62F27D09934C1A20" , k(k1).vgatherqps(xmm1, ptr(edx, xmm3, 0, 128))); + TEST_INSTRUCTION("62F27D29934C1A20" , k(k1).vgatherqps(xmm1, ptr(edx, ymm3, 0, 128))); + TEST_INSTRUCTION("62F27D49934C1A20" , k(k1).vgatherqps(ymm1, ptr(edx, zmm3, 0, 128))); + TEST_INSTRUCTION("62F2FD0842CA" , vgetexppd(xmm1, xmm2)); + TEST_INSTRUCTION("62F2FD08424C1A08" , vgetexppd(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F2FD08424C1A08" , vgetexppd(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F2FD2842CA" , vgetexppd(ymm1, ymm2)); + TEST_INSTRUCTION("62F2FD28424C1A04" , vgetexppd(ymm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F2FD28424C1A04" , vgetexppd(ymm1, ymmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F2FD4842CA" , vgetexppd(zmm1, zmm2)); + TEST_INSTRUCTION("62F2FD48424C1A02" , vgetexppd(zmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F2FD48424C1A02" , vgetexppd(zmm1, zmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F27D0842CA" , vgetexpps(xmm1, xmm2)); + TEST_INSTRUCTION("62F27D08424C1A08" , vgetexpps(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F27D08424C1A08" , vgetexpps(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F27D2842CA" , vgetexpps(ymm1, ymm2)); + TEST_INSTRUCTION("62F27D28424C1A04" , vgetexpps(ymm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F27D28424C1A04" , vgetexpps(ymm1, ymmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F27D4842CA" , vgetexpps(zmm1, zmm2)); + TEST_INSTRUCTION("62F27D48424C1A02" , vgetexpps(zmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F27D48424C1A02" , vgetexpps(zmm1, zmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F2ED0843CB" , vgetexpsd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("62F2ED08434C2B10" , vgetexpsd(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED08434C2B10" , vgetexpsd(xmm1, xmm2, qword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D0843CB" , vgetexpss(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("62F26D08434C2B20" , vgetexpss(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D08434C2B20" , vgetexpss(xmm1, xmm2, dword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F3FD0826CA01" , vgetmantpd(xmm1, xmm2, 1)); + TEST_INSTRUCTION("62F3FD08264C1A0801" , vgetmantpd(xmm1, ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("62F3FD08264C1A0801" , vgetmantpd(xmm1, xmmword_ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("62F3FD2826CA01" , vgetmantpd(ymm1, ymm2, 1)); + TEST_INSTRUCTION("62F3FD28264C1A0401" , vgetmantpd(ymm1, ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("62F3FD28264C1A0401" , vgetmantpd(ymm1, ymmword_ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("62F3FD4826CA01" , vgetmantpd(zmm1, zmm2, 1)); + TEST_INSTRUCTION("62F3FD48264C1A0201" , vgetmantpd(zmm1, ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("62F3FD48264C1A0201" , vgetmantpd(zmm1, zmmword_ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("62F37D0826CA01" , vgetmantps(xmm1, xmm2, 1)); + TEST_INSTRUCTION("62F37D08264C1A0801" , vgetmantps(xmm1, ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("62F37D08264C1A0801" , vgetmantps(xmm1, xmmword_ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("62F37D2826CA01" , vgetmantps(ymm1, ymm2, 1)); + TEST_INSTRUCTION("62F37D28264C1A0401" , vgetmantps(ymm1, ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("62F37D28264C1A0401" , vgetmantps(ymm1, ymmword_ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("62F37D4826CA01" , vgetmantps(zmm1, zmm2, 1)); + TEST_INSTRUCTION("62F37D48264C1A0201" , vgetmantps(zmm1, ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("62F37D48264C1A0201" , vgetmantps(zmm1, zmmword_ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED0827CB01" , vgetmantsd(xmm1, xmm2, xmm3, 1)); + TEST_INSTRUCTION("62F3ED08274C2B1001" , vgetmantsd(xmm1, xmm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED08274C2B1001" , vgetmantsd(xmm1, xmm2, qword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D0827CB01" , vgetmantss(xmm1, xmm2, xmm3, 1)); + TEST_INSTRUCTION("62F36D08274C2B2001" , vgetmantss(xmm1, xmm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D08274C2B2001" , vgetmantss(xmm1, xmm2, dword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("C4E3E9CFCB01" , vgf2p8affineinvqb(xmm1, xmm2, xmm3, 1)); + TEST_INSTRUCTION("C4E3E9CF8C2B8000000001" , vgf2p8affineinvqb(xmm1, xmm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("C4E3E9CF8C2B8000000001" , vgf2p8affineinvqb(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("C4E3EDCFCB01" , vgf2p8affineinvqb(ymm1, ymm2, ymm3, 1)); + TEST_INSTRUCTION("C4E3EDCF8C2B8000000001" , vgf2p8affineinvqb(ymm1, ymm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("C4E3EDCF8C2B8000000001" , vgf2p8affineinvqb(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED48CFCB01" , vgf2p8affineinvqb(zmm1, zmm2, zmm3, 1)); + TEST_INSTRUCTION("62F3ED48CF4C2B0201" , vgf2p8affineinvqb(zmm1, zmm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED48CF4C2B0201" , vgf2p8affineinvqb(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("C4E3E9CECB01" , vgf2p8affineqb(xmm1, xmm2, xmm3, 1)); + TEST_INSTRUCTION("C4E3E9CE8C2B8000000001" , vgf2p8affineqb(xmm1, xmm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("C4E3E9CE8C2B8000000001" , vgf2p8affineqb(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("C4E3EDCECB01" , vgf2p8affineqb(ymm1, ymm2, ymm3, 1)); + TEST_INSTRUCTION("C4E3EDCE8C2B8000000001" , vgf2p8affineqb(ymm1, ymm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("C4E3EDCE8C2B8000000001" , vgf2p8affineqb(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED48CECB01" , vgf2p8affineqb(zmm1, zmm2, zmm3, 1)); + TEST_INSTRUCTION("62F3ED48CE4C2B0201" , vgf2p8affineqb(zmm1, zmm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED48CE4C2B0201" , vgf2p8affineqb(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("C4E269CFCB" , vgf2p8mulb(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E269CF8C2B80000000" , vgf2p8mulb(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E269CF8C2B80000000" , vgf2p8mulb(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E26DCFCB" , vgf2p8mulb(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C4E26DCF8C2B80000000" , vgf2p8mulb(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E26DCF8C2B80000000" , vgf2p8mulb(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D48CFCB" , vgf2p8mulb(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F26D48CF4C2B02" , vgf2p8mulb(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D48CF4C2B02" , vgf2p8mulb(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5E97CCB" , vhaddpd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5E97C8C2B80000000" , vhaddpd(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5E97C8C2B80000000" , vhaddpd(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5ED7CCB" , vhaddpd(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C5ED7C8C2B80000000" , vhaddpd(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5ED7C8C2B80000000" , vhaddpd(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5EB7CCB" , vhaddps(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5EB7C8C2B80000000" , vhaddps(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5EB7C8C2B80000000" , vhaddps(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5EF7CCB" , vhaddps(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C5EF7C8C2B80000000" , vhaddps(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5EF7C8C2B80000000" , vhaddps(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5E97DCB" , vhsubpd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5E97D8C2B80000000" , vhsubpd(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5E97D8C2B80000000" , vhsubpd(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5ED7DCB" , vhsubpd(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C5ED7D8C2B80000000" , vhsubpd(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5ED7D8C2B80000000" , vhsubpd(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5EB7DCB" , vhsubps(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5EB7D8C2B80000000" , vhsubps(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5EB7D8C2B80000000" , vhsubps(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5EF7DCB" , vhsubps(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C5EF7D8C2B80000000" , vhsubps(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5EF7D8C2B80000000" , vhsubps(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E36D18CB01" , vinsertf128(ymm1, ymm2, xmm3, 1)); + TEST_INSTRUCTION("C4E36D188C2B8000000001" , vinsertf128(ymm1, ymm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("C4E36D188C2B8000000001" , vinsertf128(ymm1, ymm2, xmmword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D2818CB01" , vinsertf32x4(ymm1, ymm2, xmm3, 1)); + TEST_INSTRUCTION("62F36D28184C2B0801" , vinsertf32x4(ymm1, ymm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D28184C2B0801" , vinsertf32x4(ymm1, ymm2, xmmword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D4818CB01" , vinsertf32x4(zmm1, zmm2, xmm3, 1)); + TEST_INSTRUCTION("62F36D48184C2B0801" , vinsertf32x4(zmm1, zmm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D48184C2B0801" , vinsertf32x4(zmm1, zmm2, xmmword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D481ACB01" , vinsertf32x8(zmm1, zmm2, ymm3, 1)); + TEST_INSTRUCTION("62F36D481A4C2B0401" , vinsertf32x8(zmm1, zmm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D481A4C2B0401" , vinsertf32x8(zmm1, zmm2, ymmword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED2818CB01" , vinsertf64x2(ymm1, ymm2, xmm3, 1)); + TEST_INSTRUCTION("62F3ED28184C2B0801" , vinsertf64x2(ymm1, ymm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED28184C2B0801" , vinsertf64x2(ymm1, ymm2, xmmword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED4818CB01" , vinsertf64x2(zmm1, zmm2, xmm3, 1)); + TEST_INSTRUCTION("62F3ED48184C2B0801" , vinsertf64x2(zmm1, zmm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED48184C2B0801" , vinsertf64x2(zmm1, zmm2, xmmword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED481ACB01" , vinsertf64x4(zmm1, zmm2, ymm3, 1)); + TEST_INSTRUCTION("62F3ED481A4C2B0401" , vinsertf64x4(zmm1, zmm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED481A4C2B0401" , vinsertf64x4(zmm1, zmm2, ymmword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("C4E36D38CB01" , vinserti128(ymm1, ymm2, xmm3, 1)); + TEST_INSTRUCTION("C4E36D388C2B8000000001" , vinserti128(ymm1, ymm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("C4E36D388C2B8000000001" , vinserti128(ymm1, ymm2, xmmword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D2838CB01" , vinserti32x4(ymm1, ymm2, xmm3, 1)); + TEST_INSTRUCTION("62F36D28384C2B0801" , vinserti32x4(ymm1, ymm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D28384C2B0801" , vinserti32x4(ymm1, ymm2, xmmword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D4838CB01" , vinserti32x4(zmm1, zmm2, xmm3, 1)); + TEST_INSTRUCTION("62F36D48384C2B0801" , vinserti32x4(zmm1, zmm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D48384C2B0801" , vinserti32x4(zmm1, zmm2, xmmword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D483ACB01" , vinserti32x8(zmm1, zmm2, ymm3, 1)); + TEST_INSTRUCTION("62F36D483A4C2B0401" , vinserti32x8(zmm1, zmm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D483A4C2B0401" , vinserti32x8(zmm1, zmm2, ymmword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED2838CB01" , vinserti64x2(ymm1, ymm2, xmm3, 1)); + TEST_INSTRUCTION("62F3ED28384C2B0801" , vinserti64x2(ymm1, ymm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED28384C2B0801" , vinserti64x2(ymm1, ymm2, xmmword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED4838CB01" , vinserti64x2(zmm1, zmm2, xmm3, 1)); + TEST_INSTRUCTION("62F3ED48384C2B0801" , vinserti64x2(zmm1, zmm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED48384C2B0801" , vinserti64x2(zmm1, zmm2, xmmword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED483ACB01" , vinserti64x4(zmm1, zmm2, ymm3, 1)); + TEST_INSTRUCTION("62F3ED483A4C2B0401" , vinserti64x4(zmm1, zmm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED483A4C2B0401" , vinserti64x4(zmm1, zmm2, ymmword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("C4E36921CB01" , vinsertps(xmm1, xmm2, xmm3, 1)); + TEST_INSTRUCTION("C4E369218C2B8000000001" , vinsertps(xmm1, xmm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("C4E369218C2B8000000001" , vinsertps(xmm1, xmm2, dword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("C5FBF08C1A80000000" , vlddqu(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C5FBF08C1A80000000" , vlddqu(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C5FFF08C1A80000000" , vlddqu(ymm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C5FFF08C1A80000000" , vlddqu(ymm1, ymmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C5F8AE941180000000" , vldmxcsr(ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("C5F8AE941180000000" , vldmxcsr(dword_ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("C5F9F7CA" , vmaskmovdqu(xmm1, xmm2, ptr(edi))); + TEST_INSTRUCTION("C5F9F7CA" , vmaskmovdqu(xmm1, xmm2, xmmword_ptr(edi))); + TEST_INSTRUCTION("C4E2612FA41180000000" , vmaskmovpd(ptr(ecx, edx, 0, 128), xmm3, xmm4)); + TEST_INSTRUCTION("C4E2612FA41180000000" , vmaskmovpd(xmmword_ptr(ecx, edx, 0, 128), xmm3, xmm4)); + TEST_INSTRUCTION("C4E2652FA41180000000" , vmaskmovpd(ptr(ecx, edx, 0, 128), ymm3, ymm4)); + TEST_INSTRUCTION("C4E2652FA41180000000" , vmaskmovpd(ymmword_ptr(ecx, edx, 0, 128), ymm3, ymm4)); + TEST_INSTRUCTION("C4E2692D8C2B80000000" , vmaskmovpd(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E2692D8C2B80000000" , vmaskmovpd(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E26D2D8C2B80000000" , vmaskmovpd(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E26D2D8C2B80000000" , vmaskmovpd(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E2612EA41180000000" , vmaskmovps(ptr(ecx, edx, 0, 128), xmm3, xmm4)); + TEST_INSTRUCTION("C4E2612EA41180000000" , vmaskmovps(xmmword_ptr(ecx, edx, 0, 128), xmm3, xmm4)); + TEST_INSTRUCTION("C4E2652EA41180000000" , vmaskmovps(ptr(ecx, edx, 0, 128), ymm3, ymm4)); + TEST_INSTRUCTION("C4E2652EA41180000000" , vmaskmovps(ymmword_ptr(ecx, edx, 0, 128), ymm3, ymm4)); + TEST_INSTRUCTION("C4E2692C8C2B80000000" , vmaskmovps(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E2692C8C2B80000000" , vmaskmovps(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E26D2C8C2B80000000" , vmaskmovps(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E26D2C8C2B80000000" , vmaskmovps(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5E95FCB" , vmaxpd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5E95F8C2B80000000" , vmaxpd(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5E95F8C2B80000000" , vmaxpd(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5ED5FCB" , vmaxpd(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C5ED5F8C2B80000000" , vmaxpd(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5ED5F8C2B80000000" , vmaxpd(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F1ED485FCB" , vmaxpd(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F1ED485F4C2B02" , vmaxpd(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F1ED485F4C2B02" , vmaxpd(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5E85FCB" , vmaxps(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5E85F8C2B80000000" , vmaxps(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5E85F8C2B80000000" , vmaxps(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5EC5FCB" , vmaxps(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C5EC5F8C2B80000000" , vmaxps(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5EC5F8C2B80000000" , vmaxps(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16C485FCB" , vmaxps(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F16C485F4C2B02" , vmaxps(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16C485F4C2B02" , vmaxps(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5EB5FCB" , vmaxsd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5EB5F8C2B80000000" , vmaxsd(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5EB5F8C2B80000000" , vmaxsd(xmm1, xmm2, qword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5EA5FCB" , vmaxss(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5EA5F8C2B80000000" , vmaxss(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5EA5F8C2B80000000" , vmaxss(xmm1, xmm2, dword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5E95DCB" , vminpd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5E95D8C2B80000000" , vminpd(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5E95D8C2B80000000" , vminpd(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5ED5DCB" , vminpd(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C5ED5D8C2B80000000" , vminpd(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5ED5D8C2B80000000" , vminpd(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F1ED485DCB" , vminpd(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F1ED485D4C2B02" , vminpd(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F1ED485D4C2B02" , vminpd(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5E85DCB" , vminps(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5E85D8C2B80000000" , vminps(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5E85D8C2B80000000" , vminps(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5EC5DCB" , vminps(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C5EC5D8C2B80000000" , vminps(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5EC5D8C2B80000000" , vminps(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16C485DCB" , vminps(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F16C485D4C2B02" , vminps(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16C485D4C2B02" , vminps(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5EB5DCB" , vminsd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5EB5D8C2B80000000" , vminsd(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5EB5D8C2B80000000" , vminsd(xmm1, xmm2, qword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5EA5DCB" , vminss(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5EA5D8C2B80000000" , vminss(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5EA5D8C2B80000000" , vminss(xmm1, xmm2, dword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5F928CA" , vmovapd(xmm1, xmm2)); + TEST_INSTRUCTION("C5F9288C1A80000000" , vmovapd(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C5F9288C1A80000000" , vmovapd(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C5F9299C1180000000" , vmovapd(ptr(ecx, edx, 0, 128), xmm3)); + TEST_INSTRUCTION("C5F9299C1180000000" , vmovapd(xmmword_ptr(ecx, edx, 0, 128), xmm3)); + TEST_INSTRUCTION("C5FD28CA" , vmovapd(ymm1, ymm2)); + TEST_INSTRUCTION("C5FD288C1A80000000" , vmovapd(ymm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C5FD288C1A80000000" , vmovapd(ymm1, ymmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C5FD299C1180000000" , vmovapd(ptr(ecx, edx, 0, 128), ymm3)); + TEST_INSTRUCTION("C5FD299C1180000000" , vmovapd(ymmword_ptr(ecx, edx, 0, 128), ymm3)); + TEST_INSTRUCTION("62F1FD4828CA" , vmovapd(zmm1, zmm2)); + TEST_INSTRUCTION("62F1FD48284C1A02" , vmovapd(zmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F1FD48284C1A02" , vmovapd(zmm1, zmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F1FD48295C1102" , vmovapd(ptr(ecx, edx, 0, 128), zmm3)); + TEST_INSTRUCTION("62F1FD48295C1102" , vmovapd(zmmword_ptr(ecx, edx, 0, 128), zmm3)); + TEST_INSTRUCTION("C5F828CA" , vmovaps(xmm1, xmm2)); + TEST_INSTRUCTION("C5F8288C1A80000000" , vmovaps(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C5F8288C1A80000000" , vmovaps(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C5F8299C1180000000" , vmovaps(ptr(ecx, edx, 0, 128), xmm3)); + TEST_INSTRUCTION("C5F8299C1180000000" , vmovaps(xmmword_ptr(ecx, edx, 0, 128), xmm3)); + TEST_INSTRUCTION("C5FC28CA" , vmovaps(ymm1, ymm2)); + TEST_INSTRUCTION("C5FC288C1A80000000" , vmovaps(ymm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C5FC288C1A80000000" , vmovaps(ymm1, ymmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C5FC299C1180000000" , vmovaps(ptr(ecx, edx, 0, 128), ymm3)); + TEST_INSTRUCTION("C5FC299C1180000000" , vmovaps(ymmword_ptr(ecx, edx, 0, 128), ymm3)); + TEST_INSTRUCTION("62F17C4828CA" , vmovaps(zmm1, zmm2)); + TEST_INSTRUCTION("62F17C48284C1A02" , vmovaps(zmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F17C48284C1A02" , vmovaps(zmm1, zmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F17C48295C1102" , vmovaps(ptr(ecx, edx, 0, 128), zmm3)); + TEST_INSTRUCTION("62F17C48295C1102" , vmovaps(zmmword_ptr(ecx, edx, 0, 128), zmm3)); + TEST_INSTRUCTION("C5F97ED1" , vmovd(ecx, xmm2)); + TEST_INSTRUCTION("C5F97E9C1180000000" , vmovd(ptr(ecx, edx, 0, 128), xmm3)); + TEST_INSTRUCTION("C5F97E9C1180000000" , vmovd(dword_ptr(ecx, edx, 0, 128), xmm3)); + TEST_INSTRUCTION("C5F96ECA" , vmovd(xmm1, edx)); + TEST_INSTRUCTION("C5F96E8C1A80000000" , vmovd(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C5F96E8C1A80000000" , vmovd(xmm1, dword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C5FB12CA" , vmovddup(xmm1, xmm2)); + TEST_INSTRUCTION("C5FB128C1A80000000" , vmovddup(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C5FB128C1A80000000" , vmovddup(xmm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C5FF12CA" , vmovddup(ymm1, ymm2)); + TEST_INSTRUCTION("C5FF128C1A80000000" , vmovddup(ymm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C5FF128C1A80000000" , vmovddup(ymm1, ymmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F1FF4812CA" , vmovddup(zmm1, zmm2)); + TEST_INSTRUCTION("62F1FF48124C1A02" , vmovddup(zmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F1FF48124C1A02" , vmovddup(zmm1, zmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C5F96FCA" , vmovdqa(xmm1, xmm2)); + TEST_INSTRUCTION("C5F96F8C1A80000000" , vmovdqa(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C5F96F8C1A80000000" , vmovdqa(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C5F97F9C1180000000" , vmovdqa(ptr(ecx, edx, 0, 128), xmm3)); + TEST_INSTRUCTION("C5F97F9C1180000000" , vmovdqa(xmmword_ptr(ecx, edx, 0, 128), xmm3)); + TEST_INSTRUCTION("C5FD6FCA" , vmovdqa(ymm1, ymm2)); + TEST_INSTRUCTION("C5FD6F8C1A80000000" , vmovdqa(ymm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C5FD6F8C1A80000000" , vmovdqa(ymm1, ymmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C5FD7F9C1180000000" , vmovdqa(ptr(ecx, edx, 0, 128), ymm3)); + TEST_INSTRUCTION("C5FD7F9C1180000000" , vmovdqa(ymmword_ptr(ecx, edx, 0, 128), ymm3)); + TEST_INSTRUCTION("62F17D086FCA" , vmovdqa32(xmm1, xmm2)); + TEST_INSTRUCTION("62F17D086F4C1A08" , vmovdqa32(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F17D086F4C1A08" , vmovdqa32(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F17D087F5C1108" , vmovdqa32(ptr(ecx, edx, 0, 128), xmm3)); + TEST_INSTRUCTION("62F17D087F5C1108" , vmovdqa32(xmmword_ptr(ecx, edx, 0, 128), xmm3)); + TEST_INSTRUCTION("62F17D286FCA" , vmovdqa32(ymm1, ymm2)); + TEST_INSTRUCTION("62F17D286F4C1A04" , vmovdqa32(ymm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F17D286F4C1A04" , vmovdqa32(ymm1, ymmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F17D287F5C1104" , vmovdqa32(ptr(ecx, edx, 0, 128), ymm3)); + TEST_INSTRUCTION("62F17D287F5C1104" , vmovdqa32(ymmword_ptr(ecx, edx, 0, 128), ymm3)); + TEST_INSTRUCTION("62F17D486FCA" , vmovdqa32(zmm1, zmm2)); + TEST_INSTRUCTION("62F17D486F4C1A02" , vmovdqa32(zmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F17D486F4C1A02" , vmovdqa32(zmm1, zmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F17D487F5C1102" , vmovdqa32(ptr(ecx, edx, 0, 128), zmm3)); + TEST_INSTRUCTION("62F17D487F5C1102" , vmovdqa32(zmmword_ptr(ecx, edx, 0, 128), zmm3)); + TEST_INSTRUCTION("62F1FD086FCA" , vmovdqa64(xmm1, xmm2)); + TEST_INSTRUCTION("62F1FD086F4C1A08" , vmovdqa64(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F1FD086F4C1A08" , vmovdqa64(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F1FD087F5C1108" , vmovdqa64(ptr(ecx, edx, 0, 128), xmm3)); + TEST_INSTRUCTION("62F1FD087F5C1108" , vmovdqa64(xmmword_ptr(ecx, edx, 0, 128), xmm3)); + TEST_INSTRUCTION("62F1FD286FCA" , vmovdqa64(ymm1, ymm2)); + TEST_INSTRUCTION("62F1FD286F4C1A04" , vmovdqa64(ymm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F1FD286F4C1A04" , vmovdqa64(ymm1, ymmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F1FD287F5C1104" , vmovdqa64(ptr(ecx, edx, 0, 128), ymm3)); + TEST_INSTRUCTION("62F1FD287F5C1104" , vmovdqa64(ymmword_ptr(ecx, edx, 0, 128), ymm3)); + TEST_INSTRUCTION("62F1FD486FCA" , vmovdqa64(zmm1, zmm2)); + TEST_INSTRUCTION("62F1FD486F4C1A02" , vmovdqa64(zmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F1FD486F4C1A02" , vmovdqa64(zmm1, zmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F1FD487F5C1102" , vmovdqa64(ptr(ecx, edx, 0, 128), zmm3)); + TEST_INSTRUCTION("62F1FD487F5C1102" , vmovdqa64(zmmword_ptr(ecx, edx, 0, 128), zmm3)); + TEST_INSTRUCTION("C5FA6FCA" , vmovdqu(xmm1, xmm2)); + TEST_INSTRUCTION("C5FA6F8C1A80000000" , vmovdqu(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C5FA6F8C1A80000000" , vmovdqu(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C5FA7F9C1180000000" , vmovdqu(ptr(ecx, edx, 0, 128), xmm3)); + TEST_INSTRUCTION("C5FA7F9C1180000000" , vmovdqu(xmmword_ptr(ecx, edx, 0, 128), xmm3)); + TEST_INSTRUCTION("C5FE6FCA" , vmovdqu(ymm1, ymm2)); + TEST_INSTRUCTION("C5FE6F8C1A80000000" , vmovdqu(ymm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C5FE6F8C1A80000000" , vmovdqu(ymm1, ymmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C5FE7F9C1180000000" , vmovdqu(ptr(ecx, edx, 0, 128), ymm3)); + TEST_INSTRUCTION("C5FE7F9C1180000000" , vmovdqu(ymmword_ptr(ecx, edx, 0, 128), ymm3)); + TEST_INSTRUCTION("62F1FF086FCA" , vmovdqu16(xmm1, xmm2)); + TEST_INSTRUCTION("62F1FF086F4C1A08" , vmovdqu16(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F1FF086F4C1A08" , vmovdqu16(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F1FF087F5C1108" , vmovdqu16(ptr(ecx, edx, 0, 128), xmm3)); + TEST_INSTRUCTION("62F1FF087F5C1108" , vmovdqu16(xmmword_ptr(ecx, edx, 0, 128), xmm3)); + TEST_INSTRUCTION("62F1FF286FCA" , vmovdqu16(ymm1, ymm2)); + TEST_INSTRUCTION("62F1FF286F4C1A04" , vmovdqu16(ymm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F1FF286F4C1A04" , vmovdqu16(ymm1, ymmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F1FF287F5C1104" , vmovdqu16(ptr(ecx, edx, 0, 128), ymm3)); + TEST_INSTRUCTION("62F1FF287F5C1104" , vmovdqu16(ymmword_ptr(ecx, edx, 0, 128), ymm3)); + TEST_INSTRUCTION("62F1FF486FCA" , vmovdqu16(zmm1, zmm2)); + TEST_INSTRUCTION("62F1FF486F4C1A02" , vmovdqu16(zmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F1FF486F4C1A02" , vmovdqu16(zmm1, zmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F1FF487F5C1102" , vmovdqu16(ptr(ecx, edx, 0, 128), zmm3)); + TEST_INSTRUCTION("62F1FF487F5C1102" , vmovdqu16(zmmword_ptr(ecx, edx, 0, 128), zmm3)); + TEST_INSTRUCTION("62F17E086FCA" , vmovdqu32(xmm1, xmm2)); + TEST_INSTRUCTION("62F17E086F4C1A08" , vmovdqu32(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F17E086F4C1A08" , vmovdqu32(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F17E087F5C1108" , vmovdqu32(ptr(ecx, edx, 0, 128), xmm3)); + TEST_INSTRUCTION("62F17E087F5C1108" , vmovdqu32(xmmword_ptr(ecx, edx, 0, 128), xmm3)); + TEST_INSTRUCTION("62F17E286FCA" , vmovdqu32(ymm1, ymm2)); + TEST_INSTRUCTION("62F17E286F4C1A04" , vmovdqu32(ymm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F17E286F4C1A04" , vmovdqu32(ymm1, ymmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F17E287F5C1104" , vmovdqu32(ptr(ecx, edx, 0, 128), ymm3)); + TEST_INSTRUCTION("62F17E287F5C1104" , vmovdqu32(ymmword_ptr(ecx, edx, 0, 128), ymm3)); + TEST_INSTRUCTION("62F17E486FCA" , vmovdqu32(zmm1, zmm2)); + TEST_INSTRUCTION("62F17E486F4C1A02" , vmovdqu32(zmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F17E486F4C1A02" , vmovdqu32(zmm1, zmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F17E487F5C1102" , vmovdqu32(ptr(ecx, edx, 0, 128), zmm3)); + TEST_INSTRUCTION("62F17E487F5C1102" , vmovdqu32(zmmword_ptr(ecx, edx, 0, 128), zmm3)); + TEST_INSTRUCTION("62F1FE086FCA" , vmovdqu64(xmm1, xmm2)); + TEST_INSTRUCTION("62F1FE086F4C1A08" , vmovdqu64(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F1FE086F4C1A08" , vmovdqu64(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F1FE087F5C1108" , vmovdqu64(ptr(ecx, edx, 0, 128), xmm3)); + TEST_INSTRUCTION("62F1FE087F5C1108" , vmovdqu64(xmmword_ptr(ecx, edx, 0, 128), xmm3)); + TEST_INSTRUCTION("62F1FE286FCA" , vmovdqu64(ymm1, ymm2)); + TEST_INSTRUCTION("62F1FE286F4C1A04" , vmovdqu64(ymm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F1FE286F4C1A04" , vmovdqu64(ymm1, ymmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F1FE287F5C1104" , vmovdqu64(ptr(ecx, edx, 0, 128), ymm3)); + TEST_INSTRUCTION("62F1FE287F5C1104" , vmovdqu64(ymmword_ptr(ecx, edx, 0, 128), ymm3)); + TEST_INSTRUCTION("62F1FE486FCA" , vmovdqu64(zmm1, zmm2)); + TEST_INSTRUCTION("62F1FE486F4C1A02" , vmovdqu64(zmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F1FE486F4C1A02" , vmovdqu64(zmm1, zmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F1FE487F5C1102" , vmovdqu64(ptr(ecx, edx, 0, 128), zmm3)); + TEST_INSTRUCTION("62F1FE487F5C1102" , vmovdqu64(zmmword_ptr(ecx, edx, 0, 128), zmm3)); + TEST_INSTRUCTION("62F17F086FCA" , vmovdqu8(xmm1, xmm2)); + TEST_INSTRUCTION("62F17F086F4C1A08" , vmovdqu8(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F17F086F4C1A08" , vmovdqu8(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F17F087F5C1108" , vmovdqu8(ptr(ecx, edx, 0, 128), xmm3)); + TEST_INSTRUCTION("62F17F087F5C1108" , vmovdqu8(xmmword_ptr(ecx, edx, 0, 128), xmm3)); + TEST_INSTRUCTION("62F17F286FCA" , vmovdqu8(ymm1, ymm2)); + TEST_INSTRUCTION("62F17F286F4C1A04" , vmovdqu8(ymm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F17F286F4C1A04" , vmovdqu8(ymm1, ymmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F17F287F5C1104" , vmovdqu8(ptr(ecx, edx, 0, 128), ymm3)); + TEST_INSTRUCTION("62F17F287F5C1104" , vmovdqu8(ymmword_ptr(ecx, edx, 0, 128), ymm3)); + TEST_INSTRUCTION("62F17F486FCA" , vmovdqu8(zmm1, zmm2)); + TEST_INSTRUCTION("62F17F486F4C1A02" , vmovdqu8(zmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F17F486F4C1A02" , vmovdqu8(zmm1, zmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F17F487F5C1102" , vmovdqu8(ptr(ecx, edx, 0, 128), zmm3)); + TEST_INSTRUCTION("62F17F487F5C1102" , vmovdqu8(zmmword_ptr(ecx, edx, 0, 128), zmm3)); + TEST_INSTRUCTION("C5E812CB" , vmovhlps(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5F9179C1180000000" , vmovhpd(ptr(ecx, edx, 0, 128), xmm3)); + TEST_INSTRUCTION("C5F9179C1180000000" , vmovhpd(qword_ptr(ecx, edx, 0, 128), xmm3)); + TEST_INSTRUCTION("C5E9168C2B80000000" , vmovhpd(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5E9168C2B80000000" , vmovhpd(xmm1, xmm2, qword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5F8179C1180000000" , vmovhps(ptr(ecx, edx, 0, 128), xmm3)); + TEST_INSTRUCTION("C5F8179C1180000000" , vmovhps(qword_ptr(ecx, edx, 0, 128), xmm3)); + TEST_INSTRUCTION("C5E8168C2B80000000" , vmovhps(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5E8168C2B80000000" , vmovhps(xmm1, xmm2, qword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5E816CB" , vmovlhps(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5F9139C1180000000" , vmovlpd(ptr(ecx, edx, 0, 128), xmm3)); + TEST_INSTRUCTION("C5F9139C1180000000" , vmovlpd(qword_ptr(ecx, edx, 0, 128), xmm3)); + TEST_INSTRUCTION("C5E9128C2B80000000" , vmovlpd(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5E9128C2B80000000" , vmovlpd(xmm1, xmm2, qword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5F8139C1180000000" , vmovlps(ptr(ecx, edx, 0, 128), xmm3)); + TEST_INSTRUCTION("C5F8139C1180000000" , vmovlps(qword_ptr(ecx, edx, 0, 128), xmm3)); + TEST_INSTRUCTION("C5E8128C2B80000000" , vmovlps(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5E8128C2B80000000" , vmovlps(xmm1, xmm2, qword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5F950CA" , vmovmskpd(ecx, xmm2)); + TEST_INSTRUCTION("C5FD50CA" , vmovmskpd(ecx, ymm2)); + TEST_INSTRUCTION("C5F850CA" , vmovmskps(ecx, xmm2)); + TEST_INSTRUCTION("C5FC50CA" , vmovmskps(ecx, ymm2)); + TEST_INSTRUCTION("C5F9E79C1180000000" , vmovntdq(ptr(ecx, edx, 0, 128), xmm3)); + TEST_INSTRUCTION("C5F9E79C1180000000" , vmovntdq(xmmword_ptr(ecx, edx, 0, 128), xmm3)); + TEST_INSTRUCTION("C5FDE79C1180000000" , vmovntdq(ptr(ecx, edx, 0, 128), ymm3)); + TEST_INSTRUCTION("C5FDE79C1180000000" , vmovntdq(ymmword_ptr(ecx, edx, 0, 128), ymm3)); + TEST_INSTRUCTION("62F17D48E75C1102" , vmovntdq(ptr(ecx, edx, 0, 128), zmm3)); + TEST_INSTRUCTION("62F17D48E75C1102" , vmovntdq(zmmword_ptr(ecx, edx, 0, 128), zmm3)); + TEST_INSTRUCTION("C4E2792A8C1A80000000" , vmovntdqa(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C4E2792A8C1A80000000" , vmovntdqa(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C4E27D2A8C1A80000000" , vmovntdqa(ymm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C4E27D2A8C1A80000000" , vmovntdqa(ymm1, ymmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F27D482A4C1A02" , vmovntdqa(zmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F27D482A4C1A02" , vmovntdqa(zmm1, zmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C5F92B9C1180000000" , vmovntpd(ptr(ecx, edx, 0, 128), xmm3)); + TEST_INSTRUCTION("C5F92B9C1180000000" , vmovntpd(xmmword_ptr(ecx, edx, 0, 128), xmm3)); + TEST_INSTRUCTION("C5FD2B9C1180000000" , vmovntpd(ptr(ecx, edx, 0, 128), ymm3)); + TEST_INSTRUCTION("C5FD2B9C1180000000" , vmovntpd(ymmword_ptr(ecx, edx, 0, 128), ymm3)); + TEST_INSTRUCTION("62F1FD482B5C1102" , vmovntpd(ptr(ecx, edx, 0, 128), zmm3)); + TEST_INSTRUCTION("62F1FD482B5C1102" , vmovntpd(zmmword_ptr(ecx, edx, 0, 128), zmm3)); + TEST_INSTRUCTION("C5F82B9C1180000000" , vmovntps(ptr(ecx, edx, 0, 128), xmm3)); + TEST_INSTRUCTION("C5F82B9C1180000000" , vmovntps(xmmword_ptr(ecx, edx, 0, 128), xmm3)); + TEST_INSTRUCTION("C5FC2B9C1180000000" , vmovntps(ptr(ecx, edx, 0, 128), ymm3)); + TEST_INSTRUCTION("C5FC2B9C1180000000" , vmovntps(ymmword_ptr(ecx, edx, 0, 128), ymm3)); + TEST_INSTRUCTION("62F17C482B5C1102" , vmovntps(ptr(ecx, edx, 0, 128), zmm3)); + TEST_INSTRUCTION("62F17C482B5C1102" , vmovntps(zmmword_ptr(ecx, edx, 0, 128), zmm3)); + TEST_INSTRUCTION("C5FA7ECA" , vmovq(xmm1, xmm2)); + TEST_INSTRUCTION("C5FA7E8C1A80000000" , vmovq(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C5FA7E8C1A80000000" , vmovq(xmm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C5F9D69C1180000000" , vmovq(ptr(ecx, edx, 0, 128), xmm3)); + TEST_INSTRUCTION("C5F9D69C1180000000" , vmovq(qword_ptr(ecx, edx, 0, 128), xmm3)); + TEST_INSTRUCTION("C5FB119C1180000000" , vmovsd(ptr(ecx, edx, 0, 128), xmm3)); + TEST_INSTRUCTION("C5FB119C1180000000" , vmovsd(qword_ptr(ecx, edx, 0, 128), xmm3)); + TEST_INSTRUCTION("C5FB108C1A80000000" , vmovsd(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C5FB108C1A80000000" , vmovsd(xmm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C5EB10CB" , vmovsd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5FA16CA" , vmovshdup(xmm1, xmm2)); + TEST_INSTRUCTION("C5FA168C1A80000000" , vmovshdup(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C5FA168C1A80000000" , vmovshdup(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C5FE16CA" , vmovshdup(ymm1, ymm2)); + TEST_INSTRUCTION("C5FE168C1A80000000" , vmovshdup(ymm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C5FE168C1A80000000" , vmovshdup(ymm1, ymmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F17E4816CA" , vmovshdup(zmm1, zmm2)); + TEST_INSTRUCTION("62F17E48164C1A02" , vmovshdup(zmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F17E48164C1A02" , vmovshdup(zmm1, zmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C5FA12CA" , vmovsldup(xmm1, xmm2)); + TEST_INSTRUCTION("C5FA128C1A80000000" , vmovsldup(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C5FA128C1A80000000" , vmovsldup(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C5FE12CA" , vmovsldup(ymm1, ymm2)); + TEST_INSTRUCTION("C5FE128C1A80000000" , vmovsldup(ymm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C5FE128C1A80000000" , vmovsldup(ymm1, ymmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F17E4812CA" , vmovsldup(zmm1, zmm2)); + TEST_INSTRUCTION("62F17E48124C1A02" , vmovsldup(zmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F17E48124C1A02" , vmovsldup(zmm1, zmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C5FA119C1180000000" , vmovss(ptr(ecx, edx, 0, 128), xmm3)); + TEST_INSTRUCTION("C5FA119C1180000000" , vmovss(dword_ptr(ecx, edx, 0, 128), xmm3)); + TEST_INSTRUCTION("C5FA108C1A80000000" , vmovss(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C5FA108C1A80000000" , vmovss(xmm1, dword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C5EA10CB" , vmovss(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5F910CA" , vmovupd(xmm1, xmm2)); + TEST_INSTRUCTION("C5F9108C1A80000000" , vmovupd(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C5F9108C1A80000000" , vmovupd(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C5F9119C1180000000" , vmovupd(ptr(ecx, edx, 0, 128), xmm3)); + TEST_INSTRUCTION("C5F9119C1180000000" , vmovupd(xmmword_ptr(ecx, edx, 0, 128), xmm3)); + TEST_INSTRUCTION("C5FD10CA" , vmovupd(ymm1, ymm2)); + TEST_INSTRUCTION("C5FD108C1A80000000" , vmovupd(ymm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C5FD108C1A80000000" , vmovupd(ymm1, ymmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C5FD119C1180000000" , vmovupd(ptr(ecx, edx, 0, 128), ymm3)); + TEST_INSTRUCTION("C5FD119C1180000000" , vmovupd(ymmword_ptr(ecx, edx, 0, 128), ymm3)); + TEST_INSTRUCTION("62F1FD4810CA" , vmovupd(zmm1, zmm2)); + TEST_INSTRUCTION("62F1FD48104C1A02" , vmovupd(zmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F1FD48104C1A02" , vmovupd(zmm1, zmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F1FD48115C1102" , vmovupd(ptr(ecx, edx, 0, 128), zmm3)); + TEST_INSTRUCTION("62F1FD48115C1102" , vmovupd(zmmword_ptr(ecx, edx, 0, 128), zmm3)); + TEST_INSTRUCTION("C5F810CA" , vmovups(xmm1, xmm2)); + TEST_INSTRUCTION("C5F8108C1A80000000" , vmovups(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C5F8108C1A80000000" , vmovups(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C5F8119C1180000000" , vmovups(ptr(ecx, edx, 0, 128), xmm3)); + TEST_INSTRUCTION("C5F8119C1180000000" , vmovups(xmmword_ptr(ecx, edx, 0, 128), xmm3)); + TEST_INSTRUCTION("C5FC10CA" , vmovups(ymm1, ymm2)); + TEST_INSTRUCTION("C5FC108C1A80000000" , vmovups(ymm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C5FC108C1A80000000" , vmovups(ymm1, ymmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C5FC119C1180000000" , vmovups(ptr(ecx, edx, 0, 128), ymm3)); + TEST_INSTRUCTION("C5FC119C1180000000" , vmovups(ymmword_ptr(ecx, edx, 0, 128), ymm3)); + TEST_INSTRUCTION("62F17C4810CA" , vmovups(zmm1, zmm2)); + TEST_INSTRUCTION("62F17C48104C1A02" , vmovups(zmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F17C48104C1A02" , vmovups(zmm1, zmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F17C48115C1102" , vmovups(ptr(ecx, edx, 0, 128), zmm3)); + TEST_INSTRUCTION("62F17C48115C1102" , vmovups(zmmword_ptr(ecx, edx, 0, 128), zmm3)); + TEST_INSTRUCTION("C4E36942CB01" , vmpsadbw(xmm1, xmm2, xmm3, 1)); + TEST_INSTRUCTION("C4E369428C2B8000000001" , vmpsadbw(xmm1, xmm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("C4E369428C2B8000000001" , vmpsadbw(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("C4E36D42CB01" , vmpsadbw(ymm1, ymm2, ymm3, 1)); + TEST_INSTRUCTION("C4E36D428C2B8000000001" , vmpsadbw(ymm1, ymm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("C4E36D428C2B8000000001" , vmpsadbw(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("C5E959CB" , vmulpd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5E9598C2B80000000" , vmulpd(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5E9598C2B80000000" , vmulpd(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5ED59CB" , vmulpd(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C5ED598C2B80000000" , vmulpd(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5ED598C2B80000000" , vmulpd(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F1ED4859CB" , vmulpd(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F1ED48594C2B02" , vmulpd(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F1ED48594C2B02" , vmulpd(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5E859CB" , vmulps(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5E8598C2B80000000" , vmulps(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5E8598C2B80000000" , vmulps(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5EC59CB" , vmulps(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C5EC598C2B80000000" , vmulps(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5EC598C2B80000000" , vmulps(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16C4859CB" , vmulps(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F16C48594C2B02" , vmulps(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16C48594C2B02" , vmulps(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5EB59CB" , vmulsd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5EB598C2B80000000" , vmulsd(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5EB598C2B80000000" , vmulsd(xmm1, xmm2, qword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5EA59CB" , vmulss(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5EA598C2B80000000" , vmulss(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5EA598C2B80000000" , vmulss(xmm1, xmm2, dword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5E956CB" , vorpd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5E9568C2B80000000" , vorpd(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5E9568C2B80000000" , vorpd(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5ED56CB" , vorpd(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C5ED568C2B80000000" , vorpd(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5ED568C2B80000000" , vorpd(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F1ED4856CB" , vorpd(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F1ED48564C2B02" , vorpd(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F1ED48564C2B02" , vorpd(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5E856CB" , vorps(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5E8568C2B80000000" , vorps(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5E8568C2B80000000" , vorps(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5EC56CB" , vorps(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C5EC568C2B80000000" , vorps(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5EC568C2B80000000" , vorps(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16C4856CB" , vorps(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F16C48564C2B02" , vorps(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16C48564C2B02" , vorps(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F25F0868D1" , vp2intersectd(k2, k3, xmm4, xmm1)); + TEST_INSTRUCTION("62F25F0868541108" , vp2intersectd(k2, k3, xmm4, ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("62F25F0868541108" , vp2intersectd(k2, k3, xmm4, xmmword_ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("62F25F2868D1" , vp2intersectd(k2, k3, ymm4, ymm1)); + TEST_INSTRUCTION("62F25F2868541104" , vp2intersectd(k2, k3, ymm4, ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("62F25F2868541104" , vp2intersectd(k2, k3, ymm4, ymmword_ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("62F25F4868D1" , vp2intersectd(k2, k3, zmm4, zmm1)); + TEST_INSTRUCTION("62F25F4868541102" , vp2intersectd(k2, k3, zmm4, ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("62F25F4868541102" , vp2intersectd(k2, k3, zmm4, zmmword_ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("62F2DF0868D1" , vp2intersectq(k2, k3, xmm4, xmm1)); + TEST_INSTRUCTION("62F2DF0868541108" , vp2intersectq(k2, k3, xmm4, ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("62F2DF0868541108" , vp2intersectq(k2, k3, xmm4, xmmword_ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("62F2DF2868D1" , vp2intersectq(k2, k3, ymm4, ymm1)); + TEST_INSTRUCTION("62F2DF2868541104" , vp2intersectq(k2, k3, ymm4, ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("62F2DF2868541104" , vp2intersectq(k2, k3, ymm4, ymmword_ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("62F2DF4868D1" , vp2intersectq(k2, k3, zmm4, zmm1)); + TEST_INSTRUCTION("62F2DF4868541102" , vp2intersectq(k2, k3, zmm4, ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("62F2DF4868541102" , vp2intersectq(k2, k3, zmm4, zmmword_ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("62F25F48524C1A08" , vp4dpwssd(zmm1, zmm4, zmm5, zmm6, zmm7, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F25F48524C1A08" , vp4dpwssd(zmm1, zmm4, zmm5, zmm6, zmm7, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F25F48534C1A08" , vp4dpwssds(zmm1, zmm4, zmm5, zmm6, zmm7, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F25F48534C1A08" , vp4dpwssds(zmm1, zmm4, zmm5, zmm6, zmm7, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C4E2791CCA" , vpabsb(xmm1, xmm2)); + TEST_INSTRUCTION("C4E2791C8C1A80000000" , vpabsb(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C4E2791C8C1A80000000" , vpabsb(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C4E27D1CCA" , vpabsb(ymm1, ymm2)); + TEST_INSTRUCTION("C4E27D1C8C1A80000000" , vpabsb(ymm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C4E27D1C8C1A80000000" , vpabsb(ymm1, ymmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F27D481CCA" , vpabsb(zmm1, zmm2)); + TEST_INSTRUCTION("62F27D481C4C1A02" , vpabsb(zmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F27D481C4C1A02" , vpabsb(zmm1, zmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C4E2791ECA" , vpabsd(xmm1, xmm2)); + TEST_INSTRUCTION("C4E2791E8C1A80000000" , vpabsd(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C4E2791E8C1A80000000" , vpabsd(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C4E27D1ECA" , vpabsd(ymm1, ymm2)); + TEST_INSTRUCTION("C4E27D1E8C1A80000000" , vpabsd(ymm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C4E27D1E8C1A80000000" , vpabsd(ymm1, ymmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F27D481ECA" , vpabsd(zmm1, zmm2)); + TEST_INSTRUCTION("62F27D481E4C1A02" , vpabsd(zmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F27D481E4C1A02" , vpabsd(zmm1, zmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F2FD081FCA" , vpabsq(xmm1, xmm2)); + TEST_INSTRUCTION("62F2FD081F4C1A08" , vpabsq(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F2FD081F4C1A08" , vpabsq(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F2FD281FCA" , vpabsq(ymm1, ymm2)); + TEST_INSTRUCTION("62F2FD281F4C1A04" , vpabsq(ymm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F2FD281F4C1A04" , vpabsq(ymm1, ymmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F2FD481FCA" , vpabsq(zmm1, zmm2)); + TEST_INSTRUCTION("62F2FD481F4C1A02" , vpabsq(zmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F2FD481F4C1A02" , vpabsq(zmm1, zmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C4E2791DCA" , vpabsw(xmm1, xmm2)); + TEST_INSTRUCTION("C4E2791D8C1A80000000" , vpabsw(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C4E2791D8C1A80000000" , vpabsw(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C4E27D1DCA" , vpabsw(ymm1, ymm2)); + TEST_INSTRUCTION("C4E27D1D8C1A80000000" , vpabsw(ymm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C4E27D1D8C1A80000000" , vpabsw(ymm1, ymmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F27D481DCA" , vpabsw(zmm1, zmm2)); + TEST_INSTRUCTION("62F27D481D4C1A02" , vpabsw(zmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F27D481D4C1A02" , vpabsw(zmm1, zmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C5E96BCB" , vpackssdw(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5E96B8C2B80000000" , vpackssdw(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5E96B8C2B80000000" , vpackssdw(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5ED6BCB" , vpackssdw(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C5ED6B8C2B80000000" , vpackssdw(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5ED6B8C2B80000000" , vpackssdw(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16D486BCB" , vpackssdw(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F16D486B4C2B02" , vpackssdw(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16D486B4C2B02" , vpackssdw(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5E963CB" , vpacksswb(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5E9638C2B80000000" , vpacksswb(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5E9638C2B80000000" , vpacksswb(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5ED63CB" , vpacksswb(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C5ED638C2B80000000" , vpacksswb(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5ED638C2B80000000" , vpacksswb(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16D4863CB" , vpacksswb(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F16D48634C2B02" , vpacksswb(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16D48634C2B02" , vpacksswb(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E2692BCB" , vpackusdw(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E2692B8C2B80000000" , vpackusdw(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E2692B8C2B80000000" , vpackusdw(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E26D2BCB" , vpackusdw(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C4E26D2B8C2B80000000" , vpackusdw(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E26D2B8C2B80000000" , vpackusdw(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D482BCB" , vpackusdw(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F26D482B4C2B02" , vpackusdw(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D482B4C2B02" , vpackusdw(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5E967CB" , vpackuswb(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5E9678C2B80000000" , vpackuswb(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5E9678C2B80000000" , vpackuswb(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5ED67CB" , vpackuswb(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C5ED678C2B80000000" , vpackuswb(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5ED678C2B80000000" , vpackuswb(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16D4867CB" , vpackuswb(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F16D48674C2B02" , vpackuswb(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16D48674C2B02" , vpackuswb(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5E9FCCB" , vpaddb(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5E9FC8C2B80000000" , vpaddb(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5E9FC8C2B80000000" , vpaddb(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5EDFCCB" , vpaddb(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C5EDFC8C2B80000000" , vpaddb(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5EDFC8C2B80000000" , vpaddb(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16D48FCCB" , vpaddb(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F16D48FC4C2B02" , vpaddb(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16D48FC4C2B02" , vpaddb(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5E9FECB" , vpaddd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5E9FE8C2B80000000" , vpaddd(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5E9FE8C2B80000000" , vpaddd(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5EDFECB" , vpaddd(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C5EDFE8C2B80000000" , vpaddd(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5EDFE8C2B80000000" , vpaddd(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16D48FECB" , vpaddd(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F16D48FE4C2B02" , vpaddd(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16D48FE4C2B02" , vpaddd(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5E9D4CB" , vpaddq(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5E9D48C2B80000000" , vpaddq(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5E9D48C2B80000000" , vpaddq(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5EDD4CB" , vpaddq(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C5EDD48C2B80000000" , vpaddq(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5EDD48C2B80000000" , vpaddq(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F1ED48D4CB" , vpaddq(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F1ED48D44C2B02" , vpaddq(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F1ED48D44C2B02" , vpaddq(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5E9ECCB" , vpaddsb(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5E9EC8C2B80000000" , vpaddsb(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5E9EC8C2B80000000" , vpaddsb(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5EDECCB" , vpaddsb(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C5EDEC8C2B80000000" , vpaddsb(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5EDEC8C2B80000000" , vpaddsb(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16D48ECCB" , vpaddsb(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F16D48EC4C2B02" , vpaddsb(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16D48EC4C2B02" , vpaddsb(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5E9EDCB" , vpaddsw(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5E9ED8C2B80000000" , vpaddsw(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5E9ED8C2B80000000" , vpaddsw(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5EDEDCB" , vpaddsw(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C5EDED8C2B80000000" , vpaddsw(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5EDED8C2B80000000" , vpaddsw(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16D48EDCB" , vpaddsw(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F16D48ED4C2B02" , vpaddsw(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16D48ED4C2B02" , vpaddsw(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5E9DCCB" , vpaddusb(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5E9DC8C2B80000000" , vpaddusb(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5E9DC8C2B80000000" , vpaddusb(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5EDDCCB" , vpaddusb(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C5EDDC8C2B80000000" , vpaddusb(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5EDDC8C2B80000000" , vpaddusb(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16D48DCCB" , vpaddusb(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F16D48DC4C2B02" , vpaddusb(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16D48DC4C2B02" , vpaddusb(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5E9DDCB" , vpaddusw(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5E9DD8C2B80000000" , vpaddusw(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5E9DD8C2B80000000" , vpaddusw(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5EDDDCB" , vpaddusw(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C5EDDD8C2B80000000" , vpaddusw(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5EDDD8C2B80000000" , vpaddusw(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16D48DDCB" , vpaddusw(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F16D48DD4C2B02" , vpaddusw(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16D48DD4C2B02" , vpaddusw(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5E9FDCB" , vpaddw(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5E9FD8C2B80000000" , vpaddw(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5E9FD8C2B80000000" , vpaddw(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5EDFDCB" , vpaddw(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C5EDFD8C2B80000000" , vpaddw(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5EDFD8C2B80000000" , vpaddw(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16D48FDCB" , vpaddw(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F16D48FD4C2B02" , vpaddw(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16D48FD4C2B02" , vpaddw(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E3690FCB01" , vpalignr(xmm1, xmm2, xmm3, 1)); + TEST_INSTRUCTION("C4E3690F8C2B8000000001" , vpalignr(xmm1, xmm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("C4E3690F8C2B8000000001" , vpalignr(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("C4E36D0FCB01" , vpalignr(ymm1, ymm2, ymm3, 1)); + TEST_INSTRUCTION("C4E36D0F8C2B8000000001" , vpalignr(ymm1, ymm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("C4E36D0F8C2B8000000001" , vpalignr(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D480FCB01" , vpalignr(zmm1, zmm2, zmm3, 1)); + TEST_INSTRUCTION("62F36D480F4C2B0201" , vpalignr(zmm1, zmm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D480F4C2B0201" , vpalignr(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("C5E9DBCB" , vpand(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5E9DB8C2B80000000" , vpand(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5E9DB8C2B80000000" , vpand(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5EDDBCB" , vpand(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C5EDDB8C2B80000000" , vpand(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5EDDB8C2B80000000" , vpand(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16D08DBCB" , vpandd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("62F16D08DB4C2B08" , vpandd(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16D08DB4C2B08" , vpandd(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16D28DBCB" , vpandd(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("62F16D28DB4C2B04" , vpandd(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16D28DB4C2B04" , vpandd(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16D48DBCB" , vpandd(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F16D48DB4C2B02" , vpandd(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16D48DB4C2B02" , vpandd(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5E9DFCB" , vpandn(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5E9DF8C2B80000000" , vpandn(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5E9DF8C2B80000000" , vpandn(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5EDDFCB" , vpandn(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C5EDDF8C2B80000000" , vpandn(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5EDDF8C2B80000000" , vpandn(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16D08DFCB" , vpandnd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("62F16D08DF4C2B08" , vpandnd(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16D08DF4C2B08" , vpandnd(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16D28DFCB" , vpandnd(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("62F16D28DF4C2B04" , vpandnd(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16D28DF4C2B04" , vpandnd(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16D48DFCB" , vpandnd(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F16D48DF4C2B02" , vpandnd(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16D48DF4C2B02" , vpandnd(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F1ED08DFCB" , vpandnq(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("62F1ED08DF4C2B08" , vpandnq(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F1ED08DF4C2B08" , vpandnq(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F1ED28DFCB" , vpandnq(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("62F1ED28DF4C2B04" , vpandnq(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F1ED28DF4C2B04" , vpandnq(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F1ED48DFCB" , vpandnq(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F1ED48DF4C2B02" , vpandnq(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F1ED48DF4C2B02" , vpandnq(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F1ED08DBCB" , vpandq(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("62F1ED08DB4C2B08" , vpandq(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F1ED08DB4C2B08" , vpandq(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F1ED28DBCB" , vpandq(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("62F1ED28DB4C2B04" , vpandq(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F1ED28DB4C2B04" , vpandq(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F1ED48DBCB" , vpandq(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F1ED48DB4C2B02" , vpandq(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F1ED48DB4C2B02" , vpandq(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5E9E0CB" , vpavgb(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5E9E08C2B80000000" , vpavgb(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5E9E08C2B80000000" , vpavgb(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5EDE0CB" , vpavgb(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C5EDE08C2B80000000" , vpavgb(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5EDE08C2B80000000" , vpavgb(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16D48E0CB" , vpavgb(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F16D48E04C2B02" , vpavgb(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16D48E04C2B02" , vpavgb(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5E9E3CB" , vpavgw(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5E9E38C2B80000000" , vpavgw(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5E9E38C2B80000000" , vpavgw(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5EDE3CB" , vpavgw(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C5EDE38C2B80000000" , vpavgw(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5EDE38C2B80000000" , vpavgw(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16D48E3CB" , vpavgw(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F16D48E34C2B02" , vpavgw(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16D48E34C2B02" , vpavgw(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E36902CB01" , vpblendd(xmm1, xmm2, xmm3, 1)); + TEST_INSTRUCTION("C4E369028C2B8000000001" , vpblendd(xmm1, xmm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("C4E369028C2B8000000001" , vpblendd(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("C4E36D02CB01" , vpblendd(ymm1, ymm2, ymm3, 1)); + TEST_INSTRUCTION("C4E36D028C2B8000000001" , vpblendd(ymm1, ymm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("C4E36D028C2B8000000001" , vpblendd(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F26D0866CB" , vpblendmb(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("62F26D08664C2B08" , vpblendmb(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D08664C2B08" , vpblendmb(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D2866CB" , vpblendmb(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("62F26D28664C2B04" , vpblendmb(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D28664C2B04" , vpblendmb(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D4866CB" , vpblendmb(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F26D48664C2B02" , vpblendmb(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D48664C2B02" , vpblendmb(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D0864CB" , vpblendmd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("62F26D08644C2B08" , vpblendmd(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D08644C2B08" , vpblendmd(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D2864CB" , vpblendmd(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("62F26D28644C2B04" , vpblendmd(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D28644C2B04" , vpblendmd(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D4864CB" , vpblendmd(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F26D48644C2B02" , vpblendmd(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D48644C2B02" , vpblendmd(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED0864CB" , vpblendmq(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("62F2ED08644C2B08" , vpblendmq(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED08644C2B08" , vpblendmq(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED2864CB" , vpblendmq(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("62F2ED28644C2B04" , vpblendmq(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED28644C2B04" , vpblendmq(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED4864CB" , vpblendmq(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F2ED48644C2B02" , vpblendmq(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED48644C2B02" , vpblendmq(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED0866CB" , vpblendmw(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("62F2ED08664C2B08" , vpblendmw(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED08664C2B08" , vpblendmw(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED2866CB" , vpblendmw(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("62F2ED28664C2B04" , vpblendmw(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED28664C2B04" , vpblendmw(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED4866CB" , vpblendmw(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F2ED48664C2B02" , vpblendmw(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED48664C2B02" , vpblendmw(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E3694CCB40" , vpblendvb(xmm1, xmm2, xmm3, xmm4)); + TEST_INSTRUCTION("C4E3694C8C2B8000000060" , vpblendvb(xmm1, xmm2, ptr(ebx, ebp, 0, 128), xmm6)); + TEST_INSTRUCTION("C4E3694C8C2B8000000060" , vpblendvb(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128), xmm6)); + TEST_INSTRUCTION("C4E36D4CCB40" , vpblendvb(ymm1, ymm2, ymm3, ymm4)); + TEST_INSTRUCTION("C4E36D4C8C2B8000000060" , vpblendvb(ymm1, ymm2, ptr(ebx, ebp, 0, 128), ymm6)); + TEST_INSTRUCTION("C4E36D4C8C2B8000000060" , vpblendvb(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128), ymm6)); + TEST_INSTRUCTION("C4E3690ECB01" , vpblendw(xmm1, xmm2, xmm3, 1)); + TEST_INSTRUCTION("C4E3690E8C2B8000000001" , vpblendw(xmm1, xmm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("C4E3690E8C2B8000000001" , vpblendw(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("C4E36D0ECB01" , vpblendw(ymm1, ymm2, ymm3, 1)); + TEST_INSTRUCTION("C4E36D0E8C2B8000000001" , vpblendw(ymm1, ymm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("C4E36D0E8C2B8000000001" , vpblendw(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F27D087ACA" , vpbroadcastb(xmm1, edx)); + TEST_INSTRUCTION("C4E27978CA" , vpbroadcastb(xmm1, xmm2)); + TEST_INSTRUCTION("C4E279788C1A80000000" , vpbroadcastb(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C4E279788C1A80000000" , vpbroadcastb(xmm1, byte_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F27D287ACA" , vpbroadcastb(ymm1, edx)); + TEST_INSTRUCTION("C4E27D78CA" , vpbroadcastb(ymm1, xmm2)); + TEST_INSTRUCTION("C4E27D788C1A80000000" , vpbroadcastb(ymm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C4E27D788C1A80000000" , vpbroadcastb(ymm1, byte_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F27D487ACA" , vpbroadcastb(zmm1, edx)); + TEST_INSTRUCTION("62F27D4878CA" , vpbroadcastb(zmm1, xmm2)); + TEST_INSTRUCTION("62F27D48788C1A80000000" , vpbroadcastb(zmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F27D48788C1A80000000" , vpbroadcastb(zmm1, byte_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F27D087CCA" , vpbroadcastd(xmm1, edx)); + TEST_INSTRUCTION("C4E27958CA" , vpbroadcastd(xmm1, xmm2)); + TEST_INSTRUCTION("C4E279588C1A80000000" , vpbroadcastd(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C4E279588C1A80000000" , vpbroadcastd(xmm1, dword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F27D287CCA" , vpbroadcastd(ymm1, edx)); + TEST_INSTRUCTION("C4E27D58CA" , vpbroadcastd(ymm1, xmm2)); + TEST_INSTRUCTION("C4E27D588C1A80000000" , vpbroadcastd(ymm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C4E27D588C1A80000000" , vpbroadcastd(ymm1, dword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F27D487CCA" , vpbroadcastd(zmm1, edx)); + TEST_INSTRUCTION("62F27D4858CA" , vpbroadcastd(zmm1, xmm2)); + TEST_INSTRUCTION("62F27D48584C1A20" , vpbroadcastd(zmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F27D48584C1A20" , vpbroadcastd(zmm1, dword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F2FE082ACA" , vpbroadcastmb2q(xmm1, k2)); + TEST_INSTRUCTION("62F2FE282ACA" , vpbroadcastmb2q(ymm1, k2)); + TEST_INSTRUCTION("62F2FE482ACA" , vpbroadcastmb2q(zmm1, k2)); + TEST_INSTRUCTION("62F27E083ACA" , vpbroadcastmw2d(xmm1, k2)); + TEST_INSTRUCTION("62F27E283ACA" , vpbroadcastmw2d(ymm1, k2)); + TEST_INSTRUCTION("62F27E483ACA" , vpbroadcastmw2d(zmm1, k2)); + TEST_INSTRUCTION("C4E27959CA" , vpbroadcastq(xmm1, xmm2)); + TEST_INSTRUCTION("C4E279598C1A80000000" , vpbroadcastq(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C4E279598C1A80000000" , vpbroadcastq(xmm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C4E27D59CA" , vpbroadcastq(ymm1, xmm2)); + TEST_INSTRUCTION("C4E27D598C1A80000000" , vpbroadcastq(ymm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C4E27D598C1A80000000" , vpbroadcastq(ymm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F2FD4859CA" , vpbroadcastq(zmm1, xmm2)); + TEST_INSTRUCTION("62F2FD48594C1A10" , vpbroadcastq(zmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F2FD48594C1A10" , vpbroadcastq(zmm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F27D087BCA" , vpbroadcastw(xmm1, edx)); + TEST_INSTRUCTION("C4E27979CA" , vpbroadcastw(xmm1, xmm2)); + TEST_INSTRUCTION("C4E279798C1A80000000" , vpbroadcastw(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C4E279798C1A80000000" , vpbroadcastw(xmm1, word_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F27D287BCA" , vpbroadcastw(ymm1, edx)); + TEST_INSTRUCTION("C4E27D79CA" , vpbroadcastw(ymm1, xmm2)); + TEST_INSTRUCTION("C4E27D798C1A80000000" , vpbroadcastw(ymm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C4E27D798C1A80000000" , vpbroadcastw(ymm1, word_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F27D487BCA" , vpbroadcastw(zmm1, edx)); + TEST_INSTRUCTION("62F27D4879CA" , vpbroadcastw(zmm1, xmm2)); + TEST_INSTRUCTION("62F27D48794C1A40" , vpbroadcastw(zmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F27D48794C1A40" , vpbroadcastw(zmm1, word_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C4E36944CB01" , vpclmulqdq(xmm1, xmm2, xmm3, 1)); + TEST_INSTRUCTION("C4E369448C2B8000000001" , vpclmulqdq(xmm1, xmm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("C4E369448C2B8000000001" , vpclmulqdq(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("C4E36D44CB01" , vpclmulqdq(ymm1, ymm2, ymm3, 1)); + TEST_INSTRUCTION("C4E36D448C2B8000000001" , vpclmulqdq(ymm1, ymm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("C4E36D448C2B8000000001" , vpclmulqdq(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D4844CB01" , vpclmulqdq(zmm1, zmm2, zmm3, 1)); + TEST_INSTRUCTION("62F36D48444C2B0201" , vpclmulqdq(zmm1, zmm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D48444C2B0201" , vpclmulqdq(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("8FE868A2CB40" , vpcmov(xmm1, xmm2, xmm3, xmm4)); + TEST_INSTRUCTION("8FE8E8A28C358000000030" , vpcmov(xmm1, xmm2, xmm3, ptr(ebp, esi, 0, 128))); + TEST_INSTRUCTION("8FE8E8A28C358000000030" , vpcmov(xmm1, xmm2, xmm3, xmmword_ptr(ebp, esi, 0, 128))); + TEST_INSTRUCTION("8FE868A28C2B8000000060" , vpcmov(xmm1, xmm2, ptr(ebx, ebp, 0, 128), xmm6)); + TEST_INSTRUCTION("8FE868A28C2B8000000060" , vpcmov(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128), xmm6)); + TEST_INSTRUCTION("8FE86CA2CB40" , vpcmov(ymm1, ymm2, ymm3, ymm4)); + TEST_INSTRUCTION("8FE8ECA28C358000000030" , vpcmov(ymm1, ymm2, ymm3, ptr(ebp, esi, 0, 128))); + TEST_INSTRUCTION("8FE8ECA28C358000000030" , vpcmov(ymm1, ymm2, ymm3, ymmword_ptr(ebp, esi, 0, 128))); + TEST_INSTRUCTION("8FE86CA28C2B8000000060" , vpcmov(ymm1, ymm2, ptr(ebx, ebp, 0, 128), ymm6)); + TEST_INSTRUCTION("8FE86CA28C2B8000000060" , vpcmov(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128), ymm6)); + TEST_INSTRUCTION("62F36D083FCB01" , vpcmpb(k1, xmm2, xmm3, 1)); + TEST_INSTRUCTION("62F36D083F4C2B0801" , vpcmpb(k1, xmm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D083F4C2B0801" , vpcmpb(k1, xmm2, xmmword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D283FCB01" , vpcmpb(k1, ymm2, ymm3, 1)); + TEST_INSTRUCTION("62F36D283F4C2B0401" , vpcmpb(k1, ymm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D283F4C2B0401" , vpcmpb(k1, ymm2, ymmword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D483FCB01" , vpcmpb(k1, zmm2, zmm3, 1)); + TEST_INSTRUCTION("62F36D483F4C2B0201" , vpcmpb(k1, zmm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D483F4C2B0201" , vpcmpb(k1, zmm2, zmmword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D081FCB01" , vpcmpd(k1, xmm2, xmm3, 1)); + TEST_INSTRUCTION("62F36D081F4C2B0801" , vpcmpd(k1, xmm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D081F4C2B0801" , vpcmpd(k1, xmm2, xmmword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D281FCB01" , vpcmpd(k1, ymm2, ymm3, 1)); + TEST_INSTRUCTION("62F36D281F4C2B0401" , vpcmpd(k1, ymm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D281F4C2B0401" , vpcmpd(k1, ymm2, ymmword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D481FCB01" , vpcmpd(k1, zmm2, zmm3, 1)); + TEST_INSTRUCTION("62F36D481F4C2B0201" , vpcmpd(k1, zmm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D481F4C2B0201" , vpcmpd(k1, zmm2, zmmword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("C5E974CB" , vpcmpeqb(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5E9748C2B80000000" , vpcmpeqb(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5E9748C2B80000000" , vpcmpeqb(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16D0874CB" , vpcmpeqb(k1, xmm2, xmm3)); + TEST_INSTRUCTION("62F16D08744C2B08" , vpcmpeqb(k1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16D08744C2B08" , vpcmpeqb(k1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5ED74CB" , vpcmpeqb(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C5ED748C2B80000000" , vpcmpeqb(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5ED748C2B80000000" , vpcmpeqb(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16D2874CB" , vpcmpeqb(k1, ymm2, ymm3)); + TEST_INSTRUCTION("62F16D28744C2B04" , vpcmpeqb(k1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16D28744C2B04" , vpcmpeqb(k1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16D4874CB" , vpcmpeqb(k1, zmm2, zmm3)); + TEST_INSTRUCTION("62F16D48744C2B02" , vpcmpeqb(k1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16D48744C2B02" , vpcmpeqb(k1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5E976CB" , vpcmpeqd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5E9768C2B80000000" , vpcmpeqd(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5E9768C2B80000000" , vpcmpeqd(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16D0876CB" , vpcmpeqd(k1, xmm2, xmm3)); + TEST_INSTRUCTION("62F16D08764C2B08" , vpcmpeqd(k1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16D08764C2B08" , vpcmpeqd(k1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5ED76CB" , vpcmpeqd(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C5ED768C2B80000000" , vpcmpeqd(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5ED768C2B80000000" , vpcmpeqd(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16D2876CB" , vpcmpeqd(k1, ymm2, ymm3)); + TEST_INSTRUCTION("62F16D28764C2B04" , vpcmpeqd(k1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16D28764C2B04" , vpcmpeqd(k1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16D4876CB" , vpcmpeqd(k1, zmm2, zmm3)); + TEST_INSTRUCTION("62F16D48764C2B02" , vpcmpeqd(k1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16D48764C2B02" , vpcmpeqd(k1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E26929CB" , vpcmpeqq(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E269298C2B80000000" , vpcmpeqq(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E269298C2B80000000" , vpcmpeqq(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED0829CB" , vpcmpeqq(k1, xmm2, xmm3)); + TEST_INSTRUCTION("62F2ED08294C2B08" , vpcmpeqq(k1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED08294C2B08" , vpcmpeqq(k1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E26D29CB" , vpcmpeqq(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C4E26D298C2B80000000" , vpcmpeqq(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E26D298C2B80000000" , vpcmpeqq(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED2829CB" , vpcmpeqq(k1, ymm2, ymm3)); + TEST_INSTRUCTION("62F2ED28294C2B04" , vpcmpeqq(k1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED28294C2B04" , vpcmpeqq(k1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED4829CB" , vpcmpeqq(k1, zmm2, zmm3)); + TEST_INSTRUCTION("62F2ED48294C2B02" , vpcmpeqq(k1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED48294C2B02" , vpcmpeqq(k1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5E975CB" , vpcmpeqw(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5E9758C2B80000000" , vpcmpeqw(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5E9758C2B80000000" , vpcmpeqw(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16D0875CB" , vpcmpeqw(k1, xmm2, xmm3)); + TEST_INSTRUCTION("62F16D08754C2B08" , vpcmpeqw(k1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16D08754C2B08" , vpcmpeqw(k1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5ED75CB" , vpcmpeqw(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C5ED758C2B80000000" , vpcmpeqw(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5ED758C2B80000000" , vpcmpeqw(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16D2875CB" , vpcmpeqw(k1, ymm2, ymm3)); + TEST_INSTRUCTION("62F16D28754C2B04" , vpcmpeqw(k1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16D28754C2B04" , vpcmpeqw(k1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16D4875CB" , vpcmpeqw(k1, zmm2, zmm3)); + TEST_INSTRUCTION("62F16D48754C2B02" , vpcmpeqw(k1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16D48754C2B02" , vpcmpeqw(k1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E37961CA01" , vpcmpestri(xmm1, xmm2, 1, ecx, eax, edx)); + TEST_INSTRUCTION("C4E379618C1A8000000001" , vpcmpestri(xmm1, ptr(edx, ebx, 0, 128), 1, ecx, eax, edx)); + TEST_INSTRUCTION("C4E379618C1A8000000001" , vpcmpestri(xmm1, xmmword_ptr(edx, ebx, 0, 128), 1, ecx, eax, edx)); + TEST_INSTRUCTION("C4E37960CA01" , vpcmpestrm(xmm1, xmm2, 1, xmm0, eax, edx)); + TEST_INSTRUCTION("C4E379608C1A8000000001" , vpcmpestrm(xmm1, ptr(edx, ebx, 0, 128), 1, xmm0, eax, edx)); + TEST_INSTRUCTION("C4E379608C1A8000000001" , vpcmpestrm(xmm1, xmmword_ptr(edx, ebx, 0, 128), 1, xmm0, eax, edx)); + TEST_INSTRUCTION("C5E964CB" , vpcmpgtb(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5E9648C2B80000000" , vpcmpgtb(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5E9648C2B80000000" , vpcmpgtb(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16D0864CB" , vpcmpgtb(k1, xmm2, xmm3)); + TEST_INSTRUCTION("62F16D08644C2B08" , vpcmpgtb(k1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16D08644C2B08" , vpcmpgtb(k1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5ED64CB" , vpcmpgtb(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C5ED648C2B80000000" , vpcmpgtb(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5ED648C2B80000000" , vpcmpgtb(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16D2864CB" , vpcmpgtb(k1, ymm2, ymm3)); + TEST_INSTRUCTION("62F16D28644C2B04" , vpcmpgtb(k1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16D28644C2B04" , vpcmpgtb(k1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16D4864CB" , vpcmpgtb(k1, zmm2, zmm3)); + TEST_INSTRUCTION("62F16D48644C2B02" , vpcmpgtb(k1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16D48644C2B02" , vpcmpgtb(k1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5E966CB" , vpcmpgtd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5E9668C2B80000000" , vpcmpgtd(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5E9668C2B80000000" , vpcmpgtd(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16D0866CB" , vpcmpgtd(k1, xmm2, xmm3)); + TEST_INSTRUCTION("62F16D08664C2B08" , vpcmpgtd(k1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16D08664C2B08" , vpcmpgtd(k1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5ED66CB" , vpcmpgtd(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C5ED668C2B80000000" , vpcmpgtd(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5ED668C2B80000000" , vpcmpgtd(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16D2866CB" , vpcmpgtd(k1, ymm2, ymm3)); + TEST_INSTRUCTION("62F16D28664C2B04" , vpcmpgtd(k1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16D28664C2B04" , vpcmpgtd(k1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16D4866CB" , vpcmpgtd(k1, zmm2, zmm3)); + TEST_INSTRUCTION("62F16D48664C2B02" , vpcmpgtd(k1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16D48664C2B02" , vpcmpgtd(k1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E26937CB" , vpcmpgtq(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E269378C2B80000000" , vpcmpgtq(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E269378C2B80000000" , vpcmpgtq(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED0837CB" , vpcmpgtq(k1, xmm2, xmm3)); + TEST_INSTRUCTION("62F2ED08374C2B08" , vpcmpgtq(k1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED08374C2B08" , vpcmpgtq(k1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E26D37CB" , vpcmpgtq(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C4E26D378C2B80000000" , vpcmpgtq(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E26D378C2B80000000" , vpcmpgtq(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED2837CB" , vpcmpgtq(k1, ymm2, ymm3)); + TEST_INSTRUCTION("62F2ED28374C2B04" , vpcmpgtq(k1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED28374C2B04" , vpcmpgtq(k1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED4837CB" , vpcmpgtq(k1, zmm2, zmm3)); + TEST_INSTRUCTION("62F2ED48374C2B02" , vpcmpgtq(k1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED48374C2B02" , vpcmpgtq(k1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5E965CB" , vpcmpgtw(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5E9658C2B80000000" , vpcmpgtw(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5E9658C2B80000000" , vpcmpgtw(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16D0865CB" , vpcmpgtw(k1, xmm2, xmm3)); + TEST_INSTRUCTION("62F16D08654C2B08" , vpcmpgtw(k1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16D08654C2B08" , vpcmpgtw(k1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5ED65CB" , vpcmpgtw(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C5ED658C2B80000000" , vpcmpgtw(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5ED658C2B80000000" , vpcmpgtw(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16D2865CB" , vpcmpgtw(k1, ymm2, ymm3)); + TEST_INSTRUCTION("62F16D28654C2B04" , vpcmpgtw(k1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16D28654C2B04" , vpcmpgtw(k1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16D4865CB" , vpcmpgtw(k1, zmm2, zmm3)); + TEST_INSTRUCTION("62F16D48654C2B02" , vpcmpgtw(k1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16D48654C2B02" , vpcmpgtw(k1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E37963CA01" , vpcmpistri(xmm1, xmm2, 1, ecx)); + TEST_INSTRUCTION("C4E379638C1A8000000001" , vpcmpistri(xmm1, ptr(edx, ebx, 0, 128), 1, ecx)); + TEST_INSTRUCTION("C4E379638C1A8000000001" , vpcmpistri(xmm1, xmmword_ptr(edx, ebx, 0, 128), 1, ecx)); + TEST_INSTRUCTION("C4E37962CA01" , vpcmpistrm(xmm1, xmm2, 1, xmm0)); + TEST_INSTRUCTION("C4E379628C1A8000000001" , vpcmpistrm(xmm1, ptr(edx, ebx, 0, 128), 1, xmm0)); + TEST_INSTRUCTION("C4E379628C1A8000000001" , vpcmpistrm(xmm1, xmmword_ptr(edx, ebx, 0, 128), 1, xmm0)); + TEST_INSTRUCTION("62F3ED081FCB01" , vpcmpq(k1, xmm2, xmm3, 1)); + TEST_INSTRUCTION("62F3ED081F4C2B0801" , vpcmpq(k1, xmm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED081F4C2B0801" , vpcmpq(k1, xmm2, xmmword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED281FCB01" , vpcmpq(k1, ymm2, ymm3, 1)); + TEST_INSTRUCTION("62F3ED281F4C2B0401" , vpcmpq(k1, ymm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED281F4C2B0401" , vpcmpq(k1, ymm2, ymmword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED481FCB01" , vpcmpq(k1, zmm2, zmm3, 1)); + TEST_INSTRUCTION("62F3ED481F4C2B0201" , vpcmpq(k1, zmm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED481F4C2B0201" , vpcmpq(k1, zmm2, zmmword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D083ECB01" , vpcmpub(k1, xmm2, xmm3, 1)); + TEST_INSTRUCTION("62F36D083E4C2B0801" , vpcmpub(k1, xmm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D083E4C2B0801" , vpcmpub(k1, xmm2, xmmword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D283ECB01" , vpcmpub(k1, ymm2, ymm3, 1)); + TEST_INSTRUCTION("62F36D283E4C2B0401" , vpcmpub(k1, ymm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D283E4C2B0401" , vpcmpub(k1, ymm2, ymmword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D483ECB01" , vpcmpub(k1, zmm2, zmm3, 1)); + TEST_INSTRUCTION("62F36D483E4C2B0201" , vpcmpub(k1, zmm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D483E4C2B0201" , vpcmpub(k1, zmm2, zmmword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D081ECB01" , vpcmpud(k1, xmm2, xmm3, 1)); + TEST_INSTRUCTION("62F36D081E4C2B0801" , vpcmpud(k1, xmm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D081E4C2B0801" , vpcmpud(k1, xmm2, xmmword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D281ECB01" , vpcmpud(k1, ymm2, ymm3, 1)); + TEST_INSTRUCTION("62F36D281E4C2B0401" , vpcmpud(k1, ymm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D281E4C2B0401" , vpcmpud(k1, ymm2, ymmword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D481ECB01" , vpcmpud(k1, zmm2, zmm3, 1)); + TEST_INSTRUCTION("62F36D481E4C2B0201" , vpcmpud(k1, zmm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D481E4C2B0201" , vpcmpud(k1, zmm2, zmmword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED081ECB01" , vpcmpuq(k1, xmm2, xmm3, 1)); + TEST_INSTRUCTION("62F3ED081E4C2B0801" , vpcmpuq(k1, xmm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED081E4C2B0801" , vpcmpuq(k1, xmm2, xmmword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED281ECB01" , vpcmpuq(k1, ymm2, ymm3, 1)); + TEST_INSTRUCTION("62F3ED281E4C2B0401" , vpcmpuq(k1, ymm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED281E4C2B0401" , vpcmpuq(k1, ymm2, ymmword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED481ECB01" , vpcmpuq(k1, zmm2, zmm3, 1)); + TEST_INSTRUCTION("62F3ED481E4C2B0201" , vpcmpuq(k1, zmm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED481E4C2B0201" , vpcmpuq(k1, zmm2, zmmword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED083ECB01" , vpcmpuw(k1, xmm2, xmm3, 1)); + TEST_INSTRUCTION("62F3ED083E4C2B0801" , vpcmpuw(k1, xmm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED083E4C2B0801" , vpcmpuw(k1, xmm2, xmmword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED283ECB01" , vpcmpuw(k1, ymm2, ymm3, 1)); + TEST_INSTRUCTION("62F3ED283E4C2B0401" , vpcmpuw(k1, ymm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED283E4C2B0401" , vpcmpuw(k1, ymm2, ymmword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED483ECB01" , vpcmpuw(k1, zmm2, zmm3, 1)); + TEST_INSTRUCTION("62F3ED483E4C2B0201" , vpcmpuw(k1, zmm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED483E4C2B0201" , vpcmpuw(k1, zmm2, zmmword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED083FCB01" , vpcmpw(k1, xmm2, xmm3, 1)); + TEST_INSTRUCTION("62F3ED083F4C2B0801" , vpcmpw(k1, xmm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED083F4C2B0801" , vpcmpw(k1, xmm2, xmmword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED283FCB01" , vpcmpw(k1, ymm2, ymm3, 1)); + TEST_INSTRUCTION("62F3ED283F4C2B0401" , vpcmpw(k1, ymm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED283F4C2B0401" , vpcmpw(k1, ymm2, ymmword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED483FCB01" , vpcmpw(k1, zmm2, zmm3, 1)); + TEST_INSTRUCTION("62F3ED483F4C2B0201" , vpcmpw(k1, zmm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED483F4C2B0201" , vpcmpw(k1, zmm2, zmmword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("8FE868CCCB01" , vpcomb(xmm1, xmm2, xmm3, 1)); + TEST_INSTRUCTION("8FE868CC8C2B8000000001" , vpcomb(xmm1, xmm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("8FE868CC8C2B8000000001" , vpcomb(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("8FE868CECB01" , vpcomd(xmm1, xmm2, xmm3, 1)); + TEST_INSTRUCTION("8FE868CE8C2B8000000001" , vpcomd(xmm1, xmm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("8FE868CE8C2B8000000001" , vpcomd(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F27D0863D1" , vpcompressb(xmm1, xmm2)); + TEST_INSTRUCTION("62F27D08639C1180000000" , vpcompressb(ptr(ecx, edx, 0, 128), xmm3)); + TEST_INSTRUCTION("62F27D08639C1180000000" , vpcompressb(xmmword_ptr(ecx, edx, 0, 128), xmm3)); + TEST_INSTRUCTION("62F27D2863D1" , vpcompressb(ymm1, ymm2)); + TEST_INSTRUCTION("62F27D28639C1180000000" , vpcompressb(ptr(ecx, edx, 0, 128), ymm3)); + TEST_INSTRUCTION("62F27D28639C1180000000" , vpcompressb(ymmword_ptr(ecx, edx, 0, 128), ymm3)); + TEST_INSTRUCTION("62F27D4863D1" , vpcompressb(zmm1, zmm2)); + TEST_INSTRUCTION("62F27D48639C1180000000" , vpcompressb(ptr(ecx, edx, 0, 128), zmm3)); + TEST_INSTRUCTION("62F27D48639C1180000000" , vpcompressb(zmmword_ptr(ecx, edx, 0, 128), zmm3)); + TEST_INSTRUCTION("62F27D088BD1" , vpcompressd(xmm1, xmm2)); + TEST_INSTRUCTION("62F27D088B5C1120" , vpcompressd(ptr(ecx, edx, 0, 128), xmm3)); + TEST_INSTRUCTION("62F27D088B5C1120" , vpcompressd(xmmword_ptr(ecx, edx, 0, 128), xmm3)); + TEST_INSTRUCTION("62F27D288BD1" , vpcompressd(ymm1, ymm2)); + TEST_INSTRUCTION("62F27D288B5C1120" , vpcompressd(ptr(ecx, edx, 0, 128), ymm3)); + TEST_INSTRUCTION("62F27D288B5C1120" , vpcompressd(ymmword_ptr(ecx, edx, 0, 128), ymm3)); + TEST_INSTRUCTION("62F27D488BD1" , vpcompressd(zmm1, zmm2)); + TEST_INSTRUCTION("62F27D488B5C1120" , vpcompressd(ptr(ecx, edx, 0, 128), zmm3)); + TEST_INSTRUCTION("62F27D488B5C1120" , vpcompressd(zmmword_ptr(ecx, edx, 0, 128), zmm3)); + TEST_INSTRUCTION("62F2FD088BD1" , vpcompressq(xmm1, xmm2)); + TEST_INSTRUCTION("62F2FD088B5C1110" , vpcompressq(ptr(ecx, edx, 0, 128), xmm3)); + TEST_INSTRUCTION("62F2FD088B5C1110" , vpcompressq(xmmword_ptr(ecx, edx, 0, 128), xmm3)); + TEST_INSTRUCTION("62F2FD288BD1" , vpcompressq(ymm1, ymm2)); + TEST_INSTRUCTION("62F2FD288B5C1110" , vpcompressq(ptr(ecx, edx, 0, 128), ymm3)); + TEST_INSTRUCTION("62F2FD288B5C1110" , vpcompressq(ymmword_ptr(ecx, edx, 0, 128), ymm3)); + TEST_INSTRUCTION("62F2FD488BD1" , vpcompressq(zmm1, zmm2)); + TEST_INSTRUCTION("62F2FD488B5C1110" , vpcompressq(ptr(ecx, edx, 0, 128), zmm3)); + TEST_INSTRUCTION("62F2FD488B5C1110" , vpcompressq(zmmword_ptr(ecx, edx, 0, 128), zmm3)); + TEST_INSTRUCTION("62F2FD0863D1" , vpcompressw(xmm1, xmm2)); + TEST_INSTRUCTION("62F2FD08635C1140" , vpcompressw(ptr(ecx, edx, 0, 128), xmm3)); + TEST_INSTRUCTION("62F2FD08635C1140" , vpcompressw(xmmword_ptr(ecx, edx, 0, 128), xmm3)); + TEST_INSTRUCTION("62F2FD2863D1" , vpcompressw(ymm1, ymm2)); + TEST_INSTRUCTION("62F2FD28635C1140" , vpcompressw(ptr(ecx, edx, 0, 128), ymm3)); + TEST_INSTRUCTION("62F2FD28635C1140" , vpcompressw(ymmword_ptr(ecx, edx, 0, 128), ymm3)); + TEST_INSTRUCTION("62F2FD4863D1" , vpcompressw(zmm1, zmm2)); + TEST_INSTRUCTION("62F2FD48635C1140" , vpcompressw(ptr(ecx, edx, 0, 128), zmm3)); + TEST_INSTRUCTION("62F2FD48635C1140" , vpcompressw(zmmword_ptr(ecx, edx, 0, 128), zmm3)); + TEST_INSTRUCTION("8FE868CFCB01" , vpcomq(xmm1, xmm2, xmm3, 1)); + TEST_INSTRUCTION("8FE868CF8C2B8000000001" , vpcomq(xmm1, xmm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("8FE868CF8C2B8000000001" , vpcomq(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("8FE868ECCB01" , vpcomub(xmm1, xmm2, xmm3, 1)); + TEST_INSTRUCTION("8FE868EC8C2B8000000001" , vpcomub(xmm1, xmm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("8FE868EC8C2B8000000001" , vpcomub(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("8FE868EECB01" , vpcomud(xmm1, xmm2, xmm3, 1)); + TEST_INSTRUCTION("8FE868EE8C2B8000000001" , vpcomud(xmm1, xmm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("8FE868EE8C2B8000000001" , vpcomud(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("8FE868EFCB01" , vpcomuq(xmm1, xmm2, xmm3, 1)); + TEST_INSTRUCTION("8FE868EF8C2B8000000001" , vpcomuq(xmm1, xmm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("8FE868EF8C2B8000000001" , vpcomuq(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("8FE868EDCB01" , vpcomuw(xmm1, xmm2, xmm3, 1)); + TEST_INSTRUCTION("8FE868ED8C2B8000000001" , vpcomuw(xmm1, xmm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("8FE868ED8C2B8000000001" , vpcomuw(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("8FE868CDCB01" , vpcomw(xmm1, xmm2, xmm3, 1)); + TEST_INSTRUCTION("8FE868CD8C2B8000000001" , vpcomw(xmm1, xmm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("8FE868CD8C2B8000000001" , vpcomw(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F27D08C4CA" , vpconflictd(xmm1, xmm2)); + TEST_INSTRUCTION("62F27D08C44C1A08" , vpconflictd(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F27D08C44C1A08" , vpconflictd(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F27D28C4CA" , vpconflictd(ymm1, ymm2)); + TEST_INSTRUCTION("62F27D28C44C1A04" , vpconflictd(ymm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F27D28C44C1A04" , vpconflictd(ymm1, ymmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F27D48C4CA" , vpconflictd(zmm1, zmm2)); + TEST_INSTRUCTION("62F27D48C44C1A02" , vpconflictd(zmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F27D48C44C1A02" , vpconflictd(zmm1, zmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F2FD08C4CA" , vpconflictq(xmm1, xmm2)); + TEST_INSTRUCTION("62F2FD08C44C1A08" , vpconflictq(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F2FD08C44C1A08" , vpconflictq(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F2FD28C4CA" , vpconflictq(ymm1, ymm2)); + TEST_INSTRUCTION("62F2FD28C44C1A04" , vpconflictq(ymm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F2FD28C44C1A04" , vpconflictq(ymm1, ymmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F2FD48C4CA" , vpconflictq(zmm1, zmm2)); + TEST_INSTRUCTION("62F2FD48C44C1A02" , vpconflictq(zmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F2FD48C44C1A02" , vpconflictq(zmm1, zmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F26D0850CB" , vpdpbusd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("62F26D08504C2B08" , vpdpbusd(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D08504C2B08" , vpdpbusd(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D2850CB" , vpdpbusd(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("62F26D28504C2B04" , vpdpbusd(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D28504C2B04" , vpdpbusd(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D4850CB" , vpdpbusd(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F26D48504C2B02" , vpdpbusd(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D48504C2B02" , vpdpbusd(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D0851CB" , vpdpbusds(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("62F26D08514C2B08" , vpdpbusds(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D08514C2B08" , vpdpbusds(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D2851CB" , vpdpbusds(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("62F26D28514C2B04" , vpdpbusds(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D28514C2B04" , vpdpbusds(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D4851CB" , vpdpbusds(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F26D48514C2B02" , vpdpbusds(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D48514C2B02" , vpdpbusds(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D0852CB" , vpdpwssd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("62F26D08524C2B08" , vpdpwssd(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D08524C2B08" , vpdpwssd(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D2852CB" , vpdpwssd(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("62F26D28524C2B04" , vpdpwssd(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D28524C2B04" , vpdpwssd(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D4852CB" , vpdpwssd(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F26D48524C2B02" , vpdpwssd(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D48524C2B02" , vpdpwssd(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D0853CB" , vpdpwssds(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("62F26D08534C2B08" , vpdpwssds(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D08534C2B08" , vpdpwssds(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D2853CB" , vpdpwssds(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("62F26D28534C2B04" , vpdpwssds(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D28534C2B04" , vpdpwssds(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D4853CB" , vpdpwssds(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F26D48534C2B02" , vpdpwssds(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D48534C2B02" , vpdpwssds(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E36D06CB01" , vperm2f128(ymm1, ymm2, ymm3, 1)); + TEST_INSTRUCTION("C4E36D068C2B8000000001" , vperm2f128(ymm1, ymm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("C4E36D068C2B8000000001" , vperm2f128(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("C4E36D46CB01" , vperm2i128(ymm1, ymm2, ymm3, 1)); + TEST_INSTRUCTION("C4E36D468C2B8000000001" , vperm2i128(ymm1, ymm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("C4E36D468C2B8000000001" , vperm2i128(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F26D088DCB" , vpermb(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("62F26D088D4C2B08" , vpermb(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D088D4C2B08" , vpermb(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D288DCB" , vpermb(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("62F26D288D4C2B04" , vpermb(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D288D4C2B04" , vpermb(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D488DCB" , vpermb(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F26D488D4C2B02" , vpermb(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D488D4C2B02" , vpermb(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E26D36CB" , vpermd(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C4E26D368C2B80000000" , vpermd(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E26D368C2B80000000" , vpermd(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D4836CB" , vpermd(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F26D48364C2B02" , vpermd(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D48364C2B02" , vpermd(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D0875CB" , vpermi2b(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("62F26D08754C2B08" , vpermi2b(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D08754C2B08" , vpermi2b(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D2875CB" , vpermi2b(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("62F26D28754C2B04" , vpermi2b(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D28754C2B04" , vpermi2b(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D4875CB" , vpermi2b(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F26D48754C2B02" , vpermi2b(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D48754C2B02" , vpermi2b(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D0876CB" , vpermi2d(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("62F26D08764C2B08" , vpermi2d(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D08764C2B08" , vpermi2d(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D2876CB" , vpermi2d(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("62F26D28764C2B04" , vpermi2d(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D28764C2B04" , vpermi2d(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D4876CB" , vpermi2d(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F26D48764C2B02" , vpermi2d(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D48764C2B02" , vpermi2d(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED0877CB" , vpermi2pd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("62F2ED08774C2B08" , vpermi2pd(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED08774C2B08" , vpermi2pd(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED2877CB" , vpermi2pd(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("62F2ED28774C2B04" , vpermi2pd(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED28774C2B04" , vpermi2pd(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED4877CB" , vpermi2pd(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F2ED48774C2B02" , vpermi2pd(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED48774C2B02" , vpermi2pd(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D0877CB" , vpermi2ps(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("62F26D08774C2B08" , vpermi2ps(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D08774C2B08" , vpermi2ps(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D2877CB" , vpermi2ps(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("62F26D28774C2B04" , vpermi2ps(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D28774C2B04" , vpermi2ps(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D4877CB" , vpermi2ps(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F26D48774C2B02" , vpermi2ps(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D48774C2B02" , vpermi2ps(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED0876CB" , vpermi2q(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("62F2ED08764C2B08" , vpermi2q(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED08764C2B08" , vpermi2q(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED2876CB" , vpermi2q(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("62F2ED28764C2B04" , vpermi2q(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED28764C2B04" , vpermi2q(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED4876CB" , vpermi2q(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F2ED48764C2B02" , vpermi2q(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED48764C2B02" , vpermi2q(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED0875CB" , vpermi2w(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("62F2ED08754C2B08" , vpermi2w(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED08754C2B08" , vpermi2w(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED2875CB" , vpermi2w(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("62F2ED28754C2B04" , vpermi2w(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED28754C2B04" , vpermi2w(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED4875CB" , vpermi2w(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F2ED48754C2B02" , vpermi2w(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED48754C2B02" , vpermi2w(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E36949CB41" , vpermil2pd(xmm1, xmm2, xmm3, xmm4, 1)); + TEST_INSTRUCTION("C4E369498C2B8000000061" , vpermil2pd(xmm1, xmm2, ptr(ebx, ebp, 0, 128), xmm6, 1)); + TEST_INSTRUCTION("C4E369498C2B8000000061" , vpermil2pd(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128), xmm6, 1)); + TEST_INSTRUCTION("C4E3E9498C358000000031" , vpermil2pd(xmm1, xmm2, xmm3, ptr(ebp, esi, 0, 128), 1)); + TEST_INSTRUCTION("C4E3E9498C358000000031" , vpermil2pd(xmm1, xmm2, xmm3, xmmword_ptr(ebp, esi, 0, 128), 1)); + TEST_INSTRUCTION("C4E36D49CB41" , vpermil2pd(ymm1, ymm2, ymm3, ymm4, 1)); + TEST_INSTRUCTION("C4E36D498C2B8000000061" , vpermil2pd(ymm1, ymm2, ptr(ebx, ebp, 0, 128), ymm6, 1)); + TEST_INSTRUCTION("C4E36D498C2B8000000061" , vpermil2pd(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128), ymm6, 1)); + TEST_INSTRUCTION("C4E3ED498C358000000031" , vpermil2pd(ymm1, ymm2, ymm3, ptr(ebp, esi, 0, 128), 1)); + TEST_INSTRUCTION("C4E3ED498C358000000031" , vpermil2pd(ymm1, ymm2, ymm3, ymmword_ptr(ebp, esi, 0, 128), 1)); + TEST_INSTRUCTION("C4E36948CB41" , vpermil2ps(xmm1, xmm2, xmm3, xmm4, 1)); + TEST_INSTRUCTION("C4E369488C2B8000000061" , vpermil2ps(xmm1, xmm2, ptr(ebx, ebp, 0, 128), xmm6, 1)); + TEST_INSTRUCTION("C4E369488C2B8000000061" , vpermil2ps(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128), xmm6, 1)); + TEST_INSTRUCTION("C4E3E9488C358000000031" , vpermil2ps(xmm1, xmm2, xmm3, ptr(ebp, esi, 0, 128), 1)); + TEST_INSTRUCTION("C4E3E9488C358000000031" , vpermil2ps(xmm1, xmm2, xmm3, xmmword_ptr(ebp, esi, 0, 128), 1)); + TEST_INSTRUCTION("C4E36D48CB41" , vpermil2ps(ymm1, ymm2, ymm3, ymm4, 1)); + TEST_INSTRUCTION("C4E36D488C2B8000000061" , vpermil2ps(ymm1, ymm2, ptr(ebx, ebp, 0, 128), ymm6, 1)); + TEST_INSTRUCTION("C4E36D488C2B8000000061" , vpermil2ps(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128), ymm6, 1)); + TEST_INSTRUCTION("C4E3ED488C358000000031" , vpermil2ps(ymm1, ymm2, ymm3, ptr(ebp, esi, 0, 128), 1)); + TEST_INSTRUCTION("C4E3ED488C358000000031" , vpermil2ps(ymm1, ymm2, ymm3, ymmword_ptr(ebp, esi, 0, 128), 1)); + TEST_INSTRUCTION("C4E2690DCB" , vpermilpd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E37905CA01" , vpermilpd(xmm1, xmm2, 1)); + TEST_INSTRUCTION("C4E2690D8C2B80000000" , vpermilpd(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E2690D8C2B80000000" , vpermilpd(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E379058C1A8000000001" , vpermilpd(xmm1, ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("C4E379058C1A8000000001" , vpermilpd(xmm1, xmmword_ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("C4E26D0DCB" , vpermilpd(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C4E37D05CA01" , vpermilpd(ymm1, ymm2, 1)); + TEST_INSTRUCTION("C4E26D0D8C2B80000000" , vpermilpd(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E26D0D8C2B80000000" , vpermilpd(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E37D058C1A8000000001" , vpermilpd(ymm1, ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("C4E37D058C1A8000000001" , vpermilpd(ymm1, ymmword_ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("62F2ED480DCB" , vpermilpd(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F3FD4805CA01" , vpermilpd(zmm1, zmm2, 1)); + TEST_INSTRUCTION("62F2ED480D4C2B02" , vpermilpd(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED480D4C2B02" , vpermilpd(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F3FD48054C1A0201" , vpermilpd(zmm1, ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("62F3FD48054C1A0201" , vpermilpd(zmm1, zmmword_ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("C4E2690CCB" , vpermilps(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E37904CA01" , vpermilps(xmm1, xmm2, 1)); + TEST_INSTRUCTION("C4E2690C8C2B80000000" , vpermilps(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E2690C8C2B80000000" , vpermilps(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E379048C1A8000000001" , vpermilps(xmm1, ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("C4E379048C1A8000000001" , vpermilps(xmm1, xmmword_ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("C4E26D0CCB" , vpermilps(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C4E37D04CA01" , vpermilps(ymm1, ymm2, 1)); + TEST_INSTRUCTION("C4E26D0C8C2B80000000" , vpermilps(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E26D0C8C2B80000000" , vpermilps(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E37D048C1A8000000001" , vpermilps(ymm1, ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("C4E37D048C1A8000000001" , vpermilps(ymm1, ymmword_ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("62F26D480CCB" , vpermilps(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F37D4804CA01" , vpermilps(zmm1, zmm2, 1)); + TEST_INSTRUCTION("62F26D480C4C2B02" , vpermilps(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D480C4C2B02" , vpermilps(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F37D48044C1A0201" , vpermilps(zmm1, ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("62F37D48044C1A0201" , vpermilps(zmm1, zmmword_ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("C4E3FD01CA01" , vpermpd(ymm1, ymm2, 1)); + TEST_INSTRUCTION("C4E3FD018C1A8000000001" , vpermpd(ymm1, ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("C4E3FD018C1A8000000001" , vpermpd(ymm1, ymmword_ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("62F2ED2816CB" , vpermpd(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("62F2ED28164C2B04" , vpermpd(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED28164C2B04" , vpermpd(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED4816CB" , vpermpd(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F3FD4801CA01" , vpermpd(zmm1, zmm2, 1)); + TEST_INSTRUCTION("62F2ED48164C2B02" , vpermpd(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED48164C2B02" , vpermpd(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F3FD48014C1A0201" , vpermpd(zmm1, ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("62F3FD48014C1A0201" , vpermpd(zmm1, zmmword_ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("C4E26D16CB" , vpermps(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C4E26D168C2B80000000" , vpermps(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E26D168C2B80000000" , vpermps(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D4816CB" , vpermps(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F26D48164C2B02" , vpermps(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D48164C2B02" , vpermps(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E3FD00CA01" , vpermq(ymm1, ymm2, 1)); + TEST_INSTRUCTION("C4E3FD008C1A8000000001" , vpermq(ymm1, ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("C4E3FD008C1A8000000001" , vpermq(ymm1, ymmword_ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("62F2ED2836CB" , vpermq(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("62F2ED28364C2B04" , vpermq(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED28364C2B04" , vpermq(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED4836CB" , vpermq(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F3FD4800CA01" , vpermq(zmm1, zmm2, 1)); + TEST_INSTRUCTION("62F2ED48364C2B02" , vpermq(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED48364C2B02" , vpermq(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F3FD48004C1A0201" , vpermq(zmm1, ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("62F3FD48004C1A0201" , vpermq(zmm1, zmmword_ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("62F26D087DCB" , vpermt2b(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("62F26D087D4C2B08" , vpermt2b(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D087D4C2B08" , vpermt2b(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D287DCB" , vpermt2b(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("62F26D287D4C2B04" , vpermt2b(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D287D4C2B04" , vpermt2b(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D487DCB" , vpermt2b(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F26D487D4C2B02" , vpermt2b(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D487D4C2B02" , vpermt2b(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D087ECB" , vpermt2d(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("62F26D087E4C2B08" , vpermt2d(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D087E4C2B08" , vpermt2d(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D287ECB" , vpermt2d(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("62F26D287E4C2B04" , vpermt2d(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D287E4C2B04" , vpermt2d(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D487ECB" , vpermt2d(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F26D487E4C2B02" , vpermt2d(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D487E4C2B02" , vpermt2d(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED087FCB" , vpermt2pd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("62F2ED087F4C2B08" , vpermt2pd(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED087F4C2B08" , vpermt2pd(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED287FCB" , vpermt2pd(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("62F2ED287F4C2B04" , vpermt2pd(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED287F4C2B04" , vpermt2pd(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED487FCB" , vpermt2pd(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F2ED487F4C2B02" , vpermt2pd(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED487F4C2B02" , vpermt2pd(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D087FCB" , vpermt2ps(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("62F26D087F4C2B08" , vpermt2ps(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D087F4C2B08" , vpermt2ps(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D287FCB" , vpermt2ps(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("62F26D287F4C2B04" , vpermt2ps(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D287F4C2B04" , vpermt2ps(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D487FCB" , vpermt2ps(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F26D487F4C2B02" , vpermt2ps(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D487F4C2B02" , vpermt2ps(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED087ECB" , vpermt2q(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("62F2ED087E4C2B08" , vpermt2q(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED087E4C2B08" , vpermt2q(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED287ECB" , vpermt2q(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("62F2ED287E4C2B04" , vpermt2q(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED287E4C2B04" , vpermt2q(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED487ECB" , vpermt2q(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F2ED487E4C2B02" , vpermt2q(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED487E4C2B02" , vpermt2q(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED087DCB" , vpermt2w(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("62F2ED087D4C2B08" , vpermt2w(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED087D4C2B08" , vpermt2w(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED287DCB" , vpermt2w(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("62F2ED287D4C2B04" , vpermt2w(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED287D4C2B04" , vpermt2w(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED487DCB" , vpermt2w(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F2ED487D4C2B02" , vpermt2w(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED487D4C2B02" , vpermt2w(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED088DCB" , vpermw(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("62F2ED088D4C2B08" , vpermw(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED088D4C2B08" , vpermw(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED288DCB" , vpermw(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("62F2ED288D4C2B04" , vpermw(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED288D4C2B04" , vpermw(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED488DCB" , vpermw(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F2ED488D4C2B02" , vpermw(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED488D4C2B02" , vpermw(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F27D0862CA" , vpexpandb(xmm1, xmm2)); + TEST_INSTRUCTION("62F27D08628C1A80000000" , vpexpandb(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F27D08628C1A80000000" , vpexpandb(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F27D2862CA" , vpexpandb(ymm1, ymm2)); + TEST_INSTRUCTION("62F27D28628C1A80000000" , vpexpandb(ymm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F27D28628C1A80000000" , vpexpandb(ymm1, ymmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F27D4862CA" , vpexpandb(zmm1, zmm2)); + TEST_INSTRUCTION("62F27D48628C1A80000000" , vpexpandb(zmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F27D48628C1A80000000" , vpexpandb(zmm1, zmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F27D0889CA" , vpexpandd(xmm1, xmm2)); + TEST_INSTRUCTION("62F27D08894C1A20" , vpexpandd(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F27D08894C1A20" , vpexpandd(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F27D2889CA" , vpexpandd(ymm1, ymm2)); + TEST_INSTRUCTION("62F27D28894C1A20" , vpexpandd(ymm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F27D28894C1A20" , vpexpandd(ymm1, ymmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F27D4889CA" , vpexpandd(zmm1, zmm2)); + TEST_INSTRUCTION("62F27D48894C1A20" , vpexpandd(zmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F27D48894C1A20" , vpexpandd(zmm1, zmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F2FD0889CA" , vpexpandq(xmm1, xmm2)); + TEST_INSTRUCTION("62F2FD08894C1A10" , vpexpandq(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F2FD08894C1A10" , vpexpandq(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F2FD2889CA" , vpexpandq(ymm1, ymm2)); + TEST_INSTRUCTION("62F2FD28894C1A10" , vpexpandq(ymm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F2FD28894C1A10" , vpexpandq(ymm1, ymmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F2FD4889CA" , vpexpandq(zmm1, zmm2)); + TEST_INSTRUCTION("62F2FD48894C1A10" , vpexpandq(zmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F2FD48894C1A10" , vpexpandq(zmm1, zmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F2FD0862CA" , vpexpandw(xmm1, xmm2)); + TEST_INSTRUCTION("62F2FD08624C1A40" , vpexpandw(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F2FD08624C1A40" , vpexpandw(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F2FD2862CA" , vpexpandw(ymm1, ymm2)); + TEST_INSTRUCTION("62F2FD28624C1A40" , vpexpandw(ymm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F2FD28624C1A40" , vpexpandw(ymm1, ymmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F2FD4862CA" , vpexpandw(zmm1, zmm2)); + TEST_INSTRUCTION("62F2FD48624C1A40" , vpexpandw(zmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F2FD48624C1A40" , vpexpandw(zmm1, zmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C4E37914D101" , vpextrb(ecx, xmm2, 1)); + TEST_INSTRUCTION("C4E379149C118000000001" , vpextrb(ptr(ecx, edx, 0, 128), xmm3, 1)); + TEST_INSTRUCTION("C4E379149C118000000001" , vpextrb(byte_ptr(ecx, edx, 0, 128), xmm3, 1)); + TEST_INSTRUCTION("C4E37916D101" , vpextrd(ecx, xmm2, 1)); + TEST_INSTRUCTION("C4E379169C118000000001" , vpextrd(ptr(ecx, edx, 0, 128), xmm3, 1)); + TEST_INSTRUCTION("C4E379169C118000000001" , vpextrd(dword_ptr(ecx, edx, 0, 128), xmm3, 1)); + TEST_INSTRUCTION("C5F9C5CA01" , vpextrw(ecx, xmm2, 1)); + TEST_INSTRUCTION("C4E379159C118000000001" , vpextrw(ptr(ecx, edx, 0, 128), xmm3, 1)); + TEST_INSTRUCTION("C4E379159C118000000001" , vpextrw(word_ptr(ecx, edx, 0, 128), xmm3, 1)); + TEST_INSTRUCTION("C4E259908C1A80000000" , vpgatherdd(xmm1, ptr(edx, xmm3, 0, 128), xmm4)); + TEST_INSTRUCTION("C4E25D908C1A80000000" , vpgatherdd(ymm1, ptr(edx, ymm3, 0, 128), ymm4)); + TEST_INSTRUCTION("62F27D09904C1A20" , k(k1).vpgatherdd(xmm1, ptr(edx, xmm3, 0, 128))); + TEST_INSTRUCTION("62F27D29904C1A20" , k(k1).vpgatherdd(ymm1, ptr(edx, ymm3, 0, 128))); + TEST_INSTRUCTION("62F27D49904C1A20" , k(k1).vpgatherdd(zmm1, ptr(edx, zmm3, 0, 128))); + TEST_INSTRUCTION("C4E2D9908C1A80000000" , vpgatherdq(xmm1, ptr(edx, xmm3, 0, 128), xmm4)); + TEST_INSTRUCTION("C4E2DD908C1A80000000" , vpgatherdq(ymm1, ptr(edx, xmm3, 0, 128), ymm4)); + TEST_INSTRUCTION("62F2FD09904C1A10" , k(k1).vpgatherdq(xmm1, ptr(edx, xmm3, 0, 128))); + TEST_INSTRUCTION("62F2FD29904C1A10" , k(k1).vpgatherdq(ymm1, ptr(edx, xmm3, 0, 128))); + TEST_INSTRUCTION("62F2FD49904C1A10" , k(k1).vpgatherdq(zmm1, ptr(edx, ymm3, 0, 128))); + TEST_INSTRUCTION("C4E259918C1A80000000" , vpgatherqd(xmm1, ptr(edx, xmm3, 0, 128), xmm4)); + TEST_INSTRUCTION("C4E25D918C1A80000000" , vpgatherqd(xmm1, ptr(edx, ymm3, 0, 128), xmm4)); + TEST_INSTRUCTION("62F27D09914C1A20" , k(k1).vpgatherqd(xmm1, ptr(edx, xmm3, 0, 128))); + TEST_INSTRUCTION("62F27D29914C1A20" , k(k1).vpgatherqd(xmm1, ptr(edx, ymm3, 0, 128))); + TEST_INSTRUCTION("62F27D49914C1A20" , k(k1).vpgatherqd(ymm1, ptr(edx, zmm3, 0, 128))); + TEST_INSTRUCTION("C4E2D9918C1A80000000" , vpgatherqq(xmm1, ptr(edx, xmm3, 0, 128), xmm4)); + TEST_INSTRUCTION("C4E2DD918C1A80000000" , vpgatherqq(ymm1, ptr(edx, ymm3, 0, 128), ymm4)); + TEST_INSTRUCTION("62F2FD09914C1A10" , k(k1).vpgatherqq(xmm1, ptr(edx, xmm3, 0, 128))); + TEST_INSTRUCTION("62F2FD29914C1A10" , k(k1).vpgatherqq(ymm1, ptr(edx, ymm3, 0, 128))); + TEST_INSTRUCTION("62F2FD49914C1A10" , k(k1).vpgatherqq(zmm1, ptr(edx, zmm3, 0, 128))); + TEST_INSTRUCTION("8FE978C2CA" , vphaddbd(xmm1, xmm2)); + TEST_INSTRUCTION("8FE978C28C1A80000000" , vphaddbd(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("8FE978C28C1A80000000" , vphaddbd(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("8FE978C3CA" , vphaddbq(xmm1, xmm2)); + TEST_INSTRUCTION("8FE978C38C1A80000000" , vphaddbq(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("8FE978C38C1A80000000" , vphaddbq(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("8FE978C1CA" , vphaddbw(xmm1, xmm2)); + TEST_INSTRUCTION("8FE978C18C1A80000000" , vphaddbw(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("8FE978C18C1A80000000" , vphaddbw(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C4E26902CB" , vphaddd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E269028C2B80000000" , vphaddd(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E269028C2B80000000" , vphaddd(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E26D02CB" , vphaddd(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C4E26D028C2B80000000" , vphaddd(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E26D028C2B80000000" , vphaddd(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("8FE978CBCA" , vphadddq(xmm1, xmm2)); + TEST_INSTRUCTION("8FE978CB8C1A80000000" , vphadddq(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("8FE978CB8C1A80000000" , vphadddq(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C4E26903CB" , vphaddsw(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E269038C2B80000000" , vphaddsw(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E269038C2B80000000" , vphaddsw(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E26D03CB" , vphaddsw(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C4E26D038C2B80000000" , vphaddsw(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E26D038C2B80000000" , vphaddsw(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("8FE978D2CA" , vphaddubd(xmm1, xmm2)); + TEST_INSTRUCTION("8FE978D28C1A80000000" , vphaddubd(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("8FE978D28C1A80000000" , vphaddubd(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("8FE978D3CA" , vphaddubq(xmm1, xmm2)); + TEST_INSTRUCTION("8FE978D38C1A80000000" , vphaddubq(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("8FE978D38C1A80000000" , vphaddubq(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("8FE978D1CA" , vphaddubw(xmm1, xmm2)); + TEST_INSTRUCTION("8FE978D18C1A80000000" , vphaddubw(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("8FE978D18C1A80000000" , vphaddubw(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("8FE978DBCA" , vphaddudq(xmm1, xmm2)); + TEST_INSTRUCTION("8FE978DB8C1A80000000" , vphaddudq(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("8FE978DB8C1A80000000" , vphaddudq(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("8FE978D6CA" , vphadduwd(xmm1, xmm2)); + TEST_INSTRUCTION("8FE978D68C1A80000000" , vphadduwd(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("8FE978D68C1A80000000" , vphadduwd(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("8FE978D7CA" , vphadduwq(xmm1, xmm2)); + TEST_INSTRUCTION("8FE978D78C1A80000000" , vphadduwq(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("8FE978D78C1A80000000" , vphadduwq(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C4E26901CB" , vphaddw(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E269018C2B80000000" , vphaddw(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E269018C2B80000000" , vphaddw(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E26D01CB" , vphaddw(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C4E26D018C2B80000000" , vphaddw(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E26D018C2B80000000" , vphaddw(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("8FE978C6CA" , vphaddwd(xmm1, xmm2)); + TEST_INSTRUCTION("8FE978C68C1A80000000" , vphaddwd(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("8FE978C68C1A80000000" , vphaddwd(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("8FE978C7CA" , vphaddwq(xmm1, xmm2)); + TEST_INSTRUCTION("8FE978C78C1A80000000" , vphaddwq(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("8FE978C78C1A80000000" , vphaddwq(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C4E27941CA" , vphminposuw(xmm1, xmm2)); + TEST_INSTRUCTION("C4E279418C1A80000000" , vphminposuw(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C4E279418C1A80000000" , vphminposuw(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("8FE978E1CA" , vphsubbw(xmm1, xmm2)); + TEST_INSTRUCTION("8FE978E18C1A80000000" , vphsubbw(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("8FE978E18C1A80000000" , vphsubbw(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C4E26906CB" , vphsubd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E269068C2B80000000" , vphsubd(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E269068C2B80000000" , vphsubd(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E26D06CB" , vphsubd(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C4E26D068C2B80000000" , vphsubd(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E26D068C2B80000000" , vphsubd(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("8FE978E3CA" , vphsubdq(xmm1, xmm2)); + TEST_INSTRUCTION("8FE978E38C1A80000000" , vphsubdq(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("8FE978E38C1A80000000" , vphsubdq(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C4E26907CB" , vphsubsw(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E269078C2B80000000" , vphsubsw(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E269078C2B80000000" , vphsubsw(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E26D07CB" , vphsubsw(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C4E26D078C2B80000000" , vphsubsw(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E26D078C2B80000000" , vphsubsw(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E26905CB" , vphsubw(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E269058C2B80000000" , vphsubw(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E269058C2B80000000" , vphsubw(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E26D05CB" , vphsubw(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C4E26D058C2B80000000" , vphsubw(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E26D058C2B80000000" , vphsubw(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("8FE978E2CA" , vphsubwd(xmm1, xmm2)); + TEST_INSTRUCTION("8FE978E28C1A80000000" , vphsubwd(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("8FE978E28C1A80000000" , vphsubwd(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C4E36920CB01" , vpinsrb(xmm1, xmm2, ebx, 1)); + TEST_INSTRUCTION("C4E369208C2B8000000001" , vpinsrb(xmm1, xmm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("C4E369208C2B8000000001" , vpinsrb(xmm1, xmm2, byte_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("C4E36922CB01" , vpinsrd(xmm1, xmm2, ebx, 1)); + TEST_INSTRUCTION("C4E369228C2B8000000001" , vpinsrd(xmm1, xmm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("C4E369228C2B8000000001" , vpinsrd(xmm1, xmm2, dword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("C5E9C4CB01" , vpinsrw(xmm1, xmm2, ebx, 1)); + TEST_INSTRUCTION("C5E9C48C2B8000000001" , vpinsrw(xmm1, xmm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("C5E9C48C2B8000000001" , vpinsrw(xmm1, xmm2, word_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F27D0844CA" , vplzcntd(xmm1, xmm2)); + TEST_INSTRUCTION("62F27D08444C1A08" , vplzcntd(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F27D08444C1A08" , vplzcntd(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F27D2844CA" , vplzcntd(ymm1, ymm2)); + TEST_INSTRUCTION("62F27D28444C1A04" , vplzcntd(ymm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F27D28444C1A04" , vplzcntd(ymm1, ymmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F27D4844CA" , vplzcntd(zmm1, zmm2)); + TEST_INSTRUCTION("62F27D48444C1A02" , vplzcntd(zmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F27D48444C1A02" , vplzcntd(zmm1, zmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F2FD0844CA" , vplzcntq(xmm1, xmm2)); + TEST_INSTRUCTION("62F2FD08444C1A08" , vplzcntq(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F2FD08444C1A08" , vplzcntq(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F2FD2844CA" , vplzcntq(ymm1, ymm2)); + TEST_INSTRUCTION("62F2FD28444C1A04" , vplzcntq(ymm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F2FD28444C1A04" , vplzcntq(ymm1, ymmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F2FD4844CA" , vplzcntq(zmm1, zmm2)); + TEST_INSTRUCTION("62F2FD48444C1A02" , vplzcntq(zmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F2FD48444C1A02" , vplzcntq(zmm1, zmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("8FE8689ECB40" , vpmacsdd(xmm1, xmm2, xmm3, xmm4)); + TEST_INSTRUCTION("8FE8689E8C2B8000000060" , vpmacsdd(xmm1, xmm2, ptr(ebx, ebp, 0, 128), xmm6)); + TEST_INSTRUCTION("8FE8689E8C2B8000000060" , vpmacsdd(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128), xmm6)); + TEST_INSTRUCTION("8FE8689FCB40" , vpmacsdqh(xmm1, xmm2, xmm3, xmm4)); + TEST_INSTRUCTION("8FE8689F8C2B8000000060" , vpmacsdqh(xmm1, xmm2, ptr(ebx, ebp, 0, 128), xmm6)); + TEST_INSTRUCTION("8FE8689F8C2B8000000060" , vpmacsdqh(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128), xmm6)); + TEST_INSTRUCTION("8FE86897CB40" , vpmacsdql(xmm1, xmm2, xmm3, xmm4)); + TEST_INSTRUCTION("8FE868978C2B8000000060" , vpmacsdql(xmm1, xmm2, ptr(ebx, ebp, 0, 128), xmm6)); + TEST_INSTRUCTION("8FE868978C2B8000000060" , vpmacsdql(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128), xmm6)); + TEST_INSTRUCTION("8FE8688ECB40" , vpmacssdd(xmm1, xmm2, xmm3, xmm4)); + TEST_INSTRUCTION("8FE8688E8C2B8000000060" , vpmacssdd(xmm1, xmm2, ptr(ebx, ebp, 0, 128), xmm6)); + TEST_INSTRUCTION("8FE8688E8C2B8000000060" , vpmacssdd(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128), xmm6)); + TEST_INSTRUCTION("8FE8688FCB40" , vpmacssdqh(xmm1, xmm2, xmm3, xmm4)); + TEST_INSTRUCTION("8FE8688F8C2B8000000060" , vpmacssdqh(xmm1, xmm2, ptr(ebx, ebp, 0, 128), xmm6)); + TEST_INSTRUCTION("8FE8688F8C2B8000000060" , vpmacssdqh(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128), xmm6)); + TEST_INSTRUCTION("8FE86887CB40" , vpmacssdql(xmm1, xmm2, xmm3, xmm4)); + TEST_INSTRUCTION("8FE868878C2B8000000060" , vpmacssdql(xmm1, xmm2, ptr(ebx, ebp, 0, 128), xmm6)); + TEST_INSTRUCTION("8FE868878C2B8000000060" , vpmacssdql(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128), xmm6)); + TEST_INSTRUCTION("8FE86886CB40" , vpmacsswd(xmm1, xmm2, xmm3, xmm4)); + TEST_INSTRUCTION("8FE868868C2B8000000060" , vpmacsswd(xmm1, xmm2, ptr(ebx, ebp, 0, 128), xmm6)); + TEST_INSTRUCTION("8FE868868C2B8000000060" , vpmacsswd(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128), xmm6)); + TEST_INSTRUCTION("8FE86885CB40" , vpmacssww(xmm1, xmm2, xmm3, xmm4)); + TEST_INSTRUCTION("8FE868858C2B8000000060" , vpmacssww(xmm1, xmm2, ptr(ebx, ebp, 0, 128), xmm6)); + TEST_INSTRUCTION("8FE868858C2B8000000060" , vpmacssww(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128), xmm6)); + TEST_INSTRUCTION("8FE86896CB40" , vpmacswd(xmm1, xmm2, xmm3, xmm4)); + TEST_INSTRUCTION("8FE868968C2B8000000060" , vpmacswd(xmm1, xmm2, ptr(ebx, ebp, 0, 128), xmm6)); + TEST_INSTRUCTION("8FE868968C2B8000000060" , vpmacswd(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128), xmm6)); + TEST_INSTRUCTION("8FE86895CB40" , vpmacsww(xmm1, xmm2, xmm3, xmm4)); + TEST_INSTRUCTION("8FE868958C2B8000000060" , vpmacsww(xmm1, xmm2, ptr(ebx, ebp, 0, 128), xmm6)); + TEST_INSTRUCTION("8FE868958C2B8000000060" , vpmacsww(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128), xmm6)); + TEST_INSTRUCTION("8FE868A6CB40" , vpmadcsswd(xmm1, xmm2, xmm3, xmm4)); + TEST_INSTRUCTION("8FE868A68C2B8000000060" , vpmadcsswd(xmm1, xmm2, ptr(ebx, ebp, 0, 128), xmm6)); + TEST_INSTRUCTION("8FE868A68C2B8000000060" , vpmadcsswd(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128), xmm6)); + TEST_INSTRUCTION("8FE868B6CB40" , vpmadcswd(xmm1, xmm2, xmm3, xmm4)); + TEST_INSTRUCTION("8FE868B68C2B8000000060" , vpmadcswd(xmm1, xmm2, ptr(ebx, ebp, 0, 128), xmm6)); + TEST_INSTRUCTION("8FE868B68C2B8000000060" , vpmadcswd(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128), xmm6)); + TEST_INSTRUCTION("62F2ED08B5CB" , vpmadd52huq(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("62F2ED08B54C2B08" , vpmadd52huq(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED08B54C2B08" , vpmadd52huq(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED28B5CB" , vpmadd52huq(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("62F2ED28B54C2B04" , vpmadd52huq(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED28B54C2B04" , vpmadd52huq(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED48B5CB" , vpmadd52huq(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F2ED48B54C2B02" , vpmadd52huq(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED48B54C2B02" , vpmadd52huq(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED08B4CB" , vpmadd52luq(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("62F2ED08B44C2B08" , vpmadd52luq(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED08B44C2B08" , vpmadd52luq(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED28B4CB" , vpmadd52luq(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("62F2ED28B44C2B04" , vpmadd52luq(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED28B44C2B04" , vpmadd52luq(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED48B4CB" , vpmadd52luq(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F2ED48B44C2B02" , vpmadd52luq(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED48B44C2B02" , vpmadd52luq(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E26904CB" , vpmaddubsw(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E269048C2B80000000" , vpmaddubsw(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E269048C2B80000000" , vpmaddubsw(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E26D04CB" , vpmaddubsw(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C4E26D048C2B80000000" , vpmaddubsw(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E26D048C2B80000000" , vpmaddubsw(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D4804CB" , vpmaddubsw(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F26D48044C2B02" , vpmaddubsw(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D48044C2B02" , vpmaddubsw(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5E9F5CB" , vpmaddwd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5E9F58C2B80000000" , vpmaddwd(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5E9F58C2B80000000" , vpmaddwd(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5EDF5CB" , vpmaddwd(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C5EDF58C2B80000000" , vpmaddwd(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5EDF58C2B80000000" , vpmaddwd(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16D48F5CB" , vpmaddwd(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F16D48F54C2B02" , vpmaddwd(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16D48F54C2B02" , vpmaddwd(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E2618EA41180000000" , vpmaskmovd(ptr(ecx, edx, 0, 128), xmm3, xmm4)); + TEST_INSTRUCTION("C4E2618EA41180000000" , vpmaskmovd(xmmword_ptr(ecx, edx, 0, 128), xmm3, xmm4)); + TEST_INSTRUCTION("C4E2658EA41180000000" , vpmaskmovd(ptr(ecx, edx, 0, 128), ymm3, ymm4)); + TEST_INSTRUCTION("C4E2658EA41180000000" , vpmaskmovd(ymmword_ptr(ecx, edx, 0, 128), ymm3, ymm4)); + TEST_INSTRUCTION("C4E2698C8C2B80000000" , vpmaskmovd(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E2698C8C2B80000000" , vpmaskmovd(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E26D8C8C2B80000000" , vpmaskmovd(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E26D8C8C2B80000000" , vpmaskmovd(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E2E18EA41180000000" , vpmaskmovq(ptr(ecx, edx, 0, 128), xmm3, xmm4)); + TEST_INSTRUCTION("C4E2E18EA41180000000" , vpmaskmovq(xmmword_ptr(ecx, edx, 0, 128), xmm3, xmm4)); + TEST_INSTRUCTION("C4E2E58EA41180000000" , vpmaskmovq(ptr(ecx, edx, 0, 128), ymm3, ymm4)); + TEST_INSTRUCTION("C4E2E58EA41180000000" , vpmaskmovq(ymmword_ptr(ecx, edx, 0, 128), ymm3, ymm4)); + TEST_INSTRUCTION("C4E2E98C8C2B80000000" , vpmaskmovq(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E2E98C8C2B80000000" , vpmaskmovq(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E2ED8C8C2B80000000" , vpmaskmovq(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E2ED8C8C2B80000000" , vpmaskmovq(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E2693CCB" , vpmaxsb(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E2693C8C2B80000000" , vpmaxsb(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E2693C8C2B80000000" , vpmaxsb(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E26D3CCB" , vpmaxsb(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C4E26D3C8C2B80000000" , vpmaxsb(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E26D3C8C2B80000000" , vpmaxsb(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D483CCB" , vpmaxsb(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F26D483C4C2B02" , vpmaxsb(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D483C4C2B02" , vpmaxsb(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E2693DCB" , vpmaxsd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E2693D8C2B80000000" , vpmaxsd(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E2693D8C2B80000000" , vpmaxsd(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E26D3DCB" , vpmaxsd(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C4E26D3D8C2B80000000" , vpmaxsd(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E26D3D8C2B80000000" , vpmaxsd(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D483DCB" , vpmaxsd(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F26D483D4C2B02" , vpmaxsd(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D483D4C2B02" , vpmaxsd(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED083DCB" , vpmaxsq(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("62F2ED083D4C2B08" , vpmaxsq(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED083D4C2B08" , vpmaxsq(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED283DCB" , vpmaxsq(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("62F2ED283D4C2B04" , vpmaxsq(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED283D4C2B04" , vpmaxsq(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED483DCB" , vpmaxsq(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F2ED483D4C2B02" , vpmaxsq(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED483D4C2B02" , vpmaxsq(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5E9EECB" , vpmaxsw(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5E9EE8C2B80000000" , vpmaxsw(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5E9EE8C2B80000000" , vpmaxsw(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5EDEECB" , vpmaxsw(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C5EDEE8C2B80000000" , vpmaxsw(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5EDEE8C2B80000000" , vpmaxsw(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16D48EECB" , vpmaxsw(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F16D48EE4C2B02" , vpmaxsw(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16D48EE4C2B02" , vpmaxsw(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5E9DECB" , vpmaxub(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5E9DE8C2B80000000" , vpmaxub(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5E9DE8C2B80000000" , vpmaxub(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5EDDECB" , vpmaxub(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C5EDDE8C2B80000000" , vpmaxub(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5EDDE8C2B80000000" , vpmaxub(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16D48DECB" , vpmaxub(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F16D48DE4C2B02" , vpmaxub(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16D48DE4C2B02" , vpmaxub(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E2693FCB" , vpmaxud(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E2693F8C2B80000000" , vpmaxud(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E2693F8C2B80000000" , vpmaxud(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E26D3FCB" , vpmaxud(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C4E26D3F8C2B80000000" , vpmaxud(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E26D3F8C2B80000000" , vpmaxud(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D483FCB" , vpmaxud(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F26D483F4C2B02" , vpmaxud(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D483F4C2B02" , vpmaxud(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED083FCB" , vpmaxuq(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("62F2ED083F4C2B08" , vpmaxuq(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED083F4C2B08" , vpmaxuq(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED283FCB" , vpmaxuq(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("62F2ED283F4C2B04" , vpmaxuq(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED283F4C2B04" , vpmaxuq(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED483FCB" , vpmaxuq(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F2ED483F4C2B02" , vpmaxuq(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED483F4C2B02" , vpmaxuq(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E2693ECB" , vpmaxuw(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E2693E8C2B80000000" , vpmaxuw(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E2693E8C2B80000000" , vpmaxuw(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E26D3ECB" , vpmaxuw(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C4E26D3E8C2B80000000" , vpmaxuw(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E26D3E8C2B80000000" , vpmaxuw(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D483ECB" , vpmaxuw(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F26D483E4C2B02" , vpmaxuw(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D483E4C2B02" , vpmaxuw(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E26938CB" , vpminsb(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E269388C2B80000000" , vpminsb(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E269388C2B80000000" , vpminsb(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E26D38CB" , vpminsb(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C4E26D388C2B80000000" , vpminsb(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E26D388C2B80000000" , vpminsb(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D4838CB" , vpminsb(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F26D48384C2B02" , vpminsb(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D48384C2B02" , vpminsb(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E26939CB" , vpminsd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E269398C2B80000000" , vpminsd(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E269398C2B80000000" , vpminsd(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E26D39CB" , vpminsd(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C4E26D398C2B80000000" , vpminsd(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E26D398C2B80000000" , vpminsd(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D4839CB" , vpminsd(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F26D48394C2B02" , vpminsd(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D48394C2B02" , vpminsd(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED0839CB" , vpminsq(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("62F2ED08394C2B08" , vpminsq(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED08394C2B08" , vpminsq(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED2839CB" , vpminsq(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("62F2ED28394C2B04" , vpminsq(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED28394C2B04" , vpminsq(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED4839CB" , vpminsq(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F2ED48394C2B02" , vpminsq(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED48394C2B02" , vpminsq(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5E9EACB" , vpminsw(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5E9EA8C2B80000000" , vpminsw(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5E9EA8C2B80000000" , vpminsw(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5EDEACB" , vpminsw(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C5EDEA8C2B80000000" , vpminsw(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5EDEA8C2B80000000" , vpminsw(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16D48EACB" , vpminsw(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F16D48EA4C2B02" , vpminsw(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16D48EA4C2B02" , vpminsw(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5E9DACB" , vpminub(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5E9DA8C2B80000000" , vpminub(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5E9DA8C2B80000000" , vpminub(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5EDDACB" , vpminub(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C5EDDA8C2B80000000" , vpminub(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5EDDA8C2B80000000" , vpminub(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16D48DACB" , vpminub(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F16D48DA4C2B02" , vpminub(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16D48DA4C2B02" , vpminub(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E2693BCB" , vpminud(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E2693B8C2B80000000" , vpminud(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E2693B8C2B80000000" , vpminud(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E26D3BCB" , vpminud(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C4E26D3B8C2B80000000" , vpminud(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E26D3B8C2B80000000" , vpminud(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D483BCB" , vpminud(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F26D483B4C2B02" , vpminud(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D483B4C2B02" , vpminud(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED083BCB" , vpminuq(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("62F2ED083B4C2B08" , vpminuq(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED083B4C2B08" , vpminuq(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED283BCB" , vpminuq(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("62F2ED283B4C2B04" , vpminuq(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED283B4C2B04" , vpminuq(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED483BCB" , vpminuq(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F2ED483B4C2B02" , vpminuq(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED483B4C2B02" , vpminuq(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E2693ACB" , vpminuw(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E2693A8C2B80000000" , vpminuw(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E2693A8C2B80000000" , vpminuw(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E26D3ACB" , vpminuw(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C4E26D3A8C2B80000000" , vpminuw(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E26D3A8C2B80000000" , vpminuw(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D483ACB" , vpminuw(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F26D483A4C2B02" , vpminuw(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D483A4C2B02" , vpminuw(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F27E0829CA" , vpmovb2m(k1, xmm2)); + TEST_INSTRUCTION("62F27E2829CA" , vpmovb2m(k1, ymm2)); + TEST_INSTRUCTION("62F27E4829CA" , vpmovb2m(k1, zmm2)); + TEST_INSTRUCTION("62F27E0839CA" , vpmovd2m(k1, xmm2)); + TEST_INSTRUCTION("62F27E2839CA" , vpmovd2m(k1, ymm2)); + TEST_INSTRUCTION("62F27E4839CA" , vpmovd2m(k1, zmm2)); + TEST_INSTRUCTION("62F27E0831D1" , vpmovdb(xmm1, xmm2)); + TEST_INSTRUCTION("62F27E08315C1120" , vpmovdb(ptr(ecx, edx, 0, 128), xmm3)); + TEST_INSTRUCTION("62F27E08315C1120" , vpmovdb(dword_ptr(ecx, edx, 0, 128), xmm3)); + TEST_INSTRUCTION("62F27E2831D1" , vpmovdb(xmm1, ymm2)); + TEST_INSTRUCTION("62F27E28315C1110" , vpmovdb(ptr(ecx, edx, 0, 128), ymm3)); + TEST_INSTRUCTION("62F27E28315C1110" , vpmovdb(qword_ptr(ecx, edx, 0, 128), ymm3)); + TEST_INSTRUCTION("62F27E4831D1" , vpmovdb(xmm1, zmm2)); + TEST_INSTRUCTION("62F27E48315C1108" , vpmovdb(ptr(ecx, edx, 0, 128), zmm3)); + TEST_INSTRUCTION("62F27E48315C1108" , vpmovdb(xmmword_ptr(ecx, edx, 0, 128), zmm3)); + TEST_INSTRUCTION("62F27E0833D1" , vpmovdw(xmm1, xmm2)); + TEST_INSTRUCTION("62F27E08335C1110" , vpmovdw(ptr(ecx, edx, 0, 128), xmm3)); + TEST_INSTRUCTION("62F27E08335C1110" , vpmovdw(qword_ptr(ecx, edx, 0, 128), xmm3)); + TEST_INSTRUCTION("62F27E2833D1" , vpmovdw(xmm1, ymm2)); + TEST_INSTRUCTION("62F27E28335C1108" , vpmovdw(ptr(ecx, edx, 0, 128), ymm3)); + TEST_INSTRUCTION("62F27E28335C1108" , vpmovdw(xmmword_ptr(ecx, edx, 0, 128), ymm3)); + TEST_INSTRUCTION("62F27E4833D1" , vpmovdw(ymm1, zmm2)); + TEST_INSTRUCTION("62F27E48335C1104" , vpmovdw(ptr(ecx, edx, 0, 128), zmm3)); + TEST_INSTRUCTION("62F27E48335C1104" , vpmovdw(ymmword_ptr(ecx, edx, 0, 128), zmm3)); + TEST_INSTRUCTION("62F27E0828CA" , vpmovm2b(xmm1, k2)); + TEST_INSTRUCTION("62F27E2828CA" , vpmovm2b(ymm1, k2)); + TEST_INSTRUCTION("62F27E4828CA" , vpmovm2b(zmm1, k2)); + TEST_INSTRUCTION("62F27E0838CA" , vpmovm2d(xmm1, k2)); + TEST_INSTRUCTION("62F27E2838CA" , vpmovm2d(ymm1, k2)); + TEST_INSTRUCTION("62F27E4838CA" , vpmovm2d(zmm1, k2)); + TEST_INSTRUCTION("62F2FE0838CA" , vpmovm2q(xmm1, k2)); + TEST_INSTRUCTION("62F2FE2838CA" , vpmovm2q(ymm1, k2)); + TEST_INSTRUCTION("62F2FE4838CA" , vpmovm2q(zmm1, k2)); + TEST_INSTRUCTION("62F2FE0828CA" , vpmovm2w(xmm1, k2)); + TEST_INSTRUCTION("62F2FE2828CA" , vpmovm2w(ymm1, k2)); + TEST_INSTRUCTION("62F2FE4828CA" , vpmovm2w(zmm1, k2)); + TEST_INSTRUCTION("C5F9D7CA" , vpmovmskb(ecx, xmm2)); + TEST_INSTRUCTION("C5FDD7CA" , vpmovmskb(ecx, ymm2)); + TEST_INSTRUCTION("62F2FE0839CA" , vpmovq2m(k1, xmm2)); + TEST_INSTRUCTION("62F2FE2839CA" , vpmovq2m(k1, ymm2)); + TEST_INSTRUCTION("62F2FE4839CA" , vpmovq2m(k1, zmm2)); + TEST_INSTRUCTION("62F27E0832D1" , vpmovqb(xmm1, xmm2)); + TEST_INSTRUCTION("62F27E08325C1140" , vpmovqb(ptr(ecx, edx, 0, 128), xmm3)); + TEST_INSTRUCTION("62F27E08325C1140" , vpmovqb(word_ptr(ecx, edx, 0, 128), xmm3)); + TEST_INSTRUCTION("62F27E2832D1" , vpmovqb(xmm1, ymm2)); + TEST_INSTRUCTION("62F27E28325C1120" , vpmovqb(ptr(ecx, edx, 0, 128), ymm3)); + TEST_INSTRUCTION("62F27E28325C1120" , vpmovqb(dword_ptr(ecx, edx, 0, 128), ymm3)); + TEST_INSTRUCTION("62F27E4832D1" , vpmovqb(xmm1, zmm2)); + TEST_INSTRUCTION("62F27E48325C1110" , vpmovqb(ptr(ecx, edx, 0, 128), zmm3)); + TEST_INSTRUCTION("62F27E48325C1110" , vpmovqb(qword_ptr(ecx, edx, 0, 128), zmm3)); + TEST_INSTRUCTION("62F27E0835D1" , vpmovqd(xmm1, xmm2)); + TEST_INSTRUCTION("62F27E08355C1110" , vpmovqd(ptr(ecx, edx, 0, 128), xmm3)); + TEST_INSTRUCTION("62F27E08355C1110" , vpmovqd(qword_ptr(ecx, edx, 0, 128), xmm3)); + TEST_INSTRUCTION("62F27E2835D1" , vpmovqd(xmm1, ymm2)); + TEST_INSTRUCTION("62F27E28355C1108" , vpmovqd(ptr(ecx, edx, 0, 128), ymm3)); + TEST_INSTRUCTION("62F27E28355C1108" , vpmovqd(xmmword_ptr(ecx, edx, 0, 128), ymm3)); + TEST_INSTRUCTION("62F27E4835D1" , vpmovqd(ymm1, zmm2)); + TEST_INSTRUCTION("62F27E48355C1104" , vpmovqd(ptr(ecx, edx, 0, 128), zmm3)); + TEST_INSTRUCTION("62F27E48355C1104" , vpmovqd(ymmword_ptr(ecx, edx, 0, 128), zmm3)); + TEST_INSTRUCTION("62F27E0834D1" , vpmovqw(xmm1, xmm2)); + TEST_INSTRUCTION("62F27E08345C1120" , vpmovqw(ptr(ecx, edx, 0, 128), xmm3)); + TEST_INSTRUCTION("62F27E08345C1120" , vpmovqw(dword_ptr(ecx, edx, 0, 128), xmm3)); + TEST_INSTRUCTION("62F27E2834D1" , vpmovqw(xmm1, ymm2)); + TEST_INSTRUCTION("62F27E28345C1110" , vpmovqw(ptr(ecx, edx, 0, 128), ymm3)); + TEST_INSTRUCTION("62F27E28345C1110" , vpmovqw(qword_ptr(ecx, edx, 0, 128), ymm3)); + TEST_INSTRUCTION("62F27E4834D1" , vpmovqw(xmm1, zmm2)); + TEST_INSTRUCTION("62F27E48345C1108" , vpmovqw(ptr(ecx, edx, 0, 128), zmm3)); + TEST_INSTRUCTION("62F27E48345C1108" , vpmovqw(xmmword_ptr(ecx, edx, 0, 128), zmm3)); + TEST_INSTRUCTION("62F27E0821D1" , vpmovsdb(xmm1, xmm2)); + TEST_INSTRUCTION("62F27E08215C1120" , vpmovsdb(ptr(ecx, edx, 0, 128), xmm3)); + TEST_INSTRUCTION("62F27E08215C1120" , vpmovsdb(dword_ptr(ecx, edx, 0, 128), xmm3)); + TEST_INSTRUCTION("62F27E2821D1" , vpmovsdb(xmm1, ymm2)); + TEST_INSTRUCTION("62F27E28215C1110" , vpmovsdb(ptr(ecx, edx, 0, 128), ymm3)); + TEST_INSTRUCTION("62F27E28215C1110" , vpmovsdb(qword_ptr(ecx, edx, 0, 128), ymm3)); + TEST_INSTRUCTION("62F27E4821D1" , vpmovsdb(xmm1, zmm2)); + TEST_INSTRUCTION("62F27E48215C1108" , vpmovsdb(ptr(ecx, edx, 0, 128), zmm3)); + TEST_INSTRUCTION("62F27E48215C1108" , vpmovsdb(xmmword_ptr(ecx, edx, 0, 128), zmm3)); + TEST_INSTRUCTION("62F27E0823D1" , vpmovsdw(xmm1, xmm2)); + TEST_INSTRUCTION("62F27E08235C1110" , vpmovsdw(ptr(ecx, edx, 0, 128), xmm3)); + TEST_INSTRUCTION("62F27E08235C1110" , vpmovsdw(qword_ptr(ecx, edx, 0, 128), xmm3)); + TEST_INSTRUCTION("62F27E2823D1" , vpmovsdw(xmm1, ymm2)); + TEST_INSTRUCTION("62F27E28235C1108" , vpmovsdw(ptr(ecx, edx, 0, 128), ymm3)); + TEST_INSTRUCTION("62F27E28235C1108" , vpmovsdw(xmmword_ptr(ecx, edx, 0, 128), ymm3)); + TEST_INSTRUCTION("62F27E4823D1" , vpmovsdw(ymm1, zmm2)); + TEST_INSTRUCTION("62F27E48235C1104" , vpmovsdw(ptr(ecx, edx, 0, 128), zmm3)); + TEST_INSTRUCTION("62F27E48235C1104" , vpmovsdw(ymmword_ptr(ecx, edx, 0, 128), zmm3)); + TEST_INSTRUCTION("62F27E0822D1" , vpmovsqb(xmm1, xmm2)); + TEST_INSTRUCTION("62F27E08225C1140" , vpmovsqb(ptr(ecx, edx, 0, 128), xmm3)); + TEST_INSTRUCTION("62F27E08225C1140" , vpmovsqb(word_ptr(ecx, edx, 0, 128), xmm3)); + TEST_INSTRUCTION("62F27E2822D1" , vpmovsqb(xmm1, ymm2)); + TEST_INSTRUCTION("62F27E28225C1120" , vpmovsqb(ptr(ecx, edx, 0, 128), ymm3)); + TEST_INSTRUCTION("62F27E28225C1120" , vpmovsqb(dword_ptr(ecx, edx, 0, 128), ymm3)); + TEST_INSTRUCTION("62F27E4822D1" , vpmovsqb(xmm1, zmm2)); + TEST_INSTRUCTION("62F27E48225C1110" , vpmovsqb(ptr(ecx, edx, 0, 128), zmm3)); + TEST_INSTRUCTION("62F27E48225C1110" , vpmovsqb(qword_ptr(ecx, edx, 0, 128), zmm3)); + TEST_INSTRUCTION("62F27E0825D1" , vpmovsqd(xmm1, xmm2)); + TEST_INSTRUCTION("62F27E08255C1110" , vpmovsqd(ptr(ecx, edx, 0, 128), xmm3)); + TEST_INSTRUCTION("62F27E08255C1110" , vpmovsqd(qword_ptr(ecx, edx, 0, 128), xmm3)); + TEST_INSTRUCTION("62F27E2825D1" , vpmovsqd(xmm1, ymm2)); + TEST_INSTRUCTION("62F27E28255C1108" , vpmovsqd(ptr(ecx, edx, 0, 128), ymm3)); + TEST_INSTRUCTION("62F27E28255C1108" , vpmovsqd(xmmword_ptr(ecx, edx, 0, 128), ymm3)); + TEST_INSTRUCTION("62F27E4825D1" , vpmovsqd(ymm1, zmm2)); + TEST_INSTRUCTION("62F27E48255C1104" , vpmovsqd(ptr(ecx, edx, 0, 128), zmm3)); + TEST_INSTRUCTION("62F27E48255C1104" , vpmovsqd(ymmword_ptr(ecx, edx, 0, 128), zmm3)); + TEST_INSTRUCTION("62F27E0824D1" , vpmovsqw(xmm1, xmm2)); + TEST_INSTRUCTION("62F27E08245C1120" , vpmovsqw(ptr(ecx, edx, 0, 128), xmm3)); + TEST_INSTRUCTION("62F27E08245C1120" , vpmovsqw(dword_ptr(ecx, edx, 0, 128), xmm3)); + TEST_INSTRUCTION("62F27E2824D1" , vpmovsqw(xmm1, ymm2)); + TEST_INSTRUCTION("62F27E28245C1110" , vpmovsqw(ptr(ecx, edx, 0, 128), ymm3)); + TEST_INSTRUCTION("62F27E28245C1110" , vpmovsqw(qword_ptr(ecx, edx, 0, 128), ymm3)); + TEST_INSTRUCTION("62F27E4824D1" , vpmovsqw(xmm1, zmm2)); + TEST_INSTRUCTION("62F27E48245C1108" , vpmovsqw(ptr(ecx, edx, 0, 128), zmm3)); + TEST_INSTRUCTION("62F27E48245C1108" , vpmovsqw(xmmword_ptr(ecx, edx, 0, 128), zmm3)); + TEST_INSTRUCTION("62F27E0820D1" , vpmovswb(xmm1, xmm2)); + TEST_INSTRUCTION("62F27E08205C1110" , vpmovswb(ptr(ecx, edx, 0, 128), xmm3)); + TEST_INSTRUCTION("62F27E08205C1110" , vpmovswb(qword_ptr(ecx, edx, 0, 128), xmm3)); + TEST_INSTRUCTION("62F27E2820D1" , vpmovswb(xmm1, ymm2)); + TEST_INSTRUCTION("62F27E28205C1108" , vpmovswb(ptr(ecx, edx, 0, 128), ymm3)); + TEST_INSTRUCTION("62F27E28205C1108" , vpmovswb(xmmword_ptr(ecx, edx, 0, 128), ymm3)); + TEST_INSTRUCTION("62F27E4820D1" , vpmovswb(ymm1, zmm2)); + TEST_INSTRUCTION("62F27E48205C1104" , vpmovswb(ptr(ecx, edx, 0, 128), zmm3)); + TEST_INSTRUCTION("62F27E48205C1104" , vpmovswb(ymmword_ptr(ecx, edx, 0, 128), zmm3)); + TEST_INSTRUCTION("C4E27921CA" , vpmovsxbd(xmm1, xmm2)); + TEST_INSTRUCTION("C4E279218C1A80000000" , vpmovsxbd(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C4E279218C1A80000000" , vpmovsxbd(xmm1, dword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C4E27D21CA" , vpmovsxbd(ymm1, xmm2)); + TEST_INSTRUCTION("C4E27D218C1A80000000" , vpmovsxbd(ymm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C4E27D218C1A80000000" , vpmovsxbd(ymm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F27D4821CA" , vpmovsxbd(zmm1, xmm2)); + TEST_INSTRUCTION("62F27D48214C1A08" , vpmovsxbd(zmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F27D48214C1A08" , vpmovsxbd(zmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C4E27922CA" , vpmovsxbq(xmm1, xmm2)); + TEST_INSTRUCTION("C4E279228C1A80000000" , vpmovsxbq(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C4E279228C1A80000000" , vpmovsxbq(xmm1, word_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C4E27D22CA" , vpmovsxbq(ymm1, xmm2)); + TEST_INSTRUCTION("C4E27D228C1A80000000" , vpmovsxbq(ymm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C4E27D228C1A80000000" , vpmovsxbq(ymm1, dword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F27D4822CA" , vpmovsxbq(zmm1, xmm2)); + TEST_INSTRUCTION("62F27D48224C1A10" , vpmovsxbq(zmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F27D48224C1A10" , vpmovsxbq(zmm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C4E27920CA" , vpmovsxbw(xmm1, xmm2)); + TEST_INSTRUCTION("C4E279208C1A80000000" , vpmovsxbw(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C4E279208C1A80000000" , vpmovsxbw(xmm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C4E27D20CA" , vpmovsxbw(ymm1, xmm2)); + TEST_INSTRUCTION("C4E27D208C1A80000000" , vpmovsxbw(ymm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C4E27D208C1A80000000" , vpmovsxbw(ymm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F27D4820CA" , vpmovsxbw(zmm1, ymm2)); + TEST_INSTRUCTION("62F27D48204C1A04" , vpmovsxbw(zmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F27D48204C1A04" , vpmovsxbw(zmm1, ymmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C4E27925CA" , vpmovsxdq(xmm1, xmm2)); + TEST_INSTRUCTION("C4E279258C1A80000000" , vpmovsxdq(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C4E279258C1A80000000" , vpmovsxdq(xmm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C4E27D25CA" , vpmovsxdq(ymm1, xmm2)); + TEST_INSTRUCTION("C4E27D258C1A80000000" , vpmovsxdq(ymm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C4E27D258C1A80000000" , vpmovsxdq(ymm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F27D4825CA" , vpmovsxdq(zmm1, ymm2)); + TEST_INSTRUCTION("62F27D48254C1A04" , vpmovsxdq(zmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F27D48254C1A04" , vpmovsxdq(zmm1, ymmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C4E27923CA" , vpmovsxwd(xmm1, xmm2)); + TEST_INSTRUCTION("C4E279238C1A80000000" , vpmovsxwd(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C4E279238C1A80000000" , vpmovsxwd(xmm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C4E27D23CA" , vpmovsxwd(ymm1, xmm2)); + TEST_INSTRUCTION("C4E27D238C1A80000000" , vpmovsxwd(ymm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C4E27D238C1A80000000" , vpmovsxwd(ymm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F27D4823CA" , vpmovsxwd(zmm1, ymm2)); + TEST_INSTRUCTION("62F27D48234C1A04" , vpmovsxwd(zmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F27D48234C1A04" , vpmovsxwd(zmm1, ymmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C4E27924CA" , vpmovsxwq(xmm1, xmm2)); + TEST_INSTRUCTION("C4E279248C1A80000000" , vpmovsxwq(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C4E279248C1A80000000" , vpmovsxwq(xmm1, dword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C4E27D24CA" , vpmovsxwq(ymm1, xmm2)); + TEST_INSTRUCTION("C4E27D248C1A80000000" , vpmovsxwq(ymm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C4E27D248C1A80000000" , vpmovsxwq(ymm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F27D4824CA" , vpmovsxwq(zmm1, xmm2)); + TEST_INSTRUCTION("62F27D48244C1A08" , vpmovsxwq(zmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F27D48244C1A08" , vpmovsxwq(zmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F27E0811D1" , vpmovusdb(xmm1, xmm2)); + TEST_INSTRUCTION("62F27E08115C1120" , vpmovusdb(ptr(ecx, edx, 0, 128), xmm3)); + TEST_INSTRUCTION("62F27E08115C1120" , vpmovusdb(dword_ptr(ecx, edx, 0, 128), xmm3)); + TEST_INSTRUCTION("62F27E2811D1" , vpmovusdb(xmm1, ymm2)); + TEST_INSTRUCTION("62F27E28115C1110" , vpmovusdb(ptr(ecx, edx, 0, 128), ymm3)); + TEST_INSTRUCTION("62F27E28115C1110" , vpmovusdb(qword_ptr(ecx, edx, 0, 128), ymm3)); + TEST_INSTRUCTION("62F27E4811D1" , vpmovusdb(xmm1, zmm2)); + TEST_INSTRUCTION("62F27E48115C1108" , vpmovusdb(ptr(ecx, edx, 0, 128), zmm3)); + TEST_INSTRUCTION("62F27E48115C1108" , vpmovusdb(xmmword_ptr(ecx, edx, 0, 128), zmm3)); + TEST_INSTRUCTION("62F27E0813D1" , vpmovusdw(xmm1, xmm2)); + TEST_INSTRUCTION("62F27E08135C1110" , vpmovusdw(ptr(ecx, edx, 0, 128), xmm3)); + TEST_INSTRUCTION("62F27E08135C1110" , vpmovusdw(qword_ptr(ecx, edx, 0, 128), xmm3)); + TEST_INSTRUCTION("62F27E2813D1" , vpmovusdw(xmm1, ymm2)); + TEST_INSTRUCTION("62F27E28135C1108" , vpmovusdw(ptr(ecx, edx, 0, 128), ymm3)); + TEST_INSTRUCTION("62F27E28135C1108" , vpmovusdw(xmmword_ptr(ecx, edx, 0, 128), ymm3)); + TEST_INSTRUCTION("62F27E4813D1" , vpmovusdw(ymm1, zmm2)); + TEST_INSTRUCTION("62F27E48135C1104" , vpmovusdw(ptr(ecx, edx, 0, 128), zmm3)); + TEST_INSTRUCTION("62F27E48135C1104" , vpmovusdw(ymmword_ptr(ecx, edx, 0, 128), zmm3)); + TEST_INSTRUCTION("62F27E0812D1" , vpmovusqb(xmm1, xmm2)); + TEST_INSTRUCTION("62F27E08125C1140" , vpmovusqb(ptr(ecx, edx, 0, 128), xmm3)); + TEST_INSTRUCTION("62F27E08125C1140" , vpmovusqb(word_ptr(ecx, edx, 0, 128), xmm3)); + TEST_INSTRUCTION("62F27E2812D1" , vpmovusqb(xmm1, ymm2)); + TEST_INSTRUCTION("62F27E28125C1120" , vpmovusqb(ptr(ecx, edx, 0, 128), ymm3)); + TEST_INSTRUCTION("62F27E28125C1120" , vpmovusqb(dword_ptr(ecx, edx, 0, 128), ymm3)); + TEST_INSTRUCTION("62F27E4812D1" , vpmovusqb(xmm1, zmm2)); + TEST_INSTRUCTION("62F27E48125C1110" , vpmovusqb(ptr(ecx, edx, 0, 128), zmm3)); + TEST_INSTRUCTION("62F27E48125C1110" , vpmovusqb(qword_ptr(ecx, edx, 0, 128), zmm3)); + TEST_INSTRUCTION("62F27E0815D1" , vpmovusqd(xmm1, xmm2)); + TEST_INSTRUCTION("62F27E08155C1110" , vpmovusqd(ptr(ecx, edx, 0, 128), xmm3)); + TEST_INSTRUCTION("62F27E08155C1110" , vpmovusqd(qword_ptr(ecx, edx, 0, 128), xmm3)); + TEST_INSTRUCTION("62F27E2815D1" , vpmovusqd(xmm1, ymm2)); + TEST_INSTRUCTION("62F27E28155C1108" , vpmovusqd(ptr(ecx, edx, 0, 128), ymm3)); + TEST_INSTRUCTION("62F27E28155C1108" , vpmovusqd(xmmword_ptr(ecx, edx, 0, 128), ymm3)); + TEST_INSTRUCTION("62F27E4815D1" , vpmovusqd(ymm1, zmm2)); + TEST_INSTRUCTION("62F27E48155C1104" , vpmovusqd(ptr(ecx, edx, 0, 128), zmm3)); + TEST_INSTRUCTION("62F27E48155C1104" , vpmovusqd(ymmword_ptr(ecx, edx, 0, 128), zmm3)); + TEST_INSTRUCTION("62F27E0814D1" , vpmovusqw(xmm1, xmm2)); + TEST_INSTRUCTION("62F27E08145C1120" , vpmovusqw(ptr(ecx, edx, 0, 128), xmm3)); + TEST_INSTRUCTION("62F27E08145C1120" , vpmovusqw(dword_ptr(ecx, edx, 0, 128), xmm3)); + TEST_INSTRUCTION("62F27E2814D1" , vpmovusqw(xmm1, ymm2)); + TEST_INSTRUCTION("62F27E28145C1110" , vpmovusqw(ptr(ecx, edx, 0, 128), ymm3)); + TEST_INSTRUCTION("62F27E28145C1110" , vpmovusqw(qword_ptr(ecx, edx, 0, 128), ymm3)); + TEST_INSTRUCTION("62F27E4814D1" , vpmovusqw(xmm1, zmm2)); + TEST_INSTRUCTION("62F27E48145C1108" , vpmovusqw(ptr(ecx, edx, 0, 128), zmm3)); + TEST_INSTRUCTION("62F27E48145C1108" , vpmovusqw(xmmword_ptr(ecx, edx, 0, 128), zmm3)); + TEST_INSTRUCTION("62F27E0810D1" , vpmovuswb(xmm1, xmm2)); + TEST_INSTRUCTION("62F27E08105C1110" , vpmovuswb(ptr(ecx, edx, 0, 128), xmm3)); + TEST_INSTRUCTION("62F27E08105C1110" , vpmovuswb(qword_ptr(ecx, edx, 0, 128), xmm3)); + TEST_INSTRUCTION("62F27E2810D1" , vpmovuswb(xmm1, ymm2)); + TEST_INSTRUCTION("62F27E28105C1108" , vpmovuswb(ptr(ecx, edx, 0, 128), ymm3)); + TEST_INSTRUCTION("62F27E28105C1108" , vpmovuswb(xmmword_ptr(ecx, edx, 0, 128), ymm3)); + TEST_INSTRUCTION("62F27E4810D1" , vpmovuswb(ymm1, zmm2)); + TEST_INSTRUCTION("62F27E48105C1104" , vpmovuswb(ptr(ecx, edx, 0, 128), zmm3)); + TEST_INSTRUCTION("62F27E48105C1104" , vpmovuswb(ymmword_ptr(ecx, edx, 0, 128), zmm3)); + TEST_INSTRUCTION("62F2FE0829CA" , vpmovw2m(k1, xmm2)); + TEST_INSTRUCTION("62F2FE2829CA" , vpmovw2m(k1, ymm2)); + TEST_INSTRUCTION("62F2FE4829CA" , vpmovw2m(k1, zmm2)); + TEST_INSTRUCTION("62F27E0830D1" , vpmovwb(xmm1, xmm2)); + TEST_INSTRUCTION("62F27E08305C1110" , vpmovwb(ptr(ecx, edx, 0, 128), xmm3)); + TEST_INSTRUCTION("62F27E08305C1110" , vpmovwb(qword_ptr(ecx, edx, 0, 128), xmm3)); + TEST_INSTRUCTION("62F27E2830D1" , vpmovwb(xmm1, ymm2)); + TEST_INSTRUCTION("62F27E28305C1108" , vpmovwb(ptr(ecx, edx, 0, 128), ymm3)); + TEST_INSTRUCTION("62F27E28305C1108" , vpmovwb(xmmword_ptr(ecx, edx, 0, 128), ymm3)); + TEST_INSTRUCTION("62F27E4830D1" , vpmovwb(ymm1, zmm2)); + TEST_INSTRUCTION("62F27E48305C1104" , vpmovwb(ptr(ecx, edx, 0, 128), zmm3)); + TEST_INSTRUCTION("62F27E48305C1104" , vpmovwb(ymmword_ptr(ecx, edx, 0, 128), zmm3)); + TEST_INSTRUCTION("C4E27931CA" , vpmovzxbd(xmm1, xmm2)); + TEST_INSTRUCTION("C4E279318C1A80000000" , vpmovzxbd(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C4E279318C1A80000000" , vpmovzxbd(xmm1, dword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C4E27D31CA" , vpmovzxbd(ymm1, xmm2)); + TEST_INSTRUCTION("C4E27D318C1A80000000" , vpmovzxbd(ymm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C4E27D318C1A80000000" , vpmovzxbd(ymm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F27D4831CA" , vpmovzxbd(zmm1, xmm2)); + TEST_INSTRUCTION("62F27D48314C1A08" , vpmovzxbd(zmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F27D48314C1A08" , vpmovzxbd(zmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C4E27932CA" , vpmovzxbq(xmm1, xmm2)); + TEST_INSTRUCTION("C4E279328C1A80000000" , vpmovzxbq(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C4E279328C1A80000000" , vpmovzxbq(xmm1, word_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C4E27D32CA" , vpmovzxbq(ymm1, xmm2)); + TEST_INSTRUCTION("C4E27D328C1A80000000" , vpmovzxbq(ymm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C4E27D328C1A80000000" , vpmovzxbq(ymm1, dword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F27D4832CA" , vpmovzxbq(zmm1, xmm2)); + TEST_INSTRUCTION("62F27D48324C1A10" , vpmovzxbq(zmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F27D48324C1A10" , vpmovzxbq(zmm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C4E27930CA" , vpmovzxbw(xmm1, xmm2)); + TEST_INSTRUCTION("C4E279308C1A80000000" , vpmovzxbw(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C4E279308C1A80000000" , vpmovzxbw(xmm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C4E27D30CA" , vpmovzxbw(ymm1, xmm2)); + TEST_INSTRUCTION("C4E27D308C1A80000000" , vpmovzxbw(ymm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C4E27D308C1A80000000" , vpmovzxbw(ymm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F27D4830CA" , vpmovzxbw(zmm1, ymm2)); + TEST_INSTRUCTION("62F27D48304C1A04" , vpmovzxbw(zmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F27D48304C1A04" , vpmovzxbw(zmm1, ymmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C4E27935CA" , vpmovzxdq(xmm1, xmm2)); + TEST_INSTRUCTION("C4E279358C1A80000000" , vpmovzxdq(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C4E279358C1A80000000" , vpmovzxdq(xmm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C4E27D35CA" , vpmovzxdq(ymm1, xmm2)); + TEST_INSTRUCTION("C4E27D358C1A80000000" , vpmovzxdq(ymm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C4E27D358C1A80000000" , vpmovzxdq(ymm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F27D4835CA" , vpmovzxdq(zmm1, ymm2)); + TEST_INSTRUCTION("62F27D48354C1A04" , vpmovzxdq(zmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F27D48354C1A04" , vpmovzxdq(zmm1, ymmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C4E27933CA" , vpmovzxwd(xmm1, xmm2)); + TEST_INSTRUCTION("C4E279338C1A80000000" , vpmovzxwd(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C4E279338C1A80000000" , vpmovzxwd(xmm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C4E27D33CA" , vpmovzxwd(ymm1, xmm2)); + TEST_INSTRUCTION("C4E27D338C1A80000000" , vpmovzxwd(ymm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C4E27D338C1A80000000" , vpmovzxwd(ymm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F27D4833CA" , vpmovzxwd(zmm1, ymm2)); + TEST_INSTRUCTION("62F27D48334C1A04" , vpmovzxwd(zmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F27D48334C1A04" , vpmovzxwd(zmm1, ymmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C4E27934CA" , vpmovzxwq(xmm1, xmm2)); + TEST_INSTRUCTION("C4E279348C1A80000000" , vpmovzxwq(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C4E279348C1A80000000" , vpmovzxwq(xmm1, dword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C4E27D34CA" , vpmovzxwq(ymm1, xmm2)); + TEST_INSTRUCTION("C4E27D348C1A80000000" , vpmovzxwq(ymm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C4E27D348C1A80000000" , vpmovzxwq(ymm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F27D4834CA" , vpmovzxwq(zmm1, xmm2)); + TEST_INSTRUCTION("62F27D48344C1A08" , vpmovzxwq(zmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F27D48344C1A08" , vpmovzxwq(zmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C4E26928CB" , vpmuldq(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E269288C2B80000000" , vpmuldq(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E269288C2B80000000" , vpmuldq(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E26D28CB" , vpmuldq(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C4E26D288C2B80000000" , vpmuldq(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E26D288C2B80000000" , vpmuldq(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED4828CB" , vpmuldq(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F2ED48284C2B02" , vpmuldq(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED48284C2B02" , vpmuldq(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E2690BCB" , vpmulhrsw(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E2690B8C2B80000000" , vpmulhrsw(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E2690B8C2B80000000" , vpmulhrsw(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E26D0BCB" , vpmulhrsw(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C4E26D0B8C2B80000000" , vpmulhrsw(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E26D0B8C2B80000000" , vpmulhrsw(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D480BCB" , vpmulhrsw(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F26D480B4C2B02" , vpmulhrsw(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D480B4C2B02" , vpmulhrsw(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5E9E4CB" , vpmulhuw(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5E9E48C2B80000000" , vpmulhuw(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5E9E48C2B80000000" , vpmulhuw(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5EDE4CB" , vpmulhuw(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C5EDE48C2B80000000" , vpmulhuw(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5EDE48C2B80000000" , vpmulhuw(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16D48E4CB" , vpmulhuw(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F16D48E44C2B02" , vpmulhuw(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16D48E44C2B02" , vpmulhuw(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5E9E5CB" , vpmulhw(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5E9E58C2B80000000" , vpmulhw(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5E9E58C2B80000000" , vpmulhw(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5EDE5CB" , vpmulhw(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C5EDE58C2B80000000" , vpmulhw(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5EDE58C2B80000000" , vpmulhw(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16D48E5CB" , vpmulhw(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F16D48E54C2B02" , vpmulhw(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16D48E54C2B02" , vpmulhw(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E26940CB" , vpmulld(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E269408C2B80000000" , vpmulld(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E269408C2B80000000" , vpmulld(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E26D40CB" , vpmulld(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C4E26D408C2B80000000" , vpmulld(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E26D408C2B80000000" , vpmulld(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D4840CB" , vpmulld(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F26D48404C2B02" , vpmulld(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D48404C2B02" , vpmulld(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED0840CB" , vpmullq(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("62F2ED08404C2B08" , vpmullq(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED08404C2B08" , vpmullq(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED2840CB" , vpmullq(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("62F2ED28404C2B04" , vpmullq(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED28404C2B04" , vpmullq(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED4840CB" , vpmullq(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F2ED48404C2B02" , vpmullq(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED48404C2B02" , vpmullq(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5E9D5CB" , vpmullw(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5E9D58C2B80000000" , vpmullw(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5E9D58C2B80000000" , vpmullw(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5EDD5CB" , vpmullw(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C5EDD58C2B80000000" , vpmullw(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5EDD58C2B80000000" , vpmullw(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16D48D5CB" , vpmullw(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F16D48D54C2B02" , vpmullw(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16D48D54C2B02" , vpmullw(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED0883CB" , vpmultishiftqb(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("62F2ED08834C2B08" , vpmultishiftqb(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED08834C2B08" , vpmultishiftqb(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED2883CB" , vpmultishiftqb(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("62F2ED28834C2B04" , vpmultishiftqb(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED28834C2B04" , vpmultishiftqb(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED4883CB" , vpmultishiftqb(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F2ED48834C2B02" , vpmultishiftqb(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED48834C2B02" , vpmultishiftqb(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5E9F4CB" , vpmuludq(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5E9F48C2B80000000" , vpmuludq(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5E9F48C2B80000000" , vpmuludq(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5EDF4CB" , vpmuludq(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C5EDF48C2B80000000" , vpmuludq(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5EDF48C2B80000000" , vpmuludq(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F1ED48F4CB" , vpmuludq(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F1ED48F44C2B02" , vpmuludq(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F1ED48F44C2B02" , vpmuludq(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F27D0854CA" , vpopcntb(xmm1, xmm2)); + TEST_INSTRUCTION("62F27D08544C1A08" , vpopcntb(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F27D08544C1A08" , vpopcntb(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F27D2854CA" , vpopcntb(ymm1, ymm2)); + TEST_INSTRUCTION("62F27D28544C1A04" , vpopcntb(ymm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F27D28544C1A04" , vpopcntb(ymm1, ymmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F27D4854CA" , vpopcntb(zmm1, zmm2)); + TEST_INSTRUCTION("62F27D48544C1A02" , vpopcntb(zmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F27D48544C1A02" , vpopcntb(zmm1, zmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F27D0855CA" , vpopcntd(xmm1, xmm2)); + TEST_INSTRUCTION("62F27D08554C1A08" , vpopcntd(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F27D08554C1A08" , vpopcntd(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F27D2855CA" , vpopcntd(ymm1, ymm2)); + TEST_INSTRUCTION("62F27D28554C1A04" , vpopcntd(ymm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F27D28554C1A04" , vpopcntd(ymm1, ymmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F27D4855CA" , vpopcntd(zmm1, zmm2)); + TEST_INSTRUCTION("62F27D48554C1A02" , vpopcntd(zmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F27D48554C1A02" , vpopcntd(zmm1, zmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F2FD0855CA" , vpopcntq(xmm1, xmm2)); + TEST_INSTRUCTION("62F2FD08554C1A08" , vpopcntq(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F2FD08554C1A08" , vpopcntq(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F2FD2855CA" , vpopcntq(ymm1, ymm2)); + TEST_INSTRUCTION("62F2FD28554C1A04" , vpopcntq(ymm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F2FD28554C1A04" , vpopcntq(ymm1, ymmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F2FD4855CA" , vpopcntq(zmm1, zmm2)); + TEST_INSTRUCTION("62F2FD48554C1A02" , vpopcntq(zmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F2FD48554C1A02" , vpopcntq(zmm1, zmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F2FD0854CA" , vpopcntw(xmm1, xmm2)); + TEST_INSTRUCTION("62F2FD08544C1A08" , vpopcntw(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F2FD08544C1A08" , vpopcntw(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F2FD2854CA" , vpopcntw(ymm1, ymm2)); + TEST_INSTRUCTION("62F2FD28544C1A04" , vpopcntw(ymm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F2FD28544C1A04" , vpopcntw(ymm1, ymmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F2FD4854CA" , vpopcntw(zmm1, zmm2)); + TEST_INSTRUCTION("62F2FD48544C1A02" , vpopcntw(zmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F2FD48544C1A02" , vpopcntw(zmm1, zmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C5E9EBCB" , vpor(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5E9EB8C2B80000000" , vpor(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5E9EB8C2B80000000" , vpor(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5EDEBCB" , vpor(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C5EDEB8C2B80000000" , vpor(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5EDEB8C2B80000000" , vpor(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16D08EBCB" , vpord(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("62F16D08EB4C2B08" , vpord(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16D08EB4C2B08" , vpord(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16D28EBCB" , vpord(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("62F16D28EB4C2B04" , vpord(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16D28EB4C2B04" , vpord(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16D48EBCB" , vpord(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F16D48EB4C2B02" , vpord(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16D48EB4C2B02" , vpord(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F1ED08EBCB" , vporq(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("62F1ED08EB4C2B08" , vporq(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F1ED08EB4C2B08" , vporq(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F1ED28EBCB" , vporq(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("62F1ED28EB4C2B04" , vporq(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F1ED28EB4C2B04" , vporq(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F1ED48EBCB" , vporq(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F1ED48EB4C2B02" , vporq(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F1ED48EB4C2B02" , vporq(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("8FE868A3CB40" , vpperm(xmm1, xmm2, xmm3, xmm4)); + TEST_INSTRUCTION("8FE8E8A38C358000000030" , vpperm(xmm1, xmm2, xmm3, ptr(ebp, esi, 0, 128))); + TEST_INSTRUCTION("8FE8E8A38C358000000030" , vpperm(xmm1, xmm2, xmm3, xmmword_ptr(ebp, esi, 0, 128))); + TEST_INSTRUCTION("8FE868A38C2B8000000060" , vpperm(xmm1, xmm2, ptr(ebx, ebp, 0, 128), xmm6)); + TEST_INSTRUCTION("8FE868A38C2B8000000060" , vpperm(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128), xmm6)); + TEST_INSTRUCTION("62F1750872CA01" , vprold(xmm1, xmm2, 1)); + TEST_INSTRUCTION("62F17508724C1A0801" , vprold(xmm1, ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("62F17508724C1A0801" , vprold(xmm1, xmmword_ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("62F1752872CA01" , vprold(ymm1, ymm2, 1)); + TEST_INSTRUCTION("62F17528724C1A0401" , vprold(ymm1, ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("62F17528724C1A0401" , vprold(ymm1, ymmword_ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("62F1754872CA01" , vprold(zmm1, zmm2, 1)); + TEST_INSTRUCTION("62F17548724C1A0201" , vprold(zmm1, ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("62F17548724C1A0201" , vprold(zmm1, zmmword_ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("62F1F50872CA01" , vprolq(xmm1, xmm2, 1)); + TEST_INSTRUCTION("62F1F508724C1A0801" , vprolq(xmm1, ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("62F1F508724C1A0801" , vprolq(xmm1, xmmword_ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("62F1F52872CA01" , vprolq(ymm1, ymm2, 1)); + TEST_INSTRUCTION("62F1F528724C1A0401" , vprolq(ymm1, ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("62F1F528724C1A0401" , vprolq(ymm1, ymmword_ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("62F1F54872CA01" , vprolq(zmm1, zmm2, 1)); + TEST_INSTRUCTION("62F1F548724C1A0201" , vprolq(zmm1, ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("62F1F548724C1A0201" , vprolq(zmm1, zmmword_ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("62F26D0815CB" , vprolvd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("62F26D08154C2B08" , vprolvd(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D08154C2B08" , vprolvd(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D2815CB" , vprolvd(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("62F26D28154C2B04" , vprolvd(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D28154C2B04" , vprolvd(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D4815CB" , vprolvd(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F26D48154C2B02" , vprolvd(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D48154C2B02" , vprolvd(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED0815CB" , vprolvq(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("62F2ED08154C2B08" , vprolvq(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED08154C2B08" , vprolvq(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED2815CB" , vprolvq(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("62F2ED28154C2B04" , vprolvq(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED28154C2B04" , vprolvq(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED4815CB" , vprolvq(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F2ED48154C2B02" , vprolvq(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED48154C2B02" , vprolvq(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F1750872C201" , vprord(xmm1, xmm2, 1)); + TEST_INSTRUCTION("62F1750872441A0801" , vprord(xmm1, ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("62F1750872441A0801" , vprord(xmm1, xmmword_ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("62F1752872C201" , vprord(ymm1, ymm2, 1)); + TEST_INSTRUCTION("62F1752872441A0401" , vprord(ymm1, ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("62F1752872441A0401" , vprord(ymm1, ymmword_ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("62F1754872C201" , vprord(zmm1, zmm2, 1)); + TEST_INSTRUCTION("62F1754872441A0201" , vprord(zmm1, ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("62F1754872441A0201" , vprord(zmm1, zmmword_ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("62F1F50872C201" , vprorq(xmm1, xmm2, 1)); + TEST_INSTRUCTION("62F1F50872441A0801" , vprorq(xmm1, ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("62F1F50872441A0801" , vprorq(xmm1, xmmword_ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("62F1F52872C201" , vprorq(ymm1, ymm2, 1)); + TEST_INSTRUCTION("62F1F52872441A0401" , vprorq(ymm1, ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("62F1F52872441A0401" , vprorq(ymm1, ymmword_ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("62F1F54872C201" , vprorq(zmm1, zmm2, 1)); + TEST_INSTRUCTION("62F1F54872441A0201" , vprorq(zmm1, ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("62F1F54872441A0201" , vprorq(zmm1, zmmword_ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("62F26D0814CB" , vprorvd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("62F26D08144C2B08" , vprorvd(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D08144C2B08" , vprorvd(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D2814CB" , vprorvd(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("62F26D28144C2B04" , vprorvd(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D28144C2B04" , vprorvd(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D4814CB" , vprorvd(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F26D48144C2B02" , vprorvd(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D48144C2B02" , vprorvd(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED0814CB" , vprorvq(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("62F2ED08144C2B08" , vprorvq(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED08144C2B08" , vprorvq(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED2814CB" , vprorvq(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("62F2ED28144C2B04" , vprorvq(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED28144C2B04" , vprorvq(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED4814CB" , vprorvq(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F2ED48144C2B02" , vprorvq(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED48144C2B02" , vprorvq(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("8FE96090CA" , vprotb(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("8FE878C0CA01" , vprotb(xmm1, xmm2, 1)); + TEST_INSTRUCTION("8FE9E8908C2B80000000" , vprotb(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("8FE9E8908C2B80000000" , vprotb(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("8FE958908C1A80000000" , vprotb(xmm1, ptr(edx, ebx, 0, 128), xmm4)); + TEST_INSTRUCTION("8FE878C08C1A8000000001" , vprotb(xmm1, ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("8FE958908C1A80000000" , vprotb(xmm1, xmmword_ptr(edx, ebx, 0, 128), xmm4)); + TEST_INSTRUCTION("8FE878C08C1A8000000001" , vprotb(xmm1, xmmword_ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("8FE96092CA" , vprotd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("8FE878C2CA01" , vprotd(xmm1, xmm2, 1)); + TEST_INSTRUCTION("8FE9E8928C2B80000000" , vprotd(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("8FE9E8928C2B80000000" , vprotd(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("8FE958928C1A80000000" , vprotd(xmm1, ptr(edx, ebx, 0, 128), xmm4)); + TEST_INSTRUCTION("8FE878C28C1A8000000001" , vprotd(xmm1, ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("8FE958928C1A80000000" , vprotd(xmm1, xmmword_ptr(edx, ebx, 0, 128), xmm4)); + TEST_INSTRUCTION("8FE878C28C1A8000000001" , vprotd(xmm1, xmmword_ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("8FE96093CA" , vprotq(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("8FE878C3CA01" , vprotq(xmm1, xmm2, 1)); + TEST_INSTRUCTION("8FE9E8938C2B80000000" , vprotq(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("8FE9E8938C2B80000000" , vprotq(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("8FE958938C1A80000000" , vprotq(xmm1, ptr(edx, ebx, 0, 128), xmm4)); + TEST_INSTRUCTION("8FE878C38C1A8000000001" , vprotq(xmm1, ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("8FE958938C1A80000000" , vprotq(xmm1, xmmword_ptr(edx, ebx, 0, 128), xmm4)); + TEST_INSTRUCTION("8FE878C38C1A8000000001" , vprotq(xmm1, xmmword_ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("8FE96091CA" , vprotw(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("8FE878C1CA01" , vprotw(xmm1, xmm2, 1)); + TEST_INSTRUCTION("8FE9E8918C2B80000000" , vprotw(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("8FE9E8918C2B80000000" , vprotw(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("8FE958918C1A80000000" , vprotw(xmm1, ptr(edx, ebx, 0, 128), xmm4)); + TEST_INSTRUCTION("8FE878C18C1A8000000001" , vprotw(xmm1, ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("8FE958918C1A80000000" , vprotw(xmm1, xmmword_ptr(edx, ebx, 0, 128), xmm4)); + TEST_INSTRUCTION("8FE878C18C1A8000000001" , vprotw(xmm1, xmmword_ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("C5E9F6CB" , vpsadbw(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5E9F68C2B80000000" , vpsadbw(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5E9F68C2B80000000" , vpsadbw(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5EDF6CB" , vpsadbw(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C5EDF68C2B80000000" , vpsadbw(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5EDF68C2B80000000" , vpsadbw(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16D48F6CB" , vpsadbw(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F16D48F64C2B02" , vpsadbw(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16D48F64C2B02" , vpsadbw(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F27D09A05C1120" , k(k1).vpscatterdd(ptr(ecx, xmm2, 0, 128), xmm3)); + TEST_INSTRUCTION("62F27D29A05C1120" , k(k1).vpscatterdd(ptr(ecx, ymm2, 0, 128), ymm3)); + TEST_INSTRUCTION("62F27D49A05C1120" , k(k1).vpscatterdd(ptr(ecx, zmm2, 0, 128), zmm3)); + TEST_INSTRUCTION("62F2FD09A05C1110" , k(k1).vpscatterdq(ptr(ecx, xmm2, 0, 128), xmm3)); + TEST_INSTRUCTION("62F2FD29A05C1110" , k(k1).vpscatterdq(ptr(ecx, xmm2, 0, 128), ymm3)); + TEST_INSTRUCTION("62F2FD49A05C1110" , k(k1).vpscatterdq(ptr(ecx, ymm2, 0, 128), zmm3)); + TEST_INSTRUCTION("62F27D09A15C1120" , k(k1).vpscatterqd(ptr(ecx, xmm2, 0, 128), xmm3)); + TEST_INSTRUCTION("62F27D29A15C1120" , k(k1).vpscatterqd(ptr(ecx, ymm2, 0, 128), xmm3)); + TEST_INSTRUCTION("62F27D49A15C1120" , k(k1).vpscatterqd(ptr(ecx, zmm2, 0, 128), ymm3)); + TEST_INSTRUCTION("62F2FD09A15C1110" , k(k1).vpscatterqq(ptr(ecx, xmm2, 0, 128), xmm3)); + TEST_INSTRUCTION("62F2FD29A15C1110" , k(k1).vpscatterqq(ptr(ecx, ymm2, 0, 128), ymm3)); + TEST_INSTRUCTION("62F2FD49A15C1110" , k(k1).vpscatterqq(ptr(ecx, zmm2, 0, 128), zmm3)); + TEST_INSTRUCTION("8FE96098CA" , vpshab(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("8FE9E8988C2B80000000" , vpshab(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("8FE9E8988C2B80000000" , vpshab(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("8FE958988C1A80000000" , vpshab(xmm1, ptr(edx, ebx, 0, 128), xmm4)); + TEST_INSTRUCTION("8FE958988C1A80000000" , vpshab(xmm1, xmmword_ptr(edx, ebx, 0, 128), xmm4)); + TEST_INSTRUCTION("8FE9609ACA" , vpshad(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("8FE9E89A8C2B80000000" , vpshad(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("8FE9E89A8C2B80000000" , vpshad(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("8FE9589A8C1A80000000" , vpshad(xmm1, ptr(edx, ebx, 0, 128), xmm4)); + TEST_INSTRUCTION("8FE9589A8C1A80000000" , vpshad(xmm1, xmmword_ptr(edx, ebx, 0, 128), xmm4)); + TEST_INSTRUCTION("8FE9609BCA" , vpshaq(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("8FE9E89B8C2B80000000" , vpshaq(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("8FE9E89B8C2B80000000" , vpshaq(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("8FE9589B8C1A80000000" , vpshaq(xmm1, ptr(edx, ebx, 0, 128), xmm4)); + TEST_INSTRUCTION("8FE9589B8C1A80000000" , vpshaq(xmm1, xmmword_ptr(edx, ebx, 0, 128), xmm4)); + TEST_INSTRUCTION("8FE96099CA" , vpshaw(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("8FE9E8998C2B80000000" , vpshaw(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("8FE9E8998C2B80000000" , vpshaw(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("8FE958998C1A80000000" , vpshaw(xmm1, ptr(edx, ebx, 0, 128), xmm4)); + TEST_INSTRUCTION("8FE958998C1A80000000" , vpshaw(xmm1, xmmword_ptr(edx, ebx, 0, 128), xmm4)); + TEST_INSTRUCTION("8FE96094CA" , vpshlb(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("8FE9E8948C2B80000000" , vpshlb(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("8FE9E8948C2B80000000" , vpshlb(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("8FE958948C1A80000000" , vpshlb(xmm1, ptr(edx, ebx, 0, 128), xmm4)); + TEST_INSTRUCTION("8FE958948C1A80000000" , vpshlb(xmm1, xmmword_ptr(edx, ebx, 0, 128), xmm4)); + TEST_INSTRUCTION("8FE96096CA" , vpshld(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("8FE9E8968C2B80000000" , vpshld(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("8FE9E8968C2B80000000" , vpshld(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("8FE958968C1A80000000" , vpshld(xmm1, ptr(edx, ebx, 0, 128), xmm4)); + TEST_INSTRUCTION("8FE958968C1A80000000" , vpshld(xmm1, xmmword_ptr(edx, ebx, 0, 128), xmm4)); + TEST_INSTRUCTION("62F36D0871CB01" , vpshldd(xmm1, xmm2, xmm3, 1)); + TEST_INSTRUCTION("62F36D08714C2B0801" , vpshldd(xmm1, xmm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D08714C2B0801" , vpshldd(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D2871CB01" , vpshldd(ymm1, ymm2, ymm3, 1)); + TEST_INSTRUCTION("62F36D28714C2B0401" , vpshldd(ymm1, ymm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D28714C2B0401" , vpshldd(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D4871CB01" , vpshldd(zmm1, zmm2, zmm3, 1)); + TEST_INSTRUCTION("62F36D48714C2B0201" , vpshldd(zmm1, zmm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D48714C2B0201" , vpshldd(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED0871CB01" , vpshldq(xmm1, xmm2, xmm3, 1)); + TEST_INSTRUCTION("62F3ED08714C2B0801" , vpshldq(xmm1, xmm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED08714C2B0801" , vpshldq(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED2871CB01" , vpshldq(ymm1, ymm2, ymm3, 1)); + TEST_INSTRUCTION("62F3ED28714C2B0401" , vpshldq(ymm1, ymm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED28714C2B0401" , vpshldq(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED4871CB01" , vpshldq(zmm1, zmm2, zmm3, 1)); + TEST_INSTRUCTION("62F3ED48714C2B0201" , vpshldq(zmm1, zmm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED48714C2B0201" , vpshldq(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F26D0871CB" , vpshldvd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("62F26D08714C2B08" , vpshldvd(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D08714C2B08" , vpshldvd(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D2871CB" , vpshldvd(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("62F26D28714C2B04" , vpshldvd(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D28714C2B04" , vpshldvd(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D4871CB" , vpshldvd(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F26D48714C2B02" , vpshldvd(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D48714C2B02" , vpshldvd(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED0871CB" , vpshldvq(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("62F2ED08714C2B08" , vpshldvq(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED08714C2B08" , vpshldvq(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED2871CB" , vpshldvq(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("62F2ED28714C2B04" , vpshldvq(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED28714C2B04" , vpshldvq(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED4871CB" , vpshldvq(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F2ED48714C2B02" , vpshldvq(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED48714C2B02" , vpshldvq(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED0870CB" , vpshldvw(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("62F2ED08704C2B08" , vpshldvw(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED08704C2B08" , vpshldvw(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED2870CB" , vpshldvw(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("62F2ED28704C2B04" , vpshldvw(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED28704C2B04" , vpshldvw(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED4870CB" , vpshldvw(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F2ED48704C2B02" , vpshldvw(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED48704C2B02" , vpshldvw(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F3ED0870CB01" , vpshldw(xmm1, xmm2, xmm3, 1)); + TEST_INSTRUCTION("62F3ED08704C2B0801" , vpshldw(xmm1, xmm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED08704C2B0801" , vpshldw(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED2870CB01" , vpshldw(ymm1, ymm2, ymm3, 1)); + TEST_INSTRUCTION("62F3ED28704C2B0401" , vpshldw(ymm1, ymm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED28704C2B0401" , vpshldw(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED4870CB01" , vpshldw(zmm1, zmm2, zmm3, 1)); + TEST_INSTRUCTION("62F3ED48704C2B0201" , vpshldw(zmm1, zmm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED48704C2B0201" , vpshldw(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("8FE96097CA" , vpshlq(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("8FE9E8978C2B80000000" , vpshlq(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("8FE9E8978C2B80000000" , vpshlq(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("8FE958978C1A80000000" , vpshlq(xmm1, ptr(edx, ebx, 0, 128), xmm4)); + TEST_INSTRUCTION("8FE958978C1A80000000" , vpshlq(xmm1, xmmword_ptr(edx, ebx, 0, 128), xmm4)); + TEST_INSTRUCTION("8FE96095CA" , vpshlw(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("8FE9E8958C2B80000000" , vpshlw(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("8FE9E8958C2B80000000" , vpshlw(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("8FE958958C1A80000000" , vpshlw(xmm1, ptr(edx, ebx, 0, 128), xmm4)); + TEST_INSTRUCTION("8FE958958C1A80000000" , vpshlw(xmm1, xmmword_ptr(edx, ebx, 0, 128), xmm4)); + TEST_INSTRUCTION("62F36D0873CB01" , vpshrdd(xmm1, xmm2, xmm3, 1)); + TEST_INSTRUCTION("62F36D08734C2B0801" , vpshrdd(xmm1, xmm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D08734C2B0801" , vpshrdd(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D2873CB01" , vpshrdd(ymm1, ymm2, ymm3, 1)); + TEST_INSTRUCTION("62F36D28734C2B0401" , vpshrdd(ymm1, ymm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D28734C2B0401" , vpshrdd(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D4873CB01" , vpshrdd(zmm1, zmm2, zmm3, 1)); + TEST_INSTRUCTION("62F36D48734C2B0201" , vpshrdd(zmm1, zmm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D48734C2B0201" , vpshrdd(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED0873CB01" , vpshrdq(xmm1, xmm2, xmm3, 1)); + TEST_INSTRUCTION("62F3ED08734C2B0801" , vpshrdq(xmm1, xmm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED08734C2B0801" , vpshrdq(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED2873CB01" , vpshrdq(ymm1, ymm2, ymm3, 1)); + TEST_INSTRUCTION("62F3ED28734C2B0401" , vpshrdq(ymm1, ymm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED28734C2B0401" , vpshrdq(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED4873CB01" , vpshrdq(zmm1, zmm2, zmm3, 1)); + TEST_INSTRUCTION("62F3ED48734C2B0201" , vpshrdq(zmm1, zmm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED48734C2B0201" , vpshrdq(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F26D0873CB" , vpshrdvd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("62F26D08734C2B08" , vpshrdvd(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D08734C2B08" , vpshrdvd(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D2873CB" , vpshrdvd(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("62F26D28734C2B04" , vpshrdvd(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D28734C2B04" , vpshrdvd(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D4873CB" , vpshrdvd(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F26D48734C2B02" , vpshrdvd(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D48734C2B02" , vpshrdvd(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED0873CB" , vpshrdvq(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("62F2ED08734C2B08" , vpshrdvq(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED08734C2B08" , vpshrdvq(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED2873CB" , vpshrdvq(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("62F2ED28734C2B04" , vpshrdvq(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED28734C2B04" , vpshrdvq(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED4873CB" , vpshrdvq(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F2ED48734C2B02" , vpshrdvq(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED48734C2B02" , vpshrdvq(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED0872CB" , vpshrdvw(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("62F2ED08724C2B08" , vpshrdvw(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED08724C2B08" , vpshrdvw(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED2872CB" , vpshrdvw(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("62F2ED28724C2B04" , vpshrdvw(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED28724C2B04" , vpshrdvw(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED4872CB" , vpshrdvw(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F2ED48724C2B02" , vpshrdvw(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED48724C2B02" , vpshrdvw(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F3ED0872CB01" , vpshrdw(xmm1, xmm2, xmm3, 1)); + TEST_INSTRUCTION("62F3ED08724C2B0801" , vpshrdw(xmm1, xmm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED08724C2B0801" , vpshrdw(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED2872CB01" , vpshrdw(ymm1, ymm2, ymm3, 1)); + TEST_INSTRUCTION("62F3ED28724C2B0401" , vpshrdw(ymm1, ymm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED28724C2B0401" , vpshrdw(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED4872CB01" , vpshrdw(zmm1, zmm2, zmm3, 1)); + TEST_INSTRUCTION("62F3ED48724C2B0201" , vpshrdw(zmm1, zmm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED48724C2B0201" , vpshrdw(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("C4E26900CB" , vpshufb(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E269008C2B80000000" , vpshufb(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E269008C2B80000000" , vpshufb(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E26D00CB" , vpshufb(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C4E26D008C2B80000000" , vpshufb(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E26D008C2B80000000" , vpshufb(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D4800CB" , vpshufb(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F26D48004C2B02" , vpshufb(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D48004C2B02" , vpshufb(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D088FCB" , vpshufbitqmb(k1, xmm2, xmm3)); + TEST_INSTRUCTION("62F26D088F4C2B08" , vpshufbitqmb(k1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D088F4C2B08" , vpshufbitqmb(k1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D288FCB" , vpshufbitqmb(k1, ymm2, ymm3)); + TEST_INSTRUCTION("62F26D288F4C2B04" , vpshufbitqmb(k1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D288F4C2B04" , vpshufbitqmb(k1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D488FCB" , vpshufbitqmb(k1, zmm2, zmm3)); + TEST_INSTRUCTION("62F26D488F4C2B02" , vpshufbitqmb(k1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D488F4C2B02" , vpshufbitqmb(k1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5F970CA01" , vpshufd(xmm1, xmm2, 1)); + TEST_INSTRUCTION("C5F9708C1A8000000001" , vpshufd(xmm1, ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("C5F9708C1A8000000001" , vpshufd(xmm1, xmmword_ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("C5FD70CA01" , vpshufd(ymm1, ymm2, 1)); + TEST_INSTRUCTION("C5FD708C1A8000000001" , vpshufd(ymm1, ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("C5FD708C1A8000000001" , vpshufd(ymm1, ymmword_ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("62F17D4870CA01" , vpshufd(zmm1, zmm2, 1)); + TEST_INSTRUCTION("62F17D48704C1A0201" , vpshufd(zmm1, ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("62F17D48704C1A0201" , vpshufd(zmm1, zmmword_ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("C5FA70CA01" , vpshufhw(xmm1, xmm2, 1)); + TEST_INSTRUCTION("C5FA708C1A8000000001" , vpshufhw(xmm1, ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("C5FA708C1A8000000001" , vpshufhw(xmm1, xmmword_ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("C5FE70CA01" , vpshufhw(ymm1, ymm2, 1)); + TEST_INSTRUCTION("C5FE708C1A8000000001" , vpshufhw(ymm1, ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("C5FE708C1A8000000001" , vpshufhw(ymm1, ymmword_ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("62F17E4870CA01" , vpshufhw(zmm1, zmm2, 1)); + TEST_INSTRUCTION("62F17E48704C1A0201" , vpshufhw(zmm1, ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("62F17E48704C1A0201" , vpshufhw(zmm1, zmmword_ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("C5FB70CA01" , vpshuflw(xmm1, xmm2, 1)); + TEST_INSTRUCTION("C5FB708C1A8000000001" , vpshuflw(xmm1, ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("C5FB708C1A8000000001" , vpshuflw(xmm1, xmmword_ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("C5FF70CA01" , vpshuflw(ymm1, ymm2, 1)); + TEST_INSTRUCTION("C5FF708C1A8000000001" , vpshuflw(ymm1, ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("C5FF708C1A8000000001" , vpshuflw(ymm1, ymmword_ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("62F17F4870CA01" , vpshuflw(zmm1, zmm2, 1)); + TEST_INSTRUCTION("62F17F48704C1A0201" , vpshuflw(zmm1, ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("62F17F48704C1A0201" , vpshuflw(zmm1, zmmword_ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("C4E26908CB" , vpsignb(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E269088C2B80000000" , vpsignb(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E269088C2B80000000" , vpsignb(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E26D08CB" , vpsignb(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C4E26D088C2B80000000" , vpsignb(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E26D088C2B80000000" , vpsignb(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E2690ACB" , vpsignd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E2690A8C2B80000000" , vpsignd(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E2690A8C2B80000000" , vpsignd(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E26D0ACB" , vpsignd(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C4E26D0A8C2B80000000" , vpsignd(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E26D0A8C2B80000000" , vpsignd(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E26909CB" , vpsignw(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E269098C2B80000000" , vpsignw(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E269098C2B80000000" , vpsignw(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E26D09CB" , vpsignw(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C4E26D098C2B80000000" , vpsignw(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E26D098C2B80000000" , vpsignw(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5E9F2CB" , vpslld(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5F172F201" , vpslld(xmm1, xmm2, 1)); + TEST_INSTRUCTION("C5E9F28C2B80000000" , vpslld(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5E9F28C2B80000000" , vpslld(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5EDF2CB" , vpslld(ymm1, ymm2, xmm3)); + TEST_INSTRUCTION("C5F572F201" , vpslld(ymm1, ymm2, 1)); + TEST_INSTRUCTION("C5EDF28C2B80000000" , vpslld(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5EDF28C2B80000000" , vpslld(ymm1, ymm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F1750872741A0801" , vpslld(xmm1, ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("62F1750872741A0801" , vpslld(xmm1, xmmword_ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("62F1752872741A0401" , vpslld(ymm1, ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("62F1752872741A0401" , vpslld(ymm1, ymmword_ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("62F16D48F2CB" , vpslld(zmm1, zmm2, xmm3)); + TEST_INSTRUCTION("62F1754872F201" , vpslld(zmm1, zmm2, 1)); + TEST_INSTRUCTION("62F16D48F24C2B08" , vpslld(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16D48F24C2B08" , vpslld(zmm1, zmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F1754872741A0201" , vpslld(zmm1, ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("62F1754872741A0201" , vpslld(zmm1, zmmword_ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("C5F173FA01" , vpslldq(xmm1, xmm2, 1)); + TEST_INSTRUCTION("62F17508737C1A0801" , vpslldq(xmm1, ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("62F17508737C1A0801" , vpslldq(xmm1, xmmword_ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("C5F573FA01" , vpslldq(ymm1, ymm2, 1)); + TEST_INSTRUCTION("62F17528737C1A0401" , vpslldq(ymm1, ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("62F17528737C1A0401" , vpslldq(ymm1, ymmword_ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("62F1754873FA01" , vpslldq(zmm1, zmm2, 1)); + TEST_INSTRUCTION("62F17548737C1A0201" , vpslldq(zmm1, ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("62F17548737C1A0201" , vpslldq(zmm1, zmmword_ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("C5E9F3CB" , vpsllq(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5F173F201" , vpsllq(xmm1, xmm2, 1)); + TEST_INSTRUCTION("C5E9F38C2B80000000" , vpsllq(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5E9F38C2B80000000" , vpsllq(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5EDF3CB" , vpsllq(ymm1, ymm2, xmm3)); + TEST_INSTRUCTION("C5F573F201" , vpsllq(ymm1, ymm2, 1)); + TEST_INSTRUCTION("C5EDF38C2B80000000" , vpsllq(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5EDF38C2B80000000" , vpsllq(ymm1, ymm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F1F50873741A0801" , vpsllq(xmm1, ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("62F1F50873741A0801" , vpsllq(xmm1, xmmword_ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("62F1F52873741A0401" , vpsllq(ymm1, ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("62F1F52873741A0401" , vpsllq(ymm1, ymmword_ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("62F1ED48F3CB" , vpsllq(zmm1, zmm2, xmm3)); + TEST_INSTRUCTION("62F1F54873F201" , vpsllq(zmm1, zmm2, 1)); + TEST_INSTRUCTION("62F1ED48F34C2B08" , vpsllq(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F1ED48F34C2B08" , vpsllq(zmm1, zmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F1F54873741A0201" , vpsllq(zmm1, ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("62F1F54873741A0201" , vpsllq(zmm1, zmmword_ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("C4E26947CB" , vpsllvd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E269478C2B80000000" , vpsllvd(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E269478C2B80000000" , vpsllvd(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E26D47CB" , vpsllvd(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C4E26D478C2B80000000" , vpsllvd(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E26D478C2B80000000" , vpsllvd(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D4847CB" , vpsllvd(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F26D48474C2B02" , vpsllvd(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D48474C2B02" , vpsllvd(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E2E947CB" , vpsllvq(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E2E9478C2B80000000" , vpsllvq(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E2E9478C2B80000000" , vpsllvq(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E2ED47CB" , vpsllvq(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C4E2ED478C2B80000000" , vpsllvq(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E2ED478C2B80000000" , vpsllvq(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED4847CB" , vpsllvq(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F2ED48474C2B02" , vpsllvq(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED48474C2B02" , vpsllvq(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED0812CB" , vpsllvw(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("62F2ED08124C2B08" , vpsllvw(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED08124C2B08" , vpsllvw(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED2812CB" , vpsllvw(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("62F2ED28124C2B04" , vpsllvw(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED28124C2B04" , vpsllvw(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED4812CB" , vpsllvw(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F2ED48124C2B02" , vpsllvw(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED48124C2B02" , vpsllvw(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5E9F1CB" , vpsllw(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5F171F201" , vpsllw(xmm1, xmm2, 1)); + TEST_INSTRUCTION("C5E9F18C2B80000000" , vpsllw(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5E9F18C2B80000000" , vpsllw(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5EDF1CB" , vpsllw(ymm1, ymm2, xmm3)); + TEST_INSTRUCTION("C5F571F201" , vpsllw(ymm1, ymm2, 1)); + TEST_INSTRUCTION("C5EDF18C2B80000000" , vpsllw(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5EDF18C2B80000000" , vpsllw(ymm1, ymm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F1750871741A0801" , vpsllw(xmm1, ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("62F1750871741A0801" , vpsllw(xmm1, xmmword_ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("62F1752871741A0401" , vpsllw(ymm1, ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("62F1752871741A0401" , vpsllw(ymm1, ymmword_ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("62F16D48F1CB" , vpsllw(zmm1, zmm2, xmm3)); + TEST_INSTRUCTION("62F1754871F201" , vpsllw(zmm1, zmm2, 1)); + TEST_INSTRUCTION("62F16D48F14C2B08" , vpsllw(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16D48F14C2B08" , vpsllw(zmm1, zmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F1754871741A0201" , vpsllw(zmm1, ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("62F1754871741A0201" , vpsllw(zmm1, zmmword_ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("C5E9E2CB" , vpsrad(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5F172E201" , vpsrad(xmm1, xmm2, 1)); + TEST_INSTRUCTION("C5E9E28C2B80000000" , vpsrad(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5E9E28C2B80000000" , vpsrad(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5EDE2CB" , vpsrad(ymm1, ymm2, xmm3)); + TEST_INSTRUCTION("C5F572E201" , vpsrad(ymm1, ymm2, 1)); + TEST_INSTRUCTION("C5EDE28C2B80000000" , vpsrad(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5EDE28C2B80000000" , vpsrad(ymm1, ymm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F1750872641A0801" , vpsrad(xmm1, ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("62F1750872641A0801" , vpsrad(xmm1, xmmword_ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("62F1752872641A0401" , vpsrad(ymm1, ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("62F1752872641A0401" , vpsrad(ymm1, ymmword_ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("62F16D48E2CB" , vpsrad(zmm1, zmm2, xmm3)); + TEST_INSTRUCTION("62F1754872E201" , vpsrad(zmm1, zmm2, 1)); + TEST_INSTRUCTION("62F16D48E24C2B08" , vpsrad(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16D48E24C2B08" , vpsrad(zmm1, zmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F1754872641A0201" , vpsrad(zmm1, ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("62F1754872641A0201" , vpsrad(zmm1, zmmword_ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("62F1ED08E2CB" , vpsraq(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("62F1F50872E201" , vpsraq(xmm1, xmm2, 1)); + TEST_INSTRUCTION("62F1ED08E24C2B08" , vpsraq(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F1ED08E24C2B08" , vpsraq(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F1F50872641A0801" , vpsraq(xmm1, ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("62F1F50872641A0801" , vpsraq(xmm1, xmmword_ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("62F1ED28E2CB" , vpsraq(ymm1, ymm2, xmm3)); + TEST_INSTRUCTION("62F1F52872E201" , vpsraq(ymm1, ymm2, 1)); + TEST_INSTRUCTION("62F1ED28E24C2B08" , vpsraq(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F1ED28E24C2B08" , vpsraq(ymm1, ymm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F1F52872641A0401" , vpsraq(ymm1, ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("62F1F52872641A0401" , vpsraq(ymm1, ymmword_ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("62F1ED48E2CB" , vpsraq(zmm1, zmm2, xmm3)); + TEST_INSTRUCTION("62F1F54872E201" , vpsraq(zmm1, zmm2, 1)); + TEST_INSTRUCTION("62F1ED48E24C2B08" , vpsraq(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F1ED48E24C2B08" , vpsraq(zmm1, zmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F1F54872641A0201" , vpsraq(zmm1, ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("62F1F54872641A0201" , vpsraq(zmm1, zmmword_ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("C4E26946CB" , vpsravd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E269468C2B80000000" , vpsravd(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E269468C2B80000000" , vpsravd(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E26D46CB" , vpsravd(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C4E26D468C2B80000000" , vpsravd(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E26D468C2B80000000" , vpsravd(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D4846CB" , vpsravd(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F26D48464C2B02" , vpsravd(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D48464C2B02" , vpsravd(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED0846CB" , vpsravq(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("62F2ED08464C2B08" , vpsravq(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED08464C2B08" , vpsravq(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED2846CB" , vpsravq(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("62F2ED28464C2B04" , vpsravq(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED28464C2B04" , vpsravq(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED4846CB" , vpsravq(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F2ED48464C2B02" , vpsravq(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED48464C2B02" , vpsravq(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED0811CB" , vpsravw(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("62F2ED08114C2B08" , vpsravw(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED08114C2B08" , vpsravw(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED2811CB" , vpsravw(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("62F2ED28114C2B04" , vpsravw(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED28114C2B04" , vpsravw(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED4811CB" , vpsravw(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F2ED48114C2B02" , vpsravw(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED48114C2B02" , vpsravw(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5E9E1CB" , vpsraw(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5F171E201" , vpsraw(xmm1, xmm2, 1)); + TEST_INSTRUCTION("C5E9E18C2B80000000" , vpsraw(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5E9E18C2B80000000" , vpsraw(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5EDE1CB" , vpsraw(ymm1, ymm2, xmm3)); + TEST_INSTRUCTION("C5F571E201" , vpsraw(ymm1, ymm2, 1)); + TEST_INSTRUCTION("C5EDE18C2B80000000" , vpsraw(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5EDE18C2B80000000" , vpsraw(ymm1, ymm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F1750871641A0801" , vpsraw(xmm1, ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("62F1750871641A0801" , vpsraw(xmm1, xmmword_ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("62F1752871641A0401" , vpsraw(ymm1, ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("62F1752871641A0401" , vpsraw(ymm1, ymmword_ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("62F16D48E1CB" , vpsraw(zmm1, zmm2, xmm3)); + TEST_INSTRUCTION("62F1754871E201" , vpsraw(zmm1, zmm2, 1)); + TEST_INSTRUCTION("62F16D48E14C2B08" , vpsraw(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16D48E14C2B08" , vpsraw(zmm1, zmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F1754871641A0201" , vpsraw(zmm1, ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("62F1754871641A0201" , vpsraw(zmm1, zmmword_ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("C5E9D2CB" , vpsrld(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5F172D201" , vpsrld(xmm1, xmm2, 1)); + TEST_INSTRUCTION("C5E9D28C2B80000000" , vpsrld(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5E9D28C2B80000000" , vpsrld(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5EDD2CB" , vpsrld(ymm1, ymm2, xmm3)); + TEST_INSTRUCTION("C5F572D201" , vpsrld(ymm1, ymm2, 1)); + TEST_INSTRUCTION("C5EDD28C2B80000000" , vpsrld(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5EDD28C2B80000000" , vpsrld(ymm1, ymm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F1750872541A0801" , vpsrld(xmm1, ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("62F1750872541A0801" , vpsrld(xmm1, xmmword_ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("62F1752872541A0401" , vpsrld(ymm1, ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("62F1752872541A0401" , vpsrld(ymm1, ymmword_ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("62F16D48D2CB" , vpsrld(zmm1, zmm2, xmm3)); + TEST_INSTRUCTION("62F1754872D201" , vpsrld(zmm1, zmm2, 1)); + TEST_INSTRUCTION("62F16D48D24C2B08" , vpsrld(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16D48D24C2B08" , vpsrld(zmm1, zmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F1754872541A0201" , vpsrld(zmm1, ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("62F1754872541A0201" , vpsrld(zmm1, zmmword_ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("C5F173DA01" , vpsrldq(xmm1, xmm2, 1)); + TEST_INSTRUCTION("62F17508735C1A0801" , vpsrldq(xmm1, ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("62F17508735C1A0801" , vpsrldq(xmm1, xmmword_ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("C5F573DA01" , vpsrldq(ymm1, ymm2, 1)); + TEST_INSTRUCTION("62F17528735C1A0401" , vpsrldq(ymm1, ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("62F17528735C1A0401" , vpsrldq(ymm1, ymmword_ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("62F1754873DA01" , vpsrldq(zmm1, zmm2, 1)); + TEST_INSTRUCTION("62F17548735C1A0201" , vpsrldq(zmm1, ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("62F17548735C1A0201" , vpsrldq(zmm1, zmmword_ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("C5E9D3CB" , vpsrlq(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5F173D201" , vpsrlq(xmm1, xmm2, 1)); + TEST_INSTRUCTION("C5E9D38C2B80000000" , vpsrlq(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5E9D38C2B80000000" , vpsrlq(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5EDD3CB" , vpsrlq(ymm1, ymm2, xmm3)); + TEST_INSTRUCTION("C5F573D201" , vpsrlq(ymm1, ymm2, 1)); + TEST_INSTRUCTION("C5EDD38C2B80000000" , vpsrlq(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5EDD38C2B80000000" , vpsrlq(ymm1, ymm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F1F50873541A0801" , vpsrlq(xmm1, ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("62F1F50873541A0801" , vpsrlq(xmm1, xmmword_ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("62F1F52873541A0401" , vpsrlq(ymm1, ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("62F1F52873541A0401" , vpsrlq(ymm1, ymmword_ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("62F1ED48D3CB" , vpsrlq(zmm1, zmm2, xmm3)); + TEST_INSTRUCTION("62F1F54873D201" , vpsrlq(zmm1, zmm2, 1)); + TEST_INSTRUCTION("62F1ED48D34C2B08" , vpsrlq(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F1ED48D34C2B08" , vpsrlq(zmm1, zmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F1F54873541A0201" , vpsrlq(zmm1, ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("62F1F54873541A0201" , vpsrlq(zmm1, zmmword_ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("C4E26945CB" , vpsrlvd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E269458C2B80000000" , vpsrlvd(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E269458C2B80000000" , vpsrlvd(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E26D45CB" , vpsrlvd(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C4E26D458C2B80000000" , vpsrlvd(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E26D458C2B80000000" , vpsrlvd(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D4845CB" , vpsrlvd(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F26D48454C2B02" , vpsrlvd(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D48454C2B02" , vpsrlvd(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E2E945CB" , vpsrlvq(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C4E2E9458C2B80000000" , vpsrlvq(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E2E9458C2B80000000" , vpsrlvq(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E2ED45CB" , vpsrlvq(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C4E2ED458C2B80000000" , vpsrlvq(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E2ED458C2B80000000" , vpsrlvq(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED4845CB" , vpsrlvq(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F2ED48454C2B02" , vpsrlvq(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED48454C2B02" , vpsrlvq(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED0810CB" , vpsrlvw(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("62F2ED08104C2B08" , vpsrlvw(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED08104C2B08" , vpsrlvw(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED2810CB" , vpsrlvw(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("62F2ED28104C2B04" , vpsrlvw(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED28104C2B04" , vpsrlvw(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED4810CB" , vpsrlvw(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F2ED48104C2B02" , vpsrlvw(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED48104C2B02" , vpsrlvw(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5E9D1CB" , vpsrlw(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5F171D201" , vpsrlw(xmm1, xmm2, 1)); + TEST_INSTRUCTION("C5E9D18C2B80000000" , vpsrlw(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5E9D18C2B80000000" , vpsrlw(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5EDD1CB" , vpsrlw(ymm1, ymm2, xmm3)); + TEST_INSTRUCTION("C5F571D201" , vpsrlw(ymm1, ymm2, 1)); + TEST_INSTRUCTION("C5EDD18C2B80000000" , vpsrlw(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5EDD18C2B80000000" , vpsrlw(ymm1, ymm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F1750871541A0801" , vpsrlw(xmm1, ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("62F1750871541A0801" , vpsrlw(xmm1, xmmword_ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("62F1752871541A0401" , vpsrlw(ymm1, ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("62F1752871541A0401" , vpsrlw(ymm1, ymmword_ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("62F16D48D1CB" , vpsrlw(zmm1, zmm2, xmm3)); + TEST_INSTRUCTION("62F1754871D201" , vpsrlw(zmm1, zmm2, 1)); + TEST_INSTRUCTION("62F16D48D14C2B08" , vpsrlw(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16D48D14C2B08" , vpsrlw(zmm1, zmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F1754871541A0201" , vpsrlw(zmm1, ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("62F1754871541A0201" , vpsrlw(zmm1, zmmword_ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("C5E9F8CB" , vpsubb(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5E9F88C2B80000000" , vpsubb(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5E9F88C2B80000000" , vpsubb(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5EDF8CB" , vpsubb(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C5EDF88C2B80000000" , vpsubb(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5EDF88C2B80000000" , vpsubb(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16D48F8CB" , vpsubb(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F16D48F84C2B02" , vpsubb(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16D48F84C2B02" , vpsubb(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5E9FACB" , vpsubd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5E9FA8C2B80000000" , vpsubd(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5E9FA8C2B80000000" , vpsubd(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5EDFACB" , vpsubd(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C5EDFA8C2B80000000" , vpsubd(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5EDFA8C2B80000000" , vpsubd(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16D48FACB" , vpsubd(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F16D48FA4C2B02" , vpsubd(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16D48FA4C2B02" , vpsubd(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5E9FBCB" , vpsubq(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5E9FB8C2B80000000" , vpsubq(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5E9FB8C2B80000000" , vpsubq(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5EDFBCB" , vpsubq(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C5EDFB8C2B80000000" , vpsubq(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5EDFB8C2B80000000" , vpsubq(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F1ED48FBCB" , vpsubq(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F1ED48FB4C2B02" , vpsubq(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F1ED48FB4C2B02" , vpsubq(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5E9E8CB" , vpsubsb(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5E9E88C2B80000000" , vpsubsb(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5E9E88C2B80000000" , vpsubsb(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5EDE8CB" , vpsubsb(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C5EDE88C2B80000000" , vpsubsb(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5EDE88C2B80000000" , vpsubsb(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16D48E8CB" , vpsubsb(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F16D48E84C2B02" , vpsubsb(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16D48E84C2B02" , vpsubsb(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5E9E9CB" , vpsubsw(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5E9E98C2B80000000" , vpsubsw(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5E9E98C2B80000000" , vpsubsw(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5EDE9CB" , vpsubsw(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C5EDE98C2B80000000" , vpsubsw(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5EDE98C2B80000000" , vpsubsw(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16D48E9CB" , vpsubsw(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F16D48E94C2B02" , vpsubsw(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16D48E94C2B02" , vpsubsw(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5E9D8CB" , vpsubusb(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5E9D88C2B80000000" , vpsubusb(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5E9D88C2B80000000" , vpsubusb(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5EDD8CB" , vpsubusb(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C5EDD88C2B80000000" , vpsubusb(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5EDD88C2B80000000" , vpsubusb(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16D48D8CB" , vpsubusb(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F16D48D84C2B02" , vpsubusb(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16D48D84C2B02" , vpsubusb(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5E9D9CB" , vpsubusw(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5E9D98C2B80000000" , vpsubusw(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5E9D98C2B80000000" , vpsubusw(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5EDD9CB" , vpsubusw(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C5EDD98C2B80000000" , vpsubusw(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5EDD98C2B80000000" , vpsubusw(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16D48D9CB" , vpsubusw(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F16D48D94C2B02" , vpsubusw(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16D48D94C2B02" , vpsubusw(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5E9F9CB" , vpsubw(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5E9F98C2B80000000" , vpsubw(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5E9F98C2B80000000" , vpsubw(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5EDF9CB" , vpsubw(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C5EDF98C2B80000000" , vpsubw(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5EDF98C2B80000000" , vpsubw(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16D48F9CB" , vpsubw(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F16D48F94C2B02" , vpsubw(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16D48F94C2B02" , vpsubw(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F36D0825CB01" , vpternlogd(xmm1, xmm2, xmm3, 1)); + TEST_INSTRUCTION("62F36D08254C2B0801" , vpternlogd(xmm1, xmm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D08254C2B0801" , vpternlogd(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D2825CB01" , vpternlogd(ymm1, ymm2, ymm3, 1)); + TEST_INSTRUCTION("62F36D28254C2B0401" , vpternlogd(ymm1, ymm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D28254C2B0401" , vpternlogd(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D4825CB01" , vpternlogd(zmm1, zmm2, zmm3, 1)); + TEST_INSTRUCTION("62F36D48254C2B0201" , vpternlogd(zmm1, zmm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D48254C2B0201" , vpternlogd(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED0825CB01" , vpternlogq(xmm1, xmm2, xmm3, 1)); + TEST_INSTRUCTION("62F3ED08254C2B0801" , vpternlogq(xmm1, xmm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED08254C2B0801" , vpternlogq(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED2825CB01" , vpternlogq(ymm1, ymm2, ymm3, 1)); + TEST_INSTRUCTION("62F3ED28254C2B0401" , vpternlogq(ymm1, ymm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED28254C2B0401" , vpternlogq(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED4825CB01" , vpternlogq(zmm1, zmm2, zmm3, 1)); + TEST_INSTRUCTION("62F3ED48254C2B0201" , vpternlogq(zmm1, zmm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED48254C2B0201" , vpternlogq(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("C4E27917CA" , vptest(xmm1, xmm2)); + TEST_INSTRUCTION("C4E279178C1A80000000" , vptest(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C4E279178C1A80000000" , vptest(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C4E27D17CA" , vptest(ymm1, ymm2)); + TEST_INSTRUCTION("C4E27D178C1A80000000" , vptest(ymm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C4E27D178C1A80000000" , vptest(ymm1, ymmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F26D0826CB" , vptestmb(k1, xmm2, xmm3)); + TEST_INSTRUCTION("62F26D08264C2B08" , vptestmb(k1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D08264C2B08" , vptestmb(k1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D2826CB" , vptestmb(k1, ymm2, ymm3)); + TEST_INSTRUCTION("62F26D28264C2B04" , vptestmb(k1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D28264C2B04" , vptestmb(k1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D4826CB" , vptestmb(k1, zmm2, zmm3)); + TEST_INSTRUCTION("62F26D48264C2B02" , vptestmb(k1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D48264C2B02" , vptestmb(k1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D0827CB" , vptestmd(k1, xmm2, xmm3)); + TEST_INSTRUCTION("62F26D08274C2B08" , vptestmd(k1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D08274C2B08" , vptestmd(k1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D2827CB" , vptestmd(k1, ymm2, ymm3)); + TEST_INSTRUCTION("62F26D28274C2B04" , vptestmd(k1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D28274C2B04" , vptestmd(k1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D4827CB" , vptestmd(k1, zmm2, zmm3)); + TEST_INSTRUCTION("62F26D48274C2B02" , vptestmd(k1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D48274C2B02" , vptestmd(k1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED0827CB" , vptestmq(k1, xmm2, xmm3)); + TEST_INSTRUCTION("62F2ED08274C2B08" , vptestmq(k1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED08274C2B08" , vptestmq(k1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED2827CB" , vptestmq(k1, ymm2, ymm3)); + TEST_INSTRUCTION("62F2ED28274C2B04" , vptestmq(k1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED28274C2B04" , vptestmq(k1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED4827CB" , vptestmq(k1, zmm2, zmm3)); + TEST_INSTRUCTION("62F2ED48274C2B02" , vptestmq(k1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED48274C2B02" , vptestmq(k1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED0826CB" , vptestmw(k1, xmm2, xmm3)); + TEST_INSTRUCTION("62F2ED08264C2B08" , vptestmw(k1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED08264C2B08" , vptestmw(k1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED2826CB" , vptestmw(k1, ymm2, ymm3)); + TEST_INSTRUCTION("62F2ED28264C2B04" , vptestmw(k1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED28264C2B04" , vptestmw(k1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED4826CB" , vptestmw(k1, zmm2, zmm3)); + TEST_INSTRUCTION("62F2ED48264C2B02" , vptestmw(k1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED48264C2B02" , vptestmw(k1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26E0826CB" , vptestnmb(k1, xmm2, xmm3)); + TEST_INSTRUCTION("62F26E08264C2B08" , vptestnmb(k1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26E08264C2B08" , vptestnmb(k1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26E2826CB" , vptestnmb(k1, ymm2, ymm3)); + TEST_INSTRUCTION("62F26E28264C2B04" , vptestnmb(k1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26E28264C2B04" , vptestnmb(k1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26E4826CB" , vptestnmb(k1, zmm2, zmm3)); + TEST_INSTRUCTION("62F26E48264C2B02" , vptestnmb(k1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26E48264C2B02" , vptestnmb(k1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26E0827CB" , vptestnmd(k1, xmm2, xmm3)); + TEST_INSTRUCTION("62F26E08274C2B08" , vptestnmd(k1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26E08274C2B08" , vptestnmd(k1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26E2827CB" , vptestnmd(k1, ymm2, ymm3)); + TEST_INSTRUCTION("62F26E28274C2B04" , vptestnmd(k1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26E28274C2B04" , vptestnmd(k1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26E4827CB" , vptestnmd(k1, zmm2, zmm3)); + TEST_INSTRUCTION("62F26E48274C2B02" , vptestnmd(k1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26E48274C2B02" , vptestnmd(k1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2EE0827CB" , vptestnmq(k1, xmm2, xmm3)); + TEST_INSTRUCTION("62F2EE08274C2B08" , vptestnmq(k1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2EE08274C2B08" , vptestnmq(k1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2EE2827CB" , vptestnmq(k1, ymm2, ymm3)); + TEST_INSTRUCTION("62F2EE28274C2B04" , vptestnmq(k1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2EE28274C2B04" , vptestnmq(k1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2EE4827CB" , vptestnmq(k1, zmm2, zmm3)); + TEST_INSTRUCTION("62F2EE48274C2B02" , vptestnmq(k1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2EE48274C2B02" , vptestnmq(k1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2EE0826CB" , vptestnmw(k1, xmm2, xmm3)); + TEST_INSTRUCTION("62F2EE08264C2B08" , vptestnmw(k1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2EE08264C2B08" , vptestnmw(k1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2EE2826CB" , vptestnmw(k1, ymm2, ymm3)); + TEST_INSTRUCTION("62F2EE28264C2B04" , vptestnmw(k1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2EE28264C2B04" , vptestnmw(k1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2EE4826CB" , vptestnmw(k1, zmm2, zmm3)); + TEST_INSTRUCTION("62F2EE48264C2B02" , vptestnmw(k1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2EE48264C2B02" , vptestnmw(k1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5E968CB" , vpunpckhbw(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5E9688C2B80000000" , vpunpckhbw(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5E9688C2B80000000" , vpunpckhbw(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5ED68CB" , vpunpckhbw(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C5ED688C2B80000000" , vpunpckhbw(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5ED688C2B80000000" , vpunpckhbw(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16D4868CB" , vpunpckhbw(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F16D48684C2B02" , vpunpckhbw(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16D48684C2B02" , vpunpckhbw(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5E96ACB" , vpunpckhdq(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5E96A8C2B80000000" , vpunpckhdq(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5E96A8C2B80000000" , vpunpckhdq(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5ED6ACB" , vpunpckhdq(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C5ED6A8C2B80000000" , vpunpckhdq(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5ED6A8C2B80000000" , vpunpckhdq(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16D486ACB" , vpunpckhdq(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F16D486A4C2B02" , vpunpckhdq(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16D486A4C2B02" , vpunpckhdq(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5E96DCB" , vpunpckhqdq(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5E96D8C2B80000000" , vpunpckhqdq(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5E96D8C2B80000000" , vpunpckhqdq(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5ED6DCB" , vpunpckhqdq(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C5ED6D8C2B80000000" , vpunpckhqdq(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5ED6D8C2B80000000" , vpunpckhqdq(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F1ED486DCB" , vpunpckhqdq(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F1ED486D4C2B02" , vpunpckhqdq(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F1ED486D4C2B02" , vpunpckhqdq(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5E969CB" , vpunpckhwd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5E9698C2B80000000" , vpunpckhwd(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5E9698C2B80000000" , vpunpckhwd(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5ED69CB" , vpunpckhwd(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C5ED698C2B80000000" , vpunpckhwd(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5ED698C2B80000000" , vpunpckhwd(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16D4869CB" , vpunpckhwd(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F16D48694C2B02" , vpunpckhwd(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16D48694C2B02" , vpunpckhwd(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5E960CB" , vpunpcklbw(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5E9608C2B80000000" , vpunpcklbw(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5E9608C2B80000000" , vpunpcklbw(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5ED60CB" , vpunpcklbw(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C5ED608C2B80000000" , vpunpcklbw(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5ED608C2B80000000" , vpunpcklbw(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16D4860CB" , vpunpcklbw(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F16D48604C2B02" , vpunpcklbw(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16D48604C2B02" , vpunpcklbw(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5E962CB" , vpunpckldq(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5E9628C2B80000000" , vpunpckldq(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5E9628C2B80000000" , vpunpckldq(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5ED62CB" , vpunpckldq(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C5ED628C2B80000000" , vpunpckldq(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5ED628C2B80000000" , vpunpckldq(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16D4862CB" , vpunpckldq(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F16D48624C2B02" , vpunpckldq(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16D48624C2B02" , vpunpckldq(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5E96CCB" , vpunpcklqdq(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5E96C8C2B80000000" , vpunpcklqdq(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5E96C8C2B80000000" , vpunpcklqdq(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5ED6CCB" , vpunpcklqdq(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C5ED6C8C2B80000000" , vpunpcklqdq(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5ED6C8C2B80000000" , vpunpcklqdq(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F1ED486CCB" , vpunpcklqdq(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F1ED486C4C2B02" , vpunpcklqdq(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F1ED486C4C2B02" , vpunpcklqdq(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5E961CB" , vpunpcklwd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5E9618C2B80000000" , vpunpcklwd(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5E9618C2B80000000" , vpunpcklwd(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5ED61CB" , vpunpcklwd(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C5ED618C2B80000000" , vpunpcklwd(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5ED618C2B80000000" , vpunpcklwd(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16D4861CB" , vpunpcklwd(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F16D48614C2B02" , vpunpcklwd(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16D48614C2B02" , vpunpcklwd(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5E9EFCB" , vpxor(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5E9EF8C2B80000000" , vpxor(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5E9EF8C2B80000000" , vpxor(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5EDEFCB" , vpxor(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C5EDEF8C2B80000000" , vpxor(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5EDEF8C2B80000000" , vpxor(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16D08EFCB" , vpxord(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("62F16D08EF4C2B08" , vpxord(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16D08EF4C2B08" , vpxord(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16D28EFCB" , vpxord(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("62F16D28EF4C2B04" , vpxord(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16D28EF4C2B04" , vpxord(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16D48EFCB" , vpxord(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F16D48EF4C2B02" , vpxord(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16D48EF4C2B02" , vpxord(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F1ED08EFCB" , vpxorq(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("62F1ED08EF4C2B08" , vpxorq(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F1ED08EF4C2B08" , vpxorq(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F1ED28EFCB" , vpxorq(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("62F1ED28EF4C2B04" , vpxorq(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F1ED28EF4C2B04" , vpxorq(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F1ED48EFCB" , vpxorq(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F1ED48EF4C2B02" , vpxorq(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F1ED48EF4C2B02" , vpxorq(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F3ED0850CB01" , vrangepd(xmm1, xmm2, xmm3, 1)); + TEST_INSTRUCTION("62F3ED08504C2B0801" , vrangepd(xmm1, xmm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED08504C2B0801" , vrangepd(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED2850CB01" , vrangepd(ymm1, ymm2, ymm3, 1)); + TEST_INSTRUCTION("62F3ED28504C2B0401" , vrangepd(ymm1, ymm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED28504C2B0401" , vrangepd(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED4850CB01" , vrangepd(zmm1, zmm2, zmm3, 1)); + TEST_INSTRUCTION("62F3ED48504C2B0201" , vrangepd(zmm1, zmm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED48504C2B0201" , vrangepd(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D0850CB01" , vrangeps(xmm1, xmm2, xmm3, 1)); + TEST_INSTRUCTION("62F36D08504C2B0801" , vrangeps(xmm1, xmm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D08504C2B0801" , vrangeps(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D2850CB01" , vrangeps(ymm1, ymm2, ymm3, 1)); + TEST_INSTRUCTION("62F36D28504C2B0401" , vrangeps(ymm1, ymm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D28504C2B0401" , vrangeps(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D4850CB01" , vrangeps(zmm1, zmm2, zmm3, 1)); + TEST_INSTRUCTION("62F36D48504C2B0201" , vrangeps(zmm1, zmm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D48504C2B0201" , vrangeps(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED0851CB01" , vrangesd(xmm1, xmm2, xmm3, 1)); + TEST_INSTRUCTION("62F3ED08514C2B1001" , vrangesd(xmm1, xmm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED08514C2B1001" , vrangesd(xmm1, xmm2, qword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D0851CB01" , vrangess(xmm1, xmm2, xmm3, 1)); + TEST_INSTRUCTION("62F36D08514C2B2001" , vrangess(xmm1, xmm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D08514C2B2001" , vrangess(xmm1, xmm2, dword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F2FD084CCA" , vrcp14pd(xmm1, xmm2)); + TEST_INSTRUCTION("62F2FD084C4C1A08" , vrcp14pd(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F2FD084C4C1A08" , vrcp14pd(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F2FD284CCA" , vrcp14pd(ymm1, ymm2)); + TEST_INSTRUCTION("62F2FD284C4C1A04" , vrcp14pd(ymm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F2FD284C4C1A04" , vrcp14pd(ymm1, ymmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F2FD484CCA" , vrcp14pd(zmm1, zmm2)); + TEST_INSTRUCTION("62F2FD484C4C1A02" , vrcp14pd(zmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F2FD484C4C1A02" , vrcp14pd(zmm1, zmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F27D084CCA" , vrcp14ps(xmm1, xmm2)); + TEST_INSTRUCTION("62F27D084C4C1A08" , vrcp14ps(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F27D084C4C1A08" , vrcp14ps(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F27D284CCA" , vrcp14ps(ymm1, ymm2)); + TEST_INSTRUCTION("62F27D284C4C1A04" , vrcp14ps(ymm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F27D284C4C1A04" , vrcp14ps(ymm1, ymmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F27D484CCA" , vrcp14ps(zmm1, zmm2)); + TEST_INSTRUCTION("62F27D484C4C1A02" , vrcp14ps(zmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F27D484C4C1A02" , vrcp14ps(zmm1, zmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F2ED084DCB" , vrcp14sd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("62F2ED084D4C2B10" , vrcp14sd(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED084D4C2B10" , vrcp14sd(xmm1, xmm2, qword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D084DCB" , vrcp14ss(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("62F26D084D4C2B20" , vrcp14ss(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D084D4C2B20" , vrcp14ss(xmm1, xmm2, dword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2FD48CACA" , vrcp28pd(zmm1, zmm2)); + TEST_INSTRUCTION("62F2FD48CA4C1A02" , vrcp28pd(zmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F2FD48CA4C1A02" , vrcp28pd(zmm1, zmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F27D48CACA" , vrcp28ps(zmm1, zmm2)); + TEST_INSTRUCTION("62F27D48CA4C1A02" , vrcp28ps(zmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F27D48CA4C1A02" , vrcp28ps(zmm1, zmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F2ED08CBCB" , vrcp28sd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("62F2ED08CB4C2B10" , vrcp28sd(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED08CB4C2B10" , vrcp28sd(xmm1, xmm2, qword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D08CBCB" , vrcp28ss(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("62F26D08CB4C2B20" , vrcp28ss(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D08CB4C2B20" , vrcp28ss(xmm1, xmm2, dword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5F853CA" , vrcpps(xmm1, xmm2)); + TEST_INSTRUCTION("C5F8538C1A80000000" , vrcpps(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C5F8538C1A80000000" , vrcpps(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C5FC53CA" , vrcpps(ymm1, ymm2)); + TEST_INSTRUCTION("C5FC538C1A80000000" , vrcpps(ymm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C5FC538C1A80000000" , vrcpps(ymm1, ymmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C5EA53CB" , vrcpss(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5EA538C2B80000000" , vrcpss(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5EA538C2B80000000" , vrcpss(xmm1, xmm2, dword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F3FD0856CA01" , vreducepd(xmm1, xmm2, 1)); + TEST_INSTRUCTION("62F3FD08564C1A0801" , vreducepd(xmm1, ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("62F3FD08564C1A0801" , vreducepd(xmm1, xmmword_ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("62F3FD2856CA01" , vreducepd(ymm1, ymm2, 1)); + TEST_INSTRUCTION("62F3FD28564C1A0401" , vreducepd(ymm1, ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("62F3FD28564C1A0401" , vreducepd(ymm1, ymmword_ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("62F3FD4856CA01" , vreducepd(zmm1, zmm2, 1)); + TEST_INSTRUCTION("62F3FD48564C1A0201" , vreducepd(zmm1, ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("62F3FD48564C1A0201" , vreducepd(zmm1, zmmword_ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("62F37D0856CA01" , vreduceps(xmm1, xmm2, 1)); + TEST_INSTRUCTION("62F37D08564C1A0801" , vreduceps(xmm1, ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("62F37D08564C1A0801" , vreduceps(xmm1, xmmword_ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("62F37D2856CA01" , vreduceps(ymm1, ymm2, 1)); + TEST_INSTRUCTION("62F37D28564C1A0401" , vreduceps(ymm1, ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("62F37D28564C1A0401" , vreduceps(ymm1, ymmword_ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("62F37D4856CA01" , vreduceps(zmm1, zmm2, 1)); + TEST_INSTRUCTION("62F37D48564C1A0201" , vreduceps(zmm1, ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("62F37D48564C1A0201" , vreduceps(zmm1, zmmword_ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED0857CB01" , vreducesd(xmm1, xmm2, xmm3, 1)); + TEST_INSTRUCTION("62F3ED08574C2B1001" , vreducesd(xmm1, xmm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED08574C2B1001" , vreducesd(xmm1, xmm2, qword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D0857CB01" , vreducess(xmm1, xmm2, xmm3, 1)); + TEST_INSTRUCTION("62F36D08574C2B2001" , vreducess(xmm1, xmm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D08574C2B2001" , vreducess(xmm1, xmm2, dword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F3FD0809CA01" , vrndscalepd(xmm1, xmm2, 1)); + TEST_INSTRUCTION("62F3FD08094C1A0801" , vrndscalepd(xmm1, ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("62F3FD08094C1A0801" , vrndscalepd(xmm1, xmmword_ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("62F3FD2809CA01" , vrndscalepd(ymm1, ymm2, 1)); + TEST_INSTRUCTION("62F3FD28094C1A0401" , vrndscalepd(ymm1, ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("62F3FD28094C1A0401" , vrndscalepd(ymm1, ymmword_ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("62F3FD4809CA01" , vrndscalepd(zmm1, zmm2, 1)); + TEST_INSTRUCTION("62F3FD48094C1A0201" , vrndscalepd(zmm1, ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("62F3FD48094C1A0201" , vrndscalepd(zmm1, zmmword_ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("62F37D0808CA01" , vrndscaleps(xmm1, xmm2, 1)); + TEST_INSTRUCTION("62F37D08084C1A0801" , vrndscaleps(xmm1, ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("62F37D08084C1A0801" , vrndscaleps(xmm1, xmmword_ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("62F37D2808CA01" , vrndscaleps(ymm1, ymm2, 1)); + TEST_INSTRUCTION("62F37D28084C1A0401" , vrndscaleps(ymm1, ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("62F37D28084C1A0401" , vrndscaleps(ymm1, ymmword_ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("62F37D4808CA01" , vrndscaleps(zmm1, zmm2, 1)); + TEST_INSTRUCTION("62F37D48084C1A0201" , vrndscaleps(zmm1, ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("62F37D48084C1A0201" , vrndscaleps(zmm1, zmmword_ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED080BCB01" , vrndscalesd(xmm1, xmm2, xmm3, 1)); + TEST_INSTRUCTION("62F3ED080B4C2B1001" , vrndscalesd(xmm1, xmm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED080B4C2B1001" , vrndscalesd(xmm1, xmm2, qword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D080ACB01" , vrndscaless(xmm1, xmm2, xmm3, 1)); + TEST_INSTRUCTION("62F36D080A4C2B2001" , vrndscaless(xmm1, xmm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D080A4C2B2001" , vrndscaless(xmm1, xmm2, dword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("C4E37909CA01" , vroundpd(xmm1, xmm2, 1)); + TEST_INSTRUCTION("C4E379098C1A8000000001" , vroundpd(xmm1, ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("C4E379098C1A8000000001" , vroundpd(xmm1, xmmword_ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("C4E37D09CA01" , vroundpd(ymm1, ymm2, 1)); + TEST_INSTRUCTION("C4E37D098C1A8000000001" , vroundpd(ymm1, ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("C4E37D098C1A8000000001" , vroundpd(ymm1, ymmword_ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("C4E37908CA01" , vroundps(xmm1, xmm2, 1)); + TEST_INSTRUCTION("C4E379088C1A8000000001" , vroundps(xmm1, ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("C4E379088C1A8000000001" , vroundps(xmm1, xmmword_ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("C4E37D08CA01" , vroundps(ymm1, ymm2, 1)); + TEST_INSTRUCTION("C4E37D088C1A8000000001" , vroundps(ymm1, ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("C4E37D088C1A8000000001" , vroundps(ymm1, ymmword_ptr(edx, ebx, 0, 128), 1)); + TEST_INSTRUCTION("C4E3690BCB01" , vroundsd(xmm1, xmm2, xmm3, 1)); + TEST_INSTRUCTION("C4E3690B8C2B8000000001" , vroundsd(xmm1, xmm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("C4E3690B8C2B8000000001" , vroundsd(xmm1, xmm2, qword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("C4E3690ACB01" , vroundss(xmm1, xmm2, xmm3, 1)); + TEST_INSTRUCTION("C4E3690A8C2B8000000001" , vroundss(xmm1, xmm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("C4E3690A8C2B8000000001" , vroundss(xmm1, xmm2, dword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F2FD084ECA" , vrsqrt14pd(xmm1, xmm2)); + TEST_INSTRUCTION("62F2FD084E4C1A08" , vrsqrt14pd(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F2FD084E4C1A08" , vrsqrt14pd(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F2FD284ECA" , vrsqrt14pd(ymm1, ymm2)); + TEST_INSTRUCTION("62F2FD284E4C1A04" , vrsqrt14pd(ymm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F2FD284E4C1A04" , vrsqrt14pd(ymm1, ymmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F2FD484ECA" , vrsqrt14pd(zmm1, zmm2)); + TEST_INSTRUCTION("62F2FD484E4C1A02" , vrsqrt14pd(zmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F2FD484E4C1A02" , vrsqrt14pd(zmm1, zmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F27D084ECA" , vrsqrt14ps(xmm1, xmm2)); + TEST_INSTRUCTION("62F27D084E4C1A08" , vrsqrt14ps(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F27D084E4C1A08" , vrsqrt14ps(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F27D284ECA" , vrsqrt14ps(ymm1, ymm2)); + TEST_INSTRUCTION("62F27D284E4C1A04" , vrsqrt14ps(ymm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F27D284E4C1A04" , vrsqrt14ps(ymm1, ymmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F27D484ECA" , vrsqrt14ps(zmm1, zmm2)); + TEST_INSTRUCTION("62F27D484E4C1A02" , vrsqrt14ps(zmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F27D484E4C1A02" , vrsqrt14ps(zmm1, zmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F2ED084FCB" , vrsqrt14sd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("62F2ED084F4C2B10" , vrsqrt14sd(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED084F4C2B10" , vrsqrt14sd(xmm1, xmm2, qword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D084FCB" , vrsqrt14ss(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("62F26D084F4C2B20" , vrsqrt14ss(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D084F4C2B20" , vrsqrt14ss(xmm1, xmm2, dword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2FD48CCCA" , vrsqrt28pd(zmm1, zmm2)); + TEST_INSTRUCTION("62F2FD48CC4C1A02" , vrsqrt28pd(zmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F2FD48CC4C1A02" , vrsqrt28pd(zmm1, zmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F27D48CCCA" , vrsqrt28ps(zmm1, zmm2)); + TEST_INSTRUCTION("62F27D48CC4C1A02" , vrsqrt28ps(zmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F27D48CC4C1A02" , vrsqrt28ps(zmm1, zmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F2ED08CDCB" , vrsqrt28sd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("62F2ED08CD4C2B10" , vrsqrt28sd(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED08CD4C2B10" , vrsqrt28sd(xmm1, xmm2, qword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D08CDCB" , vrsqrt28ss(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("62F26D08CD4C2B20" , vrsqrt28ss(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D08CD4C2B20" , vrsqrt28ss(xmm1, xmm2, dword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5F852CA" , vrsqrtps(xmm1, xmm2)); + TEST_INSTRUCTION("C5F8528C1A80000000" , vrsqrtps(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C5F8528C1A80000000" , vrsqrtps(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C5FC52CA" , vrsqrtps(ymm1, ymm2)); + TEST_INSTRUCTION("C5FC528C1A80000000" , vrsqrtps(ymm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C5FC528C1A80000000" , vrsqrtps(ymm1, ymmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C5EA52CB" , vrsqrtss(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5EA528C2B80000000" , vrsqrtss(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5EA528C2B80000000" , vrsqrtss(xmm1, xmm2, dword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED082CCB" , vscalefpd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("62F2ED082C4C2B08" , vscalefpd(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED082C4C2B08" , vscalefpd(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED282CCB" , vscalefpd(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("62F2ED282C4C2B04" , vscalefpd(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED282C4C2B04" , vscalefpd(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED482CCB" , vscalefpd(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F2ED482C4C2B02" , vscalefpd(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED482C4C2B02" , vscalefpd(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D082CCB" , vscalefps(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("62F26D082C4C2B08" , vscalefps(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D082C4C2B08" , vscalefps(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D282CCB" , vscalefps(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("62F26D282C4C2B04" , vscalefps(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D282C4C2B04" , vscalefps(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D482CCB" , vscalefps(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F26D482C4C2B02" , vscalefps(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D482C4C2B02" , vscalefps(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED082DCB" , vscalefsd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("62F2ED082D4C2B10" , vscalefsd(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2ED082D4C2B10" , vscalefsd(xmm1, xmm2, qword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D082DCB" , vscalefss(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("62F26D082D4C2B20" , vscalefss(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F26D082D4C2B20" , vscalefss(xmm1, xmm2, dword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F2FD09A25C1110" , k(k1).vscatterdpd(ptr(ecx, xmm2, 0, 128), xmm3)); + TEST_INSTRUCTION("62F2FD29A25C1110" , k(k1).vscatterdpd(ptr(ecx, xmm2, 0, 128), ymm3)); + TEST_INSTRUCTION("62F2FD49A25C1110" , k(k1).vscatterdpd(ptr(ecx, ymm2, 0, 128), zmm3)); + TEST_INSTRUCTION("62F27D09A25C1120" , k(k1).vscatterdps(ptr(ecx, xmm2, 0, 128), xmm3)); + TEST_INSTRUCTION("62F27D29A25C1120" , k(k1).vscatterdps(ptr(ecx, ymm2, 0, 128), ymm3)); + TEST_INSTRUCTION("62F27D49A25C1120" , k(k1).vscatterdps(ptr(ecx, zmm2, 0, 128), zmm3)); + TEST_INSTRUCTION("62F2FD49C66C1110" , k(k1).vscatterpf0dpd(ptr(ecx, ymm2, 0, 128))); + TEST_INSTRUCTION("62F27D49C66C1120" , k(k1).vscatterpf0dps(ptr(ecx, zmm2, 0, 128))); + TEST_INSTRUCTION("62F2FD49C76C1110" , k(k1).vscatterpf0qpd(ptr(ecx, zmm2, 0, 128))); + TEST_INSTRUCTION("62F27D49C76C1120" , k(k1).vscatterpf0qps(ptr(ecx, zmm2, 0, 128))); + TEST_INSTRUCTION("62F2FD49C6741110" , k(k1).vscatterpf1dpd(ptr(ecx, ymm2, 0, 128))); + TEST_INSTRUCTION("62F27D49C6741120" , k(k1).vscatterpf1dps(ptr(ecx, zmm2, 0, 128))); + TEST_INSTRUCTION("62F2FD49C7741110" , k(k1).vscatterpf1qpd(ptr(ecx, zmm2, 0, 128))); + TEST_INSTRUCTION("62F27D49C7741120" , k(k1).vscatterpf1qps(ptr(ecx, zmm2, 0, 128))); + TEST_INSTRUCTION("62F2FD09A35C1110" , k(k1).vscatterqpd(ptr(ecx, xmm2, 0, 128), xmm3)); + TEST_INSTRUCTION("62F2FD29A35C1110" , k(k1).vscatterqpd(ptr(ecx, ymm2, 0, 128), ymm3)); + TEST_INSTRUCTION("62F2FD49A35C1110" , k(k1).vscatterqpd(ptr(ecx, zmm2, 0, 128), zmm3)); + TEST_INSTRUCTION("62F27D09A35C1120" , k(k1).vscatterqps(ptr(ecx, xmm2, 0, 128), xmm3)); + TEST_INSTRUCTION("62F27D29A35C1120" , k(k1).vscatterqps(ptr(ecx, ymm2, 0, 128), xmm3)); + TEST_INSTRUCTION("62F27D49A35C1120" , k(k1).vscatterqps(ptr(ecx, zmm2, 0, 128), ymm3)); + TEST_INSTRUCTION("62F36D2823CB01" , vshuff32x4(ymm1, ymm2, ymm3, 1)); + TEST_INSTRUCTION("62F36D28234C2B0401" , vshuff32x4(ymm1, ymm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D28234C2B0401" , vshuff32x4(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D4823CB01" , vshuff32x4(zmm1, zmm2, zmm3, 1)); + TEST_INSTRUCTION("62F36D48234C2B0201" , vshuff32x4(zmm1, zmm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D48234C2B0201" , vshuff32x4(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED2823CB01" , vshuff64x2(ymm1, ymm2, ymm3, 1)); + TEST_INSTRUCTION("62F3ED28234C2B0401" , vshuff64x2(ymm1, ymm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED28234C2B0401" , vshuff64x2(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED4823CB01" , vshuff64x2(zmm1, zmm2, zmm3, 1)); + TEST_INSTRUCTION("62F3ED48234C2B0201" , vshuff64x2(zmm1, zmm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED48234C2B0201" , vshuff64x2(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D2843CB01" , vshufi32x4(ymm1, ymm2, ymm3, 1)); + TEST_INSTRUCTION("62F36D28434C2B0401" , vshufi32x4(ymm1, ymm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D28434C2B0401" , vshufi32x4(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D4843CB01" , vshufi32x4(zmm1, zmm2, zmm3, 1)); + TEST_INSTRUCTION("62F36D48434C2B0201" , vshufi32x4(zmm1, zmm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F36D48434C2B0201" , vshufi32x4(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED2843CB01" , vshufi64x2(ymm1, ymm2, ymm3, 1)); + TEST_INSTRUCTION("62F3ED28434C2B0401" , vshufi64x2(ymm1, ymm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED28434C2B0401" , vshufi64x2(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED4843CB01" , vshufi64x2(zmm1, zmm2, zmm3, 1)); + TEST_INSTRUCTION("62F3ED48434C2B0201" , vshufi64x2(zmm1, zmm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F3ED48434C2B0201" , vshufi64x2(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("C5E9C6CB01" , vshufpd(xmm1, xmm2, xmm3, 1)); + TEST_INSTRUCTION("C5E9C68C2B8000000001" , vshufpd(xmm1, xmm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("C5E9C68C2B8000000001" , vshufpd(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("C5EDC6CB01" , vshufpd(ymm1, ymm2, ymm3, 1)); + TEST_INSTRUCTION("C5EDC68C2B8000000001" , vshufpd(ymm1, ymm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("C5EDC68C2B8000000001" , vshufpd(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F1ED48C6CB01" , vshufpd(zmm1, zmm2, zmm3, 1)); + TEST_INSTRUCTION("62F1ED48C64C2B0201" , vshufpd(zmm1, zmm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F1ED48C64C2B0201" , vshufpd(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("C5E8C6CB01" , vshufps(xmm1, xmm2, xmm3, 1)); + TEST_INSTRUCTION("C5E8C68C2B8000000001" , vshufps(xmm1, xmm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("C5E8C68C2B8000000001" , vshufps(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("C5ECC6CB01" , vshufps(ymm1, ymm2, ymm3, 1)); + TEST_INSTRUCTION("C5ECC68C2B8000000001" , vshufps(ymm1, ymm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("C5ECC68C2B8000000001" , vshufps(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F16C48C6CB01" , vshufps(zmm1, zmm2, zmm3, 1)); + TEST_INSTRUCTION("62F16C48C64C2B0201" , vshufps(zmm1, zmm2, ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("62F16C48C64C2B0201" , vshufps(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128), 1)); + TEST_INSTRUCTION("C5F951CA" , vsqrtpd(xmm1, xmm2)); + TEST_INSTRUCTION("C5F9518C1A80000000" , vsqrtpd(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C5F9518C1A80000000" , vsqrtpd(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C5FD51CA" , vsqrtpd(ymm1, ymm2)); + TEST_INSTRUCTION("C5FD518C1A80000000" , vsqrtpd(ymm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C5FD518C1A80000000" , vsqrtpd(ymm1, ymmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F1FD4851CA" , vsqrtpd(zmm1, zmm2)); + TEST_INSTRUCTION("62F1FD48514C1A02" , vsqrtpd(zmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F1FD48514C1A02" , vsqrtpd(zmm1, zmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C5F851CA" , vsqrtps(xmm1, xmm2)); + TEST_INSTRUCTION("C5F8518C1A80000000" , vsqrtps(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C5F8518C1A80000000" , vsqrtps(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C5FC51CA" , vsqrtps(ymm1, ymm2)); + TEST_INSTRUCTION("C5FC518C1A80000000" , vsqrtps(ymm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C5FC518C1A80000000" , vsqrtps(ymm1, ymmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F17C4851CA" , vsqrtps(zmm1, zmm2)); + TEST_INSTRUCTION("62F17C48514C1A02" , vsqrtps(zmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("62F17C48514C1A02" , vsqrtps(zmm1, zmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C5EB51CB" , vsqrtsd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5EB518C2B80000000" , vsqrtsd(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5EB518C2B80000000" , vsqrtsd(xmm1, xmm2, qword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5EA51CB" , vsqrtss(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5EA518C2B80000000" , vsqrtss(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5EA518C2B80000000" , vsqrtss(xmm1, xmm2, dword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5F8AE9C1180000000" , vstmxcsr(ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("C5F8AE9C1180000000" , vstmxcsr(dword_ptr(ecx, edx, 0, 128))); + TEST_INSTRUCTION("C5E95CCB" , vsubpd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5E95C8C2B80000000" , vsubpd(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5E95C8C2B80000000" , vsubpd(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5ED5CCB" , vsubpd(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C5ED5C8C2B80000000" , vsubpd(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5ED5C8C2B80000000" , vsubpd(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F1ED485CCB" , vsubpd(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F1ED485C4C2B02" , vsubpd(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F1ED485C4C2B02" , vsubpd(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5E85CCB" , vsubps(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5E85C8C2B80000000" , vsubps(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5E85C8C2B80000000" , vsubps(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5EC5CCB" , vsubps(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C5EC5C8C2B80000000" , vsubps(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5EC5C8C2B80000000" , vsubps(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16C485CCB" , vsubps(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F16C485C4C2B02" , vsubps(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16C485C4C2B02" , vsubps(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5EB5CCB" , vsubsd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5EB5C8C2B80000000" , vsubsd(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5EB5C8C2B80000000" , vsubsd(xmm1, xmm2, qword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5EA5CCB" , vsubss(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5EA5C8C2B80000000" , vsubss(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5EA5C8C2B80000000" , vsubss(xmm1, xmm2, dword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C4E2790FCA" , vtestpd(xmm1, xmm2)); + TEST_INSTRUCTION("C4E2790F8C1A80000000" , vtestpd(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C4E2790F8C1A80000000" , vtestpd(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C4E27D0FCA" , vtestpd(ymm1, ymm2)); + TEST_INSTRUCTION("C4E27D0F8C1A80000000" , vtestpd(ymm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C4E27D0F8C1A80000000" , vtestpd(ymm1, ymmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C4E2790ECA" , vtestps(xmm1, xmm2)); + TEST_INSTRUCTION("C4E2790E8C1A80000000" , vtestps(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C4E2790E8C1A80000000" , vtestps(xmm1, xmmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C4E27D0ECA" , vtestps(ymm1, ymm2)); + TEST_INSTRUCTION("C4E27D0E8C1A80000000" , vtestps(ymm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C4E27D0E8C1A80000000" , vtestps(ymm1, ymmword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C5F92ECA" , vucomisd(xmm1, xmm2)); + TEST_INSTRUCTION("C5F92E8C1A80000000" , vucomisd(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C5F92E8C1A80000000" , vucomisd(xmm1, qword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C5F82ECA" , vucomiss(xmm1, xmm2)); + TEST_INSTRUCTION("C5F82E8C1A80000000" , vucomiss(xmm1, ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C5F82E8C1A80000000" , vucomiss(xmm1, dword_ptr(edx, ebx, 0, 128))); + TEST_INSTRUCTION("C5E915CB" , vunpckhpd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5E9158C2B80000000" , vunpckhpd(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5E9158C2B80000000" , vunpckhpd(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5ED15CB" , vunpckhpd(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C5ED158C2B80000000" , vunpckhpd(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5ED158C2B80000000" , vunpckhpd(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F1ED4815CB" , vunpckhpd(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F1ED48154C2B02" , vunpckhpd(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F1ED48154C2B02" , vunpckhpd(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5E815CB" , vunpckhps(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5E8158C2B80000000" , vunpckhps(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5E8158C2B80000000" , vunpckhps(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5EC15CB" , vunpckhps(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C5EC158C2B80000000" , vunpckhps(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5EC158C2B80000000" , vunpckhps(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16C4815CB" , vunpckhps(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F16C48154C2B02" , vunpckhps(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16C48154C2B02" , vunpckhps(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5E914CB" , vunpcklpd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5E9148C2B80000000" , vunpcklpd(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5E9148C2B80000000" , vunpcklpd(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5ED14CB" , vunpcklpd(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C5ED148C2B80000000" , vunpcklpd(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5ED148C2B80000000" , vunpcklpd(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F1ED4814CB" , vunpcklpd(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F1ED48144C2B02" , vunpcklpd(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F1ED48144C2B02" , vunpcklpd(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5E814CB" , vunpcklps(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5E8148C2B80000000" , vunpcklps(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5E8148C2B80000000" , vunpcklps(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5EC14CB" , vunpcklps(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C5EC148C2B80000000" , vunpcklps(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5EC148C2B80000000" , vunpcklps(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16C4814CB" , vunpcklps(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F16C48144C2B02" , vunpcklps(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16C48144C2B02" , vunpcklps(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5E957CB" , vxorpd(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5E9578C2B80000000" , vxorpd(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5E9578C2B80000000" , vxorpd(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5ED57CB" , vxorpd(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C5ED578C2B80000000" , vxorpd(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5ED578C2B80000000" , vxorpd(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F1ED4857CB" , vxorpd(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F1ED48574C2B02" , vxorpd(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F1ED48574C2B02" , vxorpd(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5E857CB" , vxorps(xmm1, xmm2, xmm3)); + TEST_INSTRUCTION("C5E8578C2B80000000" , vxorps(xmm1, xmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5E8578C2B80000000" , vxorps(xmm1, xmm2, xmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5EC57CB" , vxorps(ymm1, ymm2, ymm3)); + TEST_INSTRUCTION("C5EC578C2B80000000" , vxorps(ymm1, ymm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5EC578C2B80000000" , vxorps(ymm1, ymm2, ymmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16C4857CB" , vxorps(zmm1, zmm2, zmm3)); + TEST_INSTRUCTION("62F16C48574C2B02" , vxorps(zmm1, zmm2, ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("62F16C48574C2B02" , vxorps(zmm1, zmm2, zmmword_ptr(ebx, ebp, 0, 128))); + TEST_INSTRUCTION("C5FC77" , vzeroall()); + TEST_INSTRUCTION("C5F877" , vzeroupper()); +} + +static void ASMJIT_NOINLINE testX86AssemblerAVX512_FP16(AssemblerTester<x86::Assembler>& tester) noexcept { + using namespace x86; + + TEST_INSTRUCTION("62F5560810F4" , vmovsh(xmm6, xmm5, xmm4)); + TEST_INSTRUCTION("62F57E0F10B4F400000010" , k(k7).vmovsh(xmm6, word_ptr(esp, esi, 3, 268435456))); + TEST_INSTRUCTION("62F57E081031" , vmovsh(xmm6, word_ptr(ecx))); + TEST_INSTRUCTION("62F57E0810717F" , vmovsh(xmm6, word_ptr(ecx, 254))); + TEST_INSTRUCTION("62F57E8F107280" , k(k7).z().vmovsh(xmm6, word_ptr(edx, -256))); + TEST_INSTRUCTION("62F57E0F11B4F400000010" , k(k7).vmovsh(word_ptr(esp, esi, 3, 268435456), xmm6)); + TEST_INSTRUCTION("62F57E081131" , vmovsh(word_ptr(ecx), xmm6)); + TEST_INSTRUCTION("62F57E0811717F" , vmovsh(word_ptr(ecx, 254), xmm6)); + TEST_INSTRUCTION("62F57E0F117280" , k(k7).vmovsh(word_ptr(edx, -256), xmm6)); + TEST_INSTRUCTION("62F57D086EF2" , vmovw(xmm6, edx)); + TEST_INSTRUCTION("62F57D087EF2" , vmovw(edx, xmm6)); + TEST_INSTRUCTION("62F57D086EB4F400000010" , vmovw(xmm6, word_ptr(esp, esi, 3, 268435456))); + TEST_INSTRUCTION("62F57D086E31" , vmovw(xmm6, word_ptr(ecx))); + TEST_INSTRUCTION("62F57D086E717F" , vmovw(xmm6, word_ptr(ecx, 254))); + TEST_INSTRUCTION("62F57D086E717F" , vmovw(xmm6, word_ptr(ecx, 254))); + TEST_INSTRUCTION("62F57D086E7280" , vmovw(xmm6, word_ptr(edx, -256))); + TEST_INSTRUCTION("62F57D087EB4F400000010" , vmovw(word_ptr(esp, esi, 3, 268435456), xmm6)); + TEST_INSTRUCTION("62F57D087E31" , vmovw(word_ptr(ecx), xmm6)); + TEST_INSTRUCTION("62F57D087E717F" , vmovw(word_ptr(ecx, 254), xmm6)); + TEST_INSTRUCTION("62F57D087E7280" , vmovw(word_ptr(edx, -256), xmm6)); + + TEST_INSTRUCTION("62F5544858F4" , vaddph(zmm6, zmm5, zmm4)); + TEST_INSTRUCTION("62F5541858F4" , rn_sae().vaddph(zmm6, zmm5, zmm4)); + TEST_INSTRUCTION("62F5544F58B4F400000010" , k(k7).vaddph(zmm6, zmm5, zmmword_ptr(esp, esi, 3, 268435456))); + TEST_INSTRUCTION("62F554585831" , vaddph(zmm6, zmm5, word_ptr(ecx)._1to32())); + TEST_INSTRUCTION("62F5544858717F" , vaddph(zmm6, zmm5, zmmword_ptr(ecx, 8128))); + TEST_INSTRUCTION("62F554DF587280" , k(k7).z().vaddph(zmm6, zmm5, word_ptr(edx, -256)._1to32())); + TEST_INSTRUCTION("62F5560858F4" , vaddsh(xmm6, xmm5, xmm4)); + TEST_INSTRUCTION("62F5561858F4" , rn_sae().vaddsh(xmm6, xmm5, xmm4)); + TEST_INSTRUCTION("62F5560F58B4F400000010" , k(k7).vaddsh(xmm6, xmm5, word_ptr(esp, esi, 3, 268435456))); + TEST_INSTRUCTION("62F556085831" , vaddsh(xmm6, xmm5, word_ptr(ecx))); + TEST_INSTRUCTION("62F5560858717F" , vaddsh(xmm6, xmm5, word_ptr(ecx, 254))); + TEST_INSTRUCTION("62F5568F587280" , k(k7).z().vaddsh(xmm6, xmm5, word_ptr(edx, -256))); + TEST_INSTRUCTION("62F35448C2EC7B" , vcmpph(k5, zmm5, zmm4, 123)); + TEST_INSTRUCTION("62F35418C2EC7B" , sae().vcmpph(k5, zmm5, zmm4, 123)); + TEST_INSTRUCTION("62F3544FC2ACF4000000107B" , k(k7).vcmpph(k5, zmm5, zmmword_ptr(esp, esi, 3, 268435456), 123)); + TEST_INSTRUCTION("62F35458C2297B" , vcmpph(k5, zmm5, word_ptr(ecx)._1to32(), 123)); + TEST_INSTRUCTION("62F35448C2697F7B" , vcmpph(k5, zmm5, zmmword_ptr(ecx, 8128), 123)); + TEST_INSTRUCTION("62F3545FC26A807B" , k(k7).vcmpph(k5, zmm5, word_ptr(edx, -256)._1to32(), 123)); + TEST_INSTRUCTION("62F35608C2EC7B" , vcmpsh(k5, xmm5, xmm4, 123)); + TEST_INSTRUCTION("62F35618C2EC7B" , sae().vcmpsh(k5, xmm5, xmm4, 123)); + TEST_INSTRUCTION("62F3560FC2ACF4000000107B" , k(k7).vcmpsh(k5, xmm5, word_ptr(esp, esi, 3, 268435456), 123)); + TEST_INSTRUCTION("62F35608C2297B" , vcmpsh(k5, xmm5, word_ptr(ecx), 123)); + TEST_INSTRUCTION("62F35608C2697F7B" , vcmpsh(k5, xmm5, word_ptr(ecx, 254), 123)); + TEST_INSTRUCTION("62F3560FC26A807B" , k(k7).vcmpsh(k5, xmm5, word_ptr(edx, -256), 123)); + TEST_INSTRUCTION("62F57C082FF5" , vcomish(xmm6, xmm5)); + TEST_INSTRUCTION("62F57C182FF5" , sae().vcomish(xmm6, xmm5)); + TEST_INSTRUCTION("62F57C082FB4F400000010" , vcomish(xmm6, word_ptr(esp, esi, 3, 268435456))); + TEST_INSTRUCTION("62F57C082F31" , vcomish(xmm6, word_ptr(ecx))); + TEST_INSTRUCTION("62F57C082F717F" , vcomish(xmm6, word_ptr(ecx, 254))); + TEST_INSTRUCTION("62F57C082F7280" , vcomish(xmm6, word_ptr(edx, -256))); + TEST_INSTRUCTION("62F57C485BF5" , vcvtdq2ph(ymm6, zmm5)); + TEST_INSTRUCTION("62F57C185BF5" , rn_sae().vcvtdq2ph(ymm6, zmm5)); + TEST_INSTRUCTION("62F57C4F5BB4F400000010" , k(k7).vcvtdq2ph(ymm6, zmmword_ptr(esp, esi, 3, 268435456))); + TEST_INSTRUCTION("62F57C585B31" , vcvtdq2ph(ymm6, dword_ptr(ecx)._1to16())); + TEST_INSTRUCTION("62F57C485B717F" , vcvtdq2ph(ymm6, zmmword_ptr(ecx, 8128))); + TEST_INSTRUCTION("62F57CDF5B7280" , k(k7).z().vcvtdq2ph(ymm6, dword_ptr(edx, -512)._1to16())); + TEST_INSTRUCTION("62F5FD485AF5" , vcvtpd2ph(xmm6, zmm5)); + TEST_INSTRUCTION("62F5FD185AF5" , rn_sae().vcvtpd2ph(xmm6, zmm5)); + TEST_INSTRUCTION("62F5FD4F5AB4F400000010" , k(k7).vcvtpd2ph(xmm6, zmmword_ptr(esp, esi, 3, 268435456))); + TEST_INSTRUCTION("62F5FD585A31" , vcvtpd2ph(xmm6, qword_ptr(ecx)._1to8())); + TEST_INSTRUCTION("62F5FD485A717F" , vcvtpd2ph(xmm6, zmmword_ptr(ecx, 8128))); + TEST_INSTRUCTION("62F5FDDF5A7280" , k(k7).z().vcvtpd2ph(xmm6, qword_ptr(edx, -1024)._1to8())); + TEST_INSTRUCTION("62F57D485BF5" , vcvtph2dq(zmm6, ymm5)); + TEST_INSTRUCTION("62F57D185BF5" , rn_sae().vcvtph2dq(zmm6, ymm5)); + TEST_INSTRUCTION("62F57D4F5BB4F400000010" , k(k7).vcvtph2dq(zmm6, ymmword_ptr(esp, esi, 3, 268435456))); + TEST_INSTRUCTION("62F57D585B31" , vcvtph2dq(zmm6, word_ptr(ecx)._1to16())); + TEST_INSTRUCTION("62F57D485B717F" , vcvtph2dq(zmm6, ymmword_ptr(ecx, 4064))); + TEST_INSTRUCTION("62F57DDF5B7280" , k(k7).z().vcvtph2dq(zmm6, word_ptr(edx, -256)._1to16())); + TEST_INSTRUCTION("62F57C485AF5" , vcvtph2pd(zmm6, xmm5)); + TEST_INSTRUCTION("62F57C185AF5" , sae().vcvtph2pd(zmm6, xmm5)); + TEST_INSTRUCTION("62F57C4F5AB4F400000010" , k(k7).vcvtph2pd(zmm6, xmmword_ptr(esp, esi, 3, 268435456))); + TEST_INSTRUCTION("62F57C585A31" , vcvtph2pd(zmm6, word_ptr(ecx)._1to8())); + TEST_INSTRUCTION("62F57C485A717F" , vcvtph2pd(zmm6, xmmword_ptr(ecx, 2032))); + TEST_INSTRUCTION("62F57CDF5A7280" , k(k7).z().vcvtph2pd(zmm6, word_ptr(edx, -256)._1to8())); + TEST_INSTRUCTION("62F67D4813F5" , vcvtph2psx(zmm6, ymm5)); + TEST_INSTRUCTION("62F67D1813F5" , sae().vcvtph2psx(zmm6, ymm5)); + TEST_INSTRUCTION("62F67D4F13B4F400000010" , k(k7).vcvtph2psx(zmm6, ymmword_ptr(esp, esi, 3, 268435456))); + TEST_INSTRUCTION("62F67D581331" , vcvtph2psx(zmm6, word_ptr(ecx)._1to16())); + TEST_INSTRUCTION("62F67D4813717F" , vcvtph2psx(zmm6, ymmword_ptr(ecx, 4064))); + TEST_INSTRUCTION("62F67DDF137280" , k(k7).z().vcvtph2psx(zmm6, word_ptr(edx, -256)._1to16())); + TEST_INSTRUCTION("62F57D487BF5" , vcvtph2qq(zmm6, xmm5)); + TEST_INSTRUCTION("62F57D187BF5" , rn_sae().vcvtph2qq(zmm6, xmm5)); + TEST_INSTRUCTION("62F57D4F7BB4F400000010" , k(k7).vcvtph2qq(zmm6, xmmword_ptr(esp, esi, 3, 268435456))); + TEST_INSTRUCTION("62F57D587B31" , vcvtph2qq(zmm6, word_ptr(ecx)._1to8())); + TEST_INSTRUCTION("62F57D487B717F" , vcvtph2qq(zmm6, xmmword_ptr(ecx, 2032))); + TEST_INSTRUCTION("62F57DDF7B7280" , k(k7).z().vcvtph2qq(zmm6, word_ptr(edx, -256)._1to8())); + TEST_INSTRUCTION("62F57C4879F5" , vcvtph2udq(zmm6, ymm5)); + TEST_INSTRUCTION("62F57C1879F5" , rn_sae().vcvtph2udq(zmm6, ymm5)); + TEST_INSTRUCTION("62F57C4F79B4F400000010" , k(k7).vcvtph2udq(zmm6, ymmword_ptr(esp, esi, 3, 268435456))); + TEST_INSTRUCTION("62F57C587931" , vcvtph2udq(zmm6, word_ptr(ecx)._1to16())); + TEST_INSTRUCTION("62F57C4879717F" , vcvtph2udq(zmm6, ymmword_ptr(ecx, 4064))); + TEST_INSTRUCTION("62F57CDF797280" , k(k7).z().vcvtph2udq(zmm6, word_ptr(edx, -256)._1to16())); + TEST_INSTRUCTION("62F57D4879F5" , vcvtph2uqq(zmm6, xmm5)); + TEST_INSTRUCTION("62F57D1879F5" , rn_sae().vcvtph2uqq(zmm6, xmm5)); + TEST_INSTRUCTION("62F57D4F79B4F400000010" , k(k7).vcvtph2uqq(zmm6, xmmword_ptr(esp, esi, 3, 268435456))); + TEST_INSTRUCTION("62F57D587931" , vcvtph2uqq(zmm6, word_ptr(ecx)._1to8())); + TEST_INSTRUCTION("62F57D4879717F" , vcvtph2uqq(zmm6, xmmword_ptr(ecx, 2032))); + TEST_INSTRUCTION("62F57DDF797280" , k(k7).z().vcvtph2uqq(zmm6, word_ptr(edx, -256)._1to8())); + TEST_INSTRUCTION("62F57C487DF5" , vcvtph2uw(zmm6, zmm5)); + TEST_INSTRUCTION("62F57C187DF5" , rn_sae().vcvtph2uw(zmm6, zmm5)); + TEST_INSTRUCTION("62F57C4F7DB4F400000010" , k(k7).vcvtph2uw(zmm6, zmmword_ptr(esp, esi, 3, 268435456))); + TEST_INSTRUCTION("62F57C587D31" , vcvtph2uw(zmm6, word_ptr(ecx)._1to32())); + TEST_INSTRUCTION("62F57C487D717F" , vcvtph2uw(zmm6, zmmword_ptr(ecx, 8128))); + TEST_INSTRUCTION("62F57CDF7D7280" , k(k7).z().vcvtph2uw(zmm6, word_ptr(edx, -256)._1to32())); + TEST_INSTRUCTION("62F57D487DF5" , vcvtph2w(zmm6, zmm5)); + TEST_INSTRUCTION("62F57D187DF5" , rn_sae().vcvtph2w(zmm6, zmm5)); + TEST_INSTRUCTION("62F57D4F7DB4F400000010" , k(k7).vcvtph2w(zmm6, zmmword_ptr(esp, esi, 3, 268435456))); + TEST_INSTRUCTION("62F57D587D31" , vcvtph2w(zmm6, word_ptr(ecx)._1to32())); + TEST_INSTRUCTION("62F57D487D717F" , vcvtph2w(zmm6, zmmword_ptr(ecx, 8128))); + TEST_INSTRUCTION("62F57DDF7D7280" , k(k7).z().vcvtph2w(zmm6, word_ptr(edx, -256)._1to32())); + TEST_INSTRUCTION("62F57D481DF5" , vcvtps2phx(ymm6, zmm5)); + TEST_INSTRUCTION("62F57D181DF5" , rn_sae().vcvtps2phx(ymm6, zmm5)); + TEST_INSTRUCTION("62F57D4F1DB4F400000010" , k(k7).vcvtps2phx(ymm6, zmmword_ptr(esp, esi, 3, 268435456))); + TEST_INSTRUCTION("62F57D581D31" , vcvtps2phx(ymm6, dword_ptr(ecx)._1to16())); + TEST_INSTRUCTION("62F57D481D717F" , vcvtps2phx(ymm6, zmmword_ptr(ecx, 8128))); + TEST_INSTRUCTION("62F57DDF1D7280" , k(k7).z().vcvtps2phx(ymm6, dword_ptr(edx, -512)._1to16())); + TEST_INSTRUCTION("62F5FC485BF5" , vcvtqq2ph(xmm6, zmm5)); + TEST_INSTRUCTION("62F5FC185BF5" , rn_sae().vcvtqq2ph(xmm6, zmm5)); + TEST_INSTRUCTION("62F5FC4F5BB4F400000010" , k(k7).vcvtqq2ph(xmm6, zmmword_ptr(esp, esi, 3, 268435456))); + TEST_INSTRUCTION("62F5FC585B31" , vcvtqq2ph(xmm6, qword_ptr(ecx)._1to8())); + TEST_INSTRUCTION("62F5FC485B717F" , vcvtqq2ph(xmm6, zmmword_ptr(ecx, 8128))); + TEST_INSTRUCTION("62F5FCDF5B7280" , k(k7).z().vcvtqq2ph(xmm6, qword_ptr(edx, -1024)._1to8())); + TEST_INSTRUCTION("62F5D7085AF4" , vcvtsd2sh(xmm6, xmm5, xmm4)); + TEST_INSTRUCTION("62F5D7185AF4" , rn_sae().vcvtsd2sh(xmm6, xmm5, xmm4)); + TEST_INSTRUCTION("62F5D70F5AB4F400000010" , k(k7).vcvtsd2sh(xmm6, xmm5, qword_ptr(esp, esi, 3, 268435456))); + TEST_INSTRUCTION("62F5D7085A31" , vcvtsd2sh(xmm6, xmm5, qword_ptr(ecx))); + TEST_INSTRUCTION("62F5D7085A717F" , vcvtsd2sh(xmm6, xmm5, qword_ptr(ecx, 1016))); + TEST_INSTRUCTION("62F5D78F5A7280" , k(k7).z().vcvtsd2sh(xmm6, xmm5, qword_ptr(edx, -1024))); + TEST_INSTRUCTION("62F556085AF4" , vcvtsh2sd(xmm6, xmm5, xmm4)); + TEST_INSTRUCTION("62F556185AF4" , sae().vcvtsh2sd(xmm6, xmm5, xmm4)); + TEST_INSTRUCTION("62F5560F5AB4F400000010" , k(k7).vcvtsh2sd(xmm6, xmm5, word_ptr(esp, esi, 3, 268435456))); + TEST_INSTRUCTION("62F556085A31" , vcvtsh2sd(xmm6, xmm5, word_ptr(ecx))); + TEST_INSTRUCTION("62F556085A717F" , vcvtsh2sd(xmm6, xmm5, word_ptr(ecx, 254))); + TEST_INSTRUCTION("62F5568F5A7280" , k(k7).z().vcvtsh2sd(xmm6, xmm5, word_ptr(edx, -256))); + TEST_INSTRUCTION("62F57E082DD6" , vcvtsh2si(edx, xmm6)); + TEST_INSTRUCTION("62F57E182DD6" , rn_sae().vcvtsh2si(edx, xmm6)); + TEST_INSTRUCTION("62F57E082D94F400000010" , vcvtsh2si(edx, word_ptr(esp, esi, 3, 268435456))); + TEST_INSTRUCTION("62F57E082D11" , vcvtsh2si(edx, word_ptr(ecx))); + TEST_INSTRUCTION("62F57E082D517F" , vcvtsh2si(edx, word_ptr(ecx, 254))); + TEST_INSTRUCTION("62F57E082D5280" , vcvtsh2si(edx, word_ptr(edx, -256))); + TEST_INSTRUCTION("62F6540813F4" , vcvtsh2ss(xmm6, xmm5, xmm4)); + TEST_INSTRUCTION("62F6541813F4" , sae().vcvtsh2ss(xmm6, xmm5, xmm4)); + TEST_INSTRUCTION("62F6540F13B4F400000010" , k(k7).vcvtsh2ss(xmm6, xmm5, word_ptr(esp, esi, 3, 268435456))); + TEST_INSTRUCTION("62F654081331" , vcvtsh2ss(xmm6, xmm5, word_ptr(ecx))); + TEST_INSTRUCTION("62F6540813717F" , vcvtsh2ss(xmm6, xmm5, word_ptr(ecx, 254))); + TEST_INSTRUCTION("62F6548F137280" , k(k7).z().vcvtsh2ss(xmm6, xmm5, word_ptr(edx, -256))); + TEST_INSTRUCTION("62F57E0879D6" , vcvtsh2usi(edx, xmm6)); + TEST_INSTRUCTION("62F57E1879D6" , rn_sae().vcvtsh2usi(edx, xmm6)); + TEST_INSTRUCTION("62F57E087994F400000010" , vcvtsh2usi(edx, word_ptr(esp, esi, 3, 268435456))); + TEST_INSTRUCTION("62F57E087911" , vcvtsh2usi(edx, word_ptr(ecx))); + TEST_INSTRUCTION("62F57E0879517F" , vcvtsh2usi(edx, word_ptr(ecx, 254))); + TEST_INSTRUCTION("62F57E08795280" , vcvtsh2usi(edx, word_ptr(edx, -256))); + TEST_INSTRUCTION("62F556082AF2" , vcvtsi2sh(xmm6, xmm5, edx)); + TEST_INSTRUCTION("62F556182AF2" , rn_sae().vcvtsi2sh(xmm6, xmm5, edx)); + TEST_INSTRUCTION("62F556082AB4F400000010" , vcvtsi2sh(xmm6, xmm5, dword_ptr(esp, esi, 3, 268435456))); + TEST_INSTRUCTION("62F556082A31" , vcvtsi2sh(xmm6, xmm5, dword_ptr(ecx))); + TEST_INSTRUCTION("62F556082A717F" , vcvtsi2sh(xmm6, xmm5, dword_ptr(ecx, 508))); + TEST_INSTRUCTION("62F556082A7280" , vcvtsi2sh(xmm6, xmm5, dword_ptr(edx, -512))); + TEST_INSTRUCTION("62F554081DF4" , vcvtss2sh(xmm6, xmm5, xmm4)); + TEST_INSTRUCTION("62F554181DF4" , rn_sae().vcvtss2sh(xmm6, xmm5, xmm4)); + TEST_INSTRUCTION("62F5540F1DB4F400000010" , k(k7).vcvtss2sh(xmm6, xmm5, dword_ptr(esp, esi, 3, 268435456))); + TEST_INSTRUCTION("62F554081D31" , vcvtss2sh(xmm6, xmm5, dword_ptr(ecx))); + TEST_INSTRUCTION("62F554081D717F" , vcvtss2sh(xmm6, xmm5, dword_ptr(ecx, 508))); + TEST_INSTRUCTION("62F5548F1D7280" , k(k7).z().vcvtss2sh(xmm6, xmm5, dword_ptr(edx, -512))); + TEST_INSTRUCTION("62F57E485BF5" , vcvttph2dq(zmm6, ymm5)); + TEST_INSTRUCTION("62F57E185BF5" , sae().vcvttph2dq(zmm6, ymm5)); + TEST_INSTRUCTION("62F57E4F5BB4F400000010" , k(k7).vcvttph2dq(zmm6, ymmword_ptr(esp, esi, 3, 268435456))); + TEST_INSTRUCTION("62F57E585B31" , vcvttph2dq(zmm6, word_ptr(ecx)._1to16())); + TEST_INSTRUCTION("62F57E485B717F" , vcvttph2dq(zmm6, ymmword_ptr(ecx, 4064))); + TEST_INSTRUCTION("62F57EDF5B7280" , k(k7).z().vcvttph2dq(zmm6, word_ptr(edx, -256)._1to16())); + TEST_INSTRUCTION("62F57D487AF5" , vcvttph2qq(zmm6, xmm5)); + TEST_INSTRUCTION("62F57D187AF5" , sae().vcvttph2qq(zmm6, xmm5)); + TEST_INSTRUCTION("62F57D4F7AB4F400000010" , k(k7).vcvttph2qq(zmm6, xmmword_ptr(esp, esi, 3, 268435456))); + TEST_INSTRUCTION("62F57D587A31" , vcvttph2qq(zmm6, word_ptr(ecx)._1to8())); + TEST_INSTRUCTION("62F57D487A717F" , vcvttph2qq(zmm6, xmmword_ptr(ecx, 2032))); + TEST_INSTRUCTION("62F57DDF7A7280" , k(k7).z().vcvttph2qq(zmm6, word_ptr(edx, -256)._1to8())); + TEST_INSTRUCTION("62F57C4878F5" , vcvttph2udq(zmm6, ymm5)); + TEST_INSTRUCTION("62F57C1878F5" , sae().vcvttph2udq(zmm6, ymm5)); + TEST_INSTRUCTION("62F57C4F78B4F400000010" , k(k7).vcvttph2udq(zmm6, ymmword_ptr(esp, esi, 3, 268435456))); + TEST_INSTRUCTION("62F57C587831" , vcvttph2udq(zmm6, word_ptr(ecx)._1to16())); + TEST_INSTRUCTION("62F57C4878717F" , vcvttph2udq(zmm6, ymmword_ptr(ecx, 4064))); + TEST_INSTRUCTION("62F57CDF787280" , k(k7).z().vcvttph2udq(zmm6, word_ptr(edx, -256)._1to16())); + TEST_INSTRUCTION("62F57D4878F5" , vcvttph2uqq(zmm6, xmm5)); + TEST_INSTRUCTION("62F57D1878F5" , sae().vcvttph2uqq(zmm6, xmm5)); + TEST_INSTRUCTION("62F57D4F78B4F400000010" , k(k7).vcvttph2uqq(zmm6, xmmword_ptr(esp, esi, 3, 268435456))); + TEST_INSTRUCTION("62F57D587831" , vcvttph2uqq(zmm6, word_ptr(ecx)._1to8())); + TEST_INSTRUCTION("62F57D4878717F" , vcvttph2uqq(zmm6, xmmword_ptr(ecx, 2032))); + TEST_INSTRUCTION("62F57DDF787280" , k(k7).z().vcvttph2uqq(zmm6, word_ptr(edx, -256)._1to8())); + TEST_INSTRUCTION("62F57C487CF5" , vcvttph2uw(zmm6, zmm5)); + TEST_INSTRUCTION("62F57C187CF5" , sae().vcvttph2uw(zmm6, zmm5)); + TEST_INSTRUCTION("62F57C4F7CB4F400000010" , k(k7).vcvttph2uw(zmm6, zmmword_ptr(esp, esi, 3, 268435456))); + TEST_INSTRUCTION("62F57C587C31" , vcvttph2uw(zmm6, word_ptr(ecx)._1to32())); + TEST_INSTRUCTION("62F57C487C717F" , vcvttph2uw(zmm6, zmmword_ptr(ecx, 8128))); + TEST_INSTRUCTION("62F57CDF7C7280" , k(k7).z().vcvttph2uw(zmm6, word_ptr(edx, -256)._1to32())); + TEST_INSTRUCTION("62F57D487CF5" , vcvttph2w(zmm6, zmm5)); + TEST_INSTRUCTION("62F57D187CF5" , sae().vcvttph2w(zmm6, zmm5)); + TEST_INSTRUCTION("62F57D4F7CB4F400000010" , k(k7).vcvttph2w(zmm6, zmmword_ptr(esp, esi, 3, 268435456))); + TEST_INSTRUCTION("62F57D587C31" , vcvttph2w(zmm6, word_ptr(ecx)._1to32())); + TEST_INSTRUCTION("62F57D487C717F" , vcvttph2w(zmm6, zmmword_ptr(ecx, 8128))); + TEST_INSTRUCTION("62F57DDF7C7280" , k(k7).z().vcvttph2w(zmm6, word_ptr(edx, -256)._1to32())); + TEST_INSTRUCTION("62F57E082CD6" , vcvttsh2si(edx, xmm6)); + TEST_INSTRUCTION("62F57E182CD6" , sae().vcvttsh2si(edx, xmm6)); + TEST_INSTRUCTION("62F57E082C94F400000010" , vcvttsh2si(edx, word_ptr(esp, esi, 3, 268435456))); + TEST_INSTRUCTION("62F57E082C11" , vcvttsh2si(edx, word_ptr(ecx))); + TEST_INSTRUCTION("62F57E082C517F" , vcvttsh2si(edx, word_ptr(ecx, 254))); + TEST_INSTRUCTION("62F57E082C5280" , vcvttsh2si(edx, word_ptr(edx, -256))); + TEST_INSTRUCTION("62F57E0878D6" , vcvttsh2usi(edx, xmm6)); + TEST_INSTRUCTION("62F57E1878D6" , sae().vcvttsh2usi(edx, xmm6)); + TEST_INSTRUCTION("62F57E087894F400000010" , vcvttsh2usi(edx, word_ptr(esp, esi, 3, 268435456))); + TEST_INSTRUCTION("62F57E087811" , vcvttsh2usi(edx, word_ptr(ecx))); + TEST_INSTRUCTION("62F57E0878517F" , vcvttsh2usi(edx, word_ptr(ecx, 254))); + TEST_INSTRUCTION("62F57E08785280" , vcvttsh2usi(edx, word_ptr(edx, -256))); + TEST_INSTRUCTION("62F57F487AF5" , vcvtudq2ph(ymm6, zmm5)); + TEST_INSTRUCTION("62F57F187AF5" , rn_sae().vcvtudq2ph(ymm6, zmm5)); + TEST_INSTRUCTION("62F57F4F7AB4F400000010" , k(k7).vcvtudq2ph(ymm6, zmmword_ptr(esp, esi, 3, 268435456))); + TEST_INSTRUCTION("62F57F587A31" , vcvtudq2ph(ymm6, dword_ptr(ecx)._1to16())); + TEST_INSTRUCTION("62F57F487A717F" , vcvtudq2ph(ymm6, zmmword_ptr(ecx, 8128))); + TEST_INSTRUCTION("62F57FDF7A7280" , k(k7).z().vcvtudq2ph(ymm6, dword_ptr(edx, -512)._1to16())); + TEST_INSTRUCTION("62F5FF487AF5" , vcvtuqq2ph(xmm6, zmm5)); + TEST_INSTRUCTION("62F5FF187AF5" , rn_sae().vcvtuqq2ph(xmm6, zmm5)); + TEST_INSTRUCTION("62F5FF4F7AB4F400000010" , k(k7).vcvtuqq2ph(xmm6, zmmword_ptr(esp, esi, 3, 268435456))); + TEST_INSTRUCTION("62F5FF587A31" , vcvtuqq2ph(xmm6, qword_ptr(ecx)._1to8())); + TEST_INSTRUCTION("62F5FF487A717F" , vcvtuqq2ph(xmm6, zmmword_ptr(ecx, 8128))); + TEST_INSTRUCTION("62F5FFDF7A7280" , k(k7).z().vcvtuqq2ph(xmm6, qword_ptr(edx, -1024)._1to8())); + TEST_INSTRUCTION("62F556087BF2" , vcvtusi2sh(xmm6, xmm5, edx)); + TEST_INSTRUCTION("62F556187BF2" , rn_sae().vcvtusi2sh(xmm6, xmm5, edx)); + TEST_INSTRUCTION("62F556087BB4F400000010" , vcvtusi2sh(xmm6, xmm5, dword_ptr(esp, esi, 3, 268435456))); + TEST_INSTRUCTION("62F556087B31" , vcvtusi2sh(xmm6, xmm5, dword_ptr(ecx))); + TEST_INSTRUCTION("62F556087B717F" , vcvtusi2sh(xmm6, xmm5, dword_ptr(ecx, 508))); + TEST_INSTRUCTION("62F556087B7280" , vcvtusi2sh(xmm6, xmm5, dword_ptr(edx, -512))); + TEST_INSTRUCTION("62F57F487DF5" , vcvtuw2ph(zmm6, zmm5)); + TEST_INSTRUCTION("62F57F187DF5" , rn_sae().vcvtuw2ph(zmm6, zmm5)); + TEST_INSTRUCTION("62F57F4F7DB4F400000010" , k(k7).vcvtuw2ph(zmm6, zmmword_ptr(esp, esi, 3, 268435456))); + TEST_INSTRUCTION("62F57F587D31" , vcvtuw2ph(zmm6, word_ptr(ecx)._1to32())); + TEST_INSTRUCTION("62F57F487D717F" , vcvtuw2ph(zmm6, zmmword_ptr(ecx, 8128))); + TEST_INSTRUCTION("62F57FDF7D7280" , k(k7).z().vcvtuw2ph(zmm6, word_ptr(edx, -256)._1to32())); + TEST_INSTRUCTION("62F57E487DF5" , vcvtw2ph(zmm6, zmm5)); + TEST_INSTRUCTION("62F57E187DF5" , rn_sae().vcvtw2ph(zmm6, zmm5)); + TEST_INSTRUCTION("62F57E4F7DB4F400000010" , k(k7).vcvtw2ph(zmm6, zmmword_ptr(esp, esi, 3, 268435456))); + TEST_INSTRUCTION("62F57E587D31" , vcvtw2ph(zmm6, word_ptr(ecx)._1to32())); + TEST_INSTRUCTION("62F57E487D717F" , vcvtw2ph(zmm6, zmmword_ptr(ecx, 8128))); + TEST_INSTRUCTION("62F57EDF7D7280" , k(k7).z().vcvtw2ph(zmm6, word_ptr(edx, -256)._1to32())); + TEST_INSTRUCTION("62F554485EF4" , vdivph(zmm6, zmm5, zmm4)); + TEST_INSTRUCTION("62F554185EF4" , rn_sae().vdivph(zmm6, zmm5, zmm4)); + TEST_INSTRUCTION("62F5544F5EB4F400000010" , k(k7).vdivph(zmm6, zmm5, zmmword_ptr(esp, esi, 3, 268435456))); + TEST_INSTRUCTION("62F554585E31" , vdivph(zmm6, zmm5, word_ptr(ecx)._1to32())); + TEST_INSTRUCTION("62F554485E717F" , vdivph(zmm6, zmm5, zmmword_ptr(ecx, 8128))); + TEST_INSTRUCTION("62F554DF5E7280" , k(k7).z().vdivph(zmm6, zmm5, word_ptr(edx, -256)._1to32())); + TEST_INSTRUCTION("62F556085EF4" , vdivsh(xmm6, xmm5, xmm4)); + TEST_INSTRUCTION("62F556185EF4" , rn_sae().vdivsh(xmm6, xmm5, xmm4)); + TEST_INSTRUCTION("62F5560F5EB4F400000010" , k(k7).vdivsh(xmm6, xmm5, word_ptr(esp, esi, 3, 268435456))); + TEST_INSTRUCTION("62F556085E31" , vdivsh(xmm6, xmm5, word_ptr(ecx))); + TEST_INSTRUCTION("62F556085E717F" , vdivsh(xmm6, xmm5, word_ptr(ecx, 254))); + TEST_INSTRUCTION("62F5568F5E7280" , k(k7).z().vdivsh(xmm6, xmm5, word_ptr(edx, -256))); + TEST_INSTRUCTION("62F554485FF4" , vmaxph(zmm6, zmm5, zmm4)); + TEST_INSTRUCTION("62F554185FF4" , sae().vmaxph(zmm6, zmm5, zmm4)); + TEST_INSTRUCTION("62F5544F5FB4F400000010" , k(k7).vmaxph(zmm6, zmm5, zmmword_ptr(esp, esi, 3, 268435456))); + TEST_INSTRUCTION("62F554585F31" , vmaxph(zmm6, zmm5, word_ptr(ecx)._1to32())); + TEST_INSTRUCTION("62F554485F717F" , vmaxph(zmm6, zmm5, zmmword_ptr(ecx, 8128))); + TEST_INSTRUCTION("62F554DF5F7280" , k(k7).z().vmaxph(zmm6, zmm5, word_ptr(edx, -256)._1to32())); + TEST_INSTRUCTION("62F556085FF4" , vmaxsh(xmm6, xmm5, xmm4)); + TEST_INSTRUCTION("62F556185FF4" , sae().vmaxsh(xmm6, xmm5, xmm4)); + TEST_INSTRUCTION("62F5560F5FB4F400000010" , k(k7).vmaxsh(xmm6, xmm5, word_ptr(esp, esi, 3, 268435456))); + TEST_INSTRUCTION("62F556085F31" , vmaxsh(xmm6, xmm5, word_ptr(ecx))); + TEST_INSTRUCTION("62F556085F717F" , vmaxsh(xmm6, xmm5, word_ptr(ecx, 254))); + TEST_INSTRUCTION("62F5568F5F7280" , k(k7).z().vmaxsh(xmm6, xmm5, word_ptr(edx, -256))); + TEST_INSTRUCTION("62F554485DF4" , vminph(zmm6, zmm5, zmm4)); + TEST_INSTRUCTION("62F554185DF4" , sae().vminph(zmm6, zmm5, zmm4)); + TEST_INSTRUCTION("62F5544F5DB4F400000010" , k(k7).vminph(zmm6, zmm5, zmmword_ptr(esp, esi, 3, 268435456))); + TEST_INSTRUCTION("62F554585D31" , vminph(zmm6, zmm5, word_ptr(ecx)._1to32())); + TEST_INSTRUCTION("62F554485D717F" , vminph(zmm6, zmm5, zmmword_ptr(ecx, 8128))); + TEST_INSTRUCTION("62F554DF5D7280" , k(k7).z().vminph(zmm6, zmm5, word_ptr(edx, -256)._1to32())); + TEST_INSTRUCTION("62F556085DF4" , vminsh(xmm6, xmm5, xmm4)); + TEST_INSTRUCTION("62F556185DF4" , sae().vminsh(xmm6, xmm5, xmm4)); + TEST_INSTRUCTION("62F5560F5DB4F400000010" , k(k7).vminsh(xmm6, xmm5, word_ptr(esp, esi, 3, 268435456))); + TEST_INSTRUCTION("62F556085D31" , vminsh(xmm6, xmm5, word_ptr(ecx))); + TEST_INSTRUCTION("62F556085D717F" , vminsh(xmm6, xmm5, word_ptr(ecx, 254))); + TEST_INSTRUCTION("62F5568F5D7280" , k(k7).z().vminsh(xmm6, xmm5, word_ptr(edx, -256))); + TEST_INSTRUCTION("62F5544859F4" , vmulph(zmm6, zmm5, zmm4)); + TEST_INSTRUCTION("62F5541859F4" , rn_sae().vmulph(zmm6, zmm5, zmm4)); + TEST_INSTRUCTION("62F5544F59B4F400000010" , k(k7).vmulph(zmm6, zmm5, zmmword_ptr(esp, esi, 3, 268435456))); + TEST_INSTRUCTION("62F554585931" , vmulph(zmm6, zmm5, word_ptr(ecx)._1to32())); + TEST_INSTRUCTION("62F5544859717F" , vmulph(zmm6, zmm5, zmmword_ptr(ecx, 8128))); + TEST_INSTRUCTION("62F554DF597280" , k(k7).z().vmulph(zmm6, zmm5, word_ptr(edx, -256)._1to32())); + TEST_INSTRUCTION("62F5560859F4" , vmulsh(xmm6, xmm5, xmm4)); + TEST_INSTRUCTION("62F5561859F4" , rn_sae().vmulsh(xmm6, xmm5, xmm4)); + TEST_INSTRUCTION("62F5560F59B4F400000010" , k(k7).vmulsh(xmm6, xmm5, word_ptr(esp, esi, 3, 268435456))); + TEST_INSTRUCTION("62F556085931" , vmulsh(xmm6, xmm5, word_ptr(ecx))); + TEST_INSTRUCTION("62F5560859717F" , vmulsh(xmm6, xmm5, word_ptr(ecx, 254))); + TEST_INSTRUCTION("62F5568F597280" , k(k7).z().vmulsh(xmm6, xmm5, word_ptr(edx, -256))); + TEST_INSTRUCTION("62F554485CF4" , vsubph(zmm6, zmm5, zmm4)); + TEST_INSTRUCTION("62F554185CF4" , rn_sae().vsubph(zmm6, zmm5, zmm4)); + TEST_INSTRUCTION("62F5544F5CB4F400000010" , k(k7).vsubph(zmm6, zmm5, zmmword_ptr(esp, esi, 3, 268435456))); + TEST_INSTRUCTION("62F554585C31" , vsubph(zmm6, zmm5, word_ptr(ecx)._1to32())); + TEST_INSTRUCTION("62F554485C717F" , vsubph(zmm6, zmm5, zmmword_ptr(ecx, 8128))); + TEST_INSTRUCTION("62F554DF5C7280" , k(k7).z().vsubph(zmm6, zmm5, word_ptr(edx, -256)._1to32())); + TEST_INSTRUCTION("62F556085CF4" , vsubsh(xmm6, xmm5, xmm4)); + TEST_INSTRUCTION("62F556185CF4" , rn_sae().vsubsh(xmm6, xmm5, xmm4)); + TEST_INSTRUCTION("62F5560F5CB4F400000010" , k(k7).vsubsh(xmm6, xmm5, word_ptr(esp, esi, 3, 268435456))); + TEST_INSTRUCTION("62F556085C31" , vsubsh(xmm6, xmm5, word_ptr(ecx))); + TEST_INSTRUCTION("62F556085C717F" , vsubsh(xmm6, xmm5, word_ptr(ecx, 254))); + TEST_INSTRUCTION("62F5568F5C7280" , k(k7).z().vsubsh(xmm6, xmm5, word_ptr(edx, -256))); + TEST_INSTRUCTION("62F57C082EF5" , vucomish(xmm6, xmm5)); + TEST_INSTRUCTION("62F57C182EF5" , sae().vucomish(xmm6, xmm5)); + TEST_INSTRUCTION("62F57C082EB4F400000010" , vucomish(xmm6, word_ptr(esp, esi, 3, 268435456))); + TEST_INSTRUCTION("62F57C082E31" , vucomish(xmm6, word_ptr(ecx))); + TEST_INSTRUCTION("62F57C082E717F" , vucomish(xmm6, word_ptr(ecx, 254))); + TEST_INSTRUCTION("62F57C082E7280" , vucomish(xmm6, word_ptr(edx, -256))); + TEST_INSTRUCTION("62F37C4866EE7B" , vfpclassph(k5, zmm6, 123)); + TEST_INSTRUCTION("62F37C4F66ACF4000000107B" , k(k7).vfpclassph(k5, zmmword_ptr(esp, esi, 3, 268435456), 123)); + TEST_INSTRUCTION("62F37C5866297B" , vfpclassph(k5, word_ptr(ecx)._1to32(), 123)); + TEST_INSTRUCTION("62F37C4866697F7B" , vfpclassph(k5, zmmword_ptr(ecx, 8128), 123)); + TEST_INSTRUCTION("62F37C5F666A807B" , k(k7).vfpclassph(k5, word_ptr(edx, -256)._1to32(), 123)); + TEST_INSTRUCTION("62F37C0867EE7B" , vfpclasssh(k5, xmm6, 123)); + TEST_INSTRUCTION("62F37C0F67ACF4000000107B" , k(k7).vfpclasssh(k5, word_ptr(esp, esi, 3, 268435456), 123)); + TEST_INSTRUCTION("62F37C0867297B" , vfpclasssh(k5, word_ptr(ecx), 123)); + TEST_INSTRUCTION("62F37C0867697F7B" , vfpclasssh(k5, word_ptr(ecx, 254), 123)); + TEST_INSTRUCTION("62F37C0F676A807B" , k(k7).vfpclasssh(k5, word_ptr(edx, -256), 123)); + TEST_INSTRUCTION("62F67D4842F5" , vgetexpph(zmm6, zmm5)); + TEST_INSTRUCTION("62F67D1842F5" , sae().vgetexpph(zmm6, zmm5)); + TEST_INSTRUCTION("62F67D4F42B4F400000010" , k(k7).vgetexpph(zmm6, zmmword_ptr(esp, esi, 3, 268435456))); + TEST_INSTRUCTION("62F67D584231" , vgetexpph(zmm6, word_ptr(ecx)._1to32())); + TEST_INSTRUCTION("62F67D4842717F" , vgetexpph(zmm6, zmmword_ptr(ecx, 8128))); + TEST_INSTRUCTION("62F67DDF427280" , k(k7).z().vgetexpph(zmm6, word_ptr(edx, -256)._1to32())); + TEST_INSTRUCTION("62F6550843F4" , vgetexpsh(xmm6, xmm5, xmm4)); + TEST_INSTRUCTION("62F6551843F4" , sae().vgetexpsh(xmm6, xmm5, xmm4)); + TEST_INSTRUCTION("62F6550F43B4F400000010" , k(k7).vgetexpsh(xmm6, xmm5, word_ptr(esp, esi, 3, 268435456))); + TEST_INSTRUCTION("62F655084331" , vgetexpsh(xmm6, xmm5, word_ptr(ecx))); + TEST_INSTRUCTION("62F6550843717F" , vgetexpsh(xmm6, xmm5, word_ptr(ecx, 254))); + TEST_INSTRUCTION("62F6558F437280" , k(k7).z().vgetexpsh(xmm6, xmm5, word_ptr(edx, -256))); + TEST_INSTRUCTION("62F37C4826F57B" , vgetmantph(zmm6, zmm5, 123)); + TEST_INSTRUCTION("62F37C1826F57B" , sae().vgetmantph(zmm6, zmm5, 123)); + TEST_INSTRUCTION("62F37C4F26B4F4000000107B" , k(k7).vgetmantph(zmm6, zmmword_ptr(esp, esi, 3, 268435456), 123)); + TEST_INSTRUCTION("62F37C5826317B" , vgetmantph(zmm6, word_ptr(ecx)._1to32(), 123)); + TEST_INSTRUCTION("62F37C4826717F7B" , vgetmantph(zmm6, zmmword_ptr(ecx, 8128), 123)); + TEST_INSTRUCTION("62F37CDF2672807B" , k(k7).z().vgetmantph(zmm6, word_ptr(edx, -256)._1to32(), 123)); + TEST_INSTRUCTION("62F3540827F47B" , vgetmantsh(xmm6, xmm5, xmm4, 123)); + TEST_INSTRUCTION("62F3541827F47B" , sae().vgetmantsh(xmm6, xmm5, xmm4, 123)); + TEST_INSTRUCTION("62F3540F27B4F4000000107B" , k(k7).vgetmantsh(xmm6, xmm5, word_ptr(esp, esi, 3, 268435456), 123)); + TEST_INSTRUCTION("62F3540827317B" , vgetmantsh(xmm6, xmm5, word_ptr(ecx), 123)); + TEST_INSTRUCTION("62F3540827717F7B" , vgetmantsh(xmm6, xmm5, word_ptr(ecx, 254), 123)); + TEST_INSTRUCTION("62F3548F2772807B" , k(k7).z().vgetmantsh(xmm6, xmm5, word_ptr(edx, -256), 123)); + TEST_INSTRUCTION("62F67D484CF5" , vrcpph(zmm6, zmm5)); + TEST_INSTRUCTION("62F67D4F4CB4F400000010" , k(k7).vrcpph(zmm6, zmmword_ptr(esp, esi, 3, 268435456))); + TEST_INSTRUCTION("62F67D584C31" , vrcpph(zmm6, word_ptr(ecx)._1to32())); + TEST_INSTRUCTION("62F67D484C717F" , vrcpph(zmm6, zmmword_ptr(ecx, 8128))); + TEST_INSTRUCTION("62F67DDF4C7280" , k(k7).z().vrcpph(zmm6, word_ptr(edx, -256)._1to32())); + TEST_INSTRUCTION("62F655084DF4" , vrcpsh(xmm6, xmm5, xmm4)); + TEST_INSTRUCTION("62F6550F4DB4F400000010" , k(k7).vrcpsh(xmm6, xmm5, word_ptr(esp, esi, 3, 268435456))); + TEST_INSTRUCTION("62F655084D31" , vrcpsh(xmm6, xmm5, word_ptr(ecx))); + TEST_INSTRUCTION("62F655084D717F" , vrcpsh(xmm6, xmm5, word_ptr(ecx, 254))); + TEST_INSTRUCTION("62F6558F4D7280" , k(k7).z().vrcpsh(xmm6, xmm5, word_ptr(edx, -256))); + TEST_INSTRUCTION("62F37C4856F57B" , vreduceph(zmm6, zmm5, 123)); + TEST_INSTRUCTION("62F37C1856F57B" , sae().vreduceph(zmm6, zmm5, 123)); + TEST_INSTRUCTION("62F37C4F56B4F4000000107B" , k(k7).vreduceph(zmm6, zmmword_ptr(esp, esi, 3, 268435456), 123)); + TEST_INSTRUCTION("62F37C5856317B" , vreduceph(zmm6, word_ptr(ecx)._1to32(), 123)); + TEST_INSTRUCTION("62F37C4856717F7B" , vreduceph(zmm6, zmmword_ptr(ecx, 8128), 123)); + TEST_INSTRUCTION("62F37CDF5672807B" , k(k7).z().vreduceph(zmm6, word_ptr(edx, -256)._1to32(), 123)); + TEST_INSTRUCTION("62F3540857F47B" , vreducesh(xmm6, xmm5, xmm4, 123)); + TEST_INSTRUCTION("62F3541857F47B" , sae().vreducesh(xmm6, xmm5, xmm4, 123)); + TEST_INSTRUCTION("62F3540F57B4F4000000107B" , k(k7).vreducesh(xmm6, xmm5, word_ptr(esp, esi, 3, 268435456), 123)); + TEST_INSTRUCTION("62F3540857317B" , vreducesh(xmm6, xmm5, word_ptr(ecx), 123)); + TEST_INSTRUCTION("62F3540857717F7B" , vreducesh(xmm6, xmm5, word_ptr(ecx, 254), 123)); + TEST_INSTRUCTION("62F3548F5772807B" , k(k7).z().vreducesh(xmm6, xmm5, word_ptr(edx, -256), 123)); + TEST_INSTRUCTION("62F37C4808F57B" , vrndscaleph(zmm6, zmm5, 123)); + TEST_INSTRUCTION("62F37C1808F57B" , sae().vrndscaleph(zmm6, zmm5, 123)); + TEST_INSTRUCTION("62F37C4F08B4F4000000107B" , k(k7).vrndscaleph(zmm6, zmmword_ptr(esp, esi, 3, 268435456), 123)); + TEST_INSTRUCTION("62F37C5808317B" , vrndscaleph(zmm6, word_ptr(ecx)._1to32(), 123)); + TEST_INSTRUCTION("62F37C4808717F7B" , vrndscaleph(zmm6, zmmword_ptr(ecx, 8128), 123)); + TEST_INSTRUCTION("62F37CDF0872807B" , k(k7).z().vrndscaleph(zmm6, word_ptr(edx, -256)._1to32(), 123)); + TEST_INSTRUCTION("62F354080AF47B" , vrndscalesh(xmm6, xmm5, xmm4, 123)); + TEST_INSTRUCTION("62F354180AF47B" , sae().vrndscalesh(xmm6, xmm5, xmm4, 123)); + TEST_INSTRUCTION("62F3540F0AB4F4000000107B" , k(k7).vrndscalesh(xmm6, xmm5, word_ptr(esp, esi, 3, 268435456), 123)); + TEST_INSTRUCTION("62F354080A317B" , vrndscalesh(xmm6, xmm5, word_ptr(ecx), 123)); + TEST_INSTRUCTION("62F354080A717F7B" , vrndscalesh(xmm6, xmm5, word_ptr(ecx, 254), 123)); + TEST_INSTRUCTION("62F3548F0A72807B" , k(k7).z().vrndscalesh(xmm6, xmm5, word_ptr(edx, -256), 123)); + TEST_INSTRUCTION("62F67D484EF5" , vrsqrtph(zmm6, zmm5)); + TEST_INSTRUCTION("62F67D4F4EB4F400000010" , k(k7).vrsqrtph(zmm6, zmmword_ptr(esp, esi, 3, 268435456))); + TEST_INSTRUCTION("62F67D584E31" , vrsqrtph(zmm6, word_ptr(ecx)._1to32())); + TEST_INSTRUCTION("62F67D484E717F" , vrsqrtph(zmm6, zmmword_ptr(ecx, 8128))); + TEST_INSTRUCTION("62F67DDF4E7280" , k(k7).z().vrsqrtph(zmm6, word_ptr(edx, -256)._1to32())); + TEST_INSTRUCTION("62F655084FF4" , vrsqrtsh(xmm6, xmm5, xmm4)); + TEST_INSTRUCTION("62F6550F4FB4F400000010" , k(k7).vrsqrtsh(xmm6, xmm5, word_ptr(esp, esi, 3, 268435456))); + TEST_INSTRUCTION("62F655084F31" , vrsqrtsh(xmm6, xmm5, word_ptr(ecx))); + TEST_INSTRUCTION("62F655084F717F" , vrsqrtsh(xmm6, xmm5, word_ptr(ecx, 254))); + TEST_INSTRUCTION("62F6558F4F7280" , k(k7).z().vrsqrtsh(xmm6, xmm5, word_ptr(edx, -256))); + TEST_INSTRUCTION("62F655482CF4" , vscalefph(zmm6, zmm5, zmm4)); + TEST_INSTRUCTION("62F655182CF4" , rn_sae().vscalefph(zmm6, zmm5, zmm4)); + TEST_INSTRUCTION("62F6554F2CB4F400000010" , k(k7).vscalefph(zmm6, zmm5, zmmword_ptr(esp, esi, 3, 268435456))); + TEST_INSTRUCTION("62F655582C31" , vscalefph(zmm6, zmm5, word_ptr(ecx)._1to32())); + TEST_INSTRUCTION("62F655482C717F" , vscalefph(zmm6, zmm5, zmmword_ptr(ecx, 8128))); + TEST_INSTRUCTION("62F655DF2C7280" , k(k7).z().vscalefph(zmm6, zmm5, word_ptr(edx, -256)._1to32())); + TEST_INSTRUCTION("62F655082DF4" , vscalefsh(xmm6, xmm5, xmm4)); + TEST_INSTRUCTION("62F655182DF4" , rn_sae().vscalefsh(xmm6, xmm5, xmm4)); + TEST_INSTRUCTION("62F6550F2DB4F400000010" , k(k7).vscalefsh(xmm6, xmm5, word_ptr(esp, esi, 3, 268435456))); + TEST_INSTRUCTION("62F655082D31" , vscalefsh(xmm6, xmm5, word_ptr(ecx))); + TEST_INSTRUCTION("62F655082D717F" , vscalefsh(xmm6, xmm5, word_ptr(ecx, 254))); + TEST_INSTRUCTION("62F6558F2D7280" , k(k7).z().vscalefsh(xmm6, xmm5, word_ptr(edx, -256))); + TEST_INSTRUCTION("62F57C4851F5" , vsqrtph(zmm6, zmm5)); + TEST_INSTRUCTION("62F57C1851F5" , rn_sae().vsqrtph(zmm6, zmm5)); + TEST_INSTRUCTION("62F57C4F51B4F400000010" , k(k7).vsqrtph(zmm6, zmmword_ptr(esp, esi, 3, 268435456))); + TEST_INSTRUCTION("62F57C585131" , vsqrtph(zmm6, word_ptr(ecx)._1to32())); + TEST_INSTRUCTION("62F57C4851717F" , vsqrtph(zmm6, zmmword_ptr(ecx, 8128))); + TEST_INSTRUCTION("62F57CDF517280" , k(k7).z().vsqrtph(zmm6, word_ptr(edx, -256)._1to32())); + TEST_INSTRUCTION("62F5560851F4" , vsqrtsh(xmm6, xmm5, xmm4)); + TEST_INSTRUCTION("62F5561851F4" , rn_sae().vsqrtsh(xmm6, xmm5, xmm4)); + TEST_INSTRUCTION("62F5560F51B4F400000010" , k(k7).vsqrtsh(xmm6, xmm5, word_ptr(esp, esi, 3, 268435456))); + TEST_INSTRUCTION("62F556085131" , vsqrtsh(xmm6, xmm5, word_ptr(ecx))); + TEST_INSTRUCTION("62F5560851717F" , vsqrtsh(xmm6, xmm5, word_ptr(ecx, 254))); + TEST_INSTRUCTION("62F5568F517280" , k(k7).z().vsqrtsh(xmm6, xmm5, word_ptr(edx, -256))); + TEST_INSTRUCTION("62F6554898F4" , vfmadd132ph(zmm6, zmm5, zmm4)); + TEST_INSTRUCTION("62F6551898F4" , rn_sae().vfmadd132ph(zmm6, zmm5, zmm4)); + TEST_INSTRUCTION("62F6554F98B4F400000010" , k(k7).vfmadd132ph(zmm6, zmm5, zmmword_ptr(esp, esi, 3, 268435456))); + TEST_INSTRUCTION("62F655589831" , vfmadd132ph(zmm6, zmm5, word_ptr(ecx)._1to32())); + TEST_INSTRUCTION("62F6554898717F" , vfmadd132ph(zmm6, zmm5, zmmword_ptr(ecx, 8128))); + TEST_INSTRUCTION("62F655DF987280" , k(k7).z().vfmadd132ph(zmm6, zmm5, word_ptr(edx, -256)._1to32())); + TEST_INSTRUCTION("62F6550899F4" , vfmadd132sh(xmm6, xmm5, xmm4)); + TEST_INSTRUCTION("62F6551899F4" , rn_sae().vfmadd132sh(xmm6, xmm5, xmm4)); + TEST_INSTRUCTION("62F6550F99B4F400000010" , k(k7).vfmadd132sh(xmm6, xmm5, word_ptr(esp, esi, 3, 268435456))); + TEST_INSTRUCTION("62F655089931" , vfmadd132sh(xmm6, xmm5, word_ptr(ecx))); + TEST_INSTRUCTION("62F6550899717F" , vfmadd132sh(xmm6, xmm5, word_ptr(ecx, 254))); + TEST_INSTRUCTION("62F6558F997280" , k(k7).z().vfmadd132sh(xmm6, xmm5, word_ptr(edx, -256))); + TEST_INSTRUCTION("62F65548A8F4" , vfmadd213ph(zmm6, zmm5, zmm4)); + TEST_INSTRUCTION("62F65518A8F4" , rn_sae().vfmadd213ph(zmm6, zmm5, zmm4)); + TEST_INSTRUCTION("62F6554FA8B4F400000010" , k(k7).vfmadd213ph(zmm6, zmm5, zmmword_ptr(esp, esi, 3, 268435456))); + TEST_INSTRUCTION("62F65558A831" , vfmadd213ph(zmm6, zmm5, word_ptr(ecx)._1to32())); + TEST_INSTRUCTION("62F65548A8717F" , vfmadd213ph(zmm6, zmm5, zmmword_ptr(ecx, 8128))); + TEST_INSTRUCTION("62F655DFA87280" , k(k7).z().vfmadd213ph(zmm6, zmm5, word_ptr(edx, -256)._1to32())); + TEST_INSTRUCTION("62F65508A9F4" , vfmadd213sh(xmm6, xmm5, xmm4)); + TEST_INSTRUCTION("62F65518A9F4" , rn_sae().vfmadd213sh(xmm6, xmm5, xmm4)); + TEST_INSTRUCTION("62F6550FA9B4F400000010" , k(k7).vfmadd213sh(xmm6, xmm5, word_ptr(esp, esi, 3, 268435456))); + TEST_INSTRUCTION("62F65508A931" , vfmadd213sh(xmm6, xmm5, word_ptr(ecx))); + TEST_INSTRUCTION("62F65508A9717F" , vfmadd213sh(xmm6, xmm5, word_ptr(ecx, 254))); + TEST_INSTRUCTION("62F6558FA97280" , k(k7).z().vfmadd213sh(xmm6, xmm5, word_ptr(edx, -256))); + TEST_INSTRUCTION("62F65548B8F4" , vfmadd231ph(zmm6, zmm5, zmm4)); + TEST_INSTRUCTION("62F65518B8F4" , rn_sae().vfmadd231ph(zmm6, zmm5, zmm4)); + TEST_INSTRUCTION("62F6554FB8B4F400000010" , k(k7).vfmadd231ph(zmm6, zmm5, zmmword_ptr(esp, esi, 3, 268435456))); + TEST_INSTRUCTION("62F65558B831" , vfmadd231ph(zmm6, zmm5, word_ptr(ecx)._1to32())); + TEST_INSTRUCTION("62F65548B8717F" , vfmadd231ph(zmm6, zmm5, zmmword_ptr(ecx, 8128))); + TEST_INSTRUCTION("62F655DFB87280" , k(k7).z().vfmadd231ph(zmm6, zmm5, word_ptr(edx, -256)._1to32())); + TEST_INSTRUCTION("62F65508B9F4" , vfmadd231sh(xmm6, xmm5, xmm4)); + TEST_INSTRUCTION("62F65518B9F4" , rn_sae().vfmadd231sh(xmm6, xmm5, xmm4)); + TEST_INSTRUCTION("62F6550FB9B4F400000010" , k(k7).vfmadd231sh(xmm6, xmm5, word_ptr(esp, esi, 3, 268435456))); + TEST_INSTRUCTION("62F65508B931" , vfmadd231sh(xmm6, xmm5, word_ptr(ecx))); + TEST_INSTRUCTION("62F65508B9717F" , vfmadd231sh(xmm6, xmm5, word_ptr(ecx, 254))); + TEST_INSTRUCTION("62F6558FB97280" , k(k7).z().vfmadd231sh(xmm6, xmm5, word_ptr(edx, -256))); + TEST_INSTRUCTION("62F6554896F4" , vfmaddsub132ph(zmm6, zmm5, zmm4)); + TEST_INSTRUCTION("62F6551896F4" , rn_sae().vfmaddsub132ph(zmm6, zmm5, zmm4)); + TEST_INSTRUCTION("62F6554F96B4F400000010" , k(k7).vfmaddsub132ph(zmm6, zmm5, zmmword_ptr(esp, esi, 3, 268435456))); + TEST_INSTRUCTION("62F655589631" , vfmaddsub132ph(zmm6, zmm5, word_ptr(ecx)._1to32())); + TEST_INSTRUCTION("62F6554896717F" , vfmaddsub132ph(zmm6, zmm5, zmmword_ptr(ecx, 8128))); + TEST_INSTRUCTION("62F655DF967280" , k(k7).z().vfmaddsub132ph(zmm6, zmm5, word_ptr(edx, -256)._1to32())); + TEST_INSTRUCTION("62F65548A6F4" , vfmaddsub213ph(zmm6, zmm5, zmm4)); + TEST_INSTRUCTION("62F65518A6F4" , rn_sae().vfmaddsub213ph(zmm6, zmm5, zmm4)); + TEST_INSTRUCTION("62F6554FA6B4F400000010" , k(k7).vfmaddsub213ph(zmm6, zmm5, zmmword_ptr(esp, esi, 3, 268435456))); + TEST_INSTRUCTION("62F65558A631" , vfmaddsub213ph(zmm6, zmm5, word_ptr(ecx)._1to32())); + TEST_INSTRUCTION("62F65548A6717F" , vfmaddsub213ph(zmm6, zmm5, zmmword_ptr(ecx, 8128))); + TEST_INSTRUCTION("62F655DFA67280" , k(k7).z().vfmaddsub213ph(zmm6, zmm5, word_ptr(edx, -256)._1to32())); + TEST_INSTRUCTION("62F65548B6F4" , vfmaddsub231ph(zmm6, zmm5, zmm4)); + TEST_INSTRUCTION("62F65518B6F4" , rn_sae().vfmaddsub231ph(zmm6, zmm5, zmm4)); + TEST_INSTRUCTION("62F6554FB6B4F400000010" , k(k7).vfmaddsub231ph(zmm6, zmm5, zmmword_ptr(esp, esi, 3, 268435456))); + TEST_INSTRUCTION("62F65558B631" , vfmaddsub231ph(zmm6, zmm5, word_ptr(ecx)._1to32())); + TEST_INSTRUCTION("62F65548B6717F" , vfmaddsub231ph(zmm6, zmm5, zmmword_ptr(ecx, 8128))); + TEST_INSTRUCTION("62F655DFB67280" , k(k7).z().vfmaddsub231ph(zmm6, zmm5, word_ptr(edx, -256)._1to32())); + TEST_INSTRUCTION("62F655489AF4" , vfmsub132ph(zmm6, zmm5, zmm4)); + TEST_INSTRUCTION("62F655189AF4" , rn_sae().vfmsub132ph(zmm6, zmm5, zmm4)); + TEST_INSTRUCTION("62F6554F9AB4F400000010" , k(k7).vfmsub132ph(zmm6, zmm5, zmmword_ptr(esp, esi, 3, 268435456))); + TEST_INSTRUCTION("62F655589A31" , vfmsub132ph(zmm6, zmm5, word_ptr(ecx)._1to32())); + TEST_INSTRUCTION("62F655489A717F" , vfmsub132ph(zmm6, zmm5, zmmword_ptr(ecx, 8128))); + TEST_INSTRUCTION("62F655DF9A7280" , k(k7).z().vfmsub132ph(zmm6, zmm5, word_ptr(edx, -256)._1to32())); + TEST_INSTRUCTION("62F655089BF4" , vfmsub132sh(xmm6, xmm5, xmm4)); + TEST_INSTRUCTION("62F655189BF4" , rn_sae().vfmsub132sh(xmm6, xmm5, xmm4)); + TEST_INSTRUCTION("62F6550F9BB4F400000010" , k(k7).vfmsub132sh(xmm6, xmm5, word_ptr(esp, esi, 3, 268435456))); + TEST_INSTRUCTION("62F655089B31" , vfmsub132sh(xmm6, xmm5, word_ptr(ecx))); + TEST_INSTRUCTION("62F655089B717F" , vfmsub132sh(xmm6, xmm5, word_ptr(ecx, 254))); + TEST_INSTRUCTION("62F6558F9B7280" , k(k7).z().vfmsub132sh(xmm6, xmm5, word_ptr(edx, -256))); + TEST_INSTRUCTION("62F65548AAF4" , vfmsub213ph(zmm6, zmm5, zmm4)); + TEST_INSTRUCTION("62F65518AAF4" , rn_sae().vfmsub213ph(zmm6, zmm5, zmm4)); + TEST_INSTRUCTION("62F6554FAAB4F400000010" , k(k7).vfmsub213ph(zmm6, zmm5, zmmword_ptr(esp, esi, 3, 268435456))); + TEST_INSTRUCTION("62F65558AA31" , vfmsub213ph(zmm6, zmm5, word_ptr(ecx)._1to32())); + TEST_INSTRUCTION("62F65548AA717F" , vfmsub213ph(zmm6, zmm5, zmmword_ptr(ecx, 8128))); + TEST_INSTRUCTION("62F655DFAA7280" , k(k7).z().vfmsub213ph(zmm6, zmm5, word_ptr(edx, -256)._1to32())); + TEST_INSTRUCTION("62F65508ABF4" , vfmsub213sh(xmm6, xmm5, xmm4)); + TEST_INSTRUCTION("62F65518ABF4" , rn_sae().vfmsub213sh(xmm6, xmm5, xmm4)); + TEST_INSTRUCTION("62F6550FABB4F400000010" , k(k7).vfmsub213sh(xmm6, xmm5, word_ptr(esp, esi, 3, 268435456))); + TEST_INSTRUCTION("62F65508AB31" , vfmsub213sh(xmm6, xmm5, word_ptr(ecx))); + TEST_INSTRUCTION("62F65508AB717F" , vfmsub213sh(xmm6, xmm5, word_ptr(ecx, 254))); + TEST_INSTRUCTION("62F6558FAB7280" , k(k7).z().vfmsub213sh(xmm6, xmm5, word_ptr(edx, -256))); + TEST_INSTRUCTION("62F65548BAF4" , vfmsub231ph(zmm6, zmm5, zmm4)); + TEST_INSTRUCTION("62F65518BAF4" , rn_sae().vfmsub231ph(zmm6, zmm5, zmm4)); + TEST_INSTRUCTION("62F6554FBAB4F400000010" , k(k7).vfmsub231ph(zmm6, zmm5, zmmword_ptr(esp, esi, 3, 268435456))); + TEST_INSTRUCTION("62F65558BA31" , vfmsub231ph(zmm6, zmm5, word_ptr(ecx)._1to32())); + TEST_INSTRUCTION("62F65548BA717F" , vfmsub231ph(zmm6, zmm5, zmmword_ptr(ecx, 8128))); + TEST_INSTRUCTION("62F655DFBA7280" , k(k7).z().vfmsub231ph(zmm6, zmm5, word_ptr(edx, -256)._1to32())); + TEST_INSTRUCTION("62F65508BBF4" , vfmsub231sh(xmm6, xmm5, xmm4)); + TEST_INSTRUCTION("62F65518BBF4" , rn_sae().vfmsub231sh(xmm6, xmm5, xmm4)); + TEST_INSTRUCTION("62F6550FBBB4F400000010" , k(k7).vfmsub231sh(xmm6, xmm5, word_ptr(esp, esi, 3, 268435456))); + TEST_INSTRUCTION("62F65508BB31" , vfmsub231sh(xmm6, xmm5, word_ptr(ecx))); + TEST_INSTRUCTION("62F65508BB717F" , vfmsub231sh(xmm6, xmm5, word_ptr(ecx, 254))); + TEST_INSTRUCTION("62F6558FBB7280" , k(k7).z().vfmsub231sh(xmm6, xmm5, word_ptr(edx, -256))); + TEST_INSTRUCTION("62F6554897F4" , vfmsubadd132ph(zmm6, zmm5, zmm4)); + TEST_INSTRUCTION("62F6551897F4" , rn_sae().vfmsubadd132ph(zmm6, zmm5, zmm4)); + TEST_INSTRUCTION("62F6554F97B4F400000010" , k(k7).vfmsubadd132ph(zmm6, zmm5, zmmword_ptr(esp, esi, 3, 268435456))); + TEST_INSTRUCTION("62F655589731" , vfmsubadd132ph(zmm6, zmm5, word_ptr(ecx)._1to32())); + TEST_INSTRUCTION("62F6554897717F" , vfmsubadd132ph(zmm6, zmm5, zmmword_ptr(ecx, 8128))); + TEST_INSTRUCTION("62F655DF977280" , k(k7).z().vfmsubadd132ph(zmm6, zmm5, word_ptr(edx, -256)._1to32())); + TEST_INSTRUCTION("62F65548A7F4" , vfmsubadd213ph(zmm6, zmm5, zmm4)); + TEST_INSTRUCTION("62F65518A7F4" , rn_sae().vfmsubadd213ph(zmm6, zmm5, zmm4)); + TEST_INSTRUCTION("62F6554FA7B4F400000010" , k(k7).vfmsubadd213ph(zmm6, zmm5, zmmword_ptr(esp, esi, 3, 268435456))); + TEST_INSTRUCTION("62F65558A731" , vfmsubadd213ph(zmm6, zmm5, word_ptr(ecx)._1to32())); + TEST_INSTRUCTION("62F65548A7717F" , vfmsubadd213ph(zmm6, zmm5, zmmword_ptr(ecx, 8128))); + TEST_INSTRUCTION("62F655DFA77280" , k(k7).z().vfmsubadd213ph(zmm6, zmm5, word_ptr(edx, -256)._1to32())); + TEST_INSTRUCTION("62F65548B7F4" , vfmsubadd231ph(zmm6, zmm5, zmm4)); + TEST_INSTRUCTION("62F65518B7F4" , rn_sae().vfmsubadd231ph(zmm6, zmm5, zmm4)); + TEST_INSTRUCTION("62F6554FB7B4F400000010" , k(k7).vfmsubadd231ph(zmm6, zmm5, zmmword_ptr(esp, esi, 3, 268435456))); + TEST_INSTRUCTION("62F65558B731" , vfmsubadd231ph(zmm6, zmm5, word_ptr(ecx)._1to32())); + TEST_INSTRUCTION("62F65548B7717F" , vfmsubadd231ph(zmm6, zmm5, zmmword_ptr(ecx, 8128))); + TEST_INSTRUCTION("62F655DFB77280" , k(k7).z().vfmsubadd231ph(zmm6, zmm5, word_ptr(edx, -256)._1to32())); + TEST_INSTRUCTION("62F655489CF4" , vfnmadd132ph(zmm6, zmm5, zmm4)); + TEST_INSTRUCTION("62F655189CF4" , rn_sae().vfnmadd132ph(zmm6, zmm5, zmm4)); + TEST_INSTRUCTION("62F6554F9CB4F400000010" , k(k7).vfnmadd132ph(zmm6, zmm5, zmmword_ptr(esp, esi, 3, 268435456))); + TEST_INSTRUCTION("62F655589C31" , vfnmadd132ph(zmm6, zmm5, word_ptr(ecx)._1to32())); + TEST_INSTRUCTION("62F655489C717F" , vfnmadd132ph(zmm6, zmm5, zmmword_ptr(ecx, 8128))); + TEST_INSTRUCTION("62F655DF9C7280" , k(k7).z().vfnmadd132ph(zmm6, zmm5, word_ptr(edx, -256)._1to32())); + TEST_INSTRUCTION("62F655089DF4" , vfnmadd132sh(xmm6, xmm5, xmm4)); + TEST_INSTRUCTION("62F655189DF4" , rn_sae().vfnmadd132sh(xmm6, xmm5, xmm4)); + TEST_INSTRUCTION("62F6550F9DB4F400000010" , k(k7).vfnmadd132sh(xmm6, xmm5, word_ptr(esp, esi, 3, 268435456))); + TEST_INSTRUCTION("62F655089D31" , vfnmadd132sh(xmm6, xmm5, word_ptr(ecx))); + TEST_INSTRUCTION("62F655089D717F" , vfnmadd132sh(xmm6, xmm5, word_ptr(ecx, 254))); + TEST_INSTRUCTION("62F6558F9D7280" , k(k7).z().vfnmadd132sh(xmm6, xmm5, word_ptr(edx, -256))); + TEST_INSTRUCTION("62F65548ACF4" , vfnmadd213ph(zmm6, zmm5, zmm4)); + TEST_INSTRUCTION("62F65518ACF4" , rn_sae().vfnmadd213ph(zmm6, zmm5, zmm4)); + TEST_INSTRUCTION("62F6554FACB4F400000010" , k(k7).vfnmadd213ph(zmm6, zmm5, zmmword_ptr(esp, esi, 3, 268435456))); + TEST_INSTRUCTION("62F65558AC31" , vfnmadd213ph(zmm6, zmm5, word_ptr(ecx)._1to32())); + TEST_INSTRUCTION("62F65548AC717F" , vfnmadd213ph(zmm6, zmm5, zmmword_ptr(ecx, 8128))); + TEST_INSTRUCTION("62F655DFAC7280" , k(k7).z().vfnmadd213ph(zmm6, zmm5, word_ptr(edx, -256)._1to32())); + TEST_INSTRUCTION("62F65508ADF4" , vfnmadd213sh(xmm6, xmm5, xmm4)); + TEST_INSTRUCTION("62F65518ADF4" , rn_sae().vfnmadd213sh(xmm6, xmm5, xmm4)); + TEST_INSTRUCTION("62F6550FADB4F400000010" , k(k7).vfnmadd213sh(xmm6, xmm5, word_ptr(esp, esi, 3, 268435456))); + TEST_INSTRUCTION("62F65508AD31" , vfnmadd213sh(xmm6, xmm5, word_ptr(ecx))); + TEST_INSTRUCTION("62F65508AD717F" , vfnmadd213sh(xmm6, xmm5, word_ptr(ecx, 254))); + TEST_INSTRUCTION("62F6558FAD7280" , k(k7).z().vfnmadd213sh(xmm6, xmm5, word_ptr(edx, -256))); + TEST_INSTRUCTION("62F65548BCF4" , vfnmadd231ph(zmm6, zmm5, zmm4)); + TEST_INSTRUCTION("62F65518BCF4" , rn_sae().vfnmadd231ph(zmm6, zmm5, zmm4)); + TEST_INSTRUCTION("62F6554FBCB4F400000010" , k(k7).vfnmadd231ph(zmm6, zmm5, zmmword_ptr(esp, esi, 3, 268435456))); + TEST_INSTRUCTION("62F65558BC31" , vfnmadd231ph(zmm6, zmm5, word_ptr(ecx)._1to32())); + TEST_INSTRUCTION("62F65548BC717F" , vfnmadd231ph(zmm6, zmm5, zmmword_ptr(ecx, 8128))); + TEST_INSTRUCTION("62F655DFBC7280" , k(k7).z().vfnmadd231ph(zmm6, zmm5, word_ptr(edx, -256)._1to32())); + TEST_INSTRUCTION("62F65508BDF4" , vfnmadd231sh(xmm6, xmm5, xmm4)); + TEST_INSTRUCTION("62F65518BDF4" , rn_sae().vfnmadd231sh(xmm6, xmm5, xmm4)); + TEST_INSTRUCTION("62F6550FBDB4F400000010" , k(k7).vfnmadd231sh(xmm6, xmm5, word_ptr(esp, esi, 3, 268435456))); + TEST_INSTRUCTION("62F65508BD31" , vfnmadd231sh(xmm6, xmm5, word_ptr(ecx))); + TEST_INSTRUCTION("62F65508BD717F" , vfnmadd231sh(xmm6, xmm5, word_ptr(ecx, 254))); + TEST_INSTRUCTION("62F6558FBD7280" , k(k7).z().vfnmadd231sh(xmm6, xmm5, word_ptr(edx, -256))); + TEST_INSTRUCTION("62F655489EF4" , vfnmsub132ph(zmm6, zmm5, zmm4)); + TEST_INSTRUCTION("62F655189EF4" , rn_sae().vfnmsub132ph(zmm6, zmm5, zmm4)); + TEST_INSTRUCTION("62F6554F9EB4F400000010" , k(k7).vfnmsub132ph(zmm6, zmm5, zmmword_ptr(esp, esi, 3, 268435456))); + TEST_INSTRUCTION("62F655589E31" , vfnmsub132ph(zmm6, zmm5, word_ptr(ecx)._1to32())); + TEST_INSTRUCTION("62F655489E717F" , vfnmsub132ph(zmm6, zmm5, zmmword_ptr(ecx, 8128))); + TEST_INSTRUCTION("62F655DF9E7280" , k(k7).z().vfnmsub132ph(zmm6, zmm5, word_ptr(edx, -256)._1to32())); + TEST_INSTRUCTION("62F655089FF4" , vfnmsub132sh(xmm6, xmm5, xmm4)); + TEST_INSTRUCTION("62F655189FF4" , rn_sae().vfnmsub132sh(xmm6, xmm5, xmm4)); + TEST_INSTRUCTION("62F6550F9FB4F400000010" , k(k7).vfnmsub132sh(xmm6, xmm5, word_ptr(esp, esi, 3, 268435456))); + TEST_INSTRUCTION("62F655089F31" , vfnmsub132sh(xmm6, xmm5, word_ptr(ecx))); + TEST_INSTRUCTION("62F655089F717F" , vfnmsub132sh(xmm6, xmm5, word_ptr(ecx, 254))); + TEST_INSTRUCTION("62F6558F9F7280" , k(k7).z().vfnmsub132sh(xmm6, xmm5, word_ptr(edx, -256))); + TEST_INSTRUCTION("62F65548AEF4" , vfnmsub213ph(zmm6, zmm5, zmm4)); + TEST_INSTRUCTION("62F65518AEF4" , rn_sae().vfnmsub213ph(zmm6, zmm5, zmm4)); + TEST_INSTRUCTION("62F6554FAEB4F400000010" , k(k7).vfnmsub213ph(zmm6, zmm5, zmmword_ptr(esp, esi, 3, 268435456))); + TEST_INSTRUCTION("62F65558AE31" , vfnmsub213ph(zmm6, zmm5, word_ptr(ecx)._1to32())); + TEST_INSTRUCTION("62F65548AE717F" , vfnmsub213ph(zmm6, zmm5, zmmword_ptr(ecx, 8128))); + TEST_INSTRUCTION("62F655DFAE7280" , k(k7).z().vfnmsub213ph(zmm6, zmm5, word_ptr(edx, -256)._1to32())); + TEST_INSTRUCTION("62F65508AFF4" , vfnmsub213sh(xmm6, xmm5, xmm4)); + TEST_INSTRUCTION("62F65518AFF4" , rn_sae().vfnmsub213sh(xmm6, xmm5, xmm4)); + TEST_INSTRUCTION("62F6550FAFB4F400000010" , k(k7).vfnmsub213sh(xmm6, xmm5, word_ptr(esp, esi, 3, 268435456))); + TEST_INSTRUCTION("62F65508AF31" , vfnmsub213sh(xmm6, xmm5, word_ptr(ecx))); + TEST_INSTRUCTION("62F65508AF717F" , vfnmsub213sh(xmm6, xmm5, word_ptr(ecx, 254))); + TEST_INSTRUCTION("62F6558FAF7280" , k(k7).z().vfnmsub213sh(xmm6, xmm5, word_ptr(edx, -256))); + TEST_INSTRUCTION("62F65548BEF4" , vfnmsub231ph(zmm6, zmm5, zmm4)); + TEST_INSTRUCTION("62F65518BEF4" , rn_sae().vfnmsub231ph(zmm6, zmm5, zmm4)); + TEST_INSTRUCTION("62F6554FBEB4F400000010" , k(k7).vfnmsub231ph(zmm6, zmm5, zmmword_ptr(esp, esi, 3, 268435456))); + TEST_INSTRUCTION("62F65558BE31" , vfnmsub231ph(zmm6, zmm5, word_ptr(ecx)._1to32())); + TEST_INSTRUCTION("62F65548BE717F" , vfnmsub231ph(zmm6, zmm5, zmmword_ptr(ecx, 8128))); + TEST_INSTRUCTION("62F655DFBE7280" , k(k7).z().vfnmsub231ph(zmm6, zmm5, word_ptr(edx, -256)._1to32())); + TEST_INSTRUCTION("62F65508BFF4" , vfnmsub231sh(xmm6, xmm5, xmm4)); + TEST_INSTRUCTION("62F65518BFF4" , rn_sae().vfnmsub231sh(xmm6, xmm5, xmm4)); + TEST_INSTRUCTION("62F6550FBFB4F400000010" , k(k7).vfnmsub231sh(xmm6, xmm5, word_ptr(esp, esi, 3, 268435456))); + TEST_INSTRUCTION("62F65508BF31" , vfnmsub231sh(xmm6, xmm5, word_ptr(ecx))); + TEST_INSTRUCTION("62F65508BF717F" , vfnmsub231sh(xmm6, xmm5, word_ptr(ecx, 254))); + TEST_INSTRUCTION("62F6558FBF7280" , k(k7).z().vfnmsub231sh(xmm6, xmm5, word_ptr(edx, -256))); + TEST_INSTRUCTION("62F6574856F4" , vfcmaddcph(zmm6, zmm5, zmm4)); + TEST_INSTRUCTION("62F6571856F4" , rn_sae().vfcmaddcph(zmm6, zmm5, zmm4)); + TEST_INSTRUCTION("62F6574F56B4F400000010" , k(k7).vfcmaddcph(zmm6, zmm5, zmmword_ptr(esp, esi, 3, 268435456))); + TEST_INSTRUCTION("62F657585631" , vfcmaddcph(zmm6, zmm5, dword_ptr(ecx)._1to16())); + TEST_INSTRUCTION("62F6574856717F" , vfcmaddcph(zmm6, zmm5, zmmword_ptr(ecx, 8128))); + TEST_INSTRUCTION("62F657DF567280" , k(k7).z().vfcmaddcph(zmm6, zmm5, dword_ptr(edx, -512)._1to16())); + TEST_INSTRUCTION("62F6570857F4" , vfcmaddcsh(xmm6, xmm5, xmm4)); + TEST_INSTRUCTION("62F6571857F4" , rn_sae().vfcmaddcsh(xmm6, xmm5, xmm4)); + TEST_INSTRUCTION("62F6570F57B4F400000010" , k(k7).vfcmaddcsh(xmm6, xmm5, dword_ptr(esp, esi, 3, 268435456))); + TEST_INSTRUCTION("62F657085731" , vfcmaddcsh(xmm6, xmm5, dword_ptr(ecx))); + TEST_INSTRUCTION("62F6570857717F" , vfcmaddcsh(xmm6, xmm5, dword_ptr(ecx, 508))); + TEST_INSTRUCTION("62F6578F577280" , k(k7).z().vfcmaddcsh(xmm6, xmm5, dword_ptr(edx, -512))); + TEST_INSTRUCTION("62F65748D6F4" , vfcmulcph(zmm6, zmm5, zmm4)); + TEST_INSTRUCTION("62F65718D6F4" , rn_sae().vfcmulcph(zmm6, zmm5, zmm4)); + TEST_INSTRUCTION("62F6574FD6B4F400000010" , k(k7).vfcmulcph(zmm6, zmm5, zmmword_ptr(esp, esi, 3, 268435456))); + TEST_INSTRUCTION("62F65758D631" , vfcmulcph(zmm6, zmm5, dword_ptr(ecx)._1to16())); + TEST_INSTRUCTION("62F65748D6717F" , vfcmulcph(zmm6, zmm5, zmmword_ptr(ecx, 8128))); + TEST_INSTRUCTION("62F657DFD67280" , k(k7).z().vfcmulcph(zmm6, zmm5, dword_ptr(edx, -512)._1to16())); + TEST_INSTRUCTION("62F65708D7F4" , vfcmulcsh(xmm6, xmm5, xmm4)); + TEST_INSTRUCTION("62F65718D7F4" , rn_sae().vfcmulcsh(xmm6, xmm5, xmm4)); + TEST_INSTRUCTION("62F6570FD7B4F400000010" , k(k7).vfcmulcsh(xmm6, xmm5, dword_ptr(esp, esi, 3, 268435456))); + TEST_INSTRUCTION("62F65708D731" , vfcmulcsh(xmm6, xmm5, dword_ptr(ecx))); + TEST_INSTRUCTION("62F65708D7717F" , vfcmulcsh(xmm6, xmm5, dword_ptr(ecx, 508))); + TEST_INSTRUCTION("62F6578FD77280" , k(k7).z().vfcmulcsh(xmm6, xmm5, dword_ptr(edx, -512))); + TEST_INSTRUCTION("62F6564856F4" , vfmaddcph(zmm6, zmm5, zmm4)); + TEST_INSTRUCTION("62F6561856F4" , rn_sae().vfmaddcph(zmm6, zmm5, zmm4)); + TEST_INSTRUCTION("62F6564F56B4F400000010" , k(k7).vfmaddcph(zmm6, zmm5, zmmword_ptr(esp, esi, 3, 268435456))); + TEST_INSTRUCTION("62F656585631" , vfmaddcph(zmm6, zmm5, dword_ptr(ecx)._1to16())); + TEST_INSTRUCTION("62F6564856717F" , vfmaddcph(zmm6, zmm5, zmmword_ptr(ecx, 8128))); + TEST_INSTRUCTION("62F656DF567280" , k(k7).z().vfmaddcph(zmm6, zmm5, dword_ptr(edx, -512)._1to16())); + TEST_INSTRUCTION("62F6560857F4" , vfmaddcsh(xmm6, xmm5, xmm4)); + TEST_INSTRUCTION("62F6561857F4" , rn_sae().vfmaddcsh(xmm6, xmm5, xmm4)); + TEST_INSTRUCTION("62F6560F57B4F400000010" , k(k7).vfmaddcsh(xmm6, xmm5, dword_ptr(esp, esi, 3, 268435456))); + TEST_INSTRUCTION("62F656085731" , vfmaddcsh(xmm6, xmm5, dword_ptr(ecx))); + TEST_INSTRUCTION("62F6560857717F" , vfmaddcsh(xmm6, xmm5, dword_ptr(ecx, 508))); + TEST_INSTRUCTION("62F6568F577280" , k(k7).z().vfmaddcsh(xmm6, xmm5, dword_ptr(edx, -512))); + TEST_INSTRUCTION("62F65648D6F4" , vfmulcph(zmm6, zmm5, zmm4)); + TEST_INSTRUCTION("62F65618D6F4" , rn_sae().vfmulcph(zmm6, zmm5, zmm4)); + TEST_INSTRUCTION("62F6564FD6B4F400000010" , k(k7).vfmulcph(zmm6, zmm5, zmmword_ptr(esp, esi, 3, 268435456))); + TEST_INSTRUCTION("62F65658D631" , vfmulcph(zmm6, zmm5, dword_ptr(ecx)._1to16())); + TEST_INSTRUCTION("62F65648D6717F" , vfmulcph(zmm6, zmm5, zmmword_ptr(ecx, 8128))); + TEST_INSTRUCTION("62F656DFD67280" , k(k7).z().vfmulcph(zmm6, zmm5, dword_ptr(edx, -512)._1to16())); + TEST_INSTRUCTION("62F65608D7F4" , vfmulcsh(xmm6, xmm5, xmm4)); + TEST_INSTRUCTION("62F65618D7F4" , rn_sae().vfmulcsh(xmm6, xmm5, xmm4)); + TEST_INSTRUCTION("62F6560FD7B4F400000010" , k(k7).vfmulcsh(xmm6, xmm5, dword_ptr(esp, esi, 3, 268435456))); + TEST_INSTRUCTION("62F65608D731" , vfmulcsh(xmm6, xmm5, dword_ptr(ecx))); + TEST_INSTRUCTION("62F65608D7717F" , vfmulcsh(xmm6, xmm5, dword_ptr(ecx, 508))); + TEST_INSTRUCTION("62F6568FD77280" , k(k7).z().vfmulcsh(xmm6, xmm5, dword_ptr(edx, -512))); +} + +static void ASMJIT_NOINLINE testX86AssemblerExtras(AssemblerTester<x86::Assembler>& tester) noexcept { + using namespace x86; + + // Extended X86 tests. + TEST_INSTRUCTION("66050201" , add(ax, 0x0102)); + TEST_INSTRUCTION("6603849004030201" , add(ax, ptr(eax, edx, 2, 0x01020304))); + TEST_INSTRUCTION("0504030201" , add(eax, 0x01020304)); + TEST_INSTRUCTION("67668D00" , lea(ax, ptr(bx, si))); + TEST_INSTRUCTION("67668D01" , lea(ax, ptr(bx, di))); + TEST_INSTRUCTION("67668D02" , lea(ax, ptr(bp, si))); + TEST_INSTRUCTION("67668D03" , lea(ax, ptr(bp, di))); + TEST_INSTRUCTION("67668D04" , lea(ax, ptr(si))); + TEST_INSTRUCTION("67668D05" , lea(ax, ptr(di))); + TEST_INSTRUCTION("67668D4600" , lea(ax, ptr(bp))); + TEST_INSTRUCTION("67668D07" , lea(ax, ptr(bx))); + TEST_INSTRUCTION("67668D4010" , lea(ax, ptr(bx, si, 0, 0x10))); + TEST_INSTRUCTION("67668D4120" , lea(ax, ptr(bx, di, 0, 0x20))); + TEST_INSTRUCTION("67668D4240" , lea(ax, ptr(bp, si, 0, 0x40))); + TEST_INSTRUCTION("67668D4360" , lea(ax, ptr(bp, di, 0, 0x60))); + TEST_INSTRUCTION("67668D848000" , lea(ax, ptr(si, 0x80))); + TEST_INSTRUCTION("67668D85A000" , lea(ax, ptr(di, 0xA0))); + TEST_INSTRUCTION("67668D86C000" , lea(ax, ptr(bp, 0xC0))); + TEST_INSTRUCTION("67668D87FF01" , lea(ax, ptr(bx, 0x01FF))); + TEST_INSTRUCTION("678D00" , lea(eax, ptr(bx, si))); + TEST_INSTRUCTION("678D01" , lea(eax, ptr(bx, di))); + TEST_INSTRUCTION("8D0433" , lea(eax, ptr(ebx, esi))); + TEST_INSTRUCTION("8D043B" , lea(eax, ptr(ebx, edi))); + TEST_INSTRUCTION("8D0500000000" , lea(eax, ptr(0))); + TEST_INSTRUCTION("B8FFFFFFFF" , mov(eax, 0xFFFFFFFF)); + TEST_INSTRUCTION("8B10" , mov(edx, ptr(eax))); + TEST_INSTRUCTION("8B10" , mov(edx, ptr(eax, 0))); + TEST_INSTRUCTION("8B9080000000" , mov(edx, ptr(eax, 128))); + TEST_INSTRUCTION("8B1408" , mov(edx, ptr(eax, ecx))); + TEST_INSTRUCTION("8B940880000000" , mov(edx, ptr(eax, ecx, 0, 128))); + TEST_INSTRUCTION("8B1408" , mov(edx, ptr(eax, ecx))); + TEST_INSTRUCTION("8B544820" , mov(edx, ptr(eax, ecx, 1, 32))); + TEST_INSTRUCTION("8B548840" , mov(edx, ptr(eax, ecx, 2, 64))); + TEST_INSTRUCTION("8B94C800010000" , mov(edx, ptr(eax, ecx, 3, 128 + 128))); + TEST_INSTRUCTION("8B1408" , mov(edx, ptr(eax, ecx))); + TEST_INSTRUCTION("8B940880000000" , mov(edx, ptr(eax, ecx, 0, 128))); + TEST_INSTRUCTION("8B1408" , mov(edx, ptr(eax, ecx))); + TEST_INSTRUCTION("8B544820" , mov(edx, ptr(eax, ecx, 1, 32))); + TEST_INSTRUCTION("8B54C802" , mov(edx, ptr(eax, ecx, 3, 2))); + TEST_INSTRUCTION("0F20C0" , mov(eax, cr0)); + TEST_INSTRUCTION("F00F20C0" , mov(eax, cr8)); + TEST_INSTRUCTION("A344332211" , mov(ptr(0x11223344), eax)); + TEST_INSTRUCTION("890544332211" , mod_mr().mov(ptr(0x11223344), eax)); + TEST_INSTRUCTION("891D44332211" , mov(ptr(0x11223344), ebx)); + TEST_INSTRUCTION("0FBE07" , movsx(eax, byte_ptr(edi))); + TEST_INSTRUCTION("0FBF07" , movsx(eax, word_ptr(edi))); + TEST_INSTRUCTION("0FB607" , movzx(eax, byte_ptr(edi))); + TEST_INSTRUCTION("0FB6C6" , movzx(eax, dh)); + TEST_INSTRUCTION("0FB707" , movzx(eax, word_ptr(edi))); + TEST_INSTRUCTION("0F95C3" , setnz(bl)); + TEST_INSTRUCTION("0F94C7" , setz(bh)); + TEST_INSTRUCTION("F600FF" , test(byte_ptr(eax), 0xFF)); + TEST_INSTRUCTION("66F700FF00" , test(word_ptr(eax), 0xFF)); + TEST_INSTRUCTION("F700FF000000" , test(dword_ptr(eax), 0xFF)); + TEST_INSTRUCTION("A836" , test(al, 0x36)); + TEST_INSTRUCTION("F6C436" , test(ah, 0x36)); + TEST_INSTRUCTION("50" , push(eax)); + TEST_INSTRUCTION("51" , push(ecx)); + TEST_INSTRUCTION("52" , push(edx)); + TEST_INSTRUCTION("53" , push(ebx)); + TEST_INSTRUCTION("54" , push(esp)); + TEST_INSTRUCTION("55" , push(ebp)); + TEST_INSTRUCTION("56" , push(esi)); + TEST_INSTRUCTION("57" , push(edi)); + TEST_INSTRUCTION("0E" , push(cs)); + TEST_INSTRUCTION("16" , push(ss)); + TEST_INSTRUCTION("1E" , push(ds)); + TEST_INSTRUCTION("06" , push(es)); + TEST_INSTRUCTION("0FA0" , push(fs)); + TEST_INSTRUCTION("0FA8" , push(gs)); + TEST_INSTRUCTION("C8010002" , enter(1, 2)); + TEST_INSTRUCTION("FF10" , call(ptr(eax))); + TEST_INSTRUCTION("FF10" , call(dword_ptr(eax))); + TEST_INSTRUCTION("6690" , xchg(ax, ax)); + TEST_INSTRUCTION("90" , xchg(eax, eax)); + + TEST_INSTRUCTION("F00118" , lock().add(ptr(eax), ebx)); + TEST_INSTRUCTION("F00FC138" , lock().xadd(ptr(eax), edi)); + TEST_INSTRUCTION("F2F00108" , xacquire().lock().add(dword_ptr(eax), ecx)); + TEST_INSTRUCTION("F3F00108" , xrelease().lock().add(dword_ptr(eax), ecx)); + + // MOD RM & MR tests. + TEST_INSTRUCTION("01CB" , mod_mr().add(ebx, ecx)); + TEST_INSTRUCTION("03D9" , mod_rm().add(ebx, ecx)); + TEST_INSTRUCTION("88C4" , mod_mr().mov(ah, al)); + TEST_INSTRUCTION("88C6" , mod_mr().mov(dh, al)); + TEST_INSTRUCTION("89D8" , mod_mr().mov(eax, ebx)); + TEST_INSTRUCTION("8AE0" , mod_rm().mov(ah, al)); + TEST_INSTRUCTION("8AF0" , mod_rm().mov(dh, al)); + TEST_INSTRUCTION("8BC3" , mod_rm().mov(eax, ebx)); + + // FPU. + TEST_INSTRUCTION("9B" , fwait()); + TEST_INSTRUCTION("D800" , fadd(dword_ptr(eax))); + TEST_INSTRUCTION("DC00" , fadd(qword_ptr(eax))); + + // AVX & AVX512. + TEST_INSTRUCTION("62F17D086EC0" , evex().vmovd(xmm0, eax)); + TEST_INSTRUCTION("62F17D087EC0" , evex().vmovd(eax, xmm0)); + TEST_INSTRUCTION("62F1F5D95800" , k(k1).z().vaddpd(zmm0, zmm1, ptr(eax)._1to8())); + TEST_INSTRUCTION("62F1748858C2" , z().vaddps(xmm0, xmm1, xmm2)); + TEST_INSTRUCTION("62F1748958C2" , k(k1).z().vaddps(xmm0, xmm1, xmm2)); + TEST_INSTRUCTION("62F16C4FC25498040F" , k(k7).vcmpps(k2, zmm2, zmmword_ptr(eax, ebx, 2, 256), 15)); + TEST_INSTRUCTION("62F16C5FC25498400F" , k(k7).vcmpps(k2, zmm2, dword_ptr(eax, ebx, 2, 256)._1to16(), 15)); + TEST_INSTRUCTION("C4E2F990040500000000" , vpgatherdq(xmm0, ptr(0, xmm0), xmm0)); + TEST_INSTRUCTION("C4E2FD91040500000000" , vpgatherqq(ymm0, ptr(0, ymm0), ymm0)); + TEST_INSTRUCTION("C4E2E9920C00" , vgatherdpd(xmm1, ptr(eax, xmm0), xmm2)); + TEST_INSTRUCTION("62F26D48CF4C1101" , vgf2p8mulb(zmm1, zmm2, zmmword_ptr(ecx, edx, 0, 64))); + TEST_INSTRUCTION("62F3ED48CE4C11010F" , vgf2p8affineqb(zmm1, zmm2, zmmword_ptr(ecx, edx, 0, 64), 15)); + TEST_INSTRUCTION("62F3ED48CF4C11010F" , vgf2p8affineinvqb(zmm1, zmm2, zmmword_ptr(ecx, edx, 0, 64), 15)); + TEST_INSTRUCTION("62F2674868246D00F8FFFF" , vp2intersectd(k4, k5, zmm3, zmmword_ptr(0xFFFFF800, ebp, 1))); + + // AVX_VNNI & AVX512_VNNI. + TEST_INSTRUCTION("C4E25550F4" , vex().vpdpbusd(ymm6, ymm5, ymm4)); + TEST_INSTRUCTION("62F2552850F4" , vpdpbusd(ymm6, ymm5, ymm4)); +} + +bool testX86Assembler(const TestSettings& settings) noexcept { + using namespace x86; + + AssemblerTester<Assembler> tester(Arch::kX86, settings); + tester.printHeader("X86"); + + testX86AssemblerBase(tester); + testX86AssemblerMMX_SSE(tester); + testX86AssemblerAVX(tester); + testX86AssemblerAVX512_FP16(tester); + testX86AssemblerExtras(tester); + + tester.printSummary(); + return tester.didPass(); +} + +#undef TEST_INSTRUCTION + +#endif // !ASMJIT_NO_X86 diff --git a/3rdparty/asmjit/test/asmjit_test_compiler.cpp b/3rdparty/asmjit/test/asmjit_test_compiler.cpp new file mode 100644 index 00000000000..f2bc306c6df --- /dev/null +++ b/3rdparty/asmjit/test/asmjit_test_compiler.cpp @@ -0,0 +1,253 @@ +// This file is part of AsmJit project <https://asmjit.com> +// +// See asmjit.h or LICENSE.md for license and copyright information +// SPDX-License-Identifier: Zlib + +#include <asmjit/core.h> + +#include <stdio.h> +#include <stdlib.h> +#include <string.h> + +#include <memory> +#include <vector> +#include <chrono> + +#include "cmdline.h" +#include "asmjitutils.h" +#include "performancetimer.h" + +#include "asmjit_test_compiler.h" + +#if !defined(ASMJIT_NO_X86) && ASMJIT_ARCH_X86 +#include <asmjit/x86.h> +void compiler_add_x86_tests(TestApp& app); +#endif + +#if !defined(ASMJIT_NO_AARCH64) && ASMJIT_ARCH_ARM == 64 +#include <asmjit/a64.h> +void compiler_add_a64_tests(TestApp& app); +#endif + +#if !defined(ASMJIT_NO_X86) && ASMJIT_ARCH_X86 + #define ASMJIT_HAVE_WORKING_JIT +#endif + +#if !defined(ASMJIT_NO_AARCH64) && ASMJIT_ARCH_ARM == 64 + #define ASMJIT_HAVE_WORKING_JIT +#endif + +using namespace asmjit; + +int TestApp::handleArgs(int argc, const char* const* argv) { + CmdLine cmd(argc, argv); + + if (cmd.hasArg("--verbose")) _verbose = true; + if (cmd.hasArg("--dump-asm")) _dumpAsm = true; + if (cmd.hasArg("--dump-hex")) _dumpHex = true; + + return 0; +} + +void TestApp::showInfo() { + printf("AsmJit Compiler Test-Suite v%u.%u.%u (Arch=%s):\n", + unsigned((ASMJIT_LIBRARY_VERSION >> 16) ), + unsigned((ASMJIT_LIBRARY_VERSION >> 8) & 0xFF), + unsigned((ASMJIT_LIBRARY_VERSION ) & 0xFF), + asmjitArchAsString(Arch::kHost)); + printf(" [%s] Verbose (use --verbose to turn verbose output ON)\n", _verbose ? "x" : " "); + printf(" [%s] DumpAsm (use --dump-asm to turn assembler dumps ON)\n", _dumpAsm ? "x" : " "); + printf(" [%s] DumpHex (use --dump-hex to dump binary in hexadecimal)\n", _dumpHex ? "x" : " "); + printf("\n"); +} + +int TestApp::run() { +#ifndef ASMJIT_HAVE_WORKING_JIT + return 0; +#else +#ifndef ASMJIT_NO_LOGGING + FormatOptions formatOptions; + formatOptions.addFlags( + FormatFlags::kMachineCode | + FormatFlags::kExplainImms | + FormatFlags::kRegCasts ); + + FileLogger fileLogger(stdout); + fileLogger.setOptions(formatOptions); + + StringLogger stringLogger; + stringLogger.setOptions(formatOptions); +#endif + + JitRuntime runtime; + + PerformanceTimer compileTimer; + PerformanceTimer finalizeTimer; + double compileTime = 0; + double finalizeTime = 0; + + for (std::unique_ptr<TestCase>& test : _tests) { + for (uint32_t pass = 0; pass < 2; pass++) { + CodeHolder code; + SimpleErrorHandler errorHandler; + + code.init(runtime.environment()); + code.setErrorHandler(&errorHandler); + + if (pass != 0) { +#ifndef ASMJIT_NO_LOGGING + if (_verbose) { + code.setLogger(&fileLogger); + } + else { + stringLogger.clear(); + code.setLogger(&stringLogger); + } +#endif + + printf("[Test] %s", test->name()); + +#ifndef ASMJIT_NO_LOGGING + if (_verbose) + printf("\n"); +#endif + } + + +#if !defined(ASMJIT_NO_X86) && ASMJIT_ARCH_X86 + x86::Compiler cc(&code); +#endif + +#if !defined(ASMJIT_NO_AARCH64) && ASMJIT_ARCH_ARM == 64 + a64::Compiler cc(&code); +#endif + +#ifndef ASMJIT_NO_LOGGING + cc.addDiagnosticOptions(DiagnosticOptions::kRAAnnotate | DiagnosticOptions::kRADebugAll); +#endif + + compileTimer.start(); + test->compile(cc); + compileTimer.stop(); + + void* func = nullptr; + Error err = errorHandler._err; + + if (!err) { + finalizeTimer.start(); + err = cc.finalize(); + finalizeTimer.stop(); + } + + // The first pass is only for timing serialization and compilation, because otherwise it would be biased by + // logging, which takes much more time than finalize() does. We want to benchmark Compiler the way it would + // be used in production. + if (pass == 0) { + compileTime += compileTimer.duration(); + finalizeTime += finalizeTimer.duration(); + continue; + } + +#ifndef ASMJIT_NO_LOGGING + if (_dumpAsm) { + if (!_verbose) + printf("\n"); + + String sb; + Formatter::formatNodeList(sb, formatOptions, &cc); + printf("%s", sb.data()); + } +#endif + + if (err == kErrorOk) + err = runtime.add(&func, &code); + + if (err == kErrorOk && _dumpHex) { + String sb; + sb.appendHex((void*)func, code.codeSize()); + printf("\n (HEX: %s)\n", sb.data()); + } + + if (_verbose) + fflush(stdout); + + if (err == kErrorOk) { + _outputSize += code.codeSize(); + + StringTmp<128> result; + StringTmp<128> expect; + + if (test->run(func, result, expect)) { + if (!_verbose) + printf(" [OK]\n"); + } + else { + if (!_verbose) + printf(" [FAILED]\n"); + +#ifndef ASMJIT_NO_LOGGING + if (!_verbose) + printf("%s", stringLogger.data()); +#endif + + printf("[Status]\n"); + printf(" Returned: %s\n", result.data()); + printf(" Expected: %s\n", expect.data()); + + _nFailed++; + } + + if (_dumpAsm) + printf("\n"); + + runtime.release(func); + } + else { + if (!_verbose) + printf(" [FAILED]\n"); + +#ifndef ASMJIT_NO_LOGGING + if (!_verbose) + printf("%s", stringLogger.data()); +#endif + + printf("[Status]\n"); + printf(" ERROR 0x%08X: %s\n", unsigned(err), errorHandler._message.data()); + + _nFailed++; + } + } + } + + printf("\n"); + printf("Summary:\n"); + printf(" OutputSize: %zu bytes\n", _outputSize); + printf(" CompileTime: %.2f ms\n", compileTime); + printf(" FinalizeTime: %.2f ms\n", finalizeTime); + printf("\n"); + + if (_nFailed == 0) + printf("** SUCCESS: All %u tests passed **\n", unsigned(_tests.size())); + else + printf("** FAILURE: %u of %u tests failed **\n", _nFailed, unsigned(_tests.size())); + + return _nFailed == 0 ? 0 : 1; +#endif +} + +int main(int argc, char* argv[]) { + TestApp app; + + app.handleArgs(argc, argv); + app.showInfo(); + +#if !defined(ASMJIT_NO_X86) && ASMJIT_ARCH_X86 + compiler_add_x86_tests(app); +#endif + +#if !defined(ASMJIT_NO_AARCH64) && ASMJIT_ARCH_ARM == 64 + compiler_add_a64_tests(app); +#endif + + return app.run(); +} diff --git a/3rdparty/asmjit/test/asmjit_test_compiler.h b/3rdparty/asmjit/test/asmjit_test_compiler.h new file mode 100644 index 00000000000..e694b379e11 --- /dev/null +++ b/3rdparty/asmjit/test/asmjit_test_compiler.h @@ -0,0 +1,73 @@ +// This file is part of AsmJit project <https://asmjit.com> +// +// See asmjit.h or LICENSE.md for license and copyright information +// SPDX-License-Identifier: Zlib + +#ifndef ASMJIT_TEST_COMPILER_H_INCLUDED +#define ASMJIT_TEST_COMPILER_H_INCLUDED + +#include <asmjit/core.h> + +#include <memory> +#include <vector> + +class SimpleErrorHandler : public asmjit::ErrorHandler { +public: + SimpleErrorHandler() + : _err(asmjit::kErrorOk) {} + + virtual void handleError(asmjit::Error err, const char* message, asmjit::BaseEmitter* origin) { + asmjit::DebugUtils::unused(origin); + _err = err; + _message.assign(message); + } + + asmjit::Error _err; + asmjit::String _message; +}; + +//! A test case interface for testing AsmJit's Compiler. +class TestCase { +public: + TestCase(const char* name = nullptr) { + if (name) + _name.assign(name); + } + + virtual ~TestCase() {} + + inline const char* name() const { return _name.data(); } + + virtual void compile(asmjit::BaseCompiler& cc) = 0; + virtual bool run(void* func, asmjit::String& result, asmjit::String& expect) = 0; + + asmjit::String _name; +}; + +class TestApp { +public: + std::vector<std::unique_ptr<TestCase>> _tests; + + unsigned _nFailed = 0; + size_t _outputSize = 0; + + bool _verbose = false; + bool _dumpAsm = false; + bool _dumpHex = false; + + TestApp() noexcept {} + ~TestApp() noexcept {} + + void add(TestCase* test) noexcept { + _tests.push_back(std::unique_ptr<TestCase>(test)); + } + + template<class T> + inline void addT() { T::add(*this); } + + int handleArgs(int argc, const char* const* argv); + void showInfo(); + int run(); +}; + +#endif // ASMJIT_TEST_COMPILER_H_INCLUDED diff --git a/3rdparty/asmjit/test/asmjit_test_compiler_a64.cpp b/3rdparty/asmjit/test/asmjit_test_compiler_a64.cpp new file mode 100644 index 00000000000..4fc362e7230 --- /dev/null +++ b/3rdparty/asmjit/test/asmjit_test_compiler_a64.cpp @@ -0,0 +1,690 @@ +// This file is part of AsmJit project <https://asmjit.com> +// +// See asmjit.h or LICENSE.md for license and copyright information +// SPDX-License-Identifier: Zlib + +#include <asmjit/core.h> +#if !defined(ASMJIT_NO_AARCH64) && ASMJIT_ARCH_ARM == 64 + +#include <asmjit/a64.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> + +#include "./asmjit_test_compiler.h" + +using namespace asmjit; + +// a64::Compiler - A64TestCase +// =========================== + +class A64TestCase : public TestCase { +public: + A64TestCase(const char* name = nullptr) + : TestCase(name) {} + + virtual void compile(BaseCompiler& cc) override { + compile(static_cast<a64::Compiler&>(cc)); + } + + virtual void compile(a64::Compiler& cc) = 0; +}; + +// a64::Compiler - A64Test_GpArgs +// ============================== + +class A64Test_GpArgs : public A64TestCase { +public: + uint32_t _argCount; + bool _preserveFP; + + A64Test_GpArgs(uint32_t argCount, bool preserveFP) + : _argCount(argCount), + _preserveFP(preserveFP) { + _name.assignFormat("GpArgs {NumArgs=%u PreserveFP=%c}", argCount, preserveFP ? 'Y' : 'N'); + } + + static void add(TestApp& app) { + for (uint32_t i = 0; i <= 16; i++) { + app.add(new A64Test_GpArgs(i, true)); + app.add(new A64Test_GpArgs(i, false)); + } + } + + virtual void compile(a64::Compiler& cc) { + uint32_t i; + uint32_t argCount = _argCount; + + FuncSignatureBuilder signature; + signature.setRetT<int>(); + for (i = 0; i < argCount; i++) + signature.addArgT<int>(); + + FuncNode* funcNode = cc.addFunc(signature); + if (_preserveFP) + funcNode->frame().setPreservedFP(); + + arm::Gp sum; + + if (argCount) { + for (i = 0; i < argCount; i++) { + arm::Gp iReg = cc.newInt32("i%u", i); + funcNode->setArg(i, iReg); + + if (i == 0) + sum = iReg; + else + cc.add(sum, sum, iReg); + } + } + else { + sum = cc.newInt32("i"); + cc.mov(sum, 0); + } + + cc.ret(sum); + cc.endFunc(); + } + + virtual bool run(void* _func, String& result, String& expect) { + typedef unsigned int U; + + typedef U (*Func0)(); + typedef U (*Func1)(U); + typedef U (*Func2)(U, U); + typedef U (*Func3)(U, U, U); + typedef U (*Func4)(U, U, U, U); + typedef U (*Func5)(U, U, U, U, U); + typedef U (*Func6)(U, U, U, U, U, U); + typedef U (*Func7)(U, U, U, U, U, U, U); + typedef U (*Func8)(U, U, U, U, U, U, U, U); + typedef U (*Func9)(U, U, U, U, U, U, U, U, U); + typedef U (*Func10)(U, U, U, U, U, U, U, U, U, U); + typedef U (*Func11)(U, U, U, U, U, U, U, U, U, U, U); + typedef U (*Func12)(U, U, U, U, U, U, U, U, U, U, U, U); + typedef U (*Func13)(U, U, U, U, U, U, U, U, U, U, U, U, U); + typedef U (*Func14)(U, U, U, U, U, U, U, U, U, U, U, U, U, U); + typedef U (*Func15)(U, U, U, U, U, U, U, U, U, U, U, U, U, U, U); + typedef U (*Func16)(U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U); + + unsigned int resultRet = 0; + unsigned int expectRet = 0; + + switch (_argCount) { + case 0: + resultRet = ptr_as_func<Func0>(_func)(); + expectRet = 0; + break; + case 1: + resultRet = ptr_as_func<Func1>(_func)(1); + expectRet = 1; + break; + case 2: + resultRet = ptr_as_func<Func2>(_func)(1, 2); + expectRet = 1 + 2; + break; + case 3: + resultRet = ptr_as_func<Func3>(_func)(1, 2, 3); + expectRet = 1 + 2 + 3; + break; + case 4: + resultRet = ptr_as_func<Func4>(_func)(1, 2, 3, 4); + expectRet = 1 + 2 + 3 + 4; + break; + case 5: + resultRet = ptr_as_func<Func5>(_func)(1, 2, 3, 4, 5); + expectRet = 1 + 2 + 3 + 4 + 5; + break; + case 6: + resultRet = ptr_as_func<Func6>(_func)(1, 2, 3, 4, 5, 6); + expectRet = 1 + 2 + 3 + 4 + 5 + 6; + break; + case 7: + resultRet = ptr_as_func<Func7>(_func)(1, 2, 3, 4, 5, 6, 7); + expectRet = 1 + 2 + 3 + 4 + 5 + 6 + 7; + break; + case 8: + resultRet = ptr_as_func<Func8>(_func)(1, 2, 3, 4, 5, 6, 7, 8); + expectRet = 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8; + break; + case 9: + resultRet = ptr_as_func<Func9>(_func)(1, 2, 3, 4, 5, 6, 7, 8, 9); + expectRet = 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9; + break; + case 10: + resultRet = ptr_as_func<Func10>(_func)(1, 2, 3, 4, 5, 6, 7, 8, 9, 10); + expectRet = 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10; + break; + case 11: + resultRet = ptr_as_func<Func11>(_func)(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11); + expectRet = 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11; + break; + case 12: + resultRet = ptr_as_func<Func12>(_func)(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12); + expectRet = 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12; + break; + case 13: + resultRet = ptr_as_func<Func13>(_func)(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13); + expectRet = 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13; + break; + case 14: + resultRet = ptr_as_func<Func14>(_func)(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14); + expectRet = 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14; + break; + case 15: + resultRet = ptr_as_func<Func15>(_func)(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15); + expectRet = 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 15; + break; + case 16: + resultRet = ptr_as_func<Func16>(_func)(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16); + expectRet = 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 15 + 16; + break; + } + + result.assignFormat("ret={%u, %u}", resultRet >> 28, resultRet & 0x0FFFFFFFu); + expect.assignFormat("ret={%u, %u}", expectRet >> 28, expectRet & 0x0FFFFFFFu); + + return resultRet == expectRet; + } +}; + +// a64::Compiler - A64Test_Simd1 +// ============================= + +class A64Test_Simd1 : public A64TestCase { +public: + A64Test_Simd1() + : A64TestCase("Simd1") {} + + static void add(TestApp& app) { + app.add(new A64Test_Simd1()); + } + + virtual void compile(a64::Compiler& cc) { + FuncNode* funcNode = cc.addFunc(FuncSignatureT<void, void*, const void*, const void*>()); + + arm::Gp dst = cc.newUIntPtr("dst"); + arm::Gp src1 = cc.newUIntPtr("src1"); + arm::Gp src2 = cc.newUIntPtr("src2"); + + funcNode->setArg(0, dst); + funcNode->setArg(1, src1); + funcNode->setArg(2, src2); + + arm::Vec v1 = cc.newVecQ("vec1"); + arm::Vec v2 = cc.newVecQ("vec2"); + arm::Vec v3 = cc.newVecQ("vec3"); + + cc.ldr(v2, arm::ptr(src1)); + cc.ldr(v3, arm::ptr(src2)); + cc.add(v1.b16(), v2.b16(), v3.b16()); + cc.str(v1, arm::ptr(dst)); + + cc.endFunc(); + } + + virtual bool run(void* _func, String& result, String& expect) { + typedef void (*Func)(void*, const void*, const void*); + + uint32_t dst[4]; + uint32_t aSrc[4] = { 0 , 1 , 2 , 255 }; + uint32_t bSrc[4] = { 99, 17, 33, 1 }; + + // NOTE: It's a byte-add, so uint8_t(255+1) == 0. + uint32_t ref[4] = { 99, 18, 35, 0 }; + + ptr_as_func<Func>(_func)(dst, aSrc, bSrc); + + unsigned int resultRet = 0; + unsigned int expectRet = 0; + + result.assignFormat("ret={%u, %u, %u, %u}", dst[0], dst[1], dst[2], dst[3]); + expect.assignFormat("ret={%u, %u, %u, %u}", ref[0], ref[1], ref[2], ref[3]); + + return resultRet == expectRet; + } +}; + +// a64::Compiler - A64Test_ManyRegs +// ================================ + +class A64Test_ManyRegs : public A64TestCase { +public: + uint32_t _regCount; + + A64Test_ManyRegs(uint32_t n) + : A64TestCase(), + _regCount(n) { + _name.assignFormat("GpRegs {NumRegs=%u}", n); + } + + static void add(TestApp& app) { + for (uint32_t i = 2; i < 64; i++) + app.add(new A64Test_ManyRegs(i)); + } + + virtual void compile(a64::Compiler& cc) { + cc.addFunc(FuncSignatureT<int>()); + + arm::Gp* regs = static_cast<arm::Gp*>(malloc(_regCount * sizeof(arm::Gp))); + + for (uint32_t i = 0; i < _regCount; i++) { + regs[i] = cc.newUInt32("reg%u", i); + cc.mov(regs[i], i + 1); + } + + arm::Gp sum = cc.newUInt32("sum"); + cc.mov(sum, 0); + + for (uint32_t i = 0; i < _regCount; i++) { + cc.add(sum, sum, regs[i]); + } + + cc.ret(sum); + cc.endFunc(); + + free(regs); + } + + virtual bool run(void* _func, String& result, String& expect) { + typedef int (*Func)(void); + Func func = ptr_as_func<Func>(_func); + + result.assignFormat("ret={%d}", func()); + expect.assignFormat("ret={%d}", calcSum()); + + return result == expect; + } + + uint32_t calcSum() const { + return (_regCount | 1) * ((_regCount + 1) / 2); + } +}; + +// a64::Compiler - A64Test_Adr +// =========================== + +class A64Test_Adr : public A64TestCase { +public: + A64Test_Adr() + : A64TestCase("Adr") {} + + static void add(TestApp& app) { + app.add(new A64Test_Adr()); + } + + virtual void compile(a64::Compiler& cc) { + cc.addFunc(FuncSignatureT<int>()); + + arm::Gp addr = cc.newIntPtr("addr"); + arm::Gp val = cc.newIntPtr("val"); + + Label L_Table = cc.newLabel(); + + cc.adr(addr, L_Table); + cc.ldrsw(val, arm::ptr(addr, 8)); + cc.ret(val); + cc.endFunc(); + + cc.bind(L_Table); + cc.embedInt32(1); + cc.embedInt32(2); + cc.embedInt32(3); + cc.embedInt32(4); + cc.embedInt32(5); + } + + virtual bool run(void* _func, String& result, String& expect) { + typedef int (*Func)(void); + Func func = ptr_as_func<Func>(_func); + + result.assignFormat("ret={%d}", func()); + expect.assignFormat("ret={%d}", 3); + + return result == expect; + } +}; + +// a64::Compiler - A64Test_Branch1 +// =============================== + +class A64Test_Branch1 : public A64TestCase { +public: + A64Test_Branch1() + : A64TestCase("Branch1") {} + + static void add(TestApp& app) { + app.add(new A64Test_Branch1()); + } + + virtual void compile(a64::Compiler& cc) { + FuncNode* funcNode = cc.addFunc(FuncSignatureT<void, void*, size_t>()); + + arm::Gp p = cc.newIntPtr("p"); + arm::Gp count = cc.newIntPtr("count"); + arm::Gp i = cc.newIntPtr("i"); + Label L = cc.newLabel(); + + funcNode->setArg(0, p); + funcNode->setArg(1, count); + + cc.mov(i, 0); + + cc.bind(L); + cc.strb(i.w(), a64::ptr(p, i)); + cc.add(i, i, 1); + cc.cmp(i, count); + cc.b_ne(L); + + cc.endFunc(); + } + + virtual bool run(void* _func, String& result, String& expect) { + typedef void (*Func)(void* p, size_t n); + Func func = ptr_as_func<Func>(_func); + + uint8_t array[16]; + func(array, 16); + + expect.assign("ret={0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15}"); + + result.assign("ret={"); + for (size_t i = 0; i < 16; i++) { + if (i) + result.append(", "); + result.appendFormat("%d", int(array[i])); + } + result.append("}"); + + return result == expect; + } +}; + +// a64::Compiler - A64Test_Invoke1 +// =============================== + +class A64Test_Invoke1 : public A64TestCase { +public: + A64Test_Invoke1() + : A64TestCase("Invoke1") {} + + static void add(TestApp& app) { + app.add(new A64Test_Invoke1()); + } + + virtual void compile(a64::Compiler& cc) { + FuncNode* funcNode = cc.addFunc(FuncSignatureT<uint32_t, uint32_t, uint32_t>()); + + arm::Gp x = cc.newUInt32("x"); + arm::Gp y = cc.newUInt32("y"); + arm::Gp r = cc.newUInt32("r"); + arm::Gp fn = cc.newUIntPtr("fn"); + + funcNode->setArg(0, x); + funcNode->setArg(1, y); + + cc.mov(fn, (uint64_t)calledFunc); + + InvokeNode* invokeNode; + cc.invoke(&invokeNode, fn, FuncSignatureT<uint32_t, uint32_t, uint32_t>(CallConvId::kHost)); + invokeNode->setArg(0, x); + invokeNode->setArg(1, y); + invokeNode->setRet(0, r); + + cc.ret(r); + cc.endFunc(); + } + + virtual bool run(void* _func, String& result, String& expect) { + typedef uint32_t (*Func)(uint32_t, uint32_t); + Func func = ptr_as_func<Func>(_func); + + uint32_t x = 49; + uint32_t y = 7; + + result.assignFormat("ret={%u}", func(x, y)); + expect.assignFormat("ret={%u}", x - y); + + return result == expect; + } + + static uint32_t calledFunc(uint32_t x, uint32_t y) { + return x - y; + } +}; + +// a64::Compiler - A64Test_Invoke2 +// =============================== + +class A64Test_Invoke2 : public A64TestCase { +public: + A64Test_Invoke2() + : A64TestCase("Invoke2") {} + + static void add(TestApp& app) { + app.add(new A64Test_Invoke2()); + } + + virtual void compile(a64::Compiler& cc) { + FuncNode* funcNode = cc.addFunc(FuncSignatureT<double, double, double>()); + + arm::Vec x = cc.newVecD("x"); + arm::Vec y = cc.newVecD("y"); + arm::Vec r = cc.newVecD("r"); + arm::Gp fn = cc.newUIntPtr("fn"); + + funcNode->setArg(0, x); + funcNode->setArg(1, y); + cc.mov(fn, (uint64_t)calledFunc); + + InvokeNode* invokeNode; + cc.invoke(&invokeNode, fn, FuncSignatureT<double, double, double>(CallConvId::kHost)); + invokeNode->setArg(0, x); + invokeNode->setArg(1, y); + invokeNode->setRet(0, r); + + cc.ret(r); + cc.endFunc(); + } + + virtual bool run(void* _func, String& result, String& expect) { + typedef double (*Func)(double, double); + Func func = ptr_as_func<Func>(_func); + + double x = 49; + double y = 7; + + result.assignFormat("ret={%f}", func(x, y)); + expect.assignFormat("ret={%f}", calledFunc(x, y)); + + return result == expect; + } + + static double calledFunc(double x, double y) { + return x - y; + } +}; + +// a64::Compiler - A64Test_Invoke3 +// =============================== + +class A64Test_Invoke3 : public A64TestCase { +public: + A64Test_Invoke3() + : A64TestCase("Invoke3") {} + + static void add(TestApp& app) { + app.add(new A64Test_Invoke3()); + } + + virtual void compile(a64::Compiler& cc) { + FuncNode* funcNode = cc.addFunc(FuncSignatureT<double, double, double>()); + + arm::Vec x = cc.newVecD("x"); + arm::Vec y = cc.newVecD("y"); + arm::Vec r = cc.newVecD("r"); + arm::Gp fn = cc.newUIntPtr("fn"); + + funcNode->setArg(0, x); + funcNode->setArg(1, y); + cc.mov(fn, (uint64_t)calledFunc); + + InvokeNode* invokeNode; + cc.invoke(&invokeNode, fn, FuncSignatureT<double, double, double>(CallConvId::kHost)); + invokeNode->setArg(0, y); + invokeNode->setArg(1, x); + invokeNode->setRet(0, r); + + cc.ret(r); + cc.endFunc(); + } + + virtual bool run(void* _func, String& result, String& expect) { + typedef double (*Func)(double, double); + Func func = ptr_as_func<Func>(_func); + + double x = 49; + double y = 7; + + result.assignFormat("ret={%f}", func(x, y)); + expect.assignFormat("ret={%f}", calledFunc(y, x)); + + return result == expect; + } + + static double calledFunc(double x, double y) { + return x - y; + } +}; + +// a64::Compiler - A64Test_JumpTable +// ================================= + +class A64Test_JumpTable : public A64TestCase { +public: + bool _annotated; + + A64Test_JumpTable(bool annotated) + : A64TestCase("A64Test_JumpTable"), + _annotated(annotated) { + _name.assignFormat("JumpTable {%s}", annotated ? "Annotated" : "Unknown Target"); + } + + enum Operator { + kOperatorAdd = 0, + kOperatorSub = 1, + kOperatorMul = 2, + kOperatorDiv = 3 + }; + + static void add(TestApp& app) { + app.add(new A64Test_JumpTable(false)); + app.add(new A64Test_JumpTable(true)); + } + + virtual void compile(a64::Compiler& cc) { + FuncNode* funcNode = cc.addFunc(FuncSignatureT<float, float, float, uint32_t>()); + + arm::Vec a = cc.newVecS("a"); + arm::Vec b = cc.newVecS("b"); + arm::Gp op = cc.newUInt32("op"); + + arm::Gp target = cc.newIntPtr("target"); + arm::Gp offset = cc.newIntPtr("offset"); + + Label L_End = cc.newLabel(); + + Label L_Table = cc.newLabel(); + Label L_Add = cc.newLabel(); + Label L_Sub = cc.newLabel(); + Label L_Mul = cc.newLabel(); + Label L_Div = cc.newLabel(); + + funcNode->setArg(0, a); + funcNode->setArg(1, b); + funcNode->setArg(2, op); + + cc.adr(target, L_Table); + cc.ldrsw(offset, arm::ptr(target, op, arm::sxtw(2))); + cc.add(target, target, offset); + + // JumpAnnotation allows to annotate all possible jump targets of + // instructions where it cannot be deduced from operands. + if (_annotated) { + JumpAnnotation* annotation = cc.newJumpAnnotation(); + annotation->addLabel(L_Add); + annotation->addLabel(L_Sub); + annotation->addLabel(L_Mul); + annotation->addLabel(L_Div); + cc.br(target, annotation); + } + else { + cc.br(target); + } + + cc.bind(L_Add); + cc.fadd(a, a, b); + cc.b(L_End); + + cc.bind(L_Sub); + cc.fsub(a, a, b); + cc.b(L_End); + + cc.bind(L_Mul); + cc.fmul(a, a, b); + cc.b(L_End); + + cc.bind(L_Div); + cc.fdiv(a, a, b); + + cc.bind(L_End); + cc.ret(a); + cc.endFunc(); + + cc.bind(L_Table); + cc.embedLabelDelta(L_Add, L_Table, 4); + cc.embedLabelDelta(L_Sub, L_Table, 4); + cc.embedLabelDelta(L_Mul, L_Table, 4); + cc.embedLabelDelta(L_Div, L_Table, 4); + } + + virtual bool run(void* _func, String& result, String& expect) { + typedef float (*Func)(float, float, uint32_t); + Func func = ptr_as_func<Func>(_func); + + float dst[4]; + float ref[4]; + + dst[0] = func(33.0f, 14.0f, kOperatorAdd); + dst[1] = func(33.0f, 14.0f, kOperatorSub); + dst[2] = func(10.0f, 6.0f, kOperatorMul); + dst[3] = func(80.0f, 8.0f, kOperatorDiv); + + ref[0] = 47.0f; + ref[1] = 19.0f; + ref[2] = 60.0f; + ref[3] = 10.0f; + + result.assignFormat("ret={%f, %f, %f, %f}", dst[0], dst[1], dst[2], dst[3]); + expect.assignFormat("ret={%f, %f, %f, %f}", ref[0], ref[1], ref[2], ref[3]); + + return result == expect; + } +}; + +// a64::Compiler - Export +// ====================== + +void compiler_add_a64_tests(TestApp& app) { + app.addT<A64Test_GpArgs>(); + app.addT<A64Test_ManyRegs>(); + app.addT<A64Test_Simd1>(); + app.addT<A64Test_Adr>(); + app.addT<A64Test_Branch1>(); + app.addT<A64Test_Invoke1>(); + app.addT<A64Test_Invoke2>(); + app.addT<A64Test_Invoke3>(); + app.addT<A64Test_JumpTable>(); +} + +#endif // !ASMJIT_NO_AARCH64 && ASMJIT_ARCH_ARM == 64 diff --git a/3rdparty/asmjit/test/asmjit_test_x86_cc.cpp b/3rdparty/asmjit/test/asmjit_test_compiler_x86.cpp index 9e80d871978..7dbe95599b4 100644 --- a/3rdparty/asmjit/test/asmjit_test_x86_cc.cpp +++ b/3rdparty/asmjit/test/asmjit_test_compiler_x86.cpp @@ -1,25 +1,10 @@ -// AsmJit - Machine code generation for C++ +// This file is part of AsmJit project <https://asmjit.com> // -// * Official AsmJit Home Page: https://asmjit.com -// * Official Github Repository: https://github.com/asmjit/asmjit -// -// Copyright (c) 2008-2020 The AsmJit Authors -// -// This software is provided 'as-is', without any express or implied -// warranty. In no event will the authors be held liable for any damages -// arising from the use of this software. -// -// Permission is granted to anyone to use this software for any purpose, -// including commercial applications, and to alter it and redistribute it -// freely, subject to the following restrictions: -// -// 1. The origin of this software must not be misrepresented; you must not -// claim that you wrote the original software. If you use this software -// in a product, an acknowledgment in the product documentation would be -// appreciated but is not required. -// 2. Altered source versions must be plainly marked as such, and must not be -// misrepresented as being the original software. -// 3. This notice may not be removed or altered from any source distribution. +// See asmjit.h or LICENSE.md for license and copyright information +// SPDX-License-Identifier: Zlib + +#include <asmjit/core.h> +#if !defined(ASMJIT_NO_X86) && ASMJIT_ARCH_X86 #include <asmjit/x86.h> #include <setjmp.h> @@ -27,13 +12,11 @@ #include <stdlib.h> #include <string.h> -#include <memory> -#include <vector> - // Required for function tests that pass / return XMM registers. #include <emmintrin.h> -#include "./asmjit_test_misc.h" +#include "asmjit_test_misc.h" +#include "asmjit_test_compiler.h" #ifdef _MSC_VER // Interaction between '_setjmp' and C++ object destruction is non-portable. @@ -42,239 +25,25 @@ using namespace asmjit; -// ============================================================================ -// [CmdLine] -// ============================================================================ +// x86::Compiler - X86TestCase +// =========================== -class CmdLine { +class X86TestCase : public TestCase { public: - CmdLine(int argc, const char* const* argv) noexcept - : _argc(argc), - _argv(argv) {} + X86TestCase(const char* name = nullptr) + : TestCase(name) {} - bool hasArg(const char* arg) noexcept { - for (int i = 1; i < _argc; i++) - if (strcmp(_argv[i], arg) == 0) - return true; - return false; + virtual void compile(BaseCompiler& cc) override { + compile(static_cast<x86::Compiler&>(cc)); } - int _argc; - const char* const* _argv; + virtual void compile(x86::Compiler& cc) = 0; }; -// ============================================================================ -// [SimpleErrorHandler] -// ============================================================================ +// x86::Compiler - X86Test_AlignBase +// ================================= -class SimpleErrorHandler : public ErrorHandler { -public: - SimpleErrorHandler() : _err(kErrorOk) {} - virtual void handleError(Error err, const char* message, BaseEmitter* origin) { - DebugUtils::unused(origin); - _err = err; - _message.assign(message); - } - - Error _err; - String _message; -}; - -// ============================================================================ -// [X86Test] -// ============================================================================ - -//! Base test interface for testing `x86::Compiler`. -class X86Test { -public: - X86Test(const char* name = nullptr) { _name.assign(name); } - virtual ~X86Test() {} - - inline const char* name() const { return _name.data(); } - - virtual void compile(x86::Compiler& c) = 0; - virtual bool run(void* func, String& result, String& expect) = 0; - - String _name; -}; - -// ============================================================================ -// [X86TestApp] -// ============================================================================ - -class X86TestApp { -public: - std::vector<std::unique_ptr<X86Test>> _tests; - - unsigned _nFailed; - size_t _outputSize; - - bool _verbose; - bool _dumpAsm; - - X86TestApp() noexcept - : _nFailed(0), - _outputSize(0), - _verbose(false), - _dumpAsm(false) {} - - ~X86TestApp() noexcept {} - - void add(X86Test* test) noexcept { - _tests.push_back(std::unique_ptr<X86Test>(test)); - } - - template<class T> - inline void addT() { T::add(*this); } - - int handleArgs(int argc, const char* const* argv); - void showInfo(); - int run(); -}; - -int X86TestApp::handleArgs(int argc, const char* const* argv) { - CmdLine cmd(argc, argv); - - if (cmd.hasArg("--verbose")) _verbose = true; - if (cmd.hasArg("--dump-asm")) _dumpAsm = true; - - return 0; -} - -void X86TestApp::showInfo() { - printf("AsmJit Compiler Test-Suite v%u.%u.%u [Arch=%s]:\n", - unsigned((ASMJIT_LIBRARY_VERSION >> 16) ), - unsigned((ASMJIT_LIBRARY_VERSION >> 8) & 0xFF), - unsigned((ASMJIT_LIBRARY_VERSION ) & 0xFF), - sizeof(void*) == 8 ? "X64" : "X86"); - printf(" [%s] Verbose (use --verbose to turn verbose output ON)\n", _verbose ? "x" : " "); - printf(" [%s] DumpAsm (use --dump-asm to turn assembler dumps ON)\n", _dumpAsm ? "x" : " "); - printf("\n"); -} - -int X86TestApp::run() { -#ifndef ASMJIT_NO_LOGGING - uint32_t kFormatFlags = FormatOptions::kFlagMachineCode | - FormatOptions::kFlagExplainImms | - FormatOptions::kFlagRegCasts | - FormatOptions::kFlagAnnotations | - FormatOptions::kFlagDebugPasses | - FormatOptions::kFlagDebugRA ; - - FileLogger fileLogger(stdout); - fileLogger.addFlags(kFormatFlags); - - StringLogger stringLogger; - stringLogger.addFlags(kFormatFlags); -#endif - - for (std::unique_ptr<X86Test>& test : _tests) { - JitRuntime runtime; - CodeHolder code; - SimpleErrorHandler errorHandler; - - code.init(runtime.environment()); - code.setErrorHandler(&errorHandler); - -#ifndef ASMJIT_NO_LOGGING - if (_verbose) { - code.setLogger(&fileLogger); - } - else { - stringLogger.clear(); - code.setLogger(&stringLogger); - } -#endif - - printf("[Test] %s", test->name()); - -#ifndef ASMJIT_NO_LOGGING - if (_verbose) printf("\n"); -#endif - - x86::Compiler cc(&code); - test->compile(cc); - - void* func = nullptr; - Error err = errorHandler._err; - - if (!err) - err = cc.finalize(); - -#ifndef ASMJIT_NO_LOGGING - if (_dumpAsm) { - if (!_verbose) printf("\n"); - - String sb; - Formatter::formatNodeList(sb, kFormatFlags, &cc); - printf("%s", sb.data()); - } -#endif - - if (err == kErrorOk) - err = runtime.add(&func, &code); - - if (_verbose) - fflush(stdout); - - if (err == kErrorOk) { - _outputSize += code.codeSize(); - - StringTmp<128> result; - StringTmp<128> expect; - - if (test->run(func, result, expect)) { - if (!_verbose) printf(" [OK]\n"); - } - else { - if (!_verbose) printf(" [FAILED]\n"); - -#ifndef ASMJIT_NO_LOGGING - if (!_verbose) printf("%s", stringLogger.data()); -#endif - - printf("[Status]\n"); - printf(" Returned: %s\n", result.data()); - printf(" Expected: %s\n", expect.data()); - - _nFailed++; - } - - if (_dumpAsm) - printf("\n"); - - runtime.release(func); - } - else { - if (!_verbose) printf(" [FAILED]\n"); - -#ifndef ASMJIT_NO_LOGGING - if (!_verbose) printf("%s", stringLogger.data()); -#endif - - printf("[Status]\n"); - printf(" ERROR 0x%08X: %s\n", unsigned(err), errorHandler._message.data()); - - _nFailed++; - } - } - - if (_nFailed == 0) - printf("\nSuccess:\n All %u tests passed\n", unsigned(_tests.size())); - else - printf("\nFailure:\n %u %s of %u failed\n", _nFailed, _nFailed == 1 ? "test" : "tests", unsigned(_tests.size())); - - printf(" OutputSize=%zu\n", _outputSize); - printf("\n"); - - return _nFailed == 0 ? 0 : 1; -} - -// ============================================================================ -// [X86Test_AlignBase] -// ============================================================================ - -class X86Test_AlignBase : public X86Test { +class X86Test_AlignBase : public X86TestCase { public: X86Test_AlignBase(uint32_t argCount, uint32_t alignment, bool preserveFP) : _argCount(argCount), @@ -283,7 +52,7 @@ public: _name.assignFormat("AlignBase {NumArgs=%u Alignment=%u PreserveFP=%c}", argCount, alignment, preserveFP ? 'Y' : 'N'); } - static void add(X86TestApp& app) { + static void add(TestApp& app) { for (uint32_t i = 0; i <= 16; i++) { for (uint32_t a = 16; a <= 32; a += 16) { app.add(new X86Test_AlignBase(i, a, true)); @@ -296,14 +65,14 @@ public: uint32_t i; uint32_t argCount = _argCount; - FuncSignatureBuilder signature(CallConv::kIdHost); + FuncSignatureBuilder signature(CallConvId::kHost); signature.setRetT<int>(); for (i = 0; i < argCount; i++) signature.addArgT<int>(); - cc.addFunc(signature); + FuncNode* funcNode = cc.addFunc(signature); if (_preserveFP) - cc.func()->frame().setPreservedFP(); + funcNode->frame().setPreservedFP(); x86::Gp gpVar = cc.newIntPtr("gpVar"); x86::Gp gpSum; @@ -313,7 +82,7 @@ public: if (argCount) { for (i = 0; i < argCount; i++) { x86::Gp gpArg = cc.newInt32("gpArg%u", i); - cc.setArg(i, gpArg); + funcNode->setArg(i, gpArg); if (i == 0) gpSum = gpArg; @@ -440,20 +209,19 @@ public: bool _preserveFP; }; -// ============================================================================ -// [X86Test_NoCode] -// ============================================================================ +// x86::Compiler - X86Test_NoCode +// ============================== -class X86Test_NoCode : public X86Test { +class X86Test_NoCode : public X86TestCase { public: - X86Test_NoCode() : X86Test("NoCode") {} + X86Test_NoCode() : X86TestCase("NoCode") {} - static void add(X86TestApp& app) { + static void add(TestApp& app) { app.add(new X86Test_NoCode()); } virtual void compile(x86::Compiler& cc) { - cc.addFunc(FuncSignatureT<void>(CallConv::kIdHost)); + cc.addFunc(FuncSignatureT<void>(CallConvId::kHost)); cc.endFunc(); } @@ -468,22 +236,21 @@ public: } }; -// ============================================================================ -// [X86Test_AlignNone] -// ============================================================================ +// x86::Compiler - X86Test_AlignNone +// ================================= -class X86Test_NoAlign : public X86Test { +class X86Test_NoAlign : public X86TestCase { public: - X86Test_NoAlign() : X86Test("NoAlign") {} + X86Test_NoAlign() : X86TestCase("NoAlign") {} - static void add(X86TestApp& app) { + static void add(TestApp& app) { app.add(new X86Test_NoAlign()); } virtual void compile(x86::Compiler& cc) { - cc.addFunc(FuncSignatureT<void>(CallConv::kIdHost)); - cc.align(kAlignCode, 0); - cc.align(kAlignCode, 1); + cc.addFunc(FuncSignatureT<void>(CallConvId::kHost)); + cc.align(AlignMode::kCode, 0); + cc.align(AlignMode::kCode, 1); cc.endFunc(); } @@ -498,22 +265,19 @@ public: } }; -// ============================================================================ -// [X86Test_JumpMerge] -// ============================================================================ +// x86::Compiler - X86Test_JumpMerge +// ================================= -class X86Test_JumpMerge : public X86Test { +class X86Test_JumpMerge : public X86TestCase { public: - X86Test_JumpMerge() : X86Test("JumpMerge") {} + X86Test_JumpMerge() : X86TestCase("JumpMerge") {} - static void add(X86TestApp& app) { + static void add(TestApp& app) { app.add(new X86Test_JumpMerge()); } virtual void compile(x86::Compiler& cc) { - cc.addFunc(FuncSignatureT<void, int*, int>(CallConv::kIdHost)); - - Label L0 = cc.newLabel(); + Label L0 = cc.newLabel(); Label L1 = cc.newLabel(); Label L2 = cc.newLabel(); Label LEnd = cc.newLabel(); @@ -521,8 +285,9 @@ public: x86::Gp dst = cc.newIntPtr("dst"); x86::Gp val = cc.newInt32("val"); - cc.setArg(0, dst); - cc.setArg(1, val); + FuncNode* funcNode = cc.addFunc(FuncSignatureT<void, int*, int>(CallConvId::kHost)); + funcNode->setArg(0, dst); + funcNode->setArg(1, val); cc.cmp(val, 0); cc.je(L2); @@ -564,20 +329,19 @@ public: } }; -// ============================================================================ -// [X86Test_JumpCross] -// ============================================================================ +// x86::Compiler - X86Test_JumpCross +// ================================= -class X86Test_JumpCross : public X86Test { +class X86Test_JumpCross : public X86TestCase { public: - X86Test_JumpCross() : X86Test("JumpCross") {} + X86Test_JumpCross() : X86TestCase("JumpCross") {} - static void add(X86TestApp& app) { + static void add(TestApp& app) { app.add(new X86Test_JumpCross()); } virtual void compile(x86::Compiler& cc) { - cc.addFunc(FuncSignatureT<void>(CallConv::kIdHost)); + cc.addFunc(FuncSignatureT<void>(CallConvId::kHost)); Label L1 = cc.newLabel(); Label L2 = cc.newLabel(); @@ -606,20 +370,19 @@ public: } }; -// ============================================================================ -// [X86Test_JumpMany] -// ============================================================================ +// x86::Compiler - X86Test_JumpMany +// ================================ -class X86Test_JumpMany : public X86Test { +class X86Test_JumpMany : public X86TestCase { public: - X86Test_JumpMany() : X86Test("JumpMany") {} + X86Test_JumpMany() : X86TestCase("JumpMany") {} - static void add(X86TestApp& app) { + static void add(TestApp& app) { app.add(new X86Test_JumpMany()); } virtual void compile(x86::Compiler& cc) { - cc.addFunc(FuncSignatureT<int>(CallConv::kIdHost)); + cc.addFunc(FuncSignatureT<int>(CallConvId::kHost)); for (uint32_t i = 0; i < 1000; i++) { Label L = cc.newLabel(); cc.jmp(L); @@ -647,20 +410,19 @@ public: } }; -// ============================================================================ -// [X86Test_JumpUnreachable1] -// ============================================================================ +// x86::Compiler - X86Test_JumpUnreachable1 +// ======================================== -class X86Test_JumpUnreachable1 : public X86Test { +class X86Test_JumpUnreachable1 : public X86TestCase { public: - X86Test_JumpUnreachable1() : X86Test("JumpUnreachable1") {} + X86Test_JumpUnreachable1() : X86TestCase("JumpUnreachable1") {} - static void add(X86TestApp& app) { + static void add(TestApp& app) { app.add(new X86Test_JumpUnreachable1()); } virtual void compile(x86::Compiler& cc) { - cc.addFunc(FuncSignatureT<void>(CallConv::kIdHost)); + cc.addFunc(FuncSignatureT<void>(CallConvId::kHost)); Label L_1 = cc.newLabel(); Label L_2 = cc.newLabel(); @@ -691,7 +453,7 @@ public: cc.bind(L_7); cc.add(v0, v1); - cc.align(kAlignCode, 16); + cc.align(AlignMode::kCode, 16); cc.bind(L_1); cc.ret(); cc.endFunc(); @@ -710,20 +472,19 @@ public: } }; -// ============================================================================ -// [X86Test_JumpUnreachable2] -// ============================================================================ +// x86::Compiler - X86Test_JumpUnreachable2 +// ======================================== -class X86Test_JumpUnreachable2 : public X86Test { +class X86Test_JumpUnreachable2 : public X86TestCase { public: - X86Test_JumpUnreachable2() : X86Test("JumpUnreachable2") {} + X86Test_JumpUnreachable2() : X86TestCase("JumpUnreachable2") {} - static void add(X86TestApp& app) { + static void add(TestApp& app) { app.add(new X86Test_JumpUnreachable2()); } virtual void compile(x86::Compiler& cc) { - cc.addFunc(FuncSignatureT<void>(CallConv::kIdHost)); + cc.addFunc(FuncSignatureT<void>(CallConvId::kHost)); Label L_1 = cc.newLabel(); Label L_2 = cc.newLabel(); @@ -757,16 +518,15 @@ public: } }; -// ============================================================================ -// [X86Test_JumpTable] -// ============================================================================ +// x86::Compiler - X86Test_JumpTable1 +// ================================== -class X86Test_JumpTable : public X86Test { +class X86Test_JumpTable1 : public X86TestCase { public: bool _annotated; - X86Test_JumpTable(bool annotated) - : X86Test("X86Test_JumpTable"), + X86Test_JumpTable1(bool annotated) + : X86TestCase("X86Test_JumpTable1"), _annotated(annotated) { _name.assignFormat("JumpTable {%s}", annotated ? "Annotated" : "Unknown Reg/Mem"); } @@ -778,31 +538,29 @@ public: kOperatorDiv = 3 }; - static void add(X86TestApp& app) { - app.add(new X86Test_JumpTable(false)); - app.add(new X86Test_JumpTable(true)); + static void add(TestApp& app) { + app.add(new X86Test_JumpTable1(false)); + app.add(new X86Test_JumpTable1(true)); } virtual void compile(x86::Compiler& cc) { - cc.addFunc(FuncSignatureT<float, float, float, uint32_t>(CallConv::kIdHost)); - x86::Xmm a = cc.newXmmSs("a"); x86::Xmm b = cc.newXmmSs("b"); x86::Gp op = cc.newUInt32("op"); x86::Gp target = cc.newIntPtr("target"); x86::Gp offset = cc.newIntPtr("offset"); - Label L_End = cc.newLabel(); - Label L_Table = cc.newLabel(); Label L_Add = cc.newLabel(); Label L_Sub = cc.newLabel(); Label L_Mul = cc.newLabel(); Label L_Div = cc.newLabel(); + Label L_End = cc.newLabel(); - cc.setArg(0, a); - cc.setArg(1, b); - cc.setArg(2, op); + FuncNode* funcNode = cc.addFunc(FuncSignatureT<float, float, float, uint32_t>(CallConvId::kHost)); + funcNode->setArg(0, a); + funcNode->setArg(1, b); + funcNode->setArg(2, op); cc.lea(offset, x86::ptr(L_Table)); if (cc.is64Bit()) @@ -876,20 +634,100 @@ public: } }; -// ============================================================================ -// [X86Test_AllocBase] -// ============================================================================ +// x86::Compiler - X86Test_JumpTable2 +// ================================== + +class X86Test_JumpTable2 : public X86TestCase { +public: + X86Test_JumpTable2() + : X86TestCase("JumpTable {Jumping to Begin}") {} + + static void add(TestApp& app) { + app.add(new X86Test_JumpTable2()); + } + + virtual void compile(x86::Compiler& cc) { + x86::Gp result = cc.newUInt32("result"); + x86::Gp value = cc.newUInt32("value"); + x86::Gp target = cc.newIntPtr("target"); + x86::Gp offset = cc.newIntPtr("offset"); + + Label L_Table = cc.newLabel(); + Label L_Begin = cc.newLabel(); + Label L_Case0 = cc.newLabel(); + Label L_Case1 = cc.newLabel(); + Label L_End = cc.newLabel(); + + FuncNode* funcNode = cc.addFunc(FuncSignatureT<int, int>(CallConvId::kHost)); + funcNode->setArg(0, value); + + cc.bind(L_Begin); + cc.lea(offset, x86::ptr(L_Table)); + if (cc.is64Bit()) + cc.movsxd(target, x86::dword_ptr(offset, value.cloneAs(offset), 2)); + else + cc.mov(target, x86::dword_ptr(offset, value.cloneAs(offset), 2)); + cc.add(target, offset); + + { + JumpAnnotation* annotation = cc.newJumpAnnotation(); + annotation->addLabel(L_Case0); + annotation->addLabel(L_Case1); + annotation->addLabel(L_Begin); // Never used, just for the purpose of the test. + cc.jmp(target, annotation); + + cc.bind(L_Case0); + cc.mov(result, 0); + cc.jmp(L_End); + + cc.bind(L_Case1); + cc.mov(result, 1); + cc.jmp(L_End); + } + + cc.bind(L_End); + cc.ret(result); + + cc.endFunc(); + + cc.bind(L_Table); + cc.embedLabelDelta(L_Case0, L_Table, 4); + cc.embedLabelDelta(L_Case1, L_Table, 4); + } + + virtual bool run(void* _func, String& result, String& expect) { + typedef int (*Func)(int); + Func func = ptr_as_func<Func>(_func); + + int results[2]; + int expected[2]; + + results[0] = func(0); + results[1] = func(1); + + expected[0] = 0; + expected[1] = 1; + + result.assignFormat("ret={%d, %d}", results[0], results[1]); + expect.assignFormat("ret={%d, %d}", expected[0], expected[1]); + + return result == expect; + } +}; + +// x86::Compiler - X86Test_AllocBase +// ================================= -class X86Test_AllocBase : public X86Test { +class X86Test_AllocBase : public X86TestCase { public: - X86Test_AllocBase() : X86Test("AllocBase") {} + X86Test_AllocBase() : X86TestCase("AllocBase") {} - static void add(X86TestApp& app) { + static void add(TestApp& app) { app.add(new X86Test_AllocBase()); } virtual void compile(x86::Compiler& cc) { - cc.addFunc(FuncSignatureT<int>(CallConv::kIdHost)); + cc.addFunc(FuncSignatureT<int>(CallConvId::kHost)); x86::Gp v0 = cc.newInt32("v0"); x86::Gp v1 = cc.newInt32("v1"); @@ -927,28 +765,26 @@ public: } }; -// ============================================================================ -// [X86Test_AllocMany1] -// ============================================================================ +// x86::Compiler - X86Test_AllocMany1 +// ================================== -class X86Test_AllocMany1 : public X86Test { +class X86Test_AllocMany1 : public X86TestCase { public: - X86Test_AllocMany1() : X86Test("AllocMany1") {} + X86Test_AllocMany1() : X86TestCase("AllocMany1") {} enum { kCount = 8 }; - static void add(X86TestApp& app) { + static void add(TestApp& app) { app.add(new X86Test_AllocMany1()); } virtual void compile(x86::Compiler& cc) { - cc.addFunc(FuncSignatureT<void, int*, int*>(CallConv::kIdHost)); - x86::Gp a0 = cc.newIntPtr("a0"); x86::Gp a1 = cc.newIntPtr("a1"); - cc.setArg(0, a0); - cc.setArg(1, a1); + FuncNode* funcNode = cc.addFunc(FuncSignatureT<void, int*, int*>(CallConvId::kHost)); + funcNode->setArg(0, a0); + funcNode->setArg(1, a1); // Create some variables. x86::Gp t = cc.newInt32("t"); @@ -999,40 +835,37 @@ public: } }; -// ============================================================================ -// [X86Test_AllocMany2] -// ============================================================================ +// x86::Compiler - X86Test_AllocMany2 +// ================================== -class X86Test_AllocMany2 : public X86Test { +class X86Test_AllocMany2 : public X86TestCase { public: - X86Test_AllocMany2() : X86Test("AllocMany2") {} + X86Test_AllocMany2() : X86TestCase("AllocMany2") {} - static void add(X86TestApp& app) { + static void add(TestApp& app) { app.add(new X86Test_AllocMany2()); } virtual void compile(x86::Compiler& cc) { - cc.addFunc(FuncSignatureT<void, uint32_t*>(CallConv::kIdHost)); - x86::Gp a = cc.newIntPtr("a"); x86::Gp v[32]; - uint32_t i; - cc.setArg(0, a); + FuncNode* funcNode = cc.addFunc(FuncSignatureT<void, uint32_t*>(CallConvId::kHost)); + funcNode->setArg(0, a); - for (i = 0; i < ASMJIT_ARRAY_SIZE(v); i++) v[i] = cc.newInt32("v%d", i); - for (i = 0; i < ASMJIT_ARRAY_SIZE(v); i++) cc.xor_(v[i], v[i]); + for (uint32_t i = 0; i < ASMJIT_ARRAY_SIZE(v); i++) v[i] = cc.newInt32("v%d", i); + for (uint32_t i = 0; i < ASMJIT_ARRAY_SIZE(v); i++) cc.xor_(v[i], v[i]); x86::Gp x = cc.newInt32("x"); Label L = cc.newLabel(); cc.mov(x, 32); cc.bind(L); - for (i = 0; i < ASMJIT_ARRAY_SIZE(v); i++) cc.add(v[i], i); + for (uint32_t i = 0; i < ASMJIT_ARRAY_SIZE(v); i++) cc.add(v[i], i); cc.dec(x); cc.jnz(L); - for (i = 0; i < ASMJIT_ARRAY_SIZE(v); i++) cc.mov(x86::dword_ptr(a, int(i * 4)), v[i]); + for (uint32_t i = 0; i < ASMJIT_ARRAY_SIZE(v); i++) cc.mov(x86::dword_ptr(a, int(i * 4)), v[i]); cc.endFunc(); } @@ -1063,21 +896,18 @@ public: } }; -// ============================================================================ -// [X86Test_AllocImul1] -// ============================================================================ +// x86::Compiler - X86Test_AllocImul1 +// ================================== -class X86Test_AllocImul1 : public X86Test { +class X86Test_AllocImul1 : public X86TestCase { public: - X86Test_AllocImul1() : X86Test("AllocImul1") {} + X86Test_AllocImul1() : X86TestCase("AllocImul1") {} - static void add(X86TestApp& app) { + static void add(TestApp& app) { app.add(new X86Test_AllocImul1()); } virtual void compile(x86::Compiler& cc) { - cc.addFunc(FuncSignatureT<void, int*, int*, int, int>(CallConv::kIdHost)); - x86::Gp dstHi = cc.newIntPtr("dstHi"); x86::Gp dstLo = cc.newIntPtr("dstLo"); @@ -1085,13 +915,13 @@ public: x86::Gp vLo = cc.newInt32("vLo"); x86::Gp src = cc.newInt32("src"); - cc.setArg(0, dstHi); - cc.setArg(1, dstLo); - cc.setArg(2, vLo); - cc.setArg(3, src); + FuncNode* funcNode = cc.addFunc(FuncSignatureT<void, int*, int*, int, int>(CallConvId::kHost)); + funcNode->setArg(0, dstHi); + funcNode->setArg(1, dstLo); + funcNode->setArg(2, vLo); + funcNode->setArg(3, src); cc.imul(vHi, vLo, src); - cc.mov(x86::dword_ptr(dstHi), vHi); cc.mov(x86::dword_ptr(dstLo), vLo); cc.endFunc(); @@ -1119,26 +949,24 @@ public: } }; -// ============================================================================ -// [X86Test_AllocImul2] -// ============================================================================ +// x86::Compiler - X86Test_AllocImul2 +// ================================== -class X86Test_AllocImul2 : public X86Test { +class X86Test_AllocImul2 : public X86TestCase { public: - X86Test_AllocImul2() : X86Test("AllocImul2") {} + X86Test_AllocImul2() : X86TestCase("AllocImul2") {} - static void add(X86TestApp& app) { + static void add(TestApp& app) { app.add(new X86Test_AllocImul2()); } virtual void compile(x86::Compiler& cc) { - cc.addFunc(FuncSignatureT<void, int*, const int*>(CallConv::kIdHost)); - x86::Gp dst = cc.newIntPtr("dst"); x86::Gp src = cc.newIntPtr("src"); - cc.setArg(0, dst); - cc.setArg(1, src); + FuncNode* funcNode = cc.addFunc(FuncSignatureT<void, int*, const int*>(CallConvId::kHost)); + funcNode->setArg(0, dst); + funcNode->setArg(1, src); for (unsigned int i = 0; i < 4; i++) { x86::Gp x = cc.newInt32("x"); @@ -1173,27 +1001,25 @@ public: } }; -// ============================================================================ -// [X86Test_AllocIdiv1] -// ============================================================================ +// x86::Compiler - X86Test_AllocIdiv1 +// ================================== -class X86Test_AllocIdiv1 : public X86Test { +class X86Test_AllocIdiv1 : public X86TestCase { public: - X86Test_AllocIdiv1() : X86Test("AllocIdiv1") {} + X86Test_AllocIdiv1() : X86TestCase("AllocIdiv1") {} - static void add(X86TestApp& app) { + static void add(TestApp& app) { app.add(new X86Test_AllocIdiv1()); } virtual void compile(x86::Compiler& cc) { - cc.addFunc(FuncSignatureT<int, int, int>(CallConv::kIdHost)); - x86::Gp a = cc.newInt32("a"); x86::Gp b = cc.newInt32("b"); x86::Gp dummy = cc.newInt32("dummy"); - cc.setArg(0, a); - cc.setArg(1, b); + FuncNode* funcNode = cc.addFunc(FuncSignatureT<int, int, int>(CallConvId::kHost)); + funcNode->setArg(0, a); + funcNode->setArg(1, b); cc.xor_(dummy, dummy); cc.idiv(dummy, a, b); @@ -1219,28 +1045,26 @@ public: } }; -// ============================================================================ -// [X86Test_AllocSetz] -// ============================================================================ +// x86::Compiler - X86Test_AllocSetz +// ================================= -class X86Test_AllocSetz : public X86Test { +class X86Test_AllocSetz : public X86TestCase { public: - X86Test_AllocSetz() : X86Test("AllocSetz") {} + X86Test_AllocSetz() : X86TestCase("AllocSetz") {} - static void add(X86TestApp& app) { + static void add(TestApp& app) { app.add(new X86Test_AllocSetz()); } virtual void compile(x86::Compiler& cc) { - cc.addFunc(FuncSignatureT<void, int, int, char*>(CallConv::kIdHost)); - x86::Gp src0 = cc.newInt32("src0"); x86::Gp src1 = cc.newInt32("src1"); x86::Gp dst0 = cc.newIntPtr("dst0"); - cc.setArg(0, src0); - cc.setArg(1, src1); - cc.setArg(2, dst0); + FuncNode* funcNode = cc.addFunc(FuncSignatureT<void, int, int, char*>(CallConvId::kHost)); + funcNode->setArg(0, src0); + funcNode->setArg(1, src1); + funcNode->setArg(2, dst0); cc.cmp(src0, src1); cc.setz(x86::byte_ptr(dst0)); @@ -1270,34 +1094,31 @@ public: } }; -// ============================================================================ -// [X86Test_AllocShlRor] -// ============================================================================ +// x86::Compiler - X86Test_AllocShlRor +// =================================== -class X86Test_AllocShlRor : public X86Test { +class X86Test_AllocShlRor : public X86TestCase { public: - X86Test_AllocShlRor() : X86Test("AllocShlRor") {} + X86Test_AllocShlRor() : X86TestCase("AllocShlRor") {} - static void add(X86TestApp& app) { + static void add(TestApp& app) { app.add(new X86Test_AllocShlRor()); } virtual void compile(x86::Compiler& cc) { - cc.addFunc(FuncSignatureT<void, int*, int, int, int>(CallConv::kIdHost)); - x86::Gp dst = cc.newIntPtr("dst"); x86::Gp var = cc.newInt32("var"); x86::Gp vShlParam = cc.newInt32("vShlParam"); x86::Gp vRorParam = cc.newInt32("vRorParam"); - cc.setArg(0, dst); - cc.setArg(1, var); - cc.setArg(2, vShlParam); - cc.setArg(3, vRorParam); + FuncNode* funcNode = cc.addFunc(FuncSignatureT<void, int*, int, int, int>(CallConvId::kHost)); + funcNode->setArg(0, dst); + funcNode->setArg(1, var); + funcNode->setArg(2, vShlParam); + funcNode->setArg(3, vRorParam); cc.shl(var, vShlParam); cc.ror(var, vRorParam); - cc.mov(x86::dword_ptr(dst), var); cc.endFunc(); } @@ -1320,41 +1141,37 @@ public: } }; -// ============================================================================ -// [X86Test_AllocGpbLo] -// ============================================================================ +// x86::Compiler - X86Test_AllocGpbLo +// ================================== -class X86Test_AllocGpbLo1 : public X86Test { +class X86Test_AllocGpbLo1 : public X86TestCase { public: - X86Test_AllocGpbLo1() : X86Test("AllocGpbLo1") {} + X86Test_AllocGpbLo1() : X86TestCase("AllocGpbLo1") {} - enum { kCount = 32 }; + enum : uint32_t { kCount = 32 }; - static void add(X86TestApp& app) { + static void add(TestApp& app) { app.add(new X86Test_AllocGpbLo1()); } virtual void compile(x86::Compiler& cc) { - cc.addFunc(FuncSignatureT<uint32_t, uint32_t*>(CallConv::kIdHost)); - x86::Gp rPtr = cc.newUIntPtr("rPtr"); x86::Gp rSum = cc.newUInt32("rSum"); - - cc.setArg(0, rPtr); - x86::Gp x[kCount]; - uint32_t i; - for (i = 0; i < kCount; i++) { + FuncNode* funcNode = cc.addFunc(FuncSignatureT<uint32_t, uint32_t*>(CallConvId::kHost)); + funcNode->setArg(0, rPtr); + + for (uint32_t i = 0; i < kCount; i++) { x[i] = cc.newUInt32("x%u", i); } // Init pseudo-regs with values from our array. - for (i = 0; i < kCount; i++) { + for (uint32_t i = 0; i < kCount; i++) { cc.mov(x[i], x86::dword_ptr(rPtr, int(i * 4))); } - for (i = 2; i < kCount; i++) { + for (uint32_t i = 2; i < kCount; i++) { // Add and truncate to 8 bit; no purpose, just mess with jit. cc.add (x[i ], x[i-1]); cc.movzx(x[i ], x[i ].r8()); @@ -1364,7 +1181,7 @@ public: // Sum up all computed values. cc.mov(rSum, 0); - for (i = 0; i < kCount; i++) { + for (uint32_t i = 0; i < kCount; i++) { cc.add(rSum, x[i]); } @@ -1410,23 +1227,23 @@ public: } }; -// ============================================================================ -// [X86Test_AllocGpbLo2] -// ============================================================================ +// x86::Compiler - X86Test_AllocGpbLo2 +// =================================== -class X86Test_AllocGpbLo2 : public X86Test { +class X86Test_AllocGpbLo2 : public X86TestCase { public: - X86Test_AllocGpbLo2() : X86Test("AllocGpbLo2") {} + X86Test_AllocGpbLo2() : X86TestCase("AllocGpbLo2") {} - static void add(X86TestApp& app) { + static void add(TestApp& app) { app.add(new X86Test_AllocGpbLo2()); } virtual void compile(x86::Compiler& cc) { - cc.addFunc(FuncSignatureT<uint32_t, uint32_t>(CallConv::kIdHost)); - x86::Gp v = cc.newUInt32("v"); - cc.setArg(0, v); + + FuncNode* funcNode = cc.addFunc(FuncSignatureT<uint32_t, uint32_t>(CallConvId::kHost)); + funcNode->setArg(0, v); + cc.mov(v.r8(), 0xFF); cc.ret(v); cc.endFunc(); @@ -1446,28 +1263,26 @@ public: } }; -// ============================================================================ -// [X86Test_AllocRepMovsb] -// ============================================================================ +// x86::Compiler - X86Test_AllocRepMovsb +// ===================================== -class X86Test_AllocRepMovsb : public X86Test { +class X86Test_AllocRepMovsb : public X86TestCase { public: - X86Test_AllocRepMovsb() : X86Test("AllocRepMovsb") {} + X86Test_AllocRepMovsb() : X86TestCase("AllocRepMovsb") {} - static void add(X86TestApp& app) { + static void add(TestApp& app) { app.add(new X86Test_AllocRepMovsb()); } virtual void compile(x86::Compiler& cc) { - cc.addFunc(FuncSignatureT<void, void*, void*, size_t>(CallConv::kIdHost)); - x86::Gp dst = cc.newIntPtr("dst"); x86::Gp src = cc.newIntPtr("src"); x86::Gp cnt = cc.newIntPtr("cnt"); - cc.setArg(0, dst); - cc.setArg(1, src); - cc.setArg(2, cnt); + FuncNode* funcNode = cc.addFunc(FuncSignatureT<void, void*, void*, size_t>(CallConvId::kHost)); + funcNode->setArg(0, dst); + funcNode->setArg(1, src); + funcNode->setArg(2, cnt); cc.rep(cnt).movs(x86::byte_ptr(dst), x86::byte_ptr(src)); cc.endFunc(); @@ -1488,29 +1303,27 @@ public: } }; -// ============================================================================ -// [X86Test_AllocIfElse1] -// ============================================================================ +// x86::Compiler - X86Test_AllocIfElse1 +// ==================================== -class X86Test_AllocIfElse1 : public X86Test { +class X86Test_AllocIfElse1 : public X86TestCase { public: - X86Test_AllocIfElse1() : X86Test("AllocIfElse1") {} + X86Test_AllocIfElse1() : X86TestCase("AllocIfElse1") {} - static void add(X86TestApp& app) { + static void add(TestApp& app) { app.add(new X86Test_AllocIfElse1()); } virtual void compile(x86::Compiler& cc) { - cc.addFunc(FuncSignatureT<int, int, int>(CallConv::kIdHost)); - x86::Gp v1 = cc.newInt32("v1"); x86::Gp v2 = cc.newInt32("v2"); Label L_1 = cc.newLabel(); Label L_2 = cc.newLabel(); - cc.setArg(0, v1); - cc.setArg(1, v2); + FuncNode* funcNode = cc.addFunc(FuncSignatureT<int, int, int>(CallConvId::kHost)); + funcNode->setArg(0, v1); + funcNode->setArg(1, v2); cc.cmp(v1, v2); cc.jg(L_1); @@ -1540,21 +1353,18 @@ public: } }; -// ============================================================================ -// [X86Test_AllocIfElse2] -// ============================================================================ +// x86::Compiler - X86Test_AllocIfElse2 +// ==================================== -class X86Test_AllocIfElse2 : public X86Test { +class X86Test_AllocIfElse2 : public X86TestCase { public: - X86Test_AllocIfElse2() : X86Test("AllocIfElse2") {} + X86Test_AllocIfElse2() : X86TestCase("AllocIfElse2") {} - static void add(X86TestApp& app) { + static void add(TestApp& app) { app.add(new X86Test_AllocIfElse2()); } virtual void compile(x86::Compiler& cc) { - cc.addFunc(FuncSignatureT<int, int, int>(CallConv::kIdHost)); - x86::Gp v1 = cc.newInt32("v1"); x86::Gp v2 = cc.newInt32("v2"); @@ -1563,8 +1373,9 @@ public: Label L_3 = cc.newLabel(); Label L_4 = cc.newLabel(); - cc.setArg(0, v1); - cc.setArg(1, v2); + FuncNode* funcNode = cc.addFunc(FuncSignatureT<int, int, int>(CallConvId::kHost)); + funcNode->setArg(0, v1); + funcNode->setArg(1, v2); cc.jmp(L_1); cc.bind(L_2); @@ -1601,21 +1412,18 @@ public: } }; -// ============================================================================ -// [X86Test_AllocIfElse3] -// ============================================================================ +// x86::Compiler - X86Test_AllocIfElse3 +// ==================================== -class X86Test_AllocIfElse3 : public X86Test { +class X86Test_AllocIfElse3 : public X86TestCase { public: - X86Test_AllocIfElse3() : X86Test("AllocIfElse3") {} + X86Test_AllocIfElse3() : X86TestCase("AllocIfElse3") {} - static void add(X86TestApp& app) { + static void add(TestApp& app) { app.add(new X86Test_AllocIfElse3()); } virtual void compile(x86::Compiler& cc) { - cc.addFunc(FuncSignatureT<int, int, int>(CallConv::kIdHost)); - x86::Gp v1 = cc.newInt32("v1"); x86::Gp v2 = cc.newInt32("v2"); x86::Gp counter = cc.newInt32("counter"); @@ -1624,8 +1432,9 @@ public: Label L_Loop = cc.newLabel(); Label L_Exit = cc.newLabel(); - cc.setArg(0, v1); - cc.setArg(1, v2); + FuncNode* funcNode = cc.addFunc(FuncSignatureT<int, int, int>(CallConvId::kHost)); + funcNode->setArg(0, v1); + funcNode->setArg(1, v2); cc.cmp(v1, v2); cc.jg(L_1); @@ -1662,21 +1471,18 @@ public: } }; -// ============================================================================ -// [X86Test_AllocIfElse4] -// ============================================================================ +// x86::Compiler - X86Test_AllocIfElse4 +// ==================================== -class X86Test_AllocIfElse4 : public X86Test { +class X86Test_AllocIfElse4 : public X86TestCase { public: - X86Test_AllocIfElse4() : X86Test("AllocIfElse4") {} + X86Test_AllocIfElse4() : X86TestCase("AllocIfElse4") {} - static void add(X86TestApp& app) { + static void add(TestApp& app) { app.add(new X86Test_AllocIfElse4()); } virtual void compile(x86::Compiler& cc) { - cc.addFunc(FuncSignatureT<int, int, int>(CallConv::kIdHost)); - x86::Gp v1 = cc.newInt32("v1"); x86::Gp v2 = cc.newInt32("v2"); x86::Gp counter = cc.newInt32("counter"); @@ -1686,11 +1492,11 @@ public: Label L_Loop2 = cc.newLabel(); Label L_Exit = cc.newLabel(); - cc.mov(counter, 0); - - cc.setArg(0, v1); - cc.setArg(1, v2); + FuncNode* funcNode = cc.addFunc(FuncSignatureT<int, int, int>(CallConvId::kHost)); + funcNode->setArg(0, v1); + funcNode->setArg(1, v2); + cc.mov(counter, 0); cc.cmp(v1, v2); cc.jg(L_1); @@ -1728,15 +1534,14 @@ public: } }; -// ============================================================================ -// [X86Test_AllocInt8] -// ============================================================================ +// x86::Compiler - X86Test_AllocInt8 +// ================================= -class X86Test_AllocInt8 : public X86Test { +class X86Test_AllocInt8 : public X86TestCase { public: - X86Test_AllocInt8() : X86Test("AllocInt8") {} + X86Test_AllocInt8() : X86TestCase("AllocInt8") {} - static void add(X86TestApp& app) { + static void add(TestApp& app) { app.add(new X86Test_AllocInt8()); } @@ -1744,8 +1549,8 @@ public: x86::Gp x = cc.newInt8("x"); x86::Gp y = cc.newInt32("y"); - cc.addFunc(FuncSignatureT<int, char>(CallConv::kIdHost)); - cc.setArg(0, x); + FuncNode* funcNode = cc.addFunc(FuncSignatureT<int, char>(CallConvId::kHost)); + funcNode->setArg(0, x); cc.movsx(y, x); @@ -1767,25 +1572,24 @@ public: } }; -// ============================================================================ -// [X86Test_AllocUnhandledArg] -// ============================================================================ +// x86::Compiler - X86Test_AllocUnhandledArg +// ========================================= -class X86Test_AllocUnhandledArg : public X86Test { +class X86Test_AllocUnhandledArg : public X86TestCase { public: - X86Test_AllocUnhandledArg() : X86Test("AllocUnhandledArg") {} + X86Test_AllocUnhandledArg() : X86TestCase("AllocUnhandledArg") {} - static void add(X86TestApp& app) { + static void add(TestApp& app) { app.add(new X86Test_AllocUnhandledArg()); } virtual void compile(x86::Compiler& cc) { - cc.addFunc(FuncSignatureT<int, int, int, int>(CallConv::kIdHost)); - x86::Gp x = cc.newInt32("x"); - cc.setArg(2, x); - cc.ret(x); + FuncNode* funcNode = cc.addFunc(FuncSignatureT<int, int, int, int>(CallConvId::kHost)); + funcNode->setArg(2, x); + + cc.ret(x); cc.endFunc(); } @@ -1803,36 +1607,33 @@ public: } }; -// ============================================================================ -// [X86Test_AllocArgsIntPtr] -// ============================================================================ +// x86::Compiler - X86Test_AllocArgsIntPtr +// ======================================= -class X86Test_AllocArgsIntPtr : public X86Test { +class X86Test_AllocArgsIntPtr : public X86TestCase { public: - X86Test_AllocArgsIntPtr() : X86Test("AllocArgsIntPtr") {} + X86Test_AllocArgsIntPtr() : X86TestCase("AllocArgsIntPtr") {} - static void add(X86TestApp& app) { + static void add(TestApp& app) { app.add(new X86Test_AllocArgsIntPtr()); } virtual void compile(x86::Compiler& cc) { - cc.addFunc(FuncSignatureT<void, void*, void*, void*, void*, void*, void*, void*, void*>(CallConv::kIdHost)); - - uint32_t i; + FuncNode* funcNode = cc.addFunc(FuncSignatureT<void, void*, void*, void*, void*, void*, void*, void*, void*>(CallConvId::kHost)); x86::Gp var[8]; - for (i = 0; i < 8; i++) { + for (uint32_t i = 0; i < 8; i++) { var[i] = cc.newIntPtr("var%u", i); - cc.setArg(i, var[i]); + funcNode->setArg(i, var[i]); } - for (i = 0; i < 8; i++) { + for (uint32_t i = 0; i < 8; i++) { cc.add(var[i], int(i + 1)); } // Move some data into buffer provided by arguments so we can verify if it // really works without looking into assembler output. - for (i = 0; i < 8; i++) { + for (uint32_t i = 0; i < 8; i++) { cc.add(x86::byte_ptr(var[i]), int(i + 1)); } @@ -1862,32 +1663,29 @@ public: } }; -// ============================================================================ -// [X86Test_AllocArgsFloat] -// ============================================================================ +// x86::Compiler - X86Test_AllocArgsFloat +// ====================================== -class X86Test_AllocArgsFloat : public X86Test { +class X86Test_AllocArgsFloat : public X86TestCase { public: - X86Test_AllocArgsFloat() : X86Test("AllocArgsFloat") {} + X86Test_AllocArgsFloat() : X86TestCase("AllocArgsFloat") {} - static void add(X86TestApp& app) { + static void add(TestApp& app) { app.add(new X86Test_AllocArgsFloat()); } virtual void compile(x86::Compiler& cc) { - cc.addFunc(FuncSignatureT<void, float, float, float, float, float, float, float, void*>(CallConv::kIdHost)); - - uint32_t i; + FuncNode* funcNode = cc.addFunc(FuncSignatureT<void, float, float, float, float, float, float, float, void*>(CallConvId::kHost)); x86::Gp p = cc.newIntPtr("p"); x86::Xmm xv[7]; - for (i = 0; i < 7; i++) { + for (uint32_t i = 0; i < 7; i++) { xv[i] = cc.newXmmSs("xv%u", i); - cc.setArg(i, xv[i]); + funcNode->setArg(i, xv[i]); } - cc.setArg(7, p); + funcNode->setArg(7, p); cc.addss(xv[0], xv[1]); cc.addss(xv[0], xv[2]); @@ -1916,32 +1714,29 @@ public: } }; -// ============================================================================ -// [X86Test_AllocArgsDouble] -// ============================================================================ +// x86::Compiler - X86Test_AllocArgsDouble +// ======================================= -class X86Test_AllocArgsDouble : public X86Test { +class X86Test_AllocArgsDouble : public X86TestCase { public: - X86Test_AllocArgsDouble() : X86Test("AllocArgsDouble") {} + X86Test_AllocArgsDouble() : X86TestCase("AllocArgsDouble") {} - static void add(X86TestApp& app) { + static void add(TestApp& app) { app.add(new X86Test_AllocArgsDouble()); } virtual void compile(x86::Compiler& cc) { - cc.addFunc(FuncSignatureT<void, double, double, double, double, double, double, double, void*>(CallConv::kIdHost)); - - uint32_t i; + FuncNode* funcNode = cc.addFunc(FuncSignatureT<void, double, double, double, double, double, double, double, void*>(CallConvId::kHost)); x86::Gp p = cc.newIntPtr("p"); x86::Xmm xv[7]; - for (i = 0; i < 7; i++) { + for (uint32_t i = 0; i < 7; i++) { xv[i] = cc.newXmmSd("xv%u", i); - cc.setArg(i, xv[i]); + funcNode->setArg(i, xv[i]); } - cc.setArg(7, p); + funcNode->setArg(7, p); cc.addsd(xv[0], xv[1]); cc.addsd(xv[0], xv[2]); @@ -1970,29 +1765,29 @@ public: } }; -// ============================================================================ -// [X86Test_AllocArgsVec] -// ============================================================================ +// x86::Compiler - X86Test_AllocArgsVec +// ==================================== -class X86Test_AllocArgsVec : public X86Test { +class X86Test_AllocArgsVec : public X86TestCase { public: - X86Test_AllocArgsVec() : X86Test("AllocArgsVec") {} + X86Test_AllocArgsVec() : X86TestCase("AllocArgsVec") {} - static void add(X86TestApp& app) { + static void add(TestApp& app) { // Not supported on Windows. #ifndef _WIN32 app.add(new X86Test_AllocArgsVec()); +#else + DebugUtils::unused(app); #endif } virtual void compile(x86::Compiler& cc) { - cc.addFunc(FuncSignatureT<x86::Xmm, x86::Xmm, x86::Xmm>(CallConv::kIdHost)); - x86::Xmm a = cc.newXmm("aXmm"); x86::Xmm b = cc.newXmm("bXmm"); - cc.setArg(0, a); - cc.setArg(1, b); + FuncNode* funcNode = cc.addFunc(FuncSignatureT<x86::Xmm, x86::Xmm, x86::Xmm>(CallConvId::kHost)); + funcNode->setArg(0, a); + funcNode->setArg(1, b); cc.paddb(a, b); cc.ret(a); @@ -2023,25 +1818,24 @@ public: } }; -// ============================================================================ -// [X86Test_AllocRetFloat1] -// ============================================================================ +// x86::Compiler - X86Test_AllocRetFloat1 +// ====================================== -class X86Test_AllocRetFloat1 : public X86Test { +class X86Test_AllocRetFloat1 : public X86TestCase { public: - X86Test_AllocRetFloat1() : X86Test("AllocRetFloat1") {} + X86Test_AllocRetFloat1() : X86TestCase("AllocRetFloat1") {} - static void add(X86TestApp& app) { + static void add(TestApp& app) { app.add(new X86Test_AllocRetFloat1()); } virtual void compile(x86::Compiler& cc) { - cc.addFunc(FuncSignatureT<float, float>(CallConv::kIdHost)); - x86::Xmm x = cc.newXmmSs("x"); - cc.setArg(0, x); - cc.ret(x); + FuncNode* funcNode = cc.addFunc(FuncSignatureT<float, float>(CallConvId::kHost)); + funcNode->setArg(0, x); + + cc.ret(x); cc.endFunc(); } @@ -2059,26 +1853,24 @@ public: } }; -// ============================================================================ -// [X86Test_AllocRetFloat2] -// ============================================================================ +// x86::Compiler - X86Test_AllocRetFloat2 +// ====================================== -class X86Test_AllocRetFloat2 : public X86Test { +class X86Test_AllocRetFloat2 : public X86TestCase { public: - X86Test_AllocRetFloat2() : X86Test("AllocRetFloat2") {} + X86Test_AllocRetFloat2() : X86TestCase("AllocRetFloat2") {} - static void add(X86TestApp& app) { + static void add(TestApp& app) { app.add(new X86Test_AllocRetFloat2()); } virtual void compile(x86::Compiler& cc) { - cc.addFunc(FuncSignatureT<float, float, float>(CallConv::kIdHost)); - x86::Xmm x = cc.newXmmSs("x"); x86::Xmm y = cc.newXmmSs("y"); - cc.setArg(0, x); - cc.setArg(1, y); + FuncNode* funcNode = cc.addFunc(FuncSignatureT<float, float, float>(CallConvId::kHost)); + funcNode->setArg(0, x); + funcNode->setArg(1, y); cc.addss(x, y); cc.ret(x); @@ -2100,25 +1892,24 @@ public: } }; -// ============================================================================ -// [X86Test_AllocRetDouble1] -// ============================================================================ +// x86::Compiler - X86Test_AllocRetDouble1 +// ======================================= -class X86Test_AllocRetDouble1 : public X86Test { +class X86Test_AllocRetDouble1 : public X86TestCase { public: - X86Test_AllocRetDouble1() : X86Test("AllocRetDouble1") {} + X86Test_AllocRetDouble1() : X86TestCase("AllocRetDouble1") {} - static void add(X86TestApp& app) { + static void add(TestApp& app) { app.add(new X86Test_AllocRetDouble1()); } virtual void compile(x86::Compiler& cc) { - cc.addFunc(FuncSignatureT<double, double>(CallConv::kIdHost)); - x86::Xmm x = cc.newXmmSd("x"); - cc.setArg(0, x); - cc.ret(x); + FuncNode* funcNode = cc.addFunc(FuncSignatureT<double, double>(CallConvId::kHost)); + funcNode->setArg(0, x); + + cc.ret(x); cc.endFunc(); } @@ -2135,26 +1926,25 @@ public: return resultRet == expectRet; } }; -// ============================================================================ -// [X86Test_AllocRetDouble2] -// ============================================================================ -class X86Test_AllocRetDouble2 : public X86Test { +// x86::Compiler - X86Test_AllocRetDouble2 +// ======================================= + +class X86Test_AllocRetDouble2 : public X86TestCase { public: - X86Test_AllocRetDouble2() : X86Test("AllocRetDouble2") {} + X86Test_AllocRetDouble2() : X86TestCase("AllocRetDouble2") {} - static void add(X86TestApp& app) { + static void add(TestApp& app) { app.add(new X86Test_AllocRetDouble2()); } virtual void compile(x86::Compiler& cc) { - cc.addFunc(FuncSignatureT<double, double, double>(CallConv::kIdHost)); - x86::Xmm x = cc.newXmmSd("x"); x86::Xmm y = cc.newXmmSd("y"); - cc.setArg(0, x); - cc.setArg(1, y); + FuncNode* funcNode = cc.addFunc(FuncSignatureT<double, double, double>(CallConvId::kHost)); + funcNode->setArg(0, x); + funcNode->setArg(1, y); cc.addsd(x, y); cc.ret(x); @@ -2176,22 +1966,21 @@ public: } }; -// ============================================================================ -// [X86Test_AllocStack] -// ============================================================================ +// x86::Compiler - X86Test_AllocStack +// ================================== -class X86Test_AllocStack : public X86Test { +class X86Test_AllocStack : public X86TestCase { public: - X86Test_AllocStack() : X86Test("AllocStack") {} + X86Test_AllocStack() : X86TestCase("AllocStack") {} enum { kSize = 256 }; - static void add(X86TestApp& app) { + static void add(TestApp& app) { app.add(new X86Test_AllocStack()); } virtual void compile(x86::Compiler& cc) { - cc.addFunc(FuncSignatureT<int>(CallConv::kIdHost)); + cc.addFunc(FuncSignatureT<int>(CallConvId::kHost)); x86::Mem stack = cc.newStack(kSize, 1); stack.setSize(1); @@ -2244,17 +2033,16 @@ public: } }; -// ============================================================================ -// [X86Test_AllocMemcpy] -// ============================================================================ +// x86::Compiler - X86Test_AllocMemcpy +// =================================== -class X86Test_AllocMemcpy : public X86Test { +class X86Test_AllocMemcpy : public X86TestCase { public: - X86Test_AllocMemcpy() : X86Test("AllocMemcpy") {} + X86Test_AllocMemcpy() : X86TestCase("AllocMemcpy") {} enum { kCount = 32 }; - static void add(X86TestApp& app) { + static void add(TestApp& app) { app.add(new X86Test_AllocMemcpy()); } @@ -2266,10 +2054,10 @@ public: Label L_Loop = cc.newLabel(); // Create base labels we use Label L_Exit = cc.newLabel(); // in our function. - cc.addFunc(FuncSignatureT<void, uint32_t*, const uint32_t*, size_t>(CallConv::kIdHost)); - cc.setArg(0, dst); - cc.setArg(1, src); - cc.setArg(2, cnt); + FuncNode* funcNode = cc.addFunc(FuncSignatureT<void, uint32_t*, const uint32_t*, size_t>(CallConvId::kHost)); + funcNode->setArg(0, dst); + funcNode->setArg(1, src); + funcNode->setArg(2, cnt); cc.test(cnt, cnt); // Exit if the size is zero. cc.jz(L_Exit); @@ -2326,15 +2114,14 @@ public: } }; -// ============================================================================ -// [X86Test_AllocExtraBlock] -// ============================================================================ +// x86::Compiler - X86Test_AllocExtraBlock +// ======================================= -class X86Test_AllocExtraBlock : public X86Test { +class X86Test_AllocExtraBlock : public X86TestCase { public: - X86Test_AllocExtraBlock() : X86Test("AllocExtraBlock") {} + X86Test_AllocExtraBlock() : X86TestCase("AllocExtraBlock") {} - static void add(X86TestApp& app) { + static void add(TestApp& app) { app.add(new X86Test_AllocExtraBlock()); } @@ -2344,10 +2131,10 @@ public: x86::Gp a = cc.newInt32("a"); x86::Gp b = cc.newInt32("b"); - cc.addFunc(FuncSignatureT<int, int, int, int>(CallConv::kIdHost)); - cc.setArg(0, cond); - cc.setArg(1, a); - cc.setArg(2, b); + FuncNode* funcNode = cc.addFunc(FuncSignatureT<int, int, int, int>(CallConvId::kHost)); + funcNode->setArg(0, cond); + funcNode->setArg(1, a); + funcNode->setArg(2, b); Label L_Ret = cc.newLabel(); Label L_Extra = cc.newLabel(); @@ -2362,7 +2149,7 @@ public: cc.ret(ret); // Emit code sequence at the end of the function. - BaseNode* prevCursor = cc.setCursor(cc.func()->endNode()->prev()); + BaseNode* prevCursor = cc.setCursor(funcNode->endNode()->prev()); cc.bind(L_Extra); cc.mov(ret, a); cc.sub(ret, b); @@ -2389,17 +2176,16 @@ public: } }; -// ============================================================================ -// [X86Test_AllocAlphaBlend] -// ============================================================================ +// x86::Compiler - X86Test_AllocAlphaBlend +// ======================================= -class X86Test_AllocAlphaBlend : public X86Test { +class X86Test_AllocAlphaBlend : public X86TestCase { public: - X86Test_AllocAlphaBlend() : X86Test("AllocAlphaBlend") {} + X86Test_AllocAlphaBlend() : X86TestCase("AllocAlphaBlend") {} enum { kCount = 17 }; - static void add(X86TestApp& app) { + static void add(TestApp& app) { app.add(new X86Test_AllocAlphaBlend()); } @@ -2419,7 +2205,7 @@ public: } virtual void compile(x86::Compiler& cc) { - asmtest::generateAlphaBlend(cc); + asmtest::generateSseAlphaBlend(cc, true); } virtual bool run(void* _func, String& result, String& expect) { @@ -2468,15 +2254,14 @@ public: } }; -// ============================================================================ -// [X86Test_FuncCallBase1] -// ============================================================================ +// x86::Compiler - X86Test_FuncCallBase1 +// ===================================== -class X86Test_FuncCallBase1 : public X86Test { +class X86Test_FuncCallBase1 : public X86TestCase { public: - X86Test_FuncCallBase1() : X86Test("FuncCallBase1") {} + X86Test_FuncCallBase1() : X86TestCase("FuncCallBase1") {} - static void add(X86TestApp& app) { + static void add(TestApp& app) { app.add(new X86Test_FuncCallBase1()); } @@ -2485,10 +2270,10 @@ public: x86::Gp v1 = cc.newInt32("v1"); x86::Gp v2 = cc.newInt32("v2"); - cc.addFunc(FuncSignatureT<int, int, int, int>(CallConv::kIdHost)); - cc.setArg(0, v0); - cc.setArg(1, v1); - cc.setArg(2, v2); + FuncNode* funcNode = cc.addFunc(FuncSignatureT<int, int, int, int>(CallConvId::kHost)); + funcNode->setArg(0, v0); + funcNode->setArg(1, v1); + funcNode->setArg(2, v2); // Just do something. cc.shl(v0, 1); @@ -2497,7 +2282,7 @@ public: // Call a function. InvokeNode* invokeNode; - cc.invoke(&invokeNode, imm((void*)calledFunc), FuncSignatureT<int, int, int, int>(CallConv::kIdHost)); + cc.invoke(&invokeNode, imm((void*)calledFunc), FuncSignatureT<int, int, int, int>(CallConvId::kHost)); invokeNode->setArg(0, v2); invokeNode->setArg(1, v1); invokeNode->setArg(2, v0); @@ -2523,22 +2308,21 @@ public: static int calledFunc(int a, int b, int c) { return (a + b) * c; } }; -// ============================================================================ -// [X86Test_FuncCallBase2] -// ============================================================================ +// x86::Compiler - X86Test_FuncCallBase2 +// ===================================== -class X86Test_FuncCallBase2 : public X86Test { +class X86Test_FuncCallBase2 : public X86TestCase { public: - X86Test_FuncCallBase2() : X86Test("FuncCallBase2") {} + X86Test_FuncCallBase2() : X86TestCase("FuncCallBase2") {} enum { kSize = 256 }; - static void add(X86TestApp& app) { + static void add(TestApp& app) { app.add(new X86Test_FuncCallBase2()); } virtual void compile(x86::Compiler& cc) { - cc.addFunc(FuncSignatureT<int>(CallConv::kIdHost)); + cc.addFunc(FuncSignatureT<int>(CallConvId::kHost)); const int kTokenSize = 32; @@ -2558,19 +2342,19 @@ public: cc.lea(p2, s2); // Try to corrupt the stack if wrongly allocated. - cc.invoke(&invokeNode, imm((void*)memcpy), FuncSignatureT<void*, void*, void*, size_t>(CallConv::kIdCDecl)); + cc.invoke(&invokeNode, imm((void*)memcpy), FuncSignatureT<void*, void*, void*, size_t>(CallConvId::kCDecl)); invokeNode->setArg(0, p1); invokeNode->setArg(1, imm(token)); invokeNode->setArg(2, imm(kTokenSize)); invokeNode->setRet(0, p1); - cc.invoke(&invokeNode, imm((void*)memcpy), FuncSignatureT<void*, void*, void*, size_t>(CallConv::kIdCDecl)); + cc.invoke(&invokeNode, imm((void*)memcpy), FuncSignatureT<void*, void*, void*, size_t>(CallConvId::kCDecl)); invokeNode->setArg(0, p2); invokeNode->setArg(1, imm(token)); invokeNode->setArg(2, imm(kTokenSize)); invokeNode->setRet(0, p2); - cc.invoke(&invokeNode, imm((void*)memcmp), FuncSignatureT<int, void*, void*, size_t>(CallConv::kIdCDecl)); + cc.invoke(&invokeNode, imm((void*)memcmp), FuncSignatureT<int, void*, void*, size_t>(CallConvId::kCDecl)); invokeNode->setArg(0, p1); invokeNode->setArg(1, p2); invokeNode->setArg(2, imm(kTokenSize)); @@ -2605,15 +2389,14 @@ public: } }; -// ============================================================================ -// [X86Test_FuncCallStd] -// ============================================================================ +// x86::Compiler - X86Test_FuncCallStd +// =================================== -class X86Test_FuncCallStd : public X86Test { +class X86Test_FuncCallStd : public X86TestCase { public: - X86Test_FuncCallStd() : X86Test("FuncCallStd") {} + X86Test_FuncCallStd() : X86TestCase("FuncCallStd") {} - static void add(X86TestApp& app) { + static void add(TestApp& app) { app.add(new X86Test_FuncCallStd()); } @@ -2622,15 +2405,15 @@ public: x86::Gp y = cc.newInt32("y"); x86::Gp z = cc.newInt32("z"); - cc.addFunc(FuncSignatureT<int, int, int, int>(CallConv::kIdHost)); - cc.setArg(0, x); - cc.setArg(1, y); - cc.setArg(2, z); + FuncNode* funcNode = cc.addFunc(FuncSignatureT<int, int, int, int>(CallConvId::kHost)); + funcNode->setArg(0, x); + funcNode->setArg(1, y); + funcNode->setArg(2, z); InvokeNode* invokeNode; cc.invoke(&invokeNode, imm((void*)calledFunc), - FuncSignatureT<int, int, int, int>(CallConv::kIdStdCall)); + FuncSignatureT<int, int, int, int>(CallConvId::kStdCall)); invokeNode->setArg(0, x); invokeNode->setArg(1, y); invokeNode->setArg(2, z); @@ -2659,31 +2442,30 @@ public: } }; -// ============================================================================ -// [X86Test_FuncCallFast] -// ============================================================================ +// x86::Compiler - X86Test_FuncCallFast +// ==================================== -class X86Test_FuncCallFast : public X86Test { +class X86Test_FuncCallFast : public X86TestCase { public: - X86Test_FuncCallFast() : X86Test("FuncCallFast") {} + X86Test_FuncCallFast() : X86TestCase("FuncCallFast") {} - static void add(X86TestApp& app) { + static void add(TestApp& app) { app.add(new X86Test_FuncCallFast()); } virtual void compile(x86::Compiler& cc) { x86::Gp var = cc.newInt32("var"); - cc.addFunc(FuncSignatureT<int, int>(CallConv::kIdHost)); - cc.setArg(0, var); + FuncNode* funcNode = cc.addFunc(FuncSignatureT<int, int>(CallConvId::kHost)); + funcNode->setArg(0, var); InvokeNode* invokeNode; - cc.invoke(&invokeNode, imm((void*)calledFunc), FuncSignatureT<int, int>(CallConv::kIdFastCall)); + cc.invoke(&invokeNode, imm((void*)calledFunc), FuncSignatureT<int, int>(CallConvId::kFastCall)); invokeNode->setArg(0, var); invokeNode->setRet(0, var); - cc.invoke(&invokeNode, imm((void*)calledFunc), FuncSignatureT<int, int>(CallConv::kIdFastCall)); + cc.invoke(&invokeNode, imm((void*)calledFunc), FuncSignatureT<int, int>(CallConvId::kFastCall)); invokeNode->setArg(0, var); invokeNode->setRet(0, var); @@ -2710,21 +2492,20 @@ public: } }; -// ============================================================================ -// [X86Test_FuncCallSIMD] -// ============================================================================ +// x86::Compiler - X86Test_FuncCallSIMD +// ==================================== -class X86Test_FuncCallSIMD : public X86Test { +class X86Test_FuncCallSIMD : public X86TestCase { public: bool _useVectorCall; X86Test_FuncCallSIMD(bool useVectorCall) - : X86Test(), + : X86TestCase(), _useVectorCall(useVectorCall) { _name.assignFormat("FuncCallSIMD {%s}", _useVectorCall ? "__vectorcall" : "__cdecl"); } - static void add(X86TestApp& app) { + static void add(TestApp& app) { app.add(new X86Test_FuncCallSIMD(false)); #ifdef _MSC_VER app.add(new X86Test_FuncCallSIMD(true)); @@ -2732,7 +2513,7 @@ public: } virtual void compile(x86::Compiler& cc) { - cc.addFunc(FuncSignatureT<void, void*, const void*, const void*>(CallConv::kIdHost)); + FuncNode* funcNode = cc.addFunc(FuncSignatureT<void, void*, const void*, const void*>(CallConvId::kHost)); x86::Gp resultPtr = cc.newIntPtr("resultPtr"); x86::Gp aPtr = cc.newIntPtr("aPtr"); @@ -2742,16 +2523,16 @@ public: x86::Xmm aXmm = cc.newXmm("aXmm"); x86::Xmm bXmm = cc.newXmm("bXmm"); - cc.setArg(0, resultPtr); - cc.setArg(1, aPtr); - cc.setArg(2, bPtr); + funcNode->setArg(0, resultPtr); + funcNode->setArg(1, aPtr); + funcNode->setArg(2, bPtr); - uint32_t ccId = CallConv::kIdCDecl; + CallConvId ccId = CallConvId::kCDecl; Imm pFnImm = imm((void*)calledFunc_cdecl); #ifdef _MSC_VER if (_useVectorCall) { - ccId = CallConv::kIdVectorCall; + ccId = CallConvId::kVectorCall; pFnImm = imm((void*)calledFunc_vcall); } #endif @@ -2801,24 +2582,23 @@ public: #endif }; -// ============================================================================ -// [X86Test_FuncCallLight] -// ============================================================================ +// x86::Compiler - X86Test_FuncCallLight +// ===================================== -class X86Test_FuncCallLight : public X86Test { +class X86Test_FuncCallLight : public X86TestCase { public: - X86Test_FuncCallLight() : X86Test("FuncCallLight") {} + X86Test_FuncCallLight() : X86TestCase("FuncCallLight") {} - static void add(X86TestApp& app) { + static void add(TestApp& app) { app.add(new X86Test_FuncCallLight()); } virtual void compile(x86::Compiler& cc) { - FuncSignatureT<void, const void*, const void*, const void*, const void*, void*> funcSig(CallConv::kIdCDecl); - FuncSignatureT<x86::Xmm, x86::Xmm, x86::Xmm> fastSig(CallConv::kIdLightCall2); + FuncSignatureT<void, const void*, const void*, const void*, const void*, void*> f1Sig(CallConvId::kCDecl); + FuncSignatureT<x86::Xmm, x86::Xmm, x86::Xmm> f2Sig(CallConvId::kLightCall2); - FuncNode* func = cc.newFunc(funcSig); - FuncNode* fast = cc.newFunc(fastSig); + FuncNode* f1Node = cc.newFunc(f1Sig); + FuncNode* f2Node = cc.newFunc(f2Sig); { x86::Gp aPtr = cc.newIntPtr("aPtr"); @@ -2832,13 +2612,12 @@ public: x86::Xmm cXmm = cc.newXmm("cXmm"); x86::Xmm dXmm = cc.newXmm("dXmm"); - cc.addFunc(func); - - cc.setArg(0, aPtr); - cc.setArg(1, bPtr); - cc.setArg(2, cPtr); - cc.setArg(3, dPtr); - cc.setArg(4, pOut); + cc.addFunc(f1Node); + f1Node->setArg(0, aPtr); + f1Node->setArg(1, bPtr); + f1Node->setArg(2, cPtr); + f1Node->setArg(3, dPtr); + f1Node->setArg(4, pOut); cc.movups(aXmm, x86::ptr(aPtr)); cc.movups(bXmm, x86::ptr(bPtr)); @@ -2850,12 +2629,12 @@ public: InvokeNode* invokeNode; - cc.invoke(&invokeNode, fast->label(), fastSig); + cc.invoke(&invokeNode, f2Node->label(), f2Sig); invokeNode->setArg(0, aXmm); invokeNode->setArg(1, bXmm); invokeNode->setRet(0, xXmm); - cc.invoke(&invokeNode, fast->label(), fastSig); + cc.invoke(&invokeNode, f2Node->label(), f2Sig); invokeNode->setArg(0, cXmm); invokeNode->setArg(1, dXmm); invokeNode->setRet(0, yXmm); @@ -2870,9 +2649,9 @@ public: x86::Xmm aXmm = cc.newXmm("aXmm"); x86::Xmm bXmm = cc.newXmm("bXmm"); - cc.addFunc(fast); - cc.setArg(0, aXmm); - cc.setArg(1, bXmm); + cc.addFunc(f2Node); + f2Node->setArg(0, aXmm); + f2Node->setArg(1, bXmm); cc.paddw(aXmm, bXmm); cc.ret(aXmm); cc.endFunc(); @@ -2901,15 +2680,14 @@ public: } }; -// ============================================================================ -// [X86Test_FuncCallManyArgs] -// ============================================================================ +// x86::Compiler - X86Test_FuncCallManyArgs +// ======================================== -class X86Test_FuncCallManyArgs : public X86Test { +class X86Test_FuncCallManyArgs : public X86TestCase { public: - X86Test_FuncCallManyArgs() : X86Test("FuncCallManyArgs") {} + X86Test_FuncCallManyArgs() : X86TestCase("FuncCallManyArgs") {} - static void add(X86TestApp& app) { + static void add(TestApp& app) { app.add(new X86Test_FuncCallManyArgs()); } @@ -2918,7 +2696,7 @@ public: } virtual void compile(x86::Compiler& cc) { - cc.addFunc(FuncSignatureT<int>(CallConv::kIdHost)); + cc.addFunc(FuncSignatureT<int>(CallConvId::kHost)); // Prepare. x86::Gp va = cc.newInt32("va"); @@ -2947,7 +2725,7 @@ public: InvokeNode* invokeNode; cc.invoke(&invokeNode, imm((void*)calledFunc), - FuncSignatureT<int, int, int, int, int, int, int, int, int, int, int>(CallConv::kIdHost)); + FuncSignatureT<int, int, int, int, int, int, int, int, int, int, int>(CallConvId::kHost)); invokeNode->setArg(0, va); invokeNode->setArg(1, vb); invokeNode->setArg(2, vc); @@ -2978,15 +2756,14 @@ public: } }; -// ============================================================================ -// [X86Test_FuncCallDuplicateArgs] -// ============================================================================ +// x86::Compiler - X86Test_FuncCallDuplicateArgs +// ============================================= -class X86Test_FuncCallDuplicateArgs : public X86Test { +class X86Test_FuncCallDuplicateArgs : public X86TestCase { public: - X86Test_FuncCallDuplicateArgs() : X86Test("FuncCallDuplicateArgs") {} + X86Test_FuncCallDuplicateArgs() : X86TestCase("FuncCallDuplicateArgs") {} - static void add(X86TestApp& app) { + static void add(TestApp& app) { app.add(new X86Test_FuncCallDuplicateArgs()); } @@ -2995,7 +2772,7 @@ public: } virtual void compile(x86::Compiler& cc) { - cc.addFunc(FuncSignatureT<int>(CallConv::kIdHost)); + cc.addFunc(FuncSignatureT<int>(CallConvId::kHost)); // Prepare. x86::Gp a = cc.newInt32("a"); @@ -3005,7 +2782,7 @@ public: InvokeNode* invokeNode; cc.invoke(&invokeNode, imm((void*)calledFunc), - FuncSignatureT<int, int, int, int, int, int, int, int, int, int, int>(CallConv::kIdHost)); + FuncSignatureT<int, int, int, int, int, int, int, int, int, int, int>(CallConvId::kHost)); invokeNode->setArg(0, a); invokeNode->setArg(1, a); invokeNode->setArg(2, a); @@ -3036,20 +2813,19 @@ public: } }; -// ============================================================================ -// [X86Test_FuncCallImmArgs] -// ============================================================================ +// x86::Compiler - X86Test_FuncCallImmArgs +// ======================================= -class X86Test_FuncCallImmArgs : public X86Test { +class X86Test_FuncCallImmArgs : public X86TestCase { public: - X86Test_FuncCallImmArgs() : X86Test("FuncCallImmArgs") {} + X86Test_FuncCallImmArgs() : X86TestCase("FuncCallImmArgs") {} - static void add(X86TestApp& app) { + static void add(TestApp& app) { app.add(new X86Test_FuncCallImmArgs()); } virtual void compile(x86::Compiler& cc) { - cc.addFunc(FuncSignatureT<int>(CallConv::kIdHost)); + cc.addFunc(FuncSignatureT<int>(CallConvId::kHost)); // Prepare. x86::Gp rv = cc.newInt32("rv"); @@ -3058,7 +2834,7 @@ public: InvokeNode* invokeNode; cc.invoke(&invokeNode, imm((void*)X86Test_FuncCallManyArgs::calledFunc), - FuncSignatureT<int, int, int, int, int, int, int, int, int, int, int>(CallConv::kIdHost)); + FuncSignatureT<int, int, int, int, int, int, int, int, int, int, int>(CallConvId::kHost)); invokeNode->setArg(0, imm(0x03)); invokeNode->setArg(1, imm(0x12)); @@ -3090,15 +2866,14 @@ public: } }; -// ============================================================================ -// [X86Test_FuncCallPtrArgs] -// ============================================================================ +// x86::Compiler - X86Test_FuncCallPtrArgs +// ======================================= -class X86Test_FuncCallPtrArgs : public X86Test { +class X86Test_FuncCallPtrArgs : public X86TestCase { public: - X86Test_FuncCallPtrArgs() : X86Test("FuncCallPtrArgs") {} + X86Test_FuncCallPtrArgs() : X86TestCase("FuncCallPtrArgs") {} - static void add(X86TestApp& app) { + static void add(TestApp& app) { app.add(new X86Test_FuncCallPtrArgs()); } @@ -3116,7 +2891,7 @@ public: } virtual void compile(x86::Compiler& cc) { - cc.addFunc(FuncSignatureT<int>(CallConv::kIdHost)); + cc.addFunc(FuncSignatureT<int>(CallConvId::kHost)); // Prepare. x86::Gp rv = cc.newInt32("rv"); @@ -3125,7 +2900,7 @@ public: InvokeNode* invokeNode; cc.invoke(&invokeNode, imm((void*)calledFunc), - FuncSignatureT<int, void*, void*, void*, void*, void*, void*, void*, void*, void*, void*>(CallConv::kIdHost)); + FuncSignatureT<int, void*, void*, void*, void*, void*, void*, void*, void*, void*, void*>(CallConvId::kHost)); invokeNode->setArg(0, imm(0x01)); invokeNode->setArg(1, imm(0x02)); @@ -3157,15 +2932,14 @@ public: } }; -// ============================================================================ -// [X86Test_FuncCallRefArgs] -// ============================================================================ +// x86::Compiler - X86Test_FuncCallRefArgs +// ======================================= -class X86Test_FuncCallRefArgs : public X86Test { +class X86Test_FuncCallRefArgs : public X86TestCase { public: - X86Test_FuncCallRefArgs() : X86Test("FuncCallRefArgs") {} + X86Test_FuncCallRefArgs() : X86TestCase("FuncCallRefArgs") {} - static void add(X86TestApp& app) { + static void add(TestApp& app) { app.add(new X86Test_FuncCallRefArgs()); } @@ -3178,7 +2952,7 @@ public: } virtual void compile(x86::Compiler& cc) { - cc.addFunc(FuncSignatureT<int, int&, int&, int&, int&>(CallConv::kIdHost)); + FuncNode* funcNode = cc.addFunc(FuncSignatureT<int, int&, int&, int&, int&>(CallConvId::kHost)); // Prepare. x86::Gp arg1 = cc.newInt32(); @@ -3187,16 +2961,16 @@ public: x86::Gp arg4 = cc.newInt32(); x86::Gp rv = cc.newInt32("rv"); - cc.setArg(0, arg1); - cc.setArg(1, arg2); - cc.setArg(2, arg3); - cc.setArg(3, arg4); + funcNode->setArg(0, arg1); + funcNode->setArg(1, arg2); + funcNode->setArg(2, arg3); + funcNode->setArg(3, arg4); // Call function. InvokeNode* invokeNode; cc.invoke(&invokeNode, imm((void*)calledFunc), - FuncSignatureT<int, int&, int&, int&, int&>(CallConv::kIdHost)); + FuncSignatureT<int, int&, int&, int&, int&>(CallConvId::kHost)); invokeNode->setArg(0, arg1); invokeNode->setArg(1, arg2); @@ -3224,15 +2998,14 @@ public: } }; -// ============================================================================ -// [X86Test_FuncCallFloatAsXmmRet] -// ============================================================================ +// x86::Compiler - X86Test_FuncCallFloatAsXmmRet +// ============================================= -class X86Test_FuncCallFloatAsXmmRet : public X86Test { +class X86Test_FuncCallFloatAsXmmRet : public X86TestCase { public: - X86Test_FuncCallFloatAsXmmRet() : X86Test("FuncCallFloatAsXmmRet") {} + X86Test_FuncCallFloatAsXmmRet() : X86TestCase("FuncCallFloatAsXmmRet") {} - static void add(X86TestApp& app) { + static void add(TestApp& app) { app.add(new X86Test_FuncCallFloatAsXmmRet()); } @@ -3241,18 +3014,18 @@ public: } virtual void compile(x86::Compiler& cc) { - cc.addFunc(FuncSignatureT<float, float, float>(CallConv::kIdHost)); + FuncNode* funcNode = cc.addFunc(FuncSignatureT<float, float, float>(CallConvId::kHost)); x86::Xmm a = cc.newXmmSs("a"); x86::Xmm b = cc.newXmmSs("b"); x86::Xmm ret = cc.newXmmSs("ret"); - cc.setArg(0, a); - cc.setArg(1, b); + funcNode->setArg(0, a); + funcNode->setArg(1, b); // Call function. InvokeNode* invokeNode; - cc.invoke(&invokeNode, imm((void*)calledFunc), FuncSignatureT<float, float, float>(CallConv::kIdHost)); + cc.invoke(&invokeNode, imm((void*)calledFunc), FuncSignatureT<float, float, float>(CallConvId::kHost)); invokeNode->setArg(0, a); invokeNode->setArg(1, b); invokeNode->setRet(0, ret); @@ -3275,15 +3048,14 @@ public: } }; -// ============================================================================ -// [X86Test_FuncCallDoubleAsXmmRet] -// ============================================================================ +// x86::Compiler - X86Test_FuncCallDoubleAsXmmRet +// ============================================== -class X86Test_FuncCallDoubleAsXmmRet : public X86Test { +class X86Test_FuncCallDoubleAsXmmRet : public X86TestCase { public: - X86Test_FuncCallDoubleAsXmmRet() : X86Test("FuncCallDoubleAsXmmRet") {} + X86Test_FuncCallDoubleAsXmmRet() : X86TestCase("FuncCallDoubleAsXmmRet") {} - static void add(X86TestApp& app) { + static void add(TestApp& app) { app.add(new X86Test_FuncCallDoubleAsXmmRet()); } @@ -3292,17 +3064,17 @@ public: } virtual void compile(x86::Compiler& cc) { - cc.addFunc(FuncSignatureT<double, double, double>(CallConv::kIdHost)); + FuncNode* funcNode = cc.addFunc(FuncSignatureT<double, double, double>(CallConvId::kHost)); x86::Xmm a = cc.newXmmSd("a"); x86::Xmm b = cc.newXmmSd("b"); x86::Xmm ret = cc.newXmmSd("ret"); - cc.setArg(0, a); - cc.setArg(1, b); + funcNode->setArg(0, a); + funcNode->setArg(1, b); InvokeNode* invokeNode; - cc.invoke(&invokeNode, imm((void*)calledFunc), FuncSignatureT<double, double, double>(CallConv::kIdHost)); + cc.invoke(&invokeNode, imm((void*)calledFunc), FuncSignatureT<double, double, double>(CallConvId::kHost)); invokeNode->setArg(0, a); invokeNode->setArg(1, b); invokeNode->setRet(0, ret); @@ -3325,15 +3097,14 @@ public: } }; -// ============================================================================ -// [X86Test_FuncCallConditional] -// ============================================================================ +// x86::Compiler - X86Test_FuncCallConditional +// =========================================== -class X86Test_FuncCallConditional : public X86Test { +class X86Test_FuncCallConditional : public X86TestCase { public: - X86Test_FuncCallConditional() : X86Test("FuncCallConditional") {} + X86Test_FuncCallConditional() : X86TestCase("FuncCallConditional") {} - static void add(X86TestApp& app) { + static void add(TestApp& app) { app.add(new X86Test_FuncCallConditional()); } @@ -3345,10 +3116,10 @@ public: InvokeNode* invokeNode; x86::Gp result; - cc.addFunc(FuncSignatureT<int, int, int, int>(CallConv::kIdHost)); - cc.setArg(0, x); - cc.setArg(1, y); - cc.setArg(2, op); + FuncNode* funcNode = cc.addFunc(FuncSignatureT<int, int, int, int>(CallConvId::kHost)); + funcNode->setArg(0, x); + funcNode->setArg(1, y); + funcNode->setArg(2, op); Label opAdd = cc.newLabel(); Label opMul = cc.newLabel(); @@ -3365,7 +3136,7 @@ public: cc.bind(opAdd); result = cc.newInt32("result_1"); - cc.invoke(&invokeNode, (uint64_t)calledFuncAdd, FuncSignatureT<int, int, int>(CallConv::kIdHost)); + cc.invoke(&invokeNode, (uint64_t)calledFuncAdd, FuncSignatureT<int, int, int>(CallConvId::kHost)); invokeNode->setArg(0, x); invokeNode->setArg(1, y); invokeNode->setRet(0, result); @@ -3374,7 +3145,7 @@ public: cc.bind(opMul); result = cc.newInt32("result_2"); - cc.invoke(&invokeNode, (uint64_t)calledFuncMul, FuncSignatureT<int, int, int>(CallConv::kIdHost)); + cc.invoke(&invokeNode, (uint64_t)calledFuncMul, FuncSignatureT<int, int, int>(CallConvId::kHost)); invokeNode->setArg(0, x); invokeNode->setArg(1, y); invokeNode->setRet(0, result); @@ -3406,15 +3177,14 @@ public: static int calledFuncMul(int x, int y) { return x * y; } }; -// ============================================================================ -// [X86Test_FuncCallMultiple] -// ============================================================================ +// x86::Compiler - X86Test_FuncCallMultiple +// ======================================== -class X86Test_FuncCallMultiple : public X86Test { +class X86Test_FuncCallMultiple : public X86TestCase { public: - X86Test_FuncCallMultiple() : X86Test("FuncCallMultiple") {} + X86Test_FuncCallMultiple() : X86TestCase("FuncCallMultiple") {} - static void add(X86TestApp& app) { + static void add(TestApp& app) { app.add(new X86Test_FuncCallMultiple()); } @@ -3429,8 +3199,8 @@ public: x86::Gp acc0 = cc.newInt32("acc0"); x86::Gp acc1 = cc.newInt32("acc1"); - cc.addFunc(FuncSignatureT<int, int*>(CallConv::kIdHost)); - cc.setArg(0, buf); + FuncNode* funcNode = cc.addFunc(FuncSignatureT<int, int*>(CallConvId::kHost)); + funcNode->setArg(0, buf); cc.mov(acc0, 0); cc.mov(acc1, 0); @@ -3444,7 +3214,7 @@ public: cc.mov(ptr, buf); cc.mov(idx, int(i)); - cc.invoke(&invokeNode, (uint64_t)calledFunc, FuncSignatureT<int, int*, int>(CallConv::kIdFastCall)); + cc.invoke(&invokeNode, (uint64_t)calledFunc, FuncSignatureT<int, int*, int>(CallConvId::kFastCall)); invokeNode->setArg(0, ptr); invokeNode->setArg(1, idx); invokeNode->setRet(0, ret); @@ -3454,7 +3224,7 @@ public: cc.mov(ptr, buf); cc.mov(idx, int(i)); - cc.invoke(&invokeNode, (uint64_t)calledFunc, FuncSignatureT<int, int*, int>(CallConv::kIdFastCall)); + cc.invoke(&invokeNode, (uint64_t)calledFunc, FuncSignatureT<int, int*, int>(CallConvId::kFastCall)); invokeNode->setArg(0, ptr); invokeNode->setArg(1, idx); invokeNode->setRet(0, ret); @@ -3483,15 +3253,14 @@ public: } }; -// ============================================================================ -// [X86Test_FuncCallRecursive] -// ============================================================================ +// x86::Compiler - X86Test_FuncCallRecursive +// ========================================= -class X86Test_FuncCallRecursive : public X86Test { +class X86Test_FuncCallRecursive : public X86TestCase { public: - X86Test_FuncCallRecursive() : X86Test("FuncCallRecursive") {} + X86Test_FuncCallRecursive() : X86TestCase("FuncCallRecursive") {} - static void add(X86TestApp& app) { + static void add(TestApp& app) { app.add(new X86Test_FuncCallRecursive()); } @@ -3499,8 +3268,8 @@ public: x86::Gp val = cc.newInt32("val"); Label skip = cc.newLabel(); - FuncNode* func = cc.addFunc(FuncSignatureT<int, int>(CallConv::kIdHost)); - cc.setArg(0, val); + FuncNode* funcNode = cc.addFunc(FuncSignatureT<int, int>(CallConvId::kHost)); + funcNode->setArg(0, val); cc.cmp(val, 1); cc.jle(skip); @@ -3511,7 +3280,7 @@ public: InvokeNode* invokeNode; - cc.invoke(&invokeNode, func->label(), FuncSignatureT<int, int>(CallConv::kIdHost)); + cc.invoke(&invokeNode, funcNode->label(), FuncSignatureT<int, int>(CallConvId::kHost)); invokeNode->setArg(0, tmp); invokeNode->setRet(0, tmp); cc.mul(cc.newInt32(), val, tmp); @@ -3535,30 +3304,29 @@ public: } }; -// ============================================================================ -// [X86Test_FuncCallVarArg1] -// ============================================================================ +// x86::Compiler - X86Test_FuncCallVarArg1 +// ======================================= -class X86Test_FuncCallVarArg1 : public X86Test { +class X86Test_FuncCallVarArg1 : public X86TestCase { public: - X86Test_FuncCallVarArg1() : X86Test("FuncCallVarArg1") {} + X86Test_FuncCallVarArg1() : X86TestCase("FuncCallVarArg1") {} - static void add(X86TestApp& app) { + static void add(TestApp& app) { app.add(new X86Test_FuncCallVarArg1()); } virtual void compile(x86::Compiler& cc) { - cc.addFunc(FuncSignatureT<int, int, int, int, int>(CallConv::kIdHost)); + FuncNode* funcNode = cc.addFunc(FuncSignatureT<int, int, int, int, int>(CallConvId::kHost)); x86::Gp a0 = cc.newInt32("a0"); x86::Gp a1 = cc.newInt32("a1"); x86::Gp a2 = cc.newInt32("a2"); x86::Gp a3 = cc.newInt32("a3"); - cc.setArg(0, a0); - cc.setArg(1, a1); - cc.setArg(2, a2); - cc.setArg(3, a3); + funcNode->setArg(0, a0); + funcNode->setArg(1, a1); + funcNode->setArg(2, a2); + funcNode->setArg(3, a3); // We call `int func(size_t, ...)` // - The `vaIndex` must be 1 (first argument after size_t). @@ -3566,7 +3334,7 @@ public: InvokeNode* invokeNode; cc.invoke(&invokeNode, imm((void*)calledFunc), - FuncSignatureT<int, size_t, int, int, int, int>(CallConv::kIdHost, 1)); + FuncSignatureT<int, size_t, int, int, int, int>(CallConvId::kHost, 1)); invokeNode->setArg(0, imm(4)); invokeNode->setArg(1, a0); invokeNode->setArg(2, a1); @@ -3604,30 +3372,29 @@ public: } }; -// ============================================================================ -// [X86Test_FuncCallVarArg2] -// ============================================================================ +// x86::Compiler - X86Test_FuncCallVarArg2 +// ======================================= -class X86Test_FuncCallVarArg2 : public X86Test { +class X86Test_FuncCallVarArg2 : public X86TestCase { public: - X86Test_FuncCallVarArg2() : X86Test("FuncCallVarArg2") {} + X86Test_FuncCallVarArg2() : X86TestCase("FuncCallVarArg2") {} - static void add(X86TestApp& app) { + static void add(TestApp& app) { app.add(new X86Test_FuncCallVarArg2()); } virtual void compile(x86::Compiler& cc) { - cc.addFunc(FuncSignatureT<double, double, double, double, double>(CallConv::kIdHost)); + FuncNode* funcNode = cc.addFunc(FuncSignatureT<double, double, double, double, double>(CallConvId::kHost)); x86::Xmm a0 = cc.newXmmSd("a0"); x86::Xmm a1 = cc.newXmmSd("a1"); x86::Xmm a2 = cc.newXmmSd("a2"); x86::Xmm a3 = cc.newXmmSd("a3"); - cc.setArg(0, a0); - cc.setArg(1, a1); - cc.setArg(2, a2); - cc.setArg(3, a3); + funcNode->setArg(0, a0); + funcNode->setArg(1, a1); + funcNode->setArg(2, a2); + funcNode->setArg(3, a3); // We call `double func(size_t, ...)` // - The `vaIndex` must be 1 (first argument after size_t). @@ -3635,7 +3402,7 @@ public: InvokeNode* invokeNode; cc.invoke(&invokeNode, imm((void*)calledFunc), - FuncSignatureT<double, size_t, double, double, double, double>(CallConv::kIdHost, 1)); + FuncSignatureT<double, size_t, double, double, double, double>(CallConvId::kHost, 1)); invokeNode->setArg(0, imm(4)); invokeNode->setArg(1, a0); invokeNode->setArg(2, a1); @@ -3673,34 +3440,94 @@ public: } }; -// ============================================================================ -// [X86Test_FuncCallMisc1] -// ============================================================================ +// x86::Compiler - X86Test_FuncCallInt64Arg +// ======================================== -class X86Test_FuncCallMisc1 : public X86Test { +class X86Test_FuncCallInt64Arg : public X86TestCase { public: - X86Test_FuncCallMisc1() : X86Test("FuncCallMisc1") {} + X86Test_FuncCallInt64Arg() : X86TestCase("FuncCallInt64Arg") {} + + static void add(TestApp& app) { + app.add(new X86Test_FuncCallInt64Arg()); + } + + virtual void compile(x86::Compiler& cc) { + FuncNode* funcNode = cc.addFunc(FuncSignatureT<uint64_t, uint64_t>(CallConvId::kHost)); + + if (cc.is64Bit()) { + x86::Gp reg = cc.newUInt64(); + funcNode->setArg(0, reg); + cc.add(reg, 1); + cc.ret(reg); + } + else { + x86::Gp hi = cc.newUInt32("hi"); + x86::Gp lo = cc.newUInt32("lo"); + + funcNode->setArg(0, 0, lo); + funcNode->setArg(0, 1, hi); + + cc.add(lo, 1); + cc.adc(hi, 0); + cc.ret(lo, hi); + } - static void add(X86TestApp& app) { + cc.endFunc(); + } + + virtual bool run(void* _func, String& result, String& expect) { + typedef uint64_t (*Func)(uint64_t); + Func func = ptr_as_func<Func>(_func); + + uint64_t resultRet = func(uint64_t(0xFFFFFFFF)); + uint64_t expectRet = 0x100000000; + + result.assignFormat("ret=%llu", (unsigned long long)resultRet); + expect.assignFormat("ret=%llu", (unsigned long long)expectRet); + + return resultRet == expectRet; + } + + static double calledFunc(size_t n, ...) { + double sum = 0; + va_list ap; + va_start(ap, n); + for (size_t i = 0; i < n; i++) { + double arg = va_arg(ap, double); + sum += arg; + } + va_end(ap); + return sum; + } +}; + +// x86::Compiler - X86Test_FuncCallMisc1 +// ===================================== + +class X86Test_FuncCallMisc1 : public X86TestCase { +public: + X86Test_FuncCallMisc1() : X86TestCase("FuncCallMisc1") {} + + static void add(TestApp& app) { app.add(new X86Test_FuncCallMisc1()); } static void dummy(int, int) {} virtual void compile(x86::Compiler& cc) { - cc.addFunc(FuncSignatureT<int, int, int>(CallConv::kIdHost)); + FuncNode* funcNode = cc.addFunc(FuncSignatureT<int, int, int>(CallConvId::kHost)); x86::Gp a = cc.newInt32("a"); x86::Gp b = cc.newInt32("b"); x86::Gp r = cc.newInt32("r"); - cc.setArg(0, a); - cc.setArg(1, b); + funcNode->setArg(0, a); + funcNode->setArg(1, b); InvokeNode* invokeNode; cc.invoke(&invokeNode, imm((void*)dummy), - FuncSignatureT<void, int, int>(CallConv::kIdHost)); + FuncSignatureT<void, int, int>(CallConvId::kHost)); invokeNode->setArg(0, a); invokeNode->setArg(1, b); @@ -3724,32 +3551,31 @@ public: } }; -// ============================================================================ -// [X86Test_FuncCallMisc2] -// ============================================================================ +// x86::Compiler - X86Test_FuncCallMisc2 +// ===================================== -class X86Test_FuncCallMisc2 : public X86Test { +class X86Test_FuncCallMisc2 : public X86TestCase { public: - X86Test_FuncCallMisc2() : X86Test("FuncCallMisc2") {} + X86Test_FuncCallMisc2() : X86TestCase("FuncCallMisc2") {} - static void add(X86TestApp& app) { + static void add(TestApp& app) { app.add(new X86Test_FuncCallMisc2()); } virtual void compile(x86::Compiler& cc) { - cc.addFunc(FuncSignatureT<double, const double*>(CallConv::kIdHost)); + FuncNode* funcNode = cc.addFunc(FuncSignatureT<double, const double*>(CallConvId::kHost)); x86::Gp p = cc.newIntPtr("p"); x86::Xmm arg = cc.newXmmSd("arg"); x86::Xmm ret = cc.newXmmSd("ret"); - cc.setArg(0, p); + funcNode->setArg(0, p); cc.movsd(arg, x86::ptr(p)); InvokeNode* invokeNode; cc.invoke(&invokeNode, imm((void*)op), - FuncSignatureT<double, double>(CallConv::kIdHost)); + FuncSignatureT<double, double>(CallConvId::kHost)); invokeNode->setArg(0, arg); invokeNode->setRet(0, ret); @@ -3775,32 +3601,31 @@ public: static double op(double a) { return a * a; } }; -// ============================================================================ -// [X86Test_FuncCallMisc3] -// ============================================================================ +// x86::Compiler - X86Test_FuncCallMisc3 +// ===================================== -class X86Test_FuncCallMisc3 : public X86Test { +class X86Test_FuncCallMisc3 : public X86TestCase { public: - X86Test_FuncCallMisc3() : X86Test("FuncCallMisc3") {} + X86Test_FuncCallMisc3() : X86TestCase("FuncCallMisc3") {} - static void add(X86TestApp& app) { + static void add(TestApp& app) { app.add(new X86Test_FuncCallMisc3()); } virtual void compile(x86::Compiler& cc) { - cc.addFunc(FuncSignatureT<double, const double*>(CallConv::kIdHost)); + FuncNode* funcNode = cc.addFunc(FuncSignatureT<double, const double*>(CallConvId::kHost)); x86::Gp p = cc.newIntPtr("p"); x86::Xmm arg = cc.newXmmSd("arg"); x86::Xmm ret = cc.newXmmSd("ret"); - cc.setArg(0, p); + funcNode->setArg(0, p); cc.movsd(arg, x86::ptr(p)); InvokeNode* invokeNode; cc.invoke(&invokeNode, imm((void*)op), - FuncSignatureT<double, double>(CallConv::kIdHost)); + FuncSignatureT<double, double>(CallConvId::kHost)); invokeNode->setArg(0, arg); invokeNode->setRet(0, ret); @@ -3829,15 +3654,14 @@ public: static double op(double a) { return a * a; } }; -// ============================================================================ -// [X86Test_FuncCallMisc4] -// ============================================================================ +// x86::Compiler - X86Test_FuncCallMisc4 +// ===================================== -class X86Test_FuncCallMisc4 : public X86Test { +class X86Test_FuncCallMisc4 : public X86TestCase { public: - X86Test_FuncCallMisc4() : X86Test("FuncCallMisc4") {} + X86Test_FuncCallMisc4() : X86TestCase("FuncCallMisc4") {} - static void add(X86TestApp& app) { + static void add(TestApp& app) { app.add(new X86Test_FuncCallMisc4()); } @@ -3845,13 +3669,13 @@ public: InvokeNode* invokeNode; FuncSignatureBuilder funcSignature; - funcSignature.setCallConv(CallConv::kIdHost); - funcSignature.setRet(Type::kIdF64); + funcSignature.setCallConvId(CallConvId::kHost); + funcSignature.setRet(TypeId::kFloat64); cc.addFunc(funcSignature); FuncSignatureBuilder invokeSignature; - invokeSignature.setCallConv(CallConv::kIdHost); - invokeSignature.setRet(Type::kIdF64); + invokeSignature.setCallConvId(CallConvId::kHost); + invokeSignature.setRet(TypeId::kFloat64); cc.invoke(&invokeNode, imm((void*)calledFunc), invokeSignature); x86::Xmm ret = cc.newXmmSd("ret"); @@ -3877,26 +3701,25 @@ public: static double calledFunc() { return 3.14; } }; -// ============================================================================ -// [X86Test_FuncCallMisc5] -// ============================================================================ +// x86::Compiler - X86Test_FuncCallMisc5 +// ===================================== // The register allocator should clobber the register used by the `call` itself. -class X86Test_FuncCallMisc5 : public X86Test { +class X86Test_FuncCallMisc5 : public X86TestCase { public: - X86Test_FuncCallMisc5() : X86Test("FuncCallMisc5") {} + X86Test_FuncCallMisc5() : X86TestCase("FuncCallMisc5") {} - static void add(X86TestApp& app) { + static void add(TestApp& app) { app.add(new X86Test_FuncCallMisc5()); } virtual void compile(x86::Compiler& cc) { - cc.addFunc(FuncSignatureT<int>(CallConv::kIdHost)); + cc.addFunc(FuncSignatureT<int>(CallConvId::kHost)); x86::Gp pFn = cc.newIntPtr("pFn"); x86::Gp vars[16]; - uint32_t i, regCount = cc.arch() == Environment::kArchX86 ? 8 : 16; + uint32_t i, regCount = cc.arch() == Arch::kX86 ? 8 : 16; ASMJIT_ASSERT(regCount <= ASMJIT_ARRAY_SIZE(vars)); cc.mov(pFn, imm((void*)calledFunc)); @@ -3910,7 +3733,7 @@ public: } InvokeNode* invokeNode; - cc.invoke(&invokeNode, pFn, FuncSignatureT<void>(CallConv::kIdHost)); + cc.invoke(&invokeNode, pFn, FuncSignatureT<void>(CallConvId::kHost)); for (i = 1; i < regCount; i++) if (vars[i].isValid()) @@ -3936,26 +3759,85 @@ public: static void calledFunc() {} }; -// ============================================================================ -// [X86Test_MiscLocalConstPool] -// ============================================================================ +// x86::Compiler - X86Test_FuncCallMisc6 +// ===================================== -class X86Test_MiscLocalConstPool : public X86Test { +class X86Test_FuncCallMisc6 : public X86TestCase { public: - X86Test_MiscLocalConstPool() : X86Test("MiscLocalConstPool") {} + X86Test_FuncCallMisc6() : X86TestCase("FuncCallMisc6") {} + + static void add(TestApp& app) { + app.add(new X86Test_FuncCallMisc6()); + } - static void add(X86TestApp& app) { + virtual void compile(x86::Compiler& cc) { + FuncNode* funcNode = cc.addFunc(FuncSignatureT<uint32_t, uint32_t>(CallConvId::kHost)); + + constexpr uint32_t kCount = 16; + + x86::Gp v[kCount]; + x86::Gp argVal = cc.newUInt32("argVal"); + x86::Gp retVal = cc.newUInt32("retVal"); + uint32_t i; + + funcNode->setArg(0, argVal); + cc.add(argVal, 1); + + for (i = 0; i < kCount; i++) + v[i] = cc.newUInt32("v%u", i); + + InvokeNode* invokeNode; + cc.invoke(&invokeNode, imm((void*)calledFunc), FuncSignatureT<uint32_t, uint32_t>(CallConvId::kHost)); + invokeNode->setArg(0, argVal); + invokeNode->setRet(0, retVal); + + for (i = 0; i < kCount; i++) + cc.mov(v[i], i + 1); + + for (i = 0; i < kCount; i++) + cc.add(argVal, v[i]); + + cc.add(retVal, argVal); + cc.ret(retVal); + + cc.endFunc(); + } + + virtual bool run(void* _func, String& result, String& expect) { + typedef uint32_t (*Func)(uint32_t x); + Func func = ptr_as_func<Func>(_func); + + uint32_t resultRet = func(111); + uint32_t expectRet = 111 + 112 + 2 + (1 + 16) * 8; + + result.assignFormat("ret=%u", resultRet); + expect.assignFormat("ret=%u", expectRet); + + return resultRet == expectRet; + } + + static uint32_t calledFunc(uint32_t x) { return x + 1; } +}; + +// x86::Compiler - X86Test_MiscLocalConstPool +// ========================================== + +class X86Test_MiscLocalConstPool : public X86TestCase { +public: + X86Test_MiscLocalConstPool() : X86TestCase("MiscLocalConstPool") {} + + static void add(TestApp& app) { app.add(new X86Test_MiscLocalConstPool()); } virtual void compile(x86::Compiler& cc) { - cc.addFunc(FuncSignatureT<int>(CallConv::kIdHost)); + cc.addFunc(FuncSignatureT<int>(CallConvId::kHost)); x86::Gp v0 = cc.newInt32("v0"); x86::Gp v1 = cc.newInt32("v1"); - x86::Mem c0 = cc.newInt32Const(ConstPool::kScopeLocal, 200); - x86::Mem c1 = cc.newInt32Const(ConstPool::kScopeLocal, 33); + x86::Mem c0 = cc.newInt32Const(ConstPoolScope::kLocal, 200); + x86::Mem c1 = cc.newInt32Const(ConstPoolScope::kLocal, 33); cc.mov(v0, c0); cc.mov(v1, c1); @@ -3979,26 +3861,25 @@ public: } }; -// ============================================================================ -// [X86Test_MiscGlobalConstPool] -// ============================================================================ +// x86::Compiler - X86Test_MiscGlobalConstPool +// =========================================== -class X86Test_MiscGlobalConstPool : public X86Test { +class X86Test_MiscGlobalConstPool : public X86TestCase { public: - X86Test_MiscGlobalConstPool() : X86Test("MiscGlobalConstPool") {} + X86Test_MiscGlobalConstPool() : X86TestCase("MiscGlobalConstPool") {} - static void add(X86TestApp& app) { + static void add(TestApp& app) { app.add(new X86Test_MiscGlobalConstPool()); } virtual void compile(x86::Compiler& cc) { - cc.addFunc(FuncSignatureT<int>(CallConv::kIdHost)); + cc.addFunc(FuncSignatureT<int>(CallConvId::kHost)); x86::Gp v0 = cc.newInt32("v0"); x86::Gp v1 = cc.newInt32("v1"); - x86::Mem c0 = cc.newInt32Const(ConstPool::kScopeGlobal, 200); - x86::Mem c1 = cc.newInt32Const(ConstPool::kScopeGlobal, 33); + x86::Mem c0 = cc.newInt32Const(ConstPoolScope::kGlobal, 200); + x86::Mem c1 = cc.newInt32Const(ConstPoolScope::kGlobal, 33); cc.mov(v0, c0); cc.mov(v1, c1); @@ -4022,19 +3903,18 @@ public: } }; -// ============================================================================ -// [X86Test_MiscMultiRet] -// ============================================================================ +// x86::Compiler - X86Test_MiscMultiRet +// ==================================== -struct X86Test_MiscMultiRet : public X86Test { - X86Test_MiscMultiRet() : X86Test("MiscMultiRet") {} +struct X86Test_MiscMultiRet : public X86TestCase { + X86Test_MiscMultiRet() : X86TestCase("MiscMultiRet") {} - static void add(X86TestApp& app) { + static void add(TestApp& app) { app.add(new X86Test_MiscMultiRet()); } virtual void compile(x86::Compiler& cc) { - cc.addFunc(FuncSignatureT<int, int, int, int>(CallConv::kIdHost)); + FuncNode* funcNode = cc.addFunc(FuncSignatureT<int, int, int, int>(CallConvId::kHost)); x86::Gp op = cc.newInt32("op"); x86::Gp a = cc.newInt32("a"); @@ -4046,9 +3926,9 @@ struct X86Test_MiscMultiRet : public X86Test { Label L_Mul = cc.newLabel(); Label L_Div = cc.newLabel(); - cc.setArg(0, op); - cc.setArg(1, a); - cc.setArg(2, b); + funcNode->setArg(0, op); + funcNode->setArg(1, a); + funcNode->setArg(2, b); cc.cmp(op, 0); cc.jz(L_Add); @@ -4114,32 +3994,31 @@ struct X86Test_MiscMultiRet : public X86Test { } }; -// ============================================================================ -// [X86Test_MiscMultiFunc] -// ============================================================================ +// x86::Compiler - X86Test_MiscMultiFunc +// ===================================== -class X86Test_MiscMultiFunc : public X86Test { +class X86Test_MiscMultiFunc : public X86TestCase { public: - X86Test_MiscMultiFunc() : X86Test("MiscMultiFunc") {} + X86Test_MiscMultiFunc() : X86TestCase("MiscMultiFunc") {} - static void add(X86TestApp& app) { + static void add(TestApp& app) { app.add(new X86Test_MiscMultiFunc()); } virtual void compile(x86::Compiler& cc) { - FuncNode* f1 = cc.newFunc(FuncSignatureT<int, int, int>(CallConv::kIdHost)); - FuncNode* f2 = cc.newFunc(FuncSignatureT<int, int, int>(CallConv::kIdHost)); + FuncNode* f1Node = cc.newFunc(FuncSignatureT<int, int, int>(CallConvId::kHost)); + FuncNode* f2Node = cc.newFunc(FuncSignatureT<int, int, int>(CallConvId::kHost)); { x86::Gp a = cc.newInt32("a"); x86::Gp b = cc.newInt32("b"); - cc.addFunc(f1); - cc.setArg(0, a); - cc.setArg(1, b); + cc.addFunc(f1Node); + f1Node->setArg(0, a); + f1Node->setArg(1, b); InvokeNode* invokeNode; - cc.invoke(&invokeNode, f2->label(), FuncSignatureT<int, int, int>(CallConv::kIdHost)); + cc.invoke(&invokeNode, f2Node->label(), FuncSignatureT<int, int, int>(CallConvId::kHost)); invokeNode->setArg(0, a); invokeNode->setArg(1, b); invokeNode->setRet(0, a); @@ -4152,9 +4031,9 @@ public: x86::Gp a = cc.newInt32("a"); x86::Gp b = cc.newInt32("b"); - cc.addFunc(f2); - cc.setArg(0, a); - cc.setArg(1, b); + cc.addFunc(f2Node); + f2Node->setArg(0, a); + f2Node->setArg(1, b); cc.add(a, b); cc.ret(a); @@ -4177,43 +4056,36 @@ public: } }; -// ============================================================================ -// [X86Test_MiscUnfollow] -// ============================================================================ +// x86::Compiler - X86Test_MiscUnfollow +// ==================================== // Global (I didn't find a better way to test this). static jmp_buf globalJmpBuf; -class X86Test_MiscUnfollow : public X86Test { +class X86Test_MiscUnfollow : public X86TestCase { public: - X86Test_MiscUnfollow() : X86Test("MiscUnfollow") {} + X86Test_MiscUnfollow() : X86TestCase("MiscUnfollow") {} - static void add(X86TestApp& app) { + static void add(TestApp& app) { app.add(new X86Test_MiscUnfollow()); } virtual void compile(x86::Compiler& cc) { - // NOTE: Fastcall calling convention is the most appropriate here, as all - // arguments will be passed by registers and there won't be any stack - // misalignment when we call the `handler()`. This was failing on OSX - // when targeting 32-bit. - cc.addFunc(FuncSignatureT<int, int, void*>(CallConv::kIdFastCall)); - + // NOTE: Fastcall calling convention is the most appropriate here as all arguments are passed via registers and + // there won't be any stack misalignment in the `handler()`. This was failing on MacOS when targeting 32-bit mode. x86::Gp a = cc.newInt32("a"); x86::Gp b = cc.newIntPtr("b"); Label tramp = cc.newLabel(); - cc.setArg(0, a); - cc.setArg(1, b); + FuncNode* funcNode = cc.addFunc(FuncSignatureT<int, int, void*>(CallConvId::kFastCall)); + funcNode->setArg(0, a); + funcNode->setArg(1, b); cc.cmp(a, 0); cc.jz(tramp); - cc.ret(a); - cc.bind(tramp); cc.unfollow().jmp(b); - cc.endFunc(); } @@ -4239,16 +4111,10 @@ public: static void ASMJIT_FASTCALL handler() { longjmp(globalJmpBuf, 1); } }; -// ============================================================================ -// [Main] -// ============================================================================ - -int main(int argc, char* argv[]) { - X86TestApp app; - - app.handleArgs(argc, argv); - app.showInfo(); +// x86::Compiler - Tests +// ===================== +void compiler_add_x86_tests(TestApp& app) { // Base tests. app.addT<X86Test_NoCode>(); app.addT<X86Test_NoAlign>(); @@ -4260,7 +4126,8 @@ int main(int argc, char* argv[]) { app.addT<X86Test_JumpMany>(); app.addT<X86Test_JumpUnreachable1>(); app.addT<X86Test_JumpUnreachable2>(); - app.addT<X86Test_JumpTable>(); + app.addT<X86Test_JumpTable1>(); + app.addT<X86Test_JumpTable2>(); // Alloc tests. app.addT<X86Test_AllocBase>(); @@ -4312,11 +4179,13 @@ int main(int argc, char* argv[]) { app.addT<X86Test_FuncCallRecursive>(); app.addT<X86Test_FuncCallVarArg1>(); app.addT<X86Test_FuncCallVarArg2>(); + app.addT<X86Test_FuncCallInt64Arg>(); app.addT<X86Test_FuncCallMisc1>(); app.addT<X86Test_FuncCallMisc2>(); app.addT<X86Test_FuncCallMisc3>(); app.addT<X86Test_FuncCallMisc4>(); app.addT<X86Test_FuncCallMisc5>(); + app.addT<X86Test_FuncCallMisc6>(); // Miscellaneous tests. app.addT<X86Test_MiscLocalConstPool>(); @@ -4324,6 +4193,6 @@ int main(int argc, char* argv[]) { app.addT<X86Test_MiscMultiRet>(); app.addT<X86Test_MiscMultiFunc>(); app.addT<X86Test_MiscUnfollow>(); - - return app.run(); } + +#endif // !ASMJIT_NO_X86 && ASMJIT_ARCH_X86 diff --git a/3rdparty/asmjit/test/asmjit_test_x86_asm.cpp b/3rdparty/asmjit/test/asmjit_test_emitters.cpp index ba85100dae0..63c14a6c2e2 100644 --- a/3rdparty/asmjit/test/asmjit_test_x86_asm.cpp +++ b/3rdparty/asmjit/test/asmjit_test_emitters.cpp @@ -1,27 +1,13 @@ -// AsmJit - Machine code generation for C++ +// This file is part of AsmJit project <https://asmjit.com> // -// * Official AsmJit Home Page: https://asmjit.com -// * Official Github Repository: https://github.com/asmjit/asmjit -// -// Copyright (c) 2008-2020 The AsmJit Authors -// -// This software is provided 'as-is', without any express or implied -// warranty. In no event will the authors be held liable for any damages -// arising from the use of this software. -// -// Permission is granted to anyone to use this software for any purpose, -// including commercial applications, and to alter it and redistribute it -// freely, subject to the following restrictions: -// -// 1. The origin of this software must not be misrepresented; you must not -// claim that you wrote the original software. If you use this software -// in a product, an acknowledgment in the product documentation would be -// appreciated but is not required. -// 2. Altered source versions must be plainly marked as such, and must not be -// misrepresented as being the original software. -// 3. This notice may not be removed or altered from any source distribution. +// See asmjit.h or LICENSE.md for license and copyright information +// SPDX-License-Identifier: Zlib + +#include <asmjit/core.h> +#if !defined(ASMJIT_NO_X86) && ASMJIT_ARCH_X86 #include <asmjit/x86.h> + #include <stdio.h> #include <stdlib.h> #include <string.h> @@ -48,7 +34,7 @@ static void makeRawFunc(x86::Emitter* emitter) noexcept { // Create and initialize `FuncDetail` and `FuncFrame`. FuncDetail func; - func.init(FuncSignatureT<void, int*, const int*, const int*>(CallConv::kIdHost), emitter->environment()); + func.init(FuncSignatureT<void, int*, const int*, const int*>(CallConvId::kHost), emitter->environment()); FuncFrame frame; frame.init(func); @@ -78,17 +64,16 @@ static void makeRawFunc(x86::Emitter* emitter) noexcept { #ifndef ASMJIT_NO_COMPILER // This function works with x86::Compiler, provided for comparison. static void makeCompiledFunc(x86::Compiler* cc) noexcept { - x86::Gp dst = cc->newIntPtr(); - x86::Gp src_a = cc->newIntPtr(); - x86::Gp src_b = cc->newIntPtr(); + x86::Gp dst = cc->newIntPtr("dst"); + x86::Gp src_a = cc->newIntPtr("src_a"); + x86::Gp src_b = cc->newIntPtr("src_b"); + x86::Xmm vec0 = cc->newXmm("vec0"); + x86::Xmm vec1 = cc->newXmm("vec1"); - x86::Xmm vec0 = cc->newXmm(); - x86::Xmm vec1 = cc->newXmm(); - - cc->addFunc(FuncSignatureT<void, int*, const int*, const int*>(CallConv::kIdHost)); - cc->setArg(0, dst); - cc->setArg(1, src_a); - cc->setArg(2, src_b); + FuncNode* funcNode = cc->addFunc(FuncSignatureT<void, int*, const int*, const int*>(CallConvId::kHost)); + funcNode->setArg(0, dst); + funcNode->setArg(1, src_a); + funcNode->setArg(2, src_b); cc->movdqu(vec0, x86::ptr(src_a)); cc->movdqu(vec1, x86::ptr(src_b)); @@ -98,10 +83,10 @@ static void makeCompiledFunc(x86::Compiler* cc) noexcept { } #endif -static uint32_t testFunc(JitRuntime& rt, uint32_t emitterType) noexcept { +static uint32_t testFunc(JitRuntime& rt, EmitterType emitterType) noexcept { #ifndef ASMJIT_NO_LOGGING FileLogger logger(stdout); - logger.setIndentation(FormatOptions::kIndentationCode, 2); + logger.setIndentation(FormatIndentationGroup::kCode, 2); #endif CodeHolder code; @@ -113,7 +98,11 @@ static uint32_t testFunc(JitRuntime& rt, uint32_t emitterType) noexcept { Error err = kErrorOk; switch (emitterType) { - case BaseEmitter::kTypeAssembler: { + case EmitterType::kNone: { + break; + } + + case EmitterType::kAssembler: { printf("Using x86::Assembler:\n"); x86::Assembler a(&code); makeRawFunc(a.as<x86::Emitter>()); @@ -121,14 +110,14 @@ static uint32_t testFunc(JitRuntime& rt, uint32_t emitterType) noexcept { } #ifndef ASMJIT_NO_BUILDER - case BaseEmitter::kTypeBuilder: { + case EmitterType::kBuilder: { printf("Using x86::Builder:\n"); x86::Builder cb(&code); makeRawFunc(cb.as<x86::Emitter>()); err = cb.finalize(); if (err) { - printf("x86::Builder::finalize() failed: %s\n", DebugUtils::errorAsString(err)); + printf("** FAILURE: x86::Builder::finalize() failed (%s) **\n", DebugUtils::errorAsString(err)); return 1; } break; @@ -136,14 +125,14 @@ static uint32_t testFunc(JitRuntime& rt, uint32_t emitterType) noexcept { #endif #ifndef ASMJIT_NO_COMPILER - case BaseEmitter::kTypeCompiler: { + case EmitterType::kCompiler: { printf("Using x86::Compiler:\n"); x86::Compiler cc(&code); makeCompiledFunc(&cc); err = cc.finalize(); if (err) { - printf("x86::Compiler::finalize() failed: %s\n", DebugUtils::errorAsString(err)); + printf("** FAILURE: x86::Compiler::finalize() failed (%s) **\n", DebugUtils::errorAsString(err)); return 1; } break; @@ -156,7 +145,7 @@ static uint32_t testFunc(JitRuntime& rt, uint32_t emitterType) noexcept { err = rt.add(&fn, &code); if (err) { - printf("JitRuntime::add() failed: %s\n", DebugUtils::errorAsString(err)); + printf("** FAILURE: JitRuntime::add() failed (%s) **\n", DebugUtils::errorAsString(err)); return 1; } @@ -174,25 +163,35 @@ static uint32_t testFunc(JitRuntime& rt, uint32_t emitterType) noexcept { } int main() { - printf("AsmJit X86 Emitter Test\n\n"); + printf("AsmJit Emitters Test-Suite v%u.%u.%u\n", + unsigned((ASMJIT_LIBRARY_VERSION >> 16) ), + unsigned((ASMJIT_LIBRARY_VERSION >> 8) & 0xFF), + unsigned((ASMJIT_LIBRARY_VERSION ) & 0xFF)); + printf("\n"); JitRuntime rt; unsigned nFailed = 0; - nFailed += testFunc(rt, BaseEmitter::kTypeAssembler); + nFailed += testFunc(rt, EmitterType::kAssembler); #ifndef ASMJIT_NO_BUILDER - nFailed += testFunc(rt, BaseEmitter::kTypeBuilder); + nFailed += testFunc(rt, EmitterType::kBuilder); #endif #ifndef ASMJIT_NO_COMPILER - nFailed += testFunc(rt, BaseEmitter::kTypeCompiler); + nFailed += testFunc(rt, EmitterType::kCompiler); #endif if (!nFailed) - printf("Success:\n All tests passed\n"); + printf("** SUCCESS **\n"); else - printf("Failure:\n %u %s failed\n", nFailed, nFailed == 1 ? "test" : "tests"); + printf("** FAILURE - %u %s failed ** \n", nFailed, nFailed == 1 ? "test" : "tests"); return nFailed ? 1 : 0; } +#else +int main() { + printf("AsmJit X86 Emitter Test is disabled on non-x86 host\n\n"); + return 0; +} +#endif // !ASMJIT_NO_X86 && ASMJIT_ARCH_X86 diff --git a/3rdparty/asmjit/test/asmjit_test_instinfo.cpp b/3rdparty/asmjit/test/asmjit_test_instinfo.cpp new file mode 100644 index 00000000000..3d51edcab14 --- /dev/null +++ b/3rdparty/asmjit/test/asmjit_test_instinfo.cpp @@ -0,0 +1,181 @@ +// This file is part of AsmJit project <https://asmjit.com> +// +// See asmjit.h or LICENSE.md for license and copyright information +// SPDX-License-Identifier: Zlib + +#include <asmjit/core.h> + +#if !defined(ASMJIT_NO_X86) +#include <asmjit/x86.h> +#endif + +#include <stdio.h> + +using namespace asmjit; + +static char accessLetter(bool r, bool w) noexcept { + return r && w ? 'X' : r ? 'R' : w ? 'W' : '_'; +} + +static void printInfo(Arch arch, const BaseInst& inst, const Operand_* operands, size_t opCount) { + StringTmp<512> sb; + + // Read & Write Information + // ------------------------ + + InstRWInfo rw; + InstAPI::queryRWInfo(arch, inst, operands, opCount, &rw); + +#ifndef ASMJIT_NO_LOGGING + Formatter::formatInstruction(sb, FormatFlags::kNone, nullptr, arch, inst, operands, opCount); +#else + sb.append("<Logging-Not-Available>"); +#endif + sb.append("\n"); + + sb.append(" Operands:\n"); + for (uint32_t i = 0; i < rw.opCount(); i++) { + const OpRWInfo& op = rw.operand(i); + + sb.appendFormat(" [%u] Op=%c Read=%016llX Write=%016llX Extend=%016llX", + i, + accessLetter(op.isRead(), op.isWrite()), + op.readByteMask(), + op.writeByteMask(), + op.extendByteMask()); + + if (op.isMemBaseUsed()) { + sb.appendFormat(" Base=%c", accessLetter(op.isMemBaseRead(), op.isMemBaseWrite())); + if (op.isMemBasePreModify()) + sb.appendFormat(" <PRE>"); + if (op.isMemBasePostModify()) + sb.appendFormat(" <POST>"); + } + + if (op.isMemIndexUsed()) { + sb.appendFormat(" Index=%c", accessLetter(op.isMemIndexRead(), op.isMemIndexWrite())); + } + + sb.append("\n"); + } + + // CPU Flags (Read/Write) + // ---------------------- + + if ((rw.readFlags() | rw.writeFlags()) != CpuRWFlags::kNone) { + sb.append(" Flags: \n"); + + struct FlagMap { + CpuRWFlags flag; + char name[4]; + }; + + static const FlagMap flagMap[] = { + { CpuRWFlags::kX86_CF, "CF" }, + { CpuRWFlags::kX86_OF, "OF" }, + { CpuRWFlags::kX86_SF, "SF" }, + { CpuRWFlags::kX86_ZF, "ZF" }, + { CpuRWFlags::kX86_AF, "AF" }, + { CpuRWFlags::kX86_PF, "PF" }, + { CpuRWFlags::kX86_DF, "DF" }, + { CpuRWFlags::kX86_IF, "IF" }, + { CpuRWFlags::kX86_AC, "AC" }, + { CpuRWFlags::kX86_C0, "C0" }, + { CpuRWFlags::kX86_C1, "C1" }, + { CpuRWFlags::kX86_C2, "C2" }, + { CpuRWFlags::kX86_C3, "C3" } + }; + + sb.append(" "); + for (uint32_t f = 0; f < 13; f++) { + char c = accessLetter((rw.readFlags() & flagMap[f].flag) != CpuRWFlags::kNone, + (rw.writeFlags() & flagMap[f].flag) != CpuRWFlags::kNone); + if (c != '_') + sb.appendFormat("%s=%c ", flagMap[f].name, c); + } + + sb.append("\n"); + } + + // CPU Features + // ------------ + + CpuFeatures features; + InstAPI::queryFeatures(arch, inst, operands, opCount, &features); + +#ifndef ASMJIT_NO_LOGGING + if (!features.empty()) { + sb.append(" Features:\n"); + sb.append(" "); + + bool first = true; + CpuFeatures::Iterator it(features.iterator()); + while (it.hasNext()) { + uint32_t featureId = uint32_t(it.next()); + if (!first) + sb.append(" & "); + Formatter::formatFeature(sb, arch, featureId); + first = false; + } + sb.append("\n"); + } +#endif + + printf("%s\n", sb.data()); +} + +template<typename... Args> +static void printInfoSimple(Arch arch,InstId instId, InstOptions options, Args&&... args) { + BaseInst inst(instId); + inst.addOptions(options); + Operand_ opArray[] = { std::forward<Args>(args)... }; + printInfo(arch, inst, opArray, sizeof...(args)); +} + +template<typename... Args> +static void printInfoExtra(Arch arch, InstId instId, InstOptions options, const BaseReg& extraReg, Args&&... args) { + BaseInst inst(instId); + inst.addOptions(options); + inst.setExtraReg(extraReg); + Operand_ opArray[] = { std::forward<Args>(args)... }; + printInfo(arch, inst, opArray, sizeof...(args)); +} + +static void testX86Arch() { +#if !defined(ASMJIT_NO_X86) + using namespace x86; + Arch arch = Arch::kX64; + + printInfoSimple(arch, Inst::kIdAdd, InstOptions::kNone, eax, ebx); + printInfoSimple(arch, Inst::kIdLods, InstOptions::kNone, eax, dword_ptr(rsi)); + + printInfoSimple(arch, Inst::kIdPshufd, InstOptions::kNone, xmm0, xmm1, imm(0)); + printInfoSimple(arch, Inst::kIdPabsb, InstOptions::kNone, mm1, mm2); + printInfoSimple(arch, Inst::kIdPabsb, InstOptions::kNone, xmm1, xmm2); + printInfoSimple(arch, Inst::kIdPextrw, InstOptions::kNone, eax, mm1, imm(0)); + printInfoSimple(arch, Inst::kIdPextrw, InstOptions::kNone, eax, xmm1, imm(0)); + printInfoSimple(arch, Inst::kIdPextrw, InstOptions::kNone, ptr(rax), xmm1, imm(0)); + + printInfoSimple(arch, Inst::kIdVpdpbusd, InstOptions::kNone, xmm0, xmm1, xmm2); + printInfoSimple(arch, Inst::kIdVpdpbusd, InstOptions::kX86_Vex, xmm0, xmm1, xmm2); + + printInfoSimple(arch, Inst::kIdVaddpd, InstOptions::kNone, ymm0, ymm1, ymm2); + printInfoSimple(arch, Inst::kIdVaddpd, InstOptions::kNone, ymm0, ymm30, ymm31); + printInfoSimple(arch, Inst::kIdVaddpd, InstOptions::kNone, zmm0, zmm1, zmm2); + + printInfoExtra(arch, Inst::kIdVaddpd, InstOptions::kNone, k1, zmm0, zmm1, zmm2); + printInfoExtra(arch, Inst::kIdVaddpd, InstOptions::kX86_ZMask, k1, zmm0, zmm1, zmm2); +#endif +} + +int main() { + printf("AsmJit Instruction Info Test-Suite v%u.%u.%u\n", + unsigned((ASMJIT_LIBRARY_VERSION >> 16) ), + unsigned((ASMJIT_LIBRARY_VERSION >> 8) & 0xFF), + unsigned((ASMJIT_LIBRARY_VERSION ) & 0xFF)); + printf("\n"); + + testX86Arch(); + + return 0; +} diff --git a/3rdparty/asmjit/test/asmjit_test_misc.h b/3rdparty/asmjit/test/asmjit_test_misc.h index 03273272d1b..0839d30ac00 100644 --- a/3rdparty/asmjit/test/asmjit_test_misc.h +++ b/3rdparty/asmjit/test/asmjit_test_misc.h @@ -1,25 +1,7 @@ -// AsmJit - Machine code generation for C++ +// This file is part of AsmJit project <https://asmjit.com> // -// * Official AsmJit Home Page: https://asmjit.com -// * Official Github Repository: https://github.com/asmjit/asmjit -// -// Copyright (c) 2008-2020 The AsmJit Authors -// -// This software is provided 'as-is', without any express or implied -// warranty. In no event will the authors be held liable for any damages -// arising from the use of this software. -// -// Permission is granted to anyone to use this software for any purpose, -// including commercial applications, and to alter it and redistribute it -// freely, subject to the following restrictions: -// -// 1. The origin of this software must not be misrepresented; you must not -// claim that you wrote the original software. If you use this software -// in a product, an acknowledgment in the product documentation would be -// appreciated but is not required. -// 2. Altered source versions must be plainly marked as such, and must not be -// misrepresented as being the original software. -// 3. This notice may not be removed or altered from any source distribution. +// See asmjit.h or LICENSE.md for license and copyright information +// SPDX-License-Identifier: Zlib #ifndef ASMJIT_TEST_MISC_H_INCLUDED #define ASMJIT_TEST_MISC_H_INCLUDED @@ -28,42 +10,42 @@ namespace asmtest { -// Generate a typical alpha blend function using SSE2 instruction set. Used -// for benchmarking and also in test86. The generated code should be stable -// and fully functional. -static void generateAlphaBlend(asmjit::x86::Compiler& cc) { - using namespace asmjit; - using namespace asmjit::x86; +using namespace asmjit; - Gp dst = cc.newIntPtr("dst"); - Gp src = cc.newIntPtr("src"); +// Generates a typical alpha blend function that uses SSE2 instruction set. +// This function combines emitting instructions with control flow constructs +// like binding Labels and jumping to them. This should be pretty representative. +template<typename Emitter> +static void generateSseAlphaBlendInternal( + Emitter& cc, + const x86::Gp& dst, const x86::Gp& src, const x86::Gp& n, + const x86::Gp& gp0, + const x86::Xmm& simd0, const x86::Xmm& simd1, const x86::Xmm& simd2, const x86::Xmm& simd3, + const x86::Xmm& simd4, const x86::Xmm& simd5, const x86::Xmm& simd6, const x86::Xmm& simd7) { - Gp i = cc.newIntPtr("i"); - Gp j = cc.newIntPtr("j"); - Gp t = cc.newIntPtr("t"); + x86::Gp i = n; + x86::Gp j = gp0; - Xmm vzero = cc.newXmm("vzero"); - Xmm v0080 = cc.newXmm("v0080"); - Xmm v0101 = cc.newXmm("v0101"); + x86::Xmm vzero = simd0; + x86::Xmm v0080 = simd1; + x86::Xmm v0101 = simd2; Label L_SmallLoop = cc.newLabel(); Label L_SmallEnd = cc.newLabel(); Label L_LargeLoop = cc.newLabel(); Label L_LargeEnd = cc.newLabel(); - Label L_DataPool = cc.newLabel(); - - cc.addFunc(FuncSignatureT<void, void*, const void*, size_t>(CallConv::kIdHost)); + Label L_Done = cc.newLabel(); - cc.setArg(0, dst); - cc.setArg(1, src); - cc.setArg(2, i); - - // How many pixels have to be processed to make the loop aligned. - cc.lea(t, x86::ptr(L_DataPool)); + // Load SIMD Constants. cc.xorps(vzero, vzero); - cc.movaps(v0080, x86::ptr(t, 0)); - cc.movaps(v0101, x86::ptr(t, 16)); + cc.mov(gp0.r32(), 0x00800080); + cc.movd(v0080, gp0.r32()); + cc.mov(gp0.r32(), 0x01010101); + cc.movd(v0101, gp0.r32()); + cc.pshufd(v0080, v0080, x86::shuffleImm(0, 0, 0, 0)); + cc.pshufd(v0101, v0101, x86::shuffleImm(0, 0, 0, 0)); + // How many pixels have to be processed to make the loop aligned. cc.xor_(j, j); cc.sub(j, dst); cc.and_(j, 15); @@ -71,15 +53,15 @@ static void generateAlphaBlend(asmjit::x86::Compiler& cc) { cc.jz(L_SmallEnd); cc.cmp(j, i); - cc.cmovg(j, i); // j = min(i, j). - cc.sub(i, j); // i -= j. + cc.cmovg(j, i); // j = min(i, j) + cc.sub(i, j); // i -= j // Small loop. cc.bind(L_SmallLoop); { - Xmm x0 = cc.newXmm("x0"); - Xmm y0 = cc.newXmm("y0"); - Xmm a0 = cc.newXmm("a0"); + x86::Xmm x0 = simd3; + x86::Xmm y0 = simd4; + x86::Xmm a0 = simd5; cc.movd(y0, x86::ptr(src)); cc.movd(x0, x86::ptr(dst)); @@ -89,7 +71,7 @@ static void generateAlphaBlend(asmjit::x86::Compiler& cc) { cc.psrlw(a0, 8); cc.punpcklbw(x0, vzero); - cc.pshuflw(a0, a0, x86::Predicate::shuf(1, 1, 1, 1)); + cc.pshuflw(a0, a0, x86::shuffleImm(1, 1, 1, 1)); cc.punpcklbw(y0, vzero); cc.pmullw(x0, a0); @@ -113,7 +95,7 @@ static void generateAlphaBlend(asmjit::x86::Compiler& cc) { cc.test(i, i); cc.mov(j, i); - cc.jz(cc.func()->exitLabel()); + cc.jz(L_Done); cc.and_(j, 3); cc.shr(i, 2); @@ -122,11 +104,11 @@ static void generateAlphaBlend(asmjit::x86::Compiler& cc) { // Aligned loop. cc.bind(L_LargeLoop); { - Xmm x0 = cc.newXmm("x0"); - Xmm x1 = cc.newXmm("x1"); - Xmm y0 = cc.newXmm("y0"); - Xmm a0 = cc.newXmm("a0"); - Xmm a1 = cc.newXmm("a1"); + x86::Xmm x0 = simd3; + x86::Xmm x1 = simd4; + x86::Xmm y0 = simd5; + x86::Xmm a0 = simd6; + x86::Xmm a1 = simd7; cc.movups(y0, x86::ptr(src)); cc.movaps(x0, x86::ptr(dst)); @@ -144,8 +126,8 @@ static void generateAlphaBlend(asmjit::x86::Compiler& cc) { cc.punpckhbw(x1, vzero); cc.punpckhwd(a1, a1); - cc.pshufd(a0, a0, x86::Predicate::shuf(3, 3, 1, 1)); - cc.pshufd(a1, a1, x86::Predicate::shuf(3, 3, 1, 1)); + cc.pshufd(a0, a0, x86::shuffleImm(3, 3, 1, 1)); + cc.pshufd(a1, a1, x86::shuffleImm(3, 3, 1, 1)); cc.pmullw(x0, a0); cc.pmullw(x1, a1); @@ -172,13 +154,102 @@ static void generateAlphaBlend(asmjit::x86::Compiler& cc) { cc.test(j, j); cc.jnz(L_SmallLoop); - cc.endFunc(); + cc.bind(L_Done); +} + +static void generateSseAlphaBlend(asmjit::BaseEmitter& emitter, bool emitPrologEpilog) { + using namespace asmjit::x86; - // Data. - cc.align(kAlignData, 16); - cc.bind(L_DataPool); - cc.embedUInt16(uint16_t(0x0080u), 8); - cc.embedUInt16(uint16_t(0x0101u), 8); + if (emitter.isAssembler()) { + Assembler& cc = *emitter.as<Assembler>(); + + x86::Gp dst = cc.zax(); + x86::Gp src = cc.zcx(); + x86::Gp i = cc.zdx(); + x86::Gp j = cc.zdi(); + + if (emitPrologEpilog) { + FuncDetail func; + func.init(FuncSignatureT<void, void*, const void*, size_t>(CallConvId::kHost), cc.environment()); + + FuncFrame frame; + frame.init(func); + frame.addDirtyRegs(dst, src, i, j); + frame.addDirtyRegs(xmm0, xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7); + + FuncArgsAssignment args(&func); + args.assignAll(dst, src, i); + args.updateFuncFrame(frame); + frame.finalize(); + + cc.emitProlog(frame); + cc.emitArgsAssignment(frame, args); + generateSseAlphaBlendInternal(cc, dst, src, i, j, xmm0, xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7); + cc.emitEpilog(frame); + } + else { + generateSseAlphaBlendInternal(cc, dst, src, i, j, xmm0, xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7); + } + } +#ifndef ASMJIT_NO_BUILDER + else if (emitter.isBuilder()) { + Builder& cc = *emitter.as<Builder>(); + + x86::Gp dst = cc.zax(); + x86::Gp src = cc.zcx(); + x86::Gp i = cc.zdx(); + x86::Gp j = cc.zdi(); + + if (emitPrologEpilog) { + FuncDetail func; + func.init(FuncSignatureT<void, void*, const void*, size_t>(CallConvId::kHost), cc.environment()); + + FuncFrame frame; + frame.init(func); + frame.addDirtyRegs(dst, src, i, j); + frame.addDirtyRegs(xmm0, xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7); + + FuncArgsAssignment args(&func); + args.assignAll(dst, src, i); + args.updateFuncFrame(frame); + frame.finalize(); + + cc.emitProlog(frame); + cc.emitArgsAssignment(frame, args); + generateSseAlphaBlendInternal(cc, dst, src, i, j, xmm0, xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7); + cc.emitEpilog(frame); + } + else { + generateSseAlphaBlendInternal(cc, dst, src, i, j, xmm0, xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7); + } + } +#endif +#ifndef ASMJIT_NO_COMPILER + else if (emitter.isCompiler()) { + Compiler& cc = *emitter.as<Compiler>(); + + Gp dst = cc.newIntPtr("dst"); + Gp src = cc.newIntPtr("src"); + Gp i = cc.newIntPtr("i"); + Gp j = cc.newIntPtr("j"); + + Xmm v0 = cc.newXmm("v0"); + Xmm v1 = cc.newXmm("v1"); + Xmm v2 = cc.newXmm("v2"); + Xmm v3 = cc.newXmm("v3"); + Xmm v4 = cc.newXmm("v4"); + Xmm v5 = cc.newXmm("v5"); + Xmm v6 = cc.newXmm("v6"); + Xmm v7 = cc.newXmm("v7"); + + FuncNode* funcNode = cc.addFunc(FuncSignatureT<void, void*, const void*, size_t>(CallConvId::kHost)); + funcNode->setArg(0, dst); + funcNode->setArg(1, src); + funcNode->setArg(2, i); + generateSseAlphaBlendInternal(cc, dst, src, i, j, v0, v1, v2, v3, v4, v5, v6, v7); + cc.endFunc(); + } +#endif } } // {asmtest} diff --git a/3rdparty/asmjit/test/asmjit_test_opcode.cpp b/3rdparty/asmjit/test/asmjit_test_opcode.cpp deleted file mode 100644 index d61a6e4bc29..00000000000 --- a/3rdparty/asmjit/test/asmjit_test_opcode.cpp +++ /dev/null @@ -1,110 +0,0 @@ -// AsmJit - Machine code generation for C++ -// -// * Official AsmJit Home Page: https://asmjit.com -// * Official Github Repository: https://github.com/asmjit/asmjit -// -// Copyright (c) 2008-2020 The AsmJit Authors -// -// This software is provided 'as-is', without any express or implied -// warranty. In no event will the authors be held liable for any damages -// arising from the use of this software. -// -// Permission is granted to anyone to use this software for any purpose, -// including commercial applications, and to alter it and redistribute it -// freely, subject to the following restrictions: -// -// 1. The origin of this software must not be misrepresented; you must not -// claim that you wrote the original software. If you use this software -// in a product, an acknowledgment in the product documentation would be -// appreciated but is not required. -// 2. Altered source versions must be plainly marked as such, and must not be -// misrepresented as being the original software. -// 3. This notice may not be removed or altered from any source distribution. - -// ---------------------------------------------------------------------------- -// This file is used to test opcodes generated by AsmJit. Output can be -// disassembled in your IDE or by your favorite disassembler. Instructions -// are grouped by category and then sorted alphabetically. -// ---------------------------------------------------------------------------- - -#include <asmjit/x86.h> -#include <stdio.h> -#include <stdlib.h> - -#include "./asmjit_test_opcode.h" - -using namespace asmjit; - -struct OpcodeDumpInfo { - uint32_t arch; - bool useRex1; - bool useRex2; -}; - -static const char* archToString(uint32_t arch) noexcept { - switch (arch & ~Environment::kArchBigEndianMask) { - case Environment::kArchX86 : return "X86"; - case Environment::kArchX64 : return "X64"; - case Environment::kArchARM : return "ARM"; - case Environment::kArchThumb : return "Thumb"; - case Environment::kArchAArch64 : return "AArch64"; - case Environment::kArchMIPS_LE : return "MIPS"; - case Environment::kArchMIPS64_LE: return "MIPS64"; - default: return "Unknown"; - } -} - -struct TestErrorHandler : public ErrorHandler { - virtual void handleError(Error err, const char* message, BaseEmitter* origin) { - (void)origin; - printf("ERROR 0x%08X: %s\n", err, message); - } -}; - -typedef void (*VoidFunc)(void); - -int main() { - TestErrorHandler eh; - - OpcodeDumpInfo infoList[] = { - { Environment::kArchX86, false, false }, - { Environment::kArchX64, false, false }, - { Environment::kArchX64, false, true }, - { Environment::kArchX64, true , false }, - { Environment::kArchX64, true , true } - }; - - for (uint32_t i = 0; i < ASMJIT_ARRAY_SIZE(infoList); i++) { - const OpcodeDumpInfo& info = infoList[i]; - - printf("Opcodes [ARCH=%s REX1=%s REX2=%s]\n", - archToString(info.arch), - info.useRex1 ? "true" : "false", - info.useRex2 ? "true" : "false"); - - CodeHolder code; - code.init(Environment(info.arch)); - code.setErrorHandler(&eh); - -#ifndef ASMJIT_NO_LOGGING - FileLogger logger(stdout); - logger.addFlags(FormatOptions::kFlagMachineCode); - code.setLogger(&logger); -#endif - - x86::Assembler a(&code); - asmtest::generateOpcodes(a.as<x86::Emitter>(), info.useRex1, info.useRex2); - - // If this is the host architecture the code generated can be executed - // for debugging purposes (the first instruction is ret anyway). - if (code.arch() == Environment::kArchHost) { - JitRuntime runtime; - VoidFunc p; - - Error err = runtime.add(&p, &code); - if (err == kErrorOk) p(); - } - } - - return 0; -} diff --git a/3rdparty/asmjit/test/asmjit_test_opcode.h b/3rdparty/asmjit/test/asmjit_test_opcode.h deleted file mode 100644 index 6f052f526b8..00000000000 --- a/3rdparty/asmjit/test/asmjit_test_opcode.h +++ /dev/null @@ -1,6059 +0,0 @@ -// AsmJit - Machine code generation for C++ -// -// * Official AsmJit Home Page: https://asmjit.com -// * Official Github Repository: https://github.com/asmjit/asmjit -// -// Copyright (c) 2008-2020 The AsmJit Authors -// -// This software is provided 'as-is', without any express or implied -// warranty. In no event will the authors be held liable for any damages -// arising from the use of this software. -// -// Permission is granted to anyone to use this software for any purpose, -// including commercial applications, and to alter it and redistribute it -// freely, subject to the following restrictions: -// -// 1. The origin of this software must not be misrepresented; you must not -// claim that you wrote the original software. If you use this software -// in a product, an acknowledgment in the product documentation would be -// appreciated but is not required. -// 2. Altered source versions must be plainly marked as such, and must not be -// misrepresented as being the original software. -// 3. This notice may not be removed or altered from any source distribution. - -#ifndef ASMJIT_TEST_OPCODE_H_INCLUDED -#define ASMJIT_TEST_OPCODE_H_INCLUDED - -#include <asmjit/x86.h> - -namespace asmtest { - -// Generate all instructions asmjit can emit. -static void generateOpcodes(asmjit::x86::Emitter* e, bool useRex1 = false, bool useRex2 = false) { - using namespace asmjit; - using namespace asmjit::x86; - - bool isX64 = e->is64Bit(); - - // Prevent a crash when the generated function is called to see the disassembly. - e->ret(); - - // All instructions use the following register that can be changed to see if - // `x86::Assembler` can properly encode all possible combinations. If the given - // `useRexRegs` argument is true the `A` version will in most cases contain - // a register having index 8 or greater to force REX prefix. - Gp gLoA = useRex1 ? r8b : al; - Gp gLoB = useRex2 ? r9b : bl; - - Gp gHiA = ah; - Gp gHiB = bh; - - Gp gwA = useRex1 ? r8w : ax; - Gp gwB = useRex2 ? r9w : bx; - - Gp gdA = useRex1 ? r8d : eax; - Gp gdB = useRex2 ? r9d : ebx; - Gp gdC = useRex2 ? r10d : ecx; - - Gp gzA = useRex1 ? r8 : e->zax(); - Gp gzB = useRex2 ? r9 : e->zbx(); - Gp gzC = useRex2 ? r10 : e->zcx(); - Gp gzD = useRex2 ? r11 : e->zdx(); - - KReg kA = k1; - KReg kB = k2; - KReg kC = k3; - - Mem anyptr_gpA = ptr(gzA); - Mem anyptr_gpB = ptr(gzB); - Mem anyptr_gpC = ptr(gzC); - Mem anyptr_gpD = ptr(gzD); - - Mem intptr_gpA = e->intptr_ptr(gzA); - Mem intptr_gpB = e->intptr_ptr(gzB); - - St stA = st0; - St stB = st7; - - Mm mmA = mm0; - Mm mmB = mm1; - - Xmm xmmA = useRex1 ? xmm8 : xmm0; - Xmm xmmB = useRex2 ? xmm9 : xmm1; - Xmm xmmC = useRex2 ? xmm10 : xmm2; - Xmm xmmD = useRex2 ? xmm11 : xmm3; - - Ymm ymmA = useRex1 ? ymm8 : ymm0; - Ymm ymmB = useRex2 ? ymm9 : ymm1; - Ymm ymmC = useRex2 ? ymm10 : ymm2; - Ymm ymmD = useRex2 ? ymm11 : ymm3; - - Zmm zmmA = useRex1 ? zmm8 : zmm0; - Zmm zmmB = useRex2 ? zmm9 : zmm1; - Zmm zmmC = useRex2 ? zmm10 : zmm2; - - Mem vx_ptr = ptr(gzB, xmmB); - Mem vy_ptr = ptr(gzB, ymmB); - Mem vz_ptr = ptr(gzB, zmmB); - - Label L; - - // Base. - e->adc(gLoA, 1); - e->adc(gLoB, 1); - e->adc(gHiA, 1); - e->adc(gHiB, 1); - e->adc(gwA, 1); - e->adc(gwB, 1); - e->adc(gdA, 1); - e->adc(gdB, 1); - e->adc(gzA, 1); - e->adc(gzA, gzB); - e->adc(gzA, intptr_gpB); - e->adc(intptr_gpA, 1); - e->adc(intptr_gpA, gzB); - e->add(gLoA, 1); - e->add(gLoB, 1); - e->add(gHiA, 1); - e->add(gHiB, 1); - e->add(gwA, 1); - e->add(gwB, 1); - e->add(gdA, 1); - e->add(gdB, 1); - e->add(gzA, 1); - e->add(gzA, gzB); - e->add(gzA, intptr_gpB); - e->add(intptr_gpA, 1); - e->add(intptr_gpA, gzB); - e->and_(gLoA, 1); - e->and_(gLoB, 1); - e->and_(gHiA, 1); - e->and_(gHiB, 1); - e->and_(gwA, 1); - e->and_(gwB, 1); - e->and_(gdA, 1); - e->and_(gdB, 1); - e->and_(gzA, 1); - e->and_(gzA, gzB); - e->and_(gzA, intptr_gpB); - e->and_(intptr_gpA, 1); - e->and_(intptr_gpA, gzB); - e->bswap(gzA); - e->bt(gdA, 1); - e->bt(gzA, 1); - e->bt(gdA, gdB); - e->bt(gzA, gzB); - e->bt(intptr_gpA, 1); - e->bt(anyptr_gpA, gdB); - e->bt(intptr_gpA, gzB); - e->btc(gdA, 1); - e->btc(gzA, 1); - e->btc(gdA, gdB); - e->btc(gzA, gzB); - e->btc(intptr_gpA, 1); - e->btc(anyptr_gpA, gdB); - e->btc(intptr_gpA, gzB); - e->btr(gdA, 1); - e->btr(gzA, 1); - e->btr(gdA, gdB); - e->btr(gzA, gzB); - e->btr(intptr_gpA, 1); - e->btr(anyptr_gpA, gdB); - e->btr(intptr_gpA, gzB); - e->bts(gdA, 1); - e->bts(gzA, 1); - e->bts(gdA, gdB); - e->bts(gzA, gzB); - e->bts(intptr_gpA, 1); - e->bts(anyptr_gpA, gdB); - e->bts(intptr_gpA, gzB); - e->call(gzA); - e->call(intptr_gpA); - e->cbw(); // Implicit AX <- Sign Extend AL. - e->cbw(ax); // Explicit AX <- Sign Extend AL. - e->cdq(); // Implicit EDX:EAX <- Sign Extend EAX. - e->cdq(edx, eax); // Explicit EDX:EAX <- Sign Extend EAX. - if (isX64) e->cdqe(); // Implicit RAX <- Sign Extend EAX. - if (isX64) e->cdqe(eax); // Explicit RAX <- Sign Extend EAX. - e->cwd(); // Implicit DX:AX <- Sign Extend AX. - e->cwd(dx, ax); // Explicit DX:AX <- Sign Extend AX. - e->cwde(); // Implicit EAX <- Sign Extend AX. - e->cwde(eax); // Explicit EAX <- Sign Extend AX. - if (isX64) e->cqo(); // Implicit RDX:RAX <- Sign Extend RAX. - if (isX64) e->cqo(rdx, rax); // Explicit RDX:RAX <- Sign Extend RAX. - e->clc(); - e->cld(); - e->cmc(); - e->cmp(gLoA, 1); - e->cmp(gLoB, 1); - e->cmp(gHiA, 1); - e->cmp(gHiB, 1); - e->cmp(gwA, 1); - e->cmp(gwB, 1); - e->cmp(gdA, 1); - e->cmp(gdB, 1); - e->cmp(gzA, 1); - e->cmp(gLoA, gLoB); - e->cmp(gHiA, gHiB); - e->cmp(gwA, gwB); - e->cmp(gdA, gdB); - e->cmp(gzA, gzB); - e->cmp(gdA, anyptr_gpB); - e->cmp(gzA, intptr_gpB); - e->cmp(intptr_gpA, 1); - e->cmp(anyptr_gpA, gdB); - e->cmp(intptr_gpA, gzB); - e->cmpxchg(gdA, gdB); // Implicit regA, regB, <EAX> - e->cmpxchg(gzA, gzB); // Implicit regA, regB, <ZAX> - e->cmpxchg(gdA, gdB, eax); // Explicit regA, regB, <EAX> - e->cmpxchg(gzA, gzB, e->zax()); // Explicit regA, regB, <ZAX> - e->cmpxchg(anyptr_gpA, gdB); // Implicit mem , regB, <EAX> - e->cmpxchg(anyptr_gpA, gzB); // Implicit mem , regB, <ZAX> - e->cmpxchg(anyptr_gpA, gdB, eax); // Explicit mem , regB, <EAX> - e->cmpxchg(anyptr_gpA, gzB, e->zax()); // Explicit mem , regB, <ZAX> - e->cmpxchg8b(anyptr_gpA); // Implicit mem , <EDX>, <EAX>, <ECX>, <EBX> - e->cmpxchg8b(anyptr_gpA, - x86::edx, x86::eax, - x86::ecx, x86::ebx); // Explicit mem , <EDX>, <EAX>, <ECX>, <EBX> - if (isX64) e->cmpxchg16b(anyptr_gpA); // Implicit mem , <RDX>, <RAX>, <RCX>, <RBX> - if (isX64) e->cmpxchg16b(anyptr_gpA, - x86::rdx, x86::rax, - x86::rcx, x86::rbx); // Explicit mem , <EDX>, <EAX>, <ECX>, <EBX> - e->cpuid(); // Implicit <EAX>, <EBX>, <ECX>, <EDX> - e->cpuid(eax, ebx, ecx, edx); // Explicit <EAX>, <EBX>, <ECX>, <EDX> - e->crc32(gdA, byte_ptr(gzB)); - e->crc32(gdA, word_ptr(gzB)); - e->crc32(gdA, dword_ptr(gzB)); - if (isX64) e->crc32(gdA, qword_ptr(gzB)); - if (isX64) e->crc32(gzA, qword_ptr(gzB)); - e->dec(gLoA); - e->dec(gHiA); - e->dec(gwA); - e->dec(gdA); - e->dec(gzA); - e->dec(intptr_gpA); - e->inc(gLoA); - e->inc(gwA); - e->inc(gdA); - e->inc(gzA); - e->inc(intptr_gpA); - e->int_(13); - e->int3(); - e->into(); - e->lea(gzA, intptr_gpB); - e->mov(gLoA, 1); - e->mov(gHiA, 1); - e->mov(gwA, 1); - e->mov(gdA, 1); - e->mov(gzA, 1); - e->mov(gLoA, gLoB); - e->mov(gHiA, gHiB); - e->mov(gwA, gwB); - e->mov(gdA, gdB); - e->mov(gzA, gzB); - e->mov(gLoA, anyptr_gpB); - e->mov(gwA, anyptr_gpB); - e->mov(gdA, anyptr_gpB); - e->mov(gzA, intptr_gpB); - e->mov(anyptr_gpA, gLoB); - e->mov(anyptr_gpA, gwB); - e->mov(anyptr_gpA, gdB); - e->mov(intptr_gpA, 1); - e->mov(intptr_gpA, gzB); - e->movsx(gzA, gLoB); - e->movsx(gzA, byte_ptr(gzB)); - e->movzx(gzA, gLoB); - e->movzx(gzA, byte_ptr(gzB)); - e->movbe(gzA, anyptr_gpB); - e->movbe(anyptr_gpA, gzB); - e->neg(gzA); - e->neg(intptr_gpA); - e->nop(); - e->not_(gzA); - e->not_(intptr_gpA); - e->or_(gLoA, 1); - e->or_(gLoB, 1); - e->or_(gHiA, 1); - e->or_(gHiB, 1); - e->or_(gwA, 1); - e->or_(gwB, 1); - e->or_(gdA, 1); - e->or_(gdB, 1); - e->or_(gzA, 1); - e->or_(gzA, gzB); - e->or_(gzA, intptr_gpB); - e->or_(intptr_gpA, 1); - e->or_(intptr_gpA, gzB); - e->pop(gzA); - e->pop(intptr_gpA); - if (!isX64) e->popa(); - if (!isX64) e->popad(); - e->popf(); - if (!isX64) e->popfd(); - if ( isX64) e->popfq(); - e->push(gzA); - e->push(intptr_gpA); - e->push(0); - if (!isX64) e->pusha(); - if (!isX64) e->pushad(); - e->pushf(); - if (!isX64) e->pushfd(); - if ( isX64) e->pushfq(); - e->rcl(gdA, 0); - e->rcl(gzA, 0); - e->rcl(gdA, 1); - e->rcl(gzA, 1); - e->rcl(gdA, cl); - e->rcl(gzA, cl); - e->rcl(intptr_gpA, 0); - e->rcl(intptr_gpA, 1); - e->rcl(intptr_gpA, cl); - e->rcr(gdA, 0); - e->rcr(gzA, 0); - e->rcr(gdA, 1); - e->rcr(gzA, 1); - e->rcr(gdA, cl); - e->rcr(gzA, cl); - e->rcr(intptr_gpA, 0); - e->rcr(intptr_gpA, 1); - e->rcr(intptr_gpA, cl); - e->rdtsc(); // Implicit <EDX:EAX> - e->rdtsc(edx, eax); // Explicit <EDX:EAX> - e->rdtscp(); // Implicit <EDX:EAX>, <ECX> - e->rdtscp(edx, eax, ecx); // Implicit <EDX:EAX>, <ECX> - e->ret(); - e->ret(0); - e->rol(gdA, 0); - e->rol(gzA, 0); - e->rol(gdA, 1); - e->rol(gzA, 1); - e->rol(gdA, cl); - e->rol(gzA, cl); - e->rol(intptr_gpA, 0); - e->rol(intptr_gpA, 1); - e->rol(intptr_gpA, cl); - e->ror(gdA, 0); - e->ror(gzA, 0); - e->ror(gdA, 1); - e->ror(gzA, 1); - e->ror(gdA, cl); - e->ror(gzA, cl); - e->ror(intptr_gpA, 0); - e->ror(intptr_gpA, 1); - e->ror(intptr_gpA, cl); - e->sbb(gLoA, 1); - e->sbb(gLoB, 1); - e->sbb(gHiA, 1); - e->sbb(gHiB, 1); - e->sbb(gwA, 1); - e->sbb(gwB, 1); - e->sbb(gdA, 1); - e->sbb(gdB, 1); - e->sbb(gzA, 1); - e->sbb(gzA, gzB); - e->sbb(gzA, intptr_gpB); - e->sbb(intptr_gpA, 1); - e->sbb(intptr_gpA, gzB); - e->sal(gdA, 0); - e->sal(gzA, 0); - e->sal(gdA, 1); - e->sal(gzA, 1); - e->sal(gdA, cl); - e->sal(gzA, cl); - e->sal(intptr_gpA, 0); - e->sal(intptr_gpA, 1); - e->sal(intptr_gpA, cl); - e->sar(gdA, 0); - e->sar(gzA, 0); - e->sar(gdA, 1); - e->sar(gzA, 1); - e->sar(gdA, cl); - e->sar(gzA, cl); - e->sar(intptr_gpA, 0); - e->sar(intptr_gpA, 1); - e->sar(intptr_gpA, cl); - e->shl(gdA, 0); - e->shl(gzA, 0); - e->shl(gdA, 1); - e->shl(gzA, 1); - e->shl(gdA, cl); - e->shl(gzA, cl); - e->shl(intptr_gpA, 0); - e->shl(intptr_gpA, 1); - e->shl(intptr_gpA, cl); - e->shr(gdA, 0); - e->shr(gzA, 0); - e->shr(gdA, 1); - e->shr(gzA, 1); - e->shr(gdA, cl); - e->shr(gzA, cl); - e->shr(intptr_gpA, 0); - e->shr(intptr_gpA, 1); - e->shr(intptr_gpA, cl); - e->shld(gdA, gdB, 0); - e->shld(gzA, gzB, 0); - e->shld(gdA, gdB, cl); - e->shld(gzA, gzB, cl); - e->shld(anyptr_gpA, gdB, 0); - e->shld(intptr_gpA, gzB, 0); - e->shld(anyptr_gpA, gdB, cl); - e->shld(intptr_gpA, gzB, cl); - e->shrd(gdA, gdB, 0); - e->shrd(gzA, gzB, 0); - e->shrd(gdA, gdB, cl); - e->shrd(gzA, gzB, cl); - e->shrd(anyptr_gpA, gdB, 0); - e->shrd(intptr_gpA, gzB, 0); - e->shrd(anyptr_gpA, gdB, cl); - e->shrd(intptr_gpA, gzB, cl); - e->stc(); - e->std(); - e->sti(); - e->sub(gLoA, 1); - e->sub(gLoB, 1); - e->sub(gHiA, 1); - e->sub(gHiB, 1); - e->sub(gwA, 1); - e->sub(gwB, 1); - e->sub(gdA, 1); - e->sub(gdB, 1); - e->sub(gzA, 1); - e->sub(gzA, gzB); - e->sub(gzA, intptr_gpB); - e->sub(intptr_gpA, 1); - e->sub(intptr_gpA, gzB); - e->swapgs(); - e->test(gzA, 1); - e->test(gzA, gzB); - e->test(intptr_gpA, 1); - e->test(intptr_gpA, gzB); - e->ud2(); - e->xadd(gzA, gzB); - e->xadd(intptr_gpA, gzB); - e->xchg(gzA, gzB); - e->xchg(intptr_gpA, gzB); - e->xchg(gzA, intptr_gpB); - e->xor_(gLoA, 1); - e->xor_(gLoB, 1); - e->xor_(gHiA, 1); - e->xor_(gHiB, 1); - e->xor_(gwA, 1); - e->xor_(gwB, 1); - e->xor_(gdA, 1); - e->xor_(gdB, 1); - e->xor_(gzA, 1); - e->xor_(gzA, gzB); - e->xor_(gzA, intptr_gpB); - e->xor_(intptr_gpA, 1); - e->xor_(intptr_gpA, gzB); - - // Special case - div|mul. - e->div(cl); // Implicit AH:AL <- AX * r8 - e->div(byte_ptr(gzA)); // Implicit AH:AL <- AX * m8 - e->div(ax, cl); // Explicit AH:AL <- AX * r8 - e->div(ax, anyptr_gpA); // Explicit AH:AL <- AX * m8 - - e->div(cx); // Implicit DX:AX <- DX:AX * r16 - e->div(word_ptr(gzA)); // Implicit DX:AX <- DX:AX * m16 - e->div(dx, ax, cx); // Explicit DX:AX <- DX:AX * r16 - e->div(dx, ax, anyptr_gpA); // Explicit DX:AX <- DX:AX * m16 - - e->div(ecx); // Implicit EDX:EAX <- EDX:EAX * r32 - e->div(dword_ptr(gzA)); // Implicit EDX:EAX <- EDX:EAX * m32 - e->div(edx, eax, ecx); // Explicit EDX:EAX <- EDX:EAX * r32 - e->div(edx, eax, anyptr_gpA); // Explicit EDX:EAX <- EDX:EAX * m32 - - if (isX64) e->div(rcx); // Implicit RDX|RAX <- RDX:RAX * r64 - if (isX64) e->div(qword_ptr(gzA)); // Implicit RDX|RAX <- RDX:RAX * m64 - if (isX64) e->div(rdx, rax, rcx); // Explicit RDX|RAX <- RDX:RAX * r64 - if (isX64) e->div(rdx, rax, anyptr_gpA); // Explicit RDX|RAX <- RDX:RAX * m64 - - e->idiv(cl); // Implicit AH:AL <- AX * r8 - e->idiv(byte_ptr(gzA)); // Implicit AH:AL <- AX * m8 - e->idiv(ax, cl); // Explicit AH:AL <- AX * r8 - e->idiv(ax, anyptr_gpA); // Explicit AH:AL <- AX * m8 - - e->idiv(cx); // Implicit DX:AX <- DX:AX * r16 - e->idiv(word_ptr(gzA)); // Implicit DX:AX <- DX:AX * m16 - e->idiv(dx, ax, cx); // Explicit DX:AX <- DX:AX * r16 - e->idiv(dx, ax, anyptr_gpA); // Explicit DX:AX <- DX:AX * m16 - - e->idiv(ecx); // Implicit EDX:EAX <- EDX:EAX * r32 - e->idiv(dword_ptr(gzA)); // Implicit EDX:EAX <- EDX:EAX * m32 - e->idiv(edx, eax, ecx); // Explicit EDX:EAX <- EDX:EAX * r32 - e->idiv(edx, eax, anyptr_gpA); // Explicit EDX:EAX <- EDX:EAX * m32 - - if (isX64) e->idiv(rcx); // Implicit RDX|RAX <- RDX:RAX * r64 - if (isX64) e->idiv(qword_ptr(gzA)); // Implicit RDX|RAX <- RDX:RAX * m64 - if (isX64) e->idiv(rdx, rax, rcx); // Explicit RDX|RAX <- RDX:RAX * r64 - if (isX64) e->idiv(rdx, rax, anyptr_gpA); // Explicit RDX|RAX <- RDX:RAX * m64 - - e->mul(cl); // Implicit AX <- AL * r8 - e->mul(byte_ptr(gzA)); // Implicit AX <- AL * m8 - e->mul(ax, cl); // Explicit AX <- AL * r8 - e->mul(ax, anyptr_gpA); // Explicit AX <- AL * m8 - - e->mul(cx); // Implicit DX:AX <- AX * r16 - e->mul(word_ptr(gzA)); // Implicit DX:AX <- AX * m16 - e->mul(dx, ax, cx); // Explicit DX:AX <- AX * r16 - e->mul(dx, ax, anyptr_gpA); // Explicit DX:AX <- AX * m16 - - e->mul(ecx); // Implicit EDX:EAX <- EAX * r32 - e->mul(dword_ptr(gzA)); // Implicit EDX:EAX <- EAX * m32 - e->mul(edx, eax, ecx); // Explicit EDX:EAX <- EAX * r32 - e->mul(edx, eax, anyptr_gpA); // Explicit EDX:EAX <- EAX * m32 - - if (isX64) e->mul(rcx); // Implicit RDX|RAX <- RAX * r64 - if (isX64) e->mul(qword_ptr(gzA)); // Implicit RDX|RAX <- RAX * m64 - if (isX64) e->mul(rdx, rax, rcx); // Explicit RDX|RAX <- RAX * r64 - if (isX64) e->mul(rdx, rax, anyptr_gpA); // Explicit RDX|RAX <- RAX * m64 - - e->imul(gdA); - e->imul(gzA); - e->imul(intptr_gpA); - e->imul(gdA, 1); - e->imul(gzA, 1); - e->imul(gdA, gdB); - e->imul(gzA, gzB); - e->imul(gdA, gdB, 1); - e->imul(gzA, gzB, 1); - e->imul(gdA, anyptr_gpB); - e->imul(gzA, intptr_gpB); - e->imul(gdA, anyptr_gpB, 1); - e->imul(gzA, intptr_gpB, 1); - - // Special case - zero-extend 32-bit immediate instead of sign-extend: - if (isX64) e->mov(gzA, uint32_t(0xFEEDFEED)); - if (isX64) e->and_(gzA, uint32_t(0xFEEDFEED)); - - // Special case - mov with absolute 32-bit address. - e->mov(al , ptr(0x01020304u)); - e->mov(ax , ptr(0x01020304u)); - e->mov(eax, ptr(0x01020304u)); - e->mov(ptr(0x01020304u), al ); - e->mov(ptr(0x01020304u), ax ); - e->mov(ptr(0x01020304u), eax); - - // Special case - mov with absolute 64-bit address. - if (isX64) e->mov(al , ptr(0x0102030405060708u)); - if (isX64) e->mov(ax , ptr(0x0102030405060708u)); - if (isX64) e->mov(eax, ptr(0x0102030405060708u)); - if (isX64) e->mov(rax, ptr(0x0102030405060708u)); - if (isX64) e->mov(ptr(0x0102030405060708u), al ); - if (isX64) e->mov(ptr(0x0102030405060708u), ax ); - if (isX64) e->mov(ptr(0x0102030405060708u), eax); - if (isX64) e->mov(ptr(0x0102030405060708u), rax); - - // Control registers. - e->nop(); - - e->mov(gzA, cr0); - e->mov(cr0, gzA); - if (isX64) e->mov(gzA, cr8); - if (isX64) e->mov(cr8, gzA); - - // Debug registers. - e->nop(); - - e->mov(gzA, dr0); - e->mov(dr0, gzA); - - // Segment registers. - e->nop(); - - if (!isX64) e->mov(es, ax); - if (!isX64) e->mov(es, bx); - if (!isX64) e->mov(ax, es); - if (!isX64) e->mov(bx, es); - - if (!isX64) e->mov(cs, ax); - if (!isX64) e->mov(cs, bx); - if (!isX64) e->mov(ax, cs); - if (!isX64) e->mov(bx, cs); - - if (!isX64) e->mov(ss, ax); - if (!isX64) e->mov(ss, bx); - if (!isX64) e->mov(ax, ss); - if (!isX64) e->mov(bx, ss); - - if (!isX64) e->mov(ds, ax); - if (!isX64) e->mov(ds, bx); - if (!isX64) e->mov(ax, ds); - if (!isX64) e->mov(bx, ds); - - e->mov(fs, ax); - e->mov(fs, bx); - e->mov(ax, fs); - e->mov(bx, fs); - - e->mov(gs, ax); - e->mov(gs, bx); - e->mov(ax, gs); - e->mov(bx, gs); - - // Instructions using REP prefix. - e->nop(); - - e->in(al, 0); - e->in(al, dx); - e->in(ax, 0); - e->in(ax, dx); - e->in(eax, 0); - e->in(eax, dx); - e->rep().ins(byte_ptr(e->zdi()), dx); - e->rep().ins(word_ptr(e->zdi()), dx); - e->rep().ins(dword_ptr(e->zdi()), dx); - - e->out(imm(0), al); - e->out(dx, al); - e->out(imm(0), ax); - e->out(dx, ax); - e->out(imm(0), eax); - e->out(dx, eax); - e->rep().outs(dx, byte_ptr(e->zsi())); - e->rep().outs(dx, word_ptr(e->zsi())); - e->rep().outs(dx, dword_ptr(e->zsi())); - - e->lodsb(); - e->lodsd(); - e->lodsw(); - e->rep().lodsb(); - e->rep().lodsd(); - e->rep().lodsw(); - if (isX64) e->rep().lodsq(); - - e->movsb(); - e->movsd(); - e->movsw(); - e->rep().movsb(); - e->rep().movsd(); - e->rep().movsw(); - if (isX64) e->rep().movsq(); - - e->stosb(); - e->stosd(); - e->stosw(); - e->rep().stosb(); - e->rep().stosd(); - e->rep().stosw(); - if (isX64) e->rep().stosq(); - - e->cmpsb(); - e->cmpsd(); - e->cmpsw(); - e->repz().cmpsb(); - e->repz().cmpsd(); - e->repz().cmpsw(); - if (isX64) e->repz().cmpsq(); - e->repnz().cmpsb(); - e->repnz().cmpsd(); - e->repnz().cmpsw(); - if (isX64) e->repnz().cmpsq(); - - e->scasb(); - e->scasd(); - e->scasw(); - e->repz().scasb(); - e->repz().scasd(); - e->repz().scasw(); - if (isX64) e->repz().scasq(); - e->repnz().scasb(); - e->repnz().scasd(); - e->repnz().scasw(); - if (isX64) e->repnz().scasq(); - - // Label...Jcc/Jecxz/Jmp. - e->nop(); - - L = e->newLabel(); - e->bind(L); - e->ja(L); - e->jae(L); - e->jb(L); - e->jbe(L); - e->jc(L); - e->je(L); - e->jg(L); - e->jge(L); - e->jl(L); - e->jle(L); - e->jna(L); - e->jnae(L); - e->jnb(L); - e->jnbe(L); - e->jnc(L); - e->jne(L); - e->jng(L); - e->jnge(L); - e->jnl(L); - e->jnle(L); - e->jno(L); - e->jnp(L); - e->jns(L); - e->jnz(L); - e->jo(L); - e->jp(L); - e->jpe(L); - e->jpo(L); - e->js(L); - e->jz(L); - e->jecxz(ecx, L); - e->jmp(L); - - // Jcc/Jecxz/Jmp...Label. - e->nop(); - - L = e->newLabel(); - e->ja(L); - e->jae(L); - e->jb(L); - e->jbe(L); - e->jc(L); - e->je(L); - e->jg(L); - e->jge(L); - e->jl(L); - e->jle(L); - e->jna(L); - e->jnae(L); - e->jnb(L); - e->jnbe(L); - e->jnc(L); - e->jne(L); - e->jng(L); - e->jnge(L); - e->jnl(L); - e->jnle(L); - e->jno(L); - e->jnp(L); - e->jns(L); - e->jnz(L); - e->jo(L); - e->jp(L); - e->jpe(L); - e->jpo(L); - e->js(L); - e->jz(L); - e->jecxz(ecx, L); - e->jmp(L); - e->bind(L); - - // FPU. - e->nop(); - - e->f2xm1(); - e->fabs(); - e->fadd(stA, stB); - e->fadd(stB, stA); - e->fadd(dword_ptr(gzA)); - e->fadd(qword_ptr(gzA)); - e->faddp(stB); - e->faddp(); - e->fbld(dword_ptr(gzA)); - e->fbstp(dword_ptr(gzA)); - e->fchs(); - e->fclex(); - e->fcom(stB); - e->fcom(); - e->fcom(dword_ptr(gzA)); - e->fcom(qword_ptr(gzA)); - e->fcomp(stB); - e->fcomp(); - e->fcomp(dword_ptr(gzA)); - e->fcomp(qword_ptr(gzA)); - e->fcompp(); - e->fcos(); - e->fdecstp(); - e->fdiv(stA, stB); - e->fdiv(stB, stA); - e->fdiv(dword_ptr(gzA)); - e->fdiv(qword_ptr(gzA)); - e->fdivp(stB); - e->fdivp(); - e->fdivr(stA, stB); - e->fdivr(stB, stA); - e->fdivr(dword_ptr(gzA)); - e->fdivr(qword_ptr(gzA)); - e->fdivrp(stB); - e->fdivrp(); - e->fiadd(dword_ptr(gzA)); - e->ficom(word_ptr(gzA)); - e->ficom(dword_ptr(gzA)); - e->ficomp(word_ptr(gzA)); - e->ficomp(dword_ptr(gzA)); - e->fidiv(word_ptr(gzA)); - e->fidiv(dword_ptr(gzA)); - e->fidivr(word_ptr(gzA)); - e->fidivr(dword_ptr(gzA)); - e->fild(word_ptr(gzA)); - e->fild(dword_ptr(gzA)); - e->fild(qword_ptr(gzA)); - e->fimul(word_ptr(gzA)); - e->fimul(dword_ptr(gzA)); - e->fincstp(); - e->finit(); - e->fninit(); - e->fisub(word_ptr(gzA)); - e->fisub(dword_ptr(gzA)); - e->fisubr(word_ptr(gzA)); - e->fisubr(dword_ptr(gzA)); - e->fist(word_ptr(gzA)); - e->fist(dword_ptr(gzA)); - e->fistp(word_ptr(gzA)); - e->fistp(dword_ptr(gzA)); - e->fistp(qword_ptr(gzA)); - e->fld(dword_ptr(gzA)); - e->fld(qword_ptr(gzA)); - e->fld(tword_ptr(gzA)); - e->fld1(); - e->fldl2t(); - e->fldl2e(); - e->fldpi(); - e->fldlg2(); - e->fldln2(); - e->fldz(); - e->fldcw(anyptr_gpA); - e->fldenv(anyptr_gpA); - e->fmul(stA, stB); - e->fmul(stB, stA); - e->fmul(dword_ptr(gzA)); - e->fmul(qword_ptr(gzA)); - e->fmulp(stB); - e->fmulp(); - e->fnclex(); - e->fnop(); - e->fnsave(anyptr_gpA); - e->fnstenv(anyptr_gpA); - e->fnstcw(anyptr_gpA); - e->fpatan(); - e->fprem(); - e->fprem1(); - e->fptan(); - e->frndint(); - e->frstor(anyptr_gpA); - e->fsave(anyptr_gpA); - e->fscale(); - e->fsin(); - e->fsincos(); - e->fsqrt(); - e->fst(dword_ptr(gzA)); - e->fst(qword_ptr(gzA)); - e->fstp(dword_ptr(gzA)); - e->fstp(qword_ptr(gzA)); - e->fstp(tword_ptr(gzA)); - e->fstcw(anyptr_gpA); - e->fstenv(anyptr_gpA); - e->fsub(stA, stB); - e->fsub(stB, stA); - e->fsub(dword_ptr(gzA)); - e->fsub(qword_ptr(gzA)); - e->fsubp(stB); - e->fsubp(); - e->fsubr(stA, stB); - e->fsubr(stB, stA); - e->fsubr(dword_ptr(gzA)); - e->fsubr(qword_ptr(gzA)); - e->fsubrp(stB); - e->fsubrp(); - e->ftst(); - e->fucom(stB); - e->fucom(); - e->fucom(stB); - e->fucomi(stB); - e->fucomip(stB); - e->fucomp(stB); - e->fucompp(); - e->fxam(); - e->fxtract(); - e->fyl2x(); - e->fyl2xp1(); - - // LAHF/SAHF - e->lahf(); // Implicit <AH> - e->lahf(ah); // Explicit <AH> - e->sahf(); // Implicit <AH> - e->sahf(ah); // Explicit <AH> - - // FXSR. - e->fxrstor(anyptr_gpA); - e->fxsave(anyptr_gpA); - - // XSAVE. - e->nop(); - - e->xgetbv(); // Implicit <EDX:EAX>, <ECX> - e->xgetbv(edx, eax, ecx); // Explicit <EDX:EAX>, <ECX> - - e->xsetbv(); // Implicit <EDX:EAX>, <ECX> - e->xsetbv(edx, eax, ecx); // Explicit <EDX:EAX>, <ECX> - - e->xrstor(anyptr_gpA); // Implicit <EDX:EAX> - e->xrstors(anyptr_gpA); // Implicit <EDX:EAX> - e->xsave(anyptr_gpA); // Implicit <EDX:EAX> - e->xsavec(anyptr_gpA); // Implicit <EDX:EAX> - e->xsaveopt(anyptr_gpA); // Implicit <EDX:EAX> - e->xsaves(anyptr_gpA); // Implicit <EDX:EAX> - - if (isX64) e->xrstor64(anyptr_gpA); // Implicit <EDX:EAX> - if (isX64) e->xrstors64(anyptr_gpA); // Implicit <EDX:EAX> - if (isX64) e->xsave64(anyptr_gpA); // Implicit <EDX:EAX> - if (isX64) e->xsavec64(anyptr_gpA); // Implicit <EDX:EAX> - if (isX64) e->xsaveopt64(anyptr_gpA); // Implicit <EDX:EAX> - if (isX64) e->xsaves64(anyptr_gpA); // Implicit <EDX:EAX> - - // POPCNT. - e->nop(); - - e->popcnt(gdA, gdB); - e->popcnt(gzA, gzB); - e->popcnt(gdA, anyptr_gpB); - e->popcnt(gzA, anyptr_gpB); - - // LZCNT. - e->nop(); - - e->lzcnt(gdA, gdB); - e->lzcnt(gzA, gzB); - e->lzcnt(gdA, anyptr_gpB); - e->lzcnt(gzA, anyptr_gpB); - - // BMI. - e->nop(); - - e->andn(gdA, gdB, gdC); - e->andn(gzA, gzB, gzC); - e->andn(gdA, gdB, anyptr_gpC); - e->andn(gzA, gzB, anyptr_gpC); - e->bextr(gdA, gdB, gdC); - e->bextr(gzA, gzB, gzC); - e->bextr(gdA, anyptr_gpB, gdC); - e->bextr(gzA, anyptr_gpB, gzC); - e->blsi(gdA, gdB); - e->blsi(gzA, gzB); - e->blsi(gdA, anyptr_gpB); - e->blsi(gzA, anyptr_gpB); - e->blsmsk(gdA, gdB); - e->blsmsk(gzA, gzB); - e->blsmsk(gdA, anyptr_gpB); - e->blsmsk(gzA, anyptr_gpB); - e->blsr(gdA, gdB); - e->blsr(gzA, gzB); - e->blsr(gdA, anyptr_gpB); - e->blsr(gzA, anyptr_gpB); - e->tzcnt(gdA, gdB); - e->tzcnt(gzA, gzB); - e->tzcnt(gdA, anyptr_gpB); - e->tzcnt(gzA, anyptr_gpB); - - // BMI2. - e->nop(); - - e->bzhi(gdA, gdB, gdC); - e->bzhi(gzA, gzB, gzC); - e->bzhi(gdA, anyptr_gpB, gdC); - e->bzhi(gzA, anyptr_gpB, gzC); - e->mulx(gdA, gdB, gdC); // Implicit gpA, gpB, gpC, <EDX> - e->mulx(gdA, gdB, gdC, edx); // Explicit gpA, gpB, gpC, <EDX> - e->mulx(gzA, gzB, gzC); // Implicit gpA, gpB, gpC, <EDX|RDX> - e->mulx(gzA, gzB, gzC, e->zdx()); // Explicit gpA, gpB, gpC, <EDX|RDX> - e->mulx(gdA, gdB, anyptr_gpC); // Implicit gpA, gpB, mem, <EDX> - e->mulx(gdA, gdB, anyptr_gpC, edx); // Explicit gpA, gpB, mem, <EDX> - e->mulx(gzA, gzB, anyptr_gpC); // Implicit gpA, gpB, mem, <EDX|RDX> - e->mulx(gzA, gzB, anyptr_gpC, e->zdx()); // Explicit gpA, gpB, mem, <EDX|RDX> - e->pdep(gdA, gdB, gdC); - e->pdep(gzA, gzB, gzC); - e->pdep(gdA, gdB, anyptr_gpC); - e->pdep(gzA, gzB, anyptr_gpC); - e->pext(gdA, gdB, gdC); - e->pext(gzA, gzB, gzC); - e->pext(gdA, gdB, anyptr_gpC); - e->pext(gzA, gzB, anyptr_gpC); - e->rorx(gdA, gdB, 0); - e->rorx(gzA, gzB, 0); - e->rorx(gdA, anyptr_gpB, 0); - e->rorx(gzA, anyptr_gpB, 0); - e->sarx(gdA, gdB, gdC); - e->sarx(gzA, gzB, gzC); - e->sarx(gdA, anyptr_gpB, gdC); - e->sarx(gzA, anyptr_gpB, gzC); - e->shlx(gdA, gdB, gdC); - e->shlx(gzA, gzB, gzC); - e->shlx(gdA, anyptr_gpB, gdC); - e->shlx(gzA, anyptr_gpB, gzC); - e->shrx(gdA, gdB, gdC); - e->shrx(gzA, gzB, gzC); - e->shrx(gdA, anyptr_gpB, gdC); - e->shrx(gzA, anyptr_gpB, gzC); - - // ADX. - e->nop(); - - e->adcx(gdA, gdB); - e->adcx(gzA, gzB); - e->adcx(gdA, anyptr_gpB); - e->adcx(gzA, anyptr_gpB); - e->adox(gdA, gdB); - e->adox(gzA, gzB); - e->adox(gdA, anyptr_gpB); - e->adox(gzA, anyptr_gpB); - - // TBM. - e->nop(); - - e->blcfill(gdA, gdB); - e->blcfill(gzA, gzB); - e->blcfill(gdA, anyptr_gpB); - e->blcfill(gzA, anyptr_gpB); - - e->blci(gdA, gdB); - e->blci(gzA, gzB); - e->blci(gdA, anyptr_gpB); - e->blci(gzA, anyptr_gpB); - - e->blcic(gdA, gdB); - e->blcic(gzA, gzB); - e->blcic(gdA, anyptr_gpB); - e->blcic(gzA, anyptr_gpB); - - e->blcmsk(gdA, gdB); - e->blcmsk(gzA, gzB); - e->blcmsk(gdA, anyptr_gpB); - e->blcmsk(gzA, anyptr_gpB); - - e->blcs(gdA, gdB); - e->blcs(gzA, gzB); - e->blcs(gdA, anyptr_gpB); - e->blcs(gzA, anyptr_gpB); - - e->blsfill(gdA, gdB); - e->blsfill(gzA, gzB); - e->blsfill(gdA, anyptr_gpB); - e->blsfill(gzA, anyptr_gpB); - - e->blsic(gdA, gdB); - e->blsic(gzA, gzB); - e->blsic(gdA, anyptr_gpB); - e->blsic(gzA, anyptr_gpB); - - e->t1mskc(gdA, gdB); - e->t1mskc(gzA, gzB); - e->t1mskc(gdA, anyptr_gpB); - e->t1mskc(gzA, anyptr_gpB); - - e->tzmsk(gdA, gdB); - e->tzmsk(gzA, gzB); - e->tzmsk(gdA, anyptr_gpB); - e->tzmsk(gzA, anyptr_gpB); - - // CLFLUSH / CLFLUSH_OPT. - e->nop(); - e->clflush(anyptr_gpA); - e->clflushopt(anyptr_gpA); - - // CLWB. - e->nop(); - e->clwb(anyptr_gpA); - - // CLZERO. - e->nop(); - e->clzero(); // Implicit <ds:[EAX|RAX]> - e->clzero(ptr(e->zax())); // Explicit <ds:[EAX|RAX]> - - // MONITOR[X] / MWAIT[X]. - e->nop(); - e->monitor(); // Implicit <ds:[EAX|RAX]>, <ECX>, <EDX> - e->monitorx(); // Implicit <ds:[EAX|RAX]>, <ECX>, <EDX> - e->mwait(); // Implicit <EAX>, <ECX> - e->mwaitx(); // Implicit <EAX>, <ECX>, <EBX> - - // PCOMMIT. - e->nop(); - e->pcommit(); - - // PREFETCH / PREFETCHW / PREFETCHWT1. - e->nop(); - e->prefetch(anyptr_gpA); // 3DNOW. - e->prefetchnta(anyptr_gpA); // MMX+SSE. - e->prefetcht0(anyptr_gpA); // MMX+SSE. - e->prefetcht1(anyptr_gpA); // MMX+SSE. - e->prefetcht2(anyptr_gpA); // MMX+SSE. - e->prefetchw(anyptr_gpA); // PREFETCHW. - e->prefetchwt1(anyptr_gpA); // PREFETCHWT1. - - // RDRAND / RDSEED. - e->nop(); - - e->rdrand(gdA); - e->rdrand(gzA); - e->rdseed(gdA); - e->rdseed(gzA); - - // MMX/MMX2. - e->nop(); - - e->movd(anyptr_gpA, mmB); - e->movd(gdA, mmB); - e->movd(mmA, anyptr_gpB); - e->movd(mmA, gdB); - e->movq(mmA, mmB); - e->movq(anyptr_gpA, mmB); - e->movq(mmA, anyptr_gpB); - e->packuswb(mmA, mmB); - e->packuswb(mmA, anyptr_gpB); - e->paddb(mmA, mmB); - e->paddb(mmA, anyptr_gpB); - e->paddw(mmA, mmB); - e->paddw(mmA, anyptr_gpB); - e->paddd(mmA, mmB); - e->paddd(mmA, anyptr_gpB); - e->paddsb(mmA, mmB); - e->paddsb(mmA, anyptr_gpB); - e->paddsw(mmA, mmB); - e->paddsw(mmA, anyptr_gpB); - e->paddusb(mmA, mmB); - e->paddusb(mmA, anyptr_gpB); - e->paddusw(mmA, mmB); - e->paddusw(mmA, anyptr_gpB); - e->pand(mmA, mmB); - e->pand(mmA, anyptr_gpB); - e->pandn(mmA, mmB); - e->pandn(mmA, anyptr_gpB); - e->pcmpeqb(mmA, mmB); - e->pcmpeqb(mmA, anyptr_gpB); - e->pcmpeqw(mmA, mmB); - e->pcmpeqw(mmA, anyptr_gpB); - e->pcmpeqd(mmA, mmB); - e->pcmpeqd(mmA, anyptr_gpB); - e->pcmpgtb(mmA, mmB); - e->pcmpgtb(mmA, anyptr_gpB); - e->pcmpgtw(mmA, mmB); - e->pcmpgtw(mmA, anyptr_gpB); - e->pcmpgtd(mmA, mmB); - e->pcmpgtd(mmA, anyptr_gpB); - e->pmulhw(mmA, mmB); - e->pmulhw(mmA, anyptr_gpB); - e->pmullw(mmA, mmB); - e->pmullw(mmA, anyptr_gpB); - e->por(mmA, mmB); - e->por(mmA, anyptr_gpB); - e->pmaddwd(mmA, mmB); - e->pmaddwd(mmA, anyptr_gpB); - e->pslld(mmA, mmB); - e->pslld(mmA, anyptr_gpB); - e->pslld(mmA, 0); - e->psllq(mmA, mmB); - e->psllq(mmA, anyptr_gpB); - e->psllq(mmA, 0); - e->psllw(mmA, mmB); - e->psllw(mmA, anyptr_gpB); - e->psllw(mmA, 0); - e->psrad(mmA, mmB); - e->psrad(mmA, anyptr_gpB); - e->psrad(mmA, 0); - e->psraw(mmA, mmB); - e->psraw(mmA, anyptr_gpB); - e->psraw(mmA, 0); - e->psrld(mmA, mmB); - e->psrld(mmA, anyptr_gpB); - e->psrld(mmA, 0); - e->psrlq(mmA, mmB); - e->psrlq(mmA, anyptr_gpB); - e->psrlq(mmA, 0); - e->psrlw(mmA, mmB); - e->psrlw(mmA, anyptr_gpB); - e->psrlw(mmA, 0); - e->psubb(mmA, mmB); - e->psubb(mmA, anyptr_gpB); - e->psubw(mmA, mmB); - e->psubw(mmA, anyptr_gpB); - e->psubd(mmA, mmB); - e->psubd(mmA, anyptr_gpB); - e->psubsb(mmA, mmB); - e->psubsb(mmA, anyptr_gpB); - e->psubsw(mmA, mmB); - e->psubsw(mmA, anyptr_gpB); - e->psubusb(mmA, mmB); - e->psubusb(mmA, anyptr_gpB); - e->psubusw(mmA, mmB); - e->psubusw(mmA, anyptr_gpB); - e->punpckhbw(mmA, mmB); - e->punpckhbw(mmA, anyptr_gpB); - e->punpckhwd(mmA, mmB); - e->punpckhwd(mmA, anyptr_gpB); - e->punpckhdq(mmA, mmB); - e->punpckhdq(mmA, anyptr_gpB); - e->punpcklbw(mmA, mmB); - e->punpcklbw(mmA, anyptr_gpB); - e->punpcklwd(mmA, mmB); - e->punpcklwd(mmA, anyptr_gpB); - e->punpckldq(mmA, mmB); - e->punpckldq(mmA, anyptr_gpB); - e->pxor(mmA, mmB); - e->pxor(mmA, anyptr_gpB); - e->emms(); - - // 3DNOW. - e->nop(); - - e->pavgusb(mmA, mmB); - e->pavgusb(mmA, anyptr_gpB); - e->pf2id(mmA, mmB); - e->pf2id(mmA, anyptr_gpB); - e->pf2iw(mmA, mmB); - e->pf2iw(mmA, anyptr_gpB); - e->pfacc(mmA, mmB); - e->pfacc(mmA, anyptr_gpB); - e->pfadd(mmA, mmB); - e->pfadd(mmA, anyptr_gpB); - e->pfcmpeq(mmA, mmB); - e->pfcmpeq(mmA, anyptr_gpB); - e->pfcmpge(mmA, mmB); - e->pfcmpge(mmA, anyptr_gpB); - e->pfcmpgt(mmA, mmB); - e->pfcmpgt(mmA, anyptr_gpB); - e->pfmax(mmA, mmB); - e->pfmax(mmA, anyptr_gpB); - e->pfmin(mmA, mmB); - e->pfmin(mmA, anyptr_gpB); - e->pfmul(mmA, mmB); - e->pfmul(mmA, anyptr_gpB); - e->pfnacc(mmA, mmB); - e->pfnacc(mmA, anyptr_gpB); - e->pfpnacc(mmA, mmB); - e->pfpnacc(mmA, anyptr_gpB); - e->pfrcp(mmA, mmB); - e->pfrcp(mmA, anyptr_gpB); - e->pfrcpit1(mmA, mmB); - e->pfrcpit1(mmA, anyptr_gpB); - e->pfrcpit2(mmA, mmB); - e->pfrcpit2(mmA, anyptr_gpB); - e->pfrcpv(mmA, mmB); - e->pfrcpv(mmA, anyptr_gpB); - e->pfrsqit1(mmA, mmB); - e->pfrsqit1(mmA, anyptr_gpB); - e->pfrsqrt(mmA, mmB); - e->pfrsqrt(mmA, anyptr_gpB); - e->pfrsqrtv(mmA, mmB); - e->pfrsqrtv(mmA, anyptr_gpB); - e->pfsub(mmA, mmB); - e->pfsub(mmA, anyptr_gpB); - e->pfsubr(mmA, mmB); - e->pfsubr(mmA, anyptr_gpB); - e->pi2fd(mmA, mmB); - e->pi2fd(mmA, anyptr_gpB); - e->pi2fw(mmA, mmB); - e->pi2fw(mmA, anyptr_gpB); - e->pmulhrw(mmA, mmB); - e->pmulhrw(mmA, anyptr_gpB); - e->pswapd(mmA, mmB); - e->pswapd(mmA, anyptr_gpB); - e->femms(); - - // SSE. - e->nop(); - - e->addps(xmmA, xmmB); - e->addps(xmmA, anyptr_gpB); - e->addss(xmmA, xmmB); - e->addss(xmmA, anyptr_gpB); - e->andnps(xmmA, xmmB); - e->andnps(xmmA, anyptr_gpB); - e->andps(xmmA, xmmB); - e->andps(xmmA, anyptr_gpB); - e->cmpps(xmmA, xmmB, 0); - e->cmpps(xmmA, anyptr_gpB, 0); - e->cmpss(xmmA, xmmB, 0); - e->cmpss(xmmA, anyptr_gpB, 0); - e->comiss(xmmA, xmmB); - e->comiss(xmmA, anyptr_gpB); - e->cvtpi2ps(xmmA, mmB); - e->cvtpi2ps(xmmA, anyptr_gpB); - e->cvtps2pi(mmA, xmmB); - e->cvtps2pi(mmA, anyptr_gpB); - e->cvtsi2ss(xmmA, gdB); - e->cvtsi2ss(xmmA, gzB); - e->cvtsi2ss(xmmA, anyptr_gpB); - e->cvtss2si(gdA, xmmB); - e->cvtss2si(gzA, xmmB); - e->cvtss2si(gdA, anyptr_gpB); - e->cvtss2si(gzA, anyptr_gpB); - e->cvttps2pi(mmA, xmmB); - e->cvttps2pi(mmA, anyptr_gpB); - e->cvttss2si(gdA, xmmB); - e->cvttss2si(gzA, xmmB); - e->cvttss2si(gdA, anyptr_gpB); - e->cvttss2si(gzA, anyptr_gpB); - e->divps(xmmA, xmmB); - e->divps(xmmA, anyptr_gpB); - e->divss(xmmA, xmmB); - e->divss(xmmA, anyptr_gpB); - e->ldmxcsr(anyptr_gpA); - e->maskmovq(mmA, mmB); // Implicit mmA, mmB, <ds:[EDI|RDI]> - e->maskmovq(mmA, mmB, ptr(e->zdi())); // Explicit mmA, mmB, <ds:[EDI|RDI]> - e->maxps(xmmA, xmmB); - e->maxps(xmmA, anyptr_gpB); - e->maxss(xmmA, xmmB); - e->maxss(xmmA, anyptr_gpB); - e->minps(xmmA, xmmB); - e->minps(xmmA, anyptr_gpB); - e->minss(xmmA, xmmB); - e->minss(xmmA, anyptr_gpB); - e->movaps(xmmA, xmmB); - e->movaps(xmmA, anyptr_gpB); - e->movaps(anyptr_gpA, xmmB); - e->movd(anyptr_gpA, xmmB); - e->movd(gdA, xmmB); - e->movd(gzA, xmmB); - e->movd(xmmA, anyptr_gpB); - e->movd(xmmA, gdB); - e->movd(xmmA, gzB); - e->movq(mmA, mmB); - e->movq(xmmA, xmmB); - e->movq(anyptr_gpA, xmmB); - e->movq(xmmA, anyptr_gpB); - e->movntq(anyptr_gpA, mmB); - e->movhlps(xmmA, xmmB); - e->movhps(xmmA, anyptr_gpB); - e->movhps(anyptr_gpA, xmmB); - e->movlhps(xmmA, xmmB); - e->movlps(xmmA, anyptr_gpB); - e->movlps(anyptr_gpA, xmmB); - e->movntps(anyptr_gpA, xmmB); - e->movss(xmmA, anyptr_gpB); - e->movss(anyptr_gpA, xmmB); - e->movups(xmmA, xmmB); - e->movups(xmmA, anyptr_gpB); - e->movups(anyptr_gpA, xmmB); - e->mulps(xmmA, xmmB); - e->mulps(xmmA, anyptr_gpB); - e->mulss(xmmA, xmmB); - e->mulss(xmmA, anyptr_gpB); - e->orps(xmmA, xmmB); - e->orps(xmmA, anyptr_gpB); - e->pavgb(mmA, mmB); - e->pavgb(mmA, anyptr_gpB); - e->pavgw(mmA, mmB); - e->pavgw(mmA, anyptr_gpB); - e->pextrw(gdA, mmB, 0); - e->pextrw(gzA, mmB, 0); - e->pinsrw(mmA, gdB, 0); - e->pinsrw(mmA, gzB, 0); - e->pinsrw(mmA, anyptr_gpB, 0); - e->pmaxsw(mmA, mmB); - e->pmaxsw(mmA, anyptr_gpB); - e->pmaxub(mmA, mmB); - e->pmaxub(mmA, anyptr_gpB); - e->pminsw(mmA, mmB); - e->pminsw(mmA, anyptr_gpB); - e->pminub(mmA, mmB); - e->pminub(mmA, anyptr_gpB); - e->pmovmskb(gdA, mmB); - e->pmovmskb(gzA, mmB); - e->pmulhuw(mmA, mmB); - e->pmulhuw(mmA, anyptr_gpB); - e->psadbw(mmA, mmB); - e->psadbw(mmA, anyptr_gpB); - e->pshufw(mmA, mmB, 0); - e->pshufw(mmA, anyptr_gpB, 0); - e->rcpps(xmmA, xmmB); - e->rcpps(xmmA, anyptr_gpB); - e->rcpss(xmmA, xmmB); - e->rcpss(xmmA, anyptr_gpB); - e->psadbw(xmmA, xmmB); - e->psadbw(xmmA, anyptr_gpB); - e->rsqrtps(xmmA, xmmB); - e->rsqrtps(xmmA, anyptr_gpB); - e->rsqrtss(xmmA, xmmB); - e->rsqrtss(xmmA, anyptr_gpB); - e->sfence(); - e->shufps(xmmA, xmmB, 0); - e->shufps(xmmA, anyptr_gpB, 0); - e->sqrtps(xmmA, xmmB); - e->sqrtps(xmmA, anyptr_gpB); - e->sqrtss(xmmA, xmmB); - e->sqrtss(xmmA, anyptr_gpB); - e->stmxcsr(anyptr_gpA); - e->subps(xmmA, xmmB); - e->subps(xmmA, anyptr_gpB); - e->subss(xmmA, xmmB); - e->subss(xmmA, anyptr_gpB); - e->ucomiss(xmmA, xmmB); - e->ucomiss(xmmA, anyptr_gpB); - e->unpckhps(xmmA, xmmB); - e->unpckhps(xmmA, anyptr_gpB); - e->unpcklps(xmmA, xmmB); - e->unpcklps(xmmA, anyptr_gpB); - e->xorps(xmmA, xmmB); - e->xorps(xmmA, anyptr_gpB); - - // SSE2. - e->nop(); - - e->addpd(xmmA, xmmB); - e->addpd(xmmA, anyptr_gpB); - e->addsd(xmmA, xmmB); - e->addsd(xmmA, anyptr_gpB); - e->andnpd(xmmA, xmmB); - e->andnpd(xmmA, anyptr_gpB); - e->andpd(xmmA, xmmB); - e->andpd(xmmA, anyptr_gpB); - e->cmppd(xmmA, xmmB, 0); - e->cmppd(xmmA, anyptr_gpB, 0); - e->cmpsd(xmmA, xmmB, 0); - e->cmpsd(xmmA, anyptr_gpB, 0); - e->comisd(xmmA, xmmB); - e->comisd(xmmA, anyptr_gpB); - e->cvtdq2pd(xmmA, xmmB); - e->cvtdq2pd(xmmA, anyptr_gpB); - e->cvtdq2ps(xmmA, xmmB); - e->cvtdq2ps(xmmA, anyptr_gpB); - e->cvtpd2dq(xmmA, xmmB); - e->cvtpd2dq(xmmA, anyptr_gpB); - e->cvtpd2pi(mmA, xmmB); - e->cvtpd2pi(mmA, anyptr_gpB); - e->cvtpd2ps(xmmA, xmmB); - e->cvtpd2ps(xmmA, anyptr_gpB); - e->cvtpi2pd(xmmA, mmB); - e->cvtpi2pd(xmmA, anyptr_gpB); - e->cvtps2dq(xmmA, xmmB); - e->cvtps2dq(xmmA, anyptr_gpB); - e->cvtps2pd(xmmA, xmmB); - e->cvtps2pd(xmmA, anyptr_gpB); - e->cvtsd2si(gdA, xmmB); - e->cvtsd2si(gzA, xmmB); - e->cvtsd2si(gdA, anyptr_gpB); - e->cvtsd2si(gzA, anyptr_gpB); - e->cvtsd2ss(xmmA, xmmB); - e->cvtsd2ss(xmmA, anyptr_gpB); - e->cvtsi2sd(xmmA, gdB); - e->cvtsi2sd(xmmA, gzB); - e->cvtsi2sd(xmmA, anyptr_gpB); - e->cvtss2sd(xmmA, xmmB); - e->cvtss2sd(xmmA, anyptr_gpB); - e->cvtss2si(gdA, xmmB); - e->cvtss2si(gzA, xmmB); - e->cvtss2si(gdA, anyptr_gpB); - e->cvtss2si(gzA, anyptr_gpB); - e->cvttpd2pi(mmA, xmmB); - e->cvttpd2pi(mmA, anyptr_gpB); - e->cvttpd2dq(xmmA, xmmB); - e->cvttpd2dq(xmmA, anyptr_gpB); - e->cvttps2dq(xmmA, xmmB); - e->cvttps2dq(xmmA, anyptr_gpB); - e->cvttsd2si(gdA, xmmB); - e->cvttsd2si(gzA, xmmB); - e->cvttsd2si(gdA, anyptr_gpB); - e->cvttsd2si(gzA, anyptr_gpB); - e->divpd(xmmA, xmmB); - e->divpd(xmmA, anyptr_gpB); - e->divsd(xmmA, xmmB); - e->divsd(xmmA, anyptr_gpB); - e->lfence(); - e->maskmovdqu(xmmA, xmmB); // Implicit xmmA, xmmB, <ds:[EDI|RDI]> - e->maskmovdqu(xmmA, xmmB, ptr(e->zdi())); // Explicit xmmA, xmmB, <ds:[EDI|RDI]> - e->maxpd(xmmA, xmmB); - e->maxpd(xmmA, anyptr_gpB); - e->maxsd(xmmA, xmmB); - e->maxsd(xmmA, anyptr_gpB); - e->mfence(); - e->minpd(xmmA, xmmB); - e->minpd(xmmA, anyptr_gpB); - e->minsd(xmmA, xmmB); - e->minsd(xmmA, anyptr_gpB); - e->movdqa(xmmA, xmmB); - e->movdqa(xmmA, anyptr_gpB); - e->movdqa(anyptr_gpA, xmmB); - e->movdqu(xmmA, xmmB); - e->movdqu(xmmA, anyptr_gpB); - e->movdqu(anyptr_gpA, xmmB); - e->movmskps(gdA, xmmB); - e->movmskps(gzA, xmmB); - e->movmskpd(gdA, xmmB); - e->movmskpd(gzA, xmmB); - e->movsd(xmmA, xmmB); - e->movsd(xmmA, anyptr_gpB); - e->movsd(anyptr_gpA, xmmB); - e->movapd(xmmA, anyptr_gpB); - e->movapd(anyptr_gpA, xmmB); - e->movdq2q(mmA, xmmB); - e->movq2dq(xmmA, mmB); - e->movhpd(xmmA, anyptr_gpB); - e->movhpd(anyptr_gpA, xmmB); - e->movlpd(xmmA, anyptr_gpB); - e->movlpd(anyptr_gpA, xmmB); - e->movntdq(anyptr_gpA, xmmB); - e->movnti(anyptr_gpA, gdB); - e->movnti(anyptr_gpA, gzB); - e->movntpd(anyptr_gpA, xmmB); - e->movupd(xmmA, anyptr_gpB); - e->movupd(anyptr_gpA, xmmB); - e->mulpd(xmmA, xmmB); - e->mulpd(xmmA, anyptr_gpB); - e->mulsd(xmmA, xmmB); - e->mulsd(xmmA, anyptr_gpB); - e->orpd(xmmA, xmmB); - e->orpd(xmmA, anyptr_gpB); - e->packsswb(xmmA, xmmB); - e->packsswb(xmmA, anyptr_gpB); - e->packssdw(xmmA, xmmB); - e->packssdw(xmmA, anyptr_gpB); - e->packuswb(xmmA, xmmB); - e->packuswb(xmmA, anyptr_gpB); - e->paddb(xmmA, xmmB); - e->paddb(xmmA, anyptr_gpB); - e->paddw(xmmA, xmmB); - e->paddw(xmmA, anyptr_gpB); - e->paddd(xmmA, xmmB); - e->paddd(xmmA, anyptr_gpB); - e->paddq(mmA, mmB); - e->paddq(mmA, anyptr_gpB); - e->paddq(xmmA, xmmB); - e->paddq(xmmA, anyptr_gpB); - e->paddsb(xmmA, xmmB); - e->paddsb(xmmA, anyptr_gpB); - e->paddsw(xmmA, xmmB); - e->paddsw(xmmA, anyptr_gpB); - e->paddusb(xmmA, xmmB); - e->paddusb(xmmA, anyptr_gpB); - e->paddusw(xmmA, xmmB); - e->paddusw(xmmA, anyptr_gpB); - e->pand(xmmA, xmmB); - e->pand(xmmA, anyptr_gpB); - e->pandn(xmmA, xmmB); - e->pandn(xmmA, anyptr_gpB); - e->pause(); - e->pavgb(xmmA, xmmB); - e->pavgb(xmmA, anyptr_gpB); - e->pavgw(xmmA, xmmB); - e->pavgw(xmmA, anyptr_gpB); - e->pcmpeqb(xmmA, xmmB); - e->pcmpeqb(xmmA, anyptr_gpB); - e->pcmpeqw(xmmA, xmmB); - e->pcmpeqw(xmmA, anyptr_gpB); - e->pcmpeqd(xmmA, xmmB); - e->pcmpeqd(xmmA, anyptr_gpB); - e->pcmpgtb(xmmA, xmmB); - e->pcmpgtb(xmmA, anyptr_gpB); - e->pcmpgtw(xmmA, xmmB); - e->pcmpgtw(xmmA, anyptr_gpB); - e->pcmpgtd(xmmA, xmmB); - e->pcmpgtd(xmmA, anyptr_gpB); - e->pmaxsw(xmmA, xmmB); - e->pmaxsw(xmmA, anyptr_gpB); - e->pmaxub(xmmA, xmmB); - e->pmaxub(xmmA, anyptr_gpB); - e->pminsw(xmmA, xmmB); - e->pminsw(xmmA, anyptr_gpB); - e->pminub(xmmA, xmmB); - e->pminub(xmmA, anyptr_gpB); - e->pmovmskb(gdA, xmmB); - e->pmovmskb(gzA, xmmB); - e->pmulhw(xmmA, xmmB); - e->pmulhw(xmmA, anyptr_gpB); - e->pmulhuw(xmmA, xmmB); - e->pmulhuw(xmmA, anyptr_gpB); - e->pmullw(xmmA, xmmB); - e->pmullw(xmmA, anyptr_gpB); - e->pmuludq(mmA, mmB); - e->pmuludq(mmA, anyptr_gpB); - e->pmuludq(xmmA, xmmB); - e->pmuludq(xmmA, anyptr_gpB); - e->por(xmmA, xmmB); - e->por(xmmA, anyptr_gpB); - e->pslld(xmmA, xmmB); - e->pslld(xmmA, anyptr_gpB); - e->pslld(xmmA, 0); - e->psllq(xmmA, xmmB); - e->psllq(xmmA, anyptr_gpB); - e->psllq(xmmA, 0); - e->psllw(xmmA, xmmB); - e->psllw(xmmA, anyptr_gpB); - e->psllw(xmmA, 0); - e->pslldq(xmmA, 0); - e->psrad(xmmA, xmmB); - e->psrad(xmmA, anyptr_gpB); - e->psrad(xmmA, 0); - e->psraw(xmmA, xmmB); - e->psraw(xmmA, anyptr_gpB); - e->psraw(xmmA, 0); - e->psubb(xmmA, xmmB); - e->psubb(xmmA, anyptr_gpB); - e->psubw(xmmA, xmmB); - e->psubw(xmmA, anyptr_gpB); - e->psubd(xmmA, xmmB); - e->psubd(xmmA, anyptr_gpB); - e->psubq(mmA, mmB); - e->psubq(mmA, anyptr_gpB); - e->psubq(xmmA, xmmB); - e->psubq(xmmA, anyptr_gpB); - e->pmaddwd(xmmA, xmmB); - e->pmaddwd(xmmA, anyptr_gpB); - e->pshufd(xmmA, xmmB, 0); - e->pshufd(xmmA, anyptr_gpB, 0); - e->pshufhw(xmmA, xmmB, 0); - e->pshufhw(xmmA, anyptr_gpB, 0); - e->pshuflw(xmmA, xmmB, 0); - e->pshuflw(xmmA, anyptr_gpB, 0); - e->psrld(xmmA, xmmB); - e->psrld(xmmA, anyptr_gpB); - e->psrld(xmmA, 0); - e->psrlq(xmmA, xmmB); - e->psrlq(xmmA, anyptr_gpB); - e->psrlq(xmmA, 0); - e->psrldq(xmmA, 0); - e->psrlw(xmmA, xmmB); - e->psrlw(xmmA, anyptr_gpB); - e->psrlw(xmmA, 0); - e->psubsb(xmmA, xmmB); - e->psubsb(xmmA, anyptr_gpB); - e->psubsw(xmmA, xmmB); - e->psubsw(xmmA, anyptr_gpB); - e->psubusb(xmmA, xmmB); - e->psubusb(xmmA, anyptr_gpB); - e->psubusw(xmmA, xmmB); - e->psubusw(xmmA, anyptr_gpB); - e->punpckhbw(xmmA, xmmB); - e->punpckhbw(xmmA, anyptr_gpB); - e->punpckhwd(xmmA, xmmB); - e->punpckhwd(xmmA, anyptr_gpB); - e->punpckhdq(xmmA, xmmB); - e->punpckhdq(xmmA, anyptr_gpB); - e->punpckhqdq(xmmA, xmmB); - e->punpckhqdq(xmmA, anyptr_gpB); - e->punpcklbw(xmmA, xmmB); - e->punpcklbw(xmmA, anyptr_gpB); - e->punpcklwd(xmmA, xmmB); - e->punpcklwd(xmmA, anyptr_gpB); - e->punpckldq(xmmA, xmmB); - e->punpckldq(xmmA, anyptr_gpB); - e->punpcklqdq(xmmA, xmmB); - e->punpcklqdq(xmmA, anyptr_gpB); - e->pxor(xmmA, xmmB); - e->pxor(xmmA, anyptr_gpB); - e->sqrtpd(xmmA, xmmB); - e->sqrtpd(xmmA, anyptr_gpB); - e->sqrtsd(xmmA, xmmB); - e->sqrtsd(xmmA, anyptr_gpB); - e->subpd(xmmA, xmmB); - e->subpd(xmmA, anyptr_gpB); - e->subsd(xmmA, xmmB); - e->subsd(xmmA, anyptr_gpB); - e->ucomisd(xmmA, xmmB); - e->ucomisd(xmmA, anyptr_gpB); - e->unpckhpd(xmmA, xmmB); - e->unpckhpd(xmmA, anyptr_gpB); - e->unpcklpd(xmmA, xmmB); - e->unpcklpd(xmmA, anyptr_gpB); - e->xorpd(xmmA, xmmB); - e->xorpd(xmmA, anyptr_gpB); - - // SSE3. - e->nop(); - - e->addsubpd(xmmA, xmmB); - e->addsubpd(xmmA, anyptr_gpB); - e->addsubps(xmmA, xmmB); - e->addsubps(xmmA, anyptr_gpB); - e->fisttp(dword_ptr(gzA)); - e->haddpd(xmmA, xmmB); - e->haddpd(xmmA, anyptr_gpB); - e->haddps(xmmA, xmmB); - e->haddps(xmmA, anyptr_gpB); - e->hsubpd(xmmA, xmmB); - e->hsubpd(xmmA, anyptr_gpB); - e->hsubps(xmmA, xmmB); - e->hsubps(xmmA, anyptr_gpB); - e->lddqu(xmmA, anyptr_gpB); - e->movddup(xmmA, xmmB); - e->movddup(xmmA, anyptr_gpB); - e->movshdup(xmmA, xmmB); - e->movshdup(xmmA, anyptr_gpB); - e->movsldup(xmmA, xmmB); - e->movsldup(xmmA, anyptr_gpB); - - // SSSE3. - e->nop(); - - e->psignb(mmA, mmB); - e->psignb(mmA, anyptr_gpB); - e->psignb(xmmA, xmmB); - e->psignb(xmmA, anyptr_gpB); - e->psignw(mmA, mmB); - e->psignw(mmA, anyptr_gpB); - e->psignw(xmmA, xmmB); - e->psignw(xmmA, anyptr_gpB); - e->psignd(mmA, mmB); - e->psignd(mmA, anyptr_gpB); - e->psignd(xmmA, xmmB); - e->psignd(xmmA, anyptr_gpB); - e->phaddw(mmA, mmB); - e->phaddw(mmA, anyptr_gpB); - e->phaddw(xmmA, xmmB); - e->phaddw(xmmA, anyptr_gpB); - e->phaddd(mmA, mmB); - e->phaddd(mmA, anyptr_gpB); - e->phaddd(xmmA, xmmB); - e->phaddd(xmmA, anyptr_gpB); - e->phaddsw(mmA, mmB); - e->phaddsw(mmA, anyptr_gpB); - e->phaddsw(xmmA, xmmB); - e->phaddsw(xmmA, anyptr_gpB); - e->phsubw(mmA, mmB); - e->phsubw(mmA, anyptr_gpB); - e->phsubw(xmmA, xmmB); - e->phsubw(xmmA, anyptr_gpB); - e->phsubd(mmA, mmB); - e->phsubd(mmA, anyptr_gpB); - e->phsubd(xmmA, xmmB); - e->phsubd(xmmA, anyptr_gpB); - e->phsubsw(mmA, mmB); - e->phsubsw(mmA, anyptr_gpB); - e->phsubsw(xmmA, xmmB); - e->phsubsw(xmmA, anyptr_gpB); - e->pmaddubsw(mmA, mmB); - e->pmaddubsw(mmA, anyptr_gpB); - e->pmaddubsw(xmmA, xmmB); - e->pmaddubsw(xmmA, anyptr_gpB); - e->pabsb(mmA, mmB); - e->pabsb(mmA, anyptr_gpB); - e->pabsb(xmmA, xmmB); - e->pabsb(xmmA, anyptr_gpB); - e->pabsw(mmA, mmB); - e->pabsw(mmA, anyptr_gpB); - e->pabsw(xmmA, xmmB); - e->pabsw(xmmA, anyptr_gpB); - e->pabsd(mmA, mmB); - e->pabsd(mmA, anyptr_gpB); - e->pabsd(xmmA, xmmB); - e->pabsd(xmmA, anyptr_gpB); - e->pmulhrsw(mmA, mmB); - e->pmulhrsw(mmA, anyptr_gpB); - e->pmulhrsw(xmmA, xmmB); - e->pmulhrsw(xmmA, anyptr_gpB); - e->pshufb(mmA, mmB); - e->pshufb(mmA, anyptr_gpB); - e->pshufb(xmmA, xmmB); - e->pshufb(xmmA, anyptr_gpB); - e->palignr(mmA, mmB, 0); - e->palignr(mmA, anyptr_gpB, 0); - e->palignr(xmmA, xmmB, 0); - e->palignr(xmmA, anyptr_gpB, 0); - - // SSE4.1. - e->nop(); - - e->blendpd(xmmA, xmmB, 0); - e->blendpd(xmmA, anyptr_gpB, 0); - e->blendps(xmmA, xmmB, 0); - e->blendps(xmmA, anyptr_gpB, 0); - e->blendvpd(xmmA, xmmB); // Implicit xmmA, xmmB, <XMM0> - e->blendvpd(xmmA, xmmB, xmm0); // Explicit xmmA, xmmB, <XMM0> - e->blendvpd(xmmA, anyptr_gpB); // Implicit xmmA, mem , <XMM0> - e->blendvpd(xmmA, anyptr_gpB, xmm0); // Explicit xmmA, mem , <XMM0> - e->blendvps(xmmA, xmmB); // Implicit xmmA, xmmB, <XMM0> - e->blendvps(xmmA, xmmB, xmm0); // Explicit xmmA, xmmB, <XMM0> - e->blendvps(xmmA, anyptr_gpB); // Implicit xmmA, mem , <XMM0> - e->blendvps(xmmA, anyptr_gpB, xmm0); // Explicit xmmA, mem , <XMM0> - - e->dppd(xmmA, xmmB, 0); - e->dppd(xmmA, anyptr_gpB, 0); - e->dpps(xmmA, xmmB, 0); - e->dpps(xmmA, anyptr_gpB, 0); - e->extractps(gdA, xmmB, 0); - e->extractps(gzA, xmmB, 0); - e->extractps(anyptr_gpA, xmmB, 0); - e->insertps(xmmA, xmmB, 0); - e->insertps(xmmA, anyptr_gpB, 0); - e->movntdqa(xmmA, anyptr_gpB); - e->mpsadbw(xmmA, xmmB, 0); - e->mpsadbw(xmmA, anyptr_gpB, 0); - e->packusdw(xmmA, xmmB); - e->packusdw(xmmA, anyptr_gpB); - e->pblendvb(xmmA, xmmB); // Implicit xmmA, xmmB, <XMM0> - e->pblendvb(xmmA, xmmB, xmm0); // Explicit xmmA, xmmB, <XMM0> - e->pblendvb(xmmA, anyptr_gpB); // Implicit xmmA, mem, <XMM0> - e->pblendvb(xmmA, anyptr_gpB, xmm0); // Implicit xmmA, mem, <XMM0> - e->pblendw(xmmA, xmmB, 0); - e->pblendw(xmmA, anyptr_gpB, 0); - e->pcmpeqq(xmmA, xmmB); - e->pcmpeqq(xmmA, anyptr_gpB); - e->pextrb(gdA, xmmB, 0); - e->pextrb(gzA, xmmB, 0); - e->pextrb(anyptr_gpA, xmmB, 0); - e->pextrd(gdA, xmmB, 0); - e->pextrd(gzA, xmmB, 0); - e->pextrd(anyptr_gpA, xmmB, 0); - if (isX64) e->pextrq(gzA, xmmB, 0); - if (isX64) e->pextrq(anyptr_gpA, xmmB, 0); - e->pextrw(gdA, xmmB, 0); - e->pextrw(gzA, xmmB, 0); - e->pextrw(anyptr_gpA, xmmB, 0); - e->phminposuw(xmmA, xmmB); - e->phminposuw(xmmA, anyptr_gpB); - e->pinsrb(xmmA, gdB, 0); - e->pinsrb(xmmA, gzB, 0); - e->pinsrb(xmmA, anyptr_gpB, 0); - e->pinsrd(xmmA, gdB, 0); - e->pinsrd(xmmA, gzB, 0); - e->pinsrd(xmmA, anyptr_gpB, 0); - e->pinsrw(xmmA, gdB, 0); - e->pinsrw(xmmA, gzB, 0); - e->pinsrw(xmmA, anyptr_gpB, 0); - e->pmaxuw(xmmA, xmmB); - e->pmaxuw(xmmA, anyptr_gpB); - e->pmaxsb(xmmA, xmmB); - e->pmaxsb(xmmA, anyptr_gpB); - e->pmaxsd(xmmA, xmmB); - e->pmaxsd(xmmA, anyptr_gpB); - e->pmaxud(xmmA, xmmB); - e->pmaxud(xmmA, anyptr_gpB); - e->pminsb(xmmA, xmmB); - e->pminsb(xmmA, anyptr_gpB); - e->pminuw(xmmA, xmmB); - e->pminuw(xmmA, anyptr_gpB); - e->pminud(xmmA, xmmB); - e->pminud(xmmA, anyptr_gpB); - e->pminsd(xmmA, xmmB); - e->pminsd(xmmA, anyptr_gpB); - e->pmovsxbw(xmmA, xmmB); - e->pmovsxbw(xmmA, anyptr_gpB); - e->pmovsxbd(xmmA, xmmB); - e->pmovsxbd(xmmA, anyptr_gpB); - e->pmovsxbq(xmmA, xmmB); - e->pmovsxbq(xmmA, anyptr_gpB); - e->pmovsxwd(xmmA, xmmB); - e->pmovsxwd(xmmA, anyptr_gpB); - e->pmovsxwq(xmmA, xmmB); - e->pmovsxwq(xmmA, anyptr_gpB); - e->pmovsxdq(xmmA, xmmB); - e->pmovsxdq(xmmA, anyptr_gpB); - e->pmovzxbw(xmmA, xmmB); - e->pmovzxbw(xmmA, anyptr_gpB); - e->pmovzxbd(xmmA, xmmB); - e->pmovzxbd(xmmA, anyptr_gpB); - e->pmovzxbq(xmmA, xmmB); - e->pmovzxbq(xmmA, anyptr_gpB); - e->pmovzxwd(xmmA, xmmB); - e->pmovzxwd(xmmA, anyptr_gpB); - e->pmovzxwq(xmmA, xmmB); - e->pmovzxwq(xmmA, anyptr_gpB); - e->pmovzxdq(xmmA, xmmB); - e->pmovzxdq(xmmA, anyptr_gpB); - e->pmuldq(xmmA, xmmB); - e->pmuldq(xmmA, anyptr_gpB); - e->pmulld(xmmA, xmmB); - e->pmulld(xmmA, anyptr_gpB); - e->ptest(xmmA, xmmB); - e->ptest(xmmA, anyptr_gpB); - e->roundps(xmmA, xmmB, 0); - e->roundps(xmmA, anyptr_gpB, 0); - e->roundss(xmmA, xmmB, 0); - e->roundss(xmmA, anyptr_gpB, 0); - e->roundpd(xmmA, xmmB, 0); - e->roundpd(xmmA, anyptr_gpB, 0); - e->roundsd(xmmA, xmmB, 0); - e->roundsd(xmmA, anyptr_gpB, 0); - - // SSE4.2. - e->nop(); - - e->pcmpestri(xmmA, xmmB , imm(0)); // Implicit xmmA, xmmB, imm, <ECX>, <EAX>, <EDX> - e->pcmpestri(xmmA, xmmB , imm(0), ecx, eax, edx); // Explicit xmmA, xmmB, imm, <ECX>, <EAX>, <EDX> - e->pcmpestri(xmmA, anyptr_gpB, imm(0)); // Implicit xmmA, mem , imm, <ECX>, <EAX>, <EDX> - e->pcmpestri(xmmA, anyptr_gpB, imm(0), ecx, eax, edx); // Explicit xmmA, mem , imm, <ECX>, <EAX>, <EDX> - e->pcmpestrm(xmmA, xmmB , imm(0)); // Implicit xmmA, xmmB, imm, <XMM0>, <EAX>, <EDX> - e->pcmpestrm(xmmA, xmmB , imm(0), xmm0, eax, edx); // Explicit xmmA, xmmB, imm, <XMM0>, <EAX>, <EDX> - e->pcmpestrm(xmmA, anyptr_gpB, imm(0)); // Implicit xmmA, mem , imm, <XMM0>, <EAX>, <EDX> - e->pcmpestrm(xmmA, anyptr_gpB, imm(0), xmm0, eax, edx); // Explicit xmmA, mem , imm, <XMM0>, <EAX>, <EDX> - e->pcmpistri(xmmA, xmmB , imm(0)); // Implicit xmmA, xmmB, imm, <ECX> - e->pcmpistri(xmmA, xmmB , imm(0), ecx); // Explicit xmmA, xmmB, imm, <ECX> - e->pcmpistri(xmmA, anyptr_gpB, imm(0)); // Implicit xmmA, mem , imm, <ECX> - e->pcmpistri(xmmA, anyptr_gpB, imm(0), ecx); // Explicit xmmA, mem , imm, <ECX> - e->pcmpistrm(xmmA, xmmB , imm(0)); // Implicit xmmA, xmmB, imm, <XMM0> - e->pcmpistrm(xmmA, xmmB , imm(0), xmm0); // Explicit xmmA, xmmB, imm, <XMM0> - e->pcmpistrm(xmmA, anyptr_gpB, imm(0)); // Implicit xmmA, mem , imm, <XMM0> - e->pcmpistrm(xmmA, anyptr_gpB, imm(0), xmm0); // Explicit xmmA, mem , imm, <XMM0> - - e->pcmpgtq(xmmA, xmmB); - e->pcmpgtq(xmmA, anyptr_gpB); - - // SSE4A. - e->nop(); - - e->extrq(xmmA, xmmB); - e->extrq(xmmA, 0x1, 0x2); - e->extrq(xmmB, 0x1, 0x2); - e->insertq(xmmA, xmmB); - e->insertq(xmmA, xmmB, 0x1, 0x2); - e->movntsd(anyptr_gpA, xmmB); - e->movntss(anyptr_gpA, xmmB); - - // AESNI. - e->nop(); - - e->aesdec(xmmA, xmmB); - e->aesdec(xmmA, anyptr_gpB); - e->aesdeclast(xmmA, xmmB); - e->aesdeclast(xmmA, anyptr_gpB); - e->aesenc(xmmA, xmmB); - e->aesenc(xmmA, anyptr_gpB); - e->aesenclast(xmmA, xmmB); - e->aesenclast(xmmA, anyptr_gpB); - e->aesimc(xmmA, xmmB); - e->aesimc(xmmA, anyptr_gpB); - e->aeskeygenassist(xmmA, xmmB, 0); - e->aeskeygenassist(xmmA, anyptr_gpB, 0); - - // SHA. - e->nop(); - - e->sha1msg1(xmmA, xmmB); - e->sha1msg1(xmmA, anyptr_gpB); - e->sha1msg2(xmmA, xmmB); - e->sha1msg2(xmmA, anyptr_gpB); - e->sha1nexte(xmmA, xmmB); - e->sha1nexte(xmmA, anyptr_gpB); - e->sha1rnds4(xmmA, xmmB, 0); - e->sha1rnds4(xmmA, anyptr_gpB, 0); - e->sha256msg1(xmmA, xmmB); - e->sha256msg1(xmmA, anyptr_gpB); - e->sha256msg2(xmmA, xmmB); - e->sha256msg2(xmmA, anyptr_gpB); - e->sha256rnds2(xmmA, xmmB); // Implicit xmmA, xmmB, <XMM0> - e->sha256rnds2(xmmA, xmmB, xmm0); // Explicit xmmA, xmmB, <XMM0> - e->sha256rnds2(xmmA, anyptr_gpB); // Implicit xmmA, mem, <XMM0> - e->sha256rnds2(xmmA, anyptr_gpB, xmm0); // Explicit xmmA, mem, <XMM0> - - // PCLMULQDQ. - e->nop(); - - e->pclmulqdq(xmmA, xmmB, 0); - e->pclmulqdq(xmmA, anyptr_gpB, 0); - - // AVX. - e->nop(); - - e->vaddpd(xmmA, xmmB, xmmC); - e->vaddpd(xmmA, xmmB, anyptr_gpC); - e->vaddpd(ymmA, ymmB, ymmC); - e->vaddpd(ymmA, ymmB, anyptr_gpC); - e->vaddps(xmmA, xmmB, xmmC); - e->vaddps(xmmA, xmmB, anyptr_gpC); - e->vaddps(ymmA, ymmB, ymmC); - e->vaddps(ymmA, ymmB, anyptr_gpC); - e->vaddsd(xmmA, xmmB, xmmC); - e->vaddsd(xmmA, xmmB, anyptr_gpC); - e->vaddss(xmmA, xmmB, xmmC); - e->vaddss(xmmA, xmmB, anyptr_gpC); - e->vaddsubpd(xmmA, xmmB, xmmC); - e->vaddsubpd(xmmA, xmmB, anyptr_gpC); - e->vaddsubpd(ymmA, ymmB, ymmC); - e->vaddsubpd(ymmA, ymmB, anyptr_gpC); - e->vaddsubps(xmmA, xmmB, xmmC); - e->vaddsubps(xmmA, xmmB, anyptr_gpC); - e->vaddsubps(ymmA, ymmB, ymmC); - e->vaddsubps(ymmA, ymmB, anyptr_gpC); - e->vandpd(xmmA, xmmB, xmmC); - e->vandpd(xmmA, xmmB, anyptr_gpC); - e->vandpd(ymmA, ymmB, ymmC); - e->vandpd(ymmA, ymmB, anyptr_gpC); - e->vandps(xmmA, xmmB, xmmC); - e->vandps(xmmA, xmmB, anyptr_gpC); - e->vandps(ymmA, ymmB, ymmC); - e->vandps(ymmA, ymmB, anyptr_gpC); - e->vandnpd(xmmA, xmmB, xmmC); - e->vandnpd(xmmA, xmmB, anyptr_gpC); - e->vandnpd(ymmA, ymmB, ymmC); - e->vandnpd(ymmA, ymmB, anyptr_gpC); - e->vandnps(xmmA, xmmB, xmmC); - e->vandnps(xmmA, xmmB, anyptr_gpC); - e->vandnps(ymmA, ymmB, ymmC); - e->vandnps(ymmA, ymmB, anyptr_gpC); - e->vblendpd(xmmA, xmmB, xmmC, 0); - e->vblendpd(xmmA, xmmB, anyptr_gpC, 0); - e->vblendpd(ymmA, ymmB, ymmC, 0); - e->vblendpd(ymmA, ymmB, anyptr_gpC, 0); - e->vblendps(xmmA, xmmB, xmmC, 0); - e->vblendps(xmmA, xmmB, anyptr_gpC, 0); - e->vblendps(ymmA, ymmB, ymmC, 0); - e->vblendps(ymmA, ymmB, anyptr_gpC, 0); - e->vblendvpd(xmmA, xmmB, xmmC, xmmD); - e->vblendvpd(xmmA, xmmB, anyptr_gpC, xmmD); - e->vblendvpd(ymmA, ymmB, ymmC, ymmD); - e->vblendvpd(ymmA, ymmB, anyptr_gpC, ymmD); - e->vbroadcastf128(ymmA, anyptr_gpB); - e->vbroadcastsd(ymmA, anyptr_gpB); - e->vbroadcastss(xmmA, anyptr_gpB); - e->vbroadcastss(ymmA, anyptr_gpB); - e->vcmppd(xmmA, xmmB, xmmC, 0); - e->vcmppd(xmmA, xmmB, anyptr_gpC, 0); - e->vcmppd(ymmA, ymmB, ymmC, 0); - e->vcmppd(ymmA, ymmB, anyptr_gpC, 0); - e->vcmpps(xmmA, xmmB, xmmC, 0); - e->vcmpps(xmmA, xmmB, anyptr_gpC, 0); - e->vcmpps(ymmA, ymmB, ymmC, 0); - e->vcmpps(ymmA, ymmB, anyptr_gpC, 0); - e->vcmpsd(xmmA, xmmB, xmmC, 0); - e->vcmpsd(xmmA, xmmB, anyptr_gpC, 0); - e->vcmpss(xmmA, xmmB, xmmC, 0); - e->vcmpss(xmmA, xmmB, anyptr_gpC, 0); - e->vcomisd(xmmA, xmmB); - e->vcomisd(xmmA, anyptr_gpB); - e->vcomiss(xmmA, xmmB); - e->vcomiss(xmmA, anyptr_gpB); - e->vcvtdq2pd(xmmA, xmmB); - e->vcvtdq2pd(xmmA, anyptr_gpB); - e->vcvtdq2pd(ymmA, xmmB); - e->vcvtdq2pd(ymmA, anyptr_gpB); - e->vcvtdq2ps(xmmA, xmmB); - e->vcvtdq2ps(xmmA, anyptr_gpB); - e->vcvtdq2ps(ymmA, ymmB); - e->vcvtdq2ps(ymmA, anyptr_gpB); - e->vcvtpd2dq(xmmA, xmmB); - e->vcvtpd2dq(xmmA, ymmB); - e->vcvtpd2dq(xmmA, anyptr_gpB); - e->vcvtpd2ps(xmmA, xmmB); - e->vcvtpd2ps(xmmA, ymmB); - e->vcvtpd2ps(xmmA, anyptr_gpB); - e->vcvtps2dq(xmmA, xmmB); - e->vcvtps2dq(xmmA, anyptr_gpB); - e->vcvtps2dq(ymmA, ymmB); - e->vcvtps2dq(ymmA, anyptr_gpB); - e->vcvtps2pd(xmmA, xmmB); - e->vcvtps2pd(xmmA, anyptr_gpB); - e->vcvtps2pd(ymmA, xmmB); - e->vcvtps2pd(ymmA, anyptr_gpB); - e->vcvtsd2si(gzA, xmmB); - e->vcvtsd2si(gzA, anyptr_gpB); - e->vcvtsd2ss(xmmA, xmmB, xmmC); - e->vcvtsd2ss(xmmA, xmmB, anyptr_gpC); - e->vcvtsi2sd(xmmA, xmmB, gzC); - e->vcvtsi2sd(xmmA, xmmB, anyptr_gpC); - e->vcvtsi2ss(xmmA, xmmB, gzC); - e->vcvtsi2ss(xmmA, xmmB, anyptr_gpC); - e->vcvtss2sd(xmmA, xmmB, xmmC); - e->vcvtss2sd(xmmA, xmmB, anyptr_gpC); - e->vcvtss2si(gzA, xmmB); - e->vcvtss2si(gzA, anyptr_gpB); - e->vcvttpd2dq(xmmA, xmmB); - e->vcvttpd2dq(xmmA, ymmB); - e->vcvttpd2dq(xmmA, anyptr_gpB); - e->vcvttps2dq(xmmA, xmmB); - e->vcvttps2dq(xmmA, anyptr_gpB); - e->vcvttps2dq(ymmA, ymmB); - e->vcvttps2dq(ymmA, anyptr_gpB); - e->vcvttsd2si(gzA, xmmB); - e->vcvttsd2si(gzA, anyptr_gpB); - e->vcvttss2si(gzA, xmmB); - e->vcvttss2si(gzA, anyptr_gpB); - e->vdivpd(xmmA, xmmB, xmmC); - e->vdivpd(xmmA, xmmB, anyptr_gpC); - e->vdivpd(ymmA, ymmB, ymmC); - e->vdivpd(ymmA, ymmB, anyptr_gpC); - e->vdivps(xmmA, xmmB, xmmC); - e->vdivps(xmmA, xmmB, anyptr_gpC); - e->vdivps(ymmA, ymmB, ymmC); - e->vdivps(ymmA, ymmB, anyptr_gpC); - e->vdivsd(xmmA, xmmB, xmmC); - e->vdivsd(xmmA, xmmB, anyptr_gpC); - e->vdivss(xmmA, xmmB, xmmC); - e->vdivss(xmmA, xmmB, anyptr_gpC); - e->vdppd(xmmA, xmmB, xmmC, 0); - e->vdppd(xmmA, xmmB, anyptr_gpC, 0); - e->vdpps(xmmA, xmmB, xmmC, 0); - e->vdpps(xmmA, xmmB, anyptr_gpC, 0); - e->vdpps(ymmA, ymmB, ymmC, 0); - e->vdpps(ymmA, ymmB, anyptr_gpC, 0); - e->vextractf128(xmmA, ymmB, 0); - e->vextractf128(anyptr_gpA, ymmB, 0); - e->vextractps(gzA, xmmB, 0); - e->vextractps(anyptr_gpA, xmmB, 0); - e->vhaddpd(xmmA, xmmB, xmmC); - e->vhaddpd(xmmA, xmmB, anyptr_gpC); - e->vhaddpd(ymmA, ymmB, ymmC); - e->vhaddpd(ymmA, ymmB, anyptr_gpC); - e->vhaddps(xmmA, xmmB, xmmC); - e->vhaddps(xmmA, xmmB, anyptr_gpC); - e->vhaddps(ymmA, ymmB, ymmC); - e->vhaddps(ymmA, ymmB, anyptr_gpC); - e->vhsubpd(xmmA, xmmB, xmmC); - e->vhsubpd(xmmA, xmmB, anyptr_gpC); - e->vhsubpd(ymmA, ymmB, ymmC); - e->vhsubpd(ymmA, ymmB, anyptr_gpC); - e->vhsubps(xmmA, xmmB, xmmC); - e->vhsubps(xmmA, xmmB, anyptr_gpC); - e->vhsubps(ymmA, ymmB, ymmC); - e->vhsubps(ymmA, ymmB, anyptr_gpC); - e->vinsertf128(ymmA, ymmB, xmmC, 0); - e->vinsertf128(ymmA, ymmB, anyptr_gpC, 0); - e->vinsertps(xmmA, xmmB, xmmC, 0); - e->vinsertps(xmmA, xmmB, anyptr_gpC, 0); - e->vlddqu(xmmA, anyptr_gpB); - e->vlddqu(ymmA, anyptr_gpB); - e->vldmxcsr(anyptr_gpA); - e->vmaskmovdqu(xmmA, xmmB); // Implicit xmmA, xmmB, <ds:[EDI|RDI]> - e->vmaskmovdqu(xmmA, xmmB, ptr(e->zdi())); // Explicit xmmA, xmmB, <ds:[EDI|RDI]> - e->vmaskmovps(xmmA, xmmB, anyptr_gpC); - e->vmaskmovps(ymmA, ymmB, anyptr_gpC); - e->vmaskmovps(anyptr_gpA, xmmB, xmmC); - e->vmaskmovps(anyptr_gpA, ymmB, ymmC); - e->vmaskmovpd(xmmA, xmmB, anyptr_gpC); - e->vmaskmovpd(ymmA, ymmB, anyptr_gpC); - e->vmaskmovpd(anyptr_gpA, xmmB, xmmC); - e->vmaskmovpd(anyptr_gpA, ymmB, ymmC); - e->vmaxpd(xmmA, xmmB, xmmC); - e->vmaxpd(xmmA, xmmB, anyptr_gpC); - e->vmaxpd(ymmA, ymmB, ymmC); - e->vmaxpd(ymmA, ymmB, anyptr_gpC); - e->vmaxps(xmmA, xmmB, xmmC); - e->vmaxps(xmmA, xmmB, anyptr_gpC); - e->vmaxps(ymmA, ymmB, ymmC); - e->vmaxps(ymmA, ymmB, anyptr_gpC); - e->vmaxsd(xmmA, xmmB, xmmC); - e->vmaxsd(xmmA, xmmB, anyptr_gpC); - e->vmaxss(xmmA, xmmB, xmmC); - e->vmaxss(xmmA, xmmB, anyptr_gpC); - e->vminpd(xmmA, xmmB, xmmC); - e->vminpd(xmmA, xmmB, anyptr_gpC); - e->vminpd(ymmA, ymmB, ymmC); - e->vminpd(ymmA, ymmB, anyptr_gpC); - e->vminps(xmmA, xmmB, xmmC); - e->vminps(xmmA, xmmB, anyptr_gpC); - e->vminps(ymmA, ymmB, ymmC); - e->vminps(ymmA, ymmB, anyptr_gpC); - e->vminsd(xmmA, xmmB, xmmC); - e->vminsd(xmmA, xmmB, anyptr_gpC); - e->vminss(xmmA, xmmB, xmmC); - e->vminss(xmmA, xmmB, anyptr_gpC); - e->vmovapd(xmmA, xmmB); - e->vmovapd(xmmA, anyptr_gpB); - e->vmovapd(anyptr_gpA, xmmB); - e->vmovapd(ymmA, ymmB); - e->vmovapd(ymmA, anyptr_gpB); - e->vmovapd(anyptr_gpA, ymmB); - e->vmovaps(xmmA, xmmB); - e->vmovaps(xmmA, anyptr_gpB); - e->vmovaps(anyptr_gpA, xmmB); - e->vmovaps(ymmA, ymmB); - e->vmovaps(ymmA, anyptr_gpB); - e->vmovaps(anyptr_gpA, ymmB); - e->vmovd(xmmA, gzB); - e->vmovd(xmmA, anyptr_gpB); - e->vmovd(gzA, xmmB); - e->vmovd(anyptr_gpA, xmmB); - e->vmovddup(xmmA, xmmB); - e->vmovddup(xmmA, anyptr_gpB); - e->vmovddup(ymmA, ymmB); - e->vmovddup(ymmA, anyptr_gpB); - e->vmovdqa(xmmA, xmmB); - e->vmovdqa(xmmA, anyptr_gpB); - e->vmovdqa(anyptr_gpA, xmmB); - e->vmovdqa(ymmA, ymmB); - e->vmovdqa(ymmA, anyptr_gpB); - e->vmovdqa(anyptr_gpA, ymmB); - e->vmovdqu(xmmA, xmmB); - e->vmovdqu(xmmA, anyptr_gpB); - e->vmovdqu(anyptr_gpA, xmmB); - e->vmovdqu(ymmA, ymmB); - e->vmovdqu(ymmA, anyptr_gpB); - e->vmovdqu(anyptr_gpA, ymmB); - e->vmovhlps(xmmA, xmmB, xmmC); - e->vmovhpd(xmmA, xmmB, anyptr_gpC); - e->vmovhpd(anyptr_gpA, xmmB); - e->vmovhps(xmmA, xmmB, anyptr_gpC); - e->vmovhps(anyptr_gpA, xmmB); - e->vmovlhps(xmmA, xmmB, xmmC); - e->vmovlpd(xmmA, xmmB, anyptr_gpC); - e->vmovlpd(anyptr_gpA, xmmB); - e->vmovlps(xmmA, xmmB, anyptr_gpC); - e->vmovlps(anyptr_gpA, xmmB); - e->vmovmskpd(gzA, xmmB); - e->vmovmskpd(gzA, ymmB); - e->vmovmskps(gzA, xmmB); - e->vmovmskps(gzA, ymmB); - e->vmovntdq(anyptr_gpA, xmmB); - e->vmovntdq(anyptr_gpA, ymmB); - e->vmovntdqa(xmmA, anyptr_gpB); - e->vmovntpd(anyptr_gpA, xmmB); - e->vmovntpd(anyptr_gpA, ymmB); - e->vmovntps(anyptr_gpA, xmmB); - e->vmovntps(anyptr_gpA, ymmB); - e->vmovsd(xmmA, xmmB, xmmC); - e->vmovsd(xmmA, anyptr_gpB); - e->vmovsd(anyptr_gpA, xmmB); - e->vmovshdup(xmmA, xmmB); - e->vmovshdup(xmmA, anyptr_gpB); - e->vmovshdup(ymmA, ymmB); - e->vmovshdup(ymmA, anyptr_gpB); - e->vmovsldup(xmmA, xmmB); - e->vmovsldup(xmmA, anyptr_gpB); - e->vmovsldup(ymmA, ymmB); - e->vmovsldup(ymmA, anyptr_gpB); - e->vmovss(xmmA, xmmB, xmmC); - e->vmovss(xmmA, anyptr_gpB); - e->vmovss(anyptr_gpA, xmmB); - e->vmovupd(xmmA, xmmB); - e->vmovupd(xmmA, anyptr_gpB); - e->vmovupd(anyptr_gpA, xmmB); - e->vmovupd(ymmA, ymmB); - e->vmovupd(ymmA, anyptr_gpB); - e->vmovupd(anyptr_gpA, ymmB); - e->vmovups(xmmA, xmmB); - e->vmovups(xmmA, anyptr_gpB); - e->vmovups(anyptr_gpA, xmmB); - e->vmovups(ymmA, ymmB); - e->vmovups(ymmA, anyptr_gpB); - e->vmovups(anyptr_gpA, ymmB); - e->vmpsadbw(xmmA, xmmB, xmmC, 0); - e->vmpsadbw(xmmA, xmmB, anyptr_gpC, 0); - e->vmulpd(xmmA, xmmB, xmmC); - e->vmulpd(xmmA, xmmB, anyptr_gpC); - e->vmulpd(ymmA, ymmB, ymmC); - e->vmulpd(ymmA, ymmB, anyptr_gpC); - e->vmulps(xmmA, xmmB, xmmC); - e->vmulps(xmmA, xmmB, anyptr_gpC); - e->vmulps(ymmA, ymmB, ymmC); - e->vmulps(ymmA, ymmB, anyptr_gpC); - e->vmulsd(xmmA, xmmB, xmmC); - e->vmulsd(xmmA, xmmB, anyptr_gpC); - e->vmulss(xmmA, xmmB, xmmC); - e->vmulss(xmmA, xmmB, anyptr_gpC); - e->vorpd(xmmA, xmmB, xmmC); - e->vorpd(xmmA, xmmB, anyptr_gpC); - e->vorpd(ymmA, ymmB, ymmC); - e->vorpd(ymmA, ymmB, anyptr_gpC); - e->vorps(xmmA, xmmB, xmmC); - e->vorps(xmmA, xmmB, anyptr_gpC); - e->vorps(ymmA, ymmB, ymmC); - e->vorps(ymmA, ymmB, anyptr_gpC); - e->vpabsb(xmmA, xmmB); - e->vpabsb(xmmA, anyptr_gpB); - e->vpabsd(xmmA, xmmB); - e->vpabsd(xmmA, anyptr_gpB); - e->vpabsw(xmmA, xmmB); - e->vpabsw(xmmA, anyptr_gpB); - e->vpackssdw(xmmA, xmmB, xmmC); - e->vpackssdw(xmmA, xmmB, anyptr_gpC); - e->vpacksswb(xmmA, xmmB, xmmC); - e->vpacksswb(xmmA, xmmB, anyptr_gpC); - e->vpackusdw(xmmA, xmmB, xmmC); - e->vpackusdw(xmmA, xmmB, anyptr_gpC); - e->vpackuswb(xmmA, xmmB, xmmC); - e->vpackuswb(xmmA, xmmB, anyptr_gpC); - e->vpaddb(xmmA, xmmB, xmmC); - e->vpaddb(xmmA, xmmB, anyptr_gpC); - e->vpaddd(xmmA, xmmB, xmmC); - e->vpaddd(xmmA, xmmB, anyptr_gpC); - e->vpaddq(xmmA, xmmB, xmmC); - e->vpaddq(xmmA, xmmB, anyptr_gpC); - e->vpaddw(xmmA, xmmB, xmmC); - e->vpaddw(xmmA, xmmB, anyptr_gpC); - e->vpaddsb(xmmA, xmmB, xmmC); - e->vpaddsb(xmmA, xmmB, anyptr_gpC); - e->vpaddsw(xmmA, xmmB, xmmC); - e->vpaddsw(xmmA, xmmB, anyptr_gpC); - e->vpaddusb(xmmA, xmmB, xmmC); - e->vpaddusb(xmmA, xmmB, anyptr_gpC); - e->vpaddusw(xmmA, xmmB, xmmC); - e->vpaddusw(xmmA, xmmB, anyptr_gpC); - e->vpalignr(xmmA, xmmB, xmmC, 0); - e->vpalignr(xmmA, xmmB, anyptr_gpC, 0); - e->vpand(xmmA, xmmB, xmmC); - e->vpand(xmmA, xmmB, anyptr_gpC); - e->vpandn(xmmA, xmmB, xmmC); - e->vpandn(xmmA, xmmB, anyptr_gpC); - e->vpavgb(xmmA, xmmB, xmmC); - e->vpavgb(xmmA, xmmB, anyptr_gpC); - e->vpavgw(xmmA, xmmB, xmmC); - e->vpavgw(xmmA, xmmB, anyptr_gpC); - e->vpblendvb(xmmA, xmmB, xmmC, xmmD); - e->vpblendvb(xmmA, xmmB, anyptr_gpC, xmmD); - e->vpblendw(xmmA, xmmB, xmmC, 0); - e->vpblendw(xmmA, xmmB, anyptr_gpC, 0); - e->vpcmpeqb(xmmA, xmmB, xmmC); - e->vpcmpeqb(xmmA, xmmB, anyptr_gpC); - e->vpcmpeqd(xmmA, xmmB, xmmC); - e->vpcmpeqd(xmmA, xmmB, anyptr_gpC); - e->vpcmpeqq(xmmA, xmmB, xmmC); - e->vpcmpeqq(xmmA, xmmB, anyptr_gpC); - e->vpcmpeqw(xmmA, xmmB, xmmC); - e->vpcmpeqw(xmmA, xmmB, anyptr_gpC); - e->vpcmpgtb(xmmA, xmmB, xmmC); - e->vpcmpgtb(xmmA, xmmB, anyptr_gpC); - e->vpcmpgtd(xmmA, xmmB, xmmC); - e->vpcmpgtd(xmmA, xmmB, anyptr_gpC); - e->vpcmpgtq(xmmA, xmmB, xmmC); - e->vpcmpgtq(xmmA, xmmB, anyptr_gpC); - e->vpcmpgtw(xmmA, xmmB, xmmC); - e->vpcmpgtw(xmmA, xmmB, anyptr_gpC); - e->vpcmpestri(xmmA, xmmB, 0); - e->vpcmpestri(xmmA, anyptr_gpB, 0); - e->vpcmpestrm(xmmA, xmmB, 0); - e->vpcmpestrm(xmmA, anyptr_gpB, 0); - e->vpcmpistri(xmmA, xmmB, 0); - e->vpcmpistri(xmmA, anyptr_gpB, 0); - e->vpcmpistrm(xmmA, xmmB, 0); - e->vpcmpistrm(xmmA, anyptr_gpB, 0); - e->vpermilpd(xmmA, xmmB, xmmC); - e->vpermilpd(xmmA, xmmB, anyptr_gpC); - e->vpermilpd(ymmA, ymmB, ymmC); - e->vpermilpd(ymmA, ymmB, anyptr_gpC); - e->vpermilpd(xmmA, xmmB, 0); - e->vpermilpd(xmmA, anyptr_gpB, 0); - e->vpermilpd(ymmA, ymmB, 0); - e->vpermilpd(ymmA, anyptr_gpB, 0); - e->vpermilps(xmmA, xmmB, xmmC); - e->vpermilps(xmmA, xmmB, anyptr_gpC); - e->vpermilps(ymmA, ymmB, ymmC); - e->vpermilps(ymmA, ymmB, anyptr_gpC); - e->vpermilps(xmmA, xmmB, 0); - e->vpermilps(xmmA, anyptr_gpB, 0); - e->vpermilps(ymmA, ymmB, 0); - e->vpermilps(ymmA, anyptr_gpB, 0); - e->vperm2f128(ymmA, ymmB, ymmC, 0); - e->vperm2f128(ymmA, ymmB, anyptr_gpC, 0); - e->vpextrb(gzA, xmmB, 0); - e->vpextrb(anyptr_gpA, xmmB, 0); - e->vpextrd(gzA, xmmB, 0); - e->vpextrd(anyptr_gpA, xmmB, 0); - if (isX64) e->vpextrq(gzA, xmmB, 0); - if (isX64) e->vpextrq(anyptr_gpA, xmmB, 0); - e->vpextrw(gzA, xmmB, 0); - e->vpextrw(anyptr_gpA, xmmB, 0); - e->vphaddd(xmmA, xmmB, xmmC); - e->vphaddd(xmmA, xmmB, anyptr_gpC); - e->vphaddsw(xmmA, xmmB, xmmC); - e->vphaddsw(xmmA, xmmB, anyptr_gpC); - e->vphaddw(xmmA, xmmB, xmmC); - e->vphaddw(xmmA, xmmB, anyptr_gpC); - e->vphminposuw(xmmA, xmmB); - e->vphminposuw(xmmA, anyptr_gpB); - e->vphsubd(xmmA, xmmB, xmmC); - e->vphsubd(xmmA, xmmB, anyptr_gpC); - e->vphsubsw(xmmA, xmmB, xmmC); - e->vphsubsw(xmmA, xmmB, anyptr_gpC); - e->vphsubw(xmmA, xmmB, xmmC); - e->vphsubw(xmmA, xmmB, anyptr_gpC); - e->vpinsrb(xmmA, xmmB, gzC, 0); - e->vpinsrb(xmmA, xmmB, anyptr_gpC, 0); - e->vpinsrd(xmmA, xmmB, gzC, 0); - e->vpinsrd(xmmA, xmmB, anyptr_gpC, 0); - e->vpinsrw(xmmA, xmmB, gzC, 0); - e->vpinsrw(xmmA, xmmB, anyptr_gpC, 0); - e->vpmaddubsw(xmmA, xmmB, xmmC); - e->vpmaddubsw(xmmA, xmmB, anyptr_gpC); - e->vpmaddwd(xmmA, xmmB, xmmC); - e->vpmaddwd(xmmA, xmmB, anyptr_gpC); - e->vpmaxsb(xmmA, xmmB, xmmC); - e->vpmaxsb(xmmA, xmmB, anyptr_gpC); - e->vpmaxsd(xmmA, xmmB, xmmC); - e->vpmaxsd(xmmA, xmmB, anyptr_gpC); - e->vpmaxsw(xmmA, xmmB, xmmC); - e->vpmaxsw(xmmA, xmmB, anyptr_gpC); - e->vpmaxub(xmmA, xmmB, xmmC); - e->vpmaxub(xmmA, xmmB, anyptr_gpC); - e->vpmaxud(xmmA, xmmB, xmmC); - e->vpmaxud(xmmA, xmmB, anyptr_gpC); - e->vpmaxuw(xmmA, xmmB, xmmC); - e->vpmaxuw(xmmA, xmmB, anyptr_gpC); - e->vpminsb(xmmA, xmmB, xmmC); - e->vpminsb(xmmA, xmmB, anyptr_gpC); - e->vpminsd(xmmA, xmmB, xmmC); - e->vpminsd(xmmA, xmmB, anyptr_gpC); - e->vpminsw(xmmA, xmmB, xmmC); - e->vpminsw(xmmA, xmmB, anyptr_gpC); - e->vpminub(xmmA, xmmB, xmmC); - e->vpminub(xmmA, xmmB, anyptr_gpC); - e->vpminud(xmmA, xmmB, xmmC); - e->vpminud(xmmA, xmmB, anyptr_gpC); - e->vpminuw(xmmA, xmmB, xmmC); - e->vpminuw(xmmA, xmmB, anyptr_gpC); - e->vpmovmskb(gzA, xmmB); - e->vpmovsxbd(xmmA, xmmB); - e->vpmovsxbd(xmmA, anyptr_gpB); - e->vpmovsxbq(xmmA, xmmB); - e->vpmovsxbq(xmmA, anyptr_gpB); - e->vpmovsxbw(xmmA, xmmB); - e->vpmovsxbw(xmmA, anyptr_gpB); - e->vpmovsxdq(xmmA, xmmB); - e->vpmovsxdq(xmmA, anyptr_gpB); - e->vpmovsxwd(xmmA, xmmB); - e->vpmovsxwd(xmmA, anyptr_gpB); - e->vpmovsxwq(xmmA, xmmB); - e->vpmovsxwq(xmmA, anyptr_gpB); - e->vpmovzxbd(xmmA, xmmB); - e->vpmovzxbd(xmmA, anyptr_gpB); - e->vpmovzxbq(xmmA, xmmB); - e->vpmovzxbq(xmmA, anyptr_gpB); - e->vpmovzxbw(xmmA, xmmB); - e->vpmovzxbw(xmmA, anyptr_gpB); - e->vpmovzxdq(xmmA, xmmB); - e->vpmovzxdq(xmmA, anyptr_gpB); - e->vpmovzxwd(xmmA, xmmB); - e->vpmovzxwd(xmmA, anyptr_gpB); - e->vpmovzxwq(xmmA, xmmB); - e->vpmovzxwq(xmmA, anyptr_gpB); - e->vpmuldq(xmmA, xmmB, xmmC); - e->vpmuldq(xmmA, xmmB, anyptr_gpC); - e->vpmulhrsw(xmmA, xmmB, xmmC); - e->vpmulhrsw(xmmA, xmmB, anyptr_gpC); - e->vpmulhuw(xmmA, xmmB, xmmC); - e->vpmulhuw(xmmA, xmmB, anyptr_gpC); - e->vpmulhw(xmmA, xmmB, xmmC); - e->vpmulhw(xmmA, xmmB, anyptr_gpC); - e->vpmulld(xmmA, xmmB, xmmC); - e->vpmulld(xmmA, xmmB, anyptr_gpC); - e->vpmullw(xmmA, xmmB, xmmC); - e->vpmullw(xmmA, xmmB, anyptr_gpC); - e->vpmuludq(xmmA, xmmB, xmmC); - e->vpmuludq(xmmA, xmmB, anyptr_gpC); - e->vpor(xmmA, xmmB, xmmC); - e->vpor(xmmA, xmmB, anyptr_gpC); - e->vpsadbw(xmmA, xmmB, xmmC); - e->vpsadbw(xmmA, xmmB, anyptr_gpC); - e->vpshufb(xmmA, xmmB, xmmC); - e->vpshufb(xmmA, xmmB, anyptr_gpC); - e->vpshufd(xmmA, xmmB, 0); - e->vpshufd(xmmA, anyptr_gpB, 0); - e->vpshufhw(xmmA, xmmB, 0); - e->vpshufhw(xmmA, anyptr_gpB, 0); - e->vpshuflw(xmmA, xmmB, 0); - e->vpshuflw(xmmA, anyptr_gpB, 0); - e->vpsignb(xmmA, xmmB, xmmC); - e->vpsignb(xmmA, xmmB, anyptr_gpC); - e->vpsignd(xmmA, xmmB, xmmC); - e->vpsignd(xmmA, xmmB, anyptr_gpC); - e->vpsignw(xmmA, xmmB, xmmC); - e->vpsignw(xmmA, xmmB, anyptr_gpC); - e->vpslld(xmmA, xmmB, xmmC); - e->vpslld(xmmA, xmmB, anyptr_gpC); - e->vpslld(xmmA, xmmB, 0); - e->vpslldq(xmmA, xmmB, 0); - e->vpsllq(xmmA, xmmB, xmmC); - e->vpsllq(xmmA, xmmB, anyptr_gpC); - e->vpsllq(xmmA, xmmB, 0); - e->vpsllw(xmmA, xmmB, xmmC); - e->vpsllw(xmmA, xmmB, anyptr_gpC); - e->vpsllw(xmmA, xmmB, 0); - e->vpsrad(xmmA, xmmB, xmmC); - e->vpsrad(xmmA, xmmB, anyptr_gpC); - e->vpsrad(xmmA, xmmB, 0); - e->vpsraw(xmmA, xmmB, xmmC); - e->vpsraw(xmmA, xmmB, anyptr_gpC); - e->vpsraw(xmmA, xmmB, 0); - e->vpsrld(xmmA, xmmB, xmmC); - e->vpsrld(xmmA, xmmB, anyptr_gpC); - e->vpsrld(xmmA, xmmB, 0); - e->vpsrldq(xmmA, xmmB, 0); - e->vpsrlq(xmmA, xmmB, xmmC); - e->vpsrlq(xmmA, xmmB, anyptr_gpC); - e->vpsrlq(xmmA, xmmB, 0); - e->vpsrlw(xmmA, xmmB, xmmC); - e->vpsrlw(xmmA, xmmB, anyptr_gpC); - e->vpsrlw(xmmA, xmmB, 0); - e->vpsubb(xmmA, xmmB, xmmC); - e->vpsubb(xmmA, xmmB, anyptr_gpC); - e->vpsubd(xmmA, xmmB, xmmC); - e->vpsubd(xmmA, xmmB, anyptr_gpC); - e->vpsubq(xmmA, xmmB, xmmC); - e->vpsubq(xmmA, xmmB, anyptr_gpC); - e->vpsubw(xmmA, xmmB, xmmC); - e->vpsubw(xmmA, xmmB, anyptr_gpC); - e->vpsubsb(xmmA, xmmB, xmmC); - e->vpsubsb(xmmA, xmmB, anyptr_gpC); - e->vpsubsw(xmmA, xmmB, xmmC); - e->vpsubsw(xmmA, xmmB, anyptr_gpC); - e->vpsubusb(xmmA, xmmB, xmmC); - e->vpsubusb(xmmA, xmmB, anyptr_gpC); - e->vpsubusw(xmmA, xmmB, xmmC); - e->vpsubusw(xmmA, xmmB, anyptr_gpC); - e->vptest(xmmA, xmmB); - e->vptest(xmmA, anyptr_gpB); - e->vptest(ymmA, ymmB); - e->vptest(ymmA, anyptr_gpB); - e->vpunpckhbw(xmmA, xmmB, xmmC); - e->vpunpckhbw(xmmA, xmmB, anyptr_gpC); - e->vpunpckhdq(xmmA, xmmB, xmmC); - e->vpunpckhdq(xmmA, xmmB, anyptr_gpC); - e->vpunpckhqdq(xmmA, xmmB, xmmC); - e->vpunpckhqdq(xmmA, xmmB, anyptr_gpC); - e->vpunpckhwd(xmmA, xmmB, xmmC); - e->vpunpckhwd(xmmA, xmmB, anyptr_gpC); - e->vpunpcklbw(xmmA, xmmB, xmmC); - e->vpunpcklbw(xmmA, xmmB, anyptr_gpC); - e->vpunpckldq(xmmA, xmmB, xmmC); - e->vpunpckldq(xmmA, xmmB, anyptr_gpC); - e->vpunpcklqdq(xmmA, xmmB, xmmC); - e->vpunpcklqdq(xmmA, xmmB, anyptr_gpC); - e->vpunpcklwd(xmmA, xmmB, xmmC); - e->vpunpcklwd(xmmA, xmmB, anyptr_gpC); - e->vpxor(xmmA, xmmB, xmmC); - e->vpxor(xmmA, xmmB, anyptr_gpC); - e->vrcpps(xmmA, xmmB); - e->vrcpps(xmmA, anyptr_gpB); - e->vrcpps(ymmA, ymmB); - e->vrcpps(ymmA, anyptr_gpB); - e->vrcpss(xmmA, xmmB, xmmC); - e->vrcpss(xmmA, xmmB, anyptr_gpC); - e->vrsqrtps(xmmA, xmmB); - e->vrsqrtps(xmmA, anyptr_gpB); - e->vrsqrtps(ymmA, ymmB); - e->vrsqrtps(ymmA, anyptr_gpB); - e->vrsqrtss(xmmA, xmmB, xmmC); - e->vrsqrtss(xmmA, xmmB, anyptr_gpC); - e->vroundpd(xmmA, xmmB, 0); - e->vroundpd(xmmA, anyptr_gpB, 0); - e->vroundpd(ymmA, ymmB, 0); - e->vroundpd(ymmA, anyptr_gpB, 0); - e->vroundps(xmmA, xmmB, 0); - e->vroundps(xmmA, anyptr_gpB, 0); - e->vroundps(ymmA, ymmB, 0); - e->vroundps(ymmA, anyptr_gpB, 0); - e->vroundsd(xmmA, xmmB, xmmC, 0); - e->vroundsd(xmmA, xmmB, anyptr_gpC, 0); - e->vroundss(xmmA, xmmB, xmmC, 0); - e->vroundss(xmmA, xmmB, anyptr_gpC, 0); - e->vshufpd(xmmA, xmmB, xmmC, 0); - e->vshufpd(xmmA, xmmB, anyptr_gpC, 0); - e->vshufpd(ymmA, ymmB, ymmC, 0); - e->vshufpd(ymmA, ymmB, anyptr_gpC, 0); - e->vshufps(xmmA, xmmB, xmmC, 0); - e->vshufps(xmmA, xmmB, anyptr_gpC, 0); - e->vshufps(ymmA, ymmB, ymmC, 0); - e->vshufps(ymmA, ymmB, anyptr_gpC, 0); - e->vsqrtpd(xmmA, xmmB); - e->vsqrtpd(xmmA, anyptr_gpB); - e->vsqrtpd(ymmA, ymmB); - e->vsqrtpd(ymmA, anyptr_gpB); - e->vsqrtps(xmmA, xmmB); - e->vsqrtps(xmmA, anyptr_gpB); - e->vsqrtps(ymmA, ymmB); - e->vsqrtps(ymmA, anyptr_gpB); - e->vsqrtsd(xmmA, xmmB, xmmC); - e->vsqrtsd(xmmA, xmmB, anyptr_gpC); - e->vsqrtss(xmmA, xmmB, xmmC); - e->vsqrtss(xmmA, xmmB, anyptr_gpC); - e->vstmxcsr(anyptr_gpA); - e->vsubpd(xmmA, xmmB, xmmC); - e->vsubpd(xmmA, xmmB, anyptr_gpC); - e->vsubpd(ymmA, ymmB, ymmC); - e->vsubpd(ymmA, ymmB, anyptr_gpC); - e->vsubps(xmmA, xmmB, xmmC); - e->vsubps(xmmA, xmmB, anyptr_gpC); - e->vsubps(ymmA, ymmB, ymmC); - e->vsubps(ymmA, ymmB, anyptr_gpC); - e->vsubsd(xmmA, xmmB, xmmC); - e->vsubsd(xmmA, xmmB, anyptr_gpC); - e->vsubss(xmmA, xmmB, xmmC); - e->vsubss(xmmA, xmmB, anyptr_gpC); - e->vtestps(xmmA, xmmB); - e->vtestps(xmmA, anyptr_gpB); - e->vtestps(ymmA, ymmB); - e->vtestps(ymmA, anyptr_gpB); - e->vtestpd(xmmA, xmmB); - e->vtestpd(xmmA, anyptr_gpB); - e->vtestpd(ymmA, ymmB); - e->vtestpd(ymmA, anyptr_gpB); - e->vucomisd(xmmA, xmmB); - e->vucomisd(xmmA, anyptr_gpB); - e->vucomiss(xmmA, xmmB); - e->vucomiss(xmmA, anyptr_gpB); - e->vunpckhpd(xmmA, xmmB, xmmC); - e->vunpckhpd(xmmA, xmmB, anyptr_gpC); - e->vunpckhpd(ymmA, ymmB, ymmC); - e->vunpckhpd(ymmA, ymmB, anyptr_gpC); - e->vunpckhps(xmmA, xmmB, xmmC); - e->vunpckhps(xmmA, xmmB, anyptr_gpC); - e->vunpckhps(ymmA, ymmB, ymmC); - e->vunpckhps(ymmA, ymmB, anyptr_gpC); - e->vunpcklpd(xmmA, xmmB, xmmC); - e->vunpcklpd(xmmA, xmmB, anyptr_gpC); - e->vunpcklpd(ymmA, ymmB, ymmC); - e->vunpcklpd(ymmA, ymmB, anyptr_gpC); - e->vunpcklps(xmmA, xmmB, xmmC); - e->vunpcklps(xmmA, xmmB, anyptr_gpC); - e->vunpcklps(ymmA, ymmB, ymmC); - e->vunpcklps(ymmA, ymmB, anyptr_gpC); - e->vxorpd(xmmA, xmmB, xmmC); - e->vxorpd(xmmA, xmmB, anyptr_gpC); - e->vxorpd(ymmA, ymmB, ymmC); - e->vxorpd(ymmA, ymmB, anyptr_gpC); - e->vxorps(xmmA, xmmB, xmmC); - e->vxorps(xmmA, xmmB, anyptr_gpC); - e->vxorps(ymmA, ymmB, ymmC); - e->vxorps(ymmA, ymmB, anyptr_gpC); - e->vzeroall(); - e->vex3().vzeroall(); - e->vzeroupper(); - e->vex3().vzeroupper(); - - // AVX+AESNI. - e->nop(); - - e->vaesdec(xmmA, xmmB, xmmC); - e->vaesdec(xmmA, xmmB, anyptr_gpC); - e->vaesdeclast(xmmA, xmmB, xmmC); - e->vaesdeclast(xmmA, xmmB, anyptr_gpC); - e->vaesenc(xmmA, xmmB, xmmC); - e->vaesenc(xmmA, xmmB, anyptr_gpC); - e->vaesenclast(xmmA, xmmB, xmmC); - e->vaesenclast(xmmA, xmmB, anyptr_gpC); - e->vaesimc(xmmA, xmmB); - e->vaesimc(xmmA, anyptr_gpB); - e->vaeskeygenassist(xmmA, xmmB, 0); - e->vaeskeygenassist(xmmA, anyptr_gpB, 0); - - // AVX+PCLMULQDQ. - e->nop(); - - e->vpclmulqdq(xmmA, xmmB, xmmC, 0); - e->vpclmulqdq(xmmA, xmmB, anyptr_gpC, 0); - - // AVX2. - e->nop(); - - e->vbroadcasti128(ymmA, anyptr_gpB); - e->vbroadcastsd(ymmA, xmmB); - e->vbroadcastss(xmmA, xmmB); - e->vbroadcastss(ymmA, xmmB); - e->vextracti128(xmmA, ymmB, 0); - e->vextracti128(anyptr_gpA, ymmB, 0); - e->vgatherdpd(xmmA, vx_ptr, xmmC); - e->vgatherdpd(ymmA, vx_ptr, ymmC); - e->vgatherdps(xmmA, vx_ptr, xmmC); - e->vgatherdps(ymmA, vy_ptr, ymmC); - e->vgatherqpd(xmmA, vx_ptr, xmmC); - e->vgatherqpd(ymmA, vy_ptr, ymmC); - e->vgatherqps(xmmA, vx_ptr, xmmC); - e->vgatherqps(xmmA, vy_ptr, xmmC); - e->vinserti128(ymmA, ymmB, xmmC, 0); - e->vinserti128(ymmA, ymmB, anyptr_gpC, 0); - e->vmovntdqa(ymmA, anyptr_gpB); - e->vmpsadbw(ymmA, ymmB, ymmC, 0); - e->vmpsadbw(ymmA, ymmB, anyptr_gpC, 0); - e->vpabsb(ymmA, ymmB); - e->vpabsb(ymmA, anyptr_gpB); - e->vpabsd(ymmA, ymmB); - e->vpabsd(ymmA, anyptr_gpB); - e->vpabsw(ymmA, ymmB); - e->vpabsw(ymmA, anyptr_gpB); - e->vpackssdw(ymmA, ymmB, ymmC); - e->vpackssdw(ymmA, ymmB, anyptr_gpC); - e->vpacksswb(ymmA, ymmB, ymmC); - e->vpacksswb(ymmA, ymmB, anyptr_gpC); - e->vpackusdw(ymmA, ymmB, ymmC); - e->vpackusdw(ymmA, ymmB, anyptr_gpC); - e->vpackuswb(ymmA, ymmB, ymmC); - e->vpackuswb(ymmA, ymmB, anyptr_gpC); - e->vpaddb(ymmA, ymmB, ymmC); - e->vpaddb(ymmA, ymmB, anyptr_gpC); - e->vpaddd(ymmA, ymmB, ymmC); - e->vpaddd(ymmA, ymmB, anyptr_gpC); - e->vpaddq(ymmA, ymmB, ymmC); - e->vpaddq(ymmA, ymmB, anyptr_gpC); - e->vpaddw(ymmA, ymmB, ymmC); - e->vpaddw(ymmA, ymmB, anyptr_gpC); - e->vpaddsb(ymmA, ymmB, ymmC); - e->vpaddsb(ymmA, ymmB, anyptr_gpC); - e->vpaddsw(ymmA, ymmB, ymmC); - e->vpaddsw(ymmA, ymmB, anyptr_gpC); - e->vpaddusb(ymmA, ymmB, ymmC); - e->vpaddusb(ymmA, ymmB, anyptr_gpC); - e->vpaddusw(ymmA, ymmB, ymmC); - e->vpaddusw(ymmA, ymmB, anyptr_gpC); - e->vpalignr(ymmA, ymmB, ymmC, 0); - e->vpalignr(ymmA, ymmB, anyptr_gpC, 0); - e->vpand(ymmA, ymmB, ymmC); - e->vpand(ymmA, ymmB, anyptr_gpC); - e->vpandn(ymmA, ymmB, ymmC); - e->vpandn(ymmA, ymmB, anyptr_gpC); - e->vpavgb(ymmA, ymmB, ymmC); - e->vpavgb(ymmA, ymmB, anyptr_gpC); - e->vpavgw(ymmA, ymmB, ymmC); - e->vpavgw(ymmA, ymmB, anyptr_gpC); - e->vpblendd(xmmA, xmmB, xmmC, 0); - e->vpblendd(xmmA, xmmB, anyptr_gpC, 0); - e->vpblendd(ymmA, ymmB, ymmC, 0); - e->vpblendd(ymmA, ymmB, anyptr_gpC, 0); - e->vpblendvb(ymmA, ymmB, ymmC, ymmD); - e->vpblendvb(ymmA, ymmB, anyptr_gpC, ymmD); - e->vpblendw(ymmA, ymmB, ymmC, 0); - e->vpblendw(ymmA, ymmB, anyptr_gpC, 0); - e->vpbroadcastb(xmmA, xmmB); - e->vpbroadcastb(xmmA, anyptr_gpB); - e->vpbroadcastb(ymmA, xmmB); - e->vpbroadcastb(ymmA, anyptr_gpB); - e->vpbroadcastd(xmmA, xmmB); - e->vpbroadcastd(xmmA, anyptr_gpB); - e->vpbroadcastd(ymmA, xmmB); - e->vpbroadcastd(ymmA, anyptr_gpB); - e->vpbroadcastq(xmmA, xmmB); - e->vpbroadcastq(xmmA, anyptr_gpB); - e->vpbroadcastq(ymmA, xmmB); - e->vpbroadcastq(ymmA, anyptr_gpB); - e->vpbroadcastw(xmmA, xmmB); - e->vpbroadcastw(xmmA, anyptr_gpB); - e->vpbroadcastw(ymmA, xmmB); - e->vpbroadcastw(ymmA, anyptr_gpB); - e->vpcmpeqb(ymmA, ymmB, ymmC); - e->vpcmpeqb(ymmA, ymmB, anyptr_gpC); - e->vpcmpeqd(ymmA, ymmB, ymmC); - e->vpcmpeqd(ymmA, ymmB, anyptr_gpC); - e->vpcmpeqq(ymmA, ymmB, ymmC); - e->vpcmpeqq(ymmA, ymmB, anyptr_gpC); - e->vpcmpeqw(ymmA, ymmB, ymmC); - e->vpcmpeqw(ymmA, ymmB, anyptr_gpC); - e->vpcmpgtb(ymmA, ymmB, ymmC); - e->vpcmpgtb(ymmA, ymmB, anyptr_gpC); - e->vpcmpgtd(ymmA, ymmB, ymmC); - e->vpcmpgtd(ymmA, ymmB, anyptr_gpC); - e->vpcmpgtq(ymmA, ymmB, ymmC); - e->vpcmpgtq(ymmA, ymmB, anyptr_gpC); - e->vpcmpgtw(ymmA, ymmB, ymmC); - e->vpcmpgtw(ymmA, ymmB, anyptr_gpC); - e->vperm2i128(ymmA, ymmB, ymmC, 0); - e->vperm2i128(ymmA, ymmB, anyptr_gpC, 0); - e->vpermd(ymmA, ymmB, ymmC); - e->vpermd(ymmA, ymmB, anyptr_gpC); - e->vpermps(ymmA, ymmB, ymmC); - e->vpermps(ymmA, ymmB, anyptr_gpC); - e->vpermpd(ymmA, ymmB, 0); - e->vpermpd(ymmA, anyptr_gpB, 0); - e->vpermq(ymmA, ymmB, 0); - e->vpermq(ymmA, anyptr_gpB, 0); - e->vpgatherdd(xmmA, vx_ptr, xmmC); - e->vpgatherdd(ymmA, vy_ptr, ymmC); - e->vpgatherdq(xmmA, vx_ptr, xmmC); - e->vpgatherdq(ymmA, vx_ptr, ymmC); - e->vpgatherqd(xmmA, vx_ptr, xmmC); - e->vpgatherqd(xmmA, vy_ptr, xmmC); - e->vpgatherqq(xmmA, vx_ptr, xmmC); - e->vpgatherqq(ymmA, vy_ptr, ymmC); - e->vpmovmskb(gzA, ymmB); - e->vpmovsxbd(ymmA, anyptr_gpB); - e->vpmovsxbd(ymmA, xmmB); - e->vpmovsxbq(ymmA, anyptr_gpB); - e->vpmovsxbq(ymmA, xmmB); - e->vpmovsxbw(ymmA, anyptr_gpB); - e->vpmovsxbw(ymmA, xmmB); - e->vpmovsxdq(ymmA, anyptr_gpB); - e->vpmovsxdq(ymmA, xmmB); - e->vpmovsxwd(ymmA, anyptr_gpB); - e->vpmovsxwd(ymmA, xmmB); - e->vpmovsxwq(ymmA, anyptr_gpB); - e->vpmovsxwq(ymmA, xmmB); - e->vpmovzxbd(ymmA, anyptr_gpB); - e->vpmovzxbd(ymmA, xmmB); - e->vpmovzxbq(ymmA, anyptr_gpB); - e->vpmovzxbq(ymmA, xmmB); - e->vpmovzxbw(ymmA, anyptr_gpB); - e->vpmovzxbw(ymmA, xmmB); - e->vpmovzxdq(ymmA, anyptr_gpB); - e->vpmovzxdq(ymmA, xmmB); - e->vpmovzxwd(ymmA, anyptr_gpB); - e->vpmovzxwd(ymmA, xmmB); - e->vpmovzxwq(ymmA, anyptr_gpB); - e->vpmovzxwq(ymmA, xmmB); - e->vpshufd(ymmA, anyptr_gpB, 0); - e->vpshufd(ymmA, ymmB, 0); - e->vpshufhw(ymmA, anyptr_gpB, 0); - e->vpshufhw(ymmA, ymmB, 0); - e->vpshuflw(ymmA, anyptr_gpB, 0); - e->vpshuflw(ymmA, ymmB, 0); - e->vpslld(ymmA, ymmB, 0); - e->vpslldq(ymmA, ymmB, 0); - e->vpsllq(ymmA, ymmB, 0); - e->vpsllw(ymmA, ymmB, 0); - e->vpsrad(ymmA, ymmB, 0); - e->vpsraw(ymmA, ymmB, 0); - e->vpsrld(ymmA, ymmB, 0); - e->vpsrldq(ymmA, ymmB, 0); - e->vpsrlq(ymmA, ymmB, 0); - e->vpsrlw(ymmA, ymmB, 0); - e->vphaddd(ymmA, ymmB, anyptr_gpC); - e->vphaddd(ymmA, ymmB, ymmC); - e->vphaddsw(ymmA, ymmB, anyptr_gpC); - e->vphaddsw(ymmA, ymmB, ymmC); - e->vphaddw(ymmA, ymmB, anyptr_gpC); - e->vphaddw(ymmA, ymmB, ymmC); - e->vphsubd(ymmA, ymmB, anyptr_gpC); - e->vphsubd(ymmA, ymmB, ymmC); - e->vphsubsw(ymmA, ymmB, anyptr_gpC); - e->vphsubsw(ymmA, ymmB, ymmC); - e->vphsubw(ymmA, ymmB, anyptr_gpC); - e->vphsubw(ymmA, ymmB, ymmC); - e->vpmaddubsw(ymmA, ymmB, anyptr_gpC); - e->vpmaddubsw(ymmA, ymmB, ymmC); - e->vpmaddwd(ymmA, ymmB, anyptr_gpC); - e->vpmaddwd(ymmA, ymmB, ymmC); - e->vpmaskmovd(anyptr_gpA, xmmB, xmmC); - e->vpmaskmovd(anyptr_gpA, ymmB, ymmC); - e->vpmaskmovd(xmmA, xmmB, anyptr_gpC); - e->vpmaskmovd(ymmA, ymmB, anyptr_gpC); - e->vpmaskmovq(anyptr_gpA, xmmB, xmmC); - e->vpmaskmovq(anyptr_gpA, ymmB, ymmC); - e->vpmaskmovq(xmmA, xmmB, anyptr_gpC); - e->vpmaskmovq(ymmA, ymmB, anyptr_gpC); - e->vpmaxsb(ymmA, ymmB, anyptr_gpC); - e->vpmaxsb(ymmA, ymmB, ymmC); - e->vpmaxsd(ymmA, ymmB, anyptr_gpC); - e->vpmaxsd(ymmA, ymmB, ymmC); - e->vpmaxsw(ymmA, ymmB, anyptr_gpC); - e->vpmaxsw(ymmA, ymmB, ymmC); - e->vpmaxub(ymmA, ymmB, anyptr_gpC); - e->vpmaxub(ymmA, ymmB, ymmC); - e->vpmaxud(ymmA, ymmB, anyptr_gpC); - e->vpmaxud(ymmA, ymmB, ymmC); - e->vpmaxuw(ymmA, ymmB, anyptr_gpC); - e->vpmaxuw(ymmA, ymmB, ymmC); - e->vpminsb(ymmA, ymmB, anyptr_gpC); - e->vpminsb(ymmA, ymmB, ymmC); - e->vpminsd(ymmA, ymmB, anyptr_gpC); - e->vpminsd(ymmA, ymmB, ymmC); - e->vpminsw(ymmA, ymmB, anyptr_gpC); - e->vpminsw(ymmA, ymmB, ymmC); - e->vpminub(ymmA, ymmB, anyptr_gpC); - e->vpminub(ymmA, ymmB, ymmC); - e->vpminud(ymmA, ymmB, anyptr_gpC); - e->vpminud(ymmA, ymmB, ymmC); - e->vpminuw(ymmA, ymmB, anyptr_gpC); - e->vpminuw(ymmA, ymmB, ymmC); - e->vpmuldq(ymmA, ymmB, anyptr_gpC); - e->vpmuldq(ymmA, ymmB, ymmC); - e->vpmulhrsw(ymmA, ymmB, anyptr_gpC); - e->vpmulhrsw(ymmA, ymmB, ymmC); - e->vpmulhuw(ymmA, ymmB, anyptr_gpC); - e->vpmulhuw(ymmA, ymmB, ymmC); - e->vpmulhw(ymmA, ymmB, anyptr_gpC); - e->vpmulhw(ymmA, ymmB, ymmC); - e->vpmulld(ymmA, ymmB, anyptr_gpC); - e->vpmulld(ymmA, ymmB, ymmC); - e->vpmullw(ymmA, ymmB, anyptr_gpC); - e->vpmullw(ymmA, ymmB, ymmC); - e->vpmuludq(ymmA, ymmB, anyptr_gpC); - e->vpmuludq(ymmA, ymmB, ymmC); - e->vpor(ymmA, ymmB, anyptr_gpC); - e->vpor(ymmA, ymmB, ymmC); - e->vpsadbw(ymmA, ymmB, anyptr_gpC); - e->vpsadbw(ymmA, ymmB, ymmC); - e->vpshufb(ymmA, ymmB, anyptr_gpC); - e->vpshufb(ymmA, ymmB, ymmC); - e->vpsignb(ymmA, ymmB, anyptr_gpC); - e->vpsignb(ymmA, ymmB, ymmC); - e->vpsignd(ymmA, ymmB, anyptr_gpC); - e->vpsignd(ymmA, ymmB, ymmC); - e->vpsignw(ymmA, ymmB, anyptr_gpC); - e->vpsignw(ymmA, ymmB, ymmC); - e->vpslld(ymmA, ymmB, anyptr_gpC); - e->vpslld(ymmA, ymmB, xmmC); - e->vpsllq(ymmA, ymmB, anyptr_gpC); - e->vpsllq(ymmA, ymmB, xmmC); - e->vpsllvd(xmmA, xmmB, anyptr_gpC); - e->vpsllvd(xmmA, xmmB, xmmC); - e->vpsllvd(ymmA, ymmB, anyptr_gpC); - e->vpsllvd(ymmA, ymmB, ymmC); - e->vpsllvq(xmmA, xmmB, anyptr_gpC); - e->vpsllvq(xmmA, xmmB, xmmC); - e->vpsllvq(ymmA, ymmB, anyptr_gpC); - e->vpsllvq(ymmA, ymmB, ymmC); - e->vpsllw(ymmA, ymmB, anyptr_gpC); - e->vpsllw(ymmA, ymmB, xmmC); - e->vpsrad(ymmA, ymmB, anyptr_gpC); - e->vpsrad(ymmA, ymmB, xmmC); - e->vpsravd(xmmA, xmmB, anyptr_gpC); - e->vpsravd(xmmA, xmmB, xmmC); - e->vpsravd(ymmA, ymmB, anyptr_gpC); - e->vpsravd(ymmA, ymmB, ymmC); - e->vpsraw(ymmA, ymmB, anyptr_gpC); - e->vpsraw(ymmA, ymmB, xmmC); - e->vpsrld(ymmA, ymmB, anyptr_gpC); - e->vpsrld(ymmA, ymmB, xmmC); - e->vpsrlq(ymmA, ymmB, anyptr_gpC); - e->vpsrlq(ymmA, ymmB, xmmC); - e->vpsrlvd(xmmA, xmmB, anyptr_gpC); - e->vpsrlvd(xmmA, xmmB, xmmC); - e->vpsrlvd(ymmA, ymmB, anyptr_gpC); - e->vpsrlvd(ymmA, ymmB, ymmC); - e->vpsrlvq(xmmA, xmmB, anyptr_gpC); - e->vpsrlvq(xmmA, xmmB, xmmC); - e->vpsrlvq(ymmA, ymmB, anyptr_gpC); - e->vpsrlvq(ymmA, ymmB, ymmC); - e->vpsrlw(ymmA, ymmB, anyptr_gpC); - e->vpsrlw(ymmA, ymmB, xmmC); - e->vpsubb(ymmA, ymmB, anyptr_gpC); - e->vpsubb(ymmA, ymmB, ymmC); - e->vpsubd(ymmA, ymmB, anyptr_gpC); - e->vpsubd(ymmA, ymmB, ymmC); - e->vpsubq(ymmA, ymmB, anyptr_gpC); - e->vpsubq(ymmA, ymmB, ymmC); - e->vpsubsb(ymmA, ymmB, anyptr_gpC); - e->vpsubsb(ymmA, ymmB, ymmC); - e->vpsubsw(ymmA, ymmB, anyptr_gpC); - e->vpsubsw(ymmA, ymmB, ymmC); - e->vpsubusb(ymmA, ymmB, anyptr_gpC); - e->vpsubusb(ymmA, ymmB, ymmC); - e->vpsubusw(ymmA, ymmB, anyptr_gpC); - e->vpsubusw(ymmA, ymmB, ymmC); - e->vpsubw(ymmA, ymmB, anyptr_gpC); - e->vpsubw(ymmA, ymmB, ymmC); - e->vpunpckhbw(ymmA, ymmB, anyptr_gpC); - e->vpunpckhbw(ymmA, ymmB, ymmC); - e->vpunpckhdq(ymmA, ymmB, anyptr_gpC); - e->vpunpckhdq(ymmA, ymmB, ymmC); - e->vpunpckhqdq(ymmA, ymmB, anyptr_gpC); - e->vpunpckhqdq(ymmA, ymmB, ymmC); - e->vpunpckhwd(ymmA, ymmB, anyptr_gpC); - e->vpunpckhwd(ymmA, ymmB, ymmC); - e->vpunpcklbw(ymmA, ymmB, anyptr_gpC); - e->vpunpcklbw(ymmA, ymmB, ymmC); - e->vpunpckldq(ymmA, ymmB, anyptr_gpC); - e->vpunpckldq(ymmA, ymmB, ymmC); - e->vpunpcklqdq(ymmA, ymmB, anyptr_gpC); - e->vpunpcklqdq(ymmA, ymmB, ymmC); - e->vpunpcklwd(ymmA, ymmB, anyptr_gpC); - e->vpunpcklwd(ymmA, ymmB, ymmC); - e->vpxor(ymmA, ymmB, anyptr_gpC); - e->vpxor(ymmA, ymmB, ymmC); - - // FMA. - e->nop(); - - e->vfmadd132pd(xmmA, xmmB, anyptr_gpC); - e->vfmadd132pd(xmmA, xmmB, xmmC); - e->vfmadd132pd(ymmA, ymmB, anyptr_gpC); - e->vfmadd132pd(ymmA, ymmB, ymmC); - e->vfmadd132ps(xmmA, xmmB, anyptr_gpC); - e->vfmadd132ps(xmmA, xmmB, xmmC); - e->vfmadd132ps(ymmA, ymmB, anyptr_gpC); - e->vfmadd132ps(ymmA, ymmB, ymmC); - e->vfmadd132sd(xmmA, xmmB, anyptr_gpC); - e->vfmadd132sd(xmmA, xmmB, xmmC); - e->vfmadd132ss(xmmA, xmmB, anyptr_gpC); - e->vfmadd132ss(xmmA, xmmB, xmmC); - e->vfmadd213pd(xmmA, xmmB, anyptr_gpC); - e->vfmadd213pd(xmmA, xmmB, xmmC); - e->vfmadd213pd(ymmA, ymmB, anyptr_gpC); - e->vfmadd213pd(ymmA, ymmB, ymmC); - e->vfmadd213ps(xmmA, xmmB, anyptr_gpC); - e->vfmadd213ps(xmmA, xmmB, xmmC); - e->vfmadd213ps(ymmA, ymmB, anyptr_gpC); - e->vfmadd213ps(ymmA, ymmB, ymmC); - e->vfmadd213sd(xmmA, xmmB, anyptr_gpC); - e->vfmadd213sd(xmmA, xmmB, xmmC); - e->vfmadd213ss(xmmA, xmmB, anyptr_gpC); - e->vfmadd213ss(xmmA, xmmB, xmmC); - e->vfmadd231pd(xmmA, xmmB, anyptr_gpC); - e->vfmadd231pd(xmmA, xmmB, xmmC); - e->vfmadd231pd(ymmA, ymmB, anyptr_gpC); - e->vfmadd231pd(ymmA, ymmB, ymmC); - e->vfmadd231ps(xmmA, xmmB, anyptr_gpC); - e->vfmadd231ps(xmmA, xmmB, xmmC); - e->vfmadd231ps(ymmA, ymmB, anyptr_gpC); - e->vfmadd231ps(ymmA, ymmB, ymmC); - e->vfmadd231sd(xmmA, xmmB, anyptr_gpC); - e->vfmadd231sd(xmmA, xmmB, xmmC); - e->vfmadd231ss(xmmA, xmmB, anyptr_gpC); - e->vfmadd231ss(xmmA, xmmB, xmmC); - e->vfmaddsub132pd(xmmA, xmmB, anyptr_gpC); - e->vfmaddsub132pd(xmmA, xmmB, xmmC); - e->vfmaddsub132pd(ymmA, ymmB, anyptr_gpC); - e->vfmaddsub132pd(ymmA, ymmB, ymmC); - e->vfmaddsub132ps(xmmA, xmmB, anyptr_gpC); - e->vfmaddsub132ps(xmmA, xmmB, xmmC); - e->vfmaddsub132ps(ymmA, ymmB, anyptr_gpC); - e->vfmaddsub132ps(ymmA, ymmB, ymmC); - e->vfmaddsub213pd(xmmA, xmmB, anyptr_gpC); - e->vfmaddsub213pd(xmmA, xmmB, xmmC); - e->vfmaddsub213pd(ymmA, ymmB, anyptr_gpC); - e->vfmaddsub213pd(ymmA, ymmB, ymmC); - e->vfmaddsub213ps(xmmA, xmmB, anyptr_gpC); - e->vfmaddsub213ps(xmmA, xmmB, xmmC); - e->vfmaddsub213ps(ymmA, ymmB, anyptr_gpC); - e->vfmaddsub213ps(ymmA, ymmB, ymmC); - e->vfmaddsub231pd(xmmA, xmmB, anyptr_gpC); - e->vfmaddsub231pd(xmmA, xmmB, xmmC); - e->vfmaddsub231pd(ymmA, ymmB, anyptr_gpC); - e->vfmaddsub231pd(ymmA, ymmB, ymmC); - e->vfmaddsub231ps(xmmA, xmmB, anyptr_gpC); - e->vfmaddsub231ps(xmmA, xmmB, xmmC); - e->vfmaddsub231ps(ymmA, ymmB, anyptr_gpC); - e->vfmaddsub231ps(ymmA, ymmB, ymmC); - e->vfmsub132pd(xmmA, xmmB, anyptr_gpC); - e->vfmsub132pd(xmmA, xmmB, xmmC); - e->vfmsub132pd(ymmA, ymmB, anyptr_gpC); - e->vfmsub132pd(ymmA, ymmB, ymmC); - e->vfmsub132ps(xmmA, xmmB, anyptr_gpC); - e->vfmsub132ps(xmmA, xmmB, xmmC); - e->vfmsub132ps(ymmA, ymmB, anyptr_gpC); - e->vfmsub132ps(ymmA, ymmB, ymmC); - e->vfmsub132sd(xmmA, xmmB, anyptr_gpC); - e->vfmsub132sd(xmmA, xmmB, xmmC); - e->vfmsub132ss(xmmA, xmmB, anyptr_gpC); - e->vfmsub132ss(xmmA, xmmB, xmmC); - e->vfmsub213pd(xmmA, xmmB, anyptr_gpC); - e->vfmsub213pd(xmmA, xmmB, xmmC); - e->vfmsub213pd(ymmA, ymmB, anyptr_gpC); - e->vfmsub213pd(ymmA, ymmB, ymmC); - e->vfmsub213ps(xmmA, xmmB, anyptr_gpC); - e->vfmsub213ps(xmmA, xmmB, xmmC); - e->vfmsub213ps(ymmA, ymmB, anyptr_gpC); - e->vfmsub213ps(ymmA, ymmB, ymmC); - e->vfmsub213sd(xmmA, xmmB, anyptr_gpC); - e->vfmsub213sd(xmmA, xmmB, xmmC); - e->vfmsub213ss(xmmA, xmmB, anyptr_gpC); - e->vfmsub213ss(xmmA, xmmB, xmmC); - e->vfmsub231pd(xmmA, xmmB, anyptr_gpC); - e->vfmsub231pd(xmmA, xmmB, xmmC); - e->vfmsub231pd(ymmA, ymmB, anyptr_gpC); - e->vfmsub231pd(ymmA, ymmB, ymmC); - e->vfmsub231ps(xmmA, xmmB, anyptr_gpC); - e->vfmsub231ps(xmmA, xmmB, xmmC); - e->vfmsub231ps(ymmA, ymmB, anyptr_gpC); - e->vfmsub231ps(ymmA, ymmB, ymmC); - e->vfmsub231sd(xmmA, xmmB, anyptr_gpC); - e->vfmsub231sd(xmmA, xmmB, xmmC); - e->vfmsub231ss(xmmA, xmmB, anyptr_gpC); - e->vfmsub231ss(xmmA, xmmB, xmmC); - e->vfmsubadd132pd(xmmA, xmmB, anyptr_gpC); - e->vfmsubadd132pd(xmmA, xmmB, xmmC); - e->vfmsubadd132pd(ymmA, ymmB, anyptr_gpC); - e->vfmsubadd132pd(ymmA, ymmB, ymmC); - e->vfmsubadd132ps(xmmA, xmmB, anyptr_gpC); - e->vfmsubadd132ps(xmmA, xmmB, xmmC); - e->vfmsubadd132ps(ymmA, ymmB, anyptr_gpC); - e->vfmsubadd132ps(ymmA, ymmB, ymmC); - e->vfmsubadd213pd(xmmA, xmmB, anyptr_gpC); - e->vfmsubadd213pd(xmmA, xmmB, xmmC); - e->vfmsubadd213pd(ymmA, ymmB, anyptr_gpC); - e->vfmsubadd213pd(ymmA, ymmB, ymmC); - e->vfmsubadd213ps(xmmA, xmmB, anyptr_gpC); - e->vfmsubadd213ps(xmmA, xmmB, xmmC); - e->vfmsubadd213ps(ymmA, ymmB, anyptr_gpC); - e->vfmsubadd213ps(ymmA, ymmB, ymmC); - e->vfmsubadd231pd(xmmA, xmmB, anyptr_gpC); - e->vfmsubadd231pd(xmmA, xmmB, xmmC); - e->vfmsubadd231pd(ymmA, ymmB, anyptr_gpC); - e->vfmsubadd231pd(ymmA, ymmB, ymmC); - e->vfmsubadd231ps(xmmA, xmmB, anyptr_gpC); - e->vfmsubadd231ps(xmmA, xmmB, xmmC); - e->vfmsubadd231ps(ymmA, ymmB, anyptr_gpC); - e->vfmsubadd231ps(ymmA, ymmB, ymmC); - e->vfnmadd132pd(xmmA, xmmB, anyptr_gpC); - e->vfnmadd132pd(xmmA, xmmB, xmmC); - e->vfnmadd132pd(ymmA, ymmB, anyptr_gpC); - e->vfnmadd132pd(ymmA, ymmB, ymmC); - e->vfnmadd132ps(xmmA, xmmB, anyptr_gpC); - e->vfnmadd132ps(xmmA, xmmB, xmmC); - e->vfnmadd132ps(ymmA, ymmB, anyptr_gpC); - e->vfnmadd132ps(ymmA, ymmB, ymmC); - e->vfnmadd132sd(xmmA, xmmB, anyptr_gpC); - e->vfnmadd132sd(xmmA, xmmB, xmmC); - e->vfnmadd132ss(xmmA, xmmB, anyptr_gpC); - e->vfnmadd132ss(xmmA, xmmB, xmmC); - e->vfnmadd213pd(xmmA, xmmB, anyptr_gpC); - e->vfnmadd213pd(xmmA, xmmB, xmmC); - e->vfnmadd213pd(ymmA, ymmB, anyptr_gpC); - e->vfnmadd213pd(ymmA, ymmB, ymmC); - e->vfnmadd213ps(xmmA, xmmB, anyptr_gpC); - e->vfnmadd213ps(xmmA, xmmB, xmmC); - e->vfnmadd213ps(ymmA, ymmB, anyptr_gpC); - e->vfnmadd213ps(ymmA, ymmB, ymmC); - e->vfnmadd213sd(xmmA, xmmB, anyptr_gpC); - e->vfnmadd213sd(xmmA, xmmB, xmmC); - e->vfnmadd213ss(xmmA, xmmB, anyptr_gpC); - e->vfnmadd213ss(xmmA, xmmB, xmmC); - e->vfnmadd231pd(xmmA, xmmB, anyptr_gpC); - e->vfnmadd231pd(xmmA, xmmB, xmmC); - e->vfnmadd231pd(ymmA, ymmB, anyptr_gpC); - e->vfnmadd231pd(ymmA, ymmB, ymmC); - e->vfnmadd231ps(xmmA, xmmB, anyptr_gpC); - e->vfnmadd231ps(xmmA, xmmB, xmmC); - e->vfnmadd231ps(ymmA, ymmB, anyptr_gpC); - e->vfnmadd231ps(ymmA, ymmB, ymmC); - e->vfnmadd231sd(xmmA, xmmB, anyptr_gpC); - e->vfnmadd231sd(xmmA, xmmB, xmmC); - e->vfnmadd231ss(xmmA, xmmB, anyptr_gpC); - e->vfnmadd231ss(xmmA, xmmB, xmmC); - e->vfnmsub132pd(xmmA, xmmB, anyptr_gpC); - e->vfnmsub132pd(xmmA, xmmB, xmmC); - e->vfnmsub132pd(ymmA, ymmB, anyptr_gpC); - e->vfnmsub132pd(ymmA, ymmB, ymmC); - e->vfnmsub132ps(xmmA, xmmB, anyptr_gpC); - e->vfnmsub132ps(xmmA, xmmB, xmmC); - e->vfnmsub132ps(ymmA, ymmB, anyptr_gpC); - e->vfnmsub132ps(ymmA, ymmB, ymmC); - e->vfnmsub132sd(xmmA, xmmB, anyptr_gpC); - e->vfnmsub132sd(xmmA, xmmB, xmmC); - e->vfnmsub132ss(xmmA, xmmB, anyptr_gpC); - e->vfnmsub132ss(xmmA, xmmB, xmmC); - e->vfnmsub213pd(xmmA, xmmB, anyptr_gpC); - e->vfnmsub213pd(xmmA, xmmB, xmmC); - e->vfnmsub213pd(ymmA, ymmB, anyptr_gpC); - e->vfnmsub213pd(ymmA, ymmB, ymmC); - e->vfnmsub213ps(xmmA, xmmB, anyptr_gpC); - e->vfnmsub213ps(xmmA, xmmB, xmmC); - e->vfnmsub213ps(ymmA, ymmB, anyptr_gpC); - e->vfnmsub213ps(ymmA, ymmB, ymmC); - e->vfnmsub213sd(xmmA, xmmB, anyptr_gpC); - e->vfnmsub213sd(xmmA, xmmB, xmmC); - e->vfnmsub213ss(xmmA, xmmB, anyptr_gpC); - e->vfnmsub213ss(xmmA, xmmB, xmmC); - e->vfnmsub231pd(xmmA, xmmB, anyptr_gpC); - e->vfnmsub231pd(xmmA, xmmB, xmmC); - e->vfnmsub231pd(ymmA, ymmB, anyptr_gpC); - e->vfnmsub231pd(ymmA, ymmB, ymmC); - e->vfnmsub231ps(xmmA, xmmB, anyptr_gpC); - e->vfnmsub231ps(xmmA, xmmB, xmmC); - e->vfnmsub231ps(ymmA, ymmB, anyptr_gpC); - e->vfnmsub231ps(ymmA, ymmB, ymmC); - e->vfnmsub231sd(xmmA, xmmB, anyptr_gpC); - e->vfnmsub231sd(xmmA, xmmB, xmmC); - e->vfnmsub231ss(xmmA, xmmB, anyptr_gpC); - e->vfnmsub231ss(xmmA, xmmB, xmmC); - - // FMA4. - e->nop(); - - e->vfmaddpd(xmmA, xmmB, xmmC, xmmD); - e->vfmaddpd(xmmA, xmmB, anyptr_gpC, xmmD); - e->vfmaddpd(xmmA, xmmB, xmmC, anyptr_gpD); - e->vfmaddpd(ymmA, ymmB, ymmC, ymmD); - e->vfmaddpd(ymmA, ymmB, anyptr_gpC, ymmD); - e->vfmaddpd(ymmA, ymmB, ymmC, anyptr_gpD); - e->vfmaddps(xmmA, xmmB, xmmC, xmmD); - e->vfmaddps(xmmA, xmmB, anyptr_gpC, xmmD); - e->vfmaddps(xmmA, xmmB, xmmC, anyptr_gpD); - e->vfmaddps(ymmA, ymmB, ymmC, ymmD); - e->vfmaddps(ymmA, ymmB, anyptr_gpC, ymmD); - e->vfmaddps(ymmA, ymmB, ymmC, anyptr_gpD); - e->vfmaddsd(xmmA, xmmB, xmmC, xmmD); - e->vfmaddsd(xmmA, xmmB, anyptr_gpC, xmmD); - e->vfmaddsd(xmmA, xmmB, xmmC, anyptr_gpD); - e->vfmaddss(xmmA, xmmB, xmmC, xmmD); - e->vfmaddss(xmmA, xmmB, anyptr_gpC, xmmD); - e->vfmaddss(xmmA, xmmB, xmmC, anyptr_gpD); - e->vfmaddsubpd(xmmA, xmmB, xmmC, xmmD); - e->vfmaddsubpd(xmmA, xmmB, anyptr_gpC, xmmD); - e->vfmaddsubpd(xmmA, xmmB, xmmC, anyptr_gpD); - e->vfmaddsubpd(ymmA, ymmB, ymmC, ymmD); - e->vfmaddsubpd(ymmA, ymmB, anyptr_gpC, ymmD); - e->vfmaddsubpd(ymmA, ymmB, ymmC, anyptr_gpD); - e->vfmaddsubps(xmmA, xmmB, xmmC, xmmD); - e->vfmaddsubps(xmmA, xmmB, anyptr_gpC, xmmD); - e->vfmaddsubps(xmmA, xmmB, xmmC, anyptr_gpD); - e->vfmaddsubps(ymmA, ymmB, ymmC, ymmD); - e->vfmaddsubps(ymmA, ymmB, anyptr_gpC, ymmD); - e->vfmaddsubps(ymmA, ymmB, ymmC, anyptr_gpD); - e->vfmsubaddpd(xmmA, xmmB, xmmC, xmmD); - e->vfmsubaddpd(xmmA, xmmB, anyptr_gpC, xmmD); - e->vfmsubaddpd(xmmA, xmmB, xmmC, anyptr_gpD); - e->vfmsubaddpd(ymmA, ymmB, ymmC, ymmD); - e->vfmsubaddpd(ymmA, ymmB, anyptr_gpC, ymmD); - e->vfmsubaddpd(ymmA, ymmB, ymmC, anyptr_gpD); - e->vfmsubaddps(xmmA, xmmB, xmmC, xmmD); - e->vfmsubaddps(xmmA, xmmB, anyptr_gpC, xmmD); - e->vfmsubaddps(xmmA, xmmB, xmmC, anyptr_gpD); - e->vfmsubaddps(ymmA, ymmB, ymmC, ymmD); - e->vfmsubaddps(ymmA, ymmB, anyptr_gpC, ymmD); - e->vfmsubaddps(ymmA, ymmB, ymmC, anyptr_gpD); - e->vfmsubpd(xmmA, xmmB, xmmC, xmmD); - e->vfmsubpd(xmmA, xmmB, anyptr_gpC, xmmD); - e->vfmsubpd(xmmA, xmmB, xmmC, anyptr_gpD); - e->vfmsubpd(ymmA, ymmB, ymmC, ymmD); - e->vfmsubpd(ymmA, ymmB, anyptr_gpC, ymmD); - e->vfmsubpd(ymmA, ymmB, ymmC, anyptr_gpD); - e->vfmsubps(xmmA, xmmB, xmmC, xmmD); - e->vfmsubps(xmmA, xmmB, anyptr_gpC, xmmD); - e->vfmsubps(xmmA, xmmB, xmmC, anyptr_gpD); - e->vfmsubps(ymmA, ymmB, ymmC, ymmD); - e->vfmsubps(ymmA, ymmB, anyptr_gpC, ymmD); - e->vfmsubps(ymmA, ymmB, ymmC, anyptr_gpD); - e->vfmsubsd(xmmA, xmmB, xmmC, xmmD); - e->vfmsubsd(xmmA, xmmB, anyptr_gpC, xmmD); - e->vfmsubsd(xmmA, xmmB, xmmC, anyptr_gpD); - e->vfmsubss(xmmA, xmmB, xmmC, xmmD); - e->vfmsubss(xmmA, xmmB, anyptr_gpC, xmmD); - e->vfmsubss(xmmA, xmmB, xmmC, anyptr_gpD); - e->vfnmaddpd(xmmA, xmmB, xmmC, xmmD); - e->vfnmaddpd(xmmA, xmmB, anyptr_gpC, xmmD); - e->vfnmaddpd(xmmA, xmmB, xmmC, anyptr_gpD); - e->vfnmaddpd(ymmA, ymmB, ymmC, ymmD); - e->vfnmaddpd(ymmA, ymmB, anyptr_gpC, ymmD); - e->vfnmaddpd(ymmA, ymmB, ymmC, anyptr_gpD); - e->vfnmaddps(xmmA, xmmB, xmmC, xmmD); - e->vfnmaddps(xmmA, xmmB, anyptr_gpC, xmmD); - e->vfnmaddps(xmmA, xmmB, xmmC, anyptr_gpD); - e->vfnmaddps(ymmA, ymmB, ymmC, ymmD); - e->vfnmaddps(ymmA, ymmB, anyptr_gpC, ymmD); - e->vfnmaddps(ymmA, ymmB, ymmC, anyptr_gpD); - e->vfnmaddsd(xmmA, xmmB, xmmC, xmmD); - e->vfnmaddsd(xmmA, xmmB, anyptr_gpC, xmmD); - e->vfnmaddsd(xmmA, xmmB, xmmC, anyptr_gpD); - e->vfnmaddss(xmmA, xmmB, xmmC, xmmD); - e->vfnmaddss(xmmA, xmmB, anyptr_gpC, xmmD); - e->vfnmaddss(xmmA, xmmB, xmmC, anyptr_gpD); - e->vfnmsubpd(xmmA, xmmB, xmmC, xmmD); - e->vfnmsubpd(xmmA, xmmB, anyptr_gpC, xmmD); - e->vfnmsubpd(xmmA, xmmB, xmmC, anyptr_gpD); - e->vfnmsubpd(ymmA, ymmB, ymmC, ymmD); - e->vfnmsubpd(ymmA, ymmB, anyptr_gpC, ymmD); - e->vfnmsubpd(ymmA, ymmB, ymmC, anyptr_gpD); - e->vfnmsubps(xmmA, xmmB, xmmC, xmmD); - e->vfnmsubps(xmmA, xmmB, anyptr_gpC, xmmD); - e->vfnmsubps(xmmA, xmmB, xmmC, anyptr_gpD); - e->vfnmsubps(ymmA, ymmB, ymmC, ymmD); - e->vfnmsubps(ymmA, ymmB, anyptr_gpC, ymmD); - e->vfnmsubps(ymmA, ymmB, ymmC, anyptr_gpD); - e->vfnmsubsd(xmmA, xmmB, xmmC, xmmD); - e->vfnmsubsd(xmmA, xmmB, anyptr_gpC, xmmD); - e->vfnmsubsd(xmmA, xmmB, xmmC, anyptr_gpD); - e->vfnmsubss(xmmA, xmmB, xmmC, xmmD); - e->vfnmsubss(xmmA, xmmB, anyptr_gpC, xmmD); - e->vfnmsubss(xmmA, xmmB, xmmC, anyptr_gpD); - - // XOP. - e->nop(); - - e->vfrczpd(xmmA, xmmB); - e->vfrczpd(xmmA, anyptr_gpB); - e->vfrczpd(ymmA, ymmB); - e->vfrczpd(ymmA, anyptr_gpB); - e->vfrczps(xmmA, xmmB); - e->vfrczps(xmmA, anyptr_gpB); - e->vfrczps(ymmA, ymmB); - e->vfrczps(ymmA, anyptr_gpB); - e->vfrczsd(xmmA, xmmB); - e->vfrczsd(xmmA, anyptr_gpB); - e->vfrczss(xmmA, xmmB); - e->vfrczss(xmmA, anyptr_gpB); - e->vpcmov(xmmA, xmmB, xmmC, xmmD); - e->vpcmov(xmmA, xmmB, anyptr_gpC, xmmD); - e->vpcmov(xmmA, xmmB, xmmC, anyptr_gpD); - e->vpcmov(ymmA, ymmB, ymmC, ymmD); - e->vpcmov(ymmA, ymmB, anyptr_gpC, ymmD); - e->vpcmov(ymmA, ymmB, ymmC, anyptr_gpD); - e->vpcomb(xmmA, xmmB, xmmC, 0); - e->vpcomb(xmmA, xmmB, anyptr_gpC, 0); - e->vpcomd(xmmA, xmmB, xmmC, 0); - e->vpcomd(xmmA, xmmB, anyptr_gpC, 0); - e->vpcomq(xmmA, xmmB, xmmC, 0); - e->vpcomq(xmmA, xmmB, anyptr_gpC, 0); - e->vpcomw(xmmA, xmmB, xmmC, 0); - e->vpcomw(xmmA, xmmB, anyptr_gpC, 0); - e->vpcomub(xmmA, xmmB, xmmC, 0); - e->vpcomub(xmmA, xmmB, anyptr_gpC, 0); - e->vpcomud(xmmA, xmmB, xmmC, 0); - e->vpcomud(xmmA, xmmB, anyptr_gpC, 0); - e->vpcomuq(xmmA, xmmB, xmmC, 0); - e->vpcomuq(xmmA, xmmB, anyptr_gpC, 0); - e->vpcomuw(xmmA, xmmB, xmmC, 0); - e->vpcomuw(xmmA, xmmB, anyptr_gpC, 0); - e->vpermil2pd(xmmA, xmmB, xmmC, xmmD, 0); - e->vpermil2pd(xmmA, xmmB, anyptr_gpC, xmmD, 0); - e->vpermil2pd(xmmA, xmmB, xmmC, anyptr_gpD, 0); - e->vpermil2pd(ymmA, ymmB, ymmC, ymmD, 0); - e->vpermil2pd(ymmA, ymmB, anyptr_gpC, ymmD, 0); - e->vpermil2pd(ymmA, ymmB, ymmC, anyptr_gpD, 0); - e->vpermil2ps(xmmA, xmmB, xmmC, xmmD, 0); - e->vpermil2ps(xmmA, xmmB, anyptr_gpC, xmmD, 0); - e->vpermil2ps(xmmA, xmmB, xmmC, anyptr_gpD, 0); - e->vpermil2ps(ymmA, ymmB, ymmC, ymmD, 0); - e->vpermil2ps(ymmA, ymmB, anyptr_gpC, ymmD, 0); - e->vpermil2ps(ymmA, ymmB, ymmC, anyptr_gpD, 0); - e->vphaddbd(xmmA, xmmB); - e->vphaddbd(xmmA, anyptr_gpB); - e->vphaddbq(xmmA, xmmB); - e->vphaddbq(xmmA, anyptr_gpB); - e->vphaddbw(xmmA, xmmB); - e->vphaddbw(xmmA, anyptr_gpB); - e->vphadddq(xmmA, xmmB); - e->vphadddq(xmmA, anyptr_gpB); - e->vphaddwd(xmmA, xmmB); - e->vphaddwd(xmmA, anyptr_gpB); - e->vphaddwq(xmmA, xmmB); - e->vphaddwq(xmmA, anyptr_gpB); - e->vphaddubd(xmmA, xmmB); - e->vphaddubd(xmmA, anyptr_gpB); - e->vphaddubq(xmmA, xmmB); - e->vphaddubq(xmmA, anyptr_gpB); - e->vphaddubw(xmmA, xmmB); - e->vphaddubw(xmmA, anyptr_gpB); - e->vphaddudq(xmmA, xmmB); - e->vphaddudq(xmmA, anyptr_gpB); - e->vphadduwd(xmmA, xmmB); - e->vphadduwd(xmmA, anyptr_gpB); - e->vphadduwq(xmmA, xmmB); - e->vphadduwq(xmmA, anyptr_gpB); - e->vphsubbw(xmmA, xmmB); - e->vphsubbw(xmmA, anyptr_gpB); - e->vphsubdq(xmmA, xmmB); - e->vphsubdq(xmmA, anyptr_gpB); - e->vphsubwd(xmmA, xmmB); - e->vphsubwd(xmmA, anyptr_gpB); - e->vpmacsdd(xmmA, xmmB, xmmC, xmmD); - e->vpmacsdd(xmmA, xmmB, anyptr_gpC, xmmD); - e->vpmacsdqh(xmmA, xmmB, xmmC, xmmD); - e->vpmacsdqh(xmmA, xmmB, anyptr_gpC, xmmD); - e->vpmacsdql(xmmA, xmmB, xmmC, xmmD); - e->vpmacsdql(xmmA, xmmB, anyptr_gpC, xmmD); - e->vpmacswd(xmmA, xmmB, xmmC, xmmD); - e->vpmacswd(xmmA, xmmB, anyptr_gpC, xmmD); - e->vpmacsww(xmmA, xmmB, xmmC, xmmD); - e->vpmacsww(xmmA, xmmB, anyptr_gpC, xmmD); - e->vpmacssdd(xmmA, xmmB, xmmC, xmmD); - e->vpmacssdd(xmmA, xmmB, anyptr_gpC, xmmD); - e->vpmacssdqh(xmmA, xmmB, xmmC, xmmD); - e->vpmacssdqh(xmmA, xmmB, anyptr_gpC, xmmD); - e->vpmacssdql(xmmA, xmmB, xmmC, xmmD); - e->vpmacssdql(xmmA, xmmB, anyptr_gpC, xmmD); - e->vpmacsswd(xmmA, xmmB, xmmC, xmmD); - e->vpmacsswd(xmmA, xmmB, anyptr_gpC, xmmD); - e->vpmacssww(xmmA, xmmB, xmmC, xmmD); - e->vpmacssww(xmmA, xmmB, anyptr_gpC, xmmD); - e->vpmadcsswd(xmmA, xmmB, xmmC, xmmD); - e->vpmadcsswd(xmmA, xmmB, anyptr_gpC, xmmD); - e->vpmadcswd(xmmA, xmmB, xmmC, xmmD); - e->vpmadcswd(xmmA, xmmB, anyptr_gpC, xmmD); - e->vpperm(xmmA, xmmB, xmmC, xmmD); - e->vpperm(xmmA, xmmB, anyptr_gpC, xmmD); - e->vpperm(xmmA, xmmB, xmmC, anyptr_gpD); - e->vprotb(xmmA, xmmB, xmmC); - e->vprotb(xmmA, anyptr_gpB, xmmC); - e->vprotb(xmmA, xmmB, anyptr_gpC); - e->vprotb(xmmA, xmmB, 0); - e->vprotb(xmmA, anyptr_gpB, 0); - e->vprotd(xmmA, xmmB, xmmC); - e->vprotd(xmmA, anyptr_gpB, xmmC); - e->vprotd(xmmA, xmmB, anyptr_gpC); - e->vprotd(xmmA, xmmB, 0); - e->vprotd(xmmA, anyptr_gpB, 0); - e->vprotq(xmmA, xmmB, xmmC); - e->vprotq(xmmA, anyptr_gpB, xmmC); - e->vprotq(xmmA, xmmB, anyptr_gpC); - e->vprotq(xmmA, xmmB, 0); - e->vprotq(xmmA, anyptr_gpB, 0); - e->vprotw(xmmA, xmmB, xmmC); - e->vprotw(xmmA, anyptr_gpB, xmmC); - e->vprotw(xmmA, xmmB, anyptr_gpC); - e->vprotw(xmmA, xmmB, 0); - e->vprotw(xmmA, anyptr_gpB, 0); - e->vpshab(xmmA, xmmB, xmmC); - e->vpshab(xmmA, anyptr_gpB, xmmC); - e->vpshab(xmmA, xmmB, anyptr_gpC); - e->vpshad(xmmA, xmmB, xmmC); - e->vpshad(xmmA, anyptr_gpB, xmmC); - e->vpshad(xmmA, xmmB, anyptr_gpC); - e->vpshaq(xmmA, xmmB, xmmC); - e->vpshaq(xmmA, anyptr_gpB, xmmC); - e->vpshaq(xmmA, xmmB, anyptr_gpC); - e->vpshaw(xmmA, xmmB, xmmC); - e->vpshaw(xmmA, anyptr_gpB, xmmC); - e->vpshaw(xmmA, xmmB, anyptr_gpC); - e->vpshlb(xmmA, xmmB, xmmC); - e->vpshlb(xmmA, anyptr_gpB, xmmC); - e->vpshlb(xmmA, xmmB, anyptr_gpC); - e->vpshld(xmmA, xmmB, xmmC); - e->vpshld(xmmA, anyptr_gpB, xmmC); - e->vpshld(xmmA, xmmB, anyptr_gpC); - e->vpshlq(xmmA, xmmB, xmmC); - e->vpshlq(xmmA, anyptr_gpB, xmmC); - e->vpshlq(xmmA, xmmB, anyptr_gpC); - e->vpshlw(xmmA, xmmB, xmmC); - e->vpshlw(xmmA, anyptr_gpB, xmmC); - e->vpshlw(xmmA, xmmB, anyptr_gpC); - - // F16C. - e->nop(); - - e->vcvtph2ps(xmmA, xmmB); - e->vcvtph2ps(xmmA, anyptr_gpB); - e->vcvtph2ps(ymmA, xmmB); - e->vcvtph2ps(ymmA, anyptr_gpB); - e->vcvtps2ph(xmmA, xmmB, 0); - e->vcvtps2ph(anyptr_gpA, xmmB, 0); - e->vcvtps2ph(xmmA, ymmB, 0); - e->vcvtps2ph(anyptr_gpA, ymmB, 0); - - // AVX512. - e->nop(); - - e->kaddb(kA, kB, kC); - e->kaddd(kA, kB, kC); - e->kaddq(kA, kB, kC); - e->kaddw(kA, kB, kC); - e->kandb(kA, kB, kC); - e->kandd(kA, kB, kC); - e->kandnb(kA, kB, kC); - e->kandnd(kA, kB, kC); - e->kandnq(kA, kB, kC); - e->kandnw(kA, kB, kC); - e->kandq(kA, kB, kC); - e->kandw(kA, kB, kC); - e->kmovb(kA, kB); - e->kmovb(kA, anyptr_gpB); - e->kmovb(kA, gdB); - if (isX64) e->kmovb(kA, gzB); - e->kmovb(anyptr_gpA, kB); - e->kmovb(gdA, kB); - if (isX64) e->kmovb(gzA, kB); - e->kmovd(kA, kB); - e->kmovd(kA, anyptr_gpB); - e->kmovd(kA, gdB); - if (isX64) e->kmovd(kA, gzB); - e->kmovd(anyptr_gpA, kB); - e->kmovd(gdA, kB); - if (isX64) e->kmovd(gzA, kB); - e->kmovq(kA, kB); - e->kmovq(kA, anyptr_gpB); - if (isX64) e->kmovq(kA, gzB); - e->kmovq(anyptr_gpA, kB); - if (isX64) e->kmovq(gzA, kB); - e->kmovw(kA, kB); - e->kmovw(kA, anyptr_gpB); - e->kmovw(kA, gdB); - if (isX64) e->kmovw(kA, gzB); - e->kmovw(anyptr_gpA, kB); - e->kmovw(gdA, kB); - if (isX64) e->kmovw(gzA, kB); - e->knotb(kA, kB); - e->knotd(kA, kB); - e->knotq(kA, kB); - e->knotw(kA, kB); - e->korb(kA, kB, kC); - e->kord(kA, kB, kC); - e->korq(kA, kB, kC); - e->kortestb(kA, kB); - e->kortestd(kA, kB); - e->kortestq(kA, kB); - e->kortestw(kA, kB); - e->korw(kA, kB, kC); - e->kshiftlb(kA, kB, 0); - e->kshiftld(kA, kB, 0); - e->kshiftlq(kA, kB, 0); - e->kshiftlw(kA, kB, 0); - e->kshiftrb(kA, kB, 0); - e->kshiftrd(kA, kB, 0); - e->kshiftrq(kA, kB, 0); - e->kshiftrw(kA, kB, 0); - e->ktestb(kA, kB); - e->ktestd(kA, kB); - e->ktestq(kA, kB); - e->ktestw(kA, kB); - e->kunpckbw(kA, kB, kC); - e->kunpckdq(kA, kB, kC); - e->kunpckwd(kA, kB, kC); - e->kxnorb(kA, kB, kC); - e->kxnord(kA, kB, kC); - e->kxnorq(kA, kB, kC); - e->kxnorw(kA, kB, kC); - e->kxorb(kA, kB, kC); - e->kxord(kA, kB, kC); - e->kxorq(kA, kB, kC); - e->kxorw(kA, kB, kC); - e->nop(); - - e->vaddpd(xmmA, xmmB, xmmC); - e->vaddpd(xmmA, xmmB, anyptr_gpC); - e->vaddpd(ymmA, ymmB, ymmC); - e->vaddpd(ymmA, ymmB, anyptr_gpC); - e->vaddpd(zmmA, zmmB, zmmC); - e->vaddpd(zmmA, zmmB, anyptr_gpC); - e->vaddps(xmmA, xmmB, xmmC); - e->vaddps(xmmA, xmmB, anyptr_gpC); - e->vaddps(ymmA, ymmB, ymmC); - e->vaddps(ymmA, ymmB, anyptr_gpC); - e->vaddps(zmmA, zmmB, zmmC); - e->vaddps(zmmA, zmmB, anyptr_gpC); - e->vaddsd(xmmA, xmmB, xmmC); - e->vaddsd(xmmA, xmmB, anyptr_gpC); - e->vaddss(xmmA, xmmB, xmmC); - e->vaddss(xmmA, xmmB, anyptr_gpC); - e->valignd(xmmA, xmmB, xmmC, 0); - e->valignd(xmmA, xmmB, anyptr_gpC, 0); - e->valignd(ymmA, ymmB, ymmC, 0); - e->valignd(ymmA, ymmB, anyptr_gpC, 0); - e->valignd(zmmA, zmmB, zmmC, 0); - e->valignd(zmmA, zmmB, anyptr_gpC, 0); - e->valignq(xmmA, xmmB, xmmC, 0); - e->valignq(xmmA, xmmB, anyptr_gpC, 0); - e->valignq(ymmA, ymmB, ymmC, 0); - e->valignq(ymmA, ymmB, anyptr_gpC, 0); - e->valignq(zmmA, zmmB, zmmC, 0); - e->valignq(zmmA, zmmB, anyptr_gpC, 0); - e->vandnpd(xmmA, xmmB, xmmC); - e->vandnpd(xmmA, xmmB, anyptr_gpC); - e->vandnpd(ymmA, ymmB, ymmC); - e->vandnpd(ymmA, ymmB, anyptr_gpC); - e->vandnpd(zmmA, zmmB, zmmC); - e->vandnpd(zmmA, zmmB, anyptr_gpC); - e->vandnps(xmmA, xmmB, xmmC); - e->vandnps(xmmA, xmmB, anyptr_gpC); - e->vandnps(ymmA, ymmB, ymmC); - e->vandnps(ymmA, ymmB, anyptr_gpC); - e->vandnps(zmmA, zmmB, zmmC); - e->vandnps(zmmA, zmmB, anyptr_gpC); - e->vandpd(xmmA, xmmB, xmmC); - e->vandpd(xmmA, xmmB, anyptr_gpC); - e->vandpd(ymmA, ymmB, ymmC); - e->vandpd(ymmA, ymmB, anyptr_gpC); - e->vandpd(zmmA, zmmB, zmmC); - e->vandpd(zmmA, zmmB, anyptr_gpC); - e->vandps(xmmA, xmmB, xmmC); - e->vandps(xmmA, xmmB, anyptr_gpC); - e->vandps(ymmA, ymmB, ymmC); - e->vandps(ymmA, ymmB, anyptr_gpC); - e->vandps(zmmA, zmmB, zmmC); - e->vandps(zmmA, zmmB, anyptr_gpC); - e->vblendmb(xmmA, xmmB, xmmC); - e->vblendmb(xmmA, xmmB, anyptr_gpC); - e->vblendmb(ymmA, ymmB, ymmC); - e->vblendmb(ymmA, ymmB, anyptr_gpC); - e->vblendmb(zmmA, zmmB, zmmC); - e->vblendmb(zmmA, zmmB, anyptr_gpC); - e->vblendmd(xmmA, xmmB, xmmC); - e->vblendmd(xmmA, xmmB, anyptr_gpC); - e->vblendmd(ymmA, ymmB, ymmC); - e->vblendmd(ymmA, ymmB, anyptr_gpC); - e->vblendmd(zmmA, zmmB, zmmC); - e->vblendmd(zmmA, zmmB, anyptr_gpC); - e->vblendmpd(xmmA, xmmB, xmmC); - e->vblendmpd(xmmA, xmmB, anyptr_gpC); - e->vblendmpd(ymmA, ymmB, ymmC); - e->vblendmpd(ymmA, ymmB, anyptr_gpC); - e->vblendmpd(zmmA, zmmB, zmmC); - e->vblendmpd(zmmA, zmmB, anyptr_gpC); - e->vblendmps(xmmA, xmmB, xmmC); - e->vblendmps(xmmA, xmmB, anyptr_gpC); - e->vblendmps(ymmA, ymmB, ymmC); - e->vblendmps(ymmA, ymmB, anyptr_gpC); - e->vblendmps(zmmA, zmmB, zmmC); - e->vblendmps(zmmA, zmmB, anyptr_gpC); - e->vblendmq(xmmA, xmmB, xmmC); - e->vblendmq(xmmA, xmmB, anyptr_gpC); - e->vblendmq(ymmA, ymmB, ymmC); - e->vblendmq(ymmA, ymmB, anyptr_gpC); - e->vblendmq(zmmA, zmmB, zmmC); - e->vblendmq(zmmA, zmmB, anyptr_gpC); - e->vblendmw(xmmA, xmmB, xmmC); - e->vblendmw(xmmA, xmmB, anyptr_gpC); - e->vblendmw(ymmA, ymmB, ymmC); - e->vblendmw(ymmA, ymmB, anyptr_gpC); - e->vblendmw(zmmA, zmmB, zmmC); - e->vblendmw(zmmA, zmmB, anyptr_gpC); - e->vbroadcastf32x2(ymmA, xmmB); - e->vbroadcastf32x2(ymmA, anyptr_gpB); - e->vbroadcastf32x2(zmmA, xmmB); - e->vbroadcastf32x2(zmmA, anyptr_gpB); - e->vbroadcastf32x4(ymmA, anyptr_gpB); - e->vbroadcastf32x4(zmmA, anyptr_gpB); - e->vbroadcastf32x8(zmmA, anyptr_gpB); - e->vbroadcastf64x2(ymmA, anyptr_gpB); - e->vbroadcastf64x2(zmmA, anyptr_gpB); - e->vbroadcastf64x4(zmmA, anyptr_gpB); - e->vbroadcasti32x2(xmmA, xmmB); - e->vbroadcasti32x2(xmmA, anyptr_gpB); - e->vbroadcasti32x2(ymmA, xmmB); - e->vbroadcasti32x2(ymmA, anyptr_gpB); - e->vbroadcasti32x2(zmmA, xmmB); - e->vbroadcasti32x2(zmmA, anyptr_gpB); - e->vbroadcasti32x4(ymmA, anyptr_gpB); - e->vbroadcasti32x4(zmmA, anyptr_gpB); - e->vbroadcasti32x8(zmmA, anyptr_gpB); - e->vbroadcasti64x2(ymmA, anyptr_gpB); - e->vbroadcasti64x2(zmmA, anyptr_gpB); - e->vbroadcasti64x4(zmmA, anyptr_gpB); - e->vbroadcastsd(ymmA, xmmB); - e->vbroadcastsd(ymmA, anyptr_gpB); - e->vbroadcastsd(zmmA, xmmB); - e->vbroadcastsd(zmmA, anyptr_gpB); - e->vbroadcastss(xmmA, xmmB); - e->vbroadcastss(xmmA, anyptr_gpB); - e->vbroadcastss(ymmA, xmmB); - e->vbroadcastss(ymmA, anyptr_gpB); - e->vbroadcastss(zmmA, xmmB); - e->vbroadcastss(zmmA, anyptr_gpB); - e->vcmppd(kA, xmmB, xmmC, 0); - e->vcmppd(kA, xmmB, anyptr_gpC, 0); - e->vcmppd(kA, ymmB, ymmC, 0); - e->vcmppd(kA, ymmB, anyptr_gpC, 0); - e->vcmppd(kA, zmmB, zmmC, 0); - e->vcmppd(kA, zmmB, anyptr_gpC, 0); - e->vcmpps(kA, xmmB, xmmC, 0); - e->vcmpps(kA, xmmB, anyptr_gpC, 0); - e->vcmpps(kA, ymmB, ymmC, 0); - e->vcmpps(kA, ymmB, anyptr_gpC, 0); - e->vcmpps(kA, zmmB, zmmC, 0); - e->vcmpps(kA, zmmB, anyptr_gpC, 0); - e->vcmpsd(kA, xmmB, xmmC, 0); - e->vcmpsd(kA, xmmB, anyptr_gpC, 0); - e->vcmpss(kA, xmmB, xmmC, 0); - e->vcmpss(kA, xmmB, anyptr_gpC, 0); - e->vcomisd(xmmA, xmmB); - e->vcomisd(xmmA, anyptr_gpB); - e->vcomiss(xmmA, xmmB); - e->vcomiss(xmmA, anyptr_gpB); - e->vcompresspd(xmmA, xmmB); - e->vcompresspd(anyptr_gpA, xmmB); - e->vcompresspd(ymmA, ymmB); - e->vcompresspd(anyptr_gpA, ymmB); - e->vcompresspd(zmmA, zmmB); - e->vcompresspd(anyptr_gpA, zmmB); - e->vcompressps(xmmA, xmmB); - e->vcompressps(anyptr_gpA, xmmB); - e->vcompressps(ymmA, ymmB); - e->vcompressps(anyptr_gpA, ymmB); - e->vcompressps(zmmA, zmmB); - e->vcompressps(anyptr_gpA, zmmB); - e->vcvtdq2pd(xmmA, xmmB); - e->vcvtdq2pd(xmmA, anyptr_gpB); - e->vcvtdq2pd(ymmA, xmmB); - e->vcvtdq2pd(ymmA, anyptr_gpB); - e->vcvtdq2pd(zmmA, ymmB); - e->vcvtdq2pd(zmmA, anyptr_gpB); - e->vcvtdq2ps(xmmA, xmmB); - e->vcvtdq2ps(xmmA, anyptr_gpB); - e->vcvtdq2ps(ymmA, ymmB); - e->vcvtdq2ps(ymmA, anyptr_gpB); - e->vcvtdq2ps(zmmA, zmmB); - e->vcvtdq2ps(zmmA, anyptr_gpB); - e->vcvtpd2dq(xmmA, xmmB); - e->vcvtpd2dq(xmmA, anyptr_gpB); - e->vcvtpd2dq(xmmA, ymmB); - e->vcvtpd2dq(xmmA, anyptr_gpB); - e->vcvtpd2dq(ymmA, zmmB); - e->vcvtpd2dq(ymmA, anyptr_gpB); - e->vcvtpd2qq(xmmA, xmmB); - e->vcvtpd2qq(xmmA, anyptr_gpB); - e->vcvtpd2qq(ymmA, ymmB); - e->vcvtpd2qq(ymmA, anyptr_gpB); - e->vcvtpd2qq(zmmA, zmmB); - e->vcvtpd2qq(zmmA, anyptr_gpB); - e->vcvtpd2udq(xmmA, xmmB); - e->vcvtpd2udq(xmmA, anyptr_gpB); - e->vcvtpd2udq(xmmA, ymmB); - e->vcvtpd2udq(xmmA, anyptr_gpB); - e->vcvtpd2udq(ymmA, zmmB); - e->vcvtpd2udq(ymmA, anyptr_gpB); - e->vcvtpd2uqq(xmmA, xmmB); - e->vcvtpd2uqq(xmmA, anyptr_gpB); - e->vcvtpd2uqq(ymmA, ymmB); - e->vcvtpd2uqq(ymmA, anyptr_gpB); - e->vcvtpd2uqq(zmmA, zmmB); - e->vcvtpd2uqq(zmmA, anyptr_gpB); - e->vcvtph2ps(xmmA, xmmB); - e->vcvtph2ps(xmmA, anyptr_gpB); - e->vcvtph2ps(ymmA, xmmB); - e->vcvtph2ps(ymmA, anyptr_gpB); - e->vcvtph2ps(zmmA, ymmB); - e->vcvtph2ps(zmmA, anyptr_gpB); - e->vcvtps2dq(xmmA, xmmB); - e->vcvtps2dq(xmmA, anyptr_gpB); - e->vcvtps2dq(ymmA, ymmB); - e->vcvtps2dq(ymmA, anyptr_gpB); - e->vcvtps2dq(zmmA, zmmB); - e->vcvtps2dq(zmmA, anyptr_gpB); - e->vcvtps2pd(xmmA, xmmB); - e->vcvtps2pd(xmmA, anyptr_gpB); - e->vcvtps2pd(ymmA, xmmB); - e->vcvtps2pd(ymmA, anyptr_gpB); - e->vcvtps2pd(zmmA, ymmB); - e->vcvtps2pd(zmmA, anyptr_gpB); - e->vcvtps2ph(xmmA, xmmB, 0); - e->vcvtps2ph(anyptr_gpA, xmmB, 0); - e->vcvtps2ph(xmmA, ymmB, 0); - e->vcvtps2ph(anyptr_gpA, ymmB, 0); - e->vcvtps2ph(ymmA, zmmB, 0); - e->vcvtps2ph(anyptr_gpA, zmmB, 0); - e->vcvtps2qq(xmmA, xmmB); - e->vcvtps2qq(xmmA, anyptr_gpB); - e->vcvtps2qq(ymmA, xmmB); - e->vcvtps2qq(ymmA, anyptr_gpB); - e->vcvtps2qq(zmmA, ymmB); - e->vcvtps2qq(zmmA, anyptr_gpB); - e->vcvtps2udq(xmmA, xmmB); - e->vcvtps2udq(xmmA, anyptr_gpB); - e->vcvtps2udq(ymmA, ymmB); - e->vcvtps2udq(ymmA, anyptr_gpB); - e->vcvtps2udq(zmmA, zmmB); - e->vcvtps2udq(zmmA, anyptr_gpB); - e->vcvtps2uqq(xmmA, xmmB); - e->vcvtps2uqq(xmmA, anyptr_gpB); - e->vcvtps2uqq(ymmA, xmmB); - e->vcvtps2uqq(ymmA, anyptr_gpB); - e->vcvtps2uqq(zmmA, ymmB); - e->vcvtps2uqq(zmmA, anyptr_gpB); - e->vcvtqq2pd(xmmA, xmmB); - e->vcvtqq2pd(xmmA, anyptr_gpB); - e->vcvtqq2pd(ymmA, ymmB); - e->vcvtqq2pd(ymmA, anyptr_gpB); - e->vcvtqq2pd(zmmA, zmmB); - e->vcvtqq2pd(zmmA, anyptr_gpB); - e->vcvtqq2ps(xmmA, xmmB); - e->vcvtqq2ps(xmmA, anyptr_gpB); - e->vcvtqq2ps(xmmA, ymmB); - e->vcvtqq2ps(xmmA, anyptr_gpB); - e->vcvtqq2ps(ymmA, zmmB); - e->vcvtqq2ps(ymmA, anyptr_gpB); - e->vcvtsd2si(gdA, xmmB); - e->vcvtsd2si(gdA, anyptr_gpB); - if (isX64) e->vcvtsd2si(gzA, xmmB); - if (isX64) e->vcvtsd2si(gzA, anyptr_gpB); - e->vcvtsd2ss(xmmA, xmmB, xmmC); - e->vcvtsd2ss(xmmA, xmmB, anyptr_gpC); - e->vcvtsd2usi(gdA, xmmB); - e->vcvtsd2usi(gdA, anyptr_gpB); - if (isX64) e->vcvtsd2usi(gzA, xmmB); - if (isX64) e->vcvtsd2usi(gzA, anyptr_gpB); - e->vcvtsi2sd(xmmA, xmmB, gdC); - e->vcvtsi2sd(xmmA, xmmB, dword_ptr(gzC)); - if (isX64) e->vcvtsi2sd(xmmA, xmmB, gzC); - if (isX64) e->vcvtsi2sd(xmmA, xmmB, qword_ptr(gzC)); - e->vcvtsi2ss(xmmA, xmmB, gdC); - e->vcvtsi2ss(xmmA, xmmB, dword_ptr(gzC)); - if (isX64) e->vcvtsi2ss(xmmA, xmmB, gzC); - if (isX64) e->vcvtsi2ss(xmmA, xmmB, qword_ptr(gzC)); - e->vcvtss2sd(xmmA, xmmB, xmmC); - e->vcvtss2sd(xmmA, xmmB, anyptr_gpC); - e->vcvtss2si(gdA, xmmB); - e->vcvtss2si(gdA, anyptr_gpB); - if (isX64) e->vcvtss2si(gzA, xmmB); - if (isX64) e->vcvtss2si(gzA, anyptr_gpB); - e->vcvtss2usi(gdA, xmmB); - e->vcvtss2usi(gdA, anyptr_gpB); - if (isX64) e->vcvtss2usi(gzA, xmmB); - if (isX64) e->vcvtss2usi(gzA, anyptr_gpB); - e->vcvttpd2dq(xmmA, xmmB); - e->vcvttpd2dq(xmmA, anyptr_gpB); - e->vcvttpd2dq(xmmA, ymmB); - e->vcvttpd2dq(xmmA, anyptr_gpB); - e->vcvttpd2dq(ymmA, zmmB); - e->vcvttpd2dq(ymmA, anyptr_gpB); - e->vcvttpd2qq(xmmA, xmmB); - e->vcvttpd2qq(xmmA, anyptr_gpB); - e->vcvttpd2qq(ymmA, ymmB); - e->vcvttpd2qq(ymmA, anyptr_gpB); - e->vcvttpd2qq(zmmA, zmmB); - e->vcvttpd2qq(zmmA, anyptr_gpB); - e->vcvttpd2udq(xmmA, xmmB); - e->vcvttpd2udq(xmmA, anyptr_gpB); - e->vcvttpd2udq(xmmA, ymmB); - e->vcvttpd2udq(xmmA, anyptr_gpB); - e->vcvttpd2udq(ymmA, zmmB); - e->vcvttpd2udq(ymmA, anyptr_gpB); - e->vcvttpd2uqq(xmmA, xmmB); - e->vcvttpd2uqq(xmmA, anyptr_gpB); - e->vcvttpd2uqq(ymmA, ymmB); - e->vcvttpd2uqq(ymmA, anyptr_gpB); - e->vcvttpd2uqq(zmmA, zmmB); - e->vcvttpd2uqq(zmmA, anyptr_gpB); - e->vcvttps2dq(xmmA, xmmB); - e->vcvttps2dq(xmmA, anyptr_gpB); - e->vcvttps2dq(ymmA, ymmB); - e->vcvttps2dq(ymmA, anyptr_gpB); - e->vcvttps2dq(zmmA, zmmB); - e->vcvttps2dq(zmmA, anyptr_gpB); - e->vcvttps2qq(xmmA, xmmB); - e->vcvttps2qq(xmmA, anyptr_gpB); - e->vcvttps2qq(ymmA, xmmB); - e->vcvttps2qq(ymmA, anyptr_gpB); - e->vcvttps2qq(zmmA, ymmB); - e->vcvttps2qq(zmmA, anyptr_gpB); - e->vcvttps2udq(xmmA, xmmB); - e->vcvttps2udq(xmmA, anyptr_gpB); - e->vcvttps2udq(ymmA, ymmB); - e->vcvttps2udq(ymmA, anyptr_gpB); - e->vcvttps2udq(zmmA, zmmB); - e->vcvttps2udq(zmmA, anyptr_gpB); - e->vcvttps2uqq(xmmA, xmmB); - e->vcvttps2uqq(xmmA, anyptr_gpB); - e->vcvttps2uqq(ymmA, xmmB); - e->vcvttps2uqq(ymmA, anyptr_gpB); - e->vcvttps2uqq(zmmA, ymmB); - e->vcvttps2uqq(zmmA, anyptr_gpB); - e->vcvttsd2si(gdA, xmmB); - e->vcvttsd2si(gdA, anyptr_gpB); - if (isX64) e->vcvttsd2si(gzA, xmmB); - if (isX64) e->vcvttsd2si(gzA, anyptr_gpB); - e->vcvttsd2usi(gdA, xmmB); - e->vcvttsd2usi(gdA, anyptr_gpB); - if (isX64) e->vcvttsd2usi(gzA, xmmB); - if (isX64) e->vcvttsd2usi(gzA, anyptr_gpB); - e->vcvttss2si(gdA, xmmB); - e->vcvttss2si(gdA, anyptr_gpB); - if (isX64) e->vcvttss2si(gzA, xmmB); - if (isX64) e->vcvttss2si(gzA, anyptr_gpB); - e->vcvttss2usi(gdA, xmmB); - e->vcvttss2usi(gdA, anyptr_gpB); - if (isX64) e->vcvttss2usi(gzA, xmmB); - if (isX64) e->vcvttss2usi(gzA, anyptr_gpB); - e->vcvtudq2pd(xmmA, xmmB); - e->vcvtudq2pd(xmmA, anyptr_gpB); - e->vcvtudq2pd(ymmA, xmmB); - e->vcvtudq2pd(ymmA, anyptr_gpB); - e->vcvtudq2pd(zmmA, ymmB); - e->vcvtudq2pd(zmmA, anyptr_gpB); - e->vcvtudq2ps(xmmA, xmmB); - e->vcvtudq2ps(xmmA, anyptr_gpB); - e->vcvtudq2ps(ymmA, ymmB); - e->vcvtudq2ps(ymmA, anyptr_gpB); - e->vcvtudq2ps(zmmA, zmmB); - e->vcvtudq2ps(zmmA, anyptr_gpB); - e->vcvtuqq2pd(xmmA, xmmB); - e->vcvtuqq2pd(xmmA, anyptr_gpB); - e->vcvtuqq2pd(ymmA, ymmB); - e->vcvtuqq2pd(ymmA, anyptr_gpB); - e->vcvtuqq2pd(zmmA, zmmB); - e->vcvtuqq2pd(zmmA, anyptr_gpB); - e->vcvtuqq2ps(xmmA, xmmB); - e->vcvtuqq2ps(xmmA, anyptr_gpB); - e->vcvtuqq2ps(xmmA, ymmB); - e->vcvtuqq2ps(xmmA, anyptr_gpB); - e->vcvtuqq2ps(ymmA, zmmB); - e->vcvtuqq2ps(ymmA, anyptr_gpB); - e->vcvtusi2sd(xmmA, xmmB, gdC); - e->vcvtusi2sd(xmmA, xmmB, dword_ptr(gzC)); - if (isX64) e->vcvtusi2sd(xmmA, xmmB, gzC); - if (isX64) e->vcvtusi2sd(xmmA, xmmB, qword_ptr(gzC)); - e->vcvtusi2ss(xmmA, xmmB, gdC); - e->vcvtusi2ss(xmmA, xmmB, dword_ptr(gzC)); - if (isX64) e->vcvtusi2ss(xmmA, xmmB, gzC); - if (isX64) e->vcvtusi2ss(xmmA, xmmB, qword_ptr(gzC)); - e->vdbpsadbw(xmmA, xmmB, xmmC, 0); - e->vdbpsadbw(xmmA, xmmB, anyptr_gpC, 0); - e->vdbpsadbw(ymmA, ymmB, ymmC, 0); - e->vdbpsadbw(ymmA, ymmB, anyptr_gpC, 0); - e->vdbpsadbw(zmmA, zmmB, zmmC, 0); - e->vdbpsadbw(zmmA, zmmB, anyptr_gpC, 0); - e->vdivpd(xmmA, xmmB, xmmC); - e->vdivpd(xmmA, xmmB, anyptr_gpC); - e->vdivpd(ymmA, ymmB, ymmC); - e->vdivpd(ymmA, ymmB, anyptr_gpC); - e->vdivpd(zmmA, zmmB, zmmC); - e->vdivpd(zmmA, zmmB, anyptr_gpC); - e->vdivps(xmmA, xmmB, xmmC); - e->vdivps(xmmA, xmmB, anyptr_gpC); - e->vdivps(ymmA, ymmB, ymmC); - e->vdivps(ymmA, ymmB, anyptr_gpC); - e->vdivps(zmmA, zmmB, zmmC); - e->vdivps(zmmA, zmmB, anyptr_gpC); - e->vdivsd(xmmA, xmmB, xmmC); - e->vdivsd(xmmA, xmmB, anyptr_gpC); - e->vdivss(xmmA, xmmB, xmmC); - e->vdivss(xmmA, xmmB, anyptr_gpC); - e->vexp2pd(zmmA, zmmB); - e->vexp2pd(zmmA, anyptr_gpB); - e->vexp2ps(zmmA, zmmB); - e->vexp2ps(zmmA, anyptr_gpB); - e->vexpandpd(xmmA, xmmB); - e->vexpandpd(xmmA, anyptr_gpB); - e->vexpandpd(ymmA, ymmB); - e->vexpandpd(ymmA, anyptr_gpB); - e->vexpandpd(zmmA, zmmB); - e->vexpandpd(zmmA, anyptr_gpB); - e->vexpandps(xmmA, xmmB); - e->vexpandps(xmmA, anyptr_gpB); - e->vexpandps(ymmA, ymmB); - e->vexpandps(ymmA, anyptr_gpB); - e->vexpandps(zmmA, zmmB); - e->vexpandps(zmmA, anyptr_gpB); - e->vextractf32x4(xmmA, ymmB, 0); - e->vextractf32x4(anyptr_gpA, ymmB, 0); - e->vextractf32x4(xmmA, zmmB, 0); - e->vextractf32x4(anyptr_gpA, zmmB, 0); - e->vextractf32x8(ymmA, zmmB, 0); - e->vextractf32x8(anyptr_gpA, zmmB, 0); - e->vextractf64x2(xmmA, ymmB, 0); - e->vextractf64x2(anyptr_gpA, ymmB, 0); - e->vextractf64x2(xmmA, zmmB, 0); - e->vextractf64x2(anyptr_gpA, zmmB, 0); - e->vextractf64x4(ymmA, zmmB, 0); - e->vextractf64x4(anyptr_gpA, zmmB, 0); - e->vextracti32x4(xmmA, ymmB, 0); - e->vextracti32x4(anyptr_gpA, ymmB, 0); - e->vextracti32x4(xmmA, zmmB, 0); - e->vextracti32x4(anyptr_gpA, zmmB, 0); - e->vextracti32x8(ymmA, zmmB, 0); - e->vextracti32x8(anyptr_gpA, zmmB, 0); - e->vextracti64x2(xmmA, ymmB, 0); - e->vextracti64x2(anyptr_gpA, ymmB, 0); - e->vextracti64x2(xmmA, zmmB, 0); - e->vextracti64x2(anyptr_gpA, zmmB, 0); - e->vextracti64x4(ymmA, zmmB, 0); - e->vextracti64x4(anyptr_gpA, zmmB, 0); - e->vextractps(gdA, xmmB, 0); - e->vextractps(gzA, xmmB, 0); - e->vextractps(anyptr_gpA, xmmB, 0); - e->vfixupimmpd(xmmA, xmmB, xmmC, 0); - e->vfixupimmpd(xmmA, xmmB, anyptr_gpC, 0); - e->vfixupimmpd(ymmA, ymmB, ymmC, 0); - e->vfixupimmpd(ymmA, ymmB, anyptr_gpC, 0); - e->vfixupimmpd(zmmA, zmmB, zmmC, 0); - e->vfixupimmpd(zmmA, zmmB, anyptr_gpC, 0); - e->vfixupimmps(xmmA, xmmB, xmmC, 0); - e->vfixupimmps(xmmA, xmmB, anyptr_gpC, 0); - e->vfixupimmps(ymmA, ymmB, ymmC, 0); - e->vfixupimmps(ymmA, ymmB, anyptr_gpC, 0); - e->vfixupimmps(zmmA, zmmB, zmmC, 0); - e->vfixupimmps(zmmA, zmmB, anyptr_gpC, 0); - e->vfixupimmsd(xmmA, xmmB, xmmC, 0); - e->vfixupimmsd(xmmA, xmmB, anyptr_gpC, 0); - e->vfixupimmss(xmmA, xmmB, xmmC, 0); - e->vfixupimmss(xmmA, xmmB, anyptr_gpC, 0); - e->vfmadd132pd(xmmA, xmmB, xmmC); - e->vfmadd132pd(xmmA, xmmB, anyptr_gpC); - e->vfmadd132pd(ymmA, ymmB, ymmC); - e->vfmadd132pd(ymmA, ymmB, anyptr_gpC); - e->vfmadd132pd(zmmA, zmmB, zmmC); - e->vfmadd132pd(zmmA, zmmB, anyptr_gpC); - e->vfmadd132ps(xmmA, xmmB, xmmC); - e->vfmadd132ps(xmmA, xmmB, anyptr_gpC); - e->vfmadd132ps(ymmA, ymmB, ymmC); - e->vfmadd132ps(ymmA, ymmB, anyptr_gpC); - e->vfmadd132ps(zmmA, zmmB, zmmC); - e->vfmadd132ps(zmmA, zmmB, anyptr_gpC); - e->vfmadd132sd(xmmA, xmmB, xmmC); - e->vfmadd132sd(xmmA, xmmB, anyptr_gpC); - e->vfmadd132ss(xmmA, xmmB, xmmC); - e->vfmadd132ss(xmmA, xmmB, anyptr_gpC); - e->vfmadd213pd(xmmA, xmmB, xmmC); - e->vfmadd213pd(xmmA, xmmB, anyptr_gpC); - e->vfmadd213pd(ymmA, ymmB, ymmC); - e->vfmadd213pd(ymmA, ymmB, anyptr_gpC); - e->vfmadd213pd(zmmA, zmmB, zmmC); - e->vfmadd213pd(zmmA, zmmB, anyptr_gpC); - e->vfmadd213ps(xmmA, xmmB, xmmC); - e->vfmadd213ps(xmmA, xmmB, anyptr_gpC); - e->vfmadd213ps(ymmA, ymmB, ymmC); - e->vfmadd213ps(ymmA, ymmB, anyptr_gpC); - e->vfmadd213ps(zmmA, zmmB, zmmC); - e->vfmadd213ps(zmmA, zmmB, anyptr_gpC); - e->vfmadd213sd(xmmA, xmmB, xmmC); - e->vfmadd213sd(xmmA, xmmB, anyptr_gpC); - e->vfmadd213ss(xmmA, xmmB, xmmC); - e->vfmadd213ss(xmmA, xmmB, anyptr_gpC); - e->vfmadd231pd(xmmA, xmmB, xmmC); - e->vfmadd231pd(xmmA, xmmB, anyptr_gpC); - e->vfmadd231pd(ymmA, ymmB, ymmC); - e->vfmadd231pd(ymmA, ymmB, anyptr_gpC); - e->vfmadd231pd(zmmA, zmmB, zmmC); - e->vfmadd231pd(zmmA, zmmB, anyptr_gpC); - e->vfmadd231ps(xmmA, xmmB, xmmC); - e->vfmadd231ps(xmmA, xmmB, anyptr_gpC); - e->vfmadd231ps(ymmA, ymmB, ymmC); - e->vfmadd231ps(ymmA, ymmB, anyptr_gpC); - e->vfmadd231ps(zmmA, zmmB, zmmC); - e->vfmadd231ps(zmmA, zmmB, anyptr_gpC); - e->vfmadd231sd(xmmA, xmmB, xmmC); - e->vfmadd231sd(xmmA, xmmB, anyptr_gpC); - e->vfmadd231ss(xmmA, xmmB, xmmC); - e->vfmadd231ss(xmmA, xmmB, anyptr_gpC); - e->vfmaddsub132pd(xmmA, xmmB, xmmC); - e->vfmaddsub132pd(xmmA, xmmB, anyptr_gpC); - e->vfmaddsub132pd(ymmA, ymmB, ymmC); - e->vfmaddsub132pd(ymmA, ymmB, anyptr_gpC); - e->vfmaddsub132pd(zmmA, zmmB, zmmC); - e->vfmaddsub132pd(zmmA, zmmB, anyptr_gpC); - e->vfmaddsub132ps(xmmA, xmmB, xmmC); - e->vfmaddsub132ps(xmmA, xmmB, anyptr_gpC); - e->vfmaddsub132ps(ymmA, ymmB, ymmC); - e->vfmaddsub132ps(ymmA, ymmB, anyptr_gpC); - e->vfmaddsub132ps(zmmA, zmmB, zmmC); - e->vfmaddsub132ps(zmmA, zmmB, anyptr_gpC); - e->vfmaddsub213pd(xmmA, xmmB, xmmC); - e->vfmaddsub213pd(xmmA, xmmB, anyptr_gpC); - e->vfmaddsub213pd(ymmA, ymmB, ymmC); - e->vfmaddsub213pd(ymmA, ymmB, anyptr_gpC); - e->vfmaddsub213pd(zmmA, zmmB, zmmC); - e->vfmaddsub213pd(zmmA, zmmB, anyptr_gpC); - e->vfmaddsub213ps(xmmA, xmmB, xmmC); - e->vfmaddsub213ps(xmmA, xmmB, anyptr_gpC); - e->vfmaddsub213ps(ymmA, ymmB, ymmC); - e->vfmaddsub213ps(ymmA, ymmB, anyptr_gpC); - e->vfmaddsub213ps(zmmA, zmmB, zmmC); - e->vfmaddsub213ps(zmmA, zmmB, anyptr_gpC); - e->vfmaddsub231pd(xmmA, xmmB, xmmC); - e->vfmaddsub231pd(xmmA, xmmB, anyptr_gpC); - e->vfmaddsub231pd(ymmA, ymmB, ymmC); - e->vfmaddsub231pd(ymmA, ymmB, anyptr_gpC); - e->vfmaddsub231pd(zmmA, zmmB, zmmC); - e->vfmaddsub231pd(zmmA, zmmB, anyptr_gpC); - e->vfmaddsub231ps(xmmA, xmmB, xmmC); - e->vfmaddsub231ps(xmmA, xmmB, anyptr_gpC); - e->vfmaddsub231ps(ymmA, ymmB, ymmC); - e->vfmaddsub231ps(ymmA, ymmB, anyptr_gpC); - e->vfmaddsub231ps(zmmA, zmmB, zmmC); - e->vfmaddsub231ps(zmmA, zmmB, anyptr_gpC); - e->vfmsub132pd(xmmA, xmmB, xmmC); - e->vfmsub132pd(xmmA, xmmB, anyptr_gpC); - e->vfmsub132pd(ymmA, ymmB, ymmC); - e->vfmsub132pd(ymmA, ymmB, anyptr_gpC); - e->vfmsub132pd(zmmA, zmmB, zmmC); - e->vfmsub132pd(zmmA, zmmB, anyptr_gpC); - e->vfmsub132ps(xmmA, xmmB, xmmC); - e->vfmsub132ps(xmmA, xmmB, anyptr_gpC); - e->vfmsub132ps(ymmA, ymmB, ymmC); - e->vfmsub132ps(ymmA, ymmB, anyptr_gpC); - e->vfmsub132ps(zmmA, zmmB, zmmC); - e->vfmsub132ps(zmmA, zmmB, anyptr_gpC); - e->vfmsub132sd(xmmA, xmmB, xmmC); - e->vfmsub132sd(xmmA, xmmB, anyptr_gpC); - e->vfmsub132ss(xmmA, xmmB, xmmC); - e->vfmsub132ss(xmmA, xmmB, anyptr_gpC); - e->vfmsub213pd(xmmA, xmmB, xmmC); - e->vfmsub213pd(xmmA, xmmB, anyptr_gpC); - e->vfmsub213pd(ymmA, ymmB, ymmC); - e->vfmsub213pd(ymmA, ymmB, anyptr_gpC); - e->vfmsub213pd(zmmA, zmmB, zmmC); - e->vfmsub213pd(zmmA, zmmB, anyptr_gpC); - e->vfmsub213ps(xmmA, xmmB, xmmC); - e->vfmsub213ps(xmmA, xmmB, anyptr_gpC); - e->vfmsub213ps(ymmA, ymmB, ymmC); - e->vfmsub213ps(ymmA, ymmB, anyptr_gpC); - e->vfmsub213ps(zmmA, zmmB, zmmC); - e->vfmsub213ps(zmmA, zmmB, anyptr_gpC); - e->vfmsub213sd(xmmA, xmmB, xmmC); - e->vfmsub213sd(xmmA, xmmB, anyptr_gpC); - e->vfmsub213ss(xmmA, xmmB, xmmC); - e->vfmsub213ss(xmmA, xmmB, anyptr_gpC); - e->vfmsub231pd(xmmA, xmmB, xmmC); - e->vfmsub231pd(xmmA, xmmB, anyptr_gpC); - e->vfmsub231pd(ymmA, ymmB, ymmC); - e->vfmsub231pd(ymmA, ymmB, anyptr_gpC); - e->vfmsub231pd(zmmA, zmmB, zmmC); - e->vfmsub231pd(zmmA, zmmB, anyptr_gpC); - e->vfmsub231ps(xmmA, xmmB, xmmC); - e->vfmsub231ps(xmmA, xmmB, anyptr_gpC); - e->vfmsub231ps(ymmA, ymmB, ymmC); - e->vfmsub231ps(ymmA, ymmB, anyptr_gpC); - e->vfmsub231ps(zmmA, zmmB, zmmC); - e->vfmsub231ps(zmmA, zmmB, anyptr_gpC); - e->vfmsub231sd(xmmA, xmmB, xmmC); - e->vfmsub231sd(xmmA, xmmB, anyptr_gpC); - e->vfmsub231ss(xmmA, xmmB, xmmC); - e->vfmsub231ss(xmmA, xmmB, anyptr_gpC); - e->vfmsubadd132pd(xmmA, xmmB, xmmC); - e->vfmsubadd132pd(xmmA, xmmB, anyptr_gpC); - e->vfmsubadd132pd(ymmA, ymmB, ymmC); - e->vfmsubadd132pd(ymmA, ymmB, anyptr_gpC); - e->vfmsubadd132pd(zmmA, zmmB, zmmC); - e->vfmsubadd132pd(zmmA, zmmB, anyptr_gpC); - e->vfmsubadd132ps(xmmA, xmmB, xmmC); - e->vfmsubadd132ps(xmmA, xmmB, anyptr_gpC); - e->vfmsubadd132ps(ymmA, ymmB, ymmC); - e->vfmsubadd132ps(ymmA, ymmB, anyptr_gpC); - e->vfmsubadd132ps(zmmA, zmmB, zmmC); - e->vfmsubadd132ps(zmmA, zmmB, anyptr_gpC); - e->vfmsubadd213pd(xmmA, xmmB, xmmC); - e->vfmsubadd213pd(xmmA, xmmB, anyptr_gpC); - e->vfmsubadd213pd(ymmA, ymmB, ymmC); - e->vfmsubadd213pd(ymmA, ymmB, anyptr_gpC); - e->vfmsubadd213pd(zmmA, zmmB, zmmC); - e->vfmsubadd213pd(zmmA, zmmB, anyptr_gpC); - e->vfmsubadd213ps(xmmA, xmmB, xmmC); - e->vfmsubadd213ps(xmmA, xmmB, anyptr_gpC); - e->vfmsubadd213ps(ymmA, ymmB, ymmC); - e->vfmsubadd213ps(ymmA, ymmB, anyptr_gpC); - e->vfmsubadd213ps(zmmA, zmmB, zmmC); - e->vfmsubadd213ps(zmmA, zmmB, anyptr_gpC); - e->vfmsubadd231pd(xmmA, xmmB, xmmC); - e->vfmsubadd231pd(xmmA, xmmB, anyptr_gpC); - e->vfmsubadd231pd(ymmA, ymmB, ymmC); - e->vfmsubadd231pd(ymmA, ymmB, anyptr_gpC); - e->vfmsubadd231pd(zmmA, zmmB, zmmC); - e->vfmsubadd231pd(zmmA, zmmB, anyptr_gpC); - e->vfmsubadd231ps(xmmA, xmmB, xmmC); - e->vfmsubadd231ps(xmmA, xmmB, anyptr_gpC); - e->vfmsubadd231ps(ymmA, ymmB, ymmC); - e->vfmsubadd231ps(ymmA, ymmB, anyptr_gpC); - e->vfmsubadd231ps(zmmA, zmmB, zmmC); - e->vfmsubadd231ps(zmmA, zmmB, anyptr_gpC); - e->vfnmadd132pd(xmmA, xmmB, xmmC); - e->vfnmadd132pd(xmmA, xmmB, anyptr_gpC); - e->vfnmadd132pd(ymmA, ymmB, ymmC); - e->vfnmadd132pd(ymmA, ymmB, anyptr_gpC); - e->vfnmadd132pd(zmmA, zmmB, zmmC); - e->vfnmadd132pd(zmmA, zmmB, anyptr_gpC); - e->vfnmadd132ps(xmmA, xmmB, xmmC); - e->vfnmadd132ps(xmmA, xmmB, anyptr_gpC); - e->vfnmadd132ps(ymmA, ymmB, ymmC); - e->vfnmadd132ps(ymmA, ymmB, anyptr_gpC); - e->vfnmadd132ps(zmmA, zmmB, zmmC); - e->vfnmadd132ps(zmmA, zmmB, anyptr_gpC); - e->vfnmadd132sd(xmmA, xmmB, xmmC); - e->vfnmadd132sd(xmmA, xmmB, anyptr_gpC); - e->vfnmadd132ss(xmmA, xmmB, xmmC); - e->vfnmadd132ss(xmmA, xmmB, anyptr_gpC); - e->vfnmadd213pd(xmmA, xmmB, xmmC); - e->vfnmadd213pd(xmmA, xmmB, anyptr_gpC); - e->vfnmadd213pd(ymmA, ymmB, ymmC); - e->vfnmadd213pd(ymmA, ymmB, anyptr_gpC); - e->vfnmadd213pd(zmmA, zmmB, zmmC); - e->vfnmadd213pd(zmmA, zmmB, anyptr_gpC); - e->vfnmadd213ps(xmmA, xmmB, xmmC); - e->vfnmadd213ps(xmmA, xmmB, anyptr_gpC); - e->vfnmadd213ps(ymmA, ymmB, ymmC); - e->vfnmadd213ps(ymmA, ymmB, anyptr_gpC); - e->vfnmadd213ps(zmmA, zmmB, zmmC); - e->vfnmadd213ps(zmmA, zmmB, anyptr_gpC); - e->vfnmadd213sd(xmmA, xmmB, xmmC); - e->vfnmadd213sd(xmmA, xmmB, anyptr_gpC); - e->vfnmadd213ss(xmmA, xmmB, xmmC); - e->vfnmadd213ss(xmmA, xmmB, anyptr_gpC); - e->vfnmadd231pd(xmmA, xmmB, xmmC); - e->vfnmadd231pd(xmmA, xmmB, anyptr_gpC); - e->vfnmadd231pd(ymmA, ymmB, ymmC); - e->vfnmadd231pd(ymmA, ymmB, anyptr_gpC); - e->vfnmadd231pd(zmmA, zmmB, zmmC); - e->vfnmadd231pd(zmmA, zmmB, anyptr_gpC); - e->vfnmadd231ps(xmmA, xmmB, xmmC); - e->vfnmadd231ps(xmmA, xmmB, anyptr_gpC); - e->vfnmadd231ps(ymmA, ymmB, ymmC); - e->vfnmadd231ps(ymmA, ymmB, anyptr_gpC); - e->vfnmadd231ps(zmmA, zmmB, zmmC); - e->vfnmadd231ps(zmmA, zmmB, anyptr_gpC); - e->vfnmadd231sd(xmmA, xmmB, xmmC); - e->vfnmadd231sd(xmmA, xmmB, anyptr_gpC); - e->vfnmadd231ss(xmmA, xmmB, xmmC); - e->vfnmadd231ss(xmmA, xmmB, anyptr_gpC); - e->vfnmsub132pd(xmmA, xmmB, xmmC); - e->vfnmsub132pd(xmmA, xmmB, anyptr_gpC); - e->vfnmsub132pd(ymmA, ymmB, ymmC); - e->vfnmsub132pd(ymmA, ymmB, anyptr_gpC); - e->vfnmsub132pd(zmmA, zmmB, zmmC); - e->vfnmsub132pd(zmmA, zmmB, anyptr_gpC); - e->vfnmsub132ps(xmmA, xmmB, xmmC); - e->vfnmsub132ps(xmmA, xmmB, anyptr_gpC); - e->vfnmsub132ps(ymmA, ymmB, ymmC); - e->vfnmsub132ps(ymmA, ymmB, anyptr_gpC); - e->vfnmsub132ps(zmmA, zmmB, zmmC); - e->vfnmsub132ps(zmmA, zmmB, anyptr_gpC); - e->vfnmsub132sd(xmmA, xmmB, xmmC); - e->vfnmsub132sd(xmmA, xmmB, anyptr_gpC); - e->vfnmsub132ss(xmmA, xmmB, xmmC); - e->vfnmsub132ss(xmmA, xmmB, anyptr_gpC); - e->vfnmsub213pd(xmmA, xmmB, xmmC); - e->vfnmsub213pd(xmmA, xmmB, anyptr_gpC); - e->vfnmsub213pd(ymmA, ymmB, ymmC); - e->vfnmsub213pd(ymmA, ymmB, anyptr_gpC); - e->vfnmsub213pd(zmmA, zmmB, zmmC); - e->vfnmsub213pd(zmmA, zmmB, anyptr_gpC); - e->vfnmsub213ps(xmmA, xmmB, xmmC); - e->vfnmsub213ps(xmmA, xmmB, anyptr_gpC); - e->vfnmsub213ps(ymmA, ymmB, ymmC); - e->vfnmsub213ps(ymmA, ymmB, anyptr_gpC); - e->vfnmsub213ps(zmmA, zmmB, zmmC); - e->vfnmsub213ps(zmmA, zmmB, anyptr_gpC); - e->vfnmsub213sd(xmmA, xmmB, xmmC); - e->vfnmsub213sd(xmmA, xmmB, anyptr_gpC); - e->vfnmsub213ss(xmmA, xmmB, xmmC); - e->vfnmsub213ss(xmmA, xmmB, anyptr_gpC); - e->vfnmsub231pd(xmmA, xmmB, xmmC); - e->vfnmsub231pd(xmmA, xmmB, anyptr_gpC); - e->vfnmsub231pd(ymmA, ymmB, ymmC); - e->vfnmsub231pd(ymmA, ymmB, anyptr_gpC); - e->vfnmsub231pd(zmmA, zmmB, zmmC); - e->vfnmsub231pd(zmmA, zmmB, anyptr_gpC); - e->vfnmsub231ps(xmmA, xmmB, xmmC); - e->vfnmsub231ps(xmmA, xmmB, anyptr_gpC); - e->vfnmsub231ps(ymmA, ymmB, ymmC); - e->vfnmsub231ps(ymmA, ymmB, anyptr_gpC); - e->vfnmsub231ps(zmmA, zmmB, zmmC); - e->vfnmsub231ps(zmmA, zmmB, anyptr_gpC); - e->vfnmsub231sd(xmmA, xmmB, xmmC); - e->vfnmsub231sd(xmmA, xmmB, anyptr_gpC); - e->vfnmsub231ss(xmmA, xmmB, xmmC); - e->vfnmsub231ss(xmmA, xmmB, anyptr_gpC); - e->vfpclasspd(kA, xmmB, 0); - e->vfpclasspd(kA, anyptr_gpB, 0); - e->vfpclasspd(kA, ymmB, 0); - e->vfpclasspd(kA, anyptr_gpB, 0); - e->vfpclasspd(kA, zmmB, 0); - e->vfpclasspd(kA, anyptr_gpB, 0); - e->vfpclassps(kA, xmmB, 0); - e->vfpclassps(kA, anyptr_gpB, 0); - e->vfpclassps(kA, ymmB, 0); - e->vfpclassps(kA, anyptr_gpB, 0); - e->vfpclassps(kA, zmmB, 0); - e->vfpclassps(kA, anyptr_gpB, 0); - e->vfpclasssd(kA, xmmB, 0); - e->vfpclasssd(kA, anyptr_gpB, 0); - e->vfpclassss(kA, xmmB, 0); - e->vfpclassss(kA, anyptr_gpB, 0); - e->vgatherdpd(xmmA, vx_ptr); - e->vgatherdpd(ymmA, vy_ptr); - e->vgatherdpd(zmmA, vz_ptr); - e->vgatherdps(xmmA, vx_ptr); - e->vgatherdps(ymmA, vy_ptr); - e->vgatherdps(zmmA, vz_ptr); - e->vgatherpf0dpd(vy_ptr); - e->vgatherpf0dps(vz_ptr); - e->vgatherpf0qpd(vz_ptr); - e->vgatherpf0qps(vz_ptr); - e->vgatherpf1dpd(vy_ptr); - e->vgatherpf1dps(vz_ptr); - e->vgatherpf1qpd(vz_ptr); - e->vgatherpf1qps(vz_ptr); - e->vgatherqpd(xmmA, vx_ptr); - e->vgatherqpd(ymmA, vy_ptr); - e->vgatherqpd(zmmA, vz_ptr); - e->vgatherqps(xmmA, vx_ptr); - e->vgatherqps(ymmA, vy_ptr); - e->vgatherqps(zmmA, vz_ptr); - e->vgetexppd(xmmA, xmmB); - e->vgetexppd(xmmA, anyptr_gpB); - e->vgetexppd(ymmA, ymmB); - e->vgetexppd(ymmA, anyptr_gpB); - e->vgetexppd(zmmA, zmmB); - e->vgetexppd(zmmA, anyptr_gpB); - e->vgetexpps(xmmA, xmmB); - e->vgetexpps(xmmA, anyptr_gpB); - e->vgetexpps(ymmA, ymmB); - e->vgetexpps(ymmA, anyptr_gpB); - e->vgetexpps(zmmA, zmmB); - e->vgetexpps(zmmA, anyptr_gpB); - e->vgetexpsd(xmmA, xmmB, xmmC); - e->vgetexpsd(xmmA, xmmB, anyptr_gpB); - e->vgetexpss(xmmA, xmmB, xmmC); - e->vgetexpss(xmmA, xmmB, anyptr_gpB); - e->vgetmantpd(xmmA, xmmB, 0); - e->vgetmantpd(xmmA, anyptr_gpB, 0); - e->vgetmantpd(ymmA, ymmB, 0); - e->vgetmantpd(ymmA, anyptr_gpB, 0); - e->vgetmantpd(zmmA, zmmB, 0); - e->vgetmantpd(zmmA, anyptr_gpB, 0); - e->vgetmantps(xmmA, xmmB, 0); - e->vgetmantps(xmmA, anyptr_gpB, 0); - e->vgetmantps(ymmA, ymmB, 0); - e->vgetmantps(ymmA, anyptr_gpB, 0); - e->vgetmantps(zmmA, zmmB, 0); - e->vgetmantps(zmmA, anyptr_gpB, 0); - e->vgetmantsd(xmmA, xmmB, xmmC, 0); - e->vgetmantsd(xmmA, xmmB, anyptr_gpB, 0); - e->vgetmantss(xmmA, xmmB, xmmC, 0); - e->vgetmantss(xmmA, xmmB, anyptr_gpB, 0); - e->vinsertf32x4(ymmA, ymmB, xmmC, 0); - e->vinsertf32x4(ymmA, ymmB, anyptr_gpC, 0); - e->vinsertf32x4(zmmA, zmmB, xmmC, 0); - e->vinsertf32x4(zmmA, zmmB, anyptr_gpC, 0); - e->vinsertf32x8(zmmA, zmmB, ymmC, 0); - e->vinsertf32x8(zmmA, zmmB, anyptr_gpC, 0); - e->vinsertf64x2(ymmA, ymmB, xmmC, 0); - e->vinsertf64x2(ymmA, ymmB, anyptr_gpC, 0); - e->vinsertf64x2(zmmA, zmmB, xmmC, 0); - e->vinsertf64x2(zmmA, zmmB, anyptr_gpC, 0); - e->vinsertf64x4(zmmA, zmmB, ymmC, 0); - e->vinsertf64x4(zmmA, zmmB, anyptr_gpC, 0); - e->vinserti32x4(ymmA, ymmB, xmmC, 0); - e->vinserti32x4(ymmA, ymmB, anyptr_gpC, 0); - e->vinserti32x4(zmmA, zmmB, xmmC, 0); - e->vinserti32x4(zmmA, zmmB, anyptr_gpC, 0); - e->vinserti32x8(zmmA, zmmB, ymmC, 0); - e->vinserti32x8(zmmA, zmmB, anyptr_gpC, 0); - e->vinserti64x2(ymmA, ymmB, xmmC, 0); - e->vinserti64x2(ymmA, ymmB, anyptr_gpC, 0); - e->vinserti64x2(zmmA, zmmB, xmmC, 0); - e->vinserti64x2(zmmA, zmmB, anyptr_gpC, 0); - e->vinserti64x4(zmmA, zmmB, ymmC, 0); - e->vinserti64x4(zmmA, zmmB, anyptr_gpC, 0); - e->vinsertps(xmmA, xmmB, xmmC, 0); - e->vinsertps(xmmA, xmmB, anyptr_gpC, 0); - e->vmaxpd(xmmA, xmmB, xmmC); - e->vmaxpd(xmmA, xmmB, anyptr_gpC); - e->vmaxpd(ymmA, ymmB, ymmC); - e->vmaxpd(ymmA, ymmB, anyptr_gpC); - e->vmaxpd(zmmA, zmmB, zmmC); - e->vmaxpd(zmmA, zmmB, anyptr_gpC); - e->vmaxps(xmmA, xmmB, xmmC); - e->vmaxps(xmmA, xmmB, anyptr_gpC); - e->vmaxps(ymmA, ymmB, ymmC); - e->vmaxps(ymmA, ymmB, anyptr_gpC); - e->vmaxps(zmmA, zmmB, zmmC); - e->vmaxps(zmmA, zmmB, anyptr_gpC); - e->vmaxsd(xmmA, xmmB, xmmC); - e->vmaxsd(xmmA, xmmB, anyptr_gpC); - e->vmaxss(xmmA, xmmB, xmmC); - e->vmaxss(xmmA, xmmB, anyptr_gpC); - e->vminpd(xmmA, xmmB, xmmC); - e->vminpd(xmmA, xmmB, anyptr_gpC); - e->vminpd(ymmA, ymmB, ymmC); - e->vminpd(ymmA, ymmB, anyptr_gpC); - e->vminpd(zmmA, zmmB, zmmC); - e->vminpd(zmmA, zmmB, anyptr_gpC); - e->vminps(xmmA, xmmB, xmmC); - e->vminps(xmmA, xmmB, anyptr_gpC); - e->vminps(ymmA, ymmB, ymmC); - e->vminps(ymmA, ymmB, anyptr_gpC); - e->vminps(zmmA, zmmB, zmmC); - e->vminps(zmmA, zmmB, anyptr_gpC); - e->vminsd(xmmA, xmmB, xmmC); - e->vminsd(xmmA, xmmB, anyptr_gpC); - e->vminss(xmmA, xmmB, xmmC); - e->vminss(xmmA, xmmB, anyptr_gpC); - e->vmovapd(xmmA, xmmB); - e->vmovapd(xmmA, anyptr_gpB); - e->vmovapd(xmmA, xmmB); - e->vmovapd(anyptr_gpA, xmmB); - e->vmovapd(ymmA, ymmB); - e->vmovapd(ymmA, anyptr_gpB); - e->vmovapd(ymmA, ymmB); - e->vmovapd(anyptr_gpA, ymmB); - e->vmovapd(zmmA, zmmB); - e->vmovapd(zmmA, anyptr_gpB); - e->vmovapd(zmmA, zmmB); - e->vmovapd(anyptr_gpA, zmmB); - e->vmovaps(xmmA, xmmB); - e->vmovaps(xmmA, anyptr_gpB); - e->vmovaps(xmmA, xmmB); - e->vmovaps(anyptr_gpA, xmmB); - e->vmovaps(ymmA, ymmB); - e->vmovaps(ymmA, anyptr_gpB); - e->vmovaps(ymmA, ymmB); - e->vmovaps(anyptr_gpA, ymmB); - e->vmovaps(zmmA, zmmB); - e->vmovaps(zmmA, anyptr_gpB); - e->vmovaps(zmmA, zmmB); - e->vmovaps(anyptr_gpA, zmmB); - e->vmovd(gdA, xmmB); - e->vmovd(gzA, xmmB); - e->vmovd(anyptr_gpA, xmmB); - e->vmovd(xmmA, gdB); - e->vmovd(xmmA, gzB); - e->vmovd(xmmA, anyptr_gpB); - e->vmovddup(xmmA, xmmB); - e->vmovddup(xmmA, anyptr_gpB); - e->vmovddup(ymmA, ymmB); - e->vmovddup(ymmA, anyptr_gpB); - e->vmovddup(zmmA, zmmB); - e->vmovddup(zmmA, anyptr_gpB); - e->vmovdqa32(xmmA, xmmB); - e->vmovdqa32(xmmA, anyptr_gpB); - e->vmovdqa32(xmmA, xmmB); - e->vmovdqa32(anyptr_gpA, xmmB); - e->vmovdqa32(ymmA, ymmB); - e->vmovdqa32(ymmA, anyptr_gpB); - e->vmovdqa32(ymmA, ymmB); - e->vmovdqa32(anyptr_gpA, ymmB); - e->vmovdqa32(zmmA, zmmB); - e->vmovdqa32(zmmA, anyptr_gpB); - e->vmovdqa32(zmmA, zmmB); - e->vmovdqa32(anyptr_gpA, zmmB); - e->vmovdqa64(xmmA, xmmB); - e->vmovdqa64(xmmA, anyptr_gpB); - e->vmovdqa64(xmmA, xmmB); - e->vmovdqa64(anyptr_gpA, xmmB); - e->vmovdqa64(ymmA, ymmB); - e->vmovdqa64(ymmA, anyptr_gpB); - e->vmovdqa64(ymmA, ymmB); - e->vmovdqa64(anyptr_gpA, ymmB); - e->vmovdqa64(zmmA, zmmB); - e->vmovdqa64(zmmA, anyptr_gpB); - e->vmovdqa64(zmmA, zmmB); - e->vmovdqa64(anyptr_gpA, zmmB); - e->vmovdqu16(xmmA, xmmB); - e->vmovdqu16(xmmA, anyptr_gpB); - e->vmovdqu16(xmmA, xmmB); - e->vmovdqu16(anyptr_gpA, xmmB); - e->vmovdqu16(ymmA, ymmB); - e->vmovdqu16(ymmA, anyptr_gpB); - e->vmovdqu16(ymmA, ymmB); - e->vmovdqu16(anyptr_gpA, ymmB); - e->vmovdqu16(zmmA, zmmB); - e->vmovdqu16(zmmA, anyptr_gpB); - e->vmovdqu16(zmmA, zmmB); - e->vmovdqu16(anyptr_gpA, zmmB); - e->vmovdqu32(xmmA, xmmB); - e->vmovdqu32(xmmA, anyptr_gpB); - e->vmovdqu32(xmmA, xmmB); - e->vmovdqu32(anyptr_gpA, xmmB); - e->vmovdqu32(ymmA, ymmB); - e->vmovdqu32(ymmA, anyptr_gpB); - e->vmovdqu32(ymmA, ymmB); - e->vmovdqu32(anyptr_gpA, ymmB); - e->vmovdqu32(zmmA, zmmB); - e->vmovdqu32(zmmA, anyptr_gpB); - e->vmovdqu32(zmmA, zmmB); - e->vmovdqu32(anyptr_gpA, zmmB); - e->vmovdqu64(xmmA, xmmB); - e->vmovdqu64(xmmA, anyptr_gpB); - e->vmovdqu64(xmmA, xmmB); - e->vmovdqu64(anyptr_gpA, xmmB); - e->vmovdqu64(ymmA, ymmB); - e->vmovdqu64(ymmA, anyptr_gpB); - e->vmovdqu64(ymmA, ymmB); - e->vmovdqu64(anyptr_gpA, ymmB); - e->vmovdqu64(zmmA, zmmB); - e->vmovdqu64(zmmA, anyptr_gpB); - e->vmovdqu64(zmmA, zmmB); - e->vmovdqu64(anyptr_gpA, zmmB); - e->vmovdqu8(xmmA, xmmB); - e->vmovdqu8(xmmA, anyptr_gpB); - e->vmovdqu8(xmmA, xmmB); - e->vmovdqu8(anyptr_gpA, xmmB); - e->vmovdqu8(ymmA, ymmB); - e->vmovdqu8(ymmA, anyptr_gpB); - e->vmovdqu8(ymmA, ymmB); - e->vmovdqu8(anyptr_gpA, ymmB); - e->vmovdqu8(zmmA, zmmB); - e->vmovdqu8(zmmA, anyptr_gpB); - e->vmovdqu8(zmmA, zmmB); - e->vmovdqu8(anyptr_gpA, zmmB); - e->vmovhlps(xmmA, xmmB, xmmC); - e->vmovhpd(anyptr_gpA, xmmB); - e->vmovhpd(xmmA, xmmB, anyptr_gpC); - e->vmovhps(anyptr_gpA, xmmB); - e->vmovhps(xmmA, xmmB, anyptr_gpC); - e->vmovlhps(xmmA, xmmB, xmmC); - e->vmovlpd(anyptr_gpA, xmmB); - e->vmovlpd(xmmA, xmmB, anyptr_gpC); - e->vmovlps(anyptr_gpA, xmmB); - e->vmovlps(xmmA, xmmB, anyptr_gpC); - e->vmovntdq(anyptr_gpA, xmmB); - e->vmovntdq(anyptr_gpA, ymmB); - e->vmovntdq(anyptr_gpA, zmmB); - e->vmovntdqa(xmmA, anyptr_gpB); - e->vmovntdqa(ymmA, anyptr_gpB); - e->vmovntdqa(zmmA, anyptr_gpB); - e->vmovntpd(anyptr_gpA, xmmB); - e->vmovntpd(anyptr_gpA, ymmB); - e->vmovntpd(anyptr_gpA, zmmB); - e->vmovntps(anyptr_gpA, xmmB); - e->vmovntps(anyptr_gpA, ymmB); - e->vmovntps(anyptr_gpA, zmmB); - if (isX64) e->vmovq(gzA, xmmB); - if (isX64) e->vmovq(xmmA, gzB); - e->vmovq(anyptr_gpA, xmmB); - e->vmovq(xmmA, anyptr_gpB); - e->vmovq(xmmA, xmmB); - e->vmovq(xmmA, anyptr_gpB); - e->vmovq(xmmA, xmmB); - e->vmovq(anyptr_gpA, xmmB); - e->vmovsd(anyptr_gpA, xmmB); - e->vmovsd(xmmA, anyptr_gpB); - e->vmovsd(xmmA, xmmB, xmmC); - e->vmovsd(xmmA, xmmB, xmmC); - e->vmovshdup(xmmA, xmmB); - e->vmovshdup(xmmA, anyptr_gpB); - e->vmovshdup(ymmA, ymmB); - e->vmovshdup(ymmA, anyptr_gpB); - e->vmovshdup(zmmA, zmmB); - e->vmovshdup(zmmA, anyptr_gpB); - e->vmovsldup(xmmA, xmmB); - e->vmovsldup(xmmA, anyptr_gpB); - e->vmovsldup(ymmA, ymmB); - e->vmovsldup(ymmA, anyptr_gpB); - e->vmovsldup(zmmA, zmmB); - e->vmovsldup(zmmA, anyptr_gpB); - e->vmovss(anyptr_gpA, xmmB); - e->vmovss(xmmA, anyptr_gpB); - e->vmovss(xmmA, xmmB, xmmC); - e->vmovss(xmmA, xmmB, xmmC); - e->vmovupd(xmmA, xmmB); - e->vmovupd(xmmA, anyptr_gpB); - e->vmovupd(xmmA, xmmB); - e->vmovupd(anyptr_gpA, xmmB); - e->vmovupd(ymmA, ymmB); - e->vmovupd(ymmA, anyptr_gpB); - e->vmovupd(ymmA, ymmB); - e->vmovupd(anyptr_gpA, ymmB); - e->vmovupd(zmmA, zmmB); - e->vmovupd(zmmA, anyptr_gpB); - e->vmovupd(zmmA, zmmB); - e->vmovupd(anyptr_gpA, zmmB); - e->vmovups(xmmA, xmmB); - e->vmovups(xmmA, anyptr_gpB); - e->vmovups(xmmA, xmmB); - e->vmovups(anyptr_gpA, xmmB); - e->vmovups(ymmA, ymmB); - e->vmovups(ymmA, anyptr_gpB); - e->vmovups(ymmA, ymmB); - e->vmovups(anyptr_gpA, ymmB); - e->vmovups(zmmA, zmmB); - e->vmovups(zmmA, anyptr_gpB); - e->vmovups(zmmA, zmmB); - e->vmovups(anyptr_gpA, zmmB); - e->vmulpd(xmmA, xmmB, xmmC); - e->vmulpd(xmmA, xmmB, anyptr_gpC); - e->vmulpd(ymmA, ymmB, ymmC); - e->vmulpd(ymmA, ymmB, anyptr_gpC); - e->vmulpd(zmmA, zmmB, zmmC); - e->vmulpd(zmmA, zmmB, anyptr_gpC); - e->vmulps(xmmA, xmmB, xmmC); - e->vmulps(xmmA, xmmB, anyptr_gpC); - e->vmulps(ymmA, ymmB, ymmC); - e->vmulps(ymmA, ymmB, anyptr_gpC); - e->vmulps(zmmA, zmmB, zmmC); - e->vmulps(zmmA, zmmB, anyptr_gpC); - e->vmulsd(xmmA, xmmB, xmmC); - e->vmulsd(xmmA, xmmB, anyptr_gpC); - e->vmulss(xmmA, xmmB, xmmC); - e->vmulss(xmmA, xmmB, anyptr_gpC); - e->vorpd(xmmA, xmmB, xmmC); - e->vorpd(xmmA, xmmB, anyptr_gpC); - e->vorpd(ymmA, ymmB, ymmC); - e->vorpd(ymmA, ymmB, anyptr_gpC); - e->vorpd(zmmA, zmmB, zmmC); - e->vorpd(zmmA, zmmB, anyptr_gpC); - e->vorps(xmmA, xmmB, xmmC); - e->vorps(xmmA, xmmB, anyptr_gpC); - e->vorps(ymmA, ymmB, ymmC); - e->vorps(ymmA, ymmB, anyptr_gpC); - e->vorps(zmmA, zmmB, zmmC); - e->vorps(zmmA, zmmB, anyptr_gpC); - e->vpabsb(xmmA, xmmB); - e->vpabsb(xmmA, anyptr_gpB); - e->vpabsb(ymmA, ymmB); - e->vpabsb(ymmA, anyptr_gpB); - e->vpabsb(zmmA, zmmB); - e->vpabsb(zmmA, anyptr_gpB); - e->vpabsd(xmmA, xmmB); - e->vpabsd(xmmA, anyptr_gpB); - e->vpabsd(ymmA, ymmB); - e->vpabsd(ymmA, anyptr_gpB); - e->vpabsd(zmmA, zmmB); - e->vpabsd(zmmA, anyptr_gpB); - e->vpabsq(xmmA, xmmB); - e->vpabsq(xmmA, anyptr_gpB); - e->vpabsq(ymmA, ymmB); - e->vpabsq(ymmA, anyptr_gpB); - e->vpabsq(zmmA, zmmB); - e->vpabsq(zmmA, anyptr_gpB); - e->vpabsw(xmmA, xmmB); - e->vpabsw(xmmA, anyptr_gpB); - e->vpabsw(ymmA, ymmB); - e->vpabsw(ymmA, anyptr_gpB); - e->vpabsw(zmmA, zmmB); - e->vpabsw(zmmA, anyptr_gpB); - e->vpackssdw(xmmA, xmmB, xmmC); - e->vpackssdw(xmmA, xmmB, anyptr_gpC); - e->vpackssdw(ymmA, ymmB, ymmC); - e->vpackssdw(ymmA, ymmB, anyptr_gpC); - e->vpackssdw(zmmA, zmmB, zmmC); - e->vpackssdw(zmmA, zmmB, anyptr_gpC); - e->vpacksswb(xmmA, xmmB, xmmC); - e->vpacksswb(xmmA, xmmB, anyptr_gpC); - e->vpacksswb(ymmA, ymmB, ymmC); - e->vpacksswb(ymmA, ymmB, anyptr_gpC); - e->vpacksswb(zmmA, zmmB, zmmC); - e->vpacksswb(zmmA, zmmB, anyptr_gpC); - e->vpackusdw(xmmA, xmmB, xmmC); - e->vpackusdw(xmmA, xmmB, anyptr_gpC); - e->vpackusdw(ymmA, ymmB, ymmC); - e->vpackusdw(ymmA, ymmB, anyptr_gpC); - e->vpackusdw(zmmA, zmmB, zmmC); - e->vpackusdw(zmmA, zmmB, anyptr_gpC); - e->vpackuswb(xmmA, xmmB, xmmC); - e->vpackuswb(xmmA, xmmB, anyptr_gpC); - e->vpackuswb(ymmA, ymmB, ymmC); - e->vpackuswb(ymmA, ymmB, anyptr_gpC); - e->vpackuswb(zmmA, zmmB, zmmC); - e->vpackuswb(zmmA, zmmB, anyptr_gpC); - e->vpaddb(xmmA, xmmB, xmmC); - e->vpaddb(xmmA, xmmB, anyptr_gpC); - e->vpaddb(ymmA, ymmB, ymmC); - e->vpaddb(ymmA, ymmB, anyptr_gpC); - e->vpaddb(zmmA, zmmB, zmmC); - e->vpaddb(zmmA, zmmB, anyptr_gpC); - e->vpaddd(xmmA, xmmB, xmmC); - e->vpaddd(xmmA, xmmB, anyptr_gpC); - e->vpaddd(ymmA, ymmB, ymmC); - e->vpaddd(ymmA, ymmB, anyptr_gpC); - e->vpaddd(zmmA, zmmB, zmmC); - e->vpaddd(zmmA, zmmB, anyptr_gpC); - e->vpaddq(xmmA, xmmB, xmmC); - e->vpaddq(xmmA, xmmB, anyptr_gpC); - e->vpaddq(ymmA, ymmB, ymmC); - e->vpaddq(ymmA, ymmB, anyptr_gpC); - e->vpaddq(zmmA, zmmB, zmmC); - e->vpaddq(zmmA, zmmB, anyptr_gpC); - e->vpaddsb(xmmA, xmmB, xmmC); - e->vpaddsb(xmmA, xmmB, anyptr_gpC); - e->vpaddsb(ymmA, ymmB, ymmC); - e->vpaddsb(ymmA, ymmB, anyptr_gpC); - e->vpaddsb(zmmA, zmmB, zmmC); - e->vpaddsb(zmmA, zmmB, anyptr_gpC); - e->vpaddsw(xmmA, xmmB, xmmC); - e->vpaddsw(xmmA, xmmB, anyptr_gpC); - e->vpaddsw(ymmA, ymmB, ymmC); - e->vpaddsw(ymmA, ymmB, anyptr_gpC); - e->vpaddsw(zmmA, zmmB, zmmC); - e->vpaddsw(zmmA, zmmB, anyptr_gpC); - e->vpaddusb(xmmA, xmmB, xmmC); - e->vpaddusb(xmmA, xmmB, anyptr_gpC); - e->vpaddusb(ymmA, ymmB, ymmC); - e->vpaddusb(ymmA, ymmB, anyptr_gpC); - e->vpaddusb(zmmA, zmmB, zmmC); - e->vpaddusb(zmmA, zmmB, anyptr_gpC); - e->vpaddusw(xmmA, xmmB, xmmC); - e->vpaddusw(xmmA, xmmB, anyptr_gpC); - e->vpaddusw(ymmA, ymmB, ymmC); - e->vpaddusw(ymmA, ymmB, anyptr_gpC); - e->vpaddusw(zmmA, zmmB, zmmC); - e->vpaddusw(zmmA, zmmB, anyptr_gpC); - e->vpaddw(xmmA, xmmB, xmmC); - e->vpaddw(xmmA, xmmB, anyptr_gpC); - e->vpaddw(ymmA, ymmB, ymmC); - e->vpaddw(ymmA, ymmB, anyptr_gpC); - e->vpaddw(zmmA, zmmB, zmmC); - e->vpaddw(zmmA, zmmB, anyptr_gpC); - e->vpalignr(xmmA, xmmB, xmmC, 0); - e->vpalignr(xmmA, xmmB, anyptr_gpC, 0); - e->vpalignr(ymmA, ymmB, ymmC, 0); - e->vpalignr(ymmA, ymmB, anyptr_gpC, 0); - e->vpalignr(zmmA, zmmB, zmmC, 0); - e->vpalignr(zmmA, zmmB, anyptr_gpC, 0); - e->vpandd(xmmA, xmmB, xmmC); - e->vpandd(xmmA, xmmB, anyptr_gpC); - e->vpandd(ymmA, ymmB, ymmC); - e->vpandd(ymmA, ymmB, anyptr_gpC); - e->vpandd(zmmA, zmmB, zmmC); - e->vpandd(zmmA, zmmB, anyptr_gpC); - e->vpandnd(xmmA, xmmB, xmmC); - e->vpandnd(xmmA, xmmB, anyptr_gpC); - e->vpandnd(ymmA, ymmB, ymmC); - e->vpandnd(ymmA, ymmB, anyptr_gpC); - e->vpandnd(zmmA, zmmB, zmmC); - e->vpandnd(zmmA, zmmB, anyptr_gpC); - e->vpandnq(xmmA, xmmB, xmmC); - e->vpandnq(xmmA, xmmB, anyptr_gpC); - e->vpandnq(ymmA, ymmB, ymmC); - e->vpandnq(ymmA, ymmB, anyptr_gpC); - e->vpandnq(zmmA, zmmB, zmmC); - e->vpandnq(zmmA, zmmB, anyptr_gpC); - e->vpandq(xmmA, xmmB, xmmC); - e->vpandq(xmmA, xmmB, anyptr_gpC); - e->vpandq(ymmA, ymmB, ymmC); - e->vpandq(ymmA, ymmB, anyptr_gpC); - e->vpandq(zmmA, zmmB, zmmC); - e->vpandq(zmmA, zmmB, anyptr_gpC); - e->vpavgb(xmmA, xmmB, xmmC); - e->vpavgb(xmmA, xmmB, anyptr_gpC); - e->vpavgb(ymmA, ymmB, ymmC); - e->vpavgb(ymmA, ymmB, anyptr_gpC); - e->vpavgb(zmmA, zmmB, zmmC); - e->vpavgb(zmmA, zmmB, anyptr_gpC); - e->vpavgw(xmmA, xmmB, xmmC); - e->vpavgw(xmmA, xmmB, anyptr_gpC); - e->vpavgw(ymmA, ymmB, ymmC); - e->vpavgw(ymmA, ymmB, anyptr_gpC); - e->vpavgw(zmmA, zmmB, zmmC); - e->vpavgw(zmmA, zmmB, anyptr_gpC); - e->vpbroadcastb(xmmA, gdB); - e->vpbroadcastb(xmmA, gzB); - e->vpbroadcastb(xmmA, xmmB); - e->vpbroadcastb(xmmA, anyptr_gpB); - e->vpbroadcastb(ymmA, gdB); - e->vpbroadcastb(ymmA, gzB); - e->vpbroadcastb(ymmA, xmmB); - e->vpbroadcastb(ymmA, anyptr_gpB); - e->vpbroadcastb(zmmA, gdB); - e->vpbroadcastb(zmmA, gzB); - e->vpbroadcastb(zmmA, xmmB); - e->vpbroadcastb(zmmA, anyptr_gpB); - e->vpbroadcastd(xmmA, gdB); - e->vpbroadcastd(xmmA, gzB); - e->vpbroadcastd(xmmA, xmmB); - e->vpbroadcastd(xmmA, anyptr_gpB); - e->vpbroadcastd(ymmA, gdB); - e->vpbroadcastd(ymmA, gzB); - e->vpbroadcastd(ymmA, xmmB); - e->vpbroadcastd(ymmA, anyptr_gpB); - e->vpbroadcastd(zmmA, gdB); - e->vpbroadcastd(zmmA, gzB); - e->vpbroadcastd(zmmA, xmmB); - e->vpbroadcastd(zmmA, anyptr_gpB); - e->vpbroadcastmb2d(xmmA, kB); - e->vpbroadcastmb2d(ymmA, kB); - e->vpbroadcastmb2d(zmmA, kB); - e->vpbroadcastmb2q(xmmA, kB); - e->vpbroadcastmb2q(ymmA, kB); - e->vpbroadcastmb2q(zmmA, kB); - if (isX64) e->vpbroadcastq(xmmA, gzB); - e->vpbroadcastq(xmmA, xmmB); - e->vpbroadcastq(xmmA, anyptr_gpB); - if (isX64) e->vpbroadcastq(ymmA, gzB); - e->vpbroadcastq(ymmA, xmmB); - e->vpbroadcastq(ymmA, anyptr_gpB); - if (isX64) e->vpbroadcastq(zmmA, gzB); - e->vpbroadcastq(zmmA, xmmB); - e->vpbroadcastq(zmmA, anyptr_gpB); - e->vpbroadcastw(xmmA, gdB); - e->vpbroadcastw(xmmA, gzB); - e->vpbroadcastw(xmmA, xmmB); - e->vpbroadcastw(xmmA, anyptr_gpB); - e->vpbroadcastw(ymmA, gdB); - e->vpbroadcastw(ymmA, gzB); - e->vpbroadcastw(ymmA, xmmB); - e->vpbroadcastw(ymmA, anyptr_gpB); - e->vpbroadcastw(zmmA, gdB); - e->vpbroadcastw(zmmA, gzB); - e->vpbroadcastw(zmmA, xmmB); - e->vpbroadcastw(zmmA, anyptr_gpB); - e->vpcmpb(kA, xmmB, xmmC, 0); - e->vpcmpb(kA, xmmB, anyptr_gpC, 0); - e->vpcmpb(kA, ymmB, ymmC, 0); - e->vpcmpb(kA, ymmB, anyptr_gpC, 0); - e->vpcmpb(kA, zmmB, zmmC, 0); - e->vpcmpb(kA, zmmB, anyptr_gpC, 0); - e->vpcmpd(kA, xmmB, xmmC, 0); - e->vpcmpd(kA, xmmB, anyptr_gpC, 0); - e->vpcmpd(kA, ymmB, ymmC, 0); - e->vpcmpd(kA, ymmB, anyptr_gpC, 0); - e->vpcmpd(kA, zmmB, zmmC, 0); - e->vpcmpd(kA, zmmB, anyptr_gpC, 0); - e->vpcmpeqb(kA, xmmB, xmmC); - e->vpcmpeqb(kA, xmmB, anyptr_gpC); - e->vpcmpeqb(kA, ymmB, ymmC); - e->vpcmpeqb(kA, ymmB, anyptr_gpC); - e->vpcmpeqb(kA, zmmB, zmmC); - e->vpcmpeqb(kA, zmmB, anyptr_gpC); - e->vpcmpeqd(kA, xmmB, xmmC); - e->vpcmpeqd(kA, xmmB, anyptr_gpC); - e->vpcmpeqd(kA, ymmB, ymmC); - e->vpcmpeqd(kA, ymmB, anyptr_gpC); - e->vpcmpeqd(kA, zmmB, zmmC); - e->vpcmpeqd(kA, zmmB, anyptr_gpC); - e->vpcmpeqq(kA, xmmB, xmmC); - e->vpcmpeqq(kA, xmmB, anyptr_gpC); - e->vpcmpeqq(kA, ymmB, ymmC); - e->vpcmpeqq(kA, ymmB, anyptr_gpC); - e->vpcmpeqq(kA, zmmB, zmmC); - e->vpcmpeqq(kA, zmmB, anyptr_gpC); - e->vpcmpeqw(kA, xmmB, xmmC); - e->vpcmpeqw(kA, xmmB, anyptr_gpC); - e->vpcmpeqw(kA, ymmB, ymmC); - e->vpcmpeqw(kA, ymmB, anyptr_gpC); - e->vpcmpeqw(kA, zmmB, zmmC); - e->vpcmpeqw(kA, zmmB, anyptr_gpC); - e->vpcmpgtb(kA, xmmB, xmmC); - e->vpcmpgtb(kA, xmmB, anyptr_gpC); - e->vpcmpgtb(kA, ymmB, ymmC); - e->vpcmpgtb(kA, ymmB, anyptr_gpC); - e->vpcmpgtb(kA, zmmB, zmmC); - e->vpcmpgtb(kA, zmmB, anyptr_gpC); - e->vpcmpgtd(kA, xmmB, xmmC); - e->vpcmpgtd(kA, xmmB, anyptr_gpC); - e->vpcmpgtd(kA, ymmB, ymmC); - e->vpcmpgtd(kA, ymmB, anyptr_gpC); - e->vpcmpgtd(kA, zmmB, zmmC); - e->vpcmpgtd(kA, zmmB, anyptr_gpC); - e->vpcmpgtq(kA, xmmB, xmmC); - e->vpcmpgtq(kA, xmmB, anyptr_gpC); - e->vpcmpgtq(kA, ymmB, ymmC); - e->vpcmpgtq(kA, ymmB, anyptr_gpC); - e->vpcmpgtq(kA, zmmB, zmmC); - e->vpcmpgtq(kA, zmmB, anyptr_gpC); - e->vpcmpgtw(kA, xmmB, xmmC); - e->vpcmpgtw(kA, xmmB, anyptr_gpC); - e->vpcmpgtw(kA, ymmB, ymmC); - e->vpcmpgtw(kA, ymmB, anyptr_gpC); - e->vpcmpgtw(kA, zmmB, zmmC); - e->vpcmpgtw(kA, zmmB, anyptr_gpC); - e->vpcmpq(kA, xmmB, xmmC, 0); - e->vpcmpq(kA, xmmB, anyptr_gpC, 0); - e->vpcmpq(kA, ymmB, ymmC, 0); - e->vpcmpq(kA, ymmB, anyptr_gpC, 0); - e->vpcmpq(kA, zmmB, zmmC, 0); - e->vpcmpq(kA, zmmB, anyptr_gpC, 0); - e->vpcmpub(kA, xmmB, xmmC, 0); - e->vpcmpub(kA, xmmB, anyptr_gpC, 0); - e->vpcmpub(kA, ymmB, ymmC, 0); - e->vpcmpub(kA, ymmB, anyptr_gpC, 0); - e->vpcmpub(kA, zmmB, zmmC, 0); - e->vpcmpub(kA, zmmB, anyptr_gpC, 0); - e->vpcmpud(kA, xmmB, xmmC, 0); - e->vpcmpud(kA, xmmB, anyptr_gpC, 0); - e->vpcmpud(kA, ymmB, ymmC, 0); - e->vpcmpud(kA, ymmB, anyptr_gpC, 0); - e->vpcmpud(kA, zmmB, zmmC, 0); - e->vpcmpud(kA, zmmB, anyptr_gpC, 0); - e->vpcmpuq(kA, xmmB, xmmC, 0); - e->vpcmpuq(kA, xmmB, anyptr_gpC, 0); - e->vpcmpuq(kA, ymmB, ymmC, 0); - e->vpcmpuq(kA, ymmB, anyptr_gpC, 0); - e->vpcmpuq(kA, zmmB, zmmC, 0); - e->vpcmpuq(kA, zmmB, anyptr_gpC, 0); - e->vpcmpuw(kA, xmmB, xmmC, 0); - e->vpcmpuw(kA, xmmB, anyptr_gpC, 0); - e->vpcmpuw(kA, ymmB, ymmC, 0); - e->vpcmpuw(kA, ymmB, anyptr_gpC, 0); - e->vpcmpuw(kA, zmmB, zmmC, 0); - e->vpcmpuw(kA, zmmB, anyptr_gpC, 0); - e->vpcmpw(kA, xmmB, xmmC, 0); - e->vpcmpw(kA, xmmB, anyptr_gpC, 0); - e->vpcmpw(kA, ymmB, ymmC, 0); - e->vpcmpw(kA, ymmB, anyptr_gpC, 0); - e->vpcmpw(kA, zmmB, zmmC, 0); - e->vpcmpw(kA, zmmB, anyptr_gpC, 0); - e->vpcompressd(xmmA, xmmB); - e->vpcompressd(anyptr_gpA, xmmB); - e->vpcompressd(ymmA, ymmB); - e->vpcompressd(anyptr_gpA, ymmB); - e->vpcompressd(zmmA, zmmB); - e->vpcompressd(anyptr_gpA, zmmB); - e->vpcompressq(xmmA, xmmB); - e->vpcompressq(anyptr_gpA, xmmB); - e->vpcompressq(ymmA, ymmB); - e->vpcompressq(anyptr_gpA, ymmB); - e->vpcompressq(zmmA, zmmB); - e->vpcompressq(anyptr_gpA, zmmB); - e->vpconflictd(xmmA, xmmB); - e->vpconflictd(xmmA, anyptr_gpB); - e->vpconflictd(ymmA, ymmB); - e->vpconflictd(ymmA, anyptr_gpB); - e->vpconflictd(zmmA, zmmB); - e->vpconflictd(zmmA, anyptr_gpB); - e->vpconflictq(xmmA, xmmB); - e->vpconflictq(xmmA, anyptr_gpB); - e->vpconflictq(ymmA, ymmB); - e->vpconflictq(ymmA, anyptr_gpB); - e->vpconflictq(zmmA, zmmB); - e->vpconflictq(zmmA, anyptr_gpB); - e->vpermb(xmmA, xmmB, xmmC); - e->vpermb(xmmA, xmmB, anyptr_gpC); - e->vpermb(ymmA, ymmB, ymmC); - e->vpermb(ymmA, ymmB, anyptr_gpC); - e->vpermb(zmmA, zmmB, zmmC); - e->vpermb(zmmA, zmmB, anyptr_gpC); - e->vpermd(ymmA, ymmB, ymmC); - e->vpermd(ymmA, ymmB, anyptr_gpC); - e->vpermd(zmmA, zmmB, zmmC); - e->vpermd(zmmA, zmmB, anyptr_gpC); - e->vpermi2b(xmmA, xmmB, xmmC); - e->vpermi2b(xmmA, xmmB, anyptr_gpC); - e->vpermi2b(ymmA, ymmB, ymmC); - e->vpermi2b(ymmA, ymmB, anyptr_gpC); - e->vpermi2b(zmmA, zmmB, zmmC); - e->vpermi2b(zmmA, zmmB, anyptr_gpC); - e->vpermi2d(xmmA, xmmB, xmmC); - e->vpermi2d(xmmA, xmmB, anyptr_gpC); - e->vpermi2d(ymmA, ymmB, ymmC); - e->vpermi2d(ymmA, ymmB, anyptr_gpC); - e->vpermi2d(zmmA, zmmB, zmmC); - e->vpermi2d(zmmA, zmmB, anyptr_gpC); - e->vpermi2pd(xmmA, xmmB, xmmC); - e->vpermi2pd(xmmA, xmmB, anyptr_gpC); - e->vpermi2pd(ymmA, ymmB, ymmC); - e->vpermi2pd(ymmA, ymmB, anyptr_gpC); - e->vpermi2pd(zmmA, zmmB, zmmC); - e->vpermi2pd(zmmA, zmmB, anyptr_gpC); - e->vpermi2ps(xmmA, xmmB, xmmC); - e->vpermi2ps(xmmA, xmmB, anyptr_gpC); - e->vpermi2ps(ymmA, ymmB, ymmC); - e->vpermi2ps(ymmA, ymmB, anyptr_gpC); - e->vpermi2ps(zmmA, zmmB, zmmC); - e->vpermi2ps(zmmA, zmmB, anyptr_gpC); - e->vpermi2q(xmmA, xmmB, xmmC); - e->vpermi2q(xmmA, xmmB, anyptr_gpC); - e->vpermi2q(ymmA, ymmB, ymmC); - e->vpermi2q(ymmA, ymmB, anyptr_gpC); - e->vpermi2q(zmmA, zmmB, zmmC); - e->vpermi2q(zmmA, zmmB, anyptr_gpC); - e->vpermi2w(xmmA, xmmB, xmmC); - e->vpermi2w(xmmA, xmmB, anyptr_gpC); - e->vpermi2w(ymmA, ymmB, ymmC); - e->vpermi2w(ymmA, ymmB, anyptr_gpC); - e->vpermi2w(zmmA, zmmB, zmmC); - e->vpermi2w(zmmA, zmmB, anyptr_gpC); - e->vpermilpd(xmmA, xmmB, xmmC); - e->vpermilpd(xmmA, xmmB, anyptr_gpC); - e->vpermilpd(ymmA, ymmB, ymmC); - e->vpermilpd(ymmA, ymmB, anyptr_gpC); - e->vpermilpd(zmmA, zmmB, zmmC); - e->vpermilpd(zmmA, zmmB, anyptr_gpC); - e->vpermilpd(xmmA, xmmB, 0); - e->vpermilpd(xmmA, anyptr_gpB, 0); - e->vpermilpd(ymmA, ymmB, 0); - e->vpermilpd(ymmA, anyptr_gpB, 0); - e->vpermilpd(zmmA, zmmB, 0); - e->vpermilpd(zmmA, anyptr_gpB, 0); - e->vpermilps(xmmA, xmmB, xmmC); - e->vpermilps(xmmA, xmmB, anyptr_gpC); - e->vpermilps(ymmA, ymmB, ymmC); - e->vpermilps(ymmA, ymmB, anyptr_gpC); - e->vpermilps(zmmA, zmmB, zmmC); - e->vpermilps(zmmA, zmmB, anyptr_gpC); - e->vpermilps(xmmA, xmmB, 0); - e->vpermilps(xmmA, anyptr_gpB, 0); - e->vpermilps(ymmA, ymmB, 0); - e->vpermilps(ymmA, anyptr_gpB, 0); - e->vpermilps(zmmA, zmmB, 0); - e->vpermilps(zmmA, anyptr_gpB, 0); - e->vpermq(ymmA, ymmB, ymmC); - e->vpermq(ymmA, ymmB, anyptr_gpC); - e->vpermq(zmmA, zmmB, zmmC); - e->vpermq(zmmA, zmmB, anyptr_gpC); - e->vpermq(ymmA, ymmB, 0); - e->vpermq(ymmA, anyptr_gpB, 0); - e->vpermq(zmmA, zmmB, 0); - e->vpermq(zmmA, anyptr_gpB, 0); - e->vpermt2b(xmmA, xmmB, xmmC); - e->vpermt2b(xmmA, xmmB, anyptr_gpC); - e->vpermt2b(ymmA, ymmB, ymmC); - e->vpermt2b(ymmA, ymmB, anyptr_gpC); - e->vpermt2b(zmmA, zmmB, zmmC); - e->vpermt2b(zmmA, zmmB, anyptr_gpC); - e->vpermt2d(xmmA, xmmB, xmmC); - e->vpermt2d(xmmA, xmmB, anyptr_gpC); - e->vpermt2d(ymmA, ymmB, ymmC); - e->vpermt2d(ymmA, ymmB, anyptr_gpC); - e->vpermt2d(zmmA, zmmB, zmmC); - e->vpermt2d(zmmA, zmmB, anyptr_gpC); - e->vpermt2pd(xmmA, xmmB, xmmC); - e->vpermt2pd(xmmA, xmmB, anyptr_gpC); - e->vpermt2pd(ymmA, ymmB, ymmC); - e->vpermt2pd(ymmA, ymmB, anyptr_gpC); - e->vpermt2pd(zmmA, zmmB, zmmC); - e->vpermt2pd(zmmA, zmmB, anyptr_gpC); - e->vpermt2ps(xmmA, xmmB, xmmC); - e->vpermt2ps(xmmA, xmmB, anyptr_gpC); - e->vpermt2ps(ymmA, ymmB, ymmC); - e->vpermt2ps(ymmA, ymmB, anyptr_gpC); - e->vpermt2ps(zmmA, zmmB, zmmC); - e->vpermt2ps(zmmA, zmmB, anyptr_gpC); - e->vpermt2q(xmmA, xmmB, xmmC); - e->vpermt2q(xmmA, xmmB, anyptr_gpC); - e->vpermt2q(ymmA, ymmB, ymmC); - e->vpermt2q(ymmA, ymmB, anyptr_gpC); - e->vpermt2q(zmmA, zmmB, zmmC); - e->vpermt2q(zmmA, zmmB, anyptr_gpC); - e->vpermt2w(xmmA, xmmB, xmmC); - e->vpermt2w(xmmA, xmmB, anyptr_gpC); - e->vpermt2w(ymmA, ymmB, ymmC); - e->vpermt2w(ymmA, ymmB, anyptr_gpC); - e->vpermt2w(zmmA, zmmB, zmmC); - e->vpermt2w(zmmA, zmmB, anyptr_gpC); - e->vpermw(xmmA, xmmB, xmmC); - e->vpermw(xmmA, xmmB, anyptr_gpC); - e->vpermw(ymmA, ymmB, ymmC); - e->vpermw(ymmA, ymmB, anyptr_gpC); - e->vpermw(zmmA, zmmB, zmmC); - e->vpermw(zmmA, zmmB, anyptr_gpC); - e->vpexpandd(xmmA, xmmB); - e->vpexpandd(xmmA, anyptr_gpB); - e->vpexpandd(ymmA, ymmB); - e->vpexpandd(ymmA, anyptr_gpB); - e->vpexpandd(zmmA, zmmB); - e->vpexpandd(zmmA, anyptr_gpB); - e->vpexpandq(xmmA, xmmB); - e->vpexpandq(xmmA, anyptr_gpB); - e->vpexpandq(ymmA, ymmB); - e->vpexpandq(ymmA, anyptr_gpB); - e->vpexpandq(zmmA, zmmB); - e->vpexpandq(zmmA, anyptr_gpB); - e->vpextrb(gdA, xmmB, 0); - e->vpextrb(anyptr_gpA, xmmB, 0); - e->vpextrb(gzA, xmmB, 0); - e->vpextrd(gdA, xmmB, 0); - e->vpextrd(anyptr_gpA, xmmB, 0); - if (isX64) e->vpextrd(gzA, xmmB, 0); - if (isX64) e->vpextrq(gzA, xmmB, 0); - e->vpextrq(anyptr_gpA, xmmB, 0); - e->vpextrw(gdA, xmmB, 0); - e->vpextrw(gzA, xmmB, 0); - e->vpextrw(gdA, xmmB, 0); - e->vpextrw(anyptr_gpA, xmmB, 0); - e->vpextrw(gzA, xmmB, 0); - e->vpgatherdd(xmmA, vx_ptr); - e->vpgatherdd(ymmA, vy_ptr); - e->vpgatherdd(zmmA, vz_ptr); - e->vpgatherdq(xmmA, vx_ptr); - e->vpgatherdq(ymmA, vy_ptr); - e->vpgatherdq(zmmA, vz_ptr); - e->vpgatherqd(xmmA, vx_ptr); - e->vpgatherqd(ymmA, vy_ptr); - e->vpgatherqd(zmmA, vz_ptr); - e->vpgatherqq(xmmA, vx_ptr); - e->vpgatherqq(ymmA, vy_ptr); - e->vpgatherqq(zmmA, vz_ptr); - e->vpinsrb(xmmA, xmmB, gdC, 0); - e->vpinsrb(xmmA, xmmB, anyptr_gpC, 0); - e->vpinsrb(xmmA, xmmB, gzC, 0); - e->vpinsrd(xmmA, xmmB, gdC, 0); - e->vpinsrd(xmmA, xmmB, anyptr_gpC, 0); - e->vpinsrd(xmmA, xmmB, gzC, 0); - if (isX64) e->vpinsrq(xmmA, xmmB, gzC, 0); - e->vpinsrq(xmmA, xmmB, anyptr_gpC, 0); - e->vpinsrw(xmmA, xmmB, gdC, 0); - e->vpinsrw(xmmA, xmmB, anyptr_gpC, 0); - e->vpinsrw(xmmA, xmmB, gzC, 0); - e->vplzcntd(xmmA, xmmB); - e->vplzcntd(xmmA, anyptr_gpB); - e->vplzcntd(ymmA, ymmB); - e->vplzcntd(ymmA, anyptr_gpB); - e->vplzcntd(zmmA, zmmB); - e->vplzcntd(zmmA, anyptr_gpB); - e->vplzcntq(xmmA, xmmB); - e->vplzcntq(xmmA, anyptr_gpB); - e->vplzcntq(ymmA, ymmB); - e->vplzcntq(ymmA, anyptr_gpB); - e->vplzcntq(zmmA, zmmB); - e->vplzcntq(zmmA, anyptr_gpB); - e->vpmadd52huq(xmmA, xmmB, xmmC); - e->vpmadd52huq(xmmA, xmmB, anyptr_gpC); - e->vpmadd52huq(ymmA, ymmB, ymmC); - e->vpmadd52huq(ymmA, ymmB, anyptr_gpC); - e->vpmadd52huq(zmmA, zmmB, zmmC); - e->vpmadd52huq(zmmA, zmmB, anyptr_gpC); - e->vpmadd52luq(xmmA, xmmB, xmmC); - e->vpmadd52luq(xmmA, xmmB, anyptr_gpC); - e->vpmadd52luq(ymmA, ymmB, ymmC); - e->vpmadd52luq(ymmA, ymmB, anyptr_gpC); - e->vpmadd52luq(zmmA, zmmB, zmmC); - e->vpmadd52luq(zmmA, zmmB, anyptr_gpC); - e->vpmaddubsw(xmmA, xmmB, xmmC); - e->vpmaddubsw(xmmA, xmmB, anyptr_gpC); - e->vpmaddubsw(ymmA, ymmB, ymmC); - e->vpmaddubsw(ymmA, ymmB, anyptr_gpC); - e->vpmaddubsw(zmmA, zmmB, zmmC); - e->vpmaddubsw(zmmA, zmmB, anyptr_gpC); - e->vpmaddwd(xmmA, xmmB, xmmC); - e->vpmaddwd(xmmA, xmmB, anyptr_gpC); - e->vpmaddwd(ymmA, ymmB, ymmC); - e->vpmaddwd(ymmA, ymmB, anyptr_gpC); - e->vpmaddwd(zmmA, zmmB, zmmC); - e->vpmaddwd(zmmA, zmmB, anyptr_gpC); - e->vpmaxsb(xmmA, xmmB, xmmC); - e->vpmaxsb(xmmA, xmmB, anyptr_gpC); - e->vpmaxsb(ymmA, ymmB, ymmC); - e->vpmaxsb(ymmA, ymmB, anyptr_gpC); - e->vpmaxsb(zmmA, zmmB, zmmC); - e->vpmaxsb(zmmA, zmmB, anyptr_gpC); - e->vpmaxsd(xmmA, xmmB, xmmC); - e->vpmaxsd(xmmA, xmmB, anyptr_gpC); - e->vpmaxsd(ymmA, ymmB, ymmC); - e->vpmaxsd(ymmA, ymmB, anyptr_gpC); - e->vpmaxsd(zmmA, zmmB, zmmC); - e->vpmaxsd(zmmA, zmmB, anyptr_gpC); - e->vpmaxsq(xmmA, xmmB, xmmC); - e->vpmaxsq(xmmA, xmmB, anyptr_gpC); - e->vpmaxsq(ymmA, ymmB, ymmC); - e->vpmaxsq(ymmA, ymmB, anyptr_gpC); - e->vpmaxsq(zmmA, zmmB, zmmC); - e->vpmaxsq(zmmA, zmmB, anyptr_gpC); - e->vpmaxsw(xmmA, xmmB, xmmC); - e->vpmaxsw(xmmA, xmmB, anyptr_gpC); - e->vpmaxsw(ymmA, ymmB, ymmC); - e->vpmaxsw(ymmA, ymmB, anyptr_gpC); - e->vpmaxsw(zmmA, zmmB, zmmC); - e->vpmaxsw(zmmA, zmmB, anyptr_gpC); - e->vpmaxub(xmmA, xmmB, xmmC); - e->vpmaxub(xmmA, xmmB, anyptr_gpC); - e->vpmaxub(ymmA, ymmB, ymmC); - e->vpmaxub(ymmA, ymmB, anyptr_gpC); - e->vpmaxub(zmmA, zmmB, zmmC); - e->vpmaxub(zmmA, zmmB, anyptr_gpC); - e->vpmaxud(xmmA, xmmB, xmmC); - e->vpmaxud(xmmA, xmmB, anyptr_gpC); - e->vpmaxud(ymmA, ymmB, ymmC); - e->vpmaxud(ymmA, ymmB, anyptr_gpC); - e->vpmaxud(zmmA, zmmB, zmmC); - e->vpmaxud(zmmA, zmmB, anyptr_gpC); - e->vpmaxuq(xmmA, xmmB, xmmC); - e->vpmaxuq(xmmA, xmmB, anyptr_gpC); - e->vpmaxuq(ymmA, ymmB, ymmC); - e->vpmaxuq(ymmA, ymmB, anyptr_gpC); - e->vpmaxuq(zmmA, zmmB, zmmC); - e->vpmaxuq(zmmA, zmmB, anyptr_gpC); - e->vpmaxuw(xmmA, xmmB, xmmC); - e->vpmaxuw(xmmA, xmmB, anyptr_gpC); - e->vpmaxuw(ymmA, ymmB, ymmC); - e->vpmaxuw(ymmA, ymmB, anyptr_gpC); - e->vpmaxuw(zmmA, zmmB, zmmC); - e->vpmaxuw(zmmA, zmmB, anyptr_gpC); - e->vpminsb(xmmA, xmmB, xmmC); - e->vpminsb(xmmA, xmmB, anyptr_gpC); - e->vpminsb(ymmA, ymmB, ymmC); - e->vpminsb(ymmA, ymmB, anyptr_gpC); - e->vpminsb(zmmA, zmmB, zmmC); - e->vpminsb(zmmA, zmmB, anyptr_gpC); - e->vpminsd(xmmA, xmmB, xmmC); - e->vpminsd(xmmA, xmmB, anyptr_gpC); - e->vpminsd(ymmA, ymmB, ymmC); - e->vpminsd(ymmA, ymmB, anyptr_gpC); - e->vpminsd(zmmA, zmmB, zmmC); - e->vpminsd(zmmA, zmmB, anyptr_gpC); - e->vpminsq(xmmA, xmmB, xmmC); - e->vpminsq(xmmA, xmmB, anyptr_gpC); - e->vpminsq(ymmA, ymmB, ymmC); - e->vpminsq(ymmA, ymmB, anyptr_gpC); - e->vpminsq(zmmA, zmmB, zmmC); - e->vpminsq(zmmA, zmmB, anyptr_gpC); - e->vpminsw(xmmA, xmmB, xmmC); - e->vpminsw(xmmA, xmmB, anyptr_gpC); - e->vpminsw(ymmA, ymmB, ymmC); - e->vpminsw(ymmA, ymmB, anyptr_gpC); - e->vpminsw(zmmA, zmmB, zmmC); - e->vpminsw(zmmA, zmmB, anyptr_gpC); - e->vpminub(xmmA, xmmB, xmmC); - e->vpminub(xmmA, xmmB, anyptr_gpC); - e->vpminub(ymmA, ymmB, ymmC); - e->vpminub(ymmA, ymmB, anyptr_gpC); - e->vpminub(zmmA, zmmB, zmmC); - e->vpminub(zmmA, zmmB, anyptr_gpC); - e->vpminud(xmmA, xmmB, xmmC); - e->vpminud(xmmA, xmmB, anyptr_gpC); - e->vpminud(ymmA, ymmB, ymmC); - e->vpminud(ymmA, ymmB, anyptr_gpC); - e->vpminud(zmmA, zmmB, zmmC); - e->vpminud(zmmA, zmmB, anyptr_gpC); - e->vpminuq(xmmA, xmmB, xmmC); - e->vpminuq(xmmA, xmmB, anyptr_gpC); - e->vpminuq(ymmA, ymmB, ymmC); - e->vpminuq(ymmA, ymmB, anyptr_gpC); - e->vpminuq(zmmA, zmmB, zmmC); - e->vpminuq(zmmA, zmmB, anyptr_gpC); - e->vpminuw(xmmA, xmmB, xmmC); - e->vpminuw(xmmA, xmmB, anyptr_gpC); - e->vpminuw(ymmA, ymmB, ymmC); - e->vpminuw(ymmA, ymmB, anyptr_gpC); - e->vpminuw(zmmA, zmmB, zmmC); - e->vpminuw(zmmA, zmmB, anyptr_gpC); - e->vpmovb2m(kA, xmmB); - e->vpmovb2m(kA, ymmB); - e->vpmovb2m(kA, zmmB); - e->vpmovd2m(kA, xmmB); - e->vpmovd2m(kA, ymmB); - e->vpmovd2m(kA, zmmB); - e->vpmovdb(xmmA, xmmB); - e->vpmovdb(anyptr_gpA, xmmB); - e->vpmovdb(xmmA, ymmB); - e->vpmovdb(anyptr_gpA, ymmB); - e->vpmovdb(xmmA, zmmB); - e->vpmovdb(anyptr_gpA, zmmB); - e->vpmovdw(xmmA, xmmB); - e->vpmovdw(anyptr_gpA, xmmB); - e->vpmovdw(xmmA, ymmB); - e->vpmovdw(anyptr_gpA, ymmB); - e->vpmovdw(ymmA, zmmB); - e->vpmovdw(anyptr_gpA, zmmB); - e->vpmovm2b(xmmA, kB); - e->vpmovm2b(ymmA, kB); - e->vpmovm2b(zmmA, kB); - e->vpmovm2d(xmmA, kB); - e->vpmovm2d(ymmA, kB); - e->vpmovm2d(zmmA, kB); - e->vpmovm2q(xmmA, kB); - e->vpmovm2q(ymmA, kB); - e->vpmovm2q(zmmA, kB); - e->vpmovm2w(xmmA, kB); - e->vpmovm2w(ymmA, kB); - e->vpmovm2w(zmmA, kB); - e->vpmovq2m(kA, xmmB); - e->vpmovq2m(kA, ymmB); - e->vpmovq2m(kA, zmmB); - e->vpmovqb(xmmA, xmmB); - e->vpmovqb(anyptr_gpA, xmmB); - e->vpmovqb(xmmA, ymmB); - e->vpmovqb(anyptr_gpA, ymmB); - e->vpmovqb(xmmA, zmmB); - e->vpmovqb(anyptr_gpA, zmmB); - e->vpmovqd(xmmA, xmmB); - e->vpmovqd(anyptr_gpA, xmmB); - e->vpmovqd(xmmA, ymmB); - e->vpmovqd(anyptr_gpA, ymmB); - e->vpmovqd(ymmA, zmmB); - e->vpmovqd(anyptr_gpA, zmmB); - e->vpmovqw(xmmA, xmmB); - e->vpmovqw(anyptr_gpA, xmmB); - e->vpmovqw(xmmA, ymmB); - e->vpmovqw(anyptr_gpA, ymmB); - e->vpmovqw(xmmA, zmmB); - e->vpmovqw(anyptr_gpA, zmmB); - e->vpmovsdb(xmmA, xmmB); - e->vpmovsdb(anyptr_gpA, xmmB); - e->vpmovsdb(xmmA, ymmB); - e->vpmovsdb(anyptr_gpA, ymmB); - e->vpmovsdb(xmmA, zmmB); - e->vpmovsdb(anyptr_gpA, zmmB); - e->vpmovsdw(xmmA, xmmB); - e->vpmovsdw(anyptr_gpA, xmmB); - e->vpmovsdw(xmmA, ymmB); - e->vpmovsdw(anyptr_gpA, ymmB); - e->vpmovsdw(ymmA, zmmB); - e->vpmovsdw(anyptr_gpA, zmmB); - e->vpmovsqb(xmmA, xmmB); - e->vpmovsqb(anyptr_gpA, xmmB); - e->vpmovsqb(xmmA, ymmB); - e->vpmovsqb(anyptr_gpA, ymmB); - e->vpmovsqb(xmmA, zmmB); - e->vpmovsqb(anyptr_gpA, zmmB); - e->vpmovsqd(xmmA, xmmB); - e->vpmovsqd(anyptr_gpA, xmmB); - e->vpmovsqd(xmmA, ymmB); - e->vpmovsqd(anyptr_gpA, ymmB); - e->vpmovsqd(ymmA, zmmB); - e->vpmovsqd(anyptr_gpA, zmmB); - e->vpmovsqw(xmmA, xmmB); - e->vpmovsqw(anyptr_gpA, xmmB); - e->vpmovsqw(xmmA, ymmB); - e->vpmovsqw(anyptr_gpA, ymmB); - e->vpmovsqw(xmmA, zmmB); - e->vpmovsqw(anyptr_gpA, zmmB); - e->vpmovswb(xmmA, xmmB); - e->vpmovswb(anyptr_gpA, xmmB); - e->vpmovswb(xmmA, ymmB); - e->vpmovswb(anyptr_gpA, ymmB); - e->vpmovswb(ymmA, zmmB); - e->vpmovswb(anyptr_gpA, zmmB); - e->vpmovsxbd(xmmA, xmmB); - e->vpmovsxbd(xmmA, anyptr_gpB); - e->vpmovsxbd(ymmA, xmmB); - e->vpmovsxbd(ymmA, anyptr_gpB); - e->vpmovsxbd(zmmA, xmmB); - e->vpmovsxbd(zmmA, anyptr_gpB); - e->vpmovsxbq(xmmA, xmmB); - e->vpmovsxbq(xmmA, anyptr_gpB); - e->vpmovsxbq(ymmA, xmmB); - e->vpmovsxbq(ymmA, anyptr_gpB); - e->vpmovsxbq(zmmA, xmmB); - e->vpmovsxbq(zmmA, anyptr_gpB); - e->vpmovsxbw(xmmA, xmmB); - e->vpmovsxbw(xmmA, anyptr_gpB); - e->vpmovsxbw(ymmA, xmmB); - e->vpmovsxbw(ymmA, anyptr_gpB); - e->vpmovsxbw(zmmA, ymmB); - e->vpmovsxbw(zmmA, anyptr_gpB); - e->vpmovsxdq(xmmA, xmmB); - e->vpmovsxdq(xmmA, anyptr_gpB); - e->vpmovsxdq(ymmA, xmmB); - e->vpmovsxdq(ymmA, anyptr_gpB); - e->vpmovsxdq(zmmA, ymmB); - e->vpmovsxdq(zmmA, anyptr_gpB); - e->vpmovsxwd(xmmA, xmmB); - e->vpmovsxwd(xmmA, anyptr_gpB); - e->vpmovsxwd(ymmA, xmmB); - e->vpmovsxwd(ymmA, anyptr_gpB); - e->vpmovsxwd(zmmA, ymmB); - e->vpmovsxwd(zmmA, anyptr_gpB); - e->vpmovsxwq(xmmA, xmmB); - e->vpmovsxwq(xmmA, anyptr_gpB); - e->vpmovsxwq(ymmA, xmmB); - e->vpmovsxwq(ymmA, anyptr_gpB); - e->vpmovsxwq(zmmA, xmmB); - e->vpmovsxwq(zmmA, anyptr_gpB); - e->vpmovusdb(xmmA, xmmB); - e->vpmovusdb(anyptr_gpA, xmmB); - e->vpmovusdb(xmmA, ymmB); - e->vpmovusdb(anyptr_gpA, ymmB); - e->vpmovusdb(xmmA, zmmB); - e->vpmovusdb(anyptr_gpA, zmmB); - e->vpmovusdw(xmmA, xmmB); - e->vpmovusdw(anyptr_gpA, xmmB); - e->vpmovusdw(xmmA, ymmB); - e->vpmovusdw(anyptr_gpA, ymmB); - e->vpmovusdw(ymmA, zmmB); - e->vpmovusdw(anyptr_gpA, zmmB); - e->vpmovusqb(xmmA, xmmB); - e->vpmovusqb(anyptr_gpA, xmmB); - e->vpmovusqb(xmmA, ymmB); - e->vpmovusqb(anyptr_gpA, ymmB); - e->vpmovusqb(xmmA, zmmB); - e->vpmovusqb(anyptr_gpA, zmmB); - e->vpmovusqd(xmmA, xmmB); - e->vpmovusqd(anyptr_gpA, xmmB); - e->vpmovusqd(xmmA, ymmB); - e->vpmovusqd(anyptr_gpA, ymmB); - e->vpmovusqd(ymmA, zmmB); - e->vpmovusqd(anyptr_gpA, zmmB); - e->vpmovusqw(xmmA, xmmB); - e->vpmovusqw(anyptr_gpA, xmmB); - e->vpmovusqw(xmmA, ymmB); - e->vpmovusqw(anyptr_gpA, ymmB); - e->vpmovusqw(xmmA, zmmB); - e->vpmovusqw(anyptr_gpA, zmmB); - e->vpmovuswb(xmmA, xmmB); - e->vpmovuswb(anyptr_gpA, xmmB); - e->vpmovuswb(xmmA, ymmB); - e->vpmovuswb(anyptr_gpA, ymmB); - e->vpmovuswb(ymmA, zmmB); - e->vpmovuswb(anyptr_gpA, zmmB); - e->vpmovw2m(kA, xmmB); - e->vpmovw2m(kA, ymmB); - e->vpmovw2m(kA, zmmB); - e->vpmovwb(xmmA, xmmB); - e->vpmovwb(anyptr_gpA, xmmB); - e->vpmovwb(xmmA, ymmB); - e->vpmovwb(anyptr_gpA, ymmB); - e->vpmovwb(ymmA, zmmB); - e->vpmovwb(anyptr_gpA, zmmB); - e->vpmovzxbd(xmmA, xmmB); - e->vpmovzxbd(xmmA, anyptr_gpB); - e->vpmovzxbd(ymmA, xmmB); - e->vpmovzxbd(ymmA, anyptr_gpB); - e->vpmovzxbd(zmmA, xmmB); - e->vpmovzxbd(zmmA, anyptr_gpB); - e->vpmovzxbq(xmmA, xmmB); - e->vpmovzxbq(xmmA, anyptr_gpB); - e->vpmovzxbq(ymmA, xmmB); - e->vpmovzxbq(ymmA, anyptr_gpB); - e->vpmovzxbq(zmmA, xmmB); - e->vpmovzxbq(zmmA, anyptr_gpB); - e->vpmovzxbw(xmmA, xmmB); - e->vpmovzxbw(xmmA, anyptr_gpB); - e->vpmovzxbw(ymmA, xmmB); - e->vpmovzxbw(ymmA, anyptr_gpB); - e->vpmovzxbw(zmmA, ymmB); - e->vpmovzxbw(zmmA, anyptr_gpB); - e->vpmovzxdq(xmmA, xmmB); - e->vpmovzxdq(xmmA, anyptr_gpB); - e->vpmovzxdq(ymmA, xmmB); - e->vpmovzxdq(ymmA, anyptr_gpB); - e->vpmovzxdq(zmmA, ymmB); - e->vpmovzxdq(zmmA, anyptr_gpB); - e->vpmovzxwd(xmmA, xmmB); - e->vpmovzxwd(xmmA, anyptr_gpB); - e->vpmovzxwd(ymmA, xmmB); - e->vpmovzxwd(ymmA, anyptr_gpB); - e->vpmovzxwd(zmmA, ymmB); - e->vpmovzxwd(zmmA, anyptr_gpB); - e->vpmovzxwq(xmmA, xmmB); - e->vpmovzxwq(xmmA, anyptr_gpB); - e->vpmovzxwq(ymmA, xmmB); - e->vpmovzxwq(ymmA, anyptr_gpB); - e->vpmovzxwq(zmmA, xmmB); - e->vpmovzxwq(zmmA, anyptr_gpB); - e->vpmuldq(xmmA, xmmB, xmmC); - e->vpmuldq(xmmA, xmmB, anyptr_gpC); - e->vpmuldq(ymmA, ymmB, ymmC); - e->vpmuldq(ymmA, ymmB, anyptr_gpC); - e->vpmuldq(zmmA, zmmB, zmmC); - e->vpmuldq(zmmA, zmmB, anyptr_gpC); - e->vpmulhrsw(xmmA, xmmB, xmmC); - e->vpmulhrsw(xmmA, xmmB, anyptr_gpC); - e->vpmulhrsw(ymmA, ymmB, ymmC); - e->vpmulhrsw(ymmA, ymmB, anyptr_gpC); - e->vpmulhrsw(zmmA, zmmB, zmmC); - e->vpmulhrsw(zmmA, zmmB, anyptr_gpC); - e->vpmulhuw(xmmA, xmmB, xmmC); - e->vpmulhuw(xmmA, xmmB, anyptr_gpC); - e->vpmulhuw(ymmA, ymmB, ymmC); - e->vpmulhuw(ymmA, ymmB, anyptr_gpC); - e->vpmulhuw(zmmA, zmmB, zmmC); - e->vpmulhuw(zmmA, zmmB, anyptr_gpC); - e->vpmulhw(xmmA, xmmB, xmmC); - e->vpmulhw(xmmA, xmmB, anyptr_gpC); - e->vpmulhw(ymmA, ymmB, ymmC); - e->vpmulhw(ymmA, ymmB, anyptr_gpC); - e->vpmulhw(zmmA, zmmB, zmmC); - e->vpmulhw(zmmA, zmmB, anyptr_gpC); - e->vpmulld(xmmA, xmmB, xmmC); - e->vpmulld(xmmA, xmmB, anyptr_gpC); - e->vpmulld(ymmA, ymmB, ymmC); - e->vpmulld(ymmA, ymmB, anyptr_gpC); - e->vpmulld(zmmA, zmmB, zmmC); - e->vpmulld(zmmA, zmmB, anyptr_gpC); - e->vpmullq(xmmA, xmmB, xmmC); - e->vpmullq(xmmA, xmmB, anyptr_gpC); - e->vpmullq(ymmA, ymmB, ymmC); - e->vpmullq(ymmA, ymmB, anyptr_gpC); - e->vpmullq(zmmA, zmmB, zmmC); - e->vpmullq(zmmA, zmmB, anyptr_gpC); - e->vpmullw(xmmA, xmmB, xmmC); - e->vpmullw(xmmA, xmmB, anyptr_gpC); - e->vpmullw(ymmA, ymmB, ymmC); - e->vpmullw(ymmA, ymmB, anyptr_gpC); - e->vpmullw(zmmA, zmmB, zmmC); - e->vpmullw(zmmA, zmmB, anyptr_gpC); - e->vpmultishiftqb(xmmA, xmmB, xmmC); - e->vpmultishiftqb(xmmA, xmmB, anyptr_gpC); - e->vpmultishiftqb(ymmA, ymmB, ymmC); - e->vpmultishiftqb(ymmA, ymmB, anyptr_gpC); - e->vpmultishiftqb(zmmA, zmmB, zmmC); - e->vpmultishiftqb(zmmA, zmmB, anyptr_gpC); - e->vpmuludq(xmmA, xmmB, xmmC); - e->vpmuludq(xmmA, xmmB, anyptr_gpC); - e->vpmuludq(ymmA, ymmB, ymmC); - e->vpmuludq(ymmA, ymmB, anyptr_gpC); - e->vpmuludq(zmmA, zmmB, zmmC); - e->vpmuludq(zmmA, zmmB, anyptr_gpC); - e->vpopcntd(zmmA, zmmB); - e->vpopcntd(zmmA, anyptr_gpB); - e->vpopcntq(zmmA, zmmB); - e->vpopcntq(zmmA, anyptr_gpB); - e->vpord(xmmA, xmmB, xmmC); - e->vpord(xmmA, xmmB, anyptr_gpC); - e->vpord(ymmA, ymmB, ymmC); - e->vpord(ymmA, ymmB, anyptr_gpC); - e->vpord(zmmA, zmmB, zmmC); - e->vpord(zmmA, zmmB, anyptr_gpC); - e->vporq(xmmA, xmmB, xmmC); - e->vporq(xmmA, xmmB, anyptr_gpC); - e->vporq(ymmA, ymmB, ymmC); - e->vporq(ymmA, ymmB, anyptr_gpC); - e->vporq(zmmA, zmmB, zmmC); - e->vporq(zmmA, zmmB, anyptr_gpC); - e->vprold(xmmA, xmmB, 0); - e->vprold(xmmA, anyptr_gpB, 0); - e->vprold(ymmA, ymmB, 0); - e->vprold(ymmA, anyptr_gpB, 0); - e->vprold(zmmA, zmmB, 0); - e->vprold(zmmA, anyptr_gpB, 0); - e->vprolq(xmmA, xmmB, 0); - e->vprolq(xmmA, anyptr_gpB, 0); - e->vprolq(ymmA, ymmB, 0); - e->vprolq(ymmA, anyptr_gpB, 0); - e->vprolq(zmmA, zmmB, 0); - e->vprolq(zmmA, anyptr_gpB, 0); - e->vprolvd(xmmA, xmmB, xmmC); - e->vprolvd(xmmA, xmmB, anyptr_gpC); - e->vprolvd(ymmA, ymmB, ymmC); - e->vprolvd(ymmA, ymmB, anyptr_gpC); - e->vprolvd(zmmA, zmmB, zmmC); - e->vprolvd(zmmA, zmmB, anyptr_gpC); - e->vprolvq(xmmA, xmmB, xmmC); - e->vprolvq(xmmA, xmmB, anyptr_gpC); - e->vprolvq(ymmA, ymmB, ymmC); - e->vprolvq(ymmA, ymmB, anyptr_gpC); - e->vprolvq(zmmA, zmmB, zmmC); - e->vprolvq(zmmA, zmmB, anyptr_gpC); - e->vprord(xmmA, xmmB, 0); - e->vprord(xmmA, anyptr_gpB, 0); - e->vprord(ymmA, ymmB, 0); - e->vprord(ymmA, anyptr_gpB, 0); - e->vprord(zmmA, zmmB, 0); - e->vprord(zmmA, anyptr_gpB, 0); - e->vprorq(xmmA, xmmB, 0); - e->vprorq(xmmA, anyptr_gpB, 0); - e->vprorq(ymmA, ymmB, 0); - e->vprorq(ymmA, anyptr_gpB, 0); - e->vprorq(zmmA, zmmB, 0); - e->vprorq(zmmA, anyptr_gpB, 0); - e->vprorvd(xmmA, xmmB, xmmC); - e->vprorvd(xmmA, xmmB, anyptr_gpC); - e->vprorvd(ymmA, ymmB, ymmC); - e->vprorvd(ymmA, ymmB, anyptr_gpC); - e->vprorvd(zmmA, zmmB, zmmC); - e->vprorvd(zmmA, zmmB, anyptr_gpC); - e->vprorvq(xmmA, xmmB, xmmC); - e->vprorvq(xmmA, xmmB, anyptr_gpC); - e->vprorvq(ymmA, ymmB, ymmC); - e->vprorvq(ymmA, ymmB, anyptr_gpC); - e->vprorvq(zmmA, zmmB, zmmC); - e->vprorvq(zmmA, zmmB, anyptr_gpC); - e->vpsadbw(xmmA, xmmB, xmmC); - e->vpsadbw(xmmA, xmmB, anyptr_gpC); - e->vpsadbw(ymmA, ymmB, ymmC); - e->vpsadbw(ymmA, ymmB, anyptr_gpC); - e->vpsadbw(zmmA, zmmB, zmmC); - e->vpsadbw(zmmA, zmmB, anyptr_gpC); - e->vpscatterdd(vx_ptr, xmmB); - e->vpscatterdd(vy_ptr, ymmB); - e->vpscatterdd(vz_ptr, zmmB); - e->vpscatterdq(vx_ptr, xmmB); - e->vpscatterdq(vy_ptr, ymmB); - e->vpscatterdq(vz_ptr, zmmB); - e->vpscatterqd(vx_ptr, xmmB); - e->vpscatterqd(vy_ptr, xmmB); - e->vpscatterqd(vz_ptr, ymmB); - e->vpscatterqq(vx_ptr, xmmB); - e->vpscatterqq(vy_ptr, ymmB); - e->vpscatterqq(vz_ptr, zmmB); - e->vpshufb(xmmA, xmmB, xmmC); - e->vpshufb(xmmA, xmmB, anyptr_gpC); - e->vpshufb(ymmA, ymmB, ymmC); - e->vpshufb(ymmA, ymmB, anyptr_gpC); - e->vpshufb(zmmA, zmmB, zmmC); - e->vpshufb(zmmA, zmmB, anyptr_gpC); - e->vpshufd(xmmA, xmmB, 0); - e->vpshufd(xmmA, anyptr_gpB, 0); - e->vpshufd(ymmA, ymmB, 0); - e->vpshufd(ymmA, anyptr_gpB, 0); - e->vpshufd(zmmA, zmmB, 0); - e->vpshufd(zmmA, anyptr_gpB, 0); - e->vpshufhw(xmmA, xmmB, 0); - e->vpshufhw(xmmA, anyptr_gpB, 0); - e->vpshufhw(ymmA, ymmB, 0); - e->vpshufhw(ymmA, anyptr_gpB, 0); - e->vpshufhw(zmmA, zmmB, 0); - e->vpshufhw(zmmA, anyptr_gpB, 0); - e->vpshuflw(xmmA, xmmB, 0); - e->vpshuflw(xmmA, anyptr_gpB, 0); - e->vpshuflw(ymmA, ymmB, 0); - e->vpshuflw(ymmA, anyptr_gpB, 0); - e->vpshuflw(zmmA, zmmB, 0); - e->vpshuflw(zmmA, anyptr_gpB, 0); - e->vpslld(xmmA, xmmB, xmmC); - e->vpslld(xmmA, xmmB, anyptr_gpC); - e->vpslld(xmmA, xmmB, 0); - e->vpslld(xmmA, anyptr_gpB, 0); - e->vpslld(ymmA, ymmB, xmmC); - e->vpslld(ymmA, ymmB, anyptr_gpC); - e->vpslld(ymmA, ymmB, 0); - e->vpslld(ymmA, anyptr_gpB, 0); - e->vpslld(zmmA, zmmB, xmmC); - e->vpslld(zmmA, zmmB, anyptr_gpC); - e->vpslld(zmmA, zmmB, 0); - e->vpslld(zmmA, anyptr_gpB, 0); - e->vpslldq(xmmA, xmmB, 0); - e->vpslldq(xmmA, anyptr_gpB, 0); - e->vpslldq(ymmA, ymmB, 0); - e->vpslldq(ymmA, anyptr_gpB, 0); - e->vpslldq(zmmA, zmmB, 0); - e->vpslldq(zmmA, anyptr_gpB, 0); - e->vpsllq(xmmA, xmmB, xmmC); - e->vpsllq(xmmA, xmmB, anyptr_gpC); - e->vpsllq(xmmA, xmmB, 0); - e->vpsllq(xmmA, anyptr_gpB, 0); - e->vpsllq(ymmA, ymmB, xmmC); - e->vpsllq(ymmA, ymmB, anyptr_gpC); - e->vpsllq(ymmA, ymmB, 0); - e->vpsllq(ymmA, anyptr_gpB, 0); - e->vpsllq(zmmA, zmmB, xmmC); - e->vpsllq(zmmA, zmmB, anyptr_gpC); - e->vpsllq(zmmA, zmmB, 0); - e->vpsllq(zmmA, anyptr_gpB, 0); - e->vpsllvd(xmmA, xmmB, xmmC); - e->vpsllvd(xmmA, xmmB, anyptr_gpC); - e->vpsllvd(ymmA, ymmB, ymmC); - e->vpsllvd(ymmA, ymmB, anyptr_gpC); - e->vpsllvd(zmmA, zmmB, zmmC); - e->vpsllvd(zmmA, zmmB, anyptr_gpC); - e->vpsllvq(xmmA, xmmB, xmmC); - e->vpsllvq(xmmA, xmmB, anyptr_gpC); - e->vpsllvq(ymmA, ymmB, ymmC); - e->vpsllvq(ymmA, ymmB, anyptr_gpC); - e->vpsllvq(zmmA, zmmB, zmmC); - e->vpsllvq(zmmA, zmmB, anyptr_gpC); - e->vpsllvw(xmmA, xmmB, xmmC); - e->vpsllvw(xmmA, xmmB, anyptr_gpC); - e->vpsllvw(ymmA, ymmB, ymmC); - e->vpsllvw(ymmA, ymmB, anyptr_gpC); - e->vpsllvw(zmmA, zmmB, zmmC); - e->vpsllvw(zmmA, zmmB, anyptr_gpC); - e->vpsllw(xmmA, xmmB, xmmC); - e->vpsllw(xmmA, xmmB, anyptr_gpC); - e->vpsllw(xmmA, xmmB, 0); - e->vpsllw(xmmA, anyptr_gpB, 0); - e->vpsllw(ymmA, ymmB, xmmC); - e->vpsllw(ymmA, ymmB, anyptr_gpC); - e->vpsllw(ymmA, ymmB, 0); - e->vpsllw(ymmA, anyptr_gpB, 0); - e->vpsllw(zmmA, zmmB, xmmC); - e->vpsllw(zmmA, zmmB, anyptr_gpC); - e->vpsllw(zmmA, zmmB, 0); - e->vpsllw(zmmA, anyptr_gpB, 0); - e->vpsrad(xmmA, xmmB, xmmC); - e->vpsrad(xmmA, xmmB, anyptr_gpC); - e->vpsrad(xmmA, xmmB, 0); - e->vpsrad(xmmA, anyptr_gpB, 0); - e->vpsrad(ymmA, ymmB, xmmC); - e->vpsrad(ymmA, ymmB, anyptr_gpC); - e->vpsrad(ymmA, ymmB, 0); - e->vpsrad(ymmA, anyptr_gpB, 0); - e->vpsrad(zmmA, zmmB, xmmC); - e->vpsrad(zmmA, zmmB, anyptr_gpC); - e->vpsrad(zmmA, zmmB, 0); - e->vpsrad(zmmA, anyptr_gpB, 0); - e->vpsraq(xmmA, xmmB, xmmC); - e->vpsraq(xmmA, xmmB, anyptr_gpC); - e->vpsraq(xmmA, xmmB, 0); - e->vpsraq(xmmA, anyptr_gpB, 0); - e->vpsraq(ymmA, ymmB, xmmC); - e->vpsraq(ymmA, ymmB, anyptr_gpC); - e->vpsraq(ymmA, ymmB, 0); - e->vpsraq(ymmA, anyptr_gpB, 0); - e->vpsraq(zmmA, zmmB, xmmC); - e->vpsraq(zmmA, zmmB, anyptr_gpC); - e->vpsraq(zmmA, zmmB, 0); - e->vpsraq(zmmA, anyptr_gpB, 0); - e->vpsravd(xmmA, xmmB, xmmC); - e->vpsravd(xmmA, xmmB, anyptr_gpC); - e->vpsravd(ymmA, ymmB, ymmC); - e->vpsravd(ymmA, ymmB, anyptr_gpC); - e->vpsravd(zmmA, zmmB, zmmC); - e->vpsravd(zmmA, zmmB, anyptr_gpC); - e->vpsravq(xmmA, xmmB, xmmC); - e->vpsravq(xmmA, xmmB, anyptr_gpC); - e->vpsravq(ymmA, ymmB, ymmC); - e->vpsravq(ymmA, ymmB, anyptr_gpC); - e->vpsravq(zmmA, zmmB, zmmC); - e->vpsravq(zmmA, zmmB, anyptr_gpC); - e->vpsravw(xmmA, xmmB, xmmC); - e->vpsravw(xmmA, xmmB, anyptr_gpC); - e->vpsravw(ymmA, ymmB, ymmC); - e->vpsravw(ymmA, ymmB, anyptr_gpC); - e->vpsravw(zmmA, zmmB, zmmC); - e->vpsravw(zmmA, zmmB, anyptr_gpC); - e->vpsraw(xmmA, xmmB, xmmC); - e->vpsraw(xmmA, xmmB, anyptr_gpC); - e->vpsraw(xmmA, xmmB, 0); - e->vpsraw(xmmA, anyptr_gpB, 0); - e->vpsraw(ymmA, ymmB, xmmC); - e->vpsraw(ymmA, ymmB, anyptr_gpC); - e->vpsraw(ymmA, ymmB, 0); - e->vpsraw(ymmA, anyptr_gpB, 0); - e->vpsraw(zmmA, zmmB, xmmC); - e->vpsraw(zmmA, zmmB, anyptr_gpC); - e->vpsraw(zmmA, zmmB, 0); - e->vpsraw(zmmA, anyptr_gpB, 0); - e->vpsrld(xmmA, xmmB, xmmC); - e->vpsrld(xmmA, xmmB, anyptr_gpC); - e->vpsrld(xmmA, xmmB, 0); - e->vpsrld(xmmA, anyptr_gpB, 0); - e->vpsrld(ymmA, ymmB, xmmC); - e->vpsrld(ymmA, ymmB, anyptr_gpC); - e->vpsrld(ymmA, ymmB, 0); - e->vpsrld(ymmA, anyptr_gpB, 0); - e->vpsrld(zmmA, zmmB, xmmC); - e->vpsrld(zmmA, zmmB, anyptr_gpC); - e->vpsrld(zmmA, zmmB, 0); - e->vpsrld(zmmA, anyptr_gpB, 0); - e->vpsrldq(xmmA, xmmB, 0); - e->vpsrldq(xmmA, anyptr_gpB, 0); - e->vpsrldq(ymmA, ymmB, 0); - e->vpsrldq(ymmA, anyptr_gpB, 0); - e->vpsrldq(zmmA, zmmB, 0); - e->vpsrldq(zmmA, anyptr_gpB, 0); - e->vpsrlq(xmmA, xmmB, xmmC); - e->vpsrlq(xmmA, xmmB, anyptr_gpC); - e->vpsrlq(xmmA, xmmB, 0); - e->vpsrlq(xmmA, anyptr_gpB, 0); - e->vpsrlq(ymmA, ymmB, xmmC); - e->vpsrlq(ymmA, ymmB, anyptr_gpC); - e->vpsrlq(ymmA, ymmB, 0); - e->vpsrlq(ymmA, anyptr_gpB, 0); - e->vpsrlq(zmmA, zmmB, xmmC); - e->vpsrlq(zmmA, zmmB, anyptr_gpC); - e->vpsrlq(zmmA, zmmB, 0); - e->vpsrlq(zmmA, anyptr_gpB, 0); - e->vpsrlvd(xmmA, xmmB, xmmC); - e->vpsrlvd(xmmA, xmmB, anyptr_gpC); - e->vpsrlvd(ymmA, ymmB, ymmC); - e->vpsrlvd(ymmA, ymmB, anyptr_gpC); - e->vpsrlvd(zmmA, zmmB, zmmC); - e->vpsrlvd(zmmA, zmmB, anyptr_gpC); - e->vpsrlvq(xmmA, xmmB, xmmC); - e->vpsrlvq(xmmA, xmmB, anyptr_gpC); - e->vpsrlvq(ymmA, ymmB, ymmC); - e->vpsrlvq(ymmA, ymmB, anyptr_gpC); - e->vpsrlvq(zmmA, zmmB, zmmC); - e->vpsrlvq(zmmA, zmmB, anyptr_gpC); - e->vpsrlvw(xmmA, xmmB, xmmC); - e->vpsrlvw(xmmA, xmmB, anyptr_gpC); - e->vpsrlvw(ymmA, ymmB, ymmC); - e->vpsrlvw(ymmA, ymmB, anyptr_gpC); - e->vpsrlvw(zmmA, zmmB, zmmC); - e->vpsrlvw(zmmA, zmmB, anyptr_gpC); - e->vpsrlw(xmmA, xmmB, xmmC); - e->vpsrlw(xmmA, xmmB, anyptr_gpC); - e->vpsrlw(xmmA, xmmB, 0); - e->vpsrlw(xmmA, anyptr_gpB, 0); - e->vpsrlw(ymmA, ymmB, xmmC); - e->vpsrlw(ymmA, ymmB, anyptr_gpC); - e->vpsrlw(ymmA, ymmB, 0); - e->vpsrlw(ymmA, anyptr_gpB, 0); - e->vpsrlw(zmmA, zmmB, xmmC); - e->vpsrlw(zmmA, zmmB, anyptr_gpC); - e->vpsrlw(zmmA, zmmB, 0); - e->vpsrlw(zmmA, anyptr_gpB, 0); - e->vpsubb(xmmA, xmmB, xmmC); - e->vpsubb(xmmA, xmmB, anyptr_gpC); - e->vpsubb(ymmA, ymmB, ymmC); - e->vpsubb(ymmA, ymmB, anyptr_gpC); - e->vpsubb(zmmA, zmmB, zmmC); - e->vpsubb(zmmA, zmmB, anyptr_gpC); - e->vpsubd(xmmA, xmmB, xmmC); - e->vpsubd(xmmA, xmmB, anyptr_gpC); - e->vpsubd(ymmA, ymmB, ymmC); - e->vpsubd(ymmA, ymmB, anyptr_gpC); - e->vpsubd(zmmA, zmmB, zmmC); - e->vpsubd(zmmA, zmmB, anyptr_gpC); - e->vpsubq(xmmA, xmmB, xmmC); - e->vpsubq(xmmA, xmmB, anyptr_gpC); - e->vpsubq(ymmA, ymmB, ymmC); - e->vpsubq(ymmA, ymmB, anyptr_gpC); - e->vpsubq(zmmA, zmmB, zmmC); - e->vpsubq(zmmA, zmmB, anyptr_gpC); - e->vpsubsb(xmmA, xmmB, xmmC); - e->vpsubsb(xmmA, xmmB, anyptr_gpC); - e->vpsubsb(ymmA, ymmB, ymmC); - e->vpsubsb(ymmA, ymmB, anyptr_gpC); - e->vpsubsb(zmmA, zmmB, zmmC); - e->vpsubsb(zmmA, zmmB, anyptr_gpC); - e->vpsubsw(xmmA, xmmB, xmmC); - e->vpsubsw(xmmA, xmmB, anyptr_gpC); - e->vpsubsw(ymmA, ymmB, ymmC); - e->vpsubsw(ymmA, ymmB, anyptr_gpC); - e->vpsubsw(zmmA, zmmB, zmmC); - e->vpsubsw(zmmA, zmmB, anyptr_gpC); - e->vpsubusb(xmmA, xmmB, xmmC); - e->vpsubusb(xmmA, xmmB, anyptr_gpC); - e->vpsubusb(ymmA, ymmB, ymmC); - e->vpsubusb(ymmA, ymmB, anyptr_gpC); - e->vpsubusb(zmmA, zmmB, zmmC); - e->vpsubusb(zmmA, zmmB, anyptr_gpC); - e->vpsubusw(xmmA, xmmB, xmmC); - e->vpsubusw(xmmA, xmmB, anyptr_gpC); - e->vpsubusw(ymmA, ymmB, ymmC); - e->vpsubusw(ymmA, ymmB, anyptr_gpC); - e->vpsubusw(zmmA, zmmB, zmmC); - e->vpsubusw(zmmA, zmmB, anyptr_gpC); - e->vpsubw(xmmA, xmmB, xmmC); - e->vpsubw(xmmA, xmmB, anyptr_gpC); - e->vpsubw(ymmA, ymmB, ymmC); - e->vpsubw(ymmA, ymmB, anyptr_gpC); - e->vpsubw(zmmA, zmmB, zmmC); - e->vpsubw(zmmA, zmmB, anyptr_gpC); - e->vpternlogd(xmmA, xmmB, xmmC, 0); - e->vpternlogd(xmmA, xmmB, anyptr_gpC, 0); - e->vpternlogd(ymmA, ymmB, ymmC, 0); - e->vpternlogd(ymmA, ymmB, anyptr_gpC, 0); - e->vpternlogd(zmmA, zmmB, zmmC, 0); - e->vpternlogd(zmmA, zmmB, anyptr_gpC, 0); - e->vpternlogq(xmmA, xmmB, xmmC, 0); - e->vpternlogq(xmmA, xmmB, anyptr_gpC, 0); - e->vpternlogq(ymmA, ymmB, ymmC, 0); - e->vpternlogq(ymmA, ymmB, anyptr_gpC, 0); - e->vpternlogq(zmmA, zmmB, zmmC, 0); - e->vpternlogq(zmmA, zmmB, anyptr_gpC, 0); - e->vptestmb(kA, xmmB, xmmC); - e->vptestmb(kA, xmmB, anyptr_gpC); - e->vptestmb(kA, ymmB, ymmC); - e->vptestmb(kA, ymmB, anyptr_gpC); - e->vptestmb(kA, zmmB, zmmC); - e->vptestmb(kA, zmmB, anyptr_gpC); - e->vptestmd(kA, xmmB, xmmC); - e->vptestmd(kA, xmmB, anyptr_gpC); - e->vptestmd(kA, ymmB, ymmC); - e->vptestmd(kA, ymmB, anyptr_gpC); - e->vptestmd(kA, zmmB, zmmC); - e->vptestmd(kA, zmmB, anyptr_gpC); - e->vptestmq(kA, xmmB, xmmC); - e->vptestmq(kA, xmmB, anyptr_gpC); - e->vptestmq(kA, ymmB, ymmC); - e->vptestmq(kA, ymmB, anyptr_gpC); - e->vptestmq(kA, zmmB, zmmC); - e->vptestmq(kA, zmmB, anyptr_gpC); - e->vptestmw(kA, xmmB, xmmC); - e->vptestmw(kA, xmmB, anyptr_gpC); - e->vptestmw(kA, ymmB, ymmC); - e->vptestmw(kA, ymmB, anyptr_gpC); - e->vptestmw(kA, zmmB, zmmC); - e->vptestmw(kA, zmmB, anyptr_gpC); - e->vptestnmb(kA, xmmB, xmmC); - e->vptestnmb(kA, xmmB, anyptr_gpC); - e->vptestnmb(kA, ymmB, ymmC); - e->vptestnmb(kA, ymmB, anyptr_gpC); - e->vptestnmb(kA, zmmB, zmmC); - e->vptestnmb(kA, zmmB, anyptr_gpC); - e->vptestnmd(kA, xmmB, xmmC); - e->vptestnmd(kA, xmmB, anyptr_gpC); - e->vptestnmd(kA, ymmB, ymmC); - e->vptestnmd(kA, ymmB, anyptr_gpC); - e->vptestnmd(kA, zmmB, zmmC); - e->vptestnmd(kA, zmmB, anyptr_gpC); - e->vptestnmq(kA, xmmB, xmmC); - e->vptestnmq(kA, xmmB, anyptr_gpC); - e->vptestnmq(kA, ymmB, ymmC); - e->vptestnmq(kA, ymmB, anyptr_gpC); - e->vptestnmq(kA, zmmB, zmmC); - e->vptestnmq(kA, zmmB, anyptr_gpC); - e->vptestnmw(kA, xmmB, xmmC); - e->vptestnmw(kA, xmmB, anyptr_gpC); - e->vptestnmw(kA, ymmB, ymmC); - e->vptestnmw(kA, ymmB, anyptr_gpC); - e->vptestnmw(kA, zmmB, zmmC); - e->vptestnmw(kA, zmmB, anyptr_gpC); - e->vpunpckhbw(xmmA, xmmB, xmmC); - e->vpunpckhbw(xmmA, xmmB, anyptr_gpC); - e->vpunpckhbw(ymmA, ymmB, ymmC); - e->vpunpckhbw(ymmA, ymmB, anyptr_gpC); - e->vpunpckhbw(zmmA, zmmB, zmmC); - e->vpunpckhbw(zmmA, zmmB, anyptr_gpC); - e->vpunpckhdq(xmmA, xmmB, xmmC); - e->vpunpckhdq(xmmA, xmmB, anyptr_gpC); - e->vpunpckhdq(ymmA, ymmB, ymmC); - e->vpunpckhdq(ymmA, ymmB, anyptr_gpC); - e->vpunpckhdq(zmmA, zmmB, zmmC); - e->vpunpckhdq(zmmA, zmmB, anyptr_gpC); - e->vpunpckhqdq(xmmA, xmmB, xmmC); - e->vpunpckhqdq(xmmA, xmmB, anyptr_gpC); - e->vpunpckhqdq(ymmA, ymmB, ymmC); - e->vpunpckhqdq(ymmA, ymmB, anyptr_gpC); - e->vpunpckhqdq(zmmA, zmmB, zmmC); - e->vpunpckhqdq(zmmA, zmmB, anyptr_gpC); - e->vpunpckhwd(xmmA, xmmB, xmmC); - e->vpunpckhwd(xmmA, xmmB, anyptr_gpC); - e->vpunpckhwd(ymmA, ymmB, ymmC); - e->vpunpckhwd(ymmA, ymmB, anyptr_gpC); - e->vpunpckhwd(zmmA, zmmB, zmmC); - e->vpunpckhwd(zmmA, zmmB, anyptr_gpC); - e->vpunpcklbw(xmmA, xmmB, xmmC); - e->vpunpcklbw(xmmA, xmmB, anyptr_gpC); - e->vpunpcklbw(ymmA, ymmB, ymmC); - e->vpunpcklbw(ymmA, ymmB, anyptr_gpC); - e->vpunpcklbw(zmmA, zmmB, zmmC); - e->vpunpcklbw(zmmA, zmmB, anyptr_gpC); - e->vpunpckldq(xmmA, xmmB, xmmC); - e->vpunpckldq(xmmA, xmmB, anyptr_gpC); - e->vpunpckldq(ymmA, ymmB, ymmC); - e->vpunpckldq(ymmA, ymmB, anyptr_gpC); - e->vpunpckldq(zmmA, zmmB, zmmC); - e->vpunpckldq(zmmA, zmmB, anyptr_gpC); - e->vpunpcklqdq(xmmA, xmmB, xmmC); - e->vpunpcklqdq(xmmA, xmmB, anyptr_gpC); - e->vpunpcklqdq(ymmA, ymmB, ymmC); - e->vpunpcklqdq(ymmA, ymmB, anyptr_gpC); - e->vpunpcklqdq(zmmA, zmmB, zmmC); - e->vpunpcklqdq(zmmA, zmmB, anyptr_gpC); - e->vpunpcklwd(xmmA, xmmB, xmmC); - e->vpunpcklwd(xmmA, xmmB, anyptr_gpC); - e->vpunpcklwd(ymmA, ymmB, ymmC); - e->vpunpcklwd(ymmA, ymmB, anyptr_gpC); - e->vpunpcklwd(zmmA, zmmB, zmmC); - e->vpunpcklwd(zmmA, zmmB, anyptr_gpC); - e->vpxord(xmmA, xmmB, xmmC); - e->vpxord(xmmA, xmmB, anyptr_gpC); - e->vpxord(ymmA, ymmB, ymmC); - e->vpxord(ymmA, ymmB, anyptr_gpC); - e->vpxord(zmmA, zmmB, zmmC); - e->vpxord(zmmA, zmmB, anyptr_gpC); - e->vpxorq(xmmA, xmmB, xmmC); - e->vpxorq(xmmA, xmmB, anyptr_gpC); - e->vpxorq(ymmA, ymmB, ymmC); - e->vpxorq(ymmA, ymmB, anyptr_gpC); - e->vpxorq(zmmA, zmmB, zmmC); - e->vpxorq(zmmA, zmmB, anyptr_gpC); - e->vrangepd(xmmA, xmmB, xmmC, 0); - e->vrangepd(xmmA, xmmB, anyptr_gpC, 0); - e->vrangepd(ymmA, ymmB, ymmC, 0); - e->vrangepd(ymmA, ymmB, anyptr_gpC, 0); - e->vrangepd(zmmA, zmmB, zmmC, 0); - e->vrangepd(zmmA, zmmB, anyptr_gpC, 0); - e->vrangeps(xmmA, xmmB, xmmC, 0); - e->vrangeps(xmmA, xmmB, anyptr_gpC, 0); - e->vrangeps(ymmA, ymmB, ymmC, 0); - e->vrangeps(ymmA, ymmB, anyptr_gpC, 0); - e->vrangeps(zmmA, zmmB, zmmC, 0); - e->vrangeps(zmmA, zmmB, anyptr_gpC, 0); - e->vrangesd(xmmA, xmmB, xmmC, 0); - e->vrangesd(xmmA, xmmB, anyptr_gpC, 0); - e->vrangess(xmmA, xmmB, xmmC, 0); - e->vrangess(xmmA, xmmB, anyptr_gpC, 0); - e->vrcp14pd(xmmA, xmmB); - e->vrcp14pd(xmmA, anyptr_gpB); - e->vrcp14pd(ymmA, ymmB); - e->vrcp14pd(ymmA, anyptr_gpB); - e->vrcp14pd(zmmA, zmmB); - e->vrcp14pd(zmmA, anyptr_gpB); - e->vrcp14ps(xmmA, xmmB); - e->vrcp14ps(xmmA, anyptr_gpB); - e->vrcp14ps(ymmA, ymmB); - e->vrcp14ps(ymmA, anyptr_gpB); - e->vrcp14ps(zmmA, zmmB); - e->vrcp14ps(zmmA, anyptr_gpB); - e->vrcp14sd(xmmA, xmmB, xmmC); - e->vrcp14sd(xmmA, xmmB, anyptr_gpC); - e->vrcp14ss(xmmA, xmmB, xmmC); - e->vrcp14ss(xmmA, xmmB, anyptr_gpC); - e->vrcp28pd(zmmA, zmmB); - e->vrcp28pd(zmmA, anyptr_gpB); - e->vrcp28ps(zmmA, zmmB); - e->vrcp28ps(zmmA, anyptr_gpB); - e->vrcp28sd(xmmA, xmmB, xmmC); - e->vrcp28sd(xmmA, xmmB, anyptr_gpC); - e->vrcp28ss(xmmA, xmmB, xmmC); - e->vrcp28ss(xmmA, xmmB, anyptr_gpC); - e->vreducepd(xmmA, xmmB, 0); - e->vreducepd(xmmA, anyptr_gpB, 0); - e->vreducepd(ymmA, ymmB, 0); - e->vreducepd(ymmA, anyptr_gpB, 0); - e->vreducepd(zmmA, zmmB, 0); - e->vreducepd(zmmA, anyptr_gpB, 0); - e->vreduceps(xmmA, xmmB, 0); - e->vreduceps(xmmA, anyptr_gpB, 0); - e->vreduceps(ymmA, ymmB, 0); - e->vreduceps(ymmA, anyptr_gpB, 0); - e->vreduceps(zmmA, zmmB, 0); - e->vreduceps(zmmA, anyptr_gpB, 0); - e->vreducesd(xmmA, xmmB, xmmC, 0); - e->vreducesd(xmmA, xmmB, anyptr_gpC, 0); - e->vreducess(xmmA, xmmB, xmmC, 0); - e->vreducess(xmmA, xmmB, anyptr_gpC, 0); - e->vrndscalepd(xmmA, xmmB, 0); - e->vrndscalepd(xmmA, anyptr_gpB, 0); - e->vrndscalepd(ymmA, ymmB, 0); - e->vrndscalepd(ymmA, anyptr_gpB, 0); - e->vrndscalepd(zmmA, zmmB, 0); - e->vrndscalepd(zmmA, anyptr_gpB, 0); - e->vrndscaleps(xmmA, xmmB, 0); - e->vrndscaleps(xmmA, anyptr_gpB, 0); - e->vrndscaleps(ymmA, ymmB, 0); - e->vrndscaleps(ymmA, anyptr_gpB, 0); - e->vrndscaleps(zmmA, zmmB, 0); - e->vrndscaleps(zmmA, anyptr_gpB, 0); - e->vrndscalesd(xmmA, xmmB, xmmC, 0); - e->vrndscalesd(xmmA, xmmB, anyptr_gpC, 0); - e->vrndscaless(xmmA, xmmB, xmmC, 0); - e->vrndscaless(xmmA, xmmB, anyptr_gpC, 0); - e->vrsqrt14pd(xmmA, xmmB); - e->vrsqrt14pd(xmmA, anyptr_gpB); - e->vrsqrt14pd(ymmA, ymmB); - e->vrsqrt14pd(ymmA, anyptr_gpB); - e->vrsqrt14pd(zmmA, zmmB); - e->vrsqrt14pd(zmmA, anyptr_gpB); - e->vrsqrt14ps(xmmA, xmmB); - e->vrsqrt14ps(xmmA, anyptr_gpB); - e->vrsqrt14ps(ymmA, ymmB); - e->vrsqrt14ps(ymmA, anyptr_gpB); - e->vrsqrt14ps(zmmA, zmmB); - e->vrsqrt14ps(zmmA, anyptr_gpB); - e->vrsqrt14sd(xmmA, xmmB, xmmC); - e->vrsqrt14sd(xmmA, xmmB, anyptr_gpC); - e->vrsqrt14ss(xmmA, xmmB, xmmC); - e->vrsqrt14ss(xmmA, xmmB, anyptr_gpC); - e->vrsqrt28pd(zmmA, zmmB); - e->vrsqrt28pd(zmmA, anyptr_gpB); - e->vrsqrt28ps(zmmA, zmmB); - e->vrsqrt28ps(zmmA, anyptr_gpB); - e->vrsqrt28sd(xmmA, xmmB, xmmC); - e->vrsqrt28sd(xmmA, xmmB, anyptr_gpC); - e->vrsqrt28ss(xmmA, xmmB, xmmC); - e->vrsqrt28ss(xmmA, xmmB, anyptr_gpC); - e->vscalefpd(xmmA, xmmB, xmmC); - e->vscalefpd(xmmA, xmmB, anyptr_gpC); - e->vscalefpd(ymmA, ymmB, ymmC); - e->vscalefpd(ymmA, ymmB, anyptr_gpC); - e->vscalefpd(zmmA, zmmB, zmmC); - e->vscalefpd(zmmA, zmmB, anyptr_gpC); - e->vscalefps(xmmA, xmmB, xmmC); - e->vscalefps(xmmA, xmmB, anyptr_gpC); - e->vscalefps(ymmA, ymmB, ymmC); - e->vscalefps(ymmA, ymmB, anyptr_gpC); - e->vscalefps(zmmA, zmmB, zmmC); - e->vscalefps(zmmA, zmmB, anyptr_gpC); - e->vscalefsd(xmmA, xmmB, xmmC); - e->vscalefsd(xmmA, xmmB, anyptr_gpC); - e->vscalefss(xmmA, xmmB, xmmC); - e->vscalefss(xmmA, xmmB, anyptr_gpC); - e->vscatterdpd(vx_ptr, xmmB); - e->vscatterdpd(vx_ptr, ymmB); - e->vscatterdpd(vy_ptr, zmmB); - e->vscatterdps(vx_ptr, xmmB); - e->vscatterdps(vy_ptr, ymmB); - e->vscatterdps(vz_ptr, zmmB); - e->vscatterpf0dpd(vy_ptr); - e->vscatterpf0dps(vz_ptr); - e->vscatterpf0qpd(vz_ptr); - e->vscatterpf0qps(vz_ptr); - e->vscatterpf1dpd(vy_ptr); - e->vscatterpf1dps(vz_ptr); - e->vscatterpf1qpd(vz_ptr); - e->vscatterpf1qps(vz_ptr); - e->vscatterqpd(vx_ptr, xmmB); - e->vscatterqpd(vy_ptr, ymmB); - e->vscatterqpd(vz_ptr, zmmB); - e->vscatterqps(vx_ptr, xmmB); - e->vscatterqps(vy_ptr, xmmB); - e->vscatterqps(vz_ptr, ymmB); - e->vshuff32x4(ymmA, ymmB, ymmC, 0); - e->vshuff32x4(ymmA, ymmB, anyptr_gpC, 0); - e->vshuff32x4(zmmA, zmmB, zmmC, 0); - e->vshuff32x4(zmmA, zmmB, anyptr_gpC, 0); - e->vshuff64x2(ymmA, ymmB, ymmC, 0); - e->vshuff64x2(ymmA, ymmB, anyptr_gpC, 0); - e->vshuff64x2(zmmA, zmmB, zmmC, 0); - e->vshuff64x2(zmmA, zmmB, anyptr_gpC, 0); - e->vshufi32x4(ymmA, ymmB, ymmC, 0); - e->vshufi32x4(ymmA, ymmB, anyptr_gpC, 0); - e->vshufi32x4(zmmA, zmmB, zmmC, 0); - e->vshufi32x4(zmmA, zmmB, anyptr_gpC, 0); - e->vshufi64x2(ymmA, ymmB, ymmC, 0); - e->vshufi64x2(ymmA, ymmB, anyptr_gpC, 0); - e->vshufi64x2(zmmA, zmmB, zmmC, 0); - e->vshufi64x2(zmmA, zmmB, anyptr_gpC, 0); - e->vshufpd(xmmA, xmmB, xmmC, 0); - e->vshufpd(xmmA, xmmB, anyptr_gpC, 0); - e->vshufpd(ymmA, ymmB, ymmC, 0); - e->vshufpd(ymmA, ymmB, anyptr_gpC, 0); - e->vshufpd(zmmA, zmmB, zmmC, 0); - e->vshufpd(zmmA, zmmB, anyptr_gpC, 0); - e->vshufps(xmmA, xmmB, xmmC, 0); - e->vshufps(xmmA, xmmB, anyptr_gpC, 0); - e->vshufps(ymmA, ymmB, ymmC, 0); - e->vshufps(ymmA, ymmB, anyptr_gpC, 0); - e->vshufps(zmmA, zmmB, zmmC, 0); - e->vshufps(zmmA, zmmB, anyptr_gpC, 0); - e->vsqrtpd(xmmA, xmmB); - e->vsqrtpd(xmmA, anyptr_gpB); - e->vsqrtpd(ymmA, ymmB); - e->vsqrtpd(ymmA, anyptr_gpB); - e->vsqrtpd(zmmA, zmmB); - e->vsqrtpd(zmmA, anyptr_gpB); - e->vsqrtps(xmmA, xmmB); - e->vsqrtps(xmmA, anyptr_gpB); - e->vsqrtps(ymmA, ymmB); - e->vsqrtps(ymmA, anyptr_gpB); - e->vsqrtps(zmmA, zmmB); - e->vsqrtps(zmmA, anyptr_gpB); - e->vsqrtsd(xmmA, xmmB, xmmC); - e->vsqrtsd(xmmA, xmmB, anyptr_gpC); - e->vsqrtss(xmmA, xmmB, xmmC); - e->vsqrtss(xmmA, xmmB, anyptr_gpC); - e->vsubpd(xmmA, xmmB, xmmC); - e->vsubpd(xmmA, xmmB, anyptr_gpC); - e->vsubpd(ymmA, ymmB, ymmC); - e->vsubpd(ymmA, ymmB, anyptr_gpC); - e->vsubpd(zmmA, zmmB, zmmC); - e->vsubpd(zmmA, zmmB, anyptr_gpC); - e->vsubps(xmmA, xmmB, xmmC); - e->vsubps(xmmA, xmmB, anyptr_gpC); - e->vsubps(ymmA, ymmB, ymmC); - e->vsubps(ymmA, ymmB, anyptr_gpC); - e->vsubps(zmmA, zmmB, zmmC); - e->vsubps(zmmA, zmmB, anyptr_gpC); - e->vsubsd(xmmA, xmmB, xmmC); - e->vsubsd(xmmA, xmmB, anyptr_gpC); - e->vsubss(xmmA, xmmB, xmmC); - e->vsubss(xmmA, xmmB, anyptr_gpC); - e->vucomisd(xmmA, xmmB); - e->vucomisd(xmmA, anyptr_gpB); - e->vucomiss(xmmA, xmmB); - e->vucomiss(xmmA, anyptr_gpB); - e->vunpckhpd(xmmA, xmmB, xmmC); - e->vunpckhpd(xmmA, xmmB, anyptr_gpC); - e->vunpckhpd(ymmA, ymmB, ymmC); - e->vunpckhpd(ymmA, ymmB, anyptr_gpC); - e->vunpckhpd(zmmA, zmmB, zmmC); - e->vunpckhpd(zmmA, zmmB, anyptr_gpC); - e->vunpckhps(xmmA, xmmB, xmmC); - e->vunpckhps(xmmA, xmmB, anyptr_gpC); - e->vunpckhps(ymmA, ymmB, ymmC); - e->vunpckhps(ymmA, ymmB, anyptr_gpC); - e->vunpckhps(zmmA, zmmB, zmmC); - e->vunpckhps(zmmA, zmmB, anyptr_gpC); - e->vunpcklpd(xmmA, xmmB, xmmC); - e->vunpcklpd(xmmA, xmmB, anyptr_gpC); - e->vunpcklpd(ymmA, ymmB, ymmC); - e->vunpcklpd(ymmA, ymmB, anyptr_gpC); - e->vunpcklpd(zmmA, zmmB, zmmC); - e->vunpcklpd(zmmA, zmmB, anyptr_gpC); - e->vunpcklps(xmmA, xmmB, xmmC); - e->vunpcklps(xmmA, xmmB, anyptr_gpC); - e->vunpcklps(ymmA, ymmB, ymmC); - e->vunpcklps(ymmA, ymmB, anyptr_gpC); - e->vunpcklps(zmmA, zmmB, zmmC); - e->vunpcklps(zmmA, zmmB, anyptr_gpC); - e->vxorpd(xmmA, xmmB, xmmC); - e->vxorpd(xmmA, xmmB, anyptr_gpC); - e->vxorpd(ymmA, ymmB, ymmC); - e->vxorpd(ymmA, ymmB, anyptr_gpC); - e->vxorpd(zmmA, zmmB, zmmC); - e->vxorpd(zmmA, zmmB, anyptr_gpC); - e->vxorps(xmmA, xmmB, xmmC); - e->vxorps(xmmA, xmmB, anyptr_gpC); - e->vxorps(ymmA, ymmB, ymmC); - e->vxorps(ymmA, ymmB, anyptr_gpC); - e->vxorps(zmmA, zmmB, zmmC); - e->vxorps(zmmA, zmmB, anyptr_gpC); - - // Mark the end. - e->nop(); - e->nop(); - e->nop(); - e->nop(); -} - -} // {asmtest} - -#endif // ASMJIT_TEST_OPCODE_H_INCLUDED diff --git a/3rdparty/asmjit/test/asmjit_test_perf.cpp b/3rdparty/asmjit/test/asmjit_test_perf.cpp new file mode 100644 index 00000000000..ab965948f40 --- /dev/null +++ b/3rdparty/asmjit/test/asmjit_test_perf.cpp @@ -0,0 +1,62 @@ +// This file is part of AsmJit project <https://asmjit.com> +// +// See asmjit.h or LICENSE.md for license and copyright information +// SPDX-License-Identifier: Zlib + +#include <asmjit/core.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> + +#include "cmdline.h" + +using namespace asmjit; + +#if !defined(ASMJIT_NO_X86) +void benchmarkX86Emitters(uint32_t numIterations, bool testX86, bool testX64) noexcept; +#endif + +#if !defined(ASMJIT_NO_AARCH64) +void benchmarkA64Emitters(uint32_t numIterations); +#endif + +int main(int argc, char* argv[]) { + CmdLine cmdLine(argc, argv); + uint32_t numIterations = 20000; + + printf("AsmJit Performance Suite v%u.%u.%u:\n\n", + unsigned((ASMJIT_LIBRARY_VERSION >> 16) ), + unsigned((ASMJIT_LIBRARY_VERSION >> 8) & 0xFF), + unsigned((ASMJIT_LIBRARY_VERSION ) & 0xFF)); + + printf("Usage:\n"); + printf(" --help Show usage only\n"); + printf(" --quick Decrease the number of iterations to make tests quicker\n"); + printf(" --arch=<ARCH> Select architecture to run ('all' by default)\n"); + printf("\n"); + + if (cmdLine.hasArg("--help")) + return 0; + + if (cmdLine.hasArg("--quick")) + numIterations = 1000; + + const char* arch = cmdLine.valueOf("--arch", "all"); + +#if !defined(ASMJIT_NO_X86) + bool testX86 = strcmp(arch, "all") == 0 || strcmp(arch, "x86") == 0; + bool testX64 = strcmp(arch, "all") == 0 || strcmp(arch, "x64") == 0; + + if (testX86 || testX64) + benchmarkX86Emitters(numIterations, testX86, testX64); +#endif + +#if !defined(ASMJIT_NO_AARCH64) + bool testAArch64 = strcmp(arch, "all") == 0 || strcmp(arch, "aarch64") == 0; + + if (testAArch64) + benchmarkA64Emitters(numIterations); +#endif + + return 0; +} diff --git a/3rdparty/asmjit/test/asmjit_test_perf.h b/3rdparty/asmjit/test/asmjit_test_perf.h new file mode 100644 index 00000000000..2ab0038ed31 --- /dev/null +++ b/3rdparty/asmjit/test/asmjit_test_perf.h @@ -0,0 +1,61 @@ +// This file is part of AsmJit project <https://asmjit.com> +// +// See asmjit.h or LICENSE.md for license and copyright information +// SPDX-License-Identifier: Zlib + +#ifndef ASMJIT_TEST_PERF_H_INCLUDED +#define ASMJIT_TEST_PERF_H_INCLUDED + +#include <asmjit/core.h> +#include "asmjitutils.h" +#include "performancetimer.h" + +class MyErrorHandler : public asmjit::ErrorHandler { + void handleError(asmjit::Error err, const char* message, asmjit::BaseEmitter* origin) { + (void)err; + (void)origin; + printf("ERROR: %s\n", message); + abort(); + } +}; + +template<typename EmitterT, typename FuncT> +static void bench(asmjit::CodeHolder& code, asmjit::Arch arch, uint32_t numIterations, const char* testName, const FuncT& func) noexcept { + EmitterT emitter; + MyErrorHandler eh; + + const char* archName = asmjitArchAsString(arch); + const char* emitterName = + emitter.isAssembler() ? "Assembler" : + emitter.isCompiler() ? "Compiler" : + emitter.isBuilder() ? "Builder" : "Unknown"; + + uint64_t codeSize = 0; + asmjit::Environment env(arch); + + PerformanceTimer timer; + double duration = std::numeric_limits<double>::infinity(); + + for (uint32_t r = 0; r < numIterations; r++) { + codeSize = 0; + code.init(env); + code.setErrorHandler(&eh); + code.attach(&emitter); + + timer.start(); + func(emitter); + timer.stop(); + + codeSize += code.codeSize(); + + code.reset(); + duration = asmjit::Support::min(duration, timer.duration()); + } + + printf(" [%s] %-9s %-16s | CodeSize:%5llu [B] | Time:%8.4f [ms]", archName, emitterName, testName, (unsigned long long)codeSize, duration); + if (codeSize) + printf(" | Speed:%8.3f [MB/s]", mbps(duration, codeSize)); + printf("\n"); +} + +#endif // ASMJIT_TEST_PERF_H_INCLUDED diff --git a/3rdparty/asmjit/test/asmjit_test_perf_a64.cpp b/3rdparty/asmjit/test/asmjit_test_perf_a64.cpp new file mode 100644 index 00000000000..4f4aebb6e72 --- /dev/null +++ b/3rdparty/asmjit/test/asmjit_test_perf_a64.cpp @@ -0,0 +1,699 @@ +// This file is part of AsmJit project <https://asmjit.com> +// +// See asmjit.h or LICENSE.md for license and copyright information +// SPDX-License-Identifier: Zlib + +#include <asmjit/core.h> + +#if !defined(ASMJIT_NO_AARCH64) +#include <asmjit/a64.h> + +#include <limits> +#include <stdio.h> +#include <string.h> + +#include "asmjit_test_perf.h" + +using namespace asmjit; + +// Generates a long sequence of GP instructions. +template<typename Emitter> +static void generateGpSequenceInternal( + Emitter& cc, + const a64::Gp& a, const a64::Gp& b, const a64::Gp& c, const a64::Gp& d) { + + using namespace asmjit::a64; + + Gp wA = a.w(); + Gp wB = b.w(); + Gp wC = c.w(); + Gp wD = d.w(); + + Gp xA = a.x(); + Gp xB = b.x(); + Gp xC = c.x(); + Gp xD = d.x(); + + Mem m = ptr(xD); + + cc.mov(wA, 0); + cc.mov(wB, 1); + cc.mov(wC, 2); + cc.mov(wD, 3); + + cc.adc(wA, wB, wC); + cc.adc(xA, xB, xC); + cc.adc(wA, wzr, wC); + cc.adc(xA, xzr, xC); + cc.adc(wzr, wB, wC); + cc.adc(xzr, xB, xC); + cc.adcs(wA, wB, wC); + cc.adcs(xA, xB, xC); + cc.add(wA, wB, wC); + cc.add(xA, xB, xC); + cc.add(wA, wB, wC, lsl(3)); + cc.add(xA, xB, xC, lsl(3)); + cc.add(wA, wzr, wC); + cc.add(xA, xzr, xC); + cc.add(wzr, wB, wC); + cc.add(xzr, xB, xC); + cc.add(wC, wD, 0, lsl(12)); + cc.add(xC, xD, 0, lsl(12)); + cc.add(wC, wD, 1024, lsl(12)); + cc.add(xC, xD, 1024, lsl(12)); + cc.add(wC, wD, 1024, lsl(12)); + cc.add(xC, xD, 1024, lsl(12)); + cc.adds(wA, wB, wC); + cc.adds(xA, xB, xC); + cc.adr(xA, 0); + cc.adr(xA, 256); + cc.adrp(xA, 4096); + cc.and_(wA, wB, wC); + cc.and_(xA, xB, xC); + cc.and_(wA, wB, 1); + cc.and_(xA, xB, 1); + cc.and_(wA, wB, 15); + cc.and_(xA, xB, 15); + cc.and_(wA, wzr, wC); + cc.and_(xA, xzr, xC); + cc.and_(wzr, wB, wC); + cc.and_(xzr, xB, xC); + cc.and_(wA, wB, 0x1); + cc.and_(xA, xB, 0x1); + cc.and_(wA, wB, 0xf); + cc.and_(xA, xB, 0xf); + cc.ands(wA, wB, wC); + cc.ands(xA, xB, xC); + cc.ands(wA, wzr, wC); + cc.ands(xA, xzr, xC); + cc.ands(wzr, wB, wC); + cc.ands(xzr, xB, xC); + cc.ands(wA, wB, 0x1); + cc.ands(xA, xB, 0x1); + cc.ands(wA, wB, 0xf); + cc.ands(xA, xB, 0xf); + cc.asr(wA, wB, 15); + cc.asr(xA, xB, 15); + cc.asrv(wA, wB, wC); + cc.asrv(xA, xB, xC); + cc.bfc(wA, 8, 16); + cc.bfc(xA, 8, 16); + cc.bfi(wA, wB, 8, 16); + cc.bfi(xA, xB, 8, 16); + cc.bfm(wA, wB, 8, 16); + cc.bfm(xA, xB, 8, 16); + cc.bfxil(wA, wB, 8, 16); + cc.bfxil(xA, xB, 8, 16); + cc.bic(wA, wB, wC, lsl(4)); + cc.bic(xA, xB, xC, lsl(4)); + cc.bic(wA, wzr, wC); + cc.bic(xA, xzr, xC); + cc.bics(wA, wB, wC, lsl(4)); + cc.bics(xA, xB, xC, lsl(4)); + cc.bics(wA, wzr, wC); + cc.bics(xA, xzr, xC); + cc.cas(wA, wB, m); + cc.cas(xA, xB, m); + cc.casa(wA, wB, m); + cc.casa(xA, xB, m); + cc.casab(wA, wB, m); + cc.casah(wA, wB, m); + cc.casal(wA, wB, m); + cc.casal(xA, xB, m); + cc.casalb(wA, wB, m); + cc.casalh(wA, wB, m); + cc.casb(wA, wB, m); + cc.cash(wA, wB, m); + cc.casl(wA, wB, m); + cc.casl(xA, xB, m); + cc.caslb(wA, wB, m); + cc.caslh(wA, wB, m); + cc.casp(wA, wB, wC, wD, m); + cc.casp(xA, xB, xC, xD, m); + cc.caspa(wA, wB, wC, wD, m); + cc.caspa(xA, xB, xC, xD, m); + cc.caspal(wA, wB, wC, wD, m); + cc.caspal(xA, xB, xC, xD, m); + cc.caspl(wA, wB, wC, wD, m); + cc.caspl(xA, xB, xC, xD, m); + cc.ccmn(wA, wB, 3, CondCode::kEQ); + cc.ccmn(xA, xB, 3, CondCode::kEQ); + cc.ccmn(wA, 2, 3, CondCode::kEQ); + cc.ccmn(xA, 2, 3, CondCode::kEQ); + cc.ccmn(wA, wzr, 3, CondCode::kEQ); + cc.ccmn(xA, xzr, 3, CondCode::kEQ); + cc.ccmp(wA, wB, 3, CondCode::kEQ); + cc.ccmp(xA, xB, 3, CondCode::kEQ); + cc.ccmp(wA, 2, 3, CondCode::kEQ); + cc.ccmp(xA, 2, 3, CondCode::kEQ); + cc.ccmp(wA, wzr, 3, CondCode::kEQ); + cc.ccmp(xA, xzr, 3, CondCode::kEQ); + cc.cinc(wA, wB, CondCode::kEQ); + cc.cinc(xA, xB, CondCode::kEQ); + cc.cinc(wzr, wB, CondCode::kEQ); + cc.cinc(wA, wzr, CondCode::kEQ); + cc.cinc(xzr, xB, CondCode::kEQ); + cc.cinc(xA, xzr, CondCode::kEQ); + cc.cinv(wA, wB, CondCode::kEQ); + cc.cinv(xA, xB, CondCode::kEQ); + cc.cinv(wzr, wB, CondCode::kEQ); + cc.cinv(wA, wzr, CondCode::kEQ); + cc.cinv(xzr, xB, CondCode::kEQ); + cc.cinv(xA, xzr, CondCode::kEQ); + cc.cls(wA, wB); + cc.cls(xA, xB); + cc.cls(wA, wzr); + cc.cls(xA, xzr); + cc.cls(wzr, wB); + cc.cls(xzr, xB); + cc.clz(wA, wB); + cc.clz(xA, xB); + cc.clz(wA, wzr); + cc.clz(xA, xzr); + cc.clz(wzr, wB); + cc.clz(xzr, xB); + cc.cmn(wA, 33); + cc.cmn(xA, 33); + cc.cmn(wA, wB); + cc.cmn(xA, xB); + cc.cmn(wA, wB, uxtb(2)); + cc.cmn(xA, xB, uxtb(2)); + cc.cmp(wA, 33); + cc.cmp(xA, 33); + cc.cmp(wA, wB); + cc.cmp(xA, xB); + cc.cmp(wA, wB, uxtb(2)); + cc.cmp(xA, xB, uxtb(2)); + cc.crc32b(wA, wB, wC); + cc.crc32b(wzr, wB, wC); + cc.crc32b(wA, wzr, wC); + cc.crc32b(wA, wB, wzr); + cc.crc32cb(wA, wB, wC); + cc.crc32cb(wzr, wB, wC); + cc.crc32cb(wA, wzr, wC); + cc.crc32cb(wA, wB, wzr); + cc.crc32ch(wA, wB, wC); + cc.crc32ch(wzr, wB, wC); + cc.crc32ch(wA, wzr, wC); + cc.crc32ch(wA, wB, wzr); + cc.crc32cw(wA, wB, wC); + cc.crc32cw(wzr, wB, wC); + cc.crc32cw(wA, wzr, wC); + cc.crc32cw(wA, wB, wzr); + cc.crc32cx(wA, wB, xC); + cc.crc32cx(wzr, wB, xC); + cc.crc32cx(wA, wzr, xC); + cc.crc32cx(wA, wB, xzr); + cc.crc32h(wA, wB, wC); + cc.crc32h(wzr, wB, wC); + cc.crc32h(wA, wzr, wC); + cc.crc32h(wA, wB, wzr); + cc.crc32w(wA, wB, wC); + cc.crc32w(wzr, wB, wC); + cc.crc32w(wA, wzr, wC); + cc.crc32w(wA, wB, wzr); + cc.crc32x(wA, wB, xC); + cc.crc32x(wzr, wB, xC); + cc.crc32x(wA, wzr, xC); + cc.crc32x(wA, wB, xzr); + cc.csel(wA, wB, wC, CondCode::kEQ); + cc.csel(xA, xB, xC, CondCode::kEQ); + cc.cset(wA, CondCode::kEQ); + cc.cset(xA, CondCode::kEQ); + cc.cset(wA, CondCode::kEQ); + cc.cset(xA, CondCode::kEQ); + cc.csetm(wA, CondCode::kEQ); + cc.csetm(xA, CondCode::kEQ); + cc.csinc(wA, wB, wC, CondCode::kEQ); + cc.csinc(xA, xB, xC, CondCode::kEQ); + cc.csinv(wA, wB, wC, CondCode::kEQ); + cc.csinv(xA, xB, xC, CondCode::kEQ); + cc.csneg(wA, wB, wC, CondCode::kEQ); + cc.csneg(xA, xB, xC, CondCode::kEQ); + cc.eon(wA, wB, wC); + cc.eon(wzr, wB, wC); + cc.eon(wA, wzr, wC); + cc.eon(wA, wB, wzr); + cc.eon(wA, wB, wC, lsl(4)); + cc.eon(xA, xB, xC); + cc.eon(xzr, xB, xC); + cc.eon(xA, xzr, xC); + cc.eon(xA, xB, xzr); + cc.eon(xA, xB, xC, lsl(4)); + cc.eor(wA, wB, wC); + cc.eor(wzr, wB, wC); + cc.eor(wA, wzr, wC); + cc.eor(wA, wB, wzr); + cc.eor(xA, xB, xC); + cc.eor(xzr, xB, xC); + cc.eor(xA, xzr, xC); + cc.eor(xA, xB, xzr); + cc.eor(wA, wB, wC, lsl(4)); + cc.eor(xA, xB, xC, lsl(4)); + cc.eor(wA, wB, 0x4000); + cc.eor(xA, xB, 0x8000); + cc.extr(wA, wB, wC, 15); + cc.extr(wzr, wB, wC, 15); + cc.extr(wA, wzr, wC, 15); + cc.extr(wA, wB, wzr, 15); + cc.extr(xA, xB, xC, 15); + cc.extr(xzr, xB, xC, 15); + cc.extr(xA, xzr, xC, 15); + cc.extr(xA, xB, xzr, 15); + cc.ldadd(wA, wB, m); + cc.ldadd(xA, xB, m); + cc.ldadda(wA, wB, m); + cc.ldadda(xA, xB, m); + cc.ldaddab(wA, wB, m); + cc.ldaddah(wA, wB, m); + cc.ldaddal(wA, wB, m); + cc.ldaddal(xA, xB, m); + cc.ldaddalb(wA, wB, m); + cc.ldaddalh(wA, wB, m); + cc.ldaddb(wA, wB, m); + cc.ldaddh(wA, wB, m); + cc.ldaddl(wA, wB, m); + cc.ldaddl(xA, xB, m); + cc.ldaddlb(wA, wB, m); + cc.ldaddlh(wA, wB, m); + cc.ldclr(wA, wB, m); + cc.ldclr(xA, xB, m); + cc.ldclra(wA, wB, m); + cc.ldclra(xA, xB, m); + cc.ldclrab(wA, wB, m); + cc.ldclrah(wA, wB, m); + cc.ldclral(wA, wB, m); + cc.ldclral(xA, xB, m); + cc.ldclralb(wA, wB, m); + cc.ldclralh(wA, wB, m); + cc.ldclrb(wA, wB, m); + cc.ldclrh(wA, wB, m); + cc.ldclrl(wA, wB, m); + cc.ldclrl(xA, xB, m); + cc.ldclrlb(wA, wB, m); + cc.ldclrlh(wA, wB, m); + cc.ldeor(wA, wB, m); + cc.ldeor(xA, xB, m); + cc.ldeora(wA, wB, m); + cc.ldeora(xA, xB, m); + cc.ldeorab(wA, wB, m); + cc.ldeorah(wA, wB, m); + cc.ldeoral(wA, wB, m); + cc.ldeoral(xA, xB, m); + cc.ldeoralb(wA, wB, m); + cc.ldeoralh(wA, wB, m); + cc.ldeorb(wA, wB, m); + cc.ldeorh(wA, wB, m); + cc.ldeorl(wA, wB, m); + cc.ldeorl(xA, xB, m); + cc.ldeorlb(wA, wB, m); + cc.ldeorlh(wA, wB, m); + cc.ldlar(wA, m); + cc.ldlar(xA, m); + cc.ldlarb(wA, m); + cc.ldlarh(wA, m); + cc.ldnp(wA, wB, m); + cc.ldnp(xA, xB, m); + cc.ldp(wA, wB, m); + cc.ldp(xA, xB, m); + cc.ldpsw(xA, xB, m); + cc.ldr(wA, m); + cc.ldr(xA, m); + cc.ldrb(wA, m); + cc.ldrh(wA, m); + cc.ldrsw(xA, m); + cc.ldraa(xA, m); + cc.ldrab(xA, m); + cc.ldset(wA, wB, m); + cc.ldset(xA, xB, m); + cc.ldseta(wA, wB, m); + cc.ldseta(xA, xB, m); + cc.ldsetab(wA, wB, m); + cc.ldsetah(wA, wB, m); + cc.ldsetal(wA, wB, m); + cc.ldsetal(xA, xB, m); + cc.ldsetalh(wA, wB, m); + cc.ldsetalb(wA, wB, m); + cc.ldsetb(wA, wB, m); + cc.ldseth(wA, wB, m); + cc.ldsetl(wA, wB, m); + cc.ldsetl(xA, xB, m); + cc.ldsetlb(wA, wB, m); + cc.ldsetlh(wA, wB, m); + cc.ldsmax(wA, wB, m); + cc.ldsmax(xA, xB, m); + cc.ldsmaxa(wA, wB, m); + cc.ldsmaxa(xA, xB, m); + cc.ldsmaxab(wA, wB, m); + cc.ldsmaxah(wA, wB, m); + cc.ldsmaxal(wA, wB, m); + cc.ldsmaxal(xA, xB, m); + cc.ldsmaxalb(wA, wB, m); + cc.ldsmaxalh(wA, wB, m); + cc.ldsmaxb(wA, wB, m); + cc.ldsmaxh(wA, wB, m); + cc.ldsmaxl(wA, wB, m); + cc.ldsmaxl(xA, xB, m); + cc.ldsmaxlb(wA, wB, m); + cc.ldsmaxlh(wA, wB, m); + cc.ldsmin(wA, wB, m); + cc.ldsmin(xA, xB, m); + cc.ldsmina(wA, wB, m); + cc.ldsmina(xA, xB, m); + cc.ldsminab(wA, wB, m); + cc.ldsminah(wA, wB, m); + cc.ldsminal(wA, wB, m); + cc.ldsminal(xA, xB, m); + cc.ldsminalb(wA, wB, m); + cc.ldsminalh(wA, wB, m); + cc.ldsminb(wA, wB, m); + cc.ldsminh(wA, wB, m); + cc.ldsminl(wA, wB, m); + cc.ldsminl(xA, xB, m); + cc.ldsminlb(wA, wB, m); + cc.ldsminlh(wA, wB, m); + cc.ldtr(wA, m); + cc.ldtr(xA, m); + cc.ldtrb(wA, m); + cc.ldtrh(wA, m); + cc.ldtrsb(wA, m); + cc.ldtrsh(wA, m); + cc.ldtrsw(xA, m); + cc.ldumax(wA, wB, m); + cc.ldumax(xA, xB, m); + cc.ldumaxa(wA, wB, m); + cc.ldumaxa(xA, xB, m); + cc.ldumaxab(wA, wB, m); + cc.ldumaxah(wA, wB, m); + cc.ldumaxal(wA, wB, m); + cc.ldumaxal(xA, xB, m); + cc.ldumaxalb(wA, wB, m); + cc.ldumaxalh(wA, wB, m); + cc.ldumaxb(wA, wB, m); + cc.ldumaxh(wA, wB, m); + cc.ldumaxl(wA, wB, m); + cc.ldumaxl(xA, xB, m); + cc.ldumaxlb(wA, wB, m); + cc.ldumaxlh(wA, wB, m); + cc.ldumin(wA, wB, m); + cc.ldumin(xA, xB, m); + cc.ldumina(wA, wB, m); + cc.ldumina(xA, xB, m); + cc.lduminab(wA, wB, m); + cc.lduminah(wA, wB, m); + cc.lduminal(wA, wB, m); + cc.lduminal(xA, xB, m); + cc.lduminalb(wA, wB, m); + cc.lduminalh(wA, wB, m); + cc.lduminb(wA, wB, m); + cc.lduminh(wA, wB, m); + cc.lduminl(wA, wB, m); + cc.lduminl(xA, xB, m); + cc.lduminlb(wA, wB, m); + cc.lduminlh(wA, wB, m); + cc.ldur(wA, m); + cc.ldur(xA, m); + cc.ldurb(wA, m); + cc.ldurh(wA, m); + cc.ldursb(wA, m); + cc.ldursh(wA, m); + cc.ldursw(xA, m); + cc.ldxp(wA, wB, m); + cc.ldxp(xA, xB, m); + cc.ldxr(wA, m); + cc.ldxr(xA, m); + cc.ldxrb(wA, m); + cc.ldxrh(wA, m); + cc.lsl(wA, wB, wC); + cc.lsl(xA, xB, xC); + cc.lsl(wA, wB, 15); + cc.lsl(xA, xB, 15); + cc.lslv(wA, wB, wC); + cc.lslv(xA, xB, xC); + cc.lsr(wA, wB, wC); + cc.lsr(xA, xB, xC); + cc.lsr(wA, wB, 15); + cc.lsr(xA, xB, 15); + cc.lsrv(wA, wB, wC); + cc.lsrv(xA, xB, xC); + cc.madd(wA, wB, wC, wD); + cc.madd(xA, xB, xC, xD); + cc.mneg(wA, wB, wC); + cc.mneg(xA, xB, xC); + cc.mov(wA, wB); + cc.mov(xA, xB); + cc.mov(wA, 0); + cc.mov(wA, 1); + cc.mov(wA, 2); + cc.mov(wA, 3); + cc.mov(wA, 4); + cc.mov(wA, 5); + cc.mov(wA, 6); + cc.mov(wA, 7); + cc.mov(wA, 8); + cc.mov(wA, 9); + cc.mov(wA, 10); + cc.mov(wA, 0xA234); + cc.mov(xA, 0xA23400000000); + cc.msub(wA, wB, wC, wD); + cc.msub(xA, xB, xC, xD); + cc.mul(wA, wB, wC); + cc.mul(xA, xB, xC); + cc.mvn(wA, wB); + cc.mvn(xA, xB); + cc.mvn(wA, wB, lsl(4)); + cc.mvn(xA, xB, lsl(4)); + cc.neg(wA, wB); + cc.neg(xA, xB); + cc.neg(wA, wB, lsl(4)); + cc.neg(xA, xB, lsl(4)); + cc.negs(wA, wB); + cc.negs(xA, xB); + cc.negs(wA, wB, lsl(4)); + cc.negs(xA, xB, lsl(4)); + cc.ngc(wA, wB); + cc.ngc(xA, xB); + cc.ngcs(wA, wB); + cc.ngcs(xA, xB); + cc.orn(wA, wB, wC); + cc.orn(xA, xB, xC); + cc.orn(wA, wB, wC, lsl(4)); + cc.orn(xA, xB, xC, lsl(4)); + cc.orr(wA, wB, wC); + cc.orr(xA, xB, xC); + cc.orr(wA, wB, wC, lsl(4)); + cc.orr(xA, xB, xC, lsl(4)); + cc.orr(wA, wB, 0x4000); + cc.orr(xA, xB, 0x8000); + cc.rbit(wA, wB); + cc.rbit(xA, xB); + cc.rev(wA, wB); + cc.rev(xA, xB); + cc.rev16(wA, wB); + cc.rev16(xA, xB); + cc.rev32(xA, xB); + cc.rev64(xA, xB); + cc.ror(wA, wB, wC); + cc.ror(xA, xB, xC); + cc.ror(wA, wB, 15); + cc.ror(xA, xB, 15); + cc.rorv(wA, wB, wC); + cc.rorv(xA, xB, xC); + cc.sbc(wA, wB, wC); + cc.sbc(xA, xB, xC); + cc.sbcs(wA, wB, wC); + cc.sbcs(xA, xB, xC); + cc.sbfiz(wA, wB, 5, 10); + cc.sbfiz(xA, xB, 5, 10); + cc.sbfm(wA, wB, 5, 10); + cc.sbfm(xA, xB, 5, 10); + cc.sbfx(wA, wB, 5, 10); + cc.sbfx(xA, xB, 5, 10); + cc.sdiv(wA, wB, wC); + cc.sdiv(xA, xB, xC); + cc.smaddl(xA, wB, wC, xD); + cc.smnegl(xA, wB, wC); + cc.smsubl(xA, wB, wC, xD); + cc.smulh(xA, xB, xC); + cc.smull(xA, wB, wC); + cc.stp(wA, wB, m); + cc.stp(xA, xB, m); + cc.sttr(wA, m); + cc.sttr(xA, m); + cc.sttrb(wA, m); + cc.sttrh(wA, m); + cc.stur(wA, m); + cc.stur(xA, m); + cc.sturb(wA, m); + cc.sturh(wA, m); + cc.stxp(wA, wB, wC, m); + cc.stxp(wA, xB, xC, m); + cc.stxr(wA, wB, m); + cc.stxr(wA, xB, m); + cc.stxrb(wA, wB, m); + cc.stxrh(wA, wB, m); + cc.sub(wA, wB, wC); + cc.sub(xA, xB, xC); + cc.sub(wA, wB, wC, lsl(3)); + cc.sub(xA, xB, xC, lsl(3)); + cc.subg(xA, xB, 32, 11); + cc.subp(xA, xB, xC); + cc.subps(xA, xB, xC); + cc.subs(wA, wB, wC); + cc.subs(xA, xB, xC); + cc.subs(wA, wB, wC, lsl(3)); + cc.subs(xA, xB, xC, lsl(3)); + cc.sxtb(wA, wB); + cc.sxtb(xA, wB); + cc.sxth(wA, wB); + cc.sxth(xA, wB); + cc.sxtw(xA, wB); + cc.tst(wA, 1); + cc.tst(xA, 1); + cc.tst(wA, wB); + cc.tst(xA, xB); + cc.tst(wA, wB, lsl(4)); + cc.tst(xA, xB, lsl(4)); + cc.udiv(wA, wB, wC); + cc.udiv(xA, xB, xC); + cc.ubfiz(wA, wB, 5, 10); + cc.ubfiz(xA, xB, 5, 10); + cc.ubfm(wA, wB, 5, 10); + cc.ubfm(xA, xB, 5, 10); + cc.ubfx(wA, wB, 5, 10); + cc.ubfx(xA, xB, 5, 10); + cc.umaddl(xA, wB, wC, xD); + cc.umnegl(xA, wB, wC); + cc.umsubl(xA, wB, wC, xD); + cc.umulh(xA, xB, xC); + cc.umull(xA, wB, wC); + cc.uxtb(wA, wB); + cc.uxth(wA, wB); +} + +static void generateGpSequence(BaseEmitter& emitter, bool emitPrologEpilog) { + if (emitter.isAssembler()) { + a64::Assembler& cc = *emitter.as<a64::Assembler>(); + + a64::Gp a = a64::x0; + a64::Gp b = a64::x1; + a64::Gp c = a64::x2; + a64::Gp d = a64::x3; + + if (emitPrologEpilog) { + FuncDetail func; + func.init(FuncSignatureT<void, void*, const void*, size_t>(CallConvId::kHost), cc.environment()); + + FuncFrame frame; + frame.init(func); + frame.addDirtyRegs(a, b, c, d); + frame.finalize(); + + cc.emitProlog(frame); + generateGpSequenceInternal(cc, a, b, c, d); + cc.emitEpilog(frame); + } + else { + generateGpSequenceInternal(cc, a, b, c, d); + } + } +#ifndef ASMJIT_NO_BUILDER + else if (emitter.isBuilder()) { + a64::Builder& cc = *emitter.as<a64::Builder>(); + + a64::Gp a = a64::x0; + a64::Gp b = a64::x1; + a64::Gp c = a64::x2; + a64::Gp d = a64::x3; + + if (emitPrologEpilog) { + FuncDetail func; + func.init(FuncSignatureT<void, void*, const void*, size_t>(CallConvId::kHost), cc.environment()); + + FuncFrame frame; + frame.init(func); + frame.addDirtyRegs(a, b, c, d); + frame.finalize(); + + cc.emitProlog(frame); + generateGpSequenceInternal(cc, a, b, c, d); + cc.emitEpilog(frame); + } + else { + generateGpSequenceInternal(cc, a, b, c, d); + } + } +#endif +#ifndef ASMJIT_NO_COMPILER + else if (emitter.isCompiler()) { + a64::Compiler& cc = *emitter.as<a64::Compiler>(); + + a64::Gp a = cc.newIntPtr("a"); + a64::Gp b = cc.newIntPtr("b"); + a64::Gp c = cc.newIntPtr("c"); + a64::Gp d = cc.newIntPtr("d"); + + cc.addFunc(FuncSignatureT<void>(CallConvId::kHost)); + generateGpSequenceInternal(cc, a, b, c, d); + cc.endFunc(); + } +#endif +} + +template<typename EmitterFn> +static void benchmarkA64Function(Arch arch, uint32_t numIterations, const char* description, const EmitterFn& emitterFn) noexcept { + CodeHolder code; + printf("%s:\n", description); + + bench<a64::Assembler>(code, arch, numIterations, "[raw]", [&](a64::Assembler& cc) { + emitterFn(cc, false); + }); + + bench<a64::Assembler>(code, arch, numIterations, "[validated]", [&](a64::Assembler& cc) { + cc.addDiagnosticOptions(DiagnosticOptions::kValidateAssembler); + emitterFn(cc, false); + }); + + bench<a64::Assembler>(code, arch, numIterations, "[prolog/epilog]", [&](a64::Assembler& cc) { + cc.addDiagnosticOptions(DiagnosticOptions::kValidateAssembler); + emitterFn(cc, true); + }); + +#ifndef ASMJIT_NO_BUILDER + bench<a64::Builder>(code, arch, numIterations, "[no-asm]", [&](a64::Builder& cc) { + emitterFn(cc, false); + }); + + bench<a64::Builder>(code, arch, numIterations, "[finalized]", [&](a64::Builder& cc) { + emitterFn(cc, false); + cc.finalize(); + }); + + bench<a64::Builder>(code, arch, numIterations, "[prolog/epilog]", [&](a64::Builder& cc) { + emitterFn(cc, true); + cc.finalize(); + }); +#endif + +#ifndef ASMJIT_NO_COMPILER + bench<a64::Compiler>(code, arch, numIterations, "[no-asm]", [&](a64::Compiler& cc) { + emitterFn(cc, true); + }); + + bench<a64::Compiler>(code, arch, numIterations, "[finalized]", [&](a64::Compiler& cc) { + emitterFn(cc, true); + cc.finalize(); + }); +#endif + + printf("\n"); +} + +void benchmarkA64Emitters(uint32_t numIterations) { + static const char description[] = "GpSequence (Sequence of GP instructions - reg/mem)"; + benchmarkA64Function(Arch::kAArch64, numIterations, description, [](BaseEmitter& emitter, bool emitPrologEpilog) { + generateGpSequence(emitter, emitPrologEpilog); + }); +} + +#endif // !ASMJIT_NO_AARCH64 diff --git a/3rdparty/asmjit/test/asmjit_test_perf_x86.cpp b/3rdparty/asmjit/test/asmjit_test_perf_x86.cpp new file mode 100644 index 00000000000..e2720b7c50a --- /dev/null +++ b/3rdparty/asmjit/test/asmjit_test_perf_x86.cpp @@ -0,0 +1,5032 @@ +// This file is part of AsmJit project <https://asmjit.com> +// +// See asmjit.h or LICENSE.md for license and copyright information +// SPDX-License-Identifier: Zlib + +#include <asmjit/core.h> + +#if !defined(ASMJIT_NO_X86) +#include <asmjit/x86.h> + +#include <limits> +#include <stdio.h> +#include <string.h> + +#include "asmjit_test_misc.h" +#include "asmjit_test_perf.h" + +using namespace asmjit; + +enum class InstForm { + kReg, + kMem +}; + +// Generates a long sequence of GP instructions. +template<typename Emitter> +static void generateGpSequenceInternal( + Emitter& cc, + InstForm form, + const x86::Gp& a, const x86::Gp& b, const x86::Gp& c, const x86::Gp& d) { + + cc.mov(a, 0xAAAAAAAA); + cc.mov(b, 0xBBBBBBBB); + cc.mov(c, 0xCCCCCCCC); + cc.mov(d, 0xFFFFFFFF); + + if (form == InstForm::kReg) { + cc.adc(a, b); + cc.adc(b, c); + cc.adc(c, d); + cc.add(a, b); + cc.add(b, c); + cc.add(c, d); + cc.and_(a, b); + cc.and_(b, c); + cc.and_(c, d); + cc.bsf(a, b); + cc.bsf(b, c); + cc.bsf(c, d); + cc.bsr(a, b); + cc.bsr(b, c); + cc.bsr(c, d); + cc.bswap(a); + cc.bswap(b); + cc.bswap(c); + cc.bt(a, b); + cc.bt(b, c); + cc.bt(c, d); + cc.btc(a, b); + cc.btc(b, c); + cc.btc(c, d); + cc.btr(a, b); + cc.btr(b, c); + cc.btr(c, d); + cc.bts(a, b); + cc.bts(b, c); + cc.bts(c, d); + cc.cmp(a, b); + cc.cmovc(a, b); + cc.cmp(b, c); + cc.cmovc(b, c); + cc.cmp(c, d); + cc.cmovc(c, d); + cc.dec(a); + cc.dec(b); + cc.dec(c); + cc.imul(a, b); + cc.imul(b, c); + cc.imul(c, d); + cc.movsx(a, b.r8Lo()); + cc.movsx(b, c.r8Lo()); + cc.movsx(c, d.r8Lo()); + cc.movzx(a, b.r8Lo()); + cc.movzx(b, c.r8Lo()); + cc.movzx(c, d.r8Lo()); + cc.neg(a); + cc.neg(b); + cc.neg(c); + cc.not_(a); + cc.not_(b); + cc.not_(c); + cc.or_(a, b); + cc.or_(b, c); + cc.or_(c, d); + cc.sbb(a, b); + cc.sbb(b, c); + cc.sbb(c, d); + cc.sub(a, b); + cc.sub(b, c); + cc.sub(c, d); + cc.test(a, b); + cc.test(b, c); + cc.test(c, d); + cc.xchg(a, b); + cc.xchg(b, c); + cc.xchg(c, d); + cc.xor_(a, b); + cc.xor_(b, c); + cc.xor_(c, d); + + cc.rcl(a, c.r8Lo()); + cc.rcl(b, c.r8Lo()); + cc.rcl(d, c.r8Lo()); + cc.rcr(a, c.r8Lo()); + cc.rcr(b, c.r8Lo()); + cc.rcr(d, c.r8Lo()); + cc.rol(a, c.r8Lo()); + cc.rol(b, c.r8Lo()); + cc.rol(d, c.r8Lo()); + cc.ror(a, c.r8Lo()); + cc.ror(b, c.r8Lo()); + cc.ror(d, c.r8Lo()); + cc.shl(a, c.r8Lo()); + cc.shl(b, c.r8Lo()); + cc.shl(d, c.r8Lo()); + cc.shr(a, c.r8Lo()); + cc.shr(b, c.r8Lo()); + cc.shr(d, c.r8Lo()); + cc.sar(a, c.r8Lo()); + cc.sar(b, c.r8Lo()); + cc.sar(d, c.r8Lo()); + cc.shld(a, b, c.r8Lo()); + cc.shld(b, d, c.r8Lo()); + cc.shld(d, a, c.r8Lo()); + cc.shrd(a, b, c.r8Lo()); + cc.shrd(b, d, c.r8Lo()); + cc.shrd(d, a, c.r8Lo()); + + cc.adcx(a, b); + cc.adox(a, b); + cc.adcx(b, c); + cc.adox(b, c); + cc.adcx(c, d); + cc.adox(c, d); + cc.andn(a, b, c); + cc.andn(b, c, d); + cc.andn(c, d, a); + cc.bextr(a, b, c); + cc.bextr(b, c, d); + cc.bextr(c, d, a); + cc.blsi(a, b); + cc.blsi(b, c); + cc.blsi(c, d); + cc.blsmsk(a, b); + cc.blsmsk(b, c); + cc.blsmsk(c, d); + cc.blsr(a, b); + cc.blsr(b, c); + cc.blsr(c, d); + cc.bzhi(a, b, c); + cc.bzhi(b, c, d); + cc.bzhi(c, d, a); + cc.lzcnt(a, b); + cc.lzcnt(b, c); + cc.lzcnt(c, d); + cc.pdep(a, b, c); + cc.pdep(b, c, d); + cc.pdep(c, d, a); + cc.pext(a, b, c); + cc.pext(b, c, d); + cc.pext(c, d, a); + cc.popcnt(a, b); + cc.popcnt(b, c); + cc.popcnt(c, d); + cc.rorx(a, b, 8); + cc.rorx(b, c, 8); + cc.rorx(c, d, 8); + cc.sarx(a, b, c); + cc.sarx(b, c, d); + cc.sarx(c, d, a); + cc.shlx(a, b, c); + cc.shlx(b, c, d); + cc.shlx(c, d, a); + cc.shrx(a, b, c); + cc.shrx(b, c, d); + cc.shrx(c, d, a); + cc.tzcnt(a, b); + cc.tzcnt(b, c); + cc.tzcnt(c, d); + } + else { + uint32_t regSize = cc.registerSize(); + x86::Mem m = x86::ptr(c, 0, regSize); + x86::Mem m8 = x86::byte_ptr(c); + + cc.adc(a, m); + cc.adc(b, m); + cc.adc(c, m); + cc.add(a, m); + cc.add(b, m); + cc.add(c, m); + cc.and_(a, m); + cc.and_(b, m); + cc.and_(c, m); + cc.bsf(a, m); + cc.bsf(b, m); + cc.bsf(c, m); + cc.bsr(a, m); + cc.bsr(b, m); + cc.bsr(c, m); + cc.bt(m, a); + cc.bt(m, b); + cc.bt(m, c); + cc.btc(m, a); + cc.btc(m, b); + cc.btc(m, c); + cc.btr(m, a); + cc.btr(m, b); + cc.btr(m, c); + cc.bts(m, a); + cc.bts(m, b); + cc.bts(m, c); + cc.cmp(a, m); + cc.cmovc(a, m); + cc.cmp(b, m); + cc.cmovc(b, m); + cc.cmp(c, m); + cc.cmovc(c, m); + cc.dec(m); + cc.movsx(a, m8); + cc.movsx(b, m8); + cc.movsx(c, m8); + cc.movzx(a, m8); + cc.movzx(b, m8); + cc.movzx(c, m8); + cc.neg(m); + cc.not_(m); + cc.or_(a, m); + cc.or_(b, m); + cc.or_(c, m); + cc.sbb(a, m); + cc.sbb(b, m); + cc.sbb(c, m); + cc.sub(a, m); + cc.sub(b, m); + cc.sub(c, m); + cc.test(m, a); + cc.test(m, b); + cc.test(m, c); + cc.xchg(a, m); + cc.xchg(b, m); + cc.xchg(c, m); + cc.xor_(a, m); + cc.xor_(b, m); + cc.xor_(c, m); + + cc.rcl(m, c.r8Lo()); + cc.rcr(m, c.r8Lo()); + cc.rol(m, c.r8Lo()); + cc.ror(m, c.r8Lo()); + cc.shl(m, c.r8Lo()); + cc.shr(m, c.r8Lo()); + cc.sar(m, c.r8Lo()); + cc.shld(m, b, c.r8Lo()); + cc.shld(m, d, c.r8Lo()); + cc.shld(m, a, c.r8Lo()); + cc.shrd(m, b, c.r8Lo()); + cc.shrd(m, d, c.r8Lo()); + cc.shrd(m, a, c.r8Lo()); + + cc.adcx(a, m); + cc.adox(a, m); + cc.adcx(b, m); + cc.adox(b, m); + cc.adcx(c, m); + cc.adox(c, m); + cc.andn(a, b, m); + cc.andn(b, c, m); + cc.andn(c, d, m); + cc.bextr(a, m, c); + cc.bextr(b, m, d); + cc.bextr(c, m, a); + cc.blsi(a, m); + cc.blsi(b, m); + cc.blsi(c, m); + cc.blsmsk(a, m); + cc.blsmsk(b, m); + cc.blsmsk(c, m); + cc.blsr(a, m); + cc.blsr(b, m); + cc.blsr(c, m); + cc.bzhi(a, m, c); + cc.bzhi(b, m, d); + cc.bzhi(c, m, a); + cc.lzcnt(a, m); + cc.lzcnt(b, m); + cc.lzcnt(c, m); + cc.pdep(a, b, m); + cc.pdep(b, c, m); + cc.pdep(c, d, m); + cc.pext(a, b, m); + cc.pext(b, c, m); + cc.pext(c, d, m); + cc.popcnt(a, m); + cc.popcnt(b, m); + cc.popcnt(c, m); + cc.rorx(a, m, 8); + cc.rorx(b, m, 8); + cc.rorx(c, m, 8); + cc.sarx(a, m, c); + cc.sarx(b, m, d); + cc.sarx(c, m, a); + cc.shlx(a, m, c); + cc.shlx(b, m, d); + cc.shlx(c, m, a); + cc.shrx(a, m, c); + cc.shrx(b, m, d); + cc.shrx(c, m, a); + cc.tzcnt(a, m); + cc.tzcnt(b, m); + cc.tzcnt(c, m); + } +} + +static void generateGpSequence(BaseEmitter& emitter, InstForm form, bool emitPrologEpilog) { + using namespace asmjit::x86; + + if (emitter.isAssembler()) { + Assembler& cc = *emitter.as<Assembler>(); + + x86::Gp a = cc.zax(); + x86::Gp b = cc.zbx(); + x86::Gp c = cc.zcx(); + x86::Gp d = cc.zdx(); + + if (emitPrologEpilog) { + FuncDetail func; + func.init(FuncSignatureT<void, void*, const void*, size_t>(CallConvId::kHost), cc.environment()); + + FuncFrame frame; + frame.init(func); + frame.addDirtyRegs(a, b, c, d); + frame.finalize(); + + cc.emitProlog(frame); + generateGpSequenceInternal(cc, form, a, b, c, d); + cc.emitEpilog(frame); + } + else { + generateGpSequenceInternal(cc, form, a, b, c, d); + } + } +#ifndef ASMJIT_NO_BUILDER + else if (emitter.isBuilder()) { + Builder& cc = *emitter.as<Builder>(); + + x86::Gp a = cc.zax(); + x86::Gp b = cc.zbx(); + x86::Gp c = cc.zcx(); + x86::Gp d = cc.zdx(); + + if (emitPrologEpilog) { + FuncDetail func; + func.init(FuncSignatureT<void, void*, const void*, size_t>(CallConvId::kHost), cc.environment()); + + FuncFrame frame; + frame.init(func); + frame.addDirtyRegs(a, b, c, d); + frame.finalize(); + + cc.emitProlog(frame); + generateGpSequenceInternal(cc, form, a, b, c, d); + cc.emitEpilog(frame); + } + else { + generateGpSequenceInternal(cc, form, a, b, c, d); + } + } +#endif +#ifndef ASMJIT_NO_COMPILER + else if (emitter.isCompiler()) { + Compiler& cc = *emitter.as<Compiler>(); + + Gp a = cc.newIntPtr("a"); + Gp b = cc.newIntPtr("b"); + Gp c = cc.newIntPtr("c"); + Gp d = cc.newIntPtr("d"); + + cc.addFunc(FuncSignatureT<void>(CallConvId::kHost)); + generateGpSequenceInternal(cc, form, a, b, c, d); + cc.endFunc(); + } +#endif +} + +// Generates a long sequence of SSE instructions using only registers. +template<typename Emitter> +static void generateSseSequenceInternal( + Emitter& cc, + InstForm form, + const x86::Gp& gp, + const x86::Xmm& xmmA, const x86::Xmm& xmmB, const x86::Xmm& xmmC, const x86::Xmm& xmmD) { + + x86::Gp gpd = gp.r32(); + x86::Gp gpq = gp.r64(); + x86::Gp gpz = cc.is32Bit() ? gpd : gpq; + + cc.xor_(gpd, gpd); + cc.xorps(xmmA, xmmA); + cc.xorps(xmmB, xmmB); + cc.xorps(xmmC, xmmC); + cc.xorps(xmmD, xmmD); + + if (form == InstForm::kReg) { + // SSE. + cc.addps(xmmA, xmmB); + cc.addss(xmmA, xmmB); + cc.andnps(xmmA, xmmB); + cc.andps(xmmA, xmmB); + cc.cmpps(xmmA, xmmB, 0); + cc.cmpss(xmmA, xmmB, 0); + cc.comiss(xmmA, xmmB); + cc.cvtsi2ss(xmmA, gpd); + cc.cvtsi2ss(xmmA, gpz); + cc.cvtss2si(gpd, xmmB); + cc.cvtss2si(gpz, xmmB); + cc.cvttss2si(gpd, xmmB); + cc.cvttss2si(gpz, xmmB); + cc.divps(xmmA, xmmB); + cc.divss(xmmA, xmmB); + cc.maxps(xmmA, xmmB); + cc.maxss(xmmA, xmmB); + cc.minps(xmmA, xmmB); + cc.minss(xmmA, xmmB); + cc.movaps(xmmA, xmmB); + cc.movd(gpd, xmmB); + cc.movd(xmmA, gpd); + cc.movq(xmmA, xmmB); + cc.movhlps(xmmA, xmmB); + cc.movlhps(xmmA, xmmB); + cc.movups(xmmA, xmmB); + cc.mulps(xmmA, xmmB); + cc.mulss(xmmA, xmmB); + cc.orps(xmmA, xmmB); + cc.rcpps(xmmA, xmmB); + cc.rcpss(xmmA, xmmB); + cc.psadbw(xmmA, xmmB); + cc.rsqrtps(xmmA, xmmB); + cc.rsqrtss(xmmA, xmmB); + cc.sfence(); + cc.shufps(xmmA, xmmB, 0); + cc.sqrtps(xmmA, xmmB); + cc.sqrtss(xmmA, xmmB); + cc.subps(xmmA, xmmB); + cc.subss(xmmA, xmmB); + cc.ucomiss(xmmA, xmmB); + cc.unpckhps(xmmA, xmmB); + cc.unpcklps(xmmA, xmmB); + cc.xorps(xmmA, xmmB); + + // SSE2. + cc.addpd(xmmA, xmmB); + cc.addsd(xmmA, xmmB); + cc.andnpd(xmmA, xmmB); + cc.andpd(xmmA, xmmB); + cc.cmppd(xmmA, xmmB, 0); + cc.cmpsd(xmmA, xmmB, 0); + cc.comisd(xmmA, xmmB); + cc.cvtdq2pd(xmmA, xmmB); + cc.cvtdq2ps(xmmA, xmmB); + cc.cvtpd2dq(xmmA, xmmB); + cc.cvtpd2ps(xmmA, xmmB); + cc.cvtps2dq(xmmA, xmmB); + cc.cvtps2pd(xmmA, xmmB); + cc.cvtsd2si(gpd, xmmB); + cc.cvtsd2si(gpz, xmmB); + cc.cvtsd2ss(xmmA, xmmB); + cc.cvtsi2sd(xmmA, gpd); + cc.cvtsi2sd(xmmA, gpz); + cc.cvtss2sd(xmmA, xmmB); + cc.cvtss2si(gpd, xmmB); + cc.cvtss2si(gpz, xmmB); + cc.cvttpd2dq(xmmA, xmmB); + cc.cvttps2dq(xmmA, xmmB); + cc.cvttsd2si(gpd, xmmB); + cc.cvttsd2si(gpz, xmmB); + cc.divpd(xmmA, xmmB); + cc.divsd(xmmA, xmmB); + cc.maxpd(xmmA, xmmB); + cc.maxsd(xmmA, xmmB); + cc.minpd(xmmA, xmmB); + cc.minsd(xmmA, xmmB); + cc.movdqa(xmmA, xmmB); + cc.movdqu(xmmA, xmmB); + cc.movmskps(gpd, xmmB); + cc.movmskpd(gpd, xmmB); + cc.movsd(xmmA, xmmB); + cc.mulpd(xmmA, xmmB); + cc.mulsd(xmmA, xmmB); + cc.orpd(xmmA, xmmB); + cc.packsswb(xmmA, xmmB); + cc.packssdw(xmmA, xmmB); + cc.packuswb(xmmA, xmmB); + cc.paddb(xmmA, xmmB); + cc.paddw(xmmA, xmmB); + cc.paddd(xmmA, xmmB); + cc.paddq(xmmA, xmmB); + cc.paddsb(xmmA, xmmB); + cc.paddsw(xmmA, xmmB); + cc.paddusb(xmmA, xmmB); + cc.paddusw(xmmA, xmmB); + cc.pand(xmmA, xmmB); + cc.pandn(xmmA, xmmB); + cc.pavgb(xmmA, xmmB); + cc.pavgw(xmmA, xmmB); + cc.pcmpeqb(xmmA, xmmB); + cc.pcmpeqw(xmmA, xmmB); + cc.pcmpeqd(xmmA, xmmB); + cc.pcmpgtb(xmmA, xmmB); + cc.pcmpgtw(xmmA, xmmB); + cc.pcmpgtd(xmmA, xmmB); + cc.pmaxsw(xmmA, xmmB); + cc.pmaxub(xmmA, xmmB); + cc.pminsw(xmmA, xmmB); + cc.pminub(xmmA, xmmB); + cc.pmovmskb(gpd, xmmB); + cc.pmulhw(xmmA, xmmB); + cc.pmulhuw(xmmA, xmmB); + cc.pmullw(xmmA, xmmB); + cc.pmuludq(xmmA, xmmB); + cc.por(xmmA, xmmB); + cc.pslld(xmmA, xmmB); + cc.pslld(xmmA, 0); + cc.psllq(xmmA, xmmB); + cc.psllq(xmmA, 0); + cc.psllw(xmmA, xmmB); + cc.psllw(xmmA, 0); + cc.pslldq(xmmA, 0); + cc.psrad(xmmA, xmmB); + cc.psrad(xmmA, 0); + cc.psraw(xmmA, xmmB); + cc.psraw(xmmA, 0); + cc.psubb(xmmA, xmmB); + cc.psubw(xmmA, xmmB); + cc.psubd(xmmA, xmmB); + cc.psubq(xmmA, xmmB); + cc.pmaddwd(xmmA, xmmB); + cc.pshufd(xmmA, xmmB, 0); + cc.pshufhw(xmmA, xmmB, 0); + cc.pshuflw(xmmA, xmmB, 0); + cc.psrld(xmmA, xmmB); + cc.psrld(xmmA, 0); + cc.psrlq(xmmA, xmmB); + cc.psrlq(xmmA, 0); + cc.psrldq(xmmA, 0); + cc.psrlw(xmmA, xmmB); + cc.psrlw(xmmA, 0); + cc.psubsb(xmmA, xmmB); + cc.psubsw(xmmA, xmmB); + cc.psubusb(xmmA, xmmB); + cc.psubusw(xmmA, xmmB); + cc.punpckhbw(xmmA, xmmB); + cc.punpckhwd(xmmA, xmmB); + cc.punpckhdq(xmmA, xmmB); + cc.punpckhqdq(xmmA, xmmB); + cc.punpcklbw(xmmA, xmmB); + cc.punpcklwd(xmmA, xmmB); + cc.punpckldq(xmmA, xmmB); + cc.punpcklqdq(xmmA, xmmB); + cc.pxor(xmmA, xmmB); + cc.sqrtpd(xmmA, xmmB); + cc.sqrtsd(xmmA, xmmB); + cc.subpd(xmmA, xmmB); + cc.subsd(xmmA, xmmB); + cc.ucomisd(xmmA, xmmB); + cc.unpckhpd(xmmA, xmmB); + cc.unpcklpd(xmmA, xmmB); + cc.xorpd(xmmA, xmmB); + + // SSE3. + cc.addsubpd(xmmA, xmmB); + cc.addsubps(xmmA, xmmB); + cc.haddpd(xmmA, xmmB); + cc.haddps(xmmA, xmmB); + cc.hsubpd(xmmA, xmmB); + cc.hsubps(xmmA, xmmB); + cc.movddup(xmmA, xmmB); + cc.movshdup(xmmA, xmmB); + cc.movsldup(xmmA, xmmB); + + // SSSE3. + cc.psignb(xmmA, xmmB); + cc.psignw(xmmA, xmmB); + cc.psignd(xmmA, xmmB); + cc.phaddw(xmmA, xmmB); + cc.phaddd(xmmA, xmmB); + cc.phaddsw(xmmA, xmmB); + cc.phsubw(xmmA, xmmB); + cc.phsubd(xmmA, xmmB); + cc.phsubsw(xmmA, xmmB); + cc.pmaddubsw(xmmA, xmmB); + cc.pabsb(xmmA, xmmB); + cc.pabsw(xmmA, xmmB); + cc.pabsd(xmmA, xmmB); + cc.pmulhrsw(xmmA, xmmB); + cc.pshufb(xmmA, xmmB); + cc.palignr(xmmA, xmmB, 0); + + // SSE4.1. + cc.blendpd(xmmA, xmmB, 0); + cc.blendps(xmmA, xmmB, 0); + cc.blendvpd(xmmA, xmmB, xmmA); + cc.blendvps(xmmA, xmmB, xmmA); + + cc.dppd(xmmA, xmmB, 0); + cc.dpps(xmmA, xmmB, 0); + cc.extractps(gpd, xmmB, 0); + cc.insertps(xmmA, xmmB, 0); + cc.mpsadbw(xmmA, xmmB, 0); + cc.packusdw(xmmA, xmmB); + cc.pblendvb(xmmA, xmmB, xmmA); + cc.pblendw(xmmA, xmmB, 0); + cc.pcmpeqq(xmmA, xmmB); + cc.pextrb(gpd, xmmB, 0); + cc.pextrd(gpd, xmmB, 0); + if (cc.is64Bit()) cc.pextrq(gpq, xmmB, 0); + cc.pextrw(gpd, xmmB, 0); + cc.phminposuw(xmmA, xmmB); + cc.pinsrb(xmmA, gpd, 0); + cc.pinsrd(xmmA, gpd, 0); + cc.pinsrw(xmmA, gpd, 0); + cc.pmaxuw(xmmA, xmmB); + cc.pmaxsb(xmmA, xmmB); + cc.pmaxsd(xmmA, xmmB); + cc.pmaxud(xmmA, xmmB); + cc.pminsb(xmmA, xmmB); + cc.pminuw(xmmA, xmmB); + cc.pminud(xmmA, xmmB); + cc.pminsd(xmmA, xmmB); + cc.pmovsxbw(xmmA, xmmB); + cc.pmovsxbd(xmmA, xmmB); + cc.pmovsxbq(xmmA, xmmB); + cc.pmovsxwd(xmmA, xmmB); + cc.pmovsxwq(xmmA, xmmB); + cc.pmovsxdq(xmmA, xmmB); + cc.pmovzxbw(xmmA, xmmB); + cc.pmovzxbd(xmmA, xmmB); + cc.pmovzxbq(xmmA, xmmB); + cc.pmovzxwd(xmmA, xmmB); + cc.pmovzxwq(xmmA, xmmB); + cc.pmovzxdq(xmmA, xmmB); + cc.pmuldq(xmmA, xmmB); + cc.pmulld(xmmA, xmmB); + cc.ptest(xmmA, xmmB); + cc.roundps(xmmA, xmmB, 0); + cc.roundss(xmmA, xmmB, 0); + cc.roundpd(xmmA, xmmB, 0); + cc.roundsd(xmmA, xmmB, 0); + } + else { + x86::Mem m = x86::ptr(gpz); + + cc.addps(xmmA, m); + cc.addss(xmmA, m); + cc.andnps(xmmA, m); + cc.andps(xmmA, m); + cc.cmpps(xmmA, m, 0); + cc.cmpss(xmmA, m, 0); + cc.comiss(xmmA, m); + cc.cvtpi2ps(xmmA, m); + cc.cvtsi2ss(xmmA, m); + cc.cvtss2si(gpd, m); + if (cc.is64Bit()) cc.cvtss2si(gpq, m); + cc.cvttss2si(gpd, m); + if (cc.is64Bit()) cc.cvttss2si(gpq, m); + cc.divps(xmmA, m); + cc.divss(xmmA, m); + cc.maxps(xmmA, m); + cc.maxss(xmmA, m); + cc.minps(xmmA, m); + cc.minss(xmmA, m); + cc.movaps(xmmA, m); + cc.movaps(m, xmmB); + cc.movd(m, xmmB); + cc.movd(xmmA, m); + cc.movq(m, xmmB); + cc.movq(xmmA, m); + cc.movhps(xmmA, m); + cc.movhps(m, xmmB); + cc.movlps(xmmA, m); + cc.movlps(m, xmmB); + cc.movntps(m, xmmB); + cc.movss(xmmA, m); + cc.movss(m, xmmB); + cc.movups(xmmA, m); + cc.movups(m, xmmB); + cc.mulps(xmmA, m); + cc.mulss(xmmA, m); + cc.orps(xmmA, m); + cc.rcpps(xmmA, m); + cc.rcpss(xmmA, m); + cc.psadbw(xmmA, m); + cc.rsqrtps(xmmA, m); + cc.rsqrtss(xmmA, m); + cc.shufps(xmmA, m, 0); + cc.sqrtps(xmmA, m); + cc.sqrtss(xmmA, m); + cc.stmxcsr(m); + cc.subps(xmmA, m); + cc.subss(xmmA, m); + cc.ucomiss(xmmA, m); + cc.unpckhps(xmmA, m); + cc.unpcklps(xmmA, m); + cc.xorps(xmmA, m); + + // SSE2. + cc.addpd(xmmA, m); + cc.addsd(xmmA, m); + cc.andnpd(xmmA, m); + cc.andpd(xmmA, m); + cc.cmppd(xmmA, m, 0); + cc.cmpsd(xmmA, m, 0); + cc.comisd(xmmA, m); + cc.cvtdq2pd(xmmA, m); + cc.cvtdq2ps(xmmA, m); + cc.cvtpd2dq(xmmA, m); + cc.cvtpd2ps(xmmA, m); + cc.cvtpi2pd(xmmA, m); + cc.cvtps2dq(xmmA, m); + cc.cvtps2pd(xmmA, m); + cc.cvtsd2si(gpd, m); + if (cc.is64Bit()) cc.cvtsd2si(gpq, m); + cc.cvtsd2ss(xmmA, m); + cc.cvtsi2sd(xmmA, m); + cc.cvtss2sd(xmmA, m); + cc.cvtss2si(gpd, m); + if (cc.is64Bit()) cc.cvtss2si(gpq, m); + cc.cvttpd2dq(xmmA, m); + cc.cvttps2dq(xmmA, m); + cc.cvttsd2si(gpd, m); + if (cc.is64Bit()) cc.cvttsd2si(gpq, m); + cc.divpd(xmmA, m); + cc.divsd(xmmA, m); + cc.maxpd(xmmA, m); + cc.maxsd(xmmA, m); + cc.minpd(xmmA, m); + cc.minsd(xmmA, m); + cc.movdqa(xmmA, m); + cc.movdqa(m, xmmB); + cc.movdqu(xmmA, m); + cc.movdqu(m, xmmB); + cc.movsd(xmmA, m); + cc.movsd(m, xmmB); + cc.movapd(xmmA, m); + cc.movapd(m, xmmB); + cc.movhpd(xmmA, m); + cc.movhpd(m, xmmB); + cc.movlpd(xmmA, m); + cc.movlpd(m, xmmB); + cc.movntdq(m, xmmB); + cc.movntpd(m, xmmB); + cc.movupd(xmmA, m); + cc.movupd(m, xmmB); + cc.mulpd(xmmA, m); + cc.mulsd(xmmA, m); + cc.orpd(xmmA, m); + cc.packsswb(xmmA, m); + cc.packssdw(xmmA, m); + cc.packuswb(xmmA, m); + cc.paddb(xmmA, m); + cc.paddw(xmmA, m); + cc.paddd(xmmA, m); + cc.paddq(xmmA, m); + cc.paddsb(xmmA, m); + cc.paddsw(xmmA, m); + cc.paddusb(xmmA, m); + cc.paddusw(xmmA, m); + cc.pand(xmmA, m); + cc.pandn(xmmA, m); + cc.pavgb(xmmA, m); + cc.pavgw(xmmA, m); + cc.pcmpeqb(xmmA, m); + cc.pcmpeqw(xmmA, m); + cc.pcmpeqd(xmmA, m); + cc.pcmpgtb(xmmA, m); + cc.pcmpgtw(xmmA, m); + cc.pcmpgtd(xmmA, m); + cc.pmaxsw(xmmA, m); + cc.pmaxub(xmmA, m); + cc.pminsw(xmmA, m); + cc.pminub(xmmA, m); + cc.pmulhw(xmmA, m); + cc.pmulhuw(xmmA, m); + cc.pmullw(xmmA, m); + cc.pmuludq(xmmA, m); + cc.por(xmmA, m); + cc.pslld(xmmA, m); + cc.psllq(xmmA, m); + cc.psllw(xmmA, m); + cc.psrad(xmmA, m); + cc.psraw(xmmA, m); + cc.psubb(xmmA, m); + cc.psubw(xmmA, m); + cc.psubd(xmmA, m); + cc.psubq(xmmA, m); + cc.pmaddwd(xmmA, m); + cc.pshufd(xmmA, m, 0); + cc.pshufhw(xmmA, m, 0); + cc.pshuflw(xmmA, m, 0); + cc.psrld(xmmA, m); + cc.psrlq(xmmA, m); + cc.psrlw(xmmA, m); + cc.psubsb(xmmA, m); + cc.psubsw(xmmA, m); + cc.psubusb(xmmA, m); + cc.psubusw(xmmA, m); + cc.punpckhbw(xmmA, m); + cc.punpckhwd(xmmA, m); + cc.punpckhdq(xmmA, m); + cc.punpckhqdq(xmmA, m); + cc.punpcklbw(xmmA, m); + cc.punpcklwd(xmmA, m); + cc.punpckldq(xmmA, m); + cc.punpcklqdq(xmmA, m); + cc.pxor(xmmA, m); + cc.sqrtpd(xmmA, m); + cc.sqrtsd(xmmA, m); + cc.subpd(xmmA, m); + cc.subsd(xmmA, m); + cc.ucomisd(xmmA, m); + cc.unpckhpd(xmmA, m); + cc.unpcklpd(xmmA, m); + cc.xorpd(xmmA, m); + + // SSE3. + cc.addsubpd(xmmA, m); + cc.addsubps(xmmA, m); + cc.haddpd(xmmA, m); + cc.haddps(xmmA, m); + cc.hsubpd(xmmA, m); + cc.hsubps(xmmA, m); + cc.lddqu(xmmA, m); + cc.movddup(xmmA, m); + cc.movshdup(xmmA, m); + cc.movsldup(xmmA, m); + + // SSSE3. + cc.psignb(xmmA, m); + cc.psignw(xmmA, m); + cc.psignd(xmmA, m); + cc.phaddw(xmmA, m); + cc.phaddd(xmmA, m); + cc.phaddsw(xmmA, m); + cc.phsubw(xmmA, m); + cc.phsubd(xmmA, m); + cc.phsubsw(xmmA, m); + cc.pmaddubsw(xmmA, m); + cc.pabsb(xmmA, m); + cc.pabsw(xmmA, m); + cc.pabsd(xmmA, m); + cc.pmulhrsw(xmmA, m); + cc.pshufb(xmmA, m); + cc.palignr(xmmA, m, 0); + + // SSE4.1. + cc.blendpd(xmmA, m, 0); + cc.blendps(xmmA, m, 0); + cc.blendvpd(xmmA, m, xmmA); + cc.blendvps(xmmA, m, xmmA); + + cc.dppd(xmmA, m, 0); + cc.dpps(xmmA, m, 0); + cc.extractps(m, xmmB, 0); + cc.insertps(xmmA, m, 0); + cc.movntdqa(xmmA, m); + cc.mpsadbw(xmmA, m, 0); + cc.packusdw(xmmA, m); + cc.pblendvb(xmmA, m, xmmA); + cc.pblendw(xmmA, m, 0); + cc.pcmpeqq(xmmA, m); + cc.pextrb(m, xmmB, 0); + cc.pextrd(m, xmmB, 0); + if (cc.is64Bit()) cc.pextrq(m, xmmB, 0); + cc.pextrw(m, xmmB, 0); + cc.phminposuw(xmmA, m); + cc.pinsrb(xmmA, m, 0); + cc.pinsrd(xmmA, m, 0); + cc.pinsrw(xmmA, m, 0); + cc.pmaxuw(xmmA, m); + cc.pmaxsb(xmmA, m); + cc.pmaxsd(xmmA, m); + cc.pmaxud(xmmA, m); + cc.pminsb(xmmA, m); + cc.pminuw(xmmA, m); + cc.pminud(xmmA, m); + cc.pminsd(xmmA, m); + cc.pmovsxbw(xmmA, m); + cc.pmovsxbd(xmmA, m); + cc.pmovsxbq(xmmA, m); + cc.pmovsxwd(xmmA, m); + cc.pmovsxwq(xmmA, m); + cc.pmovsxdq(xmmA, m); + cc.pmovzxbw(xmmA, m); + cc.pmovzxbd(xmmA, m); + cc.pmovzxbq(xmmA, m); + cc.pmovzxwd(xmmA, m); + cc.pmovzxwq(xmmA, m); + cc.pmovzxdq(xmmA, m); + cc.pmuldq(xmmA, m); + cc.pmulld(xmmA, m); + cc.ptest(xmmA, m); + cc.roundps(xmmA, m, 0); + cc.roundss(xmmA, m, 0); + cc.roundpd(xmmA, m, 0); + cc.roundsd(xmmA, m, 0); + + // SSE4.2. + cc.pcmpgtq(xmmA, m); + } +} + +static void generateSseSequence(BaseEmitter& emitter, InstForm form, bool emitPrologEpilog) { + using namespace asmjit::x86; + + if (emitter.isAssembler()) { + Assembler& cc = *emitter.as<Assembler>(); + + if (emitPrologEpilog) { + FuncDetail func; + func.init(FuncSignatureT<void, void*, const void*, size_t>(CallConvId::kHost), cc.environment()); + + FuncFrame frame; + frame.init(func); + frame.addDirtyRegs(eax, xmm0, xmm1, xmm2, xmm3); + frame.finalize(); + + cc.emitProlog(frame); + generateSseSequenceInternal(cc, form, eax, xmm0, xmm1, xmm2, xmm3); + cc.emitEpilog(frame); + } + else { + generateSseSequenceInternal(cc, form, eax, xmm0, xmm1, xmm2, xmm3); + } + } +#ifndef ASMJIT_NO_BUILDER + else if (emitter.isBuilder()) { + Builder& cc = *emitter.as<Builder>(); + + if (emitPrologEpilog) { + FuncDetail func; + func.init(FuncSignatureT<void, void*, const void*, size_t>(CallConvId::kHost), cc.environment()); + + FuncFrame frame; + frame.init(func); + frame.addDirtyRegs(eax, xmm0, xmm1, xmm2, xmm3); + frame.finalize(); + + cc.emitProlog(frame); + generateSseSequenceInternal(cc, form, eax, xmm0, xmm1, xmm2, xmm3); + cc.emitEpilog(frame); + } + else { + generateSseSequenceInternal(cc, form, eax, xmm0, xmm1, xmm2, xmm3); + } + } +#endif +#ifndef ASMJIT_NO_COMPILER + else if (emitter.isCompiler()) { + Compiler& cc = *emitter.as<Compiler>(); + + Gp gp = cc.newGpz("gp"); + Xmm a = cc.newXmm("a"); + Xmm b = cc.newXmm("b"); + Xmm c = cc.newXmm("c"); + Xmm d = cc.newXmm("d"); + + cc.addFunc(FuncSignatureT<void>(CallConvId::kHost)); + generateSseSequenceInternal(cc, form, gp, a, b, c, d); + cc.endFunc(); + } +#endif +} + +// Generates a long sequence of AVX instructions. +template<typename Emitter> +static void generateAvxSequenceInternal( + Emitter& cc, + InstForm form, + const x86::Gp& gp, + const x86::Vec& vecA, const x86::Vec& vecB, const x86::Vec& vecC, const x86::Vec& vecD) { + + x86::Gp gpd = gp.r32(); + x86::Gp gpq = gp.r64(); + x86::Gp gpz = cc.is32Bit() ? gpd : gpq; + + x86::Xmm xmmA = vecA.xmm(); + x86::Xmm xmmB = vecB.xmm(); + x86::Xmm xmmC = vecC.xmm(); + x86::Xmm xmmD = vecD.xmm(); + + x86::Ymm ymmA = vecA.ymm(); + x86::Ymm ymmB = vecB.ymm(); + x86::Ymm ymmC = vecC.ymm(); + x86::Ymm ymmD = vecD.ymm(); + + cc.xor_(gpd, gpd); + cc.vxorps(xmmA, xmmA, xmmA); + cc.vxorps(xmmB, xmmB, xmmB); + cc.vxorps(xmmC, xmmC, xmmC); + cc.vxorps(xmmD, xmmD, xmmD); + + if (form == InstForm::kReg) { + cc.vaddpd(xmmA, xmmB, xmmC); + cc.vaddpd(ymmA, ymmB, ymmC); + cc.vaddps(xmmA, xmmB, xmmC); + cc.vaddps(ymmA, ymmB, ymmC); + cc.vaddsd(xmmA, xmmB, xmmC); + cc.vaddss(xmmA, xmmB, xmmC); + cc.vaddsubpd(xmmA, xmmB, xmmC); + cc.vaddsubpd(ymmA, ymmB, ymmC); + cc.vaddsubps(xmmA, xmmB, xmmC); + cc.vaddsubps(ymmA, ymmB, ymmC); + cc.vandpd(xmmA, xmmB, xmmC); + cc.vandpd(ymmA, ymmB, ymmC); + cc.vandps(xmmA, xmmB, xmmC); + cc.vandps(ymmA, ymmB, ymmC); + cc.vandnpd(xmmA, xmmB, xmmC); + cc.vandnpd(ymmA, ymmB, ymmC); + cc.vandnps(xmmA, xmmB, xmmC); + cc.vandnps(ymmA, ymmB, ymmC); + cc.vblendpd(xmmA, xmmB, xmmC, 0); + cc.vblendpd(ymmA, ymmB, ymmC, 0); + cc.vblendps(xmmA, xmmB, xmmC, 0); + cc.vblendps(ymmA, ymmB, ymmC, 0); + cc.vblendvpd(xmmA, xmmB, xmmC, xmmA); + cc.vblendvpd(ymmA, ymmB, ymmC, ymmA); + cc.vcmppd(xmmA, xmmB, xmmC, 0); + cc.vcmppd(ymmA, ymmB, ymmC, 0); + cc.vcmpps(xmmA, xmmB, xmmC, 0); + cc.vcmpps(ymmA, ymmB, ymmC, 0); + cc.vcmpsd(xmmA, xmmB, xmmC, 0); + cc.vcmpss(xmmA, xmmB, xmmC, 0); + cc.vcomisd(xmmA, xmmB); + cc.vcomiss(xmmA, xmmB); + cc.vcvtdq2pd(xmmA, xmmB); + cc.vcvtdq2pd(ymmA, xmmB); + cc.vcvtdq2ps(xmmA, xmmB); + cc.vcvtdq2ps(ymmA, ymmB); + cc.vcvtpd2dq(xmmA, xmmB); + cc.vcvtpd2dq(xmmA, ymmB); + cc.vcvtpd2ps(xmmA, xmmB); + cc.vcvtpd2ps(xmmA, ymmB); + cc.vcvtps2dq(xmmA, xmmB); + cc.vcvtps2dq(ymmA, ymmB); + cc.vcvtps2pd(xmmA, xmmB); + cc.vcvtps2pd(ymmA, xmmB); + cc.vcvtsd2si(gpd, xmmB); + cc.vcvtsd2si(gpz, xmmB); + cc.vcvtsd2ss(xmmA, xmmB, xmmC); + cc.vcvtsi2sd(xmmA, xmmB, gpd); + cc.vcvtsi2sd(xmmA, xmmB, gpz); + cc.vcvtsi2ss(xmmA, xmmB, gpd); + cc.vcvtsi2ss(xmmA, xmmB, gpz); + cc.vcvtss2sd(xmmA, xmmB, xmmC); + cc.vcvtss2si(gpd, xmmB); + cc.vcvttpd2dq(xmmA, xmmB); + cc.vcvttpd2dq(xmmA, ymmB); + cc.vcvttps2dq(xmmA, xmmB); + cc.vcvttps2dq(ymmA, ymmB); + cc.vcvttsd2si(gpd, xmmB); + cc.vcvttss2si(gpz, xmmB); + cc.vdivpd(xmmA, xmmB, xmmC); + cc.vdivpd(ymmA, ymmB, ymmC); + cc.vdivps(xmmA, xmmB, xmmC); + cc.vdivps(ymmA, ymmB, ymmC); + cc.vdivsd(xmmA, xmmB, xmmC); + cc.vdivss(xmmA, xmmB, xmmC); + cc.vdppd(xmmA, xmmB, xmmC, 0); + cc.vdpps(xmmA, xmmB, xmmC, 0); + cc.vdpps(ymmA, ymmB, ymmC, 0); + cc.vextractf128(xmmA, ymmB, 0); + cc.vextractps(gpd, xmmB, 0); + cc.vhaddpd(xmmA, xmmB, xmmC); + cc.vhaddpd(ymmA, ymmB, ymmC); + cc.vhaddps(xmmA, xmmB, xmmC); + cc.vhaddps(ymmA, ymmB, ymmC); + cc.vhsubpd(xmmA, xmmB, xmmC); + cc.vhsubpd(ymmA, ymmB, ymmC); + cc.vhsubps(xmmA, xmmB, xmmC); + cc.vhsubps(ymmA, ymmB, ymmC); + cc.vinsertf128(ymmA, ymmB, xmmC, 0); + cc.vinsertps(xmmA, xmmB, xmmC, 0); + cc.vmaxpd(xmmA, xmmB, xmmC); + cc.vmaxpd(ymmA, ymmB, ymmC); + cc.vmaxps(xmmA, xmmB, xmmC); + cc.vmaxps(ymmA, ymmB, ymmC); + cc.vmaxsd(xmmA, xmmB, xmmC); + cc.vmaxss(xmmA, xmmB, xmmC); + cc.vminpd(xmmA, xmmB, xmmC); + cc.vminpd(ymmA, ymmB, ymmC); + cc.vminps(xmmA, xmmB, xmmC); + cc.vminps(ymmA, ymmB, ymmC); + cc.vminsd(xmmA, xmmB, xmmC); + cc.vminss(xmmA, xmmB, xmmC); + cc.vmovapd(xmmA, xmmB); + cc.vmovapd(ymmA, ymmB); + cc.vmovaps(xmmA, xmmB); + cc.vmovaps(ymmA, ymmB); + cc.vmovd(xmmA, gpd); + cc.vmovd(gpd, xmmB); + cc.vmovddup(xmmA, xmmB); + cc.vmovddup(ymmA, ymmB); + cc.vmovdqa(xmmA, xmmB); + cc.vmovdqa(ymmA, ymmB); + cc.vmovdqu(xmmA, xmmB); + cc.vmovdqu(ymmA, ymmB); + cc.vmovhlps(xmmA, xmmB, xmmC); + cc.vmovlhps(xmmA, xmmB, xmmC); + cc.vmovmskpd(gpd, xmmB); + cc.vmovmskpd(gpd, ymmB); + cc.vmovmskps(gpd, xmmB); + cc.vmovmskps(gpd, ymmB); + cc.vmovsd(xmmA, xmmB, xmmC); + cc.vmovshdup(xmmA, xmmB); + cc.vmovshdup(ymmA, ymmB); + cc.vmovsldup(xmmA, xmmB); + cc.vmovsldup(ymmA, ymmB); + cc.vmovss(xmmA, xmmB, xmmC); + cc.vmovupd(xmmA, xmmB); + cc.vmovupd(ymmA, ymmB); + cc.vmovups(xmmA, xmmB); + cc.vmovups(ymmA, ymmB); + cc.vmpsadbw(xmmA, xmmB, xmmC, 0); + cc.vmulpd(xmmA, xmmB, xmmC); + cc.vmulpd(ymmA, ymmB, ymmC); + cc.vmulps(xmmA, xmmB, xmmC); + cc.vmulps(ymmA, ymmB, ymmC); + cc.vmulsd(xmmA, xmmB, xmmC); + cc.vmulss(xmmA, xmmB, xmmC); + cc.vorpd(xmmA, xmmB, xmmC); + cc.vorpd(ymmA, ymmB, ymmC); + cc.vorps(xmmA, xmmB, xmmC); + cc.vorps(ymmA, ymmB, ymmC); + cc.vpabsb(xmmA, xmmB); + cc.vpabsd(xmmA, xmmB); + cc.vpabsw(xmmA, xmmB); + cc.vpackssdw(xmmA, xmmB, xmmC); + cc.vpacksswb(xmmA, xmmB, xmmC); + cc.vpackusdw(xmmA, xmmB, xmmC); + cc.vpackuswb(xmmA, xmmB, xmmC); + cc.vpaddb(xmmA, xmmB, xmmC); + cc.vpaddd(xmmA, xmmB, xmmC); + cc.vpaddq(xmmA, xmmB, xmmC); + cc.vpaddw(xmmA, xmmB, xmmC); + cc.vpaddsb(xmmA, xmmB, xmmC); + cc.vpaddsw(xmmA, xmmB, xmmC); + cc.vpaddusb(xmmA, xmmB, xmmC); + cc.vpaddusw(xmmA, xmmB, xmmC); + cc.vpalignr(xmmA, xmmB, xmmC, 0); + cc.vpand(xmmA, xmmB, xmmC); + cc.vpandn(xmmA, xmmB, xmmC); + cc.vpavgb(xmmA, xmmB, xmmC); + cc.vpavgw(xmmA, xmmB, xmmC); + cc.vpblendvb(xmmA, xmmB, xmmC, xmmA); + cc.vpblendw(xmmA, xmmB, xmmC, 0); + cc.vpcmpeqb(xmmA, xmmB, xmmC); + cc.vpcmpeqd(xmmA, xmmB, xmmC); + cc.vpcmpeqq(xmmA, xmmB, xmmC); + cc.vpcmpeqw(xmmA, xmmB, xmmC); + cc.vpcmpgtb(xmmA, xmmB, xmmC); + cc.vpcmpgtd(xmmA, xmmB, xmmC); + cc.vpcmpgtq(xmmA, xmmB, xmmC); + cc.vpcmpgtw(xmmA, xmmB, xmmC); + cc.vpermilpd(xmmA, xmmB, xmmC); + cc.vpermilpd(ymmA, ymmB, ymmC); + cc.vpermilpd(xmmA, xmmB, 0); + cc.vpermilpd(ymmA, ymmB, 0); + cc.vpermilps(xmmA, xmmB, xmmC); + cc.vpermilps(ymmA, ymmB, ymmC); + cc.vpermilps(xmmA, xmmB, 0); + cc.vpermilps(ymmA, ymmB, 0); + cc.vperm2f128(ymmA, ymmB, ymmC, 0); + cc.vpextrb(gpd, xmmB, 0); + cc.vpextrd(gpd, xmmB, 0); + if (cc.is64Bit()) cc.vpextrq(gpq, xmmB, 0); + cc.vpextrw(gpd, xmmB, 0); + cc.vphaddd(xmmA, xmmB, xmmC); + cc.vphaddsw(xmmA, xmmB, xmmC); + cc.vphaddw(xmmA, xmmB, xmmC); + cc.vphminposuw(xmmA, xmmB); + cc.vphsubd(xmmA, xmmB, xmmC); + cc.vphsubsw(xmmA, xmmB, xmmC); + cc.vphsubw(xmmA, xmmB, xmmC); + cc.vpinsrb(xmmA, xmmB, gpd, 0); + cc.vpinsrd(xmmA, xmmB, gpd, 0); + cc.vpinsrw(xmmA, xmmB, gpd, 0); + cc.vpmaddubsw(xmmA, xmmB, xmmC); + cc.vpmaddwd(xmmA, xmmB, xmmC); + cc.vpmaxsb(xmmA, xmmB, xmmC); + cc.vpmaxsd(xmmA, xmmB, xmmC); + cc.vpmaxsw(xmmA, xmmB, xmmC); + cc.vpmaxub(xmmA, xmmB, xmmC); + cc.vpmaxud(xmmA, xmmB, xmmC); + cc.vpmaxuw(xmmA, xmmB, xmmC); + cc.vpminsb(xmmA, xmmB, xmmC); + cc.vpminsd(xmmA, xmmB, xmmC); + cc.vpminsw(xmmA, xmmB, xmmC); + cc.vpminub(xmmA, xmmB, xmmC); + cc.vpminud(xmmA, xmmB, xmmC); + cc.vpminuw(xmmA, xmmB, xmmC); + cc.vpmovmskb(gpd, xmmB); + cc.vpmovsxbd(xmmA, xmmB); + cc.vpmovsxbq(xmmA, xmmB); + cc.vpmovsxbw(xmmA, xmmB); + cc.vpmovsxdq(xmmA, xmmB); + cc.vpmovsxwd(xmmA, xmmB); + cc.vpmovsxwq(xmmA, xmmB); + cc.vpmovzxbd(xmmA, xmmB); + cc.vpmovzxbq(xmmA, xmmB); + cc.vpmovzxbw(xmmA, xmmB); + cc.vpmovzxdq(xmmA, xmmB); + cc.vpmovzxwd(xmmA, xmmB); + cc.vpmovzxwq(xmmA, xmmB); + cc.vpmuldq(xmmA, xmmB, xmmC); + cc.vpmulhrsw(xmmA, xmmB, xmmC); + cc.vpmulhuw(xmmA, xmmB, xmmC); + cc.vpmulhw(xmmA, xmmB, xmmC); + cc.vpmulld(xmmA, xmmB, xmmC); + cc.vpmullw(xmmA, xmmB, xmmC); + cc.vpmuludq(xmmA, xmmB, xmmC); + cc.vpor(xmmA, xmmB, xmmC); + cc.vpsadbw(xmmA, xmmB, xmmC); + cc.vpshufb(xmmA, xmmB, xmmC); + cc.vpshufd(xmmA, xmmB, 0); + cc.vpshufhw(xmmA, xmmB, 0); + cc.vpshuflw(xmmA, xmmB, 0); + cc.vpsignb(xmmA, xmmB, xmmC); + cc.vpsignd(xmmA, xmmB, xmmC); + cc.vpsignw(xmmA, xmmB, xmmC); + cc.vpslld(xmmA, xmmB, xmmC); + cc.vpslld(xmmA, xmmB, 0); + cc.vpslldq(xmmA, xmmB, 0); + cc.vpsllq(xmmA, xmmB, xmmC); + cc.vpsllq(xmmA, xmmB, 0); + cc.vpsllw(xmmA, xmmB, xmmC); + cc.vpsllw(xmmA, xmmB, 0); + cc.vpsrad(xmmA, xmmB, xmmC); + cc.vpsrad(xmmA, xmmB, 0); + cc.vpsraw(xmmA, xmmB, xmmC); + cc.vpsraw(xmmA, xmmB, 0); + cc.vpsrld(xmmA, xmmB, xmmC); + cc.vpsrld(xmmA, xmmB, 0); + cc.vpsrldq(xmmA, xmmB, 0); + cc.vpsrlq(xmmA, xmmB, xmmC); + cc.vpsrlq(xmmA, xmmB, 0); + cc.vpsrlw(xmmA, xmmB, xmmC); + cc.vpsrlw(xmmA, xmmB, 0); + cc.vpsubb(xmmA, xmmB, xmmC); + cc.vpsubd(xmmA, xmmB, xmmC); + cc.vpsubq(xmmA, xmmB, xmmC); + cc.vpsubw(xmmA, xmmB, xmmC); + cc.vpsubsb(xmmA, xmmB, xmmC); + cc.vpsubsw(xmmA, xmmB, xmmC); + cc.vpsubusb(xmmA, xmmB, xmmC); + cc.vpsubusw(xmmA, xmmB, xmmC); + cc.vptest(xmmA, xmmB); + cc.vptest(ymmA, ymmB); + cc.vpunpckhbw(xmmA, xmmB, xmmC); + cc.vpunpckhdq(xmmA, xmmB, xmmC); + cc.vpunpckhqdq(xmmA, xmmB, xmmC); + cc.vpunpckhwd(xmmA, xmmB, xmmC); + cc.vpunpcklbw(xmmA, xmmB, xmmC); + cc.vpunpckldq(xmmA, xmmB, xmmC); + cc.vpunpcklqdq(xmmA, xmmB, xmmC); + cc.vpunpcklwd(xmmA, xmmB, xmmC); + cc.vpxor(xmmA, xmmB, xmmC); + cc.vrcpps(xmmA, xmmB); + cc.vrcpps(ymmA, ymmB); + cc.vrcpss(xmmA, xmmB, xmmC); + cc.vrsqrtps(xmmA, xmmB); + cc.vrsqrtps(ymmA, ymmB); + cc.vrsqrtss(xmmA, xmmB, xmmC); + cc.vroundpd(xmmA, xmmB, 0); + cc.vroundpd(ymmA, ymmB, 0); + cc.vroundps(xmmA, xmmB, 0); + cc.vroundps(ymmA, ymmB, 0); + cc.vroundsd(xmmA, xmmB, xmmC, 0); + cc.vroundss(xmmA, xmmB, xmmC, 0); + cc.vshufpd(xmmA, xmmB, xmmC, 0); + cc.vshufpd(ymmA, ymmB, ymmC, 0); + cc.vshufps(xmmA, xmmB, xmmC, 0); + cc.vshufps(ymmA, ymmB, ymmC, 0); + cc.vsqrtpd(xmmA, xmmB); + cc.vsqrtpd(ymmA, ymmB); + cc.vsqrtps(xmmA, xmmB); + cc.vsqrtps(ymmA, ymmB); + cc.vsqrtsd(xmmA, xmmB, xmmC); + cc.vsqrtss(xmmA, xmmB, xmmC); + cc.vsubpd(xmmA, xmmB, xmmC); + cc.vsubpd(ymmA, ymmB, ymmC); + cc.vsubps(xmmA, xmmB, xmmC); + cc.vsubps(ymmA, ymmB, ymmC); + cc.vsubsd(xmmA, xmmB, xmmC); + cc.vsubss(xmmA, xmmB, xmmC); + cc.vtestps(xmmA, xmmB); + cc.vtestps(ymmA, ymmB); + cc.vtestpd(xmmA, xmmB); + cc.vtestpd(ymmA, ymmB); + cc.vucomisd(xmmA, xmmB); + cc.vucomiss(xmmA, xmmB); + cc.vunpckhpd(xmmA, xmmB, xmmC); + cc.vunpckhpd(ymmA, ymmB, ymmC); + cc.vunpckhps(xmmA, xmmB, xmmC); + cc.vunpckhps(ymmA, ymmB, ymmC); + cc.vunpcklpd(xmmA, xmmB, xmmC); + cc.vunpcklpd(ymmA, ymmB, ymmC); + cc.vunpcklps(xmmA, xmmB, xmmC); + cc.vunpcklps(ymmA, ymmB, ymmC); + cc.vxorpd(xmmA, xmmB, xmmC); + cc.vxorpd(ymmA, ymmB, ymmC); + cc.vxorps(xmmA, xmmB, xmmC); + cc.vxorps(ymmA, ymmB, ymmC); + + // AVX+AESNI. + cc.vaesdec(xmmA, xmmB, xmmC); + cc.vaesdeclast(xmmA, xmmB, xmmC); + cc.vaesenc(xmmA, xmmB, xmmC); + cc.vaesenclast(xmmA, xmmB, xmmC); + cc.vaesimc(xmmA, xmmB); + cc.vaeskeygenassist(xmmA, xmmB, 0); + + // AVX+PCLMULQDQ. + cc.vpclmulqdq(xmmA, xmmB, xmmC, 0); + + // AVX2. + cc.vbroadcastsd(ymmA, xmmB); + cc.vbroadcastss(xmmA, xmmB); + cc.vbroadcastss(ymmA, xmmB); + cc.vextracti128(xmmA, ymmB, 0); + cc.vinserti128(ymmA, ymmB, xmmC, 0); + cc.vmpsadbw(ymmA, ymmB, ymmC, 0); + cc.vpabsb(ymmA, ymmB); + cc.vpabsd(ymmA, ymmB); + cc.vpabsw(ymmA, ymmB); + cc.vpackssdw(ymmA, ymmB, ymmC); + cc.vpacksswb(ymmA, ymmB, ymmC); + cc.vpackusdw(ymmA, ymmB, ymmC); + cc.vpackuswb(ymmA, ymmB, ymmC); + cc.vpaddb(ymmA, ymmB, ymmC); + cc.vpaddd(ymmA, ymmB, ymmC); + cc.vpaddq(ymmA, ymmB, ymmC); + cc.vpaddw(ymmA, ymmB, ymmC); + cc.vpaddsb(ymmA, ymmB, ymmC); + cc.vpaddsw(ymmA, ymmB, ymmC); + cc.vpaddusb(ymmA, ymmB, ymmC); + cc.vpaddusw(ymmA, ymmB, ymmC); + cc.vpalignr(ymmA, ymmB, ymmC, 0); + cc.vpand(ymmA, ymmB, ymmC); + cc.vpandn(ymmA, ymmB, ymmC); + cc.vpavgb(ymmA, ymmB, ymmC); + cc.vpavgw(ymmA, ymmB, ymmC); + cc.vpblendd(xmmA, xmmB, xmmC, 0); + cc.vpblendd(ymmA, ymmB, ymmC, 0); + cc.vpblendvb(ymmA, ymmB, ymmC, ymmA); + cc.vpblendw(ymmA, ymmB, ymmC, 0); + cc.vpbroadcastb(xmmA, xmmB); + cc.vpbroadcastb(ymmA, xmmB); + cc.vpbroadcastd(xmmA, xmmB); + cc.vpbroadcastd(ymmA, xmmB); + cc.vpbroadcastq(xmmA, xmmB); + cc.vpbroadcastq(ymmA, xmmB); + cc.vpbroadcastw(xmmA, xmmB); + cc.vpbroadcastw(ymmA, xmmB); + cc.vpcmpeqb(ymmA, ymmB, ymmC); + cc.vpcmpeqd(ymmA, ymmB, ymmC); + cc.vpcmpeqq(ymmA, ymmB, ymmC); + cc.vpcmpeqw(ymmA, ymmB, ymmC); + cc.vpcmpgtb(ymmA, ymmB, ymmC); + cc.vpcmpgtd(ymmA, ymmB, ymmC); + cc.vpcmpgtq(ymmA, ymmB, ymmC); + cc.vpcmpgtw(ymmA, ymmB, ymmC); + cc.vperm2i128(ymmA, ymmB, ymmC, 0); + cc.vpermd(ymmA, ymmB, ymmC); + cc.vpermps(ymmA, ymmB, ymmC); + cc.vpermpd(ymmA, ymmB, 0); + cc.vpermq(ymmA, ymmB, 0); + cc.vpmovmskb(gpd, ymmB); + cc.vpmovsxbd(ymmA, xmmB); + cc.vpmovsxbq(ymmA, xmmB); + cc.vpmovsxbw(ymmA, xmmB); + cc.vpmovsxdq(ymmA, xmmB); + cc.vpmovsxwd(ymmA, xmmB); + cc.vpmovsxwq(ymmA, xmmB); + cc.vpmovzxbd(ymmA, xmmB); + cc.vpmovzxbq(ymmA, xmmB); + cc.vpmovzxbw(ymmA, xmmB); + cc.vpmovzxdq(ymmA, xmmB); + cc.vpmovzxwd(ymmA, xmmB); + cc.vpmovzxwq(ymmA, xmmB); + cc.vpshufd(ymmA, ymmB, 0); + cc.vpshufhw(ymmA, ymmB, 0); + cc.vpshuflw(ymmA, ymmB, 0); + cc.vpslld(ymmA, ymmB, 0); + cc.vpslldq(ymmA, ymmB, 0); + cc.vpsllq(ymmA, ymmB, 0); + cc.vpsllw(ymmA, ymmB, 0); + cc.vpsrad(ymmA, ymmB, 0); + cc.vpsraw(ymmA, ymmB, 0); + cc.vpsrld(ymmA, ymmB, 0); + cc.vpsrldq(ymmA, ymmB, 0); + cc.vpsrlq(ymmA, ymmB, 0); + cc.vpsrlw(ymmA, ymmB, 0); + cc.vphaddd(ymmA, ymmB, ymmC); + cc.vphaddsw(ymmA, ymmB, ymmC); + cc.vphaddw(ymmA, ymmB, ymmC); + cc.vphsubd(ymmA, ymmB, ymmC); + cc.vphsubsw(ymmA, ymmB, ymmC); + cc.vphsubw(ymmA, ymmB, ymmC); + cc.vpmaddubsw(ymmA, ymmB, ymmC); + cc.vpmaddwd(ymmA, ymmB, ymmC); + cc.vpmaxsb(ymmA, ymmB, ymmC); + cc.vpmaxsd(ymmA, ymmB, ymmC); + cc.vpmaxsw(ymmA, ymmB, ymmC); + cc.vpmaxub(ymmA, ymmB, ymmC); + cc.vpmaxud(ymmA, ymmB, ymmC); + cc.vpmaxuw(ymmA, ymmB, ymmC); + cc.vpminsb(ymmA, ymmB, ymmC); + cc.vpminsd(ymmA, ymmB, ymmC); + cc.vpminsw(ymmA, ymmB, ymmC); + cc.vpminub(ymmA, ymmB, ymmC); + cc.vpminud(ymmA, ymmB, ymmC); + cc.vpminuw(ymmA, ymmB, ymmC); + cc.vpmuldq(ymmA, ymmB, ymmC); + cc.vpmulhrsw(ymmA, ymmB, ymmC); + cc.vpmulhuw(ymmA, ymmB, ymmC); + cc.vpmulhw(ymmA, ymmB, ymmC); + cc.vpmulld(ymmA, ymmB, ymmC); + cc.vpmullw(ymmA, ymmB, ymmC); + cc.vpmuludq(ymmA, ymmB, ymmC); + cc.vpor(ymmA, ymmB, ymmC); + cc.vpsadbw(ymmA, ymmB, ymmC); + cc.vpshufb(ymmA, ymmB, ymmC); + cc.vpsignb(ymmA, ymmB, ymmC); + cc.vpsignd(ymmA, ymmB, ymmC); + cc.vpsignw(ymmA, ymmB, ymmC); + cc.vpslld(ymmA, ymmB, xmmC); + cc.vpsllq(ymmA, ymmB, xmmC); + cc.vpsllvd(xmmA, xmmB, xmmC); + cc.vpsllvd(ymmA, ymmB, ymmC); + cc.vpsllvq(xmmA, xmmB, xmmC); + cc.vpsllvq(ymmA, ymmB, ymmC); + cc.vpsllw(ymmA, ymmB, xmmC); + cc.vpsrad(ymmA, ymmB, xmmC); + cc.vpsravd(xmmA, xmmB, xmmC); + cc.vpsravd(ymmA, ymmB, ymmC); + cc.vpsraw(ymmA, ymmB, xmmC); + cc.vpsrld(ymmA, ymmB, xmmC); + cc.vpsrlq(ymmA, ymmB, xmmC); + cc.vpsrlvd(xmmA, xmmB, xmmC); + cc.vpsrlvd(ymmA, ymmB, ymmC); + cc.vpsrlvq(xmmA, xmmB, xmmC); + cc.vpsrlvq(ymmA, ymmB, ymmC); + cc.vpsrlw(ymmA, ymmB, xmmC); + cc.vpsubb(ymmA, ymmB, ymmC); + cc.vpsubd(ymmA, ymmB, ymmC); + cc.vpsubq(ymmA, ymmB, ymmC); + cc.vpsubsb(ymmA, ymmB, ymmC); + cc.vpsubsw(ymmA, ymmB, ymmC); + cc.vpsubusb(ymmA, ymmB, ymmC); + cc.vpsubusw(ymmA, ymmB, ymmC); + cc.vpsubw(ymmA, ymmB, ymmC); + cc.vpunpckhbw(ymmA, ymmB, ymmC); + cc.vpunpckhdq(ymmA, ymmB, ymmC); + cc.vpunpckhqdq(ymmA, ymmB, ymmC); + cc.vpunpckhwd(ymmA, ymmB, ymmC); + cc.vpunpcklbw(ymmA, ymmB, ymmC); + cc.vpunpckldq(ymmA, ymmB, ymmC); + cc.vpunpcklqdq(ymmA, ymmB, ymmC); + cc.vpunpcklwd(ymmA, ymmB, ymmC); + cc.vpxor(ymmA, ymmB, ymmC); + + // FMA. + cc.vfmadd132pd(xmmA, xmmB, xmmC); + cc.vfmadd132pd(ymmA, ymmB, ymmC); + cc.vfmadd132ps(xmmA, xmmB, xmmC); + cc.vfmadd132ps(ymmA, ymmB, ymmC); + cc.vfmadd132sd(xmmA, xmmB, xmmC); + cc.vfmadd132ss(xmmA, xmmB, xmmC); + cc.vfmadd213pd(xmmA, xmmB, xmmC); + cc.vfmadd213pd(ymmA, ymmB, ymmC); + cc.vfmadd213ps(xmmA, xmmB, xmmC); + cc.vfmadd213ps(ymmA, ymmB, ymmC); + cc.vfmadd213sd(xmmA, xmmB, xmmC); + cc.vfmadd213ss(xmmA, xmmB, xmmC); + cc.vfmadd231pd(xmmA, xmmB, xmmC); + cc.vfmadd231pd(ymmA, ymmB, ymmC); + cc.vfmadd231ps(xmmA, xmmB, xmmC); + cc.vfmadd231ps(ymmA, ymmB, ymmC); + cc.vfmadd231sd(xmmA, xmmB, xmmC); + cc.vfmadd231ss(xmmA, xmmB, xmmC); + cc.vfmaddsub132pd(xmmA, xmmB, xmmC); + cc.vfmaddsub132pd(ymmA, ymmB, ymmC); + cc.vfmaddsub132ps(xmmA, xmmB, xmmC); + cc.vfmaddsub132ps(ymmA, ymmB, ymmC); + cc.vfmaddsub213pd(xmmA, xmmB, xmmC); + cc.vfmaddsub213pd(ymmA, ymmB, ymmC); + cc.vfmaddsub213ps(xmmA, xmmB, xmmC); + cc.vfmaddsub213ps(ymmA, ymmB, ymmC); + cc.vfmaddsub231pd(xmmA, xmmB, xmmC); + cc.vfmaddsub231pd(ymmA, ymmB, ymmC); + cc.vfmaddsub231ps(xmmA, xmmB, xmmC); + cc.vfmaddsub231ps(ymmA, ymmB, ymmC); + cc.vfmsub132pd(xmmA, xmmB, xmmC); + cc.vfmsub132pd(ymmA, ymmB, ymmC); + cc.vfmsub132ps(xmmA, xmmB, xmmC); + cc.vfmsub132ps(ymmA, ymmB, ymmC); + cc.vfmsub132sd(xmmA, xmmB, xmmC); + cc.vfmsub132ss(xmmA, xmmB, xmmC); + cc.vfmsub213pd(xmmA, xmmB, xmmC); + cc.vfmsub213pd(ymmA, ymmB, ymmC); + cc.vfmsub213ps(xmmA, xmmB, xmmC); + cc.vfmsub213ps(ymmA, ymmB, ymmC); + cc.vfmsub213sd(xmmA, xmmB, xmmC); + cc.vfmsub213ss(xmmA, xmmB, xmmC); + cc.vfmsub231pd(xmmA, xmmB, xmmC); + cc.vfmsub231pd(ymmA, ymmB, ymmC); + cc.vfmsub231ps(xmmA, xmmB, xmmC); + cc.vfmsub231ps(ymmA, ymmB, ymmC); + cc.vfmsub231sd(xmmA, xmmB, xmmC); + cc.vfmsub231ss(xmmA, xmmB, xmmC); + cc.vfmsubadd132pd(xmmA, xmmB, xmmC); + cc.vfmsubadd132pd(ymmA, ymmB, ymmC); + cc.vfmsubadd132ps(xmmA, xmmB, xmmC); + cc.vfmsubadd132ps(ymmA, ymmB, ymmC); + cc.vfmsubadd213pd(xmmA, xmmB, xmmC); + cc.vfmsubadd213pd(ymmA, ymmB, ymmC); + cc.vfmsubadd213ps(xmmA, xmmB, xmmC); + cc.vfmsubadd213ps(ymmA, ymmB, ymmC); + cc.vfmsubadd231pd(xmmA, xmmB, xmmC); + cc.vfmsubadd231pd(ymmA, ymmB, ymmC); + cc.vfmsubadd231ps(xmmA, xmmB, xmmC); + cc.vfmsubadd231ps(ymmA, ymmB, ymmC); + cc.vfnmadd132pd(xmmA, xmmB, xmmC); + cc.vfnmadd132pd(ymmA, ymmB, ymmC); + cc.vfnmadd132ps(xmmA, xmmB, xmmC); + cc.vfnmadd132ps(ymmA, ymmB, ymmC); + cc.vfnmadd132sd(xmmA, xmmB, xmmC); + cc.vfnmadd132ss(xmmA, xmmB, xmmC); + cc.vfnmadd213pd(xmmA, xmmB, xmmC); + cc.vfnmadd213pd(ymmA, ymmB, ymmC); + cc.vfnmadd213ps(xmmA, xmmB, xmmC); + cc.vfnmadd213ps(ymmA, ymmB, ymmC); + cc.vfnmadd213sd(xmmA, xmmB, xmmC); + cc.vfnmadd213ss(xmmA, xmmB, xmmC); + cc.vfnmadd231pd(xmmA, xmmB, xmmC); + cc.vfnmadd231pd(ymmA, ymmB, ymmC); + cc.vfnmadd231ps(xmmA, xmmB, xmmC); + cc.vfnmadd231ps(ymmA, ymmB, ymmC); + cc.vfnmadd231sd(xmmA, xmmB, xmmC); + cc.vfnmadd231ss(xmmA, xmmB, xmmC); + cc.vfnmsub132pd(xmmA, xmmB, xmmC); + cc.vfnmsub132pd(ymmA, ymmB, ymmC); + cc.vfnmsub132ps(xmmA, xmmB, xmmC); + cc.vfnmsub132ps(ymmA, ymmB, ymmC); + cc.vfnmsub132sd(xmmA, xmmB, xmmC); + cc.vfnmsub132ss(xmmA, xmmB, xmmC); + cc.vfnmsub213pd(xmmA, xmmB, xmmC); + cc.vfnmsub213pd(ymmA, ymmB, ymmC); + cc.vfnmsub213ps(xmmA, xmmB, xmmC); + cc.vfnmsub213ps(ymmA, ymmB, ymmC); + cc.vfnmsub213sd(xmmA, xmmB, xmmC); + cc.vfnmsub213ss(xmmA, xmmB, xmmC); + cc.vfnmsub231pd(xmmA, xmmB, xmmC); + cc.vfnmsub231pd(ymmA, ymmB, ymmC); + cc.vfnmsub231ps(xmmA, xmmB, xmmC); + cc.vfnmsub231ps(ymmA, ymmB, ymmC); + cc.vfnmsub231sd(xmmA, xmmB, xmmC); + cc.vfnmsub231ss(xmmA, xmmB, xmmC); + } + else { + x86::Mem m = x86::ptr(gpz); + x86::Mem m128 = x86::xmmword_ptr(gpz); + x86::Mem m256 = x86::xmmword_ptr(gpz); + x86::Mem vx_ptr = x86::ptr(gpz, xmmD); + x86::Mem vy_ptr = x86::ptr(gpz, ymmD); + + cc.vaddpd(xmmA, xmmB, m); + cc.vaddpd(ymmA, ymmB, m); + cc.vaddps(xmmA, xmmB, m); + cc.vaddps(ymmA, ymmB, m); + cc.vaddsd(xmmA, xmmB, m); + cc.vaddss(xmmA, xmmB, m); + cc.vaddsubpd(xmmA, xmmB, m); + cc.vaddsubpd(ymmA, ymmB, m); + cc.vaddsubps(xmmA, xmmB, m); + cc.vaddsubps(ymmA, ymmB, m); + cc.vandpd(xmmA, xmmB, m); + cc.vandpd(ymmA, ymmB, m); + cc.vandps(xmmA, xmmB, m); + cc.vandps(ymmA, ymmB, m); + cc.vandnpd(xmmA, xmmB, m); + cc.vandnpd(ymmA, ymmB, m); + cc.vandnps(xmmA, xmmB, m); + cc.vandnps(ymmA, ymmB, m); + cc.vblendpd(xmmA, xmmB, m, 0); + cc.vblendpd(ymmA, ymmB, m, 0); + cc.vblendps(xmmA, xmmB, m, 0); + cc.vblendps(ymmA, ymmB, m, 0); + cc.vblendvpd(xmmA, xmmB, m, xmmA); + cc.vblendvpd(ymmA, ymmB, m, ymmA); + cc.vbroadcastf128(ymmA, m); + cc.vbroadcastsd(ymmA, m); + cc.vbroadcastss(xmmA, m); + cc.vbroadcastss(ymmA, m); + cc.vcmppd(xmmA, xmmB, m, 0); + cc.vcmppd(ymmA, ymmB, m, 0); + cc.vcmpps(xmmA, xmmB, m, 0); + cc.vcmpps(ymmA, ymmB, m, 0); + cc.vcmpsd(xmmA, xmmB, m, 0); + cc.vcmpss(xmmA, xmmB, m, 0); + cc.vcomisd(xmmA, m); + cc.vcomiss(xmmA, m); + cc.vcvtdq2pd(xmmA, m); + cc.vcvtdq2pd(ymmA, m); + cc.vcvtdq2ps(xmmA, m); + cc.vcvtdq2ps(ymmA, m); + cc.vcvtpd2dq(xmmA, m128); + cc.vcvtpd2dq(xmmA, m256); + cc.vcvtpd2ps(xmmA, m128); + cc.vcvtpd2ps(xmmA, m256); + cc.vcvtps2dq(xmmA, m); + cc.vcvtps2dq(ymmA, m); + cc.vcvtps2pd(xmmA, m); + cc.vcvtps2pd(ymmA, m); + cc.vcvtsd2si(gpd, m); + cc.vcvtsd2ss(xmmA, xmmB, m); + cc.vcvtsi2sd(xmmA, xmmB, m); + cc.vcvtsi2ss(xmmA, xmmB, m); + cc.vcvtss2sd(xmmA, xmmB, m); + cc.vcvtss2si(gpd, m); + cc.vcvttpd2dq(xmmA, m128); + cc.vcvttpd2dq(xmmA, m256); + cc.vcvttps2dq(xmmA, m); + cc.vcvttps2dq(ymmA, m); + cc.vcvttsd2si(gpd, m); + cc.vcvttss2si(gpd, m); + cc.vdivpd(xmmA, xmmB, m); + cc.vdivpd(ymmA, ymmB, m); + cc.vdivps(xmmA, xmmB, m); + cc.vdivps(ymmA, ymmB, m); + cc.vdivsd(xmmA, xmmB, m); + cc.vdivss(xmmA, xmmB, m); + cc.vdppd(xmmA, xmmB, m, 0); + cc.vdpps(xmmA, xmmB, m, 0); + cc.vdpps(ymmA, ymmB, m, 0); + cc.vextractf128(m, ymmB, 0); + cc.vextractps(m, xmmB, 0); + cc.vhaddpd(xmmA, xmmB, m); + cc.vhaddpd(ymmA, ymmB, m); + cc.vhaddps(xmmA, xmmB, m); + cc.vhaddps(ymmA, ymmB, m); + cc.vhsubpd(xmmA, xmmB, m); + cc.vhsubpd(ymmA, ymmB, m); + cc.vhsubps(xmmA, xmmB, m); + cc.vhsubps(ymmA, ymmB, m); + cc.vinsertf128(ymmA, ymmB, m, 0); + cc.vinsertps(xmmA, xmmB, m, 0); + cc.vlddqu(xmmA, m); + cc.vlddqu(ymmA, m); + cc.vmaskmovps(xmmA, xmmB, m); + cc.vmaskmovps(ymmA, ymmB, m); + cc.vmaskmovps(m, xmmB, xmmC); + cc.vmaskmovps(m, ymmB, ymmC); + cc.vmaskmovpd(xmmA, xmmB, m); + cc.vmaskmovpd(ymmA, ymmB, m); + cc.vmaskmovpd(m, xmmB, xmmC); + cc.vmaskmovpd(m, ymmB, ymmC); + cc.vmaxpd(xmmA, xmmB, m); + cc.vmaxpd(ymmA, ymmB, m); + cc.vmaxps(xmmA, xmmB, m); + cc.vmaxps(ymmA, ymmB, m); + cc.vmaxsd(xmmA, xmmB, m); + cc.vmaxss(xmmA, xmmB, m); + cc.vminpd(xmmA, xmmB, m); + cc.vminpd(ymmA, ymmB, m); + cc.vminps(xmmA, xmmB, m); + cc.vminps(ymmA, ymmB, m); + cc.vminsd(xmmA, xmmB, m); + cc.vminss(xmmA, xmmB, m); + cc.vmovapd(xmmA, m); + cc.vmovapd(m, xmmB); + cc.vmovapd(ymmA, m); + cc.vmovapd(m, ymmB); + cc.vmovaps(xmmA, m); + cc.vmovaps(m, xmmB); + cc.vmovaps(ymmA, m); + cc.vmovaps(m, ymmB); + cc.vmovd(xmmA, m); + cc.vmovd(m, xmmB); + cc.vmovddup(xmmA, m); + cc.vmovddup(ymmA, m); + cc.vmovdqa(xmmA, m); + cc.vmovdqa(m, xmmB); + cc.vmovdqa(ymmA, m); + cc.vmovdqa(m, ymmB); + cc.vmovdqu(xmmA, m); + cc.vmovdqu(m, xmmB); + cc.vmovdqu(ymmA, m); + cc.vmovdqu(m, ymmB); + cc.vmovhpd(xmmA, xmmB, m); + cc.vmovhps(xmmA, xmmB, m); + cc.vmovhps(m, xmmB); + cc.vmovlpd(xmmA, xmmB, m); + cc.vmovlpd(m, xmmB); + cc.vmovlps(xmmA, xmmB, m); + cc.vmovlps(m, xmmB); + cc.vmovntdq(m, xmmB); + cc.vmovntdq(m, ymmB); + cc.vmovntdqa(xmmA, m); + cc.vmovntpd(m, xmmB); + cc.vmovntpd(m, ymmB); + cc.vmovntps(m, xmmB); + cc.vmovntps(m, ymmB); + cc.vmovsd(xmmA, m); + cc.vmovsd(m, xmmB); + cc.vmovshdup(xmmA, m); + cc.vmovshdup(ymmA, m); + cc.vmovsldup(xmmA, m); + cc.vmovsldup(ymmA, m); + cc.vmovss(xmmA, m); + cc.vmovss(m, xmmB); + cc.vmovupd(xmmA, m); + cc.vmovupd(m, xmmB); + cc.vmovupd(ymmA, m); + cc.vmovupd(m, ymmB); + cc.vmovups(xmmA, m); + cc.vmovups(m, xmmB); + cc.vmovups(ymmA, m); + cc.vmovups(m, ymmB); + cc.vmpsadbw(xmmA, xmmB, m, 0); + cc.vmulpd(xmmA, xmmB, m); + cc.vmulpd(ymmA, ymmB, m); + cc.vmulps(xmmA, xmmB, m); + cc.vmulps(ymmA, ymmB, m); + cc.vmulsd(xmmA, xmmB, m); + cc.vmulss(xmmA, xmmB, m); + cc.vorpd(xmmA, xmmB, m); + cc.vorpd(ymmA, ymmB, m); + cc.vorps(xmmA, xmmB, m); + cc.vorps(ymmA, ymmB, m); + cc.vpabsb(xmmA, m); + cc.vpabsd(xmmA, m); + cc.vpabsw(xmmA, m); + cc.vpackssdw(xmmA, xmmB, m); + cc.vpacksswb(xmmA, xmmB, m); + cc.vpackusdw(xmmA, xmmB, m); + cc.vpackuswb(xmmA, xmmB, m); + cc.vpaddb(xmmA, xmmB, m); + cc.vpaddd(xmmA, xmmB, m); + cc.vpaddq(xmmA, xmmB, m); + cc.vpaddw(xmmA, xmmB, m); + cc.vpaddsb(xmmA, xmmB, m); + cc.vpaddsw(xmmA, xmmB, m); + cc.vpaddusb(xmmA, xmmB, m); + cc.vpaddusw(xmmA, xmmB, m); + cc.vpalignr(xmmA, xmmB, m, 0); + cc.vpand(xmmA, xmmB, m); + cc.vpandn(xmmA, xmmB, m); + cc.vpavgb(xmmA, xmmB, m); + cc.vpavgw(xmmA, xmmB, m); + cc.vpblendvb(xmmA, xmmB, m, xmmA); + cc.vpblendw(xmmA, xmmB, m, 0); + cc.vpcmpeqb(xmmA, xmmB, m); + cc.vpcmpeqd(xmmA, xmmB, m); + cc.vpcmpeqq(xmmA, xmmB, m); + cc.vpcmpeqw(xmmA, xmmB, m); + cc.vpcmpgtb(xmmA, xmmB, m); + cc.vpcmpgtd(xmmA, xmmB, m); + cc.vpcmpgtq(xmmA, xmmB, m); + cc.vpcmpgtw(xmmA, xmmB, m); + cc.vpermilpd(xmmA, xmmB, m); + cc.vpermilpd(ymmA, ymmB, m); + cc.vpermilpd(xmmA, m, 0); + cc.vpermilpd(ymmA, m, 0); + cc.vpermilps(xmmA, xmmB, m); + cc.vpermilps(ymmA, ymmB, m); + cc.vpermilps(xmmA, m, 0); + cc.vpermilps(ymmA, m, 0); + cc.vperm2f128(ymmA, ymmB, m, 0); + cc.vpextrb(m, xmmB, 0); + cc.vpextrd(m, xmmB, 0); + if (cc.is64Bit()) cc.vpextrq(m, xmmB, 0); + cc.vpextrw(m, xmmB, 0); + cc.vphaddd(xmmA, xmmB, m); + cc.vphaddsw(xmmA, xmmB, m); + cc.vphaddw(xmmA, xmmB, m); + cc.vphminposuw(xmmA, m); + cc.vphsubd(xmmA, xmmB, m); + cc.vphsubsw(xmmA, xmmB, m); + cc.vphsubw(xmmA, xmmB, m); + cc.vpinsrb(xmmA, xmmB, m, 0); + cc.vpinsrd(xmmA, xmmB, m, 0); + cc.vpinsrw(xmmA, xmmB, m, 0); + cc.vpmaddubsw(xmmA, xmmB, m); + cc.vpmaddwd(xmmA, xmmB, m); + cc.vpmaxsb(xmmA, xmmB, m); + cc.vpmaxsd(xmmA, xmmB, m); + cc.vpmaxsw(xmmA, xmmB, m); + cc.vpmaxub(xmmA, xmmB, m); + cc.vpmaxud(xmmA, xmmB, m); + cc.vpmaxuw(xmmA, xmmB, m); + cc.vpminsb(xmmA, xmmB, m); + cc.vpminsd(xmmA, xmmB, m); + cc.vpminsw(xmmA, xmmB, m); + cc.vpminub(xmmA, xmmB, m); + cc.vpminud(xmmA, xmmB, m); + cc.vpminuw(xmmA, xmmB, m); + cc.vpmovsxbd(xmmA, m); + cc.vpmovsxbq(xmmA, m); + cc.vpmovsxbw(xmmA, m); + cc.vpmovsxdq(xmmA, m); + cc.vpmovsxwd(xmmA, m); + cc.vpmovsxwq(xmmA, m); + cc.vpmovzxbd(xmmA, m); + cc.vpmovzxbq(xmmA, m); + cc.vpmovzxbw(xmmA, m); + cc.vpmovzxdq(xmmA, m); + cc.vpmovzxwd(xmmA, m); + cc.vpmovzxwq(xmmA, m); + cc.vpmuldq(xmmA, xmmB, m); + cc.vpmulhrsw(xmmA, xmmB, m); + cc.vpmulhuw(xmmA, xmmB, m); + cc.vpmulhw(xmmA, xmmB, m); + cc.vpmulld(xmmA, xmmB, m); + cc.vpmullw(xmmA, xmmB, m); + cc.vpmuludq(xmmA, xmmB, m); + cc.vpor(xmmA, xmmB, m); + cc.vpsadbw(xmmA, xmmB, m); + cc.vpshufb(xmmA, xmmB, m); + cc.vpshufd(xmmA, m, 0); + cc.vpshufhw(xmmA, m, 0); + cc.vpshuflw(xmmA, m, 0); + cc.vpsignb(xmmA, xmmB, m); + cc.vpsignd(xmmA, xmmB, m); + cc.vpsignw(xmmA, xmmB, m); + cc.vpslld(xmmA, xmmB, m); + cc.vpsllq(xmmA, xmmB, m); + cc.vpsllw(xmmA, xmmB, m); + cc.vpsrad(xmmA, xmmB, m); + cc.vpsraw(xmmA, xmmB, m); + cc.vpsrld(xmmA, xmmB, m); + cc.vpsrlq(xmmA, xmmB, m); + cc.vpsrlw(xmmA, xmmB, m); + cc.vpsubb(xmmA, xmmB, m); + cc.vpsubd(xmmA, xmmB, m); + cc.vpsubq(xmmA, xmmB, m); + cc.vpsubw(xmmA, xmmB, m); + cc.vpsubsb(xmmA, xmmB, m); + cc.vpsubsw(xmmA, xmmB, m); + cc.vpsubusb(xmmA, xmmB, m); + cc.vpsubusw(xmmA, xmmB, m); + cc.vptest(xmmA, m); + cc.vptest(ymmA, m); + cc.vpunpckhbw(xmmA, xmmB, m); + cc.vpunpckhdq(xmmA, xmmB, m); + cc.vpunpckhqdq(xmmA, xmmB, m); + cc.vpunpckhwd(xmmA, xmmB, m); + cc.vpunpcklbw(xmmA, xmmB, m); + cc.vpunpckldq(xmmA, xmmB, m); + cc.vpunpcklqdq(xmmA, xmmB, m); + cc.vpunpcklwd(xmmA, xmmB, m); + cc.vpxor(xmmA, xmmB, m); + cc.vrcpps(xmmA, m); + cc.vrcpps(ymmA, m); + cc.vrcpss(xmmA, xmmB, m); + cc.vrsqrtps(xmmA, m); + cc.vrsqrtps(ymmA, m); + cc.vrsqrtss(xmmA, xmmB, m); + cc.vroundpd(xmmA, m, 0); + cc.vroundpd(ymmA, m, 0); + cc.vroundps(xmmA, m, 0); + cc.vroundps(ymmA, m, 0); + cc.vroundsd(xmmA, xmmB, m, 0); + cc.vroundss(xmmA, xmmB, m, 0); + cc.vshufpd(xmmA, xmmB, m, 0); + cc.vshufpd(ymmA, ymmB, m, 0); + cc.vshufps(xmmA, xmmB, m, 0); + cc.vshufps(ymmA, ymmB, m, 0); + cc.vsqrtpd(xmmA, m); + cc.vsqrtpd(ymmA, m); + cc.vsqrtps(xmmA, m); + cc.vsqrtps(ymmA, m); + cc.vsqrtsd(xmmA, xmmB, m); + cc.vsqrtss(xmmA, xmmB, m); + cc.vsubpd(xmmA, xmmB, m); + cc.vsubpd(ymmA, ymmB, m); + cc.vsubps(xmmA, xmmB, m); + cc.vsubps(ymmA, ymmB, m); + cc.vsubsd(xmmA, xmmB, m); + cc.vsubss(xmmA, xmmB, m); + cc.vtestps(xmmA, m); + cc.vtestps(ymmA, m); + cc.vtestpd(xmmA, m); + cc.vtestpd(ymmA, m); + cc.vucomisd(xmmA, m); + cc.vucomiss(xmmA, m); + cc.vunpckhpd(xmmA, xmmB, m); + cc.vunpckhpd(ymmA, ymmB, m); + cc.vunpckhps(xmmA, xmmB, m); + cc.vunpckhps(ymmA, ymmB, m); + cc.vunpcklpd(xmmA, xmmB, m); + cc.vunpcklpd(ymmA, ymmB, m); + cc.vunpcklps(xmmA, xmmB, m); + cc.vunpcklps(ymmA, ymmB, m); + cc.vxorpd(xmmA, xmmB, m); + cc.vxorpd(ymmA, ymmB, m); + cc.vxorps(xmmA, xmmB, m); + cc.vxorps(ymmA, ymmB, m); + + // AVX+AESNI. + cc.vaesdec(xmmA, xmmB, m); + cc.vaesdeclast(xmmA, xmmB, m); + cc.vaesenc(xmmA, xmmB, m); + cc.vaesenclast(xmmA, xmmB, m); + cc.vaesimc(xmmA, m); + cc.vaeskeygenassist(xmmA, m, 0); + + // AVX+PCLMULQDQ. + cc.vpclmulqdq(xmmA, xmmB, m, 0); + + // AVX2. + cc.vbroadcasti128(ymmA, m); + cc.vextracti128(m, ymmB, 0); + cc.vgatherdpd(xmmA, vx_ptr, xmmC); + cc.vgatherdpd(ymmA, vx_ptr, ymmC); + cc.vgatherdps(xmmA, vx_ptr, xmmC); + cc.vgatherdps(ymmA, vy_ptr, ymmC); + cc.vgatherqpd(xmmA, vx_ptr, xmmC); + cc.vgatherqpd(ymmA, vy_ptr, ymmC); + cc.vgatherqps(xmmA, vx_ptr, xmmC); + cc.vgatherqps(xmmA, vy_ptr, xmmC); + cc.vinserti128(ymmA, ymmB, m, 0); + cc.vmovntdqa(ymmA, m); + cc.vmpsadbw(ymmA, ymmB, m, 0); + cc.vpabsb(ymmA, m); + cc.vpabsd(ymmA, m); + cc.vpabsw(ymmA, m); + cc.vpackssdw(ymmA, ymmB, m); + cc.vpacksswb(ymmA, ymmB, m); + cc.vpackusdw(ymmA, ymmB, m); + cc.vpackuswb(ymmA, ymmB, m); + cc.vpaddb(ymmA, ymmB, m); + cc.vpaddd(ymmA, ymmB, m); + cc.vpaddq(ymmA, ymmB, m); + cc.vpaddw(ymmA, ymmB, m); + cc.vpaddsb(ymmA, ymmB, m); + cc.vpaddsw(ymmA, ymmB, m); + cc.vpaddusb(ymmA, ymmB, m); + cc.vpaddusw(ymmA, ymmB, m); + cc.vpalignr(ymmA, ymmB, m, 0); + cc.vpand(ymmA, ymmB, m); + cc.vpandn(ymmA, ymmB, m); + cc.vpavgb(ymmA, ymmB, m); + cc.vpavgw(ymmA, ymmB, m); + cc.vpblendd(xmmA, xmmB, m, 0); + cc.vpblendd(ymmA, ymmB, m, 0); + cc.vpblendvb(ymmA, ymmB, m, ymmA); + cc.vpblendw(ymmA, ymmB, m, 0); + cc.vpbroadcastb(xmmA, m); + cc.vpbroadcastb(ymmA, m); + cc.vpbroadcastd(xmmA, m); + cc.vpbroadcastd(ymmA, m); + cc.vpbroadcastq(xmmA, m); + cc.vpbroadcastq(ymmA, m); + cc.vpbroadcastw(xmmA, m); + cc.vpbroadcastw(ymmA, m); + cc.vpcmpeqb(ymmA, ymmB, m); + cc.vpcmpeqd(ymmA, ymmB, m); + cc.vpcmpeqq(ymmA, ymmB, m); + cc.vpcmpeqw(ymmA, ymmB, m); + cc.vpcmpgtb(ymmA, ymmB, m); + cc.vpcmpgtd(ymmA, ymmB, m); + cc.vpcmpgtq(ymmA, ymmB, m); + cc.vpcmpgtw(ymmA, ymmB, m); + cc.vperm2i128(ymmA, ymmB, m, 0); + cc.vpermd(ymmA, ymmB, m); + cc.vpermps(ymmA, ymmB, m); + cc.vpermpd(ymmA, m, 0); + cc.vpermq(ymmA, m, 0); + cc.vpgatherdd(xmmA, vx_ptr, xmmC); + cc.vpgatherdd(ymmA, vy_ptr, ymmC); + cc.vpgatherdq(xmmA, vx_ptr, xmmC); + cc.vpgatherdq(ymmA, vx_ptr, ymmC); + cc.vpgatherqd(xmmA, vx_ptr, xmmC); + cc.vpgatherqd(xmmA, vy_ptr, xmmC); + cc.vpgatherqq(xmmA, vx_ptr, xmmC); + cc.vpgatherqq(ymmA, vy_ptr, ymmC); + cc.vpmovsxbd(ymmA, m); + cc.vpmovsxbq(ymmA, m); + cc.vpmovsxbw(ymmA, m); + cc.vpmovsxdq(ymmA, m); + cc.vpmovsxwd(ymmA, m); + cc.vpmovsxwq(ymmA, m); + cc.vpmovzxbd(ymmA, m); + cc.vpmovzxbq(ymmA, m); + cc.vpmovzxbw(ymmA, m); + cc.vpmovzxdq(ymmA, m); + cc.vpmovzxwd(ymmA, m); + cc.vpmovzxwq(ymmA, m); + cc.vpshufd(ymmA, m, 0); + cc.vpshufhw(ymmA, m, 0); + cc.vpshuflw(ymmA, m, 0); + cc.vphaddd(ymmA, ymmB, m); + cc.vphaddsw(ymmA, ymmB, m); + cc.vphaddw(ymmA, ymmB, m); + cc.vphsubd(ymmA, ymmB, m); + cc.vphsubsw(ymmA, ymmB, m); + cc.vphsubw(ymmA, ymmB, m); + cc.vpmaddubsw(ymmA, ymmB, m); + cc.vpmaddwd(ymmA, ymmB, m); + cc.vpmaskmovd(m, xmmB, xmmC); + cc.vpmaskmovd(m, ymmB, ymmC); + cc.vpmaskmovd(xmmA, xmmB, m); + cc.vpmaskmovd(ymmA, ymmB, m); + cc.vpmaskmovq(m, xmmB, xmmC); + cc.vpmaskmovq(m, ymmB, ymmC); + cc.vpmaskmovq(xmmA, xmmB, m); + cc.vpmaskmovq(ymmA, ymmB, m); + cc.vpmaxsb(ymmA, ymmB, m); + cc.vpmaxsd(ymmA, ymmB, m); + cc.vpmaxsw(ymmA, ymmB, m); + cc.vpmaxub(ymmA, ymmB, m); + cc.vpmaxud(ymmA, ymmB, m); + cc.vpmaxuw(ymmA, ymmB, m); + cc.vpminsb(ymmA, ymmB, m); + cc.vpminsd(ymmA, ymmB, m); + cc.vpminsw(ymmA, ymmB, m); + cc.vpminub(ymmA, ymmB, m); + cc.vpminud(ymmA, ymmB, m); + cc.vpminuw(ymmA, ymmB, m); + cc.vpmuldq(ymmA, ymmB, m); + cc.vpmulhrsw(ymmA, ymmB, m); + cc.vpmulhuw(ymmA, ymmB, m); + cc.vpmulhw(ymmA, ymmB, m); + cc.vpmulld(ymmA, ymmB, m); + cc.vpmullw(ymmA, ymmB, m); + cc.vpmuludq(ymmA, ymmB, m); + cc.vpor(ymmA, ymmB, m); + cc.vpsadbw(ymmA, ymmB, m); + cc.vpshufb(ymmA, ymmB, m); + cc.vpsignb(ymmA, ymmB, m); + cc.vpsignd(ymmA, ymmB, m); + cc.vpsignw(ymmA, ymmB, m); + cc.vpslld(ymmA, ymmB, m); + cc.vpsllq(ymmA, ymmB, m); + cc.vpsllvd(xmmA, xmmB, m); + cc.vpsllvd(ymmA, ymmB, m); + cc.vpsllvq(xmmA, xmmB, m); + cc.vpsllvq(ymmA, ymmB, m); + cc.vpsllw(ymmA, ymmB, m); + cc.vpsrad(ymmA, ymmB, m); + cc.vpsravd(xmmA, xmmB, m); + cc.vpsravd(ymmA, ymmB, m); + cc.vpsraw(ymmA, ymmB, m); + cc.vpsrld(ymmA, ymmB, m); + cc.vpsrlq(ymmA, ymmB, m); + cc.vpsrlvd(xmmA, xmmB, m); + cc.vpsrlvd(ymmA, ymmB, m); + cc.vpsrlvq(xmmA, xmmB, m); + cc.vpsrlvq(ymmA, ymmB, m); + cc.vpsrlw(ymmA, ymmB, m); + cc.vpsubb(ymmA, ymmB, m); + cc.vpsubd(ymmA, ymmB, m); + cc.vpsubq(ymmA, ymmB, m); + cc.vpsubsb(ymmA, ymmB, m); + cc.vpsubsw(ymmA, ymmB, m); + cc.vpsubusb(ymmA, ymmB, m); + cc.vpsubusw(ymmA, ymmB, m); + cc.vpsubw(ymmA, ymmB, m); + cc.vpunpckhbw(ymmA, ymmB, m); + cc.vpunpckhdq(ymmA, ymmB, m); + cc.vpunpckhqdq(ymmA, ymmB, m); + cc.vpunpckhwd(ymmA, ymmB, m); + cc.vpunpcklbw(ymmA, ymmB, m); + cc.vpunpckldq(ymmA, ymmB, m); + cc.vpunpcklqdq(ymmA, ymmB, m); + cc.vpunpcklwd(ymmA, ymmB, m); + cc.vpxor(ymmA, ymmB, m); + } +} + +static void generateAvxSequence(BaseEmitter& emitter, InstForm form, bool emitPrologEpilog) { + using namespace asmjit::x86; + + if (emitter.isAssembler()) { + Assembler& cc = *emitter.as<Assembler>(); + + if (emitPrologEpilog) { + FuncDetail func; + func.init(FuncSignatureT<void, void*, const void*, size_t>(CallConvId::kHost), cc.environment()); + + FuncFrame frame; + frame.init(func); + frame.addDirtyRegs(eax, ymm0, ymm1, ymm2, ymm3); + frame.finalize(); + + cc.emitProlog(frame); + generateAvxSequenceInternal(cc, form, eax, ymm0, ymm1, ymm2, ymm3); + cc.emitEpilog(frame); + } + else { + generateAvxSequenceInternal(cc, form, eax, ymm0, ymm1, ymm2, ymm3); + } + } +#ifndef ASMJIT_NO_BUILDER + else if (emitter.isBuilder()) { + Builder& cc = *emitter.as<Builder>(); + + if (emitPrologEpilog) { + FuncDetail func; + func.init(FuncSignatureT<void, void*, const void*, size_t>(CallConvId::kHost), cc.environment()); + + FuncFrame frame; + frame.init(func); + frame.addDirtyRegs(eax, ymm0, ymm1, ymm2, ymm3); + frame.finalize(); + + cc.emitProlog(frame); + generateAvxSequenceInternal(cc, form, eax, ymm0, ymm1, ymm2, ymm3); + cc.emitEpilog(frame); + } + else { + generateAvxSequenceInternal(cc, form, eax, ymm0, ymm1, ymm2, ymm3); + } + } +#endif +#ifndef ASMJIT_NO_COMPILER + else if (emitter.isCompiler()) { + Compiler& cc = *emitter.as<Compiler>(); + + Gp gp = cc.newGpz("gp"); + Ymm a = cc.newYmm("a"); + Ymm b = cc.newYmm("b"); + Ymm c = cc.newYmm("c"); + Ymm d = cc.newYmm("d"); + + cc.addFunc(FuncSignatureT<void>(CallConvId::kHost)); + generateAvxSequenceInternal(cc, form, gp, a, b, c, d); + cc.endFunc(); + } +#endif +} + +// Generates a long sequence of AVX512 instructions. +template<typename Emitter> +static void generateAvx512SequenceInternal( + Emitter& cc, + InstForm form, + const x86::Gp& gp, + const x86::KReg& kA, const x86::KReg& kB, const x86::KReg& kC, + const x86::Vec& vecA, const x86::Vec& vecB, const x86::Vec& vecC, const x86::Vec& vecD) { + + x86::Gp gpd = gp.r32(); + x86::Gp gpq = gp.r64(); + x86::Gp gpz = cc.is32Bit() ? gpd : gpq; + + x86::Xmm xmmA = vecA.xmm(); + x86::Xmm xmmB = vecB.xmm(); + x86::Xmm xmmC = vecC.xmm(); + x86::Xmm xmmD = vecD.xmm(); + + x86::Ymm ymmA = vecA.ymm(); + x86::Ymm ymmB = vecB.ymm(); + x86::Ymm ymmC = vecC.ymm(); + x86::Ymm ymmD = vecD.ymm(); + + x86::Zmm zmmA = vecA.zmm(); + x86::Zmm zmmB = vecB.zmm(); + x86::Zmm zmmC = vecC.zmm(); + x86::Zmm zmmD = vecD.zmm(); + + cc.xor_(gpd, gpd); + cc.vxorps(xmmA, xmmA, xmmA); + cc.vxorps(xmmB, xmmB, xmmB); + cc.vxorps(xmmC, xmmC, xmmC); + cc.vxorps(xmmD, xmmD, xmmD); + + if (form == InstForm::kReg) { + cc.kaddb(kA, kB, kC); + cc.kaddd(kA, kB, kC); + cc.kaddq(kA, kB, kC); + cc.kaddw(kA, kB, kC); + cc.kandb(kA, kB, kC); + cc.kandd(kA, kB, kC); + cc.kandnb(kA, kB, kC); + cc.kandnd(kA, kB, kC); + cc.kandnq(kA, kB, kC); + cc.kandnw(kA, kB, kC); + cc.kandq(kA, kB, kC); + cc.kandw(kA, kB, kC); + cc.kmovb(kA, kB); + cc.kmovb(kA, gpd); + cc.kmovb(gpd, kB); + cc.kmovd(kA, kB); + cc.kmovd(kA, gpd); + cc.kmovd(gpd, kB); + cc.kmovq(kA, kB); + if (cc.is64Bit()) cc.kmovq(kA, gpq); + if (cc.is64Bit()) cc.kmovq(gpq, kB); + cc.kmovw(kA, kB); + cc.kmovw(kA, gpd); + cc.kmovw(gpd, kB); + cc.knotb(kA, kB); + cc.knotd(kA, kB); + cc.knotq(kA, kB); + cc.knotw(kA, kB); + cc.korb(kA, kB, kC); + cc.kord(kA, kB, kC); + cc.korq(kA, kB, kC); + cc.kortestb(kA, kB); + cc.kortestd(kA, kB); + cc.kortestq(kA, kB); + cc.kortestw(kA, kB); + cc.korw(kA, kB, kC); + cc.kshiftlb(kA, kB, 0); + cc.kshiftld(kA, kB, 0); + cc.kshiftlq(kA, kB, 0); + cc.kshiftlw(kA, kB, 0); + cc.kshiftrb(kA, kB, 0); + cc.kshiftrd(kA, kB, 0); + cc.kshiftrq(kA, kB, 0); + cc.kshiftrw(kA, kB, 0); + cc.ktestb(kA, kB); + cc.ktestd(kA, kB); + cc.ktestq(kA, kB); + cc.ktestw(kA, kB); + cc.kunpckbw(kA, kB, kC); + cc.kunpckdq(kA, kB, kC); + cc.kunpckwd(kA, kB, kC); + cc.kxnorb(kA, kB, kC); + cc.kxnord(kA, kB, kC); + cc.kxnorq(kA, kB, kC); + cc.kxnorw(kA, kB, kC); + cc.kxorb(kA, kB, kC); + cc.kxord(kA, kB, kC); + cc.kxorq(kA, kB, kC); + cc.kxorw(kA, kB, kC); + cc.nop(); + + cc.evex().vaddpd(xmmA, xmmB, xmmC); + cc.evex().vaddpd(ymmA, ymmB, ymmC); + cc.evex().vaddpd(zmmA, zmmB, zmmC); + cc.evex().vaddps(xmmA, xmmB, xmmC); + cc.evex().vaddps(ymmA, ymmB, ymmC); + cc.evex().vaddps(zmmA, zmmB, zmmC); + cc.evex().vaddsd(xmmA, xmmB, xmmC); + cc.evex().vaddss(xmmA, xmmB, xmmC); + cc.evex().valignd(xmmA, xmmB, xmmC, 0); + cc.evex().valignd(ymmA, ymmB, ymmC, 0); + cc.evex().valignd(zmmA, zmmB, zmmC, 0); + cc.evex().valignq(xmmA, xmmB, xmmC, 0); + cc.evex().valignq(ymmA, ymmB, ymmC, 0); + cc.evex().valignq(zmmA, zmmB, zmmC, 0); + cc.evex().vandnpd(xmmA, xmmB, xmmC); + cc.evex().vandnpd(ymmA, ymmB, ymmC); + cc.evex().vandnpd(zmmA, zmmB, zmmC); + cc.evex().vandnps(xmmA, xmmB, xmmC); + cc.evex().vandnps(ymmA, ymmB, ymmC); + cc.evex().vandnps(zmmA, zmmB, zmmC); + cc.evex().vandpd(xmmA, xmmB, xmmC); + cc.evex().vandpd(ymmA, ymmB, ymmC); + cc.evex().vandpd(zmmA, zmmB, zmmC); + cc.evex().vandps(xmmA, xmmB, xmmC); + cc.evex().vandps(ymmA, ymmB, ymmC); + cc.evex().vandps(zmmA, zmmB, zmmC); + cc.evex().vblendmpd(xmmA, xmmB, xmmC); + cc.evex().vblendmpd(ymmA, ymmB, ymmC); + cc.evex().vblendmpd(zmmA, zmmB, zmmC); + cc.evex().vblendmps(xmmA, xmmB, xmmC); + cc.evex().vblendmps(ymmA, ymmB, ymmC); + cc.evex().vblendmps(zmmA, zmmB, zmmC); + cc.evex().vbroadcastf32x2(ymmA, xmmB); + cc.evex().vbroadcastf32x2(zmmA, xmmB); + cc.evex().vbroadcasti32x2(xmmA, xmmB); + cc.evex().vbroadcasti32x2(ymmA, xmmB); + cc.evex().vbroadcasti32x2(zmmA, xmmB); + cc.evex().vbroadcastsd(ymmA, xmmB); + cc.evex().vbroadcastsd(zmmA, xmmB); + cc.evex().vbroadcastss(xmmA, xmmB); + cc.evex().vbroadcastss(ymmA, xmmB); + cc.evex().vbroadcastss(zmmA, xmmB); + cc.evex().vcmppd(kA, xmmB, xmmC, 0); + cc.evex().vcmppd(kA, ymmB, ymmC, 0); + cc.evex().vcmppd(kA, zmmB, zmmC, 0); + cc.evex().vcmpps(kA, xmmB, xmmC, 0); + cc.evex().vcmpps(kA, ymmB, ymmC, 0); + cc.evex().vcmpps(kA, zmmB, zmmC, 0); + cc.evex().vcmpsd(kA, xmmB, xmmC, 0); + cc.evex().vcmpss(kA, xmmB, xmmC, 0); + cc.evex().vcomisd(xmmA, xmmB); + cc.evex().vcomiss(xmmA, xmmB); + cc.evex().vcompresspd(xmmA, xmmB); + cc.evex().vcompresspd(ymmA, ymmB); + cc.evex().vcompresspd(zmmA, zmmB); + cc.evex().vcompressps(xmmA, xmmB); + cc.evex().vcompressps(ymmA, ymmB); + cc.evex().vcompressps(zmmA, zmmB); + cc.evex().vcvtdq2pd(xmmA, xmmB); + cc.evex().vcvtdq2pd(ymmA, xmmB); + cc.evex().vcvtdq2pd(zmmA, ymmB); + cc.evex().vcvtdq2ps(xmmA, xmmB); + cc.evex().vcvtdq2ps(ymmA, ymmB); + cc.evex().vcvtdq2ps(zmmA, zmmB); + cc.evex().vcvtpd2dq(xmmA, xmmB); + cc.evex().vcvtpd2dq(xmmA, ymmB); + cc.evex().vcvtpd2dq(ymmA, zmmB); + cc.evex().vcvtpd2qq(xmmA, xmmB); + cc.evex().vcvtpd2qq(ymmA, ymmB); + cc.evex().vcvtpd2qq(zmmA, zmmB); + cc.evex().vcvtpd2udq(xmmA, xmmB); + cc.evex().vcvtpd2udq(xmmA, ymmB); + cc.evex().vcvtpd2udq(ymmA, zmmB); + cc.evex().vcvtpd2uqq(xmmA, xmmB); + cc.evex().vcvtpd2uqq(ymmA, ymmB); + cc.evex().vcvtpd2uqq(zmmA, zmmB); + cc.evex().vcvtph2ps(xmmA, xmmB); + cc.evex().vcvtph2ps(ymmA, xmmB); + cc.evex().vcvtph2ps(zmmA, ymmB); + cc.evex().vcvtps2dq(xmmA, xmmB); + cc.evex().vcvtps2dq(ymmA, ymmB); + cc.evex().vcvtps2dq(zmmA, zmmB); + cc.evex().vcvtps2pd(xmmA, xmmB); + cc.evex().vcvtps2pd(ymmA, xmmB); + cc.evex().vcvtps2pd(zmmA, ymmB); + cc.evex().vcvtps2ph(xmmA, xmmB, 0); + cc.evex().vcvtps2ph(xmmA, ymmB, 0); + cc.evex().vcvtps2ph(ymmA, zmmB, 0); + cc.evex().vcvtps2qq(xmmA, xmmB); + cc.evex().vcvtps2qq(ymmA, xmmB); + cc.evex().vcvtps2qq(zmmA, ymmB); + cc.evex().vcvtps2udq(xmmA, xmmB); + cc.evex().vcvtps2udq(ymmA, ymmB); + cc.evex().vcvtps2udq(zmmA, zmmB); + cc.evex().vcvtps2uqq(xmmA, xmmB); + cc.evex().vcvtps2uqq(ymmA, xmmB); + cc.evex().vcvtps2uqq(zmmA, ymmB); + cc.evex().vcvtqq2pd(xmmA, xmmB); + cc.evex().vcvtqq2pd(ymmA, ymmB); + cc.evex().vcvtqq2pd(zmmA, zmmB); + cc.evex().vcvtqq2ps(xmmA, xmmB); + cc.evex().vcvtqq2ps(xmmA, ymmB); + cc.evex().vcvtqq2ps(ymmA, zmmB); + cc.evex().vcvtsd2si(gpd, xmmB); + if (cc.is64Bit()) cc.evex().vcvtsd2si(gpq, xmmB); + cc.evex().vcvtsd2ss(xmmA, xmmB, xmmC); + cc.evex().vcvtsd2usi(gpd, xmmB); + if (cc.is64Bit()) cc.evex().vcvtsd2usi(gpq, xmmB); + cc.evex().vcvtsi2sd(xmmA, xmmB, gpd); + if (cc.is64Bit()) cc.evex().vcvtsi2sd(xmmA, xmmB, gpq); + cc.evex().vcvtsi2ss(xmmA, xmmB, gpd); + if (cc.is64Bit()) cc.evex().vcvtsi2ss(xmmA, xmmB, gpq); + cc.evex().vcvtss2sd(xmmA, xmmB, xmmC); + cc.evex().vcvtss2si(gpd, xmmB); + if (cc.is64Bit()) cc.evex().vcvtss2si(gpq, xmmB); + cc.evex().vcvtss2usi(gpd, xmmB); + if (cc.is64Bit()) cc.evex().vcvtss2usi(gpq, xmmB); + cc.evex().vcvttpd2dq(xmmA, xmmB); + cc.evex().vcvttpd2dq(xmmA, ymmB); + cc.evex().vcvttpd2dq(ymmA, zmmB); + cc.evex().vcvttpd2qq(xmmA, xmmB); + cc.evex().vcvttpd2qq(ymmA, ymmB); + cc.evex().vcvttpd2qq(zmmA, zmmB); + cc.evex().vcvttpd2udq(xmmA, xmmB); + cc.evex().vcvttpd2udq(xmmA, ymmB); + cc.evex().vcvttpd2udq(ymmA, zmmB); + cc.evex().vcvttpd2uqq(xmmA, xmmB); + cc.evex().vcvttpd2uqq(ymmA, ymmB); + cc.evex().vcvttpd2uqq(zmmA, zmmB); + cc.evex().vcvttps2dq(xmmA, xmmB); + cc.evex().vcvttps2dq(ymmA, ymmB); + cc.evex().vcvttps2dq(zmmA, zmmB); + cc.evex().vcvttps2qq(xmmA, xmmB); + cc.evex().vcvttps2qq(ymmA, xmmB); + cc.evex().vcvttps2qq(zmmA, ymmB); + cc.evex().vcvttps2udq(xmmA, xmmB); + cc.evex().vcvttps2udq(ymmA, ymmB); + cc.evex().vcvttps2udq(zmmA, zmmB); + cc.evex().vcvttps2uqq(xmmA, xmmB); + cc.evex().vcvttps2uqq(ymmA, xmmB); + cc.evex().vcvttps2uqq(zmmA, ymmB); + cc.evex().vcvttsd2si(gpd, xmmB); + if (cc.is64Bit()) cc.evex().vcvttsd2si(gpq, xmmB); + cc.evex().vcvttsd2usi(gpd, xmmB); + if (cc.is64Bit()) cc.evex().vcvttsd2usi(gpq, xmmB); + cc.evex().vcvttss2si(gpd, xmmB); + if (cc.is64Bit()) cc.evex().vcvttss2si(gpq, xmmB); + cc.evex().vcvttss2usi(gpd, xmmB); + if (cc.is64Bit()) cc.evex().vcvttss2usi(gpq, xmmB); + cc.evex().vcvtudq2pd(xmmA, xmmB); + cc.evex().vcvtudq2pd(ymmA, xmmB); + cc.evex().vcvtudq2pd(zmmA, ymmB); + cc.evex().vcvtudq2ps(xmmA, xmmB); + cc.evex().vcvtudq2ps(ymmA, ymmB); + cc.evex().vcvtudq2ps(zmmA, zmmB); + cc.evex().vcvtuqq2pd(xmmA, xmmB); + cc.evex().vcvtuqq2pd(ymmA, ymmB); + cc.evex().vcvtuqq2pd(zmmA, zmmB); + cc.evex().vcvtuqq2ps(xmmA, xmmB); + cc.evex().vcvtuqq2ps(xmmA, ymmB); + cc.evex().vcvtuqq2ps(ymmA, zmmB); + cc.evex().vcvtusi2sd(xmmA, xmmB, gpd); + if (cc.is64Bit()) cc.evex().vcvtusi2sd(xmmA, xmmB, gpq); + cc.evex().vcvtusi2ss(xmmA, xmmB, gpd); + if (cc.is64Bit()) cc.evex().vcvtusi2ss(xmmA, xmmB, gpq); + cc.evex().vdbpsadbw(xmmA, xmmB, xmmC, 0); + cc.evex().vdbpsadbw(ymmA, ymmB, ymmC, 0); + cc.evex().vdbpsadbw(zmmA, zmmB, zmmC, 0); + cc.evex().vdivpd(xmmA, xmmB, xmmC); + cc.evex().vdivpd(ymmA, ymmB, ymmC); + cc.evex().vdivpd(zmmA, zmmB, zmmC); + cc.evex().vdivps(xmmA, xmmB, xmmC); + cc.evex().vdivps(ymmA, ymmB, ymmC); + cc.evex().vdivps(zmmA, zmmB, zmmC); + cc.evex().vdivsd(xmmA, xmmB, xmmC); + cc.evex().vdivss(xmmA, xmmB, xmmC); + cc.evex().vexp2pd(zmmA, zmmB); + cc.evex().vexp2ps(zmmA, zmmB); + cc.evex().vexpandpd(xmmA, xmmB); + cc.evex().vexpandpd(ymmA, ymmB); + cc.evex().vexpandpd(zmmA, zmmB); + cc.evex().vexpandps(xmmA, xmmB); + cc.evex().vexpandps(ymmA, ymmB); + cc.evex().vexpandps(zmmA, zmmB); + cc.evex().vextractf32x4(xmmA, ymmB, 0); + cc.evex().vextractf32x4(xmmA, zmmB, 0); + cc.evex().vextractf32x8(ymmA, zmmB, 0); + cc.evex().vextractf64x2(xmmA, ymmB, 0); + cc.evex().vextractf64x2(xmmA, zmmB, 0); + cc.evex().vextractf64x4(ymmA, zmmB, 0); + cc.evex().vextracti32x4(xmmA, ymmB, 0); + cc.evex().vextracti32x4(xmmA, zmmB, 0); + cc.evex().vextracti32x8(ymmA, zmmB, 0); + cc.evex().vextracti64x2(xmmA, ymmB, 0); + cc.evex().vextracti64x2(xmmA, zmmB, 0); + cc.evex().vextracti64x4(ymmA, zmmB, 0); + cc.evex().vextractps(gpd, xmmB, 0); + cc.evex().vfixupimmpd(xmmA, xmmB, xmmC, 0); + cc.evex().vfixupimmpd(ymmA, ymmB, ymmC, 0); + cc.evex().vfixupimmpd(zmmA, zmmB, zmmC, 0); + cc.evex().vfixupimmps(xmmA, xmmB, xmmC, 0); + cc.evex().vfixupimmps(ymmA, ymmB, ymmC, 0); + cc.evex().vfixupimmps(zmmA, zmmB, zmmC, 0); + cc.evex().vfixupimmsd(xmmA, xmmB, xmmC, 0); + cc.evex().vfixupimmss(xmmA, xmmB, xmmC, 0); + cc.evex().vfmadd132pd(xmmA, xmmB, xmmC); + cc.evex().vfmadd132pd(ymmA, ymmB, ymmC); + cc.evex().vfmadd132pd(zmmA, zmmB, zmmC); + cc.evex().vfmadd132ps(xmmA, xmmB, xmmC); + cc.evex().vfmadd132ps(ymmA, ymmB, ymmC); + cc.evex().vfmadd132ps(zmmA, zmmB, zmmC); + cc.evex().vfmadd132sd(xmmA, xmmB, xmmC); + cc.evex().vfmadd132ss(xmmA, xmmB, xmmC); + cc.evex().vfmadd213pd(xmmA, xmmB, xmmC); + cc.evex().vfmadd213pd(ymmA, ymmB, ymmC); + cc.evex().vfmadd213pd(zmmA, zmmB, zmmC); + cc.evex().vfmadd213ps(xmmA, xmmB, xmmC); + cc.evex().vfmadd213ps(ymmA, ymmB, ymmC); + cc.evex().vfmadd213ps(zmmA, zmmB, zmmC); + cc.evex().vfmadd213sd(xmmA, xmmB, xmmC); + cc.evex().vfmadd213ss(xmmA, xmmB, xmmC); + cc.evex().vfmadd231pd(xmmA, xmmB, xmmC); + cc.evex().vfmadd231pd(ymmA, ymmB, ymmC); + cc.evex().vfmadd231pd(zmmA, zmmB, zmmC); + cc.evex().vfmadd231ps(xmmA, xmmB, xmmC); + cc.evex().vfmadd231ps(ymmA, ymmB, ymmC); + cc.evex().vfmadd231ps(zmmA, zmmB, zmmC); + cc.evex().vfmadd231sd(xmmA, xmmB, xmmC); + cc.evex().vfmadd231ss(xmmA, xmmB, xmmC); + cc.evex().vfmaddsub132pd(xmmA, xmmB, xmmC); + cc.evex().vfmaddsub132pd(ymmA, ymmB, ymmC); + cc.evex().vfmaddsub132pd(zmmA, zmmB, zmmC); + cc.evex().vfmaddsub132ps(xmmA, xmmB, xmmC); + cc.evex().vfmaddsub132ps(ymmA, ymmB, ymmC); + cc.evex().vfmaddsub132ps(zmmA, zmmB, zmmC); + cc.evex().vfmaddsub213pd(xmmA, xmmB, xmmC); + cc.evex().vfmaddsub213pd(ymmA, ymmB, ymmC); + cc.evex().vfmaddsub213pd(zmmA, zmmB, zmmC); + cc.evex().vfmaddsub213ps(xmmA, xmmB, xmmC); + cc.evex().vfmaddsub213ps(ymmA, ymmB, ymmC); + cc.evex().vfmaddsub213ps(zmmA, zmmB, zmmC); + cc.evex().vfmaddsub231pd(xmmA, xmmB, xmmC); + cc.evex().vfmaddsub231pd(ymmA, ymmB, ymmC); + cc.evex().vfmaddsub231pd(zmmA, zmmB, zmmC); + cc.evex().vfmaddsub231ps(xmmA, xmmB, xmmC); + cc.evex().vfmaddsub231ps(ymmA, ymmB, ymmC); + cc.evex().vfmaddsub231ps(zmmA, zmmB, zmmC); + cc.evex().vfmsub132pd(xmmA, xmmB, xmmC); + cc.evex().vfmsub132pd(ymmA, ymmB, ymmC); + cc.evex().vfmsub132pd(zmmA, zmmB, zmmC); + cc.evex().vfmsub132ps(xmmA, xmmB, xmmC); + cc.evex().vfmsub132ps(ymmA, ymmB, ymmC); + cc.evex().vfmsub132ps(zmmA, zmmB, zmmC); + cc.evex().vfmsub132sd(xmmA, xmmB, xmmC); + cc.evex().vfmsub132ss(xmmA, xmmB, xmmC); + cc.evex().vfmsub213pd(xmmA, xmmB, xmmC); + cc.evex().vfmsub213pd(ymmA, ymmB, ymmC); + cc.evex().vfmsub213pd(zmmA, zmmB, zmmC); + cc.evex().vfmsub213ps(xmmA, xmmB, xmmC); + cc.evex().vfmsub213ps(ymmA, ymmB, ymmC); + cc.evex().vfmsub213ps(zmmA, zmmB, zmmC); + cc.evex().vfmsub213sd(xmmA, xmmB, xmmC); + cc.evex().vfmsub213ss(xmmA, xmmB, xmmC); + cc.evex().vfmsub231pd(xmmA, xmmB, xmmC); + cc.evex().vfmsub231pd(ymmA, ymmB, ymmC); + cc.evex().vfmsub231pd(zmmA, zmmB, zmmC); + cc.evex().vfmsub231ps(xmmA, xmmB, xmmC); + cc.evex().vfmsub231ps(ymmA, ymmB, ymmC); + cc.evex().vfmsub231ps(zmmA, zmmB, zmmC); + cc.evex().vfmsub231sd(xmmA, xmmB, xmmC); + cc.evex().vfmsub231ss(xmmA, xmmB, xmmC); + cc.evex().vfmsubadd132pd(xmmA, xmmB, xmmC); + cc.evex().vfmsubadd132pd(ymmA, ymmB, ymmC); + cc.evex().vfmsubadd132pd(zmmA, zmmB, zmmC); + cc.evex().vfmsubadd132ps(xmmA, xmmB, xmmC); + cc.evex().vfmsubadd132ps(ymmA, ymmB, ymmC); + cc.evex().vfmsubadd132ps(zmmA, zmmB, zmmC); + cc.evex().vfmsubadd213pd(xmmA, xmmB, xmmC); + cc.evex().vfmsubadd213pd(ymmA, ymmB, ymmC); + cc.evex().vfmsubadd213pd(zmmA, zmmB, zmmC); + cc.evex().vfmsubadd213ps(xmmA, xmmB, xmmC); + cc.evex().vfmsubadd213ps(ymmA, ymmB, ymmC); + cc.evex().vfmsubadd213ps(zmmA, zmmB, zmmC); + cc.evex().vfmsubadd231pd(xmmA, xmmB, xmmC); + cc.evex().vfmsubadd231pd(ymmA, ymmB, ymmC); + cc.evex().vfmsubadd231pd(zmmA, zmmB, zmmC); + cc.evex().vfmsubadd231ps(xmmA, xmmB, xmmC); + cc.evex().vfmsubadd231ps(ymmA, ymmB, ymmC); + cc.evex().vfmsubadd231ps(zmmA, zmmB, zmmC); + cc.evex().vfnmadd132pd(xmmA, xmmB, xmmC); + cc.evex().vfnmadd132pd(ymmA, ymmB, ymmC); + cc.evex().vfnmadd132pd(zmmA, zmmB, zmmC); + cc.evex().vfnmadd132ps(xmmA, xmmB, xmmC); + cc.evex().vfnmadd132ps(ymmA, ymmB, ymmC); + cc.evex().vfnmadd132ps(zmmA, zmmB, zmmC); + cc.evex().vfnmadd132sd(xmmA, xmmB, xmmC); + cc.evex().vfnmadd132ss(xmmA, xmmB, xmmC); + cc.evex().vfnmadd213pd(xmmA, xmmB, xmmC); + cc.evex().vfnmadd213pd(ymmA, ymmB, ymmC); + cc.evex().vfnmadd213pd(zmmA, zmmB, zmmC); + cc.evex().vfnmadd213ps(xmmA, xmmB, xmmC); + cc.evex().vfnmadd213ps(ymmA, ymmB, ymmC); + cc.evex().vfnmadd213ps(zmmA, zmmB, zmmC); + cc.evex().vfnmadd213sd(xmmA, xmmB, xmmC); + cc.evex().vfnmadd213ss(xmmA, xmmB, xmmC); + cc.evex().vfnmadd231pd(xmmA, xmmB, xmmC); + cc.evex().vfnmadd231pd(ymmA, ymmB, ymmC); + cc.evex().vfnmadd231pd(zmmA, zmmB, zmmC); + cc.evex().vfnmadd231ps(xmmA, xmmB, xmmC); + cc.evex().vfnmadd231ps(ymmA, ymmB, ymmC); + cc.evex().vfnmadd231ps(zmmA, zmmB, zmmC); + cc.evex().vfnmadd231sd(xmmA, xmmB, xmmC); + cc.evex().vfnmadd231ss(xmmA, xmmB, xmmC); + cc.evex().vfnmsub132pd(xmmA, xmmB, xmmC); + cc.evex().vfnmsub132pd(ymmA, ymmB, ymmC); + cc.evex().vfnmsub132pd(zmmA, zmmB, zmmC); + cc.evex().vfnmsub132ps(xmmA, xmmB, xmmC); + cc.evex().vfnmsub132ps(ymmA, ymmB, ymmC); + cc.evex().vfnmsub132ps(zmmA, zmmB, zmmC); + cc.evex().vfnmsub132sd(xmmA, xmmB, xmmC); + cc.evex().vfnmsub132ss(xmmA, xmmB, xmmC); + cc.evex().vfnmsub213pd(xmmA, xmmB, xmmC); + cc.evex().vfnmsub213pd(ymmA, ymmB, ymmC); + cc.evex().vfnmsub213pd(zmmA, zmmB, zmmC); + cc.evex().vfnmsub213ps(xmmA, xmmB, xmmC); + cc.evex().vfnmsub213ps(ymmA, ymmB, ymmC); + cc.evex().vfnmsub213ps(zmmA, zmmB, zmmC); + cc.evex().vfnmsub213sd(xmmA, xmmB, xmmC); + cc.evex().vfnmsub213ss(xmmA, xmmB, xmmC); + cc.evex().vfnmsub231pd(xmmA, xmmB, xmmC); + cc.evex().vfnmsub231pd(ymmA, ymmB, ymmC); + cc.evex().vfnmsub231pd(zmmA, zmmB, zmmC); + cc.evex().vfnmsub231ps(xmmA, xmmB, xmmC); + cc.evex().vfnmsub231ps(ymmA, ymmB, ymmC); + cc.evex().vfnmsub231ps(zmmA, zmmB, zmmC); + cc.evex().vfnmsub231sd(xmmA, xmmB, xmmC); + cc.evex().vfnmsub231ss(xmmA, xmmB, xmmC); + cc.evex().vfpclasspd(kA, xmmB, 0); + cc.evex().vfpclasspd(kA, ymmB, 0); + cc.evex().vfpclasspd(kA, zmmB, 0); + cc.evex().vfpclassps(kA, xmmB, 0); + cc.evex().vfpclassps(kA, ymmB, 0); + cc.evex().vfpclassps(kA, zmmB, 0); + cc.evex().vfpclasssd(kA, xmmB, 0); + cc.evex().vfpclassss(kA, xmmB, 0); + cc.evex().vgetexppd(xmmA, xmmB); + cc.evex().vgetexppd(ymmA, ymmB); + cc.evex().vgetexppd(zmmA, zmmB); + cc.evex().vgetexpps(xmmA, xmmB); + cc.evex().vgetexpps(ymmA, ymmB); + cc.evex().vgetexpps(zmmA, zmmB); + cc.evex().vgetexpsd(xmmA, xmmB, xmmC); + cc.evex().vgetexpss(xmmA, xmmB, xmmC); + cc.evex().vgetmantpd(xmmA, xmmB, 0); + cc.evex().vgetmantpd(ymmA, ymmB, 0); + cc.evex().vgetmantpd(zmmA, zmmB, 0); + cc.evex().vgetmantps(xmmA, xmmB, 0); + cc.evex().vgetmantps(ymmA, ymmB, 0); + cc.evex().vgetmantps(zmmA, zmmB, 0); + cc.evex().vgetmantsd(xmmA, xmmB, xmmC, 0); + cc.evex().vgetmantss(xmmA, xmmB, xmmC, 0); + cc.evex().vinsertf32x4(ymmA, ymmB, xmmC, 0); + cc.evex().vinsertf32x4(zmmA, zmmB, xmmC, 0); + cc.evex().vinsertf32x8(zmmA, zmmB, ymmC, 0); + cc.evex().vinsertf64x2(ymmA, ymmB, xmmC, 0); + cc.evex().vinsertf64x2(zmmA, zmmB, xmmC, 0); + cc.evex().vinsertf64x4(zmmA, zmmB, ymmC, 0); + cc.evex().vinserti32x4(ymmA, ymmB, xmmC, 0); + cc.evex().vinserti32x4(zmmA, zmmB, xmmC, 0); + cc.evex().vinserti32x8(zmmA, zmmB, ymmC, 0); + cc.evex().vinserti64x2(ymmA, ymmB, xmmC, 0); + cc.evex().vinserti64x2(zmmA, zmmB, xmmC, 0); + cc.evex().vinserti64x4(zmmA, zmmB, ymmC, 0); + cc.evex().vinsertps(xmmA, xmmB, xmmC, 0); + cc.evex().vmaxpd(xmmA, xmmB, xmmC); + cc.evex().vmaxpd(ymmA, ymmB, ymmC); + cc.evex().vmaxpd(zmmA, zmmB, zmmC); + cc.evex().vmaxps(xmmA, xmmB, xmmC); + cc.evex().vmaxps(ymmA, ymmB, ymmC); + cc.evex().vmaxps(zmmA, zmmB, zmmC); + cc.evex().vmaxsd(xmmA, xmmB, xmmC); + cc.evex().vmaxss(xmmA, xmmB, xmmC); + cc.evex().vminpd(xmmA, xmmB, xmmC); + cc.evex().vminpd(ymmA, ymmB, ymmC); + cc.evex().vminpd(zmmA, zmmB, zmmC); + cc.evex().vminps(xmmA, xmmB, xmmC); + cc.evex().vminps(ymmA, ymmB, ymmC); + cc.evex().vminps(zmmA, zmmB, zmmC); + cc.evex().vminsd(xmmA, xmmB, xmmC); + cc.evex().vminss(xmmA, xmmB, xmmC); + cc.evex().vmovapd(xmmA, xmmB); + cc.evex().vmovapd(xmmA, xmmB); + cc.evex().vmovapd(ymmA, ymmB); + cc.evex().vmovapd(ymmA, ymmB); + cc.evex().vmovapd(zmmA, zmmB); + cc.evex().vmovapd(zmmA, zmmB); + cc.evex().vmovaps(xmmA, xmmB); + cc.evex().vmovaps(xmmA, xmmB); + cc.evex().vmovaps(ymmA, ymmB); + cc.evex().vmovaps(ymmA, ymmB); + cc.evex().vmovaps(zmmA, zmmB); + cc.evex().vmovaps(zmmA, zmmB); + cc.evex().vmovd(gpd, xmmB); + cc.evex().vmovd(xmmA, gpd); + cc.evex().vmovddup(xmmA, xmmB); + cc.evex().vmovddup(ymmA, ymmB); + cc.evex().vmovddup(zmmA, zmmB); + cc.evex().vmovdqa32(xmmA, xmmB); + cc.evex().vmovdqa32(xmmA, xmmB); + cc.evex().vmovdqa32(ymmA, ymmB); + cc.evex().vmovdqa32(ymmA, ymmB); + cc.evex().vmovdqa32(zmmA, zmmB); + cc.evex().vmovdqa32(zmmA, zmmB); + cc.evex().vmovdqa64(xmmA, xmmB); + cc.evex().vmovdqa64(xmmA, xmmB); + cc.evex().vmovdqa64(ymmA, ymmB); + cc.evex().vmovdqa64(ymmA, ymmB); + cc.evex().vmovdqa64(zmmA, zmmB); + cc.evex().vmovdqa64(zmmA, zmmB); + cc.evex().vmovdqu16(xmmA, xmmB); + cc.evex().vmovdqu16(xmmA, xmmB); + cc.evex().vmovdqu16(ymmA, ymmB); + cc.evex().vmovdqu16(ymmA, ymmB); + cc.evex().vmovdqu16(zmmA, zmmB); + cc.evex().vmovdqu16(zmmA, zmmB); + cc.evex().vmovdqu32(xmmA, xmmB); + cc.evex().vmovdqu32(xmmA, xmmB); + cc.evex().vmovdqu32(ymmA, ymmB); + cc.evex().vmovdqu32(ymmA, ymmB); + cc.evex().vmovdqu32(zmmA, zmmB); + cc.evex().vmovdqu32(zmmA, zmmB); + cc.evex().vmovdqu64(xmmA, xmmB); + cc.evex().vmovdqu64(xmmA, xmmB); + cc.evex().vmovdqu64(ymmA, ymmB); + cc.evex().vmovdqu64(ymmA, ymmB); + cc.evex().vmovdqu64(zmmA, zmmB); + cc.evex().vmovdqu64(zmmA, zmmB); + cc.evex().vmovdqu8(xmmA, xmmB); + cc.evex().vmovdqu8(xmmA, xmmB); + cc.evex().vmovdqu8(ymmA, ymmB); + cc.evex().vmovdqu8(ymmA, ymmB); + cc.evex().vmovdqu8(zmmA, zmmB); + cc.evex().vmovdqu8(zmmA, zmmB); + cc.evex().vmovhlps(xmmA, xmmB, xmmC); + if (cc.is64Bit()) cc.evex().vmovq(gpq, xmmB); + if (cc.is64Bit()) cc.evex().vmovq(xmmA, gpq); + cc.evex().vmovq(xmmA, xmmB); + cc.evex().vmovsd(xmmA, xmmB, xmmC); + cc.evex().vmovshdup(xmmA, xmmB); + cc.evex().vmovshdup(ymmA, ymmB); + cc.evex().vmovshdup(zmmA, zmmB); + cc.evex().vmovsldup(xmmA, xmmB); + cc.evex().vmovsldup(ymmA, ymmB); + cc.evex().vmovsldup(zmmA, zmmB); + cc.evex().vmovss(xmmA, xmmB, xmmC); + cc.evex().vmovupd(xmmA, xmmB); + cc.evex().vmovupd(xmmA, xmmB); + cc.evex().vmovupd(ymmA, ymmB); + cc.evex().vmovupd(ymmA, ymmB); + cc.evex().vmovupd(zmmA, zmmB); + cc.evex().vmovupd(zmmA, zmmB); + cc.evex().vmovups(xmmA, xmmB); + cc.evex().vmovups(xmmA, xmmB); + cc.evex().vmovups(ymmA, ymmB); + cc.evex().vmovups(ymmA, ymmB); + cc.evex().vmovups(zmmA, zmmB); + cc.evex().vmovups(zmmA, zmmB); + cc.evex().vmulpd(xmmA, xmmB, xmmC); + cc.evex().vmulpd(ymmA, ymmB, ymmC); + cc.evex().vmulpd(zmmA, zmmB, zmmC); + cc.evex().vmulps(xmmA, xmmB, xmmC); + cc.evex().vmulps(ymmA, ymmB, ymmC); + cc.evex().vmulps(zmmA, zmmB, zmmC); + cc.evex().vmulsd(xmmA, xmmB, xmmC); + cc.evex().vmulss(xmmA, xmmB, xmmC); + cc.evex().vorpd(xmmA, xmmB, xmmC); + cc.evex().vorpd(ymmA, ymmB, ymmC); + cc.evex().vorpd(zmmA, zmmB, zmmC); + cc.evex().vorps(xmmA, xmmB, xmmC); + cc.evex().vorps(ymmA, ymmB, ymmC); + cc.evex().vorps(zmmA, zmmB, zmmC); + cc.evex().vpabsb(xmmA, xmmB); + cc.evex().vpabsb(ymmA, ymmB); + cc.evex().vpabsb(zmmA, zmmB); + cc.evex().vpabsd(xmmA, xmmB); + cc.evex().vpabsd(ymmA, ymmB); + cc.evex().vpabsd(zmmA, zmmB); + cc.evex().vpabsq(xmmA, xmmB); + cc.evex().vpabsq(ymmA, ymmB); + cc.evex().vpabsq(zmmA, zmmB); + cc.evex().vpabsw(xmmA, xmmB); + cc.evex().vpabsw(ymmA, ymmB); + cc.evex().vpabsw(zmmA, zmmB); + cc.evex().vpackssdw(xmmA, xmmB, xmmC); + cc.evex().vpackssdw(ymmA, ymmB, ymmC); + cc.evex().vpackssdw(zmmA, zmmB, zmmC); + cc.evex().vpacksswb(xmmA, xmmB, xmmC); + cc.evex().vpacksswb(ymmA, ymmB, ymmC); + cc.evex().vpacksswb(zmmA, zmmB, zmmC); + cc.evex().vpackusdw(xmmA, xmmB, xmmC); + cc.evex().vpackusdw(ymmA, ymmB, ymmC); + cc.evex().vpackusdw(zmmA, zmmB, zmmC); + cc.evex().vpackuswb(xmmA, xmmB, xmmC); + cc.evex().vpackuswb(ymmA, ymmB, ymmC); + cc.evex().vpackuswb(zmmA, zmmB, zmmC); + cc.evex().vpaddb(xmmA, xmmB, xmmC); + cc.evex().vpaddb(ymmA, ymmB, ymmC); + cc.evex().vpaddb(zmmA, zmmB, zmmC); + cc.evex().vpaddd(xmmA, xmmB, xmmC); + cc.evex().vpaddd(ymmA, ymmB, ymmC); + cc.evex().vpaddd(zmmA, zmmB, zmmC); + cc.evex().vpaddq(xmmA, xmmB, xmmC); + cc.evex().vpaddq(ymmA, ymmB, ymmC); + cc.evex().vpaddq(zmmA, zmmB, zmmC); + cc.evex().vpaddsb(xmmA, xmmB, xmmC); + cc.evex().vpaddsb(ymmA, ymmB, ymmC); + cc.evex().vpaddsb(zmmA, zmmB, zmmC); + cc.evex().vpaddsw(xmmA, xmmB, xmmC); + cc.evex().vpaddsw(ymmA, ymmB, ymmC); + cc.evex().vpaddsw(zmmA, zmmB, zmmC); + cc.evex().vpaddusb(xmmA, xmmB, xmmC); + cc.evex().vpaddusb(ymmA, ymmB, ymmC); + cc.evex().vpaddusb(zmmA, zmmB, zmmC); + cc.evex().vpaddusw(xmmA, xmmB, xmmC); + cc.evex().vpaddusw(ymmA, ymmB, ymmC); + cc.evex().vpaddusw(zmmA, zmmB, zmmC); + cc.evex().vpaddw(xmmA, xmmB, xmmC); + cc.evex().vpaddw(ymmA, ymmB, ymmC); + cc.evex().vpaddw(zmmA, zmmB, zmmC); + cc.evex().vpalignr(xmmA, xmmB, xmmC, 0); + cc.evex().vpalignr(ymmA, ymmB, ymmC, 0); + cc.evex().vpalignr(zmmA, zmmB, zmmC, 0); + cc.evex().vpandd(xmmA, xmmB, xmmC); + cc.evex().vpandd(ymmA, ymmB, ymmC); + cc.evex().vpandd(zmmA, zmmB, zmmC); + cc.evex().vpandnd(xmmA, xmmB, xmmC); + cc.evex().vpandnd(ymmA, ymmB, ymmC); + cc.evex().vpandnd(zmmA, zmmB, zmmC); + cc.evex().vpandnq(xmmA, xmmB, xmmC); + cc.evex().vpandnq(ymmA, ymmB, ymmC); + cc.evex().vpandnq(zmmA, zmmB, zmmC); + cc.evex().vpandq(xmmA, xmmB, xmmC); + cc.evex().vpandq(ymmA, ymmB, ymmC); + cc.evex().vpandq(zmmA, zmmB, zmmC); + cc.evex().vpavgb(xmmA, xmmB, xmmC); + cc.evex().vpavgb(ymmA, ymmB, ymmC); + cc.evex().vpavgb(zmmA, zmmB, zmmC); + cc.evex().vpavgw(xmmA, xmmB, xmmC); + cc.evex().vpavgw(ymmA, ymmB, ymmC); + cc.evex().vpavgw(zmmA, zmmB, zmmC); + cc.evex().vpblendmb(xmmA, xmmB, xmmC); + cc.evex().vpblendmb(ymmA, ymmB, ymmC); + cc.evex().vpblendmb(zmmA, zmmB, zmmC); + cc.evex().vpblendmd(xmmA, xmmB, xmmC); + cc.evex().vpblendmd(ymmA, ymmB, ymmC); + cc.evex().vpblendmd(zmmA, zmmB, zmmC); + cc.evex().vpblendmq(xmmA, xmmB, xmmC); + cc.evex().vpblendmq(ymmA, ymmB, ymmC); + cc.evex().vpblendmq(zmmA, zmmB, zmmC); + cc.evex().vpblendmw(xmmA, xmmB, xmmC); + cc.evex().vpblendmw(ymmA, ymmB, ymmC); + cc.evex().vpblendmw(zmmA, zmmB, zmmC); + cc.evex().vpbroadcastb(xmmA, gpd); + cc.evex().vpbroadcastb(xmmA, xmmB); + cc.evex().vpbroadcastb(ymmA, gpd); + cc.evex().vpbroadcastb(ymmA, xmmB); + cc.evex().vpbroadcastb(zmmA, gpd); + cc.evex().vpbroadcastb(zmmA, xmmB); + cc.evex().vpbroadcastd(xmmA, gpd); + cc.evex().vpbroadcastd(xmmA, xmmB); + cc.evex().vpbroadcastd(ymmA, gpd); + cc.evex().vpbroadcastd(ymmA, xmmB); + cc.evex().vpbroadcastd(zmmA, gpd); + cc.evex().vpbroadcastd(zmmA, xmmB); + cc.evex().vpbroadcastmb2q(xmmA, kB); + cc.evex().vpbroadcastmb2q(ymmA, kB); + cc.evex().vpbroadcastmb2q(zmmA, kB); + cc.evex().vpbroadcastmw2d(xmmA, kB); + cc.evex().vpbroadcastmw2d(ymmA, kB); + cc.evex().vpbroadcastmw2d(zmmA, kB); + if (cc.is64Bit()) cc.evex().vpbroadcastq(xmmA, gpq); + cc.evex().vpbroadcastq(xmmA, xmmB); + if (cc.is64Bit()) cc.evex().vpbroadcastq(ymmA, gpq); + cc.evex().vpbroadcastq(ymmA, xmmB); + if (cc.is64Bit()) cc.evex().vpbroadcastq(zmmA, gpq); + cc.evex().vpbroadcastq(zmmA, xmmB); + cc.evex().vpbroadcastw(xmmA, gpd); + cc.evex().vpbroadcastw(xmmA, xmmB); + cc.evex().vpbroadcastw(ymmA, gpd); + cc.evex().vpbroadcastw(ymmA, xmmB); + cc.evex().vpbroadcastw(zmmA, gpd); + cc.evex().vpbroadcastw(zmmA, xmmB); + cc.evex().vpcmpb(kA, xmmB, xmmC, 0); + cc.evex().vpcmpb(kA, ymmB, ymmC, 0); + cc.evex().vpcmpb(kA, zmmB, zmmC, 0); + cc.evex().vpcmpd(kA, xmmB, xmmC, 0); + cc.evex().vpcmpd(kA, ymmB, ymmC, 0); + cc.evex().vpcmpd(kA, zmmB, zmmC, 0); + cc.evex().vpcmpeqb(kA, xmmB, xmmC); + cc.evex().vpcmpeqb(kA, ymmB, ymmC); + cc.evex().vpcmpeqb(kA, zmmB, zmmC); + cc.evex().vpcmpeqd(kA, xmmB, xmmC); + cc.evex().vpcmpeqd(kA, ymmB, ymmC); + cc.evex().vpcmpeqd(kA, zmmB, zmmC); + cc.evex().vpcmpeqq(kA, xmmB, xmmC); + cc.evex().vpcmpeqq(kA, ymmB, ymmC); + cc.evex().vpcmpeqq(kA, zmmB, zmmC); + cc.evex().vpcmpeqw(kA, xmmB, xmmC); + cc.evex().vpcmpeqw(kA, ymmB, ymmC); + cc.evex().vpcmpeqw(kA, zmmB, zmmC); + cc.evex().vpcmpgtb(kA, xmmB, xmmC); + cc.evex().vpcmpgtb(kA, ymmB, ymmC); + cc.evex().vpcmpgtb(kA, zmmB, zmmC); + cc.evex().vpcmpgtd(kA, xmmB, xmmC); + cc.evex().vpcmpgtd(kA, ymmB, ymmC); + cc.evex().vpcmpgtd(kA, zmmB, zmmC); + cc.evex().vpcmpgtq(kA, xmmB, xmmC); + cc.evex().vpcmpgtq(kA, ymmB, ymmC); + cc.evex().vpcmpgtq(kA, zmmB, zmmC); + cc.evex().vpcmpgtw(kA, xmmB, xmmC); + cc.evex().vpcmpgtw(kA, ymmB, ymmC); + cc.evex().vpcmpgtw(kA, zmmB, zmmC); + cc.evex().vpcmpq(kA, xmmB, xmmC, 0); + cc.evex().vpcmpq(kA, ymmB, ymmC, 0); + cc.evex().vpcmpq(kA, zmmB, zmmC, 0); + cc.evex().vpcmpub(kA, xmmB, xmmC, 0); + cc.evex().vpcmpub(kA, ymmB, ymmC, 0); + cc.evex().vpcmpub(kA, zmmB, zmmC, 0); + cc.evex().vpcmpud(kA, xmmB, xmmC, 0); + cc.evex().vpcmpud(kA, ymmB, ymmC, 0); + cc.evex().vpcmpud(kA, zmmB, zmmC, 0); + cc.evex().vpcmpuq(kA, xmmB, xmmC, 0); + cc.evex().vpcmpuq(kA, ymmB, ymmC, 0); + cc.evex().vpcmpuq(kA, zmmB, zmmC, 0); + cc.evex().vpcmpuw(kA, xmmB, xmmC, 0); + cc.evex().vpcmpuw(kA, ymmB, ymmC, 0); + cc.evex().vpcmpuw(kA, zmmB, zmmC, 0); + cc.evex().vpcmpw(kA, xmmB, xmmC, 0); + cc.evex().vpcmpw(kA, ymmB, ymmC, 0); + cc.evex().vpcmpw(kA, zmmB, zmmC, 0); + cc.evex().vpcompressd(xmmA, xmmB); + cc.evex().vpcompressd(ymmA, ymmB); + cc.evex().vpcompressd(zmmA, zmmB); + cc.evex().vpcompressq(xmmA, xmmB); + cc.evex().vpcompressq(ymmA, ymmB); + cc.evex().vpcompressq(zmmA, zmmB); + cc.evex().vpconflictd(xmmA, xmmB); + cc.evex().vpconflictd(ymmA, ymmB); + cc.evex().vpconflictd(zmmA, zmmB); + cc.evex().vpconflictq(xmmA, xmmB); + cc.evex().vpconflictq(ymmA, ymmB); + cc.evex().vpconflictq(zmmA, zmmB); + cc.evex().vpermb(xmmA, xmmB, xmmC); + cc.evex().vpermb(ymmA, ymmB, ymmC); + cc.evex().vpermb(zmmA, zmmB, zmmC); + cc.evex().vpermd(ymmA, ymmB, ymmC); + cc.evex().vpermd(zmmA, zmmB, zmmC); + cc.evex().vpermi2b(xmmA, xmmB, xmmC); + cc.evex().vpermi2b(ymmA, ymmB, ymmC); + cc.evex().vpermi2b(zmmA, zmmB, zmmC); + cc.evex().vpermi2d(xmmA, xmmB, xmmC); + cc.evex().vpermi2d(ymmA, ymmB, ymmC); + cc.evex().vpermi2d(zmmA, zmmB, zmmC); + cc.evex().vpermi2pd(xmmA, xmmB, xmmC); + cc.evex().vpermi2pd(ymmA, ymmB, ymmC); + cc.evex().vpermi2pd(zmmA, zmmB, zmmC); + cc.evex().vpermi2ps(xmmA, xmmB, xmmC); + cc.evex().vpermi2ps(ymmA, ymmB, ymmC); + cc.evex().vpermi2ps(zmmA, zmmB, zmmC); + cc.evex().vpermi2q(xmmA, xmmB, xmmC); + cc.evex().vpermi2q(ymmA, ymmB, ymmC); + cc.evex().vpermi2q(zmmA, zmmB, zmmC); + cc.evex().vpermi2w(xmmA, xmmB, xmmC); + cc.evex().vpermi2w(ymmA, ymmB, ymmC); + cc.evex().vpermi2w(zmmA, zmmB, zmmC); + cc.evex().vpermilpd(xmmA, xmmB, xmmC); + cc.evex().vpermilpd(ymmA, ymmB, ymmC); + cc.evex().vpermilpd(zmmA, zmmB, zmmC); + cc.evex().vpermilpd(xmmA, xmmB, 0); + cc.evex().vpermilpd(ymmA, ymmB, 0); + cc.evex().vpermilpd(zmmA, zmmB, 0); + cc.evex().vpermilps(xmmA, xmmB, xmmC); + cc.evex().vpermilps(ymmA, ymmB, ymmC); + cc.evex().vpermilps(zmmA, zmmB, zmmC); + cc.evex().vpermilps(xmmA, xmmB, 0); + cc.evex().vpermilps(ymmA, ymmB, 0); + cc.evex().vpermilps(zmmA, zmmB, 0); + cc.evex().vpermq(ymmA, ymmB, ymmC); + cc.evex().vpermq(zmmA, zmmB, zmmC); + cc.evex().vpermq(ymmA, ymmB, 0); + cc.evex().vpermq(zmmA, zmmB, 0); + cc.evex().vpermt2b(xmmA, xmmB, xmmC); + cc.evex().vpermt2b(ymmA, ymmB, ymmC); + cc.evex().vpermt2b(zmmA, zmmB, zmmC); + cc.evex().vpermt2d(xmmA, xmmB, xmmC); + cc.evex().vpermt2d(ymmA, ymmB, ymmC); + cc.evex().vpermt2d(zmmA, zmmB, zmmC); + cc.evex().vpermt2pd(xmmA, xmmB, xmmC); + cc.evex().vpermt2pd(ymmA, ymmB, ymmC); + cc.evex().vpermt2pd(zmmA, zmmB, zmmC); + cc.evex().vpermt2ps(xmmA, xmmB, xmmC); + cc.evex().vpermt2ps(ymmA, ymmB, ymmC); + cc.evex().vpermt2ps(zmmA, zmmB, zmmC); + cc.evex().vpermt2q(xmmA, xmmB, xmmC); + cc.evex().vpermt2q(ymmA, ymmB, ymmC); + cc.evex().vpermt2q(zmmA, zmmB, zmmC); + cc.evex().vpermt2w(xmmA, xmmB, xmmC); + cc.evex().vpermt2w(ymmA, ymmB, ymmC); + cc.evex().vpermt2w(zmmA, zmmB, zmmC); + cc.evex().vpermw(xmmA, xmmB, xmmC); + cc.evex().vpermw(ymmA, ymmB, ymmC); + cc.evex().vpermw(zmmA, zmmB, zmmC); + cc.evex().vpexpandd(xmmA, xmmB); + cc.evex().vpexpandd(ymmA, ymmB); + cc.evex().vpexpandd(zmmA, zmmB); + cc.evex().vpexpandq(xmmA, xmmB); + cc.evex().vpexpandq(ymmA, ymmB); + cc.evex().vpexpandq(zmmA, zmmB); + cc.evex().vpextrb(gpd, xmmB, 0); + cc.evex().vpextrd(gpd, xmmB, 0); + if (cc.is64Bit()) cc.evex().vpextrq(gpq, xmmB, 0); + cc.evex().vpextrw(gpd, xmmB, 0); + cc.evex().vpinsrb(xmmA, xmmB, gpd, 0); + cc.evex().vpinsrd(xmmA, xmmB, gpd, 0); + if (cc.is64Bit()) cc.evex().vpinsrq(xmmA, xmmB, gpq, 0); + cc.evex().vpinsrw(xmmA, xmmB, gpd, 0); + cc.evex().vplzcntd(xmmA, xmmB); + cc.evex().vplzcntd(ymmA, ymmB); + cc.evex().vplzcntd(zmmA, zmmB); + cc.evex().vplzcntq(xmmA, xmmB); + cc.evex().vplzcntq(ymmA, ymmB); + cc.evex().vplzcntq(zmmA, zmmB); + cc.evex().vpmadd52huq(xmmA, xmmB, xmmC); + cc.evex().vpmadd52huq(ymmA, ymmB, ymmC); + cc.evex().vpmadd52huq(zmmA, zmmB, zmmC); + cc.evex().vpmadd52luq(xmmA, xmmB, xmmC); + cc.evex().vpmadd52luq(ymmA, ymmB, ymmC); + cc.evex().vpmadd52luq(zmmA, zmmB, zmmC); + cc.evex().vpmaddubsw(xmmA, xmmB, xmmC); + cc.evex().vpmaddubsw(ymmA, ymmB, ymmC); + cc.evex().vpmaddubsw(zmmA, zmmB, zmmC); + cc.evex().vpmaddwd(xmmA, xmmB, xmmC); + cc.evex().vpmaddwd(ymmA, ymmB, ymmC); + cc.evex().vpmaddwd(zmmA, zmmB, zmmC); + cc.evex().vpmaxsb(xmmA, xmmB, xmmC); + cc.evex().vpmaxsb(ymmA, ymmB, ymmC); + cc.evex().vpmaxsb(zmmA, zmmB, zmmC); + cc.evex().vpmaxsd(xmmA, xmmB, xmmC); + cc.evex().vpmaxsd(ymmA, ymmB, ymmC); + cc.evex().vpmaxsd(zmmA, zmmB, zmmC); + cc.evex().vpmaxsq(xmmA, xmmB, xmmC); + cc.evex().vpmaxsq(ymmA, ymmB, ymmC); + cc.evex().vpmaxsq(zmmA, zmmB, zmmC); + cc.evex().vpmaxsw(xmmA, xmmB, xmmC); + cc.evex().vpmaxsw(ymmA, ymmB, ymmC); + cc.evex().vpmaxsw(zmmA, zmmB, zmmC); + cc.evex().vpmaxub(xmmA, xmmB, xmmC); + cc.evex().vpmaxub(ymmA, ymmB, ymmC); + cc.evex().vpmaxub(zmmA, zmmB, zmmC); + cc.evex().vpmaxud(xmmA, xmmB, xmmC); + cc.evex().vpmaxud(ymmA, ymmB, ymmC); + cc.evex().vpmaxud(zmmA, zmmB, zmmC); + cc.evex().vpmaxuq(xmmA, xmmB, xmmC); + cc.evex().vpmaxuq(ymmA, ymmB, ymmC); + cc.evex().vpmaxuq(zmmA, zmmB, zmmC); + cc.evex().vpmaxuw(xmmA, xmmB, xmmC); + cc.evex().vpmaxuw(ymmA, ymmB, ymmC); + cc.evex().vpmaxuw(zmmA, zmmB, zmmC); + cc.evex().vpminsb(xmmA, xmmB, xmmC); + cc.evex().vpminsb(ymmA, ymmB, ymmC); + cc.evex().vpminsb(zmmA, zmmB, zmmC); + cc.evex().vpminsd(xmmA, xmmB, xmmC); + cc.evex().vpminsd(ymmA, ymmB, ymmC); + cc.evex().vpminsd(zmmA, zmmB, zmmC); + cc.evex().vpminsq(xmmA, xmmB, xmmC); + cc.evex().vpminsq(ymmA, ymmB, ymmC); + cc.evex().vpminsq(zmmA, zmmB, zmmC); + cc.evex().vpminsw(xmmA, xmmB, xmmC); + cc.evex().vpminsw(ymmA, ymmB, ymmC); + cc.evex().vpminsw(zmmA, zmmB, zmmC); + cc.evex().vpminub(xmmA, xmmB, xmmC); + cc.evex().vpminub(ymmA, ymmB, ymmC); + cc.evex().vpminub(zmmA, zmmB, zmmC); + cc.evex().vpminud(xmmA, xmmB, xmmC); + cc.evex().vpminud(ymmA, ymmB, ymmC); + cc.evex().vpminud(zmmA, zmmB, zmmC); + cc.evex().vpminuq(xmmA, xmmB, xmmC); + cc.evex().vpminuq(ymmA, ymmB, ymmC); + cc.evex().vpminuq(zmmA, zmmB, zmmC); + cc.evex().vpminuw(xmmA, xmmB, xmmC); + cc.evex().vpminuw(ymmA, ymmB, ymmC); + cc.evex().vpminuw(zmmA, zmmB, zmmC); + cc.evex().vpmovb2m(kA, xmmB); + cc.evex().vpmovb2m(kA, ymmB); + cc.evex().vpmovb2m(kA, zmmB); + cc.evex().vpmovd2m(kA, xmmB); + cc.evex().vpmovd2m(kA, ymmB); + cc.evex().vpmovd2m(kA, zmmB); + cc.evex().vpmovdb(xmmA, xmmB); + cc.evex().vpmovdb(xmmA, ymmB); + cc.evex().vpmovdb(xmmA, zmmB); + cc.evex().vpmovdw(xmmA, xmmB); + cc.evex().vpmovdw(xmmA, ymmB); + cc.evex().vpmovdw(ymmA, zmmB); + cc.evex().vpmovm2b(xmmA, kB); + cc.evex().vpmovm2b(ymmA, kB); + cc.evex().vpmovm2b(zmmA, kB); + cc.evex().vpmovm2d(xmmA, kB); + cc.evex().vpmovm2d(ymmA, kB); + cc.evex().vpmovm2d(zmmA, kB); + cc.evex().vpmovm2q(xmmA, kB); + cc.evex().vpmovm2q(ymmA, kB); + cc.evex().vpmovm2q(zmmA, kB); + cc.evex().vpmovm2w(xmmA, kB); + cc.evex().vpmovm2w(ymmA, kB); + cc.evex().vpmovm2w(zmmA, kB); + cc.evex().vpmovq2m(kA, xmmB); + cc.evex().vpmovq2m(kA, ymmB); + cc.evex().vpmovq2m(kA, zmmB); + cc.evex().vpmovqb(xmmA, xmmB); + cc.evex().vpmovqb(xmmA, ymmB); + cc.evex().vpmovqb(xmmA, zmmB); + cc.evex().vpmovqd(xmmA, xmmB); + cc.evex().vpmovqd(xmmA, ymmB); + cc.evex().vpmovqd(ymmA, zmmB); + cc.evex().vpmovqw(xmmA, xmmB); + cc.evex().vpmovqw(xmmA, ymmB); + cc.evex().vpmovqw(xmmA, zmmB); + cc.evex().vpmovsdb(xmmA, xmmB); + cc.evex().vpmovsdb(xmmA, ymmB); + cc.evex().vpmovsdb(xmmA, zmmB); + cc.evex().vpmovsdw(xmmA, xmmB); + cc.evex().vpmovsdw(xmmA, ymmB); + cc.evex().vpmovsdw(ymmA, zmmB); + cc.evex().vpmovsqb(xmmA, xmmB); + cc.evex().vpmovsqb(xmmA, ymmB); + cc.evex().vpmovsqb(xmmA, zmmB); + cc.evex().vpmovsqd(xmmA, xmmB); + cc.evex().vpmovsqd(xmmA, ymmB); + cc.evex().vpmovsqd(ymmA, zmmB); + cc.evex().vpmovsqw(xmmA, xmmB); + cc.evex().vpmovsqw(xmmA, ymmB); + cc.evex().vpmovsqw(xmmA, zmmB); + cc.evex().vpmovswb(xmmA, xmmB); + cc.evex().vpmovswb(xmmA, ymmB); + cc.evex().vpmovswb(ymmA, zmmB); + cc.evex().vpmovsxbd(xmmA, xmmB); + cc.evex().vpmovsxbd(ymmA, xmmB); + cc.evex().vpmovsxbd(zmmA, xmmB); + cc.evex().vpmovsxbq(xmmA, xmmB); + cc.evex().vpmovsxbq(ymmA, xmmB); + cc.evex().vpmovsxbq(zmmA, xmmB); + cc.evex().vpmovsxbw(xmmA, xmmB); + cc.evex().vpmovsxbw(ymmA, xmmB); + cc.evex().vpmovsxbw(zmmA, ymmB); + cc.evex().vpmovsxdq(xmmA, xmmB); + cc.evex().vpmovsxdq(ymmA, xmmB); + cc.evex().vpmovsxdq(zmmA, ymmB); + cc.evex().vpmovsxwd(xmmA, xmmB); + cc.evex().vpmovsxwd(ymmA, xmmB); + cc.evex().vpmovsxwd(zmmA, ymmB); + cc.evex().vpmovsxwq(xmmA, xmmB); + cc.evex().vpmovsxwq(ymmA, xmmB); + cc.evex().vpmovsxwq(zmmA, xmmB); + cc.evex().vpmovusdb(xmmA, xmmB); + cc.evex().vpmovusdb(xmmA, ymmB); + cc.evex().vpmovusdb(xmmA, zmmB); + cc.evex().vpmovusdw(xmmA, xmmB); + cc.evex().vpmovusdw(xmmA, ymmB); + cc.evex().vpmovusdw(ymmA, zmmB); + cc.evex().vpmovusqb(xmmA, xmmB); + cc.evex().vpmovusqb(xmmA, ymmB); + cc.evex().vpmovusqb(xmmA, zmmB); + cc.evex().vpmovusqd(xmmA, xmmB); + cc.evex().vpmovusqd(xmmA, ymmB); + cc.evex().vpmovusqd(ymmA, zmmB); + cc.evex().vpmovusqw(xmmA, xmmB); + cc.evex().vpmovusqw(xmmA, ymmB); + cc.evex().vpmovusqw(xmmA, zmmB); + cc.evex().vpmovuswb(xmmA, xmmB); + cc.evex().vpmovuswb(xmmA, ymmB); + cc.evex().vpmovuswb(ymmA, zmmB); + cc.evex().vpmovw2m(kA, xmmB); + cc.evex().vpmovw2m(kA, ymmB); + cc.evex().vpmovw2m(kA, zmmB); + cc.evex().vpmovwb(xmmA, xmmB); + cc.evex().vpmovwb(xmmA, ymmB); + cc.evex().vpmovwb(ymmA, zmmB); + cc.evex().vpmovzxbd(xmmA, xmmB); + cc.evex().vpmovzxbd(ymmA, xmmB); + cc.evex().vpmovzxbd(zmmA, xmmB); + cc.evex().vpmovzxbq(xmmA, xmmB); + cc.evex().vpmovzxbq(ymmA, xmmB); + cc.evex().vpmovzxbq(zmmA, xmmB); + cc.evex().vpmovzxbw(xmmA, xmmB); + cc.evex().vpmovzxbw(ymmA, xmmB); + cc.evex().vpmovzxbw(zmmA, ymmB); + cc.evex().vpmovzxdq(xmmA, xmmB); + cc.evex().vpmovzxdq(ymmA, xmmB); + cc.evex().vpmovzxdq(zmmA, ymmB); + cc.evex().vpmovzxwd(xmmA, xmmB); + cc.evex().vpmovzxwd(ymmA, xmmB); + cc.evex().vpmovzxwd(zmmA, ymmB); + cc.evex().vpmovzxwq(xmmA, xmmB); + cc.evex().vpmovzxwq(ymmA, xmmB); + cc.evex().vpmovzxwq(zmmA, xmmB); + cc.evex().vpmuldq(xmmA, xmmB, xmmC); + cc.evex().vpmuldq(ymmA, ymmB, ymmC); + cc.evex().vpmuldq(zmmA, zmmB, zmmC); + cc.evex().vpmulhrsw(xmmA, xmmB, xmmC); + cc.evex().vpmulhrsw(ymmA, ymmB, ymmC); + cc.evex().vpmulhrsw(zmmA, zmmB, zmmC); + cc.evex().vpmulhuw(xmmA, xmmB, xmmC); + cc.evex().vpmulhuw(ymmA, ymmB, ymmC); + cc.evex().vpmulhuw(zmmA, zmmB, zmmC); + cc.evex().vpmulhw(xmmA, xmmB, xmmC); + cc.evex().vpmulhw(ymmA, ymmB, ymmC); + cc.evex().vpmulhw(zmmA, zmmB, zmmC); + cc.evex().vpmulld(xmmA, xmmB, xmmC); + cc.evex().vpmulld(ymmA, ymmB, ymmC); + cc.evex().vpmulld(zmmA, zmmB, zmmC); + cc.evex().vpmullq(xmmA, xmmB, xmmC); + cc.evex().vpmullq(ymmA, ymmB, ymmC); + cc.evex().vpmullq(zmmA, zmmB, zmmC); + cc.evex().vpmullw(xmmA, xmmB, xmmC); + cc.evex().vpmullw(ymmA, ymmB, ymmC); + cc.evex().vpmullw(zmmA, zmmB, zmmC); + cc.evex().vpmultishiftqb(xmmA, xmmB, xmmC); + cc.evex().vpmultishiftqb(ymmA, ymmB, ymmC); + cc.evex().vpmultishiftqb(zmmA, zmmB, zmmC); + cc.evex().vpmuludq(xmmA, xmmB, xmmC); + cc.evex().vpmuludq(ymmA, ymmB, ymmC); + cc.evex().vpmuludq(zmmA, zmmB, zmmC); + cc.evex().vpopcntd(zmmA, zmmB); + cc.evex().vpopcntq(zmmA, zmmB); + cc.evex().vpord(xmmA, xmmB, xmmC); + cc.evex().vpord(ymmA, ymmB, ymmC); + cc.evex().vpord(zmmA, zmmB, zmmC); + cc.evex().vporq(xmmA, xmmB, xmmC); + cc.evex().vporq(ymmA, ymmB, ymmC); + cc.evex().vporq(zmmA, zmmB, zmmC); + cc.evex().vprold(xmmA, xmmB, 0); + cc.evex().vprold(ymmA, ymmB, 0); + cc.evex().vprold(zmmA, zmmB, 0); + cc.evex().vprolq(xmmA, xmmB, 0); + cc.evex().vprolq(ymmA, ymmB, 0); + cc.evex().vprolq(zmmA, zmmB, 0); + cc.evex().vprolvd(xmmA, xmmB, xmmC); + cc.evex().vprolvd(ymmA, ymmB, ymmC); + cc.evex().vprolvd(zmmA, zmmB, zmmC); + cc.evex().vprolvq(xmmA, xmmB, xmmC); + cc.evex().vprolvq(ymmA, ymmB, ymmC); + cc.evex().vprolvq(zmmA, zmmB, zmmC); + cc.evex().vprord(xmmA, xmmB, 0); + cc.evex().vprord(ymmA, ymmB, 0); + cc.evex().vprord(zmmA, zmmB, 0); + cc.evex().vprorq(xmmA, xmmB, 0); + cc.evex().vprorq(ymmA, ymmB, 0); + cc.evex().vprorq(zmmA, zmmB, 0); + cc.evex().vprorvd(xmmA, xmmB, xmmC); + cc.evex().vprorvd(ymmA, ymmB, ymmC); + cc.evex().vprorvd(zmmA, zmmB, zmmC); + cc.evex().vprorvq(xmmA, xmmB, xmmC); + cc.evex().vprorvq(ymmA, ymmB, ymmC); + cc.evex().vprorvq(zmmA, zmmB, zmmC); + cc.evex().vpsadbw(xmmA, xmmB, xmmC); + cc.evex().vpsadbw(ymmA, ymmB, ymmC); + cc.evex().vpsadbw(zmmA, zmmB, zmmC); + cc.evex().vpshufb(xmmA, xmmB, xmmC); + cc.evex().vpshufb(ymmA, ymmB, ymmC); + cc.evex().vpshufb(zmmA, zmmB, zmmC); + cc.evex().vpshufd(xmmA, xmmB, 0); + cc.evex().vpshufd(ymmA, ymmB, 0); + cc.evex().vpshufd(zmmA, zmmB, 0); + cc.evex().vpshufhw(xmmA, xmmB, 0); + cc.evex().vpshufhw(ymmA, ymmB, 0); + cc.evex().vpshufhw(zmmA, zmmB, 0); + cc.evex().vpshuflw(xmmA, xmmB, 0); + cc.evex().vpshuflw(ymmA, ymmB, 0); + cc.evex().vpshuflw(zmmA, zmmB, 0); + cc.evex().vpslld(xmmA, xmmB, xmmC); + cc.evex().vpslld(xmmA, xmmB, 0); + cc.evex().vpslld(ymmA, ymmB, xmmC); + cc.evex().vpslld(ymmA, ymmB, 0); + cc.evex().vpslld(zmmA, zmmB, xmmC); + cc.evex().vpslld(zmmA, zmmB, 0); + cc.evex().vpslldq(xmmA, xmmB, 0); + cc.evex().vpslldq(ymmA, ymmB, 0); + cc.evex().vpslldq(zmmA, zmmB, 0); + cc.evex().vpsllq(xmmA, xmmB, xmmC); + cc.evex().vpsllq(xmmA, xmmB, 0); + cc.evex().vpsllq(ymmA, ymmB, xmmC); + cc.evex().vpsllq(ymmA, ymmB, 0); + cc.evex().vpsllq(zmmA, zmmB, xmmC); + cc.evex().vpsllq(zmmA, zmmB, 0); + cc.evex().vpsllvd(xmmA, xmmB, xmmC); + cc.evex().vpsllvd(ymmA, ymmB, ymmC); + cc.evex().vpsllvd(zmmA, zmmB, zmmC); + cc.evex().vpsllvq(xmmA, xmmB, xmmC); + cc.evex().vpsllvq(ymmA, ymmB, ymmC); + cc.evex().vpsllvq(zmmA, zmmB, zmmC); + cc.evex().vpsllvw(xmmA, xmmB, xmmC); + cc.evex().vpsllvw(ymmA, ymmB, ymmC); + cc.evex().vpsllvw(zmmA, zmmB, zmmC); + cc.evex().vpsllw(xmmA, xmmB, xmmC); + cc.evex().vpsllw(xmmA, xmmB, 0); + cc.evex().vpsllw(ymmA, ymmB, xmmC); + cc.evex().vpsllw(ymmA, ymmB, 0); + cc.evex().vpsllw(zmmA, zmmB, xmmC); + cc.evex().vpsllw(zmmA, zmmB, 0); + cc.evex().vpsrad(xmmA, xmmB, xmmC); + cc.evex().vpsrad(xmmA, xmmB, 0); + cc.evex().vpsrad(ymmA, ymmB, xmmC); + cc.evex().vpsrad(ymmA, ymmB, 0); + cc.evex().vpsrad(zmmA, zmmB, xmmC); + cc.evex().vpsrad(zmmA, zmmB, 0); + cc.evex().vpsraq(xmmA, xmmB, xmmC); + cc.evex().vpsraq(xmmA, xmmB, 0); + cc.evex().vpsraq(ymmA, ymmB, xmmC); + cc.evex().vpsraq(ymmA, ymmB, 0); + cc.evex().vpsraq(zmmA, zmmB, xmmC); + cc.evex().vpsraq(zmmA, zmmB, 0); + cc.evex().vpsravd(xmmA, xmmB, xmmC); + cc.evex().vpsravd(ymmA, ymmB, ymmC); + cc.evex().vpsravd(zmmA, zmmB, zmmC); + cc.evex().vpsravq(xmmA, xmmB, xmmC); + cc.evex().vpsravq(ymmA, ymmB, ymmC); + cc.evex().vpsravq(zmmA, zmmB, zmmC); + cc.evex().vpsravw(xmmA, xmmB, xmmC); + cc.evex().vpsravw(ymmA, ymmB, ymmC); + cc.evex().vpsravw(zmmA, zmmB, zmmC); + cc.evex().vpsraw(xmmA, xmmB, xmmC); + cc.evex().vpsraw(xmmA, xmmB, 0); + cc.evex().vpsraw(ymmA, ymmB, xmmC); + cc.evex().vpsraw(ymmA, ymmB, 0); + cc.evex().vpsraw(zmmA, zmmB, xmmC); + cc.evex().vpsraw(zmmA, zmmB, 0); + cc.evex().vpsrld(xmmA, xmmB, xmmC); + cc.evex().vpsrld(xmmA, xmmB, 0); + cc.evex().vpsrld(ymmA, ymmB, xmmC); + cc.evex().vpsrld(ymmA, ymmB, 0); + cc.evex().vpsrld(zmmA, zmmB, xmmC); + cc.evex().vpsrld(zmmA, zmmB, 0); + cc.evex().vpsrldq(xmmA, xmmB, 0); + cc.evex().vpsrldq(ymmA, ymmB, 0); + cc.evex().vpsrldq(zmmA, zmmB, 0); + cc.evex().vpsrlq(xmmA, xmmB, xmmC); + cc.evex().vpsrlq(xmmA, xmmB, 0); + cc.evex().vpsrlq(ymmA, ymmB, xmmC); + cc.evex().vpsrlq(ymmA, ymmB, 0); + cc.evex().vpsrlq(zmmA, zmmB, xmmC); + cc.evex().vpsrlq(zmmA, zmmB, 0); + cc.evex().vpsrlvd(xmmA, xmmB, xmmC); + cc.evex().vpsrlvd(ymmA, ymmB, ymmC); + cc.evex().vpsrlvd(zmmA, zmmB, zmmC); + cc.evex().vpsrlvq(xmmA, xmmB, xmmC); + cc.evex().vpsrlvq(ymmA, ymmB, ymmC); + cc.evex().vpsrlvq(zmmA, zmmB, zmmC); + cc.evex().vpsrlvw(xmmA, xmmB, xmmC); + cc.evex().vpsrlvw(ymmA, ymmB, ymmC); + cc.evex().vpsrlvw(zmmA, zmmB, zmmC); + cc.evex().vpsrlw(xmmA, xmmB, xmmC); + cc.evex().vpsrlw(xmmA, xmmB, 0); + cc.evex().vpsrlw(ymmA, ymmB, xmmC); + cc.evex().vpsrlw(ymmA, ymmB, 0); + cc.evex().vpsrlw(zmmA, zmmB, xmmC); + cc.evex().vpsrlw(zmmA, zmmB, 0); + cc.evex().vpsubb(xmmA, xmmB, xmmC); + cc.evex().vpsubb(ymmA, ymmB, ymmC); + cc.evex().vpsubb(zmmA, zmmB, zmmC); + cc.evex().vpsubd(xmmA, xmmB, xmmC); + cc.evex().vpsubd(ymmA, ymmB, ymmC); + cc.evex().vpsubd(zmmA, zmmB, zmmC); + cc.evex().vpsubq(xmmA, xmmB, xmmC); + cc.evex().vpsubq(ymmA, ymmB, ymmC); + cc.evex().vpsubq(zmmA, zmmB, zmmC); + cc.evex().vpsubsb(xmmA, xmmB, xmmC); + cc.evex().vpsubsb(ymmA, ymmB, ymmC); + cc.evex().vpsubsb(zmmA, zmmB, zmmC); + cc.evex().vpsubsw(xmmA, xmmB, xmmC); + cc.evex().vpsubsw(ymmA, ymmB, ymmC); + cc.evex().vpsubsw(zmmA, zmmB, zmmC); + cc.evex().vpsubusb(xmmA, xmmB, xmmC); + cc.evex().vpsubusb(ymmA, ymmB, ymmC); + cc.evex().vpsubusb(zmmA, zmmB, zmmC); + cc.evex().vpsubusw(xmmA, xmmB, xmmC); + cc.evex().vpsubusw(ymmA, ymmB, ymmC); + cc.evex().vpsubusw(zmmA, zmmB, zmmC); + cc.evex().vpsubw(xmmA, xmmB, xmmC); + cc.evex().vpsubw(ymmA, ymmB, ymmC); + cc.evex().vpsubw(zmmA, zmmB, zmmC); + cc.evex().vpternlogd(xmmA, xmmB, xmmC, 0); + cc.evex().vpternlogd(ymmA, ymmB, ymmC, 0); + cc.evex().vpternlogd(zmmA, zmmB, zmmC, 0); + cc.evex().vpternlogq(xmmA, xmmB, xmmC, 0); + cc.evex().vpternlogq(ymmA, ymmB, ymmC, 0); + cc.evex().vpternlogq(zmmA, zmmB, zmmC, 0); + cc.evex().vptestmb(kA, xmmB, xmmC); + cc.evex().vptestmb(kA, ymmB, ymmC); + cc.evex().vptestmb(kA, zmmB, zmmC); + cc.evex().vptestmd(kA, xmmB, xmmC); + cc.evex().vptestmd(kA, ymmB, ymmC); + cc.evex().vptestmd(kA, zmmB, zmmC); + cc.evex().vptestmq(kA, xmmB, xmmC); + cc.evex().vptestmq(kA, ymmB, ymmC); + cc.evex().vptestmq(kA, zmmB, zmmC); + cc.evex().vptestmw(kA, xmmB, xmmC); + cc.evex().vptestmw(kA, ymmB, ymmC); + cc.evex().vptestmw(kA, zmmB, zmmC); + cc.evex().vptestnmb(kA, xmmB, xmmC); + cc.evex().vptestnmb(kA, ymmB, ymmC); + cc.evex().vptestnmb(kA, zmmB, zmmC); + cc.evex().vptestnmd(kA, xmmB, xmmC); + cc.evex().vptestnmd(kA, ymmB, ymmC); + cc.evex().vptestnmd(kA, zmmB, zmmC); + cc.evex().vptestnmq(kA, xmmB, xmmC); + cc.evex().vptestnmq(kA, ymmB, ymmC); + cc.evex().vptestnmq(kA, zmmB, zmmC); + cc.evex().vptestnmw(kA, xmmB, xmmC); + cc.evex().vptestnmw(kA, ymmB, ymmC); + cc.evex().vptestnmw(kA, zmmB, zmmC); + cc.evex().vpunpckhbw(xmmA, xmmB, xmmC); + cc.evex().vpunpckhbw(ymmA, ymmB, ymmC); + cc.evex().vpunpckhbw(zmmA, zmmB, zmmC); + cc.evex().vpunpckhdq(xmmA, xmmB, xmmC); + cc.evex().vpunpckhdq(ymmA, ymmB, ymmC); + cc.evex().vpunpckhdq(zmmA, zmmB, zmmC); + cc.evex().vpunpckhqdq(xmmA, xmmB, xmmC); + cc.evex().vpunpckhqdq(ymmA, ymmB, ymmC); + cc.evex().vpunpckhqdq(zmmA, zmmB, zmmC); + cc.evex().vpunpckhwd(xmmA, xmmB, xmmC); + cc.evex().vpunpckhwd(ymmA, ymmB, ymmC); + cc.evex().vpunpckhwd(zmmA, zmmB, zmmC); + cc.evex().vpunpcklbw(xmmA, xmmB, xmmC); + cc.evex().vpunpcklbw(ymmA, ymmB, ymmC); + cc.evex().vpunpcklbw(zmmA, zmmB, zmmC); + cc.evex().vpunpckldq(xmmA, xmmB, xmmC); + cc.evex().vpunpckldq(ymmA, ymmB, ymmC); + cc.evex().vpunpckldq(zmmA, zmmB, zmmC); + cc.evex().vpunpcklqdq(xmmA, xmmB, xmmC); + cc.evex().vpunpcklqdq(ymmA, ymmB, ymmC); + cc.evex().vpunpcklqdq(zmmA, zmmB, zmmC); + cc.evex().vpunpcklwd(xmmA, xmmB, xmmC); + cc.evex().vpunpcklwd(ymmA, ymmB, ymmC); + cc.evex().vpunpcklwd(zmmA, zmmB, zmmC); + cc.evex().vpxord(xmmA, xmmB, xmmC); + cc.evex().vpxord(ymmA, ymmB, ymmC); + cc.evex().vpxord(zmmA, zmmB, zmmC); + cc.evex().vpxorq(xmmA, xmmB, xmmC); + cc.evex().vpxorq(ymmA, ymmB, ymmC); + cc.evex().vpxorq(zmmA, zmmB, zmmC); + cc.evex().vrangepd(xmmA, xmmB, xmmC, 0); + cc.evex().vrangepd(ymmA, ymmB, ymmC, 0); + cc.evex().vrangepd(zmmA, zmmB, zmmC, 0); + cc.evex().vrangeps(xmmA, xmmB, xmmC, 0); + cc.evex().vrangeps(ymmA, ymmB, ymmC, 0); + cc.evex().vrangeps(zmmA, zmmB, zmmC, 0); + cc.evex().vrangesd(xmmA, xmmB, xmmC, 0); + cc.evex().vrangess(xmmA, xmmB, xmmC, 0); + cc.evex().vrcp14pd(xmmA, xmmB); + cc.evex().vrcp14pd(ymmA, ymmB); + cc.evex().vrcp14pd(zmmA, zmmB); + cc.evex().vrcp14ps(xmmA, xmmB); + cc.evex().vrcp14ps(ymmA, ymmB); + cc.evex().vrcp14ps(zmmA, zmmB); + cc.evex().vrcp14sd(xmmA, xmmB, xmmC); + cc.evex().vrcp14ss(xmmA, xmmB, xmmC); + cc.evex().vrcp28pd(zmmA, zmmB); + cc.evex().vrcp28ps(zmmA, zmmB); + cc.evex().vrcp28sd(xmmA, xmmB, xmmC); + cc.evex().vrcp28ss(xmmA, xmmB, xmmC); + cc.evex().vreducepd(xmmA, xmmB, 0); + cc.evex().vreducepd(ymmA, ymmB, 0); + cc.evex().vreducepd(zmmA, zmmB, 0); + cc.evex().vreduceps(xmmA, xmmB, 0); + cc.evex().vreduceps(ymmA, ymmB, 0); + cc.evex().vreduceps(zmmA, zmmB, 0); + cc.evex().vreducesd(xmmA, xmmB, xmmC, 0); + cc.evex().vreducess(xmmA, xmmB, xmmC, 0); + cc.evex().vrndscalepd(xmmA, xmmB, 0); + cc.evex().vrndscalepd(ymmA, ymmB, 0); + cc.evex().vrndscalepd(zmmA, zmmB, 0); + cc.evex().vrndscaleps(xmmA, xmmB, 0); + cc.evex().vrndscaleps(ymmA, ymmB, 0); + cc.evex().vrndscaleps(zmmA, zmmB, 0); + cc.evex().vrndscalesd(xmmA, xmmB, xmmC, 0); + cc.evex().vrndscaless(xmmA, xmmB, xmmC, 0); + cc.evex().vrsqrt14pd(xmmA, xmmB); + cc.evex().vrsqrt14pd(ymmA, ymmB); + cc.evex().vrsqrt14pd(zmmA, zmmB); + cc.evex().vrsqrt14ps(xmmA, xmmB); + cc.evex().vrsqrt14ps(ymmA, ymmB); + cc.evex().vrsqrt14ps(zmmA, zmmB); + cc.evex().vrsqrt14sd(xmmA, xmmB, xmmC); + cc.evex().vrsqrt14ss(xmmA, xmmB, xmmC); + cc.evex().vrsqrt28pd(zmmA, zmmB); + cc.evex().vrsqrt28ps(zmmA, zmmB); + cc.evex().vrsqrt28sd(xmmA, xmmB, xmmC); + cc.evex().vrsqrt28ss(xmmA, xmmB, xmmC); + cc.evex().vscalefpd(xmmA, xmmB, xmmC); + cc.evex().vscalefpd(ymmA, ymmB, ymmC); + cc.evex().vscalefpd(zmmA, zmmB, zmmC); + cc.evex().vscalefps(xmmA, xmmB, xmmC); + cc.evex().vscalefps(ymmA, ymmB, ymmC); + cc.evex().vscalefps(zmmA, zmmB, zmmC); + cc.evex().vscalefsd(xmmA, xmmB, xmmC); + cc.evex().vscalefss(xmmA, xmmB, xmmC); + cc.evex().vshuff32x4(ymmA, ymmB, ymmC, 0); + cc.evex().vshuff32x4(zmmA, zmmB, zmmC, 0); + cc.evex().vshuff64x2(ymmA, ymmB, ymmC, 0); + cc.evex().vshuff64x2(zmmA, zmmB, zmmC, 0); + cc.evex().vshufi32x4(ymmA, ymmB, ymmC, 0); + cc.evex().vshufi32x4(zmmA, zmmB, zmmC, 0); + cc.evex().vshufi64x2(ymmA, ymmB, ymmC, 0); + cc.evex().vshufi64x2(zmmA, zmmB, zmmC, 0); + cc.evex().vshufpd(xmmA, xmmB, xmmC, 0); + cc.evex().vshufpd(ymmA, ymmB, ymmC, 0); + cc.evex().vshufpd(zmmA, zmmB, zmmC, 0); + cc.evex().vshufps(xmmA, xmmB, xmmC, 0); + cc.evex().vshufps(ymmA, ymmB, ymmC, 0); + cc.evex().vshufps(zmmA, zmmB, zmmC, 0); + cc.evex().vsqrtpd(xmmA, xmmB); + cc.evex().vsqrtpd(ymmA, ymmB); + cc.evex().vsqrtpd(zmmA, zmmB); + cc.evex().vsqrtps(xmmA, xmmB); + cc.evex().vsqrtps(ymmA, ymmB); + cc.evex().vsqrtps(zmmA, zmmB); + cc.evex().vsqrtsd(xmmA, xmmB, xmmC); + cc.evex().vsqrtss(xmmA, xmmB, xmmC); + cc.evex().vsubpd(xmmA, xmmB, xmmC); + cc.evex().vsubpd(ymmA, ymmB, ymmC); + cc.evex().vsubpd(zmmA, zmmB, zmmC); + cc.evex().vsubps(xmmA, xmmB, xmmC); + cc.evex().vsubps(ymmA, ymmB, ymmC); + cc.evex().vsubps(zmmA, zmmB, zmmC); + cc.evex().vsubsd(xmmA, xmmB, xmmC); + cc.evex().vsubss(xmmA, xmmB, xmmC); + cc.evex().vucomisd(xmmA, xmmB); + cc.evex().vucomiss(xmmA, xmmB); + cc.evex().vunpckhpd(xmmA, xmmB, xmmC); + cc.evex().vunpckhpd(ymmA, ymmB, ymmC); + cc.evex().vunpckhpd(zmmA, zmmB, zmmC); + cc.evex().vunpckhps(xmmA, xmmB, xmmC); + cc.evex().vunpckhps(ymmA, ymmB, ymmC); + cc.evex().vunpckhps(zmmA, zmmB, zmmC); + cc.evex().vunpcklpd(xmmA, xmmB, xmmC); + cc.evex().vunpcklpd(ymmA, ymmB, ymmC); + cc.evex().vunpcklpd(zmmA, zmmB, zmmC); + cc.evex().vunpcklps(xmmA, xmmB, xmmC); + cc.evex().vunpcklps(ymmA, ymmB, ymmC); + cc.evex().vunpcklps(zmmA, zmmB, zmmC); + cc.evex().vxorpd(xmmA, xmmB, xmmC); + cc.evex().vxorpd(ymmA, ymmB, ymmC); + cc.evex().vxorpd(zmmA, zmmB, zmmC); + cc.evex().vxorps(xmmA, xmmB, xmmC); + cc.evex().vxorps(ymmA, ymmB, ymmC); + cc.evex().vxorps(zmmA, zmmB, zmmC); + } + else { + x86::Mem m = x86::ptr(gpz); + x86::Mem m32 = x86::dword_ptr(gpz); + x86::Mem m64 = x86::qword_ptr(gpz); + x86::Mem m128 = x86::xmmword_ptr(gpz); + x86::Mem m256 = x86::ymmword_ptr(gpz); + x86::Mem m512 = x86::zmmword_ptr(gpz); + x86::Mem vx_ptr = x86::ptr(gpz, xmmD); + x86::Mem vy_ptr = x86::ptr(gpz, ymmD); + x86::Mem vz_ptr = x86::ptr(gpz, zmmD); + + cc.kmovb(kA, m); + cc.kmovb(m, kB); + cc.kmovd(kA, m); + cc.kmovd(m, kB); + cc.kmovq(kA, m); + cc.kmovq(m, kB); + cc.kmovw(kA, m); + cc.kmovw(m, kB); + + cc.evex().vaddpd(xmmA, xmmB, m); + cc.evex().vaddpd(ymmA, ymmB, m); + cc.evex().vaddpd(zmmA, zmmB, m); + cc.evex().vaddps(xmmA, xmmB, m); + cc.evex().vaddps(ymmA, ymmB, m); + cc.evex().vaddps(zmmA, zmmB, m); + cc.evex().vaddsd(xmmA, xmmB, m); + cc.evex().vaddss(xmmA, xmmB, m); + cc.evex().valignd(xmmA, xmmB, m, 0); + cc.evex().valignd(ymmA, ymmB, m, 0); + cc.evex().valignd(zmmA, zmmB, m, 0); + cc.evex().valignq(xmmA, xmmB, m, 0); + cc.evex().valignq(ymmA, ymmB, m, 0); + cc.evex().valignq(zmmA, zmmB, m, 0); + cc.evex().vandnpd(xmmA, xmmB, m); + cc.evex().vandnpd(ymmA, ymmB, m); + cc.evex().vandnpd(zmmA, zmmB, m); + cc.evex().vandnps(xmmA, xmmB, m); + cc.evex().vandnps(ymmA, ymmB, m); + cc.evex().vandnps(zmmA, zmmB, m); + cc.evex().vandpd(xmmA, xmmB, m); + cc.evex().vandpd(ymmA, ymmB, m); + cc.evex().vandpd(zmmA, zmmB, m); + cc.evex().vandps(xmmA, xmmB, m); + cc.evex().vandps(ymmA, ymmB, m); + cc.evex().vandps(zmmA, zmmB, m); + cc.evex().vblendmpd(xmmA, xmmB, m); + cc.evex().vblendmpd(ymmA, ymmB, m); + cc.evex().vblendmpd(zmmA, zmmB, m); + cc.evex().vblendmps(xmmA, xmmB, m); + cc.evex().vblendmps(ymmA, ymmB, m); + cc.evex().vblendmps(zmmA, zmmB, m); + cc.evex().vbroadcastf32x2(ymmA, m); + cc.evex().vbroadcastf32x2(zmmA, m); + cc.evex().vbroadcastf32x4(ymmA, m); + cc.evex().vbroadcastf32x4(zmmA, m); + cc.evex().vbroadcastf32x8(zmmA, m); + cc.evex().vbroadcastf64x2(ymmA, m); + cc.evex().vbroadcastf64x2(zmmA, m); + cc.evex().vbroadcastf64x4(zmmA, m); + cc.evex().vbroadcasti32x2(xmmA, m); + cc.evex().vbroadcasti32x2(ymmA, m); + cc.evex().vbroadcasti32x2(zmmA, m); + cc.evex().vbroadcasti32x4(ymmA, m); + cc.evex().vbroadcasti32x4(zmmA, m); + cc.evex().vbroadcasti32x8(zmmA, m); + cc.evex().vbroadcasti64x2(ymmA, m); + cc.evex().vbroadcasti64x2(zmmA, m); + cc.evex().vbroadcasti64x4(zmmA, m); + cc.evex().vbroadcastsd(ymmA, m); + cc.evex().vbroadcastsd(zmmA, m); + cc.evex().vbroadcastss(xmmA, m); + cc.evex().vbroadcastss(ymmA, m); + cc.evex().vbroadcastss(zmmA, m); + cc.evex().vcmppd(kA, xmmB, m, 0); + cc.evex().vcmppd(kA, ymmB, m, 0); + cc.evex().vcmppd(kA, zmmB, m, 0); + cc.evex().vcmpps(kA, xmmB, m, 0); + cc.evex().vcmpps(kA, ymmB, m, 0); + cc.evex().vcmpps(kA, zmmB, m, 0); + cc.evex().vcmpsd(kA, xmmB, m, 0); + cc.evex().vcmpss(kA, xmmB, m, 0); + cc.evex().vcomisd(xmmA, m); + cc.evex().vcomiss(xmmA, m); + cc.evex().vcompresspd(m, xmmB); + cc.evex().vcompresspd(m, ymmB); + cc.evex().vcompresspd(m, zmmB); + cc.evex().vcompressps(m, xmmB); + cc.evex().vcompressps(m, ymmB); + cc.evex().vcompressps(m, zmmB); + cc.evex().vcvtdq2pd(xmmA, m); + cc.evex().vcvtdq2pd(ymmA, m); + cc.evex().vcvtdq2pd(zmmA, m); + cc.evex().vcvtdq2ps(xmmA, m); + cc.evex().vcvtdq2ps(ymmA, m); + cc.evex().vcvtdq2ps(zmmA, m); + cc.evex().vcvtpd2dq(xmmA, m128); + cc.evex().vcvtpd2dq(xmmA, m256); + cc.evex().vcvtpd2dq(ymmA, m512); + cc.evex().vcvtpd2qq(xmmA, m); + cc.evex().vcvtpd2qq(ymmA, m); + cc.evex().vcvtpd2qq(zmmA, m); + cc.evex().vcvtpd2udq(xmmA, m128); + cc.evex().vcvtpd2udq(xmmA, m256); + cc.evex().vcvtpd2udq(ymmA, m512); + cc.evex().vcvtpd2uqq(xmmA, m); + cc.evex().vcvtpd2uqq(ymmA, m); + cc.evex().vcvtpd2uqq(zmmA, m); + cc.evex().vcvtph2ps(xmmA, m); + cc.evex().vcvtph2ps(ymmA, m); + cc.evex().vcvtph2ps(zmmA, m); + cc.evex().vcvtps2dq(xmmA, m); + cc.evex().vcvtps2dq(ymmA, m); + cc.evex().vcvtps2dq(zmmA, m); + cc.evex().vcvtps2pd(xmmA, m); + cc.evex().vcvtps2pd(ymmA, m); + cc.evex().vcvtps2pd(zmmA, m); + cc.evex().vcvtps2ph(m, xmmB, 0); + cc.evex().vcvtps2ph(m, ymmB, 0); + cc.evex().vcvtps2ph(m, zmmB, 0); + cc.evex().vcvtps2qq(xmmA, m); + cc.evex().vcvtps2qq(ymmA, m); + cc.evex().vcvtps2qq(zmmA, m); + cc.evex().vcvtps2udq(xmmA, m); + cc.evex().vcvtps2udq(ymmA, m); + cc.evex().vcvtps2udq(zmmA, m); + cc.evex().vcvtps2uqq(xmmA, m); + cc.evex().vcvtps2uqq(ymmA, m); + cc.evex().vcvtps2uqq(zmmA, m); + cc.evex().vcvtqq2pd(xmmA, m); + cc.evex().vcvtqq2pd(ymmA, m); + cc.evex().vcvtqq2pd(zmmA, m); + cc.evex().vcvtqq2ps(xmmA, m128); + cc.evex().vcvtqq2ps(xmmA, m256); + cc.evex().vcvtqq2ps(ymmA, m512); + cc.evex().vcvtsd2si(gpd, m); + if (cc.is64Bit()) cc.evex().vcvtsd2si(gpq, m); + cc.evex().vcvtsd2ss(xmmA, xmmB, m); + cc.evex().vcvtsd2usi(gpd, m); + if (cc.is64Bit()) cc.evex().vcvtsd2usi(gpq, m); + cc.evex().vcvtsi2sd(xmmA, xmmB, m32); + if (cc.is64Bit()) cc.evex().vcvtsi2sd(xmmA, xmmB, m64); + cc.evex().vcvtsi2ss(xmmA, xmmB, m32); + if (cc.is64Bit()) cc.evex().vcvtsi2ss(xmmA, xmmB, m64); + cc.evex().vcvtss2sd(xmmA, xmmB, m); + cc.evex().vcvtss2si(gpd, m); + if (cc.is64Bit()) cc.evex().vcvtss2si(gpq, m); + cc.evex().vcvtss2usi(gpd, m); + if (cc.is64Bit()) cc.evex().vcvtss2usi(gpq, m); + cc.evex().vcvttpd2dq(xmmA, m128); + cc.evex().vcvttpd2dq(xmmA, m256); + cc.evex().vcvttpd2dq(ymmA, m512); + cc.evex().vcvttpd2qq(xmmA, m); + cc.evex().vcvttpd2qq(ymmA, m); + cc.evex().vcvttpd2qq(zmmA, m); + cc.evex().vcvttpd2udq(xmmA, m128); + cc.evex().vcvttpd2udq(xmmA, m256); + cc.evex().vcvttpd2udq(ymmA, m512); + cc.evex().vcvttpd2uqq(xmmA, m); + cc.evex().vcvttpd2uqq(ymmA, m); + cc.evex().vcvttpd2uqq(zmmA, m); + cc.evex().vcvttps2dq(xmmA, m); + cc.evex().vcvttps2dq(ymmA, m); + cc.evex().vcvttps2dq(zmmA, m); + cc.evex().vcvttps2qq(xmmA, m); + cc.evex().vcvttps2qq(ymmA, m); + cc.evex().vcvttps2qq(zmmA, m); + cc.evex().vcvttps2udq(xmmA, m); + cc.evex().vcvttps2udq(ymmA, m); + cc.evex().vcvttps2udq(zmmA, m); + cc.evex().vcvttps2uqq(xmmA, m); + cc.evex().vcvttps2uqq(ymmA, m); + cc.evex().vcvttps2uqq(zmmA, m); + cc.evex().vcvttsd2si(gpd, m); + if (cc.is64Bit()) cc.evex().vcvttsd2si(gpq, m); + cc.evex().vcvttsd2usi(gpd, m); + if (cc.is64Bit()) cc.evex().vcvttsd2usi(gpq, m); + cc.evex().vcvttss2si(gpd, m); + if (cc.is64Bit()) cc.evex().vcvttss2si(gpq, m); + cc.evex().vcvttss2usi(gpd, m); + if (cc.is64Bit()) cc.evex().vcvttss2usi(gpq, m); + cc.evex().vcvtudq2pd(xmmA, m); + cc.evex().vcvtudq2pd(ymmA, m); + cc.evex().vcvtudq2pd(zmmA, m); + cc.evex().vcvtudq2ps(xmmA, m); + cc.evex().vcvtudq2ps(ymmA, m); + cc.evex().vcvtudq2ps(zmmA, m); + cc.evex().vcvtuqq2pd(xmmA, m); + cc.evex().vcvtuqq2pd(ymmA, m); + cc.evex().vcvtuqq2pd(zmmA, m); + cc.evex().vcvtuqq2ps(xmmA, m128); + cc.evex().vcvtuqq2ps(xmmA, m256); + cc.evex().vcvtuqq2ps(ymmA, m512); + cc.evex().vcvtusi2sd(xmmA, xmmB, m32); + if (cc.is64Bit()) cc.evex().vcvtusi2sd(xmmA, xmmB, m64); + cc.evex().vcvtusi2ss(xmmA, xmmB, m32); + if (cc.is64Bit()) cc.evex().vcvtusi2ss(xmmA, xmmB, m64); + cc.evex().vdbpsadbw(xmmA, xmmB, m, 0); + cc.evex().vdbpsadbw(ymmA, ymmB, m, 0); + cc.evex().vdbpsadbw(zmmA, zmmB, m, 0); + cc.evex().vdivpd(xmmA, xmmB, m); + cc.evex().vdivpd(ymmA, ymmB, m); + cc.evex().vdivpd(zmmA, zmmB, m); + cc.evex().vdivps(xmmA, xmmB, m); + cc.evex().vdivps(ymmA, ymmB, m); + cc.evex().vdivps(zmmA, zmmB, m); + cc.evex().vdivsd(xmmA, xmmB, m); + cc.evex().vdivss(xmmA, xmmB, m); + cc.evex().vexp2pd(zmmA, m); + cc.evex().vexp2ps(zmmA, m); + cc.evex().vexpandpd(xmmA, m); + cc.evex().vexpandpd(ymmA, m); + cc.evex().vexpandpd(zmmA, m); + cc.evex().vexpandps(xmmA, m); + cc.evex().vexpandps(ymmA, m); + cc.evex().vexpandps(zmmA, m); + cc.evex().vextractf32x4(m, ymmB, 0); + cc.evex().vextractf32x4(m, zmmB, 0); + cc.evex().vextractf32x8(m, zmmB, 0); + cc.evex().vextractf64x2(m, ymmB, 0); + cc.evex().vextractf64x2(m, zmmB, 0); + cc.evex().vextractf64x4(m, zmmB, 0); + cc.evex().vextracti32x4(m, ymmB, 0); + cc.evex().vextracti32x4(m, zmmB, 0); + cc.evex().vextracti32x8(m, zmmB, 0); + cc.evex().vextracti64x2(m, ymmB, 0); + cc.evex().vextracti64x2(m, zmmB, 0); + cc.evex().vextracti64x4(m, zmmB, 0); + cc.evex().vextractps(m, xmmB, 0); + cc.evex().vfixupimmpd(xmmA, xmmB, m, 0); + cc.evex().vfixupimmpd(ymmA, ymmB, m, 0); + cc.evex().vfixupimmpd(zmmA, zmmB, m, 0); + cc.evex().vfixupimmps(xmmA, xmmB, m, 0); + cc.evex().vfixupimmps(ymmA, ymmB, m, 0); + cc.evex().vfixupimmps(zmmA, zmmB, m, 0); + cc.evex().vfixupimmsd(xmmA, xmmB, m, 0); + cc.evex().vfixupimmss(xmmA, xmmB, m, 0); + cc.evex().vfmadd132pd(xmmA, xmmB, m); + cc.evex().vfmadd132pd(ymmA, ymmB, m); + cc.evex().vfmadd132pd(zmmA, zmmB, m); + cc.evex().vfmadd132ps(xmmA, xmmB, m); + cc.evex().vfmadd132ps(ymmA, ymmB, m); + cc.evex().vfmadd132ps(zmmA, zmmB, m); + cc.evex().vfmadd132sd(xmmA, xmmB, m); + cc.evex().vfmadd132ss(xmmA, xmmB, m); + cc.evex().vfmadd213pd(xmmA, xmmB, m); + cc.evex().vfmadd213pd(ymmA, ymmB, m); + cc.evex().vfmadd213pd(zmmA, zmmB, m); + cc.evex().vfmadd213ps(xmmA, xmmB, m); + cc.evex().vfmadd213ps(ymmA, ymmB, m); + cc.evex().vfmadd213ps(zmmA, zmmB, m); + cc.evex().vfmadd213sd(xmmA, xmmB, m); + cc.evex().vfmadd213ss(xmmA, xmmB, m); + cc.evex().vfmadd231pd(xmmA, xmmB, m); + cc.evex().vfmadd231pd(ymmA, ymmB, m); + cc.evex().vfmadd231pd(zmmA, zmmB, m); + cc.evex().vfmadd231ps(xmmA, xmmB, m); + cc.evex().vfmadd231ps(ymmA, ymmB, m); + cc.evex().vfmadd231ps(zmmA, zmmB, m); + cc.evex().vfmadd231sd(xmmA, xmmB, m); + cc.evex().vfmadd231ss(xmmA, xmmB, m); + cc.evex().vfmaddsub132pd(xmmA, xmmB, m); + cc.evex().vfmaddsub132pd(ymmA, ymmB, m); + cc.evex().vfmaddsub132pd(zmmA, zmmB, m); + cc.evex().vfmaddsub132ps(xmmA, xmmB, m); + cc.evex().vfmaddsub132ps(ymmA, ymmB, m); + cc.evex().vfmaddsub132ps(zmmA, zmmB, m); + cc.evex().vfmaddsub213pd(xmmA, xmmB, m); + cc.evex().vfmaddsub213pd(ymmA, ymmB, m); + cc.evex().vfmaddsub213pd(zmmA, zmmB, m); + cc.evex().vfmaddsub213ps(xmmA, xmmB, m); + cc.evex().vfmaddsub213ps(ymmA, ymmB, m); + cc.evex().vfmaddsub213ps(zmmA, zmmB, m); + cc.evex().vfmaddsub231pd(xmmA, xmmB, m); + cc.evex().vfmaddsub231pd(ymmA, ymmB, m); + cc.evex().vfmaddsub231pd(zmmA, zmmB, m); + cc.evex().vfmaddsub231ps(xmmA, xmmB, m); + cc.evex().vfmaddsub231ps(ymmA, ymmB, m); + cc.evex().vfmaddsub231ps(zmmA, zmmB, m); + cc.evex().vfmsub132pd(xmmA, xmmB, m); + cc.evex().vfmsub132pd(ymmA, ymmB, m); + cc.evex().vfmsub132pd(zmmA, zmmB, m); + cc.evex().vfmsub132ps(xmmA, xmmB, m); + cc.evex().vfmsub132ps(ymmA, ymmB, m); + cc.evex().vfmsub132ps(zmmA, zmmB, m); + cc.evex().vfmsub132sd(xmmA, xmmB, m); + cc.evex().vfmsub132ss(xmmA, xmmB, m); + cc.evex().vfmsub213pd(xmmA, xmmB, m); + cc.evex().vfmsub213pd(ymmA, ymmB, m); + cc.evex().vfmsub213pd(zmmA, zmmB, m); + cc.evex().vfmsub213ps(xmmA, xmmB, m); + cc.evex().vfmsub213ps(ymmA, ymmB, m); + cc.evex().vfmsub213ps(zmmA, zmmB, m); + cc.evex().vfmsub213sd(xmmA, xmmB, m); + cc.evex().vfmsub213ss(xmmA, xmmB, m); + cc.evex().vfmsub231pd(xmmA, xmmB, m); + cc.evex().vfmsub231pd(ymmA, ymmB, m); + cc.evex().vfmsub231pd(zmmA, zmmB, m); + cc.evex().vfmsub231ps(xmmA, xmmB, m); + cc.evex().vfmsub231ps(ymmA, ymmB, m); + cc.evex().vfmsub231ps(zmmA, zmmB, m); + cc.evex().vfmsub231sd(xmmA, xmmB, m); + cc.evex().vfmsub231ss(xmmA, xmmB, m); + cc.evex().vfmsubadd132pd(xmmA, xmmB, m); + cc.evex().vfmsubadd132pd(ymmA, ymmB, m); + cc.evex().vfmsubadd132pd(zmmA, zmmB, m); + cc.evex().vfmsubadd132ps(xmmA, xmmB, m); + cc.evex().vfmsubadd132ps(ymmA, ymmB, m); + cc.evex().vfmsubadd132ps(zmmA, zmmB, m); + cc.evex().vfmsubadd213pd(xmmA, xmmB, m); + cc.evex().vfmsubadd213pd(ymmA, ymmB, m); + cc.evex().vfmsubadd213pd(zmmA, zmmB, m); + cc.evex().vfmsubadd213ps(xmmA, xmmB, m); + cc.evex().vfmsubadd213ps(ymmA, ymmB, m); + cc.evex().vfmsubadd213ps(zmmA, zmmB, m); + cc.evex().vfmsubadd231pd(xmmA, xmmB, m); + cc.evex().vfmsubadd231pd(ymmA, ymmB, m); + cc.evex().vfmsubadd231pd(zmmA, zmmB, m); + cc.evex().vfmsubadd231ps(xmmA, xmmB, m); + cc.evex().vfmsubadd231ps(ymmA, ymmB, m); + cc.evex().vfmsubadd231ps(zmmA, zmmB, m); + cc.evex().vfnmadd132pd(xmmA, xmmB, m); + cc.evex().vfnmadd132pd(ymmA, ymmB, m); + cc.evex().vfnmadd132pd(zmmA, zmmB, m); + cc.evex().vfnmadd132ps(xmmA, xmmB, m); + cc.evex().vfnmadd132ps(ymmA, ymmB, m); + cc.evex().vfnmadd132ps(zmmA, zmmB, m); + cc.evex().vfnmadd132sd(xmmA, xmmB, m); + cc.evex().vfnmadd132ss(xmmA, xmmB, m); + cc.evex().vfnmadd213pd(xmmA, xmmB, m); + cc.evex().vfnmadd213pd(ymmA, ymmB, m); + cc.evex().vfnmadd213pd(zmmA, zmmB, m); + cc.evex().vfnmadd213ps(xmmA, xmmB, m); + cc.evex().vfnmadd213ps(ymmA, ymmB, m); + cc.evex().vfnmadd213ps(zmmA, zmmB, m); + cc.evex().vfnmadd213sd(xmmA, xmmB, m); + cc.evex().vfnmadd213ss(xmmA, xmmB, m); + cc.evex().vfnmadd231pd(xmmA, xmmB, m); + cc.evex().vfnmadd231pd(ymmA, ymmB, m); + cc.evex().vfnmadd231pd(zmmA, zmmB, m); + cc.evex().vfnmadd231ps(xmmA, xmmB, m); + cc.evex().vfnmadd231ps(ymmA, ymmB, m); + cc.evex().vfnmadd231ps(zmmA, zmmB, m); + cc.evex().vfnmadd231sd(xmmA, xmmB, m); + cc.evex().vfnmadd231ss(xmmA, xmmB, m); + cc.evex().vfnmsub132pd(xmmA, xmmB, m); + cc.evex().vfnmsub132pd(ymmA, ymmB, m); + cc.evex().vfnmsub132pd(zmmA, zmmB, m); + cc.evex().vfnmsub132ps(xmmA, xmmB, m); + cc.evex().vfnmsub132ps(ymmA, ymmB, m); + cc.evex().vfnmsub132ps(zmmA, zmmB, m); + cc.evex().vfnmsub132sd(xmmA, xmmB, m); + cc.evex().vfnmsub132ss(xmmA, xmmB, m); + cc.evex().vfnmsub213pd(xmmA, xmmB, m); + cc.evex().vfnmsub213pd(ymmA, ymmB, m); + cc.evex().vfnmsub213pd(zmmA, zmmB, m); + cc.evex().vfnmsub213ps(xmmA, xmmB, m); + cc.evex().vfnmsub213ps(ymmA, ymmB, m); + cc.evex().vfnmsub213ps(zmmA, zmmB, m); + cc.evex().vfnmsub213sd(xmmA, xmmB, m); + cc.evex().vfnmsub213ss(xmmA, xmmB, m); + cc.evex().vfnmsub231pd(xmmA, xmmB, m); + cc.evex().vfnmsub231pd(ymmA, ymmB, m); + cc.evex().vfnmsub231pd(zmmA, zmmB, m); + cc.evex().vfnmsub231ps(xmmA, xmmB, m); + cc.evex().vfnmsub231ps(ymmA, ymmB, m); + cc.evex().vfnmsub231ps(zmmA, zmmB, m); + cc.evex().vfnmsub231sd(xmmA, xmmB, m); + cc.evex().vfnmsub231ss(xmmA, xmmB, m); + cc.evex().vfpclasspd(kA, m128, 0); + cc.evex().vfpclasspd(kA, m256, 0); + cc.evex().vfpclasspd(kA, m512, 0); + cc.evex().vfpclassps(kA, m128, 0); + cc.evex().vfpclassps(kA, m256, 0); + cc.evex().vfpclassps(kA, m512, 0); + cc.evex().vfpclasssd(kA, m, 0); + cc.evex().vfpclassss(kA, m, 0); + cc.evex().k(kA).vgatherdpd(xmmA, vx_ptr); + cc.evex().k(kA).vgatherdpd(ymmA, vx_ptr); + cc.evex().k(kA).vgatherdpd(zmmA, vy_ptr); + cc.evex().k(kA).vgatherdps(xmmA, vx_ptr); + cc.evex().k(kA).vgatherdps(ymmA, vy_ptr); + cc.evex().k(kA).vgatherdps(zmmA, vz_ptr); + cc.evex().k(kA).vgatherpf0dpd(vy_ptr); + cc.evex().k(kA).vgatherpf0dps(vz_ptr); + cc.evex().k(kA).vgatherpf0qpd(vz_ptr); + cc.evex().k(kA).vgatherpf0qps(vz_ptr); + cc.evex().k(kA).vgatherpf1dpd(vy_ptr); + cc.evex().k(kA).vgatherpf1dps(vz_ptr); + cc.evex().k(kA).vgatherpf1qpd(vz_ptr); + cc.evex().k(kA).vgatherpf1qps(vz_ptr); + cc.evex().k(kA).vgatherqpd(xmmA, vx_ptr); + cc.evex().k(kA).vgatherqpd(ymmA, vy_ptr); + cc.evex().k(kA).vgatherqpd(zmmA, vz_ptr); + cc.evex().k(kA).vgatherqps(xmmA, vx_ptr); + cc.evex().k(kA).vgatherqps(xmmA, vy_ptr); + cc.evex().k(kA).vgatherqps(ymmA, vz_ptr); + cc.evex().vgetexppd(xmmA, m); + cc.evex().vgetexppd(ymmA, m); + cc.evex().vgetexppd(zmmA, m); + cc.evex().vgetexpps(xmmA, m); + cc.evex().vgetexpps(ymmA, m); + cc.evex().vgetexpps(zmmA, m); + cc.evex().vgetexpsd(xmmA, xmmB, m); + cc.evex().vgetexpss(xmmA, xmmB, m); + cc.evex().vgetmantpd(xmmA, m, 0); + cc.evex().vgetmantpd(ymmA, m, 0); + cc.evex().vgetmantpd(zmmA, m, 0); + cc.evex().vgetmantps(xmmA, m, 0); + cc.evex().vgetmantps(ymmA, m, 0); + cc.evex().vgetmantps(zmmA, m, 0); + cc.evex().vgetmantsd(xmmA, xmmB, m, 0); + cc.evex().vgetmantss(xmmA, xmmB, m, 0); + cc.evex().vinsertf32x4(ymmA, ymmB, m, 0); + cc.evex().vinsertf32x4(zmmA, zmmB, m, 0); + cc.evex().vinsertf32x8(zmmA, zmmB, m, 0); + cc.evex().vinsertf64x2(ymmA, ymmB, m, 0); + cc.evex().vinsertf64x2(zmmA, zmmB, m, 0); + cc.evex().vinsertf64x4(zmmA, zmmB, m, 0); + cc.evex().vinserti32x4(ymmA, ymmB, m, 0); + cc.evex().vinserti32x4(zmmA, zmmB, m, 0); + cc.evex().vinserti32x8(zmmA, zmmB, m, 0); + cc.evex().vinserti64x2(ymmA, ymmB, m, 0); + cc.evex().vinserti64x2(zmmA, zmmB, m, 0); + cc.evex().vinserti64x4(zmmA, zmmB, m, 0); + cc.evex().vinsertps(xmmA, xmmB, m, 0); + cc.evex().vmaxpd(xmmA, xmmB, m); + cc.evex().vmaxpd(ymmA, ymmB, m); + cc.evex().vmaxpd(zmmA, zmmB, m); + cc.evex().vmaxps(xmmA, xmmB, m); + cc.evex().vmaxps(ymmA, ymmB, m); + cc.evex().vmaxps(zmmA, zmmB, m); + cc.evex().vmaxsd(xmmA, xmmB, m); + cc.evex().vmaxss(xmmA, xmmB, m); + cc.evex().vminpd(xmmA, xmmB, m); + cc.evex().vminpd(ymmA, ymmB, m); + cc.evex().vminpd(zmmA, zmmB, m); + cc.evex().vminps(xmmA, xmmB, m); + cc.evex().vminps(ymmA, ymmB, m); + cc.evex().vminps(zmmA, zmmB, m); + cc.evex().vminsd(xmmA, xmmB, m); + cc.evex().vminss(xmmA, xmmB, m); + cc.evex().vmovapd(xmmA, m); + cc.evex().vmovapd(m, xmmB); + cc.evex().vmovapd(ymmA, m); + cc.evex().vmovapd(m, ymmB); + cc.evex().vmovapd(zmmA, m); + cc.evex().vmovapd(m, zmmB); + cc.evex().vmovaps(xmmA, m); + cc.evex().vmovaps(m, xmmB); + cc.evex().vmovaps(ymmA, m); + cc.evex().vmovaps(m, ymmB); + cc.evex().vmovaps(zmmA, m); + cc.evex().vmovaps(m, zmmB); + cc.evex().vmovd(m, xmmB); + cc.evex().vmovd(xmmA, m); + cc.evex().vmovddup(xmmA, m); + cc.evex().vmovddup(ymmA, m); + cc.evex().vmovddup(zmmA, m); + cc.evex().vmovdqa32(xmmA, m); + cc.evex().vmovdqa32(m, xmmB); + cc.evex().vmovdqa32(ymmA, m); + cc.evex().vmovdqa32(m, ymmB); + cc.evex().vmovdqa32(zmmA, m); + cc.evex().vmovdqa32(m, zmmB); + cc.evex().vmovdqa64(xmmA, m); + cc.evex().vmovdqa64(m, xmmB); + cc.evex().vmovdqa64(ymmA, m); + cc.evex().vmovdqa64(m, ymmB); + cc.evex().vmovdqa64(zmmA, m); + cc.evex().vmovdqa64(m, zmmB); + cc.evex().vmovdqu16(xmmA, m); + cc.evex().vmovdqu16(m, xmmB); + cc.evex().vmovdqu16(ymmA, m); + cc.evex().vmovdqu16(m, ymmB); + cc.evex().vmovdqu16(zmmA, m); + cc.evex().vmovdqu16(m, zmmB); + cc.evex().vmovdqu32(xmmA, m); + cc.evex().vmovdqu32(m, xmmB); + cc.evex().vmovdqu32(ymmA, m); + cc.evex().vmovdqu32(m, ymmB); + cc.evex().vmovdqu32(zmmA, m); + cc.evex().vmovdqu32(m, zmmB); + cc.evex().vmovdqu64(xmmA, m); + cc.evex().vmovdqu64(m, xmmB); + cc.evex().vmovdqu64(ymmA, m); + cc.evex().vmovdqu64(m, ymmB); + cc.evex().vmovdqu64(zmmA, m); + cc.evex().vmovdqu64(m, zmmB); + cc.evex().vmovdqu8(xmmA, m); + cc.evex().vmovdqu8(m, xmmB); + cc.evex().vmovdqu8(ymmA, m); + cc.evex().vmovdqu8(m, ymmB); + cc.evex().vmovdqu8(zmmA, m); + cc.evex().vmovdqu8(m, zmmB); + cc.evex().vmovhpd(m, xmmB); + cc.evex().vmovhpd(xmmA, xmmB, m); + cc.evex().vmovhps(m, xmmB); + cc.evex().vmovhps(xmmA, xmmB, m); + cc.evex().vmovlpd(m, xmmB); + cc.evex().vmovlpd(xmmA, xmmB, m); + cc.evex().vmovlps(m, xmmB); + cc.evex().vmovlps(xmmA, xmmB, m); + cc.evex().vmovntdq(m, xmmB); + cc.evex().vmovntdq(m, ymmB); + cc.evex().vmovntdq(m, zmmB); + cc.evex().vmovntdqa(xmmA, m); + cc.evex().vmovntdqa(ymmA, m); + cc.evex().vmovntdqa(zmmA, m); + cc.evex().vmovntpd(m, xmmB); + cc.evex().vmovntpd(m, ymmB); + cc.evex().vmovntpd(m, zmmB); + cc.evex().vmovntps(m, xmmB); + cc.evex().vmovntps(m, ymmB); + cc.evex().vmovntps(m, zmmB); + cc.evex().vmovq(m, xmmB); + cc.evex().vmovq(xmmA, m); + cc.evex().vmovq(xmmA, m); + cc.evex().vmovq(m, xmmB); + cc.evex().vmovsd(m, xmmB); + cc.evex().vmovsd(xmmA, m); + cc.evex().vmovshdup(xmmA, m); + cc.evex().vmovshdup(ymmA, m); + cc.evex().vmovshdup(zmmA, m); + cc.evex().vmovsldup(xmmA, m); + cc.evex().vmovsldup(ymmA, m); + cc.evex().vmovsldup(zmmA, m); + cc.evex().vmovss(m, xmmB); + cc.evex().vmovss(xmmA, m); + cc.evex().vmovupd(xmmA, m); + cc.evex().vmovupd(m, xmmB); + cc.evex().vmovupd(ymmA, m); + cc.evex().vmovupd(m, ymmB); + cc.evex().vmovupd(zmmA, m); + cc.evex().vmovupd(m, zmmB); + cc.evex().vmovups(xmmA, m); + cc.evex().vmovups(m, xmmB); + cc.evex().vmovups(ymmA, m); + cc.evex().vmovups(m, ymmB); + cc.evex().vmovups(zmmA, m); + cc.evex().vmovups(m, zmmB); + cc.evex().vmulpd(xmmA, xmmB, m); + cc.evex().vmulpd(ymmA, ymmB, m); + cc.evex().vmulpd(zmmA, zmmB, m); + cc.evex().vmulps(xmmA, xmmB, m); + cc.evex().vmulps(ymmA, ymmB, m); + cc.evex().vmulps(zmmA, zmmB, m); + cc.evex().vmulsd(xmmA, xmmB, m); + cc.evex().vmulss(xmmA, xmmB, m); + cc.evex().vorpd(xmmA, xmmB, m); + cc.evex().vorpd(ymmA, ymmB, m); + cc.evex().vorpd(zmmA, zmmB, m); + cc.evex().vorps(xmmA, xmmB, m); + cc.evex().vorps(ymmA, ymmB, m); + cc.evex().vorps(zmmA, zmmB, m); + cc.evex().vpabsb(xmmA, m); + cc.evex().vpabsb(ymmA, m); + cc.evex().vpabsb(zmmA, m); + cc.evex().vpabsd(xmmA, m); + cc.evex().vpabsd(ymmA, m); + cc.evex().vpabsd(zmmA, m); + cc.evex().vpabsq(xmmA, m); + cc.evex().vpabsq(ymmA, m); + cc.evex().vpabsq(zmmA, m); + cc.evex().vpabsw(xmmA, m); + cc.evex().vpabsw(ymmA, m); + cc.evex().vpabsw(zmmA, m); + cc.evex().vpackssdw(xmmA, xmmB, m); + cc.evex().vpackssdw(ymmA, ymmB, m); + cc.evex().vpackssdw(zmmA, zmmB, m); + cc.evex().vpacksswb(xmmA, xmmB, m); + cc.evex().vpacksswb(ymmA, ymmB, m); + cc.evex().vpacksswb(zmmA, zmmB, m); + cc.evex().vpackusdw(xmmA, xmmB, m); + cc.evex().vpackusdw(ymmA, ymmB, m); + cc.evex().vpackusdw(zmmA, zmmB, m); + cc.evex().vpackuswb(xmmA, xmmB, m); + cc.evex().vpackuswb(ymmA, ymmB, m); + cc.evex().vpackuswb(zmmA, zmmB, m); + cc.evex().vpaddb(xmmA, xmmB, m); + cc.evex().vpaddb(ymmA, ymmB, m); + cc.evex().vpaddb(zmmA, zmmB, m); + cc.evex().vpaddd(xmmA, xmmB, m); + cc.evex().vpaddd(ymmA, ymmB, m); + cc.evex().vpaddd(zmmA, zmmB, m); + cc.evex().vpaddq(xmmA, xmmB, m); + cc.evex().vpaddq(ymmA, ymmB, m); + cc.evex().vpaddq(zmmA, zmmB, m); + cc.evex().vpaddsb(xmmA, xmmB, m); + cc.evex().vpaddsb(ymmA, ymmB, m); + cc.evex().vpaddsb(zmmA, zmmB, m); + cc.evex().vpaddsw(xmmA, xmmB, m); + cc.evex().vpaddsw(ymmA, ymmB, m); + cc.evex().vpaddsw(zmmA, zmmB, m); + cc.evex().vpaddusb(xmmA, xmmB, m); + cc.evex().vpaddusb(ymmA, ymmB, m); + cc.evex().vpaddusb(zmmA, zmmB, m); + cc.evex().vpaddusw(xmmA, xmmB, m); + cc.evex().vpaddusw(ymmA, ymmB, m); + cc.evex().vpaddusw(zmmA, zmmB, m); + cc.evex().vpaddw(xmmA, xmmB, m); + cc.evex().vpaddw(ymmA, ymmB, m); + cc.evex().vpaddw(zmmA, zmmB, m); + cc.evex().vpalignr(xmmA, xmmB, m, 0); + cc.evex().vpalignr(ymmA, ymmB, m, 0); + cc.evex().vpalignr(zmmA, zmmB, m, 0); + cc.evex().vpandd(xmmA, xmmB, m); + cc.evex().vpandd(ymmA, ymmB, m); + cc.evex().vpandd(zmmA, zmmB, m); + cc.evex().vpandnd(xmmA, xmmB, m); + cc.evex().vpandnd(ymmA, ymmB, m); + cc.evex().vpandnd(zmmA, zmmB, m); + cc.evex().vpandnq(xmmA, xmmB, m); + cc.evex().vpandnq(ymmA, ymmB, m); + cc.evex().vpandnq(zmmA, zmmB, m); + cc.evex().vpandq(xmmA, xmmB, m); + cc.evex().vpandq(ymmA, ymmB, m); + cc.evex().vpandq(zmmA, zmmB, m); + cc.evex().vpavgb(xmmA, xmmB, m); + cc.evex().vpavgb(ymmA, ymmB, m); + cc.evex().vpavgb(zmmA, zmmB, m); + cc.evex().vpavgw(xmmA, xmmB, m); + cc.evex().vpavgw(ymmA, ymmB, m); + cc.evex().vpavgw(zmmA, zmmB, m); + cc.evex().vpblendmb(xmmA, xmmB, m); + cc.evex().vpblendmb(ymmA, ymmB, m); + cc.evex().vpblendmb(zmmA, zmmB, m); + cc.evex().vpblendmd(xmmA, xmmB, m); + cc.evex().vpblendmd(ymmA, ymmB, m); + cc.evex().vpblendmd(zmmA, zmmB, m); + cc.evex().vpblendmq(xmmA, xmmB, m); + cc.evex().vpblendmq(ymmA, ymmB, m); + cc.evex().vpblendmq(zmmA, zmmB, m); + cc.evex().vpblendmw(xmmA, xmmB, m); + cc.evex().vpblendmw(ymmA, ymmB, m); + cc.evex().vpblendmw(zmmA, zmmB, m); + cc.evex().vpbroadcastb(xmmA, m); + cc.evex().vpbroadcastb(ymmA, m); + cc.evex().vpbroadcastb(zmmA, m); + cc.evex().vpbroadcastd(xmmA, m); + cc.evex().vpbroadcastd(ymmA, m); + cc.evex().vpbroadcastd(zmmA, m); + cc.evex().vpbroadcastq(xmmA, m); + cc.evex().vpbroadcastq(ymmA, m); + cc.evex().vpbroadcastq(zmmA, m); + cc.evex().vpbroadcastw(xmmA, m); + cc.evex().vpbroadcastw(ymmA, m); + cc.evex().vpbroadcastw(zmmA, m); + cc.evex().vpcmpb(kA, xmmB, m, 0); + cc.evex().vpcmpb(kA, ymmB, m, 0); + cc.evex().vpcmpb(kA, zmmB, m, 0); + cc.evex().vpcmpd(kA, xmmB, m, 0); + cc.evex().vpcmpd(kA, ymmB, m, 0); + cc.evex().vpcmpd(kA, zmmB, m, 0); + cc.evex().vpcmpeqb(kA, xmmB, m); + cc.evex().vpcmpeqb(kA, ymmB, m); + cc.evex().vpcmpeqb(kA, zmmB, m); + cc.evex().vpcmpeqd(kA, xmmB, m); + cc.evex().vpcmpeqd(kA, ymmB, m); + cc.evex().vpcmpeqd(kA, zmmB, m); + cc.evex().vpcmpeqq(kA, xmmB, m); + cc.evex().vpcmpeqq(kA, ymmB, m); + cc.evex().vpcmpeqq(kA, zmmB, m); + cc.evex().vpcmpeqw(kA, xmmB, m); + cc.evex().vpcmpeqw(kA, ymmB, m); + cc.evex().vpcmpeqw(kA, zmmB, m); + cc.evex().vpcmpgtb(kA, xmmB, m); + cc.evex().vpcmpgtb(kA, ymmB, m); + cc.evex().vpcmpgtb(kA, zmmB, m); + cc.evex().vpcmpgtd(kA, xmmB, m); + cc.evex().vpcmpgtd(kA, ymmB, m); + cc.evex().vpcmpgtd(kA, zmmB, m); + cc.evex().vpcmpgtq(kA, xmmB, m); + cc.evex().vpcmpgtq(kA, ymmB, m); + cc.evex().vpcmpgtq(kA, zmmB, m); + cc.evex().vpcmpgtw(kA, xmmB, m); + cc.evex().vpcmpgtw(kA, ymmB, m); + cc.evex().vpcmpgtw(kA, zmmB, m); + cc.evex().vpcmpq(kA, xmmB, m, 0); + cc.evex().vpcmpq(kA, ymmB, m, 0); + cc.evex().vpcmpq(kA, zmmB, m, 0); + cc.evex().vpcmpub(kA, xmmB, m, 0); + cc.evex().vpcmpub(kA, ymmB, m, 0); + cc.evex().vpcmpub(kA, zmmB, m, 0); + cc.evex().vpcmpud(kA, xmmB, m, 0); + cc.evex().vpcmpud(kA, ymmB, m, 0); + cc.evex().vpcmpud(kA, zmmB, m, 0); + cc.evex().vpcmpuq(kA, xmmB, m, 0); + cc.evex().vpcmpuq(kA, ymmB, m, 0); + cc.evex().vpcmpuq(kA, zmmB, m, 0); + cc.evex().vpcmpuw(kA, xmmB, m, 0); + cc.evex().vpcmpuw(kA, ymmB, m, 0); + cc.evex().vpcmpuw(kA, zmmB, m, 0); + cc.evex().vpcmpw(kA, xmmB, m, 0); + cc.evex().vpcmpw(kA, ymmB, m, 0); + cc.evex().vpcmpw(kA, zmmB, m, 0); + cc.evex().vpcompressd(m, xmmB); + cc.evex().vpcompressd(m, ymmB); + cc.evex().vpcompressd(m, zmmB); + cc.evex().vpcompressq(m, xmmB); + cc.evex().vpcompressq(m, ymmB); + cc.evex().vpcompressq(m, zmmB); + cc.evex().vpconflictd(xmmA, m); + cc.evex().vpconflictd(ymmA, m); + cc.evex().vpconflictd(zmmA, m); + cc.evex().vpconflictq(xmmA, m); + cc.evex().vpconflictq(ymmA, m); + cc.evex().vpconflictq(zmmA, m); + cc.evex().vpermb(xmmA, xmmB, m); + cc.evex().vpermb(ymmA, ymmB, m); + cc.evex().vpermb(zmmA, zmmB, m); + cc.evex().vpermd(ymmA, ymmB, m); + cc.evex().vpermd(zmmA, zmmB, m); + cc.evex().vpermi2b(xmmA, xmmB, m); + cc.evex().vpermi2b(ymmA, ymmB, m); + cc.evex().vpermi2b(zmmA, zmmB, m); + cc.evex().vpermi2d(xmmA, xmmB, m); + cc.evex().vpermi2d(ymmA, ymmB, m); + cc.evex().vpermi2d(zmmA, zmmB, m); + cc.evex().vpermi2pd(xmmA, xmmB, m); + cc.evex().vpermi2pd(ymmA, ymmB, m); + cc.evex().vpermi2pd(zmmA, zmmB, m); + cc.evex().vpermi2ps(xmmA, xmmB, m); + cc.evex().vpermi2ps(ymmA, ymmB, m); + cc.evex().vpermi2ps(zmmA, zmmB, m); + cc.evex().vpermi2q(xmmA, xmmB, m); + cc.evex().vpermi2q(ymmA, ymmB, m); + cc.evex().vpermi2q(zmmA, zmmB, m); + cc.evex().vpermi2w(xmmA, xmmB, m); + cc.evex().vpermi2w(ymmA, ymmB, m); + cc.evex().vpermi2w(zmmA, zmmB, m); + cc.evex().vpermilpd(xmmA, xmmB, m); + cc.evex().vpermilpd(ymmA, ymmB, m); + cc.evex().vpermilpd(zmmA, zmmB, m); + cc.evex().vpermilpd(xmmA, m, 0); + cc.evex().vpermilpd(ymmA, m, 0); + cc.evex().vpermilpd(zmmA, m, 0); + cc.evex().vpermilps(xmmA, xmmB, m); + cc.evex().vpermilps(ymmA, ymmB, m); + cc.evex().vpermilps(zmmA, zmmB, m); + cc.evex().vpermilps(xmmA, m, 0); + cc.evex().vpermilps(ymmA, m, 0); + cc.evex().vpermilps(zmmA, m, 0); + cc.evex().vpermq(ymmA, ymmB, m); + cc.evex().vpermq(zmmA, zmmB, m); + cc.evex().vpermq(ymmA, m, 0); + cc.evex().vpermq(zmmA, m, 0); + cc.evex().vpermt2b(xmmA, xmmB, m); + cc.evex().vpermt2b(ymmA, ymmB, m); + cc.evex().vpermt2b(zmmA, zmmB, m); + cc.evex().vpermt2d(xmmA, xmmB, m); + cc.evex().vpermt2d(ymmA, ymmB, m); + cc.evex().vpermt2d(zmmA, zmmB, m); + cc.evex().vpermt2pd(xmmA, xmmB, m); + cc.evex().vpermt2pd(ymmA, ymmB, m); + cc.evex().vpermt2pd(zmmA, zmmB, m); + cc.evex().vpermt2ps(xmmA, xmmB, m); + cc.evex().vpermt2ps(ymmA, ymmB, m); + cc.evex().vpermt2ps(zmmA, zmmB, m); + cc.evex().vpermt2q(xmmA, xmmB, m); + cc.evex().vpermt2q(ymmA, ymmB, m); + cc.evex().vpermt2q(zmmA, zmmB, m); + cc.evex().vpermt2w(xmmA, xmmB, m); + cc.evex().vpermt2w(ymmA, ymmB, m); + cc.evex().vpermt2w(zmmA, zmmB, m); + cc.evex().vpermw(xmmA, xmmB, m); + cc.evex().vpermw(ymmA, ymmB, m); + cc.evex().vpermw(zmmA, zmmB, m); + cc.evex().vpexpandd(xmmA, m); + cc.evex().vpexpandd(ymmA, m); + cc.evex().vpexpandd(zmmA, m); + cc.evex().vpexpandq(xmmA, m); + cc.evex().vpexpandq(ymmA, m); + cc.evex().vpexpandq(zmmA, m); + cc.evex().vpextrb(m, xmmB, 0); + cc.evex().vpextrd(m, xmmB, 0); + if (cc.is64Bit()) cc.evex().vpextrq(m, xmmB, 0); + cc.evex().vpextrw(m, xmmB, 0); + cc.evex().k(kA).vpgatherdd(xmmA, vx_ptr); + cc.evex().k(kA).vpgatherdd(ymmA, vy_ptr); + cc.evex().k(kA).vpgatherdd(zmmA, vz_ptr); + cc.evex().k(kA).vpgatherdq(xmmA, vx_ptr); + cc.evex().k(kA).vpgatherdq(ymmA, vx_ptr); + cc.evex().k(kA).vpgatherdq(zmmA, vy_ptr); + cc.evex().k(kA).vpgatherqd(xmmA, vx_ptr); + cc.evex().k(kA).vpgatherqd(xmmA, vy_ptr); + cc.evex().k(kA).vpgatherqd(ymmA, vz_ptr); + cc.evex().k(kA).vpgatherqq(xmmA, vx_ptr); + cc.evex().k(kA).vpgatherqq(ymmA, vy_ptr); + cc.evex().k(kA).vpgatherqq(zmmA, vz_ptr); + cc.evex().vpinsrb(xmmA, xmmB, m, 0); + cc.evex().vpinsrd(xmmA, xmmB, m, 0); + if (cc.is64Bit()) cc.evex().vpinsrq(xmmA, xmmB, m, 0); + cc.evex().vpinsrw(xmmA, xmmB, m, 0); + cc.evex().vplzcntd(xmmA, m); + cc.evex().vplzcntd(ymmA, m); + cc.evex().vplzcntd(zmmA, m); + cc.evex().vplzcntq(xmmA, m); + cc.evex().vplzcntq(ymmA, m); + cc.evex().vplzcntq(zmmA, m); + cc.evex().vpmadd52huq(xmmA, xmmB, m); + cc.evex().vpmadd52huq(ymmA, ymmB, m); + cc.evex().vpmadd52huq(zmmA, zmmB, m); + cc.evex().vpmadd52luq(xmmA, xmmB, m); + cc.evex().vpmadd52luq(ymmA, ymmB, m); + cc.evex().vpmadd52luq(zmmA, zmmB, m); + cc.evex().vpmaddubsw(xmmA, xmmB, m); + cc.evex().vpmaddubsw(ymmA, ymmB, m); + cc.evex().vpmaddubsw(zmmA, zmmB, m); + cc.evex().vpmaddwd(xmmA, xmmB, m); + cc.evex().vpmaddwd(ymmA, ymmB, m); + cc.evex().vpmaddwd(zmmA, zmmB, m); + cc.evex().vpmaxsb(xmmA, xmmB, m); + cc.evex().vpmaxsb(ymmA, ymmB, m); + cc.evex().vpmaxsb(zmmA, zmmB, m); + cc.evex().vpmaxsd(xmmA, xmmB, m); + cc.evex().vpmaxsd(ymmA, ymmB, m); + cc.evex().vpmaxsd(zmmA, zmmB, m); + cc.evex().vpmaxsq(xmmA, xmmB, m); + cc.evex().vpmaxsq(ymmA, ymmB, m); + cc.evex().vpmaxsq(zmmA, zmmB, m); + cc.evex().vpmaxsw(xmmA, xmmB, m); + cc.evex().vpmaxsw(ymmA, ymmB, m); + cc.evex().vpmaxsw(zmmA, zmmB, m); + cc.evex().vpmaxub(xmmA, xmmB, m); + cc.evex().vpmaxub(ymmA, ymmB, m); + cc.evex().vpmaxub(zmmA, zmmB, m); + cc.evex().vpmaxud(xmmA, xmmB, m); + cc.evex().vpmaxud(ymmA, ymmB, m); + cc.evex().vpmaxud(zmmA, zmmB, m); + cc.evex().vpmaxuq(xmmA, xmmB, m); + cc.evex().vpmaxuq(ymmA, ymmB, m); + cc.evex().vpmaxuq(zmmA, zmmB, m); + cc.evex().vpmaxuw(xmmA, xmmB, m); + cc.evex().vpmaxuw(ymmA, ymmB, m); + cc.evex().vpmaxuw(zmmA, zmmB, m); + cc.evex().vpminsb(xmmA, xmmB, m); + cc.evex().vpminsb(ymmA, ymmB, m); + cc.evex().vpminsb(zmmA, zmmB, m); + cc.evex().vpminsd(xmmA, xmmB, m); + cc.evex().vpminsd(ymmA, ymmB, m); + cc.evex().vpminsd(zmmA, zmmB, m); + cc.evex().vpminsq(xmmA, xmmB, m); + cc.evex().vpminsq(ymmA, ymmB, m); + cc.evex().vpminsq(zmmA, zmmB, m); + cc.evex().vpminsw(xmmA, xmmB, m); + cc.evex().vpminsw(ymmA, ymmB, m); + cc.evex().vpminsw(zmmA, zmmB, m); + cc.evex().vpminub(xmmA, xmmB, m); + cc.evex().vpminub(ymmA, ymmB, m); + cc.evex().vpminub(zmmA, zmmB, m); + cc.evex().vpminud(xmmA, xmmB, m); + cc.evex().vpminud(ymmA, ymmB, m); + cc.evex().vpminud(zmmA, zmmB, m); + cc.evex().vpminuq(xmmA, xmmB, m); + cc.evex().vpminuq(ymmA, ymmB, m); + cc.evex().vpminuq(zmmA, zmmB, m); + cc.evex().vpminuw(xmmA, xmmB, m); + cc.evex().vpminuw(ymmA, ymmB, m); + cc.evex().vpminuw(zmmA, zmmB, m); + cc.evex().vpmovdb(m, xmmB); + cc.evex().vpmovdb(m, ymmB); + cc.evex().vpmovdb(m, zmmB); + cc.evex().vpmovdw(m, xmmB); + cc.evex().vpmovdw(m, ymmB); + cc.evex().vpmovdw(m, zmmB); + cc.evex().vpmovqb(m, xmmB); + cc.evex().vpmovqb(m, ymmB); + cc.evex().vpmovqb(m, zmmB); + cc.evex().vpmovqd(m, xmmB); + cc.evex().vpmovqd(m, ymmB); + cc.evex().vpmovqd(m, zmmB); + cc.evex().vpmovqw(m, xmmB); + cc.evex().vpmovqw(m, ymmB); + cc.evex().vpmovqw(m, zmmB); + cc.evex().vpmovsdb(m, xmmB); + cc.evex().vpmovsdb(m, ymmB); + cc.evex().vpmovsdb(m, zmmB); + cc.evex().vpmovsdw(m, xmmB); + cc.evex().vpmovsdw(m, ymmB); + cc.evex().vpmovsdw(m, zmmB); + cc.evex().vpmovsqb(m, xmmB); + cc.evex().vpmovsqb(m, ymmB); + cc.evex().vpmovsqb(m, zmmB); + cc.evex().vpmovsqd(m, xmmB); + cc.evex().vpmovsqd(m, ymmB); + cc.evex().vpmovsqd(m, zmmB); + cc.evex().vpmovsqw(m, xmmB); + cc.evex().vpmovsqw(m, ymmB); + cc.evex().vpmovsqw(m, zmmB); + cc.evex().vpmovswb(m, xmmB); + cc.evex().vpmovswb(m, ymmB); + cc.evex().vpmovswb(m, zmmB); + cc.evex().vpmovsxbd(xmmA, m); + cc.evex().vpmovsxbd(ymmA, m); + cc.evex().vpmovsxbd(zmmA, m); + cc.evex().vpmovsxbq(xmmA, m); + cc.evex().vpmovsxbq(ymmA, m); + cc.evex().vpmovsxbq(zmmA, m); + cc.evex().vpmovsxbw(xmmA, m); + cc.evex().vpmovsxbw(ymmA, m); + cc.evex().vpmovsxbw(zmmA, m); + cc.evex().vpmovsxdq(xmmA, m); + cc.evex().vpmovsxdq(ymmA, m); + cc.evex().vpmovsxdq(zmmA, m); + cc.evex().vpmovsxwd(xmmA, m); + cc.evex().vpmovsxwd(ymmA, m); + cc.evex().vpmovsxwd(zmmA, m); + cc.evex().vpmovsxwq(xmmA, m); + cc.evex().vpmovsxwq(ymmA, m); + cc.evex().vpmovsxwq(zmmA, m); + cc.evex().vpmovusdb(m, xmmB); + cc.evex().vpmovusdb(m, ymmB); + cc.evex().vpmovusdb(m, zmmB); + cc.evex().vpmovusdw(m, xmmB); + cc.evex().vpmovusdw(m, ymmB); + cc.evex().vpmovusdw(m, zmmB); + cc.evex().vpmovusqb(m, xmmB); + cc.evex().vpmovusqb(m, ymmB); + cc.evex().vpmovusqb(m, zmmB); + cc.evex().vpmovusqd(m, xmmB); + cc.evex().vpmovusqd(m, ymmB); + cc.evex().vpmovusqd(m, zmmB); + cc.evex().vpmovusqw(m, xmmB); + cc.evex().vpmovusqw(m, ymmB); + cc.evex().vpmovusqw(m, zmmB); + cc.evex().vpmovuswb(m, xmmB); + cc.evex().vpmovuswb(m, ymmB); + cc.evex().vpmovuswb(m, zmmB); + cc.evex().vpmovwb(m, xmmB); + cc.evex().vpmovwb(m, ymmB); + cc.evex().vpmovwb(m, zmmB); + cc.evex().vpmovzxbd(xmmA, m); + cc.evex().vpmovzxbd(ymmA, m); + cc.evex().vpmovzxbd(zmmA, m); + cc.evex().vpmovzxbq(xmmA, m); + cc.evex().vpmovzxbq(ymmA, m); + cc.evex().vpmovzxbq(zmmA, m); + cc.evex().vpmovzxbw(xmmA, m); + cc.evex().vpmovzxbw(ymmA, m); + cc.evex().vpmovzxbw(zmmA, m); + cc.evex().vpmovzxdq(xmmA, m); + cc.evex().vpmovzxdq(ymmA, m); + cc.evex().vpmovzxdq(zmmA, m); + cc.evex().vpmovzxwd(xmmA, m); + cc.evex().vpmovzxwd(ymmA, m); + cc.evex().vpmovzxwd(zmmA, m); + cc.evex().vpmovzxwq(xmmA, m); + cc.evex().vpmovzxwq(ymmA, m); + cc.evex().vpmovzxwq(zmmA, m); + cc.evex().vpmuldq(xmmA, xmmB, m); + cc.evex().vpmuldq(ymmA, ymmB, m); + cc.evex().vpmuldq(zmmA, zmmB, m); + cc.evex().vpmulhrsw(xmmA, xmmB, m); + cc.evex().vpmulhrsw(ymmA, ymmB, m); + cc.evex().vpmulhrsw(zmmA, zmmB, m); + cc.evex().vpmulhuw(xmmA, xmmB, m); + cc.evex().vpmulhuw(ymmA, ymmB, m); + cc.evex().vpmulhuw(zmmA, zmmB, m); + cc.evex().vpmulhw(xmmA, xmmB, m); + cc.evex().vpmulhw(ymmA, ymmB, m); + cc.evex().vpmulhw(zmmA, zmmB, m); + cc.evex().vpmulld(xmmA, xmmB, m); + cc.evex().vpmulld(ymmA, ymmB, m); + cc.evex().vpmulld(zmmA, zmmB, m); + cc.evex().vpmullq(xmmA, xmmB, m); + cc.evex().vpmullq(ymmA, ymmB, m); + cc.evex().vpmullq(zmmA, zmmB, m); + cc.evex().vpmullw(xmmA, xmmB, m); + cc.evex().vpmullw(ymmA, ymmB, m); + cc.evex().vpmullw(zmmA, zmmB, m); + cc.evex().vpmultishiftqb(xmmA, xmmB, m); + cc.evex().vpmultishiftqb(ymmA, ymmB, m); + cc.evex().vpmultishiftqb(zmmA, zmmB, m); + cc.evex().vpmuludq(xmmA, xmmB, m); + cc.evex().vpmuludq(ymmA, ymmB, m); + cc.evex().vpmuludq(zmmA, zmmB, m); + cc.evex().vpopcntd(zmmA, m); + cc.evex().vpopcntq(zmmA, m); + cc.evex().vpord(xmmA, xmmB, m); + cc.evex().vpord(ymmA, ymmB, m); + cc.evex().vpord(zmmA, zmmB, m); + cc.evex().vporq(xmmA, xmmB, m); + cc.evex().vporq(ymmA, ymmB, m); + cc.evex().vporq(zmmA, zmmB, m); + cc.evex().vprold(xmmA, m, 0); + cc.evex().vprold(ymmA, m, 0); + cc.evex().vprold(zmmA, m, 0); + cc.evex().vprolq(xmmA, m, 0); + cc.evex().vprolq(ymmA, m, 0); + cc.evex().vprolq(zmmA, m, 0); + cc.evex().vprolvd(xmmA, xmmB, m); + cc.evex().vprolvd(ymmA, ymmB, m); + cc.evex().vprolvd(zmmA, zmmB, m); + cc.evex().vprolvq(xmmA, xmmB, m); + cc.evex().vprolvq(ymmA, ymmB, m); + cc.evex().vprolvq(zmmA, zmmB, m); + cc.evex().vprord(xmmA, m, 0); + cc.evex().vprord(ymmA, m, 0); + cc.evex().vprord(zmmA, m, 0); + cc.evex().vprorq(xmmA, m, 0); + cc.evex().vprorq(ymmA, m, 0); + cc.evex().vprorq(zmmA, m, 0); + cc.evex().vprorvd(xmmA, xmmB, m); + cc.evex().vprorvd(ymmA, ymmB, m); + cc.evex().vprorvd(zmmA, zmmB, m); + cc.evex().vprorvq(xmmA, xmmB, m); + cc.evex().vprorvq(ymmA, ymmB, m); + cc.evex().vprorvq(zmmA, zmmB, m); + cc.evex().vpsadbw(xmmA, xmmB, m); + cc.evex().vpsadbw(ymmA, ymmB, m); + cc.evex().vpsadbw(zmmA, zmmB, m); + cc.evex().k(kA).vpscatterdd(vx_ptr, xmmB); + cc.evex().k(kA).vpscatterdd(vy_ptr, ymmB); + cc.evex().k(kA).vpscatterdd(vz_ptr, zmmB); + cc.evex().k(kA).vpscatterdq(vx_ptr, xmmB); + cc.evex().k(kA).vpscatterdq(vx_ptr, ymmB); + cc.evex().k(kA).vpscatterdq(vy_ptr, zmmB); + cc.evex().k(kA).vpscatterqd(vx_ptr, xmmB); + cc.evex().k(kA).vpscatterqd(vy_ptr, xmmB); + cc.evex().k(kA).vpscatterqd(vz_ptr, ymmB); + cc.evex().k(kA).vpscatterqq(vx_ptr, xmmB); + cc.evex().k(kA).vpscatterqq(vy_ptr, ymmB); + cc.evex().k(kA).vpscatterqq(vz_ptr, zmmB); + cc.evex().vpshufb(xmmA, xmmB, m); + cc.evex().vpshufb(ymmA, ymmB, m); + cc.evex().vpshufb(zmmA, zmmB, m); + cc.evex().vpshufd(xmmA, m, 0); + cc.evex().vpshufd(ymmA, m, 0); + cc.evex().vpshufd(zmmA, m, 0); + cc.evex().vpshufhw(xmmA, m, 0); + cc.evex().vpshufhw(ymmA, m, 0); + cc.evex().vpshufhw(zmmA, m, 0); + cc.evex().vpshuflw(xmmA, m, 0); + cc.evex().vpshuflw(ymmA, m, 0); + cc.evex().vpshuflw(zmmA, m, 0); + cc.evex().vpslld(xmmA, xmmB, m); + cc.evex().vpslld(xmmA, m, 0); + cc.evex().vpslld(ymmA, ymmB, m); + cc.evex().vpslld(ymmA, m, 0); + cc.evex().vpslld(zmmA, zmmB, m); + cc.evex().vpslld(zmmA, m, 0); + cc.evex().vpslldq(xmmA, m, 0); + cc.evex().vpslldq(ymmA, m, 0); + cc.evex().vpslldq(zmmA, m, 0); + cc.evex().vpsllq(xmmA, xmmB, m); + cc.evex().vpsllq(xmmA, m, 0); + cc.evex().vpsllq(ymmA, ymmB, m); + cc.evex().vpsllq(ymmA, m, 0); + cc.evex().vpsllq(zmmA, zmmB, m); + cc.evex().vpsllq(zmmA, m, 0); + cc.evex().vpsllvd(xmmA, xmmB, m); + cc.evex().vpsllvd(ymmA, ymmB, m); + cc.evex().vpsllvd(zmmA, zmmB, m); + cc.evex().vpsllvq(xmmA, xmmB, m); + cc.evex().vpsllvq(ymmA, ymmB, m); + cc.evex().vpsllvq(zmmA, zmmB, m); + cc.evex().vpsllvw(xmmA, xmmB, m); + cc.evex().vpsllvw(ymmA, ymmB, m); + cc.evex().vpsllvw(zmmA, zmmB, m); + cc.evex().vpsllw(xmmA, xmmB, m); + cc.evex().vpsllw(xmmA, m, 0); + cc.evex().vpsllw(ymmA, ymmB, m); + cc.evex().vpsllw(ymmA, m, 0); + cc.evex().vpsllw(zmmA, zmmB, m); + cc.evex().vpsllw(zmmA, m, 0); + cc.evex().vpsrad(xmmA, xmmB, m); + cc.evex().vpsrad(xmmA, m, 0); + cc.evex().vpsrad(ymmA, ymmB, m); + cc.evex().vpsrad(ymmA, m, 0); + cc.evex().vpsrad(zmmA, zmmB, m); + cc.evex().vpsrad(zmmA, m, 0); + cc.evex().vpsraq(xmmA, xmmB, m); + cc.evex().vpsraq(xmmA, m, 0); + cc.evex().vpsraq(ymmA, ymmB, m); + cc.evex().vpsraq(ymmA, m, 0); + cc.evex().vpsraq(zmmA, zmmB, m); + cc.evex().vpsraq(zmmA, m, 0); + cc.evex().vpsravd(xmmA, xmmB, m); + cc.evex().vpsravd(ymmA, ymmB, m); + cc.evex().vpsravd(zmmA, zmmB, m); + cc.evex().vpsravq(xmmA, xmmB, m); + cc.evex().vpsravq(ymmA, ymmB, m); + cc.evex().vpsravq(zmmA, zmmB, m); + cc.evex().vpsravw(xmmA, xmmB, m); + cc.evex().vpsravw(ymmA, ymmB, m); + cc.evex().vpsravw(zmmA, zmmB, m); + cc.evex().vpsraw(xmmA, xmmB, m); + cc.evex().vpsraw(xmmA, m, 0); + cc.evex().vpsraw(ymmA, ymmB, m); + cc.evex().vpsraw(ymmA, m, 0); + cc.evex().vpsraw(zmmA, zmmB, m); + cc.evex().vpsraw(zmmA, m, 0); + cc.evex().vpsrld(xmmA, xmmB, m); + cc.evex().vpsrld(xmmA, m, 0); + cc.evex().vpsrld(ymmA, ymmB, m); + cc.evex().vpsrld(ymmA, m, 0); + cc.evex().vpsrld(zmmA, zmmB, m); + cc.evex().vpsrld(zmmA, m, 0); + cc.evex().vpsrldq(xmmA, m, 0); + cc.evex().vpsrldq(ymmA, m, 0); + cc.evex().vpsrldq(zmmA, m, 0); + cc.evex().vpsrlq(xmmA, xmmB, m); + cc.evex().vpsrlq(xmmA, m, 0); + cc.evex().vpsrlq(ymmA, ymmB, m); + cc.evex().vpsrlq(ymmA, m, 0); + cc.evex().vpsrlq(zmmA, zmmB, m); + cc.evex().vpsrlq(zmmA, m, 0); + cc.evex().vpsrlvd(xmmA, xmmB, m); + cc.evex().vpsrlvd(ymmA, ymmB, m); + cc.evex().vpsrlvd(zmmA, zmmB, m); + cc.evex().vpsrlvq(xmmA, xmmB, m); + cc.evex().vpsrlvq(ymmA, ymmB, m); + cc.evex().vpsrlvq(zmmA, zmmB, m); + cc.evex().vpsrlvw(xmmA, xmmB, m); + cc.evex().vpsrlvw(ymmA, ymmB, m); + cc.evex().vpsrlvw(zmmA, zmmB, m); + cc.evex().vpsrlw(xmmA, xmmB, m); + cc.evex().vpsrlw(xmmA, m, 0); + cc.evex().vpsrlw(ymmA, ymmB, m); + cc.evex().vpsrlw(ymmA, m, 0); + cc.evex().vpsrlw(zmmA, zmmB, m); + cc.evex().vpsrlw(zmmA, m, 0); + cc.evex().vpsubb(xmmA, xmmB, m); + cc.evex().vpsubb(ymmA, ymmB, m); + cc.evex().vpsubb(zmmA, zmmB, m); + cc.evex().vpsubd(xmmA, xmmB, m); + cc.evex().vpsubd(ymmA, ymmB, m); + cc.evex().vpsubd(zmmA, zmmB, m); + cc.evex().vpsubq(xmmA, xmmB, m); + cc.evex().vpsubq(ymmA, ymmB, m); + cc.evex().vpsubq(zmmA, zmmB, m); + cc.evex().vpsubsb(xmmA, xmmB, m); + cc.evex().vpsubsb(ymmA, ymmB, m); + cc.evex().vpsubsb(zmmA, zmmB, m); + cc.evex().vpsubsw(xmmA, xmmB, m); + cc.evex().vpsubsw(ymmA, ymmB, m); + cc.evex().vpsubsw(zmmA, zmmB, m); + cc.evex().vpsubusb(xmmA, xmmB, m); + cc.evex().vpsubusb(ymmA, ymmB, m); + cc.evex().vpsubusb(zmmA, zmmB, m); + cc.evex().vpsubusw(xmmA, xmmB, m); + cc.evex().vpsubusw(ymmA, ymmB, m); + cc.evex().vpsubusw(zmmA, zmmB, m); + cc.evex().vpsubw(xmmA, xmmB, m); + cc.evex().vpsubw(ymmA, ymmB, m); + cc.evex().vpsubw(zmmA, zmmB, m); + cc.evex().vpternlogd(xmmA, xmmB, m, 0); + cc.evex().vpternlogd(ymmA, ymmB, m, 0); + cc.evex().vpternlogd(zmmA, zmmB, m, 0); + cc.evex().vpternlogq(xmmA, xmmB, m, 0); + cc.evex().vpternlogq(ymmA, ymmB, m, 0); + cc.evex().vpternlogq(zmmA, zmmB, m, 0); + cc.evex().vptestmb(kA, xmmB, m); + cc.evex().vptestmb(kA, ymmB, m); + cc.evex().vptestmb(kA, zmmB, m); + cc.evex().vptestmd(kA, xmmB, m); + cc.evex().vptestmd(kA, ymmB, m); + cc.evex().vptestmd(kA, zmmB, m); + cc.evex().vptestmq(kA, xmmB, m); + cc.evex().vptestmq(kA, ymmB, m); + cc.evex().vptestmq(kA, zmmB, m); + cc.evex().vptestmw(kA, xmmB, m); + cc.evex().vptestmw(kA, ymmB, m); + cc.evex().vptestmw(kA, zmmB, m); + cc.evex().vptestnmb(kA, xmmB, m); + cc.evex().vptestnmb(kA, ymmB, m); + cc.evex().vptestnmb(kA, zmmB, m); + cc.evex().vptestnmd(kA, xmmB, m); + cc.evex().vptestnmd(kA, ymmB, m); + cc.evex().vptestnmd(kA, zmmB, m); + cc.evex().vptestnmq(kA, xmmB, m); + cc.evex().vptestnmq(kA, ymmB, m); + cc.evex().vptestnmq(kA, zmmB, m); + cc.evex().vptestnmw(kA, xmmB, m); + cc.evex().vptestnmw(kA, ymmB, m); + cc.evex().vptestnmw(kA, zmmB, m); + cc.evex().vpunpckhbw(xmmA, xmmB, m); + cc.evex().vpunpckhbw(ymmA, ymmB, m); + cc.evex().vpunpckhbw(zmmA, zmmB, m); + cc.evex().vpunpckhdq(xmmA, xmmB, m); + cc.evex().vpunpckhdq(ymmA, ymmB, m); + cc.evex().vpunpckhdq(zmmA, zmmB, m); + cc.evex().vpunpckhqdq(xmmA, xmmB, m); + cc.evex().vpunpckhqdq(ymmA, ymmB, m); + cc.evex().vpunpckhqdq(zmmA, zmmB, m); + cc.evex().vpunpckhwd(xmmA, xmmB, m); + cc.evex().vpunpckhwd(ymmA, ymmB, m); + cc.evex().vpunpckhwd(zmmA, zmmB, m); + cc.evex().vpunpcklbw(xmmA, xmmB, m); + cc.evex().vpunpcklbw(ymmA, ymmB, m); + cc.evex().vpunpcklbw(zmmA, zmmB, m); + cc.evex().vpunpckldq(xmmA, xmmB, m); + cc.evex().vpunpckldq(ymmA, ymmB, m); + cc.evex().vpunpckldq(zmmA, zmmB, m); + cc.evex().vpunpcklqdq(xmmA, xmmB, m); + cc.evex().vpunpcklqdq(ymmA, ymmB, m); + cc.evex().vpunpcklqdq(zmmA, zmmB, m); + cc.evex().vpunpcklwd(xmmA, xmmB, m); + cc.evex().vpunpcklwd(ymmA, ymmB, m); + cc.evex().vpunpcklwd(zmmA, zmmB, m); + cc.evex().vpxord(xmmA, xmmB, m); + cc.evex().vpxord(ymmA, ymmB, m); + cc.evex().vpxord(zmmA, zmmB, m); + cc.evex().vpxorq(xmmA, xmmB, m); + cc.evex().vpxorq(ymmA, ymmB, m); + cc.evex().vpxorq(zmmA, zmmB, m); + cc.evex().vrangepd(xmmA, xmmB, m, 0); + cc.evex().vrangepd(ymmA, ymmB, m, 0); + cc.evex().vrangepd(zmmA, zmmB, m, 0); + cc.evex().vrangeps(xmmA, xmmB, m, 0); + cc.evex().vrangeps(ymmA, ymmB, m, 0); + cc.evex().vrangeps(zmmA, zmmB, m, 0); + cc.evex().vrangesd(xmmA, xmmB, m, 0); + cc.evex().vrangess(xmmA, xmmB, m, 0); + cc.evex().vrcp14pd(xmmA, m); + cc.evex().vrcp14pd(ymmA, m); + cc.evex().vrcp14pd(zmmA, m); + cc.evex().vrcp14ps(xmmA, m); + cc.evex().vrcp14ps(ymmA, m); + cc.evex().vrcp14ps(zmmA, m); + cc.evex().vrcp14sd(xmmA, xmmB, m); + cc.evex().vrcp14ss(xmmA, xmmB, m); + cc.evex().vrcp28pd(zmmA, m); + cc.evex().vrcp28ps(zmmA, m); + cc.evex().vrcp28sd(xmmA, xmmB, m); + cc.evex().vrcp28ss(xmmA, xmmB, m); + cc.evex().vreducepd(xmmA, m, 0); + cc.evex().vreducepd(ymmA, m, 0); + cc.evex().vreducepd(zmmA, m, 0); + cc.evex().vreduceps(xmmA, m, 0); + cc.evex().vreduceps(ymmA, m, 0); + cc.evex().vreduceps(zmmA, m, 0); + cc.evex().vreducesd(xmmA, xmmB, m, 0); + cc.evex().vreducess(xmmA, xmmB, m, 0); + cc.evex().vrndscalepd(xmmA, m, 0); + cc.evex().vrndscalepd(ymmA, m, 0); + cc.evex().vrndscalepd(zmmA, m, 0); + cc.evex().vrndscaleps(xmmA, m, 0); + cc.evex().vrndscaleps(ymmA, m, 0); + cc.evex().vrndscaleps(zmmA, m, 0); + cc.evex().vrndscalesd(xmmA, xmmB, m, 0); + cc.evex().vrndscaless(xmmA, xmmB, m, 0); + cc.evex().vrsqrt14pd(xmmA, m); + cc.evex().vrsqrt14pd(ymmA, m); + cc.evex().vrsqrt14pd(zmmA, m); + cc.evex().vrsqrt14ps(xmmA, m); + cc.evex().vrsqrt14ps(ymmA, m); + cc.evex().vrsqrt14ps(zmmA, m); + cc.evex().vrsqrt14sd(xmmA, xmmB, m); + cc.evex().vrsqrt14ss(xmmA, xmmB, m); + cc.evex().vrsqrt28pd(zmmA, m); + cc.evex().vrsqrt28ps(zmmA, m); + cc.evex().vrsqrt28sd(xmmA, xmmB, m); + cc.evex().vrsqrt28ss(xmmA, xmmB, m); + cc.evex().vscalefpd(xmmA, xmmB, m); + cc.evex().vscalefpd(ymmA, ymmB, m); + cc.evex().vscalefpd(zmmA, zmmB, m); + cc.evex().vscalefps(xmmA, xmmB, m); + cc.evex().vscalefps(ymmA, ymmB, m); + cc.evex().vscalefps(zmmA, zmmB, m); + cc.evex().vscalefsd(xmmA, xmmB, m); + cc.evex().vscalefss(xmmA, xmmB, m); + cc.evex().k(kA).vscatterdpd(vx_ptr, xmmB); + cc.evex().k(kA).vscatterdpd(vx_ptr, ymmB); + cc.evex().k(kA).vscatterdpd(vy_ptr, zmmB); + cc.evex().k(kA).vscatterdps(vx_ptr, xmmB); + cc.evex().k(kA).vscatterdps(vy_ptr, ymmB); + cc.evex().k(kA).vscatterdps(vz_ptr, zmmB); + cc.evex().k(kA).vscatterpf0dpd(vy_ptr); + cc.evex().k(kA).vscatterpf0dps(vz_ptr); + cc.evex().k(kA).vscatterpf0qpd(vz_ptr); + cc.evex().k(kA).vscatterpf0qps(vz_ptr); + cc.evex().k(kA).vscatterpf1dpd(vy_ptr); + cc.evex().k(kA).vscatterpf1dps(vz_ptr); + cc.evex().k(kA).vscatterpf1qpd(vz_ptr); + cc.evex().k(kA).vscatterpf1qps(vz_ptr); + cc.evex().k(kA).vscatterqpd(vx_ptr, xmmB); + cc.evex().k(kA).vscatterqpd(vy_ptr, ymmB); + cc.evex().k(kA).vscatterqpd(vz_ptr, zmmB); + cc.evex().k(kA).vscatterqps(vx_ptr, xmmB); + cc.evex().k(kA).vscatterqps(vy_ptr, xmmB); + cc.evex().k(kA).vscatterqps(vz_ptr, ymmB); + cc.evex().vshuff32x4(ymmA, ymmB, m, 0); + cc.evex().vshuff32x4(zmmA, zmmB, m, 0); + cc.evex().vshuff64x2(ymmA, ymmB, m, 0); + cc.evex().vshuff64x2(zmmA, zmmB, m, 0); + cc.evex().vshufi32x4(ymmA, ymmB, m, 0); + cc.evex().vshufi32x4(zmmA, zmmB, m, 0); + cc.evex().vshufi64x2(ymmA, ymmB, m, 0); + cc.evex().vshufi64x2(zmmA, zmmB, m, 0); + cc.evex().vshufpd(xmmA, xmmB, m, 0); + cc.evex().vshufpd(ymmA, ymmB, m, 0); + cc.evex().vshufpd(zmmA, zmmB, m, 0); + cc.evex().vshufps(xmmA, xmmB, m, 0); + cc.evex().vshufps(ymmA, ymmB, m, 0); + cc.evex().vshufps(zmmA, zmmB, m, 0); + cc.evex().vsqrtpd(xmmA, m); + cc.evex().vsqrtpd(ymmA, m); + cc.evex().vsqrtpd(zmmA, m); + cc.evex().vsqrtps(xmmA, m); + cc.evex().vsqrtps(ymmA, m); + cc.evex().vsqrtps(zmmA, m); + cc.evex().vsqrtsd(xmmA, xmmB, m); + cc.evex().vsqrtss(xmmA, xmmB, m); + cc.evex().vsubpd(xmmA, xmmB, m); + cc.evex().vsubpd(ymmA, ymmB, m); + cc.evex().vsubpd(zmmA, zmmB, m); + cc.evex().vsubps(xmmA, xmmB, m); + cc.evex().vsubps(ymmA, ymmB, m); + cc.evex().vsubps(zmmA, zmmB, m); + cc.evex().vsubsd(xmmA, xmmB, m); + cc.evex().vsubss(xmmA, xmmB, m); + cc.evex().vucomisd(xmmA, m); + cc.evex().vucomiss(xmmA, m); + cc.evex().vunpckhpd(xmmA, xmmB, m); + cc.evex().vunpckhpd(ymmA, ymmB, m); + cc.evex().vunpckhpd(zmmA, zmmB, m); + cc.evex().vunpckhps(xmmA, xmmB, m); + cc.evex().vunpckhps(ymmA, ymmB, m); + cc.evex().vunpckhps(zmmA, zmmB, m); + cc.evex().vunpcklpd(xmmA, xmmB, m); + cc.evex().vunpcklpd(ymmA, ymmB, m); + cc.evex().vunpcklpd(zmmA, zmmB, m); + cc.evex().vunpcklps(xmmA, xmmB, m); + cc.evex().vunpcklps(ymmA, ymmB, m); + cc.evex().vunpcklps(zmmA, zmmB, m); + cc.evex().vxorpd(xmmA, xmmB, m); + cc.evex().vxorpd(ymmA, ymmB, m); + cc.evex().vxorpd(zmmA, zmmB, m); + cc.evex().vxorps(xmmA, xmmB, m); + cc.evex().vxorps(ymmA, ymmB, m); + cc.evex().vxorps(zmmA, zmmB, m); + } +} + +static void generateAvx512Sequence(BaseEmitter& emitter, InstForm form, bool emitPrologEpilog) { + using namespace asmjit::x86; + + if (emitter.isAssembler()) { + Assembler& cc = *emitter.as<Assembler>(); + + if (emitPrologEpilog) { + FuncDetail func; + func.init(FuncSignatureT<void, void*, const void*, size_t>(CallConvId::kHost), cc.environment()); + + FuncFrame frame; + frame.init(func); + frame.addDirtyRegs(eax, k1, k2, k3, zmm0, zmm1, zmm2, zmm3); + frame.finalize(); + + cc.emitProlog(frame); + generateAvx512SequenceInternal(cc, form, eax, k1, k2, k3, zmm0, zmm1, zmm2, zmm3); + cc.emitEpilog(frame); + } + else { + generateAvx512SequenceInternal(cc, form, eax, k1, k2, k3, zmm0, zmm1, zmm2, zmm3); + } + } +#ifndef ASMJIT_NO_BUILDER + else if (emitter.isBuilder()) { + Builder& cc = *emitter.as<Builder>(); + + if (emitPrologEpilog) { + FuncDetail func; + func.init(FuncSignatureT<void, void*, const void*, size_t>(CallConvId::kHost), cc.environment()); + + FuncFrame frame; + frame.init(func); + frame.addDirtyRegs(eax, k1, k2, k3, zmm0, zmm1, zmm2, zmm3); + frame.finalize(); + + cc.emitProlog(frame); + generateAvx512SequenceInternal(cc, form, eax, k1, k2, k3, zmm0, zmm1, zmm2, zmm3); + cc.emitEpilog(frame); + } + else { + generateAvx512SequenceInternal(cc, form, eax, k1, k2, k3, zmm0, zmm1, zmm2, zmm3); + } + } +#endif +#ifndef ASMJIT_NO_COMPILER + else if (emitter.isCompiler()) { + Compiler& cc = *emitter.as<Compiler>(); + + Gp gp = cc.newGpz("gp"); + Zmm vecA = cc.newZmm("vecA"); + Zmm vecB = cc.newZmm("vecB"); + Zmm vecC = cc.newZmm("vecC"); + Zmm vecD = cc.newZmm("vecD"); + + KReg kA = cc.newKq("kA"); + KReg kB = cc.newKq("kB"); + KReg kC = cc.newKq("kC"); + + cc.addFunc(FuncSignatureT<void>(CallConvId::kHost)); + generateAvx512SequenceInternal(cc, form, gp, kA, kB, kC, vecA, vecB, vecC, vecD); + cc.endFunc(); + } +#endif +} + +template<typename EmitterFn> +static void benchmarkX86Function(Arch arch, uint32_t numIterations, const char* description, const EmitterFn& emitterFn) noexcept { + CodeHolder code; + printf("%s:\n", description); + + bench<x86::Assembler>(code, arch, numIterations, "[raw]", [&](x86::Assembler& cc) { + emitterFn(cc, false); + }); + + bench<x86::Assembler>(code, arch, numIterations, "[validated]", [&](x86::Assembler& cc) { + cc.addDiagnosticOptions(DiagnosticOptions::kValidateAssembler); + emitterFn(cc, false); + }); + + bench<x86::Assembler>(code, arch, numIterations, "[prolog/epilog]", [&](x86::Assembler& cc) { + cc.addDiagnosticOptions(DiagnosticOptions::kValidateAssembler); + emitterFn(cc, true); + }); + +#ifndef ASMJIT_NO_BUILDER + bench<x86::Builder>(code, arch, numIterations, "[no-asm]", [&](x86::Builder& cc) { + emitterFn(cc, false); + }); + + bench<x86::Builder>(code, arch, numIterations, "[finalized]", [&](x86::Builder& cc) { + emitterFn(cc, false); + cc.finalize(); + }); + + bench<x86::Builder>(code, arch, numIterations, "[prolog/epilog]", [&](x86::Builder& cc) { + emitterFn(cc, true); + cc.finalize(); + }); +#endif + +#ifndef ASMJIT_NO_COMPILER + bench<x86::Compiler>(code, arch, numIterations, "[no-asm]", [&](x86::Compiler& cc) { + emitterFn(cc, true); + }); + + bench<x86::Compiler>(code, arch, numIterations, "[finalized]", [&](x86::Compiler& cc) { + emitterFn(cc, true); + cc.finalize(); + }); +#endif + + printf("\n"); +} + +void benchmarkX86Emitters(uint32_t numIterations, bool testX86, bool testX64) { + uint32_t i = 0; + uint32_t n = 0; + + Arch archs[2] {}; + + if (testX86) archs[n++] = Arch::kX86; + if (testX64) archs[n++] = Arch::kX64; + + for (i = 0; i < n; i++) { + static const char description[] = "GpSequence<Reg> (Sequence of GP instructions - reg-only)"; + benchmarkX86Function(archs[i], numIterations, description, [](BaseEmitter& emitter, bool emitPrologEpilog) { + generateGpSequence(emitter, InstForm::kReg, emitPrologEpilog); + }); + } + + for (i = 0; i < n; i++) { + static const char description[] = "GpSequence<Mem> (Sequence of GP instructions - reg/mem)"; + benchmarkX86Function(archs[i], numIterations, description, [](BaseEmitter& emitter, bool emitPrologEpilog) { + generateGpSequence(emitter, InstForm::kMem, emitPrologEpilog); + }); + } + + for (i = 0; i < n; i++) { + static const char description[] = "SseSequence<Reg> (sequence of SSE+ instructions - reg-only)"; + benchmarkX86Function(archs[i], numIterations, description, [](BaseEmitter& emitter, bool emitPrologEpilog) { + generateSseSequence(emitter, InstForm::kReg, emitPrologEpilog); + }); + } + + for (i = 0; i < n; i++) { + static const char description[] = "SseSequence<Mem> (sequence of SSE+ instructions - reg/mem)"; + benchmarkX86Function(archs[i], numIterations, description, [](BaseEmitter& emitter, bool emitPrologEpilog) { + generateSseSequence(emitter, InstForm::kMem, emitPrologEpilog); + }); + } + + for (i = 0; i < n; i++) { + static const char description[] = "AvxSequence<Reg> (sequence of AVX+ instructions - reg-only)"; + benchmarkX86Function(archs[i], numIterations, description, [](BaseEmitter& emitter, bool emitPrologEpilog) { + generateAvxSequence(emitter, InstForm::kReg, emitPrologEpilog); + }); + } + + for (i = 0; i < n; i++) { + static const char description[] = "AvxSequence<Mem> (sequence of AVX+ instructions - reg/mem)"; + benchmarkX86Function(archs[i], numIterations, description, [](BaseEmitter& emitter, bool emitPrologEpilog) { + generateAvxSequence(emitter, InstForm::kMem, emitPrologEpilog); + }); + } + + for (i = 0; i < n; i++) { + static const char description[] = "Avx512Sequence<Reg> (sequence of AVX512+ instructions - reg-only)"; + benchmarkX86Function(archs[i], numIterations, description, [](BaseEmitter& emitter, bool emitPrologEpilog) { + generateAvx512Sequence(emitter, InstForm::kReg, emitPrologEpilog); + }); + } + + for (i = 0; i < n; i++) { + static const char description[] = "Avx512Sequence<Mem> (sequence of AVX512+ instructions - reg/mem)"; + benchmarkX86Function(archs[i], numIterations, description, [](BaseEmitter& emitter, bool emitPrologEpilog) { + generateAvx512Sequence(emitter, InstForm::kMem, emitPrologEpilog); + }); + } + + for (i = 0; i < n; i++) { + static const char description[] = "SseAlphaBlend (alpha-blend function with labels and jumps)"; + benchmarkX86Function(archs[i], numIterations, description, [](BaseEmitter& emitter, bool emitPrologEpilog) { + asmtest::generateSseAlphaBlend(emitter, emitPrologEpilog); + }); + } +} + +#endif // !ASMJIT_NO_X86 diff --git a/3rdparty/asmjit/test/asmjit_test_unit.cpp b/3rdparty/asmjit/test/asmjit_test_unit.cpp index 3aac7401e17..5658ebc1d60 100644 --- a/3rdparty/asmjit/test/asmjit_test_unit.cpp +++ b/3rdparty/asmjit/test/asmjit_test_unit.cpp @@ -1,61 +1,26 @@ -// AsmJit - Machine code generation for C++ +// This file is part of AsmJit project <https://asmjit.com> // -// * Official AsmJit Home Page: https://asmjit.com -// * Official Github Repository: https://github.com/asmjit/asmjit -// -// Copyright (c) 2008-2020 The AsmJit Authors -// -// This software is provided 'as-is', without any express or implied -// warranty. In no event will the authors be held liable for any damages -// arising from the use of this software. -// -// Permission is granted to anyone to use this software for any purpose, -// including commercial applications, and to alter it and redistribute it -// freely, subject to the following restrictions: -// -// 1. The origin of this software must not be misrepresented; you must not -// claim that you wrote the original software. If you use this software -// in a product, an acknowledgment in the product documentation would be -// appreciated but is not required. -// 2. Altered source versions must be plainly marked as such, and must not be -// misrepresented as being the original software. -// 3. This notice may not be removed or altered from any source distribution. +// See asmjit.h or LICENSE.md for license and copyright information +// SPDX-License-Identifier: Zlib -#include <asmjit/asmjit.h> -#include "./broken.h" +#include <asmjit/core.h> -using namespace asmjit; +#if !defined(ASMJIT_NO_X86) +#include <asmjit/x86.h> +#endif -// ============================================================================ -// [DumpCpu] -// ============================================================================ - -struct DumpCpuFeature { - uint32_t feature; - const char* name; -}; - -static const char* archToString(uint32_t arch) noexcept { - switch (arch & ~Environment::kArchBigEndianMask) { - case Environment::kArchX86 : return "X86"; - case Environment::kArchX64 : return "X64"; - case Environment::kArchARM : return "ARM"; - case Environment::kArchThumb : return "Thumb"; - case Environment::kArchAArch64 : return "AArch64"; - case Environment::kArchMIPS_LE : return "MIPS"; - case Environment::kArchMIPS64_LE: return "MIPS64"; - default: return "Unknown"; - } -} +#include "asmjitutils.h" +#include "broken.h" + +using namespace asmjit; static void dumpCpu(void) noexcept { const CpuInfo& cpu = CpuInfo::host(); - // -------------------------------------------------------------------------- - // [CPU Information] - // -------------------------------------------------------------------------- + // CPU Information + // --------------- - INFO("Host CPU:"); + INFO("CPU Info:"); INFO(" Vendor : %s", cpu.vendor()); INFO(" Brand : %s", cpu.brand()); INFO(" Model ID : %u", cpu.modelId()); @@ -68,13 +33,12 @@ static void dumpCpu(void) noexcept { INFO(" HW-Thread Count : %u", cpu.hwThreadCount()); INFO(""); - // -------------------------------------------------------------------------- - // [CPU Features] - // -------------------------------------------------------------------------- + // CPU Features + // ------------ #ifndef ASMJIT_NO_LOGGING INFO("CPU Features:"); - BaseFeatures::Iterator it(cpu.features().iterator()); + CpuFeatures::Iterator it(cpu.features().iterator()); while (it.hasNext()) { uint32_t featureId = uint32_t(it.next()); StringTmp<64> featureString; @@ -85,10 +49,6 @@ static void dumpCpu(void) noexcept { #endif // !ASMJIT_NO_LOGGING } -// ============================================================================ -// [DumpSizeOf] -// ============================================================================ - #define DUMP_TYPE(...) \ INFO(" %-26s: %u", #__VA_ARGS__, uint32_t(sizeof(__VA_ARGS__))) @@ -144,7 +104,7 @@ static void dumpSizeOf(void) noexcept { DUMP_TYPE(FuncArgsAssignment); INFO(""); -#ifndef ASMJIT_NO_BUILDER +#if !defined(ASMJIT_NO_BUILDER) INFO("Size of builder classes:"); DUMP_TYPE(BaseBuilder); DUMP_TYPE(BaseNode); @@ -160,7 +120,7 @@ static void dumpSizeOf(void) noexcept { INFO(""); #endif -#ifndef ASMJIT_NO_COMPILER +#if !defined(ASMJIT_NO_COMPILER) INFO("Size of compiler classes:"); DUMP_TYPE(BaseCompiler); DUMP_TYPE(FuncNode); @@ -169,13 +129,13 @@ static void dumpSizeOf(void) noexcept { INFO(""); #endif -#ifdef ASMJIT_BUILD_X86 +#if !defined(ASMJIT_NO_X86) INFO("Size of x86-specific classes:"); DUMP_TYPE(x86::Assembler); - #ifndef ASMJIT_NO_BUILDER + #if !defined(ASMJIT_NO_BUILDER) DUMP_TYPE(x86::Builder); #endif - #ifndef ASMJIT_NO_COMPILER + #if !defined(ASMJIT_NO_COMPILER) DUMP_TYPE(x86::Compiler); #endif DUMP_TYPE(x86::InstDB::InstInfo); @@ -188,10 +148,6 @@ static void dumpSizeOf(void) noexcept { #undef DUMP_TYPE -// ============================================================================ -// [Main] -// ============================================================================ - static void onBeforeRun(void) noexcept { dumpCpu(); dumpSizeOf(); @@ -208,7 +164,7 @@ int main(int argc, const char* argv[]) { unsigned((ASMJIT_LIBRARY_VERSION >> 16) ), unsigned((ASMJIT_LIBRARY_VERSION >> 8) & 0xFF), unsigned((ASMJIT_LIBRARY_VERSION ) & 0xFF), - archToString(Environment::kArchHost), + asmjitArchAsString(Arch::kHost), buildType ); diff --git a/3rdparty/asmjit/test/asmjit_test_x86_instinfo.cpp b/3rdparty/asmjit/test/asmjit_test_x86_instinfo.cpp deleted file mode 100644 index 1d7d5003f8b..00000000000 --- a/3rdparty/asmjit/test/asmjit_test_x86_instinfo.cpp +++ /dev/null @@ -1,128 +0,0 @@ -// AsmJit - Machine code generation for C++ -// -// * Official AsmJit Home Page: https://asmjit.com -// * Official Github Repository: https://github.com/asmjit/asmjit -// -// Copyright (c) 2008-2020 The AsmJit Authors -// -// This software is provided 'as-is', without any express or implied -// warranty. In no event will the authors be held liable for any damages -// arising from the use of this software. -// -// Permission is granted to anyone to use this software for any purpose, -// including commercial applications, and to alter it and redistribute it -// freely, subject to the following restrictions: -// -// 1. The origin of this software must not be misrepresented; you must not -// claim that you wrote the original software. If you use this software -// in a product, an acknowledgment in the product documentation would be -// appreciated but is not required. -// 2. Altered source versions must be plainly marked as such, and must not be -// misrepresented as being the original software. -// 3. This notice may not be removed or altered from any source distribution. - -#include <asmjit/x86.h> -#include <stdio.h> - -using namespace asmjit; - -static void printInfo(uint32_t arch, const BaseInst& inst, const Operand_* operands, size_t opCount) { - StringTmp<512> sb; - - // Read & Write Information - // ------------------------ - - InstRWInfo rw; - InstAPI::queryRWInfo(arch, inst, operands, opCount, &rw); - - sb.append("Instruction:\n"); - sb.append(" "); -#ifndef ASMJIT_NO_LOGGING - Formatter::formatInstruction(sb, 0, nullptr, arch, inst, operands, opCount); -#else - sb.append("<Logging-Not-Available>"); -#endif - sb.append("\n"); - - sb.append("Operands:\n"); - for (uint32_t i = 0; i < rw.opCount(); i++) { - const OpRWInfo& op = rw.operand(i); - const char* access = op.isReadOnly() ? "R" : - op.isWriteOnly() ? "W" : - op.isReadWrite() ? "X" : "_"; - - sb.appendFormat(" [%u] RW=%s Read=%016llX Write=%016llX Extend=%016llX", - i, access, op.readByteMask(), op.writeByteMask(), op.extendByteMask()); - sb.append("\n"); - } - - // CPU Features - // ------------ - - BaseFeatures features; - InstAPI::queryFeatures(arch, inst, operands, opCount, &features); - -#ifndef ASMJIT_NO_LOGGING - if (!features.empty()) { - sb.append("Features:\n"); - sb.append(" "); - - bool first = true; - BaseFeatures::Iterator it(features.iterator()); - while (it.hasNext()) { - uint32_t featureId = uint32_t(it.next()); - if (!first) - sb.append(" & "); - Formatter::formatFeature(sb, arch, featureId); - first = false; - } - sb.append("\n"); - } -#endif - - printf("%s\n", sb.data()); -} - -template<typename... Args> -static void printInfoSimple(uint32_t arch, uint32_t instId, Args&&... args) { - BaseInst inst(instId); - Operand_ opArray[] = { std::forward<Args>(args)... }; - printInfo(arch, inst, opArray, sizeof...(args)); -} - -int main() { - using namespace x86; - uint32_t arch = Environment::kArchX64; - - printf("AsmJit X86 Instruction Information Test\n\n"); - - printInfoSimple(arch, - x86::Inst::kIdAdd, - x86::eax, x86::ebx); - - printInfoSimple(arch, - x86::Inst::kIdPshufd, - x86::xmm0, x86::xmm1, imm(0)); - - printInfoSimple(arch, - x86::Inst::kIdPextrw, - x86::eax, x86::xmm1, imm(0)); - - printInfoSimple(arch, - x86::Inst::kIdPextrw, - x86::ptr(rax), x86::xmm1, imm(0)); - - printInfoSimple(arch, - x86::Inst::kIdVaddpd, - x86::ymm0, x86::ymm1, x86::ymm2); - - printInfoSimple(arch, - x86::Inst::kIdVaddpd, - x86::ymm0, x86::ymm30, x86::ymm31); - - printInfoSimple(arch, - x86::Inst::kIdVaddpd, - x86::zmm0, x86::zmm1, x86::zmm2); - - return 0; -} diff --git a/3rdparty/asmjit/test/asmjit_test_x86_sections.cpp b/3rdparty/asmjit/test/asmjit_test_x86_sections.cpp index ddafd63b8bc..353b5e4fa1b 100644 --- a/3rdparty/asmjit/test/asmjit_test_x86_sections.cpp +++ b/3rdparty/asmjit/test/asmjit_test_x86_sections.cpp @@ -1,25 +1,7 @@ -// AsmJit - Machine code generation for C++ +// This file is part of AsmJit project <https://asmjit.com> // -// * Official AsmJit Home Page: https://asmjit.com -// * Official Github Repository: https://github.com/asmjit/asmjit -// -// Copyright (c) 2008-2020 The AsmJit Authors -// -// This software is provided 'as-is', without any express or implied -// warranty. In no event will the authors be held liable for any damages -// arising from the use of this software. -// -// Permission is granted to anyone to use this software for any purpose, -// including commercial applications, and to alter it and redistribute it -// freely, subject to the following restrictions: -// -// 1. The origin of this software must not be misrepresented; you must not -// claim that you wrote the original software. If you use this software -// in a product, an acknowledgment in the product documentation would be -// appreciated but is not required. -// 2. Altered source versions must be plainly marked as such, and must not be -// misrepresented as being the original software. -// 3. This notice may not be removed or altered from any source distribution. +// See asmjit.h or LICENSE.md for license and copyright information +// SPDX-License-Identifier: Zlib // ---------------------------------------------------------------------------- // This is a working example that demonstrates how multiple sections can be @@ -34,6 +16,9 @@ // - Copy the code to the destination address. // ---------------------------------------------------------------------------- +#include <asmjit/core.h> +#if !defined(ASMJIT_NO_X86) && ASMJIT_ARCH_X86 + #include <asmjit/x86.h> #include <stdio.h> #include <stdlib.h> @@ -48,19 +33,19 @@ using namespace asmjit; static const uint8_t dataArray[] = { 2, 9, 4, 7, 1, 3, 8, 5, 6, 0 }; static void fail(const char* message, Error err) { - printf("%s: %s\n", message, DebugUtils::errorAsString(err)); + printf("** FAILURE: %s (%s) **\n", message, DebugUtils::errorAsString(err)); exit(1); } int main() { printf("AsmJit X86 Sections Test\n\n"); - Environment env = hostEnvironment(); + Environment env = Environment::host(); JitAllocator allocator; #ifndef ASMJIT_NO_LOGGING FileLogger logger(stdout); - logger.setIndentation(FormatOptions::kIndentationCode, 2); + logger.setIndentation(FormatIndentationGroup::kCode, 2); #endif CodeHolder code; @@ -71,7 +56,7 @@ int main() { #endif Section* dataSection; - Error err = code.newSection(&dataSection, ".data", SIZE_MAX, 0, 8); + Error err = code.newSection(&dataSection, ".data", SIZE_MAX, SectionFlags::kNone, 8); if (err) { fail("Failed to create a .data section", err); @@ -85,7 +70,7 @@ int main() { Label data = a.newLabel(); FuncDetail func; - func.init(FuncSignatureT<size_t, size_t>(CallConv::kIdHost), code.environment()); + func.init(FuncSignatureT<size_t, size_t>(CallConvId::kHost), code.environment()); FuncFrame frame; frame.init(func); @@ -115,7 +100,7 @@ int main() { // how to do it explicitly. printf("\nCalculating section offsets:\n"); uint64_t offset = 0; - for (Section* section : code.sections()) { + for (Section* section : code.sectionsByOrder()) { offset = Support::alignUp(offset, section->alignment()); section->setOffset(offset); offset += section->realSize(); @@ -142,34 +127,46 @@ int main() { } // Allocate memory for the function and relocate it there. - void* roPtr; + void* rxPtr; void* rwPtr; - err = allocator.alloc(&roPtr, &rwPtr, codeSize); + err = allocator.alloc(&rxPtr, &rwPtr, codeSize); if (err) fail("Failed to allocate executable memory", err); // Relocate to the base-address of the allocated memory. - code.relocateToBase(uint64_t(uintptr_t(roPtr))); + code.relocateToBase(uint64_t(uintptr_t(rxPtr))); + + VirtMem::protectJitMemory(VirtMem::ProtectJitAccess::kReadWrite); // Copy the flattened code into `mem.rw`. There are two ways. You can either copy // everything manually by iterating over all sections or use `copyFlattenedData`. // This code is similar to what `copyFlattenedData(p, codeSize, 0)` would do: - for (Section* section : code.sections()) + for (Section* section : code.sectionsByOrder()) memcpy(static_cast<uint8_t*>(rwPtr) + size_t(section->offset()), section->data(), section->bufferSize()); + VirtMem::protectJitMemory(VirtMem::ProtectJitAccess::kReadExecute); + VirtMem::flushInstructionCache(rwPtr, code.codeSize()); + // Execute the function and test whether it works. typedef size_t (*Func)(size_t idx); - Func fn = (Func)roPtr; + Func fn = (Func)rxPtr; printf("\n"); if (fn(0) != dataArray[0] || fn(3) != dataArray[3] || fn(6) != dataArray[6] || fn(9) != dataArray[9] ) { - printf("Failure:\n The generated function returned incorrect result(s)\n"); + printf("** FAILURE: The generated function returned incorrect result(s) **\n"); return 1; } - printf("Success:\n The generated function returned expected results\n"); + printf("** SUCCESS **\n"); + return 0; +} + +#else +int main() { + printf("AsmJit X86 Sections Test is disabled on non-x86 host\n\n"); return 0; } +#endif // !ASMJIT_NO_X86 && ASMJIT_ARCH_X86 diff --git a/3rdparty/asmjit/test/asmjitutils.h b/3rdparty/asmjit/test/asmjitutils.h new file mode 100644 index 00000000000..d84d3d4c742 --- /dev/null +++ b/3rdparty/asmjit/test/asmjitutils.h @@ -0,0 +1,38 @@ +// This file is part of AsmJit project <https://asmjit.com> +// +// See asmjit.h or LICENSE.md for license and copyright information +// SPDX-License-Identifier: Zlib + +#ifndef ASMJITUTILS_H_INCLUDED +#define ASMJITUTILS_H_INCLUDED + +#include <asmjit/core.h> + +static const char* asmjitArchAsString(asmjit::Arch arch) noexcept { + switch (arch) { + case asmjit::Arch::kX86 : return "X86"; + case asmjit::Arch::kX64 : return "X64"; + + case asmjit::Arch::kRISCV32 : return "RISCV32"; + case asmjit::Arch::kRISCV64 : return "RISCV64"; + + case asmjit::Arch::kARM : return "ARM"; + case asmjit::Arch::kAArch64 : return "AArch64"; + case asmjit::Arch::kThumb : return "Thumb"; + + case asmjit::Arch::kMIPS32_LE : return "MIPS_LE"; + case asmjit::Arch::kMIPS64_LE : return "MIPS64_LE"; + + case asmjit::Arch::kARM_BE : return "ARM_BE"; + case asmjit::Arch::kThumb_BE : return "Thumb_BE"; + case asmjit::Arch::kAArch64_BE: return "AArch64_BE"; + + case asmjit::Arch::kMIPS32_BE : return "MIPS_BE"; + case asmjit::Arch::kMIPS64_BE : return "MIPS64_BE"; + + default: + return "<Unknown>"; + } +} + +#endif // ASMJITUTILS_H_INCLUDED diff --git a/3rdparty/asmjit/test/cmdline.h b/3rdparty/asmjit/test/cmdline.h new file mode 100644 index 00000000000..4da0d2ed559 --- /dev/null +++ b/3rdparty/asmjit/test/cmdline.h @@ -0,0 +1,61 @@ +// This file is part of AsmJit project <https://asmjit.com> +// +// See asmjit.h or LICENSE.md for license and copyright information +// SPDX-License-Identifier: Zlib + +#ifndef CMDLINE_H_INCLUDED +#define CMDLINE_H_INCLUDED + +#include <stdint.h> +#include <stdlib.h> +#include <string.h> + +class CmdLine { +public: + int _argc; + const char* const* _argv; + + CmdLine(int argc, const char* const* argv) + : _argc(argc), + _argv(argv) {} + + bool hasArg(const char* key) const { + for (int i = 1; i < _argc; i++) + if (strcmp(key, _argv[i]) == 0) + return true; + return false; + } + + const char* valueOf(const char* key, const char* defaultValue) const { + size_t keySize = strlen(key); + for (int i = 1; i < _argc; i++) { + const char* val = _argv[i]; + if (strlen(val) >= keySize + 1 && val[keySize] == '=' && memcmp(val, key, keySize) == 0) + return val + keySize + 1; + } + + return defaultValue; + } + + int valueAsInt(const char* key, int defaultValue) const { + const char* val = valueOf(key, nullptr); + if (val == nullptr || val[0] == '\0') + return defaultValue; + + return atoi(val); + } + + unsigned valueAsUInt(const char* key, unsigned defaultValue) const { + const char* val = valueOf(key, nullptr); + if (val == nullptr || val[0] == '\0') + return defaultValue; + + int v = atoi(val); + if (v < 0) + return defaultValue; + else + return unsigned(v); + } +}; + +#endif // CMDLINE_H_INCLUDED diff --git a/3rdparty/asmjit/test/performancetimer.h b/3rdparty/asmjit/test/performancetimer.h new file mode 100644 index 00000000000..baa0479fc34 --- /dev/null +++ b/3rdparty/asmjit/test/performancetimer.h @@ -0,0 +1,41 @@ +// This file is part of AsmJit project <https://asmjit.com> +// +// See asmjit.h or LICENSE.md for license and copyright information +// SPDX-License-Identifier: Zlib + +#ifndef PERFORMANCETIMER_H_INCLUDED +#define PERFORMANCETIMER_H_INCLUDED + +#include <asmjit/core.h> +#include <chrono> + +class PerformanceTimer { +public: + typedef std::chrono::high_resolution_clock::time_point TimePoint; + + TimePoint _startTime {}; + TimePoint _endTime {}; + + inline void start() { + _startTime = std::chrono::high_resolution_clock::now(); + } + + inline void stop() { + _endTime = std::chrono::high_resolution_clock::now(); + } + + inline double duration() const { + std::chrono::duration<double> elapsed = _endTime - _startTime; + return elapsed.count() * 1000; + } +}; + +static inline double mbps(double duration, uint64_t outputSize) noexcept { + if (duration == 0) + return 0.0; + + double bytesTotal = double(outputSize); + return (bytesTotal * 1000) / (duration * 1024 * 1024); +} + +#endif // PERFORMANCETIMER_H_INCLUDED |