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

↩ module page · 4192 lines · 209549 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_BYTE_MASK: i64 = 255            // low-byte extract when reading voxel cells as i64 (T56)
11// T79 (GE14a) bars. The DIVISOR is the recipe value under test -- the same number the new
12// world's row carries -- so the gate and the shipped world cannot disagree about what was
13// proven. SPREAD_MIN and CLAMP_MAX are what turn 'is this divisor right?' into a measurement:
14// a divisor too large flattens the world (spread collapses), one too small rails it against
15// the clamps (railed permil climbs). Both bars are deliberately loose -- they refuse a
16// DEGENERATE world, not an ugly one, because ugly is not a thing a gate can adjudicate.
17const T79_DIV: i64 = 12
18// HORIZONTAL SCALE: units of parameter space per block. Derived, not chosen: the core's
19// longest wavelength is 3400 units and a window is 128 blocks, so a scale of 32 makes the
20// window span 4096 units -- just over one full continent period, which is the smallest
21// scale at which the spline can contribute relief across a single world at all.
22const T79_SCALE: i64 = 32
23const T79_SPREAD_MIN: i64 = 12
24const T79_CLAMP_MAX: i64 = 250
25const K_SENTINEL_5A: i64 = 99344109427290   // 0x5A5A5A5A5A5A -- T58's untouched-memory sentinel pattern
26// T88 (2026-09-01, wind lane): wc_weather_tick bands the day as seg = S_T*8/P_DAYLEN, so a day holds
27// EIGHT distinct weather segments. That 8 is transcribed here ONCE -- the same discipline as the
28// PROJ_MAXV / RIG_BYTES pins, which cannot forward-reference their own tables either -- so the sweep
29// in T88 visits every segment exactly once. The transcription is CHECKABLE rather than asserted: if
30// this number stops matching the engine's banding the sweep collapses onto a single segment and
31// T88's state-changes-across-eighths conjunct goes to zero, which fails the tooth.
32const T88_EIGHTHS: i64 = 8
33// T90 (2026-09-04, the one gen-time allowlist): the count of engine P_* slots the tooth pins to nx_genp_allow_lib
34// (0..6 are pinned by their two ends, so 7 named slots stand for the block) and the treemax value the GENP fixture
35// carries -- crags' own recipe row (59:17), so the fixture is a shipped value rather than an invented one.
36const T90_PINS: i64 = 11
37const T90_TREEMAX: i64 = 17
38const K_BIRTH_HOLD_TICKS: i64 = 10000       // T35 fixture: park the birth cooldown far past the measured window so no newborn hijacks the hunter pick
39const K_MAGIC_2000: i64 = 2000   // NX-UNNAMED: mechanical, collision-free placeholder -- this name RESTATES the value and so carries no meaning. Replace it with a domain term that says WHY, or move the number to a config row.
40const K_MAGIC_1100: i64 = 1100   // NX-UNNAMED: mechanical, collision-free placeholder -- this name RESTATES the value and so carries no meaning. Replace it with a domain term that says WHY, or move the number to a config row.
41const K_MAGIC_4242: i64 = 4242   // NX-UNNAMED: mechanical, collision-free placeholder -- this name RESTATES the value and so carries no meaning. Replace it with a domain term that says WHY, or move the number to a config row.
42const K_MAGIC_10000: i64 = 10000   // NX-UNNAMED: mechanical, collision-free placeholder -- this name RESTATES the value and so carries no meaning. Replace it with a domain term that says WHY, or move the number to a config row.
43const K_MAGIC_99999: i64 = 99999   // NX-UNNAMED: mechanical, collision-free placeholder -- this name RESTATES the value and so carries no meaning. Replace it with a domain term that says WHY, or move the number to a config row.
44const K_MAGIC_1560: i64 = 1560   // NX-UNNAMED: mechanical, collision-free placeholder -- this name RESTATES the value and so carries no meaning. Replace it with a domain term that says WHY, or move the number to a config row.
45const K_MAGIC_60000: i64 = 60000   // NX-UNNAMED: mechanical, collision-free placeholder -- this name RESTATES the value and so carries no meaning. Replace it with a domain term that says WHY, or move the number to a config row.
46const K_MAGIC_74549: i64 = 74549   // NX-UNNAMED: mechanical, collision-free placeholder -- this name RESTATES the value and so carries no meaning. Replace it with a domain term that says WHY, or move the number to a config row.
47const K_MAGIC_4629: i64 = 4629   // NX-UNNAMED: mechanical, collision-free placeholder -- this name RESTATES the value and so carries no meaning. Replace it with a domain term that says WHY, or move the number to a config row.
48const K_MAGIC_1310720: i64 = 1310720   // NX-UNNAMED: mechanical, collision-free placeholder -- this name RESTATES the value and so carries no meaning. Replace it with a domain term that says WHY, or move the number to a config row.
49const K_MAGIC_3407872: i64 = 3407872   // NX-UNNAMED: mechanical, collision-free placeholder -- this name RESTATES the value and so carries no meaning. Replace it with a domain term that says WHY, or move the number to a config row.
50const K_MAGIC_1000000007: i64 = 1000000007
51const K_MAGIC_4096: i64 = 4096
52const K_MAGIC_9000: i64 = 9000            // T94 fixture: a poked day phase in ticks, arbitrary but inside DAYLEN (72000)
53const K_MAGIC_20260728: i64 = 20260728
54const K_MAGIC_3000: i64 = 3000
55const K_MAGIC_999999: i64 = 999999
56const K_MAGIC_12345: i64 = 12345
57const K_MAGIC_424242: i64 = 424242
58const K_MAGIC_1024: i64 = 1024
59const K_MAGIC_1536: i64 = 1536
60const K_MAGIC_6144: i64 = 6144
61const K_MAGIC_8191: i64 = 8191
62const K_MAGIC_57344: i64 = 57344
63const K_MAGIC_4611686018427387903: i64 = 4611686018427387903
64
65func vw(s: *u8) -> i64 { var n: i64=0; while s[n]!=(0 as u8){n=n+1} sys_write(1,s,n); return 0 }
66// GE55 T91: the door words the page sets through set_res / set_yflip, written straight into state on THIS arena
67func s9set(base: i64) -> i64 { let s: *i64 = wst(base); s[S_RESW] = 640; s[S_RESH] = 480; s[S_YFLIP] = 1; return 0 }
68func 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
79}
80// ⚠BOUND BY THE WRITTEN EXTENT, NOT THE CEILING. The renderer writes one pixel per ray (wc_rw x
81// wc_rh); it does NOT replicate rays into qxq blocks any more, so W*H spans unwritten memory. A scan
82// that still used W*H would be measuring the arena, not the frame -- and would report it as a colour
83// census. The emitted PNG is now the TRUE rendered image at its real resolution.
84func emit(base: i64, path: *u8) -> i64 {
  let ew: i64 = wc_rw(base)
  let eh: i64 = wc_rh(base)
  let rgbbuf: *u8 = sys_mmap(ew*eh*3) as *u8
  let f: *i64 = wfb(base)
  var p: i64 = 0
  while p < ew*eh {
      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, ew, eh)
98}
99func fbck(base: i64) -> i64 {
  let f: *i64 = wfb(base)
  var ck: i64 = 0
  var z: i64 = 0
  let n: i64 = wc_rw(base)*wc_rh(base)
  while z < n { ck = (ck ^ f[z]) * 3 % K_MAGIC_1000000007; z = z + 37 }
  return ck
106}
107func 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
116}
117
118func main() -> i64 {
  let base: i64 = sys_mmap(CRAFT_TOTAL + K_MAGIC_4096) as i64
  var pass: i64 = 0
  // ⚠THIS DENOMINATOR IS HAND-RECITED, which is the duplicate-ruler shape gv_ctr exists to remove:
  // adding a tooth means editing this number too, and the two can drift. It is fail-SAFE in both
  // directions here (forgetting to raise it makes pass exceed total and the gate reads RED, never a
  // false green), but the correct end state is gv_check owning the count. Raised 60 -> 61 for T61,
  // 61 -> 63 for T62 (rig-bytes drift) + T63 (mesh-not-billboard), 63 -> 64 for T64 (figure lambert),
  // 64 -> 65 for T65 (eyes-in-picture -- pinned after the mesh era silently lost them).
  let total: i64 = 96               // 93 -> 95 for T94 (GE59 day phase as data: a poked P_DAYPHASE re-bases S_T once) + T95 (neg-control:
                                    // an unset phase leaves the DAYLEN/4 boot clock alone), 2026-09-05;
                                    // 91 -> 93 for T92 (GE57 arena generation +1 per moving shift) + T93 (its
                                    // neg-control: a zero shift is not a generation), 2026-09-05;
                                    // 88 -> 90 for T89 (the seaward review arc, GE45 framing) + T90 (the one
                                    // gen-time allowlist, nx_genp_allow_lib), 2026-09-04;
                                    // 87 -> 88 for T88 (weather on the FPS frame path: the engine
                                    // call every shipped world page depends on, and the only one
                                    // that had no tooth anywhere in the tree);
                                    // 83 -> 87 for T84-T87 (GE13b: the wardrobe as DATA -- swimwear
                                    // beach, legacy contract, determinism + pose overlay, and the
                                    // missing-swim-row neg-control); 79 -> 83 for T80-T83 (the parametric gait drive:
                                    //   T80 stride phase is distance-driven not free-running,
                                    //   T81 the body faces its own travel not the camera,
                                    //   T82 fluidity, rate-limited AND convergent,
                                    //   T83 transverse-plane gait, cited and in opposition);
                                    // 78 -> 79 for T79 (GE14a staged-pipeline bind);
                                    // 77 -> 78 for T78 (GE12b body clearance);
                                    // 75 -> 77 for T76-T77 (GE13 ocean-is-data + outfit flags);
                                    // 74 -> 75 for T75 (GE12 gait-phased vertical locomotion);
                                    // 71 -> 74 for T72-T74 (W3 settlements: structural probe,
                                    // slide-and-return seam determinism, density-as-data)
  vw("=== nx_wasm_craft native verify (generated 3D voxel world) ===\n" as *u8)
150
  init_impl(base, K_MAGIC_20260728)
  let s: *i64 = wst(base)
153
  // 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 } } } } }
179
  // 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
205
  // 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 }
  let rw3: i64 = wc_rw(base)
  let rh3: i64 = wc_rh(base)
  var p2: i64 = 0
  while p2 < rw3*rh3 {
      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
  }
  // ⚠ROW STRIDE IS rw, NOT W. A compact frame's row 4 begins at 4*rw; indexing 4*W would sample
  // unwritten arena and report it as the sky pixel.
  let top: i64 = f[4*rw3 + rw3/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)
229
  // 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 } } } }
250
  // 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 } } } }
265
  // 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 } }
274
  // 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 }
286
  // 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)
293
  // 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 } }
307
  // 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 } } } }
329
  // 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 } } }
342
  // 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 }
356
  // 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 } } } }
375
  // 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 }
409
  // 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 }
446
  // 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 } }
468
  // 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 } }
498
  // 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 } } }
519
  // 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)
  let n19: i64 = wc_rw(base)*wc_rh(base)
  var p19: i64 = 0
  while p19 < n19 {
      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 }
537
  // T20 ADAPTIVE QUALITY -- THIS IS THE ORGAN THAT "SCALES TO THE AVAILABLE HARDWARE". Sustained
  // slow frames coarsen to Q_MAX and stop; sustained fast frames refine to 1 (native, one ray per
  // pixel) and stop; a steady 16ms neither coarsens nor refines, so the controller cannot flap.
  // ★ASSERTED AGAINST Q_MAX, NEVER A LITERAL. This tooth used to hardcode 5 -- the ceiling at the
  // time it was written. A tooth that COPIES a constant instead of REFERENCING it encodes a stale
  // ceiling and goes on passing after the real one moves, which is a test that cannot fail.
  // Budget note for whoever raises the ceiling next: the controller steps 1 per ~2-3 frames (EMA
  // resets to 256 after each step), so the 80/300 loop counts below must cover Q_MAX-Q_START and
  // Q_MAX-1 steps respectively. At Q_START=8, Q_MAX=24 that is 16 and 23 steps -- both covered.
  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] == Q_MAX { 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->Q_MAX 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 }
563
  // 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 }
597
  // T23 NATIVE RESOLUTION renders: q=1 is one ray per framebuffer pixel -- the full 1920x1200 =
  // 2.3M rays -- shot from the SPAWN vista (T22 parked the camera over edge water staring at sky,
  // which is a viewpoint measurement, not a quality one). This is the tooth that proves the raised
  // ceiling actually RENDERS rather than merely being allocated.
  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 }
  let n23: i64 = wc_rw(baseQ)*wc_rh(baseQ)
  var p23: i64 = 0
  while p23 < n23 {
      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
  }
  // ★THE PUBLISHED ARTIFACT IS THE NATIVE-RES FRAME. nx_gamebench_gate consumes this PNG and needs
  // >= GB_ART_MIN_RENDER (50,000) bytes. T3's frame is now 240x150 compact -- the renderer stopped
  // replicating each ray into a qxq block -- so it could have slipped under that floor and surfaced
  // in a SIBLING gate as "ARTIFACT MISSING/DECOY", an alarm pointing at the wrong organ. Emitting
  // the q=1 frame here overwrites it with the true 1920x1200 render: bigger, honest, and the direct
  // visual evidence for the raised ceiling.
  emit(baseQ, "knowledge/nx_wasm_craft_start.png" as *u8)
  sQ3[S_Q] = Q_START
  vw("T23 native-res q=1 distinct=" as *u8); vn(distinct23); vw(" (need >200)\n" as *u8)
  if distinct23 > 200 { pass = pass + 1 }
628
  // 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 }
647
  // 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)
670
  // 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)
686
  // 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)
721
  // 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 } } } }
749
  // 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 } } }
791
  // 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 } } }
851
  // 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 } } }
864
  // 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 } } } }
914
  // 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 } } } }
977
  // 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 }
1004
  // 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 }
1023
  // 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] = K_BIRTH_HOLD_TICKS
      // 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 }
1093
  // 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 }
1144
  // 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 }
1170
  // 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)
1182
  // 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 }
1264
  // 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 }
1297
  // 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 + K_MAGIC_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 } } } } }
1384
  // 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) > K_MAGIC_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 }
1426
  // 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 < K_MAGIC_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 }
1547
  // 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 }
1589
  // 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 } } }
1628
  // 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 } }
1687
  // 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 } } } }
1743
  // 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 < K_MAGIC_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 } } } }
1781
  // 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 } } } } }
1857
  // 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).
  // W3 reshape 2026-08-18: the shore's driftwood huts are WOOD BY DESIGN, so "treeless" is
  // measured on a shore whose settlement row is data-zeroed via the GENP lane (the lane T55
  // proves); the PLAIN shore must then stamp hut wood -- both directions of density-as-data.
  let base49: i64 = sys_mmap(CRAFT_TOTAL + K_MAGIC_4096) as i64
  let gp49: *i64 = wgp(base49)
  gp49[0] = GENP_MAGIC
  gp49[1] = 1
  gp49[2] = 62
  gp49[3] = 0
  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)
  // the positive direction: the PLAIN shore (settlement row live) must stamp hut wood.
  // Failing state witnessed 2026-08-18: the pre-solve engine stamped nothing anywhere.
  let base49c: i64 = sys_mmap(CRAFT_TOTAL + K_MAGIC_4096) as i64
  init_impl_v(base49c, 2, K_MAGIC_20260728)
  var wood49c: i64 = 0
  var z49c: i64 = 0
  while z49c < WZ {
      var x49c: i64 = 0
      while x49c < WX {
          var y49c: i64 = 0
          while y49c < WY {
              if vget(base49c, x49c, y49c, z49c) == 6 { wood49c = wood49c + 1 }
              y49c = y49c + 1
          }
          x49c = x49c + 1
      }
      z49c = z49c + 1
  }
  vw(" craft-all-clothed=" as *u8); vn(craftall49)
  vw(" hut-wood=" as *u8); vn(wood49c); vw("\n" as *u8)
  if hmax49 - hmin49 <= 6 { if wood49 == 0 { if kinds49 >= 2 { if clothed49 >= 1 {
      if craftall49 == 1 { if wood49c > 0 { pass = pass + 1 } } } } } }
1942
  // 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, K_MAGIC_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 } } } } } }
1987
  // 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 } } } } } }
2030
  // 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 } } } } }
2100
  // 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*K_MAGIC_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 }
2158
  // 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 - K_MAGIC_99999
  var mn54: i64 = K_MAGIC_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 < K_MAGIC_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*K_MAGIC_60000/(2*K_MAGIC_1560)
  // p2p in cm*100 via the cited conversion (7 q8 == 2.7cm => *100*100/256)
  let p2p54: i64 = (mx54 - mn54)*K_MAGIC_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 }
2210
  // T55 W1c GEN-TIME OVERRIDES (2026-08-13): recipe rows written into GENP BEFORE init must
  // reach genworld -- S_GENP counts what applied (world truth), the overridden spec rows must
  // hold the override, terrain must MOVE, a non-allowlisted idx (7, a style slot; 61 became W2
  // treespec and 62/63 became W3 settlement rows, so the control moved twice -- asserted against
  // the CONTROL world's own value, not a hardcoded default) is SKIPPED, and the
  // zero-region control (plain init, same identity+seed) is the negative control: S_GENP==0.
  let base55: i64 = sys_mmap(CRAFT_TOTAL + K_MAGIC_4096) as i64
  let base55b: i64 = sys_mmap(CRAFT_TOTAL + K_MAGIC_4096) as i64
  init_impl_v(base55, 3, K_MAGIC_20260728)
  let gp55: *i64 = wgp(base55b)
  gp55[0] = GENP_MAGIC
  gp55[1] = 5
  gp55[2] = 0
  gp55[3] = 4
  gp55[4] = 1
  gp55[5] = 30
  gp55[6] = 3
  gp55[7] = 5
  gp55[8] = 4
  gp55[9] = 18
  gp55[10] = 7
  gp55[11] = 777
  init_impl_v(base55b, 3, K_MAGIC_20260728)
  var hs55: i64 = 0
  var hs55b: i64 = 0
  var z55: i64 = 40
  while z55 < 56 {
      var x55: i64 = 40
      while x55 < 56 {
          var y55: i64 = WY - 1
          var go55: i64 = 1
          while go55 == 1 {
              if y55 < 0 { go55 = 0 } else {
                  if vget(base55, x55, y55, z55) != 0 { hs55 = hs55 + y55; go55 = 0 } else { y55 = y55 - 1 }
              }
          }
          y55 = WY - 1
          go55 = 1
          while go55 == 1 {
              if y55 < 0 { go55 = 0 } else {
                  if vget(base55b, x55, y55, z55) != 0 { hs55b = hs55b + y55; go55 = 0 } else { y55 = y55 - 1 }
              }
          }
          x55 = x55 + 1
      }
      z55 = z55 + 1
  }
  vw("T55 genp: ctl_S_GENP=" as *u8); vn(wst(base55)[S_GENP])
  vw(" ovr_S_GENP=" as *u8); vn(wst(base55b)[S_GENP])
  vw(" tbase=" as *u8); vn(wsp(base55b)[P_TBASE])
  vw(" amp1=" as *u8); vn(wsp(base55b)[P_TAMP1])
  vw(" spec7 ovr=" as *u8); vn(wsp(base55b)[7])
  vw(" ctl=" as *u8); vn(wsp(base55)[7])
  vw(" hsum ctl=" as *u8); vn(hs55); vw(" ovr=" as *u8); vn(hs55b); vw("\n" as *u8)
  var t55: i64 = 0
  if wst(base55)[S_GENP] == 0 { if wst(base55b)[S_GENP] == 4 {
      if wsp(base55b)[P_TBASE] == 4 { if wsp(base55b)[P_TAMP1] == 30 {
          if wsp(base55b)[7] == wsp(base55)[7] { if hs55 != hs55b { t55 = 1 } } } } } }
  if t55 == 1 { pass = pass + 1 }
2270
  // T56 W2 SPECIES TREES: a P_TREESPEC genome row (slot 61 via GENP) changes the FOREST both
  // ways (legacy vs pine, pine vs dome), and genome 0 is EQUIVALENT to the legacy stamp --
  // the control that keeps every identity-only world unchanged.
  let base56: i64 = sys_mmap(CRAFT_TOTAL + K_MAGIC_4096) as i64
  let base56b: i64 = sys_mmap(CRAFT_TOTAL + K_MAGIC_4096) as i64
  let base56c: i64 = sys_mmap(CRAFT_TOTAL + K_MAGIC_4096) as i64
  let base56d: i64 = sys_mmap(CRAFT_TOTAL + K_MAGIC_4096) as i64
  init_impl_v(base56, 3, K_MAGIC_20260728)
  let gp56: *i64 = wgp(base56b)
  gp56[0] = GENP_MAGIC
  gp56[1] = 1
  gp56[2] = 61
  gp56[3] = K_MAGIC_74549
  init_impl_v(base56b, 3, K_MAGIC_20260728)
  let gp56c: *i64 = wgp(base56c)
  gp56c[0] = GENP_MAGIC
  gp56c[1] = 1
  gp56c[2] = 61
  gp56c[3] = K_MAGIC_4629
  init_impl_v(base56c, 3, K_MAGIC_20260728)
  let gp56d: *i64 = wgp(base56d)
  gp56d[0] = GENP_MAGIC
  gp56d[1] = 1
  gp56d[2] = 61
  gp56d[3] = 0
  init_impl_v(base56d, 3, K_MAGIC_20260728)
  var wdA: i64 = 0
  var lfA: i64 = 0
  var wdB: i64 = 0
  var lfB: i64 = 0
  var wdC: i64 = 0
  var lfC: i64 = 0
  var wdD: i64 = 0
  var lfD: i64 = 0
  var ci56: i64 = 0
  while ci56 < WX*WY*WZ {
      let bA: i64 = (wvx(base56)[ci56] as i64) & K_BYTE_MASK
      if bA == 6 { wdA = wdA + 1 }
      if bA == 7 { lfA = lfA + 1 }
      let bB: i64 = (wvx(base56b)[ci56] as i64) & K_BYTE_MASK
      if bB == 6 { wdB = wdB + 1 }
      if bB == 7 { lfB = lfB + 1 }
      let bC: i64 = (wvx(base56c)[ci56] as i64) & K_BYTE_MASK
      if bC == 6 { wdC = wdC + 1 }
      if bC == 7 { lfC = lfC + 1 }
      let bD: i64 = (wvx(base56d)[ci56] as i64) & K_BYTE_MASK
      if bD == 6 { wdD = wdD + 1 }
      if bD == 7 { lfD = lfD + 1 }
      ci56 = ci56 + 1
  }
  vw("T56 species: legacy wood/leaf=" as *u8); vn(wdA); vw("/" as *u8); vn(lfA)
  vw(" pine=" as *u8); vn(wdB); vw("/" as *u8); vn(lfB)
  vw(" dome=" as *u8); vn(wdC); vw("/" as *u8); vn(lfC)
  vw(" genome0=" as *u8); vn(wdD); vw("/" as *u8); vn(lfD)
  vw(" S_GENP b/c/d=" as *u8); vn(wst(base56b)[S_GENP]); vw("/" as *u8); vn(wst(base56c)[S_GENP]); vw("/" as *u8); vn(wst(base56d)[S_GENP]); vw("\n" as *u8)
  var t56: i64 = 0
  if lfB != lfA { if lfC != lfB { if wdB != wdA {
      if wdD == wdA { if lfD == lfA {
          if wst(base56b)[S_GENP] == 1 { t56 = 1 } } } } } }
  if t56 == 1 { pass = pass + 1 }
2331
  // T57 W2b UNDERSTORY: a genome carrying ONLY understory bits grows ground vegetation
  // (leaves rise) while the FOREST stays exactly legacy (wood equality = the tooth that
  // catches understory bits leaking into the tree branch); shrubs out-leaf tufts.
  let base57: i64 = sys_mmap(CRAFT_TOTAL + K_MAGIC_4096) as i64
  let base57b: i64 = sys_mmap(CRAFT_TOTAL + K_MAGIC_4096) as i64
  let gp57: *i64 = wgp(base57)
  gp57[0] = GENP_MAGIC
  gp57[1] = 1
  gp57[2] = 61
  gp57[3] = K_MAGIC_1310720
  init_impl_v(base57, 3, K_MAGIC_20260728)
  let gp57b: *i64 = wgp(base57b)
  gp57b[0] = GENP_MAGIC
  gp57b[1] = 1
  gp57b[2] = 61
  gp57b[3] = K_MAGIC_3407872
  init_impl_v(base57b, 3, K_MAGIC_20260728)
  var wdT: i64 = 0
  var lfT: i64 = 0
  var wdS: i64 = 0
  var lfS: i64 = 0
  var ci57: i64 = 0
  while ci57 < WX*WY*WZ {
      let bT: i64 = (wvx(base57)[ci57] as i64) & K_BYTE_MASK
      if bT == 6 { wdT = wdT + 1 }
      if bT == 7 { lfT = lfT + 1 }
      let bS: i64 = (wvx(base57b)[ci57] as i64) & K_BYTE_MASK
      if bS == 6 { wdS = wdS + 1 }
      if bS == 7 { lfS = lfS + 1 }
      ci57 = ci57 + 1
  }
  vw("T57 understory: tufts wood/leaf=" as *u8); vn(wdT); vw("/" as *u8); vn(lfT)
  vw(" shrubs=" as *u8); vn(wdS); vw("/" as *u8); vn(lfS)
  vw(" (legacy " as *u8); vn(wdA); vw("/" as *u8); vn(lfA); vw(")\n" as *u8)
  var t57: i64 = 0
  if wdT == wdA { if lfT > lfA { if wdS == wdA { if lfS > lfT { t57 = 1 } } } }
  if t57 == 1 { pass = pass + 1 }
2369
  // T58 COMPACT-WRITE EXTENT -- BOTH DIRECTIONS. The renderer writes ONE pixel per ray into a
  // rw x rh region and no longer replicates each ray into a qxq block, so the framebuffer beyond
  // rw*rh is NOT written. FIVE separate scans in this gate used to bound by W*H; every one of them
  // would have read unwritten arena and reported it as a colour census. This tooth makes the
  // invariant mechanical instead of remembered:
  //   under-write -- the LAST word INSIDE the extent must have been overwritten
  //   over-write  -- the FIRST word PAST the extent must still hold the sentinel
  // Both halves are required: a renderer that wrote NOTHING AT ALL passes the over-write half on
  // its own, which is exactly the shape of a test that cannot fail.
  // The sentinel is wider than 24 bits, so no real packed colour can equal it by accident.
  let base58: i64 = sys_mmap(CRAFT_TOTAL + K_MAGIC_4096) as i64
  init_impl(base58, K_MAGIC_20260728)
  let s58: *i64 = wst(base58)
  s58[S_Q] = Q_START
  let rw58: i64 = wc_rw(base58)
  let rh58: i64 = wc_rh(base58)
  let f58: *i64 = wfb(base58)
  // ⚠SEED ONLY WHAT IS ASSERTED ON. Sentinel-filling all W*H (2.3M words) to then inspect THREE
  // positions is work nobody reads, and at the raised ceiling it is what pushed this gate past its
  // wall-clock deadline. The three assertions below touch the last word inside the extent, the
  // first word past it, and the far corner -- so seeding exactly those leaves the tooth
  // byte-for-byte as strong at ~1/2000th of the cost. A cheaper test that checks LESS would be a
  // weakened tooth; this one checks the same three words.
  let SENT58: i64 = K_SENTINEL_5A
  let lo58: i64 = rw58*rh58 - 1
  var i58: i64 = lo58
  while i58 < lo58 + K_MAGIC_1024 { f58[i58] = SENT58; i58 = i58 + 1 }
  f58[W*H - 1] = SENT58
  render_impl(base58)
  let inside58: i64 = f58[rw58*rh58 - 1]
  let past58: i64 = f58[rw58*rh58]
  let far58: i64 = f58[W*H - 1]
  var a58: i64 = 0
  if inside58 != SENT58 { a58 = 1 }
  var b58: i64 = 0
  if past58 == SENT58 { b58 = 1 }
  var c58: i64 = 0
  if far58 == SENT58 { c58 = 1 }
  let t58: i64 = a58 + b58 + c58
  vw("T58 compact extent rw=" as *u8); vn(rw58); vw(" rh=" as *u8); vn(rh58)
  vw(" last-inside-written=" as *u8); vn(a58)
  vw(" first-past-clean=" as *u8); vn(b58)
  vw(" neg-control-far-word-untouched=" as *u8); vn(c58)
  vw(" (extent " as *u8); vn(rw58*rh58); vw(" of ceiling " as *u8); vn(W*H); vw(")\n" as *u8)
  if t58 == 3 { pass = pass + 1 }
2415
  // T59 THE GIRLS ARE ACTUALLY IN THE PICTURE. mob_draw is WIRED (render_impl calls it) and the
  // mobs exist in state -- T16/T17/T28/T29 all pass on state alone -- yet the frame can still be
  // empty of them, because mob_draw projected with the framebuffer CEILING (W/2, H/2, stride W)
  // while the renderer had gone compact. Every girl landed outside the written region: present in
  // state, absent from the picture, with 58 teeth green.
  // ★A COLOUR-VARIETY TOOTH CANNOT SEE THIS -- terrain alone is varied, so T3/T19/T23 stay green
  // with no character on screen. The only honest test renders the SAME frame twice, differing ONLY
  // in whether the girls are near, so the delta IS the girls.
  let base59: i64 = sys_mmap(CRAFT_TOTAL + K_MAGIC_4096) as i64
  init_impl(base59, K_MAGIC_20260728)
  let s59: *i64 = wst(base59)
  let m59: *i64 = mobp(base59)
  s59[S_PITCH] = 0
  let fx59: i64 = it_sin4096(s59[S_YAW])
  let fz59: i64 = it_cos4096(s59[S_YAW])
  let tx59: i64 = s59[S_CX] + fx59*4*256/K_MAGIC_4096
  let tz59: i64 = s59[S_CZ] + fz59*4*256/K_MAGIC_4096
  let gy59: i64 = mob_ground(base59, tx59/256, WY-1, tz59/256)
  let h59: i64 = en_nth(m59, 0)
  var t59: i64 = 0
  var seen59: i64 = 0
  var diff59: i64 = 0
  if gy59 >= 0 { if h59 > 0 {
      // stand her four blocks straight ahead, camera at her eye height so she is IN FRAME
      en_set(m59, h59, MC_X, tx59)
      en_set(m59, h59, MC_Z, tz59)
      en_set(m59, h59, MC_Y, (gy59+1)*256)
      s59[S_CY] = (gy59+1)*256 + 128
      render_impl(base59)
      let f59: *i64 = wfb(base59)
      let np59: i64 = wc_rw(base59)*wc_rh(base59)
      let snap59: *i64 = sys_mmap(np59*8) as *i64
      var i59: i64 = 0
      while i59 < np59 { snap59[i59] = f59[i59]; i59 = i59 + 1 }
      // neg-control-girls-removed: move EVERY mob to the far corner, change nothing else, re-render
      var k59: i64 = 0
      while k59 < en_count(m59) {
          let hh59: i64 = en_nth(m59, k59)
          if hh59 > 0 {
              en_set(m59, hh59, MC_X, 256)
              en_set(m59, hh59, MC_Z, 256)
          }
          k59 = k59 + 1
      }
      render_impl(base59)
      var j59: i64 = 0
      while j59 < np59 {
          if snap59[j59] != f59[j59] { diff59 = diff59 + 1 }
          j59 = j59 + 1
      }
      seen59 = 1
      // a billboard four blocks out must cover MANY pixels; >0 alone would pass on a single
      // stray word, which is how an almost-broken projection sneaks through.
      if diff59 > 64 { t59 = 1 }
  } }
  vw("T59 girls-in-frame: placed-ok=" as *u8); vn(seen59)
  vw(" pixels-that-are-her=" as *u8); vn(diff59)
  vw(" (need >64; neg-control-girls-removed is the same frame with every mob moved away)\n" as *u8)
  vw("    T59 is BITE-PROVEN both ways 2026-08-14: reverting mob_draw's mrw/2 to W/2 -- the original\n" as *u8)
  vw("    defect, projecting into the framebuffer CEILING instead of ray space -- makes this read 0\n" as *u8)
  vw("    and the gate 58/59 RED, while all 58 other teeth stay GREEN. That gap IS why it exists.\n" as *u8)
  if t59 == 1 { pass = pass + 1 }
2478
  // T61 THE GIRLS ARE GENOME-DISTINCT IN THE PICTURE, NOT JUST IN STATE. T29 proves twelve distinct
  // genomes exist; T59 proves a girl reaches the frame. NEITHER can see that mob_draw was painting
  // mob_col(kind, half) -- two flat tones per KIND -- so twelve genetically distinct girls rendered as
  // three identical pairs. MC_GENE carries hair hue, outfit tint and skin tone and every bit of it was
  // discarded at the last step: the variety was in the data and never reached a pixel.
  // The test places two SAME-KIND, DIFFERENT-GENOME girls at the IDENTICAL spot, one after the other,
  // and requires the frames to differ.
  // ★THE NEG-CONTROL IS WHAT MAKES IT MEAN ANYTHING: the SAME girl placed twice must render BIT-
  // IDENTICAL. Without it a nondeterministic renderer passes this tooth on noise, and the tooth would
  // be measuring the RNG rather than the genome.
  var t61: i64 = 0
  var pairfound: i64 = 0
  var diffAB: i64 = 0
  var diffAA: i64 = 0
  let mm61: *i64 = mobp(base59)
  // find two live mobs of the SAME kind with DIFFERENT genomes -- same kind is the point, because a
  // kind difference would show up even under the old flat-tone renderer.
  var ha61: i64 = 0
  var hb61: i64 = 0
  var i61: i64 = 0
  while i61 < en_count(mm61) {
      let h1: i64 = en_nth(mm61, i61)
      if h1 > 0 { if pairfound == 0 {
          var j61: i64 = i61 + 1
          while j61 < en_count(mm61) {
              let h2: i64 = en_nth(mm61, j61)
              if h2 > 0 { if pairfound == 0 {
                  if en_get(mm61, h1, MC_KIND) == en_get(mm61, h2, MC_KIND) {
                      if en_get(mm61, h1, MC_GENE) != en_get(mm61, h2, MC_GENE) {
                          ha61 = h1
                          hb61 = h2
                          pairfound = 1
                      }
                  }
              } }
              j61 = j61 + 1
          }
      } }
      i61 = i61 + 1
  }
  if pairfound == 1 {
      let f61: *i64 = wfb(base59)
      let np61: i64 = wc_rw(base59)*wc_rh(base59)
      let snapA: *i64 = sys_mmap(np61*8) as *i64
      let snapA2: *i64 = sys_mmap(np61*8) as *i64
      // park EVERY mob far away so exactly one subject is ever in frame
      var k61: i64 = 0
      while k61 < en_count(mm61) {
          let hh61: i64 = en_nth(mm61, k61)
          if hh61 > 0 { en_set(mm61, hh61, MC_X, 256); en_set(mm61, hh61, MC_Z, 256) }
          k61 = k61 + 1
      }
      // girl A on the mark
      en_set(mm61, ha61, MC_X, tx59)
      en_set(mm61, ha61, MC_Z, tz59)
      en_set(mm61, ha61, MC_Y, (gy59+1)*256)
      render_impl(base59)
      var c61: i64 = 0
      while c61 < np61 { snapA[c61] = f61[c61]; c61 = c61 + 1 }
      // NEG-CONTROL: the same girl, same mark, rendered again -- must be bit-identical
      render_impl(base59)
      c61 = 0
      while c61 < np61 { snapA2[c61] = f61[c61]; c61 = c61 + 1 }
      var d61: i64 = 0
      while d61 < np61 { if snapA[d61] != snapA2[d61] { diffAA = diffAA + 1 } d61 = d61 + 1 }
      // girl B on the SAME mark, A parked
      en_set(mm61, ha61, MC_X, 256)
      en_set(mm61, ha61, MC_Z, 256)
      en_set(mm61, hb61, MC_X, tx59)
      en_set(mm61, hb61, MC_Z, tz59)
      en_set(mm61, hb61, MC_Y, (gy59+1)*256)
      render_impl(base59)
      d61 = 0
      while d61 < np61 { if snapA[d61] != f61[d61] { diffAB = diffAB + 1 } d61 = d61 + 1 }
      // BOTH conjuncts, named: the genome must change the picture AND the renderer must be
      // deterministic, or the difference is not attributable to the genome.
      if diffAB > 0 { if diffAA == 0 { t61 = 1 } }
  }
  vw("T61 genome-distinct girls: pair-found=" as *u8); vn(pairfound)
  vw(" same-kind-diff-genome-pixels=" as *u8); vn(diffAB)
  vw(" neg-control-same-girl-twice=" as *u8); vn(diffAA)
  vw(" (need pixels>0 AND neg-control==0)\n" as *u8)
  if t61 == 1 { pass = pass + 1 }
2562
  // T68 HAIR LENGTH REACHES THE PICTURE. MC_GENE bits 3-4 are DOCUMENTED hair length, bred by
  // gn_breed -- and until 2026-08-16 no renderer consumed them: the exact defect class T61 pinned
  // for hue (carried in the data, discarded at the last pixel). Same girl, same mark, gene
  // differing ONLY in the length bits: short twice must be BIT-IDENTICAL, short vs long must
  // differ, and the fall anchors must be strictly ordered (a curtain drawn at one fixed length
  // passes neither the diff nor nothing -- it fails the diff conjunct by construction).
  // ⚠STATE CONTRACT: T63/T65 below measure the framebuffer AS T61 LEAVES IT (girl B on the mark,
  // rendered) -- this tooth re-renders, so it must RESTORE that exact state before it ends.
  var t68: i64 = 0
  var hairdiff: i64 = 0
  var hairctl: i64 = 0
  var ord68: i64 = 0
  if rig_hair_y(0) > rig_hair_y(1) { if rig_hair_y(1) > rig_hair_y(2) { if rig_hair_y(2) > rig_hair_y(3) { ord68 = 1 } } }
  if pairfound == 1 {
      // ⚠q=1 NATIVE, measured not tasted: the lock strips are ~4.6 q8 wide -- at this gate's q=5
      // (240x150) that is HALF A PIXEL, the integer projection collapses the quad to zero area and
      // wc_tri correctly draws nothing (the T68-diag line below proved it: both edges landed on
      // screen x=121). The browser's adaptive controller runs q=1 when fast, and the portrait
      // instrument already renders q=1 for the same reason -- measure at the resolution the
      // deliverable actually ships, never fatten the subject to please a coarse ruler.
      let f68: *i64 = wfb(base59)
      let st68: *i64 = wst(base59)
      let q68: i64 = st68[S_Q]
      st68[S_Q] = 1
      let np68: i64 = wc_rw(base59)*wc_rh(base59)
      let snapH: *i64 = sys_mmap(np68*8) as *i64
      let g68: i64 = en_get(mm61, ha61, MC_GENE)
      let gbase: i64 = g68 - (((g68 >> MG_HAIRLEN_SH) & MG_HAIRLEN_MASK) << MG_HAIRLEN_SH)
      let glong: i64 = gbase + (MG_HAIRLEN_MASK << MG_HAIRLEN_SH)
      en_set(mm61, hb61, MC_X, 256)
      en_set(mm61, hb61, MC_Z, 256)
      en_set(mm61, ha61, MC_X, tx59)
      en_set(mm61, ha61, MC_Z, tz59)
      en_set(mm61, ha61, MC_Y, (gy59+1)*256)
      en_set(mm61, ha61, MC_GENE, gbase)
      render_impl(base59)
      var c68: i64 = 0
      while c68 < np68 { snapH[c68] = f68[c68]; c68 = c68 + 1 }
      render_impl(base59)
      c68 = 0
      while c68 < np68 { if snapH[c68] != f68[c68] { hairctl = hairctl + 1 } c68 = c68 + 1 }
      en_set(mm61, ha61, MC_GENE, glong)
      render_impl(base59)
      c68 = 0
      while c68 < np68 { if snapH[c68] != f68[c68] { hairdiff = hairdiff + 1 } c68 = c68 + 1 }
      // restore: the tooth's own q FIRST, then A's true gene, A parked, B back on the mark, frame
      // re-rendered (at the restored q) for T63/T65
      st68[S_Q] = q68
      en_set(mm61, ha61, MC_GENE, g68)
      en_set(mm61, ha61, MC_X, 256)
      en_set(mm61, ha61, MC_Z, 256)
      en_set(mm61, hb61, MC_X, tx59)
      en_set(mm61, hb61, MC_Z, tz59)
      en_set(mm61, hb61, MC_Y, (gy59+1)*256)
      render_impl(base59)
      if hairdiff > 0 { if hairctl == 0 { if ord68 == 1 { t68 = 1 } } }
  }
  vw("T68 hair-length-in-picture: short-vs-long-pixels=" as *u8); vn(hairdiff)
  vw(" neg-control-short-twice=" as *u8); vn(hairctl)
  vw(" anchors-ordered=" as *u8); vn(ord68)
  vw(" (pixels>0 AND control==0 AND jaw>shoulder>waist>hip)\n" as *u8)
  // DIAGNOSTIC (temporary instrument, printed always): where did the lock verts actually land?
  // rig-space (skinned) and screen-space (projected) for the first lock top and its long-fall
  // bottom -- distinguishes build-wrong / clipped / culled without another guess.
  let dg68: i64 = rigp(base59)
  let pj68: *i64 = projp(base59)
  let dt0: i64 = RIG_SEGN*12 + 1 + 2 + 8 + HAIR_NLEN*RIG_RINGN
  let db3: i64 = dt0 + 4 + 3*4
  let so68a: *i64 = sk_out(dg68, dt0)
  let so68b: *i64 = sk_out(dg68, db3)
  vw("    T68-diag lockTop rig=(" as *u8); vn(so68a[0]); vw("," as *u8); vn(so68a[1]); vw("," as *u8); vn(so68a[2])
  vw(") proj=(" as *u8); vn(pj68[dt0*3]); vw("," as *u8); vn(pj68[dt0*3+1]); vw("," as *u8); vn(pj68[dt0*3+2])
  vw(")  lockBot3 rig=(" as *u8); vn(so68b[0]); vw("," as *u8); vn(so68b[1]); vw("," as *u8); vn(so68b[2])
  vw(") proj=(" as *u8); vn(pj68[db3*3]); vw("," as *u8); vn(pj68[db3*3+1]); vw("," as *u8); vn(pj68[db3*3+2])
  vw(")\n" as *u8)
  if t68 == 1 { pass = pass + 1 }
2639
  // T62 THE RIG-BYTES DUPLICATE CANNOT DRIFT. CRAFT_TOTAL is a const and a const cannot call
  // sk_bytes(), so the engine carries the value written out once as RIG_BYTES -- a deliberate
  // duplicate, admissible ONLY because this tooth pins it to the function it copies. If nx_skeleton's
  // layout ever moves, this goes RED before a mis-sized arena ships.
  var t62: i64 = 0
  if RIG_BYTES == sk_bytes() { t62 = 1 }
  vw("T62 rig-bytes drift: RIG_BYTES=" as *u8); vn(RIG_BYTES)
  vw(" sk_bytes()=" as *u8); vn(sk_bytes())
  vw(" (must be equal)\n" as *u8)
  if t62 == 1 { pass = pass + 1 }
2650
  // T63 A MESH IS NOT A BILLBOARD, MEASURED AS GEOMETRY. A billboard fills ~100 percent of its own
  // bounding box (it IS a rectangle); a skinned figure -- head over shoulders over legs with air
  // between the limbs -- cannot. Fill permil of the girl's pixels over her bbox is therefore a shape
  // discriminator no colour tooth can fake: >=900 means the quad came back, <=100 means she has
  // degenerated to scattered specks. BOTH bounds bite.
  var t63: i64 = 0
  var fillp: i64 = 0 - 1
  var t65: i64 = 0
  var irisg: i64 = 0
  var irise: i64 = 0
  if pairfound == 1 {
      // girl B is still on the T61 mark; park her too, bank the empty frame, then stand A up again
      en_set(mm61, hb61, MC_X, 256)
      en_set(mm61, hb61, MC_Z, 256)
      render_impl(base59)
      let fE: *i64 = wfb(base59)
      let npE: i64 = wc_rw(base59)*wc_rh(base59)
      let snapE: *i64 = sys_mmap(npE*8) as *i64
      var cE: i64 = 0
      while cE < npE { snapE[cE] = fE[cE]; cE = cE + 1 }
      en_set(mm61, ha61, MC_X, tx59)
      en_set(mm61, ha61, MC_Z, tz59)
      en_set(mm61, ha61, MC_Y, (gy59+1)*256)
      render_impl(base59)
      let rwE: i64 = wc_rw(base59)
      var cnt: i64 = 0
      var bx0: i64 = K_MAGIC_999999
      var bx1: i64 = 0 - 1
      var by0: i64 = K_MAGIC_999999
      var by1: i64 = 0 - 1
      var dE: i64 = 0
      while dE < npE {
          if snapE[dE] != fE[dE] {
              cnt = cnt + 1
              let pxE: i64 = dE % rwE
              let pyE: i64 = dE / rwE
              if pxE < bx0 { bx0 = pxE }
              if pxE > bx1 { bx1 = pxE }
              if pyE < by0 { by0 = pyE }
              if pyE > by1 { by1 = pyE }
          }
          dE = dE + 1
      }
      if cnt > 0 { if bx1 >= bx0 { if by1 >= by0 {
          let bboxE: i64 = (bx1-bx0+1)*(by1-by0+1)
          if bboxE > 0 { fillp = cnt*1000/bboxE }
      } } }
      if fillp > 100 { if fillp < 900 { t63 = 1 } }
      // T65 material: iris pixels IN HER BBOX, girl-frame vs girl-less frame -- both directions bite.
      // This tooth exists because the mesh era silently LOST the eyes (iris verts landed inside the
      // head radius, so every depth tie failed) and nothing watched: a feature that only shows on a
      // picture nobody diffs is a feature that can vanish without a RED.
      if cnt > 0 { if bx1 >= bx0 {
          let irc: i64 = wpack(24, 20, 34)
          var iy: i64 = by0
          while iy <= by1 {
              var ix: i64 = bx0
              while ix <= bx1 {
                  if fE[iy*rwE + ix] == irc { irisg = irisg + 1 }
                  if snapE[iy*rwE + ix] == irc { irise = irise + 1 }
                  ix = ix + 1
              }
              iy = iy + 1
          }
          if irisg > irise { t65 = 1 }
      } }
  }
  vw("T63 mesh-not-billboard: fill_permil=" as *u8); vn(fillp)
  vw(" (billboard ~1000, specks <=100; need 100<fill<900)\n" as *u8)
  if t63 == 1 { pass = pass + 1 }
2721
  vw("T65 eyes-in-picture: iris-px girl=" as *u8); vn(irisg)
  vw(" girl-less=" as *u8); vn(irise)
  vw(" (girl must exceed girl-less in her own bbox)\n" as *u8)
  if t65 == 1 { pass = pass + 1 }
2726
  // T64 FIGURE LIGHTING, THE NON-GAMEABLE FORM (wp_shade's own shape): a sun-facing normal must come
  // out STRICTLY brighter than a sun-away one on every channel, AND the away side must equal the
  // ambient floor EXACTLY -- an equality the magnitude approximation cannot drift, so this tooth pins
  // the ordering no matter how the ambient value is later tuned. Both signals in one tooth: a shader
  // that returns a constant fails the ordering; one that ignores ambient fails the equality.
  var t64: i64 = 0
  let lc: i64 = wpack(200, 160, 120)
  let lsun: i64 = wc_lambert(WATER_MAGIC_2400, WATER_MAGIC_2500, WATER_MAGIC_1400, lc)
  let lawy: i64 = wc_lambert(0-WATER_MAGIC_2400, 0-WATER_MAGIC_2500, 0-WATER_MAGIC_1400, lc)
  let lexp: i64 = wgmix(0, lc, MESH_AMBIENT_PERMIL, 1000)
  var ord64: i64 = 1
  if (lsun & 255) <= (lawy & 255) { ord64 = 0 }
  if ((lsun >> 8) & 255) <= ((lawy >> 8) & 255) { ord64 = 0 }
  if ((lsun >> 16) & 255) <= ((lawy >> 16) & 255) { ord64 = 0 }
  if ord64 == 1 { if lawy == lexp { t64 = 1 } }
  vw("T64 figure lambert: sun=" as *u8); vn(lsun)
  vw(" away=" as *u8); vn(lawy)
  vw(" ambient-exact=" as *u8); vn(lexp)
  vw(" (sun strictly brighter per channel AND away == ambient exactly)\n" as *u8)
  if t64 == 1 { pass = pass + 1 }
2747
  // T66 SKIN WRAP-SSS, THE NON-GAMEABLE TRIPLE (pre-integrated-SSS floor, Penner 2011): on one GREY
  // input so any channel difference is the shader's own, not the input's --
  //   (a) FULLY-AWAY EQUALITY: wc_lambert_sss on the sun-opposed normal must equal plain wc_lambert
  //       BIT-EXACTLY (the wrap may not resurrect backlight; same ambient floor, same arithmetic).
  //       A red TINT dies here.
  //   (b) TERMINATOR GAIN, RED-ORDERED: on a normal PERPENDICULAR to the sun (dot==0 by construction)
  //       every channel strictly brighter than plain lambert (which sits at the ambient floor there),
  //       AND red must gain STRICTLY more than blue -- diffusion is red-dominant. A uniform
  //       brightener dies here.
  //   (c) MONOTONE: sun-facing >= terminator >= away per channel -- the wrap cannot invert the sun.
  var t66: i64 = 0
  let sc66: i64 = wpack(200, 200, 200)
  let ssun66: i64 = wc_lambert_sss(WATER_MAGIC_2400, WATER_MAGIC_2500, WATER_MAGIC_1400, sc66)
  let sawy66: i64 = wc_lambert_sss(0-WATER_MAGIC_2400, 0-WATER_MAGIC_2500, 0-WATER_MAGIC_1400, sc66)
  let lawy66: i64 = wc_lambert(0-WATER_MAGIC_2400, 0-WATER_MAGIC_2500, 0-WATER_MAGIC_1400, sc66)
  let sterm66: i64 = wc_lambert_sss(WATER_MAGIC_2500, 0-WATER_MAGIC_2400, 0, sc66)
  let lterm66: i64 = wc_lambert(WATER_MAGIC_2500, 0-WATER_MAGIC_2400, 0, sc66)
  var ok66: i64 = 1
  if sawy66 != lawy66 { ok66 = 0 }
  if (sterm66 & 255) <= (lterm66 & 255) { ok66 = 0 }
  if ((sterm66 >> 8) & 255) <= ((lterm66 >> 8) & 255) { ok66 = 0 }
  if ((sterm66 >> 16) & 255) <= ((lterm66 >> 16) & 255) { ok66 = 0 }
  let gr66: i64 = (sterm66 & 255) - (lterm66 & 255)
  let gb66: i64 = ((sterm66 >> 16) & 255) - ((lterm66 >> 16) & 255)
  if gr66 <= gb66 { ok66 = 0 }
  if (ssun66 & 255) < (sterm66 & 255) { ok66 = 0 }
  if (sterm66 & 255) < (sawy66 & 255) { ok66 = 0 }
  t66 = ok66
  vw("T66 skin wrap-SSS: term-sss=" as *u8); vn(sterm66)
  vw(" term-plain=" as *u8); vn(lterm66)
  vw(" gain r=" as *u8); vn(gr66)
  vw(" b=" as *u8); vn(gb66)
  vw(" away-exact=" as *u8); vn(sawy66)
  vw(" (away==plain exactly, terminator strictly brighter per channel, red gain > blue gain, monotone)\n" as *u8)
  if t66 == 1 { pass = pass + 1 }
2783
  // T67 THE PROJECTION CAPACITY IS A PINNED DERIVED CONSTANT, NOT A GUESS. PROJ_MAXV cannot
  // forward-reference the rig tables (const ordering), so its value is written out once and pinned
  // here, the same discipline as RIG_BYTES/T62. BOTH equalities matter: built-verts==RIG_VERT_TOTAL
  // proves the formula matches the actual construction; PROJ_MAXV==RIG_VERT_TOTAL proves the arena
  // reserves exactly that. A rig that outgrew the reservation would have the projection loop write
  // past O_PROJ with no error at all -- the pmboard zero-byte overflow class, pinned BEFORE it bites.
  var t67: i64 = 0
  let vc67: i64 = sk_hdr(rigp(base59))[1]
  if vc67 == RIG_VERT_TOTAL { if PROJ_MAXV == RIG_VERT_TOTAL { t67 = 1 } }
  vw("T67 proj-capacity pin: built-verts=" as *u8); vn(vc67)
  vw(" RIG_VERT_TOTAL=" as *u8); vn(RIG_VERT_TOTAL)
  vw(" PROJ_MAXV=" as *u8); vn(PROJ_MAXV)
  vw(" (all three must be EQUAL)\n" as *u8)
  if t67 == 1 { pass = pass + 1 }
2798
  // T69 SKIN IS HUMAN BY THE PUBLISHED STANDARD, WITH REAL SPREAD. The four genome skin stops go
  // through nx_skin_ita exactly as the renderer computes them (same hue formula); their L* must be
  // STRICTLY rising and their ITA classes STRICTLY distinct (dark -> very light), and both the
  // darkest and lightest albedo must satisfy the human-skin channel ordering r>g>b that no world
  // palette blue/teal/violet tone can -- the axis the crop referee is structurally blind to
  // (palette/contour/composition are hue-agnostic: a green figure scores like a woman there,
  // which is how "green gumby" shipped through a GREEN board).
  var t69: i64 = 0
  let hu69a: i64 = 0 * SI_GENE_MAX / MG_SKIN_MASK
  let hu69b: i64 = 1 * SI_GENE_MAX / MG_SKIN_MASK
  let hu69c: i64 = 2 * SI_GENE_MAX / MG_SKIN_MASK
  let hu69d: i64 = 3 * SI_GENE_MAX / MG_SKIN_MASK
  let l69a: i64 = si_lstar_of_gene(hu69a, 0)
  let l69b: i64 = si_lstar_of_gene(hu69b, 0)
  let l69c: i64 = si_lstar_of_gene(hu69c, 0)
  let l69d: i64 = si_lstar_of_gene(hu69d, 0)
  let cl69a: i64 = si_class_of_lstar(l69a)
  let cl69d: i64 = si_class_of_lstar(l69d)
  var mono69: i64 = 0
  if l69a < l69b { if l69b < l69c { if l69c < l69d { mono69 = 1 } } }
  var dist69: i64 = 0
  if cl69a > si_class_of_lstar(l69b) { if si_class_of_lstar(l69b) > si_class_of_lstar(l69c) { if si_class_of_lstar(l69c) > cl69d { dist69 = 1 } } }
  let ab69: *i64 = sys_mmap(24) as *i64
  si_albedo_of_gene(hu69a, si_dl_of_region(0), ab69)
  var ord69a: i64 = 0
  if ab69[0] > ab69[1] { if ab69[1] > ab69[2] { ord69a = 1 } }
  si_albedo_of_gene(hu69d, si_dl_of_region(0), ab69)
  var ord69d: i64 = 0
  if ab69[0] > ab69[1] { if ab69[1] > ab69[2] { ord69d = 1 } }
  if mono69 == 1 { if dist69 == 1 { if ord69a == 1 { if ord69d == 1 { t69 = 1 } } } }
  vw("T69 skin human-standard: Lstar milli " as *u8); vn(l69a)
  vw(" < " as *u8); vn(l69b)
  vw(" < " as *u8); vn(l69c)
  vw(" < " as *u8); vn(l69d)
  vw(" ITA-class dark-end=" as *u8); vn(cl69a)
  vw(" light-end=" as *u8); vn(cl69d)
  vw(" r>g>b both ends=" as *u8); vn(ord69a*ord69d)
  vw(" (strictly rising, classes strictly distinct, skin channel order)\n" as *u8)
  if t69 == 1 { pass = pass + 1 }
2838
  // T70 LIMBS ATTACH TO THE BODY. The picture the operator sent showed daylight between arm and
  // torso: SHOULDER_Z 40 against a chest surface at 22+7. The attachment rule is an inequality of
  // the figure's OWN radii -- arm center within touch of the shoulder taper, thigh inside the
  // pelvis footprint -- and the OLD values fail both conjuncts by construction (the bite).
  // ⚠SUBJECT-MATCH CONJUNCT, added after the first fix FAILED IN THE PICTURE while this tooth was
  // GREEN: the width inequality was verified at the shoulder-taper line while the arm bones attached
  // at RIG_NECKTOP -- the head joint, beside the r10 neck. A radius sum proven at a height the arms
  // never touch is an instrument whose subject does not match its claim. RIG_ARM_Y == RIG_SHBASE_Y
  // pins the attach height TO the line the radius is measured at.
  var t70: i64 = 0
  if RIG_SHOULDER_Z <= rig_seg_r1(1) + rig_seg_r0(7) { if RIG_HIP_Z + rig_seg_r0(3) <= rig_seg_r0(0) { if RIG_ARM_Y == RIG_SHBASE_Y { t70 = 1 } } }
  vw("T70 limbs-attach: arm_y=" as *u8); vn(RIG_ARM_Y)
  vw(" ==shoulder-line=" as *u8); vn(RIG_SHBASE_Y)
  vw(" shoulder_z=" as *u8); vn(RIG_SHOULDER_Z)
  vw(" <= chest_top+arm=" as *u8); vn(rig_seg_r1(1) + rig_seg_r0(7))
  vw(" AND hip_z+thigh=" as *u8); vn(RIG_HIP_Z + rig_seg_r0(3))
  vw(" <= hip_r=" as *u8); vn(rig_seg_r0(0))
  vw("\n" as *u8)
  if t70 == 1 { pass = pass + 1 }
2858
  // T71 THE HOURGLASS EXISTS AND ITS RATIO IS PINNED. Waist-to-hip 0.7 EXACT (the published mean
  // the radii were derived from -- at RIG_HU=32 the integer arithmetic lands it exactly, so this
  // is an equality, not a band), waist strictly narrower than bust, neck strictly narrower than
  // the head. A straight tube -- the gumby -- fails every conjunct.
  var t71: i64 = 0
  if RIG_WAIST_R*10 == RIG_HIP_R*7 { if RIG_WAIST_R < RIG_BUST_R { if RIG_NECK_R < RIG_HU/2 { t71 = 1 } } }
  vw("T71 hourglass pin: waist=" as *u8); vn(RIG_WAIST_R)
  vw(" hip=" as *u8); vn(RIG_HIP_R)
  vw(" (10*waist==7*hip) bust=" as *u8); vn(RIG_BUST_R)
  vw(" neck=" as *u8); vn(RIG_NECK_R)
  vw(" head_r=" as *u8); vn(RIG_HU/2)
  vw("\n" as *u8)
  if t71 == 1 { pass = pass + 1 }
2872
  // T60 THE ARENA MUST FIT THE WASM LINEAR MEMORY. This is the tooth that did not exist on
  // 2026-08-14, when raising the render ceiling pushed CRAFT_TOTAL to 22,022,528 against a module
  // memory of 192 pages = 12,582,912 bytes. Every render then wrote 9.4 MB past the end and the
  // browser trapped with "index out of bounds" -- /craft went black in production while all 59
  // teeth here stayed GREEN, because the NATIVE gate mmaps CRAFT_TOTAL and therefore never runs
  // into the wasm bound at all.
  // ★A NATIVE GATE CANNOT FEEL A WASM LIMIT UNLESS IT IS TOLD THE NUMBER. That is the whole reason
  // WASM_PAGE_BYTES/WASM_PAGES are named in the engine: so this comparison can exist.
  var t60: i64 = 0
  if CRAFT_TOTAL <= WASM_MEM_BYTES { t60 = 1 }
  vw("T60 arena vs wasm memory: CRAFT_TOTAL=" as *u8); vn(CRAFT_TOTAL)
  vw(" WASM_MEM_BYTES=" as *u8); vn(WASM_MEM_BYTES)
  vw(" headroom=" as *u8); vn(WASM_MEM_BYTES - CRAFT_TOTAL)
  vw(" (must be >= 0, or the browser traps on the first render)\n" as *u8)
  if t60 == 1 { pass = pass + 1 }
2888
  // T72 W3 SETTLEMENTS EXIST AND ARE BUILT CORRECTLY. A fresh vale arena (the densest
  // settlement identity) must stamp at least one constraint-solved building, and the LAST
  // stamped one -- exported as world truth in S_BLDGX/Y/Z, never re-derived here -- must read
  // structurally from the voxel field: its floor material at the anchor, air at the top wall
  // level inside (furniture only ever occupies dy 1..2), and the roof plate at wall-height+1.
  // A garbage data table cannot pass this by count alone.
  let b72: i64 = sys_mmap(CRAFT_TOTAL + K_MAGIC_4096) as i64
  init_impl_v(b72, 3, K_MAGIC_20260728)
  let s72: *i64 = wst(b72)
  let arch72: i64 = wsp(b72)[P_BLDGSPEC] & 15
  let mats72: i64 = igd_mats(arch72)
  let bh72: i64 = (igd_dims(arch72) >> 16) & 255
  let fl72: i64 = vget(b72, s72[S_BLDGX], s72[S_BLDGY], s72[S_BLDGZ])
  let air72: i64 = vget(b72, s72[S_BLDGX], s72[S_BLDGY] + bh72, s72[S_BLDGZ])
  let rf72: i64 = vget(b72, s72[S_BLDGX], s72[S_BLDGY] + bh72 + 1, s72[S_BLDGZ])
  var t72: i64 = 0
  if s72[S_BLDG] > 0 {
      if fl72 == ((mats72 >> 8) & 255) { if air72 == 0 { if rf72 == ((mats72 >> 16) & 255) { t72 = 1 } } }
  }
  vw("T72 settlements: vale buildings=" as *u8); vn(s72[S_BLDG])
  vw(" probe floor=" as *u8); vn(fl72)
  vw(" interior_air=" as *u8); vn(air72)
  vw(" roof=" as *u8); vn(rf72)
  vw(" (expect floor=" as *u8); vn((mats72 >> 8) & 255)
  vw(" air=0 roof=" as *u8); vn((mats72 >> 16) & 255)
  vw(")\n" as *u8)
  if t72 == 1 { pass = pass + 1 }
2916
  // T73 THE WINDOW SLIDES AND THE WORLD DOES NOT CHANGE. Slide the vale window one stride out
  // and back: every voxel must equal a never-slid arena -- terrain, trees, understory AND the
  // new buildings all regenerate from ABSOLUTE coords, so any window-local dependence in a
  // stamp (the strip-seam bug class) flips at least one block here.
  let b73: i64 = sys_mmap(CRAFT_TOTAL + K_MAGIC_4096) as i64
  init_impl_v(b73, 3, K_MAGIC_20260728)
  wc_shift(b73, SHIFT_STRIDE, 0)
  wc_shift(b73, 0 - SHIFT_STRIDE, 0)
  var diff73: i64 = 0
  let v73a: *u8 = wvx(b72)
  let v73b: *u8 = wvx(b73)
  var i73: i64 = 0
  while i73 < WX*WY*WZ {
      if v73a[i73] != v73b[i73] { diff73 = diff73 + 1 }
      i73 = i73 + 1
  }
  vw("T73 slide-and-return voxel diff=" as *u8); vn(diff73)
  vw(" of " as *u8); vn(WX*WY*WZ)
  vw(" (must be 0: buildings and trees are pure functions of absolute coords)\n" as *u8)
  if diff73 == 0 { pass = pass + 1 }
2937
  // T74 SETTLEMENT DENSITY IS SPEC DATA, both directions: the depths (v1) declare none and
  // must stamp ZERO; craft (v0) declares cottages and must stamp at least one.
  init_impl_v(b73, 1, K_MAGIC_20260728)
  let z74: i64 = wst(b73)[S_BLDG]
  init_impl_v(b73, 0, K_MAGIC_20260728)
  let c74: i64 = wst(b73)[S_BLDG]
  vw("T74 density-as-data: depths_buildings=" as *u8); vn(z74)
  vw(" craft_buildings=" as *u8); vn(c74)
  vw(" (0 and >0 required)\n" as *u8)
  var t74: i64 = 0
  if z74 == 0 { if c74 > 0 { t74 = 1 } }
  if t74 == 1 { pass = pass + 1 }
2950
  // T92 GE57 ARENA GENERATION (2026-09-05): wc_shift bumps S_AGEN by exactly one per call that MOVES. The GPU
  // tiers key their voxel-texture upload on it, so a 16-block re-base can never be drawn against the previous
  // arena (the transport / fall-through the operator reported). init leaves it at 0.
  let b92: i64 = sys_mmap(CRAFT_TOTAL + K_MAGIC_4096) as i64
  init_impl_v(b92, 3, K_MAGIC_20260728)
  let g92a: i64 = wst(b92)[S_AGEN]
  wc_shift(b92, SHIFT_STRIDE, 0)
  let g92b: i64 = wst(b92)[S_AGEN]
  wc_shift(b92, 0, SHIFT_STRIDE)
  let g92c: i64 = wst(b92)[S_AGEN]
  vw("T92 arena_gen after init / shift-x / shift-z = " as *u8); vn(g92a); vw("/" as *u8); vn(g92b); vw("/" as *u8); vn(g92c)
  vw(" (0/1/2 required)\n" as *u8)
  var t92: i64 = 0
  if g92a == 0 { if g92b == 1 { if g92c == 2 { t92 = 1 } } }
  if t92 == 1 { pass = pass + 1 }
  // T93 neg-control: a ZERO shift is not a generation -- wc_shift(b, 0, 0) must leave S_AGEN at 2, so a page
  // keyed on the counter never re-uploads a texture for an arena that did not move.
  wc_shift(b92, 0, 0)
  let g93: i64 = wst(b92)[S_AGEN]
  vw("T93 neg-control arena_gen after a zero shift = " as *u8); vn(g93); vw(" (2 required)\n" as *u8)
  var t93: i64 = 0
  if g93 == 2 { t93 = 1 }
  if t93 == 1 { pass = pass + 1 }
2974
  // T94 GE59 DAY PHASE AS DATA (2026-09-05): P_DAYPHASE (spec idx 39, the other dead hole) is a POST-BOOT slot,
  // so apply2_impl re-bases S_T to it on the next tick, exactly once per distinct value (S_DPAPPLIED remembers).
  let b94: i64 = sys_mmap(CRAFT_TOTAL + K_MAGIC_4096) as i64
  init_impl_v(b94, 3, K_MAGIC_20260728)
  let t94a: i64 = wst(b94)[S_T]
  let t94boot: i64 = wsp(b94)[P_DAYLEN] / 4
  let sp94: *i64 = wsp(b94)
  sp94[P_DAYPHASE] = K_MAGIC_9000
  apply2_impl(b94, 0, 0, 0, 0, 0, 0, 0, 0, 0)
  let t94b: i64 = wst(b94)[S_T]
  apply2_impl(b94, 0, 0, 0, 0, 0, 0, 0, 0, 0)
  let t94c: i64 = wst(b94)[S_T]
  vw("T94 day phase as data: boot/after-poke-tick/next-tick = " as *u8); vn(t94a); vw("/" as *u8); vn(t94b); vw("/" as *u8); vn(t94c)
  vw(" (DAYLEN/4, 9001, 9002 required)\n" as *u8)
  var t94: i64 = 0
  if t94a == t94boot { if t94b == K_MAGIC_9000 + 1 { if t94c == K_MAGIC_9000 + 2 { t94 = 1 } } }
  if t94 == 1 { pass = pass + 1 }
  // T95 neg-control: an UNSET phase (0, the zeroing loop) leaves the DAYLEN/4 boot clock alone -- every
  // world published before this rung ticks exactly as it did.
  let b95: i64 = sys_mmap(CRAFT_TOTAL + K_MAGIC_4096) as i64
  init_impl_v(b95, 3, K_MAGIC_20260728)
  apply2_impl(b95, 0, 0, 0, 0, 0, 0, 0, 0, 0)
  let t95v: i64 = wst(b95)[S_T]
  vw("T95 neg-control unset phase: S_T after one tick = " as *u8); vn(t95v); vw(" (DAYLEN/4 + 1 required)\n" as *u8)
  var t95: i64 = 0
  if t95v == wsp(b95)[P_DAYLEN] / 4 + 1 { t95 = 1 }
  if t95 == 1 { pass = pass + 1 }
3002
  // T75 GE12 GAIT-PHASED VERTICAL LOCOMOTION (gameengine rung mob_step_gait): a DROP accelerates
  // under the player's own gravity and a RISE climbs at the cited stair-ascent rate. Fixture: a flat
  // stone plateau at y=20 with air above (the T30 carve, wider), one girl parked over it, player
  // far away so no meet/pick/protection path fires.
  //   (a) parked ONE BLOCK ABOVE her stand height: per-tick descents must be STRICTLY INCREASING
  //       (9,18,27,... under GRAV) -- the legacy 64-q8/tick ease descends a CONSTANT and is the
  //       neg-control shape this tooth refuses; she must land EXACTLY on the stand height, no
  //       earlier than tick 6 (gravity from rest needs 8 ticks for 256 q8; the glide took 4) and no
  //       later than tick 12, and her O_MOBVY word must read 0 once landed (at rest, not clamped).
  //   (b) parked ONE BLOCK BELOW it (inside the floor): every rise step == WC_STEP_EASE_UP until
  //       the last, landing EXACTLY on the stand height within ceil(256/WC_STEP_EASE_UP) ticks.
  // Values are PRINTED so a failure names the tick, never just a bit.
  let baseG: i64 = sys_mmap(CRAFT_TOTAL + K_MAGIC_4096) as i64
  init_impl(baseG, K_MAGIC_20260728)
  let sG: *i64 = wst(baseG)
  let mG: *i64 = mobp(baseG)
  let hG: i64 = en_nth(mG, 0)
  var pz75: i64 = 55
  while pz75 <= 65 { var px75: i64 = 55
      while px75 <= 65 {
          vset(baseG, px75, 20, pz75, 3)
          var py75: i64 = 21
          while py75 <= 27 { vset(baseG, px75, py75, pz75, 0); py75 = py75 + 1 }
          px75 = px75 + 1 }
      pz75 = pz75 + 1 }
  wc_wmax(baseG)
  sG[S_CX] = 100*256
  sG[S_CZ] = 100*256
  let standG: i64 = 21*256
  let vyp75: *i64 = (baseG + O_MOBVY) as *i64
  en_set(mG, hG, MC_X, 60*256 + 128)
  en_set(mG, hG, MC_Z, 60*256 + 128)
  en_set(mG, hG, MC_Y, standG + 256)                 // (a) one block up, in the air
  vyp75[0] = 0
  var prevG: i64 = standG + 256
  var lastDrop: i64 = 0
  var incOk: i64 = 1
  var landTick: i64 = 0
  var tG: i64 = 0
  vw("T75 drop descents:" as *u8)
  while tG < 12 {
      mob_tick(baseG)
      let yG: i64 = en_get(mG, hG, MC_Y)
      let dG: i64 = prevG - yG
      vw(" " as *u8); vn(dG)
      if landTick == 0 {
          if yG > standG { if dG <= lastDrop { incOk = 0 } lastDrop = dG }
          if yG <= standG { landTick = tG + 1 }
      }
      prevG = yG
      tG = tG + 1
  }
  let restG: i64 = en_get(mG, hG, MC_Y)
  let vyG: i64 = vyp75[0]
  en_set(mG, hG, MC_X, 60*256 + 128)
  en_set(mG, hG, MC_Z, 60*256 + 128)
  en_set(mG, hG, MC_Y, standG - 256)                 // (b) one block DOWN, inside the floor
  vyp75[0] = 0
  var prevR: i64 = standG - 256
  var riseOk: i64 = 1
  var riseTick: i64 = 0
  let riseMax: i64 = (256 + WC_STEP_EASE_UP - 1) / WC_STEP_EASE_UP
  var tR: i64 = 0
  vw(" | rise steps:" as *u8)
  while tR < riseMax + 2 {
      mob_tick(baseG)
      let yR: i64 = en_get(mG, hG, MC_Y)
      let dR: i64 = yR - prevR
      vw(" " as *u8); vn(dR)
      if riseTick == 0 {
          if yR < standG { if dR != WC_STEP_EASE_UP { riseOk = 0 } }
          if yR >= standG { riseTick = tR + 1 }
      }
      prevR = yR
      tR = tR + 1
  }
  let restR: i64 = en_get(mG, hG, MC_Y)
  vw(" | land_tick=" as *u8); vn(landTick); vw(" rest_off=" as *u8); vn(restG - standG)
  vw(" vy_after=" as *u8); vn(vyG); vw(" rise_tick=" as *u8); vn(riseTick)
  vw(" rise_max=" as *u8); vn(riseMax); vw(" rise_rest_off=" as *u8); vn(restR - standG)
  vw(" (drop: strictly-increasing, 6..12 ticks, exact landing, vy 0; rise: ==STEP_EASE_UP, exact)\n" as *u8)
  if incOk == 1 { if landTick >= 6 { if landTick <= 12 { if restG == standG { if vyG == 0 {
      if riseOk == 1 { if riseTick >= 1 { if riseTick <= riseMax { if restR == standG {
          pass = pass + 1 } } } } } } } } }
3087
  // T76 GE13 THE OCEAN IS DATA (gameengine rung wsp_beach_ocean): the shore identity's ocean
  // row produces a real sea -- and ONLY the row does. Arena A = shore, settlements data-zeroed
  // (the T49 GENP lane) so hut stamps cannot blur the inland compare; arena B = SAME identity
  // with the OCEAN row also zeroed through the GENP lane -- the data lever IS the control.
  // Arena C = the shipped shore untouched (settlements + ocean on). Teeth:
  //   (a) A: sampled columns >= 24 seaward are OPEN SEA -- top block is WATER at flood level;
  //   (b) A: the shore band (1..40 seaward) reads water in >= 300 permil of sampled columns
  //       (the named floor the rung's done-rule demands);
  //   (c) B: ZERO water in that same band -- without the row there is no sea;
  //   (d) A vs B voxel-IDENTICAL on sampled inland columns -- the shaping is band-local by
  //       MEASUREMENT, not just by construction;
  //   (e) C: no wood block in any column past the slope -- a hut cannot stand on the sea
  //       (the shaped-height veto in the site solve, proven on the shipped identity).
  let baseOA: i64 = sys_mmap(CRAFT_TOTAL + K_MAGIC_4096) as i64
  let gpOA: *i64 = wgp(baseOA)
  gpOA[0] = GENP_MAGIC
  gpOA[1] = 1
  gpOA[2] = 62
  gpOA[3] = 0
  init_impl_v(baseOA, 2, K_MAGIC_20260728)
  let baseOB: i64 = sys_mmap(CRAFT_TOTAL + K_MAGIC_4096) as i64
  let gpOB: *i64 = wgp(baseOB)
  gpOB[0] = GENP_MAGIC
  gpOB[1] = 2
  gpOB[2] = 62
  gpOB[3] = 0
  gpOB[4] = 66
  gpOB[5] = 0
  init_impl_v(baseOB, 2, K_MAGIC_20260728)
  let baseOC: i64 = sys_mmap(CRAFT_TOTAL + K_MAGIC_4096) as i64
  init_impl_v(baseOC, 2, K_MAGIC_20260728)
  let spOA: *i64 = wsp(baseOA)
  let wlO: i64 = spOA[P_WATER]
  let slopeO: i64 = (spOA[P_OCEAN] >> 12) & 63
  var seaOk76: i64 = 1
  var bandCols76: i64 = 0
  var bandWet76: i64 = 0
  var bandWetB76: i64 = 0
  var inlandSame76: i64 = 1
  var seaWood76: i64 = 0
  var zO: i64 = 0
  while zO < WZ {
      var xO: i64 = 0
      while xO < WX {
          let dO: i64 = wsp_ocean_d(spOA, xO, zO)
          if dO >= 24 {
              var yT: i64 = WY - 1
              var topB: i64 = 0 - 1
              var topY: i64 = 0 - 1
              while yT >= 0 {
                  if topY < 0 { if vget(baseOA, xO, yT, zO) != 0 { topY = yT; topB = vget(baseOA, xO, yT, zO) } }
                  yT = yT - 1
              }
              if topB != 4 { seaOk76 = 0 }
              if topY != wlO { seaOk76 = 0 }
          }
          if dO >= 1 { if dO <= 40 {
              bandCols76 = bandCols76 + 1
              var wet9: i64 = 0
              var wetB9: i64 = 0
              var yB: i64 = 0
              while yB < WY {
                  if vget(baseOA, xO, yB, zO) == 4 { wet9 = 1 }
                  if vget(baseOB, xO, yB, zO) == 4 { wetB9 = 1 }
                  yB = yB + 1
              }
              bandWet76 = bandWet76 + wet9
              bandWetB76 = bandWetB76 + wetB9
          } }
          if dO <= 0 { if (xO % 8) == 0 { if (zO % 8) == 0 {
              var yI: i64 = 0
              while yI < WY {
                  if vget(baseOA, xO, yI, zO) != vget(baseOB, xO, yI, zO) { inlandSame76 = 0 }
                  yI = yI + 1
              }
          } } }
          if dO >= slopeO {
              var yW: i64 = 0
              while yW < WY {
                  if vget(baseOC, xO, yW, zO) == 6 { seaWood76 = seaWood76 + 1 }
                  yW = yW + 1
              }
          }
          xO = xO + 4
      }
      zO = zO + 4
  }
  var wetPermil76: i64 = 0
  if bandCols76 > 0 { wetPermil76 = bandWet76*1000/bandCols76 }
  vw("T76 ocean: band-cols=" as *u8); vn(bandCols76)
  vw(" wet-permil=" as *u8); vn(wetPermil76)
  vw(" control-wet=" as *u8); vn(bandWetB76)
  vw(" open-sea-ok=" as *u8); vn(seaOk76)
  vw(" inland-identical=" as *u8); vn(inlandSame76)
  vw(" sea-wood=" as *u8); vn(seaWood76)
  vw(" (floor 300 permil; control 0; sea-wood 0)\n" as *u8)
  if bandCols76 > 0 { if wetPermil76 >= 300 { if bandWetB76 == 0 { if seaOk76 == 1 {
      if inlandSame76 == 1 { if seaWood76 == 0 { pass = pass + 1 } } } } } }
3186
  // T77 GE13 PER-WORLD OUTFIT FLAGS: the world's outfit flag round-trips and FORCES -- mode 3
  // (nude beach) bares every girl, mode 2 (swimwear-only) covers every girl with the dimension
  // still declared; the incumbent mode 1 keeps the bred mix T49 already proves (its kinds>=2
  // is this tooth's variety control, unduplicated).
  let baseOF: i64 = sys_mmap(CRAFT_TOTAL + K_MAGIC_4096) as i64
  init_impl_v(baseOF, 2, K_MAGIC_20260728)
  let spOF: *i64 = wsp(baseOF)
  let mOF: *i64 = mobp(baseOF)
  spOF[P_OUTFIT] = 3
  var nude77: i64 = 1
  var k77: i64 = 0
  while k77 < en_count(mOF) { if mob_outfit(baseOF, k77) != 2 { nude77 = 0 } k77 = k77 + 1 }
  spOF[P_OUTFIT] = 2
  var swim77: i64 = 1
  var k77b: i64 = 0
  while k77b < en_count(mOF) { if mob_outfit(baseOF, k77b) != 0 { swim77 = 0 } k77b = k77b + 1 }
  let rt77: i64 = spOF[P_OUTFIT]
  vw("T77 outfit flags: all-nude(md3)=" as *u8); vn(nude77)
  vw(" all-swim(md2)=" as *u8); vn(swim77)
  vw(" roundtrip=" as *u8); vn(rt77); vw(" (1,1,2 required)\n" as *u8)
  if nude77 == 1 { if swim77 == 1 { if rt77 == 2 { pass = pass + 1 } } }
3208
  // T78 GE12b BODY CLEARANCE: a girl's BODY may never overlap a solid, not merely her cell
  // centre. Fixture: the shore identity (flat, treeless), a plateau carved at y=20 across
  // 55..65, and a WALL running the whole z-span at cell x=59 -- so 'west of her is stone' is
  // true wherever she wanders in the pen. She is parked at x-cell 60 with fraction 10, i.e.
  // her centre is legal (her own column is air, mob_fits is satisfied) while her body
  // overlaps the wall by MOB_R_Q8-10 q8. Player far away so no meet/pick/curiosity path runs.
  // Three teeth, and the third is the anti-vacuity one:
  //   (a) DETERMINISTIC PUSH-OUT: after ONE tick her fraction must be >= MOB_R_Q8 (before
  //       GE12b it stayed at 10 -- that is the mutant's signature and the operator's frame);
  //   (b) INVARIANT OVER TIME: across 40 further ticks, every sample taken while she is in
  //       the wall-adjacent cell must clear the face; violations must be ZERO;
  //   (c) THE FIXTURE MUST HAVE BEEN REACHED: those samples must NUMBER AT LEAST ONE. A girl
  //       who wandered out of the adjacent cell would satisfy (b) vacuously, and a tooth that
  //       passes because nothing was examined is not a tooth.
  let baseCL: i64 = sys_mmap(CRAFT_TOTAL + K_MAGIC_4096) as i64
  init_impl_v(baseCL, 2, K_MAGIC_20260728)
  let sCL: *i64 = wst(baseCL)
  let mCL: *i64 = mobp(baseCL)
  let hCL: i64 = en_nth(mCL, 0)
  var pz78: i64 = 55
  while pz78 <= 65 { var px78: i64 = 55
      while px78 <= 65 {
          vset(baseCL, px78, 20, pz78, 3)
          var py78: i64 = 21
          while py78 <= 27 { vset(baseCL, px78, py78, pz78, 0); py78 = py78 + 1 }
          px78 = px78 + 1 }
      pz78 = pz78 + 1 }
  var wz78: i64 = 55
  while wz78 <= 65 {
      vset(baseCL, 59, 21, wz78, 3)
      vset(baseCL, 59, 22, wz78, 3)
      wz78 = wz78 + 1
  }
  wc_wmax(baseCL)
  sCL[S_CX] = 100*256
  sCL[S_CZ] = 100*256
  en_set(mCL, hCL, MC_X, 60*256 + 10)
  en_set(mCL, hCL, MC_Y, 21*256)
  en_set(mCL, hCL, MC_Z, 60*256 + 128)
  let x78_before: i64 = en_get(mCL, hCL, MC_X)
  let z78_before: i64 = en_get(mCL, hCL, MC_Z)
  let g78_before: i64 = mob_ground(baseCL, x78_before >> 8, (en_get(mCL, hCL, MC_Y) >> 8) + 1, z78_before >> 8)
  let solid78_before: i64 = mob_solid2(baseCL, (x78_before >> 8) - 1, g78_before, z78_before >> 8)
  let clamped78_before: i64 = mob_clear_x(baseCL, x78_before, z78_before, g78_before)
  let ng78_before: i64 = wc_contact_floor_q(baseCL, x78_before, z78_before, (en_get(mCL, hCL, MC_Y) >> 8) + 1)
  let fit78_before: i64 = mob_fits(baseCL, clamped78_before >> 8, g78_before, z78_before >> 8)
  mob_tick(baseCL)
  let x78: i64 = en_get(mCL, hCL, MC_X)
  let c78: i64 = x78 >> 8
  var f78: i64 = x78 - c78*256
  var push78: i64 = 0
  if c78 > 60 { push78 = 1 }
  if c78 == 60 { if f78 >= MOB_R_Q8 { push78 = 1 } }
  var samp78: i64 = 0
  var viol78: i64 = 0
  var t78: i64 = 0
  while t78 < 40 {
      mob_tick(baseCL)
      let xx: i64 = en_get(mCL, hCL, MC_X)
      let cc: i64 = xx >> 8
      if cc == 60 {
          samp78 = samp78 + 1
          let ysample78: i64 = (en_get(mCL, hCL, MC_Y) >> 8) - 1
          if xx - cc*256 < MOB_R_Q8 {
              if mob_solid2(baseCL, cc - 1, ysample78, en_get(mCL, hCL, MC_Z) >> 8) == 1 {
                  viol78 = viol78 + 1
              }
          }
      }
      t78 = t78 + 1
  }
  vw("T78 diagnostics before: x=" as *u8); vn(x78_before); vw(" z=" as *u8); vn(z78_before); vw(" ground=" as *u8); vn(g78_before); vw(" wall-solid=" as *u8); vn(solid78_before); vw(" clamped-x=" as *u8); vn(clamped78_before); vw(" ng=" as *u8); vn(ng78_before); vw(" fit=" as *u8); vn(fit78_before); vw("\n" as *u8)
  vw("T78 clearance: first-tick frac=" as *u8); vn(f78)
  vw(" cell=" as *u8); vn(c78)
  vw(" pushed=" as *u8); vn(push78)
  vw(" adjacent-samples=" as *u8); vn(samp78)
  vw(" violations=" as *u8); vn(viol78)
  vw(" (radius " as *u8); vn(MOB_R_Q8)
  vw(" q8; pushed=1, violations=0, samples>=1 required)\n" as *u8)
  if push78 == 1 { if viol78 == 0 { if samp78 >= 1 { pass = pass + 1 } } }
3289
  // T79 GE14a THE STAGED PIPELINE UNDER THE LIVE ENGINE (rung wc_worldpipe_bind). The ground
  // stops being this engine's two octaves of value noise and becomes nx_worldpipe_core's
  // six-parameter staged space (continentalness -> spline, ridged relief scaled by weirdness
  // and flattened by erosion). Three legs, and NONE of them is 'the OFF path is unchanged':
  // that is already proven by every tooth above this one still passing, since they all
  // generate with P_WPIPE unset -- a fresh tooth asserting it would be a second ruler for a
  // thing already measured, and it would pass for free.
  //   (a) CAUSALITY: bind ON must produce DIFFERENT ground from bind OFF at the same seed and
  //       identity. A bind that changes nothing is a bind that is not wired.
  //   (b) NON-DEGENERACY: the ON world must USE its vertical band -- height spread at least
  //       T79_SPREAD_MIN blocks, and fewer than T79_CLAMP_MAX permil of sampled columns pinned
  //       at either clamp rail. This is what makes the recipe's divisor a MEASURED choice
  //       rather than a tasted one: a divisor that flattens the world or rails it fails here.
  //   (c) DETERMINISM: same seed, same rows, twice -> identical ground, the property every
  //       other world in this engine is held to.
  let baseP1: i64 = sys_mmap(CRAFT_TOTAL + K_MAGIC_4096) as i64
  init_impl_v(baseP1, 3, K_MAGIC_20260728)
  let baseP2: i64 = sys_mmap(CRAFT_TOTAL + K_MAGIC_4096) as i64
  let gpP2: *i64 = wgp(baseP2)
  gpP2[0] = GENP_MAGIC
  gpP2[1] = 2
  gpP2[2] = 67
  gpP2[3] = T79_DIV
  gpP2[4] = 68
  gpP2[5] = T79_SCALE
  init_impl_v(baseP2, 3, K_MAGIC_20260728)
  let baseP3: i64 = sys_mmap(CRAFT_TOTAL + K_MAGIC_4096) as i64
  let gpP3: *i64 = wgp(baseP3)
  gpP3[0] = GENP_MAGIC
  gpP3[1] = 2
  gpP3[2] = 67
  gpP3[3] = T79_DIV
  gpP3[4] = 68
  gpP3[5] = T79_SCALE
  init_impl_v(baseP3, 3, K_MAGIC_20260728)
  var diff79: i64 = 0
  var det79: i64 = 0
  var hmin79: i64 = WY
  var hmax79: i64 = 0
  var cols79: i64 = 0
  var rail79: i64 = 0
  var z79: i64 = 0
  while z79 < WZ {
      var x79: i64 = 0
      while x79 < WX {
          var yt: i64 = WY - 1
          var t1: i64 = 0 - 1
          var t2: i64 = 0 - 1
          var t3: i64 = 0 - 1
          while yt >= 0 {
              if t1 < 0 { if vget(baseP1, x79, yt, z79) != 0 { t1 = yt } }
              if t2 < 0 { if vget(baseP2, x79, yt, z79) != 0 { t2 = yt } }
              if t3 < 0 { if vget(baseP3, x79, yt, z79) != 0 { t3 = yt } }
              yt = yt - 1
          }
          if t1 != t2 { diff79 = diff79 + 1 }
          if t2 != t3 { det79 = det79 + 1 }
          if t2 >= 0 {
              cols79 = cols79 + 1
              if t2 < hmin79 { hmin79 = t2 }
              if t2 > hmax79 { hmax79 = t2 }
              if t2 <= 1 { rail79 = rail79 + 1 }
              if t2 >= WY - 8 { rail79 = rail79 + 1 }
          }
          x79 = x79 + 2
      }
      z79 = z79 + 2
  }
  var railp79: i64 = 0
  if cols79 > 0 { railp79 = rail79*1000/cols79 }
  let spread79: i64 = hmax79 - hmin79
  vw("T79 staged bind: divisor=" as *u8); vn(T79_DIV)
  vw(" scale=" as *u8); vn(T79_SCALE)
  vw(" columns-changed=" as *u8); vn(diff79)
  vw(" nondeterministic=" as *u8); vn(det79)
  vw(" surface=" as *u8); vn(hmin79)
  vw(".." as *u8); vn(hmax79)
  vw(" spread=" as *u8); vn(spread79)
  vw(" railed-permil=" as *u8); vn(railp79)
  vw(" of " as *u8); vn(cols79)
  vw(" cols (need changed>0, nondet=0, spread>=" as *u8); vn(T79_SPREAD_MIN)
  vw(", railed<" as *u8); vn(T79_CLAMP_MAX)
  vw(")\n" as *u8)
  if diff79 > 0 { if det79 == 0 { if spread79 >= T79_SPREAD_MIN { if railp79 < T79_CLAMP_MAX {
      if cols79 > 0 { pass = pass + 1 } } } } }
3375
  // ================= GAIT TEETH (T80-T83) =========================================================
  // SUBJECT: the parametric gait drive in nx_wasm_craft -- wc_hdg_step, wc_mob_sph and the five
  // wc_gp_* pose functions. Those five were EXTRACTED out of wc_mob_mesh precisely so these teeth
  // could call the SHIPPING code rather than recompute the same formula, which would test a copy
  // of the mechanism and go on passing forever after the real one changed.
  // EVERY BAR BELOW IS A knowledge/gamefeel_oracle.conf gait_* ROW, reached through the engine
  // constant that carries it. There is no literal joint angle anywhere in these teeth.
  let baseG: i64 = sys_mmap(CRAFT_TOTAL + K_MAGIC_4096) as i64
  init_impl_v(baseG, 3, K_MAGIC_20260728)
  let mG: *i64 = mobp(baseG)
  let sG: *i64 = wst(baseG)
  let ndG: *i64 = (baseG + O_NEED) as *i64
  let auxG: *i64 = (baseG + O_MOBAUX) as *i64
3389
  // ---- T80: THE STRIDE PHASE IS DRIVEN BY DISTANCE WALKED, NOT BY A FREE-RUNNING CLOCK ---------
  // THE DEFECT THIS BITES: the renderer took (MC_PH*9), and MC_PH advances +5 every tick forever
  // whether or not she moved. A standing girl kept swinging her legs, and a walking girl cycled at
  // a rate unrelated to her speed, so her feet skated over the ground.
  // THE DISCRIMINATOR IS A RATE, NOT A VALUE, and that distinction is the whole tooth: MC_PH is
  // SEEDED PER GIRL at spawn, so two girls differ in it from tick zero, and a bare "their phases
  // differ" test would pass on the OLD drive too -- it would be measuring the spawn seed and
  // calling it gait. What actually separates the two drives is how the difference EVOLVES: a
  // distance-driven phase pulls apart as the girls walk different distances, while a shared
  // free-running clock holds its difference exactly constant forever. So the tooth samples the
  // pair TWICE and compares the change.
  var t80: i64 = 0
  while t80 < 200 { mob_tick(baseG); t80 = t80 + 1 }
  var loK: i64 = 0 - 1
  var hiK: i64 = 0 - 1
  var loD: i64 = 0
  var hiD: i64 = 0
  var seen80: i64 = 0
  var k80: i64 = 0
  while k80 < en_count(mG) {
      if en_nth(mG, k80) > 0 {
          let d80: i64 = ndG[k80*4 + WC_NEED_GAIT]
          if seen80 == 0 { loD = d80; hiD = d80; loK = k80; hiK = k80; seen80 = 1 }
          if d80 < loD { loD = d80; loK = k80 }
          if d80 > hiD { hiD = d80; hiK = k80 }
      }
      k80 = k80 + 1
  }
  var gapA: i64 = 0
  var phGapA: i64 = 0
  if seen80 == 1 {
      gapA = hiD - loD
      phGapA = en_get(mG, en_nth(mG, hiK), MC_PH) - en_get(mG, en_nth(mG, loK), MC_PH)
  }
  var t80b: i64 = 0
  while t80b < 200 { mob_tick(baseG); t80b = t80b + 1 }
  var gapB: i64 = 0
  var phGapB: i64 = 0
  if seen80 == 1 {
      gapB = ndG[hiK*4 + WC_NEED_GAIT] - ndG[loK*4 + WC_NEED_GAIT]
      phGapB = en_get(mG, en_nth(mG, hiK), MC_PH) - en_get(mG, en_nth(mG, loK), MC_PH)
  }
  var reach80: i64 = 0
  if seen80 == 1 { if gapA > 0 { reach80 = 1 } }
  var grew80: i64 = 0
  if gapB > gapA { grew80 = 1 }
  var clock80: i64 = 0
  if phGapB == phGapA { clock80 = 1 }
  var differ80: i64 = 0
  if seen80 == 1 { if wc_mob_sph(baseG, hiK) != wc_mob_sph(baseG, loK) { differ80 = 1 } }
  vw("T80 stride-phase-is-distance: gap-at-200=" as *u8); vn(gapA)
  vw(" gap-at-400=" as *u8); vn(gapB)
  vw(" fixture-reached-differential-travel=" as *u8); vn(reach80)
  vw(" distance-gap-grew=" as *u8); vn(grew80)
  vw(" phases-differ=" as *u8); vn(differ80)
  vw(" neg-control-freerunning-clock-gap-is-CONSTANT=" as *u8); vn(clock80)
  vw(" (all four required; the neg-control is exactly what the old drive read)\n" as *u8)
  if reach80 == 1 { if grew80 == 1 { if differ80 == 1 { if clock80 == 1 { pass = pass + 1 } } } }
3448
  // ---- T81: THE BODY FACES WHERE SHE IS GOING, AND THE GIRLS DO NOT ALL FACE ONE WAY -----------
  // THE DEFECT THIS BITES: the rig root yaw was s[S_YAW] -- the PLAYER camera yaw -- so every girl
  // in the world pivoted together whenever the player looked around, and each one crabbed sideways
  // whenever her path and the camera disagreed. A billboard reflex left inside a skinned mesh.
  // The load-bearing conjunct is DISTINCTNESS: a camera-derived facing is identical for every girl
  // BY CONSTRUCTION, so "two girls face different ways" is precisely the property the defect cannot
  // produce, and the control below DEMONSTRATES that rather than asserting it.
  // SAMPLED ACROSS TICKS, NOT AT ONE INSTANT, AND THAT WAS A REAL BUG IN THIS TOOTH FIRST DRAFT:
  // read once after the T80 loop it came back moving=0, because every girl happened to be standing
  // on that one tick (the SOCIALIZE state parks them together), and the tooth went RED on an
  // unreached fixture. It was RIGHT to. A pass over an empty population is the vacuous-tooth
  // defect, and the fix is a bigger sample, never a lower bar.
  // THE BAR IS THE CONTROL, WHICH IS WHY THERE IS NO THRESHOLD HERE. Strict alignment on every
  // sample would be WRONG to demand: the heading is deliberately rate-limited, so it LAGS a change
  // of intent, and a girl who has just turned is legitimately misaligned for a few ticks. Any
  // percentage bar would be a number picked after seeing the answer. Instead the same alignment is
  // scored a second time using the CAMERA yaw -- exactly what the old code fed the rig -- and ours
  // must beat it. The claim is then the one actually worth making: her own heading predicts her
  // travel direction better than the player camera does.
  var algn81: i64 = 0
  var algnCam81: i64 = 0
  var moved81: i64 = 0
  var distinct81: i64 = 0
  var firstH: i64 = 0
  var seenH: i64 = 0
  var t81: i64 = 0
  while t81 < 120 {
      mob_tick(baseG)
      var k81: i64 = 0
      while k81 < en_count(mG) {
          if en_nth(mG, k81) > 0 {
              let hh: i64 = wc_hdg_of(baseG, k81)
              if seenH == 0 { firstH = hh; seenH = 1 }
              if hh != firstH { distinct81 = 1 }
              let sx: i64 = auxG[k81*3]
              let sz: i64 = auxG[k81*3 + 1]
              var mv: i64 = 0
              if sx != 0 { mv = 1 }
              if sz != 0 { mv = 1 }
              if mv == 1 {
                  moved81 = moved81 + 1
                  if it_sin4096(hh)*sx + it_cos4096(hh)*sz > 0 { algn81 = algn81 + 1 }
                  let cy81: i64 = sG[S_YAW]
                  if it_sin4096(cy81)*sx + it_cos4096(cy81)*sz > 0 { algnCam81 = algnCam81 + 1 }
              }
          }
          k81 = k81 + 1
      }
      t81 = t81 + 1
  }
  // NEGATIVE CONTROL, AND A REAL ONE: run the SAME distinctness measure over the yaw the OLD code
  // used -- every girl takes s[S_YAW] -- and require it to come back 0. The tooth therefore shows
  // its discriminator is able to report both answers, instead of only ever reporting the one that
  // happens to be wanted.
  var oldDistinct81: i64 = 0
  var firstOld: i64 = 0
  var seenOld: i64 = 0
  var k81c: i64 = 0
  while k81c < en_count(mG) {
      if en_nth(mG, k81c) > 0 {
          let oy: i64 = sG[S_YAW]
          if seenOld == 0 { firstOld = oy; seenOld = 1 }
          if oy != firstOld { oldDistinct81 = 1 }
      }
      k81c = k81c + 1
  }
  vw("T81 facing-is-hers: moving-samples=" as *u8); vn(moved81)
  vw(" aligned-using-her-own-heading=" as *u8); vn(algn81)
  vw(" aligned-using-the-CAMERA-yaw=" as *u8); vn(algnCam81)
  vw(" headings-not-all-identical=" as *u8); vn(distinct81)
  vw(" neg-control-camera-derived-yaw-is-identical-for-all=" as *u8); vn(oldDistinct81)
  vw(" (need moving>0, her-heading beats the camera, distinct=1, neg-control=0)\n" as *u8)
  if moved81 > 0 { if algn81 > algnCam81 { if distinct81 == 1 { if oldDistinct81 == 0 { pass = pass + 1 } } } }
3522
  // ---- T82: FLUIDITY IS TWO-SIDED -- RATE-LIMITED AND STILL CONVERGENT ------------------------
  // The operator requirement is an absence of BOTH locked/rigid and flaccid/hypotonic motion. That
  // is a damping specification with TWO failure modes, so a one-sided tooth proves nothing here: a
  // controller that snaps instantly passes any convergence test, and a controller with no gain at
  // all passes any rate-limit test. BOTH directions are asserted, against the same fixture.
  //   RIGID  -> some single tick exceeds the turn allowance.  Caught by ticks-over-allowance.
  //   FLOPPY -> the heading never arrives at all.             Caught by converged.
  // The fixture is the hardest case a walking body can be handed, a full half-turn reversal, and
  // that it really IS a half turn is asserted BEFORE the outcome rather than assumed.
  let dxT: i64 = 0
  let dzT: i64 = 0 - 4
  let magT: i64 = 4
  let mxT: i64 = magT*WC_TURN_PER_STRIDE/WC_STRIDE_Q8
  var h82: i64 = 0
  var err0: i64 = wc_angwrap(IT_PI - h82)
  if err0 < 0 { err0 = 0 - err0 }
  var over82: i64 = 0
  var conv82: i64 = 0
  var steps82: i64 = 0
  // THE LOOP CEILING IS DERIVED, AND DELIBERATELY NOT BINDING. A half turn at the full
  // allowance costs IT_PI/mxT ticks of turning, and the proportional approach adds a tail on
  // top of that. The ceiling is eight half-turns worth, so this tooth measures whether the
  // controller CONVERGES rather than whether it converges inside a number somebody chose, and
  // the ticks actually taken are printed beside it so the margin is visible instead of assumed.
  // At a flat 400 it WAS binding: the run needs about 380 ticks and the integer truncation
  // tail landed it exactly on the boundary, so the tooth was reporting the budget and calling
  // it the mechanism.
  let budget82: i64 = IT_PI*8/mxT
  var i82: i64 = 0
  while i82 < budget82 {
      let hprev: i64 = h82
      h82 = wc_hdg_step(h82, dxT, dzT)
      var d82: i64 = wc_angwrap(h82 - hprev)
      if d82 < 0 { d82 = 0 - d82 }
      if d82 > mxT { over82 = over82 + 1 }
      var e82: i64 = wc_angwrap(IT_PI - h82)
      if e82 < 0 { e82 = 0 - e82 }
      if conv82 == 0 { if e82 <= mxT { conv82 = 1; steps82 = i82 + 1 } }
      i82 = i82 + 1
  }
  var still82: i64 = 0
  // The probe heading is IT_PI/3 deliberately: an angle that is NOT a multiple of a quarter
  // turn, so this identity cannot hold through some symmetry of sin or cos instead of through
  // the guard actually returning early. It was an arbitrary 1234 at first and the
  // magic-number ratchet refused the build over it, correctly -- an arbitrary probe value is
  // a number with no reason attached, and the fix is a reason, not a const named after it.
  if wc_hdg_step(IT_PI/3, 0, 0) == IT_PI/3 { still82 = 1 }
  var reach82: i64 = 0
  if err0 >= IT_PI - mxT { reach82 = 1 }
  vw("T82 fluidity: allowance-per-tick=" as *u8); vn(mxT)
  vw(" start-error=" as *u8); vn(err0)
  vw(" fixture-is-a-half-turn=" as *u8); vn(reach82)
  vw(" ticks-over-allowance=" as *u8); vn(over82)
  vw(" converged=" as *u8); vn(conv82)
  vw(" in-ticks=" as *u8); vn(steps82)
  vw(" of-budget=" as *u8); vn(budget82)
  vw(" zero-intent-zero-turn=" as *u8); vn(still82)
  vw(" (a RIGID drive fails ticks-over-allowance, a FLOPPY one fails converged -- both required)\n" as *u8)
  if reach82 == 1 { if over82 == 0 { if conv82 == 1 { if still82 == 1 { pass = pass + 1 } } } }
3582
  // ---- T83: THE TRANSVERSE-PLANE GAIT IS PRESENT, CITED, AND IN OPPOSITION --------------------
  // THE DEFECT THIS BITES: the pelvis bone and the chest bone were never posed at all, and neither
  // were the two forearm bones. No pelvic rotation, no spinal counter-rotation and no elbow -- the
  // arms swung dead straight from the shoulder, which is the stiff-arm report restated as geometry.
  // rRoM is a RANGE, so the excursion over a full cycle must come back AS the published range, and
  // that is what makes these bars the conf rows rather than a taste.
  // ANTI-VACUITY: an implementation that simply MIRRORED the pelvis into the chest would satisfy
  // the opposition test on its own. The thorax-exceeds-pelvis conjunct refuses it, and that is not
  // an arbitrary bar either -- it is the cited paper headline finding, that T7/T8 carry the largest
  // rotary amplitude of any vertebra C7..L4 and the pelvis does not.
  var pmin: i64 = wc_gp_pelvis(0)
  var pmax: i64 = pmin
  var tmin: i64 = wc_gp_thorax(0)
  var tmax: i64 = tmin
  var emin: i64 = wc_gp_elbow(0)
  var emax: i64 = emin
  var opp83: i64 = 1
  var both83: i64 = 0
  var i83: i64 = 0
  while i83 < 64 {
      let ph83: i64 = i83*2*IT_PI/64
      let pv: i64 = wc_gp_pelvis(ph83)
      let tv: i64 = wc_gp_thorax(ph83)
      let ev: i64 = wc_gp_elbow(ph83)
      if pv < pmin { pmin = pv }
      if pv > pmax { pmax = pv }
      if tv < tmin { tmin = tv }
      if tv > tmax { tmax = tv }
      if ev < emin { emin = ev }
      if ev > emax { emax = ev }
      // the chest bone LOCAL yaw is -(pv+tv), so its WORLD yaw is -tv. Opposition therefore means
      // pv and tv carry the SAME sign: the pelvis turns +pv while the chest turns -tv against it.
      if pv > 0 { if tv < 0 { opp83 = 0 } }
      if pv < 0 { if tv > 0 { opp83 = 0 } }
      if pv != 0 { if tv != 0 { both83 = 1 } }
      i83 = i83 + 1
  }
  let pexc: i64 = pmax - pmin
  let texc: i64 = tmax - tmin
  let eexc: i64 = emax - emin
  let pwant: i64 = wc_ddeg(WC_PELVIS_ROT_DDEG)
  let twant: i64 = wc_ddeg(WC_THORAX_ROT_DDEG)
  let ewant: i64 = wc_ddeg(WC_ELBOW_ROM_DDEG)
  var pok: i64 = 0
  var tok: i64 = 0
  var eok: i64 = 0
  if pexc*1000 >= pwant*900 { if pexc <= pwant { pok = 1 } }
  if texc*1000 >= twant*900 { if texc <= twant { tok = 1 } }
  if eexc*1000 >= ewant*900 { if eexc <= ewant { eok = 1 } }
  var enohyper: i64 = 0
  if emin == 0 { enohyper = 1 }
  var thoraxLeads: i64 = 0
  if texc > pexc { thoraxLeads = 1 }
  vw("T83 transverse gait: pelvis-excursion=" as *u8); vn(pexc)
  vw(" of cited " as *u8); vn(pwant)
  vw(" thorax-excursion=" as *u8); vn(texc)
  vw(" of cited " as *u8); vn(twant)
  vw(" elbow-excursion=" as *u8); vn(eexc)
  vw(" of cited " as *u8); vn(ewant)
  vw(" opposition=" as *u8); vn(opp83)
  vw(" both-nonzero-somewhere=" as *u8); vn(both83)
  vw(" elbow-never-hyperextends=" as *u8); vn(enohyper)
  vw(" anti-vacuity-thorax-exceeds-pelvis=" as *u8); vn(thoraxLeads)
  vw(" (each excursion must reach 900 permil of its cited range and never exceed it)\n" as *u8)
  if pok == 1 { if tok == 1 { if eok == 1 { if opp83 == 1 { if both83 == 1 { if enohyper == 1 {
      if thoraxLeads == 1 { pass = pass + 1 } } } } } } }
3649
  // ================= WARDROBE TEETH (T84-T87) =====================================================
  // SUBJECT: GE13b, the clothing system as DATA -- gar_row / wc_outfit / mob_outfit in nx_wasm_craft.
  // THE DEFECT THESE BITE: SWIMWEAR-ONLY (P_OUTFIT=2) rendered identically to a clothed village,
  // because no swimwear garment existed anywhere -- the 3-value outfit WAS the wardrobe, and a
  // beach world had nothing to dress a girl in but the one dress.
3655
  // ---- T84: A SWIMWEAR BEACH DRESSES EVERY GIRL IN SWIMWEAR, AND ONLY SWIMWEAR ------------------
  // BOUND TO THE CAST: swim lowers worn must EQUAL the cast size (every girl wears a beach-swim
  // garment below), zero garments of any other category at boot, and after 300 ticks of life (the
  // life budget T80 samples over) still nothing outside beach-swim/beach-cover. ANTI-VACUITY: the
  // table must actually be consulted -- at least two distinct lower ids across the cast (bit 18
  // splits bikini from one-piece), so a selector returning one constant id cannot pass.
  let baseGar: i64 = sys_mmap(CRAFT_TOTAL + K_MAGIC_4096) as i64
  init_impl_v(baseGar, 2, K_MAGIC_20260728)
  let spGar: *i64 = wsp(baseGar)
  let mGar: *i64 = mobp(baseGar)
  spGar[P_OUTFIT] = 2
  let castGar: i64 = en_count(mGar)
  var swimLow84: i64 = 0
  var other84: i64 = 0
  var lowSeen84: i64 = 0
  var k84: i64 = 0
  while k84 < castGar {
      let o84: i64 = wc_outfit(baseGar, k84)
      let lo84: i64 = o84 & GAR_ID_MASK
      let up84: i64 = o84 >> GAR_SLOT_SH
      if lo84 > 0 {
          if gar_cat(gar_row(baseGar, lo84)) == GAR_CAT_SWIM { swimLow84 = swimLow84 + 1 }
          if gar_cat(gar_row(baseGar, lo84)) != GAR_CAT_SWIM { other84 = other84 + 1 }
          lowSeen84 = lowSeen84 | (1 << lo84)
      }
      if up84 > 0 { if gar_cat(gar_row(baseGar, up84)) != GAR_CAT_SWIM { other84 = other84 + 1 } }
      k84 = k84 + 1
  }
  var lowKinds84: i64 = 0
  var b84: i64 = 0
  while b84 <= GAR_N { if ((lowSeen84 >> b84) & 1) == 1 { lowKinds84 = lowKinds84 + 1 } b84 = b84 + 1 }
  var t84: i64 = 0
  while t84 < 300 { mob_tick(baseGar); t84 = t84 + 1 }
  var worn84: i64 = 0
  var offBeach84: i64 = 0
  var k84b: i64 = 0
  while k84b < castGar {
      let o84b: i64 = wc_outfit(baseGar, k84b)
      let lo84b: i64 = o84b & GAR_ID_MASK
      let up84b: i64 = o84b >> GAR_SLOT_SH
      if lo84b > 0 { worn84 = worn84 + 1; if gar_cat(gar_row(baseGar, lo84b)) > GAR_CAT_COVER { offBeach84 = offBeach84 + 1 } }
      if up84b > 0 { worn84 = worn84 + 1; if gar_cat(gar_row(baseGar, up84b)) > GAR_CAT_COVER { offBeach84 = offBeach84 + 1 } }
      k84b = k84b + 1
  }
  vw("T84 swimwear beach: cast=" as *u8); vn(castGar)
  vw(" swim-lowers-worn=" as *u8); vn(swimLow84)
  vw(" other-category-worn=" as *u8); vn(other84)
  vw(" distinct-lower-ids=" as *u8); vn(lowKinds84)
  vw(" garments-after-300-ticks=" as *u8); vn(worn84)
  vw(" off-beach-after=" as *u8); vn(offBeach84)
  vw(" (need cast>0, swim-lowers==cast, other==0, distinct>=2, garments>=cast, off-beach==0)\n" as *u8)
  if castGar > 0 { if swimLow84 == castGar { if other84 == 0 { if lowKinds84 >= 2 {
      if worn84 >= castGar { if offBeach84 == 0 { pass = pass + 1 } } } } } }
3709
  // ---- T85: THE LEGACY CONTRACT HOLDS GIRL-FOR-GIRL, IN EVERY MODE --------------------------------
  // mobout (0 clothed / 1 topless / 2 nude) is now DERIVED from the worn set's coverage bits. Two
  // things must hold on the LIVED-IN world above (girls have wandered and some sleep, so the sarong
  // overlay is exercised, not just the boot state): (a) it equals gar_legacy over the coverage of
  // what mobgar/mobgart hand out, for every girl in all four modes -- the page's doors cannot
  // disagree with each other; (b) it equals mob_outfit_v1 -- THE PRE-WARDROBE RULE KEPT RUNNABLE
  // AS THE ORACLE -- for every girl in all four modes, so no existing consumer sees a different
  // girl. The clothed identity (mode 0) must additionally dress everyone in casual/evening only:
  // beachwear in a village is the operator's "random dresses" defect mirrored.
  var mism85: i64 = 0
  var oldMism85: i64 = 0
  var checked85: i64 = 0
  var villageBeach85: i64 = 0
  var md85: i64 = 0
  while md85 <= 3 {
      spGar[P_OUTFIT] = md85
      var k85: i64 = 0
      while k85 < castGar {
          let o85: i64 = wc_outfit(baseGar, k85)
          let cov85: i64 = gar_cov(gar_row(baseGar, o85 >> GAR_SLOT_SH)) | gar_cov(gar_row(baseGar, o85 & GAR_ID_MASK))
          if mob_outfit(baseGar, k85) != gar_legacy(cov85) { mism85 = mism85 + 1 }
          if mob_outfit(baseGar, k85) != mob_outfit_v1(baseGar, k85) { oldMism85 = oldMism85 + 1 }
          if md85 == 0 {
              let lo85: i64 = o85 & GAR_ID_MASK
              if lo85 == 0 { villageBeach85 = villageBeach85 + 1 }
              if lo85 > 0 { if gar_cat(gar_row(baseGar, lo85)) < GAR_CAT_CASUAL { villageBeach85 = villageBeach85 + 1 } }
          }
          checked85 = checked85 + 1
          k85 = k85 + 1
      }
      md85 = md85 + 1
  }
  spGar[P_OUTFIT] = 2
  vw("T85 legacy contract: checked=" as *u8); vn(checked85)
  vw(" door-vs-mobout-mismatches=" as *u8); vn(mism85)
  vw(" vs-pre-wardrobe-rule-mismatches=" as *u8); vn(oldMism85)
  vw(" village-girls-bare-or-in-beachwear=" as *u8); vn(villageBeach85)
  vw(" (need checked==4*cast, cast>0, all three zero)\n" as *u8)
  if checked85 == 4*castGar { if castGar > 0 { if mism85 == 0 { if oldMism85 == 0 { if villageBeach85 == 0 { pass = pass + 1 } } } } }
3749
  // ---- T86: DETERMINISM, AND THE POSE OVERLAY IS REACHED ------------------------------------------
  // Two arenas, same identity and seed, 120 ticks each in lockstep: every girl's outfit word and her
  // lower-slot colour must agree at every tick (samples counted and bound to cast*ticks). Then the
  // overlay is FORCED rather than waited for -- the first girl in swim bottoms, awake and out of the
  // water in both arenas, is put to sleep by writing mob_pose's own state bits (a mid-morning boot
  // never sleeps inside the budget, and a tooth that waits for night proves nothing about the wrap):
  // fixture-reached = mob_pose reads SLEEP; then her lower slot must read the SARONG, its category
  // beach-cover, her legacy value UNCHANGED from her awake value, and both arenas must still agree.
  let baseGar2: i64 = sys_mmap(CRAFT_TOTAL + K_MAGIC_4096) as i64
  init_impl_v(baseGar2, 2, K_MAGIC_20260728)
  let baseGar3: i64 = sys_mmap(CRAFT_TOTAL + K_MAGIC_4096) as i64
  init_impl_v(baseGar3, 2, K_MAGIC_20260728)
  let spGar2: *i64 = wsp(baseGar2)
  let spGar3: *i64 = wsp(baseGar3)
  spGar2[P_OUTFIT] = 2
  spGar3[P_OUTFIT] = 2
  let mGar2: *i64 = mobp(baseGar2)
  let mGar3: *i64 = mobp(baseGar3)
  let cast86: i64 = en_count(mGar2)
  var samp86: i64 = 0
  var diff86: i64 = 0
  var t86: i64 = 0
  while t86 < 120 {
      var k86: i64 = 0
      while k86 < cast86 {
          let oA86: i64 = wc_outfit(baseGar2, k86)
          let oB86: i64 = wc_outfit(baseGar3, k86)
          let gA86: i64 = en_get(mGar2, en_nth(mGar2, k86), MC_GENE)
          let gB86: i64 = en_get(mGar3, en_nth(mGar3, k86), MC_GENE)
          if oA86 != oB86 { diff86 = diff86 + 1 }
          if gar_rgb(gar_row(baseGar2, oA86 & GAR_ID_MASK), gA86) != gar_rgb(gar_row(baseGar3, oB86 & GAR_ID_MASK), gB86) { diff86 = diff86 + 1 }
          samp86 = samp86 + 1
          k86 = k86 + 1
      }
      mob_tick(baseGar2)
      mob_tick(baseGar3)
      t86 = t86 + 1
  }
  var kS86: i64 = 0 - 1
  var kq86: i64 = 0
  while kq86 < cast86 {
      if kS86 < 0 {
          let oq86: i64 = wc_outfit(baseGar2, kq86)
          if gar_cov(gar_row(baseGar2, oq86 & GAR_ID_MASK)) == GAR_COV_BOT {
              if mob_pose(baseGar2, kq86) != MOB_POSE_SLEEP { if mob_pose(baseGar3, kq86) != MOB_POSE_SLEEP {
                  if wc_mob_in_water(baseGar2, kq86) == 0 { if wc_mob_in_water(baseGar3, kq86) == 0 { kS86 = kq86 } } } }
          }
      }
      kq86 = kq86 + 1
  }
  var reached86: i64 = 0
  var sarong86: i64 = 0
  var cover86: i64 = 0
  var legacySame86: i64 = 0
  var agree86: i64 = 0
  if kS86 >= 0 {
      let awakeLo86: i64 = wc_outfit(baseGar2, kS86) & GAR_ID_MASK
      let awakeLeg86: i64 = mob_outfit(baseGar2, kS86)
      let hA86: i64 = en_nth(mGar2, kS86)
      let hB86: i64 = en_nth(mGar3, kS86)
      // mob_pose reads state = (MC_DISG >> 3) & 7 and publishes state 2 as SLEEP -- written the way
      // the mind writes it, so the overlay is reached through the engine's own door, not a stub
      let dA86: i64 = en_get(mGar2, hA86, MC_DISG)
      let dB86: i64 = en_get(mGar3, hB86, MC_DISG)
      en_set(mGar2, hA86, MC_DISG, dA86 - (((dA86 >> 3) & 7) << 3) + (MOB_POSE_SLEEP << 3))
      en_set(mGar3, hB86, MC_DISG, dB86 - (((dB86 >> 3) & 7) << 3) + (MOB_POSE_SLEEP << 3))
      if mob_pose(baseGar2, kS86) == MOB_POSE_SLEEP { reached86 = 1 }
      let sleepO86: i64 = wc_outfit(baseGar2, kS86)
      let sleepLo86: i64 = sleepO86 & GAR_ID_MASK
      if sleepLo86 == GAR_SARONG { if sleepLo86 != awakeLo86 { sarong86 = 1 } }
      if gar_cat(gar_row(baseGar2, sleepLo86)) == GAR_CAT_COVER { cover86 = 1 }
      if mob_outfit(baseGar2, kS86) == awakeLeg86 { legacySame86 = 1 }
      if sleepO86 == wc_outfit(baseGar3, kS86) { agree86 = 1 }
  }
  vw("T86 determinism+overlay: lockstep-samples=" as *u8); vn(samp86)
  vw(" of " as *u8); vn(cast86*120)
  vw(" disagreements=" as *u8); vn(diff86)
  vw(" fixture-girl=" as *u8); vn(kS86)
  vw(" fixture-reached-asleep=" as *u8); vn(reached86)
  vw(" wrap-is-sarong=" as *u8); vn(sarong86)
  vw(" wrap-category-cover=" as *u8); vn(cover86)
  vw(" legacy-unchanged-by-wrap=" as *u8); vn(legacySame86)
  vw(" arenas-agree-asleep=" as *u8); vn(agree86)
  vw(" (need samples==cast*120>0, disagreements=0, and the five overlay flags all 1)\n" as *u8)
  if samp86 == cast86*120 { if cast86 > 0 { if diff86 == 0 { if reached86 == 1 { if sarong86 == 1 {
      if cover86 == 1 { if legacySame86 == 1 { if agree86 == 1 { pass = pass + 1 } } } } } } } }
3836
  // ---- T87: NEG-CONTROL -- A WARDROBE WITHOUT SWIMWEAR MUST FAIL T84's PREDICATE ------------------
  // PLANT: zero the three beach-swim rows in the spec (the table IS the spec, so a recipe that
  // dropped them is exactly this state) on a swimwear beach and re-run T84's boot predicate: it must
  // FAIL -- swim lowers worn collapses to 0 and every girl reads nude, because a missing row is not
  // wearable. RESTORE through the identity's own writer (wc_spec re-seeds the table) and the same
  // predicate must PASS again. A tooth that has only ever passed has not been shown to fire; this
  // one fires and recovers inside one run, and the plant is the exact shape the operator saw --
  // a beach with no swimwear in it.
  let baseGarN: i64 = sys_mmap(CRAFT_TOTAL + K_MAGIC_4096) as i64
  init_impl_v(baseGarN, 2, K_MAGIC_20260728)
  let spGarN: *i64 = wsp(baseGarN)
  let mGarN: *i64 = mobp(baseGarN)
  let castN87: i64 = en_count(mGarN)
  spGarN[P_OUTFIT] = 2
  spGarN[P_GARM + GAR_BIKINI_TOP - 1] = 0
  spGarN[P_GARM + GAR_BIKINI_BOT - 1] = 0
  spGarN[P_GARM + GAR_ONEPIECE - 1] = 0
  var swimPlanted87: i64 = 0
  var nudePlanted87: i64 = 0
  var k87: i64 = 0
  while k87 < castN87 {
      let lo87: i64 = wc_outfit(baseGarN, k87) & GAR_ID_MASK
      if lo87 > 0 { if gar_cat(gar_row(baseGarN, lo87)) == GAR_CAT_SWIM { swimPlanted87 = swimPlanted87 + 1 } }
      if mob_outfit(baseGarN, k87) == 2 { nudePlanted87 = nudePlanted87 + 1 }
      k87 = k87 + 1
  }
  wc_spec(baseGarN, 2)
  spGarN[P_OUTFIT] = 2
  var swimRestored87: i64 = 0
  var k87b: i64 = 0
  while k87b < castN87 {
      let lo87b: i64 = wc_outfit(baseGarN, k87b) & GAR_ID_MASK
      if lo87b > 0 { if gar_cat(gar_row(baseGarN, lo87b)) == GAR_CAT_SWIM { swimRestored87 = swimRestored87 + 1 } }
      k87b = k87b + 1
  }
  vw("T87 neg-control-swim-rows-missing: cast=" as *u8); vn(castN87)
  vw(" swim-lowers-worn-planted=" as *u8); vn(swimPlanted87)
  vw(" read-nude-planted=" as *u8); vn(nudePlanted87)
  vw(" swim-lowers-worn-restored=" as *u8); vn(swimRestored87)
  vw(" (need cast>0, planted==0 and nude==cast -- T84's predicate FAILS -- then restored==cast)\n" as *u8)
  if castN87 > 0 { if swimPlanted87 == 0 { if nudePlanted87 == castN87 { if swimRestored87 == castN87 { pass = pass + 1 } } } }
3878
  // ---- T88: WEATHER REACHES THE FRAME PATH THE PAGE ACTUALLY DRIVES --------------------------
  // The shipped world pages drive step_impl once per rendered frame; tick_impl is the legacy
  // single-action shim that only gates and the old shim call. Until 2026-08-30 ONLY tick_impl
  // ticked the weather, so spec slots P_WXCOV..P_WXTEMP stayed ZERO on every frame any shipped
  // page ever rendered -- no wind field, no gusts, no cloud coverage, for every world -- and the
  // page's own hair term read window.__wxw as [0,0,0,0] and moved nothing. The engine one-liner
  // that fixed it had NO TOOTH ANYWHERE IN THE TREE: measured 2026-09-01, P_WXWINDX occurs four
  // times in buildroot/runtime (corpus_complete=1) and not one occurrence is in a gate, so an
  // edit that deleted the call again would leave every gate in the estate green. This is that
  // tooth, and it is a THREE-ARENA DIFFERENTIAL rather than a presence check:
  //   W = the path under test           -> step_impl(base)         (the FPS frame the page drives)
  //   R = the reference, the writer      -> wc_weather_tick(base)   (what W is supposed to reach)
  //   N = neg-control, W's OTHER half    -> apply2_impl(base, ...)  (the input core, which must
  //                                                                  NOT tick weather)
  // W must equal R on all five slots at EVERY day-eighth (so the frame path writes the same
  // weather, not merely something); N must stay at zero (so the sampler is shown able to report
  // zero, and the green is caused by the call under test rather than by init or by the readback);
  // and the sweep must actually see wind and actually change state between eighths, because two
  // arenas agreeing on all-zeros would otherwise satisfy every equality above.
  let baseW88: i64 = sys_mmap(CRAFT_TOTAL + K_MAGIC_4096) as i64
  init_impl_v(baseW88, 2, K_MAGIC_20260728)
  let baseR88: i64 = sys_mmap(CRAFT_TOTAL + K_MAGIC_4096) as i64
  init_impl_v(baseR88, 2, K_MAGIC_20260728)
  let baseN88: i64 = sys_mmap(CRAFT_TOTAL + K_MAGIC_4096) as i64
  init_impl_v(baseN88, 2, K_MAGIC_20260728)
  let spW88: *i64 = wsp(baseW88)
  let spR88: *i64 = wsp(baseR88)
  let spN88: *i64 = wsp(baseN88)
  let stW88: *i64 = wst(baseW88)
  let stR88: *i64 = wst(baseR88)
  let stN88: *i64 = wst(baseN88)
  let dl88: i64 = spW88[P_DAYLEN]
  // FIXTURE-REACHED-THE-CONDITION, asserted before any outcome: a freshly initialised world has
  // never run either weather call, so all five slots must start at zero. If init ever begins
  // writing them this conjunct fails LOUDLY instead of silently handing the tooth a pre-filled
  // arena that would make every comparison below pass for the wrong reason.
  var preZero88: i64 = 1
  var p88: i64 = P_WXCOV
  while p88 <= P_WXTEMP {
      if spW88[p88] != 0 { preZero88 = 0 }
      p88 = p88 + 1
  }
  var sampled88: i64 = 0
  var agree88: i64 = 0
  var windy88: i64 = 0
  var negWrote88: i64 = 0
  var moved88: i64 = 0
  var cov088: i64 = 0
  var wx088: i64 = 0
  var wz088: i64 = 0
  var k88: i64 = 0
  while k88 < T88_EIGHTHS {
      let t88: i64 = k88*dl88/T88_EIGHTHS
      // re-zero every arena each sample so the ONLY possible writer in this sample is the call
      // under test -- a value left over from the previous eighth would flatter both comparisons
      var z88: i64 = P_WXCOV
      while z88 <= P_WXTEMP {
          spW88[z88] = 0
          spR88[z88] = 0
          spN88[z88] = 0
          z88 = z88 + 1
      }
      stW88[S_T] = t88
      stR88[S_T] = t88
      stN88[S_T] = t88
      step_impl(baseW88)
      wc_weather_tick(baseR88)
      apply2_impl(baseN88, 0, 0, 0, 0, 0, 0, 0, 0, 0)
      var same88: i64 = 1
      var c88: i64 = P_WXCOV
      while c88 <= P_WXTEMP {
          if spW88[c88] != spR88[c88] { same88 = 0 }
          if spN88[c88] != 0 { negWrote88 = negWrote88 + 1 }
          c88 = c88 + 1
      }
      if same88 == 1 { agree88 = agree88 + 1 }
      var ax88: i64 = spW88[P_WXWINDX]
      if ax88 < 0 { ax88 = 0 - ax88 }
      var az88: i64 = spW88[P_WXWINDZ]
      if az88 < 0 { az88 = 0 - az88 }
      if ax88 + az88 > 0 { windy88 = windy88 + 1 }
      if k88 == 0 {
          cov088 = spW88[P_WXCOV]
          wx088 = spW88[P_WXWINDX]
          wz088 = spW88[P_WXWINDZ]
      }
      if k88 > 0 {
          if spW88[P_WXCOV] != cov088 { moved88 = moved88 + 1 }
          if spW88[P_WXWINDX] != wx088 { moved88 = moved88 + 1 }
          if spW88[P_WXWINDZ] != wz088 { moved88 = moved88 + 1 }
      }
      sampled88 = sampled88 + 1
      k88 = k88 + 1
  }
  vw("T88 weather-on-the-frame-path: daylen=" as *u8); vn(dl88)
  vw(" fixture-slots-start-unwritten=" as *u8); vn(preZero88)
  vw(" eighths-sampled=" as *u8); vn(sampled88)
  vw(" frame-path-agrees-with-the-writer=" as *u8); vn(agree88)
  vw(" eighths-with-nonzero-wind=" as *u8); vn(windy88)
  vw(" state-changes-across-eighths=" as *u8); vn(moved88)
  vw(" neg-control-input-core-alone-wrote-slots=" as *u8); vn(negWrote88)
  vw(" (need daylen>0, start-unwritten, sampled==eighths, agree==sampled, wind>0, moved>0, neg-control==0)\n" as *u8)
  if dl88 > 0 { if preZero88 == 1 { if sampled88 == T88_EIGHTHS { if agree88 == sampled88 {
      if windy88 > 0 { if moved88 > 0 { if negWrote88 == 0 { pass = pass + 1 } } } } } } }
3983
  // ================= T89: THE REVIEW RING STANDS ON THE SEAWARD ARC (GE45 framing, 2026-09-04) ==============
  // The shore identity (v2) declares an ocean toward +z (P_OCEAN edge 0), so wsp_sea_yaw reads 0 and summon_impl
  // must place EVERY girl within a quarter turn of that bearing: dz > 0 and |dx| <= dz (tan 45 = 1, integer-exact).
  // The review camera faces the nearest girl, so the shore is behind her by construction. NEG-CONTROL: the
  // ocean-less identity (v0) has no sea bearing (-1) and keeps the full ring, so some girl stands landward
  // (dz < 0) -- the arc must not fire where no sea exists.
  let base89: i64 = sys_mmap(CRAFT_TOTAL + K_MAGIC_4096) as i64
  init_impl_v(base89, 2, K_MAGIC_20260728)
  let sy89: i64 = wsp_sea_yaw(wsp(base89))
  summon_impl(base89)
  let m89: *i64 = mobp(base89)
  let s89: *i64 = wst(base89)
  let n89: i64 = en_count(m89)
  var seaward89: i64 = 0
  var k89: i64 = 0
  while k89 < n89 {
      let h89: i64 = en_nth(m89, k89)
      if h89 > 0 {
          let dx89: i64 = en_get(m89, h89, MC_X) - s89[S_CX]
          let dz89: i64 = en_get(m89, h89, MC_Z) - s89[S_CZ]
          var ax89: i64 = dx89
          if ax89 < 0 { ax89 = 0 - ax89 }
          if dz89 > 0 { if ax89 <= dz89 { seaward89 = seaward89 + 1 } }
      }
      k89 = k89 + 1
  }
  let baseN89: i64 = sys_mmap(CRAFT_TOTAL + K_MAGIC_4096) as i64
  init_impl_v(baseN89, 0, K_MAGIC_20260728)
  let syN89: i64 = wsp_sea_yaw(wsp(baseN89))
  summon_impl(baseN89)
  let mN89: *i64 = mobp(baseN89)
  let sN89: *i64 = wst(baseN89)
  let nN89: i64 = en_count(mN89)
  var landward89: i64 = 0
  var j89: i64 = 0
  while j89 < nN89 {
      let hN89: i64 = en_nth(mN89, j89)
      if hN89 > 0 { if en_get(mN89, hN89, MC_Z) - sN89[S_CZ] < 0 { landward89 = landward89 + 1 } }
      j89 = j89 + 1
  }
  vw("T89 seaward review arc: v2 sea_yaw=" as *u8); vn(sy89)
  vw(" girls=" as *u8); vn(n89)
  vw(" seaward=" as *u8); vn(seaward89)
  vw(" | neg-control v0 sea_yaw=" as *u8); vn(syN89)
  vw(" girls=" as *u8); vn(nN89)
  vw(" landward=" as *u8); vn(landward89)
  vw(" (need sea_yaw==0, girls>0, seaward==girls, v0 sea_yaw==-1, landward>0)\n" as *u8)
  if sy89 == 0 { if n89 > 0 { if seaward89 == n89 { if syN89 == 0 - 1 { if landward89 > 0 { pass = pass + 1 } } } } }
4032
  // ================= T90: THE ONE GEN-TIME ALLOWLIST PINS THE ENGINE'S OWN SLOTS (nx_genp_allow_lib) =========
  // Every P_* slot the engine admits at gen time answers 1 from the shared lib under the engine's OWN name; a
  // style slot, the wardrobe, the derived talus slot and the first unowned index answer 0; the census equals the
  // lib's declared count; and a GENP region carrying two admitted rows lands both in the spec table before
  // genworld (S_GENP counts them). Three organs read this list; this tooth is the only place the names meet.
  var pin90: i64 = 0
  if genp_gen_ok(P_TBASE) == 1 { pin90 = pin90 + 1 }
  if genp_gen_ok(P_CAVETH) == 1 { pin90 = pin90 + 1 }
  if genp_gen_ok(P_TREEMAX) == 1 { pin90 = pin90 + 1 }
  if genp_gen_ok(P_HISTAGE) == 1 { pin90 = pin90 + 1 }
  if genp_gen_ok(P_TREESPEC) == 1 { pin90 = pin90 + 1 }
  if genp_gen_ok(P_BLDG) == 1 { pin90 = pin90 + 1 }
  if genp_gen_ok(P_BLDGSPEC) == 1 { pin90 = pin90 + 1 }
  if genp_gen_ok(P_ERODE) == 1 { pin90 = pin90 + 1 }
  if genp_gen_ok(P_OCEAN) == 1 { pin90 = pin90 + 1 }
  if genp_gen_ok(P_WPIPE) == 1 { pin90 = pin90 + 1 }
  if genp_gen_ok(P_WPSCALE) == 1 { pin90 = pin90 + 1 }
  let neg90: i64 = genp_gen_ok(P_SKYTOP) + genp_gen_ok(P_GARM) + genp_gen_ok(P_ERTAL) + genp_gen_ok(WC_SPECN)
  let census90: i64 = genp_gen_count()
  let baseG90: i64 = sys_mmap(CRAFT_TOTAL + K_MAGIC_4096) as i64
  let gp90: *i64 = wgp(baseG90)
  gp90[0] = GENP_MAGIC
  gp90[1] = 2
  gp90[2] = P_TREEMAX
  gp90[3] = T90_TREEMAX
  gp90[4] = P_WPSCALE
  gp90[5] = T79_SCALE
  init_impl_v(baseG90, 0, K_MAGIC_20260728)
  let st90: *i64 = wst(baseG90)
  let applied90: i64 = st90[S_GENP]
  let sp90: *i64 = wsp(baseG90)
  vw("T90 one gen-time allowlist: engine-slots-admitted=" as *u8); vn(pin90)
  vw("/" as *u8); vn(T90_PINS)
  vw(" neg-controls-admitted=" as *u8); vn(neg90)
  vw(" census=" as *u8); vn(census90); vw(" declared=" as *u8); vn(GA_ADMITTED)
  vw(" genp-applied=" as *u8); vn(applied90)
  vw(" treemax=" as *u8); vn(sp90[P_TREEMAX]); vw(" wpscale=" as *u8); vn(sp90[P_WPSCALE])
  vw(" (need all slots, 0 neg-controls, census==declared, applied==2, treemax==" as *u8); vn(T90_TREEMAX); vw(", wpscale==" as *u8); vn(T79_SCALE); vw(")\n" as *u8)
  if pin90 == T90_PINS { if neg90 == 0 { if census90 == GA_ADMITTED { if applied90 == 2 { if sp90[P_TREEMAX] == T90_TREEMAX { if sp90[P_WPSCALE] == T79_SCALE { pass = pass + 1 } } } } } }
4072
  // T91 GE55 RAW UNIFORM BLOCK: the sim packs its own state for the GPU -- 40 LE u32 words at O_URAW, appended at
  // the arena tail (CRAFT_TOTAL moved by exactly URAW_BYTES). Every word is read back through ur_r32 and compared
  // with the accessor the page used to reach through JS; the tail pad must read zero (neg-control: a packer that
  // wrote past palf, or a layout that drifted, shows here), and the arena total must equal off + 160.
  s9set(base)
  pack_uniforms_impl(base)
  let ub9: *u8 = (base + O_URAW) as *u8
  let s9: *i64 = wst(base)
  let sp9: *i64 = wsp(base)
  let w_camx: i64 = ur_r32(ub9, UR_CAMX)
  let w_tnow: i64 = ur_r32(ub9, UR_TNOW)
  let w_sunel: i64 = ur_r32(ub9, UR_SUNEL)
  let w_skt: i64 = ur_r32(ub9, UR_SKT)
  let w_pal3: i64 = ur_r32(ub9, UR_PAL + 3)
  let w_palf4: i64 = ur_r32(ub9, UR_PALF + 4)
  let w_resw: i64 = ur_r32(ub9, UR_RESW)
  let w_resh: i64 = ur_r32(ub9, UR_RESH)
  let w_yflip: i64 = ur_r32(ub9, UR_YFLIP)
  var w_pad: i64 = 0
  if w_resw != 640 { w_pad = 1 }
  if w_resh != 480 { w_pad = w_pad + 2 }
  if w_yflip != 1 { w_pad = w_pad + 4 }
  let e_camx: i64 = s9[S_CX] & 0xFFFFFFFF
  let e_tnow: i64 = s9[S_T] & 0xFFFFFFFF
  let e_sunel: i64 = cal_sunel(base) & 0xFFFFFFFF
  let e_skt: i64 = sp9[7] & 0xFFFFFFFF
  let e_pal3: i64 = sp9[19] & 0xFFFFFFFF
  let e_palf4: i64 = sp9[38] & 0xFFFFFFFF
  vw("T91 GE55 raw uniform block: off=" as *u8); vn(O_URAW); vw(" total=" as *u8); vn(CRAFT_TOTAL)
  vw(" camx=" as *u8); vn(w_camx); vw("/" as *u8); vn(e_camx)
  vw(" tnow=" as *u8); vn(w_tnow); vw("/" as *u8); vn(e_tnow)
  vw(" sunel=" as *u8); vn(w_sunel); vw("/" as *u8); vn(e_sunel)
  vw(" skt=" as *u8); vn(w_skt); vw("/" as *u8); vn(e_skt)
  vw(" pal3=" as *u8); vn(w_pal3); vw("/" as *u8); vn(e_pal3)
  vw(" palf4=" as *u8); vn(w_palf4); vw("/" as *u8); vn(e_palf4)
  vw(" res=" as *u8); vn(w_resw); vw("x" as *u8); vn(w_resh); vw("/640x480 yflip=" as *u8); vn(w_yflip); vw("/1 doorbits=" as *u8); vn(w_pad); vw(" (need every word equal, the door words as set, total == off+160)\n" as *u8)
  if w_camx == e_camx { if w_tnow == e_tnow { if w_sunel == e_sunel { if w_skt == e_skt { if w_pal3 == e_pal3 { if w_palf4 == e_palf4 { if w_pad == 0 { if CRAFT_TOTAL == O_CONTACT + (2*CONTACT_BOX_WORDS+CONTACT_RESULT_WORDS+CONTACT_STATE_WORDS)*8 { pass = pass + 1 } } } } } } } }
4110
  // T96: the release fixture is native scene data with an actual initial-camera ray hit.
  let rb_base: i64 = sys_mmap(CRAFT_TOTAL + K_MAGIC_4096) as i64
  let rb_init: i64 = init_impl_v(rb_base, BEACH_RELEASE_WORLD, CRAFT_DEFAULT_SEED)
  let rb_s: *i64 = wst(rb_base)
  let rb_vox: *u8 = wvx(rb_base)
  let rb_copy: *u8 = sys_mmap(WX*WY*WZ)
  var rb_n: i64 = 0
  var rb_i: i64 = 0
  while rb_i < WX*WY*WZ {
      rb_copy[rb_i] = rb_vox[rb_i]
      if (rb_vox[rb_i] as i64) == BEACH_RELEASE_MATERIAL { rb_n = rb_n+1 }
      rb_i = rb_i+1
  }
  // Regenerate only the base world, then restore the fixture. This isolates its delta
  // from existing hut foliage and checks that init produced the same geometry.
  genworld(rb_base, CRAFT_DEFAULT_SEED)
  var rb_removed: i64 = 0
  var rb_overwrite: i64 = 0
  rb_i = 0
  while rb_i < WX*WY*WZ {
      if rb_copy[rb_i] != rb_vox[rb_i] {
          rb_removed = rb_removed+1
          if (rb_vox[rb_i] as i64) != 0 { rb_overwrite = rb_overwrite+1 }
      }
      rb_i = rb_i+1
  }
  let rb_again: i64 = wc_spawn_bush(rb_base, BEACH_RELEASE_FORWARD, BEACH_RELEASE_LATERAL, BEACH_RELEASE_RADIUS, BEACH_RELEASE_HEIGHT, BEACH_RELEASE_MATERIAL)
  var rb_changed: i64 = 0
  rb_i = 0
  while rb_i < WX*WY*WZ {
      if rb_copy[rb_i] != rb_vox[rb_i] { rb_changed = rb_changed+1 }
      rb_i = rb_i+1
  }
  // Shore's verified starting heading is +z. Aim left three, forward seven, at crown height.
  let rb_x: i64 = (rb_s[S_SPX] >> 8)+BEACH_RELEASE_LATERAL
  let rb_z: i64 = (rb_s[S_SPZ] >> 8)+BEACH_RELEASE_FORWARD
  let rb_g: i64 = wheight(rb_base, rb_x, rb_z, CRAFT_DEFAULT_SEED)
  let rb_hit: *i64 = sys_mmap(5*8) as *i64
  let rb_dx: i64 = rb_x*256+128-rb_s[S_CX]
  let rb_dz: i64 = rb_z*256+128-rb_s[S_CZ]
  let rb_dy: i64 = (rb_g+BEACH_RELEASE_HEIGHT)*256+128-rb_s[S_CY]
  let rb_t: i64 = wray2(rb_base, rb_dx, rb_dy, rb_dz, WX+WY+WZ, rb_hit, 0)
  var rb_mat: i64 = 0
  if rb_t >= 0 { rb_mat = vget(rb_base, rb_hit[0], rb_hit[1], rb_hit[2]) }
  let rb_twice: i64 = wc_spawn_bush(rb_base, BEACH_RELEASE_FORWARD, BEACH_RELEASE_LATERAL, BEACH_RELEASE_RADIUS, BEACH_RELEASE_HEIGHT, BEACH_RELEASE_MATERIAL)
  rb_i = 0
  while rb_i < WX*WY*WZ {
      if rb_copy[rb_i] != rb_vox[rb_i] { rb_changed = rb_changed+1 }
      rb_i = rb_i+1
  }
  pack_uniforms_impl(rb_base)
  let rb_color: i64 = ur_r32((rb_base+O_URAW) as *u8, UR_PAL+BEACH_RELEASE_MATERIAL)
  // The material's declared world palette is the visual source of truth; the gate
  // compares the packed GPU uniform with that same material lookup rather than a duplicate RGB
  // literal that can drift when a world style changes.
  let rb_expected_color: i64 = wcol(rb_base, BEACH_RELEASE_MATERIAL) & 0xFFFFFFFF
  vw("T96 release bush init=" as *u8); vn(rb_init); vw(" world_foliage=" as *u8); vn(rb_n); vw(" fixture_delta=" as *u8); vn(rb_removed); vw(" overwritten=" as *u8); vn(rb_overwrite)
  vw(" restamp=" as *u8); vn(rb_again); vw(" changed=" as *u8); vn(rb_changed)
  vw(" ray_material=" as *u8); vn(rb_mat); vw(" gpu_palette=" as *u8); vn(rb_color); vw("\n" as *u8)
  if rb_init == 0 { if rb_removed == 14 { if rb_again == rb_removed { if rb_changed == 0 {
      if rb_mat == BEACH_RELEASE_MATERIAL { if rb_color == rb_expected_color { if rb_overwrite == 0 { if rb_twice == rb_again {
          if rb_s[S_YAW] == 0 { if rb_dz > 0 {
              var rb_ax: i64 = rb_dx
              if rb_ax < 0 { rb_ax = 0 - rb_ax }
              if rb_ax < rb_dz { pass = pass+1 }
          } }
      } } } }
  } } } }
4179
  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
4192}
nx_wasm_craft_gate.nx source

`nx_wasm_craft_gate.nx` source
