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

↩ module page · 2097 lines · 95407 B
1// nx_wasm_craft_gate.nx -- verifies the GENERATED 3D WORLD natively (same base-relative code the
2// wasm runs). The DDA renderer is checked against GROUND TRUTH (a direct grid scan says what the ray
3// must hit), edits are causal (break removes THE targeted voxel, place fills its face-neighbor),
4// the world loop is deterministic, and the input layer's edge contract holds inside the wired game
5// (E held two frames breaks exactly ONE block). PNGs land in knowledge/ for the eyeball + critics.
6// license_tier: ORIGINAL  expect_exit: 0
7import "nx_wasm_craft.nx"
8import "nx_png_write.nx"
9import "nx_gate_verdict.nx"
10const K_MAGIC_1000000007: i64 = 1000000007
11const K_MAGIC_4096: i64 = 4096
12const K_MAGIC_20260728: i64 = 20260728
13const K_MAGIC_3000: i64 = 3000
14const K_MAGIC_999999: i64 = 999999
15const K_MAGIC_12345: i64 = 12345
16const K_MAGIC_424242: i64 = 424242
17const K_MAGIC_1024: i64 = 1024
18const K_MAGIC_1536: i64 = 1536
19const K_MAGIC_6144: i64 = 6144
20const K_MAGIC_8191: i64 = 8191
21const K_MAGIC_57344: i64 = 57344
22const K_MAGIC_4611686018427387903: i64 = 4611686018427387903
23
24func vw(s: *u8) -> i64 { var n: i64=0; while s[n]!=(0 as u8){n=n+1} sys_write(1,s,n); return 0 }
25func vn(v: i64) -> i64 {
  let t: *u8 = sys_mmap(32) as *u8
  var m: i64 = v; var w: i64 = 0
  if m<0 { t[w]=45 as u8; w=w+1; m=0-m }
  if m==0 { t[w]=48 as u8; sys_write(1,t,w+1); return 0 }
  let d: *u8 = sys_mmap(32) as *u8
  var k: i64=0
  while m>0 { d[k]=(48+(m%10)) as u8; m=m/10; k=k+1 }
  var j: i64=0
  while j<k { t[w]=d[k-1-j]; w=w+1; j=j+1 }
  sys_write(1,t,w); return 0
36}
37func emit(base: i64, path: *u8) -> i64 {
  let rgbbuf: *u8 = sys_mmap(W*H*3) as *u8
  let f: *i64 = wfb(base)
  var p: i64 = 0
  while p < W*H {
      let v: i64 = f[p]
      rgbbuf[p*3]   = (v & 255) as u8
      rgbbuf[p*3+1] = ((v >> 8) & 255) as u8
      rgbbuf[p*3+2] = ((v >> 16) & 255) as u8
      p = p + 1
  }
  return nx_png_write_rgb(path, rgbbuf, W, H)
49}
50func fbck(base: i64) -> i64 {
  let f: *i64 = wfb(base)
  var ck: i64 = 0
  var z: i64 = 0
  while z < W*H { ck = (ck ^ f[z]) * 3 % K_MAGIC_1000000007; z = z + 37 }
  return ck
56}
57func nblocks(base: i64) -> i64 {
  var n: i64 = 0
  var y: i64 = 0
  while y < WY { var z: i64 = 0
      while z < WZ { var x: i64 = 0
          while x < WX { if vget(base,x,y,z) != 0 { n = n + 1 } x = x + 1 }
          z = z + 1 }
      y = y + 1 }
  return n
66}
67
68func main() -> i64 {
  let base: i64 = sys_mmap(CRAFT_TOTAL + K_MAGIC_4096) as i64
  var pass: i64 = 0
  let total: i64 = 54
  vw("=== nx_wasm_craft native verify (generated 3D voxel world) ===\n" as *u8)
73
  init_impl(base, K_MAGIC_20260728)
  let s: *i64 = wst(base)
76
  // T1 worldgen: a real mixed world -- air majority, grass+stone+water+trees all present
  var cair: i64 = 0
  var cgrass: i64 = 0
  var cstone: i64 = 0
  var cwater: i64 = 0
  var cwood: i64 = 0
  var y1: i64 = 0
  while y1 < WY { var z1: i64 = 0
      while z1 < WZ { var x1: i64 = 0
          while x1 < WX {
              let b: i64 = vget(base,x1,y1,z1)
              if b == 0 { cair = cair + 1 }
              if b == 1 { cgrass = cgrass + 1 }
              if b == 3 { cstone = cstone + 1 }
              if b == 4 { cwater = cwater + 1 }
              if b == 6 { cwood = cwood + 1 }
              x1 = x1 + 1 }
          z1 = z1 + 1 }
      y1 = y1 + 1 }
  let tot: i64 = WX*WY*WZ
  vw("T1 permil air=" as *u8); vn(cair*1000/tot); vw(" grass=" as *u8); vn(cgrass*1000/tot)
  vw(" stone=" as *u8); vn(cstone*1000/tot); vw(" water=" as *u8); vn(cwater*1000/tot)
  vw(" wood-blocks=" as *u8); vn(cwood); vw("\n" as *u8)
  if cair*1000/tot > 450 { if cgrass > 0 { if cstone > 0 { if cwater > 0 { if cwood > 0 {
      pass = pass + 1 } } } } }
102
  // T2 GROUND TRUTH: a straight-down ray must hit exactly what a direct grid scan says is
  // the topmost non-air block of the camera's column -- and on its TOP face
  let gx: i64 = 20
  let gz: i64 = 44
  var expect: i64 = 0 - 1
  var ys: i64 = WY - 1
  while ys >= 0 {
      if expect < 0 { if vget(base, gx, ys, gz) != 0 { expect = ys } }
      ys = ys - 1
  }
  let cx0: i64 = s[S_CX]
  let cy0: i64 = s[S_CY]
  let cz0: i64 = s[S_CZ]
  s[S_CX] = gx*256 + 128
  s[S_CY] = (WY - 1)*256
  s[S_CZ] = gz*256 + 128
  let hout: *i64 = sys_mmap(64) as *i64
  let hs: i64 = wray(base, 0, 0-K_MAGIC_4096, 0, 200, hout)
  vw("T2 down-ray hit y=" as *u8); vn(hout[1]); vw(" face=" as *u8); vn(hout[3])
  vw(" grid-truth y=" as *u8); vn(expect); vw("\n" as *u8)
  if hs > 0 { if hout[0] == gx { if hout[2] == gz { if hout[1] == expect { if hout[3] == 3 {
      pass = pass + 1 } } } } }
  s[S_CX] = cx0
  s[S_CY] = cy0
  s[S_CZ] = cz0
128
  // T3 render: sky above, world below, real colour variety; PNG banked
  render_impl(base)
  let f: *i64 = wfb(base)
  var distinct: i64 = 0
  var seen: *i64 = sys_mmap(K_MAGIC_4096*8) as *i64
  var q: i64 = 0
  while q < K_MAGIC_4096 { seen[q]=0; q=q+1 }
  var p2: i64 = 0
  while p2 < W*H {
      let k: i64 = ((f[p2] & 255)/16)*256 + (((f[p2]>>8)&255)/16)*16 + ((f[p2]>>16)&255)/16
      if seen[k%K_MAGIC_4096]==0 { seen[k%K_MAGIC_4096]=1; distinct=distinct+1 }
      p2 = p2 + 1
  }
  let top: i64 = f[4*W + W/2]
  let skyish: i64 = ((top >> 16) & 255)
  vw("T3 distinct=" as *u8); vn(distinct)
  vw(" top-px blue=" as *u8); vn(skyish); vw(" red=" as *u8); vn(top & 255); vw("\n" as *u8)
  if distinct > 40 { if skyish > (top & 255) { pass = pass + 1 } }
  emit(base, "knowledge/nx_wasm_craft_start.png" as *u8)
148
  // T4 walk moves the camera; the whole run is DETERMINISTIC across two fresh arenas
  let baseB: i64 = sys_mmap(CRAFT_TOTAL + K_MAGIC_4096) as i64
  init_impl(baseB, K_MAGIC_20260728)
  var mv: i64 = 0
  while mv < 30 { tick_impl(base, 0); tick_impl(baseB, 0); mv = mv + 1 }
  var tn2: i64 = 0
  while tn2 < 10 { tick_impl(base, 3); tick_impl(baseB, 3); tn2 = tn2 + 1 }
  var mv2: i64 = 0
  while mv2 < 20 { tick_impl(base, 0); tick_impl(baseB, 0); mv2 = mv2 + 1 }
  render_impl(base)
  render_impl(baseB)
  let ckA: i64 = fbck(base)
  let ckB: i64 = fbck(baseB)
  let sB: *i64 = wst(baseB)
  var movedq: i64 = s[S_CX] - (WX/2*256 + 128)
  if movedq < 0 { movedq = 0 - movedq }
  vw("T4 moved-q8=" as *u8); vn(movedq); vw(" ckA=" as *u8); vn(ckA)
  vw(" ckB=" as *u8); vn(ckB); vw("\n" as *u8)
  if movedq > 256 { if ckA == ckB { if s[S_CX] == sB[S_CX] { if s[S_CY] == sB[S_CY] {
      pass = pass + 1 } } } }
169
  // T5 BREAK is causal: look down, the targeted voxel -- and only a real one -- goes to air
  s[S_PITCH] = 0 - K_MAGIC_3000
  apply_impl(base, 0, 0, 0, 0, 0)
  let hx: i64 = s[S_HX]
  let hy: i64 = s[S_HY]
  let hz: i64 = s[S_HZ]
  let was: i64 = vget(base, hx, hy, hz)
  let nb0: i64 = nblocks(base)
  tick_impl(base, 4)
  let now: i64 = vget(base, hx, hy, hz)
  let nb1: i64 = nblocks(base)
  vw("T5 target-was=" as *u8); vn(was); vw(" now=" as *u8); vn(now)
  vw(" hok-was=1 blocks " as *u8); vn(nb0); vw("->" as *u8); vn(nb1); vw("\n" as *u8)
  if was != 0 { if now == 0 { if nb1 == nb0 - 1 { if s[S_BROKEN] == 1 { pass = pass + 1 } } } }
184
  // T6 PLACE is causal: exactly one new block appears on the targeted face
  apply_impl(base, 0, 0, 0, 0, 0)
  let nb2: i64 = nblocks(base)
  tick_impl(base, 5)
  let nb3: i64 = nblocks(base)
  vw("T6 place blocks " as *u8); vn(nb2); vw("->" as *u8); vn(nb3)
  vw(" placed=" as *u8); vn(s[S_PLACED]); vw("\n" as *u8)
  if nb3 == nb2 + 1 { if s[S_PLACED] == 1 { pass = pass + 1 } }
193
  // T7 EDGE HONESTY inside the wired game: E held across two input frames breaks EXACTLY ONE
  let baseC: i64 = sys_mmap(CRAFT_TOTAL + K_MAGIC_4096) as i64
  init_impl(baseC, K_MAGIC_20260728)
  let sC: *i64 = wst(baseC)
  sC[S_PITCH] = 0 - K_MAGIC_3000
  apply_impl(baseC, 0, 0, 0, 0, 0)
  ia_key(winp(baseC), 69, 1)
  step_impl(baseC)
  step_impl(baseC)
  vw("T7 E-held-2-frames broken=" as *u8); vn(sC[S_BROKEN]); vw(" (must be 1)\n" as *u8)
  if sC[S_BROKEN] == 1 { pass = pass + 1 }
205
  // T8 the edit is VISIBLE: the frame checksum moves after break+place, PNG banked
  render_impl(base)
  let ck2: i64 = fbck(base)
  vw("T8 frame ck " as *u8); vn(ckA); vw(" -> " as *u8); vn(ck2); vw("\n" as *u8)
  if ck2 != ckA { pass = pass + 1 }
  emit(base, "knowledge/nx_wasm_craft_edit.png" as *u8)
212
  // T9 STRAFE: at yaw 0, strafe=1 moves +x and leaves z alone (right = east by the basis math)
  let baseS: i64 = sys_mmap(CRAFT_TOTAL + K_MAGIC_4096) as i64
  init_impl(baseS, K_MAGIC_20260728)
  let sS: *i64 = wst(baseS)
  var set9: i64 = 0
  while set9 < 4 { apply2_impl(baseS, 0, 0, 0, 0, 0, 0, 0, 0, 0); set9 = set9 + 1 }
  let sx9: i64 = sS[S_CX]
  let sz9: i64 = sS[S_CZ]
  var m9: i64 = 0
  while m9 < 6 { apply2_impl(baseS, 0, 1, 0, 0, 0, 0, 0, 0, 0); m9 = m9 + 1 }
  vw("T9 strafe dx=" as *u8); vn(sS[S_CX] - sx9)
  vw(" dz=" as *u8); vn(sS[S_CZ] - sz9); vw(" (must be +,0)\n" as *u8)
  if sS[S_CX] > sx9 { if sS[S_CZ] == sz9 { pass = pass + 1 } }
226
  // T10 JUMP: parabola -- rises off the stand, comes back down, lands (grounded again)
  var set10: i64 = 0
  while set10 < 6 { apply2_impl(baseS, 0, 0, 0, 0, 0, 0, 0, 0, 0); set10 = set10 + 1 }
  let y0: i64 = sS[S_CY]
  let g0: i64 = sS[S_GROUNDED]
  apply2_impl(baseS, 0, 0, 0, 0, 0, 0, 1, 0, 0)
  var peak: i64 = sS[S_CY]
  var t10i: i64 = 0
  var landed: i64 = 0
  while t10i < 40 {
      apply2_impl(baseS, 0, 0, 0, 0, 0, 0, 0, 0, 0)
      if sS[S_CY] > peak { peak = sS[S_CY] }
      if landed == 0 { if sS[S_GROUNDED] == 1 { landed = 1 } }
      t10i = t10i + 1
  }
  var back10: i64 = 0
  if sS[S_CY] == y0 { back10 = 1 }
  vw("T10 jump y0=" as *u8); vn(y0); vw(" peak=" as *u8); vn(peak)
  vw(" (+" as *u8); vn(peak - y0); vw(") landed-back=" as *u8); vn(back10)
  vw(" grounded0=" as *u8); vn(g0); vw("\n" as *u8)
  if g0 == 1 { if peak > y0 + 100 { if landed == 1 { if sS[S_CY] == y0 { pass = pass + 1 } } } }
248
  // T11 MOUSELOOK: lookx/looky move yaw/pitch by EXACTLY delta*LOOKS (and pitch clamps)
  let yaw0: i64 = sS[S_YAW]
  let pit0: i64 = sS[S_PITCH]
  apply2_impl(baseS, 0, 0, 0, 100, 50, 0, 0, 0, 0)
  let dyaw: i64 = sS[S_YAW] - yaw0
  let dpit: i64 = pit0 - sS[S_PITCH]
  apply2_impl(baseS, 0, 0, 0, 0, 0-K_MAGIC_999999, 0, 0, 0, 0)
  let pmax: i64 = sS[S_PITCH]
  vw("T11 look dyaw=" as *u8); vn(dyaw); vw(" (want " as *u8); vn(100*LOOKS)
  vw(") dpit=" as *u8); vn(dpit); vw(" (want " as *u8); vn(50*LOOKS)
  vw(") clamp=" as *u8); vn(pmax); vw("\n" as *u8)
  if dyaw == 100*LOOKS { if dpit == 50*LOOKS { if pmax == PITCH_MAX { pass = pass + 1 } } }
261
  // T12 CAVES: air pockets exist strictly under a solid roof (not surface sky)
  var caves: i64 = 0
  var cy12: i64 = 2
  while cy12 < WY - 4 { var cz12: i64 = 0
      while cz12 < WZ { var cx12: i64 = 0
          while cx12 < WX {
              if vget(baseS, cx12, cy12, cz12) == 0 { if vsolid(baseS, cx12, cy12 + 1, cz12) == 1 {
                  caves = caves + 1 } }
              cx12 = cx12 + 1 }
          cz12 = cz12 + 1 }
      cy12 = cy12 + 1 }
  vw("T12 roofed-air cells (caves) = " as *u8); vn(caves); vw("\n" as *u8)
  if caves > 400 { pass = pass + 1 }
275
  // T13 ORES: coal, iron, gold all present in the stone
  var oc: i64 = 0
  var oi: i64 = 0
  var og: i64 = 0
  var oy: i64 = 0
  while oy < WY { var oz: i64 = 0
      while oz < WZ { var ox: i64 = 0
          while ox < WX {
              let ob: i64 = vget(baseS, ox, oy, oz)
              if ob == 9 { oc = oc + 1 }
              if ob == 10 { oi = oi + 1 }
              if ob == 11 { og = og + 1 }
              ox = ox + 1 }
          oz = oz + 1 }
      oy = oy + 1 }
  vw("T13 ores coal=" as *u8); vn(oc); vw(" iron=" as *u8); vn(oi)
  vw(" gold=" as *u8); vn(og); vw("\n" as *u8)
  if oc > 0 { if oi > 0 { if og > 0 { if oc > oi { pass = pass + 1 } } } }
294
  // T14 HOTBAR: Q-cycle wraps 7->0 (5 blocks + hoe + seeds since the farming rung), and
  // PLACE uses the selected type (dirt after one cycle)
  let baseH: i64 = sys_mmap(CRAFT_TOTAL + K_MAGIC_4096) as i64
  init_impl(baseH, K_MAGIC_20260728)
  let sH: *i64 = wst(baseH)
  var t14: i64 = 0
  var cyc: i64 = 0
  while cyc < 7 { wc_cycle(baseH); cyc = cyc + 1 }
  if sH[S_SEL] == 0 { t14 = t14 + 1 }
  wc_cycle(baseH)
  if sH[S_SEL] == 1 { t14 = t14 + 1 }
  sH[S_PITCH] = 0 - K_MAGIC_3000
  apply2_impl(baseH, 0, 0, 0, 0, 0, 0, 0, 0, 0)
  tick_impl(baseH, 4)
  apply2_impl(baseH, 0, 0, 0, 0, 0, 0, 0, 0, 0)
  let phx: i64 = sH[S_HX]
  let phy: i64 = sH[S_HY]
  let phz: i64 = sH[S_HZ]
  let phf: i64 = sH[S_HFACE]
  var wpx: i64 = phx
  var wpy: i64 = phy
  var wpz: i64 = phz
  if phf == 1 { wpx = wpx + 1 }
  if phf == 2 { wpx = wpx - 1 }
  if phf == 3 { wpy = wpy + 1 }
  if phf == 4 { wpy = wpy - 1 }
  if phf == 5 { wpz = wpz + 1 }
  if phf == 6 { wpz = wpz - 1 }
  tick_impl(baseH, 5)
  if sH[S_PLACED] == 1 { if vget(baseH, wpx, wpy, wpz) == 2 { t14 = t14 + 1 } }
  vw("T14 hotbar wrap+select-type: " as *u8); vn(t14); vw("/3 (placed block=" as *u8)
  vn(vget(baseH, wpx, wpy, wpz)); vw(" want 2=dirt)\n" as *u8)
  if t14 == 3 { pass = pass + 1 }
328
  // T15 SAVE: bit-exact round trip; corrupt image REFUSED untouched; future version REFUSED
  let baseP: i64 = sys_mmap(CRAFT_TOTAL + K_MAGIC_4096) as i64
  init_impl(baseP, K_MAGIC_20260728)
  let sP: *i64 = wst(baseP)
  sP[S_PITCH] = 0 - K_MAGIC_3000
  apply2_impl(baseP, 0, 0, 0, 0, 0, 0, 0, 0, 0)
  tick_impl(baseP, 4)                                  // one edit so the save is non-trivial
  let ehx: i64 = sP[S_HX]
  let ehy: i64 = sP[S_HY]
  let ehz: i64 = sP[S_HZ]
  let excam: i64 = sP[S_CX]
  let n15: i64 = wc_save_build(baseP)
  let img: *u8 = sys_mmap(SAVE_LEN + 64)
  let src: *u8 = (baseP + O_SAVE) as *u8
  var c15: i64 = 0
  while c15 < n15 { img[c15] = src[c15]; c15 = c15 + 1 }
  init_impl(baseP, 999)                                 // a DIFFERENT world entirely
  var t15: i64 = 0
  var c15b: i64 = 0
  while c15b < n15 { src[c15b] = img[c15b]; c15b = c15b + 1 }
  let arc: i64 = wc_save_apply(baseP)
  if arc == 0 { if vget(baseP, ehx, ehy, ehz) == 0 { if sP[S_CX] == excam { if sP[S_BROKEN] == 1 {
      t15 = t15 + 1 } } } }
  // corrupt one voxel byte -> checksum must refuse and the restored world must stay intact
  src[SAVE_HDR + K_MAGIC_12345] = (src[SAVE_HDR + K_MAGIC_12345] + 1) as u8
  let arc2: i64 = wc_save_apply(baseP)
  if arc2 == 0 - 3 { if vget(baseP, ehx, ehy, ehz) == 0 { t15 = t15 + 1 } }
  // future version refused
  src[SAVE_HDR + K_MAGIC_12345] = (src[SAVE_HDR + K_MAGIC_12345] - 1) as u8
  let hd15: *i64 = (baseP + O_SAVE) as *i64
  hd15[1] = 99
  let arc3: i64 = wc_save_apply(baseP)
  if arc3 == 0 - 2 { t15 = t15 + 1 }
  vw("T15 save roundtrip/corrupt-refuse/version-refuse: " as *u8); vn(t15)
  vw("/3 (rcs " as *u8); vn(arc); vw("," as *u8); vn(arc2); vw("," as *u8); vn(arc3); vw(")\n" as *u8)
  if t15 == 3 { pass = pass + 1 }
365
  // T16 MOBS SPAWN (composed nx_entity_store): 12 creatures, every one standing on solid ground
  let baseM: i64 = sys_mmap(CRAFT_TOTAL + K_MAGIC_4096) as i64
  init_impl(baseM, K_MAGIC_20260728)
  let mm: *i64 = mobp(baseM)
  var okm: i64 = 0
  var km: i64 = 0
  while km < en_count(mm) {
      let hm: i64 = en_nth(mm, km)
      if hm > 0 {
          let mxq: i64 = en_get(mm, hm, MC_X)
          let myq: i64 = en_get(mm, hm, MC_Y)
          let mzq: i64 = en_get(mm, hm, MC_Z)
          if vsolid(baseM, mxq >> 8, (myq >> 8) - 1, mzq >> 8) == 1 {
              if en_get(mm, hm, MC_KIND) < 3 { okm = okm + 1 }
          }
      }
      km = km + 1
  }
  vw("T16 mobs spawned=" as *u8); vn(en_count(mm))
  vw(" on-solid+valid=" as *u8); vn(okm); vw("\n" as *u8)
  if en_count(mm) == 12 { if okm == 12 { pass = pass + 1 } }
387
  // T17 MOBS MOVE and the whole sim stays deterministic across two arenas
  let baseM2: i64 = sys_mmap(CRAFT_TOTAL + K_MAGIC_4096) as i64
  init_impl(baseM2, K_MAGIC_20260728)
  let m2: *i64 = mobp(baseM2)
  let x0m: i64 = en_get(mm, en_nth(mm, 0), MC_X)
  let z0m: i64 = en_get(mm, en_nth(mm, 0), MC_Z)
  let ph0m: i64 = en_get(mm, en_nth(mm, 0), MC_PH)
  var tm: i64 = 0
  while tm < 60 { tick_impl(baseM, 9); tick_impl(baseM2, 9); tm = tm + 1 }
  var movedm: i64 = 0
  var eqm: i64 = 1
  var km2: i64 = 0
  while km2 < en_count(mm) {
      let ha: i64 = en_nth(mm, km2)
      let hb: i64 = en_nth(m2, km2)
      if en_get(mm, ha, MC_X) != en_get(m2, hb, MC_X) { eqm = 0 }
      if en_get(mm, ha, MC_Z) != en_get(m2, hb, MC_Z) { eqm = 0 }
      km2 = km2 + 1
  }
  let x1m: i64 = en_get(mm, en_nth(mm, 0), MC_X)
  let z1m: i64 = en_get(mm, en_nth(mm, 0), MC_Z)
  var dm: i64 = x1m - x0m
  if dm < 0 { dm = 0 - dm }
  var dm2: i64 = z1m - z0m
  if dm2 < 0 { dm2 = 0 - dm2 }
  vw("T17 mob0 moved-q8=" as *u8); vn(dm + dm2)
  vw(" ph " as *u8); vn(ph0m); vw("->" as *u8); vn(en_get(mm, en_nth(mm, 0), MC_PH))
  vw(" arenas-equal=" as *u8); vn(eqm); vw("\n" as *u8)
  if dm + dm2 > 30 { if eqm == 1 { pass = pass + 1 } }
417
  // T18 SAVE v3 carries the mobs: positions survive build -> fresh world -> apply EXACTLY
  let sx18: i64 = en_get(mm, en_nth(mm, 3), MC_X)
  let sz18: i64 = en_get(mm, en_nth(mm, 3), MC_Z)
  wc_save_build(baseM)
  let img18: *u8 = sys_mmap(SAVE_LEN + 64)
  let src18: *u8 = (baseM + O_SAVE) as *u8
  var c18: i64 = 0
  while c18 < SAVE_LEN { img18[c18] = src18[c18]; c18 = c18 + 1 }
  init_impl(baseM, K_MAGIC_424242)
  var c18b: i64 = 0
  while c18b < SAVE_LEN { src18[c18b] = img18[c18b]; c18b = c18b + 1 }
  let arc18: i64 = wc_save_apply(baseM)
  let rx18: i64 = en_get(mm, en_nth(mm, 3), MC_X)
  let rz18: i64 = en_get(mm, en_nth(mm, 3), MC_Z)
  vw("T18 mob3 save-roundtrip rc=" as *u8); vn(arc18)
  vw(" pos-match=" as *u8)
  var pm18: i64 = 0
  if rx18 == sx18 { if rz18 == sz18 { pm18 = 1 } }
  vn(pm18); vw(" count=" as *u8); vn(en_count(mm)); vw("\n" as *u8)
  if arc18 == 0 { if pm18 == 1 { if en_count(mm) == 12 { pass = pass + 1 } } }
438
  // T19 TEXTURES: per-texel variation must MULTIPLY the frame's real colour variety vs the flat
  // era (which measured 84 distinct) -- and the frame stays deterministic (same ck both arenas,
  // already proven by T4 on the textured render)
  var distinct19: i64 = 0
  var seen19: *i64 = sys_mmap(K_MAGIC_4096*8) as *i64
  var q19: i64 = 0
  while q19 < K_MAGIC_4096 { seen19[q19]=0; q19=q19+1 }
  let f19: *i64 = wfb(base)
  var p19: i64 = 0
  while p19 < W*H {
      let k19: i64 = ((f19[p19] & 255)/8)*K_MAGIC_1024 + (((f19[p19]>>8)&255)/8)*32 + ((f19[p19]>>16)&255)/8
      if seen19[k19%K_MAGIC_4096]==0 { seen19[k19%K_MAGIC_4096]=1; distinct19=distinct19+1 }
      p19 = p19 + 1
  }
  vw("T19 textured distinct=" as *u8); vn(distinct19); vw(" (flat era was 84; need >200)\n" as *u8)
  if distinct19 > 200 { pass = pass + 1 }
455
  // T20 ADAPTIVE QUALITY: sustained slow frames coarsen 2->5 and stop; sustained fast frames
  // refine back to 2 and stop; the EMA hysteresis never leaves the 2..5 band
  let baseQ: i64 = sys_mmap(CRAFT_TOTAL + K_MAGIC_4096) as i64
  init_impl(baseQ, K_MAGIC_20260728)
  let sQ: *i64 = wst(baseQ)
  var t20: i64 = 0
  var i20: i64 = 0
  while i20 < 80 { wc_framems(baseQ, 40); i20 = i20 + 1 }
  if sQ[S_Q] == 5 { t20 = t20 + 1 }
  var i20b: i64 = 0
  while i20b < 300 { wc_framems(baseQ, 4); i20b = i20b + 1 }
  if sQ[S_Q] == 1 { t20 = t20 + 1 }                 // sustained-fast refines all the way to NATIVE res
  var i20c: i64 = 0
  while i20c < 100 { wc_framems(baseQ, 16); i20c = i20c + 1 }
  if sQ[S_Q] == 1 { t20 = t20 + 1 }                 // 16ms = healthy 60fps work: NO flapping
  vw("T20 adaptive q slow->5 fast->1(native) steady-16ms->stays: " as *u8); vn(t20); vw("/3 (q=" as *u8)
  vn(sQ[S_Q]); vw(")\n" as *u8)
  if t20 == 3 { pass = pass + 1 }
474
  // T22 WATER TRANSPARENCY semantics: over a water column, the plain ray stops at the water
  // surface; the skip-water ray reaches the SOLID FLOOR beneath it
  var wx22: i64 = 0 - 1
  var wz22: i64 = 0 - 1
  var sz22: i64 = 0
  while sz22 < WZ {
      var sx22: i64 = 0
      while sx22 < WX {
          if wx22 < 0 { if vget(baseQ, sx22, WATER_H, sz22) == 4 { wx22 = sx22; wz22 = sz22 } }
          sx22 = sx22 + 1
      }
      sz22 = sz22 + 1
  }
  var t22: i64 = 0
  if wx22 >= 0 {
      let sQ2: *i64 = wst(baseQ)
      sQ2[S_CX] = wx22*256 + 128
      sQ2[S_CY] = (WY - 2)*256
      sQ2[S_CZ] = wz22*256 + 128
      let wout: *i64 = sys_mmap(64) as *i64
      let h1: i64 = wray(baseQ, 0, 0-K_MAGIC_4096, 0, 200, wout)
      let y1: i64 = wout[1]
      let b1: i64 = vget(baseQ, wout[0], wout[1], wout[2])
      let h2: i64 = wray2(baseQ, 0, 0-K_MAGIC_4096, 0, 200, wout, 1)
      let y2: i64 = wout[1]
      let b2: i64 = vget(baseQ, wout[0], wout[1], wout[2])
      vw("T22 water col(" as *u8); vn(wx22); vw("," as *u8); vn(wz22)
      vw(") plain-hit y=" as *u8); vn(y1); vw(" b=" as *u8); vn(b1)
      vw(" skipw-hit y=" as *u8); vn(y2); vw(" b=" as *u8); vn(b2); vw("\n" as *u8)
      if h1 > 0 { if b1 == 4 { if h2 > 0 { if y2 < y1 { if b2 != 4 { if b2 != 0 {
          t22 = 1 } } } } } }
  }
  if t22 == 1 { pass = pass + 1 }
508
  // T23 NATIVE RESOLUTION renders: q=1 full 480x300 rays from the SPAWN vista (T22 parked the
  // camera over edge water staring at sky -- a viewpoint, not a quality, measurement)
  init_impl(baseQ, K_MAGIC_20260728)
  let sQ3: *i64 = wst(baseQ)
  sQ3[S_Q] = 1
  render_impl(baseQ)
  let f23: *i64 = wfb(baseQ)
  var distinct23: i64 = 0
  var seen23: *i64 = sys_mmap(K_MAGIC_4096*8) as *i64
  var q23: i64 = 0
  while q23 < K_MAGIC_4096 { seen23[q23]=0; q23=q23+1 }
  var p23: i64 = 0
  while p23 < W*H {
      let k23: i64 = ((f23[p23] & 255)/8)*K_MAGIC_1024 + (((f23[p23]>>8)&255)/8)*32 + ((f23[p23]>>16)&255)/8
      if seen23[k23%K_MAGIC_4096]==0 { seen23[k23%K_MAGIC_4096]=1; distinct23=distinct23+1 }
      p23 = p23 + 1
  }
  sQ3[S_Q] = 2
  vw("T23 native-res q=1 distinct=" as *u8); vn(distinct23); vw(" (need >200)\n" as *u8)
  if distinct23 > 200 { pass = pass + 1 }
529
  // T21 RENDER PURITY vs the INPUT ARENA: a full render must not write ONE input word. This
  // fence exists because wray grew a 5th output and a slot-60 scratch put out[4] at slot 64 =
  // O_INPUT[0]: every pixel stomped the keyboard mask (5 keys stuck, pitch pinned, 15fps).
  let inpQ: *i64 = winp(baseQ)
  ia_key(inpQ, 87, 1)
  ia_key(inpQ, 69, 1)
  var snap21: i64 = 0
  var i21: i64 = 0
  while i21 < 8 { snap21 = (snap21*131 + inpQ[i21]) % K_MAGIC_1000000007; i21 = i21 + 1 }
  render_impl(baseQ)
  var snap21b: i64 = 0
  var i21b: i64 = 0
  while i21b < 8 { snap21b = (snap21b*131 + inpQ[i21b]) % K_MAGIC_1000000007; i21b = i21b + 1 }
  ia_key(inpQ, 87, 0)
  ia_key(inpQ, 69, 0)
  vw("T21 input arena across a render: " as *u8); vn(snap21)
  vw(" -> " as *u8); vn(snap21b); vw(" (must be equal)\n" as *u8)
  if snap21 == snap21b { pass = pass + 1 }
548
  // T25 WORLDMAX early-exit CONTRACT: a flat ray above every solid block is sky immediately;
  // after a block appears above the old ceiling AND wc_wmax resyncs, the same ray HITS it.
  // (The miss-before also documents the hazard: direct vset above the ceiling without a resync
  // is invisible -- the game's place path maintains it, raw editors must call wc_wmax.)
  let sQ4: *i64 = wst(baseQ)
  sQ4[S_CX] = 10*256 + 128
  sQ4[S_CY] = 45*256 + 128
  sQ4[S_CZ] = 10*256 + 128
  let rout: *i64 = sys_mmap(64) as *i64
  let m25a: i64 = wray(baseQ, K_MAGIC_4096, 0, 0, 150, rout)
  vset(baseQ, 30, 45, 10, 3)
  let m25b: i64 = wray(baseQ, K_MAGIC_4096, 0, 0, 150, rout)
  wc_wmax(baseQ)
  let m25c: i64 = wray(baseQ, K_MAGIC_4096, 0, 0, 150, rout)
  vw("T25 wmax flat-ray: empty=" as *u8); vn(m25a)
  vw(" stale=" as *u8); vn(m25b)
  vw(" resynced-hit x=" as *u8); vn(rout[0]); vw(" face=" as *u8); vn(rout[3]); vw("\n" as *u8)
  var t25: i64 = 0
  if m25a < 0 { if m25b < 0 { if m25c > 0 { if rout[0] == 30 { if rout[3] == 2 { t25 = 1 } } } } }
  if t25 == 1 { pass = pass + 1 }
  vset(baseQ, 30, 45, 10, 0)
  wc_wmax(baseQ)
571
  // T26 CORNER AO: the same edge texel is STRICTLY darker when a neighbour block rises beside
  // it than after that neighbour is removed (texture/bevel identical -- only AO differs)
  vset(baseQ, 50, 44, 50, 3)
  vset(baseQ, 51, 45, 50, 3)
  wc_wmax(baseQ)
  let cE1: i64 = wshade2(baseQ, 3, 3, 5, 0, 50*256 + 250, 45*256, 50*256 + 128, 0, 50, 44, 50)
  vset(baseQ, 51, 45, 50, 0)
  let cE2: i64 = wshade2(baseQ, 3, 3, 5, 0, 50*256 + 250, 45*256, 50*256 + 128, 0, 50, 44, 50)
  let s26a: i64 = (cE1 & 255) + ((cE1 >> 8) & 255) + ((cE1 >> 16) & 255)
  let s26b: i64 = (cE2 & 255) + ((cE2 >> 8) & 255) + ((cE2 >> 16) & 255)
  vw("T26 AO edge with-neighbour=" as *u8); vn(s26a)
  vw(" without=" as *u8); vn(s26b); vw(" (with must be darker)\n" as *u8)
  if s26a < s26b { pass = pass + 1 }
  vset(baseQ, 50, 44, 50, 0)
  wc_wmax(baseQ)
587
  // T24 THE SPEC IS THE GAME: variant 1 (NISHI DEPTHS) = a DIFFERENT world and look from the
  // SAME engine -- treeless, far more cavern, sunless dark sky -- and bit-deterministic
  let baseV: i64 = sys_mmap(CRAFT_TOTAL + K_MAGIC_4096) as i64
  init_impl_v(baseV, 1, K_MAGIC_20260728)
  var vtrees: i64 = 0
  var vcaves: i64 = 0
  var vy24: i64 = 2
  while vy24 < WY - 4 { var vz24: i64 = 0
      while vz24 < WZ { var vx24: i64 = 0
          while vx24 < WX {
              let vb24: i64 = vget(baseV, vx24, vy24, vz24)
              if vb24 == 6 { vtrees = vtrees + 1 }
              if vb24 == 0 { if vsolid(baseV, vx24, vy24 + 1, vz24) == 1 { vcaves = vcaves + 1 } }
              vx24 = vx24 + 1 }
          vz24 = vz24 + 1 }
      vy24 = vy24 + 1 }
  render_impl(baseV)
  let fV: *i64 = wfb(baseV)
  let topV: i64 = fV[4*W + W/2]
  let baseV2: i64 = sys_mmap(CRAFT_TOTAL + K_MAGIC_4096) as i64
  init_impl_v(baseV2, 1, K_MAGIC_20260728)
  render_impl(baseV2)
  let ckV: i64 = fbck(baseV)
  let ckV2: i64 = fbck(baseV2)
  vw("T24 DEPTHS trees=" as *u8); vn(vtrees)
  vw(" caves=" as *u8); vn(vcaves); vw(" (craft had " as *u8); vn(caves)
  vw(") sky-top r=" as *u8); vn(topV & 255)
  vw(" ck=" as *u8); vn(ckV); vw(" det=" as *u8)
  var det24: i64 = 0
  if ckV == ckV2 { det24 = 1 }
  vn(det24); vw("\n" as *u8)
  if vtrees == 0 { if vcaves > caves*3/2 { if (topV & 255) < 80 { if det24 == 1 {
      pass = pass + 1 } } } }
  emit(baseV, "knowledge/nx_wasm_depths_start.png" as *u8)
622
  // T28 THE DISGUISE LORE: the population is MIXED (real monster girls + disguised humans),
  // deterministic, and the flag survives the save round trip (it rides the entity arena)
  let baseD: i64 = sys_mmap(CRAFT_TOTAL + K_MAGIC_4096) as i64
  init_impl(baseD, K_MAGIC_20260728)
  let mD: *i64 = mobp(baseD)
  var nreal: i64 = 0
  var ndisg: i64 = 0
  var kD: i64 = 0
  while kD < en_count(mD) {
      let hD: i64 = en_nth(mD, kD)
      if en_get(mD, hD, MC_DISG) == 1 { ndisg = ndisg + 1 } else { nreal = nreal + 1 }
      kD = kD + 1
  }
  let dg3: i64 = en_get(mD, en_nth(mD, 3), MC_DISG)
  wc_save_build(baseD)
  let imgD: *u8 = sys_mmap(SAVE_LEN + 64)
  let srcD: *u8 = (baseD + O_SAVE) as *u8
  var cD: i64 = 0
  while cD < SAVE_LEN { imgD[cD] = srcD[cD]; cD = cD + 1 }
  init_impl(baseD, 555)
  var cD2: i64 = 0
  while cD2 < SAVE_LEN { srcD[cD2] = imgD[cD2]; cD2 = cD2 + 1 }
  wc_save_apply(baseD)
  let dg3b: i64 = en_get(mD, en_nth(mD, 3), MC_DISG)
  vw("T28 population real=" as *u8); vn(nreal); vw(" disguised=" as *u8); vn(ndisg)
  vw(" mob3-disg save-roundtrip " as *u8); vn(dg3); vw("->" as *u8); vn(dg3b); vw("\n" as *u8)
  if nreal > 0 { if ndisg > 0 { if nreal + ndisg == 12 { if dg3 == dg3b { pass = pass + 1 } } } }
650
  // T29 GENERATED, NOT HAND-BUILT: genomes vary across the population, are deterministic
  // across arenas, and survive the save round trip
  let baseG: i64 = sys_mmap(CRAFT_TOTAL + K_MAGIC_4096) as i64
  init_impl(baseG, K_MAGIC_20260728)
  let mG: *i64 = mobp(baseG)
  var distinctG: i64 = 0
  var kG: i64 = 0
  while kG < en_count(mG) {
      let gk: i64 = en_get(mG, en_nth(mG, kG), MC_GENE)
      var seen29: i64 = 0
      var jG: i64 = 0
      while jG < kG {
          if en_get(mG, en_nth(mG, jG), MC_GENE) == gk { seen29 = 1 }
          jG = jG + 1
      }
      if seen29 == 0 { distinctG = distinctG + 1 }
      kG = kG + 1
  }
  let baseG2: i64 = sys_mmap(CRAFT_TOTAL + K_MAGIC_4096) as i64
  init_impl(baseG2, K_MAGIC_20260728)
  let mG2: *i64 = mobp(baseG2)
  var eqG: i64 = 1
  var kG2: i64 = 0
  while kG2 < en_count(mG) {
      if en_get(mG, en_nth(mG, kG2), MC_GENE) != en_get(mG2, en_nth(mG2, kG2), MC_GENE) { eqG = 0 }
      kG2 = kG2 + 1
  }
  let g5: i64 = en_get(mG, en_nth(mG, 5), MC_GENE)
  wc_save_build(baseG)
  let imgG: *u8 = sys_mmap(SAVE_LEN + 64)
  let srcG: *u8 = (baseG + O_SAVE) as *u8
  var cG: i64 = 0
  while cG < SAVE_LEN { imgG[cG] = srcG[cG]; cG = cG + 1 }
  init_impl(baseG, 777)
  var cG2: i64 = 0
  while cG2 < SAVE_LEN { srcG[cG2] = imgG[cG2]; cG2 = cG2 + 1 }
  wc_save_apply(baseG)
  let g5b: i64 = en_get(mG, en_nth(mG, 5), MC_GENE)
  vw("T29 genomes distinct=" as *u8); vn(distinctG); vw("/12 det=" as *u8); vn(eqG)
  vw(" mob5 save " as *u8); vn(g5); vw("->" as *u8); vn(g5b); vw("\n" as *u8)
  if distinctG >= 8 { if eqG == 1 { if g5 == g5b { pass = pass + 1 } } }
692
  // T30 HIT + BODY DETECTION: the crosshair ray FINDS a girl (and a wall blocks it); walking
  // into her is refused by her body cylinder
  let baseH2: i64 = sys_mmap(CRAFT_TOTAL + K_MAGIC_4096) as i64
  init_impl(baseH2, K_MAGIC_20260728)
  let sH2: *i64 = wst(baseH2)
  let mH2: *i64 = mobp(baseH2)
  let hH2: i64 = en_nth(mH2, 0)
  // CONTROLLED PAD (the earlier version aimed across unknown terrain and the camera spawned
  // inside a hillside): flat stone floor at y=20, clear air above, girl and player placed on it
  var pz30: i64 = 55
  while pz30 <= 62 {
      var px30: i64 = 58
      while px30 <= 62 {
          vset(baseH2, px30, 20, pz30, 3)
          var py30: i64 = 21
          while py30 <= 25 { vset(baseH2, px30, py30, pz30, 0); py30 = py30 + 1 }
          px30 = px30 + 1
      }
      pz30 = pz30 + 1
  }
  wc_wmax(baseH2)
  en_set(mH2, hH2, MC_X, 60*256 + 128)
  en_set(mH2, hH2, MC_Y, 21*256)
  en_set(mH2, hH2, MC_Z, 60*256 + 128)
  let gx30: i64 = 60*256 + 128
  let gy30: i64 = 21*256
  let gz30: i64 = 60*256 + 128
  sH2[S_CX] = gx30
  sH2[S_CY] = gy30 + EYE
  sH2[S_CZ] = gz30 - 3*256
  sH2[S_YAW] = 0
  sH2[S_PITCH] = 0
  apply2_impl(baseH2, 0, 0, 0, 0, 0, 0, 0, 0, 0)
  let pick1: i64 = sH2[S_NPCT]
  // wall between: a stone pillar right in front of her blocks the pick
  vset(baseH2, 60, 21, 59, 3)
  vset(baseH2, 60, 22, 59, 3)
  apply2_impl(baseH2, 0, 0, 0, 0, 0, 0, 0, 0, 0)
  let pick2: i64 = sH2[S_NPCT]
  vset(baseH2, 60, 21, 59, 0)
  vset(baseH2, 60, 22, 59, 0)
  // T31 THE MEET VERB: E on a targeted girl MEETS her (no block broken), sets her met-bit,
  // and counts her ONLY if she is a disguised human; meeting twice does not double-count
  let dv31: i64 = en_get(mH2, hH2, MC_DISG)
  en_set(mH2, hH2, MC_DISG, dv31 & 1)               // clear met for a clean test
  let wasDisg: i64 = en_get(mH2, hH2, MC_DISG) & 1
  let br31a: i64 = sH2[S_BROKEN]
  let fd31a: i64 = sH2[S_FOUND]
  apply2_impl(baseH2, 0, 0, 0, 0, 0, 0, 0, 1, 0)    // E while she is targeted
  apply2_impl(baseH2, 0, 0, 0, 0, 0, 0, 0, 1, 0)    // and again (idempotence)
  let met31: i64 = (en_get(mH2, hH2, MC_DISG) >> 1) & 1
  let dfd: i64 = sH2[S_FOUND] - fd31a
  var okf: i64 = 0
  if wasDisg == 1 { if dfd == 1 { okf = 1 } }
  if wasDisg == 0 { if dfd == 0 { okf = 1 } }
  vw("T31 meet: met=" as *u8); vn(met31)
  vw(" broke=" as *u8); vn(sH2[S_BROKEN] - br31a)
  vw(" disg=" as *u8); vn(wasDisg); vw(" dfound=" as *u8); vn(dfd); vw("\n" as *u8)
  if met31 == 1 { if sH2[S_BROKEN] == br31a { if okf == 1 { pass = pass + 1 } } }
752
  // body: walk straight at her; the cylinder must hold the player off her center
  var w30: i64 = 0
  while w30 < 30 { apply2_impl(baseH2, 1, 0, 0, 0, 0, 0, 0, 0, 0); w30 = w30 + 1 }
  var bd30: i64 = sH2[S_CZ] - en_get(mH2, hH2, MC_Z)
  if bd30 < 0 { bd30 = 0 - bd30 }
  var bd30x: i64 = sH2[S_CX] - en_get(mH2, hH2, MC_X)
  if bd30x < 0 { bd30x = 0 - bd30x }
  var mind30: i64 = bd30
  if bd30x > mind30 { mind30 = bd30x }
  vw("T30 pick=" as *u8); vn(pick1); vw(" walled=" as *u8); vn(pick2)
  vw(" closest-axis-dist=" as *u8); vn(mind30); vw(" (pick 0, walled -1, dist>=96)\n" as *u8)
  if pick1 == 0 { if pick2 < 0 { if mind30 >= 96 { pass = pass + 1 } } }
765
  // T32 THE STAKES (losability): a warden reaches an unprotected FOUND human -> TAKEN (count
  // drops, lost++); with the PLAYER standing beside the warden, she holds -- nobody taken
  let baseW: i64 = sys_mmap(CRAFT_TOTAL + K_MAGIC_4096) as i64
  init_impl(baseW, K_MAGIC_20260728)
  let sW: *i64 = wst(baseW)
  let mW: *i64 = mobp(baseW)
  let hVic: i64 = en_nth(mW, 1)
  let hWar: i64 = en_nth(mW, 2)
  en_set(mW, hVic, MC_DISG, 3)                      // a FOUND human
  en_set(mW, hVic, MC_X, 60*256)
  en_set(mW, hVic, MC_Y, 21*256)
  en_set(mW, hVic, MC_Z, 60*256)
  en_set(mW, hWar, MC_KIND, 2)                      // a warden, by construction
  en_set(mW, hWar, MC_DISG, 0)
  en_set(mW, hWar, MC_X, 63*256)
  en_set(mW, hWar, MC_Y, 21*256)
  en_set(mW, hWar, MC_Z, 60*256)
  sW[S_CX] = 100*256                                // player far away
  sW[S_CZ] = 100*256
  var tw32: i64 = 0
  while tw32 < 400 { mob_tick(baseW); tw32 = tw32 + 1 }
  let taken32: i64 = sW[S_LOST]
  let cnt32: i64 = en_count(mW)
  // second run: the player stands beside the warden -- protection
  let baseW2: i64 = sys_mmap(CRAFT_TOTAL + K_MAGIC_4096) as i64
  init_impl(baseW2, K_MAGIC_20260728)
  let sW2: *i64 = wst(baseW2)
  let mW2: *i64 = mobp(baseW2)
  en_set(mW2, en_nth(mW2, 1), MC_DISG, 3)
  en_set(mW2, en_nth(mW2, 1), MC_X, 60*256)
  en_set(mW2, en_nth(mW2, 1), MC_Y, 21*256)
  en_set(mW2, en_nth(mW2, 1), MC_Z, 60*256)
  en_set(mW2, en_nth(mW2, 2), MC_KIND, 2)
  en_set(mW2, en_nth(mW2, 2), MC_DISG, 0)
  en_set(mW2, en_nth(mW2, 2), MC_X, 63*256)
  en_set(mW2, en_nth(mW2, 2), MC_Y, 21*256)
  en_set(mW2, en_nth(mW2, 2), MC_Z, 60*256)
  var tw33: i64 = 0
  while tw33 < 400 {
      sW2[S_CX] = en_get(mW2, en_nth(mW2, 2), MC_X) + 200   // shadow the warden
      sW2[S_CZ] = en_get(mW2, en_nth(mW2, 2), MC_Z)
      mob_tick(baseW2)
      tw33 = tw33 + 1
  }
  vw("T32 unprotected: lost=" as *u8); vn(taken32); vw(" count=" as *u8); vn(cnt32)
  vw(" | protected: lost=" as *u8); vn(sW2[S_LOST])
  vw(" count=" as *u8); vn(en_count(mW2)); vw("\n" as *u8)
  if taken32 == 1 { if cnt32 == 11 { if sW2[S_LOST] == 0 { if en_count(mW2) == 12 {
      pass = pass + 1 } } } }
815
  // T33 INHERITANCE: two MET girls in company bear a DAUGHTER whose genome fields each come
  // from ONE of her parents; the cooldown paces births; the whole thing is deterministic
  let baseI: i64 = sys_mmap(CRAFT_TOTAL + K_MAGIC_4096) as i64
  init_impl(baseI, K_MAGIC_20260728)
  let sI: *i64 = wst(baseI)
  let mI: *i64 = mobp(baseI)
  let hPa: i64 = en_nth(mI, 0)
  let hPb: i64 = en_nth(mI, 1)
  en_set(mI, hPa, MC_DISG, 2)                       // met TRUE monster girls (no warden pull:
  en_set(mI, hPb, MC_DISG, 2)                       // inheritance isolated from the stakes)
  en_set(mI, hPa, MC_X, 60*256)
  en_set(mI, hPa, MC_Z, 60*256)
  en_set(mI, hPb, MC_X, 60*256 + 200)
  en_set(mI, hPb, MC_Z, 60*256)
  let gPa: i64 = en_get(mI, hPa, MC_GENE)
  let gPb: i64 = en_get(mI, hPb, MC_GENE)
  sI[S_CX] = 100*256
  sI[S_CZ] = 100*256
  mob_tick(baseI)
  let cAfter: i64 = en_count(mI)
  var tI: i64 = 0
  while tI < 200 { mob_tick(baseI); tI = tI + 1 }
  let cLater: i64 = en_count(mI)
  var fieldsOk: i64 = 1
  var gD: i64 = 0
  if cAfter == 13 {
      gD = en_get(mI, en_nth(mI, 12), MC_GENE)
      var fI: i64 = 0
      while fI < 6 {
          var msk2: i64 = 7
          if fI == 1 { msk2 = 24 }
          if fI == 2 { msk2 = 96 }
          if fI == 3 { msk2 = 384 }
          if fI == 4 { msk2 = K_MAGIC_1536 }
          if fI == 5 { msk2 = K_MAGIC_6144 }
          var okF: i64 = 0
          if (gD & msk2) == (gPa & msk2) { okF = 1 }
          if (gD & msk2) == (gPb & msk2) { okF = 1 }
          if okF == 0 { fieldsOk = 0 }
          fI = fI + 1
      }
  }
  let baseI2: i64 = sys_mmap(CRAFT_TOTAL + K_MAGIC_4096) as i64
  init_impl(baseI2, K_MAGIC_20260728)
  let mI2: *i64 = mobp(baseI2)
  en_set(mI2, en_nth(mI2, 0), MC_DISG, 2)
  en_set(mI2, en_nth(mI2, 1), MC_DISG, 2)
  en_set(mI2, en_nth(mI2, 0), MC_X, 60*256)
  en_set(mI2, en_nth(mI2, 0), MC_Z, 60*256)
  en_set(mI2, en_nth(mI2, 1), MC_X, 60*256 + 200)
  en_set(mI2, en_nth(mI2, 1), MC_Z, 60*256)
  let sI2: *i64 = wst(baseI2)
  sI2[S_CX] = 100*256
  sI2[S_CZ] = 100*256
  mob_tick(baseI2)
  var det33: i64 = 0
  if en_count(mI2) == 13 { if en_get(mI2, en_nth(mI2, 12), MC_GENE) == gD { det33 = 1 } }
  vw("T33 birth: count " as *u8); vn(cAfter); vw(" cooldown-holds=" as *u8); vn(cLater)
  vw(" fields-from-parents=" as *u8); vn(fieldsOk)
  vw(" det=" as *u8); vn(det33)
  vw(" (gA " as *u8); vn(gPa); vw(" gB " as *u8); vn(gPb); vw(" gD " as *u8); vn(gD); vw(")\n" as *u8)
  if cAfter == 13 { if cLater == 13 { if fieldsOk == 1 { if det33 == 1 { pass = pass + 1 } } } }
878
  // T27 EDGE SAFETY, v6 STREAMING ERA: there IS no world edge anymore -- walking past the old
  // rim SLIDES the window (origin goes negative = unbounded land west) while the player stays
  // inside the arena. Teleported into the void still auto-respawns; H still resets to spawn.
  let baseE: i64 = sys_mmap(CRAFT_TOTAL + K_MAGIC_4096) as i64
  init_impl(baseE, K_MAGIC_20260728)
  let sE: *i64 = wst(baseE)
  var t27: i64 = 0
  sE[S_CX] = 128                                    // x=0.5, the old west rim
  sE[S_CZ] = 64*256 + 128
  sE[S_CY] = wstand_here(baseE, sE[S_CX], sE[S_CZ])
  sE[S_YAW] = 3*IT_PI/2                             // face -x, straight past the old world edge
  var e27: i64 = 0
  while e27 < 30 { apply2_impl(baseE, 1, 0, 0, 0, 0, 0, 0, 0, 0); e27 = e27 + 1 }
  if sE[S_CX] >= 0 { if (sE[S_CX] >> 8) < WX { if sE[S_WOX] < 0 { t27 = t27 + 1 } } }
  sE[S_CX] = 0 - 5*256                              // teleport into the void (raw editor hazard)
  sE[S_CY] = 10*256
  apply2_impl(baseE, 0, 0, 0, 0, 0, 0, 0, 0, 0)
  if sE[S_CX] == sE[S_SPX] { if sE[S_CY] == sE[S_SPY] { t27 = t27 + 1 } }   // rescued to spawn
  sE[S_CX] = 30*256 + 128
  sE[S_CZ] = 30*256 + 128
  ia_key(winp(baseE), 72, 1)
  step_impl(baseE)
  ia_key(winp(baseE), 72, 0)
  if sE[S_CX] == sE[S_SPX] { if sE[S_CZ] == sE[S_SPZ] { t27 = t27 + 1 } }   // H went home
  vw("T27 streams-past-old-edge/void-respawn/H-home: " as *u8); vn(t27); vw("/3\n" as *u8)
  if t27 == 3 { pass = pass + 1 }
905
  // T34 BEHAVIOR VARIETY: after 800 ticks the 12 girls must occupy >=2 distinct behavior
  // states (MC_DISG bits 3-5) -- a colony with lives, not a single marching mode
  var t34: i64 = 0
  var e34: i64 = 0
  while e34 < 800 { apply2_impl(baseE, 0, 0, 0, 0, 0, 0, 0, 0, 0); e34 = e34 + 1 }
  let mE: *i64 = mobp(baseE)
  let seen34: *i64 = sys_mmap(64) as *i64
  var k34: i64 = 0
  while k34 < en_count(mE) {
      let h34: i64 = en_nth(mE, k34)
      if h34 > 0 { seen34[(en_get(mE, h34, MC_DISG) >> 3) & 7] = 1 }
      k34 = k34 + 1
  }
  var dist34: i64 = 0
  var b34: i64 = 0
  while b34 < 8 { dist34 = dist34 + seen34[b34]; b34 = b34 + 1 }
  vw("T34 behavior states present: " as *u8); vn(dist34); vw("\n" as *u8)
  if dist34 >= 2 { pass = pass + 1 }
924
  // T35 FLEE: plant a warden 3 blocks from a disguised human -> after 40 ticks the human
  // must be FARTHER from the warden (she runs; she does not graze while hunted)
  // FORCE the pair (wardens may have taken every disguised human by now -- a searched-for
  // survivor makes the tooth vacuous; a constructed pair never is)
  var hHum: i64 = en_nth(mE, 0)
  var hWar: i64 = en_nth(mE, 1)
  en_set(mE, hHum, MC_DISG, ((en_get(mE, hHum, MC_DISG) >> 3) << 3) | 3)
  en_set(mE, hHum, MC_KIND, 0)
  en_set(mE, hWar, MC_KIND, 2)
  en_set(mE, hWar, MC_DISG, (en_get(mE, hWar, MC_DISG) >> 3) << 3)
  var t35: i64 = 0
  if hHum > 0 { if hWar > 0 {
      // ISOLATE the constructed pair: demote every OTHER hunter (needs-driven wander moves
      // the flock differently than the old dice did, so a stray warden can sit nearer than
      // ours and the human flees from HER -- the tooth passed before only by trajectory luck)
      var kIso: i64 = 2
      while kIso < en_count(mE) {
          let hIso: i64 = en_nth(mE, kIso)
          if hIso > 0 {
              if en_get(mE, hIso, MC_KIND) == 2 {
                  en_set(mE, hIso, MC_DISG, en_get(mE, hIso, MC_DISG) | 1)
              }
              // and OUT of the arena's play: a found human elsewhere is a nearer TARGET for
              // our warden, and a bystander flock bends both trajectories
              en_set(mE, hIso, MC_X, 120*256)
              en_set(mE, hIso, MC_Z, 120*256)
          }
          kIso = kIso + 1
      }
      // move the human far from the player + warden 3 blocks east of her; player far away.
      // Block births for the window: T33's cooldown expires ~here, and a newborn (kind is
      // inherited -- possibly an undisguised warden) hijacks the nearest-hunter pick.
      let sE2: *i64 = wst(baseE)
      sE2[S_BCD] = 10000
      // player INSIDE the shift margins: (2,2) sat in the margin band and slid the whole
      // window twice under the pair (instrumented: both teleported +32 blocks). Far enough
      // from the pair that the take-guard never triggers, close enough to no edge.
      sE2[S_CX] = 40*256
      sE2[S_CZ] = 40*256
      en_set(mE, hHum, MC_X, 64*256)
      en_set(mE, hHum, MC_Z, 64*256)
      en_set(mE, hHum, MC_Y, (mob_ground(baseE, 64, 44, 64) + 1)*256)
      en_set(mE, hWar, MC_X, 64*256 + 3*256)
      en_set(mE, hWar, MC_Z, 64*256)
      en_set(mE, hWar, MC_Y, (mob_ground(baseE, 67, 44, 64) + 1)*256)
      var d35a: i64 = 3*256
      var e35: i64 = 0
      while e35 < 40 { apply2_impl(baseE, 0, 0, 0, 0, 0, 0, 0, 0, 0); e35 = e35 + 1 }
      var ddx35: i64 = en_get(mE, hHum, MC_X) - en_get(mE, hWar, MC_X)
      if ddx35 < 0 { ddx35 = 0 - ddx35 }
      var ddz35: i64 = en_get(mE, hHum, MC_Z) - en_get(mE, hWar, MC_Z)
      if ddz35 < 0 { ddz35 = 0 - ddz35 }
      // THE HONEST CLAIM (losability doctrine): a hunted human RUNS -- she does not graze --
      // and in this short window she is not caught. Whether she ultimately OUTRUNS a warden
      // is deliberately not guaranteed by design (the warden's wander drift stacks on her
      // hunt speed; at night she closes faster still). Instrumented proof she fled: her own
      // displacement, not the race's outcome.
      var run35: i64 = en_get(mE, hHum, MC_X) - 64*256
      if run35 < 0 { run35 = 0 - run35 }
      var run35z: i64 = en_get(mE, hHum, MC_Z) - 64*256
      if run35z < 0 { run35z = 0 - run35z }
      vw("T35 hunted human dist " as *u8); vn(d35a); vw(" -> " as *u8); vn(ddx35 + ddz35)
      vw(" ran=" as *u8); vn(run35 + run35z)
      vw(" bst=" as *u8); vn((en_get(mE, hHum, MC_DISG) >> 3) & 7)
      vw(" alive=" as *u8); vn(en_count(mE)); vw("\n" as *u8)
      if run35 + run35z >= 240 { if ((en_get(mE, hHum, MC_DISG) >> 3) & 7) == 4 {
          if ddx35 + ddz35 >= 600 { t35 = 1 } } }
  } }
  if t35 == 1 { pass = pass + 1 }
994
  // T36 PERSONALITY SPECTRUM: force one girl SHY (bold=0) and one BOLD (bold=7), park the
  // player 4 blocks from each in turn -> the shy one's distance must GROW, the bold one's
  // must SHRINK. Engagement is a bred range, not one script.
  var t36: i64 = 0
  let hP1: i64 = en_nth(mE, 0)
  let hP2: i64 = en_nth(mE, 1)
  if hP1 > 0 { if hP2 > 0 {
      let sE3: *i64 = wst(baseE)
      en_set(mE, hP1, MC_GENE, en_get(mE, hP1, MC_GENE) & K_MAGIC_8191)               // bold=0 (shy)
      en_set(mE, hP2, MC_GENE, (en_get(mE, hP2, MC_GENE) & K_MAGIC_8191) | K_MAGIC_57344)     // bold=7
      en_set(mE, hP1, MC_DISG, en_get(mE, hP1, MC_DISG) & 7)                  // state=WANDER
      en_set(mE, hP2, MC_DISG, en_get(mE, hP2, MC_DISG) & 7)
      // seed needs for the claim under test: the BOLD girl must be lonely enough to care
      // (habituation gates approach on loneliness >= P_CURI); the SHY girl's retreat is
      // FEAR and needs nothing. Energy full so neither repicks into REST mid-window.
      let ndE: *i64 = (baseE + O_NEED) as *i64
      ndE[0] = 0
      ndE[1] = 1000
      ndE[2] = 0
      ndE[4] = 0
      ndE[5] = 1000
      ndE[6] = 900
      en_set(mE, hP1, MC_X, 40*256)
      en_set(mE, hP1, MC_Z, 40*256)
      en_set(mE, hP1, MC_Y, (mob_ground(baseE, 40, 44, 40) + 1)*256)
      en_set(mE, hP2, MC_X, 90*256)
      en_set(mE, hP2, MC_Z, 90*256)
      en_set(mE, hP2, MC_Y, (mob_ground(baseE, 90, 44, 90) + 1)*256)
      sE3[S_CX] = 40*256 + 4*256
      sE3[S_CZ] = 40*256
      var e36: i64 = 0
      while e36 < 50 { apply2_impl(baseE, 0, 0, 0, 0, 0, 0, 0, 0, 0); e36 = e36 + 1 }
      var dsh: i64 = en_get(mE, hP1, MC_X) - sE3[S_CX]
      if dsh < 0 { dsh = 0 - dsh }
      var dsz: i64 = en_get(mE, hP1, MC_Z) - sE3[S_CZ]
      if dsz < 0 { dsz = 0 - dsz }
      let shyd: i64 = dsh + dsz
      sE3[S_CX] = 90*256 + 4*256
      sE3[S_CZ] = 90*256
      var e36b: i64 = 0
      while e36b < 50 { apply2_impl(baseE, 0, 0, 0, 0, 0, 0, 0, 0, 0); e36b = e36b + 1 }
      var dbx: i64 = en_get(mE, hP2, MC_X) - sE3[S_CX]
      if dbx < 0 { dbx = 0 - dbx }
      var dbz: i64 = en_get(mE, hP2, MC_Z) - sE3[S_CZ]
      if dbz < 0 { dbz = 0 - dbz }
      let bldd: i64 = dbx + dbz
      vw("T36 shy dist=" as *u8); vn(shyd); vw(" (start 1024) bold dist=" as *u8); vn(bldd); vw("\n" as *u8)
      if shyd > K_MAGIC_1024 { if bldd < K_MAGIC_1024 { t36 = 1 } }
  } }
  if t36 == 1 { pass = pass + 1 }
1045
  // T37 MOTION DOORS (seq1287): the aux triples carry the organ's APPLIED step -- over a
  // 30-tick window some mob must report a nonzero horizontal step (wandering is real, the
  // doors are not dead rows) and every vertical step must respect the 384 climb clamp
  var t37: i64 = 0
  let auxg: *i64 = (baseM + O_MOBAUX) as *i64
  var mvn: i64 = 0
  var dyok: i64 = 1
  var e37: i64 = 0
  while e37 < 30 {
      apply2_impl(baseM, 0, 0, 0, 0, 0, 0, 0, 0, 0)
      var g37: i64 = 0
      while g37 < 12 {
          if auxg[g37*3] != 0 { mvn = mvn + 1 }
          if auxg[g37*3+1] != 0 { mvn = mvn + 1 }
          var ady: i64 = auxg[g37*3+2]
          if ady < 0 { ady = 0 - ady }
          if ady > 384 { dyok = 0 }
          g37 = g37 + 1
      }
      e37 = e37 + 1
  }
  vw("T37 door nonzero-steps=" as *u8); vn(mvn)
  vw(" dy-clamp-ok=" as *u8); vn(dyok); vw("\n" as *u8)
  if mvn > 0 { if dyok == 1 { t37 = 1 } }
  if t37 == 1 { pass = pass + 1 }
1071
  // artifact (not a tooth): park the camera 4 blocks south of mob0, facing +z, and bank the
  // frame -- the eyeball proof that a creature actually RENDERS in the world
  let sM: *i64 = wst(baseM)
  let vh0: i64 = en_nth(mm, 0)
  sM[S_CX] = en_get(mm, vh0, MC_X)
  sM[S_CY] = en_get(mm, vh0, MC_Y) + 300
  sM[S_CZ] = en_get(mm, vh0, MC_Z) - 4*256
  sM[S_YAW] = 0
  sM[S_PITCH] = 0 - 600
  render_impl(baseM)
  emit(baseM, "knowledge/nx_wasm_craft_mob.png" as *u8)
1083
  // T38 STREAMING CONTINUITY + MOB COHERENCE (v6): drive the window 20 strides east by
  // teleport-past-margin, then 20 back -- virgin land must regenerate BIT-IDENTICALLY (the
  // pure-function law), far land must actually DIFFER from home (no one-chunk-in-a-costume),
  // and the 12 girls must survive every slide in-bounds with genomes intact.
  let base38: i64 = sys_mmap(CRAFT_TOTAL + K_MAGIC_4096) as i64
  init_impl(base38, K_MAGIC_20260728)
  let s38: *i64 = wst(base38)
  let m38: *i64 = mobp(base38)
  var gsig0: i64 = 0
  var k38: i64 = 0
  while k38 < en_count(m38) {
      gsig0 = ((gsig0 * 131) + en_get(m38, en_nth(m38, k38), MC_GENE)) & K_MAGIC_4611686018427387903
      k38 = k38 + 1
  }
  // home-terrain signature: a 16x16 column box at local (56..72)x(56..72), abs == local at origin 0
  var hsig: i64 = 7
  var hz: i64 = 56
  while hz < 72 {
      var hx: i64 = 56
      while hx < 72 {
          var hy: i64 = 0
          while hy < WY { hsig = ((hsig * 131) + vget(base38, hx, hy, hz)) & K_MAGIC_4611686018427387903; hy = hy + 1 }
          hx = hx + 1
      }
      hz = hz + 1
  }
  var d38: i64 = 0
  while d38 < 20 { s38[S_CX] = 100*256 + 128; apply2_impl(base38, 0, 0, 0, 0, 0, 0, 0, 0, 0); d38 = d38 + 1 }
  let woxFar: i64 = s38[S_WOX]
  // far-land signature over the SAME local box (different absolute land now under it)
  var fsig: i64 = 7
  hz = 56
  while hz < 72 {
      var hx2: i64 = 56
      while hx2 < 72 {
          var hy2: i64 = 0
          while hy2 < WY { fsig = ((fsig * 131) + vget(base38, hx2, hy2, hz)) & K_MAGIC_4611686018427387903; hy2 = hy2 + 1 }
          hx2 = hx2 + 1
      }
      hz = hz + 1
  }
  while d38 < 40 { s38[S_CX] = 20*256 + 128; apply2_impl(base38, 0, 0, 0, 0, 0, 0, 0, 0, 0); d38 = d38 + 1 }
  var hsig2: i64 = 7
  hz = 56
  while hz < 72 {
      var hx3: i64 = 56
      while hx3 < 72 {
          var hy3: i64 = 0
          while hy3 < WY { hsig2 = ((hsig2 * 131) + vget(base38, hx3, hy3, hz)) & K_MAGIC_4611686018427387903; hy3 = hy3 + 1 }
          hx3 = hx3 + 1
      }
      hz = hz + 1
  }
  var gsig1: i64 = 0
  var mobok: i64 = 1
  k38 = 0
  while k38 < en_count(m38) {
      let h38: i64 = en_nth(m38, k38)
      gsig1 = ((gsig1 * 131) + en_get(m38, h38, MC_GENE)) & K_MAGIC_4611686018427387903
      let mx38: i64 = en_get(m38, h38, MC_X)
      if mx38 < 0 { mobok = 0 }
      if mx38 >= WX*256 { mobok = 0 }
      k38 = k38 + 1
  }
  var t38: i64 = 0
  if woxFar == 320 { if hsig2 == hsig { if fsig != hsig { if en_count(m38) == 12 {
      if gsig1 == gsig0 { if mobok == 1 { if s38[S_WOX] == 0 { t38 = 1 } } } } } } }
  vw("T38 streaming: origin 0->" as *u8); vn(woxFar); vw("->" as *u8); vn(s38[S_WOX])
  vw(" home-sig regen-identical=" as *u8)
  var rid: i64 = 0
  if hsig2 == hsig { rid = 1 }
  vn(rid)
  vw(" far-differs=" as *u8)
  var fdif: i64 = 0
  if fsig != hsig { fdif = 1 }
  vn(fdif)
  vw(" mobs=" as *u8); vn(en_count(m38)); vw(" genomes-held=" as *u8)
  var gh38: i64 = 0
  if gsig1 == gsig0 { gh38 = 1 }
  vn(gh38); vw("\n" as *u8)
  if t38 == 1 { pass = pass + 1 }
1165
  // T39 EDITS SURVIVE DEPARTURE (the journal law live): place a block, stream 20 strides east
  // (its strip long evicted), come back -- the edit must still be there. And a FULL journal
  // must refuse LOUDLY: the refused edit changes NOTHING and S_EJDROP counts it.
  var t39: i64 = 0
  let e1ok: i64 = wc_edit(base38, 64, 30, 64, 3)
  var d39: i64 = 0
  while d39 < 20 { s38[S_CX] = 100*256 + 128; apply2_impl(base38, 0, 0, 0, 0, 0, 0, 0, 0, 0); d39 = d39 + 1 }
  let gone39: i64 = vget(base38, 64, 30, 64)
  while d39 < 40 { s38[S_CX] = 20*256 + 128; apply2_impl(base38, 0, 0, 0, 0, 0, 0, 0, 0, 0); d39 = d39 + 1 }
  let back39: i64 = vget(base38, 64, 30, 64)
  // journal-full loud refusal on a FRESH world (do not poison base38's history)
  let base39: i64 = sys_mmap(CRAFT_TOTAL + K_MAGIC_4096) as i64
  init_impl(base39, 777)
  let s39: *i64 = wst(base39)
  var f39: i64 = 0
  var acc39: i64 = 0
  while f39 < EJRN_SLOTS {
      acc39 = acc39 + wc_edit(base39, f39 & 127, 40 + ((f39 >> 7) & 7), (f39 >> 10) & 127, 3)
      f39 = f39 + 1
  }
  let pre39: i64 = vget(base39, 5, 20, 5)
  let rc39: i64 = wc_edit(base39, 5, 20, 5, 9)
  let post39: i64 = vget(base39, 5, 20, 5)
  if e1ok == 1 { if gone39 != 3 { if back39 == 3 { if acc39 == EJRN_SLOTS {
      if rc39 == 0 { if post39 == pre39 { if s39[S_EJDROP] == 1 { t39 = 1 } } } } } } }
  vw("T39 edit-journal: placed=" as *u8); vn(e1ok); vw(" away=" as *u8); vn(gone39)
  vw(" back=" as *u8); vn(back39); vw(" filled=" as *u8); vn(acc39)
  vw(" full-refused=" as *u8)
  var fr39: i64 = 0
  if rc39 == 0 { if post39 == pre39 { fr39 = 1 } }
  vn(fr39); vw(" ejdrop=" as *u8); vn(s39[S_EJDROP]); vw("\n" as *u8)
  if t39 == 1 { pass = pass + 1 }
1198
  // T40 SOFT-BODY ON THE RIG (A4 wired): force mob 0's root back and forth one block every 10
  // ticks on two arenas -- the spring offsets must MOVE (nonzero while driven), OSCILLATE (the
  // hair-x offset changes sign), stay inside the hard clamp, and the FULL spring state must
  // replay bit-identically. BITE: one extra tick on arena B changes the checksum.
  let base40: i64 = sys_mmap(CRAFT_TOTAL + K_MAGIC_4096) as i64
  let base40b: i64 = sys_mmap(CRAFT_TOTAL + K_MAGIC_4096) as i64
  init_impl(base40, K_MAGIC_20260728)
  init_impl(base40b, K_MAGIC_20260728)
  let m40: *i64 = mobp(base40)
  let m40b: *i64 = mobp(base40b)
  var nz40: i64 = 0
  var sgn40: i64 = 0
  var last40: i64 = 0
  var clampok40: i64 = 1
  var e40: i64 = 0
  while e40 < 60 {
      let fx40: i64 = 64*256 + ((e40/10) % 2)*256
      en_set(m40, en_nth(m40, 0), MC_X, fx40)
      en_set(m40b, en_nth(m40b, 0), MC_X, fx40)
      apply2_impl(base40, 0, 0, 0, 0, 0, 0, 0, 0, 0)
      apply2_impl(base40b, 0, 0, 0, 0, 0, 0, 0, 0, 0)
      let h40: i64 = en_nth(m40, 0)
      let ox40: i64 = sb_off_x_q8((base40 + O_SOFT) as *i64, 0, SB_HAIR, en_get(m40, h40, MC_X)/4)
      if ox40 != 0 { nz40 = nz40 + 1 }
      if ox40 > 0 { if last40 < 0 { sgn40 = sgn40 + 1 } }
      if ox40 < 0 { if last40 > 0 { sgn40 = sgn40 + 1 } }
      if ox40 != 0 { last40 = ox40 }
      // clamp check PER AXIS vs the un-bobbed root: x/z carry pure tissue separation (the
      // clamp's own budget); y includes the thorax gait bob AFTER /4 floor-quantization: (Y+14)/4 - Y/4 reaches 4
      // model units = 1024 Q8, NOT 14*64=896 (the truncate-before-compare class, in a budget) --
      // leaving the body, so the y budget is clamp + bob, never a loosened clamp.
      var kk40: i64 = 0
      while kk40 < 3 {
          var ox40b: i64 = sb_off_x_q8((base40 + O_SOFT) as *i64, 0, kk40, en_get(m40, h40, MC_X)/4)
          if ox40b < 0 { ox40b = 0 - ox40b }
          var oz40b: i64 = sb_off_z_q8((base40 + O_SOFT) as *i64, 0, kk40, en_get(m40, h40, MC_Z)/4)
          if oz40b < 0 { oz40b = 0 - oz40b }
          var oy40b: i64 = sb_off_y_q8((base40 + O_SOFT) as *i64, 0, kk40, en_get(m40, h40, MC_Y)/4)
          if oy40b < 0 { oy40b = 0 - oy40b }
          if ox40b > sb_maxd(kk40)*256 + 8 { if clampok40 == 1 {
              vw("  first-exceed frame=" as *u8); vn(e40); vw(" kind=" as *u8); vn(kk40)
              vw(" axis=x val=" as *u8); vn(ox40b); vw("\n" as *u8)
          } clampok40 = 0 }
          if oz40b > sb_maxd(kk40)*256 + 8 { if clampok40 == 1 {
              vw("  first-exceed frame=" as *u8); vn(e40); vw(" kind=" as *u8); vn(kk40)
              vw(" axis=z val=" as *u8); vn(oz40b); vw("\n" as *u8)
          } clampok40 = 0 }
          if oy40b > sb_maxd(kk40)*256 + 8 + 1024 { if clampok40 == 1 {
              vw("  first-exceed frame=" as *u8); vn(e40); vw(" kind=" as *u8); vn(kk40)
              vw(" axis=y val=" as *u8); vn(oy40b); vw("\n" as *u8)
          } clampok40 = 0 }
          kk40 = kk40 + 1
      }
      e40 = e40 + 1
  }
  let ckA40: i64 = sb_ck((base40 + O_SOFT) as *i64, MOB_CAP)
  let ckB40: i64 = sb_ck((base40b + O_SOFT) as *i64, MOB_CAP)
  apply2_impl(base40b, 0, 0, 0, 0, 0, 0, 0, 0, 0)
  let ckC40: i64 = sb_ck((base40b + O_SOFT) as *i64, MOB_CAP)
  // instrumented peaks (per kind, per axis) -- printed always so a clamp RED names its axis
  var pk40: i64 = 0
  var kk41: i64 = 0
  while kk41 < 3 {
      var a40: i64 = sb_off_x_q8((base40 + O_SOFT) as *i64, 0, kk41, en_get(m40, en_nth(m40, 0), MC_X)/4)
      if a40 < 0 { a40 = 0 - a40 }
      var b40: i64 = sb_off_y_q8((base40 + O_SOFT) as *i64, 0, kk41, en_get(m40, en_nth(m40, 0), MC_Y)/4)
      if b40 < 0 { b40 = 0 - b40 }
      var c40: i64 = sb_off_z_q8((base40 + O_SOFT) as *i64, 0, kk41, en_get(m40, en_nth(m40, 0), MC_Z)/4)
      if c40 < 0 { c40 = 0 - c40 }
      vw("  k" as *u8); vn(kk41); vw(" end-xyz=" as *u8); vn(a40); vw("," as *u8); vn(b40); vw("," as *u8); vn(c40)
      if a40 > pk40 { pk40 = a40 }
      kk41 = kk41 + 1
  }
  vw("\n" as *u8)
  vw("T40 softbody: driven-frames=" as *u8); vn(nz40); vw(" sign-changes=" as *u8); vn(sgn40)
  vw(" clamp-held=" as *u8); vn(clampok40)
  vw(" replay-eq=" as *u8)
  var req40: i64 = 0
  if ckA40 == ckB40 { req40 = 1 }
  vn(req40)
  vw(" bite-differs=" as *u8)
  var bit40: i64 = 0
  if ckC40 != ckA40 { bit40 = 1 }
  vn(bit40); vw("\n" as *u8)
  if nz40 >= 20 { if sgn40 >= 1 { if clampok40 == 1 { if req40 == 1 { if bit40 == 1 {
      pass = pass + 1 } } } } }
1285
  // T41 THE CALENDAR (A1): a pure function of (tick, spec) -- day->night->day, the season
  // wheel wraps spring->winter->spring, the sun is high at noon and below at midnight, and
  // 500 PUBLIC ticks land both arenas on the identical day-tick. White-box S_T jumps are
  // legal here BECAUSE the calendar owns no hidden state -- that is the claim under test.
  let base41: i64 = sys_mmap(CRAFT_TOTAL + K_MAGIC_4096) as i64
  init_impl(base41, K_MAGIC_20260728)
  let s41: *i64 = wst(base41)
  let dl41: i64 = wsp(base41)[P_DAYLEN]
  let sd41: i64 = wsp(base41)[P_SEASD]
  var t41: i64 = 0
  s41[S_T] = 0
  if cal_night(base41) == 0 { t41 = t41 + 1 }
  s41[S_T] = dl41/4
  if cal_sunel(base41) > 2000 { t41 = t41 + 1 }
  s41[S_T] = dl41*5/8
  if cal_night(base41) == 1 { t41 = t41 + 1 }
  s41[S_T] = dl41*7/8
  if cal_sunel(base41) < 0 { t41 = t41 + 1 }
  s41[S_T] = dl41
  if cal_night(base41) == 0 { t41 = t41 + 1 }
  if cal_day(base41) == 1 { t41 = t41 + 1 }
  s41[S_T] = dl41*sd41*3
  if cal_season(base41) == 3 { t41 = t41 + 1 }
  s41[S_T] = dl41*sd41*4
  if cal_season(base41) == 0 { t41 = t41 + 1 }
  let base41b: i64 = sys_mmap(CRAFT_TOTAL + K_MAGIC_4096) as i64
  init_impl(base41b, K_MAGIC_20260728)
  s41[S_T] = 0
  let s41b: *i64 = wst(base41b)
  s41b[S_T] = 0                                    // BOTH clocks to zero: init now starts at
                                                   // mid-morning, and one un-zeroed arena
                                                   // made this a 500-vs-18500 comparison
  var e41: i64 = 0
  while e41 < 500 {
      apply2_impl(base41, 0, 0, 0, 0, 0, 0, 0, 0, 0)
      apply2_impl(base41b, 0, 0, 0, 0, 0, 0, 0, 0, 0)
      e41 = e41 + 1
  }
  if cal_dayt(base41) == cal_dayt(base41b) { if cal_dayt(base41) == 500 { t41 = t41 + 1 } }
  vw("T41 calendar checks: " as *u8); vn(t41); vw("/9\n" as *u8)
  if t41 == 9 { pass = pass + 1 }
1327
  // T42 THE FARM LOOP (B1/B2): two plots tilled and planted -- one beside water, one dry --
  // rain rows zeroed (DATA, exactly what a recombined identity does). The wet crop must
  // mature strictly FIRST, and the whole run must reproduce bit-identically on a second
  // arena. Then the HARVEST verb: break the mature crop through the real crosshair path.
  let base42: i64 = sys_mmap(CRAFT_TOTAL + K_MAGIC_4096) as i64
  let base42b: i64 = sys_mmap(CRAFT_TOTAL + K_MAGIC_4096) as i64
  init_impl(base42, K_MAGIC_20260728)
  init_impl(base42b, K_MAGIC_20260728)
  var t42: i64 = 0
  let sp42: *i64 = wsp(base42)
  let sp42b: *i64 = wsp(base42b)
  sp42[P_RAINS + 0] = 0
  sp42[P_RAINS + 1] = 0
  sp42[P_RAINS + 2] = 0
  sp42[P_RAINS + 3] = 0
  sp42b[P_RAINS + 0] = 0
  sp42b[P_RAINS + 1] = 0
  sp42b[P_RAINS + 2] = 0
  sp42b[P_RAINS + 3] = 0
  // production cadence is the Minecraft random-tick band (2400 ticks/roll); the TOOTH runs
  // the same stencil compressed -- cadence is spec DATA, and overriding data is the tooth's
  // right (the rain rows above are the precedent)
  sp42[P_GROWE] = 8
  sp42b[P_GROWE] = 8
  // dry plot: the first inland column at height >= 13 (natural water tops out at 9; the 5x5
  // wet scan reads levels y and y-1, so height 13 is provably beyond any pond's reach)
  var dpx: i64 = 0 - 1
  var dpz: i64 = 0 - 1
  var dph: i64 = 0
  var sz42: i64 = 76
  while sz42 < 92 {
      var sx42: i64 = 76
      while sx42 < 92 {
          if dpx < 0 {
              let hh42: i64 = wheight(base42, sx42, sz42, K_MAGIC_20260728)
              if hh42 >= 13 { if vget(base42, sx42, hh42, sz42) == 1 {
                  dpx = sx42
                  dpz = sz42
                  dph = hh42
              } }
          }
          sx42 = sx42 + 1
      }
      sz42 = sz42 + 1
  }
  // wet plot: any grass column will do -- we bring our own water beside it
  // both plots stay INSIDE the shift margins (32..95): T43 later STANDS the player on the
  // wet plot, and a plot near an edge would slide the window mid-tooth
  var wpx: i64 = 0 - 1
  var wpz: i64 = 0 - 1
  var wph: i64 = 0
  var sz43: i64 = 40
  while sz43 < 74 {
      var sx43: i64 = 40
      while sx43 < 74 {
          if wpx < 0 {
              let hh43: i64 = wheight(base42, sx43, sz43, K_MAGIC_20260728)
              if hh43 >= 11 { if vget(base42, sx43, hh43, sz43) == 1 {
                  // CLEAR SKY required: a canopy over the plot stands the harvesting player
                  // ON THE LEAVES (wstand walks the column top-down), 4 blocks above her crop
                  var clr43: i64 = 1
                  var cy43: i64 = hh43 + 1
                  while cy43 <= hh43 + 8 {
                      if cy43 < WY { if vget(base42, sx43, cy43, sz43) != 0 { clr43 = 0 } }
                      cy43 = cy43 + 1
                  }
                  if clr43 == 1 {
                      wpx = sx43
                      wpz = sz43
                      wph = hh43
                  }
              } }
          }
          sx43 = sx43 + 1
      }
      sz43 = sz43 + 1
  }
  var tw42: i64 = 0
  var td42: i64 = 0
  if dpx >= 0 { if wpx >= 0 {
      wc_edit(base42, wpx, wph, wpz, B_FARM)
      wc_edit(base42, wpx + 1, wph, wpz, 4)
      wc_edit(base42, wpx, wph + 1, wpz, B_CROP0)
      wc_edit(base42, dpx, dph, dpz, B_FARM)
      wc_edit(base42, dpx, dph + 1, dpz, B_CROP0)
      wc_edit(base42b, wpx, wph, wpz, B_FARM)
      wc_edit(base42b, wpx + 1, wph, wpz, 4)
      wc_edit(base42b, wpx, wph + 1, wpz, B_CROP0)
      wc_edit(base42b, dpx, dph, dpz, B_FARM)
      wc_edit(base42b, dpx, dph + 1, dpz, B_CROP0)
      var e42: i64 = 0
      var tw42b: i64 = 0
      while e42 < 2000 {
          apply2_impl(base42, 0, 0, 0, 0, 0, 0, 0, 0, 0)
          apply2_impl(base42b, 0, 0, 0, 0, 0, 0, 0, 0, 0)
          if tw42 == 0 { if vget(base42, wpx, wph + 1, wpz) == B_CROP2 { tw42 = e42 + 1 } }
          if tw42b == 0 { if vget(base42b, wpx, wph + 1, wpz) == B_CROP2 { tw42b = e42 + 1 } }
          if td42 == 0 { if vget(base42, dpx, dph + 1, dpz) == B_CROP2 { td42 = e42 + 1 } }
          e42 = e42 + 1
      }
      vw("T42 farm: wet-plot(" as *u8); vn(wpx); vw("," as *u8); vn(wpz)
      vw(") matured t=" as *u8); vn(tw42)
      vw(" dry-plot(" as *u8); vn(dpx); vw("," as *u8); vn(dpz)
      vw(") t=" as *u8); vn(td42)
      vw(" replay-eq=" as *u8)
      var req42: i64 = 0
      if tw42 == tw42b { req42 = 1 }
      vn(req42)
      vw(" soil-wet=" as *u8)
      var sw42: i64 = 0
      if vget(base42, wpx, wph, wpz) == B_FARMW { sw42 = 1 }
      vn(sw42); vw("\n" as *u8)
      if tw42 > 0 { if req42 == 1 { if sw42 == 1 {
          var wetfirst: i64 = 0
          if td42 == 0 { wetfirst = 1 }
          if td42 > tw42 { wetfirst = 1 }
          if wetfirst == 1 { t42 = 1 }
      } } }
  } }
  if t42 == 1 { pass = pass + 1 }
1448
  // T43 THE HARVEST VERB: stand IN the wet plot's crop cell, look down through the REAL
  // crosshair path, break -- S_HARV must count exactly 1 and the cell must empty.
  var t43: i64 = 0
  if t42 == 1 {
      // clear the field first: the mature-crop ADVERTISEMENT drew a forager girl into the
      // beam, npc_pick targeted her, and E politely MET her instead of harvesting (the C1
      // system sabotaging the B2 tooth is almost a feature -- but this tooth tests HARVEST)
      let m43: *i64 = mobp(base42)
      var k43: i64 = 0
      while k43 < en_count(m43) {
          let h43: i64 = en_nth(m43, k43)
          if h43 > 0 {
              en_set(m43, h43, MC_X, 110*256)
              en_set(m43, h43, MC_Z, 110*256)
          }
          k43 = k43 + 1
      }
      let s42: *i64 = wst(base42)
      s42[S_CX] = wpx*256 + 128
      s42[S_CZ] = wpz*256 + 128
      s42[S_CY] = (wph + 1)*256 + EYE
      s42[S_VY] = 0
      s42[S_YAW] = 0
      s42[S_PITCH] = 0 - PITCH_MAX                 // steepest look-down (70 deg: pi/2=6434, so
                                                   // 5000 keeps cp>0; forward drift is only
                                                   // 0.26 blocks -- no neighbor hill can eat
                                                   // the ray before it drops into the crop)
      let hv0: i64 = s42[S_HARV]
      apply_impl(base42, 0, 0, 0, 1, 0)
      let hv1: i64 = s42[S_HARV]
      let cellafter: i64 = vget(base42, wpx, wph + 1, wpz)
      vw("T43 harvest: count " as *u8); vn(hv0); vw("->" as *u8); vn(hv1)
      vw(" cell-after=" as *u8); vn(cellafter)
      vw(" [hok=" as *u8); vn(s42[S_HOK])
      vw(" hit=" as *u8); vn(s42[S_HX]); vw("," as *u8); vn(s42[S_HY]); vw("," as *u8); vn(s42[S_HZ])
      vw(" want=" as *u8); vn(wpx); vw("," as *u8); vn(wph + 1); vw("," as *u8); vn(wpz)
      vw(" npct=" as *u8); vn(s42[S_NPCT])
      vw(" broken=" as *u8); vn(s42[S_BROKEN]); vw("]" as *u8); vw("\n" as *u8)
      if hv1 == hv0 + 1 { if cellafter == 0 { t43 = 1 } }
  }
  if t43 == 1 { pass = pass + 1 }
1490
  // T44 THE SCHEDULE (C2): jump one arena to nightfall, run past a full repick cycle -- every
  // girl must be RESTING or FLEEING (the village sleeps; hunted humans still run). Daytime
  // control on a fresh arena: the same window must show at least one girl NOT resting --
  // proving NIGHT caused the sleep, not the code's mood.
  let base44: i64 = sys_mmap(CRAFT_TOTAL + K_MAGIC_4096) as i64
  init_impl(base44, K_MAGIC_20260728)
  let s44: *i64 = wst(base44)
  let m44: *i64 = mobp(base44)
  s44[S_T] = wsp(base44)[P_DAYLEN]*5/8 + 1
  var e44: i64 = 0
  while e44 < 300 { apply2_impl(base44, 0, 0, 0, 0, 0, 0, 0, 0, 0); e44 = e44 + 1 }
  var sleep44: i64 = 1
  var n44: i64 = 0
  var k44: i64 = 0
  while k44 < en_count(m44) {
      let h44: i64 = en_nth(m44, k44)
      if h44 > 0 {
          let b44: i64 = (en_get(m44, h44, MC_DISG) >> 3) & 7
          if b44 != 2 { if b44 != 4 { sleep44 = 0 } }
          n44 = n44 + 1
      }
      k44 = k44 + 1
  }
  let base44b: i64 = sys_mmap(CRAFT_TOTAL + K_MAGIC_4096) as i64
  init_impl(base44b, K_MAGIC_20260728)
  let m44b: *i64 = mobp(base44b)
  var e44b: i64 = 0
  while e44b < 300 { apply2_impl(base44b, 0, 0, 0, 0, 0, 0, 0, 0, 0); e44b = e44b + 1 }
  var awake44: i64 = 0
  var k44b: i64 = 0
  while k44b < en_count(m44b) {
      let h44b: i64 = en_nth(m44b, k44b)
      if h44b > 0 { if ((en_get(m44b, h44b, MC_DISG) >> 3) & 7) != 2 { awake44 = awake44 + 1 } }
      k44b = k44b + 1
  }
  vw("T44 schedule: night-girls=" as *u8); vn(n44); vw(" all-asleep-or-fleeing=" as *u8); vn(sleep44)
  vw(" day-awake=" as *u8); vn(awake44); vw("\n" as *u8)
  if n44 >= 8 { if sleep44 == 1 { if awake44 >= 1 { pass = pass + 1 } } }
1529
  // T45 OBJECTS TEACH BEHAVIOR (C1's exit criterion, mutation-grade): arena B adds ONE
  // advertisement ROW (grass feeds absurdly well -- grass because it provably exists at the
  // surface near every spawned girl; a stone row would be vacuously absent) and all three
  // arenas get the same hungry girl. B's behavior stream must DIVERGE from A while control
  // arena C (no new row) stays IDENTICAL to A -- the data row alone changed village life.
  let base45: i64 = sys_mmap(CRAFT_TOTAL + K_MAGIC_4096) as i64
  let base45b: i64 = sys_mmap(CRAFT_TOTAL + K_MAGIC_4096) as i64
  let base45c: i64 = sys_mmap(CRAFT_TOTAL + K_MAGIC_4096) as i64
  init_impl(base45, K_MAGIC_20260728)
  init_impl(base45b, K_MAGIC_20260728)
  init_impl(base45c, K_MAGIC_20260728)
  let nd45: *i64 = (base45 + O_NEED) as *i64
  let nd45b: *i64 = (base45b + O_NEED) as *i64
  let nd45c: *i64 = (base45c + O_NEED) as *i64
  nd45[0] = 900
  nd45b[0] = 900
  nd45c[0] = 900
  let sp45b: *i64 = wsp(base45b)
  sp45b[P_ADV + 3] = (1 << 16) | 60
  var ck45a: i64 = 0
  var ck45b: i64 = 0
  var ck45c: i64 = 0
  let m45: *i64 = mobp(base45)
  let m45b: *i64 = mobp(base45b)
  let m45c: *i64 = mobp(base45c)
  var e45: i64 = 0
  while e45 < 480 {
      apply2_impl(base45, 0, 0, 0, 0, 0, 0, 0, 0, 0)
      apply2_impl(base45b, 0, 0, 0, 0, 0, 0, 0, 0, 0)
      apply2_impl(base45c, 0, 0, 0, 0, 0, 0, 0, 0, 0)
      if e45 % 16 == 0 {
          var k45: i64 = 0
          while k45 < en_count(m45) {
              ck45a = (ck45a*131 + ((en_get(m45, en_nth(m45, k45), MC_DISG) >> 3) & 7) + 1) % K_MAGIC_1000000007
              k45 = k45 + 1
          }
          var k45b: i64 = 0
          while k45b < en_count(m45b) {
              ck45b = (ck45b*131 + ((en_get(m45b, en_nth(m45b, k45b), MC_DISG) >> 3) & 7) + 1) % K_MAGIC_1000000007
              k45b = k45b + 1
          }
          var k45c: i64 = 0
          while k45c < en_count(m45c) {
              ck45c = (ck45c*131 + ((en_get(m45c, en_nth(m45c, k45c), MC_DISG) >> 3) & 7) + 1) % K_MAGIC_1000000007
              k45c = k45c + 1
          }
      }
      e45 = e45 + 1
  }
  vw("T45 advertisement row: control-identical=" as *u8)
  var ci45: i64 = 0
  if ck45a == ck45c { ci45 = 1 }
  vn(ci45)
  vw(" row-diverged=" as *u8)
  var rd45: i64 = 0
  if ck45a != ck45b { rd45 = 1 }
  vn(rd45); vw("\n" as *u8)
  if ci45 == 1 { if rd45 == 1 { pass = pass + 1 } }
1588
  // T46 FRIENDSHIP (the relationship arc): shared time grows the bond, meeting her (E) adds
  // the step-change, and the whole word SURVIVES the save/load roundtrip -- a relationship
  // is world truth, not a per-session mood.
  let base46: i64 = sys_mmap(CRAFT_TOTAL + K_MAGIC_4096) as i64
  init_impl(base46, K_MAGIC_20260728)
  let s46: *i64 = wst(base46)
  let m46: *i64 = mobp(base46)
  var e46: i64 = 0
  while e46 < 200 {
      let h46p: i64 = en_nth(m46, 0)
      en_set(m46, h46p, MC_X, s46[S_CX] + 300)
      en_set(m46, h46p, MC_Z, s46[S_CZ])
      apply2_impl(base46, 0, 0, 0, 0, 0, 0, 0, 0, 0)
      e46 = e46 + 1
  }
  let h46: i64 = en_nth(m46, 0)
  let fr0: i64 = (en_get(m46, h46, MC_DISG) >> 6) & 255
  // a stone stage in the sky: flat, treeless, deterministic -- then meet her through the
  // REAL npc_pick ray (player 2 blocks west, facing +x, slightly down)
  var p46: i64 = 70
  while p46 < 75 {
      var q46: i64 = 70
      while q46 < 73 {
          vset(base46, p46, 40, q46, 3)
          vset(base46, p46, 41, q46, 0)
          vset(base46, p46, 42, q46, 0)
          q46 = q46 + 1
      }
      p46 = p46 + 1
  }
  s46[S_CX] = 71*256 + 128
  s46[S_CZ] = 71*256 + 128
  s46[S_CY] = 41*256 + EYE
  s46[S_VY] = 0
  s46[S_YAW] = IT_PI/2
  s46[S_PITCH] = 0 - 600
  en_set(m46, h46, MC_X, 73*256 + 128)
  en_set(m46, h46, MC_Z, 71*256 + 128)
  en_set(m46, h46, MC_Y, 41*256)
  en_set(m46, h46, MC_DISG, en_get(m46, h46, MC_DISG) & (0 - 3))   // clear met so E meets fresh
  apply_impl(base46, 0, 0, 0, 1, 0)
  let fr1: i64 = (en_get(m46, h46, MC_DISG) >> 6) & 255
  wc_save_build(base46)
  let base46c: i64 = sys_mmap(CRAFT_TOTAL + K_MAGIC_4096) as i64
  init_impl(base46c, 777)
  let src46: *u8 = (base46 + O_SAVE) as *u8
  let dst46: *u8 = (base46c + O_SAVE) as *u8
  var c46: i64 = 0
  while c46 < SAVE_LEN { dst46[c46] = src46[c46]; c46 = c46 + 1 }
  let rc46: i64 = wc_save_apply(base46c)
  let m46c: *i64 = mobp(base46c)
  let fr2: i64 = (en_get(m46c, en_nth(m46c, 0), MC_DISG) >> 6) & 255
  vw("T46 friendship: grown=" as *u8); vn(fr0); vw(" after-meet=" as *u8); vn(fr1)
  vw(" load-rc=" as *u8); vn(rc46); vw(" survives-load=" as *u8); vn(fr2); vw("\n" as *u8)
  if fr0 >= 2 { if fr1 >= fr0 + 10 { if rc46 == 0 { if fr2 == fr1 { pass = pass + 1 } } } }
1644
  // T47 THE THOUGHT LEDGER (C3): hunger writes a NEGATIVE thought, mood = the live sum, and
  // the entry EXPIRES by TTL after the cause is fed -- "why is she sad" has an inspectable,
  // decaying answer, never a scalar mystery. Positives are excluded by construction here
  // (social forced 0, daytime, no meetings), so mood < 0 is CAUSED, not coincidental.
  let base47: i64 = sys_mmap(CRAFT_TOTAL + K_MAGIC_4096) as i64
  init_impl(base47, K_MAGIC_20260728)
  let nd47: *i64 = (base47 + O_NEED) as *i64
  nd47[0] = 900
  nd47[1] = 1000
  nd47[2] = 0
  var e47: i64 = 0
  while e47 < 300 { apply2_impl(base47, 0, 0, 0, 0, 0, 0, 0, 0, 0); e47 = e47 + 1 }
  let mo1: i64 = th_mood(base47, 0)
  var hung47: i64 = 0
  let mp47: *i64 = mindp(base47)
  let s47: *i64 = wst(base47)
  var i47: i64 = 0
  while i47 < 8 {
      if (mp47[i47*2] >> 8) == TH_HUNGRY { if mp47[i47*2 + 1] > s47[S_T] { hung47 = 1 } }
      i47 = i47 + 1
  }
  nd47[0] = 0
  var e47b: i64 = 0
  while e47b < 1100 { apply2_impl(base47, 0, 0, 0, 0, 0, 0, 0, 0, 0); e47b = e47b + 1 }
  let mo2: i64 = th_mood(base47, 0)
  var hung47b: i64 = 0
  i47 = 0
  while i47 < 8 {
      if (mp47[i47*2] >> 8) == TH_HUNGRY { if mp47[i47*2 + 1] > s47[S_T] { hung47b = 1 } }
      i47 = i47 + 1
  }
  vw("T47 thoughts: hungry-mood=" as *u8); vn(mo1); vw(" ledger-names-hunger=" as *u8); vn(hung47)
  vw(" fed-mood=" as *u8); vn(mo2); vw(" expired=" as *u8)
  var exp47: i64 = 0
  if hung47b == 0 { exp47 = 1 }
  vn(exp47); vw("\n" as *u8)
  if mo1 < 0 { if hung47 == 1 { if mo2 > mo1 { if exp47 == 1 { pass = pass + 1 } } } }
1682
  // T48 GOSSIP (C5 -- the differentiator no shipped game has): a fact seeded in A reaches C
  // only THROUGH B across two forced conversations, confidence strictly decaying at each
  // hop; the CONTROL arena (same pins, same seed, NO fact) carries nothing anywhere -- the
  // seed alone explains every copy. Subjects survive the chain intact above the mutation bar.
  let base48: i64 = sys_mmap(CRAFT_TOTAL + K_MAGIC_4096) as i64
  let base48b: i64 = sys_mmap(CRAFT_TOTAL + K_MAGIC_4096) as i64
  init_impl(base48, K_MAGIC_20260728)
  init_impl(base48b, K_MAGIC_20260728)
  let m48: *i64 = mobp(base48)
  let m48b: *i64 = mobp(base48b)
  let nd48: *i64 = (base48 + O_NEED) as *i64
  let nd48b: *i64 = (base48b + O_NEED) as *i64
  var k48: i64 = 0
  while k48 < 3 {
      nd48[k48*4] = 0
      nd48[k48*4 + 1] = 1000
      nd48[k48*4 + 2] = 900
      nd48b[k48*4] = 0
      nd48b[k48*4 + 1] = 1000
      nd48b[k48*4 + 2] = 900
      k48 = k48 + 1
  }
  go_add(base48, 0, 5, GO_TAKEN, 100)
  var ph48: i64 = 0
  while ph48 < 2 {
      var e48: i64 = 0
      while e48 < 400 {
          var kp: i64 = 0
          while kp < en_count(m48) {
              let hp48: i64 = en_nth(m48, kp)
              let hp48b: i64 = en_nth(m48b, kp)
              var px48: i64 = 110*256
              var pz48: i64 = 110*256
              if ph48 == 0 {
                  if kp == 0 { px48 = 60*256 + 128; pz48 = 60*256 + 128 }
                  if kp == 1 { px48 = 60*256 + 282; pz48 = 60*256 + 128 }
                  if kp == 2 { px48 = 90*256; pz48 = 90*256 }
              } else {
                  if kp == 0 { px48 = 20*256; pz48 = 90*256 }
                  if kp == 1 { px48 = 70*256 + 128; pz48 = 70*256 + 128 }
                  if kp == 2 { px48 = 70*256 + 282; pz48 = 70*256 + 128 }
              }
              if hp48 > 0 { en_set(m48, hp48, MC_X, px48); en_set(m48, hp48, MC_Z, pz48) }
              if hp48b > 0 { en_set(m48b, hp48b, MC_X, px48); en_set(m48b, hp48b, MC_Z, pz48) }
              kp = kp + 1
          }
          apply2_impl(base48, 0, 0, 0, 0, 0, 0, 0, 0, 0)
          apply2_impl(base48b, 0, 0, 0, 0, 0, 0, 0, 0, 0)
          e48 = e48 + 1
      }
      ph48 = ph48 + 1
  }
  let mp48: *i64 = mindp(base48)
  let mp48b: *i64 = mindp(base48b)
  var bconf: i64 = 0 - 1
  var cconf: i64 = 0 - 1
  var i48: i64 = 0
  while i48 < 4 {
      let wb48: i64 = mp48[1*24 + 16 + i48*2]
      if (wb48 >> 16) == 5 { if ((wb48 >> 8) & 255) == GO_TAKEN { bconf = wb48 & 255 } }
      let wc48: i64 = mp48[2*24 + 16 + i48*2]
      if (wc48 >> 16) == 5 { if ((wc48 >> 8) & 255) == GO_TAKEN { cconf = wc48 & 255 } }
      i48 = i48 + 1
  }
  var ctl48: i64 = 0
  var k48c: i64 = 0
  while k48c < MOB_CAP {
      var i48c: i64 = 0
      while i48c < 4 { if mp48b[k48c*24 + 16 + i48c*2] != 0 { ctl48 = ctl48 + 1 } i48c = i48c + 1 }
      k48c = k48c + 1
  }
  vw("T48 gossip: B-conf=" as *u8); vn(bconf); vw(" C-conf=" as *u8); vn(cconf)
  vw(" control-facts=" as *u8); vn(ctl48); vw("\n" as *u8)
  if bconf > 0 { if bconf <= 85 { if cconf > 0 { if cconf < bconf { if ctl48 == 0 {
      pass = pass + 1 } } } } }
1758
  // T49 THE REVIEW STAGE (identity v2 = NISHI SHORE): near-flat, treeless, and the outfit
  // dimension ACTIVE with real variety across the cast -- while the CRAFT identity keeps
  // everyone clothed (the DATA row is what opens the dimension; the control proves it).
  let base49: i64 = sys_mmap(CRAFT_TOTAL + K_MAGIC_4096) as i64
  init_impl_v(base49, 2, K_MAGIC_20260728)
  var hmin49: i64 = 99
  var hmax49: i64 = 0
  var wood49: i64 = 0
  var z49: i64 = 8
  while z49 < 120 {
      var x49: i64 = 8
      while x49 < 120 {
          var y49: i64 = WY - 1
          var top49: i64 = 0 - 1
          while y49 >= 0 {
              if top49 < 0 { if vget(base49, x49, y49, z49) != 0 { top49 = y49 } }
              if vget(base49, x49, y49, z49) == 6 { wood49 = wood49 + 1 }
              y49 = y49 - 1
          }
          if top49 >= 0 {
              if top49 < hmin49 { hmin49 = top49 }
              if top49 > hmax49 { hmax49 = top49 }
          }
          x49 = x49 + 4
      }
      z49 = z49 + 4
  }
  let m49: *i64 = mobp(base49)
  var seen49: i64 = 0
  var clothed49: i64 = 0
  var k49: i64 = 0
  while k49 < en_count(m49) {
      let o49: i64 = mob_outfit(base49, k49)
      seen49 = seen49 | (1 << o49)
      if o49 == 0 { clothed49 = clothed49 + 1 }
      k49 = k49 + 1
  }
  var kinds49: i64 = 0
  var b49: i64 = 0
  while b49 < 3 { if (seen49 >> b49) & 1 == 1 { kinds49 = kinds49 + 1 } b49 = b49 + 1 }
  // control: the CRAFT identity's data keeps the dimension closed
  let base49b: i64 = sys_mmap(CRAFT_TOTAL + K_MAGIC_4096) as i64
  init_impl(base49b, K_MAGIC_20260728)
  let m49b: *i64 = mobp(base49b)
  var craftall49: i64 = 1
  var k49b: i64 = 0
  while k49b < en_count(m49b) {
      if mob_outfit(base49b, k49b) != 0 { craftall49 = 0 }
      k49b = k49b + 1
  }
  vw("T49 shore stage: height-spread=" as *u8); vn(hmax49 - hmin49)
  vw(" wood=" as *u8); vn(wood49)
  vw(" outfit-kinds=" as *u8); vn(kinds49)
  vw(" clothed=" as *u8); vn(clothed49)
  vw(" craft-all-clothed=" as *u8); vn(craftall49); vw("\n" as *u8)
  if hmax49 - hmin49 <= 6 { if wood49 == 0 { if kinds49 >= 2 { if clothed49 >= 1 {
      if craftall49 == 1 { pass = pass + 1 } } } } }
1816
  // T50 THE ISEKAI CARRY: deeds done in world A (craft) ride the passport into world B
  // (shore) -- a DIFFERENT world, freshly generated -- and the ledger keeps counting there.
  // Corrupt passports are REFUSED. Idempotence is the tooth's spine: syncing twice, or
  // re-entering the same world, must NEVER double-count a deed.
  let base50: i64 = sys_mmap(CRAFT_TOTAL + K_MAGIC_4096) as i64
  init_impl(base50, K_MAGIC_20260728)
  let s50: *i64 = wst(base50)
  s50[S_HARV] = 7
  s50[S_FOUND] = 2
  s50[S_BROKEN] = 40
  let n50: i64 = wc_pass_sync(base50)
  let lv50: i64 = pass_level_of(base50)
  wc_pass_sync(base50)                              // idempotence: a second sync adds nothing
  let p50: *i64 = passp(base50)
  let harvA: i64 = p50[5]
  // carry the bytes into a FRESH SHORE world
  let base50b: i64 = sys_mmap(CRAFT_TOTAL + K_MAGIC_4096) as i64
  init_impl_v(base50b, 2, 4242)
  let src50: *u8 = (base50 + O_PASS) as *u8
  let dst50: *u8 = (base50b + O_PASS) as *u8
  var c50: i64 = 0
  while c50 < PASS_LEN { dst50[c50] = src50[c50]; c50 = c50 + 1 }
  let rc50: i64 = wc_pass_apply(base50b)
  let s50b: *i64 = wst(base50b)
  s50b[S_HARV] = 3                                  // three more harvests in the NEW world
  wc_pass_sync(base50b)
  let p50b: *i64 = passp(base50b)
  let harvB: i64 = p50b[5]
  let mask50: i64 = p50b[10]
  // corrupt -> REFUSED, and the good arena is untouched
  let base50c: i64 = sys_mmap(CRAFT_TOTAL + K_MAGIC_4096) as i64
  init_impl(base50c, 999)
  let dst50c: *u8 = (base50c + O_PASS) as *u8
  var c50c: i64 = 0
  while c50c < PASS_LEN { dst50c[c50c] = src50[c50c]; c50c = c50c + 1 }
  let pc50: *i64 = passp(base50c)
  pc50[5] = pc50[5] + 1                             // tamper the harvest count
  let rcbad: i64 = wc_pass_apply(base50c)
  vw("T50 isekai: bytes=" as *u8); vn(n50); vw(" lv=" as *u8); vn(lv50)
  vw(" harvA=" as *u8); vn(harvA); vw(" (after +3 in world B) harvB=" as *u8); vn(harvB)
  vw(" arrive-rc=" as *u8); vn(rc50); vw(" worldmask=" as *u8); vn(mask50)
  vw(" tamper-rc=" as *u8); vn(rcbad); vw("\n" as *u8)
  if harvA == 7 { if rc50 == 0 { if harvB == 10 { if mask50 == 5 { if rcbad == 0 - 3 {
      if lv50 >= 2 { pass = pass + 1 } } } } } }
1861
  // T51 THE PARTY CROSSES: a BONDED girl invited with G walks off the boat in the next
  // world with her genome and bond intact; an UNBONDED girl is refused (a bond, not a
  // kidnapping); and the party never exceeds 3.
  let base51: i64 = sys_mmap(CRAFT_TOTAL + K_MAGIC_4096) as i64
  init_impl(base51, K_MAGIC_20260728)
  let m51: *i64 = mobp(base51)
  let s51: *i64 = wst(base51)
  let h51a: i64 = en_nth(m51, 0)
  let h51b: i64 = en_nth(m51, 1)
  en_set(m51, h51a, MC_DISG, (en_get(m51, h51a, MC_DISG) & 63) | (200 << 6))   // deep bond
  en_set(m51, h51b, MC_DISG, en_get(m51, h51b, MC_DISG) & 63)                  // stranger
  let gene51: i64 = en_get(m51, h51a, MC_GENE)
  s51[S_NPCT] = 0
  let inv51: i64 = party_of(base51)
  s51[S_NPCT] = 1
  let inv51b: i64 = party_of(base51)                // must REFUSE the stranger
  let pn51: i64 = wc_party_count(base51)
  wc_pass_sync(base51)
  let base51b: i64 = sys_mmap(CRAFT_TOTAL + K_MAGIC_4096) as i64
  init_impl_v(base51b, 2, 777)
  let cnt51pre: i64 = en_count(mobp(base51b))
  let src51: *u8 = (base51 + O_PASS) as *u8
  let dst51: *u8 = (base51b + O_PASS) as *u8
  var c51: i64 = 0
  while c51 < PASS_LEN { dst51[c51] = src51[c51]; c51 = c51 + 1 }
  let rc51: i64 = wc_pass_apply(base51b)
  let m51b: *i64 = mobp(base51b)
  var found51: i64 = 0
  var k51: i64 = 0
  while k51 < en_count(m51b) {
      let hk: i64 = en_nth(m51b, k51)
      if hk > 0 { if en_get(m51b, hk, MC_GENE) == gene51 { if (en_get(m51b, hk, MC_DISG) & 4) == 4 {
          if ((en_get(m51b, hk, MC_DISG) >> 6) & 255) >= 200 { found51 = 1 }
      } } }
      k51 = k51 + 1
  }
  vw("T51 party crosses: invite=" as *u8); vn(inv51); vw(" stranger-refused=" as *u8); vn(inv51b)
  vw(" party=" as *u8); vn(pn51); vw(" arrive-rc=" as *u8); vn(rc51)
  vw(" cast " as *u8); vn(cnt51pre); vw("->" as *u8); vn(en_count(m51b))
  vw(" companion-intact=" as *u8); vn(found51); vw("\n" as *u8)
  if inv51 == 1 { if inv51b == 0 - 2 { if pn51 == 1 { if rc51 == 0 { if found51 == 1 {
      if en_count(m51b) == cnt51pre + 1 { pass = pass + 1 } } } } } }
1904
  // T52 THE THIRD WORLD (v3 = NISHI VALE, medieval): a genuinely DIFFERENT land from craft
  // -- more relief, deeper woods, more cavern -- built from DATA ROWS ALONE, and its danger
  // is DECLARED (P_WARD) and SCALES with the arriving traveler's level. The three identities
  // must be mutually distinct: same engine, three worlds, zero engine code.
  let base52: i64 = sys_mmap(CRAFT_TOTAL + K_MAGIC_4096) as i64
  init_impl_v(base52, 3, K_MAGIC_20260728)
  var wood52: i64 = 0
  var cave52: i64 = 0
  var hmin52: i64 = 99
  var hmax52: i64 = 0
  var z52: i64 = 4
  while z52 < 124 {
      var x52: i64 = 4
      while x52 < 124 {
          var y52: i64 = WY - 1
          var top52: i64 = 0 - 1
          while y52 >= 0 {
              let b52: i64 = vget(base52, x52, y52, z52)
              if top52 < 0 { if b52 != 0 { top52 = y52 } }
              if b52 == 6 { wood52 = wood52 + 1 }
              if b52 == 0 { if y52 < top52 { cave52 = cave52 + 1 } }
              y52 = y52 - 1
          }
          if top52 >= 0 {
              if top52 < hmin52 { hmin52 = top52 }
              if top52 > hmax52 { hmax52 = top52 }
          }
          x52 = x52 + 3
      }
      z52 = z52 + 3
  }
  // craft's own numbers over the SAME sampling, for a like-for-like distinctness claim
  let base52b: i64 = sys_mmap(CRAFT_TOTAL + K_MAGIC_4096) as i64
  init_impl(base52b, K_MAGIC_20260728)
  var wood52b: i64 = 0
  var cave52b: i64 = 0
  var z52b: i64 = 4
  while z52b < 124 {
      var x52b: i64 = 4
      while x52b < 124 {
          var y52b: i64 = WY - 1
          var top52b: i64 = 0 - 1
          while y52b >= 0 {
              let b52b: i64 = vget(base52b, x52b, y52b, z52b)
              if top52b < 0 { if b52b != 0 { top52b = y52b } }
              if b52b == 6 { wood52b = wood52b + 1 }
              if b52b == 0 { if y52b < top52b { cave52b = cave52b + 1 } }
              y52b = y52b - 1
          }
          x52b = x52b + 3
      }
      z52b = z52b + 3
  }
  // danger scales with the traveler: same world, a level-1 arrival vs a veteran
  let p52: *i64 = passp(base52)
  let d52lo: i64 = pass_level_of(base52)
  p52[0] = PASS_MAGIC
  p52[1] = 1
  p52[5] = 400                                     // a veteran's harvest ledger
  p52[7] = 30
  p52[21] = wc_pass_ck(p52)
  let d52hi: i64 = pass_level_of(base52)
  vw("T52 vale: wood " as *u8); vn(wood52b); vw("->" as *u8); vn(wood52)
  vw(" cave " as *u8); vn(cave52b); vw("->" as *u8); vn(cave52)
  vw(" relief=" as *u8); vn(hmax52 - hmin52)
  vw(" ward=" as *u8); vn(wsp(base52)[P_WARD])
  vw(" lv " as *u8); vn(d52lo); vw("->" as *u8); vn(d52hi); vw("\n" as *u8)
  if wood52 > wood52b*2 { if cave52 > cave52b { if hmax52 - hmin52 >= 12 {
      if wsp(base52)[P_WARD] == 20 { if d52hi > d52lo + 5 { pass = pass + 1 } } } } }
1974
  // T53 THE LANDSCAPE ORACLE (PORTED 2026-08-02: built on the laptop lane last session and
  // never landed here -- the NAS gate ran total=52 while the local ran 53, so every "gate
  // GREEN" between was a green WITHOUT the landscape oracle. The banked LOCAL-IS-NOT-A-
  // SUPERSET fork, live.): terrain + forest measured against PUBLISHED reference bands.
  // (a) HYPSOMETRIC INTEGRAL via the Pike & Wilson elevation-relief identity
  // HI = (mean-min)/(max-min) -- one O(n) pass -- must land in the declared stage's band.
  // (b) STEM DENSITY in trees/ha against the 500-800 band (>3000 forest plots, DBH>=10cm).
  // Both REPORTED even when they pass: an oracle that only speaks on failure teaches nothing.
  let base53: i64 = sys_mmap(CRAFT_TOTAL + K_MAGIC_4096) as i64
  init_impl_v(base53, 3, K_MAGIC_20260728)
  var hsum: i64 = 0
  var hmin53: i64 = 999
  var hmax53: i64 = 0
  var ncol: i64 = 0
  var trunks: i64 = 0
  var z53: i64 = 2
  while z53 < WZ - 2 {
      var x53: i64 = 2
      while x53 < WX - 2 {
          var y53: i64 = WY - 1
          var top53: i64 = 0 - 1
          while y53 >= 0 {
              if top53 < 0 { if vget(base53, x53, y53, z53) != 0 { top53 = y53 } }
              y53 = y53 - 1
          }
          if top53 >= 0 {
              hsum = hsum + top53
              if top53 < hmin53 { hmin53 = top53 }
              if top53 > hmax53 { hmax53 = top53 }
              ncol = ncol + 1
          }
          var yt: i64 = 1
          while yt < WY - 1 {
              if vget(base53, x53, yt, z53) == 6 { if vget(base53, x53, yt + 1, z53) == 6 {
                  if vget(base53, x53, yt - 1, z53) != 6 { trunks = trunks + 1 }
              } }
              yt = yt + 1
          }
          x53 = x53 + 1
      }
      z53 = z53 + 1
  }
  var hi53: i64 = 0
  if hmax53 > hmin53 { hi53 = (hsum - ncol*hmin53)*1000/(ncol*(hmax53 - hmin53)) }
  var perha: i64 = 0
  if ncol > 0 { perha = trunks*10000/ncol }
  let stage53: i64 = wsp(base53)[P_HISTAGE]
  var hlo: i64 = 300
  var hhi: i64 = 600
  if stage53 == 1 { hlo = 600; hhi = 1000 }
  vw("T53 landscape: HI=" as *u8); vn(hi53); vw(" permil vs declared stage " as *u8); vn(stage53)
  vw(" band " as *u8); vn(hlo); vw(".." as *u8); vn(hhi); vw(" relief=" as *u8); vn(hmax53 - hmin53)
  vw(" | stems=" as *u8); vn(trunks); vw(" over " as *u8); vn(ncol); vw("m2 = " as *u8)
  vn(perha); vw(" trees/ha (published 500..800 at DBH>=10cm)\n" as *u8)
  var t53: i64 = 0
  if hi53 >= hlo { if hi53 <= hhi { if perha >= 500 { if perha <= 800 { t53 = 1 } } } }
  if t53 == 1 { pass = pass + 1 }
2032
  // T54 BREATHING (I1): the AUTONOMOUS ruler. The browser ?breath=1 probe measures the same
  // signal but needs an operator's GPU session; this tooth runs on every emit and REFUSES the
  // ship if idle life dies. Window = 780 ticks = 13s = 3.03 cycles at 14/min -- the window
  // must CONTAIN the signal (the published criterion once failed that floor). Frequency via
  // SIGN FLIPS of nonzero samples: at 1 q8 the driver is a 3-level staircase whose 0-plateaus
  // make the naive zero-crossing product 0, never negative -- it would UNDERCOUNT.
  let base54: i64 = sys_mmap(CRAFT_TOTAL + K_MAGIC_4096) as i64
  init_impl(base54, K_MAGIC_20260728)
  var flips54: i64 = 0
  var lastsg: i64 = 0
  var mx54: i64 = 0 - 99999
  var mn54: i64 = 99999
  var blendbad: i64 = 0
  var still54: i64 = 0
  // 1560 ticks = 26s = 6.07 cycles: the FIRST measurement (780 = 3.03 cycles) read fq=192 vs
  // band 200..300 with flips=5 -- one short, because the sign tracker forfeits the first
  // region (lastsg starts unset) and the granularity was 38 mHz/flip. The band was right;
  // the WINDOW was too short for its own resolution. Doubling halves the granularity and
  // makes the forfeited first flip a rounding term instead of a verdict-flipper.
  var e54: i64 = 0
  while e54 < 1560 {
      apply2_impl(base54, 0, 0, 0, 0, 0, 0, 0, 0, 0)
      let br54: i64 = mob_breath_q8i(base54, 0)
      if br54 > mx54 { mx54 = br54 }
      if br54 < mn54 { mn54 = br54 }
      var sg: i64 = 0
      if br54 > 0 { sg = 1 }
      if br54 < 0 { sg = 0 - 1 }
      // restructured to the gate's pure nested-if idiom: a trailing statement after a nested
      // if-chain inside one brace is the shape of the banked empty-.s parser trap (k45 class)
      var flip9: i64 = 0
      if sg != 0 { if lastsg != 0 { if sg != lastsg { flip9 = 1 } } }
      if flip9 == 1 { flips54 = flips54 + 1 }
      if sg != 0 { lastsg = sg }
      if mob_spd_q8i(base54, 0) == 0 {
          still54 = still54 + 1
          // blend identity: at rest the anchor IS the breath -- integer-exact, no tolerance
          if mob_anchor_q8i(base54, 0) != br54 { blendbad = blendbad + 1 }
      }
      e54 = e54 + 1
  }
  // fq in mHz cross-multiplied: flips/2 cycles over 13s => flips*1000*60/(2*780)
  let fq54: i64 = flips54*60000/(2*1560)
  // p2p in cm*100 via the cited conversion (7 q8 == 2.7cm => *100*100/256)
  let p2p54: i64 = (mx54 - mn54)*10000/256
  vw("T54 breath: fq=" as *u8); vn(fq54); vw(" mHz (band 200..300) p2p=" as *u8); vn(p2p54)
  vw(" cm*100 (band 40..80) still-ticks=" as *u8); vn(still54)
  vw(" blend-violations=" as *u8); vn(blendbad); vw(" flips=" as *u8); vn(flips54); vw("\n" as *u8)
  var t54: i64 = 0
  if fq54 >= 200 { if fq54 <= 300 { if p2p54 >= 40 { if p2p54 <= 80 { if blendbad == 0 { if still54 > 0 { t54 = 1 } } } } } }
  if t54 == 1 { pass = pass + 1 }
2084
  vw("nx_wasm_craft_gate: " as *u8); vn(pass); vw("/" as *u8); vn(total); vw("\n" as *u8)
  if pass == total { vw("VERDICT GREEN -- a generated 3D world: ray-true, walkable, editable, deterministic\n" as *u8) }
  if pass != total { vw("VERDICT RED\n" as *u8) }
  // D001 (debt 1785650687): the canonical ruler-readable verdict + harness.jrnl frame via the
  // shared lib, ON TOP of the legacy lines above -- they are this gate's public signature
  // since the 39/39 era and the judges anchor on the lib's "verdict=" shape, so both live.
  let gvc: *i64 = gv_ctr()
  gvc[0] = pass
  gvc[1] = total
  let rc9: i64 = gv_verdict("WASM-CRAFT-GATE" as *u8, gvc, "farming-life world: ray-true, deterministic, alive" as *u8)
  sys_exit(rc9)
  return 0
2097}
nx_wasm_craft_gate.nx source

`nx_wasm_craft_gate.nx` source
