nockasm 1.0.0__tar.gz

nockasm-1.0.0/.claude/settings.local.json

@@ -0,0 +1,10 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(python *)",
+      "Bash(git add *)",
+      "Bash(git commit -m ' *)",
+      "Bash(git push *)"
+    ]
+  }
+}

nockasm-1.0.0/PKG-INFO

@@ -0,0 +1,204 @@
+Metadata-Version: 2.4
+Name: nockasm
+Version: 1.0.0
+Summary: A thin macro expander from Nock Assembly to canonical Nock 4K
+Author-email: Sigilante <davisneale@gmail.com>
+License: MIT
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+
+# Nock Assembly
+
+![](./img/hero.jpg)
+
+Nock Assembly is a thin macro over [Nock ISA](https://nock.is) designed to make the language more legible for pedagogical purposes.
+
+## Design
+
+| | |
+|---|---|
+| Named opcodes        | `(%inc .x)` instead of `[4 0 2]`. Pure lexical. |
+| Axis schemas         | `:subject {.a .b .c}` resolves `.a` `.b` `.c` to axes 2, 6, 7. Right-leaning by Hoon convention. |
+| `#let .name = E in B`| Opcode-8 push. Tracks subject shift via `+peg(3, n)` so old names still resolve in body. |
+| `#match E { ... }`   | Scrutinee lifted once via opcode 8. Nested opcode-6 dispatch on literal patterns. Required `_ =>` default. |
+| `; comments`         | And whitespace. |
+
+## Install / use
+
+```python
+from nockasm import expand
+print(expand("(%inc (%self))"))
+# [4 0 1]
+
+print(expand("""
+:subject {.tag .data}
+#match .tag {
+  1 => (%inc .data)
+  2 => .data
+  _ => 0
+}
+"""))
+# [8 [0 2] 6 [5 [1 1] 0 2] [4 0 7] 6 [5 [1 2] 0 2] [0 7] 1 0]
+```
+
+End-to-end with [`pinochle`](https://github.com/sigilante/pinochle):
+
+```python
+from pinochle import nock, parse_noun
+from nockasm import expand
+
+src = """
+:subject {.before .target .after}
+#let .next = (%inc .target) in
+  [.before .next .after]
+"""
+
+formula = parse_noun(expand(src))
+result  = nock(parse_noun("[10 41 99]"), formula)
+# result == [10 42 99]
+```
+
+At the CLI:
+
+```bash
+python -m nockasm program.nasm           # canonical flat
+python -m nockasm --pretty program.nasm  # explicit binary cells
+echo "(%inc (%self))" | python -m nockasm
+```
+
+## Integration with the Nock kernel
+
+Pinochle ships `nock-kernel` for Jupyter (`Nock 4K` kernel). It accepts
+canonical Nock in `:formula` cells. Workflow today:
+
+1. Write `.nasm` in a regular Python cell (or text editor).
+2. Run `expand(src)` in a Python notebook to get canonical Nock.
+3. Paste the result into a `:formula` cell in a Nock notebook.
+
+A `:asm` cell magic for the Nock kernel that does this in one step is the
+obvious next step. Roughly:
+
+```python
+# in pinochle/packages/nock_kernel/kernel.py
+if cell.startswith(':asm'):
+    from nockasm import expand
+    formula_src = expand(cell[len(':asm'):])
+    # then dispatch as if user had typed ':formula <formula_src>'
+```
+
+## Structural macros
+
+### `#let .name = VALUE in BODY`
+
+Pushes `VALUE` onto the subject via opcode 8 and binds `.name` to axis 2 in
+`BODY`. Any axes that were already in scope are shifted rightward via
+`+peg(3, axis)`, so the old names still resolve in the body.
+
+```
+:subject {.before .target .after}
+#let .next = (%inc .target) in
+  [.before .next .after]
+; -> [8 [4 0 6] [0 6] [0 2] 0 15]
+; against [10 41 99] -> [10 42 99]
+```
+
+`VALUE` and `BODY` are both formula positions (bare atoms lift). Shadowing
+an existing schema name is a compile error.
+
+### `#match EXPR { PAT => BODY ... _ => DEFAULT }`
+
+Pattern match on the value of `EXPR`. The scrutinee is evaluated once via
+opcode 8 — i.e. lifted onto the subject — then each `PAT` is compared
+against the lifted value via opcode 5 (eq), with opcode 6 (if) dispatching
+to the matching `BODY`. The `_ =>` default is required.
+
+```
+:subject {.tag .data}
+#match .tag {
+  1 => (%inc .data)
+  2 => .data
+  _ => 0
+}
+; -> [8 [0 2] 6 [5 [1 1] 0 2] [4 0 7] 6 [5 [1 2] 0 2] [0 7] 1 0]
+; against [1 41] -> 42
+; against [2 41] -> 41
+; against [9 41] -> 0
+```
+
+`EXPR` and each `BODY` are formula positions. `PAT`s are *noun literals* —
+they're compared against the scrutinee's runtime value, not against a
+formula. Bare atoms in `PAT` position are not lifted: writing `1 => ...`
+matches the atom `1`, not the formula `[1 1]`.
+
+In the body of each arm (and the default), the scrutinee is at axis 2, and
+the original schema axes are shifted rightward via `+peg(3, axis)` — same
+shift rule as `#let`. That's why `.data` resolves to `[0 7]` (not `[0 3]`)
+in the example above.
+
+## What lifts and what doesn't
+
+Bare atoms get lifted to `[1 atom]` in formula positions. Not in noun-literal
+positions (`%const` arg, hint tag) or axis positions (`%slot` arg, `%call`
+arity arg, etc.). The per-opcode kinds:
+
+| Opcode    | Kinds | Notes |
+|-----------|-------|-------|
+| `%slot N` | a     | axis literal |
+| `%const X`| n     | any noun, no lift |
+| `%arm X`  | n     | synonym for `%const`; intent: callable formula |
+| `%crash`  | —     | `[0 0]` — Nock crash idiom |
+| `%self`   | —     | `[0 1]` — whole subject |
+| `%battery`| —     | `[0 2]` — standard core battery |
+| `%payload`| —     | `[0 3]` — standard core payload |
+| `%sample` | —     | `[0 6]` — standard gate sample |
+| `%context`| —     | `[0 7]` — standard gate context |
+| `%eval`   | ff    | both formulas |
+| `%isa`    | f     | |
+| `%inc`    | f     | |
+| `%eq`     | ff    | |
+| `%if`     | fff   | branches lift |
+| `%comp`   | ff    | |
+| `%push`   | ff    | |
+| `%call N F`| af   | |
+| `%edit N V F`| aff | |
+| `%hint T F`  | nf  | tag is a noun literal |
+| `%hintd T C F` | nff | clue is a formula — per 4K spec it's evaluated |
+
+The intent-marking opcodes (`%arm`, `%crash`, and the axis aliases) all lower
+to the same cells as their `%const` / `%slot` equivalents — they exist purely
+to surface meaning at the source level. `%arm X` is `%const X` for cases
+where `X` is a formula that will later be invoked via `%call`; `%self`
+through `%context` name the standard Hoon core/gate axes.
+
+`#let` value and body are formulas. `#match` scrutinee and arm bodies are
+formulas. Match *patterns* are noun literals (compared against the
+scrutinee's evaluated value).
+
+Raw cells `[...]` are taken structurally: their elements are *not* lifted.
+That gives you an escape hatch into raw Nock when you need it, and the
+cons-formula distribution pattern works as expected:
+
+```
+:subject {.a .b}
+[(%inc .a) (%inc .b)]
+; -> [[4 0 2] [4 0 3]]
+; against [3 5] -> [4 6] via Nock distribution
+```
+
+## Tests
+
+```bash
+python test_nockasm.py     # unit tests, 55 cases
+python test_e2e.py         # end-to-end: expand -> pinochle -> verify, 19 cases
+python test_benchmarks.py  # urbit/benchmark equivalents, 5 cases (loaded from disk)
+```
+
+`test_benchmarks.py` reads `benchmarks/tests.json` and `benchmarks/<name>.nasm`
+from disk and runs each through pinochle. The five benchmarks present
+(`dec`, `add`, `factorial`, `fibonacci`, `ackermann`) are faithful
+transcriptions of `urbit/benchmark/desk/bar/<name>.nock` — each `.nasm`
+expands to a noun bit-identical to the corresponding `.nock` formula.
+
+## License
+
+MIT.

nockasm-1.0.0/README.md

@@ -0,0 +1,195 @@
+# Nock Assembly
+
+![](./img/hero.jpg)
+
+Nock Assembly is a thin macro over [Nock ISA](https://nock.is) designed to make the language more legible for pedagogical purposes.
+
+## Design
+
+| | |
+|---|---|
+| Named opcodes        | `(%inc .x)` instead of `[4 0 2]`. Pure lexical. |
+| Axis schemas         | `:subject {.a .b .c}` resolves `.a` `.b` `.c` to axes 2, 6, 7. Right-leaning by Hoon convention. |
+| `#let .name = E in B`| Opcode-8 push. Tracks subject shift via `+peg(3, n)` so old names still resolve in body. |
+| `#match E { ... }`   | Scrutinee lifted once via opcode 8. Nested opcode-6 dispatch on literal patterns. Required `_ =>` default. |
+| `; comments`         | And whitespace. |
+
+## Install / use
+
+```python
+from nockasm import expand
+print(expand("(%inc (%self))"))
+# [4 0 1]
+
+print(expand("""
+:subject {.tag .data}
+#match .tag {
+  1 => (%inc .data)
+  2 => .data
+  _ => 0
+}
+"""))
+# [8 [0 2] 6 [5 [1 1] 0 2] [4 0 7] 6 [5 [1 2] 0 2] [0 7] 1 0]
+```
+
+End-to-end with [`pinochle`](https://github.com/sigilante/pinochle):
+
+```python
+from pinochle import nock, parse_noun
+from nockasm import expand
+
+src = """
+:subject {.before .target .after}
+#let .next = (%inc .target) in
+  [.before .next .after]
+"""
+
+formula = parse_noun(expand(src))
+result  = nock(parse_noun("[10 41 99]"), formula)
+# result == [10 42 99]
+```
+
+At the CLI:
+
+```bash
+python -m nockasm program.nasm           # canonical flat
+python -m nockasm --pretty program.nasm  # explicit binary cells
+echo "(%inc (%self))" | python -m nockasm
+```
+
+## Integration with the Nock kernel
+
+Pinochle ships `nock-kernel` for Jupyter (`Nock 4K` kernel). It accepts
+canonical Nock in `:formula` cells. Workflow today:
+
+1. Write `.nasm` in a regular Python cell (or text editor).
+2. Run `expand(src)` in a Python notebook to get canonical Nock.
+3. Paste the result into a `:formula` cell in a Nock notebook.
+
+A `:asm` cell magic for the Nock kernel that does this in one step is the
+obvious next step. Roughly:
+
+```python
+# in pinochle/packages/nock_kernel/kernel.py
+if cell.startswith(':asm'):
+    from nockasm import expand
+    formula_src = expand(cell[len(':asm'):])
+    # then dispatch as if user had typed ':formula <formula_src>'
+```
+
+## Structural macros
+
+### `#let .name = VALUE in BODY`
+
+Pushes `VALUE` onto the subject via opcode 8 and binds `.name` to axis 2 in
+`BODY`. Any axes that were already in scope are shifted rightward via
+`+peg(3, axis)`, so the old names still resolve in the body.
+
+```
+:subject {.before .target .after}
+#let .next = (%inc .target) in
+  [.before .next .after]
+; -> [8 [4 0 6] [0 6] [0 2] 0 15]
+; against [10 41 99] -> [10 42 99]
+```
+
+`VALUE` and `BODY` are both formula positions (bare atoms lift). Shadowing
+an existing schema name is a compile error.
+
+### `#match EXPR { PAT => BODY ... _ => DEFAULT }`
+
+Pattern match on the value of `EXPR`. The scrutinee is evaluated once via
+opcode 8 — i.e. lifted onto the subject — then each `PAT` is compared
+against the lifted value via opcode 5 (eq), with opcode 6 (if) dispatching
+to the matching `BODY`. The `_ =>` default is required.
+
+```
+:subject {.tag .data}
+#match .tag {
+  1 => (%inc .data)
+  2 => .data
+  _ => 0
+}
+; -> [8 [0 2] 6 [5 [1 1] 0 2] [4 0 7] 6 [5 [1 2] 0 2] [0 7] 1 0]
+; against [1 41] -> 42
+; against [2 41] -> 41
+; against [9 41] -> 0
+```
+
+`EXPR` and each `BODY` are formula positions. `PAT`s are *noun literals* —
+they're compared against the scrutinee's runtime value, not against a
+formula. Bare atoms in `PAT` position are not lifted: writing `1 => ...`
+matches the atom `1`, not the formula `[1 1]`.
+
+In the body of each arm (and the default), the scrutinee is at axis 2, and
+the original schema axes are shifted rightward via `+peg(3, axis)` — same
+shift rule as `#let`. That's why `.data` resolves to `[0 7]` (not `[0 3]`)
+in the example above.
+
+## What lifts and what doesn't
+
+Bare atoms get lifted to `[1 atom]` in formula positions. Not in noun-literal
+positions (`%const` arg, hint tag) or axis positions (`%slot` arg, `%call`
+arity arg, etc.). The per-opcode kinds:
+
+| Opcode    | Kinds | Notes |
+|-----------|-------|-------|
+| `%slot N` | a     | axis literal |
+| `%const X`| n     | any noun, no lift |
+| `%arm X`  | n     | synonym for `%const`; intent: callable formula |
+| `%crash`  | —     | `[0 0]` — Nock crash idiom |
+| `%self`   | —     | `[0 1]` — whole subject |
+| `%battery`| —     | `[0 2]` — standard core battery |
+| `%payload`| —     | `[0 3]` — standard core payload |
+| `%sample` | —     | `[0 6]` — standard gate sample |
+| `%context`| —     | `[0 7]` — standard gate context |
+| `%eval`   | ff    | both formulas |
+| `%isa`    | f     | |
+| `%inc`    | f     | |
+| `%eq`     | ff    | |
+| `%if`     | fff   | branches lift |
+| `%comp`   | ff    | |
+| `%push`   | ff    | |
+| `%call N F`| af   | |
+| `%edit N V F`| aff | |
+| `%hint T F`  | nf  | tag is a noun literal |
+| `%hintd T C F` | nff | clue is a formula — per 4K spec it's evaluated |
+
+The intent-marking opcodes (`%arm`, `%crash`, and the axis aliases) all lower
+to the same cells as their `%const` / `%slot` equivalents — they exist purely
+to surface meaning at the source level. `%arm X` is `%const X` for cases
+where `X` is a formula that will later be invoked via `%call`; `%self`
+through `%context` name the standard Hoon core/gate axes.
+
+`#let` value and body are formulas. `#match` scrutinee and arm bodies are
+formulas. Match *patterns* are noun literals (compared against the
+scrutinee's evaluated value).
+
+Raw cells `[...]` are taken structurally: their elements are *not* lifted.
+That gives you an escape hatch into raw Nock when you need it, and the
+cons-formula distribution pattern works as expected:
+
+```
+:subject {.a .b}
+[(%inc .a) (%inc .b)]
+; -> [[4 0 2] [4 0 3]]
+; against [3 5] -> [4 6] via Nock distribution
+```
+
+## Tests
+
+```bash
+python test_nockasm.py     # unit tests, 55 cases
+python test_e2e.py         # end-to-end: expand -> pinochle -> verify, 19 cases
+python test_benchmarks.py  # urbit/benchmark equivalents, 5 cases (loaded from disk)
+```
+
+`test_benchmarks.py` reads `benchmarks/tests.json` and `benchmarks/<name>.nasm`
+from disk and runs each through pinochle. The five benchmarks present
+(`dec`, `add`, `factorial`, `fibonacci`, `ackermann`) are faithful
+transcriptions of `urbit/benchmark/desk/bar/<name>.nock` — each `.nasm`
+expands to a noun bit-identical to the corresponding `.nock` formula.
+
+## License
+
+MIT.

nockasm-1.0.0/benchmarks/ackermann.nasm

@@ -0,0 +1,57 @@
+;  ackermann: ack(m, n) on a [m n] subject.
+;
+;  Faithful transcription of urbit/benchmark/desk/bar/ackermann.nock,
+;  drilled into named opcodes. The core has just two members: the
+;  main arm (axis 4) — which self-recurses via %call 4 — and the +dec
+;  arm wrapper (axis 5/10).
+;
+;  Note: in this |^ trap the payload is [m n], so axis 6 = m and
+;  axis 7 = n. The %sample and %context aliases line up by axis but
+;  not by their usual gate-call semantics — they are just convenient
+;  names for [0 6] and [0 7] here.
+;
+;  Subject: a cell [m n].
+;  Result : ack(m, n).
+
+(%push
+  (%const
+    [ ;  Main arm (axis 4 of [core m_n]). Standard Ackermann recursion.
+      (%if (%eq (%const 0) (%sample))
+           ;  m == 0  ->  +(n)
+           (%inc (%context))
+           (%if (%eq (%const 0) (%context))
+                ;  n == 0  ->  $(m (dec m), n 1)
+                (%call 4
+                       (%edit 3
+                              [ (%push (%call 5 (%self))
+                                       (%call 2 (%edit 6 (%slot 14) (%battery))))
+                                (%const 1) ]
+                              (%self)))
+                ;  else    ->  $(m (dec m), n $(n (dec n)))
+                (%call 4
+                       (%edit 3
+                              [ (%push (%call 5 (%self))
+                                       (%call 2 (%edit 6 (%slot 14) (%battery))))
+                                (%call 4
+                                       (%edit 7
+                                              (%push (%call 5 (%self))
+                                                     (%call 2 (%edit 6 (%slot 15) (%battery))))
+                                              (%self))) ]
+                              (%self)))))
+
+      ;  +dec arm wrapper (axis 5 of [core m_n]). Same body as dec.nasm.
+      (%push (%const 0)
+             [ (%arm
+                 (%if (%eq (%const 0) (%sample))
+                      (%crash)
+                      (%push (%const 0)
+                             (%push (%arm
+                                      (%if (%eq (%slot 30) (%inc (%sample)))
+                                           (%sample)
+                                           (%call 2 (%edit 6
+                                                            (%inc (%sample))
+                                                            (%self)))))
+                                    (%call 2 (%self))))))
+               (%self) ]) ])
+
+  (%call 4 (%self)))

nockasm-1.0.0/benchmarks/add.nasm

@@ -0,0 +1,48 @@
+;  add: unsigned addition of [a b].
+;
+;  Faithful transcription of urbit/benchmark/desk/bar/add.nock, drilled
+;  fully into named opcodes.
+;
+;  Subject: a cell [a b].
+;  Result : a + b.
+
+(%push
+  (%const
+    [ ;  +add arm (axis 4 of [core a_b]). Pushes [0 0] as sample
+      ;  placeholder, then autocons [add-body subject] to make a gate.
+      (%push (%const [0 0])
+             [ (%arm
+                 ;  +add body. Subject when entered: [body sample payload].
+                 ;  axis 12 = a, axis 13 = b, axis 28 = (axis 14 of payload).
+                 (%if (%eq (%const 0) (%slot 12))
+                      (%slot 13)
+                      (%call 2
+                        (%edit 6
+                          [ (%push (%call 10 (%context))
+                                   (%call 2 (%edit 6 (%slot 28) (%battery))))
+                            (%inc (%slot 13)) ]
+                          (%self)))))
+               (%self) ])
+
+      ;  +dec arm (axis 10 of [core a_b]). Same shape as dec.nasm.
+      (%push (%const 0)
+             [ (%arm
+                 (%if (%eq (%const 0) (%sample))
+                      (%crash)
+                      (%push (%const 0)
+                             (%push
+                               (%arm
+                                 (%if (%eq (%slot 30) (%inc (%sample)))
+                                      (%sample)
+                                      (%call 2 (%edit 6
+                                                       (%inc (%sample))
+                                                       (%self)))))
+                               (%call 2 (%self))))))
+               (%self) ])
+
+      ;  Main body: push +add core, then call its arm with [m n] sample.
+      (%push (%call 4 (%self))
+             (%call 2 (%edit 6 [(%slot 14) (%slot 15)] (%battery)))) ])
+
+  ;  Invoke main body at axis 11 of [core a_b].
+  (%call 11 (%self)))

nockasm-1.0.0/benchmarks/dec.nasm

@@ -0,0 +1,41 @@
+;  dec: naive unsigned decrement.
+;
+;  Faithful transcription of urbit/benchmark/desk/bar/dec.nock, drilled
+;  fully into named opcodes. Uses %arm (intent-marked %const) for the
+;  formulas later invoked via %call, %crash for [0 0], and the standard
+;  axis aliases %self / %battery / %payload / %sample / %context.
+;
+;  Subject: a single atom m  (asserted nonzero).
+;  Result : m - 1.
+
+(%push
+  ;  Push the |^ core onto the subject stack; new subject = [core m].
+  (%const
+    [ ;  main arm at axis 4: build the dec sub-core via the core tail,
+      ;  then call its first arm with m installed at sample.
+      (%push (%call 5 (%self))
+             (%call 2 (%edit 6 (%context) (%battery))))
+
+      ;  core tail at axis 5: a formula that, when invoked, autocons
+      ;  [dec-arm subject] to assemble a gate-shaped sub-core.
+      (%push (%const 0)
+             [ (%arm
+                 ;  +dec arm body. Subject when called is [arm payload]
+                 ;  with the argument at sample, original at axis 30.
+                 (%if (%eq (%const 0) (%sample))
+                      (%crash)
+                      (%push (%const 0)
+                             (%push
+                               (%arm
+                                 ;  inner |- loop on candidate b at sample:
+                                 ;  if a == +(b) return b, else recurse b+1
+                                 (%if (%eq (%slot 30) (%inc (%sample)))
+                                      (%sample)
+                                      (%call 2 (%edit 6
+                                                       (%inc (%sample))
+                                                       (%self)))))
+                               (%call 2 (%self))))))
+               (%self) ]) ])
+
+  ;  Call the main arm at axis 4 of the new subject.
+  (%call 4 (%self)))

nockasm-1.0.0/benchmarks/factorial.nasm

@@ -0,0 +1,96 @@
+;  factorial: tail-recursive factorial of a single-atom subject.
+;
+;  Faithful transcription of urbit/benchmark/desk/bar/factorial.nock,
+;  drilled into named opcodes. The core has three explicit arms — +mul
+;  (axis 4), +add (axis 20), +dec (axis 21) — and a main body (axis 11)
+;  that builds an anonymous |= gate and invokes it on m.
+;
+;  Subject: a single atom m.
+;  Result : m! (use small m; pure Nock multiplication is slow).
+
+(%push
+  (%const
+    [ ;  +mul arm (axis 4 of [core m]). Standard `|: [a=`@`1 b=`@`1]`
+      ;  pattern: push the [1 1] default sample, then autocons
+      ;  [mul-body subject].
+      (%push (%const [1 1])
+             [ (%arm
+                 ;  +mul body. Push c=0 accumulator, then push the |- arm
+                 ;  and call it.
+                 (%push (%const 0)
+                        (%push (%arm
+                                 ;  |- loop on a (axis 60) with c (axis 6).
+                                 ;  if a == 0  -> return c
+                                 ;  else recurse with a := dec(a), c := add(b, c)
+                                 (%if (%eq (%const 0) (%slot 60))
+                                      (%sample)
+                                      (%call 2
+                                        (%edit 60
+                                          (%push (%call 21 (%slot 31))
+                                                 (%call 2 (%edit 6 (%slot 124) (%battery))))
+                                          (%edit 6
+                                            (%push (%call 20 (%slot 31))
+                                                   (%call 2 (%edit 6 [(%slot 125) (%slot 14)] (%battery))))
+                                            (%self))))))
+                               (%call 2 (%self)))))
+               (%self) ])
+
+      ;  Arms cell at axis 5 of [core m]:
+      ;    head (axis 10 of [core m]) = +add arm
+      ;    tail (axis 11 of [core m]) starts with `8 [1 0] ...` — the
+      ;    +dec arm wrapped as a noun-positioned formula.
+      ;  NOTE: axis 11 is also where the main body lives — it shares a
+      ;  prefix with the +dec wrapper, hence the structural mix here.
+      [ (%push (%const [0 0])
+               [ (%arm
+                   ;  +add body — uses +dec at axis 21.
+                   (%if (%eq (%const 0) (%slot 12))
+                        (%slot 13)
+                        (%call 2
+                          (%edit 6
+                            [ (%push (%call 21 (%context))
+                                     (%call 2 (%edit 6 (%slot 28) (%battery))))
+                              (%inc (%slot 13)) ]
+                            (%self)))))
+                 (%self) ])
+
+        ;  +dec arm (axis 21 of [core m]) — identical body to dec.nasm.
+        (%push (%const 0)
+               [ (%arm
+                   (%if (%eq (%const 0) (%sample))
+                        (%crash)
+                        (%push (%const 0)
+                               (%push (%arm
+                                        (%if (%eq (%slot 30) (%inc (%sample)))
+                                             (%sample)
+                                             (%call 2 (%edit 6
+                                                              (%inc (%sample))
+                                                              (%self)))))
+                                      (%call 2 (%self))))))
+                 (%self) ]) ]
+
+      ;  Main body (also at axis 11): build the anonymous |= gate, then
+      ;  call its battery with m installed at sample.
+      (%push (%push (%const 0)
+                    [ (%arm
+                        ;  |= gate body: =/ t=1; |- ...
+                        (%push (%const 1)
+                               (%push (%arm
+                                        ;  |- loop on n (axis 30), t (sample).
+                                        ;  if n == 1 -> t
+                                        ;  else recurse n := dec(n), t := mul(t, n)
+                                        (%if (%eq (%slot 30) (%const 1))
+                                             (%sample)
+                                             (%call 2
+                                               (%edit 30
+                                                 (%push (%call 21 (%slot 31))
+                                                        (%call 2 (%edit 6 (%slot 62) (%battery))))
+                                                 (%edit 6
+                                                   (%push (%call 4 (%slot 31))
+                                                          (%call 2 (%edit 6 [(%slot 14) (%slot 62)] (%battery))))
+                                                   (%self))))))
+                                      (%call 2 (%self)))))
+                      (%self) ])
+             (%call 2 (%edit 6 (%context) (%battery)))) ])
+
+  (%call 11 (%self)))