code wiki / _hdl_build / _ale_exec_gate.nx
`_ale_exec_gate.nx` source

↩ module page · 411 lines · 18979 B
1// _ale_exec_gate.nx -- the ALE-R2b gate: sovereign agent-core EXECUTE/dispatch organ.
2// Diff-lane / no-mocks: runs the REAL sovereign planner nx_ale_plan.elf to produce the ordered
3// plan, then the REAL sovereign executor nx_ale_exec.elf (both built nx_cc_sovereign->nxasm_x86_main,
4// NO gcc) over a REAL hello-class ALE fixture, and asserts:
5//   (1) STAGE            -- stage_input (step 1) copies the input_stage material into the sandbox:
6//                           the staged file EXISTS and byte-matches the materials_dir source
7//   (2) TRANSFORM        -- run_organ (step 2) applies the named deterministic transform: the
8//                           artifact's unit| lines are the transform of the staged kv| lines
9//   (3) ARTIFACT         -- write_artifact (step 3) produced a REAL non-empty file at artifact_path
10//   (4) ORDER/NO-LEAKAGE -- a malformed out-of-order plan is REFUSED, AND the artifact is byte-
11//                           identical whether a decoy reference is planted in the sandbox or not
12//                           (the executor never opens the reference path -> no leakage end-to-end)
13//   (5) DETERMINISTIC    -- two runs on the same (plan,task,fresh sandbox) yield a BYTE-IDENTICAL artifact
14//   (6) TAMPER REJECTED  -- a plan MISSING write_artifact -> child exits NON-ZERO and writes NO artifact
15//   (G) FEEDS GRADER     -- nx_ale_grade.elf (ALE-R1a) on the produced artifact + reference scores 1000
16// Evidence -> knowledge/status/ale_exec.log (ALEEXECGATE row; the queue row's ||MARK= reads it).
17// Sovereign orchestration (fork/dup3/execve/wait4 + mkdirat). license_tier: ORIGINAL
18import "nx_syscalls.nx"
19
20func g_p(s: *u8) -> i64 { var n: i64 = 0; while s[n] != (0 as u8) { n = n + 1 } sys_write(1, s, n); return 0 }
21func g_fp(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 }
22func g_fn(fd: i64, v: i64) -> i64 { let bb: *u8 = sys_mmap(28); var m: i64 = v; if m < 0 { m = 0 - m }; let t: *u8 = sys_mmap(28); var k: i64 = 0; if m == 0 { t[0] = 48; k = 1 }; while m > 0 { t[k] = (48 + (m % 10)) as u8; m = m / 10; k = k + 1 }; var i: i64 = 0; while i < k { bb[i] = t[k - 1 - i]; i = i + 1 }; sys_write(fd, bb, k); return 0 }
23
24// run nx_ale_plan.elf <task> <planout>; return child exit code
25func g_run_plan(task: *u8, planout: *u8) -> i64 {
  let pid: i64 = sys_fork()
  if pid == 0 {
      let dn: i64 = sys_openat_wr("/dev/null" as *u8, 0x1a4)
      if dn >= 0 { sys_dup3(dn, 1, 0); sys_dup3(dn, 2, 0) }
      let argv: *i64 = sys_mmap(32) as *i64
      argv[0] = "_offc/nx_ale_plan.elf" as *u8 as i64
      argv[1] = task as i64
      argv[2] = planout as i64
      argv[3] = 0
      let envp: *i64 = sys_mmap(16) as *i64
      envp[0] = 0
      sys_execve("_offc/nx_ale_plan.elf" as *u8, argv, envp)
      sys_exit(127)
  }
  let st: *i64 = sys_mmap(16) as *i64
  sys_wait4(pid, st, 0)
  return (st[0] >> 8) & 0xff
43}
44
45// run nx_ale_exec.elf <plan> <task> <sandbox>; return child exit code
46func g_run_exec(plan: *u8, task: *u8, sandbox: *u8) -> i64 {
  let pid: i64 = sys_fork()
  if pid == 0 {
      let dn: i64 = sys_openat_wr("/dev/null" as *u8, 0x1a4)
      if dn >= 0 { sys_dup3(dn, 1, 0); sys_dup3(dn, 2, 0) }
      let argv: *i64 = sys_mmap(48) as *i64
      argv[0] = "_offc/nx_ale_exec.elf" as *u8 as i64
      argv[1] = plan as i64
      argv[2] = task as i64
      argv[3] = sandbox as i64
      argv[4] = 0
      let envp: *i64 = sys_mmap(16) as *i64
      envp[0] = 0
      sys_execve("_offc/nx_ale_exec.elf" as *u8, argv, envp)
      sys_exit(127)
  }
  let st: *i64 = sys_mmap(16) as *i64
  sys_wait4(pid, st, 0)
  return (st[0] >> 8) & 0xff
65}
66
67// run nx_ale_grade.elf <ref> <artifact> <scoreout>; return child exit code
68func g_run_grade(ref: *u8, art: *u8, scoreout: *u8) -> i64 {
  let pid: i64 = sys_fork()
  if pid == 0 {
      let dn: i64 = sys_openat_wr("/dev/null" as *u8, 0x1a4)
      if dn >= 0 { sys_dup3(dn, 1, 0); sys_dup3(dn, 2, 0) }
      let argv: *i64 = sys_mmap(48) as *i64
      argv[0] = "_offc/nx_ale_grade.elf" as *u8 as i64
      argv[1] = ref as i64
      argv[2] = art as i64
      argv[3] = scoreout as i64
      argv[4] = 0
      let envp: *i64 = sys_mmap(16) as *i64
      envp[0] = 0
      sys_execve("_offc/nx_ale_grade.elf" as *u8, argv, envp)
      sys_exit(127)
  }
  let st: *i64 = sys_mmap(16) as *i64
  sys_wait4(pid, st, 0)
  return (st[0] >> 8) & 0xff
87}
88
89// read whole file into buf (cap), return byte count (0 on open-fail / empty)
90func g_read(path: *u8, buf: *u8, cap: i64) -> i64 {
  let fd: i64 = sys_openat_rd(path)
  if fd < 0 { return 0 }
  var n: i64 = 0
  var go: i64 = 1
  while go == 1 {
      let r: i64 = sys_read(fd, (buf as i64 + n) as *u8, cap - 1 - n)
      if r <= 0 { go = 0 } else { n = n + r }
      if n >= cap - 1 { go = 0 }
  }
  sys_close(fd)
  return n
102}
103
104func g_len(s: *u8) -> i64 { var n: i64 = 0; while s[n] != (0 as u8) { n = n + 1 } return n }
105
106// two files byte-identical?  1/0  (both must be non-empty)
107func g_files_eq(pa: *u8, pb: *u8) -> i64 {
  let ba: *u8 = sys_mmap(262144)
  let bb: *u8 = sys_mmap(262144)
  let na: i64 = g_read(pa, ba, 262144)
  let nb: i64 = g_read(pb, bb, 262144)
  if na != nb { return 0 }
  if na == 0 { return 0 }
  var i: i64 = 0
  while i < na { if ba[i] != bb[i] { return 0 } i = i + 1 }
  return 1
117}
118
119// does buf[pos..] match pat (len pl)?  1/0
120func g_match(buf: *u8, n: i64, pos: i64, pat: *u8, pl: i64) -> i64 {
  if pos + pl > n { return 0 }
  var k: i64 = 0
  while k < pl { if buf[pos + k] != pat[k] { return 0 } k = k + 1 }
  return 1
125}
126
127// is pos a line start? (pos==0 or previous byte is newline)
128func g_is_bol(buf: *u8, pos: i64) -> i64 {
  if pos == 0 { return 1 }
  if buf[pos - 1] == (10 as u8) { return 1 }
  return 0
132}
133
134// does the COMPLETE line `lit` (NUL-terminated, no newline) appear as a complete line in buf?  1/0
135func g_line_in(buf: *u8, n: i64, lit: *u8) -> i64 {
  let ll: i64 = g_len(lit)
  var j: i64 = 0
  while j < n {
      if g_is_bol(buf, j) == 1 {
          if g_match(buf, n, j, lit, ll) == 1 {
              let after: i64 = j + ll
              if after == n { return 1 }
              if after < n { if buf[after] == (10 as u8) { return 1 } }
          }
      }
      j = j + 1
  }
  return 0
149}
150
151// write n bytes from buf to a fresh file at path. 1/0.
152func g_write_file(path: *u8, buf: *u8, n: i64) -> i64 {
  let fd: i64 = sys_openat_wr(path, 0x1a4)
  if fd < 0 { return 0 }
  if n > 0 { sys_write(fd, buf, n) }
  sys_close(fd)
  return 1
158}
159
160func main() -> i64 {
  let task: *u8 = "knowledge/specs/ale_exec_examples/task_exec.txt" as *u8
  let materials: *u8 = "knowledge/specs/ale_exec_examples/materials/field_input.txt" as *u8
  let reference: *u8 = "knowledge/specs/ale_exec_examples/reference.txt" as *u8
  let planp: *u8 = "/tmp/_aleexec_g_plan" as *u8
  let sb1: *u8 = "/tmp/_aleexec_g_sb1" as *u8
  let sb2: *u8 = "/tmp/_aleexec_g_sb2" as *u8
  let sbdec: *u8 = "/tmp/_aleexec_g_sbdecoy" as *u8
  let sbbad: *u8 = "/tmp/_aleexec_g_sbbad" as *u8
  let art1: *u8 = "/tmp/_aleexec_g_sb1/result.units" as *u8
  let art2: *u8 = "/tmp/_aleexec_g_sb2/result.units" as *u8
  let artdec: *u8 = "/tmp/_aleexec_g_sbdecoy/result.units" as *u8
  let artbad: *u8 = "/tmp/_aleexec_g_sbbad/result.units" as *u8
  let staged1: *u8 = "/tmp/_aleexec_g_sb1/field_input.txt" as *u8
  let decoyref: *u8 = "/tmp/_aleexec_g_sbdecoy/reference.txt" as *u8
  let badplan: *u8 = "/tmp/_aleexec_g_badplan" as *u8
  let scoreout: *u8 = "/tmp/_aleexec_g_score" as *u8
177
  // ALE-R3a: 2nd transform (copy_verbatim) fixture paths
  let taskv: *u8 = "knowledge/specs/ale_exec_examples/task_exec_verbatim.txt" as *u8
  let matv: *u8 = "knowledge/specs/ale_exec_examples/materials/verbatim_units.txt" as *u8
  let refv: *u8 = "knowledge/specs/ale_exec_examples/reference_verbatim.txt" as *u8
  let planv: *u8 = "/tmp/_aleexec_g_planv" as *u8
  let sbv1: *u8 = "/tmp/_aleexec_g_sbv1" as *u8
  let sbv2: *u8 = "/tmp/_aleexec_g_sbv2" as *u8
  let sbvdec: *u8 = "/tmp/_aleexec_g_sbvdecoy" as *u8
  let sbunk: *u8 = "/tmp/_aleexec_g_sbunk" as *u8
  let artv1: *u8 = "/tmp/_aleexec_g_sbv1/result.copy" as *u8
  let artv2: *u8 = "/tmp/_aleexec_g_sbv2/result.copy" as *u8
  let artvdec: *u8 = "/tmp/_aleexec_g_sbvdecoy/result.copy" as *u8
  let artunk: *u8 = "/tmp/_aleexec_g_sbunk/result.copy" as *u8
  let stagedv1: *u8 = "/tmp/_aleexec_g_sbv1/verbatim_units.txt" as *u8
  let decoyrefv: *u8 = "/tmp/_aleexec_g_sbvdecoy/reference_verbatim.txt" as *u8
  let unkplan: *u8 = "/tmp/_aleexec_g_unkplan" as *u8
  let scorev: *u8 = "/tmp/_aleexec_g_scorev" as *u8
195
  g_p("=== ALE-exec gate (ALE-R2b/R3a: sovereign agent-core EXECUTE phase) ===\n" as *u8)
197
  // fresh sandbox dirs (mkdir is idempotent: -EEXIST is harmless; artifact writes use O_TRUNC)
  sys_mkdir(sb1, 0x1ed)
  sys_mkdir(sb2, 0x1ed)
  sys_mkdir(sbdec, 0x1ed)
  sys_mkdir(sbbad, 0x1ed)
  sys_mkdir(sbv1, 0x1ed)
  sys_mkdir(sbv2, 0x1ed)
  sys_mkdir(sbvdec, 0x1ed)
  sys_mkdir(sbunk, 0x1ed)
207
  // PLAN: produce the ordered plan from the task via the REAL planner (genuine plan->exec link)
  let rcplan: i64 = g_run_plan(task, planp)
210
  // EXEC #1 (good): run the executor over the fixture into sb1
  let rc1: i64 = g_run_exec(planp, task, sb1)
  // EXEC #2 (determinism): a 2nd fresh run into sb2
  let rc2: i64 = g_run_exec(planp, task, sb2)
215
  // (1) STAGE: staged file exists in sb1 AND byte-matches the materials source
  var c1: i64 = 0
  if g_files_eq(staged1, materials) == 1 { c1 = 1 }
219
  // (2) TRANSFORM: the artifact's unit| lines are the transform of the staged kv| lines.
  // Confirm the four expected unit| lines (kv| -> unit|) are present as complete lines.
  let abuf: *u8 = sys_mmap(262144)
  let an: i64 = g_read(art1, abuf, 262144)
  var c2: i64 = 0
  if g_line_in(abuf, an, "unit|row_count|3" as *u8) == 1 {
      if g_line_in(abuf, an, "unit|header|id,name,score" as *u8) == 1 {
          if g_line_in(abuf, an, "unit|sorted_by|id" as *u8) == 1 {
              if g_line_in(abuf, an, "unit|checksum|7a1c" as *u8) == 1 { c2 = 1 }
          }
      }
  }
232
  // (3) ARTIFACT: a real non-empty file at artifact_path under sb1, child exited 0
  var c3: i64 = 0
  if rc1 == 0 { if an > 0 { c3 = 1 } }
236
  // (4) ORDER/NO-LEAKAGE: artifact is byte-identical whether a decoy reference is planted in the
  // sandbox or not (the executor never opens the reference path). Plant a decoy reference in
  // sbdec, run there, and compare the produced artifact to sb1's (no-reference) artifact.
  let refbuf: *u8 = sys_mmap(262144)
  let refn: i64 = g_read(reference, refbuf, 262144)
  g_write_file(decoyref, refbuf, refn)
  let rcdec: i64 = g_run_exec(planp, task, sbdec)
  var c4: i64 = 0
  if rcdec == 0 { if g_files_eq(artdec, art1) == 1 { c4 = 1 } }
246
  // (5) DETERMINISTIC: sb1 and sb2 artifacts byte-identical
  var c5: i64 = 0
  if rc1 == 0 { if rc2 == 0 { if g_files_eq(art1, art2) == 1 { c5 = 1 } } }
250
  // (6) TAMPER REJECTED: a plan MISSING write_artifact -> non-zero exit AND no artifact written.
  // Author a malformed plan (only stage_input + run_organ, no write_artifact step).
  let bptxt: *u8 = "step|1|stage_input|field_input.txt\nstep|2|run_organ|extract_kv_to_units go\n" as *u8
  g_write_file(badplan, bptxt, g_len(bptxt))
  let rcbad: i64 = g_run_exec(badplan, task, sbbad)
  let bbuf: *u8 = sys_mmap(4096)
  let bn: i64 = g_read(artbad, bbuf, 4096)
  var c6: i64 = 0
  if rcbad != 0 { if bn == 0 { c6 = 1 } }
260
  // (G) FEEDS GRADER: nx_ale_grade on the produced artifact + reference scores 1000
  let rcg: i64 = g_run_grade(reference, art1, scoreout)
  let scbuf: *u8 = sys_mmap(64)
  let scn: i64 = g_read(scoreout, scbuf, 64)
  var score: i64 = 0
  var si: i64 = 0
  while si < scn {
      if scbuf[si] >= (48 as u8) { if scbuf[si] <= (57 as u8) { score = score * 10 + (scbuf[si] - 48) } }
      si = si + 1
  }
  var cg: i64 = 0
  if rcg == 0 { if score == 1000 { cg = 1 } }
273
  // ================= ALE-R3a: data-driven vocabulary + 2nd transform (copy_verbatim) =================
  // PLAN the verbatim task via the REAL planner; its instruction leading-token selects copy_verbatim.
  let rcplanv: i64 = g_run_plan(taskv, planv)
  // EXEC #1 (good) into sbv1, EXEC #2 (determinism) into sbv2
  let rcv1: i64 = g_run_exec(planv, taskv, sbv1)
  let rcv2: i64 = g_run_exec(planv, taskv, sbv2)
280
  // (7) COPY_VERBATIM ARTIFACT: child exited 0, real non-empty artifact == staged input (identity).
  let avbuf: *u8 = sys_mmap(262144)
  let avn: i64 = g_read(artv1, avbuf, 262144)
  var c7: i64 = 0
  if rcv1 == 0 { if avn > 0 { if g_files_eq(artv1, stagedv1) == 1 { c7 = 1 } } }
  // staged file present in sbv1 AND byte-matches the materials source (stage_input ran for transform 2 too)
  var c7s: i64 = 0
  if g_files_eq(stagedv1, matv) == 1 { c7s = 1 }
289
  // (8) FEEDS GRADER (2nd transform): nx_ale_grade(reference_verbatim, artv1) == 1000 -> no regression.
  let rcgv: i64 = g_run_grade(refv, artv1, scorev)
  let scvbuf: *u8 = sys_mmap(64)
  let scvn: i64 = g_read(scorev, scvbuf, 64)
  var scorev2: i64 = 0
  var svi: i64 = 0
  while svi < scvn {
      if scvbuf[svi] >= (48 as u8) { if scvbuf[svi] <= (57 as u8) { scorev2 = scorev2 * 10 + (scvbuf[svi] - 48) } }
      svi = svi + 1
  }
  var c8: i64 = 0
  if rcgv == 0 { if scorev2 == 1000 { c8 = 1 } }
302
  // (9) DETERMINISTIC (2nd transform): sbv1 and sbv2 artifacts byte-identical
  var c9: i64 = 0
  if rcv1 == 0 { if rcv2 == 0 { if g_files_eq(artv1, artv2) == 1 { c9 = 1 } } }
306
  // (10) NO-LEAKAGE (2nd transform): plant a decoy reference in sbvdec, run there, and confirm the
  // produced artifact is byte-identical to sbv1's -- the executor never opened the reference path.
  let refvbuf: *u8 = sys_mmap(262144)
  let refvn: i64 = g_read(refv, refvbuf, 262144)
  g_write_file(decoyrefv, refvbuf, refvn)
  let rcvdec: i64 = g_run_exec(planv, taskv, sbvdec)
  var c10: i64 = 0
  if rcvdec == 0 { if g_files_eq(artvdec, artv1) == 1 { c10 = 1 } }
315
  // (11) UNKNOWN-TOKEN REFUSED (data-driven negative control): a plan whose run_organ arg leads with
  // a token ABSENT from the vocabulary table -> child exits NON-ZERO and writes NO artifact.
  let uptxt: *u8 = "step|1|stage_input|verbatim_units.txt\nstep|2|run_organ|frobnicate the staged bytes somehow\nstep|3|write_artifact|result.copy\n" as *u8
  g_write_file(unkplan, uptxt, g_len(uptxt))
  let rcunk: i64 = g_run_exec(unkplan, taskv, sbunk)
  let ubuf: *u8 = sys_mmap(4096)
  let un: i64 = g_read(artunk, ubuf, 4096)
  var c11: i64 = 0
  if rcunk != 0 { if un == 0 { c11 = 1 } }
325
  g_p("  rc_plan=" as *u8); g_fn(1, rcplan)
  g_p(" rc_exec=" as *u8); g_fn(1, rc1)
  g_p(" art_bytes=" as *u8); g_fn(1, an)
  g_p(" rc_bad=" as *u8); g_fn(1, rcbad)
  g_p(" bad_art_bytes=" as *u8); g_fn(1, bn)
  g_p(" score=" as *u8); g_fn(1, score); g_p("\n" as *u8)
  g_p("  c1_stage=" as *u8); g_fn(1, c1)
  g_p(" c2_transform=" as *u8); g_fn(1, c2)
  g_p(" c3_artifact=" as *u8); g_fn(1, c3)
  g_p(" c4_order_no_leakage=" as *u8); g_fn(1, c4)
  g_p(" c5_deterministic=" as *u8); g_fn(1, c5)
  g_p(" c6_tamper_rejected=" as *u8); g_fn(1, c6)
  g_p(" cg_feeds_grader=" as *u8); g_fn(1, cg)
  g_p("\n" as *u8)
  // ALE-R3a diagnostics (2nd transform copy_verbatim, data-driven dispatch)
  g_p("  [R3a] rc_planv=" as *u8); g_fn(1, rcplanv)
  g_p(" rc_execv=" as *u8); g_fn(1, rcv1)
  g_p(" art_copy_bytes=" as *u8); g_fn(1, avn)
  g_p(" scorev=" as *u8); g_fn(1, scorev2)
  g_p(" rc_unknown=" as *u8); g_fn(1, rcunk)
  g_p(" unk_art_bytes=" as *u8); g_fn(1, un); g_p("\n" as *u8)
  g_p("  [R3a] c7_copy_artifact=" as *u8); g_fn(1, c7)
  g_p(" c7s_stage=" as *u8); g_fn(1, c7s)
  g_p(" c8_feeds_grader=" as *u8); g_fn(1, c8)
  g_p(" c9_deterministic=" as *u8); g_fn(1, c9)
  g_p(" c10_no_leakage=" as *u8); g_fn(1, c10)
  g_p(" c11_unknown_refused=" as *u8); g_fn(1, c11)
  g_p("\n" as *u8)
354
  var allok: i64 = 1
  if c1 == 0 { allok = 0 }
  if c2 == 0 { allok = 0 }
  if c3 == 0 { allok = 0 }
  if c4 == 0 { allok = 0 }
  if c5 == 0 { allok = 0 }
  if c6 == 0 { allok = 0 }
  if cg == 0 { allok = 0 }
363
  // ALE-R3a checks: the rung is GREEN only if BOTH transforms + the data-driven negative control pass.
  var r3aok: i64 = 1
  if c7 == 0 { r3aok = 0 }
  if c7s == 0 { r3aok = 0 }
  if c8 == 0 { r3aok = 0 }
  if c9 == 0 { r3aok = 0 }
  if c10 == 0 { r3aok = 0 }
  if c11 == 0 { r3aok = 0 }
  if r3aok == 0 { allok = 0 }
373
  let lfd: i64 = sys_openat_append("knowledge/status/ale_exec.log" as *u8, 0x1a4)
  if allok == 1 {
      g_p("ALEEXECGATE verdict=GREEN (stage transform artifact order+no-leakage deterministic; missing-write_artifact tamper REJECTED; feeds grader score=1000)\n" as *u8)
      g_p("ALEEXECVOCAB verdict=GREEN (data-driven vocabulary dispatch; copy_verbatim 2nd transform 1000 no-regression; deterministic; no-leakage; UNKNOWN token REFUSED)\n" as *u8)
      if lfd >= 0 {
          g_fp(lfd, "ALEEXECGATE verdict=GREEN stage=1 transform=1 artifact=1 order_no_leakage=1 deterministic=1 tamper_rejected=1 feeds_grader=1 score=1000 rung=ALE-R2b epoch=" as *u8)
          g_fn(lfd, sys_now_realtime_sec())
          g_fp(lfd, "\n" as *u8)
          g_fp(lfd, "ALEEXECVOCAB verdict=GREEN vocab_data_driven=1 copy_verbatim=1 copy_stage=1 copy_feeds_grader=1 score_kv=1000 score_copy=1000 deterministic=1 no_leakage=1 unknown_token_refused=1 both_no_regression=1 rung=ALE-R3a epoch=" as *u8)
          g_fn(lfd, sys_now_realtime_sec())
          g_fp(lfd, "\n" as *u8)
          sys_close(lfd)
      }
      sys_exit(0)
      return 0
  }
  g_p("ALEEXECGATE verdict=RED (a check did not fire)\n" as *u8)
  if lfd >= 0 {
      g_fp(lfd, "ALEEXECGATE verdict=RED c1=" as *u8); g_fn(lfd, c1)
      g_fp(lfd, " c2=" as *u8); g_fn(lfd, c2)
      g_fp(lfd, " c3=" as *u8); g_fn(lfd, c3)
      g_fp(lfd, " c4=" as *u8); g_fn(lfd, c4)
      g_fp(lfd, " c5=" as *u8); g_fn(lfd, c5)
      g_fp(lfd, " c6=" as *u8); g_fn(lfd, c6)
      g_fp(lfd, " cg=" as *u8); g_fn(lfd, cg)
      g_fp(lfd, "\n" as *u8)
      g_fp(lfd, "ALEEXECVOCAB verdict=RED c7=" as *u8); g_fn(lfd, c7)
      g_fp(lfd, " c7s=" as *u8); g_fn(lfd, c7s)
      g_fp(lfd, " c8=" as *u8); g_fn(lfd, c8)
      g_fp(lfd, " c9=" as *u8); g_fn(lfd, c9)
      g_fp(lfd, " c10=" as *u8); g_fn(lfd, c10)
      g_fp(lfd, " c11=" as *u8); g_fn(lfd, c11)
      g_fp(lfd, " rung=ALE-R3a\n" as *u8)
      sys_close(lfd)
  }
  sys_exit(1)
  return 1
411}
_ale_exec_gate.nx source

`_ale_exec_gate.nx` source
