mlx-bun 0.0.4

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

@@ -0,0 +1,500 @@
+// GENERATED by scripts/gen-model.ts — DO NOT EDIT (regenerate instead):
+//   bun scripts/gen-model.ts <model-dir> gemma4-26b
+// source: models--mlx-community--gemma-4-26B-A4B-it-OptiQ-4bit/snapshots/dbfd2a779b038b267bb20ff95dad717f42e4de16
+// fingerprint: c9dd67ed5a525231
+//
+// 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 { Gemma4Model, type DecoderLayer } from "../gemma4";
+
+export const FINGERPRINT = "c9dd67ed5a525231";
+
+/** 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 donorSlidQuantG64B8VMoeScal(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 = (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 h1 = layer.preFfNorm.forward(h);
+  h1 = disposing(h1, layer.mlp.forward(h1));
+  h1 = disposing(h1, layer.postFfNorm1!.forward(h1));
+  const { indices, weights: topKWeights } = layer.router!.forward(h);
+  let h2 = layer.preFfNorm2!.forward(h);
+  h2 = disposing(h2, layer.experts!.forward(h2, indices, topKWeights));
+  h2 = disposing(h2, layer.postFfNorm2!.forward(h2));
+  indices.dispose();
+  topKWeights.dispose();
+  let f = ops.add(h1, h2);
+  h1.dispose();
+  h2.dispose();
+  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 donorSlidQuantG64B4VMoeScal(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 = (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 h1 = layer.preFfNorm.forward(h);
+  h1 = disposing(h1, layer.mlp.forward(h1));
+  h1 = disposing(h1, layer.postFfNorm1!.forward(h1));
+  const { indices, weights: topKWeights } = layer.router!.forward(h);
+  let h2 = layer.preFfNorm2!.forward(h);
+  h2 = disposing(h2, layer.experts!.forward(h2, indices, topKWeights));
+  h2 = disposing(h2, layer.postFfNorm2!.forward(h2));
+  indices.dispose();
+  topKWeights.dispose();
+  let f = ops.add(h1, h2);
+  h1.dispose();
+  h2.dispose();
+  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 donorFullQuantG64B8KeqVMoeScal(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=8 group_size=64 nRep=8 head_dim=512
+  const attn = (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 h1 = layer.preFfNorm.forward(h);
+  h1 = disposing(h1, layer.mlp.forward(h1));
+  h1 = disposing(h1, layer.postFfNorm1!.forward(h1));
+  const { indices, weights: topKWeights } = layer.router!.forward(h);
+  let h2 = layer.preFfNorm2!.forward(h);
+  h2 = disposing(h2, layer.experts!.forward(h2, indices, topKWeights));
+  h2 = disposing(h2, layer.postFfNorm2!.forward(h2));
+  indices.dispose();
+  topKWeights.dispose();
+  let f = ops.add(h1, h2);
+  h1.dispose();
+  h2.dispose();
+  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 donorFullQuantG64B4KeqVMoeScal(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=8 head_dim=512
+  const attn = (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 h1 = layer.preFfNorm.forward(h);
+  h1 = disposing(h1, layer.mlp.forward(h1));
+  h1 = disposing(h1, layer.postFfNorm1!.forward(h1));
+  const { indices, weights: topKWeights } = layer.router!.forward(h);
+  let h2 = layer.preFfNorm2!.forward(h);
+  h2 = disposing(h2, layer.experts!.forward(h2, indices, topKWeights));
+  h2 = disposing(h2, layer.postFfNorm2!.forward(h2));
+  indices.dispose();
+  topKWeights.dispose();
+  let f = ops.add(h1, h2);
+  h1.dispose();
+  h2.dispose();
+  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 === 30 &&
+      cache[0] instanceof RotatingQuantizedKVCache &&
+      cache[0].bits === 8 &&
+      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 === 8 &&
+      cache[4].groupSize === 64 &&
+      cache[5] instanceof QuantizedKVCache &&
+      cache[5].bits === 8 &&
+      cache[5].groupSize === 64 &&
+      cache[6] instanceof RotatingQuantizedKVCache &&
+      cache[6].bits === 4 &&
+      cache[6].groupSize === 64 &&
+      cache[7] instanceof RotatingQuantizedKVCache &&
+      cache[7].bits === 4 &&
+      cache[7].groupSize === 64 &&
+      cache[8] instanceof RotatingQuantizedKVCache &&
+      cache[8].bits === 8 &&
+      cache[8].groupSize === 64 &&
+      cache[9] instanceof RotatingQuantizedKVCache &&
+      cache[9].bits === 8 &&
+      cache[9].groupSize === 64 &&
+      cache[10] instanceof RotatingQuantizedKVCache &&
+      cache[10].bits === 4 &&
+      cache[10].groupSize === 64 &&
+      cache[11] instanceof QuantizedKVCache &&
+      cache[11].bits === 8 &&
+      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
+    );
+  }
+
+  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 = donorSlidQuantG64B8VMoeScal(this.layers[0]!, h, maskS, cache[0] as RotatingQuantizedKVCache);
+    h.dispose();
+    h = next;
+    next = donorSlidQuantG64B4VMoeScal(this.layers[1]!, h, maskS, cache[1] as RotatingQuantizedKVCache);
+    h.dispose();
+    h = next;
+    next = donorSlidQuantG64B4VMoeScal(this.layers[2]!, h, maskS, cache[2] as RotatingQuantizedKVCache);
+    h.dispose();
+    h = next;
+    next = donorSlidQuantG64B8VMoeScal(this.layers[3]!, h, maskS, cache[3] as RotatingQuantizedKVCache);
+    h.dispose();
+    h = next;
+    next = donorSlidQuantG64B8VMoeScal(this.layers[4]!, h, maskS, cache[4] as RotatingQuantizedKVCache);
+    h.dispose();
+    h = next;
+    next = donorFullQuantG64B8KeqVMoeScal(this.layers[5]!, h, maskF, cache[5] as QuantizedKVCache);
+    h.dispose();
+    h = next;
+    next = donorSlidQuantG64B4VMoeScal(this.layers[6]!, h, maskS, cache[6] as RotatingQuantizedKVCache);
+    h.dispose();
+    h = next;
+    next = donorSlidQuantG64B4VMoeScal(this.layers[7]!, h, maskS, cache[7] as RotatingQuantizedKVCache);
+    h.dispose();
+    h = next;
+    next = donorSlidQuantG64B8VMoeScal(this.layers[8]!, h, maskS, cache[8] as RotatingQuantizedKVCache);
+    h.dispose();
+    h = next;
+    next = donorSlidQuantG64B8VMoeScal(this.layers[9]!, h, maskS, cache[9] as RotatingQuantizedKVCache);
+    h.dispose();
+    h = next;
+    next = donorSlidQuantG64B4VMoeScal(this.layers[10]!, h, maskS, cache[10] as RotatingQuantizedKVCache);
+    h.dispose();
+    h = next;
+    next = donorFullQuantG64B8KeqVMoeScal(this.layers[11]!, h, maskF, cache[11] as QuantizedKVCache);
+    h.dispose();
+    h = next;
+    next = donorSlidQuantG64B8VMoeScal(this.layers[12]!, h, maskS, cache[12] as RotatingQuantizedKVCache);
+    h.dispose();
+    h = next;
+    next = donorSlidQuantG64B4VMoeScal(this.layers[13]!, h, maskS, cache[13] as RotatingQuantizedKVCache);
+    h.dispose();
+    h = next;
+    next = donorSlidQuantG64B4VMoeScal(this.layers[14]!, h, maskS, cache[14] as RotatingQuantizedKVCache);
+    h.dispose();
+    h = next;
+    next = donorSlidQuantG64B4VMoeScal(this.layers[15]!, h, maskS, cache[15] as RotatingQuantizedKVCache);
+    h.dispose();
+    h = next;
+    next = donorSlidQuantG64B4VMoeScal(this.layers[16]!, h, maskS, cache[16] as RotatingQuantizedKVCache);
+    h.dispose();
+    h = next;
+    next = donorFullQuantG64B4KeqVMoeScal(this.layers[17]!, h, maskF, cache[17] as QuantizedKVCache);
+    h.dispose();
+    h = next;
+    next = donorSlidQuantG64B4VMoeScal(this.layers[18]!, h, maskS, cache[18] as RotatingQuantizedKVCache);
+    h.dispose();
+    h = next;
+    next = donorSlidQuantG64B4VMoeScal(this.layers[19]!, h, maskS, cache[19] as RotatingQuantizedKVCache);
+    h.dispose();
+    h = next;
+    next = donorSlidQuantG64B4VMoeScal(this.layers[20]!, h, maskS, cache[20] as RotatingQuantizedKVCache);
+    h.dispose();
+    h = next;
+    next = donorSlidQuantG64B4VMoeScal(this.layers[21]!, h, maskS, cache[21] as RotatingQuantizedKVCache);
+    h.dispose();
+    h = next;
+    next = donorSlidQuantG64B4VMoeScal(this.layers[22]!, h, maskS, cache[22] as RotatingQuantizedKVCache);
+    h.dispose();
+    h = next;
+    next = donorFullQuantG64B4KeqVMoeScal(this.layers[23]!, h, maskF, cache[23] as QuantizedKVCache);
+    h.dispose();
+    h = next;
+    next = donorSlidQuantG64B4VMoeScal(this.layers[24]!, h, maskS, cache[24] as RotatingQuantizedKVCache);
+    h.dispose();
+    h = next;
+    next = donorSlidQuantG64B4VMoeScal(this.layers[25]!, h, maskS, cache[25] as RotatingQuantizedKVCache);
+    h.dispose();
+    h = next;
+    next = donorSlidQuantG64B4VMoeScal(this.layers[26]!, h, maskS, cache[26] as RotatingQuantizedKVCache);
+    h.dispose();
+    h = next;
+    next = donorSlidQuantG64B4VMoeScal(this.layers[27]!, h, maskS, cache[27] as RotatingQuantizedKVCache);
+    h.dispose();
+    h = next;
+    next = donorSlidQuantG64B4VMoeScal(this.layers[28]!, h, maskS, cache[28] as RotatingQuantizedKVCache);
+    h.dispose();
+    h = next;
+    next = donorFullQuantG64B4KeqVMoeScal(this.layers[29]!, h, maskF, cache[29] as QuantizedKVCache);
+    h.dispose();
+    h = next;
+
+    maskS.arr?.dispose();
+    maskF.arr?.dispose();
+    return disposing(h, this.finalNorm.forward(h));
+  }
+}