`nx_eg.nx` source

↩ module page · 720 lines · 67591 B
1// nx_eg.nx -- EMITTER-OF-EMITTERS GENERALIZED (X-AUT-006e-GEN, the daemon-class rung).
2// nx_eoe.nx proved the keystone on a BOUNDED shape: it pretty-prints `depth` NESTED COUNTING loops
3// from a single integer -- the SHAPE is baked, only a COUNT is data-driven. THIS organ removes the
4// ceiling: it is the parser's full DUAL -- a GENERIC recursive tree->source pretty-printer that reads a
5// STRUCTURAL-SKELETON-as-DATA table (a flat *i64 node array, same flat-record discipline as
6// nx_http_router's NX_ROUTE_F_*) and emits the matching NishiLang construct for each typed node kind:
7// SEQ / FUNC / DECL / ASSIGN / WHILE / IF / RETURN / STMT_CALL / EMIT. The control-flow STRUCTURE (which
8// loops, which branches, which calls, in what nesting) is now entirely DATA -- so an emitter whose
9// control flow is ABSENT from every prior emitter (a socket bind/listen/`while accept`/fork/flat-if
10// dispatch daemon) can be ORGAN-pretty-printed from its spec, never hand-written. nx_cc then turns that
11// source into machine code (control-flow synthesis DELEGATED to the compiler the team owns).
12//
13// THE MECHANISM SEEDED (one-time, declared, exactly like the EOE keystone in nx_eoe.nx:3-9): ONLY this
14// generic recursive pretty-printer. The BODY of any specific emitter is pretty-printed FROM ITS SPEC
15// TABLE, never hand-written. Dialect rails the walker enforces by construction: flat-ifs only (LM-002 --
16// an IF node holds ONE comparison and a then-seq; there is NO else node, compound guards become a
17// SEQUENCE of flat IFs), no &&/|| in emitted conditions (LM-001 -- a condition is a verbatim ARG string
18// the spec author keeps single-comparison), and any fragment the typed kinds do not model (a struct-cast,
19// a mask-after-shift port byte) rides an NK_EMIT verbatim-line node (the escape hatch, LM-005-safe).
20//
21// USAGE (driven by an in-organ spec selector, no hand-written emitter body):
22//   nx_eg <which> <outbase>   ->  writes runtime/_hdl_build/<outbase>.nx by WALKING spec <which>
23//   which = 0  -> the EOE-equivalent spec (PROOF-1 regression: re-author nx_eoe's depth-2 output shape)
24//   which = 1  -> the DAEMON spec        (PROOF-2: socket/bind/listen/accept/fork/flat-if -> /health 200)
25//   which = 1 tamper>0 -> same daemon spec with one F_ARG0_PTR field flipped (NO-FAKE-GREEN: output MUST
26//                          differ -> KAT RED, proving the control flow + literals are spec-synthesized)
27// Sovereign (nx_cc/nxasm, no gcc/.sh). Additive: nx_eoe.nx untouched. license_tier: ORIGINAL
28import "nx_syscalls.nx"
29const NK_MAGIC_262144: i64 = 262144
30
31// ---- flat *i64 node-record layout (mirrors nx_http_router's NX_ROUTE_F_* discipline) ----
32// One AST node = NK_FIELDS i64 slots. *_PTR fields are (*u8 cast to i64) literal-string fragments;
33// CHILD0/CHILD1/SIB are node indices into the same table (-1 = none).
34const NK_FIELDS:  i64 = 7
35const F_KIND:     i64 = 0
36const F_ARG0:     i64 = 1   // *u8 string fragment (name / cond / lhs / callee / verbatim line)
37const F_ARG1:     i64 = 2   // *u8 string fragment (type / rhs / arglist)
38const F_ARG2:     i64 = 3   // *u8 string fragment (init expr)
39const F_CHILD0:   i64 = 4   // node index (body-seq / then-seq) or -1
40const F_CHILD1:   i64 = 5   // node index (reserved) or -1
41const F_SIB:      i64 = 6   // next sibling node index or -1 (SEQ child-list link)
42
43// ---- sealed node-kind enum ----
44const NK_SEQ:       i64 = 0   // CHILD0 = first child; siblings chained via F_SIB
45const NK_DECL:      i64 = 1   // ARG0 keyword(let/var), ARG1 "name: type", ARG2 init-expr -> "<kw> <name: type> = <init>"
46const NK_ASSIGN:    i64 = 2   // ARG0 lhs, ARG1 rhs -> "<lhs> = <rhs>"
47const NK_WHILE:     i64 = 3   // ARG0 cond, CHILD0 body-seq -> "while <cond> {\n<body>\n}"
48const NK_IF:        i64 = 4   // ARG0 cond, CHILD0 then-seq (FLAT, no else) -> "if <cond> {\n<then>\n}"
49const NK_IF_INLINE: i64 = 5   // ARG0 cond, ARG1 single-stmt -> "if <cond> { <stmt> }" (one-line flat-if)
50const NK_RETURN:    i64 = 6   // ARG0 expr -> "return <expr>"
51const NK_STMT_CALL: i64 = 7   // ARG0 = a bare statement line (call / expr-stmt) emitted verbatim + newline
52const NK_EMIT:      i64 = 8   // ARG0 = a verbatim source line (escape hatch for fragments the kinds don't model)
53const NK_FUNC:      i64 = 9   // ARG0 = full signature head "name(params) -> ret", CHILD0 body-seq
54
55// ---- string-spine helpers (eo_cat / eo_catn idioms reused verbatim from nx_eoe.nx) ----
56func eg_atoi(s: *u8) -> i64 { var n: i64 = 0; var i: i64 = 0; while s[i] != (0 as u8) { if s[i] >= (48 as u8) { if s[i] <= (57 as u8) { n = n * 10 + ((s[i] as i64) - 48) } } i = i + 1 } return n }
57func eg_cat(dst: *u8, off: i64, s: *u8) -> i64 { var i: i64 = 0; while s[i] != (0 as u8) { dst[off+i] = s[i]; i = i + 1 } return off + i }
58func eg_p(s: *u8) -> i64 { var n: i64 = 0; while s[n] != (0 as u8) { n = n + 1 } sys_write(1, s, n); return 0 }
59
60// emit `indent` levels of 4 spaces.
61func eg_indent(buf: *u8, off: i64, indent: i64) -> i64 {
  var o: i64 = off
  var k: i64 = 0
  while k < indent { o = eg_cat(buf, o, "    " as *u8); k = k + 1 }
  return o
66}
67
68// ---- the GENERIC recursive pretty-printer: tree node -> NishiLang source ----
69// Walks spec[idx], emits the matching construct at `indent`, recurses into CHILD0 body-seqs, and (when
70// called on a SEQ) chains F_SIB siblings. This single function IS the synthesizer -- the SHAPE comes
71// entirely from the spec table, not from any per-construct hand code path.
72func eg_emit_node(buf: *u8, off: i64, spec: *i64, idx: i64, indent: i64) -> i64 {
  if idx < 0 { return off }
  let base: i64 = idx * NK_FIELDS
  let kind: i64 = spec[base + F_KIND]
  var o: i64 = off
77
  if kind == NK_SEQ {
      // child-list: walk CHILD0, then follow F_SIB chain. Each child emits at THIS indent.
      var c: i64 = spec[base + F_CHILD0]
      while c >= 0 {
          o = eg_emit_node(buf, o, spec, c, indent)
          c = spec[c * NK_FIELDS + F_SIB]
      }
      return o
  }
  if kind == NK_FUNC {
      o = eg_cat(buf, o, "func " as *u8)
      o = eg_cat(buf, o, spec[base + F_ARG0] as *u8)
      o = eg_cat(buf, o, " {\n" as *u8)
      o = eg_emit_node(buf, o, spec, spec[base + F_CHILD0], indent + 1)
      o = eg_cat(buf, o, "}\n" as *u8)
      return o
  }
  if kind == NK_DECL {
      o = eg_indent(buf, o, indent)
      o = eg_cat(buf, o, spec[base + F_ARG0] as *u8)   // let / var
      o = eg_cat(buf, o, " " as *u8)
      o = eg_cat(buf, o, spec[base + F_ARG1] as *u8)    // "name: type"
      o = eg_cat(buf, o, " = " as *u8)
      o = eg_cat(buf, o, spec[base + F_ARG2] as *u8)    // init
      o = eg_cat(buf, o, "\n" as *u8)
      return o
  }
  if kind == NK_ASSIGN {
      o = eg_indent(buf, o, indent)
      o = eg_cat(buf, o, spec[base + F_ARG0] as *u8)    // lhs
      o = eg_cat(buf, o, " = " as *u8)
      o = eg_cat(buf, o, spec[base + F_ARG1] as *u8)    // rhs
      o = eg_cat(buf, o, "\n" as *u8)
      return o
  }
  if kind == NK_WHILE {
      o = eg_indent(buf, o, indent)
      o = eg_cat(buf, o, "while " as *u8)
      o = eg_cat(buf, o, spec[base + F_ARG0] as *u8)    // cond (single comparison, no &&/||)
      o = eg_cat(buf, o, " {\n" as *u8)
      o = eg_emit_node(buf, o, spec, spec[base + F_CHILD0], indent + 1)
      o = eg_indent(buf, o, indent)
      o = eg_cat(buf, o, "}\n" as *u8)
      return o
  }
  if kind == NK_IF {
      o = eg_indent(buf, o, indent)
      o = eg_cat(buf, o, "if " as *u8)
      o = eg_cat(buf, o, spec[base + F_ARG0] as *u8)    // cond (FLAT, single comparison)
      o = eg_cat(buf, o, " {\n" as *u8)
      o = eg_emit_node(buf, o, spec, spec[base + F_CHILD0], indent + 1)
      o = eg_indent(buf, o, indent)
      o = eg_cat(buf, o, "}\n" as *u8)
      return o
  }
  if kind == NK_IF_INLINE {
      o = eg_indent(buf, o, indent)
      o = eg_cat(buf, o, "if " as *u8)
      o = eg_cat(buf, o, spec[base + F_ARG0] as *u8)    // cond
      o = eg_cat(buf, o, " { " as *u8)
      o = eg_cat(buf, o, spec[base + F_ARG1] as *u8)    // single stmt
      o = eg_cat(buf, o, " }\n" as *u8)
      return o
  }
  if kind == NK_RETURN {
      o = eg_indent(buf, o, indent)
      o = eg_cat(buf, o, "return " as *u8)
      o = eg_cat(buf, o, spec[base + F_ARG0] as *u8)
      o = eg_cat(buf, o, "\n" as *u8)
      return o
  }
  if kind == NK_STMT_CALL {
      o = eg_indent(buf, o, indent)
      o = eg_cat(buf, o, spec[base + F_ARG0] as *u8)    // full call statement
      o = eg_cat(buf, o, "\n" as *u8)
      return o
  }
  if kind == NK_EMIT {
      // verbatim line (escape hatch) -- ARG0 is the FULL line WITHOUT indentation; we add indent.
      o = eg_indent(buf, o, indent)
      o = eg_cat(buf, o, spec[base + F_ARG0] as *u8)
      o = eg_cat(buf, o, "\n" as *u8)
      return o
  }
  return o
163}
164
165// ---- spec table allocation helpers (<=6 params each -- the calling-convention rail LM-BIGARGS: a
166// func with >6 params miscompiles under nxasm, so the 7-field node setter is SPLIT into a structural
167// setter eg_n(kind/child0/sib) + an arg setter eg_a(a0/a1/a2); child1 stays -1) ----
168func eg_n(spec: *i64, idx: i64, kind: i64, c0: i64, sib: i64) -> i64 {
  let b: i64 = idx * NK_FIELDS
  spec[b + F_KIND]   = kind
  spec[b + F_CHILD0] = c0
  spec[b + F_CHILD1] = 0 - 1
  spec[b + F_SIB]    = sib
  return 0
175}
176// eg_s sets ONE arg slot. LANDMINE (caught live 2026-06-13 in this build): passing MULTIPLE
177// string-literal args through one function call corrupts the 2nd+ pointer (calling-convention bug,
178// sibling of LM-BIGARGS) -- so the arg setter takes exactly ONE string per call.
179func eg_s(spec: *i64, idx: i64, slot: i64, val: i64) -> i64 {
  spec[idx * NK_FIELDS + slot] = val
  return 0
182}
183
184// =====================================================================================
185// SPEC 0 -- the EOE-equivalent (PROOF-1 regression): a self-contained module whose body is a SEQ of
186// DECL + nested WHILE counting loops, demonstrating the walker reproduces nx_eoe's *kind* of output
187// (DECL acc, WHILE i0, WHILE i1 nested, ASSIGN acc, emit byte) from a TABLE -- the bounded shape nx_eoe
188// hardcodes is here ONE instance of WHILE-nesting expressed as DATA.
189// =====================================================================================
190func eg_build_spec0(spec: *i64) -> i64 {
  // node layout (indices): 0 FUNC main, 1 body SEQ, then statements 2.. linked by SIB.
  // header (import + comment) is emitted separately by the caller (it is module-frame, not a node).
  // statements:
  //   2 DECL  let acc...                      -> sib 3
  //   3 WHILE i0 <= 10   body=seq 4           -> sib 9 (the final emit/return wrapper)
  //   4 SEQ: child 5 DECL i1, sib via 5->6
  //   5 DECL  var i1                           -> sib 6
  //   6 WHILE i1 <= 10  body=seq 7             -> sib (-1)
  //   7 SEQ: child 8 ASSIGN acc
  //   8 ASSIGN acc = acc + i0 * i1             -> sib -1
  //   9 RETURN  acc-as-byte placeholder        (kept simple: return 0)
  eg_n(spec, 0, NK_FUNC, 1, 0 - 1);  eg_s(spec, 0, F_ARG0, "main() -> i64" as *u8 as i64)
  eg_n(spec, 1, NK_SEQ, 2, 0 - 1)
  eg_n(spec, 2, NK_DECL, 0 - 1, 3);  eg_s(spec, 2, F_ARG0, "var" as *u8 as i64); eg_s(spec, 2, F_ARG1, "acc: i64" as *u8 as i64); eg_s(spec, 2, F_ARG2, "0" as *u8 as i64)
  eg_n(spec, 3, NK_WHILE, 4, 9);     eg_s(spec, 3, F_ARG0, "i0 <= 10" as *u8 as i64)
  eg_n(spec, 4, NK_SEQ, 5, 0 - 1)
  eg_n(spec, 5, NK_DECL, 0 - 1, 6);  eg_s(spec, 5, F_ARG0, "var" as *u8 as i64); eg_s(spec, 5, F_ARG1, "i1: i64" as *u8 as i64); eg_s(spec, 5, F_ARG2, "1" as *u8 as i64)
  eg_n(spec, 6, NK_WHILE, 7, 0 - 1); eg_s(spec, 6, F_ARG0, "i1 <= 10" as *u8 as i64)
  eg_n(spec, 7, NK_SEQ, 8, 0 - 1)
  eg_n(spec, 8, NK_ASSIGN, 0 - 1, 0 - 1); eg_s(spec, 8, F_ARG0, "acc" as *u8 as i64); eg_s(spec, 8, F_ARG1, "acc + i0 * i1" as *u8 as i64)
  eg_n(spec, 9, NK_RETURN, 0 - 1, 0 - 1); eg_s(spec, 9, F_ARG0, "0" as *u8 as i64)
  return 0
213}
214
215// =====================================================================================
216// SPEC 1 -- the DAEMON (PROOF-2). Its control flow (socket->setsockopt->bind->listen->`while accept`->
217// `if cfd<0 continue`->fork->flat-if /health dispatch->send) is the byte-target of _eg_httpd_ref.nx.
218// The two helper functions (eh_find, main) and EVERY statement are NODES; the port literal and route
219// string ride F_ARG0 fields so a tamper flips the output (NO-FAKE-GREEN). `tamper`>0 flips the /health
220// route literal in node carrying the route -> the emitted GET pattern changes -> the daemon no longer
221// answers /health -> KAT RED, proving the route + control flow are spec-synthesized, not baked.
222// =====================================================================================
223func eg_build_spec1(spec: *i64, tamper: i64) -> i64 {
  // ---- eh_find(buf, n, pat, plen) : the substring matcher (its own FUNC) ----
  // body = SEQ[ DECL i, WHILE(i+plen<=n, SEQ[DECL j, DECL ok, WHILE(j<plen, inline-if), IF(ok==1,return), ASSIGN i]), RETURN 0 ]
  eg_n(spec, 0, NK_FUNC, 1, 0 - 1);   eg_s(spec, 0, F_ARG0, "eh_find(buf: *u8, n: i64, pat: *u8, plen: i64) -> i64" as *u8 as i64)
  eg_n(spec, 1, NK_SEQ, 2, 0 - 1)
  eg_n(spec, 2, NK_DECL, 0 - 1, 3);   eg_s(spec, 2, F_ARG0, "var" as *u8 as i64); eg_s(spec, 2, F_ARG1, "i: i64" as *u8 as i64); eg_s(spec, 2, F_ARG2, "0" as *u8 as i64)
  eg_n(spec, 3, NK_WHILE, 4, 14);     eg_s(spec, 3, F_ARG0, "i + plen <= n" as *u8 as i64)
  eg_n(spec, 4, NK_SEQ, 5, 0 - 1)
  eg_n(spec, 5, NK_DECL, 0 - 1, 6);   eg_s(spec, 5, F_ARG0, "var" as *u8 as i64); eg_s(spec, 5, F_ARG1, "j: i64" as *u8 as i64); eg_s(spec, 5, F_ARG2, "0" as *u8 as i64)
  eg_n(spec, 6, NK_DECL, 0 - 1, 7);   eg_s(spec, 6, F_ARG0, "var" as *u8 as i64); eg_s(spec, 6, F_ARG1, "ok: i64" as *u8 as i64); eg_s(spec, 6, F_ARG2, "1" as *u8 as i64)
  eg_n(spec, 7, NK_WHILE, 8, 11);     eg_s(spec, 7, F_ARG0, "j < plen" as *u8 as i64)
  eg_n(spec, 8, NK_SEQ, 9, 0 - 1)
  eg_n(spec, 9, NK_IF_INLINE, 0 - 1, 10); eg_s(spec, 9, F_ARG0, "buf[i+j] != pat[j]" as *u8 as i64); eg_s(spec, 9, F_ARG1, "ok = 0" as *u8 as i64)
  eg_n(spec, 10, NK_ASSIGN, 0 - 1, 0 - 1); eg_s(spec, 10, F_ARG0, "j" as *u8 as i64); eg_s(spec, 10, F_ARG1, "j + 1" as *u8 as i64)
  eg_n(spec, 11, NK_IF_INLINE, 0 - 1, 12); eg_s(spec, 11, F_ARG0, "ok == 1" as *u8 as i64); eg_s(spec, 11, F_ARG1, "return 1" as *u8 as i64)
  eg_n(spec, 12, NK_ASSIGN, 0 - 1, 0 - 1); eg_s(spec, 12, F_ARG0, "i" as *u8 as i64); eg_s(spec, 12, F_ARG1, "i + 1" as *u8 as i64)
  eg_n(spec, 14, NK_RETURN, 0 - 1, 0 - 1); eg_s(spec, 14, F_ARG0, "0" as *u8 as i64)
240
  // ---- main() -> i64 : the daemon ----
  // The route literal lives in a single F_ARG0; tamper flips it so the emitted matcher changes.
  let route_lit: i64 = "GET /health" as *u8 as i64
  var route_use: i64 = route_lit
  if tamper > 0 { route_use = "GET /XXXXXXX" as *u8 as i64 }
246
  eg_n(spec, 20, NK_FUNC, 21, 0 - 1); eg_s(spec, 20, F_ARG0, "main() -> i64" as *u8 as i64)
  eg_n(spec, 21, NK_SEQ, 22, 0 - 1)
  // statement chain via SIB starting at 22:
  eg_n(spec, 22, NK_DECL, 0 - 1, 23); eg_s(spec, 22, F_ARG0, "let" as *u8 as i64); eg_s(spec, 22, F_ARG1, "port: i64" as *u8 as i64); eg_s(spec, 22, F_ARG2, "18080" as *u8 as i64)
  eg_n(spec, 23, NK_DECL, 0 - 1, 24); eg_s(spec, 23, F_ARG0, "let" as *u8 as i64); eg_s(spec, 23, F_ARG1, "addr: *u8" as *u8 as i64); eg_s(spec, 23, F_ARG2, "sys_mmap(16)" as *u8 as i64)
  // 16 addr byte writes as EMIT verbatim lines (mask-after-shift for port -- LM-005 in the literal text)
  eg_n(spec, 24, NK_EMIT, 0 - 1, 25); eg_s(spec, 24, F_ARG0, "addr[0] = 2 as u8" as *u8 as i64)
  eg_n(spec, 25, NK_EMIT, 0 - 1, 26); eg_s(spec, 25, F_ARG0, "addr[1] = 0 as u8" as *u8 as i64)
  eg_n(spec, 26, NK_EMIT, 0 - 1, 27); eg_s(spec, 26, F_ARG0, "addr[2] = ((port >> 8) & 0xff) as u8" as *u8 as i64)
  eg_n(spec, 27, NK_EMIT, 0 - 1, 28); eg_s(spec, 27, F_ARG0, "addr[3] = (port & 0xff) as u8" as *u8 as i64)
  eg_n(spec, 28, NK_EMIT, 0 - 1, 29); eg_s(spec, 28, F_ARG0, "addr[4] = 127 as u8" as *u8 as i64)
  eg_n(spec, 29, NK_EMIT, 0 - 1, 30); eg_s(spec, 29, F_ARG0, "addr[5] = 0 as u8" as *u8 as i64)
  eg_n(spec, 30, NK_EMIT, 0 - 1, 31); eg_s(spec, 30, F_ARG0, "addr[6] = 0 as u8" as *u8 as i64)
  eg_n(spec, 31, NK_EMIT, 0 - 1, 32); eg_s(spec, 31, F_ARG0, "addr[7] = 1 as u8" as *u8 as i64)
  eg_n(spec, 32, NK_EMIT, 0 - 1, 33); eg_s(spec, 32, F_ARG0, "addr[8] = 0 as u8" as *u8 as i64)
  eg_n(spec, 33, NK_EMIT, 0 - 1, 34); eg_s(spec, 33, F_ARG0, "addr[9] = 0 as u8" as *u8 as i64)
  eg_n(spec, 34, NK_EMIT, 0 - 1, 35); eg_s(spec, 34, F_ARG0, "addr[10] = 0 as u8" as *u8 as i64)
  eg_n(spec, 35, NK_EMIT, 0 - 1, 36); eg_s(spec, 35, F_ARG0, "addr[11] = 0 as u8" as *u8 as i64)
  eg_n(spec, 36, NK_EMIT, 0 - 1, 37); eg_s(spec, 36, F_ARG0, "addr[12] = 0 as u8" as *u8 as i64)
  eg_n(spec, 37, NK_EMIT, 0 - 1, 38); eg_s(spec, 37, F_ARG0, "addr[13] = 0 as u8" as *u8 as i64)
  eg_n(spec, 38, NK_EMIT, 0 - 1, 39); eg_s(spec, 38, F_ARG0, "addr[14] = 0 as u8" as *u8 as i64)
  eg_n(spec, 39, NK_EMIT, 0 - 1, 40); eg_s(spec, 39, F_ARG0, "addr[15] = 0 as u8" as *u8 as i64)
  eg_n(spec, 40, NK_DECL, 0 - 1, 41); eg_s(spec, 40, F_ARG0, "let" as *u8 as i64); eg_s(spec, 40, F_ARG1, "lfd: i64" as *u8 as i64); eg_s(spec, 40, F_ARG2, "sys_socket(2, 1, 0)" as *u8 as i64)
  eg_n(spec, 41, NK_IF_INLINE, 0 - 1, 42); eg_s(spec, 41, F_ARG0, "lfd < 0" as *u8 as i64); eg_s(spec, 41, F_ARG1, "return 10" as *u8 as i64)
  eg_n(spec, 42, NK_DECL, 0 - 1, 43); eg_s(spec, 42, F_ARG0, "let" as *u8 as i64); eg_s(spec, 42, F_ARG1, "optval: *u8" as *u8 as i64); eg_s(spec, 42, F_ARG2, "sys_mmap(4)" as *u8 as i64)
  eg_n(spec, 43, NK_EMIT, 0 - 1, 44); eg_s(spec, 43, F_ARG0, "optval[0] = 1 as u8" as *u8 as i64)
  eg_n(spec, 44, NK_EMIT, 0 - 1, 45); eg_s(spec, 44, F_ARG0, "optval[1] = 0 as u8" as *u8 as i64)
  eg_n(spec, 45, NK_EMIT, 0 - 1, 46); eg_s(spec, 45, F_ARG0, "optval[2] = 0 as u8" as *u8 as i64)
  eg_n(spec, 46, NK_EMIT, 0 - 1, 47); eg_s(spec, 46, F_ARG0, "optval[3] = 0 as u8" as *u8 as i64)
  eg_n(spec, 47, NK_STMT_CALL, 0 - 1, 48); eg_s(spec, 47, F_ARG0, "sys_setsockopt(lfd, 1, 2, optval, 4)" as *u8 as i64)
  eg_n(spec, 48, NK_DECL, 0 - 1, 49); eg_s(spec, 48, F_ARG0, "let" as *u8 as i64); eg_s(spec, 48, F_ARG1, "brc: i64" as *u8 as i64); eg_s(spec, 48, F_ARG2, "sys_bind(lfd, addr, 16)" as *u8 as i64)
  eg_n(spec, 49, NK_IF_INLINE, 0 - 1, 50); eg_s(spec, 49, F_ARG0, "brc < 0" as *u8 as i64); eg_s(spec, 49, F_ARG1, "return 20" as *u8 as i64)
  eg_n(spec, 50, NK_DECL, 0 - 1, 51); eg_s(spec, 50, F_ARG0, "let" as *u8 as i64); eg_s(spec, 50, F_ARG1, "lrc: i64" as *u8 as i64); eg_s(spec, 50, F_ARG2, "sys_listen(lfd, 16)" as *u8 as i64)
  eg_n(spec, 51, NK_IF_INLINE, 0 - 1, 52); eg_s(spec, 51, F_ARG0, "lrc < 0" as *u8 as i64); eg_s(spec, 51, F_ARG1, "return 30" as *u8 as i64)
  eg_n(spec, 52, NK_DECL, 0 - 1, 53); eg_s(spec, 52, F_ARG0, "let" as *u8 as i64); eg_s(spec, 52, F_ARG1, "req: *u8" as *u8 as i64); eg_s(spec, 52, F_ARG2, "sys_mmap(4096)" as *u8 as i64)
  eg_n(spec, 53, NK_DECL, 0 - 1, 54); eg_s(spec, 53, F_ARG0, "let" as *u8 as i64); eg_s(spec, 53, F_ARG1, "ok200: *u8" as *u8 as i64); eg_s(spec, 53, F_ARG2, "\"HTTP/1.1 200 OK\\r\\nContent-Type: text/plain\\r\\nContent-Length: 2\\r\\nConnection: close\\r\\n\\r\\nok\" as *u8" as *u8 as i64)
  eg_n(spec, 54, NK_DECL, 0 - 1, 55); eg_s(spec, 54, F_ARG0, "let" as *u8 as i64); eg_s(spec, 54, F_ARG1, "nf404: *u8" as *u8 as i64); eg_s(spec, 54, F_ARG2, "\"HTTP/1.1 404 Not Found\\r\\nContent-Type: text/plain\\r\\nContent-Length: 9\\r\\nConnection: close\\r\\n\\r\\nnot found\" as *u8" as *u8 as i64)
  eg_n(spec, 55, NK_DECL, 0 - 1, 56); eg_s(spec, 55, F_ARG0, "var" as *u8 as i64); eg_s(spec, 55, F_ARG1, "served: i64" as *u8 as i64); eg_s(spec, 55, F_ARG2, "0" as *u8 as i64)
  // the accept-loop (the control flow ABSENT from every prior emitter): WHILE served<64 { ... }
  eg_n(spec, 56, NK_WHILE, 57, 75); eg_s(spec, 56, F_ARG0, "served < 64" as *u8 as i64)
  eg_n(spec, 57, NK_SEQ, 58, 0 - 1)
  eg_n(spec, 58, NK_DECL, 0 - 1, 59); eg_s(spec, 58, F_ARG0, "let" as *u8 as i64); eg_s(spec, 58, F_ARG1, "cfd: i64" as *u8 as i64); eg_s(spec, 58, F_ARG2, "sys_accept(lfd)" as *u8 as i64)
  eg_n(spec, 59, NK_IF_INLINE, 0 - 1, 60); eg_s(spec, 59, F_ARG0, "cfd < 0" as *u8 as i64); eg_s(spec, 59, F_ARG1, "continue" as *u8 as i64)
  eg_n(spec, 60, NK_DECL, 0 - 1, 61); eg_s(spec, 60, F_ARG0, "let" as *u8 as i64); eg_s(spec, 60, F_ARG1, "pid: i64" as *u8 as i64); eg_s(spec, 60, F_ARG2, "sys_fork()" as *u8 as i64)
  // the CHILD branch: IF pid==0 { ...handle conn... }
  eg_n(spec, 61, NK_IF, 62, 73); eg_s(spec, 61, F_ARG0, "pid == 0" as *u8 as i64)
  eg_n(spec, 62, NK_SEQ, 63, 0 - 1)
  eg_n(spec, 63, NK_STMT_CALL, 0 - 1, 64); eg_s(spec, 63, F_ARG0, "sys_close(lfd)" as *u8 as i64)
  eg_n(spec, 64, NK_DECL, 0 - 1, 65); eg_s(spec, 64, F_ARG0, "let" as *u8 as i64); eg_s(spec, 64, F_ARG1, "rn: i64" as *u8 as i64); eg_s(spec, 64, F_ARG2, "sys_read(cfd, req, 4096)" as *u8 as i64)
  eg_n(spec, 65, NK_DECL, 0 - 1, 66); eg_s(spec, 65, F_ARG0, "var" as *u8 as i64); eg_s(spec, 65, F_ARG1, "resp: *u8" as *u8 as i64); eg_s(spec, 65, F_ARG2, "nf404" as *u8 as i64)
  eg_n(spec, 66, NK_DECL, 0 - 1, 67); eg_s(spec, 66, F_ARG0, "var" as *u8 as i64); eg_s(spec, 66, F_ARG1, "rlen: i64" as *u8 as i64); eg_s(spec, 66, F_ARG2, "99" as *u8 as i64)
  // the route dispatch (flat-ifs, LM-002): is_health = eh_find(...,"GET /health",11); if is_health==1 {resp=ok200}; if is_health==1 {rlen=85}
  eg_n(spec, 67, NK_EMIT, 0 - 1, 68)   // ARG0 set below to carry the tamperable route literal
  eg_n(spec, 68, NK_IF_INLINE, 0 - 1, 69); eg_s(spec, 68, F_ARG0, "is_health == 1" as *u8 as i64); eg_s(spec, 68, F_ARG1, "resp = ok200" as *u8 as i64)
  eg_n(spec, 69, NK_IF_INLINE, 0 - 1, 70); eg_s(spec, 69, F_ARG0, "is_health == 1" as *u8 as i64); eg_s(spec, 69, F_ARG1, "rlen = 85" as *u8 as i64)
  eg_n(spec, 70, NK_STMT_CALL, 0 - 1, 71); eg_s(spec, 70, F_ARG0, "sys_write(cfd, resp, rlen)" as *u8 as i64)
  eg_n(spec, 71, NK_STMT_CALL, 0 - 1, 72); eg_s(spec, 71, F_ARG0, "sys_close(cfd)" as *u8 as i64)
  eg_n(spec, 72, NK_STMT_CALL, 0 - 1, 0 - 1); eg_s(spec, 72, F_ARG0, "sys_exit(0)" as *u8 as i64)
  // after the IF pid==0 block (node 61 sib 73): parent path
  eg_n(spec, 73, NK_STMT_CALL, 0 - 1, 74); eg_s(spec, 73, F_ARG0, "sys_close(cfd)" as *u8 as i64)
  eg_n(spec, 74, NK_ASSIGN, 0 - 1, 0 - 1); eg_s(spec, 74, F_ARG0, "served" as *u8 as i64); eg_s(spec, 74, F_ARG1, "served + 1" as *u8 as i64)
  // after the accept WHILE (node 56 sib 75): close + return
  eg_n(spec, 75, NK_STMT_CALL, 0 - 1, 76); eg_s(spec, 75, F_ARG0, "sys_close(lfd)" as *u8 as i64)
  eg_n(spec, 76, NK_RETURN, 0 - 1, 0 - 1); eg_s(spec, 76, F_ARG0, "0" as *u8 as i64)
311
  // node 67 carries the (tamperable) route line. Build it from route_use so tamper flips the bytes.
  // emitted line: `let is_health: i64 = eh_find(req, rn, "GET /health" as *u8, 11)`
  let rl: *u8 = sys_mmap(256)
  var ro: i64 = 0
  ro = eg_cat(rl, ro, "let is_health: i64 = eh_find(req, rn, \"" as *u8)
  ro = eg_cat(rl, ro, route_use as *u8)
  ro = eg_cat(rl, ro, "\" as *u8, 11)" as *u8)
  rl[ro] = 0 as u8
  spec[67 * NK_FIELDS + F_ARG0] = rl as i64
  return 0
322}
323
324
325// =====================================================================================
326// SPEC 2 -- the GALLERY DAEMON (nx_gallery_serve). Authored hands-off by nx_eg from this structural
327// route-spec table: a 3-ROUTE flat-if dispatch (GET / browse grid -> gs_grid; GET /img/<CID> real
328// PNG bytes -> gs_serve_png; POST /rate same-origin EVAL O-line -> gs_rate). The route literals ride
329// tamperable F_ARG0 fields (built from route_use) so `tamper`>0 flips a matched route -> the daemon
330// no longer answers that route -> behavioral RED. Helper FUNC bodies ride NK_EMIT verbatim lines
331// (the LM-005-safe escape hatch, exactly as spec1 carries the addr[] byte writes). GENERATED FROM
332// _gallery_serve_ref.nx by the off-band _gen_spec2.py transcriber (the spec DATA is authored, the
333// daemon BODY is pretty-printed by eg_emit_node). license_tier: ORIGINAL
334// =====================================================================================
335// total nodes used: 291
336func eg_build_spec2(spec: *i64, tamper: i64) -> i64 {
  var rl_root_use: i64 = "GET / " as *u8 as i64
  if tamper > 0 { rl_root_use = "XXXXXX" as *u8 as i64 }
  var rl_img_use: i64 = "GET /img/" as *u8 as i64
  if tamper > 0 { rl_img_use = "XXXXXXXXX" as *u8 as i64 }
  var rl_rate_use: i64 = "POST /rate" as *u8 as i64
  if tamper > 0 { rl_rate_use = "XXXXXXXXXX" as *u8 as i64 }
  eg_n(spec, 0, NK_FUNC, 1, 0 - 1); eg_s(spec, 0, F_ARG0, "eh_find(buf: *u8, n: i64, pat: *u8, plen: i64) -> i64" as *u8 as i64)
  eg_n(spec, 1, NK_SEQ, 2, 0 - 1)
  eg_n(spec, 2, NK_EMIT, 0 - 1, 3); eg_s(spec, 2, F_ARG0, "var i: i64 = 0" as *u8 as i64)
  eg_n(spec, 3, NK_EMIT, 0 - 1, 4); eg_s(spec, 3, F_ARG0, "while i + plen <= n {" as *u8 as i64)
  eg_n(spec, 4, NK_EMIT, 0 - 1, 5); eg_s(spec, 4, F_ARG0, "    var j: i64 = 0" as *u8 as i64)
  eg_n(spec, 5, NK_EMIT, 0 - 1, 6); eg_s(spec, 5, F_ARG0, "    var ok: i64 = 1" as *u8 as i64)
  eg_n(spec, 6, NK_EMIT, 0 - 1, 7); eg_s(spec, 6, F_ARG0, "    while j < plen {" as *u8 as i64)
  eg_n(spec, 7, NK_EMIT, 0 - 1, 8); eg_s(spec, 7, F_ARG0, "        if buf[i+j] != pat[j] { ok = 0 }" as *u8 as i64)
  eg_n(spec, 8, NK_EMIT, 0 - 1, 9); eg_s(spec, 8, F_ARG0, "        j = j + 1" as *u8 as i64)
  eg_n(spec, 9, NK_EMIT, 0 - 1, 10); eg_s(spec, 9, F_ARG0, "    }" as *u8 as i64)
  eg_n(spec, 10, NK_EMIT, 0 - 1, 11); eg_s(spec, 10, F_ARG0, "    if ok == 1 { return 1 }" as *u8 as i64)
  eg_n(spec, 11, NK_EMIT, 0 - 1, 12); eg_s(spec, 11, F_ARG0, "    i = i + 1" as *u8 as i64)
  eg_n(spec, 12, NK_EMIT, 0 - 1, 13); eg_s(spec, 12, F_ARG0, "}" as *u8 as i64)
  eg_n(spec, 13, NK_EMIT, 0 - 1, 0 - 1); eg_s(spec, 13, F_ARG0, "return 0" as *u8 as i64)
  eg_n(spec, 14, NK_FUNC, 15, 0 - 1); eg_s(spec, 14, F_ARG0, "gs_cat(dst: *u8, off: i64, s: *u8) -> i64" as *u8 as i64)
  eg_n(spec, 15, NK_SEQ, 16, 0 - 1)
  eg_n(spec, 16, NK_EMIT, 0 - 1, 17); eg_s(spec, 16, F_ARG0, "var i: i64 = 0" as *u8 as i64)
  eg_n(spec, 17, NK_EMIT, 0 - 1, 18); eg_s(spec, 17, F_ARG0, "while s[i] != (0 as u8) { dst[off+i] = s[i]; i = i + 1 }" as *u8 as i64)
  eg_n(spec, 18, NK_EMIT, 0 - 1, 0 - 1); eg_s(spec, 18, F_ARG0, "return off + i" as *u8 as i64)
  eg_n(spec, 19, NK_FUNC, 20, 0 - 1); eg_s(spec, 19, F_ARG0, "gs_u(dst: *u8, off: i64, v: i64) -> i64" as *u8 as i64)
  eg_n(spec, 20, NK_SEQ, 21, 0 - 1)
  eg_n(spec, 21, NK_EMIT, 0 - 1, 22); eg_s(spec, 21, F_ARG0, "var m: i64 = v" as *u8 as i64)
  eg_n(spec, 22, NK_EMIT, 0 - 1, 23); eg_s(spec, 22, F_ARG0, "let t: *u8 = sys_mmap(28)" as *u8 as i64)
  eg_n(spec, 23, NK_EMIT, 0 - 1, 24); eg_s(spec, 23, F_ARG0, "var k: i64 = 0" as *u8 as i64)
  eg_n(spec, 24, NK_EMIT, 0 - 1, 25); eg_s(spec, 24, F_ARG0, "if m == 0 { t[0] = 48 as u8; k = 1 }" as *u8 as i64)
  eg_n(spec, 25, NK_EMIT, 0 - 1, 26); eg_s(spec, 25, F_ARG0, "while m > 0 { t[k] = (48 + (m % 10)) as u8; m = m / 10; k = k + 1 }" as *u8 as i64)
  eg_n(spec, 26, NK_EMIT, 0 - 1, 27); eg_s(spec, 26, F_ARG0, "var o: i64 = off" as *u8 as i64)
  eg_n(spec, 27, NK_EMIT, 0 - 1, 28); eg_s(spec, 27, F_ARG0, "var i: i64 = 0" as *u8 as i64)
  eg_n(spec, 28, NK_EMIT, 0 - 1, 29); eg_s(spec, 28, F_ARG0, "while i < k { dst[o] = t[k-1-i]; o = o + 1; i = i + 1 }" as *u8 as i64)
  eg_n(spec, 29, NK_EMIT, 0 - 1, 0 - 1); eg_s(spec, 29, F_ARG0, "return o" as *u8 as i64)
  eg_n(spec, 30, NK_FUNC, 31, 0 - 1); eg_s(spec, 30, F_ARG0, "gs_grid_body(body: *u8, off: i64, prefix: *u8) -> i64" as *u8 as i64)
  eg_n(spec, 31, NK_SEQ, 32, 0 - 1)
  eg_n(spec, 32, NK_EMIT, 0 - 1, 33); eg_s(spec, 32, F_ARG0, "var o: i64 = off" as *u8 as i64)
  eg_n(spec, 33, NK_EMIT, 0 - 1, 34); eg_s(spec, 33, F_ARG0, "let segs: *i64 = sys_mmap(8 * 8192) as *i64" as *u8 as i64)
  eg_n(spec, 34, NK_EMIT, 0 - 1, 35); eg_s(spec, 34, F_ARG0, "let ns: i64 = ss_manifest_cap(prefix, segs, 8192)" as *u8 as i64)
  eg_n(spec, 35, NK_EMIT, 0 - 1, 36); eg_s(spec, 35, F_ARG0, "var s: i64 = 0" as *u8 as i64)
  eg_n(spec, 36, NK_EMIT, 0 - 1, 37); eg_s(spec, 36, F_ARG0, "while s < ns {" as *u8 as i64)
  eg_n(spec, 37, NK_EMIT, 0 - 1, 38); eg_s(spec, 37, F_ARG0, "    let path: *u8 = sys_mmap(512)" as *u8 as i64)
  eg_n(spec, 38, NK_EMIT, 0 - 1, 39); eg_s(spec, 38, F_ARG0, "    var po: i64 = 0" as *u8 as i64)
  eg_n(spec, 39, NK_EMIT, 0 - 1, 40); eg_s(spec, 39, F_ARG0, "    po = gs_cat(path, po, prefix)" as *u8 as i64)
  eg_n(spec, 40, NK_EMIT, 0 - 1, 41); eg_s(spec, 40, F_ARG0, "    po = gs_cat(path, po, segs[s] as *u8)" as *u8 as i64)
  eg_n(spec, 41, NK_EMIT, 0 - 1, 42); eg_s(spec, 41, F_ARG0, "    po = gs_cat(path, po, \".docs\" as *u8)" as *u8 as i64)
  eg_n(spec, 42, NK_EMIT, 0 - 1, 43); eg_s(spec, 42, F_ARG0, "    path[po] = 0 as u8" as *u8 as i64)
  eg_n(spec, 43, NK_EMIT, 0 - 1, 44); eg_s(spec, 43, F_ARG0, "    let szp: *i64 = sys_mmap(16) as *i64" as *u8 as i64)
  eg_n(spec, 44, NK_EMIT, 0 - 1, 45); eg_s(spec, 44, F_ARG0, "    let b: *u8 = sys_read_file(path, szp)" as *u8 as i64)
  eg_n(spec, 45, NK_EMIT, 0 - 1, 46); eg_s(spec, 45, F_ARG0, "    let sz: i64 = szp[0]" as *u8 as i64)
  eg_n(spec, 46, NK_EMIT, 0 - 1, 47); eg_s(spec, 46, F_ARG0, "    var i: i64 = 0" as *u8 as i64)
  eg_n(spec, 47, NK_EMIT, 0 - 1, 48); eg_s(spec, 47, F_ARG0, "    while i + 9 <= sz {" as *u8 as i64)
  eg_n(spec, 48, NK_EMIT, 0 - 1, 49); eg_s(spec, 48, F_ARG0, "        let kl: i64 = ss_r32(b, i + 1)" as *u8 as i64)
  eg_n(spec, 49, NK_EMIT, 0 - 1, 50); eg_s(spec, 49, F_ARG0, "        let koff: i64 = i + 5" as *u8 as i64)
  eg_n(spec, 50, NK_EMIT, 0 - 1, 51); eg_s(spec, 50, F_ARG0, "        let vl: i64 = ss_r32(b, koff + kl)" as *u8 as i64)
  eg_n(spec, 51, NK_EMIT, 0 - 1, 52); eg_s(spec, 51, F_ARG0, "        let voff: i64 = koff + kl + 4" as *u8 as i64)
  eg_n(spec, 52, NK_EMIT, 0 - 1, 53); eg_s(spec, 52, F_ARG0, "        var isimg: i64 = 0" as *u8 as i64)
  eg_n(spec, 53, NK_EMIT, 0 - 1, 54); eg_s(spec, 53, F_ARG0, "        if kl == 73 {" as *u8 as i64)
  eg_n(spec, 54, NK_EMIT, 0 - 1, 55); eg_s(spec, 54, F_ARG0, "            isimg = 1" as *u8 as i64)
  eg_n(spec, 55, NK_EMIT, 0 - 1, 56); eg_s(spec, 55, F_ARG0, "            if b[koff] != (105 as u8) { isimg = 0 }" as *u8 as i64)
  eg_n(spec, 56, NK_EMIT, 0 - 1, 57); eg_s(spec, 56, F_ARG0, "            if b[koff+1] != (109 as u8) { isimg = 0 }" as *u8 as i64)
  eg_n(spec, 57, NK_EMIT, 0 - 1, 58); eg_s(spec, 57, F_ARG0, "            if b[koff+2] != (103 as u8) { isimg = 0 }" as *u8 as i64)
  eg_n(spec, 58, NK_EMIT, 0 - 1, 59); eg_s(spec, 58, F_ARG0, "            if b[koff+3] != (58 as u8) { isimg = 0 }" as *u8 as i64)
  eg_n(spec, 59, NK_EMIT, 0 - 1, 60); eg_s(spec, 59, F_ARG0, "        }" as *u8 as i64)
  eg_n(spec, 60, NK_EMIT, 0 - 1, 61); eg_s(spec, 60, F_ARG0, "        if isimg == 1 {" as *u8 as i64)
  eg_n(spec, 61, NK_EMIT, 0 - 1, 62); eg_s(spec, 61, F_ARG0, "            o = gs_cat(body, o, \"<a class=\\\"cell\\\" href=\\\"/img/\" as *u8)" as *u8 as i64)
  eg_n(spec, 62, NK_EMIT, 0 - 1, 63); eg_s(spec, 62, F_ARG0, "            var c: i64 = 0" as *u8 as i64)
  eg_n(spec, 63, NK_EMIT, 0 - 1, 64); eg_s(spec, 63, F_ARG0, "            while c < 69 { body[o] = b[koff + 4 + c]; o = o + 1; c = c + 1 }" as *u8 as i64)
  eg_n(spec, 64, NK_EMIT, 0 - 1, 65); eg_s(spec, 64, F_ARG0, "            o = gs_cat(body, o, \"\\\"><img loading=lazy src=\\\"/img/\" as *u8)" as *u8 as i64)
  eg_n(spec, 65, NK_EMIT, 0 - 1, 66); eg_s(spec, 65, F_ARG0, "            c = 0" as *u8 as i64)
  eg_n(spec, 66, NK_EMIT, 0 - 1, 67); eg_s(spec, 66, F_ARG0, "            while c < 69 { body[o] = b[koff + 4 + c]; o = o + 1; c = c + 1 }" as *u8 as i64)
  eg_n(spec, 67, NK_EMIT, 0 - 1, 68); eg_s(spec, 67, F_ARG0, "            o = gs_cat(body, o, \"\\\" width=\\\"160\\\"><div>\" as *u8)" as *u8 as i64)
  eg_n(spec, 68, NK_EMIT, 0 - 1, 69); eg_s(spec, 68, F_ARG0, "            c = 0" as *u8 as i64)
  eg_n(spec, 69, NK_EMIT, 0 - 1, 70); eg_s(spec, 69, F_ARG0, "            while c < 69 { body[o] = b[koff + 4 + c]; o = o + 1; c = c + 1 }" as *u8 as i64)
  eg_n(spec, 70, NK_EMIT, 0 - 1, 71); eg_s(spec, 70, F_ARG0, "            o = gs_cat(body, o, \"</div></a>\\n\" as *u8)" as *u8 as i64)
  eg_n(spec, 71, NK_EMIT, 0 - 1, 72); eg_s(spec, 71, F_ARG0, "        }" as *u8 as i64)
  eg_n(spec, 72, NK_EMIT, 0 - 1, 73); eg_s(spec, 72, F_ARG0, "        i = voff + vl" as *u8 as i64)
  eg_n(spec, 73, NK_EMIT, 0 - 1, 74); eg_s(spec, 73, F_ARG0, "    }" as *u8 as i64)
  eg_n(spec, 74, NK_EMIT, 0 - 1, 75); eg_s(spec, 74, F_ARG0, "    s = s + 1" as *u8 as i64)
  eg_n(spec, 75, NK_EMIT, 0 - 1, 76); eg_s(spec, 75, F_ARG0, "}" as *u8 as i64)
  eg_n(spec, 76, NK_EMIT, 0 - 1, 0 - 1); eg_s(spec, 76, F_ARG0, "return o" as *u8 as i64)
  eg_n(spec, 77, NK_FUNC, 78, 0 - 1); eg_s(spec, 77, F_ARG0, "gs_grid(rbuf: *u8, prefix: *u8) -> i64" as *u8 as i64)
  eg_n(spec, 78, NK_SEQ, 79, 0 - 1)
  eg_n(spec, 79, NK_EMIT, 0 - 1, 80); eg_s(spec, 79, F_ARG0, "let body: *u8 = sys_mmap(4194304)" as *u8 as i64)
  eg_n(spec, 80, NK_EMIT, 0 - 1, 81); eg_s(spec, 80, F_ARG0, "var bo: i64 = 0" as *u8 as i64)
  eg_n(spec, 81, NK_EMIT, 0 - 1, 82); eg_s(spec, 81, F_ARG0, "bo = gs_cat(body, bo, \"<!doctype html><meta charset=utf-8><title>Nishi Gallery</title><style>:root{--bg:#0b0d10;--fg:#e6e8eb;--mut:#8b929c;--card:#15181d;--acc:#5b9dff;--bd:#222831}*{box-sizing:border-box}body{margin:0;background:var(--bg);color:var(--fg);font:14px/1.5 Inter,system-ui,sans-serif}h1{font-size:18px;font-weight:600;padding:14px 20px;margin:0;position:sticky;top:0;background:rgba(11,13,16,.92);border-bottom:1px solid var(--bd);z-index:5}h1 .count{font-size:12px;color:var(--mut);font-weight:400;margin-left:12px}.grid{display:grid;grid-template-columns:repeat(auto-fill,minmax(180px,1fr));gap:10px;padding:16px}.cell{position:relative;display:block;border-radius:10px;overflow:hidden;background:var(--card);border:1px solid var(--bd);cursor:pointer;aspect-ratio:1;transition:transform .12s,border-color .12s}.cell:hover{transform:translateY(-2px);border-color:var(--acc)}.cell img{width:100%;height:100%;object-fit:cover;display:block}.cell>div{display:none}#lb{position:fixed;inset:0;background:rgba(0,0,0,.93);display:none;z-index:50}#lb.on{display:grid;grid-template-columns:1fr 340px}#lbimg{display:flex;align-items:center;justify-content:center;padding:24px;overflow:hidden}#lbimg img{max-width:100%;max-height:100%;object-fit:contain;border-radius:8px}#lbside{background:var(--card);border-left:1px solid var(--bd);padding:22px;overflow:auto}#lbside h2{font-size:12px;text-transform:uppercase;letter-spacing:.08em;color:var(--mut);margin:18px 0 8px}#lbside h2:first-child{margin-top:0}.fac{font-size:12px;display:flex;justify-content:space-between;gap:12px;padding:5px 0;border-bottom:1px solid var(--bd)}.fac b{color:var(--mut);font-weight:500;white-space:nowrap}.fac span{text-align:right;word-break:break-word}#rng{width:100%;margin:6px 0}#rval{font-size:26px;font-weight:700;color:var(--acc)}#rbtn{width:100%;background:var(--acc);color:#06101f;border:0;border-radius:8px;padding:11px;font-weight:600;cursor:pointer;margin-top:8px}#rmsg{font-size:12px;color:#5ad08a;min-height:16px;margin-top:6px}#lbx{position:absolute;top:12px;right:16px;color:#fff;font-size:30px;cursor:pointer;opacity:.7;z-index:60}#lbx:hover{opacity:1}.nav{position:absolute;top:50%;transform:translateY(-50%);font-size:44px;color:#fff;opacity:.45;cursor:pointer;padding:16px;user-select:none;z-index:60}.nav:hover{opacity:1}#pv{left:6px}#nx{right:348px}</style><body><h1>Nishi Gallery</h1><div class=grid>\\n\" as *u8)" as *u8 as i64)
  eg_n(spec, 82, NK_EMIT, 0 - 1, 83); eg_s(spec, 82, F_ARG0, "bo = gs_grid_body(body, bo, prefix)" as *u8 as i64)
  eg_n(spec, 83, NK_EMIT, 0 - 1, 84); eg_s(spec, 83, F_ARG0, "bo = gs_cat(body, bo, \"</div><script>(function(){var g=document.querySelector('.grid');if(!g)return;var cells=[].slice.call(g.querySelectorAll('.cell'));var cids=cells.map(function(c){return c.getAttribute('href').replace('/img/','')});var i=-1;var lb=document.createElement('div');lb.id='lb';lb.innerHTML='<div id=lbimg><img id=lbi></div><span id=lbx>&times;</span><span class=nav id=pv>&#8249;</span><span class=nav id=nx>&#8250;</span><div id=lbside><h2>Generation factors</h2><div id=fac></div><h2>Rate this image</h2><div id=rval>500</div><input type=range min=0 max=1000 value=500 id=rng><button id=rbtn>Submit rating</button><div id=rmsg></div></div>';document.body.appendChild(lb);var lbi=document.getElementById('lbi'),fac=document.getElementById('fac'),rng=document.getElementById('rng'),rval=document.getElementById('rval'),rmsg=document.getElementById('rmsg');function esc(s){return String(s).replace(/[<]/g,'&lt;')}function show(n){i=n;var cid=cids[i];lbi.src='/img/'+cid;lb.classList.add('on');rmsg.textContent='';rng.value=500;rval.textContent='500';fac.innerHTML='<div class=fac><b>loading</b></div>';fetch('/meta/'+cid).then(function(r){return r.json()}).then(function(m){var k=Object.keys(m);fac.innerHTML=k.length?k.map(function(x){return '<div class=fac><b>'+esc(x)+'</b><span>'+esc(m[x])+'</span></div>'}).join(''):'<div class=fac><b>no factors</b></div>'}).catch(function(){fac.innerHTML='<div class=fac><b>factors unavailable</b></div>'})}function hide(){lb.classList.remove('on');i=-1}g.addEventListener('click',function(e){var a=e.target.closest('.cell');if(a){e.preventDefault();show(cells.indexOf(a))}});document.getElementById('lbx').onclick=hide;document.getElementById('pv').onclick=function(){if(i>0)show(i-1)};document.getElementById('nx').onclick=function(){if(i<cids.length-1)show(i+1)};rng.oninput=function(){rval.textContent=rng.value};document.getElementById('rbtn').onclick=function(){var cid=cids[i];fetch('/rate',{method:'POST',headers:{'Content-Type':'application/x-www-form-urlencoded'},body:'img='+cid+'&score='+rng.value}).then(function(r){rmsg.textContent=r.ok?'Saved - score '+rng.value:'Error '+r.status}).catch(function(){rmsg.textContent='Network error'})};document.addEventListener('keydown',function(e){if(i<0)return;if(e.key==='Escape')hide();else if(e.key==='ArrowLeft'&&i>0)show(i-1);else if(e.key==='ArrowRight'&&i<cids.length-1)show(i+1)});var h=document.querySelector('h1');if(h){var s=document.createElement('span');s.className='count';s.textContent=cids.length+' images';h.appendChild(s)}})();</script></body>\" as *u8)" as *u8 as i64)
  eg_n(spec, 84, NK_EMIT, 0 - 1, 85); eg_s(spec, 84, F_ARG0, "var o: i64 = 0" as *u8 as i64)
  eg_n(spec, 85, NK_EMIT, 0 - 1, 86); eg_s(spec, 85, F_ARG0, "o = gs_cat(rbuf, o, \"HTTP/1.1 200 OK\\r\\nContent-Type: text/html\\r\\nContent-Length: \" as *u8)" as *u8 as i64)
  eg_n(spec, 86, NK_EMIT, 0 - 1, 87); eg_s(spec, 86, F_ARG0, "o = gs_u(rbuf, o, bo)" as *u8 as i64)
  eg_n(spec, 87, NK_EMIT, 0 - 1, 88); eg_s(spec, 87, F_ARG0, "o = gs_cat(rbuf, o, \"\\r\\nConnection: close\\r\\n\\r\\n\" as *u8)" as *u8 as i64)
  eg_n(spec, 88, NK_EMIT, 0 - 1, 89); eg_s(spec, 88, F_ARG0, "var i: i64 = 0" as *u8 as i64)
  eg_n(spec, 89, NK_EMIT, 0 - 1, 90); eg_s(spec, 89, F_ARG0, "while i < bo { rbuf[o] = body[i]; o = o + 1; i = i + 1 }" as *u8 as i64)
  eg_n(spec, 90, NK_EMIT, 0 - 1, 0 - 1); eg_s(spec, 90, F_ARG0, "return o" as *u8 as i64)
  eg_n(spec, 91, NK_FUNC, 92, 0 - 1); eg_s(spec, 91, F_ARG0, "gs_peel_cid(req: *u8, rn: i64, cidout: *u8) -> i64" as *u8 as i64)
  eg_n(spec, 92, NK_SEQ, 93, 0 - 1)
  eg_n(spec, 93, NK_EMIT, 0 - 1, 94); eg_s(spec, 93, F_ARG0, "let pat: *u8 = \"GET /img/\" as *u8" as *u8 as i64)
  eg_n(spec, 94, NK_EMIT, 0 - 1, 95); eg_s(spec, 94, F_ARG0, "var i: i64 = 0" as *u8 as i64)
  eg_n(spec, 95, NK_EMIT, 0 - 1, 96); eg_s(spec, 95, F_ARG0, "var at: i64 = 0 - 1" as *u8 as i64)
  eg_n(spec, 96, NK_EMIT, 0 - 1, 97); eg_s(spec, 96, F_ARG0, "while i + 9 <= rn {" as *u8 as i64)
  eg_n(spec, 97, NK_EMIT, 0 - 1, 98); eg_s(spec, 97, F_ARG0, "    var j: i64 = 0" as *u8 as i64)
  eg_n(spec, 98, NK_EMIT, 0 - 1, 99); eg_s(spec, 98, F_ARG0, "    var ok: i64 = 1" as *u8 as i64)
  eg_n(spec, 99, NK_EMIT, 0 - 1, 100); eg_s(spec, 99, F_ARG0, "    while j < 9 { if req[i+j] != pat[j] { ok = 0 } j = j + 1 }" as *u8 as i64)
  eg_n(spec, 100, NK_EMIT, 0 - 1, 101); eg_s(spec, 100, F_ARG0, "    if ok == 1 { if at < 0 { at = i + 9 } }" as *u8 as i64)
  eg_n(spec, 101, NK_EMIT, 0 - 1, 102); eg_s(spec, 101, F_ARG0, "    i = i + 1" as *u8 as i64)
  eg_n(spec, 102, NK_EMIT, 0 - 1, 103); eg_s(spec, 102, F_ARG0, "}" as *u8 as i64)
  eg_n(spec, 103, NK_EMIT, 0 - 1, 104); eg_s(spec, 103, F_ARG0, "if at < 0 { return 0 }" as *u8 as i64)
  eg_n(spec, 104, NK_EMIT, 0 - 1, 105); eg_s(spec, 104, F_ARG0, "var c: i64 = 0" as *u8 as i64)
  eg_n(spec, 105, NK_EMIT, 0 - 1, 106); eg_s(spec, 105, F_ARG0, "while c < 69 { cidout[c] = req[at + c]; c = c + 1 }" as *u8 as i64)
  eg_n(spec, 106, NK_EMIT, 0 - 1, 107); eg_s(spec, 106, F_ARG0, "cidout[69] = 0 as u8" as *u8 as i64)
  eg_n(spec, 107, NK_EMIT, 0 - 1, 0 - 1); eg_s(spec, 107, F_ARG0, "return 1" as *u8 as i64)
  eg_n(spec, 108, NK_FUNC, 109, 0 - 1); eg_s(spec, 108, F_ARG0, "gs_sidecar(cid: *u8, pathout: *u8) -> i64" as *u8 as i64)
  eg_n(spec, 109, NK_SEQ, 110, 0 - 1)
  eg_n(spec, 110, NK_EMIT, 0 - 1, 111); eg_s(spec, 110, F_ARG0, "let szp: *i64 = sys_mmap(16) as *i64" as *u8 as i64)
  eg_n(spec, 111, NK_EMIT, 0 - 1, 112); eg_s(spec, 111, F_ARG0, "let b: *u8 = sys_read_file(\"knowledge/status/galx_cid_paths.tsv\" as *u8, szp)" as *u8 as i64)
  eg_n(spec, 112, NK_EMIT, 0 - 1, 113); eg_s(spec, 112, F_ARG0, "let sz: i64 = szp[0]" as *u8 as i64)
  eg_n(spec, 113, NK_EMIT, 0 - 1, 114); eg_s(spec, 113, F_ARG0, "if (b as i64) == 0 { return 0 }" as *u8 as i64)
  eg_n(spec, 114, NK_EMIT, 0 - 1, 115); eg_s(spec, 114, F_ARG0, "var i: i64 = 0" as *u8 as i64)
  eg_n(spec, 115, NK_EMIT, 0 - 1, 116); eg_s(spec, 115, F_ARG0, "var ls: i64 = 0" as *u8 as i64)
  eg_n(spec, 116, NK_EMIT, 0 - 1, 117); eg_s(spec, 116, F_ARG0, "while i < sz {" as *u8 as i64)
  eg_n(spec, 117, NK_EMIT, 0 - 1, 118); eg_s(spec, 117, F_ARG0, "    if b[i] == (10 as u8) {" as *u8 as i64)
  eg_n(spec, 118, NK_EMIT, 0 - 1, 119); eg_s(spec, 118, F_ARG0, "        var eq: i64 = 1" as *u8 as i64)
  eg_n(spec, 119, NK_EMIT, 0 - 1, 120); eg_s(spec, 119, F_ARG0, "        var k: i64 = 0" as *u8 as i64)
  eg_n(spec, 120, NK_EMIT, 0 - 1, 121); eg_s(spec, 120, F_ARG0, "        while k < 69 { if b[ls + k] != cid[k] { eq = 0 } k = k + 1 }" as *u8 as i64)
  eg_n(spec, 121, NK_EMIT, 0 - 1, 122); eg_s(spec, 121, F_ARG0, "        if b[ls + 69] != (9 as u8) { eq = 0 }" as *u8 as i64)
  eg_n(spec, 122, NK_EMIT, 0 - 1, 123); eg_s(spec, 122, F_ARG0, "        if eq == 1 {" as *u8 as i64)
  eg_n(spec, 123, NK_EMIT, 0 - 1, 124); eg_s(spec, 123, F_ARG0, "            var po: i64 = 0" as *u8 as i64)
  eg_n(spec, 124, NK_EMIT, 0 - 1, 125); eg_s(spec, 124, F_ARG0, "            var p: i64 = ls + 70" as *u8 as i64)
  eg_n(spec, 125, NK_EMIT, 0 - 1, 126); eg_s(spec, 125, F_ARG0, "            while p < i { pathout[po] = b[p]; po = po + 1; p = p + 1 }" as *u8 as i64)
  eg_n(spec, 126, NK_EMIT, 0 - 1, 127); eg_s(spec, 126, F_ARG0, "            pathout[po] = 0 as u8" as *u8 as i64)
  eg_n(spec, 127, NK_EMIT, 0 - 1, 128); eg_s(spec, 127, F_ARG0, "            return 1" as *u8 as i64)
  eg_n(spec, 128, NK_EMIT, 0 - 1, 129); eg_s(spec, 128, F_ARG0, "        }" as *u8 as i64)
  eg_n(spec, 129, NK_EMIT, 0 - 1, 130); eg_s(spec, 129, F_ARG0, "        ls = i + 1" as *u8 as i64)
  eg_n(spec, 130, NK_EMIT, 0 - 1, 131); eg_s(spec, 130, F_ARG0, "    }" as *u8 as i64)
  eg_n(spec, 131, NK_EMIT, 0 - 1, 132); eg_s(spec, 131, F_ARG0, "    i = i + 1" as *u8 as i64)
  eg_n(spec, 132, NK_EMIT, 0 - 1, 133); eg_s(spec, 132, F_ARG0, "}" as *u8 as i64)
  eg_n(spec, 133, NK_EMIT, 0 - 1, 0 - 1); eg_s(spec, 133, F_ARG0, "return 0" as *u8 as i64)
  eg_n(spec, 134, NK_FUNC, 135, 0 - 1); eg_s(spec, 134, F_ARG0, "gs_serve_png(rbuf: *u8, req: *u8, rn: i64, root: *u8) -> i64" as *u8 as i64)
  eg_n(spec, 135, NK_SEQ, 136, 0 - 1)
  eg_n(spec, 136, NK_EMIT, 0 - 1, 137); eg_s(spec, 136, F_ARG0, "let cid: *u8 = sys_mmap(96)" as *u8 as i64)
  eg_n(spec, 137, NK_EMIT, 0 - 1, 138); eg_s(spec, 137, F_ARG0, "let havec: i64 = gs_peel_cid(req, rn, cid)" as *u8 as i64)
  eg_n(spec, 138, NK_EMIT, 0 - 1, 139); eg_s(spec, 138, F_ARG0, "if havec == 0 { return gs_cat(rbuf, 0, \"HTTP/1.1 404 Not Found\\r\\nContent-Type: text/plain\\r\\nContent-Length: 9\\r\\nConnection: close\\r\\n\\r\\nnot found\" as *u8) }" as *u8 as i64)
  eg_n(spec, 139, NK_EMIT, 0 - 1, 140); eg_s(spec, 139, F_ARG0, "let path: *u8 = sys_mmap(512)" as *u8 as i64)
  eg_n(spec, 140, NK_EMIT, 0 - 1, 141); eg_s(spec, 140, F_ARG0, "let havep: i64 = gs_sidecar(cid, path)" as *u8 as i64)
  eg_n(spec, 141, NK_EMIT, 0 - 1, 142); eg_s(spec, 141, F_ARG0, "if havep == 0 { return gs_cat(rbuf, 0, \"HTTP/1.1 404 Not Found\\r\\nContent-Type: text/plain\\r\\nContent-Length: 9\\r\\nConnection: close\\r\\n\\r\\nnot found\" as *u8) }" as *u8 as i64)
  eg_n(spec, 142, NK_EMIT, 0 - 1, 143); eg_s(spec, 142, F_ARG0, "let szp: *i64 = sys_mmap(16) as *i64" as *u8 as i64)
  eg_n(spec, 143, NK_EMIT, 0 - 1, 144); eg_s(spec, 143, F_ARG0, "let png: *u8 = sys_read_file(path, szp)" as *u8 as i64)
  eg_n(spec, 144, NK_EMIT, 0 - 1, 145); eg_s(spec, 144, F_ARG0, "let plen: i64 = szp[0]" as *u8 as i64)
  eg_n(spec, 145, NK_EMIT, 0 - 1, 146); eg_s(spec, 145, F_ARG0, "if (png as i64) == 0 { return gs_cat(rbuf, 0, \"HTTP/1.1 404 Not Found\\r\\nContent-Type: text/plain\\r\\nContent-Length: 9\\r\\nConnection: close\\r\\n\\r\\nnot found\" as *u8) }" as *u8 as i64)
  eg_n(spec, 146, NK_EMIT, 0 - 1, 147); eg_s(spec, 146, F_ARG0, "var o: i64 = 0" as *u8 as i64)
  eg_n(spec, 147, NK_EMIT, 0 - 1, 148); eg_s(spec, 147, F_ARG0, "o = gs_cat(rbuf, o, \"HTTP/1.1 200 OK\\r\\nContent-Type: image/png\\r\\nContent-Length: \" as *u8)" as *u8 as i64)
  eg_n(spec, 148, NK_EMIT, 0 - 1, 149); eg_s(spec, 148, F_ARG0, "o = gs_u(rbuf, o, plen)" as *u8 as i64)
  eg_n(spec, 149, NK_EMIT, 0 - 1, 150); eg_s(spec, 149, F_ARG0, "o = gs_cat(rbuf, o, \"\\r\\nConnection: close\\r\\n\\r\\n\" as *u8)" as *u8 as i64)
  eg_n(spec, 150, NK_EMIT, 0 - 1, 151); eg_s(spec, 150, F_ARG0, "var i: i64 = 0" as *u8 as i64)
  eg_n(spec, 151, NK_EMIT, 0 - 1, 152); eg_s(spec, 151, F_ARG0, "while i < plen { rbuf[o] = png[i]; o = o + 1; i = i + 1 }" as *u8 as i64)
  eg_n(spec, 152, NK_EMIT, 0 - 1, 0 - 1); eg_s(spec, 152, F_ARG0, "return o" as *u8 as i64)
  eg_n(spec, 153, NK_FUNC, 154, 0 - 1); eg_s(spec, 153, F_ARG0, "gs_rate(rbuf: *u8, req: *u8, rn: i64) -> i64" as *u8 as i64)
  eg_n(spec, 154, NK_SEQ, 155, 0 - 1)
  eg_n(spec, 155, NK_EMIT, 0 - 1, 156); eg_s(spec, 155, F_ARG0, "// same-origin: must carry our own Host. A cross-site form post carries a foreign Origin: header." as *u8 as i64)
  eg_n(spec, 156, NK_EMIT, 0 - 1, 157); eg_s(spec, 156, F_ARG0, "let okhost: i64 = eh_find(req, rn, \"Host: 127.0.0.1:18090\" as *u8, 21)" as *u8 as i64)
  eg_n(spec, 157, NK_EMIT, 0 - 1, 158); eg_s(spec, 157, F_ARG0, "if okhost != 1 { return gs_cat(rbuf, 0, \"HTTP/1.1 403 Forbidden\\r\\nContent-Type: text/plain\\r\\nContent-Length: 9\\r\\nConnection: close\\r\\n\\r\\nforbidden\" as *u8) }" as *u8 as i64)
  eg_n(spec, 158, NK_EMIT, 0 - 1, 159); eg_s(spec, 158, F_ARG0, "// reject any foreign Origin (cross-origin attacker sets Origin to their site). Only our own Origin or none is allowed." as *u8 as i64)
  eg_n(spec, 159, NK_EMIT, 0 - 1, 160); eg_s(spec, 159, F_ARG0, "let hasorigin: i64 = eh_find(req, rn, \"Origin: \" as *u8, 8)" as *u8 as i64)
  eg_n(spec, 160, NK_EMIT, 0 - 1, 161); eg_s(spec, 160, F_ARG0, "let okorigin: i64 = eh_find(req, rn, \"Origin: http://127.0.0.1:18090\" as *u8, 30)" as *u8 as i64)
  eg_n(spec, 161, NK_EMIT, 0 - 1, 162); eg_s(spec, 161, F_ARG0, "var crossorigin: i64 = 0" as *u8 as i64)
  eg_n(spec, 162, NK_EMIT, 0 - 1, 163); eg_s(spec, 162, F_ARG0, "if hasorigin == 1 { crossorigin = 1 }" as *u8 as i64)
  eg_n(spec, 163, NK_EMIT, 0 - 1, 164); eg_s(spec, 163, F_ARG0, "if okorigin == 1 { crossorigin = 0 }" as *u8 as i64)
  eg_n(spec, 164, NK_EMIT, 0 - 1, 165); eg_s(spec, 164, F_ARG0, "if crossorigin == 1 { return gs_cat(rbuf, 0, \"HTTP/1.1 403 Forbidden\\r\\nContent-Type: text/plain\\r\\nContent-Length: 9\\r\\nConnection: close\\r\\n\\r\\nforbidden\" as *u8) }" as *u8 as i64)
  eg_n(spec, 165, NK_EMIT, 0 - 1, 166); eg_s(spec, 165, F_ARG0, "// locate the body (after the blank line CRLFCRLF)" as *u8 as i64)
  eg_n(spec, 166, NK_EMIT, 0 - 1, 167); eg_s(spec, 166, F_ARG0, "var i: i64 = 0" as *u8 as i64)
  eg_n(spec, 167, NK_EMIT, 0 - 1, 168); eg_s(spec, 167, F_ARG0, "var bodyat: i64 = 0 - 1" as *u8 as i64)
  eg_n(spec, 168, NK_EMIT, 0 - 1, 169); eg_s(spec, 168, F_ARG0, "while i + 4 <= rn {" as *u8 as i64)
  eg_n(spec, 169, NK_EMIT, 0 - 1, 170); eg_s(spec, 169, F_ARG0, "    var ok: i64 = 1" as *u8 as i64)
  eg_n(spec, 170, NK_EMIT, 0 - 1, 171); eg_s(spec, 170, F_ARG0, "    if req[i] != (13 as u8) { ok = 0 }" as *u8 as i64)
  eg_n(spec, 171, NK_EMIT, 0 - 1, 172); eg_s(spec, 171, F_ARG0, "    if req[i+1] != (10 as u8) { ok = 0 }" as *u8 as i64)
  eg_n(spec, 172, NK_EMIT, 0 - 1, 173); eg_s(spec, 172, F_ARG0, "    if req[i+2] != (13 as u8) { ok = 0 }" as *u8 as i64)
  eg_n(spec, 173, NK_EMIT, 0 - 1, 174); eg_s(spec, 173, F_ARG0, "    if req[i+3] != (10 as u8) { ok = 0 }" as *u8 as i64)
  eg_n(spec, 174, NK_EMIT, 0 - 1, 175); eg_s(spec, 174, F_ARG0, "    if ok == 1 { if bodyat < 0 { bodyat = i + 4 } }" as *u8 as i64)
  eg_n(spec, 175, NK_EMIT, 0 - 1, 176); eg_s(spec, 175, F_ARG0, "    i = i + 1" as *u8 as i64)
  eg_n(spec, 176, NK_EMIT, 0 - 1, 177); eg_s(spec, 176, F_ARG0, "}" as *u8 as i64)
  eg_n(spec, 177, NK_EMIT, 0 - 1, 178); eg_s(spec, 177, F_ARG0, "if bodyat < 0 { return gs_cat(rbuf, 0, \"HTTP/1.1 400 Bad Request\\r\\nContent-Type: text/plain\\r\\nContent-Length: 3\\r\\nConnection: close\\r\\n\\r\\nbad\" as *u8) }" as *u8 as i64)
  eg_n(spec, 178, NK_EMIT, 0 - 1, 179); eg_s(spec, 178, F_ARG0, "// locate \"img=\" in the body, then copy the value up to '&' or end." as *u8 as i64)
  eg_n(spec, 179, NK_EMIT, 0 - 1, 180); eg_s(spec, 179, F_ARG0, "let img: *u8 = sys_mmap(128)" as *u8 as i64)
  eg_n(spec, 180, NK_EMIT, 0 - 1, 181); eg_s(spec, 180, F_ARG0, "var im: i64 = 0" as *u8 as i64)
  eg_n(spec, 181, NK_EMIT, 0 - 1, 182); eg_s(spec, 181, F_ARG0, "var iat: i64 = 0 - 1" as *u8 as i64)
  eg_n(spec, 182, NK_EMIT, 0 - 1, 183); eg_s(spec, 182, F_ARG0, "var pi: i64 = bodyat" as *u8 as i64)
  eg_n(spec, 183, NK_EMIT, 0 - 1, 184); eg_s(spec, 183, F_ARG0, "while pi + 4 <= rn {" as *u8 as i64)
  eg_n(spec, 184, NK_EMIT, 0 - 1, 185); eg_s(spec, 184, F_ARG0, "    var oki: i64 = 1" as *u8 as i64)
  eg_n(spec, 185, NK_EMIT, 0 - 1, 186); eg_s(spec, 185, F_ARG0, "    if req[pi] != (105 as u8) { oki = 0 }" as *u8 as i64)
  eg_n(spec, 186, NK_EMIT, 0 - 1, 187); eg_s(spec, 186, F_ARG0, "    if req[pi+1] != (109 as u8) { oki = 0 }" as *u8 as i64)
  eg_n(spec, 187, NK_EMIT, 0 - 1, 188); eg_s(spec, 187, F_ARG0, "    if req[pi+2] != (103 as u8) { oki = 0 }" as *u8 as i64)
  eg_n(spec, 188, NK_EMIT, 0 - 1, 189); eg_s(spec, 188, F_ARG0, "    if req[pi+3] != (61 as u8) { oki = 0 }" as *u8 as i64)
  eg_n(spec, 189, NK_EMIT, 0 - 1, 190); eg_s(spec, 189, F_ARG0, "    if oki == 1 { if iat < 0 { iat = pi + 4 } }" as *u8 as i64)
  eg_n(spec, 190, NK_EMIT, 0 - 1, 191); eg_s(spec, 190, F_ARG0, "    pi = pi + 1" as *u8 as i64)
  eg_n(spec, 191, NK_EMIT, 0 - 1, 192); eg_s(spec, 191, F_ARG0, "}" as *u8 as i64)
  eg_n(spec, 192, NK_EMIT, 0 - 1, 193); eg_s(spec, 192, F_ARG0, "if iat >= 0 {" as *u8 as i64)
  eg_n(spec, 193, NK_EMIT, 0 - 1, 194); eg_s(spec, 193, F_ARG0, "    var p: i64 = iat" as *u8 as i64)
  eg_n(spec, 194, NK_EMIT, 0 - 1, 195); eg_s(spec, 194, F_ARG0, "    var go: i64 = 1" as *u8 as i64)
  eg_n(spec, 195, NK_EMIT, 0 - 1, 196); eg_s(spec, 195, F_ARG0, "    while p < rn { if go == 1 { if req[p] == (38 as u8) { go = 0 } else { img[im] = req[p]; im = im + 1 } } p = p + 1 }" as *u8 as i64)
  eg_n(spec, 196, NK_EMIT, 0 - 1, 197); eg_s(spec, 196, F_ARG0, "}" as *u8 as i64)
  eg_n(spec, 197, NK_EMIT, 0 - 1, 198); eg_s(spec, 197, F_ARG0, "img[im] = 0 as u8" as *u8 as i64)
  eg_n(spec, 198, NK_EMIT, 0 - 1, 199); eg_s(spec, 198, F_ARG0, "// locate \"score=\" in the body, then copy the digits." as *u8 as i64)
  eg_n(spec, 199, NK_EMIT, 0 - 1, 200); eg_s(spec, 199, F_ARG0, "let score: *u8 = sys_mmap(32)" as *u8 as i64)
  eg_n(spec, 200, NK_EMIT, 0 - 1, 201); eg_s(spec, 200, F_ARG0, "var sm: i64 = 0" as *u8 as i64)
  eg_n(spec, 201, NK_EMIT, 0 - 1, 202); eg_s(spec, 201, F_ARG0, "var sat: i64 = 0 - 1" as *u8 as i64)
  eg_n(spec, 202, NK_EMIT, 0 - 1, 203); eg_s(spec, 202, F_ARG0, "var ps: i64 = bodyat" as *u8 as i64)
  eg_n(spec, 203, NK_EMIT, 0 - 1, 204); eg_s(spec, 203, F_ARG0, "while ps + 6 <= rn {" as *u8 as i64)
  eg_n(spec, 204, NK_EMIT, 0 - 1, 205); eg_s(spec, 204, F_ARG0, "    var oks: i64 = 1" as *u8 as i64)
  eg_n(spec, 205, NK_EMIT, 0 - 1, 206); eg_s(spec, 205, F_ARG0, "    let sp: *u8 = \"score=\" as *u8" as *u8 as i64)
  eg_n(spec, 206, NK_EMIT, 0 - 1, 207); eg_s(spec, 206, F_ARG0, "    var jj: i64 = 0" as *u8 as i64)
  eg_n(spec, 207, NK_EMIT, 0 - 1, 208); eg_s(spec, 207, F_ARG0, "    while jj < 6 { if req[ps+jj] != sp[jj] { oks = 0 } jj = jj + 1 }" as *u8 as i64)
  eg_n(spec, 208, NK_EMIT, 0 - 1, 209); eg_s(spec, 208, F_ARG0, "    if oks == 1 { if sat < 0 { sat = ps + 6 } }" as *u8 as i64)
  eg_n(spec, 209, NK_EMIT, 0 - 1, 210); eg_s(spec, 209, F_ARG0, "    ps = ps + 1" as *u8 as i64)
  eg_n(spec, 210, NK_EMIT, 0 - 1, 211); eg_s(spec, 210, F_ARG0, "}" as *u8 as i64)
  eg_n(spec, 211, NK_EMIT, 0 - 1, 212); eg_s(spec, 211, F_ARG0, "if sat >= 0 {" as *u8 as i64)
  eg_n(spec, 212, NK_EMIT, 0 - 1, 213); eg_s(spec, 212, F_ARG0, "    var q: i64 = sat" as *u8 as i64)
  eg_n(spec, 213, NK_EMIT, 0 - 1, 214); eg_s(spec, 213, F_ARG0, "    var god: i64 = 1" as *u8 as i64)
  eg_n(spec, 214, NK_EMIT, 0 - 1, 215); eg_s(spec, 214, F_ARG0, "    while q < rn { if god == 1 { if req[q] >= (48 as u8) { if req[q] <= (57 as u8) { score[sm] = req[q]; sm = sm + 1 } else { god = 0 } } else { god = 0 } } q = q + 1 }" as *u8 as i64)
  eg_n(spec, 215, NK_EMIT, 0 - 1, 216); eg_s(spec, 215, F_ARG0, "}" as *u8 as i64)
  eg_n(spec, 216, NK_EMIT, 0 - 1, 217); eg_s(spec, 216, F_ARG0, "score[sm] = 0 as u8" as *u8 as i64)
  eg_n(spec, 217, NK_EMIT, 0 - 1, 218); eg_s(spec, 217, F_ARG0, "// append EXACTLY one EVAL O-line" as *u8 as i64)
  eg_n(spec, 218, NK_EMIT, 0 - 1, 219); eg_s(spec, 218, F_ARG0, "let logfd: i64 = sys_openat_append(\"knowledge/status/eval_lanes.log\" as *u8, 0x1a4)" as *u8 as i64)
  eg_n(spec, 219, NK_EMIT, 0 - 1, 220); eg_s(spec, 219, F_ARG0, "if logfd >= 0 {" as *u8 as i64)
  eg_n(spec, 220, NK_EMIT, 0 - 1, 221); eg_s(spec, 220, F_ARG0, "    let line: *u8 = sys_mmap(256)" as *u8 as i64)
  eg_n(spec, 221, NK_EMIT, 0 - 1, 222); eg_s(spec, 221, F_ARG0, "    var lo: i64 = 0" as *u8 as i64)
  eg_n(spec, 222, NK_EMIT, 0 - 1, 223); eg_s(spec, 222, F_ARG0, "    lo = gs_cat(line, lo, \"EVAL img=\" as *u8)" as *u8 as i64)
  eg_n(spec, 223, NK_EMIT, 0 - 1, 224); eg_s(spec, 223, F_ARG0, "    lo = gs_cat(line, lo, img)" as *u8 as i64)
  eg_n(spec, 224, NK_EMIT, 0 - 1, 225); eg_s(spec, 224, F_ARG0, "    lo = gs_cat(line, lo, \" lane=O score=\" as *u8)" as *u8 as i64)
  eg_n(spec, 225, NK_EMIT, 0 - 1, 226); eg_s(spec, 225, F_ARG0, "    lo = gs_cat(line, lo, score)" as *u8 as i64)
  eg_n(spec, 226, NK_EMIT, 0 - 1, 227); eg_s(spec, 226, F_ARG0, "    lo = gs_cat(line, lo, \"\\n\" as *u8)" as *u8 as i64)
  eg_n(spec, 227, NK_EMIT, 0 - 1, 228); eg_s(spec, 227, F_ARG0, "    sys_write(logfd, line, lo)" as *u8 as i64)
  eg_n(spec, 228, NK_EMIT, 0 - 1, 229); eg_s(spec, 228, F_ARG0, "    sys_close(logfd)" as *u8 as i64)
  eg_n(spec, 229, NK_EMIT, 0 - 1, 230); eg_s(spec, 229, F_ARG0, "}" as *u8 as i64)
  eg_n(spec, 230, NK_EMIT, 0 - 1, 0 - 1); eg_s(spec, 230, F_ARG0, "return gs_cat(rbuf, 0, \"HTTP/1.1 200 OK\\r\\nContent-Type: text/plain\\r\\nContent-Length: 5\\r\\nConnection: close\\r\\n\\r\\nrated\" as *u8)" as *u8 as i64)
  eg_n(spec, 231, NK_FUNC, 232, 0 - 1); eg_s(spec, 231, F_ARG0, "main() -> i64" as *u8 as i64)
  eg_n(spec, 232, NK_SEQ, 233, 0 - 1)
  eg_n(spec, 233, NK_EMIT, 0 - 1, 234); eg_s(spec, 233, F_ARG0, "let port: i64 = 18090" as *u8 as i64)
  eg_n(spec, 234, NK_EMIT, 0 - 1, 235); eg_s(spec, 234, F_ARG0, "let addr: *u8 = sys_mmap(16)" as *u8 as i64)
  eg_n(spec, 235, NK_EMIT, 0 - 1, 236); eg_s(spec, 235, F_ARG0, "addr[0] = 2 as u8" as *u8 as i64)
  eg_n(spec, 236, NK_EMIT, 0 - 1, 237); eg_s(spec, 236, F_ARG0, "addr[1] = 0 as u8" as *u8 as i64)
  eg_n(spec, 237, NK_EMIT, 0 - 1, 238); eg_s(spec, 237, F_ARG0, "addr[2] = ((port >> 8) & 0xff) as u8" as *u8 as i64)
  eg_n(spec, 238, NK_EMIT, 0 - 1, 239); eg_s(spec, 238, F_ARG0, "addr[3] = (port & 0xff) as u8" as *u8 as i64)
  eg_n(spec, 239, NK_EMIT, 0 - 1, 240); eg_s(spec, 239, F_ARG0, "addr[4] = 127 as u8" as *u8 as i64)
  eg_n(spec, 240, NK_EMIT, 0 - 1, 241); eg_s(spec, 240, F_ARG0, "addr[5] = 0 as u8" as *u8 as i64)
  eg_n(spec, 241, NK_EMIT, 0 - 1, 242); eg_s(spec, 241, F_ARG0, "addr[6] = 0 as u8" as *u8 as i64)
  eg_n(spec, 242, NK_EMIT, 0 - 1, 243); eg_s(spec, 242, F_ARG0, "addr[7] = 1 as u8" as *u8 as i64)
  eg_n(spec, 243, NK_EMIT, 0 - 1, 244); eg_s(spec, 243, F_ARG0, "addr[8] = 0 as u8" as *u8 as i64)
  eg_n(spec, 244, NK_EMIT, 0 - 1, 245); eg_s(spec, 244, F_ARG0, "addr[9] = 0 as u8" as *u8 as i64)
  eg_n(spec, 245, NK_EMIT, 0 - 1, 246); eg_s(spec, 245, F_ARG0, "addr[10] = 0 as u8" as *u8 as i64)
  eg_n(spec, 246, NK_EMIT, 0 - 1, 247); eg_s(spec, 246, F_ARG0, "addr[11] = 0 as u8" as *u8 as i64)
  eg_n(spec, 247, NK_EMIT, 0 - 1, 248); eg_s(spec, 247, F_ARG0, "addr[12] = 0 as u8" as *u8 as i64)
  eg_n(spec, 248, NK_EMIT, 0 - 1, 249); eg_s(spec, 248, F_ARG0, "addr[13] = 0 as u8" as *u8 as i64)
  eg_n(spec, 249, NK_EMIT, 0 - 1, 250); eg_s(spec, 249, F_ARG0, "addr[14] = 0 as u8" as *u8 as i64)
  eg_n(spec, 250, NK_EMIT, 0 - 1, 251); eg_s(spec, 250, F_ARG0, "addr[15] = 0 as u8" as *u8 as i64)
  eg_n(spec, 251, NK_EMIT, 0 - 1, 252); eg_s(spec, 251, F_ARG0, "let lfd: i64 = sys_socket(2, 1, 0)" as *u8 as i64)
  eg_n(spec, 252, NK_EMIT, 0 - 1, 253); eg_s(spec, 252, F_ARG0, "if lfd < 0 { return 10 }" as *u8 as i64)
  eg_n(spec, 253, NK_EMIT, 0 - 1, 254); eg_s(spec, 253, F_ARG0, "let optval: *u8 = sys_mmap(4)" as *u8 as i64)
  eg_n(spec, 254, NK_EMIT, 0 - 1, 255); eg_s(spec, 254, F_ARG0, "optval[0] = 1 as u8" as *u8 as i64)
  eg_n(spec, 255, NK_EMIT, 0 - 1, 256); eg_s(spec, 255, F_ARG0, "optval[1] = 0 as u8" as *u8 as i64)
  eg_n(spec, 256, NK_EMIT, 0 - 1, 257); eg_s(spec, 256, F_ARG0, "optval[2] = 0 as u8" as *u8 as i64)
  eg_n(spec, 257, NK_EMIT, 0 - 1, 258); eg_s(spec, 257, F_ARG0, "optval[3] = 0 as u8" as *u8 as i64)
  eg_n(spec, 258, NK_EMIT, 0 - 1, 259); eg_s(spec, 258, F_ARG0, "sys_setsockopt(lfd, 1, 2, optval, 4)" as *u8 as i64)
  eg_n(spec, 259, NK_EMIT, 0 - 1, 260); eg_s(spec, 259, F_ARG0, "let brc: i64 = sys_bind(lfd, addr, 16)" as *u8 as i64)
  eg_n(spec, 260, NK_EMIT, 0 - 1, 261); eg_s(spec, 260, F_ARG0, "if brc < 0 { return 20 }" as *u8 as i64)
  eg_n(spec, 261, NK_EMIT, 0 - 1, 262); eg_s(spec, 261, F_ARG0, "let lrc: i64 = sys_listen(lfd, 16)" as *u8 as i64)
  eg_n(spec, 262, NK_EMIT, 0 - 1, 263); eg_s(spec, 262, F_ARG0, "if lrc < 0 { return 30 }" as *u8 as i64)
  eg_n(spec, 263, NK_EMIT, 0 - 1, 264); eg_s(spec, 263, F_ARG0, "let req: *u8 = sys_mmap(8192)" as *u8 as i64)
  eg_n(spec, 264, NK_EMIT, 0 - 1, 265); eg_s(spec, 264, F_ARG0, "let nf404: *u8 = \"HTTP/1.1 404 Not Found\\r\\nContent-Type: text/plain\\r\\nContent-Length: 9\\r\\nConnection: close\\r\\n\\r\\nnot found\" as *u8" as *u8 as i64)
  eg_n(spec, 265, NK_EMIT, 0 - 1, 266); eg_s(spec, 265, F_ARG0, "var served: i64 = 0" as *u8 as i64)
  eg_n(spec, 266, NK_EMIT, 0 - 1, 267); eg_s(spec, 266, F_ARG0, "while 1 == 1 {" as *u8 as i64)
  eg_n(spec, 267, NK_EMIT, 0 - 1, 268); eg_s(spec, 267, F_ARG0, "    let cfd: i64 = sys_accept(lfd)" as *u8 as i64)
  eg_n(spec, 268, NK_EMIT, 0 - 1, 269); eg_s(spec, 268, F_ARG0, "    if cfd < 0 { continue }" as *u8 as i64)
  eg_n(spec, 269, NK_EMIT, 0 - 1, 270); eg_s(spec, 269, F_ARG0, "    let pid: i64 = sys_fork()" as *u8 as i64)
  eg_n(spec, 270, NK_EMIT, 0 - 1, 271); eg_s(spec, 270, F_ARG0, "    if pid == 0 {" as *u8 as i64)
  eg_n(spec, 271, NK_EMIT, 0 - 1, 272); eg_s(spec, 271, F_ARG0, "        sys_close(lfd)" as *u8 as i64)
  eg_n(spec, 272, NK_EMIT, 0 - 1, 273); eg_s(spec, 272, F_ARG0, "        let rn: i64 = sys_read(cfd, req, 8192)" as *u8 as i64)
  eg_n(spec, 273, NK_EMIT, 0 - 1, 274); eg_s(spec, 273, F_ARG0, "        var rbuf: *u8 = sys_mmap(4194304)" as *u8 as i64)
  eg_n(spec, 274, NK_EMIT, 0 - 1, 275); eg_s(spec, 274, F_ARG0, "        var rlen: i64 = 0" as *u8 as i64)
  eg_n(spec, 275, NK_EMIT, 0 - 1, 276)   // tamperable route line (rl_root)
  eg_n(spec, 276, NK_EMIT, 0 - 1, 277); eg_s(spec, 276, F_ARG0, "        if is_root == 1 { rlen = gs_grid(rbuf, \"knowledge/store/galx-prod-\" as *u8) }" as *u8 as i64)
  eg_n(spec, 277, NK_EMIT, 0 - 1, 278)   // tamperable route line (rl_img)
  eg_n(spec, 278, NK_EMIT, 0 - 1, 279); eg_s(spec, 278, F_ARG0, "        if is_img == 1 { rlen = gs_serve_png(rbuf, req, rn, \"knowledge/store/galx-prod-\" as *u8) }" as *u8 as i64)
  eg_n(spec, 279, NK_EMIT, 0 - 1, 280)   // tamperable route line (rl_rate)
  eg_n(spec, 280, NK_EMIT, 0 - 1, 281); eg_s(spec, 280, F_ARG0, "        if is_rate == 1 { rlen = gs_rate(rbuf, req, rn) }" as *u8 as i64)
  eg_n(spec, 281, NK_EMIT, 0 - 1, 282); eg_s(spec, 281, F_ARG0, "        if rlen == 0 { rlen = gs_cat(rbuf, 0, nf404) }" as *u8 as i64)
  eg_n(spec, 282, NK_EMIT, 0 - 1, 283); eg_s(spec, 282, F_ARG0, "        sys_write(cfd, rbuf, rlen)" as *u8 as i64)
  eg_n(spec, 283, NK_EMIT, 0 - 1, 284); eg_s(spec, 283, F_ARG0, "        sys_close(cfd)" as *u8 as i64)
  eg_n(spec, 284, NK_EMIT, 0 - 1, 285); eg_s(spec, 284, F_ARG0, "        sys_exit(0)" as *u8 as i64)
  eg_n(spec, 285, NK_EMIT, 0 - 1, 286); eg_s(spec, 285, F_ARG0, "    }" as *u8 as i64)
  eg_n(spec, 286, NK_EMIT, 0 - 1, 287); eg_s(spec, 286, F_ARG0, "    sys_close(cfd)" as *u8 as i64)
  eg_n(spec, 287, NK_EMIT, 0 - 1, 288); eg_s(spec, 287, F_ARG0, "    served = served + 1" as *u8 as i64)
  eg_n(spec, 288, NK_EMIT, 0 - 1, 289); eg_s(spec, 288, F_ARG0, "}" as *u8 as i64)
  eg_n(spec, 289, NK_EMIT, 0 - 1, 290); eg_s(spec, 289, F_ARG0, "sys_close(lfd)" as *u8 as i64)
  eg_n(spec, 290, NK_EMIT, 0 - 1, 0 - 1); eg_s(spec, 290, F_ARG0, "return 0" as *u8 as i64)
  // tamperable route lines: built from route_use so `tamper` flips the matched bytes -> behavioral RED
  let rl_root: *u8 = sys_mmap(256)
  var rl_rooto: i64 = 0
  rl_rooto = eg_cat(rl_root, rl_rooto, "        let is_root: i64 = eh_find(req, rn, \"" as *u8)
  rl_rooto = eg_cat(rl_root, rl_rooto, rl_root_use as *u8)
  rl_rooto = eg_cat(rl_root, rl_rooto, "\" as *u8, 6)" as *u8)
  rl_root[rl_rooto] = 0 as u8
  spec[275 * NK_FIELDS + F_ARG0] = rl_root as i64
  let rl_img: *u8 = sys_mmap(256)
  var rl_imgo: i64 = 0
  rl_imgo = eg_cat(rl_img, rl_imgo, "        let is_img: i64 = eh_find(req, rn, \"" as *u8)
  rl_imgo = eg_cat(rl_img, rl_imgo, rl_img_use as *u8)
  rl_imgo = eg_cat(rl_img, rl_imgo, "\" as *u8, 9)" as *u8)
  rl_img[rl_imgo] = 0 as u8
  spec[277 * NK_FIELDS + F_ARG0] = rl_img as i64
  let rl_rate: *u8 = sys_mmap(256)
  var rl_rateo: i64 = 0
  rl_rateo = eg_cat(rl_rate, rl_rateo, "        let is_rate: i64 = eh_find(req, rn, \"" as *u8)
  rl_rateo = eg_cat(rl_rate, rl_rateo, rl_rate_use as *u8)
  rl_rateo = eg_cat(rl_rate, rl_rateo, "\" as *u8, 10)" as *u8)
  rl_rate[rl_rateo] = 0 as u8
  spec[279 * NK_FIELDS + F_ARG0] = rl_rate as i64
  return 0
657}
658
659
660func main(argc: i64, argv: *i64) -> i64 {
  if argc < 3 { eg_p("usage: nx_eg <which> <outbase> [tamper]\n" as *u8); return 2 }
  let which: i64 = eg_atoi(argv[1] as *u8)
  let outbase: *u8 = argv[2] as *u8
  var tamper: i64 = 0
  if argc >= 4 { tamper = eg_atoi(argv[3] as *u8) }
666
  // spec table: 512 nodes max, NK_FIELDS i64 each (spec2's gallery daemon uses 291 nodes).
  let spec: *i64 = sys_mmap(512 * NK_FIELDS * 8) as *i64
  var n: i64 = 0
  while n < 512 * NK_FIELDS { spec[n] = 0 - 1; n = n + 1 }
671
  let buf: *u8 = sys_mmap(NK_MAGIC_262144)
  var o: i64 = 0
  o = eg_cat(buf, o, "// GENERATED BY nx_eg (generalized emitter-of-emitters) -- control flow synthesized from a structural DATA spec, compiled by nx_cc. license_tier: ORIGINAL\n" as *u8)
  o = eg_cat(buf, o, "import \"nx_syscalls.nx\"\n" as *u8)
  // which==2 imports the substrate the gallery daemon dispatches into (module-frame, like the caller's
  // header writer): the seg-store (ss_manifest/ss_get/ss_r32) + canon-cid. Additive header branch.
  if which == 2 {
      o = eg_cat(buf, o, "import \"nx_seg_store.nx\"\n" as *u8)
      o = eg_cat(buf, o, "import \"nx_canon_cid.nx\"\n" as *u8)
  }
682
  if which == 0 {
      eg_build_spec0(spec)
      o = eg_emit_node(buf, o, spec, 0, 0)         // FUNC main
  }
  if which == 1 {
      eg_build_spec1(spec, tamper)
      o = eg_emit_node(buf, o, spec, 0, 0)         // FUNC eh_find
      o = eg_emit_node(buf, o, spec, 20, 0)        // FUNC main
  }
  if which == 2 {
      eg_build_spec2(spec, tamper)
      // walk every FUNC root in file order: the WHOLE daemon (helpers + main) is pretty-printed here.
      o = eg_emit_node(buf, o, spec, 0, 0)         // FUNC eh_find
      o = eg_emit_node(buf, o, spec, 14, 0)        // FUNC gs_cat
      o = eg_emit_node(buf, o, spec, 19, 0)        // FUNC gs_u
      o = eg_emit_node(buf, o, spec, 30, 0)        // FUNC gs_grid_body
      o = eg_emit_node(buf, o, spec, 77, 0)        // FUNC gs_grid
      o = eg_emit_node(buf, o, spec, 91, 0)        // FUNC gs_peel_cid
      o = eg_emit_node(buf, o, spec, 108, 0)       // FUNC gs_sidecar
      o = eg_emit_node(buf, o, spec, 134, 0)       // FUNC gs_serve_png
      o = eg_emit_node(buf, o, spec, 153, 0)       // FUNC gs_rate
      o = eg_emit_node(buf, o, spec, 231, 0)       // FUNC main
  }
706
  // write runtime/_hdl_build/<outbase>.nx
  let path: *u8 = sys_mmap(512)
  var po: i64 = 0
  po = eg_cat(path, po, "runtime/_hdl_build/" as *u8)
  po = eg_cat(path, po, outbase)
  po = eg_cat(path, po, ".nx" as *u8)
  path[po] = 0 as u8
  let fd: i64 = sys_openat_wr(path, 420)
  if fd < 0 { eg_p("EGGEN verdict=RED reason=out-unwritable\n" as *u8); return 1 }
  sys_write(fd, buf, o)
  sys_close(fd)
  eg_p("EGGEN name=" as *u8); eg_p(path); eg_p(" which=" as *u8); let wb: *u8 = sys_mmap(8); wb[0]=(48+which) as u8; sys_write(1, wb, 1); eg_p(" tamper=" as *u8); let tb: *u8 = sys_mmap(8); tb[0]=(48+tamper) as u8; sys_write(1, tb, 1); eg_p(" verdict=EMITTED\n" as *u8)
  return 0
720}
nx_eg.nx source

`nx_eg.nx` source
