diff --git a/.gitignore b/.gitignore
new file mode 100644
index 000000000..7d2913bd3
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,6 @@
+################################################################################
+# This .gitignore file was automatically created by Microsoft(R) Visual Studio.
+################################################################################
+
+/.vs
+/out
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 463bb2117..69366f3a9 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -70,6 +70,7 @@ if (NE_GPU)
 endif()
 
 option(NE_BUILD_TESTS            "neural_engine: build tests"    ${NE_STANDALONE})
+option(NE_BTLA_UT                "enable BesTLA's unit tests"    OFF)
 option(NE_BUILD_EXAMPLES         "neural_engine: build examples" ${NE_STANDALONE})
 if(NE_BUILD_TESTS)
   add_compile_definitions(NE_BUILD_TESTS)
@@ -139,6 +140,11 @@ if (NE_PYTHON_API)
   add_subdirectory(third_party/pybind11)
 endif()
 
-add_subdirectory(bestla jblas)
+if (NE_BTLA_UT)
+  set(BTLA_UT_ALL ON)
+endif()
+include(FindOpenMP)
+
+add_subdirectory(bestla)
 
 add_subdirectory(neural_speed)
diff --git a/CMakePresets.json b/CMakePresets.json
index a3c8cdf25..6cca625b1 100644
--- a/CMakePresets.json
+++ b/CMakePresets.json
@@ -57,6 +57,16 @@
       "description": "Target Windows (64-bit) with the Visual Studio development environment. (RelWithDebInfo)",
       "inherits": "x64-debug",
       "cacheVariables": { "CMAKE_BUILD_TYPE": "Release" }
+    },
+    {
+      "name": "x64-bestla-UT",
+      "displayName": "x64 BesTLA unit test",
+      "description": "Target Windows (64-bit) with the Visual Studio development environment. (RelWithDebInfo)",
+      "inherits": "x64-debug",
+      "cacheVariables": {
+        "CMAKE_BUILD_TYPE": "Release",
+        "NE_BTLA_UT": "ON"
+      }
     }
   ]
 }
diff --git a/README.md b/README.md
index 4683601e5..1be563b17 100644
--- a/README.md
+++ b/README.md
@@ -385,7 +385,7 @@ Argument description of inference.py:
 | --keep                                            | Number of tokens to keep from the initial prompt: Int (default: 0, -1 = all)                                                                                                            |
 | --shift-roped-k                                   | Use [ring-buffer](./docs/infinite_inference.md#shift-rope-k-and-ring-buffer) and thus do not re-computing after reaching ctx_size (default: False)                                      |
 | --glm_tokenizer                                   | The path of the chatglm tokenizer: String (default: THUDM/chatglm-6b)                                                                                                                   |
-| --memory-f32 <br> --memory-f16 <br> --memory-auto | Data type of kv memory (default to auto);<br>If set to auto, the runtime will try with jblas flash attn managed format (currently requires GCC11+ & AMX) and fall back to fp16 if failed |
+| --memory-f32 <br> --memory-f16 <br> --memory-auto | Data type of kv memory (default to auto);<br>If set to auto, the runtime will try with bestla flash attn managed format (currently requires GCC11+ & AMX) and fall back to fp16 if failed |
 
 
 ### 3. Tensor Parallelism cross nodes/sockets
diff --git a/bestla/CMakeLists.txt b/bestla/CMakeLists.txt
index d05d1b299..c07ac66dc 100644
--- a/bestla/CMakeLists.txt
+++ b/bestla/CMakeLists.txt
@@ -1,40 +1,40 @@
-cmake_minimum_required(VERSION 3.5)
+cmake_minimum_required(VERSION 3.12)
 
-project(jblas LANGUAGES CXX VERSION 0.1.0)
+project(bestla LANGUAGES CXX VERSION 0.1.0)
 file(GLOB headers ${PROJECT_NAME}/*.h ${PROJECT_NAME}/*.hpp)
 file(GLOB xbyak_headers ${PROJECT_NAME}/xbyak/*.h ${PROJECT_NAME}/xbyak/*.hpp)
 
-option(JBLAS_UT_ALL "Enable all unit tests" OFF)
-option(JBLAS_UT_DEBUG "Enable debug unit tests" ON)
-option(JBLAS_UT_EPILOGUE "Enable unit test for epilogue" OFF)
-option(JBLAS_UT_PROLOGUE_A "Enable unit test for activation prologue" OFF)
-option(JBLAS_UT_PROLOGUE_B "Enable unit test for weight prologue" OFF)
-option(JBLAS_UT_GEMM "Enable unit test for micro gemm kernels" OFF)
-option(JBLAS_UT_WRAPPER "Enable unit test for parallel gemms" OFF)
-option(JBLAS_UT_PARALLEL "Enable unit test for parallel set" OFF)
-option(JBLAS_UT_KERNEL_JIT "Enable unit test for jit kernels" OFF)
-option(JBLAS_UT_KERNEL_INTRIN "Enable unit test for intrinsic kernels" OFF)
-option(JBLAS_UT_KERNEL_WRAPPER "Enable unit test for runtime ISA kernels" OFF)
-option(JBLAS_UT_NOASAN "Disable sanitize" OFF)
-option(JBLAS_UT_BENCHMARK "Benchmark ON may take a long time to finish all tests" OFF)
-option(JBLAS_UT_OPENMP "Use OpenMP" ON)
-
-if(JBLAS_UT_ALL)
-set(JBLAS_UT_EPILOGUE ON)
-set(JBLAS_UT_PROLOGUE_A ON)
-set(JBLAS_UT_PROLOGUE_B ON)
-set(JBLAS_UT_GEMM ON)
-set(JBLAS_UT_WRAPPER ON)
-set(JBLAS_UT_PARALLEL ON)
-set(JBLAS_UT_KERNEL_JIT ON)
-set(JBLAS_UT_KERNEL_INTRIN ON)
-set(JBLAS_UT_KERNEL_WRAPPER ON)
-endif(JBLAS_UT_ALL)
+option(BTLA_UT_ALL "Enable all unit tests" OFF)
+option(BTLA_UT_DEBUG "Enable debug unit tests" ON)
+option(BTLA_UT_EPILOGUE "Enable unit test for epilogue" OFF)
+option(BTLA_UT_PROLOGUE_A "Enable unit test for activation prologue" OFF)
+option(BTLA_UT_PROLOGUE_B "Enable unit test for weight prologue" OFF)
+option(BTLA_UT_GEMM "Enable unit test for micro gemm kernels" OFF)
+option(BTLA_UT_WRAPPER "Enable unit test for parallel gemms" OFF)
+option(BTLA_UT_PARALLEL "Enable unit test for parallel set" OFF)
+option(BTLA_UT_KERNEL_JIT "Enable unit test for jit kernels" OFF)
+option(BTLA_UT_KERNEL_INTRIN "Enable unit test for intrinsic kernels" OFF)
+option(BTLA_UT_KERNEL_WRAPPER "Enable unit test for runtime ISA kernels" OFF)
+option(BTLA_UT_NOASAN "Disable sanitize" OFF)
+option(BTLA_UT_BENCHMARK "Benchmark ON may take a long time to finish all tests" OFF)
+option(BTLA_UT_OPENMP "Use OpenMP" ON)
+
+if(BTLA_UT_ALL)
+set(BTLA_UT_EPILOGUE ON)
+set(BTLA_UT_PROLOGUE_A ON)
+set(BTLA_UT_PROLOGUE_B ON)
+set(BTLA_UT_GEMM ON)
+set(BTLA_UT_WRAPPER ON)
+set(BTLA_UT_PARALLEL ON)
+set(BTLA_UT_KERNEL_JIT ON)
+set(BTLA_UT_KERNEL_INTRIN ON)
+set(BTLA_UT_KERNEL_WRAPPER ON)
+endif(BTLA_UT_ALL)
 
 set(UT_BUILD FALSE)
-if(JBLAS_UT_DEBUG OR JBLAS_UT_PROLOGUE_A OR JBLAS_UT_PROLOGUE_B OR JBLAS_UT_EPILOGUE OR JBLAS_UT_GEMM
-OR JBLAS_UT_WRAPPER OR JBLAS_UT_PARALLEL OR JBLAS_UT_KERNEL_JIT OR JBLAS_UT_KERNEL_INTRIN
-OR JBLAS_UT_KERNEL_WRAPPER)
+if(BTLA_UT_DEBUG OR BTLA_UT_PROLOGUE_A OR BTLA_UT_PROLOGUE_B OR BTLA_UT_EPILOGUE OR BTLA_UT_GEMM
+OR BTLA_UT_WRAPPER OR BTLA_UT_PARALLEL OR BTLA_UT_KERNEL_JIT OR BTLA_UT_KERNEL_INTRIN
+OR BTLA_UT_KERNEL_WRAPPER)
 set(UT_BUILD TRUE)
 endif()
 
@@ -91,10 +91,7 @@ if(WIN32)
 	target_link_options(${PROJECT_NAME} INTERFACE /STACK:5242880) #Stack requires up to L2 cache size
 endif(WIN32)
 
-if(JBLAS_UT_OPENMP)
-include(FindOpenMP)
-target_link_libraries(${PROJECT_NAME} INTERFACE OpenMP::OpenMP_CXX OpenMP::OpenMP_C)
-endif()
+
 
 set(CMAKE_CXX_STANDARD 17)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
@@ -109,27 +106,31 @@ target_compile_features(${PROJECT_NAME} INTERFACE cxx_std_17)
 if(UT_BUILD)
 	file(GLOB srcs ${PROJECT_NAME}/ut/*.cc ${PROJECT_NAME}/ut/*.cpp) #compile everthing even run parts of UTs
 	file(GLOB ut_headers ${PROJECT_NAME}/ut/*.h)
+  include_directories(${PROJECT_NAME})
 	add_executable(${PROJECT_NAME}_ut ${srcs} ${headers} ${ut_headers})
-
+  if(BTLA_UT_OPENMP)
+    include(FindOpenMP)
+    target_link_libraries(${PROJECT_NAME}_ut PRIVATE OpenMP::OpenMP_CXX OpenMP::OpenMP_C)
+  endif()
 	if(NOT WIN32)
-		if(NOT JBLAS_UT_NOASAN)
-		target_compile_options(${PROJECT_NAME}_ut PRIVATE -fsanitize=address)
-		target_link_options(${PROJECT_NAME}_ut PRIVATE -fsanitize=address)
+		if(NOT BTLA_UT_NOASAN)
+		  target_compile_options(${PROJECT_NAME}_ut PRIVATE -fsanitize=address)
+		  target_link_options(${PROJECT_NAME}_ut PRIVATE -fsanitize=address)
 		endif()
 		target_link_options(${PROJECT_NAME}_ut PRIVATE -lpthread)
 	endif()
 
-	add_ut_flag(JBLAS_UT_DEBUG)
-	add_ut_flag(JBLAS_UT_EPILOGUE)
-	add_ut_flag(JBLAS_UT_PROLOGUE_A)
-	add_ut_flag(JBLAS_UT_PROLOGUE_B)
-	add_ut_flag(JBLAS_UT_GEMM)
-	add_ut_flag(JBLAS_UT_PARALLEL)
-	add_ut_flag(JBLAS_UT_WRAPPER)
-	add_ut_flag(JBLAS_UT_KERNEL_INTRIN)
-	add_ut_flag(JBLAS_UT_KERNEL_JIT)
-	add_ut_flag(JBLAS_UT_KERNEL_WRAPPER)
-	add_ut_flag(JBLAS_UT_BENCHMARK)
+	add_ut_flag(BTLA_UT_DEBUG)
+	add_ut_flag(BTLA_UT_EPILOGUE)
+	add_ut_flag(BTLA_UT_PROLOGUE_A)
+	add_ut_flag(BTLA_UT_PROLOGUE_B)
+	add_ut_flag(BTLA_UT_GEMM)
+	add_ut_flag(BTLA_UT_PARALLEL)
+	add_ut_flag(BTLA_UT_WRAPPER)
+	add_ut_flag(BTLA_UT_KERNEL_INTRIN)
+	add_ut_flag(BTLA_UT_KERNEL_JIT)
+	add_ut_flag(BTLA_UT_KERNEL_WRAPPER)
+	add_ut_flag(BTLA_UT_BENCHMARK)
 
 	target_link_libraries(${PROJECT_NAME}_ut PRIVATE ${PROJECT_NAME})
 endif(UT_BUILD)
diff --git a/bestla/README.md b/bestla/README.md
index 08a29a9c9..8b46f5a9b 100644
--- a/bestla/README.md
+++ b/bestla/README.md
@@ -52,6 +52,6 @@ Compile:
 
 Usage:
 ```cmake
-add_subdirectory(jblas)
-target_link_libraries("${YOUR_PROJECT}" jblas::jblas)
+add_subdirectory(bestla)
+target_link_libraries("${YOUR_PROJECT}" bestla::bestla)
 ```
diff --git a/bestla/jblas/jit_blas.h b/bestla/bestla/bestla.h
similarity index 74%
rename from bestla/jblas/jit_blas.h
rename to bestla/bestla/bestla.h
index 8446698e3..890704814 100644
--- a/bestla/jblas/jit_blas.h
+++ b/bestla/bestla/bestla.h
@@ -13,26 +13,26 @@
 //  limitations under the License.
 #pragma once
 #include <stdint.h>
-enum JBLAS_CODE {
-  JblasSuccess = 0,
-  JblasInvalidParam = 1,
-  JblasInvalidISA = 2,
-  JblasRuntimeError = 4,
-  JblasNotSupport = 8,
+enum class BTLA_CODE {
+  Success = 0,
+  InvalidParam = 1,
+  InvalidISA = 2,
+  RuntimeError = 4,
+  NotSupport = 8,
 };
-enum JBLAS_ISA : uint8_t {
-  JblasNoSIMD = 0,
-  JblasAVX,
-  JblasAVX2,
-  JblasAVX_VNNI,
-  JblasAVX512F,
-  JblasAVX512_VNNI,
-  JblasAMX_BF16,
-  JblasAMX_INT8,
-  JblasAVX512_FP16,
-  JblasAVX512_BF16,
+enum class BTLA_ISA : uint8_t {
+  NoSIMD = 0,
+  AVX,
+  AVX2,
+  AVX_VNNI,
+  AVX512F,
+  AVX512_VNNI,
+  AMX_BF16,
+  AMX_INT8,
+  AVX512_FP16,
+  AVX512_BF16,
 };
-enum class JBLAS_DTYPE : uint32_t {
+enum class BTLA_DTYPE : uint32_t {
   EleBitsMask = 0xff,
   EleBitsShift = 0,
   EleBitsUndef = 0,
@@ -70,15 +70,9 @@ enum class JBLAS_DTYPE : uint32_t {
   U32 = EleBits32 | TypeInt | SubType1,
 };
 
-enum JBLAS_LAYOUT { JblasRowMajor = 101, JblasColMajor = 102 };
-enum JBLAS_TRANSPOSE {
-  JblasNoTrans = 111,
-  JblasTrans = 112,
-  JblasConjTrans = 113,
-};
-enum JBLAS_ELTWISEOP { GELU, SWISH, TANH, EXP, LOW_PRECISION_EXP, RELU, LINEAR };
+enum class BTLA_ELTWISEOP { GELU, SWISH, TANH, EXP, LOW_PRECISION_EXP, RELU, LINEAR };
 
-enum class JBLAS_PROLOGUEB_IDS : uint32_t {
+enum class BTLA_PROLOGUEB_IDS : uint32_t {
   Undef = (uint32_t)-1,
   Begin = 0,
   NormalBegin = Begin,
diff --git a/bestla/jblas/jit_blas_device.h b/bestla/bestla/bestla_device.h
similarity index 95%
rename from bestla/jblas/jit_blas_device.h
rename to bestla/bestla/bestla_device.h
index 4e54b63d3..ebfc7d8de 100644
--- a/bestla/jblas/jit_blas_device.h
+++ b/bestla/bestla/bestla_device.h
@@ -15,7 +15,7 @@
 #include <map>
 #include <thread>
 #include <vector>
-#include "jit_blas.h"
+#include "bestla.h"
 #include "xbyak/xbyak_util.h"
 #ifdef _WIN32
 #include <windows.h>
@@ -23,7 +23,7 @@
 #include <sched.h>
 #endif
 
-namespace jblas {
+namespace bestla {
 
 namespace device {
 
@@ -195,16 +195,16 @@ class SapphireRapids {
   static constexpr bool AMX_COMPLEX = 0;
 };
 
-template <JBLAS_ISA ISA_T>
+template <BTLA_ISA ISA_T>
 class isa_base {
  public:
-  static bool constexpr avx = ISA_T >= JblasAVX;
-  static bool constexpr avx2 = ISA_T >= JblasAVX2;
-  static bool constexpr avx512f = ISA_T >= JblasAVX512F;
-  static bool constexpr avx512_vnni = ISA_T >= JblasAVX512_VNNI;
-  static bool constexpr avx512_fp16 = ISA_T >= JblasAVX512_FP16;
-  static bool constexpr amx_bf16 = ISA_T >= JblasAMX_BF16;
-  static bool constexpr amx_int8 = ISA_T >= JblasAMX_INT8;
+  static bool constexpr avx = ISA_T >= BTLA_ISA::AVX;
+  static bool constexpr avx2 = ISA_T >= BTLA_ISA::AVX2;
+  static bool constexpr avx512f = ISA_T >= BTLA_ISA::AVX512F;
+  static bool constexpr avx512_vnni = ISA_T >= BTLA_ISA::AVX512_VNNI;
+  static bool constexpr avx512_fp16 = ISA_T >= BTLA_ISA::AVX512_FP16;
+  static bool constexpr amx_bf16 = ISA_T >= BTLA_ISA::AMX_BF16;
+  static bool constexpr amx_int8 = ISA_T >= BTLA_ISA::AMX_INT8;
 };
 
 class CpuDevice {
@@ -422,7 +422,7 @@ class CpuDevice {
   float P_power = 4.8, E_power = 2.3;
 };
 
-#define GetCPUDevice() auto _cd = jblas::device::CpuDevice::getInstance();
+#define GetCPUDevice() auto _cd = bestla::device::CpuDevice::getInstance();
 
 class CpuBase {
  public:
@@ -436,4 +436,4 @@ class CpuBase {
   int mNumThreads;
 };
 }  // namespace device
-}  // namespace jblas
+}  // namespace bestla
diff --git a/bestla/jblas/jit_blas_epilogue.h b/bestla/bestla/bestla_epilogue.h
similarity index 76%
rename from bestla/jblas/jit_blas_epilogue.h
rename to bestla/bestla/bestla_epilogue.h
index 6c7e0ee4e..de25f330b 100644
--- a/bestla/jblas/jit_blas_epilogue.h
+++ b/bestla/bestla/bestla_epilogue.h
@@ -14,12 +14,12 @@
 #pragma once
 #include <tuple>
 
-#include "jit_base.h"
-#include "jit_blas.h"
-#include "jit_blas_utils.h"
+#include "bestla.h"
+#include "bestla_jit.h"
+#include "bestla_utils.h"
 #include "kernel_wrapper.h"
 
-namespace jblas {
+namespace bestla {
 namespace epilogue {
 namespace gemm {
 
@@ -30,15 +30,15 @@ struct ParamAccumulatorWriteBack {
   void* elt_const_v;
 };
 
-template <JBLAS_ISA ISA_T, typename _SRC_T, typename _DST_T>
+template <BTLA_ISA ISA_T, typename _SRC_T, typename _DST_T>
 class AccumulatorWriteBack {
  public:
   using SType = _SRC_T;
   using DType = _DST_T;
   using Param = ParamAccumulatorWriteBack<DType>;
 
-  JBLAS_CODE forward(const _SRC_T* cacheptr, const int cachestep, const int M_offset, const int N_offset, const int M,
-                     const int N, const Param& _param, void* tmpcache, size_t cachesize) {
+  BTLA_CODE forward(const _SRC_T* cacheptr, const int cachestep, const int M_offset, const int N_offset, const int M,
+                    const int N, const Param& _param, void* tmpcache, size_t cachesize) {
     auto COffset = M_offset * _param.ldc + N_offset;
     auto cptr = _param.C + COffset;
     return kernel::wrapper::Memcpy2D::template forward<ISA_T, SType, DType>(cacheptr, cptr, M, N, cachestep, _param.ldc,
@@ -46,12 +46,12 @@ class AccumulatorWriteBack {
   }
 };
 
-template <JBLAS_ISA ISA_T, typename _SRC_T, typename _DST_T, JBLAS_ELTWISEOP _OP>
+template <BTLA_ISA ISA_T, typename _SRC_T, typename _DST_T, BTLA_ELTWISEOP _OP>
 class CustomAccumulatorWriteBackWithEltop {
  public:
   using Param = ParamAccumulatorWriteBack<_DST_T>;
-  JBLAS_CODE forward(const _SRC_T* cacheptr, const int cachestep, const int M_offset, const int N_offset, const int M,
-                     const int N, const Param& _param, void* tmpcache, size_t cachesize) {
+  BTLA_CODE forward(const _SRC_T* cacheptr, const int cachestep, const int M_offset, const int N_offset, const int M,
+                    const int N, const Param& _param, void* tmpcache, size_t cachesize) {
     auto COffset = M_offset * _param.ldc + N_offset;
     auto cptr = _param.C + COffset;
     if constexpr (std::is_same<_SRC_T, float>::value && std::is_same<_DST_T, float>::value) {
@@ -62,26 +62,27 @@ class CustomAccumulatorWriteBackWithEltop {
     }
   }
 };
-template <JBLAS_ISA ISA_T>
+template <BTLA_ISA ISA_T>
 using AccumulatorWriteBackFp32 = AccumulatorWriteBack<ISA_T, float, float>;
-template <JBLAS_ISA ISA_T>
+template <BTLA_ISA ISA_T>
 using AccumulatorWriteBackInt32 = AccumulatorWriteBack<ISA_T, int, int>;
-template <JBLAS_ISA ISA_T>
+template <BTLA_ISA ISA_T>
 using AccumulatorWriteBackBf16 = AccumulatorWriteBack<ISA_T, utils::bf16, utils::bf16>;
-template <JBLAS_ISA ISA_T>
+template <BTLA_ISA ISA_T>
 using AccumulatorWriteBackFp16 = AccumulatorWriteBack<ISA_T, utils::fp16, utils::fp16>;
-template <JBLAS_ISA ISA_T>
+template <BTLA_ISA ISA_T>
 using AccumulatorWriteBackBf16Fp32 = AccumulatorWriteBack<ISA_T, utils::bf16, float>;
-template <JBLAS_ISA ISA_T>
+template <BTLA_ISA ISA_T>
 using AccumulatorWriteBackFp16Fp32 = AccumulatorWriteBack<ISA_T, utils::fp16, float>;
-template <JBLAS_ISA ISA_T>
+template <BTLA_ISA ISA_T>
 using AccumulatorWriteBackFp32Bf16 = AccumulatorWriteBack<ISA_T, float, utils::bf16>;
 
-template <JBLAS_ISA ISA_T>
-using AccumulatorWriteBackWithGeluFp32 = CustomAccumulatorWriteBackWithEltop<ISA_T, float, float, GELU>;
+template <BTLA_ISA ISA_T>
+using AccumulatorWriteBackWithGeluFp32 = CustomAccumulatorWriteBackWithEltop<ISA_T, float, float, BTLA_ELTWISEOP::GELU>;
 
-template <JBLAS_ISA ISA_T>
-using AccumulatorWriteBackWithSwishFp32 = CustomAccumulatorWriteBackWithEltop<ISA_T, float, float, SWISH>;
+template <BTLA_ISA ISA_T>
+using AccumulatorWriteBackWithSwishFp32 =
+    CustomAccumulatorWriteBackWithEltop<ISA_T, float, float, BTLA_ELTWISEOP::SWISH>;
 
 template <typename DT>
 struct ParamAlphaBetaProcess {
@@ -89,13 +90,13 @@ struct ParamAlphaBetaProcess {
   int ldc, ldd;
   float alpha, beta;
 };
-template <JBLAS_ISA ISA_T>
+template <BTLA_ISA ISA_T>
 class AlphaBetaProcessFp32 {
  public:
   using Param = ParamAlphaBetaProcess<float>;
 
-  JBLAS_CODE forward(const float* cacheptr, const int cachestep, const int M_offset, const int N_offset, const int M,
-                     const int N, const Param& _param, void* tmpcache, size_t cachesize) {
+  BTLA_CODE forward(const float* cacheptr, const int cachestep, const int M_offset, const int N_offset, const int M,
+                    const int N, const Param& _param, void* tmpcache, size_t cachesize) {
     auto DOffset = M_offset * _param.ldd + N_offset;
     auto COffset = M_offset * _param.ldc + N_offset;
     auto cptr = _param.C + COffset;
@@ -107,43 +108,43 @@ class AlphaBetaProcessFp32 {
 
 struct ParamCompFp32BlockEpilogue {
   void* scales;
-  JBLAS_DTYPE scaledtype;
+  BTLA_DTYPE scaledtype;
   int ldsb;
   int8_t* zps = nullptr;
   float* reduce = nullptr;
   int ldra;
 };
-template <JBLAS_ISA ISA_T>
+template <BTLA_ISA ISA_T>
 class CompFp32BlockEpilogue {
  public:
   using Param = ParamCompFp32BlockEpilogue;
-  JBLAS_CODE forward(const float* srcptr, float* dstptr, const int cachestep, const int M_offset, const int N_offset,
-                     const int K_offset, const int M, const int N, const Param& _param, void* tmpcache,
-                     size_t cachesize) {
-    auto ret = JblasNotSupport;
-    if (_param.scaledtype == JBLAS_DTYPE::F32) {
+  BTLA_CODE forward(const float* srcptr, float* dstptr, const int cachestep, const int M_offset, const int N_offset,
+                    const int K_offset, const int M, const int N, const Param& _param, void* tmpcache,
+                    size_t cachesize) {
+    auto ret = BTLA_CODE::NotSupport;
+    if (_param.scaledtype == BTLA_DTYPE::F32) {
       ret = kernel::wrapper::CompFp32BlockScale::template forward<ISA_T>(
           reinterpret_cast<float*>(_param.scales) + K_offset * _param.ldsb + N_offset, srcptr, cachestep, dstptr,
           cachestep, M, N);
-      assert(ret == JblasSuccess);
+      assert(ret == BTLA_CODE::Success);
       if (_param.zps != nullptr) {
         ret = kernel::wrapper::RemoveZeroPointBias::forward_wei<ISA_T>(
             dstptr, cachestep, M, N, _param.zps + K_offset * _param.ldsb + N_offset,
             reinterpret_cast<float*>(_param.scales) + K_offset * _param.ldsb + N_offset, _param.ldra,
             _param.reduce + M_offset * _param.ldra + K_offset);
       }
-      assert(ret == JblasSuccess);
+      assert(ret == BTLA_CODE::Success);
       return ret;
-    } else if (_param.scaledtype == JBLAS_DTYPE::BF16) {
+    } else if (_param.scaledtype == BTLA_DTYPE::BF16) {
       ret = kernel::wrapper::CompFp32BlockScale::template forward<ISA_T>(
           reinterpret_cast<utils::bf16*>(_param.scales) + K_offset * _param.ldsb + N_offset, srcptr, cachestep, dstptr,
           cachestep, M, N);
       if (_param.zps != nullptr) {
         assert(0);
       }
-      assert(ret == JblasSuccess);
+      assert(ret == BTLA_CODE::Success);
       return ret;
-    } else if (_param.scaledtype == JBLAS_DTYPE::F8_E8M0) {
+    } else if (_param.scaledtype == BTLA_DTYPE::F8_E8M0) {
       ret = kernel::wrapper::CompFp32BlockScale::template forward<ISA_T>(
           reinterpret_cast<utils::f8*>(_param.scales) + K_offset * _param.ldsb + N_offset, srcptr, cachestep, dstptr,
           cachestep, M, N);
@@ -151,7 +152,7 @@ class CompFp32BlockEpilogue {
         assert(0);
       }
     }
-    return JblasNotSupport;
+    return BTLA_CODE::NotSupport;
   }
 };
 
@@ -162,12 +163,12 @@ struct ParamDequantInt32ToFp32 {
   float* scalesA;
   float* scalesB;
 };
-template <JBLAS_ISA ISA_T>
+template <BTLA_ISA ISA_T>
 class DequantInt32ToFp32 {
  public:
   using Param = ParamDequantInt32ToFp32;
-  JBLAS_CODE forward(const int32_t* cacheptr, const int cachestep, const int M_offset, const int N_offset, const int M,
-                     const int N, const Param& _param, void* tmpcache, size_t cachesize) {
+  BTLA_CODE forward(const int32_t* cacheptr, const int cachestep, const int M_offset, const int N_offset, const int M,
+                    const int N, const Param& _param, void* tmpcache, size_t cachesize) {
     auto COffset = M_offset * _param.ldc + N_offset;
     auto cptr = _param.C + COffset;
     return kernel::wrapper::DequanS32Fp32::template forward<ISA_T>(cacheptr, cachestep, cptr, _param.ldc, M, N,
@@ -178,61 +179,61 @@ class DequantInt32ToFp32 {
 
 struct ParamCompInt8BlockEpilogue {
   void* scalesB;
-  JBLAS_DTYPE scaleBdtype;
+  BTLA_DTYPE scaleBdtype;
   int ldsb;
   float* scalesA;
   int ldsa;
   // optional if A asym
   uint8_t* zpA = nullptr;
   void* reduceB = nullptr;
-  JBLAS_DTYPE reduceBdtype = JBLAS_DTYPE::F32;
+  BTLA_DTYPE reduceBdtype = BTLA_DTYPE::F32;
   // optional if B asym
   int8_t* zpB = nullptr;
   float* reduceA = nullptr;
   int K = 1;
 };
-template <JBLAS_ISA ISA_T>
+template <BTLA_ISA ISA_T>
 class CompInt8BlockEpilogue {
  public:
   using Param = ParamCompInt8BlockEpilogue;
-  JBLAS_CODE forward(const int32_t* srcptr, float* dstptr, const int cachestep, const int M_offset, const int N_offset,
-                     const int K_offset, const int M, const int N, const Param& _param, void* tmpcache,
-                     size_t cachesize) {
-    JBLAS_CODE ret = JblasNotSupport;
+  BTLA_CODE forward(const int32_t* srcptr, float* dstptr, const int cachestep, const int M_offset, const int N_offset,
+                    const int K_offset, const int M, const int N, const Param& _param, void* tmpcache,
+                    size_t cachesize) {
+    BTLA_CODE ret = BTLA_CODE::NotSupport;
     float* scab = nullptr;
     size_t ScaleBTmpSize = N * sizeof(float);
     size_t ReduceBTmpSize = N * sizeof(float);
     assert(cachesize >= (ScaleBTmpSize + ReduceBTmpSize));
-    if (_param.scaleBdtype == JBLAS_DTYPE::BF16) {
+    if (_param.scaleBdtype == BTLA_DTYPE::BF16) {
       auto scache = reinterpret_cast<float*>(tmpcache);
       ret = kernel::wrapper::Memcpy2DBf16CvtFp32::template forward<ISA_T>(
           reinterpret_cast<utils::bf16*>(_param.scalesB) + N_offset + K_offset * _param.ldsb, scache, 1, N, N, N,
           false);
-      assert(ret == JblasSuccess);
+      assert(ret == BTLA_CODE::Success);
       scab = scache;
-    } else if (_param.scaleBdtype == JBLAS_DTYPE::F32) {
+    } else if (_param.scaleBdtype == BTLA_DTYPE::F32) {
       scab = reinterpret_cast<float*>(_param.scalesB) + N_offset + K_offset * _param.ldsb;
     }
     float* redb = nullptr;
     if (_param.reduceB) {
-      if (_param.reduceBdtype == JBLAS_DTYPE::BF16) {
+      if (_param.reduceBdtype == BTLA_DTYPE::BF16) {
         auto rcache = reinterpret_cast<float*>(reinterpret_cast<char*>(tmpcache) + ScaleBTmpSize);
         ret = kernel::wrapper::Memcpy2DBf16CvtFp32::template forward<ISA_T>(
             reinterpret_cast<utils::bf16*>(_param.reduceB) + N_offset + K_offset * _param.ldsb, rcache, 1, N, N, N,
             false);
-        assert(ret == JblasSuccess);
+        assert(ret == BTLA_CODE::Success);
         redb = rcache;
-      } else if (_param.reduceBdtype == JBLAS_DTYPE::F32) {
+      } else if (_param.reduceBdtype == BTLA_DTYPE::F32) {
         redb = reinterpret_cast<float*>(_param.reduceB) + N_offset + K_offset * _param.ldsb;
       }
     }
     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);
+    assert(ret == BTLA_CODE::Success);
     ret = kernel::wrapper::AccumulateFp32::template forward<ISA_T>(reinterpret_cast<const float*>(srcptr), cachestep,
                                                                    dstptr, cachestep, M, N);
-    assert(ret == JblasSuccess);
+    assert(ret == BTLA_CODE::Success);
 
     if (_param.zpA == nullptr) {
       if (_param.zpB == nullptr) {
@@ -273,18 +274,18 @@ struct ParamZpDequantInt32ToFp32 {
   float* reduceA = nullptr;
   int K = 1;
 };
-template <JBLAS_ISA ISA_T>
+template <BTLA_ISA ISA_T>
 class ZpDequantInt32ToFp32 {
  public:
   using Param = ParamZpDequantInt32ToFp32;
-  JBLAS_CODE forward(const int32_t* cacheptr, const int cachestep, const int M_offset, const int N_offset, const int M,
-                     const int N, const Param& _param, void* tmpcache, size_t cachesize) {
+  BTLA_CODE forward(const int32_t* cacheptr, const int cachestep, const int M_offset, const int N_offset, const int M,
+                    const int N, const Param& _param, void* tmpcache, size_t cachesize) {
     auto COffset = M_offset * _param.ldc + N_offset;
     auto cptr = _param.C + COffset;
     auto ret = kernel::wrapper::DequanS32Fp32::template forward<ISA_T>(cacheptr, cachestep, cptr, _param.ldc, M, N,
                                                                        _param.scalesA + M_offset * _param.ldsa,
                                                                        _param.ldsa, _param.scalesB + N_offset);
-    if (ret != JblasSuccess) {
+    if (ret != BTLA_CODE::Success) {
       return ret;
     }
     if (_param.zpA == nullptr && _param.zpB == nullptr) {
@@ -314,12 +315,12 @@ struct ParamAlphaBetaProcessS32U8 {
   float scaleAcc, scaleC;
   int zpC;
 };
-template <JBLAS_ISA ISA_T>
+template <BTLA_ISA ISA_T>
 class AlphaBetaProcessS32U8 {
  public:
   using Param = ParamAlphaBetaProcessS32U8;
-  JBLAS_CODE forward(const int32_t* cacheptr, const int cachestep, const int M_offset, const int N_offset, const int M,
-                     const int N, const Param& _param, void* tmpcache, size_t cachesize) {
+  BTLA_CODE forward(const int32_t* cacheptr, const int cachestep, const int M_offset, const int N_offset, const int M,
+                    const int N, const Param& _param, void* tmpcache, size_t cachesize) {
     auto COffset = M_offset * _param.ldc + N_offset;
     auto cptr = _param.C + COffset;
     return kernel::wrapper::QuanOutS32U32::template forward<ISA_T>(_param.alpha, cacheptr, cachestep, cptr, _param.ldc,
@@ -329,4 +330,4 @@ class AlphaBetaProcessS32U8 {
 
 }  // namespace gemm
 }  // namespace epilogue
-}  // namespace jblas
+}  // namespace bestla
diff --git a/bestla/jblas/jit_blas_gemm.h b/bestla/bestla/bestla_gemm.h
similarity index 98%
rename from bestla/jblas/jit_blas_gemm.h
rename to bestla/bestla/bestla_gemm.h
index add580da3..6829f1d0c 100644
--- a/bestla/jblas/jit_blas_gemm.h
+++ b/bestla/bestla/bestla_gemm.h
@@ -14,13 +14,13 @@
 #pragma once
 #include <array>
 
-#include "jit_blas_utils.h"
-#include "jit_base.h"
+#include "bestla_utils.h"
+#include "bestla_jit.h"
 
-namespace jblas {
+namespace bestla {
 namespace gemm {
 enum class CompType : uint16_t {
-  // base type, too many bits if reuse JBLAS_DTYPE
+  // base type, too many bits if reuse BTLA_DTYPE
   tFP32 = 0,
   tBF16 = 1,
   tFP16 = 2,
@@ -87,7 +87,7 @@ class CoreAttr {
 
   static inline uint64_t get_mask_val(uint64_t raw, uint64_t mask, uint64_t shift) { return (raw & mask) >> shift; }
 
-  static constexpr uint64_t make_core_id(int NTile, int PackRow, CompType CompType, JBLAS_ISA ISA) {
+  static constexpr uint64_t make_core_id(int NTile, int PackRow, CompType CompType, BTLA_ISA ISA) {
     return (static_cast<uint64_t>(NTile) << NTILE_SHIFT) | (static_cast<uint64_t>(PackRow) << PACKROW_SHIFT) |
            (static_cast<uint64_t>(CompType) << COMP_SHIFT) | (static_cast<uint64_t>(ISA) << ISA_SHIFT);
   }
@@ -114,7 +114,7 @@ class CoreAttr {
     return size_t(4 / packrow);
   }
 
-  static inline JBLAS_ISA get_ISA(uint64_t id) { return static_cast<JBLAS_ISA>(get_mask_val(id, ISA_MASK, ISA_SHIFT)); }
+  static inline BTLA_ISA get_ISA(uint64_t id) { return static_cast<BTLA_ISA>(get_mask_val(id, ISA_MASK, ISA_SHIFT)); }
 
   static inline CompType get_comp(uint64_t id) {
     return static_cast<CompType>(get_mask_val(id, COMP_MASK, COMP_SHIFT));
@@ -124,7 +124,7 @@ class CoreAttr {
 namespace code {
 
 template <int _NTILE, int _MTILE = 0>
-class Avx2N8P1 : protected jblas::xbyak::JitAvx2 {
+class Avx2N8P1 : protected bestla::xbyak::JitAvx2 {
  public:
   static int constexpr RegLen = 8, PackRow = 1;
   static_assert(_NTILE % RegLen == 0);
@@ -133,7 +133,7 @@ class Avx2N8P1 : protected jblas::xbyak::JitAvx2 {
   static_assert(NRegs * MRegs <= RegCount - 1);
   static int constexpr NTILE = RegLen * NRegs, MTILE = MRegs, KTILE = 1;
   static int constexpr KUNROLL = 2;
-  static auto constexpr ISA = JBLAS_ISA::JblasAVX2;
+  static auto constexpr ISA = BTLA_ISA::AVX2;
   static auto constexpr COMPUTE = CompType::COMP_FP32;
   typedef float AType;
   typedef float BType;
@@ -344,7 +344,7 @@ class Avx2N8P1 : protected jblas::xbyak::JitAvx2 {
 };
 
 template <int _NTILE, int _MTILE = 0>
-class Avx512fN16P1 : protected jblas::xbyak::JitAvx512f {
+class Avx512fN16P1 : protected bestla::xbyak::JitAvx512f {
  public:
   static int constexpr RegLen = 16, PackRow = 1;
   static_assert(_NTILE % RegLen == 0);
@@ -353,7 +353,7 @@ class Avx512fN16P1 : protected jblas::xbyak::JitAvx512f {
   static_assert(NRegs * MRegs <= RegCount - 1);
   static int constexpr NTILE = RegLen * NRegs, MTILE = MRegs, KTILE = 1;
   static int constexpr KUNROLL = 2;
-  static auto constexpr ISA = JBLAS_ISA::JblasAVX512F;
+  static auto constexpr ISA = BTLA_ISA::AVX512F;
   static auto constexpr COMPUTE = CompType::COMP_FP32;
   typedef float AType;
   typedef float BType;
@@ -564,7 +564,7 @@ class Avx512fN16P1 : protected jblas::xbyak::JitAvx512f {
 };
 
 template <int _NTILE, int _MTILE = 0>
-class Avx512fp16N32P1 : protected jblas::xbyak::JitAvx512_fp16 {
+class Avx512fp16N32P1 : protected bestla::xbyak::JitAvx512_fp16 {
  public:
   static int constexpr RegLen = 32, PackRow = 1;
   static_assert(_NTILE % RegLen == 0);
@@ -573,7 +573,7 @@ class Avx512fp16N32P1 : protected jblas::xbyak::JitAvx512_fp16 {
   static_assert(NRegs * MRegs <= RegCount - 1);
   static int constexpr NTILE = RegLen * NRegs, MTILE = MRegs, KTILE = 1;
   static int constexpr KUNROLL = 2;
-  static auto constexpr ISA = JBLAS_ISA::JblasAVX512_FP16;
+  static auto constexpr ISA = BTLA_ISA::AVX512_FP16;
   static auto constexpr COMPUTE = CompType::COMP_FP16_FP16;
   typedef utils::fp16 AType;
   typedef utils::fp16 BType;
@@ -784,7 +784,7 @@ class Avx512fp16N32P1 : protected jblas::xbyak::JitAvx512_fp16 {
 };
 
 template <int _NTILE, int _MTILE = 0>
-class Avx512bf16N16P2 : protected jblas::xbyak::JitAvx512_bf16 {
+class Avx512bf16N16P2 : protected bestla::xbyak::JitAvx512_bf16 {
  public:
   static int constexpr RegLen = 16, PackRow = 2;
   static_assert(_NTILE % RegLen == 0);
@@ -793,7 +793,7 @@ class Avx512bf16N16P2 : protected jblas::xbyak::JitAvx512_bf16 {
   static_assert(NRegs * MRegs <= RegCount - 1);
   static int constexpr NTILE = RegLen * NRegs, MTILE = MRegs, KTILE = 2;
   static int constexpr KUNROLL = 2;
-  static auto constexpr ISA = JBLAS_ISA::JblasAVX512_BF16;
+  static auto constexpr ISA = BTLA_ISA::AVX512_BF16;
   static auto constexpr COMPUTE = CompType::COMP_BF16_FP32;
   typedef utils::bf16 AType;
   typedef utils::bf16 BType;
@@ -1004,7 +1004,7 @@ class Avx512bf16N16P2 : protected jblas::xbyak::JitAvx512_bf16 {
 };
 
 template <int _NTILE, int _MTILE = 0>
-class Avx512vnniN16P4 : protected jblas::xbyak::JitAvx512vnni {
+class Avx512vnniN16P4 : protected bestla::xbyak::JitAvx512vnni {
  public:
   static int constexpr RegLen = 16, PackRow = 4;
   static_assert(_NTILE % RegLen == 0);
@@ -1013,7 +1013,7 @@ class Avx512vnniN16P4 : protected jblas::xbyak::JitAvx512vnni {
   static_assert(NRegs * MRegs <= RegCount - 1);
   static int constexpr NTILE = RegLen * NRegs, MTILE = MRegs, KTILE = 4;
   static int constexpr KUNROLL = 2;
-  static auto constexpr ISA = JBLAS_ISA::JblasAVX512_VNNI;
+  static auto constexpr ISA = BTLA_ISA::AVX512_VNNI;
   static auto constexpr COMPUTE = CompType::COMP_INT8_US_INT32;
   typedef uint8_t AType;
   typedef int8_t BType;
@@ -1223,7 +1223,7 @@ class Avx512vnniN16P4 : protected jblas::xbyak::JitAvx512vnni {
 };
 
 template <int _NTILE, int _MTILE = 0>
-class AvxvnniN8P4 : protected jblas::xbyak::JitAvxvnni {
+class AvxvnniN8P4 : protected bestla::xbyak::JitAvxvnni {
  public:
   static int constexpr RegLen = 8, PackRow = 4;
   static_assert(_NTILE % RegLen == 0);
@@ -1232,7 +1232,7 @@ class AvxvnniN8P4 : protected jblas::xbyak::JitAvxvnni {
   static_assert(NRegs * MRegs <= RegCount - 1);
   static int constexpr NTILE = RegLen * NRegs, MTILE = MRegs, KTILE = 4;
   static int constexpr KUNROLL = 2;
-  static auto constexpr ISA = JBLAS_ISA::JblasAVX_VNNI;
+  static auto constexpr ISA = BTLA_ISA::AVX_VNNI;
   static auto constexpr COMPUTE = CompType::COMP_INT8_US_INT32;
   typedef uint8_t AType;
   typedef int8_t BType;
@@ -1443,7 +1443,7 @@ class AvxvnniN8P4 : protected jblas::xbyak::JitAvxvnni {
 };
 
 template <int _NTILE, int _MTILE = 0>
-class Amxbf16N16P2 : protected jblas::xbyak::JitAmxbf16 {
+class Amxbf16N16P2 : protected bestla::xbyak::JitAmxbf16 {
  public:
   static int constexpr RegLen = 16, PackRow = 2;
   static_assert(_NTILE % RegLen == 0);
@@ -1453,7 +1453,7 @@ class Amxbf16N16P2 : protected jblas::xbyak::JitAmxbf16 {
   static_assert(NRegs * MRegs + 2 <= TileCount);
   static int constexpr NTILE = RegLen * NRegs, MTILE = MRegs * RegLen, KTILE = 32;
   static int constexpr KUNROLL = 2;
-  static auto constexpr ISA = JBLAS_ISA::JblasAMX_BF16;
+  static auto constexpr ISA = BTLA_ISA::AMX_BF16;
   static auto constexpr COMPUTE = CompType::COMP_BF16_FP32;
   typedef utils::bf16 AType;
   typedef utils::bf16 BType;
@@ -1706,7 +1706,7 @@ class Amxbf16N16P2 : protected jblas::xbyak::JitAmxbf16 {
 };
 
 template <typename AT, typename BT, int _NTILE, int _MTILE = 0>
-class Amxint8N16P4 : protected jblas::xbyak::JitAmxint8 {
+class Amxint8N16P4 : protected bestla::xbyak::JitAmxint8 {
  public:
   static int constexpr RegLen = 16, PackRow = 4;
   static_assert(_NTILE % RegLen == 0);
@@ -1716,7 +1716,7 @@ class Amxint8N16P4 : protected jblas::xbyak::JitAmxint8 {
   static_assert(NRegs * MRegs + 2 <= TileCount);
   static int constexpr NTILE = RegLen * NRegs, MTILE = MRegs * RegLen, KTILE = 64;
   static int constexpr KUNROLL = 2;
-  static auto constexpr ISA = JBLAS_ISA::JblasAMX_INT8;
+  static auto constexpr ISA = BTLA_ISA::AMX_INT8;
   static auto constexpr COMPUTE =
       (std::is_same_v<AT, int8_t>
            ? std::is_same_v<BT, int8_t> ? CompType::COMP_INT8_SS_INT32 : CompType::COMP_INT8_SU_INT32
@@ -1978,7 +1978,7 @@ using Amxint8N16P4US = Amxint8N16P4<uint8_t, int8_t, N, M>;
 template <int N, int M>
 using Amxint8N16P4SS = Amxint8N16P4<int8_t, int8_t, N, M>;
 
-class AmxConfigure : protected jblas::xbyak::JitAmxtile {
+class AmxConfigure : protected xbyak::JitAmxtile {
  public:
   typedef long long (*func_t)(tileconfig_t*);
 
@@ -2003,7 +2003,7 @@ 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 {
+class Avx512fN16P1 : protected bestla::xbyak::JitAvx512f {
  public:
   static int constexpr RegLen = 16, PackRow = 1;
   static_assert(_NTILE % RegLen == 0);
@@ -2012,7 +2012,7 @@ class Avx512fN16P1 : protected jblas::xbyak::JitAvx512f {
   static_assert(NRegs * MRegs <= RegCount - 1);
   static int constexpr NTILE = RegLen * NRegs, MTILE = MRegs, KTILE = 1;
   static int constexpr KUNROLL = 2;
-  static auto constexpr ISA = JBLAS_ISA::JblasAVX512F;
+  static auto constexpr ISA = BTLA_ISA::AVX512F;
   static auto constexpr COMPUTE = CompType::COMP_FP32;
   typedef float AType;
   typedef float BType;
@@ -2223,7 +2223,7 @@ class Avx512fN16P1 : protected jblas::xbyak::JitAvx512f {
 };
 
 template <int _NTILE, int _MTILE = 0>
-class Avx512vnniN16P4 : protected jblas::xbyak::JitAvx512vnni {
+class Avx512vnniN16P4 : protected bestla::xbyak::JitAvx512vnni {
  public:
   static int constexpr RegLen = 16, PackRow = 4;
   static_assert(_NTILE % RegLen == 0);
@@ -2232,7 +2232,7 @@ class Avx512vnniN16P4 : protected jblas::xbyak::JitAvx512vnni {
   static_assert(NRegs * MRegs <= RegCount - 1);
   static int constexpr NTILE = RegLen * NRegs, MTILE = MRegs, KTILE = 4;
   static int constexpr KUNROLL = 2;
-  static auto constexpr ISA = JBLAS_ISA::JblasAVX512_VNNI;
+  static auto constexpr ISA = BTLA_ISA::AVX512_VNNI;
   static auto constexpr COMPUTE = CompType::COMP_INT8_US_FP32;
   typedef uint8_t AType;
   typedef int8_t BType;
@@ -2521,7 +2521,7 @@ class Avx512vnniN16P4 : protected jblas::xbyak::JitAvx512vnni {
 };
 
 template <int _NTILE, int _MTILE = 0>
-class AvxvnniN8P4 : protected jblas::xbyak::JitAvxvnni {
+class AvxvnniN8P4 : protected bestla::xbyak::JitAvxvnni {
  public:
   static int constexpr RegLen = 8, PackRow = 4;
   static_assert(_NTILE % RegLen == 0);
@@ -2530,7 +2530,7 @@ class AvxvnniN8P4 : protected jblas::xbyak::JitAvxvnni {
   static_assert(NRegs * MRegs <= RegCount - 3);
   static int constexpr NTILE = RegLen * NRegs, MTILE = MRegs, KTILE = 4;
   static int constexpr KUNROLL = 2;
-  static auto constexpr ISA = JBLAS_ISA::JblasAVX_VNNI;
+  static auto constexpr ISA = BTLA_ISA::AVX_VNNI;
   static auto constexpr COMPUTE = CompType::COMP_INT8_US_FP32;
   typedef uint8_t AType;
   typedef int8_t BType;
@@ -2865,7 +2865,7 @@ class AvxvnniN8P4 : protected jblas::xbyak::JitAvxvnni {
 };
 
 template <typename AT, typename BT, int _NTILE, int _MTILE = 0>
-class Amxint8N16P4 : protected jblas::xbyak::JitAmxint8 {
+class Amxint8N16P4 : protected bestla::xbyak::JitAmxint8 {
  public:
   static int constexpr RegLen = 16, PackRow = 4;
   static_assert(_NTILE % RegLen == 0);
@@ -2875,7 +2875,7 @@ class Amxint8N16P4 : protected jblas::xbyak::JitAmxint8 {
   static_assert(NRegs * MRegs + 2 <= TileCount);
   static int constexpr NTILE = RegLen * NRegs, MTILE = MRegs * RegLen, KTILE = 64;
   static int constexpr KUNROLL = 2;
-  static auto constexpr ISA = JBLAS_ISA::JblasAMX_INT8;
+  static auto constexpr ISA = BTLA_ISA::AMX_INT8;
   static auto constexpr COMPUTE = (std::is_same_v<AT, int8_t> ? std::is_same_v<BT, int8_t> ? CompType::COMP_INT8_SS_FP32
                                                                                            : CompType::COMP_INT8_SU_FP32
                                    : std::is_same_v<BT, int8_t> ? CompType::COMP_INT8_US_FP32
@@ -3541,4 +3541,4 @@ class ICoreRowNAmxint8SSKBlock : public CoreCodeBaseAMX<code::kblock::Amxint8N16
   }
 };
 }  // namespace gemm
-}  // namespace jblas
+}  // namespace bestla
diff --git a/bestla/jblas/jit_base.h b/bestla/bestla/bestla_jit.h
similarity index 99%
rename from bestla/jblas/jit_base.h
rename to bestla/bestla/bestla_jit.h
index 143adb771..d1b76467b 100644
--- a/bestla/jblas/jit_base.h
+++ b/bestla/bestla/bestla_jit.h
@@ -21,7 +21,7 @@
 
 #define OFFSET(field) offsetof(params, field)
 
-namespace jblas {
+namespace bestla {
 
 namespace xbyak {
 class JitBase : protected Xbyak::CodeGenerator {
@@ -300,4 +300,4 @@ inline void JitAmxint8::_tdpb<uint8_t, uint8_t>(const Xbyak::Tmm& x1, const Xbya
   tdpbuud(x1, x2, x3);
 }
 }  // namespace xbyak
-}  // namespace jblas
+}  // namespace bestla
diff --git a/bestla/jblas/jit_blas_parallel.h b/bestla/bestla/bestla_parallel.h
similarity index 99%
rename from bestla/jblas/jit_blas_parallel.h
rename to bestla/bestla/bestla_parallel.h
index 5e6b3b650..56078d6d3 100644
--- a/bestla/jblas/jit_blas_parallel.h
+++ b/bestla/bestla/bestla_parallel.h
@@ -18,10 +18,10 @@
 #ifdef _OPENMP
 #include <omp.h>
 #endif
-#include "jit_blas_utils.h"
-#include "jit_blas_device.h"
+#include "bestla_utils.h"
+#include "bestla_device.h"
 
-namespace jblas {
+namespace bestla {
 namespace parallel {
 struct Config2D {
   int threads;
@@ -698,4 +698,4 @@ void GemmRunWithA(Launch_T& launcher, const typename Launch_T::Param& args, para
 }
 
 }  // namespace parallel
-}  // namespace jblas
+}  // namespace bestla
diff --git a/bestla/jblas/jit_blas_prologue_a.h b/bestla/bestla/bestla_prologue_a.h
similarity index 76%
rename from bestla/jblas/jit_blas_prologue_a.h
rename to bestla/bestla/bestla_prologue_a.h
index 8cb2b69bd..677e42203 100644
--- a/bestla/jblas/jit_blas_prologue_a.h
+++ b/bestla/bestla/bestla_prologue_a.h
@@ -17,15 +17,15 @@
 #include <cassert>
 #include <type_traits>
 
-#include "jit_blas.h"
-#include "jit_blas_device.h"
-#include "jit_blas_gemm.h"
-#include "jit_blas_parallel.h"
-#include "jit_blas_storage.h"
-#include "jit_blas_utils.h"
+#include "bestla.h"
+#include "bestla_device.h"
+#include "bestla_gemm.h"
+#include "bestla_parallel.h"
+#include "bestla_storage.h"
+#include "bestla_utils.h"
 #include "kernel_wrapper.h"
 
-namespace jblas {
+namespace bestla {
 namespace prologue_a {
 namespace gemm {
 
@@ -34,14 +34,14 @@ struct ParamActivationBase {
   const AType* A;
   int lda;
 };
-template <class _GemmCore_T, JBLAS_ISA ISA_T>
+template <class _GemmCore_T, BTLA_ISA ISA_T>
 class ActivationBase {
  public:
   using AType = typename _GemmCore_T::AType;
   using SRCType = AType;
   using Param = ParamActivationBase<AType>;
-  JBLAS_CODE getActivation(AType** dstptr, int* dststep, const Param& _param, int m_size, int k_size, int m_offset,
-                           int k_offset, void* tmpcache, size_t cachesize) {
+  BTLA_CODE getActivation(AType** dstptr, int* dststep, const Param& _param, int m_size, int k_size, int m_offset,
+                          int k_offset, void* tmpcache, size_t cachesize) {
     auto aptr = const_cast<AType*>(_param.A) + m_offset * _param.lda + k_offset;
     auto alignedptr = utils::cpu_pointer_align(aptr);
     bool use_rawptr = k_size % _GemmCore_T::KTILE == 0 && m_size >= _GemmCore_T::MTILE;
@@ -49,24 +49,24 @@ class ActivationBase {
     if (use_rawptr) {
       *dstptr = aptr;
       *dststep = _param.lda;
-      return JblasSuccess;
+      return BTLA_CODE::Success;
     } else {
       auto k_pad = utils::padto(k_size, _GemmCore_T::KTILE);
       *dststep = k_pad;
-      return kernel::wrapper::Memcpy2D::forward<JblasNoSIMD, AType, AType>(aptr, *dstptr, m_size, k_size, _param.lda,
-                                                                           k_pad);
+      return kernel::wrapper::Memcpy2D::forward<BTLA_ISA::NoSIMD, AType, AType>(aptr, *dstptr, m_size, k_size,
+                                                                                _param.lda, k_pad);
     }
   }
 };
 
-template <class _GemmCore_T, JBLAS_ISA ISA_T, typename SRC_T>
+template <class _GemmCore_T, BTLA_ISA ISA_T, typename SRC_T>
 class ActivationConverter : public ActivationBase<_GemmCore_T, ISA_T> {
  public:
   using AType = typename _GemmCore_T::AType;
   using SRCType = SRC_T;
   using Param = ParamActivationBase<SRC_T>;
-  JBLAS_CODE getActivation(AType** dstptr, int* dststep, const Param& _param, int m_size, int k_size, int m_offset,
-                           int k_offset, void* tmpcache, size_t cachesize) {
+  BTLA_CODE getActivation(AType** dstptr, int* dststep, const Param& _param, int m_size, int k_size, int m_offset,
+                          int k_offset, void* tmpcache, size_t cachesize) {
     auto aptr = const_cast<SRC_T*>(_param.A);
     auto k_pad = utils::padto(k_size, _GemmCore_T::KTILE);
     *dststep = k_pad;
@@ -88,20 +88,20 @@ class ActivationConverter : public ActivationBase<_GemmCore_T, ISA_T> {
     } else {
       assert(0);
     }
-    return JblasNotSupport;
+    return BTLA_CODE::NotSupport;
   }
 };
 
-template <class _GemmCore_T, JBLAS_ISA ISA_T>
+template <class _GemmCore_T, BTLA_ISA ISA_T>
 using ActivationConverterFp32 = ActivationConverter<_GemmCore_T, ISA_T, float>;
-template <class _GemmCore_T, JBLAS_ISA ISA_T>
+template <class _GemmCore_T, BTLA_ISA ISA_T>
 using ActivationConverterBf16 = ActivationConverter<_GemmCore_T, ISA_T, utils::bf16>;
 
 template <typename AType>
 struct ParamActivationKBlockQuantize : ParamActivationBase<AType> {
   storage::gemm::StorageQuantActivation* quan;
 };
-template <class _GemmCore_T, JBLAS_ISA ISA_T, typename SRC_T>
+template <class _GemmCore_T, BTLA_ISA ISA_T, typename SRC_T>
 class ActivationKBlockQuantize {
  public:
   using AType = typename _GemmCore_T::AType;
@@ -109,8 +109,8 @@ class ActivationKBlockQuantize {
   using QParam = storage::gemm::StorageQuantActivation;
   using SRCType = SRC_T;
   using Param = ParamActivationKBlockQuantize<SRC_T>;
-  using Parallel = jblas::parallel::Scheduler2D;
-  using ThreadProblem = jblas::parallel::ThreadProblem2D;
+  using Parallel = parallel::Scheduler2D;
+  using ThreadProblem = parallel::ThreadProblem2D;
 
   inline Parallel createParallel(int nthreads, const utils::GemmProblem& prbm) {
     return Parallel({
@@ -125,8 +125,8 @@ class ActivationKBlockQuantize {
     QParam tmp;
     int kpad = utils::padto(k, _GemmCore_T::KTILE);
     int mpad = utils::padto(m, _GemmCore_T::MTILE);
-    tmp.resize(mpad, kpad, m, k, kblock == -1 ? kpad : kblock, JBLAS_DTYPE::U8, JBLAS_DTYPE::F32, JBLAS_DTYPE::U8,
-               JBLAS_DTYPE::F32, std::is_same_v<AType, uint8_t>, hasreduce);
+    tmp.resize(mpad, kpad, m, k, kblock == -1 ? kpad : kblock, BTLA_DTYPE::U8, BTLA_DTYPE::F32, BTLA_DTYPE::U8,
+               BTLA_DTYPE::F32, std::is_same_v<AType, uint8_t>, hasreduce);
     return tmp;
   }
 
@@ -153,84 +153,84 @@ class ActivationKBlockQuantize {
     }
   }
 
-  JBLAS_CODE quantize(const Param& _param, int m, int k, jblas::parallel::IThreading* threading) {
+  BTLA_CODE quantize(const Param& _param, int m, int k, parallel::IThreading* threading) {
     auto paral = Parallel({threading->num_threads(), m, k, 1, _param.quan->mBlockSize});
     threading->parallel_for([&](int tidx) {
       parallel::ThreadProblem2D thdp{tidx};
       paral.getIndex(thdp);
       if (thdp.valid) run(_param, thdp);
     });
-    return JblasSuccess;
+    return BTLA_CODE::Success;
   }
 
  public:  // Runtime get by launcher
-  JBLAS_CODE getActivation(AType** dstptr, int* dststep, const Param& _param, int m_size, int k_size, int m_offset,
-                           int k_offset, void* tmpcache, size_t cachesize) {
+  BTLA_CODE getActivation(AType** dstptr, int* dststep, const Param& _param, int m_size, int k_size, int m_offset,
+                          int k_offset, void* tmpcache, size_t cachesize) {
     (void)m_size;
     (void)k_size;
     auto quan = _param.quan;
     auto aptr = quan->template APtr<AType>();
     *dstptr = aptr + m_offset * quan->mKPad + k_offset;
     *dststep = quan->mKPad;
-    return JblasSuccess;
+    return BTLA_CODE::Success;
   }
 
-  JBLAS_CODE getZp(AType** dstptr, int* dststep, const Param& _param, int m_size, int k_size, int m_offset,
-                   int k_offset, void* tmpcache, size_t cachesize) {
+  BTLA_CODE getZp(AType** dstptr, int* dststep, const Param& _param, int m_size, int k_size, int m_offset, int k_offset,
+                  void* tmpcache, size_t cachesize) {
     auto quan = _param.quan;
     auto aptr = quan->template ZPtr<AType>();
     if (aptr == nullptr) {  // optional
       *dstptr = nullptr;
-      return JblasSuccess;
+      return BTLA_CODE::Success;
     }
     int kele = utils::updiv(k_size, quan->mBlockSize);
     *dststep = kele;
     kernel::ref::memcpy2d(aptr + m_offset * quan->CStep() + k_offset / quan->mBlockSize, *dstptr, m_size,
                           kele * sizeof(AType), quan->CStep() * sizeof(AType), kele * sizeof(AType));
-    return JblasSuccess;
+    return BTLA_CODE::Success;
   }
 
-  JBLAS_CODE getScale(float** dstptr, int* dststep, const Param& _param, int m_size, int k_size, int m_offset,
-                      int k_offset, void* tmpcache, size_t cachesize) {
+  BTLA_CODE getScale(float** dstptr, int* dststep, const Param& _param, int m_size, int k_size, int m_offset,
+                     int k_offset, void* tmpcache, size_t cachesize) {
     auto quan = _param.quan;
     auto aptr = quan->template SPtr<float>();
     int kele = utils::updiv(k_size, quan->mBlockSize);
     *dststep = kele;
     kernel::ref::memcpy2d(aptr + m_offset * quan->CStep() + k_offset / quan->mBlockSize, *dstptr, m_size,
                           kele * sizeof(float), quan->CStep() * sizeof(float), kele * sizeof(float));
-    return JblasSuccess;
+    return BTLA_CODE::Success;
   }
 
-  JBLAS_CODE getReduce(float** dstptr, int* dststep, const Param& _param, int m_size, int k_size, int m_offset,
-                       int k_offset, void* tmpcache, size_t cachesize) {
+  BTLA_CODE getReduce(float** dstptr, int* dststep, const Param& _param, int m_size, int k_size, int m_offset,
+                      int k_offset, void* tmpcache, size_t cachesize) {
     auto quan = _param.quan;
     auto aptr = quan->template RPtr<float>();
     int kele = utils::updiv(k_size, quan->mBlockSize);
     *dststep = kele;
     kernel::ref::memcpy2d(aptr + m_offset * quan->CStep() + k_offset / quan->mBlockSize, *dstptr, m_size,
                           kele * sizeof(float), quan->CStep() * sizeof(float), kele * sizeof(float));
-    return JblasSuccess;
+    return BTLA_CODE::Success;
   }
 };
 
-template <class _GemmCore_T, JBLAS_ISA ISA_T>
+template <class _GemmCore_T, BTLA_ISA ISA_T>
 using ActivationF32KBlockQuantize = ActivationKBlockQuantize<_GemmCore_T, ISA_T, float>;
-template <class _GemmCore_T, JBLAS_ISA ISA_T>
+template <class _GemmCore_T, BTLA_ISA ISA_T>
 using ActivationBf16KBlockQuantize = ActivationKBlockQuantize<_GemmCore_T, ISA_T, utils::bf16>;
 
 template <typename AType>
 struct ParamActivationKBlockBase : ParamActivationBase<AType> {
   storage::gemm::StorageReduce* reduce;
 };
-template <class _GemmCore_T, JBLAS_ISA ISA_T, typename SRC_T>
+template <class _GemmCore_T, BTLA_ISA ISA_T, typename SRC_T>
 class ActivationKBlockBase : public ActivationConverter<_GemmCore_T, ISA_T, SRC_T> {
  public:
   using AType = typename _GemmCore_T::AType;
   using SType = storage::gemm::StorageReduce;
   using SRCType = SRC_T;
   using Param = ParamActivationKBlockBase<SRC_T>;
-  using Parallel = jblas::parallel::Scheduler2D;
-  using ThreadProblem = jblas::parallel::ThreadProblem2D;
+  using Parallel = parallel::Scheduler2D;
+  using ThreadProblem = parallel::ThreadProblem2D;
 
   inline Parallel createParallel(int nthreads, const utils::GemmProblem& prbm) {
     return Parallel({
@@ -242,7 +242,7 @@ class ActivationKBlockBase : public ActivationConverter<_GemmCore_T, ISA_T, SRC_
   }
   inline SType createStorage(int m, int k, int kblock) {
     SType tmp;
-    tmp.resize(m, k, kblock == -1 ? k : kblock, JBLAS_DTYPE::F32);
+    tmp.resize(m, k, kblock == -1 ? k : kblock, BTLA_DTYPE::F32);
     return tmp;
   }
 
@@ -255,39 +255,39 @@ class ActivationKBlockBase : public ActivationConverter<_GemmCore_T, ISA_T, SRC_
       auto thdrptr = stor->template RPtr<float>() + blk_offset;
       auto ret = kernel::wrapper::ColBlockReduceSum::template forward<ISA_T, SRC_T>(
           srcptr, _param.lda, thdp.size[0], thdp.size[1], stor->kblock, thdrptr, stor->lda);
-      assert(ret == JblasSuccess);
+      assert(ret == BTLA_CODE::Success);
     }
   }
 
-  JBLAS_CODE reduce(const Param& _param, int m, int k, int kblock, jblas::parallel::IThreading* threading) {
+  BTLA_CODE reduce(const Param& _param, int m, int k, int kblock, parallel::IThreading* threading) {
     auto paral = Parallel({threading->num_threads(), m, k, 1, kblock});
     threading->parallel_for([&](int tidx) {
       parallel::ThreadProblem2D thdp{tidx};
       paral.getIndex(thdp);
       if (thdp.valid) run(_param, thdp);
     });
-    return JblasSuccess;
+    return BTLA_CODE::Success;
   }
 
-  JBLAS_CODE getActivation(AType** dstptr, int* dststep, const Param& _param, int m_size, int k_size, int m_offset,
-                           int k_offset, void* tmpcache, size_t cachesize) {
+  BTLA_CODE getActivation(AType** dstptr, int* dststep, const Param& _param, int m_size, int k_size, int m_offset,
+                          int k_offset, void* tmpcache, size_t cachesize) {
     return ActivationConverter<_GemmCore_T, ISA_T, SRC_T>::getActivation(
         dstptr, dststep, {_param.A, _param.lda}, m_size, k_size, m_offset, k_offset, tmpcache, cachesize);
   }
 
-  JBLAS_CODE getReduce(float** dstptr, int* dststep, const Param& _param, int m_size, int k_size, int m_offset,
-                       int k_offset, void* tmpcache, size_t cachesize) {
+  BTLA_CODE getReduce(float** dstptr, int* dststep, const Param& _param, int m_size, int k_size, int m_offset,
+                      int k_offset, void* tmpcache, size_t cachesize) {
     auto reduce = _param.reduce;
     auto aptr = reduce->template RPtr<float>();
     int kele = utils::updiv(k_size, reduce->kblock);
     *dststep = kele;
     kernel::ref::memcpy2d(aptr + m_offset * reduce->lda + k_offset / reduce->kblock, *dstptr, m_size,
                           kele * sizeof(float), reduce->lda * sizeof(float), kele * sizeof(float));
-    return JblasSuccess;
+    return BTLA_CODE::Success;
   }
 };
 
-template <class _GemmCore_T, JBLAS_ISA ISA_T>
+template <class _GemmCore_T, BTLA_ISA ISA_T>
 using ActivationKBlockBaseF32 = ActivationKBlockBase<_GemmCore_T, ISA_T, float>;
 
 template <typename AType>
@@ -295,7 +295,7 @@ struct ParamShuffleActivationKBlockBase : ParamActivationKBlockBase<AType> {
   int* indices = nullptr;
   storage::gemm::StorageReorderActivation* reordered = nullptr;
 };
-template <class _GemmCore_T, JBLAS_ISA ISA_T, typename SRC_T>
+template <class _GemmCore_T, BTLA_ISA ISA_T, typename SRC_T>
 class ShuffleActivationKBlockBase : public ActivationKBlockBase<_GemmCore_T, ISA_T, SRC_T> {
  public:
   using AType = typename _GemmCore_T::AType;
@@ -303,19 +303,19 @@ class ShuffleActivationKBlockBase : public ActivationKBlockBase<_GemmCore_T, ISA
   using RAType = storage::gemm::StorageReorderActivation;
   using SRCType = SRC_T;
   using Param = ParamShuffleActivationKBlockBase<SRC_T>;
-  using Parallel = jblas::parallel::Scheduler2D;
-  using ThreadProblem = jblas::parallel::ThreadProblem2D;
+  using Parallel = parallel::Scheduler2D;
+  using ThreadProblem = parallel::ThreadProblem2D;
   inline RAType createReorderStorage(int m, int k, int kblock) {
     RAType tmp(_GemmCore_T::ID);
     int kpad = utils::padto(k, _GemmCore_T::KTILE);
     int mpad = utils::padto(m, _GemmCore_T::MTILE);
-    tmp.resize(mpad, kpad, m, k, kblock == -1 ? kpad : kblock, utils::jblas_dtype<SRC_T>);
+    tmp.resize(mpad, kpad, m, k, kblock == -1 ? kpad : kblock, utils::bestla_dtype<SRC_T>);
     return tmp;
   }
 
   inline RedType createReduceStorage(int m, int k, int kblock) {
     RedType tmp;
-    tmp.resize(m, k, kblock == -1 ? k : kblock, JBLAS_DTYPE::F32);
+    tmp.resize(m, k, kblock == -1 ? k : kblock, BTLA_DTYPE::F32);
     return tmp;
   }
 
@@ -337,23 +337,23 @@ class ShuffleActivationKBlockBase : public ActivationKBlockBase<_GemmCore_T, ISA
         auto thdrptr = stor->template RPtr<float>() + blk_offset;
         auto ret = kernel::wrapper::ColBlockReduceSum::template forward<ISA_T, SRC_T>(
             srcptr, _param.lda, thdp.size[0], thdp.size[1], stor->kblock, thdrptr, stor->lda);
-        assert(ret == JblasSuccess);
+        assert(ret == BTLA_CODE::Success);
       }
     }
   }
 
-  JBLAS_CODE preprocess(const Param& _param, int m, int k, int kblock, jblas::parallel::IThreading* threading) {
+  BTLA_CODE preprocess(const Param& _param, int m, int k, int kblock, parallel::IThreading* threading) {
     auto paral = Parallel({threading->num_threads(), m, k, 1, kblock});
     threading->parallel_for([&](int tidx) {
       parallel::ThreadProblem2D thdp{tidx};
       paral.getIndex(thdp);
       run(_param, thdp);
     });
-    return JblasSuccess;
+    return BTLA_CODE::Success;
   }
 
-  JBLAS_CODE getActivation(AType** dstptr, int* dststep, const Param& _param, int m_size, int k_size, int m_offset,
-                           int k_offset, void* tmpcache, size_t cachesize) {
+  BTLA_CODE getActivation(AType** dstptr, int* dststep, const Param& _param, int m_size, int k_size, int m_offset,
+                          int k_offset, void* tmpcache, size_t cachesize) {
     if (_param.indices == nullptr) {
       return ActivationConverter<_GemmCore_T, ISA_T, SRC_T>::getActivation(
           dstptr, dststep, {_param.A, _param.lda}, m_size, k_size, m_offset, k_offset, tmpcache, cachesize);
@@ -365,7 +365,7 @@ class ShuffleActivationKBlockBase : public ActivationKBlockBase<_GemmCore_T, ISA
   }
 };
 
-template <class _GemmCore_T, JBLAS_ISA ISA_T>
+template <class _GemmCore_T, BTLA_ISA ISA_T>
 using ShuffleActivationKBlockBaseF32 = ShuffleActivationKBlockBase<_GemmCore_T, ISA_T, float>;
 
 template <typename AType>
@@ -373,7 +373,7 @@ struct ParamShuffleActivationKBlockQuantize : ParamActivationKBlockQuantize<ATyp
   int* indices = nullptr;
   storage::gemm::StorageReorderActivation* reordered = nullptr;
 };
-template <class _GemmCore_T, JBLAS_ISA ISA_T, typename SRC_T>
+template <class _GemmCore_T, BTLA_ISA ISA_T, typename SRC_T>
 class ShuffleActivationKBlockQuantize : public ActivationKBlockQuantize<_GemmCore_T, ISA_T, SRC_T> {
  public:
   using AType = typename _GemmCore_T::AType;
@@ -382,15 +382,15 @@ class ShuffleActivationKBlockQuantize : public ActivationKBlockQuantize<_GemmCor
   using RAType = storage::gemm::StorageReorderActivation;
   using SRCType = SRC_T;
   using Param = ParamShuffleActivationKBlockQuantize<SRC_T>;
-  using Parallel = jblas::parallel::Scheduler2D;
-  using ThreadProblem = jblas::parallel::ThreadProblem2D;
+  using Parallel = parallel::Scheduler2D;
+  using ThreadProblem = parallel::ThreadProblem2D;
 
   inline QParam createQuantStorage(int m, int k, int kblock, bool hasreduce) {
     QParam tmp;
     int kpad = utils::padto(k, _GemmCore_T::KTILE);
     int mpad = utils::padto(m, _GemmCore_T::MTILE);
-    tmp.resize(mpad, kpad, m, k, kblock == -1 ? kpad : kblock, JBLAS_DTYPE::U8, JBLAS_DTYPE::F32, JBLAS_DTYPE::U8,
-               JBLAS_DTYPE::F32, std::is_same_v<AType, uint8_t>, hasreduce);
+    tmp.resize(mpad, kpad, m, k, kblock == -1 ? kpad : kblock, BTLA_DTYPE::U8, BTLA_DTYPE::F32, BTLA_DTYPE::U8,
+               BTLA_DTYPE::F32, std::is_same_v<AType, uint8_t>, hasreduce);
     return tmp;
   }
 
@@ -398,11 +398,11 @@ class ShuffleActivationKBlockQuantize : public ActivationKBlockQuantize<_GemmCor
     RAType tmp(_GemmCore_T::ID);
     int kpad = utils::padto(k, _GemmCore_T::KTILE);
     int mpad = utils::padto(m, _GemmCore_T::MTILE);
-    tmp.resize(mpad, kpad, m, k, kblock == -1 ? kpad : kblock, utils::jblas_dtype<SRC_T>);
+    tmp.resize(mpad, kpad, m, k, kblock == -1 ? kpad : kblock, utils::bestla_dtype<SRC_T>);
     return tmp;
   }
 
-  JBLAS_CODE quantize(const Param& _param, int m, int k, jblas::parallel::IThreading* threading) {
+  BTLA_CODE quantize(const Param& _param, int m, int k, parallel::IThreading* threading) {
     auto srcptr = const_cast<SRC_T*>(_param.A);
     if (_param.indices) {
       auto shuffle_src = _param.reordered->template APtr<SRC_T>();
@@ -416,12 +416,12 @@ class ShuffleActivationKBlockQuantize : public ActivationKBlockQuantize<_GemmCor
       srcptr = shuffle_src;
     }
     ActivationKBlockQuantize<_GemmCore_T, ISA_T, SRC_T>::quantize({srcptr, k, _param.quan}, m, k, threading);
-    return JblasSuccess;
+    return BTLA_CODE::Success;
   }
 };
 
-template <class _GemmCore_T, JBLAS_ISA ISA_T>
+template <class _GemmCore_T, BTLA_ISA ISA_T>
 using ShuffleActivationKBlockQuantizeF32 = ShuffleActivationKBlockQuantize<_GemmCore_T, ISA_T, float>;
 }  // namespace gemm
 }  // namespace prologue_a
-}  // namespace jblas
+}  // namespace bestla
diff --git a/bestla/jblas/jit_blas_prologue_b.h b/bestla/bestla/bestla_prologue_b.h
similarity index 80%
rename from bestla/jblas/jit_blas_prologue_b.h
rename to bestla/bestla/bestla_prologue_b.h
index 95371744f..84313000a 100644
--- a/bestla/jblas/jit_blas_prologue_b.h
+++ b/bestla/bestla/bestla_prologue_b.h
@@ -13,23 +13,23 @@
 //  limitations under the License.
 #pragma once
 #include <cassert>
-#include "jblas/jit_blas_utils.h"
-#include "jit_blas_storage.h"
-#include "jit_blas_device.h"
-#include "jit_blas_parallel.h"
+#include "bestla_utils.h"
+#include "bestla_storage.h"
+#include "bestla_device.h"
+#include "bestla_parallel.h"
 #include "kernel_wrapper.h"
 
-namespace jblas {
+namespace bestla {
 namespace prologue_b {
 namespace gemm {
 
-template <typename WT, JBLAS_ISA ISA_T>
+template <typename WT, BTLA_ISA ISA_T>
 static inline void transposeWeight(const int Row, const int Col, const WT* src, const int ld_src, WT* dst,
                                    const int ld_dst, parallel::IThreading* threading) {
-  jblas::parallel::Scheduler2D _para;
+  bestla::parallel::Scheduler2D _para;
   _para.update({threading->num_threads(), Row, Col, 16, 16});
   threading->parallel_for([&](int tidx) {
-    jblas::parallel::ThreadProblem2D thdp{tidx};
+    bestla::parallel::ThreadProblem2D thdp{tidx};
     _para.getIndex(thdp);
     if (thdp.valid) {
       kernel::wrapper::Transpose2D<WT>::template forward<ISA_T>(src + thdp.loc[0] * ld_src + thdp.loc[1],
@@ -45,7 +45,7 @@ struct ParamWeightPack {
   storage::gemm::StoragePackedWeight* packedW;
 };
 
-template <class _GemmCore_T, JBLAS_ISA ISA_T>
+template <class _GemmCore_T, BTLA_ISA ISA_T>
 class WeightPack {
  public:
   using WType = typename _GemmCore_T::BType;
@@ -56,7 +56,7 @@ class WeightPack {
     int KPad = utils::padto(k, _GemmCore_T::KTILE);
     int NPad = utils::padto(n, _GemmCore_T::NTILE);
     StorageType tmp(_GemmCore_T::ID);
-    tmp.resize(NPad, KPad, n, k, utils::jblas_dtype<WType>);
+    tmp.resize(NPad, KPad, n, k, utils::bestla_dtype<WType>);
     return tmp;
   }
 
@@ -88,20 +88,20 @@ class WeightPack {
     using PaddingInterleaveMNWType = kernel::wrapper::PaddingInterleaveMN<_GemmCore_T::NTILE, _GemmCore_T::PACK_ROW>;
     auto ret = PaddingInterleaveMNWType::template forward<ISA_T>(  //
         src, dst, thdp.size[0], thdp.size[1], rowpadded, colpadded, _param.ldb, packedw->mKPad);
-    assert(ret == JblasSuccess);
+    assert(ret == BTLA_CODE::Success);
     (void)ret;
   }
 
-  inline JBLAS_CODE getWeight(WType** dstptr, int* dststep, int k_size, int n_size, int k_offset, int n_offset,
-                              const Param param, void* tmpcache, size_t cachesize) {
+  inline BTLA_CODE getWeight(WType** 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 = param.packedW;
     auto KPad = wptr->mKPad;
     auto bptr = wptr->template WPtr<WType>() + n_offset * KPad + k_offset * _GemmCore_T::NTILE;
-    kernel::wrapper::Memcpy2D::template forward<JblasNoSIMD, WType, WType>(
+    kernel::wrapper::Memcpy2D::template forward<BTLA_ISA::NoSIMD, WType, WType>(
         bptr, *dstptr, n_size / _GemmCore_T::NTILE, _GemmCore_T::NTILE * k_size, _GemmCore_T::NTILE * KPad,
         _GemmCore_T::NTILE * k_size);
     *dststep = k_size;
-    return JblasSuccess;
+    return BTLA_CODE::Success;
   }
 };
 
@@ -109,14 +109,14 @@ struct ParamWeightKBlockNInteger {
   storage::gemm::StorageWeightKBlockNInteger* packedW;
 };
 
-template <class _GemmCore_T, JBLAS_ISA ISA_T>
+template <class _GemmCore_T, BTLA_ISA ISA_T>
 class WeightKBlockNInteger {
  public:
   using StorageWeight = storage::gemm::StorageWeightKBlockNInteger;
   using BType = typename _GemmCore_T::BType;
   using Param = ParamWeightKBlockNInteger;
 
-  static StorageWeight createStorage(int n, int k, int blocksize, JBLAS_DTYPE qtype, JBLAS_DTYPE scat, JBLAS_DTYPE redt,
+  static StorageWeight createStorage(int n, int k, int blocksize, BTLA_DTYPE qtype, BTLA_DTYPE scat, BTLA_DTYPE redt,
                                      bool is_asym) {
     int KPad = utils::padto(k, _GemmCore_T::KTILE);
     int NPad = utils::padto(n, _GemmCore_T::NTILE);
@@ -208,7 +208,7 @@ class WeightKBlockNInteger {
     int rawnk_scale = utils::updiv(K, stor->mBlockSize);
     int nk_scale = utils::updiv(stor->mKPad, stor->mBlockSize);
     parallel::Scheduler2D _para({threading->num_threads(), 1, nk_scale, 1, 1});
-    if (stor->SDtype() == JBLAS_DTYPE::F32) {  // fp32 to fp32 direct copy
+    if (stor->SDtype() == BTLA_DTYPE::F32) {  // fp32 to fp32 direct copy
       threading->parallel_for([&](int tidx) {
         parallel::ThreadProblem2D thdp{tidx};
         _para.getIndex(thdp);
@@ -229,7 +229,7 @@ class WeightKBlockNInteger {
           }
         }
       });
-    } else if (stor->SDtype() == JBLAS_DTYPE::BF16) {
+    } else if (stor->SDtype() == BTLA_DTYPE::BF16) {
       threading->parallel_for([&](int tidx) {
         parallel::ThreadProblem2D thdp{tidx};
         _para.getIndex(thdp);
@@ -254,7 +254,7 @@ class WeightKBlockNInteger {
           }
         }
       });
-    } else if (stor->SDtype() == JBLAS_DTYPE::F8_E8M0) {
+    } else if (stor->SDtype() == BTLA_DTYPE::F8_E8M0) {
       threading->parallel_for([&](int tidx) {
         parallel::ThreadProblem2D thdp{tidx};
         _para.getIndex(thdp);
@@ -304,7 +304,7 @@ class WeightKBlockNInteger {
     int rawnk_scale = utils::updiv(K, stor->mBlockSize);
     int nk_scale = utils::updiv(stor->mKPad, stor->mBlockSize);
     parallel::Scheduler2D _para({threading->num_threads(), 1, nk_scale, 1, 1});
-    if (stor->SDtype() == JBLAS_DTYPE::F32) {  // fp32 to fp32 direct copy
+    if (stor->SDtype() == BTLA_DTYPE::F32) {  // fp32 to fp32 direct copy
       threading->parallel_for([&](int tidx) {
         parallel::ThreadProblem2D thdp{tidx};
         _para.getIndex(thdp);
@@ -322,7 +322,7 @@ class WeightKBlockNInteger {
           }
         }
       });
-    } else if (stor->SDtype() == JBLAS_DTYPE::BF16) {
+    } else if (stor->SDtype() == BTLA_DTYPE::BF16) {
       threading->parallel_for([&](int tidx) {
         parallel::ThreadProblem2D thdp{tidx};
         _para.getIndex(thdp);
@@ -340,7 +340,7 @@ class WeightKBlockNInteger {
           }
         }
       });
-    } else if (stor->SDtype() == JBLAS_DTYPE::F8_E8M0) {
+    } else if (stor->SDtype() == BTLA_DTYPE::F8_E8M0) {
       threading->parallel_for([&](int tidx) {
         parallel::ThreadProblem2D thdp{tidx};
         _para.getIndex(thdp);
@@ -382,8 +382,8 @@ class WeightKBlockNInteger {
   void packQWeight(const int N, const int K, const int8_t* B, const int ldb, const float* scales,
                    const int8_t* zero_points, StorageWeight* stor, parallel::IThreading* threading) {
     setQuantCorrection(N, K, zero_points, scales, stor, threading);
-    if (stor->mDType == JBLAS_DTYPE::S8 || stor->mDType == JBLAS_DTYPE::F8_E4M3 ||
-        stor->mDType == JBLAS_DTYPE::F8_E5M2) {
+    if (stor->mDType == BTLA_DTYPE::S8 || stor->mDType == BTLA_DTYPE::F8_E4M3 ||
+        stor->mDType == BTLA_DTYPE::F8_E5M2) {
       reorderWeight(N, K, B, ldb, stor->WPtr<int8_t>(), threading);
     } else {
       auto reorded = utils::amalloc<int8_t>((size_t)stor->mKPad * stor->mNPad);
@@ -453,10 +453,10 @@ class WeightKBlockNInteger {
     if (stor->HasReduce()) {
       auto deq = utils::amalloc<float>((size_t)stor->mK * stor->mN);
       unpackWeight(stor->mN, stor->mK, stor, deq, stor->mN, threading);
-      if (stor->RDtype() == JBLAS_DTYPE::F32) {
+      if (stor->RDtype() == BTLA_DTYPE::F32) {
         reduce(stor->mN, stor->mK, stor->mBlockSize, deq, stor->mN, stor->template RPtr<float>(), stor->CStep(),
                threading);
-      } else if (stor->RDtype() == JBLAS_DTYPE::BF16) {
+      } else if (stor->RDtype() == BTLA_DTYPE::BF16) {
         reduce(stor->mN, stor->mK, stor->mBlockSize, deq, stor->mN, stor->template RPtr<utils::bf16>(), stor->CStep(),
                threading);
       } else {
@@ -498,14 +498,14 @@ class WeightKBlockNInteger {
             kernel::wrapper::PaddingInterleaveMN<_GemmCore_T::NTILE, _GemmCore_T::PACK_ROW>;
         auto ret = PaddingInterleaveMNWType::template forward<ISA_T>(  //
             src, dst, thdp.size[0], thdp.size[1], rowpadded, colpadded, ldb, KPad);
-        assert(ret == JblasSuccess);
+        assert(ret == BTLA_CODE::Success);
         (void)ret;
       }
     });
   }
 
-  static void compressWeight(const int N, const int K, const int8_t* B, const int ldb, int8_t* dstptr,
-                             JBLAS_DTYPE qtype, parallel::IThreading* threading) {
+  static void compressWeight(const int N, const int K, const int8_t* B, const int ldb, int8_t* dstptr, BTLA_DTYPE qtype,
+                             parallel::IThreading* threading) {
     parallel::Scheduler2D _para({threading->num_threads(), K, N, _GemmCore_T::KTILE, _GemmCore_T::NTILE});
     threading->parallel_for([&](int tidx) {
       parallel::ThreadProblem2D thdp({tidx});
@@ -513,7 +513,7 @@ class WeightKBlockNInteger {
       if (thdp.valid) {
         auto ret = doCompress(B + thdp.loc[0] * ldb + thdp.loc[1], dstptr + thdp.loc[0] * ldb / 2 + thdp.loc[1] / 2,
                               thdp.size[0], thdp.size[1], ldb, ldb, qtype);
-        assert(ret == JblasSuccess);
+        assert(ret == BTLA_CODE::Success);
         (void)ret;
       }
     });
@@ -534,7 +534,7 @@ class WeightKBlockNInteger {
           int rowremain = utils::remainsize(thdp.loc[0] + i, K, KBlock);
           auto ret = RowReduceSum::template forward<ISA_T>(  //
               src + i * ldb, ldb, rowremain, thdp.size[1], dst + i / KBlock * ldr);
-          assert(ret == JblasSuccess);
+          assert(ret == BTLA_CODE::Success);
           (void)ret;
         }
       }
@@ -542,123 +542,123 @@ class WeightKBlockNInteger {
   }
 
  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) {
+  virtual inline BTLA_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) {
     return getFpWeight(dstptr, dststep, k_size, n_size, k_offset, n_offset, _param, tmpcache, cachesize);
   }
 
-  virtual inline JBLAS_CODE getWeight(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) {
+  virtual inline BTLA_CODE getWeight(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) {
     return getFpWeight(dstptr, dststep, k_size, n_size, k_offset, n_offset, _param, tmpcache, cachesize);
   }
 
-  static 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) {
+  static inline BTLA_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 = _param.packedW;
-    if (wptr->mDType == JBLAS_DTYPE::S8) {
+    if (wptr->mDType == BTLA_DTYPE::S8) {
       return getQ8Weight(dstptr, dststep, k_size, n_size, k_offset, n_offset, _param, tmpcache, cachesize);
-    } else if (wptr->mDType == JBLAS_DTYPE::S4_CLIP || wptr->mDType == JBLAS_DTYPE::S4_FULLRANGE) {
+    } else if (wptr->mDType == BTLA_DTYPE::S4_CLIP || wptr->mDType == BTLA_DTYPE::S4_FULLRANGE) {
       return getQ4Weight(dstptr, dststep, k_size, n_size, k_offset, n_offset, _param, tmpcache, cachesize);
     } else {
       assert(0);
     }
-    return JblasNotSupport;
+    return BTLA_CODE::NotSupport;
   }
 
-  static 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) {
+  static inline BTLA_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) {
     return getFpKBlockWeight(dstptr, dststep, k_size, n_size, k_offset, n_offset, _param, tmpcache, cachesize);
   }
 
-  static 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) {
+  static inline BTLA_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) {
     return getFpKBlockWeight(dstptr, dststep, k_size, n_size, k_offset, n_offset, _param, tmpcache, cachesize);
   }
 
-  static inline JBLAS_CODE getKBlockWeight(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) {
+  static inline BTLA_CODE getKBlockWeight(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) {
     return getWeight(dstptr, dststep, k_size, n_size, k_offset, n_offset, _param, tmpcache, cachesize);
   }
 
-  static inline JBLAS_CODE getScale(float** dstptr, int* dststep, int k_size, int n_size, int k_offset, int n_offset,
-                                    const Param& _param, void* tmpcache, size_t cachesize) {
+  static inline BTLA_CODE getScale(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 = _param.packedW;
-    if (wptr->SDtype() == JBLAS_DTYPE::F32) {
+    if (wptr->SDtype() == BTLA_DTYPE::F32) {
       auto aptr = wptr->template SPtr<float>();
-      kernel::wrapper::Memcpy2D::template forward<JblasNoSIMD>(
+      kernel::wrapper::Memcpy2D::template forward<BTLA_ISA::NoSIMD>(
           aptr + k_offset / wptr->mBlockSize * wptr->CStep() + n_offset, *dstptr,
           utils::updiv(k_size, wptr->mBlockSize), n_size, wptr->CStep(), n_size);
       *dststep = n_size;
     }
-    if (wptr->SDtype() == JBLAS_DTYPE::BF16) {
+    if (wptr->SDtype() == BTLA_DTYPE::BF16) {
       auto aptr = wptr->template SPtr<utils::bf16>();
       kernel::wrapper::Memcpy2DBf16CvtFp32::forward<ISA_T>(
           aptr + k_offset / wptr->mBlockSize * wptr->CStep() + n_offset, *dstptr,
           utils::updiv(k_size, wptr->mBlockSize), n_size, wptr->CStep() * 2, n_size * 4, false);
       *dststep = n_size;
     }
-    return JblasSuccess;
+    return BTLA_CODE::Success;
   }
 
-  static inline JBLAS_CODE getReduce(float** dstptr, int* dststep, int k_size, int n_size, int k_offset, int n_offset,
-                                     const Param& _param, void* tmpcache, size_t cachesize) {
+  static inline BTLA_CODE getReduce(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 = _param.packedW;
-    if (wptr->RDtype() == JBLAS_DTYPE::F32) {
+    if (wptr->RDtype() == BTLA_DTYPE::F32) {
       auto aptr = wptr->template RPtr<float>();
-      kernel::wrapper::Memcpy2D::template forward<JblasNoSIMD>(
+      kernel::wrapper::Memcpy2D::template forward<BTLA_ISA::NoSIMD>(
           aptr + k_offset / wptr->mBlockSize * wptr->CStep() + n_offset, *dstptr,
           utils::updiv(k_size, wptr->mBlockSize), n_size, wptr->CStep(), n_size);
       *dststep = n_size;
     }
-    if (wptr->RDtype() == JBLAS_DTYPE::BF16) {
+    if (wptr->RDtype() == BTLA_DTYPE::BF16) {
       auto aptr = wptr->template RPtr<utils::bf16>();
       kernel::wrapper::Memcpy2DBf16CvtFp32::forward<ISA_T>(
           aptr + k_offset / wptr->mBlockSize * wptr->CStep() + n_offset, *dstptr,
           utils::updiv(k_size, wptr->mBlockSize), n_size, wptr->CStep() * 2, n_size * 4, false);
       *dststep = n_size;
     }
-    return JblasSuccess;
+    return BTLA_CODE::Success;
   }
 
  protected:
   template <typename T>
-  static 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) {
+  static inline BTLA_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 = _param.packedW;
     auto NPad = wptr->mNPad;
     auto KPad = wptr->mKPad;
     int constexpr ColSize = _GemmCore_T::NTILE * _GemmCore_T::PACK_ROW;
     for (int i = 0; i < n_size; i += _GemmCore_T::NTILE) {
-      if (wptr->SDtype() == JBLAS_DTYPE::F32) {
+      if (wptr->SDtype() == BTLA_DTYPE::F32) {
         auto sptr = wptr->template SPtr<float>() + n_offset + i;
-        if (wptr->mDType == JBLAS_DTYPE::S4_CLIP) {
-          kernel::wrapper::DecompressKBlockS4S8Fp<T>::template forward<ISA_T, JBLAS_DTYPE::S4_CLIP>(
+        if (wptr->mDType == BTLA_DTYPE::S4_CLIP) {
+          kernel::wrapper::DecompressKBlockS4S8Fp<T>::template forward<ISA_T, BTLA_DTYPE::S4_CLIP>(
               wptr->template WPtr<utils::int4x2>() + n_offset * KPad / 2 + k_offset * _GemmCore_T::NTILE / 2 +
                   i * KPad / 2,
               *dstptr + i * k_size, k_size / _GemmCore_T::PACK_ROW, ColSize, ColSize, ColSize, tmpcache, cachesize);
-        } else if (wptr->mDType == JBLAS_DTYPE::S4_FULLRANGE) {
-          kernel::wrapper::DecompressKBlockS4S8Fp<T>::template forward<ISA_T, JBLAS_DTYPE::S4_FULLRANGE>(
+        } else if (wptr->mDType == BTLA_DTYPE::S4_FULLRANGE) {
+          kernel::wrapper::DecompressKBlockS4S8Fp<T>::template forward<ISA_T, BTLA_DTYPE::S4_FULLRANGE>(
               wptr->template WPtr<utils::int4x2>() + n_offset * KPad / 2 + k_offset * _GemmCore_T::NTILE / 2 +
                   i * KPad / 2,
               *dstptr + i * k_size, k_size / _GemmCore_T::PACK_ROW, ColSize, ColSize, ColSize, tmpcache, cachesize);
-        } else if (wptr->mDType == JBLAS_DTYPE::S8) {
+        } else if (wptr->mDType == BTLA_DTYPE::S8) {
           kernel::wrapper::DecompressKBlockS8S8Fp<T>::template forward<ISA_T>(
               wptr->template WPtr<int8_t>() + n_offset * KPad + k_offset * _GemmCore_T::NTILE + i * KPad,
               *dstptr + i * k_size, k_size / _GemmCore_T::PACK_ROW, ColSize, ColSize, ColSize, tmpcache, cachesize);
         }
-      } else if (wptr->SDtype() == JBLAS_DTYPE::BF16) {
+      } else if (wptr->SDtype() == BTLA_DTYPE::BF16) {
         auto sptr = wptr->template SPtr<utils::bf16>() + n_offset + i;
-        if (wptr->mDType == JBLAS_DTYPE::S4_CLIP) {
-          kernel::wrapper::DecompressKBlockS4S8Fp<T>::template forward<ISA_T, JBLAS_DTYPE::S4_CLIP>(
+        if (wptr->mDType == BTLA_DTYPE::S4_CLIP) {
+          kernel::wrapper::DecompressKBlockS4S8Fp<T>::template forward<ISA_T, BTLA_DTYPE::S4_CLIP>(
               wptr->template WPtr<utils::int4x2>() + n_offset * KPad / 2 + k_offset * _GemmCore_T::NTILE / 2 +
                   i * KPad / 2,
               *dstptr + i * k_size, k_size / _GemmCore_T::PACK_ROW, ColSize, ColSize, ColSize, tmpcache, cachesize);
-        } else if (wptr->mDType == JBLAS_DTYPE::S4_FULLRANGE) {
-          kernel::wrapper::DecompressKBlockS4S8Fp<T>::template forward<ISA_T, JBLAS_DTYPE::S4_FULLRANGE>(
+        } else if (wptr->mDType == BTLA_DTYPE::S4_FULLRANGE) {
+          kernel::wrapper::DecompressKBlockS4S8Fp<T>::template forward<ISA_T, BTLA_DTYPE::S4_FULLRANGE>(
               wptr->template WPtr<utils::int4x2>() + n_offset * KPad / 2 + k_offset * _GemmCore_T::NTILE / 2 +
                   i * KPad / 2,
               *dstptr + i * k_size, k_size / _GemmCore_T::PACK_ROW, ColSize, ColSize, ColSize, tmpcache, cachesize);
-        } else if (wptr->mDType == JBLAS_DTYPE::S8) {
+        } else if (wptr->mDType == BTLA_DTYPE::S8) {
           kernel::wrapper::DecompressKBlockS8S8Fp<T>::template forward<ISA_T>(
               wptr->template WPtr<int8_t>() + n_offset * KPad + k_offset * _GemmCore_T::NTILE + i * KPad,
               *dstptr + i * k_size, k_size / _GemmCore_T::PACK_ROW, ColSize, ColSize, ColSize, tmpcache, cachesize);
@@ -666,37 +666,37 @@ class WeightKBlockNInteger {
       }
     }
     *dststep = k_size;
-    return JblasSuccess;
+    return BTLA_CODE::Success;
   }
 
   template <typename _T>
-  static 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) {
+  static inline BTLA_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 = _param.packedW;
     auto NPad = wptr->mNPad;
     auto KPad = wptr->mKPad;
     int constexpr ColSize = _GemmCore_T::NTILE * _GemmCore_T::PACK_ROW;
     for (int i = 0; i < n_size; i += _GemmCore_T::NTILE) {
       auto zptr = wptr->template ZPtr<int8_t>();
-      if (wptr->SDtype() == JBLAS_DTYPE::F32) {
+      if (wptr->SDtype() == BTLA_DTYPE::F32) {
         auto sptr = wptr->template SPtr<float>() + n_offset + i;
-        if (wptr->mDType == JBLAS_DTYPE::S4_CLIP) {
+        if (wptr->mDType == BTLA_DTYPE::S4_CLIP) {
           kernel::wrapper::DecompressKBlockS4Fp<_T, _GemmCore_T::PACK_ROW>::template forward<ISA_T, float,
-                                                                                             JBLAS_DTYPE::S4_CLIP>(
+                                                                                             BTLA_DTYPE::S4_CLIP>(
               wptr->template WPtr<utils::int4x2>() + n_offset * KPad / 2 + k_offset * _GemmCore_T::NTILE / 2 +
                   i * KPad / 2,
               *dstptr + i * k_size, k_size / _GemmCore_T::PACK_ROW, ColSize, ColSize, ColSize, sptr,
               zptr != nullptr ? zptr + n_offset + i : nullptr, k_offset / _GemmCore_T::PACK_ROW,
               wptr->mBlockSize / _GemmCore_T::PACK_ROW, NPad, tmpcache, cachesize);
-        } else if (wptr->mDType == JBLAS_DTYPE::S4_FULLRANGE) {
+        } else if (wptr->mDType == BTLA_DTYPE::S4_FULLRANGE) {
           kernel::wrapper::DecompressKBlockS4Fp<_T, _GemmCore_T::PACK_ROW>::template forward<ISA_T, float,
-                                                                                             JBLAS_DTYPE::S4_FULLRANGE>(
+                                                                                             BTLA_DTYPE::S4_FULLRANGE>(
               wptr->template WPtr<utils::int4x2>() + n_offset * KPad / 2 + k_offset * _GemmCore_T::NTILE / 2 +
                   i * KPad / 2,
               *dstptr + i * k_size, k_size / _GemmCore_T::PACK_ROW, ColSize, ColSize, ColSize, sptr,
               zptr != nullptr ? zptr + n_offset + i : nullptr, k_offset / _GemmCore_T::PACK_ROW,
               wptr->mBlockSize / _GemmCore_T::PACK_ROW, NPad, tmpcache, cachesize);
-        } else if (wptr->mDType == JBLAS_DTYPE::S8) {
+        } else if (wptr->mDType == BTLA_DTYPE::S8) {
           kernel::wrapper::DecompressKBlockS8Fp<_T, _GemmCore_T::PACK_ROW>::template forward<ISA_T, float>(
               wptr->template WPtr<int8_t>() + n_offset * KPad + k_offset * _GemmCore_T::NTILE + i * KPad,
               *dstptr + i * k_size, k_size / _GemmCore_T::PACK_ROW, ColSize, ColSize, ColSize, sptr,
@@ -705,25 +705,25 @@ class WeightKBlockNInteger {
         } else {
           assert(0);
         }
-      } else if (wptr->SDtype() == JBLAS_DTYPE::BF16) {
+      } else if (wptr->SDtype() == BTLA_DTYPE::BF16) {
         auto sptr = wptr->template SPtr<utils::bf16>() + n_offset + i;
-        if (wptr->mDType == JBLAS_DTYPE::S4_CLIP) {
+        if (wptr->mDType == BTLA_DTYPE::S4_CLIP) {
           kernel::wrapper::DecompressKBlockS4Fp<_T, _GemmCore_T::PACK_ROW>::template forward<ISA_T, utils::bf16,
-                                                                                             JBLAS_DTYPE::S4_CLIP>(
+                                                                                             BTLA_DTYPE::S4_CLIP>(
               wptr->template WPtr<utils::int4x2>() + n_offset * KPad / 2 + k_offset * _GemmCore_T::NTILE / 2 +
                   i * KPad / 2,
               *dstptr + i * k_size, k_size / _GemmCore_T::PACK_ROW, ColSize, ColSize, ColSize, sptr,
               zptr != nullptr ? zptr + n_offset + i : nullptr, k_offset / _GemmCore_T::PACK_ROW,
               wptr->mBlockSize / _GemmCore_T::PACK_ROW, NPad, tmpcache, cachesize);
-        } else if (wptr->mDType == JBLAS_DTYPE::S4_FULLRANGE) {
+        } else if (wptr->mDType == BTLA_DTYPE::S4_FULLRANGE) {
           kernel::wrapper::DecompressKBlockS4Fp<_T, _GemmCore_T::PACK_ROW>::template forward<ISA_T, utils::bf16,
-                                                                                             JBLAS_DTYPE::S4_FULLRANGE>(
+                                                                                             BTLA_DTYPE::S4_FULLRANGE>(
               wptr->template WPtr<utils::int4x2>() + n_offset * KPad / 2 + k_offset * _GemmCore_T::NTILE / 2 +
                   i * KPad / 2,
               *dstptr + i * k_size, k_size / _GemmCore_T::PACK_ROW, ColSize, ColSize, ColSize, sptr,
               zptr != nullptr ? zptr + n_offset + i : nullptr, k_offset / _GemmCore_T::PACK_ROW,
               wptr->mBlockSize / _GemmCore_T::PACK_ROW, NPad, tmpcache, cachesize);
-        } else if (wptr->mDType == JBLAS_DTYPE::S8) {
+        } else if (wptr->mDType == BTLA_DTYPE::S8) {
           kernel::wrapper::DecompressKBlockS8Fp<_T, _GemmCore_T::PACK_ROW>::template forward<ISA_T, utils::bf16>(
               wptr->template WPtr<int8_t>() + n_offset * KPad + k_offset * _GemmCore_T::NTILE + i * KPad,
               *dstptr + i * k_size, k_size / _GemmCore_T::PACK_ROW, ColSize, ColSize, ColSize, sptr,
@@ -735,69 +735,69 @@ class WeightKBlockNInteger {
       }
     }
     *dststep = k_size;
-    return JblasSuccess;
+    return BTLA_CODE::Success;
   }
 
-  static inline JBLAS_CODE getQ8Weight(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) {
+  static inline BTLA_CODE getQ8Weight(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 = _param.packedW;
     auto KPad = wptr->mKPad;
     auto bptr = wptr->template WPtr<int8_t>() + n_offset * KPad + k_offset * _GemmCore_T::NTILE;
-    kernel::wrapper::Memcpy2D::template forward<JblasNoSIMD, int8_t, int8_t>(
+    kernel::wrapper::Memcpy2D::template forward<BTLA_ISA::NoSIMD, int8_t, int8_t>(
         bptr, *dstptr, n_size / _GemmCore_T::NTILE, _GemmCore_T::NTILE * k_size, _GemmCore_T::NTILE * KPad,
         _GemmCore_T::NTILE * k_size);
     *dststep = k_size;
-    return JblasSuccess;
+    return BTLA_CODE::Success;
   }
 
-  static inline JBLAS_CODE getQ4Weight(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) {
+  static inline BTLA_CODE getQ4Weight(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 = _param.packedW;
     auto KPad = wptr->mKPad;
     auto bptr = wptr->template WPtr<utils::int4x2>() + n_offset * KPad / 2 + k_offset * _GemmCore_T::NTILE / 2;
     int constexpr ColSize = _GemmCore_T::NTILE * _GemmCore_T::PACK_ROW;
     for (int i = 0; i < n_size; i += _GemmCore_T::NTILE) {
-      if (wptr->mDType == JBLAS_DTYPE::S4_CLIP) {
-        kernel::wrapper::DecompressKBlockS4S8::template forward<ISA_T, JBLAS_DTYPE::S4_CLIP>(
+      if (wptr->mDType == BTLA_DTYPE::S4_CLIP) {
+        kernel::wrapper::DecompressKBlockS4S8::template forward<ISA_T, BTLA_DTYPE::S4_CLIP>(
             bptr + i * KPad / 2, *dstptr + i * k_size, k_size / _GemmCore_T::PACK_ROW, ColSize, ColSize, ColSize);
-      } else if (wptr->mDType == JBLAS_DTYPE::S4_FULLRANGE) {
-        kernel::wrapper::DecompressKBlockS4S8::template forward<ISA_T, JBLAS_DTYPE::S4_FULLRANGE>(
+      } else if (wptr->mDType == BTLA_DTYPE::S4_FULLRANGE) {
+        kernel::wrapper::DecompressKBlockS4S8::template forward<ISA_T, BTLA_DTYPE::S4_FULLRANGE>(
             bptr + i * KPad / 2, *dstptr + i * k_size, k_size / _GemmCore_T::PACK_ROW, ColSize, ColSize, ColSize);
       }
     }
     *dststep = k_size;
-    return JblasSuccess;
+    return BTLA_CODE::Success;
   }
 
   virtual inline void quantRowBlock(const float* srcptr, int8_t* dstptr, int row, int col, int ld_src, int ld_dst,
                                     float* scales, int8_t* zero_points, void* stor) {
     auto ptr = reinterpret_cast<StorageWeight*>(stor);
     auto quant_dtype = ptr->mDType;
-    if (quant_dtype == JBLAS_DTYPE::S8) {
-      kernel::wrapper::QuantizeSignIntRowBlock::forward<ISA_T, JBLAS_DTYPE::S8>(
+    if (quant_dtype == BTLA_DTYPE::S8) {
+      kernel::wrapper::QuantizeSignIntRowBlock::forward<ISA_T, BTLA_DTYPE::S8>(
           srcptr, dstptr, row, col, ld_src, ld_dst, scales, zero_points, ptr->mBlockSize);
-    } else if (quant_dtype == JBLAS_DTYPE::S4_FULLRANGE) {
-      kernel::wrapper::QuantizeSignIntRowBlock::forward<ISA_T, JBLAS_DTYPE::S4_FULLRANGE>(
+    } else if (quant_dtype == BTLA_DTYPE::S4_FULLRANGE) {
+      kernel::wrapper::QuantizeSignIntRowBlock::forward<ISA_T, BTLA_DTYPE::S4_FULLRANGE>(
           srcptr, dstptr, row, col, ld_src, ld_dst, scales, zero_points, ptr->mBlockSize);
-    } else if (quant_dtype == JBLAS_DTYPE::S4_CLIP) {
-      kernel::wrapper::QuantizeSignIntRowBlock::forward<ISA_T, JBLAS_DTYPE::S4_CLIP>(
+    } else if (quant_dtype == BTLA_DTYPE::S4_CLIP) {
+      kernel::wrapper::QuantizeSignIntRowBlock::forward<ISA_T, BTLA_DTYPE::S4_CLIP>(
           srcptr, dstptr, row, col, ld_src, ld_dst, scales, zero_points, ptr->mBlockSize);
     }
   }
 
-  static inline JBLAS_CODE doCompress(const int8_t* srcptr, void* dstptr, int row, int col, int ld_src, int ld_dst,
-                                      JBLAS_DTYPE quant_dtype) {
-    if (quant_dtype == JBLAS_DTYPE::S4_CLIP || quant_dtype == JBLAS_DTYPE::S4_FULLRANGE) {
+  static inline BTLA_CODE doCompress(const int8_t* srcptr, void* dstptr, int row, int col, int ld_src, int ld_dst,
+                                     BTLA_DTYPE quant_dtype) {
+    if (quant_dtype == BTLA_DTYPE::S4_CLIP || quant_dtype == BTLA_DTYPE::S4_FULLRANGE) {
       return kernel::wrapper::CompressS8S4<_GemmCore_T::NTILE>::template forward<ISA_T>(
           srcptr, reinterpret_cast<utils::int4x2*>(dstptr), row, col, ld_src, ld_dst);
-    } else if (quant_dtype == JBLAS_DTYPE::F4_BNB || quant_dtype == JBLAS_DTYPE::F4_NF4 ||
-               quant_dtype == JBLAS_DTYPE::F4_E2M1) {
+    } else if (quant_dtype == BTLA_DTYPE::F4_BNB || quant_dtype == BTLA_DTYPE::F4_NF4 ||
+               quant_dtype == BTLA_DTYPE::F4_E2M1) {
       return kernel::wrapper::CompressFp4<_GemmCore_T::NTILE>::template forward<ISA_T>(
           srcptr, reinterpret_cast<utils::f4x2*>(dstptr), row, col, ld_src,
           ld_dst);  // ld_dst here not stride
     } else {
       assert(0);
-      return JblasNotSupport;
+      return BTLA_CODE::NotSupport;
     }
   }
 };
@@ -806,13 +806,13 @@ struct ParamWeightKBlockNFloat {
   storage::gemm::StorageWeightKBlockNFloat* packedW;
 };
 
-template <class _GemmCore_T, JBLAS_ISA ISA_T>
+template <class _GemmCore_T, BTLA_ISA ISA_T>
 class WeightKBlockNFloat : public WeightKBlockNInteger<_GemmCore_T, ISA_T> {
  public:
   using Param = ParamWeightKBlockNInteger;  // NFloat storage Param same with NInteger storage.
   using StorageWeight = storage::gemm::StorageWeightKBlockNFloat;
 
-  StorageWeight createStorage(const int N, const int K, int blocksize, JBLAS_DTYPE fT, JBLAS_DTYPE scaT) {
+  StorageWeight createStorage(const int N, const int K, int blocksize, BTLA_DTYPE fT, BTLA_DTYPE scaT) {
     int KPad = utils::padto(K, _GemmCore_T::KTILE);
     int NPad = utils::padto(N, _GemmCore_T::NTILE);
     StorageWeight tmp(_GemmCore_T::ID);
@@ -820,81 +820,81 @@ class WeightKBlockNFloat : public WeightKBlockNInteger<_GemmCore_T, ISA_T> {
     return tmp;
   }
 
-  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) override {
+  inline BTLA_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) override {
     return getFpWeight(dstptr, dststep, k_size, n_size, k_offset, n_offset, _param, tmpcache, cachesize);
   }
 
-  inline JBLAS_CODE getWeight(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) override {
+  inline BTLA_CODE getWeight(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) override {
     return getFpWeight(dstptr, dststep, k_size, n_size, k_offset, n_offset, _param, tmpcache, cachesize);
   }
 
   template <typename _DST_T>
-  inline JBLAS_CODE getFpWeight(_DST_T** dstptr, int* dststep, int k_size, int n_size, int k_offset, int n_offset,
-                                const Param& _param, void* tmpcache, size_t cachesize) {
+  inline BTLA_CODE getFpWeight(_DST_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 = reinterpret_cast<StorageWeight*>(_param.packedW);
     auto NPad = wptr->mNPad;
     auto KPad = wptr->mKPad;
     char* bptr;
-    if (wptr->mDType == JBLAS_DTYPE::F8_E5M2 || wptr->mDType == JBLAS_DTYPE::F8_E4M3) {
+    if (wptr->mDType == BTLA_DTYPE::F8_E5M2 || wptr->mDType == BTLA_DTYPE::F8_E4M3) {
       bptr = wptr->template WPtr<char>() + n_offset * KPad + k_offset * _GemmCore_T::NTILE;
     } else {
       bptr = wptr->template WPtr<char>() + n_offset * KPad / 2 + k_offset * _GemmCore_T::NTILE / 2;
     }
     int constexpr ColSize = _GemmCore_T::NTILE * _GemmCore_T::PACK_ROW;
     for (int i = 0; i < n_size; i += _GemmCore_T::NTILE) {
-      if (wptr->SDtype() == JBLAS_DTYPE::F8_E8M0) {
-        assert(wptr->mDType == JBLAS_DTYPE::F8_E4M3 || wptr->mDType == JBLAS_DTYPE::F8_E5M2);
+      if (wptr->SDtype() == BTLA_DTYPE::F8_E8M0) {
+        assert(wptr->mDType == BTLA_DTYPE::F8_E4M3 || wptr->mDType == BTLA_DTYPE::F8_E5M2);
         auto sptr = wptr->template SPtr<utils::f8>() + n_offset + i;
         kernel::wrapper::DecompressKBlockF8FP<_GemmCore_T::PACK_ROW>::template forward<ISA_T>(
             reinterpret_cast<utils::f8*>(bptr) + i * KPad, *dstptr + i * k_size, k_size / _GemmCore_T::PACK_ROW,
             ColSize, ColSize, ColSize, sptr, k_offset / _GemmCore_T::PACK_ROW, wptr->mBlockSize / _GemmCore_T::PACK_ROW,
             NPad, wptr->mDType);
-      } else if (wptr->SDtype() == JBLAS_DTYPE::F32) {
+      } else if (wptr->SDtype() == BTLA_DTYPE::F32) {
         auto sptr = wptr->template SPtr<float>() + n_offset + i;
         auto f4ptr = reinterpret_cast<utils::f4x2*>(bptr + i * KPad / 2);
         auto fp_ptr = *dstptr + i * k_size;
-        if (wptr->mDType == JBLAS_DTYPE::F8_E4M3 || wptr->mDType == JBLAS_DTYPE::F8_E5M2) {
+        if (wptr->mDType == BTLA_DTYPE::F8_E4M3 || wptr->mDType == BTLA_DTYPE::F8_E5M2) {
           kernel::wrapper::DecompressKBlockF8FP<_GemmCore_T::PACK_ROW>::template forward<ISA_T>(
               reinterpret_cast<utils::f8*>(bptr) + i * KPad, *dstptr + i * k_size, k_size / _GemmCore_T::PACK_ROW,
               ColSize, ColSize, ColSize, sptr, k_offset / _GemmCore_T::PACK_ROW,
               wptr->mBlockSize / _GemmCore_T::PACK_ROW, NPad, wptr->mDType);
-        } else if (wptr->mDType == JBLAS_DTYPE::F4_NF4) {
+        } else if (wptr->mDType == BTLA_DTYPE::F4_NF4) {
           kernel::wrapper::DecompressKBlockF4Fp<_DST_T, _GemmCore_T::PACK_ROW>::template forward<ISA_T, float,
-                                                                                                 JBLAS_DTYPE::F4_NF4>(
+                                                                                                 BTLA_DTYPE::F4_NF4>(
               f4ptr, fp_ptr, k_size / _GemmCore_T::PACK_ROW, ColSize, ColSize, ColSize, sptr,
               k_offset / _GemmCore_T::PACK_ROW, wptr->mBlockSize / _GemmCore_T::PACK_ROW, NPad, tmpcache, cachesize);
-        } else if (wptr->mDType == JBLAS_DTYPE::F4_E2M1) {
+        } else if (wptr->mDType == BTLA_DTYPE::F4_E2M1) {
           kernel::wrapper::DecompressKBlockF4Fp<_DST_T, _GemmCore_T::PACK_ROW>::template forward<ISA_T, float,
-                                                                                                 JBLAS_DTYPE::F4_E2M1>(
+                                                                                                 BTLA_DTYPE::F4_E2M1>(
               f4ptr, fp_ptr, k_size / _GemmCore_T::PACK_ROW, ColSize, ColSize, ColSize, sptr,
               k_offset / _GemmCore_T::PACK_ROW, wptr->mBlockSize / _GemmCore_T::PACK_ROW, NPad, tmpcache, cachesize);
-        } else if (wptr->mDType == JBLAS_DTYPE::F4_BNB) {
+        } else if (wptr->mDType == BTLA_DTYPE::F4_BNB) {
           kernel::wrapper::DecompressKBlockF4Fp<_DST_T, _GemmCore_T::PACK_ROW>::template forward<ISA_T, float,
-                                                                                                 JBLAS_DTYPE::F4_BNB>(
+                                                                                                 BTLA_DTYPE::F4_BNB>(
               f4ptr, fp_ptr, k_size / _GemmCore_T::PACK_ROW, ColSize, ColSize, ColSize, sptr,
               k_offset / _GemmCore_T::PACK_ROW, wptr->mBlockSize / _GemmCore_T::PACK_ROW, NPad, tmpcache, cachesize);
         } else {
           assert(0);
         }
-      } else if (wptr->SDtype() == JBLAS_DTYPE::BF16) {
+      } else if (wptr->SDtype() == BTLA_DTYPE::BF16) {
         auto sptr = wptr->template SPtr<utils::bf16>() + n_offset + i;
         auto f4ptr = reinterpret_cast<utils::f4x2*>(bptr + i * KPad / 2);
         auto fp_ptr = *dstptr + i * k_size;
-        if (wptr->mDType == JBLAS_DTYPE::F4_NF4) {
+        if (wptr->mDType == BTLA_DTYPE::F4_NF4) {
           kernel::wrapper::DecompressKBlockF4Fp<_DST_T, _GemmCore_T::PACK_ROW>::template forward<ISA_T, utils::bf16,
-                                                                                                 JBLAS_DTYPE::F4_NF4>(
+                                                                                                 BTLA_DTYPE::F4_NF4>(
               f4ptr, fp_ptr, k_size / _GemmCore_T::PACK_ROW, ColSize, ColSize, ColSize, sptr,
               k_offset / _GemmCore_T::PACK_ROW, wptr->mBlockSize / _GemmCore_T::PACK_ROW, NPad, tmpcache, cachesize);
-        } else if (wptr->mDType == JBLAS_DTYPE::F4_E2M1) {
+        } else if (wptr->mDType == BTLA_DTYPE::F4_E2M1) {
           kernel::wrapper::DecompressKBlockF4Fp<_DST_T, _GemmCore_T::PACK_ROW>::template forward<ISA_T, utils::bf16,
-                                                                                                 JBLAS_DTYPE::F4_E2M1>(
+                                                                                                 BTLA_DTYPE::F4_E2M1>(
               f4ptr, fp_ptr, k_size / _GemmCore_T::PACK_ROW, ColSize, ColSize, ColSize, sptr,
               k_offset / _GemmCore_T::PACK_ROW, wptr->mBlockSize / _GemmCore_T::PACK_ROW, NPad, tmpcache, cachesize);
-        } else if (wptr->mDType == JBLAS_DTYPE::F4_BNB) {
+        } else if (wptr->mDType == BTLA_DTYPE::F4_BNB) {
           kernel::wrapper::DecompressKBlockF4Fp<_DST_T, _GemmCore_T::PACK_ROW>::template forward<ISA_T, utils::bf16,
-                                                                                                 JBLAS_DTYPE::F4_BNB>(
+                                                                                                 BTLA_DTYPE::F4_BNB>(
               f4ptr, fp_ptr, k_size / _GemmCore_T::PACK_ROW, ColSize, ColSize, ColSize, sptr,
               k_offset / _GemmCore_T::PACK_ROW, wptr->mBlockSize / _GemmCore_T::PACK_ROW, NPad, tmpcache, cachesize);
         } else {
@@ -905,38 +905,38 @@ class WeightKBlockNFloat : public WeightKBlockNInteger<_GemmCore_T, ISA_T> {
       }
     }
     *dststep = k_size;
-    return JblasSuccess;
+    return BTLA_CODE::Success;
   }
 
   template <typename T>
-  static inline JBLAS_CODE getKBlockWeight(T** dstptr, int* dststep, int k_size, int n_size, int k_offset, int n_offset,
-                                           const Param& _param, void* tmpcache, size_t cachesize) {
+  static inline BTLA_CODE getKBlockWeight(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 = reinterpret_cast<StorageWeight*>(_param.packedW);
     auto NPad = wptr->mNPad;
     auto KPad = wptr->mKPad;
     char* bptr;
-    if (wptr->mDType == JBLAS_DTYPE::F8_E4M3 || wptr->mDType == JBLAS_DTYPE::F8_E5M2) {
+    if (wptr->mDType == BTLA_DTYPE::F8_E4M3 || wptr->mDType == BTLA_DTYPE::F8_E5M2) {
       bptr = wptr->template WPtr<char>() + n_offset * KPad + k_offset * _GemmCore_T::NTILE;
     } else {
       bptr = wptr->template WPtr<char>() + n_offset * KPad / 2 + k_offset * _GemmCore_T::NTILE / 2;
     }
     int constexpr ColSize = _GemmCore_T::NTILE * _GemmCore_T::PACK_ROW;
     for (int i = 0; i < n_size; i += _GemmCore_T::NTILE) {
-      if (wptr->mDType == JBLAS_DTYPE::F8_E4M3 || wptr->mDType == JBLAS_DTYPE::F8_E5M2) {
+      if (wptr->mDType == BTLA_DTYPE::F8_E4M3 || wptr->mDType == BTLA_DTYPE::F8_E5M2) {
         kernel::wrapper::DecompressKBlockF8FpNoScale<T>::template forward<ISA_T>(
             reinterpret_cast<utils::f8*>(bptr) + i * KPad, *dstptr + i * k_size, k_size / _GemmCore_T::PACK_ROW,
             ColSize, ColSize, ColSize, tmpcache, cachesize, wptr->mDType);
       } else {
         auto f4ptr = reinterpret_cast<utils::f4x2*>(bptr + i * KPad / 2);
         auto fp_ptr = *dstptr + i * k_size;
-        if (wptr->mDType == JBLAS_DTYPE::F4_NF4) {
-          kernel::wrapper::DecompressKBlockF4FpNoscale<T>::template forward<ISA_T, JBLAS_DTYPE::F4_NF4>(
+        if (wptr->mDType == BTLA_DTYPE::F4_NF4) {
+          kernel::wrapper::DecompressKBlockF4FpNoscale<T>::template forward<ISA_T, BTLA_DTYPE::F4_NF4>(
               f4ptr, fp_ptr, k_size / _GemmCore_T::PACK_ROW, ColSize, ColSize, ColSize, tmpcache, cachesize);
-        } else if (wptr->mDType == JBLAS_DTYPE::F4_E2M1) {
-          kernel::wrapper::DecompressKBlockF4FpNoscale<T>::template forward<ISA_T, JBLAS_DTYPE::F4_E2M1>(
+        } else if (wptr->mDType == BTLA_DTYPE::F4_E2M1) {
+          kernel::wrapper::DecompressKBlockF4FpNoscale<T>::template forward<ISA_T, BTLA_DTYPE::F4_E2M1>(
               f4ptr, fp_ptr, k_size / _GemmCore_T::PACK_ROW, ColSize, ColSize, ColSize, tmpcache, cachesize);
-        } else if (wptr->mDType == JBLAS_DTYPE::F4_BNB) {
-          kernel::wrapper::DecompressKBlockF4FpNoscale<T>::template forward<ISA_T, JBLAS_DTYPE::F4_BNB>(
+        } else if (wptr->mDType == BTLA_DTYPE::F4_BNB) {
+          kernel::wrapper::DecompressKBlockF4FpNoscale<T>::template forward<ISA_T, BTLA_DTYPE::F4_BNB>(
               f4ptr, fp_ptr, k_size / _GemmCore_T::PACK_ROW, ColSize, ColSize, ColSize, tmpcache, cachesize);
         } else {
           assert(0);
@@ -944,7 +944,7 @@ class WeightKBlockNFloat : public WeightKBlockNInteger<_GemmCore_T, ISA_T> {
       }
     }
     *dststep = k_size;
-    return JblasSuccess;
+    return BTLA_CODE::Success;
   }
 
  protected:
@@ -952,20 +952,20 @@ class WeightKBlockNFloat : public WeightKBlockNInteger<_GemmCore_T, ISA_T> {
                      int8_t* zero_points, void* stor) override {
     auto ptr = reinterpret_cast<StorageWeight*>(stor);
     auto quant_dtype = ptr->mDType;
-    if (quant_dtype == JBLAS_DTYPE::F8_E4M3) {
-      kernel::wrapper::QuantizeF8RowBlock::forward<ISA_T, JBLAS_DTYPE::F8_E4M3>(
+    if (quant_dtype == BTLA_DTYPE::F8_E4M3) {
+      kernel::wrapper::QuantizeF8RowBlock::forward<ISA_T, BTLA_DTYPE::F8_E4M3>(
           srcptr, dstptr, row, col, ld_src, ld_dst, scales, ptr->mBlockSize, ptr->SDtype());
-    } else if (quant_dtype == JBLAS_DTYPE::F8_E5M2) {
-      kernel::wrapper::QuantizeF8RowBlock::forward<ISA_T, JBLAS_DTYPE::F8_E5M2>(
+    } else if (quant_dtype == BTLA_DTYPE::F8_E5M2) {
+      kernel::wrapper::QuantizeF8RowBlock::forward<ISA_T, BTLA_DTYPE::F8_E5M2>(
           srcptr, dstptr, row, col, ld_src, ld_dst, scales, ptr->mBlockSize, ptr->SDtype());
-    } else if (quant_dtype == JBLAS_DTYPE::F4_BNB) {
-      kernel::wrapper::QuantizeF4RowBlock::forward<ISA_T, JBLAS_DTYPE::F4_BNB>(srcptr, dstptr, row, col, ld_src, ld_dst,
+    } else if (quant_dtype == BTLA_DTYPE::F4_BNB) {
+      kernel::wrapper::QuantizeF4RowBlock::forward<ISA_T, BTLA_DTYPE::F4_BNB>(srcptr, dstptr, row, col, ld_src, ld_dst,
                                                                                scales, zero_points, ptr->mBlockSize);
-    } else if (quant_dtype == JBLAS_DTYPE::F4_E2M1) {
-      kernel::wrapper::QuantizeF4RowBlock::forward<ISA_T, JBLAS_DTYPE::F4_E2M1>(
+    } else if (quant_dtype == BTLA_DTYPE::F4_E2M1) {
+      kernel::wrapper::QuantizeF4RowBlock::forward<ISA_T, BTLA_DTYPE::F4_E2M1>(
           srcptr, dstptr, row, col, ld_src, ld_dst, scales, zero_points, ptr->mBlockSize);
-    } else if (quant_dtype == JBLAS_DTYPE::F4_NF4) {
-      kernel::wrapper::QuantizeF4RowBlock::forward<ISA_T, JBLAS_DTYPE::F4_NF4>(srcptr, dstptr, row, col, ld_src, ld_dst,
+    } else if (quant_dtype == BTLA_DTYPE::F4_NF4) {
+      kernel::wrapper::QuantizeF4RowBlock::forward<ISA_T, BTLA_DTYPE::F4_NF4>(srcptr, dstptr, row, col, ld_src, ld_dst,
                                                                                scales, zero_points, ptr->mBlockSize);
     } else {
       assert(0);
@@ -974,4 +974,4 @@ class WeightKBlockNFloat : public WeightKBlockNInteger<_GemmCore_T, ISA_T> {
 };
 }  // namespace gemm
 }  // namespace prologue_b
-}  // namespace jblas
+}  // namespace bestla
diff --git a/bestla/jblas/jit_blas_storage.h b/bestla/bestla/bestla_storage.h
similarity index 84%
rename from bestla/jblas/jit_blas_storage.h
rename to bestla/bestla/bestla_storage.h
index e3c49aa4d..5f4993f72 100644
--- a/bestla/jblas/jit_blas_storage.h
+++ b/bestla/bestla/bestla_storage.h
@@ -12,12 +12,11 @@
 //  See the License for the specific language governing permissions and
 //  limitations under the License.
 #pragma once
-#include "jit_base.h"
-#include "jit_blas.h"
-#include "jit_blas_gemm.h"
-#include "jit_blas_utils.h"
+#include "bestla.h"
+#include "bestla_gemm.h"
+#include "bestla_utils.h"
 
-namespace jblas {
+namespace bestla {
 namespace storage {
 
 constexpr size_t Alignment = 64;
@@ -154,7 +153,7 @@ class ObjectQuantCorrection : public ISerialObject {
  public:
   size_t mCSize = 0;
   int mCStep = 0;
-  JBLAS_DTYPE mScaT = JBLAS_DTYPE::F32, mZpT = JBLAS_DTYPE::F32, mRedT = JBLAS_DTYPE::F32;
+  BTLA_DTYPE mScaT = BTLA_DTYPE::F32, mZpT = BTLA_DTYPE::F32, mRedT = BTLA_DTYPE::F32;
   ObjectAlignedBuffer<Alignment> mScaleBuf;
   ObjectOptionalBuffer<Alignment> mZpBuf, mRedBuf;
 
@@ -162,7 +161,7 @@ class ObjectQuantCorrection : public ISerialObject {
  public:
   int mScaEleSize = 0, mZpEleSize = 0, mRedEleSize = 0;
 
-  size_t resize(int Rows, int Step, JBLAS_DTYPE scalet, JBLAS_DTYPE zpt, JBLAS_DTYPE redt, bool _is_asym,
+  size_t resize(int Rows, int Step, BTLA_DTYPE scalet, BTLA_DTYPE zpt, BTLA_DTYPE redt, bool _is_asym,
                 bool _has_reduce) {
     mScaT = scalet;
     mZpT = zpt;
@@ -199,16 +198,16 @@ class ObjectQuantCorrection : public ISerialObject {
   }
   virtual void deserializeBuffer(int8_t*& rptr, bool locate_buf) override {
     if (!locate_buf) {
-      mScaT = utils::deserialize<JBLAS_DTYPE>(rptr);
-      mZpT = utils::deserialize<JBLAS_DTYPE>(rptr);
-      mRedT = utils::deserialize<JBLAS_DTYPE>(rptr);
+      mScaT = utils::deserialize<BTLA_DTYPE>(rptr);
+      mZpT = utils::deserialize<BTLA_DTYPE>(rptr);
+      mRedT = utils::deserialize<BTLA_DTYPE>(rptr);
       updateSize();
       mCStep = utils::deserialize<int>(rptr);
       mCSize = utils::deserialize<size_t>(rptr);
     } else {
-      utils::serialize<JBLAS_DTYPE>(rptr, mScaT);
-      utils::serialize<JBLAS_DTYPE>(rptr, mZpT);
-      utils::serialize<JBLAS_DTYPE>(rptr, mRedT);
+      utils::serialize<BTLA_DTYPE>(rptr, mScaT);
+      utils::serialize<BTLA_DTYPE>(rptr, mZpT);
+      utils::serialize<BTLA_DTYPE>(rptr, mRedT);
       utils::serialize<int>(rptr, mCStep);
       utils::serialize<size_t>(rptr, mCSize);
     }
@@ -219,9 +218,9 @@ class ObjectQuantCorrection : public ISerialObject {
 
  protected:
   inline void updateSize() {
-    mScaEleSize = int(utils::jblas_dtype_size(mScaT));
-    mZpEleSize = int(utils::jblas_dtype_size(mZpT));
-    mRedEleSize = int(utils::jblas_dtype_size(mRedT));
+    mScaEleSize = int(utils::bestla_dtype_size(mScaT));
+    mZpEleSize = int(utils::bestla_dtype_size(mZpT));
+    mRedEleSize = int(utils::bestla_dtype_size(mRedT));
   }
 
   inline constexpr size_t getMiscSize() {
@@ -237,9 +236,9 @@ class ObjectQuantCorrection : public ISerialObject {
 
 class IWeightBase : public storage::ISerializable {
  public:
-  JBLAS_PROLOGUEB_IDS mPrologueID = JBLAS_PROLOGUEB_IDS::Undef;
+  BTLA_PROLOGUEB_IDS mPrologueID = BTLA_PROLOGUEB_IDS::Undef;
   uint64_t mCoreId = 0;
-  JBLAS_DTYPE mDType = JBLAS_DTYPE::F32;
+  BTLA_DTYPE mDType = BTLA_DTYPE::F32;
   int mNPad = 0, mKPad = 0;
   int mN = 0, mK = 0;
 
@@ -249,7 +248,7 @@ class IWeightBase : public storage::ISerializable {
   static constexpr inline size_t offset() { return sizeof(mSize); }
 
  protected:
-  void resize(int NPad, int KPad, int N, int K, JBLAS_DTYPE dtype) {
+  void resize(int NPad, int KPad, int N, int K, BTLA_DTYPE dtype) {
     mNPad = NPad;
     mKPad = KPad;
     mN = N;
@@ -273,21 +272,21 @@ class IWeightBase : public storage::ISerializable {
   virtual void deserializeBuffer(int8_t*& rptr, bool map_buf) {
     ISerializable::deserializeBuffer(rptr, map_buf);
     if (!map_buf) {
-      mPrologueID = utils::deserialize<JBLAS_PROLOGUEB_IDS>(rptr);
+      mPrologueID = utils::deserialize<BTLA_PROLOGUEB_IDS>(rptr);
       mCoreId = utils::deserialize<uint64_t>(rptr);
       mNPad = utils::deserialize<int>(rptr);
       mKPad = utils::deserialize<int>(rptr);
       mN = utils::deserialize<int>(rptr);
       mK = utils::deserialize<int>(rptr);
-      mDType = utils::deserialize<JBLAS_DTYPE>(rptr);
+      mDType = utils::deserialize<BTLA_DTYPE>(rptr);
     } else {
-      utils::serialize<JBLAS_PROLOGUEB_IDS>(rptr, mPrologueID);
+      utils::serialize<BTLA_PROLOGUEB_IDS>(rptr, mPrologueID);
       utils::serialize<uint64_t>(rptr, mCoreId);
       utils::serialize<int>(rptr, mNPad);
       utils::serialize<int>(rptr, mKPad);
       utils::serialize<int>(rptr, mN);
       utils::serialize<int>(rptr, mK);
-      utils::serialize<JBLAS_DTYPE>(rptr, mDType);
+      utils::serialize<BTLA_DTYPE>(rptr, mDType);
     }
   }
 
@@ -308,7 +307,7 @@ class IWeightKBlockBase : public IWeightBase {
  public:
   int mBlockSize = 1;
   IWeightKBlockBase(uint64_t _id) : IWeightBase(_id) {}
-  void resize(int NPad, int KPad, int Block, int N, int K, JBLAS_DTYPE dtype) {
+  void resize(int NPad, int KPad, int Block, int N, int K, BTLA_DTYPE dtype) {
     IWeightBase::resize(NPad, KPad, N, K, dtype);
     mBlockSize = Block;
   }
@@ -341,9 +340,9 @@ class IWeightKBlockBase : public IWeightBase {
 
 class IActivationBase : public storage::ISerializable {
  public:
-  JBLAS_PROLOGUEB_IDS mPrologueID = JBLAS_PROLOGUEB_IDS::Undef;
+  BTLA_PROLOGUEB_IDS mPrologueID = BTLA_PROLOGUEB_IDS::Undef;
   uint64_t mCoreId = 0;
-  JBLAS_DTYPE mDType = JBLAS_DTYPE::F32;
+  BTLA_DTYPE mDType = BTLA_DTYPE::F32;
   int mMPad = 0, mKPad = 0;
   int mM = 0, mK = 0;
 
@@ -353,7 +352,7 @@ class IActivationBase : public storage::ISerializable {
   static constexpr inline size_t offset() { return sizeof(mSize); }
 
  protected:
-  void resize(int NPad, int KPad, int N, int K, JBLAS_DTYPE dtype) {
+  void resize(int NPad, int KPad, int N, int K, BTLA_DTYPE dtype) {
     mMPad = NPad;
     mKPad = KPad;
     mM = N;
@@ -377,21 +376,21 @@ class IActivationBase : public storage::ISerializable {
   virtual void deserializeBuffer(int8_t*& rptr, bool map_buf) {
     ISerializable::deserializeBuffer(rptr, map_buf);
     if (!map_buf) {
-      mPrologueID = utils::deserialize<JBLAS_PROLOGUEB_IDS>(rptr);
+      mPrologueID = utils::deserialize<BTLA_PROLOGUEB_IDS>(rptr);
       mCoreId = utils::deserialize<uint64_t>(rptr);
       mMPad = utils::deserialize<int>(rptr);
       mKPad = utils::deserialize<int>(rptr);
       mM = utils::deserialize<int>(rptr);
       mK = utils::deserialize<int>(rptr);
-      mDType = utils::deserialize<JBLAS_DTYPE>(rptr);
+      mDType = utils::deserialize<BTLA_DTYPE>(rptr);
     } else {
-      utils::serialize<JBLAS_PROLOGUEB_IDS>(rptr, mPrologueID);
+      utils::serialize<BTLA_PROLOGUEB_IDS>(rptr, mPrologueID);
       utils::serialize<uint64_t>(rptr, mCoreId);
       utils::serialize<int>(rptr, mMPad);
       utils::serialize<int>(rptr, mKPad);
       utils::serialize<int>(rptr, mM);
       utils::serialize<int>(rptr, mK);
-      utils::serialize<JBLAS_DTYPE>(rptr, mDType);
+      utils::serialize<BTLA_DTYPE>(rptr, mDType);
     }
   }
 
@@ -412,7 +411,7 @@ class IActivationKBlockBase : public IActivationBase {
  public:
   int mBlockSize = 1;
   IActivationKBlockBase(uint64_t _id) : IActivationBase(_id) {}
-  void resize(int MPad, int KPad, int Block, int N, int K, JBLAS_DTYPE dtype) {
+  void resize(int MPad, int KPad, int Block, int N, int K, BTLA_DTYPE dtype) {
     IActivationBase::resize(MPad, KPad, N, K, dtype);
     mBlockSize = Block;
   }
@@ -446,11 +445,11 @@ class IActivationKBlockBase : public IActivationBase {
 class StoragePackedWeight : public IWeightBase {
  public:
   ObjectAlignedBuffer<Alignment> mWBuf;
-  StoragePackedWeight(uint64_t _id) : IWeightBase(_id) { mPrologueID = JBLAS_PROLOGUEB_IDS::WeightPack; }
+  StoragePackedWeight(uint64_t _id) : IWeightBase(_id) { mPrologueID = BTLA_PROLOGUEB_IDS::WeightPack; }
 
-  size_t resize(int NPad, int KPad, int N, int K, JBLAS_DTYPE dtype) {
+  size_t resize(int NPad, int KPad, int N, int K, BTLA_DTYPE dtype) {
     IWeightBase::resize(NPad, KPad, N, K, dtype);
-    auto bsize = static_cast<size_t>(NPad) * KPad * jblas::utils::jblas_dtype_size(dtype);
+    auto bsize = static_cast<size_t>(NPad) * KPad * utils::bestla_dtype_size(dtype);
     mWBuf.resize(bsize);
     mSize = IWeightBase::getSerializedSize() + mWBuf.getSerializedSize();
     mSize = utils::padto(mSize, Alignment);
@@ -483,12 +482,12 @@ class StorageReduce : public ISerializable {
   using CorrectionType = ObjectQuantCorrection;
   int m = 0, k = 0, lda = 0, kblock = 1;
   ObjectAlignedBuffer<Alignment> mRedBuf;
-  size_t resize(int _m, int _k, int _kblock, JBLAS_DTYPE redt) {
+  size_t resize(int _m, int _k, int _kblock, BTLA_DTYPE redt) {
     kblock = _kblock;
     m = _m;
     k = _k;
     lda = utils::updiv(_k, _kblock);
-    size_t bufsize = static_cast<size_t>(m) * lda * utils::jblas_dtype_size(redt);
+    size_t bufsize = static_cast<size_t>(m) * lda * utils::bestla_dtype_size(redt);
     mRedBuf.resize(bufsize);
     mSize = getSerializedSize();
     mSize = utils::padto(mSize, Alignment);
@@ -555,11 +554,11 @@ class StorageReduce : public ISerializable {
 class StorageReorderActivation : public IActivationKBlockBase {
  public:
   ObjectAlignedBuffer<Alignment> mABuf;
-  StorageReorderActivation(uint64_t _id) : IActivationKBlockBase(_id) { mPrologueID = JBLAS_PROLOGUEB_IDS::WeightPack; }
+  StorageReorderActivation(uint64_t _id) : IActivationKBlockBase(_id) { mPrologueID = BTLA_PROLOGUEB_IDS::WeightPack; }
 
-  size_t resize(int MPad, int KPad, int M, int K, int KBlock, JBLAS_DTYPE dtype) {
+  size_t resize(int MPad, int KPad, int M, int K, int KBlock, BTLA_DTYPE dtype) {
     IActivationKBlockBase::resize(MPad, KPad, KBlock, M, K, dtype);
-    auto bsize = static_cast<size_t>(MPad) * KPad * jblas::utils::jblas_dtype_size(dtype);
+    auto bsize = static_cast<size_t>(MPad) * KPad * utils::bestla_dtype_size(dtype);
     mABuf.resize(bsize);
     mSize = IActivationKBlockBase::getSerializedSize() + mABuf.getSerializedSize();
     mSize = utils::padto(mSize, Alignment);
@@ -593,14 +592,14 @@ class StorageQuantActivation : public IActivationKBlockBase {
   CorrectionType mCorrection;
   ObjectAlignedBuffer<Alignment> mQBuf;
   StorageQuantActivation(uint64_t _id = 0) : IActivationKBlockBase(_id) {
-    mPrologueID = JBLAS_PROLOGUEB_IDS::WeightPack;
+    mPrologueID = BTLA_PROLOGUEB_IDS::WeightPack;
   }
 
-  size_t resize(int _mpad, int _kpad, int _m, int _k, int _kblock, JBLAS_DTYPE buft, JBLAS_DTYPE scalet,
-                JBLAS_DTYPE zpt, JBLAS_DTYPE redt, bool is_asym, bool has_reduce) {
+  size_t resize(int _mpad, int _kpad, int _m, int _k, int _kblock, BTLA_DTYPE buft, BTLA_DTYPE scalet, BTLA_DTYPE zpt,
+                BTLA_DTYPE redt, bool is_asym, bool has_reduce) {
     IActivationKBlockBase::resize(_mpad, _kpad, _kblock, _m, _k, buft);
     mCorrection.resize(_mpad, utils::updiv(_kpad, _kblock), scalet, zpt, redt, is_asym, has_reduce);
-    size_t bufsize = static_cast<size_t>(_mpad) * _kpad * utils::jblas_dtype_size(buft);
+    size_t bufsize = static_cast<size_t>(_mpad) * _kpad * utils::bestla_dtype_size(buft);
     mQBuf.resize(bufsize);
     mSize = getSerializedSize();
     mSize = utils::padto(mSize, Alignment);
@@ -626,9 +625,9 @@ class StorageQuantActivation : public IActivationKBlockBase {
     return mCorrection.mRedBuf.get<QT_T>();
   }
 
-  inline constexpr JBLAS_DTYPE RDtype() { return mCorrection.mRedT; }
-  inline constexpr JBLAS_DTYPE ZDtype() { return mCorrection.mZpT; }
-  inline constexpr JBLAS_DTYPE SDtype() { return mCorrection.mScaT; }
+  inline constexpr BTLA_DTYPE RDtype() { return mCorrection.mRedT; }
+  inline constexpr BTLA_DTYPE ZDtype() { return mCorrection.mZpT; }
+  inline constexpr BTLA_DTYPE SDtype() { return mCorrection.mScaT; }
   inline constexpr bool IsAsym() { return mCorrection.mZpBuf.mNotEmpty; }
   inline constexpr bool HasReduce() { return mCorrection.mRedBuf.mNotEmpty; }
   inline constexpr size_t CSize() { return mCorrection.mCSize; }
@@ -680,20 +679,20 @@ class StorageWeightKBlockNInteger : public IWeightKBlockBase {
   CorrectionType mCorrection;
   ObjectOptionalBuffer<Alignment> mShuffleIndices;
   StorageWeightKBlockNInteger(uint64_t _type) : IWeightKBlockBase(_type) {
-    mPrologueID = JBLAS_PROLOGUEB_IDS::WeightKBlockNInteger;
+    mPrologueID = BTLA_PROLOGUEB_IDS::WeightKBlockNInteger;
   }
 
-  size_t resize(int NPad, int KPad, int Block, int N, int K, JBLAS_DTYPE qtype, JBLAS_DTYPE scalet, JBLAS_DTYPE redt,
+  size_t resize(int NPad, int KPad, int Block, int N, int K, BTLA_DTYPE qtype, BTLA_DTYPE scalet, BTLA_DTYPE redt,
                 bool IsAsym) {
-    JBLAS_DTYPE zpt = JBLAS_DTYPE::S8;
+    BTLA_DTYPE zpt = BTLA_DTYPE::S8;
     InfoType::resize(NPad, KPad, Block, N, K, qtype);
-    auto bits = utils::jblas_dtype_bits(qtype);
+    auto bits = utils::bestla_dtype_bits(qtype);
     auto elesize = static_cast<size_t>(NPad) * KPad;
     auto bytes = utils::updiv(elesize * bits, 8);  // add 3bits, 5btis, 7bits size calculation here
     mQBuf.resize(bytes);
     int nk_scale = utils::updiv(KPad, Block);
-    auto gemm_comp = jblas::gemm::CoreAttr::get_comp(mCoreId);
-    auto is_cint = jblas::gemm::CompTypeHelper::is_integer(gemm_comp);
+    auto gemm_comp = bestla::gemm::CoreAttr::get_comp(mCoreId);
+    auto is_cint = bestla::gemm::CompTypeHelper::is_integer(gemm_comp);
     mCorrection.resize(nk_scale, NPad, scalet, zpt, redt, IsAsym, is_cint);
     update_size();
     return mSize;
@@ -705,9 +704,9 @@ class StorageWeightKBlockNInteger : public IWeightKBlockBase {
     update_size();
   }
 
-  inline constexpr JBLAS_DTYPE RDtype() { return mCorrection.mRedT; }
-  inline constexpr JBLAS_DTYPE ZDtype() { return mCorrection.mZpT; }
-  inline constexpr JBLAS_DTYPE SDtype() { return mCorrection.mScaT; }
+  inline constexpr BTLA_DTYPE RDtype() { return mCorrection.mRedT; }
+  inline constexpr BTLA_DTYPE ZDtype() { return mCorrection.mZpT; }
+  inline constexpr BTLA_DTYPE SDtype() { return mCorrection.mScaT; }
   inline constexpr bool IsAsym() { return mCorrection.mZpBuf.mNotEmpty; }
   inline constexpr bool HasReduce() { return mCorrection.mRedBuf.mNotEmpty; }
   inline constexpr size_t CSize() { return mCorrection.mCSize; }
@@ -771,18 +770,18 @@ class StorageWeightKBlockNInteger : public IWeightKBlockBase {
 class StorageWeightKBlockNFloat : public StorageWeightKBlockNInteger {
  public:
   StorageWeightKBlockNFloat(uint64_t _type) : StorageWeightKBlockNInteger(_type) {
-    mPrologueID = JBLAS_PROLOGUEB_IDS::WeightKBlockNFloat;
+    mPrologueID = BTLA_PROLOGUEB_IDS::WeightKBlockNFloat;
   }
 
-  size_t resize(int NPad, int KPad, int Block, int N, int K, JBLAS_DTYPE ftype, JBLAS_DTYPE scalet) {
+  size_t resize(int NPad, int KPad, int Block, int N, int K, BTLA_DTYPE ftype, BTLA_DTYPE scalet) {
     StorageWeightKBlockNInteger::InfoType::resize(NPad, KPad, Block, N, K, ftype);
-    auto bits = utils::jblas_dtype_bits(ftype);
+    auto bits = utils::bestla_dtype_bits(ftype);
     auto elesize = static_cast<size_t>(NPad) * KPad;
     auto bytes = utils::updiv(elesize * bits, 8);  // add fp6 size calculation here
     StorageWeightKBlockNInteger::mQBuf.resize(bytes);
     int nk_scale = utils::updiv(KPad, Block);
-    StorageWeightKBlockNInteger::mCorrection.resize(nk_scale, NPad, scalet, JBLAS_DTYPE::EleBitsUndef,
-                                                    JBLAS_DTYPE::EleBitsUndef, false, false);
+    StorageWeightKBlockNInteger::mCorrection.resize(nk_scale, NPad, scalet, BTLA_DTYPE::EleBitsUndef,
+                                                    BTLA_DTYPE::EleBitsUndef, false, false);
     mSize = StorageWeightKBlockNInteger::InfoType::getSerializedSize() +
             StorageWeightKBlockNInteger::mQBuf.getSerializedSize() +
             StorageWeightKBlockNInteger::mCorrection.getSerializedSize();
@@ -801,17 +800,17 @@ class PackedWeightParser {
     rptr += IWeightBase::offset();
     int mProID = utils::deserialize<int>(rptr);
     IWeightBase* ptr = NULL;
-    if (mProID >= int(JBLAS_PROLOGUEB_IDS::Begin) && mProID < int(JBLAS_PROLOGUEB_IDS::End)) {
+    if (mProID >= int(BTLA_PROLOGUEB_IDS::Begin) && mProID < int(BTLA_PROLOGUEB_IDS::End)) {
       rptr = reinterpret_cast<int8_t*>(serialized_buf);
-      auto type = static_cast<JBLAS_PROLOGUEB_IDS>(mProID);
+      auto type = static_cast<BTLA_PROLOGUEB_IDS>(mProID);
       switch (type) {
-        case JBLAS_PROLOGUEB_IDS::WeightPack:
+        case BTLA_PROLOGUEB_IDS::WeightPack:
           ptr = new gemm::StoragePackedWeight(0);
           break;
-        case JBLAS_PROLOGUEB_IDS::WeightKBlockNInteger:
+        case BTLA_PROLOGUEB_IDS::WeightKBlockNInteger:
           ptr = new gemm::StorageWeightKBlockNInteger(0);
           break;
-        case JBLAS_PROLOGUEB_IDS::WeightKBlockNFloat:
+        case BTLA_PROLOGUEB_IDS::WeightKBlockNFloat:
           ptr = new gemm::StorageWeightKBlockNFloat(0);
           break;
         default:
@@ -826,4 +825,4 @@ class PackedWeightParser {
 };
 }  // namespace gemm
 }  // namespace storage
-}  // namespace jblas
+}  // namespace bestla
diff --git a/bestla/jblas/jit_blas_utils.h b/bestla/bestla/bestla_utils.h
similarity index 87%
rename from bestla/jblas/jit_blas_utils.h
rename to bestla/bestla/bestla_utils.h
index eed0c3bda..1acdc24a6 100644
--- a/bestla/jblas/jit_blas_utils.h
+++ b/bestla/bestla/bestla_utils.h
@@ -47,7 +47,7 @@
 #define ARCH_REQ_XCOMP_PERM 0x1023
 
 #endif
-#include "jit_blas.h"
+#include "bestla.h"
 
 // As long as the compiler supports the ISA, we will enable it.
 // Only the ISA you use in your project will be compiled.
@@ -72,7 +72,7 @@
 #include <immintrin.h>
 #endif
 
-namespace jblas {
+namespace bestla {
 namespace utils {
 
 template <typename T2, typename T1>
@@ -243,15 +243,15 @@ struct GemmProblem {
 };
 
 template <typename T>
-inline constexpr JBLAS_DTYPE jblas_dtype = std::is_same_v<T, double>        ? JBLAS_DTYPE::F64
-                                           : std::is_same_v<T, float>       ? JBLAS_DTYPE::F32
-                                           : std::is_same_v<T, utils::bf16> ? JBLAS_DTYPE::BF16
-                                           : std::is_same_v<T, utils::fp16> ? JBLAS_DTYPE::F16
-                                           : std::is_same_v<T, int8_t>      ? JBLAS_DTYPE::S8
-                                           : std::is_same_v<T, uint8_t>     ? JBLAS_DTYPE::U8
-                                           : std::is_same_v<T, int>         ? JBLAS_DTYPE::S32
-                                           : std::is_same_v<T, f8>          ? JBLAS_DTYPE::F8_E8M0
-                                                                            : (assert(0), JBLAS_DTYPE::F32);
+inline constexpr BTLA_DTYPE bestla_dtype = std::is_same_v<T, double>        ? BTLA_DTYPE::F64
+                                           : std::is_same_v<T, float>       ? BTLA_DTYPE::F32
+                                           : std::is_same_v<T, utils::bf16> ? BTLA_DTYPE::BF16
+                                           : std::is_same_v<T, utils::fp16> ? BTLA_DTYPE::F16
+                                           : std::is_same_v<T, int8_t>      ? BTLA_DTYPE::S8
+                                           : std::is_same_v<T, uint8_t>     ? BTLA_DTYPE::U8
+                                           : std::is_same_v<T, int>         ? BTLA_DTYPE::S32
+                                           : std::is_same_v<T, f8>          ? BTLA_DTYPE::F8_E8M0
+                                                                            : (assert(0), BTLA_DTYPE::F32);
 template <typename T>
 inline constexpr const char* type_str = std::is_same_v<T, double>    ? "double"
                                         : std::is_same_v<T, float>   ? "float"
@@ -262,75 +262,75 @@ inline constexpr const char* type_str = std::is_same_v<T, double>    ? "double"
                                         : std::is_same_v<T, f8>      ? "f8"  // TODO(zhe): more f8 cases?
                                                                      : (assert(0), "undef");
 
-inline const char* jblas_dtype_str(JBLAS_DTYPE dtype) {
+inline const char* bestla_dtype_str(BTLA_DTYPE dtype) {
   switch (dtype) {
-    case JBLAS_DTYPE::F64:
+    case BTLA_DTYPE::F64:
       return "float64";
-    case JBLAS_DTYPE::F32:
+    case BTLA_DTYPE::F32:
       return "float32";
-    case JBLAS_DTYPE::F16:
+    case BTLA_DTYPE::F16:
       return "float16";
-    case JBLAS_DTYPE::BF16:
+    case BTLA_DTYPE::BF16:
       return "bfloat16";
-    case JBLAS_DTYPE::F8_E4M3:
+    case BTLA_DTYPE::F8_E4M3:
       return "fp8_e4m3";
-    case JBLAS_DTYPE::F8_E5M2:
+    case BTLA_DTYPE::F8_E5M2:
       return "fp8_e5m2";
-    case JBLAS_DTYPE::F8_E3M4:
+    case BTLA_DTYPE::F8_E3M4:
       return "fp8_e3m4";
-    case JBLAS_DTYPE::S8:
+    case BTLA_DTYPE::S8:
       return "signed_int8";
-    case JBLAS_DTYPE::U8:
+    case BTLA_DTYPE::U8:
       return "unsigned_int8";
-    case JBLAS_DTYPE::S4_CLIP:
+    case BTLA_DTYPE::S4_CLIP:
       return "int4_clip";
-    case JBLAS_DTYPE::S4_FULLRANGE:
+    case BTLA_DTYPE::S4_FULLRANGE:
       return "int4_fullrange";
-    case JBLAS_DTYPE::F4_E2M1:
+    case BTLA_DTYPE::F4_E2M1:
       return "fp4_e2m1";
-    case JBLAS_DTYPE::F4_BNB:
+    case BTLA_DTYPE::F4_BNB:
       return "fp4_bitsandbytes";
-    case JBLAS_DTYPE::F4_NF4:
+    case BTLA_DTYPE::F4_NF4:
       return "fp4_nf4";
-    case JBLAS_DTYPE::S32:
+    case BTLA_DTYPE::S32:
       return "signed_int32";
-    case JBLAS_DTYPE::U32:
+    case BTLA_DTYPE::U32:
       return "unsigned_int32";
     default:
       return "ErrType";
   }
 }
 
-template <JBLAS_DTYPE DT>
+template <BTLA_DTYPE DT>
 inline constexpr const char* dtype_str() {
-  return jblas_dtype_str(DT);
+  return bestla_dtype_str(DT);
 }
 
-inline constexpr uint32_t jblas_dtype_get_mask_val(const JBLAS_DTYPE& t, const JBLAS_DTYPE& mask,
-                                                   const JBLAS_DTYPE& shift) {
+inline constexpr uint32_t bestla_dtype_get_mask_val(const BTLA_DTYPE& t, const BTLA_DTYPE& mask,
+                                                    const BTLA_DTYPE& shift) {
   return (static_cast<uint32_t>(t) & static_cast<uint32_t>(mask)) >> static_cast<uint32_t>(shift);
 }
 
-inline constexpr size_t jblas_dtype_bits(const JBLAS_DTYPE t) {
-  return jblas_dtype_get_mask_val(t, JBLAS_DTYPE::EleBitsMask, JBLAS_DTYPE::EleBitsShift);
+inline constexpr size_t bestla_dtype_bits(const BTLA_DTYPE t) {
+  return bestla_dtype_get_mask_val(t, BTLA_DTYPE::EleBitsMask, BTLA_DTYPE::EleBitsShift);
 }
 
-inline constexpr size_t jblas_dtype_type(const JBLAS_DTYPE t) {
-  return jblas_dtype_get_mask_val(t, JBLAS_DTYPE::TypeMask, JBLAS_DTYPE::TypeShift);
+inline constexpr size_t bestla_dtype_type(const BTLA_DTYPE t) {
+  return bestla_dtype_get_mask_val(t, BTLA_DTYPE::TypeMask, BTLA_DTYPE::TypeShift);
 }
 
-inline constexpr size_t jblas_dtype_size(const JBLAS_DTYPE t) {
-  auto bits = jblas_dtype_get_mask_val(t, JBLAS_DTYPE::EleBitsMask, JBLAS_DTYPE::EleBitsShift);
+inline constexpr size_t bestla_dtype_size(const BTLA_DTYPE t) {
+  auto bits = bestla_dtype_get_mask_val(t, BTLA_DTYPE::EleBitsMask, BTLA_DTYPE::EleBitsShift);
   return bits >> 3;  // bits to bytes
 }
 
-inline int jblas_dtype_get_f8_ebits(const JBLAS_DTYPE t) {
+inline int bestla_dtype_get_f8_ebits(const BTLA_DTYPE t) {
   int ret = -1;
   switch (t) {
-    case JBLAS_DTYPE::F8_E4M3:
+    case BTLA_DTYPE::F8_E4M3:
       ret = 4;
       break;
-    case JBLAS_DTYPE::F8_E5M2:
+    case BTLA_DTYPE::F8_E5M2:
       ret = 5;
       break;
     default:
@@ -339,13 +339,13 @@ inline int jblas_dtype_get_f8_ebits(const JBLAS_DTYPE t) {
   return ret;
 }
 
-inline int jblas_dtype_get_f8_quant_mbits(const JBLAS_DTYPE t) {
+inline int bestla_dtype_get_f8_quant_mbits(const BTLA_DTYPE t) {
   int ret = -1;
   switch (t) {
-    case JBLAS_DTYPE::F8_E4M3:
+    case BTLA_DTYPE::F8_E4M3:
       ret = 5;
       break;
-    case JBLAS_DTYPE::F8_E5M2:
+    case BTLA_DTYPE::F8_E5M2:
       ret = 4;
       break;
     default:
@@ -354,11 +354,11 @@ inline int jblas_dtype_get_f8_quant_mbits(const JBLAS_DTYPE t) {
   return ret;
 }
 
-inline float get_mxfp_maxnorm(const JBLAS_DTYPE t, int ebits, int mantissa_bits) {
+inline float get_mxfp_maxnorm(const BTLA_DTYPE t, int ebits, int mantissa_bits) {
   auto emax = std::pow(2, ebits - 1);
-  if (t == JBLAS_DTYPE::F8_E5M2) emax -= 1;
+  if (t == BTLA_DTYPE::F8_E5M2) emax -= 1;
   auto max_norm = std::pow(2, emax);
-  if (t != JBLAS_DTYPE::F8_E4M3) {
+  if (t != BTLA_DTYPE::F8_E4M3) {
     max_norm *= ((std::pow(2, mantissa_bits - 1) - 1) / std::pow(2, mantissa_bits - 2));
   } else {
     max_norm *= 1.75;
@@ -384,16 +384,16 @@ static void request_perm_xtile_data() {
 static void request_perm_xtile_data() {}
 #endif
 
-template <JBLAS_ISA ISA_T>
+template <BTLA_ISA ISA_T>
 class isa_base {
  public:
-  static bool constexpr avx = ISA_T >= JblasAVX;
-  static bool constexpr avx2 = ISA_T >= JblasAVX2;
-  static bool constexpr avx512f = ISA_T >= JblasAVX512F;
-  static bool constexpr avx512_vnni = ISA_T >= JblasAVX512_VNNI;
-  static bool constexpr avx512_fp16 = ISA_T >= JblasAVX512_FP16;
-  static bool constexpr amx_bf16 = ISA_T >= JblasAMX_BF16;
-  static bool constexpr amx_int8 = ISA_T >= JblasAMX_INT8;
+  static bool constexpr avx = ISA_T >= BTLA_ISA::AVX;
+  static bool constexpr avx2 = ISA_T >= BTLA_ISA::AVX2;
+  static bool constexpr avx512f = ISA_T >= BTLA_ISA::AVX512F;
+  static bool constexpr avx512_vnni = ISA_T >= BTLA_ISA::AVX512_VNNI;
+  static bool constexpr avx512_fp16 = ISA_T >= BTLA_ISA::AVX512_FP16;
+  static bool constexpr amx_bf16 = ISA_T >= BTLA_ISA::AMX_BF16;
+  static bool constexpr amx_int8 = ISA_T >= BTLA_ISA::AMX_INT8;
 };
 
 static inline int padto_le(int src, int padding) { return src / padding * padding; }
@@ -680,4 +680,4 @@ static float nf4_dequant_fp32_LUT[] = {0.f,
                                        0.5626170039176941f,
                                        0.7229568362236023f,
                                        1.0f};
-}  // namespace jblas
+}  // namespace bestla
diff --git a/bestla/jblas/jit_blas_wrapper.h b/bestla/bestla/bestla_wrapper.h
similarity index 95%
rename from bestla/jblas/jit_blas_wrapper.h
rename to bestla/bestla/bestla_wrapper.h
index f27a1745a..d300aa03c 100644
--- a/bestla/jblas/jit_blas_wrapper.h
+++ b/bestla/bestla/bestla_wrapper.h
@@ -14,21 +14,21 @@
 #pragma once
 #include <thread>
 
-#include "jit_blas_epilogue.h"
-#include "jit_blas_gemm.h"
-#include "jit_blas_prologue_a.h"
-#include "jit_blas_prologue_b.h"
-#include "jit_blas_utils.h"
+#include "bestla_epilogue.h"
+#include "bestla_gemm.h"
+#include "bestla_prologue_a.h"
+#include "bestla_prologue_b.h"
+#include "bestla_utils.h"
 
-namespace jblas {
+namespace bestla {
 namespace wrapper {
 namespace gemm {
-template <JBLAS_ISA _RT_ISA_T, class _GemmCore_T, template <class _T, JBLAS_ISA> class _PrologueA_T,
-          template <class _T, JBLAS_ISA> class _PrologueB_T, template <JBLAS_ISA> class _Epilogue_T>
+template <BTLA_ISA _RT_ISA_T, class _GemmCore_T, template <class _T, BTLA_ISA> class _PrologueA_T,
+          template <class _T, BTLA_ISA> class _PrologueB_T, template <BTLA_ISA> class _Epilogue_T>
 class LauncherBase {
  public:
   using GemmCore = _GemmCore_T;
-  static constexpr JBLAS_ISA ISA = _RT_ISA_T;
+  static constexpr BTLA_ISA ISA = _RT_ISA_T;
   using PrologueA = _PrologueA_T<GemmCore, _RT_ISA_T>;
   using PrologueB = _PrologueB_T<GemmCore, _RT_ISA_T>;
   using Epilogue = _Epilogue_T<_RT_ISA_T>;
@@ -114,13 +114,13 @@ class LauncherBase {
   }
 };
 
-template <JBLAS_ISA _RT_ISA_T, class _GemmCore_T, template <class _T, JBLAS_ISA> class _PrologueA_T,
-          template <class _T, JBLAS_ISA> class _PrologueB_T, template <JBLAS_ISA> class _BlockEpilogue_T,
-          template <JBLAS_ISA> class _Epilogue_T>
+template <BTLA_ISA _RT_ISA_T, class _GemmCore_T, template <class _T, BTLA_ISA> class _PrologueA_T,
+          template <class _T, BTLA_ISA> class _PrologueB_T, template <BTLA_ISA> class _BlockEpilogue_T,
+          template <BTLA_ISA> class _Epilogue_T>
 class LauncherKBlock {
  public:
   using GemmCore = _GemmCore_T;
-  static constexpr JBLAS_ISA ISA = _RT_ISA_T;
+  static constexpr BTLA_ISA ISA = _RT_ISA_T;
   using PrologueA = _PrologueA_T<GemmCore, _RT_ISA_T>;
   using PrologueB = _PrologueB_T<GemmCore, _RT_ISA_T>;
   using Epilogue = _Epilogue_T<_RT_ISA_T>;
@@ -281,12 +281,12 @@ class LauncherKBlock {
   }
 };
 
-template <JBLAS_ISA _RT_ISA_T, class _GemmCore_T, template <class _T, JBLAS_ISA> class _PrologueA_T,
-          template <class _T, JBLAS_ISA> class _PrologueB_T, template <JBLAS_ISA> class _Epilogue_T>
+template <BTLA_ISA _RT_ISA_T, class _GemmCore_T, template <class _T, BTLA_ISA> class _PrologueA_T,
+          template <class _T, BTLA_ISA> class _PrologueB_T, template <BTLA_ISA> class _Epilogue_T>
 class LauncherIntKBlock {
  public:
   using GemmCore = _GemmCore_T;
-  static constexpr JBLAS_ISA ISA = _RT_ISA_T;
+  static constexpr BTLA_ISA ISA = _RT_ISA_T;
   using PrologueA = _PrologueA_T<GemmCore, _RT_ISA_T>;
   using PrologueB = _PrologueB_T<GemmCore, _RT_ISA_T>;
   using Epilogue = _Epilogue_T<_RT_ISA_T>;
@@ -394,9 +394,8 @@ class LauncherIntKBlock {
         mProA.getScale(&scaleA_cache, &ldsa_cache, _param.paramA, m_remain, k_padded, (blk_m + i + _config.loc[0]),
                        iterk, tmp_, _config.tmpcachesize);
         mGemmCore.forward(aptr_cache, bptr_cache, cptr_cache, zpA_cache, scaleA_cache, ldsa_cache, scaleB_cache,
-                          reduceB_cache, ldsb_cache, m_remain, n_padded, k_padded, KBlock,
-                          acache_step * sizeof(AType), bcache_stride, ccache_stride, iterk, 1.f, tmp_,
-                          _config.tmpcachesize);
+                          reduceB_cache, ldsb_cache, m_remain, n_padded, k_padded, KBlock, acache_step * sizeof(AType),
+                          bcache_stride, ccache_stride, iterk, 1.f, tmp_, _config.tmpcachesize);
       }
     }
     mEpilogue.forward(tmpC, _config.block[1], (_config.loc[0] + blk_m), _config.loc[1] + blk_n, blk_msize, blk_nsize,
@@ -475,4 +474,4 @@ class LauncherIntKBlock {
 };
 }  // namespace gemm
 }  // namespace wrapper
-}  // namespace jblas
+}  // namespace bestla
diff --git a/bestla/jblas/kernel_avx2.h b/bestla/bestla/kernel_avx2.h
similarity index 82%
rename from bestla/jblas/kernel_avx2.h
rename to bestla/bestla/kernel_avx2.h
index 1e9fdf287..c5b66b4bf 100644
--- a/bestla/jblas/kernel_avx2.h
+++ b/bestla/bestla/kernel_avx2.h
@@ -12,13 +12,13 @@
 //  See the License for the specific language governing permissions and
 //  limitations under the License.
 #pragma once
-#include "jblas/jit_blas.h"
+#include "bestla.h"
+#include "bestla_utils.h"
 #include "kernel_ref.h"
-#include "jit_blas_utils.h"
 #if CompileAVX2()
 #include <immintrin.h>
 #endif
-namespace jblas {
+namespace bestla {
 namespace kernel {
 namespace avx2 {
 #if CompileAVX2()
@@ -31,7 +31,7 @@ namespace avx2 {
 static uint8_t shuffle_map[] = {0x00, 0x01, 0x02, 0x03, 0xff, 0xff, 0xff, 0xff,
                                 0x04, 0x05, 0x06, 0x07, 0xff, 0xff, 0xff, 0xff};
 
-template <JBLAS_DTYPE S4_T>
+template <BTLA_DTYPE S4_T>
 static inline __m128i unpack_4bits_sse(void* srcptr) {
   auto shuffle_v = _mm_loadu_si128(reinterpret_cast<__m128i*>(shuffle_map));
   auto raw_data = _mm_loadl_epi64(reinterpret_cast<__m128i*>(srcptr));
@@ -43,7 +43,7 @@ static inline __m128i unpack_4bits_sse(void* srcptr) {
   auto xmm2 = _mm_unpacklo_epi8(xmm0, xmm1);
   auto xmm3 = _mm_unpackhi_epi8(xmm0, xmm1);
   xmm2 = _mm_unpacklo_epi64(xmm2, xmm3);
-  if constexpr (S4_T != JBLAS_DTYPE::S4_FULLRANGE) xmm2 = _mm_slli_epi32(xmm2, 4);
+  if constexpr (S4_T != BTLA_DTYPE::S4_FULLRANGE) xmm2 = _mm_slli_epi32(xmm2, 4);
   return xmm2;
 }
 
@@ -70,10 +70,10 @@ inline __m128i ymm_cvt_fp32_bf16(__m256 vfp32) {
   return ymm_cvtepi32_epi16(_mm256_bsrli_epi128(_mm256_castps_si256(vfp32), 2));
 }
 
-template <JBLAS_DTYPE S4_T>
+template <BTLA_DTYPE S4_T>
 static inline void convert_s4_s8_16_sse(int8_t* dstptr, int8_t* srcptr) {
   auto dst0 = unpack_4bits_sse<S4_T>(srcptr);
-  if constexpr (S4_T == JBLAS_DTYPE::S4_FULLRANGE) {
+  if constexpr (S4_T == BTLA_DTYPE::S4_FULLRANGE) {
     auto s8 = _mm_set1_epi8(8);
     dst0 = _mm_sub_epi8(dst0, s8);
   }
@@ -94,7 +94,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);
+  auto dst0 = unpack_4bits_sse<BTLA_DTYPE::S4_FULLRANGE>(srcptr);
   _mm_storeu_si128(reinterpret_cast<__m128i*>(dstptr), dst0);
 }
 
@@ -112,9 +112,9 @@ static inline void dequant_s8_N_avx2(float* dstptr, int8_t* srcptr, __m256* vsca
   }
 }
 
-static inline JBLAS_CODE alphabeta_f32_f32(const float alpha, const float* srcptr, const int srcstep, const float beta,
-                                           const float* src1ptr, const int src1step, float* dstptr, const int dststep,
-                                           const int M, const int N) {
+static inline BTLA_CODE alphabeta_f32_f32(const float alpha, const float* srcptr, const int srcstep, const float beta,
+                                          const float* src1ptr, const int src1step, float* dstptr, const int dststep,
+                                          const int M, const int N) {
   int constexpr Vlen = 8;
   auto vN = utils::padto_le(N, Vlen);
   auto valpha = _mm256_set1_ps(alpha);
@@ -144,12 +144,12 @@ static inline JBLAS_CODE alphabeta_f32_f32(const float alpha, const float* srcpt
       }
     }
   }
-  return JblasSuccess;
+  return BTLA_CODE::Success;
 }
 
 template <int PACK_ROW, bool WITH_ZP, typename _DST_T>
-JBLAS_CODE dequant_kblock_s8_fp_fwd(int8_t* srcptr, _DST_T* dstptr, int row, int col, int ld_src, int ld_dst,
-                                    float* scales, int8_t* zero_points, int k_offset, int kblock, int NPad) {
+BTLA_CODE dequant_kblock_s8_fp_fwd(int8_t* srcptr, _DST_T* dstptr, int row, int col, int ld_src, int ld_dst,
+                                   float* scales, int8_t* zero_points, int k_offset, int kblock, int NPad) {
   const int Vlen = 8;
   size_t simd_process_num = utils::padto_le(col, Vlen);
   auto packrow4_permute_idx = _mm256_setr_epi32(0, 0, 0, 0, 1, 1, 1, 1);
@@ -185,12 +185,12 @@ JBLAS_CODE dequant_kblock_s8_fp_fwd(int8_t* srcptr, _DST_T* dstptr, int row, int
       dstptr[i * ld_dst + j] = tmp * sptr[j / PACK_ROW];
     }
   }
-  return JblasSuccess;
+  return BTLA_CODE::Success;
 }
 
 template <int PACK_ROW, typename _DST_T>
-static inline JBLAS_CODE dequant_kblock_s8_fp(int8_t* srcptr, _DST_T* dstptr, int row, int col, int ld_src, int ld_dst,
-                                              float* scales, int8_t* zero_points, int k_offset, int kblock, int NPad) {
+static inline BTLA_CODE dequant_kblock_s8_fp(int8_t* srcptr, _DST_T* dstptr, int row, int col, int ld_src, int ld_dst,
+                                             float* scales, int8_t* zero_points, int k_offset, int kblock, int NPad) {
   if (zero_points == nullptr)
     return dequant_kblock_s8_fp_fwd<PACK_ROW, false>(srcptr, dstptr, row, col, ld_src, ld_dst, scales, zero_points,
                                                      k_offset, kblock, NPad);
@@ -200,9 +200,9 @@ static inline JBLAS_CODE dequant_kblock_s8_fp(int8_t* srcptr, _DST_T* dstptr, in
 }
 
 template <typename SCAB_T>
-static inline JBLAS_CODE dequant_s32_fp32(const int32_t* srcptr, const int srcstep, float* dstptr, const int dststep,
-                                          const int row, const int col, const float* scaleA, const int ldsa,
-                                          const SCAB_T* scaleB) {
+static inline BTLA_CODE dequant_s32_fp32(const int32_t* srcptr, const int srcstep, float* dstptr, const int dststep,
+                                         const int row, const int col, const float* scaleA, const int ldsa,
+                                         const SCAB_T* scaleB) {
   int col8 = utils::padto_le(col, 8);
   for (int irow = 0; irow < row; irow++) {
     auto scale = scaleA[irow * ldsa];
@@ -226,11 +226,11 @@ static inline JBLAS_CODE dequant_s32_fp32(const int32_t* srcptr, const int srcst
       dstptr[irow * dststep + icol] = scale * scaleB[icol] * srcptr[irow * srcstep + icol];
     }
   }
-  return JblasSuccess;
+  return BTLA_CODE::Success;
 }
 
-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) {
+static inline BTLA_CODE remove_act_zeropoint_bias(float* accptr, int ldacc, int row, int col, uint8_t* zps,
+                                                  float* scales, int lds, const float* reduce) {
   int constexpr VLen = 8;
   auto col8 = utils::padto_le(col, VLen);
   for (int i = 0; i < row; i++) {
@@ -249,11 +249,11 @@ static inline JBLAS_CODE remove_act_zeropoint_bias(float* accptr, int ldacc, int
       }
     }
   }
-  return JblasSuccess;
+  return BTLA_CODE::Success;
 }
 
-static inline JBLAS_CODE remove_wei_zeropoint_bias(float* accptr, int ldacc, int row, int col, int8_t* zps,
-                                                   float* scales, int lds, const float* reduce) {
+static inline BTLA_CODE remove_wei_zeropoint_bias(float* accptr, int ldacc, int row, int col, int8_t* zps,
+                                                  float* scales, int lds, const float* reduce) {
   int constexpr VLen = 8;
   auto col8 = utils::padto_le(col, VLen);
   const int32_t mask[] = {-1, -1, 0, 0};
@@ -275,12 +275,12 @@ static inline JBLAS_CODE remove_wei_zeropoint_bias(float* accptr, int ldacc, int
       }
     }
   }
-  return JblasSuccess;
+  return BTLA_CODE::Success;
 }
 
-static inline JBLAS_CODE remove_zeropoint_bias(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 BTLA_CODE remove_zeropoint_bias(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) {
   int constexpr VLen = 8;
   auto col8 = utils::padto_le(col, VLen);
   auto vk = _mm256_set1_ps(static_cast<float>(k));
@@ -311,12 +311,12 @@ static inline JBLAS_CODE remove_zeropoint_bias(float* accptr, int ldacc, int row
       }
     }
   }
-  return JblasSuccess;
+  return BTLA_CODE::Success;
 }
 
-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) {
+template <BTLA_DTYPE S4_T>
+static inline BTLA_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(*reinterpret_cast<int*>(&mask));
   if (col == ld_src) {
@@ -328,17 +328,17 @@ static inline JBLAS_CODE decompress_s4_s8(utils::int4x2* srcptr, int8_t* dstptr,
     }
     for (; i < elesize; i += 2) {
       auto tmp = srcptr[i / 2];
-      dstptr[i + 0] = jblas::kernel::ref::get_s8<S4_T>(tmp.x);
-      dstptr[i + 1] = jblas::kernel::ref::get_s8<S4_T>(tmp.y);
+      dstptr[i + 0] = kernel::ref::get_s8<S4_T>(tmp.x);
+      dstptr[i + 1] = kernel::ref::get_s8<S4_T>(tmp.y);
     }
-    return JblasSuccess;
+    return BTLA_CODE::Success;
   }
-  return JblasNotSupport;
+  return BTLA_CODE::NotSupport;
 }
 
-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) {
+template <BTLA_DTYPE S4_T, typename _DST_T>
+inline BTLA_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(*reinterpret_cast<int*>(&mask));
   if (col == ld_src) {
@@ -356,17 +356,17 @@ inline JBLAS_CODE decompress_kblock_s4_s8fp(utils::int4x2* srcptr, _DST_T* dstpt
       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;
+    return BTLA_CODE::Success;
   }
-  return JblasSuccess;
+  return BTLA_CODE::Success;
 }
 
 template <bool WITH_SCALE, typename _DST_T, int _PACK_ROW, typename _S_T>
-inline JBLAS_CODE decompress_kblock_f8_fp(utils::f8* srcptr, _DST_T* dstptr, int row, int col, int ld_src, int ld_dst,
-                                          _S_T* scales, int k_offset, int kblock, int NPad, JBLAS_DTYPE src_f8_type) {
+inline BTLA_CODE decompress_kblock_f8_fp(utils::f8* srcptr, _DST_T* dstptr, int row, int col, int ld_src, int ld_dst,
+                                         _S_T* scales, int k_offset, int kblock, int NPad, BTLA_DTYPE src_f8_type) {
   int align_col = col / 16 * 16;
   int col_tail = col - align_col;
-  auto ebits = utils::jblas_dtype_get_f8_ebits(src_f8_type);
+  auto ebits = utils::bestla_dtype_get_f8_ebits(src_f8_type);
   auto mantissabit = 7 - ebits;
   auto sign_revert_and_mask = _mm256_set1_epi32(0x80000000);
   auto e_revert_and_mask = _mm256_set1_epi32(0x0000007f);
@@ -423,11 +423,11 @@ inline JBLAS_CODE decompress_kblock_f8_fp(utils::f8* srcptr, _DST_T* dstptr, int
       }
     }
   }
-  return JblasSuccess;
+  return BTLA_CODE::Success;
 }
 
 template <typename DST_T>
-inline JBLAS_CODE decompress_kblock_s8_s8fp(int8_t* srcptr, DST_T* dstptr, int row, int col, int ld_src, int ld_dst) {
+inline BTLA_CODE decompress_kblock_s8_s8fp(int8_t* srcptr, DST_T* dstptr, int row, int col, int ld_src, int ld_dst) {
   if (col == ld_src) {
     size_t elesize = (size_t)row * col;
     size_t ele64 = utils::padto_le(elesize, 64);
@@ -443,14 +443,14 @@ inline JBLAS_CODE decompress_kblock_s8_s8fp(int8_t* srcptr, DST_T* dstptr, int r
       auto tmp = srcptr[i];
       dstptr[i] = static_cast<DST_T>(static_cast<float>(tmp));
     }
-    return JblasSuccess;
+    return BTLA_CODE::Success;
   }
-  return JblasNotSupport;
+  return BTLA_CODE::NotSupport;
 }
 
 template <typename SCA_T>
-static inline JBLAS_CODE accum_alphaN_f32_f32(const SCA_T* alpha, const float* srcptr, const int srcstep, float* dstptr,
-                                              const int dststep, const int M, const int N) {
+static inline BTLA_CODE accum_alphaN_f32_f32(const SCA_T* alpha, const float* srcptr, const int srcstep, float* dstptr,
+                                             const int dststep, const int M, const int N) {
   int constexpr Vlen = 8;
   auto vN = utils::padto_le(N, Vlen);
   int j = 0;
@@ -482,20 +482,20 @@ static inline JBLAS_CODE accum_alphaN_f32_f32(const SCA_T* alpha, const float* s
       }
     }
   }
-  return JblasSuccess;
+  return BTLA_CODE::Success;
 }
 
-template <int N, typename _DST_T, JBLAS_DTYPE F4_T>
+template <int N, typename _DST_T, BTLA_DTYPE F4_T>
 static inline void dequant_f4_N(_DST_T* dstptr, int8_t* srcptr, __m256* vscales, __m256i* vzps) {
   static_assert(N % 8 == 0);
   float* LUT;
-  static_assert(F4_T == JBLAS_DTYPE::F4_BNB || F4_T == JBLAS_DTYPE::F4_NF4 || F4_T == JBLAS_DTYPE::F4_E2M1,
+  static_assert(F4_T == BTLA_DTYPE::F4_BNB || F4_T == BTLA_DTYPE::F4_NF4 || F4_T == BTLA_DTYPE::F4_E2M1,
                 "Unsupported F4 type");
-  if constexpr (F4_T == JBLAS_DTYPE::F4_BNB) {
+  if constexpr (F4_T == BTLA_DTYPE::F4_BNB) {
     LUT = fp4_bnb_dequant_fp32_LUT;
-  } else if constexpr (F4_T == JBLAS_DTYPE::F4_NF4) {
+  } else if constexpr (F4_T == BTLA_DTYPE::F4_NF4) {
     LUT = nf4_dequant_fp32_LUT;
-  } else if constexpr (F4_T == JBLAS_DTYPE::F4_E2M1) {
+  } else if constexpr (F4_T == BTLA_DTYPE::F4_E2M1) {
     LUT = fp4_e2m1_dequant_fp32_LUT;
   }
   int constexpr VLoop = N / 8;
@@ -513,17 +513,17 @@ static inline void dequant_f4_N(_DST_T* dstptr, int8_t* srcptr, __m256* vscales,
   }
 }
 
-template <int N, typename _DST_T, JBLAS_DTYPE F4_T>
+template <int N, typename _DST_T, BTLA_DTYPE F4_T>
 static inline void unpack_f4_N(_DST_T* dstptr, int8_t* srcptr) {
   static_assert(N % 8 == 0);
   float* LUT;
-  static_assert(F4_T == JBLAS_DTYPE::F4_BNB || F4_T == JBLAS_DTYPE::F4_NF4 || F4_T == JBLAS_DTYPE::F4_E2M1,
+  static_assert(F4_T == BTLA_DTYPE::F4_BNB || F4_T == BTLA_DTYPE::F4_NF4 || F4_T == BTLA_DTYPE::F4_E2M1,
                 "Unsupported F4 type");
-  if constexpr (F4_T == JBLAS_DTYPE::F4_BNB) {
+  if constexpr (F4_T == BTLA_DTYPE::F4_BNB) {
     LUT = fp4_bnb_dequant_fp32_LUT;
-  } else if constexpr (F4_T == JBLAS_DTYPE::F4_NF4) {
+  } else if constexpr (F4_T == BTLA_DTYPE::F4_NF4) {
     LUT = nf4_dequant_fp32_LUT;
-  } else if constexpr (F4_T == JBLAS_DTYPE::F4_E2M1) {
+  } else if constexpr (F4_T == BTLA_DTYPE::F4_E2M1) {
     LUT = fp4_e2m1_dequant_fp32_LUT;
   }
   int constexpr VLoop = N / 8;
@@ -540,9 +540,9 @@ static inline void unpack_f4_N(_DST_T* dstptr, int8_t* srcptr) {
   }
 }
 
-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) {
+template <BTLA_DTYPE F4_T, typename DST_T>
+inline BTLA_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(*reinterpret_cast<int*>(&mask));
   if (col == ld_src) {
@@ -559,13 +559,13 @@ inline JBLAS_CODE decompress_kblock_f4_fp_noscale(utils::f4x2* srcptr, DST_T* ds
       dstptr[i + 0] = static_cast<DST_T>(ref::f4_unpack<F4_T>(tmp.x));
       dstptr[i + 1] = static_cast<DST_T>(ref::f4_unpack<F4_T>(tmp.y));
     }
-    return JblasSuccess;
+    return BTLA_CODE::Success;
   }
-  return JblasSuccess;
+  return BTLA_CODE::Success;
 }
 
 template <bool _IS_SYM, int _NCOL, typename _ST, typename _DST_T>
-static inline JBLAS_CODE decompress_kblock_bit4_packrow1(
+static inline BTLA_CODE decompress_kblock_bit4_packrow1(
     utils::bit4x2* srcptr, _DST_T* dstptr, int row, int col, int ld_src, int ld_dst, _ST* scales, int8_t* zero_points,
     int k_offset, int kblock, int NPad, void (*dequantize)(_DST_T*, int8_t*, __m256*, __m256i*),
     void (*pad_bit4_16)(int8_t*, int8_t*), void (*pad_bit4_8)(int8_t*, int8_t*), int8_t* tmpbuf, size_t tmpsize) {
@@ -659,23 +659,23 @@ static inline JBLAS_CODE decompress_kblock_bit4_packrow1(
       dequantize(dstptr + irow * ld_dst, tmpbuf, vscales, vzps);
     }
   }
-  return JblasSuccess;
+  return BTLA_CODE::Success;
 }
 
 template <bool _IS_SYM, typename _ST, typename _DST_T>
-static inline JBLAS_CODE decompress_kblock_bit4_packrow2(utils::bit4x2* srcptr, _DST_T* dstptr, int row, int col,
-                                                         int ld_src, int ld_dst, _ST* scales, int8_t* zero_points,
-                                                         int k_offset, int kblock, int NPad,
-                                                         void (*dequantize)(_DST_T*, int8_t*, __m256*, __m256i*),
-                                                         void (*pad_bit4)(int8_t*, int8_t*), int8_t* tmp,
-                                                         size_t tmpsize) {
-  return JblasNotSupport;
-}
-
-template <JBLAS_DTYPE _F4_T, typename _DST_T, int _PACK_ROW, typename _ST>
-static inline JBLAS_CODE decompress_kblock_f4_fp(utils::f4x2* srcptr, _DST_T* dstptr, int row, int col, int ld_src,
-                                                 int ld_dst, _ST* scales, int k_offset, int kblock, int NPad,
-                                                 int8_t* tmp, size_t tmpsize) {
+static inline BTLA_CODE decompress_kblock_bit4_packrow2(utils::bit4x2* srcptr, _DST_T* dstptr, int row, int col,
+                                                        int ld_src, int ld_dst, _ST* scales, int8_t* zero_points,
+                                                        int k_offset, int kblock, int NPad,
+                                                        void (*dequantize)(_DST_T*, int8_t*, __m256*, __m256i*),
+                                                        void (*pad_bit4)(int8_t*, int8_t*), int8_t* tmp,
+                                                        size_t tmpsize) {
+  return BTLA_CODE::NotSupport;
+}
+
+template <BTLA_DTYPE _F4_T, typename _DST_T, int _PACK_ROW, typename _ST>
+static inline BTLA_CODE decompress_kblock_f4_fp(utils::f4x2* srcptr, _DST_T* dstptr, int row, int col, int ld_src,
+                                                int ld_dst, _ST* scales, int k_offset, int kblock, int NPad,
+                                                int8_t* tmp, size_t tmpsize) {
   if constexpr (_PACK_ROW == 1) {
     if (col == 24) {
       return decompress_kblock_bit4_packrow1<true, 24, _ST, _DST_T>(
@@ -692,7 +692,7 @@ static inline JBLAS_CODE decompress_kblock_f4_fp(utils::f4x2* srcptr, _DST_T* ds
                                                               k_offset, kblock, NPad, &dequant_f4_N<64, _DST_T, _F4_T>,
                                                               fp4_pad_4bit, tmp, tmpsize);
   }
-  return JblasNotSupport;
+  return BTLA_CODE::NotSupport;
 }
 
 enum class AVX2_REDUCE_TYPE { MAX, MIN, ADD };
@@ -745,9 +745,9 @@ inline __m128i avx2_cvtepi32_epu8(__m256i x) {
 }
 
 template <typename SRC_T>
-static inline JBLAS_CODE quantize_fp_u8_colblock(int row, int col, const SRC_T* srcptr, int ld_src, uint8_t* dstptr,
-                                                 int ld_dst, float* scales, int ld_scale, uint8_t* zps, int blocksize,
-                                                 float* blkreduce) {
+static inline BTLA_CODE quantize_fp_u8_colblock(int row, int col, const SRC_T* srcptr, int ld_src, uint8_t* dstptr,
+                                                int ld_dst, float* scales, int ld_scale, uint8_t* zps, int blocksize,
+                                                float* blkreduce) {
   int constexpr VLen = 8;
   auto vff = _mm256_set1_epi32(255);
   auto v0 = _mm256_set1_epi32(0);
@@ -763,8 +763,8 @@ 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(
-              reinterpret_cast<__m128i*>(const_cast<jblas::utils::bf16*>(&srcptr[(j + ij) + i * ld_src])));
+          auto vtmp =
+              _mm_loadu_si128(reinterpret_cast<__m128i*>(const_cast<utils::bf16*>(&srcptr[(j + ij) + i * ld_src])));
           vsrc = ymm_cvt_bf16_fp32(vtmp);
         }
         vmaxval = _mm256_max_ps(vmaxval, vsrc);
@@ -793,8 +793,8 @@ 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(
-                reinterpret_cast<__m128i*>(const_cast<jblas::utils::bf16*>(&srcptr[(j + ij) + i * ld_src])));
+            auto vtmp =
+                _mm_loadu_si128(reinterpret_cast<__m128i*>(const_cast<utils::bf16*>(&srcptr[(j + ij) + i * ld_src])));
             vsrc = ymm_cvt_bf16_fp32(vtmp);
           }
           vsrc = _mm256_mul_ps(vsrc, vrscale);
@@ -811,8 +811,8 @@ 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(
-                reinterpret_cast<__m128i*>(const_cast<jblas::utils::bf16*>(&srcptr[(j + ij) + i * ld_src])));
+            auto vtmp =
+                _mm_loadu_si128(reinterpret_cast<__m128i*>(const_cast<utils::bf16*>(&srcptr[(j + ij) + i * ld_src])));
             vsrc = ymm_cvt_bf16_fp32(vtmp);
           }
           vsrc = _mm256_mul_ps(vsrc, vrscale);
@@ -864,12 +864,12 @@ static inline JBLAS_CODE quantize_fp_u8_colblock(int row, int col, const SRC_T*
       }
     }
   }
-  return JblasSuccess;
+  return BTLA_CODE::Success;
 }
 
 template <typename SRC_T>
-static inline JBLAS_CODE col_block_reduce_sum(const SRC_T* srcptr, int ldsrc, int row, int col, int blocksize,
-                                              float* reduce, int ldr) {
+static inline BTLA_CODE col_block_reduce_sum(const SRC_T* srcptr, int ldsrc, int row, int col, int blocksize,
+                                             float* reduce, int ldr) {
   int constexpr VLen = 8;
   auto vblock2_ = utils::padto_le(blocksize, VLen * 2);
   auto vblock_ = utils::padto_le(blocksize, VLen);
@@ -901,11 +901,11 @@ static inline JBLAS_CODE col_block_reduce_sum(const SRC_T* srcptr, int ldsrc, in
       reduce[i * ldr + j / blocksize] = tmp;
     }
   }
-  return JblasSuccess;
+  return BTLA_CODE::Success;
 }
 
-static inline JBLAS_CODE bf16_cvt_fp32_2D_write_back(const utils::bf16* src_ptr, float* dst_ptr, int row, int col,
-                                                     int src_step, int dst_step, bool zeropadding) {
+static inline BTLA_CODE bf16_cvt_fp32_2D_write_back(const utils::bf16* src_ptr, float* dst_ptr, int row, int col,
+                                                    int src_step, int dst_step, bool zeropadding) {
   const int npadding = (dst_step - col) * sizeof(float);
   constexpr int simd_proc_elt = 8;
   auto col_body = col / simd_proc_elt * simd_proc_elt;
@@ -923,7 +923,7 @@ static inline JBLAS_CODE bf16_cvt_fp32_2D_write_back(const utils::bf16* src_ptr,
     }
     if (zeropadding && npadding) std::memset(dst + col, 0, npadding);
   }
-  return JblasSuccess;
+  return BTLA_CODE::Success;
 }
 
 static const uint8_t avx2_bf16_convert_maigc_num[32] = {
@@ -941,8 +941,8 @@ static inline __m128i cvt_fp32_to_bf16(const __m256 src, __m256i* and_helper, __
   return _mm256_castsi256_si128(ordered);
 }
 
-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) {
+static inline BTLA_CODE fp32_cvt_bf16_2D_write_back(const void* raw_srcptr, void* raw_dstptr, int row, int col,
+                                                    int srcstride, int dststride, bool zeropadding) {
   auto srcptr = reinterpret_cast<const char*>(raw_srcptr);
   auto dstptr = reinterpret_cast<char*>(raw_dstptr);
   constexpr int simd_proc_elt = 8;
@@ -957,16 +957,16 @@ static inline JBLAS_CODE fp32_cvt_bf16_2D_write_back(const void* raw_srcptr, voi
     for (; j < col_body_loop; j += simd_proc_elt) {
       auto 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);
+      _mm_storeu_si128(reinterpret_cast<__m128i*>(dst + j * sizeof(utils::bf16)), pack_bf16_value);
     }
     for (; j < col; j++) {
-      (reinterpret_cast<jblas::utils::bf16*>(dst) + j)->fromfloat(*(reinterpret_cast<const float*>(src) + j));
+      (reinterpret_cast<utils::bf16*>(dst) + j)->fromfloat(*(reinterpret_cast<const float*>(src) + j));
     }
     if (zeropadding && npadding) {
       std::memset(dst + col * sizeof(utils::bf16), 0, npadding);
     }
   }
-  return JblasSuccess;
+  return BTLA_CODE::Success;
 }
 
 #ifdef __GNUC__
@@ -976,4 +976,4 @@ static inline JBLAS_CODE fp32_cvt_bf16_2D_write_back(const void* raw_srcptr, voi
 #endif
 }  // namespace avx2
 }  // namespace kernel
-}  // namespace jblas
+}  // namespace bestla
diff --git a/bestla/jblas/kernel_avx512_bf16.h b/bestla/bestla/kernel_avx512_bf16.h
similarity index 82%
rename from bestla/jblas/kernel_avx512_bf16.h
rename to bestla/bestla/kernel_avx512_bf16.h
index 70cea4749..453b88afd 100644
--- a/bestla/jblas/kernel_avx512_bf16.h
+++ b/bestla/bestla/kernel_avx512_bf16.h
@@ -14,17 +14,17 @@
 #pragma once
 #include <immintrin.h>
 #include "kernel_avx512f.h"
-#include "jit_blas_utils.h"
+#include "bestla_utils.h"
 
-namespace jblas {
+namespace bestla {
 namespace kernel {
 namespace avx512_bf16 {
 #if CompileBF16()
 #pragma GCC push_options
 #pragma GCC target("avx512bf16", "avx512vl", "avx512bw")
 #endif
-static inline JBLAS_CODE bf16_cvt_fp32_2D_write_back(const utils::bf16* src_ptr, float* dst_ptr, int row, int col,
-                                                     int src_step, int dst_step, bool zeropadding) {
+static inline BTLA_CODE bf16_cvt_fp32_2D_write_back(const utils::bf16* src_ptr, float* dst_ptr, int row, int col,
+                                                    int src_step, int dst_step, bool zeropadding) {
 #if CompileBF16()
   const int npadding = (dst_step - col) * sizeof(float);
   constexpr int simd_proc_elt = 16;
@@ -45,13 +45,13 @@ static inline JBLAS_CODE bf16_cvt_fp32_2D_write_back(const utils::bf16* src_ptr,
           reinterpret_cast<__m512>(_mm512_bslli_epi128(_mm512_cvtepu16_epi32(_mm256_loadu_epi16(src + j)), 2)));
     if (zeropadding && npadding) std::memset(dst + col, 0, npadding);
   }
-  return JblasSuccess;
+  return BTLA_CODE::Success;
 #endif
   return avx512f::bf16_cvt_fp32_2D_write_back(src_ptr, dst_ptr, row, col, src_step, dst_step, zeropadding);
 }
 
-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) {
+static inline BTLA_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()
   auto srcptr = reinterpret_cast<const char*>(raw_srcptr);
   auto dstptr = reinterpret_cast<char*>(raw_dstptr);
@@ -66,13 +66,13 @@ static inline JBLAS_CODE fp32_cvt_bf16_2D_write_back(const void* raw_srcptr, voi
     int j = 0;
     for (; j < col_body_loop; j++) {
       _mm512_storeu_epi16(
-          (dst + (j * simd_proc_elt) * sizeof(jblas::utils::bf16)),
+          (dst + (j * simd_proc_elt) * sizeof(utils::bf16)),
           (__m512i)_mm512_cvtne2ps_pbh(_mm512_loadu_ps(src + sizeof(float) * simd_proc_elt * j + sizeof(float) * 16),
                                        _mm512_loadu_ps(src + sizeof(float) * simd_proc_elt * j + sizeof(float) * 0)));
     }
     if (col_tail > 0) {
       _mm512_mask_storeu_epi16(
-          (dst + (j * simd_proc_elt) * sizeof(jblas::utils::bf16)), tail_mask,  //
+          (dst + (j * simd_proc_elt) * sizeof(utils::bf16)), tail_mask,  //
           (__m512i)_mm512_cvtne2ps_pbh(
               _mm512_maskz_loadu_ps(tail_mask >> 16, src + sizeof(float) * simd_proc_elt * j + sizeof(float) * 16),
               _mm512_maskz_loadu_ps(tail_mask >> 0, src + sizeof(float) * simd_proc_elt * j + sizeof(float) * 0)));
@@ -81,6 +81,7 @@ static inline JBLAS_CODE fp32_cvt_bf16_2D_write_back(const void* raw_srcptr, voi
       std::memset(dst + col * sizeof(utils::bf16), 0, npadding);
     }
   }
+  return BTLA_CODE::Success;
 #endif
   return avx512f::fp32_cvt_bf16_2D_write_back(raw_srcptr, raw_dstptr, row, col, srcstride, dststride, zeropadding);
 }
@@ -89,4 +90,4 @@ static inline JBLAS_CODE fp32_cvt_bf16_2D_write_back(const void* raw_srcptr, voi
 #endif
 }  // namespace avx512_bf16
 }  // namespace kernel
-}  // namespace jblas
+}  // namespace bestla
diff --git a/bestla/jblas/kernel_avx512f.h b/bestla/bestla/kernel_avx512f.h
similarity index 85%
rename from bestla/jblas/kernel_avx512f.h
rename to bestla/bestla/kernel_avx512f.h
index 503287ff6..2e5c3f3e3 100644
--- a/bestla/jblas/kernel_avx512f.h
+++ b/bestla/bestla/kernel_avx512f.h
@@ -12,7 +12,7 @@
 //  See the License for the specific language governing permissions and
 //  limitations under the License.
 #pragma once
-#include "jit_blas_utils.h"
+#include "bestla_utils.h"
 #include "kernel_ref.h"
 
 #include <array>
@@ -23,7 +23,7 @@
 #include <immintrin.h>
 #endif
 
-namespace jblas {
+namespace bestla {
 namespace kernel {
 namespace avx512f {
 #if CompileAVX512F()
@@ -62,11 +62,11 @@ static inline __m512i unpack_4bits(__m256i v4bits, __m512i vmask) {
   return zmm1;
 }
 
-template <JBLAS_DTYPE S4_T>
+template <BTLA_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), reinterpret_cast<const __m256i*>(srcptr));
   auto zmm = unpack_4bits(ymm, vmask);
-  if constexpr (S4_T == JBLAS_DTYPE::S4_FULLRANGE) {
+  if constexpr (S4_T == BTLA_DTYPE::S4_FULLRANGE) {
     zmm = _mm512_srli_epi32(zmm, 4);
     auto s8 = _mm512_set1_epi8(8);
     zmm = _mm512_sub_epi8(zmm, s8);
@@ -74,12 +74,12 @@ static inline void convert_s4_s8(int8_t* dstptr, int8_t* srcptr, __m512i vmask,
   _mm512_mask_storeu_epi64(dstptr, __mmask8(LoadMask), zmm);
 }
 
-template <JBLAS_DTYPE S4_T>
+template <BTLA_DTYPE S4_T>
 static inline void convert_s4_s8_v32(int8_t* dstptr, int8_t* srcptr, __m512i vmask, int LoadMask) {
   auto xmm = _mm_maskz_loadu_epi32(__mmask8(LoadMask), reinterpret_cast<const __m256i*>(srcptr));
   auto ymm = _mm256_castsi128_si256(xmm);
   auto zmm = unpack_4bits(ymm, vmask);
-  if constexpr (S4_T == JBLAS_DTYPE::S4_FULLRANGE) {
+  if constexpr (S4_T == BTLA_DTYPE::S4_FULLRANGE) {
     zmm = _mm512_srli_epi32(zmm, 4);
     auto s8 = _mm512_set1_epi8(8);
     zmm = _mm512_sub_epi8(zmm, s8);
@@ -101,7 +101,7 @@ static inline void convert_s8_fp_v16(T* dstptr, int8_t* srcptr) {
   }
 }
 
-constexpr void (*pad_fp4)(int8_t* dstptr, int8_t* srcptr, __m512i vmask, int) = &convert_s4_s8<JBLAS_DTYPE::S4_CLIP>;
+constexpr void (*pad_fp4)(int8_t* dstptr, int8_t* srcptr, __m512i vmask, int) = &convert_s4_s8<BTLA_DTYPE::S4_CLIP>;
 
 template <int N, typename _DST_T, bool _IS_SYM>
 static inline void dequant_s8_N(_DST_T* dstptr, int8_t* srcptr, __m512* vscales, __m512i* vzps = nullptr) {
@@ -124,18 +124,18 @@ static inline void dequant_s8_N(_DST_T* dstptr, int8_t* srcptr, __m512* vscales,
   }
 }
 
-template <int N, typename _DST_T, JBLAS_DTYPE F4_T>
+template <int N, typename _DST_T, BTLA_DTYPE F4_T>
 static inline void dequant_f4_N(_DST_T* dstptr, int8_t* srcptr, __m512* vscales, __m512i* vzps = nullptr) {
   static_assert(N % 16 == 0);
   int constexpr VLoop = N / 16;
   float* LUT;
-  static_assert(F4_T == JBLAS_DTYPE::F4_BNB || F4_T == JBLAS_DTYPE::F4_NF4 || F4_T == JBLAS_DTYPE::F4_E2M1,
+  static_assert(F4_T == BTLA_DTYPE::F4_BNB || F4_T == BTLA_DTYPE::F4_NF4 || F4_T == BTLA_DTYPE::F4_E2M1,
                 "Unsupported F4 type");
-  if constexpr (F4_T == JBLAS_DTYPE::F4_BNB) {
+  if constexpr (F4_T == BTLA_DTYPE::F4_BNB) {
     LUT = fp4_bnb_dequant_fp32_LUT;
-  } else if constexpr (F4_T == JBLAS_DTYPE::F4_NF4) {
+  } else if constexpr (F4_T == BTLA_DTYPE::F4_NF4) {
     LUT = nf4_dequant_fp32_LUT;
-  } else if constexpr (F4_T == JBLAS_DTYPE::F4_E2M1) {
+  } else if constexpr (F4_T == BTLA_DTYPE::F4_E2M1) {
     LUT = fp4_e2m1_dequant_fp32_LUT;
   }
   for (int iv = 0; iv < VLoop; iv += 1) {
@@ -156,18 +156,18 @@ static inline void dequant_f4_N(_DST_T* dstptr, int8_t* srcptr, __m512* vscales,
   }
 }
 
-template <int N, typename _DST_T, JBLAS_DTYPE F4_T>
+template <int N, typename _DST_T, BTLA_DTYPE F4_T>
 static inline void unpack_f4_N(_DST_T* dstptr, int8_t* srcptr) {
   static_assert(N % 16 == 0);
   int constexpr VLoop = N / 16;
   float* LUT;
-  static_assert(F4_T == JBLAS_DTYPE::F4_BNB || F4_T == JBLAS_DTYPE::F4_NF4 || F4_T == JBLAS_DTYPE::F4_E2M1,
+  static_assert(F4_T == BTLA_DTYPE::F4_BNB || F4_T == BTLA_DTYPE::F4_NF4 || F4_T == BTLA_DTYPE::F4_E2M1,
                 "Unsupported F4 type");
-  if constexpr (F4_T == JBLAS_DTYPE::F4_BNB) {
+  if constexpr (F4_T == BTLA_DTYPE::F4_BNB) {
     LUT = fp4_bnb_dequant_fp32_LUT;
-  } else if constexpr (F4_T == JBLAS_DTYPE::F4_NF4) {
+  } else if constexpr (F4_T == BTLA_DTYPE::F4_NF4) {
     LUT = nf4_dequant_fp32_LUT;
-  } else if constexpr (F4_T == JBLAS_DTYPE::F4_E2M1) {
+  } else if constexpr (F4_T == BTLA_DTYPE::F4_E2M1) {
     LUT = fp4_e2m1_dequant_fp32_LUT;
   }
   for (int iv = 0; iv < VLoop; iv += 1) {
@@ -228,12 +228,12 @@ static inline void vec_broadcast_epi32_2_4(__m512i* dst4regs, __m512i* src2regs)
 }
 
 template <typename _ST, typename _DT, bool _IS_SYM>
-static inline JBLAS_CODE decompress_kblock_bit4_packrow1(utils::bit4x2* srcptr, _DT* dstptr, int row, int col,
-                                                         int ld_src, int ld_dst, _ST* scales, int8_t* zero_points,
-                                                         int k_offset, int kblock, int NPad,
-                                                         void (*dequantize)(_DT*, int8_t*, __m512*, __m512i*),
-                                                         void (*pad_bit4)(int8_t*, int8_t*, __m512i, int),
-                                                         int8_t* tmpbuf, size_t tmpsize) {
+static inline BTLA_CODE decompress_kblock_bit4_packrow1(utils::bit4x2* srcptr, _DT* dstptr, int row, int col,
+                                                        int ld_src, int ld_dst, _ST* scales, int8_t* zero_points,
+                                                        int k_offset, int kblock, int NPad,
+                                                        void (*dequantize)(_DT*, int8_t*, __m512*, __m512i*),
+                                                        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(*reinterpret_cast<int*>(&mask));
   if (col == 48) {
@@ -345,22 +345,22 @@ static inline JBLAS_CODE decompress_kblock_bit4_packrow1(utils::bit4x2* srcptr,
         }
       }
     }
-    return JblasSuccess;
+    return BTLA_CODE::Success;
   }
-  return JblasNotSupport;
+  return BTLA_CODE::NotSupport;
 }
 
-template <JBLAS_DTYPE _SRCT, typename _ST, typename _DT, bool _IS_SYM = true>
-static inline JBLAS_CODE decompress_kblock_bit4_packrow2(utils::bit4x2* srcptr, _DT* dstptr, int row, int col,
-                                                         int ld_src, int ld_dst, _ST* scales, int8_t* zero_points,
-                                                         int k_offset, int kblock, int NPad, int8_t* tmpbuf,
-                                                         size_t tmpsize) {
+template <BTLA_DTYPE _SRCT, typename _ST, typename _DT, bool _IS_SYM = true>
+static inline BTLA_CODE decompress_kblock_bit4_packrow2(utils::bit4x2* srcptr, _DT* dstptr, int row, int col,
+                                                        int ld_src, int ld_dst, _ST* scales, int8_t* zero_points,
+                                                        int k_offset, int kblock, int NPad, int8_t* tmpbuf,
+                                                        size_t tmpsize) {
   uint32_t mask = 0xf0f0f0f0;
   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);
   auto constexpr SRC_TYPE =
-      static_cast<JBLAS_DTYPE>(utils::jblas_dtype_get_mask_val(_SRCT, JBLAS_DTYPE::TypeMask, JBLAS_DTYPE::TypeShift));
+      static_cast<BTLA_DTYPE>(utils::bestla_dtype_get_mask_val(_SRCT, BTLA_DTYPE::TypeMask, BTLA_DTYPE::TypeShift));
   if (col % 64 == 0) {
     constexpr int ColTile = 64;
     constexpr int NRegs = ColTile / 16;
@@ -388,9 +388,9 @@ static inline JBLAS_CODE decompress_kblock_bit4_packrow2(utils::bit4x2* srcptr,
         }
 
         for (; irow < row0; irow++) {
-          if constexpr (SRC_TYPE == JBLAS_DTYPE::TypeFloat) {
-            convert_s4_s8<JBLAS_DTYPE::S4_CLIP>(
-                tmpbuf, reinterpret_cast<int8_t*>(srcptr + irow * ld_src / 2 + icol / 2), zmm_mask, LoadMask64);
+          if constexpr (SRC_TYPE == BTLA_DTYPE::TypeFloat) {
+            convert_s4_s8<BTLA_DTYPE::S4_CLIP>(tmpbuf, reinterpret_cast<int8_t*>(srcptr + irow * ld_src / 2 + icol / 2),
+                                               zmm_mask, LoadMask64);
             dequant_f4_N<ColTile, _DT, _SRCT>(dstptr + irow * ld_dst + icol, tmpbuf, vscales, vzps);
           } else {
             convert_s4_s8<_SRCT>(tmpbuf, reinterpret_cast<int8_t*>(srcptr + irow * ld_src / 2 + icol / 2), zmm_mask,
@@ -414,8 +414,8 @@ static inline JBLAS_CODE decompress_kblock_bit4_packrow2(utils::bit4x2* srcptr,
         }
 
         for (int irr = 0; irr < kblock; irr += 1) {
-          if constexpr (SRC_TYPE == JBLAS_DTYPE::TypeFloat) {
-            convert_s4_s8<JBLAS_DTYPE::S4_CLIP>(
+          if constexpr (SRC_TYPE == BTLA_DTYPE::TypeFloat) {
+            convert_s4_s8<BTLA_DTYPE::S4_CLIP>(
                 tmpbuf, reinterpret_cast<int8_t*>(srcptr + (irow + irr) * ld_src / 2 + icol / 2), zmm_mask, LoadMask64);
             dequant_f4_N<ColTile, _DT, _SRCT>(dstptr + (irow + irr) * ld_dst + icol, tmpbuf, vscales, vzps);
           } else {
@@ -438,9 +438,9 @@ static inline JBLAS_CODE decompress_kblock_bit4_packrow2(utils::bit4x2* srcptr,
         }
       }
       for (; irow < row; irow++) {
-        if constexpr (SRC_TYPE == JBLAS_DTYPE::TypeFloat) {
-          convert_s4_s8<JBLAS_DTYPE::S4_CLIP>(tmpbuf, reinterpret_cast<int8_t*>(srcptr + irow * ld_src / 2 + icol / 2),
-                                              zmm_mask, LoadMask64);
+        if constexpr (SRC_TYPE == BTLA_DTYPE::TypeFloat) {
+          convert_s4_s8<BTLA_DTYPE::S4_CLIP>(tmpbuf, reinterpret_cast<int8_t*>(srcptr + irow * ld_src / 2 + icol / 2),
+                                             zmm_mask, LoadMask64);
           dequant_f4_N<ColTile, _DT, _SRCT>(dstptr + irow * ld_dst + icol, tmpbuf, vscales, vzps);
         } else {
           convert_s4_s8<_SRCT>(tmpbuf, reinterpret_cast<int8_t*>(srcptr + irow * ld_src / 2 + icol / 2), zmm_mask,
@@ -449,7 +449,7 @@ static inline JBLAS_CODE decompress_kblock_bit4_packrow2(utils::bit4x2* srcptr,
         }
       }
     }
-    return JblasSuccess;
+    return BTLA_CODE::Success;
   } else if (col % 96 == 0) {
     constexpr int ColTile = 96;
     constexpr int NRegs = ColTile / 16;
@@ -477,10 +477,10 @@ static inline JBLAS_CODE decompress_kblock_bit4_packrow2(utils::bit4x2* srcptr,
         }
 
         for (; irow < row0; irow++) {
-          if constexpr (SRC_TYPE == JBLAS_DTYPE::TypeFloat) {
-            convert_s4_s8<JBLAS_DTYPE::S4_CLIP>(
-                tmpbuf, reinterpret_cast<int8_t*>(srcptr + irow * ld_src / 2 + icol / 2), zmm_mask, LoadMask64);
-            convert_s4_s8_v32<JBLAS_DTYPE::S4_CLIP>(
+          if constexpr (SRC_TYPE == BTLA_DTYPE::TypeFloat) {
+            convert_s4_s8<BTLA_DTYPE::S4_CLIP>(tmpbuf, reinterpret_cast<int8_t*>(srcptr + irow * ld_src / 2 + icol / 2),
+                                               zmm_mask, LoadMask64);
+            convert_s4_s8_v32<BTLA_DTYPE::S4_CLIP>(
                 tmpbuf + 64, reinterpret_cast<int8_t*>(srcptr + irow * ld_src / 2 + icol / 2 + 32), zmm_mask,
                 LoadMask64);
             dequant_f4_N<ColTile, _DT, _SRCT>(dstptr + irow * ld_dst + icol, tmpbuf, vscales, vzps);
@@ -508,10 +508,10 @@ static inline JBLAS_CODE decompress_kblock_bit4_packrow2(utils::bit4x2* srcptr,
         }
 
         for (int irr = 0; irr < kblock; irr += 1) {
-          if constexpr (SRC_TYPE == JBLAS_DTYPE::TypeFloat) {
-            convert_s4_s8<JBLAS_DTYPE::S4_CLIP>(
+          if constexpr (SRC_TYPE == BTLA_DTYPE::TypeFloat) {
+            convert_s4_s8<BTLA_DTYPE::S4_CLIP>(
                 tmpbuf, reinterpret_cast<int8_t*>(srcptr + (irow + irr) * ld_src / 2 + icol / 2), zmm_mask, LoadMask64);
-            convert_s4_s8_v32<JBLAS_DTYPE::S4_CLIP>(
+            convert_s4_s8_v32<BTLA_DTYPE::S4_CLIP>(
                 tmpbuf + 64, reinterpret_cast<int8_t*>(srcptr + (irow + irr) * ld_src / 2 + icol / 2 + 32), zmm_mask,
                 LoadMask64);
             dequant_f4_N<ColTile, _DT, _SRCT>(dstptr + (irow + irr) * ld_dst + icol, tmpbuf, vscales, vzps);
@@ -538,10 +538,10 @@ static inline JBLAS_CODE decompress_kblock_bit4_packrow2(utils::bit4x2* srcptr,
         }
       }
       for (; irow < row; irow++) {
-        if constexpr (SRC_TYPE == JBLAS_DTYPE::TypeFloat) {
-          convert_s4_s8<JBLAS_DTYPE::S4_CLIP>(tmpbuf, reinterpret_cast<int8_t*>(srcptr + irow * ld_src / 2 + icol / 2),
-                                              zmm_mask, LoadMask64);
-          convert_s4_s8_v32<JBLAS_DTYPE::S4_CLIP>(
+        if constexpr (SRC_TYPE == BTLA_DTYPE::TypeFloat) {
+          convert_s4_s8<BTLA_DTYPE::S4_CLIP>(tmpbuf, reinterpret_cast<int8_t*>(srcptr + irow * ld_src / 2 + icol / 2),
+                                             zmm_mask, LoadMask64);
+          convert_s4_s8_v32<BTLA_DTYPE::S4_CLIP>(
               tmpbuf + 64, reinterpret_cast<int8_t*>(srcptr + irow * ld_src / 2 + icol / 2 + 32), zmm_mask, LoadMask64);
           dequant_f4_N<ColTile, _DT, _SRCT>(dstptr + irow * ld_dst + icol, tmpbuf, vscales, vzps);
         } else {
@@ -554,17 +554,17 @@ static inline JBLAS_CODE decompress_kblock_bit4_packrow2(utils::bit4x2* srcptr,
       }
     }
 
-    return JblasSuccess;
+    return BTLA_CODE::Success;
   }
-  return JblasNotSupport;
+  return BTLA_CODE::NotSupport;
 }
 
 template <bool WITH_SCALE, typename _DST_T, int _PACK_ROW, typename _S_T>
-inline JBLAS_CODE decompress_kblock_f8_fp(utils::f8* srcptr, _DST_T* dstptr, int row, int col, int ld_src, int ld_dst,
-                                          _S_T* scales, int k_offset, int kblock, int NPad, JBLAS_DTYPE src_f8_type) {
+inline BTLA_CODE decompress_kblock_f8_fp(utils::f8* srcptr, _DST_T* dstptr, int row, int col, int ld_src, int ld_dst,
+                                         _S_T* scales, int k_offset, int kblock, int NPad, BTLA_DTYPE src_f8_type) {
   int align_col = col / 16 * 16;
   int col_tail = col - align_col;
-  auto ebits = utils::jblas_dtype_get_f8_ebits(src_f8_type);
+  auto ebits = utils::bestla_dtype_get_f8_ebits(src_f8_type);
   auto mantissabit = 7 - ebits;
   auto sign_revert_and_mask = _mm512_set1_epi32(0x80000000);
   auto e_revert_and_mask = _mm512_set1_epi32(0x0000007f);
@@ -614,13 +614,13 @@ inline JBLAS_CODE decompress_kblock_f8_fp(utils::f8* srcptr, _DST_T* dstptr, int
     for (; j < align_col; j += 16) quant(_cvtu32_mask16(0xffff));
     if (col_tail > 0) quant(_cvtu32_mask16(0xffff >> (16 - col_tail)));
   }
-  return JblasSuccess;
+  return BTLA_CODE::Success;
 }
 
-template <JBLAS_DTYPE S4_T, typename _DST_T, int _PACK_ROW, typename _ST>
-static inline JBLAS_CODE decompress_kblock_s4_fp(utils::int4x2* srcptr, _DST_T* dstptr, int row, int col, int ld_src,
-                                                 int ld_dst, _ST* scales, int8_t* zero_points, int k_offset, int kblock,
-                                                 int NPad, int8_t* tmp, size_t tmpsize) {
+template <BTLA_DTYPE S4_T, typename _DST_T, int _PACK_ROW, typename _ST>
+static inline BTLA_CODE decompress_kblock_s4_fp(utils::int4x2* srcptr, _DST_T* dstptr, int row, int col, int ld_src,
+                                                int ld_dst, _ST* scales, int8_t* zero_points, int k_offset, int kblock,
+                                                int NPad, int8_t* tmp, size_t tmpsize) {
   if constexpr (_PACK_ROW == 1) {
     if (zero_points == nullptr) {
       return decompress_kblock_bit4_packrow1<_ST, _DST_T, true>(
@@ -640,13 +640,13 @@ static inline JBLAS_CODE decompress_kblock_s4_fp(utils::int4x2* srcptr, _DST_T*
           srcptr, dstptr, row, col, ld_src, ld_dst, scales, zero_points, k_offset, kblock, NPad, tmp, tmpsize);
     }
   }
-  return JblasNotSupport;
+  return BTLA_CODE::NotSupport;
 }
 
-template <JBLAS_DTYPE _F4_T, typename _DST_T, int _PACK_ROW, typename _ST>
-static inline JBLAS_CODE decompress_kblock_f4_fp(utils::f4x2* srcptr, _DST_T* dstptr, int row, int col, int ld_src,
-                                                 int ld_dst, _ST* scales, int k_offset, int kblock, int NPad,
-                                                 int8_t* tmp, size_t tmpsize) {
+template <BTLA_DTYPE _F4_T, typename _DST_T, int _PACK_ROW, typename _ST>
+static inline BTLA_CODE decompress_kblock_f4_fp(utils::f4x2* srcptr, _DST_T* dstptr, int row, int col, int ld_src,
+                                                int ld_dst, _ST* scales, int k_offset, int kblock, int NPad,
+                                                int8_t* tmp, size_t tmpsize) {
   if constexpr (_PACK_ROW == 1) {
     return decompress_kblock_bit4_packrow1<_ST, _DST_T, true>(srcptr, dstptr, row, col, ld_src, ld_dst, scales, nullptr,
                                                               k_offset, kblock, NPad, &dequant_f4_N<48, _DST_T, _F4_T>,
@@ -655,12 +655,12 @@ static inline JBLAS_CODE decompress_kblock_f4_fp(utils::f4x2* srcptr, _DST_T* ds
     return decompress_kblock_bit4_packrow2<_F4_T, _ST, _DST_T, true>(srcptr, dstptr, row, col, ld_src, ld_dst, scales,
                                                                      nullptr, k_offset, kblock, NPad, tmp, tmpsize);
   }
-  return JblasNotSupport;
+  return BTLA_CODE::NotSupport;
 }
 
-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) {
+template <BTLA_DTYPE F4_T, typename DST_T>
+inline BTLA_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(*reinterpret_cast<int*>(&mask));
   if (col == ld_src) {
@@ -690,14 +690,14 @@ inline JBLAS_CODE decompress_kblock_f4_fp_noscale(utils::f4x2* srcptr, DST_T* ds
       dstptr[i + 0] = static_cast<DST_T>(ref::f4_unpack<F4_T>(tmp.x));
       dstptr[i + 1] = static_cast<DST_T>(ref::f4_unpack<F4_T>(tmp.y));
     }
-    return JblasSuccess;
+    return BTLA_CODE::Success;
   }
-  return JblasNotSupport;
+  return BTLA_CODE::NotSupport;
 }
 
-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) {
+template <BTLA_DTYPE S4_T>
+static inline BTLA_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(*reinterpret_cast<int*>(&mask));
   if (col == ld_src) {
@@ -719,16 +719,16 @@ static inline JBLAS_CODE decompress_s4_s8(utils::int4x2* srcptr, int8_t* dstptr,
     }
     for (; i < elesize; i += 2) {
       auto tmp = srcptr[i / 2];
-      dstptr[i + 0] = jblas::kernel::ref::get_s8<S4_T>(tmp.x);
-      dstptr[i + 1] = jblas::kernel::ref::get_s8<S4_T>(tmp.y);
+      dstptr[i + 0] = kernel::ref::get_s8<S4_T>(tmp.x);
+      dstptr[i + 1] = kernel::ref::get_s8<S4_T>(tmp.y);
     }
-    return JblasSuccess;
+    return BTLA_CODE::Success;
   }
-  return JblasNotSupport;
+  return BTLA_CODE::NotSupport;
 }
 
-static inline JBLAS_CODE quantize_f32_sign_int_rowblock_sym(const float* srcptr, int8_t* dstptr, int row, int col,
-                                                            int ld_src, int ld_dst, float* scales, int blocksize) {
+static inline BTLA_CODE quantize_f32_sign_int_rowblock_sym(const float* srcptr, int8_t* dstptr, int row, int col,
+                                                           int ld_src, int ld_dst, float* scales, int blocksize) {
   int constexpr VLen = 16;
   auto v127 = _mm512_set1_ps(127.f);
   int col16 = utils::padto_le(col, 16);
@@ -775,12 +775,12 @@ static inline JBLAS_CODE quantize_f32_sign_int_rowblock_sym(const float* srcptr,
     for (; j < align_row; j += blocksize) scalar_process_block(blocksize);
     if (j < row) scalar_process_block(row - align_row);
   }
-  return JblasSuccess;
+  return BTLA_CODE::Success;
 }
 
-static inline JBLAS_CODE quantize_f32_sign_int_rowblock_asym(const float* srcptr, int8_t* dstptr, int row, int col,
-                                                             int ld_src, int ld_dst, float* scales, int8_t* zero_points,
-                                                             int blocksize) {
+static inline BTLA_CODE quantize_f32_sign_int_rowblock_asym(const float* srcptr, int8_t* dstptr, int row, int col,
+                                                            int ld_src, int ld_dst, float* scales, int8_t* zero_points,
+                                                            int blocksize) {
   int constexpr VLen = 16;
   auto v255 = _mm512_set1_ps(255.f);
   auto v2 = _mm512_set1_ps(2.f);
@@ -842,13 +842,13 @@ static inline JBLAS_CODE quantize_f32_sign_int_rowblock_asym(const float* srcptr
     for (; j < align_row; j += blocksize) scalar_process_block(blocksize);
     if (j < row) scalar_process_block(row - align_row);
   }
-  return JblasSuccess;
+  return BTLA_CODE::Success;
 }
 
-template <JBLAS_DTYPE S4_T>
-static inline JBLAS_CODE quantize_f32_sign_int_rowblock(const float* srcptr, int8_t* dstptr, int row, int col,
-                                                        int ld_src, int ld_dst, float* scales, int8_t* zero_points,
-                                                        int blocksize) {
+template <BTLA_DTYPE S4_T>
+static inline BTLA_CODE quantize_f32_sign_int_rowblock(const float* srcptr, int8_t* dstptr, int row, int col,
+                                                       int ld_src, int ld_dst, float* scales, int8_t* zero_points,
+                                                       int blocksize) {
   if (zero_points == nullptr)
     return quantize_f32_sign_int_rowblock_sym(srcptr, dstptr, row, col, ld_src, ld_dst, scales, blocksize);
   else
@@ -878,7 +878,7 @@ constexpr auto broadcast_N_2_Nx16(const int8_t* arr) {
   return broadcast_N_2_Nx16<N>(arr, std::make_index_sequence<N * 16>{});
 }
 
-template <JBLAS_DTYPE F4_T>
+template <BTLA_DTYPE F4_T>
 inline void f32_f4_quantize_4x16(const float* srcptr, int8_t* dstptr, int ld_src, int ld_dst,
                                  const int8_t* broadcast_f4_v, float* scales, __mmask16 ls_mask) {
   __m128i xmm0{}, xmm1{}, xmm2{}, xmm3{};
@@ -895,7 +895,7 @@ inline void f32_f4_quantize_4x16(const float* srcptr, int8_t* dstptr, int ld_src
   zmm1 = _mm512_mul_ps(zmm1, zmm_scale);
   zmm2 = _mm512_mul_ps(zmm2, zmm_scale);
   zmm3 = _mm512_mul_ps(zmm3, zmm_scale);
-  if constexpr (F4_T == JBLAS_DTYPE::F4_NF4) {
+  if constexpr (F4_T == BTLA_DTYPE::F4_NF4) {
     auto zmm_zp = _mm512_set1_ps(0.8480964004993439f);
     zmm0 = _mm512_add_ps(zmm0, zmm_zp);
     zmm1 = _mm512_add_ps(zmm1, zmm_zp);
@@ -912,12 +912,12 @@ inline void f32_f4_quantize_4x16(const float* srcptr, int8_t* dstptr, int ld_src
     zmm2 = _mm512_abs_ps(zmm2);
     zmm3 = _mm512_abs_ps(zmm3);
   }
-  constexpr int loop_num = F4_T == JBLAS_DTYPE::F4_NF4 ? 16 : 8;
+  constexpr int loop_num = F4_T == BTLA_DTYPE::F4_NF4 ? 16 : 8;
   for (int i = 0; i < loop_num; i++) {
     __m512 sub_v;
-    if constexpr (F4_T == JBLAS_DTYPE::F4_NF4) sub_v = _mm512_set1_ps(F4_NF4_quant_sub_helper[i]);
-    if constexpr (F4_T == JBLAS_DTYPE::F4_BNB) sub_v = _mm512_set1_ps(F4_BNB_quant_sub_helper[i]);
-    if constexpr (F4_T == JBLAS_DTYPE::F4_E2M1) sub_v = _mm512_set1_ps(F4_E2M1_quant_sub_helper[i]);
+    if constexpr (F4_T == BTLA_DTYPE::F4_NF4) sub_v = _mm512_set1_ps(F4_NF4_quant_sub_helper[i]);
+    if constexpr (F4_T == BTLA_DTYPE::F4_BNB) sub_v = _mm512_set1_ps(F4_BNB_quant_sub_helper[i]);
+    if constexpr (F4_T == BTLA_DTYPE::F4_E2M1) sub_v = _mm512_set1_ps(F4_E2M1_quant_sub_helper[i]);
     zmm4 = _mm512_sub_ps(zmm0, sub_v);
     zmm5 = _mm512_sub_ps(zmm1, sub_v);
     zmm6 = _mm512_sub_ps(zmm2, sub_v);
@@ -935,7 +935,7 @@ inline void f32_f4_quantize_4x16(const float* srcptr, int8_t* dstptr, int ld_src
     zmm2 = _mm512_mask_add_ps(zmm2, mask2, zmm2, avoid_double_cmp);
     zmm3 = _mm512_mask_add_ps(zmm3, mask3, zmm3, avoid_double_cmp);
   }
-  if constexpr (F4_T != JBLAS_DTYPE::F4_NF4) {
+  if constexpr (F4_T != BTLA_DTYPE::F4_NF4) {
     auto xmm_bias = _mm_set1_epi8(0x08);
     xmm0 = _mm_mask_add_epi8(xmm0, mask4, xmm0, xmm_bias);
     xmm1 = _mm_mask_add_epi8(xmm1, mask5, xmm1, xmm_bias);
@@ -948,7 +948,7 @@ inline void f32_f4_quantize_4x16(const float* srcptr, int8_t* dstptr, int ld_src
   _mm_mask_storeu_epi8(dstptr + 3 * ld_dst, ls_mask, xmm3);
 }
 
-template <JBLAS_DTYPE F4_T>
+template <BTLA_DTYPE F4_T>
 inline void f32_f4_quantize_1x16(const float* srcptr, int8_t* dstptr, int ld_src, int ld_dst,
                                  const int8_t* broadcast_f4_v, float* scales, __mmask16 ls_mask) {
   __m512 zmm0{}, zmm1, zmm_scale{};
@@ -959,25 +959,25 @@ inline void f32_f4_quantize_1x16(const float* srcptr, int8_t* dstptr, int ld_src
   __mmask16 mask0, mask1;
   zmm0 = _mm512_mask_loadu_ps(zmm0, ls_mask, srcptr);
   zmm0 = _mm512_mul_ps(zmm0, zmm_scale);
-  if constexpr (F4_T == JBLAS_DTYPE::F4_NF4) {
+  if constexpr (F4_T == BTLA_DTYPE::F4_NF4) {
     auto zp = _mm512_set1_ps(0.8480964004993439f);
     zmm0 = _mm512_add_ps(zmm0, zp);
   } else {
     mask1 = _mm512_cmp_ps_mask(zmm0, zmm_v0, 1);
     zmm0 = _mm512_abs_ps(zmm0);
   }
-  constexpr int loop_num = F4_T == JBLAS_DTYPE::F4_NF4 ? 16 : 8;
+  constexpr int loop_num = F4_T == BTLA_DTYPE::F4_NF4 ? 16 : 8;
   for (int i = 0; i < loop_num; i++) {
     __m512 sub_v;
-    if constexpr (F4_T == JBLAS_DTYPE::F4_NF4) sub_v = _mm512_set1_ps(F4_NF4_quant_sub_helper[i]);
-    if constexpr (F4_T == JBLAS_DTYPE::F4_BNB) sub_v = _mm512_set1_ps(F4_BNB_quant_sub_helper[i]);
-    if constexpr (F4_T == JBLAS_DTYPE::F4_E2M1) sub_v = _mm512_set1_ps(F4_E2M1_quant_sub_helper[i]);
+    if constexpr (F4_T == BTLA_DTYPE::F4_NF4) sub_v = _mm512_set1_ps(F4_NF4_quant_sub_helper[i]);
+    if constexpr (F4_T == BTLA_DTYPE::F4_BNB) sub_v = _mm512_set1_ps(F4_BNB_quant_sub_helper[i]);
+    if constexpr (F4_T == BTLA_DTYPE::F4_E2M1) sub_v = _mm512_set1_ps(F4_E2M1_quant_sub_helper[i]);
     zmm1 = _mm512_sub_ps(zmm0, sub_v);
     mask0 = _mm512_cmp_ps_mask(zmm1, zmm_v0, 2);
     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) {
+  if constexpr (F4_T != BTLA_DTYPE::F4_NF4) {
     auto xmm_bias = _mm_set1_epi8(0x08);
     xmm0 = _mm_mask_add_epi8(xmm0, mask1, xmm0, xmm_bias);
   }
@@ -997,17 +997,16 @@ constexpr auto broadcast_F4_NF4_quantv = broadcast_N_2_Nx16<16>(F4_NF4_simd_quan
 constexpr auto broadcast_F4_BNB_quantv = broadcast_N_2_Nx16<8>(F4_BNB_simd_quant_v);
 constexpr auto broadcast_F4_E2M1_quantv = broadcast_N_2_Nx16<8>(F4_E2M1_simd_quant_v);
 
-template <JBLAS_DTYPE F4_T>
-inline JBLAS_CODE quantize_f32_f4_rowblock(const float* srcptr, int8_t* dstptr, int row, int col, int ld_src,
-                                           int ld_dst, float* scales, int8_t* zero_points, int blocksize) {
+template <BTLA_DTYPE F4_T>
+inline BTLA_CODE quantize_f32_f4_rowblock(const float* srcptr, int8_t* dstptr, int row, int col, int ld_src, int ld_dst,
+                                          float* scales, int8_t* zero_points, int blocksize) {
   // assert(col % 16 == 0);
   auto align_row = row / blocksize * blocksize;
   auto align_blk = blocksize / 4 * 4;
   int8_t* broadcast_f4_quantv;
-  if constexpr (F4_T == JBLAS_DTYPE::F4_NF4) broadcast_f4_quantv = const_cast<int8_t*>(broadcast_F4_NF4_quantv.data());
-  if constexpr (F4_T == JBLAS_DTYPE::F4_BNB) broadcast_f4_quantv = const_cast<int8_t*>(broadcast_F4_BNB_quantv.data());
-  if constexpr (F4_T == JBLAS_DTYPE::F4_E2M1)
-    broadcast_f4_quantv = const_cast<int8_t*>(broadcast_F4_E2M1_quantv.data());
+  if constexpr (F4_T == BTLA_DTYPE::F4_NF4) broadcast_f4_quantv = const_cast<int8_t*>(broadcast_F4_NF4_quantv.data());
+  if constexpr (F4_T == BTLA_DTYPE::F4_BNB) broadcast_f4_quantv = const_cast<int8_t*>(broadcast_F4_BNB_quantv.data());
+  if constexpr (F4_T == BTLA_DTYPE::F4_E2M1) broadcast_f4_quantv = const_cast<int8_t*>(broadcast_F4_E2M1_quantv.data());
   int i = 0;
   int align_col = col / 16 * 16;
 
@@ -1045,13 +1044,13 @@ inline JBLAS_CODE quantize_f32_f4_rowblock(const float* srcptr, int8_t* dstptr,
   for (; i < align_col; i += 16) process_row_blk(i, 16);
   if (i < col) process_row_blk(i, col - i);
 
-  return JblasSuccess;
+  return BTLA_CODE::Success;
 }
 
 template <typename SRC_T>
-static inline JBLAS_CODE quantize_fp_u8_colblock(int row, int col, const SRC_T* srcptr, int ld_src, uint8_t* dstptr,
-                                                 int ld_dst, float* scales, int ld_scale, uint8_t* zps, int blocksize,
-                                                 float* blkreduce) {
+static inline BTLA_CODE quantize_fp_u8_colblock(int row, int col, const SRC_T* srcptr, int ld_src, uint8_t* dstptr,
+                                                int ld_dst, float* scales, int ld_scale, uint8_t* zps, int blocksize,
+                                                float* blkreduce) {
   int constexpr VLen = 16;
   auto vff = _mm512_set1_epi32(255);
   auto v0 = _mm512_set1_epi32(0);
@@ -1153,13 +1152,12 @@ static inline JBLAS_CODE quantize_fp_u8_colblock(int row, int col, const SRC_T*
       }
     }
   }
-  return JblasSuccess;
+  return BTLA_CODE::Success;
 }
 
 template <typename SRC_T>
-static inline JBLAS_CODE quantize_fp_s8_colblock(int row, int col, const SRC_T* srcptr, int ld_src, int8_t* dstptr,
-                                                 int ld_dst, float* scales, int ld_scale, int blocksize,
-                                                 float* reduce) {
+static inline BTLA_CODE quantize_fp_s8_colblock(int row, int col, const SRC_T* srcptr, int ld_src, int8_t* dstptr,
+                                                int ld_dst, float* scales, int ld_scale, int blocksize, float* reduce) {
   int constexpr VLen = 16;
   auto vpos = _mm512_set1_epi32(127);
   auto vneg = _mm512_set1_epi32(-128);
@@ -1238,12 +1236,12 @@ static inline JBLAS_CODE quantize_fp_s8_colblock(int row, int col, const SRC_T*
       if (reduce) reduce[j / blocksize + i * ld_scale] = sum * scale;
     }
   }
-  return JblasSuccess;
+  return BTLA_CODE::Success;
 }
 
-static inline JBLAS_CODE alphabeta_f32_f32(const float alpha, const float* srcptr, const int srcstep, const float beta,
-                                           const float* src1ptr, const int src1step, float* dstptr, const int dststep,
-                                           const int M, const int N) {
+static inline BTLA_CODE alphabeta_f32_f32(const float alpha, const float* srcptr, const int srcstep, const float beta,
+                                          const float* src1ptr, const int src1step, float* dstptr, const int dststep,
+                                          const int M, const int N) {
   int constexpr Vlen = 16;
   auto vN = utils::padto_le(N, Vlen);
   auto valpha = _mm512_set1_ps(alpha);
@@ -1273,12 +1271,12 @@ static inline JBLAS_CODE alphabeta_f32_f32(const float alpha, const float* srcpt
       }
     }
   }
-  return JblasSuccess;
+  return BTLA_CODE::Success;
 }
 
-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) {
+template <BTLA_DTYPE S4_T, typename _DST_T>
+inline BTLA_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(*reinterpret_cast<int*>(&mask));
   if (col == ld_src) {
@@ -1307,16 +1305,16 @@ 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>(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)));
+      dstptr[i + 0] = static_cast<_DST_T>(static_cast<float>(kernel::ref::get_s8<S4_T>(tmp.x)));
+      dstptr[i + 1] = static_cast<_DST_T>(static_cast<float>(kernel::ref::get_s8<S4_T>(tmp.y)));
     }
-    return JblasSuccess;
+    return BTLA_CODE::Success;
   }
-  return JblasNotSupport;
+  return BTLA_CODE::NotSupport;
 }
 
 template <typename DST_T>
-inline JBLAS_CODE decompress_kblock_s8_s8fp(int8_t* srcptr, DST_T* dstptr, int row, int col, int ld_src, int ld_dst) {
+inline BTLA_CODE decompress_kblock_s8_s8fp(int8_t* srcptr, DST_T* dstptr, int row, int col, int ld_src, int ld_dst) {
   if (col == ld_src) {
     size_t elesize = (size_t)row * col;
     size_t ele64 = utils::padto_le(elesize, 64);
@@ -1332,14 +1330,14 @@ inline JBLAS_CODE decompress_kblock_s8_s8fp(int8_t* srcptr, DST_T* dstptr, int r
       auto tmp = srcptr[i];
       dstptr[i] = static_cast<DST_T>(static_cast<float>(tmp));
     }
-    return JblasSuccess;
+    return BTLA_CODE::Success;
   }
-  return JblasNotSupport;
+  return BTLA_CODE::NotSupport;
 }
 
 template <typename SCA_T>
-static inline JBLAS_CODE accum_alphaN_f32_f32(const SCA_T* alpha, const float* srcptr, const int srcstep, float* dstptr,
-                                              const int dststep, const int M, const int N) {
+static inline BTLA_CODE accum_alphaN_f32_f32(const SCA_T* alpha, const float* srcptr, const int srcstep, float* dstptr,
+                                             const int dststep, const int M, const int N) {
   int constexpr Vlen = 16;
   auto vN = utils::padto_le(N, Vlen);
   int j = 0;
@@ -1371,11 +1369,11 @@ static inline JBLAS_CODE accum_alphaN_f32_f32(const SCA_T* alpha, const float* s
       }
     }
   }
-  return JblasSuccess;
+  return BTLA_CODE::Success;
 }
 
-static inline JBLAS_CODE accum_f32_f32(const float* srcptr, const int srcstep, float* dstptr, const int dststep,
-                                       const int M, const int N) {
+static inline BTLA_CODE accum_f32_f32(const float* srcptr, const int srcstep, float* dstptr, const int dststep,
+                                      const int M, const int N) {
   int constexpr Vlen = 16;
   auto vN = utils::padto_le(N, Vlen);
   int j = 0;
@@ -1392,7 +1390,7 @@ static inline JBLAS_CODE accum_f32_f32(const float* srcptr, const int srcstep, f
       dstptr[i * dststep + j] += srcptr[i * srcstep + j];
     }
   }
-  return JblasSuccess;
+  return BTLA_CODE::Success;
 }
 
 static inline void vec_quanout_s32_u32_v16(const int32_t* srcptr, __m512& vfactor, __m512i& vzp, __m512i& vzeros,
@@ -1407,9 +1405,9 @@ static inline void vec_quanout_s32_u32_v16(const int32_t* srcptr, __m512& vfacto
   _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,
-                                         const int dststep, const int M, const int N, float scaleSrc, float scaleDst,
-                                         int zpDst) {
+static inline BTLA_CODE quanout_s32_u32(const float alpha, const int32_t* srcptr, const int srcstep, uint8_t* dstptr,
+                                        const int dststep, const int M, const int N, float scaleSrc, float scaleDst,
+                                        int zpDst) {
   float factor = alpha * scaleSrc / scaleDst;
   auto vfactor = _mm512_set1_ps(factor);
   auto vzp = _mm512_set1_epi32(zpDst);
@@ -1444,12 +1442,12 @@ static inline JBLAS_CODE quanout_s32_u32(const float alpha, const int32_t* srcpt
       dstptr[i * dststep + j] = utils::cast<float, uint8_t>(fsrc + static_cast<float>(zpDst));
     }
   }
-  return JblasSuccess;
+  return BTLA_CODE::Success;
 }
 
-static inline JBLAS_CODE accumulate_dequantize_s32_f32(const int32_t* srcptr, float* dstptr, float alpha, float beta,
-                                                       int row, int col, int ld_src, int ld_dst, float* ascales,
-                                                       int ldas, float* wscales) {
+static inline BTLA_CODE accumulate_dequantize_s32_f32(const int32_t* srcptr, float* dstptr, float alpha, float beta,
+                                                      int row, int col, int ld_src, int ld_dst, float* ascales,
+                                                      int ldas, float* wscales) {
   auto vbeta = _mm512_set1_ps(beta);
   int col16 = utils::padto_le(col, 16);
   for (int irow = 0; irow < row; irow++) {
@@ -1471,13 +1469,13 @@ static inline JBLAS_CODE accumulate_dequantize_s32_f32(const int32_t* srcptr, fl
           scale * wscales[icol] * srcptr[irow * ld_src + icol] + beta * dstptr[irow * ld_dst + icol];
     }
   }
-  return JblasSuccess;
+  return BTLA_CODE::Success;
 }
 
 template <typename SCAB_T>
-static inline JBLAS_CODE dequant_s32_fp32(const int32_t* srcptr, const int srcstep, float* dstptr, const int dststep,
-                                          const int row, const int col, const float* scaleA, const int ldsa,
-                                          const SCAB_T* scaleB) {
+static inline BTLA_CODE dequant_s32_fp32(const int32_t* srcptr, const int srcstep, float* dstptr, const int dststep,
+                                         const int row, const int col, const float* scaleA, const int ldsa,
+                                         const SCAB_T* scaleB) {
   int col16 = utils::padto_le(col, 16);
   int col64 = utils::padto_le(col, 64);
   for (int irow = 0; irow < row; irow++) {
@@ -1520,10 +1518,10 @@ static inline JBLAS_CODE dequant_s32_fp32(const int32_t* srcptr, const int srcst
       dstptr[irow * dststep + icol] = scale * scaleB[icol] * srcptr[irow * srcstep + icol];
     }
   }
-  return JblasSuccess;
+  return BTLA_CODE::Success;
 }
 
-static inline JBLAS_CODE broadcast_u8(int num, const uint8_t& srcval, uint8_t* dstptr) {
+static inline BTLA_CODE broadcast_u8(int num, const uint8_t& srcval, uint8_t* dstptr) {
   int i = 0;
   int constexpr VN = 64 / sizeof(srcval);
   int numv = utils::padto_le(num, VN);
@@ -1540,11 +1538,11 @@ static inline JBLAS_CODE broadcast_u8(int num, const uint8_t& srcval, uint8_t* d
   for (; i < num; i++) {
     dstptr[i] = srcval;
   }
-  return JblasSuccess;
+  return BTLA_CODE::Success;
 }
 
-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) {
+static inline BTLA_CODE remove_act_zeropoint_bias(float* accptr, int ldacc, int row, int col, uint8_t* zps,
+                                                  float* scales, int lds, const float* reduce) {
   int constexpr VLen = 16;
   auto col16 = utils::padto_le(col, VLen);
   for (int i = 0; i < row; i++) {
@@ -1563,11 +1561,11 @@ static inline JBLAS_CODE remove_act_zeropoint_bias(float* accptr, int ldacc, int
       }
     }
   }
-  return JblasSuccess;
+  return BTLA_CODE::Success;
 }
 
-static inline JBLAS_CODE remove_wei_zeropoint_bias(float* accptr, int ldacc, int row, int col, int8_t* zps,
-                                                   float* scales, int lds, const float* reduce) {
+static inline BTLA_CODE remove_wei_zeropoint_bias(float* accptr, int ldacc, int row, int col, int8_t* zps,
+                                                  float* scales, int lds, const float* reduce) {
   int constexpr VLen = 16;
   auto col16 = utils::padto_le(col, VLen);
   for (int i = 0; i < row; i++) {
@@ -1587,12 +1585,12 @@ static inline JBLAS_CODE remove_wei_zeropoint_bias(float* accptr, int ldacc, int
       }
     }
   }
-  return JblasSuccess;
+  return BTLA_CODE::Success;
 }
 
-static inline JBLAS_CODE remove_zeropoint_bias(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 BTLA_CODE remove_zeropoint_bias(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) {
   int constexpr VLen = 16;
   auto col16 = utils::padto_le(col, VLen);
   auto vk = _mm512_set1_ps(static_cast<float>(k));
@@ -1622,11 +1620,11 @@ static inline JBLAS_CODE remove_zeropoint_bias(float* accptr, int ldacc, int row
       }
     }
   }
-  return JblasSuccess;
+  return BTLA_CODE::Success;
 }
 
-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) {
+static inline BTLA_CODE fp32_cvt_bf16_2D_write_back(const void* raw_srcptr, void* raw_dstptr, int row, int col,
+                                                    int srcstride, int dststride, bool zeropadding) {
   auto srcptr = reinterpret_cast<const char*>(raw_srcptr);
   auto dstptr = reinterpret_cast<char*>(raw_dstptr);
   constexpr int simd_proc_elt = 16;
@@ -1646,8 +1644,7 @@ 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(reinterpret_cast<__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(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);
@@ -1656,19 +1653,19 @@ 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(reinterpret_cast<__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(utils::bf16)), tail_mask,
+                               pack_bf16_tail);
     }
     if (zeropadding && npadding) {
       std::memset(dst + col * sizeof(utils::bf16), 0, npadding);
     }
   }
-  return JblasSuccess;
+  return BTLA_CODE::Success;
 }
 
 template <typename SRC_T>
-static inline JBLAS_CODE col_block_reduce_sum(const SRC_T* srcptr, int ldsrc, int row, int col, int blocksize,
-                                              float* reduce, int ldr) {
+static inline BTLA_CODE col_block_reduce_sum(const SRC_T* srcptr, int ldsrc, int row, int col, int blocksize,
+                                             float* reduce, int ldr) {
   int constexpr VLen = 16;
   auto vblock2_ = utils::padto_le(blocksize, VLen * 2);
   auto vblock_ = utils::padto_le(blocksize, VLen);
@@ -1700,11 +1697,11 @@ static inline JBLAS_CODE col_block_reduce_sum(const SRC_T* srcptr, int ldsrc, in
       reduce[i * ldr + j / blocksize] = tmp;
     }
   }
-  return JblasSuccess;
+  return BTLA_CODE::Success;
 }
 
-static inline JBLAS_CODE fp32_cvt_fp16_2D_write_back(const float* src_ptr, utils::fp16* dst_ptr, int row, int col,
-                                                     int src_step, int dst_step, bool zeropadding) {
+static inline BTLA_CODE fp32_cvt_fp16_2D_write_back(const float* src_ptr, utils::fp16* dst_ptr, int row, int col,
+                                                    int src_step, int dst_step, bool zeropadding) {
 #if CompileFP16()
   const int npadding = (dst_step - col) * sizeof(utils::fp16);
   constexpr int simd_proc_elt = 16;
@@ -1724,14 +1721,14 @@ static inline JBLAS_CODE fp32_cvt_fp16_2D_write_back(const float* src_ptr, utils
     }
     if (zeropadding && npadding) std::memset(dst + col, 0, npadding);
   }
-  return JblasSuccess;
+  return BTLA_CODE::Success;
 #else
-  return JblasNotSupport;
+  return BTLA_CODE::NotSupport;
 #endif
 }
 
-static inline JBLAS_CODE fp16_cvt_fp32_2D_write_back(const utils::fp16* src_ptr, float* dst_ptr, int row, int col,
-                                                     int src_step, int dst_step, bool zeropadding) {
+static inline BTLA_CODE fp16_cvt_fp32_2D_write_back(const utils::fp16* src_ptr, float* dst_ptr, int row, int col,
+                                                    int src_step, int dst_step, bool zeropadding) {
 #if CompileFP16()
   const int npadding = (dst_step - col) * sizeof(float);
   constexpr int simd_proc_elt = 16;
@@ -1751,14 +1748,14 @@ static inline JBLAS_CODE fp16_cvt_fp32_2D_write_back(const utils::fp16* src_ptr,
     }
     if (zeropadding && npadding) std::memset(dst + col, 0, npadding);
   }
-  return JblasSuccess;
+  return BTLA_CODE::Success;
 #else
-  return JblasNotSupport;
+  return BTLA_CODE::NotSupport;
 #endif
 }
 
-static inline JBLAS_CODE bf16_cvt_fp32_2D_write_back(const utils::bf16* src_ptr, float* dst_ptr, int row, int col,
-                                                     int src_step, int dst_step, bool zeropadding) {
+static inline BTLA_CODE bf16_cvt_fp32_2D_write_back(const utils::bf16* src_ptr, float* dst_ptr, int row, int col,
+                                                    int src_step, int dst_step, bool zeropadding) {
   const int npadding = (dst_step - col) * sizeof(float);
   constexpr int simd_proc_elt = 16;
   auto col_body = col / simd_proc_elt * simd_proc_elt;
@@ -1780,7 +1777,7 @@ static inline JBLAS_CODE bf16_cvt_fp32_2D_write_back(const utils::bf16* src_ptr,
               _mm512_cvtepu16_epi32(_mm256_castps_si256(_mm256_loadu_ps(reinterpret_cast<float*>(src + j)))), 2)));
     if (zeropadding && npadding) std::memset(dst + col, 0, npadding);
   }
-  return JblasSuccess;
+  return BTLA_CODE::Success;
 }
 
 #ifdef __GNUC__
@@ -1946,9 +1943,9 @@ static constexpr decltype(load_maskz_fp16_bf16_tr_x16_dword<1>)* load_maskz_fp16
 template <typename T_SRC, typename T_DST = T_SRC, int RowPack = 4 / sizeof(T_DST)>
 struct padding_interleave_cvt {
   padding_interleave_cvt() = delete;
-  static JBLAS_CODE forward(const T_SRC* src, T_DST* dst, int NTile, int row, int col, int row_pad, int col_pad,
-                            int src_step, int dst_step) {
-    return JblasNotSupport;
+  static BTLA_CODE forward(const T_SRC* src, T_DST* dst, int NTile, int row, int col, int row_pad, int col_pad,
+                           int src_step, int dst_step) {
+    return BTLA_CODE::NotSupport;
   }
 };
 #if CompileBF16() && CompileFP16()
@@ -1958,8 +1955,8 @@ struct padding_interleave_cvt<utils::fp16, utils::bf16, 2> {
   padding_interleave_cvt() = delete;
 
   // M x N ===> N/NTile x M/RowPack x NTile x RowPack (leading dim stride = NTile * dststride)
-  static JBLAS_CODE forward(const utils::fp16* src, utils::bf16* dst, int NTile, int row, int col, int row_pad,
-                            int col_pad, int src_step, int dst_step) {
+  static BTLA_CODE forward(const utils::fp16* src, utils::bf16* dst, int NTile, int row, int col, int row_pad,
+                           int col_pad, int src_step, int dst_step) {
     int i = 0;
     for (; i < row / RowPack * RowPack; i += RowPack) {
       int j = 0;
@@ -2034,7 +2031,7 @@ struct padding_interleave_cvt<utils::fp16, utils::bf16, 2> {
         memset(dst + i * NTile + j * dst_step, 0, sizeof(utils::bf16) * NTile * RowPack);
       }
     }
-    return JblasSuccess;
+    return BTLA_CODE::Success;
   }
 };
 #endif
@@ -2042,9 +2039,9 @@ struct padding_interleave_cvt<utils::fp16, utils::bf16, 2> {
 template <typename T_SRC, typename T_DST = T_SRC, int ColPack = 4 / sizeof(T_DST)>
 struct padding_trans_interleave_cvt {
   padding_trans_interleave_cvt() = delete;
-  static JBLAS_CODE forward(const T_SRC* src, T_DST* dst, int MTile, int row, int col, int row_pad, int col_pad,
-                            int src_step, int dst_step) {
-    return JblasNotSupport;
+  static BTLA_CODE forward(const T_SRC* src, T_DST* dst, int MTile, int row, int col, int row_pad, int col_pad,
+                           int src_step, int dst_step) {
+    return BTLA_CODE::NotSupport;
   }
 };
 #if CompileBF16() && CompileFP16()
@@ -2053,8 +2050,8 @@ struct padding_trans_interleave_cvt<utils::fp16, utils::bf16, 2> {
   static constexpr int ColPack = 2;
   padding_trans_interleave_cvt() = delete;
 
-  static JBLAS_CODE forward(const utils::fp16* src, utils::bf16* dst, int MTile, int row, int col, int row_pad,
-                            int col_pad, int src_step, int dst_step) {
+  static BTLA_CODE forward(const utils::fp16* src, utils::bf16* dst, int MTile, int row, int col, int row_pad,
+                           int col_pad, int src_step, int dst_step) {
     assert(row_pad % 16 == 0 && col_pad % 32 == 0);
     int i = 0;
     for (; i < row / MTile * MTile; i += MTile) {
@@ -2147,7 +2144,7 @@ struct padding_trans_interleave_cvt<utils::fp16, utils::bf16, 2> {
         memset(dst + i * dst_step + j * MTile, 0, 2 * sizeof(utils::bf16) * MTile);
       }
     }
-    return JblasSuccess;
+    return BTLA_CODE::Success;
   }
 };
 #endif
@@ -2159,4 +2156,4 @@ struct padding_trans_interleave_cvt<utils::fp16, utils::bf16, 2> {
 #endif
 }  // namespace avx512f
 }  // namespace kernel
-}  // namespace jblas
+}  // namespace bestla
diff --git a/bestla/jblas/kernel_jit.h b/bestla/bestla/kernel_jit.h
similarity index 90%
rename from bestla/jblas/kernel_jit.h
rename to bestla/bestla/kernel_jit.h
index 4a711736e..718c47e25 100644
--- a/bestla/jblas/kernel_jit.h
+++ b/bestla/bestla/kernel_jit.h
@@ -20,20 +20,19 @@
 #include <unordered_map>
 #include <vector>
 
-#include "jblas/jit_blas.h"
-#include "jblas/jit_blas_device.h"
-#include "jblas/xbyak/xbyak.h"
-#include "jit_base.h"
-#include "jit_blas_utils.h"
+#include "bestla.h"
+#include "bestla_device.h"
+#include "bestla_utils.h"
+#include "bestla_jit.h"
 #include "kernel_jit_injector.h"
 
-namespace jblas {
+namespace bestla {
 namespace kernel {
 namespace jit {
 
 class DequanS8FP {
  public:
-  class MicroKernelAVX512F : protected jblas::xbyak::JitAvx512f {
+  class MicroKernelAVX512F : protected xbyak::JitAvx512f {
    public:
     struct params {
       void *srcptr, *dstptr;
@@ -47,15 +46,15 @@ class DequanS8FP {
     static int constexpr RegScale = 0;
     static int constexpr RegZP = 4;
     static int constexpr RegTmp = RegScale + 8;
-    MicroKernelAVX512F(JBLAS_DTYPE dst_dt, bool is_sym_, int pack_row) {
-      assert(dst_dt == JBLAS_DTYPE::F32 || dst_dt == JBLAS_DTYPE::BF16);
+    MicroKernelAVX512F(BTLA_DTYPE dst_dt, bool is_sym_, int pack_row) {
+      assert(dst_dt == BTLA_DTYPE::F32 || dst_dt == BTLA_DTYPE::BF16);
       is_sym = is_sym_;
       generate(dst_dt, pack_row);
       this->ready();
       mKernel = this->getCode<func_t>();
     }
 
-    void generate(JBLAS_DTYPE dst_dt, int pack_row) {
+    void generate(BTLA_DTYPE dst_dt, int pack_row) {
       assert(pack_row == 1 || pack_row == 2 || pack_row == 4);
       int scale_step = 64 / pack_row;
       Xbyak::Label data_label;
@@ -101,11 +100,11 @@ class DequanS8FP {
         }
 
         auto get_dst_step = [&] {
-          if (dst_dt == JBLAS_DTYPE::BF16) return 2;
+          if (dst_dt == BTLA_DTYPE::BF16) return 2;
           return 4;  // f32 case.
         };
 
-        auto generateNTile = [&](int N, JBLAS_DTYPE dst_dt, int scale_step, std::string row_label) {
+        auto generateNTile = [&](int N, BTLA_DTYPE dst_dt, int scale_step, std::string row_label) {
           if (pack_row == 2) {
             vmovups(Xbyak::Zmm(RegTmp), ptr[rip + data_label + 8]);
           } else if (pack_row == 4) {
@@ -131,10 +130,10 @@ class DequanS8FP {
             }
             vcvtdq2ps(Xbyak::Zmm(RegTmp), Xbyak::Zmm(RegTmp));
             vmulps(Xbyak::Zmm(RegTmp), Xbyak::Zmm(RegScale + i));
-            if (dst_dt == JBLAS_DTYPE::F32) {
+            if (dst_dt == BTLA_DTYPE::F32) {
               vmovups(ptr[reg_tmp1 + i * 64], Xbyak::Zmm(RegTmp));
             }
-            if (dst_dt == JBLAS_DTYPE::BF16) {
+            if (dst_dt == BTLA_DTYPE::BF16) {
               Xbyak::Ymm ymm_v = Xbyak::Ymm(RegTmp);
               Xbyak::Zmm zmm_v = Xbyak::Zmm(RegTmp);
               if (device::CpuDevice::getInstance()->AVX512_BF16()) {
@@ -230,8 +229,8 @@ class DequanS8FP {
   template <int PACK_ROW, typename _DST_T>
   static void forward_avx512f(int8_t* srcptr, _DST_T* dstptr, int row, int col, int ld_src, int ld_dst, float* scales,
                               int8_t* zero_points) {
-    static MicroKernelAVX512F mAVX512FSym(utils::jblas_dtype<_DST_T>, true, PACK_ROW);
-    static MicroKernelAVX512F mAVX512FASym(utils::jblas_dtype<_DST_T>, false, PACK_ROW);
+    static MicroKernelAVX512F mAVX512FSym(utils::bestla_dtype<_DST_T>, true, PACK_ROW);
+    static MicroKernelAVX512F mAVX512FASym(utils::bestla_dtype<_DST_T>, false, PACK_ROW);
     auto param = MicroKernelAVX512F::params{srcptr,
                                             dstptr,
                                             row,
@@ -251,8 +250,8 @@ class DequanS8FP {
 class DequanKBlockS8Fp {
  public:
   template <int _PACK_ROW, typename _ST, typename _DST_T>
-  static inline JBLAS_CODE forward_avx512f(int8_t* srcptr, _DST_T* dstptr, int row, int col, int ld_src, int ld_dst,
-                                           _ST* scales, int8_t* zero_points, int k_offset, int kblock, int NPad) {
+  static inline BTLA_CODE forward_avx512f(int8_t* srcptr, _DST_T* dstptr, int row, int col, int ld_src, int ld_dst,
+                                          _ST* scales, int8_t* zero_points, int k_offset, int kblock, int NPad) {
     int row0 = kblock - k_offset % kblock;
     row0 = row0 == kblock ? 0 : row0;
     row0 = row0 > row ? row : row0;
@@ -279,7 +278,7 @@ class DequanKBlockS8Fp {
     if (row2 > 0) {
       DequanS8FP::forward_avx512f<_PACK_ROW>(srcptr, dstptr, row2, col, ld_src, ld_dst, sptr, zptr);
     }
-    return JblasSuccess;
+    return BTLA_CODE::Success;
   }
 };
 
@@ -292,25 +291,24 @@ struct DataConvertConfig {
     FP32_TO_F16,
   };
 
-  DataConvertConfig(JBLAS_DTYPE src_t, JBLAS_DTYPE dst_t,
-                    std::vector<kernel::jit_injector::eltwise_injector> injectors) {
+  DataConvertConfig(BTLA_DTYPE src_t, BTLA_DTYPE dst_t, std::vector<kernel::jit_injector::eltwise_injector> injectors) {
     input_dt = src_t;
     output_dt = dst_t;
     if (injectors.size() != 0) {
-      assert(src_t == JBLAS_DTYPE::F32 || src_t == JBLAS_DTYPE::BF16 || src_t == JBLAS_DTYPE::F16);
-      if (src_t == JBLAS_DTYPE::BF16) before_postop = DataConvertConfig::cvt_direct::BF16_TO_FP32;
-      if (src_t == JBLAS_DTYPE::F16) before_postop = DataConvertConfig::cvt_direct::F16_TO_FP32;
+      assert(src_t == BTLA_DTYPE::F32 || src_t == BTLA_DTYPE::BF16 || src_t == BTLA_DTYPE::F16);
+      if (src_t == BTLA_DTYPE::BF16) before_postop = DataConvertConfig::cvt_direct::BF16_TO_FP32;
+      if (src_t == BTLA_DTYPE::F16) before_postop = DataConvertConfig::cvt_direct::F16_TO_FP32;
     }
     // once contain postop, data_type before store will be fp32.
-    if (injectors.size() != 0 || src_t == JBLAS_DTYPE::F32) {
-      if (dst_t == JBLAS_DTYPE::BF16) before_store = DataConvertConfig::cvt_direct::FP32_TO_BF16;
-      if (dst_t == JBLAS_DTYPE::F16) {
+    if (injectors.size() != 0 || src_t == BTLA_DTYPE::F32) {
+      if (dst_t == BTLA_DTYPE::BF16) before_store = DataConvertConfig::cvt_direct::FP32_TO_BF16;
+      if (dst_t == BTLA_DTYPE::F16) {
         if (!device::CpuDevice::getInstance()->AVX512_FP16()) assert(0);
         before_store = DataConvertConfig::cvt_direct::FP32_TO_F16;
       }
-    } else if (src_t == JBLAS_DTYPE::BF16 && dst_t == JBLAS_DTYPE::F32) {
+    } else if (src_t == BTLA_DTYPE::BF16 && dst_t == BTLA_DTYPE::F32) {
       before_store = DataConvertConfig::cvt_direct::BF16_TO_FP32;
-    } else if (src_t == JBLAS_DTYPE::F16 && dst_t == JBLAS_DTYPE::F32) {
+    } else if (src_t == BTLA_DTYPE::F16 && dst_t == BTLA_DTYPE::F32) {
       assert(device::CpuDevice::getInstance()->AVX512_FP16());
       before_store = DataConvertConfig::cvt_direct::F16_TO_FP32;
     }
@@ -328,7 +326,7 @@ struct DataConvertConfig {
 
   cvt_direct before_postop = cvt_direct::NO_CVT;
   cvt_direct before_store = cvt_direct::NO_CVT;
-  JBLAS_DTYPE input_dt, output_dt;
+  BTLA_DTYPE input_dt, output_dt;
 };
 
 template <typename SIMD_REG>
@@ -339,7 +337,7 @@ struct MemcpyStoreParam {
   Xbyak::Opmask store_mask = Xbyak::util::k1;
 };
 
-class JitMemcpy2DAvx2 : protected jblas::xbyak::JitAvx2 {
+class JitMemcpy2DAvx2 : protected xbyak::JitAvx2 {
  public:
   struct params {
     void *srcptr, *dstptr, *elt_const_v;
@@ -349,29 +347,29 @@ class JitMemcpy2DAvx2 : protected jblas::xbyak::JitAvx2 {
 
  public:
   static int constexpr VBytes = 32;
-  JitMemcpy2DAvx2(int unroll_row, JBLAS_DTYPE src_t, JBLAS_DTYPE dst_t,
+  JitMemcpy2DAvx2(int unroll_row, BTLA_DTYPE src_t, BTLA_DTYPE dst_t,
                   std::vector<kernel::jit_injector::eltwise_injector> injectors = {}) {
     DataConvertConfig dt_cvt_cfg(src_t, dst_t, injectors);
     generate(unroll_row, injectors, dt_cvt_cfg);
   }
 
   template <typename _SRC_T, typename _DST_T>
-  static JBLAS_CODE forward(const _SRC_T* srcptr, _DST_T* dstptr, int row, int col, int srcstep, int dststep,
-                            void* elt_const_v = nullptr) {
-    static JitMemcpy2DAvx2 instance_withops(1, utils::jblas_dtype<_SRC_T>, utils::jblas_dtype<_DST_T>);
+  static BTLA_CODE forward(const _SRC_T* srcptr, _DST_T* dstptr, int row, int col, int srcstep, int dststep,
+                           void* elt_const_v = nullptr) {
+    static JitMemcpy2DAvx2 instance_withops(1, utils::bestla_dtype<_SRC_T>, utils::bestla_dtype<_DST_T>);
     for (int i = 0; i < row; i++) {
       auto param = params{reinterpret_cast<char*>(const_cast<_SRC_T*>(srcptr)) + i * srcstep * sizeof(_SRC_T),
                           reinterpret_cast<char*>(dstptr) + i * dststep * sizeof(_DST_T), elt_const_v,
                           static_cast<int>(col * sizeof(_SRC_T))};
       instance_withops.mKernel(&param);
     }
-    return JblasSuccess;
+    return BTLA_CODE::Success;
   }
 
-  template <typename _SRC_T, typename _DST_T, JBLAS_ELTWISEOP Op>
-  static JBLAS_CODE forward1(const _SRC_T* srcptr, _DST_T* dstptr, int row, int col, int srcstep, int dststep,
-                             void* elt_const_v = nullptr) {
-    static JitMemcpy2DAvx2 instance_withops(1, utils::jblas_dtype<_SRC_T>, utils::jblas_dtype<_DST_T>,
+  template <typename _SRC_T, typename _DST_T, BTLA_ELTWISEOP Op>
+  static BTLA_CODE forward1(const _SRC_T* srcptr, _DST_T* dstptr, int row, int col, int srcstep, int dststep,
+                            void* elt_const_v = nullptr) {
+    static JitMemcpy2DAvx2 instance_withops(1, utils::bestla_dtype<_SRC_T>, utils::bestla_dtype<_DST_T>,
                                             {kernel::jit_injector::eltwise_injector(Op)});
     for (int i = 0; i < row; i++) {
       auto param = params{reinterpret_cast<char*>(const_cast<_SRC_T*>(srcptr)) + i * srcstep * sizeof(_SRC_T),
@@ -379,7 +377,7 @@ class JitMemcpy2DAvx2 : protected jblas::xbyak::JitAvx2 {
                           static_cast<int>(col * sizeof(_SRC_T))};
       instance_withops.mKernel(&param);
     }
-    return JblasSuccess;
+    return BTLA_CODE::Success;
   }
 
  protected:
@@ -428,16 +426,16 @@ class JitMemcpy2DAvx2 : protected jblas::xbyak::JitAvx2 {
 
       auto unpack_ymm_16bit_withfunc = [&](MemcpyStoreParam<Xbyak::Ymm> p,
                                            std::function<void(MemcpyStoreParam<Xbyak::Ymm>)> func,
-                                           JBLAS_DTYPE BIT16_DT) {
+                                           BTLA_DTYPE BIT16_DT) {
         vmovups(ymm_tmps[0], p.vmm_v);
         Xbyak::Ymm ymm_v = Xbyak::Ymm(p.vmm_v.getIdx());
-        if (BIT16_DT == JBLAS_DTYPE::BF16) {
+        if (BIT16_DT == BTLA_DTYPE::BF16) {
           vpmovzxwd(p.vmm_v, ymm_v);
           vpslld(p.vmm_v, p.vmm_v, 16);
         }
         func(p);
         vextractf128(Xbyak::Xmm(ymm_tmps[0].getIdx()), ymm_tmps[0], 1);
-        if (BIT16_DT == JBLAS_DTYPE::BF16) {
+        if (BIT16_DT == BTLA_DTYPE::BF16) {
           vpmovzxwd(ymm_tmps[0], Xbyak::Ymm(ymm_tmps[0].getIdx()));
           vpslld(ymm_tmps[0], ymm_tmps[0], 16);
         }
@@ -451,7 +449,7 @@ class JitMemcpy2DAvx2 : protected jblas::xbyak::JitAvx2 {
         if (dt_cvt_cfg.before_store == DataConvertConfig::cvt_direct::NO_CVT) {
           store_ymm_v(p);
         } else if (dt_cvt_cfg.before_store == DataConvertConfig::cvt_direct::BF16_TO_FP32) {
-          unpack_ymm_16bit_withfunc(p, store_ymm_v, JBLAS_DTYPE::BF16);
+          unpack_ymm_16bit_withfunc(p, store_ymm_v, BTLA_DTYPE::BF16);
         } else if (dt_cvt_cfg.before_store == DataConvertConfig::cvt_direct::FP32_TO_BF16) {
           Xbyak::Xmm xmm_v = Xbyak::Xmm(p.vmm_v.getIdx());
           Xbyak::Xmm xmm_tmp = Xbyak::Xmm(ymm_tmps[1].getIdx());
@@ -479,7 +477,7 @@ class JitMemcpy2DAvx2 : protected jblas::xbyak::JitAvx2 {
         if (dt_cvt_cfg.before_postop == DataConvertConfig::cvt_direct::NO_CVT) {
           apply_postop_and_store({ymm_v, store_addr});
         } else if (dt_cvt_cfg.before_postop == DataConvertConfig::cvt_direct::BF16_TO_FP32) {
-          unpack_ymm_16bit_withfunc({ymm_v, store_addr}, apply_postop_and_store, JBLAS_DTYPE::BF16);
+          unpack_ymm_16bit_withfunc({ymm_v, store_addr}, apply_postop_and_store, BTLA_DTYPE::BF16);
         } else {
           assert(0);
         }
@@ -549,7 +547,7 @@ class JitMemcpy2DAvx2 : protected jblas::xbyak::JitAvx2 {
   std::set<int> used_ymm_idx;
 };
 
-class JitMemcpy2DAvx512f : protected jblas::xbyak::JitAvx512f {
+class JitMemcpy2DAvx512f : protected xbyak::JitAvx512f {
  public:
   struct params {
     void *srcptr, *dstptr, *elt_const_v;
@@ -559,16 +557,16 @@ class JitMemcpy2DAvx512f : protected jblas::xbyak::JitAvx512f {
 
  public:
   static int constexpr VBytes = 64;
-  JitMemcpy2DAvx512f(int unroll_row, JBLAS_DTYPE src_t, JBLAS_DTYPE dst_t,
+  JitMemcpy2DAvx512f(int unroll_row, BTLA_DTYPE src_t, BTLA_DTYPE dst_t,
                      std::vector<kernel::jit_injector::eltwise_injector> injectors = {}) {
     DataConvertConfig dt_cvt_cfg(src_t, dst_t, injectors);
     generate(unroll_row, injectors, dt_cvt_cfg);
   }
 
   template <typename _SRC_T, typename _DST_T>
-  static JBLAS_CODE forward(const _SRC_T* srcptr, _DST_T* dstptr, int row, int col, int srcstep, int dststep,
-                            void* elt_const_v = nullptr) {
-    static JitMemcpy2DAvx512f instance_withops(1, utils::jblas_dtype<_SRC_T>, utils::jblas_dtype<_DST_T>);
+  static BTLA_CODE forward(const _SRC_T* srcptr, _DST_T* dstptr, int row, int col, int srcstep, int dststep,
+                           void* elt_const_v = nullptr) {
+    static JitMemcpy2DAvx512f instance_withops(1, utils::bestla_dtype<_SRC_T>, utils::bestla_dtype<_DST_T>);
 
     for (int i = 0; i < row; i++) {
       auto param = params{reinterpret_cast<char*>(const_cast<_SRC_T*>(srcptr)) + i * srcstep * sizeof(_SRC_T),
@@ -576,13 +574,13 @@ class JitMemcpy2DAvx512f : protected jblas::xbyak::JitAvx512f {
                           static_cast<int>(col * sizeof(_SRC_T))};
       instance_withops.mKernel(&param);
     }
-    return JblasSuccess;
+    return BTLA_CODE::Success;
   }
 
-  template <typename _SRC_T, typename _DST_T, JBLAS_ELTWISEOP Op>
-  static JBLAS_CODE forward1(const _SRC_T* srcptr, _DST_T* dstptr, int row, int col, int srcstep, int dststep,
-                             void* elt_const_v = nullptr) {
-    static JitMemcpy2DAvx512f instance_withops(1, utils::jblas_dtype<_SRC_T>, utils::jblas_dtype<_DST_T>,
+  template <typename _SRC_T, typename _DST_T, BTLA_ELTWISEOP Op>
+  static BTLA_CODE forward1(const _SRC_T* srcptr, _DST_T* dstptr, int row, int col, int srcstep, int dststep,
+                            void* elt_const_v = nullptr) {
+    static JitMemcpy2DAvx512f instance_withops(1, utils::bestla_dtype<_SRC_T>, utils::bestla_dtype<_DST_T>,
                                                {kernel::jit_injector::eltwise_injector(Op)});
     for (int i = 0; i < row; i++) {
       auto param = params{reinterpret_cast<char*>(const_cast<_SRC_T*>(srcptr)) + i * srcstep * sizeof(_SRC_T),
@@ -590,7 +588,7 @@ class JitMemcpy2DAvx512f : protected jblas::xbyak::JitAvx512f {
                           static_cast<int>(col * sizeof(_SRC_T))};
       instance_withops.mKernel(&param);
     }
-    return JblasSuccess;
+    return BTLA_CODE::Success;
   }
 
  protected:
@@ -634,22 +632,22 @@ class JitMemcpy2DAvx512f : protected jblas::xbyak::JitAvx512f {
 
       auto unpack_zmm_16bit_withfunc = [&](MemcpyStoreParam<Xbyak::Zmm> p,
                                            std::function<void(MemcpyStoreParam<Xbyak::Zmm>)> func,
-                                           JBLAS_DTYPE BIT16_DT) {
+                                           BTLA_DTYPE BIT16_DT) {
         vmovups(zmm_tmps[0], p.vmm_v);
         Xbyak::Ymm ymm_v = Xbyak::Ymm(p.vmm_v.getIdx());
-        if (BIT16_DT == JBLAS_DTYPE::BF16) {
+        if (BIT16_DT == BTLA_DTYPE::BF16) {
           vpmovzxwd(p.vmm_v, ymm_v);
           vpslld(p.vmm_v, p.vmm_v, 16);
         }
-        if (BIT16_DT == JBLAS_DTYPE::F16) vcvtph2psx(p.vmm_v, ymm_v);
+        if (BIT16_DT == BTLA_DTYPE::F16) vcvtph2psx(p.vmm_v, ymm_v);
         p.store_mask = k3;
         func(p);
         vextractf32x8(Xbyak::Ymm(zmm_tmps[0].getIdx()), zmm_tmps[0], 1);
-        if (BIT16_DT == JBLAS_DTYPE::BF16) {
+        if (BIT16_DT == BTLA_DTYPE::BF16) {
           vpmovzxwd(zmm_tmps[0], Xbyak::Ymm(zmm_tmps[0].getIdx()));
           vpslld(zmm_tmps[0], zmm_tmps[0], 16);
         }
-        if (BIT16_DT == JBLAS_DTYPE::F16) vcvtph2psx(zmm_tmps[0], Xbyak::Ymm(zmm_tmps[0].getIdx()));
+        if (BIT16_DT == BTLA_DTYPE::F16) vcvtph2psx(zmm_tmps[0], Xbyak::Ymm(zmm_tmps[0].getIdx()));
         p.vmm_v = zmm_tmps[0];
         p.store_addr = p.store_addr + VBytes;
         p.store_mask = k4;
@@ -661,9 +659,9 @@ class JitMemcpy2DAvx512f : protected jblas::xbyak::JitAvx512f {
         if (dt_cvt_cfg.before_store == DataConvertConfig::cvt_direct::NO_CVT) {
           store_zmm_v(p);
         } else if (dt_cvt_cfg.before_store == DataConvertConfig::cvt_direct::BF16_TO_FP32) {
-          unpack_zmm_16bit_withfunc(p, store_zmm_v, JBLAS_DTYPE::BF16);
+          unpack_zmm_16bit_withfunc(p, store_zmm_v, BTLA_DTYPE::BF16);
         } else if (dt_cvt_cfg.before_store == DataConvertConfig::cvt_direct::F16_TO_FP32) {
-          unpack_zmm_16bit_withfunc(p, store_zmm_v, JBLAS_DTYPE::F16);
+          unpack_zmm_16bit_withfunc(p, store_zmm_v, BTLA_DTYPE::F16);
         } else if (dt_cvt_cfg.before_store == DataConvertConfig::cvt_direct::FP32_TO_BF16) {
           Xbyak::Ymm ymm_v = Xbyak::Ymm(p.vmm_v.getIdx());
           if (device::CpuDevice::getInstance()->AVX512_BF16()) {
@@ -705,9 +703,9 @@ class JitMemcpy2DAvx512f : protected jblas::xbyak::JitAvx512f {
         if (dt_cvt_cfg.before_postop == DataConvertConfig::cvt_direct::NO_CVT) {
           apply_postop_and_store({zmm_v, store_addr, tail});
         } else if (dt_cvt_cfg.before_postop == DataConvertConfig::cvt_direct::BF16_TO_FP32) {
-          unpack_zmm_16bit_withfunc({zmm_v, store_addr, tail}, apply_postop_and_store, JBLAS_DTYPE::BF16);
+          unpack_zmm_16bit_withfunc({zmm_v, store_addr, tail}, apply_postop_and_store, BTLA_DTYPE::BF16);
         } else if (dt_cvt_cfg.before_postop == DataConvertConfig::cvt_direct::F16_TO_FP32) {
-          unpack_zmm_16bit_withfunc({zmm_v, store_addr, tail}, apply_postop_and_store, JBLAS_DTYPE::F16);
+          unpack_zmm_16bit_withfunc({zmm_v, store_addr, tail}, apply_postop_and_store, BTLA_DTYPE::F16);
         } else {
           assert(0);
         }
@@ -738,7 +736,7 @@ class JitMemcpy2DAvx512f : protected jblas::xbyak::JitAvx512f {
         int vbytes = VBytes;
         // consider a case that input==bf16 but apply postop, betore sotre will be fp32_to_bf16 but need to normal gen
         // mask.
-        if (dt_cvt_cfg.input_dt == JBLAS_DTYPE::F32) {
+        if (dt_cvt_cfg.input_dt == BTLA_DTYPE::F32) {
           shr(reg_iter, 1);
           shr(reg_size, 1);
           vbytes /= 2;
@@ -807,7 +805,7 @@ static inline Xbyak::Zmm unpack_4bit_2regs(Xbyak::CodeGenerator* jit, Xbyak::Ymm
   return dst;
 }
 
-class DecompressS4S8_AVX512F : protected jblas::xbyak::JitAvx512f {
+class DecompressS4S8_AVX512F : protected xbyak::JitAvx512f {
  public:
   struct params {
     void *srcptr, *dstptr;
@@ -879,24 +877,24 @@ class DecompressS4S8_AVX512F : protected jblas::xbyak::JitAvx512f {
     mKernel = this->getCode<func_t>();
   }
 
-  static JBLAS_CODE forward(void* srcptr, void* dstptr, size_t size) {
+  static BTLA_CODE forward(void* srcptr, void* dstptr, size_t size) {
     static DecompressS4S8_AVX512F instance;
     auto param = params{srcptr, dstptr, size};
     instance.mKernel(&param);
-    return JblasSuccess;
+    return BTLA_CODE::Success;
   }
 
  private:
   func_t mKernel = nullptr;
 };
 
-static inline JBLAS_CODE decompress_s4_s8(utils::int4x2* srcptr, int8_t* dstptr, int row, int col, int ld_src,
-                                          int ld_dst) {
+static inline BTLA_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 continuous
-    return JblasNotSupport;
+    return BTLA_CODE::NotSupport;
   }
   DecompressS4S8_AVX512F::forward(srcptr, dstptr, (size_t)row * col);
-  return JblasSuccess;
+  return BTLA_CODE::Success;
 }
 
 // src: row x col => dst: ⌈col/n_tile⌉ x ⌈row/row_pack⌉ x n_tile x row_pack (zeor-padded)
@@ -920,11 +918,11 @@ class PaddingInterleaveCvt : protected xbyak::JitAvx512f {
       12, 28, 13, 29, 14, 30, 15, 31,  //
   };
 
-  PaddingInterleaveCvt(int n_tile, JBLAS_DTYPE dst_t) : PaddingInterleaveCvt(n_tile, dst_t, dst_t) {}
-  PaddingInterleaveCvt(int n_tile, JBLAS_DTYPE dst_t, JBLAS_DTYPE src_t, int row_pack = 0) : xbyak::JitAvx512f() {
+  PaddingInterleaveCvt(int n_tile, BTLA_DTYPE dst_t) : PaddingInterleaveCvt(n_tile, dst_t, dst_t) {}
+  PaddingInterleaveCvt(int n_tile, BTLA_DTYPE dst_t, BTLA_DTYPE src_t, int row_pack = 0) : xbyak::JitAvx512f() {
     inLocalLabel();  // use local label for multiple instance
-    const auto src_bytes = static_cast<int>(utils::jblas_dtype_size(src_t));
-    const auto dst_bytes = static_cast<int>(utils::jblas_dtype_size(dst_t));
+    const auto src_bytes = static_cast<int>(utils::bestla_dtype_size(src_t));
+    const auto dst_bytes = static_cast<int>(utils::bestla_dtype_size(dst_t));
     if (row_pack == 0) row_pack = 4 / dst_bytes;  // default value
     const auto ne_zmm = 64 / std::max(src_bytes, dst_bytes);
     const auto src_bytes_vmm = ne_zmm * src_bytes;
@@ -1005,7 +1003,7 @@ class PaddingInterleaveCvt : protected xbyak::JitAvx512f {
           vmovdqu32(reg_srcs_ii | mask_rd | T_z, ptr[reg_tmp1 + ii * reg_srcstride + jj * src_bytes]);
         }
       }
-      if (src_t == JBLAS_DTYPE::F32 && dst_t == JBLAS_DTYPE::BF16) {
+      if (src_t == BTLA_DTYPE::F32 && dst_t == BTLA_DTYPE::BF16) {
         vcvtne2ps2bf16(reg_tmps[0], reg_srcs[1], reg_srcs[0]);
         vpermt2w(reg_tmps[0], vreg_idx0, reg_tmps[0]);
         vmovups(ptr[reg_tmp + jj * row_pack * dst_bytes], reg_tmps[0]);
@@ -1049,7 +1047,7 @@ class PaddingInterleaveCvt : protected xbyak::JitAvx512f {
       } else {
         assert(false);
       }
-      if (src_t == JBLAS_DTYPE::F32 && dst_t == JBLAS_DTYPE::BF16) {
+      if (src_t == BTLA_DTYPE::F32 && dst_t == BTLA_DTYPE::BF16) {
         vcvtne2ps2bf16(reg_tmps[0], reg_srcs[1], reg_srcs[0]);
         vpermt2w(reg_tmps[0], vreg_idx0, reg_tmps[0]);
         vmovups(ptr[reg_tmp + jj * row_pack * dst_bytes], reg_tmps[0]);
@@ -1078,7 +1076,7 @@ class PaddingInterleaveCvt : protected xbyak::JitAvx512f {
     const auto src_stride = static_cast<int>(sizeof(T_SRC)) * src_step;
     const auto dst_stride = static_cast<int>(sizeof(T_DST)) * dst_step;
     params param = {src, dst, row, col, src_stride, dst_stride};
-    static const PaddingInterleaveCvt kern(NTile, utils::jblas_dtype<T_DST>, utils::jblas_dtype<T_SRC>, RowPack);
+    static const PaddingInterleaveCvt kern(NTile, utils::bestla_dtype<T_DST>, utils::bestla_dtype<T_SRC>, RowPack);
     kern(&param);
 
     // extra row and col pad
@@ -1123,11 +1121,11 @@ class PaddingTransInterleaveCvt : protected xbyak::JitAvx512f {
   const int trans_cell;  // transpose matrices of size trans_cellxtrans_cell (in terms of #elements or #packs)
 
  private:
-  PaddingTransInterleaveCvt(int m_tile, JBLAS_DTYPE dst_t) : PaddingTransInterleaveCvt(m_tile, dst_t, dst_t) {}
-  PaddingTransInterleaveCvt(int m_tile, JBLAS_DTYPE dst_t, JBLAS_DTYPE src_t, int col_pack = 0)
-      : xbyak::JitAvx512f(), trans_cell(64 / col_pack / int(utils::jblas_dtype_size(dst_t))) {
-    const auto src_bytes = static_cast<int>(utils::jblas_dtype_size(src_t));
-    const auto dst_bytes = static_cast<int>(utils::jblas_dtype_size(dst_t));
+  PaddingTransInterleaveCvt(int m_tile, BTLA_DTYPE dst_t) : PaddingTransInterleaveCvt(m_tile, dst_t, dst_t) {}
+  PaddingTransInterleaveCvt(int m_tile, BTLA_DTYPE dst_t, BTLA_DTYPE src_t, int col_pack = 0)
+      : xbyak::JitAvx512f(), trans_cell(64 / col_pack / int(utils::bestla_dtype_size(dst_t))) {
+    const auto src_bytes = static_cast<int>(utils::bestla_dtype_size(src_t));
+    const auto dst_bytes = static_cast<int>(utils::bestla_dtype_size(dst_t));
     if (col_pack == 0) col_pack = 4 / dst_bytes;  // default value
     // const auto src_bytes_vmm = ne_zmm * src_bytes;
     // const auto dst_bytes_vmm = ne_zmm * dst_bytes;
@@ -1192,7 +1190,7 @@ class PaddingTransInterleaveCvt : protected xbyak::JitAvx512f {
 
     L(".colloop");
     generate_Nbitsmask(mask_rd, reg_itercol, ptr[reg_colsize], reg_tmp2, reg_tmp3, 64 / dst_bytes);
-    if (src_t == JBLAS_DTYPE::F32 && dst_t == JBLAS_DTYPE::BF16) {
+    if (src_t == BTLA_DTYPE::F32 && dst_t == BTLA_DTYPE::BF16) {
       kshiftrq(mask_rd2, mask_rd, 16);
       assert(trans_cell == 16);
       for (int ii = 0; ii < trans_cell; ++ii) {
@@ -1235,7 +1233,7 @@ class PaddingTransInterleaveCvt : protected xbyak::JitAvx512f {
       auto& tailcolloop = l_tail_case[m_tail];
       L(tailcolloop);
       generate_Nbitsmask(mask_rd, reg_itercol, ptr[reg_colsize], reg_tmp2, reg_tmp3, 64 / dst_bytes);
-      if (src_t == JBLAS_DTYPE::F32 && dst_t == JBLAS_DTYPE::BF16) {
+      if (src_t == BTLA_DTYPE::F32 && dst_t == BTLA_DTYPE::BF16) {
         kshiftrq(mask_rd2, mask_rd, 16);
         assert(trans_cell == 16);
         for (int ii = 0; ii < trans_cell; ++ii) {
@@ -1277,7 +1275,7 @@ class PaddingTransInterleaveCvt : protected xbyak::JitAvx512f {
                       int dst_step) {
     assert(utils::padto(row, MTile) <= row_pad && row_pad % MTile == 0);
     assert(utils::padto(col, ColPack) <= col_pad && col_pad % ColPack == 0);
-    static const PaddingTransInterleaveCvt kern(MTile, utils::jblas_dtype<T_DST>, utils::jblas_dtype<T_SRC>, ColPack);
+    static const PaddingTransInterleaveCvt kern(MTile, utils::bestla_dtype<T_DST>, utils::bestla_dtype<T_SRC>, ColPack);
     // 0-padded guarantee by jit kern
     const auto kern_row_pad = utils::padto(row, kern.trans_cell),
                kern_col_pad = utils::padto(col, kern.trans_cell * ColPack);
@@ -1482,4 +1480,4 @@ class CScaleInterleavedBF16FP16 : protected xbyak::JitAvx512_fp16 {
 
 }  // namespace jit
 }  // namespace kernel
-}  // namespace jblas
+}  // namespace bestla
diff --git a/bestla/jblas/kernel_jit_injector.h b/bestla/bestla/kernel_jit_injector.h
similarity index 96%
rename from bestla/jblas/kernel_jit_injector.h
rename to bestla/bestla/kernel_jit_injector.h
index d3e49eecd..3db66fa4f 100644
--- a/bestla/jblas/kernel_jit_injector.h
+++ b/bestla/bestla/kernel_jit_injector.h
@@ -22,11 +22,11 @@
 #include <set>
 #include <array>
 
-#include "jit_blas.h"
-#include "jit_blas_utils.h"
+#include "bestla.h"
+#include "bestla_utils.h"
 #include "xbyak/xbyak.h"
 
-namespace jblas {
+namespace bestla {
 namespace kernel {
 namespace jit_injector {
 using Zmm = Xbyak::Zmm;
@@ -34,7 +34,7 @@ using Ymm = Xbyak::Ymm;
 using Xmm = Xbyak::Xmm;
 class eltwise_injector {
  public:
-  eltwise_injector(JBLAS_ELTWISEOP eltwiseop) : elt_op(eltwiseop) { reigster_table_entries(); }
+  eltwise_injector(BTLA_ELTWISEOP eltwiseop) : elt_op(eltwiseop) { reigster_table_entries(); }
   virtual ~eltwise_injector() {}
 
   void assign_resources(Xbyak::CodeGenerator* ptr, const std::set<int>& used_zmm_idx, const Xbyak::Reg64& table_reg,
@@ -65,25 +65,25 @@ class eltwise_injector {
   void vector_compute(const Xbyak::Zmm& zmm_src, int const_p_offset = 0) {
     load_table_addr();
     switch (elt_op) {
-      case EXP:
+      case BTLA_ELTWISEOP::EXP:
         exp_compute_vector_fwd(zmm_src);
         break;
-      case TANH:
+      case BTLA_ELTWISEOP::TANH:
         tanh_compute_vector_fwd(zmm_src);
         break;
-      case GELU:
+      case BTLA_ELTWISEOP::GELU:
         gelu_compute_vector_fwd(zmm_src);
         break;
-      case RELU:
+      case BTLA_ELTWISEOP::RELU:
         relu_compute_vector_fwd(zmm_src, const_p_offset);
         break;
-      case LINEAR:
+      case BTLA_ELTWISEOP::LINEAR:
         linear_compute_vector_fwd(zmm_src, const_p_offset);
         break;
-      case LOW_PRECISION_EXP:
+      case BTLA_ELTWISEOP::LOW_PRECISION_EXP:
         low_precision_exp_compute_vector_fwd(zmm_src);
         break;
-      case SWISH:
+      case BTLA_ELTWISEOP::SWISH:
         swish_compute_vector_fwd(zmm_src, const_p_offset);
         break;
       default:
@@ -94,19 +94,19 @@ class eltwise_injector {
   void vector_compute(const Xbyak::Ymm& ymm_src, int const_p_offset = 0) {
     load_table_addr();
     switch (elt_op) {
-      case EXP:
+      case BTLA_ELTWISEOP::EXP:
         exp_compute_vector_fwd(ymm_src);
         break;
-      case TANH:
+      case BTLA_ELTWISEOP::TANH:
         tanh_compute_vector_fwd(ymm_src);
         break;
-      case GELU:
+      case BTLA_ELTWISEOP::GELU:
         gelu_compute_vector_fwd(ymm_src);
         break;
-      case LOW_PRECISION_EXP:
+      case BTLA_ELTWISEOP::LOW_PRECISION_EXP:
         low_precision_exp_compute_vector_fwd(ymm_src);
         break;
-      case SWISH:
+      case BTLA_ELTWISEOP::SWISH:
         swish_compute_vector_fwd(ymm_src, const_p_offset);
         break;
       default:
@@ -136,9 +136,9 @@ class eltwise_injector {
 
     static constexpr std::array<float, 3> exp_approx_f32_coeff{0.35815147f, 0.96963238f, 1.f};
     static const table_t low_precision_exp_consts{
-        {low_precision_exp_const_v0, {jblas::utils::bit_cast<uint32_t>(exp_approx_f32_coeff[0]), true}},
-        {low_precision_exp_const_v1, {jblas::utils::bit_cast<uint32_t>(exp_approx_f32_coeff[1]), true}},
-        {low_precision_exp_const_v2, {jblas::utils::bit_cast<uint32_t>(exp_approx_f32_coeff[2]), true}},
+        {low_precision_exp_const_v0, {utils::bit_cast<uint32_t>(exp_approx_f32_coeff[0]), true}},
+        {low_precision_exp_const_v1, {utils::bit_cast<uint32_t>(exp_approx_f32_coeff[1]), true}},
+        {low_precision_exp_const_v2, {utils::bit_cast<uint32_t>(exp_approx_f32_coeff[2]), true}},
     };
 
     static const table_t exp_consts{{exp_log2ef, {0x3fb8aa3b, true}},
@@ -425,12 +425,12 @@ class eltwise_injector {
     };
 
     struct need_t {
-      explicit need_t(JBLAS_ELTWISEOP& op) {
-        if (op == EXP) exp_ = true;
-        if (op == TANH) tanh_ = true;
-        if (op == GELU) gelu_ = true;
-        if (op == SWISH) swish_ = true;
-        if (op == LOW_PRECISION_EXP) low_precision_exp_ = true;
+      explicit need_t(BTLA_ELTWISEOP& op) {
+        if (op == BTLA_ELTWISEOP::EXP) exp_ = true;
+        if (op == BTLA_ELTWISEOP::TANH) tanh_ = true;
+        if (op == BTLA_ELTWISEOP::GELU) gelu_ = true;
+        if (op == BTLA_ELTWISEOP::SWISH) swish_ = true;
+        if (op == BTLA_ELTWISEOP::LOW_PRECISION_EXP) low_precision_exp_ = true;
       }
       bool bf16_ = false;
       bool exp_ = false;
@@ -835,7 +835,7 @@ class eltwise_injector {
   }
 
  private:
-  JBLAS_ELTWISEOP elt_op;
+  BTLA_ELTWISEOP elt_op;
   Xbyak::CodeGenerator* h = nullptr;
 
   /*labels*/
@@ -927,4 +927,4 @@ class eltwise_injector {
 };
 }  // namespace jit_injector
 }  // namespace kernel
-}  // namespace jblas
+}  // namespace bestla
diff --git a/bestla/jblas/kernel_ref.h b/bestla/bestla/kernel_ref.h
similarity index 74%
rename from bestla/jblas/kernel_ref.h
rename to bestla/bestla/kernel_ref.h
index 1e0ddccda..f55f4fa45 100644
--- a/bestla/jblas/kernel_ref.h
+++ b/bestla/bestla/kernel_ref.h
@@ -17,28 +17,28 @@
 #include <vector>
 #include <algorithm>
 #include <limits>
-#include "jblas/jit_blas.h"
-#include "jit_blas_utils.h"
+#include "bestla.h"
+#include "bestla_utils.h"
 
-namespace jblas {
+namespace bestla {
 namespace kernel {
 namespace ref {
 
 template <typename T>
-static inline JBLAS_CODE shuffle_activation(T* src, T* dst, int shuffle_m, int shuffle_k, int m_offset, int k_offset,
-                                            int* indices, int src_stride, int dst_stride) {
+static inline BTLA_CODE shuffle_activation(T* src, T* dst, int shuffle_m, int shuffle_k, int m_offset, int k_offset,
+                                           int* indices, int src_stride, int dst_stride) {
   T* cur_src = src + m_offset * src_stride;
   for (int i = 0; i < shuffle_m; i++) {
     for (int j = 0; j < shuffle_k; j++) {
       dst[i * dst_stride + j] = cur_src[i * src_stride + indices[k_offset + j]];
     }
   }
-  return JblasSuccess;
+  return BTLA_CODE::Success;
 }
 
 template <typename T_SRC, typename T_DST = T_SRC>
-static inline JBLAS_CODE padding_interleave(const T_SRC* src_ptr, T_DST* dst_ptr, int row, int col, int rowpad,
-                                            int colpad, int src_step, int dst_step, int NTile, int RowPack) {
+static inline BTLA_CODE padding_interleave(const T_SRC* src_ptr, T_DST* dst_ptr, int row, int col, int rowpad,
+                                           int colpad, int src_step, int dst_step, int NTile, int RowPack) {
   const T_DST dst_0(0);
   static_assert(sizeof(T_SRC) == sizeof(T_DST), "SRC & DST size should be the same");
   for (int i = 0; i < rowpad; i += RowPack) {
@@ -53,14 +53,14 @@ static inline JBLAS_CODE padding_interleave(const T_SRC* src_ptr, T_DST* dst_ptr
       }
     }
   }
-  return JblasSuccess;
+  return BTLA_CODE::Success;
 }
 
 // revert padding and interleave
 // row*col <= colpad/NTile*rowpad*NTile
 template <typename T_SRC, typename T_DST = T_SRC>
-static inline JBLAS_CODE revert_padding_interleave(const T_SRC* src_ptr, T_DST* dst_ptr, int row, int col, int rowpad,
-                                                   int colpad, int src_step, int dst_step, int NTile, int RowPack) {
+static inline BTLA_CODE revert_padding_interleave(const T_SRC* src_ptr, T_DST* dst_ptr, int row, int col, int rowpad,
+                                                  int colpad, int src_step, int dst_step, int NTile, int RowPack) {
   static_assert(sizeof(T_SRC) == sizeof(T_DST), "SRC & DST size should be the same");
   for (int i = 0; i < rowpad; i += RowPack) {
     for (int j = 0; j < colpad; j += NTile) {
@@ -76,13 +76,13 @@ static inline JBLAS_CODE revert_padding_interleave(const T_SRC* src_ptr, T_DST*
       }
     }
   }
-  return JblasSuccess;
+  return BTLA_CODE::Success;
 }
 
 // M x N ===> M/MTile x N/colPack x MTile x colPack (leading dim stride = MTile * dst_stride)
 template <typename T_SRC, typename T_DST = T_SRC>
-static inline JBLAS_CODE padding_trans_interleave(const T_SRC* src, T_DST* dst, int row, int col, int rowpad,
-                                                  int colpad, int src_step, int dst_step, int MTile, int ColPack) {
+static inline BTLA_CODE padding_trans_interleave(const T_SRC* src, T_DST* dst, int row, int col, int rowpad, int colpad,
+                                                 int src_step, int dst_step, int MTile, int ColPack) {
   // Note: rows/cols and i/j are in terms of src
   static_assert(sizeof(T_SRC) == sizeof(T_DST), "SRC & DST size should be the same");
   const T_DST dst_0(0);
@@ -98,12 +98,12 @@ static inline JBLAS_CODE padding_trans_interleave(const T_SRC* src, T_DST* dst,
       }
     }
   }
-  return JblasSuccess;
+  return BTLA_CODE::Success;
 }
 
 template <typename SRC_DT, typename DST_DT>
-static inline JBLAS_CODE dt_cvt_2D_write_back(const void* raw_srcptr, void* raw_dstptr, int row, int col, int srcstride,
-                                              int dststride, bool zeropadding) {
+static inline BTLA_CODE dt_cvt_2D_write_back(const void* raw_srcptr, void* raw_dstptr, int row, int col, int srcstride,
+                                             int dststride, bool zeropadding) {
   for (int i = 0; i < row; i++) {
     int j = 0;
     for (; j < col; j++) {
@@ -117,72 +117,72 @@ static inline JBLAS_CODE dt_cvt_2D_write_back(const void* raw_srcptr, void* raw_
       }
     }
   }
-  return JblasSuccess;
+  return BTLA_CODE::Success;
 }
 
 template <typename _DST_T>
-static inline JBLAS_CODE dequan_s8_fp(int8_t* srcptr, _DST_T* dstptr, int row, int col, int ld_src, int ld_dst,
-                                      float* scales) {
+static inline BTLA_CODE dequan_s8_fp(int8_t* srcptr, _DST_T* dstptr, int row, int col, int ld_src, int ld_dst,
+                                     float* scales) {
   for (int i = 0; i < row; i++) {
     for (int j = 0; j < col; j++) {
       dstptr[i * ld_dst + j] = static_cast<float>(srcptr[i * ld_src + j]) * scales[j];
     }
   }
-  return JblasSuccess;
+  return BTLA_CODE::Success;
 }
 
-static inline JBLAS_CODE dequan_s8_bf16(int8_t* srcptr, uint16_t* dstptr, int row, int col, int ld_src, int ld_dst,
-                                        float* scales) {
+static inline BTLA_CODE dequan_s8_bf16(int8_t* srcptr, uint16_t* dstptr, int row, int col, int ld_src, int ld_dst,
+                                       float* scales) {
   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>(static_cast<float>(srcptr[i * ld_src + j]) * scales[j]).x;
+          utils::cast<float, utils::bf16>(static_cast<float>(srcptr[i * ld_src + j]) * scales[j]).x;
     }
   }
-  return JblasSuccess;
+  return BTLA_CODE::Success;
 }
 
 template <typename _T>
-static inline JBLAS_CODE transpose2d(const _T* srcptr, _T* dstptr, int row, int col, int ld_src, int ld_dst) {
+static inline BTLA_CODE transpose2d(const _T* srcptr, _T* dstptr, int row, int col, int ld_src, int ld_dst) {
   for (int i = 0; i < col; i++) {
     for (size_t j = 0; j < row; j++) {
       dstptr[j + i * ld_dst] = srcptr[j * ld_src + i];
     }
   }
-  return JblasSuccess;
+  return BTLA_CODE::Success;
 }
 
 template <int NTile>
-static inline JBLAS_CODE compress_s8_s4(const int8_t* srcptr, jblas::utils::int4x2* dstptr, int row, int col,
-                                        int ld_src, int ld_dst) {
+static inline BTLA_CODE compress_s8_s4(const int8_t* srcptr, utils::int4x2* dstptr, int row, int col, int ld_src,
+                                       int ld_dst) {
   for (int j = 0; j < row; j++) {
     for (int ii = 0; ii < col; ii += 2) {
-      jblas::utils::int4x2 tmp;
-      tmp.x = jblas::utils::int4x2::convert(srcptr[j * ld_src + ii + 0]);
-      tmp.y = jblas::utils::int4x2::convert(srcptr[j * ld_src + ii + 1]);
+      utils::int4x2 tmp;
+      tmp.x = utils::int4x2::convert(srcptr[j * ld_src + ii + 0]);
+      tmp.y = utils::int4x2::convert(srcptr[j * ld_src + ii + 1]);
       dstptr[j * ld_dst / 2 + ii / 2] = tmp;
     }
   }
-  return JblasSuccess;
+  return BTLA_CODE::Success;
 }
 
 template <int NTile>
-static inline JBLAS_CODE compress_f4(const int8_t* srcptr, jblas::utils::f4x2* dstptr, int row, int col, int ld_src,
-                                     int ld_dst) {
+static inline BTLA_CODE compress_f4(const int8_t* srcptr, utils::f4x2* dstptr, int row, int col, int ld_src,
+                                    int ld_dst) {
   for (int j = 0; j < row; j++) {
     for (int ii = 0; ii < col; ii += 2) {
-      jblas::utils::f4x2 tmp;
+      utils::f4x2 tmp;
       tmp.x = srcptr[j * ld_src + ii + 0];
       tmp.y = srcptr[j * ld_src + ii + 1];
       dstptr[j * ld_dst / 2 + ii / 2] = tmp;
     }
   }
-  return JblasSuccess;
+  return BTLA_CODE::Success;
 }
 
 template <int NTile>
-static inline JBLAS_CODE decompress_s4_f32(jblas::utils::int4x2* srcptr, float* dstptr, int row, int col, int ld_src,
-                                           int ld_dst, float* scales) {
+static inline BTLA_CODE decompress_s4_f32(utils::int4x2* srcptr, float* dstptr, int row, int col, int ld_src,
+                                          int ld_dst, float* scales) {
   for (int i = 0; i < row; i++) {
     for (int j = 0; j < col; j += 2) {
       auto tmp = srcptr[i * ld_src / 2 + j / 2];
@@ -191,15 +191,15 @@ static inline JBLAS_CODE decompress_s4_f32(jblas::utils::int4x2* srcptr, float*
       dstptr[i * ld_dst + j + 1] = static_cast<float>(static_cast<int8_t>(tmp.y) << 4) * scales[noffset + 1];
     }
   }
-  return JblasSuccess;
+  return BTLA_CODE::Success;
 }
 
-template <JBLAS_DTYPE S4_T>
+template <BTLA_DTYPE S4_T>
 inline int8_t get_s8(int8_t v) {
   switch (S4_T) {
-    case JBLAS_DTYPE::S4_CLIP:
+    case BTLA_DTYPE::S4_CLIP:
       return v << 4;
-    case JBLAS_DTYPE::S4_FULLRANGE:
+    case BTLA_DTYPE::S4_FULLRANGE:
       v &= 0x0f;
       return v - 8;
     default:
@@ -209,7 +209,7 @@ inline int8_t get_s8(int8_t v) {
   return static_cast<int8_t>(0);
 }
 
-template <JBLAS_DTYPE S4_T>
+template <BTLA_DTYPE S4_T>
 inline void convert_s4_s8_8(int8_t* dstptr, int8_t* srcptr) {
   auto src32 = *reinterpret_cast<uint32_t*>(srcptr);
   auto tmp = static_cast<int8_t>(src32 & 0xf) << 4;
@@ -251,7 +251,7 @@ inline void convert_s4_s8_8_lowbits(int8_t* dstptr, int8_t* srcptr) {
 }
 
 template <>
-inline void convert_s4_s8_8<JBLAS_DTYPE::S4_FULLRANGE>(int8_t* dstptr, int8_t* srcptr) {
+inline void convert_s4_s8_8<BTLA_DTYPE::S4_FULLRANGE>(int8_t* dstptr, int8_t* srcptr) {
   convert_s4_s8_8_lowbits(dstptr, srcptr);
   for (size_t i = 0; i < 8; i++) {
     dstptr[i] -= 8;
@@ -259,22 +259,22 @@ inline void convert_s4_s8_8<JBLAS_DTYPE::S4_FULLRANGE>(int8_t* dstptr, int8_t* s
 }
 
 template <>
-inline void convert_s4_s8_8<JBLAS_DTYPE::F4_BNB>(int8_t* dstptr, int8_t* srcptr) {
+inline void convert_s4_s8_8<BTLA_DTYPE::F4_BNB>(int8_t* dstptr, int8_t* srcptr) {
   convert_s4_s8_8_lowbits(dstptr, srcptr);
 }
 
 template <>
-inline void convert_s4_s8_8<JBLAS_DTYPE::F4_NF4>(int8_t* dstptr, int8_t* srcptr) {
+inline void convert_s4_s8_8<BTLA_DTYPE::F4_NF4>(int8_t* dstptr, int8_t* srcptr) {
   convert_s4_s8_8_lowbits(dstptr, srcptr);
 }
 
 template <>
-inline void convert_s4_s8_8<JBLAS_DTYPE::F4_E2M1>(int8_t* dstptr, int8_t* srcptr) {
+inline void convert_s4_s8_8<BTLA_DTYPE::F4_E2M1>(int8_t* dstptr, int8_t* srcptr) {
   convert_s4_s8_8_lowbits(dstptr, srcptr);
 }
 
-template <JBLAS_DTYPE S4_T>
-inline JBLAS_CODE decompress_s4_s8(utils::int4x2* srcptr, int8_t* dstptr, int row, int col, int ld_src, int ld_dst) {
+template <BTLA_DTYPE S4_T>
+inline BTLA_CODE decompress_s4_s8(utils::int4x2* srcptr, int8_t* dstptr, int row, int col, int ld_src, int ld_dst) {
   for (int i = 0; i < row; i++) {
     for (int j = 0; j < col; j += 2) {
       auto tmp = srcptr[i * ld_src / 2 + j / 2];
@@ -282,16 +282,16 @@ inline JBLAS_CODE decompress_s4_s8(utils::int4x2* srcptr, int8_t* dstptr, int ro
       dstptr[i * ld_dst + j + 1] = get_s8<S4_T>(tmp.y);
     }
   }
-  return JblasSuccess;
+  return BTLA_CODE::Success;
 }
 
-inline float f8_to_fp32(utils::f8 v, JBLAS_DTYPE f8_t) {
+inline float f8_to_fp32(utils::f8 v, BTLA_DTYPE f8_t) {
   uint32_t sign_revert = v.x;
   uint32_t e_revert = v.x;
   uint32_t mantissa_revert = v.x;
   sign_revert <<= 24;
   sign_revert &= 0x80000000;
-  auto ebits = utils::jblas_dtype_get_f8_ebits(f8_t);
+  auto ebits = utils::bestla_dtype_get_f8_ebits(f8_t);
   auto mantissabit = 7 - ebits;
   e_revert &= 0x7f;
   e_revert >>= mantissabit;
@@ -305,8 +305,8 @@ inline float f8_to_fp32(utils::f8 v, JBLAS_DTYPE f8_t) {
 }
 
 template <typename _DST_T, int _PACK_ROW, typename _S_T>
-inline JBLAS_CODE decompress_kblock_f8_fp(utils::f8* srcptr, _DST_T* dstptr, int row, int col, int ld_src, int ld_dst,
-                                          _S_T* scales, int k_offset, int kblock, int NPad, JBLAS_DTYPE src_f8_type) {
+inline BTLA_CODE decompress_kblock_f8_fp(utils::f8* srcptr, _DST_T* dstptr, int row, int col, int ld_src, int ld_dst,
+                                         _S_T* scales, int k_offset, int kblock, int NPad, BTLA_DTYPE src_f8_type) {
   for (int i = 0; i < row; i++) {
     int kpos = (k_offset + i) / kblock;
     auto sptr = scales + kpos * NPad;
@@ -324,12 +324,12 @@ inline JBLAS_CODE decompress_kblock_f8_fp(utils::f8* srcptr, _DST_T* dstptr, int
       dstptr[i * ld_dst + j] = fp_v * scale;
     }
   }
-  return JblasSuccess;
+  return BTLA_CODE::Success;
 }
 
 template <typename _DST_T, int _PACK_ROW, typename _S_T>
-inline JBLAS_CODE decompress_kblock_s8_fp(int8_t* srcptr, _DST_T* dstptr, int row, int col, int ld_src, int ld_dst,
-                                          _S_T* scales, int8_t* zero_points, int k_offset, int kblock, int NPad) {
+inline BTLA_CODE decompress_kblock_s8_fp(int8_t* srcptr, _DST_T* dstptr, int row, int col, int ld_src, int ld_dst,
+                                         _S_T* scales, int8_t* zero_points, int k_offset, int kblock, int NPad) {
   for (int i = 0; i < row; i++) {
     int kpos = (k_offset + i) / kblock;
     auto sptr = scales + kpos * NPad;
@@ -339,13 +339,13 @@ inline JBLAS_CODE decompress_kblock_s8_fp(int8_t* srcptr, _DST_T* dstptr, int ro
       dstptr[i * ld_dst + j] = static_cast<_DST_T>(tmp * sptr[j / _PACK_ROW]);
     }
   }
-  return JblasSuccess;
+  return BTLA_CODE::Success;
 }
 
-template <JBLAS_DTYPE S4_T, typename _DST_T, int _PACK_ROW, typename _S_T>
-inline JBLAS_CODE decompress_kblock_s4_fp(utils::int4x2* srcptr, _DST_T* dstptr, int row, int col, int ld_src,
-                                          int ld_dst, _S_T* scales, int8_t* zero_points, int k_offset, int kblock,
-                                          int NPad, int8_t* tmp, size_t tmpsize) {
+template <BTLA_DTYPE S4_T, typename _DST_T, int _PACK_ROW, typename _S_T>
+inline BTLA_CODE decompress_kblock_s4_fp(utils::int4x2* srcptr, _DST_T* dstptr, int row, int col, int ld_src,
+                                         int ld_dst, _S_T* scales, int8_t* zero_points, int k_offset, int kblock,
+                                         int NPad, int8_t* tmp, size_t tmpsize) {
   for (int i = 0; i < row; i++) {
     int kpos = (k_offset + i) / kblock;
     auto sptr = scales + kpos * NPad;
@@ -370,12 +370,12 @@ inline JBLAS_CODE decompress_kblock_s4_fp(utils::int4x2* srcptr, _DST_T* dstptr,
       dstptr[i * ld_dst + j + 1] = static_cast<_DST_T>(dst1);
     }
   }
-  return JblasSuccess;
+  return BTLA_CODE::Success;
 }
 
-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) {
+template <BTLA_DTYPE S4_T, typename _DST_T>
+inline BTLA_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) {
   for (int i = 0; i < row; i++) {
     for (int j = 0; j < col; j += 2) {
       auto tmp = srcptr[i * ld_src / 2 + j / 2];
@@ -383,18 +383,18 @@ inline JBLAS_CODE decompress_kblock_s4_s8fp(utils::int4x2* srcptr, _DST_T* dstpt
       dstptr[i * ld_dst + j + 1] = static_cast<_DST_T>(static_cast<float>(get_s8<S4_T>(tmp.y)));
     }
   }
-  return JblasSuccess;
+  return BTLA_CODE::Success;
 }
 
 template <typename DST_T>
-inline JBLAS_CODE decompress_kblock_s8_s8fp(int8_t* srcptr, DST_T* dstptr, int row, int col, int ld_src, int ld_dst) {
+inline BTLA_CODE decompress_kblock_s8_s8fp(int8_t* srcptr, DST_T* dstptr, int row, int col, int ld_src, int ld_dst) {
   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>(static_cast<float>(tmp));
     }
   }
-  return JblasSuccess;
+  return BTLA_CODE::Success;
 }
 
 inline float fp4_bnb_unpack(uint8_t val) {
@@ -558,7 +558,7 @@ inline float nf4_unpack(int8_t val) {
 
 inline float nf4_dequantize(int8_t val, float absmax) { return nf4_unpack(val) * absmax; }
 
-// Note: In the BNB Nf4 definition, 0 has a non-zero value after dequantization, but Jblas uses 0 for padding, which
+// Note: In the BNB Nf4 definition, 0 has a non-zero value after dequantization, but BTLA uses 0 for padding, which
 // leads to calculation errors. We ultimately choose to swap the binary bits of -1 and 0 in Nf4 to avoid this
 // conflict.
 inline int8_t nf4_quantize(float x) {
@@ -603,16 +603,16 @@ inline int8_t nf4_quantize(float x) {
     return 0b0111;
 }
 
-template <JBLAS_DTYPE F4_T>
+template <BTLA_DTYPE F4_T>
 inline float f4_unpack(int8_t v) {
-  static_assert(F4_T == JBLAS_DTYPE::F4_BNB || F4_T == JBLAS_DTYPE::F4_NF4 || F4_T == JBLAS_DTYPE::F4_E2M1,
+  static_assert(F4_T == BTLA_DTYPE::F4_BNB || F4_T == BTLA_DTYPE::F4_NF4 || F4_T == BTLA_DTYPE::F4_E2M1,
                 "Unsupported F4 type");
   switch (F4_T) {
-    case JBLAS_DTYPE::F4_BNB:
+    case BTLA_DTYPE::F4_BNB:
       return fp4_bnb_unpack(v);
-    case JBLAS_DTYPE::F4_NF4:
+    case BTLA_DTYPE::F4_NF4:
       return nf4_unpack(v);
-    case JBLAS_DTYPE::F4_E2M1:
+    case BTLA_DTYPE::F4_E2M1:
       return fp4_e2m1_unpack(v);
     default:
       break;
@@ -620,23 +620,23 @@ inline float f4_unpack(int8_t v) {
   return std::numeric_limits<float>::quiet_NaN();
 }
 
-template <JBLAS_DTYPE F4_T>
+template <BTLA_DTYPE F4_T>
 inline float f4_dequantize(int8_t v, float scale) {
-  static_assert(F4_T == JBLAS_DTYPE::F4_BNB || F4_T == JBLAS_DTYPE::F4_NF4 || F4_T == JBLAS_DTYPE::F4_E2M1,
+  static_assert(F4_T == BTLA_DTYPE::F4_BNB || F4_T == BTLA_DTYPE::F4_NF4 || F4_T == BTLA_DTYPE::F4_E2M1,
                 "Unsupported F4 type");
   return f4_unpack<F4_T>(v) * scale;
 }
 
-template <JBLAS_DTYPE F4_T>
+template <BTLA_DTYPE F4_T>
 inline int8_t f4_quantize(float x) {
-  static_assert(F4_T == JBLAS_DTYPE::F4_BNB || F4_T == JBLAS_DTYPE::F4_NF4 || F4_T == JBLAS_DTYPE::F4_E2M1,
+  static_assert(F4_T == BTLA_DTYPE::F4_BNB || F4_T == BTLA_DTYPE::F4_NF4 || F4_T == BTLA_DTYPE::F4_E2M1,
                 "Unsupported F4 type");
   switch (F4_T) {
-    case JBLAS_DTYPE::F4_BNB:
+    case BTLA_DTYPE::F4_BNB:
       return fp4_bnb_quantize(x);
-    case JBLAS_DTYPE::F4_NF4:
+    case BTLA_DTYPE::F4_NF4:
       return nf4_quantize(x);
-    case JBLAS_DTYPE::F4_E2M1:
+    case BTLA_DTYPE::F4_E2M1:
       return fp4_e2m1_quantize(x);
     default:
       break;
@@ -644,10 +644,10 @@ inline int8_t f4_quantize(float x) {
   return static_cast<int8_t>(0);
 }
 
-template <JBLAS_DTYPE F4_T, typename _DST_T, int _PACK_ROW, typename _S_T>
-inline JBLAS_CODE decompress_kblock_f4_fp(utils::f4x2* srcptr, _DST_T* dstptr, int row, int col, int ld_src, int ld_dst,
-                                          _S_T* scales, int k_offset, int kblock, int NPad, int8_t* tmp,
-                                          size_t tmpsize) {
+template <BTLA_DTYPE F4_T, typename _DST_T, int _PACK_ROW, typename _S_T>
+inline BTLA_CODE decompress_kblock_f4_fp(utils::f4x2* srcptr, _DST_T* dstptr, int row, int col, int ld_src, int ld_dst,
+                                         _S_T* scales, int k_offset, int kblock, int NPad, int8_t* tmp,
+                                         size_t tmpsize) {
   for (int i = 0; i < row; i++) {
     int kpos = (k_offset + i) / kblock;
     auto sptr = scales + kpos * NPad;
@@ -665,12 +665,12 @@ inline JBLAS_CODE decompress_kblock_f4_fp(utils::f4x2* srcptr, _DST_T* dstptr, i
       dstptr[i * ld_dst + j + 1] = static_cast<_DST_T>(dst1);
     }
   }
-  return JblasSuccess;
+  return BTLA_CODE::Success;
 }
 
-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) {
+template <BTLA_DTYPE F4_T, typename _DST_T>
+inline BTLA_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) {
   for (int i = 0; i < row; i++) {
     for (int j = 0; j < col; j += 2) {
       auto tmp = srcptr[i * ld_src / 2 + j / 2];
@@ -678,36 +678,35 @@ inline JBLAS_CODE decompress_kblock_f4_fp_noscale(utils::f4x2* srcptr, _DST_T* d
       dstptr[i * ld_dst + j + 1] = static_cast<_DST_T>(f4_unpack<F4_T>(tmp.y));
     }
   }
-  return JblasSuccess;
+  return BTLA_CODE::Success;
 }
 
 template <typename _DST_T>
-inline JBLAS_CODE decompress_kblock_f8_fp_noscale(utils::f8* srcptr, _DST_T* dstptr, int row, int col, int ld_src,
-                                                  int ld_dst, JBLAS_DTYPE src_f8_t) {
+inline BTLA_CODE decompress_kblock_f8_fp_noscale(utils::f8* srcptr, _DST_T* dstptr, int row, int col, int ld_src,
+                                                 int ld_dst, BTLA_DTYPE src_f8_t) {
   for (int i = 0; i < row; i++) {
     for (int j = 0; j < col; j++) {
       dstptr[i * ld_dst + j] = f8_to_fp32(srcptr[i * ld_src + j], src_f8_t);
     }
   }
-  return JblasSuccess;
+  return BTLA_CODE::Success;
 }
 
-static inline JBLAS_CODE memcpy2d_dw2highw(const void* srcptr, void* dstptr, int row, int col, int srcstride,
-                                           int dststride) {
+static inline BTLA_CODE memcpy2d_dw2highw(const void* srcptr, void* dstptr, int row, int col, int srcstride,
+                                          int dststride) {
   auto bsrcptr = (char*)srcptr;
   auto bdstptr = (char*)dstptr;
   for (int i = 0; i < row; i++) {
     for (int j = 0; j < col; j++) {
-      std::memcpy(bdstptr + i * dststride + j * sizeof(jblas::utils::bf16),
-                  bsrcptr + i * srcstride + j * sizeof(float) + 2, sizeof(jblas::utils::bf16));
+      std::memcpy(bdstptr + i * dststride + j * sizeof(utils::bf16), bsrcptr + i * srcstride + j * sizeof(float) + 2,
+                  sizeof(utils::bf16));
     }
   }
-  return JblasSuccess;
+  return BTLA_CODE::Success;
 }
 
 template <typename _SRC_T, typename _DST_T>
-static inline JBLAS_CODE memcpy2d(const _SRC_T* srcptr, _DST_T* dstptr, int row, int col, int srcstride,
-                                  int dststride) {
+static inline BTLA_CODE memcpy2d(const _SRC_T* srcptr, _DST_T* dstptr, int row, int col, int srcstride, int dststride) {
   auto bsrcptr = (const char*)srcptr;
   auto bdstptr = (char*)dstptr;
   for (int i = 0; i < row; i++) {
@@ -727,23 +726,23 @@ static inline JBLAS_CODE memcpy2d(const _SRC_T* srcptr, _DST_T* dstptr, int row,
       assert(0);
     }
   }
-  return JblasSuccess;
+  return BTLA_CODE::Success;
 }
 
-static float postop(float x, JBLAS_ELTWISEOP op, void* const_elt_v) {
-  if (op == GELU) {
+static float postop(float x, BTLA_ELTWISEOP op, void* const_elt_v) {
+  if (op == BTLA_ELTWISEOP::GELU) {
     return 0.5f * x * (1.f + tanhf(0.7978845834732056f * (x + 0.044714998453855515f * x * x * x)));
   }
-  if (op == SWISH) {
+  if (op == BTLA_ELTWISEOP::SWISH) {
     return x / (1 + exp(-x));
   }
   assert(0);
   return std::numeric_limits<float>::infinity();
 }
 
-template <typename _SRC_T, typename _DST_T, JBLAS_ELTWISEOP OP_T>
-static inline JBLAS_CODE memcpy2d_withop(const _SRC_T* srcptr, _DST_T* dstptr, int row, int col, int srcstride,
-                                         int dststride, void* const_elt_v) {
+template <typename _SRC_T, typename _DST_T, BTLA_ELTWISEOP OP_T>
+static inline BTLA_CODE memcpy2d_withop(const _SRC_T* srcptr, _DST_T* dstptr, int row, int col, int srcstride,
+                                        int dststride, void* const_elt_v) {
   for (int i = 0; i < row; i++) {
     for (int j = 0; j < col; j += sizeof(_SRC_T)) {
       float v = srcptr[(i * srcstride + j) / sizeof(_SRC_T)];
@@ -751,11 +750,11 @@ static inline JBLAS_CODE memcpy2d_withop(const _SRC_T* srcptr, _DST_T* dstptr, i
       dstptr[(i * srcstride + j) / sizeof(_DST_T)] = v;
     }
   }
-  return JblasSuccess;
+  return BTLA_CODE::Success;
 }
 
-static inline JBLAS_CODE get2d_e8m0_scale(const void* srcptr, void* dstptr, int row, int col, int srcstride,
-                                          int dststride) {
+static inline BTLA_CODE get2d_e8m0_scale(const void* srcptr, void* dstptr, int row, int col, int srcstride,
+                                         int dststride) {
   auto f8_v = (const utils::f8*)srcptr;
   auto f32_v = (float*)dstptr;
   auto f8_stride = srcstride / sizeof(utils::f8);
@@ -766,12 +765,12 @@ static inline JBLAS_CODE get2d_e8m0_scale(const void* srcptr, void* dstptr, int
       f32_v[i * f32_stride + j] = std::pow(2, f8_v[i * f8_stride + j].x);
     }
   }
-  return JblasSuccess;
+  return BTLA_CODE::Success;
 }
 
-template <JBLAS_DTYPE S4_T>
-inline JBLAS_CODE quantize_f32_sign_int_rowblock(const float* srcptr, int8_t* dstptr, int row, int col, int ld_src,
-                                                 int ld_dst, float* scales, int8_t* zero_points, int blocksize) {
+template <BTLA_DTYPE S4_T>
+inline BTLA_CODE quantize_f32_sign_int_rowblock(const float* srcptr, int8_t* dstptr, int row, int col, int ld_src,
+                                                int ld_dst, float* scales, int8_t* zero_points, int blocksize) {
   int raw_blocksize = blocksize;
   for (int i = 0; i < col; i++) {
     int align_row_loop = row / blocksize * blocksize;
@@ -848,15 +847,15 @@ inline JBLAS_CODE quantize_f32_sign_int_rowblock(const float* srcptr, int8_t* ds
 
     auto dispatch_calc = [&](int blocksize) {
       switch (S4_T) {
-        case JBLAS_DTYPE::S8:
-        case JBLAS_DTYPE::S4_CLIP:
+        case BTLA_DTYPE::S8:
+        case BTLA_DTYPE::S4_CLIP:
           if (zero_points == nullptr) {
             s8_calc_store_scale_and_quantv_sym(blocksize);
           } else {
             s8_calc_store_scale_and_quantv_asym(blocksize);
           }
           break;
-        case JBLAS_DTYPE::S4_FULLRANGE:
+        case BTLA_DTYPE::S4_FULLRANGE:
           if (zero_points == nullptr) {
             s4_fullrange_calc_store_scale_and_quantv_sym(blocksize);
           } else {
@@ -872,18 +871,18 @@ inline JBLAS_CODE quantize_f32_sign_int_rowblock(const float* srcptr, int8_t* ds
     for (; j < align_row_loop; j += blocksize) dispatch_calc(blocksize);
     if (j < row) dispatch_calc(row - align_row_loop);
   }
-  return JblasSuccess;
+  return BTLA_CODE::Success;
 }
 
-template <JBLAS_DTYPE F8_T>
-int8_t f8_mx_quantize(float v, float scale, JBLAS_DTYPE scale_dtype) {
-  if (scale_dtype == JBLAS_DTYPE::F8_E8M0) {
+template <BTLA_DTYPE F8_T>
+int8_t f8_mx_quantize(float v, float scale, BTLA_DTYPE scale_dtype) {
+  if (scale_dtype == BTLA_DTYPE::F8_E8M0) {
     v /= std::pow(2, scale);
   } else {
     v /= scale;
   }
-  auto ebits = utils::jblas_dtype_get_f8_ebits(F8_T);
-  auto quant_mantissa = utils::jblas_dtype_get_f8_quant_mbits(F8_T);
+  auto ebits = utils::bestla_dtype_get_f8_ebits(F8_T);
+  auto quant_mantissa = utils::bestla_dtype_get_f8_quant_mbits(F8_T);
   auto store_mantissa = 7 - ebits;
   auto private_exp = std::floor(std::log2(std::abs(v == 0 ? v + 1 : v)));
   auto min_exp = -1 * (std::pow(2, ebits - 1)) + 2;
@@ -906,8 +905,8 @@ int8_t f8_mx_quantize(float v, float scale, JBLAS_DTYPE scale_dtype) {
   *shift_v <<= 1;
   uint8_t store_ebit = (*(p + 3) & 0xFF);
   store_ebit = store_ebit - 127 + std::pow(2, ebits - 1) - 1;
-  if (store_ebit > 15 && F8_T == JBLAS_DTYPE::F8_E4M3) store_ebit = 0;
-  if (store_ebit > 31 && F8_T == JBLAS_DTYPE::F8_E5M2) store_ebit = 0;
+  if (store_ebit > 15 && F8_T == BTLA_DTYPE::F8_E4M3) store_ebit = 0;
+  if (store_ebit > 31 && F8_T == BTLA_DTYPE::F8_E5M2) store_ebit = 0;
   store_ebit <<= store_mantissa;
   *shift_v <<= 8;
   int8_t ox80_shift = -128 >> (store_mantissa - 1);
@@ -917,9 +916,9 @@ int8_t f8_mx_quantize(float v, float scale, JBLAS_DTYPE scale_dtype) {
   return ret;
 }
 
-template <JBLAS_DTYPE F8_T>
-inline JBLAS_CODE quantize_f32_f8_rowblock_mxscale(const float* srcptr, int8_t* dstptr, int row, int col, int ld_src,
-                                                   int ld_dst, float* scales, int blocksize, JBLAS_DTYPE scale_dtype) {
+template <BTLA_DTYPE F8_T>
+inline BTLA_CODE quantize_f32_f8_rowblock_mxscale(const float* srcptr, int8_t* dstptr, int row, int col, int ld_src,
+                                                  int ld_dst, float* scales, int blocksize, BTLA_DTYPE scale_dtype) {
   for (int i = 0; i < col; i++) {
     int align_row_loop = row / blocksize * blocksize;
     int j = 0;
@@ -928,18 +927,18 @@ inline JBLAS_CODE quantize_f32_f8_rowblock_mxscale(const float* srcptr, int8_t*
       for (size_t ij = 0; ij < blksize; ij++) {
         scale = std::max(scale, std::abs(srcptr[(j + ij) * ld_src + i]));
       }
-      if (scale_dtype == JBLAS_DTYPE::F8_E8M0) {
+      if (scale_dtype == BTLA_DTYPE::F8_E8M0) {
         if (scale == 0) scale += std::abs(std::numeric_limits<float>::min());
         scale = std::floor(std::log2(scale));
-        auto ebits = utils::jblas_dtype_get_f8_ebits(F8_T);
+        auto ebits = utils::bestla_dtype_get_f8_ebits(F8_T);
         auto emax = std::pow(2, ebits - 1);
-        if (F8_T == JBLAS_DTYPE::F8_E5M2) emax -= 1;
+        if (F8_T == BTLA_DTYPE::F8_E5M2) emax -= 1;
         scale -= emax;
         auto scale_max = std::pow(2, 7) - 1;  // e8m0 scale type.
         scale = scale < (-1 * scale_max) ? (-1 * scale_max) : scale;
-      } else if (scale_dtype == JBLAS_DTYPE::F32) {
-        scale /= utils::get_mxfp_maxnorm(F8_T, utils::jblas_dtype_get_f8_ebits(F8_T),
-                                         utils::jblas_dtype_get_f8_quant_mbits(F8_T));
+      } else if (scale_dtype == BTLA_DTYPE::F32) {
+        scale /= utils::get_mxfp_maxnorm(F8_T, utils::bestla_dtype_get_f8_ebits(F8_T),
+                                         utils::bestla_dtype_get_f8_quant_mbits(F8_T));
       } else {
         assert(0);
       }
@@ -951,12 +950,12 @@ inline JBLAS_CODE quantize_f32_f8_rowblock_mxscale(const float* srcptr, int8_t*
     for (; j < align_row_loop; j += blocksize) f8_blk_quant(blocksize);
     if (j < row) f8_blk_quant(row - align_row_loop);
   }
-  return JblasSuccess;
+  return BTLA_CODE::Success;
 }
 
-template <JBLAS_DTYPE F4_T>
-inline JBLAS_CODE quantize_f32_f4_rowblock(const float* srcptr, int8_t* dstptr, int row, int col, int ld_src,
-                                           int ld_dst, float* scales, int8_t* zero_points, int blocksize) {
+template <BTLA_DTYPE F4_T>
+inline BTLA_CODE quantize_f32_f4_rowblock(const float* srcptr, int8_t* dstptr, int row, int col, int ld_src, int ld_dst,
+                                          float* scales, int8_t* zero_points, int blocksize) {
   int raw_blocksize = blocksize;
   for (int i = 0; i < col; i++) {
     int align_row_loop = row / blocksize * blocksize;
@@ -996,13 +995,12 @@ inline JBLAS_CODE quantize_f32_f4_rowblock(const float* srcptr, int8_t* dstptr,
     for (; j < align_row_loop; j += blocksize) dispatch_calc(blocksize);
     if (j < row) dispatch_calc(row - align_row_loop);
   }
-  return JblasSuccess;
+  return BTLA_CODE::Success;
 }
 
 template <typename SRC_T>
-inline JBLAS_CODE quantize_fp_u8_colblock(int row, int col, const SRC_T* srcptr, int ld_src, uint8_t* dstptr,
-                                          int ld_dst, float* scales, int ld_scale, uint8_t* zps, int blocksize,
-                                          float* blkreduce) {
+inline BTLA_CODE quantize_fp_u8_colblock(int row, int col, const SRC_T* srcptr, int ld_src, uint8_t* dstptr, int ld_dst,
+                                         float* scales, int ld_scale, uint8_t* zps, int blocksize, float* blkreduce) {
   int colblk = utils::padto_le(col, blocksize);
   for (int i = 0; i < row; i++) {
     size_t j = 0;
@@ -1057,12 +1055,12 @@ inline JBLAS_CODE quantize_fp_u8_colblock(int row, int col, const SRC_T* srcptr,
       }
     }
   }
-  return JblasSuccess;
+  return BTLA_CODE::Success;
 }
 
 template <typename SRC_T>
-inline JBLAS_CODE quantize_fp_s8_colblock(int row, int col, const SRC_T* srcptr, int ld_src, int8_t* dstptr, int ld_dst,
-                                          float* scales, int ld_scale, int blocksize, float* reduce) {
+inline BTLA_CODE quantize_fp_s8_colblock(int row, int col, const SRC_T* srcptr, int ld_src, int8_t* dstptr, int ld_dst,
+                                         float* scales, int ld_scale, int blocksize, float* reduce) {
   int colblk = utils::padto_le(col, blocksize);
   for (int i = 0; i < row; i++) {
     size_t j = 0;
@@ -1102,30 +1100,30 @@ inline JBLAS_CODE quantize_fp_s8_colblock(int row, int col, const SRC_T* srcptr,
       if (reduce) reduce[j / blocksize + i * ld_scale] = sum * scale;
     }
   }
-  return JblasSuccess;
+  return BTLA_CODE::Success;
 }
 
-static inline JBLAS_CODE alphabeta_f32_f32(const float alpha, const float* srcptr, const int srcstep, const float beta,
-                                           const float* src1ptr, const int src1step, float* dstptr, const int dststep,
-                                           const int M, const int N) {
+static inline BTLA_CODE alphabeta_f32_f32(const float alpha, const float* srcptr, const int srcstep, const float beta,
+                                          const float* src1ptr, const int src1step, float* dstptr, const int dststep,
+                                          const int M, const int N) {
   if (beta != 0.f) {
     for (int i = 0; i < M; i++) {
       for (int j = 0; j < N; j++) {
         dstptr[i * dststep + j] = alpha * srcptr[i * srcstep + j] + beta * src1ptr[i * src1step + j];
       }
     }
-    return JblasSuccess;
+    return BTLA_CODE::Success;
   }
   for (int i = 0; i < M; i++) {
     for (int j = 0; j < N; j++) {
       dstptr[i * dststep + j] = alpha * srcptr[i * srcstep + j];
     }
   }
-  return JblasSuccess;
+  return BTLA_CODE::Success;
 }
 template <typename SCA_T>
-static inline JBLAS_CODE accum_alphaN_f32_f32(const SCA_T* alpha, const float* srcptr, const int srcstep, float* dstptr,
-                                              const int dststep, const int M, const int N) {
+static inline BTLA_CODE accum_alphaN_f32_f32(const SCA_T* alpha, const float* srcptr, const int srcstep, float* dstptr,
+                                             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++) {
       if constexpr (!std::is_same_v<SCA_T, utils::f8>) {
@@ -1136,22 +1134,22 @@ static inline JBLAS_CODE accum_alphaN_f32_f32(const SCA_T* alpha, const float* s
       }
     }
   }
-  return JblasSuccess;
+  return BTLA_CODE::Success;
 }
 
-static inline JBLAS_CODE accum_f32_f32(const float* srcptr, const int srcstep, float* dstptr, const int dststep,
-                                       const int M, const int N) {
+static inline BTLA_CODE accum_f32_f32(const float* srcptr, const int srcstep, float* dstptr, 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] = srcptr[i * srcstep + j] + dstptr[i * dststep + j];
     }
   }
-  return JblasSuccess;
+  return BTLA_CODE::Success;
 }
 
-static inline JBLAS_CODE quanout_s32_u32(const float alpha, const int32_t* srcptr, const int srcstep, uint8_t* dstptr,
-                                         const int dststep, const int M, const int N, float scaleSrc, float scaleDst,
-                                         int zpDst) {
+static inline BTLA_CODE quanout_s32_u32(const float alpha, const int32_t* srcptr, const int srcstep, uint8_t* dstptr,
+                                        const int dststep, const int M, const int N, float scaleSrc, float scaleDst,
+                                        int zpDst) {
   float factor = alpha * scaleSrc / scaleDst;
   for (int i = 0; i < M; i++) {
     for (int j = 0; j < N; j++) {
@@ -1159,13 +1157,13 @@ static inline JBLAS_CODE quanout_s32_u32(const float alpha, const int32_t* srcpt
       dstptr[i * dststep + j] = utils::cast<float, uint8_t>(fsrc + static_cast<float>(zpDst));
     }
   }
-  return JblasSuccess;
+  return BTLA_CODE::Success;
 }
 
 template <typename SCAB_T>
-static inline JBLAS_CODE dequant_s32_fp32(const int32_t* srcptr, const int srcstep, float* dstptr, const int dststep,
-                                          const int M, const int N, const float* scaleA, const int ldsa,
-                                          const SCAB_T* scaleB) {
+static inline BTLA_CODE dequant_s32_fp32(const int32_t* srcptr, const int srcstep, float* dstptr, const int dststep,
+                                         const int M, const int N, const float* scaleA, const int ldsa,
+                                         const SCAB_T* scaleB) {
   for (int i = 0; i < M; i++) {
     float scale = scaleA[i * ldsa];
     for (int j = 0; j < N; j++) {
@@ -1173,11 +1171,11 @@ static inline JBLAS_CODE dequant_s32_fp32(const int32_t* srcptr, const int srcst
       dstptr[i * dststep + j] = fsrc;
     }
   }
-  return JblasSuccess;
+  return BTLA_CODE::Success;
 }
 
-inline JBLAS_CODE minmax_f32_kblock(const float* srcptr, int row, int col, int ld_src, float* minmaxptr, int ld_minmax,
-                                    int fsize_minmax, int blocksize) {
+inline BTLA_CODE minmax_f32_kblock(const float* srcptr, int row, int col, int ld_src, float* minmaxptr, int ld_minmax,
+                                   int fsize_minmax, int blocksize) {
   for (int i = 0; i < row; i++) {
     if (col >= blocksize) {
       for (int icol = 0; icol < col; icol += blocksize) {
@@ -1202,32 +1200,32 @@ inline JBLAS_CODE minmax_f32_kblock(const float* srcptr, int row, int col, int l
       minmaxptr[i * ld_minmax + 1] = maxval;
     }
   }
-  return JblasSuccess;
+  return BTLA_CODE::Success;
 }
 
-static inline JBLAS_CODE accumulate_dequantize_s32_f32(const int32_t* srcptr, float* dstptr, float alpha, float beta,
-                                                       int row, int col, int ld_src, int ld_dst, float* ascales,
-                                                       int ldas, float* wscales) {
+static inline BTLA_CODE accumulate_dequantize_s32_f32(const int32_t* srcptr, float* dstptr, float alpha, float beta,
+                                                      int row, int col, int ld_src, int ld_dst, float* ascales,
+                                                      int ldas, float* wscales) {
   for (int irow = 0; irow < row; irow++) {
     for (int icol = 0; icol < col; icol++) {
       float scale = ascales[irow * ldas] * wscales[icol] * alpha;
       dstptr[irow * ld_dst + icol] = scale * srcptr[irow * ld_src + icol] + beta * dstptr[irow * ld_dst + icol];
     }
   }
-  return JblasSuccess;
+  return BTLA_CODE::Success;
 }
 
-static inline JBLAS_CODE broadcast_u8(int num, const uint8_t& srcval, uint8_t* dstptr) {
+static inline BTLA_CODE broadcast_u8(int num, const uint8_t& srcval, uint8_t* dstptr) {
   int i = 0;
   for (; i < num; i++) {
     dstptr[i] = srcval;
   }
-  return JblasSuccess;
+  return BTLA_CODE::Success;
 }
 
 template <typename _RT>
-static inline JBLAS_CODE quant_s8_row_reduce_sum(const int8_t* srcptr, int ldsrc, const float* scales,
-                                                 const int8_t* zero_points, int row, int col, _RT* reduce) {
+static inline BTLA_CODE quant_s8_row_reduce_sum(const int8_t* srcptr, int ldsrc, const float* scales,
+                                                const int8_t* zero_points, int row, int col, _RT* reduce) {
   std::memset(reduce, 0, sizeof(reduce[0]) * col);
   for (int i = 0; i < row; i++) {
     for (int j = 0; j < col; j++) {
@@ -1239,11 +1237,11 @@ static inline JBLAS_CODE quant_s8_row_reduce_sum(const int8_t* srcptr, int ldsrc
       }
     }
   }
-  return JblasSuccess;
+  return BTLA_CODE::Success;
 }
 
 template <typename _RT>
-static inline JBLAS_CODE row_reduce_sum(const float* srcptr, int ldsrc, int row, int col, _RT* reduce) {
+static inline BTLA_CODE row_reduce_sum(const float* srcptr, int ldsrc, int row, int col, _RT* reduce) {
   for (int j = 0; j < col; j++) {
     float tmp = 0.f;
     for (int i = 0; i < row; i++) {
@@ -1251,12 +1249,12 @@ static inline JBLAS_CODE row_reduce_sum(const float* srcptr, int ldsrc, int row,
     }
     reduce[j] = static_cast<_RT>(tmp);
   }
-  return JblasSuccess;
+  return BTLA_CODE::Success;
 }
 
 template <typename SRC_T>
-static inline JBLAS_CODE col_block_reduce_sum(const SRC_T* srcptr, int ldsrc, int row, int col, int blocksize,
-                                              float* reduce, int ldr) {
+static inline BTLA_CODE col_block_reduce_sum(const SRC_T* srcptr, int ldsrc, int row, int col, int blocksize,
+                                             float* reduce, int ldr) {
   for (int i = 0; i < row; i++) {
     for (int j = 0; j < col; j += blocksize) {
       auto tmp = 0.f;
@@ -1268,34 +1266,34 @@ static inline JBLAS_CODE col_block_reduce_sum(const SRC_T* srcptr, int ldsrc, in
       reduce[i * ldr + j / blocksize] = tmp;
     }
   }
-  return JblasSuccess;
+  return BTLA_CODE::Success;
 }
 
-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) {
+static inline BTLA_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 = static_cast<float>(zps[i * lds]) * scales[i * lds];
     for (int j = 0; j < col; j++) {
       accptr[i * ldacc + j] -= zpf * reduce[j];
     }
   }
-  return JblasSuccess;
+  return BTLA_CODE::Success;
 }
 
-static inline JBLAS_CODE remove_wei_zeropoint_bias(float* accptr, int ldacc, int row, int col, int8_t* zps,
-                                                   float* scales, int lds, const float* reduce) {
+static inline BTLA_CODE remove_wei_zeropoint_bias(float* accptr, int ldacc, int row, int col, int8_t* zps,
+                                                  float* scales, int lds, const float* reduce) {
   for (int i = 0; i < row; i++) {
     auto reducef = reduce[i * lds];
     for (int j = 0; j < col; j++) {
       accptr[i * ldacc + j] -= static_cast<float>(zps[j]) * scales[j] * reducef;
     }
   }
-  return JblasSuccess;
+  return BTLA_CODE::Success;
 }
 
-static inline JBLAS_CODE remove_zeropoint_bias(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 BTLA_CODE remove_zeropoint_bias(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) {
   for (int i = 0; i < row; i++) {
     auto reduceaf = reducea[i * lds];
     auto zpaf = static_cast<float>(zpa[i * lds]) * scalea[i * lds];
@@ -1306,8 +1304,8 @@ static inline JBLAS_CODE remove_zeropoint_bias(float* accptr, int ldacc, int row
       accptr[i * ldacc + j] -= zpaf * zpbf * k;
     }
   }
-  return JblasSuccess;
+  return BTLA_CODE::Success;
 }
 }  // namespace ref
 }  // namespace kernel
-}  // namespace jblas
+}  // namespace bestla
diff --git a/bestla/jblas/kernel_wrapper.h b/bestla/bestla/kernel_wrapper.h
similarity index 71%
rename from bestla/jblas/kernel_wrapper.h
rename to bestla/bestla/kernel_wrapper.h
index 742748e89..d0832bd82 100644
--- a/bestla/jblas/kernel_wrapper.h
+++ b/bestla/bestla/kernel_wrapper.h
@@ -16,28 +16,28 @@
 #include <cassert>
 #include <type_traits>
 
-#include "jblas/jit_blas.h"
-#include "jit_blas_utils.h"
+#include "bestla.h"
+#include "bestla_utils.h"
 #include "kernel_avx2.h"
 #include "kernel_avx512f.h"
 #include "kernel_avx512_bf16.h"
 #include "kernel_jit.h"
 #include "kernel_ref.h"
 
-namespace jblas {
+namespace bestla {
 namespace kernel {
 namespace wrapper {
 template <int NTile, int RowPack>
 class PaddingInterleaveMN {
   // M x N ===> N/NTile x M/RowPack x NTile x RowPack (leading dim stride = NTile * dststride)
  public:
-  template <JBLAS_ISA ISA_T, typename T_SRC, typename T_DST = T_SRC>
-  static JBLAS_CODE forward(const T_SRC* src, T_DST* dst, int row, int col, int row_pad, int col_pad, int src_step,
-                            int dst_step) {
+  template <BTLA_ISA ISA_T, typename T_SRC, typename T_DST = T_SRC>
+  static BTLA_CODE forward(const T_SRC* src, T_DST* dst, int row, int col, int row_pad, int col_pad, int src_step,
+                           int dst_step) {
     if constexpr (utils::isa_base<ISA_T>::avx512f) {
       const auto kern_ret = kernel::avx512f::padding_interleave_cvt<T_SRC, T_DST, RowPack>::forward(
           src, dst, NTile, row, col, row_pad, col_pad, src_step, dst_step);
-      if (kern_ret != JblasNotSupport) return kern_ret;
+      if (kern_ret != BTLA_CODE::NotSupport) return kern_ret;
     }
     return ref::padding_interleave(src, dst, row, col, row_pad, col_pad, src_step, dst_step, NTile, RowPack);
   }
@@ -47,9 +47,9 @@ template <int NTile, int RowPack>
 class RevertPaddingInterleaveMN {
   // M x N ===> N/NTile x M/RowPack x NTile x RowPack (leading dim stride = NTile * dststride)
  public:
-  template <JBLAS_ISA ISA_T, typename T_SRC, typename T_DST = T_SRC>
-  static JBLAS_CODE forward(const T_SRC* src, T_DST* dst, int row, int col, int row_pad, int col_pad, int src_step,
-                            int dst_step) {
+  template <BTLA_ISA ISA_T, typename T_SRC, typename T_DST = T_SRC>
+  static BTLA_CODE forward(const T_SRC* src, T_DST* dst, int row, int col, int row_pad, int col_pad, int src_step,
+                           int dst_step) {
     return ref::revert_padding_interleave(src, dst, row, col, row_pad, col_pad, src_step, dst_step, NTile, RowPack);
   }
 };
@@ -59,14 +59,14 @@ class PaddingTransInterleaveMN {
   // row and cols are in terms of src
   // M x N ===> M/MTile x N/ColPack x MTile x ColPack (leading dim stride = MTile * dststride)
  public:
-  template <JBLAS_ISA ISA_T, typename T_SRC, typename T_DST = T_SRC>
-  static JBLAS_CODE forward(const T_SRC* src, T_DST* dst, int row, int col, int row_pad, int col_pad, int src_step,
-                            int dst_step) {
+  template <BTLA_ISA ISA_T, typename T_SRC, typename T_DST = T_SRC>
+  static BTLA_CODE forward(const T_SRC* src, T_DST* dst, int row, int col, int row_pad, int col_pad, int src_step,
+                           int dst_step) {
     // Note: rows/cols and i/j are in terms of src
     if constexpr (utils::isa_base<ISA_T>::avx512f) {
       const auto kern_ret = kernel::avx512f::padding_trans_interleave_cvt<T_SRC, T_DST, ColPack>::forward(
           src, dst, MTile, row, col, row_pad, col_pad, src_step, dst_step);
-      if (kern_ret != JblasNotSupport) return kern_ret;
+      if (kern_ret != BTLA_CODE::NotSupport) return kern_ret;
     }
     return ref::padding_trans_interleave(src, dst, row, col, row_pad, col_pad, src_step, dst_step, MTile, ColPack);
   }
@@ -74,14 +74,14 @@ class PaddingTransInterleaveMN {
 
 class Memcpy2D {
  public:
-  template <JBLAS_ISA ISA_T, typename _SRC_T, typename _DST_T>
-  static JBLAS_CODE forward(const _SRC_T* srcptr, _DST_T* dstptr, int row, int col, int srcstep, int dststep,
-                            void* const_elt_v = nullptr) {
-    auto ret = JblasNotSupport;
+  template <BTLA_ISA ISA_T, typename _SRC_T, typename _DST_T>
+  static BTLA_CODE forward(const _SRC_T* srcptr, _DST_T* dstptr, int row, int col, int srcstep, int dststep,
+                           void* const_elt_v = nullptr) {
+    auto ret = BTLA_CODE::NotSupport;
     if constexpr (utils::isa_base<ISA_T>::avx512f) {
       ret = kernel::jit::JitMemcpy2DAvx512f::forward<_SRC_T, _DST_T>(srcptr, dstptr, row, col, srcstep, dststep,
                                                                      const_elt_v);
-      if (ret == JblasSuccess) {
+      if (ret == BTLA_CODE::Success) {
         return ret;
       }
     }
@@ -93,7 +93,7 @@ class Memcpy2D {
       if (col - align_col > 0)
         ret = kernel::ref::memcpy2d(srcptr + align_col, dstptr + align_col, row, (col - align_col) * sizeof(_SRC_T),
                                     srcstep * sizeof(_SRC_T), dststep * sizeof(_DST_T));
-      if (ret == JblasSuccess) {
+      if (ret == BTLA_CODE::Success) {
         return ret;
       }
     }
@@ -102,15 +102,15 @@ class Memcpy2D {
                                  dststep * sizeof(_DST_T));
   }
 
-  template <JBLAS_ISA ISA_T, typename _SRC_T, typename _DST_T, JBLAS_ELTWISEOP OP_T>
-  static JBLAS_CODE forward1(const _SRC_T* srcptr, _DST_T* dstptr, int row, int col, int srcstep, int dststep,
-                             void* const_elt_v = nullptr) {
-    auto ret = JblasNotSupport;
+  template <BTLA_ISA ISA_T, typename _SRC_T, typename _DST_T, BTLA_ELTWISEOP OP_T>
+  static BTLA_CODE forward1(const _SRC_T* srcptr, _DST_T* dstptr, int row, int col, int srcstep, int dststep,
+                            void* const_elt_v = nullptr) {
+    auto ret = BTLA_CODE::NotSupport;
 #if CompileAVX512F()
     if constexpr (utils::isa_base<ISA_T>::avx512f) {
       ret = kernel::jit::JitMemcpy2DAvx512f::forward1<_SRC_T, _DST_T, OP_T>(srcptr, dstptr, row, col, srcstep, dststep,
                                                                             const_elt_v);
-      if (ret == JblasSuccess) {
+      if (ret == BTLA_CODE::Success) {
         return ret;
       }
     }
@@ -124,7 +124,7 @@ class Memcpy2D {
         ret = kernel::ref::memcpy2d_withop<_SRC_T, _DST_T, OP_T>(
             srcptr + align_col, dstptr + align_col, row, (col - align_col) * sizeof(_SRC_T), srcstep * sizeof(_SRC_T),
             dststep * sizeof(_DST_T), const_elt_v);
-      if (ret == JblasSuccess) {
+      if (ret == BTLA_CODE::Success) {
         return ret;
       }
     }
@@ -135,9 +135,9 @@ class Memcpy2D {
 
 class Memcpy2DFp32CvtBf16 {
  public:
-  template <JBLAS_ISA ISA_T>
-  static JBLAS_CODE forward(const void* srcptr, void* dstptr, int row, int col, int srcstride, int dststride,
-                            bool zeropadding) {
+  template <BTLA_ISA ISA_T>
+  static BTLA_CODE forward(const void* srcptr, void* dstptr, int row, int col, int srcstride, int dststride,
+                           bool zeropadding) {
 #if CompileBF16()
     if constexpr (utils::isa_base<ISA_T>::amx_bf16) {
       return kernel::avx512_bf16::fp32_cvt_bf16_2D_write_back(srcptr, dstptr, row, col, srcstride, dststride,
@@ -161,9 +161,9 @@ class Memcpy2DFp32CvtBf16 {
 
 class Memcpy2DFp32CvtFp16 {
  public:
-  template <JBLAS_ISA ISA_T>
-  static JBLAS_CODE forward(void* srcptr, void* dstptr, int row, int col, int srcstride, int dststride,
-                            bool zeropadding) {
+  template <BTLA_ISA ISA_T>
+  static BTLA_CODE forward(void* srcptr, void* dstptr, int row, int col, int srcstride, int dststride,
+                           bool zeropadding) {
 #if CompileFP16()
     if constexpr (utils::isa_base<ISA_T>::avx512_fp16) {
       return kernel::avx512f::fp32_cvt_fp16_2D_write_back(
@@ -171,15 +171,15 @@ class Memcpy2DFp32CvtFp16 {
           srcstride / sizeof(float), dststride / sizeof(utils::fp16), zeropadding);
     }
 #endif
-    return JblasNotSupport;
+    return BTLA_CODE::NotSupport;
   }
 };
 
 class Memcpy2DFp16CvtFp32 {
  public:
-  template <JBLAS_ISA ISA_T>
-  static JBLAS_CODE forward(void* srcptr, void* dstptr, int row, int col, int srcstride, int dststride,
-                            bool zeropadding) {
+  template <BTLA_ISA ISA_T>
+  static BTLA_CODE forward(void* srcptr, void* dstptr, int row, int col, int srcstride, int dststride,
+                           bool zeropadding) {
 #if CompileFP16()
     if constexpr (utils::isa_base<ISA_T>::avx512_fp16) {
       return kernel::avx512f::fp16_cvt_fp32_2D_write_back(  //
@@ -187,31 +187,31 @@ class Memcpy2DFp16CvtFp32 {
           srcstride / sizeof(utils::fp16), dststride / sizeof(float), zeropadding);
     }
 #endif
-    return JblasNotSupport;
+    return BTLA_CODE::NotSupport;
   }
 };
 
 class Memcpy2DBf16CvtFp32 {
  public:
-  template <JBLAS_ISA ISA_T>
-  static JBLAS_CODE forward(void* srcptr, void* dstptr, int row, int col, int srcstride, int dststride,
-                            bool zeropadding) {
+  template <BTLA_ISA ISA_T>
+  static BTLA_CODE forward(void* srcptr, void* dstptr, int row, int col, int srcstride, int dststride,
+                           bool zeropadding) {
 #if CompileBF16()
-    if constexpr (ISA_T >= JblasAMX_BF16) {
+    if constexpr (ISA_T >= BTLA_ISA::AMX_BF16) {
       return kernel::avx512_bf16::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
 #if CompileAVX512F()
-    if constexpr (ISA_T >= JblasAVX512F) {
+    if constexpr (ISA_T >= BTLA_ISA::AVX512F) {
       return kernel::avx512f::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
 #if CompileAVX2()
-    if constexpr (ISA_T >= JblasAVX2) {
+    if constexpr (ISA_T >= BTLA_ISA::AVX2) {
       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);
@@ -225,9 +225,9 @@ class Memcpy2DBf16CvtFp32 {
 template <int NTILE>
 class CompressS8S4 {
  public:
-  template <JBLAS_ISA ISA_T>
-  static inline JBLAS_CODE forward(const int8_t* srcptr, jblas::utils::int4x2* dstptr, int row, int col, int ld_src,
-                                   int ld_dst) {
+  template <BTLA_ISA ISA_T>
+  static inline BTLA_CODE forward(const int8_t* srcptr, bestla::utils::int4x2* dstptr, int row, int col, int ld_src,
+                                  int ld_dst) {
     return ref::compress_s8_s4<NTILE>(srcptr, dstptr, row, col, ld_src, ld_dst);
   }
 };
@@ -235,9 +235,9 @@ class CompressS8S4 {
 template <int NTILE>
 class CompressFp4 {
  public:
-  template <JBLAS_ISA ISA_T>
-  static inline JBLAS_CODE forward(const int8_t* srcptr, jblas::utils::f4x2* dstptr, int row, int col, int ld_src,
-                                   int ld_dst) {
+  template <BTLA_ISA ISA_T>
+  static inline BTLA_CODE forward(const int8_t* srcptr, bestla::utils::f4x2* dstptr, int row, int col, int ld_src,
+                                  int ld_dst) {
     return ref::compress_f4<NTILE>(srcptr, dstptr, row, col, ld_src, ld_dst);
   }
 };
@@ -245,20 +245,20 @@ class CompressFp4 {
 template <typename _T>
 class Transpose2D {
  public:
-  template <JBLAS_ISA ISA_T>
-  static inline JBLAS_CODE forward(const _T* srcptr, _T* dstptr, int row, int col, int ld_src, int ld_dst) {
+  template <BTLA_ISA ISA_T>
+  static inline BTLA_CODE forward(const _T* srcptr, _T* dstptr, int row, int col, int ld_src, int ld_dst) {
     return ref::transpose2d(srcptr, dstptr, row, col, ld_src, ld_dst);
   }
 };
 
 class QuantizeSignIntRowBlock {
  public:
-  template <JBLAS_ISA ISA_T, JBLAS_DTYPE S4_T>
-  static inline JBLAS_CODE forward(const float* srcptr, int8_t* dstptr, int row, int col, int ld_src, int ld_dst,
-                                   float* scales, int8_t* zero_points, int blocksize) {
+  template <BTLA_ISA ISA_T, BTLA_DTYPE S4_T>
+  static inline BTLA_CODE forward(const float* srcptr, int8_t* dstptr, int row, int col, int ld_src, int ld_dst,
+                                  float* scales, int8_t* zero_points, int blocksize) {
 #if CompileAVX512F()
     if constexpr (utils::isa_base<ISA_T>::avx512f &&
-                  S4_T != JBLAS_DTYPE::S4_FULLRANGE) {  // TODO(zhe): support simd version s4_fullrange quantization.
+                  S4_T != BTLA_DTYPE::S4_FULLRANGE) {  // TODO(zhe): support simd version s4_fullrange quantization.
       return avx512f::quantize_f32_sign_int_rowblock<S4_T>(srcptr, dstptr, row, col, ld_src, ld_dst, scales,
                                                            zero_points, blocksize);
     }
@@ -270,9 +270,9 @@ class QuantizeSignIntRowBlock {
 
 class QuantizeF8RowBlock {
  public:
-  template <JBLAS_ISA ISA_T, JBLAS_DTYPE F8_T>
-  static inline JBLAS_CODE forward(const float* srcptr, int8_t* dstptr, int row, int col, int ld_src, int ld_dst,
-                                   float* scales, int blocksize, JBLAS_DTYPE scale_dtype) {
+  template <BTLA_ISA ISA_T, BTLA_DTYPE F8_T>
+  static inline BTLA_CODE forward(const float* srcptr, int8_t* dstptr, int row, int col, int ld_src, int ld_dst,
+                                  float* scales, int blocksize, BTLA_DTYPE scale_dtype) {
     return ref::quantize_f32_f8_rowblock_mxscale<F8_T>(srcptr, dstptr, row, col, ld_src, ld_dst, scales, blocksize,
                                                        scale_dtype);
   }
@@ -280,9 +280,9 @@ class QuantizeF8RowBlock {
 
 class QuantizeF4RowBlock {
  public:
-  template <JBLAS_ISA ISA_T, JBLAS_DTYPE F4_T>
-  static inline JBLAS_CODE forward(const float* srcptr, int8_t* dstptr, int row, int col, int ld_src, int ld_dst,
-                                   float* scales, int8_t* zero_points, int blocksize) {
+  template <BTLA_ISA ISA_T, BTLA_DTYPE F4_T>
+  static inline BTLA_CODE forward(const float* srcptr, int8_t* dstptr, int row, int col, int ld_src, int ld_dst,
+                                  float* scales, int8_t* zero_points, int blocksize) {
 #if CompileAVX512F()
     if constexpr (utils::isa_base<ISA_T>::avx512f) {
       return avx512f::quantize_f32_f4_rowblock<F4_T>(srcptr, dstptr, row, col, ld_src, ld_dst, scales, zero_points,
@@ -296,9 +296,9 @@ class QuantizeF4RowBlock {
 
 class QuantizeU8ColBlock {
  public:
-  template <JBLAS_ISA ISA_T, typename SRC_T>
-  static inline JBLAS_CODE forward(int row, int col, const SRC_T* srcptr, int ld_src, uint8_t* dstptr, int ld_dst,
-                                   float* scales, int ld_scale, uint8_t* zps, int blocksize, float* blkreduce) {
+  template <BTLA_ISA ISA_T, typename SRC_T>
+  static inline BTLA_CODE forward(int row, int col, const SRC_T* srcptr, int ld_src, uint8_t* dstptr, int ld_dst,
+                                  float* scales, int ld_scale, uint8_t* zps, int blocksize, float* blkreduce) {
 #if CompileAVX512F()
     if constexpr (utils::isa_base<ISA_T>::avx512f) {
       return avx512f::quantize_fp_u8_colblock<SRC_T>(row, col, srcptr, ld_src, dstptr, ld_dst, scales, ld_scale, zps,
@@ -318,9 +318,9 @@ class QuantizeU8ColBlock {
 
 class QuantizeS8ColBlock {
  public:
-  template <JBLAS_ISA ISA_T, typename SRC_T>
-  static inline JBLAS_CODE forward(int row, int col, const SRC_T* srcptr, int ld_src, int8_t* dstptr, int ld_dst,
-                                   float* scales, int ld_scale, int blocksize, float* reduce) {
+  template <BTLA_ISA ISA_T, typename SRC_T>
+  static inline BTLA_CODE forward(int row, int col, const SRC_T* srcptr, int ld_src, int8_t* dstptr, int ld_dst,
+                                  float* scales, int ld_scale, int blocksize, float* reduce) {
 #if CompileAVX512F()
     if constexpr (utils::isa_base<ISA_T>::avx512f) {
       return avx512f::quantize_fp_s8_colblock<SRC_T>(row, col, srcptr, ld_src, dstptr, ld_dst, scales, ld_scale,
@@ -333,8 +333,8 @@ class QuantizeS8ColBlock {
 
 class Broadcast {
  public:
-  template <JBLAS_ISA ISA_T>
-  static inline JBLAS_CODE forward(int num, const uint8_t& srcval, uint8_t* dstptr) {
+  template <BTLA_ISA ISA_T>
+  static inline BTLA_CODE forward(int num, const uint8_t& srcval, uint8_t* dstptr) {
 #if CompileAVX512F()
     if constexpr (utils::isa_base<ISA_T>::avx512f) {
       return avx512f::broadcast_u8(num, srcval, dstptr);
@@ -346,9 +346,9 @@ class Broadcast {
 
 class AccumulateDequantizeS32F32 {
  public:
-  template <JBLAS_ISA ISA_T>
-  static inline JBLAS_CODE forward(const int32_t* srcptr, float* dstptr, float alpha, float beta, int row, int col,
-                                   int ld_src, int ld_dst, float* ascales, int ldas, float* wscales) {
+  template <BTLA_ISA ISA_T>
+  static inline BTLA_CODE forward(const int32_t* srcptr, float* dstptr, float alpha, float beta, int row, int col,
+                                  int ld_src, int ld_dst, float* ascales, int ldas, float* wscales) {
 #if CompileAVX512F()
     if constexpr (utils::isa_base<ISA_T>::avx512f) {
       return avx512f::accumulate_dequantize_s32_f32(srcptr, dstptr, alpha, beta, row, col, ld_src, ld_dst, ascales,
@@ -363,17 +363,17 @@ class AccumulateDequantizeS32F32 {
 template <typename _DST_T, int _PACK_ROW, typename _Z_T = int8_t>  // zero points always be int8_t, not compressed
 class DecompressKBlockS4Fp {
  public:
-  template <JBLAS_ISA ISA_T, typename _SCA_T, JBLAS_DTYPE S4_T>
-  static inline JBLAS_CODE forward(utils::int4x2* srcptr, _DST_T* dstptr, int row, int col, int ld_src, int ld_dst,
-                                   _SCA_T* scales, int8_t* zero_points, int k_offset, int kblock, int NPad, void* tmp,
-                                   size_t tmpsize) {
-    JBLAS_CODE ret = JblasNotSupport;
+  template <BTLA_ISA ISA_T, typename _SCA_T, BTLA_DTYPE S4_T>
+  static inline BTLA_CODE forward(utils::int4x2* srcptr, _DST_T* dstptr, int row, int col, int ld_src, int ld_dst,
+                                  _SCA_T* scales, int8_t* zero_points, int k_offset, int kblock, int NPad, void* tmp,
+                                  size_t tmpsize) {
+    BTLA_CODE ret = BTLA_CODE::NotSupport;
 #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,
           reinterpret_cast<int8_t*>(tmp), tmpsize);
-      if (ret == JblasSuccess) return ret;
+      if (ret == BTLA_CODE::Success) return ret;
     }
 #endif
 #if CompileAVX2()
@@ -407,7 +407,7 @@ class DecompressKBlockS4Fp {
         }
       }
 
-      if (ret == JblasSuccess) return ret;
+      if (ret == BTLA_CODE::Success) 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,
@@ -420,10 +420,10 @@ class DecompressKBlockS4Fp {
 template <typename _DST_T>  // zero points always be int8_t, not compressed
 class DecompressKBlockS4S8Fp {
  public:
-  template <JBLAS_ISA ISA_T, JBLAS_DTYPE S4_T>
-  static inline JBLAS_CODE forward(utils::int4x2* srcptr, _DST_T* dstptr, int row, int col, int ld_src, int ld_dst,
-                                   void* tmp, size_t tmpsize) {
-    JBLAS_CODE ret = JblasNotSupport;
+  template <BTLA_ISA ISA_T, BTLA_DTYPE S4_T>
+  static inline BTLA_CODE forward(utils::int4x2* srcptr, _DST_T* dstptr, int row, int col, int ld_src, int ld_dst,
+                                  void* tmp, size_t tmpsize) {
+    BTLA_CODE ret = BTLA_CODE::NotSupport;
 #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,
@@ -442,16 +442,16 @@ class DecompressKBlockS4S8Fp {
 template <typename _DST_T, int _PACK_ROW>
 class DecompressKBlockF4Fp {
  public:
-  template <JBLAS_ISA ISA_T, typename SCA_T, JBLAS_DTYPE F4_T>
-  static inline JBLAS_CODE forward(utils::f4x2* srcptr, _DST_T* dstptr, int row, int col, int ld_src, int ld_dst,
-                                   SCA_T* scales, int k_offset, int kblock, int NPad, void* tmp, size_t tmpsize) {
-    JBLAS_CODE ret = JblasNotSupport;
+  template <BTLA_ISA ISA_T, typename SCA_T, BTLA_DTYPE F4_T>
+  static inline BTLA_CODE forward(utils::f4x2* srcptr, _DST_T* dstptr, int row, int col, int ld_src, int ld_dst,
+                                  SCA_T* scales, int k_offset, int kblock, int NPad, void* tmp, size_t tmpsize) {
+    BTLA_CODE ret = BTLA_CODE::NotSupport;
 #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,
                                                                              reinterpret_cast<int8_t*>(tmp), tmpsize);
-      if (ret == JblasSuccess) return ret;
+      if (ret == BTLA_CODE::Success) return ret;
     }
 #endif
 #if CompileAVX2()
@@ -459,7 +459,7 @@ class DecompressKBlockF4Fp {
       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;
+      if (ret == BTLA_CODE::Success) 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,
@@ -471,10 +471,10 @@ class DecompressKBlockF4Fp {
 template <typename _DST_T>
 class DecompressKBlockF4FpNoscale {
  public:
-  template <JBLAS_ISA ISA_T, JBLAS_DTYPE F4_T>
-  static inline JBLAS_CODE forward(utils::f4x2* srcptr, _DST_T* dstptr, int row, int col, int ld_src, int ld_dst,
-                                   void* tmp, size_t tmpsize) {
-    JBLAS_CODE ret = JblasNotSupport;
+  template <BTLA_ISA ISA_T, BTLA_DTYPE F4_T>
+  static inline BTLA_CODE forward(utils::f4x2* srcptr, _DST_T* dstptr, int row, int col, int ld_src, int ld_dst,
+                                  void* tmp, size_t tmpsize) {
+    BTLA_CODE ret = BTLA_CODE::NotSupport;
     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,
                                                                     reinterpret_cast<int8_t*>(tmp), tmpsize);
@@ -490,9 +490,9 @@ class DecompressKBlockF4FpNoscale {
 
 class DecompressKBlockS4S8 {
  public:
-  template <JBLAS_ISA ISA_T, JBLAS_DTYPE S4_T>
-  static inline JBLAS_CODE forward(utils::int4x2* srcptr, int8_t* dstptr, int row, int col, int ld_src, int ld_dst) {
-    if constexpr (utils::isa_base<ISA_T>::avx512f && S4_T == JBLAS_DTYPE::S4_CLIP) {
+  template <BTLA_ISA ISA_T, BTLA_DTYPE S4_T>
+  static inline BTLA_CODE forward(utils::int4x2* srcptr, int8_t* dstptr, int row, int col, int ld_src, int ld_dst) {
+    if constexpr (utils::isa_base<ISA_T>::avx512f && S4_T == BTLA_DTYPE::S4_CLIP) {
       return jit::decompress_s4_s8(srcptr, dstptr, row, col, ld_src, ld_dst);
     }
 #if CompileAVX512F()
@@ -512,9 +512,9 @@ class DecompressKBlockS4S8 {
 template <int PACK_ROW>
 class DecompressKBlockF8FP {
  public:
-  template <JBLAS_ISA ISA_T, typename SCA_T, typename DST_T>
-  static inline JBLAS_CODE forward(utils::f8* srcptr, DST_T* dstptr, int row, int col, int ld_src, int ld_dst,
-                                   SCA_T* scales, int k_offset, int kblock, int NPad, JBLAS_DTYPE src_f8_type) {
+  template <BTLA_ISA ISA_T, typename SCA_T, typename DST_T>
+  static inline BTLA_CODE forward(utils::f8* srcptr, DST_T* dstptr, int row, int col, int ld_src, int ld_dst,
+                                  SCA_T* scales, int k_offset, int kblock, int NPad, BTLA_DTYPE src_f8_type) {
 #if CompileAVX512F()
     if constexpr (utils::isa_base<ISA_T>::avx512f) {
       return avx512f::decompress_kblock_f8_fp<true, DST_T, PACK_ROW, SCA_T>(
@@ -535,10 +535,10 @@ class DecompressKBlockF8FP {
 template <typename _DST_T, int PACK_ROW>
 class DecompressKBlockS8Fp {
  public:
-  template <JBLAS_ISA ISA_T, typename SCA_T>
-  static inline JBLAS_CODE forward(int8_t* srcptr, _DST_T* dstptr, int row, int col, int ld_src, int ld_dst,
-                                   SCA_T* scales, int8_t* zero_points, int k_offset, int kblock, int NPad, void* tmp,
-                                   size_t tmpsize) {
+  template <BTLA_ISA ISA_T, typename SCA_T>
+  static inline BTLA_CODE forward(int8_t* srcptr, _DST_T* dstptr, int row, int col, int ld_src, int ld_dst,
+                                  SCA_T* scales, int8_t* zero_points, int k_offset, int kblock, int NPad, void* tmp,
+                                  size_t tmpsize) {
 #if CompileAVX512F()
     if constexpr (utils::isa_base<ISA_T>::avx512f && std::is_same_v<SCA_T, float>) {  // TODO Scale type support
       return jit::DequanKBlockS8Fp::forward_avx512f<PACK_ROW>(srcptr, dstptr, row, col, ld_src, ld_dst, scales,
@@ -561,9 +561,9 @@ class DecompressKBlockS8Fp {
 template <typename _DST_T>
 class DecompressKBlockS8S8Fp {
  public:
-  template <JBLAS_ISA ISA_T>
-  static inline JBLAS_CODE forward(int8_t* srcptr, _DST_T* dstptr, int row, int col, int ld_src, int ld_dst, void* tmp,
-                                   size_t tmpsize) {
+  template <BTLA_ISA ISA_T>
+  static inline BTLA_CODE forward(int8_t* srcptr, _DST_T* dstptr, int row, int col, int ld_src, int ld_dst, void* tmp,
+                                  size_t tmpsize) {
     if constexpr (utils::isa_base<ISA_T>::avx512f) {  // TODO Scale type support
       return avx512f::decompress_kblock_s8_s8fp<_DST_T>(srcptr, dstptr, row, col, ld_src, ld_dst);
     }
@@ -577,9 +577,9 @@ class DecompressKBlockS8S8Fp {
 template <typename _DST_T>
 class DecompressKBlockF8FpNoScale {
  public:
-  template <JBLAS_ISA ISA_T>
-  static inline JBLAS_CODE forward(utils::f8* srcptr, _DST_T* dstptr, int row, int col, int ld_src, int ld_dst,
-                                   void* tmp, size_t tmpsize, JBLAS_DTYPE src_f8_t) {
+  template <BTLA_ISA ISA_T>
+  static inline BTLA_CODE forward(utils::f8* srcptr, _DST_T* dstptr, int row, int col, int ld_src, int ld_dst,
+                                  void* tmp, size_t tmpsize, BTLA_DTYPE src_f8_t) {
 #if CompileAVX512F()
     if constexpr (utils::isa_base<ISA_T>::avx512f) {
       return avx512f::decompress_kblock_f8_fp<false, _DST_T, 1>(
@@ -598,10 +598,10 @@ class DecompressKBlockF8FpNoScale {
 
 class AlphaBetaF32F32 {
  public:
-  template <JBLAS_ISA ISA_T>
-  static JBLAS_CODE forward(const float alpha, const float* srcptr, const int srcstep, const float beta,
-                            const float* src1ptr, const int src1step, float* dstptr, const int dststep, const int M,
-                            const int N) {
+  template <BTLA_ISA ISA_T>
+  static BTLA_CODE forward(const float alpha, const float* srcptr, const int srcstep, const float beta,
+                           const float* src1ptr, const int src1step, float* dstptr, const int dststep, const int M,
+                           const int N) {
 #if CompileAVX512F()
     if constexpr (utils::isa_base<ISA_T>::avx512f) {
       return avx512f::alphabeta_f32_f32(alpha, srcptr, srcstep, beta, src1ptr, src1step, dstptr, dststep, M, N);
@@ -618,9 +618,9 @@ class AlphaBetaF32F32 {
 
 class CompFp32BlockScale {
  public:
-  template <JBLAS_ISA ISA_T, typename SCA_T>
-  static JBLAS_CODE forward(const SCA_T* alpha, const float* srcptr, const int srcstep, float* dstptr,
-                            const int dststep, const int M, const int N) {
+  template <BTLA_ISA ISA_T, typename SCA_T>
+  static BTLA_CODE forward(const SCA_T* alpha, const float* srcptr, const int srcstep, float* dstptr, const int dststep,
+                           const int M, const int N) {
 #if CompileAVX512F()
     if constexpr (utils::isa_base<ISA_T>::avx512f) {
       return avx512f::accum_alphaN_f32_f32(alpha, srcptr, srcstep, dstptr, dststep, M, N);
@@ -635,9 +635,9 @@ class CompFp32BlockScale {
 
 class AccumulateFp32 {
  public:
-  template <JBLAS_ISA ISA_T>
-  static JBLAS_CODE forward(const float* srcptr, const int srcstep, float* dstptr, const int dststep, const int M,
-                            const int N) {
+  template <BTLA_ISA ISA_T>
+  static BTLA_CODE forward(const float* srcptr, const int srcstep, float* dstptr, const int dststep, const int M,
+                           const int N) {
 #if CompileAVX512F()
     if constexpr (utils::isa_base<ISA_T>::avx512f) {
       return avx512f::accum_f32_f32(srcptr, srcstep, dstptr, dststep, M, N);
@@ -649,9 +649,9 @@ class AccumulateFp32 {
 
 class QuanOutS32U32 {
  public:
-  template <JBLAS_ISA ISA_T>
-  static JBLAS_CODE forward(const float alpha, const int32_t* srcptr, const int srcstep, uint8_t* dstptr,
-                            const int dststep, const int M, const int N, float scaleSrc, float scaleDst, int zpDst) {
+  template <BTLA_ISA ISA_T>
+  static BTLA_CODE forward(const float alpha, const int32_t* srcptr, const int srcstep, uint8_t* dstptr,
+                           const int dststep, const int M, const int N, float scaleSrc, float scaleDst, int zpDst) {
 #if CompileAVX512F()
     if constexpr (utils::isa_base<ISA_T>::avx512f) {
       return avx512f::quanout_s32_u32(alpha, srcptr, srcstep, dstptr, dststep, M, N, scaleSrc, scaleDst, zpDst);
@@ -665,9 +665,9 @@ class QuanOutS32U32 {
 // scaleB per channel(N)
 class DequanS32Fp32 {
  public:
-  template <JBLAS_ISA ISA_T, typename SCAB_T>
-  static JBLAS_CODE forward(const int32_t* srcptr, const int srcstep, float* dstptr, const int dststep, const int M,
-                            const int N, const float* scaleA, const int ldsa, const SCAB_T* scaleB) {
+  template <BTLA_ISA ISA_T, typename SCAB_T>
+  static BTLA_CODE forward(const int32_t* srcptr, const int srcstep, float* dstptr, const int dststep, const int M,
+                           const int N, const float* scaleA, const int ldsa, const SCAB_T* scaleB) {
 #if CompileAVX512F()
     if constexpr (utils::isa_base<ISA_T>::avx512f) {
       return avx512f::dequant_s32_fp32(srcptr, srcstep, dstptr, dststep, M, N, scaleA, ldsa, scaleB);
@@ -684,9 +684,9 @@ class DequanS32Fp32 {
 
 class MinMaxKBlock {
  public:
-  template <JBLAS_ISA ISA_T>
-  static inline JBLAS_CODE forward(const float* srcptr, int row, int col, int ld_src, float* minmaxptr, int ld_minmax,
-                                   int fsize_minmax, int blocksize) {
+  template <BTLA_ISA ISA_T>
+  static inline BTLA_CODE forward(const float* srcptr, int row, int col, int ld_src, float* minmaxptr, int ld_minmax,
+                                  int fsize_minmax, int blocksize) {
     return ref::minmax_f32_kblock(srcptr, row, col, ld_src, minmaxptr, ld_minmax, fsize_minmax, blocksize);
   }
 };
@@ -694,9 +694,9 @@ class MinMaxKBlock {
 template <typename _RT>
 class QuantS8RowReduceSum {
  public:
-  template <JBLAS_ISA ISA_T>
-  static inline JBLAS_CODE forward(const int8_t* srcptr, int ldsrc, const float* scales, const int8_t* zero_points,
-                                   int row, int col, _RT* reduce) {
+  template <BTLA_ISA ISA_T>
+  static inline BTLA_CODE forward(const int8_t* srcptr, int ldsrc, const float* scales, const int8_t* zero_points,
+                                  int row, int col, _RT* reduce) {
     return ref::quant_s8_row_reduce_sum(srcptr, ldsrc, scales, zero_points, row, col, reduce);
   }
 };
@@ -704,17 +704,17 @@ class QuantS8RowReduceSum {
 template <typename _RT>
 class RowReduceSum {
  public:
-  template <JBLAS_ISA ISA_T>
-  static inline JBLAS_CODE forward(const float* srcptr, int ldsrc, int row, int col, _RT* reduce) {
+  template <BTLA_ISA ISA_T>
+  static inline BTLA_CODE forward(const float* srcptr, int ldsrc, int row, int col, _RT* reduce) {
     return ref::row_reduce_sum<_RT>(srcptr, ldsrc, row, col, reduce);
   }
 };
 
 class ColBlockReduceSum {
  public:
-  template <JBLAS_ISA ISA_T, typename SRC_T>
-  static inline JBLAS_CODE forward(const SRC_T* srcptr, int ldsrc, int row, int col, int blocksize, float* reduce,
-                                   int ldr) {
+  template <BTLA_ISA ISA_T, typename SRC_T>
+  static inline BTLA_CODE forward(const SRC_T* srcptr, int ldsrc, int row, int col, int blocksize, float* reduce,
+                                  int ldr) {
     if constexpr (utils::isa_base<ISA_T>::avx512f) {
       return avx512f::col_block_reduce_sum<SRC_T>(srcptr, ldsrc, row, col, blocksize, reduce, ldr);
     }
@@ -727,9 +727,9 @@ class ColBlockReduceSum {
 
 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) {
+  template <BTLA_ISA ISA_T>
+  static inline BTLA_CODE forward_wei(float* accptr, int ldacc, int row, int col, int8_t* zps, float* scales, int lds,
+                                      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);
@@ -742,9 +742,9 @@ class RemoveZeroPointBias {
 #endif
     return ref::remove_wei_zeropoint_bias(accptr, ldacc, row, col, zps, scales, lds, reduce);
   }
-  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) {
+  template <BTLA_ISA ISA_T>
+  static inline BTLA_CODE forward_act(float* accptr, int ldacc, int row, int col, uint8_t* zps, float* scales, int lds,
+                                      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);
@@ -757,10 +757,10 @@ class RemoveZeroPointBias {
 #endif
     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) {
+  template <BTLA_ISA ISA_T>
+  static inline BTLA_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,
@@ -778,4 +778,4 @@ class RemoveZeroPointBias {
 
 }  // namespace wrapper
 }  // namespace kernel
-}  // namespace jblas
+}  // namespace bestla
diff --git a/bestla/bestla/ut/bestla.cpp b/bestla/bestla/ut/bestla.cpp
new file mode 100644
index 000000000..dccf567e2
--- /dev/null
+++ b/bestla/bestla/ut/bestla.cpp
@@ -0,0 +1 @@
+#include "../bestla.h"
diff --git a/bestla/jblas/ut/jit_blas_epilogue.cpp b/bestla/bestla/ut/bestla_epilogue.cpp
similarity index 68%
rename from bestla/jblas/ut/jit_blas_epilogue.cpp
rename to bestla/bestla/ut/bestla_epilogue.cpp
index b86213e42..3d83035c3 100644
--- a/bestla/jblas/ut/jit_blas_epilogue.cpp
+++ b/bestla/bestla/ut/bestla_epilogue.cpp
@@ -1,7 +1,7 @@
-#include "../jit_blas_epilogue.h"
-#include "jit_blas_ut.h"
+#include "bestla_epilogue.h"
+#include "bestla_ut.h"
 
-namespace jblas {
+namespace bestla {
 using namespace utils;
 namespace ut {
 class UT_AccumulatorWriteBack {
@@ -9,67 +9,67 @@ class UT_AccumulatorWriteBack {
   UT_AccumulatorWriteBack() {
     UT_START();
     CheckISA(AVX2);
-    fp32ut<JblasAVX2>(127, 255, 0, 0, 127, 255);
-    fp32ut<JblasAVX2>(101, 237, 10, 63, 30, 33);
-    fp32ut_with_custom_gelu<JblasAVX2>(15, 15, 0, 0, 15, 15);
-    fp32ut_with_custom_swish<JblasAVX2>(15, 15, 0, 0, 15, 15);
-    bf16ut<JblasAVX2>(127, 255, 0, 0, 127, 255);
-    bf16ut<JblasAVX2>(101, 237, 10, 63, 30, 33);
-    bf16fp32ut<JblasAVX2>(101, 237, 10, 63, 30, 33);
-    bf16fp32ut<JblasAVX2>(127, 255, 0, 0, 127, 255);
+    fp32ut<BTLA_ISA::AVX2>(127, 255, 0, 0, 127, 255);
+    fp32ut<BTLA_ISA::AVX2>(101, 237, 10, 63, 30, 33);
+    fp32ut_with_custom_gelu<BTLA_ISA::AVX2>(15, 15, 0, 0, 15, 15);
+    fp32ut_with_custom_swish<BTLA_ISA::AVX2>(15, 15, 0, 0, 15, 15);
+    bf16ut<BTLA_ISA::AVX2>(127, 255, 0, 0, 127, 255);
+    bf16ut<BTLA_ISA::AVX2>(101, 237, 10, 63, 30, 33);
+    bf16fp32ut<BTLA_ISA::AVX2>(101, 237, 10, 63, 30, 33);
+    bf16fp32ut<BTLA_ISA::AVX2>(127, 255, 0, 0, 127, 255);
     CheckISA(AVX512F);
-    fp32ut<JblasAVX512F>(127, 255, 0, 0, 127, 255);
-    fp32ut<JblasAVX512F>(101, 237, 10, 63, 30, 33);
-    bf16ut<JblasAVX512F>(127, 255, 0, 0, 127, 255);
-    bf16ut<JblasAVX512F>(101, 237, 10, 63, 30, 33);
-    fp32ut_with_custom_gelu<JblasAVX512F>(15, 15, 0, 0, 15, 15);
-    fp32ut_with_custom_swish<JblasAVX512F>(15, 15, 0, 0, 15, 15);
+    fp32ut<BTLA_ISA::AVX512F>(127, 255, 0, 0, 127, 255);
+    fp32ut<BTLA_ISA::AVX512F>(101, 237, 10, 63, 30, 33);
+    bf16ut<BTLA_ISA::AVX512F>(127, 255, 0, 0, 127, 255);
+    bf16ut<BTLA_ISA::AVX512F>(101, 237, 10, 63, 30, 33);
+    fp32ut_with_custom_gelu<BTLA_ISA::AVX512F>(15, 15, 0, 0, 15, 15);
+    fp32ut_with_custom_swish<BTLA_ISA::AVX512F>(15, 15, 0, 0, 15, 15);
 
-    bf16fp32ut<JblasAVX512F>(101, 237, 10, 63, 30, 33);
-    bf16fp32ut<JblasAVX512F>(127, 255, 0, 0, 127, 255);
+    bf16fp32ut<BTLA_ISA::AVX512F>(101, 237, 10, 63, 30, 33);
+    bf16fp32ut<BTLA_ISA::AVX512F>(127, 255, 0, 0, 127, 255);
   }
-  template <JBLAS_ISA _RT_ISA_T>
+  template <BTLA_ISA _RT_ISA_T>
   void bf16fp32ut(int _M, int _N, int _M_offset, int _N_offset, int _cpy_M, int _cpy_N) {
     printf("Test Case %s %d %d %d %d %d %d\n", __FUNCTION__, _M, _N, _M_offset, _N_offset, _cpy_M, _cpy_N);
     std::vector<bf16> src(_M * _N);
     for (int i = 0; i < _M * _N; i++) src[i].fromfloat(i);
     std::vector<float> dstref(_M * _N, 0), dstker(_M * _N, 0);
     epilogue::gemm::AccumulatorWriteBackBf16Fp32<_RT_ISA_T> ker;
-    epilogue::gemm::AccumulatorWriteBackBf16Fp32<JblasNoSIMD> kerref;
+    epilogue::gemm::AccumulatorWriteBackBf16Fp32<BTLA_ISA::NoSIMD> kerref;
 
     kerref.forward(src.data(), _N, _M_offset, _N_offset, _cpy_M, _cpy_N, {dstref.data(), _N}, cache, CacheSize);
     ker.forward(src.data(), _N, _M_offset, _N_offset, _cpy_M, _cpy_N, {dstker.data(), _N}, cache, CacheSize);
-    jblas::ut::buffer_error(dstref.data(), dstker.data(), dstref.size());
+    ut::buffer_error(dstref.data(), dstker.data(), dstref.size());
   }
-  template <JBLAS_ISA _RT_ISA_T>
+  template <BTLA_ISA _RT_ISA_T>
   void bf16ut(int _M, int _N, int _M_offset, int _N_offset, int _cpy_M, int _cpy_N) {
     printf("Test Case %s %d %d %d %d %d %d\n", __FUNCTION__, _M, _N, _M_offset, _N_offset, _cpy_M, _cpy_N);
     std::vector<float> src(_M * _N);
     for (int i = 0; i < _M * _N; i++) src[i] = float(i);
     std::vector<uint16_t> dstref(_M * _N, 0), dstker(_M * _N, 0);
     epilogue::gemm::AccumulatorWriteBackFp32Bf16<_RT_ISA_T> ker;
-    epilogue::gemm::AccumulatorWriteBackFp32Bf16<JblasNoSIMD> kerref;
+    epilogue::gemm::AccumulatorWriteBackFp32Bf16<BTLA_ISA::NoSIMD> kerref;
 
-    kerref.forward(src.data(), _N, _M_offset, _N_offset, _cpy_M, _cpy_N,
-                   {reinterpret_cast<jblas::bf16*>(dstref.data()), _N}, cache, CacheSize);
-    ker.forward(src.data(), _N, _M_offset, _N_offset, _cpy_M, _cpy_N,
-                {reinterpret_cast<jblas::bf16*>(dstker.data()), _N}, cache, CacheSize);
-    jblas::ut::buffer_error<uint16_t>(dstref.data(), dstker.data(), dstref.size());
+    kerref.forward(src.data(), _N, _M_offset, _N_offset, _cpy_M, _cpy_N, {reinterpret_cast<bf16*>(dstref.data()), _N},
+                   cache, CacheSize);
+    ker.forward(src.data(), _N, _M_offset, _N_offset, _cpy_M, _cpy_N, {reinterpret_cast<bf16*>(dstker.data()), _N},
+                cache, CacheSize);
+    ut::buffer_error<uint16_t>(dstref.data(), dstker.data(), dstref.size());
   }
-  template <JBLAS_ISA _RT_ISA_T>
+  template <BTLA_ISA _RT_ISA_T>
   void fp32ut(int _M, int _N, int _M_offset, int _N_offset, int _cpy_M, int _cpy_N) {
     printf("Test Case %s %d %d %d %d %d %d\n", __FUNCTION__, _M, _N, _M_offset, _N_offset, _cpy_M, _cpy_N);
     std::vector<float> src(_M * _N);
     for (int i = 0; i < _M * _N; i++) src[i] = float(i);
     std::vector<float> dstref(_M * _N, 0), dstker(_M * _N, 0);
     epilogue::gemm::AccumulatorWriteBackFp32<_RT_ISA_T> ker;
-    epilogue::gemm::AccumulatorWriteBackFp32<JblasNoSIMD> kerref;
+    epilogue::gemm::AccumulatorWriteBackFp32<BTLA_ISA::NoSIMD> kerref;
 
     kerref.forward(src.data(), _N, _M_offset, _N_offset, _cpy_M, _cpy_N, {dstref.data(), _N}, cache, CacheSize);
     ker.forward(src.data(), _N, _M_offset, _N_offset, _cpy_M, _cpy_N, {dstker.data(), _N}, cache, CacheSize);
-    jblas::ut::buffer_error<float>(dstref.data(), dstker.data(), dstref.size());
+    ut::buffer_error<float>(dstref.data(), dstker.data(), dstref.size());
   }
-  template <JBLAS_ISA _RT_ISA_T>
+  template <BTLA_ISA _RT_ISA_T>
   void fp32ut_with_custom_gelu(int _M, int _N, int _M_offset, int _N_offset, int _cpy_M, int _cpy_N) {
     printf("Test Case %s %d %d %d %d %d %d\n", __FUNCTION__, _N, _M, _M_offset, _N_offset, _cpy_M, _cpy_N);
     std::vector<float> src(_M * _N);
@@ -81,9 +81,10 @@ class UT_AccumulatorWriteBack {
       return 0.5f * x * (1.f + tanhf(0.7978845834732056f * (x + 0.044714998453855515f * x * x * x)));
     };
     for (int i = 0; i < _M * _N; i++) src[i] = gelu(src[i]);
-    jblas::ut::buffer_error<float>(src.data(), dstker.data(), dstker.size(), 0.000001f);
+    ut::buffer_error<float>(src.data(), dstker.data(), dstker.size(), 0.000001f);
   }
-  template <JBLAS_ISA _RT_ISA_T>
+
+  template <BTLA_ISA _RT_ISA_T>
   void fp32ut_with_custom_swish(int _M, int _N, int _M_offset, int _N_offset, int _cpy_M, int _cpy_N) {
     printf("Test Case %s %d %d %d %d %d %d\n", __FUNCTION__, _N, _M, _M_offset, _N_offset, _cpy_M, _cpy_N);
     std::vector<float> src(_M * _N);
@@ -95,7 +96,7 @@ class UT_AccumulatorWriteBack {
                 CacheSize);
     auto swish = [&](float x) { return x / (1 + exp(-x)); };
     for (int i = 0; i < _M * _N; i++) src[i] = swish(src[i]);
-    jblas::ut::buffer_error<float>(src.data(), dstker.data(), dstker.size(), 0.2f);  // swish use low lprecision exp
+    ut::buffer_error<float>(src.data(), dstker.data(), dstker.size(), 0.2f);  // swish use low lprecision exp
   }
 };
 
@@ -123,18 +124,18 @@ class UT_AlphaBetaProcessFp32 {
     for (int i = 0; i < src.size(); i++) {
       src[i] = float(i);
     }
-    epilogue::gemm::AlphaBetaProcessFp32<JblasNoSIMD> kernref;
-    epilogue::gemm::AlphaBetaProcessFp32<JblasAVX512F> kern0;
+    epilogue::gemm::AlphaBetaProcessFp32<BTLA_ISA::NoSIMD> kernref;
+    epilogue::gemm::AlphaBetaProcessFp32<BTLA_ISA::AVX512F> kern0;
     kernref.forward(src.data(), _srcstep, 0, 0, _M, _N, {dstref.data(), src1.data(), _dststep, _src1step, alpha, beta},
                     cache, CacheSize);
     kern0.forward(src.data(), _srcstep, 0, 0, _M, _N, {dst.data(), src1.data(), _dststep, _src1step, alpha, beta},
                   cache, CacheSize);
-    jblas::ut::buffer_error<float>(dstref.data(), dst.data(), dstref.size());
+    ut::buffer_error<float>(dstref.data(), dst.data(), dstref.size());
   }
 };
-#ifdef JBLAS_UT_EPILOGUE
+#ifdef BTLA_UT_EPILOGUE
 static UT_AccumulatorWriteBack sUT_AccumulatorWriteBack;
 static UT_AlphaBetaProcessFp32 sUT_AlphaBetaProcessFp32;
 #endif
 }  // namespace ut
-}  // namespace jblas
+}  // namespace bestla
diff --git a/bestla/jblas/ut/jit_blas_gemm.cpp b/bestla/bestla/ut/bestla_gemm.cpp
similarity index 99%
rename from bestla/jblas/ut/jit_blas_gemm.cpp
rename to bestla/bestla/ut/bestla_gemm.cpp
index 4b9559f5a..43d86eab0 100644
--- a/bestla/jblas/ut/jit_blas_gemm.cpp
+++ b/bestla/bestla/ut/bestla_gemm.cpp
@@ -1,9 +1,8 @@
-#include "../jit_blas_gemm.h"
+#include "bestla_gemm.h"
+#include "bestla_utils.h"
+#include "bestla_ut.h"
 
-#include "../jit_blas_utils.h"
-#include "jit_blas_ut.h"
-
-namespace jblas {
+namespace bestla {
 using namespace utils;
 
 template <int NTILE>
@@ -1115,4 +1114,4 @@ class UT_GEMM_AMXINT8 {
 static UT_GEMM_AMXINT8 sUT_GEMM_AMXINT8;
 #endif
 }  // namespace ut
-}  // namespace jblas
+}  // namespace bestla
diff --git a/bestla/jblas/ut/jit_blas_parallel.cpp b/bestla/bestla/ut/bestla_parallel.cpp
similarity index 50%
rename from bestla/jblas/ut/jit_blas_parallel.cpp
rename to bestla/bestla/ut/bestla_parallel.cpp
index b730da9fd..81e4eb899 100644
--- a/bestla/jblas/ut/jit_blas_parallel.cpp
+++ b/bestla/bestla/ut/bestla_parallel.cpp
@@ -1,10 +1,10 @@
-#include "../jit_blas_utils.h"
-#include "../jit_blas_parallel.h"
-#include "../jit_blas_device.h"
-#include "../jit_blas_gemm.h"
-#include "jit_blas_ut.h"
-#include "../jit_blas_prologue_a.h"
-namespace jblas {
+#include "bestla_utils.h"
+#include "bestla_parallel.h"
+#include "bestla_device.h"
+#include "bestla_gemm.h"
+#include "bestla_ut.h"
+#include "bestla_prologue_a.h"
+namespace bestla {
 using namespace utils;
 namespace ut {
 #ifdef _OPENMP
@@ -22,13 +22,14 @@ class UT_OMPThreading {
     avector<float> src(row * col), dst(row * col), ref(row * col);
     fill_buffer_randn(src.data(), src.size(), -0.5f, 0.5f);
     int ld_src = col, ld_dst = row;
-    kernel::wrapper::Transpose2D<float>::template forward<JblasAVX512F>(src.data(), ref.data(), row, col, col, row);
-    jblas::parallel::Scheduler2D _para({threads, row, col, 1, 1});
+    kernel::wrapper::Transpose2D<float>::template forward<BTLA_ISA::AVX512F>(src.data(), ref.data(), row, col, col,
+                                                                             row);
+    parallel::Scheduler2D _para({threads, row, col, 1, 1});
     DefaultThreading.parallel_for([&](int tidx) {
-      jblas::parallel::ThreadProblem2D thdp{tidx};
+      parallel::ThreadProblem2D thdp{tidx};
       _para.getIndex(thdp);
       if (thdp.valid) {
-        kernel::wrapper::Transpose2D<float>::template forward<JblasAVX512F>(
+        kernel::wrapper::Transpose2D<float>::template forward<BTLA_ISA::AVX512F>(
             src.data() + thdp.loc[0] * ld_src + thdp.loc[1], dst.data() + thdp.loc[0] + thdp.loc[1] * ld_dst,
             thdp.size[0], thdp.size[1], ld_src, ld_dst);
       }
@@ -55,13 +56,14 @@ class UT_StdThreading {
     avector<float> src(row * col), dst(row * col), ref(row * col);
     fill_buffer_randn(src.data(), src.size(), -0.5f, 0.5f);
     int ld_src = col, ld_dst = row;
-    kernel::wrapper::Transpose2D<float>::template forward<JblasAVX512F>(src.data(), ref.data(), row, col, col, row);
-    jblas::parallel::Scheduler2D _para({threads, row, col, 1, 1});
+    kernel::wrapper::Transpose2D<float>::template forward<BTLA_ISA::AVX512F>(src.data(), ref.data(), row, col, col,
+                                                                             row);
+    parallel::Scheduler2D _para({threads, row, col, 1, 1});
     DefaultThreading.parallel_for([&](int tidx) {
-      jblas::parallel::ThreadProblem2D thdp{tidx};
+      parallel::ThreadProblem2D thdp{tidx};
       _para.getIndex(thdp);
       if (thdp.valid) {
-        kernel::wrapper::Transpose2D<float>::template forward<JblasAVX512F>(
+        kernel::wrapper::Transpose2D<float>::template forward<BTLA_ISA::AVX512F>(
             src.data() + thdp.loc[0] * ld_src + thdp.loc[1], dst.data() + thdp.loc[0] + thdp.loc[1] * ld_dst,
             thdp.size[0], thdp.size[1], ld_src, ld_dst);
       }
@@ -85,10 +87,10 @@ class UT_Scheduler2D {
 
   void ut(int row, int col, int threads) {
     printf("%s %d %d %d\n", __FUNCTION__, row, col, threads);
-    jblas::parallel::Scheduler2D sch;
+    parallel::Scheduler2D sch;
     sch.update({threads, row, col, 1, 1});
     sch.print();
-    jblas::parallel::ThreadProblem2D prb{threads - 1};
+    parallel::ThreadProblem2D prb{threads - 1};
     sch.getIndex(prb);
     prb.print();
   }
@@ -101,22 +103,22 @@ class UT_SchedulerGemmBase {
  public:
   UT_SchedulerGemmBase() {
     UT_START();
-    ut<jblas::gemm::ICoreRowNAmxint8<48, 16>>(2048, 4096, 4096, 48, 2048 * 1024, 32 * 1024);
-    ut<jblas::gemm::SCoreRowNAvx512f<48, 8>>(1, 4096, 4096, 24);
-    ut<jblas::gemm::ICoreRowNAmxint8SS<32, 32>>(2048, 4096, 4096, 24);
-    ut<jblas::gemm::ICoreRowNAmxint8SS<32, 32>>(4, 4096, 4096, 48);
+    ut<gemm::ICoreRowNAmxint8<48, 16>>(2048, 4096, 4096, 48, 2048 * 1024, 32 * 1024);
+    ut<gemm::SCoreRowNAvx512f<48, 8>>(1, 4096, 4096, 24);
+    ut<gemm::ICoreRowNAmxint8SS<32, 32>>(2048, 4096, 4096, 24);
+    ut<gemm::ICoreRowNAmxint8SS<32, 32>>(4, 4096, 4096, 48);
   }
 
   template <class GemmCore_T>
   void ut(int m, int n, int k, int threads, size_t l2cache = 0, size_t l1cache = 0) {
-    printf("%s %d %d %d %d core:%s\n", __FUNCTION__, m, n, k, threads, jblas::gemm::CoreAttr::to_str(GemmCore_T::ID));
-    jblas::parallel::gemm::SchedulerBase<GemmCore_T> sch;
+    printf("%s %d %d %d %d core:%s\n", __FUNCTION__, m, n, k, threads, gemm::CoreAttr::to_str(GemmCore_T::ID));
+    parallel::gemm::SchedulerBase<GemmCore_T> sch;
     GetCPUDevice();
     utils::GemmProblem gp(1, m, n, k);
     sch.update(
         {threads, gp, l2cache == 0 ? _cd->getL2CacheSize() : l2cache, l1cache == 0 ? _cd->getL1CacheSize() : l1cache});
     sch.print();
-    jblas::parallel::gemm::ThreadProblemBase prb{sch.valid_theads() - 1};
+    parallel::gemm::ThreadProblemBase prb{sch.valid_theads() - 1};
     sch.getIndex(prb);
     prb.print();
   }
@@ -129,32 +131,32 @@ class UT_SchedulerGemmKBlock {
  public:
   UT_SchedulerGemmKBlock() {
     UT_START();
-    ut<jblas::gemm::SCoreRowNAvx512f<48, 8>>(1, 4096, 4096, 32, 24);
-    ut<jblas::gemm::SCoreRowNAvx512f<48, 8>>(1, 4096, 4096, 64, 22, 32 * 1024);
-    ut<jblas::gemm::SCoreRowNAvx512f<48, 8>>(1, 4096, 4096, 128, 24);
-    ut<jblas::gemm::SCoreRowNAvx512f<48, 8>>(1, 4096, 4096, 1024, 24);
-    ut<jblas::gemm::ICoreRowNAmxint8SS<64, 16>>(1, 4096, 4096, 64, 24, 32 * 1024);
-    ut<jblas::gemm::ICoreRowNAmxint8SS<64, 16>>(2048, 4096, 4096, 64, 24);
-    ut<jblas::gemm::ICoreRowNAmxint8SS<64, 16>>(2048, 4096, 4096, 4096, 24);
-    ut<jblas::gemm::ICoreRowNAmxint8SS<64, 16>>(2048, 4096, 4096, 4096, 48);
-    ut<jblas::gemm::ICoreRowNAmxint8SS<64, 16>>(2048, 4096, 4096, 4096, 56);
-    ut<jblas::gemm::ICoreRowNAmxint8SS<64, 16>>(2048, 4096, 4096, 32, 56);
-    ut<jblas::gemm::ICoreRowNAmxint8SS<64, 16>>(4, 4096, 4096, 128, 48);
-    ut<jblas::gemm::ICoreRowNAmxint8SS<64, 16>>(4, 4096, 3072, 32, 48);
-    ut<jblas::gemm::ICoreRowNAmxint8SS<64, 16>>(2048, 4096, 3072, 3072, 48);
-    ut<jblas::gemm::ICoreRowNAmxint8SS<64, 16>>(2048, 4096, 3072, 32, 56);
+    ut<gemm::SCoreRowNAvx512f<48, 8>>(1, 4096, 4096, 32, 24);
+    ut<gemm::SCoreRowNAvx512f<48, 8>>(1, 4096, 4096, 64, 22, 32 * 1024);
+    ut<gemm::SCoreRowNAvx512f<48, 8>>(1, 4096, 4096, 128, 24);
+    ut<gemm::SCoreRowNAvx512f<48, 8>>(1, 4096, 4096, 1024, 24);
+    ut<gemm::ICoreRowNAmxint8SS<64, 16>>(1, 4096, 4096, 64, 24, 32 * 1024);
+    ut<gemm::ICoreRowNAmxint8SS<64, 16>>(2048, 4096, 4096, 64, 24);
+    ut<gemm::ICoreRowNAmxint8SS<64, 16>>(2048, 4096, 4096, 4096, 24);
+    ut<gemm::ICoreRowNAmxint8SS<64, 16>>(2048, 4096, 4096, 4096, 48);
+    ut<gemm::ICoreRowNAmxint8SS<64, 16>>(2048, 4096, 4096, 4096, 56);
+    ut<gemm::ICoreRowNAmxint8SS<64, 16>>(2048, 4096, 4096, 32, 56);
+    ut<gemm::ICoreRowNAmxint8SS<64, 16>>(4, 4096, 4096, 128, 48);
+    ut<gemm::ICoreRowNAmxint8SS<64, 16>>(4, 4096, 3072, 32, 48);
+    ut<gemm::ICoreRowNAmxint8SS<64, 16>>(2048, 4096, 3072, 3072, 48);
+    ut<gemm::ICoreRowNAmxint8SS<64, 16>>(2048, 4096, 3072, 32, 56);
   }
 
   template <class GemmCore_T>
   void ut(int m, int n, int k, int kblock, int threads, size_t l1cache = 0) {
     printf("%s %d %d %d %d %d core:%s\n", __FUNCTION__, m, n, k, kblock, threads,
-           jblas::gemm::CoreAttr::to_str(GemmCore_T::ID));
-    jblas::parallel::gemm::SchedulerKBlock<GemmCore_T> sch;
+           gemm::CoreAttr::to_str(GemmCore_T::ID));
+    parallel::gemm::SchedulerKBlock<GemmCore_T> sch;
     GetCPUDevice();
     utils::GemmProblem gp(1, m, n, k, kblock);
     sch.update({threads, gp, _cd->getL2CacheSize(), l1cache == 0 ? _cd->getL1CacheSize() : l1cache});
     sch.print();
-    jblas::parallel::gemm::ThreadProblemBase prb{sch.valid_theads() - 1};
+    parallel::gemm::ThreadProblemBase prb{sch.valid_theads() - 1};
     sch.getIndex(prb);
     prb.print();
   }
@@ -167,34 +169,34 @@ class UT_SchedulerGemmKBlockNew {
  public:
   UT_SchedulerGemmKBlockNew() {
     UT_START();
-    ut<jblas::gemm::ICoreRowNAmxint8SSKBlock<48, 16>>(2011, 32000, 4096, 128, 32);
-    ut<jblas::gemm::ICoreRowNAmxint8SS<64, 16>>(2048, 4096, 4096, 4096, 48);
-    ut<jblas::gemm::ICoreRowNAmxint8SS<64, 16>>(2048, 4096, 4096, 128, 24);
-    ut<jblas::gemm::ICoreRowNAmxint8SS<64, 16>>(2048, 4096, 4096, 4096, 24);
-    ut<jblas::gemm::SCoreRowNAvx512f<48, 8>>(1, 4096, 4096, 32, 24);
-    ut<jblas::gemm::SCoreRowNAvx512f<48, 8>>(1, 4096, 4096, 64, 22, 32 * 1024);
-    ut<jblas::gemm::SCoreRowNAvx512f<48, 8>>(1, 4096, 4096, 128, 24);
-    ut<jblas::gemm::SCoreRowNAvx512f<48, 8>>(1, 4096, 4096, 1024, 24);
-    ut<jblas::gemm::ICoreRowNAmxint8SS<64, 16>>(1, 4096, 4096, 64, 24, 32 * 1024);
-    ut<jblas::gemm::ICoreRowNAmxint8SS<64, 16>>(2048, 4096, 4096, 64, 24);
-    ut<jblas::gemm::ICoreRowNAmxint8SS<64, 16>>(2048, 4096, 4096, 4096, 56);
-    ut<jblas::gemm::ICoreRowNAmxint8SS<64, 16>>(2048, 4096, 4096, 32, 56);
-    ut<jblas::gemm::ICoreRowNAmxint8SS<64, 16>>(4, 4096, 4096, 128, 48);
-    ut<jblas::gemm::ICoreRowNAmxint8SS<64, 16>>(4, 4096, 3072, 32, 48);
-    ut<jblas::gemm::ICoreRowNAmxint8SS<64, 16>>(2048, 4096, 3072, 3072, 48);
-    ut<jblas::gemm::ICoreRowNAmxint8SS<64, 16>>(2048, 4096, 3072, 32, 56);
+    ut<gemm::ICoreRowNAmxint8SSKBlock<48, 16>>(2011, 32000, 4096, 128, 32);
+    ut<gemm::ICoreRowNAmxint8SS<64, 16>>(2048, 4096, 4096, 4096, 48);
+    ut<gemm::ICoreRowNAmxint8SS<64, 16>>(2048, 4096, 4096, 128, 24);
+    ut<gemm::ICoreRowNAmxint8SS<64, 16>>(2048, 4096, 4096, 4096, 24);
+    ut<gemm::SCoreRowNAvx512f<48, 8>>(1, 4096, 4096, 32, 24);
+    ut<gemm::SCoreRowNAvx512f<48, 8>>(1, 4096, 4096, 64, 22, 32 * 1024);
+    ut<gemm::SCoreRowNAvx512f<48, 8>>(1, 4096, 4096, 128, 24);
+    ut<gemm::SCoreRowNAvx512f<48, 8>>(1, 4096, 4096, 1024, 24);
+    ut<gemm::ICoreRowNAmxint8SS<64, 16>>(1, 4096, 4096, 64, 24, 32 * 1024);
+    ut<gemm::ICoreRowNAmxint8SS<64, 16>>(2048, 4096, 4096, 64, 24);
+    ut<gemm::ICoreRowNAmxint8SS<64, 16>>(2048, 4096, 4096, 4096, 56);
+    ut<gemm::ICoreRowNAmxint8SS<64, 16>>(2048, 4096, 4096, 32, 56);
+    ut<gemm::ICoreRowNAmxint8SS<64, 16>>(4, 4096, 4096, 128, 48);
+    ut<gemm::ICoreRowNAmxint8SS<64, 16>>(4, 4096, 3072, 32, 48);
+    ut<gemm::ICoreRowNAmxint8SS<64, 16>>(2048, 4096, 3072, 3072, 48);
+    ut<gemm::ICoreRowNAmxint8SS<64, 16>>(2048, 4096, 3072, 32, 56);
   }
 
   template <class GemmCore_T>
   void ut(int m, int n, int k, int kblock, int threads, size_t l1cache = 0) {
     printf("%s %d %d %d %d %d core:%s\n", __FUNCTION__, m, n, k, kblock, threads,
-           jblas::gemm::CoreAttr::to_str(GemmCore_T::ID));
-    jblas::parallel::gemm::SchedulerKBlockS<GemmCore_T> sch;
+           gemm::CoreAttr::to_str(GemmCore_T::ID));
+    parallel::gemm::SchedulerKBlockS<GemmCore_T> sch;
     GetCPUDevice();
     utils::GemmProblem gp(1, m, n, k, kblock);
     sch.update({threads, gp, _cd->getL2CacheSize(), l1cache == 0 ? _cd->getL1CacheSize() : l1cache});
     sch.print();
-    jblas::parallel::gemm::ThreadProblemBase prb{sch.valid_theads() - 1};
+    parallel::gemm::ThreadProblemBase prb{sch.valid_theads() - 1};
     sch.getIndex(prb);
     prb.print();
   }
@@ -203,4 +205,4 @@ class UT_SchedulerGemmKBlockNew {
 static UT_SchedulerGemmKBlockNew sUT_SchedulerGemmKBlockNew;
 #endif
 }  // namespace ut
-}  // namespace jblas
+}  // namespace bestla
diff --git a/bestla/jblas/ut/jit_blas_prologue_a.cpp b/bestla/bestla/ut/bestla_prologue_a.cpp
similarity index 90%
rename from bestla/jblas/ut/jit_blas_prologue_a.cpp
rename to bestla/bestla/ut/bestla_prologue_a.cpp
index 4af84f0ee..7cb4b6379 100644
--- a/bestla/jblas/ut/jit_blas_prologue_a.cpp
+++ b/bestla/bestla/ut/bestla_prologue_a.cpp
@@ -1,8 +1,8 @@
-#include "../jit_blas_prologue_a.h"
-#include "jit_blas_ut.h"
-#include "../kernel_avx512f.h"
+#include "bestla_prologue_a.h"
+#include "bestla_ut.h"
+#include "kernel_avx512f.h"
 
-namespace jblas {
+namespace bestla {
 using namespace utils;
 namespace ut {
 class UT_ActivationBase {
@@ -24,8 +24,8 @@ class UT_ActivationBase {
     for (int i = 0; i < src.size(); i++) {
       src[i] = static_cast<BType>(i);
     }
-    jblas::prologue_a::gemm::ActivationBase<_T, JblasNoSIMD> reorderref;
-    jblas::prologue_a::gemm::ActivationBase<_T, JblasAVX512F> reorderavx512;
+    prologue_a::gemm::ActivationBase<_T, BTLA_ISA::NoSIMD> reorderref;
+    prologue_a::gemm::ActivationBase<_T, BTLA_ISA::AVX512F> reorderavx512;
     auto dstrefptr = dstref.data();
     auto dstptr = dst.data();
     int dststride = 0;
@@ -37,7 +37,7 @@ class UT_ActivationBase {
     }
   }
 };
-#ifdef JBLAS_UT_PROLOGUE_A
+#ifdef BTLA_UT_PROLOGUE_A
 static UT_ActivationBase sUT_ActivationBase;
 #endif
 
@@ -63,15 +63,15 @@ class UT_ActivationConverter {
     for (int i = 0; i < src.size(); i++) {
       src[i] = static_cast<SrcType>(float(i));
     }
-    jblas::prologue_a::gemm::ActivationConverter<_T, JblasNoSIMD, SRC_T> reorderref;
-    jblas::prologue_a::gemm::ActivationConverter<_T, JblasAVX512F, SRC_T> reorderavx512;
+    prologue_a::gemm::ActivationConverter<_T, BTLA_ISA::NoSIMD, SRC_T> reorderref;
+    prologue_a::gemm::ActivationConverter<_T, BTLA_ISA::AVX512F, SRC_T> reorderavx512;
     auto dstptr = dstref.data();
     int dststride = 0;
     auto ret = reorderref.getActivation(&dstptr, &dststride, {src.data(), lda}, m, k, 0, 0, cache, CacheSize);
-    assert(ret == JblasSuccess);
+    assert(ret == BTLA_CODE::Success);
     dstptr = dst.data();
     ret = reorderavx512.getActivation(&dstptr, &dststride, {src.data(), lda}, m, k, 0, 0, cache, CacheSize);
-    assert(ret == JblasSuccess);
+    assert(ret == BTLA_CODE::Success);
     ut::buffer_error(dst.data(), dstref.data(), dst.size(), AType{0});
     aligned_vector<SrcType> revert(dst.size());
     for (size_t i = 0; i < revert.size(); i++) {
@@ -84,7 +84,7 @@ class UT_ActivationConverter {
     buffer_error_2d(src.data(), revert.data(), m, k, lda, kpad);
   }
 };
-#ifdef JBLAS_UT_PROLOGUE_A
+#ifdef BTLA_UT_PROLOGUE_A
 static UT_ActivationConverter sUT_ActivationConverter;
 #endif
 
@@ -114,8 +114,8 @@ class UT_ActivationU8KBlockQuantize {
   template <typename _T>
   void ut(int m, int k, int lda, int kblock, bool hasreduce = false) {
     int kpad = padto(k, _T::KTILE);
-    printf("Test Case core:%s: %d %d %d %d %d reduce:%d\n", jblas::gemm::CoreAttr::to_str(_T::ID), m, k, lda, kblock,
-           kpad, hasreduce);
+    printf("Test Case core:%s: %d %d %d %d %d reduce:%d\n", gemm::CoreAttr::to_str(_T::ID), m, k, lda, kblock, kpad,
+           hasreduce);
     int kcount = updiv(kpad, kblock);
     utils::aligned_vector<float> raw(m * lda), scales(m * kcount);
     ut::fill_buffer_randn(raw.data(), raw.size(), -0.5f, 0.5f);
@@ -126,7 +126,7 @@ class UT_ActivationU8KBlockQuantize {
 
     kernel::ref::quantize_fp_u8_colblock(m, k, raw.data(), lda, q.data(), lda, scales.data(), kcount, zp.data(), kblock,
                                          hasreduce ? reduce.data() : nullptr);
-    jblas::prologue_a::gemm::ActivationF32KBlockQuantize<_T, _T::ISA> actA;
+    prologue_a::gemm::ActivationF32KBlockQuantize<_T, _T::ISA> actA;
     auto quanAct = actA.createStorage(m, k, kblock, hasreduce);
     avector<int8_t> bufA(quanAct.mSize);
     quanAct.assign(bufA.data());
@@ -149,7 +149,7 @@ class UT_ActivationU8KBlockQuantize {
     }
   }
 };
-#ifdef JBLAS_UT_PROLOGUE_A
+#ifdef BTLA_UT_PROLOGUE_A
 static UT_ActivationU8KBlockQuantize sUT_ActivationU8KBlockQuantize;
 #endif
 
@@ -181,7 +181,7 @@ class UT_ActivationS8KBlockQuantize {
     q.resize(m * lda);
     kernel::ref::quantize_fp_s8_colblock(m, k, raw.data(), k, q.data(), lda, scales.data(), kcount, kblock,
                                          hasreduce ? reduce.data() : nullptr);
-    jblas::prologue_a::gemm::ActivationF32KBlockQuantize<_T, JblasAVX512F> actA;
+    prologue_a::gemm::ActivationF32KBlockQuantize<_T, BTLA_ISA::AVX512F> actA;
     auto quanAct = actA.createStorage(m, k, kblock, hasreduce);
     avector<int8_t> bufA(quanAct.mSize);
     quanAct.assign(bufA.data());
@@ -201,7 +201,7 @@ class UT_ActivationS8KBlockQuantize {
     }
   }
 };
-#ifdef JBLAS_UT_PROLOGUE_A
+#ifdef BTLA_UT_PROLOGUE_A
 static UT_ActivationS8KBlockQuantize sUT_ActivationS8KBlockQuantize;
 #endif
 
@@ -227,7 +227,7 @@ class UT_ShuffleActivationKblock {
       indices[i] = i % 2 == 0 ? (i + 1) == indices.size() ? i : i + 1 : i - 1;
     }
     for (int i = 0; i < src.size(); i++) src[i] = static_cast<_SRC_T>(i);
-    jblas::prologue_a::gemm::ShuffleActivationKBlockBase<GC, JblasNoSIMD, _SRC_T> kernel;
+    prologue_a::gemm::ShuffleActivationKBlockBase<GC, BTLA_ISA::NoSIMD, _SRC_T> kernel;
     auto dstrefptr = dstref.data();
     auto dstptr = dst.data();
     int dststride = 0;
@@ -236,7 +236,7 @@ class UT_ShuffleActivationKblock {
     reordA.assign(bufA.data());
     kernel.preprocess({src.data(), k, nullptr, indices.data(), &reordA}, m, k, 32, &DefaultThreading);
 
-	kernel.getActivation(&dstptr, &dststride, {src.data(), k, nullptr, indices.data(), &reordA}, m, kpad, 0, 0, cache,
+    kernel.getActivation(&dstptr, &dststride, {src.data(), k, nullptr, indices.data(), &reordA}, m, kpad, 0, 0, cache,
                          CacheSize);
     for (int i = 0; i < m; i++) {
       int j = 0;
@@ -265,7 +265,7 @@ class UT_ShuffleActivationKblock {
     kernel::ref::shuffle_activation(raw_cp.data(), raw.data(), m, k, 0, 0, indices.data(), k, k);
     kernel::ref::quantize_fp_s8_colblock(m, k, raw.data(), k, q.data(), lda, scales.data(), kcount, kblock,
                                          hasreduce ? reduce.data() : nullptr);
-    jblas::prologue_a::gemm::ShuffleActivationKBlockQuantize<GC, JblasNoSIMD, float> actA;
+    prologue_a::gemm::ShuffleActivationKBlockQuantize<GC, BTLA_ISA::NoSIMD, float> actA;
     auto quanAct = actA.createQuantStorage(m, k, kblock, hasreduce);
     auto reordAct = actA.createReorderStorage(m, k, kblock);
     avector<int8_t> bufA(quanAct.mSize + reordAct.mSize);
@@ -287,8 +287,8 @@ class UT_ShuffleActivationKblock {
     }
   }
 };
-#ifdef JBLAS_UT_PROLOGUE_A
+#ifdef BTLA_UT_PROLOGUE_A
 static UT_ShuffleActivationKblock sUT_ShuffleActivationKblock;
 #endif
 }  // namespace ut
-}  // namespace jblas
+}  // namespace bestla
diff --git a/bestla/jblas/ut/jit_blas_prologue_b.cpp b/bestla/bestla/ut/bestla_prologue_b.cpp
similarity index 54%
rename from bestla/jblas/ut/jit_blas_prologue_b.cpp
rename to bestla/bestla/ut/bestla_prologue_b.cpp
index 8d1863165..3280e4e4f 100644
--- a/bestla/jblas/ut/jit_blas_prologue_b.cpp
+++ b/bestla/bestla/ut/bestla_prologue_b.cpp
@@ -1,13 +1,12 @@
-#include "../jit_blas_gemm.h"
-#include "../jit_blas_prologue_b.h"
-#include "../jit_blas_parallel.h"
-#include "../jit_blas_device.h"
-#include "../jit_blas_wrapper.h"
-#include "jit_blas_ut.h"
-
-namespace jblas {
+#include "bestla_gemm.h"
+#include "bestla_prologue_b.h"
+#include "bestla_parallel.h"
+#include "bestla_device.h"
+#include "bestla_wrapper.h"
+#include "bestla_ut.h"
+
+namespace bestla {
 using namespace utils;
-using namespace parallel;
 namespace ut {
 class UT_BlockQunatize_INT8 {
  public:
@@ -63,10 +62,10 @@ class UT_BlockQunatize_INT8 {
       }
     }
 
-    auto constexpr RuntimeISA = JblasAVX512F;
-    using PrologueB = jblas::prologue_b::gemm::WeightKBlockNInteger<jblas::gemm::SCoreRowNAvx512f<48, 8>, RuntimeISA>;
+    auto constexpr RuntimeISA = BTLA_ISA::AVX512F;
+    using PrologueB = prologue_b::gemm::WeightKBlockNInteger<gemm::SCoreRowNAvx512f<48, 8>, RuntimeISA>;
     PrologueB kernel;
-    auto ptr = kernel.createStorage(n, k, blocksize, JBLAS_DTYPE::S8, jblas_dtype<float>, jblas_dtype<float>, asym);
+    auto ptr = kernel.createStorage(n, k, blocksize, BTLA_DTYPE::S8, bestla_dtype<float>, bestla_dtype<float>, asym);
     avector<int8_t> buffer(ptr.mSize);
     ptr.assign(buffer.data());
     kernel.packWeight(n, k, dequanRef.data(), ldb, &ptr, &DefaultThreading);
@@ -113,10 +112,10 @@ class UT_BlockQunatize_INT8 {
       }
     }
 
-    auto constexpr RuntimeISA = JblasAVX512F;
-    using PrologueB = jblas::prologue_b::gemm::WeightKBlockNInteger<jblas::gemm::SCoreRowNAvx512f<48, 8>, RuntimeISA>;
+    auto constexpr RuntimeISA = BTLA_ISA::AVX512F;
+    using PrologueB = prologue_b::gemm::WeightKBlockNInteger<gemm::SCoreRowNAvx512f<48, 8>, RuntimeISA>;
     PrologueB kernel;
-    auto ptr = kernel.createStorage(n, k, blocksize, JBLAS_DTYPE::S8, jblas_dtype<float>, jblas_dtype<float>, asym);
+    auto ptr = kernel.createStorage(n, k, blocksize, BTLA_DTYPE::S8, bestla_dtype<float>, bestla_dtype<float>, asym);
     avector<int8_t> buffer(ptr.mSize);
     ptr.assign(buffer.data());
     kernel.packTransposeWeight(n, k, dequanT.data(), k, &ptr, &DefaultThreading);
@@ -130,7 +129,7 @@ class UT_BlockQunatize_INT8 {
     ut::buffer_error(dequanRef.data(), dequant.data(), dequanRef.size(), 0.01f);
   }
 };
-#ifdef JBLAS_UT_PROLOGUE_B
+#ifdef BTLA_UT_PROLOGUE_B
 static UT_BlockQunatize_INT8 sUT_BlockQunatize_INT8;
 #endif
 
@@ -139,23 +138,23 @@ class UT_BlockQunatize_F8 {
   UT_BlockQunatize_F8() {
     UT_START();
     CheckISA(AVX512F);
-    ut(127, 1023, 32, JBLAS_DTYPE::F8_E4M3);
-    ut(127, 1023, 32, JBLAS_DTYPE::F8_E5M2);
+    ut(127, 1023, 32, BTLA_DTYPE::F8_E4M3);
+    ut(127, 1023, 32, BTLA_DTYPE::F8_E5M2);
   }
 
-  void ut(int n, int k, int blocksize, JBLAS_DTYPE QUANT_T) {
+  void ut(int n, int k, int blocksize, BTLA_DTYPE QUANT_T) {
     printf("%s: %d %d %d\n", __FUNCTION__, n, k, blocksize);
     int ldb = n;
     utils::aligned_vector<float> raw(n * k);
     ut::fill_buffer_randn(raw.data(), raw.size(), -3.f, 3.f);
 
-    auto constexpr RuntimeISA = JblasAVX512F;
-    using PrologueB = jblas::prologue_b::gemm::WeightKBlockNFloat<jblas::gemm::SCoreRowNAvx512f<48, 8>, RuntimeISA>;
-    using refPorB = jblas::prologue_b::gemm::WeightKBlockNFloat<jblas::gemm::SCoreRowNAvx512f<48, 8>, JblasNoSIMD>;
+    auto constexpr RuntimeISA = BTLA_ISA::AVX512F;
+    using PrologueB = prologue_b::gemm::WeightKBlockNFloat<gemm::SCoreRowNAvx512f<48, 8>, RuntimeISA>;
+    using refPorB = prologue_b::gemm::WeightKBlockNFloat<gemm::SCoreRowNAvx512f<48, 8>, BTLA_ISA::NoSIMD>;
     PrologueB kernel;
     refPorB ref_ker;
-    auto ptr = kernel.createStorage(n, k, blocksize, QUANT_T, JBLAS_DTYPE::F8_E8M0);
-    auto ref_ptr = kernel.createStorage(n, k, blocksize, QUANT_T, JBLAS_DTYPE::F8_E8M0);
+    auto ptr = kernel.createStorage(n, k, blocksize, QUANT_T, BTLA_DTYPE::F8_E8M0);
+    auto ref_ptr = kernel.createStorage(n, k, blocksize, QUANT_T, BTLA_DTYPE::F8_E8M0);
     avector<int8_t> buffer(ptr.mSize);
     avector<int8_t> ref_buffer(ptr.mSize);
     ptr.assign(buffer.data());
@@ -169,7 +168,7 @@ class UT_BlockQunatize_F8 {
     ut::buffer_error(ref_dequant.data(), dequant.data(), dequant.size(), 0.01f);
   }
 };
-#ifdef JBLAS_UT_PROLOGUE_B
+#ifdef BTLA_UT_PROLOGUE_B
 static UT_BlockQunatize_F8 sUT_BlockQunatize_F8;
 #endif
 
@@ -178,17 +177,17 @@ class UT_TransposeBlockQuantize_F4 {
   UT_TransposeBlockQuantize_F4() {
     UT_START();
     CheckISA(AVX512F);
-    ut(4096, 4096, 32, JBLAS_DTYPE::F4_BNB);
-    ut(1024, 4096, 32, JBLAS_DTYPE::F4_BNB);
-    ut(4096, 1024, 32, JBLAS_DTYPE::F4_BNB);
-    ut(48, 32, 32, JBLAS_DTYPE::F4_BNB);
-    ut(32, 32, 32, JBLAS_DTYPE::F4_BNB);
-    ut(48, 32, 32, JBLAS_DTYPE::F4_BNB);
-    ut(48, 32, 32, JBLAS_DTYPE::F4_NF4);
-    ut(48, 32, 32, JBLAS_DTYPE::F4_E2M1);
+    ut(4096, 4096, 32, BTLA_DTYPE::F4_BNB);
+    ut(1024, 4096, 32, BTLA_DTYPE::F4_BNB);
+    ut(4096, 1024, 32, BTLA_DTYPE::F4_BNB);
+    ut(48, 32, 32, BTLA_DTYPE::F4_BNB);
+    ut(32, 32, 32, BTLA_DTYPE::F4_BNB);
+    ut(48, 32, 32, BTLA_DTYPE::F4_BNB);
+    ut(48, 32, 32, BTLA_DTYPE::F4_NF4);
+    ut(48, 32, 32, BTLA_DTYPE::F4_E2M1);
   }
 
-  void ut(int n, int k, int blocksize, JBLAS_DTYPE F4_T) {
+  void ut(int n, int k, int blocksize, BTLA_DTYPE F4_T) {
     printf("Test Case: %d %d %d\n", n, k, blocksize);
     int ldb = n;
     utils::aligned_vector<float> dequanRef(n * k);
@@ -202,13 +201,13 @@ class UT_TransposeBlockQuantize_F4 {
       for (int j = 0; j < n; j++) {
         if (i % blocksize == 0) {
           switch (F4_T) {
-            case JBLAS_DTYPE::F4_E2M1:
+            case BTLA_DTYPE::F4_E2M1:
               quanW.data()[i * n + j] = 7;  // make sure each block has maximum fp4e2m1 value(0b111) to quantize
               break;
-            case JBLAS_DTYPE::F4_BNB:
+            case BTLA_DTYPE::F4_BNB:
               quanW.data()[i * n + j] = 3;  // make sure each block has maximum fp4bnb value(0b011) to quantize
               break;
-            case JBLAS_DTYPE::F4_NF4:
+            case BTLA_DTYPE::F4_NF4:
               quanW.data()[i * n + j] = 15;  // make sure each block has maximum nf4 value(0b1111) to quantize
               break;
             default:
@@ -220,23 +219,23 @@ class UT_TransposeBlockQuantize_F4 {
     for (int j = 0; j < k; j++) {
       for (int i = 0; i < n; i++) {
         switch (F4_T) {
-          case JBLAS_DTYPE::F4_E2M1:
-            dequanRef[j + i * k] = jblas::kernel::ref::f4_dequantize<JBLAS_DTYPE::F4_E2M1>(
-                quanW.data()[j * ldb + i], scales[j / blocksize * n + i]);
-            quanW.data()[j * ldb + i] = jblas::kernel::ref::f4_quantize<JBLAS_DTYPE::F4_E2M1>(
-                dequanRef[j + i * k] / scales[j / blocksize * n + i]);
+          case BTLA_DTYPE::F4_E2M1:
+            dequanRef[j + i * k] = kernel::ref::f4_dequantize<BTLA_DTYPE::F4_E2M1>(quanW.data()[j * ldb + i],
+                                                                                   scales[j / blocksize * n + i]);
+            quanW.data()[j * ldb + i] =
+                kernel::ref::f4_quantize<BTLA_DTYPE::F4_E2M1>(dequanRef[j + i * k] / scales[j / blocksize * n + i]);
             break;
-          case JBLAS_DTYPE::F4_BNB:
-            dequanRef[j + i * k] = jblas::kernel::ref::f4_dequantize<JBLAS_DTYPE::F4_BNB>(
-                quanW.data()[j * ldb + i], scales[j / blocksize * n + i]);
-            quanW.data()[j * ldb + i] = jblas::kernel::ref::f4_quantize<JBLAS_DTYPE::F4_BNB>(
-                dequanRef[j + i * k] / scales[j / blocksize * n + i]);
+          case BTLA_DTYPE::F4_BNB:
+            dequanRef[j + i * k] = kernel::ref::f4_dequantize<BTLA_DTYPE::F4_BNB>(quanW.data()[j * ldb + i],
+                                                                                  scales[j / blocksize * n + i]);
+            quanW.data()[j * ldb + i] =
+                kernel::ref::f4_quantize<BTLA_DTYPE::F4_BNB>(dequanRef[j + i * k] / scales[j / blocksize * n + i]);
             break;
-          case JBLAS_DTYPE::F4_NF4:
-            dequanRef[j + i * k] = jblas::kernel::ref::f4_dequantize<JBLAS_DTYPE::F4_NF4>(
-                quanW.data()[j * ldb + i], scales[j / blocksize * n + i]);
-            quanW.data()[j * ldb + i] = jblas::kernel::ref::f4_quantize<JBLAS_DTYPE::F4_NF4>(
-                dequanRef[j + i * k] / scales[j / blocksize * n + i]);
+          case BTLA_DTYPE::F4_NF4:
+            dequanRef[j + i * k] = kernel::ref::f4_dequantize<BTLA_DTYPE::F4_NF4>(quanW.data()[j * ldb + i],
+                                                                                  scales[j / blocksize * n + i]);
+            quanW.data()[j * ldb + i] =
+                kernel::ref::f4_quantize<BTLA_DTYPE::F4_NF4>(dequanRef[j + i * k] / scales[j / blocksize * n + i]);
             break;
           default:
             break;
@@ -244,11 +243,11 @@ class UT_TransposeBlockQuantize_F4 {
       }
     }
 
-    auto constexpr RuntimeISA = JblasAVX512F;
-    using PrologueB = jblas::prologue_b::gemm::WeightKBlockNFloat<jblas::gemm::SCoreRowNAvx512f<48, 8>, RuntimeISA>;
+    auto constexpr RuntimeISA = BTLA_ISA::AVX512F;
+    using PrologueB = prologue_b::gemm::WeightKBlockNFloat<gemm::SCoreRowNAvx512f<48, 8>, RuntimeISA>;
     PrologueB kernel;
-    auto packedW = kernel.createStorage(n, k, blocksize, F4_T, jblas_dtype<float>);
-    auto packedW1 = kernel.createStorage(n, k, blocksize, F4_T, jblas_dtype<float>);
+    auto packedW = kernel.createStorage(n, k, blocksize, F4_T, bestla_dtype<float>);
+    auto packedW1 = kernel.createStorage(n, k, blocksize, F4_T, bestla_dtype<float>);
     avector<int8_t> buf(packedW.mSize), buf1(packedW1.mSize);
     packedW.assign(buf.data());
     packedW1.assign(buf1.data());
@@ -261,7 +260,7 @@ class UT_TransposeBlockQuantize_F4 {
     ut::buffer_error(dequanRef.data(), dequant.data(), dequant.size());
   }
 };
-#ifdef JBLAS_UT_PROLOGUE_B
+#ifdef BTLA_UT_PROLOGUE_B
 static UT_TransposeBlockQuantize_F4 sUT_TransposeBlockQuantize_F4;
 #endif
 
@@ -271,14 +270,14 @@ class UT_BlockQuantize_INT4 {
     UT_START();
     CheckISA(AVX2);
     CheckISA(AVX512F);
-    ut_2(4096, 4096, 128, JBLAS_DTYPE::S4_CLIP, false);
-    ut_2(4096, 4096, 128, JBLAS_DTYPE::S4_FULLRANGE, false);
+    ut_2(4096, 4096, 128, BTLA_DTYPE::S4_CLIP, false);
+    ut_2(4096, 4096, 128, BTLA_DTYPE::S4_FULLRANGE, false);
     CheckISA(AVX512F);
-    ut_512vnni(4096, 4096, 128, JBLAS_DTYPE::S4_CLIP, false);
-    ut_512vnni(4096, 4096, 128, JBLAS_DTYPE::S4_CLIP, true);
-    ut_512vnni(4096, 4096, 128, JBLAS_DTYPE::S4_FULLRANGE, false);
+    ut_512vnni(4096, 4096, 128, BTLA_DTYPE::S4_CLIP, false);
+    ut_512vnni(4096, 4096, 128, BTLA_DTYPE::S4_CLIP, true);
+    ut_512vnni(4096, 4096, 128, BTLA_DTYPE::S4_FULLRANGE, false);
   }
-  void ut_2(int n, int k, int blocksize, JBLAS_DTYPE qtype, bool asym = false) {
+  void ut_2(int n, int k, int blocksize, BTLA_DTYPE qtype, bool asym = false) {
     printf("Test Case: %d %d %d %s\n", n, k, blocksize, asym ? "asym" : "sym");
     int ldb = n;
     int kblk_num = utils::updiv(k, blocksize);
@@ -304,13 +303,13 @@ class UT_BlockQuantize_INT4 {
       }
     }
 
-    auto constexpr RuntimeISA = JblasAVX2;
-    using PrologueB = jblas::prologue_b::gemm::WeightKBlockNInteger<jblas::gemm::SCoreRowNAvx2<48, 2>, JblasAVX2>;
-    using PrologueB512 = jblas::prologue_b::gemm::WeightKBlockNInteger<jblas::gemm::SCoreRowNAvx2<48, 2>, JblasAVX512F>;
+    auto constexpr RuntimeISA = BTLA_ISA::AVX2;
+    using PrologueB = prologue_b::gemm::WeightKBlockNInteger<gemm::SCoreRowNAvx2<48, 2>, BTLA_ISA::AVX2>;
+    using PrologueB512 = prologue_b::gemm::WeightKBlockNInteger<gemm::SCoreRowNAvx2<48, 2>, BTLA_ISA::AVX512F>;
     PrologueB kernel;
     PrologueB512 kernel512;
     utils::aligned_vector<int8_t> retW(n * k);
-    auto packedW = kernel.createStorage(n, k, blocksize, qtype, jblas_dtype<float>, jblas_dtype<float>, asym);
+    auto packedW = kernel.createStorage(n, k, blocksize, qtype, bestla_dtype<float>, bestla_dtype<float>, asym);
     avector<int8_t> buffer(packedW.mSize);
     packedW.assign(buffer.data());
     kernel.packWeight(n, k, dequant.data(), ldb, &packedW, &DefaultThreading);
@@ -320,7 +319,7 @@ class UT_BlockQuantize_INT4 {
     kernel512.unpackWeight(n, k, &packedW, unpack512f32.data(), n, &DefaultThreading);
     ut::buffer_error(unpackf32.data(), unpack512f32.data(), unpackf32.size(), 0.01f);
   }
-  void ut_512vnni(int n, int k, int blocksize, JBLAS_DTYPE qtype, bool asym = false) {
+  void ut_512vnni(int n, int k, int blocksize, BTLA_DTYPE qtype, bool asym = false) {
     printf("Test Case: %d %d %d %s\n", n, k, blocksize, asym ? "asym" : "sym");
     int ldb = n;
     int kblk_num = utils::updiv(k, blocksize);
@@ -347,13 +346,12 @@ class UT_BlockQuantize_INT4 {
       }
     }
 
-    auto constexpr RuntimeISA = JblasAVX512_VNNI;
-    using PrologueB =
-        jblas::prologue_b::gemm::WeightKBlockNInteger<jblas::gemm::ICoreRowNAvx512vnni<48, 8>, RuntimeISA>;
+    auto constexpr RuntimeISA = BTLA_ISA::AVX512_VNNI;
+    using PrologueB = prologue_b::gemm::WeightKBlockNInteger<gemm::ICoreRowNAvx512vnni<48, 8>, RuntimeISA>;
 
     PrologueB kernel;
     utils::aligned_vector<int8_t> retW(n * k);
-    auto packedW = kernel.createStorage(n, k, blocksize, qtype, jblas_dtype<float>, jblas_dtype<float>, asym);
+    auto packedW = kernel.createStorage(n, k, blocksize, qtype, bestla_dtype<float>, bestla_dtype<float>, asym);
     avector<int8_t> buffer(packedW.mSize);
     packedW.assign(buffer.data());
     kernel.packWeight(n, k, dequant.data(), ldb, &packedW, &DefaultThreading);
@@ -364,7 +362,7 @@ class UT_BlockQuantize_INT4 {
     ut::buffer_error(dequant.data(), unpackf32.data(), dequant.size(), err_thres);
   }
 };
-#ifdef JBLAS_UT_PROLOGUE_B
+#ifdef BTLA_UT_PROLOGUE_B
 static UT_BlockQuantize_INT4 sUT_BlockQuantize_INT4;
 #endif
 
@@ -373,21 +371,21 @@ class UT_StorageMemCheck {
   UT_StorageMemCheck() {
     UT_START();
     CheckISA(AVX512F);
-    ut_s4(4096, 4096, 128, JBLAS_DTYPE::S4_CLIP);
-    ut_s4(4096, 4096, 32, JBLAS_DTYPE::S4_FULLRANGE, true);
-    ut_f4(4096, 4096, 32, JBLAS_DTYPE::F4_BNB);
-    ut_f4(4096, 4096, 32, JBLAS_DTYPE::F4_E2M1);
+    ut_s4(4096, 4096, 128, BTLA_DTYPE::S4_CLIP);
+    ut_s4(4096, 4096, 32, BTLA_DTYPE::S4_FULLRANGE, true);
+    ut_f4(4096, 4096, 32, BTLA_DTYPE::F4_BNB);
+    ut_f4(4096, 4096, 32, BTLA_DTYPE::F4_E2M1);
   }
 
-  void ut_s4(int n, int k, int blocksize, JBLAS_DTYPE qtype, bool asym = false) {
+  void ut_s4(int n, int k, int blocksize, BTLA_DTYPE qtype, bool asym = false) {
     printf("Test C type Case: %d %d %d %s\n", n, k, blocksize, asym ? "asym" : "sym");
     int ldb = n;
     int kblk_num = utils::updiv(k, blocksize);
-    using GemmCore = jblas::gemm::SCoreRowNAvx512f<48, 8>;
-    using PrologueB = jblas::prologue_b::gemm::WeightKBlockNInteger<GemmCore, JblasAVX2>;
+    using GemmCore = gemm::SCoreRowNAvx512f<48, 8>;
+    using PrologueB = prologue_b::gemm::WeightKBlockNInteger<GemmCore, BTLA_ISA::AVX2>;
     PrologueB ProWei;
 
-    auto packedW = ProWei.createStorage(n, k, blocksize, qtype, jblas_dtype<float>, jblas_dtype<utils::bf16>, asym);
+    auto packedW = ProWei.createStorage(n, k, blocksize, qtype, bestla_dtype<float>, bestla_dtype<utils::bf16>, asym);
     avector<int8_t> buf0(packedW.mSize), buf1(packedW.mSize);
     packedW.assign(buf0.data());
     storage::gemm::StorageWeightKBlockNInteger tmp(GemmCore::ID);
@@ -396,15 +394,15 @@ class UT_StorageMemCheck {
     buffer_error(buf0.data(), buf1.data(), buf0.size());
   }
 
-  void ut_f4(int n, int k, int blocksize, JBLAS_DTYPE qtype) {
+  void ut_f4(int n, int k, int blocksize, BTLA_DTYPE qtype) {
     printf("Test C type Case: %d %d %d\n", n, k, blocksize);
     int ldb = n;
     int kblk_num = utils::updiv(k, blocksize);
-    using GemmCore = jblas::gemm::HCoreRowNAmxbf16<64, 16>;
-    using PrologueB = jblas::prologue_b::gemm::WeightKBlockNFloat<GemmCore, JblasAMX_BF16>;
+    using GemmCore = gemm::HCoreRowNAmxbf16<64, 16>;
+    using PrologueB = prologue_b::gemm::WeightKBlockNFloat<GemmCore, BTLA_ISA::AMX_BF16>;
     PrologueB ProWei;
 
-    auto packedW = ProWei.createStorage(n, k, blocksize, qtype, jblas_dtype<float>);
+    auto packedW = ProWei.createStorage(n, k, blocksize, qtype, bestla_dtype<float>);
     avector<int8_t> buf0(packedW.mSize), buf1(packedW.mSize);
     packedW.assign(buf0.data());
     storage::gemm::StorageWeightKBlockNFloat tmp(GemmCore::ID);
@@ -413,7 +411,7 @@ class UT_StorageMemCheck {
     buffer_error(buf0.data(), buf1.data(), buf0.size());
   }
 };
-#ifdef JBLAS_UT_PROLOGUE_B
+#ifdef BTLA_UT_PROLOGUE_B
 static UT_StorageMemCheck sUT_StorageMemCheck;
 #endif
 
@@ -423,18 +421,18 @@ class UT_ShuffleIndices {
     UT_START();
     CheckISA(AVX2);
     // ut_file();
-    ut_s4(4096, 4096, 32, JBLAS_DTYPE::S4_FULLRANGE, true);
-    ut_s4(4096, 4096, 128, JBLAS_DTYPE::S4_CLIP);
+    ut_s4(4096, 4096, 32, BTLA_DTYPE::S4_FULLRANGE, true);
+    ut_s4(4096, 4096, 128, BTLA_DTYPE::S4_CLIP);
   }
 
-  void ut_s4(int n, int k, int blocksize, JBLAS_DTYPE qtype, bool asym = false) {
+  void ut_s4(int n, int k, int blocksize, BTLA_DTYPE qtype, bool asym = false) {
     printf("Test C type Case: %d %d %d %s\n", n, k, blocksize, asym ? "asym" : "sym");
     int ldb = n;
     int kblk_num = utils::updiv(k, blocksize);
-    using GemmCore = jblas::gemm::SCoreRowNAvx2<24, 4>;
-    using PrologueB = jblas::prologue_b::gemm::WeightKBlockNInteger<GemmCore, JblasAVX2>;
+    using GemmCore = gemm::SCoreRowNAvx2<24, 4>;
+    using PrologueB = prologue_b::gemm::WeightKBlockNInteger<GemmCore, BTLA_ISA::AVX2>;
     PrologueB ProWei;
-    auto packedW = ProWei.createStorage(n, k, blocksize, qtype, jblas_dtype<float>, jblas_dtype<utils::bf16>, asym);
+    auto packedW = ProWei.createStorage(n, k, blocksize, qtype, bestla_dtype<float>, bestla_dtype<utils::bf16>, asym);
     ProWei.enableShuffle(&packedW);
     avector<int> groupindices(k, 0);
     auto groupsize = utils::updiv(k, blocksize);
@@ -461,22 +459,21 @@ class UT_ShuffleIndices {
     int k = 4096;
     int blocksize = 32;
     bool constexpr blauncher = false;
-    auto qtype = JBLAS_DTYPE::S4_CLIP;
+    auto qtype = BTLA_DTYPE::S4_CLIP;
     bool asym = true;
     auto warray = ut::readFile2Buffer<int8_t>("src0_data.bin");
     auto aarray = ut::readFile2Buffer<float>("src1_data.bin");
     auto oarray = ut::readFile2Buffer<float>("tensor_data.bin");
     auto refoarray = ut::readFile2Buffer<float>("tensor_data_ref.bin");
     auto wptr = storage::gemm::PackedWeightParser::deserialBuffer(warray.data());
-    using GemmCore = jblas::gemm::SCoreRowNAvx512f<48, 8>;
+    using GemmCore = gemm::SCoreRowNAvx512f<48, 8>;
     auto wptr_ = reinterpret_cast<storage::gemm::StorageWeightKBlockNInteger*>(wptr);
     utils::GemmProblem gp(1, m, n, k, blocksize);
     avector<float> output(m * n);
     if constexpr (blauncher) {
       using Launcher =
-          wrapper::gemm::LauncherBase<GemmCore::ISA, GemmCore, jblas::prologue_a::gemm::ShuffleActivationKBlockBaseF32,
-                                      jblas::prologue_b::gemm::WeightKBlockNInteger,
-                                      jblas::epilogue::gemm::AccumulatorWriteBackFp32>;
+          wrapper::gemm::LauncherBase<GemmCore::ISA, GemmCore, prologue_a::gemm::ShuffleActivationKBlockBaseF32,
+                                      prologue_b::gemm::WeightKBlockNInteger, epilogue::gemm::AccumulatorWriteBackFp32>;
       static Launcher kernel;
       auto rordA = kernel.mProA.createReorderStorage(m, k, blocksize);
       avector<int8_t> bufA(rordA.mSize);
@@ -486,10 +483,10 @@ class UT_ShuffleIndices {
       parallel::GemmRunWithA<parallel::gemm::SchedulerBase<GemmCore>>(kernel, args, &DefaultThreading);
 
     } else {
-      using Launcher = wrapper::gemm::LauncherKBlock<
-          GemmCore::ISA, GemmCore, jblas::prologue_a::gemm::ShuffleActivationKBlockBaseF32,
-          jblas::prologue_b::gemm::WeightKBlockNInteger, jblas::epilogue::gemm::CompFp32BlockEpilogue,
-          jblas::epilogue::gemm::AccumulatorWriteBackFp32>;
+      using Launcher =
+          wrapper::gemm::LauncherKBlock<GemmCore::ISA, GemmCore, prologue_a::gemm::ShuffleActivationKBlockBaseF32,
+                                        prologue_b::gemm::WeightKBlockNInteger, epilogue::gemm::CompFp32BlockEpilogue,
+                                        epilogue::gemm::AccumulatorWriteBackFp32>;
       static Launcher kernel;
       auto rordA = kernel.mProA.createReorderStorage(m, k, blocksize);
       auto redA = kernel.mProA.createReduceStorage(m, k, blocksize);
@@ -510,7 +507,7 @@ class UT_ShuffleIndices {
     delete wptr;
   }
 };
-#ifdef JBLAS_UT_PROLOGUE_B
+#ifdef BTLA_UT_PROLOGUE_B
 static UT_ShuffleIndices sUT_ShuffleIndices;
 #endif
 
@@ -526,119 +523,112 @@ class UT_CompFp32 {
 
   void ut_f8() {
     CheckISA(AVX2);
-    ut<sAVX2, jblas::prologue_b::gemm::WeightKBlockNFloat, f8>(2, 4096, 4096, 32, JBLAS_DTYPE::F8_E4M3);
-    ut<sAVX2, jblas::prologue_b::gemm::WeightKBlockNFloat, float>(2, 4096, 4096, 32, JBLAS_DTYPE::F8_E4M3);
-    ut<sAVX2, jblas::prologue_b::gemm::WeightKBlockNFloat, f8>(2, 4096, 4096, 32, JBLAS_DTYPE::F8_E5M2);
-    ut<sAVX2, jblas::prologue_b::gemm::WeightKBlockNFloat, float>(2, 4096, 4096, 32, JBLAS_DTYPE::F8_E5M2);
+    ut<sAVX2, prologue_b::gemm::WeightKBlockNFloat, f8>(2, 4096, 4096, 32, BTLA_DTYPE::F8_E4M3);
+    ut<sAVX2, prologue_b::gemm::WeightKBlockNFloat, float>(2, 4096, 4096, 32, BTLA_DTYPE::F8_E4M3);
+    ut<sAVX2, prologue_b::gemm::WeightKBlockNFloat, f8>(2, 4096, 4096, 32, BTLA_DTYPE::F8_E5M2);
+    ut<sAVX2, prologue_b::gemm::WeightKBlockNFloat, float>(2, 4096, 4096, 32, BTLA_DTYPE::F8_E5M2);
     CheckISA(AVX512F);
-    ut<sAVX512F, jblas::prologue_b::gemm::WeightKBlockNFloat, f8>(2, 4096, 4096, 32, JBLAS_DTYPE::F8_E4M3);
-    ut<sAVX512F, jblas::prologue_b::gemm::WeightKBlockNFloat, float>(2, 4096, 4096, 32, JBLAS_DTYPE::F8_E4M3);
-    ut<sAVX512F, jblas::prologue_b::gemm::WeightKBlockNFloat, f8>(2, 4096, 4096, 32, JBLAS_DTYPE::F8_E5M2);
-    ut<sAVX512F, jblas::prologue_b::gemm::WeightKBlockNFloat, float>(2, 4096, 4096, 32, JBLAS_DTYPE::F8_E5M2);
+    ut<sAVX512F, prologue_b::gemm::WeightKBlockNFloat, f8>(2, 4096, 4096, 32, BTLA_DTYPE::F8_E4M3);
+    ut<sAVX512F, prologue_b::gemm::WeightKBlockNFloat, float>(2, 4096, 4096, 32, BTLA_DTYPE::F8_E4M3);
+    ut<sAVX512F, prologue_b::gemm::WeightKBlockNFloat, f8>(2, 4096, 4096, 32, BTLA_DTYPE::F8_E5M2);
+    ut<sAVX512F, prologue_b::gemm::WeightKBlockNFloat, float>(2, 4096, 4096, 32, BTLA_DTYPE::F8_E5M2);
   }
   void ut_s4() {
     CheckISA(AVX2);
-    ut_int<sAVX2, jblas::prologue_b::gemm::WeightKBlockNInteger>(2, 4096, 4096, 32, JBLAS_DTYPE::S4_CLIP,
-                                                                 JBLAS_DTYPE::F32, false);
-    ut_int<sAVX2, jblas::prologue_b::gemm::WeightKBlockNInteger>(2, 4096, 4096, 128, JBLAS_DTYPE::S4_CLIP,
-                                                                 JBLAS_DTYPE::F32, false);
-    ut_int<sAVX2, jblas::prologue_b::gemm::WeightKBlockNInteger>(2, 4096, 4096, -1, JBLAS_DTYPE::S4_CLIP,
-                                                                 JBLAS_DTYPE::F32, false);
-    ut_int<sAVX2, jblas::prologue_b::gemm::WeightKBlockNInteger>(2, 4096, 4096, 32, JBLAS_DTYPE::S4_FULLRANGE,
-                                                                 JBLAS_DTYPE::F32, false);
-    ut_int<sAVX2, jblas::prologue_b::gemm::WeightKBlockNInteger>(2, 4096, 4096, 128, JBLAS_DTYPE::S4_FULLRANGE,
-                                                                 JBLAS_DTYPE::F32, false);
-    ut_int<sAVX2, jblas::prologue_b::gemm::WeightKBlockNInteger>(2, 4096, 4096, -1, JBLAS_DTYPE::S4_FULLRANGE,
-                                                                 JBLAS_DTYPE::F32, false);
-    ut_int<sAVX2, jblas::prologue_b::gemm::WeightKBlockNInteger>(2, 4096, 4096, 32, JBLAS_DTYPE::S4_CLIP,
-                                                                 JBLAS_DTYPE::BF16, false);
-    ut_int<sAVX2, jblas::prologue_b::gemm::WeightKBlockNInteger>(2, 4096, 4096, 32, JBLAS_DTYPE::S4_FULLRANGE,
-                                                                 JBLAS_DTYPE::BF16, false);
+    ut_int<sAVX2, prologue_b::gemm::WeightKBlockNInteger>(2, 4096, 4096, 32, BTLA_DTYPE::S4_CLIP, BTLA_DTYPE::F32,
+                                                          false);
+    ut_int<sAVX2, prologue_b::gemm::WeightKBlockNInteger>(2, 4096, 4096, 128, BTLA_DTYPE::S4_CLIP, BTLA_DTYPE::F32,
+                                                          false);
+    ut_int<sAVX2, prologue_b::gemm::WeightKBlockNInteger>(2, 4096, 4096, -1, BTLA_DTYPE::S4_CLIP, BTLA_DTYPE::F32,
+                                                          false);
+    ut_int<sAVX2, prologue_b::gemm::WeightKBlockNInteger>(2, 4096, 4096, 32, BTLA_DTYPE::S4_FULLRANGE, BTLA_DTYPE::F32,
+                                                          false);
+    ut_int<sAVX2, prologue_b::gemm::WeightKBlockNInteger>(2, 4096, 4096, 128, BTLA_DTYPE::S4_FULLRANGE, BTLA_DTYPE::F32,
+                                                          false);
+    ut_int<sAVX2, prologue_b::gemm::WeightKBlockNInteger>(2, 4096, 4096, -1, BTLA_DTYPE::S4_FULLRANGE, BTLA_DTYPE::F32,
+                                                          false);
+    ut_int<sAVX2, prologue_b::gemm::WeightKBlockNInteger>(2, 4096, 4096, 32, BTLA_DTYPE::S4_CLIP, BTLA_DTYPE::BF16,
+                                                          false);
+    ut_int<sAVX2, prologue_b::gemm::WeightKBlockNInteger>(2, 4096, 4096, 32, BTLA_DTYPE::S4_FULLRANGE, BTLA_DTYPE::BF16,
+                                                          false);
 
     CheckISA(AVX512F);
-    ut_int<sAVX512F, jblas::prologue_b::gemm::WeightKBlockNInteger>(2, 4096, 4096, 32, JBLAS_DTYPE::S4_CLIP,
-                                                                    JBLAS_DTYPE::F32, false);
-    ut_int<sAVX512F, jblas::prologue_b::gemm::WeightKBlockNInteger>(2, 4096, 4096, 128, JBLAS_DTYPE::S4_CLIP,
-                                                                    JBLAS_DTYPE::F32, false);
-    ut_int<sAVX512F, jblas::prologue_b::gemm::WeightKBlockNInteger>(2, 4096, 4096, -1, JBLAS_DTYPE::S4_CLIP,
-                                                                    JBLAS_DTYPE::F32, false);
-    ut_int<sAVX512F, jblas::prologue_b::gemm::WeightKBlockNInteger>(2, 4096, 4096, 32, JBLAS_DTYPE::S4_FULLRANGE,
-                                                                    JBLAS_DTYPE::F32, false);
-    ut_int<sAVX512F, jblas::prologue_b::gemm::WeightKBlockNInteger>(2, 4096, 4096, 128, JBLAS_DTYPE::S4_FULLRANGE,
-                                                                    JBLAS_DTYPE::F32, false);
-    ut_int<sAVX512F, jblas::prologue_b::gemm::WeightKBlockNInteger>(2, 4096, 4096, -1, JBLAS_DTYPE::S4_FULLRANGE,
-                                                                    JBLAS_DTYPE::F32, false);
-    ut_int<sAVX512F, jblas::prologue_b::gemm::WeightKBlockNInteger>(2, 4096, 4096, 32, JBLAS_DTYPE::S4_CLIP,
-                                                                    JBLAS_DTYPE::BF16, false);
-    ut_int<sAVX512F, jblas::prologue_b::gemm::WeightKBlockNInteger>(2, 4096, 4096, 32, JBLAS_DTYPE::S4_FULLRANGE,
-                                                                    JBLAS_DTYPE::BF16, false);
+    ut_int<sAVX512F, prologue_b::gemm::WeightKBlockNInteger>(2, 4096, 4096, 32, BTLA_DTYPE::S4_CLIP, BTLA_DTYPE::F32,
+                                                             false);
+    ut_int<sAVX512F, prologue_b::gemm::WeightKBlockNInteger>(2, 4096, 4096, 128, BTLA_DTYPE::S4_CLIP, BTLA_DTYPE::F32,
+                                                             false);
+    ut_int<sAVX512F, prologue_b::gemm::WeightKBlockNInteger>(2, 4096, 4096, -1, BTLA_DTYPE::S4_CLIP, BTLA_DTYPE::F32,
+                                                             false);
+    ut_int<sAVX512F, prologue_b::gemm::WeightKBlockNInteger>(2, 4096, 4096, 32, BTLA_DTYPE::S4_FULLRANGE,
+                                                             BTLA_DTYPE::F32, false);
+    ut_int<sAVX512F, prologue_b::gemm::WeightKBlockNInteger>(2, 4096, 4096, 128, BTLA_DTYPE::S4_FULLRANGE,
+                                                             BTLA_DTYPE::F32, false);
+    ut_int<sAVX512F, prologue_b::gemm::WeightKBlockNInteger>(2, 4096, 4096, -1, BTLA_DTYPE::S4_FULLRANGE,
+                                                             BTLA_DTYPE::F32, false);
+    ut_int<sAVX512F, prologue_b::gemm::WeightKBlockNInteger>(2, 4096, 4096, 32, BTLA_DTYPE::S4_CLIP, BTLA_DTYPE::BF16,
+                                                             false);
+    ut_int<sAVX512F, prologue_b::gemm::WeightKBlockNInteger>(2, 4096, 4096, 32, BTLA_DTYPE::S4_FULLRANGE,
+                                                             BTLA_DTYPE::BF16, false);
   }
 
   void ut_s8() {
     CheckISA(AVX2);
-    ut_int<sAVX2, jblas::prologue_b::gemm::WeightKBlockNInteger>(2, 4096, 4096, 32, JBLAS_DTYPE::S8, JBLAS_DTYPE::BF16,
-                                                                 false);
-    ut_int<sAVX2, jblas::prologue_b::gemm::WeightKBlockNInteger>(2, 4096, 4096, 32, JBLAS_DTYPE::S8, JBLAS_DTYPE::F32,
-                                                                 false);
-    ut_int<sAVX2, jblas::prologue_b::gemm::WeightKBlockNInteger>(2, 4096, 4096, 128, JBLAS_DTYPE::S8, JBLAS_DTYPE::F32,
-                                                                 false);
-    ut_int<sAVX2, jblas::prologue_b::gemm::WeightKBlockNInteger>(2, 4096, 4096, -1, JBLAS_DTYPE::S8, JBLAS_DTYPE::F32,
-                                                                 false);
+    ut_int<sAVX2, prologue_b::gemm::WeightKBlockNInteger>(2, 4096, 4096, 32, BTLA_DTYPE::S8, BTLA_DTYPE::BF16, false);
+    ut_int<sAVX2, prologue_b::gemm::WeightKBlockNInteger>(2, 4096, 4096, 32, BTLA_DTYPE::S8, BTLA_DTYPE::F32, false);
+    ut_int<sAVX2, prologue_b::gemm::WeightKBlockNInteger>(2, 4096, 4096, 128, BTLA_DTYPE::S8, BTLA_DTYPE::F32, false);
+    ut_int<sAVX2, prologue_b::gemm::WeightKBlockNInteger>(2, 4096, 4096, -1, BTLA_DTYPE::S8, BTLA_DTYPE::F32, false);
 
     CheckISA(AVX512F);
-    ut_int<sAVX512F, jblas::prologue_b::gemm::WeightKBlockNInteger>(2, 4096, 4096, 32, JBLAS_DTYPE::S8,
-                                                                    JBLAS_DTYPE::BF16, false);
-    ut_int<sAVX512F, jblas::prologue_b::gemm::WeightKBlockNInteger>(2, 4096, 4096, 32, JBLAS_DTYPE::S8,
-                                                                    JBLAS_DTYPE::F32, false);
-    ut_int<sAVX512F, jblas::prologue_b::gemm::WeightKBlockNInteger>(2, 4096, 4096, 128, JBLAS_DTYPE::S8,
-                                                                    JBLAS_DTYPE::F32, false);
-    ut_int<sAVX512F, jblas::prologue_b::gemm::WeightKBlockNInteger>(2, 4096, 4096, -1, JBLAS_DTYPE::S8,
-                                                                    JBLAS_DTYPE::F32, false);
+    ut_int<sAVX512F, prologue_b::gemm::WeightKBlockNInteger>(2, 4096, 4096, 32, BTLA_DTYPE::S8, BTLA_DTYPE::BF16,
+                                                             false);
+    ut_int<sAVX512F, prologue_b::gemm::WeightKBlockNInteger>(2, 4096, 4096, 32, BTLA_DTYPE::S8, BTLA_DTYPE::F32, false);
+    ut_int<sAVX512F, prologue_b::gemm::WeightKBlockNInteger>(2, 4096, 4096, 128, BTLA_DTYPE::S8, BTLA_DTYPE::F32,
+                                                             false);
+    ut_int<sAVX512F, prologue_b::gemm::WeightKBlockNInteger>(2, 4096, 4096, -1, BTLA_DTYPE::S8, BTLA_DTYPE::F32, false);
   }
 
   void ut_f4() {
     CheckISA(AVX2);
-    ut<sAVX2, jblas::prologue_b::gemm::WeightKBlockNFloat, float>(2, 4096, 4096, 32, JBLAS_DTYPE::F4_BNB);
-    ut<sAVX2, jblas::prologue_b::gemm::WeightKBlockNFloat, float>(2, 4096, 4096, -1, JBLAS_DTYPE::F4_BNB);
-    ut<sAVX2, jblas::prologue_b::gemm::WeightKBlockNFloat, float>(2, 4096, 4096, 32, JBLAS_DTYPE::F4_E2M1);
-    ut<sAVX2, jblas::prologue_b::gemm::WeightKBlockNFloat, float>(2, 4096, 4096, -1, JBLAS_DTYPE::F4_E2M1);
-    ut<sAVX2, jblas::prologue_b::gemm::WeightKBlockNFloat, float>(2, 4096, 4096, 32, JBLAS_DTYPE::F4_NF4);
-    ut<sAVX2, jblas::prologue_b::gemm::WeightKBlockNFloat, float>(2, 4096, 4096, -1, JBLAS_DTYPE::F4_NF4);
-    ut<sAVX2, jblas::prologue_b::gemm::WeightKBlockNFloat, utils::bf16>(2, 4096, 4096, 32, JBLAS_DTYPE::F4_BNB);
-    ut<sAVX2, jblas::prologue_b::gemm::WeightKBlockNFloat, utils::bf16>(2, 4096, 4096, 32, JBLAS_DTYPE::F4_E2M1);
-    ut<sAVX2, jblas::prologue_b::gemm::WeightKBlockNFloat, utils::bf16>(2, 4096, 4096, 32, JBLAS_DTYPE::F4_NF4);
+    ut<sAVX2, prologue_b::gemm::WeightKBlockNFloat, float>(2, 4096, 4096, 32, BTLA_DTYPE::F4_BNB);
+    ut<sAVX2, prologue_b::gemm::WeightKBlockNFloat, float>(2, 4096, 4096, -1, BTLA_DTYPE::F4_BNB);
+    ut<sAVX2, prologue_b::gemm::WeightKBlockNFloat, float>(2, 4096, 4096, 32, BTLA_DTYPE::F4_E2M1);
+    ut<sAVX2, prologue_b::gemm::WeightKBlockNFloat, float>(2, 4096, 4096, -1, BTLA_DTYPE::F4_E2M1);
+    ut<sAVX2, prologue_b::gemm::WeightKBlockNFloat, float>(2, 4096, 4096, 32, BTLA_DTYPE::F4_NF4);
+    ut<sAVX2, prologue_b::gemm::WeightKBlockNFloat, float>(2, 4096, 4096, -1, BTLA_DTYPE::F4_NF4);
+    ut<sAVX2, prologue_b::gemm::WeightKBlockNFloat, utils::bf16>(2, 4096, 4096, 32, BTLA_DTYPE::F4_BNB);
+    ut<sAVX2, prologue_b::gemm::WeightKBlockNFloat, utils::bf16>(2, 4096, 4096, 32, BTLA_DTYPE::F4_E2M1);
+    ut<sAVX2, prologue_b::gemm::WeightKBlockNFloat, utils::bf16>(2, 4096, 4096, 32, BTLA_DTYPE::F4_NF4);
 
     CheckISA(AVX512F);
-    ut<sAVX512F, jblas::prologue_b::gemm::WeightKBlockNFloat, float>(2, 4096, 4096, 32, JBLAS_DTYPE::F4_BNB);
-    ut<sAVX512F, jblas::prologue_b::gemm::WeightKBlockNFloat, float>(2, 4096, 4096, -1, JBLAS_DTYPE::F4_BNB);
-    ut<sAVX512F, jblas::prologue_b::gemm::WeightKBlockNFloat, float>(2, 4096, 4096, 32, JBLAS_DTYPE::F4_E2M1);
-    ut<sAVX512F, jblas::prologue_b::gemm::WeightKBlockNFloat, float>(2, 4096, 4096, -1, JBLAS_DTYPE::F4_E2M1);
-    ut<sAVX512F, jblas::prologue_b::gemm::WeightKBlockNFloat, float>(2, 4096, 4096, 32, JBLAS_DTYPE::F4_NF4);
-    ut<sAVX512F, jblas::prologue_b::gemm::WeightKBlockNFloat, float>(2, 4096, 4096, -1, JBLAS_DTYPE::F4_NF4);
-    ut<sAVX512F, jblas::prologue_b::gemm::WeightKBlockNFloat, utils::bf16>(2, 4096, 4096, 32, JBLAS_DTYPE::F4_BNB);
-    ut<sAVX512F, jblas::prologue_b::gemm::WeightKBlockNFloat, utils::bf16>(2, 4096, 4096, 32, JBLAS_DTYPE::F4_E2M1);
-    ut<sAVX512F, jblas::prologue_b::gemm::WeightKBlockNFloat, utils::bf16>(2, 4096, 4096, 32, JBLAS_DTYPE::F4_NF4);
+    ut<sAVX512F, prologue_b::gemm::WeightKBlockNFloat, float>(2, 4096, 4096, 32, BTLA_DTYPE::F4_BNB);
+    ut<sAVX512F, prologue_b::gemm::WeightKBlockNFloat, float>(2, 4096, 4096, -1, BTLA_DTYPE::F4_BNB);
+    ut<sAVX512F, prologue_b::gemm::WeightKBlockNFloat, float>(2, 4096, 4096, 32, BTLA_DTYPE::F4_E2M1);
+    ut<sAVX512F, prologue_b::gemm::WeightKBlockNFloat, float>(2, 4096, 4096, -1, BTLA_DTYPE::F4_E2M1);
+    ut<sAVX512F, prologue_b::gemm::WeightKBlockNFloat, float>(2, 4096, 4096, 32, BTLA_DTYPE::F4_NF4);
+    ut<sAVX512F, prologue_b::gemm::WeightKBlockNFloat, float>(2, 4096, 4096, -1, BTLA_DTYPE::F4_NF4);
+    ut<sAVX512F, prologue_b::gemm::WeightKBlockNFloat, utils::bf16>(2, 4096, 4096, 32, BTLA_DTYPE::F4_BNB);
+    ut<sAVX512F, prologue_b::gemm::WeightKBlockNFloat, utils::bf16>(2, 4096, 4096, 32, BTLA_DTYPE::F4_E2M1);
+    ut<sAVX512F, prologue_b::gemm::WeightKBlockNFloat, utils::bf16>(2, 4096, 4096, 32, BTLA_DTYPE::F4_NF4);
   }
 
-  template <class GemmCore_T, template <class _T, JBLAS_ISA> class Wei>
-  void ut_int(int m, int n, int k, int blocksize, JBLAS_DTYPE qtype, JBLAS_DTYPE stype, bool isAsym) {
+  template <class GemmCore_T, template <class _T, BTLA_ISA> class Wei>
+  void ut_int(int m, int n, int k, int blocksize, BTLA_DTYPE qtype, BTLA_DTYPE stype, bool isAsym) {
     printf("Test Case %s: %d %d %d-%d type:%s core:%s scaletype:%s\n", __FUNCTION__, m, n, k, blocksize,
-           jblas_dtype_str(qtype), jblas::gemm::CoreAttr::to_str(GemmCore_T::ID), jblas_dtype_str(stype));
+           bestla_dtype_str(qtype), gemm::CoreAttr::to_str(GemmCore_T::ID), bestla_dtype_str(stype));
     auto constexpr ISA = GemmCore_T::ISA;
-    using Launcher = jblas::wrapper::gemm::LauncherKBlock<
-        ISA, GemmCore_T, prologue_a::gemm::ActivationKBlockBaseF32, jblas::prologue_b::gemm::WeightKBlockNInteger,
-        jblas::epilogue::gemm::CompFp32BlockEpilogue, jblas::epilogue::gemm::AccumulatorWriteBackFp32>;
-    using Parallel = jblas::parallel::gemm::SchedulerKBlock<GemmCore_T>;
+    using Launcher =
+        wrapper::gemm::LauncherKBlock<ISA, GemmCore_T, prologue_a::gemm::ActivationKBlockBaseF32,
+                                      prologue_b::gemm::WeightKBlockNInteger, epilogue::gemm::CompFp32BlockEpilogue,
+                                      epilogue::gemm::AccumulatorWriteBackFp32>;
+    using Parallel = parallel::gemm::SchedulerKBlock<GemmCore_T>;
     Launcher launcher;
     blocksize = blocksize == -1 ? k : blocksize;
     using WType = typename Wei<GemmCore_T, ISA>::StorageWeight;
     WType packedw(0);
-    if constexpr (std::is_same_v<Wei<GemmCore_T, ISA>,
-                                 jblas::prologue_b::gemm::WeightKBlockNInteger<GemmCore_T, ISA>>) {
-      packedw = launcher.mProB.createStorage(n, k, blocksize, qtype, stype, jblas_dtype<float>, isAsym);
-    } else if constexpr (std::is_same_v<Wei<GemmCore_T, ISA>,
-                                        jblas::prologue_b::gemm::WeightKBlockNFloat<GemmCore_T, ISA>>) {
-      packedw = launcher.mProB.createStorage(n, k, blocksize, qtype, stype, JBLAS_DTYPE::EleBitsUndef, false);
+    if constexpr (std::is_same_v<Wei<GemmCore_T, ISA>, prologue_b::gemm::WeightKBlockNInteger<GemmCore_T, ISA>>) {
+      packedw = launcher.mProB.createStorage(n, k, blocksize, qtype, stype, bestla_dtype<float>, isAsym);
+    } else if constexpr (std::is_same_v<Wei<GemmCore_T, ISA>, prologue_b::gemm::WeightKBlockNFloat<GemmCore_T, ISA>>) {
+      packedw = launcher.mProB.createStorage(n, k, blocksize, qtype, stype);
     }
 
     utils::avector<int8_t> buffer(packedw.mSize);
@@ -656,26 +646,38 @@ class UT_CompFp32 {
                                   {&packedw},
                                   {packedw.template SPtr<int8_t>(), packedw.SDtype(), packedw.CStep()},
                                   {matC.data(), n}};
-    GemmRun<Parallel>(launcher, args, &DefaultThreading);
-    auto err = get_ut_err(qtype);
+    parallel::GemmRun<Parallel>(launcher, args, &DefaultThreading);
+    auto err = INT8_ERR;
+    auto dbits = bestla_dtype_bits(qtype);
+    auto type = bestla_dtype_type(qtype);
+    auto constexpr dtype_int = bestla_dtype_type(BTLA_DTYPE::TypeInt);
+    if (type == dtype_int) {
+      if (dbits == 8) {
+        err = INT8_ERR;
+      } else {
+        err = INT4_ERR;
+      }
+    } else {
+      err = FP4_ERR;
+    }
     buffer_error(refC.data(), matC.data(), refC.size(), err);
     buffer_error(refCupk.data(), matC.data(), refCupk.size(), 0.001f);
   }
 
-  template <class GemmCore_T, template <class _T, JBLAS_ISA> class Wei, typename Scale_T>
-  void ut(int m, int n, int k, int blocksize, JBLAS_DTYPE qtype) {
+  template <class GemmCore_T, template <class _T, BTLA_ISA> class Wei, typename Scale_T>
+  void ut(int m, int n, int k, int blocksize, BTLA_DTYPE qtype) {
     printf("Test Case %s: %d %d %d-%d type:%s core:%s scaletype:%s\n", __FUNCTION__, m, n, k, blocksize,
-           jblas_dtype_str(qtype), jblas::gemm::CoreAttr::to_str(GemmCore_T::ID), type_str<Scale_T>);
+           bestla_dtype_str(qtype), gemm::CoreAttr::to_str(GemmCore_T::ID), type_str<Scale_T>);
     auto constexpr ISA = GemmCore_T::ISA;
-    using Launcher = jblas::wrapper::gemm::LauncherKBlock<ISA, GemmCore_T, prologue_a::gemm::ActivationBase, Wei,
-                                                          jblas::epilogue::gemm::CompFp32BlockEpilogue,
-                                                          jblas::epilogue::gemm::AccumulatorWriteBackFp32>;
-    using Parallel = jblas::parallel::gemm::SchedulerKBlock<GemmCore_T>;
+    using Launcher =
+        wrapper::gemm::LauncherKBlock<ISA, GemmCore_T, prologue_a::gemm::ActivationBase, Wei,
+                                      epilogue::gemm::CompFp32BlockEpilogue, epilogue::gemm::AccumulatorWriteBackFp32>;
+    using Parallel = parallel::gemm::SchedulerKBlock<GemmCore_T>;
     Launcher launcher;
     blocksize = blocksize == -1 ? k : blocksize;
     using WType = typename Wei<GemmCore_T, ISA>::StorageWeight;
     WType packedw(0);
-    packedw = launcher.mProB.createStorage(n, k, blocksize, qtype, jblas_dtype<Scale_T>);
+    packedw = launcher.mProB.createStorage(n, k, blocksize, qtype, bestla_dtype<Scale_T>);
 
     utils::avector<int8_t> buffer(packedw.mSize);
     packedw.assign(buffer.data());
@@ -692,16 +694,16 @@ class UT_CompFp32 {
                                   {&packedw},
                                   {packedw.template SPtr<int8_t>(), packedw.SDtype(), packedw.CStep()},
                                   {matC.data(), n}};
-    GemmRun<Parallel>(launcher, args, &DefaultThreading);
+    parallel::GemmRun<Parallel>(launcher, args, &DefaultThreading);
     auto err = FP4_ERR;
 
-    if (qtype == JBLAS_DTYPE::F8_E5M2 || qtype == JBLAS_DTYPE::F8_E4M3) err = F8_ERR;
+    if (qtype == BTLA_DTYPE::F8_E5M2 || qtype == BTLA_DTYPE::F8_E4M3) err = F8_ERR;
 
     buffer_error(refC.data(), matC.data(), refC.size(), err);
     buffer_error(refCupk.data(), matC.data(), refCupk.size(), 0.001f);
   }
 };
-#ifdef JBLAS_UT_PROLOGUE_B
+#ifdef BTLA_UT_PROLOGUE_B
 static UT_CompFp32 sUT_CompFp32;
 #endif
 
@@ -716,56 +718,57 @@ class UTBenchmark_CompFp32 {
   }
 
   void ut_s4() {
-    benchmark_all<jblas::prologue_b::gemm::WeightKBlockNInteger, float>(1, 4096, 4096, 128, JBLAS_DTYPE::S4_CLIP);
-    benchmark_all<jblas::prologue_b::gemm::WeightKBlockNInteger, utils::bf16>(1, 4096, 4096, 128, JBLAS_DTYPE::S4_CLIP);
-    // benchmark_all<jblas::prologue_b::gemm::WeightKBlockS4, float>(2048, 4096, 4096, 128, JBLAS_DTYPE::S4_CLIP);
-    // benchmark_all<jblas::prologue_b::gemm::WeightKBlockS4, float>(4096, 4096, 11008, 128, JBLAS_DTYPE::S4_CLIP);
-    //  benchmark_all<jblas::prologue_b::gemm::WeightKBlockS4, float>(2, 4096, 4096, 32, JBLAS_DTYPE::S4_FULLRANGE);
-    //  benchmark_all<jblas::prologue_b::gemm::WeightKBlockS4, float>(2, 4096, 4096, 128, JBLAS_DTYPE::S4_FULLRANGE);
-    //  benchmark_all<jblas::prologue_b::gemm::WeightKBlockS4, float>(2, 4096, 4096, -1, JBLAS_DTYPE::S4_FULLRANGE);
-    //  benchmark_all<jblas::prologue_b::gemm::WeightKBlockS4, utils::bf16>(2, 4096, 4096, 32, JBLAS_DTYPE::S4_CLIP);
-    //  benchmark_all<jblas::prologue_b::gemm::WeightKBlockS4, utils::bf16>(2, 4096, 4096, 32,
-    //  JBLAS_DTYPE::S4_FULLRANGE);
+    benchmark_all<prologue_b::gemm::WeightKBlockNInteger, float>(1, 4096, 4096, 128, BTLA_DTYPE::S4_CLIP);
+    benchmark_all<prologue_b::gemm::WeightKBlockNInteger, utils::bf16>(1, 4096, 4096, 128, BTLA_DTYPE::S4_CLIP);
+    // benchmark_all<prologue_b::gemm::WeightKBlockS4, float>(2048, 4096, 4096, 128, BTLA_DTYPE::S4_CLIP);
+    // benchmark_all<prologue_b::gemm::WeightKBlockS4, float>(4096, 4096, 11008, 128, BTLA_DTYPE::S4_CLIP);
+    //  benchmark_all<prologue_b::gemm::WeightKBlockS4, float>(2, 4096, 4096, 32, BTLA_DTYPE::S4_FULLRANGE);
+    //  benchmark_all<prologue_b::gemm::WeightKBlockS4, float>(2, 4096, 4096, 128, BTLA_DTYPE::S4_FULLRANGE);
+    //  benchmark_all<prologue_b::gemm::WeightKBlockS4, float>(2, 4096, 4096, -1, BTLA_DTYPE::S4_FULLRANGE);
+    //  benchmark_all<prologue_b::gemm::WeightKBlockS4, utils::bf16>(2, 4096, 4096, 32, BTLA_DTYPE::S4_CLIP);
+    //  benchmark_all<prologue_b::gemm::WeightKBlockS4, utils::bf16>(2, 4096, 4096, 32,
+    //  BTLA_DTYPE::S4_FULLRANGE);
   }
 
   // void ut_s8() {
-  //   ut<sAMX_BF16, jblas::prologue_b::gemm::WeightKBlockS8, float>(2, 4096, 4096, 32, JBLAS_DTYPE::S8);
-  //   ut<sAMX_BF16, jblas::prologue_b::gemm::WeightKBlockS8, float>(2, 4096, 4096, 128, JBLAS_DTYPE::S8);
-  //   ut<sAMX_BF16, jblas::prologue_b::gemm::WeightKBlockS8, float>(2, 4096, 4096, -1, JBLAS_DTYPE::S8);
-  //   ut<sAMX_BF16, jblas::prologue_b::gemm::WeightKBlockS8, utils::bf16>(2, 4096, 4096, 32, JBLAS_DTYPE::S8);
+  //   ut<sAMX_BF16, prologue_b::gemm::WeightKBlockS8, float>(2, 4096, 4096, 32, BTLA_DTYPE::S8);
+  //   ut<sAMX_BF16, prologue_b::gemm::WeightKBlockS8, float>(2, 4096, 4096, 128, BTLA_DTYPE::S8);
+  //   ut<sAMX_BF16, prologue_b::gemm::WeightKBlockS8, float>(2, 4096, 4096, -1, BTLA_DTYPE::S8);
+  //   ut<sAMX_BF16, prologue_b::gemm::WeightKBlockS8, utils::bf16>(2, 4096, 4096, 32, BTLA_DTYPE::S8);
   // }
 
   // void ut_f4() {
-  //   ut<sAMX_BF16, jblas::prologue_b::gemm::WeightKBlockF4, float>(2, 4096, 4096, 32, JBLAS_DTYPE::F4_BNB);
-  //   ut<sAMX_BF16, jblas::prologue_b::gemm::WeightKBlockF4, float>(2, 4096, 4096, -1, JBLAS_DTYPE::F4_BNB);
-  //   ut<sAMX_BF16, jblas::prologue_b::gemm::WeightKBlockF4, float>(2, 4096, 4096, 32, JBLAS_DTYPE::F4_E2M1);
-  //   ut<sAMX_BF16, jblas::prologue_b::gemm::WeightKBlockF4, float>(2, 4096, 4096, -1, JBLAS_DTYPE::F4_E2M1);
-  //   ut<sAMX_BF16, jblas::prologue_b::gemm::WeightKBlockF4, float>(2, 4096, 4096, 32, JBLAS_DTYPE::F4_NF4);
-  //   ut<sAMX_BF16, jblas::prologue_b::gemm::WeightKBlockF4, float>(2, 4096, 4096, -1, JBLAS_DTYPE::F4_NF4);
-  //   ut<sAMX_BF16, jblas::prologue_b::gemm::WeightKBlockF4, utils::bf16>(2, 4096, 4096, 32, JBLAS_DTYPE::F4_BNB);
-  //   ut<sAMX_BF16, jblas::prologue_b::gemm::WeightKBlockF4, utils::bf16>(2, 4096, 4096, 32, JBLAS_DTYPE::F4_E2M1);
-  //   ut<sAMX_BF16, jblas::prologue_b::gemm::WeightKBlockF4, utils::bf16>(2, 4096, 4096, 32, JBLAS_DTYPE::F4_NF4);
+  //   ut<sAMX_BF16, prologue_b::gemm::WeightKBlockF4, float>(2, 4096, 4096, 32, BTLA_DTYPE::F4_BNB);
+  //   ut<sAMX_BF16, prologue_b::gemm::WeightKBlockF4, float>(2, 4096, 4096, -1, BTLA_DTYPE::F4_BNB);
+  //   ut<sAMX_BF16, prologue_b::gemm::WeightKBlockF4, float>(2, 4096, 4096, 32, BTLA_DTYPE::F4_E2M1);
+  //   ut<sAMX_BF16, prologue_b::gemm::WeightKBlockF4, float>(2, 4096, 4096, -1, BTLA_DTYPE::F4_E2M1);
+  //   ut<sAMX_BF16, prologue_b::gemm::WeightKBlockF4, float>(2, 4096, 4096, 32, BTLA_DTYPE::F4_NF4);
+  //   ut<sAMX_BF16, prologue_b::gemm::WeightKBlockF4, float>(2, 4096, 4096, -1, BTLA_DTYPE::F4_NF4);
+  //   ut<sAMX_BF16, prologue_b::gemm::WeightKBlockF4, utils::bf16>(2, 4096, 4096, 32, BTLA_DTYPE::F4_BNB);
+  //   ut<sAMX_BF16, prologue_b::gemm::WeightKBlockF4, utils::bf16>(2, 4096, 4096, 32, BTLA_DTYPE::F4_E2M1);
+  //   ut<sAMX_BF16, prologue_b::gemm::WeightKBlockF4, utils::bf16>(2, 4096, 4096, 32, BTLA_DTYPE::F4_NF4);
   // }
 
-  template <typename Core_T, typename LOG_T, template <class _T, JBLAS_ISA> class Wei, typename Scale_T>
+  template <typename Core_T, typename LOG_T, template <class _T, BTLA_ISA> class Wei, typename Scale_T>
   void benchmark(int m, int n, int k, int blocksize, int batch, float* A, float* B, float* C, float timems, int threads,
-                 JBLAS_DTYPE qtype) {
+                 BTLA_DTYPE qtype) {
     LOG_T log;
-    using Parallel = jblas::parallel::gemm::SchedulerBase<Core_T>;
-    using Launcher = jblas::wrapper::gemm::LauncherBase<Core_T::ISA, Core_T, jblas::prologue_a::gemm::ActivationBase,
-                                                        Wei, jblas::epilogue::gemm::AccumulatorWriteBackFp32>;
+    using Parallel = parallel::gemm::SchedulerBase<Core_T>;
+    using Launcher = wrapper::gemm::LauncherBase<Core_T::ISA, Core_T, prologue_a::gemm::ActivationBase, Wei,
+                                                 epilogue::gemm::AccumulatorWriteBackFp32>;
     Launcher kernel;
     DefaultThreading.set_threads(threads);
-    auto corestr = jblas::gemm::CoreAttr::to_str(Core_T::ID);
+    auto corestr = gemm::CoreAttr::to_str(Core_T::ID);
     utils::timer<std::chrono::milliseconds> tm;
     using WType = typename Wei<Core_T, Core_T::ISA>::StorageWeight;
     WType tmpB(0);
     if constexpr (std::is_same_v<Wei<Core_T, Core_T::ISA>,
-                                 jblas::prologue_b::gemm::WeightKBlockNInteger<Core_T, Core_T::ISA>>) {
-      tmpB = kernel.mProB.createStorage(n, k, blocksize, qtype, jblas_dtype<Scale_T>, jblas_dtype<float>, false);
+                                 prologue_b::gemm::WeightKBlockNInteger<Core_T, Core_T::ISA>>) {
+      tmpB = kernel.mProB.createStorage(n, k, blocksize, qtype, bestla_dtype<Scale_T>, bestla_dtype<float>, false);
+
     } else if constexpr (std::is_same_v<Wei<Core_T, Core_T::ISA>,
-                                        jblas::prologue_b::gemm::WeightKBlockNFloat<Core_T, Core_T::ISA>>) {
-      tmpB = kernel.mProB.createStorage(n, k, blocksize, qtype, jblas_dtype<Scale_T>, JBLAS_DTYPE::EleBitsUndef, false);
+                                        prologue_b::gemm::WeightKBlockNFloat<Core_T, Core_T::ISA>>) {
+      tmpB = kernel.mProB.createStorage(n, k, blocksize, qtype, bestla_dtype<Scale_T>);
     }
     std::vector<WType> packBs(batch, 0);
     std::vector<int8_t> bufB(tmpB.mSize * batch);
@@ -786,7 +789,7 @@ class UTBenchmark_CompFp32 {
         log.start();
         GemmProblem gp(1, m, n, k);
         typename Launcher::Param args{gp, {A + i * m * k, k}, {&packBs[i]}, {C + i * m * n, n}};
-        GemmRun<Parallel>(kernel, args, &DefaultThreading);
+        parallel::GemmRun<Parallel>(kernel, args, &DefaultThreading);
         if (log.stop()) {
           double flops = double(psize) / log.avg_val / 1e6;
           double band = double(memsize) / log.avg_val / 1e6;
@@ -797,26 +800,27 @@ class UTBenchmark_CompFp32 {
     }
   }
 
-  template <typename Core_T, typename LOG_T, template <class _T, JBLAS_ISA> class Wei, typename Scale_T>
+  template <typename Core_T, typename LOG_T, template <class _T, BTLA_ISA> class Wei, typename Scale_T>
   void benchmark_mem(int m, int n, int k, int blocksize, int batch, float* A, float* B, float* C, float timems,
-                     int threads, JBLAS_DTYPE qtype) {
+                     int threads, BTLA_DTYPE qtype) {
     LOG_T log;
-    using Parallel = jblas::parallel::gemm::SchedulerKBlock<Core_T>;
-    using Launcher = jblas::wrapper::gemm::LauncherKBlock<Core_T::ISA, Core_T, jblas::prologue_a::gemm::ActivationBase,
-                                                          Wei, jblas::epilogue::gemm::CompFp32BlockEpilogue,
-                                                          jblas::epilogue::gemm::AccumulatorWriteBackFp32>;
+    using Parallel = parallel::gemm::SchedulerKBlock<Core_T>;
+    using Launcher =
+        wrapper::gemm::LauncherKBlock<Core_T::ISA, Core_T, prologue_a::gemm::ActivationBase, Wei,
+                                      epilogue::gemm::CompFp32BlockEpilogue, epilogue::gemm::AccumulatorWriteBackFp32>;
     Launcher kernel;
     DefaultThreading.set_threads(threads);
-    auto corestr = jblas::gemm::CoreAttr::to_str(Core_T::ID);
+    auto corestr = gemm::CoreAttr::to_str(Core_T::ID);
     utils::timer<std::chrono::milliseconds> tm;
     using WType = typename Wei<Core_T, Core_T::ISA>::StorageWeight;
     WType tmpB(0);
     if constexpr (std::is_same_v<Wei<Core_T, Core_T::ISA>,
-                                 jblas::prologue_b::gemm::WeightKBlockNInteger<Core_T, Core_T::ISA>>) {
-      tmpB = kernel.mProB.createStorage(n, k, blocksize, qtype, jblas_dtype<Scale_T>, jblas_dtype<float>, false);
+                                 prologue_b::gemm::WeightKBlockNInteger<Core_T, Core_T::ISA>>) {
+      tmpB = kernel.mProB.createStorage(n, k, blocksize, qtype, bestla_dtype<Scale_T>, bestla_dtype<float>, false);
+
     } else if constexpr (std::is_same_v<Wei<Core_T, Core_T::ISA>,
-                                        jblas::prologue_b::gemm::WeightKBlockNFloat<Core_T, Core_T::ISA>>) {
-      tmpB = kernel.mProB.createStorage(n, k, blocksize, qtype, jblas_dtype<Scale_T>, JBLAS_DTYPE::EleBitsUndef, false);
+                                        prologue_b::gemm::WeightKBlockNFloat<Core_T, Core_T::ISA>>) {
+      tmpB = kernel.mProB.createStorage(n, k, blocksize, qtype, bestla_dtype<Scale_T>);
     }
     std::vector<WType> packBs(batch, 0);
     std::vector<int8_t> bufB(tmpB.mSize * batch);
@@ -841,7 +845,7 @@ class UTBenchmark_CompFp32 {
                                       {&packBs[i]},
                                       {packBs[i].template SPtr<int8_t>(), packBs[i].SDtype(), packBs[i].CStep()},
                                       {C + i * m * n, n}};
-        GemmRun<Parallel>(kernel, args, &DefaultThreading);
+        parallel::GemmRun<Parallel>(kernel, args, &DefaultThreading);
       }
       if (log.stop()) {
         double t = log.avg_val / batch;
@@ -853,8 +857,8 @@ class UTBenchmark_CompFp32 {
     }
   }
 
-  template <template <class _T, JBLAS_ISA> class Wei, typename Scale_T>
-  void benchmark_all(size_t m, size_t n, size_t k, size_t batch, JBLAS_DTYPE qtype) {
+  template <template <class _T, BTLA_ISA> class Wei, typename Scale_T>
+  void benchmark_all(size_t m, size_t n, size_t k, size_t batch, BTLA_DTYPE qtype) {
     printf("%s %d %d %d %d\n", __FUNCTION__, int(m), int(n), int(k), int(batch));
     avector<float> A(m * k * batch);
     avector<float> B(k * n);
@@ -869,19 +873,19 @@ class UTBenchmark_CompFp32 {
     GetCPUDevice();
     if (_cd->AVX512F()) {
       int blocksize = 32;
-      benchmark<jblas::gemm::SCoreRowNAvx512f<48, 8>, LOG, Wei, Scale_T>(m, n, k, blocksize, batch, A.data(), B.data(),
-                                                                         C.data(), testtime, 48, qtype);
-      benchmark_mem<jblas::gemm::SCoreRowNAvx512f<48, 8>, LOG, Wei, Scale_T>(m, n, k, blocksize, batch, A.data(),
-                                                                             B.data(), C.data(), testtime, 48, qtype);
+      benchmark<gemm::SCoreRowNAvx512f<48, 8>, LOG, Wei, Scale_T>(m, n, k, blocksize, batch, A.data(), B.data(),
+                                                                  C.data(), testtime, 48, qtype);
+      benchmark_mem<gemm::SCoreRowNAvx512f<48, 8>, LOG, Wei, Scale_T>(m, n, k, blocksize, batch, A.data(), B.data(),
+                                                                      C.data(), testtime, 48, qtype);
       blocksize = 128;
-      benchmark<jblas::gemm::SCoreRowNAvx512f<48, 8>, LOG, Wei, Scale_T>(m, n, k, blocksize, batch, A.data(), B.data(),
-                                                                         C.data(), testtime, 48, qtype);
-      benchmark_mem<jblas::gemm::SCoreRowNAvx512f<48, 8>, LOG, Wei, Scale_T>(m, n, k, blocksize, batch, A.data(),
-                                                                             B.data(), C.data(), testtime, 48, qtype);
+      benchmark<gemm::SCoreRowNAvx512f<48, 8>, LOG, Wei, Scale_T>(m, n, k, blocksize, batch, A.data(), B.data(),
+                                                                  C.data(), testtime, 48, qtype);
+      benchmark_mem<gemm::SCoreRowNAvx512f<48, 8>, LOG, Wei, Scale_T>(m, n, k, blocksize, batch, A.data(), B.data(),
+                                                                      C.data(), testtime, 48, qtype);
     }
   }
 };
-#ifdef JBLAS_UT_PROLOGUE_B_
+#ifdef BTLA_UT_PROLOGUE_B_
 static UTBenchmark_CompFp32 sUTBenchmark_CompFp32;
 #endif
 
@@ -897,107 +901,106 @@ class UT_CompInt8 {
   void ut_s4() {
     GetCPUDevice();
     if (_cd->AVX_VNNI()) {
-      ut<sAVX_VNNI, float>(2, 4096, 4096, 32, JBLAS_DTYPE::S4_CLIP);
-      ut<sAVX_VNNI, float>(2, 4096, 4096, 128, JBLAS_DTYPE::S4_CLIP);
-      ut<sAVX_VNNI, float>(2, 4096, 4096, -1, JBLAS_DTYPE::S4_CLIP);
-      ut<sAVX_VNNI, float>(2, 4096, 4096, 32, JBLAS_DTYPE::S4_FULLRANGE);
-      ut<sAVX_VNNI, float>(2, 4096, 4096, 128, JBLAS_DTYPE::S4_FULLRANGE);
-      ut<sAVX_VNNI, float>(2, 4096, 4096, -1, JBLAS_DTYPE::S4_FULLRANGE);
-      ut<sAVX_VNNI, utils::bf16>(2, 4096, 4096, 32, JBLAS_DTYPE::S4_CLIP);
-      ut<sAVX_VNNI, utils::bf16>(2, 4096, 4096, 32, JBLAS_DTYPE::S4_FULLRANGE);
+      ut<sAVX_VNNI, float>(2, 4096, 4096, 32, BTLA_DTYPE::S4_CLIP);
+      ut<sAVX_VNNI, float>(2, 4096, 4096, 128, BTLA_DTYPE::S4_CLIP);
+      ut<sAVX_VNNI, float>(2, 4096, 4096, -1, BTLA_DTYPE::S4_CLIP);
+      ut<sAVX_VNNI, float>(2, 4096, 4096, 32, BTLA_DTYPE::S4_FULLRANGE);
+      ut<sAVX_VNNI, float>(2, 4096, 4096, 128, BTLA_DTYPE::S4_FULLRANGE);
+      ut<sAVX_VNNI, float>(2, 4096, 4096, -1, BTLA_DTYPE::S4_FULLRANGE);
+      ut<sAVX_VNNI, utils::bf16>(2, 4096, 4096, 32, BTLA_DTYPE::S4_CLIP);
+      ut<sAVX_VNNI, utils::bf16>(2, 4096, 4096, 32, BTLA_DTYPE::S4_FULLRANGE);
     }
 
     if (_cd->AVX512_VNNI()) {
-      ut_dynamic<sAVX512_VNNI, float>(1, 11008, 4096, 32, JBLAS_DTYPE::S4_CLIP);
-      ut_dynamic<sAVX512_VNNI, float>(2, 4096, 4096, 32, JBLAS_DTYPE::S4_CLIP);
-      ut_dynamic<sAVX512_VNNI, float>(1, 4096, 4096, 32, JBLAS_DTYPE::S4_CLIP, false, JBLAS_DTYPE::BF16);
-      ut_dynamic<sAVX512_VNNI, float>(2, 4096, 4096, 32, JBLAS_DTYPE::S4_CLIP, true);
-      ut<sAVX512_VNNI, float>(2, 4096, 4096, 32, JBLAS_DTYPE::S4_CLIP);
-      ut<sAVX512_VNNI, float>(2, 4096, 4096, 128, JBLAS_DTYPE::S4_CLIP);
-      ut<sAVX512_VNNI, float>(2, 4096, 4096, -1, JBLAS_DTYPE::S4_CLIP);
-      ut<sAVX512_VNNI, float>(2, 4096, 4096, 32, JBLAS_DTYPE::S4_FULLRANGE);
-      ut<sAVX512_VNNI, float>(2, 4096, 4096, 128, JBLAS_DTYPE::S4_FULLRANGE);
-      ut<sAVX512_VNNI, float>(2, 4096, 4096, -1, JBLAS_DTYPE::S4_FULLRANGE);
-      ut<sAVX512_VNNI, utils::bf16>(2, 4096, 4096, 32, JBLAS_DTYPE::S4_CLIP);
-      ut<sAVX512_VNNI, utils::bf16>(2, 4096, 4096, 32, JBLAS_DTYPE::S4_FULLRANGE);
-      ut<sAVX512_VNNI, float>(2, 4096, 4096, 32, JBLAS_DTYPE::S4_CLIP, true);
+      ut_dynamic<sAVX512_VNNI, float>(1, 11008, 4096, 32, BTLA_DTYPE::S4_CLIP);
+      ut_dynamic<sAVX512_VNNI, float>(2, 4096, 4096, 32, BTLA_DTYPE::S4_CLIP);
+      ut_dynamic<sAVX512_VNNI, float>(1, 4096, 4096, 32, BTLA_DTYPE::S4_CLIP, false, BTLA_DTYPE::BF16);
+      ut_dynamic<sAVX512_VNNI, float>(2, 4096, 4096, 32, BTLA_DTYPE::S4_CLIP, true);
+      ut<sAVX512_VNNI, float>(2, 4096, 4096, 32, BTLA_DTYPE::S4_CLIP);
+      ut<sAVX512_VNNI, float>(2, 4096, 4096, 128, BTLA_DTYPE::S4_CLIP);
+      ut<sAVX512_VNNI, float>(2, 4096, 4096, -1, BTLA_DTYPE::S4_CLIP);
+      ut<sAVX512_VNNI, float>(2, 4096, 4096, 32, BTLA_DTYPE::S4_FULLRANGE);
+      ut<sAVX512_VNNI, float>(2, 4096, 4096, 128, BTLA_DTYPE::S4_FULLRANGE);
+      ut<sAVX512_VNNI, float>(2, 4096, 4096, -1, BTLA_DTYPE::S4_FULLRANGE);
+      ut<sAVX512_VNNI, utils::bf16>(2, 4096, 4096, 32, BTLA_DTYPE::S4_CLIP);
+      ut<sAVX512_VNNI, utils::bf16>(2, 4096, 4096, 32, BTLA_DTYPE::S4_FULLRANGE);
+      ut<sAVX512_VNNI, float>(2, 4096, 4096, 32, BTLA_DTYPE::S4_CLIP, true);
     }
 
     if (_cd->AMX_INT8()) {
       request_perm_xtile_data();
-      ut<sAMX_INT8_US, float>(2, 4096, 4096, 128, JBLAS_DTYPE::S4_CLIP);
-      ut<sAMX_INT8_US, float>(2, 4096, 4096, -1, JBLAS_DTYPE::S4_CLIP);
-      ut<sAMX_INT8_US, float>(2, 4096, 4096, 128, JBLAS_DTYPE::S4_FULLRANGE);
-      ut<sAMX_INT8_US, float>(2, 4096, 4096, -1, JBLAS_DTYPE::S4_FULLRANGE);
-      ut<sAMX_INT8_US, float>(16, 4096, 4096, -1, JBLAS_DTYPE::S4_FULLRANGE);
-      ut<sAMX_INT8_US, utils::bf16>(2, 4096, 4096, 128, JBLAS_DTYPE::S4_CLIP);
-      ut<sAMX_INT8_US, utils::bf16>(2, 4096, 4096, 128, JBLAS_DTYPE::S4_FULLRANGE);
-      ut<sAMX_INT8_US, float>(2, 4096, 4096, 128, JBLAS_DTYPE::S4_CLIP, true);
-      ut_s8s8<sAMX_INT8_SS, float>(2, 4096, 4096, 128, JBLAS_DTYPE::S4_CLIP);
-      ut_s8s8<sAMX_INT8_SS, float>(2, 4096, 4096, -1, JBLAS_DTYPE::S4_CLIP);
-      ut_s8s8<sAMX_INT8_SS, float>(2, 4096, 4096, 128, JBLAS_DTYPE::S4_CLIP, true);
+      ut<sAMX_INT8_US, float>(2, 4096, 4096, 128, BTLA_DTYPE::S4_CLIP);
+      ut<sAMX_INT8_US, float>(2, 4096, 4096, -1, BTLA_DTYPE::S4_CLIP);
+      ut<sAMX_INT8_US, float>(2, 4096, 4096, 128, BTLA_DTYPE::S4_FULLRANGE);
+      ut<sAMX_INT8_US, float>(2, 4096, 4096, -1, BTLA_DTYPE::S4_FULLRANGE);
+      ut<sAMX_INT8_US, float>(16, 4096, 4096, -1, BTLA_DTYPE::S4_FULLRANGE);
+      ut<sAMX_INT8_US, utils::bf16>(2, 4096, 4096, 128, BTLA_DTYPE::S4_CLIP);
+      ut<sAMX_INT8_US, utils::bf16>(2, 4096, 4096, 128, BTLA_DTYPE::S4_FULLRANGE);
+      ut<sAMX_INT8_US, float>(2, 4096, 4096, 128, BTLA_DTYPE::S4_CLIP, true);
+      ut_s8s8<sAMX_INT8_SS, float>(2, 4096, 4096, 128, BTLA_DTYPE::S4_CLIP);
+      ut_s8s8<sAMX_INT8_SS, float>(2, 4096, 4096, -1, BTLA_DTYPE::S4_CLIP);
+      ut_s8s8<sAMX_INT8_SS, float>(2, 4096, 4096, 128, BTLA_DTYPE::S4_CLIP, true);
     }
   }
 
   void ut_s4_newkblock() {
     GetCPUDevice();
     if (_cd->AVX_VNNI()) {
-      ut_newkblock<jblas::gemm::ICoreRowNAvxvnniKBlock<48, 1>, float>(1, 11008, 4096, 32, JBLAS_DTYPE::S4_CLIP);
-      ut_newkblock<jblas::gemm::ICoreRowNAvxvnniKBlock<48, 1>, float>(2, 4096, 4096, 32, JBLAS_DTYPE::S4_CLIP);
+      ut_newkblock<gemm::ICoreRowNAvxvnniKBlock<48, 1>, float>(1, 11008, 4096, 32, BTLA_DTYPE::S4_CLIP);
+      ut_newkblock<gemm::ICoreRowNAvxvnniKBlock<48, 1>, float>(2, 4096, 4096, 32, BTLA_DTYPE::S4_CLIP);
     }
 
     if (_cd->AVX512_VNNI()) {
-      ut_newkblock<jblas::gemm::ICoreRowNAvx512vnniKBlock<48, 4>, float>(1, 11008, 4096, 32, JBLAS_DTYPE::S4_CLIP);
-      ut_newkblock<jblas::gemm::ICoreRowNAvx512vnniKBlock<48, 4>, float>(2, 4096, 4096, 32, JBLAS_DTYPE::S4_CLIP);
+      ut_newkblock<gemm::ICoreRowNAvx512vnniKBlock<48, 4>, float>(1, 11008, 4096, 32, BTLA_DTYPE::S4_CLIP);
+      ut_newkblock<gemm::ICoreRowNAvx512vnniKBlock<48, 4>, float>(2, 4096, 4096, 32, BTLA_DTYPE::S4_CLIP);
     }
 
     if (_cd->AMX_INT8()) {
       request_perm_xtile_data();
-      ut_newkblock<jblas::gemm::ICoreRowNAmxint8KBlock<48, 16>, float>(128, 4096, 4096, 128, JBLAS_DTYPE::S4_CLIP);
-      ut_newkblock<jblas::gemm::ICoreRowNAmxint8KBlock<48, 16>, float>(1, 4096, 4096, 64, JBLAS_DTYPE::S4_CLIP);
+      ut_newkblock<gemm::ICoreRowNAmxint8KBlock<48, 16>, float>(128, 4096, 4096, 128, BTLA_DTYPE::S4_CLIP);
+      ut_newkblock<gemm::ICoreRowNAmxint8KBlock<48, 16>, float>(1, 4096, 4096, 64, BTLA_DTYPE::S4_CLIP);
     }
   }
 
   void ut_s8() {
     GetCPUDevice();
     if (_cd->AVX_VNNI()) {
-      ut_dynamic<sAVX_VNNI, float>(2, 4096, 4096, 32, JBLAS_DTYPE::S8);
-      ut_dynamic<sAVX_VNNI, float>(2, 4096, 4096, 128, JBLAS_DTYPE::S8);
-      ut_dynamic<sAVX_VNNI, float>(2, 4096, 4096, -1, JBLAS_DTYPE::S8);
-      ut_dynamic<sAVX_VNNI, utils::bf16>(2, 4096, 4096, 32, JBLAS_DTYPE::S8);
+      ut_dynamic<sAVX_VNNI, float>(2, 4096, 4096, 32, BTLA_DTYPE::S8);
+      ut_dynamic<sAVX_VNNI, float>(2, 4096, 4096, 128, BTLA_DTYPE::S8);
+      ut_dynamic<sAVX_VNNI, float>(2, 4096, 4096, -1, BTLA_DTYPE::S8);
+      ut_dynamic<sAVX_VNNI, utils::bf16>(2, 4096, 4096, 32, BTLA_DTYPE::S8);
     }
 
     if (_cd->AVX512_VNNI()) {
-      ut_dynamic<sAVX512_VNNI, float>(2, 4096, 4096, 32, JBLAS_DTYPE::S8);
-      ut_dynamic<sAVX512_VNNI, float>(2, 4096, 4096, 128, JBLAS_DTYPE::S8);
-      ut_dynamic<sAVX512_VNNI, float>(2, 4096, 4096, -1, JBLAS_DTYPE::S8);
-      ut_dynamic<sAVX512_VNNI, utils::bf16>(2, 4096, 4096, 32, JBLAS_DTYPE::S8);
+      ut_dynamic<sAVX512_VNNI, float>(2, 4096, 4096, 32, BTLA_DTYPE::S8);
+      ut_dynamic<sAVX512_VNNI, float>(2, 4096, 4096, 128, BTLA_DTYPE::S8);
+      ut_dynamic<sAVX512_VNNI, float>(2, 4096, 4096, -1, BTLA_DTYPE::S8);
+      ut_dynamic<sAVX512_VNNI, utils::bf16>(2, 4096, 4096, 32, BTLA_DTYPE::S8);
     }
 
     if (_cd->AMX_INT8()) {
       request_perm_xtile_data();
-      ut_dynamic<sAMX_INT8_US, float>(2, 4096, 4096, 128, JBLAS_DTYPE::S8);
-      ut_dynamic<sAMX_INT8_US, float>(2, 4096, 4096, -1, JBLAS_DTYPE::S8);
-      ut_dynamic<sAMX_INT8_US, utils::bf16>(2, 4096, 4096, 128, JBLAS_DTYPE::S8);
+      ut_dynamic<sAMX_INT8_US, float>(2, 4096, 4096, 128, BTLA_DTYPE::S8);
+      ut_dynamic<sAMX_INT8_US, float>(2, 4096, 4096, -1, BTLA_DTYPE::S8);
+      ut_dynamic<sAMX_INT8_US, utils::bf16>(2, 4096, 4096, 128, BTLA_DTYPE::S8);
     }
   }
 
   template <class GemmCore_T, typename Scale_T>
-  void ut_newkblock(int m, int n, int k, int blocksize, JBLAS_DTYPE qtype, bool isAsym = false) {
+  void ut_newkblock(int m, int n, int k, int blocksize, BTLA_DTYPE qtype, bool isAsym = false) {
     printf("Test Case %s: %d %d %d-%d type:%s core:%s scaletype:%s Asym:%d\n", __FUNCTION__, m, n, k, blocksize,
-           jblas_dtype_str(qtype), jblas::gemm::CoreAttr::to_str(GemmCore_T::ID), type_str<Scale_T>, isAsym);
+           bestla_dtype_str(qtype), gemm::CoreAttr::to_str(GemmCore_T::ID), type_str<Scale_T>, isAsym);
     auto constexpr ISA = GemmCore_T::ISA;
-    using Launcher =
-        jblas::wrapper::gemm::LauncherIntKBlock<ISA, GemmCore_T, prologue_a::gemm::ActivationF32KBlockQuantize,
-                                                jblas::prologue_b::gemm::WeightKBlockNInteger,
-                                                jblas::epilogue::gemm::AccumulatorWriteBackFp32>;
-    using Parallel = jblas::parallel::gemm::SchedulerKBlockS<GemmCore_T>;
+    using Launcher = wrapper::gemm::LauncherIntKBlock<ISA, GemmCore_T, prologue_a::gemm::ActivationF32KBlockQuantize,
+                                                      prologue_b::gemm::WeightKBlockNInteger,
+                                                      epilogue::gemm::AccumulatorWriteBackFp32>;
+    using Parallel = parallel::gemm::SchedulerKBlockS<GemmCore_T>;
     Launcher launcher;
     blocksize = blocksize == -1 ? k : blocksize;
     int kblks = updiv(k, blocksize);
     using WType = typename Launcher::PrologueB::StorageWeight;
     WType packedw =
-        launcher.mProB.createStorage(n, k, blocksize, qtype, jblas_dtype<Scale_T>, jblas_dtype<float>, isAsym);
+        launcher.mProB.createStorage(n, k, blocksize, qtype, bestla_dtype<Scale_T>, bestla_dtype<float>, isAsym);
 
     utils::avector<int8_t> buffer(packedw.mSize);
     packedw.assign(buffer.data());
@@ -1026,11 +1029,11 @@ class UT_CompInt8 {
     quanA.assign(bufferA.data());
     GemmProblem gp(1, m, n, k, blocksize);
     typename Launcher::Param args{gp, {matAf32.data(), k, &quanA}, {&packedw}, {matC.data(), n}};
-    GemmRunWithA<Parallel>(launcher, args, &DefaultThreading);
+    parallel::GemmRunWithA<Parallel>(launcher, args, &DefaultThreading);
     auto err = INT8_ERR;
-    auto dbits = jblas_dtype_bits(qtype);
-    auto type = jblas_dtype_type(qtype);
-    auto dtype_int = jblas_dtype_type(JBLAS_DTYPE::TypeInt);
+    auto dbits = bestla_dtype_bits(qtype);
+    auto type = bestla_dtype_type(qtype);
+    auto dtype_int = bestla_dtype_type(BTLA_DTYPE::TypeInt);
     if (type == dtype_int) {
       if (dbits == 8) {
         err = INT8_ERR;
@@ -1043,20 +1046,21 @@ class UT_CompInt8 {
   }
 
   template <class GemmCore_T, typename Scale_T>
-  void ut(int m, int n, int k, int blocksize, JBLAS_DTYPE qtype, bool isAsym = false) {
+  void ut(int m, int n, int k, int blocksize, BTLA_DTYPE qtype, bool isAsym = false) {
     printf("Test Case %s: %d %d %d-%d type:%s core:%s scaletype:%s Asym:%d\n", __FUNCTION__, m, n, k, blocksize,
-           jblas_dtype_str(qtype), jblas::gemm::CoreAttr::to_str(GemmCore_T::ID), type_str<Scale_T>, isAsym);
+           bestla_dtype_str(qtype), gemm::CoreAttr::to_str(GemmCore_T::ID), type_str<Scale_T>, isAsym);
     auto constexpr ISA = GemmCore_T::ISA;
-    using Launcher = jblas::wrapper::gemm::LauncherKBlock<
-        ISA, GemmCore_T, prologue_a::gemm::ActivationBase, prologue_b::gemm::WeightKBlockNInteger,
-        jblas::epilogue::gemm::CompInt8BlockEpilogue, jblas::epilogue::gemm::AccumulatorWriteBackFp32>;
-    using Parallel = jblas::parallel::gemm::SchedulerKBlock<GemmCore_T>;
+    using Launcher =
+        wrapper::gemm::LauncherKBlock<ISA, GemmCore_T, prologue_a::gemm::ActivationBase,
+                                      prologue_b::gemm::WeightKBlockNInteger, epilogue::gemm::CompInt8BlockEpilogue,
+                                      epilogue::gemm::AccumulatorWriteBackFp32>;
+    using Parallel = parallel::gemm::SchedulerKBlock<GemmCore_T>;
     Launcher launcher;
     blocksize = blocksize == -1 ? k : blocksize;
     int kblks = updiv(k, blocksize);
     using WType = typename Launcher::PrologueB::StorageWeight;
     WType packedw =
-        launcher.mProB.createStorage(n, k, blocksize, qtype, jblas_dtype<Scale_T>, jblas_dtype<float>, isAsym);
+        launcher.mProB.createStorage(n, k, blocksize, qtype, bestla_dtype<Scale_T>, bestla_dtype<float>, isAsym);
 
     utils::avector<int8_t> buffer(packedw.mSize);
     packedw.assign(buffer.data());
@@ -1089,11 +1093,11 @@ class UT_CompInt8 {
          packedw.template RPtr<void>(), packedw.RDtype(), isAsym ? packedw.template ZPtr<int8_t>() : nullptr,
          isAsym ? reduceAf32.data() : nullptr, blocksize},
         {matC.data(), n}};
-    GemmRun<Parallel>(launcher, args, &DefaultThreading);
+    parallel::GemmRun<Parallel>(launcher, args, &DefaultThreading);
     auto err = INT8_ERR;
-    auto dbits = jblas_dtype_bits(qtype);
-    auto type = jblas_dtype_type(qtype);
-    auto dtype_int = jblas_dtype_type(JBLAS_DTYPE::TypeInt);
+    auto dbits = bestla_dtype_bits(qtype);
+    auto type = bestla_dtype_type(qtype);
+    auto dtype_int = bestla_dtype_type(BTLA_DTYPE::TypeInt);
     if (type == dtype_int) {
       if (dbits == 8) {
         err = INT8_ERR;
@@ -1106,21 +1110,22 @@ class UT_CompInt8 {
   }
 
   template <class GemmCore_T, typename Scale_T>
-  void ut_dynamic(int m, int n, int k, int blocksize, JBLAS_DTYPE qtype, bool isAsym = false,
-                  JBLAS_DTYPE redtype = JBLAS_DTYPE::F32) {
+  void ut_dynamic(int m, int n, int k, int blocksize, BTLA_DTYPE qtype, bool isAsym = false,
+                  BTLA_DTYPE redtype = BTLA_DTYPE::F32) {
     printf("Test Case %s: %d %d %d-%d type:%s core:%s scaletype:%s Asym:%d reduce dtype:%s\n", __FUNCTION__, m, n, k,
-           blocksize, jblas_dtype_str(qtype), jblas::gemm::CoreAttr::to_str(GemmCore_T::ID), type_str<Scale_T>, isAsym,
-           jblas_dtype_str(redtype));
+           blocksize, bestla_dtype_str(qtype), gemm::CoreAttr::to_str(GemmCore_T::ID), type_str<Scale_T>, isAsym,
+           bestla_dtype_str(redtype));
     auto constexpr ISA = GemmCore_T::ISA;
-    using Launcher = jblas::wrapper::gemm::LauncherKBlock<
-        ISA, GemmCore_T, prologue_a::gemm::ActivationF32KBlockQuantize, prologue_b::gemm::WeightKBlockNInteger,
-        jblas::epilogue::gemm::CompInt8BlockEpilogue, jblas::epilogue::gemm::AccumulatorWriteBackFp32>;
-    using Parallel = jblas::parallel::gemm::SchedulerKBlock<GemmCore_T>;
+    using Launcher =
+        wrapper::gemm::LauncherKBlock<ISA, GemmCore_T, prologue_a::gemm::ActivationF32KBlockQuantize,
+                                      prologue_b::gemm::WeightKBlockNInteger, epilogue::gemm::CompInt8BlockEpilogue,
+                                      epilogue::gemm::AccumulatorWriteBackFp32>;
+    using Parallel = parallel::gemm::SchedulerKBlock<GemmCore_T>;
     Launcher launcher;
     blocksize = blocksize == -1 ? k : blocksize;
     int kblks = updiv(k, blocksize);
     using WType = typename Launcher::PrologueB::StorageWeight;
-    WType packedw = launcher.mProB.createStorage(n, k, blocksize, qtype, jblas_dtype<Scale_T>, redtype, isAsym);
+    WType packedw = launcher.mProB.createStorage(n, k, blocksize, qtype, bestla_dtype<Scale_T>, redtype, isAsym);
 
     utils::avector<int8_t> buffer(packedw.mSize);
     packedw.assign(buffer.data());
@@ -1156,11 +1161,11 @@ class UT_CompInt8 {
          quanA.CStep(), quanA.template ZPtr<uint8_t>(), packedw.template RPtr<void>(), packedw.RDtype(),
          packedw.template ZPtr<int8_t>(), quanA.template RPtr<float>(), blocksize},
         {matC.data(), n}};
-    GemmRunWithA<Parallel>(launcher, args, &DefaultThreading);
+    parallel::GemmRunWithA<Parallel>(launcher, args, &DefaultThreading);
     auto err = INT8_ERR;
-    auto dbits = jblas_dtype_bits(qtype);
-    auto type = jblas_dtype_type(qtype);
-    auto dtype_int = jblas_dtype_type(JBLAS_DTYPE::TypeInt);
+    auto dbits = bestla_dtype_bits(qtype);
+    auto type = bestla_dtype_type(qtype);
+    auto dtype_int = bestla_dtype_type(BTLA_DTYPE::TypeInt);
     if (type == dtype_int) {
       if (dbits == 8) {
         err = INT8_ERR;
@@ -1174,20 +1179,21 @@ class UT_CompInt8 {
   }
 
   template <class GemmCore_T, typename Scale_T>
-  void ut_s8s8(int m, int n, int k, int blocksize, JBLAS_DTYPE qtype, bool isAsym = false) {
+  void ut_s8s8(int m, int n, int k, int blocksize, BTLA_DTYPE qtype, bool isAsym = false) {
     printf("Test Case %s: %d %d %d-%d type:%s core:%s scaletype:%s Asym:%d\n", __FUNCTION__, m, n, k, blocksize,
-           jblas_dtype_str(qtype), jblas::gemm::CoreAttr::to_str(GemmCore_T::ID), type_str<Scale_T>, isAsym);
+           bestla_dtype_str(qtype), gemm::CoreAttr::to_str(GemmCore_T::ID), type_str<Scale_T>, isAsym);
     auto constexpr ISA = GemmCore_T::ISA;
-    using Launcher = jblas::wrapper::gemm::LauncherKBlock<
-        ISA, GemmCore_T, prologue_a::gemm::ActivationBase, prologue_b::gemm::WeightKBlockNInteger,
-        jblas::epilogue::gemm::CompInt8BlockEpilogue, jblas::epilogue::gemm::AccumulatorWriteBackFp32>;
-    using Parallel = jblas::parallel::gemm::SchedulerKBlock<GemmCore_T>;
+    using Launcher =
+        wrapper::gemm::LauncherKBlock<ISA, GemmCore_T, prologue_a::gemm::ActivationBase,
+                                      prologue_b::gemm::WeightKBlockNInteger, epilogue::gemm::CompInt8BlockEpilogue,
+                                      epilogue::gemm::AccumulatorWriteBackFp32>;
+    using Parallel = parallel::gemm::SchedulerKBlock<GemmCore_T>;
     Launcher launcher;
     blocksize = blocksize == -1 ? k : blocksize;
     int kblks = updiv(k, blocksize);
     using WType = typename Launcher::PrologueB::StorageWeight;
     WType packedw =
-        launcher.mProB.createStorage(n, k, blocksize, qtype, jblas_dtype<Scale_T>, jblas_dtype<float>, isAsym);
+        launcher.mProB.createStorage(n, k, blocksize, qtype, bestla_dtype<Scale_T>, bestla_dtype<float>, isAsym);
     utils::avector<int8_t> buffer(packedw.mSize);
     packedw.assign(buffer.data());
     avector<float> matBf32(k * n), matAf32(m * k), matC(m * n), refC(m * n), refCupk(m * n);
@@ -1214,13 +1220,13 @@ class UT_CompInt8 {
         {matAu8.data(), k},
         {&packedw},
         {packedw.template SPtr<int8_t>(), packedw.SDtype(), packedw.CStep(), scaleAf32.data(), kblks, nullptr, nullptr,
-         jblas_dtype<float>, packedw.template ZPtr<int8_t>(), reduceAf32.data(), blocksize},
+         bestla_dtype<float>, packedw.template ZPtr<int8_t>(), reduceAf32.data(), blocksize},
         {matC.data(), n}};
-    GemmRun<Parallel>(launcher, args, &DefaultThreading);
+    parallel::GemmRun<Parallel>(launcher, args, &DefaultThreading);
     auto err = INT8_ERR;
-    auto dbits = jblas_dtype_bits(qtype);
-    auto type = jblas_dtype_type(qtype);
-    auto dtype_int = jblas_dtype_type(JBLAS_DTYPE::TypeInt);
+    auto dbits = bestla_dtype_bits(qtype);
+    auto type = bestla_dtype_type(qtype);
+    auto dtype_int = bestla_dtype_type(BTLA_DTYPE::TypeInt);
     if (type == dtype_int) {
       if (dbits == 8) {
         err = INT8_ERR;
@@ -1233,7 +1239,7 @@ class UT_CompInt8 {
     buffer_error(refCupk.data(), matC.data(), refCupk.size(), 0.001f);
   }
 };
-#ifdef JBLAS_UT_PROLOGUE_B
+#ifdef BTLA_UT_PROLOGUE_B
 static UT_CompInt8 sUT_CompInt8;
 #endif
 
@@ -1250,63 +1256,61 @@ class UT_CompBf16 {
   }
 
   void ut_f8() {
-    ut<sAMX_BF16, jblas::prologue_b::gemm::WeightKBlockNFloat, f8>(2, 4096, 4096, 32, JBLAS_DTYPE::F8_E4M3);
-    ut<sAMX_BF16, jblas::prologue_b::gemm::WeightKBlockNFloat, float>(2, 4096, 4096, 32, JBLAS_DTYPE::F8_E4M3);
-    ut<sAMX_BF16, jblas::prologue_b::gemm::WeightKBlockNFloat, f8>(2, 4096, 4096, 32, JBLAS_DTYPE::F8_E5M2);
-    ut<sAMX_BF16, jblas::prologue_b::gemm::WeightKBlockNFloat, float>(2, 4096, 4096, 32, JBLAS_DTYPE::F8_E5M2);
+    ut<sAMX_BF16, prologue_b::gemm::WeightKBlockNFloat, f8>(2, 4096, 4096, 32, BTLA_DTYPE::F8_E4M3);
+    ut<sAMX_BF16, prologue_b::gemm::WeightKBlockNFloat, float>(2, 4096, 4096, 32, BTLA_DTYPE::F8_E4M3);
+    ut<sAMX_BF16, prologue_b::gemm::WeightKBlockNFloat, f8>(2, 4096, 4096, 32, BTLA_DTYPE::F8_E5M2);
+    ut<sAMX_BF16, prologue_b::gemm::WeightKBlockNFloat, float>(2, 4096, 4096, 32, BTLA_DTYPE::F8_E5M2);
   }
 
   void ut_s4() {
-    ut<sAMX_BF16, jblas::prologue_b::gemm::WeightKBlockNInteger, float>(2, 4096, 4096, 32, JBLAS_DTYPE::S4_CLIP);
-    ut<sAMX_BF16, jblas::prologue_b::gemm::WeightKBlockNInteger, float>(2, 4096, 4096, 128, JBLAS_DTYPE::S4_CLIP);
-    ut<sAMX_BF16, jblas::prologue_b::gemm::WeightKBlockNInteger, float>(2, 4096, 4096, -1, JBLAS_DTYPE::S4_CLIP);
-    ut<sAMX_BF16, jblas::prologue_b::gemm::WeightKBlockNInteger, float>(2, 4096, 4096, 32, JBLAS_DTYPE::S4_FULLRANGE);
-    ut<sAMX_BF16, jblas::prologue_b::gemm::WeightKBlockNInteger, float>(2, 4096, 4096, 128, JBLAS_DTYPE::S4_FULLRANGE);
-    ut<sAMX_BF16, jblas::prologue_b::gemm::WeightKBlockNInteger, float>(2, 4096, 4096, -1, JBLAS_DTYPE::S4_FULLRANGE);
-    ut<sAMX_BF16, jblas::prologue_b::gemm::WeightKBlockNInteger, utils::bf16>(2, 4096, 4096, 32, JBLAS_DTYPE::S4_CLIP);
-    ut<sAMX_BF16, jblas::prologue_b::gemm::WeightKBlockNInteger, utils::bf16>(2, 4096, 4096, 32,
-                                                                              JBLAS_DTYPE::S4_FULLRANGE);
+    ut<sAMX_BF16, prologue_b::gemm::WeightKBlockNInteger, float>(2, 4096, 4096, 32, BTLA_DTYPE::S4_CLIP);
+    ut<sAMX_BF16, prologue_b::gemm::WeightKBlockNInteger, float>(2, 4096, 4096, 128, BTLA_DTYPE::S4_CLIP);
+    ut<sAMX_BF16, prologue_b::gemm::WeightKBlockNInteger, float>(2, 4096, 4096, -1, BTLA_DTYPE::S4_CLIP);
+    ut<sAMX_BF16, prologue_b::gemm::WeightKBlockNInteger, float>(2, 4096, 4096, 32, BTLA_DTYPE::S4_FULLRANGE);
+    ut<sAMX_BF16, prologue_b::gemm::WeightKBlockNInteger, float>(2, 4096, 4096, 128, BTLA_DTYPE::S4_FULLRANGE);
+    ut<sAMX_BF16, prologue_b::gemm::WeightKBlockNInteger, float>(2, 4096, 4096, -1, BTLA_DTYPE::S4_FULLRANGE);
+    ut<sAMX_BF16, prologue_b::gemm::WeightKBlockNInteger, utils::bf16>(2, 4096, 4096, 32, BTLA_DTYPE::S4_CLIP);
+    ut<sAMX_BF16, prologue_b::gemm::WeightKBlockNInteger, utils::bf16>(2, 4096, 4096, 32, BTLA_DTYPE::S4_FULLRANGE);
   }
 
   void ut_s8() {
-    ut<sAMX_BF16, jblas::prologue_b::gemm::WeightKBlockNInteger, float>(2, 4096, 4096, 32, JBLAS_DTYPE::S8);
-    ut<sAMX_BF16, jblas::prologue_b::gemm::WeightKBlockNInteger, float>(2, 4096, 4096, 128, JBLAS_DTYPE::S8);
-    ut<sAMX_BF16, jblas::prologue_b::gemm::WeightKBlockNInteger, float>(2, 4096, 4096, -1, JBLAS_DTYPE::S8);
-    ut<sAMX_BF16, jblas::prologue_b::gemm::WeightKBlockNInteger, utils::bf16>(2, 4096, 4096, 32, JBLAS_DTYPE::S8);
+    ut<sAMX_BF16, prologue_b::gemm::WeightKBlockNInteger, float>(2, 4096, 4096, 32, BTLA_DTYPE::S8);
+    ut<sAMX_BF16, prologue_b::gemm::WeightKBlockNInteger, float>(2, 4096, 4096, 128, BTLA_DTYPE::S8);
+    ut<sAMX_BF16, prologue_b::gemm::WeightKBlockNInteger, float>(2, 4096, 4096, -1, BTLA_DTYPE::S8);
+    ut<sAMX_BF16, prologue_b::gemm::WeightKBlockNInteger, utils::bf16>(2, 4096, 4096, 32, BTLA_DTYPE::S8);
   }
 
   void ut_f4() {
-    ut<sAMX_BF16, jblas::prologue_b::gemm::WeightKBlockNFloat, float>(2, 4096, 4096, 32, JBLAS_DTYPE::F4_E2M1);
-    ut<sAMX_BF16, jblas::prologue_b::gemm::WeightKBlockNFloat, float>(2, 4096, 4096, 32, JBLAS_DTYPE::F4_BNB);
-    ut<sAMX_BF16, jblas::prologue_b::gemm::WeightKBlockNFloat, float>(2, 4096, 4096, -1, JBLAS_DTYPE::F4_BNB);
-    ut<sAMX_BF16, jblas::prologue_b::gemm::WeightKBlockNFloat, float>(2, 4096, 4096, 32, JBLAS_DTYPE::F4_E2M1);
-    ut<sAMX_BF16, jblas::prologue_b::gemm::WeightKBlockNFloat, float>(2, 4096, 4096, -1, JBLAS_DTYPE::F4_E2M1);
-    ut<sAMX_BF16, jblas::prologue_b::gemm::WeightKBlockNFloat, float>(2, 4096, 4096, 32, JBLAS_DTYPE::F4_NF4);
-    ut<sAMX_BF16, jblas::prologue_b::gemm::WeightKBlockNFloat, float>(2, 4096, 4096, -1, JBLAS_DTYPE::F4_NF4);
-    ut<sAMX_BF16, jblas::prologue_b::gemm::WeightKBlockNFloat, utils::bf16>(2, 4096, 4096, 32, JBLAS_DTYPE::F4_BNB);
-    ut<sAMX_BF16, jblas::prologue_b::gemm::WeightKBlockNFloat, utils::bf16>(2, 4096, 4096, 32, JBLAS_DTYPE::F4_E2M1);
-    ut<sAMX_BF16, jblas::prologue_b::gemm::WeightKBlockNFloat, utils::bf16>(2, 4096, 4096, 32, JBLAS_DTYPE::F4_NF4);
+    ut<sAMX_BF16, prologue_b::gemm::WeightKBlockNFloat, float>(2, 4096, 4096, 32, BTLA_DTYPE::F4_E2M1);
+    ut<sAMX_BF16, prologue_b::gemm::WeightKBlockNFloat, float>(2, 4096, 4096, 32, BTLA_DTYPE::F4_BNB);
+    ut<sAMX_BF16, prologue_b::gemm::WeightKBlockNFloat, float>(2, 4096, 4096, -1, BTLA_DTYPE::F4_BNB);
+    ut<sAMX_BF16, prologue_b::gemm::WeightKBlockNFloat, float>(2, 4096, 4096, 32, BTLA_DTYPE::F4_E2M1);
+    ut<sAMX_BF16, prologue_b::gemm::WeightKBlockNFloat, float>(2, 4096, 4096, -1, BTLA_DTYPE::F4_E2M1);
+    ut<sAMX_BF16, prologue_b::gemm::WeightKBlockNFloat, float>(2, 4096, 4096, 32, BTLA_DTYPE::F4_NF4);
+    ut<sAMX_BF16, prologue_b::gemm::WeightKBlockNFloat, float>(2, 4096, 4096, -1, BTLA_DTYPE::F4_NF4);
+    ut<sAMX_BF16, prologue_b::gemm::WeightKBlockNFloat, utils::bf16>(2, 4096, 4096, 32, BTLA_DTYPE::F4_BNB);
+    ut<sAMX_BF16, prologue_b::gemm::WeightKBlockNFloat, utils::bf16>(2, 4096, 4096, 32, BTLA_DTYPE::F4_E2M1);
+    ut<sAMX_BF16, prologue_b::gemm::WeightKBlockNFloat, utils::bf16>(2, 4096, 4096, 32, BTLA_DTYPE::F4_NF4);
   }
 
-  template <class GemmCore_T, template <class _T, JBLAS_ISA> class Wei, typename Scale_T>
-  void ut(int m, int n, int k, int blocksize, JBLAS_DTYPE qtype, bool isAsym = false) {
+  template <class GemmCore_T, template <class _T, BTLA_ISA> class Wei, typename Scale_T>
+  void ut(int m, int n, int k, int blocksize, BTLA_DTYPE qtype) {
     printf("Test Case %s: %d %d %d-%d type:%s core:%s scaletype:%s\n", __FUNCTION__, m, n, k, blocksize,
-           jblas_dtype_str(qtype), jblas::gemm::CoreAttr::to_str(GemmCore_T::ID), type_str<Scale_T>);
+           bestla_dtype_str(qtype), gemm::CoreAttr::to_str(GemmCore_T::ID), type_str<Scale_T>);
     auto constexpr ISA = GemmCore_T::ISA;
-    using Launcher = jblas::wrapper::gemm::LauncherKBlock<ISA, GemmCore_T, prologue_a::gemm::ActivationBase, Wei,
-                                                          jblas::epilogue::gemm::CompFp32BlockEpilogue,
-                                                          jblas::epilogue::gemm::AccumulatorWriteBackFp32>;
-    using Parallel = jblas::parallel::gemm::SchedulerKBlock<GemmCore_T>;
+    using Launcher =
+        wrapper::gemm::LauncherKBlock<ISA, GemmCore_T, prologue_a::gemm::ActivationBase, Wei,
+                                      epilogue::gemm::CompFp32BlockEpilogue, epilogue::gemm::AccumulatorWriteBackFp32>;
+    using Parallel = parallel::gemm::SchedulerKBlock<GemmCore_T>;
 
     Launcher launcher;
     blocksize = blocksize == -1 ? k : blocksize;
     using WType = typename Wei<GemmCore_T, ISA>::StorageWeight;
     WType packedw(0);
-    if constexpr (std::is_same_v<Wei<GemmCore_T, ISA>,
-                                 jblas::prologue_b::gemm::WeightKBlockNInteger<GemmCore_T, ISA>>) {
-      packedw = launcher.mProB.createStorage(n, k, blocksize, qtype, jblas_dtype<Scale_T>, jblas_dtype<float>, isAsym);
-    } else {
-      packedw = launcher.mProB.createStorage(n, k, blocksize, qtype, jblas_dtype<Scale_T>);
+    if constexpr (std::is_same_v<Wei<GemmCore_T, ISA>, prologue_b::gemm::WeightKBlockNInteger<GemmCore_T, ISA>>) {
+      packedw = launcher.mProB.createStorage(n, k, blocksize, qtype, bestla_dtype<Scale_T>, bestla_dtype<float>, false);
+    } else if constexpr (std::is_same_v<Wei<GemmCore_T, ISA>, prologue_b::gemm::WeightKBlockNFloat<GemmCore_T, ISA>>) {
+      packedw = launcher.mProB.createStorage(n, k, blocksize, qtype, bestla_dtype<Scale_T>);
     }
 
     utils::avector<int8_t> buffer(packedw.mSize);
@@ -1331,17 +1335,13 @@ class UT_CompBf16 {
                                   {&packedw},
                                   {packedw.template SPtr<int8_t>(), packedw.SDtype(), packedw.CStep()},
                                   {matC.data(), n}};
-    GemmRun<Parallel>(launcher, args, &DefaultThreading);
-    auto err = INT8_ERR;
-    if (qtype == JBLAS_DTYPE::S4_CLIP || qtype == JBLAS_DTYPE::S4_FULLRANGE) err = INT4_ERR;
-    if (qtype == JBLAS_DTYPE::F4_E2M1 || qtype == JBLAS_DTYPE::F4_BNB || qtype == JBLAS_DTYPE::F4_NF4) err = FP4_ERR;
-    if (qtype == JBLAS_DTYPE::F8_E5M2 || qtype == JBLAS_DTYPE::F8_E4M3) err = F8_ERR;
-
+    parallel::GemmRun<Parallel>(launcher, args, &DefaultThreading);
+    auto err = get_ut_err(qtype);
     buffer_error(refC.data(), matC.data(), refC.size(), err);
     buffer_error(refCupk.data(), matC.data(), refCupk.size(), 0.05f);
   }
 };
-#ifdef JBLAS_UT_PROLOGUE_B
+#ifdef BTLA_UT_PROLOGUE_B
 static UT_CompBf16 sUT_CompBf16;
 #endif
 
@@ -1357,57 +1357,56 @@ class UTBenchmark_CompBf16 {
   }
 
   void ut_s4() {
-    benchmark_all<jblas::prologue_b::gemm::WeightKBlockNInteger, float>(1, 4096, 4096, 128, JBLAS_DTYPE::S4_CLIP);
-    benchmark_all<jblas::prologue_b::gemm::WeightKBlockNInteger, utils::bf16>(1, 4096, 4096, 128, JBLAS_DTYPE::S4_CLIP);
-    benchmark_all<jblas::prologue_b::gemm::WeightKBlockNInteger, float>(2048, 4096, 4096, 128, JBLAS_DTYPE::S4_CLIP);
-    benchmark_all<jblas::prologue_b::gemm::WeightKBlockNInteger, float>(4096, 4096, 11008, 128, JBLAS_DTYPE::S4_CLIP);
-    // benchmark_all<jblas::prologue_b::gemm::WeightKBlockS4, float>(2, 4096, 4096, 32, JBLAS_DTYPE::S4_FULLRANGE);
-    // benchmark_all<jblas::prologue_b::gemm::WeightKBlockS4, float>(2, 4096, 4096, 128, JBLAS_DTYPE::S4_FULLRANGE);
-    // benchmark_all<jblas::prologue_b::gemm::WeightKBlockS4, float>(2, 4096, 4096, -1, JBLAS_DTYPE::S4_FULLRANGE);
-    // benchmark_all<jblas::prologue_b::gemm::WeightKBlockS4, utils::bf16>(2, 4096, 4096, 32, JBLAS_DTYPE::S4_CLIP);
-    // benchmark_all<jblas::prologue_b::gemm::WeightKBlockS4, utils::bf16>(2, 4096, 4096, 32,
-    // JBLAS_DTYPE::S4_FULLRANGE);
+    benchmark_all<prologue_b::gemm::WeightKBlockNInteger, float>(1, 4096, 4096, 128, BTLA_DTYPE::S4_CLIP);
+    benchmark_all<prologue_b::gemm::WeightKBlockNInteger, utils::bf16>(1, 4096, 4096, 128, BTLA_DTYPE::S4_CLIP);
+    benchmark_all<prologue_b::gemm::WeightKBlockNInteger, float>(2048, 4096, 4096, 128, BTLA_DTYPE::S4_CLIP);
+    benchmark_all<prologue_b::gemm::WeightKBlockNInteger, float>(4096, 4096, 11008, 128, BTLA_DTYPE::S4_CLIP);
+    // benchmark_all<prologue_b::gemm::WeightKBlockS4, float>(2, 4096, 4096, 32, BTLA_DTYPE::S4_FULLRANGE);
+    // benchmark_all<prologue_b::gemm::WeightKBlockS4, float>(2, 4096, 4096, 128, BTLA_DTYPE::S4_FULLRANGE);
+    // benchmark_all<prologue_b::gemm::WeightKBlockS4, float>(2, 4096, 4096, -1, BTLA_DTYPE::S4_FULLRANGE);
+    // benchmark_all<prologue_b::gemm::WeightKBlockS4, utils::bf16>(2, 4096, 4096, 32, BTLA_DTYPE::S4_CLIP);
+    // benchmark_all<prologue_b::gemm::WeightKBlockS4, utils::bf16>(2, 4096, 4096, 32,
+    // BTLA_DTYPE::S4_FULLRANGE);
   }
 
   // void ut_s8() {
-  //   ut<sAMX_BF16, jblas::prologue_b::gemm::WeightKBlockS8, float>(2, 4096, 4096, 32, JBLAS_DTYPE::S8);
-  //   ut<sAMX_BF16, jblas::prologue_b::gemm::WeightKBlockS8, float>(2, 4096, 4096, 128, JBLAS_DTYPE::S8);
-  //   ut<sAMX_BF16, jblas::prologue_b::gemm::WeightKBlockS8, float>(2, 4096, 4096, -1, JBLAS_DTYPE::S8);
-  //   ut<sAMX_BF16, jblas::prologue_b::gemm::WeightKBlockS8, utils::bf16>(2, 4096, 4096, 32, JBLAS_DTYPE::S8);
+  //   ut<sAMX_BF16, prologue_b::gemm::WeightKBlockS8, float>(2, 4096, 4096, 32, BTLA_DTYPE::S8);
+  //   ut<sAMX_BF16, prologue_b::gemm::WeightKBlockS8, float>(2, 4096, 4096, 128, BTLA_DTYPE::S8);
+  //   ut<sAMX_BF16, prologue_b::gemm::WeightKBlockS8, float>(2, 4096, 4096, -1, BTLA_DTYPE::S8);
+  //   ut<sAMX_BF16, prologue_b::gemm::WeightKBlockS8, utils::bf16>(2, 4096, 4096, 32, BTLA_DTYPE::S8);
   // }
 
   // void ut_f4() {
-  //   ut<sAMX_BF16, jblas::prologue_b::gemm::WeightKBlockF4, float>(2, 4096, 4096, 32, JBLAS_DTYPE::F4_BNB);
-  //   ut<sAMX_BF16, jblas::prologue_b::gemm::WeightKBlockF4, float>(2, 4096, 4096, -1, JBLAS_DTYPE::F4_BNB);
-  //   ut<sAMX_BF16, jblas::prologue_b::gemm::WeightKBlockF4, float>(2, 4096, 4096, 32, JBLAS_DTYPE::F4_E2M1);
-  //   ut<sAMX_BF16, jblas::prologue_b::gemm::WeightKBlockF4, float>(2, 4096, 4096, -1, JBLAS_DTYPE::F4_E2M1);
-  //   ut<sAMX_BF16, jblas::prologue_b::gemm::WeightKBlockF4, float>(2, 4096, 4096, 32, JBLAS_DTYPE::F4_NF4);
-  //   ut<sAMX_BF16, jblas::prologue_b::gemm::WeightKBlockF4, float>(2, 4096, 4096, -1, JBLAS_DTYPE::F4_NF4);
-  //   ut<sAMX_BF16, jblas::prologue_b::gemm::WeightKBlockF4, utils::bf16>(2, 4096, 4096, 32, JBLAS_DTYPE::F4_BNB);
-  //   ut<sAMX_BF16, jblas::prologue_b::gemm::WeightKBlockF4, utils::bf16>(2, 4096, 4096, 32, JBLAS_DTYPE::F4_E2M1);
-  //   ut<sAMX_BF16, jblas::prologue_b::gemm::WeightKBlockF4, utils::bf16>(2, 4096, 4096, 32, JBLAS_DTYPE::F4_NF4);
+  //   ut<sAMX_BF16, prologue_b::gemm::WeightKBlockF4, float>(2, 4096, 4096, 32, BTLA_DTYPE::F4_BNB);
+  //   ut<sAMX_BF16, prologue_b::gemm::WeightKBlockF4, float>(2, 4096, 4096, -1, BTLA_DTYPE::F4_BNB);
+  //   ut<sAMX_BF16, prologue_b::gemm::WeightKBlockF4, float>(2, 4096, 4096, 32, BTLA_DTYPE::F4_E2M1);
+  //   ut<sAMX_BF16, prologue_b::gemm::WeightKBlockF4, float>(2, 4096, 4096, -1, BTLA_DTYPE::F4_E2M1);
+  //   ut<sAMX_BF16, prologue_b::gemm::WeightKBlockF4, float>(2, 4096, 4096, 32, BTLA_DTYPE::F4_NF4);
+  //   ut<sAMX_BF16, prologue_b::gemm::WeightKBlockF4, float>(2, 4096, 4096, -1, BTLA_DTYPE::F4_NF4);
+  //   ut<sAMX_BF16, prologue_b::gemm::WeightKBlockF4, utils::bf16>(2, 4096, 4096, 32, BTLA_DTYPE::F4_BNB);
+  //   ut<sAMX_BF16, prologue_b::gemm::WeightKBlockF4, utils::bf16>(2, 4096, 4096, 32, BTLA_DTYPE::F4_E2M1);
+  //   ut<sAMX_BF16, prologue_b::gemm::WeightKBlockF4, utils::bf16>(2, 4096, 4096, 32, BTLA_DTYPE::F4_NF4);
   // }
 
-  template <typename Core_T, typename LOG_T, template <class _T, JBLAS_ISA> class Wei, typename Scale_T>
+  template <typename Core_T, typename LOG_T, template <class _T, BTLA_ISA> class Wei, typename Scale_T>
   void benchmark(int m, int n, int k, int blocksize, int batch, float* A, float* B, float* C, float timems, int threads,
-                 JBLAS_DTYPE qtype) {
+                 BTLA_DTYPE qtype) {
     LOG_T log;
-    using Parallel = jblas::parallel::gemm::SchedulerBase<Core_T>;
-    using Launcher =
-        jblas::wrapper::gemm::LauncherBase<Core_T::ISA, Core_T, jblas::prologue_a::gemm::ActivationConverterFp32, Wei,
-                                           jblas::epilogue::gemm::AccumulatorWriteBackFp32>;
+    using Parallel = parallel::gemm::SchedulerBase<Core_T>;
+    using Launcher = wrapper::gemm::LauncherBase<Core_T::ISA, Core_T, prologue_a::gemm::ActivationConverterFp32, Wei,
+                                                 epilogue::gemm::AccumulatorWriteBackFp32>;
     Launcher kernel;
     DefaultThreading.set_threads(threads);
-    auto corestr = jblas::gemm::CoreAttr::to_str(Core_T::ID);
+    auto corestr = gemm::CoreAttr::to_str(Core_T::ID);
     utils::timer<std::chrono::milliseconds> tm;
     using WType = typename Wei<Core_T, Core_T::ISA>::StorageWeight;
     WType tmpB(0);
     if constexpr (std::is_same_v<Wei<Core_T, Core_T::ISA>,
-                                 jblas::prologue_b::gemm::WeightKBlockNInteger<Core_T, Core_T::ISA>>) {
-      tmpB = kernel.mProB.createStorage(n, k, blocksize, qtype, jblas_dtype<Scale_T>, jblas_dtype<float>, false);
+                                 prologue_b::gemm::WeightKBlockNInteger<Core_T, Core_T::ISA>>) {
+      tmpB = kernel.mProB.createStorage(n, k, blocksize, qtype, bestla_dtype<Scale_T>, bestla_dtype<float>, false);
     } else if constexpr (std::is_same_v<Wei<Core_T, Core_T::ISA>,
-                                        jblas::prologue_b::gemm::WeightKBlockNFloat<Core_T, Core_T::ISA>>) {
-      tmpB = kernel.mProB.createStorage(n, k, blocksize, qtype, jblas_dtype<Scale_T>, JBLAS_DTYPE::EleBitsUndef, false);
+                                        prologue_b::gemm::WeightKBlockNFloat<Core_T, Core_T::ISA>>) {
+      tmpB = kernel.mProB.createStorage(n, k, blocksize, qtype, bestla_dtype<Scale_T>);
     }
     std::vector<WType> packBs(batch, 0);
     std::vector<int8_t> bufB(tmpB.mSize * batch);
@@ -1424,7 +1423,7 @@ class UTBenchmark_CompBf16 {
         log.start();
         GemmProblem gp(1, m, n, k);
         typename Launcher::Param args{gp, {A + i * m * k, k}, {&packBs[i]}, {C + i * m * n, n}};
-        GemmRun<Parallel>(kernel, args, &DefaultThreading);
+        parallel::GemmRun<Parallel>(kernel, args, &DefaultThreading);
         if (log.stop()) {
           double flops = double(psize) / log.avg_val / 1e6;
           double band = double(memsize) / log.avg_val / 1e6;
@@ -1435,8 +1434,8 @@ class UTBenchmark_CompBf16 {
     }
   }
 
-  template <template <class _T, JBLAS_ISA> class Wei, typename Scale_T>
-  void benchmark_all(size_t m, size_t n, size_t k, size_t batch, JBLAS_DTYPE qtype) {
+  template <template <class _T, BTLA_ISA> class Wei, typename Scale_T>
+  void benchmark_all(size_t m, size_t n, size_t k, size_t batch, BTLA_DTYPE qtype) {
     printf("%s %d %d %d %d\n", __FUNCTION__, int(m), int(n), int(k), int(batch));
     avector<float> A(m * k * batch);
     avector<float> B(k * n * batch);
@@ -1453,16 +1452,16 @@ class UTBenchmark_CompBf16 {
     if (_cd->AMX_BF16()) {
       request_perm_xtile_data();
       int blocksize = 32;
-      benchmark<jblas::gemm::HCoreRowNAmxbf16<32, 32>, LOG, Wei, Scale_T>(m, n, k, blocksize, batch, A.data(), B.data(),
-                                                                          C.data(), testtime, 48, qtype);
-      benchmark<jblas::gemm::HCoreRowNAmxbf16<48, 16>, LOG, Wei, Scale_T>(m, n, k, blocksize, batch, A.data(), B.data(),
-                                                                          C.data(), testtime, 48, qtype);
-      benchmark<jblas::gemm::HCoreRowNAmxbf16<64, 16>, LOG, Wei, Scale_T>(m, n, k, blocksize, batch, A.data(), B.data(),
-                                                                          C.data(), testtime, 48, qtype);
+      benchmark<gemm::HCoreRowNAmxbf16<32, 32>, LOG, Wei, Scale_T>(m, n, k, blocksize, batch, A.data(), B.data(),
+                                                                   C.data(), testtime, 48, qtype);
+      benchmark<gemm::HCoreRowNAmxbf16<48, 16>, LOG, Wei, Scale_T>(m, n, k, blocksize, batch, A.data(), B.data(),
+                                                                   C.data(), testtime, 48, qtype);
+      benchmark<gemm::HCoreRowNAmxbf16<64, 16>, LOG, Wei, Scale_T>(m, n, k, blocksize, batch, A.data(), B.data(),
+                                                                   C.data(), testtime, 48, qtype);
     }
   }
 };
-#ifdef JBLAS_UT_PROLOGUE_B_
+#ifdef BTLA_UT_PROLOGUE_B_
 static UTBenchmark_CompBf16 sUTBenchmark_CompBf16;
 #endif
 
@@ -1475,36 +1474,37 @@ class UT_ORT_NBits {
 
   void ut_s4() {
     CheckISA(AVX2);
-    ut<sAVX2>(1, 14336, 4096, 32, JBLAS_DTYPE::S4_CLIP, true);
-    ut<sAVX2>(1, 1, 32, 32, JBLAS_DTYPE::S4_CLIP, false);
-    ut<sAVX2>(1, 2, 32, 32, JBLAS_DTYPE::S4_CLIP, true);
-    ut<sAVX2>(2, 4096, 4096, 32, JBLAS_DTYPE::S4_CLIP, true);
-    ut<sAVX2>(1, 11008, 4096, 32, JBLAS_DTYPE::S4_CLIP, false);
-    ut<sAVX2>(2, 4096, 4096, 32, JBLAS_DTYPE::S4_CLIP, false);
-    ut<sAVX2>(2, 4096, 4096, 128, JBLAS_DTYPE::S4_CLIP, false);
-    ut<sAVX2>(2, 4096, 4096, -1, JBLAS_DTYPE::S4_CLIP, false);
+    ut<sAVX2>(1, 14336, 4096, 32, BTLA_DTYPE::S4_CLIP, true);
+    ut<sAVX2>(1, 1, 32, 32, BTLA_DTYPE::S4_CLIP, false);
+    ut<sAVX2>(1, 2, 32, 32, BTLA_DTYPE::S4_CLIP, true);
+    ut<sAVX2>(2, 4096, 4096, 32, BTLA_DTYPE::S4_CLIP, true);
+    ut<sAVX2>(1, 11008, 4096, 32, BTLA_DTYPE::S4_CLIP, false);
+    ut<sAVX2>(2, 4096, 4096, 32, BTLA_DTYPE::S4_CLIP, false);
+    ut<sAVX2>(2, 4096, 4096, 128, BTLA_DTYPE::S4_CLIP, false);
+    ut<sAVX2>(2, 4096, 4096, -1, BTLA_DTYPE::S4_CLIP, false);
     CheckISA(AVX512F);
-    ut<sAVX512F>(2, 4096, 4096, 32, JBLAS_DTYPE::S4_CLIP, true);
-    ut<sAVX512F>(2, 4096, 4096, 32, JBLAS_DTYPE::S4_CLIP, false);
-    ut<sAVX512F>(2, 4096, 4096, 128, JBLAS_DTYPE::S4_CLIP, false);
-    ut<sAVX512F>(2, 4096, 4096, -1, JBLAS_DTYPE::S4_CLIP, false);
+    ut<sAVX512F>(2, 4096, 4096, 32, BTLA_DTYPE::S4_CLIP, true);
+    ut<sAVX512F>(2, 4096, 4096, 32, BTLA_DTYPE::S4_CLIP, false);
+    ut<sAVX512F>(2, 4096, 4096, 128, BTLA_DTYPE::S4_CLIP, false);
+    ut<sAVX512F>(2, 4096, 4096, -1, BTLA_DTYPE::S4_CLIP, false);
   }
 
   template <class GemmCore_T>
-  void ut(int m, int n, int k, int blocksize, JBLAS_DTYPE qtype, bool isasym) {
+  void ut(int m, int n, int k, int blocksize, BTLA_DTYPE qtype, bool isasym) {
     printf("Test Case %s: %d %d %d-%d type:%s core:%s asym:%d \n", __FUNCTION__, m, n, k, blocksize,
-           jblas_dtype_str(qtype), jblas::gemm::CoreAttr::to_str(GemmCore_T::ID), isasym);
+           bestla_dtype_str(qtype), gemm::CoreAttr::to_str(GemmCore_T::ID), isasym);
     auto constexpr ISA = GemmCore_T::ISA;
-    using Launcher = jblas::wrapper::gemm::LauncherKBlock<
-        ISA, GemmCore_T, prologue_a::gemm::ActivationKBlockBaseF32, jblas::prologue_b::gemm::WeightKBlockNInteger,
-        jblas::epilogue::gemm::CompFp32BlockEpilogue, jblas::epilogue::gemm::AccumulatorWriteBackFp32>;
-    using Parallel = jblas::parallel::gemm::SchedulerKBlock<GemmCore_T>;
+    using Launcher =
+        wrapper::gemm::LauncherKBlock<ISA, GemmCore_T, prologue_a::gemm::ActivationKBlockBaseF32,
+                                      prologue_b::gemm::WeightKBlockNInteger, epilogue::gemm::CompFp32BlockEpilogue,
+                                      epilogue::gemm::AccumulatorWriteBackFp32>;
+    using Parallel = parallel::gemm::SchedulerKBlock<GemmCore_T>;
     Launcher launcher;
     blocksize = blocksize == -1 ? k : blocksize;
     using WType = storage::gemm::StorageWeightKBlockNInteger;
     WType packedw(0);
     packedw =
-        launcher.mProB.createStorage(n, k, blocksize, qtype, jblas_dtype<float>, jblas_dtype<utils::bf16>, isasym);
+        launcher.mProB.createStorage(n, k, blocksize, qtype, bestla_dtype<float>, bestla_dtype<utils::bf16>, isasym);
 
     utils::avector<int8_t> buffer(packedw.mSize);
     packedw.assign(buffer.data());
@@ -1567,9 +1567,9 @@ class UT_ORT_NBits {
          isasym ? packedw.template ZPtr<int8_t>() : nullptr, rA.template RPtr<float>(), rA.lda},
         {matC.data(), n}};
     if (isasym) {
-      GemmRunWithA<Parallel>(launcher, args, &DefaultThreading);
+      parallel::GemmRunWithA<Parallel>(launcher, args, &DefaultThreading);
     } else {
-      GemmRun<Parallel>(launcher, args, &DefaultThreading);
+      parallel::GemmRun<Parallel>(launcher, args, &DefaultThreading);
     }
     auto err = INT4_ERR;
     buffer_error(refC.data(), matC.data(), refC.size(), err);
@@ -1579,15 +1579,16 @@ class UT_ORT_NBits {
   template <class GemmCore_T>
   void ut_file(int m) {
     int n = 14336, k = 4096, blocksize = 32;
-    JBLAS_DTYPE qtype = JBLAS_DTYPE::S4_CLIP;
+    BTLA_DTYPE qtype = BTLA_DTYPE::S4_CLIP;
     bool isasym = true;
     printf("Test Case %s: %d %d %d-%d type:%s core:%s asym:%d \n", __FUNCTION__, m, n, k, blocksize,
-           jblas_dtype_str(qtype), jblas::gemm::CoreAttr::to_str(GemmCore_T::ID), isasym);
+           bestla_dtype_str(qtype), gemm::CoreAttr::to_str(GemmCore_T::ID), isasym);
     auto constexpr ISA = GemmCore_T::ISA;
-    using Launcher = jblas::wrapper::gemm::LauncherKBlock<
-        ISA, GemmCore_T, prologue_a::gemm::ActivationKBlockBaseF32, jblas::prologue_b::gemm::WeightKBlockNInteger,
-        jblas::epilogue::gemm::CompFp32BlockEpilogue, jblas::epilogue::gemm::AccumulatorWriteBackFp32>;
-    using Parallel = jblas::parallel::gemm::SchedulerKBlock<GemmCore_T>;
+    using Launcher =
+        wrapper::gemm::LauncherKBlock<ISA, GemmCore_T, prologue_a::gemm::ActivationKBlockBaseF32,
+                                      prologue_b::gemm::WeightKBlockNInteger, epilogue::gemm::CompFp32BlockEpilogue,
+                                      epilogue::gemm::AccumulatorWriteBackFp32>;
+    using Parallel = parallel::gemm::SchedulerKBlock<GemmCore_T>;
     Launcher launcher;
     const char *qfile = "int_weight.bin", *sfile = "scales.bin", *zfile = "zeros.bin";
     auto qdata = ut::readFile2Buffer<int8_t>(qfile);
@@ -1595,7 +1596,7 @@ class UT_ORT_NBits {
     auto zdata = readFile2Buffer<int8_t>(zfile);
     using WType = storage::gemm::StorageWeightKBlockNInteger;
     WType packedw =
-        launcher.mProB.createStorage(n, k, blocksize, qtype, jblas_dtype<float>, jblas_dtype<utils::bf16>, isasym);
+        launcher.mProB.createStorage(n, k, blocksize, qtype, bestla_dtype<float>, bestla_dtype<utils::bf16>, isasym);
 
     utils::avector<int8_t> buffer(packedw.mSize);
     packedw.assign(buffer.data());
@@ -1625,7 +1626,7 @@ class UT_ORT_NBits {
 
     launcher.mProB.packQWeight(n, k, qdata.data(), n, sdata.data(), zdata.data(), &packedw, &DefaultThreading);
 
-    auto bfile = readFile2Buffer<int8_t>("jblas_w3.weight.bin");
+    auto bfile = readFile2Buffer<int8_t>("bestla_w3.weight.bin");
     WType packedfile(0);
     packedfile.deserialize(bfile.data());
     buffer_error(packedw.WPtr<int8_t>(), packedfile.WPtr<int8_t>(), packedw.mQBuf.size<int8_t>());
@@ -1645,16 +1646,16 @@ class UT_ORT_NBits {
          isasym ? packedw.template ZPtr<int8_t>() : nullptr, rA.template RPtr<float>(), rA.lda},
         {matC.data(), n}};
     if (isasym) {
-      GemmRunWithA<Parallel>(launcher, args, &DefaultThreading);
+      parallel::GemmRunWithA<Parallel>(launcher, args, &DefaultThreading);
     } else {
-      GemmRun<Parallel>(launcher, args, &DefaultThreading);
+      parallel::GemmRun<Parallel>(launcher, args, &DefaultThreading);
     }
     auto err = INT4_ERR;
     buffer_error(refC.data(), matC.data(), refC.size(), err);
     buffer_error(refCupk.data(), matC.data(), refCupk.size(), 0.001f);
   }
 };
-#ifdef JBLAS_UT_PROLOGUE_B
+#ifdef BTLA_UT_PROLOGUE_B
 static UT_ORT_NBits sUT_ORT_NBits;
 #endif
 
@@ -1670,56 +1671,56 @@ class UT_CompFp16 {
   }
 
   void ut_s4() {
-    ut<sAVX512_FP16, jblas::prologue_b::gemm::WeightKBlockS4, float>(2, 4096, 4096, 32, JBLAS_DTYPE::S4_CLIP);
-    ut<sAVX512_FP16, jblas::prologue_b::gemm::WeightKBlockS4, float>(2, 4096, 4096, 128, JBLAS_DTYPE::S4_CLIP);
-    ut<sAVX512_FP16, jblas::prologue_b::gemm::WeightKBlockS4, float>(2, 4096, 4096, -1, JBLAS_DTYPE::S4_CLIP);
-    ut<sAVX512_FP16, jblas::prologue_b::gemm::WeightKBlockS4, float>(2, 4096, 4096, 32, JBLAS_DTYPE::S4_FULLRANGE);
-    ut<sAVX512_FP16, jblas::prologue_b::gemm::WeightKBlockS4, float>(2, 4096, 4096, 128, JBLAS_DTYPE::S4_FULLRANGE);
-    ut<sAVX512_FP16, jblas::prologue_b::gemm::WeightKBlockS4, float>(2, 4096, 4096, -1, JBLAS_DTYPE::S4_FULLRANGE);
-    ut<sAVX512_FP16, jblas::prologue_b::gemm::WeightKBlockS4, utils::bf16>(2, 4096, 4096, 32, JBLAS_DTYPE::S4_CLIP);
-    ut<sAVX512_FP16, jblas::prologue_b::gemm::WeightKBlockS4, utils::bf16>(2, 4096, 4096, 32, JBLAS_DTYPE::S4_FULLRANGE);
+    ut<sAVX512_FP16, prologue_b::gemm::WeightKBlockS4, float>(2, 4096, 4096, 32, BTLA_DTYPE::S4_CLIP);
+    ut<sAVX512_FP16, prologue_b::gemm::WeightKBlockS4, float>(2, 4096, 4096, 128, BTLA_DTYPE::S4_CLIP);
+    ut<sAVX512_FP16, prologue_b::gemm::WeightKBlockS4, float>(2, 4096, 4096, -1, BTLA_DTYPE::S4_CLIP);
+    ut<sAVX512_FP16, prologue_b::gemm::WeightKBlockS4, float>(2, 4096, 4096, 32, BTLA_DTYPE::S4_FULLRANGE);
+    ut<sAVX512_FP16, prologue_b::gemm::WeightKBlockS4, float>(2, 4096, 4096, 128, BTLA_DTYPE::S4_FULLRANGE);
+    ut<sAVX512_FP16, prologue_b::gemm::WeightKBlockS4, float>(2, 4096, 4096, -1, BTLA_DTYPE::S4_FULLRANGE);
+    ut<sAVX512_FP16, prologue_b::gemm::WeightKBlockS4, utils::bf16>(2, 4096, 4096, 32, BTLA_DTYPE::S4_CLIP);
+    ut<sAVX512_FP16, prologue_b::gemm::WeightKBlockS4, utils::bf16>(2, 4096, 4096, 32, BTLA_DTYPE::S4_FULLRANGE);
   }
 
   void ut_s8() {
-    ut<sAVX512_FP16, jblas::prologue_b::gemm::WeightKBlockS8, float>(2, 4096, 4096, 32, JBLAS_DTYPE::S8);
-    ut<sAVX512_FP16, jblas::prologue_b::gemm::WeightKBlockS8, float>(2, 4096, 4096, 128, JBLAS_DTYPE::S8);
-    ut<sAVX512_FP16, jblas::prologue_b::gemm::WeightKBlockS8, float>(2, 4096, 4096, -1, JBLAS_DTYPE::S8);
-    ut<sAVX512_FP16, jblas::prologue_b::gemm::WeightKBlockS8, utils::bf16>(2, 4096, 4096, 32, JBLAS_DTYPE::S8);
+    ut<sAVX512_FP16, prologue_b::gemm::WeightKBlockS8, float>(2, 4096, 4096, 32, BTLA_DTYPE::S8);
+    ut<sAVX512_FP16, prologue_b::gemm::WeightKBlockS8, float>(2, 4096, 4096, 128, BTLA_DTYPE::S8);
+    ut<sAVX512_FP16, prologue_b::gemm::WeightKBlockS8, float>(2, 4096, 4096, -1, BTLA_DTYPE::S8);
+    ut<sAVX512_FP16, prologue_b::gemm::WeightKBlockS8, utils::bf16>(2, 4096, 4096, 32, BTLA_DTYPE::S8);
   }
 
   void ut_f4() {
-    ut<sAVX512_FP16, jblas::prologue_b::gemm::WeightKBlockF4, float>(2, 4096, 4096, 32, JBLAS_DTYPE::F4_BNB);
-    ut<sAVX512_FP16, jblas::prologue_b::gemm::WeightKBlockF4, float>(2, 4096, 4096, -1, JBLAS_DTYPE::F4_BNB);
-    ut<sAVX512_FP16, jblas::prologue_b::gemm::WeightKBlockF4, float>(2, 4096, 4096, 32, JBLAS_DTYPE::F4_E2M1);
-    ut<sAVX512_FP16, jblas::prologue_b::gemm::WeightKBlockF4, float>(2, 4096, 4096, -1, JBLAS_DTYPE::F4_E2M1);
-    ut<sAVX512_FP16, jblas::prologue_b::gemm::WeightKBlockF4, float>(2, 4096, 4096, 32, JBLAS_DTYPE::F4_NF4);
-    ut<sAVX512_FP16, jblas::prologue_b::gemm::WeightKBlockF4, float>(2, 4096, 4096, -1, JBLAS_DTYPE::F4_NF4);
-    ut<sAVX512_FP16, jblas::prologue_b::gemm::WeightKBlockF4, utils::bf16>(2, 4096, 4096, 32, JBLAS_DTYPE::F4_BNB);
-    ut<sAVX512_FP16, jblas::prologue_b::gemm::WeightKBlockF4, utils::bf16>(2, 4096, 4096, 32, JBLAS_DTYPE::F4_E2M1);
-    ut<sAVX512_FP16, jblas::prologue_b::gemm::WeightKBlockF4, utils::bf16>(2, 4096, 4096, 32, JBLAS_DTYPE::F4_NF4);
+    ut<sAVX512_FP16, prologue_b::gemm::WeightKBlockF4, float>(2, 4096, 4096, 32, BTLA_DTYPE::F4_BNB);
+    ut<sAVX512_FP16, prologue_b::gemm::WeightKBlockF4, float>(2, 4096, 4096, -1, BTLA_DTYPE::F4_BNB);
+    ut<sAVX512_FP16, prologue_b::gemm::WeightKBlockF4, float>(2, 4096, 4096, 32, BTLA_DTYPE::F4_E2M1);
+    ut<sAVX512_FP16, prologue_b::gemm::WeightKBlockF4, float>(2, 4096, 4096, -1, BTLA_DTYPE::F4_E2M1);
+    ut<sAVX512_FP16, prologue_b::gemm::WeightKBlockF4, float>(2, 4096, 4096, 32, BTLA_DTYPE::F4_NF4);
+    ut<sAVX512_FP16, prologue_b::gemm::WeightKBlockF4, float>(2, 4096, 4096, -1, BTLA_DTYPE::F4_NF4);
+    ut<sAVX512_FP16, prologue_b::gemm::WeightKBlockF4, utils::bf16>(2, 4096, 4096, 32, BTLA_DTYPE::F4_BNB);
+    ut<sAVX512_FP16, prologue_b::gemm::WeightKBlockF4, utils::bf16>(2, 4096, 4096, 32, BTLA_DTYPE::F4_E2M1);
+    ut<sAVX512_FP16, prologue_b::gemm::WeightKBlockF4, utils::bf16>(2, 4096, 4096, 32, BTLA_DTYPE::F4_NF4);
   }
 
-  template <class GemmCore_T, template <class _T, JBLAS_ISA> class Wei, typename Scale_T>
-  void ut(int m, int n, int k, int blocksize, JBLAS_DTYPE qtype) {
+  template <class GemmCore_T, template <class _T, BTLA_ISA> class Wei, typename Scale_T>
+  void ut(int m, int n, int k, int blocksize, BTLA_DTYPE qtype) {
     printf("Test Case %s: %d %d %d-%d type:%s core:%s scaletype:%s\n", __FUNCTION__, m, n, k, blocksize,
-           jblas_dtype_str(qtype),jblas::gemm::CoreAttr::to_str(GemmCore_T::ID), type_str<Scale_T>);
+           bestla_dtype_str(qtype),gemm::CoreAttr::to_str(GemmCore_T::ID), type_str<Scale_T>);
     auto constexpr ISA = GemmCore_T::ISA;
-    using Launcher = jblas::wrapper::gemm::LauncherKBlock<ISA, GemmCore_T, prologue_a::gemm::ActivationBase, Wei,
-                                                          jblas::epilogue::gemm::CompFp32BlockEpilogue,
-                                                          jblas::epilogue::gemm::AccumulatorWriteBackFp32>;
-    using Parallel = jblas::parallel::gemm::SchedulerKBlock<GemmCore_T>;
+    using Launcher = wrapper::gemm::LauncherKBlock<ISA, GemmCore_T, prologue_a::gemm::ActivationBase, Wei,
+                                                          epilogue::gemm::CompFp32BlockEpilogue,
+                                                          epilogue::gemm::AccumulatorWriteBackFp32>;
+    using Parallel = parallel::gemm::SchedulerKBlock<GemmCore_T>;
     Launcher launcher;
     blocksize = blocksize == -1 ? k : blocksize;
     using WType = typename Wei<GemmCore_T, ISA>::StorageWeight;
     WType packedw(0);
-    if constexpr (std::is_same_v<Wei<GemmCore_T, ISA>, jblas::prologue_b::gemm::WeightKBlockS8<GemmCore_T, ISA>>) {
-      packedw = launcher.mProB.createStorage(n, k, blocksize, jblas_dtype<Scale_T>, jblas_dtype<float>, false);
+    if constexpr (std::is_same_v<Wei<GemmCore_T, ISA>, prologue_b::gemm::WeightKBlockS8<GemmCore_T, ISA>>) {
+      packedw = launcher.mProB.createStorage(n, k, blocksize, bestla_dtype<Scale_T>, bestla_dtype<float>, false);
     } else if constexpr (std::is_same_v<Wei<GemmCore_T, ISA>,
-                                        jblas::prologue_b::gemm::WeightKBlockS4<GemmCore_T, ISA>>) {
-      packedw = launcher.mProB.createStorage(n, k, blocksize, qtype, jblas_dtype<Scale_T>, jblas_dtype<float>, false);
+                                        prologue_b::gemm::WeightKBlockS4<GemmCore_T, ISA>>) {
+      packedw = launcher.mProB.createStorage(n, k, blocksize, qtype, bestla_dtype<Scale_T>, bestla_dtype<float>, false);
     } else if constexpr (std::is_same_v<Wei<GemmCore_T, ISA>,
-                                        jblas::prologue_b::gemm::WeightKBlockF4<GemmCore_T, ISA>>) {
-      packedw = launcher.mProB.createStorage(n, k, blocksize, qtype, jblas_dtype<Scale_T>);
+                                        prologue_b::gemm::WeightKBlockF4<GemmCore_T, ISA>>) {
+      packedw = launcher.mProB.createStorage(n, k, blocksize, qtype, bestla_dtype<Scale_T>);
     }
 
     utils::avector<int8_t> buffer(packedw.mSize);
@@ -1746,12 +1747,12 @@ class UT_CompFp16 {
                                   {&packedw},
                                   {packedw.template SPtr<int8_t>(), packedw.SDtype(), packedw.CStep()},
                                   {matC.data(), n}};
-    GemmRun<Parallel>(launcher, args);
+    parallel::GemmRun<Parallel>(launcher, args);
     auto err = INT8_ERR;
-    if constexpr (std::is_same_v<Wei<GemmCore_T, ISA>, jblas::prologue_b::gemm::WeightKBlockS4<GemmCore_T, ISA>>) {
+    if constexpr (std::is_same_v<Wei<GemmCore_T, ISA>, prologue_b::gemm::WeightKBlockS4<GemmCore_T, ISA>>) {
       err = INT4_ERR;
     } else if constexpr (std::is_same_v<Wei<GemmCore_T, ISA>,
-                                        jblas::prologue_b::gemm::WeightKBlockF4<GemmCore_T, ISA>>) {
+                                        prologue_b::gemm::WeightKBlockF4<GemmCore_T, ISA>>) {
       err = FP4_ERR;
     }
 
@@ -1759,9 +1760,9 @@ class UT_CompFp16 {
     buffer_error(refCupk.data(), matC.data(), refCupk.size(), 0.05f);
   }
 };
-#ifdef JBLAS_UT_DEBUG
+#ifdef BTLA_UT_DEBUG
 static UT_CompFp16 sUT_CompFp16;
 #endif
 #endif
 }  // namespace ut
-}  // namespace jblas
+}  // namespace bestla
diff --git a/bestla/bestla/ut/bestla_ut.cpp b/bestla/bestla/ut/bestla_ut.cpp
new file mode 100644
index 000000000..c3d00a944
--- /dev/null
+++ b/bestla/bestla/ut/bestla_ut.cpp
@@ -0,0 +1,6 @@
+#include <stdio.h>
+
+int main() {
+  printf("BesTLA UT done\n");
+  return 0;
+}
diff --git a/bestla/jblas/ut/jit_blas_ut.h b/bestla/bestla/ut/bestla_ut.h
similarity index 89%
rename from bestla/jblas/ut/jit_blas_ut.h
rename to bestla/bestla/ut/bestla_ut.h
index 318f23bf5..66d598ecc 100644
--- a/bestla/jblas/ut/jit_blas_ut.h
+++ b/bestla/bestla/ut/bestla_ut.h
@@ -1,9 +1,9 @@
 #include <random>
 #include <stdexcept>
-#include "../jit_blas_utils.h"
-#include "../jit_blas_gemm.h"
-#include "../jit_blas_device.h"
-#include "../jit_blas_parallel.h"
+#include "bestla_utils.h"
+#include "bestla_gemm.h"
+#include "bestla_device.h"
+#include "bestla_parallel.h"
 
 #define CheckISA(ISA)                         \
   {                                           \
@@ -14,16 +14,16 @@
     }                                         \
   }
 
-namespace jblas {
+namespace bestla {
 namespace ut {
-using sAVX512F = jblas::gemm::SCoreRowNAvx512f<48, 8>;
-using sAMX_BF16 = jblas::gemm::HCoreRowNAmxbf16<64, 16>;
-using sAVX512_FP16 = jblas::gemm::HCoreRowNAvx512fp16<96, 8>;
-using sAVX_VNNI = jblas::gemm::ICoreRowNAvxvnni<24, 4>;
-using sAVX512_VNNI = jblas::gemm::ICoreRowNAvx512vnni<48, 8>;
-using sAMX_INT8_US = jblas::gemm::ICoreRowNAmxint8<64, 16>;
-using sAMX_INT8_SS = jblas::gemm::ICoreRowNAmxint8SS<64, 16>;
-using sAVX2 = jblas::gemm::SCoreRowNAvx2<24, 4>;
+using sAVX512F = gemm::SCoreRowNAvx512f<48, 8>;
+using sAMX_BF16 = gemm::HCoreRowNAmxbf16<64, 16>;
+using sAVX512_FP16 = gemm::HCoreRowNAvx512fp16<96, 8>;
+using sAVX_VNNI = gemm::ICoreRowNAvxvnni<24, 4>;
+using sAVX512_VNNI = gemm::ICoreRowNAvx512vnni<48, 8>;
+using sAMX_INT8_US = gemm::ICoreRowNAmxint8<64, 16>;
+using sAMX_INT8_SS = gemm::ICoreRowNAmxint8SS<64, 16>;
+using sAVX2 = gemm::SCoreRowNAvx2<24, 4>;
 #ifdef _OPENMP
 static parallel::OMPThreading DefaultThreading(4);
 #else
@@ -44,11 +44,11 @@ static int8_t cache[CacheSize];
 #define INT4_ERR 2.f
 #define FP4_ERR 3.f
 
-static inline float get_ut_err(JBLAS_DTYPE qtype){
-  auto dbits = utils::jblas_dtype_bits(qtype);
-  auto type = utils::jblas_dtype_type(qtype);
+static inline float get_ut_err(BTLA_DTYPE qtype) {
+  auto dbits = utils::bestla_dtype_bits(qtype);
+  auto type = utils::bestla_dtype_type(qtype);
   auto err = FP32_ERR;
-  auto constexpr dtype_int = utils::jblas_dtype_type(JBLAS_DTYPE::TypeInt);
+  auto constexpr dtype_int = utils::bestla_dtype_type(BTLA_DTYPE::TypeInt);
   if (type == dtype_int) {
     if (dbits == 8) {
       err = INT8_ERR;
@@ -56,17 +56,17 @@ static inline float get_ut_err(JBLAS_DTYPE qtype){
       err = INT4_ERR;
     }
   } else {
-    if (dbits==4) {
+    if (dbits == 4) {
       err = FP4_ERR;
     } else if (dbits == 8) {
       err = F8_ERR;
     } else if (dbits == 16) {
-      if (qtype==JBLAS_DTYPE::F16) {
+      if (qtype == BTLA_DTYPE::F16) {
         err = FP16_ERR;
       } else {
         err = BF16_ERR;
       }
-	}
+    }
   }
   return err;
 }
@@ -112,7 +112,7 @@ static void fill_buffer_randn(_T* buf, size_t size, _T minval, _T maxval) {
 }
 
 template <typename _T>
-jblas::utils::aligned_vector<_T> readFile2Buffer(const char* filepath) {
+utils::aligned_vector<_T> readFile2Buffer(const char* filepath) {
   auto w1fp = fopen(filepath, "rb");
   if (w1fp == NULL) {
     return utils::aligned_vector<_T>();
@@ -127,11 +127,11 @@ jblas::utils::aligned_vector<_T> readFile2Buffer(const char* filepath) {
   return buf;
 }
 
-#define UT_START()                                              \
-  {                                                             \
-    GetCPUDevice();                                             \
-    jblas::ut::DefaultThreading.set_threads(_cd->getThreads()); \
-    printf("Test Class: %s\n", __FUNCTION__);                   \
+#define UT_START()                                       \
+  {                                                      \
+    GetCPUDevice();                                      \
+    ut::DefaultThreading.set_threads(_cd->getThreads()); \
+    printf("Test Class: %s\n", __FUNCTION__);            \
   }
 template <typename _T>
 static double buffer_error(_T* ref, _T* tar, size_t size, _T thres = _T(0)) {
@@ -168,7 +168,7 @@ static double buffer_error(_T* ref, _T* tar, size_t size, _T thres = _T(0)) {
 }
 
 template <>
-double buffer_error(jblas::utils::bf16* ref, jblas::utils::bf16* tar, size_t size, jblas::utils::bf16 thres) {
+double buffer_error(utils::bf16* ref, utils::bf16* tar, size_t size, utils::bf16 thres) {
   float err = 0;
   int cnt = 0;
   float max_err = 0, max_a = 0.f, max_b = 0.f;
@@ -263,7 +263,7 @@ static double buffer_error_2d(_T* ref, _T* tar, size_t row, size_t col, size_t r
 }
 
 struct UT_vector_s8 {
-  jblas::utils::aligned_vector<int8_t> data_;
+  utils::aligned_vector<int8_t> data_;
   void resize(size_t _size) { data_.resize(_size); }
   size_t size() { return data_.size(); }
   int8_t* data() { return data_.data(); }
@@ -278,7 +278,7 @@ struct UT_vector_s8 {
       scales[i] = randn(minval, maxval);
     }
   }
-  jblas::utils::aligned_vector<float> scales;
+  utils::aligned_vector<float> scales;
 };
 
 struct UT_vector_u8 {
@@ -531,7 +531,7 @@ static inline void gemmref_fp16fp16fp16(int m, int n, int k, utils::fp16* A, uti
 }
 
 struct UT_GEMMData_Row_fp16 {
-  jblas::utils::aligned_vector<utils::fp16> matA, matB, matC, matD;
+  utils::aligned_vector<utils::fp16> matA, matB, matC, matD;
   int M, N, K, LDA, LDB, LDC, LDD;
   UT_GEMMData_Row_fp16(int m, int n, int k, int lda, int ldb, int ldc, int ldd)
       : M(m), N(n), K(k), LDA(lda), LDB(ldb), LDC(ldc), LDD(ldd) {
@@ -543,9 +543,9 @@ struct UT_GEMMData_Row_fp16 {
     } else {
       matD.resize(m * ldd);
     }
-    jblas::ut::fill_buffer_randn(matA.data(), m * lda, utils::fp16(-0.5f), utils::fp16(0.5f));
-    jblas::ut::fill_buffer_randn(matB.data(), k * ldb, utils::fp16(-0.5f), utils::fp16(0.5f));
-    jblas::ut::fill_buffer_randn(matD.data(), matD.size(), utils::fp16(0.f), utils::fp16(1.f));
+    ut::fill_buffer_randn(matA.data(), m * lda, utils::fp16(-0.5f), utils::fp16(0.5f));
+    ut::fill_buffer_randn(matB.data(), k * ldb, utils::fp16(-0.5f), utils::fp16(0.5f));
+    ut::fill_buffer_randn(matD.data(), matD.size(), utils::fp16(0.f), utils::fp16(1.f));
   }
 
   void calc_ref(float alpha, float beta) {
@@ -568,7 +568,7 @@ struct UT_GEMMData_Row_fp16 {
 };
 
 struct UT_GEMMData_Row_f32 {
-  jblas::utils::aligned_vector<float> matA, matB, matC, matD, matRef;
+  utils::aligned_vector<float> matA, matB, matC, matD, matRef;
   int M, N, K, LDA, LDB, LDC, LDD;
   UT_GEMMData_Row_f32(int m, int n, int k, int lda, int ldb, int ldc, int ldd)
       : M(m), N(n), K(k), LDA(lda), LDB(ldb), LDC(ldc), LDD(ldd) {
@@ -580,9 +580,9 @@ struct UT_GEMMData_Row_f32 {
     } else {
       matD.resize(m * ldd);
     }
-    jblas::ut::fill_buffer_randn(matA.data(), m * lda, -0.5f, 0.5f);
-    jblas::ut::fill_buffer_randn(matB.data(), k * ldb, -0.5f, 0.5f);
-    jblas::ut::fill_buffer_randn(matD.data(), matD.size(), 0.f, 1.f);
+    ut::fill_buffer_randn(matA.data(), m * lda, -0.5f, 0.5f);
+    ut::fill_buffer_randn(matB.data(), k * ldb, -0.5f, 0.5f);
+    ut::fill_buffer_randn(matD.data(), matD.size(), 0.f, 1.f);
   }
 
   void calc_ref(float alpha, float beta) {
@@ -624,4 +624,4 @@ struct UT_GEMMData_Row_f32 {
 };
 
 };  // namespace ut
-}  // namespace jblas
+}  // namespace bestla
diff --git a/bestla/bestla/ut/bestla_utils.cpp b/bestla/bestla/ut/bestla_utils.cpp
new file mode 100644
index 000000000..bf668b374
--- /dev/null
+++ b/bestla/bestla/ut/bestla_utils.cpp
@@ -0,0 +1,4 @@
+
+namespace bestla {
+namespace ut {}  // namespace ut
+}  // namespace bestla
diff --git a/bestla/jblas/ut/jit_blas_wrapper.cpp b/bestla/bestla/ut/bestla_wrapper.cpp
similarity index 72%
rename from bestla/jblas/ut/jit_blas_wrapper.cpp
rename to bestla/bestla/ut/bestla_wrapper.cpp
index 0438c840e..9e97d04c1 100644
--- a/bestla/jblas/ut/jit_blas_wrapper.cpp
+++ b/bestla/bestla/ut/bestla_wrapper.cpp
@@ -1,9 +1,7 @@
-#include "../jit_blas_wrapper.h"
-#include "jit_blas_ut.h"
-namespace jblas {
+#include "bestla_wrapper.h"
+#include "bestla_ut.h"
+namespace bestla {
 using namespace utils;
-using namespace parallel;
-
 namespace ut {
 class UT_Fp32Fp32 {
  public:
@@ -24,8 +22,8 @@ class UT_Fp32Fp32 {
     ut<sAVX2>(1024, 1536, 1536);
 
     CheckISA(AVX512F);
-    ut<jblas::gemm::SCoreRowNAvx512f<48, 8>>(384, 768, 768);
-    ut<jblas::gemm::SCoreRowNAvx512f<48, 8>>(1024, 1024, 1024);
+    ut<gemm::SCoreRowNAvx512f<48, 8>>(384, 768, 768);
+    ut<gemm::SCoreRowNAvx512f<48, 8>>(1024, 1024, 1024);
     ut<sAVX512F>(1, 1, 1);
     ut<sAVX512F>(8, 48, 2);
     ut<sAVX512F>(8, 4096, 4096);
@@ -35,17 +33,16 @@ class UT_Fp32Fp32 {
   }
   template <class GemmCore_T>
   void ut(int m, int n, int k) {
-    printf("Test Case: %d %d %d Core:%s\n", m, n, k, jblas::gemm::CoreAttr::to_str(GemmCore_T::ID));
+    printf("Test Case: %d %d %d Core:%s\n", m, n, k, gemm::CoreAttr::to_str(GemmCore_T::ID));
     avector<float> matA(m * k), matB(k * n), matC(m * n), ref(m * n);
     fill_buffer_randn(matA.data(), matA.size(), -0.5f, 0.5f);
     fill_buffer_randn(matB.data(), matB.size(), -0.5f, 0.5f);
     gemmref_fp32fp32fp32(m, n, k, matA.data(), matB.data(), ref.data(), k, n, n);
     using Launcher =
-        jblas::wrapper::gemm::LauncherBase<GemmCore_T::ISA, GemmCore_T, jblas::prologue_a::gemm::ActivationBase,
-                                           jblas::prologue_b::gemm::WeightPack,
-                                           jblas::epilogue::gemm::AccumulatorWriteBackFp32>;
+        wrapper::gemm::LauncherBase<GemmCore_T::ISA, GemmCore_T, prologue_a::gemm::ActivationBase,
+                                    prologue_b::gemm::WeightPack, epilogue::gemm::AccumulatorWriteBackFp32>;
     Launcher launcher;
-    using Parallel = jblas::parallel::gemm::SchedulerBase<GemmCore_T>;
+    using Parallel = parallel::gemm::SchedulerBase<GemmCore_T>;
 
     auto packw = launcher.mProB.createStorage(n, k);
     avector<int8_t> buffer(packw.mSize);
@@ -53,7 +50,7 @@ class UT_Fp32Fp32 {
     launcher.mProB.packWeight(n, k, {matB.data(), n, &packw}, &DefaultThreading);
     utils::GemmProblem gp(1, m, n, k);
     typename Launcher::Param args{gp, {matA.data(), k}, {matB.data(), n, &packw}, {matC.data(), n}};
-    GemmRun<Parallel>(launcher, args, &DefaultThreading);
+    parallel::GemmRun<Parallel>(launcher, args, &DefaultThreading);
     ut::buffer_error(ref.data(), matC.data(), ref.size(), 0.001f);
   }
 
@@ -63,16 +60,16 @@ class UT_Fp32Fp32 {
   template <typename Core_T, typename LOG_T>
   void benchmark(int m, int n, int k, int batch, AType* A, BType* B, CType* C, float timems, int threads) {
     LOG_T log;
-    using Parallel = jblas::parallel::gemm::SchedulerBase<Core_T>;
-    using Launcher = jblas::wrapper::gemm::LauncherBase<Core_T::ISA, Core_T, jblas::prologue_a::gemm::ActivationBase,
-                                                        jblas::prologue_b::gemm::WeightPack,
-                                                        jblas::epilogue::gemm::AccumulatorWriteBackFp32>;
+    using Parallel = parallel::gemm::SchedulerBase<Core_T>;
+    using Launcher =
+        wrapper::gemm::LauncherBase<Core_T::ISA, Core_T, prologue_a::gemm::ActivationBase, prologue_b::gemm::WeightPack,
+                                    epilogue::gemm::AccumulatorWriteBackFp32>;
     Launcher kernel;
     DefaultThreading.set_threads(threads);
-    auto corestr = jblas::gemm::CoreAttr::to_str(Core_T::ID);
+    auto corestr = gemm::CoreAttr::to_str(Core_T::ID);
     utils::timer<std::chrono::milliseconds> tm;
     auto tmpB = kernel.mProB.createStorage(n, k);
-    std::vector<jblas::storage::gemm::StoragePackedWeight> packBs(batch, 0);
+    std::vector<storage::gemm::StoragePackedWeight> packBs(batch, 0);
     std::vector<int8_t> bufB(tmpB.mSize * batch);
     for (size_t i = 0; i < batch; i++) {
       packBs[i] = tmpB;
@@ -86,7 +83,7 @@ class UT_Fp32Fp32 {
         log.start();
         utils::GemmProblem gp(1, m, n, k);
         typename Launcher::Param args{gp, {A + i * m * k, k}, {0, 0, &packBs[i]}, {C + i * m * n, n}};
-        GemmRun<Parallel>(kernel, args, &DefaultThreading);
+        parallel::GemmRun<Parallel>(kernel, args, &DefaultThreading);
         if (log.stop()) {
           double flops = double(psize) / log.avg_val / 1e6;
           printf("%s %s Flops:%.3f PerCoreFlops:%.3f\n ", corestr, log.get_log_str(), flops, flops / threads);
@@ -162,7 +159,7 @@ class UT_U8S8S32 {
 
   template <class GemmCore_T>
   void ut(int m, int n, int k) {
-    printf("Test Case: %d %d %d Core:%s\n", m, n, k, jblas::gemm::CoreAttr::to_str(GemmCore_T::ID));
+    printf("Test Case: %d %d %d Core:%s\n", m, n, k, gemm::CoreAttr::to_str(GemmCore_T::ID));
     avector<float> matBf32(k * n), matAf32(m * k), matC(m * n), refC(m * n);
     avector<uint8_t> matAu8(m * k), zpAu8(m);
     avector<int8_t> matBs8(k * n);
@@ -185,12 +182,10 @@ class UT_U8S8S32 {
       }
     }
     gemmref_fp32fp32fp32(m, n, k, matAf32.data(), matBf32.data(), refC.data(), k, n, n);
-    using Launcher =
-        jblas::wrapper::gemm::LauncherBase<GemmCore_T::ISA, GemmCore_T, jblas::prologue_a::gemm::ActivationBase,
-                                           jblas::prologue_b::gemm::WeightPack,
-                                           jblas::epilogue::gemm::ZpDequantInt32ToFp32>;
+    using Launcher = wrapper::gemm::LauncherBase<GemmCore_T::ISA, GemmCore_T, prologue_a::gemm::ActivationBase,
+                                                 prologue_b::gemm::WeightPack, epilogue::gemm::ZpDequantInt32ToFp32>;
     Launcher launcher;
-    using Parallel = jblas::parallel::gemm::SchedulerBase<GemmCore_T>;
+    using Parallel = parallel::gemm::SchedulerBase<GemmCore_T>;
 
     auto packw = launcher.mProB.createStorage(n, k);
     avector<int8_t> buffer(packw.mSize);
@@ -202,7 +197,7 @@ class UT_U8S8S32 {
         {matAu8.data(), k},
         {matBs8.data(), n, &packw},
         {matC.data(), n, 1, scaleAf32.data(), scaleBf32.data(), zpAu8.data(), reduceB.data()}};
-    GemmRun<Parallel>(launcher, args, &DefaultThreading);
+    parallel::GemmRun<Parallel>(launcher, args, &DefaultThreading);
     ut::buffer_error(refC.data(), matC.data(), refC.size(), 0.001f);
   }
 
@@ -212,16 +207,16 @@ class UT_U8S8S32 {
   template <typename Core_T, typename LOG_T>
   void benchmark(int m, int n, int k, int batch, AType* A, BType* B, CType* C, float timems, int threads) {
     LOG_T log;
-    using Parallel = jblas::parallel::gemm::SchedulerBase<Core_T>;
-    using Launcher = jblas::wrapper::gemm::LauncherBase<Core_T::ISA, Core_T, jblas::prologue_a::gemm::ActivationBase,
-                                                        jblas::prologue_b::gemm::WeightPack,
-                                                        jblas::epilogue::gemm::AccumulatorWriteBackInt32>;
+    using Parallel = parallel::gemm::SchedulerBase<Core_T>;
+    using Launcher =
+        wrapper::gemm::LauncherBase<Core_T::ISA, Core_T, prologue_a::gemm::ActivationBase, prologue_b::gemm::WeightPack,
+                                    epilogue::gemm::AccumulatorWriteBackInt32>;
     Launcher kernel;
     DefaultThreading.set_threads(threads);
-    auto corestr = jblas::gemm::CoreAttr::to_str(Core_T::ID);
+    auto corestr = gemm::CoreAttr::to_str(Core_T::ID);
     utils::timer<std::chrono::milliseconds> tm;
     auto tmpB = kernel.mProB.createStorage(n, k);
-    std::vector<jblas::storage::gemm::StoragePackedWeight> packBs(batch, 0);
+    std::vector<storage::gemm::StoragePackedWeight> packBs(batch, 0);
     std::vector<int8_t> bufB(tmpB.mSize * batch);
     for (size_t i = 0; i < batch; i++) {
       packBs[i] = tmpB;
@@ -235,7 +230,7 @@ class UT_U8S8S32 {
         log.start();
         utils::GemmProblem gp(1, m, n, k);
         typename Launcher::Param args{gp, {A + i * m * k, k}, {0, 0, &packBs[i]}, {C + i * m * n, n}};
-        GemmRun<Parallel>(kernel, args, &DefaultThreading);
+        parallel::GemmRun<Parallel>(kernel, args, &DefaultThreading);
         if (log.stop()) {
           double flops = double(psize) / log.avg_val / 1e6;
           printf("Threads %d %s %s Flops:%.3f PerCoreFlops:%.3f\n", threads, corestr, log.get_log_str(), flops,
@@ -261,17 +256,16 @@ class UT_U8S8S32 {
     GetCPUDevice();
     if (_cd->AMX_INT8()) {
       request_perm_xtile_data();
-      benchmark<jblas::gemm::ICoreRowNAmxint8<32, 32>, LOG>(m, n, k, batch, A.data(), B.data(), C.data(), testtime, 48);
-      benchmark<jblas::gemm::ICoreRowNAmxint8<48, 16>, LOG>(m, n, k, batch, A.data(), B.data(), C.data(), testtime, 48);
-      benchmark<jblas::gemm::ICoreRowNAmxint8<64, 16>, LOG>(m, n, k, batch, A.data(), B.data(), C.data(), testtime, 48);
+      benchmark<gemm::ICoreRowNAmxint8<32, 32>, LOG>(m, n, k, batch, A.data(), B.data(), C.data(), testtime, 48);
+      benchmark<gemm::ICoreRowNAmxint8<48, 16>, LOG>(m, n, k, batch, A.data(), B.data(), C.data(), testtime, 48);
+      benchmark<gemm::ICoreRowNAmxint8<64, 16>, LOG>(m, n, k, batch, A.data(), B.data(), C.data(), testtime, 48);
     }
     if (_cd->AVX512_VNNI()) {
-      benchmark<jblas::gemm::ICoreRowNAvx512vnni<48, 8>, LOG>(m, n, k, batch, A.data(), B.data(), C.data(), testtime,
-                                                              48);
+      benchmark<gemm::ICoreRowNAvx512vnni<48, 8>, LOG>(m, n, k, batch, A.data(), B.data(), C.data(), testtime, 48);
     }
     if (_cd->AVX_VNNI()) {
-      benchmark<jblas::gemm::ICoreRowNAvxvnni<48, 2>, LOG>(m, n, k, batch, A.data(), B.data(), C.data(), testtime, 48);
-      benchmark<jblas::gemm::ICoreRowNAvxvnni<24, 4>, LOG>(m, n, k, batch, A.data(), B.data(), C.data(), testtime, 48);
+      benchmark<gemm::ICoreRowNAvxvnni<48, 2>, LOG>(m, n, k, batch, A.data(), B.data(), C.data(), testtime, 48);
+      benchmark<gemm::ICoreRowNAvxvnni<24, 4>, LOG>(m, n, k, batch, A.data(), B.data(), C.data(), testtime, 48);
     }
   }
 };
@@ -300,7 +294,7 @@ class UT_S8S8S32 {
   }
   template <class GemmCore_T>
   void ut(int m, int n, int k) {
-    printf("Test Case: %d %d %d Core:%s\n", m, n, k, jblas::gemm::CoreAttr::to_str(GemmCore_T::ID));
+    printf("Test Case: %d %d %d Core:%s\n", m, n, k, gemm::CoreAttr::to_str(GemmCore_T::ID));
     avector<float> matBf32(k * n), matAf32(m * k), matC(m * n), refC(m * n);
     avector<int8_t> matAu8(m * k);
     avector<int8_t> matBs8(k * n);
@@ -322,12 +316,10 @@ class UT_S8S8S32 {
       }
     }
     gemmref_fp32fp32fp32(m, n, k, matAf32.data(), matBf32.data(), refC.data(), k, n, n);
-    using Launcher =
-        jblas::wrapper::gemm::LauncherBase<GemmCore_T::ISA, GemmCore_T, jblas::prologue_a::gemm::ActivationBase,
-                                           jblas::prologue_b::gemm::WeightPack,
-                                           jblas::epilogue::gemm::DequantInt32ToFp32>;
+    using Launcher = wrapper::gemm::LauncherBase<GemmCore_T::ISA, GemmCore_T, prologue_a::gemm::ActivationBase,
+                                                 prologue_b::gemm::WeightPack, epilogue::gemm::DequantInt32ToFp32>;
     Launcher launcher;
-    using Parallel = jblas::parallel::gemm::SchedulerBase<GemmCore_T>;
+    using Parallel = parallel::gemm::SchedulerBase<GemmCore_T>;
 
     auto packw = launcher.mProB.createStorage(n, k);
     avector<int8_t> buffer(packw.mSize);
@@ -336,7 +328,7 @@ class UT_S8S8S32 {
     utils::GemmProblem gp(1, m, n, k);
     typename Launcher::Param args{
         gp, {matAu8.data(), k}, {matBs8.data(), n, &packw}, {matC.data(), n, 1, scaleAf32.data(), scaleBf32.data()}};
-    GemmRun<Parallel>(launcher, args, &DefaultThreading);
+    parallel::GemmRun<Parallel>(launcher, args, &DefaultThreading);
     ut::buffer_error(refC.data(), matC.data(), refC.size(), 0.001f);
   }
 
@@ -346,16 +338,16 @@ class UT_S8S8S32 {
   template <typename Core_T, typename LOG_T>
   void benchmark(int m, int n, int k, int batch, AType* A, BType* B, CType* C, float timems, int threads) {
     LOG_T log;
-    using Parallel = jblas::parallel::gemm::SchedulerBase<Core_T>;
-    using Launcher = jblas::wrapper::gemm::LauncherBase<Core_T::ISA, Core_T, jblas::prologue_a::gemm::ActivationBase,
-                                                        jblas::prologue_b::gemm::WeightPack,
-                                                        jblas::epilogue::gemm::AccumulatorWriteBackInt32>;
+    using Parallel = parallel::gemm::SchedulerBase<Core_T>;
+    using Launcher =
+        wrapper::gemm::LauncherBase<Core_T::ISA, Core_T, prologue_a::gemm::ActivationBase, prologue_b::gemm::WeightPack,
+                                    epilogue::gemm::AccumulatorWriteBackInt32>;
     Launcher kernel;
     DefaultThreading.set_threads(threads);
-    auto corestr = jblas::gemm::CoreAttr::to_str(Core_T::ID);
+    auto corestr = gemm::CoreAttr::to_str(Core_T::ID);
     utils::timer<std::chrono::milliseconds> tm;
     auto tmpB = kernel.mProB.createStorage(n, k);
-    std::vector<jblas::storage::gemm::StoragePackedWeight> packBs(batch, 0);
+    std::vector<storage::gemm::StoragePackedWeight> packBs(batch, 0);
     std::vector<int8_t> bufB(tmpB.mSize * batch);
     for (size_t i = 0; i < batch; i++) {
       packBs[i] = tmpB;
@@ -369,7 +361,7 @@ class UT_S8S8S32 {
         log.start();
         utils::GemmProblem gp(1, m, n, k);
         typename Launcher::Param args{gp, {A + i * m * k, k}, {0, 0, &packBs[i]}, {C + i * m * n, n}};
-        GemmRun<Parallel>(kernel, args, &DefaultThreading);
+        parallel::GemmRun<Parallel>(kernel, args, &DefaultThreading);
         if (log.stop()) {
           double flops = double(psize) / log.avg_val / 1e6;
           printf("Threads %d %s %s Flops:%.3f PerCoreFlops:%.3f\n", threads, corestr, log.get_log_str(), flops,
@@ -395,12 +387,9 @@ class UT_S8S8S32 {
     GetCPUDevice();
     if (_cd->AMX_INT8()) {
       request_perm_xtile_data();
-      benchmark<jblas::gemm::ICoreRowNAmxint8SS<32, 32>, LOG>(m, n, k, batch, A.data(), B.data(), C.data(), testtime,
-                                                              48);
-      benchmark<jblas::gemm::ICoreRowNAmxint8SS<48, 16>, LOG>(m, n, k, batch, A.data(), B.data(), C.data(), testtime,
-                                                              48);
-      benchmark<jblas::gemm::ICoreRowNAmxint8SS<64, 16>, LOG>(m, n, k, batch, A.data(), B.data(), C.data(), testtime,
-                                                              48);
+      benchmark<gemm::ICoreRowNAmxint8SS<32, 32>, LOG>(m, n, k, batch, A.data(), B.data(), C.data(), testtime, 48);
+      benchmark<gemm::ICoreRowNAmxint8SS<48, 16>, LOG>(m, n, k, batch, A.data(), B.data(), C.data(), testtime, 48);
+      benchmark<gemm::ICoreRowNAmxint8SS<64, 16>, LOG>(m, n, k, batch, A.data(), B.data(), C.data(), testtime, 48);
     }
   }
 };
@@ -428,13 +417,12 @@ class UT_Bf16Bf16Fp32 {
 
   template <class GemmCore_T>
   void ut(int m, int n, int k) {
-    printf("Test Case %s: %d %d %d core:%s\n", __FUNCTION__, m, n, k, jblas::gemm::CoreAttr::to_str(GemmCore_T::ID));
+    printf("Test Case %s: %d %d %d core:%s\n", __FUNCTION__, m, n, k, gemm::CoreAttr::to_str(GemmCore_T::ID));
     using Launcher =
-        jblas::wrapper::gemm::LauncherBase<GemmCore_T::ISA, GemmCore_T, jblas::prologue_a::gemm::ActivationBase,
-                                           jblas::prologue_b::gemm::WeightPack,
-                                           jblas::epilogue::gemm::AccumulatorWriteBackFp32>;
+        wrapper::gemm::LauncherBase<GemmCore_T::ISA, GemmCore_T, prologue_a::gemm::ActivationBase,
+                                    prologue_b::gemm::WeightPack, epilogue::gemm::AccumulatorWriteBackFp32>;
     Launcher launcher;
-    using Parallel = jblas::parallel::gemm::SchedulerBase<GemmCore_T>;
+    using Parallel = parallel::gemm::SchedulerBase<GemmCore_T>;
     auto packw = launcher.mProB.createStorage(n, k);
     avector<int8_t> buffer(packw.mSize);
     packw.assign(buffer.data());
@@ -446,7 +434,7 @@ class UT_Bf16Bf16Fp32 {
     gemmref_bf16bf16fp32(m, n, k, matAbf16.data(), matBbf16.data(), refC.data(), k, n, n);
     utils::GemmProblem gp(1, m, n, k);
     typename Launcher::Param args{gp, {matAbf16.data(), k}, {matBbf16.data(), n, &packw}, {matC.data(), n}};
-    GemmRun<Parallel>(launcher, args, &DefaultThreading);
+    parallel::GemmRun<Parallel>(launcher, args, &DefaultThreading);
     buffer_error(refC.data(), matC.data(), refC.size(), 0.05f);
   }
 
@@ -456,16 +444,16 @@ class UT_Bf16Bf16Fp32 {
   template <typename Core_T, typename LOG_T>
   void benchmark(int m, int n, int k, int batch, AType* A, BType* B, CType* C, float timems, int threads) {
     LOG_T log;
-    using Parallel = jblas::parallel::gemm::SchedulerBase<Core_T>;
-    using Launcher = jblas::wrapper::gemm::LauncherBase<Core_T::ISA, Core_T, jblas::prologue_a::gemm::ActivationBase,
-                                                        jblas::prologue_b::gemm::WeightPack,
-                                                        jblas::epilogue::gemm::AccumulatorWriteBackFp32>;
+    using Parallel = parallel::gemm::SchedulerBase<Core_T>;
+    using Launcher =
+        wrapper::gemm::LauncherBase<Core_T::ISA, Core_T, prologue_a::gemm::ActivationBase, prologue_b::gemm::WeightPack,
+                                    epilogue::gemm::AccumulatorWriteBackFp32>;
     Launcher kernel;
     DefaultThreading.set_threads(threads);
-    auto corestr = jblas::gemm::CoreAttr::to_str(Core_T::ID);
+    auto corestr = gemm::CoreAttr::to_str(Core_T::ID);
     utils::timer<std::chrono::milliseconds> tm;
     auto tmpB = kernel.mProB.createStorage(n, k);
-    std::vector<jblas::storage::gemm::StoragePackedWeight> packBs(batch, 0);
+    std::vector<storage::gemm::StoragePackedWeight> packBs(batch, 0);
     std::vector<int8_t> bufB(tmpB.mSize * batch);
     for (size_t i = 0; i < batch; i++) {
       packBs[i] = tmpB;
@@ -479,7 +467,7 @@ class UT_Bf16Bf16Fp32 {
         log.start();
         utils::GemmProblem gp(1, m, n, k);
         typename Launcher::Param args{gp, {A + i * m * k, k}, {0, 0, &packBs[i]}, {C + i * m * n, n}};
-        GemmRun<Parallel>(kernel, args, &DefaultThreading);
+        parallel::GemmRun<Parallel>(kernel, args, &DefaultThreading);
         if (log.stop()) {
           double flops = double(psize) / log.avg_val / 1e6;
           printf("Threads %d %s %s Flops:%.3f PerCoreFlops:%.3f\n", threads, corestr, log.get_log_str(), flops,
@@ -505,9 +493,9 @@ class UT_Bf16Bf16Fp32 {
     GetCPUDevice();
     if (_cd->AMX_BF16()) {
       request_perm_xtile_data();
-      benchmark<jblas::gemm::HCoreRowNAmxbf16<32, 32>, LOG>(m, n, k, batch, A.data(), B.data(), C.data(), testtime, 48);
-      benchmark<jblas::gemm::HCoreRowNAmxbf16<48, 16>, LOG>(m, n, k, batch, A.data(), B.data(), C.data(), testtime, 48);
-      benchmark<jblas::gemm::HCoreRowNAmxbf16<64, 16>, LOG>(m, n, k, batch, A.data(), B.data(), C.data(), testtime, 48);
+      benchmark<gemm::HCoreRowNAmxbf16<32, 32>, LOG>(m, n, k, batch, A.data(), B.data(), C.data(), testtime, 48);
+      benchmark<gemm::HCoreRowNAmxbf16<48, 16>, LOG>(m, n, k, batch, A.data(), B.data(), C.data(), testtime, 48);
+      benchmark<gemm::HCoreRowNAmxbf16<64, 16>, LOG>(m, n, k, batch, A.data(), B.data(), C.data(), testtime, 48);
     }
   }
 };
@@ -534,13 +522,12 @@ class UT_Fp16Fp16Fp16 {
 
   template <class GemmCore_T>
   void ut(int m, int n, int k) {
-    printf("Test Case %s: %d %d %d core:%s\n", __FUNCTION__, m, n, k, jblas::gemm::CoreAttr::to_str(GemmCore_T::ID));
+    printf("Test Case %s: %d %d %d core:%s\n", __FUNCTION__, m, n, k, gemm::CoreAttr::to_str(GemmCore_T::ID));
     using Launcher =
-        jblas::wrapper::gemm::LauncherBase<GemmCore_T::ISA, GemmCore_T, jblas::prologue_a::gemm::ActivationBase,
-                                           jblas::prologue_b::gemm::WeightPack,
-                                           jblas::epilogue::gemm::AccumulatorWriteBackFp16>;
+        wrapper::gemm::LauncherBase<GemmCore_T::ISA, GemmCore_T, prologue_a::gemm::ActivationBase,
+                                    prologue_b::gemm::WeightPack, epilogue::gemm::AccumulatorWriteBackFp16>;
     Launcher launcher;
-    using Parallel = jblas::parallel::gemm::SchedulerBase<GemmCore_T>;
+    using Parallel = parallel::gemm::SchedulerBase<GemmCore_T>;
     auto packw = launcher.mProB.createStorage(n, k);
     avector<int8_t> buffer(packw.mSize);
     packw.assign(buffer.data());
@@ -551,7 +538,7 @@ class UT_Fp16Fp16Fp16 {
     gemmref_fp16fp16fp16(m, n, k, matAbf16.data(), matBbf16.data(), refC.data(), k, n, n);
     GemmProblem gp(1, m, n, k);
     typename Launcher::Param args{gp, {matAbf16.data(), k}, {matBbf16.data(), n, &packw}, {matC.data(), n}};
-    GemmRun<Parallel>(launcher, args, &DefaultThreading);
+    parallel::GemmRun<Parallel>(launcher, args, &DefaultThreading);
     buffer_error(refC.data(), matC.data(), refC.size(), utils::fp16(0.0002f * k));
   }
 
@@ -561,16 +548,16 @@ class UT_Fp16Fp16Fp16 {
   template <typename Core_T, typename LOG_T>
   void benchmark(int m, int n, int k, int batch, AType* A, BType* B, CType* C, float timems, int threads) {
     LOG_T log;
-    using Parallel = jblas::parallel::gemm::SchedulerBase<Core_T>;
-    using Launcher = jblas::wrapper::gemm::LauncherBase<Core_T::ISA, Core_T, jblas::prologue_a::gemm::ActivationBase,
-                                                        jblas::prologue_b::gemm::WeightPack,
-                                                        jblas::epilogue::gemm::AccumulatorWriteBackFp16>;
+    using Parallel = parallel::gemm::SchedulerBase<Core_T>;
+    using Launcher =
+        wrapper::gemm::LauncherBase<Core_T::ISA, Core_T, prologue_a::gemm::ActivationBase, prologue_b::gemm::WeightPack,
+                                    epilogue::gemm::AccumulatorWriteBackFp16>;
     Launcher kernel;
     DefaultThreading.set_threads(threads);
-    auto corestr = jblas::gemm::CoreAttr::to_str(Core_T::ID);
+    auto corestr = gemm::CoreAttr::to_str(Core_T::ID);
     utils::timer<std::chrono::milliseconds> tm;
     auto tmpB = kernel.mProB.createStorage(n, k);
-    std::vector<jblas::storage::gemm::StoragePackedWeight> packBs(batch, 0);
+    std::vector<storage::gemm::StoragePackedWeight> packBs(batch, 0);
     std::vector<int8_t> bufB(tmpB.mSize * batch);
     for (size_t i = 0; i < batch; i++) {
       packBs[i] = tmpB;
@@ -584,7 +571,7 @@ class UT_Fp16Fp16Fp16 {
         log.start();
         GemmProblem gp(1, m, n, k);
         typename Launcher::Param args{gp, {A + i * m * k, k}, {0, 0, &packBs[i]}, {C + i * m * n, n}};
-        GemmRun<Parallel>(kernel, args, &DefaultThreading);
+        parallel::GemmRun<Parallel>(kernel, args, &DefaultThreading);
         if (log.stop()) {
           double flops = double(psize) / log.avg_val / 1e6;
           printf("Threads %d %s %s Flops:%.3f PerCoreFlops:%.3f\n", threads, corestr, log.get_log_str(), flops,
@@ -610,8 +597,7 @@ class UT_Fp16Fp16Fp16 {
     GetCPUDevice();
     if (_cd->AVX512_FP16()) {
       benchmark<sAVX512_FP16, LOG>(m, n, k, batch, A.data(), B.data(), C.data(), testtime, 56);
-      benchmark<jblas::gemm::HCoreRowNAvx512fp16<64, 12>, LOG>(m, n, k, batch, A.data(), B.data(), C.data(), testtime,
-                                                               56);
+      benchmark<gemm::HCoreRowNAvx512fp16<64, 12>, LOG>(m, n, k, batch, A.data(), B.data(), C.data(), testtime, 56);
       benchmark<sAVX512_FP16, LOG>(m, n, k, batch, A.data(), B.data(), C.data(), testtime, 48);
     }
   }
@@ -620,4 +606,4 @@ class UT_Fp16Fp16Fp16 {
 static UT_Fp16Fp16Fp16 sUT_Fp16Fp16Fp16;
 #endif
 }  // namespace ut
-}  // namespace jblas
+}  // namespace bestla
diff --git a/bestla/jblas/ut/kernel_intrin.cpp b/bestla/bestla/ut/kernel_intrin.cpp
similarity index 77%
rename from bestla/jblas/ut/kernel_intrin.cpp
rename to bestla/bestla/ut/kernel_intrin.cpp
index 9ac3802ce..e2cff3869 100644
--- a/bestla/jblas/ut/kernel_intrin.cpp
+++ b/bestla/bestla/ut/kernel_intrin.cpp
@@ -1,7 +1,7 @@
 #include "kernel_ut.h"
-#include "../kernel_avx2.h"
-#include "../kernel_avx512f.h"
-namespace jblas {
+#include "kernel_avx2.h"
+#include "kernel_avx512f.h"
+namespace bestla {
 using namespace utils;
 namespace ut {
 class UT_Avx512f_decompress_kblock_s4_fp {
@@ -9,13 +9,13 @@ class UT_Avx512f_decompress_kblock_s4_fp {
   UT_Avx512f_decompress_kblock_s4_fp() {
     UT_START();
     CheckISA(AVX512F);
-    ut<JBLAS_DTYPE::S4_CLIP, 2, float, utils::bf16>(32, 128, 128, 128, 0, 32, 128);
-    ut<JBLAS_DTYPE::S4_CLIP, 2, float, utils::bf16>(32, 96, 96, 96, 0, 32, 96);
-    ut<JBLAS_DTYPE::S4_CLIP, 1, float, float>(32, 48, 48, 128, 0, 32, 128);
-    ut<JBLAS_DTYPE::S4_CLIP, 1, float, utils::bf16>(32, 48, 48, 128, 0, 32, 128);
+    ut<BTLA_DTYPE::S4_CLIP, 2, float, utils::bf16>(32, 128, 128, 128, 0, 32, 128);
+    ut<BTLA_DTYPE::S4_CLIP, 2, float, utils::bf16>(32, 96, 96, 96, 0, 32, 96);
+    ut<BTLA_DTYPE::S4_CLIP, 1, float, float>(32, 48, 48, 128, 0, 32, 128);
+    ut<BTLA_DTYPE::S4_CLIP, 1, float, utils::bf16>(32, 48, 48, 128, 0, 32, 128);
   }
 
-  template <JBLAS_DTYPE S4_T, int PACK_ROW, typename ST_T, typename DST_T>
+  template <BTLA_DTYPE S4_T, int PACK_ROW, typename ST_T, typename DST_T>
   void ut(int row, int col, int ld_src, int ld_dst, int k_offset, int kblock, int NPad, bool asym = false) {
     printf("Test Case %s_%d_%d: %d %d %d %d %d %d %d %d\n", __FUNCTION__, int(S4_T), PACK_ROW, row, col, ld_src, ld_dst,
            k_offset, kblock, NPad, asym);
@@ -42,8 +42,8 @@ class UT_Avx512f_decompress_kblock_s4_fp {
     ut::buffer_error(ref_wei.data(), bf16_wei.data(), bf16_wei.size(), DST_T(BF16_ERR));
   }
 };
-#ifdef JBLAS_KERNEL_INTRIN
+#ifdef BTLA_KERNEL_INTRIN
 static UT_Avx512f_decompress_kblock_s4_fp sUT_Avx512f_decompress_kblock_s4_fp;
 #endif
 }  // namespace ut
-}  // namespace jblas
+}  // namespace bestla
diff --git a/bestla/jblas/ut/kernel_jit.cpp b/bestla/bestla/ut/kernel_jit.cpp
similarity index 92%
rename from bestla/jblas/ut/kernel_jit.cpp
rename to bestla/bestla/ut/kernel_jit.cpp
index 1bc06e150..613bcc154 100644
--- a/bestla/jblas/ut/kernel_jit.cpp
+++ b/bestla/bestla/ut/kernel_jit.cpp
@@ -1,7 +1,7 @@
-#include "../kernel_jit.h"
+#include "kernel_jit.h"
 #include "kernel_ut.h"
 
-namespace jblas {
+namespace bestla {
 using namespace utils;
 namespace ut {
 class UT_Memcpy2D_AVX512F {
@@ -61,10 +61,10 @@ class UT_Memcpy2D_AVX512F {
     tper = tm.stop() / TestLoop;
     printf("Ref Time: %f us\n", tper);
     printf("Bandwidth: %f GB/s\n", tsize / tper / 1000);
-    jblas::ut::buffer_error<float>(dstref.data(), dst.data(), dstref.size());
+    ut::buffer_error<float>(dstref.data(), dst.data(), dstref.size());
   }
 };
-#ifdef JBLAS_UT_KERNEL_JIT
+#ifdef BTLA_UT_KERNEL_JIT
 static UT_Memcpy2D_AVX512F sUT_Memcpy2D_AVX512F;
 #endif
 
@@ -88,10 +88,10 @@ class UT_Memcpy2D_AVX2 {
         src.data(),         //
         dstref.data(),      //
         row, col * sizeof(src[0]), srcstep * sizeof(src[0]), dststep * sizeof(src[0]));
-    jblas::ut::buffer_error<float>(dstref.data(), dst.data(), dstref.size());
+    ut::buffer_error<float>(dstref.data(), dst.data(), dstref.size());
   }
 };
-#ifdef JBLAS_UT_KERNEL_JIT
+#ifdef BTLA_UT_KERNEL_JIT
 static UT_Memcpy2D_AVX2 sUT_Memcpy2D_AVX2;
 #endif
 
@@ -140,10 +140,10 @@ class UT_PaddngInterleaveCvt {
     const auto t_ref = tm.stop() / TestLoop;
     printf("Ref Time: %f us\n", t_ref);
     printf("Bandwidth: %f GB/s\n", data_size / t_ref / 1000);
-    jblas::ut::buffer_error<T_DST>(dst_ref.data(), dst.data(), dst_ref.size());
+    ut::buffer_error<T_DST>(dst_ref.data(), dst.data(), dst_ref.size());
   }
 };
-#ifdef JBLAS_UT_KERNEL_JIT
+#ifdef BTLA_UT_KERNEL_JIT
 static UT_PaddngInterleaveCvt sUT_Pading_InterleaveCvt;
 #endif
 
@@ -191,10 +191,10 @@ class UT_PaddingTransInterleaveCvt {
     const auto t_ref = tm.stop() / TestLoop;
     printf("Ref Time: %f us\n", t_ref);
     printf("Bandwidth: %f GB/s\n", data_size / t_ref / 1000);
-    jblas::ut::buffer_error<T_DST>(dst_ref.data(), dst.data(), dst_ref.size());
+    ut::buffer_error<T_DST>(dst_ref.data(), dst.data(), dst_ref.size());
   }
 };
-#ifdef JBLAS_UT_KERNEL_JIT
+#ifdef BTLA_UT_KERNEL_JIT
 static UT_PaddingTransInterleaveCvt sUT_PaddingTransInterleaveCvt;
 #endif
 
@@ -226,11 +226,11 @@ class UT_CScaleInterleavedBF16FP16 {
     kernel::jit::CScaleInterleavedBF16FP16::reference<NTile, RowPack>(  //
         data_ref.data(), scale.data(), rows, cols, src_step, n_offset);
 
-    jblas::ut::buffer_error<utils::bf16>(data.data(), data_ref.data(), data.size());
+    ut::buffer_error<utils::bf16>(data.data(), data_ref.data(), data.size());
     printf("\n");
   }
 };
-#ifdef JBLAS_UT_KERNEL_JIT
+#ifdef BTLA_UT_KERNEL_JIT
 static UT_CScaleInterleavedBF16FP16 sUT_CScaleInterleavedBF16FP16;
 #endif
 
@@ -264,10 +264,10 @@ class UT_DeQuant {
                                                           test.scales.data(), nullptr, 0, row * 2, col);
     kernel::jit::DequanS8FP::forward_avx512f<PACK_ROW>(test.data(), tar.data(), row, col, col, col, test.scales.data(),
                                                        nullptr);
-    jblas::ut::buffer_error<DST_T>(ref.data(), tar.data(), ref.size());
+    ut::buffer_error<DST_T>(ref.data(), tar.data(), ref.size());
   }
 };
-#ifdef JBLAS_UT_KERNEL_JIT
+#ifdef BTLA_UT_KERNEL_JIT
 static UT_DeQuant sUT_DeQuant;
 #endif
 
@@ -288,13 +288,13 @@ class UT_DecompressS4S8 {
     ut::fill_buffer_randn(src8.data(), src8.size(), int8_t(-128), int8_t(127));
     kernel::ref::compress_s8_s4<48>(src8.data(), src.data(), row, col, col, col);
     aligned_vector<int8_t> ref(row * col), tar(row * col);
-    kernel::ref::decompress_s4_s8<JBLAS_DTYPE::S4_CLIP>(src.data(), ref.data(), row, col, col, col);
+    kernel::ref::decompress_s4_s8<BTLA_DTYPE::S4_CLIP>(src.data(), ref.data(), row, col, col, col);
     kernel::jit::decompress_s4_s8(src.data(), tar.data(), row, col, col, col);
-    jblas::ut::buffer_error<int8_t>(ref.data(), tar.data(), ref.size());
+    ut::buffer_error<int8_t>(ref.data(), tar.data(), ref.size());
   }
 };
-#ifdef JBLAS_UT_KERNEL_JIT
+#ifdef BTLA_UT_KERNEL_JIT
 static UT_DecompressS4S8 sUT_DecompressS4S8;
 #endif
 }  // namespace ut
-}  // namespace jblas
+}  // namespace bestla
diff --git a/bestla/jblas/ut/kernel_ut.h b/bestla/bestla/ut/kernel_ut.h
similarity index 59%
rename from bestla/jblas/ut/kernel_ut.h
rename to bestla/bestla/ut/kernel_ut.h
index 513388488..9f6ea32c7 100644
--- a/bestla/jblas/ut/kernel_ut.h
+++ b/bestla/bestla/ut/kernel_ut.h
@@ -1,6 +1,6 @@
 #pragma once
-#include "jit_blas_ut.h"
-#include "../kernel_ref.h"
+#include "bestla_ut.h"
+#include "kernel_ref.h"
 
 #ifdef _MSC_VER
 #define __PRETTY_FUNCTION__ __FUNCSIG__
diff --git a/bestla/jblas/ut/kernel_wrapper.cpp b/bestla/bestla/ut/kernel_wrapper.cpp
similarity index 79%
rename from bestla/jblas/ut/kernel_wrapper.cpp
rename to bestla/bestla/ut/kernel_wrapper.cpp
index 9c7adf79c..201a5ced9 100644
--- a/bestla/jblas/ut/kernel_wrapper.cpp
+++ b/bestla/bestla/ut/kernel_wrapper.cpp
@@ -1,6 +1,6 @@
 #include "kernel_ut.h"
-#include "../kernel_wrapper.h"
-namespace jblas {
+#include "kernel_wrapper.h"
+namespace bestla {
 using namespace utils;
 namespace ut {
 class UT_DecompressKBlockS4FP {
@@ -8,15 +8,15 @@ class UT_DecompressKBlockS4FP {
   UT_DecompressKBlockS4FP() {
     UT_START();
     CheckISA(AVX2);
-    ut_avx2<JBLAS_DTYPE::S4_CLIP, 1, float, float>(410, 24, 24, 24, 0, 128, 24);
-    ut_avx2<JBLAS_DTYPE::S4_CLIP, 1, float, float>(410, 48, 48, 48, 0, 128, 48);
+    ut_avx2<BTLA_DTYPE::S4_CLIP, 1, float, float>(410, 24, 24, 24, 0, 128, 24);
+    ut_avx2<BTLA_DTYPE::S4_CLIP, 1, float, float>(410, 48, 48, 48, 0, 128, 48);
     CheckISA(AVX512F);
-    ut<JBLAS_DTYPE::S4_CLIP, 2, float, float>(32, 128, 128, 128, 0, 32, 128);
-    ut<JBLAS_DTYPE::S4_CLIP, 1, float, float>(32, 48, 48, 128, 0, 32, 128);
-    ut<JBLAS_DTYPE::S4_CLIP, 1, float, utils::bf16>(32, 48, 48, 128, 0, 32, 128);
+    ut<BTLA_DTYPE::S4_CLIP, 2, float, float>(32, 128, 128, 128, 0, 32, 128);
+    ut<BTLA_DTYPE::S4_CLIP, 1, float, float>(32, 48, 48, 128, 0, 32, 128);
+    ut<BTLA_DTYPE::S4_CLIP, 1, float, utils::bf16>(32, 48, 48, 128, 0, 32, 128);
   }
 
-  template <JBLAS_DTYPE S4_T, int PACK_ROW, typename ST_T, typename DST_T>
+  template <BTLA_DTYPE S4_T, int PACK_ROW, typename ST_T, typename DST_T>
   void ut(int row, int col, int ld_src, int ld_dst, int k_offset, int kblock, int NPad, bool asym = false) {
     printf("Test Case %s_%d_%d: %d %d %d %d %d %d %d %d\n", __FUNCTION__, int(S4_T), PACK_ROW, row, col, ld_src, ld_dst,
            k_offset, kblock, NPad, asym);
@@ -34,16 +34,16 @@ class UT_DecompressKBlockS4FP {
       s4_wei[i / 2].x = utils::int4x2::convert(s8_wei[i]);
       s4_wei[i / 2].y = utils::int4x2::convert(s8_wei[i + 1]);
     }
-    jblas::kernel::wrapper::DecompressKBlockS4Fp<DST_T, PACK_ROW>::template forward<JblasAVX512F, ST_T, S4_T>(
+    kernel::wrapper::DecompressKBlockS4Fp<DST_T, PACK_ROW>::template forward<BTLA_ISA::AVX512F, ST_T, S4_T>(
         s4_wei.data(), bf16_wei.data(), row, col, ld_src, ld_dst, scales.data(), asym ? zero_points.data() : nullptr,
         k_offset, kblock, NPad, cache, CacheSize);
-    jblas::kernel::wrapper::DecompressKBlockS4Fp<DST_T, PACK_ROW>::template forward<JblasNoSIMD, ST_T, S4_T>(
+    kernel::wrapper::DecompressKBlockS4Fp<DST_T, PACK_ROW>::template forward<BTLA_ISA::NoSIMD, ST_T, S4_T>(
         s4_wei.data(), ref_wei.data(), row, col, ld_src, ld_dst, scales.data(), asym ? zero_points.data() : nullptr,
         k_offset, kblock, NPad, cache, CacheSize);
     ut::buffer_error(ref_wei.data(), bf16_wei.data(), bf16_wei.size(), DST_T(0.01f));
   }
 
-  template <JBLAS_DTYPE S4_T, int PACK_ROW, typename ST_T, typename DST_T>
+  template <BTLA_DTYPE S4_T, int PACK_ROW, typename ST_T, typename DST_T>
   void ut_avx2(int row, int col, int ld_src, int ld_dst, int k_offset, int kblock, int NPad, bool asym = false) {
     printf("Test Case %s_%d_%d: %d %d %d %d %d %d %d %d\n", __FUNCTION__, int(S4_T), PACK_ROW, row, col, ld_src, ld_dst,
            k_offset, kblock, NPad, asym);
@@ -62,16 +62,16 @@ class UT_DecompressKBlockS4FP {
       s4_wei[i / 2].x = utils::int4x2::convert(s8_wei[i]);
       s4_wei[i / 2].y = utils::int4x2::convert(s8_wei[i + 1]);
     }
-    jblas::kernel::wrapper::DecompressKBlockS4Fp<DST_T, PACK_ROW>::template forward<JblasNoSIMD, ST_T, S4_T>(
+    kernel::wrapper::DecompressKBlockS4Fp<DST_T, PACK_ROW>::template forward<BTLA_ISA::NoSIMD, ST_T, S4_T>(
         s4_wei.data(), bf16_wei.data(), row, col, ld_src, ld_dst, scales.data(), asym ? zero_points.data() : nullptr,
         k_offset, kblock, NPad, cache, CacheSize);
-    jblas::kernel::wrapper::DecompressKBlockS4Fp<DST_T, PACK_ROW>::template forward<JblasAVX2, ST_T, S4_T>(
+    kernel::wrapper::DecompressKBlockS4Fp<DST_T, PACK_ROW>::template forward<BTLA_ISA::AVX2, ST_T, S4_T>(
         s4_wei.data(), ref_wei.data(), row, col, ld_src, ld_dst, scales.data(), asym ? zero_points.data() : nullptr,
         k_offset, kblock, NPad, cache, CacheSize);
     ut::buffer_error(ref_wei.data(), bf16_wei.data(), bf16_wei.size(), DST_T(0.01f));
   }
 };
-#ifdef JBLAS_UT_KERNEL_WRAPPER
+#ifdef BTLA_UT_KERNEL_WRAPPER
 static UT_DecompressKBlockS4FP sUT_DecompressKBlockS4FP;
 #endif
 
@@ -80,14 +80,14 @@ class UT_DecompressKBlockF4FP {
   UT_DecompressKBlockF4FP() {
     UT_START();
     CheckISA(AVX2);
-    ut<float, 1, JBLAS_DTYPE::F4_BNB, JblasAVX2>(35, 48, 48, 48, 0, 12, 48);
-    ut<float, 1, JBLAS_DTYPE::F4_BNB, JblasAVX2>(11, 48, 48, 48, 0, 20, 48);
+    ut<float, 1, BTLA_DTYPE::F4_BNB, BTLA_ISA::AVX2>(35, 48, 48, 48, 0, 12, 48);
+    ut<float, 1, BTLA_DTYPE::F4_BNB, BTLA_ISA::AVX2>(11, 48, 48, 48, 0, 20, 48);
     CheckISA(AVX512F);
-    ut<float, 1, JBLAS_DTYPE::F4_BNB, JblasAVX512F>(35, 48, 48, 48, 0, 12, 48);
-    ut<float, 1, JBLAS_DTYPE::F4_BNB, JblasAVX512F>(11, 48, 48, 48, 0, 20, 48);
+    ut<float, 1, BTLA_DTYPE::F4_BNB, BTLA_ISA::AVX512F>(35, 48, 48, 48, 0, 12, 48);
+    ut<float, 1, BTLA_DTYPE::F4_BNB, BTLA_ISA::AVX512F>(11, 48, 48, 48, 0, 20, 48);
   }
 
-  template <typename T, int PACK_ROW, JBLAS_DTYPE F4_T, JBLAS_ISA ISA_T>
+  template <typename T, int PACK_ROW, BTLA_DTYPE F4_T, BTLA_ISA ISA_T>
   void ut(int row, int col, int ld_src, int ld_dst, int k_offset, int kblock, int NPad) {
     std::vector<utils::f4x2> f4_wei(row * col / 2);
     std::vector<int8_t> s8_wei(col * row);
@@ -100,15 +100,15 @@ class UT_DecompressKBlockF4FP {
       f4_wei[i / 2].x = utils::int4x2::convert(s8_wei[i]);
       f4_wei[i / 2].y = utils::int4x2::convert(s8_wei[i + 1]);
     }
-    jblas::kernel::wrapper::DecompressKBlockF4Fp<T, PACK_ROW>::template forward<ISA_T, T, F4_T>(
+    kernel::wrapper::DecompressKBlockF4Fp<T, PACK_ROW>::template forward<ISA_T, T, F4_T>(
         f4_wei.data(), wei.data(), row, col, ld_src, ld_dst, scales.data(), k_offset, kblock, NPad, cache, CacheSize);
-    jblas::kernel::wrapper::DecompressKBlockF4Fp<T, PACK_ROW>::template forward<JblasNoSIMD, T, F4_T>(
+    kernel::wrapper::DecompressKBlockF4Fp<T, PACK_ROW>::template forward<BTLA_ISA::NoSIMD, T, F4_T>(
         f4_wei.data(), ref_wei.data(), row, col, ld_src, ld_dst, scales.data(), k_offset, kblock, NPad, cache,
         CacheSize);
     ut::buffer_error(ref_wei.data(), wei.data(), wei.size(), T(0.01f));
   }
 };
-#ifdef JBLAS_UT_KERNEL_WRAPPER
+#ifdef BTLA_UT_KERNEL_WRAPPER
 static UT_DecompressKBlockF4FP sUT_DecompressKBlockF4FP;
 #endif
 
@@ -129,14 +129,14 @@ class UT_PaddingInterleaveMN {
     aligned_vector<T_DST> dst(row_pad * col_pad), ref(row_pad * col_pad);
     for (size_t i = 0; i < src.size(); i++) src[i] = static_cast<T_SRC>(float(i));
 
-    kernel::wrapper::PaddingInterleaveMN<NTile, RowPack>::template forward<JblasNoSIMD>(
+    kernel::wrapper::PaddingInterleaveMN<NTile, RowPack>::template forward<BTLA_ISA::NoSIMD>(
         src.data(), ref.data(), row, col, row_pad, col_pad, row_pad, col);
-    kernel::wrapper::PaddingInterleaveMN<NTile, RowPack>::template forward<JblasAVX512_FP16>(
+    kernel::wrapper::PaddingInterleaveMN<NTile, RowPack>::template forward<BTLA_ISA::AVX512_FP16>(
         src.data(), dst.data(), row, col, row_pad, col_pad, col, row_pad);
     ut::buffer_error(dst.data(), ref.data(), dst.size());
   }
 };
-#ifdef JBLAS_UT_KERNEL_WRAPPER
+#ifdef BTLA_UT_KERNEL_WRAPPER
 static UT_PaddingInterleaveMN sUT_PaddingInterleaveMN;
 #endif
 
@@ -157,14 +157,14 @@ class UT_PaddingTransInterleaveMN {
     aligned_vector<T_DST> dst(col_pad * row_pad), ref(col_pad * row_pad);
     for (size_t i = 0; i < src.size(); i++) src[i] = static_cast<T_SRC>(float(i));
 
-    kernel::wrapper::PaddingTransInterleaveMN<MTile, ColPack>::template forward<JblasNoSIMD>(
+    kernel::wrapper::PaddingTransInterleaveMN<MTile, ColPack>::template forward<BTLA_ISA::NoSIMD>(
         src.data(), ref.data(), row, col, row_pad, col_pad, row_pad, col);
-    kernel::wrapper::PaddingTransInterleaveMN<MTile, ColPack>::template forward<JblasAVX512_FP16>(
+    kernel::wrapper::PaddingTransInterleaveMN<MTile, ColPack>::template forward<BTLA_ISA::AVX512_FP16>(
         src.data(), dst.data(), row, col, row_pad, col_pad, col, row_pad);
     ut::buffer_error(dst.data(), ref.data(), dst.size());
   }
 };
-#ifdef JBLAS_UT_KERNEL_WRAPPER
+#ifdef BTLA_UT_KERNEL_WRAPPER
 static UT_PaddingTransInterleaveMN sUT_PaddingTransInterleaveMN;
 #endif
 
@@ -186,15 +186,15 @@ class UT_RevertPaddingInterleaveMN {
       src[i] = static_cast<T>(i);
     }
     aligned_vector<T> reverted(row * col);
-    kernel::wrapper::PaddingInterleaveMN<NTile, PackRow>::template forward<JblasNoSIMD>(
+    kernel::wrapper::PaddingInterleaveMN<NTile, PackRow>::template forward<BTLA_ISA::NoSIMD>(
         src.data(), packed.data(), row, col, rowpad, colpad, col, rowpad);
-    kernel::wrapper::RevertPaddingInterleaveMN<NTile, PackRow>::template forward<JblasNoSIMD>(
+    kernel::wrapper::RevertPaddingInterleaveMN<NTile, PackRow>::template forward<BTLA_ISA::NoSIMD>(
         packed.data(), reverted.data(), row, col, rowpad, colpad, rowpad, col);
     ut::buffer_error(src.data(), reverted.data(), reverted.size());
   }
 };
-#ifdef JBLAS_UT_KERNEL_WRAPPER
+#ifdef BTLA_UT_KERNEL_WRAPPER
 static UT_RevertPaddingInterleaveMN sUT_RevertPaddingInterleaveMN;
 #endif
 }  // namespace ut
-}  // namespace jblas
+}  // namespace bestla
diff --git a/bestla/jblas/xbyak/xbyak.h b/bestla/bestla/xbyak/xbyak.h
similarity index 100%
rename from bestla/jblas/xbyak/xbyak.h
rename to bestla/bestla/xbyak/xbyak.h
diff --git a/bestla/bestla/xbyak/xbyak_bin2hex.h b/bestla/bestla/xbyak/xbyak_bin2hex.h
new file mode 100644
index 000000000..fda7da3c9
--- /dev/null
+++ b/bestla/bestla/xbyak/xbyak_bin2hex.h
@@ -0,0 +1,271 @@
+//  Copyright (c) 2023 Intel Corporation
+//
+//  Licensed under the Apache License, Version 2.0 (the "License");
+//  you may not use this file except in compliance with the License.
+//  You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+//  Unless required by applicable law or agreed to in writing, software
+//  distributed under the License is distributed on an "AS IS" BASIS,
+//  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.
+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
+};
diff --git a/bestla/jblas/xbyak/xbyak_mnemonic.h b/bestla/bestla/xbyak/xbyak_mnemonic.h
similarity index 51%
rename from bestla/jblas/xbyak/xbyak_mnemonic.h
rename to bestla/bestla/xbyak/xbyak_mnemonic.h
index 9e70e39ec..5d2df99cb 100644
--- a/bestla/jblas/xbyak/xbyak_mnemonic.h
+++ b/bestla/bestla/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,1147 @@ 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 +3004,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 +3220,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 +3300,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 +3493,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 +3527,1186 @@ 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/bestla/bestla/xbyak/xbyak_util.h b/bestla/bestla/xbyak/xbyak_util.h
new file mode 100644
index 000000000..f9e43afc8
--- /dev/null
+++ b/bestla/bestla/xbyak/xbyak_util.h
@@ -0,0 +1,1160 @@
+//  Copyright (c) 2023 Intel Corporation
+//
+//  Licensed under the Apache License, Version 2.0 (the "License");
+//  you may not use this file except in compliance with the License.
+//  You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+//  Unless required by applicable law or agreed to in writing, software
+//  distributed under the License is distributed on an "AS IS" BASIS,
+//  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.
+#ifndef XBYAK_XBYAK_UTIL_H_
+#define XBYAK_XBYAK_UTIL_H_
+
+#ifdef XBYAK_ONLY_CLASS_CPU
+#include <stdint.h>
+#include <stdlib.h>
+#include <assert.h>
+#ifndef XBYAK_THROW
+#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
+#else
+#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
+*/
+#include "xbyak.h"
+#endif  // XBYAK_ONLY_CLASS_CPU
+
+#if defined(__i386__) || defined(__x86_64__) || defined(_M_IX86) || defined(_M_X64)
+#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 {
+				push	ebx
+				push	esi
+				mov		eax, dword ptr [esp + 4 * 2 + 8]  // eaxIn
+				cpuid
+				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
+				mov		dword ptr [esi + 12], edx
+				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
+#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
+#endif
+#ifdef __linux__
+#define XBYAK_USE_PERF
+#endif
+
+namespace Xbyak {
+namespace util {
+
+typedef enum { SmtLevel = 1, CoreLevel = 2 } IntelCpuTopologyLevel;
+
+namespace local {
+
+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 <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;
+}
+
+}  // namespace local
+
+/**
+        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];
+
+  static const uint32_t maxNumberCacheLevels = 10;
+  uint32_t dataCacheSize_[maxNumberCacheLevels];
+  uint32_t coresSharignDataCache_[maxNumberCacheLevels];
+  uint32_t dataCacheLevels_;
+
+  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;
+
+    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
+
+             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] = {};
+
+    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_++;
+      }
+    }
+  }
+
+ 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 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]) {
+#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
+#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
+#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
+#else
+    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 {}
+#else
+#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);
+
+#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;
+      }
+
+      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);
+
+      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;
+    }
+
+    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 (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)
+#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 {
+#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);
+#endif
+  }
+  bool has(const Type& type) const { return (type & type_) == type; }
+};
+
+#ifndef XBYAK_ONLY_CLASS_CPU
+class Clock {
+ 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
+#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
+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");
+  }
+};
+
+class StackFrame {
+#ifdef XBYAK64_WIN
+  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;
+#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
+
+          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();
+  }
+
+ 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,
+#else
+        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;
+  }
+};
+#endif
+
+class Profiler {
+  int mode_;
+  const char* suffix_;
+  const void* startAddr_;
+#ifdef XBYAK_USE_PERF
+  FILE* fp_;
+#endif
+ public:
+  enum { None = 0, Perf = 1, VTune = 2 };
+  Profiler()
+      : mode_(None),
+        suffix_(""),
+        startAddr_(0)
+#ifdef XBYAK_USE_PERF
+        ,
+        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:
+#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;
+#endif
+        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;
+#endif
+        return;
+    }
+  }
+  ~Profiler() { close(); }
+  void close() {
+#ifdef XBYAK_USE_PERF
+    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;
+#if !defined(XBYAK_USE_PERF) && !defined(XBYAK_USE_VTUNE)
+    (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_);
+    }
+#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);
+#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;
+  }
+};
+#endif  // XBYAK_ONLY_CLASS_CPU
+
+}  // namespace util
+}  // namespace Xbyak
+
+#endif
diff --git a/bestla/jblas/ut/jit_blas.cpp b/bestla/jblas/ut/jit_blas.cpp
deleted file mode 100644
index 67f011af0..000000000
--- a/bestla/jblas/ut/jit_blas.cpp
+++ /dev/null
@@ -1 +0,0 @@
-#include "../jit_blas.h"
diff --git a/bestla/jblas/ut/jit_blas_ut.cpp b/bestla/jblas/ut/jit_blas_ut.cpp
deleted file mode 100644
index 64d6fca86..000000000
--- a/bestla/jblas/ut/jit_blas_ut.cpp
+++ /dev/null
@@ -1,6 +0,0 @@
-#include <stdio.h>
-
-int main() {
-  printf("jblas UT done\n");
-  return 0;
-}
diff --git a/bestla/jblas/ut/jit_blas_utils.cpp b/bestla/jblas/ut/jit_blas_utils.cpp
deleted file mode 100644
index 72879bb2f..000000000
--- a/bestla/jblas/ut/jit_blas_utils.cpp
+++ /dev/null
@@ -1,6 +0,0 @@
-
-namespace jblas {
-namespace ut {
-
-}  // namespace ut
-}  // namespace jblas
diff --git a/bestla/jblas/xbyak/xbyak_bin2hex.h b/bestla/jblas/xbyak/xbyak_bin2hex.h
deleted file mode 100644
index 285ee3410..000000000
--- a/bestla/jblas/xbyak/xbyak_bin2hex.h
+++ /dev/null
@@ -1,271 +0,0 @@
-//  Copyright (c) 2023 Intel Corporation
-//
-//  Licensed under the Apache License, Version 2.0 (the "License");
-//  you may not use this file except in compliance with the License.
-//  You may obtain a copy of the License at
-//
-//    http://www.apache.org/licenses/LICENSE-2.0
-//
-//  Unless required by applicable law or agreed to in writing, software
-//  distributed under the License is distributed on an "AS IS" BASIS,
-//  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.
-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
-};
diff --git a/bestla/jblas/xbyak/xbyak_util.h b/bestla/jblas/xbyak/xbyak_util.h
deleted file mode 100644
index 2d75bd326..000000000
--- a/bestla/jblas/xbyak/xbyak_util.h
+++ /dev/null
@@ -1,1076 +0,0 @@
-//  Copyright (c) 2023 Intel Corporation
-//
-//  Licensed under the Apache License, Version 2.0 (the "License");
-//  you may not use this file except in compliance with the License.
-//  You may obtain a copy of the License at
-//
-//    http://www.apache.org/licenses/LICENSE-2.0
-//
-//  Unless required by applicable law or agreed to in writing, software
-//  distributed under the License is distributed on an "AS IS" BASIS,
-//  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.
-#ifndef XBYAK_XBYAK_UTIL_H_
-#define XBYAK_XBYAK_UTIL_H_
-
-#ifdef XBYAK_ONLY_CLASS_CPU
-#include <stdint.h>
-#include <stdlib.h>
-#include <assert.h>
-#ifndef XBYAK_THROW
-	#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
-#else
-	#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
-*/
-#include "xbyak.h"
-#endif // XBYAK_ONLY_CLASS_CPU
-
-#if defined(__i386__) || defined(__x86_64__) || defined(_M_IX86) || defined(_M_X64)
-	#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 {
-				push	ebx
-				push	esi
-				mov		eax, dword ptr [esp + 4 * 2 + 8] // eaxIn
-				cpuid
-				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
-				mov		dword ptr [esi + 12], edx
-				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
-#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
-#endif
-#ifdef __linux__
-	#define XBYAK_USE_PERF
-#endif
-
-namespace Xbyak { namespace util {
-
-typedef enum {
-   SmtLevel = 1,
-   CoreLevel = 2
-} IntelCpuTopologyLevel;
-
-namespace local {
-
-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<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
-
-/**
-	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];
-
-	static const uint32_t maxNumberCacheLevels = 10;
-	uint32_t dataCacheSize_[maxNumberCacheLevels];
-	uint32_t coresSharignDataCache_[maxNumberCacheLevels];
-	uint32_t dataCacheLevels_;
-
-	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;
-
-		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
-
-				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] = {};
-
-		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_++;
-			}
-		}
-	}
-
-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 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])
-	{
-#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
-#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
-#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
-#else
-		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{}
-#else
-	#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);
-
-#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;
-			}
-
-			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);
-
-			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;
-		}
-
-		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 (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)
-#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
-	{
-#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);
-#endif
-	}
-	bool has(const Type& type) const
-	{
-		return (type & type_) == type;
-	}
-};
-
-#ifndef XBYAK_ONLY_CLASS_CPU
-class Clock {
-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
-#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
-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");
-	}
-};
-
-class StackFrame {
-#ifdef XBYAK64_WIN
-	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;
-#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
-
-		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();
-	}
-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,
-#else
-			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;
-	}
-};
-#endif
-
-class Profiler {
-	int mode_;
-	const char *suffix_;
-	const void *startAddr_;
-#ifdef XBYAK_USE_PERF
-	FILE *fp_;
-#endif
-public:
-	enum {
-		None = 0,
-		Perf = 1,
-		VTune = 2
-	};
-	Profiler()
-		: mode_(None)
-		, suffix_("")
-		, startAddr_(0)
-#ifdef XBYAK_USE_PERF
-		, 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:
-#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;
-#endif
-			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;
-#endif
-			return;
-		}
-	}
-	~Profiler()
-	{
-		close();
-	}
-	void close()
-	{
-#ifdef XBYAK_USE_PERF
-		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;
-#if !defined(XBYAK_USE_PERF) && !defined(XBYAK_USE_VTUNE)
-		(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_);
-		}
-#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);
-#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;
-	}
-};
-#endif // XBYAK_ONLY_CLASS_CPU
-
-} } // end of util
-
-#endif
diff --git a/developer_document.md b/developer_document.md
index d6a91b163..bcd33e1ec 100644
--- a/developer_document.md
+++ b/developer_document.md
@@ -326,7 +326,7 @@ Most of our model examples only support single prompt processing. You need to ad
 +add_library_w_warning(${TARGET} new_model.cpp new_model_utils.cpp ${MODEL_UTILS_SOURCE})
 +target_compile_features(${TARGET} PUBLIC cxx_std_11) # don't bump
 +set_target_properties(${TARGET} PROPERTIES POSITION_INDEPENDENT_CODE ON)
-+target_link_libraries(${TARGET} PUBLIC ne_layers jblas::jblas)
++target_link_libraries(${TARGET} PUBLIC ne_layers bestla::bestla)
 ```
  and and new_model to [models_CMakeLists.txt](neural_speed/models/CMakeLists.txt).
  ```diff
@@ -408,7 +408,7 @@ index 894be0134d..a9a57c0a9e 100644
 
 # 3.	Performance optimization
 ## 3.1.	Quantize model and use Jblas library for better performance
-Quantize model and use the jblas library for inference can lead to better performance.
+Quantize model and use the bestla library for inference can lead to better performance.
 ```bash
 
 # convert the model directly use model path
diff --git a/docs/fused_attention.md b/docs/fused_attention.md
index 67b260aed..e3ac73f88 100644
--- a/docs/fused_attention.md
+++ b/docs/fused_attention.md
@@ -6,7 +6,7 @@ Attention (including MHA, GQA, MQA) is one of the key parts of transformers and
 Note that this doc assumes you have the basic knowledge of this cpp graph implementation including `ne_tensor::ne`, `ne_tensor::nb` etc. Model builder can enable fused attention with operators `ne_flash_attn*` defined in [`core/ne_layers.h`](core/ne_layers.h) while the implementation of fused attentions is mostly located in [`core/layers/mha_dense.cpp`](core/layers/mha_dense.cpp).
 
 ## KV-cache initialization
-The memory for kv-cache is allocated in `/models/model_utils/model_utils.cpp`. As the fused attention implementation requires certain instruction extensions and potentially some other limitations, fused attention is enabled only if `jblas_reordered_attn_fp32_support()` aggress, denoting with `memory_type = NE_TYPE_JBLAS`. Next, `get_batch_kv_elements_from_gpt_params()` will give the sizes (in terms of bytes if fused attention enabled, or in terms elements if fused attention disabled) of k-cache and v-cache respectively for each batch and each layer. The KV-cache is finally prepared with these 2 sizes by creating `ne_new_tensor` inside `model.kv_self.k/.v` or `model.layer[il].k_cache/.v_cache`.
+The memory for kv-cache is allocated in `/models/model_utils/model_utils.cpp`. As the fused attention implementation requires certain instruction extensions and potentially some other limitations, fused attention is enabled only if `bestla_reordered_attn_fp32_support()` aggress, denoting with `memory_type = NE_TYPE_BTLA`. Next, `get_batch_kv_elements_from_gpt_params()` will give the sizes (in terms of bytes if fused attention enabled, or in terms elements if fused attention disabled) of k-cache and v-cache respectively for each batch and each layer. The KV-cache is finally prepared with these 2 sizes by creating `ne_new_tensor` inside `model.kv_self.k/.v` or `model.layer[il].k_cache/.v_cache`.
 
 ## KV-cache Append
 KV-cache is appended every time a new pair of K and V are generated by evaluating inner product for QKV (ne_mul_qkv). This operation append an additional K/V-tensor on the dimension of sequence length (i.e. resulting `n_past = n_past + N`, where `n_past` is number of previously cached tokens and `N` is the length of current tokens).
diff --git a/neural_speed/__init__.py b/neural_speed/__init__.py
index c57805992..78a700e0e 100644
--- a/neural_speed/__init__.py
+++ b/neural_speed/__init__.py
@@ -89,7 +89,7 @@ def init(self, model_name, not_quant=False, use_cache=False,
         if use_ggml:
             quant_desc += "_ggml"
         else:
-            quant_desc += "_jblas_c" + compute_dtype
+            quant_desc += "_bestla_c" + compute_dtype
             if group_size == -1:
                 quant_desc += "_pc"
             else:
diff --git a/neural_speed/application/CMakeLists.txt b/neural_speed/application/CMakeLists.txt
index 348720c77..552c9eaa4 100644
--- a/neural_speed/application/CMakeLists.txt
+++ b/neural_speed/application/CMakeLists.txt
@@ -24,7 +24,7 @@ set_target_properties(${TARGET} PROPERTIES POSITION_INDEPENDENT_CODE ON)
 
 target_include_directories(${TARGET} PUBLIC .)
 target_compile_features(${TARGET} PUBLIC cxx_std_11)
-target_link_libraries(${TARGET} PUBLIC jblas::jblas)
+target_link_libraries(${TARGET} PUBLIC bestla::bestla)
 
 include_directories(${CMAKE_CURRENT_SOURCE_DIR})
 
diff --git a/neural_speed/application/common.cpp b/neural_speed/application/common.cpp
index b9dab596a..fe8b81eec 100644
--- a/neural_speed/application/common.cpp
+++ b/neural_speed/application/common.cpp
@@ -730,7 +730,7 @@ ne_ftype quant_params_to_ftype(const quant_params& params) {
       return NE_FTYPE_MOSTLY_Q8_0;
     }
   } else {
-    return NE_FTYPE_MOSTLY_Q_JBLAS;
+    return NE_FTYPE_MOSTLY_Q_BTLA;
   }
   return NE_FTYPE_UNKNOWN;
 }
@@ -753,7 +753,7 @@ ne_type quant_params_to_type(const quant_params& params) {
       return NE_TYPE_Q8_0;
     }
   } else {
-    return NE_TYPE_JBLAS;
+    return NE_TYPE_BTLA;
   }
   return NE_TYPE_F32;
 }
diff --git a/neural_speed/application/main_pybind.cpp b/neural_speed/application/main_pybind.cpp
index 7e7f9bf81..83a4961b2 100644
--- a/neural_speed/application/main_pybind.cpp
+++ b/neural_speed/application/main_pybind.cpp
@@ -34,9 +34,9 @@
 #include <vector>
 
 #include "common.h"
-#include "core/layers/jblas_common.hpp"
-#include "core/layers/jblas_gemm.h"
-#include "jblas/jit_blas_parallel.h"
+#include "core/layers/bestla_common.hpp"
+#include "core/layers/bestla_gemm.h"
+#include "bestla/jit_blas_parallel.h"
 #include "models/model_utils/model_types.h"
 #include "models/model_utils/model_config.h"
 #include "models/model_utils/model_utils.h"
@@ -91,10 +91,10 @@ class Model {
     generate_count = 0;
   }
 
-  static size_t np_jblas_qpack(py::array_t<int8_t> src_w, py::array_t<float> src_scales, py::array_t<int8_t> src_zeros,
-                               py::array_t<int32_t> g_idx, py::array_t<int8_t> dst, const std::string& weight_dtype,
-                               const std::string& alg, int group_size, const std::string& scale_dtype,
-                               const std::string& compute_dtype, int threads) {
+  static size_t np_bestla_qpack(py::array_t<int8_t> src_w, py::array_t<float> src_scales, py::array_t<int8_t> src_zeros,
+                                py::array_t<int32_t> g_idx, py::array_t<int8_t> dst, const std::string& weight_dtype,
+                                const std::string& alg, int group_size, const std::string& scale_dtype,
+                                const std::string& compute_dtype, int threads) {
     int8_t* w_ptr = src_w.mutable_data();
     float* scales_ptr = src_scales.mutable_data();
     int8_t* zeros_ptr = nullptr;
@@ -113,20 +113,20 @@ class Model {
     q_params.compute_dtype = parse_compute_type(compute_dtype, /*ggml_arg=*/0);
     q_params.alg = parse_alg(alg);
     q_params.group_size = group_size;
-    return jblas_qpack(w_ptr, scales_ptr, zeros_ptr, dst_ptr, q_params, threads, src_w.shape(1), src_w.shape(0),
-                       g_idx_ptr);
+    return bestla_qpack(w_ptr, scales_ptr, zeros_ptr, dst_ptr, q_params, threads, src_w.shape(1), src_w.shape(0),
+                        g_idx_ptr);
   }
 
-  static size_t np_jblas_quantize(py::array_t<float> src_w, py::array_t<int8_t> dst, const std::string& weight_dtype,
-                                  const std::string& alg, int group_size, const std::string& scale_dtype,
-                                  const std::string& compute_dtype, int threads) {
+  static size_t np_bestla_quantize(py::array_t<float> src_w, py::array_t<int8_t> dst, const std::string& weight_dtype,
+                                   const std::string& alg, int group_size, const std::string& scale_dtype,
+                                   const std::string& compute_dtype, int threads) {
     quant_params_internal q_params;
     q_params.bits = parse_bits(weight_dtype);
     q_params.scale_dtype = parse_scale_dtype(scale_dtype);
     q_params.compute_dtype = parse_compute_type(compute_dtype, /*ggml_arg=*/0);
     q_params.alg = parse_alg(alg);
     q_params.group_size = group_size;
-    return jblas_quantize(src_w.mutable_data(), dst.mutable_data(), q_params, threads, src_w.shape(0), src_w.shape(1));
+    return bestla_quantize(src_w.mutable_data(), dst.mutable_data(), q_params, threads, src_w.shape(0), src_w.shape(1));
   }
 
  private:
@@ -681,12 +681,13 @@ PYBIND11_MODULE(qwen_cpp, m)
                   py::arg("threads") = 8)
       .def("is_token_end", &Model::is_token_end)
       .def("reset_token_end", &Model::reset_token_end)
-      .def_static("np_jblas_qpack", &Model::np_jblas_qpack, "QPack tensor to jblas format", py::arg("src_w"),
+      .def_static("np_bestla_qpack", &Model::np_bestla_qpack, "QPack tensor to bestla format", py::arg("src_w"),
                   py::arg("src_scales"), py::arg("src_zeros"), py::arg("g_idx"), py::arg("dst"),
                   py::arg("weight_dtype") = "int4", py::arg("alg") = "sym", py::arg("group_size") = 32,
                   py::arg("scale_dtype") = "fp32", py::arg("compute_dtype") = "int8", py::arg("threads") = 8)
-      .def_static("np_jblas_quantize", &Model::np_jblas_quantize, "Quantize tensor to jblas format", py::arg("src_w"),
-                  py::arg("dst"), py::arg("weight_dtype") = "int4", py::arg("alg") = "sym", py::arg("group_size") = 32,
-                  py::arg("scale_dtype") = "fp32", py::arg("compute_dtype") = "int8", py::arg("threads") = 8)
+      .def_static("np_bestla_quantize", &Model::np_bestla_quantize, "Quantize tensor to bestla format",
+                  py::arg("src_w"), py::arg("dst"), py::arg("weight_dtype") = "int4", py::arg("alg") = "sym",
+                  py::arg("group_size") = 32, py::arg("scale_dtype") = "fp32", py::arg("compute_dtype") = "int8",
+                  py::arg("threads") = 8)
       .def("reinit", &Model::reinit);
 }
diff --git a/neural_speed/application/main_run.cpp b/neural_speed/application/main_run.cpp
index 2d7c12a5a..6c1a09d2a 100644
--- a/neural_speed/application/main_run.cpp
+++ b/neural_speed/application/main_run.cpp
@@ -405,6 +405,43 @@ int main(int argc, char** argv) {  // NOLINT
   const bool penalize_nl = params.penalize_nl;
   model_token id = 0;
 
+  if (params.warmup) {
+    {
+      const std::vector<model_token> tmp(32, ctx->vocab.bos_token_id);
+      std::vector<model_input> inputs = {model_input{
+          /*.tokens              =*/tmp.data(),
+          /*.n_tokens           =*/(uint32_t)tmp.size(),
+          /*.n_prompt_tokens    =*/0,
+          /*.n_past             =*/0,
+          /*.n_total            =*/0,
+          /*.request_idx        =*/0,
+          /*.beam_idx           =*/0,
+          /*.padding_side       =*/0,
+          /*n_padding           =*/0,
+      }};
+      model_eval(ctx, inputs.data(), inputs.size(), params.n_threads);
+    }
+
+    {
+      const std::vector<model_token> tmp = {
+          0,
+      };
+      std::vector<model_input> inputs = {model_input{
+          /*.tokens              =*/tmp.data(),
+          /*.n_tokens           =*/(uint32_t)tmp.size(),
+          /*.n_prompt_tokens    =*/0,
+          /*.n_past             =*/(uint32_t)(params.n_predict - 1),
+          /*.n_total            =*/(uint32_t)(params.n_predict - 1),
+          /*.request_idx        =*/0,
+          /*.beam_idx           =*/0,
+          /*.padding_side       =*/0,
+          /*n_padding           =*/0,
+      }};
+      model_eval(ctx, inputs.data(), inputs.size(), params.n_threads);
+    }
+    model_reset_timings(ctx);
+  }
+
   while ((n_remain != 0 && !is_antiprompt) || params.interactive) {
     // predict
     if (embd.size() > 0) {
diff --git a/neural_speed/cmake/Common.cmake b/neural_speed/cmake/Common.cmake
index d3e266ce6..31266cd31 100644
--- a/neural_speed/cmake/Common.cmake
+++ b/neural_speed/cmake/Common.cmake
@@ -31,6 +31,7 @@ endfunction()
 
 function(add_executable_w_warning TARGET)
     add_executable(${TARGET} ${ARGN})
+    target_link_libraries(${TARGET} PUBLIC bestla::bestla OpenMP::OpenMP_CXX OpenMP::OpenMP_C)
     set_target_properties(${TARGET} PROPERTIES C_STANDARD 11 C_STANDARD_REQUIRED ON C_EXTENSIONS OFF)
     set_target_properties(${TARGET} PROPERTIES CXX_STANDARD 11 CXX_STANDARD_REQUIRED ON CXX_EXTENSIONS OFF)
     warning_check(${TARGET})
@@ -38,6 +39,7 @@ endfunction()
 
 function(add_library_w_warning_ TARGET)
     add_library(${TARGET} ${ARGN})
+    target_link_libraries(${TARGET} PUBLIC bestla::bestla OpenMP::OpenMP_CXX OpenMP::OpenMP_C)
     set_target_properties(${TARGET} PROPERTIES C_STANDARD 11 C_STANDARD_REQUIRED ON C_EXTENSIONS OFF)
     set_target_properties(${TARGET} PROPERTIES CXX_STANDARD 11 CXX_STANDARD_REQUIRED ON CXX_EXTENSIONS OFF)
     warning_check(${TARGET})
diff --git a/neural_speed/convert/common.py b/neural_speed/convert/common.py
index 13ce0db0e..9574f91a5 100644
--- a/neural_speed/convert/common.py
+++ b/neural_speed/convert/common.py
@@ -326,7 +326,7 @@ def convert_q4_f32_tensor(src_name, dst_name, model, fout, q_config, n_head, n_h
     print(f"converting {dst_name} qauntized tensor to fp32 tensor")
 
 
-def convert_q4_jblas_tensor(src_name, dst_name, model, fout, q_config, n_head, n_head_kv=0, permute_func=None):
+def convert_q4_bestla_tensor(src_name, dst_name, model, fout, q_config, n_head, n_head_kv=0, permute_func=None):
     import intel_extension_for_transformers.llm.runtime.graph.llama_cpp as cpp_model
     qzeros = model[f"{src_name}.qzeros"]
     zeros = qzeros_to_zeros(qzeros)
@@ -376,10 +376,10 @@ def convert_q4_jblas_tensor(src_name, dst_name, model, fout, q_config, n_head, n
     else:
         g_idx = np.empty(0, dtype=np.int32)
 
-    byte_size = cpp_model.Model.np_jblas_qpack(int_weight, gptq_scales, gptq_zeros, g_idx, dst,
+    byte_size = cpp_model.Model.np_bestla_qpack(int_weight, gptq_scales, gptq_zeros, g_idx, dst,
                                                weight_dtype="int4" if q_config['bits'] == 4 else "int8",
                                                group_size=q_config['group_size'],
                                                alg="sym" if q_config['sym'] else "asym",
                                                compute_dtype="int8")
     dst.flatten()[:byte_size].tofile(fout)
-    print(f"converting {dst_name} qauntized tensor to jblas q4 block")
+    print(f"converting {dst_name} qauntized tensor to bestla q4 block")
diff --git a/neural_speed/convert/convert_gptq_bloom.py b/neural_speed/convert/convert_gptq_bloom.py
index 08f26b243..c0e88a2d7 100644
--- a/neural_speed/convert/convert_gptq_bloom.py
+++ b/neural_speed/convert/convert_gptq_bloom.py
@@ -196,7 +196,7 @@ def bytes_to_unicode():
 
     ftype_cur = 0
     if ".weight" in name and list_vars[name].dim() == 2:
-        ftype_cur = 2  # TODO(Zhenwei) support jblas
+        ftype_cur = 2  # TODO(Zhenwei) support bestla
 
     data = list_vars[src].squeeze().numpy()
     data = data.astype(np.float32)
@@ -213,7 +213,7 @@ def bytes_to_unicode():
         # to quantize
         k = name.replace(".weight", "")
         if k in weight_config and weight_config[k]["dtype"] != "fp32":
-            print(f"jblas {k}")
+            print(f"bestla {k}")
             int_weight, gptq_scale, gptq_zp = extract_gptq(new_model, k, weight_config[k])
 
             tensor = int_weight.view(-1, 32) + 8
diff --git a/neural_speed/convert/convert_gptq_llama.py b/neural_speed/convert/convert_gptq_llama.py
index cb3f64697..7583f2d9c 100644
--- a/neural_speed/convert/convert_gptq_llama.py
+++ b/neural_speed/convert/convert_gptq_llama.py
@@ -104,21 +104,21 @@ def main(args_in: Optional[List[str]] = None) -> None:
     convert_fp32_tensor("lm_head.weight", "output.weight", list_vars, f)
 
     for i in range(n_layer):
-        convert_q4_jblas_tensor(f"model.layers.{i}.self_attn.q_proj",
+        convert_q4_bestla_tensor(f"model.layers.{i}.self_attn.q_proj",
                     f"layers.{i}.attention.wq.weight", list_vars, f, quantize_config, n_head, n_head,
                     permute_func=permute_func)
-        convert_q4_jblas_tensor(f"model.layers.{i}.self_attn.k_proj",
+        convert_q4_bestla_tensor(f"model.layers.{i}.self_attn.k_proj",
                     f"layers.{i}.attention.wk.weight", list_vars, f, quantize_config, n_head, n_head_kv,
                     permute_func=permute_func)
-        convert_q4_jblas_tensor(f"model.layers.{i}.self_attn.v_proj",
+        convert_q4_bestla_tensor(f"model.layers.{i}.self_attn.v_proj",
                     f"layers.{i}.attention.wv.weight", list_vars, f, quantize_config, n_head)
-        convert_q4_jblas_tensor(f"model.layers.{i}.self_attn.o_proj",
+        convert_q4_bestla_tensor(f"model.layers.{i}.self_attn.o_proj",
                     f"layers.{i}.attention.wo.weight", list_vars, f, quantize_config, n_head)
-        convert_q4_jblas_tensor(f"model.layers.{i}.mlp.gate_proj",
+        convert_q4_bestla_tensor(f"model.layers.{i}.mlp.gate_proj",
                     f"layers.{i}.feed_forward.w1.weight", list_vars, f, quantize_config, n_head)
-        convert_q4_jblas_tensor(f"model.layers.{i}.mlp.down_proj",
+        convert_q4_bestla_tensor(f"model.layers.{i}.mlp.down_proj",
                     f"layers.{i}.feed_forward.w2.weight", list_vars, f, quantize_config, n_head)
-        convert_q4_jblas_tensor(f"model.layers.{i}.mlp.up_proj",
+        convert_q4_bestla_tensor(f"model.layers.{i}.mlp.up_proj",
                     f"layers.{i}.feed_forward.w3.weight", list_vars, f, quantize_config, n_head)
 
         convert_fp32_tensor(f"model.layers.{i}.input_layernorm.weight",
diff --git a/neural_speed/convert/convert_gptq_mistral.py b/neural_speed/convert/convert_gptq_mistral.py
index 9e48aaebc..f712053a0 100644
--- a/neural_speed/convert/convert_gptq_mistral.py
+++ b/neural_speed/convert/convert_gptq_mistral.py
@@ -107,21 +107,21 @@ def main(args_in: Optional[List[str]] = None) -> None:
     convert_fp32_tensor("lm_head.weight", "output.weight", list_vars, f)
 
     for i in range(n_layer):
-        convert_q4_jblas_tensor(f"model.layers.{i}.self_attn.q_proj",
+        convert_q4_bestla_tensor(f"model.layers.{i}.self_attn.q_proj",
                     f"layers.{i}.attention.wq.weight", list_vars, f, quantize_config, n_head, n_head,
                     permute_func=permute_func)
-        convert_q4_jblas_tensor(f"model.layers.{i}.self_attn.k_proj",
+        convert_q4_bestla_tensor(f"model.layers.{i}.self_attn.k_proj",
                     f"layers.{i}.attention.wk.weight", list_vars, f, quantize_config, n_head, n_head_kv,
                     permute_func=permute_func)
-        convert_q4_jblas_tensor(f"model.layers.{i}.self_attn.v_proj",
+        convert_q4_bestla_tensor(f"model.layers.{i}.self_attn.v_proj",
                     f"layers.{i}.attention.wv.weight", list_vars, f, quantize_config, n_head)
-        convert_q4_jblas_tensor(f"model.layers.{i}.self_attn.o_proj",
+        convert_q4_bestla_tensor(f"model.layers.{i}.self_attn.o_proj",
                     f"layers.{i}.attention.wo.weight", list_vars, f, quantize_config, n_head)
-        convert_q4_jblas_tensor(f"model.layers.{i}.mlp.gate_proj",
+        convert_q4_bestla_tensor(f"model.layers.{i}.mlp.gate_proj",
                     f"layers.{i}.feed_forward.w1.weight", list_vars, f, quantize_config, n_head)
-        convert_q4_jblas_tensor(f"model.layers.{i}.mlp.down_proj",
+        convert_q4_bestla_tensor(f"model.layers.{i}.mlp.down_proj",
                     f"layers.{i}.feed_forward.w2.weight", list_vars, f, quantize_config, n_head)
-        convert_q4_jblas_tensor(f"model.layers.{i}.mlp.up_proj",
+        convert_q4_bestla_tensor(f"model.layers.{i}.mlp.up_proj",
                     f"layers.{i}.feed_forward.w3.weight", list_vars, f, quantize_config, n_head)
 
         convert_fp32_tensor(f"model.layers.{i}.input_layernorm.weight",
diff --git a/neural_speed/core/CMakeLists.txt b/neural_speed/core/CMakeLists.txt
index bcf34a9ca..e823fc7b2 100644
--- a/neural_speed/core/CMakeLists.txt
+++ b/neural_speed/core/CMakeLists.txt
@@ -26,9 +26,9 @@ if (NE_TP)
   find_package(MPI REQUIRED)
   set(CMAKE_POSITION_INDEPENDENT_CODE ON)
   add_library(parallel_context STATIC parallel_context.cpp)
-  target_link_libraries(ne_layers PUBLIC Threads::Threads jblas::jblas ne_vec MPI::MPI_CXX ccl parallel_context)
+  target_link_libraries(ne_layers PUBLIC Threads::Threads bestla::bestla ne_vec MPI::MPI_CXX ccl parallel_context)
 else ()
-  target_link_libraries(ne_layers PUBLIC Threads::Threads jblas::jblas ne_vec)
+  target_link_libraries(ne_layers PUBLIC Threads::Threads bestla::bestla ne_vec)
 endif()
 
 if(NOT WIN32)
@@ -53,7 +53,7 @@ function(add_test_target src)
   target_compile_options(${test_target} PRIVATE -fsanitize=address)
   target_link_options(${test_target} PRIVATE -fsanitize=address)
   target_include_directories(${test_target} PUBLIC .)
-  target_link_libraries(${test_target} PUBLIC Threads::Threads jblas::jblas ne_vec)
+  target_link_libraries(${test_target} PUBLIC Threads::Threads bestla::bestla ne_vec)
   if(NOT WIN32)
     target_link_libraries(${test_target} PUBLIC rt)
   endif()
diff --git a/neural_speed/core/data_types.h b/neural_speed/core/data_types.h
index 2e6b544df..4df4786bb 100644
--- a/neural_speed/core/data_types.h
+++ b/neural_speed/core/data_types.h
@@ -43,7 +43,7 @@ enum ne_type {
   NE_TYPE_I8,
   NE_TYPE_I16,
   NE_TYPE_I32,
-  NE_TYPE_JBLAS,
+  NE_TYPE_BTLA,
   NE_TYPE_COUNT,
 };
 
@@ -66,7 +66,7 @@ enum ne_ftype {
   NE_FTYPE_MOSTLY_Q8_0 = 7,           // except 1d tensors
   NE_FTYPE_MOSTLY_Q5_0 = 8,           // except 1d tensors
   NE_FTYPE_MOSTLY_Q5_1 = 9,           // except 1d tensors
-  NE_FTYPE_MOSTLY_Q_JBLAS = 10,       // except 1d tensors
+  NE_FTYPE_MOSTLY_Q_BTLA = 10,        // except 1d tensors
 };
 
 #define QK4_0 32
diff --git a/neural_speed/core/layers/jblas_common.hpp b/neural_speed/core/layers/bestla_common.hpp
similarity index 70%
rename from neural_speed/core/layers/jblas_common.hpp
rename to neural_speed/core/layers/bestla_common.hpp
index 21955cd46..014df07f4 100644
--- a/neural_speed/core/layers/jblas_common.hpp
+++ b/neural_speed/core/layers/bestla_common.hpp
@@ -13,23 +13,23 @@
 //  limitations under the License.
 #pragma once
 #include <utility>
-#include "ne_jblas.h"
-#include "jblas/jit_blas_prologue_b.h"
-#include "jblas/jit_blas_device.h"
-#include "jblas/jit_blas_utils.h"
+#include "ne_bestla.h"
+#include "bestla/bestla_prologue_b.h"
+#include "bestla/bestla_device.h"
+#include "bestla/bestla_utils.h"
+#include "bestla/bestla_parallel.h"
 #include "layers/ele_wise.h"
-#include "jblas_defs.h"
-#include "jblas/jit_blas_parallel.h"
+#include "bestla_defs.h"
 
-namespace ne_jblas {
+namespace ne_bestla {
 
 class ne_threading {
  public:
-  static jblas::parallel::IThreading* get() {
+  static bestla::parallel::IThreading* get() {
 #ifdef _OPENMP
-    static jblas::parallel::OMPThreading DefaultThreading(4);
+    static bestla::parallel::OMPThreading DefaultThreading(4);
 #else
-    static jblas::parallel::StdThreading DefaultThreading(4);
+    static bestla::parallel::StdThreading DefaultThreading(4);
 #endif  // _OPNEMP
     return &DefaultThreading;
   }
@@ -58,30 +58,30 @@ static bool hasISA(const uint64_t* coreset, size_t len) {
   GetCPUDevice();
   bool support = false;
   for (size_t i = 0; i < len; i++) {
-    auto isa = jblas::gemm::CoreAttr::get_ISA(coreset[i]);
+    auto isa = bestla::gemm::CoreAttr::get_ISA(coreset[i]);
     switch (isa) {
-      case JblasAVX:
+      case BTLA_ISA::AVX:
         support |= _cd->AVX();
         break;
-      case JblasAVX2:
+      case BTLA_ISA::AVX2:
         support |= _cd->AVX2();
         break;
-      case JblasAMX_BF16:
+      case BTLA_ISA::AMX_BF16:
         support |= _cd->AMX_BF16();
         break;
-      case JblasAMX_INT8:
+      case BTLA_ISA::AMX_INT8:
         support |= _cd->AMX_INT8();
         break;
-      case JblasAVX512F:
+      case BTLA_ISA::AVX512F:
         support |= _cd->AVX512F();
         break;
-      case JblasAVX512_VNNI:
+      case BTLA_ISA::AVX512_VNNI:
         support |= _cd->AVX512_VNNI();
         break;
-      case JblasAVX512_FP16:
+      case BTLA_ISA::AVX512_FP16:
         support |= _cd->AVX512_FP16();
         break;
-      case JblasAVX_VNNI:
+      case BTLA_ISA::AVX_VNNI:
         support |= _cd->AVX_VNNI();
         break;
       default:
@@ -94,11 +94,12 @@ static bool hasISA(const uint64_t* coreset, size_t len) {
   return support;
 }
 
-static inline bool samePackedWeight(jblas::storage::gemm::IWeightBase* ptr0, jblas::storage::gemm::IWeightBase* ptr1) {
+static inline bool samePackedWeight(bestla::storage::gemm::IWeightBase* ptr0,
+                                    bestla::storage::gemm::IWeightBase* ptr1) {
   return ptr0->mCoreId == ptr1->mCoreId && ptr0->mPrologueID == ptr1->mPrologueID;
 }
 
-static inline bool samePackedWeight(jblas::storage::gemm::IWeightBase** ptrs, size_t len) {
+static inline bool samePackedWeight(bestla::storage::gemm::IWeightBase** ptrs, size_t len) {
   bool sameKernel = samePackedWeight(ptrs[0], ptrs[1]);
   if (sameKernel) {
     for (size_t i = 2; i < len; i++) {
@@ -115,13 +116,13 @@ struct ParamAdd {
   _T *C, *D;
   int ldc, ldd;
 };
-template <JBLAS_ISA ISA_T, typename _T>
+template <BTLA_ISA ISA_T, typename _T>
 class Add {
  public:
   using Param = ParamAdd<_T>;
 
-  JBLAS_CODE forward(const float* cacheptr, const int cachestep, const int M_offset, const int N_offset, const int M,
-                     const int N, const Param& _param, void* tmpcache, size_t cachesize) {
+  BTLA_CODE forward(const float* cacheptr, const int cachestep, const int M_offset, const int N_offset, const int M,
+                    const int N, const Param& _param, void* tmpcache, size_t cachesize) {
     auto COffset = M_offset * _param.ldc + N_offset;
     auto DOffset = M_offset * _param.ldd + N_offset;
     auto cptr = _param.C + COffset;
@@ -134,10 +135,10 @@ class Add {
         cptr[i * _param.ldc + j] = dptr[i * _param.ldd + j] + cacheptr[i * cachestep + j];
       }
     }
-    return JblasSuccess;
+    return BTLA_CODE::Success;
   }
 };
-template <JBLAS_ISA ISA_T>
+template <BTLA_ISA ISA_T>
 using AddFp32 = Add<ISA_T, float>;
 
 template <typename _T>
@@ -145,12 +146,12 @@ struct ParamMul {
   _T *C, *D;
   int ldc, ldd;
 };
-template <JBLAS_ISA ISA_T, typename _T>
+template <BTLA_ISA ISA_T, typename _T>
 class Mul {
  public:
   using Param = ParamMul<_T>;
-  JBLAS_CODE forward(const float* cacheptr, const int cachestep, const int M_offset, const int N_offset, const int M,
-                     const int N, const Param& _param, void* tmpcache, size_t cachesize) {
+  BTLA_CODE forward(const float* cacheptr, const int cachestep, const int M_offset, const int N_offset, const int M,
+                    const int N, const Param& _param, void* tmpcache, size_t cachesize) {
     auto COffset = M_offset * _param.ldc + N_offset;
     auto DOffset = M_offset * _param.ldd + N_offset;
     auto cptr = _param.C + COffset;
@@ -160,10 +161,10 @@ class Mul {
         cptr[i * _param.ldc + j] = dptr[i * _param.ldd + j] * cacheptr[i * cachestep + j];
       }
     }
-    return JblasSuccess;
+    return BTLA_CODE::Success;
   }
 };
-template <JBLAS_ISA ISA_T>
+template <BTLA_ISA ISA_T>
 using MulFp32 = Mul<ISA_T, float>;
 
 template <typename _T>
@@ -171,11 +172,11 @@ struct ParamAdd_Gelu {
   _T *C, *D;
   int ldc, ldd;
 };
-template <JBLAS_ISA ISA_T, typename _T>
+template <BTLA_ISA ISA_T, typename _T>
 class Add_Gelu {
  public:
   using Param = ParamAdd_Gelu<_T>;
-  JBLAS_CODE forward(  // NOLINT [build/include_what_you_use]
+  BTLA_CODE forward(  // NOLINT [build/include_what_you_use]
       const float* cacheptr, const int cachestep, const int M_offset, const int N_offset, const int M, const int N,
       const Param& _param, void* tmpcache, size_t cachesize) {
     auto COffset = M_offset * _param.ldc + N_offset;
@@ -184,18 +185,17 @@ class Add_Gelu {
     auto dptr = _param.D + DOffset;
     for (int i = 0; i < M; i++) {
       ne_vec_add_f32(N, cptr + i * _param.ldc, dptr + i * _param.ldd, cacheptr + i * cachestep);
-      // ne_vec_gelu_f32(N, cptr + i * _param.ldc, cptr + i * _param.ldc);
     }
-    using GeluKernel = jblas::epilogue::gemm::AccumulatorWriteBackWithGeluFp32<ISA_T>;
+    using GeluKernel = bestla::epilogue::gemm::AccumulatorWriteBackWithGeluFp32<ISA_T>;
     static GeluKernel ker;
     typename GeluKernel::Param param{_param.C, _param.ldc, NULL};
     auto ret = ker.forward(cptr, _param.ldc, M_offset, N_offset, M, N, param, tmpcache, cachesize);
     return ret;
   }
 };
-template <JBLAS_ISA ISA_T>
+template <BTLA_ISA ISA_T>
 using Add_GeluFp32 = Add_Gelu<ISA_T, float>;
 
 }  // namespace epilogue
 }  // namespace custom
-}  // namespace ne_jblas
+}  // namespace ne_bestla
diff --git a/neural_speed/core/layers/bestla_defs.h b/neural_speed/core/layers/bestla_defs.h
new file mode 100644
index 000000000..4cdfb8f9f
--- /dev/null
+++ b/neural_speed/core/layers/bestla_defs.h
@@ -0,0 +1,67 @@
+//  Copyright (c) 2023 Intel Corporation
+//
+//  Licensed under the Apache License, Version 2.0 (the "License");
+//  you may not use this file except in compliance with the License.
+//  You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+//  Unless required by applicable law or agreed to in writing, software
+//  distributed under the License is distributed on an "AS IS" BASIS,
+//  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.
+
+#pragma once
+#include "bestla/bestla_prologue_b.h"
+#include "bestla/bestla_wrapper.h"
+
+namespace bestla {
+template <class GemmCore_T, template <class, BTLA_ISA> class Wei_T>
+using tLauncher_Fp_F32F32 =
+    wrapper::gemm::LauncherKBlock<GemmCore_T::ISA, GemmCore_T, prologue_a::gemm::ShuffleActivationKBlockBaseF32, Wei_T,
+                                  epilogue::gemm::CompFp32BlockEpilogue, epilogue::gemm::AccumulatorWriteBackFp32>;
+
+template <class GemmCore_T, template <class, BTLA_ISA> class Wei_T>
+using tLauncher_Int8_F32F32 =
+    wrapper::gemm::LauncherIntKBlock<GemmCore_T::ISA, GemmCore_T, prologue_a::gemm::ShuffleActivationKBlockQuantizeF32,
+                                     Wei_T, epilogue::gemm::AccumulatorWriteBackFp32>;
+
+using tAVX2 = gemm::SCoreRowNAvx2<24, 4>;
+using tAVX_VNNI = gemm::ICoreRowNAvxvnni<24, 4>;
+using tAVX512F = gemm::SCoreRowNAvx512f<48, 8>;
+using tAVX512_VNNI = gemm::ICoreRowNAvx512vnni<48, 8>;
+using tAMX_BF16 = gemm::HCoreRowNAmxbf16<48, 16>;
+using tAVX512_BF16 = gemm::HCoreRowNAvx512bf16<48, 8>;
+using tAVX512_FP16 = gemm::HCoreRowNAvx512fp16<96, 8>;
+using tAMX_INT8_US = gemm::ICoreRowNAmxint8<48, 16>;
+using tAMX_INT8_SS = gemm::ICoreRowNAmxint8SS<48, 16>;
+
+using tAVX_VNNI_KBlock = gemm::ICoreRowNAvxvnniKBlock<24, 2>;
+using tAVX512_VNNI_KBlock = gemm::ICoreRowNAvx512vnniKBlock<48, 4>;
+using tAMX_INT8_US_KBlock = gemm::ICoreRowNAmxint8KBlock<48, 16>;
+using tAMX_INT8_SS_KBlock = gemm::ICoreRowNAmxint8SSKBlock<48, 16>;
+
+template <class GC_T, BTLA_ISA ISA_T>
+using tWeiNInt = prologue_b::gemm::WeightKBlockNInteger<GC_T, ISA_T>;
+template <class GC_T, BTLA_ISA ISA_T>
+using tWeiNFloat = prologue_b::gemm::WeightKBlockNFloat<GC_T, ISA_T>;
+
+template <class GC_T, BTLA_ISA ISA_T>
+using tActKBaseF32 = prologue_a::gemm::ShuffleActivationKBlockBaseF32<GC_T, ISA_T>;
+
+constexpr uint64_t Fp32Cores[] = {tAVX2::ID, tAVX512F::ID};
+constexpr uint64_t Bf16Cores[] = {tAMX_BF16::ID};
+constexpr uint64_t Fp16Cores[] = {tAVX512_FP16::ID};
+constexpr uint64_t Int8Cores[] = {tAVX_VNNI::ID, tAVX512F::ID, tAVX512_VNNI::ID, tAMX_INT8_US::ID, tAMX_INT8_SS::ID};
+constexpr uint64_t FloatCores[] = {tAVX2::ID, tAVX512F::ID, tAMX_BF16::ID, tAVX512_FP16::ID};
+constexpr uint64_t AllKBlockCores[] = {tAVX2::ID,
+                                       tAVX512F::ID,
+                                       tAMX_BF16::ID,
+                                       tAVX512_FP16::ID,
+                                       tAVX_VNNI_KBlock::ID,
+                                       tAVX512_VNNI_KBlock::ID,
+                                       tAMX_INT8_US_KBlock::ID,
+                                       tAMX_INT8_SS_KBlock::ID};
+
+}  // namespace bestla
diff --git a/neural_speed/core/layers/bestla_gemm.cpp b/neural_speed/core/layers/bestla_gemm.cpp
new file mode 100644
index 000000000..1184e2be9
--- /dev/null
+++ b/neural_speed/core/layers/bestla_gemm.cpp
@@ -0,0 +1,687 @@
+//  Copyright (c) 2023 Intel Corporation
+//
+//  Licensed under the Apache License, Version 2.0 (the "License");
+//  you may not use this file except in compliance with the License.
+//  You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+//  Unless required by applicable law or agreed to in writing, software
+//  distributed under the License is distributed on an "AS IS" BASIS,
+//  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.
+
+/*++
+
+Module Name:
+
+    bestla_gemm.cpp
+
+Abstract:
+
+    C APIs of BesTLA GEMMs.
+--*/
+
+#include "bestla_gemm.h"
+#include <cstdint>
+
+#include "bestla_defs.h"
+
+using namespace bestla;  // NOLINT
+
+namespace {
+template <class GemmCore_T, template <class, BTLA_ISA> class Wei_T>
+void BTLAGemmCompF32(const int M, const int N, const int K, const float* A, const int lda,
+                     storage::gemm::IWeightBase* _B, float* C, const int ldc, int8_t* WorkSpace,
+                     parallel::IThreading* th) {
+  if (M <= 16) {
+    using Parallel = parallel::gemm::SchedulerKBlock<GemmCore_T>;
+    using Launcher = tLauncher_Fp_F32F32<GemmCore_T, Wei_T>;
+    static Launcher kernel;
+    auto B = reinterpret_cast<typename Launcher::PrologueB::StorageWeight*>(_B);
+    utils::GemmProblem gp(1, M, N, K, B->mBlockSize);
+    auto reduceA = kernel.mProA.createReduceStorage(M, K, B->mBlockSize);
+    if (B->IsAsym()) {
+      reduceA.assign(WorkSpace);
+      WorkSpace += reduceA.mSize;
+    }
+    auto reordA = kernel.mProA.createReorderStorage(M, K, B->mBlockSize);
+    if (B->ShfIndice()) {
+      reordA.assign(WorkSpace);
+    }
+    typename Launcher::BEpiParam blkargs{
+        B->template SPtr<int8_t>(),     B->SDtype(), B->CStep(), B->template ZPtr<int8_t>(),
+        reduceA.template RPtr<float>(), reduceA.lda};
+    typename Launcher::Param args{gp, {A, K, &reduceA, B->ShfIndice(), &reordA}, {B}, blkargs, {C, N}};
+    if (B->IsAsym() || B->ShfIndice()) {
+      parallel::GemmRunWithA<Parallel>(kernel, args, th);
+    } else {
+      parallel::GemmRun<Parallel>(kernel, args, th);
+    }
+  } else {
+    using Parallel = parallel::gemm::SchedulerBase<GemmCore_T>;
+    using Launcher =
+        wrapper::gemm::LauncherBase<GemmCore_T::ISA, GemmCore_T, prologue_a::gemm::ShuffleActivationKBlockBaseF32,
+                                    Wei_T, epilogue::gemm::AccumulatorWriteBackFp32>;
+    static Launcher kernel;
+    auto B = reinterpret_cast<typename Launcher::PrologueB::StorageWeight*>(_B);
+    utils::GemmProblem gp(1, M, N, K, B->mBlockSize);
+    auto reordA = kernel.mProA.createReorderStorage(M, K, B->mBlockSize);
+    typename Launcher::Param args{gp, {A, K, nullptr, B->ShfIndice(), &reordA}, {B}, {C, N}};
+    if (B->ShfIndice()) {
+      reordA.assign(WorkSpace);
+      parallel::GemmRunWithA<Parallel>(kernel, args, th);
+    } else {
+      parallel::GemmRun<Parallel>(kernel, args, th);
+    }
+  }
+}
+
+template <class GemmCore_T, template <class, BTLA_ISA> class Wei_T>
+void BTLAGemmCompInt8(const int M, const int N, const int K, const float* A, const int lda,
+                      storage::gemm::IWeightBase* _B, float* C, const int ldc, int8_t* WorkSpace,
+                      parallel::IThreading* th) {
+  using Parallel = parallel::gemm::SchedulerKBlockS<GemmCore_T>;
+  using Launcher = tLauncher_Int8_F32F32<GemmCore_T, Wei_T>;
+  auto B = reinterpret_cast<typename Launcher::PrologueB::StorageWeight*>(_B);
+  utils::GemmProblem gp(1, M, N, K, B->mBlockSize);
+  static Launcher kernel;
+  auto quanA = kernel.mProA.createQuantStorage(M, K, B->mBlockSize, B->IsAsym());
+  quanA.assign(WorkSpace);
+  WorkSpace += quanA.mSize;
+  auto reordA = kernel.mProA.createReorderStorage(M, K, B->mBlockSize);
+  typename Launcher::Param args{gp, {A, K, &quanA, B->ShfIndice(), &reordA}, {B}, {C, N}};
+  if (B->ShfIndice()) {
+    reordA.assign(WorkSpace);
+    kernel.mProA.quantize({A, K, &quanA, B->ShfIndice(), &reordA}, M, K, th);
+    parallel::GemmRun<Parallel>(kernel, args, th);
+  } else {
+    parallel::GemmRunWithA<Parallel>(kernel, args, th);
+  }
+}
+
+bool BTLAGemmBatchDriver(const size_t M, const size_t N, const size_t K, const size_t BatchN,
+                         const BTLA_GEMM_DATA_PACKED_PARAMS* DataParams, int8_t* WorkSpace, void* ThreadPool) {
+  GetCPUDevice();
+  auto pth = reinterpret_cast<parallel::IThreading*>(ThreadPool);
+  bool processed = true;
+  for (size_t i = 0; i < BatchN; i++) {
+    auto ptr = storage::gemm::PackedWeightParser::deserialBuffer(const_cast<void*>(DataParams[i].B));
+    if (ptr) {
+      auto coretype = ptr->mCoreId;
+      auto NTile = gemm::CoreAttr::get_mask_val(ptr->mCoreId, gemm::CoreAttr::NTILE_MASK, gemm::CoreAttr::NTILE_SHIFT);
+      auto PackRow = gemm::CoreAttr::get_packrow(ptr->mCoreId);
+      auto CType = gemm::CoreAttr::get_comp(ptr->mCoreId);
+      auto btype = static_cast<gemm::CompType>(gemm::CompTypeHelper::get_B(CType));
+      if (ptr->mPrologueID == BTLA_PROLOGUEB_IDS::WeightKBlockNInteger) {
+        auto bptr = reinterpret_cast<storage::gemm::IWeightKBlockBase*>(ptr);
+        auto BlkSize = bptr->mBlockSize;
+        if (btype == gemm::CompType::tFP32 && PackRow == 1) {
+          if (NTile == tAVX512F::NTILE && _cd->AVX512F() && BlkSize % tAVX512F::KTILE == 0) {
+            BTLAGemmCompF32<tAVX512F, tWeiNInt>(M, N, K, DataParams[i].A, DataParams[i].lda, ptr, DataParams[i].C,
+                                                DataParams[i].ldc, WorkSpace, pth);
+          } else if (NTile == tAVX2::NTILE && _cd->AVX2() && BlkSize % tAVX2::KTILE == 0) {
+            BTLAGemmCompF32<tAVX2, tWeiNInt>(M, N, K, DataParams[i].A, DataParams[i].lda, ptr, DataParams[i].C,
+                                             DataParams[i].ldc, WorkSpace, pth);
+          }
+        }
+        if (btype == gemm::CompType::tBF16 && PackRow == 2) {
+          if (NTile == tAMX_BF16::NTILE && _cd->AMX_BF16() && BlkSize % tAMX_BF16::KTILE == 0) {
+            if (M <= tAVX512_BF16::MTILE) {
+              static_assert(tAVX512_BF16::NTILE == tAMX_BF16::NTILE);
+              BTLAGemmCompF32<tAVX512_BF16, tWeiNInt>(M, N, K, DataParams[i].A, DataParams[i].lda, ptr, DataParams[i].C,
+                                                      DataParams[i].ldc, WorkSpace, pth);
+            } else {
+              BTLAGemmCompF32<tAMX_BF16, tWeiNInt>(M, N, K, DataParams[i].A, DataParams[i].lda, ptr, DataParams[i].C,
+                                                   DataParams[i].ldc, WorkSpace, pth);
+            }
+          }
+        }
+        if (btype == gemm::CompType::tS8 && PackRow == 4) {
+          // Do we need US for AMX_INT8
+          if (NTile == tAMX_INT8_SS_KBlock::NTILE && _cd->AMX_INT8() && BlkSize % tAMX_INT8_SS_KBlock::KTILE == 0) {
+            static_assert(tAMX_INT8_SS_KBlock::NTILE == tAVX512_VNNI_KBlock::NTILE);
+            if (M <= tAVX512_VNNI_KBlock::MTILE) {
+              BTLAGemmCompInt8<tAVX512_VNNI_KBlock, tWeiNInt>(M, N, K, DataParams[i].A, DataParams[i].lda, ptr,
+                                                              DataParams[i].C, DataParams[i].ldc, WorkSpace, pth);
+            } else {
+              BTLAGemmCompInt8<tAMX_INT8_SS_KBlock, tWeiNInt>(M, N, K, DataParams[i].A, DataParams[i].lda, ptr,
+                                                              DataParams[i].C, DataParams[i].ldc, WorkSpace, pth);
+            }
+
+          } else if (NTile == tAVX512_VNNI_KBlock::NTILE && _cd->AVX512_VNNI() &&
+                     BlkSize % tAVX512_VNNI_KBlock::KTILE == 0) {
+            BTLAGemmCompInt8<tAVX512_VNNI_KBlock, tWeiNInt>(M, N, K, DataParams[i].A, DataParams[i].lda, ptr,
+                                                            DataParams[i].C, DataParams[i].ldc, WorkSpace, pth);
+          } else if (NTile == tAVX_VNNI_KBlock::NTILE && _cd->AVX_VNNI() && BlkSize % tAVX_VNNI_KBlock::KTILE == 0) {
+            BTLAGemmCompInt8<tAVX_VNNI_KBlock, tWeiNInt>(M, N, K, DataParams[i].A, DataParams[i].lda, ptr,
+                                                         DataParams[i].C, DataParams[i].ldc, WorkSpace, pth);
+          }
+        }
+      }
+      if (ptr->mPrologueID == BTLA_PROLOGUEB_IDS::WeightKBlockNFloat) {
+        auto bptr = reinterpret_cast<storage::gemm::IWeightKBlockBase*>(ptr);
+        auto BlkSize = bptr->mBlockSize;
+        if (btype == gemm::CompType::tFP32 && PackRow == 1) {
+          if (NTile == tAVX512F::NTILE && _cd->AVX512F() && BlkSize % tAVX512F::KTILE == 0) {
+            BTLAGemmCompF32<tAVX512F, tWeiNFloat>(M, N, K, DataParams[i].A, DataParams[i].lda, ptr, DataParams[i].C,
+                                                  DataParams[i].ldc, WorkSpace, pth);
+          } else if (NTile == tAVX2::NTILE && _cd->AVX2() && BlkSize % tAVX2::KTILE == 0) {
+            BTLAGemmCompF32<tAVX2, tWeiNFloat>(M, N, K, DataParams[i].A, DataParams[i].lda, ptr, DataParams[i].C,
+                                               DataParams[i].ldc, WorkSpace, pth);
+          }
+        }
+        if (btype == gemm::CompType::tBF16 && PackRow == 2) {
+          if (NTile == tAMX_BF16::NTILE && _cd->AMX_BF16() && BlkSize % tAMX_BF16::KTILE == 0) {
+            if (M <= tAVX512_BF16::MTILE) {
+              static_assert(tAVX512_BF16::NTILE == tAMX_BF16::NTILE);
+              BTLAGemmCompF32<tAVX512_BF16, tWeiNFloat>(M, N, K, DataParams[i].A, DataParams[i].lda, ptr,
+                                                        DataParams[i].C, DataParams[i].ldc, WorkSpace, pth);
+            } else {
+              BTLAGemmCompF32<tAMX_BF16, tWeiNFloat>(M, N, K, DataParams[i].A, DataParams[i].lda, ptr, DataParams[i].C,
+                                                     DataParams[i].ldc, WorkSpace, pth);
+            }
+          }
+        }
+      }
+      delete ptr;
+    } else {
+      processed = false;
+      break;
+    }
+  }
+  return processed;
+}
+
+template <typename T>
+static size_t BTLABuSize(int block_size, size_t N, size_t K, BTLA_DTYPE QuantType, BTLA_DTYPE ScaleDtype, bool isAsym,
+                         int* shuffle_indice) {
+  static T launcher;
+  using WType = typename T::PrologueB::StorageWeight;
+  WType stor(0);
+  if constexpr (std::is_same_v<typename T::PrologueB,
+                               prologue_b::gemm::WeightKBlockNInteger<typename T::GemmCore, T::ISA>>) {
+    stor = launcher.mProB.createStorage(N, K, block_size, QuantType, ScaleDtype, BTLA_DTYPE::BF16, isAsym);
+    if (shuffle_indice != nullptr) {
+      launcher.mProB.enableShuffle(&stor);
+    }
+  } else {
+    stor = launcher.mProB.createStorage(N, K, block_size, QuantType, ScaleDtype);
+    (void)(shuffle_indice);
+  }
+
+  // Reduce dtype set to bf16
+  return stor.mSize;
+}
+template <template <class, BTLA_ISA> class Wei_T>
+static size_t BTLAGemmPackBSizeLocal(size_t N, size_t K, size_t BlkSize, BTLA_DTYPE QuantType, BTLA_DTYPE ScaleDtype,
+                                     bool isAsym, ne_comp_type CompType, int* shuffle_indice) {
+  GetCPUDevice();
+  auto dtype_type = utils::bestla_dtype_type(QuantType);
+  auto constexpr dtype_int = utils::bestla_dtype_type(BTLA_DTYPE::TypeInt);
+  // from low precision to high precision
+  switch (CompType) {
+    case NE_COMP_INT8:
+      if (dtype_type == dtype_int && !isAsym) {  // asym int8 is not optimized, so fall through to others.
+        if (_cd->AMX_INT8() && BlkSize % tAMX_INT8_SS_KBlock::KTILE == 0) {
+          return BTLABuSize<tLauncher_Int8_F32F32<tAMX_INT8_SS_KBlock, Wei_T>>(
+              static_cast<int>(BlkSize), N, K, QuantType, ScaleDtype, isAsym, shuffle_indice);
+        }
+        if (_cd->AVX512_VNNI() && BlkSize % tAVX512_VNNI_KBlock::KTILE == 0) {
+          return BTLABuSize<tLauncher_Int8_F32F32<tAVX512_VNNI_KBlock, Wei_T>>(
+              static_cast<int>(BlkSize), N, K, QuantType, ScaleDtype, isAsym, shuffle_indice);
+        }
+        if (_cd->AVX_VNNI() && BlkSize % tAVX_VNNI_KBlock::KTILE == 0) {
+          return BTLABuSize<tLauncher_Int8_F32F32<tAVX_VNNI_KBlock, Wei_T>>(static_cast<int>(BlkSize), N, K, QuantType,
+                                                                            ScaleDtype, isAsym, shuffle_indice);
+        }
+      }
+    case NE_COMP_F16:
+    case NE_COMP_BF16:
+      if (_cd->AMX_BF16() && BlkSize % tAMX_BF16::KTILE == 0) {
+        return BTLABuSize<tLauncher_Int8_F32F32<tAMX_BF16, Wei_T>>(static_cast<int>(BlkSize), N, K, QuantType,
+                                                                   ScaleDtype, isAsym, shuffle_indice);
+      }
+    case NE_COMP_F32:
+    case NE_COMP_UNDEF:  // currently only f32 activation
+      if (_cd->AVX512F() && BlkSize % tAVX512F::KTILE == 0) {
+        return BTLABuSize<tLauncher_Fp_F32F32<tAVX512F, Wei_T>>(static_cast<int>(BlkSize), N, K, QuantType, ScaleDtype,
+                                                                isAsym, shuffle_indice);
+      }
+      if (_cd->AVX2() && BlkSize % tAVX2::KTILE == 0) {
+        return BTLABuSize<tLauncher_Fp_F32F32<tAVX2, Wei_T>>(static_cast<int>(BlkSize), N, K, QuantType, ScaleDtype,
+                                                             isAsym, shuffle_indice);
+      }
+      break;
+    default:
+      return 0;
+  }
+  return 0;
+}
+
+size_t BTLAGemmPackBSize(size_t N, size_t K, size_t BlkSize, BTLA_DTYPE QuantType, BTLA_DTYPE ScaleDtype, bool isAsym,
+                         ne_comp_type CompType, int* shuffle_indice) {
+  switch (QuantType) {
+    case BTLA_DTYPE::S4_CLIP:
+    case BTLA_DTYPE::S4_FULLRANGE:
+    case BTLA_DTYPE::S8:
+      return BTLAGemmPackBSizeLocal<prologue_b::gemm::WeightKBlockNInteger>(N, K, BlkSize, QuantType, ScaleDtype,
+                                                                            isAsym, CompType, shuffle_indice);
+    case BTLA_DTYPE::F8_E4M3:
+    case BTLA_DTYPE::F8_E5M2:
+    case BTLA_DTYPE::F4_BNB:
+    case BTLA_DTYPE::F4_E2M1:
+    case BTLA_DTYPE::F4_NF4:
+      return BTLAGemmPackBSizeLocal<prologue_b::gemm::WeightKBlockNFloat>(N, K, BlkSize, QuantType, ScaleDtype, isAsym,
+                                                                          CompType, shuffle_indice);
+    default:
+      return 0;
+  }
+  return 0;
+}
+
+template <typename T>
+void BTLAGemmQuantPackB(void* PackedBuf, int BlkSize, const float* FpData, int N, int K, BTLA_DTYPE QuantType,
+                        BTLA_DTYPE ScaleDtype, bool IsAsym, int ldb, bool IsTrans, void* ThreadPool) {
+  static T launcher;
+  using WType = typename T::PrologueB::StorageWeight;
+  WType stor(0);
+  if constexpr (std::is_same_v<typename T::PrologueB,
+                               prologue_b::gemm::WeightKBlockNInteger<typename T::GemmCore, T::ISA>>) {
+    stor = launcher.mProB.createStorage(N, K, BlkSize, QuantType, ScaleDtype, BTLA_DTYPE::BF16, IsAsym);
+  } else {
+    stor = launcher.mProB.createStorage(N, K, BlkSize, QuantType, ScaleDtype);
+  }
+  stor.assign(reinterpret_cast<int8_t*>(PackedBuf));
+  auto pth = reinterpret_cast<parallel::IThreading*>(ThreadPool);
+  if (IsTrans) {
+    launcher.mProB.packTransposeWeight(N, K, FpData, ldb, &stor, pth);
+  } else {
+    launcher.mProB.packWeight(N, K, FpData, ldb, &stor, pth);
+  }
+}
+
+template <template <class, BTLA_ISA> class Wei_T>
+static bool BTLAGemmQuantPackBLocal(void* PackedBuf, const float* FpData, size_t N, size_t K, size_t ldb,
+                                    size_t BlkSize, BTLA_DTYPE QuantType, BTLA_DTYPE ScaleDtype, bool isAsym,
+                                    ne_comp_type CompType, bool isTrans, void* ThreadPool) {
+  GetCPUDevice();
+  auto dtype_type = utils::bestla_dtype_type(QuantType);
+  auto constexpr dtype_int = utils::bestla_dtype_type(BTLA_DTYPE::TypeInt);
+  switch (CompType) {
+    case NE_COMP_INT8:
+      if (dtype_type == dtype_int && !isAsym) {  // asym int8 is not optimized, so fall through to others.
+        if (_cd->AMX_INT8() && BlkSize % tAMX_INT8_SS_KBlock::KTILE == 0) {
+          BTLAGemmQuantPackB<tLauncher_Int8_F32F32<tAMX_INT8_SS_KBlock, Wei_T>>(
+              PackedBuf, static_cast<int>(BlkSize), FpData, static_cast<int>(N), static_cast<int>(K), QuantType,
+              ScaleDtype, isAsym, static_cast<int>(ldb), isTrans, ThreadPool);
+          return true;
+        }
+        if (_cd->AVX512_VNNI() && BlkSize % tAVX512_VNNI_KBlock::KTILE == 0) {
+          BTLAGemmQuantPackB<tLauncher_Int8_F32F32<tAVX512_VNNI_KBlock, Wei_T>>(
+              PackedBuf, static_cast<int>(BlkSize), FpData, static_cast<int>(N), static_cast<int>(K), QuantType,
+              ScaleDtype, isAsym, static_cast<int>(ldb), isTrans, ThreadPool);
+          return true;
+        }
+        if (_cd->AVX_VNNI() && BlkSize % tAVX_VNNI_KBlock::KTILE == 0) {
+          BTLAGemmQuantPackB<tLauncher_Int8_F32F32<tAVX_VNNI_KBlock, Wei_T>>(
+              PackedBuf, static_cast<int>(BlkSize), FpData, static_cast<int>(N), static_cast<int>(K), QuantType,
+              ScaleDtype, isAsym, static_cast<int>(ldb), isTrans, ThreadPool);
+          return true;
+        }
+      }
+    case NE_COMP_F16:
+    case NE_COMP_BF16:
+      if (_cd->AMX_BF16() && BlkSize % tAMX_BF16::KTILE == 0) {
+        BTLAGemmQuantPackB<tLauncher_Fp_F32F32<tAMX_BF16, Wei_T>>(
+            PackedBuf, static_cast<int>(BlkSize), FpData, static_cast<int>(N), static_cast<int>(K), QuantType,
+            ScaleDtype, isAsym, static_cast<int>(ldb), isTrans, ThreadPool);
+        return true;
+      }
+    case NE_COMP_F32:
+    case NE_COMP_UNDEF:  // currently only f32 activation
+      if (_cd->AVX512F() && BlkSize % tAVX512F::KTILE == 0) {
+        BTLAGemmQuantPackB<tLauncher_Fp_F32F32<tAVX512F, Wei_T>>(
+            PackedBuf, static_cast<int>(BlkSize), FpData, static_cast<int>(N), static_cast<int>(K), QuantType,
+            ScaleDtype, isAsym, static_cast<int>(ldb), isTrans, ThreadPool);
+        return true;
+      }
+      if (_cd->AVX2() && BlkSize % tAVX2::KTILE == 0) {
+        BTLAGemmQuantPackB<tLauncher_Fp_F32F32<tAVX2, Wei_T>>(
+            PackedBuf, static_cast<int>(BlkSize), FpData, static_cast<int>(N), static_cast<int>(K), QuantType,
+            ScaleDtype, isAsym, static_cast<int>(ldb), isTrans, ThreadPool);
+        return true;
+      }
+    default:
+      return false;
+  }
+  return false;
+}
+
+bool BTLAGemmQuantPackB(void* PackedBuf, const float* FpData, size_t N, size_t K, size_t ldb, size_t BlkSize,
+                        BTLA_DTYPE QuantType, BTLA_DTYPE ScaleDtype, bool isAsym, ne_comp_type CompType, bool isTrans,
+                        void* ThreadPool) {
+  switch (QuantType) {
+    case BTLA_DTYPE::S4_CLIP:
+    case BTLA_DTYPE::S4_FULLRANGE:
+    case BTLA_DTYPE::S8:
+      return BTLAGemmQuantPackBLocal<prologue_b::gemm::WeightKBlockNInteger>(
+          PackedBuf, FpData, N, K, ldb, BlkSize, QuantType, ScaleDtype, isAsym, CompType, isTrans, ThreadPool);
+    case BTLA_DTYPE::F8_E5M2:
+    case BTLA_DTYPE::F8_E4M3:
+    case BTLA_DTYPE::F4_BNB:
+    case BTLA_DTYPE::F4_E2M1:
+    case BTLA_DTYPE::F4_NF4:
+      return BTLAGemmQuantPackBLocal<prologue_b::gemm::WeightKBlockNFloat>(
+          PackedBuf, FpData, N, K, ldb, BlkSize, QuantType, ScaleDtype, isAsym, CompType, isTrans, ThreadPool);
+    default:
+      return false;
+  }
+  return false;
+}
+
+template <typename T>
+void BTLAGemmPackBImpl(void* PackedBuf, int BlkSize, const int8_t* QData, const float* Scales, const int8_t* Zp, int N,
+                       int K, BTLA_DTYPE QuantType, BTLA_DTYPE ScaleDtype, bool IsAsym, int ldb, int* shuffle_indice,
+                       void* ThreadPool) {
+  static T launcher;
+  using WType = typename T::PrologueB::StorageWeight;
+  auto pth = reinterpret_cast<parallel::IThreading*>(ThreadPool);
+  WType stor(0);
+  if constexpr (std::is_same_v<typename T::PrologueB,
+                               prologue_b::gemm::WeightKBlockNInteger<typename T::GemmCore, T::ISA>>) {
+    stor = launcher.mProB.createStorage(N, K, BlkSize, QuantType, ScaleDtype, BTLA_DTYPE::BF16, IsAsym);
+    if (shuffle_indice != nullptr) {
+      launcher.mProB.enableShuffle(&stor);
+      stor.assign(reinterpret_cast<int8_t*>(PackedBuf));
+      launcher.mProB.setShuffleIndices(shuffle_indice, &stor, pth);
+    } else {
+      stor.assign(reinterpret_cast<int8_t*>(PackedBuf));
+    }
+  } else {
+    (void)(shuffle_indice);
+    stor = launcher.mProB.createStorage(N, K, BlkSize, QuantType, ScaleDtype);
+    stor.assign(reinterpret_cast<int8_t*>(PackedBuf));
+  }
+  launcher.mProB.packQWeight(N, K, QData, ldb, Scales, IsAsym ? Zp : nullptr, &stor, pth);
+}
+
+template <template <class, BTLA_ISA> class Wei_T>
+static bool BTLAGemmPackBLocal(void* PackedBuf, const int8_t* QData, const float* Scales, const int8_t* Zp, size_t N,
+                               size_t K, size_t ldb, size_t BlkSize, BTLA_DTYPE QuantType, BTLA_DTYPE ScaleDtype,
+                               bool isAsym, ne_comp_type CompType, int* shuffle_indice, void* ThreadPool) {
+  GetCPUDevice();
+  auto dtype_type = utils::bestla_dtype_type(QuantType);
+  auto constexpr dtype_int = utils::bestla_dtype_type(BTLA_DTYPE::TypeInt);
+  if (dtype_type != dtype_int) {
+    return false;
+  }
+  switch (CompType) {
+    case NE_COMP_INT8:
+      if (dtype_type == dtype_int && !isAsym) {  // asym int8 is not optimized, so fall through to others.
+        if (_cd->AMX_INT8() && BlkSize % tAMX_INT8_SS_KBlock::KTILE == 0) {
+          BTLAGemmPackBImpl<tLauncher_Int8_F32F32<tAMX_INT8_SS_KBlock, Wei_T>>(
+              PackedBuf, static_cast<int>(BlkSize), QData, Scales, Zp, static_cast<int>(N), static_cast<int>(K),
+              QuantType, ScaleDtype, isAsym, static_cast<int>(ldb), shuffle_indice, ThreadPool);
+          return true;
+        }
+        if (_cd->AVX512_VNNI() && BlkSize % tAVX512_VNNI_KBlock::KTILE == 0) {
+          BTLAGemmPackBImpl<tLauncher_Int8_F32F32<tAVX512_VNNI_KBlock, Wei_T>>(
+              PackedBuf, static_cast<int>(BlkSize), QData, Scales, Zp, static_cast<int>(N), static_cast<int>(K),
+              QuantType, ScaleDtype, isAsym, static_cast<int>(ldb), shuffle_indice, ThreadPool);
+          return true;
+        }
+        if (_cd->AVX_VNNI() && BlkSize % tAVX_VNNI_KBlock::KTILE == 0) {
+          BTLAGemmPackBImpl<tLauncher_Int8_F32F32<tAVX_VNNI_KBlock, Wei_T>>(
+              PackedBuf, static_cast<int>(BlkSize), QData, Scales, Zp, static_cast<int>(N), static_cast<int>(K),
+              QuantType, ScaleDtype, isAsym, static_cast<int>(ldb), shuffle_indice, ThreadPool);
+          return true;
+        }
+      }
+    case NE_COMP_F16:
+    case NE_COMP_BF16:
+      if (_cd->AMX_BF16() && BlkSize % tAMX_BF16::KTILE == 0) {
+        BTLAGemmPackBImpl<tLauncher_Fp_F32F32<tAMX_BF16, Wei_T>>(
+            PackedBuf, static_cast<int>(BlkSize), QData, Scales, Zp, static_cast<int>(N), static_cast<int>(K),
+            QuantType, ScaleDtype, isAsym, static_cast<int>(ldb), shuffle_indice, ThreadPool);
+        return true;
+      }
+    case NE_COMP_F32:
+    case NE_COMP_UNDEF:  // currently only f32 activation
+      if (_cd->AVX512F() && BlkSize % tAVX512F::KTILE == 0) {
+        BTLAGemmPackBImpl<tLauncher_Fp_F32F32<tAVX512F, Wei_T>>(
+            PackedBuf, static_cast<int>(BlkSize), QData, Scales, Zp, static_cast<int>(N), static_cast<int>(K),
+            QuantType, ScaleDtype, isAsym, static_cast<int>(ldb), shuffle_indice, ThreadPool);
+        return true;
+      }
+      if (_cd->AVX2() && BlkSize % tAVX2::KTILE == 0) {
+        BTLAGemmPackBImpl<tLauncher_Fp_F32F32<tAVX2, Wei_T>>(
+            PackedBuf, static_cast<int>(BlkSize), QData, Scales, Zp, static_cast<int>(N), static_cast<int>(K),
+            QuantType, ScaleDtype, isAsym, static_cast<int>(ldb), shuffle_indice, ThreadPool);
+        return true;
+      }
+    default:
+      return false;
+  }
+  return false;
+}
+
+}  // namespace
+
+bool BTLAGemmBatchDriver(const size_t M, const size_t N, const size_t K, const size_t BatchN,
+                         const BTLA_GEMM_DATA_PACKED_PARAMS* DataParams, int8_t* WorkSpace, void* ThreadPool) {
+  GetCPUDevice();
+  auto pth = reinterpret_cast<bestla::parallel::IThreading*>(ThreadPool);
+  bool processed = true;
+  for (size_t i = 0; i < BatchN; i++) {
+    auto ptr = storage::gemm::PackedWeightParser::deserialBuffer(const_cast<void*>(DataParams[i].B));
+    if (ptr) {
+      auto coretype = ptr->mCoreId;
+      auto NTile = gemm::CoreAttr::get_mask_val(ptr->mCoreId, gemm::CoreAttr::NTILE_MASK, gemm::CoreAttr::NTILE_SHIFT);
+      auto PackRow = gemm::CoreAttr::get_packrow(ptr->mCoreId);
+      auto CType = gemm::CoreAttr::get_comp(ptr->mCoreId);
+      auto btype = static_cast<gemm::CompType>(gemm::CompTypeHelper::get_B(CType));
+      if (ptr->mPrologueID == BTLA_PROLOGUEB_IDS::WeightKBlockNInteger) {
+        auto bptr = reinterpret_cast<storage::gemm::IWeightKBlockBase*>(ptr);
+        auto BlkSize = bptr->mBlockSize;
+        if (btype == gemm::CompType::tFP32 && PackRow == 1) {
+          if (NTile == tAVX512F::NTILE && _cd->AVX512F() && BlkSize % tAVX512F::KTILE == 0) {
+            BTLAGemmCompF32<tAVX512F, tWeiNInt>(M, N, K, DataParams[i].A, DataParams[i].lda, ptr, DataParams[i].C,
+                                                DataParams[i].ldc, WorkSpace, pth);
+          } else if (NTile == tAVX2::NTILE && _cd->AVX2() && BlkSize % tAVX2::KTILE == 0) {
+            BTLAGemmCompF32<tAVX2, tWeiNInt>(M, N, K, DataParams[i].A, DataParams[i].lda, ptr, DataParams[i].C,
+                                             DataParams[i].ldc, WorkSpace, pth);
+          }
+        }
+        if (btype == gemm::CompType::tBF16 && PackRow == 2) {
+          if (NTile == tAMX_BF16::NTILE && _cd->AMX_BF16() && BlkSize % tAMX_BF16::KTILE == 0) {
+            if (M <= tAVX512_BF16::MTILE) {
+              static_assert(tAVX512_BF16::NTILE == tAMX_BF16::NTILE);
+              BTLAGemmCompF32<tAVX512_BF16, tWeiNInt>(M, N, K, DataParams[i].A, DataParams[i].lda, ptr, DataParams[i].C,
+                                                      DataParams[i].ldc, WorkSpace, pth);
+            } else {
+              BTLAGemmCompF32<tAMX_BF16, tWeiNInt>(M, N, K, DataParams[i].A, DataParams[i].lda, ptr, DataParams[i].C,
+                                                   DataParams[i].ldc, WorkSpace, pth);
+            }
+          }
+        }
+        if (btype == gemm::CompType::tS8 && PackRow == 4) {
+          // Do we need US for AMX_INT8
+          if (NTile == tAMX_INT8_SS_KBlock::NTILE && _cd->AMX_INT8() && BlkSize % tAMX_INT8_SS_KBlock::KTILE == 0) {
+            static_assert(tAMX_INT8_SS_KBlock::NTILE == tAVX512_VNNI_KBlock::NTILE);
+            if (M <= tAVX512_VNNI_KBlock::MTILE) {
+              BTLAGemmCompInt8<tAVX512_VNNI_KBlock, tWeiNInt>(M, N, K, DataParams[i].A, DataParams[i].lda, ptr,
+                                                              DataParams[i].C, DataParams[i].ldc, WorkSpace, pth);
+            } else {
+              BTLAGemmCompInt8<tAMX_INT8_SS_KBlock, tWeiNInt>(M, N, K, DataParams[i].A, DataParams[i].lda, ptr,
+                                                              DataParams[i].C, DataParams[i].ldc, WorkSpace, pth);
+            }
+
+          } else if (NTile == tAVX512_VNNI_KBlock::NTILE && _cd->AVX512_VNNI() &&
+                     BlkSize % tAVX512_VNNI_KBlock::KTILE == 0) {
+            BTLAGemmCompInt8<tAVX512_VNNI_KBlock, tWeiNInt>(M, N, K, DataParams[i].A, DataParams[i].lda, ptr,
+                                                            DataParams[i].C, DataParams[i].ldc, WorkSpace, pth);
+          } else if (NTile == tAVX_VNNI_KBlock::NTILE && _cd->AVX_VNNI() && BlkSize % tAVX_VNNI_KBlock::KTILE == 0) {
+            BTLAGemmCompInt8<tAVX_VNNI_KBlock, tWeiNInt>(M, N, K, DataParams[i].A, DataParams[i].lda, ptr,
+                                                         DataParams[i].C, DataParams[i].ldc, WorkSpace, pth);
+          }
+        }
+      }
+      if (ptr->mPrologueID == BTLA_PROLOGUEB_IDS::WeightKBlockNFloat) {
+        auto bptr = reinterpret_cast<storage::gemm::IWeightKBlockBase*>(ptr);
+        auto BlkSize = bptr->mBlockSize;
+        if (btype == gemm::CompType::tFP32 && PackRow == 1) {
+          if (NTile == tAVX512F::NTILE && _cd->AVX512F() && BlkSize % tAVX512F::KTILE == 0) {
+            BTLAGemmCompF32<tAVX512F, tWeiNFloat>(M, N, K, DataParams[i].A, DataParams[i].lda, ptr, DataParams[i].C,
+                                                  DataParams[i].ldc, WorkSpace, pth);
+          } else if (NTile == tAVX2::NTILE && _cd->AVX2() && BlkSize % tAVX2::KTILE == 0) {
+            BTLAGemmCompF32<tAVX2, tWeiNFloat>(M, N, K, DataParams[i].A, DataParams[i].lda, ptr, DataParams[i].C,
+                                               DataParams[i].ldc, WorkSpace, pth);
+          }
+        }
+        if (btype == gemm::CompType::tBF16 && PackRow == 2) {
+          if (NTile == tAMX_BF16::NTILE && _cd->AMX_BF16() && BlkSize % tAMX_BF16::KTILE == 0) {
+            if (M <= tAVX512_BF16::MTILE) {
+              static_assert(tAVX512_BF16::NTILE == tAMX_BF16::NTILE);
+              BTLAGemmCompF32<tAVX512_BF16, tWeiNFloat>(M, N, K, DataParams[i].A, DataParams[i].lda, ptr,
+                                                        DataParams[i].C, DataParams[i].ldc, WorkSpace, pth);
+            } else {
+              BTLAGemmCompF32<tAMX_BF16, tWeiNFloat>(M, N, K, DataParams[i].A, DataParams[i].lda, ptr, DataParams[i].C,
+                                                     DataParams[i].ldc, WorkSpace, pth);
+            }
+          }
+        }
+      }
+      delete ptr;
+    } else {
+      processed = false;
+      break;
+    }
+  }
+  return processed;
+}
+
+size_t BTLAGemmPackBSize(size_t N, size_t K, size_t BlkSize, BTLA_DTYPE QuantType, BTLA_DTYPE ScaleDtype, bool isAsym,
+                         ne_comp_type CompType, int* shuffle_indice) {
+  switch (QuantType) {
+    case BTLA_DTYPE::S4_CLIP:
+    case BTLA_DTYPE::S4_FULLRANGE:
+    case BTLA_DTYPE::S8:
+      return BTLAGemmPackBSizeLocal<prologue_b::gemm::WeightKBlockNInteger>(N, K, BlkSize, QuantType, ScaleDtype,
+                                                                            isAsym, CompType, shuffle_indice);
+    case BTLA_DTYPE::F8_E4M3:
+    case BTLA_DTYPE::F8_E5M2:
+    case BTLA_DTYPE::F4_BNB:
+    case BTLA_DTYPE::F4_E2M1:
+    case BTLA_DTYPE::F4_NF4:
+      return BTLAGemmPackBSizeLocal<prologue_b::gemm::WeightKBlockNFloat>(N, K, BlkSize, QuantType, ScaleDtype, isAsym,
+                                                                          CompType, shuffle_indice);
+
+    default:
+      return 0;
+  }
+  return 0;
+}
+
+bool BTLAGemmQuantPackB(void* PackedBuf, const float* FpData, size_t N, size_t K, size_t ldb, size_t BlkSize,
+                        BTLA_DTYPE QuantType, BTLA_DTYPE ScaleDtype, bool isAsym, ne_comp_type CompType, bool isTrans,
+                        void* ThreadPool) {
+  switch (QuantType) {
+    case BTLA_DTYPE::S4_CLIP:
+    case BTLA_DTYPE::S4_FULLRANGE:
+    case BTLA_DTYPE::S8:
+      return BTLAGemmQuantPackBLocal<prologue_b::gemm::WeightKBlockNInteger>(
+          PackedBuf, FpData, N, K, ldb, BlkSize, QuantType, ScaleDtype, isAsym, CompType, isTrans, ThreadPool);
+    case BTLA_DTYPE::F8_E5M2:
+    case BTLA_DTYPE::F8_E4M3:
+    case BTLA_DTYPE::F4_BNB:
+    case BTLA_DTYPE::F4_E2M1:
+    case BTLA_DTYPE::F4_NF4:
+      return BTLAGemmQuantPackBLocal<prologue_b::gemm::WeightKBlockNFloat>(
+          PackedBuf, FpData, N, K, ldb, BlkSize, QuantType, ScaleDtype, isAsym, CompType, isTrans, ThreadPool);
+    default:
+      return false;
+  }
+  return false;
+}
+
+bool BTLAGemmPackB(void* PackedBuf, const int8_t* QData, const float* Scales, const int8_t* Zp, size_t N, size_t K,
+                   size_t ldb, size_t BlkSize, BTLA_DTYPE QuantType, BTLA_DTYPE ScaleDtype, bool isAsym,
+                   ne_comp_type CompType, int* shuffle_indice, void* ThreadPool) {
+  // only for integer quant
+  switch (QuantType) {
+    case BTLA_DTYPE::S4_CLIP:
+    case BTLA_DTYPE::S4_FULLRANGE:
+    case BTLA_DTYPE::S8:
+      return BTLAGemmPackBLocal<prologue_b::gemm::WeightKBlockNInteger>(PackedBuf, QData, Scales, Zp, N, K, ldb,
+                                                                        BlkSize, QuantType, ScaleDtype, isAsym,
+                                                                        CompType, shuffle_indice, ThreadPool);
+    default:
+      return false;
+  }
+  return false;
+}
+
+bool BTLAGemmUnPackB(float* FpData, const void* PackedBuf, size_t N, size_t K, size_t ldb, void* ThreadPool) {
+  auto ptr = storage::gemm::PackedWeightParser::deserialBuffer(const_cast<void*>(PackedBuf));
+  auto pth = reinterpret_cast<parallel::IThreading*>(ThreadPool);
+  GetCPUDevice();
+  if (ptr) {
+    auto NTile = gemm::CoreAttr::get_mask_val(ptr->mCoreId, gemm::CoreAttr::NTILE_MASK, gemm::CoreAttr::NTILE_SHIFT);
+    auto PackRow = gemm::CoreAttr::get_packrow(ptr->mCoreId);
+    auto CType = gemm::CoreAttr::get_comp(ptr->mCoreId);
+    auto btype = static_cast<gemm::CompType>(gemm::CompTypeHelper::get_B(CType));
+    if (ptr->mPrologueID == BTLA_PROLOGUEB_IDS::WeightKBlockNInteger) {
+      auto sptr = reinterpret_cast<storage::gemm::StorageWeightKBlockNInteger*>(ptr);
+      if (btype == gemm::CompType::tFP32 && PackRow == 1) {
+        if (NTile == tAVX512F::NTILE && _cd->AVX512F()) {
+          static prologue_b::gemm::WeightKBlockNInteger<tAVX512F, tAVX512F::ISA> proB;
+          proB.unpackWeight(static_cast<int>(N), static_cast<int>(K), sptr, FpData, static_cast<int>(ldb), pth);
+        } else if (NTile == tAVX2::NTILE && _cd->AVX2()) {
+          static prologue_b::gemm::WeightKBlockNInteger<tAVX2, tAVX2::ISA> proB;
+          proB.unpackWeight(static_cast<int>(N), static_cast<int>(K), sptr, FpData, static_cast<int>(ldb), pth);
+        }
+      }
+      if (btype == gemm::CompType::tS8 && PackRow == 4) {
+        if (NTile == tAMX_INT8_SS_KBlock::NTILE && _cd->AMX_INT8()) {
+          static prologue_b::gemm::WeightKBlockNInteger<tAMX_INT8_SS_KBlock, tAMX_INT8_SS_KBlock::ISA> proB;
+          proB.unpackWeight(static_cast<int>(N), static_cast<int>(K), sptr, FpData, static_cast<int>(ldb), pth);
+        } else if (NTile == tAVX512_VNNI_KBlock::NTILE && _cd->AVX512_VNNI()) {
+          static prologue_b::gemm::WeightKBlockNInteger<tAVX512_VNNI_KBlock, tAVX512_VNNI_KBlock::ISA> proB;
+          proB.unpackWeight(static_cast<int>(N), static_cast<int>(K), sptr, FpData, static_cast<int>(ldb), pth);
+        } else if (NTile == tAVX_VNNI_KBlock::NTILE && _cd->AVX_VNNI()) {
+          static prologue_b::gemm::WeightKBlockNInteger<tAVX_VNNI_KBlock, tAVX_VNNI_KBlock::ISA> proB;
+          proB.unpackWeight(static_cast<int>(N), static_cast<int>(K), sptr, FpData, static_cast<int>(ldb), pth);
+        }
+      }
+      if (btype == gemm::CompType::tBF16 && PackRow == 2) {
+        if (NTile == tAMX_BF16::NTILE && _cd->AMX_BF16()) {
+          static prologue_b::gemm::WeightKBlockNInteger<tAMX_BF16, tAMX_BF16::ISA> proB;
+          proB.unpackWeight(static_cast<int>(N), static_cast<int>(K), sptr, FpData, static_cast<int>(ldb), pth);
+        }
+      }
+    }
+    if (ptr->mPrologueID == BTLA_PROLOGUEB_IDS::WeightKBlockNFloat) {
+      auto sptr = reinterpret_cast<storage::gemm::StorageWeightKBlockNFloat*>(ptr);
+      if (btype == gemm::CompType::tFP32 && PackRow == 1) {
+        if (NTile == tAVX512F::NTILE && _cd->AVX512F()) {
+          static prologue_b::gemm::WeightKBlockNFloat<tAVX512F, tAVX512F::ISA> proB;
+          proB.unpackWeight(static_cast<int>(N), static_cast<int>(K), sptr, FpData, static_cast<int>(ldb), pth);
+        } else if (NTile == tAVX2::NTILE && _cd->AVX2()) {
+          static prologue_b::gemm::WeightKBlockNFloat<tAVX2, tAVX2::ISA> proB;
+          proB.unpackWeight(static_cast<int>(N), static_cast<int>(K), sptr, FpData, static_cast<int>(ldb), pth);
+        }
+      }
+      if (btype == gemm::CompType::tBF16 && PackRow == 2) {
+        if (NTile == tAMX_BF16::NTILE && _cd->AMX_BF16()) {
+          static prologue_b::gemm::WeightKBlockNFloat<tAMX_BF16, tAMX_BF16::ISA> proB;
+          proB.unpackWeight(static_cast<int>(N), static_cast<int>(K), sptr, FpData, static_cast<int>(ldb), pth);
+        }
+      }
+    }
+    delete ptr;
+    return true;
+  }
+  return false;
+}
diff --git a/neural_speed/core/layers/bestla_gemm.h b/neural_speed/core/layers/bestla_gemm.h
new file mode 100644
index 000000000..a987dd3ff
--- /dev/null
+++ b/neural_speed/core/layers/bestla_gemm.h
@@ -0,0 +1,55 @@
+//  Copyright (c) 2023 Intel Corporation
+//
+//  Licensed under the Apache License, Version 2.0 (the "License");
+//  you may not use this file except in compliance with the License.
+//  You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+//  Unless required by applicable law or agreed to in writing, software
+//  distributed under the License is distributed on an "AS IS" BASIS,
+//  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.
+
+/*++
+Module Name:
+
+    bestla_gemm.h
+
+Abstract:
+
+    C APIs of BesTLA GEMMs.
+--*/
+
+#pragma once
+
+#include "data_types.h"
+#include "bestla/bestla.h"
+
+struct BTLA_GEMM_DATA_PACKED_PARAMS {
+  const float* A = nullptr; /**< address of A (float32 matrix)*/
+  const void* B = nullptr;  /**< address of B (packed nbits blob)*/
+  float* C = nullptr;       /**< address of result matrix */
+  int lda = 0;              /**< leading dimension of A */
+  int ldc = 0;              /**< leading dimension of C*/
+};
+
+size_t BTLAGemmPackBSize(size_t N, size_t K, size_t BlkSize, BTLA_DTYPE QuantType, BTLA_DTYPE ScaleDtype, bool isAsym,
+                         ne_comp_type CompType, int* shuffle_indice);
+
+bool BTLAGemmQuantPackB(void* PackedBuf, const float* FpData, size_t N, size_t K, size_t ldb, size_t BlkSize,
+                        BTLA_DTYPE QuantType, BTLA_DTYPE ScaleDtype, bool isAsym, ne_comp_type CompType, bool isTrans,
+                        void* ThreadPool);
+
+// QData:  K*N quantized int8 weight
+// Scales: K/BlkSize * N scales
+// Zp:     K/BlkSize * N zero points
+bool BTLAGemmPackB(void* PackedBuf, const int8_t* QData, const float* Scales, const int8_t* Zp, size_t N, size_t K,
+                   size_t ldb, size_t BlkSize, BTLA_DTYPE QuantType, BTLA_DTYPE ScaleDtype, bool isAsym,
+                   ne_comp_type CompType, int* shuffle_indice, void* ThreadPool);
+
+bool BTLAGemmUnPackB(float* FpData, const void* PackedBuf, size_t N, size_t K, size_t ldb, void* ThreadPool);
+
+bool BTLAGemmBatchDriver(const size_t M, const size_t N, const size_t K, const size_t BatchN,
+                         const BTLA_GEMM_DATA_PACKED_PARAMS* DataParams, int8_t* WorkSpace, void* ThreadPool);
diff --git a/neural_speed/core/layers/inner_product.cpp b/neural_speed/core/layers/inner_product.cpp
index 53939e94e..57691482b 100644
--- a/neural_speed/core/layers/inner_product.cpp
+++ b/neural_speed/core/layers/inner_product.cpp
@@ -11,13 +11,13 @@
 //  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.
-#include "jblas_common.hpp"
-#include "jblas_gemm.h"
+#include "bestla_common.hpp"
+#include "bestla_gemm.h"
 
-using namespace jblas;     // NOLINT
-using namespace ne_jblas;  // NOLINT
+using namespace bestla;     // NOLINT
+using namespace ne_bestla;  // NOLINT
 
-unsigned long long jblas_f32f32_get_workspace_size(int _m, int _n, int _k, void* wptr) {  // NOLINT
+unsigned long long bestla_f32f32_get_workspace_size(int _m, int _n, int _k, void* wptr) {  // NOLINT
   // maximum padding
   int constexpr padding = 128;
   size_t s = static_cast<size_t>(_m) * utils::padto(static_cast<size_t>(_k), padding) * 4;
@@ -25,27 +25,25 @@ unsigned long long jblas_f32f32_get_workspace_size(int _m, int _n, int _k, void*
 }
 
 // f32f32: activation & output dtype
-void jblas_f32f32_forward(float* activation, void* weiptr, float* output, int _m, int _n, int _k, int lda, int ldo,
-                          void* workspace) {
-  auto ret = JblasRuntimeError;
-  JBLAS_GEMM_DATA_PACKED_PARAMS param{activation, weiptr, output, lda, ldo};
-  if (!JblasGemmBatchDriver(_m, _n, _k, 1, &param, reinterpret_cast<int8_t*>(workspace),
-                            ne_jblas::ne_threading::get())) {
+void bestla_f32f32_forward(float* activation, void* weiptr, float* output, int _m, int _n, int _k, int lda, int ldo,
+                           void* workspace) {
+  BTLA_GEMM_DATA_PACKED_PARAMS param{activation, weiptr, output, lda, ldo};
+  if (!BTLAGemmBatchDriver(_m, _n, _k, 1, &param, reinterpret_cast<int8_t*>(workspace),
+                           ne_bestla::ne_threading::get())) {
     printf("Err: invalid parameters\n");
     assert(0);
   }
 }
 
 namespace ip_add {
-template <class GemmCore_T, template <class, JBLAS_ISA> class Wei_T, template <class, JBLAS_ISA> class Act_T>
-void JblasGemmCompF32(const int M, const int N, const int K, const float* A, const int lda,
-                      jblas::storage::gemm::IWeightBase* _B, float* C, const int ldc, float* bias, bool broadcast_bias,
-                      int8_t* WorkSpace, jblas::parallel::IThreading* th) {
+template <class GemmCore_T, template <class, BTLA_ISA> class Wei_T, template <class, BTLA_ISA> class Act_T>
+void BTLAGemmCompF32(const int M, const int N, const int K, const float* A, const int lda,
+                     storage::gemm::IWeightBase* _B, float* C, const int ldc, float* bias, bool broadcast_bias,
+                     int8_t* WorkSpace, parallel::IThreading* th) {
   if (M <= 16) {
-    using Parallel = jblas::parallel::gemm::SchedulerKBlock<GemmCore_T>;
-    using Launcher =
-        jblas::wrapper::gemm::LauncherKBlock<GemmCore_T::ISA, GemmCore_T, Act_T, Wei_T,
-                                             jblas::epilogue::gemm::CompFp32BlockEpilogue, custom::epilogue::AddFp32>;
+    using Parallel = parallel::gemm::SchedulerKBlock<GemmCore_T>;
+    using Launcher = wrapper::gemm::LauncherKBlock<GemmCore_T::ISA, GemmCore_T, Act_T, Wei_T,
+                                                   epilogue::gemm::CompFp32BlockEpilogue, custom::epilogue::AddFp32>;
     auto B = reinterpret_cast<typename Launcher::PrologueB::StorageWeight*>(_B);
     static Launcher kernel;
     utils::GemmProblem gp(1, M, N, K, B->mBlockSize);
@@ -64,14 +62,13 @@ void JblasGemmCompF32(const int M, const int N, const int K, const float* A, con
     typename Launcher::Param args{
         gp, {A, lda, &reduceA, B->ShfIndice(), &reordA}, {B}, blkargs, {C, bias, ldc, broadcast_bias ? 0 : ldc}};
     if (B->IsAsym() || B->ShfIndice()) {
-      jblas::parallel::GemmRunWithA<Parallel>(kernel, args, th);
+      parallel::GemmRunWithA<Parallel>(kernel, args, th);
     } else {
-      jblas::parallel::GemmRun<Parallel>(kernel, args, th);
+      parallel::GemmRun<Parallel>(kernel, args, th);
     }
   } else {
-    using Parallel = jblas::parallel::gemm::SchedulerBase<GemmCore_T>;
-    using Launcher =
-        jblas::wrapper::gemm::LauncherBase<GemmCore_T::ISA, GemmCore_T, Act_T, Wei_T, custom::epilogue::AddFp32>;
+    using Parallel = parallel::gemm::SchedulerBase<GemmCore_T>;
+    using Launcher = wrapper::gemm::LauncherBase<GemmCore_T::ISA, GemmCore_T, Act_T, Wei_T, custom::epilogue::AddFp32>;
     auto B = reinterpret_cast<typename Launcher::PrologueB::StorageWeight*>(_B);
     utils::GemmProblem gp(1, M, N, K, B->mBlockSize);
     static Launcher kernel;
@@ -80,21 +77,21 @@ void JblasGemmCompF32(const int M, const int N, const int K, const float* A, con
         gp, {A, lda, nullptr, B->ShfIndice(), &reordA}, {B}, {C, bias, ldc, broadcast_bias ? 0 : ldc}};
     if (B->ShfIndice()) {
       reordA.assign(WorkSpace);
-      jblas::parallel::GemmRunWithA<Parallel>(kernel, args, th);
+      parallel::GemmRunWithA<Parallel>(kernel, args, th);
     } else {
-      jblas::parallel::GemmRun<Parallel>(kernel, args, th);
+      parallel::GemmRun<Parallel>(kernel, args, th);
     }
   }
 }
 
-template <class GemmCore_T, template <class, JBLAS_ISA> class Wei_T>
-void JblasGemmCompInt8(const int M, const int N, const int K, const float* A, const int lda,
-                       jblas::storage::gemm::IWeightBase* _B, float* C, const int ldc, float* bias, bool broadcast_bias,
-                       int8_t* WorkSpace, jblas::parallel::IThreading* th) {
-  using Parallel = jblas::parallel::gemm::SchedulerKBlockS<GemmCore_T>;
-  using Launcher = jblas::wrapper::gemm::LauncherIntKBlock<GemmCore_T::ISA, GemmCore_T,
-                                                           jblas::prologue_a::gemm::ShuffleActivationKBlockQuantizeF32,
-                                                           Wei_T, custom::epilogue::AddFp32>;
+template <class GemmCore_T, template <class, BTLA_ISA> class Wei_T>
+void BTLAGemmCompInt8(const int M, const int N, const int K, const float* A, const int lda,
+                      storage::gemm::IWeightBase* _B, float* C, const int ldc, float* bias, bool broadcast_bias,
+                      int8_t* WorkSpace, parallel::IThreading* th) {
+  using Parallel = parallel::gemm::SchedulerKBlockS<GemmCore_T>;
+  using Launcher = wrapper::gemm::LauncherIntKBlock<GemmCore_T::ISA, GemmCore_T,
+                                                    prologue_a::gemm::ShuffleActivationKBlockQuantizeF32, Wei_T,
+                                                    custom::epilogue::AddFp32>;
 
   auto B = reinterpret_cast<typename Launcher::PrologueB::StorageWeight*>(_B);
   utils::GemmProblem gp(1, M, N, K, B->mBlockSize);
@@ -108,23 +105,23 @@ void JblasGemmCompInt8(const int M, const int N, const int K, const float* A, co
   if (B->ShfIndice()) {
     reordA.assign(WorkSpace);
     kernel.mProA.quantize({A, lda, &quanA, B->ShfIndice(), &reordA}, M, K, th);
-    jblas::parallel::GemmRun<Parallel>(kernel, args, th);
+    parallel::GemmRun<Parallel>(kernel, args, th);
   } else {
-    jblas::parallel::GemmRunWithA<Parallel>(kernel, args, th);
+    parallel::GemmRunWithA<Parallel>(kernel, args, th);
   }
 }
 }  // namespace ip_add
 
-bool jblas_fusion_add_f32f32_support(void* weiptr, int _m, int _n, int _k) {
+bool bestla_fusion_add_f32f32_support(void* weiptr, int _m, int _n, int _k) {
   GetCPUDevice();
   bool support = false;
-  auto wtmp = jblas::storage::gemm::PackedWeightParser::deserialBuffer(weiptr);
+  auto wtmp = storage::gemm::PackedWeightParser::deserialBuffer(weiptr);
   if (wtmp) {
-    if (wtmp->mPrologueID == JBLAS_PROLOGUEB_IDS::WeightKBlockNInteger) {
+    if (wtmp->mPrologueID == BTLA_PROLOGUEB_IDS::WeightKBlockNInteger) {
       constexpr size_t EleNum = sizeof(AllKBlockCores) / sizeof(AllKBlockCores[0]);  // supported cores
       support = contains(wtmp->mCoreId, AllKBlockCores, EleNum);
       support &= hasISA(AllKBlockCores, EleNum);
-    } else if (wtmp->mPrologueID == JBLAS_PROLOGUEB_IDS::WeightKBlockNFloat) {
+    } else if (wtmp->mPrologueID == BTLA_PROLOGUEB_IDS::WeightKBlockNFloat) {
       constexpr size_t EleNum = sizeof(FloatCores) / sizeof(FloatCores[0]);
       support = contains(wtmp->mCoreId, FloatCores, EleNum);
       support &= hasISA(FloatCores, EleNum);
@@ -134,84 +131,83 @@ bool jblas_fusion_add_f32f32_support(void* weiptr, int _m, int _n, int _k) {
   return support;
 }
 
-void jblas_fusion_add_f32f32_forward(float* activation, void* weiptr, float* bias, float* output, int _m, int _n,
-                                     int _k, int lda, int ldo, bool broadcast_bias, void* _workspace) {
+void bestla_fusion_add_f32f32_forward(float* activation, void* weiptr, float* bias, float* output, int _m, int _n,
+                                      int _k, int lda, int ldo, bool broadcast_bias, void* _workspace) {
   GetCPUDevice();
-  auto pth = ne_jblas::ne_threading::get();
-  auto ptr = jblas::storage::gemm::PackedWeightParser::deserialBuffer(const_cast<void*>(weiptr));
+  auto pth = ne_bestla::ne_threading::get();
+  auto ptr = storage::gemm::PackedWeightParser::deserialBuffer(const_cast<void*>(weiptr));
   auto workspace = reinterpret_cast<int8_t*>(_workspace);
   if (ptr) {
     auto coretype = ptr->mCoreId;
-    auto NTile = jblas::gemm::CoreAttr::get_mask_val(ptr->mCoreId, jblas::gemm::CoreAttr::NTILE_MASK,
-                                                     jblas::gemm::CoreAttr::NTILE_SHIFT);
-    auto PackRow = jblas::gemm::CoreAttr::get_packrow(ptr->mCoreId);
-    auto CType = jblas::gemm::CoreAttr::get_comp(ptr->mCoreId);
-    auto btype = static_cast<jblas::gemm::CompType>(jblas::gemm::CompTypeHelper::get_B(CType));
-    if (ptr->mPrologueID == JBLAS_PROLOGUEB_IDS::WeightKBlockNInteger) {
-      auto bptr = reinterpret_cast<jblas::storage::gemm::IWeightKBlockBase*>(ptr);
+    auto NTile = gemm::CoreAttr::get_mask_val(ptr->mCoreId, gemm::CoreAttr::NTILE_MASK, gemm::CoreAttr::NTILE_SHIFT);
+    auto PackRow = gemm::CoreAttr::get_packrow(ptr->mCoreId);
+    auto CType = gemm::CoreAttr::get_comp(ptr->mCoreId);
+    auto btype = static_cast<gemm::CompType>(gemm::CompTypeHelper::get_B(CType));
+    if (ptr->mPrologueID == BTLA_PROLOGUEB_IDS::WeightKBlockNInteger) {
+      auto bptr = reinterpret_cast<storage::gemm::IWeightKBlockBase*>(ptr);
       auto BlkSize = bptr->mBlockSize;
-      if (btype == jblas::gemm::CompType::tFP32 && PackRow == 1) {
+      if (btype == gemm::CompType::tFP32 && PackRow == 1) {
         if (NTile == tAVX512F::NTILE && _cd->AVX512F() && BlkSize % tAVX512F::KTILE == 0) {
-          ip_add::JblasGemmCompF32<tAVX512F, tWeiNInt, tActKBaseF32>(_m, _n, _k, activation, lda, ptr, output, ldo,
-                                                                     bias, broadcast_bias, workspace, pth);
+          ip_add::BTLAGemmCompF32<tAVX512F, tWeiNInt, tActKBaseF32>(_m, _n, _k, activation, lda, ptr, output, ldo, bias,
+                                                                    broadcast_bias, workspace, pth);
         } else if (NTile == tAVX2::NTILE && _cd->AVX2() && BlkSize % tAVX2::KTILE == 0) {
-          ip_add::JblasGemmCompF32<tAVX2, tWeiNInt, tActKBaseF32>(_m, _n, _k, activation, lda, ptr, output, ldo, bias,
-                                                                  broadcast_bias, workspace, pth);
+          ip_add::BTLAGemmCompF32<tAVX2, tWeiNInt, tActKBaseF32>(_m, _n, _k, activation, lda, ptr, output, ldo, bias,
+                                                                 broadcast_bias, workspace, pth);
         }
       }
-      if (btype == jblas::gemm::CompType::tBF16 && PackRow == 2) {
+      if (btype == gemm::CompType::tBF16 && PackRow == 2) {
         if (NTile == tAMX_BF16::NTILE && _cd->AMX_BF16() && BlkSize % tAMX_BF16::KTILE == 0) {
           if (_m <= tAVX512_BF16::MTILE) {
             static_assert(tAVX512_BF16::NTILE == tAMX_BF16::NTILE);
-            ip_add::JblasGemmCompF32<tAVX512_BF16, tWeiNInt, tActKBaseF32>(_m, _n, _k, activation, lda, ptr, output,
-                                                                           ldo, bias, broadcast_bias, workspace, pth);
+            ip_add::BTLAGemmCompF32<tAVX512_BF16, tWeiNInt, tActKBaseF32>(_m, _n, _k, activation, lda, ptr, output, ldo,
+                                                                          bias, broadcast_bias, workspace, pth);
           } else {
-            ip_add::JblasGemmCompF32<tAMX_BF16, tWeiNInt, tActKBaseF32>(_m, _n, _k, activation, lda, ptr, output, ldo,
-                                                                        bias, broadcast_bias, workspace, pth);
+            ip_add::BTLAGemmCompF32<tAMX_BF16, tWeiNInt, tActKBaseF32>(_m, _n, _k, activation, lda, ptr, output, ldo,
+                                                                       bias, broadcast_bias, workspace, pth);
           }
         }
       }
-      if (btype == jblas::gemm::CompType::tS8 && PackRow == 4) {
+      if (btype == gemm::CompType::tS8 && PackRow == 4) {
         if (NTile == tAMX_INT8_SS_KBlock::NTILE && _cd->AMX_INT8() && BlkSize % tAMX_INT8_SS_KBlock::KTILE == 0) {
           static_assert(tAMX_INT8_SS_KBlock::NTILE == tAVX512_VNNI_KBlock::NTILE);
           if (_m <= tAVX512_VNNI_KBlock::MTILE) {
-            ip_add::JblasGemmCompInt8<tAVX512_VNNI_KBlock, tWeiNInt>(_m, _n, _k, activation, lda, ptr, output, ldo,
-                                                                     bias, broadcast_bias, workspace, pth);
+            ip_add::BTLAGemmCompInt8<tAVX512_VNNI_KBlock, tWeiNInt>(_m, _n, _k, activation, lda, ptr, output, ldo, bias,
+                                                                    broadcast_bias, workspace, pth);
           } else {
-            ip_add::JblasGemmCompInt8<tAMX_INT8_SS_KBlock, tWeiNInt>(_m, _n, _k, activation, lda, ptr, output, ldo,
-                                                                     bias, broadcast_bias, workspace, pth);
+            ip_add::BTLAGemmCompInt8<tAMX_INT8_SS_KBlock, tWeiNInt>(_m, _n, _k, activation, lda, ptr, output, ldo, bias,
+                                                                    broadcast_bias, workspace, pth);
           }
 
         } else if (NTile == tAVX512_VNNI_KBlock::NTILE && _cd->AVX512_VNNI() &&
                    BlkSize % tAVX512_VNNI_KBlock::KTILE == 0) {
-          ip_add::JblasGemmCompInt8<tAVX512_VNNI_KBlock, tWeiNInt>(_m, _n, _k, activation, lda, ptr, output, ldo, bias,
-                                                                   broadcast_bias, workspace, pth);
+          ip_add::BTLAGemmCompInt8<tAVX512_VNNI_KBlock, tWeiNInt>(_m, _n, _k, activation, lda, ptr, output, ldo, bias,
+                                                                  broadcast_bias, workspace, pth);
         } else if (NTile == tAVX_VNNI_KBlock::NTILE && _cd->AVX_VNNI() && BlkSize % tAVX_VNNI_KBlock::KTILE == 0) {
-          ip_add::JblasGemmCompInt8<tAVX_VNNI_KBlock, tWeiNInt>(_m, _n, _k, activation, lda, ptr, output, ldo, bias,
-                                                                broadcast_bias, workspace, pth);
+          ip_add::BTLAGemmCompInt8<tAVX_VNNI_KBlock, tWeiNInt>(_m, _n, _k, activation, lda, ptr, output, ldo, bias,
+                                                               broadcast_bias, workspace, pth);
         }
       }
     }
-    if (ptr->mPrologueID == JBLAS_PROLOGUEB_IDS::WeightKBlockNFloat) {
-      auto bptr = reinterpret_cast<jblas::storage::gemm::IWeightKBlockBase*>(ptr);
+    if (ptr->mPrologueID == BTLA_PROLOGUEB_IDS::WeightKBlockNFloat) {
+      auto bptr = reinterpret_cast<storage::gemm::IWeightKBlockBase*>(ptr);
       auto BlkSize = bptr->mBlockSize;
-      if (btype == jblas::gemm::CompType::tFP32 && PackRow == 1) {
+      if (btype == gemm::CompType::tFP32 && PackRow == 1) {
         if (NTile == tAVX512F::NTILE && _cd->AVX512F() && BlkSize % tAVX512F::KTILE == 0) {
-          ip_add::JblasGemmCompF32<tAVX512F, tWeiNFloat, tActKBaseF32>(_m, _n, _k, activation, lda, ptr, output, ldo,
+          ip_add::BTLAGemmCompF32<tAVX512F, tWeiNFloat, tActKBaseF32>(_m, _n, _k, activation, lda, ptr, output, ldo,
                                                                        bias, broadcast_bias, workspace, pth);
         } else if (NTile == tAVX2::NTILE && _cd->AVX2() && BlkSize % tAVX2::KTILE == 0) {
-          ip_add::JblasGemmCompF32<tAVX2, tWeiNFloat, tActKBaseF32>(_m, _n, _k, activation, lda, ptr, output, ldo, bias,
+          ip_add::BTLAGemmCompF32<tAVX2, tWeiNFloat, tActKBaseF32>(_m, _n, _k, activation, lda, ptr, output, ldo, bias,
                                                                     broadcast_bias, workspace, pth);
         }
       }
-      if (btype == jblas::gemm::CompType::tBF16 && PackRow == 2 && BlkSize % tAMX_BF16::KTILE == 0) {
+      if (btype == gemm::CompType::tBF16 && PackRow == 2 && BlkSize % tAMX_BF16::KTILE == 0) {
         if (NTile == tAMX_BF16::NTILE && _cd->AMX_BF16()) {
           if (_m <= tAVX512_BF16::MTILE) {
             static_assert(tAVX512_BF16::NTILE == tAMX_BF16::NTILE);
-            ip_add::JblasGemmCompF32<tAVX512_BF16, tWeiNFloat, tActKBaseF32>(_m, _n, _k, activation, lda, ptr, output,
+            ip_add::BTLAGemmCompF32<tAVX512_BF16, tWeiNFloat, tActKBaseF32>(_m, _n, _k, activation, lda, ptr, output,
                                                                              ldo, bias, broadcast_bias, workspace, pth);
           } else {
-            ip_add::JblasGemmCompF32<tAMX_BF16, tWeiNFloat, tActKBaseF32>(_m, _n, _k, activation, lda, ptr, output, ldo,
+            ip_add::BTLAGemmCompF32<tAMX_BF16, tWeiNFloat, tActKBaseF32>(_m, _n, _k, activation, lda, ptr, output, ldo,
                                                                           bias, broadcast_bias, workspace, pth);
           }
         }
diff --git a/neural_speed/core/layers/ip_fusion_ffn.cpp b/neural_speed/core/layers/ip_fusion_ffn.cpp
index b136a4850..be641d4ad 100644
--- a/neural_speed/core/layers/ip_fusion_ffn.cpp
+++ b/neural_speed/core/layers/ip_fusion_ffn.cpp
@@ -12,13 +12,13 @@
 //  See the License for the specific language governing permissions and
 //  limitations under the License.
 
-#include "jblas_common.hpp"
+#include "bestla_common.hpp"
 
-using namespace jblas;     // NOLINT
-using namespace ne_jblas;  // NOLINT
+using namespace bestla;     // NOLINT
+using namespace ne_bestla;  // NOLINT
 
-unsigned long long jblas_fusion_FFN_f32f32_get_workspace_size(int seq, int fin, int fmid, int fout,  // NOLINT
-                                                              void* w1ptr, void* w2ptr) {
+unsigned long long bestla_fusion_FFN_f32f32_get_workspace_size(int seq, int fin, int fmid, int fout,  // NOLINT
+                                                               void* w1ptr, void* w2ptr) {
   // lazy size: maximum padding
   int constexpr padding = 128;
   size_t s = static_cast<size_t>(seq) * utils::padto(static_cast<size_t>(fin), padding) * 4;
@@ -100,19 +100,18 @@ void GemmRun_ffn(Launch_T1* launcher1, Launch_T2* launcher2, const typename Laun
   });
 }
 
-template <class GemmCore_T, template <class, JBLAS_ISA> class Wei_T, template <class, JBLAS_ISA> class Act_T,
-          template <JBLAS_ISA> class Epi_T1, template <JBLAS_ISA> class Epi_T2>
-void JblasGemmCompF32(float* activation, jblas::storage::gemm::IWeightBase* w1ptr,
-                      jblas::storage::gemm::IWeightBase* w2ptr, float* tmp, float* output, int seq, int fin, int fmid,
-                      int fout, void* workspace, jblas::parallel::IThreading* th,
-                      typename Epi_T1<GemmCore_T::ISA>::Param epi_prama1,
+template <class GemmCore_T, template <class, BTLA_ISA> class Wei_T, template <class, BTLA_ISA> class Act_T,
+          template <BTLA_ISA> class Epi_T1, template <BTLA_ISA> class Epi_T2>
+void BTLAGemmCompF32(float* activation, storage::gemm::IWeightBase* w1ptr, storage::gemm::IWeightBase* w2ptr,
+                      float* tmp, float* output, int seq, int fin, int fmid, int fout, void* workspace,
+                      parallel::IThreading* th, typename Epi_T1<GemmCore_T::ISA>::Param epi_prama1,
                       typename Epi_T2<GemmCore_T::ISA>::Param epi_prama2) {
   if (seq <= 16) {
-    using Parallel = jblas::parallel::gemm::SchedulerKBlock<GemmCore_T>;
-    using Launcher_epi = jblas::wrapper::gemm::LauncherKBlock<GemmCore_T::ISA, GemmCore_T, Act_T, Wei_T,
-                                                              jblas::epilogue::gemm::CompFp32BlockEpilogue, Epi_T1>;
-    using Launcher = jblas::wrapper::gemm::LauncherKBlock<GemmCore_T::ISA, GemmCore_T, Act_T, Wei_T,
-                                                          jblas::epilogue::gemm::CompFp32BlockEpilogue, Epi_T2>;
+    using Parallel = parallel::gemm::SchedulerKBlock<GemmCore_T>;
+    using Launcher_epi = wrapper::gemm::LauncherKBlock<GemmCore_T::ISA, GemmCore_T, Act_T, Wei_T,
+                                                       epilogue::gemm::CompFp32BlockEpilogue, Epi_T1>;
+    using Launcher = wrapper::gemm::LauncherKBlock<GemmCore_T::ISA, GemmCore_T, Act_T, Wei_T,
+                                                   epilogue::gemm::CompFp32BlockEpilogue, Epi_T2>;
     static Launcher_epi kernel_epi;
     static Launcher kernel;
     auto w1ptr_ = reinterpret_cast<typename Launcher_epi::PrologueB::StorageWeight*>(w1ptr);
@@ -158,9 +157,9 @@ void JblasGemmCompF32(float* activation, jblas::storage::gemm::IWeightBase* w1pt
       GemmRun_ffn<Parallel>(&kernel_epi, &kernel, args1, args2, th);
     }
   } else {
-    using Parallel = jblas::parallel::gemm::SchedulerBase<GemmCore_T>;
-    using Launcher_epi = jblas::wrapper::gemm::LauncherBase<GemmCore_T::ISA, GemmCore_T, Act_T, Wei_T, Epi_T1>;
-    using Launcher = jblas::wrapper::gemm::LauncherBase<GemmCore_T::ISA, GemmCore_T, Act_T, Wei_T, Epi_T2>;
+    using Parallel = parallel::gemm::SchedulerBase<GemmCore_T>;
+    using Launcher_epi = wrapper::gemm::LauncherBase<GemmCore_T::ISA, GemmCore_T, Act_T, Wei_T, Epi_T1>;
+    using Launcher = wrapper::gemm::LauncherBase<GemmCore_T::ISA, GemmCore_T, Act_T, Wei_T, Epi_T2>;
     auto w1ptr_ = reinterpret_cast<typename Launcher_epi::PrologueB::StorageWeight*>(w1ptr);
     auto w2ptr_ = reinterpret_cast<typename Launcher::PrologueB::StorageWeight*>(w2ptr);
     utils::GemmProblem gp1(1, seq, fmid, fin);
@@ -183,18 +182,19 @@ void JblasGemmCompF32(float* activation, jblas::storage::gemm::IWeightBase* w1pt
   }
 }
 
-template <class GemmCore_T, template <class, JBLAS_ISA> class Wei_T, template <JBLAS_ISA> class Epi_T1,
-          template <JBLAS_ISA> class Epi_T2>
-void JblasGemmCompInt8(float* activation, jblas::storage::gemm::IWeightBase* w1ptr,
-                       jblas::storage::gemm::IWeightBase* w2ptr, float* tmp, float* output, int seq, int fin, int fmid,
-                       int fout, void* workspace, jblas::parallel::IThreading* th,
-                       typename Epi_T1<GemmCore_T::ISA>::Param epi_prama1,
+template <class GemmCore_T, template <class, BTLA_ISA> class Wei_T, template <BTLA_ISA> class Epi_T1,
+          template <BTLA_ISA> class Epi_T2>
+void BTLAGemmCompInt8(float* activation, storage::gemm::IWeightBase* w1ptr, storage::gemm::IWeightBase* w2ptr,
+                       float* tmp, float* output, int seq, int fin, int fmid, int fout, void* workspace,
+                       parallel::IThreading* th, typename Epi_T1<GemmCore_T::ISA>::Param epi_prama1,
                        typename Epi_T2<GemmCore_T::ISA>::Param epi_prama2) {
-  using Parallel = jblas::parallel::gemm::SchedulerKBlockS<GemmCore_T>;
-  using Launcher_epi = jblas::wrapper::gemm::LauncherIntKBlock<
-      GemmCore_T::ISA, GemmCore_T, jblas::prologue_a::gemm::ShuffleActivationKBlockQuantizeF32, Wei_T, Epi_T1>;
-  using Launcher = jblas::wrapper::gemm::LauncherIntKBlock<
-      GemmCore_T::ISA, GemmCore_T, jblas::prologue_a::gemm::ShuffleActivationKBlockQuantizeF32, Wei_T, Epi_T2>;
+  using Parallel = parallel::gemm::SchedulerKBlockS<GemmCore_T>;
+  using Launcher_epi =
+      wrapper::gemm::LauncherIntKBlock<GemmCore_T::ISA, GemmCore_T,
+                                       prologue_a::gemm::ShuffleActivationKBlockQuantizeF32, Wei_T, Epi_T1>;
+  using Launcher =
+      wrapper::gemm::LauncherIntKBlock<GemmCore_T::ISA, GemmCore_T,
+                                       prologue_a::gemm::ShuffleActivationKBlockQuantizeF32, Wei_T, Epi_T2>;
   auto w1ptr_ = reinterpret_cast<typename Launcher_epi::PrologueB::StorageWeight*>(w1ptr);
   auto w2ptr_ = reinterpret_cast<typename Launcher::PrologueB::StorageWeight*>(w2ptr);
   utils::GemmProblem gp1(1, seq, fmid, fin, w1ptr_->mBlockSize);
@@ -223,19 +223,19 @@ void JblasGemmCompInt8(float* activation, jblas::storage::gemm::IWeightBase* w1p
   GemmRunWithA_ffn<Parallel>(&kernel_epi, &kernel, args1, args2, th);
 }
 
-bool jblas_fusion_ffn_f32f32_support(void* w1ptr, void* w2ptr, int seq, int fin, int fmid, int fout) {
+bool bestla_fusion_ffn_f32f32_support(void* w1ptr, void* w2ptr, int seq, int fin, int fmid, int fout) {
   GetCPUDevice();
-  auto w1tmp = jblas::storage::gemm::PackedWeightParser::deserialBuffer(w1ptr);
-  auto w2tmp = jblas::storage::gemm::PackedWeightParser::deserialBuffer(w2ptr);
+  auto w1tmp = storage::gemm::PackedWeightParser::deserialBuffer(w1ptr);
+  auto w2tmp = storage::gemm::PackedWeightParser::deserialBuffer(w2ptr);
   bool support = false;
   if (w1tmp != nullptr && w2tmp != nullptr) {
     auto sameKernel = samePackedWeight(w1tmp, w2tmp);
     if (sameKernel) {
-      if (w1tmp->mPrologueID == JBLAS_PROLOGUEB_IDS::WeightKBlockNInteger) {
+      if (w1tmp->mPrologueID == BTLA_PROLOGUEB_IDS::WeightKBlockNInteger) {
         constexpr size_t EleNum = sizeof(AllKBlockCores) / sizeof(AllKBlockCores[0]);
         support = contains(w1tmp->mCoreId, AllKBlockCores, EleNum);
         support &= hasISA(AllKBlockCores, EleNum);
-      } else if (w1tmp->mPrologueID == JBLAS_PROLOGUEB_IDS::WeightKBlockNFloat) {
+      } else if (w1tmp->mPrologueID == BTLA_PROLOGUEB_IDS::WeightKBlockNFloat) {
         constexpr size_t EleNum = sizeof(FloatCores) / sizeof(FloatCores[0]);
         support = contains(w1tmp->mCoreId, FloatCores, EleNum);
         support &= hasISA(FloatCores, EleNum);
@@ -247,88 +247,87 @@ bool jblas_fusion_ffn_f32f32_support(void* w1ptr, void* w2ptr, int seq, int fin,
   return support;
 }
 
-template <template <JBLAS_ISA> class epilogue1, template <JBLAS_ISA> class epilogue2, typename Epi_args1,
+template <template <BTLA_ISA> class epilogue1, template <BTLA_ISA> class epilogue2, typename Epi_args1,
           typename Epi_args2>
-void jblas_fusion_ffn_f32f32_forward(float* activation, void* w1ptr, void* w2ptr, float* tmp, float* output, int seq,
-                                     int fin, int fmid, int fout, void* workspace, Epi_args1 epi_args1,
-                                     Epi_args2 epi_args2) {
+void bestla_fusion_ffn_f32f32_forward(float* activation, void* w1ptr, void* w2ptr, float* tmp, float* output, int seq,
+                                      int fin, int fmid, int fout, void* workspace, Epi_args1 epi_args1,
+                                      Epi_args2 epi_args2) {
   GetCPUDevice();
-  auto pth = ne_jblas::ne_threading::get();
-  auto ptr1 = jblas::storage::gemm::PackedWeightParser::deserialBuffer(w1ptr);
-  auto ptr2 = jblas::storage::gemm::PackedWeightParser::deserialBuffer(w2ptr);
+  auto pth = ne_threading::get();
+  auto ptr1 = storage::gemm::PackedWeightParser::deserialBuffer(w1ptr);
+  auto ptr2 = storage::gemm::PackedWeightParser::deserialBuffer(w2ptr);
   auto _workspace = reinterpret_cast<int8_t*>(workspace);
   if (ptr1) {
     auto coretype = ptr1->mCoreId;
-    auto NTile = jblas::gemm::CoreAttr::get_mask_val(ptr1->mCoreId, jblas::gemm::CoreAttr::NTILE_MASK,
-                                                     jblas::gemm::CoreAttr::NTILE_SHIFT);
-    auto PackRow = jblas::gemm::CoreAttr::get_packrow(ptr1->mCoreId);
-    auto CType = jblas::gemm::CoreAttr::get_comp(ptr1->mCoreId);
-    auto btype = static_cast<jblas::gemm::CompType>(jblas::gemm::CompTypeHelper::get_B(CType));
-    if (ptr1->mPrologueID == JBLAS_PROLOGUEB_IDS::WeightKBlockNInteger) {
-      auto bptr = reinterpret_cast<jblas::storage::gemm::IWeightKBlockBase*>(ptr1);
+    auto NTile = gemm::CoreAttr::get_mask_val(ptr1->mCoreId, gemm::CoreAttr::NTILE_MASK, gemm::CoreAttr::NTILE_SHIFT);
+    auto PackRow = gemm::CoreAttr::get_packrow(ptr1->mCoreId);
+    auto CType = gemm::CoreAttr::get_comp(ptr1->mCoreId);
+    auto btype = static_cast<gemm::CompType>(gemm::CompTypeHelper::get_B(CType));
+    if (ptr1->mPrologueID == BTLA_PROLOGUEB_IDS::WeightKBlockNInteger) {
+      auto bptr = reinterpret_cast<storage::gemm::IWeightKBlockBase*>(ptr1);
       auto BlkSize = bptr->mBlockSize;
-      if (btype == jblas::gemm::CompType::tFP32 && PackRow == 1) {
+      if (btype == gemm::CompType::tFP32 && PackRow == 1) {
         if (NTile == tAVX512F::NTILE && _cd->AVX512F() && BlkSize % tAVX512F::KTILE == 0) {
-          JblasGemmCompF32<tAVX512F, tWeiNInt, tActKBaseF32, epilogue1, epilogue2>(
+          BTLAGemmCompF32<tAVX512F, tWeiNInt, tActKBaseF32, epilogue1, epilogue2>(
               activation, ptr1, ptr2, tmp, output, seq, fin, fmid, fout, workspace, pth, epi_args1, epi_args2);
         } else if (NTile == tAVX2::NTILE && _cd->AVX2() && BlkSize % tAVX2::KTILE == 0) {
-          JblasGemmCompF32<tAVX2, tWeiNInt, tActKBaseF32, epilogue1, epilogue2>(
+          BTLAGemmCompF32<tAVX2, tWeiNInt, tActKBaseF32, epilogue1, epilogue2>(
               activation, ptr1, ptr2, tmp, output, seq, fin, fmid, fout, workspace, pth, epi_args1, epi_args2);
         }
       }
-      if (btype == jblas::gemm::CompType::tBF16 && PackRow == 2) {
+      if (btype == gemm::CompType::tBF16 && PackRow == 2) {
         if (NTile == tAMX_BF16::NTILE && _cd->AMX_BF16() && BlkSize % tAMX_BF16::KTILE == 0) {
           if (seq <= tAVX512_BF16::MTILE) {
             static_assert(tAVX512_BF16::NTILE == tAMX_BF16::NTILE);
-            JblasGemmCompF32<tAVX512_BF16, tWeiNInt, tActKBaseF32, epilogue1, epilogue2>(
+            BTLAGemmCompF32<tAVX512_BF16, tWeiNInt, tActKBaseF32, epilogue1, epilogue2>(
                 activation, ptr1, ptr2, tmp, output, seq, fin, fmid, fout, workspace, pth, epi_args1, epi_args2);
           } else {
-            JblasGemmCompF32<tAMX_BF16, tWeiNInt, tActKBaseF32, epilogue1, epilogue2>(
+            BTLAGemmCompF32<tAMX_BF16, tWeiNInt, tActKBaseF32, epilogue1, epilogue2>(
                 activation, ptr1, ptr2, tmp, output, seq, fin, fmid, fout, workspace, pth, epi_args1, epi_args2);
           }
         }
       }
-      if (btype == jblas::gemm::CompType::tS8 && PackRow == 4) {
+      if (btype == gemm::CompType::tS8 && PackRow == 4) {
         if (NTile == tAMX_INT8_SS_KBlock::NTILE && _cd->AMX_INT8() && BlkSize % tAMX_INT8_SS_KBlock::KTILE == 0) {
           if (seq <= tAVX512_VNNI_KBlock::MTILE) {
             static_assert(tAVX512_VNNI_KBlock::NTILE == tAMX_INT8_SS_KBlock::NTILE);
-            JblasGemmCompInt8<tAVX512_VNNI_KBlock, tWeiNInt, epilogue1, epilogue2>(
+            BTLAGemmCompInt8<tAVX512_VNNI_KBlock, tWeiNInt, epilogue1, epilogue2>(
                 activation, ptr1, ptr2, tmp, output, seq, fin, fmid, fout, workspace, pth, epi_args1, epi_args2);
           } else {
-            JblasGemmCompInt8<tAMX_INT8_SS_KBlock, tWeiNInt, epilogue1, epilogue2>(
+            BTLAGemmCompInt8<tAMX_INT8_SS_KBlock, tWeiNInt, epilogue1, epilogue2>(
                 activation, ptr1, ptr2, tmp, output, seq, fin, fmid, fout, workspace, pth, epi_args1, epi_args2);
           }
 
         } else if (NTile == tAVX512_VNNI_KBlock::NTILE && _cd->AVX512_VNNI() &&
                    BlkSize % tAVX512_VNNI_KBlock::KTILE == 0) {
-          JblasGemmCompInt8<tAVX512_VNNI_KBlock, tWeiNInt, epilogue1, epilogue2>(
+          BTLAGemmCompInt8<tAVX512_VNNI_KBlock, tWeiNInt, epilogue1, epilogue2>(
               activation, ptr1, ptr2, tmp, output, seq, fin, fmid, fout, workspace, pth, epi_args1, epi_args2);
         } else if (NTile == tAVX_VNNI_KBlock::NTILE && _cd->AVX_VNNI() && BlkSize % tAVX_VNNI_KBlock::KTILE == 0) {
-          JblasGemmCompInt8<tAVX_VNNI_KBlock, tWeiNInt, epilogue1, epilogue2>(
+          BTLAGemmCompInt8<tAVX_VNNI_KBlock, tWeiNInt, epilogue1, epilogue2>(
               activation, ptr1, ptr2, tmp, output, seq, fin, fmid, fout, workspace, pth, epi_args1, epi_args2);
         }
       }
     }
-    if (ptr1->mPrologueID == JBLAS_PROLOGUEB_IDS::WeightKBlockNFloat) {
-      auto bptr = reinterpret_cast<jblas::storage::gemm::IWeightKBlockBase*>(ptr1);
+    if (ptr1->mPrologueID == BTLA_PROLOGUEB_IDS::WeightKBlockNFloat) {
+      auto bptr = reinterpret_cast<storage::gemm::IWeightKBlockBase*>(ptr1);
       auto BlkSize = bptr->mBlockSize;
-      if (btype == jblas::gemm::CompType::tFP32 && PackRow == 1) {
+      if (btype == gemm::CompType::tFP32 && PackRow == 1) {
         if (NTile == tAVX512F::NTILE && _cd->AVX512F() && BlkSize % tAVX512F::KTILE == 0) {
-          JblasGemmCompF32<tAVX512F, tWeiNFloat, tActKBaseF32, epilogue1, epilogue2>(
+          BTLAGemmCompF32<tAVX512F, tWeiNFloat, tActKBaseF32, epilogue1, epilogue2>(
               activation, ptr1, ptr2, tmp, output, seq, fin, fmid, fout, workspace, pth, epi_args1, epi_args2);
         } else if (NTile == tAVX2::NTILE && _cd->AVX2() && BlkSize % tAVX2::KTILE == 0) {
-          JblasGemmCompF32<tAVX2, tWeiNFloat, tActKBaseF32, epilogue1, epilogue2>(
+          BTLAGemmCompF32<tAVX2, tWeiNFloat, tActKBaseF32, epilogue1, epilogue2>(
               activation, ptr1, ptr2, tmp, output, seq, fin, fmid, fout, workspace, pth, epi_args1, epi_args2);
         }
       }
-      if (btype == jblas::gemm::CompType::tBF16 && PackRow == 2) {
+      if (btype == gemm::CompType::tBF16 && PackRow == 2) {
         if (NTile == tAMX_BF16::NTILE && _cd->AMX_BF16() && BlkSize % tAMX_BF16::KTILE == 0) {
           if (seq <= tAVX512_BF16::MTILE) {
             static_assert(tAVX512_BF16::NTILE == tAMX_BF16::NTILE);
-            JblasGemmCompF32<tAVX512_BF16, tWeiNFloat, tActKBaseF32, epilogue1, epilogue2>(
+            BTLAGemmCompF32<tAVX512_BF16, tWeiNFloat, tActKBaseF32, epilogue1, epilogue2>(
                 activation, ptr1, ptr2, tmp, output, seq, fin, fmid, fout, workspace, pth, epi_args1, epi_args2);
           } else {
-            JblasGemmCompF32<tAMX_BF16, tWeiNFloat, tActKBaseF32, epilogue1, epilogue2>(
+            BTLAGemmCompF32<tAMX_BF16, tWeiNFloat, tActKBaseF32, epilogue1, epilogue2>(
                 activation, ptr1, ptr2, tmp, output, seq, fin, fmid, fout, workspace, pth, epi_args1, epi_args2);
           }
         }
@@ -421,22 +420,22 @@ void GemmRun_ffn(Launch_T1* launcher1, Launch_T2* launcher2, Launch_T3* launcher
   });
 }
 
-template <class GemmCore_T, template <class, JBLAS_ISA> class Wei_T, template <class, JBLAS_ISA> class Act_T,
-          template <JBLAS_ISA> class Epi_T1, template <JBLAS_ISA> class Epi_T2>
-void JblasGemmCompF32(float* activation, jblas::storage::gemm::IWeightBase* w1ptr,
-                      jblas::storage::gemm::IWeightBase* w2ptr, jblas::storage::gemm::IWeightBase* w3ptr, float* tmp1,
-                      float* tmp2, float* output, int seq, int fin, int fmid, int fout, void* workspace,
-                      jblas::parallel::IThreading* th, typename Epi_T1<GemmCore_T::ISA>::Param epi_prama1,
+template <class GemmCore_T, template <class, BTLA_ISA> class Wei_T, template <class, BTLA_ISA> class Act_T,
+          template <BTLA_ISA> class Epi_T1, template <BTLA_ISA> class Epi_T2>
+void BTLAGemmCompF32(float* activation, storage::gemm::IWeightBase* w1ptr, storage::gemm::IWeightBase* w2ptr,
+                      storage::gemm::IWeightBase* w3ptr, float* tmp1, float* tmp2, float* output, int seq, int fin,
+                      int fmid, int fout, void* workspace, parallel::IThreading* th,
+                      typename Epi_T1<GemmCore_T::ISA>::Param epi_prama1,
                       typename Epi_T2<GemmCore_T::ISA>::Param epi_prama2) {
   if (seq <= 16) {
-    using Parallel = jblas::parallel::gemm::SchedulerKBlock<GemmCore_T>;
-    using Launcher_epi = jblas::wrapper::gemm::LauncherKBlock<GemmCore_T::ISA, GemmCore_T, Act_T, Wei_T,
-                                                              jblas::epilogue::gemm::CompFp32BlockEpilogue, Epi_T1>;
+    using Parallel = parallel::gemm::SchedulerKBlock<GemmCore_T>;
+    using Launcher_epi = wrapper::gemm::LauncherKBlock<GemmCore_T::ISA, GemmCore_T, Act_T, Wei_T,
+                                                       epilogue::gemm::CompFp32BlockEpilogue, Epi_T1>;
     using Launcher_mul =
-        jblas::wrapper::gemm::LauncherKBlock<GemmCore_T::ISA, GemmCore_T, Act_T, Wei_T,
-                                             jblas::epilogue::gemm::CompFp32BlockEpilogue, custom::epilogue::MulFp32>;
-    using Launcher = jblas::wrapper::gemm::LauncherKBlock<GemmCore_T::ISA, GemmCore_T, Act_T, Wei_T,
-                                                          jblas::epilogue::gemm::CompFp32BlockEpilogue, Epi_T2>;
+        wrapper::gemm::LauncherKBlock<GemmCore_T::ISA, GemmCore_T, Act_T, Wei_T, epilogue::gemm::CompFp32BlockEpilogue,
+                                      custom::epilogue::MulFp32>;
+    using Launcher = wrapper::gemm::LauncherKBlock<GemmCore_T::ISA, GemmCore_T, Act_T, Wei_T,
+                                                   epilogue::gemm::CompFp32BlockEpilogue, Epi_T2>;
     static Launcher_epi kernel_epi;
     static Launcher_mul kernel_mul;
     static Launcher kernel;
@@ -478,11 +477,11 @@ void JblasGemmCompF32(float* activation, jblas::storage::gemm::IWeightBase* w1pt
       GemmRun_ffn<Parallel>(&kernel_epi, &kernel_mul, &kernel, args1, args3, args2, th);
     }
   } else {
-    using Parallel = jblas::parallel::gemm::SchedulerBase<GemmCore_T>;
-    using Launcher_epi = jblas::wrapper::gemm::LauncherBase<GemmCore_T::ISA, GemmCore_T, Act_T, Wei_T, Epi_T1>;
+    using Parallel = parallel::gemm::SchedulerBase<GemmCore_T>;
+    using Launcher_epi = wrapper::gemm::LauncherBase<GemmCore_T::ISA, GemmCore_T, Act_T, Wei_T, Epi_T1>;
     using Launcher_mul =
-        jblas::wrapper::gemm::LauncherBase<GemmCore_T::ISA, GemmCore_T, Act_T, Wei_T, custom::epilogue::MulFp32>;
-    using Launcher = jblas::wrapper::gemm::LauncherBase<GemmCore_T::ISA, GemmCore_T, Act_T, Wei_T, Epi_T2>;
+        wrapper::gemm::LauncherBase<GemmCore_T::ISA, GemmCore_T, Act_T, Wei_T, custom::epilogue::MulFp32>;
+    using Launcher = wrapper::gemm::LauncherBase<GemmCore_T::ISA, GemmCore_T, Act_T, Wei_T, Epi_T2>;
     auto w1ptr_ = reinterpret_cast<typename Launcher_epi::PrologueB::StorageWeight*>(w1ptr);
     auto w2ptr_ = reinterpret_cast<typename Launcher::PrologueB::StorageWeight*>(w2ptr);
     auto w3ptr_ = reinterpret_cast<typename Launcher_mul::PrologueB::StorageWeight*>(w3ptr);
@@ -502,22 +501,23 @@ void JblasGemmCompF32(float* activation, jblas::storage::gemm::IWeightBase* w1pt
   }
 }
 
-template <class GemmCore_T, template <class, JBLAS_ISA> class Wei_T, template <JBLAS_ISA> class Epi_T1,
-          template <JBLAS_ISA> class Epi_T2>
-void JblasGemmCompInt8(float* activation, jblas::storage::gemm::IWeightBase* w1ptr,
-                       jblas::storage::gemm::IWeightBase* w2ptr, jblas::storage::gemm::IWeightBase* w3ptr, float* tmp1,
-                       float* tmp2, float* output, int seq, int fin, int fmid, int fout, void* workspace,
-                       jblas::parallel::IThreading* th, typename Epi_T1<GemmCore_T::ISA>::Param epi_prama1,
+template <class GemmCore_T, template <class, BTLA_ISA> class Wei_T, template <BTLA_ISA> class Epi_T1,
+          template <BTLA_ISA> class Epi_T2>
+void BTLAGemmCompInt8(float* activation, storage::gemm::IWeightBase* w1ptr, storage::gemm::IWeightBase* w2ptr,
+                       storage::gemm::IWeightBase* w3ptr, float* tmp1, float* tmp2, float* output, int seq, int fin,
+                       int fmid, int fout, void* workspace, parallel::IThreading* th,
+                       typename Epi_T1<GemmCore_T::ISA>::Param epi_prama1,
                        typename Epi_T2<GemmCore_T::ISA>::Param epi_prama2) {
-  using Parallel = jblas::parallel::gemm::SchedulerKBlockS<GemmCore_T>;
-  using Launcher_epi = jblas::wrapper::gemm::LauncherIntKBlock<
-      GemmCore_T::ISA, GemmCore_T, jblas::prologue_a::gemm::ShuffleActivationKBlockQuantizeF32, Wei_T, Epi_T1>;
-  using Launcher_mul =
-      jblas::wrapper::gemm::LauncherIntKBlock<GemmCore_T::ISA, GemmCore_T,
-                                              jblas::prologue_a::gemm::ShuffleActivationKBlockQuantizeF32, Wei_T,
-                                              custom::epilogue::MulFp32>;
-  using Launcher = jblas::wrapper::gemm::LauncherIntKBlock<
-      GemmCore_T::ISA, GemmCore_T, jblas::prologue_a::gemm::ShuffleActivationKBlockQuantizeF32, Wei_T, Epi_T2>;
+  using Parallel = parallel::gemm::SchedulerKBlockS<GemmCore_T>;
+  using Launcher_epi =
+      wrapper::gemm::LauncherIntKBlock<GemmCore_T::ISA, GemmCore_T,
+                                       prologue_a::gemm::ShuffleActivationKBlockQuantizeF32, Wei_T, Epi_T1>;
+  using Launcher_mul = wrapper::gemm::LauncherIntKBlock<GemmCore_T::ISA, GemmCore_T,
+                                                        prologue_a::gemm::ShuffleActivationKBlockQuantizeF32, Wei_T,
+                                                        custom::epilogue::MulFp32>;
+  using Launcher =
+      wrapper::gemm::LauncherIntKBlock<GemmCore_T::ISA, GemmCore_T,
+                                       prologue_a::gemm::ShuffleActivationKBlockQuantizeF32, Wei_T, Epi_T2>;
   auto w1ptr_ = reinterpret_cast<typename Launcher_epi::PrologueB::StorageWeight*>(w1ptr);
   auto w2ptr_ = reinterpret_cast<typename Launcher::PrologueB::StorageWeight*>(w2ptr);
   auto w3ptr_ = reinterpret_cast<typename Launcher_mul::PrologueB::StorageWeight*>(w3ptr);
@@ -543,25 +543,25 @@ void JblasGemmCompInt8(float* activation, jblas::storage::gemm::IWeightBase* w1p
   GemmRunWithA_ffn<Parallel>(&kernel_epi, &kernel_mul, &kernel, args1, args3, args2, th);
 }
 
-bool jblas_fusion_ffn_f32f32_support(void* w1ptr, void* w2ptr, void* w3ptr, int seq, int fin, int fmid, int fout) {
+bool bestla_fusion_ffn_f32f32_support(void* w1ptr, void* w2ptr, void* w3ptr, int seq, int fin, int fmid, int fout) {
   GetCPUDevice();
-  auto w1tmp = jblas::storage::gemm::PackedWeightParser::deserialBuffer(w1ptr);
-  auto w2tmp = jblas::storage::gemm::PackedWeightParser::deserialBuffer(w2ptr);
-  auto w3tmp = jblas::storage::gemm::PackedWeightParser::deserialBuffer(w3ptr);
+  auto w1tmp = storage::gemm::PackedWeightParser::deserialBuffer(w1ptr);
+  auto w2tmp = storage::gemm::PackedWeightParser::deserialBuffer(w2ptr);
+  auto w3tmp = storage::gemm::PackedWeightParser::deserialBuffer(w3ptr);
   bool support = false;
   if (w1tmp != nullptr && w2tmp != nullptr && w3tmp != nullptr) {
-    jblas::storage::gemm::IWeightBase* tmps[3] = {w1tmp, w2tmp, w3tmp};
+    storage::gemm::IWeightBase* tmps[3] = {w1tmp, w2tmp, w3tmp};
     auto sameKernel = samePackedWeight(tmps, 3);
     if (sameKernel) {
-      if (w1tmp->mPrologueID == JBLAS_PROLOGUEB_IDS::WeightKBlockNInteger) {
-        auto w1ptr = reinterpret_cast<jblas::storage::gemm::StorageWeightKBlockNInteger*>(w1tmp);
+      if (w1tmp->mPrologueID == BTLA_PROLOGUEB_IDS::WeightKBlockNInteger) {
+        auto w1ptr = reinterpret_cast<storage::gemm::StorageWeightKBlockNInteger*>(w1tmp);
         if (w1ptr->ShfIndice()) {
           return false;  // Do not support 3w ffn fusion for activation shuffle
         }
         constexpr size_t EleNum = sizeof(AllKBlockCores) / sizeof(AllKBlockCores[0]);
         support = contains(w1tmp->mCoreId, AllKBlockCores, EleNum);
         support &= hasISA(AllKBlockCores, EleNum);
-      } else if (w1tmp->mPrologueID == JBLAS_PROLOGUEB_IDS::WeightKBlockNFloat) {
+      } else if (w1tmp->mPrologueID == BTLA_PROLOGUEB_IDS::WeightKBlockNFloat) {
         constexpr size_t EleNum = sizeof(FloatCores) / sizeof(FloatCores[0]);
         support = contains(w1tmp->mCoreId, FloatCores, EleNum);
         support &= hasISA(FloatCores, EleNum);
@@ -574,100 +574,99 @@ bool jblas_fusion_ffn_f32f32_support(void* w1ptr, void* w2ptr, void* w3ptr, int
   return support;
 }
 
-template <template <JBLAS_ISA> class epilogue1, template <JBLAS_ISA> class epilogue2, typename Epi_args1,
+template <template <BTLA_ISA> class epilogue1, template <BTLA_ISA> class epilogue2, typename Epi_args1,
           typename Epi_args2>
-void jblas_fusion_ffn_f32f32_forward(float* activation, void* w1ptr, void* w2ptr, void* w3ptr, float* tmp1, float* tmp2,
-                                     float* output, int seq, int fin, int fmid, int fout, void* workspace,
-                                     Epi_args1 epi_args1, Epi_args2 epi_args2) {
+void bestla_fusion_ffn_f32f32_forward(float* activation, void* w1ptr, void* w2ptr, void* w3ptr, float* tmp1,
+                                      float* tmp2, float* output, int seq, int fin, int fmid, int fout, void* workspace,
+                                      Epi_args1 epi_args1, Epi_args2 epi_args2) {
   GetCPUDevice();
-  auto pth = ne_jblas::ne_threading::get();
-  auto ptr1 = jblas::storage::gemm::PackedWeightParser::deserialBuffer(w1ptr);
-  auto ptr2 = jblas::storage::gemm::PackedWeightParser::deserialBuffer(w2ptr);
-  auto ptr3 = jblas::storage::gemm::PackedWeightParser::deserialBuffer(w3ptr);
+  auto pth = ne_threading::get();
+  auto ptr1 = storage::gemm::PackedWeightParser::deserialBuffer(w1ptr);
+  auto ptr2 = storage::gemm::PackedWeightParser::deserialBuffer(w2ptr);
+  auto ptr3 = storage::gemm::PackedWeightParser::deserialBuffer(w3ptr);
   auto _workspace = reinterpret_cast<int8_t*>(workspace);
   if (ptr1) {
     auto coretype = ptr1->mCoreId;
-    auto NTile = jblas::gemm::CoreAttr::get_mask_val(ptr1->mCoreId, jblas::gemm::CoreAttr::NTILE_MASK,
-                                                     jblas::gemm::CoreAttr::NTILE_SHIFT);
-    auto PackRow = jblas::gemm::CoreAttr::get_packrow(ptr1->mCoreId);
-    auto CType = jblas::gemm::CoreAttr::get_comp(ptr1->mCoreId);
-    auto btype = static_cast<jblas::gemm::CompType>(jblas::gemm::CompTypeHelper::get_B(CType));
-    if (ptr1->mPrologueID == JBLAS_PROLOGUEB_IDS::WeightKBlockNInteger) {
-      auto bptr = reinterpret_cast<jblas::storage::gemm::IWeightKBlockBase*>(ptr1);
+    auto NTile = gemm::CoreAttr::get_mask_val(ptr1->mCoreId, gemm::CoreAttr::NTILE_MASK, gemm::CoreAttr::NTILE_SHIFT);
+    auto PackRow = gemm::CoreAttr::get_packrow(ptr1->mCoreId);
+    auto CType = gemm::CoreAttr::get_comp(ptr1->mCoreId);
+    auto btype = static_cast<gemm::CompType>(gemm::CompTypeHelper::get_B(CType));
+    if (ptr1->mPrologueID == BTLA_PROLOGUEB_IDS::WeightKBlockNInteger) {
+      auto bptr = reinterpret_cast<storage::gemm::IWeightKBlockBase*>(ptr1);
       auto BlkSize = bptr->mBlockSize;
-      if (btype == jblas::gemm::CompType::tFP32 && PackRow == 1) {
+      if (btype == gemm::CompType::tFP32 && PackRow == 1) {
         if (NTile == tAVX512F::NTILE && _cd->AVX512F() && BlkSize % tAVX512F::KTILE == 0) {
-          JblasGemmCompF32<tAVX512F, tWeiNInt, tActKBaseF32, epilogue1, epilogue2>(
+          BTLAGemmCompF32<tAVX512F, tWeiNInt, tActKBaseF32, epilogue1, epilogue2>(
               activation, ptr1, ptr2, ptr3, tmp1, tmp2, output, seq, fin, fmid, fout, workspace, pth, epi_args1,
               epi_args2);
         } else if (NTile == tAVX2::NTILE && _cd->AVX2() && BlkSize % tAVX2::KTILE == 0) {
-          JblasGemmCompF32<tAVX2, tWeiNInt, tActKBaseF32, epilogue1, epilogue2>(activation, ptr1, ptr2, ptr3, tmp1,
+          BTLAGemmCompF32<tAVX2, tWeiNInt, tActKBaseF32, epilogue1, epilogue2>(activation, ptr1, ptr2, ptr3, tmp1,
                                                                                 tmp2, output, seq, fin, fmid, fout,
                                                                                 workspace, pth, epi_args1, epi_args2);
         }
       }
-      if (btype == jblas::gemm::CompType::tBF16 && PackRow == 2) {
+      if (btype == gemm::CompType::tBF16 && PackRow == 2) {
         if (NTile == tAMX_BF16::NTILE && _cd->AMX_BF16() && BlkSize % tAMX_BF16::KTILE == 0) {
           if (seq <= tAVX512_BF16::MTILE) {
             static_assert(tAVX512_BF16::NTILE == tAMX_BF16::NTILE);
-            JblasGemmCompF32<tAVX512_BF16, tWeiNInt, tActKBaseF32, epilogue1, epilogue2>(
+            BTLAGemmCompF32<tAVX512_BF16, tWeiNInt, tActKBaseF32, epilogue1, epilogue2>(
                 activation, ptr1, ptr2, ptr3, tmp1, tmp2, output, seq, fin, fmid, fout, workspace, pth, epi_args1,
                 epi_args2);
           } else {
-            JblasGemmCompF32<tAMX_BF16, tWeiNInt, tActKBaseF32, epilogue1, epilogue2>(
+            BTLAGemmCompF32<tAMX_BF16, tWeiNInt, tActKBaseF32, epilogue1, epilogue2>(
                 activation, ptr1, ptr2, ptr3, tmp1, tmp2, output, seq, fin, fmid, fout, workspace, pth, epi_args1,
                 epi_args2);
           }
         }
       }
-      if (btype == jblas::gemm::CompType::tS8 && PackRow == 4) {
+      if (btype == gemm::CompType::tS8 && PackRow == 4) {
         if (NTile == tAMX_INT8_SS_KBlock::NTILE && _cd->AMX_INT8() && BlkSize % tAMX_INT8_SS_KBlock::KTILE == 0) {
           if (seq <= tAVX512_VNNI_KBlock::MTILE) {
             static_assert(tAVX512_VNNI_KBlock::NTILE == tAMX_INT8_SS_KBlock::NTILE);
-            JblasGemmCompInt8<tAVX512_VNNI_KBlock, tWeiNInt, epilogue1, epilogue2>(
+            BTLAGemmCompInt8<tAVX512_VNNI_KBlock, tWeiNInt, epilogue1, epilogue2>(
                 activation, ptr1, ptr2, ptr3, tmp1, tmp2, output, seq, fin, fmid, fout, workspace, pth, epi_args1,
                 epi_args2);
           } else {
-            JblasGemmCompInt8<tAMX_INT8_SS_KBlock, tWeiNInt, epilogue1, epilogue2>(
+            BTLAGemmCompInt8<tAMX_INT8_SS_KBlock, tWeiNInt, epilogue1, epilogue2>(
                 activation, ptr1, ptr2, ptr3, tmp1, tmp2, output, seq, fin, fmid, fout, workspace, pth, epi_args1,
                 epi_args2);
           }
 
         } else if (NTile == tAVX512_VNNI_KBlock::NTILE && _cd->AVX512_VNNI() &&
                    BlkSize % tAVX512_VNNI_KBlock::KTILE == 0) {
-          JblasGemmCompInt8<tAVX512_VNNI_KBlock, tWeiNInt, epilogue1, epilogue2>(activation, ptr1, ptr2, ptr3, tmp1,
+          BTLAGemmCompInt8<tAVX512_VNNI_KBlock, tWeiNInt, epilogue1, epilogue2>(activation, ptr1, ptr2, ptr3, tmp1,
                                                                                  tmp2, output, seq, fin, fmid, fout,
                                                                                  workspace, pth, epi_args1, epi_args2);
         } else if (NTile == tAVX_VNNI_KBlock::NTILE && _cd->AVX_VNNI() && BlkSize % tAVX_VNNI_KBlock::KTILE == 0) {
-          JblasGemmCompInt8<tAVX_VNNI_KBlock, tWeiNInt, epilogue1, epilogue2>(activation, ptr1, ptr2, ptr3, tmp1, tmp2,
+          BTLAGemmCompInt8<tAVX_VNNI_KBlock, tWeiNInt, epilogue1, epilogue2>(activation, ptr1, ptr2, ptr3, tmp1, tmp2,
                                                                               output, seq, fin, fmid, fout, workspace,
                                                                               pth, epi_args1, epi_args2);
         }
       }
     }
-    if (ptr1->mPrologueID == JBLAS_PROLOGUEB_IDS::WeightKBlockNFloat) {
-      auto bptr = reinterpret_cast<jblas::storage::gemm::IWeightKBlockBase*>(ptr1);
+    if (ptr1->mPrologueID == BTLA_PROLOGUEB_IDS::WeightKBlockNFloat) {
+      auto bptr = reinterpret_cast<storage::gemm::IWeightKBlockBase*>(ptr1);
       auto BlkSize = bptr->mBlockSize;
-      if (btype == jblas::gemm::CompType::tFP32 && PackRow == 1) {
+      if (btype == gemm::CompType::tFP32 && PackRow == 1) {
         if (NTile == tAVX512F::NTILE && _cd->AVX512F() && BlkSize % tAVX512F::KTILE == 0) {
-          JblasGemmCompF32<tAVX512F, tWeiNFloat, tActKBaseF32, epilogue1, epilogue2>(
+          BTLAGemmCompF32<tAVX512F, tWeiNFloat, tActKBaseF32, epilogue1, epilogue2>(
               activation, ptr1, ptr2, ptr3, tmp1, tmp2, output, seq, fin, fmid, fout, workspace, pth, epi_args1,
               epi_args2);
         } else if (NTile == tAVX2::NTILE && _cd->AVX2() && BlkSize % tAVX2::KTILE == 0) {
-          JblasGemmCompF32<tAVX2, tWeiNFloat, tActKBaseF32, epilogue1, epilogue2>(activation, ptr1, ptr2, ptr3, tmp1,
+          BTLAGemmCompF32<tAVX2, tWeiNFloat, tActKBaseF32, epilogue1, epilogue2>(activation, ptr1, ptr2, ptr3, tmp1,
                                                                                   tmp2, output, seq, fin, fmid, fout,
                                                                                   workspace, pth, epi_args1, epi_args2);
         }
       }
-      if (btype == jblas::gemm::CompType::tBF16 && PackRow == 2) {
+      if (btype == gemm::CompType::tBF16 && PackRow == 2) {
         if (NTile == tAMX_BF16::NTILE && _cd->AMX_BF16() && BlkSize % tAMX_BF16::KTILE == 0) {
           if (seq <= tAVX512_BF16::MTILE) {
             static_assert(tAVX512_BF16::NTILE == tAMX_BF16::NTILE);
-            JblasGemmCompF32<tAVX512_BF16, tWeiNFloat, tActKBaseF32, epilogue1, epilogue2>(
+            BTLAGemmCompF32<tAVX512_BF16, tWeiNFloat, tActKBaseF32, epilogue1, epilogue2>(
                 activation, ptr1, ptr2, ptr3, tmp1, tmp2, output, seq, fin, fmid, fout, workspace, pth, epi_args1,
                 epi_args2);
           } else {
-            JblasGemmCompF32<tAMX_BF16, tWeiNFloat, tActKBaseF32, epilogue1, epilogue2>(
+            BTLAGemmCompF32<tAMX_BF16, tWeiNFloat, tActKBaseF32, epilogue1, epilogue2>(
                 activation, ptr1, ptr2, ptr3, tmp1, tmp2, output, seq, fin, fmid, fout, workspace, pth, epi_args1,
                 epi_args2);
           }
@@ -684,43 +683,44 @@ void jblas_fusion_ffn_f32f32_forward(float* activation, void* w1ptr, void* w2ptr
 }
 }  // namespace ffn_3w
 
-bool jblas_fusion_FFN_SiLu_f32f32_support(void* w1ptr, void* w2ptr, void* w3ptr, int seq, int fin, int fmid, int fout) {
-  return ffn_3w::jblas_fusion_ffn_f32f32_support(w1ptr, w2ptr, w3ptr, seq, fin, fmid, fout);
+bool bestla_fusion_FFN_SiLu_f32f32_support(void* w1ptr, void* w2ptr, void* w3ptr, int seq, int fin, int fmid,
+                                           int fout) {
+  return ffn_3w::bestla_fusion_ffn_f32f32_support(w1ptr, w2ptr, w3ptr, seq, fin, fmid, fout);
 }
 
-void jblas_fusion_FFN_SiLu_f32f32_forward(float* activation, void* w1ptr, void* w2ptr, void* w3ptr, float* tmp1,
-                                          float* tmp2, float* output, int seq, int fin, int fmid, int fout,
-                                          void* workspace) {
+void bestla_fusion_FFN_SiLu_f32f32_forward(float* activation, void* w1ptr, void* w2ptr, void* w3ptr, float* tmp1,
+                                           float* tmp2, float* output, int seq, int fin, int fmid, int fout,
+                                           void* workspace) {
   float silu_alpha = -1.0f;
-  jblas::epilogue::gemm::ParamAccumulatorWriteBack<float> epi_args1 = {tmp1, fmid, &silu_alpha};
-  jblas::epilogue::gemm::ParamAccumulatorWriteBack<float> epi_args2 = {output, fout};
-  ffn_3w::jblas_fusion_ffn_f32f32_forward<jblas::epilogue::gemm::AccumulatorWriteBackWithSwishFp32,
-                                          jblas::epilogue::gemm::AccumulatorWriteBackFp32>(
+  epilogue::gemm::ParamAccumulatorWriteBack<float> epi_args1 = {tmp1, fmid, &silu_alpha};
+  epilogue::gemm::ParamAccumulatorWriteBack<float> epi_args2 = {output, fout};
+  ffn_3w::bestla_fusion_ffn_f32f32_forward<epilogue::gemm::AccumulatorWriteBackWithSwishFp32,
+                                           epilogue::gemm::AccumulatorWriteBackFp32>(
       activation, w1ptr, w2ptr, w3ptr, tmp1, tmp2, output, seq, fin, fmid, fout, workspace, epi_args1, epi_args2);
 }
 
-bool jblas_fusion_FFN_GeLu_f32f32_support(void* w1ptr, void* w2ptr, int seq, int fin, int fmid, int fout) {
-  return ffn_2w::jblas_fusion_ffn_f32f32_support(w1ptr, w2ptr, seq, fin, fmid, fout);
+bool bestla_fusion_FFN_GeLu_f32f32_support(void* w1ptr, void* w2ptr, int seq, int fin, int fmid, int fout) {
+  return ffn_2w::bestla_fusion_ffn_f32f32_support(w1ptr, w2ptr, seq, fin, fmid, fout);
 }
 
-void jblas_fusion_FFN_GeLu_f32f32_forward(float* activation, void* w1ptr, void* w2ptr, float* tmp1, float* output,
-                                          int seq, int fin, int fmid, int fout, void* workspace) {
-  jblas::epilogue::gemm::ParamAccumulatorWriteBack<float> epi_args1 = {tmp1, fmid, nullptr};
-  jblas::epilogue::gemm::ParamAccumulatorWriteBack<float> epi_args2 = {output, fout};
-  ffn_2w::jblas_fusion_ffn_f32f32_forward<jblas::epilogue::gemm::AccumulatorWriteBackWithGeluFp32,
-                                          jblas::epilogue::gemm::AccumulatorWriteBackFp32>(
+void bestla_fusion_FFN_GeLu_f32f32_forward(float* activation, void* w1ptr, void* w2ptr, float* tmp1, float* output,
+                                           int seq, int fin, int fmid, int fout, void* workspace) {
+  epilogue::gemm::ParamAccumulatorWriteBack<float> epi_args1 = {tmp1, fmid, nullptr};
+  epilogue::gemm::ParamAccumulatorWriteBack<float> epi_args2 = {output, fout};
+  ffn_2w::bestla_fusion_ffn_f32f32_forward<epilogue::gemm::AccumulatorWriteBackWithGeluFp32,
+                                           epilogue::gemm::AccumulatorWriteBackFp32>(
       activation, w1ptr, w2ptr, tmp1, output, seq, fin, fmid, fout, workspace, epi_args1, epi_args2);
 }
 
-bool jblas_fusion_FFN_Add_GeLu_f32f32_support(void* w1ptr, void* w2ptr, int seq, int fin, int fmid, int fout) {
-  return ffn_2w::jblas_fusion_ffn_f32f32_support(w1ptr, w2ptr, seq, fin, fmid, fout);
+bool bestla_fusion_FFN_Add_GeLu_f32f32_support(void* w1ptr, void* w2ptr, int seq, int fin, int fmid, int fout) {
+  return ffn_2w::bestla_fusion_ffn_f32f32_support(w1ptr, w2ptr, seq, fin, fmid, fout);
 }
 
-void jblas_fusion_FFN_Add_GeLu_f32f32_forward(float* activation, void* w1ptr, void* w2ptr, float* b1ptr, float* b2ptr,
-                                              float* tmp1, float* output, int seq, int fin, int fmid, int fout,
-                                              bool broadcast_bias, void* workspace) {
+void bestla_fusion_FFN_Add_GeLu_f32f32_forward(float* activation, void* w1ptr, void* w2ptr, float* b1ptr, float* b2ptr,
+                                               float* tmp1, float* output, int seq, int fin, int fmid, int fout,
+                                               bool broadcast_bias, void* workspace) {
   custom::epilogue::ParamAdd_Gelu<float> epi_args1 = {tmp1, b1ptr, fmid, broadcast_bias ? 0 : fmid};
   custom::epilogue::ParamAdd<float> epi_args2 = {output, b2ptr, fout, broadcast_bias ? 0 : fout};
-  ffn_2w::jblas_fusion_ffn_f32f32_forward<custom::epilogue::Add_GeluFp32, custom::epilogue::AddFp32>(
+  ffn_2w::bestla_fusion_ffn_f32f32_forward<custom::epilogue::Add_GeluFp32, custom::epilogue::AddFp32>(
       activation, w1ptr, w2ptr, tmp1, output, seq, fin, fmid, fout, workspace, epi_args1, epi_args2);
 }
diff --git a/neural_speed/core/layers/ip_fusion_qkv.cpp b/neural_speed/core/layers/ip_fusion_qkv.cpp
index 9ba39d188..9cbfb1244 100644
--- a/neural_speed/core/layers/ip_fusion_qkv.cpp
+++ b/neural_speed/core/layers/ip_fusion_qkv.cpp
@@ -12,10 +12,10 @@
 //  See the License for the specific language governing permissions and
 //  limitations under the License.
 
-#include "jblas_common.hpp"
+#include "bestla_common.hpp"
 
-using namespace jblas;     // NOLINT
-using namespace ne_jblas;  // NOLINT
+using namespace bestla;     // NOLINT
+using namespace ne_bestla;  // NOLINT
 
 namespace ip_qkv {
 
@@ -69,13 +69,12 @@ void GemmRunWithA_QKV(Launch_T* launcher, const typename Launch_T::Param* args,
   });
 }
 
-template <class GemmCore_T, template <class, JBLAS_ISA> class Wei_T>
-void JblasGemmCompF32(const int M, const int N, const int K, const float* A, const int lda,
-                      jblas::storage::gemm::IWeightBase* _BQ, jblas::storage::gemm::IWeightBase* _BK,
-                      jblas::storage::gemm::IWeightBase* _BV, float* C, const int ldc, int8_t* WorkSpace,
-                      jblas::parallel::IThreading* th) {
+template <class GemmCore_T, template <class, BTLA_ISA> class Wei_T>
+void BTLAGemmCompF32(const int M, const int N, const int K, const float* A, const int lda,
+                      storage::gemm::IWeightBase* _BQ, storage::gemm::IWeightBase* _BK, storage::gemm::IWeightBase* _BV,
+                      float* C, const int ldc, int8_t* WorkSpace, parallel::IThreading* th) {
   if (M <= 16) {
-    using Parallel = jblas::parallel::gemm::SchedulerKBlock<GemmCore_T>;
+    using Parallel = parallel::gemm::SchedulerKBlock<GemmCore_T>;
     using Launcher = tLauncher_Fp_F32F32<GemmCore_T, Wei_T>;
     static Launcher kernel;
     auto BQ = reinterpret_cast<typename Launcher::PrologueB::StorageWeight*>(_BQ);
@@ -108,10 +107,10 @@ void JblasGemmCompF32(const int M, const int N, const int K, const float* A, con
       GemmRun_QKV<Parallel>(&kernel, args, th);
     }
   } else {
-    using Parallel = jblas::parallel::gemm::SchedulerBase<GemmCore_T>;
-    using Launcher = jblas::wrapper::gemm::LauncherBase<GemmCore_T::ISA, GemmCore_T,
-                                                        jblas::prologue_a::gemm::ShuffleActivationKBlockBaseF32, Wei_T,
-                                                        jblas::epilogue::gemm::AccumulatorWriteBackFp32>;
+    using Parallel = parallel::gemm::SchedulerBase<GemmCore_T>;
+    using Launcher =
+        wrapper::gemm::LauncherBase<GemmCore_T::ISA, GemmCore_T, prologue_a::gemm::ShuffleActivationKBlockBaseF32,
+                                    Wei_T, epilogue::gemm::AccumulatorWriteBackFp32>;
     static Launcher kernel;
     auto BQ = reinterpret_cast<typename Launcher::PrologueB::StorageWeight*>(_BQ);
     auto BK = reinterpret_cast<typename Launcher::PrologueB::StorageWeight*>(_BK);
@@ -130,12 +129,12 @@ void JblasGemmCompF32(const int M, const int N, const int K, const float* A, con
   }
 }
 
-template <class GemmCore_T, template <class, JBLAS_ISA> class Wei_T>
-void JblasGemmCompInt8(const int M, const int N, const int K, const float* A, const int lda,
-                       jblas::storage::gemm::IWeightBase* _BQ, jblas::storage::gemm::IWeightBase* _BK,
-                       jblas::storage::gemm::IWeightBase* _BV, float* C, const int ldc, int8_t* WorkSpace,
-                       jblas::parallel::IThreading* th) {
-  using Parallel = jblas::parallel::gemm::SchedulerKBlockS<GemmCore_T>;
+template <class GemmCore_T, template <class, BTLA_ISA> class Wei_T>
+void BTLAGemmCompInt8(const int M, const int N, const int K, const float* A, const int lda,
+                       storage::gemm::IWeightBase* _BQ, storage::gemm::IWeightBase* _BK,
+                       storage::gemm::IWeightBase* _BV, float* C, const int ldc, int8_t* WorkSpace,
+                       parallel::IThreading* th) {
+  using Parallel = parallel::gemm::SchedulerKBlockS<GemmCore_T>;
   using Launcher = tLauncher_Int8_F32F32<GemmCore_T, Wei_T>;
   auto BQ = reinterpret_cast<typename Launcher::PrologueB::StorageWeight*>(_BQ);
   auto BK = reinterpret_cast<typename Launcher::PrologueB::StorageWeight*>(_BK);
@@ -153,7 +152,7 @@ void JblasGemmCompInt8(const int M, const int N, const int K, const float* A, co
 }
 }  // namespace ip_qkv
 
-unsigned long long jblas_fusion_QKV_f32f32_get_workspace_size(int _m, int _n, int _k, void* w1ptr) {  // NOLINT
+unsigned long long bestla_fusion_QKV_f32f32_get_workspace_size(int _m, int _n, int _k, void* w1ptr) {  // NOLINT
   // maximum padding
   // we can parse w1ptr to get a accurate size, but not necessary
   int constexpr padding = 128;
@@ -161,24 +160,24 @@ unsigned long long jblas_fusion_QKV_f32f32_get_workspace_size(int _m, int _n, in
   return s;
 }
 
-bool jblas_fusion_QKV_f32f32_support(void* wqptr, void* wkptr, void* wvptr, int _m, int _n, int _k) {
+bool bestla_fusion_QKV_f32f32_support(void* wqptr, void* wkptr, void* wvptr, int _m, int _n, int _k) {
   GetCPUDevice();
   bool support = false;
-  auto wqtmp = jblas::storage::gemm::PackedWeightParser::deserialBuffer(wqptr);
-  auto wktmp = jblas::storage::gemm::PackedWeightParser::deserialBuffer(wkptr);
-  auto wvtmp = jblas::storage::gemm::PackedWeightParser::deserialBuffer(wvptr);
+  auto wqtmp = storage::gemm::PackedWeightParser::deserialBuffer(wqptr);
+  auto wktmp = storage::gemm::PackedWeightParser::deserialBuffer(wkptr);
+  auto wvtmp = storage::gemm::PackedWeightParser::deserialBuffer(wvptr);
   if (wqtmp && wktmp && wvtmp) {
     storage::gemm::IWeightBase* wset[] = {wqtmp, wktmp, wvtmp};
     if (samePackedWeight(wset, 3)) {
-      if (wqtmp->mPrologueID == JBLAS_PROLOGUEB_IDS::WeightKBlockNInteger) {
-        auto wqptr = reinterpret_cast<jblas::storage::gemm::StorageWeightKBlockNInteger*>(wqtmp);
+      if (wqtmp->mPrologueID == BTLA_PROLOGUEB_IDS::WeightKBlockNInteger) {
+        auto wqptr = reinterpret_cast<storage::gemm::StorageWeightKBlockNInteger*>(wqtmp);
         if (wqptr->ShfIndice()) {
           return false;  // Do not support QKV fusion for activation shuffle
         }
         constexpr size_t EleNum = sizeof(AllKBlockCores) / sizeof(AllKBlockCores[0]);
         support = contains(wqtmp->mCoreId, AllKBlockCores, EleNum);
         support &= hasISA(AllKBlockCores, EleNum);
-      } else if (wqtmp->mPrologueID == JBLAS_PROLOGUEB_IDS::WeightKBlockNFloat) {
+      } else if (wqtmp->mPrologueID == BTLA_PROLOGUEB_IDS::WeightKBlockNFloat) {
         constexpr size_t EleNum = sizeof(FloatCores) / sizeof(FloatCores[0]);
         support = contains(wqtmp->mCoreId, FloatCores, EleNum);
         support &= hasISA(FloatCores, EleNum);
@@ -192,8 +191,8 @@ bool jblas_fusion_QKV_f32f32_support(void* wqptr, void* wkptr, void* wvptr, int
 }
 
 // f32f32: activation & output dtype
-void jblas_fusion_QKV_f32f32_forward(float* activation, void* wqptr, void* wkptr, void* wvptr, float* output, int _m,
-                                     int _n, int _k, int lda, int ldo, void* _workspace) {
+void bestla_fusion_QKV_f32f32_forward(float* activation, void* wqptr, void* wkptr, void* wvptr, float* output, int _m,
+                                      int _n, int _k, int lda, int ldo, void* _workspace) {
   GetCPUDevice();
   auto wqtmp = storage::gemm::PackedWeightParser::deserialBuffer(wqptr);
   auto wktmp = storage::gemm::PackedWeightParser::deserialBuffer(wkptr);
@@ -201,78 +200,77 @@ void jblas_fusion_QKV_f32f32_forward(float* activation, void* wqptr, void* wkptr
   // must check support before forward, there is no need to check support twice.
   auto ptr = wqtmp;
   auto coretype = ptr->mCoreId;
-  auto NTile = jblas::gemm::CoreAttr::get_mask_val(ptr->mCoreId, jblas::gemm::CoreAttr::NTILE_MASK,
-                                                   jblas::gemm::CoreAttr::NTILE_SHIFT);
-  auto PackRow = jblas::gemm::CoreAttr::get_packrow(ptr->mCoreId);
-  auto CType = jblas::gemm::CoreAttr::get_comp(ptr->mCoreId);
-  auto btype = static_cast<jblas::gemm::CompType>(jblas::gemm::CompTypeHelper::get_B(CType));
-  auto pth = ne_jblas::ne_threading::get();
+  auto NTile = gemm::CoreAttr::get_mask_val(ptr->mCoreId, gemm::CoreAttr::NTILE_MASK, gemm::CoreAttr::NTILE_SHIFT);
+  auto PackRow = gemm::CoreAttr::get_packrow(ptr->mCoreId);
+  auto CType = gemm::CoreAttr::get_comp(ptr->mCoreId);
+  auto btype = static_cast<gemm::CompType>(gemm::CompTypeHelper::get_B(CType));
+  auto pth = ne_bestla::ne_threading::get();
   auto workspace = reinterpret_cast<int8_t*>(_workspace);
-  if (ptr->mPrologueID == JBLAS_PROLOGUEB_IDS::WeightKBlockNInteger) {
-    auto bptr = reinterpret_cast<jblas::storage::gemm::IWeightKBlockBase*>(ptr);
+  if (ptr->mPrologueID == BTLA_PROLOGUEB_IDS::WeightKBlockNInteger) {
+    auto bptr = reinterpret_cast<storage::gemm::IWeightKBlockBase*>(ptr);
     auto BlkSize = bptr->mBlockSize;
-    if (btype == jblas::gemm::CompType::tFP32 && PackRow == 1) {
+    if (btype == gemm::CompType::tFP32 && PackRow == 1) {
       if (NTile == tAVX512F::NTILE && _cd->AVX512F() && BlkSize % tAVX512F::KTILE == 0) {
-        ip_qkv::JblasGemmCompF32<tAVX512F, tWeiNInt>(_m, _n, _k, activation, lda, wqtmp, wktmp, wvtmp, output, ldo,
+        ip_qkv::BTLAGemmCompF32<tAVX512F, tWeiNInt>(_m, _n, _k, activation, lda, wqtmp, wktmp, wvtmp, output, ldo,
                                                      workspace, pth);
       } else if (NTile == tAVX2::NTILE && _cd->AVX2() && BlkSize % tAVX2::KTILE == 0) {
-        ip_qkv::JblasGemmCompF32<tAVX2, tWeiNInt>(_m, _n, _k, activation, lda, wqtmp, wktmp, wvtmp, output, ldo,
+        ip_qkv::BTLAGemmCompF32<tAVX2, tWeiNInt>(_m, _n, _k, activation, lda, wqtmp, wktmp, wvtmp, output, ldo,
                                                   workspace, pth);
       }
     }
-    if (btype == jblas::gemm::CompType::tBF16 && PackRow == 2) {
+    if (btype == gemm::CompType::tBF16 && PackRow == 2) {
       if (NTile == tAMX_BF16::NTILE && _cd->AMX_BF16() && BlkSize % tAMX_BF16::KTILE == 0) {
         if (_m <= tAVX512_BF16::MTILE) {
           static_assert(tAVX512_BF16::NTILE == tAMX_BF16::NTILE);
-          ip_qkv::JblasGemmCompF32<tAVX512_BF16, tWeiNInt>(_m, _n, _k, activation, lda, wqtmp, wktmp, wvtmp, output,
+          ip_qkv::BTLAGemmCompF32<tAVX512_BF16, tWeiNInt>(_m, _n, _k, activation, lda, wqtmp, wktmp, wvtmp, output,
                                                            ldo, workspace, pth);
         } else {
-          ip_qkv::JblasGemmCompF32<tAMX_BF16, tWeiNInt>(_m, _n, _k, activation, lda, wqtmp, wktmp, wvtmp, output, ldo,
+          ip_qkv::BTLAGemmCompF32<tAMX_BF16, tWeiNInt>(_m, _n, _k, activation, lda, wqtmp, wktmp, wvtmp, output, ldo,
                                                         workspace, pth);
         }
       }
     }
-    if (btype == jblas::gemm::CompType::tS8 && PackRow == 4) {
+    if (btype == gemm::CompType::tS8 && PackRow == 4) {
       if (NTile == tAMX_INT8_SS_KBlock::NTILE && _cd->AMX_INT8() && BlkSize % tAMX_INT8_SS_KBlock::KTILE == 0) {
         if (_m <= tAVX512_VNNI_KBlock::MTILE) {
           static_assert(tAVX512_VNNI_KBlock::NTILE == tAMX_INT8_SS_KBlock::NTILE);
-          ip_qkv::JblasGemmCompInt8<tAVX512_VNNI_KBlock, tWeiNInt>(_m, _n, _k, activation, lda, wqtmp, wktmp, wvtmp,
+          ip_qkv::BTLAGemmCompInt8<tAVX512_VNNI_KBlock, tWeiNInt>(_m, _n, _k, activation, lda, wqtmp, wktmp, wvtmp,
                                                                    output, ldo, workspace, pth);
         } else {
-          ip_qkv::JblasGemmCompInt8<tAMX_INT8_SS_KBlock, tWeiNInt>(_m, _n, _k, activation, lda, wqtmp, wktmp, wvtmp,
+          ip_qkv::BTLAGemmCompInt8<tAMX_INT8_SS_KBlock, tWeiNInt>(_m, _n, _k, activation, lda, wqtmp, wktmp, wvtmp,
                                                                    output, ldo, workspace, pth);
         }
 
       } else if (NTile == tAVX512_VNNI_KBlock::NTILE && _cd->AVX512_VNNI() &&
                  BlkSize % tAVX512_VNNI_KBlock::KTILE == 0) {
-        ip_qkv::JblasGemmCompInt8<tAVX512_VNNI_KBlock, tWeiNInt>(_m, _n, _k, activation, lda, wqtmp, wktmp, wvtmp,
+        ip_qkv::BTLAGemmCompInt8<tAVX512_VNNI_KBlock, tWeiNInt>(_m, _n, _k, activation, lda, wqtmp, wktmp, wvtmp,
                                                                  output, ldo, workspace, pth);
       } else if (NTile == tAVX_VNNI_KBlock::NTILE && _cd->AVX_VNNI() && BlkSize % tAVX_VNNI_KBlock::KTILE == 0) {
-        ip_qkv::JblasGemmCompInt8<tAVX_VNNI_KBlock, tWeiNInt>(_m, _n, _k, activation, lda, wqtmp, wktmp, wvtmp, output,
+        ip_qkv::BTLAGemmCompInt8<tAVX_VNNI_KBlock, tWeiNInt>(_m, _n, _k, activation, lda, wqtmp, wktmp, wvtmp, output,
                                                               ldo, workspace, pth);
       }
     }
   }
-  if (ptr->mPrologueID == JBLAS_PROLOGUEB_IDS::WeightKBlockNFloat) {
-    auto bptr = reinterpret_cast<jblas::storage::gemm::IWeightKBlockBase*>(ptr);
+  if (ptr->mPrologueID == BTLA_PROLOGUEB_IDS::WeightKBlockNFloat) {
+    auto bptr = reinterpret_cast<storage::gemm::IWeightKBlockBase*>(ptr);
     auto BlkSize = bptr->mBlockSize;
-    if (btype == jblas::gemm::CompType::tFP32 && PackRow == 1) {
+    if (btype == gemm::CompType::tFP32 && PackRow == 1) {
       if (NTile == tAVX512F::NTILE && _cd->AVX512F() && BlkSize % tAVX512F::KTILE == 0) {
-        ip_qkv::JblasGemmCompF32<tAVX512F, tWeiNFloat>(_m, _n, _k, activation, lda, wqtmp, wktmp, wvtmp, output, ldo,
+        ip_qkv::BTLAGemmCompF32<tAVX512F, tWeiNFloat>(_m, _n, _k, activation, lda, wqtmp, wktmp, wvtmp, output, ldo,
                                                        workspace, pth);
       } else if (NTile == tAVX2::NTILE && _cd->AVX2() && BlkSize % tAVX2::KTILE == 0) {
-        ip_qkv::JblasGemmCompF32<tAVX2, tWeiNFloat>(_m, _n, _k, activation, lda, wqtmp, wktmp, wvtmp, output, ldo,
+        ip_qkv::BTLAGemmCompF32<tAVX2, tWeiNFloat>(_m, _n, _k, activation, lda, wqtmp, wktmp, wvtmp, output, ldo,
                                                     workspace, pth);
       }
     }
-    if (btype == jblas::gemm::CompType::tBF16 && PackRow == 2) {
+    if (btype == gemm::CompType::tBF16 && PackRow == 2) {
       if (NTile == tAMX_BF16::NTILE && _cd->AMX_BF16() && BlkSize % tAMX_BF16::KTILE == 0) {
         if (_m <= tAVX512_BF16::MTILE) {
           static_assert(tAVX512_BF16::NTILE == tAMX_BF16::NTILE);
-          ip_qkv::JblasGemmCompF32<tAVX512_BF16, tWeiNFloat>(_m, _n, _k, activation, lda, wqtmp, wktmp, wvtmp, output,
+          ip_qkv::BTLAGemmCompF32<tAVX512_BF16, tWeiNFloat>(_m, _n, _k, activation, lda, wqtmp, wktmp, wvtmp, output,
                                                              ldo, workspace, pth);
         } else {
-          ip_qkv::JblasGemmCompF32<tAMX_BF16, tWeiNFloat>(_m, _n, _k, activation, lda, wqtmp, wktmp, wvtmp, output, ldo,
+          ip_qkv::BTLAGemmCompF32<tAMX_BF16, tWeiNFloat>(_m, _n, _k, activation, lda, wqtmp, wktmp, wvtmp, output, ldo,
                                                           workspace, pth);
         }
       }
diff --git a/neural_speed/core/layers/jblas_defs.h b/neural_speed/core/layers/jblas_defs.h
deleted file mode 100644
index 6e5ddf481..000000000
--- a/neural_speed/core/layers/jblas_defs.h
+++ /dev/null
@@ -1,68 +0,0 @@
-//  Copyright (c) 2023 Intel Corporation
-//
-//  Licensed under the Apache License, Version 2.0 (the "License");
-//  you may not use this file except in compliance with the License.
-//  You may obtain a copy of the License at
-//
-//    http://www.apache.org/licenses/LICENSE-2.0
-//
-//  Unless required by applicable law or agreed to in writing, software
-//  distributed under the License is distributed on an "AS IS" BASIS,
-//  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.
-
-#pragma once
-#include "jblas/jit_blas_prologue_b.h"
-#include "jblas/jit_blas_wrapper.h"
-
-namespace jblas {
-template <class GemmCore_T, template <class, JBLAS_ISA> class Wei_T>
-using tLauncher_Fp_F32F32 = jblas::wrapper::gemm::LauncherKBlock<
-    GemmCore_T::ISA, GemmCore_T, jblas::prologue_a::gemm::ShuffleActivationKBlockBaseF32, Wei_T,
-    jblas::epilogue::gemm::CompFp32BlockEpilogue, jblas::epilogue::gemm::AccumulatorWriteBackFp32>;
-
-template <class GemmCore_T, template <class, JBLAS_ISA> class Wei_T>
-using tLauncher_Int8_F32F32 =
-    jblas::wrapper::gemm::LauncherIntKBlock<GemmCore_T::ISA, GemmCore_T,
-                                            jblas::prologue_a::gemm::ShuffleActivationKBlockQuantizeF32, Wei_T,
-                                            jblas::epilogue::gemm::AccumulatorWriteBackFp32>;
-
-using tAVX2 = jblas::gemm::SCoreRowNAvx2<24, 4>;
-using tAVX_VNNI = jblas::gemm::ICoreRowNAvxvnni<24, 4>;
-using tAVX512F = jblas::gemm::SCoreRowNAvx512f<48, 8>;
-using tAVX512_VNNI = jblas::gemm::ICoreRowNAvx512vnni<48, 8>;
-using tAMX_BF16 = jblas::gemm::HCoreRowNAmxbf16<48, 16>;
-using tAVX512_BF16 = jblas::gemm::HCoreRowNAvx512bf16<48, 8>;
-using tAVX512_FP16 = jblas::gemm::HCoreRowNAvx512fp16<96, 8>;
-using tAMX_INT8_US = jblas::gemm::ICoreRowNAmxint8<48, 16>;
-using tAMX_INT8_SS = jblas::gemm::ICoreRowNAmxint8SS<48, 16>;
-
-using tAVX_VNNI_KBlock = jblas::gemm::ICoreRowNAvxvnniKBlock<24, 2>;
-using tAVX512_VNNI_KBlock = jblas::gemm::ICoreRowNAvx512vnniKBlock<48, 4>;
-using tAMX_INT8_US_KBlock = jblas::gemm::ICoreRowNAmxint8KBlock<48, 16>;
-using tAMX_INT8_SS_KBlock = jblas::gemm::ICoreRowNAmxint8SSKBlock<48, 16>;
-
-template <class GC_T, JBLAS_ISA ISA_T>
-using tWeiNInt = jblas::prologue_b::gemm::WeightKBlockNInteger<GC_T, ISA_T>;
-template <class GC_T, JBLAS_ISA ISA_T>
-using tWeiNFloat = jblas::prologue_b::gemm::WeightKBlockNFloat<GC_T, ISA_T>;
-
-template <class GC_T, JBLAS_ISA ISA_T>
-using tActKBaseF32 = jblas::prologue_a::gemm::ShuffleActivationKBlockBaseF32<GC_T, ISA_T>;
-
-constexpr uint64_t Fp32Cores[] = {tAVX2::ID, tAVX512F::ID};
-constexpr uint64_t Bf16Cores[] = {tAMX_BF16::ID};
-constexpr uint64_t Fp16Cores[] = {tAVX512_FP16::ID};
-constexpr uint64_t Int8Cores[] = {tAVX_VNNI::ID, tAVX512F::ID, tAVX512_VNNI::ID, tAMX_INT8_US::ID, tAMX_INT8_SS::ID};
-constexpr uint64_t FloatCores[] = {tAVX2::ID, tAVX512F::ID, tAMX_BF16::ID, tAVX512_FP16::ID};
-constexpr uint64_t AllKBlockCores[] = {tAVX2::ID,
-                                       tAVX512F::ID,
-                                       tAMX_BF16::ID,
-                                       tAVX512_FP16::ID,
-                                       tAVX_VNNI_KBlock::ID,
-                                       tAVX512_VNNI_KBlock::ID,
-                                       tAMX_INT8_US_KBlock::ID,
-                                       tAMX_INT8_SS_KBlock::ID};
-
-}  // namespace jblas
diff --git a/neural_speed/core/layers/jblas_gemm.cpp b/neural_speed/core/layers/jblas_gemm.cpp
deleted file mode 100644
index e9c6508af..000000000
--- a/neural_speed/core/layers/jblas_gemm.cpp
+++ /dev/null
@@ -1,549 +0,0 @@
-//  Copyright (c) 2023 Intel Corporation
-//
-//  Licensed under the Apache License, Version 2.0 (the "License");
-//  you may not use this file except in compliance with the License.
-//  You may obtain a copy of the License at
-//
-//    http://www.apache.org/licenses/LICENSE-2.0
-//
-//  Unless required by applicable law or agreed to in writing, software
-//  distributed under the License is distributed on an "AS IS" BASIS,
-//  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.
-
-/*++
-
-Module Name:
-
-    jblas_gemm.cpp
-
-Abstract:
-
-    C APIs of BesTLA GEMMs.
---*/
-
-#include "jblas_gemm.h"
-#include <cstdint>
-
-#include "jblas_defs.h"
-
-using namespace jblas;  // NOLINT
-
-template <class GemmCore_T, template <class, JBLAS_ISA> class Wei_T>
-void JblasGemmCompF32(const int M, const int N, const int K, const float* A, const int lda,
-                      jblas::storage::gemm::IWeightBase* _B, float* C, const int ldc, int8_t* WorkSpace,
-                      jblas::parallel::IThreading* th) {
-  if (M <= 16) {
-    using Parallel = jblas::parallel::gemm::SchedulerKBlock<GemmCore_T>;
-    using Launcher = tLauncher_Fp_F32F32<GemmCore_T, Wei_T>;
-    static Launcher kernel;
-    auto B = reinterpret_cast<typename Launcher::PrologueB::StorageWeight*>(_B);
-    utils::GemmProblem gp(1, M, N, K, B->mBlockSize);
-    auto reduceA = kernel.mProA.createReduceStorage(M, K, B->mBlockSize);
-    if (B->IsAsym()) {
-      reduceA.assign(WorkSpace);
-      WorkSpace += reduceA.mSize;
-    }
-    auto reordA = kernel.mProA.createReorderStorage(M, K, B->mBlockSize);
-    if (B->ShfIndice()) {
-      reordA.assign(WorkSpace);
-    }
-    typename Launcher::BEpiParam blkargs{
-        B->template SPtr<int8_t>(),     B->SDtype(), B->CStep(), B->template ZPtr<int8_t>(),
-        reduceA.template RPtr<float>(), reduceA.lda};
-    typename Launcher::Param args{gp, {A, K, &reduceA, B->ShfIndice(), &reordA}, {B}, blkargs, {C, N}};
-    if (B->IsAsym() || B->ShfIndice()) {
-      jblas::parallel::GemmRunWithA<Parallel>(kernel, args, th);
-    } else {
-      jblas::parallel::GemmRun<Parallel>(kernel, args, th);
-    }
-  } else {
-    using Parallel = jblas::parallel::gemm::SchedulerBase<GemmCore_T>;
-    using Launcher = jblas::wrapper::gemm::LauncherBase<GemmCore_T::ISA, GemmCore_T,
-                                                        jblas::prologue_a::gemm::ShuffleActivationKBlockBaseF32, Wei_T,
-                                                        jblas::epilogue::gemm::AccumulatorWriteBackFp32>;
-    static Launcher kernel;
-    auto B = reinterpret_cast<typename Launcher::PrologueB::StorageWeight*>(_B);
-    utils::GemmProblem gp(1, M, N, K, B->mBlockSize);
-    auto reordA = kernel.mProA.createReorderStorage(M, K, B->mBlockSize);
-    typename Launcher::Param args{gp, {A, K, nullptr, B->ShfIndice(), &reordA}, {B}, {C, N}};
-    if (B->ShfIndice()) {
-      reordA.assign(WorkSpace);
-      jblas::parallel::GemmRunWithA<Parallel>(kernel, args, th);
-    } else {
-      jblas::parallel::GemmRun<Parallel>(kernel, args, th);
-    }
-  }
-}
-
-template <class GemmCore_T, template <class, JBLAS_ISA> class Wei_T>
-void JblasGemmCompInt8(const int M, const int N, const int K, const float* A, const int lda,
-                       jblas::storage::gemm::IWeightBase* _B, float* C, const int ldc, int8_t* WorkSpace,
-                       jblas::parallel::IThreading* th) {
-  using Parallel = jblas::parallel::gemm::SchedulerKBlockS<GemmCore_T>;
-  using Launcher = tLauncher_Int8_F32F32<GemmCore_T, Wei_T>;
-  auto B = reinterpret_cast<typename Launcher::PrologueB::StorageWeight*>(_B);
-  utils::GemmProblem gp(1, M, N, K, B->mBlockSize);
-  static Launcher kernel;
-  auto quanA = kernel.mProA.createQuantStorage(M, K, B->mBlockSize, B->IsAsym());
-  quanA.assign(WorkSpace);
-  WorkSpace += quanA.mSize;
-  auto reordA = kernel.mProA.createReorderStorage(M, K, B->mBlockSize);
-  typename Launcher::Param args{gp, {A, K, &quanA, B->ShfIndice(), &reordA}, {B}, {C, N}};
-  if (B->ShfIndice()) {
-    reordA.assign(WorkSpace);
-    kernel.mProA.quantize({A, K, &quanA, B->ShfIndice(), &reordA}, M, K, th);
-    jblas::parallel::GemmRun<Parallel>(kernel, args, th);
-  } else {
-    jblas::parallel::GemmRunWithA<Parallel>(kernel, args, th);
-  }
-}
-
-bool JblasGemmBatchDriver(const size_t M, const size_t N, const size_t K, const size_t BatchN,
-                          const JBLAS_GEMM_DATA_PACKED_PARAMS* DataParams, int8_t* WorkSpace, void* ThreadPool) {
-  GetCPUDevice();
-  auto pth = reinterpret_cast<jblas::parallel::IThreading*>(ThreadPool);
-  bool processed = true;
-  for (size_t i = 0; i < BatchN; i++) {
-    auto ptr = jblas::storage::gemm::PackedWeightParser::deserialBuffer(const_cast<void*>(DataParams[i].B));
-    if (ptr) {
-      auto coretype = ptr->mCoreId;
-      auto NTile = jblas::gemm::CoreAttr::get_mask_val(ptr->mCoreId, jblas::gemm::CoreAttr::NTILE_MASK,
-                                                       jblas::gemm::CoreAttr::NTILE_SHIFT);
-      auto PackRow = jblas::gemm::CoreAttr::get_packrow(ptr->mCoreId);
-      auto CType = jblas::gemm::CoreAttr::get_comp(ptr->mCoreId);
-      auto btype = static_cast<jblas::gemm::CompType>(jblas::gemm::CompTypeHelper::get_B(CType));
-      if (ptr->mPrologueID == JBLAS_PROLOGUEB_IDS::WeightKBlockNInteger) {
-        auto bptr = reinterpret_cast<jblas::storage::gemm::IWeightKBlockBase*>(ptr);
-        auto BlkSize = bptr->mBlockSize;
-        if (btype == jblas::gemm::CompType::tFP32 && PackRow == 1) {
-          if (NTile == tAVX512F::NTILE && _cd->AVX512F() && BlkSize % tAVX512F::KTILE == 0) {
-            JblasGemmCompF32<tAVX512F, tWeiNInt>(M, N, K, DataParams[i].A, DataParams[i].lda, ptr, DataParams[i].C,
-                                                 DataParams[i].ldc, WorkSpace, pth);
-          } else if (NTile == tAVX2::NTILE && _cd->AVX2() && BlkSize % tAVX2::KTILE == 0) {
-            JblasGemmCompF32<tAVX2, tWeiNInt>(M, N, K, DataParams[i].A, DataParams[i].lda, ptr, DataParams[i].C,
-                                              DataParams[i].ldc, WorkSpace, pth);
-          }
-        }
-        if (btype == jblas::gemm::CompType::tBF16 && PackRow == 2) {
-          if (NTile == tAMX_BF16::NTILE && _cd->AMX_BF16() && BlkSize % tAMX_BF16::KTILE == 0) {
-            if (M <= tAVX512_BF16::MTILE) {
-              static_assert(tAVX512_BF16::NTILE == tAMX_BF16::NTILE);
-              JblasGemmCompF32<tAVX512_BF16, tWeiNInt>(M, N, K, DataParams[i].A, DataParams[i].lda, ptr,
-                                                       DataParams[i].C, DataParams[i].ldc, WorkSpace, pth);
-            } else {
-              JblasGemmCompF32<tAMX_BF16, tWeiNInt>(M, N, K, DataParams[i].A, DataParams[i].lda, ptr, DataParams[i].C,
-                                                    DataParams[i].ldc, WorkSpace, pth);
-            }
-          }
-        }
-        if (btype == jblas::gemm::CompType::tS8 && PackRow == 4) {
-          // Do we need US for AMX_INT8
-          if (NTile == tAMX_INT8_SS_KBlock::NTILE && _cd->AMX_INT8() && BlkSize % tAMX_INT8_SS_KBlock::KTILE == 0) {
-            static_assert(tAMX_INT8_SS_KBlock::NTILE == tAVX512_VNNI_KBlock::NTILE);
-            if (M <= tAVX512_VNNI_KBlock::MTILE) {
-              JblasGemmCompInt8<tAVX512_VNNI_KBlock, tWeiNInt>(M, N, K, DataParams[i].A, DataParams[i].lda, ptr,
-                                                               DataParams[i].C, DataParams[i].ldc, WorkSpace, pth);
-            } else {
-              JblasGemmCompInt8<tAMX_INT8_SS_KBlock, tWeiNInt>(M, N, K, DataParams[i].A, DataParams[i].lda, ptr,
-                                                               DataParams[i].C, DataParams[i].ldc, WorkSpace, pth);
-            }
-
-          } else if (NTile == tAVX512_VNNI_KBlock::NTILE && _cd->AVX512_VNNI() &&
-                     BlkSize % tAVX512_VNNI_KBlock::KTILE == 0) {
-            JblasGemmCompInt8<tAVX512_VNNI_KBlock, tWeiNInt>(M, N, K, DataParams[i].A, DataParams[i].lda, ptr,
-                                                             DataParams[i].C, DataParams[i].ldc, WorkSpace, pth);
-          } else if (NTile == tAVX_VNNI_KBlock::NTILE && _cd->AVX_VNNI() && BlkSize % tAVX_VNNI_KBlock::KTILE == 0) {
-            JblasGemmCompInt8<tAVX_VNNI_KBlock, tWeiNInt>(M, N, K, DataParams[i].A, DataParams[i].lda, ptr,
-                                                          DataParams[i].C, DataParams[i].ldc, WorkSpace, pth);
-          }
-        }
-      }
-      if (ptr->mPrologueID == JBLAS_PROLOGUEB_IDS::WeightKBlockNFloat) {
-        auto bptr = reinterpret_cast<jblas::storage::gemm::IWeightKBlockBase*>(ptr);
-        auto BlkSize = bptr->mBlockSize;
-        if (btype == jblas::gemm::CompType::tFP32 && PackRow == 1) {
-          if (NTile == tAVX512F::NTILE && _cd->AVX512F() && BlkSize % tAVX512F::KTILE == 0) {
-            JblasGemmCompF32<tAVX512F, tWeiNFloat>(M, N, K, DataParams[i].A, DataParams[i].lda, ptr, DataParams[i].C,
-                                                   DataParams[i].ldc, WorkSpace, pth);
-          } else if (NTile == tAVX2::NTILE && _cd->AVX2() && BlkSize % tAVX2::KTILE == 0) {
-            JblasGemmCompF32<tAVX2, tWeiNFloat>(M, N, K, DataParams[i].A, DataParams[i].lda, ptr, DataParams[i].C,
-                                                DataParams[i].ldc, WorkSpace, pth);
-          }
-        }
-        if (btype == jblas::gemm::CompType::tBF16 && PackRow == 2) {
-          if (NTile == tAMX_BF16::NTILE && _cd->AMX_BF16() && BlkSize % tAMX_BF16::KTILE == 0) {
-            if (M <= tAVX512_BF16::MTILE) {
-              static_assert(tAVX512_BF16::NTILE == tAMX_BF16::NTILE);
-              JblasGemmCompF32<tAVX512_BF16, tWeiNFloat>(M, N, K, DataParams[i].A, DataParams[i].lda, ptr,
-                                                         DataParams[i].C, DataParams[i].ldc, WorkSpace, pth);
-            } else {
-              JblasGemmCompF32<tAMX_BF16, tWeiNFloat>(M, N, K, DataParams[i].A, DataParams[i].lda, ptr, DataParams[i].C,
-                                                      DataParams[i].ldc, WorkSpace, pth);
-            }
-          }
-        }
-      }
-      delete ptr;
-    } else {
-      processed = false;
-      break;
-    }
-  }
-  return processed;
-}
-
-template <typename T>
-static size_t JblasBuSize(int block_size, size_t N, size_t K, JBLAS_DTYPE QuantType, JBLAS_DTYPE ScaleDtype,
-                          bool isAsym, int* shuffle_indice) {
-  static T launcher;
-  using WType = typename T::PrologueB::StorageWeight;
-  WType stor(0);
-  if constexpr (std::is_same_v<typename T::PrologueB,
-                               jblas::prologue_b::gemm::WeightKBlockNInteger<typename T::GemmCore, T::ISA>>) {
-    stor = launcher.mProB.createStorage(N, K, block_size, QuantType, ScaleDtype, JBLAS_DTYPE::BF16, isAsym);
-    if (shuffle_indice != nullptr) {
-      launcher.mProB.enableShuffle(&stor);
-    }
-  } else {
-    stor = launcher.mProB.createStorage(N, K, block_size, QuantType, ScaleDtype);
-    (void)(shuffle_indice);
-  }
-
-  // Reduce dtype set to bf16
-  return stor.mSize;
-}
-template <template <class, JBLAS_ISA> class Wei_T>
-static size_t JblasGemmPackBSizeLocal(size_t N, size_t K, size_t BlkSize, JBLAS_DTYPE QuantType, JBLAS_DTYPE ScaleDtype,
-                                      bool isAsym, ne_comp_type CompType, int* shuffle_indice) {
-  GetCPUDevice();
-  auto dtype_type = jblas::utils::jblas_dtype_type(QuantType);
-  auto constexpr dtype_int = jblas::utils::jblas_dtype_type(JBLAS_DTYPE::TypeInt);
-  // from low precision to high precision
-  switch (CompType) {
-    case NE_COMP_INT8:
-      if (dtype_type == dtype_int && !isAsym) {  // asym int8 is not optimized, so fall through to others.
-        if (_cd->AMX_INT8() && BlkSize % tAMX_INT8_SS_KBlock::KTILE == 0) {
-          return JblasBuSize<tLauncher_Int8_F32F32<tAMX_INT8_SS_KBlock, Wei_T>>(
-              static_cast<int>(BlkSize), N, K, QuantType, ScaleDtype, isAsym, shuffle_indice);
-        }
-        if (_cd->AVX512_VNNI() && BlkSize % tAVX512_VNNI_KBlock::KTILE == 0) {
-          return JblasBuSize<tLauncher_Int8_F32F32<tAVX512_VNNI_KBlock, Wei_T>>(
-              static_cast<int>(BlkSize), N, K, QuantType, ScaleDtype, isAsym, shuffle_indice);
-        }
-        if (_cd->AVX_VNNI() && BlkSize % tAVX_VNNI_KBlock::KTILE == 0) {
-          return JblasBuSize<tLauncher_Int8_F32F32<tAVX_VNNI_KBlock, Wei_T>>(static_cast<int>(BlkSize), N, K, QuantType,
-                                                                             ScaleDtype, isAsym, shuffle_indice);
-        }
-      }
-    case NE_COMP_F16:
-    case NE_COMP_BF16:
-      if (_cd->AMX_BF16() && BlkSize % tAMX_BF16::KTILE == 0) {
-        return JblasBuSize<tLauncher_Int8_F32F32<tAMX_BF16, Wei_T>>(static_cast<int>(BlkSize), N, K, QuantType,
-                                                                    ScaleDtype, isAsym, shuffle_indice);
-      }
-    case NE_COMP_F32:
-    case NE_COMP_UNDEF:  // currently only f32 activation
-      if (_cd->AVX512F() && BlkSize % tAVX512F::KTILE == 0) {
-        return JblasBuSize<tLauncher_Fp_F32F32<tAVX512F, Wei_T>>(static_cast<int>(BlkSize), N, K, QuantType, ScaleDtype,
-                                                                 isAsym, shuffle_indice);
-      }
-      if (_cd->AVX2() && BlkSize % tAVX2::KTILE == 0) {
-        return JblasBuSize<tLauncher_Fp_F32F32<tAVX2, Wei_T>>(static_cast<int>(BlkSize), N, K, QuantType, ScaleDtype,
-                                                              isAsym, shuffle_indice);
-      }
-      break;
-    default:
-      return 0;
-  }
-  return 0;
-}
-
-size_t JblasGemmPackBSize(size_t N, size_t K, size_t BlkSize, JBLAS_DTYPE QuantType, JBLAS_DTYPE ScaleDtype,
-                          bool isAsym, ne_comp_type CompType, int* shuffle_indice) {
-  switch (QuantType) {
-    case JBLAS_DTYPE::S4_CLIP:
-    case JBLAS_DTYPE::S4_FULLRANGE:
-    case JBLAS_DTYPE::S8:
-      return JblasGemmPackBSizeLocal<jblas::prologue_b::gemm::WeightKBlockNInteger>(
-          N, K, BlkSize, QuantType, ScaleDtype, isAsym, CompType, shuffle_indice);
-    case JBLAS_DTYPE::F8_E4M3:
-    case JBLAS_DTYPE::F8_E5M2:
-    case JBLAS_DTYPE::F4_BNB:
-    case JBLAS_DTYPE::F4_E2M1:
-    case JBLAS_DTYPE::F4_NF4:
-      return JblasGemmPackBSizeLocal<jblas::prologue_b::gemm::WeightKBlockNFloat>(N, K, BlkSize, QuantType, ScaleDtype,
-                                                                                  isAsym, CompType, shuffle_indice);
-    default:
-      return 0;
-  }
-  return 0;
-}
-
-template <typename T>
-void JblaGemmQuantPackB(void* PackedBuf, int BlkSize, const float* FpData, int N, int K, JBLAS_DTYPE QuantType,
-                        JBLAS_DTYPE ScaleDtype, bool IsAsym, int ldb, bool IsTrans, void* ThreadPool) {
-  static T launcher;
-  using WType = typename T::PrologueB::StorageWeight;
-  WType stor(0);
-  if constexpr (std::is_same_v<typename T::PrologueB,
-                               jblas::prologue_b::gemm::WeightKBlockNInteger<typename T::GemmCore, T::ISA>>) {
-    stor = launcher.mProB.createStorage(N, K, BlkSize, QuantType, ScaleDtype, JBLAS_DTYPE::BF16, IsAsym);
-  } else {
-    stor = launcher.mProB.createStorage(N, K, BlkSize, QuantType, ScaleDtype);
-  }
-  stor.assign(reinterpret_cast<int8_t*>(PackedBuf));
-  auto pth = reinterpret_cast<jblas::parallel::IThreading*>(ThreadPool);
-  if (IsTrans) {
-    launcher.mProB.packTransposeWeight(N, K, FpData, ldb, &stor, pth);
-  } else {
-    launcher.mProB.packWeight(N, K, FpData, ldb, &stor, pth);
-  }
-}
-
-template <template <class, JBLAS_ISA> class Wei_T>
-static bool JblasGemmQuantPackBLocal(void* PackedBuf, const float* FpData, size_t N, size_t K, size_t ldb,
-                                     size_t BlkSize, JBLAS_DTYPE QuantType, JBLAS_DTYPE ScaleDtype, bool isAsym,
-                                     ne_comp_type CompType, bool isTrans, void* ThreadPool) {
-  GetCPUDevice();
-  auto dtype_type = jblas::utils::jblas_dtype_type(QuantType);
-  auto constexpr dtype_int = jblas::utils::jblas_dtype_type(JBLAS_DTYPE::TypeInt);
-  switch (CompType) {
-    case NE_COMP_INT8:
-      if (dtype_type == dtype_int && !isAsym) {  // asym int8 is not optimized, so fall through to others.
-        if (_cd->AMX_INT8() && BlkSize % tAMX_INT8_SS_KBlock::KTILE == 0) {
-          JblaGemmQuantPackB<tLauncher_Int8_F32F32<tAMX_INT8_SS_KBlock, Wei_T>>(
-              PackedBuf, static_cast<int>(BlkSize), FpData, static_cast<int>(N), static_cast<int>(K), QuantType,
-              ScaleDtype, isAsym, static_cast<int>(ldb), isTrans, ThreadPool);
-          return true;
-        }
-        if (_cd->AVX512_VNNI() && BlkSize % tAVX512_VNNI_KBlock::KTILE == 0) {
-          JblaGemmQuantPackB<tLauncher_Int8_F32F32<tAVX512_VNNI_KBlock, Wei_T>>(
-              PackedBuf, static_cast<int>(BlkSize), FpData, static_cast<int>(N), static_cast<int>(K), QuantType,
-              ScaleDtype, isAsym, static_cast<int>(ldb), isTrans, ThreadPool);
-          return true;
-        }
-        if (_cd->AVX_VNNI() && BlkSize % tAVX_VNNI_KBlock::KTILE == 0) {
-          JblaGemmQuantPackB<tLauncher_Int8_F32F32<tAVX_VNNI_KBlock, Wei_T>>(
-              PackedBuf, static_cast<int>(BlkSize), FpData, static_cast<int>(N), static_cast<int>(K), QuantType,
-              ScaleDtype, isAsym, static_cast<int>(ldb), isTrans, ThreadPool);
-          return true;
-        }
-      }
-    case NE_COMP_F16:
-    case NE_COMP_BF16:
-      if (_cd->AMX_BF16() && BlkSize % tAMX_BF16::KTILE == 0) {
-        JblaGemmQuantPackB<tLauncher_Fp_F32F32<tAMX_BF16, Wei_T>>(
-            PackedBuf, static_cast<int>(BlkSize), FpData, static_cast<int>(N), static_cast<int>(K), QuantType,
-            ScaleDtype, isAsym, static_cast<int>(ldb), isTrans, ThreadPool);
-        return true;
-      }
-    case NE_COMP_F32:
-    case NE_COMP_UNDEF:  // currently only f32 activation
-      if (_cd->AVX512F() && BlkSize % tAVX512F::KTILE == 0) {
-        JblaGemmQuantPackB<tLauncher_Fp_F32F32<tAVX512F, Wei_T>>(
-            PackedBuf, static_cast<int>(BlkSize), FpData, static_cast<int>(N), static_cast<int>(K), QuantType,
-            ScaleDtype, isAsym, static_cast<int>(ldb), isTrans, ThreadPool);
-        return true;
-      }
-      if (_cd->AVX2() && BlkSize % tAVX2::KTILE == 0) {
-        JblaGemmQuantPackB<tLauncher_Fp_F32F32<tAVX2, Wei_T>>(
-            PackedBuf, static_cast<int>(BlkSize), FpData, static_cast<int>(N), static_cast<int>(K), QuantType,
-            ScaleDtype, isAsym, static_cast<int>(ldb), isTrans, ThreadPool);
-        return true;
-      }
-    default:
-      return false;
-  }
-  return false;
-}
-
-bool JblasGemmQuantPackB(void* PackedBuf, const float* FpData, size_t N, size_t K, size_t ldb, size_t BlkSize,
-                         JBLAS_DTYPE QuantType, JBLAS_DTYPE ScaleDtype, bool isAsym, ne_comp_type CompType,
-                         bool isTrans, void* ThreadPool) {
-  switch (QuantType) {
-    case JBLAS_DTYPE::S4_CLIP:
-    case JBLAS_DTYPE::S4_FULLRANGE:
-    case JBLAS_DTYPE::S8:
-      return JblasGemmQuantPackBLocal<jblas::prologue_b::gemm::WeightKBlockNInteger>(
-          PackedBuf, FpData, N, K, ldb, BlkSize, QuantType, ScaleDtype, isAsym, CompType, isTrans, ThreadPool);
-    case JBLAS_DTYPE::F8_E5M2:
-    case JBLAS_DTYPE::F8_E4M3:
-    case JBLAS_DTYPE::F4_BNB:
-    case JBLAS_DTYPE::F4_E2M1:
-    case JBLAS_DTYPE::F4_NF4:
-      return JblasGemmQuantPackBLocal<jblas::prologue_b::gemm::WeightKBlockNFloat>(
-          PackedBuf, FpData, N, K, ldb, BlkSize, QuantType, ScaleDtype, isAsym, CompType, isTrans, ThreadPool);
-    default:
-      return false;
-  }
-  return false;
-}
-
-template <typename T>
-void JblaGemmPackBImpl(void* PackedBuf, int BlkSize, const int8_t* QData, const float* Scales, const int8_t* Zp, int N,
-                       int K, JBLAS_DTYPE QuantType, JBLAS_DTYPE ScaleDtype, bool IsAsym, int ldb, int* shuffle_indice,
-                       void* ThreadPool) {
-  static T launcher;
-  using WType = typename T::PrologueB::StorageWeight;
-  auto pth = reinterpret_cast<jblas::parallel::IThreading*>(ThreadPool);
-  WType stor(0);
-  if constexpr (std::is_same_v<typename T::PrologueB,
-                               jblas::prologue_b::gemm::WeightKBlockNInteger<typename T::GemmCore, T::ISA>>) {
-    stor = launcher.mProB.createStorage(N, K, BlkSize, QuantType, ScaleDtype, JBLAS_DTYPE::BF16, IsAsym);
-    if (shuffle_indice != nullptr) {
-      launcher.mProB.enableShuffle(&stor);
-      stor.assign(reinterpret_cast<int8_t*>(PackedBuf));
-      launcher.mProB.setShuffleIndices(shuffle_indice, &stor, pth);
-    } else {
-      stor.assign(reinterpret_cast<int8_t*>(PackedBuf));
-    }
-  } else {
-    (void)(shuffle_indice);
-    stor = launcher.mProB.createStorage(N, K, BlkSize, QuantType, ScaleDtype);
-    stor.assign(reinterpret_cast<int8_t*>(PackedBuf));
-  }
-  launcher.mProB.packQWeight(N, K, QData, ldb, Scales, IsAsym ? Zp : nullptr, &stor, pth);
-}
-
-template <template <class, JBLAS_ISA> class Wei_T>
-static bool JblasGemmPackBLocal(void* PackedBuf, const int8_t* QData, const float* Scales, const int8_t* Zp, size_t N,
-                                size_t K, size_t ldb, size_t BlkSize, JBLAS_DTYPE QuantType, JBLAS_DTYPE ScaleDtype,
-                                bool isAsym, ne_comp_type CompType, int* shuffle_indice, void* ThreadPool) {
-  GetCPUDevice();
-  auto dtype_type = jblas::utils::jblas_dtype_type(QuantType);
-  auto constexpr dtype_int = jblas::utils::jblas_dtype_type(JBLAS_DTYPE::TypeInt);
-  if (dtype_type != dtype_int) {
-    return false;
-  }
-  switch (CompType) {
-    case NE_COMP_INT8:
-      if (dtype_type == dtype_int && !isAsym) {  // asym int8 is not optimized, so fall through to others.
-        if (_cd->AMX_INT8() && BlkSize % tAMX_INT8_SS_KBlock::KTILE == 0) {
-          JblaGemmPackBImpl<tLauncher_Int8_F32F32<tAMX_INT8_SS_KBlock, Wei_T>>(
-              PackedBuf, static_cast<int>(BlkSize), QData, Scales, Zp, static_cast<int>(N), static_cast<int>(K),
-              QuantType, ScaleDtype, isAsym, static_cast<int>(ldb), shuffle_indice, ThreadPool);
-          return true;
-        }
-        if (_cd->AVX512_VNNI() && BlkSize % tAVX512_VNNI_KBlock::KTILE == 0) {
-          JblaGemmPackBImpl<tLauncher_Int8_F32F32<tAVX512_VNNI_KBlock, Wei_T>>(
-              PackedBuf, static_cast<int>(BlkSize), QData, Scales, Zp, static_cast<int>(N), static_cast<int>(K),
-              QuantType, ScaleDtype, isAsym, static_cast<int>(ldb), shuffle_indice, ThreadPool);
-          return true;
-        }
-        if (_cd->AVX_VNNI() && BlkSize % tAVX_VNNI_KBlock::KTILE == 0) {
-          JblaGemmPackBImpl<tLauncher_Int8_F32F32<tAVX_VNNI_KBlock, Wei_T>>(
-              PackedBuf, static_cast<int>(BlkSize), QData, Scales, Zp, static_cast<int>(N), static_cast<int>(K),
-              QuantType, ScaleDtype, isAsym, static_cast<int>(ldb), shuffle_indice, ThreadPool);
-          return true;
-        }
-      }
-    case NE_COMP_F16:
-    case NE_COMP_BF16:
-      if (_cd->AMX_BF16() && BlkSize % tAMX_BF16::KTILE == 0) {
-        JblaGemmPackBImpl<tLauncher_Fp_F32F32<tAMX_BF16, Wei_T>>(
-            PackedBuf, static_cast<int>(BlkSize), QData, Scales, Zp, static_cast<int>(N), static_cast<int>(K),
-            QuantType, ScaleDtype, isAsym, static_cast<int>(ldb), shuffle_indice, ThreadPool);
-        return true;
-      }
-    case NE_COMP_F32:
-    case NE_COMP_UNDEF:  // currently only f32 activation
-      if (_cd->AVX512F() && BlkSize % tAVX512F::KTILE == 0) {
-        JblaGemmPackBImpl<tLauncher_Fp_F32F32<tAVX512F, Wei_T>>(
-            PackedBuf, static_cast<int>(BlkSize), QData, Scales, Zp, static_cast<int>(N), static_cast<int>(K),
-            QuantType, ScaleDtype, isAsym, static_cast<int>(ldb), shuffle_indice, ThreadPool);
-        return true;
-      }
-      if (_cd->AVX2() && BlkSize % tAVX2::KTILE == 0) {
-        JblaGemmPackBImpl<tLauncher_Fp_F32F32<tAVX2, Wei_T>>(
-            PackedBuf, static_cast<int>(BlkSize), QData, Scales, Zp, static_cast<int>(N), static_cast<int>(K),
-            QuantType, ScaleDtype, isAsym, static_cast<int>(ldb), shuffle_indice, ThreadPool);
-        return true;
-      }
-    default:
-      return false;
-  }
-  return false;
-}
-
-bool JblasGemmPackB(void* PackedBuf, const int8_t* QData, const float* Scales, const int8_t* Zp, size_t N, size_t K,
-                    size_t ldb, size_t BlkSize, JBLAS_DTYPE QuantType, JBLAS_DTYPE ScaleDtype, bool isAsym,
-                    ne_comp_type CompType, int* shuffle_indice, void* ThreadPool) {
-  // only for integer quant
-  switch (QuantType) {
-    case JBLAS_DTYPE::S4_CLIP:
-    case JBLAS_DTYPE::S4_FULLRANGE:
-    case JBLAS_DTYPE::S8:
-      return JblasGemmPackBLocal<jblas::prologue_b::gemm::WeightKBlockNInteger>(PackedBuf, QData, Scales, Zp, N, K, ldb,
-                                                                                BlkSize, QuantType, ScaleDtype, isAsym,
-                                                                                CompType, shuffle_indice, ThreadPool);
-    default:
-      return false;
-  }
-  return false;
-}
-
-bool JblasGemmUnPackB(float* FpData, const void* PackedBuf, size_t N, size_t K, size_t ldb, void* ThreadPool) {
-  auto ptr = jblas::storage::gemm::PackedWeightParser::deserialBuffer(const_cast<void*>(PackedBuf));
-  auto pth = reinterpret_cast<jblas::parallel::IThreading*>(ThreadPool);
-  GetCPUDevice();
-  if (ptr) {
-    auto NTile = jblas::gemm::CoreAttr::get_mask_val(ptr->mCoreId, jblas::gemm::CoreAttr::NTILE_MASK,
-                                                     jblas::gemm::CoreAttr::NTILE_SHIFT);
-    auto PackRow = jblas::gemm::CoreAttr::get_packrow(ptr->mCoreId);
-    auto CType = jblas::gemm::CoreAttr::get_comp(ptr->mCoreId);
-    auto btype = static_cast<jblas::gemm::CompType>(jblas::gemm::CompTypeHelper::get_B(CType));
-    if (ptr->mPrologueID == JBLAS_PROLOGUEB_IDS::WeightKBlockNInteger) {
-      auto sptr = reinterpret_cast<jblas::storage::gemm::StorageWeightKBlockNInteger*>(ptr);
-      if (btype == jblas::gemm::CompType::tFP32 && PackRow == 1) {
-        if (NTile == tAVX512F::NTILE && _cd->AVX512F()) {
-          static jblas::prologue_b::gemm::WeightKBlockNInteger<tAVX512F, tAVX512F::ISA> proB;
-          proB.unpackWeight(static_cast<int>(N), static_cast<int>(K), sptr, FpData, static_cast<int>(ldb), pth);
-        } else if (NTile == tAVX2::NTILE && _cd->AVX2()) {
-          static jblas::prologue_b::gemm::WeightKBlockNInteger<tAVX2, tAVX2::ISA> proB;
-          proB.unpackWeight(static_cast<int>(N), static_cast<int>(K), sptr, FpData, static_cast<int>(ldb), pth);
-        }
-      }
-      if (btype == jblas::gemm::CompType::tS8 && PackRow == 4) {
-        if (NTile == tAMX_INT8_SS_KBlock::NTILE && _cd->AMX_INT8()) {
-          static jblas::prologue_b::gemm::WeightKBlockNInteger<tAMX_INT8_SS_KBlock, tAMX_INT8_SS_KBlock::ISA> proB;
-          proB.unpackWeight(static_cast<int>(N), static_cast<int>(K), sptr, FpData, static_cast<int>(ldb), pth);
-        } else if (NTile == tAVX512_VNNI_KBlock::NTILE && _cd->AVX512_VNNI()) {
-          static jblas::prologue_b::gemm::WeightKBlockNInteger<tAVX512_VNNI_KBlock, tAVX512_VNNI_KBlock::ISA> proB;
-          proB.unpackWeight(static_cast<int>(N), static_cast<int>(K), sptr, FpData, static_cast<int>(ldb), pth);
-        } else if (NTile == tAVX_VNNI_KBlock::NTILE && _cd->AVX_VNNI()) {
-          static jblas::prologue_b::gemm::WeightKBlockNInteger<tAVX_VNNI_KBlock, tAVX_VNNI_KBlock::ISA> proB;
-          proB.unpackWeight(static_cast<int>(N), static_cast<int>(K), sptr, FpData, static_cast<int>(ldb), pth);
-        }
-      }
-      if (btype == jblas::gemm::CompType::tBF16 && PackRow == 2) {
-        if (NTile == tAMX_BF16::NTILE && _cd->AMX_BF16()) {
-          static jblas::prologue_b::gemm::WeightKBlockNInteger<tAMX_BF16, tAMX_BF16::ISA> proB;
-          proB.unpackWeight(static_cast<int>(N), static_cast<int>(K), sptr, FpData, static_cast<int>(ldb), pth);
-        }
-      }
-    }
-    if (ptr->mPrologueID == JBLAS_PROLOGUEB_IDS::WeightKBlockNFloat) {
-      auto sptr = reinterpret_cast<jblas::storage::gemm::StorageWeightKBlockNFloat*>(ptr);
-      if (btype == jblas::gemm::CompType::tFP32 && PackRow == 1) {
-        if (NTile == tAVX512F::NTILE && _cd->AVX512F()) {
-          static jblas::prologue_b::gemm::WeightKBlockNFloat<tAVX512F, tAVX512F::ISA> proB;
-          proB.unpackWeight(static_cast<int>(N), static_cast<int>(K), sptr, FpData, static_cast<int>(ldb), pth);
-        } else if (NTile == tAVX2::NTILE && _cd->AVX2()) {
-          static jblas::prologue_b::gemm::WeightKBlockNFloat<tAVX2, tAVX2::ISA> proB;
-          proB.unpackWeight(static_cast<int>(N), static_cast<int>(K), sptr, FpData, static_cast<int>(ldb), pth);
-        }
-      }
-      if (btype == jblas::gemm::CompType::tBF16 && PackRow == 2) {
-        if (NTile == tAMX_BF16::NTILE && _cd->AMX_BF16()) {
-          static jblas::prologue_b::gemm::WeightKBlockNFloat<tAMX_BF16, tAMX_BF16::ISA> proB;
-          proB.unpackWeight(static_cast<int>(N), static_cast<int>(K), sptr, FpData, static_cast<int>(ldb), pth);
-        }
-      }
-    }
-    delete ptr;
-    return true;
-  }
-  return false;
-}
diff --git a/neural_speed/core/layers/jblas_gemm.h b/neural_speed/core/layers/jblas_gemm.h
deleted file mode 100644
index 406b4f311..000000000
--- a/neural_speed/core/layers/jblas_gemm.h
+++ /dev/null
@@ -1,55 +0,0 @@
-//  Copyright (c) 2023 Intel Corporation
-//
-//  Licensed under the Apache License, Version 2.0 (the "License");
-//  you may not use this file except in compliance with the License.
-//  You may obtain a copy of the License at
-//
-//    http://www.apache.org/licenses/LICENSE-2.0
-//
-//  Unless required by applicable law or agreed to in writing, software
-//  distributed under the License is distributed on an "AS IS" BASIS,
-//  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.
-
-/*++
-Module Name:
-
-    jblas_gemm.h
-
-Abstract:
-
-    C APIs of BesTLA GEMMs.
---*/
-
-#pragma once
-
-#include "data_types.h"
-#include "jblas/jit_blas.h"
-
-struct JBLAS_GEMM_DATA_PACKED_PARAMS {
-  const float* A = nullptr; /**< address of A (float32 matrix)*/
-  const void* B = nullptr;  /**< address of B (packed nbits blob)*/
-  float* C = nullptr;       /**< address of result matrix */
-  int lda = 0;              /**< leading dimension of A */
-  int ldc = 0;              /**< leading dimension of C*/
-};
-
-size_t JblasGemmPackBSize(size_t N, size_t K, size_t BlkSize, JBLAS_DTYPE QuantType, JBLAS_DTYPE ScaleDtype,
-                          bool isAsym, ne_comp_type CompType, int* shuffle_indice);
-
-bool JblasGemmQuantPackB(void* PackedBuf, const float* FpData, size_t N, size_t K, size_t ldb, size_t BlkSize,
-                         JBLAS_DTYPE QuantType, JBLAS_DTYPE ScaleDtype, bool isAsym, ne_comp_type CompType,
-                         bool isTrans, void* ThreadPool);
-
-// QData:  K*N quantized int8 weight
-// Scales: K/BlkSize * N scales
-// Zp:     K/BlkSize * N zero points
-bool JblasGemmPackB(void* PackedBuf, const int8_t* QData, const float* Scales, const int8_t* Zp, size_t N, size_t K,
-                    size_t ldb, size_t BlkSize, JBLAS_DTYPE QuantType, JBLAS_DTYPE ScaleDtype, bool isAsym,
-                    ne_comp_type CompType, int* shuffle_indice, void* ThreadPool);
-
-bool JblasGemmUnPackB(float* FpData, const void* PackedBuf, size_t N, size_t K, size_t ldb, void* ThreadPool);
-
-bool JblasGemmBatchDriver(const size_t M, const size_t N, const size_t K, const size_t BatchN,
-                          const JBLAS_GEMM_DATA_PACKED_PARAMS* DataParams, int8_t* WorkSpace, void* ThreadPool);
diff --git a/neural_speed/core/layers/mha_dense.cpp b/neural_speed/core/layers/mha_dense.cpp
index ba18665a8..8f49a722a 100644
--- a/neural_speed/core/layers/mha_dense.cpp
+++ b/neural_speed/core/layers/mha_dense.cpp
@@ -29,15 +29,15 @@
 #endif
 
 #include "core/data_types.h"
-#include "layers/jblas_common.hpp"
-#include "jblas/jit_blas.h"
-#include "jblas/jit_blas_epilogue.h"
-#include "jblas/jit_blas_gemm.h"
-#include "jblas/jit_blas_parallel.h"
-#include "jblas/jit_blas_prologue_b.h"
-#include "jblas/jit_blas_prologue_a.h"
-#include "jblas/jit_blas_storage.h"
-#include "jblas/jit_blas_wrapper.h"
+#include "layers/bestla_common.hpp"
+#include "bestla/bestla.h"
+#include "bestla/bestla_epilogue.h"
+#include "bestla/bestla_gemm.h"
+#include "bestla/bestla_parallel.h"
+#include "bestla/bestla_prologue_b.h"
+#include "bestla/bestla_prologue_a.h"
+#include "bestla/bestla_storage.h"
+#include "bestla/bestla_wrapper.h"
 
 #define MHA_2ND_EXP 1
 constexpr bool MHA_PREFER_AVX512FP16 = true;
@@ -53,14 +53,16 @@ constexpr bool MHA_PREFER_AVX512FP16 = true;
 #endif
 #endif
 
+using namespace bestla;     // NOLINT
+using namespace ne_bestla;  // NOLINT
 namespace {
-using jblas::utils::bf16;
-using jblas::utils::fp16;
-using jblas::utils::padto;
-using jblas::utils::padto_le;
-using jblas::utils::remainsize;
-using jblas::utils::updiv;
-namespace utils = jblas::utils;
+using bestla::utils::bf16;
+using bestla::utils::fp16;
+using bestla::utils::padto;
+using bestla::utils::padto_le;
+using bestla::utils::remainsize;
+using bestla::utils::updiv;
+namespace utils = bestla::utils;
 
 template <typename Q_T, typename K_T, typename V_T, typename DST_T>
 struct attn_fwd_args_t {
@@ -146,7 +148,7 @@ inline __m512 exp_ph_0_1(const __m512 x) {
  * @brief An Epilogue that optionally apply a casual mask and scale the fp32 result, performing exp, accumulating sum of
  * each line of exp, and storing exp as bf16 results
  */
-template <JBLAS_ISA ISA_T, typename T_DST>
+template <BTLA_ISA ISA_T, typename T_DST>
 class ScaleExpAccSumFp32 {
  public:
   struct Param {
@@ -158,8 +160,8 @@ class ScaleExpAccSumFp32 {
     float alibi_slope;  // m-factor in the alibi paper for current head: https://arxiv.org/abs/2108.12409
   };
 
-  JBLAS_CODE forward(const float* src, const int src_step, const int M_offset, const int N_offset, const int M,
-                     const int N, const Param& p, void* /* tmpcache */, size_t /* cachesize */) const {
+  BTLA_CODE forward(const float* src, const int src_step, const int M_offset, const int N_offset, const int M,
+                    const int N, const Param& p, void* /* tmpcache */, size_t /* cachesize */) const {
     assert(("alibi not supported!", p.alibi_slope == 0.f));
     const auto dst = p.dst + M_offset * p.ld_dst + N_offset;
     const auto dst_sum = p.dst_sum + M_offset;
@@ -186,8 +188,7 @@ class ScaleExpAccSumFp32 {
       }
       dst_sum[i] += _mm512_reduce_add_ps(v_sum);
 
-      if (j < jblas::utils::padto(N, 64))
-        memset(dst + i * p.ld_dst + j, 0, sizeof(*dst) * (jblas::utils::padto(N, 64) - j));
+      if (j < utils::padto(N, 64)) memset(dst + i * p.ld_dst + j, 0, sizeof(*dst) * (utils::padto(N, 64) - j));
     }
 #else
     for (int i = 0; i < M; ++i) {
@@ -198,21 +199,21 @@ class ScaleExpAccSumFp32 {
         dst[i * p.ld_dst + j] = static_cast<T_DST>(exp_);
         dst_sum[i] += exp_;
       }
-      if (N_unmasked < jblas::utils::padto(N, 64))
-        memset(dst + i * p.ld_dst + N_unmasked, 0, sizeof(*dst) * (jblas::utils::padto(N, 64) - N_unmasked));
+      if (N_unmasked < utils::padto(N, 64))
+        memset(dst + i * p.ld_dst + N_unmasked, 0, sizeof(*dst) * (utils::padto(N, 64) - N_unmasked));
     }
 #endif
 
-    return JblasSuccess;
+    return BTLA_CODE::Success;
   }
 };
-template <JBLAS_ISA ISA_T>
+template <BTLA_ISA ISA_T>
 using ScaleExpAccSumFp32Bf16 = ScaleExpAccSumFp32<ISA_T, bf16>;
 
 /**
  * @brief An Epilogue that scale the fp32 result, convert to bf16 and write back to memory
  */
-template <JBLAS_ISA ISA_T, typename T_SRC, typename T_DST>
+template <BTLA_ISA ISA_T, typename T_SRC, typename T_DST>
 class ScaleWriteBack {
  public:
   using SType = T_SRC;
@@ -223,8 +224,8 @@ class ScaleWriteBack {
     int ld_dst;
   };
 
-  JBLAS_CODE forward(const SType* src, const int src_step, const int M_offset, const int N_offset, const int M,
-                     const int N, const Param& p, void* /* tmpcache */, size_t /* cachesize */) {
+  BTLA_CODE forward(const SType* src, const int src_step, const int M_offset, const int N_offset, const int M,
+                    const int N, const Param& p, void* /* tmpcache */, size_t /* cachesize */) {
     const auto dst = p.dst + M_offset * p.ld_dst + N_offset;
     const auto scale = p.scale + M_offset;
     // TODO(Yi): high performance implementation
@@ -232,32 +233,32 @@ class ScaleWriteBack {
       for (int j = 0; j < N; ++j)  //
         dst[i * p.ld_dst + j] = static_cast<DType>(scale[i] * src[i * src_step + j]);
 
-    return JblasSuccess;
+    return BTLA_CODE::Success;
   }
 };
-template <JBLAS_ISA ISA_T>
+template <BTLA_ISA ISA_T>
 using ScaleWriteBackFp32Bf16 = ScaleWriteBack<ISA_T, float, bf16>;
-template <JBLAS_ISA ISA_T>
+template <BTLA_ISA ISA_T>
 using ScaleWriteBackFp32Fp32 = ScaleWriteBack<ISA_T, float, float>;
-template <JBLAS_ISA ISA_T>
+template <BTLA_ISA ISA_T>
 using ScaleWriteBackS32S8 = ScaleWriteBack<ISA_T, int32_t, int8_t>;
 
 /**
  * @brief PackedWeight(Default) with batch
  */
-class StoragePackedWeightBatch : public jblas::storage::gemm::IWeightBase {
-  using Base = jblas::storage::gemm::IWeightBase;
+class StoragePackedWeightBatch : public storage::gemm::IWeightBase {
+  using Base = storage::gemm::IWeightBase;
 
  public:
   int mBatch;
-  jblas::storage::ObjectAlignedBuffer<NE_ALIGNMENT> mWBuf;
+  storage::ObjectAlignedBuffer<NE_ALIGNMENT> mWBuf;
   // size_t mWSize;
 
   explicit StoragePackedWeightBatch(uint64_t _core_id) : Base(_core_id), mBatch(0) {}
-  size_t resize(int NPad, int KPad, int N, int K, int num_batch, JBLAS_DTYPE dtype) {
+  size_t resize(int NPad, int KPad, int N, int K, int num_batch, BTLA_DTYPE dtype) {
     IWeightBase::resize(NPad, KPad, N, K, dtype);
     mBatch = num_batch;
-    auto bsize = static_cast<size_t>(mBatch) * NPad * KPad * jblas::utils::jblas_dtype_size(dtype);
+    auto bsize = static_cast<size_t>(mBatch) * NPad * KPad * utils::bestla_dtype_size(dtype);
     mWBuf.resize(bsize);
     mSize = utils::padto(IWeightBase::getSerializedSize() + mWBuf.getSerializedSize(), NE_ALIGNMENT);
     return mSize;
@@ -304,7 +305,7 @@ class StoragePackedWeightBatch : public jblas::storage::gemm::IWeightBase {
  * @brief An weight Prologue that Packs transposed Bf16 weight; optimized for runtime packing. It is the base type of
  * that for transposed / non-transposed source
  */
-template <class GemmCore_T, JBLAS_ISA ISA_T, bool IsTrans, typename T_SRC = typename GemmCore_T::BType>
+template <class GemmCore_T, BTLA_ISA ISA_T, bool IsTrans, typename T_SRC = typename GemmCore_T::BType>
 class WeightPackBatchBf16Base {
  public:
   using WType = typename GemmCore_T::BType;      // weight type
@@ -317,30 +318,30 @@ class WeightPackBatchBf16Base {
     const StorageType* packedW;
   };
 
-  JBLAS_CODE getWeight(...) = delete;
+  BTLA_CODE getWeight(...) = delete;
 
-  JBLAS_CODE getWeight(WType** dstptr, int* dststep, int /* b_size */, int /* k_size */, int /* n_size */, int b_offset,
-                       int k_offset, int n_offset, const Param& param, void* /* tmpcache */, size_t /* cachesize */) {
+  BTLA_CODE getWeight(WType** dstptr, int* dststep, int /* b_size */, int /* k_size */, int /* n_size */, int b_offset,
+                      int k_offset, int n_offset, const Param& param, void* /* tmpcache */, size_t /* cachesize */) {
     const auto wptr = param.packedW;
-    if (!wptr) return JblasInvalidParam;
+    if (!wptr) return BTLA_CODE::InvalidParam;
     assert(k_offset % GemmCore_T::KTILE == 0);
     assert(n_offset % GemmCore_T::NTILE == 0);
     auto KPad = wptr->mKPad;
     auto NPad = wptr->mNPad;
     *dstptr = wptr->template WPtr<WType>() + n_offset * KPad + k_offset * GemmCore_T::NTILE;
     *dststep = KPad;
-    return JblasSuccess;
+    return BTLA_CODE::Success;
   }
 
-  JBLAS_CODE getWeight(WType** dstptr, int* dststep, int k_size, int n_size, int k_offset, int n_offset,
-                       const Param& param, void* tmpcache, size_t cachesize) {
+  BTLA_CODE getWeight(WType** dstptr, int* dststep, int k_size, int n_size, int k_offset, int n_offset,
+                      const Param& param, void* tmpcache, size_t cachesize) {
     return getWeight(dstptr, dststep, 1, k_size, n_size, 0, k_offset, n_offset, param, tmpcache, cachesize);
   }
 
-  JBLAS_CODE packWeight(...) = delete;
+  BTLA_CODE packWeight(...) = delete;
 };
 
-template <class GemmCore_T, JBLAS_ISA ISA_T, typename T_SRC = typename GemmCore_T::BType>
+template <class GemmCore_T, BTLA_ISA ISA_T, typename T_SRC = typename GemmCore_T::BType>
 class WeightPackBatchBf16Trans : public WeightPackBatchBf16Base<GemmCore_T, ISA_T, true, T_SRC> {
   using Base = WeightPackBatchBf16Base<GemmCore_T, ISA_T, true, T_SRC>;
 
@@ -351,7 +352,7 @@ class WeightPackBatchBf16Trans : public WeightPackBatchBf16Base<GemmCore_T, ISA_
   using typename Base::WType;
 
   /// Reorder job of a thread
-  void run(const Param& p, const jblas::parallel::ThreadProblem2D& thdp, std::function<int(int)> step_batch) {
+  void run(const Param& p, const parallel::ThreadProblem2D& thdp, std::function<int(int)> step_batch) {
     if (!thdp.valid) return;
     const auto pw = dynamic_cast<const StorageType*>(p.packedW);
     assert(pw != nullptr);
@@ -363,11 +364,11 @@ class WeightPackBatchBf16Trans : public WeightPackBatchBf16Base<GemmCore_T, ISA_
     // y for batch; x for major-dim of the source data (N-dim of the packed weight)
     const auto [y, x] = thdp.loc;
     const auto [ny, nx] = thdp.size;
-    const auto nx_pad = jblas::utils::padto(nx, GemmCore_T::NTILE);
+    const auto nx_pad = utils::padto(nx, GemmCore_T::NTILE);
 
     assert(padto(pw->mK, GemmCore_T::KTILE) == KPad);
 
-    using KernInterleave = typename jblas::kernel::wrapper::PaddingTransInterleaveMN<  //
+    using KernInterleave = typename kernel::wrapper::PaddingTransInterleaveMN<  //
         GemmCore_T::NTILE, GemmCore_T::PACK_ROW>;
 
     for (int ibat = y; ibat < y + ny; ++ibat) {
@@ -377,12 +378,12 @@ class WeightPackBatchBf16Trans : public WeightPackBatchBf16Base<GemmCore_T, ISA_
           nx, pw->mK,                                                                   // size
           nx_pad, KPad,                                                                 // padded size
           p.ldb, KPad);                                                                 // step
-      assert(forward_stat == JblasSuccess);
+      assert(forward_stat == BTLA_CODE::Success);
     }
   }
 };
 
-template <class GemmCore_T, JBLAS_ISA ISA_T, typename T_SRC = typename GemmCore_T::BType>
+template <class GemmCore_T, BTLA_ISA ISA_T, typename T_SRC = typename GemmCore_T::BType>
 class WeightPackBatchBf16NonTr : public WeightPackBatchBf16Base<GemmCore_T, ISA_T, false, T_SRC> {
   using Base = WeightPackBatchBf16Base<GemmCore_T, ISA_T, false, T_SRC>;
 
@@ -393,7 +394,7 @@ class WeightPackBatchBf16NonTr : public WeightPackBatchBf16Base<GemmCore_T, ISA_
   using typename Base::WType;
 
   /// Reorder job of a thread
-  void run(const Param& p, const jblas::parallel::ThreadProblem2D& thdp, std::function<int(int)> step_batch) {
+  void run(const Param& p, const parallel::ThreadProblem2D& thdp, std::function<int(int)> step_batch) {
     if (!thdp.valid) return;
     const auto pw = dynamic_cast<const StorageType*>(p.packedW);
     assert(pw != nullptr);
@@ -405,9 +406,9 @@ class WeightPackBatchBf16NonTr : public WeightPackBatchBf16Base<GemmCore_T, ISA_
 
     auto [y, x] = thdp.loc;
     auto [ny, nx] = thdp.size;
-    const auto nx_pad = jblas::utils::padto(nx, GemmCore_T::KTILE);
+    const auto nx_pad = utils::padto(nx, GemmCore_T::KTILE);
 
-    using KernInterleave = typename jblas::kernel::wrapper::PaddingInterleaveMN<  //
+    using KernInterleave = typename kernel::wrapper::PaddingInterleaveMN<  //
         GemmCore_T::NTILE, GemmCore_T::PACK_ROW>;
 
     for (int ibat = y; ibat < y + ny; ++ibat) {
@@ -417,12 +418,12 @@ class WeightPackBatchBf16NonTr : public WeightPackBatchBf16Base<GemmCore_T, ISA_
           nx, pw->mN,                                                                   // size
           nx_pad, NPad,                                                                 // padded size
           p.ldb, KPad);                                                                 // stride
-      assert(forward_stat == JblasSuccess);
+      assert(forward_stat == BTLA_CODE::Success);
     }
   }
 };
 
-template <class _GemmCore_T, JBLAS_ISA ISA_T>
+template <class _GemmCore_T, BTLA_ISA ISA_T>
 class ActivationIdentity {
  public:
   using AType = typename _GemmCore_T::AType;
@@ -432,24 +433,24 @@ class ActivationIdentity {
   };
   ActivationIdentity() {}
 
-  JBLAS_CODE getActivation(AType** dstptr, int* dststep, const Param& _param, int m_size, int k_size, int m_offset,
-                           int k_offset, void* /* tmpcache */, size_t /* cachesize */) {
+  BTLA_CODE getActivation(AType** dstptr, int* dststep, const Param& _param, int m_size, int k_size, int m_offset,
+                          int k_offset, void* /* tmpcache */, size_t /* cachesize */) {
     auto aptr = const_cast<AType*>(_param.A);
     *dstptr = aptr + m_offset * _param.lda + k_offset;
     *dststep = _param.lda;
-    return JblasSuccess;
+    return BTLA_CODE::Success;
   }
 };
 
 /**
  * @brief LauncherBase with addition input as packed weight offset
  */
-template <JBLAS_ISA RT_ISA_, class _GemmCore_T, template <class, JBLAS_ISA> class _PrologueA_T,
-          template <class, JBLAS_ISA> class _PrologueB_T, template <JBLAS_ISA> class _Epilogue_T>
-class LauncherBaseOff                             //
-    : public jblas::wrapper::gemm::LauncherBase<  //
+template <BTLA_ISA RT_ISA_, class _GemmCore_T, template <class, BTLA_ISA> class _PrologueA_T,
+          template <class, BTLA_ISA> class _PrologueB_T, template <BTLA_ISA> class _Epilogue_T>
+class LauncherBaseOff                      //
+    : public wrapper::gemm::LauncherBase<  //
           RT_ISA_, _GemmCore_T, _PrologueA_T, _PrologueB_T, _Epilogue_T> {
-  using Base = jblas::wrapper::gemm::LauncherBase<  //
+  using Base = wrapper::gemm::LauncherBase<  //
       RT_ISA_, _GemmCore_T, _PrologueA_T, _PrologueB_T, _Epilogue_T>;
 
  public:
@@ -460,7 +461,7 @@ class LauncherBaseOff                             //
   using CType = typename Base::CType;
   static constexpr auto RT_ISA = RT_ISA_;
 
-  void run(const Param& _param, const jblas::parallel::gemm::ThreadProblemBase& _config,
+  void run(const Param& _param, const parallel::gemm::ThreadProblemBase& _config,
            int w_offset /* weight offset for batching */) {
     // TO(Yi) temperarily configure to max tiling size
     this->mGemmCore.configure(16, 16, 16);  // Need 'this->' here; See：https://stackoverflow.com/questions/11405
@@ -484,7 +485,7 @@ class LauncherBaseOff                             //
   }
 
  protected:
-  void run_block(const Param& _param, const jblas::parallel::gemm::ThreadProblemBase& _config,
+  void run_block(const Param& _param, const parallel::gemm::ThreadProblemBase& _config,
                  int w_offset /* weight offset for batching */, int blk_m, int blk_n, int blk_msize, int blk_nsize,
                  AType* tmpA, BType* /*tmpB*/, CType* tmpC, void* tmpcache) {
     int n_padded = padto(blk_nsize, GemmCore::NTILE);
@@ -533,12 +534,12 @@ class LauncherBaseOff                             //
 /**
  * @brief LauncherBase with addition input as packed weight offset
  */
-template <JBLAS_ISA RT_ISA_, class _GemmCore_T, template <class, JBLAS_ISA> class _PrologueA_T,
-          template <class, JBLAS_ISA> class _PrologueB_T, template <JBLAS_ISA> class _Epilogue_T>
-class LauncherBaseWeight                          //
-    : public jblas::wrapper::gemm::LauncherBase<  //
+template <BTLA_ISA RT_ISA_, class _GemmCore_T, template <class, BTLA_ISA> class _PrologueA_T,
+          template <class, BTLA_ISA> class _PrologueB_T, template <BTLA_ISA> class _Epilogue_T>
+class LauncherBaseWeight                   //
+    : public wrapper::gemm::LauncherBase<  //
           RT_ISA_, _GemmCore_T, _PrologueA_T, _PrologueB_T, _Epilogue_T> {
-  using Base = jblas::wrapper::gemm::LauncherBase<  //
+  using Base = wrapper::gemm::LauncherBase<  //
       RT_ISA_, _GemmCore_T, _PrologueA_T, _PrologueB_T, _Epilogue_T>;
 
  public:
@@ -549,7 +550,7 @@ class LauncherBaseWeight                          //
   using CType = typename Base::CType;
   static constexpr auto RT_ISA = RT_ISA_;
 
-  void run(const Param& _param, const jblas::parallel::gemm::ThreadProblemBase& _config) {
+  void run(const Param& _param, const parallel::gemm::ThreadProblemBase& _config) {
     this->mGemmCore.configure(16, 16, 16);  // Need 'this->' here; See：https://stackoverflow.com/questions/11405
     auto StackTmp = alloca(_config.stacksize);
     auto tmpB = reinterpret_cast<BType*>(StackTmp);
@@ -571,7 +572,7 @@ class LauncherBaseWeight                          //
   }
 
  protected:
-  void run_block(const Param& _param, const jblas::parallel::gemm::ThreadProblemBase& _config, int blk_m, int blk_n,
+  void run_block(const Param& _param, const parallel::gemm::ThreadProblemBase& _config, int blk_m, int blk_n,
                  int blk_msize, int blk_nsize, AType* tmpA, BType* tmpB, CType* tmpC, void* tmpcache) {
     int n_padded = padto(blk_nsize, GemmCore::NTILE);
     for (int iterk = 0; iterk < _param.problem.dims[3]; iterk += _config.block[2]) {
@@ -646,7 +647,7 @@ class MHAInterface {
 
   static_assert(GemmQK::MTILE == GemmPV::MTILE, "2 GEMM should have the same M_TILE.");
 
-  JBLAS_CODE compute(const attn_fwd_args_t<Q_T, K_T, V_T, DST_T>& p, const jblas::parallel::IThreading& th) {
+  BTLA_CODE compute(const attn_fwd_args_t<Q_T, K_T, V_T, DST_T>& p, const parallel::IThreading& th) {
     static constexpr auto M_TILE = GemmQK::MTILE;
     assert(p.Q_sc == 1 && p.K_sc == 1 && p.V_sc == 1 && p.dst_sc == 1);
     assert(p.Q_layout == ATTN_FWD_LAYOUT_PLAIN && p.K_layout == ATTN_FWD_LAYOUT_PLAIN &&
@@ -654,7 +655,7 @@ class MHAInterface {
     assert(p.step_v_head_size == 1);
     assert(p.step_k_head_size == 1 || p.step_k_sl == 1);
     const auto num_heads = p.batch_size * p.head_num;  // Total number of heads
-    jblas::device::CpuBase cb;                         // Note: DO NOT use cb.mNumThreads; use th.num_threads() instead
+    device::CpuBase cb;                                // Note: DO NOT use cb.mNumThreads; use th.num_threads() instead
 
     const bool is_causal = (p.attn_flags & NE_ATTN_FLAG_IS_CAUSAL) != 0;
     const bool is_alibi = (p.attn_flags & NE_ATTN_FLAG_IS_ALIBI8) != 0;
@@ -667,13 +668,13 @@ class MHAInterface {
     // TODO(Yi): init packed weight with p.tmp
     StoragePackedWeightBatch /*<typename GemmQK::BType>*/ K_pack(GemmQK::ID);  // packed K
     K_pack.resize(padto(p.sl_kv, GemmQK::NTILE), padto(p.head_size, GemmQK::KTILE), p.sl_kv, p.head_size, num_heads,
-                  jblas::utils::jblas_dtype<typename GemmQK::BType>);
-    auto bufferK = jblas::utils::amalloc<int8_t>(K_pack.mSize);
+                  utils::bestla_dtype<typename GemmQK::BType>);
+    auto bufferK = utils::amalloc<int8_t>(K_pack.mSize);
     K_pack.assign(bufferK);
     StoragePackedWeightBatch /*<typename GemmPV::BType>*/ V_pack(GemmPV::ID);  // packed V
     V_pack.resize(padto(p.head_size, GemmPV::NTILE), padto(p.sl_kv, GemmPV::KTILE), p.head_size, p.sl_kv, num_heads,
-                  jblas::utils::jblas_dtype<typename GemmPV::BType>);
-    auto bufferV = jblas::utils::amalloc<int8_t>(V_pack.mSize);
+                  utils::bestla_dtype<typename GemmPV::BType>);
+    auto bufferV = utils::amalloc<int8_t>(V_pack.mSize);
     V_pack.assign(bufferV);
     const auto K_pack_batch_off = K_pack.mKPad * K_pack.mNPad;
     const auto V_pack_batch_off = V_pack.mKPad * V_pack.mNPad;
@@ -686,8 +687,8 @@ class MHAInterface {
     };
 
     // prepare parallel scheduler for packed weight
-    using Scheduler2D = typename jblas::parallel::Scheduler2D;
-    using ThreadProblem2D = typename jblas::parallel::ThreadProblem2D;
+    using Scheduler2D = typename parallel::Scheduler2D;
+    using ThreadProblem2D = typename parallel::ThreadProblem2D;
     const auto schK = p.step_k_head_size == 1
                           ? Scheduler2D({th.num_threads(), {num_heads, p.sl_kv}, {1, GemmQK::NTILE}})
                           : Scheduler2D({th.num_threads(), {num_heads, p.head_size}, {1, GemmQK::KTILE}});
@@ -755,7 +756,7 @@ class MHAInterface {
           const auto unmasked_size_pad_pv = std::min(p.sl_kv, padto(unmasked_size, GemmPV::KTILE));
           const auto ld_tmp_exp = padto(padto(unmasked_size_pad_pv, GemmQK::NTILE), GemmPV::KTILE);
 
-          typename jblas::parallel::gemm::ThreadProblemBase tpQK{
+          typename parallel::gemm::ThreadProblemBase tpQK{
               /* ThreadProblem2D */ {tid, {}, {i_m, 0}, {m_size, unmasked_size_pad_qk}, true},
               /* .block = */ {M_TILE, GemmQK::NTILE, p.head_size},
               /* .stacksize = */ cb.mL2Cache,
@@ -764,7 +765,7 @@ class MHAInterface {
           const auto bf16_tmp = reinterpret_cast<bf16*>(tmp);
           l_expsum.run(  // QxK => S ==exp==> P
               QKArgs{
-                  jblas::utils::GemmProblem{
+                  utils::GemmProblem{
                       /* .batch */ 1,
                       /* .M = */ p.sl_q,
                       /* .N = */ unmasked_size_pad_qk,
@@ -786,7 +787,7 @@ class MHAInterface {
               tpQK, /* w_offset */ ibat * K_pack_batch_off);
           for (int ii = 0; ii < M_TILE; ++ii) exp_sum[ii] = 1.f / exp_sum[ii];
 
-          typename jblas::parallel::gemm::ThreadProblemBase tpPV{
+          typename parallel::gemm::ThreadProblemBase tpPV{
               /* ThreadProblem2D */ {tid, {}, {0, 0}, {m_size, p.head_size}, true},
               /* .block = */ {M_TILE, GemmPV::NTILE, unmasked_size_pad_qk},
               /* .stacksize = */ cb.mL2Cache,
@@ -794,13 +795,13 @@ class MHAInterface {
           };
           l_scale.run(  // PxV => O
               PVArgs{
-                  jblas::utils::GemmProblem{
+                  utils::GemmProblem{
                       /* .batch */ 1,
                       /* .M = */ std::min(p.sl_q - i_m, M_TILE),
                       /* .N = */ p.head_size,
                       /* .K = */ unmasked_size_pad_qk,
                   },
-                  /* .paramA = */ PVProPArgs{(jblas::utils::bf16*)tmp, ld_tmp_exp},
+                  /* .paramA = */ PVProPArgs{(utils::bf16*)tmp, ld_tmp_exp},
                   /* .paramB = */ PVProVArgs{nullptr, 0, &V_pack},
                   /* .paramC = */
                   PVEpiArgs{
@@ -814,9 +815,9 @@ class MHAInterface {
         }
       }
     });
-    jblas::utils::afree(bufferK);
-    jblas::utils::afree(bufferV);
-    return JblasSuccess;
+    utils::afree(bufferK);
+    utils::afree(bufferV);
+    return BTLA_CODE::Success;
   }
 
  protected:
@@ -828,20 +829,20 @@ class MHAInterface {
  * @brief An Epilogue that optionally apply a casual mask (but may not filling zero) and scale the fp32 result, update
  * the maximun of each line of the reuslt, and storing exp as bf16 results
  */
-template <JBLAS_ISA ISA_T, typename T_SRC, typename T_DST>
+template <BTLA_ISA ISA_T, typename T_SRC, typename T_DST>
 class ScaleTrackMax {
  public:
   using DType = T_DST;
   using SType = T_SRC;
   struct Param;
 
-  JBLAS_CODE forward(const SType* src, const int src_step, const int M_offset, const int N_offset, const int M,
-                     const int N, const Param& p) const {
+  BTLA_CODE forward(const SType* src, const int src_step, const int M_offset, const int N_offset, const int M,
+                    const int N, const Param& p) const {
     assert(false);
-    return JblasNotSupport;
+    return BTLA_CODE::NotSupport;
   }
 };
-template <JBLAS_ISA ISA_T>
+template <BTLA_ISA ISA_T>
 class ScaleTrackMax<ISA_T, fp16, float> {
  public:
   using DType = float;
@@ -855,8 +856,8 @@ class ScaleTrackMax<ISA_T, fp16, float> {
     float alibi_slope;  // m-factor in the alibi paper for current head: https://arxiv.org/abs/2108.12409
   };
 
-  JBLAS_CODE forward(const SType* src, const int src_step, const int M_offset, const int N_offset, const int M,
-                     const int N, const Param& p, void* /* tmpcache */, size_t /* cachesize */) const {
+  BTLA_CODE forward(const SType* src, const int src_step, const int M_offset, const int N_offset, const int M,
+                    const int N, const Param& p, void* /* tmpcache */, size_t /* cachesize */) const {
     assert(("alibi not supported!", p.alibi_slope == 0.f));
     const auto dst = p.dst + M_offset * p.ld_dst + N_offset;
     const auto dst_max = p.dst_max + M_offset;
@@ -885,8 +886,8 @@ class ScaleTrackMax<ISA_T, fp16, float> {
       }
       dst_max[i] = std::max(dst_max[i], _mm512_reduce_max_ps(v_max));
 
-      // if (j < jblas::utils::padto(N, 64))
-      //   memset(dst + i * p.ld_dst + j, 0, sizeof(*dst) * (jblas::utils::padto(N, 64) - j));
+      // if (j < utils::padto(N, 64))
+      //   memset(dst + i * p.ld_dst + j, 0, sizeof(*dst) * (utils::padto(N, 64) - j));
     }
 #else
     for (int i = 0; i < M; ++i) {
@@ -897,21 +898,21 @@ class ScaleTrackMax<ISA_T, fp16, float> {
         dst[i * p.ld_dst + j] = static_cast<T_DST>(val_);
         dst_max[i] = std::max(dst_max[i], val_);
       }
-      if (N_unmasked < jblas::utils::padto(N, 64))
-        memset(dst + i * p.ld_dst + N_unmasked, 0, sizeof(*dst) * (jblas::utils::padto(N, 64) - N_unmasked));
+      if (N_unmasked < utils::padto(N, 64))
+        memset(dst + i * p.ld_dst + N_unmasked, 0, sizeof(*dst) * (utils::padto(N, 64) - N_unmasked));
     }
 #endif
 
-    return JblasSuccess;
+    return BTLA_CODE::Success;
 #else
-    return JblasNotSupport;
+    return BTLA_CODE::NotSupport;
 #endif
   }
 };
-template <JBLAS_ISA ISA_T>
+template <BTLA_ISA ISA_T>
 using ScaleTrackMaxFp16Fp32 = ScaleTrackMax<ISA_T, fp16, float>;
 
-template <JBLAS_ISA ISA_T>
+template <BTLA_ISA ISA_T>
 class ScaleTrackMax<ISA_T, float, float> {
  public:
   using DType = float;
@@ -926,15 +927,15 @@ class ScaleTrackMax<ISA_T, float, float> {
   };
   static constexpr float seq15[16]{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
 
-  JBLAS_CODE forward(const SType* src, const int src_step, const int M_offset, const int N_offset, const int M,
-                     const int N, const Param& p, void* /* tmpcache */, size_t /* cachesize */) const {
+  BTLA_CODE forward(const SType* src, const int src_step, const int M_offset, const int N_offset, const int M,
+                    const int N, const Param& p, void* /* tmpcache */, size_t /* cachesize */) const {
     return p.alibi_slope == 0 ? forward_<false>(src, src_step, M_offset, N_offset, M, N, p)
                               : forward_<true>(src, src_step, M_offset, N_offset, M, N, p);
   }
 
   template <bool HAS_ALIBI>
-  JBLAS_CODE forward_(const SType* src, const int src_step, const int M_offset, const int N_offset, const int M,
-                      const int N, const Param& p) const {
+  BTLA_CODE forward_(const SType* src, const int src_step, const int M_offset, const int N_offset, const int M,
+                     const int N, const Param& p) const {
     const auto dst = p.dst + M_offset * p.ld_dst + N_offset;
     const auto dst_max = p.dst_max + M_offset;
 #if CompileAVX512F()
@@ -968,8 +969,8 @@ class ScaleTrackMax<ISA_T, float, float> {
       }
       dst_max[i] = std::max(dst_max[i], _mm512_reduce_max_ps(v_max));
 
-      // if (j < jblas::utils::padto(N, 64))
-      //   memset(dst + i * p.ld_dst + j, 0, sizeof(*dst) * (jblas::utils::padto(N, 64) - j));
+      // if (j < utils::padto(N, 64))
+      //   memset(dst + i * p.ld_dst + j, 0, sizeof(*dst) * (utils::padto(N, 64) - j));
     }
 #else
     for (int i = 0; i < M; ++i) {
@@ -980,21 +981,21 @@ class ScaleTrackMax<ISA_T, float, float> {
         dst[i * p.ld_dst + j] = static_cast<T_DST>();
         dst_max[i] = std::max(dst_max[i], val_);
       }
-      if (N_unmasked < jblas::utils::padto(N, 64))
-        memset(dst + i * p.ld_dst + N_unmasked, 0, sizeof(*dst) * (jblas::utils::padto(N, 64) - N_unmasked));
+      if (N_unmasked < utils::padto(N, 64))
+        memset(dst + i * p.ld_dst + N_unmasked, 0, sizeof(*dst) * (utils::padto(N, 64) - N_unmasked));
     }
 #endif
 
-    return JblasSuccess;
+    return BTLA_CODE::Success;
 #else
-    return JblasNotSupport;
+    return BTLA_CODE::NotSupport;
 #endif
   }
 };
-template <JBLAS_ISA ISA_T>
+template <BTLA_ISA ISA_T>
 using ScaleTrackMaxFp32Fp32 = ScaleTrackMax<ISA_T, float, float>;
 
-template <JBLAS_ISA ISA_T>
+template <BTLA_ISA ISA_T>
 class ScaleTrackMax<ISA_T, int32_t, float> {
  public:
   using DType = float;
@@ -1008,8 +1009,8 @@ class ScaleTrackMax<ISA_T, int32_t, float> {
     float alibi_slope;  // m-factor in the alibi paper for current head: https://arxiv.org/abs/2108.12409
   };
 
-  JBLAS_CODE forward(const SType* src, const int src_step, const int M_offset, const int N_offset, const int M,
-                     const int N, const Param& p, void* /* tmpcache */, size_t /* cachesize */) const {
+  BTLA_CODE forward(const SType* src, const int src_step, const int M_offset, const int N_offset, const int M,
+                    const int N, const Param& p, void* /* tmpcache */, size_t /* cachesize */) const {
     assert(("alibi not supported!", p.alibi_slope == 0.f));
     const auto dst = p.dst + M_offset * p.ld_dst + N_offset;
     const auto dst_max = p.dst_max + M_offset;
@@ -1036,19 +1037,19 @@ class ScaleTrackMax<ISA_T, int32_t, float> {
         j += 16;
       }
       dst_max[i] = std::max(dst_max[i], _mm512_reduce_max_ps(v_max));
-      // if (j < jblas::utils::padto(N, 64))
-      //   memset(dst + i * p.ld_dst + j, 0, sizeof(*dst) * (jblas::utils::padto(N, 64) - j));
+      // if (j < utils::padto(N, 64))
+      //   memset(dst + i * p.ld_dst + j, 0, sizeof(*dst) * (utils::padto(N, 64) - j));
     }
-    return JblasSuccess;
+    return BTLA_CODE::Success;
 #else
-    return JblasNotSupport;
+    return BTLA_CODE::NotSupport;
 #endif
   }
 };
-template <JBLAS_ISA ISA_T>
+template <BTLA_ISA ISA_T>
 using ScaleTrackMaxS32Fp32 = ScaleTrackMax<ISA_T, int32_t, float>;
 
-template <class _GemmCore_T, JBLAS_ISA ISA_T>
+template <class _GemmCore_T, BTLA_ISA ISA_T>
 class WeightBase {
  public:
   using BType = typename _GemmCore_T::BType;
@@ -1059,13 +1060,13 @@ class WeightBase {
     bool is_padded;
   };
   WeightBase() {}
-  JBLAS_CODE getWeight(BType** dst_ptr, int* dst_step, const Param& p, int k_size, int n_size, int k_offset,
-                       int n_offset, void* /* tmpcache */, size_t /* cachesize */) {
+  BTLA_CODE getWeight(BType** dst_ptr, int* dst_step, const Param& p, int k_size, int n_size, int k_offset,
+                      int n_offset, void* /* tmpcache */, size_t /* cachesize */) {
     if ((n_size % _GemmCore_T::NTILE == 0) && std::is_same<SType, BType>::value &&
         0) {  // TODO(Yi) : use a gemm core accept step for K or reorder at runtime
       *dst_ptr = const_cast<SType*>(p.B) + k_offset * p.ldb + n_offset;
       *dst_step = p.ldb;
-      return JblasSuccess;
+      return BTLA_CODE::Success;
     } else if (*dst_ptr != nullptr && std::is_same<SType, BType>::value) {
       const auto src = const_cast<SType*>(p.B) + k_offset * p.ldb + n_offset;
       const auto npad = padto(n_size, _GemmCore_T::NTILE);
@@ -1074,14 +1075,14 @@ class WeightBase {
         memcpy(*dst_ptr + k * npad, src + k * p.ldb, sizeof(BType) * n_size);
         memset(*dst_ptr + k * npad + n_size, 0, sizeof(BType) * (npad - n_size));
       }
-      return JblasSuccess;
+      return BTLA_CODE::Success;
     } else {
       assert(false);
-      return JblasNotSupport;
+      return BTLA_CODE::NotSupport;
     }
   }
 };
-template <class _GemmCore_T, JBLAS_ISA ISA_T>
+template <class _GemmCore_T, BTLA_ISA ISA_T>
 class WeightForwardNTile48 {
  public:
   using BType = typename _GemmCore_T::BType;
@@ -1092,12 +1093,12 @@ class WeightForwardNTile48 {
     bool is_padded;
   };
   WeightForwardNTile48() {}
-  JBLAS_CODE getWeight(BType** dst_ptr, int* dst_step, const Param& p, int k_size, int n_size, int k_offset,
-                       int n_offset, void* /* tmpcache */, size_t /* cachesize */) {
+  BTLA_CODE getWeight(BType** dst_ptr, int* dst_step, const Param& p, int k_size, int n_size, int k_offset,
+                      int n_offset, void* /* tmpcache */, size_t /* cachesize */) {
     assert(p.is_padded);
     *dst_ptr = const_cast<SType*>(p.B) + k_offset * 48 + n_offset * p.ldb;
     *dst_step = p.ldb;
-    return JblasSuccess;
+    return BTLA_CODE::Success;
   }
 };
 template <class SRC_T, class DST_T>
@@ -1311,7 +1312,7 @@ class MHAStableInterface {
   static_assert(GemmQK::MTILE == GemmPV::MTILE, "2 GEMM should have the same M_TILE.");
   static constexpr auto M_TILE = GemmQK::MTILE;
 
-  JBLAS_CODE compute(const attn_fwd_args_t<Q_T, K_T, V_T, DST_T>& p, const jblas::parallel::IThreading& th) {
+  BTLA_CODE compute(const attn_fwd_args_t<Q_T, K_T, V_T, DST_T>& p, const parallel::IThreading& th) {
     assert((std::is_same<Q_T, int8_t>::value || p.Q_sc == 1));
     assert((std::is_same<K_T, int8_t>::value || p.K_sc == 1));
     assert((std::is_same<V_T, int8_t>::value || p.V_sc == 1));
@@ -1335,7 +1336,7 @@ class MHAStableInterface {
     assert((p.K_layout != ATTN_FWD_LAYOUT_PLAIN || p.step_v_head_size == 1));
     assert((p.V_layout != ATTN_FWD_LAYOUT_PLAIN || p.step_k_sl == 1));
     const auto num_heads = p.batch_size * p.head_num;  // Total number of heads
-    jblas::device::CpuBase cb;                         // Note: DO NOT use cb.mNumThreads; use th.num_threads() instead
+    device::CpuBase cb;                                // Note: DO NOT use cb.mNumThreads; use th.num_threads() instead
     const bool is_causal = (p.attn_flags & NE_ATTN_FLAG_IS_CAUSAL) != 0;
     const bool is_alibi = (p.attn_flags & NE_ATTN_FLAG_IS_ALIBI8) != 0;
     assert(!is_causal || p.sl_q <= p.sl_kv);
@@ -1351,7 +1352,7 @@ class MHAStableInterface {
     const auto m_tiles = updiv(p.sl_q, M_TILE);
     const auto num_tasks = num_heads * m_tiles;
 
-    using Scheduler2D = typename jblas::parallel::Scheduler2D;
+    using Scheduler2D = typename parallel::Scheduler2D;
     const Scheduler2D parl({th.num_threads(), {num_tasks, 1}, {1, 1}});  // main parallel scheduler
 
     th.parallel_for([&](int tid) {
@@ -1364,7 +1365,7 @@ class MHAStableInterface {
 
       // calculate mm + softmax + mm
       {
-        typename jblas::parallel::ThreadProblem2D thdp{tid};
+        typename parallel::ThreadProblem2D thdp{tid};
         parl.getIndex(thdp);
         const auto [task_start, _assert0] = thdp.loc;
         auto [task_size, _assert_max1] = thdp.size;
@@ -1404,7 +1405,7 @@ class MHAStableInterface {
                                    : p.K_layout == ATTN_FWD_LAYOUT_NTILE48_ROWPACK2 ? p.step_k_sl
                                                                                     : (assert(0), 0);
 
-          typename jblas::parallel::gemm::ThreadProblemBase tpQK{
+          typename parallel::gemm::ThreadProblemBase tpQK{
               /* ThreadProblem2D */ {tid, {}, {i_m, 0}, {m_size, unmasked_size_pad_qk}, true},
               /* .block = */ {M_TILE, GemmQK::NTILE, p.head_size},
               /* .stacksize = */ cb.mL2Cache,
@@ -1412,7 +1413,7 @@ class MHAStableInterface {
           };
           l_qk.run(  // QxK => S ==exp==> P
               QKArgs{
-                  jblas::utils::GemmProblem{
+                  utils::GemmProblem{
                       /* .batch */ 1,
                       /* .M = */ p.sl_q,
                       /* .N = */ unmasked_size_pad_qk,
@@ -1458,7 +1459,7 @@ class MHAStableInterface {
                                    : p.V_layout == ATTN_FWD_LAYOUT_NTILE48_ROWPACK2 ? p.step_v_head_size
                                                                                     : (assert(0), 0);
 
-          typename jblas::parallel::gemm::ThreadProblemBase tpPV{
+          typename parallel::gemm::ThreadProblemBase tpPV{
               /* ThreadProblem2D */ {tid, {}, {0, 0}, {m_size, p.head_size}, true},
               /* .block = */ {M_TILE, GemmPV::NTILE, unmasked_size_pad_pv},
               /* .stacksize = */ cb.mL2Cache,
@@ -1466,7 +1467,7 @@ class MHAStableInterface {
           };
           l_pv.run(  // PxV => O
               PVArgs{
-                  jblas::utils::GemmProblem{
+                  utils::GemmProblem{
                       /* .batch */ 1,
                       /* .M = */ std::min(p.sl_q - i_m, M_TILE),
                       /* .N = */ p.head_size,
@@ -1488,7 +1489,7 @@ class MHAStableInterface {
         }
       }
     });
-    return JblasSuccess;
+    return BTLA_CODE::Success;
   }
 
  protected:
@@ -1497,89 +1498,89 @@ class MHAStableInterface {
 };
 
 template <typename Q_T, typename K_T, typename V_T, typename DST_T>
-void jblas_fusion_attn_forward(const attn_fwd_args_t<Q_T, K_T, V_T, DST_T>& params) = delete;
+void bestla_fusion_attn_forward(const attn_fwd_args_t<Q_T, K_T, V_T, DST_T>& params) = delete;
 
-template <class GEMM_T, JBLAS_ISA ISA_T>
+template <class GEMM_T, BTLA_ISA ISA_T>
 using WeightPackBatchBf16Bf16NonTr = WeightPackBatchBf16NonTr<GEMM_T, ISA_T, bf16>;
-template <class GEMM_T, JBLAS_ISA ISA_T>
+template <class GEMM_T, BTLA_ISA ISA_T>
 using WeightPackBatchBf16Bf16Trans = WeightPackBatchBf16Trans<GEMM_T, ISA_T, bf16>;
 template <>
-void jblas_fusion_attn_forward<bf16, bf16, bf16, bf16>(const attn_fwd_args_t<bf16, bf16, bf16, bf16>& p) {
+void bestla_fusion_attn_forward<bf16, bf16, bf16, bf16>(const attn_fwd_args_t<bf16, bf16, bf16, bf16>& p) {
   using GemmKernelBF16ExpSum = ::LauncherBaseOff<  //
-      JblasAMX_BF16,                               //
-      jblas::gemm::HCoreRowNAmxbf16<64, 16>,       //
-      jblas::prologue_a::gemm::ActivationBase,     //
+      BTLA_ISA::AMX_BF16,                          //
+      gemm::HCoreRowNAmxbf16<64, 16>,              //
+      prologue_a::gemm::ActivationBase,            //
       WeightPackBatchBf16Bf16Trans,                //
       ::ScaleExpAccSumFp32Bf16>;                   //
   using GemmKernelBF16 = ::LauncherBaseOff<        //
-      JblasAMX_BF16,                               //
-      jblas::gemm::HCoreRowNAmxbf16<64, 16>,       //
-      jblas::prologue_a::gemm::ActivationBase,     //
+      BTLA_ISA::AMX_BF16,                          //
+      gemm::HCoreRowNAmxbf16<64, 16>,              //
+      prologue_a::gemm::ActivationBase,            //
       WeightPackBatchBf16Bf16NonTr,                //
       ::ScaleWriteBackFp32Bf16>;
   static MHAInterface<GemmKernelBF16ExpSum, GemmKernelBF16> kernel;
-  const auto pth = ne_jblas::ne_threading::get();
+  const auto pth = ne_threading::get();
   [[maybe_unused]] const auto ret = kernel.compute(p, *pth);
-  assert(ret == JblasSuccess);
+  assert(ret == BTLA_CODE::Success);
 }
 
-template <class GEMM_T, JBLAS_ISA ISA_T>
+template <class GEMM_T, BTLA_ISA ISA_T>
 using WeightPackBatchFp16Bf16NonTr = WeightPackBatchBf16NonTr<GEMM_T, ISA_T, fp16>;
-template <class GEMM_T, JBLAS_ISA ISA_T>
+template <class GEMM_T, BTLA_ISA ISA_T>
 using WeightPackBatchFp16Bf16Trans = WeightPackBatchBf16Trans<GEMM_T, ISA_T, fp16>;
 template <>
-void jblas_fusion_attn_forward<float, fp16, fp16, float>(const attn_fwd_args_t<float, fp16, fp16, float>& params) {
+void bestla_fusion_attn_forward<float, fp16, fp16, float>(const attn_fwd_args_t<float, fp16, fp16, float>& params) {
   GetCPUDevice();
-  const auto pth = ne_jblas::ne_threading::get();
+  const auto pth = ne_threading::get();
   if (MHA_PREFER_AVX512FP16 && _cd->AVX512_FP16() && params.step_k_sl == 1) {
-    using GemmKernelFP16TrackMax = ::LauncherBaseWeight<   //
-        JblasAVX512_FP16,                                  //
-        jblas::gemm::HCoreRowNAvx512fp16<64, 8>,           //
-        jblas::prologue_a::gemm::ActivationConverterFp32,  //
-        ::WeightBase,                                      //
-        ::ScaleTrackMaxFp16Fp32>;                          //
-    using GemmKernelFP16 = ::LauncherBaseWeight<           //
-        JblasAVX512_FP16,                                  //
-        jblas::gemm::HCoreRowNAvx512fp16<64, 8>,           //
-        jblas::prologue_a::gemm::ActivationBase,           //
-        ::WeightBase,                                      //
-        jblas::epilogue::gemm::AccumulatorWriteBackFp16Fp32>;
+    using GemmKernelFP16TrackMax = ::LauncherBaseWeight<  //
+        BTLA_ISA::AVX512_FP16,                            //
+        gemm::HCoreRowNAvx512fp16<64, 8>,                 //
+        prologue_a::gemm::ActivationConverterFp32,        //
+        ::WeightBase,                                     //
+        ::ScaleTrackMaxFp16Fp32>;                         //
+    using GemmKernelFP16 = ::LauncherBaseWeight<          //
+        BTLA_ISA::AVX512_FP16,                            //
+        gemm::HCoreRowNAvx512fp16<64, 8>,                 //
+        prologue_a::gemm::ActivationBase,                 //
+        ::WeightBase,                                     //
+        epilogue::gemm::AccumulatorWriteBackFp16Fp32>;
     static MHAStableInterface<GemmKernelFP16TrackMax, GemmKernelFP16> kernel;
     [[maybe_unused]] const auto ret = kernel.compute(params, *pth);
-    assert(ret == JblasSuccess);
+    assert(ret == BTLA_CODE::Success);
   } else if (_cd->AMX_BF16()) {
     if (params.step_k_head_size == 1) {
       using GemmKernelFP32FP16BF16ExpSum = ::LauncherBaseOff<  //
-          JblasAMX_BF16,                                       //
-          jblas::gemm::HCoreRowNAmxbf16<64, 16>,               //
-          jblas::prologue_a::gemm::ActivationConverterFp32,    //
+          BTLA_ISA::AMX_BF16,                                  //
+          gemm::HCoreRowNAmxbf16<64, 16>,                      //
+          prologue_a::gemm::ActivationConverterFp32,           //
           WeightPackBatchFp16Bf16Trans,                        //
           ::ScaleExpAccSumFp32Bf16>;                           //
       using GemmKernelBF16FP16FP32 = ::LauncherBaseOff<        //
-          JblasAMX_BF16,                                       //
-          jblas::gemm::HCoreRowNAmxbf16<64, 16>,               //
-          jblas::prologue_a::gemm::ActivationBase,             //
+          BTLA_ISA::AMX_BF16,                                  //
+          gemm::HCoreRowNAmxbf16<64, 16>,                      //
+          prologue_a::gemm::ActivationBase,                    //
           WeightPackBatchFp16Bf16NonTr,                        //
           ::ScaleWriteBackFp32Fp32>;
       static MHAInterface<GemmKernelFP32FP16BF16ExpSum, GemmKernelBF16FP16FP32> kernel;
       [[maybe_unused]] const auto ret = kernel.compute(params, *pth);
-      assert(ret == JblasSuccess);
+      assert(ret == BTLA_CODE::Success);
     } else if (params.step_k_sl == 1) {
       using GemmKernelFP32FP16BF16ExpSum = ::LauncherBaseOff<  //
-          JblasAMX_BF16,                                       //
-          jblas::gemm::HCoreRowNAmxbf16<64, 16>,               //
-          jblas::prologue_a::gemm::ActivationConverterFp32,    //
+          BTLA_ISA::AMX_BF16,                                  //
+          gemm::HCoreRowNAmxbf16<64, 16>,                      //
+          prologue_a::gemm::ActivationConverterFp32,           //
           WeightPackBatchFp16Bf16NonTr,                        //
           ::ScaleExpAccSumFp32Bf16>;                           //
       using GemmKernelBF16FP16FP32 = ::LauncherBaseOff<        //
-          JblasAMX_BF16,                                       //
-          jblas::gemm::HCoreRowNAmxbf16<64, 16>,               //
-          jblas::prologue_a::gemm::ActivationBase,             //
+          BTLA_ISA::AMX_BF16,                                  //
+          gemm::HCoreRowNAmxbf16<64, 16>,                      //
+          prologue_a::gemm::ActivationBase,                    //
           WeightPackBatchFp16Bf16NonTr,                        //
           ::ScaleWriteBackFp32Fp32>;
       static MHAInterface<GemmKernelFP32FP16BF16ExpSum, GemmKernelBF16FP16FP32> kernel;
       [[maybe_unused]] const auto ret = kernel.compute(params, *pth);
-      assert(ret == JblasSuccess);
+      assert(ret == BTLA_CODE::Success);
     }
   } else {
     assert(false);  // no suitbale launcher
@@ -1587,67 +1588,67 @@ void jblas_fusion_attn_forward<float, fp16, fp16, float>(const attn_fwd_args_t<f
 }
 
 template <>
-void jblas_fusion_attn_forward<fp16, fp16, fp16, fp16>(const attn_fwd_args_t<fp16, fp16, fp16, fp16>& params) {
+void bestla_fusion_attn_forward<fp16, fp16, fp16, fp16>(const attn_fwd_args_t<fp16, fp16, fp16, fp16>& params) {
   GetCPUDevice();
-  const auto pth = ne_jblas::ne_threading::get();
+  const auto pth = ne_threading::get();
   if (_cd->AMX_BF16()) {
     using GemmKernelFP16TrackMax = ::LauncherBaseWeight<  //
-        JblasAVX512_FP16,                                 //
-        jblas::gemm::HCoreRowNAvx512fp16<64, 8>,          //
-        jblas::prologue_a::gemm::ActivationBase,          //
+        BTLA_ISA::AVX512_FP16,                            //
+        gemm::HCoreRowNAvx512fp16<64, 8>,                 //
+        prologue_a::gemm::ActivationBase,                 //
         ::WeightBase,                                     //
         ::ScaleTrackMaxFp16Fp32>;                         //
     using GemmKernelFP16 = ::LauncherBaseWeight<          //
-        JblasAVX512_FP16,                                 //
-        jblas::gemm::HCoreRowNAvx512fp16<64, 8>,          //
-        jblas::prologue_a::gemm::ActivationBase,          //
+        BTLA_ISA::AVX512_FP16,                            //
+        gemm::HCoreRowNAvx512fp16<64, 8>,                 //
+        prologue_a::gemm::ActivationBase,                 //
         ::WeightBase,                                     //
-        jblas::epilogue::gemm::AccumulatorWriteBackFp16>;
+        epilogue::gemm::AccumulatorWriteBackFp16>;
     static MHAStableInterface<GemmKernelFP16TrackMax, GemmKernelFP16> kernel;
     [[maybe_unused]] const auto ret = kernel.compute(params, *pth);
-    assert(ret == JblasSuccess);
+    assert(ret == BTLA_CODE::Success);
   } else {
     assert(0);
   }
 }
 
 template <>
-void jblas_fusion_attn_forward<int8_t, int8_t, int8_t, int8_t>(
+void bestla_fusion_attn_forward<int8_t, int8_t, int8_t, int8_t>(
     const attn_fwd_args_t<int8_t, int8_t, int8_t, int8_t>& params) {
   GetCPUDevice();
-  const auto pth = ne_jblas::ne_threading::get();
+  const auto pth = ne_threading::get();
   if (/* params.sl_q > 4 &&  */ _cd->AMX_INT8()) {         // TODO(Yi): add vnni impl
     using GemmKernelInt32TrackMax = ::LauncherBaseWeight<  //
-        JblasAMX_INT8,                                     //
-        jblas::gemm::ICoreRowNAmxint8SS<48, 16>,           //
-        jblas::prologue_a::gemm::ActivationBase,           //
+        BTLA_ISA::AMX_INT8,                                //
+        gemm::ICoreRowNAmxint8SS<48, 16>,                  //
+        prologue_a::gemm::ActivationBase,                  //
         ::WeightForwardNTile48,                            //
         ::ScaleTrackMaxS32Fp32>;                           //
     using GemmKernelInt32 = ::LauncherBaseWeight<          //
-        JblasAMX_INT8,                                     //
-        jblas::gemm::ICoreRowNAmxint8<48, 16>,             //
-        jblas::prologue_a::gemm::ActivationBase,           //
+        BTLA_ISA::AMX_INT8,                                //
+        gemm::ICoreRowNAmxint8<48, 16>,                    //
+        prologue_a::gemm::ActivationBase,                  //
         ::WeightForwardNTile48,                            //
         ::ScaleWriteBackS32S8>;                            //
     static MHAStableInterface<GemmKernelInt32TrackMax, GemmKernelInt32> mha;
     [[maybe_unused]] const auto ret = mha.compute(params, *pth);
-    assert(ret == JblasSuccess);
+    assert(ret == BTLA_CODE::Success);
   } else if (_cd->AVX512_VNNI()) {
     // using GemmKernelInt32TrackMax = ::LauncherBaseWeight<  //
-    //     JblasAMX_INT8,                                         // TODO(Yi): s8s8 vnni kernel?
-    //     jblas::gemm::GemmCore_Row_NN_16x48_AMX_S8S8,           //
-    //     jblas::prologue::gemm::ActivationBase,                 //
+    //     BTLA_ISA::AMX_INT8,                                         // TODO(Yi): s8s8 vnni kernel?
+    //     gemm::GemmCore_Row_NN_16x48_AMX_S8S8,           //
+    //     prologue::gemm::ActivationBase,                 //
     //     ::WeightForwardNTile48,                                          //
     //     ::ScaleTrackMaxS32Fp32>;                               //
     // using GemmKernelInt32 = ::LauncherBaseWeight<          //
-    //     JblasAVX512_VNNI,                                      //
-    //     jblas::gemm::GemmCore_Row_NN_8x48_AVX512_VNNI,         //
-    //     jblas::prologue::gemm::ActivationBase,                 //
+    //     BTLA_ISA::AVX512_VNNI,                                      //
+    //     gemm::GemmCore_Row_NN_8x48_AVX512_VNNI,         //
+    //     prologue::gemm::ActivationBase,                 //
     //     ::WeightForwardNTile48,                                          //
     //     ::ScaleWriteBackS32S8>;                                //
     // static MHAStableInterface<GemmKernelInt32TrackMax, GemmKernelInt32> mha;
     // [[maybe_unused]] const auto ret = mha.compute(params);
-    // assert(ret == JblasSuccess);
+    // assert(ret == BTLA_CODE::Success);
     assert(0);
   } else {
     assert(0);
@@ -1655,32 +1656,32 @@ void jblas_fusion_attn_forward<int8_t, int8_t, int8_t, int8_t>(
 }
 
 template <>
-void jblas_fusion_attn_forward<float, bf16, bf16, float>(const attn_fwd_args_t<float, bf16, bf16, float>& params) {
+void bestla_fusion_attn_forward<float, bf16, bf16, float>(const attn_fwd_args_t<float, bf16, bf16, float>& params) {
   GetCPUDevice();
-  const auto pth = ne_jblas::ne_threading::get();
-  if (/* params.sl_q > 4 &&  */ _cd->AMX_BF16()) {         // TODO(Yi): add vdpbf16ps impl
-    using GemmKernelBF16TrackMax = ::LauncherBaseWeight<   //
-        JblasAMX_BF16,                                     //
-        jblas::gemm::HCoreRowNAmxbf16<48, 16>,             //
-        jblas::prologue_a::gemm::ActivationConverterFp32,  //
-        ::WeightForwardNTile48,                            //
-        ::ScaleTrackMaxFp32Fp32>;                          //
-    using GemmKernelBF16 = ::LauncherBaseWeight<           //
-        JblasAMX_BF16,                                     //
-        jblas::gemm::HCoreRowNAmxbf16<48, 16>,             //
-        ::ActivationIdentity,                              // pretty sure we have enough paddings for P-matrix
-        ::WeightForwardNTile48,                            //
-        jblas::epilogue::gemm::AccumulatorWriteBackFp32>;  //
+  const auto pth = ne_threading::get();
+  if (/* params.sl_q > 4 &&  */ _cd->AMX_BF16()) {        // TODO(Yi): add vdpbf16ps impl
+    using GemmKernelBF16TrackMax = ::LauncherBaseWeight<  //
+        BTLA_ISA::AMX_BF16,                               //
+        gemm::HCoreRowNAmxbf16<48, 16>,                   //
+        prologue_a::gemm::ActivationConverterFp32,        //
+        ::WeightForwardNTile48,                           //
+        ::ScaleTrackMaxFp32Fp32>;                         //
+    using GemmKernelBF16 = ::LauncherBaseWeight<          //
+        BTLA_ISA::AMX_BF16,                               //
+        gemm::HCoreRowNAmxbf16<48, 16>,                   //
+        ::ActivationIdentity,                             // pretty sure we have enough paddings for P-matrix
+        ::WeightForwardNTile48,                           //
+        epilogue::gemm::AccumulatorWriteBackFp32>;        //
     static MHAStableInterface<GemmKernelBF16TrackMax, GemmKernelBF16> mha;
     [[maybe_unused]] const auto ret = mha.compute(params, *pth);
-    assert(ret == JblasSuccess);
+    assert(ret == BTLA_CODE::Success);
   } else {
     assert(0);
   }
 }
 
 template <typename Q_T, typename K_T, typename V_T, typename DST_T>
-void jblas_fusion_attn_forward_ref(const attn_fwd_args_t<Q_T, K_T, V_T, DST_T>& p) {
+void bestla_fusion_attn_forward_ref(const attn_fwd_args_t<Q_T, K_T, V_T, DST_T>& p) {
   const bool is_causal = (p.attn_flags & NE_ATTN_FLAG_IS_CAUSAL) != 0;
   const bool is_alibi = (p.attn_flags & NE_ATTN_FLAG_IS_ALIBI8) != 0;
   assert(!is_causal || p.sl_q <= p.sl_kv);
@@ -1689,7 +1690,7 @@ void jblas_fusion_attn_forward_ref(const attn_fwd_args_t<Q_T, K_T, V_T, DST_T>&
   attn_shape_t attn_shape{
       p.batch_size, p.head_num, p.heads_kv, p.head_size, p.sl_q, p.sl_kv,
   };
-  const auto workspace_size = jblas_fusion_attn_workspace_size(&attn_shape);
+  const auto workspace_size = bestla_fusion_attn_workspace_size(&attn_shape);
   static std::mt19937 rng;
   static std::uniform_int_distribution<> dist;
 #ifdef NE_TESTS
@@ -1808,11 +1809,11 @@ void jblas_fusion_attn_forward_ref(const attn_fwd_args_t<Q_T, K_T, V_T, DST_T>&
 }
 }  // namespace
 
-void jblas_fusion_attn_bf16_forward(const attn_bf16_fwd_args_t* params) {
-  return jblas_fusion_attn_forward(*reinterpret_cast<const attn_fwd_args_t<bf16, bf16, bf16, bf16>*>(params));
+void bestla_fusion_attn_bf16_forward(const attn_bf16_fwd_args_t* params) {
+  return bestla_fusion_attn_forward(*reinterpret_cast<const attn_fwd_args_t<bf16, bf16, bf16, bf16>*>(params));
 }
 
-bool jblas_fusion_attn_fp32_fp16_fp16_fp32_support(const attn_shape_t* params) {
+bool bestla_fusion_attn_fp32_fp16_fp16_fp32_support(const attn_shape_t* params) {
 #if CompileBF16()
   GetCPUDevice();
   // TODO(Yi): check K V's layout
@@ -1820,12 +1821,12 @@ bool jblas_fusion_attn_fp32_fp16_fp16_fp32_support(const attn_shape_t* params) {
 #endif
   return false;
 }
-void jblas_fusion_attn_fp32_fp16_fp16_fp32_forward(const attn_fp32_fp16_fp16_fp32_fwd_args_t* params) {
-  return jblas_fusion_attn_forward(*reinterpret_cast<const attn_fwd_args_t<float, fp16, fp16, float>*>(params));
-  // return jblas_fusion_attn_forward_ref(*reinterpret_cast<const attn_fwd_args_t<float, fp16, fp16, float>*>(params));
+void bestla_fusion_attn_fp32_fp16_fp16_fp32_forward(const attn_fp32_fp16_fp16_fp32_fwd_args_t* params) {
+  return bestla_fusion_attn_forward(*reinterpret_cast<const attn_fwd_args_t<float, fp16, fp16, float>*>(params));
+  // return bestla_fusion_attn_forward_ref(*reinterpret_cast<const attn_fwd_args_t<float, fp16, fp16, float>*>(params));
 }
 
-bool jblas_fusion_attn_fp16_support(const attn_shape_t* params) {
+bool bestla_fusion_attn_fp16_support(const attn_shape_t* params) {
 #if CompileFP16()
   GetCPUDevice();
   // TODO(Yi): check K V's layout
@@ -1833,20 +1834,20 @@ bool jblas_fusion_attn_fp16_support(const attn_shape_t* params) {
 #endif
   return false;
 }
-void jblas_fusion_attn_fp16_forward(const attn_fp16_fwd_args_t* params) {
-  return jblas_fusion_attn_forward<fp16, fp16, fp16, fp16>(
+void bestla_fusion_attn_fp16_forward(const attn_fp16_fwd_args_t* params) {
+  return bestla_fusion_attn_forward<fp16, fp16, fp16, fp16>(
       *reinterpret_cast<const attn_fwd_args_t<fp16, fp16, fp16, fp16>*>(params));
 }
-void jblas_fusion_attn_int8_forward(const attn_int8_fwd_args_t* params) {
-  return jblas_fusion_attn_forward<int8_t, int8_t, int8_t, int8_t>(
+void bestla_fusion_attn_int8_forward(const attn_int8_fwd_args_t* params) {
+  return bestla_fusion_attn_forward<int8_t, int8_t, int8_t, int8_t>(
       *reinterpret_cast<const attn_fwd_args_t<int8_t, int8_t, int8_t, int8_t>*>(params));
 }
-size_t jblas_fusion_attn_workspace_size(const attn_shape_t* params) {
+size_t bestla_fusion_attn_workspace_size(const attn_shape_t* params) {
   const auto& p = *params;  // TODO(Yi): Better way to get tmp size?
-  return size_t(ne_jblas::ne_threading::get()->num_threads() * sizeof(float) * 16) * padto(padto(p.sl_kv, 48), 64);
+  return size_t(ne_threading::get()->num_threads() * sizeof(float) * 16) * padto(padto(p.sl_kv, 48), 64);
 }
 
-bool jblas_reordered_attn_fp32_support(const attn_shape_t* params) {
+bool bestla_reordered_attn_fp32_support(const attn_shape_t* params) {
 #if CompileBF16()
   GetCPUDevice();
   // TODO(Yi): check K V's layout
@@ -1855,7 +1856,7 @@ bool jblas_reordered_attn_fp32_support(const attn_shape_t* params) {
   return false;
 }
 // kv cache sizes in bytes per layer per batch per beam for;
-void jblas_reordered_attn_fp32_batch_kv_info(const kv_shape_t* params, kv_cache_info_t* out) {
+void bestla_reordered_attn_fp32_batch_kv_info(const kv_shape_t* params, kv_cache_info_t* out) {
   // use bf16 for kv-cache
   const auto p = *params;
   out->k_layout = ATTN_FWD_LAYOUT_NTILE48_ROWPACK2;
@@ -1872,11 +1873,11 @@ void jblas_reordered_attn_fp32_batch_kv_info(const kv_shape_t* params, kv_cache_
   out->v_bytes = out->stride_v_head_num * p.heads_kv;
 }
 
-void jblas_reordered_attn_fp32_forward(const jblas_reordered_attn_fp32_fp32_fwd_args_t* params) {
+void bestla_reordered_attn_fp32_forward(const bestla_reordered_attn_fp32_fp32_fwd_args_t* params) {
   assert(params->K_layout == ATTN_FWD_LAYOUT_NTILE48_ROWPACK2);
   assert(params->V_layout == ATTN_FWD_LAYOUT_NTILE48_ROWPACK2);
 
-  const attn_fwd_args_t<float, bf16, bf16, float> jblas_params = {
+  const attn_fwd_args_t<float, bf16, bf16, float> bestla_params = {
       /* .Q = */ params->Q,
       /* .K = */ reinterpret_cast<bf16*>(params->K),
       /* .V = */ reinterpret_cast<bf16*>(params->V),
@@ -1913,11 +1914,11 @@ void jblas_reordered_attn_fp32_forward(const jblas_reordered_attn_fp32_fp32_fwd_
       /* .step_dst_head_num = */ params->step_dst_head_num,
       /* .step_dst_sl = */ params->step_dst_sl,
   };
-  return jblas_fusion_attn_forward<float, bf16, bf16, float>(jblas_params);
+  return bestla_fusion_attn_forward<float, bf16, bf16, float>(bestla_params);
 }
 
 template <bool zero_padding>
-void jblas_reordered_attn_fp32_update_k_(const jblas_fusion_attn_fp32_update_kv_args_t* params) {
+void bestla_reordered_attn_fp32_update_k_(const bestla_fusion_attn_fp32_update_kv_args_t* params) {
   const auto p = *params;
   NE_ASSERT(p.step_head_size == 1);
   const auto pad_headsize = padto(p.head_size, 32);
@@ -1934,7 +1935,7 @@ void jblas_reordered_attn_fp32_update_k_(const jblas_fusion_attn_fp32_update_kv_
       const auto src = p.src + ibs * p.step_bs + ihn * p.step_head_num;
 
       if (use_jit) {
-        jblas::kernel::jit::PaddingTransInterleaveCvt::forward<48>(  //
+        kernel::jit::PaddingTransInterleaveCvt::forward<48>(  //
             src, dst, p.seq_size, p.head_size, padto(p.seq_size, 48), padto(p.head_size, 32), p.step_seq, pad_headsize);
       } else {
         for (int i = 0; i < p.seq_size; ++i) {      // QK_GEMM should not require 0-padding on seq_kv (i.e. N-dim)
@@ -1957,13 +1958,13 @@ void jblas_reordered_attn_fp32_update_k_(const jblas_fusion_attn_fp32_update_kv_
     }
   }
 }
-void jblas_reordered_attn_fp32_update_k(const jblas_fusion_attn_fp32_update_kv_args_t* params) {
-  return params->no_zeroing ? jblas_reordered_attn_fp32_update_k_<false>(params)
-                            : jblas_reordered_attn_fp32_update_k_<true>(params);
+void bestla_reordered_attn_fp32_update_k(const bestla_fusion_attn_fp32_update_kv_args_t* params) {
+  return params->no_zeroing ? bestla_reordered_attn_fp32_update_k_<false>(params)
+                            : bestla_reordered_attn_fp32_update_k_<true>(params);
 }
 
 template <bool zero_padding>
-void jblas_reordered_attn_fp32_update_v_(const jblas_fusion_attn_fp32_update_kv_args_t* params) {
+void bestla_reordered_attn_fp32_update_v_(const bestla_fusion_attn_fp32_update_kv_args_t* params) {
   const auto p = *params;
   NE_ASSERT(p.step_head_size == 1);
   const auto pad_headsize = padto(p.head_size, 48);
@@ -1979,7 +1980,7 @@ void jblas_reordered_attn_fp32_update_v_(const jblas_fusion_attn_fp32_update_kv_
       const auto dst = reinterpret_cast<bf16*>(p.cache) + ibs * step_cache_bs + ihn * step_cache_head_num;
       const auto src = p.src + ibs * p.step_bs + ihn * p.step_head_num;
       if (use_jit) {
-        jblas::kernel::jit::PaddingInterleaveCvt::forward<48>(  //
+        kernel::jit::PaddingInterleaveCvt::forward<48>(  //
             src, dst, p.seq_size, p.head_size, padto(p.seq_size, 32), padto(p.head_size, 48), p.step_seq, pad_seq_max);
       } else {
         for (int i = 0; i < padto(p.seq_off + p.seq_size, 32) - p.seq_off; ++i) {  // K-dim padding for PV_GEMM
@@ -2002,13 +2003,13 @@ void jblas_reordered_attn_fp32_update_v_(const jblas_fusion_attn_fp32_update_kv_
     }
   }
 }
-void jblas_reordered_attn_fp32_update_v(const jblas_fusion_attn_fp32_update_kv_args_t* params) {
-  return params->no_zeroing ? jblas_reordered_attn_fp32_update_v_<false>(params)
-                            : jblas_reordered_attn_fp32_update_v_<true>(params);
+void bestla_reordered_attn_fp32_update_v(const bestla_fusion_attn_fp32_update_kv_args_t* params) {
+  return params->no_zeroing ? bestla_reordered_attn_fp32_update_v_<false>(params)
+                            : bestla_reordered_attn_fp32_update_v_<true>(params);
 }
 
-void jblas_reordered_attn_fp32_shift_rope_k(char* cache, const ne_fp16_t* cossin, int batch_size, int heads_kv,
-                                            int head_size, int seq_max, int seq_keep) {
+void bestla_reordered_attn_fp32_shift_rope_k(char* cache, const ne_fp16_t* cossin, int batch_size, int heads_kv,
+                                             int head_size, int seq_max, int seq_keep) {
   const auto pad_headsize = padto(head_size, 32);
   const auto pad_seq_max = padto(seq_max, 48);
   const auto cache_step_head_num = pad_headsize * pad_seq_max;
@@ -2018,13 +2019,13 @@ void jblas_reordered_attn_fp32_shift_rope_k(char* cache, const ne_fp16_t* cossin
   for (int ibs = 0; ibs < batch_size; ++ibs)
     for (int ihn = 0; ihn < heads_kv; ++ihn) {
       const auto src = reinterpret_cast<bf16*>(cache) + ibs * cache_step_bs + ihn * cache_step_head_num;
-      jblas::kernel::jit::CScaleInterleavedBF16FP16::forward<48>(  // NOLINT [build/include_what_you_use]
+      kernel::jit::CScaleInterleavedBF16FP16::forward<48>(  // NOLINT [build/include_what_you_use]
           src, reinterpret_cast<const fp16*>(cossin), head_size, pad_seq_max, pad_headsize, seq_keep);
     }
 }
 
 template <bool zero_padding>
-void jblas_fusion_attn_fp32_batch_cpy_k_(const jblas_fusion_attn_fp32_batch_cpy_kv_args_t* params) {
+void bestla_fusion_attn_fp32_batch_cpy_k_(const bestla_fusion_attn_fp32_batch_cpy_kv_args_t* params) {
   static constexpr auto N_TILE = 48;
   static constexpr auto K_TILE = 32;
   static constexpr auto K_PACK = 2;
@@ -2058,13 +2059,13 @@ void jblas_fusion_attn_fp32_batch_cpy_k_(const jblas_fusion_attn_fp32_batch_cpy_
     }
   }
 }
-void jblas_fusion_attn_fp32_batch_cpy_k(const jblas_fusion_attn_fp32_batch_cpy_kv_args_t* params) {
-  return params->no_zeroing ? jblas_fusion_attn_fp32_batch_cpy_k_<false>(params)
-                            : jblas_fusion_attn_fp32_batch_cpy_k_<true>(params);
+void bestla_fusion_attn_fp32_batch_cpy_k(const bestla_fusion_attn_fp32_batch_cpy_kv_args_t* params) {
+  return params->no_zeroing ? bestla_fusion_attn_fp32_batch_cpy_k_<false>(params)
+                            : bestla_fusion_attn_fp32_batch_cpy_k_<true>(params);
 }
 
 template <bool zero_padding>
-void jblas_fusion_attn_fp32_batch_cpy_v_(const jblas_fusion_attn_fp32_batch_cpy_kv_args_t* params) {
+void bestla_fusion_attn_fp32_batch_cpy_v_(const bestla_fusion_attn_fp32_batch_cpy_kv_args_t* params) {
   static constexpr auto N_TILE = 48;
   static constexpr auto K_TILE = 32;
   static constexpr auto K_PACK = 2;
@@ -2096,9 +2097,9 @@ void jblas_fusion_attn_fp32_batch_cpy_v_(const jblas_fusion_attn_fp32_batch_cpy_
     }
   }
 }
-void jblas_fusion_attn_fp32_batch_cpy_v(const jblas_fusion_attn_fp32_batch_cpy_kv_args_t* params) {
-  return params->no_zeroing ? jblas_fusion_attn_fp32_batch_cpy_v_<false>(params)
-                            : jblas_fusion_attn_fp32_batch_cpy_v_<true>(params);
+void bestla_fusion_attn_fp32_batch_cpy_v(const bestla_fusion_attn_fp32_batch_cpy_kv_args_t* params) {
+  return params->no_zeroing ? bestla_fusion_attn_fp32_batch_cpy_v_<false>(params)
+                            : bestla_fusion_attn_fp32_batch_cpy_v_<true>(params);
 }
 
 #ifdef __GNUC__
@@ -2124,8 +2125,8 @@ class TestMhaDese {
     printf("Test suit: %s\n", __FUNCTION__);
     CheckISA(AMX_BF16);
     GetCPUDevice();
-    ne_jblas::ne_threading::get()->set_threads(std::min(_cd->getThreads(), omp_get_max_threads()));
-    jblas::utils::request_perm_xtile_data();
+    ne_threading::get()->set_threads(std::min(_cd->getThreads(), omp_get_max_threads()));
+    utils::request_perm_xtile_data();
 
 #if CompileFP16()
     ret_ok &= test_case<float, fp16, fp16, float>({1, 1, 1, 32, 128, 64}, NE_ATTN_FLAG_NONE);
@@ -2227,7 +2228,7 @@ class TestMhaDese {
     std::vector<V_T> src_v(batch_size * heads_kv * v_rows_pad * v_cols_pad);
     std::vector<DST_T> dst(batch_size * head_num * sl_q * head_size);
     std::vector<DST_T> ref(batch_size * head_num * sl_q * head_size);  // reference result
-    std::vector<char> tmp(jblas_fusion_attn_workspace_size(&s));
+    std::vector<char> tmp(bestla_fusion_attn_workspace_size(&s));
 
     // init vector
     static std::mt19937 rng(1);
@@ -2319,10 +2320,10 @@ class TestMhaDese {
       args.step_v_head_size = v_rows_pad;
     }
 
-    jblas_fusion_attn_forward_ref(args);
+    bestla_fusion_attn_forward_ref(args);
 
     args.dst = dst.data();
-    jblas_fusion_attn_forward(args);
+    bestla_fusion_attn_forward(args);
 
     // Check result
     return compare_data(dst.data(), ref.data(), dst.size(), eps);
@@ -2350,7 +2351,7 @@ class TestMhaDese {
         /* .sl_kv_max */ static_cast<uint32_t>(sl_kv_max),
     };
     kv_cache_info_t kv_cache_info;
-    jblas_reordered_attn_fp32_batch_kv_info(&kv_shape, &kv_cache_info);
+    bestla_reordered_attn_fp32_batch_kv_info(&kv_shape, &kv_cache_info);
     assert(kv_cache_info.k_layout >= kv_cache_info.v_layout);
     const auto kv_layout = kv_cache_info.k_layout;
     const auto NTILE = kv_layout == ATTN_FWD_LAYOUT_NTILE48_ROWPACK4   ? 48
@@ -2372,7 +2373,7 @@ class TestMhaDese {
     std::vector<char> v_cache(batch_size * kv_cache_info.v_bytes);
     std::vector<DST_T> dst(batch_size * head_num * sl_q * head_size);
     std::vector<DST_T> ref(batch_size * head_num * sl_q * head_size);  // reference result
-    std::vector<char> tmp(jblas_fusion_attn_workspace_size(&s));
+    std::vector<char> tmp(bestla_fusion_attn_workspace_size(&s));
 
     // init vector
     static std::mt19937 rng(1);
@@ -2432,14 +2433,14 @@ class TestMhaDese {
         /* .step_dst_head_num = */ head_size,
         /* .step_dst_sl = */ head_num * head_size,
     };
-    jblas_fusion_attn_forward_ref(ref_args);
+    bestla_fusion_attn_forward_ref(ref_args);
 
     if (std::is_same<std::tuple<Q_T, K_T, V_T, DST_T>, std::tuple<float, float, float, float>>::value) {
       assert(kv_layout == ATTN_FWD_LAYOUT_NTILE48_ROWPACK2);
       // for testing, first reorder sl_kv - 1 and than concat the last 1 line
       const auto seq_size_first = sl_kv - 1;
       const auto seq_size_next = 1;
-      jblas_fusion_attn_fp32_update_kv_args_t update_k_args = {
+      bestla_fusion_attn_fp32_update_kv_args_t update_k_args = {
           /* .src = */ src_k.data(),
           /* .cache = */ k_cache.data(),
           /* .batch_size = */ batch_size,
@@ -2453,9 +2454,9 @@ class TestMhaDese {
           /* .step_seq = */ step_src_k_sl,
           /* .step_head_size = */ step_src_k_head_size,
       };
-      jblas_reordered_attn_fp32_update_k(&update_k_args);
+      bestla_reordered_attn_fp32_update_k(&update_k_args);
 
-      jblas_fusion_attn_fp32_update_kv_args_t update_v_args = {
+      bestla_fusion_attn_fp32_update_kv_args_t update_v_args = {
           /* .src = */ src_v.data(),
           /* .cache = */ v_cache.data(),
           /* .batch_size = */ batch_size,
@@ -2469,19 +2470,19 @@ class TestMhaDese {
           /* .step_seq = */ step_src_v_sl,
           /* .step_head_size = */ step_src_v_head_size,
       };
-      jblas_reordered_attn_fp32_update_v(&update_v_args);
+      bestla_reordered_attn_fp32_update_v(&update_v_args);
 
       update_k_args.seq_off = seq_size_first;
       update_k_args.seq_size = seq_size_next;
       update_k_args.src = src_k.data() + seq_size_first * step_src_k_sl;
-      jblas_reordered_attn_fp32_update_k(&update_k_args);
+      bestla_reordered_attn_fp32_update_k(&update_k_args);
 
       update_v_args.seq_off = seq_size_first;
       update_v_args.seq_size = seq_size_next;
       update_v_args.src = src_v.data() + seq_size_first * step_src_v_sl;
-      jblas_reordered_attn_fp32_update_v(&update_v_args);
+      bestla_reordered_attn_fp32_update_v(&update_v_args);
 
-      jblas_reordered_attn_fp32_fp32_fwd_args_t kern_args{
+      bestla_reordered_attn_fp32_fp32_fwd_args_t kern_args{
           /* .Q = */ reinterpret_cast<float*>(src_q.data()),
           /* .K = */ k_cache.data(),
           /* .V = */ v_cache.data(),
@@ -2520,7 +2521,7 @@ class TestMhaDese {
           /* .step_dst_head_num = */ head_size,
           /* .step_dst_sl = */ head_num * head_size,
       };
-      jblas_reordered_attn_fp32_forward(&kern_args);
+      bestla_reordered_attn_fp32_forward(&kern_args);
     }
 
     // Check result
diff --git a/neural_speed/core/layers/mha_dense.h b/neural_speed/core/layers/mha_dense.h
index 1e3101b81..af8581b5b 100644
--- a/neural_speed/core/layers/mha_dense.h
+++ b/neural_speed/core/layers/mha_dense.h
@@ -24,7 +24,7 @@ extern "C" {
 typedef struct attn_shape_t {
   int batch_size, head_num, heads_kv, head_size, sl_q, sl_kv;
 } attn_shape_t;
-size_t jblas_fusion_attn_workspace_size(const attn_shape_t* params);
+size_t bestla_fusion_attn_workspace_size(const attn_shape_t* params);
 
 typedef struct kv_shape_t {
   uint32_t heads_kv;   // number of heads in K/V matrix
@@ -63,7 +63,7 @@ typedef struct attn_bf16_fwd_args_t {
   int step_v_bs, step_v_head_num, step_v_sl, step_v_head_size;
   int step_dst_bs, step_dst_head_num, step_dst_sl;
 } attn_bf16_fwd_args_t;
-void jblas_fusion_attn_bf16_forward(const attn_bf16_fwd_args_t* params);
+void bestla_fusion_attn_bf16_forward(const attn_bf16_fwd_args_t* params);
 
 typedef struct attn_fp32_fp16_fp16_fp32_fwd_args_t {
   float* Q;
@@ -82,10 +82,10 @@ typedef struct attn_fp32_fp16_fp16_fp32_fwd_args_t {
   int step_dst_bs, step_dst_head_num, step_dst_sl;
 } attn_fp32_fp16_fp16_fp32_fwd_args_t;
 
-void jblas_fusion_attn_bf16_forward(const attn_bf16_fwd_args_t* params);
+void bestla_fusion_attn_bf16_forward(const attn_bf16_fwd_args_t* params);
 
-bool jblas_fusion_attn_fp32_fp16_fp16_fp32_support(const attn_shape_t* params);
-void jblas_fusion_attn_fp32_fp16_fp16_fp32_forward(const attn_fp32_fp16_fp16_fp32_fwd_args_t* params);
+bool bestla_fusion_attn_fp32_fp16_fp16_fp32_support(const attn_shape_t* params);
+void bestla_fusion_attn_fp32_fp16_fp16_fp32_forward(const attn_fp32_fp16_fp16_fp32_fwd_args_t* params);
 
 typedef struct attn_fp16_fwd_args_t {
   ne_fp16_t *Q, *K, *V, *dst;
@@ -100,8 +100,8 @@ typedef struct attn_fp16_fwd_args_t {
   int step_v_bs, step_v_head_num, step_v_sl, step_v_head_size;
   int step_dst_bs, step_dst_head_num, step_dst_sl;
 } attn_fp16_fwd_args_t;
-bool jblas_fusion_attn_fp16_support(const attn_shape_t* params);
-void jblas_fusion_attn_fp16_forward(const attn_fp16_fwd_args_t* params);
+bool bestla_fusion_attn_fp16_support(const attn_shape_t* params);
+void bestla_fusion_attn_fp16_forward(const attn_fp16_fwd_args_t* params);
 
 typedef struct attn_int8_fwd_args_t {
   int8_t *Q, *K, *V, *dst;
@@ -116,44 +116,44 @@ typedef struct attn_int8_fwd_args_t {
   int step_v_bs, step_v_head_num, step_v_sl, step_v_head_size;
   int step_dst_bs, step_dst_head_num, step_dst_sl;
 } attn_int8_fwd_args_t;
-void jblas_fusion_attn_int8_forward(const attn_int8_fwd_args_t* params);
+void bestla_fusion_attn_int8_forward(const attn_int8_fwd_args_t* params);
 
-// check if jblas_reordered_attn is supported at runtime
-bool jblas_reordered_attn_fp32_support(const attn_shape_t* params);
+// check if bestla_reordered_attn is supported at runtime
+bool bestla_reordered_attn_fp32_support(const attn_shape_t* params);
 
 // kv cache sizes in bytes per layer per batch per beam
-void jblas_reordered_attn_fp32_batch_kv_info(const kv_shape_t* params, kv_cache_info_t* out);
+void bestla_reordered_attn_fp32_batch_kv_info(const kv_shape_t* params, kv_cache_info_t* out);
 
-typedef struct jblas_fusion_attn_fp32_update_kv_args_t {
+typedef struct bestla_fusion_attn_fp32_update_kv_args_t {
   float* src;
   char* cache;
   int batch_size, heads_kv, head_size, seq_off, seq_size, seq_max;
   int step_bs, step_head_num, step_seq, step_head_size;
   bool no_zeroing;  // set to true to prevent zeroing unaligned seq
-} jblas_fusion_attn_fp32_update_kv_args_t;
+} bestla_fusion_attn_fp32_update_kv_args_t;
 // update k-cache and output the memory layout of it
-void jblas_reordered_attn_fp32_update_k(const jblas_fusion_attn_fp32_update_kv_args_t* params);
+void bestla_reordered_attn_fp32_update_k(const bestla_fusion_attn_fp32_update_kv_args_t* params);
 // update v-cache and output the memory layout of it
-void jblas_reordered_attn_fp32_update_v(const jblas_fusion_attn_fp32_update_kv_args_t* params);
+void bestla_reordered_attn_fp32_update_v(const bestla_fusion_attn_fp32_update_kv_args_t* params);
 // shift-RoPE k-cache with pre-computed cos/sin values
-void jblas_reordered_attn_fp32_shift_rope_k(char* cache, const ne_fp16_t* cossin, int batch_size, int heads_kv,
-                                            int head_size, int seq_max, int seq_keep);
+void bestla_reordered_attn_fp32_shift_rope_k(char* cache, const ne_fp16_t* cossin, int batch_size, int heads_kv,
+                                             int head_size, int seq_max, int seq_keep);
 
-typedef struct jblas_fusion_attn_fp32_batch_cpy_kv_args_t {
+typedef struct bestla_fusion_attn_fp32_batch_cpy_kv_args_t {
   char* src;
   char* dst;
   int heads_kv, head_size, seq_off, seq_size, seq_max;
   bool no_zeroing;  // set to true to prevent zeroing unaligned seq
-} jblas_fusion_attn_fp32_batch_cpy_kv_args_t;
+} bestla_fusion_attn_fp32_batch_cpy_kv_args_t;
 // copy k-cache across batch from seq_off to (seq_off + seq_size)
-void jblas_fusion_attn_fp32_batch_cpy_k(const jblas_fusion_attn_fp32_batch_cpy_kv_args_t* params);
+void bestla_fusion_attn_fp32_batch_cpy_k(const bestla_fusion_attn_fp32_batch_cpy_kv_args_t* params);
 // copy v-cache across batch from seq_off to (seq_off + seq_size)
-void jblas_fusion_attn_fp32_batch_cpy_v(const jblas_fusion_attn_fp32_batch_cpy_kv_args_t* params);
+void bestla_fusion_attn_fp32_batch_cpy_v(const bestla_fusion_attn_fp32_batch_cpy_kv_args_t* params);
 
-typedef struct jblas_reordered_attn_fp32_fp32_fwd_args_t {
+typedef struct bestla_reordered_attn_fp32_fp32_fwd_args_t {
   float* Q;
-  char* K;  // K/V should be of type and layout used in corrsponding jblas_reordered_attn_xxx_update_kv
-  char* V;  // K/V should be of type and layout used in corrsponding jblas_reordered_attn_xxx_update_kv
+  char* K;  // K/V should be of type and layout used in corrsponding bestla_reordered_attn_xxx_update_kv
+  char* V;  // K/V should be of type and layout used in corrsponding bestla_reordered_attn_xxx_update_kv
   float* dst;
   float Q_sc, K_sc, V_sc, dst_sc;
   char* tmp;
@@ -165,8 +165,8 @@ typedef struct jblas_reordered_attn_fp32_fp32_fwd_args_t {
   int stride_k_bs, stride_k_head_num, stride_k_sl, stride_k_head_size;
   int stride_v_bs, stride_v_head_num, stride_v_sl, stride_v_head_size;
   int step_dst_bs, step_dst_head_num, step_dst_sl;
-} jblas_reordered_attn_fp32_fp32_fwd_args_t;
-void jblas_reordered_attn_fp32_forward(const jblas_reordered_attn_fp32_fp32_fwd_args_t* params);
+} bestla_reordered_attn_fp32_fp32_fwd_args_t;
+void bestla_reordered_attn_fp32_forward(const bestla_reordered_attn_fp32_fp32_fwd_args_t* params);
 
 #ifdef __cplusplus
 }
diff --git a/neural_speed/core/layers/ne_jblas.cpp b/neural_speed/core/layers/ne_bestla.cpp
similarity index 55%
rename from neural_speed/core/layers/ne_jblas.cpp
rename to neural_speed/core/layers/ne_bestla.cpp
index bde77c14d..79cb2b03e 100644
--- a/neural_speed/core/layers/ne_jblas.cpp
+++ b/neural_speed/core/layers/ne_bestla.cpp
@@ -11,12 +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.
-#include "jblas_common.hpp"
-#include "jblas_gemm.h"
-using namespace jblas;     // NOLINT
-using namespace ne_jblas;  // NOLINT
+#include "bestla_common.hpp"
+#include "bestla_gemm.h"
+using namespace bestla;     // NOLINT
+using namespace ne_bestla;  // NOLINT
 
-void jblas_init() {
+void bestla_init() {
   GetCPUDevice();
   if (_cd->AMX_BF16() || _cd->AMX_INT8()) {
     utils::request_perm_xtile_data();
@@ -24,7 +24,7 @@ void jblas_init() {
   _cd->print();
 }
 
-void jblas_timer(bool _init) {
+void bestla_timer(bool _init) {
   static utils::timer<utils::microseconds> tr;
   if (_init)
     tr.start();
@@ -32,23 +32,23 @@ void jblas_timer(bool _init) {
     printf("time :%f us\n", tr.stop());
 }
 
-int jblas_set_threads(int _nth) {
-  ne_jblas::ne_threading::get()->set_threads(_nth);
-  return ne_jblas::ne_threading::get()->num_threads();
+int bestla_set_threads(int _nth) {
+  ne_bestla::ne_threading::get()->set_threads(_nth);
+  return ne_bestla::ne_threading::get()->num_threads();
 }
 
-void* jblas_get_thread_handle() { return ne_jblas::ne_threading::get(); }
+void* bestla_get_thread_handle() { return ne_bestla::ne_threading::get(); }
 
-void jblas_unpackweight_fp32(void* wptr, int n, int k, float* fp32data, int ld) {
-  JblasGemmUnPackB(fp32data, wptr, static_cast<size_t>(n), static_cast<size_t>(k), static_cast<size_t>(ld),
-                   ne_jblas::ne_threading::get());
+void bestla_unpackweight_fp32(void* wptr, int n, int k, float* fp32data, int ld) {
+  BTLAGemmUnPackB(fp32data, wptr, static_cast<size_t>(n), static_cast<size_t>(k), static_cast<size_t>(ld),
+                  ne_bestla::ne_threading::get());
 }
 
-void jblas_packweight_copyattr(const float* f32ptr, void* dstptr, int n, int k, int ld, void* srcptr) {
-  auto wtmp = jblas::storage::gemm::PackedWeightParser::deserialBuffer(srcptr);
+void bestla_packweight_copyattr(const float* f32ptr, void* dstptr, int n, int k, int ld, void* srcptr) {
+  auto wtmp = storage::gemm::PackedWeightParser::deserialBuffer(srcptr);
   if (wtmp != nullptr) {
     auto proID = wtmp->mPrologueID;
-    if (wtmp->mPrologueID != JBLAS_PROLOGUEB_IDS::WeightPack) {
+    if (wtmp->mPrologueID != BTLA_PROLOGUEB_IDS::WeightPack) {
       auto kwtmp = reinterpret_cast<storage::gemm::IWeightKBlockBase*>(wtmp);
       auto coreID = wtmp->mCoreId;
       auto comptype = gemm::CoreAttr::get_comp(coreID);
@@ -63,15 +63,15 @@ void jblas_packweight_copyattr(const float* f32ptr, void* dstptr, int n, int k,
       if (btype == gemm::CompType::tFP32) {
         ne_comptype = ne_comp_type::NE_COMP_F32;
       }
-      if (kwtmp->mPrologueID == JBLAS_PROLOGUEB_IDS::WeightKBlockNInteger) {
+      if (kwtmp->mPrologueID == BTLA_PROLOGUEB_IDS::WeightKBlockNInteger) {
         auto niptr = reinterpret_cast<storage::gemm::StorageWeightKBlockNInteger*>(kwtmp);
 
-        JblasGemmQuantPackB(dstptr, f32ptr, n, k, ld, niptr->mBlockSize, niptr->mDType, niptr->SDtype(),
-                            niptr->IsAsym(), ne_comptype, false, ne_jblas::ne_threading::get());
-      } else if (kwtmp->mPrologueID == JBLAS_PROLOGUEB_IDS::WeightKBlockNFloat) {
+        BTLAGemmQuantPackB(dstptr, f32ptr, n, k, ld, niptr->mBlockSize, niptr->mDType, niptr->SDtype(), niptr->IsAsym(),
+                           ne_comptype, false, ne_bestla::ne_threading::get());
+      } else if (kwtmp->mPrologueID == BTLA_PROLOGUEB_IDS::WeightKBlockNFloat) {
         auto f4ptr = reinterpret_cast<storage::gemm::StorageWeightKBlockNFloat*>(kwtmp);
-        JblasGemmQuantPackB(dstptr, f32ptr, n, k, ld, f4ptr->mBlockSize, f4ptr->mDType, f4ptr->SDtype(), false,
-                            ne_comptype, false, ne_jblas::ne_threading::get());
+        BTLAGemmQuantPackB(dstptr, f32ptr, n, k, ld, f4ptr->mBlockSize, f4ptr->mDType, f4ptr->SDtype(), false,
+                           ne_comptype, false, ne_bestla::ne_threading::get());
       }
     }
   }
diff --git a/neural_speed/core/layers/ne_test_layers_utils.hpp b/neural_speed/core/layers/ne_test_layers_utils.hpp
index 0e656da88..ebe63797e 100644
--- a/neural_speed/core/layers/ne_test_layers_utils.hpp
+++ b/neural_speed/core/layers/ne_test_layers_utils.hpp
@@ -19,7 +19,7 @@
 #include <vector>
 #include <algorithm>
 
-#include "jblas/jit_blas_utils.h"
+#include "bestla/jit_blas_utils.h"
 
 #ifndef NE_TESTS
 static_assert(false, "Only include this header file for testing!");
@@ -34,17 +34,17 @@ inline void init_vector(T* v, size_t size, float v_min = -10, float v_max = 10,
 }
 
 template <>
-inline void init_vector<jblas::utils::bf16>(jblas::utils::bf16* v, size_t size, float v_min, float v_max, int seed) {
+inline void init_vector<bestla::utils::bf16>(bestla::utils::bf16* v, size_t size, float v_min, float v_max, int seed) {
   std::mt19937 gen(seed);
   std::uniform_real_distribution<float> u(v_min, v_max);
-  for (size_t i = 0; i < size; ++i) v[i] = jblas::utils::bf16(u(gen));
+  for (size_t i = 0; i < size; ++i) v[i] = bestla::utils::bf16(u(gen));
 }
 
 template <>
-inline void init_vector<jblas::utils::fp16>(jblas::utils::fp16* v, size_t size, float v_min, float v_max, int seed) {
+inline void init_vector<bestla::utils::fp16>(bestla::utils::fp16* v, size_t size, float v_min, float v_max, int seed) {
   std::mt19937 gen(seed);
   std::uniform_real_distribution<float> u(v_min, v_max);
-  for (size_t i = 0; i < size; ++i) v[i] = jblas::utils::fp16(u(gen));
+  for (size_t i = 0; i < size; ++i) v[i] = bestla::utils::fp16(u(gen));
 }
 
 template <typename T>
diff --git a/neural_speed/core/ne_bestla.h b/neural_speed/core/ne_bestla.h
new file mode 100644
index 000000000..ce131e4be
--- /dev/null
+++ b/neural_speed/core/ne_bestla.h
@@ -0,0 +1,69 @@
+//  Copyright (c) 2023 Intel Corporation
+//
+//  Licensed under the Apache License, Version 2.0 (the "License");
+//  you may not use this file except in compliance with the License.
+//  You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+//  Unless required by applicable law or agreed to in writing, software
+//  distributed under the License is distributed on an "AS IS" BASIS,
+//  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.
+#ifndef NE_CORE_GRAPH_INNER_PRODUCT_H
+#define NE_CORE_GRAPH_INNER_PRODUCT_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void bestla_timer(bool _init);
+
+int bestla_set_threads(int _nth);
+
+void* bestla_get_thread_handle();
+
+void bestla_init();
+
+unsigned long long bestla_f32f32_get_workspace_size(int _m, int _n, int _k, void* wptr);
+
+void bestla_f32f32_forward(float* activation, void* weiptr, float* output, int _m, int _n, int _k, int lda, int ldo,
+                           void* workspace);
+
+bool bestla_fusion_add_f32f32_support(void* weiptr, int _m, int _n, int _k);
+void bestla_fusion_add_f32f32_forward(float* activation, void* weiptr, float* bias, float* output, int _m, int _n,
+                                      int _k, int lda, int ldo, bool boardcast_bias, void* workspace);
+
+unsigned long long bestla_fusion_QKV_f32f32_get_workspace_size(int _m, int _n, int _k, void* w1ptr);
+
+bool bestla_fusion_QKV_f32f32_support(void* wqptr, void* wkptr, void* wvptr, int _m, int _n, int _k);
+
+void bestla_fusion_QKV_f32f32_forward(float* activation, void* wqptr, void* wkptr, void* wvptr, float* output, int _m,
+                                      int _n, int _k, int lda, int ldo, void* workspace);
+
+unsigned long long bestla_fusion_FFN_f32f32_get_workspace_size(int seq, int fin, int fmid, int fout, void* w1ptr,
+                                                               void* w2ptr);
+
+bool bestla_fusion_FFN_SiLu_f32f32_support(void* w1ptr, void* w2ptr, void* w3ptr, int seq, int fin, int fmid, int fout);
+
+void bestla_fusion_FFN_SiLu_f32f32_forward(float* activation, void* w1ptr, void* w2ptr, void* w3ptr, float* tmp1,
+                                           float* tmp2, float* output, int seq, int fin, int fmid, int fout,
+                                           void* workspace);
+
+bool bestla_fusion_FFN_GeLu_f32f32_support(void* w1ptr, void* w2ptr, int seq, int fin, int fmid, int fout);
+void bestla_fusion_FFN_GeLu_f32f32_forward(float* activation, void* w1ptr, void* w2ptr, float* tmp1, float* output,
+                                           int seq, int fin, int fmid, int fout, void* workspace);
+
+bool bestla_fusion_FFN_Add_GeLu_f32f32_support(void* w1ptr, void* w2ptr, int seq, int fin, int fmid, int fout);
+void bestla_fusion_FFN_Add_GeLu_f32f32_forward(float* activation, void* w1ptr, void* w2ptr, float* b1ptr, float* b2ptr,
+                                               float* tmp1, float* output, int seq, int fin, int fmid, int fout,
+                                               bool boardcast_bias, void* workspace);
+
+void bestla_unpackweight_fp32(void* wptr, int n, int k, float* fp32data, int ld);
+// packweight to dstptr, copy weight attributes from srcptr
+void bestla_packweight_copyattr(const float* f32ptr, void* dstpr, int n, int k, int ld, void* srcptr);
+#ifdef __cplusplus
+}
+#endif
+#endif  // NE_CORE_GRAPH_INNER_PRODUCT_H
diff --git a/neural_speed/core/ne_jblas.h b/neural_speed/core/ne_jblas.h
deleted file mode 100644
index 85308255c..000000000
--- a/neural_speed/core/ne_jblas.h
+++ /dev/null
@@ -1,69 +0,0 @@
-//  Copyright (c) 2023 Intel Corporation
-//
-//  Licensed under the Apache License, Version 2.0 (the "License");
-//  you may not use this file except in compliance with the License.
-//  You may obtain a copy of the License at
-//
-//    http://www.apache.org/licenses/LICENSE-2.0
-//
-//  Unless required by applicable law or agreed to in writing, software
-//  distributed under the License is distributed on an "AS IS" BASIS,
-//  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.
-#ifndef NE_CORE_GRAPH_INNER_PRODUCT_H
-#define NE_CORE_GRAPH_INNER_PRODUCT_H
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-void jblas_timer(bool _init);
-
-int jblas_set_threads(int _nth);
-
-void* jblas_get_thread_handle();
-
-void jblas_init();
-
-unsigned long long jblas_f32f32_get_workspace_size(int _m, int _n, int _k, void* wptr);
-
-void jblas_f32f32_forward(float* activation, void* weiptr, float* output, int _m, int _n, int _k, int lda, int ldo,
-                          void* workspace);
-
-bool jblas_fusion_add_f32f32_support(void* weiptr, int _m, int _n, int _k);
-void jblas_fusion_add_f32f32_forward(float* activation, void* weiptr, float* bias, float* output, int _m, int _n,
-                                     int _k, int lda, int ldo, bool boardcast_bias, void* workspace);
-
-unsigned long long jblas_fusion_QKV_f32f32_get_workspace_size(int _m, int _n, int _k, void* w1ptr);
-
-bool jblas_fusion_QKV_f32f32_support(void* wqptr, void* wkptr, void* wvptr, int _m, int _n, int _k);
-
-void jblas_fusion_QKV_f32f32_forward(float* activation, void* wqptr, void* wkptr, void* wvptr, float* output, int _m,
-                                     int _n, int _k, int lda, int ldo, void* workspace);
-
-unsigned long long jblas_fusion_FFN_f32f32_get_workspace_size(int seq, int fin, int fmid, int fout, void* w1ptr,
-                                                              void* w2ptr);
-
-bool jblas_fusion_FFN_SiLu_f32f32_support(void* w1ptr, void* w2ptr, void* w3ptr, int seq, int fin, int fmid, int fout);
-
-void jblas_fusion_FFN_SiLu_f32f32_forward(float* activation, void* w1ptr, void* w2ptr, void* w3ptr, float* tmp1,
-                                          float* tmp2, float* output, int seq, int fin, int fmid, int fout,
-                                          void* workspace);
-
-bool jblas_fusion_FFN_GeLu_f32f32_support(void* w1ptr, void* w2ptr, int seq, int fin, int fmid, int fout);
-void jblas_fusion_FFN_GeLu_f32f32_forward(float* activation, void* w1ptr, void* w2ptr, float* tmp1, float* output,
-                                          int seq, int fin, int fmid, int fout, void* workspace);
-
-bool jblas_fusion_FFN_Add_GeLu_f32f32_support(void* w1ptr, void* w2ptr, int seq, int fin, int fmid, int fout);
-void jblas_fusion_FFN_Add_GeLu_f32f32_forward(float* activation, void* w1ptr, void* w2ptr, float* b1ptr, float* b2ptr,
-                                              float* tmp1, float* output, int seq, int fin, int fmid, int fout,
-                                              bool boardcast_bias, void* workspace);
-
-void jblas_unpackweight_fp32(void* wptr, int n, int k, float* fp32data, int ld);
-// packweight to dstptr, copy weight attributes from srcptr
-void jblas_packweight_copyattr(const float* f32ptr, void* dstpr, int n, int k, int ld, void* srcptr);
-#ifdef __cplusplus
-}
-#endif
-#endif  // NE_CORE_GRAPH_INNER_PRODUCT_H
diff --git a/neural_speed/core/ne_layers.c b/neural_speed/core/ne_layers.c
index 94f9ab7df..18f51e3ae 100644
--- a/neural_speed/core/ne_layers.c
+++ b/neural_speed/core/ne_layers.c
@@ -48,7 +48,7 @@
 #include "layers/ele_wise.h"
 #include "layers/mha_dense.h"
 #include "ne.h"
-#include "ne_jblas.h"
+#include "ne_bestla.h"
 
 // if C99 - static_assert is noop
 // ref: https://stackoverflow.com/a/53923785/4039976
@@ -358,7 +358,7 @@ static_assert(NE_TYPE_COUNT == 14, "NE_TYPE_NAME is outdated");
 static bool NE_IS_QUANTIZED[NE_TYPE_COUNT] = {
     [NE_TYPE_F32] = false, [NE_TYPE_F16] = false, [NE_TYPE_Q4_0] = true, [NE_TYPE_Q4_1] = true,
     [NE_TYPE_Q5_0] = true, [NE_TYPE_Q5_1] = true, [NE_TYPE_Q8_0] = true, [NE_TYPE_Q8_1] = true,
-    [NE_TYPE_I8] = false,  [NE_TYPE_I16] = false, [NE_TYPE_I32] = false, [NE_TYPE_JBLAS] = true,
+    [NE_TYPE_I8] = false,  [NE_TYPE_I16] = false, [NE_TYPE_I32] = false, [NE_TYPE_BTLA] = true,
 };
 static_assert(NE_TYPE_COUNT == 14, "NE_IS_QUANTIZED is outdated");
 
@@ -708,8 +708,8 @@ struct ne_context* ne_init(struct ne_init_params params) {
   if (is_first_call) {
     // initialize time system (required on Windows)
     ne_time_init();
-    // initialize jblas's amx instruction.
-    jblas_init();
+    // initialize bestla's amx instruction.
+    bestla_init();
     // initialize GELU, SILU and EXP F32 tables
     {
       const uint64_t t_start = ne_time_us();
@@ -882,7 +882,7 @@ struct ne_tensor* ne_new_tensor_impl(struct ne_context* ctx, enum ne_type type,
   size_t size_needed = 0;
 
   if (data == NULL && !ctx->no_alloc) {
-    if (type == NE_TYPE_JBLAS) {
+    if (type == NE_TYPE_BTLA) {
       size_needed = size;
     } else {
       size_needed += NE_TYPE_SIZE[type] * (ne[0] / NE_BLCK_SIZE[type]);
@@ -974,7 +974,7 @@ struct ne_tensor* ne_new_tensor_impl(struct ne_context* ctx, enum ne_type type,
     result->ne[i] = ne[i];
   }
   result->nb[0] = NE_TYPE_SIZE[type];
-  if (type != NE_TYPE_JBLAS) {
+  if (type != NE_TYPE_BTLA) {
     result->nb[1] = result->nb[0] * (result->ne[0] / NE_BLCK_SIZE[type]);
   }
 
@@ -3272,7 +3272,7 @@ struct ne_tensor* ne_flash_attn(struct ne_context* ctx, struct ne_tensor* q, str
   bool is_node = true;
   struct ne_tensor* result = ne_new_tensor_4d(ctx, NE_TYPE_F32, headsize, headnum, seq_cur, batch, NE_SIZE_CALC);
   attn_shape_t atte_shape = {batch, headnum, headsize, seq_cur, seq_all};
-  size_t tmpsize = jblas_fusion_attn_workspace_size(&atte_shape);
+  size_t tmpsize = bestla_fusion_attn_workspace_size(&atte_shape);
   struct ne_tensor* tmp_t = ne_new_tensor_1d(ctx, NE_TYPE_I8, tmpsize, NE_SIZE_CALC);
   result->op = NE_OP_FLASH_ATTN;
   result->grad = NULL;
@@ -6692,8 +6692,9 @@ static void ne_compute_forward_mul_mat_q_f32(const struct ne_compute_params* par
   //}
 }
 
-static void ne_compute_forward_mul_mat_q_f32_jblas(const struct ne_compute_params* params, const struct ne_tensor* src0,
-                                                   const struct ne_tensor* src1, struct ne_tensor* dst) {
+static void ne_compute_forward_mul_mat_q_f32_bestla(const struct ne_compute_params* params,
+                                                    const struct ne_tensor* src0, const struct ne_tensor* src1,
+                                                    struct ne_tensor* dst) {
   int64_t t0 = ne_perf_time_us();
   UNUSED(t0);
 
@@ -6765,8 +6766,8 @@ static void ne_compute_forward_mul_mat_q_f32_jblas(const struct ne_compute_param
   if (params->type == NE_TASK_FINALIZE) {
     return;
   }
-  jblas_f32f32_forward((float*)src1->data, src0->data, (float*)dst->data, ne1, ne0, ne10, nb11 / ne_element_size(src1),
-                       nb1 / ne_element_size(dst), params->wdata);
+  bestla_f32f32_forward((float*)src1->data, src0->data, (float*)dst->data, ne1, ne0, ne10, nb11 / ne_element_size(src1),
+                        nb1 / ne_element_size(dst), params->wdata);
 }
 
 static void ne_compute_forward_mul_mat(const struct ne_compute_params* params, const struct ne_tensor* src0,
@@ -6780,8 +6781,8 @@ static void ne_compute_forward_mul_mat(const struct ne_compute_params* params, c
     case NE_TYPE_Q8_1: {
       ne_compute_forward_mul_mat_q_f32(params, src0, src1, dst);
     } break;
-    case NE_TYPE_JBLAS: {
-      ne_compute_forward_mul_mat_q_f32_jblas(params, src0, src1, dst);
+    case NE_TYPE_BTLA: {
+      ne_compute_forward_mul_mat_q_f32_bestla(params, src0, src1, dst);
     } break;
     case NE_TYPE_F16: {
       ne_compute_forward_mul_mat_f16_f32(params, src0, src1, dst);
@@ -6795,9 +6796,9 @@ static void ne_compute_forward_mul_mat(const struct ne_compute_params* params, c
   }
 }
 
-static void ne_compute_forward_mul_mat_bias_q_f32_jblas(const struct ne_compute_params* params,
-                                                        const struct ne_tensor* src0, const struct ne_tensor* src1,
-                                                        const struct ne_tensor* bias, struct ne_tensor* dst) {
+static void ne_compute_forward_mul_mat_bias_q_f32_bestla(const struct ne_compute_params* params,
+                                                         const struct ne_tensor* src0, const struct ne_tensor* src1,
+                                                         const struct ne_tensor* bias, struct ne_tensor* dst) {
   int64_t t0 = ne_perf_time_us();
   UNUSED(t0);
 
@@ -6870,16 +6871,16 @@ static void ne_compute_forward_mul_mat_bias_q_f32_jblas(const struct ne_compute_
     return;
   }
   const bool boardcast_bias = bias->ne[1] == 1;
-  jblas_fusion_add_f32f32_forward((float*)src1->data, src0->data, (float*)bias->data, (float*)dst->data, ne1, ne0, ne10,
-                                  ne10, ne0, boardcast_bias, params->wdata);
+  bestla_fusion_add_f32f32_forward((float*)src1->data, src0->data, (float*)bias->data, (float*)dst->data, ne1, ne0,
+                                   ne10, ne10, ne0, boardcast_bias, params->wdata);
 }
 
 static void ne_compute_forward_mul_mat_bias(const struct ne_compute_params* params, const struct ne_tensor* src0,
                                             const struct ne_tensor* src1, const struct ne_tensor* bias,
                                             struct ne_tensor* dst) {
   switch (src0->type) {
-    case NE_TYPE_JBLAS: {
-      ne_compute_forward_mul_mat_bias_q_f32_jblas(params, src0, src1, bias, dst);
+    case NE_TYPE_BTLA: {
+      ne_compute_forward_mul_mat_bias_q_f32_bestla(params, src0, src1, bias, dst);
     } break;
     default: {
       NE_ASSERT(false);
@@ -6900,8 +6901,8 @@ static void ne_compute_forward_mul_qkv(const struct ne_compute_params* params, c
   const int n = dst->ne[0];
   const int m = dst->ne[1];
   const int k = src->ne[0];
-  jblas_fusion_QKV_f32f32_forward((float*)src->data, qw->data, kw->data, vw->data, (float*)dst->data, m, n, k, k, n,
-                                  params->wdata);
+  bestla_fusion_QKV_f32f32_forward((float*)src->data, qw->data, kw->data, vw->data, (float*)dst->data, m, n, k, k, n,
+                                   params->wdata);
 }
 
 static void ne_compute_forward_ffn_silu(const struct ne_compute_params* params, const struct ne_tensor* src,
@@ -6918,8 +6919,8 @@ static void ne_compute_forward_ffn_silu(const struct ne_compute_params* params,
   const int fout = dst->ne[0];
   const int fmid = w1->ne[1];
   const int seq = dst->ne[1];
-  jblas_fusion_FFN_SiLu_f32f32_forward((float*)src->data, w1->data, w2->data, w3->data, (float*)tmp->data,
-                                       (float*)tmp1->data, (float*)dst->data, seq, fin, fmid, fout, params->wdata);
+  bestla_fusion_FFN_SiLu_f32f32_forward((float*)src->data, w1->data, w2->data, w3->data, (float*)tmp->data,
+                                        (float*)tmp1->data, (float*)dst->data, seq, fin, fmid, fout, params->wdata);
 }
 
 static void ne_compute_forward_ffn_add_gelu(const struct ne_compute_params* params, const struct ne_tensor* src,
@@ -6938,9 +6939,9 @@ static void ne_compute_forward_ffn_add_gelu(const struct ne_compute_params* para
   const int fmid = w1->ne[1];
   const int seq = dst->ne[1];
   const bool boardcast_bias = b1->ne[1] == 1 || b2->ne[1] == 1;
-  jblas_fusion_FFN_Add_GeLu_f32f32_forward((float*)src->data, w1->data, w2->data, (float*)b1->data, (float*)b2->data,
-                                           (float*)tmp->data, (float*)dst->data, seq, fin, fmid, fout, boardcast_bias,
-                                           params->wdata);
+  bestla_fusion_FFN_Add_GeLu_f32f32_forward((float*)src->data, w1->data, w2->data, (float*)b1->data, (float*)b2->data,
+                                            (float*)tmp->data, (float*)dst->data, seq, fin, fmid, fout, boardcast_bias,
+                                            params->wdata);
 }
 
 static void ne_compute_forward_ffn_gelu(const struct ne_compute_params* params, const struct ne_tensor* src,
@@ -6957,8 +6958,8 @@ static void ne_compute_forward_ffn_gelu(const struct ne_compute_params* params,
   const int fout = dst->ne[0];
   const int fmid = w1->ne[1];
   const int seq = dst->ne[1];
-  jblas_fusion_FFN_GeLu_f32f32_forward((float*)src->data, w1->data, w2->data, (float*)tmp->data, (float*)dst->data, seq,
-                                       fin, fmid, fout, params->wdata);
+  bestla_fusion_FFN_GeLu_f32f32_forward((float*)src->data, w1->data, w2->data, (float*)tmp->data, (float*)dst->data,
+                                        seq, fin, fmid, fout, params->wdata);
 }
 
 // ne_compute_forward_scale
@@ -8147,8 +8148,8 @@ static void ne_compute_forward_rope_f16(const struct ne_compute_params* params,
   }
 }
 
-static void ne_compute_forward_rope_jblas(const struct ne_compute_params* params, const struct ne_tensor* src0,
-                                          const struct ne_tensor* src1, struct ne_tensor* dst) {
+static void ne_compute_forward_rope_bestla(const struct ne_compute_params* params, const struct ne_tensor* src0,
+                                           const struct ne_tensor* src1, struct ne_tensor* dst) {
   if (params->type == NE_TASK_INIT || params->type == NE_TASK_FINALIZE) return;
   NE_ASSERT(("use internal multi-threading", params->nth == 1));
 
@@ -8184,7 +8185,7 @@ static void ne_compute_forward_rope_jblas(const struct ne_compute_params* params
         theta *= theta_scale;
       }
     }
-    jblas_reordered_attn_fp32_shift_rope_k(dst->data, cossin, batch_size, head_num, head_size, seq_len, n_keep);
+    bestla_reordered_attn_fp32_shift_rope_k(dst->data, cossin, batch_size, head_num, head_size, seq_len, n_keep);
     if (dst->opt[0] == NULL) free(cossin);
     return;
   }
@@ -8200,8 +8201,8 @@ static void ne_compute_forward_rope(const struct ne_compute_params* params, cons
     case NE_TYPE_F32: {
       ne_compute_forward_rope_f32(params, src0, src1, dst);
     } break;
-    case NE_TYPE_JBLAS: {
-      ne_compute_forward_rope_jblas(params, src0, src1, dst);
+    case NE_TYPE_BTLA: {
+      ne_compute_forward_rope_bestla(params, src0, src1, dst);
     } break;
     default: {
       NE_ASSERT(false);
@@ -8738,7 +8739,7 @@ static void ne_compute_forward_flash_attn_f32_f16_f16(const struct ne_compute_pa
       .step_dst_head_num = headsize,
       .step_dst_sl = embedsize,
   };
-  jblas_fusion_attn_fp32_fp16_fp16_fp32_forward(&args);
+  bestla_fusion_attn_fp32_fp16_fp16_fp32_forward(&args);
 }
 
 static void ne_compute_forward_flash_attn_reordered(const struct ne_compute_params* params, const struct ne_tensor* q,
@@ -8759,11 +8760,11 @@ static void ne_compute_forward_flash_attn_reordered(const struct ne_compute_para
   float scale = *(float*)dst->padding;
   ne_attn_flags_t flags = *(ne_attn_flags_t*)&dst->padding[sizeof(scale)];
 
-  NE_ASSERT(k->type == NE_TYPE_JBLAS && v->type == NE_TYPE_JBLAS);
+  NE_ASSERT(k->type == NE_TYPE_BTLA && v->type == NE_TYPE_BTLA);
   ATTN_FWD_LAYOUT K_layout = *(ATTN_FWD_LAYOUT*)(&k->nb[0]);
   ATTN_FWD_LAYOUT V_layout = *(ATTN_FWD_LAYOUT*)(&v->nb[0]);
 
-  jblas_reordered_attn_fp32_fp32_fwd_args_t args = {
+  bestla_reordered_attn_fp32_fp32_fwd_args_t args = {
       .Q = (float*)q->data,
       .K = (char*)k->data,
       .V = (char*)v->data,
@@ -8804,7 +8805,7 @@ static void ne_compute_forward_flash_attn_reordered(const struct ne_compute_para
       .step_dst_head_num = dst->nb[1] / dst_ele_size,
       .step_dst_sl = dst->nb[2] / dst_ele_size,
   };
-  jblas_reordered_attn_fp32_forward(&args);
+  bestla_reordered_attn_fp32_forward(&args);
 }
 
 static void ne_compute_forward_flash_attn_f16(const struct ne_compute_params* params, const struct ne_tensor* q,
@@ -9041,7 +9042,7 @@ static void ne_compute_forward_flash_attn(const struct ne_compute_params* params
     case NE_TYPE_F32: {
       if (k->type == NE_TYPE_F16) {
         ne_compute_forward_flash_attn_f32_f16_f16(params, q, k, v, tmp, dst);
-      } else if (k->type == NE_TYPE_JBLAS && v->type == NE_TYPE_JBLAS) {
+      } else if (k->type == NE_TYPE_BTLA && v->type == NE_TYPE_BTLA) {
         ne_compute_forward_flash_attn_reordered(params, q, k, v, tmp, dst);
       } else {
         NE_ASSERT(false);
@@ -9062,7 +9063,7 @@ static void ne_compute_forward_flash_attn_kv_update(const struct ne_compute_para
   const bool is_v = (bool)p_data[1];
   const bool no_zeroing = (bool)p_data[2];
   NE_ASSERT(cur->type == NE_TYPE_F32);
-  jblas_fusion_attn_fp32_update_kv_args_t args = {
+  bestla_fusion_attn_fp32_update_kv_args_t args = {
       .src = cur->data,
       .cache = cache->data,
       .batch_size = cur->ne[3],
@@ -9078,9 +9079,9 @@ static void ne_compute_forward_flash_attn_kv_update(const struct ne_compute_para
       .no_zeroing = no_zeroing,
   };
   if (is_v)
-    jblas_reordered_attn_fp32_update_v(&args);
+    bestla_reordered_attn_fp32_update_v(&args);
   else
-    jblas_reordered_attn_fp32_update_k(&args);
+    bestla_reordered_attn_fp32_update_k(&args);
 }
 
 // ne_compute_forward_flash_ff
@@ -10352,7 +10353,7 @@ void ne_graph_compute(struct ne_context* ctx, struct ne_cgraph* cgraph) {
     }
   }
 #else
-  n_threads = jblas_set_threads(n_threads);  // prevent from using two sockets
+  n_threads = bestla_set_threads(n_threads);  // prevent from using two sockets
   omp_set_num_threads(n_threads);
 #endif
   // initialize tasks + work buffer
@@ -10450,9 +10451,9 @@ void ne_graph_compute(struct ne_context* ctx, struct ne_cgraph* cgraph) {
           // printf("nr0 = %8d, nr1 = %8d, nr0*nr1 = %8d, n_tasks = %d\n", nr0, nr1, nr0*nr1, node->n_tasks);
 
           size_t cur = 0;
-          if (node->src0->type == NE_TYPE_JBLAS) {
-            cur = jblas_f32f32_get_workspace_size(node->src1->ne[1], node->src0->ne[1], node->src1->ne[0],
-                                                  node->src0->data);
+          if (node->src0->type == NE_TYPE_BTLA) {
+            cur = bestla_f32f32_get_workspace_size(node->src1->ne[1], node->src0->ne[1], node->src1->ne[0],
+                                                   node->src0->data);
             node->n_tasks = 1;
           } else if (node->src0->type == NE_TYPE_F16 && node->src1->type == NE_TYPE_F32) {
             cur = NE_TYPE_SIZE[NE_TYPE_F16] * ne_nelements(node->src1);
@@ -10473,15 +10474,15 @@ void ne_graph_compute(struct ne_context* ctx, struct ne_cgraph* cgraph) {
         case NE_OP_MUL_FFN_GELU:
         case NE_OP_MUL_FFN_ADD_GELU: {
           size_t cur = 0;
-          cur = jblas_fusion_FFN_f32f32_get_workspace_size(node->src0->ne[1], node->src0->ne[0], node->src1->ne[1],
-                                                           node->opt[0]->ne[1], node->src1->data, node->opt[0]->data);
+          cur = bestla_fusion_FFN_f32f32_get_workspace_size(node->src0->ne[1], node->src0->ne[0], node->src1->ne[1],
+                                                            node->opt[0]->ne[1], node->src1->data, node->opt[0]->data);
           work_size = MAX(work_size, cur);
           node->n_tasks = 1;
         } break;
         case NE_OP_MUL_QKV: {
           size_t cur = 0;
-          cur = jblas_fusion_QKV_f32f32_get_workspace_size(node->src0->ne[1], node->src1->ne[1], node->src1->ne[0],
-                                                           node->src1->data);
+          cur = bestla_fusion_QKV_f32f32_get_workspace_size(node->src0->ne[1], node->src1->ne[1], node->src1->ne[0],
+                                                            node->src1->data);
           work_size = MAX(work_size, cur);
           node->n_tasks = 1;
         } break;
@@ -10504,7 +10505,7 @@ void ne_graph_compute(struct ne_context* ctx, struct ne_cgraph* cgraph) {
         case NE_OP_DIAG_MASK_INF:
         case NE_OP_PADDING_MASK_INF:
         case NE_OP_ROPE:
-          if (node->type == NE_TYPE_JBLAS) {
+          if (node->type == NE_TYPE_BTLA) {
             node->n_tasks = 1;
           } else if (node->src0->ne[1] > 4) {
             node->n_tasks = n_threads;
@@ -10629,7 +10630,7 @@ void ne_graph_compute(struct ne_context* ctx, struct ne_cgraph* cgraph) {
     const int64_t perf_node_start_cycles = ne_perf_cycles();
     const int64_t perf_node_start_time_us = ne_perf_time_us();
 #if NE_DEBUG
-    jblas_timer(true);
+    bestla_timer(true);
 #endif
 #ifndef _OPENMP
     // INIT
@@ -10791,7 +10792,7 @@ void ne_graph_compute(struct ne_context* ctx, struct ne_cgraph* cgraph) {
 #endif
 #if NE_DEBUG
     printf("Node %d ", node->op);
-    jblas_timer(false);
+    bestla_timer(false);
 #endif
     // performance stats (node)
     {
diff --git a/neural_speed/models/baichuan/CMakeLists.txt b/neural_speed/models/baichuan/CMakeLists.txt
index 334abc7fe..5263e59e0 100644
--- a/neural_speed/models/baichuan/CMakeLists.txt
+++ b/neural_speed/models/baichuan/CMakeLists.txt
@@ -16,4 +16,4 @@ set(TARGET baichuan)
 add_library_w_warning(${TARGET} baichuan.cpp baichuan_utils.cpp ${MODEL_UTILS_SOURCE})
 target_compile_features(${TARGET} PUBLIC cxx_std_11) # don't bump
 set_target_properties(${TARGET} PROPERTIES POSITION_INDEPENDENT_CODE ON)
-target_link_libraries(${TARGET} PUBLIC ne_layers jblas::jblas)
+target_link_libraries(${TARGET} PUBLIC ne_layers bestla::bestla)
diff --git a/neural_speed/models/baichuan/baichuan.cpp b/neural_speed/models/baichuan/baichuan.cpp
index d37cbad4c..608902f9d 100644
--- a/neural_speed/models/baichuan/baichuan.cpp
+++ b/neural_speed/models/baichuan/baichuan.cpp
@@ -32,7 +32,7 @@
 #include "core/data_types.h"
 #include "core/ne.h"
 #include "core/ne_layers.h"
-#include "core/ne_jblas.h"
+#include "core/ne_bestla.h"
 #include "core/layers/mha_dense.h"
 #include "models/model_utils/model_config.h"
 #include "models/model_utils/model_utils.h"
@@ -93,27 +93,27 @@ static bool baichuan_model_eval_internal(model_context* ctx, const model_input*
   ne_cgraph gf = {};
   gf.n_threads = N >= 32 && ne_cpu_has_blas() ? 1 : n_threads;
 
-  const bool run_mha_reordered = model.layers[0].k_cache->type == NE_TYPE_JBLAS;
+  const bool run_mha_reordered = model.layers[0].k_cache->type == NE_TYPE_BTLA;
   kv_cache_info_t kv_cache_info = {};
   if (run_mha_reordered) {
-    NE_ASSERT(("kv cache should be the same dtype", model.layers[0].v_cache->type == NE_TYPE_JBLAS));
+    NE_ASSERT(("kv cache should be the same dtype", model.layers[0].v_cache->type == NE_TYPE_BTLA));
     attn_shape_t attn_shape = {
         /* .batch_size = */ 1,
         /* .head_num = */ n_head,
         /* .heads_kv = */ n_head,
         /* .head_size = */ head_size,
-        /* .sl_q = */ N,  // Note: make sure that jblas reordered attn supports next token inference
+        /* .sl_q = */ N,  // Note: make sure that bestla reordered attn supports next token inference
         /* .sl_kv = */ n_past + N,
     };
 
-    NE_ASSERT(("jblas managed kv-cache not supported; use `--memory-f16 / --memory-f32` instead",
-               jblas_reordered_attn_fp32_support(&attn_shape)));
+    NE_ASSERT(("bestla managed kv-cache not supported; use `--memory-f16 / --memory-f32` instead",
+               bestla_reordered_attn_fp32_support(&attn_shape)));
     kv_shape_t kv_shape{
         /* .heads_kv = */ static_cast<uint32_t>(n_head),
         /* .head_size = */ static_cast<uint32_t>(head_size),
         /* .sl_kv_max = */ static_cast<uint32_t>(n_ctx),
     };
-    jblas_reordered_attn_fp32_batch_kv_info(&kv_shape, &kv_cache_info);
+    bestla_reordered_attn_fp32_batch_kv_info(&kv_shape, &kv_cache_info);
   }
 
   struct ne_tensor* embd = d_ne_new_tensor_1d(ctx0, NE_TYPE_I32, N);
@@ -201,12 +201,12 @@ static bool baichuan_model_eval_internal(model_context* ctx, const model_input*
         {
           const auto k_cache = ne_view_3d(ctx0, model.layers[il].k_cache,  // tensor
                                           head_size, n_ctx, n_head,        // ne
-                                          0, 0,                            // nb (jblas managed)
+                                          0, 0,                            // nb (bestla managed)
                                           0);                              // offset
           ne_build_forward_expand(&gf, ne_flash_attn_update_k(ctx0, k_cache, key_layer, n_past, false));
           const auto v_cache = ne_view_3d(ctx0, model.layers[il].v_cache,  // tensor
                                           head_size, n_ctx, n_head,        // ne
-                                          0, 0,                            // nb (jblas managed)
+                                          0, 0,                            // nb (bestla managed)
                                           0);                              // offset
           ne_build_forward_expand(&gf, ne_flash_attn_update_v(ctx0, v_cache, value_layer, n_past, false));
         }
@@ -215,14 +215,14 @@ static bool baichuan_model_eval_internal(model_context* ctx, const model_input*
         key_layer =                                                                       //
             ne_view_3d(ctx0, model.layers[il].k_cache,                                    // tensor
                        head_size, n_past + N, n_head,                                     // ne
-                       kv_cache_info.stride_k_sl, kv_cache_info.stride_k_head_num,        // nb (jblas managed)
+                       kv_cache_info.stride_k_sl, kv_cache_info.stride_k_head_num,        // nb (bestla managed)
                        0);                                                                // offset
         *reinterpret_cast<ATTN_FWD_LAYOUT*>(&key_layer->nb[0]) = kv_cache_info.k_layout;  // us nb0 for layout
 
         value_layer =                                                                       //
             ne_view_3d(ctx0, model.layers[il].v_cache,                                      // tensor
                        n_past + N, head_size, n_head,                                       // ne
-                       kv_cache_info.stride_v_head_size, kv_cache_info.stride_v_head_num,   // nb (jblas managed)
+                       kv_cache_info.stride_v_head_size, kv_cache_info.stride_v_head_num,   // nb (bestla managed)
                        0);                                                                  // offset
         *reinterpret_cast<ATTN_FWD_LAYOUT*>(&value_layer->nb[0]) = kv_cache_info.v_layout;  // us nb0 for layout
 
@@ -246,9 +246,9 @@ static bool baichuan_model_eval_internal(model_context* ctx, const model_input*
 
     // mlp.forward
     struct ne_tensor* mlp_output;
-    if (jblas_fusion_FFN_SiLu_f32f32_support(model.layers[il].ffn[0]->data, model.layers[il].ffn[1]->data,
-                                             model.layers[il].ffn[2]->data, N, hidden_states->ne[0],
-                                             model.layers[il].ffn[0]->ne[1], model.layers[il].ffn[1]->ne[1])) {
+    if (bestla_fusion_FFN_SiLu_f32f32_support(model.layers[il].ffn[0]->data, model.layers[il].ffn[1]->data,
+                                              model.layers[il].ffn[2]->data, N, hidden_states->ne[0],
+                                              model.layers[il].ffn[0]->ne[1], model.layers[il].ffn[1]->ne[1])) {
       mlp_output =
           ne_ffn_silu(ctx0, model.layers[il].ffn[0], model.layers[il].ffn[1], model.layers[il].ffn[2], hidden_states);
     } else {
diff --git a/neural_speed/models/baichuan/baichuan_utils.cpp b/neural_speed/models/baichuan/baichuan_utils.cpp
index d270a61a4..6469f7629 100644
--- a/neural_speed/models/baichuan/baichuan_utils.cpp
+++ b/neural_speed/models/baichuan/baichuan_utils.cpp
@@ -47,7 +47,7 @@ void model_load_internal(const std::string& fname, model_archs arch, model_conte
   ms->load(ctx, progress_callback, progress_callback_user_data);
 
   model_context& lctx = *ctx;
-  lctx.support_jblas_kv = true;
+  lctx.support_bestla_kv = true;
 }
 
 void BAICHUAN::init(const char* path_model, model_context* ctx, int n_gpu_layer_, bool use_mmap_, bool use_mlock_,
diff --git a/neural_speed/models/bloom/CMakeLists.txt b/neural_speed/models/bloom/CMakeLists.txt
index 60fe8f90e..f401c44c2 100644
--- a/neural_speed/models/bloom/CMakeLists.txt
+++ b/neural_speed/models/bloom/CMakeLists.txt
@@ -16,4 +16,4 @@ set(TARGET bloom)
 add_library_w_warning(${TARGET} bloom.cpp bloom_utils.cpp ${MODEL_UTILS_SOURCE})
 target_compile_features(${TARGET} PUBLIC cxx_std_11) # don't bump
 set_target_properties(${TARGET} PROPERTIES POSITION_INDEPENDENT_CODE ON)
-target_link_libraries(${TARGET} PUBLIC ne_layers jblas::jblas)
+target_link_libraries(${TARGET} PUBLIC ne_layers bestla::bestla)
diff --git a/neural_speed/models/bloom/bloom.cpp b/neural_speed/models/bloom/bloom.cpp
index 6a73d8361..3f7ce5958 100644
--- a/neural_speed/models/bloom/bloom.cpp
+++ b/neural_speed/models/bloom/bloom.cpp
@@ -31,7 +31,7 @@
 #include "core/data_types.h"
 #include "core/ne.h"
 #include "core/ne_layers.h"
-#include "core/ne_jblas.h"
+#include "core/ne_bestla.h"
 #include "core/layers/mha_dense.h"
 #include "models/model_utils/model_config.h"
 #include "models/model_utils/model_utils.h"
@@ -211,9 +211,9 @@ static bool bloom_model_eval_internal(model_context* ctx, const model_input* inp
         cur = ne_mul(ctx0, ne_repeat(ctx0, model.layers[il].ffn[0], cur), cur);
         cur = ne_add(ctx0, ne_repeat(ctx0, model.layers[il].ffn[1], cur), cur);
       }
-      if (jblas_fusion_FFN_Add_GeLu_f32f32_support(model.layers[il].ffn[2]->data, model.layers[il].ffn[4]->data,
-                                                   N * batch_size, cur->ne[0], model.layers[il].ffn[0]->ne[1],
-                                                   model.layers[il].ffn[2]->ne[1])) {
+      if (bestla_fusion_FFN_Add_GeLu_f32f32_support(model.layers[il].ffn[2]->data, model.layers[il].ffn[4]->data,
+                                                    N * batch_size, cur->ne[0], model.layers[il].ffn[0]->ne[1],
+                                                    model.layers[il].ffn[2]->ne[1])) {
         cur = ne_ffn_add_gelu(ctx0, model.layers[il].ffn[2], model.layers[il].ffn[4], model.layers[il].ffn[3],
                               model.layers[il].ffn[5], cur);
       } else {
diff --git a/neural_speed/models/chatglm/CMakeLists.txt b/neural_speed/models/chatglm/CMakeLists.txt
index ebdb54337..391f6a9dc 100644
--- a/neural_speed/models/chatglm/CMakeLists.txt
+++ b/neural_speed/models/chatglm/CMakeLists.txt
@@ -16,10 +16,10 @@ set(TARGET chatglm2)
 add_library_w_warning(${TARGET} chatglm2.cpp chatglm2_utils.cpp ${MODEL_UTILS_SOURCE})
 target_compile_features(${TARGET} PUBLIC cxx_std_11) # don't bump
 set_target_properties(${TARGET} PROPERTIES POSITION_INDEPENDENT_CODE ON)
-target_link_libraries(${TARGET} PUBLIC ne_layers jblas::jblas)
+target_link_libraries(${TARGET} PUBLIC ne_layers bestla::bestla)
 
 set(TARGET chatglm)
 add_library_w_warning(${TARGET} chatglm.cpp chatglm_utils.cpp ${MODEL_UTILS_SOURCE})
 target_compile_features(${TARGET} PUBLIC cxx_std_11) # don't bump
 set_target_properties(${TARGET} PROPERTIES POSITION_INDEPENDENT_CODE ON)
-target_link_libraries(${TARGET} PUBLIC ne_layers jblas::jblas)
+target_link_libraries(${TARGET} PUBLIC ne_layers bestla::bestla)
diff --git a/neural_speed/models/chatglm/chatglm.cpp b/neural_speed/models/chatglm/chatglm.cpp
index 8cce0142b..243cccb52 100644
--- a/neural_speed/models/chatglm/chatglm.cpp
+++ b/neural_speed/models/chatglm/chatglm.cpp
@@ -31,7 +31,7 @@
 #include "core/data_types.h"
 #include "core/ne.h"
 #include "core/ne_layers.h"
-#include "core/ne_jblas.h"
+#include "core/ne_bestla.h"
 #include "core/layers/mha_dense.h"
 #include "models/model_utils/model_config.h"
 #include "models/model_utils/model_utils.h"
@@ -246,7 +246,7 @@ static bool chatglm_model_eval_internal(model_context* ctx, const model_input* i
 
     // mlp.forward
     struct ne_tensor* mlp_output;
-    bool status = jblas_fusion_FFN_Add_GeLu_f32f32_support(
+    bool status = bestla_fusion_FFN_Add_GeLu_f32f32_support(
         model.layers[il].ffn[0]->data, model.layers[il].ffn[2]->data, N * batch_size, mlp_input->ne[0],
         model.layers[il].ffn[0]->ne[1], model.layers[il].ffn[2]->ne[1]);
     if (status) {
diff --git a/neural_speed/models/chatglm/chatglm2.cpp b/neural_speed/models/chatglm/chatglm2.cpp
index 8f37b6522..cd9c384a7 100644
--- a/neural_speed/models/chatglm/chatglm2.cpp
+++ b/neural_speed/models/chatglm/chatglm2.cpp
@@ -98,27 +98,27 @@ static bool chatglm_model_eval_internal(model_context* ctx, const model_input* i
   ne_cgraph gf = {};
   gf.n_threads = N >= 32 && ne_cpu_has_blas() ? 1 : n_threads;
 
-  const bool run_mha_reordered = model.layers[0].k_cache->type == NE_TYPE_JBLAS;
+  const bool run_mha_reordered = model.layers[0].k_cache->type == NE_TYPE_BTLA;
   kv_cache_info_t kv_cache_info = {};
   if (run_mha_reordered) {
-    NE_ASSERT(("kv cache should be the same dtype", model.layers[0].v_cache->type == NE_TYPE_JBLAS));
+    NE_ASSERT(("kv cache should be the same dtype", model.layers[0].v_cache->type == NE_TYPE_BTLA));
     attn_shape_t attn_shape = {
         /* .batch_size = */ 1,
         /* .head_num = */ n_head,
         /* .heads_kv = */ num_kv_heads,
         /* .head_size = */ head_size,
-        /* .sl_q = */ N,  // Note: make sure that jblas reordered attn supports next token inference
+        /* .sl_q = */ N,  // Note: make sure that bestla reordered attn supports next token inference
         /* .sl_kv = */ n_cached,
     };
 
-    NE_ASSERT(("jblas managed kv-cache not supported; use `--memory-f16 / --memory-f32` instead",
-               jblas_reordered_attn_fp32_support(&attn_shape)));
+    NE_ASSERT(("bestla managed kv-cache not supported; use `--memory-f16 / --memory-f32` instead",
+               bestla_reordered_attn_fp32_support(&attn_shape)));
     kv_shape_t kv_shape{
         /* .heads_kv = */ static_cast<uint32_t>(num_kv_heads),
         /* .head_size = */ static_cast<uint32_t>(head_size),
         /* .sl_kv_max = */ static_cast<uint32_t>(n_ctx),
     };
-    jblas_reordered_attn_fp32_batch_kv_info(&kv_shape, &kv_cache_info);
+    bestla_reordered_attn_fp32_batch_kv_info(&kv_shape, &kv_cache_info);
   }
 
   struct ne_tensor* embd = d_ne_new_tensor_1d(ctx0, NE_TYPE_I32, N);
@@ -231,12 +231,12 @@ static bool chatglm_model_eval_internal(model_context* ctx, const model_input* i
         {
           const auto k_cache = ne_view_3d(ctx0, model.layers[il].k_cache,  // tensor
                                           head_size, n_ctx, num_kv_heads,  // ne
-                                          0, 0,                            // nb (jblas managed)
+                                          0, 0,                            // nb (bestla managed)
                                           0);                              // offset
           ne_build_forward_expand(&gf, ne_flash_attn_update_k(ctx0, k_cache, key_layer, n_past, is_ring_full));
           const auto v_cache = ne_view_3d(ctx0, model.layers[il].v_cache,  // tensor
                                           head_size, n_ctx, num_kv_heads,  // ne
-                                          0, 0,                            // nb (jblas managed)
+                                          0, 0,                            // nb (bestla managed)
                                           0);                              // offset
           ne_build_forward_expand(&gf, ne_flash_attn_update_v(ctx0, v_cache, value_layer, n_past, is_ring_full));
         }
@@ -245,7 +245,7 @@ static bool chatglm_model_eval_internal(model_context* ctx, const model_input* i
         key_layer =                                                                       //
             ne_view_3d(ctx0, model.layers[il].k_cache,                                    // tensor
                        head_size, n_cached, num_kv_heads,                                 // ne
-                       kv_cache_info.stride_k_sl, kv_cache_info.stride_k_head_num,        // nb (jblas managed)
+                       kv_cache_info.stride_k_sl, kv_cache_info.stride_k_head_num,        // nb (bestla managed)
                        0);                                                                // offset
         *reinterpret_cast<ATTN_FWD_LAYOUT*>(&key_layer->nb[0]) = kv_cache_info.k_layout;  // us nb0 for layout
         if (is_ring_full) {
@@ -258,7 +258,7 @@ static bool chatglm_model_eval_internal(model_context* ctx, const model_input* i
         value_layer =
             ne_view_3d(ctx0, model.layers[il].v_cache,                                      // tensor
                        n_cached, head_size, num_kv_heads,                                   // ne
-                       kv_cache_info.stride_v_head_size, kv_cache_info.stride_v_head_num,   // nb (jblas managed)
+                       kv_cache_info.stride_v_head_size, kv_cache_info.stride_v_head_num,   // nb (bestla managed)
                        0);                                                                  // offset
         *reinterpret_cast<ATTN_FWD_LAYOUT*>(&value_layer->nb[0]) = kv_cache_info.v_layout;  // us nb0 for layout
 
diff --git a/neural_speed/models/chatglm/chatglm2_utils.cpp b/neural_speed/models/chatglm/chatglm2_utils.cpp
index 91deb1fc8..3ead9273d 100644
--- a/neural_speed/models/chatglm/chatglm2_utils.cpp
+++ b/neural_speed/models/chatglm/chatglm2_utils.cpp
@@ -50,7 +50,7 @@ void model_load_internal(const std::string& fname, model_archs arch, model_conte
   ms->init(fname.c_str(), ctx, n_gpu_layers, use_mmap, use_mlock, vocab_only);
   ms->load(ctx, progress_callback, progress_callback_user_data);
 
-  lctx.support_jblas_kv = true;
+  lctx.support_bestla_kv = true;
   lctx.t_load_us = ne_time_us() - lctx.t_start_us;
 }
 
diff --git a/neural_speed/models/falcon/CMakeLists.txt b/neural_speed/models/falcon/CMakeLists.txt
index fc9415f26..887b165d2 100644
--- a/neural_speed/models/falcon/CMakeLists.txt
+++ b/neural_speed/models/falcon/CMakeLists.txt
@@ -16,4 +16,4 @@ set(TARGET falcon)
 add_library_w_warning(${TARGET} falcon.cpp falcon_utils.cpp ${MODEL_UTILS_SOURCE})
 target_compile_features(${TARGET} PUBLIC cxx_std_11) # don't bump
 set_target_properties(${TARGET} PROPERTIES POSITION_INDEPENDENT_CODE ON)
-target_link_libraries(${TARGET} PUBLIC ne_layers jblas::jblas)
+target_link_libraries(${TARGET} PUBLIC ne_layers bestla::bestla)
diff --git a/neural_speed/models/falcon/falcon.cpp b/neural_speed/models/falcon/falcon.cpp
index cdcd00af4..e866fd94a 100644
--- a/neural_speed/models/falcon/falcon.cpp
+++ b/neural_speed/models/falcon/falcon.cpp
@@ -31,7 +31,7 @@
 #include "core/data_types.h"
 #include "core/ne.h"
 #include "core/ne_layers.h"
-#include "core/ne_jblas.h"
+#include "core/ne_bestla.h"
 #include "core/layers/mha_dense.h"
 #include "models/model_utils/model_config.h"
 #include "models/model_utils/model_utils.h"
@@ -93,27 +93,27 @@ static bool falcon_model_eval_internal(model_context* ctx, const model_input* in
   ne_cgraph gf = {};
   gf.n_threads = N >= 32 && ne_cpu_has_blas() ? 1 : n_threads;
 
-  const bool run_mha_reordered = kv_self.k->type == NE_TYPE_JBLAS;
+  const bool run_mha_reordered = kv_self.k->type == NE_TYPE_BTLA;
   kv_cache_info_t kv_cache_info = {};
   if (run_mha_reordered) {
-    NE_ASSERT(("kv cache should be the same dtype", kv_self.v->type == NE_TYPE_JBLAS));
+    NE_ASSERT(("kv cache should be the same dtype", kv_self.v->type == NE_TYPE_BTLA));
     attn_shape_t attn_shape = {
         /* .batch_size = */ 1,
         /* .head_num = */ n_head,
         /* .heads_kv = */ n_head_kv,
         /* .head_size = */ head_dim,
-        /* .sl_q = */ N,  // Note: make sure that jblas reordered attn supports next token inference
+        /* .sl_q = */ N,  // Note: make sure that bestla reordered attn supports next token inference
         /* .sl_kv = */ n_past + N,
     };
 
-    NE_ASSERT(("jblas managed kv-cache not supported; use `--memory-f16 / --memory-f32` instead",
-               jblas_reordered_attn_fp32_support(&attn_shape)));
+    NE_ASSERT(("bestla managed kv-cache not supported; use `--memory-f16 / --memory-f32` instead",
+               bestla_reordered_attn_fp32_support(&attn_shape)));
     kv_shape_t kv_shape{
         /* .heads_kv = */ static_cast<uint32_t>(n_head_kv),
         /* .head_size = */ static_cast<uint32_t>(head_dim),
         /* .sl_kv_max = */ static_cast<uint32_t>(n_ctx),
     };
-    jblas_reordered_attn_fp32_batch_kv_info(&kv_shape, &kv_cache_info);
+    bestla_reordered_attn_fp32_batch_kv_info(&kv_shape, &kv_cache_info);
   }
 
   struct ne_tensor* embd = d_ne_new_tensor_1d(ctx0, NE_TYPE_I32, N);
@@ -232,12 +232,12 @@ static bool falcon_model_eval_internal(model_context* ctx, const model_input* in
         {
           const auto k_cache = ne_view_3d(ctx0, kv_self.k,             // tensor
                                           head_dim, n_ctx, n_head_kv,  // ne
-                                          0, 0,                        // nb (jblas managed)
+                                          0, 0,                        // nb (bestla managed)
                                           il * k_size);                // offset
           ne_build_forward_expand(&gf, ne_flash_attn_update_k(ctx0, k_cache, Kcur, n_past, false));
           const auto v_cache = ne_view_3d(ctx0, kv_self.v,             // tensor
                                           head_dim, n_ctx, n_head_kv,  // ne
-                                          0, 0,                        // nb (jblas managed)
+                                          0, 0,                        // nb (bestla managed)
                                           il * v_size);                // offset
           ne_build_forward_expand(&gf, ne_flash_attn_update_v(ctx0, v_cache, Vcur, n_past, false));
         }
@@ -248,14 +248,14 @@ static bool falcon_model_eval_internal(model_context* ctx, const model_input* in
         struct ne_tensor* K =
             ne_view_3d(ctx0, kv_self.k,                                             // tensor
                        head_dim, seq_kv, n_head_kv,                                 // ne
-                       kv_cache_info.stride_k_sl, kv_cache_info.stride_k_head_num,  // nb (jblas managed)
+                       kv_cache_info.stride_k_sl, kv_cache_info.stride_k_head_num,  // nb (bestla managed)
                        il * k_size);                                                // offset
         *reinterpret_cast<ATTN_FWD_LAYOUT*>(&K->nb[0]) = kv_cache_info.k_layout;    // us nb0 for layout
         ne_set_name(K, "K");
         struct ne_tensor* V =
             ne_view_3d(ctx0, kv_self.v,                                                    // tensor
                        seq_kv, head_dim, n_head_kv,                                        // ne
-                       kv_cache_info.stride_v_head_size, kv_cache_info.stride_v_head_num,  // nb (jblas managed)
+                       kv_cache_info.stride_v_head_size, kv_cache_info.stride_v_head_num,  // nb (bestla managed)
                        il * v_size);                                                       // offset
         *reinterpret_cast<ATTN_FWD_LAYOUT*>(&V->nb[0]) = kv_cache_info.v_layout;           // us nb0 for layout
         ne_set_name(V, "V");
@@ -277,9 +277,9 @@ static bool falcon_model_eval_internal(model_context* ctx, const model_input* in
     // FFN (pre_layer_norm output)
     {
       // FFN FUSION
-      if (jblas_fusion_FFN_GeLu_f32f32_support(model.layers[il].ffn[0]->data, model.layers[il].ffn[1]->data,
-                                               N * batch_size, cur->ne[0], model.layers[il].ffn[0]->ne[1],
-                                               model.layers[il].ffn[1]->ne[1])) {
+      if (bestla_fusion_FFN_GeLu_f32f32_support(model.layers[il].ffn[0]->data, model.layers[il].ffn[1]->data,
+                                                N * batch_size, cur->ne[0], model.layers[il].ffn[0]->ne[1],
+                                                model.layers[il].ffn[1]->ne[1])) {
         cur = ne_ffn_gelu(ctx0, model.layers[il].ffn[0], model.layers[il].ffn[1], inpFF);
       } else {
         cur = ne_mul_mat(ctx0, model.layers[il].ffn[0], inpFF);
diff --git a/neural_speed/models/falcon/falcon_utils.cpp b/neural_speed/models/falcon/falcon_utils.cpp
index d962290c0..95e399022 100644
--- a/neural_speed/models/falcon/falcon_utils.cpp
+++ b/neural_speed/models/falcon/falcon_utils.cpp
@@ -46,7 +46,7 @@ void model_load_internal(const std::string& fname, model_archs arch, model_conte
   ms->init(fname.c_str(), ctx, n_gpu_layers, use_mmap, use_mlock, vocab_only);
   ms->load(ctx, progress_callback, progress_callback_user_data);
   model_context& lctx = *ctx;
-  lctx.support_jblas_kv = true;
+  lctx.support_bestla_kv = true;
 }
 
 void FALCON::init(const char* path_model, model_context* ctx, int n_gpu_layer_, bool use_mmap_, bool use_mlock_,
diff --git a/neural_speed/models/gptj/CMakeLists.txt b/neural_speed/models/gptj/CMakeLists.txt
index 23d60ca98..b854da979 100644
--- a/neural_speed/models/gptj/CMakeLists.txt
+++ b/neural_speed/models/gptj/CMakeLists.txt
@@ -16,4 +16,4 @@ set(TARGET gptj)
 add_library_w_warning(${TARGET} gptj.cpp gptj_utils.cpp ${MODEL_UTILS_SOURCE})
 target_compile_features(${TARGET} PUBLIC cxx_std_11) # don't bump
 set_target_properties(${TARGET} PROPERTIES POSITION_INDEPENDENT_CODE ON)
-target_link_libraries(${TARGET} PUBLIC ne_layers jblas::jblas)
+target_link_libraries(${TARGET} PUBLIC ne_layers bestla::bestla)
diff --git a/neural_speed/models/gptj/gptj.cpp b/neural_speed/models/gptj/gptj.cpp
index 8a04d128a..1ee917510 100644
--- a/neural_speed/models/gptj/gptj.cpp
+++ b/neural_speed/models/gptj/gptj.cpp
@@ -33,7 +33,7 @@
 #include "core/layers/mha_dense.h"
 #include "core/ne.h"
 #include "core/ne_layers.h"
-#include "core/ne_jblas.h"
+#include "core/ne_bestla.h"
 #include "models/model_utils/model_config.h"
 #include "models/model_utils/model_utils.h"
 #include "models/model_utils/util.h"
@@ -115,29 +115,29 @@ static bool gptj_model_eval_internal(model_context* ctx, const model_input* inpu
   ne_cgraph gf = {};
   gf.n_threads = n_threads;
 
-  const bool run_mha_reordered = kv_self.k->type == NE_TYPE_JBLAS;
-  const bool run_mha_fp16 = !run_mha_reordered && MHA_FP16 && jblas_fusion_attn_fp16_support(NULL);
+  const bool run_mha_reordered = kv_self.k->type == NE_TYPE_BTLA;
+  const bool run_mha_fp16 = !run_mha_reordered && MHA_FP16 && bestla_fusion_attn_fp16_support(NULL);
   const bool run_mha_bf16_first =
-      !run_mha_reordered && MHA_FUSION && !MHA_FP16 && jblas_fusion_attn_fp32_fp16_fp16_fp32_support(NULL);
+      !run_mha_reordered && MHA_FUSION && !MHA_FP16 && bestla_fusion_attn_fp32_fp16_fp16_fp32_support(NULL);
   kv_cache_info_t kv_cache_info = {0, 0};
   if (run_mha_reordered) {
-    NE_ASSERT(kv_self.v->type == NE_TYPE_JBLAS);  // kv type should be the same
+    NE_ASSERT(kv_self.v->type == NE_TYPE_BTLA);  // kv type should be the same
     attn_shape_t attn_shape = {
         /* .batch_size = */ batch_size,
         /* .head_num = */ n_head,
         /* .heads_kv = */ n_head,  // GPT-J does not have MQA/GQA
         /* .head_size = */ head_size,
-        /* .sl_q = */ N,  // Note: make sure that jblas reordered attn supports next token inference
+        /* .sl_q = */ N,  // Note: make sure that bestla reordered attn supports next token inference
         /* .sl_kv = */ n_cached,
     };
-    NE_ASSERT(("jblas managed kv-cache not supported; use `--memory-f16 / --memory-f32` instead",
-               jblas_reordered_attn_fp32_support(&attn_shape)));
+    NE_ASSERT(("bestla managed kv-cache not supported; use `--memory-f16 / --memory-f32` instead",
+               bestla_reordered_attn_fp32_support(&attn_shape)));
     kv_shape_t kv_shape{
         /* .head_num = */ static_cast<uint32_t>(n_head),
         /* .head_size = */ static_cast<uint32_t>(head_size),
         /* .sl_kv_max = */ static_cast<uint32_t>(n_ctx),
     };
-    jblas_reordered_attn_fp32_batch_kv_info(&kv_shape, &kv_cache_info);
+    bestla_reordered_attn_fp32_batch_kv_info(&kv_shape, &kv_cache_info);
   }
 
   struct ne_tensor* embd = d_ne_new_tensor_1d(ctx0, NE_TYPE_I32, N * batch_size);
@@ -170,10 +170,10 @@ static bool gptj_model_eval_internal(model_context* ctx, const model_input* inpu
 
     ne_tensor *Qcur, *Kcur, *Vcur;
     int kv_n_ctx_block = lctx.kv_n_ctx_block;
-    if (jblas_fusion_QKV_f32f32_support(model.layers[il].attn[0]->data, model.layers[il].attn[1]->data,
-                                        model.layers[il].attn[2]->data, N * batch_size, head_size * n_head,
-                                        head_size * n_head)) {  // fused execution of QKV
-                                                                // if (false) {
+    if (bestla_fusion_QKV_f32f32_support(model.layers[il].attn[0]->data, model.layers[il].attn[1]->data,
+                                         model.layers[il].attn[2]->data, N * batch_size, head_size * n_head,
+                                         head_size * n_head)) {  // fused execution of QKV
+                                                                 // if (false) {
       struct ne_tensor* QKVcur =
           ne_mul_qkv(ctx0, model.layers[il].attn[0], model.layers[il].attn[1], model.layers[il].attn[2], cur);
       const size_t qkv_size = N * head_size * n_head * batch_size;
@@ -266,14 +266,14 @@ static bool gptj_model_eval_internal(model_context* ctx, const model_input* inpu
       const auto v_size = kv_cache_info.v_bytes;
       const auto k_cache = ne_view_4d(ctx0, kv_self.k,                       // tensor
                                       head_size, n_ctx, n_head, batch_size,  // ne
-                                      0, 0, k_size,                          // nb (jblas managed)
+                                      0, 0, k_size,                          // nb (bestla managed)
                                       il * kv_n_ctx_block * k_size);         // offset
       ne_build_forward_expand(&gf, ne_flash_attn_update_k(ctx0, k_cache, Kcur, n_past, is_ring_full));
       const auto v_cache = ne_view_4d(ctx0, kv_self.v,                       // tensor
                                       head_size, n_ctx, n_head, batch_size,  // ne
-                                      0, 0, v_size,                          // nb (jblas managed)
+                                      0, 0, v_size,                          // nb (bestla managed)
                                       il * kv_n_ctx_block * v_size);         // offset
-      // jblas alway view V as (D, n_head, seq, bs)
+      // bestla alway view V as (D, n_head, seq, bs)
       const auto Vcur_plain = ne_reshape_4d(ctx0, Vcur, head_size, n_head, N, batch_size);
       ne_build_forward_expand(&gf, ne_flash_attn_update_v(ctx0, v_cache, Vcur_plain, n_past, is_ring_full));
     }
@@ -285,7 +285,7 @@ static bool gptj_model_eval_internal(model_context* ctx, const model_input* inpu
       const auto k_size = kv_cache_info.k_bytes;
       K = ne_view_4d(ctx0, kv_self.k,                                                     // tensor
                      head_size, n_cached, n_head, batch_size,                             // ne
-                     kv_cache_info.stride_k_sl, kv_cache_info.stride_k_head_num, k_size,  // nb (jblas managed)
+                     kv_cache_info.stride_k_sl, kv_cache_info.stride_k_head_num, k_size,  // nb (bestla managed)
                      il * kv_n_ctx_block * k_size);                                       // offset
       *reinterpret_cast<ATTN_FWD_LAYOUT*>(&K->nb[0]) = kv_cache_info.k_layout;
       if (is_ring_full) {
@@ -298,7 +298,7 @@ static bool gptj_model_eval_internal(model_context* ctx, const model_input* inpu
       const auto v_size = kv_cache_info.v_bytes;
       V = ne_view_4d(ctx0, kv_self.v,                                                            // tensor
                      n_cached, head_size, n_head, batch_size,                                    // ne
-                     kv_cache_info.stride_v_head_size, kv_cache_info.stride_v_head_num, v_size,  // nb (jblas managed)
+                     kv_cache_info.stride_v_head_size, kv_cache_info.stride_v_head_num, v_size,  // nb (bestla managed)
                      il * kv_n_ctx_block * v_size);                                              // offset
       *reinterpret_cast<ATTN_FWD_LAYOUT*>(&V->nb[0]) = kv_cache_info.v_layout;
     } else if (run_mha_fp16) {
@@ -417,9 +417,9 @@ static bool gptj_model_eval_internal(model_context* ctx, const model_input* inpu
 
     // feed-forward network
     // disable ffn fusion because fp32 support not ready
-    if (jblas_fusion_FFN_Add_GeLu_f32f32_support(model.layers[il].ffn[0]->data, model.layers[il].ffn[2]->data,
-                                                 N * batch_size, inpSA->ne[0], model.layers[il].ffn[0]->ne[1],
-                                                 model.layers[il].ffn[2]->ne[1])) {
+    if (bestla_fusion_FFN_Add_GeLu_f32f32_support(model.layers[il].ffn[0]->data, model.layers[il].ffn[2]->data,
+                                                  N * batch_size, inpSA->ne[0], model.layers[il].ffn[0]->ne[1],
+                                                  model.layers[il].ffn[2]->ne[1])) {
       cur = ne_ffn_add_gelu(ctx0, model.layers[il].ffn[0], model.layers[il].ffn[2], model.layers[il].ffn[1],
                             model.layers[il].ffn[3], inpSA);
     } else {
@@ -464,8 +464,8 @@ static bool gptj_model_eval_internal(model_context* ctx, const model_input* inpu
   }
 
   // lm_head
-  if (jblas_fusion_add_f32f32_support(model.others[3]->data, N * batch_size, model.others[3]->ne[1],
-                                      model.others[3]->ne[0])) {
+  if (bestla_fusion_add_f32f32_support(model.others[3]->data, N * batch_size, model.others[3]->ne[1],
+                                       model.others[3]->ne[0])) {
     inpL = ne_mul_mat_with_bias(ctx0, model.others[3], model.others[4], inpL);
   } else {
     inpL = ne_mul_mat(ctx0, model.others[3], inpL);
diff --git a/neural_speed/models/gptj/gptj_utils.cpp b/neural_speed/models/gptj/gptj_utils.cpp
index e81b9a02e..6a6ac7075 100644
--- a/neural_speed/models/gptj/gptj_utils.cpp
+++ b/neural_speed/models/gptj/gptj_utils.cpp
@@ -47,7 +47,7 @@ void model_load_internal(const std::string& fname, model_archs arch, model_conte
   ms->load(ctx, progress_callback, progress_callback_user_data);
 
   model_context& lctx = *ctx;
-  lctx.support_jblas_kv = true;
+  lctx.support_bestla_kv = true;
 }
 
 void GPTJ::init(const char* path_model, model_context* ctx, int n_gpu_layer_, bool use_mmap_, bool use_mlock_,
diff --git a/neural_speed/models/gptneox/CMakeLists.txt b/neural_speed/models/gptneox/CMakeLists.txt
index 0b7106379..538a17d50 100644
--- a/neural_speed/models/gptneox/CMakeLists.txt
+++ b/neural_speed/models/gptneox/CMakeLists.txt
@@ -16,4 +16,4 @@ set(TARGET gptneox)
 add_library_w_warning(${TARGET} gptneox.cpp gptneox_utils.cpp ${MODEL_UTILS_SOURCE})
 target_compile_features(${TARGET} PUBLIC cxx_std_11) # don't bump
 set_target_properties(${TARGET} PROPERTIES POSITION_INDEPENDENT_CODE ON)
-target_link_libraries(${TARGET} PUBLIC ne_layers jblas::jblas)
+target_link_libraries(${TARGET} PUBLIC ne_layers bestla::bestla)
diff --git a/neural_speed/models/gptneox/gptneox.cpp b/neural_speed/models/gptneox/gptneox.cpp
index 4953f78d6..93784e709 100644
--- a/neural_speed/models/gptneox/gptneox.cpp
+++ b/neural_speed/models/gptneox/gptneox.cpp
@@ -31,7 +31,7 @@
 #include "core/data_types.h"
 #include "core/ne.h"
 #include "core/ne_layers.h"
-#include "core/ne_jblas.h"
+#include "core/ne_bestla.h"
 #include "core/layers/mha_dense.h"
 #include "models/model_utils/model_config.h"
 #include "models/model_utils/model_utils.h"
@@ -43,8 +43,8 @@ struct ne_tensor* gpt_neox_ff(const model_layer& layer, const int batch_size, co
   struct ne_tensor* cur = ne_norm(ctx0, inp);
 
   cur = ne_add(ctx0, ne_mul(ctx0, ne_repeat(ctx0, layer.norm[2], cur), cur), ne_repeat(ctx0, layer.norm[3], cur));
-  if (jblas_fusion_FFN_Add_GeLu_f32f32_support(layer.ffn[0]->data, layer.ffn[2]->data, N * batch_size, cur->ne[0],
-                                               layer.ffn[0]->ne[1], layer.ffn[2]->ne[1])) {
+  if (bestla_fusion_FFN_Add_GeLu_f32f32_support(layer.ffn[0]->data, layer.ffn[2]->data, N * batch_size, cur->ne[0],
+                                                layer.ffn[0]->ne[1], layer.ffn[2]->ne[1])) {
     cur = ne_ffn_add_gelu(ctx0, layer.ffn[0], layer.ffn[2], layer.ffn[1], layer.ffn[3], cur);
   } else {
     cur = ne_mul_mat(ctx0, layer.ffn[0], cur);
@@ -129,27 +129,27 @@ static bool gptneox_model_eval_internal(model_context* ctx, const model_input* i
   ne_cgraph gf = {};
   gf.n_threads = N >= 32 && ne_cpu_has_blas() ? 1 : n_threads;
 
-  const bool run_mha_reordered = kv_self.k->type == NE_TYPE_JBLAS;
+  const bool run_mha_reordered = kv_self.k->type == NE_TYPE_BTLA;
   kv_cache_info_t kv_cache_info = {};
   if (run_mha_reordered) {
-    NE_ASSERT(("kv cache should be the same dtype", kv_self.v->type == NE_TYPE_JBLAS));
+    NE_ASSERT(("kv cache should be the same dtype", kv_self.v->type == NE_TYPE_BTLA));
     attn_shape_t attn_shape = {
         /* .batch_size = */ 1,
         /* .head_num = */ n_head,
         /* .heads_kv = */ n_head,
         /* .head_size = */ head_dim,
-        /* .sl_q = */ N,  // Note: make sure that jblas reordered attn supports next token inference
+        /* .sl_q = */ N,  // Note: make sure that bestla reordered attn supports next token inference
         /* .sl_kv = */ n_past + N,
     };
 
-    NE_ASSERT(("jblas managed kv-cache not supported; use `--memory-f16 / --memory-f32` instead",
-               jblas_reordered_attn_fp32_support(&attn_shape)));
+    NE_ASSERT(("bestla managed kv-cache not supported; use `--memory-f16 / --memory-f32` instead",
+               bestla_reordered_attn_fp32_support(&attn_shape)));
     kv_shape_t kv_shape{
         /* .heads_kv = */ static_cast<uint32_t>(n_head),
         /* .head_size = */ static_cast<uint32_t>(head_dim),
         /* .sl_kv_max = */ static_cast<uint32_t>(n_ctx),
     };
-    jblas_reordered_attn_fp32_batch_kv_info(&kv_shape, &kv_cache_info);
+    bestla_reordered_attn_fp32_batch_kv_info(&kv_shape, &kv_cache_info);
   }
   struct ne_tensor* embd = d_ne_new_tensor_1d(ctx0, NE_TYPE_I32, N * batch_size);
   ne_set_name(embd, "embd");
@@ -271,12 +271,12 @@ static bool gptneox_model_eval_internal(model_context* ctx, const model_input* i
         {
           const auto k_cache = ne_view_3d(ctx0, kv_self.k,          // tensor
                                           head_dim, n_ctx, n_head,  // ne
-                                          0, 0,                     // nb (jblas managed)
+                                          0, 0,                     // nb (bestla managed)
                                           il * k_size);             // offset
           ne_build_forward_expand(&gf, ne_flash_attn_update_k(ctx0, k_cache, Kcur, n_past, false));
           const auto v_cache = ne_view_3d(ctx0, kv_self.v,          // tensor
                                           head_dim, n_ctx, n_head,  // ne
-                                          0, 0,                     // nb (jblas managed)
+                                          0, 0,                     // nb (bestla managed)
                                           il * v_size);             // offset
           ne_build_forward_expand(&gf, ne_flash_attn_update_v(ctx0, v_cache, Vcur, n_past, false));
         }
@@ -287,14 +287,14 @@ static bool gptneox_model_eval_internal(model_context* ctx, const model_input* i
         struct ne_tensor* K =
             ne_view_3d(ctx0, kv_self.k,                                             // tensor
                        head_dim, seq_kv, n_head,                                    // ne
-                       kv_cache_info.stride_k_sl, kv_cache_info.stride_k_head_num,  // nb (jblas managed)
+                       kv_cache_info.stride_k_sl, kv_cache_info.stride_k_head_num,  // nb (bestla managed)
                        il * k_size);                                                // offset
         *reinterpret_cast<ATTN_FWD_LAYOUT*>(&K->nb[0]) = kv_cache_info.k_layout;    // us nb0 for layout
         ne_set_name(K, "K");
         struct ne_tensor* V =
             ne_view_3d(ctx0, kv_self.v,                                                    // tensor
                        seq_kv, head_dim, n_head,                                           // ne
-                       kv_cache_info.stride_v_head_size, kv_cache_info.stride_v_head_num,  // nb (jblas managed)
+                       kv_cache_info.stride_v_head_size, kv_cache_info.stride_v_head_num,  // nb (bestla managed)
                        il * v_size);                                                       // offset
         *reinterpret_cast<ATTN_FWD_LAYOUT*>(&V->nb[0]) = kv_cache_info.v_layout;           // us nb0 for layout
         ne_set_name(V, "V");
diff --git a/neural_speed/models/gptneox/gptneox_utils.cpp b/neural_speed/models/gptneox/gptneox_utils.cpp
index 20efec831..f7ebfe34a 100644
--- a/neural_speed/models/gptneox/gptneox_utils.cpp
+++ b/neural_speed/models/gptneox/gptneox_utils.cpp
@@ -46,7 +46,7 @@ void model_load_internal(const std::string& fname, model_archs arch, model_conte
   ms->init(fname.c_str(), ctx, n_gpu_layers, use_mmap, use_mlock, vocab_only);
   ms->load(ctx, progress_callback, progress_callback_user_data);
   model_context& lctx = *ctx;
-  lctx.support_jblas_kv = true;
+  lctx.support_bestla_kv = true;
 }
 
 void GPTNEOX::init(const char* path_model, model_context* ctx, int n_gpu_layer_, bool use_mmap_, bool use_mlock_,
diff --git a/neural_speed/models/llama/CMakeLists.txt b/neural_speed/models/llama/CMakeLists.txt
index 20331b439..bd0fbdd64 100644
--- a/neural_speed/models/llama/CMakeLists.txt
+++ b/neural_speed/models/llama/CMakeLists.txt
@@ -16,4 +16,4 @@ set(TARGET llama)
 add_library_w_warning(${TARGET} llama.cpp llama_utils.cpp ${MODEL_UTILS_SOURCE})
 target_compile_features(${TARGET} PUBLIC cxx_std_11) # don't bump
 set_target_properties(${TARGET} PROPERTIES POSITION_INDEPENDENT_CODE ON)
-target_link_libraries(${TARGET} PUBLIC ne_layers jblas::jblas)
+target_link_libraries(${TARGET} PUBLIC ne_layers bestla::bestla)
diff --git a/neural_speed/models/llama/llama.cpp b/neural_speed/models/llama/llama.cpp
index 894f927a5..9759b4a6e 100644
--- a/neural_speed/models/llama/llama.cpp
+++ b/neural_speed/models/llama/llama.cpp
@@ -33,7 +33,7 @@
 #include "core/data_types.h"
 #include "core/layers/mha_dense.h"
 #include "core/ne.h"
-#include "core/ne_jblas.h"
+#include "core/ne_bestla.h"
 #include "core/ne_layers.h"
 #include "models/model_utils/model_config.h"
 #include "models/model_utils/model_files.h"
@@ -119,27 +119,27 @@ static bool llama_model_eval_internal(model_context* ctx, const model_input* inp
   ne_cgraph gf = {};
   gf.n_threads = N >= 32 && ne_cpu_has_blas() ? 1 : n_threads;
 
-  const bool run_mha_reordered = kv_self.k->type == NE_TYPE_JBLAS;
+  const bool run_mha_reordered = kv_self.k->type == NE_TYPE_BTLA;
   kv_cache_info_t kv_cache_info = {0, 0};
   if (run_mha_reordered) {
-    NE_ASSERT(kv_self.v->type == NE_TYPE_JBLAS);  // kv type should be the same
+    NE_ASSERT(kv_self.v->type == NE_TYPE_BTLA);  // kv type should be the same
     attn_shape_t attn_shape = {
         /* .batch_size = */ 1,
         /* .head_num = */ n_head,
         /* .heads_kv = */ n_head_kv,
         /* .head_size = */ head_size,
-        /* .sl_q = */ N,  // Note: make sure that jblas reordered attn supports next token inferencing
+        /* .sl_q = */ N,  // Note: make sure that bestla reordered attn supports next token inferencing
         /* .sl_kv = */ n_cached,
     };
 
-    NE_ASSERT(("jblas managed kv-cache not supported; use `--memory-f16 / --memory-f32` instead",
-               jblas_reordered_attn_fp32_support(&attn_shape)));
+    NE_ASSERT(("bestla managed kv-cache not supported; use `--memory-f16 / --memory-f32` instead",
+               bestla_reordered_attn_fp32_support(&attn_shape)));
     kv_shape_t kv_shape{
         /* .heads_kv = */ static_cast<uint32_t>(n_head_kv),
         /* .head_size = */ static_cast<uint32_t>(head_size),
         /* .sl_kv_max = */ static_cast<uint32_t>(n_ctx),
     };
-    jblas_reordered_attn_fp32_batch_kv_info(&kv_shape, &kv_cache_info);
+    bestla_reordered_attn_fp32_batch_kv_info(&kv_shape, &kv_cache_info);
   }
 
   struct ne_tensor* embd = ne_new_tensor_1d(ctx0, NE_TYPE_I32, N, NE_SIZE_CALC);
@@ -171,9 +171,9 @@ static bool llama_model_eval_internal(model_context* ctx, const model_input* inp
       cur = ne_mul(ctx0, cur, model.layers[il].norm[0]);
     }
     ne_tensor *Qcur, *Kcur, *Vcur;
-    if (jblas_fusion_QKV_f32f32_support(model.layers[il].attn[0]->data, model.layers[il].attn[1]->data,
-                                        model.layers[il].attn[2]->data, N, model.layers[il].attn[0]->ne[1],
-                                        model.layers[il].attn[0]->ne[0]) &&
+    if (bestla_fusion_QKV_f32f32_support(model.layers[il].attn[0]->data, model.layers[il].attn[1]->data,
+                                         model.layers[il].attn[2]->data, N, model.layers[il].attn[0]->ne[1],
+                                         model.layers[il].attn[0]->ne[0]) &&
         n_head == n_head_kv) {  // fused execution of QKV
       struct ne_tensor* QKVcur =
           ne_mul_qkv(ctx0, model.layers[il].attn[0], model.layers[il].attn[1], model.layers[il].attn[2], cur);
@@ -274,14 +274,14 @@ static bool llama_model_eval_internal(model_context* ctx, const model_input* inp
       {
         const auto k_cache = ne_view_3d(ctx0, kv_self.k,              // tensor
                                         head_size, n_ctx, n_head_kv,  // ne
-                                        0, 0,                         // nb (jblas managed)
+                                        0, 0,                         // nb (bestla managed)
                                         il * k_size);                 // offset
         ne_build_forward_expand(&gf, ne_flash_attn_update_k(ctx0, k_cache, Kcur, n_past, is_ring_full));
         const auto v_cache = ne_view_3d(ctx0, kv_self.v,              // tensor
                                         head_size, n_ctx, n_head_kv,  // ne
-                                        0, 0,                         // nb (jblas managed)
+                                        0, 0,                         // nb (bestla managed)
                                         il * v_size);                 // offset
-        // jblas alway view V as (D, n_head, seq)
+        // bestla alway view V as (D, n_head, seq)
         const auto Vcur_plain =
             ne_reshape_3d(ctx0, ne_view_1d(ctx0, Vcur, n_embd_gqa * N, 0), n_embd_gqa / n_head_kv, n_head_kv, N);
         ne_build_forward_expand(&gf, ne_flash_attn_update_v(ctx0, v_cache, Vcur_plain, n_past, is_ring_full));
@@ -293,7 +293,7 @@ static bool llama_model_eval_internal(model_context* ctx, const model_input* inp
       struct ne_tensor* K =
           ne_view_3d(ctx0, kv_self.k,                                             // tensor
                      head_size, n_cached, n_head_kv,                              // ne
-                     kv_cache_info.stride_k_sl, kv_cache_info.stride_k_head_num,  // nb (jblas managed)
+                     kv_cache_info.stride_k_sl, kv_cache_info.stride_k_head_num,  // nb (bestla managed)
                      il * k_size);                                                // offset
       *reinterpret_cast<ATTN_FWD_LAYOUT*>(&K->nb[0]) = kv_cache_info.k_layout;    // us nb0 for layout
       if (is_ring_full) {
@@ -308,7 +308,7 @@ static bool llama_model_eval_internal(model_context* ctx, const model_input* inp
       struct ne_tensor* V =
           ne_view_3d(ctx0, kv_self.v,                                                    // tensor
                      n_cached, head_size, n_head_kv,                                     // ne
-                     kv_cache_info.stride_v_head_size, kv_cache_info.stride_v_head_num,  // nb (jblas managed)
+                     kv_cache_info.stride_v_head_size, kv_cache_info.stride_v_head_num,  // nb (bestla managed)
                      il * v_size);                                                       // offset
       *reinterpret_cast<ATTN_FWD_LAYOUT*>(&V->nb[0]) = kv_cache_info.v_layout;           // us nb0 for layout
       ne_set_name(V, "V");
@@ -343,9 +343,9 @@ static bool llama_model_eval_internal(model_context* ctx, const model_input* inp
         cur = ne_mul(ctx0, cur, model.layers[il].norm[1]);
       }
 
-      if (jblas_fusion_FFN_SiLu_f32f32_support(model.layers[il].ffn[0]->data, model.layers[il].ffn[1]->data,
-                                               model.layers[il].ffn[2]->data, N, cur->ne[0],
-                                               model.layers[il].ffn[0]->ne[1], model.layers[il].ffn[1]->ne[1])) {
+      if (bestla_fusion_FFN_SiLu_f32f32_support(model.layers[il].ffn[0]->data, model.layers[il].ffn[1]->data,
+                                                model.layers[il].ffn[2]->data, N, cur->ne[0],
+                                                model.layers[il].ffn[0]->ne[1], model.layers[il].ffn[1]->ne[1])) {
         cur = ne_ffn_silu(ctx0, model.layers[il].ffn[0], model.layers[il].ffn[1], model.layers[il].ffn[2], cur);
       } else {
         struct ne_tensor* tmp = ne_mul_mat(ctx0, model.layers[il].ffn[2], cur);
diff --git a/neural_speed/models/llama/llama_utils.cpp b/neural_speed/models/llama/llama_utils.cpp
index 69c4dbdc2..2780718ac 100644
--- a/neural_speed/models/llama/llama_utils.cpp
+++ b/neural_speed/models/llama/llama_utils.cpp
@@ -47,7 +47,7 @@ void model_load_internal(const std::string& fname, model_archs arch, model_conte
   ms->load(ctx, progress_callback, progress_callback_user_data);
 
   model_context& lctx = *ctx;
-  lctx.support_jblas_kv = true;
+  lctx.support_bestla_kv = true;
 }
 
 void Llama::init(const char* path_model, model_context* ctx, int n_gpu_layer_, bool use_mmap_, bool use_mlock_,
diff --git a/neural_speed/models/mistral/CMakeLists.txt b/neural_speed/models/mistral/CMakeLists.txt
index 0d9fdecf4..dd894d1a2 100644
--- a/neural_speed/models/mistral/CMakeLists.txt
+++ b/neural_speed/models/mistral/CMakeLists.txt
@@ -16,4 +16,4 @@ set(TARGET mistral)
 add_library_w_warning(${TARGET} mistral.cpp mistral_utils.cpp ${MODEL_UTILS_SOURCE})
 target_compile_features(${TARGET} PUBLIC cxx_std_11) # don't bump
 set_target_properties(${TARGET} PROPERTIES POSITION_INDEPENDENT_CODE ON)
-target_link_libraries(${TARGET} PUBLIC ne_layers jblas::jblas)
+target_link_libraries(${TARGET} PUBLIC ne_layers bestla::bestla)
diff --git a/neural_speed/models/model_utils/arg_parse.cpp b/neural_speed/models/model_utils/arg_parse.cpp
index dff4f98f2..db77169e0 100644
--- a/neural_speed/models/model_utils/arg_parse.cpp
+++ b/neural_speed/models/model_utils/arg_parse.cpp
@@ -272,6 +272,8 @@ bool gpt_params_parse(int argc, char** argv, gpt_params& params) {  // NOLINT
       params.interactive = true;
     } else if (arg == "--embedding") {
       params.embedding = true;
+    } else if (arg == "--no-warmup") {
+      params.warmup = false;
     } else if (arg == "--interactive-first") {
       params.interactive_first = true;
     } else if (arg == "-ins" || arg == "--instruct") {
diff --git a/neural_speed/models/model_utils/model_config.h b/neural_speed/models/model_utils/model_config.h
index 3d5702ca4..58b24c3bf 100644
--- a/neural_speed/models/model_utils/model_config.h
+++ b/neural_speed/models/model_utils/model_config.h
@@ -84,6 +84,7 @@ struct gpt_params {
   bool embedding = false;          // get only sentence embedding
   bool interactive_first = false;  // wait for user input immediately
   bool multiline_input = false;    // reverse the usage of `\`
+  bool warmup = true;
 
   bool instruct = false;        // instruction mode (used for Alpaca models)
   bool penalize_nl = true;      // consider newlines as a repeatable token
diff --git a/neural_speed/models/model_utils/model_files.h b/neural_speed/models/model_utils/model_files.h
index ff65ebaea..69fd73ffd 100644
--- a/neural_speed/models/model_utils/model_files.h
+++ b/neural_speed/models/model_utils/model_files.h
@@ -29,7 +29,7 @@
 #define NE_MEM_ALIGN 16
 #endif
 
-#include "core/layers/jblas_common.hpp"
+#include "core/layers/bestla_common.hpp"
 #include "core/ne_layers.h"
 #include "models/model_utils/util.h"
 #include "models/models.h"
@@ -103,7 +103,7 @@ struct model_load_tensor {
     calc_type();
     calc_split_type();
     calc_ne();
-    if (type == NE_TYPE_JBLAS) {
+    if (type == NE_TYPE_BTLA) {
       size = shards[0].size;
     } else {
       calc_size();
@@ -329,7 +329,7 @@ struct model_file_loader {
         case NE_TYPE_Q5_0:
         case NE_TYPE_Q5_1:
         case NE_TYPE_Q8_0:
-        case NE_TYPE_JBLAS:
+        case NE_TYPE_BTLA:
           break;
         default: {
           throw format("unrecognized tensor type %u\n", shard.type);
@@ -342,7 +342,7 @@ struct model_file_loader {
       }
       shard.file_idx = file_idx;
       shard.file_off = file.tell();
-      if (shard.type == NE_TYPE_JBLAS) {
+      if (shard.type == NE_TYPE_BTLA) {
         size_t size = 0;
         file.read_raw(&size, sizeof(size_t));
         shard.size = size;
@@ -429,7 +429,7 @@ struct model_file_saver {
       case NE_TYPE_Q5_0:
       case NE_TYPE_Q5_1:
       case NE_TYPE_Q8_0:
-      case NE_TYPE_JBLAS:
+      case NE_TYPE_BTLA:
         break;
       default:
         MODEL_ASSERT(false);
@@ -440,7 +440,7 @@ struct model_file_saver {
     file.write_raw(tensor.ne.data(), sizeof(tensor.ne[0]) * tensor.ne.size());
     file.write_raw(tensor.name.data(), tensor.name.size());
     file.seek(-static_cast<ptrdiff_t>(file.tell()) & 31, SEEK_CUR);
-    if (new_type != NE_TYPE_JBLAS) MODEL_ASSERT(new_size == model_calc_tensor_size(tensor.ne, new_type));
+    if (new_type != NE_TYPE_BTLA) MODEL_ASSERT(new_size == model_calc_tensor_size(tensor.ne, new_type));
     file.write_raw(new_data, new_size);
   }
 };
@@ -526,7 +526,7 @@ struct model_model_loader {
     size_t size_needed = 0;
     for (const model_load_tensor& lt : tensors_map.tensors) {
       *ctx_size_p += sizeof(struct ne_tensor) + NE_OBJECT_SIZE;
-      if (lt.type == NE_TYPE_JBLAS) {
+      if (lt.type == NE_TYPE_BTLA) {
         size_needed = lt.size;
       } else {
         size_needed = (lt.size + NE_MEM_ALIGN - 1) / NE_MEM_ALIGN * NE_MEM_ALIGN;
@@ -562,7 +562,7 @@ struct model_model_loader {
   struct ne_tensor* get_tensor_for(model_load_tensor& lt, ne_backend backend) {
     struct ne_tensor* tensor;
     if (lt.ne.size() == 2) {
-      if (lt.type == NE_TYPE_JBLAS) {
+      if (lt.type == NE_TYPE_BTLA) {
         tensor = ne_new_tensor_2d(ne_ctx, lt.type, lt.ne.at(0), lt.ne.at(1), lt.size);
       } else {
         tensor = ne_new_tensor_2d(ne_ctx, lt.type, lt.ne.at(0), lt.ne.at(1), NE_SIZE_CALC);
@@ -627,16 +627,16 @@ struct model_model_loader {
     }
   }
 
-  void jblas_split_weight(void** src, void** dst, size_t src_n, size_t src_k, size_t dst_n, size_t dst_k, size_t n_rank,
-                          size_t k_rank) {
+  void bestla_split_weight(void** src, void** dst, size_t src_n, size_t src_k, size_t dst_n, size_t dst_k,
+                           size_t n_rank, size_t k_rank) {
     auto src_fp32 = (float*)malloc(src_n * src_k * sizeof(float));
     if (src_fp32 == nullptr) {
       assert(0);
     }
-    jblas_unpackweight_fp32(*src, src_n, src_k, src_fp32, src_n);
+    bestla_unpackweight_fp32(*src, src_n, src_k, src_fp32, src_n);
     // layout will be K * N in the buffer
     auto dst_fp32 = src_fp32 + k_rank * dst_k * src_n + n_rank * dst_n;
-    jblas_packweight_copyattr(dst_fp32, *dst, dst_n, dst_k, src_n, *src);
+    bestla_packweight_copyattr(dst_fp32, *dst, dst_n, dst_k, src_n, *src);
     free(src_fp32);
   }
   void load_data_for(model_load_tensor& lt) {
@@ -685,13 +685,13 @@ struct model_model_loader {
       model_file& file = file_loaders.at(shard.file_idx)->file;
       file.seek(shard.file_off, SEEK_SET);
       size_t num_rows = lt.ne.size() == 1 ? 1 : lt.ne.at(1);
-      if (lt.type == NE_TYPE_JBLAS) {
+      if (lt.type == NE_TYPE_BTLA) {
         tmp_buf.resize(shard.size);
         file.read_raw(tmp_buf.addr, shard.size);
         void* dst_data = (void*)lt.data;
         void* src_data = (void*)(tmp_buf.addr);
-        jblas_split_weight(&src_data, &dst_data, lt.world_size * num_rows, lt.ne.at(0), num_rows, lt.ne.at(0), lt.rank,
-                           0);
+        bestla_split_weight(&src_data, &dst_data, lt.world_size * num_rows, lt.ne.at(0), num_rows, lt.ne.at(0), lt.rank,
+                            0);
       } else {
         // only copy part of weight form the tmp_buf of origin file
         tmp_buf.resize(lt.size * lt.world_size);
@@ -707,13 +707,13 @@ struct model_model_loader {
       model_file& file = file_loaders.at(shard.file_idx)->file;
       file.seek(shard.file_off, SEEK_SET);
       size_t num_rows = lt.ne.size() == 1 ? 1 : lt.ne.at(1);
-      if (lt.type == NE_TYPE_JBLAS) {
+      if (lt.type == NE_TYPE_BTLA) {
         tmp_buf.resize(shard.size);
         file.read_raw(tmp_buf.addr, shard.size);
         void* dst_data = (void*)lt.data;
         void* src_data = (void*)(tmp_buf.addr);
-        jblas_split_weight(&src_data, &dst_data, num_rows, lt.world_size * lt.ne.at(0), num_rows, lt.ne.at(0), 0,
-                           lt.rank);
+        bestla_split_weight(&src_data, &dst_data, num_rows, lt.world_size * lt.ne.at(0), num_rows, lt.ne.at(0), 0,
+                            lt.rank);
       } else {
         tmp_buf.resize(lt.size * lt.world_size);
         file.read_raw(tmp_buf.addr, lt.size * lt.world_size);
diff --git a/neural_speed/models/model_utils/model_types.h b/neural_speed/models/model_utils/model_types.h
index 0b5db5bae..7356bea6a 100644
--- a/neural_speed/models/model_utils/model_types.h
+++ b/neural_speed/models/model_utils/model_types.h
@@ -84,7 +84,7 @@ enum model_archs {
 static const size_t MB = 1024 * 1024;
 
 typedef enum KV_MEM_TYPE {  // Memory kv data type
-  KV_MEM_TYPE_AUTO,         // Try with jblas flash attn managed format; fall back to fp16 if failed
+  KV_MEM_TYPE_AUTO,         // Try with bestla flash attn managed format; fall back to fp16 if failed
   KV_MEM_TYPE_F16,          // Use F16 for memory kv
   KV_MEM_TYPE_F32,          // Use F32 for memory kv
 } KV_MEM_TYPE;
@@ -287,8 +287,8 @@ struct model_context {
   // next tokens (decoding) generation may be larger than `request_running_bs`(for example, beam search)
   int batch_size = 1;
   bool beam_search = false;
-  bool shift_roped_k = false;     // whether to store non-RoPEd K cache
-  bool support_jblas_kv = false;  // whether the model graph supports jblas-kvcache
+  bool shift_roped_k = false;      // whether to store non-RoPEd K cache
+  bool support_bestla_kv = false;  // whether the model graph supports bestla-kvcache
   int beam_size = 1;
   int kv_n_ctx_block = 1;
   generation_config generation_conf;
diff --git a/neural_speed/models/model_utils/model_utils.cpp b/neural_speed/models/model_utils/model_utils.cpp
index f8a287a7f..dbcb29b8c 100644
--- a/neural_speed/models/model_utils/model_utils.cpp
+++ b/neural_speed/models/model_utils/model_utils.cpp
@@ -41,11 +41,11 @@
 #include <unordered_map>
 
 #include "application/common.h"
-#include "core/layers/jblas_common.hpp"
+#include "core/layers/bestla_common.hpp"
 #include "core/layers/mha_dense.h"
 #include "core/ne_layers.h"
-#include "core/layers/jblas_gemm.h"
-#include "jblas/jit_blas_parallel.h"
+#include "core/layers/bestla_gemm.h"
+#include "bestla/bestla_parallel.h"
 
 #include "models/model_utils/model_config.h"
 #include "models/model_utils/model_files.h"
@@ -69,7 +69,7 @@ static bool kv_cache_init(const struct model_hparams& hparams, struct model_kv_c
 
   int64_t layer_ne_k = batch_size * beam_size * k_size;
   int64_t layer_ne_v = batch_size * beam_size * v_size;
-  const auto wsize = wtype == NE_TYPE_JBLAS ? 1 : ne_type_size(wtype);
+  const auto wsize = wtype == NE_TYPE_BTLA ? 1 : ne_type_size(wtype);
 #ifdef NE_TP_MODEL
   // when use TP, cached kv will also have smaller size
   parallel_context* p_ctx = init_parallel_context();
@@ -96,8 +96,8 @@ static bool kv_cache_init(const struct model_hparams& hparams, struct model_kv_c
     return false;
   }
 
-  // NE_TYPE_JBLAS can not be allocated memory
-  const auto wtype_alloc = wtype == NE_TYPE_JBLAS ? NE_TYPE_I8 : wtype;
+  // NE_TYPE_BTLA can not be allocated memory
+  const auto wtype_alloc = wtype == NE_TYPE_BTLA ? NE_TYPE_I8 : wtype;
 
   if (model) {  // non-null param of model for kv-cache as components of model->layers[il]
     for (int il = 0; il < hparams.n_layer; ++il) {
@@ -108,7 +108,7 @@ static bool kv_cache_init(const struct model_hparams& hparams, struct model_kv_c
         const int heads_kv = hparams.multi_query_group_num > 0 ? hparams.multi_query_group_num : hparams.n_head;
         k_cache = d_ne_new_tensor_4d(model->ctx, NE_TYPE_F16, head_size, n_ctx, heads_kv, batch_size * beam_size);
         v_cache = d_ne_new_tensor_4d(model->ctx, NE_TYPE_F16, n_ctx, head_size, heads_kv, batch_size * beam_size);
-      } else if (wtype == NE_TYPE_JBLAS) {
+      } else if (wtype == NE_TYPE_BTLA) {
         k_cache = ne_new_tensor_1d(model->ctx, wtype_alloc, layer_ne_k + NE_ALIGNMENT, NE_SIZE_CALC);
         const auto k_align_off = reinterpret_cast<uintptr_t>(k_cache->data) % NE_ALIGNMENT;
         k_cache = ne_view_1d(model->ctx, k_cache, layer_ne_k, NE_ALIGNMENT - k_align_off);
@@ -123,7 +123,7 @@ static bool kv_cache_init(const struct model_hparams& hparams, struct model_kv_c
       ne_set_name(k_cache, "cache_k");
       ne_set_name(v_cache, "cache_v");
     }
-    const bool run_mha_reordered = model->layers[0].k_cache->type == NE_TYPE_JBLAS;
+    const bool run_mha_reordered = model->layers[0].k_cache->type == NE_TYPE_BTLA;
     fprintf(stderr, "%s: run_mha_reordered = %d\n", __func__, run_mha_reordered);
   } else {
     cache.k = ne_new_tensor_1d(cache.ctx, wtype_alloc, n_layer * layer_ne_k + NE_ALIGNMENT, NE_SIZE_CALC);
@@ -139,7 +139,7 @@ static bool kv_cache_init(const struct model_hparams& hparams, struct model_kv_c
   }
 
   if (shift_roped_k) {  // prepare rope helper for fused-attention
-    const auto cossin_dtype = wtype == NE_TYPE_JBLAS ? NE_TYPE_F16 : wtype;
+    const auto cossin_dtype = wtype == NE_TYPE_BTLA ? NE_TYPE_F16 : wtype;
     cache.cossin = ne_new_tensor_1d(cache.ctx, cossin_dtype, head_size, NE_SIZE_CALC);
     ne_set_name(cache.cossin, "cossin(-1)");
     float theta = -1;
@@ -870,18 +870,22 @@ quant_params_internal quant_params_to_internal(const quant_params& params) {
                                parse_compute_type(params.compute_dtype, params.use_ggml)};
 }
 
-size_t jblas_qpack(const int8_t* src_w, const float* src_scales, const int8_t* src_zps, void* dstpr,
-                   const quant_params_internal params, int nthread, int n, int k, int* g_idx) {
+size_t bestla_qpack(const int8_t* src_w, const float* src_scales, const int8_t* src_zps, void* dstpr,
+                    const quant_params_internal params, int nthread, int n, int k, int* g_idx) {
   auto ctype = quant2ne_comp_type(params.compute_dtype);
   auto dstbptr = reinterpret_cast<int8_t*>(dstpr);
-  jblas::parallel::OMPThreading threading(nthread);
-  JBLAS_DTYPE quant_type = JBLAS_DTYPE::S4_CLIP;
+#ifdef __OPENMP
+  bestla::parallel::OMPThreading threading(nthread);
+#else
+  bestla::parallel::StdThreading threading(nthread);
+#endif
+  BTLA_DTYPE quant_type = BTLA_DTYPE::S4_CLIP;
   if (params.bits == quant_bits::q8) {
-    quant_type = JBLAS_DTYPE::S8;
+    quant_type = BTLA_DTYPE::S8;
   }
-  auto dtype_type = static_cast<JBLAS_DTYPE>(
-      jblas::utils::jblas_dtype_get_mask_val(quant_type, JBLAS_DTYPE::TypeMask, JBLAS_DTYPE::TypeShift));
-  if (dtype_type == JBLAS_DTYPE::TypeFloat) {
+  auto dtype_type = static_cast<BTLA_DTYPE>(
+      bestla::utils::bestla_dtype_get_mask_val(quant_type, BTLA_DTYPE::TypeMask, BTLA_DTYPE::TypeShift));
+  if (dtype_type == BTLA_DTYPE::TypeFloat) {
     printf("Not support float dtype in qpack\n");
     if (params.alg == quant_alg::asym) {
       printf("Invalid alg for float quant types, will be igonred\n");
@@ -890,18 +894,18 @@ size_t jblas_qpack(const int8_t* src_w, const float* src_scales, const int8_t* s
       printf("Compute Int8 is not supported by float quant types, will be igonred\n");
     }
   }
-  JBLAS_DTYPE scale_type = JBLAS_DTYPE::BF16;
+  BTLA_DTYPE scale_type = BTLA_DTYPE::BF16;
   if (params.scale_dtype == quant_sdtype::fp32) {
-    scale_type = JBLAS_DTYPE::F32;
+    scale_type = BTLA_DTYPE::F32;
   }
   if (params.scale_dtype == quant_sdtype::fp16) {
     printf("Current not support float16 scale, reset to bf16\n");
   }
   auto gsize = params.group_size == -1 ? k : params.group_size;
-  auto size = JblasGemmPackBSize(n, k, gsize, quant_type, scale_type, params.alg == quant_alg::asym, ctype, g_idx);
+  auto size = BTLAGemmPackBSize(n, k, gsize, quant_type, scale_type, params.alg == quant_alg::asym, ctype, g_idx);
   if (size) {
-    if (!JblasGemmPackB(dstpr, src_w, src_scales, src_zps, n, k, n, gsize, quant_type, scale_type,
-                        params.alg == quant_alg::asym, ctype, g_idx, &threading)) {
+    if (!BTLAGemmPackB(dstpr, src_w, src_scales, src_zps, n, k, n, gsize, quant_type, scale_type,
+                       params.alg == quant_alg::asym, ctype, g_idx, &threading)) {
       printf("Failed to quant this weight\n");
       return 0;
     }
@@ -911,30 +915,34 @@ size_t jblas_qpack(const int8_t* src_w, const float* src_scales, const int8_t* s
 }
 
 // dstptr: default maximum workspace = float array size
-size_t jblas_quantize(const float* f32ptr, void* dstpr, const quant_params_internal params, int nthread, size_t n,
-                      size_t k) {
+size_t bestla_quantize(const float* f32ptr, void* dstpr, const quant_params_internal params, int nthread, size_t n,
+                       size_t k) {
   auto ctype = quant2ne_comp_type(params.compute_dtype);
   auto dstbptr = reinterpret_cast<int8_t*>(dstpr);
-  jblas::parallel::OMPThreading threading(nthread);
-  JBLAS_DTYPE quant_type = JBLAS_DTYPE::S4_CLIP;
+#ifdef __OPENMP
+  bestla::parallel::OMPThreading threading(nthread);
+#else
+  bestla::parallel::StdThreading threading(nthread);
+#endif
+  BTLA_DTYPE quant_type = BTLA_DTYPE::S4_CLIP;
   if (params.bits == quant_bits::q8) {
-    quant_type = JBLAS_DTYPE::S8;
+    quant_type = BTLA_DTYPE::S8;
   }
   if (params.bits == quant_bits::fp4_e2m1) {
-    quant_type = JBLAS_DTYPE::F4_E2M1;
+    quant_type = BTLA_DTYPE::F4_E2M1;
   }
   if (params.bits == quant_bits::nf4) {
-    quant_type = JBLAS_DTYPE::F4_NF4;
+    quant_type = BTLA_DTYPE::F4_NF4;
   }
   if (params.bits == quant_bits::fp8_e4m3) {
-    quant_type = JBLAS_DTYPE::F8_E4M3;
+    quant_type = BTLA_DTYPE::F8_E4M3;
   }
   if (params.bits == quant_bits::fp8_e5m2) {
-    quant_type = JBLAS_DTYPE::F8_E5M2;
+    quant_type = BTLA_DTYPE::F8_E5M2;
   }
-  auto dtype_type = static_cast<JBLAS_DTYPE>(
-      jblas::utils::jblas_dtype_get_mask_val(quant_type, JBLAS_DTYPE::TypeMask, JBLAS_DTYPE::TypeShift));
-  if (dtype_type == JBLAS_DTYPE::TypeFloat) {
+  auto dtype_type = static_cast<BTLA_DTYPE>(
+      bestla::utils::bestla_dtype_get_mask_val(quant_type, BTLA_DTYPE::TypeMask, BTLA_DTYPE::TypeShift));
+  if (dtype_type == BTLA_DTYPE::TypeFloat) {
     if (params.alg == quant_alg::asym) {
       printf("Invalid alg for float quant types, will be igonred\n");
     }
@@ -942,25 +950,25 @@ size_t jblas_quantize(const float* f32ptr, void* dstpr, const quant_params_inter
       printf("Compute Int8 is not supported by float quant types, will be igonred\n");
     }
   }
-  JBLAS_DTYPE scale_type = JBLAS_DTYPE::BF16;
+  BTLA_DTYPE scale_type = BTLA_DTYPE::BF16;
   if (params.scale_dtype == quant_sdtype::fp32) {
-    scale_type = JBLAS_DTYPE::F32;
+    scale_type = BTLA_DTYPE::F32;
   }
   if (params.scale_dtype == quant_sdtype::fp16) {
     printf("Current not support float16 scale, reset to bf16\n");
   }
-  if (quant_type == JBLAS_DTYPE::F8_E4M3 || quant_type == JBLAS_DTYPE::F8_E5M2) {
+  if (quant_type == BTLA_DTYPE::F8_E4M3 || quant_type == BTLA_DTYPE::F8_E5M2) {
     if (params.scale_dtype != quant_sdtype::fp8 && params.scale_dtype != quant_sdtype::fp32) {
       printf("Warning: fp8 weight only supports fp8 / fp32 scale now! Fall back to fp8.\n");
     }
-    scale_type = JBLAS_DTYPE::F8_E8M0;
+    scale_type = BTLA_DTYPE::F8_E8M0;
   }
   auto gsize = params.group_size == -1 ? k : params.group_size;
-  auto size = JblasGemmPackBSize(n, k, gsize, quant_type, scale_type, params.alg == quant_alg::asym, ctype, nullptr);
+  auto size = BTLAGemmPackBSize(n, k, gsize, quant_type, scale_type, params.alg == quant_alg::asym, ctype, nullptr);
   bool constexpr IsTrans_TorchWeight = true;
   if (size) {
-    if (!JblasGemmQuantPackB(dstpr, f32ptr, n, k, k, gsize, quant_type, scale_type, params.alg == quant_alg::asym,
-                             ctype, IsTrans_TorchWeight, &threading)) {
+    if (!BTLAGemmQuantPackB(dstpr, f32ptr, n, k, k, gsize, quant_type, scale_type, params.alg == quant_alg::asym, ctype,
+                            IsTrans_TorchWeight, &threading)) {
       printf("Failed to quant this weight\n");
       return 0;
     }
@@ -1044,12 +1052,12 @@ void ne_common_quantize(const int nthread, const quant_params_internal& params,
   }
   printf("quantizing .. ");
   fflush(stdout);
-  if (new_type == NE_TYPE_JBLAS) {
+  if (new_type == NE_TYPE_BTLA) {
     size_t k_ = tensor.ne.at(0);
     size_t n_ = tensor.ne.at(1);
     printf("JBLAS ");
-    new_size = jblas_quantize(f32_data, work.addr, params, nthread, n_, k_);
-  } else if (new_type >= NE_TYPE_Q4_0 && new_type < NE_TYPE_JBLAS) {
+    new_size = bestla_quantize(f32_data, work.addr, params, nthread, n_, k_);
+  } else if (new_type >= NE_TYPE_Q4_0 && new_type < NE_TYPE_BTLA) {
     printf("GGML ");
     new_size = ggml_quantize(f32_data, work.addr, new_type, nthread, nelements);
   }
@@ -1173,13 +1181,13 @@ struct model_context* model_init_from_file(const char* path_model, struct model_
         /* .sl_q = */ 1,  // for next-token inference
         /* .sl_kv = */ static_cast<int>(ctx->n_ctx),
     };
-    const bool support_jblas_kv = ctx->support_jblas_kv && jblas_reordered_attn_fp32_support(&attn_shape);
-    fprintf(stderr, "%s: support_jblas_kv = %d\n", __func__, support_jblas_kv);
+    const bool support_bestla_kv = ctx->support_bestla_kv && bestla_reordered_attn_fp32_support(&attn_shape);
+    fprintf(stderr, "%s: support_bestla_kv = %d\n", __func__, support_bestla_kv);
 
     const ne_type memory_type = params.kv_type == KV_MEM_TYPE_F16   ? NE_TYPE_F16
                                 : params.kv_type == KV_MEM_TYPE_F32 ? NE_TYPE_F32
                                 : params.kv_type == KV_MEM_TYPE_AUTO
-                                    ? (support_jblas_kv ? NE_TYPE_JBLAS : NE_TYPE_F16)  // fall back to fp16
+                                    ? (support_bestla_kv ? NE_TYPE_BTLA : NE_TYPE_F16)  // fall back to fp16
                                     : NE_TYPE_COUNT;
     NE_ASSERT(memory_type != NE_TYPE_COUNT);
 
@@ -1537,12 +1545,12 @@ struct model_context* model_init_from_gpt_params(const gpt_params& params) {
       /* .head_num = */ static_cast<int>(model_hparams.n_head),
       /* .heads_kv = */ static_cast<int>(model_hparams.n_head_kv + model_hparams.multi_query_group_num),
       /* .head_size = */ static_cast<int>(model_hparams.n_embd / model_hparams.n_head),
-      /* .sl_q = */ 1,  // Note: make sure that jblas reordered attn supports next token inferencing
+      /* .sl_q = */ 1,  // Note: make sure that bestla reordered attn supports next token inferencing
       /* .sl_kv = */ static_cast<int>(lparams.n_ctx),
   };
   const auto k_cache_example = lctx->model.kv_self.k != nullptr ? lctx->model.kv_self.k           // llama.cpp style
                                                                 : lctx->model.layers[0].k_cache;  // chatglm style
-  NE_ASSERT(k_cache_example->type != NE_TYPE_JBLAS || jblas_reordered_attn_fp32_support(&attn_shape));
+  NE_ASSERT(k_cache_example->type != NE_TYPE_BTLA || bestla_reordered_attn_fp32_support(&attn_shape));
 
   if (lctx == NULL) {
     fprintf(stderr, "%s: error: failed to load model '%s'\n", __func__, params.model.c_str());
@@ -1566,14 +1574,14 @@ void get_batch_kv_elements_from_gpt_params(int heads_kv, int head_size, int n_ct
   if (wtype == NE_TYPE_F16 || wtype == NE_TYPE_F32) {
     *k_size = n_ctx * heads_kv * head_size;
     *v_size = n_ctx * heads_kv * head_size;
-  } else if (wtype == NE_TYPE_JBLAS) {
+  } else if (wtype == NE_TYPE_BTLA) {
     kv_shape_t kv_shape = {
         /* .heads_kv = */ static_cast<uint32_t>(heads_kv),
         /* .head_size = */ static_cast<uint32_t>(head_size),
         /* .sl_kv_max = */ static_cast<uint32_t>(n_ctx),
     };
     kv_cache_info_t kv_cache_info;
-    jblas_reordered_attn_fp32_batch_kv_info(&kv_shape, &kv_cache_info);
+    bestla_reordered_attn_fp32_batch_kv_info(&kv_shape, &kv_cache_info);
     *k_size = kv_cache_info.k_bytes;
     *v_size = kv_cache_info.v_bytes;
   } else {
@@ -1987,6 +1995,8 @@ void model_print_timings(struct model_context* ctx) {
 
 void model_reset_timings(struct model_context* ctx) {
   ctx->t_start_us = ne_time_us();
+  ctx->has_evaluated_once = false;
+  ctx->eval_times.clear();
   ctx->t_sample_us = ctx->n_sample = 0;
   ctx->t_eval_us = ctx->n_eval = 0;
   ctx->t_p_eval_us = ctx->n_p_eval = 0;
@@ -2050,8 +2060,8 @@ static void ne_model_kv_cache_seq_cpy(struct model_context* ctx, const model_seq
   }
 }
 
-static void jblas_model_kv_cache_seq_cpy(struct model_context* ctx, const model_seq_id& seq_id_src,
-                                         const model_seq_id& seq_id_dst, const model_pos& p0, const model_pos& p1) {
+static void bestla_model_kv_cache_seq_cpy(struct model_context* ctx, const model_seq_id& seq_id_src,
+                                          const model_seq_id& seq_id_dst, const model_pos& p0, const model_pos& p1) {
   const auto& kv_self = ctx->model.kv_self;
   const auto& hparams = ctx->model.hparams;
   const int heads_kv = hparams.multi_query_group_num > 0 ? hparams.multi_query_group_num : hparams.n_head;
@@ -2065,11 +2075,11 @@ static void jblas_model_kv_cache_seq_cpy(struct model_context* ctx, const model_
       /* .head_size = */ static_cast<uint32_t>(head_size),
       /* .sl_kv_max = */ static_cast<uint32_t>(n_ctx),
   };
-  jblas_reordered_attn_fp32_batch_kv_info(&kv_shape, &kv_cache_info);
+  bestla_reordered_attn_fp32_batch_kv_info(&kv_shape, &kv_cache_info);
   const auto k_bytes = kv_cache_info.k_bytes;
   const auto v_bytes = kv_cache_info.v_bytes;
 
-  jblas_fusion_attn_fp32_batch_cpy_kv_args_t seq_cpy_param{
+  bestla_fusion_attn_fp32_batch_cpy_kv_args_t seq_cpy_param{
       /* .src = */ nullptr,
       /* .dst = */ nullptr,
       /* .heads_kv = */ heads_kv,
@@ -2083,21 +2093,21 @@ static void jblas_model_kv_cache_seq_cpy(struct model_context* ctx, const model_
     const auto k_data = reinterpret_cast<char*>(kv_self.k->data) + il * kv_n_ctx_block * k_bytes;
     seq_cpy_param.src = k_data + seq_id_src * k_bytes;
     seq_cpy_param.dst = k_data + seq_id_dst * k_bytes;
-    jblas_fusion_attn_fp32_batch_cpy_k(&seq_cpy_param);
+    bestla_fusion_attn_fp32_batch_cpy_k(&seq_cpy_param);
 
     const auto v_data = reinterpret_cast<char*>(kv_self.v->data) + il * kv_n_ctx_block * v_bytes;
     seq_cpy_param.src = v_data + seq_id_src * v_bytes;
     seq_cpy_param.dst = v_data + seq_id_dst * v_bytes;
-    jblas_fusion_attn_fp32_batch_cpy_v(&seq_cpy_param);
+    bestla_fusion_attn_fp32_batch_cpy_v(&seq_cpy_param);
   }
 }
 
 void model_kv_cache_seq_cpy(struct model_context* ctx, const model_seq_id& seq_id_src, const model_seq_id& seq_id_dst,
                             const model_pos& p0, const model_pos& p1) {
-  if (ctx->model.kv_self.k->type != NE_TYPE_JBLAS)
+  if (ctx->model.kv_self.k->type != NE_TYPE_BTLA)
     ne_model_kv_cache_seq_cpy(ctx, seq_id_src, seq_id_dst, p0, p1);
   else
-    jblas_model_kv_cache_seq_cpy(ctx, seq_id_src, seq_id_dst, p0, p1);
+    bestla_model_kv_cache_seq_cpy(ctx, seq_id_src, seq_id_dst, p0, p1);
 }
 
 static ne_tensor* ne_model_kv_cache_seq_concat(struct ne_cgraph* cgraph, struct model_context* moctx,
@@ -2164,10 +2174,10 @@ static ne_tensor* ne_model_kv_cache_seq_concat(struct ne_cgraph* cgraph, struct
 ne_tensor* model_kv_cache_seq_concat(struct ne_cgraph* cgraph, struct model_context* moctx, struct ne_context* nectx,
                                      const int64_t& ne0, const int64_t& ne1, const int64_t& ne2, const int64_t& ne3,
                                      const std::vector<int>& block_ids, const int& layer_idx, const bool& concat_k) {
-  if (moctx->model.kv_self.k->type != NE_TYPE_JBLAS) {
+  if (moctx->model.kv_self.k->type != NE_TYPE_BTLA) {
     return ne_model_kv_cache_seq_concat(cgraph, moctx, nectx, ne0, ne1, ne2, ne3, block_ids, layer_idx, concat_k);
   } else {
-    return nullptr;  // jblas
+    return nullptr;  // bestla
   }
 }
 
diff --git a/neural_speed/models/model_utils/model_utils.h b/neural_speed/models/model_utils/model_utils.h
index ff19090e1..1873c3893 100644
--- a/neural_speed/models/model_utils/model_utils.h
+++ b/neural_speed/models/model_utils/model_utils.h
@@ -83,10 +83,10 @@ MODEL_API void model_free(struct model_context* ctx);
 // param - from args
 // quant_layer - depends on each model's config
 MODEL_API int model_quantize(const quant_params& param, std::shared_ptr<quant_layer_base> quant_layer);
-size_t jblas_qpack(const int8_t* src_w, const float* src_scales, const int8_t* src_zps, void* dstpr,
-                   const quant_params_internal params, int nthread, int n, int k, int* g_idx);
-size_t jblas_quantize(const float* f32ptr, void* dstpr, const quant_params_internal params, int nthread, size_t n,
-                      size_t k);
+size_t bestla_qpack(const int8_t* src_w, const float* src_scales, const int8_t* src_zps, void* dstpr,
+                    const quant_params_internal params, int nthread, int n, int k, int* g_idx);
+size_t bestla_quantize(const float* f32ptr, void* dstpr, const quant_params_internal params, int nthread, size_t n,
+                       size_t k);
 // Apply a LoRA adapter to a loaded model
 // path_base_model is the path to a higher quality model to use as a base for
 // the layers modified by the adapter. Can be NULL to use the current loaded
diff --git a/neural_speed/models/model_utils/quant_config.h b/neural_speed/models/model_utils/quant_config.h
index ec4d86214..f470c7598 100644
--- a/neural_speed/models/model_utils/quant_config.h
+++ b/neural_speed/models/model_utils/quant_config.h
@@ -16,7 +16,7 @@
 #include <string>
 #include <memory>
 #include "core/data_types.h"
-#include "jblas/jit_blas.h"
+#include "bestla/bestla.h"
 
 enum class quant_bits : int { q4 = 0, q8, fp4_e2m1, nf4, fp8_e4m3, fp8_e5m2, count };
 static inline quant_bits parse_bits(const std::string& bits) {
@@ -83,10 +83,10 @@ static inline quant_sdtype parse_scale_dtype(std::string arg) {
 
 enum class quant_comp : int {
   ggml = 0,  // native
-  int8,      // jblas int8
-  fp32,      // jblas fp32
-  bf16,      // jblas bf16
-  fp16,      // jblas fp16
+  int8,      // bestla int8
+  fp32,      // bestla fp32
+  bf16,      // bestla bf16
+  fp16,      // bestla fp16
   count,
 };
 static inline quant_comp parse_compute_type(std::string arg, bool ggml_arg) {
@@ -154,7 +154,7 @@ static inline ne_type quant_params_to_type(const quant_params_internal& params)
       }
     }
   } else {
-    return NE_TYPE_JBLAS;
+    return NE_TYPE_BTLA;
   }
   return NE_TYPE_F32;
 }
diff --git a/neural_speed/models/model_utils/util.h b/neural_speed/models/model_utils/util.h
index 1431ffb5f..11b06c7f8 100644
--- a/neural_speed/models/model_utils/util.h
+++ b/neural_speed/models/model_utils/util.h
@@ -30,7 +30,7 @@
 #include <thread>
 #include <unordered_set>
 #include <vector>
-#include "jblas/jit_blas_utils.h"  // borrow aligned_malloc
+#include "bestla/bestla_utils.h"  // borrow aligned_malloc
 
 #ifdef __has_include
 #if __has_include(<unistd.h>)
@@ -407,12 +407,12 @@ struct model_buffer {
   model_buffer() = default;
 
   void resize(size_t len) {
-    jblas::utils::afree(addr);
-    addr = jblas::utils::amalloc<uint8_t>(len);
+    bestla::utils::afree(addr);
+    addr = bestla::utils::amalloc<uint8_t>(len);
     size = len;
   }
 
-  ~model_buffer() { jblas::utils::afree(addr); }
+  ~model_buffer() { bestla::utils::afree(addr); }
 
   // disable copy and move
   model_buffer(const model_buffer&) = delete;
diff --git a/neural_speed/models/mpt/CMakeLists.txt b/neural_speed/models/mpt/CMakeLists.txt
index c6570bed9..d0b1d2626 100644
--- a/neural_speed/models/mpt/CMakeLists.txt
+++ b/neural_speed/models/mpt/CMakeLists.txt
@@ -16,4 +16,4 @@ set(TARGET mpt)
 add_library_w_warning(${TARGET} mpt.cpp mpt_utils.cpp ${MODEL_UTILS_SOURCE})
 target_compile_features(${TARGET} PUBLIC cxx_std_11) # don't bump
 set_target_properties(${TARGET} PROPERTIES POSITION_INDEPENDENT_CODE ON)
-target_link_libraries(${TARGET} PUBLIC ne_layers jblas::jblas)
+target_link_libraries(${TARGET} PUBLIC ne_layers bestla::bestla)
diff --git a/neural_speed/models/mpt/mpt.cpp b/neural_speed/models/mpt/mpt.cpp
index f64cd3fa4..fcff0cae6 100644
--- a/neural_speed/models/mpt/mpt.cpp
+++ b/neural_speed/models/mpt/mpt.cpp
@@ -31,7 +31,7 @@
 #include "core/data_types.h"
 #include "core/ne.h"
 #include "core/ne_layers.h"
-#include "core/ne_jblas.h"
+#include "core/ne_bestla.h"
 #include "core/layers/mha_dense.h"
 #include "models/model_utils/model_config.h"
 #include "models/model_utils/model_utils.h"
@@ -90,27 +90,27 @@ static bool mpt_model_eval_internal(model_context* ctx, const model_input* input
   ne_cgraph gf = {};
   gf.n_threads = N >= 32 && ne_cpu_has_blas() ? 1 : n_threads;
 
-  const bool run_mha_reordered = kv_self.k->type == NE_TYPE_JBLAS;
+  const bool run_mha_reordered = kv_self.k->type == NE_TYPE_BTLA;
   kv_cache_info_t kv_cache_info = {};
   if (run_mha_reordered) {
-    NE_ASSERT(("kv cache should be the same dtype", kv_self.v->type == NE_TYPE_JBLAS));
+    NE_ASSERT(("kv cache should be the same dtype", kv_self.v->type == NE_TYPE_BTLA));
     attn_shape_t attn_shape = {
         /* .batch_size = */ 1,
         /* .head_num = */ n_head,
         /* .heads_kv = */ n_head,
         /* .head_size = */ head_dim,
-        /* .sl_q = */ N,  // Note: make sure that jblas reordered attn supports next token inference
+        /* .sl_q = */ N,  // Note: make sure that bestla reordered attn supports next token inference
         /* .sl_kv = */ n_past + N,
     };
 
-    NE_ASSERT(("jblas managed kv-cache not supported; use `--memory-f16 / --memory-f32` instead",
-               jblas_reordered_attn_fp32_support(&attn_shape)));
+    NE_ASSERT(("bestla managed kv-cache not supported; use `--memory-f16 / --memory-f32` instead",
+               bestla_reordered_attn_fp32_support(&attn_shape)));
     kv_shape_t kv_shape{
         /* .heads_kv = */ static_cast<uint32_t>(n_head),
         /* .head_size = */ static_cast<uint32_t>(head_dim),
         /* .sl_kv_max = */ static_cast<uint32_t>(n_ctx),
     };
-    jblas_reordered_attn_fp32_batch_kv_info(&kv_shape, &kv_cache_info);
+    bestla_reordered_attn_fp32_batch_kv_info(&kv_shape, &kv_cache_info);
   }
 
   struct ne_tensor* embd = d_ne_new_tensor_1d(ctx0, NE_TYPE_I32, N);
@@ -210,13 +210,13 @@ static bool mpt_model_eval_internal(model_context* ctx, const model_input* input
       {
         const auto k_cache = ne_view_3d(ctx0, kv_self.k,          // tensor
                                         head_dim, n_ctx, n_head,  // ne
-                                        0, 0,                     // nb (jblas managed)
+                                        0, 0,                     // nb (bestla managed)
                                         il * k_size);             // offset
         Kcur = ne_view_3d(ctx0, Kcur, head_dim, n_head, N, Kcur->nb[0] * head_dim, Kcur->nb[1], 0);
         ne_build_forward_expand(&gf, ne_flash_attn_update_k(ctx0, k_cache, Kcur, n_past, false));
         const auto v_cache = ne_view_3d(ctx0, kv_self.v,          // tensor
                                         head_dim, n_ctx, n_head,  // ne
-                                        0, 0,                     // nb (jblas managed)
+                                        0, 0,                     // nb (bestla managed)
                                         il * v_size);             // offset
         Vcur = ne_view_3d(ctx0, Vcur, head_dim, n_head, N, Vcur->nb[0] * head_dim, Vcur->nb[1], 0);
         ne_build_forward_expand(&gf, ne_flash_attn_update_v(ctx0, v_cache, Vcur, n_past, false));
@@ -228,14 +228,14 @@ static bool mpt_model_eval_internal(model_context* ctx, const model_input* input
       struct ne_tensor* K =
           ne_view_3d(ctx0, kv_self.k,                                             // tensor
                      head_dim, seq_kv, n_head,                                    // ne
-                     kv_cache_info.stride_k_sl, kv_cache_info.stride_k_head_num,  // nb (jblas managed)
+                     kv_cache_info.stride_k_sl, kv_cache_info.stride_k_head_num,  // nb (bestla managed)
                      il * k_size);                                                // offset
       *reinterpret_cast<ATTN_FWD_LAYOUT*>(&K->nb[0]) = kv_cache_info.k_layout;    // us nb0 for layout
       ne_set_name(K, "K");
       struct ne_tensor* V =
           ne_view_3d(ctx0, kv_self.v,                                                    // tensor
                      seq_kv, head_dim, n_head,                                           // ne
-                     kv_cache_info.stride_v_head_size, kv_cache_info.stride_v_head_num,  // nb (jblas managed)
+                     kv_cache_info.stride_v_head_size, kv_cache_info.stride_v_head_num,  // nb (bestla managed)
                      il * v_size);                                                       // offset
       *reinterpret_cast<ATTN_FWD_LAYOUT*>(&V->nb[0]) = kv_cache_info.v_layout;           // us nb0 for layout
       ne_set_name(V, "V");
@@ -262,9 +262,9 @@ static bool mpt_model_eval_internal(model_context* ctx, const model_input* input
     // n = self.mlp(m)
     {
       // FFN FUSION
-      if (jblas_fusion_FFN_GeLu_f32f32_support(model.layers[il].ffn[0]->data, model.layers[il].ffn[1]->data,
-                                               N * batch_size, cur->ne[0], model.layers[il].ffn[0]->ne[1],
-                                               model.layers[il].ffn[1]->ne[1])) {
+      if (bestla_fusion_FFN_GeLu_f32f32_support(model.layers[il].ffn[0]->data, model.layers[il].ffn[1]->data,
+                                                N * batch_size, cur->ne[0], model.layers[il].ffn[0]->ne[1],
+                                                model.layers[il].ffn[1]->ne[1])) {
         cur = ne_ffn_gelu(ctx0, model.layers[il].ffn[0], model.layers[il].ffn[1], cur);
       } else {
         cur = ne_mul_mat(ctx0, model.layers[il].ffn[0], cur);
diff --git a/neural_speed/models/mpt/mpt_utils.cpp b/neural_speed/models/mpt/mpt_utils.cpp
index 839bff3f0..1e94bc9e5 100644
--- a/neural_speed/models/mpt/mpt_utils.cpp
+++ b/neural_speed/models/mpt/mpt_utils.cpp
@@ -47,7 +47,7 @@ void model_load_internal(const std::string& fname, model_archs arch, model_conte
   ms->load(ctx, progress_callback, progress_callback_user_data);
 
   model_context& lctx = *ctx;
-  lctx.support_jblas_kv = true;
+  lctx.support_bestla_kv = true;
 }
 
 void MPT::init(const char* path_model, model_context* ctx, int n_gpu_layer_, bool use_mmap_, bool use_mlock_,
diff --git a/neural_speed/models/opt/CMakeLists.txt b/neural_speed/models/opt/CMakeLists.txt
index d91a36853..387e5834a 100644
--- a/neural_speed/models/opt/CMakeLists.txt
+++ b/neural_speed/models/opt/CMakeLists.txt
@@ -16,4 +16,4 @@ set(TARGET opt)
 add_library_w_warning(${TARGET} opt.cpp opt_utils.cpp ${MODEL_UTILS_SOURCE})
 target_compile_features(${TARGET} PUBLIC cxx_std_11) # don't bump
 set_target_properties(${TARGET} PROPERTIES POSITION_INDEPENDENT_CODE ON)
-target_link_libraries(${TARGET} PUBLIC ne_layers jblas::jblas)
+target_link_libraries(${TARGET} PUBLIC ne_layers bestla::bestla)
diff --git a/neural_speed/models/qwen/CMakeLists.txt b/neural_speed/models/qwen/CMakeLists.txt
index 384026cd0..da6b43f2c 100644
--- a/neural_speed/models/qwen/CMakeLists.txt
+++ b/neural_speed/models/qwen/CMakeLists.txt
@@ -16,4 +16,4 @@ set(TARGET qwen)
 add_library_w_warning(${TARGET} qwen.cpp qwen_utils.cpp ${MODEL_UTILS_SOURCE})
 target_compile_features(${TARGET} PUBLIC cxx_std_11) # don't bump
 set_target_properties(${TARGET} PROPERTIES POSITION_INDEPENDENT_CODE ON)
-target_link_libraries(${TARGET} PUBLIC ne_layers jblas::jblas)
+target_link_libraries(${TARGET} PUBLIC ne_layers bestla::bestla)
diff --git a/neural_speed/models/qwen/qwen.cpp b/neural_speed/models/qwen/qwen.cpp
index d55d183a2..ea98e0785 100644
--- a/neural_speed/models/qwen/qwen.cpp
+++ b/neural_speed/models/qwen/qwen.cpp
@@ -31,7 +31,7 @@
 #include "core/data_types.h"
 #include "core/ne.h"
 #include "core/ne_layers.h"
-#include "core/ne_jblas.h"
+#include "core/ne_bestla.h"
 #include "core/layers/mha_dense.h"
 #include "models/model_utils/model_config.h"
 #include "models/model_utils/model_utils.h"
@@ -41,8 +41,8 @@
 struct ne_tensor* qwen_ff(const model_layer& layer, const int batch_size, const int N, ne_context* ctx0,
                           ne_tensor* inp) {
   struct ne_tensor* cur = inp;
-  if (jblas_fusion_FFN_SiLu_f32f32_support(layer.ffn[1]->data, layer.ffn[2]->data, layer.ffn[0]->data, N, cur->ne[0],
-                                           layer.ffn[1]->ne[1], layer.ffn[2]->ne[1])) {
+  if (bestla_fusion_FFN_SiLu_f32f32_support(layer.ffn[1]->data, layer.ffn[2]->data, layer.ffn[0]->data, N, cur->ne[0],
+                                            layer.ffn[1]->ne[1], layer.ffn[2]->ne[1])) {
     cur = ne_ffn_silu(ctx0, layer.ffn[1], layer.ffn[2], layer.ffn[0], cur);
   } else {
     struct ne_tensor* cur_1 = ne_mul_mat(ctx0, layer.ffn[0], cur);
@@ -119,27 +119,27 @@ static bool qwen_model_eval_internal(model_context* ctx, const model_input* inpu
   ne_cgraph gf = {};
   gf.n_threads = N >= 32 && ne_cpu_has_blas() ? 1 : n_threads;
 
-  const bool run_mha_reordered = kv_self.k->type == NE_TYPE_JBLAS;
+  const bool run_mha_reordered = kv_self.k->type == NE_TYPE_BTLA;
   kv_cache_info_t kv_cache_info = {};
   if (run_mha_reordered) {
-    NE_ASSERT(("kv cache should be the same dtype", kv_self.v->type == NE_TYPE_JBLAS));
+    NE_ASSERT(("kv cache should be the same dtype", kv_self.v->type == NE_TYPE_BTLA));
     attn_shape_t attn_shape = {
         /* .batch_size = */ 1,
         /* .head_num = */ n_head,
         /* .heads_kv = */ n_head,
         /* .head_size = */ head_dim,
-        /* .sl_q = */ N,  // Note: make sure that jblas reordered attn supports next token inference
+        /* .sl_q = */ N,  // Note: make sure that bestla reordered attn supports next token inference
         /* .sl_kv = */ n_past + N,
     };
 
-    NE_ASSERT(("jblas managed kv-cache not supported; use `--memory-f16 / --memory-f32` instead",
-               jblas_reordered_attn_fp32_support(&attn_shape)));
+    NE_ASSERT(("bestla managed kv-cache not supported; use `--memory-f16 / --memory-f32` instead",
+               bestla_reordered_attn_fp32_support(&attn_shape)));
     kv_shape_t kv_shape{
         /* .heads_kv = */ static_cast<uint32_t>(n_head),
         /* .head_size = */ static_cast<uint32_t>(head_dim),
         /* .sl_kv_max = */ static_cast<uint32_t>(n_ctx),
     };
-    jblas_reordered_attn_fp32_batch_kv_info(&kv_shape, &kv_cache_info);
+    bestla_reordered_attn_fp32_batch_kv_info(&kv_shape, &kv_cache_info);
   }
   struct ne_tensor* embd = d_ne_new_tensor_1d(ctx0, NE_TYPE_I32, N * batch_size);
   ne_set_name(embd, "embd");
@@ -266,12 +266,12 @@ static bool qwen_model_eval_internal(model_context* ctx, const model_input* inpu
         {
           const auto k_cache = ne_view_3d(ctx0, kv_self.k,          // tensor
                                           head_dim, n_ctx, n_head,  // ne
-                                          0, 0,                     // nb (jblas managed)
+                                          0, 0,                     // nb (bestla managed)
                                           il * k_size);             // offset
           ne_build_forward_expand(&gf, ne_flash_attn_update_k(ctx0, k_cache, Kcur, n_past, false));
           const auto v_cache = ne_view_3d(ctx0, kv_self.v,          // tensor
                                           head_dim, n_ctx, n_head,  // ne
-                                          0, 0,                     // nb (jblas managed)
+                                          0, 0,                     // nb (bestla managed)
                                           il * v_size);             // offset
           ne_build_forward_expand(&gf, ne_flash_attn_update_v(ctx0, v_cache, Vcur, n_past, false));
         }
@@ -282,14 +282,14 @@ static bool qwen_model_eval_internal(model_context* ctx, const model_input* inpu
         struct ne_tensor* K =
             ne_view_3d(ctx0, kv_self.k,                                             // tensor
                        head_dim, seq_kv, n_head,                                    // ne
-                       kv_cache_info.stride_k_sl, kv_cache_info.stride_k_head_num,  // nb (jblas managed)
+                       kv_cache_info.stride_k_sl, kv_cache_info.stride_k_head_num,  // nb (bestla managed)
                        il * k_size);                                                // offset
         *reinterpret_cast<ATTN_FWD_LAYOUT*>(&K->nb[0]) = kv_cache_info.k_layout;    // us nb0 for layout
         ne_set_name(K, "K");
         struct ne_tensor* V =
             ne_view_3d(ctx0, kv_self.v,                                                    // tensor
                        seq_kv, head_dim, n_head,                                           // ne
-                       kv_cache_info.stride_v_head_size, kv_cache_info.stride_v_head_num,  // nb (jblas managed)
+                       kv_cache_info.stride_v_head_size, kv_cache_info.stride_v_head_num,  // nb (bestla managed)
                        il * v_size);                                                       // offset
         *reinterpret_cast<ATTN_FWD_LAYOUT*>(&V->nb[0]) = kv_cache_info.v_layout;           // us nb0 for layout
         ne_set_name(V, "V");
diff --git a/neural_speed/models/qwen/qwen_utils.cpp b/neural_speed/models/qwen/qwen_utils.cpp
index 67aaa074a..0df90ea5f 100644
--- a/neural_speed/models/qwen/qwen_utils.cpp
+++ b/neural_speed/models/qwen/qwen_utils.cpp
@@ -175,5 +175,5 @@ void model_load_internal(const std::string& fname, model_archs arch, model_conte
   ms->init(fname.c_str(), ctx, n_gpu_layers, use_mmap, use_mlock, vocab_only);
   ms->load(ctx, progress_callback, progress_callback_user_data);
   model_context& lctx = *ctx;
-  lctx.support_jblas_kv = true;
+  lctx.support_bestla_kv = true;
 }
diff --git a/neural_speed/models/starcoder/CMakeLists.txt b/neural_speed/models/starcoder/CMakeLists.txt
index 613fc69c2..d55e0ca55 100644
--- a/neural_speed/models/starcoder/CMakeLists.txt
+++ b/neural_speed/models/starcoder/CMakeLists.txt
@@ -16,4 +16,4 @@ set(TARGET starcoder)
 add_library_w_warning(${TARGET} starcoder.cpp starcoder_utils.cpp ${MODEL_UTILS_SOURCE})
 target_compile_features(${TARGET} PUBLIC cxx_std_11) # don't bump
 set_target_properties(${TARGET} PROPERTIES POSITION_INDEPENDENT_CODE ON)
-target_link_libraries(${TARGET} PUBLIC ne_layers jblas::jblas)
+target_link_libraries(${TARGET} PUBLIC ne_layers bestla::bestla)
diff --git a/neural_speed/models/starcoder/starcoder.cpp b/neural_speed/models/starcoder/starcoder.cpp
index 6753767ca..6c8c34353 100644
--- a/neural_speed/models/starcoder/starcoder.cpp
+++ b/neural_speed/models/starcoder/starcoder.cpp
@@ -31,7 +31,7 @@
 #include "core/data_types.h"
 #include "core/ne.h"
 #include "core/ne_layers.h"
-#include "core/ne_jblas.h"
+#include "core/ne_bestla.h"
 #include "core/layers/mha_dense.h"
 #include "models/model_utils/model_config.h"
 #include "models/model_utils/model_utils.h"
@@ -92,27 +92,27 @@ static bool starcoder_model_eval_internal(model_context* ctx, const model_input*
   ne_cgraph gf = {};
   gf.n_threads = N >= 32 && ne_cpu_has_blas() ? 1 : n_threads;
 
-  const bool run_mha_reordered = kv_self.k->type == NE_TYPE_JBLAS;
+  const bool run_mha_reordered = kv_self.k->type == NE_TYPE_BTLA;
   kv_cache_info_t kv_cache_info = {};
   if (run_mha_reordered) {
-    NE_ASSERT(("kv cache should be the same dtype", kv_self.v->type == NE_TYPE_JBLAS));
+    NE_ASSERT(("kv cache should be the same dtype", kv_self.v->type == NE_TYPE_BTLA));
     attn_shape_t attn_shape = {
         /* .batch_size = */ 1,
         /* .head_num = */ n_head,
         /* .heads_kv = */ n_head,
         /* .head_size = */ head_dim,
-        /* .sl_q = */ N,  // Note: make sure that jblas reordered attn supports next token inference
+        /* .sl_q = */ N,  // Note: make sure that bestla reordered attn supports next token inference
         /* .sl_kv = */ n_past + N,
     };
 
-    NE_ASSERT(("jblas managed kv-cache not supported; use `--memory-f16 / --memory-f32` instead",
-               jblas_reordered_attn_fp32_support(&attn_shape)));
+    NE_ASSERT(("bestla managed kv-cache not supported; use `--memory-f16 / --memory-f32` instead",
+               bestla_reordered_attn_fp32_support(&attn_shape)));
     kv_shape_t kv_shape{
         /* .heads_kv = */ static_cast<uint32_t>(n_head),
         /* .head_size = */ static_cast<uint32_t>(head_dim),
         /* .sl_kv_max = */ static_cast<uint32_t>(n_ctx),
     };
-    jblas_reordered_attn_fp32_batch_kv_info(&kv_shape, &kv_cache_info);
+    bestla_reordered_attn_fp32_batch_kv_info(&kv_shape, &kv_cache_info);
   }
 
   struct ne_tensor* embd = d_ne_new_tensor_1d(ctx0, NE_TYPE_I32, N);
@@ -257,12 +257,12 @@ static bool starcoder_model_eval_internal(model_context* ctx, const model_input*
         {
           const auto k_cache = ne_view_3d(ctx0, kv_self.k,          // tensor
                                           head_dim, n_ctx, n_head,  // ne
-                                          0, 0,                     // nb (jblas managed)
+                                          0, 0,                     // nb (bestla managed)
                                           il * k_size);             // offset
           ne_build_forward_expand(&gf, ne_flash_attn_update_k(ctx0, k_cache, Kcur, n_past, false));
           const auto v_cache = ne_view_3d(ctx0, kv_self.v,          // tensor
                                           head_dim, n_ctx, n_head,  // ne
-                                          0, 0,                     // nb (jblas managed)
+                                          0, 0,                     // nb (bestla managed)
                                           il * v_size);             // offset
           ne_build_forward_expand(&gf, ne_flash_attn_update_v(ctx0, v_cache, Vcur, n_past, false));
         }
@@ -273,14 +273,14 @@ static bool starcoder_model_eval_internal(model_context* ctx, const model_input*
         struct ne_tensor* K =
             ne_view_3d(ctx0, kv_self.k,                                             // tensor
                        head_dim, seq_kv, n_head,                                    // ne
-                       kv_cache_info.stride_k_sl, kv_cache_info.stride_k_head_num,  // nb (jblas managed)
+                       kv_cache_info.stride_k_sl, kv_cache_info.stride_k_head_num,  // nb (bestla managed)
                        il * k_size);                                                // offset
         *reinterpret_cast<ATTN_FWD_LAYOUT*>(&K->nb[0]) = kv_cache_info.k_layout;    // us nb0 for layout
         ne_set_name(K, "K");
         struct ne_tensor* V =
             ne_view_3d(ctx0, kv_self.v,                                                    // tensor
                        seq_kv, head_dim, n_head,                                           // ne
-                       kv_cache_info.stride_v_head_size, kv_cache_info.stride_v_head_num,  // nb (jblas managed)
+                       kv_cache_info.stride_v_head_size, kv_cache_info.stride_v_head_num,  // nb (bestla managed)
                        il * v_size);                                                       // offset
         *reinterpret_cast<ATTN_FWD_LAYOUT*>(&V->nb[0]) = kv_cache_info.v_layout;           // us nb0 for layout
         ne_set_name(V, "V");
@@ -334,9 +334,9 @@ static bool starcoder_model_eval_internal(model_context* ctx, const model_input*
       // cur = fc_w*cur + fc_b
       // [3072, N]
       // FFN FUSION
-      if (jblas_fusion_FFN_Add_GeLu_f32f32_support(model.layers[il].ffn[0]->data, model.layers[il].ffn[2]->data,
-                                                   N * batch_size, cur->ne[0], model.layers[il].ffn[0]->ne[1],
-                                                   model.layers[il].ffn[2]->ne[1])) {
+      if (bestla_fusion_FFN_Add_GeLu_f32f32_support(model.layers[il].ffn[0]->data, model.layers[il].ffn[2]->data,
+                                                    N * batch_size, cur->ne[0], model.layers[il].ffn[0]->ne[1],
+                                                    model.layers[il].ffn[2]->ne[1])) {
         cur = ne_ffn_add_gelu(ctx0, model.layers[il].ffn[0], model.layers[il].ffn[2], model.layers[il].ffn[1],
                               model.layers[il].ffn[3], cur);
       } else {
diff --git a/neural_speed/models/starcoder/starcoder_utils.cpp b/neural_speed/models/starcoder/starcoder_utils.cpp
index 41d5a5117..90789ab7d 100644
--- a/neural_speed/models/starcoder/starcoder_utils.cpp
+++ b/neural_speed/models/starcoder/starcoder_utils.cpp
@@ -46,7 +46,7 @@ void model_load_internal(const std::string& fname, model_archs arch, model_conte
   ms->init(fname.c_str(), ctx, n_gpu_layers, use_mmap, use_mlock, vocab_only);
   ms->load(ctx, progress_callback, progress_callback_user_data);
   model_context& lctx = *ctx;
-  lctx.support_jblas_kv = true;
+  lctx.support_bestla_kv = true;
 }
 
 void STARCODER::init(const char* path_model, model_context* ctx, int n_gpu_layer_, bool use_mmap_, bool use_mlock_,
diff --git a/neural_speed/models/whisper/CMakeLists.txt b/neural_speed/models/whisper/CMakeLists.txt
index 4060682f8..e5f488900 100644
--- a/neural_speed/models/whisper/CMakeLists.txt
+++ b/neural_speed/models/whisper/CMakeLists.txt
@@ -16,4 +16,4 @@ set(TARGET whisper)
 add_library_w_warning(${TARGET} whisper.cpp whisper_utils.cpp)  # no (gpt) model utils needed
 target_compile_features(${TARGET} PUBLIC cxx_std_11) # don't bump
 set_target_properties(${TARGET} PROPERTIES POSITION_INDEPENDENT_CODE ON)
-target_link_libraries(${TARGET} PUBLIC ne_layers ${LLAMA_EXTRA_LIBS} jblas::jblas)
+target_link_libraries(${TARGET} PUBLIC ne_layers ${LLAMA_EXTRA_LIBS} bestla::bestla)
diff --git a/neural_speed/models/whisper/whisper.cpp b/neural_speed/models/whisper/whisper.cpp
index 5dc5f7063..1fdfbfbae 100644
--- a/neural_speed/models/whisper/whisper.cpp
+++ b/neural_speed/models/whisper/whisper.cpp
@@ -30,7 +30,7 @@
 #include "core/data_types.h"
 #include "core/layers/mha_dense.h"
 #include "core/ne.h"
-#include "core/ne_jblas.h"
+#include "core/ne_bestla.h"
 #include "core/ne_layers.h"
 #include "models/model_utils/model_config.h"
 #include "models/model_utils/model_utils.h"
diff --git a/scripts/inference.py b/scripts/inference.py
index f4d43bb4d..eeaa29cef 100644
--- a/scripts/inference.py
+++ b/scripts/inference.py
@@ -116,7 +116,7 @@ def main(args_in: Optional[List[str]] = None) -> None:
     parser.add_argument(
         "--memory-auto",
         action="store_true",
-        help="Try with jblas flash attn managed format for kv memory (Currently GCC13 & AMX required); "
+        help="Try with bestla flash attn managed format for kv memory (Currently GCC13 & AMX required); "
         "fall back to fp16 if failed (default option for kv-memory)",
     )