mlx-bun 0.0.4

package/src/model/generated/gemma4-12b.ts

@@ -0,0 +1,526 @@
+// GENERATED by scripts/gen-model.ts — DO NOT EDIT (regenerate instead):
+//   bun scripts/gen-model.ts <model-dir> gemma4-12b
+// source: models--mlx-community--gemma-4-12B-it-OptiQ-4bit/snapshots/5b1101065d2094c8f12aa87fee80e0afa5b292b7
+// fingerprint: 9f812d2eb461fcbe
+//
+// Branch-resolved, unrolled forward pass for this architecture
+// (docs/design/optimization_plan.md Phase C). Bit-exactness vs the monolith is the
+// generator's gate: tests/generated-parity.test.ts. The cache-signature
+// guard falls back to the monolith for anything this file wasn't
+// generated for (bf16 compat runs, vision bidir prefill).
+
+import { MlxArray } from "../../mlx/array";
+import * as ops from "../../mlx/ops";
+import {
+  disposing,
+  fusedSdpaRuntimeOk,
+  KVCache,
+  QuantizedKVCache,
+  quantizedSdpaTiled,
+  quantizedSdpaUnfused,
+  RotatingKVCache,
+  RotatingQuantizedKVCache,
+  type Cache,
+  type Mask,
+  type SharedKv,
+} from "../gemma4-base";
+import {
+  fusedDecodeKernelSupported, fusedDecodeSdpa, perfKernelEnabled,
+} from "../fused-decode-kernel";
+import { Gemma4Model, type DecoderLayer } from "../gemma4";
+
+export const FINGERPRINT = "9f812d2eb461fcbe";
+
+/** Forward passes served by the generated fast path (vs monolith
+ *  fallback) — the parity gate asserts the fast path actually ran. */
+export let generatedForwardUses = 0;
+
+function disposeSharedKv(s: SharedKv): void {
+  if (s.kind === "plain") {
+    s.keys.dispose();
+    s.values.dispose();
+  } else {
+    for (const t of [s.keys, s.values])
+      for (const a of [t.packed, t.scales, t.biases]) a.dispose();
+  }
+}
+
+function donorSlidQuantG64B4VScal(layer: DecoderLayer, x: MlxArray, mask: Mask, cache: RotatingQuantizedKVCache): MlxArray {
+  const a = layer.attn;
+  const [B, L] = x.shape as [number, number, number];
+  let h = layer.inputNorm.forward(x);
+  let q = a.qProj.forward(h);
+  q = disposing(q, ops.reshape(q, [B, L, a.nHeads, a.headDim]));
+  q = disposing(q, a.qNorm.forward(q));
+  const offset = cache.offset;
+  let k = a.kProj!.forward(h);
+  k = disposing(k, ops.reshape(k, [B, L, a.nKvHeads, a.headDim]));
+  let v = a.vProj!.forward(h);
+  v = disposing(v, ops.reshape(v, [B, L, a.nKvHeads, a.headDim]));
+  const kNormed = a.kNorm!.forward(k);
+  const kT = ops.transposeAxes(kNormed, [0, 2, 1, 3]);
+  kNormed.dispose();
+  const kRoped = a.rope(kT, cache.ropeOffsetArr ?? offset);
+  kT.dispose();
+  const vNormed = a.vNorm!.forward(v);
+  const vT = ops.transposeAxes(vNormed, [0, 2, 1, 3]);
+  vNormed.dispose();
+  v.dispose();
+  k.dispose();
+  const [kq, vq] = cache.updateAndFetchQuantized(kRoped, vT);
+  kRoped.dispose();
+  vT.dispose();
+  q = disposing(q, ops.transposeAxes(q, [0, 2, 1, 3]));
+  q = disposing(q, a.rope(q, cache.ropeOffsetArr ?? offset));
+  // dispatch-site constants: bits=4 group_size=64 nRep=2 head_dim=256
+  const attn = perfKernelEnabled() && mask.mode === "" && fusedDecodeKernelSupported(q, 4, 64)
+    ? fusedDecodeSdpa(q, kq, vq, 64, 4)
+    : (L > 1 || process.env.MLX_BUN_FUSED_DECODE === "1") && fusedSdpaRuntimeOk(q, mask)
+      ? quantizedSdpaTiled(q, kq, vq, 1.0, mask, 64, 4)
+      : quantizedSdpaUnfused(q, kq, vq, 1.0, mask, 64, 4);
+  q.dispose();
+  const attnT = ops.transposeAxes(attn, [0, 2, 1, 3]);
+  attn.dispose();
+  const merged = ops.reshape(attnT, [B, L, -1]);
+  attnT.dispose();
+  const out = a.oProj.forward(merged);
+  merged.dispose();
+  h.dispose();
+  h = out;
+  h = disposing(h, layer.postAttnNorm.forward(h));
+  h = disposing(h, ops.add(x, h));
+  const residual = h;
+  let f = layer.preFfNorm.forward(h);
+  f = disposing(f, layer.mlp.forward(f));
+  f = disposing(f, layer.postFfNorm.forward(f));
+  h = ops.add(residual, f);
+  residual.dispose();
+  f.dispose();
+  h = disposing(h, ops.mul(h, layer.layerScalar!));
+  for (const t of [kq, vq]) for (const c of [t.packed, t.scales, t.biases]) c.dispose();
+  return h;
+}
+
+function donorSlidQuantG64B8VScal(layer: DecoderLayer, x: MlxArray, mask: Mask, cache: RotatingQuantizedKVCache): MlxArray {
+  const a = layer.attn;
+  const [B, L] = x.shape as [number, number, number];
+  let h = layer.inputNorm.forward(x);
+  let q = a.qProj.forward(h);
+  q = disposing(q, ops.reshape(q, [B, L, a.nHeads, a.headDim]));
+  q = disposing(q, a.qNorm.forward(q));
+  const offset = cache.offset;
+  let k = a.kProj!.forward(h);
+  k = disposing(k, ops.reshape(k, [B, L, a.nKvHeads, a.headDim]));
+  let v = a.vProj!.forward(h);
+  v = disposing(v, ops.reshape(v, [B, L, a.nKvHeads, a.headDim]));
+  const kNormed = a.kNorm!.forward(k);
+  const kT = ops.transposeAxes(kNormed, [0, 2, 1, 3]);
+  kNormed.dispose();
+  const kRoped = a.rope(kT, cache.ropeOffsetArr ?? offset);
+  kT.dispose();
+  const vNormed = a.vNorm!.forward(v);
+  const vT = ops.transposeAxes(vNormed, [0, 2, 1, 3]);
+  vNormed.dispose();
+  v.dispose();
+  k.dispose();
+  const [kq, vq] = cache.updateAndFetchQuantized(kRoped, vT);
+  kRoped.dispose();
+  vT.dispose();
+  q = disposing(q, ops.transposeAxes(q, [0, 2, 1, 3]));
+  q = disposing(q, a.rope(q, cache.ropeOffsetArr ?? offset));
+  // dispatch-site constants: bits=8 group_size=64 nRep=2 head_dim=256
+  const attn = perfKernelEnabled() && mask.mode === "" && fusedDecodeKernelSupported(q, 8, 64)
+    ? fusedDecodeSdpa(q, kq, vq, 64, 8)
+    : (L > 1 || process.env.MLX_BUN_FUSED_DECODE === "1") && fusedSdpaRuntimeOk(q, mask)
+      ? quantizedSdpaTiled(q, kq, vq, 1.0, mask, 64, 8)
+      : quantizedSdpaUnfused(q, kq, vq, 1.0, mask, 64, 8);
+  q.dispose();
+  const attnT = ops.transposeAxes(attn, [0, 2, 1, 3]);
+  attn.dispose();
+  const merged = ops.reshape(attnT, [B, L, -1]);
+  attnT.dispose();
+  const out = a.oProj.forward(merged);
+  merged.dispose();
+  h.dispose();
+  h = out;
+  h = disposing(h, layer.postAttnNorm.forward(h));
+  h = disposing(h, ops.add(x, h));
+  const residual = h;
+  let f = layer.preFfNorm.forward(h);
+  f = disposing(f, layer.mlp.forward(f));
+  f = disposing(f, layer.postFfNorm.forward(f));
+  h = ops.add(residual, f);
+  residual.dispose();
+  f.dispose();
+  h = disposing(h, ops.mul(h, layer.layerScalar!));
+  for (const t of [kq, vq]) for (const c of [t.packed, t.scales, t.biases]) c.dispose();
+  return h;
+}
+
+function donorFullQuantG64B4KeqVScal(layer: DecoderLayer, x: MlxArray, mask: Mask, cache: QuantizedKVCache): MlxArray {
+  const a = layer.attn;
+  const [B, L] = x.shape as [number, number, number];
+  let h = layer.inputNorm.forward(x);
+  let q = a.qProj.forward(h);
+  q = disposing(q, ops.reshape(q, [B, L, a.nHeads, a.headDim]));
+  q = disposing(q, a.qNorm.forward(q));
+  const offset = cache.offset;
+  let k = a.kProj!.forward(h);
+  k = disposing(k, ops.reshape(k, [B, L, a.nKvHeads, a.headDim]));
+  const kNormed = a.kNorm!.forward(k);
+  const kT = ops.transposeAxes(kNormed, [0, 2, 1, 3]);
+  kNormed.dispose();
+  const kRoped = a.rope(kT, cache.ropeOffsetArr ?? offset);
+  kT.dispose();
+  const vNormed = a.vNorm!.forward(k);
+  const vT = ops.transposeAxes(vNormed, [0, 2, 1, 3]);
+  vNormed.dispose();
+  k.dispose();
+  const [kq, vq] = cache.updateAndFetchQuantized(kRoped, vT);
+  kRoped.dispose();
+  vT.dispose();
+  q = disposing(q, ops.transposeAxes(q, [0, 2, 1, 3]));
+  q = disposing(q, a.rope(q, cache.ropeOffsetArr ?? offset));
+  // dispatch-site constants: bits=4 group_size=64 nRep=16 head_dim=512
+  const attn = perfKernelEnabled() && mask.mode === "" && fusedDecodeKernelSupported(q, 4, 64)
+    ? fusedDecodeSdpa(q, kq, vq, 64, 4)
+    : (L > 1 || process.env.MLX_BUN_FUSED_DECODE === "1") && fusedSdpaRuntimeOk(q, mask)
+      ? quantizedSdpaTiled(q, kq, vq, 1.0, mask, 64, 4)
+      : quantizedSdpaUnfused(q, kq, vq, 1.0, mask, 64, 4);
+  q.dispose();
+  const attnT = ops.transposeAxes(attn, [0, 2, 1, 3]);
+  attn.dispose();
+  const merged = ops.reshape(attnT, [B, L, -1]);
+  attnT.dispose();
+  const out = a.oProj.forward(merged);
+  merged.dispose();
+  h.dispose();
+  h = out;
+  h = disposing(h, layer.postAttnNorm.forward(h));
+  h = disposing(h, ops.add(x, h));
+  const residual = h;
+  let f = layer.preFfNorm.forward(h);
+  f = disposing(f, layer.mlp.forward(f));
+  f = disposing(f, layer.postFfNorm.forward(f));
+  h = ops.add(residual, f);
+  residual.dispose();
+  f.dispose();
+  h = disposing(h, ops.mul(h, layer.layerScalar!));
+  for (const t of [kq, vq]) for (const c of [t.packed, t.scales, t.biases]) c.dispose();
+  return h;
+}
+
+export class GeneratedGemma4 extends Gemma4Model {
+  /** Per-layer cache classes must match what this file was generated
+   *  for; anything else runs the monolith path. */
+  #matches(cache: Cache[]): boolean {
+    return (
+      cache.length === 48 &&
+      cache[0] instanceof RotatingQuantizedKVCache &&
+      cache[0].bits === 4 &&
+      cache[0].groupSize === 64 &&
+      cache[1] instanceof RotatingQuantizedKVCache &&
+      cache[1].bits === 4 &&
+      cache[1].groupSize === 64 &&
+      cache[2] instanceof RotatingQuantizedKVCache &&
+      cache[2].bits === 4 &&
+      cache[2].groupSize === 64 &&
+      cache[3] instanceof RotatingQuantizedKVCache &&
+      cache[3].bits === 8 &&
+      cache[3].groupSize === 64 &&
+      cache[4] instanceof RotatingQuantizedKVCache &&
+      cache[4].bits === 4 &&
+      cache[4].groupSize === 64 &&
+      cache[5] instanceof QuantizedKVCache &&
+      cache[5].bits === 4 &&
+      cache[5].groupSize === 64 &&
+      cache[6] instanceof RotatingQuantizedKVCache &&
+      cache[6].bits === 8 &&
+      cache[6].groupSize === 64 &&
+      cache[7] instanceof RotatingQuantizedKVCache &&
+      cache[7].bits === 8 &&
+      cache[7].groupSize === 64 &&
+      cache[8] instanceof RotatingQuantizedKVCache &&
+      cache[8].bits === 8 &&
+      cache[8].groupSize === 64 &&
+      cache[9] instanceof RotatingQuantizedKVCache &&
+      cache[9].bits === 4 &&
+      cache[9].groupSize === 64 &&
+      cache[10] instanceof RotatingQuantizedKVCache &&
+      cache[10].bits === 8 &&
+      cache[10].groupSize === 64 &&
+      cache[11] instanceof QuantizedKVCache &&
+      cache[11].bits === 4 &&
+      cache[11].groupSize === 64 &&
+      cache[12] instanceof RotatingQuantizedKVCache &&
+      cache[12].bits === 8 &&
+      cache[12].groupSize === 64 &&
+      cache[13] instanceof RotatingQuantizedKVCache &&
+      cache[13].bits === 4 &&
+      cache[13].groupSize === 64 &&
+      cache[14] instanceof RotatingQuantizedKVCache &&
+      cache[14].bits === 4 &&
+      cache[14].groupSize === 64 &&
+      cache[15] instanceof RotatingQuantizedKVCache &&
+      cache[15].bits === 4 &&
+      cache[15].groupSize === 64 &&
+      cache[16] instanceof RotatingQuantizedKVCache &&
+      cache[16].bits === 4 &&
+      cache[16].groupSize === 64 &&
+      cache[17] instanceof QuantizedKVCache &&
+      cache[17].bits === 4 &&
+      cache[17].groupSize === 64 &&
+      cache[18] instanceof RotatingQuantizedKVCache &&
+      cache[18].bits === 4 &&
+      cache[18].groupSize === 64 &&
+      cache[19] instanceof RotatingQuantizedKVCache &&
+      cache[19].bits === 4 &&
+      cache[19].groupSize === 64 &&
+      cache[20] instanceof RotatingQuantizedKVCache &&
+      cache[20].bits === 4 &&
+      cache[20].groupSize === 64 &&
+      cache[21] instanceof RotatingQuantizedKVCache &&
+      cache[21].bits === 4 &&
+      cache[21].groupSize === 64 &&
+      cache[22] instanceof RotatingQuantizedKVCache &&
+      cache[22].bits === 4 &&
+      cache[22].groupSize === 64 &&
+      cache[23] instanceof QuantizedKVCache &&
+      cache[23].bits === 4 &&
+      cache[23].groupSize === 64 &&
+      cache[24] instanceof RotatingQuantizedKVCache &&
+      cache[24].bits === 4 &&
+      cache[24].groupSize === 64 &&
+      cache[25] instanceof RotatingQuantizedKVCache &&
+      cache[25].bits === 4 &&
+      cache[25].groupSize === 64 &&
+      cache[26] instanceof RotatingQuantizedKVCache &&
+      cache[26].bits === 4 &&
+      cache[26].groupSize === 64 &&
+      cache[27] instanceof RotatingQuantizedKVCache &&
+      cache[27].bits === 4 &&
+      cache[27].groupSize === 64 &&
+      cache[28] instanceof RotatingQuantizedKVCache &&
+      cache[28].bits === 4 &&
+      cache[28].groupSize === 64 &&
+      cache[29] instanceof QuantizedKVCache &&
+      cache[29].bits === 4 &&
+      cache[29].groupSize === 64 &&
+      cache[30] instanceof RotatingQuantizedKVCache &&
+      cache[30].bits === 4 &&
+      cache[30].groupSize === 64 &&
+      cache[31] instanceof RotatingQuantizedKVCache &&
+      cache[31].bits === 4 &&
+      cache[31].groupSize === 64 &&
+      cache[32] instanceof RotatingQuantizedKVCache &&
+      cache[32].bits === 4 &&
+      cache[32].groupSize === 64 &&
+      cache[33] instanceof RotatingQuantizedKVCache &&
+      cache[33].bits === 4 &&
+      cache[33].groupSize === 64 &&
+      cache[34] instanceof RotatingQuantizedKVCache &&
+      cache[34].bits === 4 &&
+      cache[34].groupSize === 64 &&
+      cache[35] instanceof QuantizedKVCache &&
+      cache[35].bits === 4 &&
+      cache[35].groupSize === 64 &&
+      cache[36] instanceof RotatingQuantizedKVCache &&
+      cache[36].bits === 4 &&
+      cache[36].groupSize === 64 &&
+      cache[37] instanceof RotatingQuantizedKVCache &&
+      cache[37].bits === 4 &&
+      cache[37].groupSize === 64 &&
+      cache[38] instanceof RotatingQuantizedKVCache &&
+      cache[38].bits === 4 &&
+      cache[38].groupSize === 64 &&
+      cache[39] instanceof RotatingQuantizedKVCache &&
+      cache[39].bits === 4 &&
+      cache[39].groupSize === 64 &&
+      cache[40] instanceof RotatingQuantizedKVCache &&
+      cache[40].bits === 4 &&
+      cache[40].groupSize === 64 &&
+      cache[41] instanceof QuantizedKVCache &&
+      cache[41].bits === 4 &&
+      cache[41].groupSize === 64 &&
+      cache[42] instanceof RotatingQuantizedKVCache &&
+      cache[42].bits === 4 &&
+      cache[42].groupSize === 64 &&
+      cache[43] instanceof RotatingQuantizedKVCache &&
+      cache[43].bits === 4 &&
+      cache[43].groupSize === 64 &&
+      cache[44] instanceof RotatingQuantizedKVCache &&
+      cache[44].bits === 4 &&
+      cache[44].groupSize === 64 &&
+      cache[45] instanceof RotatingQuantizedKVCache &&
+      cache[45].bits === 4 &&
+      cache[45].groupSize === 64 &&
+      cache[46] instanceof RotatingQuantizedKVCache &&
+      cache[46].bits === 4 &&
+      cache[46].groupSize === 64 &&
+      cache[47] instanceof QuantizedKVCache &&
+      cache[47].bits === 4 &&
+      cache[47].groupSize === 64
+    );
+  }
+
+  protected override forwardLayers(
+    h0: MlxArray, cache: Cache[], bidir: MlxArray | null, ids: MlxArray | null,
+  ): MlxArray {
+    if (bidir !== null || !this.#matches(cache))
+      return super.forwardLayers(h0, cache, bidir, ids);
+    generatedForwardUses++;
+    const L = h0.shape[1]!;
+    const maskS = cache[0]!.makeMask(L, this.windowSize);
+    const maskF = cache[5]!.makeMask(L, null);
+    let h = h0;
+    let next: MlxArray;
+    next = donorSlidQuantG64B4VScal(this.layers[0]!, h, maskS, cache[0] as RotatingQuantizedKVCache);
+    h.dispose();
+    h = next;
+    next = donorSlidQuantG64B4VScal(this.layers[1]!, h, maskS, cache[1] as RotatingQuantizedKVCache);
+    h.dispose();
+    h = next;
+    next = donorSlidQuantG64B4VScal(this.layers[2]!, h, maskS, cache[2] as RotatingQuantizedKVCache);
+    h.dispose();
+    h = next;
+    next = donorSlidQuantG64B8VScal(this.layers[3]!, h, maskS, cache[3] as RotatingQuantizedKVCache);
+    h.dispose();
+    h = next;
+    next = donorSlidQuantG64B4VScal(this.layers[4]!, h, maskS, cache[4] as RotatingQuantizedKVCache);
+    h.dispose();
+    h = next;
+    next = donorFullQuantG64B4KeqVScal(this.layers[5]!, h, maskF, cache[5] as QuantizedKVCache);
+    h.dispose();
+    h = next;
+    next = donorSlidQuantG64B8VScal(this.layers[6]!, h, maskS, cache[6] as RotatingQuantizedKVCache);
+    h.dispose();
+    h = next;
+    next = donorSlidQuantG64B8VScal(this.layers[7]!, h, maskS, cache[7] as RotatingQuantizedKVCache);
+    h.dispose();
+    h = next;
+    next = donorSlidQuantG64B8VScal(this.layers[8]!, h, maskS, cache[8] as RotatingQuantizedKVCache);
+    h.dispose();
+    h = next;
+    next = donorSlidQuantG64B4VScal(this.layers[9]!, h, maskS, cache[9] as RotatingQuantizedKVCache);
+    h.dispose();
+    h = next;
+    next = donorSlidQuantG64B8VScal(this.layers[10]!, h, maskS, cache[10] as RotatingQuantizedKVCache);
+    h.dispose();
+    h = next;
+    next = donorFullQuantG64B4KeqVScal(this.layers[11]!, h, maskF, cache[11] as QuantizedKVCache);
+    h.dispose();
+    h = next;
+    next = donorSlidQuantG64B8VScal(this.layers[12]!, h, maskS, cache[12] as RotatingQuantizedKVCache);
+    h.dispose();
+    h = next;
+    next = donorSlidQuantG64B4VScal(this.layers[13]!, h, maskS, cache[13] as RotatingQuantizedKVCache);
+    h.dispose();
+    h = next;
+    next = donorSlidQuantG64B4VScal(this.layers[14]!, h, maskS, cache[14] as RotatingQuantizedKVCache);
+    h.dispose();
+    h = next;
+    next = donorSlidQuantG64B4VScal(this.layers[15]!, h, maskS, cache[15] as RotatingQuantizedKVCache);
+    h.dispose();
+    h = next;
+    next = donorSlidQuantG64B4VScal(this.layers[16]!, h, maskS, cache[16] as RotatingQuantizedKVCache);
+    h.dispose();
+    h = next;
+    next = donorFullQuantG64B4KeqVScal(this.layers[17]!, h, maskF, cache[17] as QuantizedKVCache);
+    h.dispose();
+    h = next;
+    next = donorSlidQuantG64B4VScal(this.layers[18]!, h, maskS, cache[18] as RotatingQuantizedKVCache);
+    h.dispose();
+    h = next;
+    next = donorSlidQuantG64B4VScal(this.layers[19]!, h, maskS, cache[19] as RotatingQuantizedKVCache);
+    h.dispose();
+    h = next;
+    next = donorSlidQuantG64B4VScal(this.layers[20]!, h, maskS, cache[20] as RotatingQuantizedKVCache);
+    h.dispose();
+    h = next;
+    next = donorSlidQuantG64B4VScal(this.layers[21]!, h, maskS, cache[21] as RotatingQuantizedKVCache);
+    h.dispose();
+    h = next;
+    next = donorSlidQuantG64B4VScal(this.layers[22]!, h, maskS, cache[22] as RotatingQuantizedKVCache);
+    h.dispose();
+    h = next;
+    next = donorFullQuantG64B4KeqVScal(this.layers[23]!, h, maskF, cache[23] as QuantizedKVCache);
+    h.dispose();
+    h = next;
+    next = donorSlidQuantG64B4VScal(this.layers[24]!, h, maskS, cache[24] as RotatingQuantizedKVCache);
+    h.dispose();
+    h = next;
+    next = donorSlidQuantG64B4VScal(this.layers[25]!, h, maskS, cache[25] as RotatingQuantizedKVCache);
+    h.dispose();
+    h = next;
+    next = donorSlidQuantG64B4VScal(this.layers[26]!, h, maskS, cache[26] as RotatingQuantizedKVCache);
+    h.dispose();
+    h = next;
+    next = donorSlidQuantG64B4VScal(this.layers[27]!, h, maskS, cache[27] as RotatingQuantizedKVCache);
+    h.dispose();
+    h = next;
+    next = donorSlidQuantG64B4VScal(this.layers[28]!, h, maskS, cache[28] as RotatingQuantizedKVCache);
+    h.dispose();
+    h = next;
+    next = donorFullQuantG64B4KeqVScal(this.layers[29]!, h, maskF, cache[29] as QuantizedKVCache);
+    h.dispose();
+    h = next;
+    next = donorSlidQuantG64B4VScal(this.layers[30]!, h, maskS, cache[30] as RotatingQuantizedKVCache);
+    h.dispose();
+    h = next;
+    next = donorSlidQuantG64B4VScal(this.layers[31]!, h, maskS, cache[31] as RotatingQuantizedKVCache);
+    h.dispose();
+    h = next;
+    next = donorSlidQuantG64B4VScal(this.layers[32]!, h, maskS, cache[32] as RotatingQuantizedKVCache);
+    h.dispose();
+    h = next;
+    next = donorSlidQuantG64B4VScal(this.layers[33]!, h, maskS, cache[33] as RotatingQuantizedKVCache);
+    h.dispose();
+    h = next;
+    next = donorSlidQuantG64B4VScal(this.layers[34]!, h, maskS, cache[34] as RotatingQuantizedKVCache);
+    h.dispose();
+    h = next;
+    next = donorFullQuantG64B4KeqVScal(this.layers[35]!, h, maskF, cache[35] as QuantizedKVCache);
+    h.dispose();
+    h = next;
+    next = donorSlidQuantG64B4VScal(this.layers[36]!, h, maskS, cache[36] as RotatingQuantizedKVCache);
+    h.dispose();
+    h = next;
+    next = donorSlidQuantG64B4VScal(this.layers[37]!, h, maskS, cache[37] as RotatingQuantizedKVCache);
+    h.dispose();
+    h = next;
+    next = donorSlidQuantG64B4VScal(this.layers[38]!, h, maskS, cache[38] as RotatingQuantizedKVCache);
+    h.dispose();
+    h = next;
+    next = donorSlidQuantG64B4VScal(this.layers[39]!, h, maskS, cache[39] as RotatingQuantizedKVCache);
+    h.dispose();
+    h = next;
+    next = donorSlidQuantG64B4VScal(this.layers[40]!, h, maskS, cache[40] as RotatingQuantizedKVCache);
+    h.dispose();
+    h = next;
+    next = donorFullQuantG64B4KeqVScal(this.layers[41]!, h, maskF, cache[41] as QuantizedKVCache);
+    h.dispose();
+    h = next;
+    next = donorSlidQuantG64B4VScal(this.layers[42]!, h, maskS, cache[42] as RotatingQuantizedKVCache);
+    h.dispose();
+    h = next;
+    next = donorSlidQuantG64B4VScal(this.layers[43]!, h, maskS, cache[43] as RotatingQuantizedKVCache);
+    h.dispose();
+    h = next;
+    next = donorSlidQuantG64B4VScal(this.layers[44]!, h, maskS, cache[44] as RotatingQuantizedKVCache);
+    h.dispose();
+    h = next;
+    next = donorSlidQuantG64B4VScal(this.layers[45]!, h, maskS, cache[45] as RotatingQuantizedKVCache);
+    h.dispose();
+    h = next;
+    next = donorSlidQuantG64B4VScal(this.layers[46]!, h, maskS, cache[46] as RotatingQuantizedKVCache);
+    h.dispose();
+    h = next;
+    next = donorFullQuantG64B4KeqVScal(this.layers[47]!, h, maskF, cache[47] as QuantizedKVCache);
+    h.dispose();
+    h = next;
+
+    maskS.arr?.dispose();
+    maskF.arr?.dispose();
+    return disposing(h, this.finalNorm.forward(h));
+  }
+}