code wiki / (root) / nx_nxa_morf_gate.nx
`nx_nxa_morf_gate.nx` source

↩ module page · 414 lines · 19332 B
1// nx_nxa_morf_gate.nx -- FACE AND MORF ARE GEOMETRY, NOT TAGS.
2//
3// The subject organ closes the last two ABSENT rows on nx_asset_floor_gate. That gate's own law is
4// the reason this one exists:
5//     PRESENCE OF A SECTION IS NOT PRESENCE OF THE CAPABILITY.
6// A FACE section holding zero indices and a MORF section holding zero deltas would flip the floor
7// score to 7/7 while the character remained exactly as expressionless as before. So every tooth
8// here asks a question a tag cannot answer:
9//   - does FACE carry real vertex membership, and is every index inside the mesh
10//   - does MORF carry a displacement set for every declared channel, each with a NON-EMPTY support
11//   - does full weight produce EXACTLY the stored vertex deltas, including unchanged non-FACE
12//     vertices, independently of the subject's stdout (zero taper at a support edge is allowed)
13//   - is a zero weight BYTE-IDENTICAL to the input (a no-op morph must be provably a no-op; size
14//     equality would not do, so this compares every byte)
15//   - is derive DETERMINISTIC (two runs, byte-identical)
16// The negative controls are real artifacts, not fixtures invented to fail: the banked pre-change
17// asset (which genuinely lacks both sections) and a malformed channel spec.
18//
19// This gate re-declares the section layout rather than importing it from the subject. That is
20// deliberate: an independent reader is a witness, whereas sharing the subject's own accessor would
21// let one bug agree with itself.
22// license_tier: ORIGINAL   No hw writes (Rule 26).   expect_exit: 0
23import "nx_syscalls.nx"
24import "nx_gate_verdict.nx"
25import "nx_gatekit_lib.nx"
26import "nx_nxa.nx"
27import "nx_estate_path.nx"
28
29const MG_ELF:  *u8 = "./nx_nxa_morf.elf"
30const MG_DIR:  *u8 = "/tmp/nxmorfgate"
31const MG_PRE:  *u8 = "knowledge/bank/ref9d.nxa.premorf-20260823"
32const MG_D1:   *u8 = "/tmp/nxmorfgate/d1.nxa"
33const MG_D2:   *u8 = "/tmp/nxmorfgate/d2.nxa"
34const MG_E0:   *u8 = "/tmp/nxmorfgate/e0.nxa"
35const MG_EU:   *u8 = "/tmp/nxmorfgate/eu.nxa"
36const MG_EBAD: *u8 = "/tmp/nxmorfgate/ebad.nxa"
37const MG_CAP:  i64 = 65536
38const MG_MODE: i64 = 493
39
40// NXA container layout (nx_nxa.nx owns magic/checksum; these are the header shapes it implies)
41const MG_HDR:  i64 = 32
42const MG_TOCE: i64 = 32
43const MG_W:    i64 = 8
44// FACE payload: [nface, stature_axis, lo_permil, hi_permil] then nface vertex indices
45const MG_FACE_HDR: i64 = 4
46// MORF payload: [nchan, nrows, dstride, unit] then nchan x [tag, support] then deltas
47const MG_MORF_HDR: i64 = 4
48const MG_CHANREC:  i64 = 2
49const MG_CONF: *u8 = "knowledge/facs_au.conf"
50const MG_UNIT: i64 = 1000
51// Select a channel with actual nonzero deltas from the derived asset.
52const MG_SPEC_ZERO: *u8 = "0:0"
53const MG_SPEC_BAD:  *u8 = "notaspec"
54
55// Optional arguments: <subject ELF> <fresh /tmp basename>.
56// Relative ELF paths resolve from ep_anchor's estate root. Omitted args retain
57// the original subject and paths. A supplied basename must create a fresh dir.
58func mg_pathlen(p: *u8) -> i64 {
  var n: i64 = 0
  while p[n] != (0 as u8) { n = n+1 }
  return n
62}
63func mg_join(a: *u8,b: *u8) -> *u8 {
  let out: *u8 = sys_mmap(mg_pathlen(a)+mg_pathlen(b)+1)
  if (out as i64) <= 0 { return 0 as *u8 }
  var n: i64 = gk_cat(out,0,a)
  n = gk_cat(out,n,b); out[n] = 0 as u8
  return out
69}
70func mg_basename(p: *u8) -> i64 {
  var i: i64 = 0
  while p[i] != (0 as u8) {
      let c: i64 = p[i] as i64; var ok: i64 = 0
      if c >= 48 { if c <= 57 { ok = 1 } }
      if c >= 65 { if c <= 90 { ok = 1 } }
      if c >= 97 { if c <= 122 { ok = 1 } }
      if c == 45 { ok = 1 }; if c == 95 { ok = 1 }
      if ok == 0 { return 0 }; i = i+1
  }
  if i == 0 { return 0 }
  return 1
82}
83
84func mg_rd(b: *u8, off: i64) -> i64 {
  let p: *i64 = ((b as i64) + off) as *i64
  return p[0]
87}
88func mg_tageq(b: *u8, off: i64, t: *u8) -> i64 {
  var i: i64 = 0
  while i < 4 { if b[off + i] != t[i] { return 0 } i = i + 1 }
  return 1
92}
93// payload BYTE offset of section `t`, or -1
94func mg_sec(b: *u8, ns: i64, t: *u8) -> i64 {
  var s: i64 = 0
  while s < ns {
      let e: i64 = MG_HDR + s*MG_TOCE
      if mg_tageq(b, e, t) == 1 { return mg_rd(b, e + 8) }
      s = s + 1
  }
  return 0 - 1
102}
103func mg_nsec(b: *u8) -> i64 { return mg_rd(b, 16) }
104
105// full-byte comparison. Size equality is NEVER identity (a same-size rewrite sails through), so
106// this reads both files whole and compares every byte.
107func mg_same(a: *u8, b: *u8) -> i64 {
  let la: *i64 = sys_mmap(16) as *i64
  let lb: *i64 = sys_mmap(16) as *i64
  let ba: *u8 = sys_read_file(a, la)
  let bb: *u8 = sys_read_file(b, lb)
  if (ba as i64) == 0 { return 0 }
  if (bb as i64) == 0 { return 0 }
  if la[0] != lb[0] { return 0 }
  var i: i64 = 0
  while i < la[0] {
      if ba[i] != bb[i] { return 0 }
      i = i + 1
  }
  return 1
121}
122
123
124// Independent config witness: derive ordered tags from every complete AU row.
125// The byte-derived allocation cannot cap a future channel table silently.
126func mg_conf_tags(tags: *i64, b: *u8, n: i64) -> i64 {
  var p: i64 = 0; var count: i64 = 0
  while p < n {
      var end: i64 = p
      while end < n { if b[end] == (10 as u8) { break }; end = end + 1 }
      if end - p >= 3 {
          if b[p] == (97 as u8) { if b[p+1] == (117 as u8) { if b[p+2] == (124 as u8) {
              var pipes: i64 = 0; var q: i64 = p
              while q < end { if b[q] == (124 as u8) { pipes = pipes + 1 }; q = q + 1 }
              if pipes != 9 { return 0 - 1 }
              if end - p < 8 { return 0 - 1 }
              if b[p+7] != (124 as u8) { return 0 - 1 }
              var tag: i64 = 0; var j: i64 = 0
              while j < 4 { tag = tag | ((b[p+3+j] as i64) << (j*8)); j = j + 1 }
              j = 0; while j < count { if tags[j] == tag { return 0 - 1 }; j = j + 1 }
              tags[count] = tag; count = count + 1
          } } }
      }
      p = end + 1
  }
  return count
147}
148
149// Validate container boundaries before this independent gate reads payloads.
150func mg_container(b: *u8, n: i64) -> i64 {
  if n < MG_HDR { return 0 }
  if mg_rd(b, 0) != nxa_magic() { return 0 }
  let ns: i64 = mg_nsec(b)
  if ns < 1 { return 0 }
  if ns > (n - MG_HDR)/MG_TOCE { return 0 }
  var s: i64 = 0
  while s < ns {
      let e: i64 = MG_HDR + s*MG_TOCE
      let off: i64 = mg_rd(b, e+8); let words: i64 = mg_rd(b, e+16)
      if off < MG_HDR + ns*MG_TOCE { return 0 }
      if off > n { return 0 }; if words < 0 { return 0 }
      if words > (n-off)/MG_W { return 0 }
      s = s + 1
  }
  return 1
166}
167func mg_words(b: *u8, tag: *u8) -> i64 {
  var s: i64 = 0
  while s < mg_nsec(b) {
      let e: i64 = MG_HDR + s*MG_TOCE
      if mg_tageq(b,e,tag) == 1 { return mg_rd(b,e+16) }
      s = s + 1
  }
  return 0
175}
176
177// Compare actual VERT coordinates, never the subject's self-reported moved count.
178// Expected positions are the input coordinates plus stored deltas at full declared unit.
179func mg_eval_exact(d: *u8, fo: i64, mo: i64, vo: i64, nv: i64, nf: i64, nc: i64, ch: i64, path: *u8) -> i64 {
  let lp: *i64 = sys_mmap(16) as *i64
  let out: *u8 = sys_read_file(path, lp)
  if (out as i64) == 0 { return 0 }
  if mg_container(out, lp[0]) == 0 { return 0 }
  let ov: i64 = mg_sec(out, mg_nsec(out), "VERT" as *u8)
  if ov < 0 { return 0 }
  if mg_words(out,"VERT" as *u8) < 1 + nv*3 { return 0 }
  if mg_rd(out,ov) != nv { return 0 }
  let expected: *i64 = sys_mmap(nv*3*MG_W) as *i64
  var k: i64 = 0
  while k < nv*3 { expected[k] = mg_rd(d,vo+MG_W+k*MG_W); k = k + 1 }
  let db: i64 = mo + (MG_MORF_HDR+nc*MG_CHANREC)*MG_W
  var row: i64 = 0; var moved: i64 = 0
  while row < nf {
      let vi: i64 = mg_rd(d,fo+(MG_FACE_HDR+row)*MG_W)
      var a: i64 = 0; var any: i64 = 0
      while a < 3 {
          let delta: i64 = mg_rd(d,db+((ch*nf+row)*3+a)*MG_W)
          expected[vi*3+a] = expected[vi*3+a]+delta
          if delta != 0 { any = 1 }
          a = a + 1
      }
      if any == 1 { moved = moved + 1 }; row = row + 1
  }
  if moved == 0 { return 0 }
  k = 0
  while k < nv*3 {
      if mg_rd(out,ov+MG_W+k*MG_W) != expected[k] { return 0 }
      k = k + 1
  }
  return 1
211}
212
213func main(argc: i64, argv: *i64) -> i64 {
  if ep_anchor() < 0 { gv_puts("MORF-GATE-REFUSE estate anchor unavailable\n" as *u8); return 3 }
  if argc > 3 { gv_puts("usage: gate [subject-ELF [fresh-tmp-basename]]\n" as *u8); return 2 }
  var subject: *u8 = MG_ELF
  var dir: *u8 = MG_DIR
  var d1path: *u8 = MG_D1; var d2path: *u8 = MG_D2
  var e0path: *u8 = MG_E0; var eupath: *u8 = MG_EU; var badpath: *u8 = MG_EBAD
  if argc > 1 { subject = argv[1] as *u8 }
  if mg_pathlen(subject) == 0 { return 2 }
  if argc > 2 {
      let name: *u8 = argv[2] as *u8
      if mg_basename(name) == 0 { gv_puts("MORF-GATE-REFUSE invalid tmp basename\n" as *u8); return 2 }
      dir = mg_join("/tmp/" as *u8,name)
      if (dir as i64) <= 0 { return 3 }
      if sys_mkdir(dir,493) != 0 { gv_puts("MORF-GATE-REFUSE tmp directory is not fresh\n" as *u8); return 3 }
      d1path = mg_join(dir,"/d1.nxa" as *u8); d2path = mg_join(dir,"/d2.nxa" as *u8)
      e0path = mg_join(dir,"/e0.nxa" as *u8); eupath = mg_join(dir,"/eu.nxa" as *u8); badpath = mg_join(dir,"/ebad.nxa" as *u8)
      if (d1path as i64) <= 0 { return 3 }; if (d2path as i64) <= 0 { return 3 }
      if (e0path as i64) <= 0 { return 3 }; if (eupath as i64) <= 0 { return 3 }; if (badpath as i64) <= 0 { return 3 }
  } else { sys_mkdir(dir,493) }
  gv_puts("subject=" as *u8); gv_puts(subject); gv_puts(" tmp=" as *u8); gv_puts(dir); gv_puts("\n" as *u8)
  let ctr: *i64 = gv_ctr()
  gv_head("nx_nxa_morf gate -- FACE and MORF carry geometry, and the morph moves exactly its own support" as *u8)
  let buf: *u8 = sys_mmap(MG_CAP + 64)
  let bl: *i64 = sys_mmap(16) as *i64
238
  // ---- setup: the negative control is a REAL banked artifact, not an invented fixture --------
  let pre_ok: i64 = gk_exists(MG_PRE)
  gv_check("setup-banked-pre-change-asset-present (the neg-control is a real artifact)" as *u8, pre_ok, ctr)
  if pre_ok == 0 {
      let rcp: i64 = gv_verdict("NX-NXA-MORF" as *u8, ctr, "no banked pre-change asset to measure against" as *u8)
      sys_exit(rcp)
      return rcp
  }
247
  // ---- derive ------------------------------------------------------------------------------
  let rc1: i64 = gk_run_capture(subject, "derive" as *u8, MG_PRE, d1path, 0 as *u8, buf, MG_CAP, bl)
  gv_check("derive-exits-zero" as *u8, rc1 == 0, ctr)
251
  let lp: *i64 = sys_mmap(16) as *i64
  let d: *u8 = sys_read_file(d1path, lp)
  var readable: i64 = 0
  if (d as i64) != 0 { readable = mg_container(d, lp[0]) }
  gv_check("derived-asset-readable" as *u8, readable, ctr)
  if readable == 0 {
      let rcr: i64 = gv_verdict("NX-NXA-MORF" as *u8, ctr, "derive produced nothing readable" as *u8)
      sys_exit(rcr)
      return rcr
  }
  let ns: i64 = mg_nsec(d)
  let fo: i64 = mg_sec(d, ns, "FACE" as *u8)
  let mo: i64 = mg_sec(d, ns, "MORF" as *u8)
  let vo: i64 = mg_sec(d, ns, "VERT" as *u8)
  gv_puts("  sections=" as *u8); gv_num(ns); gv_puts("\n" as *u8)
267
  let fl: i64 = mg_words(d, "FACE" as *u8)
  let ml: i64 = mg_words(d, "MORF" as *u8)
  let vl: i64 = mg_words(d, "VERT" as *u8)
  gv_check("FACE-header-bounded" as *u8, fl >= MG_FACE_HDR, ctr)
  if fl < MG_FACE_HDR { return gv_verdict("NX-NXA-MORF" as *u8, ctr, "FACE header missing" as *u8) }
  gv_check("MORF-header-bounded" as *u8, ml >= MG_MORF_HDR, ctr)
  if ml < MG_MORF_HDR { return gv_verdict("NX-NXA-MORF" as *u8, ctr, "MORF header missing" as *u8) }
  gv_check("VERT-header-bounded" as *u8, vl >= 1, ctr)
  if vl < 1 { return gv_verdict("NX-NXA-MORF" as *u8, ctr, "VERT header missing" as *u8) }
  let cl: *i64 = sys_mmap(16) as *i64
  let cb: *u8 = sys_read_file(MG_CONF, cl)
  var expected_count: i64 = 0
  let tags: *i64 = sys_mmap((cl[0]+1)*MG_W) as *i64
  if (cb as i64) != 0 { expected_count = mg_conf_tags(tags, cb, cl[0]) }
  gv_check("AU-config-readable-valid-unique-tags-and-nonempty" as *u8, expected_count > 0, ctr)
283
  // ---- FACE is real membership, not an empty tag --------------------------------------------
  var nface: i64 = 0
  if fo >= 0 { nface = mg_rd(d, fo) }
  var nv: i64 = 0
  if vo >= 0 { nv = mg_rd(d, vo) }
  gv_puts("  face_verts=" as *u8); gv_num(nface)
  gv_puts(" of verts=" as *u8); gv_num(nv); gv_puts("\n" as *u8)
  var face_ok: i64 = 0
  if fo >= 0 { if nface > 0 { if nface <= nv { if nface <= fl-MG_FACE_HDR { if nv <= (vl-1)/3 { face_ok = 1 } } } } }
  gv_check("FACE-present-with-non-empty-membership (count bound in the condition, an empty FACE cannot pass)" as *u8, face_ok, ctr)
294
  // every index must address a real vertex -- a membership list of garbage is not a face
  var idx_ok: i64 = 1
  var oob: i64 = 0
  let seen: *i64 = sys_mmap((vl+1)*MG_W) as *i64
  if face_ok == 1 {
      var i: i64 = 0
      while i < nface {
          let vi: i64 = mg_rd(d, fo + (MG_FACE_HDR + i)*MG_W)
          if vi < 0 { idx_ok = 0; oob = oob + 1 }
          else { if vi >= nv { idx_ok = 0; oob = oob + 1 } else { if seen[vi] != 0 { idx_ok = 0; oob = oob + 1 }; seen[vi] = 1 } }
          i = i + 1
      }
  } else { idx_ok = 0 }
  gv_puts("  face indices out of range=" as *u8); gv_num(oob); gv_puts("\n" as *u8)
  gv_check("every-FACE-index-addresses-a-real-vertex" as *u8, idx_ok, ctr)
310
  // ---- MORF declares every channel with a NON-EMPTY support ---------------------------------
  var nchan: i64 = 0
  var nrows: i64 = 0
  var unit: i64 = 0
  if mo >= 0 {
      nchan = mg_rd(d, mo)
      nrows = mg_rd(d, mo + MG_W)
      unit = mg_rd(d, mo + MG_W*3)
  }
  gv_puts("  channels=" as *u8); gv_num(nchan)
  gv_puts(" rows=" as *u8); gv_num(nrows)
  gv_puts(" unit=" as *u8); gv_num(unit); gv_puts("\n" as *u8)
  var morf_ok: i64 = 0
  if expected_count > 0 { if nchan == expected_count { if nrows == nface { if unit == MG_UNIT {
      if mg_rd(d, mo+MG_W*2) == 3 {
          if nchan <= (ml-MG_MORF_HDR)/MG_CHANREC {
              let available: i64 = ml-MG_MORF_HDR-nchan*MG_CHANREC
              if nrows > 0 { if nrows <= available/3/nchan { morf_ok = 1 } }
          }
      }
  } } } }
  gv_check("MORF-shape-matches-all-config-channels-and-bounded-FACE-rows" as *u8, morf_ok, ctr)
  if face_ok == 0 { return gv_verdict("NX-NXA-MORF" as *u8, ctr, "invalid FACE" as *u8) }
  if idx_ok == 0 { return gv_verdict("NX-NXA-MORF" as *u8, ctr, "invalid membership" as *u8) }
  if morf_ok == 0 { return gv_verdict("NX-NXA-MORF" as *u8, ctr, "invalid MORF" as *u8) }
  var tags_ok: i64 = 1; var allsup: i64 = 1; var selected: i64 = 0 - 1
  let db: i64 = mo+(MG_MORF_HDR+nchan*MG_CHANREC)*MG_W
  var c: i64 = 0
  while c < nchan {
      let ro: i64 = mo+(MG_MORF_HDR+c*MG_CHANREC)*MG_W
      if mg_rd(d,ro) != tags[c] { tags_ok = 0 }
      let sup: i64 = mg_rd(d,ro+MG_W)
      if sup <= 0 { allsup = 0 }; if sup > nface { allsup = 0 }
      var nonzero: i64 = 0; var i: i64 = 0
      while i < nface {
          var a: i64 = 0; var any: i64 = 0
          while a < 3 { if mg_rd(d,db+((c*nface+i)*3+a)*MG_W) != 0 { any = 1 }; a = a + 1 }
          if any == 1 { nonzero = nonzero + 1 }; i = i + 1
      }
      gv_puts("  channel=" as *u8); gv_num(c); gv_puts(" support=" as *u8); gv_num(sup)
      gv_puts(" nonzero_delta_vertices=" as *u8); gv_num(nonzero); gv_puts("\n" as *u8)
      // A taper may legitimately make support-boundary deltas zero; an entirely
      // zero action still fails the original non-vacuity requirement.
      if nonzero == 0 { allsup = 0 }; if nonzero > sup { allsup = 0 }
      if selected < 0 { if nonzero > 0 { selected = c } }
      c = c + 1
  }
  gv_check("every-channel-tag-matches-ordered-config" as *u8, tags_ok, ctr)
  gv_check("every-declared-channel-has-bounded-nonempty-support-and-real-deltas" as *u8, allsup, ctr)
  gv_check("a-nonzero-channel-is-selected-from-the-actual-asset" as *u8, selected >= 0, ctr)
  var exact: i64 = 0
  if selected >= 0 {
      let spec: *u8 = sys_mmap(256)
      var so: i64 = gk_catn(spec, 0, selected)
      so = gk_cat(spec, so, ":" as *u8); so = gk_catn(spec, so, unit); spec[so] = 0 as u8
      let rc2: i64 = gk_run_capture(subject, "eval" as *u8, d1path, eupath, spec, buf, MG_CAP, bl)
      gv_check("eval-at-asset-unit-exits-zero" as *u8, rc2 == 0, ctr)
      if rc2 == 0 { exact = mg_eval_exact(d,fo,mo,vo,nv,nface,nchan,selected,eupath) }
  }
  gv_check("actual-VERT-equals-stored-deltas-and-all-non-FACE-vertices-unchanged" as *u8, exact, ctr)
371
  // ---- a zero weight must be a PROVEN no-op, byte for byte ----------------------------------
  let rc3: i64 = gk_run_capture(subject, "eval" as *u8, d1path, e0path, MG_SPEC_ZERO, buf, MG_CAP, bl)
  var zero_same: i64 = 0
  if rc3 == 0 { zero_same = mg_same(d1path, e0path) }
  gv_check("zero-weight-output-is-BYTE-IDENTICAL-to-its-input (size equality is not identity)" as *u8, zero_same, ctr)
377
  // ---- determinism --------------------------------------------------------------------------
  let rc4: i64 = gk_run_capture(subject, "derive" as *u8, MG_PRE, d2path, 0 as *u8, buf, MG_CAP, bl)
  var det: i64 = 0
  if rc4 == 0 { det = mg_same(d1path, d2path) }
  gv_check("derive-is-deterministic (two runs, byte-identical)" as *u8, det, ctr)
383
  // ---- neg-control: the banked pre-change asset genuinely lacks both sections ----------------
  let lp2: *i64 = sys_mmap(16) as *i64
  let p: *u8 = sys_read_file(MG_PRE, lp2)
  var pre_lacks: i64 = 0
  if (p as i64) != 0 { if mg_container(p, lp2[0]) == 1 {
      let pns: i64 = mg_nsec(p)
      var hasf: i64 = 0
      var hasm: i64 = 0
      if mg_sec(p, pns, "FACE" as *u8) >= 0 { hasf = 1 }
      if mg_sec(p, pns, "MORF" as *u8) >= 0 { hasm = 1 }
      if hasf == 0 { if hasm == 0 { pre_lacks = 1 } }
      gv_puts("  pre-change asset sections=" as *u8); gv_num(pns)
      gv_puts(" FACE=" as *u8); gv_num(hasf)
      gv_puts(" MORF=" as *u8); gv_num(hasm); gv_puts("\n" as *u8)
  }
  }
  var derived_has: i64 = 0
  if fo >= 0 { if mo >= 0 { derived_has = 1 } }
  gv_bite("neg-control-pre-change-asset-lacks-FACE-and-MORF" as *u8, pre_lacks, 1 - derived_has, ctr)
403
  // ---- neg-control: a malformed channel spec must refuse BY NAME ----------------------------
  let rc5: i64 = gk_run_capture(subject, "eval" as *u8, d1path, badpath, MG_SPEC_BAD, buf, MG_CAP, bl)
  var refused: i64 = 0
  if rc5 != 0 { refused = gk_out_has(buf, bl[0], "MORF-REFUSE eval spec" as *u8) }
  let rc6: i64 = gk_run_capture(subject, "eval" as *u8, d1path, e0path, MG_SPEC_ZERO, buf, MG_CAP, bl)
  var good_refused: i64 = 0
  if rc6 != 0 { good_refused = 1 }
  gv_bite("neg-control-malformed-channel-spec-refused-by-name" as *u8, refused, good_refused, ctr)
412
  return gv_verdict("NX-NXA-MORF" as *u8, ctr, "config-bound channels carry real deltas; actual vertices match the stored full-weight displacement" as *u8)
414}
nx_nxa_morf_gate.nx source

`nx_nxa_morf_gate.nx` source
