nx_compare_rank_fleet.nx source
↩ module page · 319 lines · 19744 B
1// nx_compare_rank_fleet.nx -- PROVE THE RANKING ENGINE ON EVERY COMPARE, and publish the estate
2// portfolio (PR9). Operator 2026-08-18: "prove it on every compare to show that this engine and system
3// makes logical sense ... drive us to a true width and breadth compare sota and best of breed using
4// mechanical provable repeatable capabilities."
5//
6// Whole population, no sampling: every domain in regen.list is visited. Partition (printed, sums):
7// RANKED -- has a .plan with rung rows: nx_compare_rank ran, its critical path and top rung
8// are captured, its comparerank- plane is published by the ranker itself.
9// NO-LADDER -- ranked, but the plan has no ver| rows: the ranker labeled it "ranking by value
10// alone"; the fix is a data row, and this census NAMES the domain so it is a worklist.
11// NO-PLAN -- a .matrix but no .plan: a capability census with NO roadmap the engine can drive.
12// This is the width-and-breadth gap by name: the compare knows what we lack versus the
13// field but has not declared what to build first. Fix = a plan (rungs + ver ladder).
14// NO-MATRIX -- listed in regen.list but no matrix: a hub card with nothing measured behind it.
15// FAILED -- the ranker exited nonzero or printed nothing: the engine itself is the blocker;
16// the exit code and last line are printed so the team can act.
17// Then the PORTFOLIO: every RANKED domain's critical-path #1 rung is fed to nx_dr_ocm ONCE MORE across
18// domains (value = its printed priority as the estate-comparable score, momentum 1, cost = its printed
19// c), so the estate-wide next-actions are one ordered list, and that list is written to the
20// portfolio- plane (id=<domain>/<rung>) and its top rows filed into pm intake. Sponsorship already
21// rode inside each domain's priority; a domain-scoped sponsor row therefore lifts that domain's #1
22// across the estate, which is exactly what a domain-level verdict means.
23//
24// usage: nx_compare_rank_fleet [budget_tenths] (runs from nishihost cwd; forks ./nx_compare_rank.elf
25// or the _build twin, ./nx_dr_ocm_cli.elf, ./nx_store_put.elf, ./nx_pm_intake.elf)
26// exit: 0 (census printed; the verdict is the partition, not a pass/fail -- a NO-PLAN domain is a
27// worklist row, not a failure of this organ) | 3 regen.list unreadable
28// license_tier: ORIGINAL No hw writes (Rule 26).
29import "nx_syscalls.nx"
30import "nx_tool_run.nx"
31
32const RF_MAX_DOM: i64 = 128
33const RF_CAP: i64 = 262144
34const RF_LIST_CAP: i64 = 16384
35const RF_TIMEOUT_MS: i64 = 280000
36const RF_PM_TOP: i64 = 5 // estate-level intake rows per run
37const RF_DEFAULT_BUDGET: i64 = 300
38
39func rf_slen(s: *u8) -> i64 { var n: i64 = 0; while s[n] != (0 as u8) { n = n + 1 } return n }
40func rf_puts(s: *u8) -> i64 { sys_write(1, s, rf_slen(s)); return 0 }
41func rf_pn(v: i64) -> i64 {
42 let t: *u8 = sys_mmap(32) as *u8
43 var m: i64 = v; var w: i64 = 0
44 if m < 0 { t[w] = 45 as u8; w = w + 1; m = 0 - m }
45 if m == 0 { t[w] = 48 as u8; sys_write(1, t, w + 1); return 0 }
46 let d: *u8 = sys_mmap(32) as *u8
47 var k: i64 = 0
48 while m > 0 { d[k] = (48 + (m % 10)) as u8; m = m / 10; k = k + 1 }
49 var j: i64 = 0
50 while j < k { t[w] = d[k-1-j]; w = w + 1; j = j + 1 }
51 sys_write(1, t, w); return 0
52}
53func rf_cat(d: *u8, o: i64, s: *u8) -> i64 { var i: i64 = 0; var oo: i64 = o; while s[i] != (0 as u8) { d[oo] = s[i]; oo = oo + 1; i = i + 1 } d[oo] = 0 as u8; return oo }
54func rf_catn(d: *u8, o: i64, v: i64) -> i64 {
55 let t: *u8 = sys_mmap(32) as *u8
56 var m: i64 = v; var k: i64 = 0; var oo: i64 = o
57 if m < 0 { d[oo] = 45 as u8; oo = oo + 1; m = 0 - m }
58 if m == 0 { d[oo] = 48 as u8; oo = oo + 1; d[oo] = 0 as u8; return oo }
59 while m > 0 { t[k] = (48 + (m % 10)) as u8; m = m / 10; k = k + 1 }
60 while k > 0 { k = k - 1; d[oo] = t[k]; oo = oo + 1 }
61 d[oo] = 0 as u8
62 return oo
63}
64func rf_read(path: *u8, b: *u8, cap: i64) -> i64 {
65 let fd: i64 = sys_openat_rd(path)
66 if fd < 0 { return 0 - 1 }
67 var n: i64 = 0
68 var go: i64 = 1
69 while go == 1 { let r: i64 = sys_read(fd, (b as i64 + n) as *u8, cap - n); if r > 0 { n = n + r } else { go = 0 } if n >= cap { go = 0 } }
70 sys_close(fd)
71 return n
72}
73func rf_exists(path: *u8) -> i64 { let fd: i64 = sys_openat_rd(path); if fd < 0 { return 0 } sys_close(fd); return 1 }
74func rf_find(hay: *u8, hlen: i64, needle: *u8) -> i64 {
75 let nl: i64 = rf_slen(needle)
76 var i: i64 = 0
77 while i + nl <= hlen {
78 var k: i64 = 0; var same: i64 = 1
79 while k < nl { if hay[i+k] != needle[k] { same = 0; k = nl } k = k + 1 }
80 if same == 1 { return i }
81 i = i + 1
82 }
83 return 0 - 1
84}
85func rf_int_after(hay: *u8, hlen: i64, needle: *u8) -> i64 {
86 let p: i64 = rf_find(hay, hlen, needle)
87 if p < 0 { return 0 - 1 }
88 var j: i64 = p + rf_slen(needle)
89 var v: i64 = 0; var any: i64 = 0; var go: i64 = 1
90 while go == 1 { if j < hlen { let c: i64 = hay[j] as i64; if c >= 48 { if c <= 57 { v = v * 10 + (c - 48); any = 1; j = j + 1 } else { go = 0 } } else { go = 0 } } else { go = 0 } }
91 if any == 0 { return 0 - 1 }
92 return v
93}
94// copy the token after needle up to a space or newline into dst
95func rf_tok_after(hay: *u8, hlen: i64, needle: *u8, dst: *u8, dcap: i64) -> i64 {
96 dst[0] = 0 as u8
97 let p: i64 = rf_find(hay, hlen, needle)
98 if p < 0 { return 0 }
99 var j: i64 = p + rf_slen(needle)
100 var o: i64 = 0
101 while j < hlen { let c: i64 = hay[j] as i64; if c == 32 { j = hlen } else { if c == 10 { j = hlen } else { if o < dcap - 1 { dst[o] = hay[j]; o = o + 1 } j = j + 1 } } }
102 dst[o] = 0 as u8
103 return o
104}
105
106// EVERY ROW APPENDS AS IT IS DECIDED (2026-09-01). This organ accumulated all N domains into arrays and
107// printed the census only after the LAST ranker fork returned. Measured consequence: a run interrupted at
108// 95% yields exactly what one interrupted at 5% does -- its header and nothing else. That is not a corner
109// case here: each domain costs a fork of up to RF_TIMEOUT_MS (280s), so a full estate pass runs for hours
110// and the whole of it was staked on reaching the end. A LONG JOB THAT BUFFERS ITS OUTPUT HAS NO PARTIAL
111// RESULTS -- AN INTERRUPTION COSTS EVERYTHING, NOT THE REMAINDER.
112// This prints in the SAME order the census loop below walked, so a COMPLETED run's byte stream is unchanged
113// (provable by nx_behaveprobe live-vs-staged); only an INTERRUPTED run differs, and it differs from nothing
114// to every row it actually finished.
115func rf_emit_row_as_decided(dname: *i64, dclass: *i64, dtop: *i64, dstage: *i64, dpri: *i64, dcost: *i64, i2: i64) -> i64 {
116 let cl: i64 = dclass[i2]
117 rf_puts(" " as *u8); rf_puts(dname[i2] as *u8); rf_puts(": " as *u8)
118 if cl == 0 { rf_puts("RANKED top=" as *u8); rf_puts(dtop[i2] as *u8); rf_puts(" stage=" as *u8); rf_puts(dstage[i2] as *u8); rf_puts(" priority=" as *u8); rf_pn(dpri[i2]); rf_puts(" c=" as *u8); rf_pn(dcost[i2]) }
119 if cl == 1 { rf_puts("NO-LADDER (ranked by value alone) top=" as *u8); rf_puts(dtop[i2] as *u8); rf_puts(" priority=" as *u8); rf_pn(dpri[i2]); rf_puts(" -- UNBLOCK: add ver|0.1|<ms> rows to the .plan" as *u8) }
120 if cl == 2 { rf_puts("NO-PLAN -- a capability census with no roadmap the engine can drive; UNBLOCK: write <dom>.plan (rung rows + ver ladder)" as *u8) }
121 if cl == 3 { rf_puts("NO-MATRIX -- listed but nothing measured; UNBLOCK: admit a .matrix or retire the row" as *u8) }
122 if cl == 4 { rf_puts("FAILED -- the ranker printed nothing or no #1; UNBLOCK: run nx_compare_rank <dom> by hand and read its refusal" as *u8) }
123 rf_puts("\n" as *u8)
124 return 0
125}
126
127func main(argc: i64, argv: *i64) -> i64 {
128 var budget: i64 = RF_DEFAULT_BUDGET
129 if argc > 1 { var v: i64 = 0; let s: *u8 = argv[1] as *u8; var i: i64 = 0; while s[i] != (0 as u8) { let c: i64 = s[i] as i64; if c >= 48 { if c <= 57 { v = v * 10 + (c - 48) } } i = i + 1 } if v > 0 { budget = v } }
130 let lst: *u8 = sys_mmap(RF_LIST_CAP)
131 let ln: i64 = rf_read("buildroot/knowledge/compare/regen.list" as *u8, lst, RF_LIST_CAP)
132 if ln <= 0 { rf_puts("FLEET REFUSED: regen.list unreadable\n" as *u8); return 3 }
133 // ranker: promoted or build twin
134 var ranker: *u8 = "./nx_compare_rank.elf" as *u8
135 if rf_exists(ranker) == 0 { ranker = "./buildroot/_build/nx_compare_rank.sov.elf" as *u8 }
136 rf_puts("=== NX-COMPARE-RANK-FLEET ranker=" as *u8); rf_puts(ranker); rf_puts(" budget_tenths=" as *u8); rf_pn(budget); rf_puts("\n" as *u8)
137 // per-domain results
138 let dname: *i64 = sys_mmap(RF_MAX_DOM * 8) as *i64
139 let dclass: *i64 = sys_mmap(RF_MAX_DOM * 8) as *i64 // 0 RANKED 1 NO-LADDER 2 NO-PLAN 3 NO-MATRIX 4 FAILED
140 let dtop: *i64 = sys_mmap(RF_MAX_DOM * 8) as *i64 // top rung id string
141 let dpri: *i64 = sys_mmap(RF_MAX_DOM * 8) as *i64
142 let dcost: *i64 = sys_mmap(RF_MAX_DOM * 8) as *i64
143 // COST-SQUARED FIX (2026-09-01). nx_dr_ocm's own header: Priority=(V*M)/C. This organ used to pass
144 // v=domain_priority -- which the domain ranker already computed as v*m/c -- with c=cost AGAIN, so the
145 // estate portfolio was ordered by v*m/c SQUARED and systematically over-favoured cheap rungs. The #1
146 // line already prints its raw v= and m=; parse them and feed the ranker its actual contract.
147 let dval: *i64 = sys_mmap(RF_MAX_DOM * 8) as *i64
148 let dmom: *i64 = sys_mmap(RF_MAX_DOM * 8) as *i64
149 let dstage: *i64 = sys_mmap(RF_MAX_DOM * 8) as *i64
150 var nd: i64 = 0
151 // NO SILENT CAP (2026-09-01). `nd = nd + 1` sits INSIDE `if nd < RF_MAX_DOM`, so past the cap this
152 // organ simply stopped counting domains and the PARTITION below still printed as though it had measured
153 // the estate. A smaller number that reads like better news is the worst shape of a silent cap. The estate
154 // is at ~96-109 domains against RF_MAX_DOM=128, so this is close to binding, not hypothetical.
155 var rf_capped: i64 = 0
156 var p: i64 = 0
157 while p < ln {
158 var e: i64 = p
159 while e < ln { if lst[e] == (10 as u8) { break } e = e + 1 }
160 lst[e] = 0 as u8
161 let dom: *u8 = (lst as i64 + p) as *u8
162 p = e + 1
163 if dom[0] != (0 as u8) { if dom[0] != (35 as u8) { if nd >= RF_MAX_DOM { rf_capped = rf_capped + 1 } if nd < RF_MAX_DOM {
164 dname[nd] = dom as i64
165 let mp: *u8 = sys_mmap(512); var mo: i64 = rf_cat(mp, 0, "buildroot/knowledge/compare/" as *u8); mo = rf_cat(mp, mo, dom); mo = rf_cat(mp, mo, ".matrix" as *u8)
166 let pp: *u8 = sys_mmap(512); var po: i64 = rf_cat(pp, 0, "buildroot/knowledge/compare/" as *u8); po = rf_cat(pp, po, dom); po = rf_cat(pp, po, ".plan" as *u8)
167 dtop[nd] = "-" as *u8 as i64
168 dpri[nd] = 0
169 dcost[nd] = 0
170 dval[nd] = 0
171 dmom[nd] = 1
172 dstage[nd] = "-" as *u8 as i64
173 if rf_exists(mp) == 0 { dclass[nd] = 3 }
174 else { if rf_exists(pp) == 0 { dclass[nd] = 2 }
175 else {
176 let av: *i64 = sys_mmap(8 * 4) as *i64
177 av[0] = ranker as i64
178 av[1] = dom as i64
179 av[2] = 0
180 let out: *u8 = sys_mmap(RF_CAP)
181 let olen: *i64 = sys_mmap(16) as *i64
182 olen[0] = 0
183 tr_run_capture_to(ranker, av, out, RF_CAP - 1, olen, RF_TIMEOUT_MS)
184 if olen[0] <= 0 { dclass[nd] = 4 }
185 else {
186 if rf_find(out, olen[0], "NO ver| ladder" as *u8) >= 0 { dclass[nd] = 1 } else { dclass[nd] = 0 }
187 // top rung: first " #1 [" line: stage then id then priority then c
188 let p1: i64 = rf_find(out, olen[0], " #1 [" as *u8)
189 if p1 >= 0 {
190 let sub: *u8 = (out as i64 + p1) as *u8
191 let sl: i64 = olen[0] - p1
192 let stg: *u8 = sys_mmap(64)
193 rf_tok_after(sub, sl, " #1 [" as *u8, stg, 64)
194 // strip trailing "]"
195 var q: i64 = 0; while stg[q] != (0 as u8) { if stg[q] == (93 as u8) { stg[q] = 0 as u8 } q = q + 1 }
196 dstage[nd] = stg as i64
197 let idb: *u8 = sys_mmap(64)
198 rf_tok_after(sub, sl, "] " as *u8, idb, 64)
199 dtop[nd] = idb as i64
200 dpri[nd] = rf_int_after(sub, sl, "priority=" as *u8)
201 dval[nd] = rf_int_after(sub, sl, " v=" as *u8)
202 dmom[nd] = rf_int_after(sub, sl, " m=" as *u8)
203 // an older ranker output without v=/m= falls back to the composite priority with
204 // momentum 1 -- degrading to the PREVIOUS behaviour for that domain, never dropping it
205 if dval[nd] <= 0 { dval[nd] = dpri[nd] }
206 if dmom[nd] <= 0 { dmom[nd] = 1 }
207 dcost[nd] = rf_int_after(sub, sl, " c=" as *u8)
208 if dcost[nd] <= 0 { dcost[nd] = 1 }
209 } else { if rf_find(out, olen[0], "nothing open" as *u8) < 0 { dclass[nd] = 4 } }
210 }
211 } }
212 rf_emit_row_as_decided(dname, dclass, dtop, dstage, dpri, dcost, nd)
213 nd = nd + 1
214 } } }
215 }
216 // ---- print census with partition ----
217 var c0: i64 = 0; var c1: i64 = 0; var c2: i64 = 0; var c3: i64 = 0; var c4: i64 = 0
218 var i2: i64 = 0
219 while i2 < nd {
220 let cl: i64 = dclass[i2]
221 if cl == 0 { c0 = c0 + 1 } if cl == 1 { c1 = c1 + 1 } if cl == 2 { c2 = c2 + 1 } if cl == 3 { c3 = c3 + 1 } if cl == 4 { c4 = c4 + 1 }
222 // The row was already printed by rf_row at the moment this domain was DECIDED, in this same order,
223 // so this pass now only TALLIES. One printer, one order: re-spelling the row here would be the
224 // duplicate-ruler defect, and the two copies would drift the first time a class string changed.
225 i2 = i2 + 1
226 }
227 if rf_capped > 0 {
228 rf_puts("WARNING domain-set CAPPED at RF_MAX_DOM -- " as *u8); rf_pn(rf_capped)
229 rf_puts(" domains in regen.list were NOT ranked, so every figure below is over a PARTIAL estate\n" as *u8)
230 }
231 rf_puts("PARTITION domains=" as *u8); rf_pn(nd); rf_puts(" RANKED=" as *u8); rf_pn(c0); rf_puts(" NO-LADDER=" as *u8); rf_pn(c1); rf_puts(" NO-PLAN=" as *u8); rf_pn(c2); rf_puts(" NO-MATRIX=" as *u8); rf_pn(c3); rf_puts(" FAILED=" as *u8); rf_pn(c4)
232 rf_puts(" sum=" as *u8); rf_pn(c0 + c1 + c2 + c3 + c4); rf_puts("\n" as *u8)
233 // ---- estate portfolio: every ranked/no-ladder domain's #1 through dr_ocm across domains ----
234 let pav: *i64 = sys_mmap(8 * (RF_MAX_DOM * 3 + 4)) as *i64
235 pav[0] = "./nx_dr_ocm_cli.elf" as *u8 as i64
236 let bs: *u8 = sys_mmap(32); rf_catn(bs, 0, budget); pav[1] = bs as i64
237 var ai: i64 = 2
238 let pidx: *i64 = sys_mmap(RF_MAX_DOM * 8) as *i64
239 var np: i64 = 0
240 i2 = 0
241 while i2 < nd {
242 if dclass[i2] <= 1 { if dpri[i2] > 0 {
243 let sv: *u8 = sys_mmap(32); rf_catn(sv, 0, dval[i2]); pav[ai] = sv as i64; ai = ai + 1
244 let sm: *u8 = sys_mmap(32); rf_catn(sm, 0, dmom[i2]); pav[ai] = sm as i64; ai = ai + 1
245 let sc: *u8 = sys_mmap(32); rf_catn(sc, 0, dcost[i2]); pav[ai] = sc as i64; ai = ai + 1
246 pidx[np] = i2; np = np + 1
247 } }
248 i2 = i2 + 1
249 }
250 pav[ai] = 0
251 if np == 0 { rf_puts("PORTFOLIO: no ranked domain produced a #1 -- nothing to order\n" as *u8); return 0 }
252 let pout: *u8 = sys_mmap(RF_CAP)
253 let plen: *i64 = sys_mmap(16) as *i64
254 tr_run_capture_to("./nx_dr_ocm_cli.elf" as *u8, pav, pout, RF_CAP - 1, plen, RF_TIMEOUT_MS)
255 // parse ranking: walk objects, read rank and id
256 let rk_of: *i64 = sys_mmap(RF_MAX_DOM * 8) as *i64
257 var z: i64 = 0; while z < np { rk_of[z] = 0; z = z + 1 }
258 var oi: i64 = 0
259 var currank: i64 = 0
260 while oi + 8 < plen[0] {
261 if pout[oi] == (34 as u8) {
262 let rem: i64 = plen[0] - oi
263 let here: *u8 = (pout as i64 + oi) as *u8
264 if rf_find(here, 8, "\"rank\":" as *u8) == 0 { currank = rf_int_after(here, rem, "\"rank\":" as *u8) }
265 if rf_find(here, 6, "\"id\":" as *u8) == 0 { let idv: i64 = rf_int_after(here, rem, "\"id\":" as *u8); if idv >= 0 { if idv < np { rk_of[idv] = currank } } }
266 }
267 oi = oi + 1
268 }
269 rf_puts("PORTFOLIO (estate-wide next actions, one dr_ocm pass over every domain's #1):\n" as *u8)
270 var r: i64 = 1
271 var filed: i64 = 0
272 var pub: i64 = 0
273 while r <= np {
274 var f: i64 = 0 - 1
275 var q2: i64 = 0
276 while q2 < np { if rk_of[q2] == r { f = q2; q2 = np } q2 = q2 + 1 }
277 if f >= 0 {
278 let di: i64 = pidx[f]
279 rf_puts(" #" as *u8); rf_pn(r); rf_puts(" " as *u8); rf_puts(dname[di] as *u8); rf_puts("/" as *u8); rf_puts(dtop[di] as *u8); rf_puts(" stage=" as *u8); rf_puts(dstage[di] as *u8); rf_puts(" domain_priority=" as *u8); rf_pn(dpri[di]); rf_puts(" c=" as *u8); rf_pn(dcost[di]); rf_puts("\n" as *u8)
280 // portfolio- plane row
281 let sav: *i64 = sys_mmap(8 * 16) as *i64
282 let rid: *u8 = sys_mmap(160); var ro: i64 = rf_cat(rid, 0, dname[di] as *u8); ro = rf_cat(rid, ro, "/" as *u8); ro = rf_cat(rid, ro, dtop[di] as *u8)
283 let sr: *u8 = sys_mmap(32); rf_catn(sr, 0, r)
284 let spr: *u8 = sys_mmap(32); rf_catn(spr, 0, dpri[di])
285 let sn: *u8 = sys_mmap(512); var sno: i64 = rf_cat(sn, 0, "estate rank from one dr_ocm pass over every ranked domain's critical-path #1; stage=" as *u8); sno = rf_cat(sn, sno, dstage[di] as *u8); sno = rf_cat(sn, sno, " domain_priority=" as *u8); sno = rf_catn(sn, sno, dpri[di]); sno = rf_cat(sn, sno, " c=" as *u8); sno = rf_catn(sn, sno, dcost[di])
286 sav[0] = "./nx_store_put.elf" as *u8 as i64
287 sav[1] = "portfolio-" as *u8 as i64
288 sav[2] = "put" as *u8 as i64
289 sav[3] = "nx_compare_rank_fleet" as *u8 as i64
290 sav[4] = rid as i64
291 sav[5] = dtop[di]
292 sav[6] = sr as i64
293 sav[7] = spr as i64
294 sav[8] = "pm" as *u8 as i64
295 sav[9] = dname[di]
296 sav[10] = sn as i64
297 sav[11] = 0
298 let so: *u8 = sys_mmap(4096); let sl: *i64 = sys_mmap(16) as *i64
299 tr_run_capture_to("./nx_store_put.elf" as *u8, sav, so, 4095, sl, RF_TIMEOUT_MS)
300 if sl[0] > 0 { pub = pub + 1 }
301 if r <= RF_PM_TOP {
302 let iav: *i64 = sys_mmap(8 * 8) as *i64
303 let it: *u8 = sys_mmap(512); var io: i64 = rf_cat(it, 0, "PORTFOLIO #" as *u8); io = rf_catn(it, io, r); io = rf_cat(it, io, " " as *u8); io = rf_cat(it, io, rid); io = rf_cat(it, io, " stage=" as *u8); io = rf_cat(it, io, dstage[di] as *u8); io = rf_cat(it, io, " domain_priority=" as *u8); io = rf_catn(it, io, dpri[di])
304 iav[0] = "./nx_pm_intake.elf" as *u8 as i64
305 iav[1] = "ask" as *u8 as i64
306 iav[2] = "knowledge/status/pm_intake.jrnl" as *u8 as i64
307 iav[3] = "nx_compare_rank_fleet" as *u8 as i64
308 iav[4] = it as i64
309 iav[5] = 0
310 let ioo: *u8 = sys_mmap(2048); let iol: *i64 = sys_mmap(16) as *i64
311 tr_run_capture_to("./nx_pm_intake.elf" as *u8, iav, ioo, 2047, iol, RF_TIMEOUT_MS)
312 if iol[0] > 0 { filed = filed + 1 }
313 }
314 }
315 r = r + 1
316 }
317 rf_puts("PORTFOLIO published=" as *u8); rf_pn(pub); rf_puts(" of=" as *u8); rf_pn(np); rf_puts(" plane=portfolio- pm_filed=" as *u8); rf_pn(filed); rf_puts("\n" as *u8)
318 return 0
319}