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

↩ module page · 350 lines · 19792 B
1// nx_relief_bands_gate.nx -- THE MULTI-BAND MICRO-RELIEF LAW AND THE DISCRETE PORE LAYER, GATED.
2// /compare/graphics C5, symbol rlf_pore_mask. Subject: nx_relief_lib.
3//
4// WHAT THIS GATE IS FOR. nx_relief_lib grew from one spatial band to three on 2026-08-28. Three
5// bands is three amplitudes and three wavelengths, and six numbers with nothing checking them is
6// exactly the shape rule 11 exists to stop. So every claim the new code makes is a tooth here, and
7// each tooth is a property the WRONG implementations provably cannot satisfy:
8//   * a band table that drifted from its conf ledger        -> dies at T7
9//   * a "pore layer" that is really a fourth noise octave   -> dies at T5 (coverage, bite-proven)
10//   * a mask that ignores the orifice diameter              -> dies at T6 (bite-proven at r=0)
11//   * a band 1 rigged by amplitude rather than wavelength   -> dies at T3 (bite-proven)
12//   * an addition that disturbed the shipped single-band    -> dies at T2
13//   * a second tilt convention for the new bands            -> dies at T1
14//   * a resolution claim that flatters the whole-body atlas -> dies at T8, which asserts the
15//                                                              UNFLATTERING direction as well
16// T5 is the load-bearing tooth for the MECHANISM and its bar is not a constant: it is the coverage
17// the model itself DERIVES (pi r^2 over the cell), measured at TWO different lattice scales, so a
18// field that is not a sparse disc layer cannot agree with it twice.
19// license_tier: ORIGINAL  expect_exit: 0   No hw writes (Rule 26).
20import "nx_syscalls.nx"
21import "nx_gate_verdict.nx"
22import "nx_relief_lib.nx"
23
24// the shader's unit-normal scale, mirrored. EVERY tilt function here is linear in it, so this
25// choice cannot flatter any result -- it only sets the units the numbers are printed in.
26const RB_N_FULL: i64 = 256
27// FIXTURE, NOT A CLAIM ABOUT PRODUCTION (corrected 2026-08-29). This is the TOP rung of the ship
28// ladder, chosen deliberately so every verdict below holds A FORTIORI: a band the LARGEST
29// whole-body atlas cannot carry, no smaller one can either. What actually ships is NOT fixed
30// here -- txm_ship_res (nx_nxa_texm.nx) descends 4096/2048/1024/512 by TEXTURE-MEMORY budget
31// alone with no physical term, so the shipped rung follows knowledge/asset_texture_floor.conf
32// and was measured at 2048 on the live cast. The previous comment asserted this WAS the shipped
33// resolution, which was false and is the stale-name-list defect wearing a const comment: a gate
34// that hardcodes what production "actually" does states something that will outlive its truth.
35const RB_RES_BODY: i64 = 4096
36// a face-sized region, 250 mm across. A FIXTURE SCALE for the published table, NOT a law: every
37// span-taking function below accepts any span, and the tooth that matters asserts the boundary.
38const RB_FACE_UM: i64 = 250000
39const RB_CELL_A: i64 = 64          // two lattice scales for the coverage measurement. A sparse disc
40const RB_CELL_B: i64 = 128         // layer has the SAME coverage at both; a noise octave does not.
41const RB_SWEEP_A: i64 = 512        // 8x8 = 64 cells at RB_CELL_A
42const RB_SWEEP_B: i64 = 1024       // 8x8 = 64 cells at RB_CELL_B
43// agreement tolerance between the DERIVED coverage and the MEASURED one, in permil of surface.
44// DECLARED IMPRECISION: a disc of radius r is measured on an integer grid, so a finite sweep
45// quantises its area. This is that quantisation, not slack for a wrong model.
46const RB_TOL_PERMIL: i64 = 4
47const RB_SEED: i64 = 20260828
48const RB_BUF: i64 = 256
49const RB_CONF_A: *u8 = "knowledge/relief_bands.conf"
50const RB_CONF_B: *u8 = "buildroot/knowledge/relief_bands.conf"
51
52func rb_slen(s: *u8) -> i64 { var n: i64 = 0; while s[n] != (0 as u8) { n = n + 1 } return n }
53func rb_abs(v: i64) -> i64 { if v < 0 { return 0 - v } return v }
54func rb_max2(a: i64, b: i64) -> i64 { if a > b { return a } return b }
55
56// substring search. Returns the offset, or -1.
57func rb_find(hay: *u8, hn: i64, ndl: *u8, nn: i64) -> i64 {
  if nn <= 0 { return 0 - 1 }
  var i: i64 = 0
  while i + nn <= hn {
      var j: i64 = 0
      var ok: i64 = 1
      while j < nn {
          if hay[i + j] != ndl[j] { ok = 0; j = nn } else { j = j + 1 }
      }
      if ok == 1 { return i }
      i = i + 1
  }
  return 0 - 1
70}
71
72// build the conf row a band's CONSTS imply. The row is composed FROM the consts, so finding it in
73// the ledger is a real coupling and not a comparison of two hand-typed strings.
74func rb_row(d: *u8, id: i64, name: *u8, amp: i64, lam: i64) -> i64 {
  var p: i64 = gv_cat(d, 0, "band|" as *u8)
  p = gv_catn(d, p, id)
  p = gv_cat(d, p, "|" as *u8)
  p = gv_cat(d, p, name)
  p = gv_cat(d, p, "|" as *u8)
  p = gv_catn(d, p, amp)
  p = gv_cat(d, p, "|" as *u8)
  p = gv_catn(d, p, lam)
  p = gv_cat(d, p, "|" as *u8)
  d[p] = 0 as u8
  return p
86}
87
88// THE PARAMETRIC MASK: what rlf_pore_mask would be at an arbitrary pit radius. rlf_pore_mask IS
89// this at rlf_pore_radius(), and T4 pins that identity -- so this is a knob on the SHIPPED
90// function, never a second implementation of it.
91func rb_mask_at_r(x: i64, y: i64, cell: i64, r: i64) -> i64 {
  if r <= 0 { return 0 }
  let r2: i64 = r * r
  let d2: i64 = rlf_pore_d2(x, y, cell)
  if d2 >= r2 { return 0 }
  return (r2 - d2) * RLF_H_RANGE / r2
97}
98// measured pore coverage over a contiguous n x n sweep, in permil of surface, at pit radius r.
99func rb_cover_permil(cell: i64, n: i64, r: i64) -> i64 {
  var hits: i64 = 0
  var i: i64 = 0
  while i < n {
      var j: i64 = 0
      while j < n {
          if rb_mask_at_r(i, j, cell, r) > 0 { hits = hits + 1 }
          j = j + 1
      }
      i = i + 1
  }
  return hits * 1000 / (n * n)
111}
112// 1 = the measured coverage does not agree with what the disc model derives.
113func rb_cover_wrong(measured: i64, derived: i64) -> i64 {
  if rb_abs(measured - derived) > RB_TOL_PERMIL { return 1 }
  return 0
116}
117// 1 = a band of this shape does NOT out-tilt band 0.
118func rb_not_outtilt(a_um: i64, lambda_um: i64) -> i64 {
  if rlf_band_tilt_full(RB_N_FULL, a_um, lambda_um) <= rlf_tilt_full(RB_N_FULL) { return 1 }
  return 0
121}
122
123func main() -> i64 {
  let ctr: *i64 = gv_ctr()
  gv_head("nx_relief_bands_gate -- multi-band micro-relief and the discrete pore layer" as *u8)
126
  let t0b: i64 = rlf_tilt_full(RB_N_FULL)
  let t1b: i64 = rlf_band_tilt_full(RB_N_FULL, RLF_SEC_UM, RLF_SEC_LAMBDA_UM)
  let tpb: i64 = rlf_pore_tilt_full(RB_N_FULL)
  let rad: i64 = rlf_pore_radius()
  let derived: i64 = rlf_pore_area_permil()
  gv_puts("  band tilts of " as *u8); gv_num(RB_N_FULL)
  gv_puts(": primary(" as *u8); gv_num(RLF_RELIEF_UM); gv_puts("um/" as *u8); gv_num(RLF_RELIEF_LAMBDA_UM)
  gv_puts("um)=" as *u8); gv_num(t0b)
  gv_puts("  secondary(" as *u8); gv_num(RLF_SEC_UM); gv_puts("um/" as *u8); gv_num(RLF_SEC_LAMBDA_UM)
  gv_puts("um)=" as *u8); gv_num(t1b)
  gv_puts("  pore-rim(" as *u8); gv_num(RLF_PORE_UM); gv_puts("um/" as *u8); gv_num(RLF_PORE_DIA_UM)
  gv_puts("um)=" as *u8); gv_num(tpb); gv_puts("\n" as *u8)
  gv_puts("  pore radius=" as *u8); gv_num(rad)
  gv_puts(" of " as *u8); gv_num(RLF_UNIT)
  gv_puts(" per cell, derived coverage=" as *u8); gv_num(derived); gv_puts(" permil\n" as *u8)
142
  // ---- T0 THE FIXTURE MUST REACH THE CONDITION. If the pit radius is degenerate or no pit is
  // ever hit in the sweep, every tooth below is vacuous and passing them would mean nothing.
  let covA: i64 = rb_cover_permil(RB_CELL_A, RB_SWEEP_A, rad)
  let covB: i64 = rb_cover_permil(RB_CELL_B, RB_SWEEP_B, rad)
  var t0: i64 = 1
  if rad <= 0 { t0 = 0 }
  if covA <= 0 { t0 = 0 }
  if covB <= 0 { t0 = 0 }
  gv_puts("  measured coverage: cell " as *u8); gv_num(RB_CELL_A); gv_puts(" -> " as *u8); gv_num(covA)
  gv_puts(" permil, cell " as *u8); gv_num(RB_CELL_B); gv_puts(" -> " as *u8); gv_num(covB)
  gv_puts(" permil (derived " as *u8); gv_num(derived); gv_puts(")\n" as *u8)
  gv_check("T0 fixture-pit-radius-positive-and-pits-actually-hit-at-both-scales" as *u8, t0, ctr)
155
  // ---- T1 ONE RULER. The general per-band tilt function must reproduce the shipped single-band
  // one EXACTLY at band 0, over the whole scale, or the new bands are being measured by a second
  // convention and no comparison between them means anything.
  var t1: i64 = 1
  var n: i64 = 1
  while n <= RB_N_FULL {
      if rlf_band_tilt_full(n, RLF_RELIEF_UM, RLF_RELIEF_LAMBDA_UM) != rlf_tilt_full(n) { t1 = 0 }
      n = n + 1
  }
  gv_check("T1 band-tilt-is-the-shipped-tilt-at-band-0-over-the-whole-scale" as *u8, t1, ctr)
166
  // ---- T2 THE ADDITION DISTURBED NOTHING. nx_sdfrender_sss_gate's T1 (flat skin bit-exact) and
  // T4 (shader field IS baker field) both rest on these two functions. Re-derived here from the
  // primitive, so a change to either would surface HERE rather than as a mystery in the shader.
  var t2: i64 = 1
  var i2: i64 = 0
  while i2 < 128 {
      let x: i64 = i2 * 7
      let y: i64 = i2 * 11
      if rlf_relief_h(x, y, RB_RES_BODY, RB_SEED) != rlf_noise3(x, y, RB_SEED, rlf_relief_lat(RB_RES_BODY)) { t2 = 0 }
      if rlf_relief_h3(x, y, RB_SEED, 18) != rlf_noise3(x, y, RB_SEED, 18) { t2 = 0 }
      i2 = i2 + 1
  }
  gv_check("T2 single-band-path-unchanged-by-the-addition" as *u8, t2, ctr)
180
  // ---- T3 ASPECT RATIO DOMINATES DEPTH. Band 1 must be strictly SHALLOWER than band 0 and still
  // carry strictly MORE tilt. Both conjuncts, because either alone is not the claim: a deeper
  // band out-tilting a shallower one would be unremarkable, and this rung's whole argument is
  // that fineness beats depth.
  var t3: i64 = 1
  if RLF_SEC_UM >= RLF_RELIEF_UM { t3 = 0 }
  if t1b <= t0b { t3 = 0 }
  gv_check("T3 secondary-band-is-shallower-than-primary-AND-out-tilts-it" as *u8, t3, ctr)
189
  // ---- T4 THE PARAMETRIC MASK IS THE SHIPPED MASK. Pins rb_mask_at_r to rlf_pore_mask at the
  // real radius, so T5's and T6's knob turns the SHIPPED function and not a lookalike.
  var t4: i64 = 1
  var i4: i64 = 0
  while i4 < RB_SWEEP_A {
      if rb_mask_at_r(i4, i4 * 3, RB_CELL_A, rad) != rlf_pore_mask(i4, i4 * 3, RB_CELL_A) { t4 = 0 }
      i4 = i4 + 1
  }
  gv_check("T4 parametric-mask-is-bit-identical-to-the-shipped-mask-at-the-real-radius" as *u8, t4, ctr)
199
  // ---- T5 THE LOAD-BEARING TOOTH: THIS IS A SPARSE DISC LAYER, NOT A NOISE OCTAVE. The measured
  // coverage must match what pi*r^2/cell^2 derives, AT TWO DIFFERENT LATTICE SCALES. A noise
  // field can be made to hit one number by tuning a threshold; it cannot be scale-invariant at a
  // coverage the disc model derived independently.
  var t5: i64 = 1
  if rb_cover_wrong(covA, derived) == 1 { t5 = 0 }
  if rb_cover_wrong(covB, derived) == 1 { t5 = 0 }
  gv_check("T5 pore-coverage-matches-the-derived-disc-area-at-two-lattice-scales" as *u8, t5, ctr)
208
  // ---- T6 THE PROFILE FALLS OFF WITH DISTANCE, and is bounded by the codomain. Recorded as the
  // nearest and furthest still-lit samples in the sweep, so it measures the real field.
  var mind2: i64 = RLF_PORE_D2_INF
  var maxd2: i64 = 0 - 1
  var mmin: i64 = 0
  var mmax: i64 = 0
  var over: i64 = 0
  var i6: i64 = 0
  while i6 < RB_SWEEP_B {
      var j6: i64 = 0
      while j6 < 64 {
          let m: i64 = rlf_pore_mask(i6, j6, RB_CELL_B)
          if m > RLF_H_RANGE { over = 1 }
          if m < 0 { over = 1 }
          if m > 0 {
              let d: i64 = rlf_pore_d2(i6, j6, RB_CELL_B)
              if d < mind2 { mind2 = d; mmin = m }
              if d > maxd2 { maxd2 = d; mmax = m }
          }
          j6 = j6 + 1
      }
      i6 = i6 + 1
  }
  var t6: i64 = 1
  if over == 1 { t6 = 0 }
  if maxd2 < 0 { t6 = 0 }
  if mmin <= mmax { t6 = 0 }
  gv_puts("  profile: nearest lit sample d2=" as *u8); gv_num(mind2); gv_puts(" mask=" as *u8); gv_num(mmin)
  gv_puts(" | furthest lit d2=" as *u8); gv_num(maxd2); gv_puts(" mask=" as *u8); gv_num(mmax); gv_puts("\n" as *u8)
  gv_check("T6 mask-falls-off-with-distance-and-stays-inside-the-codomain" as *u8, t6, ctr)
239
  // ---- T7 RESOLUTION HONESTY, ASSERTED IN THE UNFLATTERING DIRECTION TOO. On the whole-body
  // atlas the estate actually bakes, BOTH new bands must be reported as NOT carried -- a rung
  // that claimed otherwise would be flattering itself. On a face-sized region at the resolution
  // rlf_band_res_needed names, both must be carried. A tooth that only checked the good news
  // would pass for an organ that always returned 1.
  let needSecBody: i64 = rlf_band_res_needed(RLF_BODY_UM, RLF_SEC_LAMBDA_UM)
  let needSecFace: i64 = rlf_band_res_needed(RB_FACE_UM, RLF_SEC_LAMBDA_UM)
  let needPorFace: i64 = rlf_band_res_needed(RB_FACE_UM, RLF_PORE_PITCH_UM)
  var t7: i64 = 1
  if rlf_band_resolvable(RB_RES_BODY, RLF_SEC_LAMBDA_UM) != 0 { t7 = 0 }
  if rlf_band_resolvable(RB_RES_BODY, RLF_PORE_PITCH_UM) != 0 { t7 = 0 }
  if rlf_band_resolvable_span(RB_FACE_UM, needSecFace, RLF_SEC_LAMBDA_UM) != 1 { t7 = 0 }
  if rlf_band_resolvable_span(RB_FACE_UM, needPorFace, RLF_PORE_PITCH_UM) != 1 { t7 = 0 }
  gv_puts("  whole-body atlas " as *u8); gv_num(RB_RES_BODY)
  gv_puts(": texel=" as *u8); gv_num(rlf_texel_um(RB_RES_BODY))
  gv_puts("um -> secondary carried=" as *u8); gv_num(rlf_band_resolvable(RB_RES_BODY, RLF_SEC_LAMBDA_UM))
  gv_puts(" pore carried=" as *u8); gv_num(rlf_band_resolvable(RB_RES_BODY, RLF_PORE_PITCH_UM))
  gv_puts("\n  RES NEEDED: secondary over a whole body=" as *u8); gv_num(needSecBody)
  gv_puts(", over a " as *u8); gv_num(RB_FACE_UM / 1000); gv_puts("mm face=" as *u8); gv_num(needSecFace)
  gv_puts("; pore over that face=" as *u8); gv_num(needPorFace); gv_puts("\n" as *u8)
  gv_check("T7 new-bands-declared-ABSENT-on-the-whole-body-atlas-and-PRESENT-per-region" as *u8, t7, ctr)
261
  // ---- T8 THE WHOLE-BODY PREDICATE IS THE SPAN PREDICATE AT THE BODY SPAN. One ruler again:
  // without this the two could disagree and each would look right on its own.
  var t8: i64 = 1
  var r8: i64 = 512
  while r8 <= 16384 {
      if rlf_band_resolvable(r8, RLF_SEC_LAMBDA_UM) != rlf_band_resolvable_span(RLF_BODY_UM, r8, RLF_SEC_LAMBDA_UM) { t8 = 0 }
      if rlf_texel_um(r8) != rlf_texel_um_span(RLF_BODY_UM, r8) { t8 = 0 }
      r8 = r8 + 512
  }
  gv_check("T8 whole-body-resolvability-is-the-span-form-at-the-body-span" as *u8, t8, ctr)
272
  // ---- T9 THE COMPOSED HEIGHT STAYS INSIDE THE ENVELOPE ITS OWN CONSTS DECLARE, and the total
  // is the sum of the three bands. The compiler takes literal const initialisers only, so that
  // relationship cannot be written as arithmetic in the lib -- it is pinned here instead.
  var t9: i64 = 1
  if rlf_total_um() != RLF_RELIEF_UM + RLF_SEC_UM + RLF_PORE_UM { t9 = 0 }
  var lo9: i64 = 0
  var hi9: i64 = 0
  var i9: i64 = 0
  while i9 < 512 {
      let u: i64 = rlf_relief_um2(i9 * 5, i9 * 3, RB_RES_BODY, RB_SEED)
      if u < lo9 { lo9 = u }
      if u > hi9 { hi9 = u }
      i9 = i9 + 1
  }
  if lo9 < 0 - RLF_PORE_UM { t9 = 0 }
  if hi9 > RLF_RELIEF_UM + RLF_SEC_UM { t9 = 0 }
  gv_puts("  composed height over the sweep: " as *u8); gv_num(lo9); gv_puts(" .. " as *u8); gv_num(hi9)
  gv_puts(" um, envelope -" as *u8); gv_num(RLF_PORE_UM); gv_puts(" .. " as *u8)
  gv_num(RLF_RELIEF_UM + RLF_SEC_UM); gv_puts("\n" as *u8)
  gv_check("T9 composed-height-inside-its-declared-envelope-and-total-reconciles" as *u8, t9, ctr)
293
  // ---- T10 THE BANDS AGREE WITH THEIR PROVENANCE LEDGER. Each expected row is COMPOSED FROM
  // THE CONSTS, so this is a real coupling rather than two hand-typed strings compared. If the
  // ledger cannot be read from this working directory the gate ABSTAINS -- it does not acquit.
  let cn: *i64 = sys_mmap(8) as *i64
  cn[0] = 0
  var cbuf: *u8 = sys_read_file(RB_CONF_A, cn)
  var csrc: i64 = 1
  if cn[0] <= 0 { cbuf = sys_read_file(RB_CONF_B, cn); csrc = 2 }
  var present: i64 = 0
  if cn[0] > 0 { present = 1 }
  gv_puts("  band ledger: " as *u8)
  if csrc == 1 { gv_puts(RB_CONF_A) } else { gv_puts(RB_CONF_B) }
  gv_puts(" bytes=" as *u8); gv_num(cn[0]); gv_puts("\n" as *u8)
  if gv_need("relief_bands.conf readable from this working directory" as *u8, present, ctr) == 1 {
      let row: *u8 = sys_mmap(RB_BUF) as *u8
      var t10: i64 = 1
      rb_row(row, 0, "primary" as *u8, RLF_RELIEF_UM, RLF_RELIEF_LAMBDA_UM)
      if rb_find(cbuf, cn[0], row, rb_slen(row)) < 0 { t10 = 0 }
      rb_row(row, 1, "secondary" as *u8, RLF_SEC_UM, RLF_SEC_LAMBDA_UM)
      if rb_find(cbuf, cn[0], row, rb_slen(row)) < 0 { t10 = 0 }
      rb_row(row, 2, "pore" as *u8, RLF_PORE_UM, RLF_PORE_PITCH_UM)
      if rb_find(cbuf, cn[0], row, rb_slen(row)) < 0 { t10 = 0 }
      var p2: i64 = gv_cat(row, 0, "pore_dia|" as *u8)
      p2 = gv_catn(row, p2, RLF_PORE_DIA_UM)
      p2 = gv_cat(row, p2, "|" as *u8)
      row[p2] = 0 as u8
      if rb_find(cbuf, cn[0], row, rb_slen(row)) < 0 { t10 = 0 }
      gv_check("T10 every-band-const-has-a-matching-row-in-the-provenance-ledger" as *u8, t10, ctr)
322
      // ---- T11 A BAND MAY NOT ACQUIRE A NUMBER WITH NO SOURCE FIELD AT ALL. UNPINNED is a legal
      // and honest source; a MISSING one is not. This is what stops the ledger from decaying into
      // a list of numbers that happens to match the code.
      var t11: i64 = 1
      if rb_find(cbuf, cn[0], "|nx_relief_lib-2026-08-25" as *u8, 25) < 0 { t11 = 0 }
      if rb_find(cbuf, cn[0], "|UNPINNED" as *u8, 9) < 0 { t11 = 0 }
      gv_check("T11 ledger-carries-a-source-field-for-every-band-pinned-or-honestly-UNPINNED" as *u8, t11, ctr)
  }
331
  // ---- NEGATIVE CONTROLS. Each fires on the wrong implementation and is silent on the shipped
  // one, which is the only evidence that the tooth above it can fail at all.
  // (1) a field that covers all of the skin is a noise octave, not a pore layer.
  gv_bite("neg-control-a-field-covering-the-whole-surface-is-not-a-pore-layer" as *u8,
          rb_cover_wrong(1000, derived), rb_cover_wrong(covB, derived), ctr)
  // (2) the mask must be DRIVEN by the orifice diameter. At zero radius it must vanish entirely;
  // an implementation returning a constant, or ignoring r, keeps its coverage and dies here.
  gv_bite("neg-control-a-mask-that-ignores-the-orifice-diameter-cannot-vanish-at-r-zero" as *u8,
          rb_cover_wrong(rb_cover_permil(RB_CELL_B, RB_SWEEP_A, 0), derived),
          rb_cover_wrong(covB, derived), ctr)
  // (3) T3 is about the WAVELENGTH, not a rigged amplitude: band 1's own depth at band 0's
  // wavelength must FAIL to out-tilt band 0, while band 1's real wavelength succeeds.
  gv_bite("neg-control-band-1-depth-at-band-0-wavelength-cannot-out-tilt-band-0" as *u8,
          rb_not_outtilt(RLF_SEC_UM, RLF_RELIEF_LAMBDA_UM),
          rb_not_outtilt(RLF_SEC_UM, RLF_SEC_LAMBDA_UM), ctr)
347
  return gv_verdict("nx_relief_bands_gate" as *u8, ctr,
      "micro-relief carries three bands with a provenance ledger a gate checks: the secondary band is a third the depth of the primary and carries more tilt because slope follows the aspect ratio, and the pore layer is a sparse jittered-grid disc field whose coverage matches the area its own model derives at two lattice scales. The single-band path shipped on 2026-08-25 is untouched. Where a band cannot be carried the organ says so: on the whole-body atlas both new bands are reported ABSENT, and the resolution that would carry them is published rather than assumed." as *u8)
350}
nx_relief_bands_gate.nx source

`nx_relief_bands_gate.nx` source
