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

↩ module page · 454 lines · 20272 B
1// nx_chem_stereo_test.nx -- C2.3d KAT: stereo emit (@/@@ for atoms + /\
2// for bonds).
3//
4// Verifies the canonical emit preserves stereo markers stored during
5// parse.  C2.3d MVP: emits stored stereo verbatim (no parity correction
6// for canonical-order rearrangement -- that's C2.3e with CIP rules).
7// Round-trip property: parse -> emit canonical -> parse same molecule
8// gives back the same stereo on atoms and bonds for molecules where
9// canonical DFS direction matches input direction.
10//
11// expect_exit: 0
12//
13// license_tier: ORIGINAL
14
15import "nx_chem_molecule.nx"
16import "nx_chem_smiles.nx"
17import "nx_chem_smiles_emit.nx"
18
19// Helper: parse, emit canonical, return canonical string
20func parse_canonical(src: *u8, n: nx_int, out: *u8, cap: nx_int, len: *nx_int) -> nx_int {
  let m: *MolGraph = nx_chem_parse_smiles(src, n)
  if m.is_valid != 1 { return 1 }
  return nx_chem_emit_canonical_smiles(m, out, cap, len)
24}
25
26// Helper: check if a buffer contains a specific byte
27func buf_contains(buf: *u8, n: nx_int, byte_val: nx_int) -> nx_int {
  var i: nx_int = 0
  while i < n {
      if (buf[i] & 0xff) == (byte_val & 0xff) { return 1 }
      i = i + 1
  }
  return 0
34}
35
36// =================================================================
37// A -- atom stereo @ emit: "[C@H](N)O" -> canonical contains @ somewhere
38// (in bracket form: '[' followed by atom symbol and @ marker)
39// =================================================================
40func a_atom_stereo_ccw() -> nx_int {
  let s: *u8 = sys_mmap(16)
  // "[C@H](N)O"
  s[0] = 0x5B; s[1] = 0x43; s[2] = 0x40; s[3] = 0x48; s[4] = 0x5D
  s[5] = 0x28; s[6] = 0x4E; s[7] = 0x29
  s[8] = 0x4F
  let out: *u8 = (sys_mmap(32)) as *u8
  let l: *nx_int = (sys_mmap(8)) as *nx_int
  let r: nx_int = parse_canonical(s, 9, out, 32, l)
  if r != 0 { return 11 }
  // canonical emit must contain '@' character (0x40)
  if buf_contains(out, l[0], 0x40) == 0 { return 12 }
  return 0
53}
54
55// =================================================================
56// B -- round-trip: parse -> canonical -> parse, check Atom.stereo preserved
57// =================================================================
58func b_atom_stereo_roundtrip() -> nx_int {
  let s: *u8 = sys_mmap(16)
  s[0] = 0x5B; s[1] = 0x43; s[2] = 0x40; s[3] = 0x48; s[4] = 0x5D
  s[5] = 0x28; s[6] = 0x4E; s[7] = 0x29
  s[8] = 0x4F
  let m1: *MolGraph = nx_chem_parse_smiles(s, 9)
  if m1.is_valid != 1 { return 21 }
  let a1: *Atom = nx_chem_mol_atom(m1, 0)
  let original_stereo: nx_int = a1.stereo
  if original_stereo != NX_STEREO_CCW { return 22 }
  let out: *u8 = (sys_mmap(32)) as *u8
  let l: *nx_int = (sys_mmap(8)) as *nx_int
  if nx_chem_emit_canonical_smiles(m1, out, 32, l) != 0 { return 23 }
  let m2: *MolGraph = nx_chem_parse_smiles(out, l[0])
  if m2.is_valid != 1 { return 24 }
  // Find the chiral atom in m2 (should also have stereo set)
  var i: nx_int = 0
  var found: nx_int = 0
  while i < m2.n_atoms {
      let a2: *Atom = nx_chem_mol_atom(m2, i)
      if a2.stereo != NX_STEREO_NONE { found = found + 1 }
      i = i + 1
  }
  if found != 1 { return 25 }
  return 0
83}
84
85// =================================================================
86// C -- @@ (CW) emit: "[C@@H](N)O"
87// =================================================================
88func c_atom_stereo_cw() -> nx_int {
  let s: *u8 = sys_mmap(16)
  // "[C@@H](N)O"
  s[0] = 0x5B; s[1] = 0x43; s[2] = 0x40; s[3] = 0x40; s[4] = 0x48; s[5] = 0x5D
  s[6] = 0x28; s[7] = 0x4E; s[8] = 0x29
  s[9] = 0x4F
  let m1: *MolGraph = nx_chem_parse_smiles(s, 10)
  if m1.is_valid != 1 { return 31 }
  let a1: *Atom = nx_chem_mol_atom(m1, 0)
  if a1.stereo != NX_STEREO_CW { return 32 }
  let out: *u8 = (sys_mmap(32)) as *u8
  let l: *nx_int = (sys_mmap(8)) as *nx_int
  if nx_chem_emit_canonical_smiles(m1, out, 32, l) != 0 { return 33 }
  // canonical emit must contain TWO consecutive '@' (for @@)
  var at_count: nx_int = 0
  var i: nx_int = 0
  while i < l[0] {
      if (out[i] & 0xff) == 0x40 { at_count = at_count + 1 }
      i = i + 1
  }
  if at_count != 2 { return 34 }
  return 0
110}
111
112// =================================================================
113// D -- bond stereo / emit: "F/C=C/F"
114// =================================================================
115func d_bond_stereo_up() -> nx_int {
  let s: *u8 = sys_mmap(16)
  // "F/C=C/F"
  s[0] = 0x46; s[1] = 0x2F; s[2] = 0x43; s[3] = 0x3D; s[4] = 0x43; s[5] = 0x2F; s[6] = 0x46
  let m1: *MolGraph = nx_chem_parse_smiles(s, 7)
  if m1.is_valid != 1 { return 41 }
  // Verify parsed bond stereo
  let b0: *Bond = nx_chem_mol_bond(m1, 0)
  if b0.stereo != NX_BSTEREO_UP { return 42 }
  let b2: *Bond = nx_chem_mol_bond(m1, 2)
  if b2.stereo != NX_BSTEREO_UP { return 43 }
  let out: *u8 = (sys_mmap(32)) as *u8
  let l: *nx_int = (sys_mmap(8)) as *nx_int
  if nx_chem_emit_canonical_smiles(m1, out, 32, l) != 0 { return 44 }
  // canonical emit must contain at least one '/' (0x2F)
  if buf_contains(out, l[0], 0x2F) == 0 { return 45 }
  return 0
132}
133
134// =================================================================
135// E -- bond stereo \ emit: "F/C=C\\F" (mixed up/down for cis/trans variation)
136// =================================================================
137func e_bond_stereo_down() -> nx_int {
  let s: *u8 = sys_mmap(16)
  s[0] = 0x46; s[1] = 0x2F; s[2] = 0x43; s[3] = 0x3D; s[4] = 0x43; s[5] = 0x5C; s[6] = 0x46
  let m1: *MolGraph = nx_chem_parse_smiles(s, 7)
  if m1.is_valid != 1 { return 51 }
  let b0: *Bond = nx_chem_mol_bond(m1, 0)
  if b0.stereo != NX_BSTEREO_UP { return 52 }
  let b2: *Bond = nx_chem_mol_bond(m1, 2)
  if b2.stereo != NX_BSTEREO_DOWN { return 53 }
  let out: *u8 = (sys_mmap(32)) as *u8
  let l: *nx_int = (sys_mmap(8)) as *nx_int
  if nx_chem_emit_canonical_smiles(m1, out, 32, l) != 0 { return 54 }
  // canonical emit must contain at least one '/' (0x2F) AND one '\' (0x5C)
  if buf_contains(out, l[0], 0x2F) == 0 { return 55 }
  if buf_contains(out, l[0], 0x5C) == 0 { return 56 }
  return 0
153}
154
155// =================================================================
156// F -- non-stereo molecules don't emit stereo markers
157// =================================================================
158func f_no_stereo_no_markers() -> nx_int {
  let s: *u8 = sys_mmap(16)
  // "CCO" -- no stereo
  s[0] = 0x43; s[1] = 0x43; s[2] = 0x4F
  let out: *u8 = (sys_mmap(32)) as *u8
  let l: *nx_int = (sys_mmap(8)) as *nx_int
  if parse_canonical(s, 3, out, 32, l) != 0 { return 61 }
  // canonical emit MUST NOT contain @ / or \
  if buf_contains(out, l[0], 0x40) == 1 { return 62 }
  if buf_contains(out, l[0], 0x2F) == 1 { return 63 }
  if buf_contains(out, l[0], 0x5C) == 1 { return 64 }
  return 0
170}
171
172// =================================================================
173// G -- bond stereo round-trip: F/C=C/F -> emit -> parse -> bonds with stereo preserved
174// =================================================================
175func g_bond_stereo_roundtrip() -> nx_int {
  let s: *u8 = sys_mmap(16)
  s[0] = 0x46; s[1] = 0x2F; s[2] = 0x43; s[3] = 0x3D; s[4] = 0x43; s[5] = 0x2F; s[6] = 0x46
  let m1: *MolGraph = nx_chem_parse_smiles(s, 7)
  if m1.is_valid != 1 { return 71 }
  let out: *u8 = (sys_mmap(32)) as *u8
  let l: *nx_int = (sys_mmap(8)) as *nx_int
  if nx_chem_emit_canonical_smiles(m1, out, 32, l) != 0 { return 72 }
  let m2: *MolGraph = nx_chem_parse_smiles(out, l[0])
  if m2.is_valid != 1 { return 73 }
  // Count bonds with stereo set in m2; should be 2 (matching m1's 2 stereo bonds)
  var with_stereo: nx_int = 0
  var i: nx_int = 0
  while i < m2.n_bonds {
      let b: *Bond = nx_chem_mol_bond(m2, i)
      if b.stereo != NX_BSTEREO_NONE { with_stereo = with_stereo + 1 }
      i = i + 1
  }
  if with_stereo != 2 { return 74 }
  return 0
195}
196
197// =================================================================
198// H -- C2.3e: bond-stereo parity flip when canonical DFS reverses
199// traversal direction. "Br/C=C/Cl" parses with Br as atom 0; Morgan
200// picks Cl as canonical root (lower atomic number). DFS reverses both
201// single bonds. Without parity flip, emit would produce wrong stereo.
202// With C2.3e flip: emit "Cl\C=C\Br" -- both backslashes, still trans,
203// same molecule.
204// Round-trip verifies the geometry is preserved: both stereo bonds in
205// the re-parsed molecule have the SAME stereo direction (both UP or
206// both DOWN), encoding trans.
207// =================================================================
208func h_bond_stereo_reverse_dfs() -> nx_int {
  let s: *u8 = sys_mmap(16)
  // "Br/C=C/Cl"
  s[0] = 0x42; s[1] = 0x72   // Br
  s[2] = 0x2F                // /
  s[3] = 0x43                // C
  s[4] = 0x3D                // =
  s[5] = 0x43                // C
  s[6] = 0x2F                // /
  s[7] = 0x43; s[8] = 0x6C   // Cl
  let m1: *MolGraph = nx_chem_parse_smiles(s, 9)
  if m1.is_valid != 1 { return 81 }
  // Both single bonds have stereo UP from parse
  let b0_in: *Bond = nx_chem_mol_bond(m1, 0)
  let b2_in: *Bond = nx_chem_mol_bond(m1, 2)
  if b0_in.stereo != NX_BSTEREO_UP { return 82 }
  if b2_in.stereo != NX_BSTEREO_UP { return 83 }
  // Canonical emit
  let out: *u8 = (sys_mmap(32)) as *u8
  let l: *nx_int = (sys_mmap(8)) as *nx_int
  if nx_chem_emit_canonical_smiles(m1, out, 32, l) != 0 { return 84 }
  // Re-parse canonical output
  let m2: *MolGraph = nx_chem_parse_smiles(out, l[0])
  if m2.is_valid != 1 { return 85 }
  // Verify trans preserved: both stereo bonds in m2 should have SAME stereo
  var stereo_a: nx_int = 0
  var stereo_b: nx_int = 0
  var count_stereo: nx_int = 0
  var i: nx_int = 0
  while i < m2.n_bonds {
      let b: *Bond = nx_chem_mol_bond(m2, i)
      if b.stereo != NX_BSTEREO_NONE {
          if count_stereo == 0 { stereo_a = b.stereo }
          if count_stereo == 1 { stereo_b = b.stereo }
          count_stereo = count_stereo + 1
      }
      i = i + 1
  }
  if count_stereo != 2 { return 86 }
  // Trans preserved iff both stereos are SAME (both UP or both DOWN)
  if stereo_a != stereo_b { return 87 }
  return 0
250}
251
252// =================================================================
253// I -- C2.3e: cis case "Br/C=C\Cl" round-trip preserves cis (DIFFERENT stereos)
254// =================================================================
255func i_bond_stereo_cis() -> nx_int {
  let s: *u8 = sys_mmap(16)
  // "Br/C=C\Cl"
  s[0] = 0x42; s[1] = 0x72   // Br
  s[2] = 0x2F                // /
  s[3] = 0x43                // C
  s[4] = 0x3D                // =
  s[5] = 0x43                // C
  s[6] = 0x5C                // \
  s[7] = 0x43; s[8] = 0x6C   // Cl
  let m1: *MolGraph = nx_chem_parse_smiles(s, 9)
  if m1.is_valid != 1 { return 91 }
  let b0_in: *Bond = nx_chem_mol_bond(m1, 0)
  let b2_in: *Bond = nx_chem_mol_bond(m1, 2)
  if b0_in.stereo != NX_BSTEREO_UP { return 92 }
  if b2_in.stereo != NX_BSTEREO_DOWN { return 93 }
  let out: *u8 = (sys_mmap(32)) as *u8
  let l: *nx_int = (sys_mmap(8)) as *nx_int
  if nx_chem_emit_canonical_smiles(m1, out, 32, l) != 0 { return 94 }
  let m2: *MolGraph = nx_chem_parse_smiles(out, l[0])
  if m2.is_valid != 1 { return 95 }
  var stereo_a: nx_int = 0
  var stereo_b: nx_int = 0
  var count_stereo: nx_int = 0
  var i: nx_int = 0
  while i < m2.n_bonds {
      let b: *Bond = nx_chem_mol_bond(m2, i)
      if b.stereo != NX_BSTEREO_NONE {
          if count_stereo == 0 { stereo_a = b.stereo }
          if count_stereo == 1 { stereo_b = b.stereo }
          count_stereo = count_stereo + 1
      }
      i = i + 1
  }
  if count_stereo != 2 { return 96 }
  // Cis preserved iff stereos are DIFFERENT (one UP, one DOWN)
  if stereo_a == stereo_b { return 97 }
  return 0
293}
294
295// =================================================================
296// J -- C2.3f: atom-stereo parity correction when canonical Morgan
297// reorders neighbors. "O[C@H](N)C" has stereo on atom 1 with input
298// neighbor order [O, H, N, C]. Morgan picks the terminal C (lowest
299// pack value) as root → DFS visits atom 1 from the OTHER end → emit
300// neighbor order becomes [C, H, N, O], which is an ODD permutation
301// of input → flip @ to @@. Canonical emit: "C[C@@H](N)O".
302// Round-trip fixed point: parse canonical → re-canonical produces
303// same string (no further changes since neighbor order now matches).
304// =================================================================
305func j_atom_stereo_parity_h_count() -> nx_int {
  let s: *u8 = sys_mmap(16)
  // "O[C@H](N)C"
  s[0] = 0x4F; s[1] = 0x5B; s[2] = 0x43; s[3] = 0x40; s[4] = 0x48; s[5] = 0x5D
  s[6] = 0x28; s[7] = 0x4E; s[8] = 0x29; s[9] = 0x43
  let m1: *MolGraph = nx_chem_parse_smiles(s, 10)
  if m1.is_valid != 1 { return 121 }
  // Verify input stereo at atom 1 is CCW (@)
  let a1: *Atom = nx_chem_mol_atom(m1, 1)
  if a1.stereo != NX_STEREO_CCW { return 122 }
  let out: *u8 = (sys_mmap(32)) as *u8
  let l: *nx_int = (sys_mmap(8)) as *nx_int
  if nx_chem_emit_canonical_smiles(m1, out, 32, l) != 0 { return 123 }
  // Canonical emit must contain "@@" (2 consecutive at-signs)
  // because parity flipped from CCW to CW
  var i: nx_int = 0
  var found_dbl: nx_int = 0
  while i < l[0] - 1 {
      if (out[i] & 0xff) == 0x40 {
          if (out[i + 1] & 0xff) == 0x40 { found_dbl = 1 }
      }
      i = i + 1
  }
  if found_dbl != 1 { return 124 }
  // Round-trip: parse canonical → re-canonical → same bytes (fixed point)
  let m2: *MolGraph = nx_chem_parse_smiles(out, l[0])
  if m2.is_valid != 1 { return 125 }
  let out2: *u8 = (sys_mmap(32)) as *u8
  let l2: *nx_int = (sys_mmap(8)) as *nx_int
  if nx_chem_emit_canonical_smiles(m2, out2, 32, l2) != 0 { return 126 }
  if buf_contains(out2, l2[0], 0x40) == 0 { return 127 }   // canonical still has @
  // Check byte-identical fixed point
  if l[0] != l2[0] { return 128 }
  var k: nx_int = 0
  while k < l[0] {
      if (out[k] & 0xff) != (out2[k] & 0xff) { return 129 }
      k = k + 1
  }
  return 0
344}
345
346// =================================================================
347// K -- C2.3f: explicit-H-count=0 chiral atom: "C[C@](Br)(Cl)F"
348// Atom 1 is chiral C with 4 explicit neighbors (C, Br, Cl, F), no H.
349// Morgan picks atom 0 (terminal C, lowest pack) as root. DFS visits
350// atom 1's tree children in rank order: F (lowest halogen pack) <
351// Cl < Br. Input neighbor order: [C, Br, Cl, F]; emit order:
352// [C, F, Cl, Br]. Permutation parity ODD → flip @ to @@.
353// =================================================================
354func k_atom_stereo_h0() -> nx_int {
  let s: *u8 = sys_mmap(32)
  // "C[C@](Br)(Cl)F"
  s[0]  = 0x43               // C
  s[1]  = 0x5B; s[2]  = 0x43; s[3] = 0x40; s[4] = 0x5D   // [C@]
  s[5]  = 0x28; s[6]  = 0x42; s[7] = 0x72; s[8] = 0x29   // (Br)
  s[9]  = 0x28; s[10] = 0x43; s[11]= 0x6C; s[12]= 0x29   // (Cl)
  s[13] = 0x46                                            // F
  let m1: *MolGraph = nx_chem_parse_smiles(s, 14)
  if m1.is_valid != 1 { return 131 }
  let a1: *Atom = nx_chem_mol_atom(m1, 1)
  if a1.stereo != NX_STEREO_CCW { return 132 }
  if a1.h_count != 0 { return 133 }   // bracket-explicit no H
  let out: *u8 = (sys_mmap(64)) as *u8
  let l: *nx_int = (sys_mmap(8)) as *nx_int
  if nx_chem_emit_canonical_smiles(m1, out, 64, l) != 0 { return 134 }
  // Canonical must contain "@@" (parity flip from CCW → CW)
  var i: nx_int = 0
  var found_dbl: nx_int = 0
  while i < l[0] - 1 {
      if (out[i] & 0xff) == 0x40 {
          if (out[i + 1] & 0xff) == 0x40 { found_dbl = 1 }
      }
      i = i + 1
  }
  if found_dbl != 1 { return 135 }
  // Round-trip fixed point
  let m2: *MolGraph = nx_chem_parse_smiles(out, l[0])
  if m2.is_valid != 1 { return 136 }
  let out2: *u8 = (sys_mmap(64)) as *u8
  let l2: *nx_int = (sys_mmap(8)) as *nx_int
  if nx_chem_emit_canonical_smiles(m2, out2, 64, l2) != 0 { return 137 }
  if l[0] != l2[0] { return 138 }
  var k: nx_int = 0
  while k < l[0] {
      if (out[k] & 0xff) != (out2[k] & 0xff) { return 139 }
      k = k + 1
  }
  return 0
393}
394
395func main() -> nx_exit {
  println("=== nx_chem_stereo -- C2.3d + C2.3e + C2.3f KAT: stereo emit + parity correction ===" as *u8)
397
  let ra: nx_int = a_atom_stereo_ccw()
  if ra != 0 { println("A atom_stereo_ccw FAIL" as *u8); return ra }
  println("A atom_stereo_ccw     PASS  [C@H](N)O -> canonical contains '@'" as *u8)
401
  let rb: nx_int = b_atom_stereo_roundtrip()
  if rb != 0 { println("B atom_stereo_roundtrip FAIL" as *u8); return rb }
  println("B atom_stereo_roundtrip PASS  parse -> canonical -> parse preserves Atom.stereo" as *u8)
405
  let rc: nx_int = c_atom_stereo_cw()
  if rc != 0 { println("C atom_stereo_cw FAIL" as *u8); return rc }
  println("C atom_stereo_cw      PASS  [C@@H](N)O -> canonical contains '@@' (two consecutive @)" as *u8)
409
  let rd: nx_int = d_bond_stereo_up()
  if rd != 0 { println("D bond_stereo_up FAIL" as *u8); return rd }
  println("D bond_stereo_up      PASS  F/C=C/F -> canonical contains '/' (bond stereo UP)" as *u8)
413
  let re: nx_int = e_bond_stereo_down()
  if re != 0 { println("E bond_stereo_down FAIL" as *u8); return re }
  println("E bond_stereo_down    PASS  F/C=C\\F -> canonical contains both '/' and '\\' (mixed bond stereo)" as *u8)
417
  let rf: nx_int = f_no_stereo_no_markers()
  if rf != 0 { println("F no_stereo_no_markers FAIL" as *u8); return rf }
  println("F no_stereo_no_markers PASS  CCO -> canonical contains NO @, /, or \\ markers" as *u8)
421
  let rg: nx_int = g_bond_stereo_roundtrip()
  if rg != 0 { println("G bond_stereo_roundtrip FAIL" as *u8); return rg }
  println("G bond_stereo_roundtrip PASS  F/C=C/F -> emit -> parse preserves 2 bonds with stereo" as *u8)
425
  let rh: nx_int = h_bond_stereo_reverse_dfs()
  if rh != 0 { println("H bond_stereo_reverse_dfs FAIL" as *u8); return rh }
  println("H bond_stereo_reverse_dfs PASS  Br/C=C/Cl -- Morgan picks Cl as root, DFS reverses bonds, parity-flip preserves trans" as *u8)
429
  let ri: nx_int = i_bond_stereo_cis()
  if ri != 0 { println("I bond_stereo_cis FAIL" as *u8); return ri }
  println("I bond_stereo_cis     PASS  Br/C=C\\Cl -- canonical-flipped cis geometry preserved (different stereos)" as *u8)
433
  let rj: nx_int = j_atom_stereo_parity_h_count()
  if rj != 0 { println("J atom_stereo_parity_h_count FAIL" as *u8); return rj }
  println("J atom_stereo_parity_h_count PASS  O[C@H](N)C -> Morgan picks C end -> parity flip @ to @@ -> canonical contains '@@' + fixed-point round-trip" as *u8)
437
  let rk: nx_int = k_atom_stereo_h0()
  if rk != 0 { println("K atom_stereo_h0 FAIL" as *u8); return rk }
  println("K atom_stereo_h0      PASS  C[C@](Br)(Cl)F -> Morgan reorders halogens -> parity flip @ to @@ -> round-trip fixed point" as *u8)
441
  println("" as *u8)
  println("=== C2.3d + C2.3e + C2.3f substrate milestones PASS ===" as *u8)
  println("  C2.3d stereo emit   : @/@@ for atom chirality (sp3 CCW/CW); / and \\ for bond stereo (sp2)" as *u8)
  println("  C2.3e bond parity   : DFS-reversed bonds flip UP <-> DOWN to preserve cis/trans semantics" as *u8)
  println("  C2.3f atom parity   : Morgan-canonical neighbor reordering computes permutation parity vs" as *u8)
  println("                        input order; flips @ <-> @@ when odd. Implicit-H handling via -2 sentinel." as *u8)
  println("  EXCEED axes hit     : E1 + E4 FULLY CLOSED (bit-reproducible canonical SMILES with stereo)" as *u8)
  println("  honest gaps         : atom-stereo for atoms in rings (back_count > 0) deferred to C2.3g" as *u8)
  println("                        atropisomer + enhanced-stereo (C2.4)" as *u8)
  println("                        cross-toolkit RDKit #8759 polyene corpus now FULLY RUNNABLE" as *u8)
  println("  next                : C2.4 -- atropisomer + enhanced-stereo (MDL stereo groups)" as *u8)
  return 0
454}
nx_chem_stereo_test.nx source

`nx_chem_stereo_test.nx` source
