Upload Qwen3.5-9B-Math-GraphCalc (43-layer zero-gradient WSP + in-weights RV32 graphing calculator)

.gitattributes

@@ -33,3 +33,11 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+assets/architecture.png filter=lfs diff=lfs merge=lfs -text
+assets/benchmarks.png filter=lfs diff=lfs merge=lfs -text
+assets/example_output.png filter=lfs diff=lfs merge=lfs -text
+assets/hero_banner.png filter=lfs diff=lfs merge=lfs -text
+assets/hf_public_benchmarks.png filter=lfs diff=lfs merge=lfs -text
+assets/in_weights_plots.png filter=lfs diff=lfs merge=lfs -text
+chip_indices.bin.zlib filter=lfs diff=lfs merge=lfs -text
+tokenizer.json filter=lfs diff=lfs merge=lfs -text

README.md

@@ -0,0 +1,361 @@
+---
+license: apache-2.0
+license_link: https://huggingface.co/Qwen/Qwen3.5-9B-Base/blob/main/LICENSE
+base_model: Qwen/Qwen3.5-9B-Base
+library_name: transformers
+pipeline_tag: text-generation
+language:
+  - en
+tags:
+  - weight-space-modeling
+  - zero-gradient
+  - risc-v
+  - in-weights-computer
+  - gated-deltanet
+  - math
+  - graphing-calculator
+  - pedagogy
+  - qwen3_5
+model-index:
+  - name: Qwen3.5-9B-Math-GraphCalc
+    results:
+      - task:
+          type: text-generation
+          name: Hard Math & Function Graphing (Disjoint Held-Out)
+        dataset:
+          name: Carbon-GraphCalc-HeldOut-60
+          type: custom
+          split: test
+        metrics:
+          - type: accuracy
+            value: 96.67
+            name: Math Accuracy (%)
+          - type: accuracy
+            value: 70.00
+            name: Verified Pedagogical Teaching (%)
+          - type: accuracy
+            value: 97.06
+            name: Graph Feature Accuracy (%)
+          - type: accuracy
+            value: 100.00
+            name: Function Plotting Rate (%)
+          - type: accuracy
+            value: 100.00
+            name: In-Weights RV32 Execution Lockstep (%)
+      - task:
+          type: text-generation
+          name: Zero-Shot Math Tutoring (Plain + ChatML Held-Out)
+        dataset:
+          name: Carbon-MathTutor-HeldOut-180
+          type: custom
+          split: test
+        metrics:
+          - type: accuracy
+            value: 86.67
+            name: Overall Math Accuracy (%)
+          - type: accuracy
+            value: 80.56
+            name: Plain Q&A Math Accuracy (%)
+          - type: accuracy
+            value: 73.06
+            name: Verified Pedagogical Teaching (%)
+      - task:
+          type: text-generation
+          name: GSM8K Official Test (Zero-Shot Greedy)
+        dataset:
+          name: openai/gsm8k
+          type: openai/gsm8k
+          config: main
+          split: test
+        metrics:
+          - type: accuracy
+            value: 78.85
+            name: ChatML Zero-Shot Accuracy (%)
+          - type: accuracy
+            value: 75.78
+            name: Mean Accuracy Plain+ChatML (%)
+          - type: accuracy
+            value: 53.07
+            name: Verified Pedagogical Teaching (%)
+      - task:
+          type: text-generation
+          name: MATH-500 Official Competition Benchmark (Zero-Shot Greedy)
+        dataset:
+          name: HuggingFaceH4/MATH-500
+          type: HuggingFaceH4/MATH-500
+          split: test
+        metrics:
+          - type: accuracy
+            value: 58.20
+            name: ChatML Zero-Shot Accuracy (%)
+          - type: accuracy
+            value: 51.80
+            name: Mean Accuracy Plain+ChatML (%)
+          - type: accuracy
+            value: 42.40
+            name: Verified Pedagogical Teaching (%)
+      - task:
+          type: text-generation
+          name: AIME 2024 Olympiad Benchmark (Zero-Shot Greedy)
+        dataset:
+          name: HuggingFaceH4/aime_2024
+          type: HuggingFaceH4/aime_2024
+          split: train
+        metrics:
+          - type: accuracy
+            value: 10.00
+            name: ChatML Zero-Shot Accuracy (%)
+---
+
+<p align="center">
+  <img src="assets/hero_banner.png" alt="Qwen3.5-9B-Math-GraphCalc — 9.0B Pedagogical Math Tutor + In-Weights RISC-V Graphing Calculator" width="100%">
+</p>
+
+<p align="center">
+  <a href="https://huggingface.co/Qwen/Qwen3.5-9B-Base"><img src="https://img.shields.io/badge/Base-Qwen3.5--9B--Base-38bdf8?style=flat-square" alt="Base Model"></a>
+  <img src="https://img.shields.io/badge/Params-9.0B%20Nonzero%20BF16-10b981?style=flat-square" alt="9.0B Nonzero Params">
+  <img src="https://img.shields.io/badge/Gradients-0%20(Pure%20Weight%20Space)-34d399?style=flat-square" alt="Zero Gradients">
+  <img src="https://img.shields.io/badge/In--Weights%20CPU-RV32IM%20%2B%20Zba%20%2B%20256b%20Bignum-8b7cf6?style=flat-square" alt="In-Weights CPU">
+</p>
+
+**`Qwen3.5-9B-Math-GraphCalc`** (`8,985,670,530` nonzero `bfloat16` parameters = `8.99B`) is an experimental **43-layer** `Qwen3_5ForCausalLM` model built from [`Qwen/Qwen3.5-9B-Base`](https://huggingface.co/Qwen/Qwen3.5-9B-Base) **strictly in weight space**:
+
+- **Zero gradients** (`torch.set_grad_enabled(False)`), **zero optimizer steps**, and **zero fitting of weights to recorded activations**.
+- **Zero external Python `eval()`, SymPy, or host calculator servers**: 11 compiled Gated-DeltaNet transformer layers (`layers[0..10]`) sit directly in front of Qwen's 32 widened language layers (`layers[11..42]`, `hidden_size = 5632`, `m = 22`) and execute bare-metal RISC-V instructions (`graphcalc.elf`, `87,636` bytes) using Qwen3.5's own Gated-DeltaNet recurrent state as RAM.
+- When asked a multi-digit calculation, algebraic equation, definite integral, or function-graphing question, the model emits `<tool_call>` at token 0, computes exact 256-bit bignums, reduced fractions, 40-iteration CORDIC trig/log values, roots, turning points, Simpson definite integrals, and coordinate samples **inside its forward pass**, and then teaches the solution step by step.
+
+---
+
+## Example Output — 9B Tutor + In-Weights Graphing Calculator
+
+### Example 1: Function Graphing, Roots & Extrema Walkthrough (`169,027` In-Weights RV32 Steps)
+
+> **User Prompt:** `"Graph y = x^3 - 3*x from x = -2 to 2, identify its roots and turning points, and state the local maximum y-value."`
+
+1. **Token 0 — Language layers (`layers[11..42]`) emit `<tool_call>`:**
+   ```xml
+   <tool_call>
+   <function=graphcalc>
+<parameter=expression>
+x^3 - 3*x
+</parameter>
+<parameter=xmin>
+-2
+</parameter>
+<parameter=xmax>
+2
+</parameter>
+</function>
+   </tool_call>
+   ```
+2. **In-Weights RISC-V Execution — `layers[0..10]` run `graphcalc.elf` inside Gated-DeltaNet RAM and emit `<tool_response>`:**
+   ```text
+function: f(x) = x^3 - 3*x  on [-2, 2]
+roots: x = -1.732051, x = 0, x = 1.732051
+local max: (-1, 2) | local min: (1, -2)
+y-intercept: (0, 0) | integral: 0
+table: (-2, -2), (-1.3333, 1.6296), (-0.6667, 1.7037), (0, 0), (0.6667, -1.7037), (1.3333, -1.6296), (2, 2)
+   ```
+   <p align="center">
+     <img src="assets/example_output.png" alt="Rendered curve, roots, extrema and 7-point sample table computed inside layers[0..10] for f(x) = x^3 - 3x" width="100%">
+   </p>
+3. **Verbatim 9B Step-by-Step Tutor Walkthrough — `layers[11..42]` read `<tool_response>` and teach the solution:**
+   > ## 1. Graphing the Function
+   >
+   > Let's first graph the function y = x³ - 3x from x = -2 to x = 2:
+   >
+   > The graph shows a cubic function with:
+   > - A local maximum at (-1, 2)
+   > - A local minimum at (1, -2)
+   > - Passing through the origin (0, 0)
+   > - Symmetric about the origin (odd function)
+   >
+   > ## 2. Finding the Roots
+   >
+   > The roots are the x-values where y = 0. From the graph, we can see the function crosses the x-axis at three points:
+   >
+   > **Roots:**
+   > - x = -1.732051 (approximately -√3)
+   > - x = 0
+   > - x = 1.732051 (approximately √3)
+   >
+   > Let's verify these roots algebraically:
+   > x³ - 3x = 0
+   > x(x² - 3) = 0
+   > x = 0 or x² - 3 = 0
+   > x = 0 or x² = 3
+   > x = 0 or x = ±√3
+   >
+   > So the exact roots are x = -√3, x = 0, and x = √3.
+   >
+   > ## 3. Finding the Turning Points
+   >
+   > Turning points occur where the derivative equals zero. Let's find the derivative:
+   > f(x) = x³ - 3x
+   > f'(x) = 3x² - 3
+   >
+   > Setting f'(x) = 0:
+   > 3x² - 3 = 0
+   > 3x² = 3
+   > x² = 1
+   > x = ±1
+   >
+   > Now let's find the y-values at these x-values:
+   > - At x = -1: f(-1) = (-1)³ - 3(-1) = -1 + 3 = 2
+   > - At x = 1: f(1) = (1)³ - 3(1) = 1 - 3 = -2
+   >
+   > So the turning points are:
+   > - Local maximum at (-1, 2)
+   > - Local minimum at (1, -2)
+   >
+   > ## 4. Local Maximum y-Value
+   >
+   > The local maximum occurs at x = -1, and the y-value at this point is 2.
+   >
+   > **Answer:**
+   > - Roots: x = -√3, x = 0, x = √3
+   > - Turning points: Local maximum at (-1, 2) and local minimum at (1, -2)
+   > - Local maximum y-value: 2
+   >
+   > The function has a local maximum y-value of 2 at x = -1.
+
+### Example 2: Exact 9-Digit Bignum Arithmetic (`15,701` In-Weights RV32 Steps via 256-bit `OP_BN`)
+
+> **User Prompt:** `"Calculate 37429 * 8613 + 194820 and explain your steps."`
+
+1. **In-Weights RISC-V `<tool_response>` (`layers[0..10]`):**
+   ```text
+expression: 37429 * 8613 + 194820
+step 1: 37429 * 8613 = 322375977
+step 2: 322375977 + 194820 = 322570797
+exact value: 322570797
+   ```
+2. **Verbatim 9B Tutor Explanation (`layers[11..42]`):**
+   > ## 37429 * 8613 + 194820
+   >
+   > ## Step 1: Multiply 37429 by 8613
+   >
+   > Let's break this multiplication down:
+   >
+   > 37429 × 8613 = 322,375,977
+   >
+   > ## Step 2: Add 194,820 to the result
+   >
+   > 322,375,977 + 194,820 = 322,570,797
+   >
+   > ## Final Answer: 322,570,797
+   >
+   > The graphing calculator confirmed this exact value. When working with large numbers, it's helpful to break the problem into smaller steps and verify each part.
+
+---
+
+## Functions Solved, Integrated & Sampled Inside 9B Weights
+
+<p align="center">
+  <img src="assets/in_weights_plots.png" alt="Functions solved, integrated, and sampled inside 9B transformer weights (layers[0..10])" width="100%">
+</p>
+
+Every coordinate, root, extremum, and definite integral above is computed token-by-token inside `layers[0..10]` (`0` mismatches between HF `Qwen3_5DecoderLayer` weights, Triton `Executor2`, `BR.Session`, and numpy circuit IR):
+
+| Prompted Function & Domain | In-Weights RV32 Steps | Exact Roots Found | Extrema / Vertex | 48-Panel Simpson `∫ f(x) dx` |
+|---|---:|---|---|---:|
+| `f(x) = x³ − 3x` on `[−2, 2]` | `169,027` | `x = −1.732051, 0, 1.732051` | `max(−1, 2)`, `min(1, −2)` | `0` |
+| `f(x) = 2 sin(x)` on `[0, 6.28]` | `313,365` | `x = 0, 3.141593` | `max(1.570797, 2)`, `min(4.712388, −2)` | `0.00001` |
+| `f(x) = x² − 6x + 5` on `[−1, 7]` | `78,963` | `x = 1, 5` | `vertex (3, −4)` | `10.666667` |
+
+---
+
+## Benchmarks
+
+<p align="center">
+  <img src="assets/benchmarks.png" alt="9B Held-Out Hard-Math & Function Graphing Benchmark (N = 60 Disjoint Problems)" width="100%">
+</p>
+
+### 1. Disjoint Hard-Math & Function Graphing (`N = 60` Unseen Problems, Greedy Decoding)
+
+Across the 60 unseen hard-math and function-graphing problems, `Qwen3.5-9B-Math-GraphCalc` executes **`3,195,505` in-weights RV32 instruction token steps** with **`0` lockstep errors**:
+
+| Model Arm | WSP Base Edits | Compiled RV32 NNZ | Math Acc | Verified Teaching | Graph Feature Acc | Plot Rate | In-Weights Exec OK |
+|---|---:|---:|---:|---:|---:|---:|---:|
+| `Qwen/Qwen3.5-9B-Base` (`32L`) | `0` | `0` | `73.33%` | `63.33%` | `43.14%` | `0.00%` | `0.00%` |
+| `Qwen3.5-9B-Math-Tutor` (`32L WSP`) | `2,916,073` | `0` | `81.67%` | `75.00%` | `53.92%` | `0.00%` | `0.00%` |
+| **`Qwen3.5-9B-Math-GraphCalc` (`43L`)** | **`2,920,169`** | **`1,045,984`** | **`96.67%`** | **`70.00%`** | **`97.06%`** | **`100.00%`** | **`100.00%`** |
+
+### 2. Official Public HuggingFace Math Benchmarks (`7,546` Total Zero-Shot Greedy Evaluations)
+
+<p align="center">
+  <img src="assets/hf_public_benchmarks.png" alt="Official Public HuggingFace Math Benchmarks — GSM8K, MATH-500, AIME 2024, and MATH-500 Computational-50" width="100%">
+</p>
+
+Evaluated zero-shot with greedy decoding directly on official HuggingFace Hub datasets ([`openai/gsm8k`](https://huggingface.co/datasets/openai/gsm8k) full `1,319` test set, [`HuggingFaceH4/MATH-500`](https://huggingface.co/datasets/HuggingFaceH4/MATH-500) full `500` competition set, and [`HuggingFaceH4/aime_2024`](https://huggingface.co/datasets/HuggingFaceH4/aime_2024) full `30` Olympiad set across both raw `Plain Q&A` and `ChatML` formats):
+
+| Public HF Dataset | Arm | Mean Math Acc | Plain Q&A Acc | ChatML Acc | Plain Verified Teach | ChatML Verified Teach |
+|---|---|---:|---:|---:|---:|---:|
+| **`openai/gsm8k`** (`N = 1,319 × 2`) | `Qwen3.5-9B-Base` | `78.54%` | `82.79%` | `74.30%` | `51.40%` | `5.31%` |
+| **`openai/gsm8k`** (`N = 1,319 × 2`) | **`9B WSP Tutor / GraphCalc`** | **`75.78%`** | **`72.71%`** | **`78.85%`** | **`59.89%`** | **`53.07%`** |
+| **`HuggingFaceH4/MATH-500`** (`N = 500 × 2`) | `Qwen3.5-9B-Base` | `48.40%` | `40.60%` | `56.20%` | `17.60%` | `2.80%` |
+| **`HuggingFaceH4/MATH-500`** (`N = 500 × 2`) | **`9B WSP Tutor / GraphCalc`** | **`51.80%`** | **`45.40%`** | **`58.20%`** | **`28.00%`** | **`42.40%`** |
+| **`HuggingFaceH4/aime_2024`** (`N = 30 × 2`) | `Qwen3.5-9B-Base` | `6.67%` | `3.33%` | `10.00%` | `0.00%` | `0.00%` |
+| **`HuggingFaceH4/aime_2024`** (`N = 30 × 2`) | **`9B WSP Tutor / GraphCalc`** | **`8.34%`** | **`6.67%`** | **`10.00%`** | **`6.67%`** | **`0.00%`** |
+
+#### `MATH-500` Accuracy by Competition Difficulty Level (Zero-Shot ChatML)
+
+| Competition Level | `Qwen/Qwen3.5-9B-Base` | **`9B WSP Tutor / GraphCalc`** |
+|---|---:|---:|
+| Level 1 | `88.37%` | **`88.37%`** |
+| Level 2 | `76.67%` | **`77.78%`** |
+| Level 3 | `69.52%` | **`72.38%`** |
+| Level 4 | `48.44%` | **`52.34%`** |
+| Level 5 | `29.10%` | **`29.85%`** |
+
+> **Domain Scope (`<tools>` vs. Standard Zero-Shot):** `graphcalc.elf` implements a specialized single-variable graphing & 256-bit arithmetic/CORDIC calculator (`+ - * / ^`, `sin`, `cos`, `tan`, `sqrt`, `ln`, `exp`, roots, extrema, Simpson integrals). Pass `<tools>` for multi-digit arithmetic, exact fractions, calculus, and function graphing (**`96.67%`** accuracy on `GraphCalc-HeldOut-60`). For general symbolic competition math, modular number theory, or multi-variable systems (where forcing a single-variable `<tool_call>` on a 50-item `MATH-500` scalar slice scored `58.00%` vs `72.00%` without `<tools>` across `2,927,967` RV32 steps), omit `<tools>` — the untied `E6` gate triggers **`0 / 360`** false tool calls and runs at full 32-layer speed.
+
+### 3. Disjoint Zero-Shot Math Tutoring & Language Retention (`N = 180 × 2 = 360` Generations, No `<tools>`)
+
+When prompted without `<tools>`, untied `lm_head` `<tool_call>` calibration (`E6 = 1.3×`) triggers **`0 / 360` false tool calls** while improving zero-shot `plain` Q&A tutoring and preserving `FineWeb-Edu` causal language modeling (`+0.0001` nats):
+
+| Model Arm | Overall Math Acc | Plain Q&A Math Acc | ChatML Math Acc | Verified Teaching | `FineWeb-Edu` NLL | False `<tool_call>` |
+|---|---:|---:|---:|---:|---:|---:|
+| `Qwen/Qwen3.5-9B-Base` | `81.67%` | `68.89%` | `94.44%` | `12.78%` | `2.1093` | `0 / 360` |
+| `Qwen3.5-9B-Math-Tutor` (`A3`) | `86.67%` | `80.56%` | `92.78%` | `73.06%` | `2.1094` | `0 / 360` |
+| **`Qwen3.5-9B-Math-GraphCalc` (no `<tools>`)** | **`86.67%`** | **`80.56%`** | **`92.78%`** | **`73.06%`** | **`2.1094`** | **`0 / 360`** |
+
+---
+
+## Architecture — How the 43-Layer Model Works
+
+<p align="center">
+  <img src="assets/architecture.png" alt="43-Layer Qwen3.5-9B-Math-GraphCalc In-Weights Execution Loop" width="100%">
+</p>
+
+1. **Stage 1 — Untied 9B Weight-Space Tutor Surgery (`2,920,169` base scalar edits):**
+   - **`E1` (Untied Turn-Header Bridge):** Re-anchors `Question` and `Answer` in `embed_tokens.weight` into Qwen3.5-9B's native ChatML turn subspace with zero output-logit side effects, while damping raw `</think>` / `<|file_sep|>` markup leak in untied `lm_head.weight`.
+   - **`E2` & `E3` (Static MLP Subspace Surgery):** Closed-form SVD/projection inspection of `layers[18..31]` damps worksheet continuation, multi-newline collapse, bare MCQ guess, and orthogonalized CJK exam leakage while amplifying clean English step-initiation and deductive-reasoning columns.
+   - **`E6` (Untied `<tool_call>` Gate):** Scales `lm_head.weight[<tool_call>]` (`4,096` scalars) by `1.3×` so `<tool_call>` wins rank 1 when `<tools>` is present and stays silent (`0/360`) without `<tools>`.
+2. **Stage 2 — 11-Layer Compiled RISC-V Co-Processor (`1,045,984` nonzero compiled scalars):**
+   - Compiles RV32IM + Zba + 256-bit hardware bignum (`OP_BN`) + `CarbonText` bridge (`Target(16, 32, 12288)`) via [`qwenputer`](https://github.com/divagr18/qwenputer) into `layers[0..10]` (`1,265` residual slots, `hidden_size = 5632`, `m = 22`).
+   - Because `Qwen3.5-9B-Base` already has `linear_num_value_heads = 32` and `intermediate_size = 12288`, widening `layers[11..42]` requires **zero** MLP or Gated-DeltaNet head expansion — only orthogonal hidden-dimension padding (`4096 -> 5632`) plus analytical ballast muting (`sinks = None`) on `mu_dim`.
+   - Untied `lm_head.weight` copies `(*code_dims, tau_dim)` (`15` chip columns) alongside the `4,096` Qwen columns, preserving 100% bit-exact logits across all `478,656` tokens (`head_mismatch = 0`).
+3. **Zero-Padding-Free Compact `model.safetensors` (`8.99B` Nonzero BF16):**
+   - Stores only the `8,985,670,530` nonzero `bfloat16` parameters in `model.safetensors` plus lossless `chip_layout.json` + `chip_indices.bin.zlib`, cutting checkpoint size in half (`17.97 GB` instead of `36.42 GB` zero-padded shards) while reconstructing all 43 `Qwen3_5DecoderLayer` modules bit-for-bit (`torch.equal`).
+
+---
+
+## Quickstart
+
+```bash
+pip install torch transformers safetensors huggingface_hub tokenizers
+git clone https://github.com/divagr18/qwenputer
+git clone https://huggingface.co/DJLougen/Qwen3.5-9B-Math-GraphCalc
+
+# Run end-to-end 43-layer in-weights generation (Triton fast path or --pure-hf un-fused HF layers)
+QWENPUTER_ROOT=./qwenputer python Qwen3.5-9B-Math-GraphCalc/runner.py \
+  --ask "Graph y = x^3 - 3*x from x = -2 to 2, identify its roots and turning points, and state the local maximum y-value."
+```
+
+---
+
+## Credits & License
+
+- **Base Model:** [`Qwen/Qwen3.5-9B-Base`](https://huggingface.co/Qwen/Qwen3.5-9B-Base) (Apache 2.0)
+- **RV32 Circuit Compiler Foundation:** Built upon the Gated-DeltaNet RISC-V compiler from [`divagr18/qwenputer`](https://github.com/divagr18/qwenputer), extended with untied 9B `lm_head` synthesis, zero-gradient analytical ballast muting, ChatML bridge tokens (`256..264`), and custom C graphing-calculator firmware (`graphcalc.c`).

chat_template.jinja

@@ -0,0 +1,154 @@
+{%- set image_count = namespace(value=0) %}
+{%- set video_count = namespace(value=0) %}
+{%- macro render_content(content, do_vision_count, is_system_content=false) %}
+    {%- if content is string %}
+        {{- content }}
+    {%- elif content is iterable and content is not mapping %}
+        {%- for item in content %}
+            {%- if 'image' in item or 'image_url' in item or item.type == 'image' %}
+                {%- if is_system_content %}
+                    {{- raise_exception('System message cannot contain images.') }}
+                {%- endif %}
+                {%- if do_vision_count %}
+                    {%- set image_count.value = image_count.value + 1 %}
+                {%- endif %}
+                {%- if add_vision_id %}
+                    {{- 'Picture ' ~ image_count.value ~ ': ' }}
+                {%- endif %}
+                {{- '<|vision_start|><|image_pad|><|vision_end|>' }}
+            {%- elif 'video' in item or item.type == 'video' %}
+                {%- if is_system_content %}
+                    {{- raise_exception('System message cannot contain videos.') }}
+                {%- endif %}
+                {%- if do_vision_count %}
+                    {%- set video_count.value = video_count.value + 1 %}
+                {%- endif %}
+                {%- if add_vision_id %}
+                    {{- 'Video ' ~ video_count.value ~ ': ' }}
+                {%- endif %}
+                {{- '<|vision_start|><|video_pad|><|vision_end|>' }}
+            {%- elif 'text' in item %}
+                {{- item.text }}
+            {%- else %}
+                {{- raise_exception('Unexpected item type in content.') }}
+            {%- endif %}
+        {%- endfor %}
+    {%- elif content is none or content is undefined %}
+        {{- '' }}
+    {%- else %}
+        {{- raise_exception('Unexpected content type.') }}
+    {%- endif %}
+{%- endmacro %}
+{%- if not messages %}
+    {{- raise_exception('No messages provided.') }}
+{%- endif %}
+{%- if tools and tools is iterable and tools is not mapping %}
+    {{- '<|im_start|>system\n' }}
+    {{- "# Tools\n\nYou have access to the following functions:\n\n<tools>" }}
+    {%- for tool in tools %}
+        {{- "\n" }}
+        {{- tool | tojson }}
+    {%- endfor %}
+    {{- "\n</tools>" }}
+    {{- '\n\nIf you choose to call a function ONLY reply in the following format with NO suffix:\n\n<tool_call>\n<function=example_function_name>\n<parameter=example_parameter_1>\nvalue_1\n</parameter>\n<parameter=example_parameter_2>\nThis is the value for the second parameter\nthat can span\nmultiple lines\n</parameter>\n</function>\n</tool_call>\n\n<IMPORTANT>\nReminder:\n- Function calls MUST follow the specified format: an inner <function=...></function> block must be nested within <tool_call></tool_call> XML tags\n- Required parameters MUST be specified\n- You may provide optional reasoning for your function call in natural language BEFORE the function call, but NOT after\n- If there is no function call available, answer the question like normal with your current knowledge and do not tell the user about function calls\n</IMPORTANT>' }}
+    {%- if messages[0].role == 'system' %}
+        {%- set content = render_content(messages[0].content, false, true)|trim %}
+        {%- if content %}
+            {{- '\n\n' + content }}
+        {%- endif %}
+    {%- endif %}
+    {{- '<|im_end|>\n' }}
+{%- else %}
+    {%- if messages[0].role == 'system' %}
+        {%- set content = render_content(messages[0].content, false, true)|trim %}
+        {{- '<|im_start|>system\n' + content + '<|im_end|>\n' }}
+    {%- endif %}
+{%- endif %}
+{%- set ns = namespace(multi_step_tool=true, last_query_index=messages|length - 1) %}
+{%- for message in messages[::-1] %}
+    {%- set index = (messages|length - 1) - loop.index0 %}
+    {%- if ns.multi_step_tool and message.role == "user" %}
+        {%- set content = render_content(message.content, false)|trim %}
+        {%- if not(content.startswith('<tool_response>') and content.endswith('</tool_response>')) %}
+            {%- set ns.multi_step_tool = false %}
+            {%- set ns.last_query_index = index %}
+        {%- endif %}
+    {%- endif %}
+{%- endfor %}
+{%- if ns.multi_step_tool %}
+    {{- raise_exception('No user query found in messages.') }}
+{%- endif %}
+{%- for message in messages %}
+    {%- set content = render_content(message.content, true)|trim %}
+    {%- if message.role == "system" %}
+        {%- if not loop.first %}
+            {{- raise_exception('System message must be at the beginning.') }}
+        {%- endif %}
+    {%- elif message.role == "user" %}
+        {{- '<|im_start|>' + message.role + '\n' + content + '<|im_end|>' + '\n' }}
+    {%- elif message.role == "assistant" %}
+        {%- set reasoning_content = '' %}
+        {%- if message.reasoning_content is string %}
+            {%- set reasoning_content = message.reasoning_content %}
+        {%- else %}
+            {%- if '</think>' in content %}
+                {%- set reasoning_content = content.split('</think>')[0].rstrip('\n').split('<think>')[-1].lstrip('\n') %}
+                {%- set content = content.split('</think>')[-1].lstrip('\n') %}
+            {%- endif %}
+        {%- endif %}
+        {%- set reasoning_content = reasoning_content|trim %}
+        {%- if loop.index0 > ns.last_query_index %}
+            {{- '<|im_start|>' + message.role + '\n<think>\n' + reasoning_content + '\n</think>\n\n' + content }}
+        {%- else %}
+            {{- '<|im_start|>' + message.role + '\n' + content }}
+        {%- endif %}
+        {%- if message.tool_calls and message.tool_calls is iterable and message.tool_calls is not mapping %}
+            {%- for tool_call in message.tool_calls %}
+                {%- if tool_call.function is defined %}
+                    {%- set tool_call = tool_call.function %}
+                {%- endif %}
+                {%- if loop.first %}
+                    {%- if content|trim %}
+                        {{- '\n\n<tool_call>\n<function=' + tool_call.name + '>\n' }}
+                    {%- else %}
+                        {{- '<tool_call>\n<function=' + tool_call.name + '>\n' }}
+                    {%- endif %}
+                {%- else %}
+                    {{- '\n<tool_call>\n<function=' + tool_call.name + '>\n' }}
+                {%- endif %}
+                {%- if tool_call.arguments is defined %}
+                    {%- for args_name, args_value in tool_call.arguments|items %}
+                        {{- '<parameter=' + args_name + '>\n' }}
+                        {%- set args_value = args_value | tojson | safe if args_value is mapping or (args_value is sequence and args_value is not string) else args_value | string %}
+                        {{- args_value }}
+                        {{- '\n</parameter>\n' }}
+                    {%- endfor %}
+                {%- endif %}
+                {{- '</function>\n</tool_call>' }}
+            {%- endfor %}
+        {%- endif %}
+        {{- '<|im_end|>\n' }}
+    {%- elif message.role == "tool" %}
+        {%- if loop.previtem and loop.previtem.role != "tool" %}
+            {{- '<|im_start|>user' }}
+        {%- endif %}
+        {{- '\n<tool_response>\n' }}
+        {{- content }}
+        {{- '\n</tool_response>' }}
+        {%- if not loop.last and loop.nextitem.role != "tool" %}
+            {{- '<|im_end|>\n' }}
+        {%- elif loop.last %}
+            {{- '<|im_end|>\n' }}
+        {%- endif %}
+    {%- else %}
+        {{- raise_exception('Unexpected message role.') }}
+    {%- endif %}
+{%- endfor %}
+{%- if add_generation_prompt %}
+    {{- '<|im_start|>assistant\n' }}
+    {%- if enable_thinking is defined and enable_thinking is false %}
+        {{- '<think>\n\n</think>\n\n' }}
+    {%- else %}
+        {{- '<think>\n' }}
+    {%- endif %}
+{%- endif %}

chip_indices.bin.zlib

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:13f715f1f3285e34b1460f56517efe1cf9025a94f1d701c4805772641bdc22d8
+size 45910417

chipformer.json

@@ -0,0 +1,344 @@
+{
+  "layout": "rv1-carbon-graphcalc",
+  "base_model": "Qwen/Qwen3.5-9B-Base",
+  "tie_word_embeddings": false,
+  "total_nonzero_params": 8985670530,
+  "total_dense_params": 18208957504,
+  "wsp_patch": "patch_9b_graphcalc.safetensors",
+  "wsp_changed_base_weights": 2920169,
+  "compiled_chip_layer_nonzero_weights": 1045984,
+  "compiled_embedding_chip_nonzero_weights": 25387170,
+  "compiled_lm_head_chip_nonzero_weights": 5321013,
+  "firmware": "graphcalc.elf",
+  "firmware_elf_bytes": 87636,
+  "chip_token_offset": 248320,
+  "chip_vocab": 230324,
+  "chip_layers": 11,
+  "qwen_layers_from": 11,
+  "num_total_layers": 43,
+  "hidden": 5632,
+  "chip_dims_offset": 4096,
+  "ballast_dims": 22,
+  "circuit": {
+    "layers": 11,
+    "dims": 2918,
+    "heads": 103,
+    "ffn_units": 42113,
+    "max_units": 8149,
+    "max_heads": 16
+  },
+  "slots": 1265,
+  "muted": true,
+  "anti_sink": "none (analytical ballast mute; zero fitted activations)",
+  "code_dims": [
+    4250,
+    4251,
+    4252,
+    4253,
+    4254,
+    4255,
+    4256,
+    4257,
+    4258,
+    4259,
+    4260,
+    4261,
+    4262,
+    4263,
+    4264,
+    4265,
+    4266,
+    4267,
+    4268,
+    4269,
+    4270
+  ],
+  "tau_dim": 4273,
+  "mu_dim": 4272,
+  "nfam": 5,
+  "npay": 16,
+  "tool_call": [
+    248058,
+    248059
+  ],
+  "specials": [
+    "<tool_response>",
+    "</tool_response>",
+    "<think>",
+    "</think>",
+    "<|im_end|>",
+    "<|im_start|>",
+    "user",
+    "assistant",
+    "\n\n"
+  ],
+  "halt_nl_byte": 32,
+  "printable": [
+    188,
+    189,
+    190,
+    191,
+    192,
+    193,
+    194,
+    195,
+    196,
+    197,
+    198,
+    199,
+    200,
+    201,
+    202,
+    203,
+    204,
+    205,
+    206,
+    207,
+    208,
+    209,
+    210,
+    211,
+    212,
+    213,
+    214,
+    215,
+    216,
+    217,
+    218,
+    219,
+    220,
+    0,
+    1,
+    2,
+    3,
+    4,
+    5,
+    6,
+    7,
+    8,
+    9,
+    10,
+    11,
+    12,
+    13,
+    14,
+    15,
+    16,
+    17,
+    18,
+    19,
+    20,
+    21,
+    22,
+    23,
+    24,
+    25,
+    26,
+    27,
+    28,
+    29,
+    30,
+    31,
+    32,
+    33,
+    34,
+    35,
+    36,
+    37,
+    38,
+    39,
+    40,
+    41,
+    42,
+    43,
+    44,
+    45,
+    46,
+    47,
+    48,
+    49,
+    50,
+    51,
+    52,
+    53,
+    54,
+    55,
+    56,
+    57,
+    58,
+    59,
+    60,
+    61,
+    62,
+    63,
+    64,
+    65,
+    66,
+    67,
+    68,
+    69,
+    70,
+    71,
+    72,
+    73,
+    74,
+    75,
+    76,
+    77,
+    78,
+    79,
+    80,
+    81,
+    82,
+    83,
+    84,
+    85,
+    86,
+    87,
+    88,
+    89,
+    90,
+    91,
+    92,
+    93,
+    221,
+    222,
+    223,
+    224,
+    225,
+    226,
+    227,
+    228,
+    229,
+    230,
+    231,
+    232,
+    233,
+    234,
+    235,
+    236,
+    237,
+    238,
+    239,
+    240,
+    241,
+    242,
+    243,
+    244,
+    245,
+    246,
+    247,
+    248,
+    249,
+    250,
+    251,
+    252,
+    253,
+    254,
+    94,
+    95,
+    96,
+    97,
+    98,
+    99,
+    100,
+    101,
+    102,
+    103,
+    104,
+    105,
+    255,
+    106,
+    107,
+    108,
+    109,
+    110,
+    111,
+    112,
+    113,
+    114,
+    115,
+    116,
+    117,
+    118,
+    119,
+    120,
+    121,
+    122,
+    123,
+    124,
+    125,
+    126,
+    127,
+    128,
+    129,
+    130,
+    131,
+    132,
+    133,
+    134,
+    135,
+    136,
+    137,
+    138,
+    139,
+    140,
+    141,
+    142,
+    143,
+    144,
+    145,
+    146,
+    147,
+    148,
+    149,
+    150,
+    151,
+    152,
+    153,
+    154,
+    155,
+    156,
+    157,
+    158,
+    159,
+    160,
+    161,
+    162,
+    163,
+    164,
+    165,
+    166,
+    167,
+    168,
+    169,
+    170,
+    171,
+    172,
+    173,
+    174,
+    175,
+    176,
+    177,
+    178,
+    179,
+    180,
+    181,
+    182,
+    183,
+    184,
+    185,
+    186,
+    187,
+    248066,
+    248067,
+    248068,
+    248069,
+    248046,
+    248045,
+    846,
+    74455,
+    271
+  ],
+  "think_logit_damped": true
+}

config.json

@@ -0,0 +1,105 @@
+{
+  "architectures": [
+    "Qwen3_5ForCausalLM"
+  ],
+  "output_hidden_states": false,
+  "return_dict": true,
+  "dtype": "bfloat16",
+  "chunk_size_feed_forward": 0,
+  "is_encoder_decoder": false,
+  "id2label": {
+    "0": "LABEL_0",
+    "1": "LABEL_1"
+  },
+  "label2id": {
+    "LABEL_0": 0,
+    "LABEL_1": 1
+  },
+  "problem_type": null,
+  "vocab_size": 478656,
+  "hidden_size": 5632,
+  "intermediate_size": 12288,
+  "num_hidden_layers": 43,
+  "num_attention_heads": 16,
+  "num_key_value_heads": 4,
+  "hidden_act": "silu",
+  "max_position_embeddings": 262144,
+  "initializer_range": 0.02,
+  "rms_norm_eps": 1e-06,
+  "use_cache": true,
+  "tie_word_embeddings": false,
+  "rope_parameters": {
+    "mrope_interleaved": true,
+    "mrope_section": [
+      11,
+      11,
+      10
+    ],
+    "rope_type": "default",
+    "rope_theta": 10000000,
+    "partial_rotary_factor": 0.25
+  },
+  "attention_bias": false,
+  "attention_dropout": 0.0,
+  "head_dim": 256,
+  "linear_conv_kernel_dim": 4,
+  "linear_key_head_dim": 128,
+  "linear_value_head_dim": 128,
+  "linear_num_key_heads": 16,
+  "linear_num_value_heads": 32,
+  "layer_types": [
+    "linear_attention",
+    "linear_attention",
+    "linear_attention",
+    "linear_attention",
+    "linear_attention",
+    "linear_attention",
+    "linear_attention",
+    "linear_attention",
+    "linear_attention",
+    "linear_attention",
+    "linear_attention",
+    "linear_attention",
+    "linear_attention",
+    "linear_attention",
+    "full_attention",
+    "linear_attention",
+    "linear_attention",
+    "linear_attention",
+    "full_attention",
+    "linear_attention",
+    "linear_attention",
+    "linear_attention",
+    "full_attention",
+    "linear_attention",
+    "linear_attention",
+    "linear_attention",
+    "full_attention",
+    "linear_attention",
+    "linear_attention",
+    "linear_attention",
+    "full_attention",
+    "linear_attention",
+    "linear_attention",
+    "linear_attention",
+    "full_attention",
+    "linear_attention",
+    "linear_attention",
+    "linear_attention",
+    "full_attention",
+    "linear_attention",
+    "linear_attention",
+    "linear_attention",
+    "full_attention"
+  ],
+  "pad_token_id": null,
+  "bos_token_id": null,
+  "eos_token_id": 248044,
+  "attn_output_gate": true,
+  "mlp_only_layers": [],
+  "model_type": "qwen3_5_text",
+  "mtp_num_hidden_layers": 0,
+  "mtp_use_dedicated_embeddings": false,
+  "mamba_ssm_dtype": "float32",
+  "output_attentions": false
+}

firmware/build.sh

@@ -0,0 +1,36 @@
+#!/bin/bash
+# Build the Carbon Graphing Calculator RV32IM+Zba+Bignum firmware (run in WSL):
+#   bash carbon/firmware/build.sh [OUT_DIR]
+# Produces:
+#   OUT_DIR/graphcalc.elf       (for compiled Qwen3.5 RV32 chip layers & chipformer.rv.ref.Machine)
+#   OUT_DIR/graphcalc-qemu.elf  (for standalone qemu-riscv32 verification via stdin)
+set -euo pipefail
+HERE=$(cd "$(dirname "$0")" && pwd)
+OUT=$(realpath "${1:-$HERE}")
+QWENPUTER=${QWENPUTER:-$HERE/../../../qwenputer}
+ENV=$QWENPUTER/experimental/riscv/chipformer/rv/env
+CALC_ENV=$ENV/calc
+GCC=riscv64-unknown-elf-gcc
+MARCH=rv32im_zba
+PICO=/usr/lib/picolibc/riscv64-unknown-elf
+LIBC=$PICO/lib/release/rv32im/ilp32/libc.a
+[ -f "$LIBC" ] || LIBC=$(find /usr/lib/picolibc -path '*rv32im/ilp32/libc.a' | head -n 1)
+LIBGCC=$($GCC -march=rv32im -mabi=ilp32 -print-libgcc-file-name)
+
+B=$(mktemp -d)
+python3 "$HERE/tables.py" "$B/graphcalc_tables.h" "$B/sled.S"
+mkdir -p "$OUT"
+
+for map in rom qemu; do
+  name=$([ $map = rom ] && echo graphcalc || echo graphcalc-qemu)
+  def=$([ $map = rom ] && echo "" || echo "-DQEMU")
+  sled=$([ $map = rom ] && echo "$B/sled.S" || echo "")
+  $GCC -march=$MARCH -mabi=ilp32 ${CFLAGS:--O2} -fno-tree-loop-distribute-patterns -Wall -Wextra $def \
+    -isystem "$PICO/include" -I"$ENV" -I"$CALC_ENV" -I"$B" \
+    -nostdlib -nostartfiles -static -T"$ENV/$map.ld" -o "$OUT/$name.elf" \
+    "$ENV/crt0.S" "$HERE/graphcalc.c" "$ENV/sys.c" $sled \
+    -Wl,--start-group "$LIBC" "$LIBGCC" -Wl,--end-group
+done
+
+riscv64-unknown-elf-size -A "$OUT/graphcalc.elf" | grep -E '^\.(text|rodata|data|bss)'
+rm -rf "$B"

firmware/graphcalc.c

@@ -0,0 +1,2210 @@
+// Carbon In-Weights Graphing & Symbolic/Numeric Calculator Firmware (RV32IM + Zba + Bignum).
+// Executes directly inside compiled Qwen3.5 Gated-DeltaNet + SwiGLU layers (layers[0..10]).
+// Strictly integer & fixed-point (Q32.32 + 128-digit hardware bignum register file) — zero FPU.
+
+#include <stdint.h>
+#include <stddef.h>
+#include "rt.h"
+#include "graphcalc_tables.h"
+
+#ifdef QEMU
+// Software emulation of chipformer's custom-0/custom-1 128-digit bignum unit for qemu-riscv32.
+#define BN_OPS(n, off, m, d, s, ovw)                                                        \
+    ((uint32_t)(d) | (uint32_t)(s) << 3 | (uint32_t)(ovw) << 6 | (uint32_t)(n) << 7 |       \
+     (uint32_t)(off) << 13 | (uint32_t)(m) << 20)
+#define BN_OFF(off) ((uint32_t)(off) << 13)
+#define BN_M(m) ((uint32_t)(m) << 20)
+
+static uint8_t sw_bn[8][128];
+
+static uint32_t bn_mac(uint32_t ops) {
+    uint32_t dd = ops & 7, ds = (ops >> 3) & 7, ovw = (ops >> 6) & 1;
+    uint32_t n = (ops >> 7) & 63, off = (ops >> 13) & 127, m = (ops >> 20) & 15;
+    if (m > 9) m = 9;
+    uint32_t c = 0;
+    for (uint32_t i = 0; i < n; i++) {
+        uint32_t r = i + off;
+        uint32_t d = r < 128 ? sw_bn[dd][r] : 0;
+        uint32_t v = (ovw ? 0 : d) + sw_bn[ds][i] * m + c;
+        c = v / 10;
+        if (r < 128) sw_bn[dd][r] = (uint8_t)(v % 10);
+    }
+    return c;
+}
+
+static uint32_t bn_msb(uint32_t ops) {
+    uint32_t dd = ops & 7, ds = (ops >> 3) & 7;
+    uint32_t n = (ops >> 7) & 63, off = (ops >> 13) & 127, m = (ops >> 20) & 15;
+    if (m > 9) m = 9;
+    int32_t c = 0;
+    for (uint32_t i = 0; i < n; i++) {
+        uint32_t r = i + off;
+        int32_t d = r < 128 ? (int32_t)sw_bn[dd][r] : 0;
+        int32_t v = d - (int32_t)(sw_bn[ds][i] * m) - c;
+        int32_t rem = ((v % 10) + 10) % 10;
+        c = (rem - v) / 10;
+        if (r < 128) sw_bn[dd][r] = (uint8_t)rem;
+    }
+    return (uint32_t)c;
+}
+
+static void bn_ld(const char *end, uint32_t ops) {
+    uint32_t dd = ops & 7, n = (ops >> 7) & 63, off = (ops >> 13) & 127;
+    for (uint32_t i = 0; i < n; i++) {
+        uint32_t r = i + off;
+        uint32_t v = (uint32_t)((unsigned char)end[-1 - (int)i]) & 15u;
+        if (v > 9) v = 9;
+        if (r < 128) sw_bn[dd][r] = (uint8_t)v;
+    }
+}
+
+static uint32_t bn_get(uint32_t ops) {
+    uint32_t dd = ops & 7, off = (ops >> 13) & 127;
+    return sw_bn[dd][off];
+}
+
+static uint32_t bn_scan(const char *s) {
+    uint32_t n = 0;
+    while (n < 63 && (unsigned char)s[n] >= '0' && (unsigned char)s[n] <= '9') n++;
+    return n;
+}
+
+static void bn_print(int r, int len) {
+    for (int i = len - 1; i >= 0; i--) rv_putchar((char)('0' + sw_bn[r][i]));
+}
+#else
+#include "bn.h"
+#endif
+
+// ============================================================================
+// Basic Output & String Helpers (no libc printf bloat)
+// ============================================================================
+
+static void puts_raw(const char *s) {
+    while (*s) rv_putchar(*s++);
+}
+
+static void putc_rep(char c, int n) {
+    for (int i = 0; i < n; i++) rv_putchar(c);
+}
+
+static int slen(const char *s) {
+    int n = 0;
+    while (s[n]) n++;
+    return n;
+}
+
+static int streq(const char *a, const char *b) {
+    while (*a && *b && *a == *b) { a++; b++; }
+    return *a == 0 && *b == 0;
+}
+
+static int streq_ci(const char *a, const char *b) {
+    while (*a && *b) {
+        char ca = *a++, cb = *b++;
+        if (ca >= 'A' && ca <= 'Z') ca = (char)(ca + 32);
+        if (cb >= 'A' && cb <= 'Z') cb = (char)(cb + 32);
+        if (ca != cb) return 0;
+    }
+    return *a == 0 && *b == 0;
+}
+
+static int starts_with_ci(const char *s, const char *p) {
+    while (*p) {
+        char cs = *s++, cp = *p++;
+        if (cs >= 'A' && cs <= 'Z') cs = (char)(cs + 32);
+        if (cp >= 'A' && cp <= 'Z') cp = (char)(cp + 32);
+        if (cs != cp) return 0;
+    }
+    return 1;
+}
+
+static int is_space(char c) {
+    return c == ' ' || c == '\t' || c == '\r' || c == '\n';
+}
+
+static int is_alpha(char c) {
+    return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || c == '_';
+}
+
+static int is_digit(char c) {
+    return c >= '0' && c <= '9';
+}
+
+static void copy_trim(char *dst, int cap, const char *src, int len) {
+    int a = 0, b = len;
+    while (a < b && is_space(src[a])) a++;
+    while (b > a && is_space(src[b - 1])) b--;
+    if (b - a >= 2 && ((src[a] == '"' && src[b - 1] == '"') ||
+                       (src[a] == '\'' && src[b - 1] == '\'') ||
+                       (src[a] == '$' && src[b - 1] == '$'))) {
+        a++;
+        b--;
+    }
+    int o = 0;
+    for (int i = a; i < b && o < cap - 1; i++) {
+        dst[o++] = src[i] == '\n' || src[i] == '\r' ? ' ' : src[i];
+    }
+    dst[o] = 0;
+}
+
+static void append_str(char *buf, int cap, int *pos, const char *s) {
+    while (*s && *pos < cap - 1) buf[(*pos)++] = *s++;
+    buf[*pos] = 0;
+}
+
+static void append_char(char *buf, int cap, int *pos, char c) {
+    if (*pos < cap - 1) {
+        buf[(*pos)++] = c;
+        buf[*pos] = 0;
+    }
+}
+
+// ============================================================================
+// Engine A: 62-Digit Hardware Bignum + Exact Reduced Rationals (bn.h)
+// ============================================================================
+
+#define MAXD 62
+#define ONE_REG 7
+
+typedef uint32_t num;
+#define REG(a) ((a) & 7u)
+#define NEG(a) (((a) >> 8) & 1u)
+#define LEN(a) ((int)((a) >> 16))
+#define NUM(r, neg, len) ((uint32_t)(r) | ((uint32_t)(neg) << 8) | ((uint32_t)(len) << 16))
+
+static uint32_t bn_dirty[8];
+static uint32_t bn_used;
+static int bn_err;
+static char one_ch = '1';  // MUST stay in RAM (.data), NOT const (.rodata)!
+
+static char bn_steps[512];
+static int bn_step_pos;
+static int bn_step_cnt;
+
+static int bn_dig(num a, int i) { return (int)bn_get(BN_OPS(0, i, 0, REG(a), 0, 0)); }
+
+static void bn_wrote(num a, int n) {
+    if ((uint32_t)n > bn_dirty[REG(a)]) bn_dirty[REG(a)] = (uint32_t)n;
+}
+
+static num bn_alloc(int len) {
+    for (int r = 0; r < ONE_REG; r++) {
+        if (!(bn_used >> r & 1u)) {
+            bn_used |= 1u << r;
+            for (uint32_t o = 0; o < bn_dirty[r]; o += 63) {
+                uint32_t chunk = bn_dirty[r] - o < 63 ? bn_dirty[r] - o : 63;
+                bn_mac(BN_OPS(chunk, o, 0, r, r, 1));
+            }
+            bn_dirty[r] = 0;
+            return NUM(r, 0, len);
+        }
+    }
+    bn_err = 2;
+    return NUM(0, 0, len);
+}
+
+static void bn_release(num a) { bn_used &= ~(1u << REG(a)); }
+
+static int bn_is_zero(num a) { return LEN(a) == 1 && !bn_dig(a, 0); }
+
+static num bn_trim(num a) {
+    int n = LEN(a);
+    while (n > 1 && !bn_dig(a, n - 1)) n--;
+    a = (a & 0xFFFFu) | ((uint32_t)n << 16);
+    return (n == 1 && !bn_dig(a, 0)) ? (a & ~0x100u) : a;
+}
+
+static int bn_cmp_mag(num a, num b) {
+    if (LEN(a) != LEN(b)) return LEN(a) < LEN(b) ? -1 : 1;
+    for (int i = LEN(a) - 1; i >= 0; i--) {
+        int x = bn_dig(a, i), y = bn_dig(b, i);
+        if (x != y) return x < y ? -1 : 1;
+    }
+    return 0;
+}
+
+static num bn_add_mag(num a, num b) {
+    int n = (LEN(a) > LEN(b) ? LEN(a) : LEN(b)) + 1;
+    if (n > MAXD) bn_err = 1;
+    bn_mac(BN_OPS(n, 0, 1, REG(a), REG(b), 0));
+    bn_wrote(a, n);
+    if (!bn_dig(a, n - 1)) n--;
+    return (a & 0xFFFFu) | ((uint32_t)n << 16);
+}
+
+static num bn_sub_mag(num a, num b) {
+    bn_msb(BN_OPS(LEN(a), 0, 1, REG(a), REG(b), 0));
+    return bn_trim(a);
+}
+
+__attribute__((noinline)) static num bn_add(num a, num b) {
+    num s;
+    if (NEG(a) == NEG(b)) {
+        s = bn_add_mag(a, b);
+        bn_release(b);
+    } else if (bn_cmp_mag(a, b) >= 0) {
+        s = bn_sub_mag(a, b);
+        bn_release(b);
+    } else {
+        s = bn_sub_mag(b, a);
+        bn_release(a);
+    }
+    return s;
+}
+
+__attribute__((noinline)) static num bn_mul(num a, num b) {
+    if (LEN(a) < LEN(b)) { num t = a; a = b; b = t; }
+    int la = LEN(a), lb = LEN(b);
+    num c = bn_alloc(la + lb);
+    if (la + lb > MAXD) {
+        bn_err = 1;
+        return c;
+    }
+    uint32_t base = BN_OPS(la + 1, 0, 0, REG(c), REG(a), 0);
+    for (int j = 0; j < lb; j++) {
+        uint32_t d = (uint32_t)bn_dig(b, j);
+        if (d) bn_mac(base | BN_OFF(j) | BN_M(d));
+    }
+    bn_wrote(c, la + lb);
+    return bn_trim(c | ((NEG(a) ^ NEG(b)) << 8));
+}
+
+typedef struct { num q, r; } bn_qr;
+
+__attribute__((noinline)) static bn_qr bn_divmod(num a, num b) {
+    if (bn_is_zero(b)) bn_err = 1;
+    if (bn_err || bn_cmp_mag(a, b) < 0) return (bn_qr){bn_alloc(1), a & ~0x100u};
+    int la = LEN(a), lb = LEN(b), ra = (int)REG(a);
+    num q = bn_alloc(la - lb + 1);
+    int b1 = bn_dig(b, lb - 1), den = lb >= 2 ? b1 * 10 + bn_dig(b, lb - 2) : b1;
+    uint32_t msb = BN_OPS(lb + 1, 0, 0, ra, REG(b), 0), mac = BN_OPS(lb + 1, 0, 1, ra, REG(b), 0);
+    uint32_t setq = BN_OPS(1, 0, 0, REG(q), ONE_REG, 1);
+    for (int t = la - lb; t >= 0; t--) {
+        int top = t + lb;
+        int w = bn_dig(a, top) * 10 + bn_dig(a, top - 1);
+        if (lb >= 2) w = w * 10 + bn_dig(a, top - 2);
+        int qd = (lb >= 3 ? w + 1 : w) / den;
+        if (qd > 9) qd = 9;
+        if (qd) {
+            uint32_t o = BN_OFF(t);
+            if (bn_msb(msb | o | BN_M(qd)))
+                do qd--;
+                while (!bn_mac(mac | o) && qd > 0);
+            if (qd) bn_mac(setq | o | BN_M(qd));
+        }
+    }
+    bn_wrote(q, la - lb + 1);
+    return (bn_qr){bn_trim(q), bn_trim(NUM(ra, 0, lb))};
+}
+
+__attribute__((noinline)) static num bn_divide(num a, num b, int want_mod) {
+    uint32_t sa = NEG(a), sb = NEG(b);
+    bn_qr d = bn_divmod(a, b);
+    if (sa != sb && !bn_is_zero(d.r)) {
+        d.q = bn_add_mag(d.q, NUM(ONE_REG, 0, 1));
+        num r2 = bn_sub_mag(b & ~0x100u, d.r);
+        bn_release(d.r);
+        d.r = r2;
+    } else {
+        bn_release(b);
+    }
+    bn_release(want_mod ? d.q : d.r);
+    num out = want_mod ? d.r : d.q;
+    out = (out & ~0x100u) | ((want_mod ? sb : (sa ^ sb)) << 8);
+    return bn_is_zero(out) ? (out & ~0x100u) : out;
+}
+
+__attribute__((noinline)) static num bn_gcd(num a, num b) {
+    a &= ~0x100u;
+    b &= ~0x100u;
+    while (!bn_err && !bn_is_zero(b)) {
+        bn_qr d = bn_divmod(a, b);
+        bn_release(d.q);
+        a = b;
+        b = d.r;
+    }
+    bn_release(b);
+    return a;
+}
+
+__attribute__((noinline)) static num bn_power(num a, num e) {
+    int x = 0;
+    if (NEG(e) || LEN(e) > 3) bn_err = 1;
+    for (int i = LEN(e) - 1; i >= 0 && !bn_err; i--) x = x * 10 + bn_dig(e, i);
+    bn_release(e);
+    num res = bn_alloc(1);
+    bn_mac(BN_OPS(1, 0, 1, REG(res), ONE_REG, 1));
+    bn_wrote(res, 1);
+    while (x && !bn_err) {
+        if (x & 1) {
+            num t = bn_mul(res, a);
+            bn_release(res);
+            res = t;
+        }
+        x >>= 1;
+        if (x) {
+            num t = bn_mul(a, a);
+            bn_release(a);
+            a = t;
+        }
+    }
+    bn_release(a);
+    return res;
+}
+
+static num bn_vals[16];
+static num bn_vden[16];
+static int bn_hasden[16];
+static int bn_vsc[16];
+static char bn_ops[16];
+
+static int bn_prec(int op) {
+    return op == '^' ? 4 : op == 'n' ? 3 : (op == '*' || op == 'f' || op == 'd' || op == '%') ? 2 : 1;
+}
+
+static num bn_copy_of(num a) {
+    num c = bn_alloc(LEN(a));
+    bn_mac(BN_OPS(LEN(a), 0, 1, REG(c), REG(a), 1));
+    bn_wrote(c, LEN(a));
+    return NUM(REG(c), NEG(a), LEN(a));
+}
+
+__attribute__((noinline)) static void bn_reduce(int i) {
+    num n = bn_vals[i], d = bn_vden[i];
+    bn_hasden[i] = 0;
+    if (bn_err) return;
+    if (bn_is_zero(n)) {
+        bn_release(d);
+        return;
+    }
+    uint32_t neg = NEG(n);
+    num g = bn_gcd(bn_copy_of(n), bn_copy_of(d));
+    bn_qr x = bn_divmod(n & ~0x100u, g);
+    bn_release(x.r);
+    bn_qr y = bn_divmod(d, g);
+    bn_release(y.r);
+    bn_release(g);
+    bn_vals[i] = x.q | (neg << 8);
+    if (LEN(y.q) == 1 && bn_dig(y.q, 0) == 1) {
+        bn_release(y.q);
+    } else {
+        bn_vden[i] = y.q;
+        bn_hasden[i] = 1;
+    }
+}
+
+__attribute__((noinline)) static void bn_frac_op(int op, int i, num a, num da, int fa, num b, num db, int fb) {
+    num n, d;
+    if (op == '*') {
+        n = bn_mul(a, b);
+        bn_release(a);
+        bn_release(b);
+        if (fa && fb) {
+            d = bn_mul(da, db);
+            bn_release(da);
+            bn_release(db);
+        } else {
+            d = fa ? da : db;
+        }
+    } else if (op == 'd') {
+        if (bn_is_zero(b)) bn_err = 1;
+        if (fb) { n = bn_mul(a, db); bn_release(a); bn_release(db); }
+        else n = a;
+        if (fa) { d = bn_mul(da, b); bn_release(da); bn_release(b); }
+        else d = b;
+        if (NEG(d)) {
+            d &= ~0x100u;
+            if (!bn_is_zero(n)) n ^= 0x100u;
+        }
+    } else {
+        num t1 = a, t2 = b;
+        if (fb) { t1 = bn_mul(a, db); bn_release(a); }
+        if (fa) { t2 = bn_mul(b, da); bn_release(b); }
+        if (fa && fb) { d = bn_mul(da, db); bn_release(da); bn_release(db); }
+        else d = fa ? da : db;
+        n = bn_add(t1, (op == '-' && !bn_is_zero(t2)) ? (t2 ^ 0x100u) : t2);
+    }
+    bn_vals[i] = n;
+    bn_vden[i] = d;
+    bn_reduce(i);
+}
+
+static num bn_shift(num a, int k) {
+    int n = LEN(a) + k;
+    if (n > MAXD) { bn_err = 1; return a; }
+    num c = bn_alloc(n);
+    bn_mac(BN_OPS(LEN(a), k, 1, REG(c), REG(a), 1));
+    bn_wrote(c, n);
+    bn_release(a);
+    return NUM(REG(c), NEG(a), n);
+}
+
+static void bn_fmt_slot(int idx, char *buf, int cap) {
+    int p = 0;
+    num v = bn_vals[idx];
+    int sc = bn_vsc[idx], n = LEN(v);
+    if (NEG(v)) append_char(buf, cap, &p, '-');
+    if (!sc) {
+        for (int i = n - 1; i >= 0; i--) append_char(buf, cap, &p, (char)('0' + bn_dig(v, i)));
+    } else {
+        int z = 0;
+        while (z < sc && !bn_dig(v, z)) z++;
+        if (n <= sc) append_char(buf, cap, &p, '0');
+        for (int i = n > sc ? n - 1 : sc - 1; i >= z; i--) {
+            if (i == sc - 1) append_char(buf, cap, &p, '.');
+            append_char(buf, cap, &p, (char)('0' + (i < n ? bn_dig(v, i) : 0)));
+        }
+    }
+    if (bn_hasden[idx]) {
+        num dv = bn_vden[idx];
+        append_char(buf, cap, &p, '/');
+        for (int i = LEN(dv) - 1; i >= 0; i--) append_char(buf, cap, &p, (char)('0' + bn_dig(dv, i)));
+    }
+}
+
+static int bn_apply(int op, int nv) {
+    if (op == 'n') {
+        num v = bn_vals[nv - 1];
+        bn_vals[nv - 1] = bn_is_zero(v) ? v : (v ^ 0x100u);
+        return nv;
+    }
+    if (nv < 2) { bn_err = 1; return nv; }
+
+    char sa_str[72], sb_str[72], sr_str[72];
+    int can_log = (!bn_err && bn_step_cnt < 8 && LEN(bn_vals[nv - 2]) <= 30 && LEN(bn_vals[nv - 1]) <= 30);
+    if (can_log) {
+        bn_fmt_slot(nv - 2, sa_str, sizeof sa_str);
+        bn_fmt_slot(nv - 1, sb_str, sizeof sb_str);
+    }
+
+    int sb = bn_vsc[nv - 1], sa = bn_vsc[nv - 2];
+    int fb = bn_hasden[nv - 1], fa = bn_hasden[nv - 2];
+    num b = bn_vals[--nv], a = bn_vals[nv - 1], r;
+    int rational = op == 'd' || ((fa || fb) && (op == '+' || op == '-' || op == '*'));
+    if ((fa || fb) && !rational) bn_err = 1;
+    if (rational && (sa || sb)) bn_err = 1;
+    if (bn_err) {
+        r = a;
+        bn_hasden[nv - 1] = 0;
+        bn_vals[nv - 1] = r;
+        bn_vsc[nv - 1] = sa;
+    } else if (rational) {
+        bn_frac_op(op, nv - 1, a, bn_vden[nv - 1], fa, b, bn_vden[nv], fb);
+        bn_vsc[nv - 1] = 0;
+    } else {
+        if (op == '+' || op == '-') {
+            if (sa < sb) { a = bn_shift(a, sb - sa); sa = sb; }
+            if (sb < sa) b = bn_shift(b, sa - sb);
+            r = bn_add(a, (op == '-' && !bn_is_zero(b)) ? (b ^ 0x100u) : b);
+        } else if (op == '*') {
+            r = bn_mul(a, b);
+            bn_release(a);
+            bn_release(b);
+            sa += sb;
+        } else if (sa || sb) {
+            bn_err = 1;
+            r = a;
+        } else if (op == '^') {
+            r = bn_power(a, b);
+        } else if (op == 'g') {
+            r = bn_gcd(a, b);
+        } else {
+            r = bn_divide(a, b, op == '%');
+        }
+        bn_hasden[nv - 1] = 0;
+        bn_vals[nv - 1] = r;
+        bn_vsc[nv - 1] = sa;
+    }
+
+    if (can_log && !bn_err && LEN(bn_vals[nv - 1]) <= 62) {
+        bn_fmt_slot(nv - 1, sr_str, sizeof sr_str);
+        bn_step_cnt++;
+        append_str(bn_steps, sizeof bn_steps, &bn_step_pos, "step ");
+        append_char(bn_steps, sizeof bn_steps, &bn_step_pos, (char)('0' + bn_step_cnt));
+        append_str(bn_steps, sizeof bn_steps, &bn_step_pos, ": ");
+        if (op == 'g') {
+            append_str(bn_steps, sizeof bn_steps, &bn_step_pos, "gcd(");
+            append_str(bn_steps, sizeof bn_steps, &bn_step_pos, sa_str);
+            append_str(bn_steps, sizeof bn_steps, &bn_step_pos, ", ");
+            append_str(bn_steps, sizeof bn_steps, &bn_step_pos, sb_str);
+            append_str(bn_steps, sizeof bn_steps, &bn_step_pos, ") = ");
+        } else {
+            const char *op_s = op == 'd' ? "/" : op == 'f' ? "//" : op == '^' ? "^" :
+                               op == '*' ? "*" : op == '+' ? "+" : op == '-' ? "-" : "%";
+            append_str(bn_steps, sizeof bn_steps, &bn_step_pos, sa_str);
+            append_char(bn_steps, sizeof bn_steps, &bn_step_pos, ' ');
+            append_str(bn_steps, sizeof bn_steps, &bn_step_pos, op_s);
+            append_char(bn_steps, sizeof bn_steps, &bn_step_pos, ' ');
+            append_str(bn_steps, sizeof bn_steps, &bn_step_pos, sb_str);
+            append_str(bn_steps, sizeof bn_steps, &bn_step_pos, " = ");
+        }
+        append_str(bn_steps, sizeof bn_steps, &bn_step_pos, sr_str);
+        append_char(bn_steps, sizeof bn_steps, &bn_step_pos, '\n');
+    }
+    return nv;
+}
+
+// Try evaluating a pure arithmetic/rational/bignum expression in Engine A.
+// Returns 0 on success (having printed the structured trace + exact answer), 1 if unsupported/failed.
+static int run_bignum_engine(const char *expr_ram) {
+    bn_used = 0;
+    bn_err = 0;
+    bn_step_pos = 0;
+    bn_step_cnt = 0;
+    bn_steps[0] = 0;
+    for (int r = 0; r < ONE_REG; r++) {
+        bn_mac(BN_OPS(63, 0, 0, r, r, 1));
+        bn_mac(BN_OPS(63, 63, 0, r, r, 1));
+        bn_dirty[r] = 0;
+    }
+    bn_ld(&one_ch + 1, BN_OPS(1, 0, 0, ONE_REG, 0, 0));
+
+    const char *s = expr_ram;
+    int operand = 1, nv = 0, no = 0;
+    for (;;) {
+        char c = *s;
+        if (c == ' ' || c == '\t') { s++; continue; }
+        if (nv >= 15 || no >= 15) bn_err = 1;
+        if (bn_err) break;
+        if (operand) {
+            if (is_digit(c)) {
+                int n = (int)bn_scan(s);
+                const char *end = s + n;
+                int frac = 0;
+                if (*end == '.' && is_digit(end[1])) {
+                    static char dbuf[MAXD + 4];
+                    frac = (int)bn_scan(end + 1);
+                    if (n + frac > MAXD) { bn_err = 1; break; }
+                    for (int i = 0; i < n; i++) dbuf[i] = s[i];
+                    for (int i = 0; i < frac; i++) dbuf[n + i] = end[1 + i];
+                    s = end + 1 + frac;
+                    n += frac;
+                    end = dbuf + n;
+                } else {
+                    s = end;
+                }
+                if (n > MAXD) { bn_err = 1; break; }
+                num a = bn_alloc(n);
+                bn_ld(end, BN_OPS(n, 0, 0, REG(a), 0, 0));
+                bn_wrote(a, n);
+                bn_vsc[nv] = frac;
+                bn_hasden[nv] = 0;
+                bn_vals[nv++] = bn_dig(a, n - 1) ? a : bn_trim(a);
+                operand = 0;
+            } else if (c == '(') {
+                bn_ops[no++] = '(';
+                s++;
+            } else if (c == '-' || c == '+') {
+                if (c == '-') bn_ops[no++] = 'n';
+                s++;
+            } else if (starts_with_ci(s, "gcd(")) {
+                bn_ops[no++] = 'g';
+                s += 4;
+            } else {
+                bn_err = 1;
+            }
+            continue;
+        }
+        // Implicit multiplication before '(' when preceded by number or ')'
+        if (c == '(') {
+            int pr = bn_prec('*');
+            while (no && bn_ops[no - 1] != '(' && bn_ops[no - 1] != 'g' && bn_prec(bn_ops[no - 1]) >= pr)
+                nv = bn_apply(bn_ops[--no], nv);
+            bn_ops[no++] = '*';
+            bn_ops[no++] = '(';
+            s++;
+            operand = 1;
+            continue;
+        }
+        if (c == ')' || c == ',') {
+            while (no && bn_ops[no - 1] != '(' && bn_ops[no - 1] != 'g') nv = bn_apply(bn_ops[--no], nv);
+            if (!no) {
+                bn_err = 1;
+            } else if (c == ')') {
+                if (bn_ops[--no] == 'g') nv = bn_apply('g', nv);
+            } else if (bn_ops[no - 1] != 'g') {
+                bn_err = 1;
+            } else {
+                operand = 1;
+            }
+            s++;
+            continue;
+        }
+        if (!c) break;
+        int op = (unsigned char)c, len = 1;
+        if (c == '*' && s[1] == '*') {
+            op = '^';
+            len = 2;
+        } else if (c == '/') {
+            op = s[1] == '/' ? 'f' : 'd';
+            len = s[1] == '/' ? 2 : 1;
+        } else if (c != '+' && c != '-' && c != '*' && c != '%' && c != '^') {
+            bn_err = 1;
+            continue;
+        }
+        int pr = bn_prec(op);
+        while (no && bn_ops[no - 1] != '(' && bn_ops[no - 1] != 'g' &&
+               (bn_prec(bn_ops[no - 1]) > pr || (bn_prec(bn_ops[no - 1]) == pr && op != '^')))
+            nv = bn_apply(bn_ops[--no], nv);
+        bn_ops[no++] = (char)op;
+        s += len;
+        operand = 1;
+    }
+    while (!bn_err && no) {
+        int op = bn_ops[--no];
+        if (op == '(' || op == 'g') bn_err = 1;
+        else nv = bn_apply(op, nv);
+    }
+    if (bn_err || nv != 1 || operand) return 1;
+
+    puts_raw("expression: ");
+    puts_raw(expr_ram);
+    rv_putchar('\n');
+    if (bn_step_cnt >= 2) puts_raw(bn_steps);
+
+    puts_raw("exact value: ");
+    num v = bn_vals[0];
+    int sc = bn_vsc[0], n = LEN(v);
+    if (NEG(v)) rv_putchar('-');
+    if (!sc) {
+        bn_print((int)REG(v), n);
+    } else {
+        int z = 0;
+        while (z < sc && !bn_dig(v, z)) z++;
+        if (n <= sc) rv_putchar('0');
+        for (int i = n > sc ? n - 1 : sc - 1; i >= z; i--) {
+            if (i == sc - 1) rv_putchar('.');
+            rv_putchar((char)('0' + (i < n ? bn_dig(v, i) : 0)));
+        }
+    }
+    if (bn_hasden[0]) {
+        num den = bn_vden[0];
+        rv_putchar('/');
+        bn_print((int)REG(den), LEN(den));
+        // Also print 6-decimal expansion when numerator*10^6 fits in MAXD
+        if (n + 6 <= MAXD) {
+            uint32_t neg = NEG(v);
+            num scaled = bn_shift(bn_copy_of(v & ~0x100u), 6);
+            bn_qr dec = bn_divmod(scaled, den);
+            int exact_dec = bn_is_zero(dec.r);
+            puts_raw(exact_dec ? " (= " : " (~ ");
+            if (neg) rv_putchar('-');
+            int dn = LEN(dec.q);
+            int z = 0;
+            while (z < 6 && exact_dec && (z >= dn || !bn_dig(dec.q, z))) z++;
+            if (dn <= 6) rv_putchar('0');
+            for (int i = dn > 6 ? dn - 1 : 5; i >= z; i--) {
+                if (i == 5) rv_putchar('.');
+                rv_putchar((char)('0' + (i < dn ? bn_dig(dec.q, i) : 0)));
+            }
+            rv_putchar(')');
+            bn_release(dec.q);
+            bn_release(dec.r);
+        }
+    }
+    rv_putchar('\n');
+    return 0;
+}
+
+// ============================================================================
+// Engine B: Q32.32 Fixed-Point Scientific, Equation Solver & Graphing Engine
+// ============================================================================
+
+typedef int64_t q32_t;
+#define Q32_MAX 0x7FFFFFFFFFFFFFFFLL
+#define Q32_MIN (-0x7FFFFFFFFFFFFFFFLL - 1LL)
+
+static int q_err;
+
+static q32_t q32_from_int(int64_t x) {
+    if (x > 2147483647LL || x < -2147483648LL) { q_err = 1; return x > 0 ? Q32_MAX : Q32_MIN; }
+    return x << 32;
+}
+
+static q32_t q32_add(q32_t a, q32_t b) {
+    uint64_t r = (uint64_t)a + (uint64_t)b;
+    if (((a ^ (q32_t)r) & (b ^ (q32_t)r)) < 0) {
+        q_err = 1;
+        return a > 0 ? Q32_MAX : Q32_MIN;
+    }
+    return (q32_t)r;
+}
+
+static q32_t q32_sub(q32_t a, q32_t b) {
+    uint64_t r = (uint64_t)a - (uint64_t)b;
+    if (((a ^ b) & (a ^ (q32_t)r)) < 0) {
+        q_err = 1;
+        return a > 0 ? Q32_MAX : Q32_MIN;
+    }
+    return (q32_t)r;
+}
+
+static q32_t q32_mul(q32_t a, q32_t b) {
+    int neg = (a < 0) ^ (b < 0);
+    uint64_t ua = a < 0 ? -(uint64_t)a : (uint64_t)a;
+    uint64_t ub = b < 0 ? -(uint64_t)b : (uint64_t)b;
+    uint32_t al = (uint32_t)ua, ah = (uint32_t)(ua >> 32);
+    uint32_t bl = (uint32_t)ub, bh = (uint32_t)(ub >> 32);
+    if (ah && bh) {
+        uint64_t hh = (uint64_t)ah * bh;
+        if (hh >= 0x80000000ULL) { q_err = 1; return neg ? Q32_MIN : Q32_MAX; }
+        uint64_t p_ll = (uint64_t)al * bl;
+        uint64_t p_hl = (uint64_t)ah * bl;
+        uint64_t p_lh = (uint64_t)al * bh;
+        uint64_t mid = (p_ll >> 32) + (p_hl & 0xFFFFFFFFULL) + (p_lh & 0xFFFFFFFFULL);
+        uint64_t hi = hh + (p_hl >> 32) + (p_lh >> 32) + (mid >> 32);
+        if (hi >= 0x80000000ULL) { q_err = 1; return neg ? Q32_MIN : Q32_MAX; }
+        uint64_t res = (hi << 32) | (mid & 0xFFFFFFFFULL);
+        res += (p_ll >> 31) & 1ULL;
+        return neg ? -(q32_t)res : (q32_t)res;
+    }
+    uint64_t p_ll = (uint64_t)al * bl;
+    uint64_t p_hl = (uint64_t)ah * bl;
+    uint64_t p_lh = (uint64_t)al * bh;
+    uint64_t mid = (p_ll >> 32) + (p_hl & 0xFFFFFFFFULL) + (p_lh & 0xFFFFFFFFULL);
+    uint64_t hi = (p_hl >> 32) + (p_lh >> 32) + (mid >> 32);
+    if (hi >= 0x80000000ULL) { q_err = 1; return neg ? Q32_MIN : Q32_MAX; }
+    uint64_t res = (hi << 32) | (mid & 0xFFFFFFFFULL);
+    res += (p_ll >> 31) & 1ULL;
+    return neg ? -(q32_t)res : (q32_t)res;
+}
+
+static q32_t q32_div(q32_t a, q32_t b) {
+    if (b == 0) { q_err = 1; return 0; }
+    int neg = (a < 0) ^ (b < 0);
+    uint64_t ua = a < 0 ? -(uint64_t)a : (uint64_t)a;
+    uint64_t ub = b < 0 ? -(uint64_t)b : (uint64_t)b;
+    uint64_t q_int = ua / ub;
+    if (q_int >= 0x80000000ULL) { q_err = 1; return neg ? Q32_MIN : Q32_MAX; }
+    uint64_t rem = ua % ub;
+    uint32_t frac = 0;
+    if (ub <= 0xFFFFFFFFULL) {
+        frac = (uint32_t)(((rem << 32) + (ub >> 1)) / ub);
+        uint64_t res = (q_int << 32) + frac;
+        return neg ? -(q32_t)res : (q32_t)res;
+    }
+    for (int i = 0; i < 32; i++) {
+        uint64_t top = rem >> 63;
+        rem <<= 1;
+        frac <<= 1;
+        if (top || rem >= ub) {
+            rem -= ub;
+            frac |= 1u;
+        }
+    }
+    uint64_t top = rem >> 63;
+    rem <<= 1;
+    uint64_t res = (q_int << 32) | frac;
+    if (top || rem >= ub) res++;
+    return neg ? -(q32_t)res : (q32_t)res;
+}
+
+static q32_t q32_sqrt(q32_t x) {
+    if (x < 0) { q_err = 1; return 0; }
+    if (x == 0) return 0;
+    uint64_t ux = (uint64_t)x;
+    uint64_t rem = 0, root = 0;
+    for (int i = 47; i >= 0; i--) {
+        uint64_t two = i >= 16 ? ((ux >> (2 * (i - 16))) & 3ULL) : 0ULL;
+        rem = (rem << 2) | two;
+        uint64_t cand = (root << 2) | 1ULL;
+        if (rem >= cand) {
+            rem -= cand;
+            root = (root << 1) | 1ULL;
+        } else {
+            root <<= 1;
+        }
+    }
+    return (q32_t)root;
+}
+
+static void q32_sincos(q32_t theta, q32_t *out_s, q32_t *out_c) {
+    q32_t r = theta;
+    if (r > Q32_PI || r < -Q32_PI) {
+        int save = q_err;
+        int64_t turns = q32_mul(r, Q32_INV_TWO_PI) >> 32;
+        q_err = save;
+        r -= turns * Q32_TWO_PI;
+        while (r > Q32_PI) r -= Q32_TWO_PI;
+        while (r < -Q32_PI) r += Q32_TWO_PI;
+    }
+    int flip = 0;
+    if (r > Q32_HALF_PI) { r = Q32_PI - r; flip = 1; }
+    else if (r < -Q32_HALF_PI) { r = -Q32_PI - r; flip = 1; }
+
+    q32_t x = CORDIC_K, y = 0, z = r;
+    for (int i = 0; i < 30; i++) {
+        q32_t dx = y >> i, dy = x >> i;
+        if (z >= 0) { x -= dx; y += dy; z -= CORDIC_ATAN[i]; }
+        else        { x += dx; y -= dy; z += CORDIC_ATAN[i]; }
+    }
+    if (flip) x = -x;
+    if (x > -16 && x < 16) x = 0;
+    if (y > -16 && y < 16) y = 0;
+    *out_s = y;
+    *out_c = x;
+}
+
+static q32_t q32_ln(q32_t x) {
+    if (x <= 0) { q_err = 1; return 0; }
+    uint64_t m = (uint64_t)x;
+    int k = 0;
+    while (m >= (2ULL << 32)) { m >>= 1; k++; }
+    while (m < (1ULL << 32)) { m <<= 1; k--; }
+    uint64_t prod = 1ULL << 32;
+    q32_t acc = 0;
+    for (int i = 1; i <= 30; i++) {
+        uint64_t nxt = prod + (prod >> i);
+        if (nxt <= m) {
+            prod = nxt;
+            acc += LN1P_POW2[i];
+        }
+    }
+    if (m > prod) acc += q32_div((q32_t)(m - prod), (q32_t)prod);
+    return (int64_t)k * Q32_LN2 + acc;
+}
+
+static q32_t q32_exp(q32_t x) {
+    if (x > 92288000000LL) { q_err = 1; return Q32_MAX; }
+    if (x < -96000000000LL) return 0;
+    q32_t kq = q32_mul(x, Q32_INV_LN2);
+    int32_t k = (int32_t)(kq >> 32);
+    q32_t r = x - (int64_t)k * Q32_LN2;
+    while (r < 0) { r += Q32_LN2; k--; }
+    while (r >= Q32_LN2) { r -= Q32_LN2; k++; }
+    uint64_t prod = 1ULL << 32;
+    for (int i = 1; i <= 30; i++) {
+        if (r >= LN1P_POW2[i]) {
+            r -= LN1P_POW2[i];
+            prod += prod >> i;
+        }
+    }
+    if (r > 0) prod += (prod * (uint64_t)r) >> 32;
+    if (k >= 31) { q_err = 1; return Q32_MAX; }
+    if (k >= 0) {
+        uint64_t res = prod << k;
+        if (res >= 0x8000000000000000ULL) { q_err = 1; return Q32_MAX; }
+        return (q32_t)res;
+    }
+    return (-k >= 63) ? 0 : (q32_t)(prod >> (-k));
+}
+
+static q32_t q32_ipow(q32_t a, int32_t e) {
+    int inv = 0;
+    if (e < 0) { inv = 1; e = -e; }
+    q32_t res = Q32_ONE;
+    while (e > 0 && !q_err) {
+        if (e & 1) res = q32_mul(res, a);
+        e >>= 1;
+        if (e) a = q32_mul(a, a);
+    }
+    return inv ? q32_div(Q32_ONE, res) : res;
+}
+
+static q32_t q32_pow(q32_t a, q32_t b) {
+    if ((b & 0xFFFFFFFFLL) == 0) {
+        int64_t e = b >> 32;
+        if (e >= -64 && e <= 64) return q32_ipow(a, (int32_t)e);
+    }
+    if (a == 0) {
+        if (b <= 0) q_err = 1;
+        return 0;
+    }
+    if (a < 0) { q_err = 1; return 0; }
+    return q32_exp(q32_mul(b, q32_ln(a)));
+}
+
+static int parse_q32_num(const char *s, const char **endp, q32_t *out) {
+    while (*s == ' ') s++;
+    int neg = 0;
+    if (*s == '-' || *s == '+') { neg = (*s == '-'); s++; }
+    while (*s == ' ') s++;
+    if (starts_with_ci(s, "pi") && !is_alpha(s[2])) {
+        *out = neg ? -Q32_PI : Q32_PI;
+        if (endp) *endp = s + 2;
+        return 1;
+    }
+    if (!is_digit(*s) && !(*s == '.' && is_digit(s[1]))) return 0;
+    uint64_t ip = 0;
+    while (is_digit(*s)) {
+        ip = ip * 10 + (uint64_t)(*s - '0');
+        if (ip > 2147483647ULL) return 0;
+        s++;
+    }
+    uint64_t fp_num = 0, fp_den = 1;
+    if (*s == '.') {
+        s++;
+        while (is_digit(*s)) {
+            if (fp_den < 100000000000ULL) {
+                fp_num = fp_num * 10 + (uint64_t)(*s - '0');
+                fp_den *= 10;
+            }
+            s++;
+        }
+    }
+    uint64_t frac = 0;
+    if (fp_num > 0) {
+        // Compute (fp_num << 32) / fp_den cleanly via 32-bit binary division
+        uint64_t rem = fp_num;
+        for (int i = 0; i < 32; i++) {
+            rem <<= 1;
+            frac <<= 1;
+            if (rem >= fp_den) { rem -= fp_den; frac |= 1ULL; }
+        }
+        if ((rem << 1) >= fp_den) frac++;
+    }
+    q32_t v = (q32_t)((ip << 32) + frac);
+    // Optional /denom for inline bounds like "-pi/2" or "3/2"
+    if (*s == '/' && is_digit(s[1])) {
+        s++;
+        int64_t d = 0;
+        while (is_digit(*s) && d < 100000000LL) { d = d * 10 + (*s - '0'); s++; }
+        if (d > 0) v = q32_div(v, q32_from_int(d));
+    }
+    *out = neg ? -v : v;
+    if (endp) *endp = s;
+    return 1;
+}
+
+static void fmt_q32(q32_t v, char *buf, int cap, int decimals) {
+    int p = 0;
+    if (v > -64 && v < 64) v = 0;  // snap sub-1.5e-8 noise to 0
+    int neg = v < 0;
+    uint64_t uv = neg ? -(uint64_t)v : (uint64_t)v;
+    uint32_t scale = 1;
+    for (int i = 0; i < decimals; i++) scale *= 10u;
+    uint32_t ip = (uint32_t)(uv >> 32);
+    uint64_t fl = uv & 0xFFFFFFFFULL;
+    // Rounded decimal fraction: ((fl * scale) + 2^31) >> 32
+    uint64_t prod = fl * (uint64_t)scale + (1ULL << 31);
+    uint32_t dec = (uint32_t)(prod >> 32);
+    if (dec >= scale) { ip++; dec -= scale; }
+    if (ip == 0 && dec == 0) neg = 0;
+    if (neg) append_char(buf, cap, &p, '-');
+
+    char itmp[16];
+    int in = 0;
+    if (ip == 0) itmp[in++] = '0';
+    while (ip > 0) { itmp[in++] = (char)('0' + (ip % 10u)); ip /= 10u; }
+    while (in > 0) append_char(buf, cap, &p, itmp[--in]);
+
+    if (decimals > 0 && dec > 0) {
+        char dtmp[12];
+        for (int i = decimals - 1; i >= 0; i--) {
+            dtmp[i] = (char)('0' + (dec % 10u));
+            dec /= 10u;
+        }
+        int len = decimals;
+        while (len > 0 && dtmp[len - 1] == '0') len--;
+        if (len > 0) {
+            append_char(buf, cap, &p, '.');
+            for (int i = 0; i < len; i++) append_char(buf, cap, &p, dtmp[i]);
+        }
+    }
+}
+
+// Continued-fraction recovery for exact small rationals p/q (1 < q <= 240, error <= 6 ULPs).
+static void fmt_q32_rich(q32_t v, char *buf, int cap) {
+    fmt_q32(v, buf, cap, 6);
+    uint64_t uv = v < 0 ? -(uint64_t)v : (uint64_t)v;
+    if ((uv & 0xFFFFFFFFULL) < 64 || (uv & 0xFFFFFFFFULL) > 0xFFFFFFC0ULL) return;
+    int64_t p0 = 0, q0 = 1, p1 = 1, q1 = 0;
+    uint64_t num = uv, den = 1ULL << 32;
+    for (int step = 0; step < 12 && den != 0; step++) {
+        int64_t a = (int64_t)(num / den);
+        uint64_t r = num % den;
+        int64_t p2 = a * p1 + p0;
+        int64_t q2 = a * q1 + q0;
+        if (q2 > 240) break;
+        p0 = p1; q0 = q1; p1 = p2; q1 = q2;
+        if (q1 > 1) {
+            int save = q_err;
+            q_err = 0;
+            q32_t cand = q32_div(q32_from_int(v < 0 ? -p1 : p1), q32_from_int(q1));
+            q_err = save;
+            q32_t diff = v > cand ? v - cand : cand - v;
+            if (diff <= 6) {
+                char dec_buf[32];
+                fmt_q32(v, dec_buf, sizeof dec_buf, 6);
+                int pos = 0;
+                if (v < 0) append_char(buf, cap, &pos, '-');
+                char tmp[24];
+                int tn = 0;
+                uint32_t up = (uint32_t)p1;
+                while (up > 0) { tmp[tn++] = (char)('0' + (up % 10u)); up /= 10u; }
+                while (tn > 0) append_char(buf, cap, &pos, tmp[--tn]);
+                append_char(buf, cap, &pos, '/');
+                uint32_t uq = (uint32_t)q1;
+                while (uq > 0) { tmp[tn++] = (char)('0' + (uq % 10u)); uq /= 10u; }
+                while (tn > 0) append_char(buf, cap, &pos, tmp[--tn]);
+                append_str(buf, cap, &pos, " (~");
+                append_str(buf, cap, &pos, dec_buf);
+                append_char(buf, cap, &pos, ')');
+                return;
+            }
+        }
+        num = den;
+        den = r;
+    }
+}
+
+// --- RPN Bytecode Compiler & Evaluator ---
+enum {
+    OP_NUM = 1, OP_VAR_X,
+    OP_ADD, OP_SUB, OP_MUL, OP_DIV, OP_POW, OP_NEG,
+    OP_SIN, OP_COS, OP_TAN, OP_SQRT, OP_ABS, OP_EXP, OP_LN, OP_LOG10
+};
+
+typedef struct {
+    uint8_t op;
+    q32_t val;
+} RpnInst;
+
+typedef struct {
+    RpnInst code[96];
+    int n;
+    int uses_x;
+} RpnProg;
+
+static int rpn_prec(int op) {
+    if (op >= OP_SIN) return 5;
+    if (op == OP_POW) return 4;
+    if (op == OP_NEG) return 3;
+    if (op == OP_MUL || op == OP_DIV) return 2;
+    return 1;
+}
+
+static int compile_rpn(const char *s, RpnProg *prog) {
+    prog->n = 0;
+    prog->uses_x = 0;
+    uint8_t op_stk[64];
+    int no = 0, operand = 1;
+
+    while (*s) {
+        if (is_space(*s)) { s++; continue; }
+        if (prog->n >= 92 || no >= 60) return 0;
+
+        // Implicit multiplication when an atom/group just finished (`operand == 0`)
+        // and the next token starts an operand (`x`, `pi`, `e`, `(`, or function name, or digit after `)`)
+        if (!operand) {
+            if (*s == '(' || is_alpha(*s)) {
+                int pr = rpn_prec(OP_MUL);
+                while (no && op_stk[no - 1] != '(' && rpn_prec(op_stk[no - 1]) >= pr)
+                    prog->code[prog->n++] = (RpnInst){op_stk[--no], 0};
+                op_stk[no++] = OP_MUL;
+                operand = 1;
+            }
+        }
+
+        if (operand) {
+            if (*s == '(') {
+                op_stk[no++] = '(';
+                s++;
+            } else if (*s == '-' || *s == '+') {
+                if (*s == '-') op_stk[no++] = OP_NEG;
+                s++;
+            } else if (is_digit(*s) || (*s == '.' && is_digit(s[1]))) {
+                const char *end = s;
+                // Do not let parse_q32_num swallow `/denom` inside general expressions!
+                uint64_t ip = 0;
+                while (is_digit(*end)) {
+                    ip = ip * 10 + (uint64_t)(*end - '0');
+                    if (ip > 2147483647ULL) return 0;
+                    end++;
+                }
+                uint64_t fp_num = 0, fp_den = 1;
+                if (*end == '.') {
+                    end++;
+                    while (is_digit(*end)) {
+                        if (fp_den < 100000000000ULL) {
+                            fp_num = fp_num * 10 + (uint64_t)(*end - '0');
+                            fp_den *= 10;
+                        }
+                        end++;
+                    }
+                }
+                uint64_t frac = 0;
+                if (fp_num > 0) {
+                    uint64_t rem = fp_num;
+                    for (int i = 0; i < 32; i++) {
+                        rem <<= 1; frac <<= 1;
+                        if (rem >= fp_den) { rem -= fp_den; frac |= 1ULL; }
+                    }
+                    if ((rem << 1) >= fp_den) frac++;
+                }
+                prog->code[prog->n++] = (RpnInst){OP_NUM, (q32_t)((ip << 32) + frac)};
+                s = end;
+                operand = 0;
+            } else if (is_alpha(*s)) {
+                char id[16];
+                int il = 0;
+                while (is_alpha(*s) || is_digit(*s)) {
+                    if (il < 15) id[il++] = (*s >= 'A' && *s <= 'Z') ? (char)(*s + 32) : *s;
+                    s++;
+                }
+                id[il] = 0;
+                while (*s == ' ') s++;
+                if (streq(id, "x") || streq(id, "t")) {
+                    prog->code[prog->n++] = (RpnInst){OP_VAR_X, 0};
+                    prog->uses_x = 1;
+                    operand = 0;
+                } else if (streq(id, "pi")) {
+                    prog->code[prog->n++] = (RpnInst){OP_NUM, Q32_PI};
+                    operand = 0;
+                } else if (streq(id, "e")) {
+                    prog->code[prog->n++] = (RpnInst){OP_NUM, Q32_E};
+                    operand = 0;
+                } else if (*s == '(') {
+                    uint8_t fn = 0;
+                    if (streq(id, "sin")) fn = OP_SIN;
+                    else if (streq(id, "cos")) fn = OP_COS;
+                    else if (streq(id, "tan")) fn = OP_TAN;
+                    else if (streq(id, "sqrt")) fn = OP_SQRT;
+                    else if (streq(id, "abs")) fn = OP_ABS;
+                    else if (streq(id, "exp")) fn = OP_EXP;
+                    else if (streq(id, "ln") || streq(id, "log")) fn = OP_LN;
+                    else if (streq(id, "log10")) fn = OP_LOG10;
+                    else return 0;
+                    op_stk[no++] = fn;
+                    op_stk[no++] = '(';
+                    s++;  // consume '('
+                } else {
+                    return 0;
+                }
+            } else {
+                return 0;
+            }
+            continue;
+        }
+
+        if (*s == ')') {
+            while (no && op_stk[no - 1] != '(')
+                prog->code[prog->n++] = (RpnInst){op_stk[--no], 0};
+            if (!no) return 0;
+            no--;  // pop '('
+            if (no && op_stk[no - 1] >= OP_SIN)
+                prog->code[prog->n++] = (RpnInst){op_stk[--no], 0};
+            s++;
+            continue;
+        }
+
+        uint8_t op = 0;
+        int adv = 1;
+        if (*s == '+') op = OP_ADD;
+        else if (*s == '-') op = OP_SUB;
+        else if (*s == '*' && s[1] == '*') { op = OP_POW; adv = 2; }
+        else if (*s == '*') op = OP_MUL;
+        else if (*s == '/') op = OP_DIV;
+        else if (*s == '^') op = OP_POW;
+        else return 0;
+
+        int pr = rpn_prec(op);
+        while (no && op_stk[no - 1] != '(' &&
+               (rpn_prec(op_stk[no - 1]) > pr || (rpn_prec(op_stk[no - 1]) == pr && op != OP_POW)))
+            prog->code[prog->n++] = (RpnInst){op_stk[--no], 0};
+        op_stk[no++] = op;
+        s += adv;
+        operand = 1;
+    }
+
+    if (operand) return 0;
+    while (no) {
+        if (op_stk[no - 1] == '(') return 0;
+        prog->code[prog->n++] = (RpnInst){op_stk[--no], 0};
+    }
+    return prog->n > 0;
+}
+
+static q32_t eval_rpn(const RpnProg *prog, q32_t x_val, int *ok, char *step_buf, int step_cap) {
+    q32_t stk[48];
+    int sp = 0, step_pos = 0, step_cnt = 0;
+    q_err = 0;
+    if (step_buf && step_cap > 0) step_buf[0] = 0;
+
+    for (int i = 0; i < prog->n && !q_err; i++) {
+        uint8_t op = prog->code[i].op;
+        if (op == OP_NUM) {
+            stk[sp++] = prog->code[i].val;
+        } else if (op == OP_VAR_X) {
+            stk[sp++] = x_val;
+        } else if (op == OP_NEG || op >= OP_SIN) {
+            if (sp < 1) { q_err = 1; break; }
+            q32_t a = stk[sp - 1], r = 0, s_tmp, c_tmp;
+            const char *fn_name = NULL;
+            if (op == OP_NEG) r = -a;
+            else if (op == OP_SIN) { q32_sincos(a, &s_tmp, &c_tmp); r = s_tmp; fn_name = "sin"; }
+            else if (op == OP_COS) { q32_sincos(a, &s_tmp, &c_tmp); r = c_tmp; fn_name = "cos"; }
+            else if (op == OP_TAN) {
+                q32_sincos(a, &s_tmp, &c_tmp);
+                if (c_tmp > -4096 && c_tmp < 4096) q_err = 1;
+                else r = q32_div(s_tmp, c_tmp);
+                fn_name = "tan";
+            }
+            else if (op == OP_SQRT) { r = q32_sqrt(a); fn_name = "sqrt"; }
+            else if (op == OP_ABS) { r = a < 0 ? -a : a; fn_name = "abs"; }
+            else if (op == OP_EXP) { r = q32_exp(a); fn_name = "exp"; }
+            else if (op == OP_LN) { r = q32_ln(a); fn_name = "ln"; }
+            else if (op == OP_LOG10) { r = q32_div(q32_ln(a), Q32_LN10); fn_name = "log10"; }
+            stk[sp - 1] = r;
+            if (step_buf && fn_name && !q_err && step_cnt < 8) {
+                char ba[32], br[32];
+                fmt_q32(a, ba, sizeof ba, 6);
+                fmt_q32(r, br, sizeof br, 6);
+                step_cnt++;
+                append_str(step_buf, step_cap, &step_pos, "step ");
+                append_char(step_buf, step_cap, &step_pos, (char)('0' + step_cnt));
+                append_str(step_buf, step_cap, &step_pos, ": ");
+                append_str(step_buf, step_cap, &step_pos, fn_name);
+                append_char(step_buf, step_cap, &step_pos, '(');
+                append_str(step_buf, step_cap, &step_pos, ba);
+                append_str(step_buf, step_cap, &step_pos, ") = ");
+                append_str(step_buf, step_cap, &step_pos, br);
+                append_char(step_buf, step_cap, &step_pos, '\n');
+            }
+        } else {
+            if (sp < 2) { q_err = 1; break; }
+            q32_t b = stk[--sp], a = stk[sp - 1], r = 0;
+            const char *op_s = "+";
+            if (op == OP_ADD) { r = q32_add(a, b); op_s = "+"; }
+            else if (op == OP_SUB) { r = q32_sub(a, b); op_s = "-"; }
+            else if (op == OP_MUL) { r = q32_mul(a, b); op_s = "*"; }
+            else if (op == OP_DIV) { r = q32_div(a, b); op_s = "/"; }
+            else if (op == OP_POW) { r = q32_pow(a, b); op_s = "^"; }
+            stk[sp - 1] = r;
+            if (step_buf && !q_err && step_cnt < 8) {
+                char ba[32], bb[32], br[32];
+                fmt_q32(a, ba, sizeof ba, 6);
+                fmt_q32(b, bb, sizeof bb, 6);
+                fmt_q32(r, br, sizeof br, 6);
+                step_cnt++;
+                append_str(step_buf, step_cap, &step_pos, "step ");
+                append_char(step_buf, step_cap, &step_pos, (char)('0' + step_cnt));
+                append_str(step_buf, step_cap, &step_pos, ": ");
+                append_str(step_buf, step_cap, &step_pos, ba);
+                append_char(step_buf, step_cap, &step_pos, ' ');
+                append_str(step_buf, step_cap, &step_pos, op_s);
+                append_char(step_buf, step_cap, &step_pos, ' ');
+                append_str(step_buf, step_cap, &step_pos, bb);
+                append_str(step_buf, step_cap, &step_pos, " = ");
+                append_str(step_buf, step_cap, &step_pos, br);
+                append_char(step_buf, step_cap, &step_pos, '\n');
+            }
+        }
+    }
+    if (q_err || sp != 1) {
+        if (ok) *ok = 0;
+        return 0;
+    }
+    if (ok) *ok = 1;
+    return stk[0];
+}
+
+// Detect exact degree <= 2 polynomial f(x) = a*x^2 + b*x + c using 7-point verification.
+// Returns degree (0, 1, 2) or -1 if non-quadratic / nonlinear.
+static int detect_poly2(const RpnProg *prog, q32_t *out_a, q32_t *out_b, q32_t *out_c) {
+    int ok0, ok1, okm1, ok2, okm2, okt1, okt2;
+    q32_t y0 = eval_rpn(prog, 0, &ok0, NULL, 0);
+    q32_t y1 = eval_rpn(prog, Q32_ONE, &ok1, NULL, 0);
+    q32_t ym1 = eval_rpn(prog, -Q32_ONE, &okm1, NULL, 0);
+    if (!ok0 || !ok1 || !okm1) return -1;
+
+    q_err = 0;
+    q32_t c = y0;
+    q32_t b = q32_sub(y1, ym1) >> 1;
+    q32_t a = q32_sub(q32_add(y1, ym1), q32_add(y0, y0)) >> 1;
+    if (q_err) return -1;
+
+    q32_t xs[4] = {2 * Q32_ONE, -2 * Q32_ONE, (11LL << 29), -(13LL << 30)};  // 2, -2, 1.375, -3.25
+    int *oks[4] = {&ok2, &okm2, &okt1, &okt2};
+    for (int i = 0; i < 4; i++) {
+        q32_t y = eval_rpn(prog, xs[i], oks[i], NULL, 0);
+        if (!*oks[i]) return -1;
+        q_err = 0;
+        q32_t pred = q32_add(q32_mul(q32_add(q32_mul(a, xs[i]), b), xs[i]), c);
+        if (q_err) return -1;
+        q32_t diff = y > pred ? y - pred : pred - y;
+        if (diff > 256) return -1;  // > 6e-8 mismatch -> higher degree or transcendental
+    }
+    if (a > -64 && a < 64) a = 0;
+    if (b > -64 && b < 64) b = 0;
+    if (c > -64 && c < 64) c = 0;
+    *out_a = a;
+    *out_b = b;
+    *out_c = c;
+    return a != 0 ? 2 : (b != 0 ? 1 : 0);
+}
+
+static q32_t bisect_diff(const RpnProg *lhs, const RpnProg *rhs, q32_t rhs_const,
+                         q32_t xa, q32_t xb, q32_t ga) {
+    for (int it = 0; it < 28; it++) {
+        q32_t xm = (xa >> 1) + (xb >> 1) + ((xa & xb) & 1LL);
+        int ok1 = 1, ok2 = 1;
+        q32_t lv = eval_rpn(lhs, xm, &ok1, NULL, 0);
+        q32_t rv = (rhs && rhs->uses_x) ? eval_rpn(rhs, xm, &ok2, NULL, 0) : rhs_const;
+        if (!ok1 || !ok2) break;
+        q32_t gm = lv - rv;
+        if (gm == 0) return xm;
+        if ((ga < 0 && gm < 0) || (ga > 0 && gm > 0)) {
+            xa = xm;
+            ga = gm;
+        } else {
+            xb = xm;
+        }
+    }
+    return (xa >> 1) + (xb >> 1);
+}
+
+static void add_unique_root(q32_t *roots, int *nroots, int cap, q32_t r) {
+    for (int i = 0; i < *nroots; i++) {
+        q32_t d = roots[i] > r ? roots[i] - r : r - roots[i];
+        if (d < 400000LL) return;  // < 1e-4 duplicate
+    }
+    if (*nroots < cap) {
+        int pos = *nroots;
+        while (pos > 0 && roots[pos - 1] > r) {
+            roots[pos] = roots[pos - 1];
+            pos--;
+        }
+        roots[pos] = r;
+        (*nroots)++;
+    }
+}
+
+// --- Equation Solver Mode (`LHS = RHS`) ---
+static int run_solver_mode(const char *full_eq, const char *lhs_s, const char *rhs_s,
+                           int has_bounds, q32_t xmin, q32_t xmax) {
+    RpnProg lhs, rhs;
+    if (!compile_rpn(lhs_s, &lhs) || !compile_rpn(rhs_s, &rhs)) return 1;
+
+    puts_raw("equation: ");
+    puts_raw(full_eq);
+    rv_putchar('\n');
+
+    // Build combined difference program g(x) = LHS(x) - RHS(x) if small enough for poly detection
+    RpnProg diff = lhs;
+    int can_poly = (lhs.n + rhs.n + 1 <= 92);
+    if (can_poly) {
+        for (int i = 0; i < rhs.n; i++) diff.code[diff.n++] = rhs.code[i];
+        diff.code[diff.n++] = (RpnInst){OP_SUB, 0};
+        diff.uses_x = lhs.uses_x || rhs.uses_x;
+    }
+
+    q32_t pa = 0, pb = 0, pc = 0;
+    int deg = (!has_bounds && can_poly) ? detect_poly2(&diff, &pa, &pb, &pc) : -1;
+
+    char buf1[48], buf2[48];
+    if (deg == 0) {
+        puts_raw(pc == 0 ? "identity: true for all real x\n" : "no solution (contradiction)\n");
+        return 0;
+    }
+    if (deg == 1) {
+        q_err = 0;
+        q32_t root = q32_div(-pc, pb);
+        fmt_q32(pb, buf1, sizeof buf1, 6);
+        fmt_q32(pc, buf2, sizeof buf2, 6);
+        puts_raw("linear form: ");
+        puts_raw(buf1);
+        puts_raw("*x + (");
+        puts_raw(buf2);
+        puts_raw(") = 0\n");
+        fmt_q32_rich(root, buf1, sizeof buf1);
+        puts_raw("exact solution: x = ");
+        puts_raw(buf1);
+        rv_putchar('\n');
+        int ok1, ok2;
+        q32_t lv = eval_rpn(&lhs, root, &ok1, NULL, 0);
+        q32_t rv = eval_rpn(&rhs, root, &ok2, NULL, 0);
+        if (ok1 && ok2) {
+            fmt_q32(lv, buf1, sizeof buf1, 6);
+            fmt_q32(rv, buf2, sizeof buf2, 6);
+            puts_raw("check: LHS = ");
+            puts_raw(buf1);
+            puts_raw(", RHS = ");
+            puts_raw(buf2);
+            rv_putchar('\n');
+        }
+        return 0;
+    }
+    if (deg == 2) {
+        q_err = 0;
+        q32_t disc = q32_sub(q32_mul(pb, pb), 4 * q32_mul(pa, pc));
+        char ba[32], bb[32], bc[32], bd[32];
+        fmt_q32(pa, ba, sizeof ba, 6);
+        fmt_q32(pb, bb, sizeof bb, 6);
+        fmt_q32(pc, bc, sizeof bc, 6);
+        fmt_q32(disc, bd, sizeof bd, 6);
+        puts_raw("quadratic form: (");
+        puts_raw(ba);
+        puts_raw(")*x^2 + (");
+        puts_raw(bb);
+        puts_raw(")*x + (");
+        puts_raw(bc);
+        puts_raw(") = 0\ndiscriminant: D = ");
+        puts_raw(bd);
+        rv_putchar('\n');
+        q32_t two_a = 2 * pa;
+        if (disc < -128) {
+            q32_t re = q32_div(-pb, two_a);
+            q32_t im = q32_div(q32_sqrt(-disc), two_a < 0 ? -two_a : two_a);
+            fmt_q32(re, buf1, sizeof buf1, 6);
+            fmt_q32(im, buf2, sizeof buf2, 6);
+            puts_raw("real solutions: none (D < 0)\ncomplex solutions: x = ");
+            puts_raw(buf1);
+            puts_raw(" - ");
+            puts_raw(buf2);
+            puts_raw("*i, x = ");
+            puts_raw(buf1);
+            puts_raw(" + ");
+            puts_raw(buf2);
+            puts_raw("*i\n");
+            return 0;
+        }
+        if (disc <= 128) {
+            q32_t r = q32_div(-pb, two_a);
+            fmt_q32_rich(r, buf1, sizeof buf1);
+            puts_raw("double root: x = ");
+            puts_raw(buf1);
+            rv_putchar('\n');
+            return 0;
+        }
+        q32_t sd = q32_sqrt(disc);
+        q32_t r1 = q32_div(-pb - sd, two_a);
+        q32_t r2 = q32_div(-pb + sd, two_a);
+        if (r1 > r2) { q32_t t = r1; r1 = r2; r2 = t; }
+        fmt_q32_rich(r1, buf1, sizeof buf1);
+        fmt_q32_rich(r2, buf2, sizeof buf2);
+        puts_raw("solutions: x = ");
+        puts_raw(buf1);
+        puts_raw(", x = ");
+        puts_raw(buf2);
+        rv_putchar('\n');
+        int ok1, ok2;
+        q32_t lv = eval_rpn(&lhs, r1, &ok1, NULL, 0);
+        q32_t rv = eval_rpn(&rhs, r1, &ok2, NULL, 0);
+        if (ok1 && ok2) {
+            fmt_q32(lv, buf1, sizeof buf1, 6);
+            fmt_q32(rv, buf2, sizeof buf2, 6);
+            puts_raw("check (at x1): LHS = ");
+            puts_raw(buf1);
+            puts_raw(", RHS = ");
+            puts_raw(buf2);
+            rv_putchar('\n');
+        }
+        return 0;
+    }
+
+    // General nonlinear equation scan + 28-step bisection
+    q32_t lo = has_bounds ? xmin : -(20LL << 32);
+    q32_t hi = has_bounds ? xmax : (20LL << 32);
+    int rhs_const_ok = 1;
+    q32_t rhs_const = rhs.uses_x ? 0 : eval_rpn(&rhs, 0, &rhs_const_ok, NULL, 0);
+    q32_t roots[8];
+    int nroots = 0;
+    for (int pass = 0; pass < (has_bounds ? 1 : 2) && nroots == 0; pass++) {
+        if (pass == 1) { lo = -(100LL << 32); hi = 100LL << 32; }
+        const int N = 64;
+        q32_t step = (hi - lo) >> 6;
+        q32_t px = lo, pg = 0;
+        int pok = 0;
+        for (int i = 0; i <= N; i++) {
+            q32_t x = (i == N) ? hi : (lo + i * step);
+            int ok1, ok2 = rhs_const_ok;
+            q32_t lv = eval_rpn(&lhs, x, &ok1, NULL, 0);
+            q32_t rv = rhs.uses_x ? eval_rpn(&rhs, x, &ok2, NULL, 0) : rhs_const;
+            int ok = ok1 && ok2;
+            q32_t g = ok ? (lv - rv) : 0;
+            if (ok && g > -256 && g < 256) {
+                add_unique_root(roots, &nroots, 8, x);
+            } else if (ok && pok && ((pg < 0 && g > 0) || (pg > 0 && g < 0))) {
+                q32_t r = bisect_diff(&lhs, &rhs, rhs_const, px, x, pg);
+                // Reject vertical asymptotes (e.g. 1/x = 0)
+                int okc1, okc2 = rhs_const_ok;
+                q32_t cl = eval_rpn(&lhs, r, &okc1, NULL, 0);
+                q32_t cr = rhs.uses_x ? eval_rpn(&rhs, r, &okc2, NULL, 0) : rhs_const;
+                q32_t rem = (okc1 && okc2) ? (cl > cr ? cl - cr : cr - cl) : Q32_ONE;
+                if (okc1 && okc2 && rem < (Q32_ONE >> 10))
+                    add_unique_root(roots, &nroots, 8, r);
+            }
+            px = x; pg = g; pok = ok;
+        }
+    }
+    if (nroots == 0) {
+        puts_raw("solutions on search interval: none found\n");
+    } else {
+        puts_raw("solutions: ");
+        for (int i = 0; i < nroots; i++) {
+            if (i > 0) puts_raw(", ");
+            puts_raw("x = ");
+            fmt_q32_rich(roots[i], buf1, sizeof buf1);
+            puts_raw(buf1);
+        }
+        rv_putchar('\n');
+        int ok1, ok2;
+        q32_t lv = eval_rpn(&lhs, roots[0], &ok1, NULL, 0);
+        q32_t rv = eval_rpn(&rhs, roots[0], &ok2, NULL, 0);
+        if (ok1 && ok2) {
+            fmt_q32(lv, buf1, sizeof buf1, 6);
+            fmt_q32(rv, buf2, sizeof buf2, 6);
+            puts_raw("check: LHS = ");
+            puts_raw(buf1);
+            puts_raw(", RHS = ");
+            puts_raw(buf2);
+            rv_putchar('\n');
+        }
+    }
+    return 0;
+}
+
+// Golden-section polish for local extremum on [a, b] (`find_max` = 1 for max, 0 for min)
+static q32_t polish_extremum(const RpnProg *prog, q32_t a, q32_t b, int find_max, q32_t *out_y) {
+    // inv_phi = (sqrt(5) - 1) / 2 = 0.61803398875 in Q32.32 = 2654435769LL
+    const q32_t INV_PHI = 2654435769LL;
+    q32_t c = b - q32_mul(b - a, INV_PHI);
+    q32_t d = a + q32_mul(b - a, INV_PHI);
+    int okc, okd;
+    q32_t yc = eval_rpn(prog, c, &okc, NULL, 0);
+    q32_t yd = eval_rpn(prog, d, &okd, NULL, 0);
+    for (int it = 0; it < 15 && okc && okd; it++) {
+        int pick_left = find_max ? (yc > yd) : (yc < yd);
+        if (pick_left) {
+            b = d; d = c; yd = yc;
+            c = b - q32_mul(b - a, INV_PHI);
+            yc = eval_rpn(prog, c, &okc, NULL, 0);
+        } else {
+            a = c; c = d; yc = yd;
+            d = a + q32_mul(b - a, INV_PHI);
+            yd = eval_rpn(prog, d, &okd, NULL, 0);
+        }
+    }
+    q32_t xm = (a >> 1) + (b >> 1);
+    int okm, okp, okn;
+    q32_t ym = eval_rpn(prog, xm, &okm, NULL, 0);
+    // Final 3-point parabolic vertex polish (`dh = 2^-11`) for exact 6-decimal extrema
+    q32_t dh = (1LL << 21);
+    q32_t yp = eval_rpn(prog, xm + dh, &okp, NULL, 0);
+    q32_t yn = eval_rpn(prog, xm - dh, &okn, NULL, 0);
+    if (okm && okp && okn) {
+        q32_t denom = 2 * ((yp - 2 * ym) + yn);
+        if (denom > 1024 || denom < -1024) {
+            int save = q_err;
+            q_err = 0;
+            q32_t delta = q32_mul(dh, q32_div(yn - yp, denom));
+            if (!q_err && delta > -dh && delta < dh) {
+                xm += delta;
+                ym = eval_rpn(prog, xm, &okm, NULL, 0);
+            }
+            q_err = save;
+        }
+    }
+    *out_y = ym;
+    return xm;
+}
+
+// --- Graphing Calculator & Table Mode (`y = f(x)`) ---
+static int run_graph_mode(const char *expr_s, const RpnProg *prog, q32_t xmin, q32_t xmax, int table_only) {
+    if (xmax <= xmin) xmax = xmin + (10LL << 32);
+
+    // 48 subintervals -> 49 grid points:
+    //   48 = 2 * 24 (exact 25 plot columns at i = 2*col)
+    //   48 = 6 * 8  (exact 7 table points at i = 8*k)
+    //   48 is even  (exact 48-panel Simpson's rule definite integral!)
+    static q32_t gx[49], gy[49];
+    static uint8_t gok[49];
+    q32_t span = xmax - xmin;
+    q32_t h = q32_div(span, 48 * Q32_ONE);
+
+    q32_t ymin = Q32_MAX, ymax = Q32_MIN;
+    int valid_cnt = 0, all_valid = 1;
+    for (int i = 0; i <= 48; i++) {
+        gx[i] = (i == 48) ? xmax : (xmin + i * h);
+        int ok = 0;
+        gy[i] = eval_rpn(prog, gx[i], &ok, NULL, 0);
+        gok[i] = (uint8_t)ok;
+        if (ok) {
+            if (gy[i] < ymin) ymin = gy[i];
+            if (gy[i] > ymax) ymax = gy[i];
+            valid_cnt++;
+        } else {
+            all_valid = 0;
+        }
+    }
+
+    char b1[40], b2[40], b3[40];
+    fmt_q32(xmin, b1, sizeof b1, 4);
+    fmt_q32(xmax, b2, sizeof b2, 4);
+    puts_raw("function: f(x) = ");
+    puts_raw(expr_s);
+    puts_raw("  on [");
+    puts_raw(b1);
+    puts_raw(", ");
+    puts_raw(b2);
+    puts_raw("]\n");
+
+    if (valid_cnt == 0) {
+        puts_raw("error: function undefined on entire interval\n");
+        return 0;
+    }
+
+    // 1. Roots on [xmin, xmax]
+    q32_t roots[8];
+    int nroots = 0;
+    q32_t pa = 0, pb = 0, pc = 0;
+    int deg = detect_poly2(prog, &pa, &pb, &pc);
+    if (deg == 1) {
+        q32_t r = q32_div(-pc, pb);
+        if (r >= xmin - 1024 && r <= xmax + 1024) add_unique_root(roots, &nroots, 8, r);
+    } else if (deg == 2) {
+        q32_t disc = q32_sub(q32_mul(pb, pb), 4 * q32_mul(pa, pc));
+        if (disc >= -128) {
+            q32_t sd = disc > 0 ? q32_sqrt(disc) : 0;
+            q32_t r1 = q32_div(-pb - sd, 2 * pa);
+            q32_t r2 = q32_div(-pb + sd, 2 * pa);
+            if (r1 >= xmin - 1024 && r1 <= xmax + 1024) add_unique_root(roots, &nroots, 8, r1);
+            if (r2 >= xmin - 1024 && r2 <= xmax + 1024) add_unique_root(roots, &nroots, 8, r2);
+        }
+    } else {
+        for (int i = 0; i <= 48; i++) {
+            if (gok[i] && gy[i] > -512 && gy[i] < 512) {
+                add_unique_root(roots, &nroots, 8, gx[i]);
+            } else if (i < 48 && gok[i] && gok[i + 1] &&
+                       ((gy[i] < 0 && gy[i + 1] > 0) || (gy[i] > 0 && gy[i + 1] < 0))) {
+                q32_t r = bisect_diff(prog, NULL, 0, gx[i], gx[i + 1], gy[i]);
+                int okr;
+                q32_t yr = eval_rpn(prog, r, &okr, NULL, 0);
+                q32_t ay = yr < 0 ? -yr : yr;
+                if (okr && ay < (Q32_ONE >> 10))
+                    add_unique_root(roots, &nroots, 8, r);
+            }
+        }
+    }
+    puts_raw("roots: ");
+    if (nroots == 0) {
+        puts_raw("none on interval\n");
+    } else {
+        for (int i = 0; i < nroots; i++) {
+            if (i > 0) puts_raw(", ");
+            puts_raw("x = ");
+            fmt_q32_rich(roots[i], b1, sizeof b1);
+            puts_raw(b1);
+        }
+        rv_putchar('\n');
+    }
+
+    // 2. Vertex / Local Extrema
+    if (deg == 2) {
+        q32_t vx = q32_div(-pb, 2 * pa);
+        int okv;
+        q32_t vy = eval_rpn(prog, vx, &okv, NULL, 0);
+        if (okv && vy < ymin && vx >= xmin && vx <= xmax) ymin = vy;
+        if (okv && vy > ymax && vx >= xmin && vx <= xmax) ymax = vy;
+        fmt_q32(vx, b1, sizeof b1, 6);
+        fmt_q32(vy, b2, sizeof b2, 6);
+        puts_raw(pa > 0 ? "vertex (min): (" : "vertex (max): (");
+        puts_raw(b1);
+        puts_raw(", ");
+        puts_raw(b2);
+        puts_raw(")\n");
+    } else {
+        int printed_ext = 0;
+        for (int i = 1; i < 48 && printed_ext < 3; i++) {
+            if (!gok[i - 1] || !gok[i] || !gok[i + 1]) continue;
+            int is_max = (gy[i] > gy[i - 1] && gy[i] >= gy[i + 1] && (gy[i] > gy[i - 1] || gy[i] > gy[i + 1]));
+            int is_min = (gy[i] < gy[i - 1] && gy[i] <= gy[i + 1] && (gy[i] < gy[i - 1] || gy[i] < gy[i + 1]));
+            if (is_max || is_min) {
+                q32_t ey = 0;
+                q32_t ex = polish_extremum(prog, gx[i - 1], gx[i + 1], is_max, &ey);
+                if (ey < ymin) ymin = ey;
+                if (ey > ymax) ymax = ey;
+                if (printed_ext > 0) puts_raw(" | ");
+                puts_raw(is_max ? "local max: (" : "local min: (");
+                fmt_q32(ex, b1, sizeof b1, 6);
+                fmt_q32(ey, b2, sizeof b2, 6);
+                puts_raw(b1);
+                puts_raw(", ");
+                puts_raw(b2);
+                rv_putchar(')');
+                printed_ext++;
+            }
+        }
+        if (printed_ext > 0) rv_putchar('\n');
+    }
+
+    // 3. y-intercept & 96-panel Simpson's definite integral
+    int has_yint = 0;
+    if (xmin <= 0 && xmax >= 0) {
+        int ok0;
+        q32_t y0 = eval_rpn(prog, 0, &ok0, NULL, 0);
+        if (ok0) {
+            fmt_q32(y0, b1, sizeof b1, 6);
+            puts_raw("y-intercept: (0, ");
+            puts_raw(b1);
+            rv_putchar(')');
+            has_yint = 1;
+        }
+    }
+    if (all_valid) {
+        q_err = 0;
+        q32_t sum = q32_add(gy[0], gy[48]);
+        for (int i = 1; i < 48 && !q_err; i++) {
+            q32_t term = (i & 1) ? q32_mul(4 * Q32_ONE, gy[i]) : q32_mul(2 * Q32_ONE, gy[i]);
+            sum = q32_add(sum, term);
+        }
+        q32_t integ = q32_mul(q32_div(h, 3 * Q32_ONE), sum);
+        if (!q_err) {
+            if (has_yint) puts_raw(" | ");
+            puts_raw("integral: ");
+            fmt_q32(integ, b1, sizeof b1, 6);
+            puts_raw(b1);
+            has_yint = 1;
+        }
+    }
+    if (has_yint) rv_putchar('\n');
+
+    // 4. Coordinate Table (7 clean points; with derivative f'(x) when in table mode)
+    if (table_only) {
+        puts_raw("x | f(x) | f'(x)\n");
+        q32_t dh = (1LL << 20);  // 2^-12 (~2.44e-4) central difference step
+        for (int k = 0; k <= 6; k++) {
+            int idx = 8 * k;
+            fmt_q32(gx[idx], b1, sizeof b1, 4);
+            puts_raw(b1);
+            puts_raw(" | ");
+            if (!gok[idx]) {
+                puts_raw("undef | undef\n");
+            } else {
+                fmt_q32(gy[idx], b2, sizeof b2, 6);
+                puts_raw(b2);
+                puts_raw(" | ");
+                int okp, okm;
+                q32_t yp = eval_rpn(prog, gx[idx] + dh, &okp, NULL, 0);
+                q32_t ym = eval_rpn(prog, gx[idx] - dh, &okm, NULL, 0);
+                if (okp && okm) {
+                    q32_t deriv = (yp - ym) << 11;  // / (2 * 2^-12) = * 2^11
+                    fmt_q32(deriv, b3, sizeof b3, 6);
+                    puts_raw(b3);
+                } else {
+                    puts_raw("undef");
+                }
+                rv_putchar('\n');
+            }
+        }
+        return 0;
+    }
+
+    puts_raw("table: ");
+    for (int k = 0; k <= 6; k++) {
+        int idx = 8 * k;
+        if (k > 0) puts_raw(", ");
+        rv_putchar('(');
+        fmt_q32(gx[idx], b1, sizeof b1, 4);
+        puts_raw(b1);
+        puts_raw(", ");
+        if (gok[idx]) {
+            fmt_q32(gy[idx], b2, sizeof b2, 4);
+            puts_raw(b2);
+        } else {
+            puts_raw("undef");
+        }
+        rv_putchar(')');
+    }
+    rv_putchar('\n');
+
+    // 5. 9x25 ASCII Coordinate Plot
+    q32_t pmin = ymin, pmax = ymax;
+    // Clamp extreme asymptote spikes so e.g. 1/x or tan(x) remains readable
+    if (pmax - pmin > (200LL << 32) && !all_valid) {
+        pmin = -(20LL << 32);
+        pmax = 20LL << 32;
+    }
+    if (pmax - pmin < (1LL << 28)) {
+        pmin -= Q32_ONE;
+        pmax += Q32_ONE;
+    }
+    q32_t yspan = pmax - pmin;
+
+    char grid[9][25];
+    for (int r = 0; r < 9; r++)
+        for (int c = 0; c < 25; c++) grid[r][c] = ' ';
+
+    int rx = -1, cy = -1;
+    q32_t inv_yspan8 = q32_div(8 * Q32_ONE, yspan);
+    if (pmin <= 0 && pmax >= 0) {
+        rx = (int)((q32_mul(pmax, inv_yspan8) + (1LL << 31)) >> 32);
+        if (rx >= 0 && rx < 9)
+            for (int c = 0; c < 25; c++) grid[rx][c] = '-';
+    }
+    if (xmin <= 0 && xmax >= 0) {
+        cy = (int)((q32_div(-xmin, span) * 24 + (1LL << 31)) >> 32);
+        if (cy >= 0 && cy < 25)
+            for (int r = 0; r < 9; r++) grid[r][cy] = '|';
+    }
+    if (rx >= 0 && rx < 9 && cy >= 0 && cy < 25) grid[rx][cy] = '+';
+
+    for (int c = 0; c < 25; c++) {
+        int idx = 2 * c;
+        if (!gok[idx] || gy[idx] < pmin || gy[idx] > pmax) continue;
+        int r = (int)((q32_mul(pmax - gy[idx], inv_yspan8) + (1LL << 31)) >> 32);
+        if (r >= 0 && r < 9) grid[r][c] = '*';
+    }
+
+    for (int r = 0; r < 9; r++) {
+        if ((r & 1) == 0 || r == rx) {
+            q32_t ytick = (r == rx) ? 0 : (pmax - (yspan * r) / 8);
+            fmt_q32(ytick, b1, sizeof b1, 2);
+            int l = slen(b1);
+            putc_rep(' ', l < 7 ? 7 - l : 0);
+            puts_raw(b1);
+        } else {
+            putc_rep(' ', 7);
+        }
+        puts_raw(" |");
+        int endc = 25;
+        while (endc > 0 && grid[r][endc - 1] == ' ') endc--;
+        for (int c = 0; c < endc; c++) rv_putchar(grid[r][c]);
+        rv_putchar('\n');
+    }
+    // Bottom x-axis tick line
+    fmt_q32(xmin, b1, sizeof b1, 2);
+    fmt_q32((xmin >> 1) + (xmax >> 1), b2, sizeof b2, 2);
+    fmt_q32(xmax, b3, sizeof b3, 2);
+    puts_raw("        x=");
+    puts_raw(b1);
+    int used_w = 2 + slen(b1);
+    int mid_target = 11 - (2 + slen(b2)) / 2;
+    if (mid_target <= used_w) mid_target = used_w + 1;
+    putc_rep(' ', mid_target - used_w);
+    puts_raw("x=");
+    puts_raw(b2);
+    used_w = mid_target + 2 + slen(b2);
+    int right_target = 25 - (2 + slen(b3));
+    if (right_target <= used_w) right_target = used_w + 1;
+    putc_rep(' ', right_target - used_w);
+    puts_raw("x=");
+    puts_raw(b3);
+    rv_putchar('\n');
+    return 0;
+}
+
+// ============================================================================
+// Tool-Call Gathering, UTF-8 Normalization & Mode Dispatcher
+// ============================================================================
+
+static char raw_call[1024];
+static char norm_call[1024];
+static char fn_buf[32];
+static char expr_buf[256];
+static char xmin_buf[64];
+static char xmax_buf[64];
+static int has_xmin, has_xmax;
+
+static void normalize_utf8(const char *src, char *dst, int cap) {
+    int o = 0;
+    for (int i = 0; src[i] && o < cap - 4; ) {
+        unsigned char c0 = (unsigned char)src[i];
+        unsigned char c1 = (unsigned char)src[i + 1];
+        unsigned char c2 = c1 ? (unsigned char)src[i + 2] : 0;
+        if (c0 == 0xC3 && c1 == 0x97) { dst[o++] = '*'; i += 2; }                      // ×
+        else if (c0 == 0xC3 && c1 == 0xB7) { dst[o++] = '/'; i += 2; }                 // ÷
+        else if (c0 == 0xC2 && c1 == 0xB2) { dst[o++] = '^'; dst[o++] = '2'; i += 2; } // ²
+        else if (c0 == 0xC2 && c1 == 0xB3) { dst[o++] = '^'; dst[o++] = '3'; i += 2; } // ³
+        else if (c0 == 0xCF && c1 == 0x80) { dst[o++] = 'p'; dst[o++] = 'i'; i += 2; } // π
+        else if (c0 == 0xE2 && c1 == 0x88 && c2 == 0x92) { dst[o++] = '-'; i += 3; }   // −
+        else if (c0 == 0xE2 && c1 == 0x80 && c2 == 0x93) { dst[o++] = '-'; i += 3; }   // –
+        else if (c0 == '&' && starts_with_ci(src + i, "&lt;")) { dst[o++] = '<'; i += 4; }
+        else if (c0 == '&' && starts_with_ci(src + i, "&gt;")) { dst[o++] = '>'; i += 4; }
+        else { dst[o++] = src[i++]; }
+    }
+    dst[o] = 0;
+}
+
+static void parse_call_payload(void) {
+    normalize_utf8(raw_call, norm_call, sizeof norm_call);
+    fn_buf[0] = 0;
+    expr_buf[0] = 0;
+    xmin_buf[0] = 0;
+    xmax_buf[0] = 0;
+    has_xmin = 0;
+    has_xmax = 0;
+
+    int saw_param = 0;
+    for (int i = 0; norm_call[i]; i++) {
+        if (starts_with_ci(norm_call + i, "<function=")) {
+            int s = i + 10, e = s;
+            while (norm_call[e] && norm_call[e] != '>' && !is_space(norm_call[e])) e++;
+            copy_trim(fn_buf, sizeof fn_buf, norm_call + s, e - s);
+        } else if (starts_with_ci(norm_call + i, "<parameter=")) {
+            saw_param = 1;
+            int ks = i + 11, ke = ks;
+            while (norm_call[ke] && norm_call[ke] != '>') ke++;
+            if (!norm_call[ke]) break;
+            char key[24];
+            copy_trim(key, sizeof key, norm_call + ks, ke - ks);
+            for (int k = 0; key[k]; k++) if (key[k] >= 'A' && key[k] <= 'Z') key[k] = (char)(key[k] + 32);
+            int vs = ke + 1, ve = vs;
+            while (norm_call[ve] && norm_call[ve] != '<') ve++;
+            if (starts_with_ci(key, "expr") || starts_with_ci(key, "eq") ||
+                starts_with_ci(key, "func") || starts_with_ci(key, "cmd") || streq(key, "f")) {
+                copy_trim(expr_buf, sizeof expr_buf, norm_call + vs, ve - vs);
+            } else if (streq(key, "xmin") || streq(key, "min") || streq(key, "a") || streq(key, "from")) {
+                copy_trim(xmin_buf, sizeof xmin_buf, norm_call + vs, ve - vs);
+                has_xmin = xmin_buf[0] != 0;
+            } else if (streq(key, "xmax") || streq(key, "max") || streq(key, "b") || streq(key, "to")) {
+                copy_trim(xmax_buf, sizeof xmax_buf, norm_call + vs, ve - vs);
+                has_xmax = xmax_buf[0] != 0;
+            } else if (streq(key, "mode")) {
+                copy_trim(fn_buf, sizeof fn_buf, norm_call + vs, ve - vs);
+            } else if (!expr_buf[0]) {
+                copy_trim(expr_buf, sizeof expr_buf, norm_call + vs, ve - vs);
+            }
+            i = ve - 1;
+        }
+    }
+
+    if (!saw_param) {
+        // Fallback: JSON {"expression": "..."} or plain text expression
+        int found_json = 0;
+        for (int i = 0; norm_call[i]; i++) {
+            if (starts_with_ci(norm_call + i, "\"expression\"") || starts_with_ci(norm_call + i, "\"equation\"")) {
+                int j = i + 12;
+                while (norm_call[j] && norm_call[j] != ':') j++;
+                if (norm_call[j] == ':') j++;
+                while (is_space(norm_call[j])) j++;
+                if (norm_call[j] == '"') {
+                    int vs = ++j;
+                    while (norm_call[j] && norm_call[j] != '"') j++;
+                    copy_trim(expr_buf, sizeof expr_buf, norm_call + vs, j - vs);
+                    found_json = 1;
+                    break;
+                }
+            }
+        }
+        if (!found_json) copy_trim(expr_buf, sizeof expr_buf, norm_call, slen(norm_call));
+    }
+
+    // Strip optional inline domain suffix: " on [a, b]" or " from x = a to b" or " from a to b"
+    int n = slen(expr_buf);
+    for (int i = 0; i < n; i++) {
+        if (!has_xmin && (starts_with_ci(expr_buf + i, " on [") || starts_with_ci(expr_buf + i, " in ["))) {
+            int lb = i + 5, cm = lb;
+            while (expr_buf[cm] && expr_buf[cm] != ',' && expr_buf[cm] != ']') cm++;
+            if (expr_buf[cm] == ',') {
+                int rb = cm + 1;
+                while (expr_buf[rb] && expr_buf[rb] != ']') rb++;
+                if (expr_buf[rb] == ']') {
+                    copy_trim(xmin_buf, sizeof xmin_buf, expr_buf + lb, cm - lb);
+                    copy_trim(xmax_buf, sizeof xmax_buf, expr_buf + cm + 1, rb - cm - 1);
+                    has_xmin = has_xmax = 1;
+                    expr_buf[i] = 0;
+                    copy_trim(expr_buf, sizeof expr_buf, expr_buf, i);
+                    break;
+                }
+            }
+        } else if (!has_xmin && starts_with_ci(expr_buf + i, " from ")) {
+            int p = i + 6;
+            while (is_space(expr_buf[p])) p++;
+            if ((expr_buf[p] == 'x' || expr_buf[p] == 'X') && (expr_buf[p + 1] == '=' || expr_buf[p + 1] == ' ')) {
+                p++;
+                while (is_space(expr_buf[p]) || expr_buf[p] == '=') p++;
+            }
+            int to_pos = -1;
+            for (int k = p; expr_buf[k]; k++) {
+                if (starts_with_ci(expr_buf + k, " to ")) { to_pos = k; break; }
+            }
+            if (to_pos > p) {
+                copy_trim(xmin_buf, sizeof xmin_buf, expr_buf + p, to_pos - p);
+                copy_trim(xmax_buf, sizeof xmax_buf, expr_buf + to_pos + 4, slen(expr_buf) - (to_pos + 4));
+                has_xmin = has_xmax = 1;
+                expr_buf[i] = 0;
+                copy_trim(expr_buf, sizeof expr_buf, expr_buf, i);
+                break;
+            }
+        }
+    }
+
+    // Optional command prefix ("graph ...", "plot ...", "solve ...", "table ...")
+    const char *prefixes[4] = {"graph ", "plot ", "solve ", "table "};
+    for (int k = 0; k < 4; k++) {
+        if (starts_with_ci(expr_buf, prefixes[k])) {
+            int plen = slen(prefixes[k]);
+            if (!fn_buf[0] || streq(fn_buf, "graphcalc"))
+                copy_trim(fn_buf, sizeof fn_buf, prefixes[k], plen - 1);
+            copy_trim(expr_buf, sizeof expr_buf, expr_buf + plen, slen(expr_buf) - plen);
+            break;
+        }
+    }
+
+    // Strip leading "y =" or "f(x) =" when there is no second '='
+    int eq_cnt = 0, first_eq = -1;
+    for (int i = 0; expr_buf[i]; i++) {
+        if (expr_buf[i] == '=') {
+            if (eq_cnt == 0) first_eq = i;
+            eq_cnt++;
+        }
+    }
+    if (eq_cnt == 1 && first_eq > 0) {
+        char lhs_tmp[32];
+        copy_trim(lhs_tmp, sizeof lhs_tmp, expr_buf, first_eq);
+        if (streq(lhs_tmp, "y") || streq(lhs_tmp, "Y") ||
+            starts_with_ci(lhs_tmp, "f(x)") || starts_with_ci(lhs_tmp, "g(x)")) {
+            copy_trim(expr_buf, sizeof expr_buf, expr_buf + first_eq + 1, slen(expr_buf) - first_eq - 1);
+        }
+    }
+}
+
+static int has_alpha_outside_gcd(const char *s) {
+    for (int i = 0; s[i]; ) {
+        if (starts_with_ci(s + i, "gcd(")) { i += 4; continue; }
+        if (is_alpha(s[i])) return 1;
+        i++;
+    }
+    return 0;
+}
+
+static void dispatch_call(void) {
+    parse_call_payload();
+    if (!expr_buf[0]) {
+        puts_raw("error: empty expression\n");
+        return;
+    }
+
+    q32_t xmin = -(5LL << 32), xmax = 5LL << 32;
+    int got_bounds = 0;
+    if (has_xmin && parse_q32_num(xmin_buf, NULL, &xmin)) got_bounds = 1;
+    if (has_xmax && parse_q32_num(xmax_buf, NULL, &xmax)) got_bounds = 1;
+
+    // 1. Check for Equation (`LHS = RHS`)
+    int eq_pos = -1;
+    for (int i = 0; expr_buf[i]; i++) {
+        if (expr_buf[i] == '=') { eq_pos = i; break; }
+    }
+    if (eq_pos > 0 && expr_buf[eq_pos + 1]) {
+        char lhs_s[160], rhs_s[160];
+        copy_trim(lhs_s, sizeof lhs_s, expr_buf, eq_pos);
+        copy_trim(rhs_s, sizeof rhs_s, expr_buf + eq_pos + 1, slen(expr_buf) - eq_pos - 1);
+        if (run_solver_mode(expr_buf, lhs_s, rhs_s, got_bounds, xmin, xmax) == 0) return;
+        puts_raw("error: invalid equation syntax\n");
+        return;
+    }
+
+    // 2. Pure Bignum / Exact Rational Arithmetic (no variable x, no trig/log/sqrt)
+    int is_explicit_graph_fn = streq_ci(fn_buf, "graph") || streq_ci(fn_buf, "plot") || streq_ci(fn_buf, "table");
+    if (!has_alpha_outside_gcd(expr_buf) && !got_bounds && !is_explicit_graph_fn) {
+        if (run_bignum_engine(expr_buf) == 0) return;
+    }
+
+    // 3. Compile RPN for Scientific Numeric Eval or Function Graphing / Table
+    RpnProg prog;
+    if (!compile_rpn(expr_buf, &prog)) {
+        puts_raw("error: syntax error in expression\n");
+        return;
+    }
+
+    int force_graph = got_bounds || is_explicit_graph_fn;
+    if (!prog.uses_x && !force_graph) {
+        char step_log[512];
+        int ok = 0;
+        q32_t val = eval_rpn(&prog, 0, &ok, step_log, sizeof step_log);
+        if (!ok) {
+            puts_raw("error: math domain or overflow error\n");
+            return;
+        }
+        puts_raw("expression: ");
+        puts_raw(expr_buf);
+        rv_putchar('\n');
+        if (step_log[0]) puts_raw(step_log);
+        char vbuf[48];
+        fmt_q32_rich(val, vbuf, sizeof vbuf);
+        puts_raw("value: ");
+        puts_raw(vbuf);
+        rv_putchar('\n');
+        return;
+    }
+
+    int table_only = starts_with_ci(fn_buf, "table");
+    run_graph_mode(expr_buf, &prog, xmin, xmax, table_only);
+}
+
+#ifndef QEMU
+// P3 Bridge memory & CarbonText extended special tokens (256..264)
+#define TEXT_BUF ((const volatile unsigned char *)0x8000)
+#define CAP_ROWS 80
+
+enum {
+    TOK_TOOL_RESPONSE = 256,
+    TOK_TOOL_RESPONSE_END = 257,
+    TOK_THINK = 258,
+    TOK_THINK_END = 259,
+    TOK_IM_END = 260,
+    TOK_IM_START = 261,
+    TOK_USER = 262,
+    TOK_ASSISTANT = 263,
+    TOK_NL2 = 264
+};
+
+static void put_tok(int c) { rv_ecall2(1, c, 0, 0); }
+
+static int gather_bridge_text(void) {
+    int n = 0;
+    for (int i = 1; i <= CAP_ROWS; i++) {
+        const volatile unsigned char *r = TEXT_BUF + 16 * i;
+        if (!r[0]) break;
+        for (int k = 0; k < 16 && r[k]; k++) {
+            if (n < (int)sizeof(raw_call) - 1) raw_call[n++] = (char)r[k];
+        }
+    }
+    raw_call[n] = 0;
+    return n;
+}
+
+int main(void) {
+    for (;;) {
+        // Park until Qwen emits </tool_call> (GO resumes right after this exit ecall)
+        rv_ecall2(93, 0, 0, 0);
+        int n = gather_bridge_text();
+
+        // Native Qwen3.5 ChatML tool-response turn header:
+        // <|im_end|>\n<|im_start|>user\n<tool_response>\n
+        put_tok(TOK_IM_END);
+        put_tok('\n');
+        put_tok(TOK_IM_START);
+        put_tok(TOK_USER);
+        put_tok('\n');
+        put_tok(TOK_TOOL_RESPONSE);
+        put_tok('\n');
+
+        if (n <= 0) {
+            puts_raw("error: empty tool call\n");
+        } else {
+            dispatch_call();
+        }
+
+        // Native Qwen3.5 ChatML assistant continuation header:
+        // </tool_response><|im_end|>\n<|im_start|>assistant\n<think>\n\n</think>\n\n##[HALT -> ' ']
+        put_tok(TOK_TOOL_RESPONSE_END);
+        put_tok(TOK_IM_END);
+        put_tok('\n');
+        put_tok(TOK_IM_START);
+        put_tok(TOK_ASSISTANT);
+        put_tok('\n');
+        put_tok(TOK_THINK);
+        put_tok(TOK_NL2);
+        put_tok(TOK_THINK_END);
+        put_tok(TOK_NL2);
+        put_tok('#');
+        put_tok('#');
+    }
+}
+#else
+int main(void) {
+    int pos = 0;
+    while (pos < (int)sizeof(raw_call) - 1) {
+        long got = rv_ecall2(63, 0, (long)(raw_call + pos), (long)(sizeof(raw_call) - 1 - pos));
+        if (got <= 0) break;
+        pos += (int)got;
+    }
+    raw_call[pos] = 0;
+    dispatch_call();
+    return 0;
+}
+#endif

firmware/tables.py

@@ -0,0 +1,61 @@
+"""Generate DROM fixed-point math lookup tables (`graphcalc_tables.h`) and bignum print sleds (`sled.S`)."""
+import math
+import sys
+from pathlib import Path
+
+
+def write_tables(hdr_path: Path) -> None:
+    one32 = 1 << 32
+    lines = [
+        "// Auto-generated Q32.32 constants and CORDIC / log tables in DROM (.rodata).",
+        "#pragma once",
+        "#include <stdint.h>",
+        "",
+        f"#define Q32_ONE ({one32}LL)",
+        f"#define Q32_PI ({round(math.pi * one32)}LL)",
+        f"#define Q32_TWO_PI ({round(2.0 * math.pi * one32)}LL)",
+        f"#define Q32_INV_TWO_PI ({round((1.0 / (2.0 * math.pi)) * one32)}LL)",
+        f"#define Q32_HALF_PI ({round(0.5 * math.pi * one32)}LL)",
+        f"#define Q32_E ({round(math.e * one32)}LL)",
+        f"#define Q32_LN2 ({round(math.log(2.0) * one32)}LL)",
+        f"#define Q32_INV_LN2 ({round((1.0 / math.log(2.0)) * one32)}LL)",
+        f"#define Q32_LN10 ({round(math.log(10.0) * one32)}LL)",
+        "",
+    ]
+    # CORDIC gain K = prod_{i=0}^{29} 1 / sqrt(1 + 2^{-2i})
+    k_gain = 1.0
+    atan_vals = []
+    for i in range(30):
+        k_gain /= math.hypot(1.0, 2.0 ** (-i))
+        atan_vals.append(round(math.atan(2.0 ** (-i)) * one32))
+    lines.append(f"#define CORDIC_K ({round(k_gain * one32)}LL)")
+    lines.append("static const int64_t CORDIC_ATAN[30] = {")
+    for i in range(0, 30, 5):
+        chunk = ", ".join(f"{v}LL" for v in atan_vals[i : i + 5])
+        lines.append(f"    {chunk},")
+    lines.append("};\n")
+
+    # Shifted log table: ln(1 + 2^{-i}) for i = 1..30 in Q32.32
+    ln1p_vals = [0] + [round(math.log1p(2.0 ** (-i)) * one32) for i in range(1, 31)]
+    lines.append("static const int64_t LN1P_POW2[31] = {")
+    for i in range(0, 31, 5):
+        chunk = ", ".join(f"{v}LL" for v in ln1p_vals[i : i + 5])
+        lines.append(f"    {chunk},")
+    lines.append("};\n")
+
+    hdr_path.write_text("\n".join(lines), encoding="utf-8")
+
+
+def write_sled(sled_path: Path) -> None:
+    out = ["    .section .text", "    .globl bn_sleds"]
+    for r in range(8):
+        out += [f"bn_sled{r}:"] + [f"    .insn i 0x2B, 0, x{r}, x0, {k}" for k in range(127, -1, -1)]
+        out += ["    ret"]
+    out += ["    .section .rodata", "    .align 2", "bn_sleds:"]
+    out += [f"    .word bn_sled{r}" for r in range(8)]
+    sled_path.write_text("\n".join(out) + "\n", encoding="utf-8")
+
+
+if __name__ == "__main__":
+    write_tables(Path(sys.argv[1]))
+    write_sled(Path(sys.argv[2]))

generation_config.json

@@ -0,0 +1,13 @@
+{
+  "eos_token_id": [
+    248046,
+    248044
+  ],
+  "pad_token_id": 248044,
+  "bad_words_ids": [
+    [
+      248045
+    ]
+  ],
+  "do_sample": false
+}

model.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c7dacb327bea9361e115a0378d19ce9e030e8aeed3561361a461812ba1cceee7
+size 17971408308

runner.py

@@ -0,0 +1,886 @@
+"""Standalone in-weights runner for `Qwen3.5-9B-Math-GraphCalc` (and `0.8B`).
+
+Requires `qwenputer` (`https://github.com/divagr18/qwenputer`) on `PYTHONPATH` or pointed to by
+`QWENPUTER_ROOT` (defaults to `./qwenputer` or `../qwenputer`):
+
+    git clone https://github.com/divagr18/qwenputer
+    QWENPUTER_ROOT=./qwenputer python runner.py --ask "Calculate 37429 * 8613 + 194820 and explain your steps."
+"""
+
+from __future__ import annotations
+
+import argparse
+import copy
+import gc
+import json
+import os
+import re
+import sys
+import time
+import zlib
+from pathlib import Path
+
+import numpy as np
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from safetensors import safe_open
+from tokenizers import Tokenizer
+from transformers import AutoConfig, AutoTokenizer, DynamicCache, Qwen3_5ForCausalLM
+from transformers.models.qwen3_5 import modeling_qwen3_5 as q35_mod
+
+MODEL_DIR = Path(__file__).resolve().parent
+
+
+def _locate_qwenputer_rv() -> Path:
+    candidates = []
+    if os.environ.get("QWENPUTER_ROOT"):
+        candidates.append(Path(os.environ["QWENPUTER_ROOT"]))
+    candidates.extend([
+        Path.cwd() / "qwenputer",
+        Path.cwd().parent / "qwenputer",
+        MODEL_DIR / "qwenputer",
+        MODEL_DIR.parent / "qwenputer",
+        MODEL_DIR.parent.parent / "qwenputer",
+        MODEL_DIR.parent.parent.parent / "qwenputer",
+    ])
+    for root in candidates:
+        rv = root.resolve() / "experimental" / "riscv"
+        if (rv / "chipformer").is_dir():
+            return rv
+    raise RuntimeError(
+        "Could not locate `chipformer` from `qwenputer` (`experimental/riscv/chipformer`). "
+        "Clone https://github.com/divagr18/qwenputer and set QWENPUTER_ROOT=/path/to/qwenputer."
+    )
+
+
+try:
+    import chipformer  # noqa: F401
+except ImportError:
+    sys.path.insert(0, str(_locate_qwenputer_rv()))
+
+from chipformer.q35 import fast as F_chip  # noqa: E402
+from chipformer.q35 import ir  # noqa: E402
+from chipformer.q35.ir import Target  # noqa: E402
+from chipformer.rv import bridge as BR  # noqa: E402
+from chipformer.rv import core, elf, hf, ref  # noqa: E402
+from chipformer.rv import spec as S  # noqa: E402
+
+CARBON_SPECIALS = [
+    "<tool_response>",   # 256
+    "</tool_response>",  # 257
+    "<think>",           # 258
+    "</think>",          # 259
+    "<|im_end|>",        # 260
+    "<|im_start|>",      # 261
+    "user",              # 262
+    "assistant",         # 263
+    "\n\n",              # 264
+]
+
+GRAPHCALC_TOOL = {
+    "type": "function",
+    "function": {
+        "name": "graphcalc",
+        "description": (
+            "Exact in-weights graphing & math calculator (62-digit integers/rationals, scientific "
+            "functions, equation solver, and coordinate plotter). Pass an arithmetic expression, "
+            "an equation in x (LHS = RHS), or a function f(x); optionally pass xmin and xmax to "
+            "plot y = f(x) and compute roots, vertex/extrema, definite integral, and value table."
+        ),
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "expression": {
+                    "type": "string",
+                    "description": "Math expression, equation (LHS = RHS), or function of x (e.g. 'x^2 - 4*x + 3')",
+                },
+                "xmin": {
+                    "type": "number",
+                    "description": "Optional domain/plot minimum x (default -5 for plots, -20 for nonlinear solve)",
+                },
+                "xmax": {
+                    "type": "number",
+                    "description": "Optional domain/plot maximum x (default 5 for plots, 20 for nonlinear solve)",
+                },
+            },
+            "required": ["expression"],
+        },
+    },
+}
+
+GRAPHCALC_SYSTEM_PROMPT = (
+    "You are a clear, encouraging step-by-step math tutor equipped with an embedded graphing "
+    "calculator (`graphcalc`). Always call `graphcalc` first to compute exact arithmetic, roots, "
+    "coordinate tables, or function plots, then explain every step clearly so a student can learn."
+)
+
+_orig_chunk_gdn = q35_mod.torch_chunk_gated_delta_rule
+_orig_rec_gdn = q35_mod.torch_recurrent_gated_delta_rule
+
+
+def _fp32_chunk_gdn(*args, **kwargs):
+    with torch.autocast("cuda", enabled=False):
+        return _orig_chunk_gdn(*args, **kwargs)
+
+
+def _fp32_rec_gdn(*args, **kwargs):
+    with torch.autocast("cuda", enabled=False):
+        return _orig_rec_gdn(*args, **kwargs)
+
+
+q35_mod.torch_chunk_gated_delta_rule = _fp32_chunk_gdn
+q35_mod.torch_recurrent_gated_delta_rule = _fp32_rec_gdn
+F_chip.exact_matmuls()
+
+
+class CarbonText(BR.Text):
+    """Qwen3.5 bridge vocabulary with native ChatML special tokens (256..264) and space HALT echo."""
+
+    def __init__(self, tokenizer_path: str | Path) -> None:
+        p = Path(tokenizer_path)
+        tj = p if p.is_file() else (p / "tokenizer.json")
+        self.tok = Tokenizer.from_file(str(tj))
+        vocab = self.tok.get_vocab(with_added_tokens=True)
+        base_vocab = {s: i for s, i in vocab.items() if not s.startswith("<|chip_")}
+        self.n = max(base_vocab.values()) + 1
+        dec = {c: b for b, c in BR.bytes_to_unicode().items()}
+        added = (
+            {a.content for a in self.tok.get_added_tokens_decoder().values()}
+            if hasattr(self.tok, "get_added_tokens_decoder")
+            else set()
+        )
+        self.bytes = [b""] * self.n
+        for s, i in base_vocab.items():
+            if s in added or not all(ch in dec for ch in s):
+                self.bytes[i] = s.encode("utf-8")
+            else:
+                self.bytes[i] = bytes(dec[ch] for ch in s)
+        self.TCO = base_vocab["<tool_call>"]
+        self.TCC = base_vocab["</tool_call>"]
+        u = BR.bytes_to_unicode()
+        special_ids = []
+        for sp in CARBON_SPECIALS:
+            if sp in base_vocab:
+                special_ids.append(base_vocab[sp])
+            else:
+                enc = self.tok.encode(sp, add_special_tokens=False).ids
+                assert len(enc) == 1, f"Special {sp!r} is not a single Qwen token: {enc}"
+                special_ids.append(enc[0])
+        self.printable = [base_vocab[u[b]] for b in range(256)] + special_ids
+        self.pindex = {q: p for p, q in enumerate(self.printable)}
+        self.NL = self.printable[32]
+
+
+def _compact_layer_inplace(layer: nn.Module, is_chip: bool) -> tuple[int, int]:
+    before = after = 0
+    if is_chip and hasattr(layer, "linear_attn") and isinstance(layer.linear_attn.out_proj, nn.Linear):
+        F_chip.prune_heads(layer.linear_attn)
+    for parent in list(layer.modules()):
+        for name, child in list(parent.named_children()):
+            if isinstance(child, nn.Linear) and child.bias is None:
+                sp = F_chip.SparseLinear(child.weight)
+                before += child.weight.numel()
+                after += sp.weight.numel()
+                setattr(parent, name, sp)
+    return before, after
+
+
+def _load_and_compact_qwen35(path: Path, n_chip: int, dev: str) -> tuple[Qwen3_5ForCausalLM, dict]:
+    layout_file = path / "chip_layout.json"
+    if not layout_file.is_file():
+        model = Qwen3_5ForCausalLM.from_pretrained(
+            str(path),
+            dtype=torch.bfloat16,
+            attn_implementation="sdpa",
+        )
+        chip_b = chip_a = qwen_b = qwen_a = 0
+        for i, layer in enumerate(model.model.layers):
+            b, a = _compact_layer_inplace(layer, is_chip=(i < n_chip))
+            if i < n_chip:
+                chip_b += b
+                chip_a += a
+            else:
+                qwen_b += b
+                qwen_a += a
+        return model.to(dev).eval(), {
+            "chip_dense": chip_b,
+            "chip_compact": chip_a,
+            "qwen_dense": qwen_b,
+            "qwen_compact": qwen_a,
+        }
+
+    layout = json.loads(layout_file.read_text(encoding="utf-8"))
+    blob = (path / "chip_indices.bin.zlib").read_bytes()
+    cfg = AutoConfig.from_pretrained(str(path))
+    cfg._attn_implementation = "sdpa"
+    with torch.device("meta"):
+        model = Qwen3_5ForCausalLM(cfg)
+
+    tensors_spec: dict[str, dict] = layout["tensors"]
+    by_layer: list[list[str]] = [[] for _ in range(cfg.num_hidden_layers)]
+    for k in tensors_spec:
+        if k.startswith("model.layers."):
+            lid = int(k.split(".", 3)[2])
+            by_layer[lid].append(k)
+
+    chip_before = chip_after = qwen_before = qwen_after = head_before = head_after = 0
+    with safe_open(str(path / "model.safetensors"), framework="pt", device="cpu") as f:
+        def _unpack_one(k: str) -> torch.Tensor:
+            spec = tensors_spec[k]
+            vals = f.get_tensor(k)
+            if spec["mode"] == "dense":
+                return vals
+            shape = tuple(spec["shape"])
+            raw = zlib.decompress(blob[spec["offset"] : spec["offset"] + spec["length"]])
+            idx = np.cumsum(np.frombuffer(raw, dtype=np.uint32), dtype=np.int64)
+            out = torch.zeros(int(np.prod(shape)), dtype=vals.dtype)
+            out[torch.from_numpy(idx)] = vals
+            return out.view(shape)
+
+        for lid in range(cfg.num_hidden_layers):
+            prefix = f"model.layers.{lid}."
+            sub_sd = {k[len(prefix) :]: _unpack_one(k) for k in by_layer[lid]}
+            layer = model.model.layers[lid]
+            layer.load_state_dict(sub_sd, assign=True, strict=True)
+            del sub_sd
+            b, a = _compact_layer_inplace(layer, is_chip=(lid < n_chip))
+            if lid < n_chip:
+                chip_before += b
+                chip_after += a
+            else:
+                qwen_before += b
+                qwen_after += a
+            layer.to(dev)
+
+        norm_w = _unpack_one("model.norm.weight").to(dev)
+        model.model.norm.load_state_dict({"weight": norm_w}, assign=True, strict=True)
+
+        emb_w = _unpack_one("model.embed_tokens.weight").to(dev)
+        model.model.embed_tokens.load_state_dict({"weight": emb_w}, assign=True, strict=True)
+
+        if "lm_head.weight" in tensors_spec and not getattr(cfg, "tie_word_embeddings", True):
+            head_w_cpu = _unpack_one("lm_head.weight")
+            head_before = head_w_cpu.numel()
+            hc0, hc1 = F_chip._hull(F_chip.nonzero_cols(head_w_cpu))
+            hblock = nn.Parameter(head_w_cpu[:, hc0:hc1].contiguous().to(dev), requires_grad=False)
+            head_after = hblock.numel()
+            model.lm_head = F_chip.SparseLinear(
+                head_w_cpu, rows=(0, head_w_cpu.shape[0]), cols=(hc0, hc1), block=hblock
+            )
+            del head_w_cpu
+        else:
+            model.lm_head.load_state_dict({"weight": emb_w}, assign=True, strict=True)
+            model.tie_weights()
+            head_before = head_after = emb_w.numel()
+
+    model.model.rotary_emb = q35_mod.Qwen3_5TextRotaryEmbedding(config=cfg).to(dev)
+    model.eval()
+    if dev == "cuda":
+        with torch.no_grad():
+            for _ in range(2):
+                _wc = DynamicCache(config=cfg)
+                model.model(
+                    input_ids=torch.zeros((1, 2), dtype=torch.long, device=dev),
+                    past_key_values=_wc,
+                    use_cache=True,
+                )
+                model.model(
+                    input_ids=torch.zeros((1, 1), dtype=torch.long, device=dev),
+                    past_key_values=_wc,
+                    use_cache=True,
+                )
+                del _wc
+        gc.collect()
+        torch.cuda.empty_cache()
+    else:
+        gc.collect()
+    return model, {
+        "chip_dense": chip_before,
+        "chip_compact": chip_after,
+        "qwen_dense": qwen_before,
+        "qwen_compact": qwen_after,
+        "head_dense": head_before,
+        "head_compact": head_after,
+    }
+
+
+class CarbonGraphCalcRunner:
+    """Self-contained runner for `Qwen3.5-Math-GraphCalc` checkpoints."""
+
+    def __init__(
+        self,
+        model_dir: str | Path = MODEL_DIR,
+        firmware_path: str | Path | None = None,
+        device: str | None = None,
+        fast: bool = True,
+        executor: bool | str = True,
+    ) -> None:
+        torch.set_grad_enabled(False)
+        F_chip.exact_matmuls()
+        self.path = Path(model_dir)
+        self.meta = json.loads((self.path / "chipformer.json").read_text(encoding="utf-8"))
+        self.dev = device or ("cuda" if torch.cuda.is_available() else "cpu")
+        self.n_chip = int(self.meta["chip_layers"])
+        self.v0 = int(self.meta["chip_token_offset"])
+        self.d0 = int(self.meta["chip_dims_offset"])
+
+        self.model, self.compact_stats = _load_and_compact_qwen35(self.path, self.n_chip, self.dev)
+        self.lm = self.model.model
+        if isinstance(self.model.lm_head, F_chip.SparseLinear):
+            self.head_c0 = self.model.lm_head.c0
+            self.head_c1 = self.model.lm_head.c1
+            self.qwen_head_w = self.model.lm_head.weight[: self.v0]
+        else:
+            self.head_c0 = 0
+            self.head_c1 = self.model.config.hidden_size
+            self.qwen_head_w = self.model.lm_head.weight[: self.v0]
+        self._p4_buf = torch.zeros((4, 1, 1), dtype=torch.long, device=self.dev)
+
+        self.tok = AutoTokenizer.from_pretrained(str(self.path))
+        self.T = CarbonText(self.path / "tokenizer.json")
+
+        cfg = self.model.config
+        self.c = core.build(
+            Target(cfg.linear_num_key_heads, cfg.linear_num_value_heads, cfg.intermediate_size),
+            self.T,
+        )
+        self.code_dims = torch.tensor(self.meta["code_dims"], device=self.dev, dtype=torch.long)
+        self.eos = {248046, 248044}
+        self.go_model_id = self.v0 + S.tok("GO")
+
+        fw = firmware_path or (self.path / self.meta.get("firmware", "graphcalc.elf"))
+        self.firmware_path = Path(fw)
+        self.prog = elf.program(self.firmware_path)
+        core.snapshot(self.c, self.fresh_machine())
+
+        self.executor = executor if self.dev == "cuda" else False
+        self.verify = self.executor == "verify"
+        if self.executor:
+            try:
+                self._build_exec()
+            except Exception as exc:
+                if self.verify:
+                    raise
+                print(f"[runner] Triton Executor2 unavailable ({type(exc).__name__}: {exc}); using CUDA-graphed HF chip layers.", flush=True)
+                self.executor = False
+                self.verify = False
+
+        self.fast = bool(fast and self.dev == "cuda" and (not self.executor or self.verify))
+        if self.fast:
+            self._build_fast()
+
+    def _build_exec(self) -> None:
+        from chipformer.rv.chat import ExecRow
+
+        self.keep_ir = torch.tensor(self.c.keep, device=self.dev, dtype=torch.long)
+        cols = self.meta["code_dims"] + [self.meta["tau_dim"], self.meta["mu_dim"]]
+        self.keep_cols = torch.tensor(cols, device=self.dev, dtype=torch.long)
+        self.emb_cache: dict[int, torch.Tensor] = {}
+        self.erow = ExecRow(self)
+        self.erow._capture()
+
+    def _exec_emb(self, ids: list[int]) -> torch.Tensor:
+        new = sorted({i for i in ids if i not in self.emb_cache})
+        if new:
+            rows = self.erow.ex.embed(
+                [i - self.v0 if i >= self.v0 else BR.text_token(i) for i in new]
+            )
+            for i, r in zip(new, rows):
+                self.emb_cache[i] = r
+        return torch.stack([self.emb_cache[i] for i in ids])
+
+    @torch.no_grad()
+    def _exec_step_one(self, tok_id: int) -> torch.Tensor:
+        row = self.emb_cache.get(tok_id)
+        if row is None:
+            st = tok_id - self.v0 if tok_id >= self.v0 else BR.text_token(tok_id)
+            row = self.erow.ex.embed([st])[0]
+            self.emb_cache[tok_id] = row
+        self.erow.xbuf[0].copy_(row)
+        self.erow.graph.replay()
+        return self.erow.kbuf
+
+    @torch.no_grad()
+    def _exec_start_collect(self, ids: list[int]) -> torch.Tensor:
+        if self.erow.graph is None:
+            self.erow._capture()
+        for st in self.erow.heads:
+            st["S"].zero_()
+            st["hist"].zero_()
+        emb = self._exec_emb(ids)
+        keeps = torch.empty((len(ids), len(self.keep_cols)), dtype=torch.float32, device=self.dev)
+        for t in range(len(ids)):
+            self.erow.xbuf.copy_(emb[t : t + 1])
+            self.erow.graph.replay()
+            keeps[t].copy_(self.erow.kbuf)
+        self.erow.ex.load_init()
+        return keeps
+
+    def _exec_hc(self, tok_id: int, keep: torch.Tensor) -> torch.Tensor:
+        hc = torch.zeros(self.lm.embed_tokens.weight.shape[1], dtype=torch.bfloat16, device=self.dev)
+        hc[: self.d0] = self.lm.embed_tokens.weight[tok_id, : self.d0]
+        hc[self.keep_cols] = keep.to(torch.bfloat16)
+        return hc
+
+    def _build_fast(self) -> None:
+        cfg = copy.deepcopy(self.model.config)
+        cfg.num_hidden_layers = self.n_chip + 1
+        cfg.layer_types = ["linear_attention"] * self.n_chip + ["full_attention"]
+        self.ccfg = cfg
+        dummy = q35_mod.Qwen3_5DecoderLayer(cfg, self.n_chip).to(self.dev, torch.bfloat16)
+        for p in dummy.parameters():
+            p.data.zero_()
+        with torch.device("meta"):
+            cm = q35_mod.Qwen3_5TextModel(cfg)
+        cm.embed_tokens = self.lm.embed_tokens
+        cm.layers = nn.ModuleList([*self.lm.layers[: self.n_chip], dummy])
+        cm.norm = nn.Identity()
+        cm.rotary_emb = q35_mod.Qwen3_5TextRotaryEmbedding(config=cfg).to(self.dev)
+        self.cm = cm.eval()
+        self.graph = None
+
+    def _chip_cache(self):
+        if getattr(self, "ccache", None) is None:
+            self.ccache = DynamicCache(config=self.ccfg)
+        else:
+            for L in range(self.n_chip):
+                lay = self.ccache.layers[L]
+                lay.conv_states[0].zero_()
+                lay.recurrent_states[0].zero_()
+                lay.has_previous_state[0] = False
+        return self.ccache
+
+    @torch.no_grad()
+    def _chip_body(self):
+        h = self.cm.embed_tokens(self.g_ids)
+        for L in range(self.n_chip):
+            h = self.cm.layers[L](
+                h,
+                position_embeddings=None,
+                attention_mask=None,
+                position_ids=None,
+                past_key_values=self.ccache,
+            )
+        self.g_out.copy_(h)
+
+    @torch.no_grad()
+    def _capture(self):
+        self.g_ids = torch.zeros((1, 1), dtype=torch.long, device=self.dev)
+        self.g_out = torch.zeros(
+            (1, 1, self.model.config.hidden_size), dtype=torch.bfloat16, device=self.dev
+        )
+        lays = [self.ccache.layers[L] for L in range(self.n_chip)]
+        saved = [(lay.conv_states[0].clone(), lay.recurrent_states[0].clone()) for lay in lays]
+        s = torch.cuda.Stream()
+        s.wait_stream(torch.cuda.current_stream())
+        with torch.cuda.stream(s):
+            for _ in range(3):
+                self._chip_body()
+        torch.cuda.current_stream().wait_stream(s)
+        self.graph = torch.cuda.CUDAGraph()
+        with torch.cuda.graph(self.graph):
+            self._chip_body()
+        for lay, (cs, rs) in zip(lays, saved):
+            lay.conv_states[0].copy_(cs)
+            lay.recurrent_states[0].copy_(rs)
+
+    @torch.no_grad()
+    def _chip_step(self, tok_id: int, g: int, cache, compiled: bool = True) -> torch.Tensor:
+        if not compiled or self.graph is None:
+            x = torch.tensor([[tok_id]], device=self.dev)
+            out = self.cm(
+                input_ids=x,
+                past_key_values=cache,
+                use_cache=True,
+                cache_position=torch.tensor([g], device=self.dev),
+            )
+            return out.last_hidden_state[0, -1].clone()
+        self.g_ids.fill_(tok_id)
+        self.graph.replay()
+        return self.g_out[0, -1].clone()
+
+    @torch.no_grad()
+    def _qwen_step(self, hc: torch.Tensor, cache, pos: int, full_head: bool = False) -> torch.Tensor:
+        h = hc.view(1, 1, -1)
+        p4 = self._p4_buf
+        p4.fill_(pos)
+        pe = self.lm.rotary_emb(h, p4[1:])
+        for i in range(self.n_chip, len(self.lm.layers)):
+            h = self.lm.layers[i](
+                h,
+                position_embeddings=pe,
+                attention_mask=None,
+                position_ids=p4[0],
+                past_key_values=cache,
+            )
+        nh = self.lm.norm(h)[0, -1]
+        if full_head:
+            return self.model.lm_head(nh)
+        return F.linear(nh[self.head_c0 : self.head_c1], self.qwen_head_w)
+
+    @torch.no_grad()
+    def _qwen_prefill(
+        self, x_ids: torch.Tensor, keeps: torch.Tensor, full_head: bool = False
+    ) -> tuple[DynamicCache, torch.Tensor]:
+        p_len = int(x_ids.shape[1])
+        h = torch.zeros(
+            (1, p_len, self.model.config.hidden_size), dtype=torch.bfloat16, device=self.dev
+        )
+        h[0, :, : self.d0] = self.lm.embed_tokens.weight[x_ids[0], : self.d0]
+        h[0, :, self.keep_cols] = keeps.to(torch.bfloat16)
+        cache = DynamicCache(config=self.model.config)
+        pos_vec = torch.arange(0, p_len, device=self.dev, dtype=torch.long).unsqueeze(0)
+        p4 = pos_vec.unsqueeze(0).expand(4, -1, -1)
+        pe = self.lm.rotary_emb(h, p4[1:])
+        for i in range(self.n_chip, len(self.lm.layers)):
+            h = self.lm.layers[i](
+                h,
+                position_embeddings=pe,
+                attention_mask=None,
+                position_ids=p4[0],
+                past_key_values=cache,
+            )
+        nh = self.lm.norm(h)[0, -1]
+        logits = (
+            self.model.lm_head(nh)
+            if full_head
+            else F.linear(nh[self.head_c0 : self.head_c1], self.qwen_head_w)
+        )
+        return cache, logits
+
+    @torch.no_grad()
+    def _qwen_chunk(
+        self, hcs: list[torch.Tensor], cache, pos0: int, full_head: bool = False
+    ) -> torch.Tensor:
+        if len(hcs) == 1:
+            return self._qwen_step(hcs[0], cache, pos0, full_head=full_head)
+        k_len = len(hcs)
+        h = torch.stack(hcs, dim=0).unsqueeze(0)
+        pos_vec = torch.arange(pos0, pos0 + k_len, device=self.dev, dtype=torch.long).unsqueeze(0)
+        p4 = pos_vec.unsqueeze(0).expand(4, -1, -1)
+        pe = self.lm.rotary_emb(h, p4[1:])
+        attn_mask = torch.zeros((1, 1, k_len, pos0 + k_len), dtype=h.dtype, device=self.dev)
+        future = torch.triu(torch.ones((k_len, k_len), dtype=torch.bool, device=self.dev), diagonal=1)
+        attn_mask[0, 0, :, pos0:][future] = torch.finfo(h.dtype).min
+        for i in range(self.n_chip, len(self.lm.layers)):
+            lmask = attn_mask if self.model.config.layer_types[i] == "full_attention" else None
+            h = self.lm.layers[i](
+                h,
+                position_embeddings=pe,
+                attention_mask=lmask,
+                position_ids=p4[0],
+                past_key_values=cache,
+            )
+        nh = self.lm.norm(h)[0, -1]
+        if full_head:
+            return self.model.lm_head(nh)
+        return F.linear(nh[self.head_c0 : self.head_c1], self.qwen_head_w)
+
+    @torch.no_grad()
+    def _layers_slow(self, tok_id: int, cache, pos: int | None):
+        h = self.lm.embed_tokens(torch.tensor([[tok_id]], device=self.dev))
+        pe = tp = None
+        if pos is not None:
+            p4 = torch.full((4, 1, 1), pos, device=self.dev, dtype=torch.long)
+            tp = p4[0]
+            pe = self.lm.rotary_emb(h, p4[1:])
+        hc = None
+        n = self.n_chip if pos is None else len(self.lm.layers)
+        for i in range(n):
+            h = self.lm.layers[i](
+                h,
+                position_embeddings=pe,
+                attention_mask=None,
+                position_ids=tp,
+                past_key_values=cache,
+            )
+            if i == self.n_chip - 1:
+                hc = h
+        logits = None if pos is None else self.model.lm_head(self.lm.norm(h))[0, -1]
+        return hc[0, -1], logits
+
+    def _decode_code_list(self, vals: list[float]) -> int | None:
+        if not any(v != 0.0 for v in vals):
+            return None
+        nf = core.NFAM
+        fid = 0
+        for i in range(nf):
+            if vals[i] > 0.0:
+                fid |= 1 << i
+        p = 0
+        for i in range(len(vals) - nf):
+            if vals[nf + i] > 0.0:
+                p |= 1 << i
+        t = core.decode_code(fid, p, self.T)
+        if t < 0:
+            raise RuntimeError(f"Invalid circuit token prediction (family={fid}, payload={p})")
+        return t - S.TEXT_TOKEN if S.is_text(t) else self.v0 + t
+
+    def code_token(self, code: torch.Tensor) -> int | None:
+        return self._decode_code_list(code.tolist())
+
+    def circuit_token(self, hc: torch.Tensor) -> int | None:
+        return self.code_token(hc[self.code_dims])
+
+    def fresh_machine(self) -> ref.Machine:
+        m = ref.Machine.from_program(self.prog)
+        BR.park(m)
+        return m
+
+    def prompt_ids(
+        self,
+        user_prompt: str | list[dict],
+        system_prompt: str | None = GRAPHCALC_SYSTEM_PROMPT,
+        use_tools: bool = True,
+    ) -> list[int]:
+        if isinstance(user_prompt, str):
+            msgs = []
+            if system_prompt:
+                msgs.append({"role": "system", "content": system_prompt})
+            msgs.append({"role": "user", "content": user_prompt})
+        else:
+            msgs = list(user_prompt)
+        tools = [GRAPHCALC_TOOL] if use_tools else None
+        out = self.tok.apply_chat_template(
+            msgs,
+            tools=tools,
+            add_generation_prompt=True,
+            enable_thinking=False,
+            tokenize=True,
+        )
+        if not isinstance(out, list):
+            out = out["input_ids"]
+        return [int(x) for x in out]
+
+    @torch.no_grad()
+    def generate(
+        self,
+        ids: list[int],
+        max_new_text: int = 512,
+        max_chip_tokens: int = 500_000,
+        max_calls: int = 1,
+        check_head: bool = False,
+        check_lock: bool = False,
+    ) -> dict:
+        m = self.fresh_machine()
+        lock = None
+        if check_lock:
+            lock = BR.Session(self.T, self.fresh_machine())
+            lock.history(ids)
+
+        x = torch.tensor([ids], device=self.dev, dtype=torch.long)
+        core.snapshot(self.c, m)
+        n_code = len(self.code_dims)
+
+        if self.executor and not self.verify:
+            keeps = self._exec_start_collect(ids)
+            cache, logits = self._qwen_prefill(x, keeps, full_head=check_head)
+        else:
+            lm_out = self.lm(input_ids=x, use_cache=True)
+            cache = lm_out.past_key_values
+            if self.executor:
+                self.erow.start(ids)
+            if self.fast:
+                ccache = self._chip_cache()
+                h = self.cm.embed_tokens(x)
+                for L in range(self.n_chip):
+                    h = self.cm.layers[L](
+                        h,
+                        position_embeddings=None,
+                        attention_mask=None,
+                        position_ids=None,
+                        past_key_values=ccache,
+                    )
+                hf.inject(self.c, ccache)
+                if self.graph is None:
+                    self._capture()
+                g = len(ids)
+            elif not self.executor:
+                hf.inject(self.c, cache)
+            logits = self.model.lm_head(lm_out.last_hidden_state[0, -1])
+        pos = len(ids)
+        gen: list[int] = []
+        n_qwen_text = n_echo_text = n_chip_tok = n_calls = head_mismatch = n_verify_bad = 0
+        nxt = int(torch.argmax(logits[: self.v0]))
+        prev_owned = False
+        in_tool_call = False
+        pending_hcs: list[torch.Tensor] = []
+        pending_pos0: int | None = None
+        t0 = time.time()
+        expect: list[int] = []
+        lock_error = None
+
+        while n_chip_tok < max_chip_tokens:
+            if n_qwen_text >= max_new_text and (not prev_owned) and (not in_tool_call):
+                break
+
+            gen.append(nxt)
+            if nxt == self.T.TCO and not prev_owned:
+                in_tool_call = True
+            elif nxt == self.T.TCC:
+                in_tool_call = False
+            if nxt == self.go_model_id:
+                n_calls += 1
+
+            if lock is not None:
+                st = nxt - self.v0 if nxt >= self.v0 else BR.text_token(nxt)
+                if expect:
+                    e = expect.pop(0)
+                    if st != e:
+                        lock_error = {"at": len(gen) - 1, "got": st, "want": e}
+                        break
+                elif st < S.VOCAB:
+                    lock_error = {"at": len(gen) - 1, "got": S.name(st), "want": "text"}
+                    break
+                else:
+                    k = len(lock.toks)
+                    try:
+                        lock.qwen([nxt])
+                    except RuntimeError as exc:
+                        lock_error = {"at": len(gen) - 1, "got": str(exc), "want": "halt"}
+                        break
+                    expect = list(lock.toks[k + 1 :])
+
+            if nxt in self.eos and not prev_owned:
+                break
+
+            chip_in = nxt >= self.v0
+            hc = keep = None
+            if self.executor:
+                keep = self._exec_step_one(nxt)
+                if not chip_in:
+                    hc = self._exec_hc(nxt, keep)
+            if self.fast and (self.verify or not self.executor):
+                hf_hc = self._chip_step(nxt, g, ccache)
+                g += 1
+                if self.verify:
+                    same = (
+                        bool((hf_hc[self.keep_cols] == keep.to(torch.bfloat16)).all())
+                        if chip_in
+                        else bool((hf_hc == hc).all())
+                    )
+                    if not same:
+                        n_verify_bad += 1
+                hc = hf_hc
+            elif not self.executor:
+                hc, logits = self._layers_slow(nxt, cache, None if chip_in else pos)
+
+            if chip_in:
+                n_chip_tok += 1
+                nxt = (
+                    self._decode_code_list(keep[:n_code].tolist())
+                    if hc is None
+                    else self.circuit_token(hc)
+                )
+                prev_owned = True
+                if nxt is None:
+                    raise RuntimeError("Circuit relinquished ownership mid-chip-token")
+            else:
+                if prev_owned:
+                    n_echo_text += 1
+                else:
+                    n_qwen_text += 1
+                ct = (
+                    self._decode_code_list(keep[:n_code].tolist())
+                    if (keep is not None and not self.verify)
+                    else self.circuit_token(hc)
+                )
+                if ct is not None and (self.fast or self.executor) and not check_head:
+                    if pending_pos0 is None:
+                        pending_pos0 = pos
+                    pending_hcs.append(hc)
+                    pos += 1
+                    nxt = ct
+                    prev_owned = True
+                else:
+                    if self.fast or self.executor:
+                        if pending_hcs:
+                            pending_hcs.append(hc)
+                            logits = self._qwen_chunk(
+                                pending_hcs, cache, pending_pos0, full_head=check_head
+                            )
+                            pending_hcs.clear()
+                            pending_pos0 = None
+                        else:
+                            logits = self._qwen_step(hc, cache, pos, full_head=check_head)
+                    pos += 1
+                    if ct is not None:
+                        if check_head and int(torch.argmax(logits)) != ct:
+                            head_mismatch += 1
+                        nxt = ct
+                        prev_owned = True
+                    else:
+                        q_logits = logits[: self.v0]
+                        if n_calls >= max_calls or n_qwen_text >= max(16, max_new_text - 48):
+                            q_logits = q_logits.clone()
+                            q_logits[self.T.TCO] = float("-inf")
+                        nxt = int(torch.argmax(q_logits))
+                        prev_owned = False
+
+        dt = time.time() - t0
+        parsed = self.parse_turn(gen)
+        return {
+            "tokens": gen,
+            "text_tokens": n_qwen_text,
+            "echo_text_tokens": n_echo_text,
+            "chip_tokens": n_chip_tok,
+            "tool_calls_executed": n_calls,
+            "seconds": round(dt, 3),
+            "head_mismatch": head_mismatch,
+            "lock_error": lock_error,
+            "verify_mismatch": n_verify_bad if self.verify else None,
+            **parsed,
+        }
+
+    def text_of(self, ids: list[int]) -> str:
+        return self.tok.decode([i for i in ids if i < self.v0], skip_special_tokens=False)
+
+    def parse_turn(self, gen_ids: list[int]) -> dict:
+        raw = self.text_of(gen_ids)
+        calls = re.findall(r"<tool_call>\s*(.*?)\s*</tool_call>", raw, flags=re.DOTALL)
+        responses = re.findall(r"<tool_response>\n?(.*?)\n?</tool_response>", raw, flags=re.DOTALL)
+        cleaned = re.sub(
+            r"<tool_call>.*?</tool_response>\s*(?:<\|im_end\|>\s*<\|im_start\|>assistant\s*<think>\s*</think>\s*)?",
+            "\n\n",
+            raw,
+            flags=re.DOTALL,
+        )
+        cleaned = re.sub(r"<tool_call>.*$", "", cleaned, flags=re.DOTALL)
+        cleaned = re.sub(r"</?think>", "", cleaned)
+        for stop_s in ("<|im_end|>", "<|endoftext|>", "<|im_start|>"):
+            if stop_s in cleaned:
+                cleaned = cleaned.split(stop_s, 1)[0]
+        cleaned = re.sub(r"\n{3,}", "\n\n", cleaned).strip()
+        return {
+            "raw_text": raw,
+            "tool_calls": calls,
+            "tool_responses": responses,
+            "final_explanation": cleaned,
+        }
+
+
+def main() -> None:
+    ap = argparse.ArgumentParser(description="Run Qwen3.5-Math-GraphCalc in-weights")
+    ap.add_argument(
+        "--ask",
+        default="Graph y = x^3 - 3*x from x = -2 to 2, identify its roots and turning points, and state the local maximum y-value.",
+        help="Math or graphing question to solve",
+    )
+    ap.add_argument("--pure-hf", action="store_true", help="Run un-fused HF Qwen3_5DecoderLayer weights (executor=False)")
+    ap.add_argument("--max-new-text", type=int, default=512)
+    args = ap.parse_args()
+
+    runner = CarbonGraphCalcRunner(MODEL_DIR, fast=True, executor=not args.pure_hf)
+    res = runner.generate(runner.prompt_ids(args.ask), max_new_text=args.max_new_text, check_lock=True)
+    if res["tool_responses"]:
+        print("=== IN-WEIGHTS RV32 <tool_response> ===")
+        print(res["tool_responses"][0])
+        print()
+    print("=== STEP-BY-STEP TUTOR EXPLANATION ===")
+    print(res["final_explanation"])
+    print(f"\n[chip_tokens={res['chip_tokens']} | lock_error={res['lock_error']} | {res['seconds']}s]")
+
+
+if __name__ == "__main__":
+    main()

tokenizer.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:eeb7adf50a06ace136ccec295ee33e6e88deac189bffab57052415de813a7dcf
+size 64037666

tokenizer_config.json

@@ -0,0 +1,48 @@
+{
+  "add_prefix_space": false,
+  "audio_bos_token": "<|audio_start|>",
+  "audio_eos_token": "<|audio_end|>",
+  "audio_token": "<|audio_pad|>",
+  "backend": "tokenizers",
+  "bos_token": null,
+  "clean_up_tokenization_spaces": false,
+  "eos_token": "<|endoftext|>",
+  "errors": "replace",
+  "extra_special_tokens": [
+    "<|im_start|>",
+    "<|im_end|>",
+    "<|object_ref_start|>",
+    "<|object_ref_end|>",
+    "<|box_start|>",
+    "<|box_end|>",
+    "<|quad_start|>",
+    "<|quad_end|>",
+    "<|vision_start|>",
+    "<|vision_end|>",
+    "<|vision_pad|>",
+    "<|image_pad|>",
+    "<|video_pad|>"
+  ],
+  "image_token": "<|image_pad|>",
+  "is_local": false,
+  "local_files_only": true,
+  "merges_file": null,
+  "model_max_length": 262144,
+  "model_specific_special_tokens": {
+    "audio_bos_token": "<|audio_start|>",
+    "audio_eos_token": "<|audio_end|>",
+    "audio_token": "<|audio_pad|>",
+    "image_token": "<|image_pad|>",
+    "video_token": "<|video_pad|>",
+    "vision_bos_token": "<|vision_start|>",
+    "vision_eos_token": "<|vision_end|>"
+  },
+  "pad_token": "<|endoftext|>",
+  "pretokenize_regex": "(?i:'s|'t|'re|'ve|'m|'ll|'d)|[^\\r\\n\\p{L}\\p{N}]?[\\p{L}\\p{M}]+|\\p{N}| ?[^\\s\\p{L}\\p{M}\\p{N}]+[\\r\\n]*|\\s*[\\r\\n]+|\\s+(?!\\S)|\\s+",
+  "split_special_tokens": false,
+  "tokenizer_class": "Qwen3_5Tokenizer",
+  "unk_token": null,
+  "video_token": "<|video_pad|>",
+  "vision_bos_token": "<|vision_start|>",
+  "vision_eos_token": "<|vision_end|>"
+}