diff --git a/onnxruntime/contrib_ops/cpu/quantization/matmul_nbits.cc b/onnxruntime/contrib_ops/cpu/quantization/matmul_nbits.cc
index 3fc640c6fb341..bca54a72fe8a7 100644
--- a/onnxruntime/contrib_ops/cpu/quantization/matmul_nbits.cc
+++ b/onnxruntime/contrib_ops/cpu/quantization/matmul_nbits.cc
@@ -51,10 +51,10 @@ class MatMulNBits final : public OpKernel {
   const size_t nbits_;
   const bool column_wise_quant_{true};
   IAllocatorUniquePtr<void> packed_b_;
-  size_t packed_b_size_;
-  bool is_asym_;
-  bool all_constant_;
-  int64_t accuracy_level_;
+  size_t packed_b_size_{0};
+  bool is_asym_{false};
+  bool all_constant_{false};
+  int64_t accuracy_level_{0};
 };
 
 Status MatMulNBits::PrePack(const Tensor& tensor, int input_idx, /*out*/ AllocatorPtr alloc,
@@ -65,57 +65,48 @@ Status MatMulNBits::PrePack(const Tensor& tensor, int input_idx, /*out*/ Allocat
     return Status::OK();
   }
   auto compt_type = static_cast<MLAS_COMPUTE_TYPE>(accuracy_level_);
-  if (MlasIsNBitGemmAvailable(N_, K_, block_size_, static_cast<int>(nbits_), is_asym_, compt_type)) {
-    // better to use threadpool here, LLM weight will consume a lot of time
-    MLAS_THREADPOOL* pool = NULL;
-    if (input_idx == 1) {
-      auto qptr = tensor.Data<uint8_t>();
-      packed_b_size_ = MlasNBitsGemmPackBSize(N_, K_, block_size_, static_cast<int>(nbits_), is_asym_, compt_type);
-      packed_b_ = IAllocator::MakeUniquePtr<void>(alloc, packed_b_size_, true);
-      if (packed_b_ == nullptr) {
-        return Status::OK();
-      }
-      MlasNBitsGemmPackB(packed_b_.get(), qptr, nullptr, nullptr, N_, K_, K_, block_size_, static_cast<int>(nbits_),
-                         is_asym_, false, compt_type, pool);
-      if (prepacked_weights) {
-        prepacked_weights->buffers_.push_back(std::move(packed_b_));
-        prepacked_weights->buffer_sizes_.push_back(packed_b_size_);
-      }
-      is_packed = true;
+  MLAS_THREADPOOL* pool = NULL;
+  if (input_idx == 1) {
+    packed_b_size_ = MlasNBitsGemmPackBSize(N_, K_, block_size_, static_cast<int>(nbits_), is_asym_, compt_type);
+    if (packed_b_size_ == 0) return Status::OK();
+    auto qptr = tensor.Data<uint8_t>();
+    packed_b_ = IAllocator::MakeUniquePtr<void>(alloc, packed_b_size_, true);
+    if (packed_b_ == nullptr) {
+      return Status::OK();
+    }
+    MlasNBitsGemmPackB(packed_b_.get(), qptr, nullptr, nullptr, N_, K_, K_, block_size_, static_cast<int>(nbits_),
+                       is_asym_, false, compt_type, pool);
+    if (prepacked_weights) {
+      prepacked_weights->buffers_.push_back(std::move(packed_b_));
+      prepacked_weights->buffer_sizes_.push_back(packed_b_size_);
     }
-    if (input_idx == 2) {
-      auto sptr = tensor.Data<float>();
-      if (packed_b_ == nullptr) {
-        return Status::OK();
-      }
-      MlasNBitsGemmPackB(packed_b_.get(), nullptr, sptr, nullptr, N_, K_, K_, block_size_, static_cast<int>(nbits_),
-                         is_asym_, !is_asym_, compt_type, pool);
-      if (prepacked_weights) {
-        prepacked_weights->buffers_.push_back(std::move(packed_b_));
-        prepacked_weights->buffer_sizes_.push_back(packed_b_size_);
-      }
-      is_packed = true;
+    is_packed = true;
+  }
+  if (input_idx == 2 && packed_b_ != nullptr) {
+    auto sptr = tensor.Data<float>();
+    MlasNBitsGemmPackB(packed_b_.get(), nullptr, sptr, nullptr, N_, K_, K_, block_size_, static_cast<int>(nbits_),
+                       is_asym_, !is_asym_, compt_type, pool);
+    if (prepacked_weights) {
+      prepacked_weights->buffers_.push_back(std::move(packed_b_));
+      prepacked_weights->buffer_sizes_.push_back(packed_b_size_);
     }
-    if (input_idx == 3) {
-      auto zptr = tensor.Data<uint8_t>();
-      if (packed_b_ == nullptr) {
-        return Status::OK();
-      }
-      MlasNBitsGemmPackB(packed_b_.get(), nullptr, nullptr, zptr, N_, K_, K_, block_size_, static_cast<int>(nbits_),
-                         is_asym_, is_asym_, compt_type, pool);
-      if (prepacked_weights) {
-        prepacked_weights->buffers_.push_back(std::move(packed_b_));
-        prepacked_weights->buffer_sizes_.push_back(packed_b_size_);
-      }
-      is_packed = true;
+    is_packed = true;
+  }
+  if (input_idx == 3 && packed_b_ != nullptr) {
+    auto zptr = tensor.Data<uint8_t>();
+    MlasNBitsGemmPackB(packed_b_.get(), nullptr, nullptr, zptr, N_, K_, K_, block_size_, static_cast<int>(nbits_),
+                       is_asym_, is_asym_, compt_type, pool);
+    if (prepacked_weights) {
+      prepacked_weights->buffers_.push_back(std::move(packed_b_));
+      prepacked_weights->buffer_sizes_.push_back(packed_b_size_);
     }
+    is_packed = true;
   }
 
   return Status::OK();
 }
 
-Status MatMulNBits::UseSharedPrePackedBuffers(std::vector<BufferUniquePtr>& prepacked_buffers,
-                                              int input_idx,
+Status MatMulNBits::UseSharedPrePackedBuffers(std::vector<BufferUniquePtr>& prepacked_buffers, int input_idx,
                                               /*out*/ bool& used_shared_buffers) {
   used_shared_buffers = false;
   // Pack three tensors into one buffer
@@ -149,8 +140,7 @@ Status MatMulNBits::Compute(OpKernelContext* ctx) const {
     Tensor* y = ctx->Output(0, helper.OutputShape());
 
     // Bail out early if the output is going to be empty
-    if (y->Shape().Size() == 0)
-      return Status::OK();
+    if (y->Shape().Size() == 0) return Status::OK();
 
     auto* y_data = y->MutableData<float>();
 
@@ -159,7 +149,7 @@ Status MatMulNBits::Compute(OpKernelContext* ctx) const {
     const size_t N = static_cast<size_t>(helper.N());
     const size_t K = static_cast<size_t>(helper.K());
     const size_t lda = helper.Lda(false);
-    std::vector<MLAS_NBITS_GEMM_DATA_SIMPLE_PARAMS> gemm_params(max_len);
+    std::vector<MLAS_NBITS_GEMM_DATA_PACKED_PARAMS> gemm_params(max_len);
     AllocatorPtr allocator;
     auto status = ctx->GetTempSpaceAllocator(&allocator);
     ORT_RETURN_IF_ERROR(status);
@@ -172,7 +162,7 @@ Status MatMulNBits::Compute(OpKernelContext* ctx) const {
       gemm_params[i].C = y_data + helper.OutputOffsets()[i];
       gemm_params[i].ldc = N;
     }
-    MlasNBitsGemmBatchPackedB(M, N, K, max_len, gemm_params.data(), (int8_t*)ws_ptr.get(), thread_pool);
+    MlasNBitsGemmBatchPackedB(M, N, K, max_len, gemm_params.data(), reinterpret_cast<int8_t*>(ws_ptr.get()), thread_pool);
     return Status::OK();
   }
 
diff --git a/onnxruntime/core/mlas/inc/mlas_q4.h b/onnxruntime/core/mlas/inc/mlas_q4.h
index c4fe1bb56c70c..316344ad8c214 100644
--- a/onnxruntime/core/mlas/inc/mlas_q4.h
+++ b/onnxruntime/core/mlas/inc/mlas_q4.h
@@ -357,4 +357,4 @@ MlasDequantizeBlockwise(
     int rows,
     int columns,
     MLAS_THREADPOOL* thread_pool
-    );
\ No newline at end of file
+    );
diff --git a/onnxruntime/core/mlas/inc/mlas_qnbit.h b/onnxruntime/core/mlas/inc/mlas_qnbit.h
index ca89d90cf8b15..f13bfda037633 100644
--- a/onnxruntime/core/mlas/inc/mlas_qnbit.h
+++ b/onnxruntime/core/mlas/inc/mlas_qnbit.h
@@ -90,35 +90,20 @@ typedef enum {
 } MLAS_COMPUTE_TYPE;
 
 /**
- * @brief Data parameters for Q4 GEMM routine
- *        C = A * B + Bias
- *        A must be a float32 matrix
- *        B must be a quantized and packed int4 blob
+ * @brief Data parameters for NBits GEMM routine
+ *        C = A * B
+ *        A, C must be a float32 matrix
+ *        B must be a packed nbits blob
  *        All except C are [in] parameters
  */
-struct MLAS_NBITS_GEMM_DATA_SIMPLE_PARAMS {
+struct MLAS_NBITS_GEMM_DATA_PACKED_PARAMS {
     const float* A = nullptr; /**< address of A (float32 matrix)*/
-    const void* B = nullptr;  /**< address of B (quantized and packed int4 blob)*/
+    const void* B = nullptr;  /**< address of B (packed nbits blob)*/
     float* C = nullptr;       /**< address of result matrix */
     size_t lda = 0;           /**< leading dimension of A */
     size_t ldc = 0;           /**< leading dimension of C*/
 };
 
-/**
- * @brief Check if the parameter combination is supported by the runtime device.
- *
- * @param N      the number of columns of matrix B.
- * @param K      the number of rows of matrix B.
- * @param block_size    size of the block to quantize, elements from the same block share the same
- * scale and zero point
- * @param nbits  number of bits used for weight quantization (default 4)
- * @param is_asym  flag for asymmetric quantization
- * @param comp_type  specify input data type and accumulator data type
- * @return support flag, true if the combination is supported.
- */
-bool MLASCALL
-MlasIsNBitGemmAvailable(size_t N, size_t K, size_t block_size, int nbits, bool is_asym, MLAS_COMPUTE_TYPE comp_type);
-
 /**
  * @brief Compute the byte size of the parameter combination
  *
@@ -204,7 +189,7 @@ MlasNBitsGemmBatchPackedB(
     const size_t N,
     const size_t K,
     const size_t BatchN,
-    const MLAS_NBITS_GEMM_DATA_SIMPLE_PARAMS* DataParams,
+    const MLAS_NBITS_GEMM_DATA_PACKED_PARAMS* DataParams,
     int8_t* WorkSpace,
     MLAS_THREADPOOL* ThreadPool = nullptr
-);
\ No newline at end of file
+);
diff --git a/onnxruntime/core/mlas/lib/jblas_defs.h b/onnxruntime/core/mlas/lib/jblas_defs.h
index 95d84dda61fa4..8f0dc38ec1d5b 100644
--- a/onnxruntime/core/mlas/lib/jblas_defs.h
+++ b/onnxruntime/core/mlas/lib/jblas_defs.h
@@ -11,8 +11,7 @@ Licensed under the MIT License.
 #include "jblas/jit_blas_prologue_b.h"
 #include "jblas/jit_blas_wrapper.h"
 
-namespace jblas
-{
+namespace jblas {
 template <class GemmCore_T>
 using tLauncher_Fp32_S4_F32F32 = jblas::wrapper::gemm::LauncherKBlock<
     GemmCore_T::ISA,
@@ -40,12 +39,12 @@ using tAMX_INT8_US = jblas::gemm::ICoreRowNAmxint8<64, 16>;
 using tAMX_INT8_SS = jblas::gemm::ICoreRowNAmxint8SS<64, 16>;
 using tAVX2 = jblas::gemm::SCoreRowNAvx2<48, 2>;
 
-class ORTThreading : public jblas::parallel::IThreading
-{
+class ORTThreading : public jblas::parallel::IThreading {
    public:
     ORTThreading(void* tp);
     void parallel_for(const jblas::parallel::thread_func& func) override;
     virtual void set_threads(int nthreads) override { assert(0); }
+    virtual void sync() override { assert(0); }
     void* mTp;
 };
 
diff --git a/onnxruntime/core/mlas/lib/jblas_gemm.cpp b/onnxruntime/core/mlas/lib/jblas_gemm.cpp
index 95d866c64b918..d6b906aa331b0 100644
--- a/onnxruntime/core/mlas/lib/jblas_gemm.cpp
+++ b/onnxruntime/core/mlas/lib/jblas_gemm.cpp
@@ -57,7 +57,7 @@ JblasQ4GemmCompF32(
             kernel.mProA.reduce({A, K}, &reduceA, M, K, &single);
         }
         typename Launcher::BEpiParam blkargs{
-            B->template SPtr<int8_t>(),    B->mScaT,   B->mCStep, B->template ZPtr<int8_t>(),
+            B->template SPtr<int8_t>(), B->mScaT, B->mCStep, B->template ZPtr<int8_t>(),
             reduceA.template get<float>(), reduceA.lda};
 
         typename Launcher::Param args{M, N, K, B->mBlockSize, {A, K}, {B}, blkargs, {C, N}};
@@ -121,7 +121,7 @@ JblasQ4GemmBatchDriver(
     const size_t N,
     const size_t K,
     const size_t BatchN,
-    const MLAS_NBITS_GEMM_DATA_SIMPLE_PARAMS* DataParams,
+    const MLAS_NBITS_GEMM_DATA_PACKED_PARAMS* DataParams,
     int8_t* WorkSpace,
     MLAS_THREADPOOL* ThreadPool
 )
@@ -222,6 +222,7 @@ size_t
 JblasQ4GemmPackBSize(size_t N, size_t K, size_t BlkSize, bool isAsym, MLAS_COMPUTE_TYPE CompType)
 {
     GetCPUDevice();
+    // from low precision to high precision
     switch (CompType) {
         case CompInt8:
             if (_cd->AMX_INT8() && BlkSize % tAMX_INT8_SS::KTILE == 0) {
@@ -233,7 +234,8 @@ JblasQ4GemmPackBSize(size_t N, size_t K, size_t BlkSize, bool isAsym, MLAS_COMPU
             if (_cd->AVX_VNNI() && BlkSize % tAVX_VNNI::KTILE == 0) {
                 return JblasQ4BuSize<tLauncher_Int8_S4_F32F32<tAVX_VNNI>>(int(BlkSize), N, K, isAsym);
             }
-            break;
+        case CompBf16:
+        case CompFp16:
         case CompFp32:
             if (_cd->AVX512F() && BlkSize % tAVX512F::KTILE == 0) {
                 return JblasQ4BuSize<tLauncher_Int8_S4_F32F32<tAVX512F>>(int(BlkSize), N, K, isAsym);
@@ -242,8 +244,6 @@ JblasQ4GemmPackBSize(size_t N, size_t K, size_t BlkSize, bool isAsym, MLAS_COMPU
                 return JblasQ4BuSize<tLauncher_Int8_S4_F32F32<tAVX2>>(int(BlkSize), N, K, isAsym);
             }
             break;
-        case CompBf16:
-        case CompFp16:
         default:
             return 0;
     }
@@ -315,7 +315,8 @@ JblasQ4GemmPackB(
                 );
                 return true;
             }
-            break;
+        case CompBf16:
+        case CompFp16:
         case CompFp32:
             if (_cd->AVX512F() && BlkSize % tAVX512F::KTILE == 0) {
                 JblaNBitsGemmPackB<tLauncher_Fp32_S4_F32F32<tAVX512F>>(
@@ -329,9 +330,6 @@ JblasQ4GemmPackB(
                 );
                 return true;
             }
-            break;
-        case CompBf16:
-        case CompFp16:
         default:
             return false;
     }
diff --git a/onnxruntime/core/mlas/lib/jblas_gemm.h b/onnxruntime/core/mlas/lib/jblas_gemm.h
index d84f815ee1c45..28c6dc729792c 100644
--- a/onnxruntime/core/mlas/lib/jblas_gemm.h
+++ b/onnxruntime/core/mlas/lib/jblas_gemm.h
@@ -45,7 +45,7 @@ JblasQ4GemmBatchDriver(
     const size_t N,
     const size_t K,
     const size_t BatchN,
-    const MLAS_NBITS_GEMM_DATA_SIMPLE_PARAMS* DataParams,
+    const MLAS_NBITS_GEMM_DATA_PACKED_PARAMS* DataParams,
     int8_t* WorkSpace,
     MLAS_THREADPOOL* ThreadPool
 );
\ No newline at end of file
diff --git a/onnxruntime/core/mlas/lib/q4_dq.cpp b/onnxruntime/core/mlas/lib/q4_dq.cpp
index aa560638decee..48d975a7fd26d 100644
--- a/onnxruntime/core/mlas/lib/q4_dq.cpp
+++ b/onnxruntime/core/mlas/lib/q4_dq.cpp
@@ -1059,4 +1059,4 @@ MlasDequantizeBlockwise<float, 4>(
     int rows,
     int columns,
     MLAS_THREADPOOL* thread_pool
-    );
\ No newline at end of file
+    );
diff --git a/onnxruntime/core/mlas/lib/q4gemm.cpp b/onnxruntime/core/mlas/lib/q4gemm.cpp
index 289c8d0f3d985..a734f53432bb6 100644
--- a/onnxruntime/core/mlas/lib/q4gemm.cpp
+++ b/onnxruntime/core/mlas/lib/q4gemm.cpp
@@ -176,4 +176,4 @@ MlasQ8Q4GemmBatch(
     )
 {
     MlasQ4GemmBatchDriver(QType, M, N, K, BatchN, DataParams, ThreadPool);
-}
\ No newline at end of file
+}
diff --git a/onnxruntime/core/mlas/lib/sqnbitgemm.cpp b/onnxruntime/core/mlas/lib/sqnbitgemm.cpp
index ad66013649c6b..03d20b426ec43 100644
--- a/onnxruntime/core/mlas/lib/sqnbitgemm.cpp
+++ b/onnxruntime/core/mlas/lib/sqnbitgemm.cpp
@@ -166,12 +166,6 @@ MlasNBitsGemmPackBSize(size_t N, size_t K, size_t BlkSize, int nbits, bool isAsy
     return 0;
 }
 
-bool MLASCALL
-MlasIsNBitGemmAvailable(size_t N, size_t K, size_t BlkSize, int nbits, bool isAsym, MLAS_COMPUTE_TYPE CompType)
-{
-    return MlasNBitsGemmPackBSize(N, K, BlkSize, nbits, isAsym, CompType) > 0;
-}
-
 void MLASCALL
 MlasNBitsGemmPackB(
     void* PackedBuf,
@@ -233,7 +227,7 @@ MlasNBitsGemmBatchPackedB(
     const size_t N,
     const size_t K,
     const size_t BatchN,
-    const MLAS_NBITS_GEMM_DATA_SIMPLE_PARAMS* DataParams,
+    const MLAS_NBITS_GEMM_DATA_PACKED_PARAMS* DataParams,
     int8_t* WorkSpace,
     MLAS_THREADPOOL* ThreadPool
 )
diff --git a/onnxruntime/core/mlas/lib/x86_64/jblas/jblas/jit_base.h b/onnxruntime/core/mlas/lib/x86_64/jblas/jblas/jit_base.h
index c2f08a0fc9770..143adb771760b 100644
--- a/onnxruntime/core/mlas/lib/x86_64/jblas/jblas/jit_base.h
+++ b/onnxruntime/core/mlas/lib/x86_64/jblas/jblas/jit_base.h
@@ -73,9 +73,9 @@ class JitBase : protected Xbyak::CodeGenerator {
     jb(".maskflag");
     cmp(_tmp, 0);
     jl(".zeroflag");
-    uint64_t allmask = ((uint64_t)1 << N) - 1;
+    uint64_t allmask = (static_cast<uint64_t>(1) << N) - 1;
     if (N == 64) {
-      allmask = (uint64_t)-1;
+      allmask = static_cast<uint64_t>(-1);
     }
     mov(_tmp, allmask);
     kmovq(_msk, _tmp);
@@ -256,19 +256,19 @@ class JitAmxtile : protected JitAvx512f {
     // Configure C tiles
     int t = 0;
     for (; t < CNum; ++t) {
-      tc.rows[t] = uint8_t(TILE_M);
-      tc.colb[t] = uint16_t(TILE_N * 4);
+      tc.rows[t] = static_cast<uint8_t>(TILE_M);
+      tc.colb[t] = static_cast<uint16_t>(TILE_N * 4);
     }
     // Configure A tiles
     for (; t < CNum + ANum; ++t) {
-      tc.rows[t] = uint8_t(TILE_M);
-      tc.colb[t] = uint16_t(TILE_K * elesize);
+      tc.rows[t] = static_cast<uint8_t>(TILE_M);
+      tc.colb[t] = static_cast<uint16_t>(TILE_K * elesize);
     }
     // Configure B tile. B effectively has 64 rows and 16 columns.
     int kpack = 4 / elesize;
     for (; t < CNum + ANum + BNum; ++t) {
-      tc.rows[t] = uint8_t(TILE_K / kpack);
-      tc.colb[t] = uint16_t(TILE_N * 4);
+      tc.rows[t] = static_cast<uint8_t>(TILE_K / kpack);
+      tc.colb[t] = static_cast<uint16_t>(TILE_N * 4);
     }
   }
 };
diff --git a/onnxruntime/core/mlas/lib/x86_64/jblas/jblas/jit_blas.h b/onnxruntime/core/mlas/lib/x86_64/jblas/jblas/jit_blas.h
index 2ecb6630d3da0..8ecf3535c17f4 100644
--- a/onnxruntime/core/mlas/lib/x86_64/jblas/jblas/jit_blas.h
+++ b/onnxruntime/core/mlas/lib/x86_64/jblas/jblas/jit_blas.h
@@ -93,4 +93,4 @@ enum class JBLAS_PROLOGUEB_IDS : uint32_t {
   WeightKBlockF4,
   KBlockEnd,
   End,
-};
\ No newline at end of file
+};
diff --git a/onnxruntime/core/mlas/lib/x86_64/jblas/jblas/jit_blas_device.h b/onnxruntime/core/mlas/lib/x86_64/jblas/jblas/jit_blas_device.h
index bf3f45db18f62..5cac1080bc610 100644
--- a/onnxruntime/core/mlas/lib/x86_64/jblas/jblas/jit_blas_device.h
+++ b/onnxruntime/core/mlas/lib/x86_64/jblas/jblas/jit_blas_device.h
@@ -274,5 +274,4 @@ class CpuBase {
   int mNumThreads;
 };
 }  // namespace device
-
 }  // namespace jblas
diff --git a/onnxruntime/core/mlas/lib/x86_64/jblas/jblas/jit_blas_epilogue.h b/onnxruntime/core/mlas/lib/x86_64/jblas/jblas/jit_blas_epilogue.h
index 1cab348459a0c..ca82c9308a936 100644
--- a/onnxruntime/core/mlas/lib/x86_64/jblas/jblas/jit_blas_epilogue.h
+++ b/onnxruntime/core/mlas/lib/x86_64/jblas/jblas/jit_blas_epilogue.h
@@ -43,10 +43,10 @@ class AccumulatorWriteBack {
     static_assert(Valid, "fp32 to bf16 conversion only.");
     if constexpr (std::is_same<DType, utils::bf16>::value) {
       return kernel::wrapper::Memcpy2DFp32CvtBf16::template forward<ISA_T>(
-          (void*)cacheptr, (void*)cptr, M, N, cachestep * sizeof(SType), _param.ldc * sizeof(DType), false);
+          const_cast<_SRC_T*>(cacheptr), cptr, M, N, cachestep * sizeof(SType), _param.ldc * sizeof(DType), false);
     } else if constexpr (std::is_same<std::tuple<SType, DType>, std::tuple<utils::fp16, float>>::value) {
       return kernel::wrapper::Memcpy2DFp16CvtFp32::template forward<ISA_T>(
-          (void*)cacheptr, (void*)cptr, M, N, cachestep * sizeof(SType), _param.ldc * sizeof(DType), false);
+          const_cast<_SRC_T*>(cacheptr), cptr, M, N, cachestep * sizeof(SType), _param.ldc * sizeof(DType), false);
     } else if constexpr (sizeof(SType) == sizeof(DType)) {
       return kernel::wrapper::Memcpy2D::template forward<ISA_T, SType, DType>(cacheptr, cptr, M, N, cachestep,
                                                                               _param.ldc, _param.elt_const_v, ops...);
@@ -132,19 +132,21 @@ class CompFp32BlockEpilogue {
     auto ret = JblasNotSupport;
     if (_param.scaledtype == JBLAS_DTYPE::F32) {
       ret = kernel::wrapper::CompFp32BlockScale::template forward<ISA_T>(
-          (float*)_param.scales + K_offset * _param.ldsb + N_offset, srcptr, cachestep, dstptr, cachestep, M, N);
+          reinterpret_cast<float*>(_param.scales) + K_offset * _param.ldsb + N_offset, srcptr, cachestep, dstptr,
+          cachestep, M, N);
       assert(ret == JblasSuccess);
       if (_param.zps != nullptr) {
         ret = kernel::wrapper::RemoveZeroPointBias::forward_wei<ISA_T>(
             dstptr, cachestep, M, N, _param.zps + K_offset * _param.ldsb + N_offset,
-            (float*)_param.scales + K_offset * _param.ldsb + N_offset, _param.ldra,
+            reinterpret_cast<float*>(_param.scales) + K_offset * _param.ldsb + N_offset, _param.ldra,
             _param.reduce + M_offset * _param.ldra + K_offset);
       }
       assert(ret == JblasSuccess);
       return ret;
     } else if (_param.scaledtype == JBLAS_DTYPE::BF16) {
       ret = kernel::wrapper::CompFp32BlockScale::template forward<ISA_T>(
-          (utils::bf16*)_param.scales + K_offset * _param.ldsb + N_offset, srcptr, cachestep, dstptr, cachestep, M, N);
+          reinterpret_cast<utils::bf16*>(_param.scales) + K_offset * _param.ldsb + N_offset, srcptr, cachestep, dstptr,
+          cachestep, M, N);
       if (_param.zps != nullptr) {
         assert(0);
       }
@@ -202,31 +204,34 @@ class CompInt8BlockEpilogue {
     size_t ReduceBTmpSize = N * sizeof(float);
     assert(cachesize >= (ScaleBTmpSize + ReduceBTmpSize));
     if (_param.scaleBdtype == JBLAS_DTYPE::BF16) {
-      auto scache = (float*)tmpcache;
+      auto scache = reinterpret_cast<float*>(tmpcache);
       ret = kernel::wrapper::Memcpy2DBf16CvtFp32::template forward<ISA_T>(
-          (utils::bf16*)_param.scalesB + N_offset + K_offset * _param.ldsb, scache, 1, N, N, N, false);
+          reinterpret_cast<utils::bf16*>(_param.scalesB) + N_offset + K_offset * _param.ldsb, scache, 1, N, N, N,
+          false);
       assert(ret == JblasSuccess);
       scab = scache;
     } else if (_param.scaleBdtype == JBLAS_DTYPE::F32) {
-      scab = (float*)_param.scalesB + N_offset + K_offset * _param.ldsb;
+      scab = reinterpret_cast<float*>(_param.scalesB) + N_offset + K_offset * _param.ldsb;
     }
     float* redb = nullptr;
     if (_param.reduceB) {
       if (_param.reduceBdtype == JBLAS_DTYPE::BF16) {
-        auto rcache = (float*)((char*)tmpcache + ScaleBTmpSize);
+        auto rcache = reinterpret_cast<float*>(reinterpret_cast<char*>(tmpcache) + ScaleBTmpSize);
         ret = kernel::wrapper::Memcpy2DBf16CvtFp32::template forward<ISA_T>(
-            (utils::bf16*)_param.reduceB + N_offset + K_offset * _param.ldsb, rcache, 1, N, N, N, false);
+            reinterpret_cast<utils::bf16*>(_param.reduceB) + N_offset + K_offset * _param.ldsb, rcache, 1, N, N, N,
+            false);
         assert(ret == JblasSuccess);
         redb = rcache;
       } else if (_param.reduceBdtype == JBLAS_DTYPE::F32) {
-        redb = (float*)_param.reduceB + N_offset + K_offset * _param.ldsb;
+        redb = reinterpret_cast<float*>(_param.reduceB) + N_offset + K_offset * _param.ldsb;
       }
     }
-    ret = kernel::wrapper::DequanS32Fp32::template forward<ISA_T>(srcptr, cachestep, (float*)srcptr, cachestep, M, N,
-                                                                  _param.scalesA + M_offset * _param.ldsa + K_offset,
-                                                                  _param.ldsa, scab);
+    ret = kernel::wrapper::DequanS32Fp32::template forward<ISA_T>(
+        srcptr, cachestep, reinterpret_cast<float*>(const_cast<int32_t*>(srcptr)), cachestep, M, N,
+        _param.scalesA + M_offset * _param.ldsa + K_offset, _param.ldsa, scab);
     assert(ret == JblasSuccess);
-    ret = kernel::wrapper::AccumulateFp32::template forward<ISA_T>((float*)srcptr, cachestep, dstptr, cachestep, M, N);
+    ret = kernel::wrapper::AccumulateFp32::template forward<ISA_T>(reinterpret_cast<const float*>(srcptr), cachestep,
+                                                                   dstptr, cachestep, M, N);
     assert(ret == JblasSuccess);
 
     if (_param.zpA == nullptr) {
diff --git a/onnxruntime/core/mlas/lib/x86_64/jblas/jblas/jit_blas_gemm.h b/onnxruntime/core/mlas/lib/x86_64/jblas/jblas/jit_blas_gemm.h
index e024dcd45643e..364da9223940f 100644
--- a/onnxruntime/core/mlas/lib/x86_64/jblas/jblas/jit_blas_gemm.h
+++ b/onnxruntime/core/mlas/lib/x86_64/jblas/jblas/jit_blas_gemm.h
@@ -1946,6 +1946,518 @@ class AmxConfigure : protected jblas::xbyak::JitAmxtile {
   func_t mKernel = nullptr;
 };
 
+namespace kblock {
+// optimize for kblock gemm, each block size in k dimension has dequant operation
+// all accumulators use fp32 dtype.
+template <int _NTILE, int _MTILE = 0>
+class Avx512fN16P1 : protected jblas::xbyak::JitAvx512f {
+ public:
+  static int constexpr RegLen = 16, PackRow = 1;
+  static_assert(_NTILE % RegLen == 0);
+  static int constexpr NRegs = _NTILE / RegLen;
+  static int constexpr MRegs = _MTILE == 0 ? (RegCount - 1) / NRegs : _MTILE;
+  static_assert(NRegs * MRegs <= RegCount - 1);
+  static int constexpr NTILE = RegLen * NRegs, MTILE = MRegs, KTILE = 1;
+  static int constexpr KUNROLL = 2;
+  static uint32_t constexpr ISA = (uint32_t)JBLAS_ISA::JblasAVX512F;
+  static uint32_t constexpr COMPUTE = (uint32_t)CompType::COMP_FP32;
+  typedef float AType;
+  typedef float BType;
+  typedef float CType;
+
+  struct params {
+    AType* matA;
+    int astride;
+    BType* matB;
+    int bstride;
+    CType* matC;
+    int cstride;
+    int k;
+    int n;
+    int init;
+  };
+  typedef long long (*func_t)(params*);
+
+  int CRegCount = 0, BRegCount = 0, ARegCount = 0, TmpRegCount = 0;
+  int CReg = 0, BReg = 0, AReg = 0, TmpReg = 0;
+  static int constexpr BKStepSize = KTILE * NTILE * sizeof(BType);
+  static int constexpr AKStepSize = KTILE * sizeof(AType);
+
+  void generate_code(int _mtile) {
+    assign_regs();
+    reset();
+    generate_mtile(_mtile);
+    ready();
+    mKernel = getCode<func_t>();
+  }
+  func_t mKernel = nullptr;
+
+ protected:
+  Xbyak::Reg64 parambase;
+  Xbyak::Reg64 reg_matAptr;
+  Xbyak::Reg64 reg_matBptr;
+  Xbyak::Reg64 reg_matCptr;
+  Xbyak::Reg64 reg_ksize;
+  Xbyak::Reg64 reg_nsize;
+  Xbyak::Reg64 reg_cstride;
+  Xbyak::Reg64 reg_astride;
+  Xbyak::Reg64 reg_iterk;
+  Xbyak::Reg64 reg_itern;
+  Xbyak::Reg64 reg_tmp;
+  Xbyak::Reg64 reg_tmp1;
+  Xbyak::Reg64 reg_tmp2;
+  Xbyak::Reg64 reg_ret = rax;
+  Xbyak::Opmask msk_wr = k1;
+
+  void assign_regs() {
+    CRegCount = MRegs * NRegs;
+    ARegCount = 1;
+    BRegCount = RegCount - ARegCount - CRegCount;
+    if (BRegCount < NRegs) {
+      BRegCount = 0;
+      ARegCount = BRegCount + 1;
+    }
+    if (BRegCount > NRegs) {
+      BRegCount = NRegs;
+    }
+    CReg = 0;
+    BReg = CReg + CRegCount;
+    AReg = BReg + BRegCount;
+    TmpReg = AReg + ARegCount;
+    assert(TmpReg <= RegCount);
+    TmpRegCount = RegCount - TmpReg;
+  }
+
+  void generate_mtile(int _mtile) {
+    inLocalLabel();  // use local label for multiple instance
+    Xbyak::util::StackFrame st(this, 1, 10, 16 * 10);
+    parambase = st.p[0];
+    reg_matAptr = st.t[0];
+    reg_matBptr = st.t[1];
+    reg_matCptr = st.t[0];
+    reg_ksize = st.t[2];
+    reg_astride = st.t[3];
+    reg_cstride = st.t[3];
+    reg_iterk = st.t[4];
+    reg_tmp = st.t[5];
+    reg_tmp1 = st.t[6];
+    reg_tmp2 = st.t[7];
+    reg_nsize = st.t[8];
+    reg_itern = st.t[9];
+    reg_ret = rax;
+
+    vreg_push(rsp);
+
+    load32(reg_ksize, ptr[parambase + OFFSET(k)]);
+    load32(reg_nsize, ptr[parambase + OFFSET(n)]);
+    xor_(reg_itern, reg_itern);
+    L(".nloop");
+    init_regs(_mtile);
+    mov(reg_matAptr, ptr[parambase + OFFSET(matA)]);
+    load32(reg_astride, ptr[parambase + OFFSET(astride)]);
+    mov(reg_matBptr, ptr[parambase + OFFSET(matB)]);
+    load32(reg_tmp, ptr[parambase + OFFSET(bstride)]);
+    imul(reg_tmp, reg_itern);
+    lea(reg_matBptr, ptr[reg_matBptr + reg_tmp]);
+    xor_(reg_iterk, reg_iterk);
+    generate_kloop(_mtile);
+    write_back(_mtile);
+    add(reg_itern, NTILE);
+    cmp(reg_itern, reg_nsize);
+    jb(".nloop");
+    mov(reg_ret, 0);
+    vreg_pop(rsp);
+
+    outLocalLabel();  // end of local label
+  }
+
+  void generate_kloop(int _mtile) {
+    inLocalLabel();
+    mov(reg_tmp, reg_ksize);
+    padto_le(reg_tmp, KUNROLL * KTILE);
+    cmp(reg_tmp, 0);
+    jz(".kloop", T_NEAR);
+    L(".unkloop");
+    generate_fma(_mtile, KUNROLL);
+    add(reg_matAptr, KUNROLL * AKStepSize);
+    add(reg_matBptr, KUNROLL * BKStepSize);
+    add(reg_iterk, KUNROLL * KTILE);
+    cmp(reg_iterk, reg_tmp);  // k iteration variable
+    jb(".unkloop");
+    cmp(reg_tmp, reg_ksize);
+    jge(".kend", T_NEAR);
+    L(".kloop");
+    generate_fma(_mtile, 1);
+    add(reg_matAptr, 1 * AKStepSize);
+    add(reg_matBptr, 1 * BKStepSize);
+    add(reg_iterk, 1 * KTILE);
+    cmp(reg_iterk, reg_ksize);  // k iteration variable
+    jb(".kloop");
+    L(".kend");
+    outLocalLabel();
+  }
+
+  void generate_fma(int _mtile, int _ktile) {
+    for (int kk = 0; kk < _ktile; kk++) {
+      lea(reg_tmp1, ptr[reg_matAptr + kk * AKStepSize]);
+      if (BRegCount == NRegs) {
+        for (int i = 0; i < NRegs; i++) {
+          vmovups(vreg_t(BReg + i), ptr[reg_matBptr + kk * BKStepSize + i * VecBytes]);
+        }
+        for (int mm = 0; mm < _mtile; mm++) {
+          vbroadcastss(vreg_t(AReg), ptr[reg_tmp1]);
+          add(reg_tmp1, reg_astride);
+          for (int i = 0; i < NRegs; i++) {
+            vfmadd231ps(vreg_t(CReg + mm * NRegs + i), vreg_t(AReg), vreg_t(BReg + i));
+          }
+        }
+      } else if (BRegCount == 0) {
+        for (int mm = 0; mm < _mtile; mm += ARegCount) {
+          int mm_re = utils::remainsize(mm, _mtile, ARegCount);
+          for (int imm = 0; imm < mm_re; imm++) {
+            vbroadcastss(vreg_t(AReg + imm), ptr[reg_tmp1]);
+            add(reg_tmp1, reg_astride);
+            for (int i = 0; i < NRegs; i++) {
+              vfmadd231ps(vreg_t(CReg + mm * NRegs + i), vreg_t(AReg + imm),
+                          ptr[reg_matBptr + kk * BKStepSize + i * VecBytes]);
+            }
+          }
+        }
+      } else {
+        assert(0);
+      }
+    }
+  }
+
+  void init_regs(int _mtile) {
+    inLocalLabel();
+    load32(reg_tmp, ptr[parambase + OFFSET(init)]);
+    cmp(reg_tmp, 0);
+    je(".read", T_NEAR);
+    for (int i = 0; i < _mtile; i++) {
+      for (int j = 0; j < NRegs; j++) {
+        vxor(vreg_t(CReg + i * NRegs + j), vreg_t(CReg + i * NRegs + j), vreg_t(CReg + i * NRegs + j));
+      }
+    }
+    jmp(".end", T_NEAR);
+    L(".read");
+    mov(reg_matCptr, ptr[parambase + OFFSET(matC)]);
+    lea(reg_matCptr, ptr[reg_matCptr + reg_itern * sizeof(CType)]);
+    load32(reg_cstride, ptr[parambase + OFFSET(cstride)]);
+    for (int i = 0; i < _mtile; i++) {
+      for (int j = 0; j < NRegs; j++) {
+        vmovups(vreg_t(CReg + i * NRegs + j), ptr[reg_matCptr + j * VecBytes]);
+      }
+      add(reg_matCptr, reg_cstride);
+    }
+    L(".end");
+    outLocalLabel();
+  }
+
+  void write_back(int _mtile) {
+    inLocalLabel();
+    mov(reg_matCptr, ptr[parambase + OFFSET(matC)]);
+    load32(reg_cstride, ptr[parambase + OFFSET(cstride)]);
+    lea(reg_matCptr, ptr[reg_matCptr + reg_itern * sizeof(CType)]);
+    for (int i = 0; i < _mtile; i++) {
+      for (int j = 0; j < NRegs; j++) {
+        vmovups(ptr[reg_matCptr + j * VecBytes], vreg_t(CReg + i * NRegs + j));
+      }
+      add(reg_matCptr, reg_cstride);
+    }
+    outLocalLabel();
+  }
+};
+
+template <int _NTILE, int _MTILE = 0>
+class Avx512vnniN16P4 : protected jblas::xbyak::JitAvx512vnni {
+ public:
+  static int constexpr RegLen = 16, PackRow = 4;
+  static_assert(_NTILE % RegLen == 0);
+  static int constexpr NRegs = _NTILE / RegLen;
+  static int constexpr MRegs = _MTILE == 0 ? (RegCount - 1 - NRegs) / (NRegs * 2) : _MTILE;
+  static_assert(NRegs * MRegs <= RegCount - 1);
+  static int constexpr NTILE = RegLen * NRegs, MTILE = MRegs, KTILE = 4;
+  static int constexpr KUNROLL = 2;
+  static uint32_t constexpr ISA = (uint32_t)JBLAS_ISA::JblasAVX512_VNNI;
+  static uint32_t constexpr COMPUTE = (uint32_t)CompType::COMP_INT8_US_FP32;
+  typedef uint8_t AType;
+  typedef int8_t BType;
+  typedef float CType;
+
+  struct params {
+    AType* matA;
+    int astride;
+    BType* matB;
+    int bstride;
+    CType* matC;
+    int cstride;
+    uint8_t* zpA;
+    float* scaleA;
+    int ldsa;
+    float* scaleB;
+    float* reduceB;
+    int ldsb;
+    int k;
+    int n;
+    int kblock;
+    int init;
+  };
+  typedef long long (*func_t)(params*);
+
+  int CRegCount = 0, BRegCount = 0, ARegCount = 0, TmpRegCount = 0;
+  int CReg = 0, CF32Reg = 0, BReg = 0, AReg = 0, TmpReg = 0;
+  static int constexpr BKStepSize = KTILE * NTILE * sizeof(BType);
+  static int constexpr AKStepSize = KTILE * sizeof(AType);
+
+  void generate_code(int _mtile) {
+    assign_regs();
+    reset();
+    generate_mtile(_mtile);
+    ready();
+    mKernel = getCode<func_t>();
+  }
+  func_t mKernel = nullptr;
+
+ protected:
+  Xbyak::Reg64 parambase;
+  Xbyak::Reg64 reg_matAptr;
+  Xbyak::Reg64 reg_matBptr;
+  Xbyak::Reg64 reg_matCptr;
+  Xbyak::Reg64 reg_ksize;
+  Xbyak::Reg64 reg_nsize;
+  Xbyak::Reg64 reg_cstride;
+  Xbyak::Reg64 reg_astride;
+  Xbyak::Reg64 reg_iterk;
+  Xbyak::Reg64 reg_iterkb;
+  Xbyak::Reg64 reg_itern;
+  Xbyak::Reg64 reg_tmp;
+  Xbyak::Reg64 reg_tmp1;
+  Xbyak::Reg64 reg_tmp2;
+  Xbyak::Reg64 reg_tmp3;
+  Xbyak::Reg64 reg_tmp4;
+  Xbyak::Reg64 reg_ret = rax;
+
+  void assign_regs() {
+    CRegCount = MRegs * NRegs;
+    ARegCount = 1;
+    BRegCount = NRegs;
+    CReg = 0;
+    CF32Reg = CReg + CRegCount;
+    BReg = CF32Reg + CRegCount;
+    AReg = BReg + BRegCount;
+    TmpReg = AReg + ARegCount;
+    assert(TmpReg < RegCount);
+    TmpRegCount = RegCount - TmpReg;
+    assert(TmpRegCount >= 1);
+  }
+
+  void generate_mtile(int _mtile) {
+    inLocalLabel();  // use local label for multiple instance
+    Xbyak::util::StackFrame st(this, 1, 13, 16 * 10);
+    parambase = st.p[0];
+    reg_matAptr = st.t[0];
+    reg_matBptr = st.t[1];
+    reg_matCptr = st.t[0];
+    reg_ksize = st.t[2];
+    reg_astride = st.t[3];
+    reg_cstride = st.t[3];
+    reg_iterk = st.t[4];
+    reg_iterkb = st.t[12];
+    reg_tmp = st.t[5];
+    reg_tmp1 = st.t[6];
+    reg_tmp2 = st.t[7];
+    reg_tmp3 = st.t[10];
+    reg_tmp4 = st.t[11];
+    reg_nsize = st.t[8];
+    reg_itern = st.t[9];
+    reg_ret = rax;
+
+    vreg_push(rsp);
+
+    load32(reg_ksize, ptr[parambase + OFFSET(k)]);
+    load32(reg_nsize, ptr[parambase + OFFSET(n)]);
+    xor_(reg_itern, reg_itern);
+    L(".nloop");
+    init_regs(_mtile);
+    mov(reg_matAptr, ptr[parambase + OFFSET(matA)]);
+    load32(reg_astride, ptr[parambase + OFFSET(astride)]);
+    mov(reg_matBptr, ptr[parambase + OFFSET(matB)]);
+    load32(reg_tmp, ptr[parambase + OFFSET(bstride)]);
+    imul(reg_tmp, reg_itern);
+    lea(reg_matBptr, ptr[reg_matBptr + reg_tmp]);
+    xor_(reg_iterk, reg_iterk);
+    generate_kloop(_mtile);
+    write_back(_mtile);
+    add(reg_itern, NTILE);
+    cmp(reg_itern, reg_nsize);
+    jb(".nloop");
+    mov(reg_ret, 0);
+    vreg_pop(rsp);
+
+    outLocalLabel();  // end of local label
+  }
+
+  void generate_kloop(int _mtile) {
+    inLocalLabel();
+    xor_(reg_iterkb, reg_iterkb);
+    L(".kloop");
+    for (int i = 0; i < _mtile; i++) {
+      for (int j = 0; j < NRegs; j++) {
+        vpxorq(Xbyak::Zmm(CReg + i * NRegs + j), Xbyak::Zmm(CReg + i * NRegs + j), Xbyak::Zmm(CReg + i * NRegs + j));
+      }
+    }
+    xor_(reg_tmp2, reg_tmp2);
+    load32(reg_tmp3, ptr[parambase + OFFSET(kblock)]);
+    mov(reg_tmp, reg_tmp3);
+    padto_le(reg_tmp, KUNROLL * KTILE);
+    cmp(reg_tmp, 0);
+    jz(".kbloop", T_NEAR);
+    L(".unkbloop");
+    generate_fma(_mtile, KUNROLL, reg_tmp1);
+    add(reg_matAptr, KUNROLL * AKStepSize);
+    add(reg_matBptr, KUNROLL * BKStepSize);
+    add(reg_tmp2, KUNROLL * KTILE);
+    cmp(reg_tmp2, reg_tmp);
+    jb(".unkbloop");
+    cmp(reg_tmp, reg_tmp3);
+    jge(".kend", T_NEAR);
+    L(".kbloop");
+    generate_fma(_mtile, 1, reg_tmp1);
+    add(reg_matAptr, 1 * AKStepSize);
+    add(reg_matBptr, 1 * BKStepSize);
+    add(reg_tmp2, 1 * KTILE);
+    cmp(reg_tmp2, reg_tmp3);
+    jb(".kbloop");
+    L(".kend");
+    add(reg_iterk, reg_tmp2);
+    generate_f32_accumulate(_mtile);
+    generate_zp_correction(_mtile);
+    inc(reg_iterkb);
+    cmp(reg_iterk, reg_ksize);  // k iteration variable
+    jb(".kloop");
+
+    outLocalLabel();
+  }
+
+  void generate_fma(int _mtile, int _ktile, Xbyak::Reg64& tmp) {
+    for (int kk = 0; kk < _ktile; kk++) {
+      lea(tmp, ptr[reg_matAptr + kk * AKStepSize]);
+      for (int i = 0; i < NRegs; i++) {
+        vmovups(vreg_t(BReg + i), ptr[reg_matBptr + kk * BKStepSize + i * VecBytes]);
+      }
+      for (int mm = 0; mm < _mtile; mm++) {
+        vpbroadcastd(vreg_t(AReg), ptr[reg_tmp1]);
+        add(reg_tmp1, reg_astride);
+        for (int i = 0; i < NRegs; i++) {
+          vpdpbusds_(vreg_t(CReg + mm * NRegs + i), vreg_t(AReg), vreg_t(BReg + i));
+        }
+      }
+    }
+  }
+
+  void init_regs(int _mtile) {
+    inLocalLabel();
+    load32(reg_tmp, ptr[parambase + OFFSET(init)]);
+    cmp(reg_tmp, 0);
+    je(".read", T_NEAR);
+    for (int i = 0; i < _mtile; i++) {
+      for (int j = 0; j < NRegs; j++) {
+        vxor(vreg_t(CF32Reg + i * NRegs + j), vreg_t(CF32Reg + i * NRegs + j), vreg_t(CF32Reg + i * NRegs + j));
+      }
+    }
+    jmp(".end", T_NEAR);
+    L(".read");
+    mov(reg_matCptr, ptr[parambase + OFFSET(matC)]);
+    lea(reg_matCptr, ptr[reg_matCptr + reg_itern * sizeof(CType)]);
+    load32(reg_cstride, ptr[parambase + OFFSET(cstride)]);
+    for (int i = 0; i < _mtile; i++) {
+      for (int j = 0; j < NRegs; j++) {
+        vmovups(vreg_t(CF32Reg + i * NRegs + j), ptr[reg_matCptr + j * VecBytes]);
+      }
+      add(reg_matCptr, reg_cstride);
+    }
+    L(".end");
+    outLocalLabel();
+  }
+
+  void generate_f32_accumulate(int _mtile) {
+    load32(reg_tmp, ptr[parambase + OFFSET(ldsb)]);
+    imul(reg_tmp, reg_iterkb);
+    mov(reg_tmp2, ptr[parambase + OFFSET(scaleB)]);
+    lea(reg_tmp2, ptr[reg_tmp2 + reg_tmp * sizeof(float)]);
+    lea(reg_tmp2, ptr[reg_tmp2 + reg_itern * sizeof(float)]);
+
+    mov(reg_tmp, ptr[parambase + OFFSET(scaleA)]);
+    lea(reg_tmp, ptr[reg_tmp + reg_iterkb * sizeof(float)]);
+    load32(reg_tmp1, ptr[parambase + OFFSET(ldsa)]);
+    for (int i = 0; i < NRegs; i++) {
+      vmovups(Xbyak::Zmm(BReg + i), ptr[reg_tmp2 + i * VecBytes]);
+    }
+    for (int mm = 0; mm < _mtile; mm++) {
+      vbroadcastss(Xbyak::Zmm(TmpReg), ptr[reg_tmp]);
+      lea(reg_tmp, ptr[reg_tmp + reg_tmp1 * sizeof(float)]);
+      for (int i = 0; i < NRegs; i++) {
+        vcvtdq2ps(Xbyak::Zmm(CReg + mm * NRegs + i), Xbyak::Zmm(CReg + mm * NRegs + i));
+        vmulps(Xbyak::Zmm(AReg), Xbyak::Zmm(TmpReg), Xbyak::Zmm(BReg + i));
+        vmulps(Xbyak::Zmm(CReg + mm * NRegs + i), Xbyak::Zmm(AReg));
+        vaddps(Xbyak::Zmm(CF32Reg + mm * NRegs + i), Xbyak::Zmm(CReg + mm * NRegs + i));
+      }
+    }
+  }
+
+  void generate_zp_correction(int _mtile) {
+    load32(reg_tmp1, ptr[parambase + OFFSET(ldsb)]);
+    imul(reg_tmp1, reg_iterkb);
+    mov(reg_tmp2, ptr[parambase + OFFSET(reduceB)]);
+    lea(reg_tmp2, ptr[reg_tmp2 + reg_tmp1 * sizeof(float)]);
+    lea(reg_tmp2, ptr[reg_tmp2 + reg_itern * sizeof(float)]);
+    auto& reg_redB = reg_tmp2;
+
+    mov(reg_tmp, ptr[parambase + OFFSET(zpA)]);
+    lea(reg_tmp, ptr[reg_tmp + reg_iterkb * sizeof(AType)]);
+    auto& reg_zpA = reg_tmp;
+
+    mov(reg_tmp1, ptr[parambase + OFFSET(scaleA)]);
+    lea(reg_tmp1, ptr[reg_tmp1 + reg_iterkb * sizeof(float)]);
+    auto& reg_scaleA = reg_tmp1;
+
+    load32(reg_tmp3, ptr[parambase + OFFSET(ldsa)]);
+    auto& reg_ldsa = reg_tmp3;
+    for (int i = 0; i < NRegs; i++) {
+      vmovups(Xbyak::Zmm(BReg + i), ptr[reg_redB + i * VecBytes]);
+    }
+
+    for (int i = 0; i < _mtile; i++) {
+      vpbroadcastb(Xbyak::Xmm(AReg), ptr[reg_zpA]);
+      vpmovzxbd(Xbyak::Zmm(AReg), Xbyak::Xmm(AReg));
+      vcvtdq2ps(Xbyak::Zmm(AReg), Xbyak::Zmm(AReg));
+      vmulps(Xbyak::Zmm(AReg), Xbyak::Zmm(AReg), zword_b[reg_scaleA]);
+      for (int j = 0; j < NRegs; j++) {
+        vmulps(Xbyak::Zmm(CReg + j), Xbyak::Zmm(AReg), Xbyak::Zmm(BReg + j));
+        vsubps(Xbyak::Zmm(CF32Reg + i * NRegs + j), Xbyak::Zmm(CReg + j));
+      }
+      lea(reg_zpA, ptr[reg_zpA + reg_ldsa * sizeof(AType)]);
+      lea(reg_scaleA, ptr[reg_scaleA + reg_ldsa * sizeof(float)]);
+    }
+  }
+
+  void write_back(int _mtile) {
+    inLocalLabel();
+    mov(reg_matCptr, ptr[parambase + OFFSET(matC)]);
+    load32(reg_cstride, ptr[parambase + OFFSET(cstride)]);
+    lea(reg_matCptr, ptr[reg_matCptr + reg_itern * sizeof(CType)]);
+    for (int i = 0; i < _mtile; i++) {
+      for (int j = 0; j < NRegs; j++) {
+        vmovups(ptr[reg_matCptr + j * VecBytes], vreg_t(CF32Reg + i * NRegs + j));
+      }
+      add(reg_matCptr, reg_cstride);
+    }
+    outLocalLabel();
+  }
+};
+
+}  // namespace kblock
 }  // namespace code
 template <template <int, int> class CodeT, int _NTILE, int _MTILE = 0>
 class CoreCodeBase {
@@ -1959,7 +2471,7 @@ class CoreCodeBase {
   static int constexpr KTILE = Code::KTILE;
   static int constexpr PACK_ROW = Code::PackRow;
   static int constexpr COMP = Code::COMPUTE;
-  static int constexpr PREFERED_N = 144;
+  static int constexpr PREFERRED_N = NTILE * 3;
   static JBLAS_ISA constexpr ISA = (JBLAS_ISA)Code::ISA;
   static uint32_t constexpr ID = CoreAttr::make_core_id(NTILE, PACK_ROW, COMP, ISA);
   void configure() { (void)(0); }
@@ -1985,7 +2497,7 @@ class CoreCodeBaseAMX {
   static int constexpr KTILE = Code::KTILE;
   static int constexpr PACK_ROW = Code::PackRow;
   static int constexpr COMP = Code::COMPUTE;
-  static int constexpr PREFERED_N = 144;
+  static int constexpr PREFERRED_N = NTILE * 3;
   static JBLAS_ISA constexpr ISA = (JBLAS_ISA)Code::ISA;
   static uint32_t constexpr ID = CoreAttr::make_core_id(_NTILE, PACK_ROW, COMP, ISA);
   Xbyak::CodeGenerator cfgcode;
@@ -2101,6 +2613,23 @@ class ICoreRowNAvx512vnni : public CoreCodeBase<code::Avx512vnniN16P4, _NTILE, _
   }
 };
 
+template <int _NTILE, int _MTILE = 0>
+class ICoreRowNAvx512vnniKBlock : public CoreCodeBase<code::kblock::Avx512vnniN16P4, _NTILE, _MTILE> {
+ public:
+  using Code = typename CoreCodeBase<code::kblock::Avx512vnniN16P4, _NTILE, _MTILE>::Code;
+  void forward(uint8_t* matA, int8_t* matB, float* matC, uint8_t* zpA, float* scaleA, int _ldsa, float* scaleB,
+               float* reduceB, int _ldsb, int _m, int _n, int _k, int _kblock, int _astride, int _bstride, int _cstride,
+               int kpos, void* tmpcache, size_t cachesize) {
+    auto param = typename Code::params{matA,  _astride, matB,    _bstride, matC, _cstride, zpA,     scaleA,
+                                       _ldsa, scaleB,   reduceB, _ldsb,    _k,   _n,       _kblock, kpos == 0 ? 1 : 0};
+    if (_m <= Code::MTILE) {
+      this->mCodes[_m - 1].mKernel(&param);
+    } else {
+      assert(0);
+    }
+  }
+};
+
 template <int _NTILE, int _MTILE = 0>
 class ICoreRowNAvxvnni : public CoreCodeBase<code::AvxvnniN8P4, _NTILE, _MTILE> {
  public:
diff --git a/onnxruntime/core/mlas/lib/x86_64/jblas/jblas/jit_blas_parallel.h b/onnxruntime/core/mlas/lib/x86_64/jblas/jblas/jit_blas_parallel.h
index 0720936ec32b1..e32f8485b9161 100644
--- a/onnxruntime/core/mlas/lib/x86_64/jblas/jblas/jit_blas_parallel.h
+++ b/onnxruntime/core/mlas/lib/x86_64/jblas/jblas/jit_blas_parallel.h
@@ -87,7 +87,7 @@ class Scheduler2D {
   void schedule() {
     int rownum = utils::updiv(mSize[0], mStep[0]);
     int colnum = utils::updiv(mSize[1], mStep[1]);
-    float ratio = colnum * rownum / float(mThdCount);
+    float ratio = colnum * rownum / static_cast<float>(mThdCount);
     if (ratio <= 1) {
       mThdSize[0] = mStep[0];
       mThdSize[1] = mStep[1];
@@ -97,11 +97,13 @@ class Scheduler2D {
     }
     float colratio = ratio > colnum ? colnum : ceil(ratio);
     mThdSize[1] = static_cast<int>(colratio * mStep[1]);
-    mThdPerRow = static_cast<int>(ceil(float(colnum) / colratio));
-    mThdSize[0] = static_cast<int>(ceil(rownum / (float(mThdCount) / mThdPerRow)) * mStep[0]);
+    mThdPerRow = static_cast<int>(ceil(static_cast<float>(colnum) / colratio));
+    mThdSize[0] = static_cast<int>(ceil(rownum / (static_cast<float>(mThdCount) / mThdPerRow)) * mStep[0]);
     calc_valid_threads();
   }
-  void calc_valid_threads() { mThdValid = mThdPerRow * int(std::ceil(float(mSize[0]) / mThdSize[0])); }
+  void calc_valid_threads() {
+    mThdValid = mThdPerRow * static_cast<int>(std::ceil(static_cast<float>(mSize[0]) / mThdSize[0]));
+  }
 
   int mThdPerRow = 0;
   int mThdValid = 0;
@@ -170,7 +172,7 @@ class SchedulerBase : public Scheduler2D {
   void schedule() {
     int rownum = utils::updiv(mSize[0], mStep[0]);
     int colnum = utils::updiv(mSize[1], mStep[1]);
-    mDensity = float(mSize[0]) * mSize[1] / (mSize[0] + mSize[1]);
+    mDensity = static_cast<float>(mSize[0]) * mSize[1] / (mSize[0] + mSize[1]);
     int maxN = 0;
     float maxScore = std::numeric_limits<float>::min();
     int core_enum = static_cast<int>(std::sqrt(mThdCount));
@@ -191,16 +193,16 @@ class SchedulerBase : public Scheduler2D {
     generate_by_cores(maxN, mThdCount / maxN, rownum, colnum);
     update_cache_blocking();
     Scheduler2D::set(mThdSize, mSize, mStep);
-    mL2Use = size_t(mBlock[0]) * mBlock[1] * mEleSize[2];
-    mL2Use += size_t(mBlock[1]) * mBlock[2] * mEleSize[1];
-    mL2Use += size_t(mStep[0]) * mBlock[2] * mEleSize[0];
+    mL2Use = static_cast<size_t>(mBlock[0]) * mBlock[1] * mEleSize[2];
+    mL2Use += static_cast<size_t>(mBlock[1]) * mBlock[2] * mEleSize[1];
+    mL2Use += static_cast<size_t>(mStep[0]) * mBlock[2] * mEleSize[0];
   }
   const float DensityThres = 32;
 
   float calculate_score() {
-    int tmpnstep = mThdSize[1] < _GemmCore_T::PREFERED_N ? mThdSize[1] : _GemmCore_T::PREFERED_N;
-    float threadratio = float(mThdValid) / mThdCount;
-    float density = float(tmpnstep) * mThdSize[0] / (tmpnstep + mThdSize[0]);
+    int tmpnstep = mThdSize[1] < _GemmCore_T::PREFERRED_N ? mThdSize[1] : _GemmCore_T::PREFERRED_N;
+    float threadratio = static_cast<float>(mThdValid) / mThdCount;
+    float density = static_cast<float>(tmpnstep) * mThdSize[0] / (tmpnstep + mThdSize[0]);
     if (mDensity < DensityThres) {
       return threadratio;
     }
@@ -229,8 +231,8 @@ class SchedulerBase : public Scheduler2D {
 
   void cache_blocking_compute() {
     int constexpr KRef = 256;
-    size_t csize_total = mL2Size - _GemmCore_T::PREFERED_N * KRef * mEleSize[1];
-    int maxM = static_cast<int>(csize_total / _GemmCore_T::PREFERED_N / mEleSize[2]);
+    size_t csize_total = mL2Size - _GemmCore_T::PREFERRED_N * KRef * mEleSize[1];
+    int maxM = static_cast<int>(csize_total / _GemmCore_T::PREFERRED_N / mEleSize[2]);
     maxM = utils::downdiv(maxM, mStep[0]);
     int nthdm = mThdSize[0] / mStep[0];
     if (maxM < nthdm) {
@@ -257,11 +259,11 @@ class SchedulerBase : public Scheduler2D {
   void cache_block_memory() {
     mBlock[0] = mThdSize[0];
     mBlock[1] = mStep[1];
-    size_t reservsize = (size_t)mBlock[0] * mBlock[1] * mEleSize[2];
+    size_t reservsize = static_cast<size_t>(mBlock[0]) * mBlock[1] * mEleSize[2];
     size_t maxK = (mL1Size - reservsize) / (mBlock[1] * mEleSize[1] + mBlock[0] * mEleSize[0]);
     size_t Bsize = maxK * mBlock[1] * mEleSize[1];
     size_t Bsize_1K = utils::padto_le(Bsize, 1024);
-    mBlock[2] = int(Bsize_1K / mEleSize[1] / mBlock[1]);
+    mBlock[2] = static_cast<int>(Bsize_1K / mEleSize[1] / mBlock[1]);
     mBlock[2] = utils::padto_le(mBlock[2], mStep[2]);
   }
 
@@ -327,7 +329,7 @@ class SchedulerKBlock : public Scheduler2D {
   void schedule() {
     int rownum = utils::updiv(mSize[0], mStep[0]);
     int colnum = utils::updiv(mSize[1], mStep[1]);
-    mDensity = float(mSize[0]) * mSize[1] / (mSize[0] + mSize[1]);
+    mDensity = static_cast<float>(mSize[0]) * mSize[1] / (mSize[0] + mSize[1]);
     int maxN = 0;
     float maxScore = std::numeric_limits<float>::min();
     int core_enum = static_cast<int>(std::sqrt(mThdCount));
@@ -348,16 +350,16 @@ class SchedulerKBlock : public Scheduler2D {
     generate_by_cores(maxN, mThdCount / maxN, rownum, colnum);
     update_cache_blocking();
     Scheduler2D::set(mThdSize, mSize, mStep);
-    mL2Use = size_t(mBlock[0]) * mBlock[1] * mEleSize[2] * 2;
-    mL2Use += size_t(mBlock[1]) * mBlock[2] * mEleSize[1];
-    mL2Use += size_t(mStep[0]) * mBlock[2] * mEleSize[0];
+    mL2Use = static_cast<size_t>(mBlock[0]) * mBlock[1] * mEleSize[2] * 2;
+    mL2Use += static_cast<size_t>(mBlock[1]) * mBlock[2] * mEleSize[1];
+    mL2Use += static_cast<size_t>(mStep[0]) * mBlock[2] * mEleSize[0];
   }
   const float DensityThres = 32;
 
   float calculate_score() {
-    int tmpnstep = mThdSize[1] < _GemmCore_T::PREFERED_N ? mThdSize[1] : _GemmCore_T::PREFERED_N;
-    float threadratio = float(mThdValid) / mThdCount;
-    float density = float(tmpnstep) * mThdSize[0] / (tmpnstep + mThdSize[0]);
+    int tmpnstep = mThdSize[1] < _GemmCore_T::PREFERRED_N ? mThdSize[1] : _GemmCore_T::PREFERRED_N;
+    float threadratio = static_cast<float>(mThdValid) / mThdCount;
+    float density = static_cast<float>(tmpnstep) * mThdSize[0] / (tmpnstep + mThdSize[0]);
     if (mDensity < DensityThres) {
       return threadratio * 1.f;
     }
@@ -385,7 +387,104 @@ class SchedulerKBlock : public Scheduler2D {
 
   void cache_blocking_compute() {
     int constexpr KRef = 256;
-    int constexpr NRef = _GemmCore_T::PREFERED_N;
+    int constexpr NRef = _GemmCore_T::PREFERRED_N;
+    int constexpr MTile = _GemmCore_T::MTILE;
+    int constexpr KSplitStage = 16;
+    int BlkNum = utils::updiv(mSize[2], mKBlock);
+    int KSplitSize = utils::padto(utils::updiv(mSize[2], KSplitStage), mStep[2]);
+    mBlock[1] = NRef < mThdSize[1] ? NRef : mThdSize[1];
+    if (KSplitSize >= mKBlock) {
+      mBlock[2] = mKBlock;
+    } else {
+      int scale = utils::downdiv(KSplitStage, BlkNum);
+      for (; scale >= 1; scale--) {
+        if (mKBlock % scale == 0) {
+          break;
+        }
+      }
+      mBlock[2] = utils::downdiv(mKBlock, scale);
+	  mBlock[2] =utils::padto_le(mBlock[2],mStep[2]);
+    }      
+    size_t size_remain = mL2Size - mBlock[1] * mBlock[2] * mEleSize[1];
+    // MBlock*KBlock*ASize+MBlock*NBlock*CSize*2<=size_remain
+    int maxMBlock = static_cast<int>(size_remain / (mBlock[1] * mEleSize[2] * 2 + mBlock[2] * mEleSize[0]));
+    int maxM = utils::downdiv(maxMBlock, mStep[0]);
+    int nthdm = mThdSize[0] / mStep[0];
+    if (maxM < nthdm) {
+      int niter = utils::updiv(nthdm, maxM);
+      mBlock[0] = utils::updiv(nthdm, niter) * mStep[0];
+    } else {
+      mBlock[0] = mThdSize[0];
+    }
+  }
+
+  void cache_block_memory() {
+    mBlock[0] = _GemmCore_T::MTILE;
+    size_t startK = std::max(16, _GemmCore_T::KTILE);
+    auto getMaxN = [&](size_t refk) {
+      size_t sizeA = refk * mEleSize[0] * mBlock[0];
+      size_t maxN = (mL1Size - sizeA) / (mBlock[0] * mEleSize[2] * 2 + refk * mEleSize[1]);
+      return maxN;
+    };
+    auto getMaxK = [&](size_t refN) {
+      size_t sizeC = refN * mEleSize[2] * mBlock[0] * 2;
+      size_t maxK = (mL1Size - sizeC) / (mBlock[0] * mEleSize[0] + refN * mEleSize[1]);
+      return maxK;
+    };
+    auto maxN = getMaxN(startK);
+    if (maxN <= mThdSize[1]) {
+      mBlock[1] = static_cast<int>(maxN);
+      mBlock[1] = utils::padto_le(mBlock[1], mStep[1]);
+      mBlock[2] = static_cast<int>(startK);
+    } else {
+      mBlock[1] = mThdSize[1];
+      mBlock[2] = static_cast<int>(getMaxK(mBlock[1]));
+      mBlock[2] = utils::padto_le(mBlock[2], mStep[2]);
+      mBlock[2] = std::min(mKBlock, mBlock[2]);
+      auto tmp = utils::updiv(mKBlock, mBlock[2]);
+      while (mKBlock % tmp != 0) tmp++;  // TODO(Yu) optimize
+      mBlock[2] = utils::downdiv(mKBlock, tmp);
+    }
+  }
+  size_t mL2Size = 0, mL1Size = 0, mL2Use = 0;
+  float mDensity = 0.f;
+  int mKBlock = 0;
+
+ private:
+  int mSize[3] = {0, 0, 0};
+  int mThdSize[3] = {0, 0, 0};
+  static constexpr int mStep[3] = {_GemmCore_T::MTILE, _GemmCore_T::NTILE, _GemmCore_T::KTILE};
+  static constexpr int mEleSize[3] = {sizeof(typename _GemmCore_T::AType), sizeof(typename _GemmCore_T::BType),
+                                      sizeof(typename _GemmCore_T::CType)};
+  int mSizePadded[3] = {0, 0, 0};
+  int mBlock[3] = {0, 0, 0};
+};
+#if 0
+template <class _GemmCore_T>
+class SchedulerKBlockS : public SchedulerBase<_GemmCore_T> {
+  // Block[2]: block size of K must be mutiplier of mKBlock
+  //           or factor of mKBlock
+ public:
+  using ThreadProblem = ThreadProblemBase;
+  SchedulerKBlockS() = default;
+  SchedulerKBlockS(const ConfigGemmKBlock& config) { update(config); }
+
+ protected:
+  // C-KBlock Accumulator=MBlock*NBlock
+  // C-K Accumulator=MBlock*NBlock
+  // B=MBlock*KBlock
+  // A=MTILE*KBlock
+  void update_cache_blocking() {
+    if (mDensity <= DensityThres) {
+      return cache_block_memory();
+    } else {
+      return cache_blocking_compute();
+    }
+  }
+
+  void cache_blocking_compute() {
+    int constexpr KRef = 256;
+    int constexpr NRef = _GemmCore_T::PREFERRED_N;
     int constexpr MTile = _GemmCore_T::MTILE;
     int constexpr KSplitStage = 16;
     int BlkNum = utils::updiv(mSize[2], mKBlock);
@@ -438,9 +537,6 @@ class SchedulerKBlock : public Scheduler2D {
       mBlock[2] = getMaxK(mBlock[1]);
       mBlock[2] = utils::padto_le(mBlock[2], mStep[2]);
       mBlock[2] = std::min(mKBlock, mBlock[2]);
-	  auto tmp = utils::updiv(mKBlock, mBlock[2]);
-      while (mKBlock % tmp != 0) tmp++;  // TODO(Yu) optimize
-      mBlock[2] = utils::downdiv(mKBlock, tmp);
     }
   }
   size_t mL2Size = 0, mL1Size = 0, mL2Use = 0;
@@ -456,7 +552,7 @@ class SchedulerKBlock : public Scheduler2D {
   int mSizePadded[3] = {0, 0, 0};
   int mBlock[3] = {0, 0, 0};
 };
-
+#endif
 }  // namespace gemm
 using thread_func = std::function<void(int tid)>;
 
@@ -464,6 +560,7 @@ class IThreading {
  public:
   IThreading(int nthreads) : mThreadNum(nthreads) {}
   virtual void parallel_for(const thread_func& func) = 0;
+  virtual inline void sync() = 0;
   virtual int num_threads() { return mThreadNum; };
   virtual void set_threads(int nthreads) = 0;
 
@@ -485,6 +582,10 @@ class OMPThreading : public IThreading {
     mThreadNum = nthreads;
     omp_set_num_threads(nthreads);
   }
+  virtual inline void sync() override {
+#pragma omp barrier
+    (void)(0);  // make msvc happy with c++20
+  }
 };
 #endif
 
@@ -505,6 +606,8 @@ class StdThreading : public IThreading {
     thdset.resize(nthreads);
   }
 
+  virtual inline void sync() override { assert(0); }
+
  private:
   std::vector<std::thread> thdset;
 };
@@ -547,5 +650,27 @@ void GemmKBlockRun(Launch_T& launcher, const typename Launch_T::Param& args, par
   });
 }
 
+template <class Parallel_T, class Launch_T>
+void GemmKBlockRunWithA(Launch_T& launcher, const typename Launch_T::Param& args,
+                        const typename Launch_T::AParam& Aargs, parallel::IThreading* th) {
+  device::CpuBase cb;
+  Parallel_T para({th->num_threads(), args.M, args.N, args.K, cb.mL2Cache, cb.mL1Cache, args.KBlock});
+  using AParall = typename Launch_T::PrologueA::Parallel;
+  AParall apara({th->num_threads(), args.M, args.K, 1, args.KBlock});
+  th->parallel_for([&](int tidx) {
+    typename AParall::ThreadProblem thdpA{tidx};
+    apara.getIndex(thdpA);
+    if (thdpA.valid) {
+      launcher.mProA.run(Aargs, thdpA);
+    }
+    th->sync();
+    typename Parallel_T::ThreadProblem thdp{tidx};
+    para.getIndex(thdp);
+    if (thdp.valid) {
+      launcher.run(args, thdp);
+    }
+  });
+}
+
 }  // namespace parallel
 }  // namespace jblas
diff --git a/onnxruntime/core/mlas/lib/x86_64/jblas/jblas/jit_blas_prologue_b.h b/onnxruntime/core/mlas/lib/x86_64/jblas/jblas/jit_blas_prologue_b.h
index e75d787603877..ff9cb05e5d090 100644
--- a/onnxruntime/core/mlas/lib/x86_64/jblas/jblas/jit_blas_prologue_b.h
+++ b/onnxruntime/core/mlas/lib/x86_64/jblas/jblas/jit_blas_prologue_b.h
@@ -57,7 +57,7 @@ class WeightPack {
   }
 
   void packWeightTranspose(const int N, const int K, const Param& _param, parallel::IThreading* threading) {
-    auto B_NT = utils::amalloc<WType>((size_t)N * K);
+    auto B_NT = utils::amalloc<WType>(static_cast<size_t>(N) * K);
     transposeWeight<WType, ISA_T>(N, K, _param.B, _param.ldb, B_NT, N, threading);
     packWeight(N, K, {B_NT, N, _param.packedW}, threading);
     utils::afree(B_NT);
@@ -120,7 +120,7 @@ class WeightKBlockS8 {
 
   virtual void packTransposeWeight(const int N, const int K, const float* B, const int ldb, void* stor,
                                    parallel::IThreading* threading) {
-    auto B_NT = utils::amalloc<float>((size_t)N * K);
+    auto B_NT = utils::amalloc<float>(static_cast<size_t>(N) * K);
     transposeWeight<float, ISA_T>(N, K, B, ldb, B_NT, N, threading);
     packWeight(N, K, B_NT, N, stor, threading);
     utils::afree(B_NT);
@@ -129,7 +129,7 @@ class WeightKBlockS8 {
   // from packed N//NtilexKPadxNTile int8 weight to KxN f32 weight
   virtual void unpackTransposeWeight(const int N, const int K, void* stor, float* B, const int ldb,
                                      parallel::IThreading* threading) {
-    auto B_NT = utils::amalloc<float>((size_t)N * K);
+    auto B_NT = utils::amalloc<float>(static_cast<size_t>(N) * K);
     unpackWeight(N, K, stor, B_NT, N, threading);
     transposeWeight<float, ISA_T>(K, N, B_NT, N, B, ldb, threading);
     utils::afree(B_NT);
@@ -138,14 +138,14 @@ class WeightKBlockS8 {
   // from KxN f32 weight to packed N//NtilexKPadxNTile int8 weight
   virtual void packWeight(const int N, const int K, const float* B, const int ldb, void* stor,
                           parallel::IThreading* threading) {
-    auto tmpq = utils::amalloc<int8_t>((size_t)N * K);
+    auto tmpq = utils::amalloc<int8_t>(static_cast<size_t>(N) * K);
     auto ptr = reinterpret_cast<StorageWeight*>(stor);
     int nk_scale = utils::updiv(K, ptr->mBlockSize);
-    auto ssize = (size_t)N * nk_scale;
+    auto ssize = static_cast<size_t>(N) * nk_scale;
     auto Tscales = utils::amalloc<float>(ssize);
     auto Tzps = utils::amalloc<int8_t>(ptr->mIsAsym ? ssize : 0);
     quantizeWeight(N, K, B, ldb, ptr->mBlockSize, tmpq, Tscales, Tzps, ptr->mDType, threading);
-    packQWeight(N, K, tmpq, ldb, Tscales, Tzps, stor, threading);
+    packQWeight(N, K, tmpq, N, Tscales, Tzps, stor, threading);
     utils::afree(tmpq);
     utils::afree(Tscales);
     utils::afree(Tzps);
@@ -401,7 +401,7 @@ class WeightKBlockS8 {
  public:
   virtual inline JBLAS_CODE getWeight(float** dstptr, int* dststep, int k_size, int n_size, int k_offset, int n_offset,
                                       const Param& _param, void* tmpcache, size_t cachesize) {
-    auto wptr = (StorageWeight*)(_param.packedW);
+    auto wptr = reinterpret_cast<StorageWeight*>(const_cast<storage::gemm::WeightKBlockBase*>(_param.packedW));
     auto NPad = wptr->mNPad;
     auto KPad = wptr->mKPad;
     auto bptr = wptr->WPtr() + n_offset * KPad + k_offset * _GemmCore_T::NTILE;
@@ -436,7 +436,7 @@ class WeightKBlockS8 {
   }
   virtual inline JBLAS_CODE getWeight(int8_t** dstptr, int* dststep, int k_size, int n_size, int k_offset, int n_offset,
                                       const Param& _param, void* tmpcache, size_t cachesize) {
-    auto wptr = (StorageWeight*)(_param.packedW);
+    auto wptr = reinterpret_cast<StorageWeight*>(const_cast<storage::gemm::WeightKBlockBase*>(_param.packedW));
     auto KPad = wptr->mKPad;
     auto bptr = wptr->WPtr() + n_offset * KPad + k_offset * _GemmCore_T::NTILE;
     kernel::wrapper::Memcpy2D::template forward<ISA_T, int8_t, int8_t>(
@@ -448,7 +448,7 @@ class WeightKBlockS8 {
 
   virtual inline JBLAS_CODE getKBlockWeight(float** dstptr, int* dststep, int k_size, int n_size, int k_offset,
                                             int n_offset, const Param& _param, void* tmpcache, size_t cachesize) {
-    auto wptr = (StorageWeight*)(_param.packedW);
+    auto wptr = reinterpret_cast<StorageWeight*>(const_cast<storage::gemm::WeightKBlockBase*>(_param.packedW));
     auto NPad = wptr->mNPad;
     auto KPad = wptr->mKPad;
     auto bptr = wptr->WPtr() + n_offset * KPad + k_offset * _GemmCore_T::NTILE;
@@ -463,7 +463,7 @@ class WeightKBlockS8 {
 
   virtual inline JBLAS_CODE getKBlockWeight(utils::bf16** dstptr, int* dststep, int k_size, int n_size, int k_offset,
                                             int n_offset, const Param& _param, void* tmpcache, size_t cachesize) {
-    auto wptr = (StorageWeight*)(_param.packedW);
+    auto wptr = reinterpret_cast<StorageWeight*>(const_cast<storage::gemm::WeightKBlockBase*>(_param.packedW));
     auto NPad = wptr->mNPad;
     auto KPad = wptr->mKPad;
     auto bptr = wptr->WPtr() + n_offset * KPad + k_offset * _GemmCore_T::NTILE;
@@ -528,10 +528,10 @@ class WeightKBlockS4 : public WeightKBlockS8<_GemmCore_T, ISA_T> {
                                const float* scales, const uint8_t* zero_points, void* ptr,
                                parallel::IThreading* threading) {
     auto stor = reinterpret_cast<StorageWeight*>(ptr);
-    auto tmp = utils::amalloc<float>((size_t)stor->mKPad * stor->mNPad);
+    auto tmp = utils::amalloc<float>(static_cast<size_t>(stor->mKPad) * stor->mNPad);
     auto blks = utils::updiv(K, stor->mBlockSize);
-    auto tmpscales = (float*)tmp;
-    auto tmpzeropoints = (int8_t*)(tmpscales + N * blks);
+    auto tmpscales = tmp;
+    auto tmpzeropoints = reinterpret_cast<int8_t*>(tmpscales + N * blks);
     if (scales) {
       for (size_t i = 0; i < N * blks; i += 2) {
         tmpscales[i] = scales[i] / 16;
@@ -567,7 +567,7 @@ class WeightKBlockS4 : public WeightKBlockS8<_GemmCore_T, ISA_T> {
         });
       };
       transposeunpackfunc_u4s4();
-      auto reorded = s8ptr + (size_t)K * N;
+      auto reorded = s8ptr + static_cast<size_t>(K) * N;
       WeightKBlockS8<_GemmCore_T, ISA_T>::reorderWeight(N, K, s8ptr, N, reorded, threading);
       compressWeight(stor->mNPad, stor->mKPad, reorded, stor->mNPad, stor->WPtr(), threading);
     }
@@ -592,7 +592,7 @@ class WeightKBlockS4 : public WeightKBlockS8<_GemmCore_T, ISA_T> {
  public:
   inline JBLAS_CODE getWeight(int8_t** dstptr, int* dststep, int k_size, int n_size, int k_offset, int n_offset,
                               const Param& _param, void* tmpcache, size_t cachesize) override {
-    auto wptr = (StorageWeight*)(_param.packedW);
+    auto wptr = reinterpret_cast<StorageWeight*>(const_cast<storage::gemm::WeightKBlockBase*>(_param.packedW));
     auto KPad = wptr->mKPad;
     auto bptr = wptr->WPtr() + n_offset * KPad / 2 + k_offset * _GemmCore_T::NTILE / 2;
     int constexpr ColSize = _GemmCore_T::NTILE * _GemmCore_T::PACK_ROW;
@@ -657,7 +657,7 @@ class WeightKBlockS4 : public WeightKBlockS8<_GemmCore_T, ISA_T> {
   template <typename T>
   inline JBLAS_CODE getFpKBlockWeight(T** dstptr, int* dststep, int k_size, int n_size, int k_offset, int n_offset,
                                       const Param& _param, void* tmpcache, size_t cachesize) {
-    auto wptr = (StorageWeight*)(_param.packedW);
+    auto wptr = reinterpret_cast<StorageWeight*>(const_cast<storage::gemm::WeightKBlockBase*>(_param.packedW));
     auto NPad = wptr->mNPad;
     auto KPad = wptr->mKPad;
     auto bptr = wptr->WPtr() + n_offset * KPad / 2 + k_offset * _GemmCore_T::NTILE / 2;
@@ -694,7 +694,7 @@ class WeightKBlockS4 : public WeightKBlockS8<_GemmCore_T, ISA_T> {
   template <typename _T>
   inline JBLAS_CODE getFpWeight(_T** dstptr, int* dststep, int k_size, int n_size, int k_offset, int n_offset,
                                 const Param& _param, void* tmpcache, size_t cachesize) {
-    auto wptr = (StorageWeight*)(_param.packedW);
+    auto wptr = reinterpret_cast<StorageWeight*>(const_cast<storage::gemm::WeightKBlockBase*>(_param.packedW));
     auto NPad = wptr->mNPad;
     auto KPad = wptr->mKPad;
     auto bptr = wptr->WPtr() + n_offset * KPad / 2 + k_offset * _GemmCore_T::NTILE / 2;
@@ -755,7 +755,7 @@ class WeightKBlockF4 : public WeightKBlockS4<_GemmCore_T, ISA_T> {
                            parallel::IThreading* threading) {
     WeightKBlockS8<_GemmCore_T, ISA_T>::setQuantCorrection(N, K, NULL, scales, ptr, threading);
     auto stor = reinterpret_cast<StorageWeight*>(ptr);
-    auto reorded = utils::amalloc<int8_t>((size_t)stor->mKPad * stor->mNPad);
+    auto reorded = utils::amalloc<int8_t>(static_cast<size_t>(stor->mKPad) * stor->mNPad);
     WeightKBlockS8<_GemmCore_T, ISA_T>::reorderWeight(N, K, B, ldb, reorded, threading);
     WeightKBlockS4<_GemmCore_T, ISA_T>::compressWeight(stor->mNPad, stor->mKPad, reorded, stor->mNPad, stor->WPtr(),
                                                        threading);
@@ -806,7 +806,7 @@ class WeightKBlockF4 : public WeightKBlockS4<_GemmCore_T, ISA_T> {
   template <typename T>
   inline JBLAS_CODE getFpWeight(T** dstptr, int* dststep, int k_size, int n_size, int k_offset, int n_offset,
                                 const Param& _param, void* tmpcache, size_t cachesize) {
-    auto wptr = (StorageWeight*)(_param.packedW);
+    auto wptr = reinterpret_cast<StorageWeight*>(const_cast<storage::gemm::WeightKBlockBase*>(_param.packedW));
     auto NPad = wptr->mNPad;
     auto KPad = wptr->mKPad;
     auto bptr = wptr->WPtr() + n_offset * KPad / 2 + k_offset * _GemmCore_T::NTILE / 2;
@@ -859,7 +859,7 @@ class WeightKBlockF4 : public WeightKBlockS4<_GemmCore_T, ISA_T> {
   template <typename T>
   inline JBLAS_CODE getFpKBlockWeight(T** dstptr, int* dststep, int k_size, int n_size, int k_offset, int n_offset,
                                       const Param& _param, void* tmpcache, size_t cachesize) {
-    auto wptr = (StorageWeight*)(_param.packedW);
+    auto wptr = reinterpret_cast<StorageWeight*>(const_cast<storage::gemm::WeightKBlockBase*>(_param.packedW));
     auto NPad = wptr->mNPad;
     auto KPad = wptr->mKPad;
     auto bptr = wptr->WPtr() + n_offset * KPad / 2 + k_offset * _GemmCore_T::NTILE / 2;
diff --git a/onnxruntime/core/mlas/lib/x86_64/jblas/jblas/jit_blas_storage.h b/onnxruntime/core/mlas/lib/x86_64/jblas/jblas/jit_blas_storage.h
index 2c05e5a4f59ab..412dbf2f26562 100644
--- a/onnxruntime/core/mlas/lib/x86_64/jblas/jblas/jit_blas_storage.h
+++ b/onnxruntime/core/mlas/lib/x86_64/jblas/jblas/jit_blas_storage.h
@@ -61,7 +61,7 @@ class ISerialBuffer : public ISerialObject {
  public:
   template <typename T>
   inline constexpr T* get() {
-    return (T*)mBufPtr;
+    return reinterpret_cast<T*>(mBufPtr);
   };
   template <typename T>
   inline size_t size() {
@@ -80,7 +80,7 @@ class ISerialBuffer : public ISerialObject {
   virtual void serializeToBuffer(int8_t*& wptr) override {
     utils::serialize(wptr, mBufSize);
     wptr = utils::pointer_align<Alignment>(wptr);
-    if (wptr != (int8_t*)mBufPtr) {
+    if (wptr != mBufPtr) {
       std::memcpy(wptr, mBufPtr, mBufSize);
     }
     wptr += mBufSize;
@@ -92,7 +92,7 @@ class ISerialBuffer : public ISerialObject {
       utils::serialize<size_t>(rptr, mBufSize);
     }
     rptr = utils::pointer_align<Alignment>(rptr);
-    mBufPtr = (int8_t*)rptr;
+    mBufPtr = rptr;
     rptr += mBufSize;
   }
 
@@ -251,7 +251,7 @@ class StorageQuantCorrection : public ISerialObject {
     mIsAsym = _is_asym;
     mHasReduce = _has_reduce;
     mCStep = Step;
-    mCSize = (size_t)Rows * Step;
+    mCSize = static_cast<size_t>(Rows) * Step;
     return getSerializedSize();
   }
 
@@ -352,7 +352,7 @@ class StorageReduce : public ISerializable, public ISerialBuffer {
     m = _m;
     k = _k;
     lda = utils::updiv(_k, _kblock);
-    size_t bufsize = size_t(m) * lda * utils::jblas_dtype_size(redt);
+    size_t bufsize = static_cast<size_t>(m) * lda * utils::jblas_dtype_size(redt);
     ISerialBuffer::resize(bufsize);
     mSize = getSerializedSize();
     return mSize;
@@ -425,7 +425,7 @@ class StorageQuantActivation : public ISerializable, public ISerialBuffer, publi
     lda = _lda;
     m = _m;
     CorrectionType::resize(_m, utils::updiv(_lda, _kblock), scalet, zpt, redt, is_asym, has_reduce);
-    size_t bufsize = size_t(m) * lda * utils::jblas_dtype_size(buft);
+    size_t bufsize = static_cast<size_t>(m) * lda * utils::jblas_dtype_size(buft);
     ISerialBuffer::resize(bufsize);
     mSize = getSerializedSize();
     return mSize;
@@ -495,7 +495,7 @@ class StoragePackedWeight : public WeightBase, public ISerialBuffer {
 
   size_t resize(int NPad, int KPad, int N, int K, JBLAS_DTYPE dtype) {
     WeightBase::resize(NPad, KPad, N, K, dtype);
-    auto bsize = (size_t)NPad * KPad * jblas::utils::jblas_dtype_size(dtype);
+    auto bsize = static_cast<size_t>(NPad) * KPad * jblas::utils::jblas_dtype_size(dtype);
     ISerialBuffer::resize(bsize);
     mSize = WeightBase::getSerializedSize() + ISerialBuffer::getSerializedSize();
     return mSize;
@@ -539,12 +539,12 @@ class StorageWeightKBlockS8 : public WeightKBlockBase, public Buffer8Bit, public
   size_t resize(int NPad, int KPad, int Block, int N, int K, JBLAS_DTYPE scalet, JBLAS_DTYPE redt, bool IsAsym) {
     JBLAS_DTYPE zpt = JBLAS_DTYPE::S8;
     InfoType::resize(NPad, KPad, Block, N, K, JBLAS_DTYPE::S8);
-    QWeightType::resize((size_t)NPad * KPad);
+    QWeightType::resize(static_cast<size_t>(NPad) * KPad);
     int nk_scale = utils::updiv(KPad, Block);
     auto gemm_comp = jblas::gemm::CoreAttr::get_mask_val(mCoreId, jblas::gemm::CoreAttr::COMP_MASK,
                                                          jblas::gemm::CoreAttr::COMP_SHIFT);
     CorrectionType::resize(nk_scale, NPad, scalet, zpt, redt, IsAsym,
-                           gemm_comp >= (uint32_t)jblas::gemm::CompType::COMP_INT_START);
+                           gemm_comp >= static_cast<uint32_t>(jblas::gemm::CompType::COMP_INT_START));
     mSize = InfoType::getSerializedSize() + QWeightType::getSerializedSize() + CorrectionType::getSerializedSize();
     return mSize;
   }
@@ -579,12 +579,12 @@ class StorageWeightKBlockS4 : public WeightKBlockBase, public Buffer4Bit, public
                 bool IsAsym) {
     JBLAS_DTYPE zpt = JBLAS_DTYPE::S8;
     InfoType::resize(NPad, KPad, Block, N, K, s4t);
-    QWeightType::resize((size_t)NPad * KPad);
+    QWeightType::resize(static_cast<size_t>(NPad) * KPad);
     int nk_scale = utils::updiv(KPad, Block);
     auto gemm_comp = jblas::gemm::CoreAttr::get_mask_val(mCoreId, jblas::gemm::CoreAttr::COMP_MASK,
                                                          jblas::gemm::CoreAttr::COMP_SHIFT);
     CorrectionType::resize(nk_scale, NPad, scalet, zpt, redt, IsAsym,
-                           gemm_comp >= (uint32_t)jblas::gemm::CompType::COMP_INT_START);
+                           gemm_comp >= static_cast<uint32_t>(jblas::gemm::CompType::COMP_INT_START));
     mSize = InfoType::getSerializedSize() + QWeightType::getSerializedSize() + CorrectionType::getSerializedSize();
     return mSize;
   }
@@ -662,4 +662,4 @@ class PackedWeightParser {
 };
 }  // namespace gemm
 }  // namespace storage
-}  // namespace jblas
\ No newline at end of file
+}  // namespace jblas
diff --git a/onnxruntime/core/mlas/lib/x86_64/jblas/jblas/jit_blas_utils.h b/onnxruntime/core/mlas/lib/x86_64/jblas/jblas/jit_blas_utils.h
index bb046c061334f..96d9e94c9bfc0 100644
--- a/onnxruntime/core/mlas/lib/x86_64/jblas/jblas/jit_blas_utils.h
+++ b/onnxruntime/core/mlas/lib/x86_64/jblas/jblas/jit_blas_utils.h
@@ -71,8 +71,6 @@
 #include <immintrin.h>
 #endif
 
-#define MIN(a, b) ((a) < (b) ? (a) : (b))
-#define MAX(a, b) ((a) > (b) ? (a) : (b))
 namespace jblas {
 namespace utils {
 
@@ -324,7 +322,7 @@ inline constexpr const char* dtype_str() {
 }
 
 inline constexpr size_t jblas_dtype_size(const JBLAS_DTYPE t) {
-  auto bits = (uint32_t)t & 0xff;
+  auto bits = static_cast<uint32_t>(t) & static_cast<uint32_t>(0xff);
   return bits >> 3;  // bits to bytes
 }
 
@@ -410,13 +408,13 @@ bf16 cast(float _src) {
 
 template <typename _T>
 void serialize(int8_t*& buf, _T _val) {
-  *(_T*)buf = _val;
+  *reinterpret_cast<_T*>(buf) = _val;
   buf += sizeof(_T);
 }
 
 template <typename _T>
 _T deserialize(int8_t*& buf) {
-  auto val = *(_T*)buf;
+  auto val = *reinterpret_cast<_T*>(buf);
   buf += sizeof(_T);
   return val;
 }
@@ -435,11 +433,11 @@ static inline _T* amalloc(size_t _size, size_t _alignment = 64) {
   if (_size == 0) {
     return NULL;
   }
-  auto psize = padto(_size * sizeof(_T), int(_alignment));
+  auto psize = padto(_size * sizeof(_T), static_cast<int>(_alignment));
 #ifdef _WIN32
-  return (_T*)_aligned_malloc(psize, _alignment);
+  return reinterpret_cast<_T*>(_aligned_malloc(psize, _alignment));
 #else
-  return (_T*)aligned_alloc(_alignment, psize);
+  return reinterpret_cast<_T*>(aligned_alloc(_alignment, psize));
 #endif
 }
 
@@ -538,7 +536,7 @@ class timer_statistics_logger {
   typedef timer<milliseconds> log_timer_t;
   timer_statistics_logger() {
     clear();
-    log_ratio = (float)std::chrono::duration_cast<_PRECISION>(_LOG_PRECISION(1)).count();
+    log_ratio = static_cast<float>(std::chrono::duration_cast<_PRECISION>(_LOG_PRECISION(1)).count());
   }
 
   void clear() {
diff --git a/onnxruntime/core/mlas/lib/x86_64/jblas/jblas/jit_blas_wrapper.h b/onnxruntime/core/mlas/lib/x86_64/jblas/jblas/jit_blas_wrapper.h
index 2858405f3bfa2..27e240a822cdc 100644
--- a/onnxruntime/core/mlas/lib/x86_64/jblas/jblas/jit_blas_wrapper.h
+++ b/onnxruntime/core/mlas/lib/x86_64/jblas/jblas/jit_blas_wrapper.h
@@ -56,13 +56,13 @@ class LauncherBase {
   void run(const Param& _param, const parallel::gemm::ThreadProblemBase& _config) {
     mGemmCore.configure();
     auto StackTmp = alloca(_config.l2cachesize);
-    auto tmpB = (BType*)(StackTmp);
+    auto tmpB = reinterpret_cast<BType*>(StackTmp);
     tmpB = utils::pointer_align<64>(tmpB);
-    auto tmpA = (AType*)(tmpB + (size_t)_config.block[1] * _config.block[2]);
+    auto tmpA = reinterpret_cast<AType*>(tmpB + static_cast<size_t>(_config.block[1]) * _config.block[2]);
     tmpA = utils::pointer_align<64>(tmpA);
-    auto tmpC = (CType*)(tmpA + (size_t)GemmCore::MTILE * _config.block[2]);
+    auto tmpC = reinterpret_cast<CType*>(tmpA + static_cast<size_t>(GemmCore::MTILE) * _config.block[2]);
     tmpC = utils::pointer_align<64>(tmpC);
-    auto tmpCache = (void*)(tmpC + (size_t)_config.block[0] * _config.block[1]);
+    auto tmpCache = (void*)(tmpC + static_cast<size_t>(_config.block[0]) * _config.block[1]);
     tmpCache = utils::pointer_align<64>(tmpCache);
     for (int itern = 0; itern < _config.size[1]; itern += _config.block[1]) {
       int n_remain = utils::remainsize(itern, _config.size[1], _config.block[1]);
@@ -151,15 +151,15 @@ class LauncherKBlock {
   void run(const Param& _param, const parallel::gemm::ThreadProblemBase& _config) {
     mGemmCore.configure();
     auto StackTmp = alloca(_config.l2cachesize);
-    auto tmpB = (BType*)(StackTmp);
+    auto tmpB = reinterpret_cast<BType*>(StackTmp);
     tmpB = utils::pointer_align<64>(tmpB);
-    auto tmpA = (AType*)(tmpB + (size_t)_config.block[1] * _config.block[2]);
+    auto tmpA = reinterpret_cast<AType*>(tmpB + static_cast<size_t>(_config.block[1]) * _config.block[2]);
     tmpA = utils::pointer_align<64>(tmpA);
-    auto tmpC = (AccType*)(tmpA + (size_t)GemmCore::MTILE * _config.block[2]);
+    auto tmpC = reinterpret_cast<AccType*>(tmpA + static_cast<size_t>(GemmCore::MTILE) * _config.block[2]);
     tmpC = utils::pointer_align<64>(tmpC);
-    auto tmpBlk = (CType*)(tmpC + (size_t)_config.block[0] * _config.block[1]);
+    auto tmpBlk = reinterpret_cast<CType*>(tmpC + static_cast<size_t>(_config.block[0]) * _config.block[1]);
     tmpBlk = utils::pointer_align<64>(tmpBlk);
-    auto tmpCache = (void*)(tmpBlk + (size_t)_config.block[0] * _config.block[1]);
+    auto tmpCache = reinterpret_cast<void*>(tmpBlk + static_cast<size_t>(_config.block[0]) * _config.block[1]);
     tmpCache = utils::pointer_align<64>(tmpCache);
     for (int itern = 0; itern < _config.size[1]; itern += _config.block[1]) {
       int n_remain = utils::remainsize(itern, _config.size[1], _config.block[1]);
@@ -221,7 +221,7 @@ class LauncherKBlock {
                           _config.tmpcachesize);
       }
     }
-    auto cachewithblk = _config.tmpcachesize + (size_t)_config.block[0] * _config.block[1] * sizeof(CType);
+    auto cachewithblk = _config.tmpcachesize + static_cast<size_t>(_config.block[0]) * _config.block[1] * sizeof(CType);
     mEpilogue.forward(tmpC, _config.block[1], (_config.loc[0] + blk_m), _config.loc[1] + blk_n, blk_msize, blk_nsize,
                       _param.paramC, tmpBlk, cachewithblk);
   }
@@ -271,7 +271,7 @@ class LauncherKBlock {
       mBlockEpi.forward(tmpBlk, tmpC, _config.block[1], (_config.loc[0] + blk_m), _config.loc[1] + blk_n,
                         iterk / _param.KBlock, blk_msize, blk_nsize, _param.paramBlk, tmpcache, _config.tmpcachesize);
     }
-    auto cachewithblk = _config.tmpcachesize + (size_t)_config.block[0] * _config.block[1] * sizeof(CType);
+    auto cachewithblk = _config.tmpcachesize + static_cast<size_t>(_config.block[0]) * _config.block[1] * sizeof(CType);
     mEpilogue.forward(tmpC, _config.block[1], (_config.loc[0] + blk_m), _config.loc[1] + blk_n, blk_msize, blk_nsize,
                       _param.paramC, tmpBlk, cachewithblk);
   }
diff --git a/onnxruntime/core/mlas/lib/x86_64/jblas/jblas/kernel_avx2.h b/onnxruntime/core/mlas/lib/x86_64/jblas/jblas/kernel_avx2.h
index b0d9d4bfb9e39..d4af001847787 100644
--- a/onnxruntime/core/mlas/lib/x86_64/jblas/jblas/kernel_avx2.h
+++ b/onnxruntime/core/mlas/lib/x86_64/jblas/jblas/kernel_avx2.h
@@ -33,8 +33,8 @@ static uint8_t shuffle_map[] = {0x00, 0x01, 0x02, 0x03, 0xff, 0xff, 0xff, 0xff,
 
 template <JBLAS_DTYPE S4_T>
 static inline __m128i unpack_4bits_sse(void* srcptr) {
-  auto shuffle_v = _mm_loadu_si128((__m128i*)shuffle_map);
-  auto raw_data = _mm_loadl_epi64((__m128i*)srcptr);
+  auto shuffle_v = _mm_loadu_si128(reinterpret_cast<__m128i*>(shuffle_map));
+  auto raw_data = _mm_loadl_epi64(reinterpret_cast<__m128i*>(srcptr));
   auto xmm0 = _mm_shuffle_epi8(raw_data, shuffle_v);
   auto xmm1 = _mm_srli_epi32(xmm0, 0x04);
   auto and_helper = _mm_set1_epi8(0x0f);
@@ -56,7 +56,7 @@ inline __m128i ymm_cvtepi32_epi16(__m256i src) {
   __m128i tmp;
 #ifdef __GNUC__
   for (size_t i = 0; i < 8; i++) {
-    ((int16_t*)(&tmp))[i] = ((int32_t*)(&src))[i];
+    (reinterpret_cast<int16_t*>(&tmp))[i] = (reinterpret_cast<int32_t*>(&src))[i];
   }
 #else
   for (size_t i = 0; i < 8; i++) {
@@ -77,7 +77,7 @@ static inline void convert_s4_s8_16_sse(int8_t* dstptr, int8_t* srcptr) {
     auto s8 = _mm_set1_epi8(8);
     dst0 = _mm_sub_epi8(dst0, s8);
   }
-  _mm_storeu_si128((__m128i*)dstptr, dst0);
+  _mm_storeu_si128(reinterpret_cast<__m128i*>(dstptr), dst0);
 }
 
 template <typename T>
@@ -87,7 +87,7 @@ static inline void convert_s8_fp_v8(T* dstptr, int8_t* srcptr) {
   auto ymm1 = _mm256_cvtepi32_ps(ymm);
   if constexpr (std::is_same_v<T, utils::bf16>) {
     auto xmm = ymm_cvt_fp32_bf16(ymm1);
-    _mm_storeu_si128((__m128i*)dstptr, xmm);
+    _mm_storeu_si128(reinterpret_cast<__m128i*>(dstptr), xmm);
   } else {
     _mm256_storeu_ps(dstptr, ymm1);
   }
@@ -95,7 +95,7 @@ static inline void convert_s8_fp_v8(T* dstptr, int8_t* srcptr) {
 
 static inline void fp4_pad_4bit(int8_t* dstptr, int8_t* srcptr) {
   auto dst0 = unpack_4bits_sse<JBLAS_DTYPE::S4_FULLRANGE>(srcptr);
-  _mm_storeu_si128((__m128i*)dstptr, dst0);
+  _mm_storeu_si128(reinterpret_cast<__m128i*>(dstptr), dst0);
 }
 
 template <int N, bool _IS_SYM>
@@ -103,7 +103,7 @@ static inline void dequant_s8_N_avx2(float* dstptr, int8_t* srcptr, __m256* vsca
   static_assert(N % 8 == 0);
   int constexpr VLoop = N / 8;
   for (int iv = 0; iv < VLoop; iv += 1) {
-    auto src_s8 = _mm_loadl_epi64((__m128i*)(srcptr + iv * 8));
+    auto src_s8 = _mm_loadl_epi64(reinterpret_cast<__m128i*>(srcptr + iv * 8));
     auto zmm = _mm256_cvtepi8_epi32(src_s8);
     if constexpr (!_IS_SYM) zmm = _mm256_sub_epi32(zmm, vzps[iv]);
     auto fzmm = _mm256_cvtepi32_ps(zmm);
@@ -201,11 +201,11 @@ static inline JBLAS_CODE dequant_s32_fp32(const int32_t* srcptr, const int srcst
       if constexpr (std::is_same_v<SCAB_T, float>) {
         vwscale = _mm256_loadu_ps(scaleB + icol);
       } else if constexpr (std::is_same_v<SCAB_T, utils::bf16>) {
-        auto tmp = _mm_loadu_si128((__m128i*)(scaleB + icol));
+        auto tmp = _mm_loadu_si128(reinterpret_cast<__m128i*>(scaleB + icol));
         vwscale = ymm_cvt_bf16_fp32(tmp);
       }
       auto vscale = _mm256_mul_ps(valpha, vwscale);
-      auto vsrcd = _mm256_loadu_si256((__m256i*)(srcptr + irow * srcstep + icol));
+      auto vsrcd = _mm256_loadu_si256(reinterpret_cast<const __m256i*>(srcptr + irow * srcstep + icol));
       auto vsrc = _mm256_cvtepi32_ps(vsrcd);
       vsrc = _mm256_mul_ps(vsrc, vscale);
       _mm256_storeu_ps(dstptr + irow * dststep + icol, vsrc);
@@ -222,7 +222,7 @@ static inline JBLAS_CODE remove_act_zeropoint_bias(float* accptr, int ldacc, int
   int constexpr VLen = 8;
   auto col8 = utils::padto_le(col, VLen);
   for (int i = 0; i < row; i++) {
-    auto zpf = float(zps[i * lds]) * scales[i * lds];
+    auto zpf = static_cast<float>(zps[i * lds]) * scales[i * lds];
     int j = 0;
     auto vzp = _mm256_set1_ps(-zpf);
     for (; j < col8; j += VLen) {
@@ -249,7 +249,8 @@ static inline JBLAS_CODE remove_wei_zeropoint_bias(float* accptr, int ldacc, int
     auto vreduce = _mm256_set1_ps(-reduce[i * lds]);
     int j = 0;
     for (; j < col8; j += VLen) {
-      auto vzp_s32 = _mm256_cvtepi8_epi32(_mm_maskload_epi32((const int*)(zps + j), _mm_loadu_si128((__m128i*)mask)));
+      auto vzp_s32 = _mm256_cvtepi8_epi32(_mm_maskload_epi32(reinterpret_cast<const int*>(zps + j),
+                                                             _mm_loadu_si128(reinterpret_cast<const __m128i*>(mask))));
       auto vzp_f32 = _mm256_cvtepi32_ps(vzp_s32);
       auto vzp = _mm256_mul_ps(vzp_f32, _mm256_loadu_ps(scales + j));
       auto vacc = _mm256_loadu_ps(&accptr[i * ldacc + j]);
@@ -258,7 +259,7 @@ static inline JBLAS_CODE remove_wei_zeropoint_bias(float* accptr, int ldacc, int
     }
     if (j < col) {
       for (; j < col8; j++) {
-        accptr[i * ldacc + j] -= float(zps[j]) * scales[j] * reduce[i * lds];
+        accptr[i * ldacc + j] -= static_cast<float>(zps[j]) * scales[j] * reduce[i * lds];
       }
     }
   }
@@ -270,15 +271,16 @@ static inline JBLAS_CODE remove_zeropoint_bias(float* accptr, int ldacc, int row
                                                const float* reduceb) {
   int constexpr VLen = 8;
   auto col8 = utils::padto_le(col, VLen);
-  auto vk = _mm256_set1_ps((float)(k));
+  auto vk = _mm256_set1_ps(static_cast<float>(k));
   const int32_t mask[] = {-1, -1, 0, 0};
   for (int i = 0; i < row; i++) {
     auto vreducea = _mm256_set1_ps(-reducea[i * lds]);
-    auto zpaf = float(zpa[i * lds]) * scalea[i * lds];
+    auto zpaf = static_cast<float>(zpa[i * lds]) * scalea[i * lds];
     auto vzpa = _mm256_set1_ps(-zpaf);
     int j = 0;
     for (; j < col8; j += VLen) {
-      auto vzp_s32 = _mm256_cvtepi8_epi32(_mm_maskload_epi32((const int*)(zpb + j), _mm_loadu_si128((__m128i*)mask)));
+      auto vzp_s32 = _mm256_cvtepi8_epi32(_mm_maskload_epi32(reinterpret_cast<const int*>(zpb + j),
+                                                             _mm_loadu_si128(reinterpret_cast<const __m128i*>(mask))));
       auto vzp_f32 = _mm256_cvtepi32_ps(vzp_s32);
       auto vzpb = _mm256_mul_ps(vzp_f32, _mm256_loadu_ps(scaleb + j));
       auto vreduceb = _mm256_loadu_ps(reduceb + j);
@@ -291,9 +293,9 @@ static inline JBLAS_CODE remove_zeropoint_bias(float* accptr, int ldacc, int row
     }
     if (j < col) {
       for (; j < col8; j++) {
-        accptr[i * ldacc + j] -= float(zpb[j]) * scaleb[j] * reducea[i * lds];
+        accptr[i * ldacc + j] -= static_cast<float>(zpb[j]) * scaleb[j] * reducea[i * lds];
         accptr[i * ldacc + j] -= zpaf * reduceb[j];
-        accptr[i * ldacc + j] -= zpaf * float(zpb[j]) * scaleb[j] * k;
+        accptr[i * ldacc + j] -= zpaf * static_cast<float>(zpb[j]) * scaleb[j] * k;
       }
     }
   }
@@ -304,14 +306,14 @@ template <JBLAS_DTYPE S4_T>
 static inline JBLAS_CODE decompress_s4_s8(utils::int4x2* srcptr, int8_t* dstptr, int row, int col, int ld_src,
                                           int ld_dst) {
   uint32_t mask = 0xf0f0f0f0;
-  auto vmask = _mm256_set1_epi32(*(int*)&mask);
+  auto vmask = _mm256_set1_epi32(*reinterpret_cast<int*>(&mask));
   if (col == ld_src) {
-    size_t elesize = (size_t)row * col;
+    size_t elesize = static_cast<size_t>(row) * col;
     size_t ele16 = utils::padto_le(elesize, 16);
     size_t i = 0;
 #pragma unroll
     for (; i < ele16; i += 16) {
-      convert_s4_s8_16_sse<S4_T>(dstptr + i, (int8_t*)(srcptr + i / 2));
+      convert_s4_s8_16_sse<S4_T>(dstptr + i, reinterpret_cast<int8_t*>(srcptr + i / 2));
     }
     for (; i < elesize; i += 2) {
       auto tmp = srcptr[i / 2];
@@ -327,22 +329,22 @@ template <JBLAS_DTYPE S4_T, typename _DST_T>
 inline JBLAS_CODE decompress_kblock_s4_s8fp(utils::int4x2* srcptr, _DST_T* dstptr, int row, int col, int ld_src,
                                             int ld_dst, int8_t* tmp, size_t tmpsize) {
   uint32_t mask = 0xf0f0f0f0;
-  auto vmask = _mm256_set1_epi32(*(int*)&mask);
+  auto vmask = _mm256_set1_epi32(*reinterpret_cast<int*>(&mask));
   if (col == ld_src) {
-    size_t elesize = (size_t)row * col;
+    size_t elesize = static_cast<size_t>(row) * col;
     size_t ele16 = utils::padto_le(elesize, 16);
     size_t i = 0;
     assert(tmpsize >= 16);
 #pragma unroll
     for (; i < ele16; i += 16) {
-      convert_s4_s8_16_sse<S4_T>(tmp, (int8_t*)(srcptr + i / 2));
+      convert_s4_s8_16_sse<S4_T>(tmp, reinterpret_cast<int8_t*>(srcptr + i / 2));
       convert_s8_fp_v8(dstptr + i, tmp);
       convert_s8_fp_v8(dstptr + i + 8, tmp + 8);
     }
     for (; i < elesize; i += 2) {
       auto tmp = srcptr[i / 2];
-      dstptr[i + 0] = static_cast<_DST_T>(float(ref::get_s8<S4_T>(tmp.x)));
-      dstptr[i + 1] = static_cast<_DST_T>(float(ref::get_s8<S4_T>(tmp.y)));
+      dstptr[i + 0] = static_cast<_DST_T>(static_cast<float>(ref::get_s8<S4_T>(tmp.x)));
+      dstptr[i + 1] = static_cast<_DST_T>(static_cast<float>(ref::get_s8<S4_T>(tmp.y)));
     }
     return JblasSuccess;
   }
@@ -364,7 +366,7 @@ inline JBLAS_CODE decompress_kblock_s8_s8fp(int8_t* srcptr, DST_T* dstptr, int r
     }
     for (; i < elesize; i += 1) {
       auto tmp = srcptr[i];
-      dstptr[i] = static_cast<DST_T>(float(tmp));
+      dstptr[i] = static_cast<DST_T>(static_cast<float>(tmp));
     }
     return JblasSuccess;
   }
@@ -382,7 +384,7 @@ static inline JBLAS_CODE accum_alphaN_f32_f32(const SCA_T* alpha, const float* s
     if constexpr (std::is_same_v<SCA_T, float>) {
       valpha = _mm256_loadu_ps(alpha + j);
     } else if constexpr (std::is_same_v<SCA_T, utils::bf16>) {
-      auto tmp = _mm_loadu_si128((const __m128i*)(alpha + j));
+      auto tmp = _mm_loadu_si128(reinterpret_cast<const __m128i*>(alpha + j));
       valpha = ymm_cvt_bf16_fp32(tmp);
     }
     for (size_t i = 0; i < M; i++) {
@@ -416,7 +418,7 @@ static inline void dequant_f4_N(_DST_T* dstptr, int8_t* srcptr, __m256* vscales,
   int constexpr VLoop = N / 8;
 #pragma unroll(VLoop)
   for (int iv = 0; iv < VLoop; iv++) {
-    auto idx = _mm_loadl_epi64((__m128i*)(srcptr + iv * 8));
+    auto idx = _mm_loadl_epi64(reinterpret_cast<__m128i*>(srcptr + iv * 8));
     auto pad_idx = _mm256_cvtepu8_epi32(idx);
     auto fp32_dq_v = _mm256_i32gather_ps(LUT, pad_idx, 4);
     fp32_dq_v = _mm256_mul_ps(fp32_dq_v, vscales[iv]);
@@ -424,7 +426,7 @@ static inline void dequant_f4_N(_DST_T* dstptr, int8_t* srcptr, __m256* vscales,
       _mm256_storeu_ps(dstptr + iv * 8, fp32_dq_v);
     } else if constexpr (std::is_same_v<_DST_T, utils::bf16>) {
       auto bf16v = ymm_cvt_fp32_bf16(fp32_dq_v);
-      _mm_storeu_si128((__m128i*)(dstptr + iv * 8), bf16v);
+      _mm_storeu_si128(reinterpret_cast<__m128i*>(dstptr + iv * 8), bf16v);
     }
   }
 }
@@ -445,14 +447,14 @@ static inline void unpack_f4_N(_DST_T* dstptr, int8_t* srcptr) {
   int constexpr VLoop = N / 8;
 #pragma unroll(VLoop)
   for (int iv = 0; iv < VLoop; iv++) {
-    auto idx = _mm_loadl_epi64((__m128i*)(srcptr + iv * 8));
+    auto idx = _mm_loadl_epi64(reinterpret_cast<__m128i*>(srcptr + iv * 8));
     auto pad_idx = _mm256_cvtepu8_epi32(idx);
     auto fp32_dq_v = _mm256_i32gather_ps(LUT, pad_idx, 4);
     if constexpr (std::is_same_v<_DST_T, float>) {
       _mm256_storeu_ps(dstptr + iv * 8, fp32_dq_v);
     } else if constexpr (std::is_same_v<_DST_T, utils::bf16>) {
       auto bf16v = ymm_cvt_fp32_bf16(fp32_dq_v);
-      _mm_storeu_si128((__m128i*)(dstptr + iv * 8), bf16v);
+      _mm_storeu_si128(reinterpret_cast<__m128i*>(dstptr + iv * 8), bf16v);
     }
   }
 }
@@ -461,15 +463,15 @@ template <JBLAS_DTYPE F4_T, typename DST_T>
 inline JBLAS_CODE decompress_kblock_f4_fp_noscale(utils::f4x2* srcptr, DST_T* dstptr, int row, int col, int ld_src,
                                                   int ld_dst, int8_t* tmp, size_t tmpsize) {
   uint32_t mask = 0xf0f0f0f0;
-  auto vmask = _mm256_set1_epi32(*(int*)&mask);
+  auto vmask = _mm256_set1_epi32(*reinterpret_cast<int*>(&mask));
   if (col == ld_src) {
-    size_t elesize = (size_t)row * col;
+    size_t elesize = static_cast<size_t>(row) * col;
     size_t ele16 = utils::padto_le(elesize, 16);
     size_t i = 0;
     assert(tmpsize >= 16);
 #pragma unroll
     for (; i < ele16; i += 16) {
-      fp4_pad_4bit(tmp, (int8_t*)(srcptr + i / 2));
+      fp4_pad_4bit(tmp, reinterpret_cast<int8_t*>(srcptr + i / 2));
       unpack_f4_N<16, DST_T, F4_T>(dstptr + i, tmp);
     }
     for (; i < elesize; i += 2) {
@@ -490,7 +492,7 @@ static inline JBLAS_CODE decompress_kblock_bit4_packrow1(utils::bit4x2* srcptr,
                                                          void (*pad_bit4)(int8_t*, int8_t*), int8_t* tmpbuf,
                                                          size_t tmpsize) {
   uint32_t mask = 0xf0f0f0f0;
-  auto vmask = _mm256_set1_epi32(*(int*)&mask);
+  auto vmask = _mm256_set1_epi32(*reinterpret_cast<int*>(&mask));
   if (col == 48) {
     __m256 vscales[6];
     __m256i vzps[6];
@@ -507,19 +509,20 @@ static inline JBLAS_CODE decompress_kblock_bit4_packrow1(utils::bit4x2* srcptr,
       for (int iv = 0; iv < 6; iv++) {
         vscales[iv] = _mm256_loadu_ps(scales + (k_offset + irow) / kblock * NPad + iv * 8);
         if constexpr (!_IS_SYM) {
-          auto tmp = _mm_loadu_si64((__m128i*)(zero_points + (k_offset + irow) / kblock * NPad + iv * 8));
+          auto tmp =
+              _mm_loadu_si64(reinterpret_cast<__m128i*>(zero_points + (k_offset + irow) / kblock * NPad + iv * 8));
           vzps[iv] = _mm256_cvtepi8_epi32(tmp);
         }
       }
       for (; irow < rowpad4; irow += UnrollRow) {
         for (int iter16 = 0; iter16 < Loop16; iter16++)
-          pad_bit4(tmpbuf + iter16 * 16, (int8_t*)(srcptr + irow * ld_src / 2 + 8 * iter16));
+          pad_bit4(tmpbuf + iter16 * 16, reinterpret_cast<int8_t*>(srcptr + irow * ld_src / 2 + 8 * iter16));
         for (int iterr = 0; iterr < UnrollRow; iterr++)
           dequantize(dstptr + (irow + iterr) * ld_dst, tmpbuf + iterr * 48, vscales, vzps);
       }
       for (; irow < row0; irow++) {
         for (int iter16 = 0; iter16 < 3; iter16++)
-          pad_bit4(tmpbuf + iter16 * 16, (int8_t*)(srcptr + irow * ld_src / 2 + 8 * iter16));
+          pad_bit4(tmpbuf + iter16 * 16, reinterpret_cast<int8_t*>(srcptr + irow * ld_src / 2 + 8 * iter16));
         dequantize(dstptr + irow * ld_dst, tmpbuf, vscales, vzps);
       }
     }
@@ -533,13 +536,14 @@ static inline JBLAS_CODE decompress_kblock_bit4_packrow1(utils::bit4x2* srcptr,
       for (int iv = 0; iv < 6; iv++) {
         vscales[iv] = _mm256_loadu_ps(scales + (k_offset + irow) / kblock * NPad + iv * 8);
         if constexpr (!_IS_SYM) {
-          auto tmp = _mm_loadu_si64((__m128i*)(zero_points + (k_offset + irow) / kblock * NPad + iv * 8));
+          auto tmp =
+              _mm_loadu_si64(reinterpret_cast<__m128i*>(zero_points + (k_offset + irow) / kblock * NPad + iv * 8));
           vzps[iv] = _mm256_cvtepi8_epi32(tmp);
         }
       }
       for (int irr = 0; irr < kblock; irr += UnrollRow) {
         for (int iter16 = 0; iter16 < Loop16; iter16++)
-          pad_bit4(tmpbuf + iter16 * 16, (int8_t*)(srcptr + (irow + irr) * ld_src / 2 + 8 * iter16));
+          pad_bit4(tmpbuf + iter16 * 16, reinterpret_cast<int8_t*>(srcptr + (irow + irr) * ld_src / 2 + 8 * iter16));
         for (int iterr = 0; iterr < UnrollRow; iterr++)
           dequantize(dstptr + (irow + irr + iterr) * ld_src, tmpbuf + iterr * 48, vscales, vzps);
       }
@@ -548,13 +552,14 @@ static inline JBLAS_CODE decompress_kblock_bit4_packrow1(utils::bit4x2* srcptr,
       for (int iv = 0; iv < 6; iv++) {
         vscales[iv] = _mm256_loadu_ps(scales + (k_offset + irow) / kblock * NPad + iv * 8);
         if constexpr (!_IS_SYM) {
-          auto tmp = _mm_loadu_si64((__m128i*)(zero_points + (k_offset + irow) / kblock * NPad + iv * 8));
+          auto tmp =
+              _mm_loadu_si64(reinterpret_cast<__m128i*>(zero_points + (k_offset + irow) / kblock * NPad + iv * 8));
           vzps[iv] = _mm256_cvtepi8_epi32(tmp);
         }
       }
       for (; irow < row; irow++) {
         for (int iter16 = 0; iter16 < 3; iter16++)
-          pad_bit4(tmpbuf + iter16 * 16, (int8_t*)(srcptr + irow * ld_src / 2 + 8 * iter16));
+          pad_bit4(tmpbuf + iter16 * 16, reinterpret_cast<int8_t*>(srcptr + irow * ld_src / 2 + 8 * iter16));
         dequantize(dstptr + irow * ld_dst, tmpbuf, vscales, vzps);
       }
     }
@@ -685,7 +690,7 @@ static inline JBLAS_CODE quantize_fp_u8_colblock(int row, int col, const SRC_T*
           __m256 vsrc;
           if constexpr (std::is_same_v<SRC_T, float>) vsrc = _mm256_loadu_ps(&srcptr[(j + ij) + i * ld_src]);
           if constexpr (std::is_same_v<SRC_T, utils::bf16>) {
-            auto vtmp = _mm_loadu_si128((__m128i*)&srcptr[(j + ij) + i * ld_src]);
+            auto vtmp = _mm_loadu_si128(reinterpret_cast<__m128i*>(&srcptr[(j + ij) + i * ld_src]));
             vsrc = ymm_cvt_bf16_fp32(vtmp);
           }
           vsrc = _mm256_mul_ps(vsrc, vrscale);
@@ -695,14 +700,14 @@ static inline JBLAS_CODE quantize_fp_u8_colblock(int row, int col, const SRC_T*
           vdsrc = _mm256_min_epi32(vdsrc, vff);
           vdsrc = _mm256_max_epi32(vdsrc, v0);
           auto vbsrc = avx2_cvtepi32_epu8(vdsrc);
-          _mm_storel_epi64((__m128i*)&dstptr[(j + ij) + i * ld_dst], vbsrc);
+          _mm_storel_epi64(reinterpret_cast<__m128i*>(&dstptr[(j + ij) + i * ld_dst]), vbsrc);
         }
       } else {
         for (; ij < vblocksize; ij += VLen) {
           __m256 vsrc;
           if constexpr (std::is_same_v<SRC_T, float>) vsrc = _mm256_loadu_ps(&srcptr[(j + ij) + i * ld_src]);
           if constexpr (std::is_same_v<SRC_T, utils::bf16>) {
-            auto vtmp = _mm_loadu_si128((__m128i*)&srcptr[(j + ij) + i * ld_src]);
+            auto vtmp = _mm_loadu_si128(reinterpret_cast<__m128i*>(&srcptr[(j + ij) + i * ld_src]));
             vsrc = ymm_cvt_bf16_fp32(vtmp);
           }
           vsrc = _mm256_mul_ps(vsrc, vrscale);
@@ -711,7 +716,7 @@ static inline JBLAS_CODE quantize_fp_u8_colblock(int row, int col, const SRC_T*
           vdsrc = _mm256_min_epi32(vdsrc, vff);
           vdsrc = _mm256_max_epi32(vdsrc, v0);
           auto vbsrc = avx2_cvtepi32_epu8(vdsrc);
-          _mm_storel_epi64((__m128i*)&dstptr[(j + ij) + i * ld_dst], vbsrc);
+          _mm_storel_epi64(reinterpret_cast<__m128i*>(&dstptr[(j + ij) + i * ld_dst]), vbsrc);
         }
       }
       for (; ij < blocksize; ij++) {
@@ -833,8 +838,8 @@ static inline __m128i cvt_fp32_to_bf16(const __m256 src, __m256i* and_helper, __
 
 static inline JBLAS_CODE fp32_cvt_bf16_2D_write_back(const void* raw_srcptr, void* raw_dstptr, int row, int col,
                                                      int srcstride, int dststride, bool zeropadding) {
-  char* srcptr = (char*)raw_srcptr;
-  char* dstptr = (char*)raw_dstptr;
+  auto srcptr = reinterpret_cast<const char*>(raw_srcptr);
+  auto dstptr = reinterpret_cast<char*>(raw_dstptr);
   constexpr int simd_proc_elt = 8;
   auto bf16_and_helper = _mm256_set1_epi32(0X00000001);
   auto bf16_add_helper = _mm256_set1_epi32(0x00007FFF);
@@ -846,11 +851,11 @@ static inline JBLAS_CODE fp32_cvt_bf16_2D_write_back(const void* raw_srcptr, voi
     int j = 0;
     for (; j < col_body_loop; j += simd_proc_elt) {
       auto pack_bf16_value =
-          cvt_fp32_to_bf16(_mm256_loadu_ps(reinterpret_cast<float*>(src) + j), &bf16_and_helper, &bf16_add_helper);
-      _mm_storeu_si128((__m128i*)(dst + j * sizeof(jblas::utils::bf16)), pack_bf16_value);
+          cvt_fp32_to_bf16(_mm256_loadu_ps(reinterpret_cast<const float*>(src) + j), &bf16_and_helper, &bf16_add_helper);
+      _mm_storeu_si128(reinterpret_cast<__m128i*>(dst + j * sizeof(jblas::utils::bf16)), pack_bf16_value);
     }
     for (; j < col; j++) {
-      (reinterpret_cast<jblas::utils::bf16*>(dst) + j)->fromfloat(*(reinterpret_cast<float*>(src) + j));
+      (reinterpret_cast<jblas::utils::bf16*>(dst) + j)->fromfloat(*(reinterpret_cast<const float*>(src) + j));
     }
     if (zeropadding && npadding) {
       std::memset(dst + col * sizeof(utils::bf16), 0, npadding);
@@ -866,4 +871,4 @@ static inline JBLAS_CODE fp32_cvt_bf16_2D_write_back(const void* raw_srcptr, voi
 #endif
 }  // namespace avx2
 }  // namespace kernel
-}  // namespace jblas
\ No newline at end of file
+}  // namespace jblas
diff --git a/onnxruntime/core/mlas/lib/x86_64/jblas/jblas/kernel_avx512_bf16.h b/onnxruntime/core/mlas/lib/x86_64/jblas/jblas/kernel_avx512_bf16.h
index e319aaba7ce96..70cea4749aa79 100644
--- a/onnxruntime/core/mlas/lib/x86_64/jblas/jblas/kernel_avx512_bf16.h
+++ b/onnxruntime/core/mlas/lib/x86_64/jblas/jblas/kernel_avx512_bf16.h
@@ -53,8 +53,8 @@ static inline JBLAS_CODE bf16_cvt_fp32_2D_write_back(const utils::bf16* src_ptr,
 static inline JBLAS_CODE fp32_cvt_bf16_2D_write_back(const void* raw_srcptr, void* raw_dstptr, int row, int col,
                                                      int srcstride, int dststride, bool zeropadding) {
 #if CompileBF16()
-  char* srcptr = (char*)raw_srcptr;
-  char* dstptr = (char*)raw_dstptr;
+  auto srcptr = reinterpret_cast<const char*>(raw_srcptr);
+  auto dstptr = reinterpret_cast<char*>(raw_dstptr);
   constexpr int simd_proc_elt = 32;
   auto col_body_loop = col / simd_proc_elt;
   auto col_tail = col % simd_proc_elt;
@@ -89,4 +89,4 @@ static inline JBLAS_CODE fp32_cvt_bf16_2D_write_back(const void* raw_srcptr, voi
 #endif
 }  // namespace avx512_bf16
 }  // namespace kernel
-}  // namespace jblas
\ No newline at end of file
+}  // namespace jblas
diff --git a/onnxruntime/core/mlas/lib/x86_64/jblas/jblas/kernel_avx512f.h b/onnxruntime/core/mlas/lib/x86_64/jblas/jblas/kernel_avx512f.h
index dfe701e541b3d..4119c1d21c20a 100644
--- a/onnxruntime/core/mlas/lib/x86_64/jblas/jblas/kernel_avx512f.h
+++ b/onnxruntime/core/mlas/lib/x86_64/jblas/jblas/kernel_avx512f.h
@@ -67,7 +67,7 @@ static inline __m512i unpack_4bits(__m256i v4bits, __m512i vmask) {
 
 template <JBLAS_DTYPE S4_T>
 static inline void convert_s4_s8(int8_t* dstptr, int8_t* srcptr, __m512i vmask, int LoadMask) {
-  auto ymm = _mm256_maskz_loadu_epi32(__mmask8(LoadMask), (const __m256i*)(srcptr));
+  auto ymm = _mm256_maskz_loadu_epi32(__mmask8(LoadMask), reinterpret_cast<const __m256i*>(srcptr));
   auto zmm = unpack_4bits(ymm, vmask);
   if constexpr (S4_T == JBLAS_DTYPE::S4_FULLRANGE) {
     zmm = _mm512_srli_epi32(zmm, 4);
@@ -79,12 +79,12 @@ static inline void convert_s4_s8(int8_t* dstptr, int8_t* srcptr, __m512i vmask,
 
 template <typename T>
 static inline void convert_s8_fp_v16(T* dstptr, int8_t* srcptr) {
-  auto xmm = _mm_loadu_si128((const __m128i*)(srcptr));
+  auto xmm = _mm_loadu_si128(reinterpret_cast<const __m128i*>(srcptr));
   auto zmm = _mm512_cvtepi8_epi32(xmm);
   auto zmm1 = _mm512_cvtepi32_ps(zmm);
   if constexpr (std::is_same_v<T, utils::bf16>) {
     auto ymm = zmm_cvt_fp32_bf16(zmm1);
-    _mm256_storeu_si256((__m256i*)dstptr, ymm);
+    _mm256_storeu_si256(reinterpret_cast<__m256i*>(dstptr), ymm);
   } else {
     _mm512_storeu_ps(dstptr, zmm1);
   }
@@ -98,7 +98,7 @@ static inline void dequant_s8_N(_DST_T* dstptr, int8_t* srcptr, __m512* vscales,
   int constexpr VLoop = N / 16;
 #pragma unroll(VLoop)
   for (int iv = 0; iv < VLoop; iv += 1) {
-    auto src_s8 = _mm_loadu_si128((__m128i*)(srcptr + iv * 16));
+    auto src_s8 = _mm_loadu_si128(reinterpret_cast<__m128i*>(srcptr + iv * 16));
     auto zmm = _mm512_cvtepi8_epi32(src_s8);
     if constexpr (!_IS_SYM) zmm = _mm512_sub_epi32(zmm, vzps[iv]);
     auto fzmm = _mm512_cvtepi32_ps(zmm);
@@ -107,7 +107,7 @@ static inline void dequant_s8_N(_DST_T* dstptr, int8_t* srcptr, __m512* vscales,
       _mm512_storeu_ps(dstptr + iv * 16, fzmm);
     } else if constexpr (std::is_same<_DST_T, utils::bf16>::value) {
       auto bf16_v = zmm_cvt_fp32_bf16(fzmm);
-      _mm256_storeu_si256((__m256i*)(dstptr + iv * 16), bf16_v);
+      _mm256_storeu_si256(reinterpret_cast<__m256i*>(dstptr + iv * 16), bf16_v);
     } else {
       assert(false);
     }
@@ -130,7 +130,7 @@ static inline void dequant_f4_N(_DST_T* dstptr, int8_t* srcptr, __m512* vscales,
   }
 #pragma unroll(VLoop)
   for (int iv = 0; iv < VLoop; iv += 1) {
-    auto idx = _mm_loadu_si128((__m128i*)(srcptr + iv * 16));
+    auto idx = _mm_loadu_si128(reinterpret_cast<__m128i*>(srcptr + iv * 16));
     idx = _mm_srli_epi32(idx, 4);
     auto pad_idx = _mm512_cvtepu8_epi32(idx);
     auto lut = _mm512_loadu_si512(LUT);
@@ -140,7 +140,7 @@ static inline void dequant_f4_N(_DST_T* dstptr, int8_t* srcptr, __m512* vscales,
       _mm512_storeu_ps(dstptr + iv * 16, fzmm);
     } else if constexpr (std::is_same<_DST_T, utils::bf16>::value) {
       auto bf16_v = zmm_cvt_fp32_bf16(fzmm);
-      _mm256_storeu_si256((__m256i*)(dstptr + iv * 16), bf16_v);
+      _mm256_storeu_si256(reinterpret_cast<__m256i*>(dstptr + iv * 16), bf16_v);
     } else {
       assert(false);
     }
@@ -163,7 +163,7 @@ static inline void unpack_f4_N(_DST_T* dstptr, int8_t* srcptr) {
   }
 #pragma unroll(VLoop)
   for (int iv = 0; iv < VLoop; iv += 1) {
-    auto idx = _mm_loadu_si128((__m128i*)(srcptr + iv * 16));
+    auto idx = _mm_loadu_si128(reinterpret_cast<__m128i*>(srcptr + iv * 16));
     idx = _mm_srli_epi32(idx, 4);
     auto pad_idx = _mm512_cvtepu8_epi32(idx);
     auto lut = _mm512_loadu_si512(LUT);
@@ -173,7 +173,7 @@ static inline void unpack_f4_N(_DST_T* dstptr, int8_t* srcptr) {
       _mm512_storeu_ps(dstptr + iv * 16, fzmm);
     } else if constexpr (std::is_same<_DST_T, utils::bf16>::value) {
       auto bf16_v = zmm_cvt_fp32_bf16(fzmm);
-      _mm256_storeu_si256((__m256i*)(dstptr + iv * 16), bf16_v);
+      _mm256_storeu_si256(reinterpret_cast<__m256i*>(dstptr + iv * 16), bf16_v);
     } else {
       assert(false);
     }
@@ -187,7 +187,7 @@ static inline __m512 vec_loadscalex16(_ST* ptr) {
 
 template <>
 inline __m512 vec_loadscalex16(utils::bf16* ptr) {
-  auto vbf16 = _mm256_loadu_si256((__m256i*)ptr);
+  auto vbf16 = _mm256_loadu_si256(reinterpret_cast<__m256i*>(ptr));
   return zmm_cvt_bf16_fp32(vbf16);
 }
 
@@ -227,7 +227,7 @@ static inline JBLAS_CODE decompress_kblock_bit4_packrow1(utils::bit4x2* srcptr,
                                                          void (*pad_bit4)(int8_t*, int8_t*, __m512i, int),
                                                          int8_t* tmpbuf, size_t tmpsize) {
   uint32_t mask = 0xf0f0f0f0;
-  auto zmm_mask = _mm512_set1_epi32(*(int*)&mask);
+  auto zmm_mask = _mm512_set1_epi32(*reinterpret_cast<int*>(&mask));
   if (col == 48) {
     constexpr int ColTile = 48;
     constexpr int NRegs = ColTile / 16;
@@ -248,13 +248,15 @@ static inline JBLAS_CODE decompress_kblock_bit4_packrow1(utils::bit4x2* srcptr,
       for (int iv = 0; iv < 3; iv++) {
         vscales[iv] = vec_loadscalex16(scales + (k_offset + irow) / kblock * NPad + iv * 16);
         if constexpr (!_IS_SYM) {
-          auto tmp = _mm_loadu_si128((__m128i*)(zero_points + (k_offset + irow) / kblock * NPad + iv * 16));
+          auto tmp =
+              _mm_loadu_si128(reinterpret_cast<__m128i*>(zero_points + (k_offset + irow) / kblock * NPad + iv * 16));
           vzps[iv] = _mm512_cvtepi8_epi32(tmp);
         }
       }
       for (; irow < rowpad4; irow += UnrollRow) {
         for (int iter64 = 0; iter64 < Loop64; iter64++) {
-          pad_bit4(tmpbuf + iter64 * 64, (int8_t*)(srcptr + irow * ld_src / 2 + 32 * iter64), zmm_mask, LoadMask64);
+          pad_bit4(tmpbuf + iter64 * 64, reinterpret_cast<int8_t*>(srcptr + irow * ld_src / 2 + 32 * iter64), zmm_mask,
+                   LoadMask64);
         }
         for (int iterr = 0; iterr < UnrollRow; iterr++) {
           if constexpr (_IS_SYM) {
@@ -265,7 +267,7 @@ static inline JBLAS_CODE decompress_kblock_bit4_packrow1(utils::bit4x2* srcptr,
         }
       }
       for (; irow < row0; irow++) {
-        pad_bit4(tmpbuf, (int8_t*)(srcptr + irow * ld_src / 2), zmm_mask, LoadMask48);
+        pad_bit4(tmpbuf, reinterpret_cast<int8_t*>(srcptr + irow * ld_src / 2), zmm_mask, LoadMask48);
         if constexpr (_IS_SYM) {
           dequantize(dstptr + irow * ld_dst, tmpbuf, vscales, nullptr);
         } else {
@@ -282,15 +284,16 @@ static inline JBLAS_CODE decompress_kblock_bit4_packrow1(utils::bit4x2* srcptr,
       for (int iv = 0; iv < 3; iv++) {
         vscales[iv] = vec_loadscalex16(scales + (k_offset + irow) / kblock * NPad + iv * 16);
         if constexpr (!_IS_SYM) {
-          auto tmp = _mm_loadu_si128((__m128i*)(zero_points + (k_offset + irow) / kblock * NPad + iv * 16));
+          auto tmp =
+              _mm_loadu_si128(reinterpret_cast<__m128i*>(zero_points + (k_offset + irow) / kblock * NPad + iv * 16));
           vzps[iv] = _mm512_cvtepi8_epi32(tmp);
         }
       }
 
       for (int irr = 0; irr < kblock; irr += UnrollRow) {
         for (int iter64 = 0; iter64 < Loop64; iter64++) {
-          pad_bit4(tmpbuf + iter64 * 64, (int8_t*)(srcptr + (irow + irr) * ld_src / 2 + 32 * iter64), zmm_mask,
-                   LoadMask64);
+          pad_bit4(tmpbuf + iter64 * 64, reinterpret_cast<int8_t*>(srcptr + (irow + irr) * ld_src / 2 + 32 * iter64),
+                   zmm_mask, LoadMask64);
         }
         for (int iterr = 0; iterr < UnrollRow; iterr++) {
           if constexpr (_IS_SYM) {
@@ -305,13 +308,14 @@ static inline JBLAS_CODE decompress_kblock_bit4_packrow1(utils::bit4x2* srcptr,
       for (int iv = 0; iv < 3; iv++) {
         vscales[iv] = vec_loadscalex16(scales + (k_offset + irow) / kblock * NPad + iv * 16);
         if constexpr (!_IS_SYM) {
-          auto tmp = _mm_loadu_si128((__m128i*)(zero_points + (k_offset + irow) / kblock * NPad + iv * 16));
+          auto tmp =
+              _mm_loadu_si128(reinterpret_cast<__m128i*>(zero_points + (k_offset + irow) / kblock * NPad + iv * 16));
           vzps[iv] = _mm512_cvtepi8_epi32(tmp);
         }
       }
     }
     for (; irow < row; irow++) {
-      pad_bit4(tmpbuf, (int8_t*)(srcptr + irow * ld_src / 2), zmm_mask, LoadMask48);
+      pad_bit4(tmpbuf, reinterpret_cast<int8_t*>(srcptr + irow * ld_src / 2), zmm_mask, LoadMask48);
       if constexpr (_IS_SYM) {
         dequantize(dstptr + irow * ld_dst, tmpbuf, vscales, nullptr);
       } else {
@@ -331,7 +335,7 @@ static inline JBLAS_CODE decompress_kblock_bit4_packrow2(utils::bit4x2* srcptr,
                                                          void (*pad_bit4)(int8_t*, int8_t*, __m512i, int),
                                                          int8_t* tmpbuf, size_t tmpsize) {
   uint32_t mask = 0xf0f0f0f0;
-  auto zmm_mask = _mm512_set1_epi32(*(int*)&mask);
+  auto zmm_mask = _mm512_set1_epi32(*reinterpret_cast<int*>(&mask));
   auto broadcast_idx = _mm512_setr_epi64(0, 4, 1, 5, 2, 6, 3, 7);
   auto broadcast_idx_128 = _mm_setr_epi16(0, 1, 2, 3, 4, 5, 6, 7);
   if (col % 64 == 0) {
@@ -352,15 +356,15 @@ static inline JBLAS_CODE decompress_kblock_bit4_packrow2(utils::bit4x2* srcptr,
           auto tmpscale = vec_loadscalex16(scales + (k_offset + irow) / kblock * NPad + iv * 16 + icol / 2);
           vec_broadcast_ps_1_2(vscales + iv * 2, &tmpscale, broadcast_idx);
           if constexpr (!_IS_SYM) {
-            auto tmpzp =
-                _mm_loadu_si128((__m128i*)(zero_points + (k_offset + irow) / kblock * NPad + iv * 16 + icol / 2));
+            auto tmpzp = _mm_loadu_si128(
+                reinterpret_cast<__m128i*>(zero_points + (k_offset + irow) / kblock * NPad + iv * 16 + icol / 2));
             auto vzp = _mm512_cvtepi8_epi32(tmpzp);
             vec_broadcast_epi32_1_2(vzps + iv * 2, &vzp, broadcast_idx);
           }
         }
 
         for (; irow < row0; irow++) {
-          pad_bit4(tmpbuf, (int8_t*)(srcptr + irow * ld_src / 2 + icol / 2), zmm_mask, LoadMask64);
+          pad_bit4(tmpbuf, reinterpret_cast<int8_t*>(srcptr + irow * ld_src / 2 + icol / 2), zmm_mask, LoadMask64);
           if constexpr (_IS_SYM) {
             dequantize(dstptr + irow * ld_dst + icol, tmpbuf, vscales, nullptr);
           } else {
@@ -375,15 +379,16 @@ static inline JBLAS_CODE decompress_kblock_bit4_packrow2(utils::bit4x2* srcptr,
           auto tmpscale = vec_loadscalex16(scales + (k_offset + irow) / kblock * NPad + iv * 16 + icol / 2);
           vec_broadcast_ps_1_2(vscales + iv * 2, &tmpscale, broadcast_idx);
           if constexpr (!_IS_SYM) {
-            auto tmpzp =
-                _mm_loadu_si128((__m128i*)(zero_points + (k_offset + irow) / kblock * NPad + iv * 16 + icol / 2));
+            auto tmpzp = _mm_loadu_si128(
+                reinterpret_cast<__m128i*>(zero_points + (k_offset + irow) / kblock * NPad + iv * 16 + icol / 2));
             auto vzp = _mm512_cvtepi8_epi32(tmpzp);
             vec_broadcast_epi32_1_2(vzps + iv * 2, &vzp, broadcast_idx);
           }
         }
 
         for (int irr = 0; irr < kblock; irr += 1) {
-          pad_bit4(tmpbuf, (int8_t*)(srcptr + (irow + irr) * ld_src / 2 + icol / 2), zmm_mask, LoadMask64);
+          pad_bit4(tmpbuf, reinterpret_cast<int8_t*>(srcptr + (irow + irr) * ld_src / 2 + icol / 2), zmm_mask,
+                   LoadMask64);
           if constexpr (_IS_SYM) {
             dequantize(dstptr + (irow + irr) * ld_dst + icol, tmpbuf, vscales, nullptr);
           } else {
@@ -396,15 +401,15 @@ static inline JBLAS_CODE decompress_kblock_bit4_packrow2(utils::bit4x2* srcptr,
           auto tmpscale = vec_loadscalex16(scales + (k_offset + irow) / kblock * NPad + iv * 16 + icol / 2);
           vec_broadcast_ps_1_2(vscales + iv * 2, &tmpscale, broadcast_idx);
           if constexpr (!_IS_SYM) {
-            auto tmpzp =
-                _mm_loadu_si128((__m128i*)(zero_points + (k_offset + irow) / kblock * NPad + iv * 16 + icol / 2));
+            auto tmpzp = _mm_loadu_si128(
+                reinterpret_cast<__m128i*>(zero_points + (k_offset + irow) / kblock * NPad + iv * 16 + icol / 2));
             auto vzp = _mm512_cvtepi8_epi32(tmpzp);
             vec_broadcast_epi32_1_2(vzps + iv * 2, &vzp, broadcast_idx);
           }
         }
       }
       for (; irow < row; irow++) {
-        pad_bit4(tmpbuf, (int8_t*)(srcptr + irow * ld_src / 2 + icol / 2), zmm_mask, LoadMask64);
+        pad_bit4(tmpbuf, reinterpret_cast<int8_t*>(srcptr + irow * ld_src / 2 + icol / 2), zmm_mask, LoadMask64);
         if constexpr (_IS_SYM) {
           dequantize(dstptr + irow * ld_dst + icol, tmpbuf, vscales, nullptr);
         } else {
@@ -466,7 +471,7 @@ template <JBLAS_DTYPE F4_T, typename DST_T>
 inline JBLAS_CODE decompress_kblock_f4_fp_noscale(utils::f4x2* srcptr, DST_T* dstptr, int row, int col, int ld_src,
                                                   int ld_dst, int8_t* tmp, size_t tmpsize) {
   uint32_t mask = 0xf0f0f0f0;
-  auto zmm_mask = _mm512_set1_epi32(*(int*)&mask);
+  auto zmm_mask = _mm512_set1_epi32(*reinterpret_cast<int*>(&mask));
   if (col == ld_src) {
     size_t elesize = (size_t)row * col;
     size_t ele256 = utils::padto_le(elesize, 256);
@@ -475,17 +480,17 @@ inline JBLAS_CODE decompress_kblock_f4_fp_noscale(utils::f4x2* srcptr, DST_T* ds
     size_t i = 0;
     constexpr int LoadMask64 = (1 << (64 / 8)) - 1;
     for (; i < ele256; i += 256) {
-      pad_fp4(tmp + 0, (int8_t*)(srcptr + i / 2 + 0), zmm_mask, LoadMask64);
-      pad_fp4(tmp + 64, (int8_t*)(srcptr + i / 2 + 32), zmm_mask, LoadMask64);
-      pad_fp4(tmp + 128, (int8_t*)(srcptr + i / 2 + 64), zmm_mask, LoadMask64);
-      pad_fp4(tmp + 192, (int8_t*)(srcptr + i / 2 + 96), zmm_mask, LoadMask64);
+      pad_fp4(tmp + 0, reinterpret_cast<int8_t*>(srcptr + i / 2 + 0), zmm_mask, LoadMask64);
+      pad_fp4(tmp + 64, reinterpret_cast<int8_t*>(srcptr + i / 2 + 32), zmm_mask, LoadMask64);
+      pad_fp4(tmp + 128, reinterpret_cast<int8_t*>(srcptr + i / 2 + 64), zmm_mask, LoadMask64);
+      pad_fp4(tmp + 192, reinterpret_cast<int8_t*>(srcptr + i / 2 + 96), zmm_mask, LoadMask64);
       for (size_t j = 0; j < 256; j += 64) {
         unpack_f4_N<64, DST_T, F4_T>(dstptr + i + j, tmp + j);
       }
     }
     if (i + 64 <= ele64) {
       for (; i < ele64; i += 64) {
-        pad_fp4(tmp, (int8_t*)(srcptr + i / 2), zmm_mask, LoadMask64);
+        pad_fp4(tmp, reinterpret_cast<int8_t*>(srcptr + i / 2), zmm_mask, LoadMask64);
         unpack_f4_N<64, DST_T, F4_T>(dstptr + i, tmp);
       }
     }
@@ -503,7 +508,7 @@ template <JBLAS_DTYPE S4_T>
 static inline JBLAS_CODE decompress_s4_s8(utils::int4x2* srcptr, int8_t* dstptr, int row, int col, int ld_src,
                                           int ld_dst) {
   uint32_t mask = 0xf0f0f0f0;
-  auto zmm_mask = _mm512_set1_epi32(*(int*)&mask);
+  auto zmm_mask = _mm512_set1_epi32(*reinterpret_cast<int*>(&mask));
   if (col == ld_src) {
     size_t elesize = (size_t)row * col;
     size_t ele256 = utils::padto_le(elesize, 256);
@@ -511,14 +516,14 @@ static inline JBLAS_CODE decompress_s4_s8(utils::int4x2* srcptr, int8_t* dstptr,
     size_t i = 0;
     constexpr int LoadMask64 = (1 << (64 / 8)) - 1;
     for (; i < ele256; i += 256) {
-      convert_s4_s8<S4_T>(dstptr + i + 0, (int8_t*)(srcptr + i / 2 + 0), zmm_mask, LoadMask64);
-      convert_s4_s8<S4_T>(dstptr + i + 64, (int8_t*)(srcptr + i / 2 + 32), zmm_mask, LoadMask64);
-      convert_s4_s8<S4_T>(dstptr + i + 128, (int8_t*)(srcptr + i / 2 + 64), zmm_mask, LoadMask64);
-      convert_s4_s8<S4_T>(dstptr + i + 192, (int8_t*)(srcptr + i / 2 + 96), zmm_mask, LoadMask64);
+      convert_s4_s8<S4_T>(dstptr + i + 0, reinterpret_cast<int8_t*>(srcptr + i / 2 + 0), zmm_mask, LoadMask64);
+      convert_s4_s8<S4_T>(dstptr + i + 64, reinterpret_cast<int8_t*>(srcptr + i / 2 + 32), zmm_mask, LoadMask64);
+      convert_s4_s8<S4_T>(dstptr + i + 128, reinterpret_cast<int8_t*>(srcptr + i / 2 + 64), zmm_mask, LoadMask64);
+      convert_s4_s8<S4_T>(dstptr + i + 192, reinterpret_cast<int8_t*>(srcptr + i / 2 + 96), zmm_mask, LoadMask64);
     }
     if (i + 64 <= ele64) {
       for (; i < ele64; i += 64) {
-        convert_s4_s8<S4_T>(dstptr + i, (int8_t*)(srcptr + i / 2), zmm_mask, LoadMask64);
+        convert_s4_s8<S4_T>(dstptr + i, reinterpret_cast<int8_t*>(srcptr + i / 2), zmm_mask, LoadMask64);
       }
     }
     for (; i < elesize; i += 2) {
@@ -556,7 +561,7 @@ static inline JBLAS_CODE quantize_f32_sign_int_rowblock_sym(const float* srcptr,
         vsrc = _mm512_mul_ps(vsrc, vrscale);
         auto vdsrc = _mm512_cvtps_epi32(vsrc);
         auto vbsrc = _mm512_cvtepi32_epi8(vdsrc);
-        _mm_storeu_si128((__m128i*)&dstptr[(j + ij) * ld_dst + i], vbsrc);
+        _mm_storeu_si128(reinterpret_cast<__m128i*>(&dstptr[(j + ij) * ld_dst + i]), vbsrc);
       }
     };
     for (; j < align_row; j += blocksize) simd_process_block(blocksize);
@@ -612,13 +617,13 @@ static inline JBLAS_CODE quantize_f32_sign_int_rowblock_asym(const float* srcptr
       auto vmedium = _mm512_div_ps(vsum, v2);
       vzp = _mm512_mul_ps(_mm512_sub_ps(v0, vmedium), vrscale);
       auto vbzp = _mm512_cvtsepi32_epi8(_mm512_cvtps_epi32(vzp));
-      _mm_storeu_si128((__m128i*)&zero_points[j / blocksize * ld_dst + i], vbzp);
+      _mm_storeu_si128(reinterpret_cast<__m128i*>(&zero_points[j / blocksize * ld_dst + i]), vbzp);
       for (size_t ij = 0; ij < size; ij++) {
         auto vsrc = _mm512_loadu_ps(&srcptr[(j + ij) * ld_src + i]);
         vsrc = _mm512_mul_ps(_mm512_sub_ps(vsrc, vmedium), vrscale);
         auto vdsrc = _mm512_cvtps_epi32(vsrc);
         auto vbsrc = _mm512_cvtsepi32_epi8(vdsrc);
-        _mm_storeu_si128((__m128i*)&dstptr[(j + ij) * ld_dst + i], vbsrc);
+        _mm_storeu_si128(reinterpret_cast<__m128i*>(&dstptr[(j + ij) * ld_dst + i]), vbsrc);
       }
     };
     for (; j < align_row; j += blocksize) simd_process_block(blocksize);
@@ -730,10 +735,10 @@ inline void f32_f4_quantize_4x16(const float* srcptr, int8_t* dstptr, int ld_src
     mask1 = _mm512_cmple_ps_mask(zmm5, zmm_v0);
     mask2 = _mm512_cmple_ps_mask(zmm6, zmm_v0);
     mask3 = _mm512_cmple_ps_mask(zmm7, zmm_v0);
-    xmm0 = _mm_mask_blend_epi8(mask0, xmm0, _mm_loadu_si128((const __m128i*)(broadcast_f4_v + i * 16)));
-    xmm1 = _mm_mask_blend_epi8(mask1, xmm1, _mm_loadu_si128((const __m128i*)(broadcast_f4_v + i * 16)));
-    xmm2 = _mm_mask_blend_epi8(mask2, xmm2, _mm_loadu_si128((const __m128i*)(broadcast_f4_v + i * 16)));
-    xmm3 = _mm_mask_blend_epi8(mask3, xmm3, _mm_loadu_si128((const __m128i*)(broadcast_f4_v + i * 16)));
+    xmm0 = _mm_mask_blend_epi8(mask0, xmm0, _mm_loadu_si128(reinterpret_cast<const __m128i*>(broadcast_f4_v + i * 16)));
+    xmm1 = _mm_mask_blend_epi8(mask1, xmm1, _mm_loadu_si128(reinterpret_cast<const __m128i*>(broadcast_f4_v + i * 16)));
+    xmm2 = _mm_mask_blend_epi8(mask2, xmm2, _mm_loadu_si128(reinterpret_cast<const __m128i*>(broadcast_f4_v + i * 16)));
+    xmm3 = _mm_mask_blend_epi8(mask3, xmm3, _mm_loadu_si128(reinterpret_cast<const __m128i*>(broadcast_f4_v + i * 16)));
     zmm0 = _mm512_mask_add_ps(zmm0, mask0, zmm0, avoid_double_cmp);
     zmm1 = _mm512_mask_add_ps(zmm1, mask1, zmm1, avoid_double_cmp);
     zmm2 = _mm512_mask_add_ps(zmm2, mask2, zmm2, avoid_double_cmp);
@@ -778,7 +783,7 @@ inline void f32_f4_quantize_1x16(const float* srcptr, int8_t* dstptr, int ld_src
     if constexpr (F4_T == JBLAS_DTYPE::F4_E2M1) sub_v = _mm512_set1_ps(F4_E2M1_quant_sub_helper[i]);
     zmm1 = _mm512_sub_ps(zmm0, sub_v);
     mask0 = _mm512_cmple_ps_mask(zmm1, zmm_v0);
-    xmm0 = _mm_mask_blend_epi8(mask0, xmm0, _mm_loadu_si128((const __m128i*)(broadcast_f4_v + i * 16)));
+    xmm0 = _mm_mask_blend_epi8(mask0, xmm0, _mm_loadu_si128(reinterpret_cast<const __m128i*>(broadcast_f4_v + i * 16)));
     zmm0 = _mm512_mask_add_ps(zmm0, mask0, zmm0, avoid_double_cmp);
   }
   if constexpr (F4_T != JBLAS_DTYPE::F4_NF4) {
@@ -882,7 +887,7 @@ static inline JBLAS_CODE quantize_fp_u8_colblock(int row, int col, const SRC_T*
       auto minval = _mm512_reduce_min_ps(vminval);
       if (ij < blocksize) {
         for (; ij < blocksize; ij++) {
-          auto srcval = (float)srcptr[(j + ij) + i * ld_src];
+          auto srcval = static_cast<float>(srcptr[(j + ij) + i * ld_src]);
           maxval = std::max(maxval, srcval);
           minval = std::min(minval, srcval);
         }
@@ -912,10 +917,10 @@ static inline JBLAS_CODE quantize_fp_u8_colblock(int row, int col, const SRC_T*
         vdsrc = _mm512_min_epi32(vdsrc, vff);
         vdsrc = _mm512_max_epi32(vdsrc, v0);
         auto vbsrc = _mm512_cvtepi32_epi8(vdsrc);
-        _mm_storeu_si128((__m128i*)&dstptr[(j + ij) + i * ld_dst], vbsrc);
+        _mm_storeu_si128(reinterpret_cast<__m128i*>(&dstptr[(j + ij) + i * ld_dst]), vbsrc);
       }
       for (; ij < blocksize; ij++) {
-        auto srcval = (float)srcptr[(j + ij) + i * ld_src];
+        auto srcval = static_cast<float>(srcptr[(j + ij) + i * ld_src]);
         srcval = srcval * rscale;
         auto srcint = utils::cast<float, int>(srcval);
         sum += srcint;
@@ -933,7 +938,7 @@ static inline JBLAS_CODE quantize_fp_u8_colblock(int row, int col, const SRC_T*
       float maxval = 0.f;
       float minval = 0.f;
       for (size_t ij = j; ij < col; ij++) {
-        auto fsrc = float(srcptr[ij + i * ld_src]);
+        auto fsrc = static_cast<float>(srcptr[ij + i * ld_src]);
         maxval = std::max(fsrc, maxval);
         minval = std::min(fsrc, minval);
       }
@@ -944,7 +949,7 @@ static inline JBLAS_CODE quantize_fp_u8_colblock(int row, int col, const SRC_T*
       zps[j / blocksize + i * ld_scale] = zp;
       int sum = 0;
       for (size_t ij = j; ij < col; ij++) {
-        auto fsrc = float(srcptr[ij + i * ld_src]);
+        auto fsrc = static_cast<float>(srcptr[ij + i * ld_src]);
         auto srcint = utils::cast<float, int>(fsrc * rscale);
         sum += srcint;
         srcint += zp;
@@ -987,7 +992,7 @@ static inline JBLAS_CODE quantize_fp_s8_colblock(int row, int col, const SRC_T*
       auto maxval = _mm512_reduce_max_ps(vmaxval);
       if (ij < blocksize) {
         for (; ij < blocksize; ij++) {
-          auto srcval = std::abs((float)srcptr[(j + ij) + i * ld_src]);
+          auto srcval = std::abs(static_cast<float>(srcptr[(j + ij) + i * ld_src]));
           maxval = std::max(maxval, srcval);
         }
       }
@@ -1011,11 +1016,11 @@ static inline JBLAS_CODE quantize_fp_s8_colblock(int row, int col, const SRC_T*
         vdsrc = _mm512_min_epi32(vdsrc, vpos);
         vdsrc = _mm512_max_epi32(vdsrc, vneg);
         auto vbsrc = _mm512_cvtepi32_epi8(vdsrc);
-        _mm_storeu_si128((__m128i*)&dstptr[(j + ij) + i * ld_dst], vbsrc);
+        _mm_storeu_si128(reinterpret_cast<__m128i*>(&dstptr[(j + ij) + i * ld_dst]), vbsrc);
       }
       if (ij < blocksize) {
         for (; ij < blocksize; ij++) {
-          auto srcval = (float)srcptr[(j + ij) + i * ld_src];
+          auto srcval = static_cast<float>(srcptr[(j + ij) + i * ld_src]);
           srcval = srcval * rscale;
           auto srcint = int(roundf(srcval));
           sum += srcint;
@@ -1084,7 +1089,7 @@ template <JBLAS_DTYPE S4_T, typename _DST_T>
 inline JBLAS_CODE decompress_kblock_s4_s8fp(utils::int4x2* srcptr, _DST_T* dstptr, int row, int col, int ld_src,
                                             int ld_dst, int8_t* tmp, size_t tmpsize) {
   uint32_t mask = 0xf0f0f0f0;
-  auto zmm_mask = _mm512_set1_epi32(*(int*)&mask);
+  auto zmm_mask = _mm512_set1_epi32(*reinterpret_cast<int*>(&mask));
   if (col == ld_src) {
     size_t elesize = (size_t)row * col;
     size_t ele256 = utils::padto_le(elesize, 256);
@@ -1093,17 +1098,17 @@ inline JBLAS_CODE decompress_kblock_s4_s8fp(utils::int4x2* srcptr, _DST_T* dstpt
     size_t i = 0;
     constexpr int LoadMask64 = (1 << (64 / 8)) - 1;
     for (; i < ele256; i += 256) {
-      convert_s4_s8<S4_T>(tmp + 0, (int8_t*)(srcptr + i / 2 + 0), zmm_mask, LoadMask64);
-      convert_s4_s8<S4_T>(tmp + 64, (int8_t*)(srcptr + i / 2 + 32), zmm_mask, LoadMask64);
-      convert_s4_s8<S4_T>(tmp + 128, (int8_t*)(srcptr + i / 2 + 64), zmm_mask, LoadMask64);
-      convert_s4_s8<S4_T>(tmp + 192, (int8_t*)(srcptr + i / 2 + 96), zmm_mask, LoadMask64);
+      convert_s4_s8<S4_T>(tmp + 0, reinterpret_cast<int8_t*>(srcptr + i / 2 + 0), zmm_mask, LoadMask64);
+      convert_s4_s8<S4_T>(tmp + 64, reinterpret_cast<int8_t*>(srcptr + i / 2 + 32), zmm_mask, LoadMask64);
+      convert_s4_s8<S4_T>(tmp + 128, reinterpret_cast<int8_t*>(srcptr + i / 2 + 64), zmm_mask, LoadMask64);
+      convert_s4_s8<S4_T>(tmp + 192, reinterpret_cast<int8_t*>(srcptr + i / 2 + 96), zmm_mask, LoadMask64);
       for (size_t j = 0; j < 256; j += 16) {
         convert_s8_fp_v16(dstptr + i + j, tmp + j);
       }
     }
     if (i + 64 <= ele64) {
       for (; i < ele64; i += 64) {
-        convert_s4_s8<S4_T>(tmp, (int8_t*)(srcptr + i / 2), zmm_mask, LoadMask64);
+        convert_s4_s8<S4_T>(tmp, reinterpret_cast<int8_t*>(srcptr + i / 2), zmm_mask, LoadMask64);
         for (size_t j = 0; j < 64; j += 16) {
           convert_s8_fp_v16(dstptr + i + j, tmp + j);
         }
@@ -1111,8 +1116,8 @@ inline JBLAS_CODE decompress_kblock_s4_s8fp(utils::int4x2* srcptr, _DST_T* dstpt
     }
     for (; i < elesize; i += 2) {
       auto tmp = srcptr[i / 2];
-      dstptr[i + 0] = static_cast<_DST_T>(float(jblas::kernel::ref::get_s8<S4_T>(tmp.x)));
-      dstptr[i + 1] = static_cast<_DST_T>(float(jblas::kernel::ref::get_s8<S4_T>(tmp.y)));
+      dstptr[i + 0] = static_cast<_DST_T>(static_cast<float>(jblas::kernel::ref::get_s8<S4_T>(tmp.x)));
+      dstptr[i + 1] = static_cast<_DST_T>(static_cast<float>(jblas::kernel::ref::get_s8<S4_T>(tmp.y)));
     }
     return JblasSuccess;
   }
@@ -1134,7 +1139,7 @@ inline JBLAS_CODE decompress_kblock_s8_s8fp(int8_t* srcptr, DST_T* dstptr, int r
     }
     for (; i < elesize; i += 1) {
       auto tmp = srcptr[i];
-      dstptr[i] = static_cast<DST_T>(float(tmp));
+      dstptr[i] = static_cast<DST_T>(static_cast<float>(tmp));
     }
     return JblasSuccess;
   }
@@ -1152,7 +1157,7 @@ static inline JBLAS_CODE accum_alphaN_f32_f32(const SCA_T* alpha, const float* s
     if constexpr (std::is_same_v<SCA_T, float>) {
       valpha = _mm512_loadu_ps(alpha + j);
     } else if constexpr (std::is_same_v<SCA_T, utils::bf16>) {
-      auto tmp = _mm256_loadu_si256((const __m256i*)(alpha + j));
+      auto tmp = _mm256_loadu_si256(reinterpret_cast<const __m256i*>(alpha + j));
       valpha = zmm_cvt_bf16_fp32(tmp);
     }
     for (size_t i = 0; i < M; i++) {
@@ -1164,7 +1169,7 @@ static inline JBLAS_CODE accum_alphaN_f32_f32(const SCA_T* alpha, const float* s
   }
   for (; j < N; j += 1) {
     for (size_t i = 0; i < M; i++) {
-      dstptr[i * dststep + j] += float(alpha[j]) * srcptr[i * srcstep + j];
+      dstptr[i * dststep + j] += static_cast<float>(alpha[j]) * srcptr[i * srcstep + j];
     }
   }
   return JblasSuccess;
@@ -1200,7 +1205,7 @@ static inline void vec_quanout_s32_u32_v16(const int32_t* srcptr, __m512& vfacto
   vsrcd = _mm512_max_epi32(vsrcd, vzeros);
   vsrcd = _mm512_min_epi32(vsrcd, v255);
   auto vdstb = _mm512_cvtepi32_epi8(vsrcd);
-  _mm_storeu_si128((__m128i*)dstptr, vdstb);
+  _mm_storeu_si128(reinterpret_cast<__m128i*>(dstptr), vdstb);
 }
 
 static inline JBLAS_CODE quanout_s32_u32(const float alpha, const int32_t* srcptr, const int srcstep, uint8_t* dstptr,
@@ -1236,8 +1241,8 @@ static inline JBLAS_CODE quanout_s32_u32(const float alpha, const int32_t* srcpt
       }
     }
     for (; j < N; j++) {
-      float fsrc = float(srcptr[i * srcstep + j]) * factor;
-      dstptr[i * dststep + j] = utils::cast<float, uint8_t>(fsrc + float(zpDst));
+      float fsrc = static_cast<float>(srcptr[i * srcstep + j]) * factor;
+      dstptr[i * dststep + j] = utils::cast<float, uint8_t>(fsrc + static_cast<float>(zpDst));
     }
   }
   return JblasSuccess;
@@ -1286,7 +1291,7 @@ static inline JBLAS_CODE dequant_s32_fp32(const int32_t* srcptr, const int srcst
         if constexpr (std::is_same_v<SCAB_T, float>) {
           vwscale = _mm512_loadu_ps(scaleB + icol + ic * 16);
         } else if constexpr (std::is_same_v<SCAB_T, utils::bf16>) {
-          auto tmp = _mm256_loadu_si256((const __m256i*)(scaleB + icol + ic * 16));
+          auto tmp = _mm256_loadu_si256(reinterpret_cast<const __m256i*>(scaleB + icol + ic * 16));
           vwscale = zmm_cvt_bf16_fp32(tmp);
         }
         auto vscale = _mm512_mul_ps(valpha, vwscale);
@@ -1302,7 +1307,7 @@ static inline JBLAS_CODE dequant_s32_fp32(const int32_t* srcptr, const int srcst
         if constexpr (std::is_same_v<SCAB_T, float>) {
           vwscale = _mm512_loadu_ps(scaleB + icol);
         } else if constexpr (std::is_same_v<SCAB_T, utils::bf16>) {
-          auto tmp = _mm256_loadu_si256((const __m256i*)(scaleB + icol));
+          auto tmp = _mm256_loadu_si256(reinterpret_cast<const __m256i*>(scaleB + icol));
           vwscale = zmm_cvt_bf16_fp32(tmp);
         }
         auto vscale = _mm512_mul_ps(valpha, vwscale);
@@ -1330,7 +1335,7 @@ static inline JBLAS_CODE broadcast_u8(int num, const uint8_t& srcval, uint8_t* d
   int num32 = utils::padto_le(num, 32);
   if (i + 32 <= num32) {
     for (; i < num32; i += 32) {
-      _mm256_storeu_si256((__m256i*)(dstptr + i), _mm512_castsi512_si256(vsrc));
+      _mm256_storeu_si256(reinterpret_cast<__m256i*>(dstptr + i), _mm512_castsi512_si256(vsrc));
     }
   }
   for (; i < num; i++) {
@@ -1344,7 +1349,7 @@ static inline JBLAS_CODE remove_act_zeropoint_bias(float* accptr, int ldacc, int
   int constexpr VLen = 16;
   auto col16 = utils::padto_le(col, VLen);
   for (int i = 0; i < row; i++) {
-    auto zpf = float(zps[i * lds]) * scales[i * lds];
+    auto zpf = static_cast<float>(zps[i * lds]) * scales[i * lds];
     int j = 0;
     auto vzp = _mm512_set1_ps(-zpf);
     for (; j < col16; j += VLen) {
@@ -1370,7 +1375,7 @@ static inline JBLAS_CODE remove_wei_zeropoint_bias(float* accptr, int ldacc, int
     auto vreduce = _mm512_set1_ps(-reduce[i * lds]);
     int j = 0;
     for (; j < col16; j += VLen) {
-      auto vzp_s32 = _mm512_cvtepi8_epi32(_mm_loadu_si128((__m128i*)(zps + j)));
+      auto vzp_s32 = _mm512_cvtepi8_epi32(_mm_loadu_si128(reinterpret_cast<__m128i*>(zps + j)));
       auto vzp_f32 = _mm512_cvtepi32_ps(vzp_s32);
       auto vzp = _mm512_mul_ps(vzp_f32, _mm512_loadu_ps(scales + j));
       auto vacc = _mm512_loadu_ps(&accptr[i * ldacc + j]);
@@ -1379,7 +1384,7 @@ static inline JBLAS_CODE remove_wei_zeropoint_bias(float* accptr, int ldacc, int
     }
     if (j < col) {
       for (; j < col16; j++) {
-        accptr[i * ldacc + j] -= float(zps[j]) * scales[j] * reduce[i * lds];
+        accptr[i * ldacc + j] -= static_cast<float>(zps[j]) * scales[j] * reduce[i * lds];
       }
     }
   }
@@ -1391,14 +1396,14 @@ static inline JBLAS_CODE remove_zeropoint_bias(float* accptr, int ldacc, int row
                                                const float* reduceb) {
   int constexpr VLen = 16;
   auto col16 = utils::padto_le(col, VLen);
-  auto vk = _mm512_set1_ps((float)(k));
+  auto vk = _mm512_set1_ps(static_cast<float>(k));
   for (int i = 0; i < row; i++) {
     auto vreducea = _mm512_set1_ps(-reducea[i * lds]);
-    auto zpaf = float(zpa[i * lds]) * scalea[i * lds];
+    auto zpaf = static_cast<float>(zpa[i * lds]) * scalea[i * lds];
     auto vzpa = _mm512_set1_ps(-zpaf);
     int j = 0;
     for (; j < col16; j += VLen) {
-      auto vzp_s32 = _mm512_cvtepi8_epi32(_mm_loadu_si128((__m128i*)(zpb + j)));
+      auto vzp_s32 = _mm512_cvtepi8_epi32(_mm_loadu_si128(reinterpret_cast<__m128i*>(zpb + j)));
       auto vzp_f32 = _mm512_cvtepi32_ps(vzp_s32);
       auto vzpb = _mm512_mul_ps(vzp_f32, _mm512_loadu_ps(scaleb + j));
       auto vreduceb = _mm512_loadu_ps(reduceb + j);
@@ -1411,7 +1416,7 @@ static inline JBLAS_CODE remove_zeropoint_bias(float* accptr, int ldacc, int row
     }
     if (j < col) {
       for (; j < col16; j++) {
-        float zpbf = float(zpb[j]) * scaleb[j];
+        float zpbf = static_cast<float>(zpb[j]) * scaleb[j];
         accptr[i * ldacc + j] -= zpbf * reducea[i * lds];
         accptr[i * ldacc + j] -= zpaf * reduceb[j];
         accptr[i * ldacc + j] -= zpaf * zpbf * k;
@@ -1423,8 +1428,8 @@ static inline JBLAS_CODE remove_zeropoint_bias(float* accptr, int ldacc, int row
 
 static inline JBLAS_CODE fp32_cvt_bf16_2D_write_back(const void* raw_srcptr, void* raw_dstptr, int row, int col,
                                                      int srcstride, int dststride, bool zeropadding) {
-  char* srcptr = (char*)raw_srcptr;
-  char* dstptr = (char*)raw_dstptr;
+  auto srcptr = reinterpret_cast<const char*>(raw_srcptr);
+  auto dstptr = reinterpret_cast<char*>(raw_dstptr);
   constexpr int simd_proc_elt = 16;
   auto col_body_loop = col / simd_proc_elt;
   auto col_tail = col % simd_proc_elt;
@@ -1442,7 +1447,8 @@ static inline JBLAS_CODE fp32_cvt_bf16_2D_write_back(const void* raw_srcptr, voi
       round_bias = _mm512_add_epi32(round_bias, bf16_add_helper);
       auto round_fp32_v = _mm512_add_epi32(round_bias, _mm512_loadu_si512(src + sizeof(float) * simd_proc_elt * j));
       auto pack_bf16_value = _mm512_cvtepi32_epi16(_mm512_srli_epi32(round_fp32_v, 16));
-      _mm256_storeu_si256((__m256i*)(dst + (j * simd_proc_elt) * sizeof(jblas::utils::bf16)), pack_bf16_value);
+      _mm256_storeu_si256(reinterpret_cast<__m256i*>(dst + (j * simd_proc_elt) * sizeof(jblas::utils::bf16)),
+                          pack_bf16_value);
     }
     if (col_tail > 0) {
       auto round_bias = _mm512_maskz_loadu_epi32(tail_mask, src + sizeof(float) * simd_proc_elt * j);
@@ -1451,8 +1457,8 @@ static inline JBLAS_CODE fp32_cvt_bf16_2D_write_back(const void* raw_srcptr, voi
       auto round_fp32_v =
           _mm512_add_epi32(round_bias, _mm512_maskz_loadu_epi32(tail_mask, src + sizeof(float) * simd_proc_elt * j));
       auto pack_bf16_tail = _mm512_cvtepi32_epi16(_mm512_srli_epi32(round_fp32_v, 16));
-      _mm256_mask_storeu_epi16((__m256i*)(dst + (j * simd_proc_elt) * sizeof(jblas::utils::bf16)), tail_mask,
-                               pack_bf16_tail);
+      _mm256_mask_storeu_epi16(reinterpret_cast<__m256i*>(dst + (j * simd_proc_elt) * sizeof(jblas::utils::bf16)),
+                               tail_mask, pack_bf16_tail);
     }
     if (zeropadding && npadding) {
       std::memset(dst + col * sizeof(utils::bf16), 0, npadding);
diff --git a/onnxruntime/core/mlas/lib/x86_64/jblas/jblas/kernel_jit.h b/onnxruntime/core/mlas/lib/x86_64/jblas/jblas/kernel_jit.h
index e1e61372c38a9..85241b31c7213 100644
--- a/onnxruntime/core/mlas/lib/x86_64/jblas/jblas/kernel_jit.h
+++ b/onnxruntime/core/mlas/lib/x86_64/jblas/jblas/kernel_jit.h
@@ -183,8 +183,14 @@ class DequanS8F32 {
                               int8_t* zero_points) {
     static MicroKernelAVX512F mAVX512FSym(true);
     static MicroKernelAVX512F mAVX512FASym(false);
-    auto param = MicroKernelAVX512F::params{
-        srcptr, dstptr, row, col, int(ld_src * sizeof(int8_t)), int(ld_dst * sizeof(float)), scales, zero_points};
+    auto param = MicroKernelAVX512F::params{srcptr,
+                                            dstptr,
+                                            row,
+                                            col,
+                                            static_cast<int>(ld_src * sizeof(int8_t)),
+                                            static_cast<int>(ld_dst * sizeof(float)),
+                                            scales,
+                                            zero_points};
     if (zero_points == nullptr) {
       mAVX512FSym.mKernel(&param);
     } else {
@@ -255,13 +261,13 @@ class JitMemcpy2DAvx2 : protected jblas::xbyak::JitAvx2 {
     static JitMemcpy2DAvx2 instance_withops(1, p);
     static JitMemcpy2DAvx2 instance2_withops(2, p);
     static_assert(sizeof(_SRC_T) == sizeof(_DST_T));  // TODO SRC_T DST_T conversion copy
-    auto param = params{(void*)srcptr,
-                        (void*)dstptr,
+    auto param = params{reinterpret_cast<void*>(const_cast<_SRC_T*>(srcptr)),
+                        reinterpret_cast<void*>(dstptr),
                         elt_const_v,
                         row,
-                        int(col * sizeof(_SRC_T)),
-                        int(srcstep * sizeof(_SRC_T)),
-                        int(dststep * sizeof(_DST_T))};
+                        static_cast<int>(col * sizeof(_SRC_T)),
+                        static_cast<int>(srcstep * sizeof(_SRC_T)),
+                        static_cast<int>(dststep * sizeof(_DST_T))};
     int row2 = utils::padto_le(row, 2);
     if (row2) {
       param.row = row2;
@@ -269,8 +275,8 @@ class JitMemcpy2DAvx2 : protected jblas::xbyak::JitAvx2 {
     }
     int rowtail = row - row2;
     if (rowtail) {
-      param.srcptr = (char*)param.srcptr + row2 * srcstep * sizeof(_SRC_T);
-      param.dstptr = (char*)param.dstptr + row2 * dststep * sizeof(_DST_T);
+      param.srcptr = reinterpret_cast<char*>(param.srcptr) + row2 * srcstep * sizeof(_SRC_T);
+      param.dstptr = reinterpret_cast<char*>(param.dstptr) + row2 * dststep * sizeof(_DST_T);
       param.row = rowtail;
       instance_withops.mKernel(&param);
     }
@@ -286,13 +292,13 @@ class JitMemcpy2DAvx2 : protected jblas::xbyak::JitAvx2 {
     static JitMemcpy2DAvx2 instance_withops(1, {kernel::jit_injector::eltwise_injector(Op)});
     static JitMemcpy2DAvx2 instance2_withops(2, {kernel::jit_injector::eltwise_injector(Op)});
     static_assert(sizeof(_SRC_T) == sizeof(_DST_T));  // TODO SRC_T DST_T conversion copy
-    auto param = params{(void*)srcptr,
-                        (void*)dstptr,
+    auto param = params{reinterpret_cast<void*>(const_cast<_SRC_T*>(srcptr)),
+                        reinterpret_cast<void*>(dstptr),
                         elt_const_v,
                         row,
-                        int(col * sizeof(_SRC_T)),
-                        int(srcstep * sizeof(_SRC_T)),
-                        int(dststep * sizeof(_DST_T))};
+                        static_cast<int>(col * sizeof(_SRC_T)),
+                        static_cast<int>(srcstep * sizeof(_SRC_T)),
+                        static_cast<int>(dststep * sizeof(_DST_T))};
     int row2 = utils::padto_le(row, 2);
     if (row2) {
       param.row = row2;
@@ -300,8 +306,8 @@ class JitMemcpy2DAvx2 : protected jblas::xbyak::JitAvx2 {
     }
     int rowtail = row - row2;
     if (rowtail) {
-      param.srcptr = (char*)param.srcptr + row2 * srcstep * sizeof(_SRC_T);
-      param.dstptr = (char*)param.dstptr + row2 * dststep * sizeof(_DST_T);
+      param.srcptr = reinterpret_cast<char*>(param.srcptr) + row2 * srcstep * sizeof(_SRC_T);
+      param.dstptr = reinterpret_cast<char*>(param.dstptr) + row2 * dststep * sizeof(_DST_T);
       param.row = rowtail;
       instance_withops.mKernel(&param);
     }
@@ -482,13 +488,13 @@ class JitMemcpy2DAvx512f : protected jblas::xbyak::JitAvx512f {
     static JitMemcpy2DAvx512f instance_withops(1, p);
     static JitMemcpy2DAvx512f instance4_withops(4, p);
     static_assert(sizeof(_SRC_T) == sizeof(_DST_T));  // TODO SRC_T DST_T conversion copy
-    auto param = params{(void*)srcptr,
-                        (void*)dstptr,
+    auto param = params{reinterpret_cast<void*>(const_cast<_SRC_T*>(srcptr)),
+                        reinterpret_cast<void*>(dstptr),
                         elt_const_v,
                         row,
-                        int(col * sizeof(_SRC_T)),
-                        int(srcstep * sizeof(_SRC_T)),
-                        int(dststep * sizeof(_DST_T))};
+                        static_cast<int>(col * sizeof(_SRC_T)),
+                        static_cast<int>(srcstep * sizeof(_SRC_T)),
+                        static_cast<int>(dststep * sizeof(_DST_T))};
     int row4 = utils::padto_le(row, 4);
     if (row4) {
       param.row = row4;
@@ -496,8 +502,8 @@ class JitMemcpy2DAvx512f : protected jblas::xbyak::JitAvx512f {
     }
     int rowtail = row - row4;
     if (rowtail) {
-      param.srcptr = (char*)param.srcptr + row4 * srcstep * sizeof(_SRC_T);
-      param.dstptr = (char*)param.dstptr + row4 * dststep * sizeof(_DST_T);
+      param.srcptr = reinterpret_cast<char*>(param.srcptr) + row4 * srcstep * sizeof(_SRC_T);
+      param.dstptr = reinterpret_cast<char*>(param.dstptr) + row4 * dststep * sizeof(_DST_T);
       param.row = rowtail;
       instance_withops.mKernel(&param);
     }
@@ -510,13 +516,13 @@ class JitMemcpy2DAvx512f : protected jblas::xbyak::JitAvx512f {
     static JitMemcpy2DAvx512f instance_withops(1, {kernel::jit_injector::eltwise_injector(Op)});
     static JitMemcpy2DAvx512f instance4_withops(4, {kernel::jit_injector::eltwise_injector(Op)});
     static_assert(sizeof(_SRC_T) == sizeof(_DST_T));  // TODO SRC_T DST_T conversion copy
-    auto param = params{(void*)srcptr,
-                        (void*)dstptr,
+    auto param = params{reinterpret_cast<void*>(const_cast<_SRC_T*>(srcptr)),
+                        reinterpret_cast<void*>(dstptr),
                         elt_const_v,
                         row,
-                        int(col * sizeof(_SRC_T)),
-                        int(srcstep * sizeof(_SRC_T)),
-                        int(dststep * sizeof(_DST_T))};
+                        static_cast<int>(col * sizeof(_SRC_T)),
+                        static_cast<int>(srcstep * sizeof(_SRC_T)),
+                        static_cast<int>(dststep * sizeof(_DST_T))};
     int row4 = utils::padto_le(row, 4);
     if (row4) {
       param.row = row4;
@@ -524,8 +530,8 @@ class JitMemcpy2DAvx512f : protected jblas::xbyak::JitAvx512f {
     }
     int rowtail = row - row4;
     if (rowtail) {
-      param.srcptr = (char*)param.srcptr + row4 * srcstep * sizeof(_SRC_T);
-      param.dstptr = (char*)param.dstptr + row4 * dststep * sizeof(_DST_T);
+      param.srcptr = reinterpret_cast<char*>(param.srcptr) + row4 * srcstep * sizeof(_SRC_T);
+      param.dstptr = reinterpret_cast<char*>(param.dstptr) + row4 * dststep * sizeof(_DST_T);
       param.row = rowtail;
       instance_withops.mKernel(&param);
     }
@@ -779,7 +785,7 @@ class DecompressS4S8_AVX512F : protected jblas::xbyak::JitAvx512f {
 
 static inline JBLAS_CODE decompress_s4_s8(utils::int4x2* srcptr, int8_t* dstptr, int row, int col, int ld_src,
                                           int ld_dst) {
-  if (col != ld_src) {  // memory is not continueous
+  if (col != ld_src) {  // memory is not continuous
     return JblasNotSupport;
   }
   DecompressS4S8_AVX512F::forward(srcptr, dstptr, (size_t)row * col);
@@ -1115,7 +1121,7 @@ class PaddingTransInterleaveCvt : protected xbyak::JitAvx512f {
     jmp(ptr[reg_tmp + reg_tmp2 * sizeof(void*)], T_NEAR);  // switch(rows-iterrow) ...
     align(sizeof(intptr_t));
     L(l_tail_tbl);
-    db(reinterpret_cast<uintptr_t>(nullptr), sizeof(intptr_t));  // case 0 should never occour
+    db(reinterpret_cast<uintptr_t>(nullptr), sizeof(intptr_t));  // case 0 should never occur
     for (int i = 1; i < trans_cell; ++i) putL(l_tail_case[i]);
 
     for (int m_tail = 1; m_tail < trans_cell; ++m_tail) {  // case (m_tail):
@@ -1276,13 +1282,13 @@ class CScaleInterleavedBF16FP16 : protected xbyak::JitAvx512_fp16 {
           vpmovzxwd(vreg1, yword[reg_src + (i * n_tile + j * row_pack) * sizeof(utils::bf16) + 32]);
           vpslldq(vreg0, vreg0, 2);
           vpslldq(vreg1, vreg1, 2);
-          vcvtps2phx(Ymm(vreg0.getIdx()), vreg0);
-          vcvtps2phx(Ymm(vreg1.getIdx()), vreg1);
+          vcvtps2phx(Xbyak::Ymm(vreg0.getIdx()), vreg0);
+          vcvtps2phx(Xbyak::Ymm(vreg1.getIdx()), vreg1);
           // #UD If (dest_reg == src1_reg) or (dest_reg == src2_reg)
-          vfmulcph(Ymm(vreg2.getIdx()), Ymm(vreg0.getIdx()), Ymm(vreg_scale.getIdx()));
-          vfmulcph(Ymm(vreg3.getIdx()), Ymm(vreg1.getIdx()), Ymm(vreg_scale.getIdx()));
-          vcvtph2psx(vreg0, Ymm(vreg2.getIdx()));
-          vcvtph2psx(vreg1, Ymm(vreg3.getIdx()));
+          vfmulcph(Xbyak::Ymm(vreg2.getIdx()), Xbyak::Ymm(vreg0.getIdx()), Xbyak::Ymm(vreg_scale.getIdx()));
+          vfmulcph(Xbyak::Ymm(vreg3.getIdx()), Xbyak::Ymm(vreg1.getIdx()), Xbyak::Ymm(vreg_scale.getIdx()));
+          vcvtph2psx(vreg0, Xbyak::Ymm(vreg2.getIdx()));
+          vcvtph2psx(vreg1, Xbyak::Ymm(vreg3.getIdx()));
           vcvtne2ps2bf16(vreg0, vreg1, vreg0);
           vmovups(zword[reg_src + (i * n_tile + j * row_pack) * sizeof(utils::bf16)] | mask, vreg0);
         }
@@ -1296,13 +1302,13 @@ class CScaleInterleavedBF16FP16 : protected xbyak::JitAvx512_fp16 {
           vpmovzxwd(vreg1, yword[reg_src + (i * n_tile + j * row_pack) * sizeof(utils::bf16) + 32]);
           vpslldq(vreg0, vreg0, 2);
           vpslldq(vreg1, vreg1, 2);
-          vcvtps2phx(Ymm(vreg0.getIdx()), vreg0);
-          vcvtps2phx(Ymm(vreg1.getIdx()), vreg1);
+          vcvtps2phx(Xbyak::Ymm(vreg0.getIdx()), vreg0);
+          vcvtps2phx(Xbyak::Ymm(vreg1.getIdx()), vreg1);
           // #UD If (dest_reg == src1_reg) or (dest_reg == src2_reg)
-          vfmulcph(Ymm(vreg2.getIdx()), Ymm(vreg0.getIdx()), Ymm(vreg_scale.getIdx()));
-          vfmulcph(Ymm(vreg3.getIdx()), Ymm(vreg1.getIdx()), Ymm(vreg_scale.getIdx()));
-          vcvtph2psx(vreg0, Ymm(vreg2.getIdx()));
-          vcvtph2psx(vreg1, Ymm(vreg3.getIdx()));
+          vfmulcph(Xbyak::Ymm(vreg2.getIdx()), Xbyak::Ymm(vreg0.getIdx()), Xbyak::Ymm(vreg_scale.getIdx()));
+          vfmulcph(Xbyak::Ymm(vreg3.getIdx()), Xbyak::Ymm(vreg1.getIdx()), Xbyak::Ymm(vreg_scale.getIdx()));
+          vcvtph2psx(vreg0, Xbyak::Ymm(vreg2.getIdx()));
+          vcvtph2psx(vreg1, Xbyak::Ymm(vreg3.getIdx()));
           vcvtne2ps2bf16(vreg0, vreg1, vreg0);
           vmovups(zword[reg_src + (i * n_tile + j * row_pack) * sizeof(utils::bf16)], vreg0);
         }
diff --git a/onnxruntime/core/mlas/lib/x86_64/jblas/jblas/kernel_jit_injector.h b/onnxruntime/core/mlas/lib/x86_64/jblas/jblas/kernel_jit_injector.h
index 0f04924d0c601..d3e49eecd6b4e 100644
--- a/onnxruntime/core/mlas/lib/x86_64/jblas/jblas/kernel_jit_injector.h
+++ b/onnxruntime/core/mlas/lib/x86_64/jblas/jblas/kernel_jit_injector.h
@@ -25,12 +25,13 @@
 #include "jit_blas.h"
 #include "jit_blas_utils.h"
 #include "xbyak/xbyak.h"
-using Zmm = Xbyak::Zmm;
-using Ymm = Xbyak::Ymm;
-using Xmm = Xbyak::Xmm;
+
 namespace jblas {
 namespace kernel {
 namespace jit_injector {
+using Zmm = Xbyak::Zmm;
+using Ymm = Xbyak::Ymm;
+using Xmm = Xbyak::Xmm;
 class eltwise_injector {
  public:
   eltwise_injector(JBLAS_ELTWISEOP eltwiseop) : elt_op(eltwiseop) { reigster_table_entries(); }
@@ -651,7 +652,7 @@ class eltwise_injector {
       h->vgatherdps(vmm_coeff, idx_addr, ymm_mask);
     };
 
-    // because tanh(x) = -tanh(-x), we extract sign to make x postive
+    // because tanh(x) = -tanh(-x), we extract sign to make x positive
     // and reapply sign at the end
     h->vmovups(ymm_src_original, ymm_src);
     h->vandps(ymm_src, ymm_src, table_val(positive_mask));
@@ -723,7 +724,7 @@ class eltwise_injector {
       h->vpermt2ps(zmm_coeff, zmm_pol_idx, coeffs_address(coeff_idx, 16));
     };
 
-    // because tanh(x) = -tanh(-x), we extract sign to make x postive
+    // because tanh(x) = -tanh(-x), we extract sign to make x positive
     // and reapply sign at the end
     h->vmovups(zmm_src_original, zmm_src);
     h->vpandd(zmm_src, zmm_src, table_val(positive_mask));
diff --git a/onnxruntime/core/mlas/lib/x86_64/jblas/jblas/kernel_ref.h b/onnxruntime/core/mlas/lib/x86_64/jblas/jblas/kernel_ref.h
index cbce84985b94e..6e00704395ed3 100644
--- a/onnxruntime/core/mlas/lib/x86_64/jblas/jblas/kernel_ref.h
+++ b/onnxruntime/core/mlas/lib/x86_64/jblas/jblas/kernel_ref.h
@@ -13,7 +13,8 @@
 //  limitations under the License.
 #pragma once
 #include <vector>
-
+#include <algorithm>
+#include <limits>
 #include "jit_blas_utils.h"
 
 namespace jblas {
@@ -107,7 +108,7 @@ static inline JBLAS_CODE dequan_s8_f32(int8_t* srcptr, float* dstptr, int row, i
                                        float* scales) {
   for (int i = 0; i < row; i++) {
     for (int j = 0; j < col; j++) {
-      dstptr[i * ld_dst + j] = float(srcptr[i * ld_src + j]) * scales[j];
+      dstptr[i * ld_dst + j] = static_cast<float>(srcptr[i * ld_src + j]) * scales[j];
     }
   }
   return JblasSuccess;
@@ -118,7 +119,7 @@ static inline JBLAS_CODE dequan_s8_bf16(int8_t* srcptr, uint16_t* dstptr, int ro
   for (int i = 0; i < row; i++) {
     for (int j = 0; j < col; j++) {
       dstptr[i * ld_dst + j] =
-          jblas::utils::cast<float, jblas::utils::bf16>(float(srcptr[i * ld_src + j]) * scales[j]).x;
+          jblas::utils::cast<float, jblas::utils::bf16>(static_cast<float>(srcptr[i * ld_src + j]) * scales[j]).x;
     }
   }
   return JblasSuccess;
@@ -169,8 +170,8 @@ static inline JBLAS_CODE decompress_s4_f32(jblas::utils::int4x2* srcptr, float*
     for (int j = 0; j < col; j += 2) {
       auto tmp = srcptr[i * ld_src / 2 + j / 2];
       auto noffset = i * NTile + j % NTile;
-      dstptr[i * ld_dst + j + 0] = float((int8_t)tmp.x << 4) * scales[noffset + 0];
-      dstptr[i * ld_dst + j + 1] = float((int8_t)tmp.y << 4) * scales[noffset + 1];
+      dstptr[i * ld_dst + j + 0] = static_cast<float>(static_cast<int8_t>(tmp.x) << 4) * scales[noffset + 0];
+      dstptr[i * ld_dst + j + 1] = static_cast<float>(static_cast<int8_t>(tmp.y) << 4) * scales[noffset + 1];
     }
   }
   return JblasSuccess;
@@ -188,7 +189,7 @@ inline int8_t get_s8(int8_t v) {
       assert(false);
       break;
   }
-  return int8_t(0);
+  return static_cast<int8_t>(0);
 }
 
 template <JBLAS_DTYPE S4_T>
@@ -210,8 +211,8 @@ inline JBLAS_CODE decompress_kblock_s8_f32(int8_t* srcptr, _DST_T* dstptr, int r
     int kpos = (k_offset + i) / kblock;
     auto sptr = scales + kpos * NPad;
     for (int j = 0; j < col; j += 1) {
-      float tmp = (float)(srcptr[i * ld_src + j]);
-      if (zero_points != nullptr) tmp -= (float)(zero_points[kpos * NPad + j]);
+      float tmp = static_cast<float>(srcptr[i * ld_src + j]);
+      if (zero_points != nullptr) tmp -= static_cast<float>(zero_points[kpos * NPad + j]);
       dstptr[i * ld_dst + j] = static_cast<_DST_T>(tmp * sptr[j / _PACK_ROW]);
     }
   }
@@ -231,14 +232,16 @@ inline JBLAS_CODE decompress_kblock_s4_fp(utils::int4x2* srcptr, _DST_T* dstptr,
       int s0_idx, s1_idx;
       s0_idx = j / _PACK_ROW;
       s1_idx = (j + 1) / _PACK_ROW;
-      scale0 = float(sptr[s0_idx]);
-      scale1 = float(sptr[s1_idx]);
+      scale0 = static_cast<float>(sptr[s0_idx]);
+      scale1 = static_cast<float>(sptr[s1_idx]);
       if (zero_points != nullptr) {
-        dst0 = (float(get_s8<S4_T>(tmp.x)) - float((zero_points + kpos * NPad)[s0_idx])) * scale0;
-        dst1 = (float(get_s8<S4_T>(tmp.y)) - float((zero_points + kpos * NPad)[s1_idx])) * scale1;
+        dst0 = (static_cast<float>(get_s8<S4_T>(tmp.x)) - static_cast<float>((zero_points + kpos * NPad)[s0_idx])) *
+               scale0;
+        dst1 = (static_cast<float>(get_s8<S4_T>(tmp.y)) - static_cast<float>((zero_points + kpos * NPad)[s1_idx])) *
+               scale1;
       } else {
-        dst0 = float(get_s8<S4_T>(tmp.x)) * scale0;
-        dst1 = float(get_s8<S4_T>(tmp.y)) * scale1;
+        dst0 = static_cast<float>(get_s8<S4_T>(tmp.x)) * scale0;
+        dst1 = static_cast<float>(get_s8<S4_T>(tmp.y)) * scale1;
       }
       dstptr[i * ld_dst + j + 0] = static_cast<_DST_T>(dst0);
       dstptr[i * ld_dst + j + 1] = static_cast<_DST_T>(dst1);
@@ -253,8 +256,8 @@ inline JBLAS_CODE decompress_kblock_s4_s8fp(utils::int4x2* srcptr, _DST_T* dstpt
   for (int i = 0; i < row; i++) {
     for (int j = 0; j < col; j += 2) {
       auto tmp = srcptr[i * ld_src / 2 + j / 2];
-      dstptr[i * ld_dst + j + 0] = static_cast<_DST_T>(float(get_s8<S4_T>(tmp.x)));
-      dstptr[i * ld_dst + j + 1] = static_cast<_DST_T>(float(get_s8<S4_T>(tmp.y)));
+      dstptr[i * ld_dst + j + 0] = static_cast<_DST_T>(static_cast<float>(get_s8<S4_T>(tmp.x)));
+      dstptr[i * ld_dst + j + 1] = static_cast<_DST_T>(static_cast<float>(get_s8<S4_T>(tmp.y)));
     }
   }
   return JblasSuccess;
@@ -265,7 +268,7 @@ inline JBLAS_CODE decompress_kblock_s8_s8fp(int8_t* srcptr, DST_T* dstptr, int r
   for (int i = 0; i < row; i++) {
     for (int j = 0; j < col; j += 1) {
       auto tmp = srcptr[i * ld_src + j];
-      dstptr[i * ld_dst + j] = static_cast<DST_T>(float(tmp));
+      dstptr[i * ld_dst + j] = static_cast<DST_T>(static_cast<float>(tmp));
     }
   }
   return JblasSuccess;
@@ -515,7 +518,7 @@ inline int8_t f4_quantize(float x) {
     default:
       break;
   }
-  return int8_t(0);
+  return static_cast<int8_t>(0);
 }
 
 template <JBLAS_DTYPE F4_T, typename _DST_T, int _PACK_ROW, typename _S_T>
@@ -531,8 +534,8 @@ inline JBLAS_CODE decompress_kblock_f4_fp(utils::f4x2* srcptr, _DST_T* dstptr, i
       int s0_idx, s1_idx;
       s0_idx = j / _PACK_ROW;
       s1_idx = (j + 1) / _PACK_ROW;
-      scale0 = float(sptr[s0_idx]);
-      scale1 = float(sptr[s1_idx]);
+      scale0 = static_cast<float>(sptr[s0_idx]);
+      scale1 = static_cast<float>(sptr[s1_idx]);
       dst0 = f4_dequantize<F4_T>(tmp.x, scale0);
       dst1 = f4_dequantize<F4_T>(tmp.y, scale1);
       dstptr[i * ld_dst + j + 0] = static_cast<_DST_T>(dst0);
@@ -610,7 +613,7 @@ inline JBLAS_CODE quantize_f32_sign_int_rowblock(const float* srcptr, int8_t* ds
       scales[j / raw_blocksize * ld_dst + i] = scale;
       for (size_t ij = 0; ij < blocksize; ij++) {
         auto quant_v = srcptr[(j + ij) * ld_src + i] * rscale;
-        int8_t x = MIN(15, (int8_t)(quant_v + 8.5f));
+        int8_t x = std::min(static_cast<int8_t>(15), static_cast<int8_t>(quant_v + 8.5f));
         dstptr[(j + ij) * ld_dst + i] = x << 4;
       }
     };
@@ -649,7 +652,7 @@ inline JBLAS_CODE quantize_f32_sign_int_rowblock(const float* srcptr, int8_t* ds
       zero_points[j / raw_blocksize * ld_dst + i] = bzp;
       for (size_t ij = 0; ij < blocksize; ij++) {
         auto quant_v = (srcptr[(j + ij) * ld_src + i] - fmedium) * rscale;
-        int8_t x = MIN(15, (int8_t)(quant_v + 8.5f));
+        int8_t x = std::min(static_cast<int8_t>(15), static_cast<int8_t>(quant_v + 8.5f));
         dstptr[(j + ij) * ld_dst + i] = x << 4;
       }
     };
@@ -748,7 +751,7 @@ inline JBLAS_CODE quantize_fp_u8_colblock(int row, int col, const SRC_T* srcptr,
       scales[j / blocksize + i * ld_scale] = scale;
       zps[j / blocksize + i * ld_scale] = zp;
       int sum = 0;
-      auto zpf = float(zp);
+      auto zpf = static_cast<float>(zp);
       for (size_t ij = 0; ij < blocksize; ij++) {
         auto fsrc = static_cast<float>(srcptr[(j + ij) + i * ld_src]);
         auto qtmp = utils::cast<float, int>(fsrc * rscale);
@@ -856,7 +859,7 @@ static inline JBLAS_CODE accum_alphaN_f32_f32(const SCA_T* alpha, const float* s
                                               const int dststep, const int M, const int N) {
   for (size_t i = 0; i < M; i++) {
     for (size_t j = 0; j < N; j++) {
-      dstptr[i * dststep + j] = float(alpha[j]) * srcptr[i * srcstep + j] + dstptr[i * dststep + j];
+      dstptr[i * dststep + j] = static_cast<float>(alpha[j]) * srcptr[i * srcstep + j] + dstptr[i * dststep + j];
     }
   }
   return JblasSuccess;
@@ -878,8 +881,8 @@ static inline JBLAS_CODE quanout_s32_u32(const float alpha, const int32_t* srcpt
   float factor = alpha * scaleSrc / scaleDst;
   for (int i = 0; i < M; i++) {
     for (int j = 0; j < N; j++) {
-      float fsrc = float(srcptr[i * srcstep + j]) * factor;
-      dstptr[i * dststep + j] = utils::cast<float, uint8_t>(fsrc + float(zpDst));
+      float fsrc = static_cast<float>(srcptr[i * srcstep + j]) * factor;
+      dstptr[i * dststep + j] = utils::cast<float, uint8_t>(fsrc + static_cast<float>(zpDst));
     }
   }
   return JblasSuccess;
@@ -892,7 +895,7 @@ static inline JBLAS_CODE dequant_s32_fp32(const int32_t* srcptr, const int srcst
   for (int i = 0; i < M; i++) {
     float scale = scaleA[i * ldsa];
     for (int j = 0; j < N; j++) {
-      float fsrc = float(srcptr[i * srcstep + j]) * float(scaleB[j]) * scale;
+      float fsrc = static_cast<float>(srcptr[i * srcstep + j]) * static_cast<float>(scaleB[j]) * scale;
       dstptr[i * dststep + j] = fsrc;
     }
   }
@@ -955,9 +958,10 @@ static inline JBLAS_CODE quant_s8_row_reduce_sum(const int8_t* srcptr, int ldsrc
   for (int i = 0; i < row; i++) {
     for (int j = 0; j < col; j++) {
       if (zero_points != nullptr) {
-        reduce[j] += _RT((float(srcptr[i * ldsrc + j]) - float(zero_points[j])) * float(scales[j]));
+        reduce[j] += static_cast<_RT>((static_cast<float>(srcptr[i * ldsrc + j]) - static_cast<float>(zero_points[j])) *
+                                      static_cast<float>(scales[j]));
       } else {
-        reduce[j] += _RT(srcptr[i * ldsrc + j] * scales[j]);
+        reduce[j] += static_cast<_RT>(srcptr[i * ldsrc + j] * scales[j]);
       }
     }
   }
@@ -971,7 +975,7 @@ static inline JBLAS_CODE row_reduce_sum(const float* srcptr, int ldsrc, int row,
     for (int i = 0; i < row; i++) {
       tmp += srcptr[i * ldsrc + j];
     }
-    reduce[j] = _RT(tmp);
+    reduce[j] = static_cast<_RT>(tmp);
   }
   return JblasSuccess;
 }
@@ -996,7 +1000,7 @@ static inline JBLAS_CODE col_block_reduce_sum(const SRC_T* srcptr, int ldsrc, in
 static inline JBLAS_CODE remove_act_zeropoint_bias(float* accptr, int ldacc, int row, int col, uint8_t* zps,
                                                    float* scales, int lds, const float* reduce) {
   for (int i = 0; i < row; i++) {
-    auto zpf = float(zps[i * lds]) * scales[i * lds];
+    auto zpf = static_cast<float>(zps[i * lds]) * scales[i * lds];
     for (int j = 0; j < col; j++) {
       accptr[i * ldacc + j] -= zpf * reduce[j];
     }
@@ -1009,7 +1013,7 @@ static inline JBLAS_CODE remove_wei_zeropoint_bias(float* accptr, int ldacc, int
   for (int i = 0; i < row; i++) {
     auto reducef = reduce[i * lds];
     for (int j = 0; j < col; j++) {
-      accptr[i * ldacc + j] -= float(zps[j]) * scales[j] * reducef;
+      accptr[i * ldacc + j] -= static_cast<float>(zps[j]) * scales[j] * reducef;
     }
   }
   return JblasSuccess;
@@ -1020,9 +1024,9 @@ static inline JBLAS_CODE remove_zeropoint_bias(float* accptr, int ldacc, int row
                                                const float* reduceb) {
   for (int i = 0; i < row; i++) {
     auto reduceaf = reducea[i * lds];
-    auto zpaf = float(zpa[i * lds]) * scalea[i * lds];
+    auto zpaf = static_cast<float>(zpa[i * lds]) * scalea[i * lds];
     for (int j = 0; j < col; j++) {
-      auto zpbf = float(zpb[j]) * scaleb[j];
+      auto zpbf = static_cast<float>(zpb[j]) * scaleb[j];
       accptr[i * ldacc + j] -= zpbf * reduceaf;
       accptr[i * ldacc + j] -= zpaf * reduceb[j];
       accptr[i * ldacc + j] -= zpaf * zpbf * k;
diff --git a/onnxruntime/core/mlas/lib/x86_64/jblas/jblas/kernel_wrapper.h b/onnxruntime/core/mlas/lib/x86_64/jblas/jblas/kernel_wrapper.h
index 8275a6312a248..d25b72ee2fa4d 100644
--- a/onnxruntime/core/mlas/lib/x86_64/jblas/jblas/kernel_wrapper.h
+++ b/onnxruntime/core/mlas/lib/x86_64/jblas/jblas/kernel_wrapper.h
@@ -160,9 +160,9 @@ class Memcpy2DFp32CvtFp16 {
                             bool zeropadding) {
 #if CompileFP16()
     if constexpr (utils::isa_base<ISA_T>::avx512_fp16) {
-      return kernel::avx512f::fp32_cvt_fp16_2D_write_back((const float*)srcptr, (utils::fp16*)dstptr, row, col,
-                                                          srcstride / sizeof(float), dststride / sizeof(utils::fp16),
-                                                          zeropadding);
+      return kernel::avx512f::fp32_cvt_fp16_2D_write_back(
+          reinterpret_cast<const float*>(srcptr), reinterpret_cast<utils::fp16*>(dstptr), row, col,
+          srcstride / sizeof(float), dststride / sizeof(utils::fp16), zeropadding);
     }
 #endif
     return JblasNotSupport;
@@ -177,8 +177,8 @@ class Memcpy2DFp16CvtFp32 {
 #if CompileFP16()
     if constexpr (utils::isa_base<ISA_T>::avx512_fp16) {
       return kernel::avx512f::fp16_cvt_fp32_2D_write_back(  //
-          (const utils::fp16*)srcptr, (float*)dstptr, row, col, srcstride / sizeof(utils::fp16),
-          dststride / sizeof(float), zeropadding);
+          reinterpret_cast<const utils::fp16*>(srcptr), reinterpret_cast<float*>(dstptr), row, col,
+          srcstride / sizeof(utils::fp16), dststride / sizeof(float), zeropadding);
     }
 #endif
     return JblasNotSupport;
@@ -193,22 +193,22 @@ class Memcpy2DBf16CvtFp32 {
 #if CompileBF16()
     if constexpr (ISA_T >= JblasAMX_BF16) {
       return kernel::avx512_bf16::bf16_cvt_fp32_2D_write_back(  //
-          (const utils::bf16*)srcptr, (float*)dstptr, row, col, srcstride / sizeof(utils::bf16),
-          dststride / sizeof(float), zeropadding);
+          reinterpret_cast<const utils::bf16*>(srcptr), reinterpret_cast<float*>(dstptr), row, col,
+          srcstride / sizeof(utils::bf16), dststride / sizeof(float), zeropadding);
     }
 #endif
 #if CompileAVX512F()
     if constexpr (ISA_T >= JblasAVX512F) {
       return kernel::avx512f::bf16_cvt_fp32_2D_write_back(  //
-          (const utils::bf16*)srcptr, (float*)dstptr, row, col, srcstride / sizeof(utils::bf16),
-          dststride / sizeof(float), zeropadding);
+          reinterpret_cast<const utils::bf16*>(srcptr), reinterpret_cast<float*>(dstptr), row, col,
+          srcstride / sizeof(utils::bf16), dststride / sizeof(float), zeropadding);
     }
 #endif
 #if CompileAVX2()
     if constexpr (ISA_T >= JblasAVX2) {
-      return kernel::avx2::bf16_cvt_fp32_2D_write_back((const utils::bf16*)srcptr, (float*)dstptr, row, col,
-                                                       srcstride / sizeof(utils::bf16), dststride / sizeof(float),
-                                                       zeropadding);
+      return kernel::avx2::bf16_cvt_fp32_2D_write_back(
+          reinterpret_cast<const utils::bf16*>(srcptr), reinterpret_cast<float*>(dstptr), row, col,
+          srcstride / sizeof(utils::bf16), dststride / sizeof(float), zeropadding);
     }
 #endif
     return kernel::ref::dt_cvt_2D_write_back<utils::bf16, float>(srcptr, dstptr, row, col, srcstride, dststride,
@@ -355,7 +355,8 @@ class DecompressKBlockS4Fp {
 #if CompileAVX512F()
     if constexpr (utils::isa_base<ISA_T>::avx512f) {
       ret = avx512f::decompress_kblock_s4_fp<S4_T, _DST_T, _PACK_ROW, _SCA_T>(
-          srcptr, dstptr, row, col, ld_src, ld_dst, scales, zero_points, k_offset, kblock, NPad, (int8_t*)tmp, tmpsize);
+          srcptr, dstptr, row, col, ld_src, ld_dst, scales, zero_points, k_offset, kblock, NPad,
+          reinterpret_cast<int8_t*>(tmp), tmpsize);
       if (ret == JblasSuccess) return ret;
     }
 #endif
@@ -366,18 +367,21 @@ class DecompressKBlockS4Fp {
       if (zero_points == nullptr) {
         ret = avx2::decompress_kblock_bit4_packrow1<true>(srcptr, dstptr, row, col, ld_src, ld_dst, scales, zero_points,
                                                           k_offset, kblock, NPad, &avx2::dequant_s8_N_avx2<48, true>,
-                                                          &avx2::convert_s4_s8_16_sse<S4_T>, (int8_t*)tmp, tmpsize);
+                                                          &avx2::convert_s4_s8_16_sse<S4_T>,
+                                                          reinterpret_cast<int8_t*>(tmp), tmpsize);
       } else {
         ret = avx2::decompress_kblock_bit4_packrow1<false>(
             srcptr, dstptr, row, col, ld_src, ld_dst, scales, zero_points, k_offset, kblock, NPad,
-            &avx2::dequant_s8_N_avx2<48, false>, &avx2::convert_s4_s8_16_sse<S4_T>, (int8_t*)tmp, tmpsize);
+            &avx2::dequant_s8_N_avx2<48, false>, &avx2::convert_s4_s8_16_sse<S4_T>, reinterpret_cast<int8_t*>(tmp),
+            tmpsize);
       }
 
       if (ret == JblasSuccess) return ret;
     }
 #endif
-    ret = ref::decompress_kblock_s4_fp<S4_T, _DST_T, _PACK_ROW, _SCA_T>(
-        srcptr, dstptr, row, col, ld_src, ld_dst, scales, zero_points, k_offset, kblock, NPad, (int8_t*)tmp, tmpsize);
+    ret = ref::decompress_kblock_s4_fp<S4_T, _DST_T, _PACK_ROW, _SCA_T>(srcptr, dstptr, row, col, ld_src, ld_dst,
+                                                                        scales, zero_points, k_offset, kblock, NPad,
+                                                                        reinterpret_cast<int8_t*>(tmp), tmpsize);
     return ret;
   }
 };
@@ -391,16 +395,16 @@ class DecompressKBlockS4S8Fp {
     JBLAS_CODE ret = JblasNotSupport;
 #if CompileAVX512F()
     if constexpr (utils::isa_base<ISA_T>::avx512f) {
-      return avx512f::decompress_kblock_s4_s8fp<S4_T, _DST_T>(srcptr, dstptr, row, col, ld_src, ld_dst, (int8_t*)tmp,
-                                                              tmpsize);
+      return avx512f::decompress_kblock_s4_s8fp<S4_T, _DST_T>(srcptr, dstptr, row, col, ld_src, ld_dst,
+                                                              reinterpret_cast<int8_t*>(tmp), tmpsize);
     }
 #endif
     if constexpr (utils::isa_base<ISA_T>::avx2) {
-      return avx2::decompress_kblock_s4_s8fp<S4_T, _DST_T>(srcptr, dstptr, row, col, ld_src, ld_dst, (int8_t*)tmp,
-                                                           tmpsize);
+      return avx2::decompress_kblock_s4_s8fp<S4_T, _DST_T>(srcptr, dstptr, row, col, ld_src, ld_dst,
+                                                           reinterpret_cast<int8_t*>(tmp), tmpsize);
     }
-    return ref::decompress_kblock_s4_s8fp<S4_T, _DST_T>(srcptr, dstptr, row, col, ld_src, ld_dst, (int8_t*)tmp,
-                                                        tmpsize);
+    return ref::decompress_kblock_s4_s8fp<S4_T, _DST_T>(srcptr, dstptr, row, col, ld_src, ld_dst,
+                                                        reinterpret_cast<int8_t*>(tmp), tmpsize);
   }
 };
 
@@ -413,20 +417,23 @@ class DecompressKBlockF4Fp {
     JBLAS_CODE ret = JblasNotSupport;
 #if CompileAVX512F()
     if constexpr (utils::isa_base<ISA_T>::avx512f) {
-      ret = avx512f::decompress_kblock_f4_fp<F4_T, _DST_T, _PACK_ROW, SCA_T>(
-          srcptr, dstptr, row, col, ld_src, ld_dst, scales, k_offset, kblock, NPad, (int8_t*)tmp, tmpsize);
+      ret = avx512f::decompress_kblock_f4_fp<F4_T, _DST_T, _PACK_ROW, SCA_T>(srcptr, dstptr, row, col, ld_src, ld_dst,
+                                                                             scales, k_offset, kblock, NPad,
+                                                                             reinterpret_cast<int8_t*>(tmp), tmpsize);
       if (ret == JblasSuccess) return ret;
     }
 #endif
 #if CompileAVX2()
     if constexpr (utils::isa_base<ISA_T>::avx2 && std::is_same_v<SCA_T, float>) {
-      ret = avx2::decompress_kblock_f4_fp<F4_T, _DST_T, _PACK_ROW, SCA_T>(
-          srcptr, dstptr, row, col, ld_src, ld_dst, scales, k_offset, kblock, NPad, (int8_t*)tmp, tmpsize);
+      ret = avx2::decompress_kblock_f4_fp<F4_T, _DST_T, _PACK_ROW, SCA_T>(srcptr, dstptr, row, col, ld_src, ld_dst,
+                                                                          scales, k_offset, kblock, NPad,
+                                                                          reinterpret_cast<int8_t*>(tmp), tmpsize);
       if (ret == JblasSuccess) return ret;
     }
 #endif
-    return ref::decompress_kblock_f4_fp<F4_T, _DST_T, _PACK_ROW, SCA_T>(
-        srcptr, dstptr, row, col, ld_src, ld_dst, scales, k_offset, kblock, NPad, (int8_t*)tmp, tmpsize);
+    return ref::decompress_kblock_f4_fp<F4_T, _DST_T, _PACK_ROW, SCA_T>(srcptr, dstptr, row, col, ld_src, ld_dst,
+                                                                        scales, k_offset, kblock, NPad,
+                                                                        reinterpret_cast<int8_t*>(tmp), tmpsize);
   }
 };
 
@@ -439,14 +446,14 @@ class DecompressKBlockF4FpNoscale {
     JBLAS_CODE ret = JblasNotSupport;
     if constexpr (utils::isa_base<ISA_T>::avx512f) {
       return avx512f::decompress_kblock_f4_fp_noscale<F4_T, _DST_T>(srcptr, dstptr, row, col, ld_src, ld_dst,
-                                                                    (int8_t*)tmp, tmpsize);
+                                                                    reinterpret_cast<int8_t*>(tmp), tmpsize);
     }
     if constexpr (utils::isa_base<ISA_T>::avx2) {
-      return avx2::decompress_kblock_f4_fp_noscale<F4_T, _DST_T>(srcptr, dstptr, row, col, ld_src, ld_dst, (int8_t*)tmp,
-                                                                 tmpsize);
+      return avx2::decompress_kblock_f4_fp_noscale<F4_T, _DST_T>(srcptr, dstptr, row, col, ld_src, ld_dst,
+                                                                 reinterpret_cast<int8_t*>(tmp), tmpsize);
     }
-    return ref::decompress_kblock_f4_fp_noscale<F4_T, _DST_T>(srcptr, dstptr, row, col, ld_src, ld_dst, (int8_t*)tmp,
-                                                              tmpsize);
+    return ref::decompress_kblock_f4_fp_noscale<F4_T, _DST_T>(srcptr, dstptr, row, col, ld_src, ld_dst,
+                                                              reinterpret_cast<int8_t*>(tmp), tmpsize);
   }
 };
 
@@ -643,7 +650,7 @@ class RemoveZeroPointBias {
  public:
   template <JBLAS_ISA ISA_T>
   static inline JBLAS_CODE forward_wei(float* accptr, int ldacc, int row, int col, int8_t* zps, float* scales, int lds,
-                                   const float* reduce) {
+                                       const float* reduce) {
 #if CompileAVX512F()
     if constexpr (utils::isa_base<ISA_T>::avx512f) {
       return avx512f::remove_wei_zeropoint_bias(accptr, ldacc, row, col, zps, scales, lds, reduce);
@@ -658,7 +665,7 @@ class RemoveZeroPointBias {
   }
   template <JBLAS_ISA ISA_T>
   static inline JBLAS_CODE forward_act(float* accptr, int ldacc, int row, int col, uint8_t* zps, float* scales, int lds,
-                                   const float* reduce) {
+                                       const float* reduce) {
 #if CompileAVX512F()
     if constexpr (utils::isa_base<ISA_T>::avx512f) {
       return avx512f::remove_act_zeropoint_bias(accptr, ldacc, row, col, zps, scales, lds, reduce);
@@ -672,8 +679,9 @@ class RemoveZeroPointBias {
     return ref::remove_act_zeropoint_bias(accptr, ldacc, row, col, zps, scales, lds, reduce);
   }
   template <JBLAS_ISA ISA_T>
-  static inline JBLAS_CODE forward_both(float* accptr, int ldacc, int row, int col, uint8_t* zpa, int8_t* zpb, float* scalea,
-                                   float* scaleb, int lds, int k, const float* reducea, const float* reduceb) {
+  static inline JBLAS_CODE forward_both(float* accptr, int ldacc, int row, int col, uint8_t* zpa, int8_t* zpb,
+                                        float* scalea, float* scaleb, int lds, int k, const float* reducea,
+                                        const float* reduceb) {
 #if CompileAVX512F()
     if constexpr (utils::isa_base<ISA_T>::avx512f) {
       return avx512f::remove_zeropoint_bias(accptr, ldacc, row, col, zpa, zpb, scalea, scaleb, lds, k, reducea,
diff --git a/onnxruntime/core/mlas/lib/x86_64/jblas/jblas/xbyak/xbyak_bin2hex.h b/onnxruntime/core/mlas/lib/x86_64/jblas/jblas/xbyak/xbyak_bin2hex.h
index 285ee34105081..fda7da3c9b7c1 100644
--- a/onnxruntime/core/mlas/lib/x86_64/jblas/jblas/xbyak/xbyak_bin2hex.h
+++ b/onnxruntime/core/mlas/lib/x86_64/jblas/jblas/xbyak/xbyak_bin2hex.h
@@ -12,260 +12,260 @@
 //  See the License for the specific language governing permissions and
 //  limitations under the License.
 enum {
-	B00000000= 0,
-	B00000001= 1,
-	B00000010= 2,
-	B00000011= 3,
-	B00000100= 4,
-	B00000101= 5,
-	B00000110= 6,
-	B00000111= 7,
-	B00001000= 8,
-	B00001001= 9,
-	B00001010= 10,
-	B00001011= 11,
-	B00001100= 12,
-	B00001101= 13,
-	B00001110= 14,
-	B00001111= 15,
-	B00010000= 16,
-	B00010001= 17,
-	B00010010= 18,
-	B00010011= 19,
-	B00010100= 20,
-	B00010101= 21,
-	B00010110= 22,
-	B00010111= 23,
-	B00011000= 24,
-	B00011001= 25,
-	B00011010= 26,
-	B00011011= 27,
-	B00011100= 28,
-	B00011101= 29,
-	B00011110= 30,
-	B00011111= 31,
-	B00100000= 32,
-	B00100001= 33,
-	B00100010= 34,
-	B00100011= 35,
-	B00100100= 36,
-	B00100101= 37,
-	B00100110= 38,
-	B00100111= 39,
-	B00101000= 40,
-	B00101001= 41,
-	B00101010= 42,
-	B00101011= 43,
-	B00101100= 44,
-	B00101101= 45,
-	B00101110= 46,
-	B00101111= 47,
-	B00110000= 48,
-	B00110001= 49,
-	B00110010= 50,
-	B00110011= 51,
-	B00110100= 52,
-	B00110101= 53,
-	B00110110= 54,
-	B00110111= 55,
-	B00111000= 56,
-	B00111001= 57,
-	B00111010= 58,
-	B00111011= 59,
-	B00111100= 60,
-	B00111101= 61,
-	B00111110= 62,
-	B00111111= 63,
-	B01000000= 64,
-	B01000001= 65,
-	B01000010= 66,
-	B01000011= 67,
-	B01000100= 68,
-	B01000101= 69,
-	B01000110= 70,
-	B01000111= 71,
-	B01001000= 72,
-	B01001001= 73,
-	B01001010= 74,
-	B01001011= 75,
-	B01001100= 76,
-	B01001101= 77,
-	B01001110= 78,
-	B01001111= 79,
-	B01010000= 80,
-	B01010001= 81,
-	B01010010= 82,
-	B01010011= 83,
-	B01010100= 84,
-	B01010101= 85,
-	B01010110= 86,
-	B01010111= 87,
-	B01011000= 88,
-	B01011001= 89,
-	B01011010= 90,
-	B01011011= 91,
-	B01011100= 92,
-	B01011101= 93,
-	B01011110= 94,
-	B01011111= 95,
-	B01100000= 96,
-	B01100001= 97,
-	B01100010= 98,
-	B01100011= 99,
-	B01100100= 100,
-	B01100101= 101,
-	B01100110= 102,
-	B01100111= 103,
-	B01101000= 104,
-	B01101001= 105,
-	B01101010= 106,
-	B01101011= 107,
-	B01101100= 108,
-	B01101101= 109,
-	B01101110= 110,
-	B01101111= 111,
-	B01110000= 112,
-	B01110001= 113,
-	B01110010= 114,
-	B01110011= 115,
-	B01110100= 116,
-	B01110101= 117,
-	B01110110= 118,
-	B01110111= 119,
-	B01111000= 120,
-	B01111001= 121,
-	B01111010= 122,
-	B01111011= 123,
-	B01111100= 124,
-	B01111101= 125,
-	B01111110= 126,
-	B01111111= 127,
-	B10000000= 128,
-	B10000001= 129,
-	B10000010= 130,
-	B10000011= 131,
-	B10000100= 132,
-	B10000101= 133,
-	B10000110= 134,
-	B10000111= 135,
-	B10001000= 136,
-	B10001001= 137,
-	B10001010= 138,
-	B10001011= 139,
-	B10001100= 140,
-	B10001101= 141,
-	B10001110= 142,
-	B10001111= 143,
-	B10010000= 144,
-	B10010001= 145,
-	B10010010= 146,
-	B10010011= 147,
-	B10010100= 148,
-	B10010101= 149,
-	B10010110= 150,
-	B10010111= 151,
-	B10011000= 152,
-	B10011001= 153,
-	B10011010= 154,
-	B10011011= 155,
-	B10011100= 156,
-	B10011101= 157,
-	B10011110= 158,
-	B10011111= 159,
-	B10100000= 160,
-	B10100001= 161,
-	B10100010= 162,
-	B10100011= 163,
-	B10100100= 164,
-	B10100101= 165,
-	B10100110= 166,
-	B10100111= 167,
-	B10101000= 168,
-	B10101001= 169,
-	B10101010= 170,
-	B10101011= 171,
-	B10101100= 172,
-	B10101101= 173,
-	B10101110= 174,
-	B10101111= 175,
-	B10110000= 176,
-	B10110001= 177,
-	B10110010= 178,
-	B10110011= 179,
-	B10110100= 180,
-	B10110101= 181,
-	B10110110= 182,
-	B10110111= 183,
-	B10111000= 184,
-	B10111001= 185,
-	B10111010= 186,
-	B10111011= 187,
-	B10111100= 188,
-	B10111101= 189,
-	B10111110= 190,
-	B10111111= 191,
-	B11000000= 192,
-	B11000001= 193,
-	B11000010= 194,
-	B11000011= 195,
-	B11000100= 196,
-	B11000101= 197,
-	B11000110= 198,
-	B11000111= 199,
-	B11001000= 200,
-	B11001001= 201,
-	B11001010= 202,
-	B11001011= 203,
-	B11001100= 204,
-	B11001101= 205,
-	B11001110= 206,
-	B11001111= 207,
-	B11010000= 208,
-	B11010001= 209,
-	B11010010= 210,
-	B11010011= 211,
-	B11010100= 212,
-	B11010101= 213,
-	B11010110= 214,
-	B11010111= 215,
-	B11011000= 216,
-	B11011001= 217,
-	B11011010= 218,
-	B11011011= 219,
-	B11011100= 220,
-	B11011101= 221,
-	B11011110= 222,
-	B11011111= 223,
-	B11100000= 224,
-	B11100001= 225,
-	B11100010= 226,
-	B11100011= 227,
-	B11100100= 228,
-	B11100101= 229,
-	B11100110= 230,
-	B11100111= 231,
-	B11101000= 232,
-	B11101001= 233,
-	B11101010= 234,
-	B11101011= 235,
-	B11101100= 236,
-	B11101101= 237,
-	B11101110= 238,
-	B11101111= 239,
-	B11110000= 240,
-	B11110001= 241,
-	B11110010= 242,
-	B11110011= 243,
-	B11110100= 244,
-	B11110101= 245,
-	B11110110= 246,
-	B11110111= 247,
-	B11111000= 248,
-	B11111001= 249,
-	B11111010= 250,
-	B11111011= 251,
-	B11111100= 252,
-	B11111101= 253,
-	B11111110= 254,
-	B11111111= 255
+  B00000000 = 0,
+  B00000001 = 1,
+  B00000010 = 2,
+  B00000011 = 3,
+  B00000100 = 4,
+  B00000101 = 5,
+  B00000110 = 6,
+  B00000111 = 7,
+  B00001000 = 8,
+  B00001001 = 9,
+  B00001010 = 10,
+  B00001011 = 11,
+  B00001100 = 12,
+  B00001101 = 13,
+  B00001110 = 14,
+  B00001111 = 15,
+  B00010000 = 16,
+  B00010001 = 17,
+  B00010010 = 18,
+  B00010011 = 19,
+  B00010100 = 20,
+  B00010101 = 21,
+  B00010110 = 22,
+  B00010111 = 23,
+  B00011000 = 24,
+  B00011001 = 25,
+  B00011010 = 26,
+  B00011011 = 27,
+  B00011100 = 28,
+  B00011101 = 29,
+  B00011110 = 30,
+  B00011111 = 31,
+  B00100000 = 32,
+  B00100001 = 33,
+  B00100010 = 34,
+  B00100011 = 35,
+  B00100100 = 36,
+  B00100101 = 37,
+  B00100110 = 38,
+  B00100111 = 39,
+  B00101000 = 40,
+  B00101001 = 41,
+  B00101010 = 42,
+  B00101011 = 43,
+  B00101100 = 44,
+  B00101101 = 45,
+  B00101110 = 46,
+  B00101111 = 47,
+  B00110000 = 48,
+  B00110001 = 49,
+  B00110010 = 50,
+  B00110011 = 51,
+  B00110100 = 52,
+  B00110101 = 53,
+  B00110110 = 54,
+  B00110111 = 55,
+  B00111000 = 56,
+  B00111001 = 57,
+  B00111010 = 58,
+  B00111011 = 59,
+  B00111100 = 60,
+  B00111101 = 61,
+  B00111110 = 62,
+  B00111111 = 63,
+  B01000000 = 64,
+  B01000001 = 65,
+  B01000010 = 66,
+  B01000011 = 67,
+  B01000100 = 68,
+  B01000101 = 69,
+  B01000110 = 70,
+  B01000111 = 71,
+  B01001000 = 72,
+  B01001001 = 73,
+  B01001010 = 74,
+  B01001011 = 75,
+  B01001100 = 76,
+  B01001101 = 77,
+  B01001110 = 78,
+  B01001111 = 79,
+  B01010000 = 80,
+  B01010001 = 81,
+  B01010010 = 82,
+  B01010011 = 83,
+  B01010100 = 84,
+  B01010101 = 85,
+  B01010110 = 86,
+  B01010111 = 87,
+  B01011000 = 88,
+  B01011001 = 89,
+  B01011010 = 90,
+  B01011011 = 91,
+  B01011100 = 92,
+  B01011101 = 93,
+  B01011110 = 94,
+  B01011111 = 95,
+  B01100000 = 96,
+  B01100001 = 97,
+  B01100010 = 98,
+  B01100011 = 99,
+  B01100100 = 100,
+  B01100101 = 101,
+  B01100110 = 102,
+  B01100111 = 103,
+  B01101000 = 104,
+  B01101001 = 105,
+  B01101010 = 106,
+  B01101011 = 107,
+  B01101100 = 108,
+  B01101101 = 109,
+  B01101110 = 110,
+  B01101111 = 111,
+  B01110000 = 112,
+  B01110001 = 113,
+  B01110010 = 114,
+  B01110011 = 115,
+  B01110100 = 116,
+  B01110101 = 117,
+  B01110110 = 118,
+  B01110111 = 119,
+  B01111000 = 120,
+  B01111001 = 121,
+  B01111010 = 122,
+  B01111011 = 123,
+  B01111100 = 124,
+  B01111101 = 125,
+  B01111110 = 126,
+  B01111111 = 127,
+  B10000000 = 128,
+  B10000001 = 129,
+  B10000010 = 130,
+  B10000011 = 131,
+  B10000100 = 132,
+  B10000101 = 133,
+  B10000110 = 134,
+  B10000111 = 135,
+  B10001000 = 136,
+  B10001001 = 137,
+  B10001010 = 138,
+  B10001011 = 139,
+  B10001100 = 140,
+  B10001101 = 141,
+  B10001110 = 142,
+  B10001111 = 143,
+  B10010000 = 144,
+  B10010001 = 145,
+  B10010010 = 146,
+  B10010011 = 147,
+  B10010100 = 148,
+  B10010101 = 149,
+  B10010110 = 150,
+  B10010111 = 151,
+  B10011000 = 152,
+  B10011001 = 153,
+  B10011010 = 154,
+  B10011011 = 155,
+  B10011100 = 156,
+  B10011101 = 157,
+  B10011110 = 158,
+  B10011111 = 159,
+  B10100000 = 160,
+  B10100001 = 161,
+  B10100010 = 162,
+  B10100011 = 163,
+  B10100100 = 164,
+  B10100101 = 165,
+  B10100110 = 166,
+  B10100111 = 167,
+  B10101000 = 168,
+  B10101001 = 169,
+  B10101010 = 170,
+  B10101011 = 171,
+  B10101100 = 172,
+  B10101101 = 173,
+  B10101110 = 174,
+  B10101111 = 175,
+  B10110000 = 176,
+  B10110001 = 177,
+  B10110010 = 178,
+  B10110011 = 179,
+  B10110100 = 180,
+  B10110101 = 181,
+  B10110110 = 182,
+  B10110111 = 183,
+  B10111000 = 184,
+  B10111001 = 185,
+  B10111010 = 186,
+  B10111011 = 187,
+  B10111100 = 188,
+  B10111101 = 189,
+  B10111110 = 190,
+  B10111111 = 191,
+  B11000000 = 192,
+  B11000001 = 193,
+  B11000010 = 194,
+  B11000011 = 195,
+  B11000100 = 196,
+  B11000101 = 197,
+  B11000110 = 198,
+  B11000111 = 199,
+  B11001000 = 200,
+  B11001001 = 201,
+  B11001010 = 202,
+  B11001011 = 203,
+  B11001100 = 204,
+  B11001101 = 205,
+  B11001110 = 206,
+  B11001111 = 207,
+  B11010000 = 208,
+  B11010001 = 209,
+  B11010010 = 210,
+  B11010011 = 211,
+  B11010100 = 212,
+  B11010101 = 213,
+  B11010110 = 214,
+  B11010111 = 215,
+  B11011000 = 216,
+  B11011001 = 217,
+  B11011010 = 218,
+  B11011011 = 219,
+  B11011100 = 220,
+  B11011101 = 221,
+  B11011110 = 222,
+  B11011111 = 223,
+  B11100000 = 224,
+  B11100001 = 225,
+  B11100010 = 226,
+  B11100011 = 227,
+  B11100100 = 228,
+  B11100101 = 229,
+  B11100110 = 230,
+  B11100111 = 231,
+  B11101000 = 232,
+  B11101001 = 233,
+  B11101010 = 234,
+  B11101011 = 235,
+  B11101100 = 236,
+  B11101101 = 237,
+  B11101110 = 238,
+  B11101111 = 239,
+  B11110000 = 240,
+  B11110001 = 241,
+  B11110010 = 242,
+  B11110011 = 243,
+  B11110100 = 244,
+  B11110101 = 245,
+  B11110110 = 246,
+  B11110111 = 247,
+  B11111000 = 248,
+  B11111001 = 249,
+  B11111010 = 250,
+  B11111011 = 251,
+  B11111100 = 252,
+  B11111101 = 253,
+  B11111110 = 254,
+  B11111111 = 255
 };
diff --git a/onnxruntime/core/mlas/lib/x86_64/jblas/jblas/xbyak/xbyak_mnemonic.h b/onnxruntime/core/mlas/lib/x86_64/jblas/jblas/xbyak/xbyak_mnemonic.h
index 9e70e39ec9a71..533b1712a7669 100644
--- a/onnxruntime/core/mlas/lib/x86_64/jblas/jblas/xbyak/xbyak_mnemonic.h
+++ b/onnxruntime/core/mlas/lib/x86_64/jblas/jblas/xbyak/xbyak_mnemonic.h
@@ -11,9 +11,12 @@
 //  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 //  See the License for the specific language governing permissions and
 //  limitations under the License.
-const char *getVersionString() const { return "6.73"; }
-void aadd(const Address& addr, const Reg32e &reg) { opModM(addr, reg, 0x0F, 0x38, 0x0FC); }
-void aand(const Address& addr, const Reg32e &reg) { db(0x66); opModM(addr, reg, 0x0F, 0x38, 0x0FC); }
+const char* getVersionString() const { return "6.73"; }
+void aadd(const Address& addr, const Reg32e& reg) { opModM(addr, reg, 0x0F, 0x38, 0x0FC); }
+void aand(const Address& addr, const Reg32e& reg) {
+  db(0x66);
+  opModM(addr, reg, 0x0F, 0x38, 0x0FC);
+}
 void adc(const Operand& op, uint32_t imm) { opRM_I(op, imm, 0x10, 2); }
 void adc(const Operand& op1, const Operand& op2) { opRM_RM(op1, op2, 0x10); }
 void adcx(const Reg32e& reg, const Operand& op) { opGen(reg, op, 0xF6, 0x66, isREG32_REG32orMEM, NONE, 0x38); }
@@ -31,7 +34,9 @@ void aesdeclast(const Xmm& xmm, const Operand& op) { opGen(xmm, op, 0xDF, 0x66,
 void aesenc(const Xmm& xmm, const Operand& op) { opGen(xmm, op, 0xDC, 0x66, isXMM_XMMorMEM, NONE, 0x38); }
 void aesenclast(const Xmm& xmm, const Operand& op) { opGen(xmm, op, 0xDD, 0x66, isXMM_XMMorMEM, NONE, 0x38); }
 void aesimc(const Xmm& xmm, const Operand& op) { opGen(xmm, op, 0xDB, 0x66, isXMM_XMMorMEM, NONE, 0x38); }
-void aeskeygenassist(const Xmm& xmm, const Operand& op, uint8_t imm) { opGen(xmm, op, 0xDF, 0x66, isXMM_XMMorMEM, imm, 0x3A); }
+void aeskeygenassist(const Xmm& xmm, const Operand& op, uint8_t imm) {
+  opGen(xmm, op, 0xDF, 0x66, isXMM_XMMorMEM, imm, 0x3A);
+}
 void and_(const Operand& op, uint32_t imm) { opRM_I(op, imm, 0x20, 4); }
 void and_(const Operand& op1, const Operand& op2) { opRM_RM(op1, op2, 0x20); }
 void andn(const Reg32e& r1, const Reg32e& r2, const Operand& op) { opGpr(r1, r2, op, T_0F38, 0xf2, true); }
@@ -39,78 +44,199 @@ void andnpd(const Xmm& xmm, const Operand& op) { opGen(xmm, op, 0x55, 0x66, isXM
 void andnps(const Xmm& xmm, const Operand& op) { opGen(xmm, op, 0x55, 0x100, isXMM_XMMorMEM); }
 void andpd(const Xmm& xmm, const Operand& op) { opGen(xmm, op, 0x54, 0x66, isXMM_XMMorMEM); }
 void andps(const Xmm& xmm, const Operand& op) { opGen(xmm, op, 0x54, 0x100, isXMM_XMMorMEM); }
-void aor(const Address& addr, const Reg32e &reg) { db(0xF2); opModM(addr, reg, 0x0F, 0x38, 0x0FC); }
-void axor(const Address& addr, const Reg32e &reg) { db(0xF3); opModM(addr, reg, 0x0F, 0x38, 0x0FC); }
+void aor(const Address& addr, const Reg32e& reg) {
+  db(0xF2);
+  opModM(addr, reg, 0x0F, 0x38, 0x0FC);
+}
+void axor(const Address& addr, const Reg32e& reg) {
+  db(0xF3);
+  opModM(addr, reg, 0x0F, 0x38, 0x0FC);
+}
 void bextr(const Reg32e& r1, const Operand& op, const Reg32e& r2) { opGpr(r1, op, r2, T_0F38, 0xf7, false); }
-void blendpd(const Xmm& xmm, const Operand& op, int imm) { opGen(xmm, op, 0x0D, 0x66, isXMM_XMMorMEM, static_cast<uint8_t>(imm), 0x3A); }
-void blendps(const Xmm& xmm, const Operand& op, int imm) { opGen(xmm, op, 0x0C, 0x66, isXMM_XMMorMEM, static_cast<uint8_t>(imm), 0x3A); }
+void blendpd(const Xmm& xmm, const Operand& op, int imm) {
+  opGen(xmm, op, 0x0D, 0x66, isXMM_XMMorMEM, static_cast<uint8_t>(imm), 0x3A);
+}
+void blendps(const Xmm& xmm, const Operand& op, int imm) {
+  opGen(xmm, op, 0x0C, 0x66, isXMM_XMMorMEM, static_cast<uint8_t>(imm), 0x3A);
+}
 void blendvpd(const Xmm& xmm, const Operand& op) { opGen(xmm, op, 0x15, 0x66, isXMM_XMMorMEM, NONE, 0x38); }
 void blendvps(const Xmm& xmm, const Operand& op) { opGen(xmm, op, 0x14, 0x66, isXMM_XMMorMEM, NONE, 0x38); }
 void blsi(const Reg32e& r, const Operand& op) { opGpr(Reg32e(3, r.getBit()), op, r, T_0F38, 0xf3, false); }
 void blsmsk(const Reg32e& r, const Operand& op) { opGpr(Reg32e(2, r.getBit()), op, r, T_0F38, 0xf3, false); }
 void blsr(const Reg32e& r, const Operand& op) { opGpr(Reg32e(1, r.getBit()), op, r, T_0F38, 0xf3, false); }
 void bnd() { db(0xF2); }
-void bndcl(const BoundsReg& bnd, const Operand& op) { db(0xF3); opR_ModM(op, i32e, bnd.getIdx(), 0x0F, 0x1A, NONE, !op.isMEM()); }
-void bndcn(const BoundsReg& bnd, const Operand& op) { db(0xF2); opR_ModM(op, i32e, bnd.getIdx(), 0x0F, 0x1B, NONE, !op.isMEM()); }
-void bndcu(const BoundsReg& bnd, const Operand& op) { db(0xF2); opR_ModM(op, i32e, bnd.getIdx(), 0x0F, 0x1A, NONE, !op.isMEM()); }
+void bndcl(const BoundsReg& bnd, const Operand& op) {
+  db(0xF3);
+  opR_ModM(op, i32e, bnd.getIdx(), 0x0F, 0x1A, NONE, !op.isMEM());
+}
+void bndcn(const BoundsReg& bnd, const Operand& op) {
+  db(0xF2);
+  opR_ModM(op, i32e, bnd.getIdx(), 0x0F, 0x1B, NONE, !op.isMEM());
+}
+void bndcu(const BoundsReg& bnd, const Operand& op) {
+  db(0xF2);
+  opR_ModM(op, i32e, bnd.getIdx(), 0x0F, 0x1A, NONE, !op.isMEM());
+}
 void bndldx(const BoundsReg& bnd, const Address& addr) { opMIB(addr, bnd, 0x0F, 0x1A); }
-void bndmk(const BoundsReg& bnd, const Address& addr) { db(0xF3); opModM(addr, bnd, 0x0F, 0x1B); }
-void bndmov(const Address& addr, const BoundsReg& bnd) { db(0x66); opModM(addr, bnd, 0x0F, 0x1B); }
-void bndmov(const BoundsReg& bnd, const Operand& op) { db(0x66); opModRM(bnd, op, op.isBNDREG(), op.isMEM(), 0x0F, 0x1A); }
+void bndmk(const BoundsReg& bnd, const Address& addr) {
+  db(0xF3);
+  opModM(addr, bnd, 0x0F, 0x1B);
+}
+void bndmov(const Address& addr, const BoundsReg& bnd) {
+  db(0x66);
+  opModM(addr, bnd, 0x0F, 0x1B);
+}
+void bndmov(const BoundsReg& bnd, const Operand& op) {
+  db(0x66);
+  opModRM(bnd, op, op.isBNDREG(), op.isMEM(), 0x0F, 0x1A);
+}
 void bndstx(const Address& addr, const BoundsReg& bnd) { opMIB(addr, bnd, 0x0F, 0x1B); }
-void bsf(const Reg&reg, const Operand& op) { opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, 0xBC); }
-void bsr(const Reg&reg, const Operand& op) { opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, 0xBD); }
+void bsf(const Reg& reg, const Operand& op) { opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, 0xBC); }
+void bsr(const Reg& reg, const Operand& op) { opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, 0xBD); }
 void bswap(const Reg32e& reg) { opModR(Reg32(1), reg, 0x0F); }
-void bt(const Operand& op, const Reg& reg) { opModRM(reg, op, op.isREG(16|32|64) && op.getBit() == reg.getBit(), op.isMEM(), 0x0f, 0xA3); }
-void bt(const Operand& op, uint8_t imm) { opR_ModM(op, 16|32|64, 4, 0x0f, 0xba, NONE, false, 1); db(imm); }
-void btc(const Operand& op, const Reg& reg) { opModRM(reg, op, op.isREG(16|32|64) && op.getBit() == reg.getBit(), op.isMEM(), 0x0f, 0xBB); }
-void btc(const Operand& op, uint8_t imm) { opR_ModM(op, 16|32|64, 7, 0x0f, 0xba, NONE, false, 1); db(imm); }
-void btr(const Operand& op, const Reg& reg) { opModRM(reg, op, op.isREG(16|32|64) && op.getBit() == reg.getBit(), op.isMEM(), 0x0f, 0xB3); }
-void btr(const Operand& op, uint8_t imm) { opR_ModM(op, 16|32|64, 6, 0x0f, 0xba, NONE, false, 1); db(imm); }
-void bts(const Operand& op, const Reg& reg) { opModRM(reg, op, op.isREG(16|32|64) && op.getBit() == reg.getBit(), op.isMEM(), 0x0f, 0xAB); }
-void bts(const Operand& op, uint8_t imm) { opR_ModM(op, 16|32|64, 5, 0x0f, 0xba, NONE, false, 1); db(imm); }
+void bt(const Operand& op, const Reg& reg) {
+  opModRM(reg, op, op.isREG(16 | 32 | 64) && op.getBit() == reg.getBit(), op.isMEM(), 0x0f, 0xA3);
+}
+void bt(const Operand& op, uint8_t imm) {
+  opR_ModM(op, 16 | 32 | 64, 4, 0x0f, 0xba, NONE, false, 1);
+  db(imm);
+}
+void btc(const Operand& op, const Reg& reg) {
+  opModRM(reg, op, op.isREG(16 | 32 | 64) && op.getBit() == reg.getBit(), op.isMEM(), 0x0f, 0xBB);
+}
+void btc(const Operand& op, uint8_t imm) {
+  opR_ModM(op, 16 | 32 | 64, 7, 0x0f, 0xba, NONE, false, 1);
+  db(imm);
+}
+void btr(const Operand& op, const Reg& reg) {
+  opModRM(reg, op, op.isREG(16 | 32 | 64) && op.getBit() == reg.getBit(), op.isMEM(), 0x0f, 0xB3);
+}
+void btr(const Operand& op, uint8_t imm) {
+  opR_ModM(op, 16 | 32 | 64, 6, 0x0f, 0xba, NONE, false, 1);
+  db(imm);
+}
+void bts(const Operand& op, const Reg& reg) {
+  opModRM(reg, op, op.isREG(16 | 32 | 64) && op.getBit() == reg.getBit(), op.isMEM(), 0x0f, 0xAB);
+}
+void bts(const Operand& op, uint8_t imm) {
+  opR_ModM(op, 16 | 32 | 64, 5, 0x0f, 0xba, NONE, false, 1);
+  db(imm);
+}
 void bzhi(const Reg32e& r1, const Operand& op, const Reg32e& r2) { opGpr(r1, op, r2, T_0F38, 0xf5, false); }
-void cbw() { db(0x66); db(0x98); }
+void cbw() {
+  db(0x66);
+  db(0x98);
+}
 void cdq() { db(0x99); }
 void clc() { db(0xF8); }
 void cld() { db(0xFC); }
 void cldemote(const Address& addr) { opMIB(addr, eax, 0x0F, 0x1C); }
 void clflush(const Address& addr) { opModM(addr, Reg32(7), 0x0F, 0xAE); }
-void clflushopt(const Address& addr) { db(0x66); opModM(addr, Reg32(7), 0x0F, 0xAE); }
+void clflushopt(const Address& addr) {
+  db(0x66);
+  opModM(addr, Reg32(7), 0x0F, 0xAE);
+}
 void cli() { db(0xFA); }
-void clwb(const Address& addr) { db(0x66); opMIB(addr, esi, 0x0F, 0xAE); }
-void clzero() { db(0x0F); db(0x01); db(0xFC); }
+void clwb(const Address& addr) {
+  db(0x66);
+  opMIB(addr, esi, 0x0F, 0xAE);
+}
+void clzero() {
+  db(0x0F);
+  db(0x01);
+  db(0xFC);
+}
 void cmc() { db(0xF5); }
-void cmova(const Reg& reg, const Operand& op) { opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, 0x40 | 7); }//-V524
-void cmovae(const Reg& reg, const Operand& op) { opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, 0x40 | 3); }//-V524
-void cmovb(const Reg& reg, const Operand& op) { opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, 0x40 | 2); }//-V524
-void cmovbe(const Reg& reg, const Operand& op) { opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, 0x40 | 6); }//-V524
-void cmovc(const Reg& reg, const Operand& op) { opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, 0x40 | 2); }//-V524
-void cmove(const Reg& reg, const Operand& op) { opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, 0x40 | 4); }//-V524
-void cmovg(const Reg& reg, const Operand& op) { opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, 0x40 | 15); }//-V524
-void cmovge(const Reg& reg, const Operand& op) { opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, 0x40 | 13); }//-V524
-void cmovl(const Reg& reg, const Operand& op) { opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, 0x40 | 12); }//-V524
-void cmovle(const Reg& reg, const Operand& op) { opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, 0x40 | 14); }//-V524
-void cmovna(const Reg& reg, const Operand& op) { opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, 0x40 | 6); }//-V524
-void cmovnae(const Reg& reg, const Operand& op) { opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, 0x40 | 2); }//-V524
-void cmovnb(const Reg& reg, const Operand& op) { opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, 0x40 | 3); }//-V524
-void cmovnbe(const Reg& reg, const Operand& op) { opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, 0x40 | 7); }//-V524
-void cmovnc(const Reg& reg, const Operand& op) { opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, 0x40 | 3); }//-V524
-void cmovne(const Reg& reg, const Operand& op) { opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, 0x40 | 5); }//-V524
-void cmovng(const Reg& reg, const Operand& op) { opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, 0x40 | 14); }//-V524
-void cmovnge(const Reg& reg, const Operand& op) { opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, 0x40 | 12); }//-V524
-void cmovnl(const Reg& reg, const Operand& op) { opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, 0x40 | 13); }//-V524
-void cmovnle(const Reg& reg, const Operand& op) { opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, 0x40 | 15); }//-V524
-void cmovno(const Reg& reg, const Operand& op) { opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, 0x40 | 1); }//-V524
-void cmovnp(const Reg& reg, const Operand& op) { opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, 0x40 | 11); }//-V524
-void cmovns(const Reg& reg, const Operand& op) { opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, 0x40 | 9); }//-V524
-void cmovnz(const Reg& reg, const Operand& op) { opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, 0x40 | 5); }//-V524
-void cmovo(const Reg& reg, const Operand& op) { opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, 0x40 | 0); }//-V524
-void cmovp(const Reg& reg, const Operand& op) { opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, 0x40 | 10); }//-V524
-void cmovpe(const Reg& reg, const Operand& op) { opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, 0x40 | 10); }//-V524
-void cmovpo(const Reg& reg, const Operand& op) { opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, 0x40 | 11); }//-V524
-void cmovs(const Reg& reg, const Operand& op) { opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, 0x40 | 8); }//-V524
-void cmovz(const Reg& reg, const Operand& op) { opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, 0x40 | 4); }//-V524
+void cmova(const Reg& reg, const Operand& op) {
+  opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, 0x40 | 7);
+}  //-V524
+void cmovae(const Reg& reg, const Operand& op) {
+  opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, 0x40 | 3);
+}  //-V524
+void cmovb(const Reg& reg, const Operand& op) {
+  opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, 0x40 | 2);
+}  //-V524
+void cmovbe(const Reg& reg, const Operand& op) {
+  opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, 0x40 | 6);
+}  //-V524
+void cmovc(const Reg& reg, const Operand& op) {
+  opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, 0x40 | 2);
+}  //-V524
+void cmove(const Reg& reg, const Operand& op) {
+  opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, 0x40 | 4);
+}  //-V524
+void cmovg(const Reg& reg, const Operand& op) {
+  opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, 0x40 | 15);
+}  //-V524
+void cmovge(const Reg& reg, const Operand& op) {
+  opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, 0x40 | 13);
+}  //-V524
+void cmovl(const Reg& reg, const Operand& op) {
+  opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, 0x40 | 12);
+}  //-V524
+void cmovle(const Reg& reg, const Operand& op) {
+  opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, 0x40 | 14);
+}  //-V524
+void cmovna(const Reg& reg, const Operand& op) {
+  opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, 0x40 | 6);
+}  //-V524
+void cmovnae(const Reg& reg, const Operand& op) {
+  opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, 0x40 | 2);
+}  //-V524
+void cmovnb(const Reg& reg, const Operand& op) {
+  opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, 0x40 | 3);
+}  //-V524
+void cmovnbe(const Reg& reg, const Operand& op) {
+  opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, 0x40 | 7);
+}  //-V524
+void cmovnc(const Reg& reg, const Operand& op) {
+  opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, 0x40 | 3);
+}  //-V524
+void cmovne(const Reg& reg, const Operand& op) {
+  opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, 0x40 | 5);
+}  //-V524
+void cmovng(const Reg& reg, const Operand& op) {
+  opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, 0x40 | 14);
+}  //-V524
+void cmovnge(const Reg& reg, const Operand& op) {
+  opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, 0x40 | 12);
+}  //-V524
+void cmovnl(const Reg& reg, const Operand& op) {
+  opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, 0x40 | 13);
+}  //-V524
+void cmovnle(const Reg& reg, const Operand& op) {
+  opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, 0x40 | 15);
+}  //-V524
+void cmovno(const Reg& reg, const Operand& op) {
+  opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, 0x40 | 1);
+}  //-V524
+void cmovnp(const Reg& reg, const Operand& op) {
+  opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, 0x40 | 11);
+}  //-V524
+void cmovns(const Reg& reg, const Operand& op) {
+  opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, 0x40 | 9);
+}  //-V524
+void cmovnz(const Reg& reg, const Operand& op) {
+  opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, 0x40 | 5);
+}  //-V524
+void cmovo(const Reg& reg, const Operand& op) {
+  opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, 0x40 | 0);
+}  //-V524
+void cmovp(const Reg& reg, const Operand& op) {
+  opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, 0x40 | 10);
+}  //-V524
+void cmovpe(const Reg& reg, const Operand& op) {
+  opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, 0x40 | 10);
+}  //-V524
+void cmovpo(const Reg& reg, const Operand& op) {
+  opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, 0x40 | 11);
+}  //-V524
+void cmovs(const Reg& reg, const Operand& op) {
+  opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, 0x40 | 8);
+}  //-V524
+void cmovz(const Reg& reg, const Operand& op) {
+  opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, 0x40 | 4);
+}  //-V524
 void cmp(const Operand& op, uint32_t imm) { opRM_I(op, imm, 0x38, 7); }
 void cmp(const Operand& op1, const Operand& op2) { opRM_RM(op1, op2, 0x38); }
 void cmpeqpd(const Xmm& x, const Operand& op) { cmppd(x, op, 0); }
@@ -147,17 +273,30 @@ void cmpsb() { db(0xA6); }
 void cmpsd() { db(0xA7); }
 void cmpsd(const Xmm& xmm, const Operand& op, uint8_t imm8) { opGen(xmm, op, 0xC2, 0xF2, isXMM_XMMorMEM, imm8); }
 void cmpss(const Xmm& xmm, const Operand& op, uint8_t imm8) { opGen(xmm, op, 0xC2, 0xF3, isXMM_XMMorMEM, imm8); }
-void cmpsw() { db(0x66); db(0xA7); }
+void cmpsw() {
+  db(0x66);
+  db(0xA7);
+}
 void cmpunordpd(const Xmm& x, const Operand& op) { cmppd(x, op, 3); }
 void cmpunordps(const Xmm& x, const Operand& op) { cmpps(x, op, 3); }
 void cmpunordsd(const Xmm& x, const Operand& op) { cmpsd(x, op, 3); }
 void cmpunordss(const Xmm& x, const Operand& op) { cmpss(x, op, 3); }
-void cmpxchg(const Operand& op, const Reg& reg) { opModRM(reg, op, (op.isREG() && reg.isREG() && op.getBit() == reg.getBit()), op.isMEM(), 0x0F, 0xB0 | (reg.isBit(8) ? 0 : 1)); }
+void cmpxchg(const Operand& op, const Reg& reg) {
+  opModRM(reg, op, (op.isREG() && reg.isREG() && op.getBit() == reg.getBit()), op.isMEM(), 0x0F,
+          0xB0 | (reg.isBit(8) ? 0 : 1));
+}
 void cmpxchg8b(const Address& addr) { opModM(addr, Reg32(1), 0x0F, 0xC7); }
 void comisd(const Xmm& xmm, const Operand& op) { opGen(xmm, op, 0x2F, 0x66, isXMM_XMMorMEM); }
 void comiss(const Xmm& xmm, const Operand& op) { opGen(xmm, op, 0x2F, 0x100, isXMM_XMMorMEM); }
-void cpuid() { db(0x0F); db(0xA2); }
-void crc32(const Reg32e& reg, const Operand& op) { if (reg.isBit(32) && op.isBit(16)) db(0x66); db(0xF2); opModRM(reg, op, op.isREG(), op.isMEM(), 0x0F, 0x38, 0xF0 | (op.isBit(8) ? 0 : 1)); }
+void cpuid() {
+  db(0x0F);
+  db(0xA2);
+}
+void crc32(const Reg32e& reg, const Operand& op) {
+  if (reg.isBit(32) && op.isBit(16)) db(0x66);
+  db(0xF2);
+  opModRM(reg, op, op.isREG(), op.isMEM(), 0x0F, 0x38, 0xF0 | (op.isBit(8) ? 0 : 1));
+}
 void cvtdq2pd(const Xmm& xmm, const Operand& op) { opGen(xmm, op, 0xE6, 0xF3, isXMM_XMMorMEM); }
 void cvtdq2ps(const Xmm& xmm, const Operand& op) { opGen(xmm, op, 0x5B, 0x100, isXMM_XMMorMEM); }
 void cvtpd2dq(const Xmm& xmm, const Operand& op) { opGen(xmm, op, 0xE6, 0xF2, isXMM_XMMorMEM); }
@@ -180,7 +319,10 @@ void cvttps2dq(const Xmm& xmm, const Operand& op) { opGen(xmm, op, 0x5B, 0xF3, i
 void cvttps2pi(const Operand& reg, const Operand& op) { opGen(reg, op, 0x2C, 0x100, isMMX_XMMorMEM); }
 void cvttsd2si(const Operand& reg, const Operand& op) { opGen(reg, op, 0x2C, 0xF2, isREG32_XMMorMEM); }
 void cvttss2si(const Operand& reg, const Operand& op) { opGen(reg, op, 0x2C, 0xF3, isREG32_XMMorMEM); }
-void cwd() { db(0x66); db(0x99); }
+void cwd() {
+  db(0x66);
+  db(0x99);
+}
 void cwde() { db(0x98); }
 void dec(const Operand& op) { opIncDec(op, 0x48, 1); }
 void div(const Operand& op) { opR_ModM(op, 0, 6, 0xF6); }
@@ -188,25 +330,62 @@ void divpd(const Xmm& xmm, const Operand& op) { opGen(xmm, op, 0x5E, 0x66, isXMM
 void divps(const Xmm& xmm, const Operand& op) { opGen(xmm, op, 0x5E, 0x100, isXMM_XMMorMEM); }
 void divsd(const Xmm& xmm, const Operand& op) { opGen(xmm, op, 0x5E, 0xF2, isXMM_XMMorMEM); }
 void divss(const Xmm& xmm, const Operand& op) { opGen(xmm, op, 0x5E, 0xF3, isXMM_XMMorMEM); }
-void dppd(const Xmm& xmm, const Operand& op, int imm) { opGen(xmm, op, 0x41, 0x66, isXMM_XMMorMEM, static_cast<uint8_t>(imm), 0x3A); }
-void dpps(const Xmm& xmm, const Operand& op, int imm) { opGen(xmm, op, 0x40, 0x66, isXMM_XMMorMEM, static_cast<uint8_t>(imm), 0x3A); }
-void emms() { db(0x0F); db(0x77); }
-void endbr32() { db(0xF3); db(0x0F); db(0x1E); db(0xFB); }
-void endbr64() { db(0xF3); db(0x0F); db(0x1E); db(0xFA); }
-void enter(uint16_t x, uint8_t y) { db(0xC8); dw(x); db(y); }
+void dppd(const Xmm& xmm, const Operand& op, int imm) {
+  opGen(xmm, op, 0x41, 0x66, isXMM_XMMorMEM, static_cast<uint8_t>(imm), 0x3A);
+}
+void dpps(const Xmm& xmm, const Operand& op, int imm) {
+  opGen(xmm, op, 0x40, 0x66, isXMM_XMMorMEM, static_cast<uint8_t>(imm), 0x3A);
+}
+void emms() {
+  db(0x0F);
+  db(0x77);
+}
+void endbr32() {
+  db(0xF3);
+  db(0x0F);
+  db(0x1E);
+  db(0xFB);
+}
+void endbr64() {
+  db(0xF3);
+  db(0x0F);
+  db(0x1E);
+  db(0xFA);
+}
+void enter(uint16_t x, uint8_t y) {
+  db(0xC8);
+  dw(x);
+  db(y);
+}
 void extractps(const Operand& op, const Xmm& xmm, uint8_t imm) { opExt(op, xmm, 0x17, imm); }
-void f2xm1() { db(0xD9); db(0xF0); }
-void fabs() { db(0xD9); db(0xE1); }
+void f2xm1() {
+  db(0xD9);
+  db(0xF0);
+}
+void fabs() {
+  db(0xD9);
+  db(0xE1);
+}
 void fadd(const Address& addr) { opFpuMem(addr, 0x00, 0xD8, 0xDC, 0, 0); }
 void fadd(const Fpu& reg1) { opFpuFpu(st0, reg1, 0xD8C0, 0xDCC0); }
 void fadd(const Fpu& reg1, const Fpu& reg2) { opFpuFpu(reg1, reg2, 0xD8C0, 0xDCC0); }
-void faddp() { db(0xDE); db(0xC1); }
+void faddp() {
+  db(0xDE);
+  db(0xC1);
+}
 void faddp(const Fpu& reg1) { opFpuFpu(reg1, st0, 0x0000, 0xDEC0); }
 void faddp(const Fpu& reg1, const Fpu& reg2) { opFpuFpu(reg1, reg2, 0x0000, 0xDEC0); }
 void fbld(const Address& addr) { opModM(addr, Reg32(4), 0xDF, 0x100); }
 void fbstp(const Address& addr) { opModM(addr, Reg32(6), 0xDF, 0x100); }
-void fchs() { db(0xD9); db(0xE0); }
-void fclex() { db(0x9B); db(0xDB); db(0xE2); }
+void fchs() {
+  db(0xD9);
+  db(0xE0);
+}
+void fclex() {
+  db(0x9B);
+  db(0xDB);
+  db(0xE2);
+}
 void fcmovb(const Fpu& reg1) { opFpuFpu(st0, reg1, 0xDAC0, 0x00C0); }
 void fcmovb(const Fpu& reg1, const Fpu& reg2) { opFpuFpu(reg1, reg2, 0xDAC0, 0x00C0); }
 void fcmovbe(const Fpu& reg1) { opFpuFpu(st0, reg1, 0xDAD0, 0x00D0); }
@@ -223,29 +402,50 @@ void fcmovnu(const Fpu& reg1) { opFpuFpu(st0, reg1, 0xDBD8, 0x00D8); }
 void fcmovnu(const Fpu& reg1, const Fpu& reg2) { opFpuFpu(reg1, reg2, 0xDBD8, 0x00D8); }
 void fcmovu(const Fpu& reg1) { opFpuFpu(st0, reg1, 0xDAD8, 0x00D8); }
 void fcmovu(const Fpu& reg1, const Fpu& reg2) { opFpuFpu(reg1, reg2, 0xDAD8, 0x00D8); }
-void fcom() { db(0xD8); db(0xD1); }
+void fcom() {
+  db(0xD8);
+  db(0xD1);
+}
 void fcom(const Address& addr) { opFpuMem(addr, 0x00, 0xD8, 0xDC, 2, 0); }
 void fcom(const Fpu& reg) { opFpu(reg, 0xD8, 0xD0); }
 void fcomi(const Fpu& reg1) { opFpuFpu(st0, reg1, 0xDBF0, 0x00F0); }
 void fcomi(const Fpu& reg1, const Fpu& reg2) { opFpuFpu(reg1, reg2, 0xDBF0, 0x00F0); }
 void fcomip(const Fpu& reg1) { opFpuFpu(st0, reg1, 0xDFF0, 0x00F0); }
 void fcomip(const Fpu& reg1, const Fpu& reg2) { opFpuFpu(reg1, reg2, 0xDFF0, 0x00F0); }
-void fcomp() { db(0xD8); db(0xD9); }
+void fcomp() {
+  db(0xD8);
+  db(0xD9);
+}
 void fcomp(const Address& addr) { opFpuMem(addr, 0x00, 0xD8, 0xDC, 3, 0); }
 void fcomp(const Fpu& reg) { opFpu(reg, 0xD8, 0xD8); }
-void fcompp() { db(0xDE); db(0xD9); }
-void fcos() { db(0xD9); db(0xFF); }
-void fdecstp() { db(0xD9); db(0xF6); }
+void fcompp() {
+  db(0xDE);
+  db(0xD9);
+}
+void fcos() {
+  db(0xD9);
+  db(0xFF);
+}
+void fdecstp() {
+  db(0xD9);
+  db(0xF6);
+}
 void fdiv(const Address& addr) { opFpuMem(addr, 0x00, 0xD8, 0xDC, 6, 0); }
 void fdiv(const Fpu& reg1) { opFpuFpu(st0, reg1, 0xD8F0, 0xDCF8); }
 void fdiv(const Fpu& reg1, const Fpu& reg2) { opFpuFpu(reg1, reg2, 0xD8F0, 0xDCF8); }
-void fdivp() { db(0xDE); db(0xF9); }
+void fdivp() {
+  db(0xDE);
+  db(0xF9);
+}
 void fdivp(const Fpu& reg1) { opFpuFpu(reg1, st0, 0x0000, 0xDEF8); }
 void fdivp(const Fpu& reg1, const Fpu& reg2) { opFpuFpu(reg1, reg2, 0x0000, 0xDEF8); }
 void fdivr(const Address& addr) { opFpuMem(addr, 0x00, 0xD8, 0xDC, 7, 0); }
 void fdivr(const Fpu& reg1) { opFpuFpu(st0, reg1, 0xD8F8, 0xDCF0); }
 void fdivr(const Fpu& reg1, const Fpu& reg2) { opFpuFpu(reg1, reg2, 0xD8F8, 0xDCF0); }
-void fdivrp() { db(0xDE); db(0xF1); }
+void fdivrp() {
+  db(0xDE);
+  db(0xF1);
+}
 void fdivrp(const Fpu& reg1) { opFpuFpu(reg1, st0, 0x0000, 0xDEF0); }
 void fdivrp(const Fpu& reg1, const Fpu& reg2) { opFpuFpu(reg1, reg2, 0x0000, 0xDEF0); }
 void ffree(const Fpu& reg) { opFpu(reg, 0xDD, 0xC0); }
@@ -256,8 +456,15 @@ void fidiv(const Address& addr) { opFpuMem(addr, 0xDE, 0xDA, 0x00, 6, 0); }
 void fidivr(const Address& addr) { opFpuMem(addr, 0xDE, 0xDA, 0x00, 7, 0); }
 void fild(const Address& addr) { opFpuMem(addr, 0xDF, 0xDB, 0xDF, 0, 5); }
 void fimul(const Address& addr) { opFpuMem(addr, 0xDE, 0xDA, 0x00, 1, 0); }
-void fincstp() { db(0xD9); db(0xF7); }
-void finit() { db(0x9B); db(0xDB); db(0xE3); }
+void fincstp() {
+  db(0xD9);
+  db(0xF7);
+}
+void finit() {
+  db(0x9B);
+  db(0xDB);
+  db(0xE3);
+}
 void fist(const Address& addr) { opFpuMem(addr, 0xDF, 0xDB, 0x00, 2, 0); }
 void fistp(const Address& addr) { opFpuMem(addr, 0xDF, 0xDB, 0xDF, 3, 7); }
 void fisttp(const Address& addr) { opFpuMem(addr, 0xDF, 0xDB, 0xDD, 1, 0); }
@@ -265,80 +472,196 @@ void fisub(const Address& addr) { opFpuMem(addr, 0xDE, 0xDA, 0x00, 4, 0); }
 void fisubr(const Address& addr) { opFpuMem(addr, 0xDE, 0xDA, 0x00, 5, 0); }
 void fld(const Address& addr) { opFpuMem(addr, 0x00, 0xD9, 0xDD, 0, 0); }
 void fld(const Fpu& reg) { opFpu(reg, 0xD9, 0xC0); }
-void fld1() { db(0xD9); db(0xE8); }
+void fld1() {
+  db(0xD9);
+  db(0xE8);
+}
 void fldcw(const Address& addr) { opModM(addr, Reg32(5), 0xD9, 0x100); }
 void fldenv(const Address& addr) { opModM(addr, Reg32(4), 0xD9, 0x100); }
-void fldl2e() { db(0xD9); db(0xEA); }
-void fldl2t() { db(0xD9); db(0xE9); }
-void fldlg2() { db(0xD9); db(0xEC); }
-void fldln2() { db(0xD9); db(0xED); }
-void fldpi() { db(0xD9); db(0xEB); }
-void fldz() { db(0xD9); db(0xEE); }
+void fldl2e() {
+  db(0xD9);
+  db(0xEA);
+}
+void fldl2t() {
+  db(0xD9);
+  db(0xE9);
+}
+void fldlg2() {
+  db(0xD9);
+  db(0xEC);
+}
+void fldln2() {
+  db(0xD9);
+  db(0xED);
+}
+void fldpi() {
+  db(0xD9);
+  db(0xEB);
+}
+void fldz() {
+  db(0xD9);
+  db(0xEE);
+}
 void fmul(const Address& addr) { opFpuMem(addr, 0x00, 0xD8, 0xDC, 1, 0); }
 void fmul(const Fpu& reg1) { opFpuFpu(st0, reg1, 0xD8C8, 0xDCC8); }
 void fmul(const Fpu& reg1, const Fpu& reg2) { opFpuFpu(reg1, reg2, 0xD8C8, 0xDCC8); }
-void fmulp() { db(0xDE); db(0xC9); }
+void fmulp() {
+  db(0xDE);
+  db(0xC9);
+}
 void fmulp(const Fpu& reg1) { opFpuFpu(reg1, st0, 0x0000, 0xDEC8); }
 void fmulp(const Fpu& reg1, const Fpu& reg2) { opFpuFpu(reg1, reg2, 0x0000, 0xDEC8); }
-void fnclex() { db(0xDB); db(0xE2); }
-void fninit() { db(0xDB); db(0xE3); }
-void fnop() { db(0xD9); db(0xD0); }
+void fnclex() {
+  db(0xDB);
+  db(0xE2);
+}
+void fninit() {
+  db(0xDB);
+  db(0xE3);
+}
+void fnop() {
+  db(0xD9);
+  db(0xD0);
+}
 void fnsave(const Address& addr) { opModM(addr, Reg32(6), 0xDD, 0x100); }
 void fnstcw(const Address& addr) { opModM(addr, Reg32(7), 0xD9, 0x100); }
 void fnstenv(const Address& addr) { opModM(addr, Reg32(6), 0xD9, 0x100); }
 void fnstsw(const Address& addr) { opModM(addr, Reg32(7), 0xDD, 0x100); }
-void fnstsw(const Reg16& r) { if (r.getIdx() != Operand::AX) XBYAK_THROW(ERR_BAD_PARAMETER) db(0xDF); db(0xE0); }
-void fpatan() { db(0xD9); db(0xF3); }
-void fprem() { db(0xD9); db(0xF8); }
-void fprem1() { db(0xD9); db(0xF5); }
-void fptan() { db(0xD9); db(0xF2); }
-void frndint() { db(0xD9); db(0xFC); }
+void fnstsw(const Reg16& r) {
+  if (r.getIdx() != Operand::AX) XBYAK_THROW(ERR_BAD_PARAMETER) db(0xDF);
+  db(0xE0);
+}
+void fpatan() {
+  db(0xD9);
+  db(0xF3);
+}
+void fprem() {
+  db(0xD9);
+  db(0xF8);
+}
+void fprem1() {
+  db(0xD9);
+  db(0xF5);
+}
+void fptan() {
+  db(0xD9);
+  db(0xF2);
+}
+void frndint() {
+  db(0xD9);
+  db(0xFC);
+}
 void frstor(const Address& addr) { opModM(addr, Reg32(4), 0xDD, 0x100); }
-void fsave(const Address& addr) { db(0x9B); opModM(addr, Reg32(6), 0xDD, 0x100); }
-void fscale() { db(0xD9); db(0xFD); }
-void fsin() { db(0xD9); db(0xFE); }
-void fsincos() { db(0xD9); db(0xFB); }
-void fsqrt() { db(0xD9); db(0xFA); }
+void fsave(const Address& addr) {
+  db(0x9B);
+  opModM(addr, Reg32(6), 0xDD, 0x100);
+}
+void fscale() {
+  db(0xD9);
+  db(0xFD);
+}
+void fsin() {
+  db(0xD9);
+  db(0xFE);
+}
+void fsincos() {
+  db(0xD9);
+  db(0xFB);
+}
+void fsqrt() {
+  db(0xD9);
+  db(0xFA);
+}
 void fst(const Address& addr) { opFpuMem(addr, 0x00, 0xD9, 0xDD, 2, 0); }
 void fst(const Fpu& reg) { opFpu(reg, 0xDD, 0xD0); }
-void fstcw(const Address& addr) { db(0x9B); opModM(addr, Reg32(7), 0xD9, 0x100); }
-void fstenv(const Address& addr) { db(0x9B); opModM(addr, Reg32(6), 0xD9, 0x100); }
+void fstcw(const Address& addr) {
+  db(0x9B);
+  opModM(addr, Reg32(7), 0xD9, 0x100);
+}
+void fstenv(const Address& addr) {
+  db(0x9B);
+  opModM(addr, Reg32(6), 0xD9, 0x100);
+}
 void fstp(const Address& addr) { opFpuMem(addr, 0x00, 0xD9, 0xDD, 3, 0); }
 void fstp(const Fpu& reg) { opFpu(reg, 0xDD, 0xD8); }
-void fstsw(const Address& addr) { db(0x9B); opModM(addr, Reg32(7), 0xDD, 0x100); }
-void fstsw(const Reg16& r) { if (r.getIdx() != Operand::AX) XBYAK_THROW(ERR_BAD_PARAMETER) db(0x9B); db(0xDF); db(0xE0); }
+void fstsw(const Address& addr) {
+  db(0x9B);
+  opModM(addr, Reg32(7), 0xDD, 0x100);
+}
+void fstsw(const Reg16& r) {
+  if (r.getIdx() != Operand::AX) XBYAK_THROW(ERR_BAD_PARAMETER) db(0x9B);
+  db(0xDF);
+  db(0xE0);
+}
 void fsub(const Address& addr) { opFpuMem(addr, 0x00, 0xD8, 0xDC, 4, 0); }
 void fsub(const Fpu& reg1) { opFpuFpu(st0, reg1, 0xD8E0, 0xDCE8); }
 void fsub(const Fpu& reg1, const Fpu& reg2) { opFpuFpu(reg1, reg2, 0xD8E0, 0xDCE8); }
-void fsubp() { db(0xDE); db(0xE9); }
+void fsubp() {
+  db(0xDE);
+  db(0xE9);
+}
 void fsubp(const Fpu& reg1) { opFpuFpu(reg1, st0, 0x0000, 0xDEE8); }
 void fsubp(const Fpu& reg1, const Fpu& reg2) { opFpuFpu(reg1, reg2, 0x0000, 0xDEE8); }
 void fsubr(const Address& addr) { opFpuMem(addr, 0x00, 0xD8, 0xDC, 5, 0); }
 void fsubr(const Fpu& reg1) { opFpuFpu(st0, reg1, 0xD8E8, 0xDCE0); }
 void fsubr(const Fpu& reg1, const Fpu& reg2) { opFpuFpu(reg1, reg2, 0xD8E8, 0xDCE0); }
-void fsubrp() { db(0xDE); db(0xE1); }
+void fsubrp() {
+  db(0xDE);
+  db(0xE1);
+}
 void fsubrp(const Fpu& reg1) { opFpuFpu(reg1, st0, 0x0000, 0xDEE0); }
 void fsubrp(const Fpu& reg1, const Fpu& reg2) { opFpuFpu(reg1, reg2, 0x0000, 0xDEE0); }
-void ftst() { db(0xD9); db(0xE4); }
-void fucom() { db(0xDD); db(0xE1); }
+void ftst() {
+  db(0xD9);
+  db(0xE4);
+}
+void fucom() {
+  db(0xDD);
+  db(0xE1);
+}
 void fucom(const Fpu& reg) { opFpu(reg, 0xDD, 0xE0); }
 void fucomi(const Fpu& reg1) { opFpuFpu(st0, reg1, 0xDBE8, 0x00E8); }
 void fucomi(const Fpu& reg1, const Fpu& reg2) { opFpuFpu(reg1, reg2, 0xDBE8, 0x00E8); }
 void fucomip(const Fpu& reg1) { opFpuFpu(st0, reg1, 0xDFE8, 0x00E8); }
 void fucomip(const Fpu& reg1, const Fpu& reg2) { opFpuFpu(reg1, reg2, 0xDFE8, 0x00E8); }
-void fucomp() { db(0xDD); db(0xE9); }
+void fucomp() {
+  db(0xDD);
+  db(0xE9);
+}
 void fucomp(const Fpu& reg) { opFpu(reg, 0xDD, 0xE8); }
-void fucompp() { db(0xDA); db(0xE9); }
+void fucompp() {
+  db(0xDA);
+  db(0xE9);
+}
 void fwait() { db(0x9B); }
-void fxam() { db(0xD9); db(0xE5); }
-void fxch() { db(0xD9); db(0xC9); }
+void fxam() {
+  db(0xD9);
+  db(0xE5);
+}
+void fxch() {
+  db(0xD9);
+  db(0xC9);
+}
 void fxch(const Fpu& reg) { opFpu(reg, 0xD9, 0xC8); }
 void fxrstor(const Address& addr) { opModM(addr, Reg32(1), 0x0F, 0xAE); }
-void fxtract() { db(0xD9); db(0xF4); }
-void fyl2x() { db(0xD9); db(0xF1); }
-void fyl2xp1() { db(0xD9); db(0xF9); }
-void gf2p8affineinvqb(const Xmm& xmm, const Operand& op, int imm) { opGen(xmm, op, 0xCF, 0x66, isXMM_XMMorMEM, static_cast<uint8_t>(imm), 0x3A); }
-void gf2p8affineqb(const Xmm& xmm, const Operand& op, int imm) { opGen(xmm, op, 0xCE, 0x66, isXMM_XMMorMEM, static_cast<uint8_t>(imm), 0x3A); }
+void fxtract() {
+  db(0xD9);
+  db(0xF4);
+}
+void fyl2x() {
+  db(0xD9);
+  db(0xF1);
+}
+void fyl2xp1() {
+  db(0xD9);
+  db(0xF9);
+}
+void gf2p8affineinvqb(const Xmm& xmm, const Operand& op, int imm) {
+  opGen(xmm, op, 0xCF, 0x66, isXMM_XMMorMEM, static_cast<uint8_t>(imm), 0x3A);
+}
+void gf2p8affineqb(const Xmm& xmm, const Operand& op, int imm) {
+  opGen(xmm, op, 0xCE, 0x66, isXMM_XMMorMEM, static_cast<uint8_t>(imm), 0x3A);
+}
 void gf2p8mulb(const Xmm& xmm, const Operand& op) { opGen(xmm, op, 0xCF, 0x66, isXMM_XMMorMEM, NONE, 0x38); }
 void haddpd(const Xmm& xmm, const Operand& op) { opGen(xmm, op, 0x7C, 0x66, isXMM_XMMorMEM); }
 void haddps(const Xmm& xmm, const Operand& op) { opGen(xmm, op, 0x7C, 0xF2, isXMM_XMMorMEM); }
@@ -352,222 +675,320 @@ void in_(const Reg& a, uint8_t v) { opInOut(a, 0xE4, v); }
 void inc(const Operand& op) { opIncDec(op, 0x40, 0); }
 void insertps(const Xmm& xmm, const Operand& op, uint8_t imm) { opGen(xmm, op, 0x21, 0x66, isXMM_XMMorMEM, imm, 0x3A); }
 void int3() { db(0xCC); }
-void int_(uint8_t x) { db(0xCD); db(x); }
-void ja(const Label& label, LabelType type = T_AUTO) { opJmp(label, type, 0x77, 0x87, 0x0F); }//-V524
-void ja(const char *label, LabelType type = T_AUTO) { ja(std::string(label), type); }//-V524
-void ja(const void *addr) { opJmpAbs(addr, T_NEAR, 0x77, 0x87, 0x0F); }//-V524
-void ja(std::string label, LabelType type = T_AUTO) { opJmp(label, type, 0x77, 0x87, 0x0F); }//-V524
-void jae(const Label& label, LabelType type = T_AUTO) { opJmp(label, type, 0x73, 0x83, 0x0F); }//-V524
-void jae(const char *label, LabelType type = T_AUTO) { jae(std::string(label), type); }//-V524
-void jae(const void *addr) { opJmpAbs(addr, T_NEAR, 0x73, 0x83, 0x0F); }//-V524
-void jae(std::string label, LabelType type = T_AUTO) { opJmp(label, type, 0x73, 0x83, 0x0F); }//-V524
-void jb(const Label& label, LabelType type = T_AUTO) { opJmp(label, type, 0x72, 0x82, 0x0F); }//-V524
-void jb(const char *label, LabelType type = T_AUTO) { jb(std::string(label), type); }//-V524
-void jb(const void *addr) { opJmpAbs(addr, T_NEAR, 0x72, 0x82, 0x0F); }//-V524
-void jb(std::string label, LabelType type = T_AUTO) { opJmp(label, type, 0x72, 0x82, 0x0F); }//-V524
-void jbe(const Label& label, LabelType type = T_AUTO) { opJmp(label, type, 0x76, 0x86, 0x0F); }//-V524
-void jbe(const char *label, LabelType type = T_AUTO) { jbe(std::string(label), type); }//-V524
-void jbe(const void *addr) { opJmpAbs(addr, T_NEAR, 0x76, 0x86, 0x0F); }//-V524
-void jbe(std::string label, LabelType type = T_AUTO) { opJmp(label, type, 0x76, 0x86, 0x0F); }//-V524
-void jc(const Label& label, LabelType type = T_AUTO) { opJmp(label, type, 0x72, 0x82, 0x0F); }//-V524
-void jc(const char *label, LabelType type = T_AUTO) { jc(std::string(label), type); }//-V524
-void jc(const void *addr) { opJmpAbs(addr, T_NEAR, 0x72, 0x82, 0x0F); }//-V524
-void jc(std::string label, LabelType type = T_AUTO) { opJmp(label, type, 0x72, 0x82, 0x0F); }//-V524
-void je(const Label& label, LabelType type = T_AUTO) { opJmp(label, type, 0x74, 0x84, 0x0F); }//-V524
-void je(const char *label, LabelType type = T_AUTO) { je(std::string(label), type); }//-V524
-void je(const void *addr) { opJmpAbs(addr, T_NEAR, 0x74, 0x84, 0x0F); }//-V524
-void je(std::string label, LabelType type = T_AUTO) { opJmp(label, type, 0x74, 0x84, 0x0F); }//-V524
-void jg(const Label& label, LabelType type = T_AUTO) { opJmp(label, type, 0x7F, 0x8F, 0x0F); }//-V524
-void jg(const char *label, LabelType type = T_AUTO) { jg(std::string(label), type); }//-V524
-void jg(const void *addr) { opJmpAbs(addr, T_NEAR, 0x7F, 0x8F, 0x0F); }//-V524
-void jg(std::string label, LabelType type = T_AUTO) { opJmp(label, type, 0x7F, 0x8F, 0x0F); }//-V524
-void jge(const Label& label, LabelType type = T_AUTO) { opJmp(label, type, 0x7D, 0x8D, 0x0F); }//-V524
-void jge(const char *label, LabelType type = T_AUTO) { jge(std::string(label), type); }//-V524
-void jge(const void *addr) { opJmpAbs(addr, T_NEAR, 0x7D, 0x8D, 0x0F); }//-V524
-void jge(std::string label, LabelType type = T_AUTO) { opJmp(label, type, 0x7D, 0x8D, 0x0F); }//-V524
-void jl(const Label& label, LabelType type = T_AUTO) { opJmp(label, type, 0x7C, 0x8C, 0x0F); }//-V524
-void jl(const char *label, LabelType type = T_AUTO) { jl(std::string(label), type); }//-V524
-void jl(const void *addr) { opJmpAbs(addr, T_NEAR, 0x7C, 0x8C, 0x0F); }//-V524
-void jl(std::string label, LabelType type = T_AUTO) { opJmp(label, type, 0x7C, 0x8C, 0x0F); }//-V524
-void jle(const Label& label, LabelType type = T_AUTO) { opJmp(label, type, 0x7E, 0x8E, 0x0F); }//-V524
-void jle(const char *label, LabelType type = T_AUTO) { jle(std::string(label), type); }//-V524
-void jle(const void *addr) { opJmpAbs(addr, T_NEAR, 0x7E, 0x8E, 0x0F); }//-V524
-void jle(std::string label, LabelType type = T_AUTO) { opJmp(label, type, 0x7E, 0x8E, 0x0F); }//-V524
-void jna(const Label& label, LabelType type = T_AUTO) { opJmp(label, type, 0x76, 0x86, 0x0F); }//-V524
-void jna(const char *label, LabelType type = T_AUTO) { jna(std::string(label), type); }//-V524
-void jna(const void *addr) { opJmpAbs(addr, T_NEAR, 0x76, 0x86, 0x0F); }//-V524
-void jna(std::string label, LabelType type = T_AUTO) { opJmp(label, type, 0x76, 0x86, 0x0F); }//-V524
-void jnae(const Label& label, LabelType type = T_AUTO) { opJmp(label, type, 0x72, 0x82, 0x0F); }//-V524
-void jnae(const char *label, LabelType type = T_AUTO) { jnae(std::string(label), type); }//-V524
-void jnae(const void *addr) { opJmpAbs(addr, T_NEAR, 0x72, 0x82, 0x0F); }//-V524
-void jnae(std::string label, LabelType type = T_AUTO) { opJmp(label, type, 0x72, 0x82, 0x0F); }//-V524
-void jnb(const Label& label, LabelType type = T_AUTO) { opJmp(label, type, 0x73, 0x83, 0x0F); }//-V524
-void jnb(const char *label, LabelType type = T_AUTO) { jnb(std::string(label), type); }//-V524
-void jnb(const void *addr) { opJmpAbs(addr, T_NEAR, 0x73, 0x83, 0x0F); }//-V524
-void jnb(std::string label, LabelType type = T_AUTO) { opJmp(label, type, 0x73, 0x83, 0x0F); }//-V524
-void jnbe(const Label& label, LabelType type = T_AUTO) { opJmp(label, type, 0x77, 0x87, 0x0F); }//-V524
-void jnbe(const char *label, LabelType type = T_AUTO) { jnbe(std::string(label), type); }//-V524
-void jnbe(const void *addr) { opJmpAbs(addr, T_NEAR, 0x77, 0x87, 0x0F); }//-V524
-void jnbe(std::string label, LabelType type = T_AUTO) { opJmp(label, type, 0x77, 0x87, 0x0F); }//-V524
-void jnc(const Label& label, LabelType type = T_AUTO) { opJmp(label, type, 0x73, 0x83, 0x0F); }//-V524
-void jnc(const char *label, LabelType type = T_AUTO) { jnc(std::string(label), type); }//-V524
-void jnc(const void *addr) { opJmpAbs(addr, T_NEAR, 0x73, 0x83, 0x0F); }//-V524
-void jnc(std::string label, LabelType type = T_AUTO) { opJmp(label, type, 0x73, 0x83, 0x0F); }//-V524
-void jne(const Label& label, LabelType type = T_AUTO) { opJmp(label, type, 0x75, 0x85, 0x0F); }//-V524
-void jne(const char *label, LabelType type = T_AUTO) { jne(std::string(label), type); }//-V524
-void jne(const void *addr) { opJmpAbs(addr, T_NEAR, 0x75, 0x85, 0x0F); }//-V524
-void jne(std::string label, LabelType type = T_AUTO) { opJmp(label, type, 0x75, 0x85, 0x0F); }//-V524
-void jng(const Label& label, LabelType type = T_AUTO) { opJmp(label, type, 0x7E, 0x8E, 0x0F); }//-V524
-void jng(const char *label, LabelType type = T_AUTO) { jng(std::string(label), type); }//-V524
-void jng(const void *addr) { opJmpAbs(addr, T_NEAR, 0x7E, 0x8E, 0x0F); }//-V524
-void jng(std::string label, LabelType type = T_AUTO) { opJmp(label, type, 0x7E, 0x8E, 0x0F); }//-V524
-void jnge(const Label& label, LabelType type = T_AUTO) { opJmp(label, type, 0x7C, 0x8C, 0x0F); }//-V524
-void jnge(const char *label, LabelType type = T_AUTO) { jnge(std::string(label), type); }//-V524
-void jnge(const void *addr) { opJmpAbs(addr, T_NEAR, 0x7C, 0x8C, 0x0F); }//-V524
-void jnge(std::string label, LabelType type = T_AUTO) { opJmp(label, type, 0x7C, 0x8C, 0x0F); }//-V524
-void jnl(const Label& label, LabelType type = T_AUTO) { opJmp(label, type, 0x7D, 0x8D, 0x0F); }//-V524
-void jnl(const char *label, LabelType type = T_AUTO) { jnl(std::string(label), type); }//-V524
-void jnl(const void *addr) { opJmpAbs(addr, T_NEAR, 0x7D, 0x8D, 0x0F); }//-V524
-void jnl(std::string label, LabelType type = T_AUTO) { opJmp(label, type, 0x7D, 0x8D, 0x0F); }//-V524
-void jnle(const Label& label, LabelType type = T_AUTO) { opJmp(label, type, 0x7F, 0x8F, 0x0F); }//-V524
-void jnle(const char *label, LabelType type = T_AUTO) { jnle(std::string(label), type); }//-V524
-void jnle(const void *addr) { opJmpAbs(addr, T_NEAR, 0x7F, 0x8F, 0x0F); }//-V524
-void jnle(std::string label, LabelType type = T_AUTO) { opJmp(label, type, 0x7F, 0x8F, 0x0F); }//-V524
-void jno(const Label& label, LabelType type = T_AUTO) { opJmp(label, type, 0x71, 0x81, 0x0F); }//-V524
-void jno(const char *label, LabelType type = T_AUTO) { jno(std::string(label), type); }//-V524
-void jno(const void *addr) { opJmpAbs(addr, T_NEAR, 0x71, 0x81, 0x0F); }//-V524
-void jno(std::string label, LabelType type = T_AUTO) { opJmp(label, type, 0x71, 0x81, 0x0F); }//-V524
-void jnp(const Label& label, LabelType type = T_AUTO) { opJmp(label, type, 0x7B, 0x8B, 0x0F); }//-V524
-void jnp(const char *label, LabelType type = T_AUTO) { jnp(std::string(label), type); }//-V524
-void jnp(const void *addr) { opJmpAbs(addr, T_NEAR, 0x7B, 0x8B, 0x0F); }//-V524
-void jnp(std::string label, LabelType type = T_AUTO) { opJmp(label, type, 0x7B, 0x8B, 0x0F); }//-V524
-void jns(const Label& label, LabelType type = T_AUTO) { opJmp(label, type, 0x79, 0x89, 0x0F); }//-V524
-void jns(const char *label, LabelType type = T_AUTO) { jns(std::string(label), type); }//-V524
-void jns(const void *addr) { opJmpAbs(addr, T_NEAR, 0x79, 0x89, 0x0F); }//-V524
-void jns(std::string label, LabelType type = T_AUTO) { opJmp(label, type, 0x79, 0x89, 0x0F); }//-V524
-void jnz(const Label& label, LabelType type = T_AUTO) { opJmp(label, type, 0x75, 0x85, 0x0F); }//-V524
-void jnz(const char *label, LabelType type = T_AUTO) { jnz(std::string(label), type); }//-V524
-void jnz(const void *addr) { opJmpAbs(addr, T_NEAR, 0x75, 0x85, 0x0F); }//-V524
-void jnz(std::string label, LabelType type = T_AUTO) { opJmp(label, type, 0x75, 0x85, 0x0F); }//-V524
-void jo(const Label& label, LabelType type = T_AUTO) { opJmp(label, type, 0x70, 0x80, 0x0F); }//-V524
-void jo(const char *label, LabelType type = T_AUTO) { jo(std::string(label), type); }//-V524
-void jo(const void *addr) { opJmpAbs(addr, T_NEAR, 0x70, 0x80, 0x0F); }//-V524
-void jo(std::string label, LabelType type = T_AUTO) { opJmp(label, type, 0x70, 0x80, 0x0F); }//-V524
-void jp(const Label& label, LabelType type = T_AUTO) { opJmp(label, type, 0x7A, 0x8A, 0x0F); }//-V524
-void jp(const char *label, LabelType type = T_AUTO) { jp(std::string(label), type); }//-V524
-void jp(const void *addr) { opJmpAbs(addr, T_NEAR, 0x7A, 0x8A, 0x0F); }//-V524
-void jp(std::string label, LabelType type = T_AUTO) { opJmp(label, type, 0x7A, 0x8A, 0x0F); }//-V524
-void jpe(const Label& label, LabelType type = T_AUTO) { opJmp(label, type, 0x7A, 0x8A, 0x0F); }//-V524
-void jpe(const char *label, LabelType type = T_AUTO) { jpe(std::string(label), type); }//-V524
-void jpe(const void *addr) { opJmpAbs(addr, T_NEAR, 0x7A, 0x8A, 0x0F); }//-V524
-void jpe(std::string label, LabelType type = T_AUTO) { opJmp(label, type, 0x7A, 0x8A, 0x0F); }//-V524
-void jpo(const Label& label, LabelType type = T_AUTO) { opJmp(label, type, 0x7B, 0x8B, 0x0F); }//-V524
-void jpo(const char *label, LabelType type = T_AUTO) { jpo(std::string(label), type); }//-V524
-void jpo(const void *addr) { opJmpAbs(addr, T_NEAR, 0x7B, 0x8B, 0x0F); }//-V524
-void jpo(std::string label, LabelType type = T_AUTO) { opJmp(label, type, 0x7B, 0x8B, 0x0F); }//-V524
-void js(const Label& label, LabelType type = T_AUTO) { opJmp(label, type, 0x78, 0x88, 0x0F); }//-V524
-void js(const char *label, LabelType type = T_AUTO) { js(std::string(label), type); }//-V524
-void js(const void *addr) { opJmpAbs(addr, T_NEAR, 0x78, 0x88, 0x0F); }//-V524
-void js(std::string label, LabelType type = T_AUTO) { opJmp(label, type, 0x78, 0x88, 0x0F); }//-V524
-void jz(const Label& label, LabelType type = T_AUTO) { opJmp(label, type, 0x74, 0x84, 0x0F); }//-V524
-void jz(const char *label, LabelType type = T_AUTO) { jz(std::string(label), type); }//-V524
-void jz(const void *addr) { opJmpAbs(addr, T_NEAR, 0x74, 0x84, 0x0F); }//-V524
-void jz(std::string label, LabelType type = T_AUTO) { opJmp(label, type, 0x74, 0x84, 0x0F); }//-V524
+void int_(uint8_t x) {
+  db(0xCD);
+  db(x);
+}
+void ja(const Label& label, LabelType type = T_AUTO) { opJmp(label, type, 0x77, 0x87, 0x0F); }    //-V524
+void ja(const char* label, LabelType type = T_AUTO) { ja(std::string(label), type); }             //-V524
+void ja(const void* addr) { opJmpAbs(addr, T_NEAR, 0x77, 0x87, 0x0F); }                           //-V524
+void ja(std::string label, LabelType type = T_AUTO) { opJmp(label, type, 0x77, 0x87, 0x0F); }     //-V524
+void jae(const Label& label, LabelType type = T_AUTO) { opJmp(label, type, 0x73, 0x83, 0x0F); }   //-V524
+void jae(const char* label, LabelType type = T_AUTO) { jae(std::string(label), type); }           //-V524
+void jae(const void* addr) { opJmpAbs(addr, T_NEAR, 0x73, 0x83, 0x0F); }                          //-V524
+void jae(std::string label, LabelType type = T_AUTO) { opJmp(label, type, 0x73, 0x83, 0x0F); }    //-V524
+void jb(const Label& label, LabelType type = T_AUTO) { opJmp(label, type, 0x72, 0x82, 0x0F); }    //-V524
+void jb(const char* label, LabelType type = T_AUTO) { jb(std::string(label), type); }             //-V524
+void jb(const void* addr) { opJmpAbs(addr, T_NEAR, 0x72, 0x82, 0x0F); }                           //-V524
+void jb(std::string label, LabelType type = T_AUTO) { opJmp(label, type, 0x72, 0x82, 0x0F); }     //-V524
+void jbe(const Label& label, LabelType type = T_AUTO) { opJmp(label, type, 0x76, 0x86, 0x0F); }   //-V524
+void jbe(const char* label, LabelType type = T_AUTO) { jbe(std::string(label), type); }           //-V524
+void jbe(const void* addr) { opJmpAbs(addr, T_NEAR, 0x76, 0x86, 0x0F); }                          //-V524
+void jbe(std::string label, LabelType type = T_AUTO) { opJmp(label, type, 0x76, 0x86, 0x0F); }    //-V524
+void jc(const Label& label, LabelType type = T_AUTO) { opJmp(label, type, 0x72, 0x82, 0x0F); }    //-V524
+void jc(const char* label, LabelType type = T_AUTO) { jc(std::string(label), type); }             //-V524
+void jc(const void* addr) { opJmpAbs(addr, T_NEAR, 0x72, 0x82, 0x0F); }                           //-V524
+void jc(std::string label, LabelType type = T_AUTO) { opJmp(label, type, 0x72, 0x82, 0x0F); }     //-V524
+void je(const Label& label, LabelType type = T_AUTO) { opJmp(label, type, 0x74, 0x84, 0x0F); }    //-V524
+void je(const char* label, LabelType type = T_AUTO) { je(std::string(label), type); }             //-V524
+void je(const void* addr) { opJmpAbs(addr, T_NEAR, 0x74, 0x84, 0x0F); }                           //-V524
+void je(std::string label, LabelType type = T_AUTO) { opJmp(label, type, 0x74, 0x84, 0x0F); }     //-V524
+void jg(const Label& label, LabelType type = T_AUTO) { opJmp(label, type, 0x7F, 0x8F, 0x0F); }    //-V524
+void jg(const char* label, LabelType type = T_AUTO) { jg(std::string(label), type); }             //-V524
+void jg(const void* addr) { opJmpAbs(addr, T_NEAR, 0x7F, 0x8F, 0x0F); }                           //-V524
+void jg(std::string label, LabelType type = T_AUTO) { opJmp(label, type, 0x7F, 0x8F, 0x0F); }     //-V524
+void jge(const Label& label, LabelType type = T_AUTO) { opJmp(label, type, 0x7D, 0x8D, 0x0F); }   //-V524
+void jge(const char* label, LabelType type = T_AUTO) { jge(std::string(label), type); }           //-V524
+void jge(const void* addr) { opJmpAbs(addr, T_NEAR, 0x7D, 0x8D, 0x0F); }                          //-V524
+void jge(std::string label, LabelType type = T_AUTO) { opJmp(label, type, 0x7D, 0x8D, 0x0F); }    //-V524
+void jl(const Label& label, LabelType type = T_AUTO) { opJmp(label, type, 0x7C, 0x8C, 0x0F); }    //-V524
+void jl(const char* label, LabelType type = T_AUTO) { jl(std::string(label), type); }             //-V524
+void jl(const void* addr) { opJmpAbs(addr, T_NEAR, 0x7C, 0x8C, 0x0F); }                           //-V524
+void jl(std::string label, LabelType type = T_AUTO) { opJmp(label, type, 0x7C, 0x8C, 0x0F); }     //-V524
+void jle(const Label& label, LabelType type = T_AUTO) { opJmp(label, type, 0x7E, 0x8E, 0x0F); }   //-V524
+void jle(const char* label, LabelType type = T_AUTO) { jle(std::string(label), type); }           //-V524
+void jle(const void* addr) { opJmpAbs(addr, T_NEAR, 0x7E, 0x8E, 0x0F); }                          //-V524
+void jle(std::string label, LabelType type = T_AUTO) { opJmp(label, type, 0x7E, 0x8E, 0x0F); }    //-V524
+void jna(const Label& label, LabelType type = T_AUTO) { opJmp(label, type, 0x76, 0x86, 0x0F); }   //-V524
+void jna(const char* label, LabelType type = T_AUTO) { jna(std::string(label), type); }           //-V524
+void jna(const void* addr) { opJmpAbs(addr, T_NEAR, 0x76, 0x86, 0x0F); }                          //-V524
+void jna(std::string label, LabelType type = T_AUTO) { opJmp(label, type, 0x76, 0x86, 0x0F); }    //-V524
+void jnae(const Label& label, LabelType type = T_AUTO) { opJmp(label, type, 0x72, 0x82, 0x0F); }  //-V524
+void jnae(const char* label, LabelType type = T_AUTO) { jnae(std::string(label), type); }         //-V524
+void jnae(const void* addr) { opJmpAbs(addr, T_NEAR, 0x72, 0x82, 0x0F); }                         //-V524
+void jnae(std::string label, LabelType type = T_AUTO) { opJmp(label, type, 0x72, 0x82, 0x0F); }   //-V524
+void jnb(const Label& label, LabelType type = T_AUTO) { opJmp(label, type, 0x73, 0x83, 0x0F); }   //-V524
+void jnb(const char* label, LabelType type = T_AUTO) { jnb(std::string(label), type); }           //-V524
+void jnb(const void* addr) { opJmpAbs(addr, T_NEAR, 0x73, 0x83, 0x0F); }                          //-V524
+void jnb(std::string label, LabelType type = T_AUTO) { opJmp(label, type, 0x73, 0x83, 0x0F); }    //-V524
+void jnbe(const Label& label, LabelType type = T_AUTO) { opJmp(label, type, 0x77, 0x87, 0x0F); }  //-V524
+void jnbe(const char* label, LabelType type = T_AUTO) { jnbe(std::string(label), type); }         //-V524
+void jnbe(const void* addr) { opJmpAbs(addr, T_NEAR, 0x77, 0x87, 0x0F); }                         //-V524
+void jnbe(std::string label, LabelType type = T_AUTO) { opJmp(label, type, 0x77, 0x87, 0x0F); }   //-V524
+void jnc(const Label& label, LabelType type = T_AUTO) { opJmp(label, type, 0x73, 0x83, 0x0F); }   //-V524
+void jnc(const char* label, LabelType type = T_AUTO) { jnc(std::string(label), type); }           //-V524
+void jnc(const void* addr) { opJmpAbs(addr, T_NEAR, 0x73, 0x83, 0x0F); }                          //-V524
+void jnc(std::string label, LabelType type = T_AUTO) { opJmp(label, type, 0x73, 0x83, 0x0F); }    //-V524
+void jne(const Label& label, LabelType type = T_AUTO) { opJmp(label, type, 0x75, 0x85, 0x0F); }   //-V524
+void jne(const char* label, LabelType type = T_AUTO) { jne(std::string(label), type); }           //-V524
+void jne(const void* addr) { opJmpAbs(addr, T_NEAR, 0x75, 0x85, 0x0F); }                          //-V524
+void jne(std::string label, LabelType type = T_AUTO) { opJmp(label, type, 0x75, 0x85, 0x0F); }    //-V524
+void jng(const Label& label, LabelType type = T_AUTO) { opJmp(label, type, 0x7E, 0x8E, 0x0F); }   //-V524
+void jng(const char* label, LabelType type = T_AUTO) { jng(std::string(label), type); }           //-V524
+void jng(const void* addr) { opJmpAbs(addr, T_NEAR, 0x7E, 0x8E, 0x0F); }                          //-V524
+void jng(std::string label, LabelType type = T_AUTO) { opJmp(label, type, 0x7E, 0x8E, 0x0F); }    //-V524
+void jnge(const Label& label, LabelType type = T_AUTO) { opJmp(label, type, 0x7C, 0x8C, 0x0F); }  //-V524
+void jnge(const char* label, LabelType type = T_AUTO) { jnge(std::string(label), type); }         //-V524
+void jnge(const void* addr) { opJmpAbs(addr, T_NEAR, 0x7C, 0x8C, 0x0F); }                         //-V524
+void jnge(std::string label, LabelType type = T_AUTO) { opJmp(label, type, 0x7C, 0x8C, 0x0F); }   //-V524
+void jnl(const Label& label, LabelType type = T_AUTO) { opJmp(label, type, 0x7D, 0x8D, 0x0F); }   //-V524
+void jnl(const char* label, LabelType type = T_AUTO) { jnl(std::string(label), type); }           //-V524
+void jnl(const void* addr) { opJmpAbs(addr, T_NEAR, 0x7D, 0x8D, 0x0F); }                          //-V524
+void jnl(std::string label, LabelType type = T_AUTO) { opJmp(label, type, 0x7D, 0x8D, 0x0F); }    //-V524
+void jnle(const Label& label, LabelType type = T_AUTO) { opJmp(label, type, 0x7F, 0x8F, 0x0F); }  //-V524
+void jnle(const char* label, LabelType type = T_AUTO) { jnle(std::string(label), type); }         //-V524
+void jnle(const void* addr) { opJmpAbs(addr, T_NEAR, 0x7F, 0x8F, 0x0F); }                         //-V524
+void jnle(std::string label, LabelType type = T_AUTO) { opJmp(label, type, 0x7F, 0x8F, 0x0F); }   //-V524
+void jno(const Label& label, LabelType type = T_AUTO) { opJmp(label, type, 0x71, 0x81, 0x0F); }   //-V524
+void jno(const char* label, LabelType type = T_AUTO) { jno(std::string(label), type); }           //-V524
+void jno(const void* addr) { opJmpAbs(addr, T_NEAR, 0x71, 0x81, 0x0F); }                          //-V524
+void jno(std::string label, LabelType type = T_AUTO) { opJmp(label, type, 0x71, 0x81, 0x0F); }    //-V524
+void jnp(const Label& label, LabelType type = T_AUTO) { opJmp(label, type, 0x7B, 0x8B, 0x0F); }   //-V524
+void jnp(const char* label, LabelType type = T_AUTO) { jnp(std::string(label), type); }           //-V524
+void jnp(const void* addr) { opJmpAbs(addr, T_NEAR, 0x7B, 0x8B, 0x0F); }                          //-V524
+void jnp(std::string label, LabelType type = T_AUTO) { opJmp(label, type, 0x7B, 0x8B, 0x0F); }    //-V524
+void jns(const Label& label, LabelType type = T_AUTO) { opJmp(label, type, 0x79, 0x89, 0x0F); }   //-V524
+void jns(const char* label, LabelType type = T_AUTO) { jns(std::string(label), type); }           //-V524
+void jns(const void* addr) { opJmpAbs(addr, T_NEAR, 0x79, 0x89, 0x0F); }                          //-V524
+void jns(std::string label, LabelType type = T_AUTO) { opJmp(label, type, 0x79, 0x89, 0x0F); }    //-V524
+void jnz(const Label& label, LabelType type = T_AUTO) { opJmp(label, type, 0x75, 0x85, 0x0F); }   //-V524
+void jnz(const char* label, LabelType type = T_AUTO) { jnz(std::string(label), type); }           //-V524
+void jnz(const void* addr) { opJmpAbs(addr, T_NEAR, 0x75, 0x85, 0x0F); }                          //-V524
+void jnz(std::string label, LabelType type = T_AUTO) { opJmp(label, type, 0x75, 0x85, 0x0F); }    //-V524
+void jo(const Label& label, LabelType type = T_AUTO) { opJmp(label, type, 0x70, 0x80, 0x0F); }    //-V524
+void jo(const char* label, LabelType type = T_AUTO) { jo(std::string(label), type); }             //-V524
+void jo(const void* addr) { opJmpAbs(addr, T_NEAR, 0x70, 0x80, 0x0F); }                           //-V524
+void jo(std::string label, LabelType type = T_AUTO) { opJmp(label, type, 0x70, 0x80, 0x0F); }     //-V524
+void jp(const Label& label, LabelType type = T_AUTO) { opJmp(label, type, 0x7A, 0x8A, 0x0F); }    //-V524
+void jp(const char* label, LabelType type = T_AUTO) { jp(std::string(label), type); }             //-V524
+void jp(const void* addr) { opJmpAbs(addr, T_NEAR, 0x7A, 0x8A, 0x0F); }                           //-V524
+void jp(std::string label, LabelType type = T_AUTO) { opJmp(label, type, 0x7A, 0x8A, 0x0F); }     //-V524
+void jpe(const Label& label, LabelType type = T_AUTO) { opJmp(label, type, 0x7A, 0x8A, 0x0F); }   //-V524
+void jpe(const char* label, LabelType type = T_AUTO) { jpe(std::string(label), type); }           //-V524
+void jpe(const void* addr) { opJmpAbs(addr, T_NEAR, 0x7A, 0x8A, 0x0F); }                          //-V524
+void jpe(std::string label, LabelType type = T_AUTO) { opJmp(label, type, 0x7A, 0x8A, 0x0F); }    //-V524
+void jpo(const Label& label, LabelType type = T_AUTO) { opJmp(label, type, 0x7B, 0x8B, 0x0F); }   //-V524
+void jpo(const char* label, LabelType type = T_AUTO) { jpo(std::string(label), type); }           //-V524
+void jpo(const void* addr) { opJmpAbs(addr, T_NEAR, 0x7B, 0x8B, 0x0F); }                          //-V524
+void jpo(std::string label, LabelType type = T_AUTO) { opJmp(label, type, 0x7B, 0x8B, 0x0F); }    //-V524
+void js(const Label& label, LabelType type = T_AUTO) { opJmp(label, type, 0x78, 0x88, 0x0F); }    //-V524
+void js(const char* label, LabelType type = T_AUTO) { js(std::string(label), type); }             //-V524
+void js(const void* addr) { opJmpAbs(addr, T_NEAR, 0x78, 0x88, 0x0F); }                           //-V524
+void js(std::string label, LabelType type = T_AUTO) { opJmp(label, type, 0x78, 0x88, 0x0F); }     //-V524
+void jz(const Label& label, LabelType type = T_AUTO) { opJmp(label, type, 0x74, 0x84, 0x0F); }    //-V524
+void jz(const char* label, LabelType type = T_AUTO) { jz(std::string(label), type); }             //-V524
+void jz(const void* addr) { opJmpAbs(addr, T_NEAR, 0x74, 0x84, 0x0F); }                           //-V524
+void jz(std::string label, LabelType type = T_AUTO) { opJmp(label, type, 0x74, 0x84, 0x0F); }     //-V524
 void lahf() { db(0x9F); }
-void lddqu(const Xmm& xmm, const Address& addr) { db(0xF2); opModM(addr, xmm, 0x0F, 0xF0); }
+void lddqu(const Xmm& xmm, const Address& addr) {
+  db(0xF2);
+  opModM(addr, xmm, 0x0F, 0xF0);
+}
 void ldmxcsr(const Address& addr) { opModM(addr, Reg32(2), 0x0F, 0xAE); }
-void lea(const Reg& reg, const Address& addr) { if (!reg.isBit(16 | i32e)) XBYAK_THROW(ERR_BAD_SIZE_OF_REGISTER) opModM(addr, reg, 0x8D); }
+void lea(const Reg& reg, const Address& addr) {
+  if (!reg.isBit(16 | i32e)) XBYAK_THROW(ERR_BAD_SIZE_OF_REGISTER) opModM(addr, reg, 0x8D);
+}
 void leave() { db(0xC9); }
-void lfence() { db(0x0F); db(0xAE); db(0xE8); }
+void lfence() {
+  db(0x0F);
+  db(0xAE);
+  db(0xE8);
+}
 void lfs(const Reg& reg, const Address& addr) { opLoadSeg(addr, reg, 0x0F, 0xB4); }
 void lgs(const Reg& reg, const Address& addr) { opLoadSeg(addr, reg, 0x0F, 0xB5); }
 void lock() { db(0xF0); }
 void lodsb() { db(0xAC); }
 void lodsd() { db(0xAD); }
-void lodsw() { db(0x66); db(0xAD); }
+void lodsw() {
+  db(0x66);
+  db(0xAD);
+}
 void loop(const Label& label) { opJmp(label, T_SHORT, 0xE2, 0, 0); }
-void loop(const char *label) { loop(std::string(label)); }
+void loop(const char* label) { loop(std::string(label)); }
 void loop(std::string label) { opJmp(label, T_SHORT, 0xE2, 0, 0); }
 void loope(const Label& label) { opJmp(label, T_SHORT, 0xE1, 0, 0); }
-void loope(const char *label) { loope(std::string(label)); }
+void loope(const char* label) { loope(std::string(label)); }
 void loope(std::string label) { opJmp(label, T_SHORT, 0xE1, 0, 0); }
 void loopne(const Label& label) { opJmp(label, T_SHORT, 0xE0, 0, 0); }
-void loopne(const char *label) { loopne(std::string(label)); }
+void loopne(const char* label) { loopne(std::string(label)); }
 void loopne(std::string label) { opJmp(label, T_SHORT, 0xE0, 0, 0); }
 void lss(const Reg& reg, const Address& addr) { opLoadSeg(addr, reg, 0x0F, 0xB2); }
-void lzcnt(const Reg&reg, const Operand& op) { opSp1(reg, op, 0xF3, 0x0F, 0xBD); }
-void maskmovdqu(const Xmm& reg1, const Xmm& reg2) { db(0x66);  opModR(reg1, reg2, 0x0F, 0xF7); }
-void maskmovq(const Mmx& reg1, const Mmx& reg2) { if (!reg1.isMMX() || !reg2.isMMX()) XBYAK_THROW(ERR_BAD_COMBINATION) opModR(reg1, reg2, 0x0F, 0xF7); }
+void lzcnt(const Reg& reg, const Operand& op) { opSp1(reg, op, 0xF3, 0x0F, 0xBD); }
+void maskmovdqu(const Xmm& reg1, const Xmm& reg2) {
+  db(0x66);
+  opModR(reg1, reg2, 0x0F, 0xF7);
+}
+void maskmovq(const Mmx& reg1, const Mmx& reg2) {
+  if (!reg1.isMMX() || !reg2.isMMX()) XBYAK_THROW(ERR_BAD_COMBINATION) opModR(reg1, reg2, 0x0F, 0xF7);
+}
 void maxpd(const Xmm& xmm, const Operand& op) { opGen(xmm, op, 0x5F, 0x66, isXMM_XMMorMEM); }
 void maxps(const Xmm& xmm, const Operand& op) { opGen(xmm, op, 0x5F, 0x100, isXMM_XMMorMEM); }
 void maxsd(const Xmm& xmm, const Operand& op) { opGen(xmm, op, 0x5F, 0xF2, isXMM_XMMorMEM); }
 void maxss(const Xmm& xmm, const Operand& op) { opGen(xmm, op, 0x5F, 0xF3, isXMM_XMMorMEM); }
-void mfence() { db(0x0F); db(0xAE); db(0xF0); }
+void mfence() {
+  db(0x0F);
+  db(0xAE);
+  db(0xF0);
+}
 void minpd(const Xmm& xmm, const Operand& op) { opGen(xmm, op, 0x5D, 0x66, isXMM_XMMorMEM); }
 void minps(const Xmm& xmm, const Operand& op) { opGen(xmm, op, 0x5D, 0x100, isXMM_XMMorMEM); }
 void minsd(const Xmm& xmm, const Operand& op) { opGen(xmm, op, 0x5D, 0xF2, isXMM_XMMorMEM); }
 void minss(const Xmm& xmm, const Operand& op) { opGen(xmm, op, 0x5D, 0xF3, isXMM_XMMorMEM); }
-void monitor() { db(0x0F); db(0x01); db(0xC8); }
-void monitorx() { db(0x0F); db(0x01); db(0xFA); }
-void movapd(const Address& addr, const Xmm& xmm) { db(0x66); opModM(addr, xmm, 0x0F, 0x29); }
+void monitor() {
+  db(0x0F);
+  db(0x01);
+  db(0xC8);
+}
+void monitorx() {
+  db(0x0F);
+  db(0x01);
+  db(0xFA);
+}
+void movapd(const Address& addr, const Xmm& xmm) {
+  db(0x66);
+  opModM(addr, xmm, 0x0F, 0x29);
+}
 void movapd(const Xmm& xmm, const Operand& op) { opMMX(xmm, op, 0x28, 0x66); }
 void movaps(const Address& addr, const Xmm& xmm) { opModM(addr, xmm, 0x0F, 0x29); }
 void movaps(const Xmm& xmm, const Operand& op) { opMMX(xmm, op, 0x28, 0x100); }
 void movbe(const Address& addr, const Reg& reg) { opModM(addr, reg, 0x0F, 0x38, 0xF1); }
 void movbe(const Reg& reg, const Address& addr) { opModM(addr, reg, 0x0F, 0x38, 0xF0); }
-void movd(const Address& addr, const Mmx& mmx) { if (mmx.isXMM()) db(0x66); opModM(addr, mmx, 0x0F, 0x7E); }
-void movd(const Mmx& mmx, const Address& addr) { if (mmx.isXMM()) db(0x66); opModM(addr, mmx, 0x0F, 0x6E); }
-void movd(const Mmx& mmx, const Reg32& reg) { if (mmx.isXMM()) db(0x66); opModR(mmx, reg, 0x0F, 0x6E); }
-void movd(const Reg32& reg, const Mmx& mmx) { if (mmx.isXMM()) db(0x66); opModR(mmx, reg, 0x0F, 0x7E); }
+void movd(const Address& addr, const Mmx& mmx) {
+  if (mmx.isXMM()) db(0x66);
+  opModM(addr, mmx, 0x0F, 0x7E);
+}
+void movd(const Mmx& mmx, const Address& addr) {
+  if (mmx.isXMM()) db(0x66);
+  opModM(addr, mmx, 0x0F, 0x6E);
+}
+void movd(const Mmx& mmx, const Reg32& reg) {
+  if (mmx.isXMM()) db(0x66);
+  opModR(mmx, reg, 0x0F, 0x6E);
+}
+void movd(const Reg32& reg, const Mmx& mmx) {
+  if (mmx.isXMM()) db(0x66);
+  opModR(mmx, reg, 0x0F, 0x7E);
+}
 void movddup(const Xmm& xmm, const Operand& op) { opGen(xmm, op, 0x12, 0xF2, isXMM_XMMorMEM, NONE, NONE); }
-void movdir64b(const Reg& reg, const Address& addr) { db(0x66); opModM(addr, reg.cvt32(), 0x0F, 0x38, 0xF8); }
+void movdir64b(const Reg& reg, const Address& addr) {
+  db(0x66);
+  opModM(addr, reg.cvt32(), 0x0F, 0x38, 0xF8);
+}
 void movdiri(const Address& addr, const Reg32e& reg) { opModM(addr, reg, 0x0F, 0x38, 0xF9); }
-void movdq2q(const Mmx& mmx, const Xmm& xmm) { db(0xF2); opModR(mmx, xmm, 0x0F, 0xD6); }
-void movdqa(const Address& addr, const Xmm& xmm) { db(0x66); opModM(addr, xmm, 0x0F, 0x7F); }
+void movdq2q(const Mmx& mmx, const Xmm& xmm) {
+  db(0xF2);
+  opModR(mmx, xmm, 0x0F, 0xD6);
+}
+void movdqa(const Address& addr, const Xmm& xmm) {
+  db(0x66);
+  opModM(addr, xmm, 0x0F, 0x7F);
+}
 void movdqa(const Xmm& xmm, const Operand& op) { opMMX(xmm, op, 0x6F, 0x66); }
-void movdqu(const Address& addr, const Xmm& xmm) { db(0xF3); opModM(addr, xmm, 0x0F, 0x7F); }
+void movdqu(const Address& addr, const Xmm& xmm) {
+  db(0xF3);
+  opModM(addr, xmm, 0x0F, 0x7F);
+}
 void movdqu(const Xmm& xmm, const Operand& op) { opMMX(xmm, op, 0x6F, 0xF3); }
-void movhlps(const Xmm& reg1, const Xmm& reg2) {  opModR(reg1, reg2, 0x0F, 0x12); }
+void movhlps(const Xmm& reg1, const Xmm& reg2) { opModR(reg1, reg2, 0x0F, 0x12); }
 void movhpd(const Operand& op1, const Operand& op2) { opMovXMM(op1, op2, 0x16, 0x66); }
 void movhps(const Operand& op1, const Operand& op2) { opMovXMM(op1, op2, 0x16, 0x100); }
-void movlhps(const Xmm& reg1, const Xmm& reg2) {  opModR(reg1, reg2, 0x0F, 0x16); }
+void movlhps(const Xmm& reg1, const Xmm& reg2) { opModR(reg1, reg2, 0x0F, 0x16); }
 void movlpd(const Operand& op1, const Operand& op2) { opMovXMM(op1, op2, 0x12, 0x66); }
 void movlps(const Operand& op1, const Operand& op2) { opMovXMM(op1, op2, 0x12, 0x100); }
-void movmskpd(const Reg32e& reg, const Xmm& xmm) { db(0x66); movmskps(reg, xmm); }
+void movmskpd(const Reg32e& reg, const Xmm& xmm) {
+  db(0x66);
+  movmskps(reg, xmm);
+}
 void movmskps(const Reg32e& reg, const Xmm& xmm) { opModR(reg, xmm, 0x0F, 0x50); }
 void movntdq(const Address& addr, const Xmm& reg) { opModM(addr, Reg16(reg.getIdx()), 0x0F, 0xE7); }
-void movntdqa(const Xmm& xmm, const Address& addr) { db(0x66); opModM(addr, xmm, 0x0F, 0x38, 0x2A); }
+void movntdqa(const Xmm& xmm, const Address& addr) {
+  db(0x66);
+  opModM(addr, xmm, 0x0F, 0x38, 0x2A);
+}
 void movnti(const Address& addr, const Reg32e& reg) { opModM(addr, reg, 0x0F, 0xC3); }
 void movntpd(const Address& addr, const Xmm& reg) { opModM(addr, Reg16(reg.getIdx()), 0x0F, 0x2B); }
 void movntps(const Address& addr, const Xmm& xmm) { opModM(addr, Mmx(xmm.getIdx()), 0x0F, 0x2B); }
-void movntq(const Address& addr, const Mmx& mmx) { if (!mmx.isMMX()) XBYAK_THROW(ERR_BAD_COMBINATION) opModM(addr, mmx, 0x0F, 0xE7); }
-void movq(const Address& addr, const Mmx& mmx) { if (mmx.isXMM()) db(0x66); opModM(addr, mmx, 0x0F, mmx.isXMM() ? 0xD6 : 0x7F); }
-void movq(const Mmx& mmx, const Operand& op) { if (mmx.isXMM()) db(0xF3); opModRM(mmx, op, (mmx.getKind() == op.getKind()), op.isMEM(), 0x0F, mmx.isXMM() ? 0x7E : 0x6F); }
-void movq2dq(const Xmm& xmm, const Mmx& mmx) { db(0xF3); opModR(xmm, mmx, 0x0F, 0xD6); }
+void movntq(const Address& addr, const Mmx& mmx) {
+  if (!mmx.isMMX()) XBYAK_THROW(ERR_BAD_COMBINATION) opModM(addr, mmx, 0x0F, 0xE7);
+}
+void movq(const Address& addr, const Mmx& mmx) {
+  if (mmx.isXMM()) db(0x66);
+  opModM(addr, mmx, 0x0F, mmx.isXMM() ? 0xD6 : 0x7F);
+}
+void movq(const Mmx& mmx, const Operand& op) {
+  if (mmx.isXMM()) db(0xF3);
+  opModRM(mmx, op, (mmx.getKind() == op.getKind()), op.isMEM(), 0x0F, mmx.isXMM() ? 0x7E : 0x6F);
+}
+void movq2dq(const Xmm& xmm, const Mmx& mmx) {
+  db(0xF3);
+  opModR(xmm, mmx, 0x0F, 0xD6);
+}
 void movsb() { db(0xA4); }
 void movsd() { db(0xA5); }
-void movsd(const Address& addr, const Xmm& xmm) { db(0xF2); opModM(addr, xmm, 0x0F, 0x11); }
+void movsd(const Address& addr, const Xmm& xmm) {
+  db(0xF2);
+  opModM(addr, xmm, 0x0F, 0x11);
+}
 void movsd(const Xmm& xmm, const Operand& op) { opMMX(xmm, op, 0x10, 0xF2); }
 void movshdup(const Xmm& xmm, const Operand& op) { opGen(xmm, op, 0x16, 0xF3, isXMM_XMMorMEM, NONE, NONE); }
 void movsldup(const Xmm& xmm, const Operand& op) { opGen(xmm, op, 0x12, 0xF3, isXMM_XMMorMEM, NONE, NONE); }
-void movss(const Address& addr, const Xmm& xmm) { db(0xF3); opModM(addr, xmm, 0x0F, 0x11); }
+void movss(const Address& addr, const Xmm& xmm) {
+  db(0xF3);
+  opModM(addr, xmm, 0x0F, 0x11);
+}
 void movss(const Xmm& xmm, const Operand& op) { opMMX(xmm, op, 0x10, 0xF3); }
-void movsw() { db(0x66); db(0xA5); }
+void movsw() {
+  db(0x66);
+  db(0xA5);
+}
 void movsx(const Reg& reg, const Operand& op) { opMovxx(reg, op, 0xBE); }
-void movupd(const Address& addr, const Xmm& xmm) { db(0x66); opModM(addr, xmm, 0x0F, 0x11); }
+void movupd(const Address& addr, const Xmm& xmm) {
+  db(0x66);
+  opModM(addr, xmm, 0x0F, 0x11);
+}
 void movupd(const Xmm& xmm, const Operand& op) { opMMX(xmm, op, 0x10, 0x66); }
 void movups(const Address& addr, const Xmm& xmm) { opModM(addr, xmm, 0x0F, 0x11); }
 void movups(const Xmm& xmm, const Operand& op) { opMMX(xmm, op, 0x10, 0x100); }
 void movzx(const Reg& reg, const Operand& op) { opMovxx(reg, op, 0xB6); }
-void mpsadbw(const Xmm& xmm, const Operand& op, int imm) { opGen(xmm, op, 0x42, 0x66, isXMM_XMMorMEM, static_cast<uint8_t>(imm), 0x3A); }
+void mpsadbw(const Xmm& xmm, const Operand& op, int imm) {
+  opGen(xmm, op, 0x42, 0x66, isXMM_XMMorMEM, static_cast<uint8_t>(imm), 0x3A);
+}
 void mul(const Operand& op) { opR_ModM(op, 0, 4, 0xF6); }
 void mulpd(const Xmm& xmm, const Operand& op) { opGen(xmm, op, 0x59, 0x66, isXMM_XMMorMEM); }
 void mulps(const Xmm& xmm, const Operand& op) { opGen(xmm, op, 0x59, 0x100, isXMM_XMMorMEM); }
 void mulsd(const Xmm& xmm, const Operand& op) { opGen(xmm, op, 0x59, 0xF2, isXMM_XMMorMEM); }
 void mulss(const Xmm& xmm, const Operand& op) { opGen(xmm, op, 0x59, 0xF3, isXMM_XMMorMEM); }
 void mulx(const Reg32e& r1, const Reg32e& r2, const Operand& op) { opGpr(r1, r2, op, T_F2 | T_0F38, 0xf6, true); }
-void mwait() { db(0x0F); db(0x01); db(0xC9); }
-void mwaitx() { db(0x0F); db(0x01); db(0xFB); }
+void mwait() {
+  db(0x0F);
+  db(0x01);
+  db(0xC9);
+}
+void mwaitx() {
+  db(0x0F);
+  db(0x01);
+  db(0xFB);
+}
 void neg(const Operand& op) { opR_ModM(op, 0, 3, 0xF6); }
 void not_(const Operand& op) { opR_ModM(op, 0, 2, 0xF6); }
 void or_(const Operand& op, uint32_t imm) { opRM_I(op, imm, 0x08, 1); }
@@ -578,7 +999,10 @@ void out_(const Reg& d, const Reg& a) { opInOut(a, d, 0xEE); }
 void out_(uint8_t v, const Reg& a) { opInOut(a, 0xE6, v); }
 void outsb() { db(0x6E); }
 void outsd() { db(0x6F); }
-void outsw() { db(0x66); db(0x6F); }
+void outsw() {
+  db(0x66);
+  db(0x6F);
+}
 void pabsb(const Mmx& mmx, const Operand& op) { opMMX(mmx, op, 0x1C, 0x66, NONE, 0x38); }
 void pabsd(const Mmx& mmx, const Operand& op) { opMMX(mmx, op, 0x1E, 0x66, NONE, 0x38); }
 void pabsw(const Mmx& mmx, const Operand& op) { opMMX(mmx, op, 0x1D, 0x66, NONE, 0x38); }
@@ -594,31 +1018,48 @@ void paddsw(const Mmx& mmx, const Operand& op) { opMMX(mmx, op, 0xED); }
 void paddusb(const Mmx& mmx, const Operand& op) { opMMX(mmx, op, 0xDC); }
 void paddusw(const Mmx& mmx, const Operand& op) { opMMX(mmx, op, 0xDD); }
 void paddw(const Mmx& mmx, const Operand& op) { opMMX(mmx, op, 0xFD); }
-void palignr(const Mmx& mmx, const Operand& op, int imm) { opMMX(mmx, op, 0x0f, 0x66, static_cast<uint8_t>(imm), 0x3a); }
+void palignr(const Mmx& mmx, const Operand& op, int imm) {
+  opMMX(mmx, op, 0x0f, 0x66, static_cast<uint8_t>(imm), 0x3a);
+}
 void pand(const Mmx& mmx, const Operand& op) { opMMX(mmx, op, 0xDB); }
 void pandn(const Mmx& mmx, const Operand& op) { opMMX(mmx, op, 0xDF); }
-void pause() { db(0xF3); db(0x90); }
+void pause() {
+  db(0xF3);
+  db(0x90);
+}
 void pavgb(const Mmx& mmx, const Operand& op) { opMMX(mmx, op, 0xE0); }
 void pavgw(const Mmx& mmx, const Operand& op) { opMMX(mmx, op, 0xE3); }
 void pblendvb(const Xmm& xmm, const Operand& op) { opGen(xmm, op, 0x10, 0x66, isXMM_XMMorMEM, NONE, 0x38); }
-void pblendw(const Xmm& xmm, const Operand& op, int imm) { opGen(xmm, op, 0x0E, 0x66, isXMM_XMMorMEM, static_cast<uint8_t>(imm), 0x3A); }
+void pblendw(const Xmm& xmm, const Operand& op, int imm) {
+  opGen(xmm, op, 0x0E, 0x66, isXMM_XMMorMEM, static_cast<uint8_t>(imm), 0x3A);
+}
 void pclmulhqhqdq(const Xmm& xmm, const Operand& op) { pclmulqdq(xmm, op, 0x11); }
 void pclmulhqlqdq(const Xmm& xmm, const Operand& op) { pclmulqdq(xmm, op, 0x01); }
 void pclmullqhqdq(const Xmm& xmm, const Operand& op) { pclmulqdq(xmm, op, 0x10); }
 void pclmullqlqdq(const Xmm& xmm, const Operand& op) { pclmulqdq(xmm, op, 0x00); }
-void pclmulqdq(const Xmm& xmm, const Operand& op, int imm) { opGen(xmm, op, 0x44, 0x66, isXMM_XMMorMEM, static_cast<uint8_t>(imm), 0x3A); }
+void pclmulqdq(const Xmm& xmm, const Operand& op, int imm) {
+  opGen(xmm, op, 0x44, 0x66, isXMM_XMMorMEM, static_cast<uint8_t>(imm), 0x3A);
+}
 void pcmpeqb(const Mmx& mmx, const Operand& op) { opMMX(mmx, op, 0x74); }
 void pcmpeqd(const Mmx& mmx, const Operand& op) { opMMX(mmx, op, 0x76); }
 void pcmpeqq(const Xmm& xmm, const Operand& op) { opGen(xmm, op, 0x29, 0x66, isXMM_XMMorMEM, NONE, 0x38); }
 void pcmpeqw(const Mmx& mmx, const Operand& op) { opMMX(mmx, op, 0x75); }
-void pcmpestri(const Xmm& xmm, const Operand& op, uint8_t imm) { opGen(xmm, op, 0x61, 0x66, isXMM_XMMorMEM, imm, 0x3A); }
-void pcmpestrm(const Xmm& xmm, const Operand& op, uint8_t imm) { opGen(xmm, op, 0x60, 0x66, isXMM_XMMorMEM, imm, 0x3A); }
+void pcmpestri(const Xmm& xmm, const Operand& op, uint8_t imm) {
+  opGen(xmm, op, 0x61, 0x66, isXMM_XMMorMEM, imm, 0x3A);
+}
+void pcmpestrm(const Xmm& xmm, const Operand& op, uint8_t imm) {
+  opGen(xmm, op, 0x60, 0x66, isXMM_XMMorMEM, imm, 0x3A);
+}
 void pcmpgtb(const Mmx& mmx, const Operand& op) { opMMX(mmx, op, 0x64); }
 void pcmpgtd(const Mmx& mmx, const Operand& op) { opMMX(mmx, op, 0x66); }
 void pcmpgtq(const Xmm& xmm, const Operand& op) { opGen(xmm, op, 0x37, 0x66, isXMM_XMMorMEM, NONE, 0x38); }
 void pcmpgtw(const Mmx& mmx, const Operand& op) { opMMX(mmx, op, 0x65); }
-void pcmpistri(const Xmm& xmm, const Operand& op, uint8_t imm) { opGen(xmm, op, 0x63, 0x66, isXMM_XMMorMEM, imm, 0x3A); }
-void pcmpistrm(const Xmm& xmm, const Operand& op, uint8_t imm) { opGen(xmm, op, 0x62, 0x66, isXMM_XMMorMEM, imm, 0x3A); }
+void pcmpistri(const Xmm& xmm, const Operand& op, uint8_t imm) {
+  opGen(xmm, op, 0x63, 0x66, isXMM_XMMorMEM, imm, 0x3A);
+}
+void pcmpistrm(const Xmm& xmm, const Operand& op, uint8_t imm) {
+  opGen(xmm, op, 0x62, 0x66, isXMM_XMMorMEM, imm, 0x3A);
+}
 void pdep(const Reg32e& r1, const Reg32e& r2, const Operand& op) { opGpr(r1, r2, op, T_F2 | T_0F38, 0xf5, true); }
 void pext(const Reg32e& r1, const Reg32e& r2, const Operand& op) { opGpr(r1, r2, op, T_F3 | T_0F38, 0xf5, true); }
 void pextrb(const Operand& op, const Xmm& xmm, uint8_t imm) { opExt(op, xmm, 0x14, imm); }
@@ -633,7 +1074,10 @@ void phsubsw(const Mmx& mmx, const Operand& op) { opMMX(mmx, op, 0x07, 0x66, NON
 void phsubw(const Mmx& mmx, const Operand& op) { opMMX(mmx, op, 0x05, 0x66, NONE, 0x38); }
 void pinsrb(const Xmm& xmm, const Operand& op, uint8_t imm) { opGen(xmm, op, 0x20, 0x66, isXMM_REG32orMEM, imm, 0x3A); }
 void pinsrd(const Xmm& xmm, const Operand& op, uint8_t imm) { opGen(xmm, op, 0x22, 0x66, isXMM_REG32orMEM, imm, 0x3A); }
-void pinsrw(const Mmx& mmx, const Operand& op, int imm) { if (!op.isREG(32) && !op.isMEM()) XBYAK_THROW(ERR_BAD_COMBINATION) opGen(mmx, op, 0xC4, mmx.isXMM() ? 0x66 : NONE, 0, imm); }
+void pinsrw(const Mmx& mmx, const Operand& op, int imm) {
+  if (!op.isREG(32) && !op.isMEM())
+    XBYAK_THROW(ERR_BAD_COMBINATION) opGen(mmx, op, 0xC4, mmx.isXMM() ? 0x66 : NONE, 0, imm);
+}
 void pmaddubsw(const Mmx& mmx, const Operand& op) { opMMX(mmx, op, 0x04, 0x66, NONE, 0x38); }
 void pmaddwd(const Mmx& mmx, const Operand& op) { opMMX(mmx, op, 0xF5); }
 void pmaxsb(const Xmm& xmm, const Operand& op) { opGen(xmm, op, 0x3C, 0x66, isXMM_XMMorMEM, NONE, 0x38); }
@@ -648,7 +1092,10 @@ void pminsw(const Mmx& mmx, const Operand& op) { opMMX(mmx, op, 0xEA); }
 void pminub(const Mmx& mmx, const Operand& op) { opMMX(mmx, op, 0xDA); }
 void pminud(const Xmm& xmm, const Operand& op) { opGen(xmm, op, 0x3B, 0x66, isXMM_XMMorMEM, NONE, 0x38); }
 void pminuw(const Xmm& xmm, const Operand& op) { opGen(xmm, op, 0x3A, 0x66, isXMM_XMMorMEM, NONE, 0x38); }
-void pmovmskb(const Reg32e& reg, const Mmx& mmx) { if (mmx.isXMM()) db(0x66); opModR(reg, mmx, 0x0F, 0xD7); }
+void pmovmskb(const Reg32e& reg, const Mmx& mmx) {
+  if (mmx.isXMM()) db(0x66);
+  opModR(reg, mmx, 0x0F, 0xD7);
+}
 void pmovsxbd(const Xmm& xmm, const Operand& op) { opGen(xmm, op, 0x21, 0x66, isXMM_XMMorMEM, NONE, 0x38); }
 void pmovsxbq(const Xmm& xmm, const Operand& op) { opGen(xmm, op, 0x22, 0x66, isXMM_XMMorMEM, NONE, 0x38); }
 void pmovsxbw(const Xmm& xmm, const Operand& op) { opGen(xmm, op, 0x20, 0x66, isXMM_XMMorMEM, NONE, 0x38); }
@@ -668,7 +1115,7 @@ void pmulhw(const Mmx& mmx, const Operand& op) { opMMX(mmx, op, 0xE5); }
 void pmulld(const Xmm& xmm, const Operand& op) { opGen(xmm, op, 0x40, 0x66, isXMM_XMMorMEM, NONE, 0x38); }
 void pmullw(const Mmx& mmx, const Operand& op) { opMMX(mmx, op, 0xD5); }
 void pmuludq(const Mmx& mmx, const Operand& op) { opMMX(mmx, op, 0xF4); }
-void popcnt(const Reg&reg, const Operand& op) { opSp1(reg, op, 0xF3, 0x0F, 0xB8); }
+void popcnt(const Reg& reg, const Operand& op) { opSp1(reg, op, 0xF3, 0x0F, 0xB8); }
 void popf() { db(0x9D); }
 void por(const Mmx& mmx, const Operand& op) { opMMX(mmx, op, 0xEB); }
 void prefetchit0(const Address& addr) { opModM(addr, Reg32(7), 0x0F, 0x18); }
@@ -731,28 +1178,65 @@ void rcpps(const Xmm& xmm, const Operand& op) { opGen(xmm, op, 0x53, 0x100, isXM
 void rcpss(const Xmm& xmm, const Operand& op) { opGen(xmm, op, 0x53, 0xF3, isXMM_XMMorMEM); }
 void rcr(const Operand& op, const Reg8& _cl) { opShift(op, _cl, 3); }
 void rcr(const Operand& op, int imm) { opShift(op, imm, 3); }
-void rdmsr() { db(0x0F); db(0x32); }
-void rdpmc() { db(0x0F); db(0x33); }
-void rdrand(const Reg& r) { if (r.isBit(8)) XBYAK_THROW(ERR_BAD_SIZE_OF_REGISTER) opModR(Reg(6, Operand::REG, r.getBit()), r, 0x0F, 0xC7); }
-void rdseed(const Reg& r) { if (r.isBit(8)) XBYAK_THROW(ERR_BAD_SIZE_OF_REGISTER) opModR(Reg(7, Operand::REG, r.getBit()), r, 0x0F, 0xC7); }
-void rdtsc() { db(0x0F); db(0x31); }
-void rdtscp() { db(0x0F); db(0x01); db(0xF9); }
+void rdmsr() {
+  db(0x0F);
+  db(0x32);
+}
+void rdpmc() {
+  db(0x0F);
+  db(0x33);
+}
+void rdrand(const Reg& r) {
+  if (r.isBit(8)) XBYAK_THROW(ERR_BAD_SIZE_OF_REGISTER) opModR(Reg(6, Operand::REG, r.getBit()), r, 0x0F, 0xC7);
+}
+void rdseed(const Reg& r) {
+  if (r.isBit(8)) XBYAK_THROW(ERR_BAD_SIZE_OF_REGISTER) opModR(Reg(7, Operand::REG, r.getBit()), r, 0x0F, 0xC7);
+}
+void rdtsc() {
+  db(0x0F);
+  db(0x31);
+}
+void rdtscp() {
+  db(0x0F);
+  db(0x01);
+  db(0xF9);
+}
 void rep() { db(0xF3); }
 void repe() { db(0xF3); }
 void repne() { db(0xF2); }
 void repnz() { db(0xF2); }
 void repz() { db(0xF3); }
-void ret(int imm = 0) { if (imm) { db(0xC2); dw(imm); } else { db(0xC3); } }
-void retf(int imm = 0) { if (imm) { db(0xCA); dw(imm); } else { db(0xCB); } }
+void ret(int imm = 0) {
+  if (imm) {
+    db(0xC2);
+    dw(imm);
+  } else {
+    db(0xC3);
+  }
+}
+void retf(int imm = 0) {
+  if (imm) {
+    db(0xCA);
+    dw(imm);
+  } else {
+    db(0xCB);
+  }
+}
 void rol(const Operand& op, const Reg8& _cl) { opShift(op, _cl, 0); }
 void rol(const Operand& op, int imm) { opShift(op, imm, 0); }
 void ror(const Operand& op, const Reg8& _cl) { opShift(op, _cl, 1); }
 void ror(const Operand& op, int imm) { opShift(op, imm, 1); }
-void rorx(const Reg32e& r, const Operand& op, uint8_t imm) { opGpr(r, op, Reg32e(0, r.getBit()), T_0F3A | T_F2, 0xF0, false, imm); }
+void rorx(const Reg32e& r, const Operand& op, uint8_t imm) {
+  opGpr(r, op, Reg32e(0, r.getBit()), T_0F3A | T_F2, 0xF0, false, imm);
+}
 void roundpd(const Xmm& xmm, const Operand& op, uint8_t imm) { opGen(xmm, op, 0x09, 0x66, isXMM_XMMorMEM, imm, 0x3A); }
 void roundps(const Xmm& xmm, const Operand& op, uint8_t imm) { opGen(xmm, op, 0x08, 0x66, isXMM_XMMorMEM, imm, 0x3A); }
-void roundsd(const Xmm& xmm, const Operand& op, int imm) { opGen(xmm, op, 0x0B, 0x66, isXMM_XMMorMEM, static_cast<uint8_t>(imm), 0x3A); }
-void roundss(const Xmm& xmm, const Operand& op, int imm) { opGen(xmm, op, 0x0A, 0x66, isXMM_XMMorMEM, static_cast<uint8_t>(imm), 0x3A); }
+void roundsd(const Xmm& xmm, const Operand& op, int imm) {
+  opGen(xmm, op, 0x0B, 0x66, isXMM_XMMorMEM, static_cast<uint8_t>(imm), 0x3A);
+}
+void roundss(const Xmm& xmm, const Operand& op, int imm) {
+  opGen(xmm, op, 0x0A, 0x66, isXMM_XMMorMEM, static_cast<uint8_t>(imm), 0x3A);
+}
 void rsqrtps(const Xmm& xmm, const Operand& op) { opGen(xmm, op, 0x52, 0x100, isXMM_XMMorMEM); }
 void rsqrtss(const Xmm& xmm, const Operand& op) { opGen(xmm, op, 0x52, 0xF3, isXMM_XMMorMEM); }
 void sahf() { db(0x9E); }
@@ -765,43 +1249,56 @@ void sbb(const Operand& op, uint32_t imm) { opRM_I(op, imm, 0x18, 3); }
 void sbb(const Operand& op1, const Operand& op2) { opRM_RM(op1, op2, 0x18); }
 void scasb() { db(0xAE); }
 void scasd() { db(0xAF); }
-void scasw() { db(0x66); db(0xAF); }
-void serialize() { db(0x0F); db(0x01); db(0xE8); }
-void seta(const Operand& op) { opR_ModM(op, 8, 0, 0x0F, 0x90 | 7); }//-V524
-void setae(const Operand& op) { opR_ModM(op, 8, 0, 0x0F, 0x90 | 3); }//-V524
-void setb(const Operand& op) { opR_ModM(op, 8, 0, 0x0F, 0x90 | 2); }//-V524
-void setbe(const Operand& op) { opR_ModM(op, 8, 0, 0x0F, 0x90 | 6); }//-V524
-void setc(const Operand& op) { opR_ModM(op, 8, 0, 0x0F, 0x90 | 2); }//-V524
-void sete(const Operand& op) { opR_ModM(op, 8, 0, 0x0F, 0x90 | 4); }//-V524
-void setg(const Operand& op) { opR_ModM(op, 8, 0, 0x0F, 0x90 | 15); }//-V524
-void setge(const Operand& op) { opR_ModM(op, 8, 0, 0x0F, 0x90 | 13); }//-V524
-void setl(const Operand& op) { opR_ModM(op, 8, 0, 0x0F, 0x90 | 12); }//-V524
-void setle(const Operand& op) { opR_ModM(op, 8, 0, 0x0F, 0x90 | 14); }//-V524
-void setna(const Operand& op) { opR_ModM(op, 8, 0, 0x0F, 0x90 | 6); }//-V524
-void setnae(const Operand& op) { opR_ModM(op, 8, 0, 0x0F, 0x90 | 2); }//-V524
-void setnb(const Operand& op) { opR_ModM(op, 8, 0, 0x0F, 0x90 | 3); }//-V524
-void setnbe(const Operand& op) { opR_ModM(op, 8, 0, 0x0F, 0x90 | 7); }//-V524
-void setnc(const Operand& op) { opR_ModM(op, 8, 0, 0x0F, 0x90 | 3); }//-V524
-void setne(const Operand& op) { opR_ModM(op, 8, 0, 0x0F, 0x90 | 5); }//-V524
-void setng(const Operand& op) { opR_ModM(op, 8, 0, 0x0F, 0x90 | 14); }//-V524
-void setnge(const Operand& op) { opR_ModM(op, 8, 0, 0x0F, 0x90 | 12); }//-V524
-void setnl(const Operand& op) { opR_ModM(op, 8, 0, 0x0F, 0x90 | 13); }//-V524
-void setnle(const Operand& op) { opR_ModM(op, 8, 0, 0x0F, 0x90 | 15); }//-V524
-void setno(const Operand& op) { opR_ModM(op, 8, 0, 0x0F, 0x90 | 1); }//-V524
-void setnp(const Operand& op) { opR_ModM(op, 8, 0, 0x0F, 0x90 | 11); }//-V524
-void setns(const Operand& op) { opR_ModM(op, 8, 0, 0x0F, 0x90 | 9); }//-V524
-void setnz(const Operand& op) { opR_ModM(op, 8, 0, 0x0F, 0x90 | 5); }//-V524
-void seto(const Operand& op) { opR_ModM(op, 8, 0, 0x0F, 0x90 | 0); }//-V524
-void setp(const Operand& op) { opR_ModM(op, 8, 0, 0x0F, 0x90 | 10); }//-V524
-void setpe(const Operand& op) { opR_ModM(op, 8, 0, 0x0F, 0x90 | 10); }//-V524
-void setpo(const Operand& op) { opR_ModM(op, 8, 0, 0x0F, 0x90 | 11); }//-V524
-void sets(const Operand& op) { opR_ModM(op, 8, 0, 0x0F, 0x90 | 8); }//-V524
-void setz(const Operand& op) { opR_ModM(op, 8, 0, 0x0F, 0x90 | 4); }//-V524
-void sfence() { db(0x0F); db(0xAE); db(0xF8); }
+void scasw() {
+  db(0x66);
+  db(0xAF);
+}
+void serialize() {
+  db(0x0F);
+  db(0x01);
+  db(0xE8);
+}
+void seta(const Operand& op) { opR_ModM(op, 8, 0, 0x0F, 0x90 | 7); }     //-V524
+void setae(const Operand& op) { opR_ModM(op, 8, 0, 0x0F, 0x90 | 3); }    //-V524
+void setb(const Operand& op) { opR_ModM(op, 8, 0, 0x0F, 0x90 | 2); }     //-V524
+void setbe(const Operand& op) { opR_ModM(op, 8, 0, 0x0F, 0x90 | 6); }    //-V524
+void setc(const Operand& op) { opR_ModM(op, 8, 0, 0x0F, 0x90 | 2); }     //-V524
+void sete(const Operand& op) { opR_ModM(op, 8, 0, 0x0F, 0x90 | 4); }     //-V524
+void setg(const Operand& op) { opR_ModM(op, 8, 0, 0x0F, 0x90 | 15); }    //-V524
+void setge(const Operand& op) { opR_ModM(op, 8, 0, 0x0F, 0x90 | 13); }   //-V524
+void setl(const Operand& op) { opR_ModM(op, 8, 0, 0x0F, 0x90 | 12); }    //-V524
+void setle(const Operand& op) { opR_ModM(op, 8, 0, 0x0F, 0x90 | 14); }   //-V524
+void setna(const Operand& op) { opR_ModM(op, 8, 0, 0x0F, 0x90 | 6); }    //-V524
+void setnae(const Operand& op) { opR_ModM(op, 8, 0, 0x0F, 0x90 | 2); }   //-V524
+void setnb(const Operand& op) { opR_ModM(op, 8, 0, 0x0F, 0x90 | 3); }    //-V524
+void setnbe(const Operand& op) { opR_ModM(op, 8, 0, 0x0F, 0x90 | 7); }   //-V524
+void setnc(const Operand& op) { opR_ModM(op, 8, 0, 0x0F, 0x90 | 3); }    //-V524
+void setne(const Operand& op) { opR_ModM(op, 8, 0, 0x0F, 0x90 | 5); }    //-V524
+void setng(const Operand& op) { opR_ModM(op, 8, 0, 0x0F, 0x90 | 14); }   //-V524
+void setnge(const Operand& op) { opR_ModM(op, 8, 0, 0x0F, 0x90 | 12); }  //-V524
+void setnl(const Operand& op) { opR_ModM(op, 8, 0, 0x0F, 0x90 | 13); }   //-V524
+void setnle(const Operand& op) { opR_ModM(op, 8, 0, 0x0F, 0x90 | 15); }  //-V524
+void setno(const Operand& op) { opR_ModM(op, 8, 0, 0x0F, 0x90 | 1); }    //-V524
+void setnp(const Operand& op) { opR_ModM(op, 8, 0, 0x0F, 0x90 | 11); }   //-V524
+void setns(const Operand& op) { opR_ModM(op, 8, 0, 0x0F, 0x90 | 9); }    //-V524
+void setnz(const Operand& op) { opR_ModM(op, 8, 0, 0x0F, 0x90 | 5); }    //-V524
+void seto(const Operand& op) { opR_ModM(op, 8, 0, 0x0F, 0x90 | 0); }     //-V524
+void setp(const Operand& op) { opR_ModM(op, 8, 0, 0x0F, 0x90 | 10); }    //-V524
+void setpe(const Operand& op) { opR_ModM(op, 8, 0, 0x0F, 0x90 | 10); }   //-V524
+void setpo(const Operand& op) { opR_ModM(op, 8, 0, 0x0F, 0x90 | 11); }   //-V524
+void sets(const Operand& op) { opR_ModM(op, 8, 0, 0x0F, 0x90 | 8); }     //-V524
+void setz(const Operand& op) { opR_ModM(op, 8, 0, 0x0F, 0x90 | 4); }     //-V524
+void sfence() {
+  db(0x0F);
+  db(0xAE);
+  db(0xF8);
+}
 void sha1msg1(const Xmm& xmm, const Operand& op) { opGen(xmm, op, 0xC9, NONE, isXMM_XMMorMEM, NONE, 0x38); }
 void sha1msg2(const Xmm& xmm, const Operand& op) { opGen(xmm, op, 0xCA, NONE, isXMM_XMMorMEM, NONE, 0x38); }
 void sha1nexte(const Xmm& xmm, const Operand& op) { opGen(xmm, op, 0xC8, NONE, isXMM_XMMorMEM, NONE, 0x38); }
-void sha1rnds4(const Xmm& xmm, const Operand& op, uint8_t imm) { opGen(xmm, op, 0xCC, NONE, isXMM_XMMorMEM, imm, 0x3A); }
+void sha1rnds4(const Xmm& xmm, const Operand& op, uint8_t imm) {
+  opGen(xmm, op, 0xCC, NONE, isXMM_XMMorMEM, imm, 0x3A);
+}
 void sha256msg1(const Xmm& xmm, const Operand& op) { opGen(xmm, op, 0xCC, NONE, isXMM_XMMorMEM, NONE, 0x38); }
 void sha256msg2(const Xmm& xmm, const Operand& op) { opGen(xmm, op, 0xCD, NONE, isXMM_XMMorMEM, NONE, 0x38); }
 void sha256rnds2(const Xmm& xmm, const Operand& op) { opGen(xmm, op, 0xCB, NONE, isXMM_XMMorMEM, NONE, 0x38); }
@@ -821,59 +1318,147 @@ void sqrtpd(const Xmm& xmm, const Operand& op) { opGen(xmm, op, 0x51, 0x66, isXM
 void sqrtps(const Xmm& xmm, const Operand& op) { opGen(xmm, op, 0x51, 0x100, isXMM_XMMorMEM); }
 void sqrtsd(const Xmm& xmm, const Operand& op) { opGen(xmm, op, 0x51, 0xF2, isXMM_XMMorMEM); }
 void sqrtss(const Xmm& xmm, const Operand& op) { opGen(xmm, op, 0x51, 0xF3, isXMM_XMMorMEM); }
-void stac() { db(0x0F); db(0x01); db(0xCB); }
+void stac() {
+  db(0x0F);
+  db(0x01);
+  db(0xCB);
+}
 void stc() { db(0xF9); }
 void std() { db(0xFD); }
 void sti() { db(0xFB); }
 void stmxcsr(const Address& addr) { opModM(addr, Reg32(3), 0x0F, 0xAE); }
 void stosb() { db(0xAA); }
 void stosd() { db(0xAB); }
-void stosw() { db(0x66); db(0xAB); }
+void stosw() {
+  db(0x66);
+  db(0xAB);
+}
 void sub(const Operand& op, uint32_t imm) { opRM_I(op, imm, 0x28, 5); }
 void sub(const Operand& op1, const Operand& op2) { opRM_RM(op1, op2, 0x28); }
 void subpd(const Xmm& xmm, const Operand& op) { opGen(xmm, op, 0x5C, 0x66, isXMM_XMMorMEM); }
 void subps(const Xmm& xmm, const Operand& op) { opGen(xmm, op, 0x5C, 0x100, isXMM_XMMorMEM); }
 void subsd(const Xmm& xmm, const Operand& op) { opGen(xmm, op, 0x5C, 0xF2, isXMM_XMMorMEM); }
 void subss(const Xmm& xmm, const Operand& op) { opGen(xmm, op, 0x5C, 0xF3, isXMM_XMMorMEM); }
-void sysenter() { db(0x0F); db(0x34); }
-void sysexit() { db(0x0F); db(0x35); }
-void tpause(const Reg32& r) { int idx = r.getIdx(); if (idx > 7) XBYAK_THROW(ERR_BAD_PARAMETER) db(0x66); db(0x0F); db(0xAE); setModRM(3, 6, idx); }
-void tzcnt(const Reg&reg, const Operand& op) { opSp1(reg, op, 0xF3, 0x0F, 0xBC); }
+void sysenter() {
+  db(0x0F);
+  db(0x34);
+}
+void sysexit() {
+  db(0x0F);
+  db(0x35);
+}
+void tpause(const Reg32& r) {
+  int idx = r.getIdx();
+  if (idx > 7) XBYAK_THROW(ERR_BAD_PARAMETER) db(0x66);
+  db(0x0F);
+  db(0xAE);
+  setModRM(3, 6, idx);
+}
+void tzcnt(const Reg& reg, const Operand& op) { opSp1(reg, op, 0xF3, 0x0F, 0xBC); }
 void ucomisd(const Xmm& xmm, const Operand& op) { opGen(xmm, op, 0x2E, 0x66, isXMM_XMMorMEM); }
 void ucomiss(const Xmm& xmm, const Operand& op) { opGen(xmm, op, 0x2E, 0x100, isXMM_XMMorMEM); }
-void ud2() { db(0x0F); db(0x0B); }
-void umonitor(const Reg& r) { int idx = r.getIdx(); if (idx > 7) XBYAK_THROW(ERR_BAD_PARAMETER) int bit = r.getBit(); if (BIT != bit) { if ((BIT == 32 && bit == 16) || (BIT == 64 && bit == 32)) { db(0x67); } else { XBYAK_THROW(ERR_BAD_SIZE_OF_REGISTER) } } db(0xF3); db(0x0F); db(0xAE); setModRM(3, 6, idx); }
-void umwait(const Reg32& r) { int idx = r.getIdx(); if (idx > 7) XBYAK_THROW(ERR_BAD_PARAMETER) db(0xF2); db(0x0F); db(0xAE); setModRM(3, 6, idx); }
+void ud2() {
+  db(0x0F);
+  db(0x0B);
+}
+void umonitor(const Reg& r) {
+  int idx = r.getIdx();
+  if (idx > 7) XBYAK_THROW(ERR_BAD_PARAMETER) int bit = r.getBit();
+  if (BIT != bit) {
+    if ((BIT == 32 && bit == 16) || (BIT == 64 && bit == 32)) {
+      db(0x67);
+    } else {
+      XBYAK_THROW(ERR_BAD_SIZE_OF_REGISTER)
+    }
+  }
+  db(0xF3);
+  db(0x0F);
+  db(0xAE);
+  setModRM(3, 6, idx);
+}
+void umwait(const Reg32& r) {
+  int idx = r.getIdx();
+  if (idx > 7) XBYAK_THROW(ERR_BAD_PARAMETER) db(0xF2);
+  db(0x0F);
+  db(0xAE);
+  setModRM(3, 6, idx);
+}
 void unpckhpd(const Xmm& xmm, const Operand& op) { opGen(xmm, op, 0x15, 0x66, isXMM_XMMorMEM); }
 void unpckhps(const Xmm& xmm, const Operand& op) { opGen(xmm, op, 0x15, 0x100, isXMM_XMMorMEM); }
 void unpcklpd(const Xmm& xmm, const Operand& op) { opGen(xmm, op, 0x14, 0x66, isXMM_XMMorMEM); }
 void unpcklps(const Xmm& xmm, const Operand& op) { opGen(xmm, op, 0x14, 0x100, isXMM_XMMorMEM); }
-void vaddpd(const Xmm& xmm, const Operand& op1, const Operand& op2 = Operand()) { opAVX_X_X_XM(xmm, op1, op2, T_0F | T_66 | T_EW1 | T_YMM | T_EVEX | T_ER_Z | T_B64, 0x58); }
-void vaddps(const Xmm& xmm, const Operand& op1, const Operand& op2 = Operand()) { opAVX_X_X_XM(xmm, op1, op2, T_0F | T_EW0 | T_YMM | T_EVEX | T_ER_Z | T_B32, 0x58); }
-void vaddsd(const Xmm& xmm, const Operand& op1, const Operand& op2 = Operand()) { opAVX_X_X_XM(xmm, op1, op2, T_0F | T_F2 | T_EW1 | T_EVEX | T_ER_X | T_N8, 0x58); }
-void vaddss(const Xmm& xmm, const Operand& op1, const Operand& op2 = Operand()) { opAVX_X_X_XM(xmm, op1, op2, T_0F | T_F3 | T_EW0 | T_EVEX | T_ER_X | T_N4, 0x58); }
-void vaddsubpd(const Xmm& xmm, const Operand& op1, const Operand& op2 = Operand()) { opAVX_X_X_XM(xmm, op1, op2, T_66 | T_0F | T_YMM, 0xD0); }
-void vaddsubps(const Xmm& xmm, const Operand& op1, const Operand& op2 = Operand()) { opAVX_X_X_XM(xmm, op1, op2, T_F2 | T_0F | T_YMM, 0xD0); }
-void vaesdec(const Xmm& xmm, const Operand& op1, const Operand& op2 = Operand()) { opAVX_X_X_XM(xmm, op1, op2, T_66 | T_0F38 | T_YMM | T_EVEX, 0xDE); }
-void vaesdeclast(const Xmm& xmm, const Operand& op1, const Operand& op2 = Operand()) { opAVX_X_X_XM(xmm, op1, op2, T_66 | T_0F38 | T_YMM | T_EVEX, 0xDF); }
-void vaesenc(const Xmm& xmm, const Operand& op1, const Operand& op2 = Operand()) { opAVX_X_X_XM(xmm, op1, op2, T_66 | T_0F38 | T_YMM | T_EVEX, 0xDC); }
-void vaesenclast(const Xmm& xmm, const Operand& op1, const Operand& op2 = Operand()) { opAVX_X_X_XM(xmm, op1, op2, T_66 | T_0F38 | T_YMM | T_EVEX, 0xDD); }
+void vaddpd(const Xmm& xmm, const Operand& op1, const Operand& op2 = Operand()) {
+  opAVX_X_X_XM(xmm, op1, op2, T_0F | T_66 | T_EW1 | T_YMM | T_EVEX | T_ER_Z | T_B64, 0x58);
+}
+void vaddps(const Xmm& xmm, const Operand& op1, const Operand& op2 = Operand()) {
+  opAVX_X_X_XM(xmm, op1, op2, T_0F | T_EW0 | T_YMM | T_EVEX | T_ER_Z | T_B32, 0x58);
+}
+void vaddsd(const Xmm& xmm, const Operand& op1, const Operand& op2 = Operand()) {
+  opAVX_X_X_XM(xmm, op1, op2, T_0F | T_F2 | T_EW1 | T_EVEX | T_ER_X | T_N8, 0x58);
+}
+void vaddss(const Xmm& xmm, const Operand& op1, const Operand& op2 = Operand()) {
+  opAVX_X_X_XM(xmm, op1, op2, T_0F | T_F3 | T_EW0 | T_EVEX | T_ER_X | T_N4, 0x58);
+}
+void vaddsubpd(const Xmm& xmm, const Operand& op1, const Operand& op2 = Operand()) {
+  opAVX_X_X_XM(xmm, op1, op2, T_66 | T_0F | T_YMM, 0xD0);
+}
+void vaddsubps(const Xmm& xmm, const Operand& op1, const Operand& op2 = Operand()) {
+  opAVX_X_X_XM(xmm, op1, op2, T_F2 | T_0F | T_YMM, 0xD0);
+}
+void vaesdec(const Xmm& xmm, const Operand& op1, const Operand& op2 = Operand()) {
+  opAVX_X_X_XM(xmm, op1, op2, T_66 | T_0F38 | T_YMM | T_EVEX, 0xDE);
+}
+void vaesdeclast(const Xmm& xmm, const Operand& op1, const Operand& op2 = Operand()) {
+  opAVX_X_X_XM(xmm, op1, op2, T_66 | T_0F38 | T_YMM | T_EVEX, 0xDF);
+}
+void vaesenc(const Xmm& xmm, const Operand& op1, const Operand& op2 = Operand()) {
+  opAVX_X_X_XM(xmm, op1, op2, T_66 | T_0F38 | T_YMM | T_EVEX, 0xDC);
+}
+void vaesenclast(const Xmm& xmm, const Operand& op1, const Operand& op2 = Operand()) {
+  opAVX_X_X_XM(xmm, op1, op2, T_66 | T_0F38 | T_YMM | T_EVEX, 0xDD);
+}
 void vaesimc(const Xmm& xm, const Operand& op) { opAVX_X_XM_IMM(xm, op, T_66 | T_0F38 | T_W0, 0xDB); }
-void vaeskeygenassist(const Xmm& xm, const Operand& op, uint8_t imm) { opAVX_X_XM_IMM(xm, op, T_66 | T_0F3A, 0xDF, imm); }
-void vandnpd(const Xmm& xmm, const Operand& op1, const Operand& op2 = Operand()) { opAVX_X_X_XM(xmm, op1, op2, T_0F | T_66 | T_EW1 | T_YMM | T_EVEX | T_ER_Z | T_B64, 0x55); }
-void vandnps(const Xmm& xmm, const Operand& op1, const Operand& op2 = Operand()) { opAVX_X_X_XM(xmm, op1, op2, T_0F | T_EW0 | T_YMM | T_EVEX | T_ER_Z | T_B32, 0x55); }
-void vandpd(const Xmm& xmm, const Operand& op1, const Operand& op2 = Operand()) { opAVX_X_X_XM(xmm, op1, op2, T_0F | T_66 | T_EW1 | T_YMM | T_EVEX | T_ER_Z | T_B64, 0x54); }
-void vandps(const Xmm& xmm, const Operand& op1, const Operand& op2 = Operand()) { opAVX_X_X_XM(xmm, op1, op2, T_0F | T_EW0 | T_YMM | T_EVEX | T_ER_Z | T_B32, 0x54); }
-void vbcstnebf162ps(const Xmm& x, const Address& addr) { opVex(x, 0, addr, T_F3 | T_0F38 | T_W0 | T_YMM | T_B16, 0xB1); }
+void vaeskeygenassist(const Xmm& xm, const Operand& op, uint8_t imm) {
+  opAVX_X_XM_IMM(xm, op, T_66 | T_0F3A, 0xDF, imm);
+}
+void vandnpd(const Xmm& xmm, const Operand& op1, const Operand& op2 = Operand()) {
+  opAVX_X_X_XM(xmm, op1, op2, T_0F | T_66 | T_EW1 | T_YMM | T_EVEX | T_ER_Z | T_B64, 0x55);
+}
+void vandnps(const Xmm& xmm, const Operand& op1, const Operand& op2 = Operand()) {
+  opAVX_X_X_XM(xmm, op1, op2, T_0F | T_EW0 | T_YMM | T_EVEX | T_ER_Z | T_B32, 0x55);
+}
+void vandpd(const Xmm& xmm, const Operand& op1, const Operand& op2 = Operand()) {
+  opAVX_X_X_XM(xmm, op1, op2, T_0F | T_66 | T_EW1 | T_YMM | T_EVEX | T_ER_Z | T_B64, 0x54);
+}
+void vandps(const Xmm& xmm, const Operand& op1, const Operand& op2 = Operand()) {
+  opAVX_X_X_XM(xmm, op1, op2, T_0F | T_EW0 | T_YMM | T_EVEX | T_ER_Z | T_B32, 0x54);
+}
+void vbcstnebf162ps(const Xmm& x, const Address& addr) {
+  opVex(x, 0, addr, T_F3 | T_0F38 | T_W0 | T_YMM | T_B16, 0xB1);
+}
 void vbcstnesh2ps(const Xmm& x, const Address& addr) { opVex(x, 0, addr, T_66 | T_0F38 | T_W0 | T_YMM | T_B16, 0xB1); }
-void vblendpd(const Xmm& x1, const Xmm& x2, const Operand& op, uint8_t imm) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F3A | T_W0 | T_YMM, 0x0D, imm); }
-void vblendps(const Xmm& x1, const Xmm& x2, const Operand& op, uint8_t imm) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F3A | T_W0 | T_YMM, 0x0C, imm); }
-void vblendvpd(const Xmm& x1, const Xmm& x2, const Operand& op, const Xmm& x4) { opAVX_X_X_XM(x1, x2, op, T_0F3A | T_66 | T_YMM, 0x4B, x4.getIdx() << 4); }
-void vblendvps(const Xmm& x1, const Xmm& x2, const Operand& op, const Xmm& x4) { opAVX_X_X_XM(x1, x2, op, T_0F3A | T_66 | T_YMM, 0x4A, x4.getIdx() << 4); }
+void vblendpd(const Xmm& x1, const Xmm& x2, const Operand& op, uint8_t imm) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F3A | T_W0 | T_YMM, 0x0D, imm);
+}
+void vblendps(const Xmm& x1, const Xmm& x2, const Operand& op, uint8_t imm) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F3A | T_W0 | T_YMM, 0x0C, imm);
+}
+void vblendvpd(const Xmm& x1, const Xmm& x2, const Operand& op, const Xmm& x4) {
+  opAVX_X_X_XM(x1, x2, op, T_0F3A | T_66 | T_YMM, 0x4B, x4.getIdx() << 4);
+}
+void vblendvps(const Xmm& x1, const Xmm& x2, const Operand& op, const Xmm& x4) {
+  opAVX_X_X_XM(x1, x2, op, T_0F3A | T_66 | T_YMM, 0x4A, x4.getIdx() << 4);
+}
 void vbroadcastf128(const Ymm& y, const Address& addr) { opAVX_X_XM_IMM(y, addr, T_0F38 | T_66 | T_W0 | T_YMM, 0x1A); }
 void vbroadcasti128(const Ymm& y, const Address& addr) { opAVX_X_XM_IMM(y, addr, T_0F38 | T_66 | T_W0 | T_YMM, 0x5A); }
-void vbroadcastsd(const Ymm& y, const Operand& op) { if (!op.isMEM() && !(y.isYMM() && op.isXMM()) && !(y.isZMM() && op.isXMM())) XBYAK_THROW(ERR_BAD_COMBINATION) opAVX_X_XM_IMM(y, op, T_0F38 | T_66 | T_W0 | T_YMM | T_EVEX | T_EW1 | T_N8, 0x19); }
-void vbroadcastss(const Xmm& x, const Operand& op) { if (!(op.isXMM() || op.isMEM())) XBYAK_THROW(ERR_BAD_COMBINATION) opAVX_X_XM_IMM(x, op, T_N4 | T_66 | T_0F38 | T_W0 | T_YMM | T_EVEX, 0x18); }
+void vbroadcastsd(const Ymm& y, const Operand& op) {
+  if (!op.isMEM() && !(y.isYMM() && op.isXMM()) && !(y.isZMM() && op.isXMM()))
+    XBYAK_THROW(ERR_BAD_COMBINATION) opAVX_X_XM_IMM(y, op, T_0F38 | T_66 | T_W0 | T_YMM | T_EVEX | T_EW1 | T_N8, 0x19);
+}
+void vbroadcastss(const Xmm& x, const Operand& op) {
+  if (!(op.isXMM() || op.isMEM()))
+    XBYAK_THROW(ERR_BAD_COMBINATION) opAVX_X_XM_IMM(x, op, T_N4 | T_66 | T_0F38 | T_W0 | T_YMM | T_EVEX, 0x18);
+}
 void vcmpeq_ospd(const Xmm& x1, const Xmm& x2, const Operand& op) { vcmppd(x1, x2, op, 16); }
 void vcmpeq_osps(const Xmm& x1, const Xmm& x2, const Operand& op) { vcmpps(x1, x2, op, 16); }
 void vcmpeq_ossd(const Xmm& x1, const Xmm& x2, const Operand& op) { vcmpsd(x1, x2, op, 16); }
@@ -986,10 +1571,18 @@ void vcmpordpd(const Xmm& x1, const Xmm& x2, const Operand& op) { vcmppd(x1, x2,
 void vcmpordps(const Xmm& x1, const Xmm& x2, const Operand& op) { vcmpps(x1, x2, op, 7); }
 void vcmpordsd(const Xmm& x1, const Xmm& x2, const Operand& op) { vcmpsd(x1, x2, op, 7); }
 void vcmpordss(const Xmm& x1, const Xmm& x2, const Operand& op) { vcmpss(x1, x2, op, 7); }
-void vcmppd(const Xmm& x1, const Xmm& x2, const Operand& op, uint8_t imm) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F | T_YMM, 0xC2, imm); }
-void vcmpps(const Xmm& x1, const Xmm& x2, const Operand& op, uint8_t imm) { opAVX_X_X_XM(x1, x2, op, T_0F | T_YMM, 0xC2, imm); }
-void vcmpsd(const Xmm& x1, const Xmm& x2, const Operand& op, uint8_t imm) { opAVX_X_X_XM(x1, x2, op, T_F2 | T_0F, 0xC2, imm); }
-void vcmpss(const Xmm& x1, const Xmm& x2, const Operand& op, uint8_t imm) { opAVX_X_X_XM(x1, x2, op, T_F3 | T_0F, 0xC2, imm); }
+void vcmppd(const Xmm& x1, const Xmm& x2, const Operand& op, uint8_t imm) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F | T_YMM, 0xC2, imm);
+}
+void vcmpps(const Xmm& x1, const Xmm& x2, const Operand& op, uint8_t imm) {
+  opAVX_X_X_XM(x1, x2, op, T_0F | T_YMM, 0xC2, imm);
+}
+void vcmpsd(const Xmm& x1, const Xmm& x2, const Operand& op, uint8_t imm) {
+  opAVX_X_X_XM(x1, x2, op, T_F2 | T_0F, 0xC2, imm);
+}
+void vcmpss(const Xmm& x1, const Xmm& x2, const Operand& op, uint8_t imm) {
+  opAVX_X_X_XM(x1, x2, op, T_F3 | T_0F, 0xC2, imm);
+}
 void vcmptrue_uspd(const Xmm& x1, const Xmm& x2, const Operand& op) { vcmppd(x1, x2, op, 31); }
 void vcmptrue_usps(const Xmm& x1, const Xmm& x2, const Operand& op) { vcmpps(x1, x2, op, 31); }
 void vcmptrue_ussd(const Xmm& x1, const Xmm& x2, const Operand& op) { vcmpsd(x1, x2, op, 31); }
@@ -1006,406 +1599,1150 @@ void vcmpunordpd(const Xmm& x1, const Xmm& x2, const Operand& op) { vcmppd(x1, x
 void vcmpunordps(const Xmm& x1, const Xmm& x2, const Operand& op) { vcmpps(x1, x2, op, 3); }
 void vcmpunordsd(const Xmm& x1, const Xmm& x2, const Operand& op) { vcmpsd(x1, x2, op, 3); }
 void vcmpunordss(const Xmm& x1, const Xmm& x2, const Operand& op) { vcmpss(x1, x2, op, 3); }
-void vcomisd(const Xmm& xm, const Operand& op) { opAVX_X_XM_IMM(xm, op, T_N8 | T_66 | T_0F | T_EW1 | T_EVEX | T_SAE_X, 0x2F); }
+void vcomisd(const Xmm& xm, const Operand& op) {
+  opAVX_X_XM_IMM(xm, op, T_N8 | T_66 | T_0F | T_EW1 | T_EVEX | T_SAE_X, 0x2F);
+}
 void vcomiss(const Xmm& xm, const Operand& op) { opAVX_X_XM_IMM(xm, op, T_N4 | T_0F | T_EW0 | T_EVEX | T_SAE_X, 0x2F); }
-void vcvtdq2pd(const Xmm& x, const Operand& op) { checkCvt1(x, op); opVex(x, 0, op, T_0F | T_F3 | T_YMM | T_EVEX | T_EW0 | T_B32 | T_N8 | T_N_VL, 0xE6); }
-void vcvtdq2ps(const Xmm& xm, const Operand& op) { opAVX_X_XM_IMM(xm, op, T_0F | T_EW0 | T_YMM | T_EVEX | T_ER_Z | T_B32, 0x5B); }
+void vcvtdq2pd(const Xmm& x, const Operand& op) {
+  checkCvt1(x, op);
+  opVex(x, 0, op, T_0F | T_F3 | T_YMM | T_EVEX | T_EW0 | T_B32 | T_N8 | T_N_VL, 0xE6);
+}
+void vcvtdq2ps(const Xmm& xm, const Operand& op) {
+  opAVX_X_XM_IMM(xm, op, T_0F | T_EW0 | T_YMM | T_EVEX | T_ER_Z | T_B32, 0x5B);
+}
 void vcvtneebf162ps(const Xmm& x, const Address& addr) { opVex(x, 0, addr, T_F3 | T_0F38 | T_W0 | T_YMM, 0xB0); }
 void vcvtneeph2ps(const Xmm& x, const Address& addr) { opVex(x, 0, addr, T_66 | T_0F38 | T_W0 | T_YMM, 0xB0); }
 void vcvtneobf162ps(const Xmm& x, const Address& addr) { opVex(x, 0, addr, T_F2 | T_0F38 | T_W0 | T_YMM, 0xB0); }
 void vcvtneoph2ps(const Xmm& x, const Address& addr) { opVex(x, 0, addr, T_0F38 | T_W0 | T_YMM, 0xB0); }
-void vcvtneps2bf16(const Xmm& x, const Operand& op, PreferredEncoding encoding = DefaultEncoding) { opCvt2(x, op, T_F3 | T_0F38 | T_EW0 | T_YMM | T_SAE_Z | T_B32 | orEvexIf(encoding), 0x72); }
-void vcvtpd2dq(const Xmm& x, const Operand& op) { opCvt2(x, op, T_0F | T_F2 | T_YMM | T_EVEX | T_EW1 | T_B64 | T_ER_Z, 0xE6); }
-void vcvtpd2ps(const Xmm& x, const Operand& op) { opCvt2(x, op, T_0F | T_66 | T_YMM | T_EVEX | T_EW1 | T_B64 | T_ER_Z, 0x5A); }
-void vcvtph2ps(const Xmm& x, const Operand& op) { checkCvt1(x, op); opVex(x, 0, op, T_0F38 | T_66 | T_W0 | T_EVEX | T_EW0 | T_N8 | T_N_VL | T_SAE_Y, 0x13); }
-void vcvtps2dq(const Xmm& xm, const Operand& op) { opAVX_X_XM_IMM(xm, op, T_66 | T_0F | T_EW0 | T_YMM | T_EVEX | T_ER_Z | T_B32, 0x5B); }
-void vcvtps2pd(const Xmm& x, const Operand& op) { checkCvt1(x, op); opVex(x, 0, op, T_0F | T_YMM | T_EVEX | T_EW0 | T_B32 | T_N8 | T_N_VL | T_SAE_Y, 0x5A); }
-void vcvtps2ph(const Operand& op, const Xmm& x, uint8_t imm) { checkCvt1(x, op); opVex(x, 0, op, T_0F3A | T_66 | T_W0 | T_EVEX | T_EW0 | T_N8 | T_N_VL | T_SAE_Y | T_M_K, 0x1D, imm); }
-void vcvtsd2si(const Reg32& r, const Operand& op) { opAVX_X_X_XM(Xmm(r.getIdx()), xm0, op, T_0F | T_F2 | T_W0 | T_EVEX | T_EW0 | T_N4 | T_ER_X, 0x2D); }
-void vcvtsd2ss(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_N8 | T_F2 | T_0F | T_EW1 | T_EVEX | T_ER_X, 0x5A); }
-void vcvtsi2sd(const Xmm& x1, const Xmm& x2, const Operand& op) { opCvt3(x1, x2, op, T_0F | T_F2 | T_EVEX, T_W1 | T_EW1 | T_ER_X | T_N8, T_W0 | T_EW0 | T_N4, 0x2A); }
-void vcvtsi2ss(const Xmm& x1, const Xmm& x2, const Operand& op) { opCvt3(x1, x2, op, T_0F | T_F3 | T_EVEX | T_ER_X, T_W1 | T_EW1 | T_N8, T_W0 | T_EW0 | T_N4, 0x2A); }
-void vcvtss2sd(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_N4 | T_F3 | T_0F | T_EW0 | T_EVEX | T_SAE_X, 0x5A); }
-void vcvtss2si(const Reg32& r, const Operand& op) { opAVX_X_X_XM(Xmm(r.getIdx()), xm0, op, T_0F | T_F3 | T_W0 | T_EVEX | T_EW0 | T_ER_X | T_N8, 0x2D); }
-void vcvttpd2dq(const Xmm& x, const Operand& op) { opCvt2(x, op, T_66 | T_0F | T_YMM | T_EVEX |T_EW1 | T_B64 | T_ER_Z, 0xE6); }
-void vcvttps2dq(const Xmm& xm, const Operand& op) { opAVX_X_XM_IMM(xm, op, T_F3 | T_0F | T_EW0 | T_YMM | T_EVEX | T_SAE_Z | T_B32, 0x5B); }
-void vcvttsd2si(const Reg32& r, const Operand& op) { opAVX_X_X_XM(Xmm(r.getIdx()), xm0, op, T_0F | T_F2 | T_W0 | T_EVEX | T_EW0 | T_N4 | T_SAE_X, 0x2C); }
-void vcvttss2si(const Reg32& r, const Operand& op) { opAVX_X_X_XM(Xmm(r.getIdx()), xm0, op, T_0F | T_F3 | T_W0 | T_EVEX | T_EW0 | T_SAE_X | T_N8, 0x2C); }
-void vdivpd(const Xmm& xmm, const Operand& op1, const Operand& op2 = Operand()) { opAVX_X_X_XM(xmm, op1, op2, T_0F | T_66 | T_EW1 | T_YMM | T_EVEX | T_ER_Z | T_B64, 0x5E); }
-void vdivps(const Xmm& xmm, const Operand& op1, const Operand& op2 = Operand()) { opAVX_X_X_XM(xmm, op1, op2, T_0F | T_EW0 | T_YMM | T_EVEX | T_ER_Z | T_B32, 0x5E); }
-void vdivsd(const Xmm& xmm, const Operand& op1, const Operand& op2 = Operand()) { opAVX_X_X_XM(xmm, op1, op2, T_0F | T_F2 | T_EW1 | T_EVEX | T_ER_X | T_N8, 0x5E); }
-void vdivss(const Xmm& xmm, const Operand& op1, const Operand& op2 = Operand()) { opAVX_X_X_XM(xmm, op1, op2, T_0F | T_F3 | T_EW0 | T_EVEX | T_ER_X | T_N4, 0x5E); }
-void vdppd(const Xmm& x1, const Xmm& x2, const Operand& op, uint8_t imm) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F3A | T_W0, 0x41, imm); }
-void vdpps(const Xmm& x1, const Xmm& x2, const Operand& op, uint8_t imm) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F3A | T_W0 | T_YMM, 0x40, imm); }
-void vextractf128(const Operand& op, const Ymm& y, uint8_t imm) { if (!(op.isXMEM() && y.isYMM())) XBYAK_THROW(ERR_BAD_COMBINATION) opVex(y, 0, op, T_0F3A | T_66 | T_W0 | T_YMM, 0x19, imm); }
-void vextracti128(const Operand& op, const Ymm& y, uint8_t imm) { if (!(op.isXMEM() && y.isYMM())) XBYAK_THROW(ERR_BAD_COMBINATION) opVex(y, 0, op, T_0F3A | T_66 | T_W0 | T_YMM, 0x39, imm); }
-void vextractps(const Operand& op, const Xmm& x, uint8_t imm) { if (!((op.isREG(32) || op.isMEM()) && x.isXMM())) XBYAK_THROW(ERR_BAD_COMBINATION) opVex(x, 0, op, T_0F3A | T_66 | T_W0 | T_EVEX | T_N4, 0x17, imm); }
-void vfmadd132pd(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_W1 | T_EW1 | T_YMM | T_EVEX | T_B64, 0x98); }
-void vfmadd132ps(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_W0 | T_EW0 | T_YMM | T_EVEX | T_B32, 0x98); }
-void vfmadd132sd(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_N8 | T_66 | T_0F38 | T_W1 | T_EW1 | T_EVEX | T_ER_X, 0x99); }
-void vfmadd132ss(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_N4 | T_66 | T_0F38 | T_W0 | T_EW0 | T_EVEX | T_ER_X, 0x99); }
-void vfmadd213pd(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_W1 | T_EW1 | T_YMM | T_EVEX | T_B64, 0xA8); }
-void vfmadd213ps(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_W0 | T_EW0 | T_YMM | T_EVEX | T_B32, 0xA8); }
-void vfmadd213sd(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_N8 | T_66 | T_0F38 | T_W1 | T_EW1 | T_EVEX | T_ER_X, 0xA9); }
-void vfmadd213ss(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_N4 | T_66 | T_0F38 | T_W0 | T_EW0 | T_EVEX | T_ER_X, 0xA9); }
-void vfmadd231pd(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_W1 | T_EW1 | T_YMM | T_EVEX | T_B64, 0xB8); }
-void vfmadd231ps(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_W0 | T_EW0 | T_YMM | T_EVEX | T_B32, 0xB8); }
-void vfmadd231sd(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_N8 | T_66 | T_0F38 | T_W1 | T_EW1 | T_EVEX | T_ER_X, 0xB9); }
-void vfmadd231ss(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_N4 | T_66 | T_0F38 | T_W0 | T_EW0 | T_EVEX | T_ER_X, 0xB9); }
-void vfmaddsub132pd(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_W1 | T_EW1 | T_YMM | T_EVEX | T_B64, 0x96); }
-void vfmaddsub132ps(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_W0 | T_EW0 | T_YMM | T_EVEX | T_B32, 0x96); }
-void vfmaddsub213pd(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_W1 | T_EW1 | T_YMM | T_EVEX | T_B64, 0xA6); }
-void vfmaddsub213ps(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_W0 | T_EW0 | T_YMM | T_EVEX | T_B32, 0xA6); }
-void vfmaddsub231pd(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_W1 | T_EW1 | T_YMM | T_EVEX | T_B64, 0xB6); }
-void vfmaddsub231ps(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_W0 | T_EW0 | T_YMM | T_EVEX | T_B32, 0xB6); }
-void vfmsub132pd(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_W1 | T_EW1 | T_YMM | T_EVEX | T_B64, 0x9A); }
-void vfmsub132ps(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_W0 | T_EW0 | T_YMM | T_EVEX | T_B32, 0x9A); }
-void vfmsub132sd(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_N8 | T_66 | T_0F38 | T_W1 | T_EW1 | T_EVEX | T_ER_X, 0x9B); }
-void vfmsub132ss(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_N4 | T_66 | T_0F38 | T_W0 | T_EW0 | T_EVEX | T_ER_X, 0x9B); }
-void vfmsub213pd(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_W1 | T_EW1 | T_YMM | T_EVEX | T_B64, 0xAA); }
-void vfmsub213ps(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_W0 | T_EW0 | T_YMM | T_EVEX | T_B32, 0xAA); }
-void vfmsub213sd(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_N8 | T_66 | T_0F38 | T_W1 | T_EW1 | T_EVEX | T_ER_X, 0xAB); }
-void vfmsub213ss(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_N4 | T_66 | T_0F38 | T_W0 | T_EW0 | T_EVEX | T_ER_X, 0xAB); }
-void vfmsub231pd(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_W1 | T_EW1 | T_YMM | T_EVEX | T_B64, 0xBA); }
-void vfmsub231ps(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_W0 | T_EW0 | T_YMM | T_EVEX | T_B32, 0xBA); }
-void vfmsub231sd(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_N8 | T_66 | T_0F38 | T_W1 | T_EW1 | T_EVEX | T_ER_X, 0xBB); }
-void vfmsub231ss(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_N4 | T_66 | T_0F38 | T_W0 | T_EW0 | T_EVEX | T_ER_X, 0xBB); }
-void vfmsubadd132pd(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_W1 | T_EW1 | T_YMM | T_EVEX | T_B64, 0x97); }
-void vfmsubadd132ps(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_W0 | T_EW0 | T_YMM | T_EVEX | T_B32, 0x97); }
-void vfmsubadd213pd(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_W1 | T_EW1 | T_YMM | T_EVEX | T_B64, 0xA7); }
-void vfmsubadd213ps(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_W0 | T_EW0 | T_YMM | T_EVEX | T_B32, 0xA7); }
-void vfmsubadd231pd(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_W1 | T_EW1 | T_YMM | T_EVEX | T_B64, 0xB7); }
-void vfmsubadd231ps(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_W0 | T_EW0 | T_YMM | T_EVEX | T_B32, 0xB7); }
-void vfnmadd132pd(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_W1 | T_EW1 | T_YMM | T_EVEX | T_B64, 0x9C); }
-void vfnmadd132ps(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_W0 | T_EW0 | T_YMM | T_EVEX | T_B32, 0x9C); }
-void vfnmadd132sd(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_N8 | T_66 | T_0F38 | T_W1 | T_EW1 | T_EVEX | T_ER_X, 0x9D); }
-void vfnmadd132ss(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_N4 | T_66 | T_0F38 | T_W0 | T_EW0 | T_EVEX | T_ER_X, 0x9D); }
-void vfnmadd213pd(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_W1 | T_EW1 | T_YMM | T_EVEX | T_B64, 0xAC); }
-void vfnmadd213ps(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_W0 | T_EW0 | T_YMM | T_EVEX | T_B32, 0xAC); }
-void vfnmadd213sd(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_N8 | T_66 | T_0F38 | T_W1 | T_EW1 | T_EVEX | T_ER_X, 0xAD); }
-void vfnmadd213ss(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_N4 | T_66 | T_0F38 | T_W0 | T_EW0 | T_EVEX | T_ER_X, 0xAD); }
-void vfnmadd231pd(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_W1 | T_EW1 | T_YMM | T_EVEX | T_B64, 0xBC); }
-void vfnmadd231ps(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_W0 | T_EW0 | T_YMM | T_EVEX | T_B32, 0xBC); }
-void vfnmadd231sd(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_N8 | T_66 | T_0F38 | T_W1 | T_EW1 | T_EVEX | T_ER_X, 0xBD); }
-void vfnmadd231ss(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_N4 | T_66 | T_0F38 | T_W0 | T_EW0 | T_EVEX | T_ER_X, 0xBD); }
-void vfnmsub132pd(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_W1 | T_EW1 | T_YMM | T_EVEX | T_B64, 0x9E); }
-void vfnmsub132ps(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_W0 | T_EW0 | T_YMM | T_EVEX | T_B32, 0x9E); }
-void vfnmsub132sd(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_N8 | T_66 | T_0F38 | T_W1 | T_EW1 | T_EVEX | T_ER_X, 0x9F); }
-void vfnmsub132ss(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_N4 | T_66 | T_0F38 | T_W0 | T_EW0 | T_EVEX | T_ER_X, 0x9F); }
-void vfnmsub213pd(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_W1 | T_EW1 | T_YMM | T_EVEX | T_B64, 0xAE); }
-void vfnmsub213ps(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_W0 | T_EW0 | T_YMM | T_EVEX | T_B32, 0xAE); }
-void vfnmsub213sd(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_N8 | T_66 | T_0F38 | T_W1 | T_EW1 | T_EVEX | T_ER_X, 0xAF); }
-void vfnmsub213ss(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_N4 | T_66 | T_0F38 | T_W0 | T_EW0 | T_EVEX | T_ER_X, 0xAF); }
-void vfnmsub231pd(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_W1 | T_EW1 | T_YMM | T_EVEX | T_B64, 0xBE); }
-void vfnmsub231ps(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_W0 | T_EW0 | T_YMM | T_EVEX | T_B32, 0xBE); }
-void vfnmsub231sd(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_N8 | T_66 | T_0F38 | T_W1 | T_EW1 | T_EVEX | T_ER_X, 0xBF); }
-void vfnmsub231ss(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_N4 | T_66 | T_0F38 | T_W0 | T_EW0 | T_EVEX | T_ER_X, 0xBF); }
-void vgatherdpd(const Xmm& x1, const Address& addr, const Xmm& x2) { opGather(x1, addr, x2, T_0F38 | T_66 | T_YMM | T_VSIB | T_W1, 0x92, 0); }
-void vgatherdps(const Xmm& x1, const Address& addr, const Xmm& x2) { opGather(x1, addr, x2, T_0F38 | T_66 | T_YMM | T_VSIB | T_W0, 0x92, 1); }
-void vgatherqpd(const Xmm& x1, const Address& addr, const Xmm& x2) { opGather(x1, addr, x2, T_0F38 | T_66 | T_YMM | T_VSIB | T_W1, 0x93, 1); }
-void vgatherqps(const Xmm& x1, const Address& addr, const Xmm& x2) { opGather(x1, addr, x2, T_0F38 | T_66 | T_YMM | T_VSIB | T_W0, 0x93, 2); }
-void vgf2p8affineinvqb(const Xmm& x1, const Xmm& x2, const Operand& op, uint8_t imm) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F3A | T_W1 | T_EW1 | T_YMM | T_EVEX | T_SAE_Z | T_B64, 0xCF, imm); }
-void vgf2p8affineqb(const Xmm& x1, const Xmm& x2, const Operand& op, uint8_t imm) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F3A | T_W1 | T_EW1 | T_YMM | T_EVEX | T_SAE_Z | T_B64, 0xCE, imm); }
-void vgf2p8mulb(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_W0 | T_EW0 | T_YMM | T_EVEX | T_SAE_Z, 0xCF); }
-void vhaddpd(const Xmm& xmm, const Operand& op1, const Operand& op2 = Operand()) { opAVX_X_X_XM(xmm, op1, op2, T_66 | T_0F | T_YMM, 0x7C); }
-void vhaddps(const Xmm& xmm, const Operand& op1, const Operand& op2 = Operand()) { opAVX_X_X_XM(xmm, op1, op2, T_F2 | T_0F | T_YMM, 0x7C); }
-void vhsubpd(const Xmm& xmm, const Operand& op1, const Operand& op2 = Operand()) { opAVX_X_X_XM(xmm, op1, op2, T_66 | T_0F | T_YMM, 0x7D); }
-void vhsubps(const Xmm& xmm, const Operand& op1, const Operand& op2 = Operand()) { opAVX_X_X_XM(xmm, op1, op2, T_F2 | T_0F | T_YMM, 0x7D); }
-void vinsertf128(const Ymm& y1, const Ymm& y2, const Operand& op, uint8_t imm) { if (!(y1.isYMM() && y2.isYMM() && op.isXMEM())) XBYAK_THROW(ERR_BAD_COMBINATION) opVex(y1, &y2, op, T_0F3A | T_66 | T_W0 | T_YMM, 0x18, imm); }
-void vinserti128(const Ymm& y1, const Ymm& y2, const Operand& op, uint8_t imm) { if (!(y1.isYMM() && y2.isYMM() && op.isXMEM())) XBYAK_THROW(ERR_BAD_COMBINATION) opVex(y1, &y2, op, T_0F3A | T_66 | T_W0 | T_YMM, 0x38, imm); }
-void vinsertps(const Xmm& x1, const Xmm& x2, const Operand& op, uint8_t imm) { opAVX_X_X_XM(x1, x2, op, T_N4 | T_66 | T_0F3A | T_W0 | T_EW0 | T_EVEX, 0x21, imm); }
+void vcvtneps2bf16(const Xmm& x, const Operand& op, PreferredEncoding encoding = DefaultEncoding) {
+  opCvt2(x, op, T_F3 | T_0F38 | T_EW0 | T_YMM | T_SAE_Z | T_B32 | orEvexIf(encoding), 0x72);
+}
+void vcvtpd2dq(const Xmm& x, const Operand& op) {
+  opCvt2(x, op, T_0F | T_F2 | T_YMM | T_EVEX | T_EW1 | T_B64 | T_ER_Z, 0xE6);
+}
+void vcvtpd2ps(const Xmm& x, const Operand& op) {
+  opCvt2(x, op, T_0F | T_66 | T_YMM | T_EVEX | T_EW1 | T_B64 | T_ER_Z, 0x5A);
+}
+void vcvtph2ps(const Xmm& x, const Operand& op) {
+  checkCvt1(x, op);
+  opVex(x, 0, op, T_0F38 | T_66 | T_W0 | T_EVEX | T_EW0 | T_N8 | T_N_VL | T_SAE_Y, 0x13);
+}
+void vcvtps2dq(const Xmm& xm, const Operand& op) {
+  opAVX_X_XM_IMM(xm, op, T_66 | T_0F | T_EW0 | T_YMM | T_EVEX | T_ER_Z | T_B32, 0x5B);
+}
+void vcvtps2pd(const Xmm& x, const Operand& op) {
+  checkCvt1(x, op);
+  opVex(x, 0, op, T_0F | T_YMM | T_EVEX | T_EW0 | T_B32 | T_N8 | T_N_VL | T_SAE_Y, 0x5A);
+}
+void vcvtps2ph(const Operand& op, const Xmm& x, uint8_t imm) {
+  checkCvt1(x, op);
+  opVex(x, 0, op, T_0F3A | T_66 | T_W0 | T_EVEX | T_EW0 | T_N8 | T_N_VL | T_SAE_Y | T_M_K, 0x1D, imm);
+}
+void vcvtsd2si(const Reg32& r, const Operand& op) {
+  opAVX_X_X_XM(Xmm(r.getIdx()), xm0, op, T_0F | T_F2 | T_W0 | T_EVEX | T_EW0 | T_N4 | T_ER_X, 0x2D);
+}
+void vcvtsd2ss(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_N8 | T_F2 | T_0F | T_EW1 | T_EVEX | T_ER_X, 0x5A);
+}
+void vcvtsi2sd(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opCvt3(x1, x2, op, T_0F | T_F2 | T_EVEX, T_W1 | T_EW1 | T_ER_X | T_N8, T_W0 | T_EW0 | T_N4, 0x2A);
+}
+void vcvtsi2ss(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opCvt3(x1, x2, op, T_0F | T_F3 | T_EVEX | T_ER_X, T_W1 | T_EW1 | T_N8, T_W0 | T_EW0 | T_N4, 0x2A);
+}
+void vcvtss2sd(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_N4 | T_F3 | T_0F | T_EW0 | T_EVEX | T_SAE_X, 0x5A);
+}
+void vcvtss2si(const Reg32& r, const Operand& op) {
+  opAVX_X_X_XM(Xmm(r.getIdx()), xm0, op, T_0F | T_F3 | T_W0 | T_EVEX | T_EW0 | T_ER_X | T_N8, 0x2D);
+}
+void vcvttpd2dq(const Xmm& x, const Operand& op) {
+  opCvt2(x, op, T_66 | T_0F | T_YMM | T_EVEX | T_EW1 | T_B64 | T_ER_Z, 0xE6);
+}
+void vcvttps2dq(const Xmm& xm, const Operand& op) {
+  opAVX_X_XM_IMM(xm, op, T_F3 | T_0F | T_EW0 | T_YMM | T_EVEX | T_SAE_Z | T_B32, 0x5B);
+}
+void vcvttsd2si(const Reg32& r, const Operand& op) {
+  opAVX_X_X_XM(Xmm(r.getIdx()), xm0, op, T_0F | T_F2 | T_W0 | T_EVEX | T_EW0 | T_N4 | T_SAE_X, 0x2C);
+}
+void vcvttss2si(const Reg32& r, const Operand& op) {
+  opAVX_X_X_XM(Xmm(r.getIdx()), xm0, op, T_0F | T_F3 | T_W0 | T_EVEX | T_EW0 | T_SAE_X | T_N8, 0x2C);
+}
+void vdivpd(const Xmm& xmm, const Operand& op1, const Operand& op2 = Operand()) {
+  opAVX_X_X_XM(xmm, op1, op2, T_0F | T_66 | T_EW1 | T_YMM | T_EVEX | T_ER_Z | T_B64, 0x5E);
+}
+void vdivps(const Xmm& xmm, const Operand& op1, const Operand& op2 = Operand()) {
+  opAVX_X_X_XM(xmm, op1, op2, T_0F | T_EW0 | T_YMM | T_EVEX | T_ER_Z | T_B32, 0x5E);
+}
+void vdivsd(const Xmm& xmm, const Operand& op1, const Operand& op2 = Operand()) {
+  opAVX_X_X_XM(xmm, op1, op2, T_0F | T_F2 | T_EW1 | T_EVEX | T_ER_X | T_N8, 0x5E);
+}
+void vdivss(const Xmm& xmm, const Operand& op1, const Operand& op2 = Operand()) {
+  opAVX_X_X_XM(xmm, op1, op2, T_0F | T_F3 | T_EW0 | T_EVEX | T_ER_X | T_N4, 0x5E);
+}
+void vdppd(const Xmm& x1, const Xmm& x2, const Operand& op, uint8_t imm) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F3A | T_W0, 0x41, imm);
+}
+void vdpps(const Xmm& x1, const Xmm& x2, const Operand& op, uint8_t imm) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F3A | T_W0 | T_YMM, 0x40, imm);
+}
+void vextractf128(const Operand& op, const Ymm& y, uint8_t imm) {
+  if (!(op.isXMEM() && y.isYMM()))
+    XBYAK_THROW(ERR_BAD_COMBINATION) opVex(y, 0, op, T_0F3A | T_66 | T_W0 | T_YMM, 0x19, imm);
+}
+void vextracti128(const Operand& op, const Ymm& y, uint8_t imm) {
+  if (!(op.isXMEM() && y.isYMM()))
+    XBYAK_THROW(ERR_BAD_COMBINATION) opVex(y, 0, op, T_0F3A | T_66 | T_W0 | T_YMM, 0x39, imm);
+}
+void vextractps(const Operand& op, const Xmm& x, uint8_t imm) {
+  if (!((op.isREG(32) || op.isMEM()) && x.isXMM()))
+    XBYAK_THROW(ERR_BAD_COMBINATION) opVex(x, 0, op, T_0F3A | T_66 | T_W0 | T_EVEX | T_N4, 0x17, imm);
+}
+void vfmadd132pd(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_W1 | T_EW1 | T_YMM | T_EVEX | T_B64, 0x98);
+}
+void vfmadd132ps(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_W0 | T_EW0 | T_YMM | T_EVEX | T_B32, 0x98);
+}
+void vfmadd132sd(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_N8 | T_66 | T_0F38 | T_W1 | T_EW1 | T_EVEX | T_ER_X, 0x99);
+}
+void vfmadd132ss(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_N4 | T_66 | T_0F38 | T_W0 | T_EW0 | T_EVEX | T_ER_X, 0x99);
+}
+void vfmadd213pd(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_W1 | T_EW1 | T_YMM | T_EVEX | T_B64, 0xA8);
+}
+void vfmadd213ps(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_W0 | T_EW0 | T_YMM | T_EVEX | T_B32, 0xA8);
+}
+void vfmadd213sd(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_N8 | T_66 | T_0F38 | T_W1 | T_EW1 | T_EVEX | T_ER_X, 0xA9);
+}
+void vfmadd213ss(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_N4 | T_66 | T_0F38 | T_W0 | T_EW0 | T_EVEX | T_ER_X, 0xA9);
+}
+void vfmadd231pd(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_W1 | T_EW1 | T_YMM | T_EVEX | T_B64, 0xB8);
+}
+void vfmadd231ps(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_W0 | T_EW0 | T_YMM | T_EVEX | T_B32, 0xB8);
+}
+void vfmadd231sd(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_N8 | T_66 | T_0F38 | T_W1 | T_EW1 | T_EVEX | T_ER_X, 0xB9);
+}
+void vfmadd231ss(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_N4 | T_66 | T_0F38 | T_W0 | T_EW0 | T_EVEX | T_ER_X, 0xB9);
+}
+void vfmaddsub132pd(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_W1 | T_EW1 | T_YMM | T_EVEX | T_B64, 0x96);
+}
+void vfmaddsub132ps(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_W0 | T_EW0 | T_YMM | T_EVEX | T_B32, 0x96);
+}
+void vfmaddsub213pd(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_W1 | T_EW1 | T_YMM | T_EVEX | T_B64, 0xA6);
+}
+void vfmaddsub213ps(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_W0 | T_EW0 | T_YMM | T_EVEX | T_B32, 0xA6);
+}
+void vfmaddsub231pd(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_W1 | T_EW1 | T_YMM | T_EVEX | T_B64, 0xB6);
+}
+void vfmaddsub231ps(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_W0 | T_EW0 | T_YMM | T_EVEX | T_B32, 0xB6);
+}
+void vfmsub132pd(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_W1 | T_EW1 | T_YMM | T_EVEX | T_B64, 0x9A);
+}
+void vfmsub132ps(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_W0 | T_EW0 | T_YMM | T_EVEX | T_B32, 0x9A);
+}
+void vfmsub132sd(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_N8 | T_66 | T_0F38 | T_W1 | T_EW1 | T_EVEX | T_ER_X, 0x9B);
+}
+void vfmsub132ss(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_N4 | T_66 | T_0F38 | T_W0 | T_EW0 | T_EVEX | T_ER_X, 0x9B);
+}
+void vfmsub213pd(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_W1 | T_EW1 | T_YMM | T_EVEX | T_B64, 0xAA);
+}
+void vfmsub213ps(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_W0 | T_EW0 | T_YMM | T_EVEX | T_B32, 0xAA);
+}
+void vfmsub213sd(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_N8 | T_66 | T_0F38 | T_W1 | T_EW1 | T_EVEX | T_ER_X, 0xAB);
+}
+void vfmsub213ss(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_N4 | T_66 | T_0F38 | T_W0 | T_EW0 | T_EVEX | T_ER_X, 0xAB);
+}
+void vfmsub231pd(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_W1 | T_EW1 | T_YMM | T_EVEX | T_B64, 0xBA);
+}
+void vfmsub231ps(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_W0 | T_EW0 | T_YMM | T_EVEX | T_B32, 0xBA);
+}
+void vfmsub231sd(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_N8 | T_66 | T_0F38 | T_W1 | T_EW1 | T_EVEX | T_ER_X, 0xBB);
+}
+void vfmsub231ss(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_N4 | T_66 | T_0F38 | T_W0 | T_EW0 | T_EVEX | T_ER_X, 0xBB);
+}
+void vfmsubadd132pd(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_W1 | T_EW1 | T_YMM | T_EVEX | T_B64, 0x97);
+}
+void vfmsubadd132ps(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_W0 | T_EW0 | T_YMM | T_EVEX | T_B32, 0x97);
+}
+void vfmsubadd213pd(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_W1 | T_EW1 | T_YMM | T_EVEX | T_B64, 0xA7);
+}
+void vfmsubadd213ps(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_W0 | T_EW0 | T_YMM | T_EVEX | T_B32, 0xA7);
+}
+void vfmsubadd231pd(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_W1 | T_EW1 | T_YMM | T_EVEX | T_B64, 0xB7);
+}
+void vfmsubadd231ps(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_W0 | T_EW0 | T_YMM | T_EVEX | T_B32, 0xB7);
+}
+void vfnmadd132pd(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_W1 | T_EW1 | T_YMM | T_EVEX | T_B64, 0x9C);
+}
+void vfnmadd132ps(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_W0 | T_EW0 | T_YMM | T_EVEX | T_B32, 0x9C);
+}
+void vfnmadd132sd(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_N8 | T_66 | T_0F38 | T_W1 | T_EW1 | T_EVEX | T_ER_X, 0x9D);
+}
+void vfnmadd132ss(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_N4 | T_66 | T_0F38 | T_W0 | T_EW0 | T_EVEX | T_ER_X, 0x9D);
+}
+void vfnmadd213pd(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_W1 | T_EW1 | T_YMM | T_EVEX | T_B64, 0xAC);
+}
+void vfnmadd213ps(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_W0 | T_EW0 | T_YMM | T_EVEX | T_B32, 0xAC);
+}
+void vfnmadd213sd(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_N8 | T_66 | T_0F38 | T_W1 | T_EW1 | T_EVEX | T_ER_X, 0xAD);
+}
+void vfnmadd213ss(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_N4 | T_66 | T_0F38 | T_W0 | T_EW0 | T_EVEX | T_ER_X, 0xAD);
+}
+void vfnmadd231pd(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_W1 | T_EW1 | T_YMM | T_EVEX | T_B64, 0xBC);
+}
+void vfnmadd231ps(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_W0 | T_EW0 | T_YMM | T_EVEX | T_B32, 0xBC);
+}
+void vfnmadd231sd(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_N8 | T_66 | T_0F38 | T_W1 | T_EW1 | T_EVEX | T_ER_X, 0xBD);
+}
+void vfnmadd231ss(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_N4 | T_66 | T_0F38 | T_W0 | T_EW0 | T_EVEX | T_ER_X, 0xBD);
+}
+void vfnmsub132pd(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_W1 | T_EW1 | T_YMM | T_EVEX | T_B64, 0x9E);
+}
+void vfnmsub132ps(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_W0 | T_EW0 | T_YMM | T_EVEX | T_B32, 0x9E);
+}
+void vfnmsub132sd(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_N8 | T_66 | T_0F38 | T_W1 | T_EW1 | T_EVEX | T_ER_X, 0x9F);
+}
+void vfnmsub132ss(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_N4 | T_66 | T_0F38 | T_W0 | T_EW0 | T_EVEX | T_ER_X, 0x9F);
+}
+void vfnmsub213pd(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_W1 | T_EW1 | T_YMM | T_EVEX | T_B64, 0xAE);
+}
+void vfnmsub213ps(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_W0 | T_EW0 | T_YMM | T_EVEX | T_B32, 0xAE);
+}
+void vfnmsub213sd(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_N8 | T_66 | T_0F38 | T_W1 | T_EW1 | T_EVEX | T_ER_X, 0xAF);
+}
+void vfnmsub213ss(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_N4 | T_66 | T_0F38 | T_W0 | T_EW0 | T_EVEX | T_ER_X, 0xAF);
+}
+void vfnmsub231pd(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_W1 | T_EW1 | T_YMM | T_EVEX | T_B64, 0xBE);
+}
+void vfnmsub231ps(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_W0 | T_EW0 | T_YMM | T_EVEX | T_B32, 0xBE);
+}
+void vfnmsub231sd(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_N8 | T_66 | T_0F38 | T_W1 | T_EW1 | T_EVEX | T_ER_X, 0xBF);
+}
+void vfnmsub231ss(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_N4 | T_66 | T_0F38 | T_W0 | T_EW0 | T_EVEX | T_ER_X, 0xBF);
+}
+void vgatherdpd(const Xmm& x1, const Address& addr, const Xmm& x2) {
+  opGather(x1, addr, x2, T_0F38 | T_66 | T_YMM | T_VSIB | T_W1, 0x92, 0);
+}
+void vgatherdps(const Xmm& x1, const Address& addr, const Xmm& x2) {
+  opGather(x1, addr, x2, T_0F38 | T_66 | T_YMM | T_VSIB | T_W0, 0x92, 1);
+}
+void vgatherqpd(const Xmm& x1, const Address& addr, const Xmm& x2) {
+  opGather(x1, addr, x2, T_0F38 | T_66 | T_YMM | T_VSIB | T_W1, 0x93, 1);
+}
+void vgatherqps(const Xmm& x1, const Address& addr, const Xmm& x2) {
+  opGather(x1, addr, x2, T_0F38 | T_66 | T_YMM | T_VSIB | T_W0, 0x93, 2);
+}
+void vgf2p8affineinvqb(const Xmm& x1, const Xmm& x2, const Operand& op, uint8_t imm) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F3A | T_W1 | T_EW1 | T_YMM | T_EVEX | T_SAE_Z | T_B64, 0xCF, imm);
+}
+void vgf2p8affineqb(const Xmm& x1, const Xmm& x2, const Operand& op, uint8_t imm) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F3A | T_W1 | T_EW1 | T_YMM | T_EVEX | T_SAE_Z | T_B64, 0xCE, imm);
+}
+void vgf2p8mulb(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_W0 | T_EW0 | T_YMM | T_EVEX | T_SAE_Z, 0xCF);
+}
+void vhaddpd(const Xmm& xmm, const Operand& op1, const Operand& op2 = Operand()) {
+  opAVX_X_X_XM(xmm, op1, op2, T_66 | T_0F | T_YMM, 0x7C);
+}
+void vhaddps(const Xmm& xmm, const Operand& op1, const Operand& op2 = Operand()) {
+  opAVX_X_X_XM(xmm, op1, op2, T_F2 | T_0F | T_YMM, 0x7C);
+}
+void vhsubpd(const Xmm& xmm, const Operand& op1, const Operand& op2 = Operand()) {
+  opAVX_X_X_XM(xmm, op1, op2, T_66 | T_0F | T_YMM, 0x7D);
+}
+void vhsubps(const Xmm& xmm, const Operand& op1, const Operand& op2 = Operand()) {
+  opAVX_X_X_XM(xmm, op1, op2, T_F2 | T_0F | T_YMM, 0x7D);
+}
+void vinsertf128(const Ymm& y1, const Ymm& y2, const Operand& op, uint8_t imm) {
+  if (!(y1.isYMM() && y2.isYMM() && op.isXMEM()))
+    XBYAK_THROW(ERR_BAD_COMBINATION) opVex(y1, &y2, op, T_0F3A | T_66 | T_W0 | T_YMM, 0x18, imm);
+}
+void vinserti128(const Ymm& y1, const Ymm& y2, const Operand& op, uint8_t imm) {
+  if (!(y1.isYMM() && y2.isYMM() && op.isXMEM()))
+    XBYAK_THROW(ERR_BAD_COMBINATION) opVex(y1, &y2, op, T_0F3A | T_66 | T_W0 | T_YMM, 0x38, imm);
+}
+void vinsertps(const Xmm& x1, const Xmm& x2, const Operand& op, uint8_t imm) {
+  opAVX_X_X_XM(x1, x2, op, T_N4 | T_66 | T_0F3A | T_W0 | T_EW0 | T_EVEX, 0x21, imm);
+}
 void vlddqu(const Xmm& x, const Address& addr) { opAVX_X_X_XM(x, cvtIdx0(x), addr, T_0F | T_F2 | T_W0 | T_YMM, 0xF0); }
 void vldmxcsr(const Address& addr) { opAVX_X_X_XM(xm2, xm0, addr, T_0F, 0xAE); }
 void vmaskmovdqu(const Xmm& x1, const Xmm& x2) { opAVX_X_X_XM(x1, xm0, x2, T_0F | T_66, 0xF7); }
-void vmaskmovpd(const Address& addr, const Xmm& x1, const Xmm& x2) { opAVX_X_X_XM(x2, x1, addr, T_0F38 | T_66 | T_W0 | T_YMM, 0x2F); }
-void vmaskmovpd(const Xmm& x1, const Xmm& x2, const Address& addr) { opAVX_X_X_XM(x1, x2, addr, T_0F38 | T_66 | T_W0 | T_YMM, 0x2D); }
-void vmaskmovps(const Address& addr, const Xmm& x1, const Xmm& x2) { opAVX_X_X_XM(x2, x1, addr, T_0F38 | T_66 | T_W0 | T_YMM, 0x2E); }
-void vmaskmovps(const Xmm& x1, const Xmm& x2, const Address& addr) { opAVX_X_X_XM(x1, x2, addr, T_0F38 | T_66 | T_W0 | T_YMM, 0x2C); }
-void vmaxpd(const Xmm& xmm, const Operand& op1, const Operand& op2 = Operand()) { opAVX_X_X_XM(xmm, op1, op2, T_0F | T_66 | T_EW1 | T_YMM | T_EVEX | T_ER_Z | T_B64, 0x5F); }
-void vmaxps(const Xmm& xmm, const Operand& op1, const Operand& op2 = Operand()) { opAVX_X_X_XM(xmm, op1, op2, T_0F | T_EW0 | T_YMM | T_EVEX | T_ER_Z | T_B32, 0x5F); }
-void vmaxsd(const Xmm& xmm, const Operand& op1, const Operand& op2 = Operand()) { opAVX_X_X_XM(xmm, op1, op2, T_0F | T_F2 | T_EW1 | T_EVEX | T_ER_X | T_N8, 0x5F); }
-void vmaxss(const Xmm& xmm, const Operand& op1, const Operand& op2 = Operand()) { opAVX_X_X_XM(xmm, op1, op2, T_0F | T_F3 | T_EW0 | T_EVEX | T_ER_X | T_N4, 0x5F); }
-void vminpd(const Xmm& xmm, const Operand& op1, const Operand& op2 = Operand()) { opAVX_X_X_XM(xmm, op1, op2, T_0F | T_66 | T_EW1 | T_YMM | T_EVEX | T_ER_Z | T_B64, 0x5D); }
-void vminps(const Xmm& xmm, const Operand& op1, const Operand& op2 = Operand()) { opAVX_X_X_XM(xmm, op1, op2, T_0F | T_EW0 | T_YMM | T_EVEX | T_ER_Z | T_B32, 0x5D); }
-void vminsd(const Xmm& xmm, const Operand& op1, const Operand& op2 = Operand()) { opAVX_X_X_XM(xmm, op1, op2, T_0F | T_F2 | T_EW1 | T_EVEX | T_ER_X | T_N8, 0x5D); }
-void vminss(const Xmm& xmm, const Operand& op1, const Operand& op2 = Operand()) { opAVX_X_X_XM(xmm, op1, op2, T_0F | T_F3 | T_EW0 | T_EVEX | T_ER_X | T_N4, 0x5D); }
-void vmovapd(const Address& addr, const Xmm& xmm) { opAVX_X_XM_IMM(xmm, addr, T_66 | T_0F | T_EW1 | T_YMM | T_EVEX | T_M_K, 0x29); }
+void vmaskmovpd(const Address& addr, const Xmm& x1, const Xmm& x2) {
+  opAVX_X_X_XM(x2, x1, addr, T_0F38 | T_66 | T_W0 | T_YMM, 0x2F);
+}
+void vmaskmovpd(const Xmm& x1, const Xmm& x2, const Address& addr) {
+  opAVX_X_X_XM(x1, x2, addr, T_0F38 | T_66 | T_W0 | T_YMM, 0x2D);
+}
+void vmaskmovps(const Address& addr, const Xmm& x1, const Xmm& x2) {
+  opAVX_X_X_XM(x2, x1, addr, T_0F38 | T_66 | T_W0 | T_YMM, 0x2E);
+}
+void vmaskmovps(const Xmm& x1, const Xmm& x2, const Address& addr) {
+  opAVX_X_X_XM(x1, x2, addr, T_0F38 | T_66 | T_W0 | T_YMM, 0x2C);
+}
+void vmaxpd(const Xmm& xmm, const Operand& op1, const Operand& op2 = Operand()) {
+  opAVX_X_X_XM(xmm, op1, op2, T_0F | T_66 | T_EW1 | T_YMM | T_EVEX | T_ER_Z | T_B64, 0x5F);
+}
+void vmaxps(const Xmm& xmm, const Operand& op1, const Operand& op2 = Operand()) {
+  opAVX_X_X_XM(xmm, op1, op2, T_0F | T_EW0 | T_YMM | T_EVEX | T_ER_Z | T_B32, 0x5F);
+}
+void vmaxsd(const Xmm& xmm, const Operand& op1, const Operand& op2 = Operand()) {
+  opAVX_X_X_XM(xmm, op1, op2, T_0F | T_F2 | T_EW1 | T_EVEX | T_ER_X | T_N8, 0x5F);
+}
+void vmaxss(const Xmm& xmm, const Operand& op1, const Operand& op2 = Operand()) {
+  opAVX_X_X_XM(xmm, op1, op2, T_0F | T_F3 | T_EW0 | T_EVEX | T_ER_X | T_N4, 0x5F);
+}
+void vminpd(const Xmm& xmm, const Operand& op1, const Operand& op2 = Operand()) {
+  opAVX_X_X_XM(xmm, op1, op2, T_0F | T_66 | T_EW1 | T_YMM | T_EVEX | T_ER_Z | T_B64, 0x5D);
+}
+void vminps(const Xmm& xmm, const Operand& op1, const Operand& op2 = Operand()) {
+  opAVX_X_X_XM(xmm, op1, op2, T_0F | T_EW0 | T_YMM | T_EVEX | T_ER_Z | T_B32, 0x5D);
+}
+void vminsd(const Xmm& xmm, const Operand& op1, const Operand& op2 = Operand()) {
+  opAVX_X_X_XM(xmm, op1, op2, T_0F | T_F2 | T_EW1 | T_EVEX | T_ER_X | T_N8, 0x5D);
+}
+void vminss(const Xmm& xmm, const Operand& op1, const Operand& op2 = Operand()) {
+  opAVX_X_X_XM(xmm, op1, op2, T_0F | T_F3 | T_EW0 | T_EVEX | T_ER_X | T_N4, 0x5D);
+}
+void vmovapd(const Address& addr, const Xmm& xmm) {
+  opAVX_X_XM_IMM(xmm, addr, T_66 | T_0F | T_EW1 | T_YMM | T_EVEX | T_M_K, 0x29);
+}
 void vmovapd(const Xmm& xm, const Operand& op) { opAVX_X_XM_IMM(xm, op, T_66 | T_0F | T_EW1 | T_YMM | T_EVEX, 0x28); }
-void vmovaps(const Address& addr, const Xmm& xmm) { opAVX_X_XM_IMM(xmm, addr, T_0F | T_EW0 | T_YMM | T_EVEX | T_M_K, 0x29); }
+void vmovaps(const Address& addr, const Xmm& xmm) {
+  opAVX_X_XM_IMM(xmm, addr, T_0F | T_EW0 | T_YMM | T_EVEX | T_M_K, 0x29);
+}
 void vmovaps(const Xmm& xm, const Operand& op) { opAVX_X_XM_IMM(xm, op, T_0F | T_EW0 | T_YMM | T_EVEX, 0x28); }
-void vmovd(const Operand& op, const Xmm& x) { if (!op.isREG(32) && !op.isMEM()) XBYAK_THROW(ERR_BAD_COMBINATION) opAVX_X_X_XM(x, xm0, op, T_0F | T_66 | T_W0 | T_EVEX | T_N4, 0x7E); }
-void vmovd(const Xmm& x, const Operand& op) { if (!op.isREG(32) && !op.isMEM()) XBYAK_THROW(ERR_BAD_COMBINATION) opAVX_X_X_XM(x, xm0, op, T_0F | T_66 | T_W0 | T_EVEX | T_N4, 0x6E); }
-void vmovddup(const Xmm& xm, const Operand& op) { opAVX_X_XM_IMM(xm, op, T_DUP | T_F2 | T_0F | T_EW1 | T_YMM | T_EVEX | T_ER_X | T_ER_Y | T_ER_Z, 0x12); }
+void vmovd(const Operand& op, const Xmm& x) {
+  if (!op.isREG(32) && !op.isMEM())
+    XBYAK_THROW(ERR_BAD_COMBINATION) opAVX_X_X_XM(x, xm0, op, T_0F | T_66 | T_W0 | T_EVEX | T_N4, 0x7E);
+}
+void vmovd(const Xmm& x, const Operand& op) {
+  if (!op.isREG(32) && !op.isMEM())
+    XBYAK_THROW(ERR_BAD_COMBINATION) opAVX_X_X_XM(x, xm0, op, T_0F | T_66 | T_W0 | T_EVEX | T_N4, 0x6E);
+}
+void vmovddup(const Xmm& xm, const Operand& op) {
+  opAVX_X_XM_IMM(xm, op, T_DUP | T_F2 | T_0F | T_EW1 | T_YMM | T_EVEX | T_ER_X | T_ER_Y | T_ER_Z, 0x12);
+}
 void vmovdqa(const Address& addr, const Xmm& xmm) { opAVX_X_XM_IMM(xmm, addr, T_66 | T_0F | T_YMM, 0x7F); }
 void vmovdqa(const Xmm& xm, const Operand& op) { opAVX_X_XM_IMM(xm, op, T_66 | T_0F | T_YMM, 0x6F); }
 void vmovdqu(const Address& addr, const Xmm& xmm) { opAVX_X_XM_IMM(xmm, addr, T_F3 | T_0F | T_YMM, 0x7F); }
 void vmovdqu(const Xmm& xm, const Operand& op) { opAVX_X_XM_IMM(xm, op, T_F3 | T_0F | T_YMM, 0x6F); }
-void vmovhlps(const Xmm& x1, const Xmm& x2, const Operand& op = Operand()) { if (!op.isNone() && !op.isXMM()) XBYAK_THROW(ERR_BAD_COMBINATION) opAVX_X_X_XM(x1, x2, op, T_0F | T_EVEX | T_EW0, 0x12); }
-void vmovhpd(const Address& addr, const Xmm& x) { opAVX_X_X_XM(x, xm0, addr, T_0F | T_66 | T_EVEX | T_EW1 | T_N8, 0x17); }
-void vmovhpd(const Xmm& x, const Operand& op1, const Operand& op2 = Operand()) { if (!op2.isNone() && !op2.isMEM()) XBYAK_THROW(ERR_BAD_COMBINATION) opAVX_X_X_XM(x, op1, op2, T_0F | T_66 | T_EVEX | T_EW1 | T_N8, 0x16); }
+void vmovhlps(const Xmm& x1, const Xmm& x2, const Operand& op = Operand()) {
+  if (!op.isNone() && !op.isXMM())
+    XBYAK_THROW(ERR_BAD_COMBINATION) opAVX_X_X_XM(x1, x2, op, T_0F | T_EVEX | T_EW0, 0x12);
+}
+void vmovhpd(const Address& addr, const Xmm& x) {
+  opAVX_X_X_XM(x, xm0, addr, T_0F | T_66 | T_EVEX | T_EW1 | T_N8, 0x17);
+}
+void vmovhpd(const Xmm& x, const Operand& op1, const Operand& op2 = Operand()) {
+  if (!op2.isNone() && !op2.isMEM())
+    XBYAK_THROW(ERR_BAD_COMBINATION) opAVX_X_X_XM(x, op1, op2, T_0F | T_66 | T_EVEX | T_EW1 | T_N8, 0x16);
+}
 void vmovhps(const Address& addr, const Xmm& x) { opAVX_X_X_XM(x, xm0, addr, T_0F | T_EVEX | T_EW0 | T_N8, 0x17); }
-void vmovhps(const Xmm& x, const Operand& op1, const Operand& op2 = Operand()) { if (!op2.isNone() && !op2.isMEM()) XBYAK_THROW(ERR_BAD_COMBINATION) opAVX_X_X_XM(x, op1, op2, T_0F | T_EVEX | T_EW0 | T_N8, 0x16); }
-void vmovlhps(const Xmm& x1, const Xmm& x2, const Operand& op = Operand()) { if (!op.isNone() && !op.isXMM()) XBYAK_THROW(ERR_BAD_COMBINATION) opAVX_X_X_XM(x1, x2, op, T_0F | T_EVEX | T_EW0, 0x16); }
-void vmovlpd(const Address& addr, const Xmm& x) { opAVX_X_X_XM(x, xm0, addr, T_0F | T_66 | T_EVEX | T_EW1 | T_N8, 0x13); }
-void vmovlpd(const Xmm& x, const Operand& op1, const Operand& op2 = Operand()) { if (!op2.isNone() && !op2.isMEM()) XBYAK_THROW(ERR_BAD_COMBINATION) opAVX_X_X_XM(x, op1, op2, T_0F | T_66 | T_EVEX | T_EW1 | T_N8, 0x12); }
+void vmovhps(const Xmm& x, const Operand& op1, const Operand& op2 = Operand()) {
+  if (!op2.isNone() && !op2.isMEM())
+    XBYAK_THROW(ERR_BAD_COMBINATION) opAVX_X_X_XM(x, op1, op2, T_0F | T_EVEX | T_EW0 | T_N8, 0x16);
+}
+void vmovlhps(const Xmm& x1, const Xmm& x2, const Operand& op = Operand()) {
+  if (!op.isNone() && !op.isXMM())
+    XBYAK_THROW(ERR_BAD_COMBINATION) opAVX_X_X_XM(x1, x2, op, T_0F | T_EVEX | T_EW0, 0x16);
+}
+void vmovlpd(const Address& addr, const Xmm& x) {
+  opAVX_X_X_XM(x, xm0, addr, T_0F | T_66 | T_EVEX | T_EW1 | T_N8, 0x13);
+}
+void vmovlpd(const Xmm& x, const Operand& op1, const Operand& op2 = Operand()) {
+  if (!op2.isNone() && !op2.isMEM())
+    XBYAK_THROW(ERR_BAD_COMBINATION) opAVX_X_X_XM(x, op1, op2, T_0F | T_66 | T_EVEX | T_EW1 | T_N8, 0x12);
+}
 void vmovlps(const Address& addr, const Xmm& x) { opAVX_X_X_XM(x, xm0, addr, T_0F | T_EVEX | T_EW0 | T_N8, 0x13); }
-void vmovlps(const Xmm& x, const Operand& op1, const Operand& op2 = Operand()) { if (!op2.isNone() && !op2.isMEM()) XBYAK_THROW(ERR_BAD_COMBINATION) opAVX_X_X_XM(x, op1, op2, T_0F | T_EVEX | T_EW0 | T_N8, 0x12); }
-void vmovmskpd(const Reg& r, const Xmm& x) { if (!r.isBit(i32e)) XBYAK_THROW(ERR_BAD_COMBINATION) opAVX_X_X_XM(x.isXMM() ? Xmm(r.getIdx()) : Ymm(r.getIdx()), cvtIdx0(x), x, T_0F | T_66 | T_W0 | T_YMM, 0x50); }
-void vmovmskps(const Reg& r, const Xmm& x) { if (!r.isBit(i32e)) XBYAK_THROW(ERR_BAD_COMBINATION) opAVX_X_X_XM(x.isXMM() ? Xmm(r.getIdx()) : Ymm(r.getIdx()), cvtIdx0(x), x, T_0F | T_W0 | T_YMM, 0x50); }
+void vmovlps(const Xmm& x, const Operand& op1, const Operand& op2 = Operand()) {
+  if (!op2.isNone() && !op2.isMEM())
+    XBYAK_THROW(ERR_BAD_COMBINATION) opAVX_X_X_XM(x, op1, op2, T_0F | T_EVEX | T_EW0 | T_N8, 0x12);
+}
+void vmovmskpd(const Reg& r, const Xmm& x) {
+  if (!r.isBit(i32e))
+    XBYAK_THROW(ERR_BAD_COMBINATION)
+    opAVX_X_X_XM(x.isXMM() ? Xmm(r.getIdx()) : Ymm(r.getIdx()), cvtIdx0(x), x, T_0F | T_66 | T_W0 | T_YMM, 0x50);
+}
+void vmovmskps(const Reg& r, const Xmm& x) {
+  if (!r.isBit(i32e))
+    XBYAK_THROW(ERR_BAD_COMBINATION)
+    opAVX_X_X_XM(x.isXMM() ? Xmm(r.getIdx()) : Ymm(r.getIdx()), cvtIdx0(x), x, T_0F | T_W0 | T_YMM, 0x50);
+}
 void vmovntdq(const Address& addr, const Xmm& x) { opVex(x, 0, addr, T_0F | T_66 | T_YMM | T_EVEX | T_EW0, 0xE7); }
 void vmovntdqa(const Xmm& x, const Address& addr) { opVex(x, 0, addr, T_0F38 | T_66 | T_YMM | T_EVEX | T_EW0, 0x2A); }
 void vmovntpd(const Address& addr, const Xmm& x) { opVex(x, 0, addr, T_0F | T_66 | T_YMM | T_EVEX | T_EW1, 0x2B); }
 void vmovntps(const Address& addr, const Xmm& x) { opVex(x, 0, addr, T_0F | T_YMM | T_EVEX | T_EW0, 0x2B); }
-void vmovq(const Address& addr, const Xmm& x) { opAVX_X_X_XM(x, xm0, addr, T_0F | T_66 | T_EVEX | T_EW1 | T_N8, x.getIdx() < 16 ? 0xD6 : 0x7E); }
-void vmovq(const Xmm& x, const Address& addr) { int type, code; if (x.getIdx() < 16) { type = T_0F | T_F3; code = 0x7E; } else { type = T_0F | T_66 | T_EVEX | T_EW1 | T_N8; code = 0x6E; } opAVX_X_X_XM(x, xm0, addr, type, code); }
+void vmovq(const Address& addr, const Xmm& x) {
+  opAVX_X_X_XM(x, xm0, addr, T_0F | T_66 | T_EVEX | T_EW1 | T_N8, x.getIdx() < 16 ? 0xD6 : 0x7E);
+}
+void vmovq(const Xmm& x, const Address& addr) {
+  int type, code;
+  if (x.getIdx() < 16) {
+    type = T_0F | T_F3;
+    code = 0x7E;
+  } else {
+    type = T_0F | T_66 | T_EVEX | T_EW1 | T_N8;
+    code = 0x6E;
+  }
+  opAVX_X_X_XM(x, xm0, addr, type, code);
+}
 void vmovq(const Xmm& x1, const Xmm& x2) { opAVX_X_X_XM(x1, xm0, x2, T_0F | T_F3 | T_EVEX | T_EW1 | T_N8, 0x7E); }
-void vmovsd(const Address& addr, const Xmm& x) { opAVX_X_X_XM(x, xm0, addr, T_N8 | T_F2 | T_0F | T_EW1 | T_EVEX | T_M_K, 0x11); }
-void vmovsd(const Xmm& x, const Address& addr) { opAVX_X_X_XM(x, xm0, addr, T_N8 | T_F2 | T_0F | T_EW1 | T_EVEX, 0x10); }
-void vmovsd(const Xmm& x1, const Xmm& x2, const Operand& op = Operand()) { if (!op.isNone() && !op.isXMM()) XBYAK_THROW(ERR_BAD_COMBINATION) opAVX_X_X_XM(x1, x2, op, T_N8 | T_F2 | T_0F | T_EW1 | T_EVEX, 0x10); }
+void vmovsd(const Address& addr, const Xmm& x) {
+  opAVX_X_X_XM(x, xm0, addr, T_N8 | T_F2 | T_0F | T_EW1 | T_EVEX | T_M_K, 0x11);
+}
+void vmovsd(const Xmm& x, const Address& addr) {
+  opAVX_X_X_XM(x, xm0, addr, T_N8 | T_F2 | T_0F | T_EW1 | T_EVEX, 0x10);
+}
+void vmovsd(const Xmm& x1, const Xmm& x2, const Operand& op = Operand()) {
+  if (!op.isNone() && !op.isXMM())
+    XBYAK_THROW(ERR_BAD_COMBINATION) opAVX_X_X_XM(x1, x2, op, T_N8 | T_F2 | T_0F | T_EW1 | T_EVEX, 0x10);
+}
 void vmovshdup(const Xmm& xm, const Operand& op) { opAVX_X_XM_IMM(xm, op, T_F3 | T_0F | T_EW0 | T_YMM | T_EVEX, 0x16); }
 void vmovsldup(const Xmm& xm, const Operand& op) { opAVX_X_XM_IMM(xm, op, T_F3 | T_0F | T_EW0 | T_YMM | T_EVEX, 0x12); }
-void vmovss(const Address& addr, const Xmm& x) { opAVX_X_X_XM(x, xm0, addr, T_N4 | T_F3 | T_0F | T_EW0 | T_EVEX | T_M_K, 0x11); }
-void vmovss(const Xmm& x, const Address& addr) { opAVX_X_X_XM(x, xm0, addr, T_N4 | T_F3 | T_0F | T_EW0 | T_EVEX, 0x10); }
-void vmovss(const Xmm& x1, const Xmm& x2, const Operand& op = Operand()) { if (!op.isNone() && !op.isXMM()) XBYAK_THROW(ERR_BAD_COMBINATION) opAVX_X_X_XM(x1, x2, op, T_N4 | T_F3 | T_0F | T_EW0 | T_EVEX, 0x10); }
-void vmovupd(const Address& addr, const Xmm& xmm) { opAVX_X_XM_IMM(xmm, addr, T_66 | T_0F | T_EW1 | T_YMM | T_EVEX | T_M_K, 0x11); }
+void vmovss(const Address& addr, const Xmm& x) {
+  opAVX_X_X_XM(x, xm0, addr, T_N4 | T_F3 | T_0F | T_EW0 | T_EVEX | T_M_K, 0x11);
+}
+void vmovss(const Xmm& x, const Address& addr) {
+  opAVX_X_X_XM(x, xm0, addr, T_N4 | T_F3 | T_0F | T_EW0 | T_EVEX, 0x10);
+}
+void vmovss(const Xmm& x1, const Xmm& x2, const Operand& op = Operand()) {
+  if (!op.isNone() && !op.isXMM())
+    XBYAK_THROW(ERR_BAD_COMBINATION) opAVX_X_X_XM(x1, x2, op, T_N4 | T_F3 | T_0F | T_EW0 | T_EVEX, 0x10);
+}
+void vmovupd(const Address& addr, const Xmm& xmm) {
+  opAVX_X_XM_IMM(xmm, addr, T_66 | T_0F | T_EW1 | T_YMM | T_EVEX | T_M_K, 0x11);
+}
 void vmovupd(const Xmm& xm, const Operand& op) { opAVX_X_XM_IMM(xm, op, T_66 | T_0F | T_EW1 | T_YMM | T_EVEX, 0x10); }
-void vmovups(const Address& addr, const Xmm& xmm) { opAVX_X_XM_IMM(xmm, addr, T_0F | T_EW0 | T_YMM | T_EVEX | T_M_K, 0x11); }
+void vmovups(const Address& addr, const Xmm& xmm) {
+  opAVX_X_XM_IMM(xmm, addr, T_0F | T_EW0 | T_YMM | T_EVEX | T_M_K, 0x11);
+}
 void vmovups(const Xmm& xm, const Operand& op) { opAVX_X_XM_IMM(xm, op, T_0F | T_EW0 | T_YMM | T_EVEX, 0x10); }
-void vmpsadbw(const Xmm& x1, const Xmm& x2, const Operand& op, uint8_t imm) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F3A | T_W0 | T_YMM, 0x42, imm); }
-void vmulpd(const Xmm& xmm, const Operand& op1, const Operand& op2 = Operand()) { opAVX_X_X_XM(xmm, op1, op2, T_0F | T_66 | T_EW1 | T_YMM | T_EVEX | T_ER_Z | T_B64, 0x59); }
-void vmulps(const Xmm& xmm, const Operand& op1, const Operand& op2 = Operand()) { opAVX_X_X_XM(xmm, op1, op2, T_0F | T_EW0 | T_YMM | T_EVEX | T_ER_Z | T_B32, 0x59); }
-void vmulsd(const Xmm& xmm, const Operand& op1, const Operand& op2 = Operand()) { opAVX_X_X_XM(xmm, op1, op2, T_0F | T_F2 | T_EW1 | T_EVEX | T_ER_X | T_N8, 0x59); }
-void vmulss(const Xmm& xmm, const Operand& op1, const Operand& op2 = Operand()) { opAVX_X_X_XM(xmm, op1, op2, T_0F | T_F3 | T_EW0 | T_EVEX | T_ER_X | T_N4, 0x59); }
-void vorpd(const Xmm& xmm, const Operand& op1, const Operand& op2 = Operand()) { opAVX_X_X_XM(xmm, op1, op2, T_0F | T_66 | T_EW1 | T_YMM | T_EVEX | T_ER_Z | T_B64, 0x56); }
-void vorps(const Xmm& xmm, const Operand& op1, const Operand& op2 = Operand()) { opAVX_X_X_XM(xmm, op1, op2, T_0F | T_EW0 | T_YMM | T_EVEX | T_ER_Z | T_B32, 0x56); }
+void vmpsadbw(const Xmm& x1, const Xmm& x2, const Operand& op, uint8_t imm) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F3A | T_W0 | T_YMM, 0x42, imm);
+}
+void vmulpd(const Xmm& xmm, const Operand& op1, const Operand& op2 = Operand()) {
+  opAVX_X_X_XM(xmm, op1, op2, T_0F | T_66 | T_EW1 | T_YMM | T_EVEX | T_ER_Z | T_B64, 0x59);
+}
+void vmulps(const Xmm& xmm, const Operand& op1, const Operand& op2 = Operand()) {
+  opAVX_X_X_XM(xmm, op1, op2, T_0F | T_EW0 | T_YMM | T_EVEX | T_ER_Z | T_B32, 0x59);
+}
+void vmulsd(const Xmm& xmm, const Operand& op1, const Operand& op2 = Operand()) {
+  opAVX_X_X_XM(xmm, op1, op2, T_0F | T_F2 | T_EW1 | T_EVEX | T_ER_X | T_N8, 0x59);
+}
+void vmulss(const Xmm& xmm, const Operand& op1, const Operand& op2 = Operand()) {
+  opAVX_X_X_XM(xmm, op1, op2, T_0F | T_F3 | T_EW0 | T_EVEX | T_ER_X | T_N4, 0x59);
+}
+void vorpd(const Xmm& xmm, const Operand& op1, const Operand& op2 = Operand()) {
+  opAVX_X_X_XM(xmm, op1, op2, T_0F | T_66 | T_EW1 | T_YMM | T_EVEX | T_ER_Z | T_B64, 0x56);
+}
+void vorps(const Xmm& xmm, const Operand& op1, const Operand& op2 = Operand()) {
+  opAVX_X_X_XM(xmm, op1, op2, T_0F | T_EW0 | T_YMM | T_EVEX | T_ER_Z | T_B32, 0x56);
+}
 void vpabsb(const Xmm& xm, const Operand& op) { opAVX_X_XM_IMM(xm, op, T_66 | T_0F38 | T_YMM | T_EVEX, 0x1C); }
-void vpabsd(const Xmm& xm, const Operand& op) { opAVX_X_XM_IMM(xm, op, T_66 | T_0F38 | T_EW0 | T_YMM | T_EVEX | T_B32, 0x1E); }
+void vpabsd(const Xmm& xm, const Operand& op) {
+  opAVX_X_XM_IMM(xm, op, T_66 | T_0F38 | T_EW0 | T_YMM | T_EVEX | T_B32, 0x1E);
+}
 void vpabsw(const Xmm& xm, const Operand& op) { opAVX_X_XM_IMM(xm, op, T_66 | T_0F38 | T_YMM | T_EVEX, 0x1D); }
-void vpackssdw(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F | T_EW0 | T_YMM | T_EVEX | T_B32, 0x6B); }
-void vpacksswb(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F | T_YMM | T_EVEX, 0x63); }
-void vpackusdw(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_EW0 | T_YMM | T_EVEX | T_B32, 0x2B); }
-void vpackuswb(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F | T_YMM | T_EVEX, 0x67); }
-void vpaddb(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F | T_YMM | T_EVEX, 0xFC); }
-void vpaddd(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F | T_EW0 | T_YMM | T_EVEX | T_B32, 0xFE); }
-void vpaddq(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F | T_EW1 | T_YMM | T_EVEX | T_B64, 0xD4); }
-void vpaddsb(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F | T_YMM | T_EVEX, 0xEC); }
-void vpaddsw(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F | T_YMM | T_EVEX, 0xED); }
-void vpaddusb(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F | T_YMM | T_EVEX, 0xDC); }
-void vpaddusw(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F | T_YMM | T_EVEX, 0xDD); }
-void vpaddw(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F | T_YMM | T_EVEX, 0xFD); }
-void vpalignr(const Xmm& x1, const Xmm& x2, const Operand& op, uint8_t imm) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F3A | T_YMM | T_EVEX, 0x0F, imm); }
+void vpackssdw(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F | T_EW0 | T_YMM | T_EVEX | T_B32, 0x6B);
+}
+void vpacksswb(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F | T_YMM | T_EVEX, 0x63);
+}
+void vpackusdw(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_EW0 | T_YMM | T_EVEX | T_B32, 0x2B);
+}
+void vpackuswb(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F | T_YMM | T_EVEX, 0x67);
+}
+void vpaddb(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F | T_YMM | T_EVEX, 0xFC);
+}
+void vpaddd(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F | T_EW0 | T_YMM | T_EVEX | T_B32, 0xFE);
+}
+void vpaddq(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F | T_EW1 | T_YMM | T_EVEX | T_B64, 0xD4);
+}
+void vpaddsb(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F | T_YMM | T_EVEX, 0xEC);
+}
+void vpaddsw(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F | T_YMM | T_EVEX, 0xED);
+}
+void vpaddusb(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F | T_YMM | T_EVEX, 0xDC);
+}
+void vpaddusw(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F | T_YMM | T_EVEX, 0xDD);
+}
+void vpaddw(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F | T_YMM | T_EVEX, 0xFD);
+}
+void vpalignr(const Xmm& x1, const Xmm& x2, const Operand& op, uint8_t imm) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F3A | T_YMM | T_EVEX, 0x0F, imm);
+}
 void vpand(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F | T_YMM, 0xDB); }
 void vpandn(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F | T_YMM, 0xDF); }
-void vpavgb(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F | T_YMM | T_EVEX, 0xE0); }
-void vpavgw(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F | T_YMM | T_EVEX, 0xE3); }
-void vpblendd(const Xmm& x1, const Xmm& x2, const Operand& op, uint8_t imm) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F3A | T_W0 | T_YMM, 0x02, imm); }
-void vpblendvb(const Xmm& x1, const Xmm& x2, const Operand& op, const Xmm& x4) { opAVX_X_X_XM(x1, x2, op, T_0F3A | T_66 | T_YMM, 0x4C, x4.getIdx() << 4); }
-void vpblendw(const Xmm& x1, const Xmm& x2, const Operand& op, uint8_t imm) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F3A | T_W0 | T_YMM, 0x0E, imm); }
-void vpbroadcastb(const Xmm& x, const Operand& op) { if (!(op.isXMM() || op.isMEM())) XBYAK_THROW(ERR_BAD_COMBINATION) opAVX_X_XM_IMM(x, op, T_N1 | T_66 | T_0F38 | T_W0 | T_YMM | T_EVEX, 0x78); }
-void vpbroadcastd(const Xmm& x, const Operand& op) { if (!(op.isXMM() || op.isMEM())) XBYAK_THROW(ERR_BAD_COMBINATION) opAVX_X_XM_IMM(x, op, T_N4 | T_66 | T_0F38 | T_W0 | T_YMM | T_EVEX, 0x58); }
-void vpbroadcastq(const Xmm& x, const Operand& op) { if (!(op.isXMM() || op.isMEM())) XBYAK_THROW(ERR_BAD_COMBINATION) opAVX_X_XM_IMM(x, op, T_N8 | T_66 | T_0F38 | T_W0 | T_EW1 | T_YMM | T_EVEX, 0x59); }
-void vpbroadcastw(const Xmm& x, const Operand& op) { if (!(op.isXMM() || op.isMEM())) XBYAK_THROW(ERR_BAD_COMBINATION) opAVX_X_XM_IMM(x, op, T_N2 | T_66 | T_0F38 | T_W0 | T_YMM | T_EVEX, 0x79); }
+void vpavgb(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F | T_YMM | T_EVEX, 0xE0);
+}
+void vpavgw(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F | T_YMM | T_EVEX, 0xE3);
+}
+void vpblendd(const Xmm& x1, const Xmm& x2, const Operand& op, uint8_t imm) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F3A | T_W0 | T_YMM, 0x02, imm);
+}
+void vpblendvb(const Xmm& x1, const Xmm& x2, const Operand& op, const Xmm& x4) {
+  opAVX_X_X_XM(x1, x2, op, T_0F3A | T_66 | T_YMM, 0x4C, x4.getIdx() << 4);
+}
+void vpblendw(const Xmm& x1, const Xmm& x2, const Operand& op, uint8_t imm) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F3A | T_W0 | T_YMM, 0x0E, imm);
+}
+void vpbroadcastb(const Xmm& x, const Operand& op) {
+  if (!(op.isXMM() || op.isMEM()))
+    XBYAK_THROW(ERR_BAD_COMBINATION) opAVX_X_XM_IMM(x, op, T_N1 | T_66 | T_0F38 | T_W0 | T_YMM | T_EVEX, 0x78);
+}
+void vpbroadcastd(const Xmm& x, const Operand& op) {
+  if (!(op.isXMM() || op.isMEM()))
+    XBYAK_THROW(ERR_BAD_COMBINATION) opAVX_X_XM_IMM(x, op, T_N4 | T_66 | T_0F38 | T_W0 | T_YMM | T_EVEX, 0x58);
+}
+void vpbroadcastq(const Xmm& x, const Operand& op) {
+  if (!(op.isXMM() || op.isMEM()))
+    XBYAK_THROW(ERR_BAD_COMBINATION) opAVX_X_XM_IMM(x, op, T_N8 | T_66 | T_0F38 | T_W0 | T_EW1 | T_YMM | T_EVEX, 0x59);
+}
+void vpbroadcastw(const Xmm& x, const Operand& op) {
+  if (!(op.isXMM() || op.isMEM()))
+    XBYAK_THROW(ERR_BAD_COMBINATION) opAVX_X_XM_IMM(x, op, T_N2 | T_66 | T_0F38 | T_W0 | T_YMM | T_EVEX, 0x79);
+}
 void vpclmulhqhqdq(const Xmm& x1, const Xmm& x2, const Operand& op) { vpclmulqdq(x1, x2, op, 0x11); }
 void vpclmulhqlqdq(const Xmm& x1, const Xmm& x2, const Operand& op) { vpclmulqdq(x1, x2, op, 0x01); }
 void vpclmullqhqdq(const Xmm& x1, const Xmm& x2, const Operand& op) { vpclmulqdq(x1, x2, op, 0x10); }
 void vpclmullqlqdq(const Xmm& x1, const Xmm& x2, const Operand& op) { vpclmulqdq(x1, x2, op, 0x00); }
-void vpclmulqdq(const Xmm& x1, const Xmm& x2, const Operand& op, uint8_t imm) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F3A | T_W0 | T_YMM | T_EVEX, 0x44, imm); }
+void vpclmulqdq(const Xmm& x1, const Xmm& x2, const Operand& op, uint8_t imm) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F3A | T_W0 | T_YMM | T_EVEX, 0x44, imm);
+}
 void vpcmpeqb(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F | T_YMM, 0x74); }
 void vpcmpeqd(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F | T_YMM, 0x76); }
-void vpcmpeqq(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_YMM, 0x29); }
+void vpcmpeqq(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_YMM, 0x29);
+}
 void vpcmpeqw(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F | T_YMM, 0x75); }
 void vpcmpestri(const Xmm& xm, const Operand& op, uint8_t imm) { opAVX_X_XM_IMM(xm, op, T_66 | T_0F3A, 0x61, imm); }
 void vpcmpestrm(const Xmm& xm, const Operand& op, uint8_t imm) { opAVX_X_XM_IMM(xm, op, T_66 | T_0F3A, 0x60, imm); }
 void vpcmpgtb(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F | T_YMM, 0x64); }
 void vpcmpgtd(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F | T_YMM, 0x66); }
-void vpcmpgtq(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_YMM, 0x37); }
+void vpcmpgtq(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_YMM, 0x37);
+}
 void vpcmpgtw(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F | T_YMM, 0x65); }
 void vpcmpistri(const Xmm& xm, const Operand& op, uint8_t imm) { opAVX_X_XM_IMM(xm, op, T_66 | T_0F3A, 0x63, imm); }
 void vpcmpistrm(const Xmm& xm, const Operand& op, uint8_t imm) { opAVX_X_XM_IMM(xm, op, T_66 | T_0F3A, 0x62, imm); }
-void vpdpbssd(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_F2 | T_0F38 | T_W0 | T_YMM, 0x50); }
-void vpdpbssds(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_F2 | T_0F38 | T_W0 | T_YMM, 0x51); }
-void vpdpbsud(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_F3 | T_0F38 | T_W0 | T_YMM, 0x50); }
-void vpdpbsuds(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_F3 | T_0F38 | T_W0 | T_YMM, 0x51); }
-void vpdpbusd(const Xmm& x1, const Xmm& x2, const Operand& op, PreferredEncoding encoding = DefaultEncoding) { opEncoding(x1, x2, op, T_66 | T_0F38 | T_EW0 | T_YMM | T_SAE_Z | T_B32, 0x50, encoding); }
-void vpdpbusds(const Xmm& x1, const Xmm& x2, const Operand& op, PreferredEncoding encoding = DefaultEncoding) { opEncoding(x1, x2, op, T_66 | T_0F38 | T_EW0 | T_YMM | T_SAE_Z | T_B32, 0x51, encoding); }
-void vpdpbuud(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_0F38 | T_W0 | T_YMM, 0x50); }
-void vpdpbuuds(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_0F38 | T_W0 | T_YMM, 0x51); }
-void vpdpwssd(const Xmm& x1, const Xmm& x2, const Operand& op, PreferredEncoding encoding = DefaultEncoding) { opEncoding(x1, x2, op, T_66 | T_0F38 | T_EW0 | T_YMM | T_SAE_Z | T_B32, 0x52, encoding); }
-void vpdpwssds(const Xmm& x1, const Xmm& x2, const Operand& op, PreferredEncoding encoding = DefaultEncoding) { opEncoding(x1, x2, op, T_66 | T_0F38 | T_EW0 | T_YMM | T_SAE_Z | T_B32, 0x53, encoding); }
-void vpdpwsud(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_F3 | T_0F38 | T_W0 | T_YMM, 0xD2); }
-void vpdpwsuds(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_F3 | T_0F38 | T_W0 | T_YMM, 0xD3); }
-void vpdpwusd(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_W0 | T_YMM, 0xD2); }
-void vpdpwusds(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_W0 | T_YMM, 0xD3); }
-void vpdpwuud(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_0F38 | T_W0 | T_YMM, 0xD2); }
-void vpdpwuuds(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_0F38 | T_W0 | T_YMM, 0xD3); }
-void vperm2f128(const Ymm& y1, const Ymm& y2, const Operand& op, uint8_t imm) { if (!(y1.isYMM() && y2.isYMM() && op.isYMEM())) XBYAK_THROW(ERR_BAD_COMBINATION) opVex(y1, &y2, op, T_0F3A | T_66 | T_W0 | T_YMM, 0x06, imm); }
-void vperm2i128(const Ymm& y1, const Ymm& y2, const Operand& op, uint8_t imm) { if (!(y1.isYMM() && y2.isYMM() && op.isYMEM())) XBYAK_THROW(ERR_BAD_COMBINATION) opVex(y1, &y2, op, T_0F3A | T_66 | T_W0 | T_YMM, 0x46, imm); }
-void vpermd(const Ymm& y1, const Ymm& y2, const Operand& op) { opAVX_X_X_XM(y1, y2, op, T_66 | T_0F38 | T_W0 | T_EW0 | T_YMM | T_EVEX | T_B32, 0x36); }
-void vpermilpd(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_W0 | T_EW1 | T_YMM | T_EVEX | T_B64, 0x0D); }
-void vpermilpd(const Xmm& xm, const Operand& op, uint8_t imm) { opAVX_X_XM_IMM(xm, op, T_66 | T_0F3A | T_EW1 | T_YMM | T_EVEX | T_B64, 0x05, imm); }
-void vpermilps(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_W0 | T_EW0 | T_YMM | T_EVEX | T_B32, 0x0C); }
-void vpermilps(const Xmm& xm, const Operand& op, uint8_t imm) { opAVX_X_XM_IMM(xm, op, T_66 | T_0F3A | T_EW0 | T_YMM | T_EVEX | T_B32, 0x04, imm); }
-void vpermpd(const Ymm& y, const Operand& op, uint8_t imm) { opAVX_X_XM_IMM(y, op, T_66 | T_0F3A | T_W1 | T_EW1 | T_YMM | T_EVEX | T_B64, 0x01, imm); }
-void vpermpd(const Ymm& y1, const Ymm& y2, const Operand& op) { opAVX_X_X_XM(y1, y2, op, T_66 | T_0F38 | T_EW1 | T_YMM | T_MUST_EVEX | T_B64, 0x16); }
-void vpermps(const Ymm& y1, const Ymm& y2, const Operand& op) { opAVX_X_X_XM(y1, y2, op, T_66 | T_0F38 | T_W0 | T_EW0 | T_YMM | T_EVEX | T_B32, 0x16); }
-void vpermq(const Ymm& y, const Operand& op, uint8_t imm) { opAVX_X_XM_IMM(y, op, T_66 | T_0F3A | T_W1 | T_EW1 | T_YMM | T_EVEX | T_B64, 0x00, imm); }
-void vpermq(const Ymm& y1, const Ymm& y2, const Operand& op) { opAVX_X_X_XM(y1, y2, op, T_66 | T_0F38 | T_W0 | T_EW1 | T_YMM | T_EVEX | T_B64, 0x36); }
-void vpextrb(const Operand& op, const Xmm& x, uint8_t imm) { if (!((op.isREG(8|16|i32e) || op.isMEM()) && x.isXMM())) XBYAK_THROW(ERR_BAD_COMBINATION) opVex(x, 0, op, T_0F3A | T_66 | T_EVEX | T_N1, 0x14, imm); }
-void vpextrd(const Operand& op, const Xmm& x, uint8_t imm) { if (!((op.isREG(32) || op.isMEM()) && x.isXMM())) XBYAK_THROW(ERR_BAD_COMBINATION) opVex(x, 0, op, T_0F3A | T_66 | T_W0 | T_EVEX | T_EW0 | T_N4, 0x16, imm); }
-void vpextrq(const Operand& op, const Xmm& x, uint8_t imm) { if (!((op.isREG(64) || op.isMEM()) && x.isXMM())) XBYAK_THROW(ERR_BAD_COMBINATION) opVex(x, 0, op, T_0F3A | T_66 | T_W1 | T_EVEX | T_EW1 | T_N8, 0x16, imm); }
-void vpextrw(const Operand& op, const Xmm& x, uint8_t imm) { if (!((op.isREG(16|i32e) || op.isMEM()) && x.isXMM())) XBYAK_THROW(ERR_BAD_COMBINATION) if (op.isREG() && x.getIdx() < 16) { opAVX_X_X_XM(Xmm(op.getIdx()), xm0, x, T_0F | T_66, 0xC5, imm); } else { opVex(x, 0, op, T_0F3A | T_66 | T_EVEX | T_N2, 0x15, imm); } }
-void vpgatherdd(const Xmm& x1, const Address& addr, const Xmm& x2) { opGather(x1, addr, x2, T_0F38 | T_66 | T_YMM | T_VSIB | T_W0, 0x90, 1); }
-void vpgatherdq(const Xmm& x1, const Address& addr, const Xmm& x2) { opGather(x1, addr, x2, T_0F38 | T_66 | T_YMM | T_VSIB | T_W1, 0x90, 0); }
-void vpgatherqd(const Xmm& x1, const Address& addr, const Xmm& x2) { opGather(x1, addr, x2, T_0F38 | T_66 | T_YMM | T_VSIB | T_W0, 0x91, 2); }
-void vpgatherqq(const Xmm& x1, const Address& addr, const Xmm& x2) { opGather(x1, addr, x2, T_0F38 | T_66 | T_YMM | T_VSIB | T_W1, 0x91, 1); }
+void vpdpbssd(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_F2 | T_0F38 | T_W0 | T_YMM, 0x50);
+}
+void vpdpbssds(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_F2 | T_0F38 | T_W0 | T_YMM, 0x51);
+}
+void vpdpbsud(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_F3 | T_0F38 | T_W0 | T_YMM, 0x50);
+}
+void vpdpbsuds(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_F3 | T_0F38 | T_W0 | T_YMM, 0x51);
+}
+void vpdpbusd(const Xmm& x1, const Xmm& x2, const Operand& op, PreferredEncoding encoding = DefaultEncoding) {
+  opEncoding(x1, x2, op, T_66 | T_0F38 | T_EW0 | T_YMM | T_SAE_Z | T_B32, 0x50, encoding);
+}
+void vpdpbusds(const Xmm& x1, const Xmm& x2, const Operand& op, PreferredEncoding encoding = DefaultEncoding) {
+  opEncoding(x1, x2, op, T_66 | T_0F38 | T_EW0 | T_YMM | T_SAE_Z | T_B32, 0x51, encoding);
+}
+void vpdpbuud(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_0F38 | T_W0 | T_YMM, 0x50);
+}
+void vpdpbuuds(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_0F38 | T_W0 | T_YMM, 0x51);
+}
+void vpdpwssd(const Xmm& x1, const Xmm& x2, const Operand& op, PreferredEncoding encoding = DefaultEncoding) {
+  opEncoding(x1, x2, op, T_66 | T_0F38 | T_EW0 | T_YMM | T_SAE_Z | T_B32, 0x52, encoding);
+}
+void vpdpwssds(const Xmm& x1, const Xmm& x2, const Operand& op, PreferredEncoding encoding = DefaultEncoding) {
+  opEncoding(x1, x2, op, T_66 | T_0F38 | T_EW0 | T_YMM | T_SAE_Z | T_B32, 0x53, encoding);
+}
+void vpdpwsud(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_F3 | T_0F38 | T_W0 | T_YMM, 0xD2);
+}
+void vpdpwsuds(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_F3 | T_0F38 | T_W0 | T_YMM, 0xD3);
+}
+void vpdpwusd(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_W0 | T_YMM, 0xD2);
+}
+void vpdpwusds(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_W0 | T_YMM, 0xD3);
+}
+void vpdpwuud(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_0F38 | T_W0 | T_YMM, 0xD2);
+}
+void vpdpwuuds(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_0F38 | T_W0 | T_YMM, 0xD3);
+}
+void vperm2f128(const Ymm& y1, const Ymm& y2, const Operand& op, uint8_t imm) {
+  if (!(y1.isYMM() && y2.isYMM() && op.isYMEM()))
+    XBYAK_THROW(ERR_BAD_COMBINATION) opVex(y1, &y2, op, T_0F3A | T_66 | T_W0 | T_YMM, 0x06, imm);
+}
+void vperm2i128(const Ymm& y1, const Ymm& y2, const Operand& op, uint8_t imm) {
+  if (!(y1.isYMM() && y2.isYMM() && op.isYMEM()))
+    XBYAK_THROW(ERR_BAD_COMBINATION) opVex(y1, &y2, op, T_0F3A | T_66 | T_W0 | T_YMM, 0x46, imm);
+}
+void vpermd(const Ymm& y1, const Ymm& y2, const Operand& op) {
+  opAVX_X_X_XM(y1, y2, op, T_66 | T_0F38 | T_W0 | T_EW0 | T_YMM | T_EVEX | T_B32, 0x36);
+}
+void vpermilpd(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_W0 | T_EW1 | T_YMM | T_EVEX | T_B64, 0x0D);
+}
+void vpermilpd(const Xmm& xm, const Operand& op, uint8_t imm) {
+  opAVX_X_XM_IMM(xm, op, T_66 | T_0F3A | T_EW1 | T_YMM | T_EVEX | T_B64, 0x05, imm);
+}
+void vpermilps(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_W0 | T_EW0 | T_YMM | T_EVEX | T_B32, 0x0C);
+}
+void vpermilps(const Xmm& xm, const Operand& op, uint8_t imm) {
+  opAVX_X_XM_IMM(xm, op, T_66 | T_0F3A | T_EW0 | T_YMM | T_EVEX | T_B32, 0x04, imm);
+}
+void vpermpd(const Ymm& y, const Operand& op, uint8_t imm) {
+  opAVX_X_XM_IMM(y, op, T_66 | T_0F3A | T_W1 | T_EW1 | T_YMM | T_EVEX | T_B64, 0x01, imm);
+}
+void vpermpd(const Ymm& y1, const Ymm& y2, const Operand& op) {
+  opAVX_X_X_XM(y1, y2, op, T_66 | T_0F38 | T_EW1 | T_YMM | T_MUST_EVEX | T_B64, 0x16);
+}
+void vpermps(const Ymm& y1, const Ymm& y2, const Operand& op) {
+  opAVX_X_X_XM(y1, y2, op, T_66 | T_0F38 | T_W0 | T_EW0 | T_YMM | T_EVEX | T_B32, 0x16);
+}
+void vpermq(const Ymm& y, const Operand& op, uint8_t imm) {
+  opAVX_X_XM_IMM(y, op, T_66 | T_0F3A | T_W1 | T_EW1 | T_YMM | T_EVEX | T_B64, 0x00, imm);
+}
+void vpermq(const Ymm& y1, const Ymm& y2, const Operand& op) {
+  opAVX_X_X_XM(y1, y2, op, T_66 | T_0F38 | T_W0 | T_EW1 | T_YMM | T_EVEX | T_B64, 0x36);
+}
+void vpextrb(const Operand& op, const Xmm& x, uint8_t imm) {
+  if (!((op.isREG(8 | 16 | i32e) || op.isMEM()) && x.isXMM()))
+    XBYAK_THROW(ERR_BAD_COMBINATION) opVex(x, 0, op, T_0F3A | T_66 | T_EVEX | T_N1, 0x14, imm);
+}
+void vpextrd(const Operand& op, const Xmm& x, uint8_t imm) {
+  if (!((op.isREG(32) || op.isMEM()) && x.isXMM()))
+    XBYAK_THROW(ERR_BAD_COMBINATION) opVex(x, 0, op, T_0F3A | T_66 | T_W0 | T_EVEX | T_EW0 | T_N4, 0x16, imm);
+}
+void vpextrq(const Operand& op, const Xmm& x, uint8_t imm) {
+  if (!((op.isREG(64) || op.isMEM()) && x.isXMM()))
+    XBYAK_THROW(ERR_BAD_COMBINATION) opVex(x, 0, op, T_0F3A | T_66 | T_W1 | T_EVEX | T_EW1 | T_N8, 0x16, imm);
+}
+void vpextrw(const Operand& op, const Xmm& x, uint8_t imm) {
+  if (!((op.isREG(16 | i32e) || op.isMEM()) && x.isXMM()))
+    XBYAK_THROW(ERR_BAD_COMBINATION) if (op.isREG() && x.getIdx() < 16) {
+      opAVX_X_X_XM(Xmm(op.getIdx()), xm0, x, T_0F | T_66, 0xC5, imm);
+    }
+  else {
+    opVex(x, 0, op, T_0F3A | T_66 | T_EVEX | T_N2, 0x15, imm);
+  }
+}
+void vpgatherdd(const Xmm& x1, const Address& addr, const Xmm& x2) {
+  opGather(x1, addr, x2, T_0F38 | T_66 | T_YMM | T_VSIB | T_W0, 0x90, 1);
+}
+void vpgatherdq(const Xmm& x1, const Address& addr, const Xmm& x2) {
+  opGather(x1, addr, x2, T_0F38 | T_66 | T_YMM | T_VSIB | T_W1, 0x90, 0);
+}
+void vpgatherqd(const Xmm& x1, const Address& addr, const Xmm& x2) {
+  opGather(x1, addr, x2, T_0F38 | T_66 | T_YMM | T_VSIB | T_W0, 0x91, 2);
+}
+void vpgatherqq(const Xmm& x1, const Address& addr, const Xmm& x2) {
+  opGather(x1, addr, x2, T_0F38 | T_66 | T_YMM | T_VSIB | T_W1, 0x91, 1);
+}
 void vphaddd(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_YMM, 0x02); }
-void vphaddsw(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_YMM, 0x03); }
+void vphaddsw(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_YMM, 0x03);
+}
 void vphaddw(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_YMM, 0x01); }
 void vphminposuw(const Xmm& xm, const Operand& op) { opAVX_X_XM_IMM(xm, op, T_66 | T_0F38, 0x41); }
 void vphsubd(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_YMM, 0x06); }
-void vphsubsw(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_YMM, 0x07); }
+void vphsubsw(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_YMM, 0x07);
+}
 void vphsubw(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_YMM, 0x05); }
-void vpinsrb(const Xmm& x1, const Xmm& x2, const Operand& op, uint8_t imm) { if (!(x1.isXMM() && x2.isXMM() && (op.isREG(32) || op.isMEM()))) XBYAK_THROW(ERR_BAD_COMBINATION) opVex(x1, &x2, op, T_0F3A | T_66 | T_EVEX | T_N1, 0x20, imm); }
-void vpinsrd(const Xmm& x1, const Xmm& x2, const Operand& op, uint8_t imm) { if (!(x1.isXMM() && x2.isXMM() && (op.isREG(32) || op.isMEM()))) XBYAK_THROW(ERR_BAD_COMBINATION) opVex(x1, &x2, op, T_0F3A | T_66 | T_W0 | T_EVEX | T_EW0 | T_N4, 0x22, imm); }
-void vpinsrq(const Xmm& x1, const Xmm& x2, const Operand& op, uint8_t imm) { if (!(x1.isXMM() && x2.isXMM() && (op.isREG(64) || op.isMEM()))) XBYAK_THROW(ERR_BAD_COMBINATION) opVex(x1, &x2, op, T_0F3A | T_66 | T_W1 | T_EVEX | T_EW1 | T_N8, 0x22, imm); }
-void vpinsrw(const Xmm& x1, const Xmm& x2, const Operand& op, uint8_t imm) { if (!(x1.isXMM() && x2.isXMM() && (op.isREG(32) || op.isMEM()))) XBYAK_THROW(ERR_BAD_COMBINATION) opVex(x1, &x2, op, T_0F | T_66 | T_EVEX | T_N2, 0xC4, imm); }
-void vpmadd52huq(const Xmm& x1, const Xmm& x2, const Operand& op, PreferredEncoding encoding = DefaultEncoding) { opEncoding(x1, x2, op, T_66 | T_0F38 | T_EW1 | T_YMM | T_B64, 0xB5, encoding); }
-void vpmadd52luq(const Xmm& x1, const Xmm& x2, const Operand& op, PreferredEncoding encoding = DefaultEncoding) { opEncoding(x1, x2, op, T_66 | T_0F38 | T_EW1 | T_YMM | T_B64, 0xB4, encoding); }
-void vpmaddubsw(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_YMM | T_EVEX, 0x04); }
-void vpmaddwd(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F | T_YMM | T_EVEX, 0xF5); }
-void vpmaskmovd(const Address& addr, const Xmm& x1, const Xmm& x2) { opAVX_X_X_XM(x2, x1, addr, T_0F38 | T_66 | T_W0 | T_YMM, 0x8E); }
-void vpmaskmovd(const Xmm& x1, const Xmm& x2, const Address& addr) { opAVX_X_X_XM(x1, x2, addr, T_0F38 | T_66 | T_W0 | T_YMM, 0x8C); }
-void vpmaskmovq(const Address& addr, const Xmm& x1, const Xmm& x2) { opAVX_X_X_XM(x2, x1, addr, T_0F38 | T_66 | T_W1 | T_YMM, 0x8E); }
-void vpmaskmovq(const Xmm& x1, const Xmm& x2, const Address& addr) { opAVX_X_X_XM(x1, x2, addr, T_0F38 | T_66 | T_W1 | T_YMM, 0x8C); }
-void vpmaxsb(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_YMM | T_EVEX, 0x3C); }
-void vpmaxsd(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_EW0 | T_YMM | T_EVEX | T_B32, 0x3D); }
-void vpmaxsw(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F | T_YMM | T_EVEX, 0xEE); }
-void vpmaxub(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F | T_YMM | T_EVEX, 0xDE); }
-void vpmaxud(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_EW0 | T_YMM | T_EVEX | T_B32, 0x3F); }
-void vpmaxuw(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_YMM | T_EVEX, 0x3E); }
-void vpminsb(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_YMM | T_EVEX, 0x38); }
-void vpminsd(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_EW0 | T_YMM | T_EVEX | T_B32, 0x39); }
-void vpminsw(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F | T_YMM | T_EVEX, 0xEA); }
-void vpminub(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F | T_YMM | T_EVEX, 0xDA); }
-void vpminud(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_EW0 | T_YMM | T_EVEX | T_B32, 0x3B); }
-void vpminuw(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_YMM | T_EVEX, 0x3A); }
-void vpmovmskb(const Reg32e& r, const Xmm& x) { if (!x.is(Operand::XMM | Operand::YMM)) XBYAK_THROW(ERR_BAD_COMBINATION) opVex(x.isYMM() ? Ymm(r.getIdx()) : Xmm(r.getIdx()), 0, x, T_0F | T_66 | T_YMM, 0xD7); }
-void vpmovsxbd(const Xmm& xm, const Operand& op) { opAVX_X_XM_IMM(xm, op, T_N4 | T_N_VL | T_66 | T_0F38 | T_YMM | T_EVEX, 0x21); }
-void vpmovsxbq(const Xmm& xm, const Operand& op) { opAVX_X_XM_IMM(xm, op, T_N2 | T_N_VL | T_66 | T_0F38 | T_YMM | T_EVEX, 0x22); }
-void vpmovsxbw(const Xmm& xm, const Operand& op) { opAVX_X_XM_IMM(xm, op, T_N8 | T_N_VL | T_66 | T_0F38 | T_YMM | T_EVEX, 0x20); }
-void vpmovsxdq(const Xmm& xm, const Operand& op) { opAVX_X_XM_IMM(xm, op, T_N8 | T_N_VL | T_66 | T_0F38 | T_EW0 | T_YMM | T_EVEX, 0x25); }
-void vpmovsxwd(const Xmm& xm, const Operand& op) { opAVX_X_XM_IMM(xm, op, T_N8 | T_N_VL | T_66 | T_0F38 | T_YMM | T_EVEX, 0x23); }
-void vpmovsxwq(const Xmm& xm, const Operand& op) { opAVX_X_XM_IMM(xm, op, T_N4 | T_N_VL | T_66 | T_0F38 | T_YMM | T_EVEX, 0x24); }
-void vpmovzxbd(const Xmm& xm, const Operand& op) { opAVX_X_XM_IMM(xm, op, T_N4 | T_N_VL | T_66 | T_0F38 | T_YMM | T_EVEX, 0x31); }
-void vpmovzxbq(const Xmm& xm, const Operand& op) { opAVX_X_XM_IMM(xm, op, T_N2 | T_N_VL | T_66 | T_0F38 | T_YMM | T_EVEX, 0x32); }
-void vpmovzxbw(const Xmm& xm, const Operand& op) { opAVX_X_XM_IMM(xm, op, T_N8 | T_N_VL | T_66 | T_0F38 | T_YMM | T_EVEX, 0x30); }
-void vpmovzxdq(const Xmm& xm, const Operand& op) { opAVX_X_XM_IMM(xm, op, T_N8 | T_N_VL | T_66 | T_0F38 | T_EW0 | T_YMM | T_EVEX, 0x35); }
-void vpmovzxwd(const Xmm& xm, const Operand& op) { opAVX_X_XM_IMM(xm, op, T_N8 | T_N_VL | T_66 | T_0F38 | T_YMM | T_EVEX, 0x33); }
-void vpmovzxwq(const Xmm& xm, const Operand& op) { opAVX_X_XM_IMM(xm, op, T_N4 | T_N_VL | T_66 | T_0F38 | T_YMM | T_EVEX, 0x34); }
-void vpmuldq(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_EW1 | T_YMM | T_EVEX | T_B64, 0x28); }
-void vpmulhrsw(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_YMM | T_EVEX, 0x0B); }
-void vpmulhuw(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F | T_YMM | T_EVEX, 0xE4); }
-void vpmulhw(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F | T_YMM | T_EVEX, 0xE5); }
-void vpmulld(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_EW0 | T_YMM | T_EVEX | T_B32, 0x40); }
-void vpmullw(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F | T_YMM | T_EVEX, 0xD5); }
-void vpmuludq(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F | T_EW1 | T_YMM | T_EVEX | T_B64, 0xF4); }
+void vpinsrb(const Xmm& x1, const Xmm& x2, const Operand& op, uint8_t imm) {
+  if (!(x1.isXMM() && x2.isXMM() && (op.isREG(32) || op.isMEM())))
+    XBYAK_THROW(ERR_BAD_COMBINATION) opVex(x1, &x2, op, T_0F3A | T_66 | T_EVEX | T_N1, 0x20, imm);
+}
+void vpinsrd(const Xmm& x1, const Xmm& x2, const Operand& op, uint8_t imm) {
+  if (!(x1.isXMM() && x2.isXMM() && (op.isREG(32) || op.isMEM())))
+    XBYAK_THROW(ERR_BAD_COMBINATION) opVex(x1, &x2, op, T_0F3A | T_66 | T_W0 | T_EVEX | T_EW0 | T_N4, 0x22, imm);
+}
+void vpinsrq(const Xmm& x1, const Xmm& x2, const Operand& op, uint8_t imm) {
+  if (!(x1.isXMM() && x2.isXMM() && (op.isREG(64) || op.isMEM())))
+    XBYAK_THROW(ERR_BAD_COMBINATION) opVex(x1, &x2, op, T_0F3A | T_66 | T_W1 | T_EVEX | T_EW1 | T_N8, 0x22, imm);
+}
+void vpinsrw(const Xmm& x1, const Xmm& x2, const Operand& op, uint8_t imm) {
+  if (!(x1.isXMM() && x2.isXMM() && (op.isREG(32) || op.isMEM())))
+    XBYAK_THROW(ERR_BAD_COMBINATION) opVex(x1, &x2, op, T_0F | T_66 | T_EVEX | T_N2, 0xC4, imm);
+}
+void vpmadd52huq(const Xmm& x1, const Xmm& x2, const Operand& op, PreferredEncoding encoding = DefaultEncoding) {
+  opEncoding(x1, x2, op, T_66 | T_0F38 | T_EW1 | T_YMM | T_B64, 0xB5, encoding);
+}
+void vpmadd52luq(const Xmm& x1, const Xmm& x2, const Operand& op, PreferredEncoding encoding = DefaultEncoding) {
+  opEncoding(x1, x2, op, T_66 | T_0F38 | T_EW1 | T_YMM | T_B64, 0xB4, encoding);
+}
+void vpmaddubsw(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_YMM | T_EVEX, 0x04);
+}
+void vpmaddwd(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F | T_YMM | T_EVEX, 0xF5);
+}
+void vpmaskmovd(const Address& addr, const Xmm& x1, const Xmm& x2) {
+  opAVX_X_X_XM(x2, x1, addr, T_0F38 | T_66 | T_W0 | T_YMM, 0x8E);
+}
+void vpmaskmovd(const Xmm& x1, const Xmm& x2, const Address& addr) {
+  opAVX_X_X_XM(x1, x2, addr, T_0F38 | T_66 | T_W0 | T_YMM, 0x8C);
+}
+void vpmaskmovq(const Address& addr, const Xmm& x1, const Xmm& x2) {
+  opAVX_X_X_XM(x2, x1, addr, T_0F38 | T_66 | T_W1 | T_YMM, 0x8E);
+}
+void vpmaskmovq(const Xmm& x1, const Xmm& x2, const Address& addr) {
+  opAVX_X_X_XM(x1, x2, addr, T_0F38 | T_66 | T_W1 | T_YMM, 0x8C);
+}
+void vpmaxsb(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_YMM | T_EVEX, 0x3C);
+}
+void vpmaxsd(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_EW0 | T_YMM | T_EVEX | T_B32, 0x3D);
+}
+void vpmaxsw(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F | T_YMM | T_EVEX, 0xEE);
+}
+void vpmaxub(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F | T_YMM | T_EVEX, 0xDE);
+}
+void vpmaxud(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_EW0 | T_YMM | T_EVEX | T_B32, 0x3F);
+}
+void vpmaxuw(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_YMM | T_EVEX, 0x3E);
+}
+void vpminsb(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_YMM | T_EVEX, 0x38);
+}
+void vpminsd(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_EW0 | T_YMM | T_EVEX | T_B32, 0x39);
+}
+void vpminsw(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F | T_YMM | T_EVEX, 0xEA);
+}
+void vpminub(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F | T_YMM | T_EVEX, 0xDA);
+}
+void vpminud(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_EW0 | T_YMM | T_EVEX | T_B32, 0x3B);
+}
+void vpminuw(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_YMM | T_EVEX, 0x3A);
+}
+void vpmovmskb(const Reg32e& r, const Xmm& x) {
+  if (!x.is(Operand::XMM | Operand::YMM))
+    XBYAK_THROW(ERR_BAD_COMBINATION)
+    opVex(x.isYMM() ? Ymm(r.getIdx()) : Xmm(r.getIdx()), 0, x, T_0F | T_66 | T_YMM, 0xD7);
+}
+void vpmovsxbd(const Xmm& xm, const Operand& op) {
+  opAVX_X_XM_IMM(xm, op, T_N4 | T_N_VL | T_66 | T_0F38 | T_YMM | T_EVEX, 0x21);
+}
+void vpmovsxbq(const Xmm& xm, const Operand& op) {
+  opAVX_X_XM_IMM(xm, op, T_N2 | T_N_VL | T_66 | T_0F38 | T_YMM | T_EVEX, 0x22);
+}
+void vpmovsxbw(const Xmm& xm, const Operand& op) {
+  opAVX_X_XM_IMM(xm, op, T_N8 | T_N_VL | T_66 | T_0F38 | T_YMM | T_EVEX, 0x20);
+}
+void vpmovsxdq(const Xmm& xm, const Operand& op) {
+  opAVX_X_XM_IMM(xm, op, T_N8 | T_N_VL | T_66 | T_0F38 | T_EW0 | T_YMM | T_EVEX, 0x25);
+}
+void vpmovsxwd(const Xmm& xm, const Operand& op) {
+  opAVX_X_XM_IMM(xm, op, T_N8 | T_N_VL | T_66 | T_0F38 | T_YMM | T_EVEX, 0x23);
+}
+void vpmovsxwq(const Xmm& xm, const Operand& op) {
+  opAVX_X_XM_IMM(xm, op, T_N4 | T_N_VL | T_66 | T_0F38 | T_YMM | T_EVEX, 0x24);
+}
+void vpmovzxbd(const Xmm& xm, const Operand& op) {
+  opAVX_X_XM_IMM(xm, op, T_N4 | T_N_VL | T_66 | T_0F38 | T_YMM | T_EVEX, 0x31);
+}
+void vpmovzxbq(const Xmm& xm, const Operand& op) {
+  opAVX_X_XM_IMM(xm, op, T_N2 | T_N_VL | T_66 | T_0F38 | T_YMM | T_EVEX, 0x32);
+}
+void vpmovzxbw(const Xmm& xm, const Operand& op) {
+  opAVX_X_XM_IMM(xm, op, T_N8 | T_N_VL | T_66 | T_0F38 | T_YMM | T_EVEX, 0x30);
+}
+void vpmovzxdq(const Xmm& xm, const Operand& op) {
+  opAVX_X_XM_IMM(xm, op, T_N8 | T_N_VL | T_66 | T_0F38 | T_EW0 | T_YMM | T_EVEX, 0x35);
+}
+void vpmovzxwd(const Xmm& xm, const Operand& op) {
+  opAVX_X_XM_IMM(xm, op, T_N8 | T_N_VL | T_66 | T_0F38 | T_YMM | T_EVEX, 0x33);
+}
+void vpmovzxwq(const Xmm& xm, const Operand& op) {
+  opAVX_X_XM_IMM(xm, op, T_N4 | T_N_VL | T_66 | T_0F38 | T_YMM | T_EVEX, 0x34);
+}
+void vpmuldq(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_EW1 | T_YMM | T_EVEX | T_B64, 0x28);
+}
+void vpmulhrsw(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_YMM | T_EVEX, 0x0B);
+}
+void vpmulhuw(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F | T_YMM | T_EVEX, 0xE4);
+}
+void vpmulhw(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F | T_YMM | T_EVEX, 0xE5);
+}
+void vpmulld(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_EW0 | T_YMM | T_EVEX | T_B32, 0x40);
+}
+void vpmullw(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F | T_YMM | T_EVEX, 0xD5);
+}
+void vpmuludq(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F | T_EW1 | T_YMM | T_EVEX | T_B64, 0xF4);
+}
 void vpor(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F | T_YMM, 0xEB); }
-void vpsadbw(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F | T_YMM | T_EVEX, 0xF6); }
-void vpshufb(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_YMM | T_EVEX, 0x00); }
-void vpshufd(const Xmm& xm, const Operand& op, uint8_t imm) { opAVX_X_XM_IMM(xm, op, T_66 | T_0F | T_EW0 | T_YMM | T_EVEX | T_B32, 0x70, imm); }
-void vpshufhw(const Xmm& xm, const Operand& op, uint8_t imm) { opAVX_X_XM_IMM(xm, op, T_F3 | T_0F | T_YMM | T_EVEX, 0x70, imm); }
-void vpshuflw(const Xmm& xm, const Operand& op, uint8_t imm) { opAVX_X_XM_IMM(xm, op, T_F2 | T_0F | T_YMM | T_EVEX, 0x70, imm); }
+void vpsadbw(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F | T_YMM | T_EVEX, 0xF6);
+}
+void vpshufb(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_YMM | T_EVEX, 0x00);
+}
+void vpshufd(const Xmm& xm, const Operand& op, uint8_t imm) {
+  opAVX_X_XM_IMM(xm, op, T_66 | T_0F | T_EW0 | T_YMM | T_EVEX | T_B32, 0x70, imm);
+}
+void vpshufhw(const Xmm& xm, const Operand& op, uint8_t imm) {
+  opAVX_X_XM_IMM(xm, op, T_F3 | T_0F | T_YMM | T_EVEX, 0x70, imm);
+}
+void vpshuflw(const Xmm& xm, const Operand& op, uint8_t imm) {
+  opAVX_X_XM_IMM(xm, op, T_F2 | T_0F | T_YMM | T_EVEX, 0x70, imm);
+}
 void vpsignb(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_YMM, 0x08); }
 void vpsignd(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_YMM, 0x0A); }
 void vpsignw(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_YMM, 0x09); }
-void vpslld(const Xmm& x, const Operand& op, uint8_t imm) { opAVX_X_X_XM(Xmm(x.getKind(), 6), x, op, T_66 | T_0F | T_EW0 | T_YMM | T_EVEX | T_B32 | T_MEM_EVEX, 0x72, imm); }
-void vpslld(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_N16 | T_66 | T_0F | T_EW0 | T_YMM | T_EVEX, 0xF2); }
-void vpslldq(const Xmm& x, const Operand& op, uint8_t imm) { opAVX_X_X_XM(Xmm(x.getKind(), 7), x, op, T_66 | T_0F | T_YMM | T_EVEX | T_MEM_EVEX, 0x73, imm); }
-void vpsllq(const Xmm& x, const Operand& op, uint8_t imm) { opAVX_X_X_XM(Xmm(x.getKind(), 6), x, op, T_66 | T_0F | T_EW1 | T_YMM | T_EVEX | T_B64 | T_MEM_EVEX, 0x73, imm); }
-void vpsllq(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_N16 | T_66 | T_0F | T_EW1 | T_YMM | T_EVEX, 0xF3); }
-void vpsllvd(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_W0 | T_EW0 | T_YMM | T_EVEX | T_B32, 0x47); }
-void vpsllvq(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_W1 | T_EW1 | T_YMM | T_EVEX | T_B64, 0x47); }
-void vpsllw(const Xmm& x, const Operand& op, uint8_t imm) { opAVX_X_X_XM(Xmm(x.getKind(), 6), x, op, T_66 | T_0F | T_YMM | T_EVEX | T_MEM_EVEX, 0x71, imm); }
-void vpsllw(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_N16 | T_66 | T_0F | T_YMM | T_EVEX, 0xF1); }
-void vpsrad(const Xmm& x, const Operand& op, uint8_t imm) { opAVX_X_X_XM(Xmm(x.getKind(), 4), x, op, T_66 | T_0F | T_EW0 | T_YMM | T_EVEX | T_B32 | T_MEM_EVEX, 0x72, imm); }
-void vpsrad(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_N16 | T_66 | T_0F | T_EW0 | T_YMM | T_EVEX, 0xE2); }
-void vpsravd(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_W0 | T_EW0 | T_YMM | T_EVEX | T_B32, 0x46); }
-void vpsraw(const Xmm& x, const Operand& op, uint8_t imm) { opAVX_X_X_XM(Xmm(x.getKind(), 4), x, op, T_66 | T_0F | T_YMM | T_EVEX | T_MEM_EVEX, 0x71, imm); }
-void vpsraw(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_N16 | T_66 | T_0F | T_YMM | T_EVEX, 0xE1); }
-void vpsrld(const Xmm& x, const Operand& op, uint8_t imm) { opAVX_X_X_XM(Xmm(x.getKind(), 2), x, op, T_66 | T_0F | T_EW0 | T_YMM | T_EVEX | T_B32 | T_MEM_EVEX, 0x72, imm); }
-void vpsrld(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_N16 | T_66 | T_0F | T_EW0 | T_YMM | T_EVEX, 0xD2); }
-void vpsrldq(const Xmm& x, const Operand& op, uint8_t imm) { opAVX_X_X_XM(Xmm(x.getKind(), 3), x, op, T_66 | T_0F | T_YMM | T_EVEX | T_MEM_EVEX, 0x73, imm); }
-void vpsrlq(const Xmm& x, const Operand& op, uint8_t imm) { opAVX_X_X_XM(Xmm(x.getKind(), 2), x, op, T_66 | T_0F | T_EW1 | T_YMM | T_EVEX | T_B64 | T_MEM_EVEX, 0x73, imm); }
-void vpsrlq(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_N16 | T_66 | T_0F | T_EW1 | T_YMM | T_EVEX, 0xD3); }
-void vpsrlvd(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_W0 | T_EW0 | T_YMM | T_EVEX | T_B32, 0x45); }
-void vpsrlvq(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_W1 | T_EW1 | T_YMM | T_EVEX | T_B64, 0x45); }
-void vpsrlw(const Xmm& x, const Operand& op, uint8_t imm) { opAVX_X_X_XM(Xmm(x.getKind(), 2), x, op, T_66 | T_0F | T_YMM | T_EVEX | T_MEM_EVEX, 0x71, imm); }
-void vpsrlw(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_N16 | T_66 | T_0F | T_YMM | T_EVEX, 0xD1); }
-void vpsubb(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F | T_YMM | T_EVEX, 0xF8); }
-void vpsubd(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F | T_EW0 | T_YMM | T_EVEX | T_B32, 0xFA); }
-void vpsubq(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F | T_EW1 | T_YMM | T_EVEX | T_B64, 0xFB); }
-void vpsubsb(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F | T_YMM | T_EVEX, 0xE8); }
-void vpsubsw(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F | T_YMM | T_EVEX, 0xE9); }
-void vpsubusb(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F | T_YMM | T_EVEX, 0xD8); }
-void vpsubusw(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F | T_YMM | T_EVEX, 0xD9); }
-void vpsubw(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F | T_YMM | T_EVEX, 0xF9); }
+void vpslld(const Xmm& x, const Operand& op, uint8_t imm) {
+  opAVX_X_X_XM(Xmm(x.getKind(), 6), x, op, T_66 | T_0F | T_EW0 | T_YMM | T_EVEX | T_B32 | T_MEM_EVEX, 0x72, imm);
+}
+void vpslld(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_N16 | T_66 | T_0F | T_EW0 | T_YMM | T_EVEX, 0xF2);
+}
+void vpslldq(const Xmm& x, const Operand& op, uint8_t imm) {
+  opAVX_X_X_XM(Xmm(x.getKind(), 7), x, op, T_66 | T_0F | T_YMM | T_EVEX | T_MEM_EVEX, 0x73, imm);
+}
+void vpsllq(const Xmm& x, const Operand& op, uint8_t imm) {
+  opAVX_X_X_XM(Xmm(x.getKind(), 6), x, op, T_66 | T_0F | T_EW1 | T_YMM | T_EVEX | T_B64 | T_MEM_EVEX, 0x73, imm);
+}
+void vpsllq(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_N16 | T_66 | T_0F | T_EW1 | T_YMM | T_EVEX, 0xF3);
+}
+void vpsllvd(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_W0 | T_EW0 | T_YMM | T_EVEX | T_B32, 0x47);
+}
+void vpsllvq(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_W1 | T_EW1 | T_YMM | T_EVEX | T_B64, 0x47);
+}
+void vpsllw(const Xmm& x, const Operand& op, uint8_t imm) {
+  opAVX_X_X_XM(Xmm(x.getKind(), 6), x, op, T_66 | T_0F | T_YMM | T_EVEX | T_MEM_EVEX, 0x71, imm);
+}
+void vpsllw(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_N16 | T_66 | T_0F | T_YMM | T_EVEX, 0xF1);
+}
+void vpsrad(const Xmm& x, const Operand& op, uint8_t imm) {
+  opAVX_X_X_XM(Xmm(x.getKind(), 4), x, op, T_66 | T_0F | T_EW0 | T_YMM | T_EVEX | T_B32 | T_MEM_EVEX, 0x72, imm);
+}
+void vpsrad(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_N16 | T_66 | T_0F | T_EW0 | T_YMM | T_EVEX, 0xE2);
+}
+void vpsravd(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_W0 | T_EW0 | T_YMM | T_EVEX | T_B32, 0x46);
+}
+void vpsraw(const Xmm& x, const Operand& op, uint8_t imm) {
+  opAVX_X_X_XM(Xmm(x.getKind(), 4), x, op, T_66 | T_0F | T_YMM | T_EVEX | T_MEM_EVEX, 0x71, imm);
+}
+void vpsraw(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_N16 | T_66 | T_0F | T_YMM | T_EVEX, 0xE1);
+}
+void vpsrld(const Xmm& x, const Operand& op, uint8_t imm) {
+  opAVX_X_X_XM(Xmm(x.getKind(), 2), x, op, T_66 | T_0F | T_EW0 | T_YMM | T_EVEX | T_B32 | T_MEM_EVEX, 0x72, imm);
+}
+void vpsrld(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_N16 | T_66 | T_0F | T_EW0 | T_YMM | T_EVEX, 0xD2);
+}
+void vpsrldq(const Xmm& x, const Operand& op, uint8_t imm) {
+  opAVX_X_X_XM(Xmm(x.getKind(), 3), x, op, T_66 | T_0F | T_YMM | T_EVEX | T_MEM_EVEX, 0x73, imm);
+}
+void vpsrlq(const Xmm& x, const Operand& op, uint8_t imm) {
+  opAVX_X_X_XM(Xmm(x.getKind(), 2), x, op, T_66 | T_0F | T_EW1 | T_YMM | T_EVEX | T_B64 | T_MEM_EVEX, 0x73, imm);
+}
+void vpsrlq(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_N16 | T_66 | T_0F | T_EW1 | T_YMM | T_EVEX, 0xD3);
+}
+void vpsrlvd(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_W0 | T_EW0 | T_YMM | T_EVEX | T_B32, 0x45);
+}
+void vpsrlvq(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_W1 | T_EW1 | T_YMM | T_EVEX | T_B64, 0x45);
+}
+void vpsrlw(const Xmm& x, const Operand& op, uint8_t imm) {
+  opAVX_X_X_XM(Xmm(x.getKind(), 2), x, op, T_66 | T_0F | T_YMM | T_EVEX | T_MEM_EVEX, 0x71, imm);
+}
+void vpsrlw(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_N16 | T_66 | T_0F | T_YMM | T_EVEX, 0xD1);
+}
+void vpsubb(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F | T_YMM | T_EVEX, 0xF8);
+}
+void vpsubd(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F | T_EW0 | T_YMM | T_EVEX | T_B32, 0xFA);
+}
+void vpsubq(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F | T_EW1 | T_YMM | T_EVEX | T_B64, 0xFB);
+}
+void vpsubsb(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F | T_YMM | T_EVEX, 0xE8);
+}
+void vpsubsw(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F | T_YMM | T_EVEX, 0xE9);
+}
+void vpsubusb(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F | T_YMM | T_EVEX, 0xD8);
+}
+void vpsubusw(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F | T_YMM | T_EVEX, 0xD9);
+}
+void vpsubw(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F | T_YMM | T_EVEX, 0xF9);
+}
 void vptest(const Xmm& xm, const Operand& op) { opAVX_X_XM_IMM(xm, op, T_66 | T_0F38 | T_YMM, 0x17); }
-void vpunpckhbw(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F | T_YMM | T_EVEX, 0x68); }
-void vpunpckhdq(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F | T_EW0 | T_YMM | T_EVEX | T_B32, 0x6A); }
-void vpunpckhqdq(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F | T_EW1 | T_YMM | T_EVEX | T_B64, 0x6D); }
-void vpunpckhwd(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F | T_YMM | T_EVEX, 0x69); }
-void vpunpcklbw(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F | T_YMM | T_EVEX, 0x60); }
-void vpunpckldq(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F | T_EW0 | T_YMM | T_EVEX | T_B32, 0x62); }
-void vpunpcklqdq(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F | T_EW1 | T_YMM | T_EVEX | T_B64, 0x6C); }
-void vpunpcklwd(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F | T_YMM | T_EVEX, 0x61); }
+void vpunpckhbw(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F | T_YMM | T_EVEX, 0x68);
+}
+void vpunpckhdq(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F | T_EW0 | T_YMM | T_EVEX | T_B32, 0x6A);
+}
+void vpunpckhqdq(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F | T_EW1 | T_YMM | T_EVEX | T_B64, 0x6D);
+}
+void vpunpckhwd(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F | T_YMM | T_EVEX, 0x69);
+}
+void vpunpcklbw(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F | T_YMM | T_EVEX, 0x60);
+}
+void vpunpckldq(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F | T_EW0 | T_YMM | T_EVEX | T_B32, 0x62);
+}
+void vpunpcklqdq(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F | T_EW1 | T_YMM | T_EVEX | T_B64, 0x6C);
+}
+void vpunpcklwd(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F | T_YMM | T_EVEX, 0x61);
+}
 void vpxor(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F | T_YMM, 0xEF); }
 void vrcpps(const Xmm& xm, const Operand& op) { opAVX_X_XM_IMM(xm, op, T_0F | T_YMM, 0x53); }
 void vrcpss(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_F3 | T_0F, 0x53); }
-void vroundpd(const Xmm& xm, const Operand& op, uint8_t imm) { opAVX_X_XM_IMM(xm, op, T_66 | T_0F3A | T_YMM, 0x09, imm); }
-void vroundps(const Xmm& xm, const Operand& op, uint8_t imm) { opAVX_X_XM_IMM(xm, op, T_66 | T_0F3A | T_YMM, 0x08, imm); }
-void vroundsd(const Xmm& x1, const Xmm& x2, const Operand& op, uint8_t imm) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F3A | T_W0, 0x0B, imm); }
-void vroundss(const Xmm& x1, const Xmm& x2, const Operand& op, uint8_t imm) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F3A | T_W0, 0x0A, imm); }
+void vroundpd(const Xmm& xm, const Operand& op, uint8_t imm) {
+  opAVX_X_XM_IMM(xm, op, T_66 | T_0F3A | T_YMM, 0x09, imm);
+}
+void vroundps(const Xmm& xm, const Operand& op, uint8_t imm) {
+  opAVX_X_XM_IMM(xm, op, T_66 | T_0F3A | T_YMM, 0x08, imm);
+}
+void vroundsd(const Xmm& x1, const Xmm& x2, const Operand& op, uint8_t imm) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F3A | T_W0, 0x0B, imm);
+}
+void vroundss(const Xmm& x1, const Xmm& x2, const Operand& op, uint8_t imm) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F3A | T_W0, 0x0A, imm);
+}
 void vrsqrtps(const Xmm& xm, const Operand& op) { opAVX_X_XM_IMM(xm, op, T_0F | T_YMM, 0x52); }
 void vrsqrtss(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_F3 | T_0F, 0x52); }
-void vsha512msg1(const Ymm& y, const Xmm& x) { if (!(y.isYMM() && x.isXMM())) XBYAK_THROW(ERR_BAD_PARAMETER) opVex(y, 0, x, T_F2 | T_0F38 | T_W0 | T_YMM, 0xCC); }
-void vsha512msg2(const Ymm& y1, const Ymm& y2) { if (!(y1.isYMM() && y2.isYMM())) XBYAK_THROW(ERR_BAD_PARAMETER) opVex(y1, 0, y2, T_F2 | T_0F38 | T_W0 | T_YMM, 0xCD); }
-void vsha512rnds2(const Ymm& y1, const Ymm& y2, const Xmm& x) { if (!(y1.isYMM() && y2.isYMM() && x.isXMM())) XBYAK_THROW(ERR_BAD_PARAMETER) opVex(y1, &y2, x, T_F2 | T_0F38 | T_W0 | T_YMM, 0xCB); }
-void vshufpd(const Xmm& x1, const Xmm& x2, const Operand& op, uint8_t imm) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F | T_EW1 | T_YMM | T_EVEX | T_B64, 0xC6, imm); }
-void vshufps(const Xmm& x1, const Xmm& x2, const Operand& op, uint8_t imm) { opAVX_X_X_XM(x1, x2, op, T_0F | T_EW0 | T_YMM | T_EVEX | T_B32, 0xC6, imm); }
-void vsm3msg1(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_0F38 | T_W0 | T_EW0 | T_EVEX, 0xDA); }
-void vsm3msg2(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_W0 | T_EW0 | T_EVEX, 0xDA); }
-void vsm3rnds2(const Xmm& x1, const Xmm& x2, const Operand& op, uint8_t imm) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F3A | T_W0 | T_EW0 | T_EVEX, 0xDE, imm); }
-void vsm4key4(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_F3 | T_0F38 | T_W0 | T_EW0 | T_EVEX, 0xDA); }
-void vsm4rnds4(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_F2 | T_0F38 | T_W0 | T_EW0 | T_EVEX, 0xDA); }
-void vsqrtpd(const Xmm& xm, const Operand& op) { opAVX_X_XM_IMM(xm, op, T_66 | T_0F | T_EW1 | T_YMM | T_EVEX | T_ER_Z | T_B64, 0x51); }
-void vsqrtps(const Xmm& xm, const Operand& op) { opAVX_X_XM_IMM(xm, op, T_0F | T_EW0 | T_YMM | T_EVEX | T_ER_Z | T_B32, 0x51); }
-void vsqrtsd(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_N8 | T_F2 | T_0F | T_EW1 | T_EVEX | T_ER_X, 0x51); }
-void vsqrtss(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_N4 | T_F3 | T_0F | T_EW0 | T_EVEX | T_ER_X, 0x51); }
+void vsha512msg1(const Ymm& y, const Xmm& x) {
+  if (!(y.isYMM() && x.isXMM())) XBYAK_THROW(ERR_BAD_PARAMETER) opVex(y, 0, x, T_F2 | T_0F38 | T_W0 | T_YMM, 0xCC);
+}
+void vsha512msg2(const Ymm& y1, const Ymm& y2) {
+  if (!(y1.isYMM() && y2.isYMM())) XBYAK_THROW(ERR_BAD_PARAMETER) opVex(y1, 0, y2, T_F2 | T_0F38 | T_W0 | T_YMM, 0xCD);
+}
+void vsha512rnds2(const Ymm& y1, const Ymm& y2, const Xmm& x) {
+  if (!(y1.isYMM() && y2.isYMM() && x.isXMM()))
+    XBYAK_THROW(ERR_BAD_PARAMETER) opVex(y1, &y2, x, T_F2 | T_0F38 | T_W0 | T_YMM, 0xCB);
+}
+void vshufpd(const Xmm& x1, const Xmm& x2, const Operand& op, uint8_t imm) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F | T_EW1 | T_YMM | T_EVEX | T_B64, 0xC6, imm);
+}
+void vshufps(const Xmm& x1, const Xmm& x2, const Operand& op, uint8_t imm) {
+  opAVX_X_X_XM(x1, x2, op, T_0F | T_EW0 | T_YMM | T_EVEX | T_B32, 0xC6, imm);
+}
+void vsm3msg1(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_0F38 | T_W0 | T_EW0 | T_EVEX, 0xDA);
+}
+void vsm3msg2(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_W0 | T_EW0 | T_EVEX, 0xDA);
+}
+void vsm3rnds2(const Xmm& x1, const Xmm& x2, const Operand& op, uint8_t imm) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F3A | T_W0 | T_EW0 | T_EVEX, 0xDE, imm);
+}
+void vsm4key4(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_F3 | T_0F38 | T_W0 | T_EW0 | T_EVEX, 0xDA);
+}
+void vsm4rnds4(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_F2 | T_0F38 | T_W0 | T_EW0 | T_EVEX, 0xDA);
+}
+void vsqrtpd(const Xmm& xm, const Operand& op) {
+  opAVX_X_XM_IMM(xm, op, T_66 | T_0F | T_EW1 | T_YMM | T_EVEX | T_ER_Z | T_B64, 0x51);
+}
+void vsqrtps(const Xmm& xm, const Operand& op) {
+  opAVX_X_XM_IMM(xm, op, T_0F | T_EW0 | T_YMM | T_EVEX | T_ER_Z | T_B32, 0x51);
+}
+void vsqrtsd(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_N8 | T_F2 | T_0F | T_EW1 | T_EVEX | T_ER_X, 0x51);
+}
+void vsqrtss(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_N4 | T_F3 | T_0F | T_EW0 | T_EVEX | T_ER_X, 0x51);
+}
 void vstmxcsr(const Address& addr) { opAVX_X_X_XM(xm3, xm0, addr, T_0F, 0xAE); }
-void vsubpd(const Xmm& xmm, const Operand& op1, const Operand& op2 = Operand()) { opAVX_X_X_XM(xmm, op1, op2, T_0F | T_66 | T_EW1 | T_YMM | T_EVEX | T_ER_Z | T_B64, 0x5C); }
-void vsubps(const Xmm& xmm, const Operand& op1, const Operand& op2 = Operand()) { opAVX_X_X_XM(xmm, op1, op2, T_0F | T_EW0 | T_YMM | T_EVEX | T_ER_Z | T_B32, 0x5C); }
-void vsubsd(const Xmm& xmm, const Operand& op1, const Operand& op2 = Operand()) { opAVX_X_X_XM(xmm, op1, op2, T_0F | T_F2 | T_EW1 | T_EVEX | T_ER_X | T_N8, 0x5C); }
-void vsubss(const Xmm& xmm, const Operand& op1, const Operand& op2 = Operand()) { opAVX_X_X_XM(xmm, op1, op2, T_0F | T_F3 | T_EW0 | T_EVEX | T_ER_X | T_N4, 0x5C); }
+void vsubpd(const Xmm& xmm, const Operand& op1, const Operand& op2 = Operand()) {
+  opAVX_X_X_XM(xmm, op1, op2, T_0F | T_66 | T_EW1 | T_YMM | T_EVEX | T_ER_Z | T_B64, 0x5C);
+}
+void vsubps(const Xmm& xmm, const Operand& op1, const Operand& op2 = Operand()) {
+  opAVX_X_X_XM(xmm, op1, op2, T_0F | T_EW0 | T_YMM | T_EVEX | T_ER_Z | T_B32, 0x5C);
+}
+void vsubsd(const Xmm& xmm, const Operand& op1, const Operand& op2 = Operand()) {
+  opAVX_X_X_XM(xmm, op1, op2, T_0F | T_F2 | T_EW1 | T_EVEX | T_ER_X | T_N8, 0x5C);
+}
+void vsubss(const Xmm& xmm, const Operand& op1, const Operand& op2 = Operand()) {
+  opAVX_X_X_XM(xmm, op1, op2, T_0F | T_F3 | T_EW0 | T_EVEX | T_ER_X | T_N4, 0x5C);
+}
 void vtestpd(const Xmm& xm, const Operand& op) { opAVX_X_XM_IMM(xm, op, T_66 | T_0F38 | T_YMM, 0x0F); }
 void vtestps(const Xmm& xm, const Operand& op) { opAVX_X_XM_IMM(xm, op, T_66 | T_0F38 | T_YMM, 0x0E); }
-void vucomisd(const Xmm& xm, const Operand& op) { opAVX_X_XM_IMM(xm, op, T_N8 | T_66 | T_0F | T_EW1 | T_EVEX | T_SAE_X, 0x2E); }
-void vucomiss(const Xmm& xm, const Operand& op) { opAVX_X_XM_IMM(xm, op, T_N4 | T_0F | T_EW0 | T_EVEX | T_SAE_X, 0x2E); }
-void vunpckhpd(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F | T_EW1 | T_YMM | T_EVEX | T_B64, 0x15); }
-void vunpckhps(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_0F | T_EW0 | T_YMM | T_EVEX | T_B32, 0x15); }
-void vunpcklpd(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F | T_EW1 | T_YMM | T_EVEX | T_B64, 0x14); }
-void vunpcklps(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_0F | T_EW0 | T_YMM | T_EVEX | T_B32, 0x14); }
-void vxorpd(const Xmm& xmm, const Operand& op1, const Operand& op2 = Operand()) { opAVX_X_X_XM(xmm, op1, op2, T_0F | T_66 | T_EW1 | T_YMM | T_EVEX | T_ER_Z | T_B64, 0x57); }
-void vxorps(const Xmm& xmm, const Operand& op1, const Operand& op2 = Operand()) { opAVX_X_X_XM(xmm, op1, op2, T_0F | T_EW0 | T_YMM | T_EVEX | T_ER_Z | T_B32, 0x57); }
-void vzeroall() { db(0xC5); db(0xFC); db(0x77); }
-void vzeroupper() { db(0xC5); db(0xF8); db(0x77); }
+void vucomisd(const Xmm& xm, const Operand& op) {
+  opAVX_X_XM_IMM(xm, op, T_N8 | T_66 | T_0F | T_EW1 | T_EVEX | T_SAE_X, 0x2E);
+}
+void vucomiss(const Xmm& xm, const Operand& op) {
+  opAVX_X_XM_IMM(xm, op, T_N4 | T_0F | T_EW0 | T_EVEX | T_SAE_X, 0x2E);
+}
+void vunpckhpd(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F | T_EW1 | T_YMM | T_EVEX | T_B64, 0x15);
+}
+void vunpckhps(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_0F | T_EW0 | T_YMM | T_EVEX | T_B32, 0x15);
+}
+void vunpcklpd(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F | T_EW1 | T_YMM | T_EVEX | T_B64, 0x14);
+}
+void vunpcklps(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_0F | T_EW0 | T_YMM | T_EVEX | T_B32, 0x14);
+}
+void vxorpd(const Xmm& xmm, const Operand& op1, const Operand& op2 = Operand()) {
+  opAVX_X_X_XM(xmm, op1, op2, T_0F | T_66 | T_EW1 | T_YMM | T_EVEX | T_ER_Z | T_B64, 0x57);
+}
+void vxorps(const Xmm& xmm, const Operand& op1, const Operand& op2 = Operand()) {
+  opAVX_X_X_XM(xmm, op1, op2, T_0F | T_EW0 | T_YMM | T_EVEX | T_ER_Z | T_B32, 0x57);
+}
+void vzeroall() {
+  db(0xC5);
+  db(0xFC);
+  db(0x77);
+}
+void vzeroupper() {
+  db(0xC5);
+  db(0xF8);
+  db(0x77);
+}
 void wait() { db(0x9B); }
-void wbinvd() { db(0x0F); db(0x09); }
-void wrmsr() { db(0x0F); db(0x30); }
-void xabort(uint8_t imm) { db(0xC6); db(0xF8); db(imm); }
-void xadd(const Operand& op, const Reg& reg) { opModRM(reg, op, (op.isREG() && reg.isREG() && op.getBit() == reg.getBit()), op.isMEM(), 0x0F, 0xC0 | (reg.isBit(8) ? 0 : 1)); }
-void xbegin(uint32_t rel) { db(0xC7); db(0xF8); dd(rel); }
-void xend() { db(0x0F); db(0x01); db(0xD5); }
-void xgetbv() { db(0x0F); db(0x01); db(0xD0); }
+void wbinvd() {
+  db(0x0F);
+  db(0x09);
+}
+void wrmsr() {
+  db(0x0F);
+  db(0x30);
+}
+void xabort(uint8_t imm) {
+  db(0xC6);
+  db(0xF8);
+  db(imm);
+}
+void xadd(const Operand& op, const Reg& reg) {
+  opModRM(reg, op, (op.isREG() && reg.isREG() && op.getBit() == reg.getBit()), op.isMEM(), 0x0F,
+          0xC0 | (reg.isBit(8) ? 0 : 1));
+}
+void xbegin(uint32_t rel) {
+  db(0xC7);
+  db(0xF8);
+  dd(rel);
+}
+void xend() {
+  db(0x0F);
+  db(0x01);
+  db(0xD5);
+}
+void xgetbv() {
+  db(0x0F);
+  db(0x01);
+  db(0xD0);
+}
 void xlatb() { db(0xD7); }
 void xor_(const Operand& op, uint32_t imm) { opRM_I(op, imm, 0x30, 6); }
 void xor_(const Operand& op1, const Operand& op2) { opRM_RM(op1, op2, 0x30); }
@@ -1670,76 +3007,208 @@ void vunpcklpd(const Xmm& x, const Operand& op) { vunpcklpd(x, x, op); }
 void vunpcklps(const Xmm& x, const Operand& op) { vunpcklps(x, x, op); }
 #endif
 #ifdef XBYAK64
-void jecxz(std::string label) { db(0x67); opJmp(label, T_SHORT, 0xe3, 0, 0); }
-void jecxz(const Label& label) { db(0x67); opJmp(label, T_SHORT, 0xe3, 0, 0); }
+void jecxz(std::string label) {
+  db(0x67);
+  opJmp(label, T_SHORT, 0xe3, 0, 0);
+}
+void jecxz(const Label& label) {
+  db(0x67);
+  opJmp(label, T_SHORT, 0xe3, 0, 0);
+}
 void jrcxz(std::string label) { opJmp(label, T_SHORT, 0xe3, 0, 0); }
 void jrcxz(const Label& label) { opJmp(label, T_SHORT, 0xe3, 0, 0); }
-void cdqe() { db(0x48); db(0x98); }
-void cqo() { db(0x48); db(0x99); }
-void cmpsq() { db(0x48); db(0xA7); }
+void cdqe() {
+  db(0x48);
+  db(0x98);
+}
+void cqo() {
+  db(0x48);
+  db(0x99);
+}
+void cmpsq() {
+  db(0x48);
+  db(0xA7);
+}
 void popfq() { db(0x9D); }
 void pushfq() { db(0x9C); }
-void lodsq() { db(0x48); db(0xAD); }
-void movsq() { db(0x48); db(0xA5); }
-void scasq() { db(0x48); db(0xAF); }
-void stosq() { db(0x48); db(0xAB); }
-void syscall() { db(0x0F); db(0x05); }
-void sysret() { db(0x0F); db(0x07); }
-void clui() { db(0xF3); db(0x0F); db(0x01); db(0xEE); }
-void stui() { db(0xF3); db(0x0F); db(0x01); db(0xEF); }
-void testui() { db(0xF3); db(0x0F); db(0x01); db(0xED); }
-void uiret() { db(0xF3); db(0x0F); db(0x01); db(0xEC); }
+void lodsq() {
+  db(0x48);
+  db(0xAD);
+}
+void movsq() {
+  db(0x48);
+  db(0xA5);
+}
+void scasq() {
+  db(0x48);
+  db(0xAF);
+}
+void stosq() {
+  db(0x48);
+  db(0xAB);
+}
+void syscall() {
+  db(0x0F);
+  db(0x05);
+}
+void sysret() {
+  db(0x0F);
+  db(0x07);
+}
+void clui() {
+  db(0xF3);
+  db(0x0F);
+  db(0x01);
+  db(0xEE);
+}
+void stui() {
+  db(0xF3);
+  db(0x0F);
+  db(0x01);
+  db(0xEF);
+}
+void testui() {
+  db(0xF3);
+  db(0x0F);
+  db(0x01);
+  db(0xED);
+}
+void uiret() {
+  db(0xF3);
+  db(0x0F);
+  db(0x01);
+  db(0xEC);
+}
 void cmpxchg16b(const Address& addr) { opModM(addr, Reg64(1), 0x0F, 0xC7); }
 void fxrstor64(const Address& addr) { opModM(addr, Reg64(1), 0x0F, 0xAE); }
-void movq(const Reg64& reg, const Mmx& mmx) { if (mmx.isXMM()) db(0x66); opModR(mmx, reg, 0x0F, 0x7E); }
-void movq(const Mmx& mmx, const Reg64& reg) { if (mmx.isXMM()) db(0x66); opModR(mmx, reg, 0x0F, 0x6E); }
-void movsxd(const Reg64& reg, const Operand& op) { if (!op.isBit(32)) XBYAK_THROW(ERR_BAD_COMBINATION) opModRM(reg, op, op.isREG(), op.isMEM(), 0x63); }
-void pextrq(const Operand& op, const Xmm& xmm, uint8_t imm) { if (!op.isREG(64) && !op.isMEM()) XBYAK_THROW(ERR_BAD_COMBINATION) opGen(Reg64(xmm.getIdx()), op, 0x16, 0x66, 0, imm, 0x3A); }
-void pinsrq(const Xmm& xmm, const Operand& op, uint8_t imm) { if (!op.isREG(64) && !op.isMEM()) XBYAK_THROW(ERR_BAD_COMBINATION) opGen(Reg64(xmm.getIdx()), op, 0x22, 0x66, 0, imm, 0x3A); }
-void senduipi(const Reg64& r) { db(0xF3); opModR(Reg32(6), r.cvt32(), 0x0F, 0xC7); }
-void vcvtss2si(const Reg64& r, const Operand& op) { opAVX_X_X_XM(Xmm(r.getIdx()), xm0, op, T_0F | T_F3 | T_W1 | T_EVEX | T_EW1 | T_ER_X | T_N8, 0x2D); }
-void vcvttss2si(const Reg64& r, const Operand& op) { opAVX_X_X_XM(Xmm(r.getIdx()), xm0, op, T_0F | T_F3 | T_W1 | T_EVEX | T_EW1 | T_SAE_X | T_N8, 0x2C); }
-void vcvtsd2si(const Reg64& r, const Operand& op) { opAVX_X_X_XM(Xmm(r.getIdx()), xm0, op, T_0F | T_F2 | T_W1 | T_EVEX | T_EW1 | T_N4 | T_ER_X, 0x2D); }
-void vcvttsd2si(const Reg64& r, const Operand& op) { opAVX_X_X_XM(Xmm(r.getIdx()), xm0, op, T_0F | T_F2 | T_W1 | T_EVEX | T_EW1 | T_N4 | T_SAE_X, 0x2C); }
-void vmovq(const Xmm& x, const Reg64& r) { opAVX_X_X_XM(x, xm0, Xmm(r.getIdx()), T_66 | T_0F | T_W1 | T_EVEX | T_EW1, 0x6E); }
-void vmovq(const Reg64& r, const Xmm& x) { opAVX_X_X_XM(x, xm0, Xmm(r.getIdx()), T_66 | T_0F | T_W1 | T_EVEX | T_EW1, 0x7E); }
-void cmpbexadd(const Address& addr, const Reg32e& r1, const Reg32e& r2) { opGpr(r1, addr, r2, T_66 | T_0F38, 0xE6, false); }
-void cmpbxadd(const Address& addr, const Reg32e& r1, const Reg32e& r2) { opGpr(r1, addr, r2, T_66 | T_0F38, 0xE2, false); }
-void cmplexadd(const Address& addr, const Reg32e& r1, const Reg32e& r2) { opGpr(r1, addr, r2, T_66 | T_0F38, 0xEE, false); }
-void cmplxadd(const Address& addr, const Reg32e& r1, const Reg32e& r2) { opGpr(r1, addr, r2, T_66 | T_0F38, 0xEC, false); }
-void cmpnbexadd(const Address& addr, const Reg32e& r1, const Reg32e& r2) { opGpr(r1, addr, r2, T_66 | T_0F38, 0xE7, false); }
-void cmpnbxadd(const Address& addr, const Reg32e& r1, const Reg32e& r2) { opGpr(r1, addr, r2, T_66 | T_0F38, 0xE3, false); }
-void cmpnlexadd(const Address& addr, const Reg32e& r1, const Reg32e& r2) { opGpr(r1, addr, r2, T_66 | T_0F38, 0xEF, false); }
-void cmpnlxadd(const Address& addr, const Reg32e& r1, const Reg32e& r2) { opGpr(r1, addr, r2, T_66 | T_0F38, 0xED, false); }
-void cmpnoxadd(const Address& addr, const Reg32e& r1, const Reg32e& r2) { opGpr(r1, addr, r2, T_66 | T_0F38, 0xE1, false); }
-void cmpnpxadd(const Address& addr, const Reg32e& r1, const Reg32e& r2) { opGpr(r1, addr, r2, T_66 | T_0F38, 0xEB, false); }
-void cmpnsxadd(const Address& addr, const Reg32e& r1, const Reg32e& r2) { opGpr(r1, addr, r2, T_66 | T_0F38, 0xE9, false); }
-void cmpnzxadd(const Address& addr, const Reg32e& r1, const Reg32e& r2) { opGpr(r1, addr, r2, T_66 | T_0F38, 0xE5, false); }
-void cmpoxadd(const Address& addr, const Reg32e& r1, const Reg32e& r2) { opGpr(r1, addr, r2, T_66 | T_0F38, 0xE0, false); }
-void cmppxadd(const Address& addr, const Reg32e& r1, const Reg32e& r2) { opGpr(r1, addr, r2, T_66 | T_0F38, 0xEA, false); }
-void cmpsxadd(const Address& addr, const Reg32e& r1, const Reg32e& r2) { opGpr(r1, addr, r2, T_66 | T_0F38, 0xE8, false); }
-void cmpzxadd(const Address& addr, const Reg32e& r1, const Reg32e& r2) { opGpr(r1, addr, r2, T_66 | T_0F38, 0xE4, false); }
+void movq(const Reg64& reg, const Mmx& mmx) {
+  if (mmx.isXMM()) db(0x66);
+  opModR(mmx, reg, 0x0F, 0x7E);
+}
+void movq(const Mmx& mmx, const Reg64& reg) {
+  if (mmx.isXMM()) db(0x66);
+  opModR(mmx, reg, 0x0F, 0x6E);
+}
+void movsxd(const Reg64& reg, const Operand& op) {
+  if (!op.isBit(32)) XBYAK_THROW(ERR_BAD_COMBINATION) opModRM(reg, op, op.isREG(), op.isMEM(), 0x63);
+}
+void pextrq(const Operand& op, const Xmm& xmm, uint8_t imm) {
+  if (!op.isREG(64) && !op.isMEM())
+    XBYAK_THROW(ERR_BAD_COMBINATION) opGen(Reg64(xmm.getIdx()), op, 0x16, 0x66, 0, imm, 0x3A);
+}
+void pinsrq(const Xmm& xmm, const Operand& op, uint8_t imm) {
+  if (!op.isREG(64) && !op.isMEM())
+    XBYAK_THROW(ERR_BAD_COMBINATION) opGen(Reg64(xmm.getIdx()), op, 0x22, 0x66, 0, imm, 0x3A);
+}
+void senduipi(const Reg64& r) {
+  db(0xF3);
+  opModR(Reg32(6), r.cvt32(), 0x0F, 0xC7);
+}
+void vcvtss2si(const Reg64& r, const Operand& op) {
+  opAVX_X_X_XM(Xmm(r.getIdx()), xm0, op, T_0F | T_F3 | T_W1 | T_EVEX | T_EW1 | T_ER_X | T_N8, 0x2D);
+}
+void vcvttss2si(const Reg64& r, const Operand& op) {
+  opAVX_X_X_XM(Xmm(r.getIdx()), xm0, op, T_0F | T_F3 | T_W1 | T_EVEX | T_EW1 | T_SAE_X | T_N8, 0x2C);
+}
+void vcvtsd2si(const Reg64& r, const Operand& op) {
+  opAVX_X_X_XM(Xmm(r.getIdx()), xm0, op, T_0F | T_F2 | T_W1 | T_EVEX | T_EW1 | T_N4 | T_ER_X, 0x2D);
+}
+void vcvttsd2si(const Reg64& r, const Operand& op) {
+  opAVX_X_X_XM(Xmm(r.getIdx()), xm0, op, T_0F | T_F2 | T_W1 | T_EVEX | T_EW1 | T_N4 | T_SAE_X, 0x2C);
+}
+void vmovq(const Xmm& x, const Reg64& r) {
+  opAVX_X_X_XM(x, xm0, Xmm(r.getIdx()), T_66 | T_0F | T_W1 | T_EVEX | T_EW1, 0x6E);
+}
+void vmovq(const Reg64& r, const Xmm& x) {
+  opAVX_X_X_XM(x, xm0, Xmm(r.getIdx()), T_66 | T_0F | T_W1 | T_EVEX | T_EW1, 0x7E);
+}
+void cmpbexadd(const Address& addr, const Reg32e& r1, const Reg32e& r2) {
+  opGpr(r1, addr, r2, T_66 | T_0F38, 0xE6, false);
+}
+void cmpbxadd(const Address& addr, const Reg32e& r1, const Reg32e& r2) {
+  opGpr(r1, addr, r2, T_66 | T_0F38, 0xE2, false);
+}
+void cmplexadd(const Address& addr, const Reg32e& r1, const Reg32e& r2) {
+  opGpr(r1, addr, r2, T_66 | T_0F38, 0xEE, false);
+}
+void cmplxadd(const Address& addr, const Reg32e& r1, const Reg32e& r2) {
+  opGpr(r1, addr, r2, T_66 | T_0F38, 0xEC, false);
+}
+void cmpnbexadd(const Address& addr, const Reg32e& r1, const Reg32e& r2) {
+  opGpr(r1, addr, r2, T_66 | T_0F38, 0xE7, false);
+}
+void cmpnbxadd(const Address& addr, const Reg32e& r1, const Reg32e& r2) {
+  opGpr(r1, addr, r2, T_66 | T_0F38, 0xE3, false);
+}
+void cmpnlexadd(const Address& addr, const Reg32e& r1, const Reg32e& r2) {
+  opGpr(r1, addr, r2, T_66 | T_0F38, 0xEF, false);
+}
+void cmpnlxadd(const Address& addr, const Reg32e& r1, const Reg32e& r2) {
+  opGpr(r1, addr, r2, T_66 | T_0F38, 0xED, false);
+}
+void cmpnoxadd(const Address& addr, const Reg32e& r1, const Reg32e& r2) {
+  opGpr(r1, addr, r2, T_66 | T_0F38, 0xE1, false);
+}
+void cmpnpxadd(const Address& addr, const Reg32e& r1, const Reg32e& r2) {
+  opGpr(r1, addr, r2, T_66 | T_0F38, 0xEB, false);
+}
+void cmpnsxadd(const Address& addr, const Reg32e& r1, const Reg32e& r2) {
+  opGpr(r1, addr, r2, T_66 | T_0F38, 0xE9, false);
+}
+void cmpnzxadd(const Address& addr, const Reg32e& r1, const Reg32e& r2) {
+  opGpr(r1, addr, r2, T_66 | T_0F38, 0xE5, false);
+}
+void cmpoxadd(const Address& addr, const Reg32e& r1, const Reg32e& r2) {
+  opGpr(r1, addr, r2, T_66 | T_0F38, 0xE0, false);
+}
+void cmppxadd(const Address& addr, const Reg32e& r1, const Reg32e& r2) {
+  opGpr(r1, addr, r2, T_66 | T_0F38, 0xEA, false);
+}
+void cmpsxadd(const Address& addr, const Reg32e& r1, const Reg32e& r2) {
+  opGpr(r1, addr, r2, T_66 | T_0F38, 0xE8, false);
+}
+void cmpzxadd(const Address& addr, const Reg32e& r1, const Reg32e& r2) {
+  opGpr(r1, addr, r2, T_66 | T_0F38, 0xE4, false);
+}
 void ldtilecfg(const Address& addr) { opVex(tmm0, &tmm0, addr, T_0F38 | T_W0, 0x49); }
 void sttilecfg(const Address& addr) { opVex(tmm0, &tmm0, addr, T_66 | T_0F38 | T_W0, 0x49); }
 void tileloadd(const Tmm& tm, const Address& addr) { opAMX(tm, addr, T_F2 | T_0F38 | T_W0, 0x4b); }
 void tileloaddt1(const Tmm& tm, const Address& addr) { opAMX(tm, addr, T_66 | T_0F38 | T_W0, 0x4b); }
-void tilerelease() { db(0xc4); db(0xe2); db(0x78); db(0x49); db(0xc0); }
+void tilerelease() {
+  db(0xc4);
+  db(0xe2);
+  db(0x78);
+  db(0x49);
+  db(0xc0);
+}
 void tilestored(const Address& addr, const Tmm& tm) { opVex(tm, &tmm0, addr, T_F3 | T_0F38 | T_W0, 0x4b); }
 void tilezero(const Tmm& Tmm) { opVex(Tmm, &tmm0, tmm0, T_F2 | T_0F38 | T_W0, 0x49); }
 void tdpbssd(const Tmm& x1, const Tmm& x2, const Tmm& x3) { opVex(x1, &x3, x2, T_F2 | T_0F38 | T_W0, 0x5e); }
 void tdpbsud(const Tmm& x1, const Tmm& x2, const Tmm& x3) { opVex(x1, &x3, x2, T_F3 | T_0F38 | T_W0, 0x5e); }
 void tdpbusd(const Tmm& x1, const Tmm& x2, const Tmm& x3) { opVex(x1, &x3, x2, T_66 | T_0F38 | T_W0, 0x5e); }
 void tdpbuud(const Tmm& x1, const Tmm& x2, const Tmm& x3) { opVex(x1, &x3, x2, T_0F38 | T_W0, 0x5e); }
-void tdpfp16ps(const Tmm &x1, const Tmm &x2, const Tmm &x3) { opVex(x1, &x3, x2, T_F2 | T_0F38 | T_W0, 0x5c); }
+void tdpfp16ps(const Tmm& x1, const Tmm& x2, const Tmm& x3) { opVex(x1, &x3, x2, T_F2 | T_0F38 | T_W0, 0x5c); }
 void tdpbf16ps(const Tmm& x1, const Tmm& x2, const Tmm& x3) { opVex(x1, &x3, x2, T_F3 | T_0F38 | T_W0, 0x5c); }
 #else
-void jcxz(std::string label) { db(0x67); opJmp(label, T_SHORT, 0xe3, 0, 0); }
-void jcxz(const Label& label) { db(0x67); opJmp(label, T_SHORT, 0xe3, 0, 0); }
+void jcxz(std::string label) {
+  db(0x67);
+  opJmp(label, T_SHORT, 0xe3, 0, 0);
+}
+void jcxz(const Label& label) {
+  db(0x67);
+  opJmp(label, T_SHORT, 0xe3, 0, 0);
+}
 void jecxz(std::string label) { opJmp(label, T_SHORT, 0xe3, 0, 0); }
 void jecxz(const Label& label) { opJmp(label, T_SHORT, 0xe3, 0, 0); }
 void aaa() { db(0x37); }
-void aad() { db(0xD5); db(0x0A); }
-void aam() { db(0xD4); db(0x0A); }
+void aad() {
+  db(0xD5);
+  db(0x0A);
+}
+void aam() {
+  db(0xD4);
+  db(0x0A);
+}
 void aas() { db(0x3F); }
 void daa() { db(0x27); }
 void das() { db(0x2F); }
@@ -1754,39 +3223,60 @@ void lds(const Reg& reg, const Address& addr) { opLoadSeg(addr, reg, 0xC5, 0x100
 void les(const Reg& reg, const Address& addr) { opLoadSeg(addr, reg, 0xC4, 0x100); }
 #endif
 #ifndef XBYAK_NO_OP_NAMES
-void and(const Operand& op1, const Operand& op2) { and_(op1, op2); }
-void and(const Operand& op, uint32_t imm) { and_(op, imm); }
-void or(const Operand& op1, const Operand& op2) { or_(op1, op2); }
-void or(const Operand& op, uint32_t imm) { or_(op, imm); }
-void xor(const Operand& op1, const Operand& op2) { xor_(op1, op2); }
-void xor(const Operand& op, uint32_t imm) { xor_(op, imm); }
-void not(const Operand& op) { not_(op); }
+void and (const Operand& op1, const Operand& op2) { and_(op1, op2); }
+void and (const Operand& op, uint32_t imm) { and_(op, imm); }
+void or (const Operand& op1, const Operand& op2) { or_(op1, op2); }
+void or (const Operand& op, uint32_t imm) { or_(op, imm); }
+void xor (const Operand& op1, const Operand& op2) { xor_(op1, op2); } void xor
+    (const Operand& op, uint32_t imm) { xor_(op, imm); } void not(const Operand& op) {
+  not_(op);
+}
 #endif
 #ifndef XBYAK_DISABLE_AVX512
-void kaddb(const Opmask& r1, const Opmask& r2, const Opmask& r3) { opVex(r1, &r2, r3, T_L1 | T_0F | T_66 | T_W0, 0x4A); }
-void kaddd(const Opmask& r1, const Opmask& r2, const Opmask& r3) { opVex(r1, &r2, r3, T_L1 | T_0F | T_66 | T_W1, 0x4A); }
+void kaddb(const Opmask& r1, const Opmask& r2, const Opmask& r3) {
+  opVex(r1, &r2, r3, T_L1 | T_0F | T_66 | T_W0, 0x4A);
+}
+void kaddd(const Opmask& r1, const Opmask& r2, const Opmask& r3) {
+  opVex(r1, &r2, r3, T_L1 | T_0F | T_66 | T_W1, 0x4A);
+}
 void kaddq(const Opmask& r1, const Opmask& r2, const Opmask& r3) { opVex(r1, &r2, r3, T_L1 | T_0F | T_W1, 0x4A); }
 void kaddw(const Opmask& r1, const Opmask& r2, const Opmask& r3) { opVex(r1, &r2, r3, T_L1 | T_0F | T_W0, 0x4A); }
-void kandb(const Opmask& r1, const Opmask& r2, const Opmask& r3) { opVex(r1, &r2, r3, T_L1 | T_0F | T_66 | T_W0, 0x41); }
-void kandd(const Opmask& r1, const Opmask& r2, const Opmask& r3) { opVex(r1, &r2, r3, T_L1 | T_0F | T_66 | T_W1, 0x41); }
-void kandnb(const Opmask& r1, const Opmask& r2, const Opmask& r3) { opVex(r1, &r2, r3, T_L1 | T_0F | T_66 | T_W0, 0x42); }
-void kandnd(const Opmask& r1, const Opmask& r2, const Opmask& r3) { opVex(r1, &r2, r3, T_L1 | T_0F | T_66 | T_W1, 0x42); }
+void kandb(const Opmask& r1, const Opmask& r2, const Opmask& r3) {
+  opVex(r1, &r2, r3, T_L1 | T_0F | T_66 | T_W0, 0x41);
+}
+void kandd(const Opmask& r1, const Opmask& r2, const Opmask& r3) {
+  opVex(r1, &r2, r3, T_L1 | T_0F | T_66 | T_W1, 0x41);
+}
+void kandnb(const Opmask& r1, const Opmask& r2, const Opmask& r3) {
+  opVex(r1, &r2, r3, T_L1 | T_0F | T_66 | T_W0, 0x42);
+}
+void kandnd(const Opmask& r1, const Opmask& r2, const Opmask& r3) {
+  opVex(r1, &r2, r3, T_L1 | T_0F | T_66 | T_W1, 0x42);
+}
 void kandnq(const Opmask& r1, const Opmask& r2, const Opmask& r3) { opVex(r1, &r2, r3, T_L1 | T_0F | T_W1, 0x42); }
 void kandnw(const Opmask& r1, const Opmask& r2, const Opmask& r3) { opVex(r1, &r2, r3, T_L1 | T_0F | T_W0, 0x42); }
 void kandq(const Opmask& r1, const Opmask& r2, const Opmask& r3) { opVex(r1, &r2, r3, T_L1 | T_0F | T_W1, 0x41); }
 void kandw(const Opmask& r1, const Opmask& r2, const Opmask& r3) { opVex(r1, &r2, r3, T_L1 | T_0F | T_W0, 0x41); }
 void kmovb(const Address& addr, const Opmask& k) { opVex(k, 0, addr, T_L0 | T_0F | T_66 | T_W0, 0x91); }
-void kmovb(const Opmask& k, const Operand& op) { if (!op.isMEM() && !op.isOPMASK()) XBYAK_THROW(ERR_BAD_COMBINATION) opVex(k, 0, op, T_L0 | T_0F | T_66 | T_W0, 0x90); }
+void kmovb(const Opmask& k, const Operand& op) {
+  if (!op.isMEM() && !op.isOPMASK()) XBYAK_THROW(ERR_BAD_COMBINATION) opVex(k, 0, op, T_L0 | T_0F | T_66 | T_W0, 0x90);
+}
 void kmovb(const Opmask& k, const Reg32& r) { opVex(k, 0, r, T_L0 | T_0F | T_66 | T_W0, 0x92); }
 void kmovb(const Reg32& r, const Opmask& k) { opVex(r, 0, k, T_L0 | T_0F | T_66 | T_W0, 0x93); }
 void kmovd(const Address& addr, const Opmask& k) { opVex(k, 0, addr, T_L0 | T_0F | T_66 | T_W1, 0x91); }
-void kmovd(const Opmask& k, const Operand& op) { if (!op.isMEM() && !op.isOPMASK()) XBYAK_THROW(ERR_BAD_COMBINATION) opVex(k, 0, op, T_L0 | T_0F | T_66 | T_W1, 0x90); }
+void kmovd(const Opmask& k, const Operand& op) {
+  if (!op.isMEM() && !op.isOPMASK()) XBYAK_THROW(ERR_BAD_COMBINATION) opVex(k, 0, op, T_L0 | T_0F | T_66 | T_W1, 0x90);
+}
 void kmovd(const Opmask& k, const Reg32& r) { opVex(k, 0, r, T_L0 | T_0F | T_F2 | T_W0, 0x92); }
 void kmovd(const Reg32& r, const Opmask& k) { opVex(r, 0, k, T_L0 | T_0F | T_F2 | T_W0, 0x93); }
 void kmovq(const Address& addr, const Opmask& k) { opVex(k, 0, addr, T_L0 | T_0F | T_W1, 0x91); }
-void kmovq(const Opmask& k, const Operand& op) { if (!op.isMEM() && !op.isOPMASK()) XBYAK_THROW(ERR_BAD_COMBINATION) opVex(k, 0, op, T_L0 | T_0F | T_W1, 0x90); }
+void kmovq(const Opmask& k, const Operand& op) {
+  if (!op.isMEM() && !op.isOPMASK()) XBYAK_THROW(ERR_BAD_COMBINATION) opVex(k, 0, op, T_L0 | T_0F | T_W1, 0x90);
+}
 void kmovw(const Address& addr, const Opmask& k) { opVex(k, 0, addr, T_L0 | T_0F | T_W0, 0x91); }
-void kmovw(const Opmask& k, const Operand& op) { if (!op.isMEM() && !op.isOPMASK()) XBYAK_THROW(ERR_BAD_COMBINATION) opVex(k, 0, op, T_L0 | T_0F | T_W0, 0x90); }
+void kmovw(const Opmask& k, const Operand& op) {
+  if (!op.isMEM() && !op.isOPMASK()) XBYAK_THROW(ERR_BAD_COMBINATION) opVex(k, 0, op, T_L0 | T_0F | T_W0, 0x90);
+}
 void kmovw(const Opmask& k, const Reg32& r) { opVex(k, 0, r, T_L0 | T_0F | T_W0, 0x92); }
 void kmovw(const Reg32& r, const Opmask& k) { opVex(r, 0, k, T_L0 | T_0F | T_W0, 0x93); }
 void knotb(const Opmask& r1, const Opmask& r2) { opVex(r1, 0, r2, T_0F | T_66 | T_W0, 0x44); }
@@ -1813,37 +3303,87 @@ void ktestb(const Opmask& r1, const Opmask& r2) { opVex(r1, 0, r2, T_0F | T_66 |
 void ktestd(const Opmask& r1, const Opmask& r2) { opVex(r1, 0, r2, T_0F | T_66 | T_W1, 0x99); }
 void ktestq(const Opmask& r1, const Opmask& r2) { opVex(r1, 0, r2, T_0F | T_W1, 0x99); }
 void ktestw(const Opmask& r1, const Opmask& r2) { opVex(r1, 0, r2, T_0F | T_W0, 0x99); }
-void kunpckbw(const Opmask& r1, const Opmask& r2, const Opmask& r3) { opVex(r1, &r2, r3, T_L1 | T_0F | T_66 | T_W0, 0x4B); }
+void kunpckbw(const Opmask& r1, const Opmask& r2, const Opmask& r3) {
+  opVex(r1, &r2, r3, T_L1 | T_0F | T_66 | T_W0, 0x4B);
+}
 void kunpckdq(const Opmask& r1, const Opmask& r2, const Opmask& r3) { opVex(r1, &r2, r3, T_L1 | T_0F | T_W1, 0x4B); }
 void kunpckwd(const Opmask& r1, const Opmask& r2, const Opmask& r3) { opVex(r1, &r2, r3, T_L1 | T_0F | T_W0, 0x4B); }
-void kxnorb(const Opmask& r1, const Opmask& r2, const Opmask& r3) { opVex(r1, &r2, r3, T_L1 | T_0F | T_66 | T_W0, 0x46); }
-void kxnord(const Opmask& r1, const Opmask& r2, const Opmask& r3) { opVex(r1, &r2, r3, T_L1 | T_0F | T_66 | T_W1, 0x46); }
+void kxnorb(const Opmask& r1, const Opmask& r2, const Opmask& r3) {
+  opVex(r1, &r2, r3, T_L1 | T_0F | T_66 | T_W0, 0x46);
+}
+void kxnord(const Opmask& r1, const Opmask& r2, const Opmask& r3) {
+  opVex(r1, &r2, r3, T_L1 | T_0F | T_66 | T_W1, 0x46);
+}
 void kxnorq(const Opmask& r1, const Opmask& r2, const Opmask& r3) { opVex(r1, &r2, r3, T_L1 | T_0F | T_W1, 0x46); }
 void kxnorw(const Opmask& r1, const Opmask& r2, const Opmask& r3) { opVex(r1, &r2, r3, T_L1 | T_0F | T_W0, 0x46); }
-void kxorb(const Opmask& r1, const Opmask& r2, const Opmask& r3) { opVex(r1, &r2, r3, T_L1 | T_0F | T_66 | T_W0, 0x47); }
-void kxord(const Opmask& r1, const Opmask& r2, const Opmask& r3) { opVex(r1, &r2, r3, T_L1 | T_0F | T_66 | T_W1, 0x47); }
+void kxorb(const Opmask& r1, const Opmask& r2, const Opmask& r3) {
+  opVex(r1, &r2, r3, T_L1 | T_0F | T_66 | T_W0, 0x47);
+}
+void kxord(const Opmask& r1, const Opmask& r2, const Opmask& r3) {
+  opVex(r1, &r2, r3, T_L1 | T_0F | T_66 | T_W1, 0x47);
+}
 void kxorq(const Opmask& r1, const Opmask& r2, const Opmask& r3) { opVex(r1, &r2, r3, T_L1 | T_0F | T_W1, 0x47); }
 void kxorw(const Opmask& r1, const Opmask& r2, const Opmask& r3) { opVex(r1, &r2, r3, T_L1 | T_0F | T_W0, 0x47); }
-void v4fmaddps(const Zmm& z1, const Zmm& z2, const Address& addr) { opAVX_X_X_XM(z1, z2, addr, T_0F38 | T_F2 | T_EW0 | T_YMM | T_MUST_EVEX | T_N16, 0x9A); }
-void v4fmaddss(const Xmm& x1, const Xmm& x2, const Address& addr) { opAVX_X_X_XM(x1, x2, addr, T_0F38 | T_F2 | T_EW0 | T_MUST_EVEX | T_N16, 0x9B); }
-void v4fnmaddps(const Zmm& z1, const Zmm& z2, const Address& addr) { opAVX_X_X_XM(z1, z2, addr, T_0F38 | T_F2 | T_EW0 | T_YMM | T_MUST_EVEX | T_N16, 0xAA); }
-void v4fnmaddss(const Xmm& x1, const Xmm& x2, const Address& addr) { opAVX_X_X_XM(x1, x2, addr, T_0F38 | T_F2 | T_EW0 | T_MUST_EVEX | T_N16, 0xAB); }
-void vaddph(const Xmm& xmm, const Operand& op1, const Operand& op2 = Operand()) { opAVX_X_X_XM(xmm, op1, op2, T_MAP5 | T_EW0 | T_YMM | T_MUST_EVEX | T_ER_Z | T_B16, 0x58); }
-void vaddsh(const Xmm& xmm, const Operand& op1, const Operand& op2 = Operand()) { opAVX_X_X_XM(xmm, op1, op2, T_MAP5 | T_F3 | T_EW0 | T_MUST_EVEX | T_ER_X | T_N2, 0x58); }
-void valignd(const Xmm& x1, const Xmm& x2, const Operand& op, uint8_t imm) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F3A | T_EW0 | T_YMM | T_MUST_EVEX, 0x03, imm); }
-void valignq(const Xmm& x1, const Xmm& x2, const Operand& op, uint8_t imm) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F3A | T_EW1 | T_YMM | T_MUST_EVEX, 0x03, imm); }
-void vblendmpd(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_EW1 | T_YMM | T_MUST_EVEX | T_B64, 0x65); }
-void vblendmps(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_EW0 | T_YMM | T_MUST_EVEX | T_B32, 0x65); }
-void vbroadcastf32x2(const Ymm& y, const Operand& op) { opAVX_X_XM_IMM(y, op, T_66 | T_0F38 | T_YMM | T_MUST_EVEX | T_EW0 | T_N8, 0x19); }
-void vbroadcastf32x4(const Ymm& y, const Address& addr) { opAVX_X_XM_IMM(y, addr, T_66 | T_0F38 | T_YMM | T_MUST_EVEX | T_EW0 | T_N16, 0x1A); }
-void vbroadcastf32x8(const Zmm& y, const Address& addr) { opAVX_X_XM_IMM(y, addr, T_66 | T_0F38 | T_YMM | T_MUST_EVEX | T_EW0 | T_N32, 0x1B); }
-void vbroadcastf64x2(const Ymm& y, const Address& addr) { opAVX_X_XM_IMM(y, addr, T_66 | T_0F38 | T_YMM | T_MUST_EVEX | T_EW1 | T_N16, 0x1A); }
-void vbroadcastf64x4(const Zmm& y, const Address& addr) { opAVX_X_XM_IMM(y, addr, T_66 | T_0F38 | T_YMM | T_MUST_EVEX | T_EW1 | T_N32, 0x1B); }
-void vbroadcasti32x2(const Xmm& x, const Operand& op) { opAVX_X_XM_IMM(x, op, T_66 | T_0F38 | T_YMM | T_MUST_EVEX | T_EW0 | T_N8, 0x59); }
-void vbroadcasti32x4(const Ymm& y, const Operand& op) { opAVX_X_XM_IMM(y, op, T_66 | T_0F38 | T_YMM | T_MUST_EVEX | T_EW0 | T_N16, 0x5A); }
-void vbroadcasti32x8(const Zmm& z, const Operand& op) { opAVX_X_XM_IMM(z, op, T_66 | T_0F38 | T_YMM | T_MUST_EVEX | T_EW0 | T_N32, 0x5B); }
-void vbroadcasti64x2(const Ymm& y, const Operand& op) { opAVX_X_XM_IMM(y, op, T_66 | T_0F38 | T_YMM | T_MUST_EVEX | T_EW1 | T_N16, 0x5A); }
-void vbroadcasti64x4(const Zmm& z, const Operand& op) { opAVX_X_XM_IMM(z, op, T_66 | T_0F38 | T_YMM | T_MUST_EVEX | T_EW1 | T_N32, 0x5B); }
+void v4fmaddps(const Zmm& z1, const Zmm& z2, const Address& addr) {
+  opAVX_X_X_XM(z1, z2, addr, T_0F38 | T_F2 | T_EW0 | T_YMM | T_MUST_EVEX | T_N16, 0x9A);
+}
+void v4fmaddss(const Xmm& x1, const Xmm& x2, const Address& addr) {
+  opAVX_X_X_XM(x1, x2, addr, T_0F38 | T_F2 | T_EW0 | T_MUST_EVEX | T_N16, 0x9B);
+}
+void v4fnmaddps(const Zmm& z1, const Zmm& z2, const Address& addr) {
+  opAVX_X_X_XM(z1, z2, addr, T_0F38 | T_F2 | T_EW0 | T_YMM | T_MUST_EVEX | T_N16, 0xAA);
+}
+void v4fnmaddss(const Xmm& x1, const Xmm& x2, const Address& addr) {
+  opAVX_X_X_XM(x1, x2, addr, T_0F38 | T_F2 | T_EW0 | T_MUST_EVEX | T_N16, 0xAB);
+}
+void vaddph(const Xmm& xmm, const Operand& op1, const Operand& op2 = Operand()) {
+  opAVX_X_X_XM(xmm, op1, op2, T_MAP5 | T_EW0 | T_YMM | T_MUST_EVEX | T_ER_Z | T_B16, 0x58);
+}
+void vaddsh(const Xmm& xmm, const Operand& op1, const Operand& op2 = Operand()) {
+  opAVX_X_X_XM(xmm, op1, op2, T_MAP5 | T_F3 | T_EW0 | T_MUST_EVEX | T_ER_X | T_N2, 0x58);
+}
+void valignd(const Xmm& x1, const Xmm& x2, const Operand& op, uint8_t imm) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F3A | T_EW0 | T_YMM | T_MUST_EVEX, 0x03, imm);
+}
+void valignq(const Xmm& x1, const Xmm& x2, const Operand& op, uint8_t imm) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F3A | T_EW1 | T_YMM | T_MUST_EVEX, 0x03, imm);
+}
+void vblendmpd(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_EW1 | T_YMM | T_MUST_EVEX | T_B64, 0x65);
+}
+void vblendmps(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_EW0 | T_YMM | T_MUST_EVEX | T_B32, 0x65);
+}
+void vbroadcastf32x2(const Ymm& y, const Operand& op) {
+  opAVX_X_XM_IMM(y, op, T_66 | T_0F38 | T_YMM | T_MUST_EVEX | T_EW0 | T_N8, 0x19);
+}
+void vbroadcastf32x4(const Ymm& y, const Address& addr) {
+  opAVX_X_XM_IMM(y, addr, T_66 | T_0F38 | T_YMM | T_MUST_EVEX | T_EW0 | T_N16, 0x1A);
+}
+void vbroadcastf32x8(const Zmm& y, const Address& addr) {
+  opAVX_X_XM_IMM(y, addr, T_66 | T_0F38 | T_YMM | T_MUST_EVEX | T_EW0 | T_N32, 0x1B);
+}
+void vbroadcastf64x2(const Ymm& y, const Address& addr) {
+  opAVX_X_XM_IMM(y, addr, T_66 | T_0F38 | T_YMM | T_MUST_EVEX | T_EW1 | T_N16, 0x1A);
+}
+void vbroadcastf64x4(const Zmm& y, const Address& addr) {
+  opAVX_X_XM_IMM(y, addr, T_66 | T_0F38 | T_YMM | T_MUST_EVEX | T_EW1 | T_N32, 0x1B);
+}
+void vbroadcasti32x2(const Xmm& x, const Operand& op) {
+  opAVX_X_XM_IMM(x, op, T_66 | T_0F38 | T_YMM | T_MUST_EVEX | T_EW0 | T_N8, 0x59);
+}
+void vbroadcasti32x4(const Ymm& y, const Operand& op) {
+  opAVX_X_XM_IMM(y, op, T_66 | T_0F38 | T_YMM | T_MUST_EVEX | T_EW0 | T_N16, 0x5A);
+}
+void vbroadcasti32x8(const Zmm& z, const Operand& op) {
+  opAVX_X_XM_IMM(z, op, T_66 | T_0F38 | T_YMM | T_MUST_EVEX | T_EW0 | T_N32, 0x5B);
+}
+void vbroadcasti64x2(const Ymm& y, const Operand& op) {
+  opAVX_X_XM_IMM(y, op, T_66 | T_0F38 | T_YMM | T_MUST_EVEX | T_EW1 | T_N16, 0x5A);
+}
+void vbroadcasti64x4(const Zmm& z, const Operand& op) {
+  opAVX_X_XM_IMM(z, op, T_66 | T_0F38 | T_YMM | T_MUST_EVEX | T_EW1 | T_N32, 0x5B);
+}
 void vcmpeq_ospd(const Opmask& k, const Xmm& x, const Operand& op) { vcmppd(k, x, op, 16); }
 void vcmpeq_osps(const Opmask& k, const Xmm& x, const Operand& op) { vcmpps(k, x, op, 16); }
 void vcmpeq_ossd(const Opmask& k, const Xmm& x, const Operand& op) { vcmpsd(k, x, op, 16); }
@@ -1956,12 +3496,24 @@ void vcmpordpd(const Opmask& k, const Xmm& x, const Operand& op) { vcmppd(k, x,
 void vcmpordps(const Opmask& k, const Xmm& x, const Operand& op) { vcmpps(k, x, op, 7); }
 void vcmpordsd(const Opmask& k, const Xmm& x, const Operand& op) { vcmpsd(k, x, op, 7); }
 void vcmpordss(const Opmask& k, const Xmm& x, const Operand& op) { vcmpss(k, x, op, 7); }
-void vcmppd(const Opmask& k, const Xmm& x, const Operand& op, uint8_t imm) { opAVX_K_X_XM(k, x, op, T_66 | T_0F | T_EW1 | T_YMM | T_SAE_Z | T_MUST_EVEX | T_B64, 0xC2, imm); }
-void vcmpph(const Opmask& k, const Xmm& x, const Operand& op, uint8_t imm) { opAVX_K_X_XM(k, x, op, T_0F3A | T_EW0 | T_YMM | T_SAE_Z | T_MUST_EVEX | T_B16, 0xC2, imm); }
-void vcmpps(const Opmask& k, const Xmm& x, const Operand& op, uint8_t imm) { opAVX_K_X_XM(k, x, op, T_0F | T_EW0 | T_YMM | T_SAE_Z | T_MUST_EVEX | T_B32, 0xC2, imm); }
-void vcmpsd(const Opmask& k, const Xmm& x, const Operand& op, uint8_t imm) { opAVX_K_X_XM(k, x, op, T_N8 | T_F2 | T_0F | T_EW1 | T_SAE_Z | T_MUST_EVEX, 0xC2, imm); }
-void vcmpsh(const Opmask& k, const Xmm& x, const Operand& op, uint8_t imm) { opAVX_K_X_XM(k, x, op, T_N2 | T_F3 | T_0F3A | T_EW0 | T_SAE_X | T_MUST_EVEX, 0xC2, imm); }
-void vcmpss(const Opmask& k, const Xmm& x, const Operand& op, uint8_t imm) { opAVX_K_X_XM(k, x, op, T_N4 | T_F3 | T_0F | T_EW0 | T_SAE_Z | T_MUST_EVEX, 0xC2, imm); }
+void vcmppd(const Opmask& k, const Xmm& x, const Operand& op, uint8_t imm) {
+  opAVX_K_X_XM(k, x, op, T_66 | T_0F | T_EW1 | T_YMM | T_SAE_Z | T_MUST_EVEX | T_B64, 0xC2, imm);
+}
+void vcmpph(const Opmask& k, const Xmm& x, const Operand& op, uint8_t imm) {
+  opAVX_K_X_XM(k, x, op, T_0F3A | T_EW0 | T_YMM | T_SAE_Z | T_MUST_EVEX | T_B16, 0xC2, imm);
+}
+void vcmpps(const Opmask& k, const Xmm& x, const Operand& op, uint8_t imm) {
+  opAVX_K_X_XM(k, x, op, T_0F | T_EW0 | T_YMM | T_SAE_Z | T_MUST_EVEX | T_B32, 0xC2, imm);
+}
+void vcmpsd(const Opmask& k, const Xmm& x, const Operand& op, uint8_t imm) {
+  opAVX_K_X_XM(k, x, op, T_N8 | T_F2 | T_0F | T_EW1 | T_SAE_Z | T_MUST_EVEX, 0xC2, imm);
+}
+void vcmpsh(const Opmask& k, const Xmm& x, const Operand& op, uint8_t imm) {
+  opAVX_K_X_XM(k, x, op, T_N2 | T_F3 | T_0F3A | T_EW0 | T_SAE_X | T_MUST_EVEX, 0xC2, imm);
+}
+void vcmpss(const Opmask& k, const Xmm& x, const Operand& op, uint8_t imm) {
+  opAVX_K_X_XM(k, x, op, T_N4 | T_F3 | T_0F | T_EW0 | T_SAE_Z | T_MUST_EVEX, 0xC2, imm);
+}
 void vcmptrue_uspd(const Opmask& k, const Xmm& x, const Operand& op) { vcmppd(k, x, op, 31); }
 void vcmptrue_usps(const Opmask& k, const Xmm& x, const Operand& op) { vcmpps(k, x, op, 31); }
 void vcmptrue_ussd(const Opmask& k, const Xmm& x, const Operand& op) { vcmpsd(k, x, op, 31); }
@@ -1978,390 +3530,1196 @@ void vcmpunordpd(const Opmask& k, const Xmm& x, const Operand& op) { vcmppd(k, x
 void vcmpunordps(const Opmask& k, const Xmm& x, const Operand& op) { vcmpps(k, x, op, 3); }
 void vcmpunordsd(const Opmask& k, const Xmm& x, const Operand& op) { vcmpsd(k, x, op, 3); }
 void vcmpunordss(const Opmask& k, const Xmm& x, const Operand& op) { vcmpss(k, x, op, 3); }
-void vcomish(const Xmm& x, const Operand& op) { opAVX_X_XM_IMM(x, op, T_MAP5 | T_MUST_EVEX | T_EW0 | T_SAE_X | T_N2, 0x2F); }
-void vcompressb(const Operand& op, const Xmm& x) { opAVX_X_XM_IMM(x, op, T_N1 | T_66 | T_0F38 | T_EW0 | T_YMM | T_MUST_EVEX, 0x63); }
-void vcompresspd(const Operand& op, const Xmm& x) { opAVX_X_XM_IMM(x, op, T_N8 | T_66 | T_0F38 | T_EW1 | T_YMM | T_MUST_EVEX, 0x8A); }
-void vcompressps(const Operand& op, const Xmm& x) { opAVX_X_XM_IMM(x, op, T_N4 | T_66 | T_0F38 | T_EW0 | T_YMM | T_MUST_EVEX, 0x8A); }
-void vcompressw(const Operand& op, const Xmm& x) { opAVX_X_XM_IMM(x, op, T_N2 | T_66 | T_0F38 | T_EW1 | T_YMM | T_MUST_EVEX, 0x63); }
-void vcvtdq2ph(const Xmm& x, const Operand& op) { checkCvt4(x, op); opCvt(x, op, T_N16 | T_N_VL | T_MAP5 | T_EW0 | T_YMM | T_ER_Z | T_MUST_EVEX | T_B32, 0x5B); }
-void vcvtne2ps2bf16(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_F2 | T_0F38 | T_EW0 | T_YMM | T_SAE_Z | T_MUST_EVEX | T_B32, 0x72); }
-void vcvtpd2ph(const Xmm& x, const Operand& op) { opCvt5(x, op, T_N16 | T_N_VL | T_66 | T_MAP5 | T_EW1 | T_ER_Z | T_MUST_EVEX | T_B64, 0x5A); }
-void vcvtpd2qq(const Xmm& x, const Operand& op) { opAVX_X_XM_IMM(x, op, T_66 | T_0F | T_EW1 | T_YMM | T_ER_Z | T_MUST_EVEX | T_B64, 0x7B); }
-void vcvtpd2udq(const Xmm& x, const Operand& op) { opCvt2(x, op, T_0F | T_EW1 | T_YMM | T_ER_Z | T_MUST_EVEX | T_B64, 0x79); }
-void vcvtpd2uqq(const Xmm& x, const Operand& op) { opAVX_X_XM_IMM(x, op, T_66 | T_0F | T_EW1 | T_YMM | T_ER_Z | T_MUST_EVEX | T_B64, 0x79); }
-void vcvtph2dq(const Xmm& x, const Operand& op) { checkCvt1(x, op); opVex(x, 0, op, T_N8 | T_N_VL | T_66 | T_MAP5 | T_EW0 | T_YMM | T_ER_Y | T_MUST_EVEX | T_B16, 0x5B); }
-void vcvtph2pd(const Xmm& x, const Operand& op) { if (!op.isXMM() && !op.isMEM()) XBYAK_THROW(ERR_BAD_MEM_SIZE) opVex(x, 0, op, T_N4 | T_N_VL | T_MAP5 | T_EW0 | T_YMM | T_SAE_X | T_MUST_EVEX | T_B16, 0x5A); }
-void vcvtph2psx(const Xmm& x, const Operand& op) { checkCvt1(x, op); opVex(x, 0, op, T_N8 | T_N_VL | T_66 | T_MAP6 | T_EW0 | T_YMM | T_SAE_Y | T_MUST_EVEX | T_B16, 0x13); }
-void vcvtph2qq(const Xmm& x, const Operand& op) { if (!op.isXMM() && !op.isMEM()) XBYAK_THROW(ERR_BAD_MEM_SIZE) opVex(x, 0, op, T_N4 | T_N_VL | T_66 | T_MAP5 | T_EW0 | T_YMM | T_ER_X | T_MUST_EVEX | T_B16, 0x7B); }
-void vcvtph2udq(const Xmm& x, const Operand& op) { checkCvt1(x, op); opVex(x, 0, op, T_N8 | T_N_VL | T_MAP5 | T_EW0 | T_YMM | T_ER_Y | T_MUST_EVEX | T_B16, 0x79); }
-void vcvtph2uqq(const Xmm& x, const Operand& op) { if (!op.isXMM() && !op.isMEM()) XBYAK_THROW(ERR_BAD_MEM_SIZE) opVex(x, 0, op, T_N4 | T_N_VL | T_66 | T_MAP5 | T_EW0 | T_YMM | T_ER_X | T_MUST_EVEX | T_B16, 0x79); }
-void vcvtph2uw(const Xmm& x, const Operand& op) { opAVX_X_XM_IMM(x, op, T_MAP5 | T_EW0 | T_YMM | T_ER_Z | T_MUST_EVEX | T_B16, 0x7D); }
-void vcvtph2w(const Xmm& x, const Operand& op) { opAVX_X_XM_IMM(x, op, T_66 | T_MAP5 | T_EW0 | T_YMM | T_ER_Z | T_MUST_EVEX | T_B16, 0x7D); }
-void vcvtps2phx(const Xmm& x, const Operand& op) { checkCvt4(x, op); opCvt(x, op, T_N16 | T_N_VL | T_66 | T_MAP5 | T_EW0 | T_ER_Z | T_MUST_EVEX | T_B32, 0x1D); }
-void vcvtps2qq(const Xmm& x, const Operand& op) { checkCvt1(x, op); opVex(x, 0, op, T_N8 | T_N_VL | T_66 | T_0F | T_EW0 | T_YMM | T_ER_Y | T_MUST_EVEX | T_B32, 0x7B); }
-void vcvtps2udq(const Xmm& x, const Operand& op) { opAVX_X_XM_IMM(x, op, T_0F | T_EW0 | T_YMM | T_ER_Z | T_MUST_EVEX | T_B32, 0x79); }
-void vcvtps2uqq(const Xmm& x, const Operand& op) { checkCvt1(x, op); opVex(x, 0, op, T_N8 | T_N_VL | T_66 | T_0F | T_EW0 | T_YMM | T_ER_Y | T_MUST_EVEX | T_B32, 0x79); }
-void vcvtqq2pd(const Xmm& x, const Operand& op) { opAVX_X_XM_IMM(x, op, T_F3 | T_0F | T_EW1 | T_YMM | T_ER_Z | T_MUST_EVEX | T_B64, 0xE6); }
-void vcvtqq2ph(const Xmm& x, const Operand& op) { opCvt5(x, op, T_N16 | T_N_VL | T_MAP5 | T_EW1 | T_ER_Z | T_MUST_EVEX | T_B64, 0x5B); }
-void vcvtqq2ps(const Xmm& x, const Operand& op) { opCvt2(x, op, T_0F | T_EW1 | T_YMM | T_ER_Z | T_MUST_EVEX | T_B64, 0x5B); }
-void vcvtsd2sh(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_N8 | T_F2 | T_MAP5 | T_EW1 | T_ER_X | T_MUST_EVEX, 0x5A); }
-void vcvtsd2usi(const Reg32e& r, const Operand& op) { int type = (T_N8 | T_F2 | T_0F | T_ER_X | T_MUST_EVEX) | (r.isREG(64) ? T_EW1 : T_EW0); opVex(r, &xm0, op, type, 0x79); }
-void vcvtsh2sd(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_N2 | T_F3 | T_MAP5 | T_EW0 | T_SAE_X | T_MUST_EVEX, 0x5A); }
-void vcvtsh2si(const Reg32e& r, const Operand& op) { int type = (T_N2 | T_F3 | T_MAP5 | T_ER_X | T_MUST_EVEX) | (r.isREG(64) ? T_EW1 : T_EW0); opVex(r, &xm0, op, type, 0x2D); }
-void vcvtsh2ss(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_N2 | T_MAP6 | T_EW0 | T_SAE_X | T_MUST_EVEX, 0x13); }
-void vcvtsh2usi(const Reg32e& r, const Operand& op) { int type = (T_N2 | T_F3 | T_MAP5 | T_ER_X | T_MUST_EVEX) | (r.isREG(64) ? T_EW1 : T_EW0); opVex(r, &xm0, op, type, 0x79); }
-void vcvtsi2sh(const Xmm& x1, const Xmm& x2, const Operand& op) { if (!(x1.isXMM() && x2.isXMM() && op.isBit(32|64))) XBYAK_THROW(ERR_BAD_COMBINATION) int type = (T_F3 | T_MAP5 | T_ER_R | T_MUST_EVEX | T_M_K) | (op.isBit(32) ? (T_EW0 | T_N4) : (T_EW1 | T_N8)); opVex(x1, &x2, op, type, 0x2A); }
-void vcvtss2sh(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_N4 | T_MAP5 | T_EW0 | T_ER_X | T_MUST_EVEX, 0x1D); }
-void vcvtss2usi(const Reg32e& r, const Operand& op) { int type = (T_N4 | T_F3 | T_0F | T_ER_X | T_MUST_EVEX) | (r.isREG(64) ? T_EW1 : T_EW0); opVex(r, &xm0, op, type, 0x79); }
-void vcvttpd2qq(const Xmm& x, const Operand& op) { opAVX_X_XM_IMM(x, op, T_66 | T_0F | T_EW1 | T_YMM | T_SAE_Z | T_MUST_EVEX | T_B64, 0x7A); }
-void vcvttpd2udq(const Xmm& x, const Operand& op) { opCvt2(x, op, T_0F | T_EW1 | T_YMM | T_SAE_Z | T_MUST_EVEX | T_B64, 0x78); }
-void vcvttpd2uqq(const Xmm& x, const Operand& op) { opAVX_X_XM_IMM(x, op, T_66 | T_0F | T_EW1 | T_YMM | T_SAE_Z | T_MUST_EVEX | T_B64, 0x78); }
-void vcvttph2dq(const Xmm& x, const Operand& op) { checkCvt1(x, op); opVex(x, 0, op, T_N8 | T_N_VL | T_F3 | T_MAP5 | T_EW0 | T_YMM | T_SAE_Y | T_MUST_EVEX | T_B16, 0x5B); }
-void vcvttph2qq(const Xmm& x, const Operand& op) { if (!op.isXMM() && !op.isMEM()) XBYAK_THROW(ERR_BAD_MEM_SIZE) opVex(x, 0, op, T_N4 | T_N_VL | T_66 | T_MAP5 | T_EW0 | T_YMM | T_SAE_X | T_MUST_EVEX | T_B16, 0x7A); }
-void vcvttph2udq(const Xmm& x, const Operand& op) { checkCvt1(x, op); opVex(x, 0, op, T_N8 | T_N_VL | T_MAP5 | T_EW0 | T_YMM | T_SAE_Y | T_MUST_EVEX | T_B16, 0x78); }
-void vcvttph2uqq(const Xmm& x, const Operand& op) { if (!op.isXMM() && !op.isMEM()) XBYAK_THROW(ERR_BAD_MEM_SIZE) opVex(x, 0, op, T_N4 | T_N_VL | T_66 | T_MAP5 | T_EW0 | T_YMM | T_SAE_X | T_MUST_EVEX | T_B16, 0x78); }
-void vcvttph2uw(const Xmm& x, const Operand& op) { opAVX_X_XM_IMM(x, op, T_MAP5 | T_EW0 | T_YMM | T_SAE_Z | T_MUST_EVEX | T_B16, 0x7C); }
-void vcvttph2w(const Xmm& x, const Operand& op) { opAVX_X_XM_IMM(x, op, T_66 | T_MAP5 | T_EW0 | T_YMM | T_SAE_Z | T_MUST_EVEX | T_B16, 0x7C); }
-void vcvttps2qq(const Xmm& x, const Operand& op) { checkCvt1(x, op); opVex(x, 0, op, T_N8 | T_N_VL | T_66 | T_0F | T_EW0 | T_YMM | T_SAE_Y | T_MUST_EVEX | T_B32, 0x7A); }
-void vcvttps2udq(const Xmm& x, const Operand& op) { opAVX_X_XM_IMM(x, op, T_0F | T_EW0 | T_YMM | T_SAE_Z | T_MUST_EVEX | T_B32, 0x78); }
-void vcvttps2uqq(const Xmm& x, const Operand& op) { checkCvt1(x, op); opVex(x, 0, op, T_N8 | T_N_VL | T_66 | T_0F | T_EW0 | T_YMM | T_SAE_Y | T_MUST_EVEX | T_B32, 0x78); }
-void vcvttsd2usi(const Reg32e& r, const Operand& op) { int type = (T_N8 | T_F2 | T_0F | T_SAE_X | T_MUST_EVEX) | (r.isREG(64) ? T_EW1 : T_EW0); opVex(r, &xm0, op, type, 0x78); }
-void vcvttsh2si(const Reg32e& r, const Operand& op) { int type = (T_N2 | T_F3 | T_MAP5 | T_EW0 | T_SAE_X | T_MUST_EVEX) | (r.isREG(64) ? T_EW1 : T_EW0); opVex(r, &xm0, op, type, 0x2C); }
-void vcvttsh2usi(const Reg32e& r, const Operand& op) { int type = (T_N2 | T_F3 | T_MAP5 | T_EW0 | T_SAE_X | T_MUST_EVEX) | (r.isREG(64) ? T_EW1 : T_EW0); opVex(r, &xm0, op, type, 0x78); }
-void vcvttss2usi(const Reg32e& r, const Operand& op) { int type = (T_N4 | T_F3 | T_0F | T_SAE_X | T_MUST_EVEX) | (r.isREG(64) ? T_EW1 : T_EW0); opVex(r, &xm0, op, type, 0x78); }
-void vcvtudq2pd(const Xmm& x, const Operand& op) { checkCvt1(x, op); opVex(x, 0, op, T_N8 | T_N_VL | T_F3 | T_0F | T_EW0 | T_YMM | T_MUST_EVEX | T_B32, 0x7A); }
-void vcvtudq2ph(const Xmm& x, const Operand& op) { checkCvt4(x, op); opCvt(x, op, T_N16 | T_N_VL | T_F2 | T_MAP5 | T_EW0 | T_ER_Z | T_MUST_EVEX | T_B32, 0x7A); }
-void vcvtudq2ps(const Xmm& x, const Operand& op) { opAVX_X_XM_IMM(x, op, T_F2 | T_0F | T_EW0 | T_YMM | T_ER_Z | T_MUST_EVEX | T_B32, 0x7A); }
-void vcvtuqq2pd(const Xmm& x, const Operand& op) { opAVX_X_XM_IMM(x, op, T_F3 | T_0F | T_EW1 | T_YMM | T_ER_Z | T_MUST_EVEX | T_B64, 0x7A); }
-void vcvtuqq2ph(const Xmm& x, const Operand& op) { opCvt5(x, op, T_N16 | T_N_VL | T_F2 | T_MAP5 | T_EW1 | T_ER_Z | T_MUST_EVEX | T_B64, 0x7A); }
-void vcvtuqq2ps(const Xmm& x, const Operand& op) { opCvt2(x, op, T_F2 | T_0F | T_EW1 | T_YMM | T_ER_Z | T_MUST_EVEX | T_B64, 0x7A); }
-void vcvtusi2sd(const Xmm& x1, const Xmm& x2, const Operand& op) { opCvt3(x1, x2, op, T_F2 | T_0F | T_MUST_EVEX, T_W1 | T_EW1 | T_ER_X | T_N8, T_W0 | T_EW0 | T_N4, 0x7B); }
-void vcvtusi2sh(const Xmm& x1, const Xmm& x2, const Operand& op) { if (!(x1.isXMM() && x2.isXMM() && op.isBit(32|64))) XBYAK_THROW(ERR_BAD_COMBINATION) int type = (T_F3 | T_MAP5 | T_ER_R | T_MUST_EVEX | T_M_K) | (op.isBit(32) ? (T_EW0 | T_N4) : (T_EW1 | T_N8)); opVex(x1, &x2, op, type, 0x7B); }
-void vcvtusi2ss(const Xmm& x1, const Xmm& x2, const Operand& op) { opCvt3(x1, x2, op, T_F3 | T_0F | T_MUST_EVEX | T_ER_X, T_W1 | T_EW1 | T_N8, T_W0 | T_EW0 | T_N4, 0x7B); }
-void vcvtuw2ph(const Xmm& x, const Operand& op) { opAVX_X_XM_IMM(x, op, T_F2 | T_MAP5 | T_EW0 | T_YMM | T_ER_Z | T_MUST_EVEX | T_B16, 0x7D); }
-void vcvtw2ph(const Xmm& x, const Operand& op) { opAVX_X_XM_IMM(x, op, T_F3 | T_MAP5 | T_EW0 | T_YMM | T_ER_Z | T_MUST_EVEX | T_B16, 0x7D); }
-void vdbpsadbw(const Xmm& x1, const Xmm& x2, const Operand& op, uint8_t imm) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F3A | T_EW0 | T_YMM | T_MUST_EVEX, 0x42, imm); }
-void vdivph(const Xmm& xmm, const Operand& op1, const Operand& op2 = Operand()) { opAVX_X_X_XM(xmm, op1, op2, T_MAP5 | T_EW0 | T_YMM | T_MUST_EVEX | T_ER_Z | T_B16, 0x5E); }
-void vdivsh(const Xmm& xmm, const Operand& op1, const Operand& op2 = Operand()) { opAVX_X_X_XM(xmm, op1, op2, T_MAP5 | T_F3 | T_EW0 | T_MUST_EVEX | T_ER_X | T_N2, 0x5E); }
-void vdpbf16ps(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_F3 | T_0F38 | T_EW0 | T_YMM | T_SAE_Z | T_MUST_EVEX | T_B32, 0x52); }
-void vexp2pd(const Zmm& z, const Operand& op) { opAVX_X_XM_IMM(z, op, T_66 | T_0F38 | T_MUST_EVEX | T_YMM | T_EW1 | T_B64 | T_SAE_Z, 0xC8); }
-void vexp2ps(const Zmm& z, const Operand& op) { opAVX_X_XM_IMM(z, op, T_66 | T_0F38 | T_MUST_EVEX | T_YMM | T_EW0 | T_B32 | T_SAE_Z, 0xC8); }
-void vexpandpd(const Xmm& x, const Operand& op) { opAVX_X_XM_IMM(x, op, T_N8 | T_66 | T_0F38 | T_EW1 | T_YMM | T_MUST_EVEX, 0x88); }
-void vexpandps(const Xmm& x, const Operand& op) { opAVX_X_XM_IMM(x, op, T_N4 | T_66 | T_0F38 | T_EW0 | T_YMM | T_MUST_EVEX, 0x88); }
-void vextractf32x4(const Operand& op, const Ymm& r, uint8_t imm) { if (!op.is(Operand::MEM | Operand::XMM)) XBYAK_THROW(ERR_BAD_COMBINATION) opVex(r, 0, op, T_N16 | T_66 | T_0F3A | T_EW0 | T_YMM | T_MUST_EVEX, 0x19, imm); }
-void vextractf32x8(const Operand& op, const Zmm& r, uint8_t imm) { if (!op.is(Operand::MEM | Operand::YMM)) XBYAK_THROW(ERR_BAD_COMBINATION) opVex(r, 0, op, T_N32 | T_66 | T_0F3A | T_EW0 | T_YMM | T_MUST_EVEX, 0x1B, imm); }
-void vextractf64x2(const Operand& op, const Ymm& r, uint8_t imm) { if (!op.is(Operand::MEM | Operand::XMM)) XBYAK_THROW(ERR_BAD_COMBINATION) opVex(r, 0, op, T_N16 | T_66 | T_0F3A | T_EW1 | T_YMM | T_MUST_EVEX, 0x19, imm); }
-void vextractf64x4(const Operand& op, const Zmm& r, uint8_t imm) { if (!op.is(Operand::MEM | Operand::YMM)) XBYAK_THROW(ERR_BAD_COMBINATION) opVex(r, 0, op, T_N32 | T_66 | T_0F3A | T_EW1 | T_YMM | T_MUST_EVEX, 0x1B, imm); }
-void vextracti32x4(const Operand& op, const Ymm& r, uint8_t imm) { if (!op.is(Operand::MEM | Operand::XMM)) XBYAK_THROW(ERR_BAD_COMBINATION) opVex(r, 0, op, T_N16 | T_66 | T_0F3A | T_EW0 | T_YMM | T_MUST_EVEX, 0x39, imm); }
-void vextracti32x8(const Operand& op, const Zmm& r, uint8_t imm) { if (!op.is(Operand::MEM | Operand::YMM)) XBYAK_THROW(ERR_BAD_COMBINATION) opVex(r, 0, op, T_N32 | T_66 | T_0F3A | T_EW0 | T_YMM | T_MUST_EVEX, 0x3B, imm); }
-void vextracti64x2(const Operand& op, const Ymm& r, uint8_t imm) { if (!op.is(Operand::MEM | Operand::XMM)) XBYAK_THROW(ERR_BAD_COMBINATION) opVex(r, 0, op, T_N16 | T_66 | T_0F3A | T_EW1 | T_YMM | T_MUST_EVEX, 0x39, imm); }
-void vextracti64x4(const Operand& op, const Zmm& r, uint8_t imm) { if (!op.is(Operand::MEM | Operand::YMM)) XBYAK_THROW(ERR_BAD_COMBINATION) opVex(r, 0, op, T_N32 | T_66 | T_0F3A | T_EW1 | T_YMM | T_MUST_EVEX, 0x3B, imm); }
-void vfcmaddcph(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_F2 | T_MAP6 | T_EW0 | T_YMM | T_ER_Z | T_MUST_EVEX | T_B32, 0x56); }
-void vfcmulcph(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_F2 | T_MAP6 | T_EW0 | T_YMM | T_ER_Z | T_MUST_EVEX | T_B32, 0xD6); }
-void vfixupimmpd(const Xmm& x1, const Xmm& x2, const Operand& op, uint8_t imm) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F3A | T_EW1 | T_YMM | T_SAE_Z | T_MUST_EVEX | T_B64, 0x54, imm); }
-void vfixupimmps(const Xmm& x1, const Xmm& x2, const Operand& op, uint8_t imm) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F3A | T_EW0 | T_YMM | T_SAE_Z | T_MUST_EVEX | T_B32, 0x54, imm); }
-void vfixupimmsd(const Xmm& x1, const Xmm& x2, const Operand& op, uint8_t imm) { opAVX_X_X_XM(x1, x2, op, T_N8 | T_66 | T_0F3A | T_EW1 | T_SAE_Z | T_MUST_EVEX, 0x55, imm); }
-void vfixupimmss(const Xmm& x1, const Xmm& x2, const Operand& op, uint8_t imm) { opAVX_X_X_XM(x1, x2, op, T_N4 | T_66 | T_0F3A | T_EW0 | T_SAE_Z | T_MUST_EVEX, 0x55, imm); }
-void vfmadd132ph(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_MAP6 | T_EW0 | T_YMM | T_ER_Z | T_MUST_EVEX | T_B16, 0x98); }
-void vfmadd132sh(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_N2 | T_66 | T_MAP6 | T_EW0 | T_ER_X | T_MUST_EVEX, 0x99); }
-void vfmadd213ph(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_MAP6 | T_EW0 | T_YMM | T_ER_Z | T_MUST_EVEX | T_B16, 0xA8); }
-void vfmadd213sh(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_N2 | T_66 | T_MAP6 | T_EW0 | T_ER_X | T_MUST_EVEX, 0xA9); }
-void vfmadd231ph(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_MAP6 | T_EW0 | T_YMM | T_ER_Z | T_MUST_EVEX | T_B16, 0xB8); }
-void vfmadd231sh(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_N2 | T_66 | T_MAP6 | T_EW0 | T_ER_X | T_MUST_EVEX, 0xB9); }
-void vfmaddcph(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_F3 | T_MAP6 | T_EW0 | T_YMM | T_ER_Z | T_MUST_EVEX | T_B32, 0x56); }
-void vfmaddsub132ph(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_MAP6 | T_EW0 | T_YMM | T_ER_Z | T_MUST_EVEX | T_B16, 0x96); }
-void vfmaddsub213ph(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_MAP6 | T_EW0 | T_YMM | T_ER_Z | T_MUST_EVEX | T_B16, 0xA6); }
-void vfmaddsub231ph(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_MAP6 | T_EW0 | T_YMM | T_ER_Z | T_MUST_EVEX | T_B16, 0xB6); }
-void vfmsub132ph(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_MAP6 | T_EW0 | T_YMM | T_ER_Z | T_MUST_EVEX | T_B16, 0x9A); }
-void vfmsub132sh(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_N2 | T_66 | T_MAP6 | T_EW0 | T_ER_X | T_MUST_EVEX, 0x9B); }
-void vfmsub213ph(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_MAP6 | T_EW0 | T_YMM | T_ER_Z | T_MUST_EVEX | T_B16, 0xAA); }
-void vfmsub213sh(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_N2 | T_66 | T_MAP6 | T_EW0 | T_ER_X | T_MUST_EVEX, 0xAB); }
-void vfmsub231ph(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_MAP6 | T_EW0 | T_YMM | T_ER_Z | T_MUST_EVEX | T_B16, 0xBA); }
-void vfmsub231sh(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_N2 | T_66 | T_MAP6 | T_EW0 | T_ER_X | T_MUST_EVEX, 0xBB); }
-void vfmsubadd132ph(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_MAP6 | T_EW0 | T_YMM | T_ER_Z | T_MUST_EVEX | T_B16, 0x97); }
-void vfmsubadd213ph(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_MAP6 | T_EW0 | T_YMM | T_ER_Z | T_MUST_EVEX | T_B16, 0xA7); }
-void vfmsubadd231ph(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_MAP6 | T_EW0 | T_YMM | T_ER_Z | T_MUST_EVEX | T_B16, 0xB7); }
-void vfmulcph(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_F3 | T_MAP6 | T_EW0 | T_YMM | T_ER_Z | T_MUST_EVEX | T_B32, 0xD6); }
-void vfnmadd132ph(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_MAP6 | T_EW0 | T_YMM | T_ER_Z | T_MUST_EVEX | T_B16, 0x9C); }
-void vfnmadd132sh(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_N2 | T_66 | T_MAP6 | T_EW0 | T_ER_X | T_MUST_EVEX, 0x9D); }
-void vfnmadd213ph(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_MAP6 | T_EW0 | T_YMM | T_ER_Z | T_MUST_EVEX | T_B16, 0xAC); }
-void vfnmadd213sh(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_N2 | T_66 | T_MAP6 | T_EW0 | T_ER_X | T_MUST_EVEX, 0xAD); }
-void vfnmadd231ph(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_MAP6 | T_EW0 | T_YMM | T_ER_Z | T_MUST_EVEX | T_B16, 0xBC); }
-void vfnmadd231sh(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_N2 | T_66 | T_MAP6 | T_EW0 | T_ER_X | T_MUST_EVEX, 0xBD); }
-void vfnmsub132ph(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_MAP6 | T_EW0 | T_YMM | T_ER_Z | T_MUST_EVEX | T_B16, 0x9E); }
-void vfnmsub132sh(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_N2 | T_66 | T_MAP6 | T_EW0 | T_ER_X | T_MUST_EVEX, 0x9F); }
-void vfnmsub213ph(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_MAP6 | T_EW0 | T_YMM | T_ER_Z | T_MUST_EVEX | T_B16, 0xAE); }
-void vfnmsub213sh(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_N2 | T_66 | T_MAP6 | T_EW0 | T_ER_X | T_MUST_EVEX, 0xAF); }
-void vfnmsub231ph(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_MAP6 | T_EW0 | T_YMM | T_ER_Z | T_MUST_EVEX | T_B16, 0xBE); }
-void vfnmsub231sh(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_N2 | T_66 | T_MAP6 | T_EW0 | T_ER_X | T_MUST_EVEX, 0xBF); }
-void vfpclasspd(const Opmask& k, const Operand& op, uint8_t imm) { if (!op.isBit(128|256|512)) XBYAK_THROW(ERR_BAD_MEM_SIZE) opVex(k.changeBit(op.getBit()), 0, op, T_66 | T_0F3A | T_MUST_EVEX | T_YMM | T_EW1 | T_B64, 0x66, imm); }
-void vfpclassph(const Opmask& k, const Operand& op, uint8_t imm) { if (!op.isBit(128|256|512)) XBYAK_THROW(ERR_BAD_MEM_SIZE) opVex(k.changeBit(op.getBit()), 0, op, T_0F3A | T_MUST_EVEX | T_YMM | T_EW0 | T_B16, 0x66, imm); }
-void vfpclassps(const Opmask& k, const Operand& op, uint8_t imm) { if (!op.isBit(128|256|512)) XBYAK_THROW(ERR_BAD_MEM_SIZE) opVex(k.changeBit(op.getBit()), 0, op, T_66 | T_0F3A | T_MUST_EVEX | T_YMM | T_EW0 | T_B32, 0x66, imm); }
-void vfpclasssd(const Opmask& k, const Operand& op, uint8_t imm) { if (!op.isXMEM()) XBYAK_THROW(ERR_BAD_MEM_SIZE) opVex(k, 0, op, T_66 | T_0F3A | T_MUST_EVEX | T_EW1 | T_N8, 0x67, imm); }
-void vfpclasssh(const Opmask& k, const Operand& op, uint8_t imm) { if (!op.isXMEM()) XBYAK_THROW(ERR_BAD_MEM_SIZE) opVex(k, 0, op, T_0F3A | T_MUST_EVEX | T_EW0 | T_N2, 0x67, imm); }
-void vfpclassss(const Opmask& k, const Operand& op, uint8_t imm) { if (!op.isXMEM()) XBYAK_THROW(ERR_BAD_MEM_SIZE) opVex(k, 0, op, T_66 | T_0F3A | T_MUST_EVEX | T_EW0 | T_N4, 0x67, imm); }
-void vgatherdpd(const Xmm& x, const Address& addr) { opGather2(x, addr, T_N8 | T_66 | T_0F38 | T_EW1 | T_YMM | T_MUST_EVEX | T_VSIB, 0x92, 1); }
-void vgatherdps(const Xmm& x, const Address& addr) { opGather2(x, addr, T_N4 | T_66 | T_0F38 | T_EW0 | T_YMM | T_MUST_EVEX | T_VSIB, 0x92, 0); }
-void vgatherpf0dpd(const Address& addr) { opGatherFetch(addr, zm1, T_N8 | T_66 | T_0F38 | T_EW1 | T_MUST_EVEX | T_M_K | T_VSIB, 0xC6, Operand::YMM); }
-void vgatherpf0dps(const Address& addr) { opGatherFetch(addr, zm1, T_N4 | T_66 | T_0F38 | T_EW0 | T_MUST_EVEX | T_M_K | T_VSIB, 0xC6, Operand::ZMM); }
-void vgatherpf0qpd(const Address& addr) { opGatherFetch(addr, zm1, T_N8 | T_66 | T_0F38 | T_EW1 | T_MUST_EVEX | T_M_K | T_VSIB, 0xC7, Operand::ZMM); }
-void vgatherpf0qps(const Address& addr) { opGatherFetch(addr, zm1, T_N4 | T_66 | T_0F38 | T_EW0 | T_MUST_EVEX | T_M_K | T_VSIB, 0xC7, Operand::ZMM); }
-void vgatherpf1dpd(const Address& addr) { opGatherFetch(addr, zm2, T_N8 | T_66 | T_0F38 | T_EW1 | T_MUST_EVEX | T_M_K | T_VSIB, 0xC6, Operand::YMM); }
-void vgatherpf1dps(const Address& addr) { opGatherFetch(addr, zm2, T_N4 | T_66 | T_0F38 | T_EW0 | T_MUST_EVEX | T_M_K | T_VSIB, 0xC6, Operand::ZMM); }
-void vgatherpf1qpd(const Address& addr) { opGatherFetch(addr, zm2, T_N8 | T_66 | T_0F38 | T_EW1 | T_MUST_EVEX | T_M_K | T_VSIB, 0xC7, Operand::ZMM); }
-void vgatherpf1qps(const Address& addr) { opGatherFetch(addr, zm2, T_N4 | T_66 | T_0F38 | T_EW0 | T_MUST_EVEX | T_M_K | T_VSIB, 0xC7, Operand::ZMM); }
-void vgatherqpd(const Xmm& x, const Address& addr) { opGather2(x, addr, T_N8 | T_66 | T_0F38 | T_EW1 | T_YMM | T_MUST_EVEX | T_VSIB, 0x93, 0); }
-void vgatherqps(const Xmm& x, const Address& addr) { opGather2(x, addr, T_N4 | T_66 | T_0F38 | T_EW0 | T_YMM | T_MUST_EVEX | T_VSIB, 0x93, 2); }
-void vgetexppd(const Xmm& x, const Operand& op) { opAVX_X_XM_IMM(x, op, T_66 | T_0F38 | T_EW1 | T_YMM | T_SAE_Z | T_MUST_EVEX | T_B64, 0x42); }
-void vgetexpph(const Xmm& x, const Operand& op) { opAVX_X_XM_IMM(x, op, T_66 | T_MAP6 | T_EW0 | T_YMM | T_SAE_Z | T_MUST_EVEX | T_B16, 0x42); }
-void vgetexpps(const Xmm& x, const Operand& op) { opAVX_X_XM_IMM(x, op, T_66 | T_0F38 | T_EW0 | T_YMM | T_SAE_Z | T_MUST_EVEX | T_B32, 0x42); }
-void vgetexpsd(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_N8 | T_66 | T_0F38 | T_EW1 | T_SAE_X | T_MUST_EVEX, 0x43); }
-void vgetexpsh(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_N2 | T_66 | T_MAP6 | T_EW0 | T_SAE_X | T_MUST_EVEX, 0x43); }
-void vgetexpss(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_N4 | T_66 | T_0F38 | T_EW0 | T_SAE_X | T_MUST_EVEX, 0x43); }
-void vgetmantpd(const Xmm& x, const Operand& op, uint8_t imm) { opAVX_X_XM_IMM(x, op, T_66 | T_0F3A | T_EW1 | T_YMM | T_SAE_Z | T_MUST_EVEX | T_B64, 0x26, imm); }
-void vgetmantph(const Xmm& x, const Operand& op, uint8_t imm) { opAVX_X_XM_IMM(x, op, T_0F3A | T_EW0 | T_YMM | T_SAE_Z | T_MUST_EVEX | T_B16, 0x26, imm); }
-void vgetmantps(const Xmm& x, const Operand& op, uint8_t imm) { opAVX_X_XM_IMM(x, op, T_66 | T_0F3A | T_EW0 | T_YMM | T_SAE_Z | T_MUST_EVEX | T_B32, 0x26, imm); }
-void vgetmantsd(const Xmm& x1, const Xmm& x2, const Operand& op, uint8_t imm) { opAVX_X_X_XM(x1, x2, op, T_N8 | T_66 | T_0F3A | T_EW1 | T_SAE_X | T_MUST_EVEX, 0x27, imm); }
-void vgetmantsh(const Xmm& x1, const Xmm& x2, const Operand& op, uint8_t imm) { opAVX_X_X_XM(x1, x2, op, T_N2 | T_0F3A | T_EW0 | T_SAE_X | T_MUST_EVEX, 0x27, imm); }
-void vgetmantss(const Xmm& x1, const Xmm& x2, const Operand& op, uint8_t imm) { opAVX_X_X_XM(x1, x2, op, T_N4 | T_66 | T_0F3A | T_EW0 | T_SAE_X | T_MUST_EVEX, 0x27, imm); }
-void vinsertf32x4(const Ymm& r1, const Ymm& r2, const Operand& op, uint8_t imm) {if (!(r1.getKind() == r2.getKind() && op.is(Operand::MEM | Operand::XMM))) XBYAK_THROW(ERR_BAD_COMBINATION) opVex(r1, &r2, op, T_N16 | T_66 | T_0F3A | T_EW0 | T_YMM | T_MUST_EVEX, 0x18, imm); }
-void vinsertf32x8(const Zmm& r1, const Zmm& r2, const Operand& op, uint8_t imm) {if (!op.is(Operand::MEM | Operand::YMM)) XBYAK_THROW(ERR_BAD_COMBINATION) opVex(r1, &r2, op, T_N32 | T_66 | T_0F3A | T_EW0 | T_YMM | T_MUST_EVEX, 0x1A, imm); }
-void vinsertf64x2(const Ymm& r1, const Ymm& r2, const Operand& op, uint8_t imm) {if (!(r1.getKind() == r2.getKind() && op.is(Operand::MEM | Operand::XMM))) XBYAK_THROW(ERR_BAD_COMBINATION) opVex(r1, &r2, op, T_N16 | T_66 | T_0F3A | T_EW1 | T_YMM | T_MUST_EVEX, 0x18, imm); }
-void vinsertf64x4(const Zmm& r1, const Zmm& r2, const Operand& op, uint8_t imm) {if (!op.is(Operand::MEM | Operand::YMM)) XBYAK_THROW(ERR_BAD_COMBINATION) opVex(r1, &r2, op, T_N32 | T_66 | T_0F3A | T_EW1 | T_YMM | T_MUST_EVEX, 0x1A, imm); }
-void vinserti32x4(const Ymm& r1, const Ymm& r2, const Operand& op, uint8_t imm) {if (!(r1.getKind() == r2.getKind() && op.is(Operand::MEM | Operand::XMM))) XBYAK_THROW(ERR_BAD_COMBINATION) opVex(r1, &r2, op, T_N16 | T_66 | T_0F3A | T_EW0 | T_YMM | T_MUST_EVEX, 0x38, imm); }
-void vinserti32x8(const Zmm& r1, const Zmm& r2, const Operand& op, uint8_t imm) {if (!op.is(Operand::MEM | Operand::YMM)) XBYAK_THROW(ERR_BAD_COMBINATION) opVex(r1, &r2, op, T_N32 | T_66 | T_0F3A | T_EW0 | T_YMM | T_MUST_EVEX, 0x3A, imm); }
-void vinserti64x2(const Ymm& r1, const Ymm& r2, const Operand& op, uint8_t imm) {if (!(r1.getKind() == r2.getKind() && op.is(Operand::MEM | Operand::XMM))) XBYAK_THROW(ERR_BAD_COMBINATION) opVex(r1, &r2, op, T_N16 | T_66 | T_0F3A | T_EW1 | T_YMM | T_MUST_EVEX, 0x38, imm); }
-void vinserti64x4(const Zmm& r1, const Zmm& r2, const Operand& op, uint8_t imm) {if (!op.is(Operand::MEM | Operand::YMM)) XBYAK_THROW(ERR_BAD_COMBINATION) opVex(r1, &r2, op, T_N32 | T_66 | T_0F3A | T_EW1 | T_YMM | T_MUST_EVEX, 0x3A, imm); }
-void vmaxph(const Xmm& xmm, const Operand& op1, const Operand& op2 = Operand()) { opAVX_X_X_XM(xmm, op1, op2, T_MAP5 | T_EW0 | T_YMM | T_MUST_EVEX | T_ER_Z | T_B16, 0x5F); }
-void vmaxsh(const Xmm& xmm, const Operand& op1, const Operand& op2 = Operand()) { opAVX_X_X_XM(xmm, op1, op2, T_MAP5 | T_F3 | T_EW0 | T_MUST_EVEX | T_ER_X | T_N2, 0x5F); }
-void vminph(const Xmm& xmm, const Operand& op1, const Operand& op2 = Operand()) { opAVX_X_X_XM(xmm, op1, op2, T_MAP5 | T_EW0 | T_YMM | T_MUST_EVEX | T_ER_Z | T_B16, 0x5D); }
-void vminsh(const Xmm& xmm, const Operand& op1, const Operand& op2 = Operand()) { opAVX_X_X_XM(xmm, op1, op2, T_MAP5 | T_F3 | T_EW0 | T_MUST_EVEX | T_ER_X | T_N2, 0x5D); }
-void vmovdqa32(const Address& addr, const Xmm& x) { opAVX_X_XM_IMM(x, addr, T_66 | T_0F | T_EW0 | T_YMM | T_ER_X | T_ER_Y | T_ER_Z | T_MUST_EVEX | T_M_K, 0x7F); }
-void vmovdqa32(const Xmm& x, const Operand& op) { opAVX_X_XM_IMM(x, op, T_66 | T_0F | T_EW0 | T_YMM | T_ER_X | T_ER_Y | T_ER_Z | T_MUST_EVEX, 0x6F); }
-void vmovdqa64(const Address& addr, const Xmm& x) { opAVX_X_XM_IMM(x, addr, T_66 | T_0F | T_EW1 | T_YMM | T_ER_X | T_ER_Y | T_ER_Z | T_MUST_EVEX | T_M_K, 0x7F); }
-void vmovdqa64(const Xmm& x, const Operand& op) { opAVX_X_XM_IMM(x, op, T_66 | T_0F | T_EW1 | T_YMM | T_ER_X | T_ER_Y | T_ER_Z | T_MUST_EVEX, 0x6F); }
-void vmovdqu16(const Address& addr, const Xmm& x) { opAVX_X_XM_IMM(x, addr, T_F2 | T_0F | T_EW1 | T_YMM | T_ER_X | T_ER_Y | T_ER_Z | T_MUST_EVEX | T_M_K, 0x7F); }
-void vmovdqu16(const Xmm& x, const Operand& op) { opAVX_X_XM_IMM(x, op, T_F2 | T_0F | T_EW1 | T_YMM | T_ER_X | T_ER_Y | T_ER_Z | T_MUST_EVEX, 0x6F); }
-void vmovdqu32(const Address& addr, const Xmm& x) { opAVX_X_XM_IMM(x, addr, T_F3 | T_0F | T_EW0 | T_YMM | T_ER_X | T_ER_Y | T_ER_Z | T_MUST_EVEX | T_M_K, 0x7F); }
-void vmovdqu32(const Xmm& x, const Operand& op) { opAVX_X_XM_IMM(x, op, T_F3 | T_0F | T_EW0 | T_YMM | T_ER_X | T_ER_Y | T_ER_Z | T_MUST_EVEX, 0x6F); }
-void vmovdqu64(const Address& addr, const Xmm& x) { opAVX_X_XM_IMM(x, addr, T_F3 | T_0F | T_EW1 | T_YMM | T_ER_X | T_ER_Y | T_ER_Z | T_MUST_EVEX | T_M_K, 0x7F); }
-void vmovdqu64(const Xmm& x, const Operand& op) { opAVX_X_XM_IMM(x, op, T_F3 | T_0F | T_EW1 | T_YMM | T_ER_X | T_ER_Y | T_ER_Z | T_MUST_EVEX, 0x6F); }
-void vmovdqu8(const Address& addr, const Xmm& x) { opAVX_X_XM_IMM(x, addr, T_F2 | T_0F | T_EW0 | T_YMM | T_ER_X | T_ER_Y | T_ER_Z | T_MUST_EVEX | T_M_K, 0x7F); }
-void vmovdqu8(const Xmm& x, const Operand& op) { opAVX_X_XM_IMM(x, op, T_F2 | T_0F | T_EW0 | T_YMM | T_ER_X | T_ER_Y | T_ER_Z | T_MUST_EVEX, 0x6F); }
-void vmovsh(const Address& addr, const Xmm& x) { opAVX_X_XM_IMM(x, addr, T_N2 | T_F3 | T_MAP5 | T_EW0 | T_MUST_EVEX | T_M_K, 0x11); }
-void vmovsh(const Xmm& x, const Address& addr) { opAVX_X_X_XM(x, xm0, addr, T_N2 | T_F3 | T_MAP5 | T_EW0 | T_MUST_EVEX, 0x10); }
-void vmovsh(const Xmm& x1, const Xmm& x2, const Xmm& x3) { opAVX_X_X_XM(x1, x2, x3, T_N2 | T_F3 | T_MAP5 | T_EW0 | T_MUST_EVEX, 0x10); }
+void vcomish(const Xmm& x, const Operand& op) {
+  opAVX_X_XM_IMM(x, op, T_MAP5 | T_MUST_EVEX | T_EW0 | T_SAE_X | T_N2, 0x2F);
+}
+void vcompressb(const Operand& op, const Xmm& x) {
+  opAVX_X_XM_IMM(x, op, T_N1 | T_66 | T_0F38 | T_EW0 | T_YMM | T_MUST_EVEX, 0x63);
+}
+void vcompresspd(const Operand& op, const Xmm& x) {
+  opAVX_X_XM_IMM(x, op, T_N8 | T_66 | T_0F38 | T_EW1 | T_YMM | T_MUST_EVEX, 0x8A);
+}
+void vcompressps(const Operand& op, const Xmm& x) {
+  opAVX_X_XM_IMM(x, op, T_N4 | T_66 | T_0F38 | T_EW0 | T_YMM | T_MUST_EVEX, 0x8A);
+}
+void vcompressw(const Operand& op, const Xmm& x) {
+  opAVX_X_XM_IMM(x, op, T_N2 | T_66 | T_0F38 | T_EW1 | T_YMM | T_MUST_EVEX, 0x63);
+}
+void vcvtdq2ph(const Xmm& x, const Operand& op) {
+  checkCvt4(x, op);
+  opCvt(x, op, T_N16 | T_N_VL | T_MAP5 | T_EW0 | T_YMM | T_ER_Z | T_MUST_EVEX | T_B32, 0x5B);
+}
+void vcvtne2ps2bf16(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_F2 | T_0F38 | T_EW0 | T_YMM | T_SAE_Z | T_MUST_EVEX | T_B32, 0x72);
+}
+void vcvtpd2ph(const Xmm& x, const Operand& op) {
+  opCvt5(x, op, T_N16 | T_N_VL | T_66 | T_MAP5 | T_EW1 | T_ER_Z | T_MUST_EVEX | T_B64, 0x5A);
+}
+void vcvtpd2qq(const Xmm& x, const Operand& op) {
+  opAVX_X_XM_IMM(x, op, T_66 | T_0F | T_EW1 | T_YMM | T_ER_Z | T_MUST_EVEX | T_B64, 0x7B);
+}
+void vcvtpd2udq(const Xmm& x, const Operand& op) {
+  opCvt2(x, op, T_0F | T_EW1 | T_YMM | T_ER_Z | T_MUST_EVEX | T_B64, 0x79);
+}
+void vcvtpd2uqq(const Xmm& x, const Operand& op) {
+  opAVX_X_XM_IMM(x, op, T_66 | T_0F | T_EW1 | T_YMM | T_ER_Z | T_MUST_EVEX | T_B64, 0x79);
+}
+void vcvtph2dq(const Xmm& x, const Operand& op) {
+  checkCvt1(x, op);
+  opVex(x, 0, op, T_N8 | T_N_VL | T_66 | T_MAP5 | T_EW0 | T_YMM | T_ER_Y | T_MUST_EVEX | T_B16, 0x5B);
+}
+void vcvtph2pd(const Xmm& x, const Operand& op) {
+  if (!op.isXMM() && !op.isMEM())
+    XBYAK_THROW(ERR_BAD_MEM_SIZE)
+    opVex(x, 0, op, T_N4 | T_N_VL | T_MAP5 | T_EW0 | T_YMM | T_SAE_X | T_MUST_EVEX | T_B16, 0x5A);
+}
+void vcvtph2psx(const Xmm& x, const Operand& op) {
+  checkCvt1(x, op);
+  opVex(x, 0, op, T_N8 | T_N_VL | T_66 | T_MAP6 | T_EW0 | T_YMM | T_SAE_Y | T_MUST_EVEX | T_B16, 0x13);
+}
+void vcvtph2qq(const Xmm& x, const Operand& op) {
+  if (!op.isXMM() && !op.isMEM())
+    XBYAK_THROW(ERR_BAD_MEM_SIZE)
+    opVex(x, 0, op, T_N4 | T_N_VL | T_66 | T_MAP5 | T_EW0 | T_YMM | T_ER_X | T_MUST_EVEX | T_B16, 0x7B);
+}
+void vcvtph2udq(const Xmm& x, const Operand& op) {
+  checkCvt1(x, op);
+  opVex(x, 0, op, T_N8 | T_N_VL | T_MAP5 | T_EW0 | T_YMM | T_ER_Y | T_MUST_EVEX | T_B16, 0x79);
+}
+void vcvtph2uqq(const Xmm& x, const Operand& op) {
+  if (!op.isXMM() && !op.isMEM())
+    XBYAK_THROW(ERR_BAD_MEM_SIZE)
+    opVex(x, 0, op, T_N4 | T_N_VL | T_66 | T_MAP5 | T_EW0 | T_YMM | T_ER_X | T_MUST_EVEX | T_B16, 0x79);
+}
+void vcvtph2uw(const Xmm& x, const Operand& op) {
+  opAVX_X_XM_IMM(x, op, T_MAP5 | T_EW0 | T_YMM | T_ER_Z | T_MUST_EVEX | T_B16, 0x7D);
+}
+void vcvtph2w(const Xmm& x, const Operand& op) {
+  opAVX_X_XM_IMM(x, op, T_66 | T_MAP5 | T_EW0 | T_YMM | T_ER_Z | T_MUST_EVEX | T_B16, 0x7D);
+}
+void vcvtps2phx(const Xmm& x, const Operand& op) {
+  checkCvt4(x, op);
+  opCvt(x, op, T_N16 | T_N_VL | T_66 | T_MAP5 | T_EW0 | T_ER_Z | T_MUST_EVEX | T_B32, 0x1D);
+}
+void vcvtps2qq(const Xmm& x, const Operand& op) {
+  checkCvt1(x, op);
+  opVex(x, 0, op, T_N8 | T_N_VL | T_66 | T_0F | T_EW0 | T_YMM | T_ER_Y | T_MUST_EVEX | T_B32, 0x7B);
+}
+void vcvtps2udq(const Xmm& x, const Operand& op) {
+  opAVX_X_XM_IMM(x, op, T_0F | T_EW0 | T_YMM | T_ER_Z | T_MUST_EVEX | T_B32, 0x79);
+}
+void vcvtps2uqq(const Xmm& x, const Operand& op) {
+  checkCvt1(x, op);
+  opVex(x, 0, op, T_N8 | T_N_VL | T_66 | T_0F | T_EW0 | T_YMM | T_ER_Y | T_MUST_EVEX | T_B32, 0x79);
+}
+void vcvtqq2pd(const Xmm& x, const Operand& op) {
+  opAVX_X_XM_IMM(x, op, T_F3 | T_0F | T_EW1 | T_YMM | T_ER_Z | T_MUST_EVEX | T_B64, 0xE6);
+}
+void vcvtqq2ph(const Xmm& x, const Operand& op) {
+  opCvt5(x, op, T_N16 | T_N_VL | T_MAP5 | T_EW1 | T_ER_Z | T_MUST_EVEX | T_B64, 0x5B);
+}
+void vcvtqq2ps(const Xmm& x, const Operand& op) {
+  opCvt2(x, op, T_0F | T_EW1 | T_YMM | T_ER_Z | T_MUST_EVEX | T_B64, 0x5B);
+}
+void vcvtsd2sh(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_N8 | T_F2 | T_MAP5 | T_EW1 | T_ER_X | T_MUST_EVEX, 0x5A);
+}
+void vcvtsd2usi(const Reg32e& r, const Operand& op) {
+  int type = (T_N8 | T_F2 | T_0F | T_ER_X | T_MUST_EVEX) | (r.isREG(64) ? T_EW1 : T_EW0);
+  opVex(r, &xm0, op, type, 0x79);
+}
+void vcvtsh2sd(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_N2 | T_F3 | T_MAP5 | T_EW0 | T_SAE_X | T_MUST_EVEX, 0x5A);
+}
+void vcvtsh2si(const Reg32e& r, const Operand& op) {
+  int type = (T_N2 | T_F3 | T_MAP5 | T_ER_X | T_MUST_EVEX) | (r.isREG(64) ? T_EW1 : T_EW0);
+  opVex(r, &xm0, op, type, 0x2D);
+}
+void vcvtsh2ss(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_N2 | T_MAP6 | T_EW0 | T_SAE_X | T_MUST_EVEX, 0x13);
+}
+void vcvtsh2usi(const Reg32e& r, const Operand& op) {
+  int type = (T_N2 | T_F3 | T_MAP5 | T_ER_X | T_MUST_EVEX) | (r.isREG(64) ? T_EW1 : T_EW0);
+  opVex(r, &xm0, op, type, 0x79);
+}
+void vcvtsi2sh(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  if (!(x1.isXMM() && x2.isXMM() && op.isBit(32 | 64)))
+    XBYAK_THROW(ERR_BAD_COMBINATION)
+    int type = (T_F3 | T_MAP5 | T_ER_R | T_MUST_EVEX | T_M_K) | (op.isBit(32) ? (T_EW0 | T_N4) : (T_EW1 | T_N8));
+  opVex(x1, &x2, op, type, 0x2A);
+}
+void vcvtss2sh(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_N4 | T_MAP5 | T_EW0 | T_ER_X | T_MUST_EVEX, 0x1D);
+}
+void vcvtss2usi(const Reg32e& r, const Operand& op) {
+  int type = (T_N4 | T_F3 | T_0F | T_ER_X | T_MUST_EVEX) | (r.isREG(64) ? T_EW1 : T_EW0);
+  opVex(r, &xm0, op, type, 0x79);
+}
+void vcvttpd2qq(const Xmm& x, const Operand& op) {
+  opAVX_X_XM_IMM(x, op, T_66 | T_0F | T_EW1 | T_YMM | T_SAE_Z | T_MUST_EVEX | T_B64, 0x7A);
+}
+void vcvttpd2udq(const Xmm& x, const Operand& op) {
+  opCvt2(x, op, T_0F | T_EW1 | T_YMM | T_SAE_Z | T_MUST_EVEX | T_B64, 0x78);
+}
+void vcvttpd2uqq(const Xmm& x, const Operand& op) {
+  opAVX_X_XM_IMM(x, op, T_66 | T_0F | T_EW1 | T_YMM | T_SAE_Z | T_MUST_EVEX | T_B64, 0x78);
+}
+void vcvttph2dq(const Xmm& x, const Operand& op) {
+  checkCvt1(x, op);
+  opVex(x, 0, op, T_N8 | T_N_VL | T_F3 | T_MAP5 | T_EW0 | T_YMM | T_SAE_Y | T_MUST_EVEX | T_B16, 0x5B);
+}
+void vcvttph2qq(const Xmm& x, const Operand& op) {
+  if (!op.isXMM() && !op.isMEM())
+    XBYAK_THROW(ERR_BAD_MEM_SIZE)
+    opVex(x, 0, op, T_N4 | T_N_VL | T_66 | T_MAP5 | T_EW0 | T_YMM | T_SAE_X | T_MUST_EVEX | T_B16, 0x7A);
+}
+void vcvttph2udq(const Xmm& x, const Operand& op) {
+  checkCvt1(x, op);
+  opVex(x, 0, op, T_N8 | T_N_VL | T_MAP5 | T_EW0 | T_YMM | T_SAE_Y | T_MUST_EVEX | T_B16, 0x78);
+}
+void vcvttph2uqq(const Xmm& x, const Operand& op) {
+  if (!op.isXMM() && !op.isMEM())
+    XBYAK_THROW(ERR_BAD_MEM_SIZE)
+    opVex(x, 0, op, T_N4 | T_N_VL | T_66 | T_MAP5 | T_EW0 | T_YMM | T_SAE_X | T_MUST_EVEX | T_B16, 0x78);
+}
+void vcvttph2uw(const Xmm& x, const Operand& op) {
+  opAVX_X_XM_IMM(x, op, T_MAP5 | T_EW0 | T_YMM | T_SAE_Z | T_MUST_EVEX | T_B16, 0x7C);
+}
+void vcvttph2w(const Xmm& x, const Operand& op) {
+  opAVX_X_XM_IMM(x, op, T_66 | T_MAP5 | T_EW0 | T_YMM | T_SAE_Z | T_MUST_EVEX | T_B16, 0x7C);
+}
+void vcvttps2qq(const Xmm& x, const Operand& op) {
+  checkCvt1(x, op);
+  opVex(x, 0, op, T_N8 | T_N_VL | T_66 | T_0F | T_EW0 | T_YMM | T_SAE_Y | T_MUST_EVEX | T_B32, 0x7A);
+}
+void vcvttps2udq(const Xmm& x, const Operand& op) {
+  opAVX_X_XM_IMM(x, op, T_0F | T_EW0 | T_YMM | T_SAE_Z | T_MUST_EVEX | T_B32, 0x78);
+}
+void vcvttps2uqq(const Xmm& x, const Operand& op) {
+  checkCvt1(x, op);
+  opVex(x, 0, op, T_N8 | T_N_VL | T_66 | T_0F | T_EW0 | T_YMM | T_SAE_Y | T_MUST_EVEX | T_B32, 0x78);
+}
+void vcvttsd2usi(const Reg32e& r, const Operand& op) {
+  int type = (T_N8 | T_F2 | T_0F | T_SAE_X | T_MUST_EVEX) | (r.isREG(64) ? T_EW1 : T_EW0);
+  opVex(r, &xm0, op, type, 0x78);
+}
+void vcvttsh2si(const Reg32e& r, const Operand& op) {
+  int type = (T_N2 | T_F3 | T_MAP5 | T_EW0 | T_SAE_X | T_MUST_EVEX) | (r.isREG(64) ? T_EW1 : T_EW0);
+  opVex(r, &xm0, op, type, 0x2C);
+}
+void vcvttsh2usi(const Reg32e& r, const Operand& op) {
+  int type = (T_N2 | T_F3 | T_MAP5 | T_EW0 | T_SAE_X | T_MUST_EVEX) | (r.isREG(64) ? T_EW1 : T_EW0);
+  opVex(r, &xm0, op, type, 0x78);
+}
+void vcvttss2usi(const Reg32e& r, const Operand& op) {
+  int type = (T_N4 | T_F3 | T_0F | T_SAE_X | T_MUST_EVEX) | (r.isREG(64) ? T_EW1 : T_EW0);
+  opVex(r, &xm0, op, type, 0x78);
+}
+void vcvtudq2pd(const Xmm& x, const Operand& op) {
+  checkCvt1(x, op);
+  opVex(x, 0, op, T_N8 | T_N_VL | T_F3 | T_0F | T_EW0 | T_YMM | T_MUST_EVEX | T_B32, 0x7A);
+}
+void vcvtudq2ph(const Xmm& x, const Operand& op) {
+  checkCvt4(x, op);
+  opCvt(x, op, T_N16 | T_N_VL | T_F2 | T_MAP5 | T_EW0 | T_ER_Z | T_MUST_EVEX | T_B32, 0x7A);
+}
+void vcvtudq2ps(const Xmm& x, const Operand& op) {
+  opAVX_X_XM_IMM(x, op, T_F2 | T_0F | T_EW0 | T_YMM | T_ER_Z | T_MUST_EVEX | T_B32, 0x7A);
+}
+void vcvtuqq2pd(const Xmm& x, const Operand& op) {
+  opAVX_X_XM_IMM(x, op, T_F3 | T_0F | T_EW1 | T_YMM | T_ER_Z | T_MUST_EVEX | T_B64, 0x7A);
+}
+void vcvtuqq2ph(const Xmm& x, const Operand& op) {
+  opCvt5(x, op, T_N16 | T_N_VL | T_F2 | T_MAP5 | T_EW1 | T_ER_Z | T_MUST_EVEX | T_B64, 0x7A);
+}
+void vcvtuqq2ps(const Xmm& x, const Operand& op) {
+  opCvt2(x, op, T_F2 | T_0F | T_EW1 | T_YMM | T_ER_Z | T_MUST_EVEX | T_B64, 0x7A);
+}
+void vcvtusi2sd(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opCvt3(x1, x2, op, T_F2 | T_0F | T_MUST_EVEX, T_W1 | T_EW1 | T_ER_X | T_N8, T_W0 | T_EW0 | T_N4, 0x7B);
+}
+void vcvtusi2sh(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  if (!(x1.isXMM() && x2.isXMM() && op.isBit(32 | 64)))
+    XBYAK_THROW(ERR_BAD_COMBINATION)
+    int type = (T_F3 | T_MAP5 | T_ER_R | T_MUST_EVEX | T_M_K) | (op.isBit(32) ? (T_EW0 | T_N4) : (T_EW1 | T_N8));
+  opVex(x1, &x2, op, type, 0x7B);
+}
+void vcvtusi2ss(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opCvt3(x1, x2, op, T_F3 | T_0F | T_MUST_EVEX | T_ER_X, T_W1 | T_EW1 | T_N8, T_W0 | T_EW0 | T_N4, 0x7B);
+}
+void vcvtuw2ph(const Xmm& x, const Operand& op) {
+  opAVX_X_XM_IMM(x, op, T_F2 | T_MAP5 | T_EW0 | T_YMM | T_ER_Z | T_MUST_EVEX | T_B16, 0x7D);
+}
+void vcvtw2ph(const Xmm& x, const Operand& op) {
+  opAVX_X_XM_IMM(x, op, T_F3 | T_MAP5 | T_EW0 | T_YMM | T_ER_Z | T_MUST_EVEX | T_B16, 0x7D);
+}
+void vdbpsadbw(const Xmm& x1, const Xmm& x2, const Operand& op, uint8_t imm) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F3A | T_EW0 | T_YMM | T_MUST_EVEX, 0x42, imm);
+}
+void vdivph(const Xmm& xmm, const Operand& op1, const Operand& op2 = Operand()) {
+  opAVX_X_X_XM(xmm, op1, op2, T_MAP5 | T_EW0 | T_YMM | T_MUST_EVEX | T_ER_Z | T_B16, 0x5E);
+}
+void vdivsh(const Xmm& xmm, const Operand& op1, const Operand& op2 = Operand()) {
+  opAVX_X_X_XM(xmm, op1, op2, T_MAP5 | T_F3 | T_EW0 | T_MUST_EVEX | T_ER_X | T_N2, 0x5E);
+}
+void vdpbf16ps(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_F3 | T_0F38 | T_EW0 | T_YMM | T_SAE_Z | T_MUST_EVEX | T_B32, 0x52);
+}
+void vexp2pd(const Zmm& z, const Operand& op) {
+  opAVX_X_XM_IMM(z, op, T_66 | T_0F38 | T_MUST_EVEX | T_YMM | T_EW1 | T_B64 | T_SAE_Z, 0xC8);
+}
+void vexp2ps(const Zmm& z, const Operand& op) {
+  opAVX_X_XM_IMM(z, op, T_66 | T_0F38 | T_MUST_EVEX | T_YMM | T_EW0 | T_B32 | T_SAE_Z, 0xC8);
+}
+void vexpandpd(const Xmm& x, const Operand& op) {
+  opAVX_X_XM_IMM(x, op, T_N8 | T_66 | T_0F38 | T_EW1 | T_YMM | T_MUST_EVEX, 0x88);
+}
+void vexpandps(const Xmm& x, const Operand& op) {
+  opAVX_X_XM_IMM(x, op, T_N4 | T_66 | T_0F38 | T_EW0 | T_YMM | T_MUST_EVEX, 0x88);
+}
+void vextractf32x4(const Operand& op, const Ymm& r, uint8_t imm) {
+  if (!op.is(Operand::MEM | Operand::XMM))
+    XBYAK_THROW(ERR_BAD_COMBINATION) opVex(r, 0, op, T_N16 | T_66 | T_0F3A | T_EW0 | T_YMM | T_MUST_EVEX, 0x19, imm);
+}
+void vextractf32x8(const Operand& op, const Zmm& r, uint8_t imm) {
+  if (!op.is(Operand::MEM | Operand::YMM))
+    XBYAK_THROW(ERR_BAD_COMBINATION) opVex(r, 0, op, T_N32 | T_66 | T_0F3A | T_EW0 | T_YMM | T_MUST_EVEX, 0x1B, imm);
+}
+void vextractf64x2(const Operand& op, const Ymm& r, uint8_t imm) {
+  if (!op.is(Operand::MEM | Operand::XMM))
+    XBYAK_THROW(ERR_BAD_COMBINATION) opVex(r, 0, op, T_N16 | T_66 | T_0F3A | T_EW1 | T_YMM | T_MUST_EVEX, 0x19, imm);
+}
+void vextractf64x4(const Operand& op, const Zmm& r, uint8_t imm) {
+  if (!op.is(Operand::MEM | Operand::YMM))
+    XBYAK_THROW(ERR_BAD_COMBINATION) opVex(r, 0, op, T_N32 | T_66 | T_0F3A | T_EW1 | T_YMM | T_MUST_EVEX, 0x1B, imm);
+}
+void vextracti32x4(const Operand& op, const Ymm& r, uint8_t imm) {
+  if (!op.is(Operand::MEM | Operand::XMM))
+    XBYAK_THROW(ERR_BAD_COMBINATION) opVex(r, 0, op, T_N16 | T_66 | T_0F3A | T_EW0 | T_YMM | T_MUST_EVEX, 0x39, imm);
+}
+void vextracti32x8(const Operand& op, const Zmm& r, uint8_t imm) {
+  if (!op.is(Operand::MEM | Operand::YMM))
+    XBYAK_THROW(ERR_BAD_COMBINATION) opVex(r, 0, op, T_N32 | T_66 | T_0F3A | T_EW0 | T_YMM | T_MUST_EVEX, 0x3B, imm);
+}
+void vextracti64x2(const Operand& op, const Ymm& r, uint8_t imm) {
+  if (!op.is(Operand::MEM | Operand::XMM))
+    XBYAK_THROW(ERR_BAD_COMBINATION) opVex(r, 0, op, T_N16 | T_66 | T_0F3A | T_EW1 | T_YMM | T_MUST_EVEX, 0x39, imm);
+}
+void vextracti64x4(const Operand& op, const Zmm& r, uint8_t imm) {
+  if (!op.is(Operand::MEM | Operand::YMM))
+    XBYAK_THROW(ERR_BAD_COMBINATION) opVex(r, 0, op, T_N32 | T_66 | T_0F3A | T_EW1 | T_YMM | T_MUST_EVEX, 0x3B, imm);
+}
+void vfcmaddcph(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_F2 | T_MAP6 | T_EW0 | T_YMM | T_ER_Z | T_MUST_EVEX | T_B32, 0x56);
+}
+void vfcmulcph(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_F2 | T_MAP6 | T_EW0 | T_YMM | T_ER_Z | T_MUST_EVEX | T_B32, 0xD6);
+}
+void vfixupimmpd(const Xmm& x1, const Xmm& x2, const Operand& op, uint8_t imm) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F3A | T_EW1 | T_YMM | T_SAE_Z | T_MUST_EVEX | T_B64, 0x54, imm);
+}
+void vfixupimmps(const Xmm& x1, const Xmm& x2, const Operand& op, uint8_t imm) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F3A | T_EW0 | T_YMM | T_SAE_Z | T_MUST_EVEX | T_B32, 0x54, imm);
+}
+void vfixupimmsd(const Xmm& x1, const Xmm& x2, const Operand& op, uint8_t imm) {
+  opAVX_X_X_XM(x1, x2, op, T_N8 | T_66 | T_0F3A | T_EW1 | T_SAE_Z | T_MUST_EVEX, 0x55, imm);
+}
+void vfixupimmss(const Xmm& x1, const Xmm& x2, const Operand& op, uint8_t imm) {
+  opAVX_X_X_XM(x1, x2, op, T_N4 | T_66 | T_0F3A | T_EW0 | T_SAE_Z | T_MUST_EVEX, 0x55, imm);
+}
+void vfmadd132ph(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_MAP6 | T_EW0 | T_YMM | T_ER_Z | T_MUST_EVEX | T_B16, 0x98);
+}
+void vfmadd132sh(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_N2 | T_66 | T_MAP6 | T_EW0 | T_ER_X | T_MUST_EVEX, 0x99);
+}
+void vfmadd213ph(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_MAP6 | T_EW0 | T_YMM | T_ER_Z | T_MUST_EVEX | T_B16, 0xA8);
+}
+void vfmadd213sh(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_N2 | T_66 | T_MAP6 | T_EW0 | T_ER_X | T_MUST_EVEX, 0xA9);
+}
+void vfmadd231ph(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_MAP6 | T_EW0 | T_YMM | T_ER_Z | T_MUST_EVEX | T_B16, 0xB8);
+}
+void vfmadd231sh(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_N2 | T_66 | T_MAP6 | T_EW0 | T_ER_X | T_MUST_EVEX, 0xB9);
+}
+void vfmaddcph(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_F3 | T_MAP6 | T_EW0 | T_YMM | T_ER_Z | T_MUST_EVEX | T_B32, 0x56);
+}
+void vfmaddsub132ph(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_MAP6 | T_EW0 | T_YMM | T_ER_Z | T_MUST_EVEX | T_B16, 0x96);
+}
+void vfmaddsub213ph(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_MAP6 | T_EW0 | T_YMM | T_ER_Z | T_MUST_EVEX | T_B16, 0xA6);
+}
+void vfmaddsub231ph(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_MAP6 | T_EW0 | T_YMM | T_ER_Z | T_MUST_EVEX | T_B16, 0xB6);
+}
+void vfmsub132ph(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_MAP6 | T_EW0 | T_YMM | T_ER_Z | T_MUST_EVEX | T_B16, 0x9A);
+}
+void vfmsub132sh(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_N2 | T_66 | T_MAP6 | T_EW0 | T_ER_X | T_MUST_EVEX, 0x9B);
+}
+void vfmsub213ph(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_MAP6 | T_EW0 | T_YMM | T_ER_Z | T_MUST_EVEX | T_B16, 0xAA);
+}
+void vfmsub213sh(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_N2 | T_66 | T_MAP6 | T_EW0 | T_ER_X | T_MUST_EVEX, 0xAB);
+}
+void vfmsub231ph(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_MAP6 | T_EW0 | T_YMM | T_ER_Z | T_MUST_EVEX | T_B16, 0xBA);
+}
+void vfmsub231sh(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_N2 | T_66 | T_MAP6 | T_EW0 | T_ER_X | T_MUST_EVEX, 0xBB);
+}
+void vfmsubadd132ph(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_MAP6 | T_EW0 | T_YMM | T_ER_Z | T_MUST_EVEX | T_B16, 0x97);
+}
+void vfmsubadd213ph(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_MAP6 | T_EW0 | T_YMM | T_ER_Z | T_MUST_EVEX | T_B16, 0xA7);
+}
+void vfmsubadd231ph(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_MAP6 | T_EW0 | T_YMM | T_ER_Z | T_MUST_EVEX | T_B16, 0xB7);
+}
+void vfmulcph(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_F3 | T_MAP6 | T_EW0 | T_YMM | T_ER_Z | T_MUST_EVEX | T_B32, 0xD6);
+}
+void vfnmadd132ph(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_MAP6 | T_EW0 | T_YMM | T_ER_Z | T_MUST_EVEX | T_B16, 0x9C);
+}
+void vfnmadd132sh(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_N2 | T_66 | T_MAP6 | T_EW0 | T_ER_X | T_MUST_EVEX, 0x9D);
+}
+void vfnmadd213ph(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_MAP6 | T_EW0 | T_YMM | T_ER_Z | T_MUST_EVEX | T_B16, 0xAC);
+}
+void vfnmadd213sh(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_N2 | T_66 | T_MAP6 | T_EW0 | T_ER_X | T_MUST_EVEX, 0xAD);
+}
+void vfnmadd231ph(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_MAP6 | T_EW0 | T_YMM | T_ER_Z | T_MUST_EVEX | T_B16, 0xBC);
+}
+void vfnmadd231sh(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_N2 | T_66 | T_MAP6 | T_EW0 | T_ER_X | T_MUST_EVEX, 0xBD);
+}
+void vfnmsub132ph(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_MAP6 | T_EW0 | T_YMM | T_ER_Z | T_MUST_EVEX | T_B16, 0x9E);
+}
+void vfnmsub132sh(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_N2 | T_66 | T_MAP6 | T_EW0 | T_ER_X | T_MUST_EVEX, 0x9F);
+}
+void vfnmsub213ph(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_MAP6 | T_EW0 | T_YMM | T_ER_Z | T_MUST_EVEX | T_B16, 0xAE);
+}
+void vfnmsub213sh(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_N2 | T_66 | T_MAP6 | T_EW0 | T_ER_X | T_MUST_EVEX, 0xAF);
+}
+void vfnmsub231ph(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_MAP6 | T_EW0 | T_YMM | T_ER_Z | T_MUST_EVEX | T_B16, 0xBE);
+}
+void vfnmsub231sh(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_N2 | T_66 | T_MAP6 | T_EW0 | T_ER_X | T_MUST_EVEX, 0xBF);
+}
+void vfpclasspd(const Opmask& k, const Operand& op, uint8_t imm) {
+  if (!op.isBit(128 | 256 | 512))
+    XBYAK_THROW(ERR_BAD_MEM_SIZE)
+    opVex(k.changeBit(op.getBit()), 0, op, T_66 | T_0F3A | T_MUST_EVEX | T_YMM | T_EW1 | T_B64, 0x66, imm);
+}
+void vfpclassph(const Opmask& k, const Operand& op, uint8_t imm) {
+  if (!op.isBit(128 | 256 | 512))
+    XBYAK_THROW(ERR_BAD_MEM_SIZE)
+    opVex(k.changeBit(op.getBit()), 0, op, T_0F3A | T_MUST_EVEX | T_YMM | T_EW0 | T_B16, 0x66, imm);
+}
+void vfpclassps(const Opmask& k, const Operand& op, uint8_t imm) {
+  if (!op.isBit(128 | 256 | 512))
+    XBYAK_THROW(ERR_BAD_MEM_SIZE)
+    opVex(k.changeBit(op.getBit()), 0, op, T_66 | T_0F3A | T_MUST_EVEX | T_YMM | T_EW0 | T_B32, 0x66, imm);
+}
+void vfpclasssd(const Opmask& k, const Operand& op, uint8_t imm) {
+  if (!op.isXMEM())
+    XBYAK_THROW(ERR_BAD_MEM_SIZE) opVex(k, 0, op, T_66 | T_0F3A | T_MUST_EVEX | T_EW1 | T_N8, 0x67, imm);
+}
+void vfpclasssh(const Opmask& k, const Operand& op, uint8_t imm) {
+  if (!op.isXMEM()) XBYAK_THROW(ERR_BAD_MEM_SIZE) opVex(k, 0, op, T_0F3A | T_MUST_EVEX | T_EW0 | T_N2, 0x67, imm);
+}
+void vfpclassss(const Opmask& k, const Operand& op, uint8_t imm) {
+  if (!op.isXMEM())
+    XBYAK_THROW(ERR_BAD_MEM_SIZE) opVex(k, 0, op, T_66 | T_0F3A | T_MUST_EVEX | T_EW0 | T_N4, 0x67, imm);
+}
+void vgatherdpd(const Xmm& x, const Address& addr) {
+  opGather2(x, addr, T_N8 | T_66 | T_0F38 | T_EW1 | T_YMM | T_MUST_EVEX | T_VSIB, 0x92, 1);
+}
+void vgatherdps(const Xmm& x, const Address& addr) {
+  opGather2(x, addr, T_N4 | T_66 | T_0F38 | T_EW0 | T_YMM | T_MUST_EVEX | T_VSIB, 0x92, 0);
+}
+void vgatherpf0dpd(const Address& addr) {
+  opGatherFetch(addr, zm1, T_N8 | T_66 | T_0F38 | T_EW1 | T_MUST_EVEX | T_M_K | T_VSIB, 0xC6, Operand::YMM);
+}
+void vgatherpf0dps(const Address& addr) {
+  opGatherFetch(addr, zm1, T_N4 | T_66 | T_0F38 | T_EW0 | T_MUST_EVEX | T_M_K | T_VSIB, 0xC6, Operand::ZMM);
+}
+void vgatherpf0qpd(const Address& addr) {
+  opGatherFetch(addr, zm1, T_N8 | T_66 | T_0F38 | T_EW1 | T_MUST_EVEX | T_M_K | T_VSIB, 0xC7, Operand::ZMM);
+}
+void vgatherpf0qps(const Address& addr) {
+  opGatherFetch(addr, zm1, T_N4 | T_66 | T_0F38 | T_EW0 | T_MUST_EVEX | T_M_K | T_VSIB, 0xC7, Operand::ZMM);
+}
+void vgatherpf1dpd(const Address& addr) {
+  opGatherFetch(addr, zm2, T_N8 | T_66 | T_0F38 | T_EW1 | T_MUST_EVEX | T_M_K | T_VSIB, 0xC6, Operand::YMM);
+}
+void vgatherpf1dps(const Address& addr) {
+  opGatherFetch(addr, zm2, T_N4 | T_66 | T_0F38 | T_EW0 | T_MUST_EVEX | T_M_K | T_VSIB, 0xC6, Operand::ZMM);
+}
+void vgatherpf1qpd(const Address& addr) {
+  opGatherFetch(addr, zm2, T_N8 | T_66 | T_0F38 | T_EW1 | T_MUST_EVEX | T_M_K | T_VSIB, 0xC7, Operand::ZMM);
+}
+void vgatherpf1qps(const Address& addr) {
+  opGatherFetch(addr, zm2, T_N4 | T_66 | T_0F38 | T_EW0 | T_MUST_EVEX | T_M_K | T_VSIB, 0xC7, Operand::ZMM);
+}
+void vgatherqpd(const Xmm& x, const Address& addr) {
+  opGather2(x, addr, T_N8 | T_66 | T_0F38 | T_EW1 | T_YMM | T_MUST_EVEX | T_VSIB, 0x93, 0);
+}
+void vgatherqps(const Xmm& x, const Address& addr) {
+  opGather2(x, addr, T_N4 | T_66 | T_0F38 | T_EW0 | T_YMM | T_MUST_EVEX | T_VSIB, 0x93, 2);
+}
+void vgetexppd(const Xmm& x, const Operand& op) {
+  opAVX_X_XM_IMM(x, op, T_66 | T_0F38 | T_EW1 | T_YMM | T_SAE_Z | T_MUST_EVEX | T_B64, 0x42);
+}
+void vgetexpph(const Xmm& x, const Operand& op) {
+  opAVX_X_XM_IMM(x, op, T_66 | T_MAP6 | T_EW0 | T_YMM | T_SAE_Z | T_MUST_EVEX | T_B16, 0x42);
+}
+void vgetexpps(const Xmm& x, const Operand& op) {
+  opAVX_X_XM_IMM(x, op, T_66 | T_0F38 | T_EW0 | T_YMM | T_SAE_Z | T_MUST_EVEX | T_B32, 0x42);
+}
+void vgetexpsd(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_N8 | T_66 | T_0F38 | T_EW1 | T_SAE_X | T_MUST_EVEX, 0x43);
+}
+void vgetexpsh(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_N2 | T_66 | T_MAP6 | T_EW0 | T_SAE_X | T_MUST_EVEX, 0x43);
+}
+void vgetexpss(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_N4 | T_66 | T_0F38 | T_EW0 | T_SAE_X | T_MUST_EVEX, 0x43);
+}
+void vgetmantpd(const Xmm& x, const Operand& op, uint8_t imm) {
+  opAVX_X_XM_IMM(x, op, T_66 | T_0F3A | T_EW1 | T_YMM | T_SAE_Z | T_MUST_EVEX | T_B64, 0x26, imm);
+}
+void vgetmantph(const Xmm& x, const Operand& op, uint8_t imm) {
+  opAVX_X_XM_IMM(x, op, T_0F3A | T_EW0 | T_YMM | T_SAE_Z | T_MUST_EVEX | T_B16, 0x26, imm);
+}
+void vgetmantps(const Xmm& x, const Operand& op, uint8_t imm) {
+  opAVX_X_XM_IMM(x, op, T_66 | T_0F3A | T_EW0 | T_YMM | T_SAE_Z | T_MUST_EVEX | T_B32, 0x26, imm);
+}
+void vgetmantsd(const Xmm& x1, const Xmm& x2, const Operand& op, uint8_t imm) {
+  opAVX_X_X_XM(x1, x2, op, T_N8 | T_66 | T_0F3A | T_EW1 | T_SAE_X | T_MUST_EVEX, 0x27, imm);
+}
+void vgetmantsh(const Xmm& x1, const Xmm& x2, const Operand& op, uint8_t imm) {
+  opAVX_X_X_XM(x1, x2, op, T_N2 | T_0F3A | T_EW0 | T_SAE_X | T_MUST_EVEX, 0x27, imm);
+}
+void vgetmantss(const Xmm& x1, const Xmm& x2, const Operand& op, uint8_t imm) {
+  opAVX_X_X_XM(x1, x2, op, T_N4 | T_66 | T_0F3A | T_EW0 | T_SAE_X | T_MUST_EVEX, 0x27, imm);
+}
+void vinsertf32x4(const Ymm& r1, const Ymm& r2, const Operand& op, uint8_t imm) {
+  if (!(r1.getKind() == r2.getKind() && op.is(Operand::MEM | Operand::XMM)))
+    XBYAK_THROW(ERR_BAD_COMBINATION) opVex(r1, &r2, op, T_N16 | T_66 | T_0F3A | T_EW0 | T_YMM | T_MUST_EVEX, 0x18, imm);
+}
+void vinsertf32x8(const Zmm& r1, const Zmm& r2, const Operand& op, uint8_t imm) {
+  if (!op.is(Operand::MEM | Operand::YMM))
+    XBYAK_THROW(ERR_BAD_COMBINATION) opVex(r1, &r2, op, T_N32 | T_66 | T_0F3A | T_EW0 | T_YMM | T_MUST_EVEX, 0x1A, imm);
+}
+void vinsertf64x2(const Ymm& r1, const Ymm& r2, const Operand& op, uint8_t imm) {
+  if (!(r1.getKind() == r2.getKind() && op.is(Operand::MEM | Operand::XMM)))
+    XBYAK_THROW(ERR_BAD_COMBINATION) opVex(r1, &r2, op, T_N16 | T_66 | T_0F3A | T_EW1 | T_YMM | T_MUST_EVEX, 0x18, imm);
+}
+void vinsertf64x4(const Zmm& r1, const Zmm& r2, const Operand& op, uint8_t imm) {
+  if (!op.is(Operand::MEM | Operand::YMM))
+    XBYAK_THROW(ERR_BAD_COMBINATION) opVex(r1, &r2, op, T_N32 | T_66 | T_0F3A | T_EW1 | T_YMM | T_MUST_EVEX, 0x1A, imm);
+}
+void vinserti32x4(const Ymm& r1, const Ymm& r2, const Operand& op, uint8_t imm) {
+  if (!(r1.getKind() == r2.getKind() && op.is(Operand::MEM | Operand::XMM)))
+    XBYAK_THROW(ERR_BAD_COMBINATION) opVex(r1, &r2, op, T_N16 | T_66 | T_0F3A | T_EW0 | T_YMM | T_MUST_EVEX, 0x38, imm);
+}
+void vinserti32x8(const Zmm& r1, const Zmm& r2, const Operand& op, uint8_t imm) {
+  if (!op.is(Operand::MEM | Operand::YMM))
+    XBYAK_THROW(ERR_BAD_COMBINATION) opVex(r1, &r2, op, T_N32 | T_66 | T_0F3A | T_EW0 | T_YMM | T_MUST_EVEX, 0x3A, imm);
+}
+void vinserti64x2(const Ymm& r1, const Ymm& r2, const Operand& op, uint8_t imm) {
+  if (!(r1.getKind() == r2.getKind() && op.is(Operand::MEM | Operand::XMM)))
+    XBYAK_THROW(ERR_BAD_COMBINATION) opVex(r1, &r2, op, T_N16 | T_66 | T_0F3A | T_EW1 | T_YMM | T_MUST_EVEX, 0x38, imm);
+}
+void vinserti64x4(const Zmm& r1, const Zmm& r2, const Operand& op, uint8_t imm) {
+  if (!op.is(Operand::MEM | Operand::YMM))
+    XBYAK_THROW(ERR_BAD_COMBINATION) opVex(r1, &r2, op, T_N32 | T_66 | T_0F3A | T_EW1 | T_YMM | T_MUST_EVEX, 0x3A, imm);
+}
+void vmaxph(const Xmm& xmm, const Operand& op1, const Operand& op2 = Operand()) {
+  opAVX_X_X_XM(xmm, op1, op2, T_MAP5 | T_EW0 | T_YMM | T_MUST_EVEX | T_ER_Z | T_B16, 0x5F);
+}
+void vmaxsh(const Xmm& xmm, const Operand& op1, const Operand& op2 = Operand()) {
+  opAVX_X_X_XM(xmm, op1, op2, T_MAP5 | T_F3 | T_EW0 | T_MUST_EVEX | T_ER_X | T_N2, 0x5F);
+}
+void vminph(const Xmm& xmm, const Operand& op1, const Operand& op2 = Operand()) {
+  opAVX_X_X_XM(xmm, op1, op2, T_MAP5 | T_EW0 | T_YMM | T_MUST_EVEX | T_ER_Z | T_B16, 0x5D);
+}
+void vminsh(const Xmm& xmm, const Operand& op1, const Operand& op2 = Operand()) {
+  opAVX_X_X_XM(xmm, op1, op2, T_MAP5 | T_F3 | T_EW0 | T_MUST_EVEX | T_ER_X | T_N2, 0x5D);
+}
+void vmovdqa32(const Address& addr, const Xmm& x) {
+  opAVX_X_XM_IMM(x, addr, T_66 | T_0F | T_EW0 | T_YMM | T_ER_X | T_ER_Y | T_ER_Z | T_MUST_EVEX | T_M_K, 0x7F);
+}
+void vmovdqa32(const Xmm& x, const Operand& op) {
+  opAVX_X_XM_IMM(x, op, T_66 | T_0F | T_EW0 | T_YMM | T_ER_X | T_ER_Y | T_ER_Z | T_MUST_EVEX, 0x6F);
+}
+void vmovdqa64(const Address& addr, const Xmm& x) {
+  opAVX_X_XM_IMM(x, addr, T_66 | T_0F | T_EW1 | T_YMM | T_ER_X | T_ER_Y | T_ER_Z | T_MUST_EVEX | T_M_K, 0x7F);
+}
+void vmovdqa64(const Xmm& x, const Operand& op) {
+  opAVX_X_XM_IMM(x, op, T_66 | T_0F | T_EW1 | T_YMM | T_ER_X | T_ER_Y | T_ER_Z | T_MUST_EVEX, 0x6F);
+}
+void vmovdqu16(const Address& addr, const Xmm& x) {
+  opAVX_X_XM_IMM(x, addr, T_F2 | T_0F | T_EW1 | T_YMM | T_ER_X | T_ER_Y | T_ER_Z | T_MUST_EVEX | T_M_K, 0x7F);
+}
+void vmovdqu16(const Xmm& x, const Operand& op) {
+  opAVX_X_XM_IMM(x, op, T_F2 | T_0F | T_EW1 | T_YMM | T_ER_X | T_ER_Y | T_ER_Z | T_MUST_EVEX, 0x6F);
+}
+void vmovdqu32(const Address& addr, const Xmm& x) {
+  opAVX_X_XM_IMM(x, addr, T_F3 | T_0F | T_EW0 | T_YMM | T_ER_X | T_ER_Y | T_ER_Z | T_MUST_EVEX | T_M_K, 0x7F);
+}
+void vmovdqu32(const Xmm& x, const Operand& op) {
+  opAVX_X_XM_IMM(x, op, T_F3 | T_0F | T_EW0 | T_YMM | T_ER_X | T_ER_Y | T_ER_Z | T_MUST_EVEX, 0x6F);
+}
+void vmovdqu64(const Address& addr, const Xmm& x) {
+  opAVX_X_XM_IMM(x, addr, T_F3 | T_0F | T_EW1 | T_YMM | T_ER_X | T_ER_Y | T_ER_Z | T_MUST_EVEX | T_M_K, 0x7F);
+}
+void vmovdqu64(const Xmm& x, const Operand& op) {
+  opAVX_X_XM_IMM(x, op, T_F3 | T_0F | T_EW1 | T_YMM | T_ER_X | T_ER_Y | T_ER_Z | T_MUST_EVEX, 0x6F);
+}
+void vmovdqu8(const Address& addr, const Xmm& x) {
+  opAVX_X_XM_IMM(x, addr, T_F2 | T_0F | T_EW0 | T_YMM | T_ER_X | T_ER_Y | T_ER_Z | T_MUST_EVEX | T_M_K, 0x7F);
+}
+void vmovdqu8(const Xmm& x, const Operand& op) {
+  opAVX_X_XM_IMM(x, op, T_F2 | T_0F | T_EW0 | T_YMM | T_ER_X | T_ER_Y | T_ER_Z | T_MUST_EVEX, 0x6F);
+}
+void vmovsh(const Address& addr, const Xmm& x) {
+  opAVX_X_XM_IMM(x, addr, T_N2 | T_F3 | T_MAP5 | T_EW0 | T_MUST_EVEX | T_M_K, 0x11);
+}
+void vmovsh(const Xmm& x, const Address& addr) {
+  opAVX_X_X_XM(x, xm0, addr, T_N2 | T_F3 | T_MAP5 | T_EW0 | T_MUST_EVEX, 0x10);
+}
+void vmovsh(const Xmm& x1, const Xmm& x2, const Xmm& x3) {
+  opAVX_X_X_XM(x1, x2, x3, T_N2 | T_F3 | T_MAP5 | T_EW0 | T_MUST_EVEX, 0x10);
+}
 void vmovw(const Address& addr, const Xmm& x) { opAVX_X_XM_IMM(x, addr, T_N2 | T_66 | T_MAP5 | T_MUST_EVEX, 0x7E); }
 void vmovw(const Reg32e& r, const Xmm& x) { opAVX_X_X_XM(x, xm0, r, T_N2 | T_66 | T_MAP5 | T_MUST_EVEX, 0x7E); }
-void vmovw(const Xmm& x, const Operand& op) { if (!op.isREG(32|64) && !op.isMEM()) XBYAK_THROW(ERR_BAD_COMBINATION) opAVX_X_X_XM(x, xm0, op, T_N2 | T_66 | T_MAP5 | T_MUST_EVEX, 0x6E); }
-void vmulph(const Xmm& xmm, const Operand& op1, const Operand& op2 = Operand()) { opAVX_X_X_XM(xmm, op1, op2, T_MAP5 | T_EW0 | T_YMM | T_MUST_EVEX | T_ER_Z | T_B16, 0x59); }
-void vmulsh(const Xmm& xmm, const Operand& op1, const Operand& op2 = Operand()) { opAVX_X_X_XM(xmm, op1, op2, T_MAP5 | T_F3 | T_EW0 | T_MUST_EVEX | T_ER_X | T_N2, 0x59); }
-void vp2intersectd(const Opmask& k, const Xmm& x, const Operand& op) { if (k.getOpmaskIdx() != 0) XBYAK_THROW(ERR_OPMASK_IS_ALREADY_SET) opAVX_K_X_XM(k, x, op, T_F2 | T_0F38 | T_YMM | T_EVEX | T_EW0 | T_B32, 0x68); }
-void vp2intersectq(const Opmask& k, const Xmm& x, const Operand& op) { if (k.getOpmaskIdx() != 0) XBYAK_THROW(ERR_OPMASK_IS_ALREADY_SET) opAVX_K_X_XM(k, x, op, T_F2 | T_0F38 | T_YMM | T_EVEX | T_EW1 | T_B64, 0x68); }
-void vp4dpwssd(const Zmm& z1, const Zmm& z2, const Address& addr) { opAVX_X_X_XM(z1, z2, addr, T_0F38 | T_F2 | T_EW0 | T_YMM | T_MUST_EVEX | T_N16, 0x52); }
-void vp4dpwssds(const Zmm& z1, const Zmm& z2, const Address& addr) { opAVX_X_X_XM(z1, z2, addr, T_0F38 | T_F2 | T_EW0 | T_YMM | T_MUST_EVEX | T_N16, 0x53); }
-void vpabsq(const Xmm& x, const Operand& op) { opAVX_X_XM_IMM(x, op, T_66 | T_0F38 | T_MUST_EVEX | T_EW1 | T_B64 | T_YMM, 0x1F); }
-void vpandd(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F | T_EW0 | T_YMM | T_MUST_EVEX | T_B32, 0xDB); }
-void vpandnd(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F | T_EW0 | T_YMM | T_MUST_EVEX | T_B32, 0xDF); }
-void vpandnq(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F | T_EW1 | T_YMM | T_MUST_EVEX | T_B64, 0xDF); }
-void vpandq(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F | T_EW1 | T_YMM | T_MUST_EVEX | T_B64, 0xDB); }
-void vpblendmb(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_EW0 | T_YMM | T_MUST_EVEX, 0x66); }
-void vpblendmd(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_EW0 | T_YMM | T_MUST_EVEX | T_B32, 0x64); }
-void vpblendmq(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_EW1 | T_YMM | T_MUST_EVEX | T_B64, 0x64); }
-void vpblendmw(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_EW1 | T_YMM | T_MUST_EVEX, 0x66); }
+void vmovw(const Xmm& x, const Operand& op) {
+  if (!op.isREG(32 | 64) && !op.isMEM())
+    XBYAK_THROW(ERR_BAD_COMBINATION) opAVX_X_X_XM(x, xm0, op, T_N2 | T_66 | T_MAP5 | T_MUST_EVEX, 0x6E);
+}
+void vmulph(const Xmm& xmm, const Operand& op1, const Operand& op2 = Operand()) {
+  opAVX_X_X_XM(xmm, op1, op2, T_MAP5 | T_EW0 | T_YMM | T_MUST_EVEX | T_ER_Z | T_B16, 0x59);
+}
+void vmulsh(const Xmm& xmm, const Operand& op1, const Operand& op2 = Operand()) {
+  opAVX_X_X_XM(xmm, op1, op2, T_MAP5 | T_F3 | T_EW0 | T_MUST_EVEX | T_ER_X | T_N2, 0x59);
+}
+void vp2intersectd(const Opmask& k, const Xmm& x, const Operand& op) {
+  if (k.getOpmaskIdx() != 0)
+    XBYAK_THROW(ERR_OPMASK_IS_ALREADY_SET) opAVX_K_X_XM(k, x, op, T_F2 | T_0F38 | T_YMM | T_EVEX | T_EW0 | T_B32, 0x68);
+}
+void vp2intersectq(const Opmask& k, const Xmm& x, const Operand& op) {
+  if (k.getOpmaskIdx() != 0)
+    XBYAK_THROW(ERR_OPMASK_IS_ALREADY_SET) opAVX_K_X_XM(k, x, op, T_F2 | T_0F38 | T_YMM | T_EVEX | T_EW1 | T_B64, 0x68);
+}
+void vp4dpwssd(const Zmm& z1, const Zmm& z2, const Address& addr) {
+  opAVX_X_X_XM(z1, z2, addr, T_0F38 | T_F2 | T_EW0 | T_YMM | T_MUST_EVEX | T_N16, 0x52);
+}
+void vp4dpwssds(const Zmm& z1, const Zmm& z2, const Address& addr) {
+  opAVX_X_X_XM(z1, z2, addr, T_0F38 | T_F2 | T_EW0 | T_YMM | T_MUST_EVEX | T_N16, 0x53);
+}
+void vpabsq(const Xmm& x, const Operand& op) {
+  opAVX_X_XM_IMM(x, op, T_66 | T_0F38 | T_MUST_EVEX | T_EW1 | T_B64 | T_YMM, 0x1F);
+}
+void vpandd(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F | T_EW0 | T_YMM | T_MUST_EVEX | T_B32, 0xDB);
+}
+void vpandnd(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F | T_EW0 | T_YMM | T_MUST_EVEX | T_B32, 0xDF);
+}
+void vpandnq(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F | T_EW1 | T_YMM | T_MUST_EVEX | T_B64, 0xDF);
+}
+void vpandq(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F | T_EW1 | T_YMM | T_MUST_EVEX | T_B64, 0xDB);
+}
+void vpblendmb(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_EW0 | T_YMM | T_MUST_EVEX, 0x66);
+}
+void vpblendmd(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_EW0 | T_YMM | T_MUST_EVEX | T_B32, 0x64);
+}
+void vpblendmq(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_EW1 | T_YMM | T_MUST_EVEX | T_B64, 0x64);
+}
+void vpblendmw(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_EW1 | T_YMM | T_MUST_EVEX, 0x66);
+}
 void vpbroadcastb(const Xmm& x, const Reg8& r) { opVex(x, 0, r, T_66 | T_0F38 | T_EW0 | T_YMM | T_MUST_EVEX, 0x7A); }
 void vpbroadcastd(const Xmm& x, const Reg32& r) { opVex(x, 0, r, T_66 | T_0F38 | T_EW0 | T_YMM | T_MUST_EVEX, 0x7C); }
-void vpbroadcastmb2q(const Xmm& x, const Opmask& k) { opVex(x, 0, k, T_F3 | T_0F38 | T_YMM | T_MUST_EVEX | T_EW1, 0x2A); }
-void vpbroadcastmw2d(const Xmm& x, const Opmask& k) { opVex(x, 0, k, T_F3 | T_0F38 | T_YMM | T_MUST_EVEX | T_EW0, 0x3A); }
+void vpbroadcastmb2q(const Xmm& x, const Opmask& k) {
+  opVex(x, 0, k, T_F3 | T_0F38 | T_YMM | T_MUST_EVEX | T_EW1, 0x2A);
+}
+void vpbroadcastmw2d(const Xmm& x, const Opmask& k) {
+  opVex(x, 0, k, T_F3 | T_0F38 | T_YMM | T_MUST_EVEX | T_EW0, 0x3A);
+}
 void vpbroadcastw(const Xmm& x, const Reg16& r) { opVex(x, 0, r, T_66 | T_0F38 | T_EW0 | T_YMM | T_MUST_EVEX, 0x7B); }
-void vpcmpb(const Opmask& k, const Xmm& x, const Operand& op, uint8_t imm) { opAVX_K_X_XM(k, x, op, T_66 | T_0F3A | T_EW0 | T_YMM | T_MUST_EVEX, 0x3F, imm); }
-void vpcmpd(const Opmask& k, const Xmm& x, const Operand& op, uint8_t imm) { opAVX_K_X_XM(k, x, op, T_66 | T_0F3A | T_EW0 | T_YMM | T_MUST_EVEX | T_B32, 0x1F, imm); }
-void vpcmpeqb(const Opmask& k, const Xmm& x, const Operand& op) { opAVX_K_X_XM(k, x, op, T_66 | T_0F | T_YMM | T_MUST_EVEX, 0x74); }
-void vpcmpeqd(const Opmask& k, const Xmm& x, const Operand& op) { opAVX_K_X_XM(k, x, op, T_66 | T_0F | T_YMM | T_MUST_EVEX | T_B32, 0x76); }
-void vpcmpeqq(const Opmask& k, const Xmm& x, const Operand& op) { opAVX_K_X_XM(k, x, op, T_66 | T_0F38 | T_EW1 | T_YMM | T_MUST_EVEX | T_B64, 0x29); }
-void vpcmpeqw(const Opmask& k, const Xmm& x, const Operand& op) { opAVX_K_X_XM(k, x, op, T_66 | T_0F | T_YMM | T_MUST_EVEX, 0x75); }
-void vpcmpgtb(const Opmask& k, const Xmm& x, const Operand& op) { opAVX_K_X_XM(k, x, op, T_66 | T_0F | T_YMM | T_MUST_EVEX, 0x64); }
-void vpcmpgtd(const Opmask& k, const Xmm& x, const Operand& op) { opAVX_K_X_XM(k, x, op, T_66 | T_0F | T_EW0 | T_YMM | T_MUST_EVEX | T_B32, 0x66); }
-void vpcmpgtq(const Opmask& k, const Xmm& x, const Operand& op) { opAVX_K_X_XM(k, x, op, T_66 | T_0F38 | T_EW1 | T_YMM | T_MUST_EVEX | T_B64, 0x37); }
-void vpcmpgtw(const Opmask& k, const Xmm& x, const Operand& op) { opAVX_K_X_XM(k, x, op, T_66 | T_0F | T_YMM | T_MUST_EVEX, 0x65); }
-void vpcmpq(const Opmask& k, const Xmm& x, const Operand& op, uint8_t imm) { opAVX_K_X_XM(k, x, op, T_66 | T_0F3A | T_EW1 | T_YMM | T_MUST_EVEX | T_B64, 0x1F, imm); }
-void vpcmpub(const Opmask& k, const Xmm& x, const Operand& op, uint8_t imm) { opAVX_K_X_XM(k, x, op, T_66 | T_0F3A | T_EW0 | T_YMM | T_MUST_EVEX, 0x3E, imm); }
-void vpcmpud(const Opmask& k, const Xmm& x, const Operand& op, uint8_t imm) { opAVX_K_X_XM(k, x, op, T_66 | T_0F3A | T_EW0 | T_YMM | T_MUST_EVEX | T_B32, 0x1E, imm); }
-void vpcmpuq(const Opmask& k, const Xmm& x, const Operand& op, uint8_t imm) { opAVX_K_X_XM(k, x, op, T_66 | T_0F3A | T_EW1 | T_YMM | T_MUST_EVEX | T_B64, 0x1E, imm); }
-void vpcmpuw(const Opmask& k, const Xmm& x, const Operand& op, uint8_t imm) { opAVX_K_X_XM(k, x, op, T_66 | T_0F3A | T_EW1 | T_YMM | T_MUST_EVEX, 0x3E, imm); }
-void vpcmpw(const Opmask& k, const Xmm& x, const Operand& op, uint8_t imm) { opAVX_K_X_XM(k, x, op, T_66 | T_0F3A | T_EW1 | T_YMM | T_MUST_EVEX, 0x3F, imm); }
-void vpcompressd(const Operand& op, const Xmm& x) { opAVX_X_XM_IMM(x, op, T_N4 | T_66 | T_0F38 | T_EW0 | T_YMM | T_MUST_EVEX, 0x8B); }
-void vpcompressq(const Operand& op, const Xmm& x) { opAVX_X_XM_IMM(x, op, T_N8 | T_66 | T_0F38 | T_EW1 | T_YMM | T_MUST_EVEX, 0x8B); }
-void vpconflictd(const Xmm& x, const Operand& op) { opAVX_X_XM_IMM(x, op, T_66 | T_0F38 | T_EW0 | T_YMM | T_MUST_EVEX | T_B32, 0xC4); }
-void vpconflictq(const Xmm& x, const Operand& op) { opAVX_X_XM_IMM(x, op, T_66 | T_0F38 | T_EW1 | T_YMM | T_MUST_EVEX | T_B64, 0xC4); }
-void vpermb(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_EW0 | T_YMM | T_MUST_EVEX, 0x8D); }
-void vpermi2b(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_EW0 | T_YMM | T_MUST_EVEX, 0x75); }
-void vpermi2d(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_EW0 | T_YMM | T_MUST_EVEX | T_B32, 0x76); }
-void vpermi2pd(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_EW1 | T_YMM | T_MUST_EVEX | T_B64, 0x77); }
-void vpermi2ps(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_EW0 | T_YMM | T_MUST_EVEX | T_B32, 0x77); }
-void vpermi2q(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_EW1 | T_YMM | T_MUST_EVEX | T_B64, 0x76); }
-void vpermi2w(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_EW1 | T_YMM | T_MUST_EVEX, 0x75); }
-void vpermt2b(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_EW0 | T_YMM | T_MUST_EVEX, 0x7D); }
-void vpermt2d(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_EW0 | T_YMM | T_MUST_EVEX | T_B32, 0x7E); }
-void vpermt2pd(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_EW1 | T_YMM | T_MUST_EVEX | T_B64, 0x7F); }
-void vpermt2ps(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_EW0 | T_YMM | T_MUST_EVEX | T_B32, 0x7F); }
-void vpermt2q(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_EW1 | T_YMM | T_MUST_EVEX | T_B64, 0x7E); }
-void vpermt2w(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_EW1 | T_YMM | T_MUST_EVEX, 0x7D); }
-void vpermw(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_EW1 | T_YMM | T_MUST_EVEX, 0x8D); }
-void vpexpandb(const Xmm& x, const Operand& op) { opAVX_X_XM_IMM(x, op, T_N1 | T_66 | T_0F38 | T_EW0 | T_YMM | T_SAE_Z | T_MUST_EVEX, 0x62); }
-void vpexpandd(const Xmm& x, const Operand& op) { opAVX_X_XM_IMM(x, op, T_N4 | T_66 | T_0F38 | T_EW0 | T_YMM | T_MUST_EVEX, 0x89); }
-void vpexpandq(const Xmm& x, const Operand& op) { opAVX_X_XM_IMM(x, op, T_N8 | T_66 | T_0F38 | T_EW1 | T_YMM | T_MUST_EVEX, 0x89); }
-void vpexpandw(const Xmm& x, const Operand& op) { opAVX_X_XM_IMM(x, op, T_N2 | T_66 | T_0F38 | T_EW1 | T_YMM | T_SAE_Z | T_MUST_EVEX, 0x62); }
-void vpgatherdd(const Xmm& x, const Address& addr) { opGather2(x, addr, T_N4 | T_66 | T_0F38 | T_EW0 | T_YMM | T_MUST_EVEX | T_VSIB, 0x90, 0); }
-void vpgatherdq(const Xmm& x, const Address& addr) { opGather2(x, addr, T_N8 | T_66 | T_0F38 | T_EW1 | T_YMM | T_MUST_EVEX | T_VSIB, 0x90, 1); }
-void vpgatherqd(const Xmm& x, const Address& addr) { opGather2(x, addr, T_N4 | T_66 | T_0F38 | T_EW0 | T_YMM | T_MUST_EVEX | T_VSIB, 0x91, 2); }
-void vpgatherqq(const Xmm& x, const Address& addr) { opGather2(x, addr, T_N8 | T_66 | T_0F38 | T_EW1 | T_YMM | T_MUST_EVEX | T_VSIB, 0x91, 0); }
-void vplzcntd(const Xmm& x, const Operand& op) { opAVX_X_XM_IMM(x, op, T_66 | T_0F38 | T_EW0 | T_YMM | T_MUST_EVEX | T_B32, 0x44); }
-void vplzcntq(const Xmm& x, const Operand& op) { opAVX_X_XM_IMM(x, op, T_66 | T_0F38 | T_EW1 | T_YMM | T_MUST_EVEX | T_B64, 0x44); }
-void vpmaxsq(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_EW1 | T_YMM | T_MUST_EVEX | T_B64, 0x3D); }
-void vpmaxuq(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_EW1 | T_YMM | T_MUST_EVEX | T_B64, 0x3F); }
-void vpminsq(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_EW1 | T_YMM | T_MUST_EVEX | T_B64, 0x39); }
-void vpminuq(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_EW1 | T_YMM | T_MUST_EVEX | T_B64, 0x3B); }
+void vpcmpb(const Opmask& k, const Xmm& x, const Operand& op, uint8_t imm) {
+  opAVX_K_X_XM(k, x, op, T_66 | T_0F3A | T_EW0 | T_YMM | T_MUST_EVEX, 0x3F, imm);
+}
+void vpcmpd(const Opmask& k, const Xmm& x, const Operand& op, uint8_t imm) {
+  opAVX_K_X_XM(k, x, op, T_66 | T_0F3A | T_EW0 | T_YMM | T_MUST_EVEX | T_B32, 0x1F, imm);
+}
+void vpcmpeqb(const Opmask& k, const Xmm& x, const Operand& op) {
+  opAVX_K_X_XM(k, x, op, T_66 | T_0F | T_YMM | T_MUST_EVEX, 0x74);
+}
+void vpcmpeqd(const Opmask& k, const Xmm& x, const Operand& op) {
+  opAVX_K_X_XM(k, x, op, T_66 | T_0F | T_YMM | T_MUST_EVEX | T_B32, 0x76);
+}
+void vpcmpeqq(const Opmask& k, const Xmm& x, const Operand& op) {
+  opAVX_K_X_XM(k, x, op, T_66 | T_0F38 | T_EW1 | T_YMM | T_MUST_EVEX | T_B64, 0x29);
+}
+void vpcmpeqw(const Opmask& k, const Xmm& x, const Operand& op) {
+  opAVX_K_X_XM(k, x, op, T_66 | T_0F | T_YMM | T_MUST_EVEX, 0x75);
+}
+void vpcmpgtb(const Opmask& k, const Xmm& x, const Operand& op) {
+  opAVX_K_X_XM(k, x, op, T_66 | T_0F | T_YMM | T_MUST_EVEX, 0x64);
+}
+void vpcmpgtd(const Opmask& k, const Xmm& x, const Operand& op) {
+  opAVX_K_X_XM(k, x, op, T_66 | T_0F | T_EW0 | T_YMM | T_MUST_EVEX | T_B32, 0x66);
+}
+void vpcmpgtq(const Opmask& k, const Xmm& x, const Operand& op) {
+  opAVX_K_X_XM(k, x, op, T_66 | T_0F38 | T_EW1 | T_YMM | T_MUST_EVEX | T_B64, 0x37);
+}
+void vpcmpgtw(const Opmask& k, const Xmm& x, const Operand& op) {
+  opAVX_K_X_XM(k, x, op, T_66 | T_0F | T_YMM | T_MUST_EVEX, 0x65);
+}
+void vpcmpq(const Opmask& k, const Xmm& x, const Operand& op, uint8_t imm) {
+  opAVX_K_X_XM(k, x, op, T_66 | T_0F3A | T_EW1 | T_YMM | T_MUST_EVEX | T_B64, 0x1F, imm);
+}
+void vpcmpub(const Opmask& k, const Xmm& x, const Operand& op, uint8_t imm) {
+  opAVX_K_X_XM(k, x, op, T_66 | T_0F3A | T_EW0 | T_YMM | T_MUST_EVEX, 0x3E, imm);
+}
+void vpcmpud(const Opmask& k, const Xmm& x, const Operand& op, uint8_t imm) {
+  opAVX_K_X_XM(k, x, op, T_66 | T_0F3A | T_EW0 | T_YMM | T_MUST_EVEX | T_B32, 0x1E, imm);
+}
+void vpcmpuq(const Opmask& k, const Xmm& x, const Operand& op, uint8_t imm) {
+  opAVX_K_X_XM(k, x, op, T_66 | T_0F3A | T_EW1 | T_YMM | T_MUST_EVEX | T_B64, 0x1E, imm);
+}
+void vpcmpuw(const Opmask& k, const Xmm& x, const Operand& op, uint8_t imm) {
+  opAVX_K_X_XM(k, x, op, T_66 | T_0F3A | T_EW1 | T_YMM | T_MUST_EVEX, 0x3E, imm);
+}
+void vpcmpw(const Opmask& k, const Xmm& x, const Operand& op, uint8_t imm) {
+  opAVX_K_X_XM(k, x, op, T_66 | T_0F3A | T_EW1 | T_YMM | T_MUST_EVEX, 0x3F, imm);
+}
+void vpcompressd(const Operand& op, const Xmm& x) {
+  opAVX_X_XM_IMM(x, op, T_N4 | T_66 | T_0F38 | T_EW0 | T_YMM | T_MUST_EVEX, 0x8B);
+}
+void vpcompressq(const Operand& op, const Xmm& x) {
+  opAVX_X_XM_IMM(x, op, T_N8 | T_66 | T_0F38 | T_EW1 | T_YMM | T_MUST_EVEX, 0x8B);
+}
+void vpconflictd(const Xmm& x, const Operand& op) {
+  opAVX_X_XM_IMM(x, op, T_66 | T_0F38 | T_EW0 | T_YMM | T_MUST_EVEX | T_B32, 0xC4);
+}
+void vpconflictq(const Xmm& x, const Operand& op) {
+  opAVX_X_XM_IMM(x, op, T_66 | T_0F38 | T_EW1 | T_YMM | T_MUST_EVEX | T_B64, 0xC4);
+}
+void vpermb(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_EW0 | T_YMM | T_MUST_EVEX, 0x8D);
+}
+void vpermi2b(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_EW0 | T_YMM | T_MUST_EVEX, 0x75);
+}
+void vpermi2d(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_EW0 | T_YMM | T_MUST_EVEX | T_B32, 0x76);
+}
+void vpermi2pd(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_EW1 | T_YMM | T_MUST_EVEX | T_B64, 0x77);
+}
+void vpermi2ps(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_EW0 | T_YMM | T_MUST_EVEX | T_B32, 0x77);
+}
+void vpermi2q(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_EW1 | T_YMM | T_MUST_EVEX | T_B64, 0x76);
+}
+void vpermi2w(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_EW1 | T_YMM | T_MUST_EVEX, 0x75);
+}
+void vpermt2b(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_EW0 | T_YMM | T_MUST_EVEX, 0x7D);
+}
+void vpermt2d(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_EW0 | T_YMM | T_MUST_EVEX | T_B32, 0x7E);
+}
+void vpermt2pd(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_EW1 | T_YMM | T_MUST_EVEX | T_B64, 0x7F);
+}
+void vpermt2ps(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_EW0 | T_YMM | T_MUST_EVEX | T_B32, 0x7F);
+}
+void vpermt2q(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_EW1 | T_YMM | T_MUST_EVEX | T_B64, 0x7E);
+}
+void vpermt2w(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_EW1 | T_YMM | T_MUST_EVEX, 0x7D);
+}
+void vpermw(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_EW1 | T_YMM | T_MUST_EVEX, 0x8D);
+}
+void vpexpandb(const Xmm& x, const Operand& op) {
+  opAVX_X_XM_IMM(x, op, T_N1 | T_66 | T_0F38 | T_EW0 | T_YMM | T_SAE_Z | T_MUST_EVEX, 0x62);
+}
+void vpexpandd(const Xmm& x, const Operand& op) {
+  opAVX_X_XM_IMM(x, op, T_N4 | T_66 | T_0F38 | T_EW0 | T_YMM | T_MUST_EVEX, 0x89);
+}
+void vpexpandq(const Xmm& x, const Operand& op) {
+  opAVX_X_XM_IMM(x, op, T_N8 | T_66 | T_0F38 | T_EW1 | T_YMM | T_MUST_EVEX, 0x89);
+}
+void vpexpandw(const Xmm& x, const Operand& op) {
+  opAVX_X_XM_IMM(x, op, T_N2 | T_66 | T_0F38 | T_EW1 | T_YMM | T_SAE_Z | T_MUST_EVEX, 0x62);
+}
+void vpgatherdd(const Xmm& x, const Address& addr) {
+  opGather2(x, addr, T_N4 | T_66 | T_0F38 | T_EW0 | T_YMM | T_MUST_EVEX | T_VSIB, 0x90, 0);
+}
+void vpgatherdq(const Xmm& x, const Address& addr) {
+  opGather2(x, addr, T_N8 | T_66 | T_0F38 | T_EW1 | T_YMM | T_MUST_EVEX | T_VSIB, 0x90, 1);
+}
+void vpgatherqd(const Xmm& x, const Address& addr) {
+  opGather2(x, addr, T_N4 | T_66 | T_0F38 | T_EW0 | T_YMM | T_MUST_EVEX | T_VSIB, 0x91, 2);
+}
+void vpgatherqq(const Xmm& x, const Address& addr) {
+  opGather2(x, addr, T_N8 | T_66 | T_0F38 | T_EW1 | T_YMM | T_MUST_EVEX | T_VSIB, 0x91, 0);
+}
+void vplzcntd(const Xmm& x, const Operand& op) {
+  opAVX_X_XM_IMM(x, op, T_66 | T_0F38 | T_EW0 | T_YMM | T_MUST_EVEX | T_B32, 0x44);
+}
+void vplzcntq(const Xmm& x, const Operand& op) {
+  opAVX_X_XM_IMM(x, op, T_66 | T_0F38 | T_EW1 | T_YMM | T_MUST_EVEX | T_B64, 0x44);
+}
+void vpmaxsq(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_EW1 | T_YMM | T_MUST_EVEX | T_B64, 0x3D);
+}
+void vpmaxuq(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_EW1 | T_YMM | T_MUST_EVEX | T_B64, 0x3F);
+}
+void vpminsq(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_EW1 | T_YMM | T_MUST_EVEX | T_B64, 0x39);
+}
+void vpminuq(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_EW1 | T_YMM | T_MUST_EVEX | T_B64, 0x3B);
+}
 void vpmovb2m(const Opmask& k, const Xmm& x) { opVex(k, 0, x, T_F3 | T_0F38 | T_MUST_EVEX | T_YMM | T_EW0, 0x29); }
 void vpmovd2m(const Opmask& k, const Xmm& x) { opVex(k, 0, x, T_F3 | T_0F38 | T_MUST_EVEX | T_YMM | T_EW0, 0x39); }
-void vpmovdb(const Operand& op, const Xmm& x) { opVmov(op, x, T_N4 | T_N_VL | T_F3 | T_0F38 | T_EW0 | T_YMM | T_MUST_EVEX | T_M_K, 0x31, false); }
-void vpmovdw(const Operand& op, const Xmm& x) { opVmov(op, x, T_N8 | T_N_VL | T_F3 | T_0F38 | T_EW0 | T_YMM | T_MUST_EVEX | T_M_K, 0x33, true); }
+void vpmovdb(const Operand& op, const Xmm& x) {
+  opVmov(op, x, T_N4 | T_N_VL | T_F3 | T_0F38 | T_EW0 | T_YMM | T_MUST_EVEX | T_M_K, 0x31, false);
+}
+void vpmovdw(const Operand& op, const Xmm& x) {
+  opVmov(op, x, T_N8 | T_N_VL | T_F3 | T_0F38 | T_EW0 | T_YMM | T_MUST_EVEX | T_M_K, 0x33, true);
+}
 void vpmovm2b(const Xmm& x, const Opmask& k) { opVex(x, 0, k, T_F3 | T_0F38 | T_MUST_EVEX | T_YMM | T_EW0, 0x28); }
 void vpmovm2d(const Xmm& x, const Opmask& k) { opVex(x, 0, k, T_F3 | T_0F38 | T_MUST_EVEX | T_YMM | T_EW0, 0x38); }
 void vpmovm2q(const Xmm& x, const Opmask& k) { opVex(x, 0, k, T_F3 | T_0F38 | T_MUST_EVEX | T_YMM | T_EW1, 0x38); }
 void vpmovm2w(const Xmm& x, const Opmask& k) { opVex(x, 0, k, T_F3 | T_0F38 | T_MUST_EVEX | T_YMM | T_EW1, 0x28); }
 void vpmovq2m(const Opmask& k, const Xmm& x) { opVex(k, 0, x, T_F3 | T_0F38 | T_MUST_EVEX | T_YMM | T_EW1, 0x39); }
-void vpmovqb(const Operand& op, const Xmm& x) { opVmov(op, x, T_N2 | T_N_VL | T_F3 | T_0F38 | T_EW0 | T_YMM | T_MUST_EVEX | T_M_K, 0x32, false); }
-void vpmovqd(const Operand& op, const Xmm& x) { opVmov(op, x, T_N8 | T_N_VL | T_F3 | T_0F38 | T_EW0 | T_YMM | T_MUST_EVEX | T_M_K, 0x35, true); }
-void vpmovqw(const Operand& op, const Xmm& x) { opVmov(op, x, T_N4 | T_N_VL | T_F3 | T_0F38 | T_EW0 | T_YMM | T_MUST_EVEX | T_M_K, 0x34, false); }
-void vpmovsdb(const Operand& op, const Xmm& x) { opVmov(op, x, T_N4 | T_N_VL | T_F3 | T_0F38 | T_EW0 | T_YMM | T_MUST_EVEX | T_M_K, 0x21, false); }
-void vpmovsdw(const Operand& op, const Xmm& x) { opVmov(op, x, T_N8 | T_N_VL | T_F3 | T_0F38 | T_EW0 | T_YMM | T_MUST_EVEX | T_M_K, 0x23, true); }
-void vpmovsqb(const Operand& op, const Xmm& x) { opVmov(op, x, T_N2 | T_N_VL | T_F3 | T_0F38 | T_EW0 | T_YMM | T_MUST_EVEX | T_M_K, 0x22, false); }
-void vpmovsqd(const Operand& op, const Xmm& x) { opVmov(op, x, T_N8 | T_N_VL | T_F3 | T_0F38 | T_EW0 | T_YMM | T_MUST_EVEX | T_M_K, 0x25, true); }
-void vpmovsqw(const Operand& op, const Xmm& x) { opVmov(op, x, T_N4 | T_N_VL | T_F3 | T_0F38 | T_EW0 | T_YMM | T_MUST_EVEX | T_M_K, 0x24, false); }
-void vpmovswb(const Operand& op, const Xmm& x) { opVmov(op, x, T_N8 | T_N_VL | T_F3 | T_0F38 | T_EW0 | T_YMM | T_MUST_EVEX | T_M_K, 0x20, true); }
-void vpmovusdb(const Operand& op, const Xmm& x) { opVmov(op, x, T_N4 | T_N_VL | T_F3 | T_0F38 | T_EW0 | T_YMM | T_MUST_EVEX | T_M_K, 0x11, false); }
-void vpmovusdw(const Operand& op, const Xmm& x) { opVmov(op, x, T_N8 | T_N_VL | T_F3 | T_0F38 | T_EW0 | T_YMM | T_MUST_EVEX | T_M_K, 0x13, true); }
-void vpmovusqb(const Operand& op, const Xmm& x) { opVmov(op, x, T_N2 | T_N_VL | T_F3 | T_0F38 | T_EW0 | T_YMM | T_MUST_EVEX | T_M_K, 0x12, false); }
-void vpmovusqd(const Operand& op, const Xmm& x) { opVmov(op, x, T_N8 | T_N_VL | T_F3 | T_0F38 | T_EW0 | T_YMM | T_MUST_EVEX | T_M_K, 0x15, true); }
-void vpmovusqw(const Operand& op, const Xmm& x) { opVmov(op, x, T_N4 | T_N_VL | T_F3 | T_0F38 | T_EW0 | T_YMM | T_MUST_EVEX | T_M_K, 0x14, false); }
-void vpmovuswb(const Operand& op, const Xmm& x) { opVmov(op, x, T_N8 | T_N_VL | T_F3 | T_0F38 | T_EW0 | T_YMM | T_MUST_EVEX | T_M_K, 0x10, true); }
+void vpmovqb(const Operand& op, const Xmm& x) {
+  opVmov(op, x, T_N2 | T_N_VL | T_F3 | T_0F38 | T_EW0 | T_YMM | T_MUST_EVEX | T_M_K, 0x32, false);
+}
+void vpmovqd(const Operand& op, const Xmm& x) {
+  opVmov(op, x, T_N8 | T_N_VL | T_F3 | T_0F38 | T_EW0 | T_YMM | T_MUST_EVEX | T_M_K, 0x35, true);
+}
+void vpmovqw(const Operand& op, const Xmm& x) {
+  opVmov(op, x, T_N4 | T_N_VL | T_F3 | T_0F38 | T_EW0 | T_YMM | T_MUST_EVEX | T_M_K, 0x34, false);
+}
+void vpmovsdb(const Operand& op, const Xmm& x) {
+  opVmov(op, x, T_N4 | T_N_VL | T_F3 | T_0F38 | T_EW0 | T_YMM | T_MUST_EVEX | T_M_K, 0x21, false);
+}
+void vpmovsdw(const Operand& op, const Xmm& x) {
+  opVmov(op, x, T_N8 | T_N_VL | T_F3 | T_0F38 | T_EW0 | T_YMM | T_MUST_EVEX | T_M_K, 0x23, true);
+}
+void vpmovsqb(const Operand& op, const Xmm& x) {
+  opVmov(op, x, T_N2 | T_N_VL | T_F3 | T_0F38 | T_EW0 | T_YMM | T_MUST_EVEX | T_M_K, 0x22, false);
+}
+void vpmovsqd(const Operand& op, const Xmm& x) {
+  opVmov(op, x, T_N8 | T_N_VL | T_F3 | T_0F38 | T_EW0 | T_YMM | T_MUST_EVEX | T_M_K, 0x25, true);
+}
+void vpmovsqw(const Operand& op, const Xmm& x) {
+  opVmov(op, x, T_N4 | T_N_VL | T_F3 | T_0F38 | T_EW0 | T_YMM | T_MUST_EVEX | T_M_K, 0x24, false);
+}
+void vpmovswb(const Operand& op, const Xmm& x) {
+  opVmov(op, x, T_N8 | T_N_VL | T_F3 | T_0F38 | T_EW0 | T_YMM | T_MUST_EVEX | T_M_K, 0x20, true);
+}
+void vpmovusdb(const Operand& op, const Xmm& x) {
+  opVmov(op, x, T_N4 | T_N_VL | T_F3 | T_0F38 | T_EW0 | T_YMM | T_MUST_EVEX | T_M_K, 0x11, false);
+}
+void vpmovusdw(const Operand& op, const Xmm& x) {
+  opVmov(op, x, T_N8 | T_N_VL | T_F3 | T_0F38 | T_EW0 | T_YMM | T_MUST_EVEX | T_M_K, 0x13, true);
+}
+void vpmovusqb(const Operand& op, const Xmm& x) {
+  opVmov(op, x, T_N2 | T_N_VL | T_F3 | T_0F38 | T_EW0 | T_YMM | T_MUST_EVEX | T_M_K, 0x12, false);
+}
+void vpmovusqd(const Operand& op, const Xmm& x) {
+  opVmov(op, x, T_N8 | T_N_VL | T_F3 | T_0F38 | T_EW0 | T_YMM | T_MUST_EVEX | T_M_K, 0x15, true);
+}
+void vpmovusqw(const Operand& op, const Xmm& x) {
+  opVmov(op, x, T_N4 | T_N_VL | T_F3 | T_0F38 | T_EW0 | T_YMM | T_MUST_EVEX | T_M_K, 0x14, false);
+}
+void vpmovuswb(const Operand& op, const Xmm& x) {
+  opVmov(op, x, T_N8 | T_N_VL | T_F3 | T_0F38 | T_EW0 | T_YMM | T_MUST_EVEX | T_M_K, 0x10, true);
+}
 void vpmovw2m(const Opmask& k, const Xmm& x) { opVex(k, 0, x, T_F3 | T_0F38 | T_MUST_EVEX | T_YMM | T_EW1, 0x29); }
-void vpmovwb(const Operand& op, const Xmm& x) { opVmov(op, x, T_N8 | T_N_VL | T_F3 | T_0F38 | T_EW0 | T_YMM | T_MUST_EVEX | T_M_K, 0x30, true); }
-void vpmullq(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_EW1 | T_YMM | T_MUST_EVEX | T_B64, 0x40); }
-void vpmultishiftqb(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_EW1 | T_YMM | T_MUST_EVEX | T_B64, 0x83); }
-void vpopcntb(const Xmm& x, const Operand& op) { opAVX_X_XM_IMM(x, op, T_66 | T_0F38 | T_EW0 | T_YMM | T_SAE_Z | T_MUST_EVEX, 0x54); }
-void vpopcntd(const Xmm& x, const Operand& op) { opAVX_X_XM_IMM(x, op, T_66 | T_0F38 | T_EW0 | T_YMM | T_SAE_Z | T_MUST_EVEX | T_B32, 0x55); }
-void vpopcntq(const Xmm& x, const Operand& op) { opAVX_X_XM_IMM(x, op, T_66 | T_0F38 | T_EW1 | T_YMM | T_SAE_Z | T_MUST_EVEX | T_B64, 0x55); }
-void vpopcntw(const Xmm& x, const Operand& op) { opAVX_X_XM_IMM(x, op, T_66 | T_0F38 | T_EW1 | T_YMM | T_SAE_Z | T_MUST_EVEX, 0x54); }
-void vpord(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F | T_EW0 | T_YMM | T_MUST_EVEX | T_B32, 0xEB); }
-void vporq(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F | T_EW1 | T_YMM | T_MUST_EVEX | T_B64, 0xEB); }
-void vprold(const Xmm& x, const Operand& op, uint8_t imm) { opAVX_X_X_XM(Xmm(x.getKind(), 1), x, op, T_66 | T_0F | T_EW0 | T_YMM | T_MUST_EVEX | T_B32, 0x72, imm); }
-void vprolq(const Xmm& x, const Operand& op, uint8_t imm) { opAVX_X_X_XM(Xmm(x.getKind(), 1), x, op, T_66 | T_0F | T_EW1 | T_YMM | T_MUST_EVEX | T_B64, 0x72, imm); }
-void vprolvd(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_EW0 | T_YMM | T_MUST_EVEX | T_B32, 0x15); }
-void vprolvq(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_EW1 | T_YMM | T_MUST_EVEX | T_B64, 0x15); }
-void vprord(const Xmm& x, const Operand& op, uint8_t imm) { opAVX_X_X_XM(Xmm(x.getKind(), 0), x, op, T_66 | T_0F | T_EW0 | T_YMM | T_MUST_EVEX | T_B32, 0x72, imm); }
-void vprorq(const Xmm& x, const Operand& op, uint8_t imm) { opAVX_X_X_XM(Xmm(x.getKind(), 0), x, op, T_66 | T_0F | T_EW1 | T_YMM | T_MUST_EVEX | T_B64, 0x72, imm); }
-void vprorvd(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_EW0 | T_YMM | T_MUST_EVEX | T_B32, 0x14); }
-void vprorvq(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_EW1 | T_YMM | T_MUST_EVEX | T_B64, 0x14); }
-void vpscatterdd(const Address& addr, const Xmm& x) { opGather2(x, addr, T_N4 | T_66 | T_0F38 | T_EW0 | T_YMM | T_MUST_EVEX | T_M_K | T_VSIB, 0xA0, 0); }
-void vpscatterdq(const Address& addr, const Xmm& x) { opGather2(x, addr, T_N8 | T_66 | T_0F38 | T_EW1 | T_YMM | T_MUST_EVEX | T_M_K | T_VSIB, 0xA0, 1); }
-void vpscatterqd(const Address& addr, const Xmm& x) { opGather2(x, addr, T_N4 | T_66 | T_0F38 | T_EW0 | T_YMM | T_MUST_EVEX | T_M_K | T_VSIB, 0xA1, 2); }
-void vpscatterqq(const Address& addr, const Xmm& x) { opGather2(x, addr, T_N8 | T_66 | T_0F38 | T_EW1 | T_YMM | T_MUST_EVEX | T_M_K | T_VSIB, 0xA1, 0); }
-void vpshldd(const Xmm& x1, const Xmm& x2, const Operand& op, uint8_t imm) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F3A | T_EW0 | T_YMM | T_SAE_Z | T_MUST_EVEX | T_B32, 0x71, imm); }
-void vpshldq(const Xmm& x1, const Xmm& x2, const Operand& op, uint8_t imm) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F3A | T_EW1 | T_YMM | T_SAE_Z | T_MUST_EVEX | T_B64, 0x71, imm); }
-void vpshldvd(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_EW0 | T_YMM | T_SAE_Z | T_MUST_EVEX | T_B32, 0x71); }
-void vpshldvq(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_EW1 | T_YMM | T_SAE_Z | T_MUST_EVEX | T_B64, 0x71); }
-void vpshldvw(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_EW1 | T_YMM | T_SAE_Z | T_MUST_EVEX, 0x70); }
-void vpshldw(const Xmm& x1, const Xmm& x2, const Operand& op, uint8_t imm) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F3A | T_EW1 | T_YMM | T_SAE_Z | T_MUST_EVEX, 0x70, imm); }
-void vpshrdd(const Xmm& x1, const Xmm& x2, const Operand& op, uint8_t imm) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F3A | T_EW0 | T_YMM | T_SAE_Z | T_MUST_EVEX | T_B32, 0x73, imm); }
-void vpshrdq(const Xmm& x1, const Xmm& x2, const Operand& op, uint8_t imm) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F3A | T_EW1 | T_YMM | T_SAE_Z | T_MUST_EVEX | T_B64, 0x73, imm); }
-void vpshrdvd(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_EW0 | T_YMM | T_SAE_Z | T_MUST_EVEX | T_B32, 0x73); }
-void vpshrdvq(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_EW1 | T_YMM | T_SAE_Z | T_MUST_EVEX | T_B64, 0x73); }
-void vpshrdvw(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_EW1 | T_YMM | T_SAE_Z | T_MUST_EVEX, 0x72); }
-void vpshrdw(const Xmm& x1, const Xmm& x2, const Operand& op, uint8_t imm) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F3A | T_EW1 | T_YMM | T_SAE_Z | T_MUST_EVEX, 0x72, imm); }
-void vpshufbitqmb(const Opmask& k, const Xmm& x, const Operand& op) { opVex(k, &x, op, T_66 | T_0F38 | T_EW0 | T_YMM | T_MUST_EVEX, 0x8F); }
-void vpsllvw(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_EW1 | T_YMM | T_MUST_EVEX, 0x12); }
-void vpsraq(const Xmm& x, const Operand& op, uint8_t imm) { opAVX_X_X_XM(Xmm(x.getKind(), 4), x, op, T_66 | T_0F | T_EW1 | T_YMM | T_MUST_EVEX | T_B64, 0x72, imm); }
-void vpsraq(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_N16 | T_66 | T_0F | T_EW1 | T_YMM | T_MUST_EVEX, 0xE2); }
-void vpsravq(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_EW1 | T_YMM | T_MUST_EVEX | T_B64, 0x46); }
-void vpsravw(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_EW1 | T_YMM | T_MUST_EVEX, 0x11); }
-void vpsrlvw(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_EW1 | T_YMM | T_MUST_EVEX, 0x10); }
-void vpternlogd(const Xmm& x1, const Xmm& x2, const Operand& op, uint8_t imm) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F3A | T_EW0 | T_YMM | T_MUST_EVEX | T_B32, 0x25, imm); }
-void vpternlogq(const Xmm& x1, const Xmm& x2, const Operand& op, uint8_t imm) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F3A | T_EW1 | T_YMM | T_MUST_EVEX | T_B64, 0x25, imm); }
-void vptestmb(const Opmask& k, const Xmm& x, const Operand& op) { opAVX_K_X_XM(k, x, op, T_66 | T_0F38 | T_EW0 | T_YMM | T_MUST_EVEX, 0x26); }
-void vptestmd(const Opmask& k, const Xmm& x, const Operand& op) { opAVX_K_X_XM(k, x, op, T_66 | T_0F38 | T_EW0 | T_YMM | T_MUST_EVEX | T_B32, 0x27); }
-void vptestmq(const Opmask& k, const Xmm& x, const Operand& op) { opAVX_K_X_XM(k, x, op, T_66 | T_0F38 | T_EW1 | T_YMM | T_MUST_EVEX | T_B64, 0x27); }
-void vptestmw(const Opmask& k, const Xmm& x, const Operand& op) { opAVX_K_X_XM(k, x, op, T_66 | T_0F38 | T_EW1 | T_YMM | T_MUST_EVEX, 0x26); }
-void vptestnmb(const Opmask& k, const Xmm& x, const Operand& op) { opAVX_K_X_XM(k, x, op, T_F3 | T_0F38 | T_EW0 | T_YMM | T_MUST_EVEX, 0x26); }
-void vptestnmd(const Opmask& k, const Xmm& x, const Operand& op) { opAVX_K_X_XM(k, x, op, T_F3 | T_0F38 | T_EW0 | T_YMM | T_MUST_EVEX | T_B32, 0x27); }
-void vptestnmq(const Opmask& k, const Xmm& x, const Operand& op) { opAVX_K_X_XM(k, x, op, T_F3 | T_0F38 | T_EW1 | T_YMM | T_MUST_EVEX | T_B64, 0x27); }
-void vptestnmw(const Opmask& k, const Xmm& x, const Operand& op) { opAVX_K_X_XM(k, x, op, T_F3 | T_0F38 | T_EW1 | T_YMM | T_MUST_EVEX, 0x26); }
-void vpxord(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F | T_EW0 | T_YMM | T_MUST_EVEX | T_B32, 0xEF); }
-void vpxorq(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F | T_EW1 | T_YMM | T_MUST_EVEX | T_B64, 0xEF); }
-void vrangepd(const Xmm& x1, const Xmm& x2, const Operand& op, uint8_t imm) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F3A | T_EW1 | T_YMM | T_SAE_Z | T_MUST_EVEX | T_B64, 0x50, imm); }
-void vrangeps(const Xmm& x1, const Xmm& x2, const Operand& op, uint8_t imm) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F3A | T_EW0 | T_YMM | T_SAE_Z | T_MUST_EVEX | T_B32, 0x50, imm); }
-void vrangesd(const Xmm& x1, const Xmm& x2, const Operand& op, uint8_t imm) { opAVX_X_X_XM(x1, x2, op, T_N8 | T_66 | T_0F3A | T_EW1 | T_SAE_X | T_MUST_EVEX, 0x51, imm); }
-void vrangess(const Xmm& x1, const Xmm& x2, const Operand& op, uint8_t imm) { opAVX_X_X_XM(x1, x2, op, T_N4 | T_66 | T_0F3A | T_EW0 | T_SAE_X | T_MUST_EVEX, 0x51, imm); }
-void vrcp14pd(const Xmm& x, const Operand& op) { opAVX_X_XM_IMM(x, op, T_66 | T_0F38 | T_EW1 | T_YMM | T_MUST_EVEX | T_B64, 0x4C); }
-void vrcp14ps(const Xmm& x, const Operand& op) { opAVX_X_XM_IMM(x, op, T_66 | T_0F38 | T_EW0 | T_YMM | T_MUST_EVEX | T_B32, 0x4C); }
-void vrcp14sd(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_N8 | T_66 | T_0F38 | T_EW1 | T_MUST_EVEX, 0x4D); }
-void vrcp14ss(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_N4 | T_66 | T_0F38 | T_EW0 | T_MUST_EVEX, 0x4D); }
-void vrcp28pd(const Zmm& z, const Operand& op) { opAVX_X_XM_IMM(z, op, T_66 | T_0F38 | T_MUST_EVEX | T_YMM | T_EW1 | T_B64 | T_SAE_Z, 0xCA); }
-void vrcp28ps(const Zmm& z, const Operand& op) { opAVX_X_XM_IMM(z, op, T_66 | T_0F38 | T_MUST_EVEX | T_YMM | T_EW0 | T_B32 | T_SAE_Z, 0xCA); }
-void vrcp28sd(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_N8 | T_66 | T_0F38 | T_EW1 | T_SAE_X | T_MUST_EVEX, 0xCB); }
-void vrcp28ss(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_N4 | T_66 | T_0F38 | T_EW0 | T_SAE_X | T_MUST_EVEX, 0xCB); }
-void vrcpph(const Xmm& x, const Operand& op) { opAVX_X_XM_IMM(x, op, T_66 | T_MAP6 | T_EW0 | T_YMM | T_MUST_EVEX | T_B16, 0x4C); }
-void vrcpsh(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_N2 | T_66 | T_MAP6 | T_EW0 | T_MUST_EVEX, 0x4D); }
-void vreducepd(const Xmm& x, const Operand& op, uint8_t imm) { opAVX_X_XM_IMM(x, op, T_66 | T_0F3A | T_EW1 | T_YMM | T_SAE_Z | T_MUST_EVEX | T_B64, 0x56, imm); }
-void vreduceph(const Xmm& x, const Operand& op, uint8_t imm) { opAVX_X_XM_IMM(x, op, T_0F3A | T_EW0 | T_YMM | T_SAE_Z | T_MUST_EVEX | T_B16, 0x56, imm); }
-void vreduceps(const Xmm& x, const Operand& op, uint8_t imm) { opAVX_X_XM_IMM(x, op, T_66 | T_0F3A | T_EW0 | T_YMM | T_SAE_Z | T_MUST_EVEX | T_B32, 0x56, imm); }
-void vreducesd(const Xmm& x1, const Xmm& x2, const Operand& op, uint8_t imm) { opAVX_X_X_XM(x1, x2, op, T_N8 | T_66 | T_0F3A | T_EW1 | T_SAE_X | T_MUST_EVEX, 0x57, imm); }
-void vreducesh(const Xmm& x1, const Xmm& x2, const Operand& op, uint8_t imm) { opAVX_X_X_XM(x1, x2, op, T_N2 | T_0F3A | T_EW0 | T_SAE_X | T_MUST_EVEX, 0x57, imm); }
-void vreducess(const Xmm& x1, const Xmm& x2, const Operand& op, uint8_t imm) { opAVX_X_X_XM(x1, x2, op, T_N4 | T_66 | T_0F3A | T_EW0 | T_SAE_X | T_MUST_EVEX, 0x57, imm); }
-void vrndscalepd(const Xmm& x, const Operand& op, uint8_t imm) { opAVX_X_XM_IMM(x, op, T_66 | T_0F3A | T_EW1 | T_YMM | T_SAE_Z | T_MUST_EVEX | T_B64, 0x09, imm); }
-void vrndscaleph(const Xmm& x, const Operand& op, uint8_t imm) { opAVX_X_XM_IMM(x, op, T_0F3A | T_EW0 | T_YMM | T_SAE_Z | T_MUST_EVEX | T_B16, 0x08, imm); }
-void vrndscaleps(const Xmm& x, const Operand& op, uint8_t imm) { opAVX_X_XM_IMM(x, op, T_66 | T_0F3A | T_EW0 | T_YMM | T_SAE_Z | T_MUST_EVEX | T_B32, 0x08, imm); }
-void vrndscalesd(const Xmm& x1, const Xmm& x2, const Operand& op, uint8_t imm) { opAVX_X_X_XM(x1, x2, op, T_N8 | T_66 | T_0F3A | T_EW1 | T_SAE_X | T_MUST_EVEX, 0x0B, imm); }
-void vrndscalesh(const Xmm& x1, const Xmm& x2, const Operand& op, uint8_t imm) { opAVX_X_X_XM(x1, x2, op, T_N2 | T_0F3A | T_EW0 | T_SAE_X | T_MUST_EVEX, 0x0A, imm); }
-void vrndscaless(const Xmm& x1, const Xmm& x2, const Operand& op, uint8_t imm) { opAVX_X_X_XM(x1, x2, op, T_N4 | T_66 | T_0F3A | T_EW0 | T_SAE_X | T_MUST_EVEX, 0x0A, imm); }
-void vrsqrt14pd(const Xmm& x, const Operand& op) { opAVX_X_XM_IMM(x, op, T_66 | T_0F38 | T_EW1 | T_YMM | T_MUST_EVEX | T_B64, 0x4E); }
-void vrsqrt14ps(const Xmm& x, const Operand& op) { opAVX_X_XM_IMM(x, op, T_66 | T_0F38 | T_EW0 | T_YMM | T_MUST_EVEX | T_B32, 0x4E); }
-void vrsqrt14sd(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_N8 | T_66 | T_0F38 | T_EW1 | T_YMM | T_MUST_EVEX, 0x4F); }
-void vrsqrt14ss(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_N4 | T_66 | T_0F38 | T_EW0 | T_YMM | T_MUST_EVEX, 0x4F); }
-void vrsqrt28pd(const Zmm& z, const Operand& op) { opAVX_X_XM_IMM(z, op, T_66 | T_0F38 | T_MUST_EVEX | T_YMM | T_EW1 | T_B64 | T_SAE_Z, 0xCC); }
-void vrsqrt28ps(const Zmm& z, const Operand& op) { opAVX_X_XM_IMM(z, op, T_66 | T_0F38 | T_MUST_EVEX | T_YMM | T_EW0 | T_B32 | T_SAE_Z, 0xCC); }
-void vrsqrt28sd(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_N8 | T_66 | T_0F38 | T_EW1 | T_SAE_X | T_MUST_EVEX, 0xCD); }
-void vrsqrt28ss(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_N4 | T_66 | T_0F38 | T_EW0 | T_SAE_X | T_MUST_EVEX, 0xCD); }
-void vrsqrtph(const Xmm& x, const Operand& op) { opAVX_X_XM_IMM(x, op, T_66 | T_MAP6 | T_EW0 | T_YMM | T_MUST_EVEX | T_B16, 0x4E); }
-void vrsqrtsh(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_N2 | T_66 | T_MAP6 | T_EW0 | T_MUST_EVEX, 0x4F); }
-void vscalefpd(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_EW1 | T_YMM | T_ER_Z | T_MUST_EVEX | T_B64, 0x2C); }
-void vscalefph(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_MAP6 | T_EW0 | T_YMM | T_ER_Z | T_MUST_EVEX | T_B16, 0x2C); }
-void vscalefps(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_EW0 | T_YMM | T_ER_Z | T_MUST_EVEX | T_B32, 0x2C); }
-void vscalefsd(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_N8 | T_66 | T_0F38 | T_EW1 | T_ER_X | T_MUST_EVEX, 0x2D); }
-void vscalefsh(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_N2 | T_66 | T_MAP6 | T_EW0 | T_ER_X | T_MUST_EVEX, 0x2D); }
-void vscalefss(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_N4 | T_66 | T_0F38 | T_EW0 | T_ER_X | T_MUST_EVEX, 0x2D); }
-void vscatterdpd(const Address& addr, const Xmm& x) { opGather2(x, addr, T_N8 | T_66 | T_0F38 | T_EW1 | T_YMM | T_MUST_EVEX | T_M_K | T_VSIB, 0xA2, 1); }
-void vscatterdps(const Address& addr, const Xmm& x) { opGather2(x, addr, T_N4 | T_66 | T_0F38 | T_EW0 | T_YMM | T_MUST_EVEX | T_M_K | T_VSIB, 0xA2, 0); }
-void vscatterpf0dpd(const Address& addr) { opGatherFetch(addr, zm5, T_N8 | T_66 | T_0F38 | T_EW1 | T_MUST_EVEX | T_M_K | T_VSIB, 0xC6, Operand::YMM); }
-void vscatterpf0dps(const Address& addr) { opGatherFetch(addr, zm5, T_N4 | T_66 | T_0F38 | T_EW0 | T_MUST_EVEX | T_M_K | T_VSIB, 0xC6, Operand::ZMM); }
-void vscatterpf0qpd(const Address& addr) { opGatherFetch(addr, zm5, T_N8 | T_66 | T_0F38 | T_EW1 | T_MUST_EVEX | T_M_K | T_VSIB, 0xC7, Operand::ZMM); }
-void vscatterpf0qps(const Address& addr) { opGatherFetch(addr, zm5, T_N4 | T_66 | T_0F38 | T_EW0 | T_MUST_EVEX | T_M_K | T_VSIB, 0xC7, Operand::ZMM); }
-void vscatterpf1dpd(const Address& addr) { opGatherFetch(addr, zm6, T_N8 | T_66 | T_0F38 | T_EW1 | T_MUST_EVEX | T_M_K | T_VSIB, 0xC6, Operand::YMM); }
-void vscatterpf1dps(const Address& addr) { opGatherFetch(addr, zm6, T_N4 | T_66 | T_0F38 | T_EW0 | T_MUST_EVEX | T_M_K | T_VSIB, 0xC6, Operand::ZMM); }
-void vscatterpf1qpd(const Address& addr) { opGatherFetch(addr, zm6, T_N8 | T_66 | T_0F38 | T_EW1 | T_MUST_EVEX | T_M_K | T_VSIB, 0xC7, Operand::ZMM); }
-void vscatterpf1qps(const Address& addr) { opGatherFetch(addr, zm6, T_N4 | T_66 | T_0F38 | T_EW0 | T_MUST_EVEX | T_M_K | T_VSIB, 0xC7, Operand::ZMM); }
-void vscatterqpd(const Address& addr, const Xmm& x) { opGather2(x, addr, T_N8 | T_66 | T_0F38 | T_EW1 | T_YMM | T_MUST_EVEX | T_M_K | T_VSIB, 0xA3, 0); }
-void vscatterqps(const Address& addr, const Xmm& x) { opGather2(x, addr, T_N4 | T_66 | T_0F38 | T_EW0 | T_YMM | T_MUST_EVEX | T_M_K | T_VSIB, 0xA3, 2); }
-void vshuff32x4(const Ymm& y1, const Ymm& y2, const Operand& op, uint8_t imm) { opAVX_X_X_XM(y1, y2, op, T_66 | T_0F3A | T_YMM | T_MUST_EVEX | T_EW0 | T_B32, 0x23, imm); }
-void vshuff64x2(const Ymm& y1, const Ymm& y2, const Operand& op, uint8_t imm) { opAVX_X_X_XM(y1, y2, op, T_66 | T_0F3A | T_YMM | T_MUST_EVEX | T_EW1 | T_B64, 0x23, imm); }
-void vshufi32x4(const Ymm& y1, const Ymm& y2, const Operand& op, uint8_t imm) { opAVX_X_X_XM(y1, y2, op, T_66 | T_0F3A | T_YMM | T_MUST_EVEX | T_EW0 | T_B32, 0x43, imm); }
-void vshufi64x2(const Ymm& y1, const Ymm& y2, const Operand& op, uint8_t imm) { opAVX_X_X_XM(y1, y2, op, T_66 | T_0F3A | T_YMM | T_MUST_EVEX | T_EW1 | T_B64, 0x43, imm); }
-void vsqrtph(const Xmm& x, const Operand& op) { opAVX_X_XM_IMM(x, op, T_MAP5 | T_EW0 | T_YMM | T_ER_Z | T_MUST_EVEX | T_B16, 0x51); }
-void vsqrtsh(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, T_N2 | T_F3 | T_MAP5 | T_EW0 | T_ER_X | T_MUST_EVEX, 0x51); }
-void vsubph(const Xmm& xmm, const Operand& op1, const Operand& op2 = Operand()) { opAVX_X_X_XM(xmm, op1, op2, T_MAP5 | T_EW0 | T_YMM | T_MUST_EVEX | T_ER_Z | T_B16, 0x5C); }
-void vsubsh(const Xmm& xmm, const Operand& op1, const Operand& op2 = Operand()) { opAVX_X_X_XM(xmm, op1, op2, T_MAP5 | T_F3 | T_EW0 | T_MUST_EVEX | T_ER_X | T_N2, 0x5C); }
-void vucomish(const Xmm& x, const Operand& op) { opAVX_X_XM_IMM(x, op, T_MAP5 | T_MUST_EVEX | T_EW0 | T_SAE_X | T_N2, 0x2E); }
+void vpmovwb(const Operand& op, const Xmm& x) {
+  opVmov(op, x, T_N8 | T_N_VL | T_F3 | T_0F38 | T_EW0 | T_YMM | T_MUST_EVEX | T_M_K, 0x30, true);
+}
+void vpmullq(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_EW1 | T_YMM | T_MUST_EVEX | T_B64, 0x40);
+}
+void vpmultishiftqb(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_EW1 | T_YMM | T_MUST_EVEX | T_B64, 0x83);
+}
+void vpopcntb(const Xmm& x, const Operand& op) {
+  opAVX_X_XM_IMM(x, op, T_66 | T_0F38 | T_EW0 | T_YMM | T_SAE_Z | T_MUST_EVEX, 0x54);
+}
+void vpopcntd(const Xmm& x, const Operand& op) {
+  opAVX_X_XM_IMM(x, op, T_66 | T_0F38 | T_EW0 | T_YMM | T_SAE_Z | T_MUST_EVEX | T_B32, 0x55);
+}
+void vpopcntq(const Xmm& x, const Operand& op) {
+  opAVX_X_XM_IMM(x, op, T_66 | T_0F38 | T_EW1 | T_YMM | T_SAE_Z | T_MUST_EVEX | T_B64, 0x55);
+}
+void vpopcntw(const Xmm& x, const Operand& op) {
+  opAVX_X_XM_IMM(x, op, T_66 | T_0F38 | T_EW1 | T_YMM | T_SAE_Z | T_MUST_EVEX, 0x54);
+}
+void vpord(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F | T_EW0 | T_YMM | T_MUST_EVEX | T_B32, 0xEB);
+}
+void vporq(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F | T_EW1 | T_YMM | T_MUST_EVEX | T_B64, 0xEB);
+}
+void vprold(const Xmm& x, const Operand& op, uint8_t imm) {
+  opAVX_X_X_XM(Xmm(x.getKind(), 1), x, op, T_66 | T_0F | T_EW0 | T_YMM | T_MUST_EVEX | T_B32, 0x72, imm);
+}
+void vprolq(const Xmm& x, const Operand& op, uint8_t imm) {
+  opAVX_X_X_XM(Xmm(x.getKind(), 1), x, op, T_66 | T_0F | T_EW1 | T_YMM | T_MUST_EVEX | T_B64, 0x72, imm);
+}
+void vprolvd(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_EW0 | T_YMM | T_MUST_EVEX | T_B32, 0x15);
+}
+void vprolvq(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_EW1 | T_YMM | T_MUST_EVEX | T_B64, 0x15);
+}
+void vprord(const Xmm& x, const Operand& op, uint8_t imm) {
+  opAVX_X_X_XM(Xmm(x.getKind(), 0), x, op, T_66 | T_0F | T_EW0 | T_YMM | T_MUST_EVEX | T_B32, 0x72, imm);
+}
+void vprorq(const Xmm& x, const Operand& op, uint8_t imm) {
+  opAVX_X_X_XM(Xmm(x.getKind(), 0), x, op, T_66 | T_0F | T_EW1 | T_YMM | T_MUST_EVEX | T_B64, 0x72, imm);
+}
+void vprorvd(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_EW0 | T_YMM | T_MUST_EVEX | T_B32, 0x14);
+}
+void vprorvq(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_EW1 | T_YMM | T_MUST_EVEX | T_B64, 0x14);
+}
+void vpscatterdd(const Address& addr, const Xmm& x) {
+  opGather2(x, addr, T_N4 | T_66 | T_0F38 | T_EW0 | T_YMM | T_MUST_EVEX | T_M_K | T_VSIB, 0xA0, 0);
+}
+void vpscatterdq(const Address& addr, const Xmm& x) {
+  opGather2(x, addr, T_N8 | T_66 | T_0F38 | T_EW1 | T_YMM | T_MUST_EVEX | T_M_K | T_VSIB, 0xA0, 1);
+}
+void vpscatterqd(const Address& addr, const Xmm& x) {
+  opGather2(x, addr, T_N4 | T_66 | T_0F38 | T_EW0 | T_YMM | T_MUST_EVEX | T_M_K | T_VSIB, 0xA1, 2);
+}
+void vpscatterqq(const Address& addr, const Xmm& x) {
+  opGather2(x, addr, T_N8 | T_66 | T_0F38 | T_EW1 | T_YMM | T_MUST_EVEX | T_M_K | T_VSIB, 0xA1, 0);
+}
+void vpshldd(const Xmm& x1, const Xmm& x2, const Operand& op, uint8_t imm) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F3A | T_EW0 | T_YMM | T_SAE_Z | T_MUST_EVEX | T_B32, 0x71, imm);
+}
+void vpshldq(const Xmm& x1, const Xmm& x2, const Operand& op, uint8_t imm) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F3A | T_EW1 | T_YMM | T_SAE_Z | T_MUST_EVEX | T_B64, 0x71, imm);
+}
+void vpshldvd(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_EW0 | T_YMM | T_SAE_Z | T_MUST_EVEX | T_B32, 0x71);
+}
+void vpshldvq(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_EW1 | T_YMM | T_SAE_Z | T_MUST_EVEX | T_B64, 0x71);
+}
+void vpshldvw(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_EW1 | T_YMM | T_SAE_Z | T_MUST_EVEX, 0x70);
+}
+void vpshldw(const Xmm& x1, const Xmm& x2, const Operand& op, uint8_t imm) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F3A | T_EW1 | T_YMM | T_SAE_Z | T_MUST_EVEX, 0x70, imm);
+}
+void vpshrdd(const Xmm& x1, const Xmm& x2, const Operand& op, uint8_t imm) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F3A | T_EW0 | T_YMM | T_SAE_Z | T_MUST_EVEX | T_B32, 0x73, imm);
+}
+void vpshrdq(const Xmm& x1, const Xmm& x2, const Operand& op, uint8_t imm) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F3A | T_EW1 | T_YMM | T_SAE_Z | T_MUST_EVEX | T_B64, 0x73, imm);
+}
+void vpshrdvd(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_EW0 | T_YMM | T_SAE_Z | T_MUST_EVEX | T_B32, 0x73);
+}
+void vpshrdvq(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_EW1 | T_YMM | T_SAE_Z | T_MUST_EVEX | T_B64, 0x73);
+}
+void vpshrdvw(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_EW1 | T_YMM | T_SAE_Z | T_MUST_EVEX, 0x72);
+}
+void vpshrdw(const Xmm& x1, const Xmm& x2, const Operand& op, uint8_t imm) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F3A | T_EW1 | T_YMM | T_SAE_Z | T_MUST_EVEX, 0x72, imm);
+}
+void vpshufbitqmb(const Opmask& k, const Xmm& x, const Operand& op) {
+  opVex(k, &x, op, T_66 | T_0F38 | T_EW0 | T_YMM | T_MUST_EVEX, 0x8F);
+}
+void vpsllvw(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_EW1 | T_YMM | T_MUST_EVEX, 0x12);
+}
+void vpsraq(const Xmm& x, const Operand& op, uint8_t imm) {
+  opAVX_X_X_XM(Xmm(x.getKind(), 4), x, op, T_66 | T_0F | T_EW1 | T_YMM | T_MUST_EVEX | T_B64, 0x72, imm);
+}
+void vpsraq(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_N16 | T_66 | T_0F | T_EW1 | T_YMM | T_MUST_EVEX, 0xE2);
+}
+void vpsravq(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_EW1 | T_YMM | T_MUST_EVEX | T_B64, 0x46);
+}
+void vpsravw(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_EW1 | T_YMM | T_MUST_EVEX, 0x11);
+}
+void vpsrlvw(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_EW1 | T_YMM | T_MUST_EVEX, 0x10);
+}
+void vpternlogd(const Xmm& x1, const Xmm& x2, const Operand& op, uint8_t imm) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F3A | T_EW0 | T_YMM | T_MUST_EVEX | T_B32, 0x25, imm);
+}
+void vpternlogq(const Xmm& x1, const Xmm& x2, const Operand& op, uint8_t imm) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F3A | T_EW1 | T_YMM | T_MUST_EVEX | T_B64, 0x25, imm);
+}
+void vptestmb(const Opmask& k, const Xmm& x, const Operand& op) {
+  opAVX_K_X_XM(k, x, op, T_66 | T_0F38 | T_EW0 | T_YMM | T_MUST_EVEX, 0x26);
+}
+void vptestmd(const Opmask& k, const Xmm& x, const Operand& op) {
+  opAVX_K_X_XM(k, x, op, T_66 | T_0F38 | T_EW0 | T_YMM | T_MUST_EVEX | T_B32, 0x27);
+}
+void vptestmq(const Opmask& k, const Xmm& x, const Operand& op) {
+  opAVX_K_X_XM(k, x, op, T_66 | T_0F38 | T_EW1 | T_YMM | T_MUST_EVEX | T_B64, 0x27);
+}
+void vptestmw(const Opmask& k, const Xmm& x, const Operand& op) {
+  opAVX_K_X_XM(k, x, op, T_66 | T_0F38 | T_EW1 | T_YMM | T_MUST_EVEX, 0x26);
+}
+void vptestnmb(const Opmask& k, const Xmm& x, const Operand& op) {
+  opAVX_K_X_XM(k, x, op, T_F3 | T_0F38 | T_EW0 | T_YMM | T_MUST_EVEX, 0x26);
+}
+void vptestnmd(const Opmask& k, const Xmm& x, const Operand& op) {
+  opAVX_K_X_XM(k, x, op, T_F3 | T_0F38 | T_EW0 | T_YMM | T_MUST_EVEX | T_B32, 0x27);
+}
+void vptestnmq(const Opmask& k, const Xmm& x, const Operand& op) {
+  opAVX_K_X_XM(k, x, op, T_F3 | T_0F38 | T_EW1 | T_YMM | T_MUST_EVEX | T_B64, 0x27);
+}
+void vptestnmw(const Opmask& k, const Xmm& x, const Operand& op) {
+  opAVX_K_X_XM(k, x, op, T_F3 | T_0F38 | T_EW1 | T_YMM | T_MUST_EVEX, 0x26);
+}
+void vpxord(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F | T_EW0 | T_YMM | T_MUST_EVEX | T_B32, 0xEF);
+}
+void vpxorq(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F | T_EW1 | T_YMM | T_MUST_EVEX | T_B64, 0xEF);
+}
+void vrangepd(const Xmm& x1, const Xmm& x2, const Operand& op, uint8_t imm) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F3A | T_EW1 | T_YMM | T_SAE_Z | T_MUST_EVEX | T_B64, 0x50, imm);
+}
+void vrangeps(const Xmm& x1, const Xmm& x2, const Operand& op, uint8_t imm) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F3A | T_EW0 | T_YMM | T_SAE_Z | T_MUST_EVEX | T_B32, 0x50, imm);
+}
+void vrangesd(const Xmm& x1, const Xmm& x2, const Operand& op, uint8_t imm) {
+  opAVX_X_X_XM(x1, x2, op, T_N8 | T_66 | T_0F3A | T_EW1 | T_SAE_X | T_MUST_EVEX, 0x51, imm);
+}
+void vrangess(const Xmm& x1, const Xmm& x2, const Operand& op, uint8_t imm) {
+  opAVX_X_X_XM(x1, x2, op, T_N4 | T_66 | T_0F3A | T_EW0 | T_SAE_X | T_MUST_EVEX, 0x51, imm);
+}
+void vrcp14pd(const Xmm& x, const Operand& op) {
+  opAVX_X_XM_IMM(x, op, T_66 | T_0F38 | T_EW1 | T_YMM | T_MUST_EVEX | T_B64, 0x4C);
+}
+void vrcp14ps(const Xmm& x, const Operand& op) {
+  opAVX_X_XM_IMM(x, op, T_66 | T_0F38 | T_EW0 | T_YMM | T_MUST_EVEX | T_B32, 0x4C);
+}
+void vrcp14sd(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_N8 | T_66 | T_0F38 | T_EW1 | T_MUST_EVEX, 0x4D);
+}
+void vrcp14ss(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_N4 | T_66 | T_0F38 | T_EW0 | T_MUST_EVEX, 0x4D);
+}
+void vrcp28pd(const Zmm& z, const Operand& op) {
+  opAVX_X_XM_IMM(z, op, T_66 | T_0F38 | T_MUST_EVEX | T_YMM | T_EW1 | T_B64 | T_SAE_Z, 0xCA);
+}
+void vrcp28ps(const Zmm& z, const Operand& op) {
+  opAVX_X_XM_IMM(z, op, T_66 | T_0F38 | T_MUST_EVEX | T_YMM | T_EW0 | T_B32 | T_SAE_Z, 0xCA);
+}
+void vrcp28sd(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_N8 | T_66 | T_0F38 | T_EW1 | T_SAE_X | T_MUST_EVEX, 0xCB);
+}
+void vrcp28ss(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_N4 | T_66 | T_0F38 | T_EW0 | T_SAE_X | T_MUST_EVEX, 0xCB);
+}
+void vrcpph(const Xmm& x, const Operand& op) {
+  opAVX_X_XM_IMM(x, op, T_66 | T_MAP6 | T_EW0 | T_YMM | T_MUST_EVEX | T_B16, 0x4C);
+}
+void vrcpsh(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_N2 | T_66 | T_MAP6 | T_EW0 | T_MUST_EVEX, 0x4D);
+}
+void vreducepd(const Xmm& x, const Operand& op, uint8_t imm) {
+  opAVX_X_XM_IMM(x, op, T_66 | T_0F3A | T_EW1 | T_YMM | T_SAE_Z | T_MUST_EVEX | T_B64, 0x56, imm);
+}
+void vreduceph(const Xmm& x, const Operand& op, uint8_t imm) {
+  opAVX_X_XM_IMM(x, op, T_0F3A | T_EW0 | T_YMM | T_SAE_Z | T_MUST_EVEX | T_B16, 0x56, imm);
+}
+void vreduceps(const Xmm& x, const Operand& op, uint8_t imm) {
+  opAVX_X_XM_IMM(x, op, T_66 | T_0F3A | T_EW0 | T_YMM | T_SAE_Z | T_MUST_EVEX | T_B32, 0x56, imm);
+}
+void vreducesd(const Xmm& x1, const Xmm& x2, const Operand& op, uint8_t imm) {
+  opAVX_X_X_XM(x1, x2, op, T_N8 | T_66 | T_0F3A | T_EW1 | T_SAE_X | T_MUST_EVEX, 0x57, imm);
+}
+void vreducesh(const Xmm& x1, const Xmm& x2, const Operand& op, uint8_t imm) {
+  opAVX_X_X_XM(x1, x2, op, T_N2 | T_0F3A | T_EW0 | T_SAE_X | T_MUST_EVEX, 0x57, imm);
+}
+void vreducess(const Xmm& x1, const Xmm& x2, const Operand& op, uint8_t imm) {
+  opAVX_X_X_XM(x1, x2, op, T_N4 | T_66 | T_0F3A | T_EW0 | T_SAE_X | T_MUST_EVEX, 0x57, imm);
+}
+void vrndscalepd(const Xmm& x, const Operand& op, uint8_t imm) {
+  opAVX_X_XM_IMM(x, op, T_66 | T_0F3A | T_EW1 | T_YMM | T_SAE_Z | T_MUST_EVEX | T_B64, 0x09, imm);
+}
+void vrndscaleph(const Xmm& x, const Operand& op, uint8_t imm) {
+  opAVX_X_XM_IMM(x, op, T_0F3A | T_EW0 | T_YMM | T_SAE_Z | T_MUST_EVEX | T_B16, 0x08, imm);
+}
+void vrndscaleps(const Xmm& x, const Operand& op, uint8_t imm) {
+  opAVX_X_XM_IMM(x, op, T_66 | T_0F3A | T_EW0 | T_YMM | T_SAE_Z | T_MUST_EVEX | T_B32, 0x08, imm);
+}
+void vrndscalesd(const Xmm& x1, const Xmm& x2, const Operand& op, uint8_t imm) {
+  opAVX_X_X_XM(x1, x2, op, T_N8 | T_66 | T_0F3A | T_EW1 | T_SAE_X | T_MUST_EVEX, 0x0B, imm);
+}
+void vrndscalesh(const Xmm& x1, const Xmm& x2, const Operand& op, uint8_t imm) {
+  opAVX_X_X_XM(x1, x2, op, T_N2 | T_0F3A | T_EW0 | T_SAE_X | T_MUST_EVEX, 0x0A, imm);
+}
+void vrndscaless(const Xmm& x1, const Xmm& x2, const Operand& op, uint8_t imm) {
+  opAVX_X_X_XM(x1, x2, op, T_N4 | T_66 | T_0F3A | T_EW0 | T_SAE_X | T_MUST_EVEX, 0x0A, imm);
+}
+void vrsqrt14pd(const Xmm& x, const Operand& op) {
+  opAVX_X_XM_IMM(x, op, T_66 | T_0F38 | T_EW1 | T_YMM | T_MUST_EVEX | T_B64, 0x4E);
+}
+void vrsqrt14ps(const Xmm& x, const Operand& op) {
+  opAVX_X_XM_IMM(x, op, T_66 | T_0F38 | T_EW0 | T_YMM | T_MUST_EVEX | T_B32, 0x4E);
+}
+void vrsqrt14sd(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_N8 | T_66 | T_0F38 | T_EW1 | T_YMM | T_MUST_EVEX, 0x4F);
+}
+void vrsqrt14ss(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_N4 | T_66 | T_0F38 | T_EW0 | T_YMM | T_MUST_EVEX, 0x4F);
+}
+void vrsqrt28pd(const Zmm& z, const Operand& op) {
+  opAVX_X_XM_IMM(z, op, T_66 | T_0F38 | T_MUST_EVEX | T_YMM | T_EW1 | T_B64 | T_SAE_Z, 0xCC);
+}
+void vrsqrt28ps(const Zmm& z, const Operand& op) {
+  opAVX_X_XM_IMM(z, op, T_66 | T_0F38 | T_MUST_EVEX | T_YMM | T_EW0 | T_B32 | T_SAE_Z, 0xCC);
+}
+void vrsqrt28sd(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_N8 | T_66 | T_0F38 | T_EW1 | T_SAE_X | T_MUST_EVEX, 0xCD);
+}
+void vrsqrt28ss(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_N4 | T_66 | T_0F38 | T_EW0 | T_SAE_X | T_MUST_EVEX, 0xCD);
+}
+void vrsqrtph(const Xmm& x, const Operand& op) {
+  opAVX_X_XM_IMM(x, op, T_66 | T_MAP6 | T_EW0 | T_YMM | T_MUST_EVEX | T_B16, 0x4E);
+}
+void vrsqrtsh(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_N2 | T_66 | T_MAP6 | T_EW0 | T_MUST_EVEX, 0x4F);
+}
+void vscalefpd(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_EW1 | T_YMM | T_ER_Z | T_MUST_EVEX | T_B64, 0x2C);
+}
+void vscalefph(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_MAP6 | T_EW0 | T_YMM | T_ER_Z | T_MUST_EVEX | T_B16, 0x2C);
+}
+void vscalefps(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_66 | T_0F38 | T_EW0 | T_YMM | T_ER_Z | T_MUST_EVEX | T_B32, 0x2C);
+}
+void vscalefsd(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_N8 | T_66 | T_0F38 | T_EW1 | T_ER_X | T_MUST_EVEX, 0x2D);
+}
+void vscalefsh(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_N2 | T_66 | T_MAP6 | T_EW0 | T_ER_X | T_MUST_EVEX, 0x2D);
+}
+void vscalefss(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_N4 | T_66 | T_0F38 | T_EW0 | T_ER_X | T_MUST_EVEX, 0x2D);
+}
+void vscatterdpd(const Address& addr, const Xmm& x) {
+  opGather2(x, addr, T_N8 | T_66 | T_0F38 | T_EW1 | T_YMM | T_MUST_EVEX | T_M_K | T_VSIB, 0xA2, 1);
+}
+void vscatterdps(const Address& addr, const Xmm& x) {
+  opGather2(x, addr, T_N4 | T_66 | T_0F38 | T_EW0 | T_YMM | T_MUST_EVEX | T_M_K | T_VSIB, 0xA2, 0);
+}
+void vscatterpf0dpd(const Address& addr) {
+  opGatherFetch(addr, zm5, T_N8 | T_66 | T_0F38 | T_EW1 | T_MUST_EVEX | T_M_K | T_VSIB, 0xC6, Operand::YMM);
+}
+void vscatterpf0dps(const Address& addr) {
+  opGatherFetch(addr, zm5, T_N4 | T_66 | T_0F38 | T_EW0 | T_MUST_EVEX | T_M_K | T_VSIB, 0xC6, Operand::ZMM);
+}
+void vscatterpf0qpd(const Address& addr) {
+  opGatherFetch(addr, zm5, T_N8 | T_66 | T_0F38 | T_EW1 | T_MUST_EVEX | T_M_K | T_VSIB, 0xC7, Operand::ZMM);
+}
+void vscatterpf0qps(const Address& addr) {
+  opGatherFetch(addr, zm5, T_N4 | T_66 | T_0F38 | T_EW0 | T_MUST_EVEX | T_M_K | T_VSIB, 0xC7, Operand::ZMM);
+}
+void vscatterpf1dpd(const Address& addr) {
+  opGatherFetch(addr, zm6, T_N8 | T_66 | T_0F38 | T_EW1 | T_MUST_EVEX | T_M_K | T_VSIB, 0xC6, Operand::YMM);
+}
+void vscatterpf1dps(const Address& addr) {
+  opGatherFetch(addr, zm6, T_N4 | T_66 | T_0F38 | T_EW0 | T_MUST_EVEX | T_M_K | T_VSIB, 0xC6, Operand::ZMM);
+}
+void vscatterpf1qpd(const Address& addr) {
+  opGatherFetch(addr, zm6, T_N8 | T_66 | T_0F38 | T_EW1 | T_MUST_EVEX | T_M_K | T_VSIB, 0xC7, Operand::ZMM);
+}
+void vscatterpf1qps(const Address& addr) {
+  opGatherFetch(addr, zm6, T_N4 | T_66 | T_0F38 | T_EW0 | T_MUST_EVEX | T_M_K | T_VSIB, 0xC7, Operand::ZMM);
+}
+void vscatterqpd(const Address& addr, const Xmm& x) {
+  opGather2(x, addr, T_N8 | T_66 | T_0F38 | T_EW1 | T_YMM | T_MUST_EVEX | T_M_K | T_VSIB, 0xA3, 0);
+}
+void vscatterqps(const Address& addr, const Xmm& x) {
+  opGather2(x, addr, T_N4 | T_66 | T_0F38 | T_EW0 | T_YMM | T_MUST_EVEX | T_M_K | T_VSIB, 0xA3, 2);
+}
+void vshuff32x4(const Ymm& y1, const Ymm& y2, const Operand& op, uint8_t imm) {
+  opAVX_X_X_XM(y1, y2, op, T_66 | T_0F3A | T_YMM | T_MUST_EVEX | T_EW0 | T_B32, 0x23, imm);
+}
+void vshuff64x2(const Ymm& y1, const Ymm& y2, const Operand& op, uint8_t imm) {
+  opAVX_X_X_XM(y1, y2, op, T_66 | T_0F3A | T_YMM | T_MUST_EVEX | T_EW1 | T_B64, 0x23, imm);
+}
+void vshufi32x4(const Ymm& y1, const Ymm& y2, const Operand& op, uint8_t imm) {
+  opAVX_X_X_XM(y1, y2, op, T_66 | T_0F3A | T_YMM | T_MUST_EVEX | T_EW0 | T_B32, 0x43, imm);
+}
+void vshufi64x2(const Ymm& y1, const Ymm& y2, const Operand& op, uint8_t imm) {
+  opAVX_X_X_XM(y1, y2, op, T_66 | T_0F3A | T_YMM | T_MUST_EVEX | T_EW1 | T_B64, 0x43, imm);
+}
+void vsqrtph(const Xmm& x, const Operand& op) {
+  opAVX_X_XM_IMM(x, op, T_MAP5 | T_EW0 | T_YMM | T_ER_Z | T_MUST_EVEX | T_B16, 0x51);
+}
+void vsqrtsh(const Xmm& x1, const Xmm& x2, const Operand& op) {
+  opAVX_X_X_XM(x1, x2, op, T_N2 | T_F3 | T_MAP5 | T_EW0 | T_ER_X | T_MUST_EVEX, 0x51);
+}
+void vsubph(const Xmm& xmm, const Operand& op1, const Operand& op2 = Operand()) {
+  opAVX_X_X_XM(xmm, op1, op2, T_MAP5 | T_EW0 | T_YMM | T_MUST_EVEX | T_ER_Z | T_B16, 0x5C);
+}
+void vsubsh(const Xmm& xmm, const Operand& op1, const Operand& op2 = Operand()) {
+  opAVX_X_X_XM(xmm, op1, op2, T_MAP5 | T_F3 | T_EW0 | T_MUST_EVEX | T_ER_X | T_N2, 0x5C);
+}
+void vucomish(const Xmm& x, const Operand& op) {
+  opAVX_X_XM_IMM(x, op, T_MAP5 | T_MUST_EVEX | T_EW0 | T_SAE_X | T_N2, 0x2E);
+}
 #ifdef XBYAK64
 void kmovq(const Opmask& k, const Reg64& r) { opVex(k, 0, r, T_L0 | T_0F | T_F2 | T_W1, 0x92); }
 void kmovq(const Reg64& r, const Opmask& k) { opVex(r, 0, k, T_L0 | T_0F | T_F2 | T_W1, 0x93); }
diff --git a/onnxruntime/core/mlas/lib/x86_64/jblas/jblas/xbyak/xbyak_util.h b/onnxruntime/core/mlas/lib/x86_64/jblas/jblas/xbyak/xbyak_util.h
index 2d75bd3266733..f9e43afc8371f 100644
--- a/onnxruntime/core/mlas/lib/x86_64/jblas/jblas/xbyak/xbyak_util.h
+++ b/onnxruntime/core/mlas/lib/x86_64/jblas/jblas/xbyak/xbyak_util.h
@@ -19,42 +19,42 @@
 #include <stdlib.h>
 #include <assert.h>
 #ifndef XBYAK_THROW
-	#define XBYAK_THROW(x) ;
-	#define XBYAK_THROW_RET(x, y) return y;
+#define XBYAK_THROW(x) ;
+#define XBYAK_THROW_RET(x, y) return y;
 #endif
 #ifndef XBYAK_CONSTEXPR
-#if ((__cplusplus >= 201402L) && !(!defined(__clang__) && defined(__GNUC__) && (__GNUC__ <= 5))) || (defined(_MSC_VER) && _MSC_VER >= 1910)
-	#define XBYAK_CONSTEXPR constexpr
+#if ((__cplusplus >= 201402L) && !(!defined(__clang__) && defined(__GNUC__) && (__GNUC__ <= 5))) || \
+    (defined(_MSC_VER) && _MSC_VER >= 1910)
+#define XBYAK_CONSTEXPR constexpr
 #else
-	#define XBYAK_CONSTEXPR
+#define XBYAK_CONSTEXPR
 #endif
 #endif
 #else
 #include <string.h>
 
 /**
-	utility class and functions for Xbyak
-	Xbyak::util::Clock ; rdtsc timer
-	Xbyak::util::Cpu ; detect CPU
+        utility class and functions for Xbyak
+        Xbyak::util::Clock ; rdtsc timer
+        Xbyak::util::Cpu ; detect CPU
 */
 #include "xbyak.h"
-#endif // XBYAK_ONLY_CLASS_CPU
+#endif  // XBYAK_ONLY_CLASS_CPU
 
 #if defined(__i386__) || defined(__x86_64__) || defined(_M_IX86) || defined(_M_X64)
-	#define XBYAK_INTEL_CPU_SPECIFIC
+#define XBYAK_INTEL_CPU_SPECIFIC
 #endif
 
 #ifdef XBYAK_INTEL_CPU_SPECIFIC
 #ifdef _WIN32
-	#if defined(_MSC_VER) && (_MSC_VER < 1400) && defined(XBYAK32)
-		static inline __declspec(naked) void __cpuid(int[4], int)
-		{
-			__asm {
+#if defined(_MSC_VER) && (_MSC_VER < 1400) && defined(XBYAK32)
+static inline __declspec(naked) void __cpuid(int[4], int) {
+  __asm {
 				push	ebx
 				push	esi
-				mov		eax, dword ptr [esp + 4 * 2 + 8] // eaxIn
+				mov		eax, dword ptr [esp + 4 * 2 + 8]  // eaxIn
 				cpuid
-				mov		esi, dword ptr [esp + 4 * 2 + 4] // data
+				mov		esi, dword ptr [esp + 4 * 2 + 4]  // data
 				mov		dword ptr [esi], eax
 				mov		dword ptr [esi + 4], ebx
 				mov		dword ptr [esi + 8], ecx
@@ -62,645 +62,645 @@
 				pop		esi
 				pop		ebx
 				ret
-			}
-		}
-	#else
-		#include <intrin.h> // for __cpuid
-	#endif
+  }
+}
 #else
-	#ifndef __GNUC_PREREQ
-    	#define __GNUC_PREREQ(major, minor) ((((__GNUC__) << 16) + (__GNUC_MINOR__)) >= (((major) << 16) + (minor)))
-	#endif
-	#if __GNUC_PREREQ(4, 3) && !defined(__APPLE__)
-		#if !defined(signature_VORTEX_ebx) && !defined(signature_NEXGEN_ebx) && \
-			!defined(signature_AMD_ebx)  // workaround for Bug 96238 - [i386] cpuid.h header needs include guards
-			#include <cpuid.h>
-		#endif
-	#else
-		#if defined(__APPLE__) && defined(XBYAK32) // avoid err : can't find a register in class `BREG' while reloading `asm'
-			#define __cpuid(eaxIn, a, b, c, d) __asm__ __volatile__("pushl %%ebx\ncpuid\nmovl %%ebp, %%esi\npopl %%ebx" : "=a"(a), "=S"(b), "=c"(c), "=d"(d) : "0"(eaxIn))
-			#define __cpuid_count(eaxIn, ecxIn, a, b, c, d) __asm__ __volatile__("pushl %%ebx\ncpuid\nmovl %%ebp, %%esi\npopl %%ebx" : "=a"(a), "=S"(b), "=c"(c), "=d"(d) : "0"(eaxIn), "2"(ecxIn))
-		#else
-			#define __cpuid(eaxIn, a, b, c, d) __asm__ __volatile__("cpuid\n" : "=a"(a), "=b"(b), "=c"(c), "=d"(d) : "0"(eaxIn))
-			#define __cpuid_count(eaxIn, ecxIn, a, b, c, d) __asm__ __volatile__("cpuid\n" : "=a"(a), "=b"(b), "=c"(c), "=d"(d) : "0"(eaxIn), "2"(ecxIn))
-		#endif
-	#endif
+#include <intrin.h>  // for __cpuid
+#endif
+#else
+#ifndef __GNUC_PREREQ
+#define __GNUC_PREREQ(major, minor) ((((__GNUC__) << 16) + (__GNUC_MINOR__)) >= (((major) << 16) + (minor)))
+#endif
+#if __GNUC_PREREQ(4, 3) && !defined(__APPLE__)
+#if !defined(signature_VORTEX_ebx) && !defined(signature_NEXGEN_ebx) && \
+    !defined(signature_AMD_ebx)  // workaround for Bug 96238 - [i386] cpuid.h header needs include guards
+#include <cpuid.h>
+#endif
+#else
+#if defined(__APPLE__) && defined(XBYAK32)  // avoid err : can't find a register in class `BREG' while reloading `asm'
+#define __cpuid(eaxIn, a, b, c, d)                                         \
+  __asm__ __volatile__("pushl %%ebx\ncpuid\nmovl %%ebp, %%esi\npopl %%ebx" \
+                       : "=a"(a), "=S"(b), "=c"(c), "=d"(d)                \
+                       : "0"(eaxIn))
+#define __cpuid_count(eaxIn, ecxIn, a, b, c, d)                            \
+  __asm__ __volatile__("pushl %%ebx\ncpuid\nmovl %%ebp, %%esi\npopl %%ebx" \
+                       : "=a"(a), "=S"(b), "=c"(c), "=d"(d)                \
+                       : "0"(eaxIn), "2"(ecxIn))
+#else
+#define __cpuid(eaxIn, a, b, c, d) __asm__ __volatile__("cpuid\n" : "=a"(a), "=b"(b), "=c"(c), "=d"(d) : "0"(eaxIn))
+#define __cpuid_count(eaxIn, ecxIn, a, b, c, d) \
+  __asm__ __volatile__("cpuid\n" : "=a"(a), "=b"(b), "=c"(c), "=d"(d) : "0"(eaxIn), "2"(ecxIn))
+#endif
+#endif
 #endif
 #endif
 
 #ifdef XBYAK_USE_VTUNE
-	// -I /opt/intel/vtune_amplifier/include/ -L /opt/intel/vtune_amplifier/lib64 -ljitprofiling -ldl
-	#include <jitprofiling.h>
-	#ifdef _MSC_VER
-		#pragma comment(lib, "libittnotify.lib")
-	#endif
-	#ifdef __linux__
-		#include <dlfcn.h>
-	#endif
+// -I /opt/intel/vtune_amplifier/include/ -L /opt/intel/vtune_amplifier/lib64 -ljitprofiling -ldl
+#include <jitprofiling.h>
+#ifdef _MSC_VER
+#pragma comment(lib, "libittnotify.lib")
+#endif
+#ifdef __linux__
+#include <dlfcn.h>
+#endif
 #endif
 #ifdef __linux__
-	#define XBYAK_USE_PERF
+#define XBYAK_USE_PERF
 #endif
 
-namespace Xbyak { namespace util {
+namespace Xbyak {
+namespace util {
 
-typedef enum {
-   SmtLevel = 1,
-   CoreLevel = 2
-} IntelCpuTopologyLevel;
+typedef enum { SmtLevel = 1, CoreLevel = 2 } IntelCpuTopologyLevel;
 
 namespace local {
 
-template<uint64_t L, uint64_t H = 0>
-struct TypeT {
-};
+template <uint64_t L, uint64_t H = 0>
+struct TypeT {};
 
-template<uint64_t L1, uint64_t H1, uint64_t L2, uint64_t H2>
-XBYAK_CONSTEXPR TypeT<L1 | L2, H1 | H2> operator|(TypeT<L1, H1>, TypeT<L2, H2>) { return TypeT<L1 | L2, H1 | H2>(); }
+template <uint64_t L1, uint64_t H1, uint64_t L2, uint64_t H2>
+XBYAK_CONSTEXPR TypeT<L1 | L2, H1 | H2> operator|(TypeT<L1, H1>, TypeT<L2, H2>) {
+  return TypeT<L1 | L2, H1 | H2>();
+}
 
-template<typename T>
-inline T max_(T x, T y) { return x >= y ? x : y; }
-template<typename T>
-inline T min_(T x, T y) { return x < y ? x : y; }
+template <typename T>
+inline T max_(T x, T y) {
+  return x >= y ? x : y;
+}
+template <typename T>
+inline T min_(T x, T y) {
+  return x < y ? x : y;
+}
 
-} // local
+}  // namespace local
 
 /**
-	CPU detection class
-	@note static inline const member is supported by c++17 or later, so use template hack
+        CPU detection class
+        @note static inline const member is supported by c++17 or later, so use template hack
 */
 class Cpu {
-public:
-	class Type {
-		uint64_t L;
-		uint64_t H;
-	public:
-		Type(uint64_t L = 0, uint64_t H = 0) : L(L), H(H) { }
-		template<uint64_t L_, uint64_t H_>
-		Type(local::TypeT<L_, H_>) : L(L_), H(H_) {}
-		Type& operator&=(const Type& rhs) { L &= rhs.L; H &= rhs.H; return *this; }
-		Type& operator|=(const Type& rhs) { L |= rhs.L; H |= rhs.H; return *this; }
-		Type operator&(const Type& rhs) const { Type t = *this; t &= rhs; return t; }
-		Type operator|(const Type& rhs) const { Type t = *this; t |= rhs; return t; }
-		bool operator==(const Type& rhs) const { return H == rhs.H && L == rhs.L; }
-		bool operator!=(const Type& rhs) const { return !operator==(rhs); }
-		// without explicit because backward compatilibity
-		operator bool() const { return (H | L) != 0; }
-		uint64_t getL() const { return L; }
-		uint64_t getH() const { return H; }
-	};
-private:
-	Type type_;
-	//system topology
-	bool x2APIC_supported_;
-	static const size_t maxTopologyLevels = 2;
-	uint32_t numCores_[maxTopologyLevels];
+ public:
+  class Type {
+    uint64_t L;
+    uint64_t H;
+
+   public:
+    Type(uint64_t L = 0, uint64_t H = 0) : L(L), H(H) {}
+    template <uint64_t L_, uint64_t H_>
+    Type(local::TypeT<L_, H_>) : L(L_), H(H_) {}
+    Type& operator&=(const Type& rhs) {
+      L &= rhs.L;
+      H &= rhs.H;
+      return *this;
+    }
+    Type& operator|=(const Type& rhs) {
+      L |= rhs.L;
+      H |= rhs.H;
+      return *this;
+    }
+    Type operator&(const Type& rhs) const {
+      Type t = *this;
+      t &= rhs;
+      return t;
+    }
+    Type operator|(const Type& rhs) const {
+      Type t = *this;
+      t |= rhs;
+      return t;
+    }
+    bool operator==(const Type& rhs) const { return H == rhs.H && L == rhs.L; }
+    bool operator!=(const Type& rhs) const { return !operator==(rhs); }
+    // without explicit because backward compatilibity
+    operator bool() const { return (H | L) != 0; }
+    uint64_t getL() const { return L; }
+    uint64_t getH() const { return H; }
+  };
 
-	static const uint32_t maxNumberCacheLevels = 10;
-	uint32_t dataCacheSize_[maxNumberCacheLevels];
-	uint32_t coresSharignDataCache_[maxNumberCacheLevels];
-	uint32_t dataCacheLevels_;
+ private:
+  Type type_;
+  // system topology
+  bool x2APIC_supported_;
+  static const size_t maxTopologyLevels = 2;
+  uint32_t numCores_[maxTopologyLevels];
 
-	uint32_t get32bitAsBE(const char *x) const
-	{
-		return x[0] | (x[1] << 8) | (x[2] << 16) | (x[3] << 24);
-	}
-	uint32_t mask(int n) const
-	{
-		return (1U << n) - 1;
-	}
-	void setFamily()
-	{
-		uint32_t data[4] = {};
-		getCpuid(1, data);
-		stepping = data[0] & mask(4);
-		model = (data[0] >> 4) & mask(4);
-		family = (data[0] >> 8) & mask(4);
-		// type = (data[0] >> 12) & mask(2);
-		extModel = (data[0] >> 16) & mask(4);
-		extFamily = (data[0] >> 20) & mask(8);
-		if (family == 0x0f) {
-			displayFamily = family + extFamily;
-		} else {
-			displayFamily = family;
-		}
-		if (family == 6 || family == 0x0f) {
-			displayModel = (extModel << 4) + model;
-		} else {
-			displayModel = model;
-		}
-	}
-	uint32_t extractBit(uint32_t val, uint32_t base, uint32_t end)
-	{
-		return (val >> base) & ((1u << (end - base)) - 1);
-	}
-	void setNumCores()
-	{
-		if (!has(tINTEL) && !has(tAMD)) return;
+  static const uint32_t maxNumberCacheLevels = 10;
+  uint32_t dataCacheSize_[maxNumberCacheLevels];
+  uint32_t coresSharignDataCache_[maxNumberCacheLevels];
+  uint32_t dataCacheLevels_;
 
-		uint32_t data[4] = {};
-		getCpuidEx(0x0, 0, data);
-		if (data[0] >= 0xB) {
-			 /*
-				if leaf 11 exists(x2APIC is supported),
-				we use it to get the number of smt cores and cores on socket
+  uint32_t get32bitAsBE(const char* x) const { return x[0] | (x[1] << 8) | (x[2] << 16) | (x[3] << 24); }
+  uint32_t mask(int n) const { return (1U << n) - 1; }
+  void setFamily() {
+    uint32_t data[4] = {};
+    getCpuid(1, data);
+    stepping = data[0] & mask(4);
+    model = (data[0] >> 4) & mask(4);
+    family = (data[0] >> 8) & mask(4);
+    // type = (data[0] >> 12) & mask(2);
+    extModel = (data[0] >> 16) & mask(4);
+    extFamily = (data[0] >> 20) & mask(8);
+    if (family == 0x0f) {
+      displayFamily = family + extFamily;
+    } else {
+      displayFamily = family;
+    }
+    if (family == 6 || family == 0x0f) {
+      displayModel = (extModel << 4) + model;
+    } else {
+      displayModel = model;
+    }
+  }
+  uint32_t extractBit(uint32_t val, uint32_t base, uint32_t end) { return (val >> base) & ((1u << (end - base)) - 1); }
+  void setNumCores() {
+    if (!has(tINTEL) && !has(tAMD)) return;
 
-				leaf 0xB can be zeroed-out by a hypervisor
-			*/
-			x2APIC_supported_ = true;
-			for (uint32_t i = 0; i < maxTopologyLevels; i++) {
-				getCpuidEx(0xB, i, data);
-				IntelCpuTopologyLevel level = (IntelCpuTopologyLevel)extractBit(data[2], 8, 15);
-				if (level == SmtLevel || level == CoreLevel) {
-					numCores_[level - 1] = extractBit(data[1], 0, 15);
-				}
-			}
-			/*
-				Fallback values in case a hypervisor has 0xB leaf zeroed-out.
-			*/
-			numCores_[SmtLevel - 1] = local::max_(1u, numCores_[SmtLevel - 1]);
-			numCores_[CoreLevel - 1] = local::max_(numCores_[SmtLevel - 1], numCores_[CoreLevel - 1]);
-		} else {
-			/*
-				Failed to deremine num of cores without x2APIC support.
-				TODO: USE initial APIC ID to determine ncores.
-			*/
-			numCores_[SmtLevel - 1] = 0;
-			numCores_[CoreLevel - 1] = 0;
-		}
+    uint32_t data[4] = {};
+    getCpuidEx(0x0, 0, data);
+    if (data[0] >= 0xB) {
+      /*
+             if leaf 11 exists(x2APIC is supported),
+             we use it to get the number of smt cores and cores on socket
 
-	}
-	void setCacheHierarchy()
-	{
-		if (!has(tINTEL) && !has(tAMD)) return;
+             leaf 0xB can be zeroed-out by a hypervisor
+     */
+      x2APIC_supported_ = true;
+      for (uint32_t i = 0; i < maxTopologyLevels; i++) {
+        getCpuidEx(0xB, i, data);
+        IntelCpuTopologyLevel level = (IntelCpuTopologyLevel)extractBit(data[2], 8, 15);
+        if (level == SmtLevel || level == CoreLevel) {
+          numCores_[level - 1] = extractBit(data[1], 0, 15);
+        }
+      }
+      /*
+              Fallback values in case a hypervisor has 0xB leaf zeroed-out.
+      */
+      numCores_[SmtLevel - 1] = local::max_(1u, numCores_[SmtLevel - 1]);
+      numCores_[CoreLevel - 1] = local::max_(numCores_[SmtLevel - 1], numCores_[CoreLevel - 1]);
+    } else {
+      /*
+              Failed to deremine num of cores without x2APIC support.
+              TODO: USE initial APIC ID to determine ncores.
+      */
+      numCores_[SmtLevel - 1] = 0;
+      numCores_[CoreLevel - 1] = 0;
+    }
+  }
+  void setCacheHierarchy() {
+    if (!has(tINTEL) && !has(tAMD)) return;
 
-		// https://github.com/amd/ZenDNN/blob/a08bf9a9efc160a69147cdecfb61cc85cc0d4928/src/cpu/x64/xbyak/xbyak_util.h#L236-L288
-		if (has(tAMD)) {
-			// There are 3 Data Cache Levels (L1, L2, L3)
-			dataCacheLevels_ = 3;
-			const uint32_t leaf = 0x8000001D; // for modern AMD CPus
-			// Sub leaf value ranges from 0 to 3
-			// Sub leaf value 0 refers to L1 Data Cache
-			// Sub leaf value 1 refers to L1 Instruction Cache
-			// Sub leaf value 2 refers to L2 Cache
-			// Sub leaf value 3 refers to L3 Cache
-			// For legacy AMD CPU, use leaf 0x80000005 for L1 cache
-			// and 0x80000006 for L2 and L3 cache
-			int cache_index = 0;
-			for (uint32_t sub_leaf = 0; sub_leaf <= dataCacheLevels_; sub_leaf++) {
-				// Skip sub_leaf = 1 as it refers to
-				// L1 Instruction Cache (not required)
-				if (sub_leaf == 1) {
-					continue;
-				}
-				uint32_t data[4] = {};
-				getCpuidEx(leaf, sub_leaf, data);
-				// Cache Size = Line Size * Partitions * Associativity * Cache Sets
-				dataCacheSize_[cache_index] =
-					(extractBit(data[1], 22, 31) + 1) // Associativity-1
-					* (extractBit(data[1], 12, 21) + 1) // Partitions-1
-					* (extractBit(data[1], 0, 11) + 1) // Line Size
-					* (data[2] + 1);
-				// Calculate the number of cores sharing the current data cache
-				int smt_width = numCores_[0];
-				int logical_cores = numCores_[1];
-				int actual_logical_cores = extractBit(data[0], 14, 25) /* # of cores * # of threads */ + 1;
-				if (logical_cores != 0) {
-					actual_logical_cores = local::min_(actual_logical_cores, logical_cores);
-				}
-				coresSharignDataCache_[cache_index] = local::max_(actual_logical_cores / smt_width, 1);
-				++cache_index;
-			}
-			return;
-		}
-		// intel
-		const uint32_t NO_CACHE = 0;
-		const uint32_t DATA_CACHE = 1;
-//		const uint32_t INSTRUCTION_CACHE = 2;
-		const uint32_t UNIFIED_CACHE = 3;
-		uint32_t smt_width = 0;
-		uint32_t logical_cores = 0;
-		uint32_t data[4] = {};
+    // https://github.com/amd/ZenDNN/blob/a08bf9a9efc160a69147cdecfb61cc85cc0d4928/src/cpu/x64/xbyak/xbyak_util.h#L236-L288
+    if (has(tAMD)) {
+      // There are 3 Data Cache Levels (L1, L2, L3)
+      dataCacheLevels_ = 3;
+      const uint32_t leaf = 0x8000001D;  // for modern AMD CPus
+      // Sub leaf value ranges from 0 to 3
+      // Sub leaf value 0 refers to L1 Data Cache
+      // Sub leaf value 1 refers to L1 Instruction Cache
+      // Sub leaf value 2 refers to L2 Cache
+      // Sub leaf value 3 refers to L3 Cache
+      // For legacy AMD CPU, use leaf 0x80000005 for L1 cache
+      // and 0x80000006 for L2 and L3 cache
+      int cache_index = 0;
+      for (uint32_t sub_leaf = 0; sub_leaf <= dataCacheLevels_; sub_leaf++) {
+        // Skip sub_leaf = 1 as it refers to
+        // L1 Instruction Cache (not required)
+        if (sub_leaf == 1) {
+          continue;
+        }
+        uint32_t data[4] = {};
+        getCpuidEx(leaf, sub_leaf, data);
+        // Cache Size = Line Size * Partitions * Associativity * Cache Sets
+        dataCacheSize_[cache_index] = (extractBit(data[1], 22, 31) + 1)    // Associativity-1
+                                      * (extractBit(data[1], 12, 21) + 1)  // Partitions-1
+                                      * (extractBit(data[1], 0, 11) + 1)   // Line Size
+                                      * (data[2] + 1);
+        // Calculate the number of cores sharing the current data cache
+        int smt_width = numCores_[0];
+        int logical_cores = numCores_[1];
+        int actual_logical_cores = extractBit(data[0], 14, 25) /* # of cores * # of threads */ + 1;
+        if (logical_cores != 0) {
+          actual_logical_cores = local::min_(actual_logical_cores, logical_cores);
+        }
+        coresSharignDataCache_[cache_index] = local::max_(actual_logical_cores / smt_width, 1);
+        ++cache_index;
+      }
+      return;
+    }
+    // intel
+    const uint32_t NO_CACHE = 0;
+    const uint32_t DATA_CACHE = 1;
+    //		const uint32_t INSTRUCTION_CACHE = 2;
+    const uint32_t UNIFIED_CACHE = 3;
+    uint32_t smt_width = 0;
+    uint32_t logical_cores = 0;
+    uint32_t data[4] = {};
 
-		if (x2APIC_supported_) {
-			smt_width = numCores_[0];
-			logical_cores = numCores_[1];
-		}
+    if (x2APIC_supported_) {
+      smt_width = numCores_[0];
+      logical_cores = numCores_[1];
+    }
 
-		/*
-			Assumptions:
-			the first level of data cache is not shared (which is the
-			case for every existing architecture) and use this to
-			determine the SMT width for arch not supporting leaf 11.
-			when leaf 4 reports a number of core less than numCores_
-			on socket reported by leaf 11, then it is a correct number
-			of cores not an upperbound.
-		*/
-		for (int i = 0; dataCacheLevels_ < maxNumberCacheLevels; i++) {
-			getCpuidEx(0x4, i, data);
-			uint32_t cacheType = extractBit(data[0], 0, 4);
-			if (cacheType == NO_CACHE) break;
-			if (cacheType == DATA_CACHE || cacheType == UNIFIED_CACHE) {
-				uint32_t actual_logical_cores = extractBit(data[0], 14, 25) + 1;
-				if (logical_cores != 0) { // true only if leaf 0xB is supported and valid
-					actual_logical_cores = local::min_(actual_logical_cores, logical_cores);
-				}
-				assert(actual_logical_cores != 0);
-				dataCacheSize_[dataCacheLevels_] =
-					(extractBit(data[1], 22, 31) + 1)
-					* (extractBit(data[1], 12, 21) + 1)
-					* (extractBit(data[1], 0, 11) + 1)
-					* (data[2] + 1);
-				if (cacheType == DATA_CACHE && smt_width == 0) smt_width = actual_logical_cores;
-				assert(smt_width != 0);
-				coresSharignDataCache_[dataCacheLevels_] = local::max_(actual_logical_cores / smt_width, 1u);
-				dataCacheLevels_++;
-			}
-		}
-	}
+    /*
+            Assumptions:
+            the first level of data cache is not shared (which is the
+            case for every existing architecture) and use this to
+            determine the SMT width for arch not supporting leaf 11.
+            when leaf 4 reports a number of core less than numCores_
+            on socket reported by leaf 11, then it is a correct number
+            of cores not an upperbound.
+    */
+    for (int i = 0; dataCacheLevels_ < maxNumberCacheLevels; i++) {
+      getCpuidEx(0x4, i, data);
+      uint32_t cacheType = extractBit(data[0], 0, 4);
+      if (cacheType == NO_CACHE) break;
+      if (cacheType == DATA_CACHE || cacheType == UNIFIED_CACHE) {
+        uint32_t actual_logical_cores = extractBit(data[0], 14, 25) + 1;
+        if (logical_cores != 0) {  // true only if leaf 0xB is supported and valid
+          actual_logical_cores = local::min_(actual_logical_cores, logical_cores);
+        }
+        assert(actual_logical_cores != 0);
+        dataCacheSize_[dataCacheLevels_] = (extractBit(data[1], 22, 31) + 1) * (extractBit(data[1], 12, 21) + 1) *
+                                           (extractBit(data[1], 0, 11) + 1) * (data[2] + 1);
+        if (cacheType == DATA_CACHE && smt_width == 0) smt_width = actual_logical_cores;
+        assert(smt_width != 0);
+        coresSharignDataCache_[dataCacheLevels_] = local::max_(actual_logical_cores / smt_width, 1u);
+        dataCacheLevels_++;
+      }
+    }
+  }
 
-public:
-	int model;
-	int family;
-	int stepping;
-	int extModel;
-	int extFamily;
-	int displayFamily; // family + extFamily
-	int displayModel; // model + extModel
+ public:
+  int model;
+  int family;
+  int stepping;
+  int extModel;
+  int extFamily;
+  int displayFamily;  // family + extFamily
+  int displayModel;   // model + extModel
 
-	uint32_t getNumCores(IntelCpuTopologyLevel level) const {
-		if (!x2APIC_supported_) XBYAK_THROW_RET(ERR_X2APIC_IS_NOT_SUPPORTED, 0)
-		switch (level) {
-		case SmtLevel: return numCores_[level - 1];
-		case CoreLevel: return numCores_[level - 1] / numCores_[SmtLevel - 1];
-		default: XBYAK_THROW_RET(ERR_X2APIC_IS_NOT_SUPPORTED, 0)
-		}
-	}
+  uint32_t getNumCores(IntelCpuTopologyLevel level) const {
+    if (!x2APIC_supported_) XBYAK_THROW_RET(ERR_X2APIC_IS_NOT_SUPPORTED, 0)
+    switch (level) {
+      case SmtLevel:
+        return numCores_[level - 1];
+      case CoreLevel:
+        return numCores_[level - 1] / numCores_[SmtLevel - 1];
+      default:
+        XBYAK_THROW_RET(ERR_X2APIC_IS_NOT_SUPPORTED, 0)
+    }
+  }
 
-	uint32_t getDataCacheLevels() const { return dataCacheLevels_; }
-	uint32_t getCoresSharingDataCache(uint32_t i) const
-	{
-		if (i >= dataCacheLevels_) XBYAK_THROW_RET(ERR_BAD_PARAMETER, 0)
-		return coresSharignDataCache_[i];
-	}
-	uint32_t getDataCacheSize(uint32_t i) const
-	{
-		if (i >= dataCacheLevels_) XBYAK_THROW_RET(ERR_BAD_PARAMETER, 0)
-		return dataCacheSize_[i];
-	}
+  uint32_t getDataCacheLevels() const { return dataCacheLevels_; }
+  uint32_t getCoresSharingDataCache(uint32_t i) const {
+    if (i >= dataCacheLevels_) XBYAK_THROW_RET(ERR_BAD_PARAMETER, 0)
+    return coresSharignDataCache_[i];
+  }
+  uint32_t getDataCacheSize(uint32_t i) const {
+    if (i >= dataCacheLevels_) XBYAK_THROW_RET(ERR_BAD_PARAMETER, 0)
+    return dataCacheSize_[i];
+  }
 
-	/*
-		data[] = { eax, ebx, ecx, edx }
-	*/
-	static inline void getCpuid(uint32_t eaxIn, uint32_t data[4])
-	{
+  /*
+          data[] = { eax, ebx, ecx, edx }
+  */
+  static inline void getCpuid(uint32_t eaxIn, uint32_t data[4]) {
 #ifdef XBYAK_INTEL_CPU_SPECIFIC
-	#ifdef _WIN32
-		__cpuid(reinterpret_cast<int*>(data), eaxIn);
-	#else
-		__cpuid(eaxIn, data[0], data[1], data[2], data[3]);
-	#endif
+#ifdef _WIN32
+    __cpuid(reinterpret_cast<int*>(data), eaxIn);
 #else
-		(void)eaxIn;
-		(void)data;
+    __cpuid(eaxIn, data[0], data[1], data[2], data[3]);
 #endif
-	}
-	static inline void getCpuidEx(uint32_t eaxIn, uint32_t ecxIn, uint32_t data[4])
-	{
+#else
+    (void)eaxIn;
+    (void)data;
+#endif
+  }
+  static inline void getCpuidEx(uint32_t eaxIn, uint32_t ecxIn, uint32_t data[4]) {
 #ifdef XBYAK_INTEL_CPU_SPECIFIC
-	#ifdef _WIN32
-		__cpuidex(reinterpret_cast<int*>(data), eaxIn, ecxIn);
-	#else
-		__cpuid_count(eaxIn, ecxIn, data[0], data[1], data[2], data[3]);
-	#endif
+#ifdef _WIN32
+    __cpuidex(reinterpret_cast<int*>(data), eaxIn, ecxIn);
 #else
-		(void)eaxIn;
-		(void)ecxIn;
-		(void)data;
+    __cpuid_count(eaxIn, ecxIn, data[0], data[1], data[2], data[3]);
 #endif
-	}
-	static inline uint64_t getXfeature()
-	{
+#else
+    (void)eaxIn;
+    (void)ecxIn;
+    (void)data;
+#endif
+  }
+  static inline uint64_t getXfeature() {
 #ifdef XBYAK_INTEL_CPU_SPECIFIC
-	#ifdef _MSC_VER
-		return _xgetbv(0);
-	#else
-		uint32_t eax, edx;
-		// xgetvb is not support on gcc 4.2
-//		__asm__ volatile("xgetbv" : "=a"(eax), "=d"(edx) : "c"(0));
-		__asm__ volatile(".byte 0x0f, 0x01, 0xd0" : "=a"(eax), "=d"(edx) : "c"(0));
-		return ((uint64_t)edx << 32) | eax;
-	#endif
+#ifdef _MSC_VER
+    return _xgetbv(0);
+#else
+    uint32_t eax, edx;
+    // xgetvb is not support on gcc 4.2
+    //		__asm__ volatile("xgetbv" : "=a"(eax), "=d"(edx) : "c"(0));
+    __asm__ volatile(".byte 0x0f, 0x01, 0xd0" : "=a"(eax), "=d"(edx) : "c"(0));
+    return ((uint64_t)edx << 32) | eax;
+#endif
 #else
-		return 0;
+    return 0;
 #endif
-	}
+  }
 
 #define XBYAK_SPLIT_ID(id) ((0 <= id && id < 64) ? (1ull << (id % 64)) : 0), (id >= 64 ? (1ull << (id % 64)) : 0)
 #if (__cplusplus >= 201103) || (defined(_MSC_VER) && (_MSC_VER >= 1700)) /* VS2012 */
-	#define XBYAK_DEFINE_TYPE(id, NAME) static const constexpr local::TypeT<XBYAK_SPLIT_ID(id)> NAME{}
+#define XBYAK_DEFINE_TYPE(id, NAME) \
+  static const constexpr local::TypeT<XBYAK_SPLIT_ID(id)> NAME {}
 #else
-	#define XBYAK_DEFINE_TYPE(id, NAME) static const local::TypeT<XBYAK_SPLIT_ID(id)> NAME
+#define XBYAK_DEFINE_TYPE(id, NAME) static const local::TypeT<XBYAK_SPLIT_ID(id)> NAME
 #endif
-	XBYAK_DEFINE_TYPE(0, tMMX);
-	XBYAK_DEFINE_TYPE(1, tMMX2);
-	XBYAK_DEFINE_TYPE(2, tCMOV);
-	XBYAK_DEFINE_TYPE(3, tSSE);
-	XBYAK_DEFINE_TYPE(4, tSSE2);
-	XBYAK_DEFINE_TYPE(5, tSSE3);
-	XBYAK_DEFINE_TYPE(6, tSSSE3);
-	XBYAK_DEFINE_TYPE(7, tSSE41);
-	XBYAK_DEFINE_TYPE(8, tSSE42);
-	XBYAK_DEFINE_TYPE(9, tPOPCNT);
-	XBYAK_DEFINE_TYPE(10, tAESNI);
-	XBYAK_DEFINE_TYPE(11, tAVX512_FP16);
-	XBYAK_DEFINE_TYPE(12, tOSXSAVE);
-	XBYAK_DEFINE_TYPE(13, tPCLMULQDQ);
-	XBYAK_DEFINE_TYPE(14, tAVX);
-	XBYAK_DEFINE_TYPE(15, tFMA);
-	XBYAK_DEFINE_TYPE(16, t3DN);
-	XBYAK_DEFINE_TYPE(17, tE3DN);
-	XBYAK_DEFINE_TYPE(18, tWAITPKG);
-	XBYAK_DEFINE_TYPE(19, tRDTSCP);
-	XBYAK_DEFINE_TYPE(20, tAVX2);
-	XBYAK_DEFINE_TYPE(21, tBMI1); // andn, bextr, blsi, blsmsk, blsr, tzcnt
-	XBYAK_DEFINE_TYPE(22, tBMI2); // bzhi, mulx, pdep, pext, rorx, sarx, shlx, shrx
-	XBYAK_DEFINE_TYPE(23, tLZCNT);
-	XBYAK_DEFINE_TYPE(24, tINTEL);
-	XBYAK_DEFINE_TYPE(25, tAMD);
-	XBYAK_DEFINE_TYPE(26, tENHANCED_REP); // enhanced rep movsb/stosb
-	XBYAK_DEFINE_TYPE(27, tRDRAND);
-	XBYAK_DEFINE_TYPE(28, tADX); // adcx, adox
-	XBYAK_DEFINE_TYPE(29, tRDSEED); // rdseed
-	XBYAK_DEFINE_TYPE(30, tSMAP); // stac
-	XBYAK_DEFINE_TYPE(31, tHLE); // xacquire, xrelease, xtest
-	XBYAK_DEFINE_TYPE(32, tRTM); // xbegin, xend, xabort
-	XBYAK_DEFINE_TYPE(33, tF16C); // vcvtph2ps, vcvtps2ph
-	XBYAK_DEFINE_TYPE(34, tMOVBE); // mobve
-	XBYAK_DEFINE_TYPE(35, tAVX512F);
-	XBYAK_DEFINE_TYPE(36, tAVX512DQ);
-	XBYAK_DEFINE_TYPE(37, tAVX512_IFMA);
-	XBYAK_DEFINE_TYPE(37, tAVX512IFMA);// = tAVX512_IFMA;
-	XBYAK_DEFINE_TYPE(38, tAVX512PF);
-	XBYAK_DEFINE_TYPE(39, tAVX512ER);
-	XBYAK_DEFINE_TYPE(40, tAVX512CD);
-	XBYAK_DEFINE_TYPE(41, tAVX512BW);
-	XBYAK_DEFINE_TYPE(42, tAVX512VL);
-	XBYAK_DEFINE_TYPE(43, tAVX512_VBMI);
-	XBYAK_DEFINE_TYPE(43, tAVX512VBMI); // = tAVX512_VBMI; // changed by Intel's manual
-	XBYAK_DEFINE_TYPE(44, tAVX512_4VNNIW);
-	XBYAK_DEFINE_TYPE(45, tAVX512_4FMAPS);
-	XBYAK_DEFINE_TYPE(46, tPREFETCHWT1);
-	XBYAK_DEFINE_TYPE(47, tPREFETCHW);
-	XBYAK_DEFINE_TYPE(48, tSHA);
-	XBYAK_DEFINE_TYPE(49, tMPX);
-	XBYAK_DEFINE_TYPE(50, tAVX512_VBMI2);
-	XBYAK_DEFINE_TYPE(51, tGFNI);
-	XBYAK_DEFINE_TYPE(52, tVAES);
-	XBYAK_DEFINE_TYPE(53, tVPCLMULQDQ);
-	XBYAK_DEFINE_TYPE(54, tAVX512_VNNI);
-	XBYAK_DEFINE_TYPE(55, tAVX512_BITALG);
-	XBYAK_DEFINE_TYPE(56, tAVX512_VPOPCNTDQ);
-	XBYAK_DEFINE_TYPE(57, tAVX512_BF16);
-	XBYAK_DEFINE_TYPE(58, tAVX512_VP2INTERSECT);
-	XBYAK_DEFINE_TYPE(59, tAMX_TILE);
-	XBYAK_DEFINE_TYPE(60, tAMX_INT8);
-	XBYAK_DEFINE_TYPE(61, tAMX_BF16);
-	XBYAK_DEFINE_TYPE(62, tAVX_VNNI);
-	XBYAK_DEFINE_TYPE(63, tCLFLUSHOPT);
-	XBYAK_DEFINE_TYPE(64, tCLDEMOTE);
-	XBYAK_DEFINE_TYPE(65, tMOVDIRI);
-	XBYAK_DEFINE_TYPE(66, tMOVDIR64B);
-	XBYAK_DEFINE_TYPE(67, tCLZERO); // AMD Zen
-	XBYAK_DEFINE_TYPE(68, tAMX_FP16);
-	XBYAK_DEFINE_TYPE(69, tAVX_VNNI_INT8);
-	XBYAK_DEFINE_TYPE(70, tAVX_NE_CONVERT);
-	XBYAK_DEFINE_TYPE(71, tAVX_IFMA);
-	XBYAK_DEFINE_TYPE(72, tRAO_INT);
-	XBYAK_DEFINE_TYPE(73, tCMPCCXADD);
-	XBYAK_DEFINE_TYPE(74, tPREFETCHITI);
-	XBYAK_DEFINE_TYPE(75, tSERIALIZE);
-	XBYAK_DEFINE_TYPE(76, tUINTR);
-	XBYAK_DEFINE_TYPE(77, tXSAVE);
-	XBYAK_DEFINE_TYPE(78, tSHA512);
-	XBYAK_DEFINE_TYPE(79, tSM3);
-	XBYAK_DEFINE_TYPE(80, tSM4);
-	XBYAK_DEFINE_TYPE(81, tAVX_VNNI_INT16);
+  XBYAK_DEFINE_TYPE(0, tMMX);
+  XBYAK_DEFINE_TYPE(1, tMMX2);
+  XBYAK_DEFINE_TYPE(2, tCMOV);
+  XBYAK_DEFINE_TYPE(3, tSSE);
+  XBYAK_DEFINE_TYPE(4, tSSE2);
+  XBYAK_DEFINE_TYPE(5, tSSE3);
+  XBYAK_DEFINE_TYPE(6, tSSSE3);
+  XBYAK_DEFINE_TYPE(7, tSSE41);
+  XBYAK_DEFINE_TYPE(8, tSSE42);
+  XBYAK_DEFINE_TYPE(9, tPOPCNT);
+  XBYAK_DEFINE_TYPE(10, tAESNI);
+  XBYAK_DEFINE_TYPE(11, tAVX512_FP16);
+  XBYAK_DEFINE_TYPE(12, tOSXSAVE);
+  XBYAK_DEFINE_TYPE(13, tPCLMULQDQ);
+  XBYAK_DEFINE_TYPE(14, tAVX);
+  XBYAK_DEFINE_TYPE(15, tFMA);
+  XBYAK_DEFINE_TYPE(16, t3DN);
+  XBYAK_DEFINE_TYPE(17, tE3DN);
+  XBYAK_DEFINE_TYPE(18, tWAITPKG);
+  XBYAK_DEFINE_TYPE(19, tRDTSCP);
+  XBYAK_DEFINE_TYPE(20, tAVX2);
+  XBYAK_DEFINE_TYPE(21, tBMI1);  // andn, bextr, blsi, blsmsk, blsr, tzcnt
+  XBYAK_DEFINE_TYPE(22, tBMI2);  // bzhi, mulx, pdep, pext, rorx, sarx, shlx, shrx
+  XBYAK_DEFINE_TYPE(23, tLZCNT);
+  XBYAK_DEFINE_TYPE(24, tINTEL);
+  XBYAK_DEFINE_TYPE(25, tAMD);
+  XBYAK_DEFINE_TYPE(26, tENHANCED_REP);  // enhanced rep movsb/stosb
+  XBYAK_DEFINE_TYPE(27, tRDRAND);
+  XBYAK_DEFINE_TYPE(28, tADX);     // adcx, adox
+  XBYAK_DEFINE_TYPE(29, tRDSEED);  // rdseed
+  XBYAK_DEFINE_TYPE(30, tSMAP);    // stac
+  XBYAK_DEFINE_TYPE(31, tHLE);     // xacquire, xrelease, xtest
+  XBYAK_DEFINE_TYPE(32, tRTM);     // xbegin, xend, xabort
+  XBYAK_DEFINE_TYPE(33, tF16C);    // vcvtph2ps, vcvtps2ph
+  XBYAK_DEFINE_TYPE(34, tMOVBE);   // mobve
+  XBYAK_DEFINE_TYPE(35, tAVX512F);
+  XBYAK_DEFINE_TYPE(36, tAVX512DQ);
+  XBYAK_DEFINE_TYPE(37, tAVX512_IFMA);
+  XBYAK_DEFINE_TYPE(37, tAVX512IFMA);  // = tAVX512_IFMA;
+  XBYAK_DEFINE_TYPE(38, tAVX512PF);
+  XBYAK_DEFINE_TYPE(39, tAVX512ER);
+  XBYAK_DEFINE_TYPE(40, tAVX512CD);
+  XBYAK_DEFINE_TYPE(41, tAVX512BW);
+  XBYAK_DEFINE_TYPE(42, tAVX512VL);
+  XBYAK_DEFINE_TYPE(43, tAVX512_VBMI);
+  XBYAK_DEFINE_TYPE(43, tAVX512VBMI);  // = tAVX512_VBMI; // changed by Intel's manual
+  XBYAK_DEFINE_TYPE(44, tAVX512_4VNNIW);
+  XBYAK_DEFINE_TYPE(45, tAVX512_4FMAPS);
+  XBYAK_DEFINE_TYPE(46, tPREFETCHWT1);
+  XBYAK_DEFINE_TYPE(47, tPREFETCHW);
+  XBYAK_DEFINE_TYPE(48, tSHA);
+  XBYAK_DEFINE_TYPE(49, tMPX);
+  XBYAK_DEFINE_TYPE(50, tAVX512_VBMI2);
+  XBYAK_DEFINE_TYPE(51, tGFNI);
+  XBYAK_DEFINE_TYPE(52, tVAES);
+  XBYAK_DEFINE_TYPE(53, tVPCLMULQDQ);
+  XBYAK_DEFINE_TYPE(54, tAVX512_VNNI);
+  XBYAK_DEFINE_TYPE(55, tAVX512_BITALG);
+  XBYAK_DEFINE_TYPE(56, tAVX512_VPOPCNTDQ);
+  XBYAK_DEFINE_TYPE(57, tAVX512_BF16);
+  XBYAK_DEFINE_TYPE(58, tAVX512_VP2INTERSECT);
+  XBYAK_DEFINE_TYPE(59, tAMX_TILE);
+  XBYAK_DEFINE_TYPE(60, tAMX_INT8);
+  XBYAK_DEFINE_TYPE(61, tAMX_BF16);
+  XBYAK_DEFINE_TYPE(62, tAVX_VNNI);
+  XBYAK_DEFINE_TYPE(63, tCLFLUSHOPT);
+  XBYAK_DEFINE_TYPE(64, tCLDEMOTE);
+  XBYAK_DEFINE_TYPE(65, tMOVDIRI);
+  XBYAK_DEFINE_TYPE(66, tMOVDIR64B);
+  XBYAK_DEFINE_TYPE(67, tCLZERO);  // AMD Zen
+  XBYAK_DEFINE_TYPE(68, tAMX_FP16);
+  XBYAK_DEFINE_TYPE(69, tAVX_VNNI_INT8);
+  XBYAK_DEFINE_TYPE(70, tAVX_NE_CONVERT);
+  XBYAK_DEFINE_TYPE(71, tAVX_IFMA);
+  XBYAK_DEFINE_TYPE(72, tRAO_INT);
+  XBYAK_DEFINE_TYPE(73, tCMPCCXADD);
+  XBYAK_DEFINE_TYPE(74, tPREFETCHITI);
+  XBYAK_DEFINE_TYPE(75, tSERIALIZE);
+  XBYAK_DEFINE_TYPE(76, tUINTR);
+  XBYAK_DEFINE_TYPE(77, tXSAVE);
+  XBYAK_DEFINE_TYPE(78, tSHA512);
+  XBYAK_DEFINE_TYPE(79, tSM3);
+  XBYAK_DEFINE_TYPE(80, tSM4);
+  XBYAK_DEFINE_TYPE(81, tAVX_VNNI_INT16);
 
 #undef XBYAK_SPLIT_ID
 #undef XBYAK_DEFINE_TYPE
 
-	Cpu()
-		: type_()
-		, x2APIC_supported_(false)
-		, numCores_()
-		, dataCacheSize_()
-		, coresSharignDataCache_()
-		, dataCacheLevels_(0)
-	{
-		uint32_t data[4] = {};
-		const uint32_t& EAX = data[0];
-		const uint32_t& EBX = data[1];
-		const uint32_t& ECX = data[2];
-		const uint32_t& EDX = data[3];
-		getCpuid(0, data);
-		const uint32_t maxNum = EAX;
-		static const char intel[] = "ntel";
-		static const char amd[] = "cAMD";
-		if (ECX == get32bitAsBE(amd)) {
-			type_ |= tAMD;
-			getCpuid(0x80000001, data);
-			if (EDX & (1U << 31)) {
-				type_ |= t3DN;
-				// 3DNow! implies support for PREFETCHW on AMD
-				type_ |= tPREFETCHW;
-			}
+  Cpu()
+      : type_(),
+        x2APIC_supported_(false),
+        numCores_(),
+        dataCacheSize_(),
+        coresSharignDataCache_(),
+        dataCacheLevels_(0) {
+    uint32_t data[4] = {};
+    const uint32_t& EAX = data[0];
+    const uint32_t& EBX = data[1];
+    const uint32_t& ECX = data[2];
+    const uint32_t& EDX = data[3];
+    getCpuid(0, data);
+    const uint32_t maxNum = EAX;
+    static const char intel[] = "ntel";
+    static const char amd[] = "cAMD";
+    if (ECX == get32bitAsBE(amd)) {
+      type_ |= tAMD;
+      getCpuid(0x80000001, data);
+      if (EDX & (1U << 31)) {
+        type_ |= t3DN;
+        // 3DNow! implies support for PREFETCHW on AMD
+        type_ |= tPREFETCHW;
+      }
 
-			if (EDX & (1U << 29)) {
-				// Long mode implies support for PREFETCHW on AMD
-				type_ |= tPREFETCHW;
-			}
-		}
-		if (ECX == get32bitAsBE(intel)) {
-			type_ |= tINTEL;
-		}
+      if (EDX & (1U << 29)) {
+        // Long mode implies support for PREFETCHW on AMD
+        type_ |= tPREFETCHW;
+      }
+    }
+    if (ECX == get32bitAsBE(intel)) {
+      type_ |= tINTEL;
+    }
 
-		// Extended flags information
-		getCpuid(0x80000000, data);
-		const uint32_t maxExtendedNum = EAX;
-		if (maxExtendedNum >= 0x80000001) {
-			getCpuid(0x80000001, data);
+    // Extended flags information
+    getCpuid(0x80000000, data);
+    const uint32_t maxExtendedNum = EAX;
+    if (maxExtendedNum >= 0x80000001) {
+      getCpuid(0x80000001, data);
 
-			if (EDX & (1U << 31)) type_ |= t3DN;
-			if (EDX & (1U << 30)) type_ |= tE3DN;
-			if (EDX & (1U << 27)) type_ |= tRDTSCP;
-			if (EDX & (1U << 22)) type_ |= tMMX2;
-			if (EDX & (1U << 15)) type_ |= tCMOV;
-			if (ECX & (1U << 5)) type_ |= tLZCNT;
-			if (ECX & (1U << 8)) type_ |= tPREFETCHW;
-		}
+      if (EDX & (1U << 31)) type_ |= t3DN;
+      if (EDX & (1U << 30)) type_ |= tE3DN;
+      if (EDX & (1U << 27)) type_ |= tRDTSCP;
+      if (EDX & (1U << 22)) type_ |= tMMX2;
+      if (EDX & (1U << 15)) type_ |= tCMOV;
+      if (ECX & (1U << 5)) type_ |= tLZCNT;
+      if (ECX & (1U << 8)) type_ |= tPREFETCHW;
+    }
 
-		if (maxExtendedNum >= 0x80000008) {
-			getCpuid(0x80000008, data);
-			if (EBX & (1U << 0)) type_ |= tCLZERO;
-		}
+    if (maxExtendedNum >= 0x80000008) {
+      getCpuid(0x80000008, data);
+      if (EBX & (1U << 0)) type_ |= tCLZERO;
+    }
 
-		getCpuid(1, data);
-		if (ECX & (1U << 0)) type_ |= tSSE3;
-		if (ECX & (1U << 1)) type_ |= tPCLMULQDQ;
-		if (ECX & (1U << 9)) type_ |= tSSSE3;
-		if (ECX & (1U << 19)) type_ |= tSSE41;
-		if (ECX & (1U << 20)) type_ |= tSSE42;
-		if (ECX & (1U << 22)) type_ |= tMOVBE;
-		if (ECX & (1U << 23)) type_ |= tPOPCNT;
-		if (ECX & (1U << 25)) type_ |= tAESNI;
-		if (ECX & (1U << 26)) type_ |= tXSAVE;
-		if (ECX & (1U << 27)) type_ |= tOSXSAVE;
-		if (ECX & (1U << 30)) type_ |= tRDRAND;
-		if (ECX & (1U << 29)) type_ |= tF16C;
+    getCpuid(1, data);
+    if (ECX & (1U << 0)) type_ |= tSSE3;
+    if (ECX & (1U << 1)) type_ |= tPCLMULQDQ;
+    if (ECX & (1U << 9)) type_ |= tSSSE3;
+    if (ECX & (1U << 19)) type_ |= tSSE41;
+    if (ECX & (1U << 20)) type_ |= tSSE42;
+    if (ECX & (1U << 22)) type_ |= tMOVBE;
+    if (ECX & (1U << 23)) type_ |= tPOPCNT;
+    if (ECX & (1U << 25)) type_ |= tAESNI;
+    if (ECX & (1U << 26)) type_ |= tXSAVE;
+    if (ECX & (1U << 27)) type_ |= tOSXSAVE;
+    if (ECX & (1U << 30)) type_ |= tRDRAND;
+    if (ECX & (1U << 29)) type_ |= tF16C;
 
-		if (EDX & (1U << 15)) type_ |= tCMOV;
-		if (EDX & (1U << 23)) type_ |= tMMX;
-		if (EDX & (1U << 25)) type_ |= tMMX2 | tSSE;
-		if (EDX & (1U << 26)) type_ |= tSSE2;
+    if (EDX & (1U << 15)) type_ |= tCMOV;
+    if (EDX & (1U << 23)) type_ |= tMMX;
+    if (EDX & (1U << 25)) type_ |= tMMX2 | tSSE;
+    if (EDX & (1U << 26)) type_ |= tSSE2;
 
-		if (type_ & tOSXSAVE) {
-			// check XFEATURE_ENABLED_MASK[2:1] = '11b'
-			uint64_t bv = getXfeature();
-			if ((bv & 6) == 6) {
-				if (ECX & (1U << 28)) type_ |= tAVX;
-				if (ECX & (1U << 12)) type_ |= tFMA;
-				// do *not* check AVX-512 state on macOS because it has on-demand AVX-512 support
+    if (type_ & tOSXSAVE) {
+      // check XFEATURE_ENABLED_MASK[2:1] = '11b'
+      uint64_t bv = getXfeature();
+      if ((bv & 6) == 6) {
+        if (ECX & (1U << 28)) type_ |= tAVX;
+        if (ECX & (1U << 12)) type_ |= tFMA;
+          // do *not* check AVX-512 state on macOS because it has on-demand AVX-512 support
 #if !defined(__APPLE__)
-				if (((bv >> 5) & 7) == 7)
+        if (((bv >> 5) & 7) == 7)
 #endif
-				{
-					getCpuidEx(7, 0, data);
-					if (EBX & (1U << 16)) type_ |= tAVX512F;
-					if (type_ & tAVX512F) {
-						if (EBX & (1U << 17)) type_ |= tAVX512DQ;
-						if (EBX & (1U << 21)) type_ |= tAVX512_IFMA;
-						if (EBX & (1U << 26)) type_ |= tAVX512PF;
-						if (EBX & (1U << 27)) type_ |= tAVX512ER;
-						if (EBX & (1U << 28)) type_ |= tAVX512CD;
-						if (EBX & (1U << 30)) type_ |= tAVX512BW;
-						if (EBX & (1U << 31)) type_ |= tAVX512VL;
-						if (ECX & (1U << 1)) type_ |= tAVX512_VBMI;
-						if (ECX & (1U << 6)) type_ |= tAVX512_VBMI2;
-						if (ECX & (1U << 11)) type_ |= tAVX512_VNNI;
-						if (ECX & (1U << 12)) type_ |= tAVX512_BITALG;
-						if (ECX & (1U << 14)) type_ |= tAVX512_VPOPCNTDQ;
-						if (EDX & (1U << 2)) type_ |= tAVX512_4VNNIW;
-						if (EDX & (1U << 3)) type_ |= tAVX512_4FMAPS;
-						if (EDX & (1U << 8)) type_ |= tAVX512_VP2INTERSECT;
-						if ((type_ & tAVX512BW) && (EDX & (1U << 23))) type_ |= tAVX512_FP16;
-					}
-				}
-			}
-		}
-		if (maxNum >= 7) {
-			getCpuidEx(7, 0, data);
-			const uint32_t maxNumSubLeaves = EAX;
-			if (type_ & tAVX && (EBX & (1U << 5))) type_ |= tAVX2;
-			if (EBX & (1U << 3)) type_ |= tBMI1;
-			if (EBX & (1U << 8)) type_ |= tBMI2;
-			if (EBX & (1U << 9)) type_ |= tENHANCED_REP;
-			if (EBX & (1U << 18)) type_ |= tRDSEED;
-			if (EBX & (1U << 19)) type_ |= tADX;
-			if (EBX & (1U << 20)) type_ |= tSMAP;
-			if (EBX & (1U << 23)) type_ |= tCLFLUSHOPT;
-			if (EBX & (1U << 4)) type_ |= tHLE;
-			if (EBX & (1U << 11)) type_ |= tRTM;
-			if (EBX & (1U << 14)) type_ |= tMPX;
-			if (EBX & (1U << 29)) type_ |= tSHA;
-			if (ECX & (1U << 0)) type_ |= tPREFETCHWT1;
-			if (ECX & (1U << 5)) type_ |= tWAITPKG;
-			if (ECX & (1U << 8)) type_ |= tGFNI;
-			if (ECX & (1U << 9)) type_ |= tVAES;
-			if (ECX & (1U << 10)) type_ |= tVPCLMULQDQ;
-			if (ECX & (1U << 25)) type_ |= tCLDEMOTE;
-			if (ECX & (1U << 27)) type_ |= tMOVDIRI;
-			if (ECX & (1U << 28)) type_ |= tMOVDIR64B;
-			if (EDX & (1U << 5)) type_ |= tUINTR;
-			if (EDX & (1U << 14)) type_ |= tSERIALIZE;
-			if (EDX & (1U << 22)) type_ |= tAMX_BF16;
-			if (EDX & (1U << 24)) type_ |= tAMX_TILE;
-			if (EDX & (1U << 25)) type_ |= tAMX_INT8;
-			if (maxNumSubLeaves >= 1) {
-				getCpuidEx(7, 1, data);
-				if (EAX & (1U << 0)) type_ |= tSHA512;
-				if (EAX & (1U << 1)) type_ |= tSM3;
-				if (EAX & (1U << 2)) type_ |= tSM4;
-				if (EAX & (1U << 3)) type_ |= tRAO_INT;
-				if (EAX & (1U << 4)) type_ |= tAVX_VNNI;
-				if (type_ & tAVX512F) {
-					if (EAX & (1U << 5)) type_ |= tAVX512_BF16;
-				}
-				if (EAX & (1U << 7)) type_ |= tCMPCCXADD;
-				if (EAX & (1U << 21)) type_ |= tAMX_FP16;
-				if (EAX & (1U << 23)) type_ |= tAVX_IFMA;
-				if (EDX & (1U << 4)) type_ |= tAVX_VNNI_INT8;
-				if (EDX & (1U << 5)) type_ |= tAVX_NE_CONVERT;
-				if (EDX & (1U << 10)) type_ |= tAVX_VNNI_INT16;
-				if (EDX & (1U << 14)) type_ |= tPREFETCHITI;
-			}
-		}
-		setFamily();
-		setNumCores();
-		setCacheHierarchy();
-	}
-	void putFamily() const
-	{
+        {
+          getCpuidEx(7, 0, data);
+          if (EBX & (1U << 16)) type_ |= tAVX512F;
+          if (type_ & tAVX512F) {
+            if (EBX & (1U << 17)) type_ |= tAVX512DQ;
+            if (EBX & (1U << 21)) type_ |= tAVX512_IFMA;
+            if (EBX & (1U << 26)) type_ |= tAVX512PF;
+            if (EBX & (1U << 27)) type_ |= tAVX512ER;
+            if (EBX & (1U << 28)) type_ |= tAVX512CD;
+            if (EBX & (1U << 30)) type_ |= tAVX512BW;
+            if (EBX & (1U << 31)) type_ |= tAVX512VL;
+            if (ECX & (1U << 1)) type_ |= tAVX512_VBMI;
+            if (ECX & (1U << 6)) type_ |= tAVX512_VBMI2;
+            if (ECX & (1U << 11)) type_ |= tAVX512_VNNI;
+            if (ECX & (1U << 12)) type_ |= tAVX512_BITALG;
+            if (ECX & (1U << 14)) type_ |= tAVX512_VPOPCNTDQ;
+            if (EDX & (1U << 2)) type_ |= tAVX512_4VNNIW;
+            if (EDX & (1U << 3)) type_ |= tAVX512_4FMAPS;
+            if (EDX & (1U << 8)) type_ |= tAVX512_VP2INTERSECT;
+            if ((type_ & tAVX512BW) && (EDX & (1U << 23))) type_ |= tAVX512_FP16;
+          }
+        }
+      }
+    }
+    if (maxNum >= 7) {
+      getCpuidEx(7, 0, data);
+      const uint32_t maxNumSubLeaves = EAX;
+      if (type_ & tAVX && (EBX & (1U << 5))) type_ |= tAVX2;
+      if (EBX & (1U << 3)) type_ |= tBMI1;
+      if (EBX & (1U << 8)) type_ |= tBMI2;
+      if (EBX & (1U << 9)) type_ |= tENHANCED_REP;
+      if (EBX & (1U << 18)) type_ |= tRDSEED;
+      if (EBX & (1U << 19)) type_ |= tADX;
+      if (EBX & (1U << 20)) type_ |= tSMAP;
+      if (EBX & (1U << 23)) type_ |= tCLFLUSHOPT;
+      if (EBX & (1U << 4)) type_ |= tHLE;
+      if (EBX & (1U << 11)) type_ |= tRTM;
+      if (EBX & (1U << 14)) type_ |= tMPX;
+      if (EBX & (1U << 29)) type_ |= tSHA;
+      if (ECX & (1U << 0)) type_ |= tPREFETCHWT1;
+      if (ECX & (1U << 5)) type_ |= tWAITPKG;
+      if (ECX & (1U << 8)) type_ |= tGFNI;
+      if (ECX & (1U << 9)) type_ |= tVAES;
+      if (ECX & (1U << 10)) type_ |= tVPCLMULQDQ;
+      if (ECX & (1U << 25)) type_ |= tCLDEMOTE;
+      if (ECX & (1U << 27)) type_ |= tMOVDIRI;
+      if (ECX & (1U << 28)) type_ |= tMOVDIR64B;
+      if (EDX & (1U << 5)) type_ |= tUINTR;
+      if (EDX & (1U << 14)) type_ |= tSERIALIZE;
+      if (EDX & (1U << 22)) type_ |= tAMX_BF16;
+      if (EDX & (1U << 24)) type_ |= tAMX_TILE;
+      if (EDX & (1U << 25)) type_ |= tAMX_INT8;
+      if (maxNumSubLeaves >= 1) {
+        getCpuidEx(7, 1, data);
+        if (EAX & (1U << 0)) type_ |= tSHA512;
+        if (EAX & (1U << 1)) type_ |= tSM3;
+        if (EAX & (1U << 2)) type_ |= tSM4;
+        if (EAX & (1U << 3)) type_ |= tRAO_INT;
+        if (EAX & (1U << 4)) type_ |= tAVX_VNNI;
+        if (type_ & tAVX512F) {
+          if (EAX & (1U << 5)) type_ |= tAVX512_BF16;
+        }
+        if (EAX & (1U << 7)) type_ |= tCMPCCXADD;
+        if (EAX & (1U << 21)) type_ |= tAMX_FP16;
+        if (EAX & (1U << 23)) type_ |= tAVX_IFMA;
+        if (EDX & (1U << 4)) type_ |= tAVX_VNNI_INT8;
+        if (EDX & (1U << 5)) type_ |= tAVX_NE_CONVERT;
+        if (EDX & (1U << 10)) type_ |= tAVX_VNNI_INT16;
+        if (EDX & (1U << 14)) type_ |= tPREFETCHITI;
+      }
+    }
+    setFamily();
+    setNumCores();
+    setCacheHierarchy();
+  }
+  void putFamily() const {
 #ifndef XBYAK_ONLY_CLASS_CPU
-		printf("family=%d, model=%X, stepping=%d, extFamily=%d, extModel=%X\n",
-			family, model, stepping, extFamily, extModel);
-		printf("display:family=%X, model=%X\n", displayFamily, displayModel);
+    printf("family=%d, model=%X, stepping=%d, extFamily=%d, extModel=%X\n", family, model, stepping, extFamily,
+           extModel);
+    printf("display:family=%X, model=%X\n", displayFamily, displayModel);
 #endif
-	}
-	bool has(const Type& type) const
-	{
-		return (type & type_) == type;
-	}
+  }
+  bool has(const Type& type) const { return (type & type_) == type; }
 };
 
 #ifndef XBYAK_ONLY_CLASS_CPU
 class Clock {
-public:
-	static inline uint64_t getRdtsc()
-	{
+ public:
+  static inline uint64_t getRdtsc() {
 #ifdef XBYAK_INTEL_CPU_SPECIFIC
-	#ifdef _MSC_VER
-		return __rdtsc();
-	#else
-		uint32_t eax, edx;
-		__asm__ volatile("rdtsc" : "=a"(eax), "=d"(edx));
-		return ((uint64_t)edx << 32) | eax;
-	#endif
+#ifdef _MSC_VER
+    return __rdtsc();
 #else
-		// TODO: Need another impl of Clock or rdtsc-equivalent for non-x86 cpu
-		return 0;
+    uint32_t eax, edx;
+    __asm__ volatile("rdtsc" : "=a"(eax), "=d"(edx));
+    return ((uint64_t)edx << 32) | eax;
 #endif
-	}
-	Clock()
-		: clock_(0)
-		, count_(0)
-	{
-	}
-	void begin()
-	{
-		clock_ -= getRdtsc();
-	}
-	void end()
-	{
-		clock_ += getRdtsc();
-		count_++;
-	}
-	int getCount() const { return count_; }
-	uint64_t getClock() const { return clock_; }
-	void clear() { count_ = 0; clock_ = 0; }
-private:
-	uint64_t clock_;
-	int count_;
+#else
+    // TODO: Need another impl of Clock or rdtsc-equivalent for non-x86 cpu
+    return 0;
+#endif
+  }
+  Clock() : clock_(0), count_(0) {}
+  void begin() { clock_ -= getRdtsc(); }
+  void end() {
+    clock_ += getRdtsc();
+    count_++;
+  }
+  int getCount() const { return count_; }
+  uint64_t getClock() const { return clock_; }
+  void clear() {
+    count_ = 0;
+    clock_ = 0;
+  }
+
+ private:
+  uint64_t clock_;
+  int count_;
 };
 
 #ifdef XBYAK64
@@ -708,369 +708,453 @@ const int UseRCX = 1 << 6;
 const int UseRDX = 1 << 7;
 
 class Pack {
-	static const size_t maxTblNum = 15;
-	Xbyak::Reg64 tbl_[maxTblNum];
-	size_t n_;
-public:
-	Pack() : tbl_(), n_(0) {}
-	Pack(const Xbyak::Reg64 *tbl, size_t n) { init(tbl, n); }
-	Pack(const Pack& rhs)
-		: n_(rhs.n_)
-	{
-		for (size_t i = 0; i < n_; i++) tbl_[i] = rhs.tbl_[i];
-	}
-	Pack& operator=(const Pack& rhs)
-	{
-		n_ = rhs.n_;
-		for (size_t i = 0; i < n_; i++) tbl_[i] = rhs.tbl_[i];
-		return *this;
-	}
-	Pack(const Xbyak::Reg64& t0)
-	{ n_ = 1; tbl_[0] = t0; }
-	Pack(const Xbyak::Reg64& t1, const Xbyak::Reg64& t0)
-	{ n_ = 2; tbl_[0] = t0; tbl_[1] = t1; }
-	Pack(const Xbyak::Reg64& t2, const Xbyak::Reg64& t1, const Xbyak::Reg64& t0)
-	{ n_ = 3; tbl_[0] = t0; tbl_[1] = t1; tbl_[2] = t2; }
-	Pack(const Xbyak::Reg64& t3, const Xbyak::Reg64& t2, const Xbyak::Reg64& t1, const Xbyak::Reg64& t0)
-	{ n_ = 4; tbl_[0] = t0; tbl_[1] = t1; tbl_[2] = t2; tbl_[3] = t3; }
-	Pack(const Xbyak::Reg64& t4, const Xbyak::Reg64& t3, const Xbyak::Reg64& t2, const Xbyak::Reg64& t1, const Xbyak::Reg64& t0)
-	{ n_ = 5; tbl_[0] = t0; tbl_[1] = t1; tbl_[2] = t2; tbl_[3] = t3; tbl_[4] = t4; }
-	Pack(const Xbyak::Reg64& t5, const Xbyak::Reg64& t4, const Xbyak::Reg64& t3, const Xbyak::Reg64& t2, const Xbyak::Reg64& t1, const Xbyak::Reg64& t0)
-	{ n_ = 6; tbl_[0] = t0; tbl_[1] = t1; tbl_[2] = t2; tbl_[3] = t3; tbl_[4] = t4; tbl_[5] = t5; }
-	Pack(const Xbyak::Reg64& t6, const Xbyak::Reg64& t5, const Xbyak::Reg64& t4, const Xbyak::Reg64& t3, const Xbyak::Reg64& t2, const Xbyak::Reg64& t1, const Xbyak::Reg64& t0)
-	{ n_ = 7; tbl_[0] = t0; tbl_[1] = t1; tbl_[2] = t2; tbl_[3] = t3; tbl_[4] = t4; tbl_[5] = t5; tbl_[6] = t6; }
-	Pack(const Xbyak::Reg64& t7, const Xbyak::Reg64& t6, const Xbyak::Reg64& t5, const Xbyak::Reg64& t4, const Xbyak::Reg64& t3, const Xbyak::Reg64& t2, const Xbyak::Reg64& t1, const Xbyak::Reg64& t0)
-	{ n_ = 8; tbl_[0] = t0; tbl_[1] = t1; tbl_[2] = t2; tbl_[3] = t3; tbl_[4] = t4; tbl_[5] = t5; tbl_[6] = t6; tbl_[7] = t7; }
-	Pack(const Xbyak::Reg64& t8, const Xbyak::Reg64& t7, const Xbyak::Reg64& t6, const Xbyak::Reg64& t5, const Xbyak::Reg64& t4, const Xbyak::Reg64& t3, const Xbyak::Reg64& t2, const Xbyak::Reg64& t1, const Xbyak::Reg64& t0)
-	{ n_ = 9; tbl_[0] = t0; tbl_[1] = t1; tbl_[2] = t2; tbl_[3] = t3; tbl_[4] = t4; tbl_[5] = t5; tbl_[6] = t6; tbl_[7] = t7; tbl_[8] = t8; }
-	Pack(const Xbyak::Reg64& t9, const Xbyak::Reg64& t8, const Xbyak::Reg64& t7, const Xbyak::Reg64& t6, const Xbyak::Reg64& t5, const Xbyak::Reg64& t4, const Xbyak::Reg64& t3, const Xbyak::Reg64& t2, const Xbyak::Reg64& t1, const Xbyak::Reg64& t0)
-	{ n_ = 10; tbl_[0] = t0; tbl_[1] = t1; tbl_[2] = t2; tbl_[3] = t3; tbl_[4] = t4; tbl_[5] = t5; tbl_[6] = t6; tbl_[7] = t7; tbl_[8] = t8; tbl_[9] = t9; }
-	Pack(const Xbyak::Reg64& ta, const Xbyak::Reg64& t9, const Xbyak::Reg64& t8, const Xbyak::Reg64& t7, const Xbyak::Reg64& t6, const Xbyak::Reg64& t5, const Xbyak::Reg64& t4, const Xbyak::Reg64& t3, const Xbyak::Reg64& t2, const Xbyak::Reg64& t1, const Xbyak::Reg64& t0)
-	{ n_ = 11; tbl_[0] = t0; tbl_[1] = t1; tbl_[2] = t2; tbl_[3] = t3; tbl_[4] = t4; tbl_[5] = t5; tbl_[6] = t6; tbl_[7] = t7; tbl_[8] = t8; tbl_[9] = t9; tbl_[10] = ta; }
-	Pack(const Xbyak::Reg64& tb, const Xbyak::Reg64& ta, const Xbyak::Reg64& t9, const Xbyak::Reg64& t8, const Xbyak::Reg64& t7, const Xbyak::Reg64& t6, const Xbyak::Reg64& t5, const Xbyak::Reg64& t4, const Xbyak::Reg64& t3, const Xbyak::Reg64& t2, const Xbyak::Reg64& t1, const Xbyak::Reg64& t0)
-	{ n_ = 12; tbl_[0] = t0; tbl_[1] = t1; tbl_[2] = t2; tbl_[3] = t3; tbl_[4] = t4; tbl_[5] = t5; tbl_[6] = t6; tbl_[7] = t7; tbl_[8] = t8; tbl_[9] = t9; tbl_[10] = ta; tbl_[11] = tb; }
-	Pack& append(const Xbyak::Reg64& t)
-	{
-		if (n_ == maxTblNum) {
-			fprintf(stderr, "ERR Pack::can't append\n");
-			XBYAK_THROW_RET(ERR_BAD_PARAMETER, *this)
-		}
-		tbl_[n_++] = t;
-		return *this;
-	}
-	void init(const Xbyak::Reg64 *tbl, size_t n)
-	{
-		if (n > maxTblNum) {
-			fprintf(stderr, "ERR Pack::init bad n=%d\n", (int)n);
-			XBYAK_THROW(ERR_BAD_PARAMETER)
-		}
-		n_ = n;
-		for (size_t i = 0; i < n; i++) {
-			tbl_[i] = tbl[i];
-		}
-	}
-	const Xbyak::Reg64& operator[](size_t n) const
-	{
-		if (n >= n_) {
-			fprintf(stderr, "ERR Pack bad n=%d(%d)\n", (int)n, (int)n_);
-			XBYAK_THROW_RET(ERR_BAD_PARAMETER, rax)
-		}
-		return tbl_[n];
-	}
-	size_t size() const { return n_; }
-	/*
-		get tbl[pos, pos + num)
-	*/
-	Pack sub(size_t pos, size_t num = size_t(-1)) const
-	{
-		if (num == size_t(-1)) num = n_ - pos;
-		if (pos + num > n_) {
-			fprintf(stderr, "ERR Pack::sub bad pos=%d, num=%d\n", (int)pos, (int)num);
-			XBYAK_THROW_RET(ERR_BAD_PARAMETER, Pack())
-		}
-		Pack pack;
-		pack.n_ = num;
-		for (size_t i = 0; i < num; i++) {
-			pack.tbl_[i] = tbl_[pos + i];
-		}
-		return pack;
-	}
-	void put() const
-	{
-		for (size_t i = 0; i < n_; i++) {
-			printf("%s ", tbl_[i].toString());
-		}
-		printf("\n");
-	}
+  static const size_t maxTblNum = 15;
+  Xbyak::Reg64 tbl_[maxTblNum];
+  size_t n_;
+
+ public:
+  Pack() : tbl_(), n_(0) {}
+  Pack(const Xbyak::Reg64* tbl, size_t n) { init(tbl, n); }
+  Pack(const Pack& rhs) : n_(rhs.n_) {
+    for (size_t i = 0; i < n_; i++) tbl_[i] = rhs.tbl_[i];
+  }
+  Pack& operator=(const Pack& rhs) {
+    n_ = rhs.n_;
+    for (size_t i = 0; i < n_; i++) tbl_[i] = rhs.tbl_[i];
+    return *this;
+  }
+  Pack(const Xbyak::Reg64& t0) {
+    n_ = 1;
+    tbl_[0] = t0;
+  }
+  Pack(const Xbyak::Reg64& t1, const Xbyak::Reg64& t0) {
+    n_ = 2;
+    tbl_[0] = t0;
+    tbl_[1] = t1;
+  }
+  Pack(const Xbyak::Reg64& t2, const Xbyak::Reg64& t1, const Xbyak::Reg64& t0) {
+    n_ = 3;
+    tbl_[0] = t0;
+    tbl_[1] = t1;
+    tbl_[2] = t2;
+  }
+  Pack(const Xbyak::Reg64& t3, const Xbyak::Reg64& t2, const Xbyak::Reg64& t1, const Xbyak::Reg64& t0) {
+    n_ = 4;
+    tbl_[0] = t0;
+    tbl_[1] = t1;
+    tbl_[2] = t2;
+    tbl_[3] = t3;
+  }
+  Pack(const Xbyak::Reg64& t4, const Xbyak::Reg64& t3, const Xbyak::Reg64& t2, const Xbyak::Reg64& t1,
+       const Xbyak::Reg64& t0) {
+    n_ = 5;
+    tbl_[0] = t0;
+    tbl_[1] = t1;
+    tbl_[2] = t2;
+    tbl_[3] = t3;
+    tbl_[4] = t4;
+  }
+  Pack(const Xbyak::Reg64& t5, const Xbyak::Reg64& t4, const Xbyak::Reg64& t3, const Xbyak::Reg64& t2,
+       const Xbyak::Reg64& t1, const Xbyak::Reg64& t0) {
+    n_ = 6;
+    tbl_[0] = t0;
+    tbl_[1] = t1;
+    tbl_[2] = t2;
+    tbl_[3] = t3;
+    tbl_[4] = t4;
+    tbl_[5] = t5;
+  }
+  Pack(const Xbyak::Reg64& t6, const Xbyak::Reg64& t5, const Xbyak::Reg64& t4, const Xbyak::Reg64& t3,
+       const Xbyak::Reg64& t2, const Xbyak::Reg64& t1, const Xbyak::Reg64& t0) {
+    n_ = 7;
+    tbl_[0] = t0;
+    tbl_[1] = t1;
+    tbl_[2] = t2;
+    tbl_[3] = t3;
+    tbl_[4] = t4;
+    tbl_[5] = t5;
+    tbl_[6] = t6;
+  }
+  Pack(const Xbyak::Reg64& t7, const Xbyak::Reg64& t6, const Xbyak::Reg64& t5, const Xbyak::Reg64& t4,
+       const Xbyak::Reg64& t3, const Xbyak::Reg64& t2, const Xbyak::Reg64& t1, const Xbyak::Reg64& t0) {
+    n_ = 8;
+    tbl_[0] = t0;
+    tbl_[1] = t1;
+    tbl_[2] = t2;
+    tbl_[3] = t3;
+    tbl_[4] = t4;
+    tbl_[5] = t5;
+    tbl_[6] = t6;
+    tbl_[7] = t7;
+  }
+  Pack(const Xbyak::Reg64& t8, const Xbyak::Reg64& t7, const Xbyak::Reg64& t6, const Xbyak::Reg64& t5,
+       const Xbyak::Reg64& t4, const Xbyak::Reg64& t3, const Xbyak::Reg64& t2, const Xbyak::Reg64& t1,
+       const Xbyak::Reg64& t0) {
+    n_ = 9;
+    tbl_[0] = t0;
+    tbl_[1] = t1;
+    tbl_[2] = t2;
+    tbl_[3] = t3;
+    tbl_[4] = t4;
+    tbl_[5] = t5;
+    tbl_[6] = t6;
+    tbl_[7] = t7;
+    tbl_[8] = t8;
+  }
+  Pack(const Xbyak::Reg64& t9, const Xbyak::Reg64& t8, const Xbyak::Reg64& t7, const Xbyak::Reg64& t6,
+       const Xbyak::Reg64& t5, const Xbyak::Reg64& t4, const Xbyak::Reg64& t3, const Xbyak::Reg64& t2,
+       const Xbyak::Reg64& t1, const Xbyak::Reg64& t0) {
+    n_ = 10;
+    tbl_[0] = t0;
+    tbl_[1] = t1;
+    tbl_[2] = t2;
+    tbl_[3] = t3;
+    tbl_[4] = t4;
+    tbl_[5] = t5;
+    tbl_[6] = t6;
+    tbl_[7] = t7;
+    tbl_[8] = t8;
+    tbl_[9] = t9;
+  }
+  Pack(const Xbyak::Reg64& ta, const Xbyak::Reg64& t9, const Xbyak::Reg64& t8, const Xbyak::Reg64& t7,
+       const Xbyak::Reg64& t6, const Xbyak::Reg64& t5, const Xbyak::Reg64& t4, const Xbyak::Reg64& t3,
+       const Xbyak::Reg64& t2, const Xbyak::Reg64& t1, const Xbyak::Reg64& t0) {
+    n_ = 11;
+    tbl_[0] = t0;
+    tbl_[1] = t1;
+    tbl_[2] = t2;
+    tbl_[3] = t3;
+    tbl_[4] = t4;
+    tbl_[5] = t5;
+    tbl_[6] = t6;
+    tbl_[7] = t7;
+    tbl_[8] = t8;
+    tbl_[9] = t9;
+    tbl_[10] = ta;
+  }
+  Pack(const Xbyak::Reg64& tb, const Xbyak::Reg64& ta, const Xbyak::Reg64& t9, const Xbyak::Reg64& t8,
+       const Xbyak::Reg64& t7, const Xbyak::Reg64& t6, const Xbyak::Reg64& t5, const Xbyak::Reg64& t4,
+       const Xbyak::Reg64& t3, const Xbyak::Reg64& t2, const Xbyak::Reg64& t1, const Xbyak::Reg64& t0) {
+    n_ = 12;
+    tbl_[0] = t0;
+    tbl_[1] = t1;
+    tbl_[2] = t2;
+    tbl_[3] = t3;
+    tbl_[4] = t4;
+    tbl_[5] = t5;
+    tbl_[6] = t6;
+    tbl_[7] = t7;
+    tbl_[8] = t8;
+    tbl_[9] = t9;
+    tbl_[10] = ta;
+    tbl_[11] = tb;
+  }
+  Pack& append(const Xbyak::Reg64& t) {
+    if (n_ == maxTblNum) {
+      fprintf(stderr, "ERR Pack::can't append\n");
+      XBYAK_THROW_RET(ERR_BAD_PARAMETER, *this)
+    }
+    tbl_[n_++] = t;
+    return *this;
+  }
+  void init(const Xbyak::Reg64* tbl, size_t n) {
+    if (n > maxTblNum) {
+      fprintf(stderr, "ERR Pack::init bad n=%d\n", (int)n);
+      XBYAK_THROW(ERR_BAD_PARAMETER)
+    }
+    n_ = n;
+    for (size_t i = 0; i < n; i++) {
+      tbl_[i] = tbl[i];
+    }
+  }
+  const Xbyak::Reg64& operator[](size_t n) const {
+    if (n >= n_) {
+      fprintf(stderr, "ERR Pack bad n=%d(%d)\n", (int)n, (int)n_);
+      XBYAK_THROW_RET(ERR_BAD_PARAMETER, rax)
+    }
+    return tbl_[n];
+  }
+  size_t size() const { return n_; }
+  /*
+          get tbl[pos, pos + num)
+  */
+  Pack sub(size_t pos, size_t num = size_t(-1)) const {
+    if (num == size_t(-1)) num = n_ - pos;
+    if (pos + num > n_) {
+      fprintf(stderr, "ERR Pack::sub bad pos=%d, num=%d\n", (int)pos, (int)num);
+      XBYAK_THROW_RET(ERR_BAD_PARAMETER, Pack())
+    }
+    Pack pack;
+    pack.n_ = num;
+    for (size_t i = 0; i < num; i++) {
+      pack.tbl_[i] = tbl_[pos + i];
+    }
+    return pack;
+  }
+  void put() const {
+    for (size_t i = 0; i < n_; i++) {
+      printf("%s ", tbl_[i].toString());
+    }
+    printf("\n");
+  }
 };
 
 class StackFrame {
 #ifdef XBYAK64_WIN
-	static const int noSaveNum = 6;
-	static const int rcxPos = 0;
-	static const int rdxPos = 1;
+  static const int noSaveNum = 6;
+  static const int rcxPos = 0;
+  static const int rdxPos = 1;
 #else
-	static const int noSaveNum = 8;
-	static const int rcxPos = 3;
-	static const int rdxPos = 2;
+  static const int noSaveNum = 8;
+  static const int rcxPos = 3;
+  static const int rdxPos = 2;
 #endif
-	static const int maxRegNum = 14; // maxRegNum = 16 - rsp - rax
-	Xbyak::CodeGenerator *code_;
-	int pNum_;
-	int tNum_;
-	bool useRcx_;
-	bool useRdx_;
-	int saveNum_;
-	int P_;
-	bool makeEpilog_;
-	Xbyak::Reg64 pTbl_[4];
-	Xbyak::Reg64 tTbl_[maxRegNum];
-	Pack p_;
-	Pack t_;
-	StackFrame(const StackFrame&);
-	void operator=(const StackFrame&);
-public:
-	const Pack& p;
-	const Pack& t;
-	/*
-		make stack frame
-		@param sf [in] this
-		@param pNum [in] num of function parameter(0 <= pNum <= 4)
-		@param tNum [in] num of temporary register(0 <= tNum, with UseRCX, UseRDX) #{pNum + tNum [+rcx] + [rdx]} <= 14
-		@param stackSizeByte [in] local stack size
-		@param makeEpilog [in] automatically call close() if true
+  static const int maxRegNum = 14;  // maxRegNum = 16 - rsp - rax
+  Xbyak::CodeGenerator* code_;
+  int pNum_;
+  int tNum_;
+  bool useRcx_;
+  bool useRdx_;
+  int saveNum_;
+  int P_;
+  bool makeEpilog_;
+  Xbyak::Reg64 pTbl_[4];
+  Xbyak::Reg64 tTbl_[maxRegNum];
+  Pack p_;
+  Pack t_;
+  StackFrame(const StackFrame&);
+  void operator=(const StackFrame&);
+
+ public:
+  const Pack& p;
+  const Pack& t;
+  /*
+          make stack frame
+          @param sf [in] this
+          @param pNum [in] num of function parameter(0 <= pNum <= 4)
+          @param tNum [in] num of temporary register(0 <= tNum, with UseRCX, UseRDX) #{pNum + tNum [+rcx] + [rdx]} <= 14
+          @param stackSizeByte [in] local stack size
+          @param makeEpilog [in] automatically call close() if true
+
+          you can use
+          rax
+          gp0, ..., gp(pNum - 1)
+          gt0, ..., gt(tNum-1)
+          rcx if tNum & UseRCX
+          rdx if tNum & UseRDX
+          rsp[0..stackSizeByte - 1]
+  */
+  StackFrame(Xbyak::CodeGenerator* code, int pNum, int tNum = 0, int stackSizeByte = 0, bool makeEpilog = true)
+      : code_(code),
+        pNum_(pNum),
+        tNum_(tNum & ~(UseRCX | UseRDX)),
+        useRcx_((tNum & UseRCX) != 0),
+        useRdx_((tNum & UseRDX) != 0),
+        saveNum_(0),
+        P_(0),
+        makeEpilog_(makeEpilog),
+        p(p_),
+        t(t_) {
+    using namespace Xbyak;
+    if (pNum < 0 || pNum > 4) XBYAK_THROW(ERR_BAD_PNUM)
+    const int allRegNum = pNum + tNum_ + (useRcx_ ? 1 : 0) + (useRdx_ ? 1 : 0);
+    if (tNum_ < 0 || allRegNum > maxRegNum) XBYAK_THROW(ERR_BAD_TNUM)
+    const Reg64& _rsp = code->rsp;
+    saveNum_ = local::max_(0, allRegNum - noSaveNum);
+    const int* tbl = getOrderTbl() + noSaveNum;
+    for (int i = 0; i < saveNum_; i++) {
+      code->push(Reg64(tbl[i]));
+    }
+    P_ = (stackSizeByte + 7) / 8;
+    if (P_ > 0 && (P_ & 1) == (saveNum_ & 1)) P_++;  // (rsp % 16) == 8, then increment P_ for 16 byte alignment
+    P_ *= 8;
+    if (P_ > 0) code->sub(_rsp, P_);
+    int pos = 0;
+    for (int i = 0; i < pNum; i++) {
+      pTbl_[i] = Xbyak::Reg64(getRegIdx(pos));
+    }
+    for (int i = 0; i < tNum_; i++) {
+      tTbl_[i] = Xbyak::Reg64(getRegIdx(pos));
+    }
+    if (useRcx_ && rcxPos < pNum) code_->mov(code_->r10, code_->rcx);
+    if (useRdx_ && rdxPos < pNum) code_->mov(code_->r11, code_->rdx);
+    p_.init(pTbl_, pNum);
+    t_.init(tTbl_, tNum_);
+  }
+  /*
+          make epilog manually
+          @param callRet [in] call ret() if true
+  */
+  void close(bool callRet = true) {
+    using namespace Xbyak;
+    const Reg64& _rsp = code_->rsp;
+    const int* tbl = getOrderTbl() + noSaveNum;
+    if (P_ > 0) code_->add(_rsp, P_);
+    for (int i = 0; i < saveNum_; i++) {
+      code_->pop(Reg64(tbl[saveNum_ - 1 - i]));
+    }
 
-		you can use
-		rax
-		gp0, ..., gp(pNum - 1)
-		gt0, ..., gt(tNum-1)
-		rcx if tNum & UseRCX
-		rdx if tNum & UseRDX
-		rsp[0..stackSizeByte - 1]
-	*/
-	StackFrame(Xbyak::CodeGenerator *code, int pNum, int tNum = 0, int stackSizeByte = 0, bool makeEpilog = true)
-		: code_(code)
-		, pNum_(pNum)
-		, tNum_(tNum & ~(UseRCX | UseRDX))
-		, useRcx_((tNum & UseRCX) != 0)
-		, useRdx_((tNum & UseRDX) != 0)
-		, saveNum_(0)
-		, P_(0)
-		, makeEpilog_(makeEpilog)
-		, p(p_)
-		, t(t_)
-	{
-		using namespace Xbyak;
-		if (pNum < 0 || pNum > 4) XBYAK_THROW(ERR_BAD_PNUM)
-		const int allRegNum = pNum + tNum_ + (useRcx_ ? 1 : 0) + (useRdx_ ? 1 : 0);
-		if (tNum_ < 0 || allRegNum > maxRegNum) XBYAK_THROW(ERR_BAD_TNUM)
-		const Reg64& _rsp = code->rsp;
-		saveNum_ = local::max_(0, allRegNum - noSaveNum);
-		const int *tbl = getOrderTbl() + noSaveNum;
-		for (int i = 0; i < saveNum_; i++) {
-			code->push(Reg64(tbl[i]));
-		}
-		P_ = (stackSizeByte + 7) / 8;
-		if (P_ > 0 && (P_ & 1) == (saveNum_ & 1)) P_++; // (rsp % 16) == 8, then increment P_ for 16 byte alignment
-		P_ *= 8;
-		if (P_ > 0) code->sub(_rsp, P_);
-		int pos = 0;
-		for (int i = 0; i < pNum; i++) {
-			pTbl_[i] = Xbyak::Reg64(getRegIdx(pos));
-		}
-		for (int i = 0; i < tNum_; i++) {
-			tTbl_[i] = Xbyak::Reg64(getRegIdx(pos));
-		}
-		if (useRcx_ && rcxPos < pNum) code_->mov(code_->r10, code_->rcx);
-		if (useRdx_ && rdxPos < pNum) code_->mov(code_->r11, code_->rdx);
-		p_.init(pTbl_, pNum);
-		t_.init(tTbl_, tNum_);
-	}
-	/*
-		make epilog manually
-		@param callRet [in] call ret() if true
-	*/
-	void close(bool callRet = true)
-	{
-		using namespace Xbyak;
-		const Reg64& _rsp = code_->rsp;
-		const int *tbl = getOrderTbl() + noSaveNum;
-		if (P_ > 0) code_->add(_rsp, P_);
-		for (int i = 0; i < saveNum_; i++) {
-			code_->pop(Reg64(tbl[saveNum_ - 1 - i]));
-		}
+    if (callRet) code_->ret();
+  }
+  ~StackFrame() {
+    if (!makeEpilog_) return;
+    close();
+  }
 
-		if (callRet) code_->ret();
-	}
-	~StackFrame()
-	{
-		if (!makeEpilog_) return;
-		close();
-	}
-private:
-	const int *getOrderTbl() const
-	{
-		using namespace Xbyak;
-		static const int tbl[] = {
+ private:
+  const int* getOrderTbl() const {
+    using namespace Xbyak;
+    static const int tbl[] = {
 #ifdef XBYAK64_WIN
-			Operand::RCX, Operand::RDX, Operand::R8, Operand::R9, Operand::R10, Operand::R11, Operand::RDI, Operand::RSI,
+        Operand::RCX, Operand::RDX, Operand::R8,  Operand::R9,  Operand::R10, Operand::R11, Operand::RDI, Operand::RSI,
 #else
-			Operand::RDI, Operand::RSI, Operand::RDX, Operand::RCX, Operand::R8, Operand::R9, Operand::R10, Operand::R11,
+        Operand::RDI, Operand::RSI, Operand::RDX, Operand::RCX, Operand::R8,  Operand::R9, Operand::R10, Operand::R11,
 #endif
-			Operand::RBX, Operand::RBP, Operand::R12, Operand::R13, Operand::R14, Operand::R15
-		};
-		return &tbl[0];
-	}
-	int getRegIdx(int& pos) const
-	{
-		assert(pos < maxRegNum);
-		using namespace Xbyak;
-		const int *tbl = getOrderTbl();
-		int r = tbl[pos++];
-		if (useRcx_) {
-			if (r == Operand::RCX) { return Operand::R10; }
-			if (r == Operand::R10) { r = tbl[pos++]; }
-		}
-		if (useRdx_) {
-			if (r == Operand::RDX) { return Operand::R11; }
-			if (r == Operand::R11) { return tbl[pos++]; }
-		}
-		return r;
-	}
+        Operand::RBX, Operand::RBP, Operand::R12, Operand::R13, Operand::R14, Operand::R15};
+    return &tbl[0];
+  }
+  int getRegIdx(int& pos) const {
+    assert(pos < maxRegNum);
+    using namespace Xbyak;
+    const int* tbl = getOrderTbl();
+    int r = tbl[pos++];
+    if (useRcx_) {
+      if (r == Operand::RCX) {
+        return Operand::R10;
+      }
+      if (r == Operand::R10) {
+        r = tbl[pos++];
+      }
+    }
+    if (useRdx_) {
+      if (r == Operand::RDX) {
+        return Operand::R11;
+      }
+      if (r == Operand::R11) {
+        return tbl[pos++];
+      }
+    }
+    return r;
+  }
 };
 #endif
 
 class Profiler {
-	int mode_;
-	const char *suffix_;
-	const void *startAddr_;
+  int mode_;
+  const char* suffix_;
+  const void* startAddr_;
 #ifdef XBYAK_USE_PERF
-	FILE *fp_;
+  FILE* fp_;
 #endif
-public:
-	enum {
-		None = 0,
-		Perf = 1,
-		VTune = 2
-	};
-	Profiler()
-		: mode_(None)
-		, suffix_("")
-		, startAddr_(0)
+ public:
+  enum { None = 0, Perf = 1, VTune = 2 };
+  Profiler()
+      : mode_(None),
+        suffix_(""),
+        startAddr_(0)
 #ifdef XBYAK_USE_PERF
-		, fp_(0)
+        ,
+        fp_(0)
 #endif
-	{
-	}
-	// append suffix to funcName
-	void setNameSuffix(const char *suffix)
-	{
-		suffix_ = suffix;
-	}
-	void setStartAddr(const void *startAddr)
-	{
-		startAddr_ = startAddr;
-	}
-	void init(int mode)
-	{
-		mode_ = None;
-		switch (mode) {
-		default:
-		case None:
-			return;
-		case Perf:
+  {
+  }
+  // append suffix to funcName
+  void setNameSuffix(const char* suffix) { suffix_ = suffix; }
+  void setStartAddr(const void* startAddr) { startAddr_ = startAddr; }
+  void init(int mode) {
+    mode_ = None;
+    switch (mode) {
+      default:
+      case None:
+        return;
+      case Perf:
 #ifdef XBYAK_USE_PERF
-			close();
-			{
-				const int pid = getpid();
-				char name[128];
-				snprintf(name, sizeof(name), "/tmp/perf-%d.map", pid);
-				fp_ = fopen(name, "a+");
-				if (fp_ == 0) {
-					fprintf(stderr, "can't open %s\n", name);
-					return;
-				}
-			}
-			mode_ = Perf;
+        close();
+        {
+          const int pid = getpid();
+          char name[128];
+          snprintf(name, sizeof(name), "/tmp/perf-%d.map", pid);
+          fp_ = fopen(name, "a+");
+          if (fp_ == 0) {
+            fprintf(stderr, "can't open %s\n", name);
+            return;
+          }
+        }
+        mode_ = Perf;
 #endif
-			return;
-		case VTune:
+        return;
+      case VTune:
 #ifdef XBYAK_USE_VTUNE
-			dlopen("dummy", RTLD_LAZY); // force to load dlopen to enable jit profiling
-			if (iJIT_IsProfilingActive() != iJIT_SAMPLING_ON) {
-				fprintf(stderr, "VTune profiling is not active\n");
-				return;
-			}
-			mode_ = VTune;
+        dlopen("dummy", RTLD_LAZY);  // force to load dlopen to enable jit profiling
+        if (iJIT_IsProfilingActive() != iJIT_SAMPLING_ON) {
+          fprintf(stderr, "VTune profiling is not active\n");
+          return;
+        }
+        mode_ = VTune;
 #endif
-			return;
-		}
-	}
-	~Profiler()
-	{
-		close();
-	}
-	void close()
-	{
+        return;
+    }
+  }
+  ~Profiler() { close(); }
+  void close() {
 #ifdef XBYAK_USE_PERF
-		if (fp_ == 0) return;
-		fclose(fp_);
-		fp_ = 0;
+    if (fp_ == 0) return;
+    fclose(fp_);
+    fp_ = 0;
 #endif
-	}
-	void set(const char *funcName, const void *startAddr, size_t funcSize) const
-	{
-		if (mode_ == None) return;
+  }
+  void set(const char* funcName, const void* startAddr, size_t funcSize) const {
+    if (mode_ == None) return;
 #if !defined(XBYAK_USE_PERF) && !defined(XBYAK_USE_VTUNE)
-		(void)funcName;
-		(void)startAddr;
-		(void)funcSize;
+    (void)funcName;
+    (void)startAddr;
+    (void)funcSize;
 #endif
 #ifdef XBYAK_USE_PERF
-		if (mode_ == Perf) {
-			if (fp_ == 0) return;
-			fprintf(fp_, "%llx %zx %s%s", (long long)startAddr, funcSize, funcName, suffix_);
-			/*
-				perf does not recognize the function name which is less than 3,
-				so append '_' at the end of the name if necessary
-			*/
-			size_t n = strlen(funcName) + strlen(suffix_);
-			for (size_t i = n; i < 3; i++) {
-				fprintf(fp_, "_");
-			}
-			fprintf(fp_, "\n");
-			fflush(fp_);
-		}
+    if (mode_ == Perf) {
+      if (fp_ == 0) return;
+      fprintf(fp_, "%llx %zx %s%s", (long long)startAddr, funcSize, funcName, suffix_);
+      /*
+              perf does not recognize the function name which is less than 3,
+              so append '_' at the end of the name if necessary
+      */
+      size_t n = strlen(funcName) + strlen(suffix_);
+      for (size_t i = n; i < 3; i++) {
+        fprintf(fp_, "_");
+      }
+      fprintf(fp_, "\n");
+      fflush(fp_);
+    }
 #endif
 #ifdef XBYAK_USE_VTUNE
-		if (mode_ != VTune) return;
-		char className[] = "";
-		char fileName[] = "";
-		iJIT_Method_Load jmethod = {};
-		jmethod.method_id = iJIT_GetNewMethodID();
-		jmethod.class_file_name = className;
-		jmethod.source_file_name = fileName;
-		jmethod.method_load_address = const_cast<void*>(startAddr);
-		jmethod.method_size = funcSize;
-		jmethod.line_number_size = 0;
-		char buf[128];
-		snprintf(buf, sizeof(buf), "%s%s", funcName, suffix_);
-		jmethod.method_name = buf;
-		iJIT_NotifyEvent(iJVM_EVENT_TYPE_METHOD_LOAD_FINISHED, (void*)&jmethod);
+    if (mode_ != VTune) return;
+    char className[] = "";
+    char fileName[] = "";
+    iJIT_Method_Load jmethod = {};
+    jmethod.method_id = iJIT_GetNewMethodID();
+    jmethod.class_file_name = className;
+    jmethod.source_file_name = fileName;
+    jmethod.method_load_address = const_cast<void*>(startAddr);
+    jmethod.method_size = funcSize;
+    jmethod.line_number_size = 0;
+    char buf[128];
+    snprintf(buf, sizeof(buf), "%s%s", funcName, suffix_);
+    jmethod.method_name = buf;
+    iJIT_NotifyEvent(iJVM_EVENT_TYPE_METHOD_LOAD_FINISHED, (void*)&jmethod);
 #endif
-	}
-	/*
-		for continuous set
-		funcSize = endAddr - <previous set endAddr>
-	*/
-	void set(const char *funcName, const void *endAddr)
-	{
-		set(funcName, startAddr_, (size_t)endAddr - (size_t)startAddr_);
-		startAddr_ = endAddr;
-	}
+  }
+  /*
+          for continuous set
+          funcSize = endAddr - <previous set endAddr>
+  */
+  void set(const char* funcName, const void* endAddr) {
+    set(funcName, startAddr_, (size_t)endAddr - (size_t)startAddr_);
+    startAddr_ = endAddr;
+  }
 };
-#endif // XBYAK_ONLY_CLASS_CPU
+#endif  // XBYAK_ONLY_CLASS_CPU
 
-} } // end of util
+}  // namespace util
+}  // namespace Xbyak
 
 #endif
diff --git a/onnxruntime/test/contrib_ops/matmul_nbits.cc b/onnxruntime/test/contrib_ops/matmul_nbits.cc
index 23c68083e4ae5..0bf57e39d927f 100644
--- a/onnxruntime/test/contrib_ops/matmul_nbits.cc
+++ b/onnxruntime/test/contrib_ops/matmul_nbits.cc
@@ -23,7 +23,8 @@
 namespace onnxruntime {
 namespace test {
 
-void MlasJblasQ4Test(int64_t M, int64_t N, int64_t K, int block_size, bool is_asym, MLAS_COMPUTE_TYPE acc_lvl, float err = 0.1f) {
+void MlasJblasQ4Test(int64_t M, int64_t N, int64_t K, int block_size, bool is_asym, MLAS_COMPUTE_TYPE acc_lvl,
+                     float err = 0.1f) {
   // (M x K) X (K x N)
 
   OpTester test("MatMulNBits", 1, kMSDomain);
@@ -52,12 +53,12 @@ void MlasJblasQ4Test(int64_t M, int64_t N, int64_t K, int block_size, bool is_as
   for (size_t i = 0; i < N * kblks; i++) {
     input2_vals[i] += (i % 100) * 0.00003f;
   }
-  std::vector<uint8_t> input3_vals(N * kblks / 2, (uint8_t)0x88);
+  std::vector<uint8_t> input3_vals(N * kblks / 2, static_cast<uint8_t>(0x88));
 
   std::vector<float> input1_f_vals(N * K);
   if (is_asym) {
     for (size_t i = 0; i < N * kblks; i += 2) {
-      input3_vals[i / 2] = uint8_t(i + 1);
+      input3_vals[i / 2] = static_cast<uint8_t>(i + 1);
     }
     for (int64_t i = 0; i < K; i += 2) {
       for (int64_t j = 0; j < N; j++) {
@@ -69,8 +70,8 @@ void MlasJblasQ4Test(int64_t M, int64_t N, int64_t K, int block_size, bool is_as
         auto src1 = ((srcv & 0xf0) >> 4) - 8;
         auto scale0 = input2_vals[j * kblks + i / block_size];
         auto scale1 = input2_vals[j * kblks + (i + 1) / block_size];
-        input1_f_vals[i * N + j] = (float(src0) - zp0) * scale0;
-        input1_f_vals[(i + 1) * N + j] = (float(src1) - zp0) * scale1;
+        input1_f_vals[i * N + j] = (static_cast<float>(src0) - zp0) * scale0;
+        input1_f_vals[(i + 1) * N + j] = (static_cast<float>(src1) - zp0) * scale1;
       }
     }
   } else {
@@ -81,8 +82,8 @@ void MlasJblasQ4Test(int64_t M, int64_t N, int64_t K, int block_size, bool is_as
         auto src1 = ((srcv & 0xf0) >> 4) - 8;
         auto scale0 = input2_vals[j * kblks + i / block_size];
         auto scale1 = input2_vals[j * kblks + (i + 1) / block_size];
-        input1_f_vals[i * N + j] = float(src0) * scale0;
-        input1_f_vals[(i + 1) * N + j] = float(src1) * scale1;
+        input1_f_vals[i * N + j] = static_cast<float>(src0) * scale0;
+        input1_f_vals[(i + 1) * N + j] = static_cast<float>(src1) * scale1;
       }
     }
   }
@@ -100,21 +101,23 @@ void MlasJblasQ4Test(int64_t M, int64_t N, int64_t K, int block_size, bool is_as
 
   test.AddInput<float>("A", {M, K}, input0_vals, false);
 
-  test.AddInput<uint8_t>("B", {N, (int64_t)kblks, (int64_t)(block_size / 2)}, input1_vals, true);
-  test.AddInput<float>("scales", {N, (int64_t)kblks}, input2_vals, true);
+  test.AddInput<uint8_t>("B", {N, static_cast<int64_t>(kblks), static_cast<int64_t>(block_size / 2)}, input1_vals,
+                         true);
+  test.AddInput<float>("scales", {N, static_cast<int64_t>(kblks)}, input2_vals, true);
   if (is_asym) {
-    test.AddInput<uint8_t>("zero_points", {N, (int64_t)(kblks / 2)}, input3_vals, true);
+    test.AddInput<uint8_t>("zero_points", {N, static_cast<int64_t>(kblks / 2)}, input3_vals, true);
   }
   test.AddOutput<float>("Y", {M, N}, expected_vals, false, 0.f, err);
 
   OrtValue b, scale, zp;
-  Tensor::InitOrtValue(DataTypeImpl::GetType<uint8_t>(), TensorShape({N, (int64_t)kblks, (int64_t)(block_size / 2)}),
+  Tensor::InitOrtValue(DataTypeImpl::GetType<uint8_t>(),
+                       TensorShape({N, static_cast<int64_t>(kblks), static_cast<int64_t>(block_size / 2)}),
                        input1_vals.data(), OrtMemoryInfo(CPU, OrtAllocatorType::OrtDeviceAllocator), b);
 
-  Tensor::InitOrtValue(DataTypeImpl::GetType<float>(), TensorShape({N, (int64_t)kblks}),
+  Tensor::InitOrtValue(DataTypeImpl::GetType<float>(), TensorShape({N, static_cast<int64_t>(kblks)}),
                        input2_vals.data(), OrtMemoryInfo(CPU, OrtAllocatorType::OrtDeviceAllocator), scale);
   if (is_asym) {
-    Tensor::InitOrtValue(DataTypeImpl::GetType<uint8_t>(), TensorShape({N, (int64_t)(kblks / 2)}),
+    Tensor::InitOrtValue(DataTypeImpl::GetType<uint8_t>(), TensorShape({N, static_cast<int64_t>(kblks / 2)}),
                          input3_vals.data(), OrtMemoryInfo(CPU, OrtAllocatorType::OrtDeviceAllocator), zp);
   }
   SessionOptions so;
@@ -136,35 +139,21 @@ void MlasJblasQ4Test(int64_t M, int64_t N, int64_t K, int block_size, bool is_as
     return execution_providers;
   };
 
-  test.Config(so)
-      .ConfigEps(cpu_ep())
-      .RunWithConfig();
+  test.Config(so).ConfigEps(cpu_ep()).RunWithConfig();
 }
 
 #ifdef MLAS_JBLAS
-TEST(MatMulNBits, MlasJblasQ4Fp32G128Sym) {
-  MlasJblasQ4Test(2, 4096, 4096, 128, false, CompFp32);
-}
+TEST(MatMulNBits, MlasJblasQ4Fp32G128Sym) { MlasJblasQ4Test(2, 4096, 4096, 128, false, CompFp32); }
 
-TEST(MatMulNBits, MlasJblasQ4Fp32G32Sym) {
-  MlasJblasQ4Test(2, 4096, 4096, 32, false, CompFp32);
-}
+TEST(MatMulNBits, MlasJblasQ4Fp32G32Sym) { MlasJblasQ4Test(2, 4096, 4096, 32, false, CompFp32); }
 
-TEST(MatMulNBits, MlasJblasQ4Fp32G32Asym) {
-  MlasJblasQ4Test(2, 4096, 4096, 32, true, CompFp32);
-}
+TEST(MatMulNBits, MlasJblasQ4Fp32G32Asym) { MlasJblasQ4Test(2, 4096, 4096, 32, true, CompFp32); }
 
-TEST(MatMulNBits, MlasJblasQ4Int8G128Sym) {
-  MlasJblasQ4Test(2, 4096, 4096, 128, false, CompInt8);
-}
+TEST(MatMulNBits, MlasJblasQ4Int8G128Sym) { MlasJblasQ4Test(2, 4096, 4096, 128, false, CompInt8); }
 
-TEST(MatMulNBits, MlasJblasQ4Int8G1024) {
-  MlasJblasQ4Test(2, 4096, 4096, 1024, false, CompInt8);
-}
+TEST(MatMulNBits, MlasJblasQ4Int8G1024) { MlasJblasQ4Test(2, 4096, 4096, 1024, false, CompInt8); }
 
-TEST(MatMulNBits, MlasJblasQ4Int8GPerN) {
-  MlasJblasQ4Test(2, 4096, 4096, 4096, false, CompInt8);
-}
+TEST(MatMulNBits, MlasJblasQ4Int8GPerN) { MlasJblasQ4Test(2, 4096, 4096, 4096, false, CompInt8); }
 #endif
 
 }  // namespace test
diff --git a/onnxruntime/test/mlas/bench/bench_sqnbitgemm.cpp b/onnxruntime/test/mlas/bench/bench_sqnbitgemm.cpp
index 372a2b3da67ec..3da31fc5045b0 100644
--- a/onnxruntime/test/mlas/bench/bench_sqnbitgemm.cpp
+++ b/onnxruntime/test/mlas/bench/bench_sqnbitgemm.cpp
@@ -96,33 +96,33 @@ void Q4GEMM_Jblas(benchmark::State& state, int block_size, bool is_asym, MLAS_CO
   const size_t N = static_cast<size_t>(state.range(1));
   const size_t K = static_cast<size_t>(state.range(2));
   const size_t threads = static_cast<size_t>(state.range(3));
-  block_size = block_size == -1 ? int(K) : block_size;
+  block_size = block_size == -1 ? static_cast<int>(K) : block_size;
   const size_t pack_b_size = MlasNBitsGemmPackBSize(N, K, block_size, 4, is_asym, cmp_type);
 
   OrtThreadPoolParams tpo;
-  tpo.thread_pool_size = int(threads);
+  tpo.thread_pool_size = static_cast<int>(threads);
   tpo.auto_set_affinity = true;
-  std::unique_ptr<onnxruntime::concurrency::ThreadPool> tp(
-      onnxruntime::concurrency::CreateThreadPool(&onnxruntime::Env::Default(),
-                                                 tpo, onnxruntime::concurrency::ThreadPoolType::INTRA_OP));
+  std::unique_ptr<onnxruntime::concurrency::ThreadPool> tp(onnxruntime::concurrency::CreateThreadPool(
+      &onnxruntime::Env::Default(), tpo, onnxruntime::concurrency::ThreadPoolType::INTRA_OP));
 
   auto A1 = RandomVectorUniform(static_cast<size_t>(M * K), -1.0f, 1.0f);
   auto B1 = RandomVectorUniform<uint8_t>(static_cast<size_t>(N * K / 2), 0, 255);
-  auto blk_num = (K + block_size - 1) / block_size;
+  auto blk_num = static_cast<size_t>((K + block_size - 1) / block_size);
   auto B_scale = RandomVectorUniform(static_cast<size_t>(N * blk_num), 0.003f, 0.005f);
   std::vector<float> C1(static_cast<size_t>(M * N));
   auto B_zp = RandomVectorUniform<uint8_t>(static_cast<size_t>(N * blk_num / 2), 0, 255);
 
   std::vector<int8_t> B1_packed(pack_b_size);
-  MlasNBitsGemmPackB(B1_packed.data(), B1.data(), B_scale.data(), is_asym ? B_zp.data() : nullptr, N, K, K, block_size, 4, is_asym, true, cmp_type, tp.get());
+  MlasNBitsGemmPackB(B1_packed.data(), B1.data(), B_scale.data(), is_asym ? B_zp.data() : nullptr, N, K, K, block_size,
+                     4, is_asym, true, cmp_type, tp.get());
 
-  MLAS_NBITS_GEMM_DATA_SIMPLE_PARAMS params1;
+  MLAS_NBITS_GEMM_DATA_PACKED_PARAMS params1;
   params1.A = A1.data();
   params1.lda = K;
   params1.C = C1.data();
   params1.ldc = N;
   params1.B = B1_packed.data();
-  std::vector<int8_t> workspace(size_t(M <= 32 ? 32 : M) * K * 4);
+  std::vector<int8_t> workspace(static_cast<size_t>(M <= 32 ? 32 : M) * K * 4);
   MlasNBitsGemmBatchPackedB(M, N, K, 1, &params1, workspace.data(), tp.get());
 
   for (auto _ : state) {