examples: the desk calculator -- 12 34 + . -> > 0046

The five stage drivers are now one program.  examples/calc.r8asm is a two
register desk calculator: digits build a number, + - * / set the pending
operator, . prints the accumulator (`> 0046` + newline) and , clears it.  EOF (the
0 that inp returns when the input runs out) erases the loop counter, so the loop
ends and the tape simply runs off its end.

    in 12 34 + .   out 62 32 48 48 52 54 10       (> 0046)   314777 steps
    in 2047 3 / .  out 62 32 48 54 56 50 10       (> 0682)   362281
    in 7 6 * .     out 62 32 48 48 52 50 10       (> 0042)   299352
    in 9 4 - .     out 62 32 48 48 48 53 10       (> 0005)   292030
    both of the first two in one session          659759 steps

62585 characters, under ROT-8-viz's 65536 for the first time in this series, so
the whole calculator can be cross-checked against the reference machine later.
tape_run and derive agree, r8forge_examples_test passes all 16 examples, ctest 8/8.

Four deliberate departures from docs/calc.md, each forced by a measurement:

  * settle before loading the new operand, and `.` settles too -- the literal
    order printed 0034 for 12 34 + . because the space arrives before the + and
    overwrites A;  * the operator is one-hot (1 2 4 8) so settlement is four flat
    mutually exclusive biz blocks;  * the loop quota is refilled each round
    (clb_ones can only make _CELL_SIZE ones, 11 here) instead of a fixed 128;
  * three cell moves worth ~24k of tape: clb_undigits scratch 35..45 -> 5..15
    (next to the window it decodes), result/display target 0 -> 20 (adjacent
    scratch makes the %synth blocks shorter), 35..45 reused as one shot flags.

Also found a trap worth remembering: a biz body that ended with `.tp B1; set_0`
(condition cell is FLAG) has net displacement +2, and only on the skipped path
does it desynchronise every later .tp -- the symptom was `-` and `,` sending the
tape into the weeds.  Net displacement 0 on both paths, always.
This commit is contained in:
dsh committed 2026-11-15 16:03:45 +08:00
1 parent f9821f8989
commit b497bf0637
4 files changed
+513 -3

No files matched your search

+1 -1
View File
@@ -32,7 +32,7 @@ cmake --build build --config Release
# 当前基线:都通过,别弄坏(`ctest --test-dir build -j 4` 一次跑完 8 条,约 9 秒)
r8forge asm/test.r8asm # 64513 字符(每个标准宏至少一次 + 每个语言特性)
r8forge_byte_op_test # 21 项(divmod 16384 组、digits 2048、undigits 4096)
r8forge_examples_test # 15 个 example + asm/test.r8asm,核对头部 `; out`/`; in`
r8forge_examples_test # 16 个 example + asm/test.r8asm,核对头部 `; out`/`; in`
r8forge_macro_docs_test # 48 macros in 22 files
r8forge_synth_test examples/full_add.r8asm # all eight combinations ok
r8forge_derive verify_loop.r8asm -1 0=5 # out 5 0
+1 -1
View File
@@ -84,7 +84,7 @@ src/r8asm.cc 汇编器实现
src/synth.cc 真值表 -> 搜索
asm/ 标准库(48 个宏,含 8 个 %synth 合成块)
drv/ 单点验证驱动(喂固定输入跑一个宏,看 out/stat)
examples/ 15 个能跑的例程:每组宏一份 + %synth 的几种写法 + 一个交互例程
examples/ 16 个能跑的例程:每组宏一份 + %synth 的几种写法 + 一个交互例程
tests/ 汇编器 / 虚拟机 / 字节级 / 例程 / 文档格式 自检
docs/ 设计笔记(长文)
.r8forge_cache/ 合成结果缓存(已入库)
+1 -1
View File
@@ -750,7 +750,7 @@ r8forge_tape_run t.rot8 # 打印 out 和步数
|---|---|---|
| `r8forge_byte_op_test` | 21 个测试项 = 20 个宏(`clb_neg_nc` 的 Ci=1 / Ci=0 各算一项),见 §7.1、§7.2、§7.5、§7.6、§7.7、§7.9、§8、§9 | **按返回值**:穷举 0..255(`clb_add_ip` 2048 抽样、`clb_mul` 65536 全穷举、`clb_ones` 12 个计数全穷举、`clb_divmod` 8 个除数 × 全部 2048 个被除数 = 16384 组全穷举、`clb_digits` 全部 2048 个值全穷举、`clb_undigits` 2048 个值 × 干净/高位垃圾 2 种 = 4096 组全穷举),任一不符即退出码非 0 |
| `r8forge_synth_test examples/full_add.r8asm` | `%synth` 端到端:汇编 + 跑 8 种输入 | `all eight combinations ok` |
| `r8forge_examples_test` | `examples/` 里全部 15 个程序(10 组宏例程 + 4 个 `%synth` 例子 + 1 个交互例程,见 §10.3)**加上 `asm/test.r8asm`**(§10.2) | **按返回值**:每个头部 `; out ...` 与实跑 `out` 逐项相等,缺这一行也算失败;写了 `; in ...` 的先把那串字符喂给 `inp` |
| `r8forge_examples_test` | `examples/` 里全部 16 个程序(10 组宏例程 + 4 个 `%synth` 例子 + 交互例程 + 计算器,见 §10.3)**加上 `asm/test.r8asm`**(§10.2) | **按返回值**:每个头部 `; out ...` 与实跑 `out` 逐项相等,缺这一行也算失败;写了 `; in ...` 的先把那串字符喂给 `inp` |
| `r8forge verify_clb_bit_add_nc.r8asm` | 4 cell 加法切片(进位进→出) | 单点:`0+0+Ci` |
| `r8forge verify_clb_bit_inc_nc.r8asm` | 3 cell 自增切片 | 单点 |
| `r8forge_derive verify_loop.r8asm -1 0=N` | 动态循环:`N=0..11` 时循环体跑 `N` 次(`A = N`、`C = 0`) | 逐值 `out` |
+510
View File
@@ -0,0 +1,510 @@
; in 12 34 + .
; out 62 32 48 48 52 54 10
;
; calc —— 桌上计算器 stage 5(docs/calc.md §3 第 5 步):把前面四块拼成一条常驻
; 纸带。两个寄存器 A(累加器)和 P(待结算的操作数),没有栈:`inp` 一个字符、
; 分派、算、`out` 全都在一条 `loop`/`endloop` 里,所以三者各只展开一次。
;
; 命令协议(docs/calc.md §1):
; '0'..'9' 攒进 4 位 ASCII 窗口(REG..REG+3,高位在低地址,见 stage 2)
; '*' '+' '-' '/' 把运算符记到 OP
; '.' 结算还没消费的 OP、显示 A、再把 A 留在 P 里
; ',' 清 A、P、OP
; 空格/CR 等 只当数字的终止符
; 0(EOF) erase 主循环配额,跳出循环,纸带自然跑完
;
; 验证(r8forge_derive 和 r8forge_tape_run 两份实现逐项一致):
; build/Release/r8forge.exe examples/calc.r8asm > calc.rot8 ; 62585 字符
; build/Release/r8forge_tape_run.exe calc.rot8 -i "12 34 + ."
; -> out 62 32 48 48 52 54 10 314777 步 "> 0046\n"
; build/Release/r8forge_tape_run.exe calc.rot8 -i "2047 3 / ."
; -> out 62 32 48 54 56 50 10 362281 步 "> 0682\n"
; build/Release/r8forge_tape_run.exe calc.rot8 -i "7 6 * ."
; -> out 62 32 48 48 52 50 10 299352 步 "> 0042\n"
; build/Release/r8forge_tape_run.exe calc.rot8 -i "9 4 - ."
; -> out 62 32 48 48 48 53 10 292030 步 "> 0005\n"
; build/Release/r8forge_tape_run.exe calc.rot8 -i "12 34 + . 2047 3 / ."
; -> out 62 32 48 48 52 54 10 62 32 48 54 56 50 10 (14 个数,659759 步)
;
; "9 4 - ." 这一行和交接说明里写的 `out 62 32 48 48 53 48 10`("> 0050")差两位:
; 9 - 4 = 5,stage 3 的显示把它打成 "0005"(48 48 48 53),所以这里给的是实测值。
; 0050 是 54 - 4 之类的答案,看着像那条期望值抄错了行(或者当年那份实现把窗口
; 挪错了一格);其余四条和 BEHAVIOUR 里的三个例子都逐项对得上。
;
; ------------------------------------------------------------ 四处不得不改的
;
; (1) 结算顺序。按 docs/calc.md 的字面顺序(先把窗口 undigits 进 P,再把"旧 OP"
; 作用到 A 和 P 上),"12 34 + ." 会打出 0034:终结 "34" 的那个空格比 '+' 先到,
; 那会儿 OP 还是 0,结算成 A = P = 34,"12" 被盖掉;等 '+' 真到了,后面已经没有
; 下一个数来触发结算。两寄存器的机器要给出 46,结算只能发生在**新操作数落地
; 之前**(用旧的 P),并且 '.' 必须先把还没消费的 OP 结算掉。所以实际的规则是:
;
; flush(非数字字符 + HAVE 置位):先 A = A op_old P(OP=0 -> A = P),OP 归 0,
; **然后**才 P = clb_undigits(窗口);
; '.':强制走一次 flush(把待结算的 OP 结掉),再 P = A,再显示 A。
;
; 这样 "12 34 +"、"12 34 + 5 * ."(= 230)、"12 34 + . 5 * ."(= 230)都对。
; 代价:不打运算符、连着打两个数再 '.'("12 34 .")显示的是 A 里的 12 而不是
; 刚打完的 34 —— 两格寄存器分不清"新操作数"和"要显示的数",这是这套状态自己
; 的边界(协议里没有这种输入)。
;
; (2) OP 的编码是 one-hot(1 加、2 减、4 乘、8 除、0 无),不是 0..4。结算因此是
; 四条**互斥的单层 biz**(谁命中谁结算,再把"没有运算符"那个默认标志清掉),
; 不用写 if/else 嵌套 —— 嵌套的 `biz`/`rnz` 身体一旦净位移不为 0 就会把后面所有
; `.tp` 指错格(AGENTS.md 第 2 条),这里用扁平分派就是为了不踩它。
;
; (3) 循环配额。SPEC §7.5 的 clb_ones 只保证 A <= _CELL_SIZE,11 位的 cell 里最多
; 11 个 1 —— 计划里的"128 个 1"造不出来。所以配额造满 11 个,循环体每轮用
; `.tp CNT; rol; set_1` 把刚吃掉的那个 1 补回去(配额一直是全 1),EOF 一到
; erase CNT,`endloop` 的 rnz 看到最低位是 0 就退出去。循环次数因此不再有 11 的
; 上限,纸带长度却和次数无关(loop 的记账法见 SPEC §5.1)。
;
; (4) 内存地图。calc_op 那张表,三处挪动,都是为了把纸带压进 65536:
; * clb_undigits 的 11 格草稿从 35..45 挪到 5..15,和 clb_digits 的草稿区
; 叠着放。原表那样放时 REG(1..4)和草稿隔着 30 格,clb_undigits 里的
; .tp 行走把这条宏从 9.6k 撑到 27k 字符。两套草稿本来就不会同时活着
; (显示前会整块擦),叠在一起是免费的。
; * 四个运算的落点和显示目标从 cell 0 挪到 20,紧挨着 A、P、共用草稿块。
; `%synth` 的块是按"参数相邻"搜索出来的,落点放在 0 时每个位级块都要跨
; 20 多格走过去,四个运算从 9.5k 涨到 16.7k 字符。
; * 换出来的 35..45 当一次性分派标志;0 号格放 '\n' 的常量(显示时离 REG 近)。
;
; 实测:这条纸带 62585 字符(`r8forge examples/calc.r8asm` 的输出长度),在
; ROT-8-viz 的 INS_SIZE(65536) 以内,可以拿过去做可视化/第二意见;表头的
; `; in` / `; out` 就是 r8forge_examples_test 用的那一组。
%include "asm/lib.r8asm"
%include "asm/digits.r8asm" ; clb_digits(顺带带进 divmod / add_ip / raw_sub / raw_or)
%include "asm/undigits.r8asm" ; clb_undigits(顺带带进 mul / raw_add_nc)
%include "asm/raw_sub_nc.r8asm" ; clb_sub_nc
%include "asm/mul.r8asm" ; clb_mul
%include "asm/divmod.r8asm" ; clb_divmod
%include "asm/ones.r8asm" ; clb_ones
%include "asm/add_ip.r8asm" ; clb_nonzero / clb_add_ip
%include "asm/not_ip.r8asm" ; clb_not_ip
; Macro load
; %1: Cell operand
; %2: Count value
;
; 先把整格清干净,再 `.xor` 上常数(`.xor` 是异或,不清格就变成和旧值异或)。
%macro load 2
erase %1
.tp %1
.xor %2
%endmacro
; Macro clb_zero_small
; %this: Cell operand
;
; 把只占第 0..3 位的小格(0..15)清成 0:四轮 set_0+ror 正好把四位各扫一遍。
; 比 erase(44 字符)短;前提是第 4 位以上本来就是 0 —— OP 就是这种格子。
%macro clb_zero_small 0
%rep 4
set_0
ror
%endrep
%endmacro
; ---- 内存地图(calc_op 那张表,挪过三处,见文件开头第 (4) 条)----
.var NL 0 ; '\n' = 10(0 号格空出来放它:显示时离 REG 最近)
.var REG 1 ; REG..REG+3:4 位 ASCII 数字窗口,也是 clb_digits 的输出
.var D3 REG+0 ; 窗口最高位
.var D0 REG+3 ; 窗口最低位:新数字写这里
.var S 5 ; S..S+12:clb_digits 的 13 格草稿(显示前整块擦)
.var SU 5 ; SU..SU+10:clb_undigits 的 11 格草稿,和上面那块叠着放
.var BUF 16 ; copy 的缓冲格(每份 copy 前擦一遍;也在 S 区尾部)
.var FO0 17 ; "这一轮没有运算符"的默认标志(也在 S 区尾部)
.var GT 18 ; '>' = 62
.var SP 19 ; ' ' = 32
.var RES 20 ; 四个运算的落点 + 显示目标:clb_digits 会吃掉它
.var A 21 ; 累加器:add/sub 的 A、mul 的 MC、divmod 的 N
.var P 22 ; 待结算的操作数:add/sub 的 B、mul 的 MUL、divmod 的 D
.var SC 23 ; SC..SC+6:四个运算共用的 7 格草稿
.var MCi SC+0 ; 进位格:add/sub 的 Ci = mul 的 Ci = divmod 的 S+0
.var PH SC+1 ; mul 的 PH
.var MCA SC+2 ; mul 的 MCA
.var MS SC+3 ; mul 的 S
.var MT SC+4 ; mul 的 T
.var MF SC+5 ; mul 的 F = divmod 的 buf
.var MNR SC+6 ; mul 的 NR
.var R 30 ; divmod 的余数(只在调用期间有意义)
.var C 31 ; 当前字符
.var HAVE 32 ; 正在攒一个数
.var OP 33 ; 待结算的运算符,one-hot:1 加、2 减、4 乘、8 除、0 无
.var CNT 34 ; 主循环配额(11 个 1,每轮补回来)
.var T 46 ; 分派临时:t = C - 0x2A
; ---- 一次性分派标志:原来 clb_undigits 的草稿区(35..45),现在空出来了 ----
.var FLAG 35 ; 命令树里 if/else 的"这一支走 else"标志
.var B0 36 ; 命令树分派用的 0/1 位
.var B1 37
.var B2 38
.var NEWOP 39 ; 命令解析出来的新 OP(flush 之后才搬进 OP)
.var WANT 40 ; 这一轮要显示
.var RESET 41 ; 这一轮要清 A、P、OP
.var NONDIG 42 ; 这一轮不是数字(要走命令/终止符那一支)
.var ISCMD 43 ; 这一轮真的是六个命令字符之一
; ---- 结算时把 OP 的四位搬进这四个 0/1 格(和命令树的 B0..B2 复用,不冲突:
; 命令树跑完才轮到结算)----
.var F1 B0 ; OP 的 bit0:加
.var F2 B1 ; bit1:减
.var F3 B2 ; bit2:乘
.var F4 44 ; bit3:除
; ================================ 开机 ================================
; 三个常量格和空窗口只造一次。
load GT 62
load SP 32
load NL 10
%for k 4
load REG + k 48
%endfor
; 主循环配额:11 个 1(11 位 cell 能造的上限),循环体每轮补回来。
; clb_ones 要求 A <= _CELL_SIZE;这里 A 就是 11,正好是满格。
.tp T
.xor 11
clb_ones T CNT SC+1 SC+2
; ================================ 主循环 ================================
loop CNT
; ---- 续配额:loop 已经吃掉一个 1 并转了一格,转回来再补一个 ----
; CNT 进来是全 1;set_0+ror 之后是 0b0111...1,rol 回去成 0b111...0,
; set_1 补成 0b111...1 —— 配额又满了,下一轮照旧。
.tp CNT
rol
set_1
; ---- 读一个字符 ----
.tp C
inp
; ---- EOF:字符 0 就是输入用完了 ----
; clb_nonzero 给出"整格非零",clb_not_ip 把最低位取反 -> (C == 0)。
; 条件格借 R(divmod 的余数,这里闲着),clb_nonzero 的草稿格借 SC+0。
.tp MCi
set_0 ; 草稿格只要求最低位干净
clb_nonzero C R MCi ; R 的最低位 = (C != 0),C 保持原样
clb_not_ip R ; R 的最低位 = (C == 0)
.tp R
biz
erase CNT ; 配额清零 -> endloop 的 rnz 不再跳回
erase HAVE ; 输入完了,攒了一半的数不用再结算
.tp R
set_0 ; 吃掉条件(biz/rnz 是循环对)
rnz
; ---- 是不是数字:bit4 == 1(和 stage 1 一样的一次 ror×4 + biz)----
.tp NONDIG
set_1 ; 默认"不是数字";数字那一支会把它清掉
.tp C
%rep 4
ror
%endrep
.tp C
biz
; ---- 数字:窗口整体右移一格,新字符落在 REG+3 ----
; 低地址是高位(stage 2 的约定):REG+0 <- REG+1 <- REG+2 <- REG+3 <- C,
; 从高到低搬,先搬低地址那一格(它的源还没被盖掉)。
%rep 7
ror ; 4 + 7 = 11,转回原字符
%endrep
.tp BUF
erase BUF
.tp REG + 1
copy REG + 0 BUF ; REG+0 <- REG+1
.tp BUF
erase BUF
.tp REG + 2
copy REG + 1 BUF ; REG+1 <- REG+2
.tp BUF
erase BUF
.tp REG + 3
copy REG + 2 BUF ; REG+2 <- REG+3
.tp BUF
erase BUF
.tp C
copy REG + 3 BUF ; REG+3 <- C(新数字)
.tp C
set_0 ; 吃掉条件位(C 不用再留)
.tp HAVE
set_1 ; HAVE = 1
.tp NONDIG
set_0 ; 是数字 -> 不走命令/终止符那一支
.tp C ; 身体回到条件格(净位移 0)
rnz
; 非数字:把 C 转回原字符(数字那一支已经转回来过,再转 7 次对它没意义,
; 它死了;这段在纸带上只出现一次)。
.tp C
%rep 7
ror
%endrep
; ---- 非数字:命令解析 + flush + 命令动作 ----
.tp NONDIG
biz
; 一次性标志先清掉(不是 '.' 时不会有整块擦,得自己清)
.tp ISCMD
set_0
.tp WANT
set_0
.tp RESET
set_0
; ---- 1) 命令解析:t = C - 0x2A,进位出 Ci = (C >= 0x2A) ----
; 先把"新 OP"算进 NEWOP,旧 OP 留给 flush 结算(见文件开头第 (1) 条)。
load SC + 2 42
.tp SC + 1
set_0
.tp SC + 1
set_1 ; 进位入 = 1 -> S = C - 42
clb_sub_nc C SC + 2 T SC + 1
.tp SC + 1
biz ; Ci=1 -> C >= 0x2A:可能是六个命令之一
.tp ISCMD
set_1
; 剥 t 的三位(t 死了,随便破坏)
.tp B0
set_0
.tp B1
set_0
.tp B2
set_0
.tp T
clb_bit_mov B0
.tp T
ror
clb_bit_mov B1
.tp T
ror
clb_bit_mov B2
; ---- 六路判决:t = 0 '*'、1 '+'、2 ','、3 '-'、4 '.'、5 '/' ----
.tp FLAG
set_1
.tp B2
biz ; bit2 = 1 -> t 在 {4,5}
.tp FLAG
set_1
.tp B0
biz ; t == 5 -> '/'
load NEWOP 8
.tp FLAG
set_0
.tp B0
set_0
rnz
.tp FLAG
biz ; t == 4 -> '.'
load NEWOP 0
.tp WANT
set_1
.tp HAVE
set_1 ; 强制走一次 flush,把待结算的 OP 结掉
.tp FLAG
set_0
rnz
.tp B2
set_0
rnz
.tp FLAG
biz ; bit2 = 0 -> t 在 {0,1,2,3}
.tp FLAG
set_1
.tp B1
biz ; bit1 = 1 -> t 在 {2,3}
.tp FLAG
set_1
.tp B0
biz ; t == 3 -> '-'
load NEWOP 2
.tp FLAG
set_0
.tp B0
set_0
rnz
.tp FLAG
biz ; t == 2 -> ','
load NEWOP 0
.tp RESET
set_1
.tp FLAG
set_0
rnz
.tp B1
set_0
rnz
.tp FLAG
biz ; bit1 = 0 -> t 在 {0,1}
.tp FLAG
set_1
.tp B0
biz ; t == 1 -> '+'
load NEWOP 1
.tp FLAG
set_0
.tp B0
set_0
rnz
.tp FLAG
biz ; t == 0 -> '*'
load NEWOP 4
.tp FLAG
set_0
rnz
.tp FLAG ; 这一支的条件格是 FLAG,身体必须回到 FLAG
set_0
rnz
.tp FLAG
set_0
rnz
.tp SC + 1
set_0 ; 吃掉条件(回到条件格)
rnz
; ---- 2) flush:把攒着的数换出来,先把旧 OP 结算掉 ----
.tp HAVE
biz
; ---- 2a) 结算旧 OP:A = A op_old P(OP=0 -> A = P),结果落 RES ----
; OP 是 one-hot,四位各搬一个 0/1 格(clb_bit_mov 会吃掉源的那一位)。
.tp OP
clb_bit_mov F1
.tp OP
ror
clb_bit_mov F2
.tp OP
ror
clb_bit_mov F3
.tp OP
ror
clb_bit_mov F4
.tp FO0
set_1 ; 默认:没有运算符 -> A = P
; 共用草稿块整块擦(mul 要求 7 格全干净;add/sub 只用 SC+0,也要 0)
%for k 7
erase SC + k
%endfor
; 四条互斥的单层判决:命中就结算,并清掉"没有运算符"那个默认标志。
.tp F1
biz
clb_add_nc A P RES MCi
.tp FO0
set_0
.tp F1
set_0
rnz
.tp F2
biz
.tp MCi
set_1 ; 进位入 = 1 -> S = A - P
clb_sub_nc A P RES MCi
.tp FO0
set_0
.tp F2
set_0
rnz
.tp F3
biz
clb_mul A P RES PH MCA MS MCi MT MF MNR
.tp FO0
set_0
.tp F3
set_0
rnz
.tp F4
biz
clb_divmod A P RES R SC
.tp FO0
set_0
.tp F4
set_0
rnz
.tp FO0
biz
; OP == 0:只剩搬运 A = P(先写 RES,下面统一搬进 A)
.tp BUF
erase BUF
.tp P
copy RES BUF
.tp FO0
set_0
rnz
; ---- 2b) RES -> A ----
.tp BUF
erase BUF
.tp RES
copy A BUF
; ---- 2c) 旧 OP 消费掉了 ----
.tp OP
clb_zero_small
; ---- 2d) P = 窗口里的数,窗口复位成 "0000" ----
clb_undigits REG P SU
%for k 4
load REG + k 48
%endfor
; ---- 2e) HAVE = 0 ----
.tp HAVE
set_0
rnz
; ---- 3) 是命令才换 OP ----
.tp ISCMD
biz
.tp BUF
erase BUF
.tp NEWOP
copy OP BUF
.tp ISCMD
set_0
rnz
; ---- 4) ',' 清 A、P(OP 上一步已经归 0)----
.tp RESET
biz
.tp A
erase A
.tp P
erase P
.tp RESET
set_0
rnz
; ---- 5) '.' 显示 A ----
.tp WANT
biz
; 累加器回到 P:下一轮 flush 的"旧操作数"就是它
.tp BUF
erase BUF
.tp A
copy P BUF
; clb_digits 进场要求 REG 和 S 干净(第一遍靠开机,之后每遍都擦)
%for k 4
erase REG + k
%endfor
%for k 13
erase S + k
%endfor
output GT
output SP
clb_digits RES REG S
output REG + 0
output REG + 1
output REG + 2
output REG + 3
output NL
; 窗口复位:clb_digits 把四位数字写进 REG 了
%for k 4
load REG + k 48
%endfor
.tp WANT
set_0 ; 身体回到条件格(WANT 也可能已被整块擦成 0)
rnz
; ---- 身体回到条件格 NONDIG(净位移 0)----
.tp NONDIG
set_0
rnz
endloop CNT