Add qwen35-2b-fp32-int8-g32-exclude-l6-l9-l10up-l15o-home-token-major-v2-v4 (tiled prefill GEMM over the v3 bundle) (part 2)

.gitattributes

@@ -70,3 +70,4 @@ qwen35-08b-fp32-int8-attn-int4-mlp-gptq-home-token-major-v2-v4/tokenizer/tokeniz
 qwen35-08b-fp32-int8-g32-home-token-major-v2-v4/graph.json filter=lfs diff=lfs merge=lfs -text
 qwen35-08b-fp32-int8-g32-home-token-major-v2-v4/tokenizer/tokenizer.json filter=lfs diff=lfs merge=lfs -text
 qwen35-2b-fp32-int8-g32-exclude-l6-l9-l10up-l15o-home-token-major-v2-v4/graph.json filter=lfs diff=lfs merge=lfs -text
+qwen35-2b-fp32-int8-g32-exclude-l6-l9-l10up-l15o-home-token-major-v2-v4/tokenizer/tokenizer.json filter=lfs diff=lfs merge=lfs -text

qwen35-2b-fp32-int8-g32-exclude-l6-l9-l10up-l15o-home-token-major-v2-v4/kernels/9e92e586bb26ecd87c2080b364abbe2d6761b1f165d4d8bbd0170a88b01626e1.wgsl

@@ -0,0 +1,71 @@
+@group(0) @binding(0) var<storage, read> b0: array<f32>;
+@group(0) @binding(1) var<storage, read> b1: array<u32>;
+@group(0) @binding(2) var<storage, read> b2: array<f32>;
+@group(0) @binding(3) var<storage, read_write> out: array<f32>;
+fn dequant_1(index: u32) -> f32 {
+    let row = index / 2048u;
+    let col = index % 2048u;
+    let word = b1[row * 512u + col / 4u];
+    let code = i32((word >> ((col % 4u) * 8u)) & 255u) - 128;
+    return f32(code) * b2[row * 64u + col / 32u];
+}
+
+var<workgroup> tile_a: array<array<f32, 16>, 16>;
+var<workgroup> tile_b: array<array<f32, 64>, 16>;
+@compute @workgroup_size(16, 16)
+fn main(@builtin(workgroup_id) group: vec3<u32>, @builtin(local_invocation_id) local: vec3<u32>) {
+    let lane = local.y * 16u + local.x;
+    let batch = group.z;
+    let tile_n = group.x * 64u;
+    let tile_row = group.y * 16u;
+    var acc: array<array<f32, 4>, 1>;
+    for (var k0 = 0u; k0 < 2048u; k0 += 16u) {
+        for (var e = 0u; e < 1u; e++) {
+            let flat = lane + e * 256u;
+            let m_local = flat / 16u;
+            let row = tile_row + m_local;
+            let col = k0 + flat % 16u;
+            var value = 0.0;
+            if (row < 16u && col < 2048u) { value = f32(f32(b0[(batch * 16u + row) * 2048u + col])); }
+            tile_a[m_local][flat % 16u] = value;
+        }
+        if (lane < 256u) {
+            let n_local = lane / 4u;
+            let word_local = lane % 4u;
+            let n_index = tile_n + n_local;
+            let first = k0 + word_local * 4u;
+            var word = 0u;
+            var scale = 0.0;
+            if (n_index < 16u && first < 2048u) {
+                word = b1[n_index * 512u + first / 4u];
+                scale = f32(b2[n_index * 64u + first / 32u]);
+            }
+            for (var e = 0u; e < 4u; e++) {
+                let code = i32((word >> (e * 8u)) & 255u) - 128;
+                var value = 0.0;
+                if (first + e < 2048u) { value = f32(code) * scale; }
+                tile_b[word_local * 4u + e][n_local] = value;
+            }
+        }
+        workgroupBarrier();
+        for (var kk = 0u; kk < 16u; kk++) {
+            var b_values: array<f32, 4>;
+            for (var c = 0u; c < 4u; c++) { b_values[c] = tile_b[kk][local.x * 4u + c]; }
+            for (var r = 0u; r < 1u; r++) {
+                let a_value = tile_a[local.y * 1u + r][kk];
+                for (var c = 0u; c < 4u; c++) { acc[r][c] += a_value * b_values[c]; }
+            }
+        }
+        workgroupBarrier();
+    }
+    for (var r = 0u; r < 1u; r++) {
+        let out_row = tile_row + local.y * 1u + r;
+        for (var c = 0u; c < 4u; c++) {
+            let out_col = tile_n + local.x * 4u + c;
+            if (out_row < 16u && out_col < 16u) {
+                let i = (batch * 16u + out_row) * 16u + out_col;
+                out[i] = f32(acc[r][c] + 0.0);
+            }
+        }
+    }
+}

qwen35-2b-fp32-int8-g32-exclude-l6-l9-l10up-l15o-home-token-major-v2-v4/kernels/9f02cd7a8eb5e6d20c2b01559fc58db5b0447ae41a51e2cd479ed519fc284791.wgsl

@@ -0,0 +1,16 @@
+@group(0) @binding(0) var<storage, read> b0: array<f32>;
+@group(0) @binding(1) var<storage, read> b1: array<f32>;
+@group(0) @binding(2) var<storage, read> b2: array<f32>;
+@group(0) @binding(3) var<storage, read> b3: array<f32>;
+@group(0) @binding(4) var<storage, read_write> out: array<f32>;
+
+@compute @workgroup_size(64)
+fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+let i = gid.x + gid.y * 248320u;
+if (i >= 248320u) { return; }
+let coord = (i / 1u) % 248320u;
+if (coord >= 0u && coord < 65536u) { out[i] = f32(b0[(i / 248320u) * 65536u + (coord - 0u) * 1u + i % 1u]); }
+if (coord >= 65536u && coord < 131072u) { out[i] = f32(b1[(i / 248320u) * 65536u + (coord - 65536u) * 1u + i % 1u]); }
+if (coord >= 131072u && coord < 196608u) { out[i] = f32(b2[(i / 248320u) * 65536u + (coord - 131072u) * 1u + i % 1u]); }
+if (coord >= 196608u && coord < 248320u) { out[i] = f32(b3[(i / 248320u) * 51712u + (coord - 196608u) * 1u + i % 1u]); }
+}

qwen35-2b-fp32-int8-g32-exclude-l6-l9-l10up-l15o-home-token-major-v2-v4/kernels/9f040facf0594804dba5b0f10f53b11b7223a1e1705896f95a8f95aa0fff5eec.wgsl

@@ -0,0 +1,11 @@
+@group(0) @binding(0) var<storage, read> b0: array<f32>;
+@group(0) @binding(1) var<storage, read> b1: array<f32>;
+@group(0) @binding(2) var<storage, read_write> out: array<f32>;
+
+@compute @workgroup_size(64)
+fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+let i = gid.x + gid.y * 2048u;
+if (i >= 2048u) { return; }
+let coord = (i / 1u) % 32u;
+if (coord >= 1u && coord < 34u && (coord - 1u) % 3u == 0u) { out[i] = f32(b0[((i / 2048u) % 1u) * 704u + ((i / 32u) % 64u) * 11u + ((((i / 1u) % 32u) - 1u) / 3u) * 1u]); } else { out[i] = f32(b1[i]); }
+}

qwen35-2b-fp32-int8-g32-exclude-l6-l9-l10up-l15o-home-token-major-v2-v4/kernels/9f4e63b03a84e92e7257e997baaa7fbcdd502eedd695d50e5dd2443ecf164df9.wgsl

@@ -0,0 +1,41 @@
+@group(0) @binding(0) var<storage, read> b0: array<u32>;
+@group(0) @binding(1) var<storage, read> b1: array<f32>;
+@group(0) @binding(2) var<storage, read> b2: array<f32>;
+@group(0) @binding(3) var<storage, read_write> out: array<f32>;
+fn dequant_0(index: u32) -> f32 {
+    let row = index / 6144u;
+    let col = index % 6144u;
+    let word = b0[row * 1536u + col / 4u];
+    let code = i32((word >> ((col % 4u) * 8u)) & 255u) - 128;
+    return f32(code) * b1[row * 192u + col / 32u];
+}
+
+var<workgroup> partial: array<f32, 64>;
+@compute @workgroup_size(64)
+fn main(@builtin(workgroup_id) group: vec3<u32>, @builtin(local_invocation_id) local: vec3<u32>) {
+    let i = group.x + group.y * 2048u;
+    if (i >= 2048u) { return; }
+    let lane = local.x;
+    let row = i % 2048u;
+    var acc = 0.0;
+    for (var w = lane; w < 1536u; w += 64u) {
+        let word = b0[row * 1536u + w];
+        let first = w * 4u;
+        var part = 0.0;
+        for (var e = 0u; e < 4u; e++) {
+            let col = first + e;
+            if (col < 6144u) {
+                let code = i32((word >> (e * 8u)) & 255u) - 128;
+                part += f32(code) * f32(b2[(i / 2048u) * 6144u + col]);
+            }
+        }
+        acc += part * f32(b1[row * 192u + first / 32u]);
+    }
+    partial[lane] = acc;
+    workgroupBarrier();
+    for (var stride = 32u; stride > 0u; stride /= 2u) {
+        if (lane < stride) { partial[lane] += partial[lane + stride]; }
+        workgroupBarrier();
+    }
+    if (lane == 0u) { out[i] = f32(partial[0] + 0.0); }
+}

qwen35-2b-fp32-int8-g32-exclude-l6-l9-l10up-l15o-home-token-major-v2-v4/kernels/9f5d05eb12c629ebad8edf513c9195f2df8f97198e781b05804110b7feda6400.wgsl

@@ -0,0 +1,71 @@
+@group(0) @binding(0) var<storage, read> b0: array<f32>;
+@group(0) @binding(1) var<storage, read> b1: array<u32>;
+@group(0) @binding(2) var<storage, read> b2: array<f32>;
+@group(0) @binding(3) var<storage, read_write> out: array<f32>;
+fn dequant_1(index: u32) -> f32 {
+    let row = index / 2048u;
+    let col = index % 2048u;
+    let word = b1[row * 512u + col / 4u];
+    let code = i32((word >> ((col % 4u) * 8u)) & 255u) - 128;
+    return f32(code) * b2[row * 64u + col / 32u];
+}
+
+var<workgroup> tile_a: array<array<f32, 16>, 16>;
+var<workgroup> tile_b: array<array<f32, 64>, 16>;
+@compute @workgroup_size(16, 16)
+fn main(@builtin(workgroup_id) group: vec3<u32>, @builtin(local_invocation_id) local: vec3<u32>) {
+    let lane = local.y * 16u + local.x;
+    let batch = group.z;
+    let tile_n = group.x * 64u;
+    let tile_row = group.y * 16u;
+    var acc: array<array<f32, 4>, 1>;
+    for (var k0 = 0u; k0 < 2048u; k0 += 16u) {
+        for (var e = 0u; e < 1u; e++) {
+            let flat = lane + e * 256u;
+            let m_local = flat / 16u;
+            let row = tile_row + m_local;
+            let col = k0 + flat % 16u;
+            var value = 0.0;
+            if (row < 4u && col < 2048u) { value = f32(f32(b0[(batch * 4u + row) * 2048u + col])); }
+            tile_a[m_local][flat % 16u] = value;
+        }
+        if (lane < 256u) {
+            let n_local = lane / 4u;
+            let word_local = lane % 4u;
+            let n_index = tile_n + n_local;
+            let first = k0 + word_local * 4u;
+            var word = 0u;
+            var scale = 0.0;
+            if (n_index < 6144u && first < 2048u) {
+                word = b1[n_index * 512u + first / 4u];
+                scale = f32(b2[n_index * 64u + first / 32u]);
+            }
+            for (var e = 0u; e < 4u; e++) {
+                let code = i32((word >> (e * 8u)) & 255u) - 128;
+                var value = 0.0;
+                if (first + e < 2048u) { value = f32(code) * scale; }
+                tile_b[word_local * 4u + e][n_local] = value;
+            }
+        }
+        workgroupBarrier();
+        for (var kk = 0u; kk < 16u; kk++) {
+            var b_values: array<f32, 4>;
+            for (var c = 0u; c < 4u; c++) { b_values[c] = tile_b[kk][local.x * 4u + c]; }
+            for (var r = 0u; r < 1u; r++) {
+                let a_value = tile_a[local.y * 1u + r][kk];
+                for (var c = 0u; c < 4u; c++) { acc[r][c] += a_value * b_values[c]; }
+            }
+        }
+        workgroupBarrier();
+    }
+    for (var r = 0u; r < 1u; r++) {
+        let out_row = tile_row + local.y * 1u + r;
+        for (var c = 0u; c < 4u; c++) {
+            let out_col = tile_n + local.x * 4u + c;
+            if (out_row < 4u && out_col < 6144u) {
+                let i = (batch * 4u + out_row) * 6144u + out_col;
+                out[i] = f32(acc[r][c] + 0.0);
+            }
+        }
+    }
+}

qwen35-2b-fp32-int8-g32-exclude-l6-l9-l10up-l15o-home-token-major-v2-v4/kernels/a16a539c1a662c846d6c661e572b0b8e19335f9ef41742f784d738bcfd3cd7a6.wgsl

@@ -0,0 +1,9 @@
+@group(0) @binding(0) var<storage, read> b0: array<f32>;
+@group(0) @binding(1) var<storage, read_write> out: array<f32>;
+
+@compute @workgroup_size(64)
+fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+let i = gid.x + gid.y * 393216u;
+if (i >= 393216u) { return; }
+out[i] = f32(b0[((i / 393216u) % 1u) * 417792u + ((i / 64u) % 6144u) * 68u + (((i / 1u) % 64u) * 1u + 4u) * 1u]);
+}

qwen35-2b-fp32-int8-g32-exclude-l6-l9-l10up-l15o-home-token-major-v2-v4/kernels/a1a974f6d8d51fd7c3496ede0966af303ad9f0c0c9ee44cf93ec962d2b0e87e1.wgsl

@@ -0,0 +1,10 @@
+@group(0) @binding(0) var<storage, read> b0: array<f32>;
+@group(0) @binding(1) var<storage, read_write> out: array<f32>;
+
+@compute @workgroup_size(64)
+fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+let i = gid.x + gid.y * 64u;
+if (i >= 64u) { return; }
+let x = f32(b0[i]);
+out[i] = f32(-x);
+}

qwen35-2b-fp32-int8-g32-exclude-l6-l9-l10up-l15o-home-token-major-v2-v4/kernels/a1cf6b03baf18d389f0a2b95440c17125a8ecc1e633568de985d42cac6e0d1cb.wgsl

@@ -0,0 +1,9 @@
+@group(0) @binding(0) var<storage, read> b0: array<f32>;
+@group(0) @binding(1) var<storage, read_write> out: array<f32>;
+
+@compute @workgroup_size(64)
+fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+let i = gid.x + gid.y * 512u;
+if (i >= 512u) { return; }
+out[i] = f32(b0[1u * 512u + ((i / 512u) % 1u) * 512u + ((i / 32u) % 16u) * 32u + ((i / 1u) % 32u) * 1u]);
+}

qwen35-2b-fp32-int8-g32-exclude-l6-l9-l10up-l15o-home-token-major-v2-v4/kernels/a21c6a35532bc26ccfc46df22f98e1592e3b285e3800544c032edf39425bde1a.wgsl

@@ -0,0 +1,9 @@
+@group(0) @binding(0) var<storage, read> b0: array<f32>;
+@group(0) @binding(1) var<storage, read_write> out: array<f32>;
+
+@compute @workgroup_size(64)
+fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+let i = gid.x + gid.y * 98304u;
+if (i >= 98304u) { return; }
+out[i] = f32(b0[((i / 98304u) % 1u) * 98304u + ((i / 16u) % 6144u) * 1u + ((i / 1u) % 16u) * 6144u]);
+}

qwen35-2b-fp32-int8-g32-exclude-l6-l9-l10up-l15o-home-token-major-v2-v4/kernels/a24673da4fae6d1c49aa143f8425996b2d036db7b0341987dab330c78ead91d7.wgsl

@@ -0,0 +1,9 @@
+@group(0) @binding(0) var<storage, read> b0: array<f32>;
+@group(0) @binding(1) var<storage, read_write> out: array<f32>;
+
+@compute @workgroup_size(64)
+fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+let i = gid.x + gid.y * 32768u;
+if (i >= 32768u) { return; }
+out[i] = f32(b0[((i / 32768u) % 1u) * 98304u + ((i / 2048u) % 16u) * 6144u + (((i / 1u) % 2048u) * 1u + 4096u) * 1u]);
+}

qwen35-2b-fp32-int8-g32-exclude-l6-l9-l10up-l15o-home-token-major-v2-v4/kernels/a2bd65fc2709e093644d6cbf0c292b4d71520009a87bedcf4bca8fcb5f5c15b8.wgsl

@@ -0,0 +1,9 @@
+@group(0) @binding(0) var<storage, read> b0: array<i32>;
+@group(0) @binding(1) var<storage, read_write> out: array<f32>;
+
+@compute @workgroup_size(64)
+fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+let i = gid.x + gid.y * 64u;
+if (i >= 12u) { return; }
+out[i] = f32(b0[i]);
+}

qwen35-2b-fp32-int8-g32-exclude-l6-l9-l10up-l15o-home-token-major-v2-v4/kernels/a2e242b97ac8ec546c9f91b5af599c2231915bdabb57d55cdc21f61a49c21007.wgsl

@@ -0,0 +1,10 @@
+@group(0) @binding(0) var<storage, read> b0: array<f32>;
+@group(0) @binding(1) var<storage, read_write> out: array<f32>;
+
+@compute @workgroup_size(64)
+fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+let i = gid.x + gid.y * 1024u;
+if (i >= 1024u) { return; }
+let x = f32(b0[i]);
+out[i] = f32(1.0 / (1.0 + exp(-x)));
+}

qwen35-2b-fp32-int8-g32-exclude-l6-l9-l10up-l15o-home-token-major-v2-v4/kernels/a37dac611b27158f19aa5bd70c43217286e610e733cbd602b91666b4af42d3ef.wgsl

@@ -0,0 +1,9 @@
+@group(0) @binding(0) var<storage, read> b0: array<i32>;
+@group(0) @binding(1) var<storage, read_write> out: array<i32>;
+
+@compute @workgroup_size(64)
+fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+let i = gid.x + gid.y * 64u;
+if (i >= 1u) { return; }
+out[i] = i32(b0[i]);
+}

qwen35-2b-fp32-int8-g32-exclude-l6-l9-l10up-l15o-home-token-major-v2-v4/kernels/a405c3a6203b40db5812e5299cee829b88a6cee8742a177b8e6bf0395ed52d89.wgsl

@@ -0,0 +1,83 @@
+@group(0) @binding(0) var<storage, read> b0: array<f32>;
+@group(0) @binding(1) var<storage, read> b1: array<f32>;
+@group(0) @binding(2) var<storage, read> b2: array<f32>;
+@group(0) @binding(3) var<storage, read> b3: array<f32>;
+@group(0) @binding(4) var<storage, read_write> out: array<f32>;
+
+var<workgroup> q_row: array<f32, 256>;
+var<workgroup> scores: array<f32, 1024>;
+var<workgroup> partial: array<f32, 64>;
+@compute @workgroup_size(64)
+fn main(@builtin(workgroup_id) group: vec3<u32>, @builtin(local_invocation_id) local: vec3<u32>) {
+    let lane = local.x;
+    let head = group.x / 16u;
+    let row = group.x % 16u;
+    let kv_head = head / 4u;
+    for (var d = lane; d < 256u; d += 64u) { q_row[d] = f32(b0[(head * 16u + row) * 256u + d]); }
+    workgroupBarrier();
+    var running_max = -3.4028234663852886e38;
+    var running_sum = 0.0;
+    var acc: array<f32, 4>;
+    for (var start = 0u; start < 4096u; start += 1024u) {
+        let count = min(1024u, 4096u - start);
+        var tile_max = -3.4028234663852886e38;
+        for (var t = lane; t < count; t += 64u) {
+            let j = start + t;
+            var score = -3.4028234663852886e38;
+            if (f32(b3[row * 4096u + j]) > -1000.0) {
+                var dot = 0.0;
+                for (var d = 0u; d < 256u; d++) { dot += q_row[d] * f32(b1[(((kv_head * 4096u + j) * 256u + d) / 256u) % 4096u * 512u + (((kv_head * 4096u + j) * 256u + d) / 1048576u) % 2u * 256u + (((kv_head * 4096u + j) * 256u + d) / 1u) % 256u * 1u]); }
+                score = dot * 0.0625 + f32(b3[row * 4096u + j]);
+            }
+            scores[t] = score;
+            tile_max = max(tile_max, score);
+        }
+        partial[lane] = tile_max;
+        workgroupBarrier();
+        for (var stride = 32u; stride > 0u; stride /= 2u) {
+            if (lane < stride) { partial[lane] = max(partial[lane], partial[lane + stride]); }
+            workgroupBarrier();
+        }
+        let next_max = max(running_max, partial[0]);
+        workgroupBarrier();
+        var tile_sum = 0.0;
+        for (var t = lane; t < count; t += 64u) {
+            var p = 0.0;
+            if (scores[t] > -3.0e38) { p = exp(scores[t] - next_max); }
+            scores[t] = p;
+            tile_sum += p;
+        }
+        partial[lane] = tile_sum;
+        workgroupBarrier();
+        for (var stride = 32u; stride > 0u; stride /= 2u) {
+            if (lane < stride) { partial[lane] += partial[lane + stride]; }
+            workgroupBarrier();
+        }
+        var correction = 0.0;
+        if (running_max > -3.0e38) { correction = exp(running_max - next_max); }
+        running_sum = running_sum * correction + partial[0];
+        running_max = next_max;
+        for (var c = 0u; c < 4u; c++) {
+            let d = lane + c * 64u;
+            var total = acc[c] * correction;
+            if (d < 256u) {
+                for (var t = 0u; t < count; t++) {
+                    let p = scores[t];
+                    if (p != 0.0) {
+                        let j = start + t;
+                        total += p * f32(b2[(((kv_head * 4096u + j) * 256u + d) / 256u) % 4096u * 512u + (((kv_head * 4096u + j) * 256u + d) / 1048576u) % 2u * 256u + (((kv_head * 4096u + j) * 256u + d) / 1u) % 256u * 1u]);
+                    }
+                }
+            }
+            acc[c] = total;
+        }
+        workgroupBarrier();
+    }
+    for (var c = 0u; c < 4u; c++) {
+        let d = lane + c * 64u;
+        if (d < 256u) {
+            let i = (head * 16u + row) * 256u + d;
+            out[i] = f32(acc[c] / running_sum);
+        }
+    }
+}

qwen35-2b-fp32-int8-g32-exclude-l6-l9-l10up-l15o-home-token-major-v2-v4/kernels/a53c1ce51ebaec593ad667efae9603efe3807db8f0ee060a620ac031cc4f2b92.wgsl

@@ -0,0 +1,10 @@
+@group(0) @binding(0) var<storage, read> b0: array<f32>;
+@group(0) @binding(1) var<storage, read_write> out: array<f32>;
+
+@compute @workgroup_size(64)
+fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+let i = gid.x + gid.y * 8192u;
+if (i >= 8192u) { return; }
+let x = f32(b0[i]);
+out[i] = f32(1.0 / (1.0 + exp(-x)));
+}

qwen35-2b-fp32-int8-g32-exclude-l6-l9-l10up-l15o-home-token-major-v2-v4/kernels/a62f6b62277fe048d6bac44a25a2e61399e7e2eab103fccd3a23c29a3c827856.wgsl

@@ -0,0 +1,44 @@
+@group(0) @binding(0) var<storage, read> b0: array<f32>;
+@group(0) @binding(1) var<storage, read> b1: array<f32>;
+@group(0) @binding(2) var<storage, read> b2: array<f32>;
+@group(0) @binding(3) var<storage, read> b3: array<f32>;
+@group(0) @binding(4) var<storage, read> b4: array<f32>;
+@group(0) @binding(5) var<storage, read> b5: array<f32>;
+@group(0) @binding(6) var<storage, read_write> out: array<f32>;
+
+var<workgroup> partial: array<f32, 128>;
+var<workgroup> delta: f32;
+@compute @workgroup_size(128)
+fn main(@builtin(workgroup_id) group: vec3<u32>, @builtin(local_invocation_id) local: vec3<u32>) {
+    let column = group.x;
+    let head = group.y;
+    let batch_index = group.z;
+    let lane = local.x;
+    var recurrent = 0.0;
+    if (lane < 128u) { recurrent = f32(b5[((batch_index * 16u + head) * 128u + lane) * 128u + column]); }
+    for (var token = 0u; token < 64u; token++) {
+        recurrent *= exp(f32(b3[(batch_index * 64u + token) * 16u + head]));
+        partial[lane] = 0.0;
+        if (lane < 128u) { partial[lane] = recurrent * f32(b1[((batch_index * 64u + token) * 16u + head) * 128u + lane]); }
+        workgroupBarrier();
+        for (var stride = 64u; stride > 0u; stride /= 2u) {
+            if (lane < stride) { partial[lane] += partial[lane + stride]; }
+            workgroupBarrier();
+        }
+        if (lane == 0u) { delta = (f32(b2[((batch_index * 64u + token) * 16u + head) * 128u + column]) - partial[0]) * f32(b4[(batch_index * 64u + token) * 16u + head]); }
+        workgroupBarrier();
+        if (lane < 128u) { recurrent += f32(b1[((batch_index * 64u + token) * 16u + head) * 128u + lane]) * delta; }
+        partial[lane] = 0.0;
+        if (lane < 128u) {
+            partial[lane] = recurrent * f32(b0[((batch_index * 64u + token) * 16u + head) * 128u + lane]) * 0.08838834764831845;
+        }
+        workgroupBarrier();
+        for (var stride = 64u; stride > 0u; stride /= 2u) {
+            if (lane < stride) { partial[lane] += partial[lane + stride]; }
+            workgroupBarrier();
+        }
+        if (lane == 0u) { out[((batch_index * 16u + head) * 192u + 128u + token) * 128u + column] = f32(partial[0]); }
+        workgroupBarrier();
+    }
+    if (lane < 128u) { out[((batch_index * 16u + head) * 192u + lane) * 128u + column] = f32(recurrent); }
+}

qwen35-2b-fp32-int8-g32-exclude-l6-l9-l10up-l15o-home-token-major-v2-v4/kernels/a672c3e158716bde7444c8141f3df1da16da739ccdd2eb2ad60f9d42d0775157.wgsl

@@ -0,0 +1,11 @@
+@group(0) @binding(0) var<storage, read> b0: array<f32>;
+@group(0) @binding(1) var<storage, read> b1: array<f32>;
+@group(0) @binding(2) var<storage, read_write> out: array<f32>;
+
+@compute @workgroup_size(64)
+fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+let i = gid.x + gid.y * 2048u;
+if (i >= 2048u) { return; }
+let coord = (i / 128u) % 1u;
+if (coord == 0u) { out[i] = f32(b0[((i / 2048u) % 1u) * 2048u + ((i / 128u) % 16u) * 128u + ((i / 1u) % 128u) * 1u]); } else { out[i] = f32(b1[i]); }
+}

qwen35-2b-fp32-int8-g32-exclude-l6-l9-l10up-l15o-home-token-major-v2-v4/kernels/a77f14c89662d2d3da8abd8f109667793dc662d307e5e1c61123be753e25437b.wgsl

@@ -0,0 +1,9 @@
+@group(0) @binding(0) var<storage, read> b0: array<f32>;
+@group(0) @binding(1) var<storage, read_write> out: array<f32>;
+
+@compute @workgroup_size(64)
+fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+let i = gid.x + gid.y * 128u;
+if (i >= 96u) { return; }
+out[i] = f32(b0[((i / 1u) % 32u) * 1u]);
+}

qwen35-2b-fp32-int8-g32-exclude-l6-l9-l10up-l15o-home-token-major-v2-v4/kernels/a7b50e8b6e4d56404b6261383f50b3eed4a2a59c3fadaaffcc974575c32a374f.wgsl

@@ -0,0 +1,9 @@
+@group(0) @binding(0) var<storage, read> b0: array<f32>;
+@group(0) @binding(1) var<storage, read_write> out: array<f32>;
+
+@compute @workgroup_size(64)
+fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+let i = gid.x + gid.y * 98304u;
+if (i >= 98304u) { return; }
+out[i] = f32(b0[((i / 98304u) % 1u) * 98304u + ((i / 6144u) % 16u) * 1u + ((i / 1u) % 6144u) * 16u]);
+}

qwen35-2b-fp32-int8-g32-exclude-l6-l9-l10up-l15o-home-token-major-v2-v4/kernels/a7c8fd0a86506f31fb9b62b5df69df36332f1f08da9790ce077870722d85b189.wgsl

@@ -0,0 +1,59 @@
+@group(0) @binding(0) var<storage, read> b0: array<f32>;
+@group(0) @binding(1) var<storage, read> b1: array<u32>;
+@group(0) @binding(2) var<storage, read_write> out: array<f32>;
+fn unpack_bf16_1(index: u32) -> f32 {
+    let pair = b1[index / 2u];
+    let bits = (pair >> ((index % 2u) * 16u)) & 65535u;
+    return bitcast<f32>(bits << 16u);
+}
+
+var<workgroup> tile_a: array<array<f32, 16>, 16>;
+var<workgroup> tile_b: array<array<f32, 64>, 16>;
+@compute @workgroup_size(16, 16)
+fn main(@builtin(workgroup_id) group: vec3<u32>, @builtin(local_invocation_id) local: vec3<u32>) {
+    let lane = local.y * 16u + local.x;
+    let batch = group.z;
+    let tile_n = group.x * 64u;
+    let tile_row = group.y * 16u;
+    var acc: array<array<f32, 4>, 1>;
+    for (var k0 = 0u; k0 < 2048u; k0 += 16u) {
+        for (var e = 0u; e < 1u; e++) {
+            let flat = lane + e * 256u;
+            let m_local = flat / 16u;
+            let row = tile_row + m_local;
+            let col = k0 + flat % 16u;
+            var value = 0.0;
+            if (row < 4u && col < 2048u) { value = f32(f32(b0[(batch * 4u + row) * 2048u + col])); }
+            tile_a[m_local][flat % 16u] = value;
+        }
+        for (var e = 0u; e < 4u; e++) {
+            let n_local = lane / 4u;
+            let k_local = (lane % 4u) * 4u + e;
+            let n_index = tile_n + n_local;
+            let col = k0 + k_local;
+            var value = 0.0;
+            if (n_index < 16u && col < 2048u) { value = f32(unpack_bf16_1(n_index * 2048u + col)); }
+            tile_b[k_local][n_local] = value;
+        }
+        workgroupBarrier();
+        for (var kk = 0u; kk < 16u; kk++) {
+            var b_values: array<f32, 4>;
+            for (var c = 0u; c < 4u; c++) { b_values[c] = tile_b[kk][local.x * 4u + c]; }
+            for (var r = 0u; r < 1u; r++) {
+                let a_value = tile_a[local.y * 1u + r][kk];
+                for (var c = 0u; c < 4u; c++) { acc[r][c] += a_value * b_values[c]; }
+            }
+        }
+        workgroupBarrier();
+    }
+    for (var r = 0u; r < 1u; r++) {
+        let out_row = tile_row + local.y * 1u + r;
+        for (var c = 0u; c < 4u; c++) {
+            let out_col = tile_n + local.x * 4u + c;
+            if (out_row < 4u && out_col < 16u) {
+                let i = (batch * 4u + out_row) * 16u + out_col;
+                out[i] = f32(acc[r][c] + 0.0);
+            }
+        }
+    }
+}

qwen35-2b-fp32-int8-g32-exclude-l6-l9-l10up-l15o-home-token-major-v2-v4/kernels/a87152b0fd2f78f60d7abb61c2f6c4a9bde8a9dd45d0275b58d760a3da9f71ce.wgsl

@@ -0,0 +1,17 @@
+@group(0) @binding(0) var<storage, read> b0: array<f32>;
+@group(0) @binding(1) var<storage, read> b1: array<f32>;
+@group(0) @binding(2) var<storage, read_write> out: array<f32>;
+
+@compute @workgroup_size(64)
+fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+let i = gid.x + gid.y * 384u;
+if (i >= 384u) { return; }
+let batch = i / 128u;
+let row = (i / 4u) % 32u;
+let col = i % 4u;
+var acc = 0.0;
+for (var p = 0u; p < 1u; p++) {
+    acc += f32(b0[(((batch / 1u) % 3u) * 32u) + row * 1u + p]) * f32(b1[(((batch / 1u) % 3u) * 4u) + p * 4u + col]);
+}
+out[i] = f32(acc);
+}

qwen35-2b-fp32-int8-g32-exclude-l6-l9-l10up-l15o-home-token-major-v2-v4/kernels/a896c93b04922c0f78f1c77fbaabbc79eb71776223748bb32a6d5339e32029e8.wgsl

@@ -0,0 +1,9 @@
+@group(0) @binding(0) var<storage, read> b0: array<i32>;
+@group(0) @binding(1) var<storage, read_write> out: array<i32>;
+
+@compute @workgroup_size(64)
+fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+let i = gid.x + gid.y * 256u;
+if (i >= 256u) { return; }
+out[i] = i32(b0[((i / 1u) % 64u) * 1u]);
+}

qwen35-2b-fp32-int8-g32-exclude-l6-l9-l10up-l15o-home-token-major-v2-v4/kernels/a99778950c185f009de4f25b85da7a7fbaf72a4b6c6b50f7c40c5a6622edac0b.wgsl

@@ -0,0 +1,20 @@
+@group(0) @binding(0) var<storage, read> b0: array<i32>;
+@group(0) @binding(1) var<storage, read> b1: array<u32>;
+@group(0) @binding(2) var<storage, read> b2: array<f32>;
+@group(0) @binding(3) var<storage, read_write> out: array<f32>;
+fn dequant_1(index: u32) -> f32 {
+    let row = index / 2048u;
+    let col = index % 2048u;
+    let word = b1[row * 512u + col / 4u];
+    let code = i32((word >> ((col % 4u) * 8u)) & 255u) - 128;
+    return f32(code) * b2[row * 64u + col / 32u];
+}
+
+@compute @workgroup_size(64)
+fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+let i = gid.x + gid.y * 8192u;
+if (i >= 8192u) { return; }
+let token = i32(b0[i / 2048u]);
+if (token < 196608 || token >= 248320) { out[i] = f32(0.0); return; }
+out[i] = f32(dequant_1(u32(token - 196608) * 2048u + i % 2048u));
+}

qwen35-2b-fp32-int8-g32-exclude-l6-l9-l10up-l15o-home-token-major-v2-v4/kernels/a9f0eef095f015e2099adf81552a6727c45e70fc11f5e50b777d36b6370ab986.wgsl

@@ -0,0 +1,9 @@
+@group(0) @binding(0) var<storage, read> b0: array<f32>;
+@group(0) @binding(1) var<storage, read_write> out: array<f32>;
+
+@compute @workgroup_size(64)
+fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+let i = gid.x + gid.y * 8192u;
+if (i >= 8192u) { return; }
+out[i] = f32(b0[((i / 8192u) % 1u) * 24576u + ((i / 2048u) % 4u) * 6144u + (((i / 1u) % 2048u) * 1u + 2048u) * 1u]);
+}

qwen35-2b-fp32-int8-g32-exclude-l6-l9-l10up-l15o-home-token-major-v2-v4/kernels/a9f6bc361f1ea31f79f0ef6164872eeb04896a45338871a2d779789b47b1920b.wgsl

@@ -0,0 +1,10 @@
+@group(0) @binding(0) var<storage, read> b0: array<f32>;
+@group(0) @binding(1) var<storage, read> b1: array<f32>;
+@group(0) @binding(2) var<storage, read_write> out: array<f32>;
+
+@compute @workgroup_size(64)
+fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+let i = gid.x + gid.y * 131072u;
+if (i >= 131072u) { return; }
+out[i] = f32(f32(b0[i]) * f32(b1[i]));
+}

qwen35-2b-fp32-int8-g32-exclude-l6-l9-l10up-l15o-home-token-major-v2-v4/kernels/a9fa5db20fa8de1de429c6850c3e40ff8180bcdb59373919b84d2438b3b17352.wgsl

@@ -0,0 +1,9 @@
+@group(0) @binding(0) var<storage, read> b0: array<i32>;
+@group(0) @binding(1) var<storage, read_write> out: array<i32>;
+
+@compute @workgroup_size(64)
+fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+let i = gid.x + gid.y * 64u;
+if (i >= 48u) { return; }
+out[i] = i32(b0[(((i / 16u) % 3u) * 1u + 1u) * 16u + ((i / 16u) % 1u) * 16u + ((i / 1u) % 16u) * 1u]);
+}

qwen35-2b-fp32-int8-g32-exclude-l6-l9-l10up-l15o-home-token-major-v2-v4/kernels/aa227ae49fab3f75d86e02e6f390be785eabfeafe70e77a5c7eb4ad51895e382.wgsl

@@ -0,0 +1,10 @@
+@group(0) @binding(0) var<storage, read> b0: array<f32>;
+@group(0) @binding(1) var<storage, read> b1: array<f32>;
+@group(0) @binding(2) var<storage, read_write> out: array<f32>;
+
+@compute @workgroup_size(64)
+fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+let i = gid.x + gid.y * 32768u;
+if (i >= 32768u) { return; }
+out[i] = f32(f32(b0[i]) * f32(b1[i]));
+}

qwen35-2b-fp32-int8-g32-exclude-l6-l9-l10up-l15o-home-token-major-v2-v4/kernels/abdb17daf29310a7828a55a1efeebaa65b6553e236fc20702e8c712e0a46dd5b.wgsl

@@ -0,0 +1,10 @@
+@group(0) @binding(0) var<storage, read> b0: array<f32>;
+@group(0) @binding(1) var<storage, read_write> out: array<f32>;
+
+@compute @workgroup_size(64)
+fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+let i = gid.x + gid.y * 2048u;
+if (i >= 2048u) { return; }
+let x = f32(b0[i]);
+out[i] = f32(1.0 / (1.0 + exp(-x)));
+}

qwen35-2b-fp32-int8-g32-exclude-l6-l9-l10up-l15o-home-token-major-v2-v4/kernels/ac173d038b5767711ad9f7cafbceb9ca3ec84aaeb3d07a3037e7cd0f83fead2c.wgsl

@@ -0,0 +1,9 @@
+@group(0) @binding(0) var<storage, read> b0: array<f32>;
+@group(0) @binding(1) var<storage, read_write> out: array<f32>;
+
+@compute @workgroup_size(64)
+fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+let i = gid.x + gid.y * 131072u;
+if (i >= 131072u) { return; }
+out[i] = f32(b0[((i / 131072u) % 1u) * 393216u + ((i / 2048u) % 64u) * 6144u + (((i / 1u) % 2048u) * 1u + 0u) * 1u]);
+}

qwen35-2b-fp32-int8-g32-exclude-l6-l9-l10up-l15o-home-token-major-v2-v4/kernels/ad72f60d58133272228319f1c066e7cd43ac28573ddeeb7a6f69be01af341f57.wgsl

@@ -0,0 +1,9 @@
+@group(0) @binding(0) var<storage, read> b0: array<f32>;
+@group(0) @binding(1) var<storage, read_write> out: array<f32>;
+
+@compute @workgroup_size(64)
+fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+let i = gid.x + gid.y * 512u;
+if (i >= 512u) { return; }
+out[i] = f32(b0[((i / 512u) % 1u) * 2048u + ((i / 256u) % 2u) * 1024u + ((i / 64u) % 4u) * 256u + (((i / 1u) % 64u) * 1u + 0u) * 1u]);
+}

qwen35-2b-fp32-int8-g32-exclude-l6-l9-l10up-l15o-home-token-major-v2-v4/kernels/adf1e58a124e1301625024ae142dca5fb1dd50799fa94b52eaeffb82ea99852c.wgsl

@@ -0,0 +1,10 @@
+@group(0) @binding(0) var<storage, read> b0: array<f32>;
+@group(0) @binding(1) var<storage, read_write> out: array<f32>;
+
+@compute @workgroup_size(64)
+fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+let i = gid.x + gid.y * 4096u;
+if (i >= 4096u) { return; }
+let x = f32(b0[i]);
+out[i] = f32(-x);
+}

qwen35-2b-fp32-int8-g32-exclude-l6-l9-l10up-l15o-home-token-major-v2-v4/kernels/ae69e698c92571766e36ad8c078b13e42bde56745d45698daaadaca587b7279c.wgsl

@@ -0,0 +1,11 @@
+@group(0) @binding(0) var<storage, read> b0: array<f32>;
+@group(0) @binding(1) var<storage, read> b1: array<f32>;
+@group(0) @binding(2) var<storage, read_write> out: array<f32>;
+
+@compute @workgroup_size(64)
+fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+let i = gid.x + gid.y * 128u;
+if (i >= 128u) { return; }
+let coord = (i / 1u) % 32u;
+if (coord >= 2u && coord < 32u && (coord - 2u) % 3u == 0u) { out[i] = f32(b0[((i / 128u) % 1u) * 40u + ((i / 32u) % 4u) * 10u + ((((i / 1u) % 32u) - 2u) / 3u) * 1u]); } else { out[i] = f32(b1[i]); }
+}

qwen35-2b-fp32-int8-g32-exclude-l6-l9-l10up-l15o-home-token-major-v2-v4/kernels/b02b0be460d581c720afd68c8b722e8da47e2ee432b5d61bbdf24b6084cb2f26.wgsl

@@ -0,0 +1,11 @@
+@group(0) @binding(0) var<storage, read> b0: array<f32>;
+@group(0) @binding(1) var<storage, read> b1: array<f32>;
+@group(0) @binding(2) var<storage, read_write> out: array<f32>;
+
+@compute @workgroup_size(64)
+fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+let i = gid.x + gid.y * 2048u;
+if (i >= 2048u) { return; }
+let x = f32(b0[i]); let s = f32(f32(x / (1.0 + exp(-x))));
+out[i] = f32(s * f32(b1[i]));
+}

qwen35-2b-fp32-int8-g32-exclude-l6-l9-l10up-l15o-home-token-major-v2-v4/kernels/b12eae76f13225c0c5d35fc9309964aba3172712799ff3bd8538bb2c1b34aa33.wgsl

@@ -0,0 +1,9 @@
+@group(0) @binding(0) var<storage, read> b0: array<f32>;
+@group(0) @binding(1) var<storage, read_write> out: array<f32>;
+
+@compute @workgroup_size(64)
+fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+let i = gid.x + gid.y * 1536u;
+if (i >= 1536u) { return; }
+out[i] = f32(b0[((i / 512u) % 3u) * 512u + ((i / 512u) % 1u) * 512u + ((i / 32u) % 16u) * 1u + ((i / 1u) % 32u) * 16u]);
+}

qwen35-2b-fp32-int8-g32-exclude-l6-l9-l10up-l15o-home-token-major-v2-v4/kernels/b199d835db70f888c7b99a3ac6e9ec56f6c47d5bba4eaf352e0a8eabed56411e.wgsl

@@ -0,0 +1,10 @@
+@group(0) @binding(0) var<storage, read> b0: array<f32>;
+@group(0) @binding(1) var<storage, read> b1: array<f32>;
+@group(0) @binding(2) var<storage, read_write> out: array<f32>;
+
+@compute @workgroup_size(64)
+fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+let i = gid.x + gid.y * 2048u;
+if (i >= 2048u) { return; }
+out[i] = f32(f32(b0[i]) * f32(b1[((i / 128u) % 16u) * 1u]));
+}

qwen35-2b-fp32-int8-g32-exclude-l6-l9-l10up-l15o-home-token-major-v2-v4/kernels/b28ea4a8345a9c9abb2d74bfd620ba5de46616434dbaffdbabf022ea71800839.wgsl

@@ -0,0 +1,9 @@
+@group(0) @binding(0) var<storage, read> b0: array<f32>;
+@group(0) @binding(1) var<storage, read_write> out: array<f32>;
+
+@compute @workgroup_size(64)
+fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+let i = gid.x + gid.y * 8192u;
+if (i >= 8192u) { return; }
+out[i] = f32(b0[i]);
+}

qwen35-2b-fp32-int8-g32-exclude-l6-l9-l10up-l15o-home-token-major-v2-v4/kernels/b2ae1b161c8a6315f8863e47511607027dfe583aac1db4c1626371ddfa0c64e2.wgsl

@@ -0,0 +1,9 @@
+@group(0) @binding(0) var<storage, read> b0: array<f32>;
+@group(0) @binding(1) var<storage, read_write> out: array<f32>;
+
+@compute @workgroup_size(64)
+fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+let i = gid.x + gid.y * 256u;
+if (i >= 256u) { return; }
+out[i] = f32(b0[((i / 256u) % 1u) * 512u + ((i / 128u) % 2u) * 256u + ((i / 32u) % 4u) * 64u + (((i / 1u) % 32u) * 1u + 32u) * 1u]);
+}

qwen35-2b-fp32-int8-g32-exclude-l6-l9-l10up-l15o-home-token-major-v2-v4/kernels/b2b16798cbe94c919025d76b0435afe47966ffdd1ea53ec74a791c03c4709a28.wgsl

@@ -0,0 +1,9 @@
+@group(0) @binding(0) var<storage, read> b0: array<f32>;
+@group(0) @binding(1) var<storage, read_write> out: array<f32>;
+
+@compute @workgroup_size(64)
+fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+let i = gid.x + gid.y * 30720u;
+if (i >= 30720u) { return; }
+out[i] = f32(b0[((i / 30720u) % 1u) * 49152u + ((i / 5u) % 6144u) * 8u + (((i / 1u) % 5u) * 1u + 0u) * 1u]);
+}

qwen35-2b-fp32-int8-g32-exclude-l6-l9-l10up-l15o-home-token-major-v2-v4/kernels/b3bb2905555188f535b6b8bc1d050c142b5fea8222d9ef193466f80aa2c54dea.wgsl

@@ -0,0 +1,11 @@
+@group(0) @binding(0) var<storage, read> b0: array<f32>;
+@group(0) @binding(1) var<storage, read> b1: array<f32>;
+@group(0) @binding(2) var<storage, read_write> out: array<f32>;
+
+@compute @workgroup_size(64)
+fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+let i = gid.x + gid.y * 2048u;
+if (i >= 2048u) { return; }
+let coord = (i / 1u) % 32u;
+if (coord >= 2u && coord < 32u && (coord - 2u) % 3u == 0u) { out[i] = f32(b0[((i / 2048u) % 1u) * 640u + ((i / 32u) % 64u) * 10u + ((((i / 1u) % 32u) - 2u) / 3u) * 1u]); } else { out[i] = f32(b1[i]); }
+}

qwen35-2b-fp32-int8-g32-exclude-l6-l9-l10up-l15o-home-token-major-v2-v4/kernels/b44895294a35fd06948d21f6d4c53f7daa28386437f8e19488befb3b41e193b9.wgsl

@@ -0,0 +1,25 @@
+@group(0) @binding(0) var<storage, read> b0: array<f32>;
+@group(0) @binding(1) var<storage, read> b1: array<u32>;
+@group(0) @binding(2) var<storage, read_write> out: array<f32>;
+fn unpack_bf16_1(index: u32) -> f32 {
+    let pair = b1[index / 2u];
+    let bits = (pair >> ((index % 2u) * 16u)) & 65535u;
+    return bitcast<f32>(bits << 16u);
+}
+
+var<workgroup> partial: array<f32, 64>;
+@compute @workgroup_size(64)
+fn main(@builtin(workgroup_id) group: vec3<u32>, @builtin(local_invocation_id) local: vec3<u32>) {
+    let i = group.x + group.y * 16u;
+    if (i >= 16u) { return; }
+    let lane = local.x;
+    var acc = 0.0;
+    for (var p = lane; p < 2048u; p += 64u) { acc += f32(b0[(i / 16u) * 2048u + p]) * unpack_bf16_1((i % 16u) * 2048u + p); }
+    partial[lane] = acc;
+    workgroupBarrier();
+    for (var stride = 32u; stride > 0u; stride /= 2u) {
+        if (lane < stride) { partial[lane] += partial[lane + stride]; }
+        workgroupBarrier();
+    }
+    if (lane == 0u) { out[i] = f32(partial[0] + 0.0); }
+}

qwen35-2b-fp32-int8-g32-exclude-l6-l9-l10up-l15o-home-token-major-v2-v4/kernels/b57928140994202536cd4f99d2e14f5dba9754f014843673790d5d48c9cbb9ab.wgsl

@@ -0,0 +1,9 @@
+@group(0) @binding(0) var<storage, read> b0: array<f32>;
+@group(0) @binding(1) var<storage, read_write> out: array<f32>;
+
+@compute @workgroup_size(64)
+fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+let i = gid.x + gid.y * 512u;
+if (i >= 512u) { return; }
+out[i] = f32(b0[((i / 512u) % 1u) * 512u + ((i / 256u) % 2u) * 256u + ((i / 256u) % 1u) * 512u + ((i / 1u) % 256u) * 1u]);
+}

qwen35-2b-fp32-int8-g32-exclude-l6-l9-l10up-l15o-home-token-major-v2-v4/kernels/b5984ff6eb9e56ef0f9930f775c1dc3c203eec15924e5fea4c2525b2ce180857.wgsl

@@ -0,0 +1,9 @@
+@group(0) @binding(0) var<storage, read> b0: array<f32>;
+@group(0) @binding(1) var<storage, read_write> out: array<f32>;
+
+@compute @workgroup_size(64)
+fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+let i = gid.x + gid.y * 4096u;
+if (i >= 4096u) { return; }
+out[i] = f32(b0[((i / 4096u) % 1u) * 8192u + ((i / 512u) % 8u) * 1024u + ((i / 32u) % 16u) * 64u + (((i / 1u) % 32u) * 1u + 0u) * 1u]);
+}

qwen35-2b-fp32-int8-g32-exclude-l6-l9-l10up-l15o-home-token-major-v2-v4/kernels/b6c3ce0defd66eef66dc3fd6eb9eab3fee12d179332698c3c764009988628b49.wgsl

@@ -0,0 +1,10 @@
+@group(0) @binding(0) var<storage, read> b0: array<f32>;
+@group(0) @binding(1) var<storage, read_write> out: array<f32>;
+
+@compute @workgroup_size(64)
+fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+let i = gid.x + gid.y * 49152u;
+if (i >= 49152u) { return; }
+let x = f32(b0[i]);
+out[i] = f32(x / (1.0 + exp(-x)));
+}

qwen35-2b-fp32-int8-g32-exclude-l6-l9-l10up-l15o-home-token-major-v2-v4/kernels/bb7f03e6a2277dc56084e9130086507be58871253867c0ce8ad60ee5ce4521b6.wgsl

@@ -0,0 +1,9 @@
+@group(0) @binding(0) var<storage, read> b0: array<f32>;
+@group(0) @binding(1) var<storage, read_write> out: array<f32>;
+
+@compute @workgroup_size(64)
+fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+let i = gid.x + gid.y * 262144u;
+if (i >= 262144u) { return; }
+out[i] = f32(b0[((i / 262144u) % 1u) * 393216u + ((i / 16384u) % 16u) * 24576u + (((i / 128u) % 128u) * 1u + 0u) * 128u + ((i / 1u) % 128u) * 1u]);
+}

qwen35-2b-fp32-int8-g32-exclude-l6-l9-l10up-l15o-home-token-major-v2-v4/kernels/bb9029b667eeb13670d1f640cd677c6eabd7a7569686c599e3eeb9482d642b00.wgsl

@@ -0,0 +1,10 @@
+@group(0) @binding(0) var<storage, read> b0: array<f32>;
+@group(0) @binding(1) var<storage, read> b1: array<f32>;
+@group(0) @binding(2) var<storage, read_write> out: array<f32>;
+
+@compute @workgroup_size(64)
+fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+let i = gid.x + gid.y * 2048u;
+if (i >= 2048u) { return; }
+out[i] = f32(f32(b0[i]) - (f32(b1[i]) * 1.0));
+}

qwen35-2b-fp32-int8-g32-exclude-l6-l9-l10up-l15o-home-token-major-v2-v4/kernels/bc3debb5b2d1630349d983f26929555c7a91b4c38435f2c464c6c66a52b9c566.wgsl

@@ -0,0 +1,24 @@
+@group(0) @binding(0) var<storage, read> b0: array<f32>;
+@group(0) @binding(1) var<storage, read> b1: array<f32>;
+@group(0) @binding(2) var<storage, read_write> out: array<f32>;
+
+var<workgroup> factor: f32;
+@compute @workgroup_size(64)
+fn main(@builtin(workgroup_id) group: vec3<u32>, @builtin(local_invocation_id) local: vec3<u32>) {
+    let row = group.x + group.y * 4u;
+    if (row >= 4u) { return; }
+    let lane = local.x;
+    if (lane == 0u) {
+        var total = 0.0;
+        for (var j = 0u; j < 2048u; j++) {
+            let v = f32(b0[row * 2048u + j]);
+            total += v * v;
+        }
+        factor = inverseSqrt(total / 2048.0 + 1e-06);
+    }
+    workgroupBarrier();
+    for (var p = lane; p < 2048u; p += 64u) {
+        let i = row * 2048u + p;
+        out[i] = f32(f32(b0[row * 2048u + p]) * factor * (f32(b1[p]) + 1.0));
+    }
+}

qwen35-2b-fp32-int8-g32-exclude-l6-l9-l10up-l15o-home-token-major-v2-v4/kernels/bcb78b92dbbfeb212c190e064bc2f9d8e79c201398cf38c9aa62df6fdba94469.wgsl

@@ -0,0 +1,9 @@
+@group(0) @binding(0) var<storage, read> b0: array<f32>;
+@group(0) @binding(1) var<storage, read_write> out: array<f32>;
+
+@compute @workgroup_size(64)
+fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+let i = gid.x + gid.y * 32768u;
+if (i >= 32768u) { return; }
+out[i] = f32(b0[((i / 32768u) % 1u) * 32768u + ((i / 16384u) % 2u) * 256u + ((i / 256u) % 64u) * 512u + ((i / 1u) % 256u) * 1u]);
+}

qwen35-2b-fp32-int8-g32-exclude-l6-l9-l10up-l15o-home-token-major-v2-v4/kernels/bd6381fa811422353933b25724497c0c188434d81e3d5e9f1a33c35bbebe6d39.wgsl

@@ -0,0 +1,59 @@
+@group(0) @binding(0) var<storage, read> b0: array<f32>;
+@group(0) @binding(1) var<storage, read> b1: array<u32>;
+@group(0) @binding(2) var<storage, read_write> out: array<f32>;
+fn unpack_bf16_1(index: u32) -> f32 {
+    let pair = b1[index / 2u];
+    let bits = (pair >> ((index % 2u) * 16u)) & 65535u;
+    return bitcast<f32>(bits << 16u);
+}
+
+var<workgroup> tile_a: array<array<f32, 16>, 64>;
+var<workgroup> tile_b: array<array<f32, 64>, 16>;
+@compute @workgroup_size(16, 16)
+fn main(@builtin(workgroup_id) group: vec3<u32>, @builtin(local_invocation_id) local: vec3<u32>) {
+    let lane = local.y * 16u + local.x;
+    let batch = group.z;
+    let tile_n = group.x * 64u;
+    let tile_row = group.y * 64u;
+    var acc: array<array<f32, 4>, 4>;
+    for (var k0 = 0u; k0 < 6144u; k0 += 16u) {
+        for (var e = 0u; e < 4u; e++) {
+            let flat = lane + e * 256u;
+            let m_local = flat / 16u;
+            let row = tile_row + m_local;
+            let col = k0 + flat % 16u;
+            var value = 0.0;
+            if (row < 64u && col < 6144u) { value = f32(f32(b0[(batch * 64u + row) * 6144u + col])); }
+            tile_a[m_local][flat % 16u] = value;
+        }
+        for (var e = 0u; e < 4u; e++) {
+            let n_local = lane / 4u;
+            let k_local = (lane % 4u) * 4u + e;
+            let n_index = tile_n + n_local;
+            let col = k0 + k_local;
+            var value = 0.0;
+            if (n_index < 2048u && col < 6144u) { value = f32(unpack_bf16_1(n_index * 6144u + col)); }
+            tile_b[k_local][n_local] = value;
+        }
+        workgroupBarrier();
+        for (var kk = 0u; kk < 16u; kk++) {
+            var b_values: array<f32, 4>;
+            for (var c = 0u; c < 4u; c++) { b_values[c] = tile_b[kk][local.x * 4u + c]; }
+            for (var r = 0u; r < 4u; r++) {
+                let a_value = tile_a[local.y * 4u + r][kk];
+                for (var c = 0u; c < 4u; c++) { acc[r][c] += a_value * b_values[c]; }
+            }
+        }
+        workgroupBarrier();
+    }
+    for (var r = 0u; r < 4u; r++) {
+        let out_row = tile_row + local.y * 4u + r;
+        for (var c = 0u; c < 4u; c++) {
+            let out_col = tile_n + local.x * 4u + c;
+            if (out_row < 64u && out_col < 2048u) {
+                let i = (batch * 64u + out_row) * 2048u + out_col;
+                out[i] = f32(acc[r][c] + 0.0);
+            }
+        }
+    }
+}

qwen35-2b-fp32-int8-g32-exclude-l6-l9-l10up-l15o-home-token-major-v2-v4/kernels/bd70e4fc42ac55f0f52612841bcc3f9fe7df5bbb0fc76f94e56a131a92454658.wgsl

@@ -0,0 +1,9 @@
+@group(0) @binding(0) var<storage, read> b0: array<f32>;
+@group(0) @binding(1) var<storage, read_write> out: array<f32>;
+
+@compute @workgroup_size(64)
+fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+let i = gid.x + gid.y * 24576u;
+if (i >= 24576u) { return; }
+out[i] = f32(b0[((i / 24576u) % 1u) * 32768u + ((i / 12288u) % 2u) * 16384u + ((i / 192u) % 64u) * 256u + (((i / 1u) % 192u) * 1u + 64u) * 1u]);
+}