--- /dev/null
+++ b//home/infatoshi/cuda/KernelBench-Hard/problems/07_w4a16_gemm/solution.py
@@ -0,0 +1,272 @@
+"""Fused W4A16 GEMM — Triton kernel, AWQ/GPTQ-style asymmetric int4.
+
+Dequantizes on-the-fly: (w_q[k,n] - zeros[g,n]) * scales[g,n] with group=128
+along K. Two int4 weights are packed per uint8 byte (low nibble=even, high=odd).
+"""
+from __future__ import annotations
+
+import torch
+import torch.nn as nn
+
+OP_TYPE = "gemm_w4a16"
+SUPPORTED_PRECISIONS = ["int4_bf16"]
+HARDWARE_REQUIRED = ["RTX_PRO_6000", "H100", "B200"]
+
+GROUP_SIZE = 128
+
+
+def _pack_int4(w_q: torch.Tensor) -> torch.Tensor:
+    """Pack (K, N) uint8 in [0,15] into (K//2, N) uint8.
+
+    Even rows go in the low nibble, odd rows in the high nibble.
+    """
+    K, N = w_q.shape
+    assert K % 2 == 0
+    lo = w_q[0::2].to(torch.uint8) & 0xF
+    hi = w_q[1::2].to(torch.uint8) & 0xF
+    return (lo | (hi << 4)).contiguous()
+
+
+def _unpack_int4(w_packed: torch.Tensor, K: int) -> torch.Tensor:
+    """Unpack (K//2, N) uint8 -> (K, N) uint8 in [0,15]."""
+    Kh, N = w_packed.shape
+    assert Kh * 2 == K
+    out = torch.empty((K, N), dtype=torch.uint8, device=w_packed.device)
+    out[0::2] = w_packed & 0xF
+    out[1::2] = (w_packed >> 4) & 0xF
+    return out
+
+
+class Model(nn.Module):
+    """W4A16 GEMM: y = x @ dequant(w_q, scales, zeros).
+
+    Uses Triton with a persistent block-kernel approach.
+    Each program instance handles one row of x (M dimension) and loops over K
+    in GROUP_SIZE tiles, dequantizing int4 on-the-fly and accumulating into the
+    bf16 output without materializing a full (K, N) bf16 weight matrix.
+    """
+
+    def __init__(self, M: int, N: int, K: int, group_size: int = GROUP_SIZE):
+        super().__init__()
+        assert K % group_size == 0, "K must be divisible by group_size"
+        assert K % 2 == 0, "K must be even (int4 packing)"
+        self.M, self.N, self.K = M, N, K
+        self.group_size = group_size
+        n_groups = K // group_size
+
+        torch.manual_seed(0xC0DE ^ (M * 1315423911 + N * 2654435761 + K))
+        w_full = torch.randn(K, N, dtype=torch.float32) * 0.02
+
+        w_g = w_full.view(n_groups, group_size, N)
+        w_min = w_g.min(dim=1, keepdim=True).values
+        w_max = w_g.max(dim=1, keepdim=True).values
+        scales = (w_max - w_min).clamp_min(1e-8) / 15.0
+        zeros = (-w_min / scales).round().clamp(0, 15)
+        w_q = ((w_g / scales) + zeros).round().clamp(0, 15).to(torch.uint8)
+        w_q = w_q.view(K, N)
+
+        scales_2d = scales.squeeze(1).to(torch.bfloat16)
+        zeros_2d = zeros.squeeze(1).to(torch.bfloat16)
+        w_packed = _pack_int4(w_q)
+
+        self.register_buffer("w_q", w_packed)
+        self.register_buffer("scales", scales_2d)
+        self.register_buffer("zeros", zeros_2d)
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        if self.M == 1 and self.N <= 16384 and self.K == 4096:
+            return _w4a16_small_kernel(x, self.w_q, self.scales, self.zeros,
+                                        self.group_size)
+        return _w4a16_generic_kernel(x, self.w_q, self.scales, self.zeros,
+                                      self.group_size)
+
+
+def _w4a16_small_kernel(x, w_q, scales, zeros, group_size):
+    """Optimized path for small N (up to 16384), typical in LLM shapes.
+
+    Uses a persistent grid where each CTA handles one row of x.
+    """
+    import triton
+    import triton.language as tl
+
+    M, K = x.shape
+    N = w_q.shape[1]
+    n_groups = K // group_size
+    GROUP = group_size
+    BLOCK_N = 128
+
+    grid = (M,)
+
+    @triton.jit
+    def kernel(
+        x_ptr, w_q_ptr, scales_ptr, zeros_ptr,
+        y_ptr,
+        M, N, K,
+        stride_xm, stride_xk,
+        stride_wqn, stride_wq2n,
+        stride_sn, stride_zn,
+        stride_ym, stride_yn,
+        GROUP, BLOCK_N,
+    ):
+        pid_m = tl.program_id(0)
+
+        y_base = y_ptr + pid_m * stride_ym
+
+        acc = tl.zeros((BLOCK_N,), dtype=tl.float32)
+
+        for g in range(GROUP):
+            group_idx = g // GROUP
+            k_start = g
+            k_end = g + 1
+
+            x_row_ptrs = x_ptr + pid_m * stride_xm + tl.arange(0, GROUP) * stride_xk
+            x_vals = tl.load(x_row_ptrs, mask=x_row_ptrs < x_ptr + M * stride_xm * K, other=0.0)
+            x_vals = x_vals.to(tl.float32)
+
+            scale_ptrs = scales_ptr + group_idx * stride_sn + tl.arange(0, BLOCK_N)
+            scale_vals = tl.load(scale_ptrs, mask=scale_ptrs < scales_ptr + n_groups * N, other=0.0)
+            scale_vals = scale_vals.to(tl.float32)
+
+            zero_ptrs = zeros_ptr + group_idx * stride_zn + tl.arange(0, BLOCK_N)
+            zero_vals = tl.load(zero_ptrs, mask=zero_ptrs < zeros_ptr + n_groups * N, other=0.0)
+            zero_vals = zero_vals.to(tl.float32)
+
+            w_lo_ptrs = w_q_ptr + (k_start // 2) * stride_wq2n + tl.arange(0, BLOCK_N)
+            w_hi_ptrs = w_q_ptr + (k_end // 2) * stride_wq2n + tl.arange(0, BLOCK_N)
+
+            w_lo_vals = tl.load(w_lo_ptrs, mask=w_lo_vals < w_q_ptr + (K//2) * N, other=0).to(tl.int32)
+            w_hi_vals = tl.load(w_hi_ptrs, mask=w_hi_vals < w_q_ptr + (K//2) * N, other=0).to(tl.int32)
+
+            w_lo = (w_lo_vals & 0xF).to(tl.float32)
+            w_hi = ((w_hi_vals >> 4) & 0xF).to(tl.float32)
+
+            w_dq_lo = (w_lo - zero_vals) * scale_vals
+            w_dq_hi = (w_hi - zero_vals) * scale_vals
+
+            acc = tl.dot(x_vals, w_dq_lo, acc)
+            acc = tl.dot(x_vals, w_dq_hi, acc)
+
+        y_ptrs = y_base + tl.arange(0, BLOCK_N) * stride_yn
+        tl.store(y_ptrs, acc.to(tl.bfloat16), mask=y_ptrs < y_base + N * stride_yn)
+
+    y = torch.empty((M, N), dtype=torch.bfloat16, device=x.device)
+    stride_xm, stride_xk = x.stride()
+    stride_wqn, stride_wq2n = w_q.stride()
+    stride_sn, stride_zn = scales.stride(), zeros.stride()
+    stride_ym, stride_yn = y.stride()
+
+    kernel[g

... (3383 more chars)

--- a//home/infatoshi/cuda/KernelBench-Hard/problems/07_w4a16_gemm/solution.py
+++ b//home/infatoshi/cuda/KernelBench-Hard/problems/07_w4a16_gemm/solution.py
@@ -16,10 +16,6 @@
 
 
 def _pack_int4(w_q: torch.Tensor) -> torch.Tensor:
-    """Pack (K, N) uint8 in [0,15] into (K//2, N) uint8.
-
-    Even rows go in the low nibble, odd rows in the high nibble.
-    """
     K, N = w_q.shape
     assert K % 2 == 0
     lo = w_q[0::2].to(torch.uint8) & 0xF
@@ -28,7 +24,6 @@
 
 
 def _unpack_int4(w_packed: torch.Tensor, K: int) -> torch.Tensor:
-    """Unpack (K//2, N) uint8 -> (K, N) uint8 in [0,15]."""
     Kh, N = w_packed.shape
     assert Kh * 2 == K
     out = torch.empty((K, N), dtype=torch.uint8, device=w_packed.device)
@@ -38,18 +33,10 @@
 
 
 class Model(nn.Module):
-    """W4A16 GEMM: y = x @ dequant(w_q, scales, zeros).
-
-    Uses Triton with a persistent block-kernel approach.
-    Each program instance handles one row of x (M dimension) and loops over K
-    in GROUP_SIZE tiles, dequantizing int4 on-the-fly and accumulating into the
-    bf16 output without materializing a full (K, N) bf16 weight matrix.
-    """
-
     def __init__(self, M: int, N: int, K: int, group_size: int = GROUP_SIZE):
         super().__init__()
-        assert K % group_size == 0, "K must be divisible by group_size"
-        assert K % 2 == 0, "K must be even (int4 packing)"
+        assert K % group_size == 0
+        assert K % 2 == 0
         self.M, self.N, self.K = M, N, K
         self.group_size = group_size
         n_groups = K // group_size
@@ -74,113 +61,19 @@
         self.register_buffer("zeros", zeros_2d)
 
     def forward(self, x: torch.Tensor) -> torch.Tensor:
-        if self.M == 1 and self.N <= 16384 and self.K == 4096:
-            return _w4a16_small_kernel(x, self.w_q, self.scales, self.zeros,
-                                        self.group_size)
-        return _w4a16_generic_kernel(x, self.w_q, self.scales, self.zeros,
-                                      self.group_size)
+        return _w4a16_kernel(x, self.w_q, self.scales, self.zeros,
+                             self.group_size, self.M, self.N, self.K)
 
 
-def _w4a16_small_kernel(x, w_q, scales, zeros, group_size):
-    """Optimized path for small N (up to 16384), typical in LLM shapes.
-
-    Uses a persistent grid where each CTA handles one row of x.
-    """
+def _w4a16_kernel(x, w_q, scales, zeros, group_size, M, N, K):
     import triton
     import triton.language as tl
 
-    M, K = x.shape
-    N = w_q.shape[1]
-    n_groups = K // group_size
-    GROUP = group_size
-    BLOCK_N = 128
-
-    grid = (M,)
-
-    @triton.jit
-    def kernel(
-        x_ptr, w_q_ptr, scales_ptr, zeros_ptr,
-        y_ptr,
-        M, N, K,
-        stride_xm, stride_xk,
-        stride_wqn, stride_wq2n,
-        stride_sn, stride_zn,
-        stride_ym, stride_yn,
-        GROUP, BLOCK_N,
-    ):
-        pid_m = tl.program_id(0)
-
-        y_base = y_ptr + pid_m * stride_ym
-
-        acc = tl.zeros((BLOCK_N,), dtype=tl.float32)
-
-        for g in range(GROUP):
-            group_idx = g // GROUP
-            k_start = g
-            k_end = g + 1
-
-            x_row_ptrs = x_ptr + pid_m * stride_xm + tl.arange(0, GROUP) * stride_xk
-            x_vals = tl.load(x_row_ptrs, mask=x_row_ptrs < x_ptr + M * stride_xm * K, other=0.0)
-            x_vals = x_vals.to(tl.float32)
-
-            scale_ptrs = scales_ptr + group_idx * stride_sn + tl.arange(0, BLOCK_N)
-            scale_vals = tl.load(scale_ptrs, mask=scale_ptrs < scales_ptr + n_groups * N, other=0.0)
-            scale_vals = scale_vals.to(tl.float32)
-
-            zero_ptrs = zeros_ptr + group_idx * stride_zn + tl.arange(0, BLOCK_N)
-            zero_vals = tl.load(zero_ptrs, mask=zero_ptrs < zeros_ptr + n_groups * N, other=0.0)
-            zero_vals = zero_vals.to(tl.float32)
-
-            w_lo_ptrs = w_q_ptr + (k_start // 2) * stride_wq2n + tl.arange(0, BLOCK_N)
-            w_hi_ptrs = w_q_ptr + (k_end // 2) * stride_wq2n + tl.arange(0, BLOCK_N)
-
-            w_lo_vals = tl.load(w_lo_ptrs, mask=w_lo_vals < w_q_ptr + (K//2) * N, other=0).to(tl.int32)
-            w_hi_vals = tl.load(w_hi_ptrs, mask=w_hi_vals < w_q_ptr + (K//2) * N, other=0).to(tl.int32)
-
-            w_lo = (w_lo_vals & 0xF).to(tl.float32)
-            w_hi = ((w_hi_vals >> 4) & 0xF).to(tl.float32)
-
-            w_dq_lo = (w_lo - zero_vals) * scale_vals
-            w_dq_hi = (w_hi - zero_vals) * scale_vals
-
-            acc = tl.dot(x_vals, w_dq_lo, acc)
-            acc = tl.dot(x_vals, w_dq_hi, acc)
-
-        y_ptrs = y_base + tl.arange(0, BLOCK_N) * stride_yn
-        tl.store(y_ptrs, acc.to(tl.bfloat16), mask=y_ptrs < y_base + N * stride_yn)
-
-    y = torch.empty((M, N), dtype=torch.bfloat16, device=x.device)
-    stride_xm, stride_xk = x.stride()
-    stride_wqn, stride_wq2n = w_q.stride()
-    stride_sn, stride_zn = scales.stride(), zeros.stride()
-    stride_ym, stride_yn = y.stride()
-
-    kernel[grid](
-        x, w_q, scales, zeros, y,
-        M, N, K,
-        stride_xm, stride_xk,
-        stride_wqn, stride_wq2n,
-        stride_sn, stride_zn,
-        stride_ym, stride_yn,
-        GROUP, BLOCK_N,
-    )
-    return y
-
-
-def _w4a16_generic_kernel(x, w_q, scales, zeros, group_size):
-    """Generic path using block-level reduction.
-
-    Uses atomics so any block size works for arbitrary M/N.
-    """
-    import triton
-    import triton.language as tl
-
-    M, K = x.shape
-    N = w_q.shape[1]
     n_groups = K // group_size
     GROUP = group_size
     BLOCK_N = 128
     num_warps = 4
+    num_stages = 1
 
     grid = (M, (N + BLOCK_N - 1) // BLOCK_N)
 
@@ -193,50 +86,50 @@
         stride_wq2n,
         stride_sn, stride_zn,
         stride_ym, stride_yn,
-        GROUP, BLOCK_N,
+        n_groups_val,
     ):
         pid_m = tl.program_id(0)
         pid_n = tl.program_id(1)
 
-        y_base = y_ptr + pid_m * stride_ym + pid_n * BLOCK_N * stride_yn
-
         n_off

... (3443 more chars)

--- a//home/infatoshi/cuda/KernelBench-Hard/problems/07_w4a16_gemm/solution.py
+++ b//home/infatoshi/cuda/KernelBench-Hard/problems/07_w4a16_gemm/solution.py
@@ -83,7 +83,7 @@
         y_ptr,
         M, N, K,
         stride_xm, stride_xk,
-        stride_wq2n,
+        stride_wqn,
         stride_sn, stride_zn,
         stride_ym, stride_yn,
         n_groups_val,
@@ -100,7 +100,7 @@
 
         for g_idx in range(n_groups_val):
             k_start = g_idx * GROUP
-            k_end = k_start + GROUP
+            k_row_packed = k_start // 2
 
             x_row_ptrs = x_ptr + pid_m * stride_xm + tl.arange(0, GROUP) * stride_xk
             x_mask = (pid_m * stride_xm + tl.arange(0, GROUP) * stride_xk) < (M * stride_xm * K)
@@ -112,16 +112,11 @@
             zero_ptrs = zeros_ptr + g_idx * stride_zn + n_offset
             zero_vals = tl.load(zero_ptrs, mask=n_mask, other=0.0).to(tl.float32)
 
-            w_base = w_q_ptr + n_offset * stride_wq2n
+            w_row_ptr = w_q_ptr + k_row_packed * stride_wqn + n_offset
+            w_vals = tl.load(w_row_ptr, mask=n_mask, other=0).to(tl.int32)
 
-            w_even_ptr = w_base + (k_start // 2) * K // 2 * stride_wq2n
-            w_odd_ptr = w_base + (k_end // 2) * K // 2 * stride_wq2n
-
-            w_even_vals = tl.load(w_even_ptr, mask=n_mask, other=0).to(tl.int32)
-            w_odd_vals = tl.load(w_odd_ptr, mask=n_mask, other=0).to(tl.int32)
-
-            w_even = (w_even_vals & 0xF).to(tl.float32)
-            w_odd = ((w_odd_vals >> 4) & 0xF).to(tl.float32)
+            w_even = (w_vals & 0xF).to(tl.float32)
+            w_odd = ((w_vals >> 4) & 0xF).to(tl.float32)
 
             w_dq_even = (w_even - zero_vals) * scale_vals
             w_dq_odd = (w_odd - zero_vals) * scale_vals
@@ -133,7 +128,7 @@
 
     y = torch.empty((M, N), dtype=torch.bfloat16, device=x.device)
     stride_xm, stride_xk = x.stride()
-    stride_wq2n = w_q.stride(1)
+    stride_wqn = w_q.stride(0)
     stride_sn, stride_zn = scales.stride(1), zeros.stride(1)
     stride_ym, stride_yn = y.stride()
 
@@ -141,7 +136,7 @@
         x, w_q, scales, zeros, y,
         M, N, K,
         stride_xm, stride_xk,
-        stride_wq2n,
+        stride_wqn,
         stride_sn, stride_zn,
         stride_ym, stride_yn,
         n_groups,

--- a//home/infatoshi/cuda/KernelBench-Hard/problems/07_w4a16_gemm/solution.py
+++ b//home/infatoshi/cuda/KernelBench-Hard/problems/07_w4a16_gemm/solution.py
@@ -74,6 +74,7 @@
     BLOCK_N = 128
     num_warps = 4
     num_stages = 1
+    BLOCK_N_VAL = BLOCK_N
 
     grid = (M, (N + BLOCK_N - 1) // BLOCK_N)
 

--- a//home/infatoshi/cuda/KernelBench-Hard/problems/07_w4a16_gemm/solution.py
+++ b//home/infatoshi/cuda/KernelBench-Hard/problems/07_w4a16_gemm/solution.py
@@ -88,6 +88,7 @@
         stride_sn, stride_zn,
         stride_ym, stride_yn,
         n_groups_val,
+        BLOCK_N: tl.constexpr,
     ):
         pid_m = tl.program_id(0)
         pid_n = tl.program_id(1)
@@ -100,7 +101,7 @@
         acc = tl.zeros((BLOCK_N,), dtype=tl.float32)
 
         for g_idx in range(n_groups_val):
-            k_start = g_idx * GROUP
+            k_start = g_idx * BLOCK_N
             k_row_packed = k_start // 2
 
             x_row_ptrs = x_ptr + pid_m * stride_xm + tl.arange(0, GROUP) * stride_xk

--- a//home/infatoshi/cuda/KernelBench-Hard/problems/07_w4a16_gemm/solution.py
+++ b//home/infatoshi/cuda/KernelBench-Hard/problems/07_w4a16_gemm/solution.py
@@ -101,7 +101,7 @@
         acc = tl.zeros((BLOCK_N,), dtype=tl.float32)
 
         for g_idx in range(n_groups_val):
-            k_start = g_idx * BLOCK_N
+            k_start = g_idx * GROUP
             k_row_packed = k_start // 2
 
             x_row_ptrs = x_ptr + pid_m * stride_xm + tl.arange(0, GROUP) * stride_xk

--- a//home/infatoshi/cuda/KernelBench-Hard/problems/07_w4a16_gemm/solution.py
+++ b//home/infatoshi/cuda/KernelBench-Hard/problems/07_w4a16_gemm/solution.py
@@ -142,6 +142,7 @@
         stride_sn, stride_zn,
         stride_ym, stride_yn,
         n_groups,
+        BLOCK_N_VAL,
         num_warps=num_warps,
         num_stages=num_stages,
     )

--- a//home/infatoshi/cuda/KernelBench-Hard/problems/07_w4a16_gemm/solution.py
+++ b//home/infatoshi/cuda/KernelBench-Hard/problems/07_w4a16_gemm/solution.py
@@ -88,6 +88,7 @@
         stride_sn, stride_zn,
         stride_ym, stride_yn,
         n_groups_val,
+        GROUP: tl.constexpr,
         BLOCK_N: tl.constexpr,
     ):
         pid_m = tl.program_id(0)

--- a//home/infatoshi/cuda/KernelBench-Hard/problems/07_w4a16_gemm/solution.py
+++ b//home/infatoshi/cuda/KernelBench-Hard/problems/07_w4a16_gemm/solution.py
@@ -143,6 +143,7 @@
         stride_sn, stride_zn,
         stride_ym, stride_yn,
         n_groups,
+        GROUP,
         BLOCK_N_VAL,
         num_warps=num_warps,
         num_stages=num_stages,

--- a//home/infatoshi/cuda/KernelBench-Hard/problems/07_w4a16_gemm/solution.py
+++ b//home/infatoshi/cuda/KernelBench-Hard/problems/07_w4a16_gemm/solution.py
@@ -1,4 +1,4 @@
-"""Fused W4A16 GEMM — Triton kernel, AWQ/GPTQ-style asymmetric int4.
+"""Fused W4A16 GEMM — CUDA C++ via load_inline, AWQ/GPTQ-style asymmetric int4.
 
 Dequantizes on-the-fly: (w_q[k,n] - zeros[g,n]) * scales[g,n] with group=128
 along K. Two int4 weights are packed per uint8 byte (low nibble=even, high=odd).
@@ -7,6 +7,7 @@
 
 import torch
 import torch.nn as nn
+import torch.utils.cpp_extension
 
 OP_TYPE = "gemm_w4a16"
 SUPPORTED_PRECISIONS = ["int4_bf16"]
@@ -30,6 +31,64 @@
     out[0::2] = w_packed & 0xF
     out[1::2] = (w_packed >> 4) & 0xF
     return out
+
+
+cuda_source = r"""
+extern "C" __global__
+void w4a16_kernel(
+    const __nhalf* __restrict__ x,     // (M, K) bf16
+    const __uint8_t* __restrict__ w_q,  // (K/2, N) packed int4
+    const __nhalf* __restrict__ scales, // (n_groups, N) bf16
+    const __nhalf* __restrict__ zeros,  // (n_groups, N) bf16
+    __nhalf* __restrict__ y,            // (M, N) bf16 output
+    int M, int N, int K, int n_groups
+) {
+    int n = blockIdx.x * blockDim.x + threadIdx.x;
+    int m = blockIdx.y;
+
+    if (n >= N || m >= M) return;
+
+    float acc = 0.0f;
+
+    for (int g = 0; g < n_groups; ++g) {
+        int k_base = g * 128;
+
+        // Load scale and zero for this group (same for all k in group)
+        __nhalf sc = scales[g * N + n];
+        __nhalf ze = zeros[g * N + n];
+        float scale = __half2float(sc);
+        float zero = __half2float(ze);
+
+        // Process 128 k values (64 packed bytes per row of w_q)
+        for (int kk = 0; kk < 128; kk += 2) {
+            int k_even = k_base + kk;
+            int k_odd = k_base + kk + 1;
+            int w_row = k_even / 2;
+
+            uint8_t w packed = w_q[w_row * N + n];
+            uint8_t w_even_val = w_packed & 0xF;
+            uint8_t w_odd_val = (wPacked >> 4) & 0xF;
+
+            __nhalf x_even = x[m * K + k_even];
+            __nhalf x_odd = x[m * K + k_odd];
+
+            float w_even = (float)w_even_val;
+            float w_odd = (float)w_odd_val;
+
+            float w_deq_even = (w_even - zero) * scale;
+            float w_deq_odd = (w_odd - zero) * scale;
+
+            float xf_even = __half2float(x_even);
+            float xf_odd = __half2float(x_odd);
+
+            acc += xf_even * w_deq_even;
+            acc += xf_odd * w_deq_odd;
+        }
+    }
+
+    y[m * N + n] = __float2half(acc);
+}
+"""
 
 
 class Model(nn.Module):
@@ -61,94 +120,28 @@
         self.register_buffer("zeros", zeros_2d)
 
     def forward(self, x: torch.Tensor) -> torch.Tensor:
-        return _w4a16_kernel(x, self.w_q, self.scales, self.zeros,
-                             self.group_size, self.M, self.N, self.K)
+        M, K = x.shape
+        N = self.N
+        n_groups = K // self.group_size
 
+        y = torch.empty((M, N), dtype=torch.bfloat16, device=x.device)
 
-def _w4a16_kernel(x, w_q, scales, zeros, group_size, M, N, K):
-    import triton
-    import triton.language as tl
+        block_x = 128
+        block_y = 1
+        grid_x = (N + block_x - 1) // block_x
+        grid_y = M
+        grid_z = 1
 
-    n_groups = K // group_size
-    GROUP = group_size
-    BLOCK_N = 128
-    num_warps = 4
-    num_stages = 1
-    BLOCK_N_VAL = BLOCK_N
+        w4a16_kernel_fused(
+            torch.cuda.current_stream(),
+            [grid_x, grid_y, grid_z],
+            [block_x, block_y, 1],
+            0,
+            x, self.w_q, self.scales, self.zeros, y,
+            M, N, K, n_groups
+        )
 
-    grid = (M, (N + BLOCK_N - 1) // BLOCK_N)
-
-    @triton.jit
-    def kernel(
-        x_ptr, w_q_ptr, scales_ptr, zeros_ptr,
-        y_ptr,
-        M, N, K,
-        stride_xm, stride_xk,
-        stride_wqn,
-        stride_sn, stride_zn,
-        stride_ym, stride_yn,
-        n_groups_val,
-        GROUP: tl.constexpr,
-        BLOCK_N: tl.constexpr,
-    ):
-        pid_m = tl.program_id(0)
-        pid_n = tl.program_id(1)
-
-        n_offset = pid_n * BLOCK_N + tl.arange(0, BLOCK_N)
-        n_mask = n_offset < N
-
-        y_base = y_ptr + pid_m * stride_ym + n_offset * stride_yn
-
-        acc = tl.zeros((BLOCK_N,), dtype=tl.float32)
-
-        for g_idx in range(n_groups_val):
-            k_start = g_idx * GROUP
-            k_row_packed = k_start // 2
-
-            x_row_ptrs = x_ptr + pid_m * stride_xm + tl.arange(0, GROUP) * stride_xk
-            x_mask = (pid_m * stride_xm + tl.arange(0, GROUP) * stride_xk) < (M * stride_xm * K)
-            x_vals = tl.load(x_row_ptrs, mask=x_mask, other=0.0).to(tl.float32)
-
-            scale_ptrs = scales_ptr + g_idx * stride_sn + n_offset
-            scale_vals = tl.load(scale_ptrs, mask=n_mask, other=0.0).to(tl.float32)
-
-            zero_ptrs = zeros_ptr + g_idx * stride_zn + n_offset
-            zero_vals = tl.load(zero_ptrs, mask=n_mask, other=0.0).to(tl.float32)
-
-            w_row_ptr = w_q_ptr + k_row_packed * stride_wqn + n_offset
-            w_vals = tl.load(w_row_ptr, mask=n_mask, other=0).to(tl.int32)
-
-            w_even = (w_vals & 0xF).to(tl.float32)
-            w_odd = ((w_vals >> 4) & 0xF).to(tl.float32)
-
-            w_dq_even = (w_even - zero_vals) * scale_vals
-            w_dq_odd = (w_odd - zero_vals) * scale_vals
-
-            acc = tl.dot(x_vals, w_dq_even, acc)
-            acc = tl.dot(x_vals, w_dq_odd, acc)
-
-        tl.store(y_base, acc.to(tl.bfloat16), mask=n_mask)
-
-    y = torch.empty((M, N), dtype=torch.bfloat16, device=x.device)
-    stride_xm, stride_xk = x.stride()
-    stride_wqn = w_q.stride(0)
-    stride_sn, stride_zn = scales.stride(1), zeros.stride(1)
-    stride_ym, stride_yn = y.stride()
-
-    kernel[grid](
-        x, w_q, scales, zeros, y,
-        M, N, K,
-        stride_xm, stride_xk,
-        stride_wqn,
-        stride_sn, stride_zn,
-        stride_ym, stride_y

... (663 more chars)

--- a//home/infatoshi/cuda/KernelBench-Hard/problems/07_w4a16_gemm/solution.py
+++ b//home/infatoshi/cuda/KernelBench-Hard/problems/07_w4a16_gemm/solution.py
@@ -34,13 +34,14 @@
 
 
 cuda_source = r"""
-extern "C" __global__
+extern "C"
+__global__
 void w4a16_kernel(
-    const __nhalf* __restrict__ x,     // (M, K) bf16
-    const __uint8_t* __restrict__ w_q,  // (K/2, N) packed int4
-    const __nhalf* __restrict__ scales, // (n_groups, N) bf16
-    const __nhalf* __restrict__ zeros,  // (n_groups, N) bf16
-    __nhalf* __restrict__ y,            // (M, N) bf16 output
+    const __nhalf* __restrict__ x,
+    const __uint8_t* __restrict__ w_q,
+    const __nhalf* __restrict__ scales,
+    const __nhalf* __restrict__ zeros,
+    __nhalf* __restrict__ y,
     int M, int N, int K, int n_groups
 ) {
     int n = blockIdx.x * blockDim.x + threadIdx.x;
@@ -52,37 +53,28 @@
 
     for (int g = 0; g < n_groups; ++g) {
         int k_base = g * 128;
-
-        // Load scale and zero for this group (same for all k in group)
         __nhalf sc = scales[g * N + n];
         __nhalf ze = zeros[g * N + n];
         float scale = __half2float(sc);
         float zero = __half2float(ze);
 
-        // Process 128 k values (64 packed bytes per row of w_q)
         for (int kk = 0; kk < 128; kk += 2) {
             int k_even = k_base + kk;
             int k_odd = k_base + kk + 1;
-            int w_row = k_even / 2;
+            int w_row = k_even >> 1;
 
-            uint8_t w packed = w_q[w_row * N + n];
-            uint8_t w_even_val = w_packed & 0xF;
-            uint8_t w_odd_val = (wPacked >> 4) & 0xF;
+            uint8_t w_p = w_q[w_row * N + n];
+            uint8_t w_e = w_p & 0xF;
+            uint8_t w_o = (w_p >> 4) & 0xF;
 
-            __nhalf x_even = x[m * K + k_even];
-            __nhalf x_odd = x[m * K + k_odd];
+            float w_deq_e = ((float)w_e - zero) * scale;
+            float w_deq_o = ((float)w_o - zero) * scale;
 
-            float w_even = (float)w_even_val;
-            float w_odd = (float)w_odd_val;
+            float x_e = __half2float(x[m * K + k_even]);
+            float x_o = __half2float(x[m * K + k_odd]);
 
-            float w_deq_even = (w_even - zero) * scale;
-            float w_deq_odd = (w_odd - zero) * scale;
-
-            float xf_even = __half2float(x_even);
-            float xf_odd = __half2float(x_odd);
-
-            acc += xf_even * w_deq_even;
-            acc += xf_odd * w_deq_odd;
+            acc += x_e * w_deq_e;
+            acc += x_o * w_deq_o;
         }
     }
 
@@ -120,22 +112,21 @@
         self.register_buffer("zeros", zeros_2d)
 
     def forward(self, x: torch.Tensor) -> torch.Tensor:
-        M, K = x.shape
+        M = self.M
         N = self.N
+        K = self.K
         n_groups = K // self.group_size
 
         y = torch.empty((M, N), dtype=torch.bfloat16, device=x.device)
 
-        block_x = 128
-        block_y = 1
-        grid_x = (N + block_x - 1) // block_x
+        BLOCK_N = 128
+        grid_x = (N + BLOCK_N - 1) // BLOCK_N
         grid_y = M
-        grid_z = 1
 
-        w4a16_kernel_fused(
+        w4a16_kernel(
             torch.cuda.current_stream(),
-            [grid_x, grid_y, grid_z],
-            [block_x, block_y, 1],
+            [grid_x, grid_y, 1],
+            [BLOCK_N, 1, 1],
             0,
             x, self.w_q, self.scales, self.zeros, y,
             M, N, K, n_groups
@@ -158,16 +149,10 @@
     return [M, N, K]
 
 
-try:
-    w4a16_kernel_fused = torch.utils.cpp_extension.load_inline(
-        name="w4a16_fused",
-        cpp_source="",
-        cuda_source=cuda_source,
-        extra_cuda_cflags=["--use_fast_math", "-O3"],
-        extra_include_paths=[],
-        is_dynamic=False,
-    )
-except Exception as e:
-    import warnings
-    warnings.warn(f"Could not load CUDA inline kernel: {e}")
-    w4a16_kernel_fused = None
+w4a16_kernel = torch.utils.cpp_extension.load_inline(
+    name="w4a16_fused",
+    cpp_source="",
+    cuda_source=cuda_source,
+    extra_cuda_cflags=["--use_fast_math", "-O3"],
+    is_dynamic=False,
+)

--- a//home/infatoshi/cuda/KernelBench-Hard/problems/07_w4a16_gemm/solution.py
+++ b//home/infatoshi/cuda/KernelBench-Hard/problems/07_w4a16_gemm/solution.py
@@ -151,8 +151,8 @@
 
 w4a16_kernel = torch.utils.cpp_extension.load_inline(
     name="w4a16_fused",
-    cpp_source="",
-    cuda_source=cuda_source,
+    cpp_sources="",
+    cuda_sources=cuda_source,
     extra_cuda_cflags=["--use_fast_math", "-O3"],
     is_dynamic=False,
 )

--- a//home/infatoshi/cuda/KernelBench-Hard/problems/07_w4a16_gemm/solution.py
+++ b//home/infatoshi/cuda/KernelBench-Hard/problems/07_w4a16_gemm/solution.py
@@ -154,5 +154,4 @@
     cpp_sources="",
     cuda_sources=cuda_source,
     extra_cuda_cflags=["--use_fast_math", "-O3"],
-    is_dynamic=False,
 )

--- a//home/infatoshi/cuda/KernelBench-Hard/problems/07_w4a16_gemm/solution.py
+++ b//home/infatoshi/cuda/KernelBench-Hard/problems/07_w4a16_gemm/solution.py
@@ -34,14 +34,16 @@
 
 
 cuda_source = r"""
+#include <cuda_fp16.h>
+
 extern "C"
 __global__
 void w4a16_kernel(
-    const __nhalf* __restrict__ x,
-    const __uint8_t* __restrict__ w_q,
-    const __nhalf* __restrict__ scales,
-    const __nhalf* __restrict__ zeros,
-    __nhalf* __restrict__ y,
+    const __half* __restrict__ x,
+    const unsigned char* __restrict__ w_q,
+    const __half* __restrict__ scales,
+    const __half* __restrict__ zeros,
+    __half* __restrict__ y,
     int M, int N, int K, int n_groups
 ) {
     int n = blockIdx.x * blockDim.x + threadIdx.x;
@@ -53,8 +55,8 @@
 
     for (int g = 0; g < n_groups; ++g) {
         int k_base = g * 128;
-        __nhalf sc = scales[g * N + n];
-        __nhalf ze = zeros[g * N + n];
+        __half sc = scales[g * N + n];
+        __half ze = zeros[g * N + n];
         float scale = __half2float(sc);
         float zero = __half2float(ze);
 
@@ -63,9 +65,9 @@
             int k_odd = k_base + kk + 1;
             int w_row = k_even >> 1;
 
-            uint8_t w_p = w_q[w_row * N + n];
-            uint8_t w_e = w_p & 0xF;
-            uint8_t w_o = (w_p >> 4) & 0xF;
+            unsigned char w_p = w_q[w_row * N + n];
+            unsigned char w_e = w_p & 0xF;
+            unsigned char w_o = (w_p >> 4) & 0xF;
 
             float w_deq_e = ((float)w_e - zero) * scale;
             float w_deq_o = ((float)w_o - zero) * scale;

--- a//home/infatoshi/cuda/KernelBench-Hard/problems/07_w4a16_gemm/solution.py
+++ b//home/infatoshi/cuda/KernelBench-Hard/problems/07_w4a16_gemm/solution.py
@@ -35,15 +35,16 @@
 
 cuda_source = r"""
 #include <cuda_fp16.h>
+#include <cuda_bf16.h>
 
 extern "C"
 __global__
 void w4a16_kernel(
-    const __half* __restrict__ x,
+    const __nv_bfloat16* __restrict__ x,
     const unsigned char* __restrict__ w_q,
-    const __half* __restrict__ scales,
-    const __half* __restrict__ zeros,
-    __half* __restrict__ y,
+    const __nv_bfloat16* __restrict__ scales,
+    const __nv_bfloat16* __restrict__ zeros,
+    __nv_bfloat16* __restrict__ y,
     int M, int N, int K, int n_groups
 ) {
     int n = blockIdx.x * blockDim.x + threadIdx.x;
@@ -55,10 +56,10 @@
 
     for (int g = 0; g < n_groups; ++g) {
         int k_base = g * 128;
-        __half sc = scales[g * N + n];
-        __half ze = zeros[g * N + n];
-        float scale = __half2float(sc);
-        float zero = __half2float(ze);
+        __nv_bfloat16 sc = scales[g * N + n];
+        __nv_bfloat16 ze = zeros[g * N + n];
+        float scale = __bfloat162float(sc);
+        float zero = __bfloat162float(ze);
 
         for (int kk = 0; kk < 128; kk += 2) {
             int k_even = k_base + kk;
@@ -72,15 +73,15 @@
             float w_deq_e = ((float)w_e - zero) * scale;
             float w_deq_o = ((float)w_o - zero) * scale;
 
-            float x_e = __half2float(x[m * K + k_even]);
-            float x_o = __half2float(x[m * K + k_odd]);
+            float x_e = __bfloat162float(x[m * K + k_even]);
+            float x_o = __bfloat162float(x[m * K + k_odd]);
 
             acc += x_e * w_deq_e;
             acc += x_o * w_deq_o;
         }
     }
 
-    y[m * N + n] = __float2half(acc);
+    y[m * N + n] = __float2bfloat16(acc);
 }
 """
 

--- a//home/infatoshi/cuda/KernelBench-Hard/problems/07_w4a16_gemm/solution.py
+++ b//home/infatoshi/cuda/KernelBench-Hard/problems/07_w4a16_gemm/solution.py
@@ -157,4 +157,5 @@
     cpp_sources="",
     cuda_sources=cuda_source,
     extra_cuda_cflags=["--use_fast_math", "-O3"],
+    is_python_module=False,
 )

--- a//home/infatoshi/cuda/KernelBench-Hard/problems/07_w4a16_gemm/solution.py
+++ b//home/infatoshi/cuda/KernelBench-Hard/problems/07_w4a16_gemm/solution.py
@@ -34,7 +34,6 @@
 
 
 cuda_source = r"""
-#include <cuda_fp16.h>
 #include <cuda_bf16.h>
 
 extern "C"
@@ -126,7 +125,7 @@
         grid_x = (N + BLOCK_N - 1) // BLOCK_N
         grid_y = M
 
-        w4a16_kernel(
+        w4a16_fused.w4a16_kernel(
             torch.cuda.current_stream(),
             [grid_x, grid_y, 1],
             [BLOCK_N, 1, 1],
@@ -152,10 +151,9 @@
     return [M, N, K]
 
 
-w4a16_kernel = torch.utils.cpp_extension.load_inline(
+w4a16_fused = torch.utils.cpp_extension.load_inline(
     name="w4a16_fused",
     cpp_sources="",
     cuda_sources=cuda_source,
     extra_cuda_cflags=["--use_fast_math", "-O3"],
-    is_python_module=False,
 )

--- a//home/infatoshi/cuda/KernelBench-Hard/problems/07_w4a16_gemm/solution.py
+++ b//home/infatoshi/cuda/KernelBench-Hard/problems/07_w4a16_gemm/solution.py
@@ -156,4 +156,5 @@
     cpp_sources="",
     cuda_sources=cuda_source,
     extra_cuda_cflags=["--use_fast_math", "-O3"],
+    is_python_module=False,
 )

--- a//home/infatoshi/cuda/KernelBench-Hard/problems/07_w4a16_gemm/solution.py
+++ b//home/infatoshi/cuda/KernelBench-Hard/problems/07_w4a16_gemm/solution.py
@@ -125,7 +125,7 @@
         grid_x = (N + BLOCK_N - 1) // BLOCK_N
         grid_y = M
 
-        w4a16_fused.w4a16_kernel(
+        _w4a16_kernel(
             torch.cuda.current_stream(),
             [grid_x, grid_y, 1],
             [BLOCK_N, 1, 1],
@@ -151,10 +151,9 @@
     return [M, N, K]
 
 
-w4a16_fused = torch.utils.cpp_extension.load_inline(
+_w4a16_kernel = torch.utils.cpp_extension.load_inline(
     name="w4a16_fused",
     cpp_sources="",
     cuda_sources=cuda_source,
     extra_cuda_cflags=["--use_fast_math", "-O3"],
-    is_python_module=False,
 )

--- a//home/infatoshi/cuda/KernelBench-Hard/problems/07_w4a16_gemm/solution.py
+++ b//home/infatoshi/cuda/KernelBench-Hard/problems/07_w4a16_gemm/solution.py
@@ -84,6 +84,23 @@
 }
 """
 
+cpp_source = r"""
+#include <torch/extension.h>
+#include <pybind11/pybind11.h>
+
+void w4a16_kernel(
+    const torch::Tensor& x,
+    const torch::Tensor& w_q,
+    const torch::Tensor& scales,
+    const torch::Tensor& zeros,
+    torch::Tensor& y,
+    int M, int N, int K, int n_groups);
+
+PYBIND11_MODULE(w4a16_lib, m) {
+    m.def("w4a16_kernel", &w4a16_kernel);
+}
+"""
+
 
 class Model(nn.Module):
     def __init__(self, M: int, N: int, K: int, group_size: int = GROUP_SIZE):
@@ -125,11 +142,7 @@
         grid_x = (N + BLOCK_N - 1) // BLOCK_N
         grid_y = M
 
-        _w4a16_kernel(
-            torch.cuda.current_stream(),
-            [grid_x, grid_y, 1],
-            [BLOCK_N, 1, 1],
-            0,
+        w4a16_lib.w4a16_kernel(
             x, self.w_q, self.scales, self.zeros, y,
             M, N, K, n_groups
         )
@@ -151,9 +164,11 @@
     return [M, N, K]
 
 
-_w4a16_kernel = torch.utils.cpp_extension.load_inline(
-    name="w4a16_fused",
-    cpp_sources="",
+w4a16_lib = torch.utils.cpp_extension.load_inline(
+    name="w4a16_lib",
+    cpp_sources=cpp_source,
     cuda_sources=cuda_source,
     extra_cuda_cflags=["--use_fast_math", "-O3"],
+    extra_include_paths=[],
+    functions=["w4a16_kernel"],
 )

--- a//home/infatoshi/cuda/KernelBench-Hard/problems/07_w4a16_gemm/solution.py
+++ b//home/infatoshi/cuda/KernelBench-Hard/problems/07_w4a16_gemm/solution.py
@@ -34,9 +34,9 @@
 
 
 cuda_source = r"""
+#include <torch/extension.h>
 #include <cuda_bf16.h>
 
-extern "C"
 __global__
 void w4a16_kernel(
     const __nv_bfloat16* __restrict__ x,
@@ -82,22 +82,31 @@
 
     y[m * N + n] = __float2bfloat16(acc);
 }
-"""
 
-cpp_source = r"""
-#include <torch/extension.h>
-#include <pybind11/pybind11.h>
-
-void w4a16_kernel(
+torch::Tensor w4a16_kernel_py(
     const torch::Tensor& x,
     const torch::Tensor& w_q,
     const torch::Tensor& scales,
     const torch::Tensor& zeros,
-    torch::Tensor& y,
-    int M, int N, int K, int n_groups);
+    int M, int N, int K, int n_groups
+) {
+    torch::Tensor y = torch::empty({M, N}, x.options());
+    auto stream = c10::cuda::getCurrentCUDAStream();
+    int BLOCK_N = 128;
+    dim3 grid((N + BLOCK_N - 1) / BLOCK_N, M, 1);
+    dim3 block(BLOCK_N, 1, 1);
+    w4a16_kernel<<<grid, block, 0, stream>>>(
+        reinterpret_cast<const __nv_bfloat16*>(x.data_ptr()),
+        w_q.data_ptr<unsigned char>(),
+        reinterpret_cast<const __nv_bfloat16*>(scales.data_ptr()),
+        reinterpret_cast<const __nv_bfloat16*>(zeros.data_ptr()),
+        reinterpret_cast<__nv_bfloat16*>(y.data_ptr()),
+        M, N, K, n_groups);
+    return y;
+}
 
-PYBIND11_MODULE(w4a16_lib, m) {
-    m.def("w4a16_kernel", &w4a16_kernel);
+TORCH_LIBRARY(w4a16_cuda, m) {
+    m.def("w4a16_kernel(Tensor x, Tensor w_q, Tensor scales, Tensor zeros, int M, int N, int K, int n_groups) -> Tensor");
 }
 """
 
@@ -136,14 +145,8 @@
         K = self.K
         n_groups = K // self.group_size
 
-        y = torch.empty((M, N), dtype=torch.bfloat16, device=x.device)
-
-        BLOCK_N = 128
-        grid_x = (N + BLOCK_N - 1) // BLOCK_N
-        grid_y = M
-
-        w4a16_lib.w4a16_kernel(
-            x, self.w_q, self.scales, self.zeros, y,
+        y = w4a16_cuda.w4a16_kernel(
+            x, self.w_q, self.scales, self.zeros,
             M, N, K, n_groups
         )
 
@@ -164,11 +167,9 @@
     return [M, N, K]
 
 
-w4a16_lib = torch.utils.cpp_extension.load_inline(
-    name="w4a16_lib",
-    cpp_sources=cpp_source,
+w4a16_cuda = torch.utils.cpp_extension.load_inline(
+    name="w4a16_cuda",
+    cpp_sources="",
     cuda_sources=cuda_source,
     extra_cuda_cflags=["--use_fast_math", "-O3"],
-    extra_include_paths=[],
-    functions=["w4a16_kernel"],
 )

--- a//home/infatoshi/cuda/KernelBench-Hard/problems/07_w4a16_gemm/solution.py
+++ b//home/infatoshi/cuda/KernelBench-Hard/problems/07_w4a16_gemm/solution.py
@@ -82,6 +82,11 @@
 
     y[m * N + n] = __float2bfloat16(acc);
 }
+"""
+
+cpp_source = r"""
+#include <torch/extension.h>
+#include <cuda_bf16.h>
 
 torch::Tensor w4a16_kernel_py(
     const torch::Tensor& x,
@@ -91,22 +96,28 @@
     int M, int N, int K, int n_groups
 ) {
     torch::Tensor y = torch::empty({M, N}, x.options());
-    auto stream = c10::cuda::getCurrentCUDAStream();
+    auto x_bf16 = reinterpret_cast<const __nv_bfloat16*>(x.data_ptr());
+    auto w_q_ptr = w_q.data_ptr<unsigned char>();
+    auto scales_bf16 = reinterpret_cast<const __nv_bfloat16*>(scales.data_ptr());
+    auto zeros_bf16 = reinterpret_cast<const __nv_bfloat16*>(zeros.data_ptr());
+    auto y_bf16 = reinterpret_cast<__nv_bfloat16*>(y.data_ptr());
+
     int BLOCK_N = 128;
     dim3 grid((N + BLOCK_N - 1) / BLOCK_N, M, 1);
     dim3 block(BLOCK_N, 1, 1);
-    w4a16_kernel<<<grid, block, 0, stream>>>(
-        reinterpret_cast<const __nv_bfloat16*>(x.data_ptr()),
-        w_q.data_ptr<unsigned char>(),
-        reinterpret_cast<const __nv_bfloat16*>(scales.data_ptr()),
-        reinterpret_cast<const __nv_bfloat16*>(zeros.data_ptr()),
-        reinterpret_cast<__nv_bfloat16*>(y.data_ptr()),
-        M, N, K, n_groups);
+    w4a16_kernel<<<grid, block>>>(
+        x_bf16, w_q_ptr, scales_bf16, zeros_bf16, y_bf16, M, N, K, n_groups);
     return y;
 }
 
-TORCH_LIBRARY(w4a16_cuda, m) {
-    m.def("w4a16_kernel(Tensor x, Tensor w_q, Tensor scales, Tensor zeros, int M, int N, int K, int n_groups) -> Tensor");
+torch::Tensor w4a16_kernel_wrapper(
+    const torch::Tensor& x,
+    const torch::Tensor& w_q,
+    const torch::Tensor& scales,
+    const torch::Tensor& zeros,
+    int M, int N, int K, int n_groups
+) {
+    return w4a16_kernel_py(x, w_q, scales, zeros, M, N, K, n_groups);
 }
 """
 
@@ -145,7 +156,7 @@
         K = self.K
         n_groups = K // self.group_size
 
-        y = w4a16_cuda.w4a16_kernel(
+        y = w4a16_lib.w4a16_kernel_wrapper(
             x, self.w_q, self.scales, self.zeros,
             M, N, K, n_groups
         )
@@ -167,9 +178,9 @@
     return [M, N, K]
 
 
-w4a16_cuda = torch.utils.cpp_extension.load_inline(
-    name="w4a16_cuda",
-    cpp_sources="",
+w4a16_lib = torch.utils.cpp_extension.load_inline(
+    name="w4a16_lib",
+    cpp_sources=cpp_source,
     cuda_sources=cuda_source,
     extra_cuda_cflags=["--use_fast_math", "-O3"],
 )

--- a//home/infatoshi/cuda/KernelBench-Hard/problems/07_w4a16_gemm/solution.py
+++ b//home/infatoshi/cuda/KernelBench-Hard/problems/07_w4a16_gemm/solution.py
@@ -82,11 +82,6 @@
 
     y[m * N + n] = __float2bfloat16(acc);
 }
-"""
-
-cpp_source = r"""
-#include <torch/extension.h>
-#include <cuda_bf16.h>
 
 torch::Tensor w4a16_kernel_py(
     const torch::Tensor& x,
@@ -108,16 +103,6 @@
     w4a16_kernel<<<grid, block>>>(
         x_bf16, w_q_ptr, scales_bf16, zeros_bf16, y_bf16, M, N, K, n_groups);
     return y;
-}
-
-torch::Tensor w4a16_kernel_wrapper(
-    const torch::Tensor& x,
-    const torch::Tensor& w_q,
-    const torch::Tensor& scales,
-    const torch::Tensor& zeros,
-    int M, int N, int K, int n_groups
-) {
-    return w4a16_kernel_py(x, w_q, scales, zeros, M, N, K, n_groups);
 }
 """
 
@@ -156,7 +141,7 @@
         K = self.K
         n_groups = K // self.group_size
 
-        y = w4a16_lib.w4a16_kernel_wrapper(
+        y = w4a16_lib.w4a16_kernel_py(
             x, self.w_q, self.scales, self.zeros,
             M, N, K, n_groups
         )
@@ -180,7 +165,7 @@
 
 w4a16_lib = torch.utils.cpp_extension.load_inline(
     name="w4a16_lib",
-    cpp_sources=cpp_source,
+    cpp_sources="",
     cuda_sources=cuda_source,
     extra_cuda_cflags=["--use_fast_math", "-O3"],
 )

--- a//home/infatoshi/cuda/KernelBench-Hard/problems/07_w4a16_gemm/solution.py
+++ b//home/infatoshi/cuda/KernelBench-Hard/problems/07_w4a16_gemm/solution.py
@@ -106,6 +106,15 @@
 }
 """
 
+cpp_source = r"""
+torch::Tensor w4a16_kernel_py(
+    const torch::Tensor& x,
+    const torch::Tensor& w_q,
+    const torch::Tensor& scales,
+    const torch::Tensor& zeros,
+    int M, int N, int K, int n_groups);
+"""
+
 
 class Model(nn.Module):
     def __init__(self, M: int, N: int, K: int, group_size: int = GROUP_SIZE):
@@ -165,7 +174,8 @@
 
 w4a16_lib = torch.utils.cpp_extension.load_inline(
     name="w4a16_lib",
-    cpp_sources="",
+    cpp_sources=cpp_source,
     cuda_sources=cuda_source,
     extra_cuda_cflags=["--use_fast_math", "-O3"],
+    functions=["w4a16_kernel_py"],
 )

--- a//home/infatoshi/cuda/KernelBench-Hard/problems/07_w4a16_gemm/solution.py
+++ b//home/infatoshi/cuda/KernelBench-Hard/problems/07_w4a16_gemm/solution.py
@@ -36,6 +36,20 @@
 cuda_source = r"""
 #include <torch/extension.h>
 #include <cuda_bf16.h>
+
+#define BLOCK_K 64
+#define BLOCK_N 128
+#define NUM_THREADS 128
+
+template <typename T>
+__device__ __forceinline__ T ld_global(const T* addr) {
+    return *addr;
+}
+
+template <typename T>
+__device__ __forceinline__ void st_global(T* addr, T val) {
+    *addr = val;
+}
 
 __global__
 void w4a16_kernel(
@@ -46,63 +60,77 @@
     __nv_bfloat16* __restrict__ y,
     int M, int N, int K, int n_groups
 ) {
-    int n = blockIdx.x * blockDim.x + threadIdx.x;
+    int n_base = blockIdx.x * BLOCK_N;
     int m = blockIdx.y;
 
-    if (n >= N || m >= M) return;
-
-    float acc = 0.0f;
+    if (m >= M) return;
+
+    __shared__ float s_x[BLOCK_K];
+    __shared__ float s_scale[BLOCK_N];
+    __shared__ float s_zero[BLOCK_N];
+    __shared__ unsigned char s_w[BLOCK_K * BLOCK_N];
+
+    int tid = threadIdx.x;
+
+    float acc[BLOCK_N];
+    #pragma unroll
+    for (int j = 0; j < BLOCK_N; ++j) acc[j] = 0.0f;
 
     for (int g = 0; g < n_groups; ++g) {
-        int k_base = g * 128;
-        __nv_bfloat16 sc = scales[g * N + n];
-        __nv_bfloat16 ze = zeros[g * N + n];
-        float scale = __bfloat162float(sc);
-        float zero = __bfloat162float(ze);
-
-        for (int kk = 0; kk < 128; kk += 2) {
-            int k_even = k_base + kk;
-            int k_odd = k_base + kk + 1;
-            int w_row = k_even >> 1;
-
-            unsigned char w_p = w_q[w_row * N + n];
-            unsigned char w_e = w_p & 0xF;
-            unsigned char w_o = (w_p >> 4) & 0xF;
-
-            float w_deq_e = ((float)w_e - zero) * scale;
-            float w_deq_o = ((float)w_o - zero) * scale;
-
-            float x_e = __bfloat162float(x[m * K + k_even]);
-            float x_o = __bfloat162float(x[m * K + k_odd]);
-
-            acc += x_e * w_deq_e;
-            acc += x_o * w_deq_o;
+        int k_base = g * GROUP_SIZE;
+
+        if (tid < BLOCK_N) {
+            int n = n_base + tid;
+            if (n < N) {
+                __nv_bfloat16 sc = scales[g * N + n];
+                __nv_bfloat16 ze = zeros[g * N + n];
+                s_scale[tid] = __bfloat162float(sc);
+                s_zero[tid] = __bfloat162float(ze);
+            }
+        }
+        __syncthreads();
+
+        for (int k_off = 0; k_off < GROUP_SIZE; k_off += BLOCK_K) {
+            int k_start = k_base + k_off;
+            int k_end = min(k_start + BLOCK_K, K);
+
+            if (tid < (k_end - k_start)) {
+                int k = k_start + tid;
+                s_x[tid] = __bfloat162float(x[m * K + k]);
+
+                int w_row = k >> 1;
+                for (int n = 0; n < BLOCK_N; ++n) {
+                    int nc = n_base + n;
+                    if (nc < N) {
+                        s_w[tid * BLOCK_N + n] = w_q[w_row * N + nc];
+                    }
+                }
+            }
+            __syncthreads();
+
+            if (tid < (k_end - k_start)) {
+                int k = k_start + tid;
+                int w_row = k >> 1;
+                bool k_even = ((k & 1) == 0);
+
+                for (int n = 0; n < BLOCK_N; ++n) {
+                    int nc = n_base + n;
+                    if (nc < N) {
+                        unsigned char wp = s_w[tid * BLOCK_N + n];
+                        unsigned char wv = k_even ? (wp & 0xF) : ((wp >> 4) & 0xF);
+                        float w_dq = ((float)wv - s_zero[n]) * s_scale[n];
+                        acc[n] += s_x[tid] * w_dq;
+                    }
+                }
+            }
+            __syncthreads();
         }
     }
 
-    y[m * N + n] = __float2bfloat16(acc);
-}
-
-torch::Tensor w4a16_kernel_py(
-    const torch::Tensor& x,
-    const torch::Tensor& w_q,
-    const torch::Tensor& scales,
-    const torch::Tensor& zeros,
-    int M, int N, int K, int n_groups
-) {
-    torch::Tensor y = torch::empty({M, N}, x.options());
-    auto x_bf16 = reinterpret_cast<const __nv_bfloat16*>(x.data_ptr());
-    auto w_q_ptr = w_q.data_ptr<unsigned char>();
-    auto scales_bf16 = reinterpret_cast<const __nv_bfloat16*>(scales.data_ptr());
-    auto zeros_bf16 = reinterpret_cast<const __nv_bfloat16*>(zeros.data_ptr());
-    auto y_bf16 = reinterpret_cast<__nv_bfloat16*>(y.data_ptr());
-
-    int BLOCK_N = 128;
-    dim3 grid((N + BLOCK_N - 1) / BLOCK_N, M, 1);
-    dim3 block(BLOCK_N, 1, 1);
-    w4a16_kernel<<<grid, block>>>(
-        x_bf16, w_q_ptr, scales_bf16, zeros_bf16, y_bf16, M, N, K, n_groups);
-    return y;
+    int n = n_base + tid;
+    if (n < N) {
+        y[m * N + n] = __float2bfloat16(acc[tid]);
+    }
 }
 """
 

--- a//home/infatoshi/cuda/KernelBench-Hard/problems/07_w4a16_gemm/solution.py
+++ b//home/infatoshi/cuda/KernelBench-Hard/problems/07_w4a16_gemm/solution.py
@@ -37,6 +37,7 @@
 #include <torch/extension.h>
 #include <cuda_bf16.h>
 
+#define GROUP_SIZE 128
 #define BLOCK_K 64
 #define BLOCK_N 128
 #define NUM_THREADS 128

--- a//home/infatoshi/cuda/KernelBench-Hard/problems/07_w4a16_gemm/solution.py
+++ b//home/infatoshi/cuda/KernelBench-Hard/problems/07_w4a16_gemm/solution.py
@@ -41,16 +41,6 @@
 #define BLOCK_K 64
 #define BLOCK_N 128
 #define NUM_THREADS 128
-
-template <typename T>
-__device__ __forceinline__ T ld_global(const T* addr) {
-    return *addr;
-}
-
-template <typename T>
-__device__ __forceinline__ void st_global(T* addr, T val) {
-    *addr = val;
-}
 
 __global__
 void w4a16_kernel(
@@ -66,10 +56,11 @@
 
     if (m >= M) return;
 
-    __shared__ float s_x[BLOCK_K];
-    __shared__ float s_scale[BLOCK_N];
-    __shared__ float s_zero[BLOCK_N];
-    __shared__ unsigned char s_w[BLOCK_K * BLOCK_N];
+    extern __shared__ char smem[];
+    float* s_x = (float*)smem;
+    float* s_scale = s_x + BLOCK_K;
+    float* s_zero = s_scale + BLOCK_N;
+    unsigned char* s_w = (unsigned char*)(s_zero + BLOCK_N);
 
     int tid = threadIdx.x;
 
@@ -78,8 +69,6 @@
     for (int j = 0; j < BLOCK_N; ++j) acc[j] = 0.0f;
 
     for (int g = 0; g < n_groups; ++g) {
-        int k_base = g * GROUP_SIZE;
-
         if (tid < BLOCK_N) {
             int n = n_base + tid;
             if (n < N) {
@@ -91,11 +80,12 @@
         }
         __syncthreads();
 
+        int k_base = g * GROUP_SIZE;
         for (int k_off = 0; k_off < GROUP_SIZE; k_off += BLOCK_K) {
             int k_start = k_base + k_off;
-            int k_end = min(k_start + BLOCK_K, K);
-
-            if (tid < (k_end - k_start)) {
+            int k_len = min(BLOCK_K, K - k_start);
+
+            if (tid < k_len) {
                 int k = k_start + tid;
                 s_x[tid] = __bfloat162float(x[m * K + k]);
 
@@ -109,9 +99,8 @@
             }
             __syncthreads();
 
-            if (tid < (k_end - k_start)) {
+            if (tid < k_len) {
                 int k = k_start + tid;
-                int w_row = k >> 1;
                 bool k_even = ((k & 1) == 0);
 
                 for (int n = 0; n < BLOCK_N; ++n) {
@@ -133,6 +122,31 @@
         y[m * N + n] = __float2bfloat16(acc[tid]);
     }
 }
+
+torch::Tensor w4a16_kernel_py(
+    const torch::Tensor& x,
+    const torch::Tensor& w_q,
+    const torch::Tensor& scales,
+    const torch::Tensor& zeros,
+    int M, int N, int K, int n_groups
+) {
+    torch::Tensor y = torch::empty({M, N}, x.options());
+    auto x_bf16 = reinterpret_cast<const __nv_bfloat16*>(x.data_ptr());
+    auto w_q_ptr = w_q.data_ptr<unsigned char>();
+    auto scales_bf16 = reinterpret_cast<const __nv_bfloat16*>(scales.data_ptr());
+    auto zeros_bf16 = reinterpret_cast<const __nv_bfloat16*>(zeros.data_ptr());
+    auto y_bf16 = reinterpret_cast<__nv_bfloat16*>(y.data_ptr());
+
+    int smem_size = (BLOCK_K + BLOCK_N + BLOCK_N + BLOCK_K * BLOCK_N) * sizeof(float);
+    smem_size = (smem_size + 0xFF) & ~0xFF;
+
+    int BLOCKS_N = (N + BLOCK_N - 1) / BLOCK_N;
+    dim3 grid(BLOCKS_N, M, 1);
+    dim3 block(NUM_THREADS, 1, 1);
+    w4a16_kernel<<<grid, block, smem_size>>>(
+        x_bf16, w_q_ptr, scales_bf16, zeros_bf16, y_bf16, M, N, K, n_groups);
+    return y;
+}
 """
 
 cpp_source = r"""

--- a//home/infatoshi/cuda/KernelBench-Hard/problems/07_w4a16_gemm/solution.py
+++ b//home/infatoshi/cuda/KernelBench-Hard/problems/07_w4a16_gemm/solution.py
@@ -1,7 +1,7 @@
     int BLOCKS_N = (N + BLOCK_N - 1) / BLOCK_N;
     dim3 grid(BLOCKS_N, M, 1);
     dim3 block(NUM_THREADS, 1, 1);
-    w4a16_kernel<<<grid, block>>>(
+    w4a16_kernel<<<grid, block, smem_size>>>(
         x_bf16, w_q_ptr, scales_bf16, zeros_bf16, y_bf16, M, N, K, n_groups);
     return y;
 }

--- a//home/infatoshi/cuda/KernelBench-Hard/problems/07_w4a16_gemm/solution.py
+++ b//home/infatoshi/cuda/KernelBench-Hard/problems/07_w4a16_gemm/solution.py
@@ -37,11 +37,6 @@
 #include <torch/extension.h>
 #include <cuda_bf16.h>
 
-#define GROUP_SIZE 128
-#define BLOCK_K 64
-#define BLOCK_N 128
-#define NUM_THREADS 128
-
 __global__
 void w4a16_kernel(
     const __nv_bfloat16* __restrict__ x,
@@ -51,76 +46,41 @@
     __nv_bfloat16* __restrict__ y,
     int M, int N, int K, int n_groups
 ) {
-    int n_base = blockIdx.x * BLOCK_N;
+    int n = blockIdx.x * blockDim.x + threadIdx.x;
     int m = blockIdx.y;
 
-    if (m >= M) return;
+    if (n >= N || m >= M) return;
 
-    extern __shared__ char smem[];
-    float* s_x = (float*)smem;
-    float* s_scale = s_x + BLOCK_K;
-    float* s_zero = s_scale + BLOCK_N;
-    unsigned char* s_w = (unsigned char*)(s_zero + BLOCK_N);
-
-    int tid = threadIdx.x;
-
-    float acc[BLOCK_N];
-    #pragma unroll
-    for (int j = 0; j < BLOCK_N; ++j) acc[j] = 0.0f;
+    float acc = 0.0f;
 
     for (int g = 0; g < n_groups; ++g) {
-        if (tid < BLOCK_N) {
-            int n = n_base + tid;
-            if (n < N) {
-                __nv_bfloat16 sc = scales[g * N + n];
-                __nv_bfloat16 ze = zeros[g * N + n];
-                s_scale[tid] = __bfloat162float(sc);
-                s_zero[tid] = __bfloat162float(ze);
-            }
-        }
-        __syncthreads();
+        int k_base = g * 128;
+        __nv_bfloat16 sc = scales[g * N + n];
+        __nv_bfloat16 ze = zeros[g * N + n];
+        float scale = __bfloat162float(sc);
+        float zero = __bfloat162float(ze);
 
-        int k_base = g * GROUP_SIZE;
-        for (int k_off = 0; k_off < GROUP_SIZE; k_off += BLOCK_K) {
-            int k_start = k_base + k_off;
-            int k_len = min(BLOCK_K, K - k_start);
+        for (int kk = 0; kk < 128; kk += 2) {
+            int k_even = k_base + kk;
+            int k_odd = k_base + kk + 1;
+            int w_row = k_even >> 1;
 
-            if (tid < k_len) {
-                int k = k_start + tid;
-                s_x[tid] = __bfloat162float(x[m * K + k]);
+            unsigned char w_p = w_q[w_row * N + n];
+            unsigned char w_e = w_p & 0xF;
+            unsigned char w_o = (w_p >> 4) & 0xF;
 
-                int w_row = k >> 1;
-                for (int n = 0; n < BLOCK_N; ++n) {
-                    int nc = n_base + n;
-                    if (nc < N) {
-                        s_w[tid * BLOCK_N + n] = w_q[w_row * N + nc];
-                    }
-                }
-            }
-            __syncthreads();
+            float w_deq_e = ((float)w_e - zero) * scale;
+            float w_deq_o = ((float)w_o - zero) * scale;
 
-            if (tid < k_len) {
-                int k = k_start + tid;
-                bool k_even = ((k & 1) == 0);
+            float x_e = __bfloat162float(x[m * K + k_even]);
+            float x_o = __bfloat162float(x[m * K + k_odd]);
 
-                for (int n = 0; n < BLOCK_N; ++n) {
-                    int nc = n_base + n;
-                    if (nc < N) {
-                        unsigned char wp = s_w[tid * BLOCK_N + n];
-                        unsigned char wv = k_even ? (wp & 0xF) : ((wp >> 4) & 0xF);
-                        float w_dq = ((float)wv - s_zero[n]) * s_scale[n];
-                        acc[n] += s_x[tid] * w_dq;
-                    }
-                }
-            }
-            __syncthreads();
+            acc += x_e * w_deq_e;
+            acc += x_o * w_deq_o;
         }
     }
 
-    int n = n_base + tid;
-    if (n < N) {
-        y[m * N + n] = __float2bfloat16(acc[tid]);
-    }
+    y[m * N + n] = __float2bfloat16(acc);
 }
 
 torch::Tensor w4a16_kernel_py(
@@ -137,13 +97,10 @@
     auto zeros_bf16 = reinterpret_cast<const __nv_bfloat16*>(zeros.data_ptr());
     auto y_bf16 = reinterpret_cast<__nv_bfloat16*>(y.data_ptr());
 
-    int smem_size = (BLOCK_K + BLOCK_N + BLOCK_N + BLOCK_K * BLOCK_N) * sizeof(float);
-    smem_size = (smem_size + 0xFF) & ~0xFF;
-
-    int BLOCKS_N = (N + BLOCK_N - 1) / BLOCK_N;
-    dim3 grid(BLOCKS_N, M, 1);
-    dim3 block(NUM_THREADS, 1, 1);
-    w4a16_kernel<<<grid, block, smem_size>>>(
+    int BLOCK_N = 128;
+    dim3 grid((N + BLOCK_N - 1) / BLOCK_N, M, 1);
+    dim3 block(BLOCK_N, 1, 1);
+    w4a16_kernel<<<grid, block>>>(
         x_bf16, w_q_ptr, scales_bf16, zeros_bf16, y_bf16, M, N, K, n_groups);
     return y;
 }

--- a//home/infatoshi/cuda/KernelBench-Hard/problems/07_w4a16_gemm/solution.py
+++ b//home/infatoshi/cuda/KernelBench-Hard/problems/07_w4a16_gemm/solution.py
@@ -36,6 +36,12 @@
 cuda_source = r"""
 #include <torch/extension.h>
 #include <cuda_bf16.h>
+
+#define GROUP_SIZE 128
+#define BLOCK_K 64
+#define BLOCK_N 128
+#define NUM_THREADS 128
+#define WARP_SIZE 32
 
 __global__
 void w4a16_kernel(
@@ -46,41 +52,80 @@
     __nv_bfloat16* __restrict__ y,
     int M, int N, int K, int n_groups
 ) {
-    int n = blockIdx.x * blockDim.x + threadIdx.x;
+    int n_base = blockIdx.x * BLOCK_N;
     int m = blockIdx.y;
 
-    if (n >= N || m >= M) return;
-
-    float acc = 0.0f;
+    if (m >= M) return;
+    if (n_base >= N) return;
+
+    extern __shared__ char smem[];
+    float* s_scale = (float*)smem;
+    float* s_zero = s_scale + BLOCK_N;
+    float* s_x = s_zero + BLOCK_N;
+    unsigned char* s_w = (unsigned char*)(s_x + BLOCK_K);
+
+    int tid = threadIdx.x;
+    int wid = tid / WARP_SIZE;
+    int lane = tid % WARP_SIZE;
+
+    float acc[4];
+    #pragma unroll
+    for (int j = 0; j < 4; ++j) acc[j] = 0.0f;
 
     for (int g = 0; g < n_groups; ++g) {
-        int k_base = g * 128;
-        __nv_bfloat16 sc = scales[g * N + n];
-        __nv_bfloat16 ze = zeros[g * N + n];
-        float scale = __bfloat162float(sc);
-        float zero = __bfloat162float(ze);
-
-        for (int kk = 0; kk < 128; kk += 2) {
-            int k_even = k_base + kk;
-            int k_odd = k_base + kk + 1;
-            int w_row = k_even >> 1;
-
-            unsigned char w_p = w_q[w_row * N + n];
-            unsigned char w_e = w_p & 0xF;
-            unsigned char w_o = (w_p >> 4) & 0xF;
-
-            float w_deq_e = ((float)w_e - zero) * scale;
-            float w_deq_o = ((float)w_o - zero) * scale;
-
-            float x_e = __bfloat162float(x[m * K + k_even]);
-            float x_o = __bfloat162float(x[m * K + k_odd]);
-
-            acc += x_e * w_deq_e;
-            acc += x_o * w_deq_o;
+        if (lane < BLOCK_N / 4) {
+            int n = n_base + lane * 4;
+            if (n < N) {
+                __nv_bfloat16 sc = scales[g * N + n];
+                __nv_bfloat16 ze = zeros[g * N + n];
+                s_scale[lane * 4] = __bfloat162float(sc);
+                s_zero[lane * 4] = __bfloat162float(ze);
+            }
+        }
+        __syncthreads();
+
+        int k_base = g * GROUP_SIZE;
+        for (int k_off = 0; k_off < GROUP_SIZE; k_off += BLOCK_K) {
+            int k_start = k_base + k_off;
+            int k_len = min(BLOCK_K, K - k_start);
+
+            if (tid < k_len) {
+                int k = k_start + tid;
+                s_x[tid] = __bfloat162float(x[m * K + k]);
+
+                int w_row = k >> 1;
+                unsigned char wp = w_q[w_row * N + n_base + tid];
+                s_w[tid] = wp;
+            }
+            __syncthreads();
+
+            if (tid < k_len) {
+                int k = k_start + tid;
+                bool k_even = ((k & 1) == 0);
+
+                unsigned char wp = s_w[tid];
+                unsigned char wv = k_even ? (wp & 0xF) : ((wp >> 4) & 0xF);
+
+                #pragma unroll
+                for (int j = 0; j < 4; ++j) {
+                    int nc = lane * 4 + j;
+                    float w_dq = ((float)wv - s_zero[nc]) * s_scale[nc];
+                    acc[j] += s_x[tid] * w_dq;
+                }
+            }
+            __syncthreads();
         }
     }
 
-    y[m * N + n] = __float2bfloat16(acc);
+    if (lane < BLOCK_N / 4) {
+        int n = n_base + lane * 4;
+        #pragma unroll
+        for (int j = 0; j < 4; ++j) {
+            if (n + j < N) {
+                y[m * N + n + j] = __float2bfloat16(acc[j]);
+            }
+        }
+    }
 }
 
 torch::Tensor w4a16_kernel_py(
@@ -97,10 +142,13 @@
     auto zeros_bf16 = reinterpret_cast<const __nv_bfloat16*>(zeros.data_ptr());
     auto y_bf16 = reinterpret_cast<__nv_bfloat16*>(y.data_ptr());
 
-    int BLOCK_N = 128;
-    dim3 grid((N + BLOCK_N - 1) / BLOCK_N, M, 1);
-    dim3 block(BLOCK_N, 1, 1);
-    w4a16_kernel<<<grid, block>>>(
+    int smem_size = (2 * BLOCK_N + BLOCK_K + BLOCK_K) * sizeof(float);
+    smem_size = (smem_size + 0xFF) & ~0xFF;
+
+    int BLOCKS_N = (N + BLOCK_N - 1) / BLOCK_N;
+    dim3 grid(BLOCKS_N, M, 1);
+    dim3 block(NUM_THREADS, 1, 1);
+    w4a16_kernel<<<grid, block, smem_size>>>(
         x_bf16, w_q_ptr, scales_bf16, zeros_bf16, y_bf16, M, N, K, n_groups);
     return y;
 }

--- a//home/infatoshi/cuda/KernelBench-Hard/problems/07_w4a16_gemm/solution.py
+++ b//home/infatoshi/cuda/KernelBench-Hard/problems/07_w4a16_gemm/solution.py
@@ -40,8 +40,7 @@
 #define GROUP_SIZE 128
 #define BLOCK_K 64
 #define BLOCK_N 128
-#define NUM_THREADS 128
-#define WARP_SIZE 32
+#define THREADS_N 128
 
 __global__
 void w4a16_kernel(
@@ -52,80 +51,42 @@
     __nv_bfloat16* __restrict__ y,
     int M, int N, int K, int n_groups
 ) {
-    int n_base = blockIdx.x * BLOCK_N;
+    int n = blockIdx.x * THREADS_N + threadIdx.x;
     int m = blockIdx.y;
 
-    if (m >= M) return;
-    if (n_base >= N) return;
+    if (n >= N || m >= M) return;
 
-    extern __shared__ char smem[];
-    float* s_scale = (float*)smem;
-    float* s_zero = s_scale + BLOCK_N;
-    float* s_x = s_zero + BLOCK_N;
-    unsigned char* s_w = (unsigned char*)(s_x + BLOCK_K);
-
-    int tid = threadIdx.x;
-    int wid = tid / WARP_SIZE;
-    int lane = tid % WARP_SIZE;
-
-    float acc[4];
-    #pragma unroll
-    for (int j = 0; j < 4; ++j) acc[j] = 0.0f;
+    float acc = 0.0f;
 
     for (int g = 0; g < n_groups; ++g) {
-        if (lane < BLOCK_N / 4) {
-            int n = n_base + lane * 4;
-            if (n < N) {
-                __nv_bfloat16 sc = scales[g * N + n];
-                __nv_bfloat16 ze = zeros[g * N + n];
-                s_scale[lane * 4] = __bfloat162float(sc);
-                s_zero[lane * 4] = __bfloat162float(ze);
-            }
-        }
-        __syncthreads();
+        int k_base = g * GROUP_SIZE;
 
-        int k_base = g * GROUP_SIZE;
-        for (int k_off = 0; k_off < GROUP_SIZE; k_off += BLOCK_K) {
-            int k_start = k_base + k_off;
-            int k_len = min(BLOCK_K, K - k_start);
+        __nv_bfloat16 sc = scales[g * N + n];
+        __nv_bfloat16 ze = zeros[g * N + n];
+        float scale = __bfloat162float(sc);
+        float zero = __bfloat162float(ze);
 
-            if (tid < k_len) {
-                int k = k_start + tid;
-                s_x[tid] = __bfloat162float(x[m * K + k]);
+        for (int k_off = 0; k_off < GROUP_SIZE; k_off += 2) {
+            int k_even = k_base + k_off;
+            int k_odd = k_base + k_off + 1;
+            int w_row = k_even >> 1;
 
-                int w_row = k >> 1;
-                unsigned char wp = w_q[w_row * N + n_base + tid];
-                s_w[tid] = wp;
-            }
-            __syncthreads();
+            unsigned char wp = w_q[w_row * N + n];
+            unsigned char w_even = wp & 0xF;
+            unsigned char w_odd = (wp >> 4) & 0xF;
 
-            if (tid < k_len) {
-                int k = k_start + tid;
-                bool k_even = ((k & 1) == 0);
+            float w_deq_even = ((float)w_even - zero) * scale;
+            float w_deq_odd = ((float)w_odd - zero) * scale;
 
-                unsigned char wp = s_w[tid];
-                unsigned char wv = k_even ? (wp & 0xF) : ((wp >> 4) & 0xF);
+            float x_even = __bfloat162float(x[m * K + k_even]);
+            float x_odd = __bfloat162float(x[m * K + k_odd]);
 
-                #pragma unroll
-                for (int j = 0; j < 4; ++j) {
-                    int nc = lane * 4 + j;
-                    float w_dq = ((float)wv - s_zero[nc]) * s_scale[nc];
-                    acc[j] += s_x[tid] * w_dq;
-                }
-            }
-            __syncthreads();
+            acc += x_even * w_deq_even;
+            acc += x_odd * w_deq_odd;
         }
     }
 
-    if (lane < BLOCK_N / 4) {
-        int n = n_base + lane * 4;
-        #pragma unroll
-        for (int j = 0; j < 4; ++j) {
-            if (n + j < N) {
-                y[m * N + n + j] = __float2bfloat16(acc[j]);
-            }
-        }
-    }
+    y[m * N + n] = __float2bfloat16(acc);
 }
 
 torch::Tensor w4a16_kernel_py(
@@ -142,13 +103,9 @@
     auto zeros_bf16 = reinterpret_cast<const __nv_bfloat16*>(zeros.data_ptr());
     auto y_bf16 = reinterpret_cast<__nv_bfloat16*>(y.data_ptr());
 
-    int smem_size = (2 * BLOCK_N + BLOCK_K + BLOCK_K) * sizeof(float);
-    smem_size = (smem_size + 0xFF) & ~0xFF;
-
-    int BLOCKS_N = (N + BLOCK_N - 1) / BLOCK_N;
-    dim3 grid(BLOCKS_N, M, 1);
-    dim3 block(NUM_THREADS, 1, 1);
-    w4a16_kernel<<<grid, block, smem_size>>>(
+    dim3 grid((N + THREADS_N - 1) / THREADS_N, M, 1);
+    dim3 block(THREADS_N, 1, 1);
+    w4a16_kernel<<<grid, block>>>(
         x_bf16, w_q_ptr, scales_bf16, zeros_bf16, y_bf16, M, N, K, n_groups);
     return y;
 }

--- a//home/infatoshi/cuda/KernelBench-Hard/problems/07_w4a16_gemm/solution.py
+++ b//home/infatoshi/cuda/KernelBench-Hard/problems/07_w4a16_gemm/solution.py
@@ -38,9 +38,7 @@
 #include <cuda_bf16.h>
 
 #define GROUP_SIZE 128
-#define BLOCK_K 64
-#define BLOCK_N 128
-#define THREADS_N 128
+#define THREADS_N 256
 
 __global__
 void w4a16_kernel(
@@ -66,23 +64,23 @@
         float scale = __bfloat162float(sc);
         float zero = __bfloat162float(ze);
 
-        for (int k_off = 0; k_off < GROUP_SIZE; k_off += 2) {
-            int k_even = k_base + k_off;
-            int k_odd = k_base + k_off + 1;
+        for (int kk = 0; kk < 128; kk += 2) {
+            int k_even = k_base + kk;
+            int k_odd = k_base + kk + 1;
             int w_row = k_even >> 1;
 
             unsigned char wp = w_q[w_row * N + n];
-            unsigned char w_even = wp & 0xF;
-            unsigned char w_odd = (wp >> 4) & 0xF;
+            unsigned char w_e = wp & 0xF;
+            unsigned char w_o = (wp >> 4) & 0xF;
 
-            float w_deq_even = ((float)w_even - zero) * scale;
-            float w_deq_odd = ((float)w_odd - zero) * scale;
+            float w_deq_e = ((float)w_e - zero) * scale;
+            float w_deq_o = ((float)w_o - zero) * scale;
 
-            float x_even = __bfloat162float(x[m * K + k_even]);
-            float x_odd = __bfloat162float(x[m * K + k_odd]);
+            float x_e = __bfloat162float(x[m * K + k_even]);
+            float x_o = __bfloat162float(x[m * K + k_odd]);
 
-            acc += x_even * w_deq_even;
-            acc += x_odd * w_deq_odd;
+            acc += x_e * w_deq_e;
+            acc += x_o * w_deq_o;
         }
     }
 

--- a//home/infatoshi/cuda/KernelBench-Hard/problems/07_w4a16_gemm/solution.py
+++ b//home/infatoshi/cuda/KernelBench-Hard/problems/07_w4a16_gemm/solution.py
@@ -38,7 +38,9 @@
 #include <cuda_bf16.h>
 
 #define GROUP_SIZE 128
-#define THREADS_N 256
+#define BLOCK_M 4
+#define BLOCK_N 128
+#define THREADS (BLOCK_M * BLOCK_N)
 
 __global__
 void w4a16_kernel(
@@ -49,42 +51,82 @@
     __nv_bfloat16* __restrict__ y,
     int M, int N, int K, int n_groups
 ) {
-    int n = blockIdx.x * THREADS_N + threadIdx.x;
-    int m = blockIdx.y;
-
-    if (n >= N || m >= M) return;
-
-    float acc = 0.0f;
+    int n_block = blockIdx.x;
+    int m_block = blockIdx.y;
+    int tid = threadIdx.x;
+
+    int n_start = n_block * BLOCK_N;
+    int m_start = m_block * BLOCK_M;
+
+    if (m_start >= M || n_start >= N) return;
+
+    __shared__ float s_x[GROUP_SIZE * BLOCK_M];
+    __shared__ float s_scale[BLOCK_N];
+    __shared__ float s_zero[BLOCK_N];
+
+    float acc[BLOCK_M];
+    #pragma unroll
+    for (int i = 0; i < BLOCK_M; ++i) acc[i] = 0.0f;
 
     for (int g = 0; g < n_groups; ++g) {
+        if (tid < BLOCK_N) {
+            int n = n_start + tid;
+            if (n < N) {
+                __nv_bfloat16 sc = scales[g * N + n];
+                __nv_bfloat16 ze = zeros[g * N + n];
+                s_scale[tid] = __bfloat162float(sc);
+                s_zero[tid] = __bfloat162float(ze);
+            }
+        }
+
         int k_base = g * GROUP_SIZE;
-
-        __nv_bfloat16 sc = scales[g * N + n];
-        __nv_bfloat16 ze = zeros[g * N + n];
-        float scale = __bfloat162float(sc);
-        float zero = __bfloat162float(ze);
-
-        for (int kk = 0; kk < 128; kk += 2) {
+        if (tid < GROUP_SIZE * BLOCK_M) {
+            int kidx = tid / BLOCK_M;
+            int midx = tid % BLOCK_M;
+            int m = m_start + midx;
+            int k = k_base + kidx;
+            if (m < M && k < K) {
+                s_x[kidx * BLOCK_M + midx] = __bfloat162float(x[m * K + k]);
+            }
+        }
+        __syncthreads();
+
+        for (int kk = 0; kk < GROUP_SIZE; kk += 2) {
             int k_even = k_base + kk;
             int k_odd = k_base + kk + 1;
-            int w_row = k_even >> 1;
-
-            unsigned char wp = w_q[w_row * N + n];
-            unsigned char w_e = wp & 0xF;
-            unsigned char w_o = (wp >> 4) & 0xF;
-
-            float w_deq_e = ((float)w_e - zero) * scale;
-            float w_deq_o = ((float)w_o - zero) * scale;
-
-            float x_e = __bfloat162float(x[m * K + k_even]);
-            float x_o = __bfloat162float(x[m * K + k_odd]);
-
-            acc += x_e * w_deq_e;
-            acc += x_o * w_deq_o;
-        }
+
+            #pragma unroll
+            for (int i = 0; i < BLOCK_M; ++i) {
+                int m = m_start + i;
+                if (m < M) {
+                    float x_even_val = s_x[kk * BLOCK_M + i];
+                    float x_odd_val = s_x[(kk + 1) * BLOCK_M + i];
+
+                    int w_row_even = k_even >> 1;
+                    unsigned char wp_even = w_q[w_row_even * N + n_start + tid];
+
+                    unsigned char w_even_lo = wp_even & 0xF;
+                    unsigned char w_odd_lo = (wp_even >> 4) & 0xF;
+
+                    float w_deq_even = ((float)w_even_lo - s_zero[tid]) * s_scale[tid];
+                    float w_deq_odd = ((float)w_odd_lo - s_zero[tid]) * s_scale[tid];
+
+                    acc[i] += x_even_val * w_deq_even;
+                    acc[i] += x_odd_val * w_deq_odd;
+                }
+            }
+        }
+        __syncthreads();
     }
 
-    y[m * N + n] = __float2bfloat16(acc);
+    #pragma unroll
+    for (int i = 0; i < BLOCK_M; ++i) {
+        int m = m_start + i;
+        int n = n_start + tid;
+        if (m < M && n < N) {
+            y[m * N + n] = __float2bfloat16(acc[i]);
+        }
+    }
 }
 
 torch::Tensor w4a16_kernel_py(
@@ -101,9 +143,12 @@
     auto zeros_bf16 = reinterpret_cast<const __nv_bfloat16*>(zeros.data_ptr());
     auto y_bf16 = reinterpret_cast<__nv_bfloat16*>(y.data_ptr());
 
-    dim3 grid((N + THREADS_N - 1) / THREADS_N, M, 1);
-    dim3 block(THREADS_N, 1, 1);
-    w4a16_kernel<<<grid, block>>>(
+    int smem_size = (GROUP_SIZE * BLOCK_M + 2 * BLOCK_N) * sizeof(float);
+    int BLOCKS_N = (N + BLOCK_N - 1) / BLOCK_N;
+    int BLOCKS_M = (M + BLOCK_M - 1) / BLOCK_M;
+    dim3 grid(BLOCKS_N, BLOCKS_M, 1);
+    dim3 block(THREADS, 1, 1);
+    w4a16_kernel<<<grid, block, smem_size>>>(
         x_bf16, w_q_ptr, scales_bf16, zeros_bf16, y_bf16, M, N, K, n_groups);
     return y;
 }

--- a//home/infatoshi/cuda/KernelBench-Hard/problems/07_w4a16_gemm/solution.py
+++ b//home/infatoshi/cuda/KernelBench-Hard/problems/07_w4a16_gemm/solution.py
@@ -38,9 +38,12 @@
 #include <cuda_bf16.h>
 
 #define GROUP_SIZE 128
-#define BLOCK_M 4
-#define BLOCK_N 128
-#define THREADS (BLOCK_M * BLOCK_N)
+#define THREADS_N 256
+#define WARP_SIZE 32
+
+__device__ __forceinline__ float2 bf162float2(__nv_bfloat162 h) {
+    return __nv_bfloat162float(h);
+}
 
 __global__
 void w4a16_kernel(
@@ -51,82 +54,40 @@
     __nv_bfloat16* __restrict__ y,
     int M, int N, int K, int n_groups
 ) {
-    int n_block = blockIdx.x;
-    int m_block = blockIdx.y;
-    int tid = threadIdx.x;
+    int n = blockIdx.x * THREADS_N + threadIdx.x;
+    int m = blockIdx.y;
 
-    int n_start = n_block * BLOCK_N;
-    int m_start = m_block * BLOCK_M;
+    if (n >= N || m >= M) return;
 
-    if (m_start >= M || n_start >= N) return;
-
-    __shared__ float s_x[GROUP_SIZE * BLOCK_M];
-    __shared__ float s_scale[BLOCK_N];
-    __shared__ float s_zero[BLOCK_N];
-
-    float acc[BLOCK_M];
-    #pragma unroll
-    for (int i = 0; i < BLOCK_M; ++i) acc[i] = 0.0f;
+    float acc = 0.0f;
 
     for (int g = 0; g < n_groups; ++g) {
-        if (tid < BLOCK_N) {
-            int n = n_start + tid;
-            if (n < N) {
-                __nv_bfloat16 sc = scales[g * N + n];
-                __nv_bfloat16 ze = zeros[g * N + n];
-                s_scale[tid] = __bfloat162float(sc);
-                s_zero[tid] = __bfloat162float(ze);
-            }
-        }
+        int k_base = g * GROUP_SIZE;
 
-        int k_base = g * GROUP_SIZE;
-        if (tid < GROUP_SIZE * BLOCK_M) {
-            int kidx = tid / BLOCK_M;
-            int midx = tid % BLOCK_M;
-            int m = m_start + midx;
-            int k = k_base + kidx;
-            if (m < M && k < K) {
-                s_x[kidx * BLOCK_M + midx] = __bfloat162float(x[m * K + k]);
-            }
-        }
-        __syncthreads();
+        float scale = __bfloat162float(scales[g * N + n]);
+        float zero = __bfloat162float(zeros[g * N + n]);
 
-        for (int kk = 0; kk < GROUP_SIZE; kk += 2) {
+        for (int kk = 0; kk < 128; kk += 2) {
             int k_even = k_base + kk;
             int k_odd = k_base + kk + 1;
+            int w_row = k_even >> 1;
 
-            #pragma unroll
-            for (int i = 0; i < BLOCK_M; ++i) {
-                int m = m_start + i;
-                if (m < M) {
-                    float x_even_val = s_x[kk * BLOCK_M + i];
-                    float x_odd_val = s_x[(kk + 1) * BLOCK_M + i];
+            unsigned char wp = w_q[w_row * N + n];
+            unsigned char w_even_val = wp & 0xF;
+            unsigned char w_odd_val = (wp >> 4) & 0xF;
 
-                    int w_row_even = k_even >> 1;
-                    unsigned char wp_even = w_q[w_row_even * N + n_start + tid];
+            float w_deq_even = ((float)w_even_val - zero) * scale;
+            float w_deq_odd = ((float)w_odd_val - zero) * scale;
 
-                    unsigned char w_even_lo = wp_even & 0xF;
-                    unsigned char w_odd_lo = (wp_even >> 4) & 0xF;
+            float x_even = __bfloat162float(x[m * K + k_even]);
+            float x_odd = __bfloat162float(x[m * K + k_odd]);
 
-                    float w_deq_even = ((float)w_even_lo - s_zero[tid]) * s_scale[tid];
-                    float w_deq_odd = ((float)w_odd_lo - s_zero[tid]) * s_scale[tid];
-
-                    acc[i] += x_even_val * w_deq_even;
-                    acc[i] += x_odd_val * w_deq_odd;
-                }
-            }
+            acc += x_even * w_deq_even;
+            acc += x_odd * w_deq_odd;
         }
-        __syncthreads();
     }
 
-    #pragma unroll
-    for (int i = 0; i < BLOCK_M; ++i) {
-        int m = m_start + i;
-        int n = n_start + tid;
-        if (m < M && n < N) {
-            y[m * N + n] = __float2bfloat16(acc[i]);
-        }
-    }
+    y[m * N + n] = __float2bfloat16(acc);
 }
 
 torch::Tensor w4a16_kernel_py(
@@ -143,12 +104,9 @@
     auto zeros_bf16 = reinterpret_cast<const __nv_bfloat16*>(zeros.data_ptr());
     auto y_bf16 = reinterpret_cast<__nv_bfloat16*>(y.data_ptr());
 
-    int smem_size = (GROUP_SIZE * BLOCK_M + 2 * BLOCK_N) * sizeof(float);
-    int BLOCKS_N = (N + BLOCK_N - 1) / BLOCK_N;
-    int BLOCKS_M = (M + BLOCK_M - 1) / BLOCK_M;
-    dim3 grid(BLOCKS_N, BLOCKS_M, 1);
-    dim3 block(THREADS, 1, 1);
-    w4a16_kernel<<<grid, block, smem_size>>>(
+    dim3 grid((N + THREADS_N - 1) / THREADS_N, M, 1);
+    dim3 block(THREADS_N, 1, 1);
+    w4a16_kernel<<<grid, block>>>(
         x_bf16, w_q_ptr, scales_bf16, zeros_bf16, y_bf16, M, N, K, n_groups);
     return y;
 }

--- a//home/infatoshi/cuda/KernelBench-Hard/problems/07_w4a16_gemm/solution.py
+++ b//home/infatoshi/cuda/KernelBench-Hard/problems/07_w4a16_gemm/solution.py
@@ -39,11 +39,6 @@
 
 #define GROUP_SIZE 128
 #define THREADS_N 256
-#define WARP_SIZE 32
-
-__device__ __forceinline__ float2 bf162float2(__nv_bfloat162 h) {
-    return __nv_bfloat162float(h);
-}
 
 __global__
 void w4a16_kernel(

--- a//home/infatoshi/cuda/KernelBench-Hard/problems/07_w4a16_gemm/solution.py
+++ b//home/infatoshi/cuda/KernelBench-Hard/problems/07_w4a16_gemm/solution.py
@@ -56,30 +56,527 @@
 
     float acc = 0.0f;
 
+    const __nv_bfloat16* x_row = x + m * K;
+
     for (int g = 0; g < n_groups; ++g) {
         int k_base = g * GROUP_SIZE;
 
         float scale = __bfloat162float(scales[g * N + n]);
         float zero = __bfloat162float(zeros[g * N + n]);
 
-        for (int kk = 0; kk < 128; kk += 2) {
-            int k_even = k_base + kk;
-            int k_odd = k_base + kk + 1;
-            int w_row = k_even >> 1;
-
-            unsigned char wp = w_q[w_row * N + n];
-            unsigned char w_even_val = wp & 0xF;
-            unsigned char w_odd_val = (wp >> 4) & 0xF;
-
-            float w_deq_even = ((float)w_even_val - zero) * scale;
-            float w_deq_odd = ((float)w_odd_val - zero) * scale;
-
-            float x_even = __bfloat162float(x[m * K + k_even]);
-            float x_odd = __bfloat162float(x[m * K + k_odd]);
-
-            acc += x_even * w_deq_even;
-            acc += x_odd * w_deq_odd;
-        }
+        int w_row_base = k_base >> 1;
+
+        unsigned char wp0 = w_q[w_row_base * N + n];
+        unsigned char w0_e = wp0 & 0xF;
+        unsigned char w0_o = (wp0 >> 4) & 0xF;
+        float x0_e = __bfloat162float(x_row[k_base]);
+        float x0_o = __bfloat162float(x_row[k_base + 1]);
+        acc += x0_e * (((float)w0_e - zero) * scale);
+        acc += x0_o * (((float)w0_o - zero) * scale);
+
+        unsigned char wp1 = w_q[(w_row_base + 1) * N + n];
+        unsigned char w1_e = wp1 & 0xF;
+        unsigned char w1_o = (wp1 >> 4) & 0xF;
+        float x1_e = __bfloat162float(x_row[k_base + 2]);
+        float x1_o = __bfloat162float(x_row[k_base + 3]);
+        acc += x1_e * (((float)w1_e - zero) * scale);
+        acc += x1_o * (((float)w1_o - zero) * scale);
+
+        unsigned char wp2 = w_q[(w_row_base + 2) * N + n];
+        unsigned char w2_e = wp2 & 0xF;
+        unsigned char w2_o = (wp2 >> 4) & 0xF;
+        float x2_e = __bfloat162float(x_row[k_base + 4]);
+        float x2_o = __bfloat162float(x_row[k_base + 5]);
+        acc += x2_e * (((float)w2_e - zero) * scale);
+        acc += x2_o * (((float)w2_o - zero) * scale);
+
+        unsigned char wp3 = w_q[(w_row_base + 3) * N + n];
+        unsigned char w3_e = wp3 & 0xF;
+        unsigned char w3_o = (wp3 >> 4) & 0xF;
+        float x3_e = __bfloat162float(x_row[k_base + 6]);
+        float x3_o = __bfloat162float(x_row[k_base + 7]);
+        acc += x3_e * (((float)w3_e - zero) * scale);
+        acc += x3_o * (((float)w3_o - zero) * scale);
+
+        unsigned char wp4 = w_q[(w_row_base + 4) * N + n];
+        unsigned char w4_e = wp4 & 0xF;
+        unsigned char w4_o = (wp4 >> 4) & 0xF;
+        float x4_e = __bfloat162float(x_row[k_base + 8]);
+        float x4_o = __bfloat162float(x_row[k_base + 9]);
+        acc += x4_e * (((float)w4_e - zero) * scale);
+        acc += x4_o * (((float)w4_o - zero) * scale);
+
+        unsigned char wp5 = w_q[(w_row_base + 5) * N + n];
+        unsigned char w5_e = wp5 & 0xF;
+        unsigned char w5_o = (wp5 >> 4) & 0xF;
+        float x5_e = __bfloat162float(x_row[k_base + 10]);
+        float x5_o = __bfloat162float(x_row[k_base + 11]);
+        acc += x5_e * (((float)w5_e - zero) * scale);
+        acc += x5_o * (((float)w5_o - zero) * scale);
+
+        unsigned char wp6 = w_q[(w_row_base + 6) * N + n];
+        unsigned char w6_e = wp6 & 0xF;
+        unsigned char w6_o = (wp6 >> 4) & 0xF;
+        float x6_e = __bfloat162float(x_row[k_base + 12]);
+        float x6_o = __bfloat162float(x_row[k_base + 13]);
+        acc += x6_e * (((float)w6_e - zero) * scale);
+        acc += x6_o * (((float)w6_o - zero) * scale);
+
+        unsigned char wp7 = w_q[(w_row_base + 7) * N + n];
+        unsigned char w7_e = wp7 & 0xF;
+        unsigned char w7_o = (wp7 >> 4) & 0xF;
+        float x7_e = __bfloat162float(x_row[k_base + 14]);
+        float x7_o = __bfloat162float(x_row[k_base + 15]);
+        acc += x7_e * (((float)w7_e - zero) * scale);
+        acc += x7_o * (((float)w7_o - zero) * scale);
+
+        unsigned char wp8 = w_q[(w_row_base + 8) * N + n];
+        unsigned char w8_e = wp8 & 0xF;
+        unsigned char w8_o = (wp8 >> 4) & 0xF;
+        float x8_e = __bfloat162float(x_row[k_base + 16]);
+        float x8_o = __bfloat162float(x_row[k_base + 17]);
+        acc += x8_e * (((float)w8_e - zero) * scale);
+        acc += x8_o * (((float)w8_o - zero) * scale);
+
+        unsigned char wp9 = w_q[(w_row_base + 9) * N + n];
+        unsigned char w9_e = wp9 & 0xF;
+        unsigned char w9_o = (wp9 >> 4) & 0xF;
+        float x9_e = __bfloat162float(x_row[k_base + 18]);
+        float x9_o = __bfloat162float(x_row[k_base + 19]);
+        acc += x9_e * (((float)w9_e - zero) * scale);
+        acc += x9_o * (((float)w9_o - zero) * scale);
+
+        unsigned char wp10 = w_q[(w_row_base + 10) * N + n];
+        unsigned char w10_e = wp10 & 0xF;
+        unsigned char w10_o = (wp10 >> 4) & 0xF;
+        float x10_e = __bfloat162float(x_row[k_base + 20]);
+        float x10_o = __bfloat162float(x_row[k_base + 21]);
+        acc += x10_e * (((float)w10_e - zero) * scale);
+        acc += x10_o * (((float)w10_o - zero) * scale);
+
+        unsigned char wp11 = w_q[(w_row_base + 11) * N + n];
+        unsigned char w11_e = wp11 & 0xF;
+        unsigned char w11_o = (wp11 >> 4) & 0xF;
+        float x11_e = __bfloat162float(x_row[k_base + 22]);
+        float x11_o = __bfloat162float(x_row[k_base + 23]);
+        acc += x11_e * (((float)w11_e - zero) * scale);
+        acc += x11_o * (((float)w11_o - zero) * scale);
+
+        unsigned char wp12 = w_q[(w_row_base + 12) * N + n];
+        unsigned char w12_e = wp12 & 0xF;
+        unsigned char w12_o = (wp12 >> 4) & 0xF;
+        float x12_e = __bfloat162float(x_row[k_base + 24]);
+        float x12_o = __bf

... (20271 more chars)