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

↩ module page · 1436 lines · 156770 B
1// nx_cast_shader_src.nx -- THE CHARACTER CAST VERTEX STAGE, WRITTEN ONCE (gameengine S12c, 2026-09-05).
2// The cast vertex shader that nx_game_page_emit ships as the hand-written GLSL literal MVS (extracted to the board as
3// buildroot/knowledge/compare/cast_mvs_hand.glsl, 2,485 raw / 2,521 expanded / 3,097 canonical tokens) is transcribed here
4// SLICE BY SLICE as shader-IR builder calls, so that BOTH dialects are emitted from one source: GLSL for the WebGL2 door
5// (proven against the hand text by nx_glsl_tokdiff -- an emitted slice is accepted when its canonical token stream is a PREFIX
6// of the hand's up to main's closing brace, slice_prefix=1, and the whole stage when the verdict reads IDENTICAL) and WGSL for
7// the WebGPU door (the S12 cast pipeline). The vocabulary is nx_world_shader_src's ws_* shorthands over nx_shader_ir; nothing
8// here re-implements a builder. RULES THAT KEEP THE CANONICAL FORM REACHABLE: a negative literal is sir_neg over the positive
9// literal ((-999.0), never a "-999.0" literal); every literal is spelled with the hand's own digits, canonically (0.5 not .5,
10// 0.930 not 0.93 -- the ruler canonicalises spelling, never value); a compound assignment is x=(x op (y)); left-associative
11// chains are built left-nested exactly as the grammar parses them; the hand's grouping parentheses are simply the tree's shape.
12// The f32 uniform arrays the hand declares (uOF uGB uGT uGN, float[12]) are declared EXACTLY as the hand does -- the
13// uniform-space stride rule is a WGSL-dialect fact and belongs in the WGSL backend's lowering (S12c-2b), never in this source.
14// SLICES (each measured, journaled on gameengine.plan under GE59):
15//   1  declarations + hsh + the instance/lock prologue (through vII=ii;)          -- MEASURED 602/3097 canonical, slice_prefix
16//   2  dual-quaternion skinning off the joint table, garment displacement, the PASS-1 face cut, the y-up rotation and world
17//      placement (through vec3 wp=...;)
18//   3  soft-body fields (hb2, sbo over the DYNA anchors, hair wind, dress inheritance, the body branch), wp+=sbo
19//   4  garment degeneration, the cast-shadow projection, vW, the clip transform (gl_Position)
20// license_tier: ORIGINAL   No hw writes (Rule 26).
21import "nx_world_shader_src.nx"
22import "nx_cast_projection_contract_t234.nx"
23import "nx_normal_encoding_contract.nx"
24
25// ---- shorthands the world module does not have (thin, one node each) ----
26func cs_i(m: *i64, n: *u8) -> i64 { return sir_ident(m, n, T_I32) }
27func cs_fl(m: *i64, n: *u8) -> i64 { return sir_ident(m, n, T_F32) }
28func cs_v3(m: *i64, n: *u8) -> i64 { return sir_ident(m, n, T_V3F) }
29func cs_v4(m: *i64, n: *u8) -> i64 { return sir_ident(m, n, T_V4F) }
30func cs_f32(m: *i64, e: i64) -> i64 { return sir_cast(m, e, T_F32) }
31func cs_i32(m: *i64, e: i64) -> i64 { return sir_cast(m, e, T_I32) }
32// (-<f32 literal>) -- the hand's negative constants, as negation over the positive literal
33func cs_negf(m: *i64, s: *u8) -> i64 { return sir_neg(m, ws_f(m, s), T_F32) }
34// arr[i] where arr is a module-scope array of element type ety
35func cs_idx(m: *i64, arr: *u8, ety: i64, i: i64) -> i64 { return sir_index(m, sir_ident(m, arr, ety), i, ety) }
36// uIH[ii].<sel>
37func cs_ih(m: *i64, sel: *u8) -> i64 { return ws_sw(m, cs_idx(m, "uIH" as *u8, T_V4F, cs_i(m, "ii" as *u8)), sel, T_F32) }
38// <vec3 name>.<one component>   <vec4 name>.<one component>   <vec4 name>.xyz
39func cs_sx3(m: *i64, n: *u8, sel: *u8) -> i64 { return ws_sx(m, n, T_V3F, sel, T_F32) }
40func cs_sx4(m: *i64, n: *u8, sel: *u8) -> i64 { return ws_sx(m, n, T_V4F, sel, T_F32) }
41func cs_xyz(m: *i64, n: *u8) -> i64 { return ws_sx(m, n, T_V4F, "xyz" as *u8, T_V3F) }
42func cs_hsh(m: *i64, e: i64) -> i64 { return ws_c1(m, "hsh" as *u8, e, T_F32) }
43func cs_fadd(m: *i64, a: i64, b: i64) -> i64 { return ws_bin(m, "+" as *u8, a, b, T_F32) }
44func cs_fsub(m: *i64, a: i64, b: i64) -> i64 { return ws_bin(m, "-" as *u8, a, b, T_F32) }
45func cs_fmul(m: *i64, a: i64, b: i64) -> i64 { return ws_bin(m, "*" as *u8, a, b, T_F32) }
46func cs_fdiv(m: *i64, a: i64, b: i64) -> i64 { return ws_bin(m, "/" as *u8, a, b, T_F32) }
47func cs_iadd(m: *i64, a: i64, b: i64) -> i64 { return ws_bin(m, "+" as *u8, a, b, T_I32) }
48func cs_isub(m: *i64, a: i64, b: i64) -> i64 { return ws_bin(m, "-" as *u8, a, b, T_I32) }
49func cs_imul(m: *i64, a: i64, b: i64) -> i64 { return ws_bin(m, "*" as *u8, a, b, T_I32) }
50func cs_idiv(m: *i64, a: i64, b: i64) -> i64 { return ws_bin(m, "/" as *u8, a, b, T_I32) }
51func cs_v3add(m: *i64, a: i64, b: i64) -> i64 { return ws_bin(m, "+" as *u8, a, b, T_V3F) }
52func cs_v3sub(m: *i64, a: i64, b: i64) -> i64 { return ws_bin(m, "-" as *u8, a, b, T_V3F) }
53func cs_v3mul(m: *i64, a: i64, b: i64) -> i64 { return ws_bin(m, "*" as *u8, a, b, T_V3F) }
54func cs_v4add(m: *i64, a: i64, b: i64) -> i64 { return ws_bin(m, "+" as *u8, a, b, T_V4F) }
55func cs_v4mul(m: *i64, a: i64, b: i64) -> i64 { return ws_bin(m, "*" as *u8, a, b, T_V4F) }
56func cs_cross(m: *i64, a: i64, b: i64) -> i64 { return ws_c2(m, "cross" as *u8, a, b, T_V3F) }
57func cs_dot(m: *i64, a: i64, b: i64) -> i64 { return ws_c2(m, "dot" as *u8, a, b, T_F32) }
58func cs_ss(m: *i64, a: i64, b: i64, c: i64) -> i64 { return ws_c3(m, "smoothstep" as *u8, a, b, c, T_F32) }
59// smoothstep(<lit>,<lit>,<f32 ident>)
60func cs_ssl(m: *i64, a: *u8, b: *u8, n: *u8) -> i64 { return cs_ss(m, ws_f(m, a), ws_f(m, b), cs_fl(m, n)) }
61
62// ---- the declarations, in the hand's order (the GLSL backend emits the chain in declaration order) ----
63// One shared resident prefix; authored vertex mode extends it without moving the surface ABI.
64func shsrc_cast_prefix(m:*i64)->i64 {
  sir_attrib(m, "aP" as *u8, T_V3F, 0); sir_attrib(m, "aJ" as *u8, T_V4F, 1); sir_attrib(m, "aW" as *u8, T_V4F, 2)
  sir_attrib(m, "aN" as *u8, T_V3F, 3); sir_attrib(m, "aUV" as *u8, T_V2F, 4); sir_attrib(m, "aHS" as *u8, T_F32, 5)
  sir_texture(m, "uJT" as *u8, T_TEX2F); sir_uniform(m, "uSc" as *u8, T_F32, 0)
  sir_uniform(m, "uIP" as *u8, T_V3F, 12); sir_uniform(m, "uIH" as *u8, T_V4F, 12)
  sir_uniform(m, "uSB" as *u8, T_V3F, 72)
  sir_uniform(m, "uOF" as *u8, T_F32, 12); sir_uniform(m, "uGB" as *u8, T_F32, 12); sir_uniform(m, "uGT" as *u8, T_F32, 12); sir_uniform(m, "uGK" as *u8, T_I32, 0)
  sir_uniform(m, "uGN" as *u8, T_F32, 12)
  sir_uniform(m, "uTm" as *u8, T_F32, 0); sir_uniform(m, "uWnd" as *u8, T_F32, 0)
  sir_uniform(m, "uZMN" as *u8, T_F32, 0); sir_uniform(m, "uH" as *u8, T_F32, 0); sir_uniform(m, "uNIP" as *u8, T_F32, 0)
  sir_uniform(m, "uDNL" as *u8, T_V4F, 0); sir_uniform(m, "uDNR" as *u8, T_V4F, 0); sir_uniform(m, "uDNB" as *u8, T_V4F, 0)
  sir_uniform(m, "uDNG" as *u8, T_V4F, 0); sir_uniform(m, "uDNTl" as *u8, T_V4F, 0); sir_uniform(m, "uDNTr" as *u8, T_V4F, 0)
  sir_uniform(m, "uCamM" as *u8, T_V3F, 0); sir_uniform(m, "uYPM" as *u8, T_V4F, 0); sir_uniform(m, "uResM" as *u8, T_V2F, 0)
  sir_texture(m, "uGD" as *u8, T_TEX2F); sir_uniform(m, "uSunM" as *u8, T_V3F, 0); sir_uniform(m, "uHF2" as *u8, T_V3F, 84)
  sir_uniform(m, "uHM" as *u8, T_I32, 0); sir_uniform(m, "uGar" as *u8, T_I32, 0); sir_uniform(m, "uAuth" as *u8, T_I32, 0)
  sir_uniform(m, "uShd" as *u8, T_I32, 0); sir_uniform(m, "uShdP" as *u8, T_V4F, 0)
  return 0
81}
82func shsrc_cast_varyings(m:*i64)->i64 {
  sir_vary(m, "vB" as *u8, T_V3F, 0, 0); sir_vary(m, "vW" as *u8, T_V3F, 1, 0); sir_vary(m, "vN" as *u8, T_V3F, 2, 0)
  sir_vary(m, "vII" as *u8, T_I32, 3, 1); sir_vary(m, "vSh" as *u8, T_F32, 4, 1); sir_vary(m, "vUV" as *u8, T_V2F, 5, 0)
  sir_vary(m, "vSt" as *u8, T_F32, 6, 0)
  return 0
87}
88func shsrc_cast_resident_decls(m:*i64)->i64 {
  shsrc_cast_prefix(m);shsrc_cast_varyings(m);return 0
90}
91func shsrc_cast_decls(m:*i64)->i64 {
  shsrc_cast_prefix(m)
  sir_uniform(m,"uSkinMode",T_I32,0); sir_uniform(m,"uAssetBasis",T_I32,0)
  sir_attrib(m,"aT",T_V4F,6)
  shsrc_cast_varyings(m);sir_vary(m,"vT",T_V4F,7,0);return 0
96}
97
98// float hsh(float s){return fract(sin(s*127.1)*43758.5453);}
99func shsrc_cast_fn_hsh(m: *i64) -> i64 {
  let f: i64 = sir_func(m, "hsh" as *u8, T_F32)
  sir_param(m, f, "s" as *u8, T_F32)
  let inner: i64 = ws_c1(m, "sin" as *u8, cs_fmul(m, cs_fl(m, "s" as *u8), ws_f(m, "127.1" as *u8)), T_F32)
  ws_st(m, f, ws_ret(m, ws_c1(m, "fract" as *u8, cs_fmul(m, inner, ws_f(m, "43758.5453" as *u8)), T_F32)))
  return f
105}
106
107// ---- slice 2 helpers ----
108// texelFetch(uJT,ivec2(int(aJ.<sel>+.5),<row>),0)
109func cs_jt(m: *i64, sel: *u8, row: *u8) -> i64 {
  let co: i64 = ws_vt2(m, T_V2I, cs_i32(m, cs_fadd(m, cs_sx4(m, "aJ" as *u8, sel), ws_f(m, "0.5" as *u8))), cs_i(m, row))
  return sir_texload(m, sir_ident(m, "uJT" as *u8, T_TEX2F), co, ws_i(m, "0" as *u8))
112}
113// float s<k>=dot(r0,r<k>)<0.?-1.:1.;
114func cs_sign(m: *i64, f: i64, name: *u8, rn: *u8) -> i64 {
  let c: i64 = ws_cmp(m, "<" as *u8, cs_dot(m, cs_v4(m, "r0" as *u8), cs_v4(m, rn)), ws_f(m, "0.0" as *u8))
  return ws_st(m, f, sir_var(m, name, T_F32, sir_select(m, c, cs_negf(m, "1.0" as *u8), ws_f(m, "1.0" as *u8), T_F32)))
117}
118// aW.x*q0+aW.y*s1*q1+aW.z*s2*q2+aW.w*s3*q3 (left-nested exactly as the grammar parses it)
119func cs_blend(m: *i64, q0: *u8, q1: *u8, q2: *u8, q3: *u8) -> i64 {
  let t0: i64 = cs_v4mul(m, cs_sx4(m, "aW" as *u8, "x" as *u8), cs_v4(m, q0))
  let t1: i64 = cs_v4mul(m, cs_fmul(m, cs_sx4(m, "aW" as *u8, "y" as *u8), cs_fl(m, "s1" as *u8)), cs_v4(m, q1))
  let t2: i64 = cs_v4mul(m, cs_fmul(m, cs_sx4(m, "aW" as *u8, "z" as *u8), cs_fl(m, "s2" as *u8)), cs_v4(m, q2))
  let t3: i64 = cs_v4mul(m, cs_fmul(m, cs_sx4(m, "aW" as *u8, "w" as *u8), cs_fl(m, "s3" as *u8)), cs_v4(m, q3))
  return cs_v4add(m, cs_v4add(m, cs_v4add(m, t0, t1), t2), t3)
125}
126// 2.*cross(br.xyz,cross(br.xyz,<n>)+br.w*<n>)  -- the dual-quaternion rotation of a vec3 named n
127func cs_rot(m: *i64, n: *u8) -> i64 {
  let inner: i64 = cs_v3add(m, cs_cross(m, cs_xyz(m, "br" as *u8), cs_v3(m, n)), cs_v3mul(m, cs_sx4(m, "br" as *u8, "w" as *u8), cs_v3(m, n)))
  return cs_v3mul(m, ws_f(m, "2.0" as *u8), cs_cross(m, cs_xyz(m, "br" as *u8), inner))
130}
131// vec3(<n>.x*uIH[ii].y-<n>.z*uIH[ii].x,<n>.y,<n>.x*uIH[ii].x+<n>.z*uIH[ii].y)  -- the per-instance yaw
132func cs_yaw(m: *i64, n: *u8) -> i64 {
  let x: i64 = cs_fsub(m, cs_fmul(m, cs_sx3(m, n, "x" as *u8), cs_ih(m, "y" as *u8)), cs_fmul(m, cs_sx3(m, n, "z" as *u8), cs_ih(m, "x" as *u8)))
  let z: i64 = cs_fadd(m, cs_fmul(m, cs_sx3(m, n, "x" as *u8), cs_ih(m, "x" as *u8)), cs_fmul(m, cs_sx3(m, n, "z" as *u8), cs_ih(m, "y" as *u8)))
  return ws_v3(m, x, cs_sx3(m, n, "y" as *u8), z)
136}
137// vec3(<n>.x,<n>.z,-<n>.y)  -- the y-up swap
138func cs_yup(m: *i64, n: *u8) -> i64 {
  return ws_v3(m, cs_sx3(m, n, "x" as *u8), cs_sx3(m, n, "z" as *u8), sir_neg(m, cs_sx3(m, n, "y" as *u8), T_F32))
140}
141
142// SLICE 2: skinning off the joint table, garment displacement, the PASS-1 face cut, y-up rotation, world placement
143// Preserve the existing WebGL brow, socket and lip relief in the shared cast source.
144// These artistic ratios are inherited unchanged; this is backend convergence, not anatomical calibration.
145func cs_face_relief(m: *i64, f: i64) -> i64 {
  var body: i64 = 0
  body = ws_q2(m, body, sir_var(m, "HH7" as *u8, T_F32, cs_fmul(m, ws_f(m, "0.115" as *u8), cs_fl(m, "uH" as *u8))))
  body = ws_q2(m, body, sir_var(m, "hc7" as *u8, T_V3F, ws_v3(m, ws_f(m, "0.0" as *u8), ws_f(m, "0.0" as *u8), cs_fadd(m, cs_fl(m, "uZMN" as *u8), cs_fmul(m, ws_f(m, "0.94" as *u8), cs_fl(m, "uH" as *u8))))))
  body = ws_q2(m, body, sir_var(m, "no7" as *u8, T_V3F, cs_v3mul(m, cs_v3(m, "aN" as *u8), ws_c1(m, "sign" as *u8, cs_dot(m, cs_v3(m, "aN" as *u8), cs_v3sub(m, cs_v3(m, "aP" as *u8), cs_v3(m, "hc7" as *u8))), T_F32))))
  body = ws_q2(m, body, sir_var(m, "ez7" as *u8, T_F32, cs_fmul(m, cs_fsub(m, cs_fl(m, "fh9" as *u8), ws_f(m, "0.9420" as *u8)), cs_fl(m, "uH" as *u8))))
  body = ws_q2(m, body, sir_var(m, "bz7" as *u8, T_F32, cs_fmul(m, cs_fsub(m, cs_fl(m, "fh9" as *u8), ws_f(m, "0.954" as *u8)), cs_fl(m, "uH" as *u8))))
  body = ws_q2(m, body, sir_var(m, "mz7" as *u8, T_F32, cs_fmul(m, cs_fsub(m, cs_fl(m, "fh9" as *u8), ws_f(m, "0.908" as *u8)), cs_fl(m, "uH" as *u8))))
  body = ws_q2(m, body, sir_var(m, "ax7" as *u8, T_F32, ws_c1(m, "abs" as *u8, cs_sx3(m, "aP" as *u8, "x" as *u8), T_F32)))
  body = ws_q2(m, body, sir_var(m, "bo7" as *u8, T_F32, cs_fdiv(m, cs_fl(m, "ax7" as *u8), cs_fl(m, "HH7" as *u8))))
  body = ws_q2(m, body, sir_var(m, "bt7" as *u8, T_F32, ws_c3(m, "clamp" as *u8, cs_fdiv(m, cs_fsub(m, cs_fl(m, "bo7" as *u8), ws_f(m, "0.085" as *u8)), ws_f(m, "0.16" as *u8)), ws_f(m, "0.0" as *u8), ws_f(m, "1.0" as *u8), T_F32)))
  body = ws_q2(m, body, sir_var(m, "bc7" as *u8, T_F32, cs_fmul(m, cs_fsub(m, cs_fmul(m, ws_f(m, "0.024" as *u8), ws_c1(m, "sin" as *u8, cs_fmul(m, ws_f(m, "3.14159" as *u8), ws_c2(m, "pow" as *u8, cs_fl(m, "bt7" as *u8), ws_f(m, "1.45" as *u8), T_F32)), T_F32)), cs_fmul(m, ws_f(m, "0.006" as *u8), cs_fl(m, "bt7" as *u8))), cs_fl(m, "HH7" as *u8))))
  body = ws_q2(m, body, sir_var(m, "br7" as *u8, T_F32, cs_fmul(m, cs_fmul(m, cs_fsub(m, ws_f(m, "1.0" as *u8), cs_ss(m, ws_f(m, "0.0" as *u8), cs_fmul(m, ws_f(m, "0.020" as *u8), cs_fl(m, "HH7" as *u8)), ws_c1(m, "abs" as *u8, cs_fsub(m, cs_fl(m, "bz7" as *u8), cs_fl(m, "bc7" as *u8)), T_F32))), cs_ss(m, ws_f(m, "0.0" as *u8), ws_f(m, "0.10" as *u8), cs_fl(m, "bt7" as *u8))), cs_fsub(m, ws_f(m, "1.0" as *u8), cs_ss(m, ws_f(m, "0.90" as *u8), ws_f(m, "1.0" as *u8), cs_fl(m, "bt7" as *u8))))))
  body = ws_q2(m, body, sir_var(m, "ex7" as *u8, T_F32, cs_fsub(m, cs_fl(m, "ax7" as *u8), cs_fmul(m, ws_f(m, "0.16" as *u8), cs_fl(m, "HH7" as *u8)))))
  body = ws_q2(m, body, sir_var(m, "ed7" as *u8, T_F32, ws_c1(m, "sqrt" as *u8, cs_fadd(m, cs_fmul(m, cs_fl(m, "ex7" as *u8), cs_fl(m, "ex7" as *u8)), cs_fmul(m, cs_fmul(m, cs_fl(m, "ez7" as *u8), cs_fl(m, "ez7" as *u8)), ws_f(m, "1.4" as *u8))), T_F32)))
  body = ws_q2(m, body, sir_var(m, "so7" as *u8, T_F32, cs_fsub(m, ws_f(m, "1.0" as *u8), cs_ss(m, ws_f(m, "0.0" as *u8), cs_fmul(m, ws_f(m, "0.085" as *u8), cs_fl(m, "HH7" as *u8)), cs_fl(m, "ed7" as *u8)))))
  body = ws_q2(m, body, sir_var(m, "lp7" as *u8, T_F32, cs_fmul(m, cs_fsub(m, ws_f(m, "1.0" as *u8), cs_ss(m, ws_f(m, "0.0" as *u8), cs_fmul(m, ws_f(m, "0.018" as *u8), cs_fl(m, "HH7" as *u8)), ws_c1(m, "abs" as *u8, cs_fl(m, "mz7" as *u8), T_F32))), cs_fsub(m, ws_f(m, "1.0" as *u8), cs_ss(m, cs_fmul(m, ws_f(m, "0.030" as *u8), cs_fl(m, "HH7" as *u8)), cs_fmul(m, ws_f(m, "0.062" as *u8), cs_fl(m, "HH7" as *u8)), cs_fl(m, "ax7" as *u8))))))
  body = ws_q2(m, body, sir_var(m, "d7" as *u8, T_F32, cs_fadd(m, cs_fsub(m, cs_fmul(m, cs_fmul(m, cs_fl(m, "br7" as *u8), ws_f(m, "0.0100" as *u8)), cs_fl(m, "HH7" as *u8)), cs_fmul(m, cs_fmul(m, cs_fl(m, "so7" as *u8), ws_f(m, "0.0250" as *u8)), cs_fl(m, "HH7" as *u8))), cs_fmul(m, cs_fmul(m, cs_fl(m, "lp7" as *u8), ws_f(m, "0.0100" as *u8)), cs_fl(m, "HH7" as *u8)))))
  body = ws_q2(m, body, ws_op(m, "aP2" as *u8, T_V3F, "+" as *u8, cs_v3mul(m, cs_v3(m, "no7" as *u8), cs_fl(m, "d7" as *u8))))
  let region: i64 = ws_and(m, ws_and(m, ws_cmp(m, ">" as *u8, cs_fl(m, "fh9" as *u8), ws_f(m, "0.885" as *u8)), ws_cmp(m, "<" as *u8, cs_fl(m, "fh9" as *u8), ws_f(m, "0.985" as *u8))), ws_cmp(m, "<" as *u8, cs_sx3(m, "aP" as *u8, "y" as *u8), cs_negf(m, "1200.0" as *u8)))
  let height: i64 = sir_var(m, "fh9" as *u8, T_F32, cs_fdiv(m, cs_fsub(m, cs_sx3(m, "aP" as *u8, "z" as *u8), cs_fl(m, "uZMN" as *u8)), cs_fl(m, "uH" as *u8)))
  let eligible: i64 = ws_and(m, cs_ieq(m, "uAuth" as *u8, "0" as *u8), cs_ieq(m, "uGar" as *u8, "0" as *u8))
  ws_st(m, f, ws_if(m, eligible, ws_q2(m, height, ws_if(m, region, body, 0)), 0))
  return 0
169}
170
171// Emits shared DQ deformation statements and returns the world-position expression.
172func cs_dq_world_value(m: *i64, f: i64) -> i64 {
  // int rb=int(uIH[ii].w+.5);int rd2=rb+1;
  ws_st(m, f, sir_var(m, "rb" as *u8, T_I32, cs_i32(m, cs_fadd(m, cs_ih(m, "w" as *u8), ws_f(m, "0.5" as *u8)))))
  ws_st(m, f, sir_var(m, "rd2" as *u8, T_I32, cs_iadd(m, cs_i(m, "rb" as *u8), ws_i(m, "1" as *u8))))
  // vec4 r<k>=texelFetch(uJT,ivec2(int(aJ.<c>+.5),rb),0),d<k>=texelFetch(uJT,ivec2(int(aJ.<c>+.5),rd2),0);
  ws_st(m, f, sir_var(m, "r0" as *u8, T_V4F, cs_jt(m, "x" as *u8, "rb" as *u8))); ws_st(m, f, sir_var(m, "d0" as *u8, T_V4F, cs_jt(m, "x" as *u8, "rd2" as *u8)))
  ws_st(m, f, sir_var(m, "r1" as *u8, T_V4F, cs_jt(m, "y" as *u8, "rb" as *u8))); ws_st(m, f, sir_var(m, "d1" as *u8, T_V4F, cs_jt(m, "y" as *u8, "rd2" as *u8)))
  ws_st(m, f, sir_var(m, "r2" as *u8, T_V4F, cs_jt(m, "z" as *u8, "rb" as *u8))); ws_st(m, f, sir_var(m, "d2" as *u8, T_V4F, cs_jt(m, "z" as *u8, "rd2" as *u8)))
  ws_st(m, f, sir_var(m, "r3" as *u8, T_V4F, cs_jt(m, "w" as *u8, "rb" as *u8))); ws_st(m, f, sir_var(m, "d3" as *u8, T_V4F, cs_jt(m, "w" as *u8, "rd2" as *u8)))
  // float s1=dot(r0,r1)<0.?-1.:1.;float s2=...;float s3=...;
  cs_sign(m, f, "s1" as *u8, "r1" as *u8); cs_sign(m, f, "s2" as *u8, "r2" as *u8); cs_sign(m, f, "s3" as *u8, "r3" as *u8)
  // vec4 br=aW.x*r0+aW.y*s1*r1+aW.z*s2*r2+aW.w*s3*r3; vec4 bd=... d0..d3
  ws_st(m, f, sir_var(m, "br" as *u8, T_V4F, cs_blend(m, "r0" as *u8, "r1" as *u8, "r2" as *u8, "r3" as *u8)))
  ws_st(m, f, sir_var(m, "bd" as *u8, T_V4F, cs_blend(m, "d0" as *u8, "d1" as *u8, "d2" as *u8, "d3" as *u8)))
  // float nr=max(length(br),1e-6);br/=nr;bd/=nr;
  ws_st(m, f, sir_var(m, "nr" as *u8, T_F32, ws_c2(m, "max" as *u8, ws_c1(m, "length" as *u8, cs_v4(m, "br" as *u8), T_F32), ws_f(m, "1e-6" as *u8), T_F32)))
  ws_st(m, f, ws_op(m, "br" as *u8, T_V4F, "/" as *u8, cs_fl(m, "nr" as *u8)))
  ws_st(m, f, ws_op(m, "bd" as *u8, T_V4F, "/" as *u8, cs_fl(m, "nr" as *u8)))
  // vec3 aP2=aP+jit;
  ws_st(m, f, sir_var(m, "aP2" as *u8, T_V3F, cs_v3add(m, cs_v3(m, "aP" as *u8), cs_v3(m, "jit" as *u8))))
  // if(uGar==1){aP2+=texelFetch(uGD,ivec2(gl_VertexID,ii),0).xyz;}
  let gco: i64 = ws_vt2(m, T_V2I, sir_builtin(m, "vertex_index" as *u8, T_I32), cs_i(m, "ii" as *u8))
  let gd: i64 = ws_sw(m, sir_texload(m, sir_ident(m, "uGD" as *u8, T_TEX2F), gco, ws_i(m, "0" as *u8)), "xyz" as *u8, T_V3F)
  ws_st(m, f, ws_if(m, ws_cmp(m, "==" as *u8, cs_i(m, "uGar" as *u8), ws_i(m, "1" as *u8)), ws_op(m, "aP2" as *u8, T_V3F, "+" as *u8, gd), 0))
  // if(uGar==2){vec3 hf9=uHF2[ii*7+int(aHS+.5)];float hw9=clamp(aHS/6.,0.,1.);hw9*=hw9;aP2+=vec3(hf9.x,hf9.y,hf9.z)*hw9;}
  var g2: i64 = 0
  let hidx: i64 = cs_iadd(m, cs_imul(m, cs_i(m, "ii" as *u8), ws_i(m, "7" as *u8)), cs_i32(m, cs_fadd(m, cs_fl(m, "aHS" as *u8), ws_f(m, "0.5" as *u8))))
  g2 = ws_q2(m, g2, sir_var(m, "hf9" as *u8, T_V3F, cs_idx(m, "uHF2" as *u8, T_V3F, hidx)))
  g2 = ws_q2(m, g2, sir_var(m, "hw9" as *u8, T_F32, ws_c3(m, "clamp" as *u8, cs_fdiv(m, cs_fl(m, "aHS" as *u8), ws_f(m, "6.0" as *u8)), ws_f(m, "0.0" as *u8), ws_f(m, "1.0" as *u8), T_F32)))
  g2 = ws_q2(m, g2, ws_op(m, "hw9" as *u8, T_F32, "*" as *u8, cs_fl(m, "hw9" as *u8)))
  let hv: i64 = ws_v3(m, cs_sx3(m, "hf9" as *u8, "x" as *u8), cs_sx3(m, "hf9" as *u8, "y" as *u8), cs_sx3(m, "hf9" as *u8, "z" as *u8))
  g2 = ws_q2(m, g2, ws_op(m, "aP2" as *u8, T_V3F, "+" as *u8, cs_v3mul(m, hv, cs_fl(m, "hw9" as *u8))))
  ws_st(m, f, ws_if(m, ws_cmp(m, "==" as *u8, cs_i(m, "uGar" as *u8), ws_i(m, "2" as *u8)), g2, 0))
  // if(uHM==1&&uAuth==0){ ... the PASS-1 face cut ... }
  let fc: i64 = ws_and(m, ws_cmp(m, "==" as *u8, cs_i(m, "uHM" as *u8), ws_i(m, "1" as *u8)), ws_cmp(m, "==" as *u8, cs_i(m, "uAuth" as *u8), ws_i(m, "0" as *u8)))
  var fh: i64 = 0
  // float hb1=(aP.z-uZMN)/uH;
  fh = ws_q2(m, fh, sir_var(m, "hb1" as *u8, T_F32, cs_fdiv(m, cs_fsub(m, cs_sx3(m, "aP" as *u8, "z" as *u8), cs_fl(m, "uZMN" as *u8)), cs_fl(m, "uH" as *u8))))
  // float w1=smoothstep(.885,.905,hb1)*(1.-smoothstep(.930,.9448,hb1));if(aP.y>-1200.)w1=0.;
  fh = ws_q2(m, fh, sir_var(m, "w1" as *u8, T_F32, cs_fmul(m, cs_ssl(m, "0.885" as *u8, "0.905" as *u8, "hb1" as *u8), cs_fsub(m, ws_f(m, "1.0" as *u8), cs_ssl(m, "0.930" as *u8, "0.9448" as *u8, "hb1" as *u8)))))
  fh = ws_q2(m, fh, ws_if(m, ws_cmp(m, ">" as *u8, cs_sx3(m, "aP" as *u8, "y" as *u8), cs_negf(m, "1200.0" as *u8)), ws_set(m, cs_fl(m, "w1" as *u8), ws_f(m, "0.0" as *u8)), 0))
  // aP2.z+=704.*w1;
  fh = ws_q2(m, fh, ws_opx(m, "aP2" as *u8, T_V3F, "z" as *u8, T_F32, "+" as *u8, cs_fmul(m, ws_f(m, "704.0" as *u8), cs_fl(m, "w1" as *u8))))
  // float w2=(1.-smoothstep(.915,.925,hb1))*smoothstep(.885,.895,hb1)*smoothstep(uH*.015,uH*.03,abs(aP.x));if(aP.y>-1200.)w2=0.;
  let w2a: i64 = cs_fmul(m, cs_fsub(m, ws_f(m, "1.0" as *u8), cs_ssl(m, "0.915" as *u8, "0.925" as *u8, "hb1" as *u8)), cs_ssl(m, "0.885" as *u8, "0.895" as *u8, "hb1" as *u8))
  let w2b: i64 = cs_ss(m, cs_fmul(m, cs_fl(m, "uH" as *u8), ws_f(m, "0.015" as *u8)), cs_fmul(m, cs_fl(m, "uH" as *u8), ws_f(m, "0.03" as *u8)), ws_c1(m, "abs" as *u8, cs_sx3(m, "aP" as *u8, "x" as *u8), T_F32))
  fh = ws_q2(m, fh, sir_var(m, "w2" as *u8, T_F32, cs_fmul(m, w2a, w2b)))
  fh = ws_q2(m, fh, ws_if(m, ws_cmp(m, ">" as *u8, cs_sx3(m, "aP" as *u8, "y" as *u8), cs_negf(m, "1200.0" as *u8)), ws_set(m, cs_fl(m, "w2" as *u8), ws_f(m, "0.0" as *u8)), 0))
  // aP2.x*=1.+.08*w2;
  fh = ws_q2(m, fh, ws_opx(m, "aP2" as *u8, T_V3F, "x" as *u8, T_F32, "*" as *u8, cs_fadd(m, ws_f(m, "1.0" as *u8), cs_fmul(m, ws_f(m, "0.08" as *u8), cs_fl(m, "w2" as *u8)))))
  ws_st(m, f, ws_if(m, fc, fh, 0))
  cs_face_relief(m, f)
  // vec3 sp=aP2+2.*cross(br.xyz,cross(br.xyz,aP2)+br.w*aP2)+2.*(br.w*bd.xyz-bd.w*br.xyz+cross(br.xyz,bd.xyz));
  let tr9: i64 = cs_v3add(m, cs_v3sub(m, cs_v3mul(m, cs_sx4(m, "br" as *u8, "w" as *u8), cs_xyz(m, "bd" as *u8)), cs_v3mul(m, cs_sx4(m, "bd" as *u8, "w" as *u8), cs_xyz(m, "br" as *u8))), cs_cross(m, cs_xyz(m, "br" as *u8), cs_xyz(m, "bd" as *u8)))
  let sp: i64 = cs_v3add(m, cs_v3add(m, cs_v3(m, "aP2" as *u8), cs_rot(m, "aP2" as *u8)), cs_v3mul(m, ws_f(m, "2.0" as *u8), tr9))
  ws_st(m, f, sir_var(m, "sp" as *u8, T_V3F, sp))
  // vec3 sn=aN+2.*cross(br.xyz,cross(br.xyz,aN)+br.w*aN);
  ws_st(m, f, sir_var(m, "sn" as *u8, T_V3F, cs_v3add(m, cs_v3(m, "aN" as *u8), cs_rot(m, "aN" as *u8))))
  // vec3 nyup=vec3(sn.x,sn.z,-sn.y); vN=vec3(...yaw of nyup...); vB=aP;
  ws_st(m, f, sir_var(m, "nyup" as *u8, T_V3F, cs_yup(m, "sn" as *u8)))
  ws_st(m, f, ws_set(m, cs_v3(m, "vN" as *u8), cs_yaw(m, "nyup" as *u8)))
  ws_st(m, f, ws_set(m, cs_v3(m, "vB" as *u8), cs_v3(m, "aP" as *u8)))
  // vec3 yup=vec3(sp.x,sp.z,-sp.y); vec3 rot=vec3(...yaw of yup...); vec3 wp=uIP[ii]+rot*(uSc*uIH[ii].z);
  ws_st(m, f, sir_var(m, "yup" as *u8, T_V3F, cs_yup(m, "sp" as *u8)))
  ws_st(m, f, sir_var(m, "rot" as *u8, T_V3F, cs_yaw(m, "yup" as *u8)))
  return cs_v3add(m, cs_idx(m, "uIP" as *u8, T_V3F, cs_i(m, "ii" as *u8)), cs_v3mul(m, cs_v3(m, "rot" as *u8), cs_fmul(m, cs_fl(m, "uSc" as *u8), cs_ih(m, "z" as *u8))))
238}
239
240// The full cast owns wp outside its LBS/DQ branches. Surface owns a local wp.
241func cs_slice2(m:*i64,f:i64)->i64 {let value:i64=cs_dq_world_value(m,f);ws_st(m,f,ws_set(m,cs_v3(m,"wp"),value));return 0}
242func cs_slice2_local(m:*i64,f:i64)->i64 {let value:i64=cs_dq_world_value(m,f);ws_st(m,f,sir_var(m,"wp",T_V3F,value));return 0}
243
244
245// Authored LBS is a distinct skinning contract; it does not reinterpret DQ rows.
246func cs_lbs_column(m:*i64,row:*u8)->i64 {
let a:i64=cs_v4mul(m,cs_sx4(m,"aW","x"),cs_jt(m,"x",row))
let b:i64=cs_v4mul(m,cs_sx4(m,"aW","y"),cs_jt(m,"y",row))
let c:i64=cs_v4mul(m,cs_sx4(m,"aW","z"),cs_jt(m,"z",row))
let d:i64=cs_v4mul(m,cs_sx4(m,"aW","w"),cs_jt(m,"w",row))
return cs_v4add(m,cs_v4add(m,cs_v4add(m,a,b),c),d)
252}
253func cs_affine_slice(m:*i64,f:i64)->i64 {
let px:i64=cs_v3mul(m,cs_xyz(m,"lc0"),cs_sx3(m,"aP","x"))
let py:i64=cs_v3mul(m,cs_xyz(m,"lc1"),cs_sx3(m,"aP","y"))
let pz:i64=cs_v3mul(m,cs_xyz(m,"lc2"),cs_sx3(m,"aP","z"))
ws_st(m,f,sir_var(m,"lp",T_V3F,cs_v3add(m,cs_v3add(m,cs_v3add(m,px,py),pz),cs_xyz(m,"lc3"))))
ws_st(m,f,sir_var(m,"ln0",T_V3F,cs_cross(m,cs_xyz(m,"lc1"),cs_xyz(m,"lc2"))))
ws_st(m,f,sir_var(m,"ln1",T_V3F,cs_cross(m,cs_xyz(m,"lc2"),cs_xyz(m,"lc0"))))
ws_st(m,f,sir_var(m,"ln2",T_V3F,cs_cross(m,cs_xyz(m,"lc0"),cs_xyz(m,"lc1"))))
ws_st(m,f,sir_var(m,"ldet",T_F32,cs_dot(m,cs_xyz(m,"lc0"),cs_v3(m,"ln0"))))
let nx:i64=cs_v3mul(m,cs_v3(m,"ln0"),cs_sx3(m,"aN","x"))
let ny:i64=cs_v3mul(m,cs_v3(m,"ln1"),cs_sx3(m,"aN","y"))
let nz:i64=cs_v3mul(m,cs_v3(m,"ln2"),cs_sx3(m,"aN","z"))
ws_st(m,f,sir_var(m,"ln",T_V3F,ws_bin(m,"/",cs_v3add(m,cs_v3add(m,nx,ny),nz),cs_fl(m,"ldet"),T_V3F)))
// Basis is explicitly selected by the prepared asset contract: 0 Z-up, 1 glTF Y-up.
ws_st(m,f,sir_var(m,"lyp",T_V3F,sir_select(m,cs_ieq(m,"uAssetBasis","1"),cs_v3(m,"lp"),cs_yup(m,"lp"),T_V3F)))
ws_st(m,f,sir_var(m,"lyn",T_V3F,sir_select(m,cs_ieq(m,"uAssetBasis","1"),cs_v3(m,"ln"),cs_yup(m,"ln"),T_V3F)))
cs_material_lbs_tangent(m,f)
ws_st(m,f,ws_set(m,cs_v3(m,"vN"),cs_yaw(m,"lyn")))
ws_st(m,f,ws_set(m,cs_v3(m,"vB"),cs_v3(m,"aP")))
ws_st(m,f,sir_var(m,"lrot",T_V3F,cs_yaw(m,"lyp")))
ws_st(m,f,ws_set(m,cs_v3(m,"wp"),cs_v3add(m,cs_idx(m,"uIP",T_V3F,cs_i(m,"ii")),cs_v3mul(m,cs_v3(m,"lrot"),cs_fmul(m,cs_fl(m,"uSc"),cs_ih(m,"z"))))))
return 0
275}
276func cs_lbs_slice(m:*i64,f:i64)->i64 {
ws_st(m,f,sir_var(m,"lr0",T_I32,cs_i32(m,cs_fadd(m,cs_ih(m,"w"),ws_f(m,"0.5")))))
ws_st(m,f,sir_var(m,"lr1",T_I32,cs_iadd(m,cs_i(m,"lr0"),ws_i(m,"1"))))
ws_st(m,f,sir_var(m,"lr2",T_I32,cs_iadd(m,cs_i(m,"lr0"),ws_i(m,"2"))))
ws_st(m,f,sir_var(m,"lr3",T_I32,cs_iadd(m,cs_i(m,"lr0"),ws_i(m,"3"))))
ws_st(m,f,sir_var(m,"lc0",T_V4F,cs_lbs_column(m,"lr0")))
ws_st(m,f,sir_var(m,"lc1",T_V4F,cs_lbs_column(m,"lr1")))
ws_st(m,f,sir_var(m,"lc2",T_V4F,cs_lbs_column(m,"lr2")))
ws_st(m,f,sir_var(m,"lc3",T_V4F,cs_lbs_column(m,"lr3")))
return cs_affine_slice(m,f)
286}
287// Static authored geometry uses node-world columns, not a synthetic skin or vertex joint data.
288func cs_static_slice(m:*i64,f:i64)->i64 {
ws_st(m,f,sir_var(m,"lr0",T_I32,cs_i32(m,cs_fadd(m,cs_ih(m,"w"),ws_f(m,"0.5")))))
ws_st(m,f,sir_var(m,"lr1",T_I32,cs_iadd(m,cs_i(m,"lr0"),ws_i(m,"1"))))
ws_st(m,f,sir_var(m,"lr2",T_I32,cs_iadd(m,cs_i(m,"lr0"),ws_i(m,"2"))))
ws_st(m,f,sir_var(m,"lr3",T_I32,cs_iadd(m,cs_i(m,"lr0"),ws_i(m,"3"))))
ws_st(m,f,sir_var(m,"lc0",T_V4F,sir_texload(m,sir_ident(m,"uJT",T_TEX2F),ws_vt2(m,T_V2I,ws_i(m,"0"),cs_i(m,"lr0")),ws_i(m,"0"))))
ws_st(m,f,sir_var(m,"lc1",T_V4F,sir_texload(m,sir_ident(m,"uJT",T_TEX2F),ws_vt2(m,T_V2I,ws_i(m,"0"),cs_i(m,"lr1")),ws_i(m,"0"))))
ws_st(m,f,sir_var(m,"lc2",T_V4F,sir_texload(m,sir_ident(m,"uJT",T_TEX2F),ws_vt2(m,T_V2I,ws_i(m,"0"),cs_i(m,"lr2")),ws_i(m,"0"))))
ws_st(m,f,sir_var(m,"lc3",T_V4F,sir_texload(m,sir_ident(m,"uJT",T_TEX2F),ws_vt2(m,T_V2I,ws_i(m,"0"),cs_i(m,"lr3")),ws_i(m,"0"))))
return cs_affine_slice(m,f)
298}
299func cs_skin_dispatch(m:*i64,f:i64)->i64 {
ws_st(m,f,sir_var(m,"wp",T_V3F,ws_v1(m,T_V3F,ws_f(m,"0.0"))))
// Unlinked function nodes are statement accumulators; only their body chains are emitted.
let authored:i64=sir_node(m,K_FUNC,T_VOID,0,0,0,0)
let unskinned:i64=sir_node(m,K_FUNC,T_VOID,0,0,0,0)
let skinchoice:i64=sir_node(m,K_FUNC,T_VOID,0,0,0,0)
let legacy:i64=sir_node(m,K_FUNC,T_VOID,0,0,0,0)
cs_static_slice(m,unskinned);cs_lbs_slice(m,authored);cs_slice2(m,legacy);cs_slice3(m,legacy)
ws_st(m,skinchoice,ws_if(m,cs_ieq(m,"uSkinMode","1"),sir_get(m,authored,SIR_B),sir_get(m,legacy,SIR_B)))
ws_st(m,f,ws_if(m,cs_ieq(m,"uSkinMode","2"),sir_get(m,unskinned,SIR_B),sir_get(m,skinchoice,SIR_B)))
return 0
310}
311
312// ---- slice 3 helpers ----
313// uSB[ii*6+<k>]  (k==0 spells uSB[ii*6], exactly as the hand does)
314func cs_sb(m: *i64, k: *u8) -> i64 {
  let base: i64 = cs_imul(m, cs_i(m, "ii" as *u8), ws_i(m, "6" as *u8))
  if k[0] == (48 as u8) { return cs_idx(m, "uSB" as *u8, T_V3F, base) }
  return cs_idx(m, "uSB" as *u8, T_V3F, cs_iadd(m, base, ws_i(m, k)))
318}
319// 1.-smoothstep(0.,<dn>.w*<k>,length(aP-<dn>.xyz))  -- the falloff from one DYNA anchor
320func cs_fall(m: *i64, dn: *u8, k: *u8) -> i64 {
  let d: i64 = ws_c1(m, "length" as *u8, cs_v3sub(m, cs_v3(m, "aP" as *u8), cs_xyz(m, dn)), T_F32)
  return cs_fsub(m, ws_f(m, "1.0" as *u8), cs_ss(m, ws_f(m, "0.0" as *u8), cs_fmul(m, cs_sx4(m, dn, "w" as *u8), ws_f(m, k)), d))
323}
324// <dn>.w>0.5
325func cs_dnon(m: *i64, dn: *u8) -> i64 { return ws_cmp(m, ">" as *u8, cs_sx4(m, dn, "w" as *u8), ws_f(m, "0.5" as *u8)) }
326// (1.-smoothstep(-1000.,-14000.,aP.y))  -- the front gate
327func cs_front(m: *i64) -> i64 {
  return cs_fsub(m, ws_f(m, "1.0" as *u8), cs_ss(m, cs_negf(m, "1000.0" as *u8), cs_negf(m, "14000.0" as *u8), cs_sx3(m, "aP" as *u8, "y" as *u8)))
329}
330// if(<dn>.w>0.5){sbo+=uSB[ii*6+<k>]*(1.-smoothstep(0.,<dn>.w*1.6,length(aP-<dn>.xyz)));}
331func cs_dnadd(m: *i64, dn: *u8, k: *u8) -> i64 {
  return ws_if(m, cs_dnon(m, dn), ws_op(m, "sbo" as *u8, T_V3F, "+" as *u8, cs_v3mul(m, cs_sb(m, k), cs_fall(m, dn, "1.6" as *u8))), 0)
333}
334// if(uDNTl.w>0.5){float <w>=max(fall(uDNTl,1.6),fall(uDNTr,1.6));sbo+=uSB[ii*6+5]*<w>;}
335func cs_thigh(m: *i64, w: *u8) -> i64 {
  let mx: i64 = ws_c2(m, "max" as *u8, cs_fall(m, "uDNTl" as *u8, "1.6" as *u8), cs_fall(m, "uDNTr" as *u8, "1.6" as *u8), T_F32)
  let body: i64 = ws_q2(m, sir_var(m, w, T_F32, mx), ws_op(m, "sbo" as *u8, T_V3F, "+" as *u8, cs_v3mul(m, cs_sb(m, "5" as *u8), cs_fl(m, w))))
  return ws_if(m, cs_dnon(m, "uDNTl" as *u8), body, 0)
339}
340
341// SLICE 3: the soft-body fields over the asset's DYNA anchors -- hair wind, dress inheritance, the body branch
342func cs_slice3(m: *i64, f: i64) -> i64 {
  // float hb2=(aP.z-uZMN)/uH; vec3 sbo=vec3(0.);
  ws_st(m, f, sir_var(m, "hb2" as *u8, T_F32, cs_fdiv(m, cs_fsub(m, cs_sx3(m, "aP" as *u8, "z" as *u8), cs_fl(m, "uZMN" as *u8)), cs_fl(m, "uH" as *u8))))
  ws_st(m, f, sir_var(m, "sbo" as *u8, T_V3F, ws_v1(m, T_V3F, ws_f(m, "0.0" as *u8))))
  // branch 1: if(uHM>1||uGar==2){ tw9 / sbo / wp9 / wind }
  let c1: i64 = ws_or(m, ws_cmp(m, ">" as *u8, cs_i(m, "uHM" as *u8), ws_i(m, "1" as *u8)), ws_cmp(m, "==" as *u8, cs_i(m, "uGar" as *u8), ws_i(m, "2" as *u8)))
  var b1: i64 = 0
  b1 = ws_q2(m, b1, sir_var(m, "tw9" as *u8, T_F32, ws_c3(m, "clamp" as *u8, cs_fmul(m, cs_fsub(m, ws_f(m, "1.02" as *u8), cs_fl(m, "hb2" as *u8)), ws_f(m, "1.7" as *u8)), ws_f(m, "0.0" as *u8), ws_f(m, "1.0" as *u8), T_F32)))
  b1 = ws_q2(m, b1, ws_set(m, cs_v3(m, "sbo" as *u8), cs_v3mul(m, cs_sb(m, "0" as *u8), cs_fl(m, "tw9" as *u8))))
  b1 = ws_q2(m, b1, sir_var(m, "wp9" as *u8, T_F32, cs_fadd(m, cs_fmul(m, cs_fl(m, "uTm" as *u8), ws_f(m, "3.1" as *u8)), cs_fmul(m, cs_fl(m, "vSh" as *u8), ws_f(m, "7.9" as *u8)))))
  let wv: i64 = ws_v3(m, ws_f(m, "0.7" as *u8), cs_fmul(m, ws_f(m, "0.15" as *u8), ws_c1(m, "sin" as *u8, cs_fmul(m, cs_fl(m, "wp9" as *u8), ws_f(m, "1.7" as *u8)), T_F32)), ws_f(m, "0.7" as *u8))
  let wa: i64 = cs_fmul(m, cs_fmul(m, ws_c1(m, "sin" as *u8, cs_fl(m, "wp9" as *u8), T_F32), cs_fl(m, "uWnd" as *u8)), cs_fl(m, "tw9" as *u8))
  b1 = ws_q2(m, b1, ws_op(m, "sbo" as *u8, T_V3F, "+" as *u8, cs_v3mul(m, wv, wa)))
  // branch 2: else if(uGar==1){ dress inherits the body's fields }
  let c2: i64 = ws_cmp(m, "==" as *u8, cs_i(m, "uGar" as *u8), ws_i(m, "1" as *u8))
  var b2: i64 = 0
  b2 = ws_q2(m, b2, ws_set(m, cs_v3(m, "sbo" as *u8), cs_v3mul(m, cs_sb(m, "2" as *u8), cs_fsub(m, ws_f(m, "1.0" as *u8), cs_ssl(m, "0.30" as *u8, "0.55" as *u8, "hb2" as *u8)))))
  var d2: i64 = 0
  d2 = ws_q2(m, d2, sir_var(m, "wLg" as *u8, T_F32, cs_fall(m, "uDNL" as *u8, "1.4" as *u8)))
  d2 = ws_q2(m, d2, sir_var(m, "wRg" as *u8, T_F32, cs_fall(m, "uDNR" as *u8, "1.4" as *u8)))
  d2 = ws_q2(m, d2, ws_op(m, "sbo" as *u8, T_V3F, "+" as *u8, cs_v3mul(m, cs_v3mul(m, cs_sb(m, "1" as *u8), ws_c2(m, "max" as *u8, cs_fl(m, "wLg" as *u8), cs_fl(m, "wRg" as *u8), T_F32)), cs_front(m))))
  b2 = ws_q2(m, b2, ws_if(m, cs_dnon(m, "uDNL" as *u8), d2, 0))
  b2 = ws_q2(m, b2, cs_dnadd(m, "uDNB" as *u8, "3" as *u8))
  b2 = ws_q2(m, b2, cs_dnadd(m, "uDNG" as *u8, "4" as *u8))
  b2 = ws_q2(m, b2, cs_thigh(m, "wT9" as *u8))
  // branch 3: else{ float wB; per-side fields from the asset's own DYNA anchors, or the height band }
  var b3: i64 = 0
  b3 = ws_q2(m, b3, sir_var(m, "wB" as *u8, T_F32, 0))
  var d3: i64 = 0
  d3 = ws_q2(m, d3, sir_var(m, "wL" as *u8, T_F32, cs_fall(m, "uDNL" as *u8, "1.4" as *u8)))
  d3 = ws_q2(m, d3, sir_var(m, "wR" as *u8, T_F32, cs_fall(m, "uDNR" as *u8, "1.4" as *u8)))
  d3 = ws_q2(m, d3, ws_set(m, cs_fl(m, "wB" as *u8), cs_fmul(m, ws_c2(m, "max" as *u8, cs_fl(m, "wL" as *u8), cs_fl(m, "wR" as *u8), T_F32), cs_front(m))))
  let e3a: i64 = cs_fsub(m, ws_f(m, "1.0" as *u8), cs_ss(m, ws_f(m, "0.0" as *u8), ws_f(m, "0.085" as *u8), ws_c1(m, "abs" as *u8, cs_fsub(m, cs_fl(m, "hb2" as *u8), cs_fl(m, "uNIP" as *u8)), T_F32)))
  let e3b: i64 = cs_fsub(m, ws_f(m, "1.0" as *u8), cs_ss(m, ws_f(m, "6000.0" as *u8), ws_f(m, "26000.0" as *u8), ws_c1(m, "abs" as *u8, cs_sx3(m, "aP" as *u8, "x" as *u8), T_F32)))
  let e3: i64 = ws_set(m, cs_fl(m, "wB" as *u8), cs_fmul(m, cs_fmul(m, e3a, e3b), cs_front(m)))
  b3 = ws_q2(m, b3, ws_if(m, cs_dnon(m, "uDNL" as *u8), d3, e3))
  b3 = ws_q2(m, b3, ws_set(m, cs_v3(m, "sbo" as *u8), cs_v3mul(m, cs_sb(m, "1" as *u8), cs_fl(m, "wB" as *u8))))
  b3 = ws_q2(m, b3, cs_dnadd(m, "uDNB" as *u8, "3" as *u8))
  b3 = ws_q2(m, b3, cs_dnadd(m, "uDNG" as *u8, "4" as *u8))
  b3 = ws_q2(m, b3, cs_thigh(m, "wT8" as *u8))
  // the chain: if(c1){b1}else if(c2){b2}else{b3}  -- an else-if is an S_IF as the sole else statement
  ws_st(m, f, ws_if(m, c1, b1, ws_if(m, c2, b2, b3)))
  // wp+=sbo;
  ws_st(m, f, ws_op(m, "wp" as *u8, T_V3F, "+" as *u8, cs_v3(m, "sbo" as *u8)))
  return 0
387}
388
389// ---- slice 4 helpers ----
390// <v3 name>.<sel> as an f32 read of a vec4 uniform (uYPM / uShdP) and of the vec2 uResM
391func cs_ypm(m: *i64, sel: *u8) -> i64 { return cs_sx4(m, "uYPM" as *u8, sel) }
392func cs_res(m: *i64, sel: *u8) -> i64 { return ws_sx(m, "uResM" as *u8, T_V2F, sel, T_F32) }
393// gbm==<k> / hv9==<k>
394func cs_ieq(m: *i64, n: *u8, k: *u8) -> i64 { return ws_cmp(m, "==" as *u8, cs_i(m, n), ws_i(m, k)) }
395// <n>==4||<n>==5||<n>==8||<n>==9  (left-nested)
396func cs_skirt(m: *i64, n: *u8) -> i64 {
  return ws_or(m, ws_or(m, ws_or(m, cs_ieq(m, n, "4" as *u8), cs_ieq(m, n, "5" as *u8)), cs_ieq(m, n, "8" as *u8)), cs_ieq(m, n, "9" as *u8))
398}
399// int(<arr>[ii]+.5)
400func cs_gid(m: *i64, arr: *u8) -> i64 { return cs_i32(m, cs_fadd(m, cs_idx(m, arr, T_F32, cs_i(m, "ii" as *u8)), ws_f(m, "0.5" as *u8))) }
401// vec3(0.,-999.,0.)
402func cs_degen(m: *i64) -> i64 { return ws_v3(m, ws_f(m, "0.0" as *u8), cs_negf(m, "999.0" as *u8), ws_f(m, "0.0" as *u8)) }
403
404// SLICE 4: garment degeneration, the cast-shadow projection, vW, the clip transform
405func cs_slice4(m: *i64, f: i64) -> i64 {
  if csp_ready()!=1{sir_refuse(m,"invalid character projection configuration");return 0-1}
  let projection_guard:*u8=csp_literal(0)
  let projection_sum:*u8=csp_literal(1)
  let projection_difference:*u8=csp_literal(2)
  let projection_product:*u8=csp_literal(3)
  if (projection_guard as i64)<=0||(projection_sum as i64)<=0||(projection_difference as i64)<=0||(projection_product as i64)<=0{if (projection_guard as i64)>0{csp_release(projection_guard)};if (projection_sum as i64)>0{csp_release(projection_sum)};if (projection_difference as i64)>0{csp_release(projection_difference)};if (projection_product as i64)>0{csp_release(projection_product)};sir_refuse(m,"character projection input or literal allocation failure");return 0-1}
412
  // int gbm=int(uGB[ii]+.5);if(uGar==1&&!(gbm==4||gbm==5||gbm==8||gbm==9))wp=vec3(0.,-999.,0.);
  ws_st(m, f, sir_var(m, "gbm" as *u8, T_I32, cs_gid(m, "uGB" as *u8)))
  let cg: i64 = ws_and(m, ws_cmp(m, "==" as *u8, cs_i(m, "uGar" as *u8), ws_i(m, "1" as *u8)), sir_not(m, cs_skirt(m, "gbm" as *u8)))
  ws_st(m, f, ws_if(m, cg, ws_set(m, cs_v3(m, "wp" as *u8), cs_degen(m)), 0))
  // if(uGar==3){int gk9=uGK;int hv9=(gk9==1||gk9==6)?int(uGT[ii]+.5):int(uGB[ii]+.5);bool wr9=(hv9==gk9);if(gk9==8)wr9=(hv9==4||hv9==5||hv9==8||hv9==9);if(!wr9)wp=vec3(0.,-999.,0.);}
  var g3: i64 = 0
  g3 = ws_q2(m, g3, sir_var(m, "gk9" as *u8, T_I32, cs_i(m, "uGK" as *u8)))
  let upper: i64 = ws_or(m, cs_ieq(m, "gk9" as *u8, "1" as *u8), cs_ieq(m, "gk9" as *u8, "6" as *u8))
  g3 = ws_q2(m, g3, sir_var(m, "hv9" as *u8, T_I32, sir_select(m, upper, cs_gid(m, "uGT" as *u8), cs_gid(m, "uGB" as *u8), T_I32)))
  g3 = ws_q2(m, g3, sir_var(m, "wr9" as *u8, T_BOOL, ws_cmp(m, "==" as *u8, cs_i(m, "hv9" as *u8), cs_i(m, "gk9" as *u8))))
  g3 = ws_q2(m, g3, ws_if(m, cs_ieq(m, "gk9" as *u8, "8" as *u8), ws_set(m, sir_ident(m, "wr9" as *u8, T_BOOL), cs_skirt(m, "hv9" as *u8)), 0))
  g3 = ws_q2(m, g3, ws_if(m, sir_not(m, sir_ident(m, "wr9" as *u8, T_BOOL)), ws_set(m, cs_v3(m, "wp" as *u8), cs_degen(m)), 0))
  ws_st(m, f, ws_if(m, ws_cmp(m, "==" as *u8, cs_i(m, "uGar" as *u8), ws_i(m, "3" as *u8)), g3, 0))
  // vSt=0.;
  ws_st(m, f, ws_set(m, cs_fl(m, "vSt" as *u8), ws_f(m, "0.0" as *u8)))
  // if(uShd==1&&wp.y>-900.){float gY9=uIP[ii].y+uShdP.x;vec3 sd9=normalize(uSunM);float sy9=max(sd9.y,uShdP.y);vSt=(wp.y-gY9)/sy9;wp=vec3(wp.x-sd9.x*vSt,gY9,wp.z-sd9.z*vSt);}
  let cs9: i64 = ws_and(m, ws_cmp(m, "==" as *u8, cs_i(m, "uShd" as *u8), ws_i(m, "1" as *u8)), ws_cmp(m, ">" as *u8, cs_sx3(m, "wp" as *u8, "y" as *u8), cs_negf(m, "900.0" as *u8)))
  var s9: i64 = 0
  s9 = ws_q2(m, s9, sir_var(m, "gY9" as *u8, T_F32, cs_fadd(m, ws_sw(m, cs_idx(m, "uIP" as *u8, T_V3F, cs_i(m, "ii" as *u8)), "y" as *u8, T_F32), cs_sx4(m, "uShdP" as *u8, "x" as *u8))))
  s9 = ws_q2(m, s9, sir_var(m, "sd9" as *u8, T_V3F, ws_c1(m, "normalize" as *u8, cs_v3(m, "uSunM" as *u8), T_V3F)))
  s9 = ws_q2(m, s9, sir_var(m, "sy9" as *u8, T_F32, ws_c2(m, "max" as *u8, cs_sx3(m, "sd9" as *u8, "y" as *u8), cs_sx4(m, "uShdP" as *u8, "y" as *u8), T_F32)))
  s9 = ws_q2(m, s9, ws_set(m, cs_fl(m, "vSt" as *u8), cs_fdiv(m, cs_fsub(m, cs_sx3(m, "wp" as *u8, "y" as *u8), cs_fl(m, "gY9" as *u8)), cs_fl(m, "sy9" as *u8))))
  let wpx: i64 = cs_fsub(m, cs_sx3(m, "wp" as *u8, "x" as *u8), cs_fmul(m, cs_sx3(m, "sd9" as *u8, "x" as *u8), cs_fl(m, "vSt" as *u8)))
  let wpz: i64 = cs_fsub(m, cs_sx3(m, "wp" as *u8, "z" as *u8), cs_fmul(m, cs_sx3(m, "sd9" as *u8, "z" as *u8), cs_fl(m, "vSt" as *u8)))
  s9 = ws_q2(m, s9, ws_set(m, cs_v3(m, "wp" as *u8), ws_v3(m, wpx, cs_fl(m, "gY9" as *u8), wpz)))
  ws_st(m, f, ws_if(m, cs9, s9, 0))
  // vW=wp; vec3 rel=wp-uCamM;
  ws_st(m, f, ws_set(m, cs_v3(m, "vW" as *u8), cs_v3(m, "wp" as *u8)))
  ws_st(m, f, sir_var(m, "rel" as *u8, T_V3F, cs_v3sub(m, cs_v3(m, "wp" as *u8), cs_v3(m, "uCamM" as *u8))))
  // vec3 fw=vec3(uYPM.x*uYPM.w,uYPM.z,uYPM.y*uYPM.w);
  ws_st(m, f, sir_var(m, "fw" as *u8, T_V3F, ws_v3(m, cs_fmul(m, cs_ypm(m, "x" as *u8), cs_ypm(m, "w" as *u8)), cs_ypm(m, "z" as *u8), cs_fmul(m, cs_ypm(m, "y" as *u8), cs_ypm(m, "w" as *u8)))))
  // vec3 rt=vec3(uYPM.y,0.,-uYPM.x);
  ws_st(m, f, sir_var(m, "rt" as *u8, T_V3F, ws_v3(m, cs_ypm(m, "y" as *u8), ws_f(m, "0.0" as *u8), sir_neg(m, cs_ypm(m, "x" as *u8), T_F32))))
  // vec3 up=vec3(-uYPM.x*uYPM.z,uYPM.w,-uYPM.y*uYPM.z);  (unary minus binds tighter than *)
  ws_st(m, f, sir_var(m, "up" as *u8, T_V3F, ws_v3(m, cs_fmul(m, sir_neg(m, cs_ypm(m, "x" as *u8), T_F32), cs_ypm(m, "z" as *u8)), cs_ypm(m, "w" as *u8), cs_fmul(m, sir_neg(m, cs_ypm(m, "y" as *u8), T_F32), cs_ypm(m, "z" as *u8)))))
  // float zv=max(dot(rel,fw),.081);
  ws_st(m, f, sir_var(m, "zv" as *u8, T_F32, ws_c2(m, "max" as *u8, cs_dot(m, cs_v3(m, "rel" as *u8), cs_v3(m, "fw" as *u8)), ws_f(m, projection_guard), T_F32)))
  // gl_Position=vec4(dot(rel,rt),dot(rel,up)*(uResM.x/uResM.y),zv*(300.08/299.92)-(48./299.92),zv);
  let px: i64 = cs_dot(m, cs_v3(m, "rel" as *u8), cs_v3(m, "rt" as *u8))
  let py: i64 = cs_fmul(m, cs_dot(m, cs_v3(m, "rel" as *u8), cs_v3(m, "up" as *u8)), cs_fdiv(m, cs_res(m, "x" as *u8), cs_res(m, "y" as *u8)))
  let pz: i64 = cs_fsub(m, cs_fmul(m, cs_fl(m, "zv" as *u8), cs_fdiv(m, ws_f(m, projection_sum), ws_f(m, projection_difference))), cs_fdiv(m, ws_f(m, projection_product), ws_f(m, projection_difference)))
  ws_st(m, f, ws_set(m, sir_builtin(m, "position" as *u8, T_V4F), ws_v4(m, px, py, pz, cs_fl(m, "zv" as *u8))))
  // sir_lit copies text into the module pool; release temporary numeric spellings.
  if (projection_guard as i64)>0{csp_release(projection_guard)};if (projection_sum as i64)>0{csp_release(projection_sum)};if (projection_difference as i64)>0{csp_release(projection_difference)};if (projection_product as i64)>0{csp_release(projection_product)}
  return 0
458}
459
460// SLICE 1 of main: vUV, the instance id, the hair-lock densification prologue, vII -- then the later slices append
461func shsrc_cast_main(m: *i64) -> i64 {
  let f: i64 = sir_func(m, "main" as *u8, T_VOID)
  ws_st(m,f,ws_set(m,cs_v4(m,"vT"),ws_v4(m,ws_f(m,"0.0"),ws_f(m,"0.0"),ws_f(m,"0.0"),ws_f(m,"1.0"))))
  // vUV=aUV;
  ws_st(m, f, ws_set(m, ws_id(m, "vUV" as *u8, T_V2F), ws_id(m, "aUV" as *u8, T_V2F)))
  // int ii=gl_InstanceID;
  ws_st(m, f, sir_var(m, "ii" as *u8, T_I32, sir_builtin(m, "instance_index" as *u8, T_I32)))
  // vec3 jit=vec3(0.);vSh=1.;
  ws_st(m, f, sir_var(m, "jit" as *u8, T_V3F, ws_v1(m, T_V3F, ws_f(m, "0.0" as *u8))))
  ws_st(m, f, ws_set(m, cs_fl(m, "vSh" as *u8), ws_f(m, "1.0" as *u8)))
  // if(uHM>1){ ... }
  var th: i64 = 0
  // int lk=ii-(ii/uHM)*uHM;
  th = ws_q2(m, th, sir_var(m, "lk" as *u8, T_I32, cs_isub(m, cs_i(m, "ii" as *u8), cs_imul(m, cs_idiv(m, cs_i(m, "ii" as *u8), cs_i(m, "uHM" as *u8)), cs_i(m, "uHM" as *u8)))))
  // ii=ii/uHM;
  th = ws_q2(m, th, ws_set(m, cs_i(m, "ii" as *u8), cs_idiv(m, cs_i(m, "ii" as *u8), cs_i(m, "uHM" as *u8))))
  // float f1=hsh(float(lk)+1.),f2=hsh(float(lk)+7.),f3=hsh(float(lk)+13.);
  th = ws_q2(m, th, sir_var(m, "f1" as *u8, T_F32, cs_hsh(m, cs_fadd(m, cs_f32(m, cs_i(m, "lk" as *u8)), ws_f(m, "1.0" as *u8)))))
  th = ws_q2(m, th, sir_var(m, "f2" as *u8, T_F32, cs_hsh(m, cs_fadd(m, cs_f32(m, cs_i(m, "lk" as *u8)), ws_f(m, "7.0" as *u8)))))
  th = ws_q2(m, th, sir_var(m, "f3" as *u8, T_F32, cs_hsh(m, cs_fadd(m, cs_f32(m, cs_i(m, "lk" as *u8)), ws_f(m, "13.0" as *u8)))))
  // float gs9=uGN[ii];
  th = ws_q2(m, th, sir_var(m, "gs9" as *u8, T_F32, cs_idx(m, "uGN" as *u8, T_F32, cs_i(m, "ii" as *u8))))
  // if(hsh(float(lk)+41.)>.72+.15*gs9){gl_Position=vec4(0.,-999.,0.,1.);vB=vec3(0.);vW=vec3(0.,-999.,0.);vN=vec3(0.,1.,0.);vII=ii;vSh=0.;return;}
  let drop: i64 = ws_cmp(m, ">" as *u8, cs_hsh(m, cs_fadd(m, cs_f32(m, cs_i(m, "lk" as *u8)), ws_f(m, "41.0" as *u8))), cs_fadd(m, ws_f(m, "0.72" as *u8), cs_fmul(m, ws_f(m, "0.15" as *u8), cs_fl(m, "gs9" as *u8))))
  var dh: i64 = 0
  dh = ws_q2(m, dh, ws_set(m, sir_builtin(m, "position" as *u8, T_V4F), ws_v4(m, ws_f(m, "0.0" as *u8), cs_negf(m, "999.0" as *u8), ws_f(m, "0.0" as *u8), ws_f(m, "1.0" as *u8))))
  dh = ws_q2(m, dh, ws_set(m, ws_id(m, "vB" as *u8, T_V3F), ws_v1(m, T_V3F, ws_f(m, "0.0" as *u8))))
  dh = ws_q2(m, dh, ws_set(m, ws_id(m, "vW" as *u8, T_V3F), ws_v3(m, ws_f(m, "0.0" as *u8), cs_negf(m, "999.0" as *u8), ws_f(m, "0.0" as *u8))))
  dh = ws_q2(m, dh, ws_set(m, ws_id(m, "vN" as *u8, T_V3F), ws_v3f(m, "0.0" as *u8, "1.0" as *u8, "0.0" as *u8)))
  dh = ws_q2(m, dh, ws_set(m, cs_i(m, "vII" as *u8), cs_i(m, "ii" as *u8)))
  dh = ws_q2(m, dh, ws_set(m, cs_fl(m, "vSh" as *u8), ws_f(m, "0.0" as *u8)))
  dh = ws_q2(m, dh, sir_return(m, 0))
  th = ws_q2(m, th, ws_if(m, drop, dh, 0))
  // float sp9=(.48+.22*hsh(gs9*17.+float(ii)*3.1))*260.;
  let sp9: i64 = cs_fmul(m, cs_fadd(m, ws_f(m, "0.48" as *u8), cs_fmul(m, ws_f(m, "0.22" as *u8), cs_hsh(m, cs_fadd(m, cs_fmul(m, cs_fl(m, "gs9" as *u8), ws_f(m, "17.0" as *u8)), cs_fmul(m, cs_f32(m, cs_i(m, "ii" as *u8)), ws_f(m, "3.1" as *u8)))))), ws_f(m, "260.0" as *u8))
  th = ws_q2(m, th, sir_var(m, "sp9" as *u8, T_F32, sp9))
  // float sw9=(hsh(float(ii)*7.7+2.)-.5)*.9;
  let sw9: i64 = cs_fmul(m, cs_fsub(m, cs_hsh(m, cs_fadd(m, cs_fmul(m, cs_f32(m, cs_i(m, "ii" as *u8)), ws_f(m, "7.7" as *u8)), ws_f(m, "2.0" as *u8))), ws_f(m, "0.5" as *u8)), ws_f(m, "0.9" as *u8))
  th = ws_q2(m, th, sir_var(m, "sw9" as *u8, T_F32, sw9))
  // jit=vec3((f1-.5+sw9*.4)*sp9,(f2-.5)*sp9,(f3-.5)*90.);
  let jx: i64 = cs_fmul(m, cs_fadd(m, cs_fsub(m, cs_fl(m, "f1" as *u8), ws_f(m, "0.5" as *u8)), cs_fmul(m, cs_fl(m, "sw9" as *u8), ws_f(m, "0.4" as *u8))), cs_fl(m, "sp9" as *u8))
  let jy: i64 = cs_fmul(m, cs_fsub(m, cs_fl(m, "f2" as *u8), ws_f(m, "0.5" as *u8)), cs_fl(m, "sp9" as *u8))
  let jz: i64 = cs_fmul(m, cs_fsub(m, cs_fl(m, "f3" as *u8), ws_f(m, "0.5" as *u8)), ws_f(m, "90.0" as *u8))
  th = ws_q2(m, th, ws_set(m, ws_id(m, "jit" as *u8, T_V3F), ws_v3(m, jx, jy, jz)))
  // vSh=.72+.5*hsh(float(lk)+29.);
  th = ws_q2(m, th, ws_set(m, cs_fl(m, "vSh" as *u8), cs_fadd(m, ws_f(m, "0.72" as *u8), cs_fmul(m, ws_f(m, "0.5" as *u8), cs_hsh(m, cs_fadd(m, cs_f32(m, cs_i(m, "lk" as *u8)), ws_f(m, "29.0" as *u8)))))))
  ws_st(m, f, ws_if(m, ws_cmp(m, ">" as *u8, cs_i(m, "uHM" as *u8), ws_i(m, "1" as *u8)), th, 0))
  // vII=ii;
  ws_st(m, f, ws_set(m, cs_i(m, "vII" as *u8), cs_i(m, "ii" as *u8)))
  cs_skin_dispatch(m, f)
  if cs_slice4(m, f)<0{return 0-1}
  return f
513}
514
515// the whole module: declarations, hsh, main (the slices landed so far)
516func shsrc_cast_vs(m: *i64) -> i64 {
  m[M_CLIP_DEPTH] = SIR_CLIP_NEGATIVE_ONE_TO_ONE
  shsrc_cast_decls(m)
  shsrc_cast_fn_hsh(m)
  if shsrc_cast_main(m)<0{return 0-1}
  if m[M_OVER]!=0{return 0-1}
  return 0
523}
524
525// ==== THE CAST FRAGMENT STAGE (S12c-6, 2026-09-05) -- transcribed slice by slice from the SERVED hand text ====
526// Target: buildroot/knowledge/compare/cast_mfs_hand.glsl (the page's own MFS: 34040 B, 5671 raw / 7268 canonical tokens,
527// extracted from sites/nishifamily/world/beach.html -- NEVER from the emitter, which assembles the literal from pieces).
528// Same rules as the vertex stage. The fragment ASSIGNS fc and exits early with a void return (S12c-5 owns the WGSL
529// spelling), block ids are u-suffixed literals (sir_lit_u), the one const local is sir_const. Emitted by `nx_wgsl cast
530// <vs-out> <fs-out>` and measured by nx_glsl_tokdiff against the target with slice_prefix as the per-slice accept predicate.
531//   FS slice 1  declarations + vxm + vmarch + main through the uOcc==2 debug return
532func cs_u(m: *i64, s: *u8) -> i64 { return sir_lit_u(m, s) }
533func cs_v3i(m: *i64, n: *u8) -> i64 { return sir_ident(m, n, T_V3I) }
534func cs_sxi3(m: *i64, n: *u8, sel: *u8) -> i64 { return ws_sx(m, n, T_V3I, sel, T_I32) }
535func cs_u32(m: *i64, n: *u8) -> i64 { return sir_ident(m, n, T_U32) }
536func cs_icmp(m: *i64, op: *u8, n: *u8, k: *u8) -> i64 { return ws_cmp(m, op, cs_i(m, n), ws_i(m, k)) }
537func cs_floor3(m: *i64, e: i64) -> i64 { return ws_c1(m, "floor" as *u8, e, T_V3F) }
538
539// the declarations, in the hand's order (varyings, then uniforms and textures interleaved as written, the output last)
540func shsrc_cast_fs_decls(m: *i64) -> i64 {
  sir_vary(m, "vB" as *u8, T_V3F, 0, 0); sir_vary(m, "vW" as *u8, T_V3F, 1, 0); sir_vary(m, "vN" as *u8, T_V3F, 2, 0)
  sir_vary(m, "vII" as *u8, T_I32, 3, 1); sir_vary(m, "vSh" as *u8, T_F32, 4, 1); sir_vary(m, "vUV" as *u8, T_V2F, 5, 0)
  sir_vary(m, "vSt" as *u8, T_F32, 6, 0)
  sir_uniform(m, "uCamM" as *u8, T_V3F, 0); sir_uniform(m, "uSkTM" as *u8, T_V3F, 0); sir_texture(m, "uVm" as *u8, T_TEX3U); sir_uniform(m, "uOcc" as *u8, T_I32, 0)
  sir_uniform(m, "uCS" as *u8, T_V3F, 12); sir_uniform(m, "uCO" as *u8, T_V3F, 12); sir_uniform(m, "uCH" as *u8, T_V3F, 12); sir_uniform(m, "uGar" as *u8, T_I32, 0)
  sir_uniform(m, "uGN" as *u8, T_F32, 12); sir_uniform(m, "uOF" as *u8, T_F32, 12)
  sir_uniform(m, "uGT" as *u8, T_F32, 12); sir_uniform(m, "uGB" as *u8, T_F32, 12); sir_uniform(m, "uCT" as *u8, T_V3F, 12); sir_uniform(m, "uCB" as *u8, T_V3F, 12)
  sir_uniform(m, "uGK" as *u8, T_I32, 0); sir_uniform(m, "uGM" as *u8, T_I32, 0); sir_uniform(m, "uGMH" as *u8, T_I32, 0)
  sir_uniform(m, "uMoodF" as *u8, T_F32, 12); sir_uniform(m, "uBH" as *u8, T_F32, 12)
  sir_uniform(m, "uTm" as *u8, T_F32, 0)
  sir_uniform(m, "uIH" as *u8, T_V4F, 12)
  sir_uniform(m, "uEyeG" as *u8, T_I32, 0)
  sir_uniform(m, "uAnatM" as *u8, T_I32, 0)
  sir_texture(m, "uAtl" as *u8, T_TEX2F); sir_uniform(m, "uAtlOn" as *u8, T_I32, 0); sir_uniform(m, "uAtlMean" as *u8, T_V3F, 0); sir_uniform(m, "uAuth" as *u8, T_I32, 0)
  sir_uniform(m, "uZMN" as *u8, T_F32, 0); sir_uniform(m, "uH" as *u8, T_F32, 0); sir_uniform(m, "uNIP" as *u8, T_F32, 0); sir_uniform(m, "uEYE" as *u8, T_F32, 0); sir_uniform(m, "uSunM" as *u8, T_V3F, 0)
  sir_uniform(m, "uShd" as *u8, T_I32, 0); sir_uniform(m, "uShdP" as *u8, T_V4F, 0); sir_uniform(m, "uShdK" as *u8, T_V3F, 0); sir_uniform(m, "uSkyF" as *u8, T_V3F, 0); sir_uniform(m, "uVt" as *u8, T_I32, 0)
  sir_texture(m, "uNrm" as *u8, T_TEX2F); sir_uniform(m, "uNrmOn" as *u8, T_I32, 0)
  sir_uniform(m, "uSkinMaps" as *u8, T_I32, 0)
  sir_uniform(m, "uInspect" as *u8, T_I32, 0)
  sir_uniform(m,"uMaterialMode",T_I32,0);sir_uniform(m,"uBaseColorFactor",T_V4F,0);sir_uniform(m,"uAlphaMode",T_I32,0);sir_uniform(m,"uAlphaCutoff",T_F32,0);sir_uniform(m,"uMetallicFactor",T_F32,0);sir_uniform(m,"uRoughnessFactor",T_F32,0);sir_uniform(m,"uEmissiveFactor",T_V3F,0);sir_uniform(m,"uMaterialLight",T_V3F,0);sir_uniform(m,"uMaterialAmbient",T_V3F,0);sir_uniform(m,"uMaterialDoubleSided",T_I32,0)
  sir_uniform(m,"uNrmEncoding",T_I32,0)
  sir_vary(m,"vT",T_V4F,7,0);sir_uniform(m,"uNrmScale",T_F32,0)
  sir_fragout(m, "fc" as *u8, T_V4F, 0)
  return 0
565}
566
567// uint vxm(ivec3 c){if(c.x<0||c.y<0||c.z<0||c.x>127||c.y>47||c.z>127)return 0u;return texelFetch(uVm,ivec3(c.x,c.z,c.y),0).r;}
568func shsrc_cast_fs_vxm(m: *i64) -> i64 {
  let f: i64 = sir_func(m, "vxm" as *u8, T_U32)
  sir_param(m, f, "c" as *u8, T_V3I)
  var o: i64 = ws_or(m, ws_cmp(m, "<" as *u8, cs_sxi3(m, "c" as *u8, "x" as *u8), ws_i(m, "0" as *u8)), ws_cmp(m, "<" as *u8, cs_sxi3(m, "c" as *u8, "y" as *u8), ws_i(m, "0" as *u8)))
  o = ws_or(m, o, ws_cmp(m, "<" as *u8, cs_sxi3(m, "c" as *u8, "z" as *u8), ws_i(m, "0" as *u8)))
  o = ws_or(m, o, ws_cmp(m, ">" as *u8, cs_sxi3(m, "c" as *u8, "x" as *u8), ws_i(m, "127" as *u8)))
  o = ws_or(m, o, ws_cmp(m, ">" as *u8, cs_sxi3(m, "c" as *u8, "y" as *u8), ws_i(m, "47" as *u8)))
  o = ws_or(m, o, ws_cmp(m, ">" as *u8, cs_sxi3(m, "c" as *u8, "z" as *u8), ws_i(m, "127" as *u8)))
  ws_st(m, f, ws_if(m, o, sir_return(m, cs_u(m, "0" as *u8)), 0))
  let co: i64 = ws_vt3(m, T_V3I, cs_sxi3(m, "c" as *u8, "x" as *u8), cs_sxi3(m, "c" as *u8, "z" as *u8), cs_sxi3(m, "c" as *u8, "y" as *u8))
  ws_st(m, f, ws_ret(m, ws_sw(m, sir_texload(m, sir_ident(m, "uVm" as *u8, T_TEX3U), co, ws_i(m, "0" as *u8)), "r" as *u8, T_U32)))
  return f
580}
581
582// float vmarch(vec3 org,vec3 rdm,float lim){...}  -- the ONE voxel DDA (camera occlusion and the shadow's sun path)
583func shsrc_cast_fs_vmarch(m: *i64) -> i64 {
  let f: i64 = sir_func(m, "vmarch" as *u8, T_F32)
  sir_param(m, f, "org" as *u8, T_V3F); sir_param(m, f, "rdm" as *u8, T_V3F); sir_param(m, f, "lim" as *u8, T_F32)
  // ivec3 c=ivec3(floor(org));ivec3 st=ivec3(sign(rdm));vec3 dd=abs(1./max(abs(rdm),vec3(1e-6)));
  ws_st(m, f, sir_var(m, "c" as *u8, T_V3I, ws_v1(m, T_V3I, cs_floor3(m, cs_v3(m, "org" as *u8)))))
  ws_st(m, f, sir_var(m, "st" as *u8, T_V3I, ws_v1(m, T_V3I, ws_c1(m, "sign" as *u8, cs_v3(m, "rdm" as *u8), T_V3F))))
  let mx9: i64 = ws_c2(m, "max" as *u8, ws_c1(m, "abs" as *u8, cs_v3(m, "rdm" as *u8), T_V3F), ws_v1(m, T_V3F, ws_f(m, "1e-6" as *u8)), T_V3F)
  ws_st(m, f, sir_var(m, "dd" as *u8, T_V3F, ws_c1(m, "abs" as *u8, ws_bin(m, "/" as *u8, ws_f(m, "1.0" as *u8), mx9, T_V3F), T_V3F)))
  // vec3 tmm=(vec3(st)*(vec3(c)-org)+vec3(st)*.5+.5)*dd;float t2=0.;
  let t1: i64 = cs_v3mul(m, ws_v1(m, T_V3F, cs_v3i(m, "st" as *u8)), cs_v3sub(m, ws_v1(m, T_V3F, cs_v3i(m, "c" as *u8)), cs_v3(m, "org" as *u8)))
  let t2: i64 = cs_v3mul(m, ws_v1(m, T_V3F, cs_v3i(m, "st" as *u8)), ws_f(m, "0.5" as *u8))
  let tin: i64 = cs_v3add(m, cs_v3add(m, t1, t2), ws_f(m, "0.5" as *u8))
  ws_st(m, f, sir_var(m, "tmm" as *u8, T_V3F, cs_v3mul(m, tin, cs_v3(m, "dd" as *u8))))
  ws_st(m, f, sir_var(m, "t2" as *u8, T_F32, ws_f(m, "0.0" as *u8)))
  // for(int i=0;i<120;i++){ step x / y / z; if(t2>=lim)return -1.; uint b=vxm(c);if(b!=0u&&b!=4u)return t2;}
  let b1: i64 = ws_q3(m, ws_opx(m, "c" as *u8, T_V3I, "x" as *u8, T_I32, "+" as *u8, cs_sxi3(m, "st" as *u8, "x" as *u8)), ws_set(m, cs_fl(m, "t2" as *u8), cs_sx3(m, "tmm" as *u8, "x" as *u8)), ws_opx(m, "tmm" as *u8, T_V3F, "x" as *u8, T_F32, "+" as *u8, cs_sx3(m, "dd" as *u8, "x" as *u8)))
  let b2: i64 = ws_q3(m, ws_opx(m, "c" as *u8, T_V3I, "y" as *u8, T_I32, "+" as *u8, cs_sxi3(m, "st" as *u8, "y" as *u8)), ws_set(m, cs_fl(m, "t2" as *u8), cs_sx3(m, "tmm" as *u8, "y" as *u8)), ws_opx(m, "tmm" as *u8, T_V3F, "y" as *u8, T_F32, "+" as *u8, cs_sx3(m, "dd" as *u8, "y" as *u8)))
  let b3: i64 = ws_q3(m, ws_opx(m, "c" as *u8, T_V3I, "z" as *u8, T_I32, "+" as *u8, cs_sxi3(m, "st" as *u8, "z" as *u8)), ws_set(m, cs_fl(m, "t2" as *u8), cs_sx3(m, "tmm" as *u8, "z" as *u8)), ws_opx(m, "tmm" as *u8, T_V3F, "z" as *u8, T_F32, "+" as *u8, cs_sx3(m, "dd" as *u8, "z" as *u8)))
  let c1: i64 = ws_and(m, ws_cmp(m, "<" as *u8, cs_sx3(m, "tmm" as *u8, "x" as *u8), cs_sx3(m, "tmm" as *u8, "y" as *u8)), ws_cmp(m, "<" as *u8, cs_sx3(m, "tmm" as *u8, "x" as *u8), cs_sx3(m, "tmm" as *u8, "z" as *u8)))
  let c2: i64 = ws_cmp(m, "<" as *u8, cs_sx3(m, "tmm" as *u8, "y" as *u8), cs_sx3(m, "tmm" as *u8, "z" as *u8))
  let if1: i64 = ws_if(m, c1, b1, ws_if(m, c2, b2, b3))
  let if2: i64 = ws_if(m, ws_cmp(m, ">=" as *u8, cs_fl(m, "t2" as *u8), cs_fl(m, "lim" as *u8)), sir_return(m, cs_negf(m, "1.0" as *u8)), 0)
  let bv: i64 = sir_var(m, "b" as *u8, T_U32, ws_c1(m, "vxm" as *u8, cs_v3i(m, "c" as *u8), T_U32))
  let if3: i64 = ws_if(m, ws_and(m, ws_cmp(m, "!=" as *u8, cs_u32(m, "b" as *u8), cs_u(m, "0" as *u8)), ws_cmp(m, "!=" as *u8, cs_u32(m, "b" as *u8), cs_u(m, "4" as *u8))), sir_return(m, cs_fl(m, "t2" as *u8)), 0)
  let body: i64 = ws_q4(m, if1, if2, bv, if3)
  sir_for_until(m, f, sir_var(m, "i" as *u8, T_I32, ws_i(m, "0" as *u8)), cs_icmp(m, ">=" as *u8, "i" as *u8, "120" as *u8), ws_set(m, cs_i(m, "i" as *u8), cs_iadd(m, cs_i(m, "i" as *u8), ws_i(m, "1" as *u8))), body)
  ws_st(m, f, sir_return(m, cs_negf(m, "1.0" as *u8)))
  return f
611}
612
613// FS slice 2 of main: the cast-shadow texel (uShd==1: air here, solid one lift below, sun path clear, contact depth
614// DERIVED from sun height over SHD_CTR blocks), the view vector, the skinned normal and its TEXM normal-map perturbation
615// (uNrmOn==1&&uGar==0, screen-space cotangent frame from dFdx/dFdy), the view-side flip, bind height h, skin tone mc
616// Emit shared byte-contract constants without coupling the renderer to the full baker.
617func cs_normal_number(m:*i64,value:i64,integer:i64)->i64{
let text:*u8=sys_mmap_try(CSP_LITERAL_CAP)
if (text as i64)<=0{sir_refuse(m,"normal encoding literal allocation");return 0}
var n:i64=eb_num(text,0,CSP_LITERAL_CAP,value)
if integer==0{text[n]=46 as u8;text[n+1]=48 as u8;n=n+2}
text[n]=0 as u8
var result:i64=0
if integer==1{result=ws_i(m,text)}else{result=ws_f(m,text)}
sys_munmap_direct(text,CSP_LITERAL_CAP)
return result
627}
628// Input is sampled linear RGB, before normal scale/tangent transform/normalization.
629// Encoding is admitted at the asset boundary; zero is undeclared legacy compatibility.
630func cs_normal_decode_rgb(m:*i64,sample:i64,encoding:i64)->i64{
if sample<=0||encoding<=0{sir_refuse(m,"normal decode missing typed input");return 0}
if sample>=m[M_NCOUNT]||encoding>=m[M_NCOUNT]{sir_refuse(m,"normal decode input outside module");return 0}
if sir_get(m,sample,SIR_TY)!=T_V3F||sir_get(m,encoding,SIR_TY)!=T_I32{sir_refuse(m,"normal decode requires vec3f sample and i32 encoding");return 0}
let maximum:i64=cs_normal_number(m,NTB_GREY_MAX,0)
let midpoint:i64=cs_normal_number(m,NTB_N_MID,0)
let scale:i64=cs_normal_number(m,NTB_N_SCALE,0)
let native_id:i64=cs_normal_number(m,NTB_NORMAL_ENCODING_NATIVE_MID_SCALE,1)
if maximum==0||midpoint==0||scale==0||native_id==0{return 0}
let native:i64=ws_bin(m,"/",cs_v3sub(m,cs_v3mul(m,sample,maximum),midpoint),scale,T_V3F)
let legacy:i64=cs_v3sub(m,cs_v3mul(m,sample,ws_f(m,"2.0")),ws_f(m,"1.0"))
return sir_select(m,ws_cmp(m,"==",encoding,native_id),native,legacy,T_V3F)
642}
643
644func cs_fs_slice2(m: *i64, f: i64) -> i64 {
  // if(uShd==1){uint bg9=vxm(ivec3(floor(vW-vec3(0.,uShdP.x*2.,0.))));if(bg9==0u||bg9==4u)discard;
  let sp: i64 = ws_v3(m, ws_f(m, "0.0" as *u8), cs_fmul(m, cs_sx4(m, "uShdP" as *u8, "x" as *u8), ws_f(m, "2.0" as *u8)), ws_f(m, "0.0" as *u8))
  let bg: i64 = sir_var(m, "bg9" as *u8, T_U32, ws_c1(m, "vxm" as *u8, ws_v1(m, T_V3I, cs_floor3(m, cs_v3sub(m, cs_v3(m, "vW" as *u8), sp))), T_U32))
  let d1: i64 = ws_if(m, ws_or(m, ws_cmp(m, "==" as *u8, cs_u32(m, "bg9" as *u8), cs_u(m, "0" as *u8)), ws_cmp(m, "==" as *u8, cs_u32(m, "bg9" as *u8), cs_u(m, "4" as *u8))), sir_discard(m), 0)
  //   if(vmarch(vW,normalize(uSunM),vSt)>=0.)discard;
  let d2: i64 = ws_if(m, ws_cmp(m, ">=" as *u8, ws_c3(m, "vmarch" as *u8, cs_v3(m, "vW" as *u8), ws_c1(m, "normalize" as *u8, cs_v3(m, "uSunM" as *u8), T_V3F), cs_fl(m, "vSt" as *u8), T_F32), ws_f(m, "0.0" as *u8)), sir_discard(m), 0)
  //   const float SHD_CTR=1.2;float sy8=max(normalize(uSunM).y,uShdP.y);float skm8=dot(uSkyF,vec3(1./3.));
  let kc: i64 = sir_const(m, "SHD_CTR" as *u8, T_F32, ws_f(m, "1.2" as *u8))
  let sy: i64 = sir_var(m, "sy8" as *u8, T_F32, ws_c2(m, "max" as *u8, ws_sw(m, ws_c1(m, "normalize" as *u8, cs_v3(m, "uSunM" as *u8), T_V3F), "y" as *u8, T_F32), cs_sx4(m, "uShdP" as *u8, "y" as *u8), T_F32))
  let sk: i64 = sir_var(m, "skm8" as *u8, T_F32, cs_dot(m, cs_v3(m, "uSkyF" as *u8), ws_v1(m, T_V3F, cs_fdiv(m, ws_f(m, "1.0" as *u8), ws_f(m, "3.0" as *u8)))))
  //   float kc8=sqrt(uShdP.w*skm8/(sy8+skm8));
  let k8: i64 = sir_var(m, "kc8" as *u8, T_F32, ws_c1(m, "sqrt" as *u8, cs_fdiv(m, cs_fmul(m, cs_sx4(m, "uShdP" as *u8, "w" as *u8), cs_fl(m, "skm8" as *u8)), cs_fadd(m, cs_fl(m, "sy8" as *u8), cs_fl(m, "skm8" as *u8))), T_F32))
  //   fc=vec4(uShdK*mix(kc8/max(uShdP.z,.05),1.,smoothstep(0.,SHD_CTR,vSt)),1.);return;}
  let mx: i64 = ws_c3(m, "mix" as *u8, cs_fdiv(m, cs_fl(m, "kc8" as *u8), ws_c2(m, "max" as *u8, cs_sx4(m, "uShdP" as *u8, "z" as *u8), ws_f(m, "0.05" as *u8), T_F32)), ws_f(m, "1.0" as *u8), cs_ss(m, ws_f(m, "0.0" as *u8), cs_fl(m, "SHD_CTR" as *u8), cs_fl(m, "vSt" as *u8)), T_F32)
  let fo: i64 = ws_set(m, cs_v4(m, "fc" as *u8), ws_vt2(m, T_V4F, cs_v3mul(m, cs_v3(m, "uShdK" as *u8), mx), ws_f(m, "1.0" as *u8)))
  ws_st(m, f, ws_if(m, cs_icmp(m, "==" as *u8, "uShd" as *u8, "1" as *u8), ws_q2(m, ws_q5(m, bg, d1, d2, kc, sy), ws_q4(m, sk, k8, fo, sir_return(m, 0))), 0))
  // vec3 vd=normalize(vW-uCamM); vec3 n=normalize(vN);
  ws_st(m, f, sir_var(m, "vd" as *u8, T_V3F, ws_c1(m, "normalize" as *u8, cs_v3sub(m, cs_v3(m, "vW" as *u8), cs_v3(m, "uCamM" as *u8)), T_V3F)))
  ws_st(m, f, sir_var(m, "n" as *u8, T_V3F, ws_c1(m, "normalize" as *u8, cs_v3(m, "vN" as *u8), T_V3F)))
  // if(uNrmOn==1&&uGar==0){vec3 tn=texture(uNrm,vUV).xyz*2.-1.;vec3 dp1=dFdx(vW);vec3 dp2=dFdy(vW);vec2 du1=dFdx(vUV);vec2 du2=dFdy(vUV);
  let tn_sample:i64=sir_var(m,"tnSample",T_V3F,ws_sw(m,sir_texsample(m,sir_ident(m,"uNrm",T_TEX2F),sir_ident(m,"vUV",T_V2F)),"xyz",T_V3F))
  let tn_decoded:i64=cs_normal_decode_rgb(m,cs_v3(m,"tnSample"),cs_i(m,"uNrmEncoding"))
  if tn_decoded==0{return 0-1}
  let tn:i64=ws_q2(m,tn_sample,sir_var(m,"tn",T_V3F,tn_decoded))
  let p1: i64 = sir_var(m, "dp1" as *u8, T_V3F, ws_c1(m, "dpdx" as *u8, cs_v3(m, "vW" as *u8), T_V3F))
  let p2: i64 = sir_var(m, "dp2" as *u8, T_V3F, ws_c1(m, "dpdy" as *u8, cs_v3(m, "vW" as *u8), T_V3F))
  let u1: i64 = sir_var(m, "du1" as *u8, T_V2F, ws_c1(m, "dpdx" as *u8, sir_ident(m, "vUV" as *u8, T_V2F), T_V2F))
  let u2: i64 = sir_var(m, "du2" as *u8, T_V2F, ws_c1(m, "dpdy" as *u8, sir_ident(m, "vUV" as *u8, T_V2F), T_V2F))
  //   vec3 dp2p=cross(dp2,n);vec3 dp1p=cross(n,dp1);vec3 T9=dp2p*du1.x+dp1p*du2.x;vec3 B9=dp2p*du1.y+dp1p*du2.y;
  let q2: i64 = sir_var(m, "dp2p" as *u8, T_V3F, cs_cross(m, cs_v3(m, "dp2" as *u8), cs_v3(m, "n" as *u8)))
  let q1: i64 = sir_var(m, "dp1p" as *u8, T_V3F, cs_cross(m, cs_v3(m, "n" as *u8), cs_v3(m, "dp1" as *u8)))
  let t9: i64 = sir_var(m, "T9" as *u8, T_V3F, cs_v3add(m, cs_v3mul(m, cs_v3(m, "dp2p" as *u8), ws_sx(m, "du1" as *u8, T_V2F, "x" as *u8, T_F32)), cs_v3mul(m, cs_v3(m, "dp1p" as *u8), ws_sx(m, "du2" as *u8, T_V2F, "x" as *u8, T_F32))))
  let b9: i64 = sir_var(m, "B9" as *u8, T_V3F, cs_v3add(m, cs_v3mul(m, cs_v3(m, "dp2p" as *u8), ws_sx(m, "du1" as *u8, T_V2F, "y" as *u8, T_F32)), cs_v3mul(m, cs_v3(m, "dp1p" as *u8), ws_sx(m, "du2" as *u8, T_V2F, "y" as *u8, T_F32))))
  //   float im9=inversesqrt(max(dot(T9,T9),dot(B9,B9))+1e-12);n=normalize(mat3(T9*im9,B9*im9,n)*tn);}
  let i9: i64 = sir_var(m, "im9" as *u8, T_F32, ws_c1(m, "inverseSqrt" as *u8, cs_fadd(m, ws_c2(m, "max" as *u8, cs_dot(m, cs_v3(m, "T9" as *u8), cs_v3(m, "T9" as *u8)), cs_dot(m, cs_v3(m, "B9" as *u8), cs_v3(m, "B9" as *u8)), T_F32), ws_f(m, "1e-12" as *u8)), T_F32))
  let m3: i64 = ws_vt3(m, T_M3F, cs_v3mul(m, cs_v3(m, "T9" as *u8), cs_fl(m, "im9" as *u8)), cs_v3mul(m, cs_v3(m, "B9" as *u8), cs_fl(m, "im9" as *u8)), cs_v3(m, "n" as *u8))
  let nn: i64 = ws_set(m, cs_v3(m, "n" as *u8), ws_c1(m, "normalize" as *u8, ws_bin(m, "*" as *u8, m3, cs_v3(m, "tn" as *u8), T_V3F), T_V3F))
  ws_st(m, f, ws_if(m, ws_and(m, cs_icmp(m, "==" as *u8, "uNrmOn" as *u8, "1" as *u8), cs_icmp(m, "==" as *u8, "uGar" as *u8, "0" as *u8)), ws_q3(m, ws_q5(m, tn, p1, p2, u1, u2), ws_q5(m, q2, q1, t9, b9, i9), nn), 0))
  // if(dot(n,vd)>0.)n=-n; float h=(vB.z-uZMN)/uH; vec3 mc=uCS[vII];
  ws_st(m, f, ws_if(m, ws_cmp(m, ">" as *u8, cs_dot(m, cs_v3(m, "n" as *u8), cs_v3(m, "vd" as *u8)), ws_f(m, "0.0" as *u8)), ws_set(m, cs_v3(m, "n" as *u8), sir_neg(m, cs_v3(m, "n" as *u8), T_V3F)), 0))
  ws_st(m, f, sir_var(m, "h" as *u8, T_F32, cs_fdiv(m, cs_fsub(m, cs_sx3(m, "vB" as *u8, "z" as *u8), cs_fl(m, "uZMN" as *u8)), cs_fl(m, "uH" as *u8))))
  ws_st(m, f, sir_var(m, "mc" as *u8, T_V3F, cs_idx(m, "uCS" as *u8, T_V3F, cs_i(m, "vII" as *u8))))
  return 0
688}
689
690// ---- slice 3 helpers: the cloth pass and the light twins the hair and skin tails share ----
691// uGM==<k>
692func cs_gm(m: *i64, k: *u8) -> i64 { return cs_icmp(m, "==" as *u8, "uGM" as *u8, k) }
693// vec3(<one literal>)
694func cs_v3l(m: *i64, s: *u8) -> i64 { return ws_v1(m, T_V3F, ws_f(m, s)) }
695// vec3 <n>=1.-exp(-vec3(.123,.287,.700)*length(vW-uCamM)/168.);  -- the fog twin (world FSH derivation), declared as n
696func cs_fog(m: *i64, n: *u8) -> i64 {
  let e: i64 = ws_bin(m, "/" as *u8, cs_v3mul(m, sir_neg(m, ws_v3f(m, "0.123" as *u8, "0.287" as *u8, "0.700" as *u8), T_V3F), ws_c1(m, "length" as *u8, cs_v3sub(m, cs_v3(m, "vW" as *u8), cs_v3(m, "uCamM" as *u8)), T_F32)), ws_f(m, "168.0" as *u8), T_V3F)
  return sir_var(m, n, T_V3F, ws_bin(m, "-" as *u8, ws_f(m, "1.0" as *u8), ws_c1(m, "exp" as *u8, e, T_V3F), T_V3F))
699}
700// if(uVt==1)<n>=vec3(.94)*pow(max(<n>,vec3(0.))*(1./.94),vec3(1.45));  -- the grade twin
701func cs_grade(m: *i64, n: *u8) -> i64 {
  let inner: i64 = cs_v3mul(m, ws_c2(m, "max" as *u8, cs_v3(m, n), cs_v3l(m, "0.0" as *u8), T_V3F), cs_fdiv(m, ws_f(m, "1.0" as *u8), ws_f(m, "0.94" as *u8)))
  let p: i64 = ws_c2(m, "pow" as *u8, inner, cs_v3l(m, "1.45" as *u8), T_V3F)
  return ws_if(m, cs_icmp(m, "==" as *u8, "uVt" as *u8, "1" as *u8), ws_set(m, cs_v3(m, n), cs_v3mul(m, cs_v3l(m, "0.94" as *u8), p)), 0)
705}
706// vec3 <n>=(dot(uSunM,uSunM)>.01)?normalize(uSunM):<els>;  -- the sun direction with its declared fallback
707func cs_sunL(m: *i64, n: *u8, els: i64) -> i64 {
  let c: i64 = ws_cmp(m, ">" as *u8, cs_dot(m, cs_v3(m, "uSunM" as *u8), cs_v3(m, "uSunM" as *u8)), ws_f(m, "0.01" as *u8))
  return sir_var(m, n, T_V3F, sir_select(m, c, ws_c1(m, "normalize" as *u8, cs_v3(m, "uSunM" as *u8), T_V3F), els, T_V3F))
710}
711// normalize(vec3(2400.,2500.,1400.))  -- the page's fixed sun when uSunM is unset
712func cs_sun0(m: *i64) -> i64 { return ws_c1(m, "normalize" as *u8, ws_v3f(m, "2400.0" as *u8, "2500.0" as *u8, "1400.0" as *u8), T_V3F) }
713// float <sv>=1.;if(uOcc>=1){float <t>=(floor(vW.y)+1.2-vW.y)/max(<L>.y,.2);if(vmarch(vW+<L>*<t>,<L>,40.)>=0.)<sv>=0.;}
714// -- the voxel sun-visibility march (one shape, three consumers: cloth svg9, hair sv8, skin sv9); returns the two statements as a seq
715// -- split in two because a SEQ handed to sir_stmt at FUNCTION scope keeps only its first child (measured on slice 7:
716//    first_diff=6968 a_tok=vec3 b_tok=if, the if had vanished); inside a block a seq nests fine, so cs_sunvis stays for those
717func cs_sunvis_decl(m: *i64, sv: *u8) -> i64 { return sir_var(m, sv, T_F32, ws_f(m, "1.0" as *u8)) }
718func cs_sunvis_if(m: *i64, sv: *u8, t: *u8, L: *u8) -> i64 {
  let num: i64 = cs_fsub(m, cs_fadd(m, ws_c1(m, "floor" as *u8, cs_sx3(m, "vW" as *u8, "y" as *u8), T_F32), ws_f(m, "1.2" as *u8)), cs_sx3(m, "vW" as *u8, "y" as *u8))
  let tv: i64 = sir_var(m, t, T_F32, cs_fdiv(m, num, ws_c2(m, "max" as *u8, cs_sx3(m, L, "y" as *u8), ws_f(m, "0.2" as *u8), T_F32)))
  let mv: i64 = ws_c3(m, "vmarch" as *u8, cs_v3add(m, cs_v3(m, "vW" as *u8), cs_v3mul(m, cs_v3(m, L), cs_fl(m, t))), cs_v3(m, L), ws_f(m, "40.0" as *u8), T_F32)
  let z: i64 = ws_if(m, ws_cmp(m, ">=" as *u8, mv, ws_f(m, "0.0" as *u8)), ws_set(m, cs_fl(m, sv), ws_f(m, "0.0" as *u8)), 0)
  return ws_if(m, cs_icmp(m, ">=" as *u8, "uOcc" as *u8, "1" as *u8), ws_q2(m, tv, z), 0)
724}
725func cs_sunvis(m: *i64, sv: *u8, t: *u8, L: *u8) -> i64 { return ws_q2(m, cs_sunvis_decl(m, sv), cs_sunvis_if(m, sv, t, L)) }
726// sin(fract(<e>)*<k>)
727func cs_sinfr(m: *i64, e: i64, k: *u8) -> i64 { return ws_c1(m, "sin" as *u8, cs_fmul(m, ws_c1(m, "fract" as *u8, e, T_F32), ws_f(m, k)), T_F32) }
728// kq.<sel>
729func cs_kq(m: *i64, sel: *u8) -> i64 { return ws_sx(m, "kq" as *u8, T_V2F, sel, T_F32) }
730
731// FS slice 3 of main: the cloth pass (uGar==3) -- Lambert base + the Charlie sheen lobe (Estevez and Kulla 2017) with the
732// Neubelt and Pettineo 2013 visibility over the skin pass's declared light twins, a mm-scale weave relief per material class,
733// the fog and grade twins; RETURNS, so no skin code runs on cloth
734func cs_fs_slice3(m: *i64, f: i64) -> i64 {
  // vec3 tg9=(uGK==1||uGK==6)?uCT[vII]:uCB[vII];
  let tg: i64 = sir_var(m, "tg9" as *u8, T_V3F, sir_select(m, ws_or(m, cs_icmp(m, "==" as *u8, "uGK" as *u8, "1" as *u8), cs_icmp(m, "==" as *u8, "uGK" as *u8, "6" as *u8)), cs_idx(m, "uCT" as *u8, T_V3F, cs_i(m, "vII" as *u8)), cs_idx(m, "uCB" as *u8, T_V3F, cs_i(m, "vII" as *u8)), T_V3F))
  // vec3 Lg9=(dot(uSunM,uSunM)>.01)?normalize(uSunM):normalize(vec3(2400.,2500.,1400.)); float svg9=1.;if(uOcc>=1){...}
  let lg: i64 = cs_sunL(m, "Lg9" as *u8, cs_sun0(m))
  let sv: i64 = cs_sunvis(m, "svg9" as *u8, "t0g" as *u8, "Lg9" as *u8)
  // vec3 Vg9=-vd;vec3 Hg9=normalize(Lg9+Vg9);
  let vg: i64 = sir_var(m, "Vg9" as *u8, T_V3F, sir_neg(m, cs_v3(m, "vd" as *u8), T_V3F))
  let hg: i64 = sir_var(m, "Hg9" as *u8, T_V3F, ws_c1(m, "normalize" as *u8, cs_v3add(m, cs_v3(m, "Lg9" as *u8), cs_v3(m, "Vg9" as *u8)), T_V3F))
  // float nlg=max(dot(n,Lg9),0.),nvg=max(dot(n,Vg9),1e-3),nhg=max(dot(n,Hg9),0.);
  let nl: i64 = sir_var(m, "nlg" as *u8, T_F32, ws_c2(m, "max" as *u8, cs_dot(m, cs_v3(m, "n" as *u8), cs_v3(m, "Lg9" as *u8)), ws_f(m, "0.0" as *u8), T_F32))
  let nv: i64 = sir_var(m, "nvg" as *u8, T_F32, ws_c2(m, "max" as *u8, cs_dot(m, cs_v3(m, "n" as *u8), cs_v3(m, "Vg9" as *u8)), ws_f(m, "1e-3" as *u8), T_F32))
  let nh: i64 = sir_var(m, "nhg" as *u8, T_F32, ws_c2(m, "max" as *u8, cs_dot(m, cs_v3(m, "n" as *u8), cs_v3(m, "Hg9" as *u8)), ws_f(m, "0.0" as *u8), T_F32))
  // float mmg=uH/1780.;float wvg=1.;
  let mm: i64 = sir_var(m, "mmg" as *u8, T_F32, cs_fdiv(m, cs_fl(m, "uH" as *u8), ws_f(m, "1780.0" as *u8)))
  let wv: i64 = sir_var(m, "wvg" as *u8, T_F32, ws_f(m, "1.0" as *u8))
  // if(uGM==3){vec2 kq=vec2(vB.x/(mmg*.9),vB.z/(mmg*1.3));wvg=.94+.06*sin(fract(kq.x)*6.2832)*sin(fract(kq.y)*6.2832);}
  let kq3: i64 = sir_var(m, "kq" as *u8, T_V2F, ws_v2(m, cs_fdiv(m, cs_sx3(m, "vB" as *u8, "x" as *u8), cs_fmul(m, cs_fl(m, "mmg" as *u8), ws_f(m, "0.9" as *u8))), cs_fdiv(m, cs_sx3(m, "vB" as *u8, "z" as *u8), cs_fmul(m, cs_fl(m, "mmg" as *u8), ws_f(m, "1.3" as *u8)))))
  let w3: i64 = ws_set(m, cs_fl(m, "wvg" as *u8), cs_fadd(m, ws_f(m, "0.94" as *u8), cs_fmul(m, cs_fmul(m, ws_f(m, "0.06" as *u8), cs_sinfr(m, cs_kq(m, "x" as *u8), "6.2832" as *u8)), cs_sinfr(m, cs_kq(m, "y" as *u8), "6.2832" as *u8))))
  // else if(uGM==2){vec2 kq=vB.xz/(mmg*.5);wvg=.96+.04*abs(sin(fract(kq.x)*3.1416))*abs(sin(fract(kq.y)*3.1416));}
  let kq2: i64 = sir_var(m, "kq" as *u8, T_V2F, ws_bin(m, "/" as *u8, ws_sx(m, "vB" as *u8, T_V3F, "xz" as *u8, T_V2F), cs_fmul(m, cs_fl(m, "mmg" as *u8), ws_f(m, "0.5" as *u8)), T_V2F))
  let w2: i64 = ws_set(m, cs_fl(m, "wvg" as *u8), cs_fadd(m, ws_f(m, "0.96" as *u8), cs_fmul(m, cs_fmul(m, ws_f(m, "0.04" as *u8), ws_c1(m, "abs" as *u8, cs_sinfr(m, cs_kq(m, "x" as *u8), "3.1416" as *u8), T_F32)), ws_c1(m, "abs" as *u8, cs_sinfr(m, cs_kq(m, "y" as *u8), "3.1416" as *u8), T_F32))))
  // else if(uGM==1){wvg=.97+.03*sin(fract(vB.x/(mmg*.6))*6.2832);}
  let w1: i64 = ws_set(m, cs_fl(m, "wvg" as *u8), cs_fadd(m, ws_f(m, "0.97" as *u8), cs_fmul(m, ws_f(m, "0.03" as *u8), cs_sinfr(m, cs_fdiv(m, cs_sx3(m, "vB" as *u8, "x" as *u8), cs_fmul(m, cs_fl(m, "mmg" as *u8), ws_f(m, "0.6" as *u8))), "6.2832" as *u8))))
  let wif: i64 = ws_if(m, cs_gm(m, "3" as *u8), ws_q2(m, kq3, w3), ws_if(m, cs_gm(m, "2" as *u8), ws_q2(m, kq2, w2), ws_if(m, cs_gm(m, "1" as *u8), w1, 0)))
  // float ag9=(uGM==4)?.15:(uGM==3?.55:(uGM==2?.4:.3));
  let ag: i64 = sir_var(m, "ag9" as *u8, T_F32, sir_select(m, cs_gm(m, "4" as *u8), ws_f(m, "0.15" as *u8), sir_select(m, cs_gm(m, "3" as *u8), ws_f(m, "0.55" as *u8), sir_select(m, cs_gm(m, "2" as *u8), ws_f(m, "0.4" as *u8), ws_f(m, "0.3" as *u8), T_F32), T_F32), T_F32))
  // float ig9=1./ag9;float s2g=max(1.-nhg*nhg,1e-4);float Dg9=(2.+ig9)*pow(s2g,ig9*.5)*.159155;
  let ig: i64 = sir_var(m, "ig9" as *u8, T_F32, cs_fdiv(m, ws_f(m, "1.0" as *u8), cs_fl(m, "ag9" as *u8)))
  let s2: i64 = sir_var(m, "s2g" as *u8, T_F32, ws_c2(m, "max" as *u8, cs_fsub(m, ws_f(m, "1.0" as *u8), cs_fmul(m, cs_fl(m, "nhg" as *u8), cs_fl(m, "nhg" as *u8))), ws_f(m, "1e-4" as *u8), T_F32))
  let dg: i64 = sir_var(m, "Dg9" as *u8, T_F32, cs_fmul(m, cs_fmul(m, cs_fadd(m, ws_f(m, "2.0" as *u8), cs_fl(m, "ig9" as *u8)), ws_c2(m, "pow" as *u8, cs_fl(m, "s2g" as *u8), cs_fmul(m, cs_fl(m, "ig9" as *u8), ws_f(m, "0.5" as *u8)), T_F32)), ws_f(m, "0.159155" as *u8)))
  // float Vsg=1./(4.*max(nlg+nvg,1e-3));
  let vs: i64 = sir_var(m, "Vsg" as *u8, T_F32, cs_fdiv(m, ws_f(m, "1.0" as *u8), cs_fmul(m, ws_f(m, "4.0" as *u8), ws_c2(m, "max" as *u8, cs_fadd(m, cs_fl(m, "nlg" as *u8), cs_fl(m, "nvg" as *u8)), ws_f(m, "1e-3" as *u8), T_F32))))
  // vec3 shg=(uGM==4)?mix(vec3(1.),tg9,.5):mix(vec3(1.),tg9,.15);
  let sh: i64 = sir_var(m, "shg" as *u8, T_V3F, sir_select(m, cs_gm(m, "4" as *u8), ws_c3(m, "mix" as *u8, cs_v3l(m, "1.0" as *u8), cs_v3(m, "tg9" as *u8), ws_f(m, "0.5" as *u8), T_V3F), ws_c3(m, "mix" as *u8, cs_v3l(m, "1.0" as *u8), cs_v3(m, "tg9" as *u8), ws_f(m, "0.15" as *u8), T_V3F), T_V3F))
  // float ksg=(uGM==4)?.35:(uGM==3?.12:(uGM==2?.10:.16));
  let ks: i64 = sir_var(m, "ksg" as *u8, T_F32, sir_select(m, cs_gm(m, "4" as *u8), ws_f(m, "0.35" as *u8), sir_select(m, cs_gm(m, "3" as *u8), ws_f(m, "0.12" as *u8), sir_select(m, cs_gm(m, "2" as *u8), ws_f(m, "0.10" as *u8), ws_f(m, "0.16" as *u8), T_F32), T_F32), T_F32))
  // vec3 alg=tg9*tg9*wvg;
  let al: i64 = sir_var(m, "alg" as *u8, T_V3F, cs_v3mul(m, cs_v3mul(m, cs_v3(m, "tg9" as *u8), cs_v3(m, "tg9" as *u8)), cs_fl(m, "wvg" as *u8)))
  // vec3 ling=alg*(uSkyF+1.008*nlg*svg9)+alg*vec3(.17,.14,.095)*max(0.,-n.y)*(.35+.65*svg9)+vec3(1.,.94,.81)*1.008*shg*Dg9*Vsg*nlg*ksg*svg9;
  let la: i64 = cs_v3mul(m, cs_v3(m, "alg" as *u8), ws_bin(m, "+" as *u8, cs_v3(m, "uSkyF" as *u8), cs_fmul(m, cs_fmul(m, ws_f(m, cs_scene_direct_diffuse()), cs_fl(m, "nlg" as *u8)), cs_fl(m, "svg9" as *u8)), T_V3F))
  let lb: i64 = cs_v3mul(m, cs_v3mul(m, cs_v3mul(m, cs_v3(m, "alg" as *u8), ws_v3f(m, "0.17" as *u8, "0.14" as *u8, "0.095" as *u8)), ws_c2(m, "max" as *u8, ws_f(m, "0.0" as *u8), sir_neg(m, cs_sx3(m, "n" as *u8, "y" as *u8), T_F32), T_F32)), cs_fadd(m, ws_f(m, "0.35" as *u8), cs_fmul(m, ws_f(m, "0.65" as *u8), cs_fl(m, "svg9" as *u8))))
  let lc: i64 = cs_v3mul(m, cs_v3mul(m, cs_v3mul(m, cs_v3mul(m, cs_v3mul(m, cs_v3mul(m, cs_v3mul(m, ws_v3f(m, "1.0" as *u8, "0.94" as *u8, "0.81" as *u8), ws_f(m, cs_scene_direct_diffuse())), cs_v3(m, "shg" as *u8)), cs_fl(m, "Dg9" as *u8)), cs_fl(m, "Vsg" as *u8)), cs_fl(m, "nlg" as *u8)), cs_fl(m, "ksg" as *u8)), cs_fl(m, "svg9" as *u8))
  let li: i64 = sir_var(m, "ling" as *u8, T_V3F, cs_v3add(m, cs_v3add(m, la, lb), lc))
  // if(uGM==4)ling+=vec3(1.,.94,.81)*pow(nhg,60.)*.25*svg9;
  let l4: i64 = ws_if(m, cs_gm(m, "4" as *u8), ws_op(m, "ling" as *u8, T_V3F, "+" as *u8, cs_v3mul(m, cs_v3mul(m, cs_v3mul(m, ws_v3f(m, "1.0" as *u8, "0.94" as *u8, "0.81" as *u8), ws_c2(m, "pow" as *u8, cs_fl(m, "nhg" as *u8), ws_f(m, "60.0" as *u8), T_F32)), ws_f(m, "0.25" as *u8)), cs_fl(m, "svg9" as *u8))), 0)
  // vec3 cg9=sqrt(max(ling,vec3(0.))); vec3 fwg=...; cg9=mix(cg9,uSkTM,fwg); if(uVt==1)cg9=...; fc=vec4(cg9,1.);return;
  let cg: i64 = sir_var(m, "cg9" as *u8, T_V3F, ws_c1(m, "sqrt" as *u8, ws_c2(m, "max" as *u8, cs_v3(m, "ling" as *u8), cs_v3l(m, "0.0" as *u8), T_V3F), T_V3F))
  let fw: i64 = cs_fog(m, "fwg" as *u8)
  let mx: i64 = ws_set(m, cs_v3(m, "cg9" as *u8), ws_c3(m, "mix" as *u8, cs_v3(m, "cg9" as *u8), cs_v3(m, "uSkTM" as *u8), cs_v3(m, "fwg" as *u8), T_V3F))
  let gr: i64 = cs_grade(m, "cg9" as *u8)
  let fo: i64 = ws_set(m, cs_v4(m, "fc" as *u8), ws_vt2(m, T_V4F, cs_v3(m, "cg9" as *u8), ws_f(m, "1.0" as *u8)))
  let body: i64 = ws_q3(m, ws_q2(m, ws_q5(m, tg, lg, sv, vg, hg), ws_q5(m, nl, nv, nh, mm, wv)), ws_q2(m, ws_q5(m, wif, ag, ig, s2, dg), ws_q5(m, vs, sh, ks, al, li)), ws_q2(m, ws_q5(m, l4, cg, fw, mx, gr), ws_q2(m, fo, sir_return(m, 0))))
  ws_st(m, f, ws_if(m, cs_icmp(m, "==" as *u8, "uGar" as *u8, "3" as *u8), body, 0))
  return 0
789}
790
791// ---- slice 4 helpers: the bands and the genome paint ----
792func cs_b(m: *i64, n: *u8) -> i64 { return sir_ident(m, n, T_BOOL) }
793// bool <n>=(uGMH&<bit>)==0;  -- one bit of the garment-MESH mask per garment id
794func cs_pm(m: *i64, n: *u8, bit: *u8) -> i64 { return sir_var(m, n, T_BOOL, ws_cmp(m, "==" as *u8, ws_bin(m, "&" as *u8, cs_i(m, "uGMH" as *u8), ws_i(m, bit), T_I32), ws_i(m, "0" as *u8))) }
795// h <op> <lit>
796func cs_h(m: *i64, op: *u8, lit: *u8) -> i64 { return ws_cmp(m, op, cs_fl(m, "h" as *u8), ws_f(m, lit)) }
797// h<uNIP+.055  -- the garment top edge DERIVED from the bust line
798func cs_hnip(m: *i64) -> i64 { return ws_cmp(m, "<" as *u8, cs_fl(m, "h" as *u8), cs_fadd(m, cs_fl(m, "uNIP" as *u8), ws_f(m, "0.055" as *u8))) }
799// axb<15000.  -- the torso gate
800func cs_axb(m: *i64) -> i64 { return ws_cmp(m, "<" as *u8, cs_fl(m, "axb" as *u8), ws_f(m, "15000.0" as *u8)) }
801// <arr>[vII] for the vec3[12] genome arrays (uCT uCB uCH uCS) and the float[12] ones (uGT uGB uOF uGN uBH)
802func cs_g3(m: *i64, arr: *u8) -> i64 { return cs_idx(m, arr, T_V3F, cs_i(m, "vII" as *u8)) }
803func cs_gf(m: *i64, arr: *u8) -> i64 { return cs_idx(m, arr, T_F32, cs_i(m, "vII" as *u8)) }
804// vB.y <op> <e>
805func cs_vby(m: *i64, op: *u8, e: i64) -> i64 { return ws_cmp(m, op, cs_sx3(m, "vB" as *u8, "y" as *u8), e) }
806// uAuth==0
807func cs_auth0(m: *i64) -> i64 { return cs_icmp(m, "==" as *u8, "uAuth" as *u8, "0" as *u8) }
808// a&&b&&c / a&&b&&c&&d, left-nested as the grammar parses them
809func cs_and3(m: *i64, a: i64, b: i64, c: i64) -> i64 { return ws_and(m, ws_and(m, a, b), c) }
810func cs_and4(m: *i64, a: i64, b: i64, c: i64, d: i64) -> i64 { return ws_and(m, cs_and3(m, a, b, c), d) }
811// abs(h-uNIP)<.055
812func cs_nipband(m: *i64) -> i64 { return ws_cmp(m, "<" as *u8, ws_c1(m, "abs" as *u8, cs_fsub(m, cs_fl(m, "h" as *u8), cs_fl(m, "uNIP" as *u8)), T_F32), ws_f(m, "0.055" as *u8)) }
813
814// FS slice 4 of main: atlas albedo containment (uAtlOn, ATL_W/ATL_R), the torso-gated garment bands BY GARMENT ID under
815// the uGMH mesh mask, bare chest detail at anatomy-ratio positions, body hair (mons and axilla), foot contact AO, the
816// hair cap and the wig-line feather
817func cs_fs_slice4(m: *i64, f: i64) -> i64 {
  // if(uAtlOn==1&&uGar==0){vec3 t9=texture(uAtl,vUV).rgb;if(uAuth==1){mc=t9;}else{const float ATL_W=.5;const float ATL_R=.18;
  //   vec3 t9n=t9/max(uAtlMean,vec3(1./255.));mc*=clamp(mix(vec3(1.),t9n,ATL_W),vec3(1.-ATL_R),vec3(1.+ATL_R));}}
  let t9: i64 = sir_var(m, "t9" as *u8, T_V3F, ws_sw(m, sir_texsample(m, sir_ident(m, "uAtl" as *u8, T_TEX2F), sir_ident(m, "vUV" as *u8, T_V2F)), "rgb" as *u8, T_V3F))
  let aw: i64 = sir_const(m, "ATL_W" as *u8, T_F32, ws_f(m, "0.5" as *u8))
  let ar: i64 = sir_const(m, "ATL_R" as *u8, T_F32, ws_f(m, "0.18" as *u8))
  let tn: i64 = sir_var(m, "t9n" as *u8, T_V3F, ws_bin(m, "/" as *u8, cs_v3(m, "t9" as *u8), ws_c2(m, "max" as *u8, cs_v3(m, "uAtlMean" as *u8), ws_v1(m, T_V3F, cs_fdiv(m, ws_f(m, "1.0" as *u8), ws_f(m, "255.0" as *u8))), T_V3F), T_V3F))
  let cl: i64 = ws_c3(m, "clamp" as *u8, ws_c3(m, "mix" as *u8, cs_v3l(m, "1.0" as *u8), cs_v3(m, "t9n" as *u8), cs_fl(m, "ATL_W" as *u8), T_V3F), ws_v1(m, T_V3F, cs_fsub(m, ws_f(m, "1.0" as *u8), cs_fl(m, "ATL_R" as *u8))), ws_v1(m, T_V3F, cs_fadd(m, ws_f(m, "1.0" as *u8), cs_fl(m, "ATL_R" as *u8))), T_V3F)
  let els: i64 = ws_q4(m, aw, ar, tn, ws_op(m, "mc" as *u8, T_V3F, "*" as *u8, cl))
  let ai: i64 = ws_if(m, cs_icmp(m, "==" as *u8, "uAuth" as *u8, "1" as *u8), ws_set(m, cs_v3(m, "mc" as *u8), cs_v3(m, "t9" as *u8)), els)
  ws_st(m, f, ws_if(m, ws_and(m, cs_icmp(m, "==" as *u8, "uAtlOn" as *u8, "1" as *u8), cs_icmp(m, "==" as *u8, "uGar" as *u8, "0" as *u8)), ws_q2(m, t9, ai), 0))
  // float axb=abs(vB.x); int gt9=int(uGT[vII]+.5);int gb9=int(uGB[vII]+.5);bool dr9=(gb9==5||gb9==9);bool op9=(gb9==3);
  ws_st(m, f, sir_var(m, "axb" as *u8, T_F32, ws_c1(m, "abs" as *u8, cs_sx3(m, "vB" as *u8, "x" as *u8), T_F32)))
  ws_st(m, f, sir_var(m, "gt9" as *u8, T_I32, cs_i32(m, cs_fadd(m, cs_gf(m, "uGT" as *u8), ws_f(m, "0.5" as *u8)))))
  ws_st(m, f, sir_var(m, "gb9" as *u8, T_I32, cs_i32(m, cs_fadd(m, cs_gf(m, "uGB" as *u8), ws_f(m, "0.5" as *u8)))))
  ws_st(m, f, sir_var(m, "dr9" as *u8, T_BOOL, ws_or(m, cs_icmp(m, "==" as *u8, "gb9" as *u8, "5" as *u8), cs_icmp(m, "==" as *u8, "gb9" as *u8, "9" as *u8))))
  ws_st(m, f, sir_var(m, "op9" as *u8, T_BOOL, cs_icmp(m, "==" as *u8, "gb9" as *u8, "3" as *u8)))
  // bool pm1=(uGMH&2)==0,pm2=(uGMH&4)==0,pm3=(uGMH&8)==0,pm5=(uGMH&32)==0,pm6=(uGMH&64)==0,pm7=(uGMH&128)==0,pm9=(uGMH&512)==0;
  ws_st(m, f, cs_pm(m, "pm1" as *u8, "2" as *u8)); ws_st(m, f, cs_pm(m, "pm2" as *u8, "4" as *u8)); ws_st(m, f, cs_pm(m, "pm3" as *u8, "8" as *u8))
  ws_st(m, f, cs_pm(m, "pm5" as *u8, "32" as *u8)); ws_st(m, f, cs_pm(m, "pm6" as *u8, "64" as *u8)); ws_st(m, f, cs_pm(m, "pm7" as *u8, "128" as *u8)); ws_st(m, f, cs_pm(m, "pm9" as *u8, "512" as *u8))
  // if(pm6&&gt9==6&&!dr9&&!op9&&h>.545&&h<uNIP+.055&&axb<15000.)mc=uCT[vII];
  let c6: i64 = ws_and(m, ws_and(m, ws_and(m, cs_and4(m, cs_b(m, "pm6" as *u8), cs_icmp(m, "==" as *u8, "gt9" as *u8, "6" as *u8), sir_not(m, cs_b(m, "dr9" as *u8)), sir_not(m, cs_b(m, "op9" as *u8))), cs_h(m, ">" as *u8, "0.545" as *u8)), cs_hnip(m)), cs_axb(m))
  ws_st(m, f, ws_if(m, ws_and(m, cs_auth0(m), c6), ws_set(m, cs_v3(m, "mc" as *u8), cs_g3(m, "uCT" as *u8)), 0))
  // if((dr9||op9)&&h>.545&&h<uNIP+.055&&axb<15000.&&((gb9==5&&pm5)||(gb9==9&&pm9)||(gb9==3&&pm3)))mc=uCB[vII];
  let g5: i64 = ws_and(m, cs_icmp(m, "==" as *u8, "gb9" as *u8, "5" as *u8), cs_b(m, "pm5" as *u8))
  let g9: i64 = ws_and(m, cs_icmp(m, "==" as *u8, "gb9" as *u8, "9" as *u8), cs_b(m, "pm9" as *u8))
  let g3: i64 = ws_and(m, cs_icmp(m, "==" as *u8, "gb9" as *u8, "3" as *u8), cs_b(m, "pm3" as *u8))
  let cd: i64 = ws_and(m, cs_and4(m, ws_or(m, cs_b(m, "dr9" as *u8), cs_b(m, "op9" as *u8)), cs_h(m, ">" as *u8, "0.545" as *u8), cs_hnip(m), cs_axb(m)), ws_or(m, ws_or(m, g5, g9), g3))
  ws_st(m, f, ws_if(m, ws_and(m, cs_auth0(m), cd), ws_set(m, cs_v3(m, "mc" as *u8), cs_g3(m, "uCB" as *u8)), 0))
  // if(pm1&&gt9==1&&!dr9&&!op9&&abs(h-uNIP)<.055&&axb<15000.)mc=uCT[vII];
  let c1: i64 = ws_and(m, ws_and(m, cs_and4(m, cs_b(m, "pm1" as *u8), cs_icmp(m, "==" as *u8, "gt9" as *u8, "1" as *u8), sir_not(m, cs_b(m, "dr9" as *u8)), sir_not(m, cs_b(m, "op9" as *u8))), cs_nipband(m)), cs_axb(m))
  ws_st(m, f, ws_if(m, ws_and(m, cs_auth0(m), c1), ws_set(m, cs_v3(m, "mc" as *u8), cs_g3(m, "uCT" as *u8)), 0))
  // if(pm3&&op9&&h>.395&&h<.545&&axb<15000.)mc=uCB[vII];
  let c3: i64 = ws_and(m, cs_and4(m, cs_b(m, "pm3" as *u8), cs_b(m, "op9" as *u8), cs_h(m, ">" as *u8, "0.395" as *u8), cs_h(m, "<" as *u8, "0.545" as *u8)), cs_axb(m))
  ws_st(m, f, ws_if(m, ws_and(m, cs_auth0(m), c3), ws_set(m, cs_v3(m, "mc" as *u8), cs_g3(m, "uCB" as *u8)), 0))
  // if(pm7&&gb9==7&&h>.395&&h<.545&&axb<15000.)mc=uCB[vII]*.8;
  let c7: i64 = ws_and(m, cs_and4(m, cs_b(m, "pm7" as *u8), cs_icmp(m, "==" as *u8, "gb9" as *u8, "7" as *u8), cs_h(m, ">" as *u8, "0.395" as *u8), cs_h(m, "<" as *u8, "0.545" as *u8)), cs_axb(m))
  ws_st(m, f, ws_if(m, ws_and(m, cs_auth0(m), c7), ws_set(m, cs_v3(m, "mc" as *u8), cs_v3mul(m, cs_g3(m, "uCB" as *u8), ws_f(m, "0.8" as *u8))), 0))
  // if(pm2&&gb9==2&&h>.475&&h<.545&&axb<15000.)mc=uCB[vII];
  let c2: i64 = ws_and(m, cs_and4(m, cs_b(m, "pm2" as *u8), cs_icmp(m, "==" as *u8, "gb9" as *u8, "2" as *u8), cs_h(m, ">" as *u8, "0.475" as *u8), cs_h(m, "<" as *u8, "0.545" as *u8)), cs_axb(m))
  ws_st(m, f, ws_if(m, ws_and(m, cs_auth0(m), c2), ws_set(m, cs_v3(m, "mc" as *u8), cs_g3(m, "uCB" as *u8)), 0))
  // if(uAuth==0&&uOF[vII]>.5&&vB.y<-1200.&&abs(h-uNIP)<.055){float nx9=abs(vB.x)-uH*.056;float nz9=(h-uNIP)*uH;
  //   float nd9=sqrt(nx9*nx9+nz9*nz9*1.3);float nr9=uH*.0125*(.85+.12*uGN[vII]);
  //   if(nd9<nr9)mc=mc*.72+vec3(.17,.06,.06);if(nd9<nr9*.38)mc=mc*.60+vec3(.22,.08,.08);}
  let cc: i64 = cs_and4(m, cs_auth0(m), ws_cmp(m, ">" as *u8, cs_gf(m, "uOF" as *u8), ws_f(m, "0.5" as *u8)), cs_vby(m, "<" as *u8, cs_negf(m, "1200.0" as *u8)), cs_nipband(m))
  let nx: i64 = sir_var(m, "nx9" as *u8, T_F32, cs_fsub(m, ws_c1(m, "abs" as *u8, cs_sx3(m, "vB" as *u8, "x" as *u8), T_F32), cs_fmul(m, cs_fl(m, "uH" as *u8), ws_f(m, "0.056" as *u8))))
  let nz: i64 = sir_var(m, "nz9" as *u8, T_F32, cs_fmul(m, cs_fsub(m, cs_fl(m, "h" as *u8), cs_fl(m, "uNIP" as *u8)), cs_fl(m, "uH" as *u8)))
  let nd: i64 = sir_var(m, "nd9" as *u8, T_F32, ws_c1(m, "sqrt" as *u8, cs_fadd(m, cs_fmul(m, cs_fl(m, "nx9" as *u8), cs_fl(m, "nx9" as *u8)), cs_fmul(m, cs_fmul(m, cs_fl(m, "nz9" as *u8), cs_fl(m, "nz9" as *u8)), ws_f(m, "1.3" as *u8))), T_F32))
  let nr: i64 = sir_var(m, "nr9" as *u8, T_F32, cs_fmul(m, cs_fmul(m, cs_fl(m, "uH" as *u8), ws_f(m, "0.0125" as *u8)), cs_fadd(m, ws_f(m, "0.85" as *u8), cs_fmul(m, ws_f(m, "0.12" as *u8), cs_gf(m, "uGN" as *u8)))))
  let n1: i64 = ws_if(m, ws_cmp(m, "<" as *u8, cs_fl(m, "nd9" as *u8), cs_fl(m, "nr9" as *u8)), ws_set(m, cs_v3(m, "mc" as *u8), cs_v3add(m, cs_v3mul(m, cs_v3(m, "mc" as *u8), ws_f(m, "0.72" as *u8)), ws_v3f(m, "0.17" as *u8, "0.06" as *u8, "0.06" as *u8))), 0)
  let n2: i64 = ws_if(m, ws_cmp(m, "<" as *u8, cs_fl(m, "nd9" as *u8), cs_fmul(m, cs_fl(m, "nr9" as *u8), ws_f(m, "0.38" as *u8))), ws_set(m, cs_v3(m, "mc" as *u8), cs_v3add(m, cs_v3mul(m, cs_v3(m, "mc" as *u8), ws_f(m, "0.60" as *u8)), ws_v3f(m, "0.22" as *u8, "0.08" as *u8, "0.08" as *u8))), 0)
  ws_st(m, f, ws_if(m, cc, ws_q3(m, ws_q4(m, nx, nz, nd, nr), n1, n2), 0))
  // if(uAuth==0&&uGar==0){float bhd9=(uBH[vII]<1.5)?1.:(uBH[vII]<2.5?.35:0.);
  //   if(bhd9>0.){vec3 bhc9=uCH[vII]*.55;float bhx9=abs(vB.x)/uH;
  //     if(uOF[vII]>1.5&&vB.y<-1200.&&h>.475&&h<.535){float pw9=.05*(h-.475)/.06;if(bhx9<pw9){float pe9=smoothstep(pw9,pw9*.6,bhx9)*smoothstep(.475,.49,h)*(1.-smoothstep(.525,.535,h));mc=mix(mc,bhc9,pe9*bhd9);}}
  //     if(h>.735&&h<.775&&bhx9>.076&&bhx9<.094){float ae9=(1.-smoothstep(0.,.02,abs(h-.755)))*(1.-smoothstep(0.,.009,abs(bhx9-.085)));mc=mix(mc,bhc9,ae9*bhd9*.8);}}}
  let bd: i64 = sir_var(m, "bhd9" as *u8, T_F32, sir_select(m, ws_cmp(m, "<" as *u8, cs_gf(m, "uBH" as *u8), ws_f(m, "1.5" as *u8)), ws_f(m, "1.0" as *u8), sir_select(m, ws_cmp(m, "<" as *u8, cs_gf(m, "uBH" as *u8), ws_f(m, "2.5" as *u8)), ws_f(m, "0.35" as *u8), ws_f(m, "0.0" as *u8), T_F32), T_F32))
  let bc: i64 = sir_var(m, "bhc9" as *u8, T_V3F, cs_v3mul(m, cs_g3(m, "uCH" as *u8), ws_f(m, "0.55" as *u8)))
  let bx: i64 = sir_var(m, "bhx9" as *u8, T_F32, cs_fdiv(m, ws_c1(m, "abs" as *u8, cs_sx3(m, "vB" as *u8, "x" as *u8), T_F32), cs_fl(m, "uH" as *u8)))
  let pw: i64 = sir_var(m, "pw9" as *u8, T_F32, cs_fdiv(m, cs_fmul(m, ws_f(m, "0.05" as *u8), cs_fsub(m, cs_fl(m, "h" as *u8), ws_f(m, "0.475" as *u8))), ws_f(m, "0.06" as *u8)))
  let pe: i64 = sir_var(m, "pe9" as *u8, T_F32, cs_fmul(m, cs_fmul(m, cs_ss(m, cs_fl(m, "pw9" as *u8), cs_fmul(m, cs_fl(m, "pw9" as *u8), ws_f(m, "0.6" as *u8)), cs_fl(m, "bhx9" as *u8)), cs_ssl(m, "0.475" as *u8, "0.49" as *u8, "h" as *u8)), cs_fsub(m, ws_f(m, "1.0" as *u8), cs_ssl(m, "0.525" as *u8, "0.535" as *u8, "h" as *u8))))
  let pmx: i64 = ws_set(m, cs_v3(m, "mc" as *u8), ws_c3(m, "mix" as *u8, cs_v3(m, "mc" as *u8), cs_v3(m, "bhc9" as *u8), cs_fmul(m, cs_fl(m, "pe9" as *u8), cs_fl(m, "bhd9" as *u8)), T_V3F))
  let pif: i64 = ws_if(m, ws_cmp(m, "<" as *u8, cs_fl(m, "bhx9" as *u8), cs_fl(m, "pw9" as *u8)), ws_q2(m, pe, pmx), 0)
  let mons: i64 = ws_if(m, cs_and4(m, ws_cmp(m, ">" as *u8, cs_gf(m, "uOF" as *u8), ws_f(m, "1.5" as *u8)), cs_vby(m, "<" as *u8, cs_negf(m, "1200.0" as *u8)), cs_h(m, ">" as *u8, "0.475" as *u8), cs_h(m, "<" as *u8, "0.535" as *u8)), ws_q2(m, pw, pif), 0)
  let ae: i64 = sir_var(m, "ae9" as *u8, T_F32, cs_fmul(m, cs_fsub(m, ws_f(m, "1.0" as *u8), cs_ss(m, ws_f(m, "0.0" as *u8), ws_f(m, "0.02" as *u8), ws_c1(m, "abs" as *u8, cs_fsub(m, cs_fl(m, "h" as *u8), ws_f(m, "0.755" as *u8)), T_F32))), cs_fsub(m, ws_f(m, "1.0" as *u8), cs_ss(m, ws_f(m, "0.0" as *u8), ws_f(m, "0.009" as *u8), ws_c1(m, "abs" as *u8, cs_fsub(m, cs_fl(m, "bhx9" as *u8), ws_f(m, "0.085" as *u8)), T_F32)))))
  let am: i64 = ws_set(m, cs_v3(m, "mc" as *u8), ws_c3(m, "mix" as *u8, cs_v3(m, "mc" as *u8), cs_v3(m, "bhc9" as *u8), cs_fmul(m, cs_fmul(m, cs_fl(m, "ae9" as *u8), cs_fl(m, "bhd9" as *u8)), ws_f(m, "0.8" as *u8)), T_V3F))
  let axil: i64 = ws_if(m, cs_and4(m, cs_h(m, ">" as *u8, "0.735" as *u8), cs_h(m, "<" as *u8, "0.775" as *u8), ws_cmp(m, ">" as *u8, cs_fl(m, "bhx9" as *u8), ws_f(m, "0.076" as *u8)), ws_cmp(m, "<" as *u8, cs_fl(m, "bhx9" as *u8), ws_f(m, "0.094" as *u8))), ws_q2(m, ae, am), 0)
  let bif: i64 = ws_if(m, ws_cmp(m, ">" as *u8, cs_fl(m, "bhd9" as *u8), ws_f(m, "0.0" as *u8)), ws_q4(m, bc, bx, mons, axil), 0)
  ws_st(m, f, ws_if(m, ws_and(m, cs_auth0(m), cs_icmp(m, "==" as *u8, "uGar" as *u8, "0" as *u8)), ws_q2(m, bd, bif), 0))
  // if(uAuth==0&&h<.028)mc*=1.-.25*(1.-smoothstep(0.,.008,h));
  ws_st(m, f, ws_if(m, ws_and(m, cs_auth0(m), cs_h(m, "<" as *u8, "0.028" as *u8)), ws_op(m, "mc" as *u8, T_V3F, "*" as *u8, cs_fsub(m, ws_f(m, "1.0" as *u8), cs_fmul(m, ws_f(m, "0.25" as *u8), cs_fsub(m, ws_f(m, "1.0" as *u8), cs_ssl(m, "0.0" as *u8, "0.008" as *u8, "h" as *u8))))), 0))
  // if(uAuth==0&&h>.955&&vB.y>=-1200.)mc=uCH[vII]; if(uAuth==0&&vB.y<-1200.)mc=mix(mc,uCH[vII],smoothstep(.975,.990,h)); if(uAuth==0&&h>.865&&vB.y>3000.)mc=uCH[vII];
  ws_st(m, f, ws_if(m, cs_and3(m, cs_auth0(m), cs_h(m, ">" as *u8, "0.955" as *u8), cs_vby(m, ">=" as *u8, cs_negf(m, "1200.0" as *u8))), ws_set(m, cs_v3(m, "mc" as *u8), cs_g3(m, "uCH" as *u8)), 0))
  ws_st(m, f, ws_if(m, ws_and(m, cs_auth0(m), cs_vby(m, "<" as *u8, cs_negf(m, "1200.0" as *u8))), ws_set(m, cs_v3(m, "mc" as *u8), ws_c3(m, "mix" as *u8, cs_v3(m, "mc" as *u8), cs_g3(m, "uCH" as *u8), cs_ssl(m, "0.975" as *u8, "0.990" as *u8, "h" as *u8), T_V3F)), 0))
  ws_st(m, f, ws_if(m, cs_and3(m, cs_auth0(m), cs_h(m, ">" as *u8, "0.865" as *u8), cs_vby(m, ">" as *u8, ws_f(m, "3000.0" as *u8))), ws_set(m, cs_v3(m, "mc" as *u8), cs_g3(m, "uCH" as *u8)), 0))
  return 0
893}
894
895// ---- slice 5 helpers: the generated face ----
896// <k>*HH9   and   <k>*HH9*fs9   (head-height ratios, feature-scaled)
897func cs_hh(m: *i64, k: *u8) -> i64 { return cs_fmul(m, ws_f(m, k), cs_fl(m, "HH9" as *u8)) }
898func cs_hhf(m: *i64, k: *u8) -> i64 { return cs_fmul(m, cs_hh(m, k), cs_fl(m, "fs9" as *u8)) }
899// er9*<k>   and   <k>*er9  (the hand spells both orders; the tree keeps each)
900func cs_erk(m: *i64, k: *u8) -> i64 { return cs_fmul(m, cs_fl(m, "er9" as *u8), ws_f(m, k)) }
901func cs_ker(m: *i64, k: *u8) -> i64 { return cs_fmul(m, ws_f(m, k), cs_fl(m, "er9" as *u8)) }
902// ((vB.x>0.)?1.:-1.)  -- the eye's world side
903func cs_sgn(m: *i64) -> i64 { return sir_select(m, ws_cmp(m, ">" as *u8, cs_sx3(m, "vB" as *u8, "x" as *u8), ws_f(m, "0.0" as *u8)), ws_f(m, "1.0" as *u8), cs_negf(m, "1.0" as *u8), T_F32) }
904// uIH[vII].<sel>
905func cs_ihv(m: *i64, sel: *u8) -> i64 { return ws_sw(m, cs_idx(m, "uIH" as *u8, T_V4F, cs_i(m, "vII" as *u8)), sel, T_F32) }
906// (uAnatM==1)?0.:<e>  -- the measurement mode freezes every degree of freedom it is not measuring
907func cs_anat0(m: *i64, e: i64) -> i64 { return sir_select(m, cs_icmp(m, "==" as *u8, "uAnatM" as *u8, "1" as *u8), ws_f(m, "0.0" as *u8), e, T_F32) }
908// float <b>=fract(uTm*.24+float(vII)*.37);float <lf>=(uAnatM==1)?0.:smoothstep(.950,.962,<b>)*(1.-smoothstep(.982,.994,<b>));  -- the blink
909func cs_blink(m: *i64, b: *u8, lf: *u8) -> i64 {
  let ph: i64 = sir_var(m, b, T_F32, ws_c1(m, "fract" as *u8, cs_fadd(m, cs_fmul(m, cs_fl(m, "uTm" as *u8), ws_f(m, "0.24" as *u8)), cs_fmul(m, cs_f32(m, cs_i(m, "vII" as *u8)), ws_f(m, "0.37" as *u8))), T_F32))
  let win: i64 = cs_fmul(m, cs_ssl(m, "0.950" as *u8, "0.962" as *u8, b), cs_fsub(m, ws_f(m, "1.0" as *u8), cs_ssl(m, "0.982" as *u8, "0.994" as *u8, b)))
  let lv: i64 = sir_var(m, lf, T_F32, cs_anat0(m, win))
  return ws_q2(m, ph, lv)
914}
915
916// the painted eye: if(ed9<er9&&uEyeG==0){ sclera, lid shade, gaze-follow, iris, catchlight, blink }
917func cs_fs_eye(m: *i64) -> i64 {
  // mc=vec3(.93,.92,.91); mc*=1.-.20*smoothstep(er9*.45,er9,abs(ez9));
  let s1: i64 = ws_set(m, cs_v3(m, "mc" as *u8), ws_v3f(m, "0.93" as *u8, "0.92" as *u8, "0.91" as *u8))
  let s2: i64 = ws_op(m, "mc" as *u8, T_V3F, "*" as *u8, cs_fsub(m, ws_f(m, "1.0" as *u8), cs_fmul(m, ws_f(m, "0.20" as *u8), cs_ss(m, cs_erk(m, "0.45" as *u8), cs_fl(m, "er9" as *u8), ws_c1(m, "abs" as *u8, cs_fl(m, "ez9" as *u8), T_F32)))))
  // vec3 gvd9=normalize(uCamM-vW);
  let gv: i64 = sir_var(m, "gvd9" as *u8, T_V3F, ws_c1(m, "normalize" as *u8, cs_v3sub(m, cs_v3(m, "uCamM" as *u8), cs_v3(m, "vW" as *u8)), T_V3F))
  // float ggx9=(uAnatM==1)?0.:clamp(dot(gvd9,vec3(uIH[vII].y,0.,-uIH[vII].x))*.55,-.30,.30)*er9;
  let ax: i64 = ws_v3(m, cs_ihv(m, "y" as *u8), ws_f(m, "0.0" as *u8), sir_neg(m, cs_ihv(m, "x" as *u8), T_F32))
  let gx: i64 = sir_var(m, "ggx9" as *u8, T_F32, cs_anat0(m, cs_fmul(m, ws_c3(m, "clamp" as *u8, cs_fmul(m, cs_dot(m, cs_v3(m, "gvd9" as *u8), ax), ws_f(m, "0.55" as *u8)), cs_negf(m, "0.30" as *u8), ws_f(m, "0.30" as *u8), T_F32), cs_fl(m, "er9" as *u8))))
  // float ggz9=(uAnatM==1)?0.:clamp(gvd9.y*.4,-.22,.22)*er9;
  let gz: i64 = sir_var(m, "ggz9" as *u8, T_F32, cs_anat0(m, cs_fmul(m, ws_c3(m, "clamp" as *u8, cs_fmul(m, cs_sx3(m, "gvd9" as *u8, "y" as *u8), ws_f(m, "0.4" as *u8)), cs_negf(m, "0.22" as *u8), ws_f(m, "0.22" as *u8), T_F32), cs_fl(m, "er9" as *u8))))
  // float u9g=vB.x-((vB.x>0.)?1.:-1.)*.16*HH9; float ir9=er9*.55;
  let ug: i64 = sir_var(m, "u9g" as *u8, T_F32, cs_fsub(m, cs_sx3(m, "vB" as *u8, "x" as *u8), cs_fmul(m, cs_fmul(m, cs_sgn(m), ws_f(m, "0.16" as *u8)), cs_fl(m, "HH9" as *u8))))
  let ir: i64 = sir_var(m, "ir9" as *u8, T_F32, cs_erk(m, "0.55" as *u8))
  // float edg9=sqrt((u9g-ggx9)*(u9g-ggx9)+(ez9-ggz9)*(ez9-ggz9)*1.4);  (a node is never reused as two children: each factor is built twice)
  let dx1: i64 = cs_fsub(m, cs_fl(m, "u9g" as *u8), cs_fl(m, "ggx9" as *u8))
  let dx2: i64 = cs_fsub(m, cs_fl(m, "u9g" as *u8), cs_fl(m, "ggx9" as *u8))
  let dz1: i64 = cs_fsub(m, cs_fl(m, "ez9" as *u8), cs_fl(m, "ggz9" as *u8))
  let dz2: i64 = cs_fsub(m, cs_fl(m, "ez9" as *u8), cs_fl(m, "ggz9" as *u8))
  let eg: i64 = sir_var(m, "edg9" as *u8, T_F32, ws_c1(m, "sqrt" as *u8, cs_fadd(m, cs_fmul(m, dx1, dx2), cs_fmul(m, cs_fmul(m, dz1, dz2), ws_f(m, "1.4" as *u8))), T_F32))
  // if(edg9<ir9){float t9=edg9/ir9;vec3 ib9=uCH[vII]*.5;mc=ib9*(1.15-.55*t9);mc+=vec3(.10,.07,.03)*max(0.,.5-abs(t9-.6))*1.6;if(t9>.82)mc*=.42;if(edg9<ir9*.42)mc=vec3(.03,.03,.05);}
  let t9: i64 = sir_var(m, "t9" as *u8, T_F32, cs_fdiv(m, cs_fl(m, "edg9" as *u8), cs_fl(m, "ir9" as *u8)))
  let ib: i64 = sir_var(m, "ib9" as *u8, T_V3F, cs_v3mul(m, cs_g3(m, "uCH" as *u8), ws_f(m, "0.5" as *u8)))
  let i1: i64 = ws_set(m, cs_v3(m, "mc" as *u8), cs_v3mul(m, cs_v3(m, "ib9" as *u8), cs_fsub(m, ws_f(m, "1.15" as *u8), cs_fmul(m, ws_f(m, "0.55" as *u8), cs_fl(m, "t9" as *u8)))))
  let i2: i64 = ws_op(m, "mc" as *u8, T_V3F, "+" as *u8, cs_v3mul(m, cs_v3mul(m, ws_v3f(m, "0.10" as *u8, "0.07" as *u8, "0.03" as *u8), ws_c2(m, "max" as *u8, ws_f(m, "0.0" as *u8), cs_fsub(m, ws_f(m, "0.5" as *u8), ws_c1(m, "abs" as *u8, cs_fsub(m, cs_fl(m, "t9" as *u8), ws_f(m, "0.6" as *u8)), T_F32)), T_F32)), ws_f(m, "1.6" as *u8)))
  let i3: i64 = ws_if(m, ws_cmp(m, ">" as *u8, cs_fl(m, "t9" as *u8), ws_f(m, "0.82" as *u8)), ws_op(m, "mc" as *u8, T_V3F, "*" as *u8, ws_f(m, "0.42" as *u8)), 0)
  let i4: i64 = ws_if(m, ws_cmp(m, "<" as *u8, cs_fl(m, "edg9" as *u8), cs_fmul(m, cs_fl(m, "ir9" as *u8), ws_f(m, "0.42" as *u8))), ws_set(m, cs_v3(m, "mc" as *u8), ws_v3f(m, "0.03" as *u8, "0.03" as *u8, "0.05" as *u8)), 0)
  let iris: i64 = ws_if(m, ws_cmp(m, "<" as *u8, cs_fl(m, "edg9" as *u8), cs_fl(m, "ir9" as *u8)), ws_q3(m, ws_q2(m, t9, ib), ws_q2(m, i1, i2), ws_q2(m, i3, i4)), 0)
  // float u9=vB.x-((vB.x>0.)?1.:-1.)*.16*HH9*fs9; float cd9=length(vec2(u9-.25*er9,(ez9-.30*er9)*1.25));
  let u9: i64 = sir_var(m, "u9" as *u8, T_F32, cs_fsub(m, cs_sx3(m, "vB" as *u8, "x" as *u8), cs_fmul(m, cs_fmul(m, cs_fmul(m, cs_sgn(m), ws_f(m, "0.16" as *u8)), cs_fl(m, "HH9" as *u8)), cs_fl(m, "fs9" as *u8))))
  let cd: i64 = sir_var(m, "cd9" as *u8, T_F32, ws_c1(m, "length" as *u8, ws_v2(m, cs_fsub(m, cs_fl(m, "u9" as *u8), cs_ker(m, "0.25" as *u8)), cs_fmul(m, cs_fsub(m, cs_fl(m, "ez9" as *u8), cs_ker(m, "0.30" as *u8)), ws_f(m, "1.25" as *u8))), T_F32))
  // if(cd9<.17*er9)mc=vec3(1.25,1.24,1.22); if(cd9>=.17*er9&&cd9<.24*er9)mc=mix(mc,vec3(1.1),.5);
  let c1: i64 = ws_if(m, ws_cmp(m, "<" as *u8, cs_fl(m, "cd9" as *u8), cs_ker(m, "0.17" as *u8)), ws_set(m, cs_v3(m, "mc" as *u8), ws_v3f(m, "1.25" as *u8, "1.24" as *u8, "1.22" as *u8)), 0)
  let c2: i64 = ws_if(m, ws_and(m, ws_cmp(m, ">=" as *u8, cs_fl(m, "cd9" as *u8), cs_ker(m, "0.17" as *u8)), ws_cmp(m, "<" as *u8, cs_fl(m, "cd9" as *u8), cs_ker(m, "0.24" as *u8))), ws_set(m, cs_v3(m, "mc" as *u8), ws_c3(m, "mix" as *u8, cs_v3(m, "mc" as *u8), cs_v3l(m, "1.1" as *u8), ws_f(m, "0.5" as *u8), T_V3F)), 0)
  // float bl9=...;float lf9=...; if(lf9>0.&&ez9>(1.-2.2*lf9)*er9)mc=skin9*.92;
  let bl: i64 = cs_blink(m, "bl9" as *u8, "lf9" as *u8)
  let bk: i64 = ws_if(m, ws_and(m, ws_cmp(m, ">" as *u8, cs_fl(m, "lf9" as *u8), ws_f(m, "0.0" as *u8)), ws_cmp(m, ">" as *u8, cs_fl(m, "ez9" as *u8), cs_fmul(m, cs_fsub(m, ws_f(m, "1.0" as *u8), cs_fmul(m, ws_f(m, "2.2" as *u8), cs_fl(m, "lf9" as *u8))), cs_fl(m, "er9" as *u8)))), ws_set(m, cs_v3(m, "mc" as *u8), cs_v3mul(m, cs_v3(m, "skin9" as *u8), ws_f(m, "0.92" as *u8))), 0)
  let body: i64 = ws_q4(m, ws_q4(m, s1, s2, gv, gx), ws_q4(m, gz, ug, ir, eg), ws_q4(m, iris, u9, cd, c1), ws_q3(m, c2, bl, bk))
  return ws_if(m, ws_and(m, ws_cmp(m, "<" as *u8, cs_fl(m, "ed9" as *u8), cs_fl(m, "er9" as *u8)), cs_icmp(m, "==" as *u8, "uEyeG" as *u8, "0" as *u8)), body, 0)
956}
957
958// FS slice 5 of main: the GENERATED face (uAuth==0&&uGar==0&&h>.885&&h<.985&&vB.y<-1200.) -- landmarks as anatomy-canon
959// ratios over the head segment, the socket hole for real eyeballs, the painted eye, lashes, wet sheen, brows and mouth on mood
960func cs_fs_slice5(m: *i64, f: i64) -> i64 {
  // float HH9=.115*uH;float fs9=.82+.12*uGN[vII];float ex9=abs(vB.x)-.16*HH9*fs9;float ez9=(h-.9420)*uH;
  let hh: i64 = sir_var(m, "HH9" as *u8, T_F32, cs_fmul(m, ws_f(m, "0.115" as *u8), cs_fl(m, "uH" as *u8)))
  let fs: i64 = sir_var(m, "fs9" as *u8, T_F32, cs_fadd(m, ws_f(m, "0.82" as *u8), cs_fmul(m, ws_f(m, "0.12" as *u8), cs_gf(m, "uGN" as *u8))))
  let ex: i64 = sir_var(m, "ex9" as *u8, T_F32, cs_fsub(m, ws_c1(m, "abs" as *u8, cs_sx3(m, "vB" as *u8, "x" as *u8), T_F32), cs_hhf(m, "0.16" as *u8)))
  let ez: i64 = sir_var(m, "ez9" as *u8, T_F32, cs_fmul(m, cs_fsub(m, cs_fl(m, "h" as *u8), ws_f(m, "0.9420" as *u8)), cs_fl(m, "uH" as *u8)))
  // float ed9=sqrt(ex9*ex9+ez9*ez9*1.4);float er9=min(.060*HH9*fs9,.046*HH9*.95);
  let ed: i64 = sir_var(m, "ed9" as *u8, T_F32, ws_c1(m, "sqrt" as *u8, cs_fadd(m, cs_fmul(m, cs_fl(m, "ex9" as *u8), cs_fl(m, "ex9" as *u8)), cs_fmul(m, cs_fmul(m, cs_fl(m, "ez9" as *u8), cs_fl(m, "ez9" as *u8)), ws_f(m, "1.4" as *u8))), T_F32))
  let er: i64 = sir_var(m, "er9" as *u8, T_F32, ws_c2(m, "min" as *u8, cs_hhf(m, "0.060" as *u8), cs_fmul(m, cs_hh(m, "0.046" as *u8), ws_f(m, "0.95" as *u8)), T_F32))
  // if(ed9<er9*1.25)mc=mix(mc,mc*.88,smoothstep(er9*1.25,er9,ed9)*.5); vec3 skin9=mc;
  let lid: i64 = ws_if(m, ws_cmp(m, "<" as *u8, cs_fl(m, "ed9" as *u8), cs_erk(m, "1.25" as *u8)), ws_set(m, cs_v3(m, "mc" as *u8), ws_c3(m, "mix" as *u8, cs_v3(m, "mc" as *u8), cs_v3mul(m, cs_v3(m, "mc" as *u8), ws_f(m, "0.88" as *u8)), cs_fmul(m, cs_fsub(m, ws_f(m, "1.0" as *u8), cs_ss(m, cs_fl(m, "er9" as *u8), cs_erk(m, "1.25" as *u8), cs_fl(m, "ed9" as *u8))), ws_f(m, "0.5" as *u8)), T_V3F)), 0)
  let sk: i64 = sir_var(m, "skin9" as *u8, T_V3F, cs_v3(m, "mc" as *u8))
  // float blg9=...;float lfg9=...;if(uEyeG==1&&lfg9<=0.&&ed9<er9*.98)discard;if(uEyeG==1&&lfg9>0.&&ed9<er9*.98)mc*=.92;
  let bl: i64 = cs_blink(m, "blg9" as *u8, "lfg9" as *u8)
  let hole: i64 = ws_if(m, cs_and3(m, cs_icmp(m, "==" as *u8, "uEyeG" as *u8, "1" as *u8), ws_cmp(m, "<=" as *u8, cs_fl(m, "lfg9" as *u8), ws_f(m, "0.0" as *u8)), ws_cmp(m, "<" as *u8, cs_fl(m, "ed9" as *u8), cs_erk(m, "0.98" as *u8))), sir_discard(m), 0)
  let lidc: i64 = ws_if(m, cs_and3(m, cs_icmp(m, "==" as *u8, "uEyeG" as *u8, "1" as *u8), ws_cmp(m, ">" as *u8, cs_fl(m, "lfg9" as *u8), ws_f(m, "0.0" as *u8)), ws_cmp(m, "<" as *u8, cs_fl(m, "ed9" as *u8), cs_erk(m, "0.98" as *u8))), ws_op(m, "mc" as *u8, T_V3F, "*" as *u8, ws_f(m, "0.92" as *u8)), 0)
  let eye: i64 = cs_fs_eye(m)
  // float lash9=smoothstep(er9*1.28,er9*1.02,ed9)*smoothstep(er9*.55,er9*1.0,ez9); if(lash9>.15)mc=mix(mc,vec3(.05,.03,.04),clamp(lash9,0.,.9));
  let la: i64 = sir_var(m, "lash9" as *u8, T_F32, cs_fmul(m, cs_fsub(m, ws_f(m, "1.0" as *u8), cs_ss(m, cs_erk(m, "1.02" as *u8), cs_erk(m, "1.28" as *u8), cs_fl(m, "ed9" as *u8))), cs_ss(m, cs_erk(m, "0.55" as *u8), cs_erk(m, "1.0" as *u8), cs_fl(m, "ez9" as *u8))))
  let li: i64 = ws_if(m, ws_cmp(m, ">" as *u8, cs_fl(m, "lash9" as *u8), ws_f(m, "0.15" as *u8)), ws_set(m, cs_v3(m, "mc" as *u8), ws_c3(m, "mix" as *u8, cs_v3(m, "mc" as *u8), ws_v3f(m, "0.05" as *u8, "0.03" as *u8, "0.04" as *u8), ws_c3(m, "clamp" as *u8, cs_fl(m, "lash9" as *u8), ws_f(m, "0.0" as *u8), ws_f(m, "0.9" as *u8), T_F32), T_V3F)), 0)
  // if(ed9<er9*.9){float sh9=1.-smoothstep(0.,er9*.9,length(vec2((vB.x-((vB.x>0.)?1.:-1.)*.16*HH9)+.10*er9,(ez9+.18*er9)*1.1)));mc=mix(mc,mc+vec3(.30,.32,.34),sh9*.35);}
  let px: i64 = cs_fadd(m, cs_fsub(m, cs_sx3(m, "vB" as *u8, "x" as *u8), cs_fmul(m, cs_fmul(m, cs_sgn(m), ws_f(m, "0.16" as *u8)), cs_fl(m, "HH9" as *u8))), cs_ker(m, "0.10" as *u8))
  let pz: i64 = cs_fmul(m, cs_fadd(m, cs_fl(m, "ez9" as *u8), cs_ker(m, "0.18" as *u8)), ws_f(m, "1.1" as *u8))
  let sh: i64 = sir_var(m, "sh9" as *u8, T_F32, cs_fsub(m, ws_f(m, "1.0" as *u8), cs_ss(m, ws_f(m, "0.0" as *u8), cs_erk(m, "0.9" as *u8), ws_c1(m, "length" as *u8, ws_v2(m, px, pz), T_F32))))
  let shm: i64 = ws_set(m, cs_v3(m, "mc" as *u8), ws_c3(m, "mix" as *u8, cs_v3(m, "mc" as *u8), cs_v3add(m, cs_v3(m, "mc" as *u8), ws_v3f(m, "0.30" as *u8, "0.32" as *u8, "0.34" as *u8)), cs_fmul(m, cs_fl(m, "sh9" as *u8), ws_f(m, "0.35" as *u8)), T_V3F))
  let wet: i64 = ws_if(m, ws_cmp(m, "<" as *u8, cs_fl(m, "ed9" as *u8), cs_erk(m, "0.9" as *u8)), ws_q2(m, sh, shm), 0)
  // float bz9=(h-.954)*uH; float bw8=abs(bz9-uMoodF[vII]*.012*HH9); if(bw8<.009*HH9&&abs(ex9)<.075*HH9*fs9)mc=mix(mc,uCH[vII]*.45,.75*(1.-smoothstep(.005*HH9,.009*HH9,bw8)));
  let bz: i64 = sir_var(m, "bz9" as *u8, T_F32, cs_fmul(m, cs_fsub(m, cs_fl(m, "h" as *u8), ws_f(m, "0.954" as *u8)), cs_fl(m, "uH" as *u8)))
  // BROWS v2 (2026-09-06) -- twin of the MFS block in nx_game_page_emit: two arcs (never one bar), arch at 62 percent of the .085H..245H span, head .030H tapering to .009H, a diagonal hair-stroke mask, mood lifts/presses. The flat bar (bw8) is retired.
  // float bxo=abs(vB.x)/(HH9*fs9); float bt9=clamp((bxo-.085)/.16,0.,1.); float bcy=(.024*sin(3.14159*pow(bt9,1.45))-.006*bt9+uMoodF[vII]*.012)*HH9; float bhh=mix(.015,.0045,smoothstep(.30,1.,bt9))*HH9; float bd9=abs(bz9-bcy);
  let bxo: i64 = sir_var(m, "bxo" as *u8, T_F32, cs_fdiv(m, ws_c1(m, "abs" as *u8, cs_sx3(m, "vB" as *u8, "x" as *u8), T_F32), cs_fmul(m, cs_fl(m, "HH9" as *u8), cs_fl(m, "fs9" as *u8))))
  let bt: i64 = sir_var(m, "bt9" as *u8, T_F32, ws_c3(m, "clamp" as *u8, cs_fdiv(m, cs_fsub(m, cs_fl(m, "bxo" as *u8), ws_f(m, "0.085" as *u8)), ws_f(m, "0.16" as *u8)), ws_f(m, "0.0" as *u8), ws_f(m, "1.0" as *u8), T_F32))
  let bcy: i64 = sir_var(m, "bcy" as *u8, T_F32, cs_fmul(m, cs_fadd(m, cs_fsub(m, cs_fmul(m, ws_f(m, "0.024" as *u8), ws_c1(m, "sin" as *u8, cs_fmul(m, ws_f(m, "3.14159" as *u8), ws_c2(m, "pow" as *u8, cs_fl(m, "bt9" as *u8), ws_f(m, "1.45" as *u8), T_F32)), T_F32)), cs_fmul(m, ws_f(m, "0.006" as *u8), cs_fl(m, "bt9" as *u8))), cs_fmul(m, cs_gf(m, "uMoodF" as *u8), ws_f(m, "0.012" as *u8))), cs_fl(m, "HH9" as *u8)))
  let bhh: i64 = sir_var(m, "bhh" as *u8, T_F32, cs_fmul(m, ws_c3(m, "mix" as *u8, ws_f(m, "0.015" as *u8), ws_f(m, "0.0045" as *u8), cs_ssl(m, "0.30" as *u8, "1.0" as *u8, "bt9" as *u8), T_F32), cs_fl(m, "HH9" as *u8)))
  let bd: i64 = sir_var(m, "bd9" as *u8, T_F32, ws_c1(m, "abs" as *u8, cs_fsub(m, cs_fl(m, "bz9" as *u8), cs_fl(m, "bcy" as *u8)), T_F32))
  // float bq9=(bz9/HH9*.91-bxo*.42)/.0055; float bst=.35+.65*smoothstep(.18,.62,fract(bq9+.61*fract(sin(floor(bq9)*12.9898+fs9*78.233)*43758.5453)));
  let bq: i64 = sir_var(m, "bq9" as *u8, T_F32, cs_fdiv(m, cs_fsub(m, cs_fmul(m, cs_fdiv(m, cs_fl(m, "bz9" as *u8), cs_fl(m, "HH9" as *u8)), ws_f(m, "0.91" as *u8)), cs_fmul(m, cs_fl(m, "bxo" as *u8), ws_f(m, "0.42" as *u8))), ws_f(m, "0.0055" as *u8)))
  let bst: i64 = sir_var(m, "bst" as *u8, T_F32, cs_fadd(m, ws_f(m, "0.35" as *u8), cs_fmul(m, ws_f(m, "0.65" as *u8), cs_ss(m, ws_f(m, "0.18" as *u8), ws_f(m, "0.62" as *u8), ws_c1(m, "fract" as *u8, cs_fadd(m, cs_fl(m, "bq9" as *u8), cs_fmul(m, ws_f(m, "0.61" as *u8), ws_c1(m, "fract" as *u8, cs_fmul(m, ws_c1(m, "sin" as *u8, cs_fadd(m, cs_fmul(m, ws_c1(m, "floor" as *u8, cs_fl(m, "bq9" as *u8), T_F32), ws_f(m, "12.9898" as *u8)), cs_fmul(m, cs_fl(m, "fs9" as *u8), ws_f(m, "78.233" as *u8))), T_F32), ws_f(m, "43758.5453" as *u8)), T_F32))), T_F32))))
  // float bcv=(1.-smoothstep(bhh*.55,bhh,bd9))*smoothstep(0.,.10,bt9)*(1.-smoothstep(.90,1.,bt9))*bst*(1.-.35*smoothstep(.55,1.,bt9)); if(bcv>.02)mc=mix(mc,uCH[vII]*mix(.40,.55,bt9),clamp(bcv*.92,0.,.92));
  let bcv: i64 = sir_var(m, "bcv" as *u8, T_F32, cs_fmul(m, cs_fmul(m, cs_fmul(m, cs_fmul(m, cs_fsub(m, ws_f(m, "1.0" as *u8), cs_ss(m, cs_fmul(m, cs_fl(m, "bhh" as *u8), ws_f(m, "0.55" as *u8)), cs_fl(m, "bhh" as *u8), cs_fl(m, "bd9" as *u8))), cs_ssl(m, "0.0" as *u8, "0.10" as *u8, "bt9" as *u8)), cs_fsub(m, ws_f(m, "1.0" as *u8), cs_ssl(m, "0.90" as *u8, "1.0" as *u8, "bt9" as *u8))), cs_fl(m, "bst" as *u8)), cs_fsub(m, ws_f(m, "1.0" as *u8), cs_fmul(m, ws_f(m, "0.35" as *u8), cs_ssl(m, "0.55" as *u8, "1.0" as *u8, "bt9" as *u8)))))
  let brow: i64 = ws_if(m, ws_cmp(m, ">" as *u8, cs_fl(m, "bcv" as *u8), ws_f(m, "0.02" as *u8)), ws_set(m, cs_v3(m, "mc" as *u8), ws_c3(m, "mix" as *u8, cs_v3(m, "mc" as *u8), cs_v3mul(m, cs_g3(m, "uCH" as *u8), ws_c3(m, "mix" as *u8, ws_f(m, "0.40" as *u8), ws_f(m, "0.55" as *u8), cs_fl(m, "bt9" as *u8), T_F32)), ws_c3(m, "clamp" as *u8, cs_fmul(m, cs_fl(m, "bcv" as *u8), ws_f(m, "0.92" as *u8)), ws_f(m, "0.0" as *u8), ws_f(m, "0.92" as *u8), T_F32), T_V3F)), 0)
  // float mz9=(h-.908)*uH; float mx9=vB.x/(.085*HH9*fs9); float mcv9=uMoodF[vII]*.022*HH9*(mx9*mx9-.35); float lw8=abs(mz9-mcv9);
  let mz: i64 = sir_var(m, "mz9" as *u8, T_F32, cs_fmul(m, cs_fsub(m, cs_fl(m, "h" as *u8), ws_f(m, "0.908" as *u8)), cs_fl(m, "uH" as *u8)))
  let mx: i64 = sir_var(m, "mx9" as *u8, T_F32, cs_fdiv(m, cs_sx3(m, "vB" as *u8, "x" as *u8), cs_hhf(m, "0.085" as *u8)))
  let mcv: i64 = sir_var(m, "mcv9" as *u8, T_F32, cs_fmul(m, cs_fmul(m, cs_fmul(m, cs_gf(m, "uMoodF" as *u8), ws_f(m, "0.022" as *u8)), cs_fl(m, "HH9" as *u8)), cs_fsub(m, cs_fmul(m, cs_fl(m, "mx9" as *u8), cs_fl(m, "mx9" as *u8)), ws_f(m, "0.35" as *u8))))
  let lw: i64 = sir_var(m, "lw8" as *u8, T_F32, ws_c1(m, "abs" as *u8, cs_fsub(m, cs_fl(m, "mz9" as *u8), cs_fl(m, "mcv9" as *u8)), T_F32))
  // if(lw8<.010*HH9*fs9&&abs(vB.x)<.055*HH9*fs9)mc=mix(mc,vec3(.72,.42,.42),.8*(1.-smoothstep(.006*HH9*fs9,.010*HH9*fs9,lw8)));
  let mouth: i64 = ws_if(m, ws_and(m, ws_cmp(m, "<" as *u8, cs_fl(m, "lw8" as *u8), cs_hhf(m, "0.010" as *u8)), ws_cmp(m, "<" as *u8, ws_c1(m, "abs" as *u8, cs_sx3(m, "vB" as *u8, "x" as *u8), T_F32), cs_hhf(m, "0.055" as *u8))), ws_set(m, cs_v3(m, "mc" as *u8), ws_c3(m, "mix" as *u8, cs_v3(m, "mc" as *u8), ws_v3f(m, "0.72" as *u8, "0.42" as *u8, "0.42" as *u8), cs_fmul(m, ws_f(m, "0.8" as *u8), cs_fsub(m, ws_f(m, "1.0" as *u8), cs_ss(m, cs_hhf(m, "0.006" as *u8), cs_hhf(m, "0.010" as *u8), cs_fl(m, "lw8" as *u8)))), T_V3F)), 0)
  let body: i64 = ws_q3(m, ws_q3(m, ws_q4(m, hh, fs, ex, ez), ws_q4(m, ed, er, lid, sk), ws_q4(m, bl, hole, lidc, eye)), ws_q3(m, ws_q4(m, la, li, wet, bz), ws_q4(m, ws_q4(m, bxo, bt, bcy, bhh), ws_q4(m, bd, bq, bst, bcv), brow, ws_q3(m, mz, mx, 0)), ws_q3(m, mcv, lw, mouth)), 0)
  let cond: i64 = ws_and(m, cs_and4(m, cs_auth0(m), cs_icmp(m, "==" as *u8, "uGar" as *u8, "0" as *u8), cs_h(m, ">" as *u8, "0.885" as *u8), cs_h(m, "<" as *u8, "0.985" as *u8)), cs_vby(m, "<" as *u8, cs_negf(m, "1200.0" as *u8)))
  ws_st(m, f, ws_if(m, cond, body, 0))
  return 0
1012}
1013
1014// ---- slice 6 helpers: the hair strand branch ----
1015// fract(sin(dot(floor(vB.xz*.01),vec2(<a>,<b>)))*43758.5453)  -- the per-lock hash
1016func cs_lockhash(m: *i64, a: *u8, b: *u8) -> i64 {
  let d: i64 = cs_dot(m, ws_c1(m, "floor" as *u8, ws_bin(m, "*" as *u8, ws_sx(m, "vB" as *u8, T_V3F, "xz" as *u8, T_V2F), ws_f(m, "0.01" as *u8), T_V2F), T_V2F), ws_v2f(m, a, b))
  return ws_c1(m, "fract" as *u8, cs_fmul(m, ws_c1(m, "sin" as *u8, d, T_F32), ws_f(m, "43758.5453" as *u8)), T_F32)
1019}
1020// uCH[vII].<sel>
1021func cs_chv(m: *i64, sel: *u8) -> i64 { return ws_sw(m, cs_g3(m, "uCH" as *u8), sel, T_F32) }
1022// exp(-(thH<op>k)*(thH<op>k)/(2.*<b>*<b>))*.3989/<b>  -- one Marschner longitudinal lobe; <sh> is the shift expression (built twice: a node is one child)
1023func cs_lobe(m: *i64, op: *u8, sh1: i64, sh2: i64, b: *u8) -> i64 {
  let num: i64 = cs_fmul(m, sir_neg(m, ws_bin(m, op, cs_fl(m, "thH" as *u8), sh1, T_F32), T_F32), ws_bin(m, op, cs_fl(m, "thH" as *u8), sh2, T_F32))
  let den: i64 = cs_fmul(m, cs_fmul(m, ws_f(m, "2.0" as *u8), cs_fl(m, b)), cs_fl(m, b))
  return cs_fdiv(m, cs_fmul(m, ws_c1(m, "exp" as *u8, cs_fdiv(m, num, den), T_F32), ws_f(m, "0.3989" as *u8)), cs_fl(m, b))
1027}
1028// (1.-fH8)
1029func cs_1mf(m: *i64) -> i64 { return cs_fsub(m, ws_f(m, "1.0" as *u8), cs_fl(m, "fH8" as *u8)) }
1030
1031// hair A: the under-cloth cull, the sub-strand stripes, the lock albedo, the sun, the strand tangent, the sun-visibility march, Kajiya diffuse
1032func cs_fs_hair_a(m: *i64) -> i64 {
  // if(uOF[vII]<.5&&h>.395&&h<uNIP+.055){float ex8=vB.x/16000.;float ey8=(vB.y+1500.)/12500.;if(ex8*ex8+ey8*ey8<1.)discard;}
  let e8: i64 = sir_var(m, "ex8" as *u8, T_F32, cs_fdiv(m, cs_sx3(m, "vB" as *u8, "x" as *u8), ws_f(m, "16000.0" as *u8)))
  let y8: i64 = sir_var(m, "ey8" as *u8, T_F32, cs_fdiv(m, cs_fadd(m, cs_sx3(m, "vB" as *u8, "y" as *u8), ws_f(m, "1500.0" as *u8)), ws_f(m, "12500.0" as *u8)))
  let d8: i64 = ws_if(m, ws_cmp(m, "<" as *u8, cs_fadd(m, cs_fmul(m, cs_fl(m, "ex8" as *u8), cs_fl(m, "ex8" as *u8)), cs_fmul(m, cs_fl(m, "ey8" as *u8), cs_fl(m, "ey8" as *u8))), ws_f(m, "1.0" as *u8)), sir_discard(m), 0)
  let cull: i64 = ws_if(m, cs_and3(m, ws_cmp(m, "<" as *u8, cs_gf(m, "uOF" as *u8), ws_f(m, "0.5" as *u8)), cs_h(m, ">" as *u8, "0.395" as *u8), cs_hnip(m)), ws_q3(m, e8, y8, d8), 0)
  // float su9=vUV.x*6.0+fract(sin(dot(floor(vB.xz*.01),vec2(127.1,311.7)))*43758.5453)*3.0;float sf9=abs(fract(su9)-.5)*2.0;float th9=.96-.30*vUV.y;if(sf9>th9&&vUV.y>.04)discard;
  let su: i64 = sir_var(m, "su9" as *u8, T_F32, cs_fadd(m, cs_fmul(m, ws_sx(m, "vUV" as *u8, T_V2F, "x" as *u8, T_F32), ws_f(m, "6.0" as *u8)), cs_fmul(m, cs_lockhash(m, "127.1" as *u8, "311.7" as *u8), ws_f(m, "3.0" as *u8))))
  let sf: i64 = sir_var(m, "sf9" as *u8, T_F32, cs_fmul(m, ws_c1(m, "abs" as *u8, cs_fsub(m, ws_c1(m, "fract" as *u8, cs_fl(m, "su9" as *u8), T_F32), ws_f(m, "0.5" as *u8)), T_F32), ws_f(m, "2.0" as *u8)))
  let th: i64 = sir_var(m, "th9" as *u8, T_F32, cs_fsub(m, ws_f(m, "0.96" as *u8), cs_fmul(m, ws_f(m, "0.30" as *u8), ws_sx(m, "vUV" as *u8, T_V2F, "y" as *u8, T_F32))))
  let st: i64 = ws_if(m, ws_and(m, ws_cmp(m, ">" as *u8, cs_fl(m, "sf9" as *u8), cs_fl(m, "th9" as *u8)), ws_cmp(m, ">" as *u8, ws_sx(m, "vUV" as *u8, T_V2F, "y" as *u8, T_F32), ws_f(m, "0.04" as *u8))), sir_discard(m), 0)
  // float hg9=clamp((h-.72)/.26,0.,1.);float ml9=.94+.12*fract(sin(dot(floor(vB.xz*.01),vec2(12.9898,78.233)))*43758.5453);vec3 hc9=uCH[vII]*ml9*(1.18-.28*hg9);
  let hg: i64 = sir_var(m, "hg9" as *u8, T_F32, ws_c3(m, "clamp" as *u8, cs_fdiv(m, cs_fsub(m, cs_fl(m, "h" as *u8), ws_f(m, "0.72" as *u8)), ws_f(m, "0.26" as *u8)), ws_f(m, "0.0" as *u8), ws_f(m, "1.0" as *u8), T_F32))
  let ml: i64 = sir_var(m, "ml9" as *u8, T_F32, cs_fadd(m, ws_f(m, "0.94" as *u8), cs_fmul(m, ws_f(m, "0.12" as *u8), cs_lockhash(m, "12.9898" as *u8, "78.233" as *u8))))
  let hc: i64 = sir_var(m, "hc9" as *u8, T_V3F, cs_v3mul(m, cs_v3mul(m, cs_g3(m, "uCH" as *u8), cs_fl(m, "ml9" as *u8)), cs_fsub(m, ws_f(m, "1.18" as *u8), cs_fmul(m, ws_f(m, "0.28" as *u8), cs_fl(m, "hg9" as *u8)))))
  // vec3 Lh9=...; vec3 tH9=normalize(vec3(dFdx(vW.x),dFdx(vW.y),dFdx(vW.z))+vec3(1e-4)); float sv8=1.;if(uOcc>=1){...t07...}
  let lh: i64 = cs_sunL(m, "Lh9" as *u8, cs_sun0(m))
  let tx: i64 = ws_v3(m, ws_c1(m, "dpdx" as *u8, cs_sx3(m, "vW" as *u8, "x" as *u8), T_F32), ws_c1(m, "dpdx" as *u8, cs_sx3(m, "vW" as *u8, "y" as *u8), T_F32), ws_c1(m, "dpdx" as *u8, cs_sx3(m, "vW" as *u8, "z" as *u8), T_F32))
  let tg: i64 = sir_var(m, "tH9" as *u8, T_V3F, ws_c1(m, "normalize" as *u8, cs_v3add(m, tx, cs_v3l(m, "1e-4" as *u8)), T_V3F))
  let sv: i64 = cs_sunvis(m, "sv8" as *u8, "t07" as *u8, "Lh9" as *u8)
  // float stl9=dot(tH9,Lh9);float kj9=sqrt(max(0.,1.-stl9*stl9)); vec3 hm9=hc9*(.8+.2*(1.0-sf9))*max(vSh,.6); vec3 hlin9=hm9*hm9*(uSkyF+1.008*kj9*sv8);
  let sl: i64 = sir_var(m, "stl9" as *u8, T_F32, cs_dot(m, cs_v3(m, "tH9" as *u8), cs_v3(m, "Lh9" as *u8)))
  let kj: i64 = sir_var(m, "kj9" as *u8, T_F32, ws_c1(m, "sqrt" as *u8, ws_c2(m, "max" as *u8, ws_f(m, "0.0" as *u8), cs_fsub(m, ws_f(m, "1.0" as *u8), cs_fmul(m, cs_fl(m, "stl9" as *u8), cs_fl(m, "stl9" as *u8))), T_F32), T_F32))
  let hm: i64 = sir_var(m, "hm9" as *u8, T_V3F, cs_v3mul(m, cs_v3mul(m, cs_v3(m, "hc9" as *u8), cs_fadd(m, ws_f(m, "0.8" as *u8), cs_fmul(m, ws_f(m, "0.2" as *u8), cs_fsub(m, ws_f(m, "1.0" as *u8), cs_fl(m, "sf9" as *u8))))), ws_c2(m, "max" as *u8, cs_fl(m, "vSh" as *u8), ws_f(m, "0.6" as *u8), T_F32)))
  let hl: i64 = sir_var(m, "hlin9" as *u8, T_V3F, cs_v3mul(m, cs_v3mul(m, cs_v3(m, "hm9" as *u8), cs_v3(m, "hm9" as *u8)), ws_bin(m, "+" as *u8, cs_v3(m, "uSkyF" as *u8), cs_fmul(m, cs_fmul(m, ws_f(m, cs_scene_direct_diffuse()), cs_fl(m, "kj9" as *u8)), cs_fl(m, "sv8" as *u8)), T_V3F)))
  return ws_q4(m, ws_q4(m, cull, su, sf, th), ws_q4(m, st, hg, ml, hc), ws_q4(m, lh, tg, sv, sl), ws_q3(m, kj, hm, hl))
1058}
1059
1060// hair B: hr_marschner_lobe -- Karis 2016 closed-form R/TT/TRT over Marschner 2003 lobes, melanin absorption, the firefly clamp, the sun term
1061func cs_fs_hair_b(m: *i64) -> i64 {
  // vec3 Vh9=normalize(uCamM-vW); float sTi=clamp(dot(tH9,Lh9),-1.,1.);float sTr=clamp(dot(tH9,Vh9),-1.,1.);
  let vh: i64 = sir_var(m, "Vh9" as *u8, T_V3F, ws_c1(m, "normalize" as *u8, cs_v3sub(m, cs_v3(m, "uCamM" as *u8), cs_v3(m, "vW" as *u8)), T_V3F))
  let si: i64 = sir_var(m, "sTi" as *u8, T_F32, ws_c3(m, "clamp" as *u8, cs_dot(m, cs_v3(m, "tH9" as *u8), cs_v3(m, "Lh9" as *u8)), cs_negf(m, "1.0" as *u8), ws_f(m, "1.0" as *u8), T_F32))
  let sr: i64 = sir_var(m, "sTr" as *u8, T_F32, ws_c3(m, "clamp" as *u8, cs_dot(m, cs_v3(m, "tH9" as *u8), cs_v3(m, "Vh9" as *u8)), cs_negf(m, "1.0" as *u8), ws_f(m, "1.0" as *u8), T_F32))
  // float thI=asin(sTi);float thR=asin(sTr);float thH=(thI+thR)*.5;float cTd=cos((thR-thI)*.5);
  let ti: i64 = sir_var(m, "thI" as *u8, T_F32, ws_c1(m, "asin" as *u8, cs_fl(m, "sTi" as *u8), T_F32))
  let tr: i64 = sir_var(m, "thR" as *u8, T_F32, ws_c1(m, "asin" as *u8, cs_fl(m, "sTr" as *u8), T_F32))
  let thh: i64 = sir_var(m, "thH" as *u8, T_F32, cs_fmul(m, cs_fadd(m, cs_fl(m, "thI" as *u8), cs_fl(m, "thR" as *u8)), ws_f(m, "0.5" as *u8)))
  let ct: i64 = sir_var(m, "cTd" as *u8, T_F32, ws_c1(m, "cos" as *u8, cs_fmul(m, cs_fsub(m, cs_fl(m, "thR" as *u8), cs_fl(m, "thI" as *u8)), ws_f(m, "0.5" as *u8)), T_F32))
  // vec3 Lp8=Lh9-tH9*sTi;vec3 Vp8=Vh9-tH9*sTr; float cPhi=dot(Lp8,Vp8)/max(length(Lp8)*length(Vp8),1e-5); float cHPhi=sqrt(clamp(.5+.5*cPhi,0.,1.));
  let lp: i64 = sir_var(m, "Lp8" as *u8, T_V3F, cs_v3sub(m, cs_v3(m, "Lh9" as *u8), cs_v3mul(m, cs_v3(m, "tH9" as *u8), cs_fl(m, "sTi" as *u8))))
  let vp: i64 = sir_var(m, "Vp8" as *u8, T_V3F, cs_v3sub(m, cs_v3(m, "Vh9" as *u8), cs_v3mul(m, cs_v3(m, "tH9" as *u8), cs_fl(m, "sTr" as *u8))))
  let cp: i64 = sir_var(m, "cPhi" as *u8, T_F32, cs_fdiv(m, cs_dot(m, cs_v3(m, "Lp8" as *u8), cs_v3(m, "Vp8" as *u8)), ws_c2(m, "max" as *u8, cs_fmul(m, ws_c1(m, "length" as *u8, cs_v3(m, "Lp8" as *u8), T_F32), ws_c1(m, "length" as *u8, cs_v3(m, "Vp8" as *u8), T_F32)), ws_f(m, "1e-5" as *u8), T_F32)))
  let ch: i64 = sir_var(m, "cHPhi" as *u8, T_F32, ws_c1(m, "sqrt" as *u8, ws_c3(m, "clamp" as *u8, cs_fadd(m, ws_f(m, "0.5" as *u8), cs_fmul(m, ws_f(m, "0.5" as *u8), cs_fl(m, "cPhi" as *u8))), ws_f(m, "0.0" as *u8), ws_f(m, "1.0" as *u8), T_F32), T_F32))
  // float lum8=dot(uCH[vII],vec3(.299,.587,.114)); float mel8=-log(clamp(lum8,.02,.95)); float phr8=clamp((uCH[vII].r-max(uCH[vII].g,uCH[vII].b)+.08)*3.5,0.,1.);
  let lu: i64 = sir_var(m, "lum8" as *u8, T_F32, cs_dot(m, cs_g3(m, "uCH" as *u8), ws_v3f(m, "0.299" as *u8, "0.587" as *u8, "0.114" as *u8)))
  let me: i64 = sir_var(m, "mel8" as *u8, T_F32, sir_neg(m, ws_c1(m, "log" as *u8, ws_c3(m, "clamp" as *u8, cs_fl(m, "lum8" as *u8), ws_f(m, "0.02" as *u8), ws_f(m, "0.95" as *u8), T_F32), T_F32), T_F32))
  let ph: i64 = sir_var(m, "phr8" as *u8, T_F32, ws_c3(m, "clamp" as *u8, cs_fmul(m, cs_fadd(m, cs_fsub(m, cs_chv(m, "r" as *u8), ws_c2(m, "max" as *u8, cs_chv(m, "g" as *u8), cs_chv(m, "b" as *u8), T_F32)), ws_f(m, "0.08" as *u8)), ws_f(m, "3.5" as *u8)), ws_f(m, "0.0" as *u8), ws_f(m, "1.0" as *u8), T_F32))
  // vec3 sigA8=mel8*mix(vec3(.419,.697,1.37),vec3(.187,.40,1.05),phr8); float bR8=radians(mix(6.,10.,clamp(uGN[vII]/3.,0.,1.)));float aR8=radians(-3.);
  let sa: i64 = sir_var(m, "sigA8" as *u8, T_V3F, ws_bin(m, "*" as *u8, cs_fl(m, "mel8" as *u8), ws_c3(m, "mix" as *u8, ws_v3f(m, "0.419" as *u8, "0.697" as *u8, "1.37" as *u8), ws_v3f(m, "0.187" as *u8, "0.40" as *u8, "1.05" as *u8), cs_fl(m, "phr8" as *u8), T_V3F), T_V3F))
  let br: i64 = sir_var(m, "bR8" as *u8, T_F32, ws_c1(m, "radians" as *u8, ws_c3(m, "mix" as *u8, ws_f(m, "6.0" as *u8), ws_f(m, "10.0" as *u8), ws_c3(m, "clamp" as *u8, cs_fdiv(m, cs_gf(m, "uGN" as *u8), ws_f(m, "3.0" as *u8)), ws_f(m, "0.0" as *u8), ws_f(m, "1.0" as *u8), T_F32), T_F32), T_F32))
  let ar: i64 = sir_var(m, "aR8" as *u8, T_F32, ws_c1(m, "radians" as *u8, cs_negf(m, "3.0" as *u8), T_F32))
  // float MR8=exp(-(thH-aR8)*(thH-aR8)/(2.*bR8*bR8))*.3989/bR8;
  let mr: i64 = sir_var(m, "MR8" as *u8, T_F32, cs_lobe(m, "-" as *u8, cs_fl(m, "aR8" as *u8), cs_fl(m, "aR8" as *u8), "bR8" as *u8))
  // float bTT8=bR8*.5;float MTT8=exp(-(thH+aR8*.5)*(thH+aR8*.5)/(2.*bTT8*bTT8))*.3989/bTT8;
  let bt: i64 = sir_var(m, "bTT8" as *u8, T_F32, cs_fmul(m, cs_fl(m, "bR8" as *u8), ws_f(m, "0.5" as *u8)))
  let mt: i64 = sir_var(m, "MTT8" as *u8, T_F32, cs_lobe(m, "+" as *u8, cs_fmul(m, cs_fl(m, "aR8" as *u8), ws_f(m, "0.5" as *u8)), cs_fmul(m, cs_fl(m, "aR8" as *u8), ws_f(m, "0.5" as *u8)), "bTT8" as *u8))
  // float bT28=bR8*2.;float MT28=exp(-(thH+aR8*1.5)*(thH+aR8*1.5)/(2.*bT28*bT28))*.3989/bT28;
  let b2: i64 = sir_var(m, "bT28" as *u8, T_F32, cs_fmul(m, cs_fl(m, "bR8" as *u8), ws_f(m, "2.0" as *u8)))
  let m2: i64 = sir_var(m, "MT28" as *u8, T_F32, cs_lobe(m, "+" as *u8, cs_fmul(m, cs_fl(m, "aR8" as *u8), ws_f(m, "1.5" as *u8)), cs_fmul(m, cs_fl(m, "aR8" as *u8), ws_f(m, "1.5" as *u8)), "bT28" as *u8))
  // float fH8=.0466+(1.-.0466)*pow(1.-clamp(cTd*cHPhi,0.,1.),5.); vec3 Tt8=exp(-sigA8/max(cTd,.25));
  let fh: i64 = sir_var(m, "fH8" as *u8, T_F32, cs_fadd(m, ws_f(m, "0.0466" as *u8), cs_fmul(m, cs_fsub(m, ws_f(m, "1.0" as *u8), ws_f(m, "0.0466" as *u8)), ws_c2(m, "pow" as *u8, cs_fsub(m, ws_f(m, "1.0" as *u8), ws_c3(m, "clamp" as *u8, cs_fmul(m, cs_fl(m, "cTd" as *u8), cs_fl(m, "cHPhi" as *u8)), ws_f(m, "0.0" as *u8), ws_f(m, "1.0" as *u8), T_F32)), ws_f(m, "5.0" as *u8), T_F32))))
  let tt: i64 = sir_var(m, "Tt8" as *u8, T_V3F, ws_c1(m, "exp" as *u8, ws_bin(m, "/" as *u8, sir_neg(m, cs_v3(m, "sigA8" as *u8), T_V3F), ws_c2(m, "max" as *u8, cs_fl(m, "cTd" as *u8), ws_f(m, "0.25" as *u8), T_F32), T_V3F), T_V3F))
  // vec3 spec8=(MR8*(.25*cHPhi)*fH8*vec3(1.)+MTT8*exp(-3.65*cPhi-3.98)*(1.-fH8)*(1.-fH8)*Tt8+MT28*exp(17.*cPhi-16.78)*(1.-fH8)*(1.-fH8)*fH8*Tt8*Tt8)/max(cTd*cTd,.06);
  let ta: i64 = ws_bin(m, "*" as *u8, cs_fmul(m, cs_fmul(m, cs_fl(m, "MR8" as *u8), cs_fmul(m, ws_f(m, "0.25" as *u8), cs_fl(m, "cHPhi" as *u8))), cs_fl(m, "fH8" as *u8)), cs_v3l(m, "1.0" as *u8), T_V3F)
  let eb: i64 = ws_c1(m, "exp" as *u8, cs_fsub(m, cs_fmul(m, cs_negf(m, "3.65" as *u8), cs_fl(m, "cPhi" as *u8)), ws_f(m, "3.98" as *u8)), T_F32)
  let tb: i64 = ws_bin(m, "*" as *u8, cs_fmul(m, cs_fmul(m, cs_fmul(m, cs_fl(m, "MTT8" as *u8), eb), cs_1mf(m)), cs_1mf(m)), cs_v3(m, "Tt8" as *u8), T_V3F)
  let ec: i64 = ws_c1(m, "exp" as *u8, cs_fsub(m, cs_fmul(m, ws_f(m, "17.0" as *u8), cs_fl(m, "cPhi" as *u8)), ws_f(m, "16.78" as *u8)), T_F32)
  let tc: i64 = cs_v3mul(m, ws_bin(m, "*" as *u8, cs_fmul(m, cs_fmul(m, cs_fmul(m, cs_fmul(m, cs_fl(m, "MT28" as *u8), ec), cs_1mf(m)), cs_1mf(m)), cs_fl(m, "fH8" as *u8)), cs_v3(m, "Tt8" as *u8), T_V3F), cs_v3(m, "Tt8" as *u8))
  let sp: i64 = sir_var(m, "spec8" as *u8, T_V3F, ws_bin(m, "/" as *u8, cs_v3add(m, cs_v3add(m, ta, tb), tc), ws_c2(m, "max" as *u8, cs_fmul(m, cs_fl(m, "cTd" as *u8), cs_fl(m, "cTd" as *u8)), ws_f(m, "0.06" as *u8), T_F32), T_V3F))
  // spec8=min(spec8,vec3(6.)); hlin9+=vec3(1.,.94,.81)*1.008*spec8*sv8;
  let mn: i64 = ws_set(m, cs_v3(m, "spec8" as *u8), ws_c2(m, "min" as *u8, cs_v3(m, "spec8" as *u8), cs_v3l(m, "6.0" as *u8), T_V3F))
  let ad: i64 = ws_op(m, "hlin9" as *u8, T_V3F, "+" as *u8, cs_v3mul(m, cs_v3mul(m, cs_v3mul(m, ws_v3f(m, "1.0" as *u8, "0.94" as *u8, "0.81" as *u8), ws_f(m, cs_scene_direct_diffuse())), cs_v3(m, "spec8" as *u8)), cs_fl(m, "sv8" as *u8)))
  return ws_q4(m, ws_q4(m, ws_q4(m, vh, si, sr, ti), ws_q4(m, tr, thh, ct, lp), ws_q4(m, vp, cp, ch, lu), ws_q4(m, me, ph, sa, br)), ws_q4(m, ar, mr, bt, mt), ws_q4(m, b2, m2, fh, tt), ws_q3(m, sp, mn, ad))
1106}
1107
1108// hair C: the hair's own fog and grade twins, the output, the return
1109func cs_fs_hair_c(m: *i64) -> i64 {
  // vec3 hcl9=sqrt(max(hlin9,vec3(0.))); vec3 hfw9=...; hcl9=mix(hcl9,uSkTM,hfw9); if(uVt==1)hcl9=...; fc=vec4(hcl9,1.);return;
  let hc: i64 = sir_var(m, "hcl9" as *u8, T_V3F, ws_c1(m, "sqrt" as *u8, ws_c2(m, "max" as *u8, cs_v3(m, "hlin9" as *u8), cs_v3l(m, "0.0" as *u8), T_V3F), T_V3F))
  let fw: i64 = cs_fog(m, "hfw9" as *u8)
  let mx: i64 = ws_set(m, cs_v3(m, "hcl9" as *u8), ws_c3(m, "mix" as *u8, cs_v3(m, "hcl9" as *u8), cs_v3(m, "uSkTM" as *u8), cs_v3(m, "hfw9" as *u8), T_V3F))
  let gr: i64 = cs_grade(m, "hcl9" as *u8)
  let fo: i64 = ws_set(m, cs_v4(m, "fc" as *u8), ws_vt2(m, T_V4F, cs_v3(m, "hcl9" as *u8), ws_f(m, "1.0" as *u8)))
  return ws_q3(m, ws_q2(m, hc, fw), ws_q2(m, mx, gr), ws_q2(m, fo, sir_return(m, 0)))
1117}
1118
1119// FS slice 6 of main: the skirt mesh tint (uGar==1) and the HAIR STRAND branch (uGar==2): albedo x (sky + sun x Kajiya x the
1120// voxel sun-visibility) plus the Marschner R/TT/TRT specular, its own fog and grade twins, RETURNS
1121func cs_fs_slice6(m: *i64, f: i64) -> i64 {
  // if(uGar==1)mc=uCB[vII];
  ws_st(m, f, ws_if(m, cs_icmp(m, "==" as *u8, "uGar" as *u8, "1" as *u8), ws_set(m, cs_v3(m, "mc" as *u8), cs_g3(m, "uCB" as *u8)), 0))
  // if(uGar==2){ ... }
  ws_st(m, f, ws_if(m, cs_icmp(m, "==" as *u8, "uGar" as *u8, "2" as *u8), ws_q3(m, cs_fs_hair_a(m), cs_fs_hair_b(m), cs_fs_hair_c(m)), 0))
  return 0
1127}
1128
1129// ---- slice 7: the skin tail ----
1130// the flush block: capillary zonation on the anatomy bands, the sun-tone gradient, the cheek convexity lift (uGar==0&&uAuth==0)
1131func cs_fs_flush(m: *i64) -> i64 {
  // float fl9=0.; float chz9=(h-.925)*uH/(.115*uH);
  let f0: i64 = sir_var(m, "fl9" as *u8, T_F32, ws_f(m, "0.0" as *u8))
  let cz: i64 = sir_var(m, "chz9" as *u8, T_F32, cs_fdiv(m, cs_fmul(m, cs_fsub(m, cs_fl(m, "h" as *u8), ws_f(m, "0.925" as *u8)), cs_fl(m, "uH" as *u8)), cs_fmul(m, ws_f(m, "0.115" as *u8), cs_fl(m, "uH" as *u8))))
  // fl9+=max(0.,1.-length(vec2((abs(vB.x)-.11*.115*uH)/(.06*.115*uH),chz9/(.5))))*.5;
  let cx: i64 = cs_fdiv(m, cs_fsub(m, ws_c1(m, "abs" as *u8, cs_sx3(m, "vB" as *u8, "x" as *u8), T_F32), cs_fmul(m, cs_fmul(m, ws_f(m, "0.11" as *u8), ws_f(m, "0.115" as *u8)), cs_fl(m, "uH" as *u8))), cs_fmul(m, cs_fmul(m, ws_f(m, "0.06" as *u8), ws_f(m, "0.115" as *u8)), cs_fl(m, "uH" as *u8)))
  let f1: i64 = ws_op(m, "fl9" as *u8, T_F32, "+" as *u8, cs_fmul(m, ws_c2(m, "max" as *u8, ws_f(m, "0.0" as *u8), cs_fsub(m, ws_f(m, "1.0" as *u8), ws_c1(m, "length" as *u8, ws_v2(m, cx, cs_fdiv(m, cs_fl(m, "chz9" as *u8), ws_f(m, "0.5" as *u8))), T_F32)), T_F32), ws_f(m, "0.5" as *u8)))
  // fl9+=(1.-smoothstep(0.,.02,abs(h-.918)))*(1.-smoothstep(0.,.03*.115*uH,abs(vB.x)))*.6;
  let f2: i64 = ws_op(m, "fl9" as *u8, T_F32, "+" as *u8, cs_fmul(m, cs_fmul(m, cs_fsub(m, ws_f(m, "1.0" as *u8), cs_ss(m, ws_f(m, "0.0" as *u8), ws_f(m, "0.02" as *u8), ws_c1(m, "abs" as *u8, cs_fsub(m, cs_fl(m, "h" as *u8), ws_f(m, "0.918" as *u8)), T_F32))), cs_fsub(m, ws_f(m, "1.0" as *u8), cs_ss(m, ws_f(m, "0.0" as *u8), cs_fmul(m, cs_fmul(m, ws_f(m, "0.03" as *u8), ws_f(m, "0.115" as *u8)), cs_fl(m, "uH" as *u8)), ws_c1(m, "abs" as *u8, cs_sx3(m, "vB" as *u8, "x" as *u8), T_F32)))), ws_f(m, "0.6" as *u8)))
  // fl9+=(1.-smoothstep(0.,.025,abs(h-.520)))*.30; fl9+=(1.-smoothstep(0.,.025,abs(h-.335)))*.25;
  let f3: i64 = ws_op(m, "fl9" as *u8, T_F32, "+" as *u8, cs_fmul(m, cs_fsub(m, ws_f(m, "1.0" as *u8), cs_ss(m, ws_f(m, "0.0" as *u8), ws_f(m, "0.025" as *u8), ws_c1(m, "abs" as *u8, cs_fsub(m, cs_fl(m, "h" as *u8), ws_f(m, "0.520" as *u8)), T_F32))), ws_f(m, "0.30" as *u8)))
  let f4: i64 = ws_op(m, "fl9" as *u8, T_F32, "+" as *u8, cs_fmul(m, cs_fsub(m, ws_f(m, "1.0" as *u8), cs_ss(m, ws_f(m, "0.0" as *u8), ws_f(m, "0.025" as *u8), ws_c1(m, "abs" as *u8, cs_fsub(m, cs_fl(m, "h" as *u8), ws_f(m, "0.335" as *u8)), T_F32))), ws_f(m, "0.25" as *u8)))
  // mc=mix(mc,mc*vec3(1.10,.90,.88),clamp(fl9,0.,.3)); mc*=mix(vec3(1.),vec3(1.03,.995,.96),clamp((h-.35)/.55,0.,1.)*.7);
  let m1: i64 = ws_set(m, cs_v3(m, "mc" as *u8), ws_c3(m, "mix" as *u8, cs_v3(m, "mc" as *u8), cs_v3mul(m, cs_v3(m, "mc" as *u8), ws_v3f(m, "1.10" as *u8, "0.90" as *u8, "0.88" as *u8)), ws_c3(m, "clamp" as *u8, cs_fl(m, "fl9" as *u8), ws_f(m, "0.0" as *u8), ws_f(m, "0.3" as *u8), T_F32), T_V3F))
  let m2: i64 = ws_op(m, "mc" as *u8, T_V3F, "*" as *u8, ws_c3(m, "mix" as *u8, cs_v3l(m, "1.0" as *u8), ws_v3f(m, "1.03" as *u8, "0.995" as *u8, "0.96" as *u8), cs_fmul(m, ws_c3(m, "clamp" as *u8, cs_fdiv(m, cs_fsub(m, cs_fl(m, "h" as *u8), ws_f(m, "0.35" as *u8)), ws_f(m, "0.55" as *u8)), ws_f(m, "0.0" as *u8), ws_f(m, "1.0" as *u8), T_F32), ws_f(m, "0.7" as *u8)), T_V3F))
  // float ck9=(h-.912)*uH/(.115*uH); float ckm9=max(0.,1.-length(vec2((abs(vB.x)-.13*.115*uH)/(.10*.115*uH),ck9/.65))); mc*=1.+.06*ckm9;
  let ck: i64 = sir_var(m, "ck9" as *u8, T_F32, cs_fdiv(m, cs_fmul(m, cs_fsub(m, cs_fl(m, "h" as *u8), ws_f(m, "0.912" as *u8)), cs_fl(m, "uH" as *u8)), cs_fmul(m, ws_f(m, "0.115" as *u8), cs_fl(m, "uH" as *u8))))
  let kx: i64 = cs_fdiv(m, cs_fsub(m, ws_c1(m, "abs" as *u8, cs_sx3(m, "vB" as *u8, "x" as *u8), T_F32), cs_fmul(m, cs_fmul(m, ws_f(m, "0.13" as *u8), ws_f(m, "0.115" as *u8)), cs_fl(m, "uH" as *u8))), cs_fmul(m, cs_fmul(m, ws_f(m, "0.10" as *u8), ws_f(m, "0.115" as *u8)), cs_fl(m, "uH" as *u8)))
  let km: i64 = sir_var(m, "ckm9" as *u8, T_F32, ws_c2(m, "max" as *u8, ws_f(m, "0.0" as *u8), cs_fsub(m, ws_f(m, "1.0" as *u8), ws_c1(m, "length" as *u8, ws_v2(m, kx, cs_fdiv(m, cs_fl(m, "ck9" as *u8), ws_f(m, "0.65" as *u8))), T_F32)), T_F32))
  let m3: i64 = ws_op(m, "mc" as *u8, T_V3F, "*" as *u8, cs_fadd(m, ws_f(m, "1.0" as *u8), cs_fmul(m, ws_f(m, "0.06" as *u8), cs_fl(m, "ckm9" as *u8))))
  return ws_q3(m, ws_q4(m, f0, cz, f1, f2), ws_q4(m, f3, f4, m1, m2), ws_q3(m, ck, km, m3))
1152}
1153
1154// TEXM SPEC is F0; GLOSS is 1-roughness. The 8-bit floor follows map precision.
1155func cs_skin_maps_v1(m: *i64) -> i64 {
  let nl: i64 = sir_var(m, "skinNL" as *u8, T_F32, ws_c3(m, "clamp" as *u8, cs_fl(m, "ndl" as *u8), ws_f(m, "0.0" as *u8), ws_f(m, "1.0" as *u8), T_F32))
  let nv: i64 = sir_var(m, "skinNV" as *u8, T_F32, ws_c3(m, "clamp" as *u8, cs_dot(m, cs_v3(m, "n" as *u8), sir_neg(m, cs_v3(m, "vd" as *u8), T_V3F)), ws_f(m, "0.0" as *u8), ws_f(m, "1.0" as *u8), T_F32))
  let zero: i64 = ws_set(m, cs_fl(m, "skinSpec" as *u8), ws_f(m, "0.0" as *u8))
  let s0: i64 = sir_var(m, "skinF0" as *u8, T_F32, ws_sw(m, sir_texsample(m, sir_ident(m, "uAtl" as *u8, T_TEX2F), sir_ident(m, "vUV" as *u8, T_V2F)), "a" as *u8, T_F32))
  let s1: i64 = sir_var(m, "skinRough" as *u8, T_F32, ws_c2(m, "max" as *u8, cs_fsub(m, ws_f(m, "1.0" as *u8), ws_sw(m, sir_texsample(m, sir_ident(m, "uNrm" as *u8, T_TEX2F), sir_ident(m, "vUV" as *u8, T_V2F)), "a" as *u8, T_F32)), cs_fdiv(m, ws_f(m, "1.0" as *u8), ws_f(m, "255.0" as *u8)), T_F32))
  let s2: i64 = sir_var(m, "skinA2" as *u8, T_F32, ws_c2(m, "pow" as *u8, cs_fl(m, "skinRough" as *u8), ws_f(m, "4.0" as *u8), T_F32))
  let s3: i64 = sir_var(m, "skinNH" as *u8, T_F32, ws_c3(m, "clamp" as *u8, cs_dot(m, cs_v3(m, "n" as *u8), cs_v3(m, "H" as *u8)), ws_f(m, "0.0" as *u8), ws_f(m, "1.0" as *u8), T_F32))
  let s4: i64 = sir_var(m, "skinVH" as *u8, T_F32, ws_c3(m, "clamp" as *u8, cs_dot(m, sir_neg(m, cs_v3(m, "vd" as *u8), T_V3F), cs_v3(m, "H" as *u8)), ws_f(m, "0.0" as *u8), ws_f(m, "1.0" as *u8), T_F32))
  let s5: i64 = sir_var(m, "skinDen" as *u8, T_F32, cs_fadd(m, cs_fsub(m, ws_f(m, "1.0" as *u8), cs_fmul(m, cs_fl(m, "skinNH" as *u8), cs_fl(m, "skinNH" as *u8))), cs_fmul(m, cs_fmul(m, cs_fl(m, "skinNH" as *u8), cs_fl(m, "skinNH" as *u8)), cs_fl(m, "skinA2" as *u8))))
  let s6: i64 = sir_var(m, "skinD" as *u8, T_F32, cs_fdiv(m, cs_fl(m, "skinA2" as *u8), cs_fmul(m, ws_f(m, "3.141592653589793" as *u8), cs_fmul(m, cs_fl(m, "skinDen" as *u8), cs_fl(m, "skinDen" as *u8)))))
  let s7: i64 = sir_var(m, "skinK" as *u8, T_F32, cs_fdiv(m, ws_c2(m, "pow" as *u8, cs_fadd(m, cs_fl(m, "skinRough" as *u8), ws_f(m, "1.0" as *u8)), ws_f(m, "2.0" as *u8), T_F32), ws_f(m, "8.0" as *u8)))
  let s8: i64 = sir_var(m, "skinGL" as *u8, T_F32, cs_fdiv(m, cs_fl(m, "skinNL" as *u8), cs_fadd(m, cs_fmul(m, cs_fl(m, "skinNL" as *u8), cs_fsub(m, ws_f(m, "1.0" as *u8), cs_fl(m, "skinK" as *u8))), cs_fl(m, "skinK" as *u8))))
  let s9: i64 = sir_var(m, "skinGVdivNV" as *u8, T_F32, cs_fdiv(m, ws_f(m, "1.0" as *u8), cs_fadd(m, cs_fmul(m, cs_fl(m, "skinNV" as *u8), cs_fsub(m, ws_f(m, "1.0" as *u8), cs_fl(m, "skinK" as *u8))), cs_fl(m, "skinK" as *u8))))
  let s10: i64 = sir_var(m, "skinF" as *u8, T_F32, cs_fadd(m, cs_fl(m, "skinF0" as *u8), cs_fmul(m, cs_fsub(m, ws_f(m, "1.0" as *u8), cs_fl(m, "skinF0" as *u8)), ws_c2(m, "pow" as *u8, cs_fsub(m, ws_f(m, "1.0" as *u8), cs_fl(m, "skinVH" as *u8)), ws_f(m, "5.0" as *u8), T_F32))))
  let s11: i64 = ws_set(m, cs_fl(m, "skinSpec" as *u8), cs_fdiv(m, cs_fmul(m, cs_fmul(m, cs_fmul(m, cs_fl(m, "skinD" as *u8), cs_fl(m, "skinGL" as *u8)), cs_fl(m, "skinGVdivNV" as *u8)), cs_fl(m, "skinF" as *u8)), ws_f(m, "4.0" as *u8)))
  let visible: i64 = ws_and(m, ws_cmp(m, ">" as *u8, cs_fl(m, "skinNL" as *u8), ws_f(m, "0.0" as *u8)), ws_cmp(m, ">" as *u8, cs_fl(m, "skinNV" as *u8), ws_f(m, "0.0" as *u8)))
  let body: i64 = ws_q2(m, s3, ws_q2(m, s4, ws_q2(m, s5, ws_q2(m, s6, ws_q2(m, s7, ws_q2(m, s8, ws_q2(m, s9, ws_q2(m, s10, s11))))))))
  return ws_q4(m, nl, nv, zero, ws_q4(m, s0, s1, s2, ws_if(m, visible, body, 0)))
1174}
1175
1176// FS slice 7 of main: SKIN, NOT PLASTIC -- the Penner per-channel wrap, the red-shifted terminator, the flush block, specular
1177// and rim, the voxel sun-visibility, the energy split (sky fill + sun + sand bounce + rim), the fog and grade twins, the output
1178func cs_fs_slice7(m: *i64, f: i64) -> i64 {
  // vec3 L=normalize(vec3(2400.,2500.,1400.)); vec3 Ls9=(dot(uSunM,uSunM)>.01)?normalize(uSunM):L; float ndl=dot(n,Ls9);
  ws_st(m, f, sir_var(m, "L" as *u8, T_V3F, cs_sun0(m)))
  ws_st(m, f, cs_sunL(m, "Ls9" as *u8, cs_v3(m, "L" as *u8)))
  ws_st(m, f, sir_var(m, "ndl" as *u8, T_F32, cs_dot(m, cs_v3(m, "n" as *u8), cs_v3(m, "Ls9" as *u8))))
  // float wr=.42; float dif=clamp((ndl+wr)/(1.+wr),0.,1.);
  ws_st(m, f, sir_var(m, "wr" as *u8, T_F32, ws_f(m, "0.42" as *u8)))
  ws_st(m, f, sir_var(m, "dif" as *u8, T_F32, ws_c3(m, "clamp" as *u8, cs_fdiv(m, cs_fadd(m, cs_fl(m, "ndl" as *u8), cs_fl(m, "wr" as *u8)), cs_fadd(m, ws_f(m, "1.0" as *u8), cs_fl(m, "wr" as *u8))), ws_f(m, "0.0" as *u8), ws_f(m, "1.0" as *u8), T_F32)))
  // float invr=length(fwidth(n))/max(length(fwidth(vW)),1e-6); float cv9=0.;
  ws_st(m, f, sir_var(m, "invr" as *u8, T_F32, cs_fdiv(m, ws_c1(m, "length" as *u8, ws_c1(m, "fwidth" as *u8, cs_v3(m, "n" as *u8), T_V3F), T_F32), ws_c2(m, "max" as *u8, ws_c1(m, "length" as *u8, ws_c1(m, "fwidth" as *u8, cs_v3(m, "vW" as *u8), T_V3F), T_F32), ws_f(m, "1e-6" as *u8), T_F32))))
  ws_st(m, f, sir_var(m, "cv9" as *u8, T_F32, ws_f(m, "0.0" as *u8)))
  // vec3 w3=(uGar==0&&uAuth==0)?vec3(.469,.234,.102)+cv9*vec3(.375,.156,.047):vec3(wr); if(h>.885)w3=mix(w3,vec3(wr),.6);
  // Reuse the established scalar wrap: geometry must not create separate RGB light terminators.
  let wsel: i64 = ws_v1(m, T_V3F, cs_fl(m, "wr" as *u8))
  ws_st(m, f, sir_var(m, "w3" as *u8, T_V3F, wsel))
  ws_st(m, f, ws_if(m, cs_h(m, ">" as *u8, "0.885" as *u8), ws_set(m, cs_v3(m, "w3" as *u8), ws_c3(m, "mix" as *u8, cs_v3(m, "w3" as *u8), ws_v1(m, T_V3F, cs_fl(m, "wr" as *u8)), ws_f(m, "0.6" as *u8), T_V3F)), 0))
  // vec3 dif3=clamp((vec3(ndl)+w3)/(1.+w3),0.,1.); float term=1.-smoothstep(.0,.45,abs(ndl+.05));
  ws_st(m, f, sir_var(m, "dif3" as *u8, T_V3F, ws_c3(m, "clamp" as *u8, ws_bin(m, "/" as *u8, cs_v3add(m, ws_v1(m, T_V3F, cs_fl(m, "ndl" as *u8)), cs_v3(m, "w3" as *u8)), ws_bin(m, "+" as *u8, ws_f(m, "1.0" as *u8), cs_v3(m, "w3" as *u8), T_V3F), T_V3F), ws_f(m, "0.0" as *u8), ws_f(m, "1.0" as *u8), T_V3F)))
  ws_st(m, f, sir_var(m, "term" as *u8, T_F32, cs_fsub(m, ws_f(m, "1.0" as *u8), cs_ss(m, ws_f(m, "0.0" as *u8), ws_f(m, "0.45" as *u8), ws_c1(m, "abs" as *u8, cs_fadd(m, cs_fl(m, "ndl" as *u8), ws_f(m, "0.05" as *u8)), T_F32)))))
  // if(uGar==0&&uAuth==0){ the flush block }
  ws_st(m, f, ws_if(m, ws_and(m, cs_icmp(m, "==" as *u8, "uGar" as *u8, "0" as *u8), cs_auth0(m)), cs_fs_flush(m), 0))
  // Shared sun direction for diffuse and specular: vec3 H=normalize(Ls9-vd);float spe=pow(max(dot(n,H),0.),26.); float rim=pow(1.-max(dot(n,-vd),0.),2.5);
  ws_st(m, f, sir_var(m, "H" as *u8, T_V3F, ws_c1(m, "normalize" as *u8, cs_v3sub(m, cs_v3(m, "Ls9" as *u8), cs_v3(m, "vd" as *u8)), T_V3F)))
  ws_st(m, f, sir_var(m, "spe" as *u8, T_F32, ws_c2(m, "pow" as *u8, ws_c2(m, "max" as *u8, cs_dot(m, cs_v3(m, "n" as *u8), cs_v3(m, "H" as *u8)), ws_f(m, "0.0" as *u8), T_F32), ws_f(m, "26.0" as *u8), T_F32)))
  ws_st(m, f, sir_var(m, "skinSpec" as *u8, T_F32, cs_fmul(m, cs_fl(m, "spe" as *u8), ws_f(m, "0.048" as *u8))))
  ws_st(m, f, ws_if(m, cs_and3(m, cs_icmp(m, "==" as *u8, "uSkinMaps" as *u8, "1" as *u8), cs_icmp(m, "==" as *u8, "uGar" as *u8, "0" as *u8), cs_auth0(m)), cs_skin_maps_v1(m), 0))
  ws_st(m, f, sir_var(m, "rim" as *u8, T_F32, ws_c2(m, "pow" as *u8, cs_fsub(m, ws_f(m, "1.0" as *u8), ws_c2(m, "max" as *u8, cs_dot(m, cs_v3(m, "n" as *u8), sir_neg(m, cs_v3(m, "vd" as *u8), T_V3F)), ws_f(m, "0.0" as *u8), T_F32)), ws_f(m, "2.5" as *u8), T_F32)))
  // float sv9=1.;if(uOcc>=1){float t08=...;if(vmarch(vW+Ls9*t08,Ls9,40.)>=0.)sv9=0.;}
  ws_st(m, f, cs_sunvis_decl(m, "sv9" as *u8))
  ws_st(m, f, cs_sunvis_if(m, "sv9" as *u8, "t08" as *u8, "Ls9" as *u8))
  // vec3 mcl=mc*mc;vec3 lin=mcl*(uSkyF+1.008*dif3*sv9)+mcl*vec3(.17,.14,.095)*max(0.,-n.y)*(.35+.65*sv9)+vec3(1.,.94,.81)*spe*.048*sv9+uSkTM*uSkTM*rim*.09;vec3 col=sqrt(max(lin,vec3(0.)));
  ws_st(m, f, sir_var(m, "mcl" as *u8, T_V3F, cs_v3mul(m, cs_v3(m, "mc" as *u8), cs_v3(m, "mc" as *u8))))
  let la: i64 = cs_v3mul(m, cs_v3(m, "mcl" as *u8), cs_v3add(m, cs_v3(m, "uSkyF" as *u8), cs_v3mul(m, ws_bin(m, "*" as *u8, ws_f(m, cs_scene_direct_diffuse()), cs_v3(m, "dif3" as *u8), T_V3F), cs_fl(m, "sv9" as *u8))))
  let lb: i64 = cs_v3mul(m, cs_v3mul(m, cs_v3mul(m, cs_v3(m, "mcl" as *u8), ws_v3f(m, "0.17" as *u8, "0.14" as *u8, "0.095" as *u8)), ws_c2(m, "max" as *u8, ws_f(m, "0.0" as *u8), sir_neg(m, cs_sx3(m, "n" as *u8, "y" as *u8), T_F32), T_F32)), cs_fadd(m, ws_f(m, "0.35" as *u8), cs_fmul(m, ws_f(m, "0.65" as *u8), cs_fl(m, "sv9" as *u8))))
  let lc: i64 = cs_v3mul(m, cs_v3mul(m, ws_v3f(m, "1.0" as *u8, "0.94" as *u8, "0.81" as *u8), cs_fl(m, "skinSpec" as *u8)), cs_fl(m, "sv9" as *u8))
  let ld: i64 = cs_v3mul(m, cs_v3mul(m, cs_v3mul(m, cs_v3(m, "uSkTM" as *u8), cs_v3(m, "uSkTM" as *u8)), cs_fl(m, "rim" as *u8)), ws_f(m, "0.09" as *u8))
  ws_st(m, f, sir_var(m, "lin" as *u8, T_V3F, cs_v3add(m, cs_v3add(m, cs_v3add(m, la, lb), lc), ld)))
  ws_st(m, f, sir_var(m, "col" as *u8, T_V3F, ws_c1(m, "sqrt" as *u8, ws_c2(m, "max" as *u8, cs_v3(m, "lin" as *u8), cs_v3l(m, "0.0" as *u8), T_V3F), T_V3F)))
  // vec3 fw9=...; vec3 gf9=mix(col,uSkTM,fw9);if(uVt==1)gf9=...;fc=vec4(gf9,1.);  -- the last statement of main, no return
  ws_st(m, f, cs_fog(m, "fw9" as *u8))
  ws_st(m, f, sir_var(m, "gf9" as *u8, T_V3F, ws_c3(m, "mix" as *u8, cs_v3(m, "col" as *u8), cs_v3(m, "uSkTM" as *u8), cs_v3(m, "fw9" as *u8), T_V3F)))
  ws_st(m, f, cs_grade(m, "gf9" as *u8))
  ws_st(m, f, ws_set(m, cs_v4(m, "fc" as *u8), ws_vt2(m, T_V4F, cs_v3(m, "gf9" as *u8), ws_f(m, "1.0" as *u8))))
  return 0
1222}
1223
1224// FS slice 1 of main: the camera-side occlusion march and its debug lever
1225// Inspection v1: mode 0 is the normal material; 1 atlas albedo, 2 geometry normals,
1226// 3 mapped normals, 4 neutral geometry lighting. These are diagnostic views, not beauty scores.
1227// Missing albedo is magenta, never silently a generated replacement. Shared by GLSL and WGSL.
1228
1229// Authored base-color inspection preserves linear factors and alpha semantics.
1230// This is an albedo diagnostic, not a substitute for metallic-roughness lighting.
1231func cs_material_decode(m:*i64,x:i64)->i64{return sir_select(m,ws_cmp(m,"<=",x,ws_f(m,"0.04045")),cs_fdiv(m,x,ws_f(m,"12.92")),ws_c2(m,"pow",cs_fdiv(m,cs_fadd(m,x,ws_f(m,"0.055")),ws_f(m,"1.055")),ws_f(m,"2.4"),T_F32),T_F32)}
1232func cs_material_encode(m:*i64,x:i64)->i64{return sir_select(m,ws_cmp(m,"<=",x,ws_f(m,"0.0031308")),cs_fmul(m,x,ws_f(m,"12.92")),cs_fsub(m,cs_fmul(m,ws_f(m,"1.055"),ws_c2(m,"pow",x,cs_fdiv(m,ws_f(m,"1.0"),ws_f(m,"2.4")),T_F32)),ws_f(m,"0.055")),T_F32)}
1233func cs_material_albedo(m:*i64,f:i64)->i64{
let body:i64=sir_node(m,K_FUNC,T_VOID,0,0,0,0)
let sample:i64=sir_texsample(m,sir_ident(m,"uAtl",T_TEX2F),sir_ident(m,"vUV",T_V2F))
ws_st(m,body,sir_var(m,"matTex",T_V4F,sir_select(m,cs_icmp(m,"==","uAtlOn","1"),sample,ws_v1(m,T_V4F,ws_f(m,"1.0")),T_V4F)))
ws_st(m,body,sir_var(m,"matAlpha",T_F32,cs_fmul(m,cs_sx4(m,"matTex","a"),cs_sx4(m,"uBaseColorFactor","a"))))
ws_st(m,body,ws_if(m,ws_and(m,cs_icmp(m,"==","uAlphaMode","1"),ws_cmp(m,"<",cs_fl(m,"matAlpha"),cs_fl(m,"uAlphaCutoff"))),sir_discard(m),0))
ws_st(m,body,sir_var(m,"matr",T_F32,cs_material_encode(m,cs_fmul(m,cs_material_decode(m,cs_sx4(m,"matTex","r")),cs_sx4(m,"uBaseColorFactor","r")))))
ws_st(m,body,sir_var(m,"matg",T_F32,cs_material_encode(m,cs_fmul(m,cs_material_decode(m,cs_sx4(m,"matTex","g")),cs_sx4(m,"uBaseColorFactor","g")))))
ws_st(m,body,sir_var(m,"matb",T_F32,cs_material_encode(m,cs_fmul(m,cs_material_decode(m,cs_sx4(m,"matTex","b")),cs_sx4(m,"uBaseColorFactor","b")))))
let color:i64=ws_v4(m,cs_fl(m,"matr"),cs_fl(m,"matg"),cs_fl(m,"matb"),sir_select(m,cs_icmp(m,"==","uAlphaMode","2"),cs_fl(m,"matAlpha"),ws_f(m,"1.0"),T_F32))
ws_st(m,body,ws_set(m,cs_v4(m,"fc"),color));ws_st(m,body,sir_return(m,0))
let active:i64=ws_and(m,cs_icmp(m,"==","uMaterialMode","1"),ws_and(m,cs_icmp(m,"==","uInspect","1"),ws_and(m,cs_icmp(m,"==","uGar","0"),cs_icmp(m,"==","uShd","0"))))
ws_st(m,f,ws_if(m,active,sir_get(m,body,SIR_B),0));return 0
1246}
1247
1248// Scale before normalization so finite subnormal/large inputs do not square into zero/infinity.
1249// Zero directions have no direct-light contribution; callers reject each nonfinite source component.
1250func cs_material_unit_decl(m:*i64)->i64{
let f:i64=sir_func(m,"materialUnit",T_V3F);sir_param(m,f,"value",T_V3F)
let x:i64=ws_c1(m,"abs",cs_sx3(m,"value","x"),T_F32);let y:i64=ws_c1(m,"abs",cs_sx3(m,"value","y"),T_F32);let z:i64=ws_c1(m,"abs",cs_sx3(m,"value","z"),T_F32)
ws_st(m,f,sir_var(m,"largest",T_F32,ws_c2(m,"max",ws_c2(m,"max",x,y,T_F32),z,T_F32)))
let valid:i64=ws_and(m,ws_cmp(m,">",cs_fl(m,"largest"),ws_f(m,"0.0")),ws_cmp(m,"<=",cs_fl(m,"largest"),ws_f(m,"3.4028234663852886e38")))
ws_st(m,f,ws_if(m,sir_not(m,valid),sir_return(m,ws_v1(m,T_V3F,ws_f(m,"0.0"))),0))
ws_st(m,f,sir_return(m,ws_c1(m,"normalize",ws_bin(m,"/",cs_v3(m,"value"),cs_fl(m,"largest"),T_V3F),T_V3F)));return f
1257}
1258// Single-scattering metallic/roughness direct BRDF; ambient is explicit diffuse irradiance, not IBL.
1259// Caller admits positive roughness and finite nonnegative light inputs; source albedo inspection stays separate.
1260func cs_material_lit(m:*i64,f:i64)->i64{
let body:i64=sir_node(m,K_FUNC,T_VOID,0,0,0,0)
let tex:i64=sir_texsample(m,sir_ident(m,"uAtl",T_TEX2F),sir_ident(m,"vUV",T_V2F))
ws_st(m,body,sir_var(m,"litTex",T_V4F,sir_select(m,cs_icmp(m,"==","uAtlOn","1"),tex,ws_v1(m,T_V4F,ws_f(m,"1.0")),T_V4F)))
ws_st(m,body,sir_var(m,"litAlpha",T_F32,cs_fmul(m,cs_sx4(m,"litTex","a"),cs_sx4(m,"uBaseColorFactor","a"))))
ws_st(m,body,ws_if(m,ws_and(m,cs_icmp(m,"==","uAlphaMode","1"),ws_cmp(m,"<",cs_fl(m,"litAlpha"),cs_fl(m,"uAlphaCutoff"))),sir_discard(m),0))
ws_st(m,body,sir_var(m,"litBase",T_V3F,ws_v3(m,cs_fmul(m,cs_material_decode(m,cs_sx4(m,"litTex","r")),cs_sx4(m,"uBaseColorFactor","r")),cs_fmul(m,cs_material_decode(m,cs_sx4(m,"litTex","g")),cs_sx4(m,"uBaseColorFactor","g")),cs_fmul(m,cs_material_decode(m,cs_sx4(m,"litTex","b")),cs_sx4(m,"uBaseColorFactor","b")))))
ws_st(m,body,sir_var(m,"litN",T_V3F,ws_c1(m,"materialUnit",cs_v3(m,"vN"),T_V3F)))
let mapped:i64=sir_node(m,K_FUNC,T_VOID,0,0,0,0)
let normalTex:i64=ws_sw(m,sir_texsample(m,sir_ident(m,"uNrm",T_TEX2F),sir_ident(m,"vUV",T_V2F)),"xyz",T_V3F)
ws_st(m,mapped,sir_var(m,"litNormalTexel",T_V3F,normalTex))
let normalDecoded:i64=cs_normal_decode_rgb(m,cs_v3(m,"litNormalTexel"),cs_i(m,"uNrmEncoding"))
ws_st(m,mapped,ws_set(m,cs_v3(m,"litN"),cs_material_mapped_call(m,cs_v3(m,"vN"),cs_v4(m,"vT"),normalDecoded,cs_fl(m,"uNrmScale"))))
ws_st(m,body,ws_if(m,cs_ieq(m,"uNrmOn","1"),sir_get(m,mapped,SIR_B),0))
ws_st(m,body,ws_if(m,ws_and(m,cs_icmp(m,"==","uMaterialDoubleSided","1"),sir_not(m,sir_ident(m,"materialFrontFacing",T_BOOL))),ws_set(m,cs_v3(m,"litN"),sir_neg(m,cs_v3(m,"litN"),T_V3F)),0))
ws_st(m,body,sir_var(m,"litV",T_V3F,ws_c1(m,"materialUnit",cs_v3sub(m,cs_v3(m,"uCamM"),cs_v3(m,"vW")),T_V3F)))
ws_st(m,body,sir_var(m,"litL",T_V3F,ws_c1(m,"materialUnit",cs_v3(m,"uSunM"),T_V3F)))
ws_st(m,body,sir_var(m,"litNL",T_F32,cs_dot(m,cs_v3(m,"litN"),cs_v3(m,"litL"))))
ws_st(m,body,sir_var(m,"litNV",T_F32,cs_dot(m,cs_v3(m,"litN"),cs_v3(m,"litV"))))
ws_st(m,body,sir_var(m,"litF0",T_V3F,ws_c3(m,"mix",ws_v1(m,T_V3F,ws_f(m,"0.04")),cs_v3(m,"litBase"),cs_fl(m,"uMetallicFactor"),T_V3F)))
ws_st(m,body,sir_var(m,"litDiffuse",T_V3F,cs_v3mul(m,cs_v3(m,"litBase"),cs_fdiv(m,cs_fsub(m,ws_f(m,"1.0"),cs_fl(m,"uMetallicFactor")),ws_f(m,"3.141592653589793")))))
ws_st(m,body,sir_var(m,"litOut",T_V3F,cs_v3add(m,cs_v3(m,"uEmissiveFactor"),cs_v3mul(m,cs_v3mul(m,cs_v3(m,"litDiffuse"),cs_v3sub(m,ws_v1(m,T_V3F,ws_f(m,"1.0")),cs_v3(m,"litF0"))),cs_v3(m,"uMaterialAmbient")))))
let direct:i64=sir_node(m,K_FUNC,T_VOID,0,0,0,0)
ws_st(m,direct,sir_var(m,"litH",T_V3F,ws_c1(m,"materialUnit",cs_v3add(m,cs_v3(m,"litV"),cs_v3(m,"litL")),T_V3F)))
ws_st(m,direct,sir_var(m,"litNH",T_F32,ws_c3(m,"clamp",cs_dot(m,cs_v3(m,"litN"),cs_v3(m,"litH")),ws_f(m,"0.0"),ws_f(m,"1.0"),T_F32)))
ws_st(m,direct,sir_var(m,"litVH",T_F32,ws_c3(m,"clamp",cs_dot(m,cs_v3(m,"litV"),cs_v3(m,"litH")),ws_f(m,"0.0"),ws_f(m,"1.0"),T_F32)))
ws_st(m,direct,sir_var(m,"litA",T_F32,cs_fmul(m,cs_fl(m,"uRoughnessFactor"),cs_fl(m,"uRoughnessFactor"))))
ws_st(m,direct,sir_var(m,"litA2",T_F32,cs_fmul(m,cs_fl(m,"litA"),cs_fl(m,"litA"))))
ws_st(m,direct,sir_var(m,"litDden",T_F32,cs_fadd(m,cs_fsub(m,ws_f(m,"1.0"),cs_fmul(m,cs_fl(m,"litNH"),cs_fl(m,"litNH"))),cs_fmul(m,cs_fl(m,"litA2"),cs_fmul(m,cs_fl(m,"litNH"),cs_fl(m,"litNH"))))))
ws_st(m,direct,sir_var(m,"litRatio",T_F32,cs_fdiv(m,cs_fl(m,"litA"),cs_fl(m,"litDden"))))
ws_st(m,direct,sir_var(m,"litD",T_F32,cs_fdiv(m,cs_fmul(m,cs_fl(m,"litRatio"),cs_fl(m,"litRatio")),ws_f(m,"3.141592653589793"))))
ws_st(m,direct,sir_var(m,"litCosineScale",T_F32,ws_c2(m,"max",cs_fl(m,"litNL"),cs_fl(m,"litNV"),T_F32)))
ws_st(m,direct,sir_var(m,"litNLS",T_F32,cs_fdiv(m,cs_fl(m,"litNL"),cs_fl(m,"litCosineScale"))))
ws_st(m,direct,sir_var(m,"litNVS",T_F32,cs_fdiv(m,cs_fl(m,"litNV"),cs_fl(m,"litCosineScale"))))
let gv:i64=ws_c1(m,"sqrt",cs_fadd(m,cs_fmul(m,cs_fmul(m,cs_fl(m,"litNV"),cs_fl(m,"litNV")),cs_fsub(m,ws_f(m,"1.0"),cs_fl(m,"litA2"))),cs_fl(m,"litA2")),T_F32)
let gl:i64=ws_c1(m,"sqrt",cs_fadd(m,cs_fmul(m,cs_fmul(m,cs_fl(m,"litNL"),cs_fl(m,"litNL")),cs_fsub(m,ws_f(m,"1.0"),cs_fl(m,"litA2"))),cs_fl(m,"litA2")),T_F32)
ws_st(m,direct,sir_var(m,"litVisibility",T_F32,cs_fdiv(m,cs_fmul(m,ws_f(m,"0.5"),cs_fl(m,"litNLS")),cs_fadd(m,cs_fmul(m,cs_fl(m,"litNLS"),gv),cs_fmul(m,cs_fl(m,"litNVS"),gl)))))
ws_st(m,direct,sir_var(m,"litF",T_V3F,cs_v3add(m,cs_v3(m,"litF0"),cs_v3mul(m,cs_v3sub(m,ws_v1(m,T_V3F,ws_f(m,"1.0")),cs_v3(m,"litF0")),ws_c2(m,"pow",cs_fsub(m,ws_f(m,"1.0"),cs_fl(m,"litVH")),ws_f(m,"5.0"),T_F32)))))
let brdf:i64=cs_v3add(m,cs_v3mul(m,cs_v3mul(m,cs_v3(m,"litDiffuse"),cs_v3sub(m,ws_v1(m,T_V3F,ws_f(m,"1.0")),cs_v3(m,"litF"))),cs_fl(m,"litNL")),cs_v3mul(m,cs_v3(m,"litF"),cs_fmul(m,cs_fl(m,"litD"),cs_fl(m,"litVisibility"))))
ws_st(m,direct,ws_set(m,cs_v3(m,"litOut"),cs_v3add(m,cs_v3(m,"litOut"),cs_v3mul(m,brdf,cs_v3(m,"uMaterialLight")))))
ws_st(m,body,ws_if(m,ws_and(m,ws_cmp(m,">",cs_fl(m,"litNL"),ws_f(m,"0.0")),ws_cmp(m,">",cs_fl(m,"litNV"),ws_f(m,"0.0"))),sir_get(m,direct,SIR_B),0))
ws_st(m,body,ws_set(m,cs_v4(m,"fc"),ws_v4(m,cs_material_encode(m,cs_sx3(m,"litOut","r")),cs_material_encode(m,cs_sx3(m,"litOut","g")),cs_material_encode(m,cs_sx3(m,"litOut","b")),sir_select(m,cs_icmp(m,"==","uAlphaMode","2"),cs_fl(m,"litAlpha"),ws_f(m,"1.0"),T_F32))))
ws_st(m,body,sir_return(m,0))
let active:i64=ws_and(m,cs_icmp(m,"==","uMaterialMode","2"),ws_and(m,cs_icmp(m,"==","uInspect","0"),ws_and(m,cs_icmp(m,"==","uGar","0"),cs_icmp(m,"==","uShd","0"))))
ws_st(m,f,ws_if(m,active,sir_get(m,body,SIR_B),0));return 0
1305}
1306
1307func cs_fs_inspection_v1(m: *i64, f: i64) -> i64 {
  let active: i64 = ws_and(m, cs_icmp(m, "==" as *u8, "uGar" as *u8, "0" as *u8), ws_and(m, cs_icmp(m, ">=" as *u8, "uInspect" as *u8, "1" as *u8), cs_icmp(m, "<=" as *u8, "uInspect" as *u8, "4" as *u8)))
  let normal: i64 = ws_c1(m, "normalize" as *u8, cs_v3(m, "vN" as *u8), T_V3F)
  let encoded: i64 = cs_v3add(m, cs_v3mul(m, normal, ws_f(m, "0.5" as *u8)), ws_f(m, "0.5" as *u8))
  let init: i64 = sir_var(m, "inspectColor" as *u8, T_V3F, encoded)
  let sample: i64 = ws_sw(m, sir_texsample(m, sir_ident(m, "uAtl" as *u8, T_TEX2F), sir_ident(m, "vUV" as *u8, T_V2F)), "rgb" as *u8, T_V3F)
  let albedo: i64 = sir_select(m, cs_icmp(m, "==" as *u8, "uAtlOn" as *u8, "1" as *u8), sample, ws_v3f(m, "1.0" as *u8, "0.0" as *u8, "1.0" as *u8), T_V3F)
  let mode1: i64 = ws_if(m, cs_icmp(m, "==" as *u8, "uInspect" as *u8, "1" as *u8), ws_set(m, cs_v3(m, "inspectColor" as *u8), albedo), 0)
  let mapped: i64 = cs_v3add(m, cs_v3mul(m, cs_v3(m, "n" as *u8), ws_f(m, "0.5" as *u8)), ws_f(m, "0.5" as *u8))
  let mode3: i64 = ws_if(m, cs_icmp(m, "==" as *u8, "uInspect" as *u8, "3" as *u8), ws_set(m, cs_v3(m, "inspectColor" as *u8), mapped), 0)
  let facing: i64 = ws_c1(m, "abs" as *u8, cs_dot(m, normal, cs_v3(m, "vd" as *u8)), T_F32)
  let mode4: i64 = ws_if(m, cs_icmp(m, "==" as *u8, "uInspect" as *u8, "4" as *u8), ws_set(m, cs_v3(m, "inspectColor" as *u8), ws_v1(m, T_V3F, facing)), 0)
  let color: i64 = ws_set(m, cs_v4(m, "fc" as *u8), ws_vt2(m, T_V4F, cs_v3(m, "inspectColor" as *u8), ws_f(m, "1.0" as *u8)))
  ws_st(m, f, ws_if(m, active, ws_q2(m, ws_q5(m, init, mode1, mode3, mode4, color), sir_return(m, 0)), 0))
  return 0
1322}
1323
1324func shsrc_cast_fs_main(m: *i64) -> i64 {
  let f: i64 = sir_func(m, "main" as *u8, T_VOID)
  sir_param_front_facing(m,f,"materialFrontFacing")
  // vec3 dW=vW-uCamM;float dst=length(dW); int hdbg=0;float tdbg=0.;
  ws_st(m, f, sir_var(m, "dW" as *u8, T_V3F, cs_v3sub(m, cs_v3(m, "vW" as *u8), cs_v3(m, "uCamM" as *u8))))
  ws_st(m, f, sir_var(m, "dst" as *u8, T_F32, ws_c1(m, "length" as *u8, cs_v3(m, "dW" as *u8), T_F32)))
  ws_st(m, f, sir_var(m, "hdbg" as *u8, T_I32, ws_i(m, "0" as *u8)))
  ws_st(m, f, sir_var(m, "tdbg" as *u8, T_F32, ws_f(m, "0.0" as *u8)))
  // if(uOcc>=1){uint bf=vxm(ivec3(floor(vW)));if(bf!=0u&&bf!=4u)discard;}
  let bf: i64 = sir_var(m, "bf" as *u8, T_U32, ws_c1(m, "vxm" as *u8, ws_v1(m, T_V3I, cs_floor3(m, cs_v3(m, "vW" as *u8))), T_U32))
  let d1: i64 = ws_if(m, ws_and(m, ws_cmp(m, "!=" as *u8, cs_u32(m, "bf" as *u8), cs_u(m, "0" as *u8)), ws_cmp(m, "!=" as *u8, cs_u32(m, "bf" as *u8), cs_u(m, "4" as *u8))), sir_discard(m), 0)
  ws_st(m, f, ws_if(m, cs_icmp(m, ">=" as *u8, "uOcc" as *u8, "1" as *u8), ws_q2(m, bf, d1), 0))
  // if(uOcc>=1&&dst>1.){vec3 rdm9=dW/dst;float th9=vmarch(uCamM,rdm9,dst-.05);
  //   if(th9>=0.){ivec3 hc9=ivec3(floor(uCamM+rdm9*(th9+.02)));
  //     if(!(th9>dst-1.2&&hc9.y<int(floor(vW.y)))){if(uOcc==1){discard;}hdbg=1;tdbg=th9/dst;}}}
  let r9: i64 = sir_var(m, "rdm9" as *u8, T_V3F, ws_bin(m, "/" as *u8, cs_v3(m, "dW" as *u8), cs_fl(m, "dst" as *u8), T_V3F))
  let th: i64 = sir_var(m, "th9" as *u8, T_F32, ws_c3(m, "vmarch" as *u8, cs_v3(m, "uCamM" as *u8), cs_v3(m, "rdm9" as *u8), cs_fsub(m, cs_fl(m, "dst" as *u8), ws_f(m, "0.05" as *u8)), T_F32))
  let hcp: i64 = cs_v3add(m, cs_v3(m, "uCamM" as *u8), cs_v3mul(m, cs_v3(m, "rdm9" as *u8), cs_fadd(m, cs_fl(m, "th9" as *u8), ws_f(m, "0.02" as *u8))))
  let hc: i64 = sir_var(m, "hc9" as *u8, T_V3I, ws_v1(m, T_V3I, cs_floor3(m, hcp)))
  let inif: i64 = ws_if(m, cs_icmp(m, "==" as *u8, "uOcc" as *u8, "1" as *u8), sir_discard(m), 0)
  let gc: i64 = ws_and(m, ws_cmp(m, ">" as *u8, cs_fl(m, "th9" as *u8), cs_fsub(m, cs_fl(m, "dst" as *u8), ws_f(m, "1.2" as *u8))), ws_cmp(m, "<" as *u8, cs_sxi3(m, "hc9" as *u8, "y" as *u8), cs_i32(m, ws_c1(m, "floor" as *u8, cs_sx3(m, "vW" as *u8, "y" as *u8), T_F32))))
  let b3: i64 = ws_q3(m, inif, ws_set(m, cs_i(m, "hdbg" as *u8), ws_i(m, "1" as *u8)), ws_set(m, cs_fl(m, "tdbg" as *u8), cs_fdiv(m, cs_fl(m, "th9" as *u8), cs_fl(m, "dst" as *u8))))
  let if3: i64 = ws_if(m, sir_not(m, gc), b3, 0)
  let if2: i64 = ws_if(m, ws_cmp(m, ">=" as *u8, cs_fl(m, "th9" as *u8), ws_f(m, "0.0" as *u8)), ws_q2(m, hc, if3), 0)
  ws_st(m, f, ws_if(m, ws_and(m, cs_icmp(m, ">=" as *u8, "uOcc" as *u8, "1" as *u8), ws_cmp(m, ">" as *u8, cs_fl(m, "dst" as *u8), ws_f(m, "1.0" as *u8))), ws_q3(m, r9, th, if2), 0))
  // if(uOcc==2){fc=vec4(hdbg==1?1.:0.,hdbg==1?tdbg:1.,0.,1.);return;}
  let s1: i64 = sir_select(m, cs_icmp(m, "==" as *u8, "hdbg" as *u8, "1" as *u8), ws_f(m, "1.0" as *u8), ws_f(m, "0.0" as *u8), T_F32)
  let s2: i64 = sir_select(m, cs_icmp(m, "==" as *u8, "hdbg" as *u8, "1" as *u8), cs_fl(m, "tdbg" as *u8), ws_f(m, "1.0" as *u8), T_F32)
  let dv: i64 = ws_v4(m, s1, s2, ws_f(m, "0.0" as *u8), ws_f(m, "1.0" as *u8))
  ws_st(m, f, ws_if(m, cs_icmp(m, "==" as *u8, "uOcc" as *u8, "2" as *u8), ws_q2(m, ws_set(m, cs_v4(m, "fc" as *u8), dv), sir_return(m, 0)), 0))
  if cs_fs_slice2(m, f)<0{return 0-1}
  cs_material_albedo(m,f)
  cs_material_lit(m,f)
  cs_fs_inspection_v1(m, f)
  cs_fs_slice3(m, f)
  cs_fs_slice4(m, f)
  cs_fs_slice5(m, f)
  cs_fs_slice6(m, f)
  cs_fs_slice7(m, f)
  return f
1364}
1365
1366// the whole fragment module: declarations, vxm, vmarch, main (the slices landed so far)
1367func shsrc_cast_fs(m: *i64) -> i64 {
  shsrc_cast_fs_decls(m)
  shsrc_cast_fs_vxm(m)
  shsrc_cast_fs_vmarch(m)
  cs_material_unit_decl(m);cs_material_mapped_normal_decl(m)
  if shsrc_cast_fs_main(m)<0{return 0-1}
  if m[M_OVER]!=0{return 0-1}
  return 0
1375}
1376
1377// Shared body/eye visibility predicate. Frame axes are caller-validated inverse semi-axes;
1378// depth_axis is unit length. Points and origin share the current pose coordinate frame.
1379// open_fraction is in [0,1]; zero is closed. Closed depth and ellipse boundaries are included.
1380// This is geometric visibility, not a claim that an input outline is anatomical.
1381func cs_aperture_contains_v1(m:*i64,point:i64,origin:i64,right:i64,up:i64,depth_axis:i64,depth_min:i64,depth_max:i64,open_fraction:i64)->i64{
// Call arguments own intrusive next links: each dot receives a distinct subtraction node.
let x:i64=cs_dot(m,cs_v3sub(m,point,origin),right)
let y:i64=cs_dot(m,cs_v3sub(m,point,origin),up)
let z:i64=cs_dot(m,cs_v3sub(m,point,origin),depth_axis)
let oo:i64=cs_fmul(m,open_fraction,open_fraction)
let xy:i64=cs_fadd(m,cs_fmul(m,cs_fmul(m,x,x),oo),cs_fmul(m,y,y))
let opening:i64=ws_and(m,ws_cmp(m,">" as *u8,open_fraction,ws_f(m,"0.0" as *u8)),ws_cmp(m,"<=" as *u8,xy,oo))
return ws_and(m,opening,ws_and(m,ws_cmp(m,">=" as *u8,z,depth_min),ws_cmp(m,"<=" as *u8,z,depth_max)))
1390}
1391
1392import "nx_wgsl.nx"
1393// Input tangent is already posed; xyz is orthogonalized to inverse-transpose normal,
1394// w includes source UV handedness and sign of the linear pose determinant.
1395func cs_material_mapped_normal_decl(m:*i64)->i64{
let f:i64=sir_func(m,"materialMappedNormal",T_V3F)
sir_param(m,f,"normal",T_V3F);sir_param(m,f,"tangent",T_V4F)
sir_param(m,f,"decoded",T_V3F);sir_param(m,f,"scale",T_F32)
ws_st(m,f,sir_var(m,"frameN",T_V3F,ws_c1(m,"materialUnit",cs_v3(m,"normal"),T_V3F)))
let orthogonal:i64=cs_v3sub(m,cs_xyz(m,"tangent"),cs_v3mul(m,cs_v3(m,"frameN"),cs_dot(m,cs_v3(m,"frameN"),cs_xyz(m,"tangent"))))
ws_st(m,f,sir_var(m,"frameT",T_V3F,ws_c1(m,"materialUnit",orthogonal,T_V3F)))
ws_st(m,f,sir_var(m,"frameB",T_V3F,cs_v3mul(m,cs_cross(m,cs_v3(m,"frameN"),cs_v3(m,"frameT")),cs_sx4(m,"tangent","w"))))
let x:i64=cs_v3mul(m,cs_v3(m,"frameT"),cs_fmul(m,cs_sx3(m,"decoded","x"),cs_fl(m,"scale")))
let y:i64=cs_v3mul(m,cs_v3(m,"frameB"),cs_fmul(m,cs_sx3(m,"decoded","y"),cs_fl(m,"scale")))
let z:i64=cs_v3mul(m,cs_v3(m,"frameN"),cs_sx3(m,"decoded","z"))
ws_st(m,f,sir_return(m,ws_c1(m,"materialUnit",cs_v3add(m,cs_v3add(m,x,y),z),T_V3F)));return f
1407}
1408// Emits into cs_lbs_slice only after lc0..2 and ldet are available.
1409func cs_material_lbs_tangent(m:*i64,f:i64)->i64{
let x:i64=cs_v3mul(m,cs_xyz(m,"lc0"),cs_sx4(m,"aT","x"))
let y:i64=cs_v3mul(m,cs_xyz(m,"lc1"),cs_sx4(m,"aT","y"))
let z:i64=cs_v3mul(m,cs_xyz(m,"lc2"),cs_sx4(m,"aT","z"))
ws_st(m,f,sir_var(m,"lt",T_V3F,cs_v3add(m,cs_v3add(m,x,y),z)))
ws_st(m,f,sir_var(m,"lyt",T_V3F,sir_select(m,cs_ieq(m,"uAssetBasis","1"),cs_v3(m,"lt"),cs_yup(m,"lt"),T_V3F)))
let hand:i64=cs_fmul(m,cs_sx4(m,"aT","w"),ws_c1(m,"sign",cs_fl(m,"ldet"),T_F32))
ws_st(m,f,ws_set(m,cs_v4(m,"vT"),ws_vt2(m,T_V4F,cs_yaw(m,"lyt"),hand)));return 0
1417}
1418func cs_material_mapped_call(m:*i64,normal:i64,tangent:i64,decoded:i64,scale:i64)->i64{
if normal<=0||tangent<=0||decoded<=0||scale<=0{sir_refuse(m,"mapped normal missing input");return 0}
if normal>=m[M_NCOUNT]||tangent>=m[M_NCOUNT]||decoded>=m[M_NCOUNT]||scale>=m[M_NCOUNT]{sir_refuse(m,"mapped normal input outside module");return 0}
if sir_get(m,normal,SIR_TY)!=T_V3F||sir_get(m,tangent,SIR_TY)!=T_V4F||sir_get(m,decoded,SIR_TY)!=T_V3F||sir_get(m,scale,SIR_TY)!=T_F32{sir_refuse(m,"mapped normal input type mismatch");return 0}
let call:i64=sir_call(m,"materialMappedNormal",T_V3F)
sir_arg(m,call,normal);sir_arg(m,call,tangent);sir_arg(m,call,decoded);sir_arg(m,call,scale);return call
1424}
1425
1426// Renderer-relative diffuse coefficients shared by resident cast and prepared materials.
1427// These preserve the existing artistic response; they are not measured illumination.
1428func cs_scene_direct_diffuse()->*u8{return "1.008" as *u8}
1429func cs_scene_sky_r()->*u8{return "0.095" as *u8}
1430func cs_scene_sky_g()->*u8{return "0.112" as *u8}
1431func cs_scene_sky_b()->*u8{return "0.138" as *u8}
1432
1433import "nx_gltf_writer.nx"
1434func cs_scene_light_recipe_write(w:*i64)->i64{
glw_s(w,"{\"schema\":\"nishi-cast-scene-light/1\",\"owner\":\"nx_cast_shader_src\",\"version\":1,\"basis\":\"world-Y-up\",\"units\":\"relative-display\",\"valueDomain\":\"linear-light-relative\",\"ambientModel\":\"uniform-diffuse-irradiance\",\"directDiffuse\":");glw_s(w,cs_scene_direct_diffuse());glw_s(w,",\"skyDiffuse\":[");glw_s(w,cs_scene_sky_r());glw_s(w,",");glw_s(w,cs_scene_sky_g());glw_s(w,",");glw_s(w,cs_scene_sky_b());glw_s(w,"] ,\"calibration\":\"artistic-legacy-cast-coefficients-not-measured\",\"daylightPolicy\":\"legacy-cast-unmodulated\",\"visibility\":\"unoccluded-direct\"}");return w[3]
1436}
nx_cast_shader_src.nx source

`nx_cast_shader_src.nx` source
