code wiki / _hdl_build / _attempt_loop_gate_authored.nx
_attempt_loop_gate_authored.nx source
↩ module page · 424 lines · 17882 B
1// _attempt_loop_gate_authored.nx -- gate for the Warden attempt loop
2// (X-Q-003 rung 1 + the X-Q-006 SPEC build route). Drives wd_beat on a
3// SCRATCH queue through the REAL sovereign lane, the REAL nx_reconcile elf
4// and the REAL nx_auto_builder elf -- no mocks. Six beats:
5// beat1: pick NOEXEC1 (w9, no recipe) -> RAISED to NOVEL, and the best
6// covered row REDR1 (w8, recipe exits 7, no marker) is attempted in
7// the SAME beat -> RED (raise never wastes a beat; fail-loud).
8// beat2: LIAR1 (w7, recipe exits 0 but marker says RED) -> RED. THE
9// anti-fake-green proof: exit codes never decide, evidence does.
10// beat3: GREEN1 (w6, recipe appends its green marker) -> nx_reconcile
11// flips it DONE on evidence -> GREEN.
12// beat4: SPEC1 (w5, ||SPEC= build spec) -> auto-builder classifier-routes
13// the shape, AUTHORS _pe_alspec1 + KAT, AUTOBUILD GREEN evidence,
14// reconcile flips DONE: a queue row BUILT a new module hands-off.
15// beat5: BADSPEC1 (w4, malformed spec) -> auto-builder REFUSES (exit 2),
16// marker never green -> RED (bad specs die loud).
17// beat6: nothing runnable -> IDLE row.
18// Staleness killer: seed verdict=STALE lines for the green/liar anchors so a
19// previous run's marker lines can never pre-flip a row (last-line-wins).
20// Plus conf KATs (parse + default-on-absent).
21// Markers: ALG-* checks; final ALGATE row -> knowledge/status/attempt_loop.log
22// license_tier: ORIGINAL
23
24import "nx_wd_core.nx"
25
26func alg_p(s: *u8) -> i64 { var n: i64=0; while s[n]!=(0 as u8){n=n+1} sys_write(1,s,n); return 0 }
27func alg_f(fd: i64, s: *u8) -> i64 { var n: i64=0; while s[n]!=(0 as u8){n=n+1} sys_write(fd,s,n); return 0 }
28
29func alg_chk(label: *u8, ok: i64, bad: *i64) -> i64 {
30 alg_p("ALG-" as *u8)
31 alg_p(label)
32 if ok == 1 { alg_p(" ok\n" as *u8) } else { alg_p(" BAD\n" as *u8); bad[0] = bad[0] + 1 }
33 return 0
34}
35
36func alg_seed_queue(qp: *u8) -> i64 {
37 let fd: i64 = sys_openat_wr(qp, 0x1a4)
38 if fd < 0 { return 0 }
39 alg_f(fd, "# scratch queue for the attempt-loop gate\n" as *u8)
40 alg_f(fd, "NOEXEC1\tX\t9\tS\tWarden\tTODO\t-\tprose-gate-no-recipe\tuncovered row must raise\n" as *u8)
41 alg_f(fd, "REDR1\tX\t8\tS\tWarden\tTODO\t-\tg||MARK=/tmp/_wd_toy.log::WDTOYRED::verdict=GREEN||EXEC=nx_wd_toy_red\trecipe fails loud\n" as *u8)
42 alg_f(fd, "LIAR1\tX\t7\tS\tWarden\tTODO\t-\tg||MARK=/tmp/_wd_toy.log::WDTOYLIAR::verdict=GREEN||EXEC=nx_wd_toy_liar\tfake-green dies\n" as *u8)
43 alg_f(fd, "GREEN1\tX\t6\tS\tWarden\tTODO\t-\tg||MARK=/tmp/_wd_toy.log::WDTOYGREEN::verdict=GREEN||EXEC=nx_wd_toy_green\tcovered hands-off\n" as *u8)
44 alg_f(fd, "SPEC1\tX\t5\tS\tWarden\tTODO\t-\tg||MARK=knowledge/status/auto_builder.log::AUTOBUILD name=_pe_alspec1 ::verdict=GREEN||SPEC=knowledge/specs/build_alspec1.spec\trow that BUILDS\n" as *u8)
45 alg_f(fd, "BADSPEC1\tX\t4\tS\tWarden\tTODO\t-\tg||MARK=/tmp/_wd_toy.log::NEVERANCHOR::verdict=GREEN||SPEC=knowledge/specs/build_alspec_bad.spec\tmalformed spec dies loud\n" as *u8)
46 // pad so later shorter rewrites can never leave a stale tail even if an
47 // earlier run wrote a longer scratch file (no O_TRUNC in the wrapper)
48 var i: i64 = 0
49 while i < 16 { alg_f(fd, "\n" as *u8); i = i + 1 }
50 sys_close(fd)
51 return 1
52}
53
54func alg_seed_stale() -> i64 {
55 let fd: i64 = sys_openat_append("/tmp/_wd_toy.log" as *u8, 0x1a4)
56 if fd < 0 { return 0 }
57 alg_f(fd, "WDTOYGREEN verdict=STALE\n" as *u8)
58 alg_f(fd, "WDTOYLIAR verdict=STALE\n" as *u8)
59 sys_close(fd)
60 // the SPEC fixture's evidence log is the REAL auto_builder.log (its tail
61 // already holds gate-fixture rows by precedent); a STALE row here makes
62 // last-line-wins deterministic across gate re-runs
63 let fa: i64 = sys_openat_append("knowledge/status/auto_builder.log" as *u8, 0x1a4)
64 if fa < 0 { return 0 }
65 alg_f(fa, "AUTOBUILD name=_pe_alspec1 shape=12 ms=0 verdict=STALE\n" as *u8)
66 // X-Q-006 SHAPEB: seed the httpsm anchor STALE too so a prior run's GREEN
67 // line can never pre-flip SHAPEB (last-line-wins determinism, same as A)
68 alg_f(fa, "AUTOBUILD name=_pe_httpsm shape=18 ms=0 verdict=STALE\n" as *u8)
69 sys_close(fa)
70 return 1
71}
72
73// X-Q-006: a SEPARATE scratch queue holding ONLY the two DISTINCT-shape SPEC
74// rows. Kept apart from the baseline 6-beat queue so beats 1-6 (the X-Q-003 /
75// X-Q-006a ALGATE anchor) stay byte-identical -- the new rows can never alter
76// an_pick during the baseline run. SHAPEA carries in_framed -> classifier
77// shape 12 (WIRE_TLV); SHAPEB carries in_table+in_state -> classifier shape 18
78// (STATE_MACHINE). The shape is chosen by plc_match_spec on the feature
79// vector, NEVER hardcoded -- two distinct shapes from two distinct vectors is
80// the structural anti-hardcode proof. Both routes go through the SAME wd_beat
81// lane -> auto_builder authors + KAT-greens -> reconcile flips DONE hands-off.
82func alg_seed_xq006_queue(qp: *u8) -> i64 {
83 let fd: i64 = sys_openat_wr(qp, 0x1a4)
84 if fd < 0 { return 0 }
85 alg_f(fd, "# X-Q-006 covered-SHAPE scratch queue (two distinct classifier shapes)\n" as *u8)
86 alg_f(fd, "SHAPEA\tX\t3\tS\tWarden\tTODO\t-\tg||MARK=knowledge/status/auto_builder.log::AUTOBUILD name=_pe_alspec1 ::verdict=GREEN||SPEC=knowledge/specs/build_alspec1.spec\tcovered-shape route A\n" as *u8)
87 alg_f(fd, "SHAPEB\tX\t2\tS\tWarden\tTODO\t-\tg||MARK=knowledge/status/auto_builder.log::AUTOBUILD name=_pe_httpsm ::verdict=GREEN||SPEC=knowledge/specs/build_httpsm.spec\tcovered-shape route B\n" as *u8)
88 var i: i64 = 0
89 while i < 16 { alg_f(fd, "\n" as *u8); i = i + 1 }
90 sys_close(fd)
91 return 1
92}
93
94// status byte of row <id> in queue qp (84=T 78=N 68=D 82=R), -1 absent
95func alg_status_of(qp: *u8, id: *u8) -> i64 {
96 let cx: *i64 = an_newcx()
97 let rows: i64 = an_load(qp, cx)
98 if rows <= 0 { return 0 - 1 }
99 let r: i64 = an_find(cx, id)
100 if r < 0 { return 0 - 1 }
101 let st: *i64 = cx[4] as *i64
102 return st[r]
103}
104
105// count occurrences of pat in file at path (-1 file absent)
106func alg_count(path: *u8, pat: *u8) -> i64 {
107 let buf: *u8 = sys_mmap(262144)
108 let fd: i64 = sys_openat_rd(path)
109 if fd < 0 { return 0 - 1 }
110 var n: i64 = 0
111 var r: i64 = sys_read(fd, buf, 262143)
112 while r > 0 { n = n + r; r = sys_read(fd, buf + n, 262143 - n) }
113 sys_close(fd)
114 var pl: i64 = 0
115 while pat[pl] != (0 as u8) { pl = pl + 1 }
116 var c: i64 = 0
117 var i: i64 = 0
118 while i < n {
119 if wd_at(buf, n, i, pat, pl) == 1 { c = c + 1 }
120 i = i + 1
121 }
122 return c
123}
124
125// beat-state checks split per beat group (flat ifs, bounded call counts --
126// the ~10-call function-size law from the pulse lesson)
127func alg_beats_a(wcx: *i64, qp: *u8, badv: *i64) -> i64 {
128 let rc1: i64 = wd_beat(wcx)
129 var c: i64 = 0
130 if rc1 == 1 { c = 1 }
131 alg_chk("B1-RC" as *u8, c, badv)
132 c = 0
133 if alg_status_of(qp, "NOEXEC1" as *u8) == 78 { c = 1 }
134 alg_chk("B1-RAISED-NOVEL" as *u8, c, badv)
135 c = 0
136 if alg_status_of(qp, "REDR1" as *u8) == 82 { c = 1 }
137 alg_chk("B1-REDROW" as *u8, c, badv)
138
139 let rc2: i64 = wd_beat(wcx)
140 c = 0
141 if rc2 == 1 { c = 1 }
142 alg_chk("B2-RC" as *u8, c, badv)
143 c = 0
144 if alg_status_of(qp, "LIAR1" as *u8) == 82 { c = 1 }
145 alg_chk("B2-LIAR-RED" as *u8, c, badv)
146
147 let rc3: i64 = wd_beat(wcx)
148 c = 0
149 if rc3 == 0 { c = 1 }
150 alg_chk("B3-RC" as *u8, c, badv)
151 c = 0
152 if alg_status_of(qp, "GREEN1" as *u8) == 68 { c = 1 }
153 alg_chk("B3-GREEN-DONE" as *u8, c, badv)
154 return 0
155}
156
157// beats 4-6: the SPEC route (rows that BUILD) + the drained IDLE
158func alg_beats_b(wcx: *i64, qp: *u8, badv: *i64) -> i64 {
159 let rc4: i64 = wd_beat(wcx)
160 var c: i64 = 0
161 if rc4 == 0 { c = 1 }
162 alg_chk("B4-RC" as *u8, c, badv)
163 c = 0
164 if alg_status_of(qp, "SPEC1" as *u8) == 68 { c = 1 }
165 alg_chk("B4-SPEC-BUILT-DONE" as *u8, c, badv)
166
167 let rc5: i64 = wd_beat(wcx)
168 c = 0
169 if rc5 == 1 { c = 1 }
170 alg_chk("B5-RC" as *u8, c, badv)
171 c = 0
172 if alg_status_of(qp, "BADSPEC1" as *u8) == 82 { c = 1 }
173 alg_chk("B5-BADSPEC-RED" as *u8, c, badv)
174
175 let rc6: i64 = wd_beat(wcx)
176 c = 0
177 if rc6 == 0 { c = 1 }
178 alg_chk("B6-RC" as *u8, c, badv)
179 return 0
180}
181
182// X-Q-006: the shape the auto_builder LANDED for <name>, read from the LAST
183// "AUTOBUILD name=<name> shape=" line in auto_builder.log (last-line-wins, same
184// discipline as alg_count). Returns the integer after shape=, or -1 absent.
185// This proves the route was CLASSIFIER-driven: the gate never asserts a shape,
186// it reads back whatever plc_match_spec actually chose for the feature vector.
187func alg_shape_of(name: *u8) -> i64 {
188 let path: *u8 = "knowledge/status/auto_builder.log" as *u8
189 let buf: *u8 = sys_mmap(262144)
190 let fd: i64 = sys_openat_rd(path)
191 if fd < 0 { return 0 - 1 }
192 var n: i64 = 0
193 var r: i64 = sys_read(fd, buf, 262143)
194 while r > 0 { n = n + r; r = sys_read(fd, buf + n, 262143 - n) }
195 sys_close(fd)
196 // build the prefix "AUTOBUILD name=<name> shape=" so we land on this name's
197 // line and not a different name whose value happens to embed <name>
198 let pre: *u8 = sys_mmap(256)
199 var pl: i64 = 0
200 let a: *u8 = "AUTOBUILD name=" as *u8
201 var ai: i64 = 0
202 while a[ai] != (0 as u8) { pre[pl] = a[ai]; pl = pl + 1; ai = ai + 1 }
203 var ni: i64 = 0
204 while name[ni] != (0 as u8) { pre[pl] = name[ni]; pl = pl + 1; ni = ni + 1 }
205 let b: *u8 = " shape=" as *u8
206 var bi: i64 = 0
207 while b[bi] != (0 as u8) { pre[pl] = b[bi]; pl = pl + 1; bi = bi + 1 }
208 pre[pl] = 0 as u8
209 var found: i64 = 0 - 1
210 var i: i64 = 0
211 while i < n {
212 if wd_at(buf, n, i, pre, pl) == 1 { found = i + pl }
213 i = i + 1
214 }
215 if found < 0 { return 0 - 1 }
216 var v: i64 = 0
217 var any: i64 = 0
218 var go: i64 = 1
219 var p: i64 = found
220 while go == 1 {
221 if p >= n { go = 0 } else {
222 let ch: i64 = buf[p] as i64
223 if ch >= 48 { if ch <= 57 { v = v * 10 + (ch - 48); any = 1; p = p + 1 } else { go = 0 } } else { go = 0 }
224 }
225 }
226 if any == 0 { return 0 - 1 }
227 return v
228}
229
230// X-Q-006 beats 7-8: route the two DISTINCT-shape SPEC rows through the SAME
231// wd_beat lane (a fresh wcx over the SEPARATE xq006 queue qp6, so the baseline
232// queue/ALGATE stay untouched). Each must reach DONE via nx_reconcile (status
233// byte 68), then the two LANDED classifier shapes must DIFFER -- the structural
234// proof that plc_match_spec routed on the feature vector (a hardcoded shape
235// cannot emit two distinct shapes from two distinct vectors). Hands-off: zero
236// tutor step between the queue row and the gated capability.
237func alg_beats_c(wcx: *i64, qp6: *u8, badv6: *i64) -> i64 {
238 // beat 7 -> SHAPEA (w3, highest), beat 8 -> SHAPEB (w2)
239 let rc7: i64 = wd_beat(wcx)
240 var c: i64 = 0
241 if rc7 == 0 { c = 1 }
242 alg_chk("XQ006-B7-RC" as *u8, c, badv6)
243 c = 0
244 if alg_status_of(qp6, "SHAPEA" as *u8) == 68 { c = 1 }
245 alg_chk("XQ006-A-DONE" as *u8, c, badv6)
246
247 let rc8: i64 = wd_beat(wcx)
248 c = 0
249 if rc8 == 0 { c = 1 }
250 alg_chk("XQ006-B8-RC" as *u8, c, badv6)
251 c = 0
252 if alg_status_of(qp6, "SHAPEB" as *u8) == 68 { c = 1 }
253 alg_chk("XQ006-B-DONE" as *u8, c, badv6)
254
255 let sa: i64 = alg_shape_of("_pe_alspec1" as *u8)
256 let sb: i64 = alg_shape_of("_pe_httpsm" as *u8)
257 c = 0
258 if sa > 0 { c = 1 }
259 alg_chk("XQ006-A-SHAPE-POS" as *u8, c, badv6)
260 c = 0
261 if sb > 0 { c = 1 }
262 alg_chk("XQ006-B-SHAPE-POS" as *u8, c, badv6)
263 c = 0
264 if sa != sb { if sa > 0 { if sb > 0 { c = 1 } } }
265 alg_chk("XQ006-DISTINCT-SHAPES" as *u8, c, badv6)
266 // stash the two landed shapes for the verdict line (badv6[1]=sa badv6[2]=sb)
267 // and a ran-flag (badv6[3]=1) so a seed-fail before this point can never
268 // be mistaken for a clean GREEN verdict.
269 badv6[1] = sa
270 badv6[2] = sb
271 badv6[3] = 1
272 return 0
273}
274
275func main() -> i64 {
276 let badv: *i64 = sys_mmap(16) as *i64
277 badv[0] = 0
278 alg_p("=== attempt-loop gate (X-Q-003 rung 1) ===\n" as *u8)
279
280 // reconcile elf must be staged durable (the loop's judge)
281 let rec: *u8 = "_offc/nx_reconcile.elf" as *u8
282 let probe: i64 = sys_openat_rd(rec)
283 if probe < 0 {
284 alg_p("ALGATE verdict=RED reason=reconcile-elf-absent\n" as *u8)
285 sys_exit(9)
286 }
287 sys_close(probe)
288
289 // conf KATs: parse a seeded conf; default on absent conf
290 let cfp: *u8 = "/tmp/_al_conf.conf" as *u8
291 let cf: i64 = sys_openat_wr(cfp, 0x1a4)
292 if cf >= 0 { alg_f(cf, "exec_deadline_ms=120000\n" as *u8); sys_close(cf) }
293 var ck: i64 = 0
294 if wd_conf_deadline(cfp) == 120000 { ck = 1 }
295 alg_chk("CONF-PARSE" as *u8, ck, badv)
296 ck = 0
297 if wd_conf_deadline("/tmp/_al_no_such.conf" as *u8) == WD_DEADLINE_DEFAULT { ck = 1 }
298 alg_chk("CONF-DEFAULT" as *u8, ck, badv)
299
300 // scratch world
301 let qp: *u8 = "/tmp/_al_scratch_queue.tsv" as *u8
302 let rl: *u8 = "/tmp/_al_results.log" as *u8
303 if alg_seed_queue(qp) != 1 { alg_p("ALGATE verdict=RED reason=seed-fail\n" as *u8); sys_exit(98) }
304 alg_seed_stale()
305 let base_raised: i64 = alg_count(rl, "verdict=RAISED" as *u8)
306 let base_red: i64 = alg_count(rl, "verdict=RED rc=" as *u8)
307 let base_green: i64 = alg_count(rl, "verdict=GREEN rc=" as *u8)
308 let base_idle: i64 = alg_count(rl, "verdict=IDLE" as *u8)
309 let wcx: *i64 = wd_newwcx(qp, rl, "_offc/nx_sov_build_run.elf" as *u8, rec,
310 "_offc/nx_auto_builder.elf" as *u8, 600000)
311
312 alg_beats_a(wcx, qp, badv)
313 alg_beats_b(wcx, qp, badv)
314
315 // audit-trail counts (this run's delta over any prior runs; absent file
316 // counts as 0 prior). These count the FIRST SIX beats only -- the X-Q-006
317 // shape beats (7-8) run AFTER this block so the 18/18 ALGATE arithmetic
318 // (GREEN-2 etc.) stays byte-identical to X-Q-003/X-Q-006a.
319 var br: i64 = base_raised
320 if br < 0 { br = 0 }
321 var bd: i64 = base_red
322 if bd < 0 { bd = 0 }
323 var bg: i64 = base_green
324 if bg < 0 { bg = 0 }
325 var bi: i64 = base_idle
326 if bi < 0 { bi = 0 }
327 var c2: i64 = 0
328 let now_raised: i64 = alg_count(rl, "verdict=RAISED" as *u8)
329 if now_raised - br == 1 { c2 = 1 }
330 alg_chk("ROWS-RAISED-1" as *u8, c2, badv)
331 c2 = 0
332 let now_red: i64 = alg_count(rl, "verdict=RED rc=" as *u8)
333 if now_red - bd == 3 { c2 = 1 }
334 alg_chk("ROWS-RED-3" as *u8, c2, badv)
335 c2 = 0
336 let now_green: i64 = alg_count(rl, "verdict=GREEN rc=" as *u8)
337 if now_green - bg == 2 { c2 = 1 }
338 alg_chk("ROWS-GREEN-2" as *u8, c2, badv)
339 c2 = 0
340 let now_idle: i64 = alg_count(rl, "verdict=IDLE" as *u8)
341 if now_idle - bi == 1 { c2 = 1 }
342 alg_chk("ROWS-IDLE-1" as *u8, c2, badv)
343
344 // verdict row -> the organ's status log (the row X-Q-003's MARK reads)
345 let lg: i64 = sys_openat_append("knowledge/status/attempt_loop.log" as *u8, 0x1a4)
346 var rcg: i64 = 0
347 if badv[0] == 0 {
348 alg_p("ALGATE beats=6 checks=18/18 verdict=GREEN\n" as *u8)
349 if lg >= 0 {
350 alg_f(lg, "ALGATE beats=6 checks=18/18 verdict=GREEN epoch=" as *u8)
351 wd_wn(lg, sys_now_realtime_sec())
352 alg_f(lg, "\n" as *u8)
353 }
354 } else {
355 alg_p("ALGATE verdict=RED bad=" as *u8)
356 wd_wn(1, badv[0])
357 alg_p("\n" as *u8)
358 if lg >= 0 {
359 alg_f(lg, "ALGATE verdict=RED bad=" as *u8)
360 wd_wn(lg, badv[0])
361 alg_f(lg, "\n" as *u8)
362 }
363 rcg = badv[0]
364 }
365 if lg >= 0 { sys_close(lg) }
366
367 // X-Q-006: AFTER the ALGATE block (so the 18/18 arithmetic is untouched),
368 // run beats 7-8 = the multi-shape classifier-driven route through the SAME
369 // wd_beat lane, then emit a SEPARATE durable XQ006GATE anchor. Hands-off:
370 // the auto_builder authors + KAT-greens each shape, reconcile flips DONE.
371 alg_p("=== X-Q-006 covered-SHAPE routing (beats 7-8) ===\n" as *u8)
372 let badv6: *i64 = sys_mmap(32) as *i64
373 badv6[0] = 0
374 badv6[1] = 0
375 badv6[2] = 0
376 badv6[3] = 0
377 // SEPARATE scratch world for the shape beats (baseline queue untouched)
378 let qp6: *u8 = "/tmp/_al_xq006_queue.tsv" as *u8
379 let rl6: *u8 = "/tmp/_al_xq006_results.log" as *u8
380 if alg_seed_xq006_queue(qp6) != 1 {
381 alg_p("XQ006GATE verdict=RED reason=seed-fail\n" as *u8)
382 if rcg == 0 { rcg = 97 }
383 } else {
384 let wcx6: *i64 = wd_newwcx(qp6, rl6, "_offc/nx_sov_build_run.elf" as *u8, rec,
385 "_offc/nx_auto_builder.elf" as *u8, 600000)
386 alg_beats_c(wcx6, qp6, badv6)
387 }
388 // GREEN iff every shape check passed (badv6[0]==0) AND the beats actually
389 // ran (badv6[3]==1 -- a seed-fail can never masquerade as a clean pass).
390 var xqg: i64 = 0
391 if badv6[0] == 0 { if badv6[3] == 1 { xqg = 1 } }
392 let lg2: i64 = sys_openat_append("knowledge/status/attempt_loop.log" as *u8, 0x1a4)
393 if xqg == 1 {
394 alg_p("XQ006GATE shapes=" as *u8)
395 wd_wn(1, badv6[1])
396 alg_p("," as *u8)
397 wd_wn(1, badv6[2])
398 alg_p(" distinct=1 authored=2 kat_green=2 verdict=GREEN\n" as *u8)
399 if lg2 >= 0 {
400 alg_f(lg2, "XQ006GATE shapes=" as *u8)
401 wd_wn(lg2, badv6[1])
402 alg_f(lg2, "," as *u8)
403 wd_wn(lg2, badv6[2])
404 alg_f(lg2, " distinct=1 authored=2 kat_green=2 verdict=GREEN epoch=" as *u8)
405 wd_wn(lg2, sys_now_realtime_sec())
406 alg_f(lg2, "\n" as *u8)
407 }
408 } else {
409 var xb: i64 = badv6[0]
410 if xb == 0 { xb = 99 }
411 alg_p("XQ006GATE verdict=RED bad=" as *u8)
412 wd_wn(1, xb)
413 alg_p("\n" as *u8)
414 if lg2 >= 0 {
415 alg_f(lg2, "XQ006GATE verdict=RED bad=" as *u8)
416 wd_wn(lg2, xb)
417 alg_f(lg2, "\n" as *u8)
418 }
419 if rcg == 0 { rcg = xb }
420 }
421 if lg2 >= 0 { sys_close(lg2) }
422 sys_exit(rcg)
423 return rcg
424}