rino 0.1.0 → 0.2.0

data/ext/src/util.h

@@ -2,8 +2,8 @@
  * International Union of Pure and Applied Chemistry (IUPAC)
  * International Chemical Identifier (InChI)
  * Version 1
- * Software version 1.00
- * April 13, 2005
+ * Software version 1.01
+ * July 21, 2006
  * Developed at NIST
  */
 
@@ -40,6 +40,9 @@ int my_fgetsTab1( char *szLine, int len, FILE *f, int *bTooLongLine );
 #endif
 int my_fgetsUpToLfOrTab( char *szLine, int len, FILE *f );
 
+#define ALPHA_BASE  27
+long inchi_strtol( const char *str, const char **p, int base);
+double inchi_strtod( const char *str, const char **p );
 
 AT_NUMB *is_in_the_list( AT_NUMB *pathAtom, AT_NUMB nNextAtom, int nPathLen );
 int get_periodic_table_number( const char* elname );
@@ -47,7 +50,8 @@ int is_el_a_metal( int nPeriodicNum );
 int get_el_valence( int nPeriodicNum, int charge, int val_num );
 int get_unusual_el_valence( int nPeriodicNum, int charge, int radical, int bonds_valence, int num_H, int num_bonds );
 int detect_unusual_el_valence( int nPeriodicNum, int charge, int radical, int bonds_valence, int num_H, int num_bonds );
-int needed_unusual_el_valence( int nPeriodicNum, int charge, int radical, int bonds_valence, int num_H, int num_bonds );
+int needed_unusual_el_valence( int nPeriodicNum, int charge, int radical, int bonds_valence,
+                               int actual_bonds_val, int num_H, int num_bonds );
 int get_el_type( int nPeriodicNum );
 int get_el_number( const char* elname );
 int do_not_add_H( int nPeriodicNum );
@@ -65,6 +69,13 @@ int nNoMetalNeighIndex( inp_ATOM *at, int at_no );
 int nNoMetalOtherNeighIndex( inp_ATOM *at, int at_no, int cur_neigh );
 int nNoMetalOtherNeighIndex2( inp_ATOM *at, int at_no, int cur_neigh, int cur_neigh2 );
 
+/* mol2atom.c */
+int nBondsValToMetal( inp_ATOM* at, int iat );
+
+/* ichi_bns.c */
+int nBondsValenceInpAt( const inp_ATOM *at, int *nNumAltBonds, int *nNumWrongBonds );
+
+int bHeteroAtomMayHaveXchgIsoH( inp_ATOM *atom, int iat );
 
 /* IChICan2.c */
 int SetBitFree( void );
@@ -73,6 +84,7 @@ void WriteCoord( char *str, double x );
 
 
 extern int ERR_ELEM;
+extern int nElDataLen;
 
 /* BILLY 8/6/04 */
 #ifndef INCHI_ALL_CPP

data/lib/rino.rb

@@ -32,7 +32,7 @@ $:.unshift File.join(File.dirname(__FILE__), "..", "ext")
 
 require 'tempfile'
 require 'clean_tempfile'
-require 'ruby_inchi_main'
+require 'libinchi'
 
 module Rino
   # Creates an InChI string from a molfile. This class coordinates the creation
@@ -55,7 +55,6 @@ module Rino
       @out = Tempfile.new("inchi_output.txt")
       @log = Tempfile.new("inchi_log.txt")
       @prob = Tempfile.new("inchi_problem.txt")
-      @main = Main.new
       @options = Array.new
     end
     
@@ -64,7 +63,7 @@ module Rino
     def read(molfile)
       write_input(molfile)
       
-      @main.run(create_argv)
+      InChI.run(create_argv)
       
       get_inchi
     end
@@ -108,4 +107,73 @@ module Rino
       result
     end
   end
+  
+  # Creates a molfile from an InChI identifier. Sets all atom coordinates
+  # to 0.0. This class coordinates the creation and deletion of temporary
+  # i/o files according to the rules used by Tempfile.
+  class InChIReader
+  
+    # Accepts the same options as the InChI command line
+    # software. See: http://wwmm.ch.cam.ac.uk/inchifaq/ and the
+    # InChI Technical Manual for an explanation of these options.
+    # Use with caution.
+    #
+    # Example:
+    # 
+    # reader = Rino::InChIReader.new
+    # 
+    # reader.options << "-SRel"
+    attr_reader :options
+    
+    def initialize
+      @in = CleanTempfile.new("inchi_input.txt")
+      @out = Tempfile.new("inchi_output.txt")
+      @log = Tempfile.new("inchi_log.txt")
+      @prob = Tempfile.new("inchi_problem.txt")
+      @options = ['-InChI2Struct']
+      @expand_inchi = '-InChI2Struct'
+      @inchi2SDF = '-OutputSDF'
+    end
+    
+    # Returns a molfile string corresponding to <tt>inchi</tt>.
+    def read(inchi)
+      output_sdf(expand(inchi))
+    end
+    
+    private
+  
+    def expand(inchi)
+      @in.open
+      @in << inchi
+      @in.close
+      
+      @options.delete(@inchi2SDF)
+      @options.insert(-1, @expand_inchi)
+      InChI.run(create_argv)
+
+      IO.read(@out.path)
+    end
+    
+    def output_sdf(full_inchi)
+      @in.open
+      @in << full_inchi
+      @in.close
+      @options.delete(@expand_inchi)
+      @options.insert(-1, @inchi2SDF)
+      
+      InChI.run(create_argv)
+      
+      IO.read(@out.path)
+    end
+    
+    def create_argv
+      result = ["", @in.path, @out.path, @log.path, @prob.path]
+      
+      @options.each do |x|
+        result << x
+      end
+      
+      result;
+    end
+  end
 end

data/test/test.rb

@@ -323,6 +323,7 @@ JME 2004.10 Sun Jun 04 14:52:53 EDT 2006
 M  END
 "
   @reader = Rino::MolfileReader.new
+  @inchi_reader = Rino::InChIReader.new
   end
 
   def test_benzene_inchi
@@ -337,11 +338,11 @@ M  END
     assert_equal("InChI=1/C8H10O/c1-7(9)8-5-3-2-4-6-8/h2-7,9H,1H3/t7-/m0/s1", inchi)
   end
 
-  def test_ferrocene_inchi
-    inchi = @reader.read(@ferrocene)
+#  def test_ferrocene_inchi
+#    inchi = @reader.read(@ferrocene)
 
-    assert_equal("InChI=1/2C5H5.2C5.2Fe/c4*1-2-4-5-3-1;;/h2*1-5H;;;;/q;;2*-1;;+2", inchi)
-  end
+#    assert_equal("InChI=1/2C5H5.2C5.2Fe/c4*1-2-4-5-3-1;;/h2*1-5H;;;;/q;;2*-1;;+2", inchi)
+#  end
 
   def test_c60_inchi
     inchi = @reader.read(@c60)
@@ -380,6 +381,34 @@ M  END
     inchi = @reader.read(@benzene)
     assert_equal("InChI=1/C6H6/c1-2-4-6-5-3-1/h1-6H", inchi)
   end
+  
+  def test_benzene_roundtrip
+    inchi_in = 'InChI=1/C6H6/c1-2-4-6-5-3-1/h1-6H'
+
+    assert_equal(inchi_in, round_trip_inchi(inchi_in))
+  end
+  
+  def test_c60_roundtrip
+    inchi_in = 'InChI=1/C60/c1-2-5-6-3(1)8-12-10-4(1)9-11-7(2)17-21-13(5)23-24-14(6)22-18(8)28-20(12)30-26-16(10)15(9)25-29-19(11)27(17)37-41-31(21)33(23)43-44-34(24)32(22)42-38(28)48-40(30)46-36(26)35(25)45-39(29)47(37)55-49(41)51(43)57-52(44)50(42)56(48)59-54(46)53(45)58(55)60(57)59'
+    
+    assert_equal(inchi_in, round_trip_inchi(inchi_in))
+  end
+  
+  #def test_taxol_roundtrip
+  #  inchi_in = 'InChI=1/C47H51NO14/c1-25-31(60-43(56)36(52)35(28-16-10-7-11-17-28)48-41(54)29-18-12-8-13-19-29)23-47(57)40(61-42(55)30-20-14-9-15-21-30)38-45(6,32(51)22-33-46(38,24-58-33)62-27(3)50)39(53)37(59-26(2)49)34(25)44(47,4)5/h7-21,31-33,35-38,40,51-52,57H,22-24H2,1-6H3,(H,48,54)/t31-,32-,33-,35-,36+,37+,38-,40-,45+,46-,47+/m0/s1'
+  #
+  #  assert_equal(inchi_in, round_trip_inchi(inchi_in))
+  #end
+  
+  private
+  
+  def round_trip_inchi(inchi_in)
+    @inchi_reader.options.clear
+    @reader.options.clear
+    molfile = @inchi_reader.read(inchi_in)
+    
+    @reader.read(molfile)
+  end
 end
 
 

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.0
 specification_version: 1
 name: rino
 version: !ruby/object:Gem::Version 
-  version: 0.1.0
-date: 2006-08-16 00:00:00 -07:00
+  version: 0.2.0
+date: 2006-09-18 00:00:00 -07:00
 summary: A Ruby wrapper for the C InChI toolkit
 require_paths: 
 - lib
@@ -36,20 +36,7 @@ files:
 - test/test.rb
 - ext/src/aux2atom.h
 - ext/src/comdef.h
-- ext/src/e_0dstereo.h
-- ext/src/e_comdef.h
-- ext/src/e_ctl_data.h
-- ext/src/e_ichicomp.h
-- ext/src/e_ichierr.h
-- ext/src/e_ichi_io.h
-- ext/src/e_ichi_parms.h
-- ext/src/e_ichisize.h
-- ext/src/e_inchi_atom.h
-- ext/src/e_inpdef.h
-- ext/src/e_mode.h
-- ext/src/e_readmol.h
-- ext/src/e_readstru.h
-- ext/src/e_util.h
+- ext/src/dispstru.h
 - ext/src/extr_ct.h
 - ext/src/ichi_bns.h
 - ext/src/ichicano.h
@@ -64,34 +51,26 @@ files:
 - ext/src/ichinorm.h
 - ext/src/ichiparm.h
 - ext/src/ichiring.h
+- ext/src/ichirvrs.h
 - ext/src/ichisize.h
 - ext/src/ichister.h
 - ext/src/ichitaut.h
 - ext/src/ichitime.h
-- ext/src/inchi_api.h
-- ext/src/inchi_dll.h
-- ext/src/inchi_dll_main.h
+- ext/src/inchicmp.h
 - ext/src/inpdef.h
 - ext/src/lreadmol.h
 - ext/src/mode.h
+- ext/src/mol2atom.h
+- ext/src/readmol.h
 - ext/src/strutil.h
 - ext/src/util.h
-- ext/src/e_0dstereo.c
-- ext/src/e_ichi_io.c
-- ext/src/e_ichimain.c
-- ext/src/e_ichi_parms.c
-- ext/src/e_inchi_atom.c
-- ext/src/e_mol2atom.c
-- ext/src/e_readinch.c
-- ext/src/e_readmol.c
-- ext/src/e_readstru.c
-- ext/src/e_util.c
+- ext/src/dispstru.c
 - ext/src/ichi_bns.c
 - ext/src/ichican2.c
 - ext/src/ichicano.c
 - ext/src/ichicans.c
 - ext/src/ichiisot.c
-- ext/src/ichilnct.c
+- ext/src/ichimain.c
 - ext/src/ichimak2.c
 - ext/src/ichimake.c
 - ext/src/ichimap1.c
@@ -103,17 +82,26 @@ files:
 - ext/src/ichiprt2.c
 - ext/src/ichiprt3.c
 - ext/src/ichiqueu.c
+- ext/src/ichiread.c
 - ext/src/ichiring.c
+- ext/src/ichirvr1.c
+- ext/src/ichirvr2.c
+- ext/src/ichirvr3.c
+- ext/src/ichirvr4.c
+- ext/src/ichirvr5.c
+- ext/src/ichirvr6.c
+- ext/src/ichirvr7.c
 - ext/src/ichisort.c
 - ext/src/ichister.c
 - ext/src/ichitaut.c
-- ext/src/inchi_dll.c
-- ext/src/inchi_dll_main.c
-- ext/src/ruby_inchi_main.c
+- ext/src/libinchi_wrap.c
+- ext/src/mol2atom.c
+- ext/src/readinch.c
+- ext/src/readmol.c
 - ext/src/runichi.c
 - ext/src/strutil.c
 - ext/src/util.c
-- ext/ruby_inchi_main.so
+- ext/libinchi.so
 test_files: []
 
 rdoc_options: []

data/ext/src/e_0dstereo.c

@@ -1,3014 +0,0 @@
-/*
- * International Union of Pure and Applied Chemistry (IUPAC)
- * International Chemical Identifier (InChI)
- * Version 1
- * Software version 1.00
- * April 13, 2005
- * Developed at NIST
- */
-
-/* this file is used only in case of #define CREATE_0D_PARITIES */
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <math.h>
-#include <string.h>
-#include <ctype.h>
-
-#include "e_mode.h"
-#include "inchi_api.h"
-#include "e_inchi_atom.h"
-#include "e_ichisize.h"
-#include "e_comdef.h"
-#include "e_ichicomp.h"
-#include "e_util.h"
-#include "e_0dstereo.h"
-
-#define ALWAYS_SET_STEREO_PARITY   0
-
-#define SB_PARITY_FLAG  0x38 /* disconnected structure has undef. parity */
-#define SB_PARITY_SHFT  3
-#define SB_PARITY_MASK  0x07
-#define SB_PARITY_1(X) (X & SB_PARITY_MASK)  /* refers to connected structure */
-#define SB_PARITY_2(X) (((X) >> SB_PARITY_SHFT) & SB_PARITY_MASK) /* refers to connected structure */
-
-#define inchi_NUMH(AT,CUR_AT)  (AT[CUR_AT].num_iso_H[0]+AT[CUR_AT].num_iso_H[1]+AT[CUR_AT].num_iso_H[2]+AT[CUR_AT].num_iso_H[3])
-#define inchi_NUMH2(AT,CUR_AT) ((AT[CUR_AT].num_iso_H[0]>0?AT[CUR_AT].num_iso_H[0]:0) +AT[CUR_AT].num_iso_H[1]+AT[CUR_AT].num_iso_H[2]+AT[CUR_AT].num_iso_H[3])
-#define IS_METAL(a) (a == AtType_Metal || a == AtType_Sn4 || a == AtType_Sn3 || a == AtType_Sn2)
-
-typedef struct tagStereo0D {
-    inchi_Stereo0D *stereo0D;         /* array of num_stereo0D 0D stereo elements or NULL */
-    int            num_stereo0D;      /* number of 0D stereo elements */
-    int            max_num_Stereo0D;  /* allocated length of stereo0D */
-    int            delta_num_stereo0D;/* allocation increments */ 
-    S_CHAR        *cAtType;
-} Stereo0D;
-
-typedef enum tagAtType {
-    /* possible stereocenter */
-    AtType_C4    = 1, /* >C< */
-    AtType_Si4   = 2, /* >Si< */
-    AtType_Ge4   = 3, /* >Ge< */
-    AtType_Sn4   = 4, /* >Sn< */
-    AtType_B4m   = 5, /* B(-) */
-    AtType_S4    = 6, /* =S< */
-    AtType_S6    = 7, /* >S<, 2 double bonds */
-    AtType_S3p   = 8, /* -S(+)< */
-    AtType_S5p   = 9, /* >S(+)<, 1 double bond */
-    AtType_Se4   =10, /* =Se< */
-    AtType_Se6   =11, /* >Se<, 2 double bonds */
-    AtType_Se3p  =12, /* -Se(+)< */
-    AtType_Se5p  =13, /* >Se(+)<, 1 double bond */
-    AtType_N5    =14, /* >N<, 1 double bond */
-    AtType_N4p   =15, /* >N(+)< */
-    AtType_N3r   =16, /* -N<|  (N in a 3-member ring) */
-    AtType_P4p   =17, /* >N(+)< */
-    AtType_P5    =18, /* >P<, 1 double bond */
-    AtType_As4p  =19, /* >As(+)< */
-    AtType_As5   =20, /* >As<, 1 double bond */
-    /* possible stereobond */
-    AtType_C3    =21, /* =C<, =C/ */
-    AtType_Si3   =22,
-    AtType_Ge3   =23,
-    AtType_Sn3   =24,
-    AtType_N3p   =25, /* =N(+)< */
-    AtType_N3    =26, /* =N/ */
-    /* middle allene/cumulene */
-    AtType_C2    =27, /* =C= */
-    AtType_Si2   =28, /* =Si= */
-    AtType_Ge2   =29, /* =Ge= */
-    AtType_Sn2   =30, /* =Ge= */
-    /* may become stereobond after charge or radical shift */
-    AtType_Nns   =31,
-    /* metal */
-    AtType_Metal =32,
-    /* terminal H */
-    AtType_TermH =33,
-    AtType_TermD =34,
-    AtType_TermT =35
-} AT_TYPE;
-
-typedef enum tagElType {
-    ElType_C  = 1,
-    ElType_Si = 2,
-    ElType_Ge = 3,
-    ElType_Sn = 4,
-    ElType_B  = 5,
-    ElType_S  = 6,
-    ElType_Se = 7,
-    ElType_N  = 8,
-    ElType_P  = 9,
-    ElType_As =10,
-    ElType_H  =11,
-    ElType_D  =12,
-    ElType_T  =13
-
-} EL_TYPE;
-
-inchi_Stereo0D *e_GetNewStereo( Stereo0D *pStereo );
-
-
-static int ee_extract_ChargeRadical( char *elname, int *pnRadical, int *pnCharge );
-static int ee_extract_H_atoms( char *elname, S_CHAR num_iso_H[] );
-static int e_GetElType( inchi_Atom *at, int cur_atom );
-static int e_bCanInpAtomBeAStereoCenter( int cur_at, S_CHAR *cAtType );
-static int e_nNumNonMetalNeigh( inchi_Atom *atom, int cur_at, Stereo0D *pStereo, int *i_ord_LastMetal );
-
-void e_swap ( char *a, char *b, size_t width );
-int e_insertions_sort( void *base, size_t num, size_t width, int ( *compare )(const void *e1, const void *e2 ) );
-int e_bCanAtomHaveAStereoBond( inchi_Atom *at, int cur_at, S_CHAR *cAtType );
-int e_bCanAtomBeMiddleAllene( int cur_at, S_CHAR *cAtType );
-int e_bCanAtomBeTerminalAllene( int cur_at, S_CHAR *cAtType );
-
-/**********************************************************************************/
-#define AMBIGUOUS_STEREO           1
-#define AMBIGUOUS_STEREO_ERROR     32
-
-
-#define AB_MAX_WELL_DEFINED_PARITY inchi_max(INCHI_PARITY_ODD, INCHI_PARITY_EVEN) /* 1, 2 => well defined parities, uncluding 'unknown' */
-#define AB_MIN_WELL_DEFINED_PARITY inchi_min(INCHI_PARITY_ODD, INCHI_PARITY_EVEN) /* min(INCHI_PARITY_ODD, INCHI_PARITY_EVEN) */
-
-#define AMBIGUOUS_STEREO           1
-
-#define MIN_DOT_PROD 50          /* min value of at->stereo_bond_z_prod[i] to define parity */
-
-#define ATOM_PARITY_WELL_DEF(X)     (AB_MIN_WELL_DEFINED_PARITY <= (X) && (X) <= AB_MAX_WELL_DEFINED_PARITY)
-/**********************************************************************************/
-
-#define CT_ERR_FIRST         (-30000)
-#define CT_OUT_OF_RAM        (CT_ERR_FIRST- 2)  /*(-30002) */
-#define CT_ISO_H_ERR         (CT_ERR_FIRST- 9)  /*(-30009) */
-#define CT_CALC_STEREO_ERR   (CT_ERR_FIRST-15)  /*(-30015) */
-#define CT_UNKNOWN_ERR       (CT_ERR_FIRST-18)  /*(-30018) */
-
-#define CT_ERR_MIN CT_UNKNOWN_ERR
-#define CT_ERR_MAX CT_ERR_FIRST
-
-#define RETURNED_ERROR(nVal) (CT_ERR_MIN<=(nVal) && (nVal)<=CT_ERR_MAX)
-/**********************************************************************************/
-#define MAX_CUMULENE_LEN   2     /* max number of bonds in a cumulene chain - 1 */
-/**********************************************************************************/
-int ee_extract_ChargeRadical( char *elname, int *pnRadical, int *pnCharge )
-{
-    char *q, *r, *p;
-    int  nCharge=0, nRad = 0, charge_len = 0, k, nVal, nSign, nLastSign=1, len;
-
-    p = elname;
-
-    /*  extract radicals & charges */
-    while ( q = strpbrk( p, "+-^" ) ) {
-        switch ( *q ) {
-        case '+':
-        case '-':
-            for ( k = 0, nVal=0; (nSign = ('+' == q[k])) || (nSign = -('-' == q[k])); k++ ) {
-                nVal += (nLastSign = nSign);
-                charge_len ++;
-            }
-            if ( nSign = (int)strtol( q+k, &r, 10 ) ) { /*  fixed 12-5-2001 */
-                nVal += nLastSign * (nSign-1);
-            }
-            charge_len = r - q;
-            nCharge += nVal;
-            break;
-        /* case '.': */ /*  singlet '.' may be confused with '.' in formulas like CaO.H2O */
-        case '^':
-            nRad = 1; /* doublet here is 1. See below */
-            charge_len = 1;
-            for ( k = 1; q[0] == q[k]; k++ ) {
-                nRad ++;
-                charge_len ++;
-            }
-            break;
-        }
-        memmove( q, q+charge_len, strlen(q+charge_len)+1 );
-    }
-    len = strlen(p);
-    /*  radical */
-    if ( (q = strrchr( p, ':' )) && !q[1]) {
-        nRad = RADICAL_SINGLET;
-        q[0] = '\0';
-        len --;
-    } else {
-        while( (q = strrchr( p, '.' )) && !q[1] ) {
-            nRad ++;
-            q[0] = '\0';
-            len --;
-        }
-
-        nRad = nRad == 1? RADICAL_DOUBLET :
-               nRad == 2? RADICAL_TRIPLET : 0;
-    }
-    *pnRadical = nRad;
-    *pnCharge  = nCharge;
-    return ( nRad || nCharge );
-
-}
-/***********************************************************************/
-int ee_extract_H_atoms( char *elname, S_CHAR num_iso_H[] )
-{
-    int i, len, c, k, val, bExtracted = 0;
-    char *q;
-    i = 0;
-    len = (int)strlen(elname);
-    c =  UCINT elname[0];
-    while ( i < len ) {
-        switch ( c ) {
-        case 'H':
-            k = 0;
-            break;
-        case 'D':
-            k = 2;
-            break;
-        case 'T':
-            k = 3;
-            break;
-        default:
-            k = -1;
-            break;
-        }
-        q = elname+i+1; /*  pointer to the next to elname[i] character */
-        c = UCINT q[0];
-        if ( k >= 0 && !islower( c ) ) {
-            /*  found a hydrogen */
-            bExtracted ++;
-            if ( isdigit( c ) ) {
-                val = (int)strtol( q, &q, 10 );
-                /*  q = pointer to the next to number of hydrogen atom(s) character */
-            } else {
-                val = 1;
-            }
-            num_iso_H[k] += val;
-            /*  remove the hydrogen atom from the string */
-            len -= (q-elname)-i;
-            memmove( elname+i, q, len + 1 );
-            /*  c =  UCINT elname[i]; */
-        } else {
-            i ++;
-        }
-        c =  UCINT elname[i]; /*  moved here 11-04-2002 */
-    }
-    return bExtracted;
-}
-/************************************************/
-#define MAX_BOND_TYPE 4
-int e_GetElType( inchi_Atom *at, int cur_atom )
-{
-    char szEl[ATOM_EL_LEN];
-    int  nRadical, nCharge, bChargeOrRad, bH, bAddH = 0, nElType=0, bond_valence, valence, num_H=0;
-    S_CHAR num_iso_H[NUM_H_ISOTOPES+1];
-    S_CHAR num_bonds[MAX_BOND_TYPE];
-    int  i;
-    int  nRadicalValence = 0;
-
-    if ( sizeof(at->num_iso_H)    != sizeof(num_iso_H) ||
-         sizeof(at->num_iso_H[0]) != sizeof(num_iso_H[0]) ) {
-        /* program error */
-        return -1;
-    }
-    strcpy( szEl, at[cur_atom].elname);
-    memset( num_iso_H, 0, sizeof(num_iso_H) );
-    bChargeOrRad  = ee_extract_ChargeRadical( szEl, &nRadical, &nCharge );
-    bH            = ee_extract_H_atoms( szEl, num_iso_H );
-    if ( !bChargeOrRad ) {
-        nRadical = at[cur_atom].radical;
-        nCharge  = at[cur_atom].charge;
-    }
-    if ( !bH ) {
-        memcpy( num_iso_H, at[cur_atom].num_iso_H, sizeof(num_iso_H) );
-        if ( bAddH = (num_iso_H[0] < 0 ) ) {
-            num_iso_H[0] = 0;
-        }
-    }
-    num_H = num_iso_H[0]+num_iso_H[1]+num_iso_H[2]+num_iso_H[3];
-
-    if (nRadical==INCHI_RADICAL_DOUBLET) {
-        nRadicalValence = 1;
-    } else
-    if ( nRadical==INCHI_RADICAL_TRIPLET || nRadical==INCHI_RADICAL_SINGLET ){
-        nRadicalValence = 2;
-    }
-    
-    /* element type */
-    if ( !strcmp( szEl, "C" ) ) {
-        nElType = ElType_C;
-    } else
-    if ( !strcmp( szEl, "Si" ) ) {
-        nElType = ElType_Si;
-    } else
-    if ( !strcmp( szEl, "Ge" ) ) {
-        nElType = ElType_Ge;
-    } else
-    if ( !strcmp( szEl, "Sn" ) ) {
-        nElType = ElType_Sn;
-    } else
-    if ( !strcmp( szEl, "B" ) ) {
-        nElType = ElType_B;
-    } else
-    if ( !strcmp( szEl, "S" ) ) {
-        nElType = ElType_S;
-    } else
-    if ( !strcmp( szEl, "Se" ) ) {
-        nElType = ElType_Se;
-    } else
-    if ( !strcmp( szEl, "N" ) ) {
-        nElType = ElType_N;
-    } else
-    if ( !strcmp( szEl, "P" ) ) {
-        nElType = ElType_P;
-    } else
-    if ( !strcmp( szEl, "As" ) ) {
-        nElType = ElType_As;
-    } else
-    if ( !szEl[0] ) {
-        if ( 1 == num_H && (num_iso_H[0] == 1 || num_iso_H[1] == 1) ) {
-            nElType = ElType_H;
-        } else
-        if ( 1 == num_H && num_iso_H[2] == 1 ) {
-            nElType = ElType_D;
-        } else
-        if ( 1 == num_H && num_iso_H[3] == 1 ) {
-            nElType = ElType_T;
-        } else {
-            return -1;
-        }
-    } else {
-        if ( e_is_element_a_metal( szEl ) ) {
-            return AtType_Metal;
-        }
-        return -1; /* no stereo */
-    }
-
-    /* atom type */
-    memset( num_bonds, 0, sizeof(num_bonds) );
-    bond_valence = 0;
-    valence      = at[cur_atom].num_bonds;
-    for ( i = 0; i < valence; i ++ ) {
-        if ( 0 < at[cur_atom].bond_type[i] && at[cur_atom].bond_type[i] <= MAX_BOND_TYPE ) {
-            num_bonds[at[cur_atom].bond_type[i]-1] ++;
-        }
-    }
-    bond_valence = num_bonds[0] + 2*num_bonds[1] + 3*num_bonds[2];
-    if ( num_bonds[3] ) {
-        if ( num_bonds[3] == 2 ) {
-            bond_valence += 3; /* -C= */
-        } else
-        if ( num_bonds[3] == 3 ) {
-            bond_valence += 4; /* >C= */
-        } else {
-            return -1;
-        }
-    }
-    
-    switch( nElType ) {
-    
-    case ElType_C:
-    case ElType_Si:
-    case ElType_Ge:
-    case ElType_Sn:
-
-        if ( bAddH && bond_valence + num_H + (abs(nCharge)==1) + nRadicalValence == 4 ) {
-            bAddH = 0; /* no H will be added */
-        }
-    
-        if ( bond_valence == valence && (valence==4 || valence == 3 && (bAddH || num_H==1)) && !nRadical ) {
-            switch( nElType ) {
-            case ElType_C:
-                return AtType_C4;
-            case ElType_Si:
-                return AtType_Si4;
-            case ElType_Ge:
-                return AtType_Ge4;
-            case ElType_Sn:
-                return AtType_Sn4;
-            }
-        } else
-        if ( bond_valence == valence && (valence==3 || valence == 2 && (bAddH || num_H==1)) && nRadical == INCHI_RADICAL_DOUBLET ) {
-            switch( nElType ) {
-            case ElType_C:
-                return AtType_C3;
-            case ElType_Si:
-                return -1;
-            case ElType_Ge:
-                return -1;
-            case ElType_Sn:
-                return AtType_Metal;
-            }
-        } else
-        if ( bond_valence == 4 && valence == 2 && !num_H  && !nRadical ) {
-            /* two double bonds or single & triple */
-            switch( nElType ) {
-            case ElType_C:
-                return AtType_C2;
-            case ElType_Si:
-                return AtType_Si2;
-            case ElType_Ge:
-                return AtType_Ge2;
-            case ElType_Sn:
-                return AtType_Sn2;
-            }
-        } else
-        if ( bond_valence == 3 && valence == 2 && !num_H && nRadical == INCHI_RADICAL_DOUBLET ) {
-            /* two double bonds or single & triple */
-            switch( nElType ) {
-            case ElType_C:
-                return AtType_C2;
-            case ElType_Si:
-                return -1;
-            case ElType_Ge:
-                return -1;
-            case ElType_Sn:
-                return AtType_Metal;
-            }
-        } else
-        if ( bond_valence > valence && (valence==3 || valence == 2 && (bAddH || num_H==1)) && !nRadical ) {
-            /* "bond_valence > valence" instead of "bond_valence == valence+1" to accommodate
-             *  erroneouse acceptance by 1.12Beta of stereo bond case when C has valence > 5 */
-            switch( nElType ) {
-            case ElType_C:
-                return AtType_C3;
-            case ElType_Si:
-                return AtType_Si3;
-            case ElType_Ge:
-                return AtType_Ge3;
-            case ElType_Sn:
-                return AtType_Sn3;
-            }
-        } else
-        if ( bond_valence == valence+1 && bond_valence > 3 ) {
-            /* trying to accommodate hypervalence in coord compounds before disconnection */
-            switch( nElType ) {
-            case ElType_C:
-                return AtType_C3;
-            case ElType_Si:
-                return -1;
-            case ElType_Ge:
-                return -1;
-            case ElType_Sn:
-                return AtType_Metal;
-            }
-        } else
-        if ( bond_valence == valence && bond_valence >= 2 && abs(nCharge) == 1 && 3 == (valence + (bAddH || num_H==1)) ) {
-            /* trying to accommodate C(-)-N(+) bond that may become double after ion pair removal. added 2004-01-31 */
-            switch( nElType ) {
-            case ElType_C:
-                return AtType_C3;
-            case ElType_Si:
-                return AtType_Si3;
-            case ElType_Ge:
-                return -1;
-            case ElType_Sn:
-                return AtType_Metal;
-            }
-        }
-        return (nElType == ElType_Sn)? AtType_Metal : -1;
-
-    case ElType_B:
-        if ( bond_valence == valence && (valence==4 || valence==3 && (bAddH || num_H==1)) && nCharge == -1 && !nRadical ) {
-            return AtType_B4m;
-        }
-        return -1;
-
-    case ElType_S:
-    case ElType_Se:
-        if ( (valence == 3 && bond_valence == 3) && (nCharge == 1 || nRadical == INCHI_RADICAL_DOUBLET) ) {
-            switch( nElType ) {
-            case ElType_S:
-                return AtType_S3p;
-            case ElType_Se:
-                return AtType_Se3p;
-            }
-        } else
-        if ( (valence == 3 && bond_valence == 4) && nCharge == 0 && !nRadical ) {
-            switch( nElType ) {
-            case ElType_S:
-                return AtType_S4;
-            case ElType_Se:
-                return AtType_Se4;
-            }
-        } else
-        if ( (valence == 4 && bond_valence == 5) && (nCharge == 1 || nRadical == INCHI_RADICAL_DOUBLET) ) {
-            switch( nElType ) {
-            case ElType_S:
-                return AtType_S5p;
-            case ElType_Se:
-                return AtType_Se5p;
-            }
-        } else
-        if ( (valence == 4 && bond_valence == 6) && nCharge == 0 && !nRadical ) {
-            switch( nElType ) {
-            case ElType_S:
-                return AtType_S6;
-            case ElType_Se:
-                return AtType_S6;
-            }
-        } else {
-            return -1;
-        }
-    case ElType_N:
-    case ElType_P:
-    case ElType_As:
-        if ( bAddH && bond_valence + num_H - (abs(nCharge)==1? nCharge:0) + nRadicalValence == 3 ) {
-            bAddH = 0; /* no H will be added */
-        } else
-        if ( bAddH && bond_valence + num_H == 5 ) {
-            bAddH = 0; /* no H will be added */
-        }
-        if ( bond_valence == valence && (valence==4 || valence==3 && (bAddH || num_H==1)) && nCharge == 1 && !nRadical ) {
-            switch( nElType ) {
-            case ElType_N:
-                return AtType_N4p;
-            case ElType_P:
-                return AtType_P4p;
-            case ElType_As:
-                return AtType_As4p;
-            }
-        } else
-        if ( bond_valence == valence+1 && (valence==4 /*|| valence == 3*/) && nCharge == 0 ) {
-            switch( nElType ) {
-            case ElType_N:
-                return AtType_N5;
-            case ElType_P:
-                return AtType_P5;
-            case ElType_As:
-                return AtType_As5;
-            }
-        } else
-        if ( bond_valence == valence && valence==3 && nCharge == 0 && !nRadical ) {
-            switch( nElType ) {
-            case ElType_N:
-            { 
-                AT_NUM neigh1, neigh2;
-                int    j1, j2, bIn3MembRing = 0;
-                for ( j1 = 0; j1 < valence && !bIn3MembRing; j1 ++ ) {
-                    neigh1 = at[cur_atom].neighbor[j1];
-                    for ( j2 = j1+1; j2 < valence && !bIn3MembRing; j2 ++ ) {
-                        neigh2 = at[cur_atom].neighbor[j2];
-                        if ( e_is_in_the_slist( at[neigh1].neighbor, neigh2, at[neigh1].num_bonds ) ) {
-                            bIn3MembRing ++;
-                        }
-                    }
-                }
-                return bIn3MembRing? AtType_N3r : AtType_Nns /* -1*/;
-            }
-            case ElType_P:
-            case ElType_As:
-                return -1;
-            }
-        } else
-        if ( bond_valence == valence+1 && valence==2 && nCharge == 0 && !nRadical ) {
-            switch( nElType ) {
-            case ElType_N:
-                return AtType_N3;
-            case ElType_P:
-            case ElType_As:
-                return -1;
-            }
-        } else
-        if ( bond_valence == valence+1 && valence==3 && nCharge == 0 && !nRadical ) {
-            /* reproduce 1.12Beta bug: =N< is accepted in stereogenic bonds */
-            switch( nElType ) {
-            case ElType_N:
-                return AtType_N3;
-            case ElType_P:
-            case ElType_As:
-                return -1;
-            }
-        } else
-        if ( bond_valence == valence && valence==2 && nCharge == 0 && nRadical == INCHI_RADICAL_DOUBLET ) {
-            switch( nElType ) {
-            case ElType_N:
-                return AtType_N3;
-            case ElType_P:
-            case ElType_As:
-                return -1;
-            }
-        } else
-        if ( bond_valence == valence+1 && (valence==3 || valence == 2 && (bAddH || num_H==1)) && nCharge == 1 ) {
-            switch( nElType ) {
-            case ElType_N:
-                return AtType_N3p;
-            case ElType_P:
-            case ElType_As:
-                return -1;
-            }
-        } else
-        if ( bond_valence == valence && (valence==3 || valence == 2 && (bAddH || num_H==1)) && nCharge == 1 && nRadical == INCHI_RADICAL_DOUBLET ) {
-            switch( nElType ) {
-            case ElType_N:
-                return AtType_N3p;
-            case ElType_P:
-            case ElType_As:
-                return -1;
-            }
-        } else
-        if ( bond_valence == valence && valence == 2 && (bAddH || num_H==1) && nCharge == 0 ||
-             bond_valence == valence && valence == 2 && nCharge == -1 ) {
-            switch( nElType ) {
-            case ElType_N:
-                return AtType_Nns;
-            case ElType_P:
-            case ElType_As:
-                return -1;
-            }
-        } else
-        if ( (bond_valence == valence+2 || bond_valence + nRadicalValence == valence+2) && valence==3 ) {
-            switch( nElType ) {
-            case ElType_N:
-                return AtType_Nns; /* -N<< may be in a stereogenic bond in case of double bond metal disconnection */
-            case ElType_P:
-            case ElType_As:
-                return -1;
-            }
-        }
-        return -1;
-
-        case ElType_H:
-            if ( valence == 1 )
-                return AtType_TermH;
-            break;
-        case ElType_D:
-            if ( valence == 1 )
-                return AtType_TermD;
-            break;
-        case ElType_T:
-            if ( valence == 1 )
-                return AtType_TermT;
-            break;
-
-    }
-
-    return -1;
-}
-
-
-/**********************************************************************************/
-void e_swap ( char *a, char *b, size_t width )
-{
-    char tmp;
-    if ( a != b )
-        while ( width-- ) {
-            tmp = *a;
-            *a++ = *b;
-            *b++ = tmp;
-        }
-}
-/**********************************************************************************/
-/*  Sort by insertions */
-int e_insertions_sort( void *base, size_t num, size_t width, int ( *compare )(const void *e1, const void *e2 ) )
-{
-  char *i, *j, *pk;
-  int  num_trans = 0;
-  size_t k;
-  for( k=1, pk = (char*)base; k < num; k++, pk += width ) {
-     for( i = pk, j = pk + width; j > (char*)base && (*compare)(i,j) > 0; j=i, i -= width ) {
-        e_swap( i, j, width );
-        num_trans ++;
-     }
-  }
-  return num_trans;
-}
-
-
-#define    ZTYPE_DOWN     (-1)  /*  should be equal to -ZTYPE_UP */
-#define    ZTYPE_NONE     0
-#define    ZTYPE_UP       1     /*  should be equal to -ZTYPE_DOWN */
-#define    ZTYPE_3D       3
-#define    ZTYPE_EITHER   9999
-
-/*  criteria for ill-defined */
-#define MIN_ANGLE             0.10   /*  5.73 degrees */
-#define MIN_SINE              0.03   /*  min edge/plane angle in case the tetrahedra has significantly different edge length */
-#define MIN_ANGLE_DBOND       0.087156 /* 5 degrees = max angle considered as too small for unambiguous double bond stereo */
-#define MIN_SINE_OUTSIDE      0.06   /*  min edge/plane angle to determine whether the central atom is outside of the tetrahedra */
-#define MIN_SINE_SQUARE       0.125  /*  min edge/plane angle in case the tetrahedra is somewhat close to a parallelogram */
-#define MIN_SINE_EDGE         0.167  /*  min sine/(min.edge) ratio to avoid undefined in case of long edges */
-#define MIN_LEN_STRAIGHT      1.900  /*  min length of two normalized to 1 bonds in a straight line */
-#define MAX_SINE              0.70710678118654752440084436210485 /*  1/sqrt(2)=sin(pi/4) */
-#define MIN_BOND_LEN          0.000001
-#define ZERO_LENGTH           MIN_BOND_LEN
-#define ZERO_FLOAT            1.0e-12
-#define BOND_PARITY_UNDEFINED 64
-#if( STEREO_CENTER_BONDS_NORM == 1 )
-#define MPY_SINE              1.00  /*  was 3.0 */
-#define MAX_EDGE_RATIO        2.50   /*  max max/min edge ratio for a tetrahedra close to a parallelogram  */
-#else
-#define MPY_SINE              3.00
-#define MAX_EDGE_RATIO        6.00   /*  max max/min edge ratio for a tetrahedra close to a parallelogram  */
-#endif
-/*  local prototypes */
-static double e_get_z_coord( inchi_Atom* at, int cur_atom, int neigh_no,  int *nType,int bPointedEdgeStereo );
-static double e_len3( const double c[] );
-static double e_len2( const double c[] );
-static double* e_diff3( const double a[], const double b[], double result[] );
-static double* e_add3( const double a[], const double b[], double result[] );
-static double* e_mult3( const double a[], double b, double result[] );
-static double* e_copy3( const double a[], double result[] );
-static double* e_change_sign3( const double a[], double result[] );
-static double e_dot_prod3( const double a[], const double b[] );
-static int e_dot_prodchar3( const S_CHAR a[], const S_CHAR b[] );
-static double* e_cross_prod3( const double a[], const double b[], double result[] );
-static double e_triple_prod( double a[], double b[], double c[], double *sine_value );
-static double e_triple_prod_and_min_abs_sine(double at_coord[][3], double *min_sine);
-static int are_3_vect_in_one_plane( double at_coord[][3], double min_sine);
-static int e_triple_prod_char( inchi_Atom *at, int at_1, int i_next_at_1, S_CHAR *z_dir1,
-                                    int at_2, int i_next_at_2, S_CHAR *z_dir2 );
-
-static int e_CompDble( const void *a1, const void *a2 );
-static int e_Get2DTetrahedralAmbiguity( double at_coord[][3], int bAddExplicitNeighbor );
-static double e_triple_prod_and_min_abs_sine2(double at_coord[][3], double central_at_coord[], int bAddedExplicitNeighbor, double *min_sine, int *bAmbiguous);
-static int e_are_4at_in_one_plane( double at_coord[][3], double min_sine);
-static int e_half_stereo_bond_parity( inchi_Atom *at, int cur_at, S_CHAR *z_dir, int *bOnlyNonMetal, int bPointedEdgeStereo, Stereo0D *pStereo );
-static int e_set_stereo_bonds_parity( Stereo0D *pStereo, inchi_Atom *at, int at_1, int bPointedEdgeStereo );
-static int e_set_stereo_atom_parity( Stereo0D *pStereo, inchi_Atom *at, int cur_at, int bPointedEdgeStereo );
-static int e_FixSb0DParities( inchi_Atom *at, Stereo0D *pStereo, int chain_length, AT_NUM at_middle,
-                     int at_1, int i_next_at_1, S_CHAR z_dir1[], S_CHAR z_dir1NM[], int bOnlyNM1, int bAnomaly1NM, int parity1, int parity1NM,
-                     int at_2, int i_next_at_2, S_CHAR z_dir2[], S_CHAR z_dir2NM[], int bOnlyNM2, int bAnomaly2NM, int parity2, int parity2NM );
-
-
-/******************************************************************/
-
-
-static double         *pDoubleForSort;
-
-/**********************************************************************************/
-double e_get_z_coord( inchi_Atom* at, int cur_atom, int neigh_no,  int *nType, int bPointedEdgeStereo )
-{
-    int stereo_value = at[cur_atom].bond_stereo[neigh_no];
-    int stereo_type  = abs( stereo_value );
-    int neigh        = (int)at[cur_atom].neighbor[neigh_no];
-    double z         = at[neigh].z - at[cur_atom].z;
-    int    bFlat;
-
-    if ( bFlat = (fabs(z) < ZERO_LENGTH) ) {
-        int i;
-        for ( i = 0; i < at[cur_atom].num_bonds; i ++ ) {
-            if ( fabs(at[cur_atom].z - at[(int)at[cur_atom].neighbor[i]].z) > ZERO_LENGTH ) {
-                bFlat = 0;
-                break;
-            }
-        }
-    }
-
-    if ( bFlat ) {
-        if ( !bPointedEdgeStereo || bPointedEdgeStereo * stereo_value >= 0 ) {
-            /* bPointedEdgeStereo > 0: define stereo from pointed end of the stereo bond only */
-            /* bPointedEdgeStereo < 0: define stereo from wide end of the stereo bond only (case of removed H) */
-            switch( stereo_type ) {
-                /*  1=Up (solid triangle), 6=Down (Dashed triangle), 4=Either (zigzag triangle) */
-            case 0: /*  No stereo */
-                *nType = ZTYPE_NONE;
-                break;
-            case INCHI_BOND_STEREO_SINGLE_1UP: /*  1= Up */
-                *nType = ZTYPE_UP;
-                break;
-            case INCHI_BOND_STEREO_SINGLE_1EITHER: /*  4 = Either */
-                *nType = ZTYPE_EITHER;
-                break;
-            case INCHI_BOND_STEREO_SINGLE_1DOWN: /*  6 = Down */
-                *nType = ZTYPE_DOWN;
-                break;
-            default:
-                *nType = ZTYPE_NONE; /*  ignore unexpected values */
-            }
-            if ( stereo_value < 0 && (*nType == ZTYPE_DOWN || *nType == ZTYPE_UP) )
-                *nType = -*nType;
-        } else {
-            *nType = ZTYPE_NONE; /* no stereo */
-        }
-    } else
-    if ( stereo_type == INCHI_BOND_STEREO_SINGLE_1EITHER &&
-         ( !bPointedEdgeStereo || bPointedEdgeStereo * stereo_value >= 0 ) ) {
-        *nType = ZTYPE_EITHER; 
-    } else {
-        *nType = ZTYPE_3D;
-    }
-    return z;
-}
-/******************************************************************/
-double e_len3( const double c[] )
-{
-    return sqrt( c[0]*c[0]   + c[1]*c[1]   + c[2]*c[2] );
-}
-/******************************************************************/
-double e_len2( const double c[] )
-{
-    return sqrt( c[0]*c[0]   + c[1]*c[1] );
-}
-/******************************************************************/
-double* e_diff3( const double a[], const double b[], double result[] )
-{
-
-    result[0] =  a[0] - b[0];
-    result[1] =  a[1] - b[1];
-    result[2] =  a[2] - b[2];
-
-    return result;
-}
-/******************************************************************/
-double* e_add3( const double a[], const double b[], double result[] )
-{
-    result[0] =  a[0] + b[0];
-    result[1] =  a[1] + b[1];
-    result[2] =  a[2] + b[2];
-
-    return result;
-}
-/******************************************************************/
-double* e_mult3( const double a[], double b, double result[] )
-{
-    result[0] = a[0] * b;
-    result[1] = a[1] * b;
-    result[2] = a[2] * b;
-
-    return result;
-}
-/*************************************************************/
-double* e_copy3( const double a[], double result[] )
-{
-    result[0] = a[0];
-    result[1] = a[1];
-    result[2] = a[2];
-
-    return result;
-}
-/*************************************************************/
-double* e_change_sign3( const double a[], double result[] )
-{
-    result[0] = -a[0];
-    result[1] = -a[1];
-    result[2] = -a[2];
-
-    return result;
-}
-/*************************************************************/
-double e_dot_prod3( const double a[], const double b[] )
-{
-    return a[0]*b[0] + a[1]*b[1] + a[2]*b[2];
-}
-/*************************************************************/
-int e_dot_prodchar3( const S_CHAR a[], const S_CHAR b[] )
-{
-    int prod = ((int)a[0]*(int)b[0] + (int)a[1]*(int)b[1] + (int)a[2]*(int)b[2])/100;
-    if ( prod > 100 )
-        prod = 100;
-    else
-    if ( prod < -100 )
-        prod = -100;
-    return prod;
-}
-/*************************************************************/
-double* e_cross_prod3( const double a[], const double b[], double result[] )
-{
-    double tmp[3];
-    
-    tmp[0] =  (a[1]*b[2]-a[2]*b[1]);
-    tmp[1] = -(a[0]*b[2]-a[2]*b[0]);
-    tmp[2] =  (a[0]*b[1]-a[1]*b[0]);
-
-    result[0] = tmp[0];
-    result[1] = tmp[1];
-    result[2] = tmp[2];
-
-    return result;
-}
-/*************************************************************/
-double e_triple_prod( double a[], double b[], double c[], double *sine_value )
-{
-    double ab[3], dot_prod_ab_c, abs_c, abs_ab;
-    e_cross_prod3( a, b, ab );
-    /* ab[0] =  (a[1]*b[2]-a[2]*b[1]); */
-    /* ab[1] = -(a[0]*b[2]-a[2]*b[0]); */
-    /* ab[2] =  (a[0]*b[1]-a[1]*b[0]); */
-    dot_prod_ab_c   =  e_dot_prod3( ab, c );
-    /* dot_prod_ab_c   =  ab[0]*c[0] + ab[1]*c[1] + ab[2]*c[2]; */
-    if ( sine_value ) {
-        abs_c  = e_len3( c );
-        /* abs_c  = sqrt( c[0]*c[0]   + c[1]*c[1]   + c[2]*c[2] ); */
-        abs_ab = e_len3( ab );
-        /* abs_ab = sqrt( ab[0]*ab[0] + ab[1]*ab[1] + ab[2]*ab[2] ); */
-
-        if ( abs_c > 1.e-7 /* otherwise c has zero length */ && abs_ab > 1.e-7 /* otherwise a is parallel to b*/ ) {
-            *sine_value = MPY_SINE * dot_prod_ab_c / ( abs_c * abs_ab);
-            /*  *sine_value = dot_prod_ab_c / ( abs_c * abs_ab); */
-        } else {
-            *sine_value = 0.0;
-        }
-    }
-    return dot_prod_ab_c;
-}
-/*************************************************************/
-int e_CompDble( const void *a1, const void *a2 )
-{
-    double diff = pDoubleForSort[*(const int*)a1] - pDoubleForSort[*(const int*)a2];
-    if ( diff > 0.0 )
-        return 1;
-    if ( diff < 0.0 )
-        return -1;
-    return 0;
-}
-/*************************************************************/
-#define T2D_OKAY  1
-#define T2D_WARN  2
-#define T2D_UNDF  4
-int e_Get2DTetrahedralAmbiguity( double at_coord[][3], int bAddExplicitNeighbor )
-{
-    const double one_pi = 2.0*atan2(1.0 /* y */, 0.0 /* x */);
-    const double two_pi = 2.0*one_pi;
-    const double dAngleAndPiMaxDiff = 2.0*atan2(1.0, sqrt(7.0)); /*  min sine between 2 InPlane bonds */
-    int    nBondType[MAX_NUM_STEREO_ATOM_NEIGH], nBondOrder[MAX_NUM_STEREO_ATOM_NEIGH];
-    double dBondDirection[MAX_NUM_STEREO_ATOM_NEIGH], dAngle, dAlpha, dLimit, dBisector;
-    int  nNumNeigh = MAX_NUM_STEREO_ATOM_NEIGH - (bAddExplicitNeighbor != 0);
-    int  i, num_Up, num_Dn, bPrev_Up, cur_len_Up, cur_first_Up, len_Up, first_Up;
-    int  ret;
-
-    ret = 0;
-    for ( i = 0, num_Up = num_Dn = 0; i < nNumNeigh; i ++ ) {
-        dAngle = atan2( at_coord[i][1], at_coord[i][0] ); /*  range from -pi to +pi */
-        if ( dAngle < 0.0 ) {
-            dAngle += two_pi;
-        }
-        dBondDirection[i] = dAngle;
-        nBondType[i] = (at_coord[i][2] > 0.0)? 1 : (at_coord[i][2] < 0.0)? -1 : 0; /* z-coord sign */
-        if ( nBondType[i] > 0 ) {
-            num_Up ++;
-        } else
-        if ( nBondType[i] < 0 ) {
-            num_Dn ++;
-        }
-        nBondOrder[i] = i;
-    }
-    if ( num_Up < num_Dn ) {
-        for ( i = 0; i < nNumNeigh; i ++ ) {
-            nBondType[i] = -nBondType[i];
-        }
-        e_swap( (char*)&num_Dn, (char*)&num_Up, sizeof(num_Dn) );
-    }
-    if ( !num_Up ) {
-        return T2D_UNDF;
-    }
-    /*  sort according to the bond orientations */
-    pDoubleForSort = dBondDirection;
-    e_insertions_sort( nBondOrder, nNumNeigh, sizeof(nBondOrder[0]), e_CompDble );
-    
-    /*  find the longest contiguous sequence of Up bonds */
-    if ( num_Up == nNumNeigh ) {
-        /*  all bonds are Up */
-        len_Up   = cur_len_Up = nNumNeigh; /* added cur_len_Up initialization 1/8/2002 */
-        first_Up = 0;
-    } else {
-        /*  at least one bond is not Up */
-        cur_len_Up = len_Up = bPrev_Up = 0;
-        /* prev. cycle header version ---
-        for ( i = 0; 1; i ++ ) {
-            if ( i >= nNumNeigh && !bPrev_Up ) {
-                break;
-            }
-        ----------} */
-        /* look at all bonds and continue (circle therough the beginning) as long as the current bond is Up */
-        for ( i = 0; i < nNumNeigh || bPrev_Up; i ++ ) {
-            if ( nBondType[nBondOrder[i % nNumNeigh]] > 0 ) {
-                if ( bPrev_Up ) {
-                    cur_len_Up ++; /* uncrement number of Up bonds in current contiguous sequence of them */
-                } else {
-                    bPrev_Up     = 1; /* start new contiguous sequence of Up bonds */
-                    cur_len_Up   = 1;
-                    cur_first_Up = i % nNumNeigh;
-                }
-            } else
-            if ( bPrev_Up ) { /* end of contiguous sequence of Up bonds */
-                if ( cur_len_Up > len_Up ) {
-                    first_Up = cur_first_Up; /* store the sequence because it is longer than the ptrvious one */
-                    len_Up   = cur_len_Up;
-                }
-                bPrev_Up = 0;
-            }
-        }
-    }
-    /*  Turn all the bonds around the center so that */
-    /*  the 1st Up bond has zero radian direction */
-    dAlpha = dBondDirection[nBondOrder[first_Up]];
-    for ( i = 0; i < nNumNeigh; i ++ ) {
-        if ( i == nBondOrder[first_Up] ) {
-            dBondDirection[i] = 0.0;
-        } else {
-            dAngle = dBondDirection[i] - dAlpha;
-            if ( dAngle < 0.0 ) {
-                dAngle += two_pi;
-            }
-            dBondDirection[i] = dAngle;
-        }
-    }
-
-    /********************************************************
-     * Process particular cases
-     ********************************************************/
-
-    switch( nNumNeigh ) {
-
-    /************************ 3 bonds ***********************
-     */
-    case 3:
-        switch( num_Up ) {
-        /* -------------------------- 0 Up ------------ */
-        case 0:
-            return T2D_UNDF;
-        /* -------------------------- 1 Up ------------ */
-        case 1:
-            if ( num_Dn ) {
-#ifdef _DEBUG
-                if ( num_Dn != 1 )  /*  debug only */
-                    return -1;
-#endif
-                ret = (T2D_UNDF | T2D_WARN);
-            } else {
-                dAngle = dBondDirection[nBondOrder[(first_Up + 2) % nNumNeigh]] -
-                         dBondDirection[nBondOrder[(first_Up + 1) % nNumNeigh]];
-                if ( dAngle < 0.0 ) {
-                    dAngle += two_pi;
-                }
-                if ( dAngle - one_pi < -MIN_ANGLE || dAngle - one_pi > MIN_ANGLE  ) {
-                    ret = T2D_OKAY;
-                } else {
-                    ret = (T2D_UNDF | T2D_WARN);
-                }
-            }
-            break;
-        /* -------------------------- 2 Up ------------ */
-        case 2:
-            if ( num_Dn ) {
-                dAlpha = dBondDirection[nBondOrder[(first_Up + 1) % nNumNeigh]] -
-                         dBondDirection[nBondOrder[(first_Up    ) % nNumNeigh]];
-                if ( dAlpha < 0.0 ) {
-                    dAlpha += two_pi;
-                }
-                if ( dAlpha > one_pi - MIN_ANGLE ) {
-                    ret = T2D_OKAY;
-                } else
-                if ( dAlpha < two_pi / 3.0 - MIN_ANGLE ) {
-                    ret = (T2D_UNDF | T2D_WARN);
-                } else {
-                    /*  angle between 2 Up bonds is between 120 and 180 degrees */
-                    /*  direction of the (Alpha angle bisector) + 180 degrees  */
-                    dBisector = (dBondDirection[nBondOrder[(first_Up     ) % nNumNeigh]] +
-                                dBondDirection[nBondOrder[(first_Up + 1 ) % nNumNeigh]] ) / 2.0 - one_pi;
-                    if ( dBisector < 0.0 ) {
-                        dBisector += two_pi;
-                    }
-                    if ( dAlpha < two_pi / 3.0 + MIN_ANGLE ) {
-                        /*  dAlpha is inside ( 2pi/3 - eps, 2pi/3 + eps ) interval */
-                        dLimit = MIN_ANGLE * 3.0 / 2.0;
-                    } else {
-                        dLimit = dAlpha * 3.0 / 2.0 - one_pi;
-                    }
-                    dAngle = dBondDirection[nBondOrder[(first_Up + 2 ) % nNumNeigh]];
-                    if (  dBisector - dAngle < -dLimit ||
-                          dBisector - dAngle >  dLimit  ) {
-                        ret = (T2D_UNDF | T2D_WARN);
-                    } else {
-                        ret = T2D_OKAY;
-                    }
-                }
-            } else {
-                ret = T2D_OKAY;
-            }
-
-            break;
-        /* -------------------------- 3 Up ------------ */
-        case 3:
-            ret = T2D_OKAY;
-            break;
-        /* -------------------------- other Up -------- */
-        default:
-            return -1;
-
-        }
-
-        break;
-
-    /************************************** 4 bonds **************************
-     */
-    case 4:
-        switch( num_Up ) {
-        /* -------------------------- 0 Up ------------ */
-        case 0:
-            return T2D_UNDF;
-        /* -------------------------- 1 Up ------------ */
-        case 1:
-            if ( num_Dn ) {
-                if ( nBondType[nBondOrder[(first_Up + 2) % nNumNeigh]] < 0 ) {
-                    /*
-                     * Up, In Plane, Dn, In Plane. Undefined if angle between
-                     * two In Plane bonds is wuthin pi +/- 2*arcsine(1/sqrt(8)) interval
-                     * That is, 138.5 to 221.4 degrees; for certainty the interval is
-                     * increased by 5.7 degrees at each end to
-                     * 134.8 to 227.1 degrees
-                     */
-                    dAngle = dBondDirection[nBondOrder[(first_Up + 3) % nNumNeigh]] -
-                             dBondDirection[nBondOrder[(first_Up + 1) % nNumNeigh]];
-                    if ( dAngle < 0.0 ) {
-                        dAngle += two_pi;
-                    }
-                    if ( fabs( dAngle - one_pi ) < dAngleAndPiMaxDiff + MIN_ANGLE ) {
-                        ret = (T2D_UNDF | T2D_WARN); 
-                    } else {
-                        ret = T2D_OKAY;
-                    }
-                } else {
-                    ret = T2D_OKAY;
-                }
-#ifdef _DEBUG
-                if ( num_Dn != 1 )  /*  debug only */
-                    return -1;
-#endif
-            } else {
-                ret    = T2D_OKAY;
-                dAngle = dBondDirection[nBondOrder[(first_Up + 3) % nNumNeigh]] -
-                         dBondDirection[nBondOrder[(first_Up + 1) % nNumNeigh]];
-                if ( dAngle < 0.0 ) {
-                    dAngle += two_pi;
-                }
-                if ( dAngle < one_pi - MIN_ANGLE ) {
-                    ret |= T2D_WARN;
-                }
-            }
-            break;
-        /* -------------------------- 2 Up ------------ */
-        case 2:
-            if ( cur_len_Up == 1 ) {
-                ret = T2D_OKAY;
-            } else {
-                ret = (T2D_UNDF | T2D_WARN);
-            }
-            break;
-        /* -------------------------- 3 Up ------------ */
-        case 3:
-            ret    = T2D_OKAY;
-            dAngle = dBondDirection[nBondOrder[(first_Up + 2) % nNumNeigh]] -
-                     dBondDirection[nBondOrder[(first_Up + 0) % nNumNeigh]];
-            if ( dAngle < 0.0 ) {
-                dAngle += two_pi;
-            }
-            if ( dAngle < one_pi - MIN_ANGLE ) {
-                ret |= T2D_WARN;
-            }
-            break;
-        /* -------------------------- 4 Up ------------ */
-        case 4:
-            ret = (T2D_UNDF | T2D_WARN);
-            break;
-        /* -------------------------- other Up -------- */
-        default:
-            return -1; /*  program error */
-        }
-
-        if ( ret == T2D_OKAY ) {
-            /*  check whether all bonds are inside a less than 180 degrees sector */
-            for ( i = 0; i < nNumNeigh; i ++ ) {
-                dAngle = dBondDirection[nBondOrder[(i + nNumNeigh - 1) % nNumNeigh]] -
-                         dBondDirection[nBondOrder[ i % nNumNeigh]];
-                if ( dAngle < 0.0 ) {
-                    dAngle += two_pi;
-                }
-                if ( dAngle < one_pi - MIN_ANGLE ) {
-                    ret |= T2D_WARN;
-                    break;
-                }
-            }
-        }
-
-        break;
-    /*************************** other nuber of bonds ******************/
-    default:
-        return -1; /*  error */
-    }
-
-    return ret;
-
-}
-/*************************************************************/
-double e_triple_prod_and_min_abs_sine2(double at_coord[][3], double central_at_coord[], int bAddedExplicitNeighbor, double *min_sine, int *bAmbiguous)
-{
-    double min_sine_value=9999.0, sine_value, min_edge_len, max_edge_len, min_edge_len_NoExplNeigh, max_edge_len_NoExplNeigh;
-    double s0, s1, s2, s3, e01, e02, e03, e12, e13, e23, tmp[3], e[3][3];
-    double prod, ret, central_prod[4];
-    int    bLongEdges;
-
-    if ( !min_sine ) {
-        return e_triple_prod( at_coord[0], at_coord[1], at_coord[2], NULL );
-    }
-    
-    ret = e_triple_prod( at_coord[0], at_coord[1], at_coord[2], &sine_value );
-    sine_value = MPY_SINE * fabs( sine_value );
-    
-    e_diff3( at_coord[1], at_coord[0], e[2] );
-    e_diff3( at_coord[0], at_coord[2], e[1] );
-    e_diff3( at_coord[2], at_coord[1], e[0] );
-    
-    /*  lengths of the 6 edges of the tetrahedra */
-    e03 = e_len3( at_coord[0] ); /* 1 */
-    e13 = e_len3( at_coord[1] );
-    e23 = e_len3( at_coord[2] ); /* includes added neighbor if bAddedExplicitNeighbor*/
-    e02 = e_len3( e[1] );        /* includes added neighbor if bAddedExplicitNeighbor*/
-    e12 = e_len3( e[0] );        /* includes added neighbor if bAddedExplicitNeighbor*/
-    e01 = e_len3( e[2] );        
-    
-    /*  min & max edge length */
-    max_edge_len =
-    min_edge_len = e03;
-
-    if ( min_edge_len > e13 )
-        min_edge_len = e13;
-    if ( min_edge_len > e01 )
-        min_edge_len = e01;
-    min_edge_len_NoExplNeigh = min_edge_len;
-
-    if ( min_edge_len > e23 )
-        min_edge_len = e23;
-    if ( min_edge_len > e02 )
-        min_edge_len = e02;
-    if ( min_edge_len > e12 )
-        min_edge_len = e12;
-
-    if ( max_edge_len < e13 )
-        max_edge_len = e13;
-    if ( max_edge_len < e01 )
-        max_edge_len = e01;
-    max_edge_len_NoExplNeigh = max_edge_len;
-
-    if ( max_edge_len < e23 )
-        max_edge_len = e23;
-    if ( max_edge_len < e02 )
-        max_edge_len = e02;
-    if ( max_edge_len < e12 )
-        max_edge_len = e12;
-    
-    if ( !bAddedExplicitNeighbor ) {
-        min_edge_len_NoExplNeigh = min_edge_len;
-        max_edge_len_NoExplNeigh = max_edge_len;
-    }
-
-    bLongEdges = bAddedExplicitNeighbor? 
-                  ( max_edge_len_NoExplNeigh < MAX_EDGE_RATIO * min_edge_len_NoExplNeigh ) :
-                  ( max_edge_len             < MAX_EDGE_RATIO * min_edge_len );
-
-    if ( sine_value > MIN_SINE && ( min_sine || bAmbiguous ) ) {
-        if ( min_sine ) {
-            prod = fabs( ret );
-            /*  tetrahedra height = volume(prod) / area of a plane(cross_prod) */
-            /*  (instead of a tetrahedra calculate parallelogram/parallelepiped area/volume) */
-
-            /*  4 heights from each of the 4 vertices to the opposite plane */
-            s0  = prod / e_len3( e_cross_prod3( at_coord[1], at_coord[2], tmp ) );
-            s1  = prod / e_len3( e_cross_prod3( at_coord[0], at_coord[2], tmp ) );
-            s2  = prod / e_len3( e_cross_prod3( at_coord[0], at_coord[1], tmp ) );
-            s3  = prod / e_len3( e_cross_prod3( e[0], e[1], tmp ) );
-            /*  abs. value of a sine of an angle between each tetrahedra edge and plane */
-            /*  sine = height / edge length */
-            if ( (sine_value = s0/e01) < min_sine_value )
-                min_sine_value = sine_value;
-            if ( (sine_value = s0/e02) < min_sine_value )
-                min_sine_value = sine_value;
-            if ( (sine_value = s0/e03) < min_sine_value )
-                min_sine_value = sine_value;
-
-            if ( (sine_value = s1/e01) < min_sine_value )
-                min_sine_value = sine_value;
-            if ( (sine_value = s1/e12) < min_sine_value )
-                min_sine_value = sine_value;
-            if ( (sine_value = s1/e13) < min_sine_value )
-                min_sine_value = sine_value;
-
-            if ( (sine_value = s2/e02) < min_sine_value )
-                min_sine_value = sine_value;
-            if ( (sine_value = s2/e12) < min_sine_value )
-                min_sine_value = sine_value;
-            if ( (sine_value = s2/e23) < min_sine_value )
-                min_sine_value = sine_value;
-
-            if ( (sine_value = s3/e03) < min_sine_value )
-                min_sine_value = sine_value;
-            if ( (sine_value = s3/e13) < min_sine_value )
-                min_sine_value = sine_value;
-            if ( (sine_value = s3/e23) < min_sine_value )
-                min_sine_value = sine_value;
-            /*  actually use triple sine */
-            *min_sine = sine_value = MPY_SINE * min_sine_value;
-        }
-
-        if ( bAmbiguous && sine_value >= MIN_SINE ) {
-            /*  check whether the central atom is outside the tetrahedra (0,0,0), at_coord[0,1,2] */
-            /*  compare the tetrahedra volume and the volume of a tetrahedra having central_at_coord[] vertex */
-            int i;
-            e_diff3( central_at_coord, at_coord[0], tmp );
-            central_prod[0] = e_triple_prod( at_coord[0], at_coord[1], central_at_coord, NULL );
-            central_prod[1] = e_triple_prod( at_coord[1], at_coord[2], central_at_coord, NULL );
-            central_prod[2] = e_triple_prod( at_coord[2], at_coord[0], central_at_coord, NULL );
-            central_prod[3] = e_triple_prod( e[2], e[1], tmp, NULL );
-            for ( i = 0; i <= 3; i ++ ) {
-                if ( central_prod[i] / ret < -MIN_SINE_OUTSIDE ) {
-                    *bAmbiguous |= AMBIGUOUS_STEREO;
-                    break;
-                }
-            }
-        }
-#if( STEREO_CENTER_BONDS_NORM == 1 )        
-        
-        if ( bLongEdges && !bAddedExplicitNeighbor && max_edge_len >= MIN_LEN_STRAIGHT ) {
-            /*  possible planar tetragon */
-            if ( sine_value < MIN_SINE_SQUARE ) {
-                *min_sine = MIN_SINE / 2.0; /*  force parity to be undefined */
-                if ( bAmbiguous && !*bAmbiguous ) {
-                    *bAmbiguous |= AMBIGUOUS_STEREO;
-                }
-            }
-        }
-        
-        if ( bLongEdges && sine_value < MIN_SINE_SQUARE && sine_value < MIN_SINE_EDGE * min_edge_len_NoExplNeigh ) {
-            *min_sine = MIN_SINE / 2.0; /*  force parity to be undefined */
-            if ( bAmbiguous && !*bAmbiguous ) {
-                *bAmbiguous |= AMBIGUOUS_STEREO;
-            }
-        }
-#endif
-
-    } else
-    if ( min_sine ) {
-        *min_sine = sine_value;
-    }
-    
-    return ret;
-}
-/*************************************************************/
-double e_triple_prod_and_min_abs_sine(double at_coord[][3], double *min_sine)
-{
-    double min_sine_value=9999.0, sine_value;
-    double prod=0.0;
-
-    if ( !min_sine ) {
-        return e_triple_prod( at_coord[0], at_coord[1], at_coord[2], NULL );
-    }
-    
-    prod = e_triple_prod( at_coord[0], at_coord[1], at_coord[2], &sine_value );
-    sine_value = fabs( sine_value );
-    min_sine_value = inchi_min( min_sine_value, sine_value );
-    
-    prod = e_triple_prod( at_coord[1], at_coord[2], at_coord[0], &sine_value );
-    sine_value = fabs( sine_value );
-    min_sine_value = inchi_min( min_sine_value, sine_value );
-    
-    prod = e_triple_prod( at_coord[2], at_coord[0], at_coord[1], &sine_value );
-    sine_value = fabs( sine_value );
-    min_sine_value = inchi_min( min_sine_value, sine_value );
-
-    *min_sine = min_sine_value;
-    
-    return prod;
-}
-/*************************************************************/
-/*  Find if point (0,0,0)a and 3 atoms are in one plane */
-int are_3_vect_in_one_plane( double at_coord[][3], double min_sine)
-{
-    double actual_min_sine;
-    double prod;
-    prod = e_triple_prod_and_min_abs_sine( at_coord, &actual_min_sine);
-    return actual_min_sine <= min_sine;
-}
-/*************************************************************/
-/*  Find if 4 atoms are in one plane */
-int e_are_4at_in_one_plane( double at_coord[][3], double min_sine)
-{
-    double actual_min_sine, min_actual_min_sine;
-    double coord[3][3], prod;
-    int i, k, j;
-    for ( k = 0; k < 4; k ++ ) { /* cycle added 4004-08-15 */
-        for ( i = j = 0; i < 4; i ++ ) {
-            if ( i != k ) {
-                e_diff3( at_coord[i], at_coord[k], coord[j] );
-                j ++;
-            }
-        }
-        prod = e_triple_prod_and_min_abs_sine( coord, &actual_min_sine);
-        if ( !k || actual_min_sine < min_actual_min_sine ) {
-            min_actual_min_sine = actual_min_sine;
-        }
-    }
-    return min_actual_min_sine <= min_sine;
-}
-/*************************************************************/
-int e_triple_prod_char( inchi_Atom *at, int at_1, int i_next_at_1, S_CHAR *z_dir1,
-                                    int at_2, int i_next_at_2, S_CHAR *z_dir2 )
-{
-    inchi_Atom *at1, *at2;
-    double    pnt[3][3], len;
-    int       i;
-    int       ret = 0;
-
-    at1 = at + at_1;
-    at2 = at + at[at_1].neighbor[i_next_at_1];
-
-    pnt[0][0] = at2->x - at1->x;
-    pnt[0][1] = at2->y - at1->y;
-    pnt[0][2] = at2->z - at1->z;
-
-    at2 = at + at_2;
-    at1 = at + at[at_2].neighbor[i_next_at_2];
-
-    pnt[1][0] = at2->x - at1->x; 
-    pnt[1][1] = at2->y - at1->y; 
-    pnt[1][2] = at2->z - at1->z;
-/*
- *  resultant pnt vector directions:
- *
- *         pnt[0]              pnt[1]
- *
- *   [at_1]---->[...]    [...]---->[at_2]
- *
- *  
- *  e_add3 below: (pnt[0] + pnt[1]) -> pnt[1]
- */
-    e_add3( pnt[0], pnt[1], pnt[1] );
-
-
-
-    for ( i = 0; i < 3; i ++ ) {
-        pnt[0][i] = (double)z_dir1[i];
-        pnt[2][i] = (double)z_dir2[i];
-    }
-    for ( i = 0; i < 3; i ++ ) {
-        len = e_len3( pnt[i] );
-        if ( len < MIN_BOND_LEN ) {
-            goto exit_function; /*  too short bond */
-        }
-        e_mult3( pnt[i], 1.0/len, pnt[i] );
-    }
-    len = 100.0*e_triple_prod(pnt[0], pnt[1], pnt[2], NULL );
-/*
- *   ^ pnt[0]
- *   |                         The orientation on this diagram
- *   |                         produces len = -100
- *  [at_1]------>[at_2]
- *        pnt[1]    /
- *                 /
- *                / pnt[2]  (up from the plane)
- *               v
- *
- * Note: len is invariant upon at_1 <--> at_2 transposition because
- *       triple product changes sign upon pnt[0]<-->pnt[2] transposition and
- *       triple product changes sign upon pnt[1]--> -pnt[1] change of direction:
- *
- * e_triple_prod(pnt[0],  pnt[1], pnt[2], NULL ) =
- * e_triple_prod(pnt[2], -pnt[1], pnt[0], NULL )
- *
- */
-    
-    ret = len >= 0.0? (int)floor(len+0.5) : -(int)floor(0.5-len);
-
-exit_function:
-
-    return ret;
-}
-
-#ifdef NEVER
-/********************************************************************************************/
-int bCanInpAtomBeAStereoCenter( inchi_Atom *at, int cur_at )
-{
-    
-/*************************************************************************************
- * current version
- *************************************************************************************
- *       Use #define to split the stereocenter description table into parts
- *       to make it easier to read
- *
- *                      --------- 4 single bonds stereocenters -------
- *                                                                    
- *                       |       |       |       |      |       |     
- *                      -C-     -Si-    -Ge-    -Sn-   >As[+]  >B[-]  
- *                       |       |       |       |      |       |     
- */
-#define SZELEM1         "C\000","Si",   "Ge",   "Sn",   "As", "B\000",
-#define CCHARGE1         0,      0,      0,      0,      1,   -1,    
-#define CNUMBONDSANDH1   4,      4,      4,      4,      4,    4,    
-#define CCHEMVALENCEH1   4,      4,      4,      4,      4,    4,    
-#define CHAS3MEMBRING1   0,      0,      0,      0,      0,    0,    
-#define CREQUIRDNEIGH1   0,      0,      0,      0,      3,    0,    
-/*
- *                      --------------- S, Se stereocenters ----------
- *                                                                                
- *                               |       |      ||             |     |     ||     
- *                      -S=     =S=     -S[+]   >S[+]   -Se=  =Se=  -Se[+] >Se[+] 
- *                       |       |       |       |       |     |     |      |     
- */
-#define SZELEM2         "S\000","S\000","S\000","S\000","Se", "Se", "Se",  "Se",  
-#define CCHARGE2         0,      0,      1,      1,      0,    0,    1,     1,    
-#define CNUMBONDSANDH2   3,      4,      3,      4,      3,    4,    3,     4,    
-#define CCHEMVALENCEH2   4,      6,      3,      5,      4,    6,    3,     5,    
-#define CHAS3MEMBRING2   0,      0,      0,      0,      0,    0,    0,     0,    
-#define CREQUIRDNEIGH2   3,      3,      3,      3,      3,    3,    3,     3,
-/*
- *                      ------------------ N, P stereocenters --------
- *
- *                                      X---Y                  
- *                        |      |       \ /     |       |     
- *                       =N-    >N[+]     N     >P[+]   =P-    
- *                        |      |        |      |       |     
- */
-#define SZELEM3         "N\000","N\000","N\000","P\000","P\000",
-#define CCHARGE3         0,      1,      0,      1,      0,     
-#define CNUMBONDSANDH3   4,      4,      3,      4,      4,     
-#define CCHEMVALENCEH3   5,      4,      3,      4,      5,     
-#define CHAS3MEMBRING3   0,      0,      1,      0,      0,     
-#define CREQUIRDNEIGH3   3,      3,      1,      3,      3,     
-
-
-
-    static char        szElem[][3]={ SZELEM1         SZELEM2         SZELEM3        };
-    static S_CHAR        cCharge[]={ CCHARGE1        CCHARGE2        CCHARGE3       };
-    static S_CHAR  cNumBondsAndH[]={ CNUMBONDSANDH1  CNUMBONDSANDH2  CNUMBONDSANDH3 };
-    static S_CHAR  cChemValenceH[]={ CCHEMVALENCEH1  CCHEMVALENCEH2  CCHEMVALENCEH3 };
-    static S_CHAR  cHas3MembRing[]={ CHAS3MEMBRING1  CHAS3MEMBRING2  CHAS3MEMBRING3 };
-    static S_CHAR  cRequirdNeigh[]={ CREQUIRDNEIGH1  CREQUIRDNEIGH2  CREQUIRDNEIGH3 };
-
-    static int n = sizeof(szElem)/sizeof(szElem[0]);
-    /* reqired neighbor types (bitmap):
-       0 => check bonds only
-       1 => no terminal hydrogen atom neighbors
-       2 => no terminal -X and -XH together (don't care the bond type, charge, radical)
-            (X = tautomeric endpoint atom)
-       Note: whenever cChemValenceH[] > cNumBondsAndH[]
-             the tautomeric and/or alternating bonds
-             are permitted
-
-    */
-    int i, ret = 0;
-    for ( i = 0; i < n; i++ ) {
-        if ( !strcmp( at[cur_at].elname, szElem[i]) &&
-             at[cur_at].charge == cCharge[i] &&
-             (!at[cur_at].radical || at[cur_at].radical == 1) &&
-             at[cur_at].num_bonds +  inchi_NUMH(at,cur_at) == cNumBondsAndH[i] &&
-             at[cur_at].chem_bonds_valence+inchi_NUMH(at,cur_at) == cChemValenceH[i] &&
-             (cHas3MembRing[i]? is_atom_in_3memb_ring( at, cur_at ) : 1) &&
-             e_bInpAtomHasRequirdNeigh ( at, cur_at, cRequirdNeigh[i], cChemValenceH[i]-cNumBondsAndH[i]) ) {
-            ret = cNumBondsAndH[i];
-            break;
-        }
-    }
-    return ret;
-}
-
-#endif  /* NEVER */
-/********************************************************************************************/
-int e_bCanInpAtomBeAStereoCenter( int cur_at, S_CHAR *cAtType )
-{
-    switch ( cAtType[cur_at] ) {
-    case AtType_C4  :
-    case AtType_Si4 :
-    case AtType_Ge4 :
-    case AtType_Sn4 :
-    case AtType_B4m :
-    case AtType_S6  :
-    case AtType_S5p :
-    case AtType_Se6 :
-    case AtType_Se5p:
-    case AtType_N5  :
-    case AtType_N4p :
-    case AtType_P4p :
-    case AtType_P5  :
-    case AtType_As4p:
-    case AtType_As5 :
-        return 4;
-
-    case AtType_S3p :
-    case AtType_Se3p:
-    case AtType_S4  :
-    case AtType_Se4 :
-    case AtType_N3r :
-        return 3;
-    }
-    return 0;
-}
-/****************************************************************/
-/*  used for atoms adjacent to stereogenic bonds only */
-int e_bCanAtomHaveAStereoBond( inchi_Atom *at, int cur_at, S_CHAR *cAtType )
-{
-    int i, neigh, nNumFound;
-    char *p;
-    static char sNeigh[] = "O;S;Se;Te;";
-    switch ( cAtType[cur_at] ) {
-    case AtType_C3 :
-    case AtType_Si3:
-    case AtType_Ge3:
-    case AtType_Sn3:
-    case AtType_N3p:
-    case AtType_N3 :
-        return 3;
-    case AtType_Nns:
-        /*
-                  |
-           found =N=
-
-           if it has one neighbor =O or =S or =Se or =Te then return 3, otherwise return 1
-
-         */
-        nNumFound = 0;
-        for ( i = 0; i < at[cur_at].num_bonds; i ++ ) {
-            if ( at[cur_at].bond_type[i] == INCHI_BOND_TYPE_DOUBLE ) {
-                neigh = (int)at[cur_at].neighbor[i];
-                if ( (p = strstr(sNeigh, at[neigh].elname)) &&
-                     ';' == p[strlen(at[neigh].elname)] ) {
-                     nNumFound ++;
-                }
-            }
-        }
-        return nNumFound==1? 3 : 1;
-    }
-    return 0;
-}
-/****************************************************************/
-int e_bCanAtomBeMiddleAllene( int cur_at, S_CHAR *cAtType )
-{
-    switch ( cAtType[cur_at] ) {
-    case AtType_C2 :
-    case AtType_Si2:
-    case AtType_Ge2:
-    case AtType_Sn2:
-        return 2;
-    }
-    return 0;
-}
-/****************************************************************/
-int e_bCanAtomBeTerminalAllene( int cur_at, S_CHAR *cAtType )
-{
-    switch ( cAtType[cur_at] ) {
-    case AtType_C3 :
-    case AtType_Si3:
-    case AtType_Ge3:
-    case AtType_Sn3:
-        return 3;
-    }
-    return 0;
-}
-/*******************************************************************************************/
-int e_FixSb0DParities( inchi_Atom *at, Stereo0D *pStereo, int chain_length, AT_NUM at_middle,
-                     int at_1, int i_next_at_1, S_CHAR z_dir1[], S_CHAR z_dir1NM[], int bOnlyNM1, int bAnomaly1NM, int parity1, int parity1NM,
-                     int at_2, int i_next_at_2, S_CHAR z_dir2[], S_CHAR z_dir2NM[], int bOnlyNM2, int bAnomaly2NM, int parity2, int parity2NM )
-{
-    int             i_neigh_at_1, i_neigh_at_2, i, j1, j2;
-    int             j_neigh_at_1, j_neigh_at_2, j_next_at_1, j_next_at_2; /* positions after metal removal */
-    inchi_Stereo0D *stereo0D = NULL;
-    int             dot_prod_z = 0, dot_prod_zNM = 0, parity, parityNM;
-
-    if ( (!parity1 || !parity2) && (!parity1NM || !parity2NM) )
-        return 0;
-
-    if ( ATOM_PARITY_WELL_DEF( parity1 ) && ATOM_PARITY_WELL_DEF( parity2 ) ) {
-        /*  find how the whole bond parity depend on geometry */
-        /*  if dot_prod_z < 0 then bond_parity := 3-bond_parity */
-        /*  can be done only for a well-defined geometry */
-        /********************************************************************
-         *  Case of bOnlyNonMetal: stereobond end atoms have valence > 3
-         *  therefore they will not be recognized until metals have
-         *  been disconnected. Until then the assigned parities will
-         *  not change: ReconcileCmlIncidentBondParities() in the dll
-         *  ignores hypervanlence atoms marked as belonging to a stereobond.
-         *  Explicit H are removed only after metal diconnection.
-         *
-         *  However, there is a possibility that the normalization
-         *  removes an explicit H thus reducing the valence to acceptable
-         *  value for the bond to be treated as stereogenic.
-         *  In this case a wrong INChI stereolayer for the reconnected
-         *  structure will be produced.
-         *
-         *  After the metal disconnection ReconcileAllCmlBondParities()
-         *  will be called to reconcile newly appearing stereobonds
-         ********************************************************************/
-
-        dot_prod_z  = (chain_length%2)? 
-                       e_triple_prod_char( at, at_1, i_next_at_1, z_dir1, at_2, i_next_at_2, z_dir2 ) :
-                       e_dot_prodchar3(z_dir1, z_dir2);
-
-        if ( abs(dot_prod_z) < MIN_DOT_PROD ) {
-            /*  The geometry is not well-defined */
-            parity1 = parity2 = INCHI_PARITY_UNDEFINED;
-            dot_prod_z = 0;
-        }
-    
-    }
-    if ( ATOM_PARITY_WELL_DEF( parity1NM ) && ATOM_PARITY_WELL_DEF( parity2NM ) ) {
-        /*  find how the whole bond parity depend on geometry */
-        /*  if dot_prod_z < 0 then bond_parity := 3-bond_parity */
-        /*  can be done only for a well-defined geometry */
-        /********************************************************************
-         *  Case of bOnlyNonMetal: stereobond end atoms have valence > 3
-         *  therefore they will not be recognized until metals have
-         *  been disconnected. Until then the assigned parities will
-         *  not change: ReconcileCmlIncidentBondParities() in the dll
-         *  ignores hypervanlence atoms marked as belonging to a stereobond.
-         *  Explicit H are removed only after metal diconnection.
-         *
-         *  However, there is a possibility that the normalization
-         *  removes an explicit H thus reducing the valence to acceptable
-         *  value for the bond to be treated as stereogenic.
-         *  In this case a wrong INChI stereolayer for the reconnected
-         *  structure will be produced.
-         *
-         *  After the metal disconnection ReconcileAllCmlBondParities()
-         *  will be called to reconcile newly appearing stereobonds
-         ********************************************************************/
-
-        dot_prod_zNM  = (chain_length%2)? 
-                       e_triple_prod_char( at, at_1, i_next_at_1, z_dir1NM, at_2, i_next_at_2, z_dir2NM ) :
-                       e_dot_prodchar3(z_dir1NM, z_dir2NM);
-
-        if ( abs(dot_prod_zNM) < MIN_DOT_PROD ) {
-            /*  The geometry is not well-defined */
-            parity1NM = parity2NM = INCHI_PARITY_UNDEFINED;
-            dot_prod_zNM = 0;
-        }
-    
-    }
-
-    i_neigh_at_1 = i_neigh_at_2 = -1;
-    j_neigh_at_1 = j_neigh_at_2 = j_next_at_1 = j_next_at_2 = -1;
-
-    /************************************************************************
-     *
-     * The possibly stereogenic bond is defined by atoms at_1, at_2 and
-     * positions in their adjacency lists i_next_at_1, i_next_at_2.
-     *
-     * We need one more neighbor of at_1 and at_2 to establist cis or trans.
-     * The current API allows only same neighbors for both connected and
-     * metal-disconnected (or non-metal, NM) structures. Therefore if an
-     * atom has both metal and non-metal neighbors, select the non-metal one.
-     *
-     * In case of bOnlyNM we have to use ordering numbers of the bonds
-     * counted as if all metals have been disconnected.
-     *
-     * In all other cases we use real ordering numbers of the bonds
-     * to calculate the parities.
-     *
-     * The input parities meaning:
-     * ===========================
-     * EVEN=2: the atoms in the adjacency list are arranged clockwise as
-     *         seen from the arrowhead of the z_dir vector
-     *
-     * The output parities meaning:
-     * ============================
-     * EVEN=2: trans geometry. For more details see the API description.
-     *
-     **************************************************************************/
-
-    if ( bOnlyNM1 || ATOM_PARITY_WELL_DEF( parity1NM ) ) {
-        /* disconnected metal case */
-        for ( i = j1 = 0; i < at[at_1].num_bonds; i ++ ) {
-            if ( IS_METAL(pStereo->cAtType[at[at_1].neighbor[i]]) ) {
-                continue;
-            }
-            if ( i == i_next_at_1 ) {
-                j_next_at_1 = j1; /* position of the stereo bond in adjacency list
-                                     when metals are disconnected */
-            } else
-            if ( i_neigh_at_1 < 0 ) {
-                i_neigh_at_1 = i;  /* position of the first non-metal neighbor (metal is connected) */
-                j_neigh_at_1 = j1; /* position of the first non-metal neighbor (metal is disconnected) */
-            }
-            j1 ++;
-        }
-    } else {
-        /* no metal case */
-        j_neigh_at_1 = i_neigh_at_1 = (i_next_at_1==0);
-        j_next_at_1  = i_next_at_1;
-        j1           = at[at_1].num_bonds;
-    }
-
-    if ( bOnlyNM2 || ATOM_PARITY_WELL_DEF( parity2NM ) ) {
-        for ( i = j2 = 0; i < at[at_2].num_bonds; i ++ ) {
-            if ( IS_METAL(pStereo->cAtType[at[at_2].neighbor[i]]) ) {
-                continue;
-            }
-            if ( i == i_next_at_2 ) {
-                j_next_at_2 = j2;
-            } else
-            if ( i_neigh_at_2 < 0 ) {
-                i_neigh_at_2 = i;
-                j_neigh_at_2 = j2;
-            }
-            j2 ++;
-        }
-    } else {
-        j_neigh_at_2 = i_neigh_at_2 = (i_next_at_2==0);
-        j_next_at_2  = i_next_at_2;
-        j2           = at[at_2].num_bonds;
-    }
-
-    if ( i_neigh_at_1 < 0 || i_neigh_at_2 < 0 ||
-         j_neigh_at_1 < 0 || j_neigh_at_2 < 0 ||
-         j_next_at_1  < 0 || j_next_at_2  < 0 ) {
-        return 0; /* debugging */
-    }
-    if ( parity1 || parity1NM ) {
-        /* create a new stereo descriptor */
-        stereo0D = e_GetNewStereo( pStereo );
-        if ( !stereo0D ) {
-            return -1; /* error */
-        }
-        /* choose the smallest (earliest in the adjacency list) neighbor of at_1 */
-        stereo0D->neighbor[0] = at[at_1].neighbor[i_neigh_at_1];
-        /* stereibond atoms */
-        stereo0D->neighbor[1] = at_1;
-        stereo0D->neighbor[2] = at_2;
-        /* choose the smallest neighbor of at_2 */
-        stereo0D->neighbor[3] = at[at_2].neighbor[i_neigh_at_2];
-        stereo0D->central_atom = at_middle;
-        stereo0D->type = (chain_length % 2)? INCHI_StereoType_Allene : INCHI_StereoType_DoubleBond;
-
-        if ( dot_prod_z || dot_prod_zNM ) {
-
-            int i_parity1 = i_neigh_at_1 + i_next_at_1 + (i_neigh_at_1 > i_next_at_1);
-            int j_parity1 = j_neigh_at_1 + j_next_at_1 + (j_neigh_at_1 > j_next_at_1);
-            int i_parity2 = i_neigh_at_2 + i_next_at_2 + (i_neigh_at_2 > i_next_at_2);
-            int j_parity2 = j_neigh_at_2 + j_next_at_2 + (j_neigh_at_2 > j_next_at_2);
-            
-            /* regular (connected) parity; parity1 and parity2 are well-defined only together */
-            if ( ATOM_PARITY_WELL_DEF( parity1 ) ) {
-                parity = 2 - ( parity1 + parity2 + (dot_prod_z < 0) +
-                               ((bOnlyNM1)? j_parity1 : i_parity1) +
-                               ((bOnlyNM2)? j_parity2 : i_parity2) ) % 2;
-            } else {
-                parity = parity1;
-            }
-
-
-            /* disconnected parity; parity1NM and parity2NM are well-defined only together */
-            if ( ATOM_PARITY_WELL_DEF( parity1NM ) ) {
-                parityNM = 2 - ( parity1NM + parity2NM + (dot_prod_zNM < 0) +
-                                 ((bOnlyNM1||bAnomaly1NM)? j_parity1 : i_parity1) +
-                                 ((bOnlyNM2||bAnomaly2NM)? j_parity2 : i_parity2) ) % 2;
-            } else {
-                parityNM = parity1NM;
-            }
-        } else {
-            parity   = parity1;
-            parityNM = parity1NM;
-        }
-        stereo0D->parity = parity;
-        if ( parityNM != parity || bAnomaly1NM || bAnomaly2NM ) {
-            stereo0D->parity |= (parityNM << SB_PARITY_SHFT);
-        }
-
-        return stereo0D->parity;
-    }
-    return 0;
-}
-/**************************************************************************/
-int e_nNumNonMetalNeigh( inchi_Atom *atom, int cur_at, Stereo0D *pStereo, int *i_ord_LastMetal )
-{
-    int          j, nNumNonMetal;
-    inchi_Atom *at  = atom + cur_at;
-    int         val = at->num_bonds;
-    int         atype;
-
-    *i_ord_LastMetal = -1;
-    nNumNonMetal     = 0;
-
-    atype = pStereo->cAtType[cur_at];
-    
-    if ( IS_METAL(atype) )
-        return 0;
-    for ( j = 0; j < val; j ++ ) {
-        atype = pStereo->cAtType[(int)at->neighbor[j]];
-        if ( IS_METAL(atype) )
-            *i_ord_LastMetal = j;
-        else
-            nNumNonMetal ++;
-    }
-    return nNumNonMetal;
-}
-/*======================================================================================================
- 
-e_half_stereo_bond_parity() General Description:
-
-    A) find projections of 3 bonds on a reasonable plane defined
-       by a vector z_dir perpendicular to the plane
-    B) calculate parity (parity=2[EVEN]: neighbors are clockwise as seen from the arrowhead of z_dir[] vector)
-
-e_half_stereo_bond_parity() Detailed Description:
-
-    1) Find at_coord[] = vectors from the central atoms to its neighbors
-    2) If only 2 neighbors are present, then create a reasonable 3rd neighbor
-       (an implicit H or a fictitious atom in case of =NX) coordinates
-    3) Normalize at_coord[] to unit length
-    4) Find unit vector pnt[2] perpendicular to the plane containing
-       at_coord[] arrow ends.
-       Even though it is not necessary, make z-coordinate of pnt[2] positive.
-       ** pnt[2] has the new z-axis direction **
-    5) Let pnt[0] = perpendicular to pnt[2] component of at_coord[0];
-       Normalize pnt[0] to unit length.
-       ** pnt[0] has the new x-axis direction **
-    6) Let pnt[1] = pnt[2] x pnt[0] (cross-product);
-       ** pnt[1] has the new y-axis direction **
-    7) Find at_coord[] in the new xyz-basis and normalize their xy-projections
-       to a unit length
-    8) In the new xy-plane find (counterclockwise) angles:
-       tmp1 = (from at_coord[0] to at_coord[1])
-       tmp2 = (from at_coord[0] to at_coord[2])
-    9) Calculate the parity: if tmp1 < tmp2 then 1 (odd) else 2 (even)
-       (even: looking from the arrow end of the new z-axis, 0, 1, and 2 neighbors
-        are in clockwise order)
-   10) Calculate z_dir = 100*pnt[2].
-   
-   Note1. If z_dir vectors of atoms located at the opposite ends of a double bond have approximately
-          opposite directions (that is, their dot-product is negative) then the parity of the
-          stereogenic bond calculated from half-bond-parities should be inverted
-
-   Note2. In case of a tetrahedral cumulene a triple product (z_dir1, (1->2), z_dir2) is used instead
-          of the dot-product. (1->2) is a vector from the atom#1 to the atom #2. This triple product
-          is invariant with respect to the atom numbering because it does not change upon (1,2)
-          permutation.
-  
-  Stereo ambiguity in case of 2 neighbors:
-  ----------------------------------------
-  Undefined: single-double bond angle > pi - arcsin(0.03) = 178.28164199834454285275613218975 degrees
-  Ambiguous: single-double bond angle > 175 degrees = pi - 0.087156 Rad
- 
-   Return values 
-   (cases: I=only in case of isotopic H atoms the neighbors are different,
-           N=in case of non-isotopic H atoms the neighbors are different)
-
-  -4 = INCHI_PARITY_UNDEFINED => atom is adjacent to a stereogenic bond, but the geometry is undefined, I
-  -3 = INCHI_PARITY_UNKNOWN => atom is adjacent to a stereogenic bond, but the geometry is not known to the iuser, I
-  -2 =-INCHI_PARITY_EVEN => parity of an atom adjacent to a stereogenic bond, I
-  -1 =-INCHI_PARITY_ODD  => parity of an atom adjacent to a stereogenic bond, I
-   0 = INCHI_PARITY_NONE => the atom is not adjacent to a stereogenic bond
-   1 = INCHI_PARITY_ODD  => parity of an atom adjacent to a stereogenic bond, N&I
-   2 = INCHI_PARITY_EVEN => parity of an atom adjacent to a stereogenic bond, N&I
-   3 = INCHI_PARITY_UNKNOWN => atom is adjacent to a stereogenic bond, but the geometry is not known to the iuser, N&I
-   4 = INCHI_PARITY_UNDEFINED => atom is adjacent to a stereogenic bond, but the geometry is undefined, N&I
-
-
-=====================================================================================================*/
-
-int e_half_stereo_bond_parity( inchi_Atom *at, int cur_at, S_CHAR *z_dir, int *bOnlyNonMetal,
-                                int bPointedEdgeStereo, Stereo0D *pStereo )
-{
-    double at_coord[MAX_NUM_STEREO_BOND_NEIGH][3], c, s, tmp[3], tmp1, tmp2, min_tmp, max_tmp, z;
-    double temp[3], pnt[3][3];
-    int j, k, p0, p1, p2, next, num_z, nType, num_either_single, num_either_double;
-    int nNumExplictAttachments;
-    int bond_parity  =  INCHI_PARITY_UNDEFINED;
-    int    num_H=0, num_eH=0, num_nH=0 /* = num_iso_H[0] */;
-    const double one_pi = 2.0*atan2(1.0 /* y */, 0.0 /* x */);
-    const double two_pi = 2.0*one_pi;
-    AT_NUM       nSbNeighOrigAtNumb[MAX_NUM_STEREO_BOND_NEIGH];
-    int          bAmbiguousStereo = 0;
-    S_CHAR       num_iso_eH[NUM_H_ISOTOPES+1]; /* count explicit H */
-
-    if ( z_dir && !z_dir[0] && !z_dir[1] && !z_dir[2] ) {
-        z_dir[2]=100;
-    }
-    /* *bOnlyNonMetal = 0; */
-    if ( at[cur_at].num_bonds > MAX_NUM_STEREO_BOND_NEIGH || *bOnlyNonMetal ) {
-        int i_ord_LastMetal;
-        int nNumNonMetal = e_nNumNonMetalNeigh( at, cur_at, pStereo, &i_ord_LastMetal );
-        if ( nNumNonMetal <= MAX_NUM_STEREO_BOND_NEIGH ) {
-            *bOnlyNonMetal = 1;
-            if ( 1 == nNumNonMetal ) {
-                return bond_parity; /* INCHI_PARITY_UNDEFINED */
-            }
-            if ( 0 == nNumNonMetal ) {
-                return INCHI_PARITY_NONE;
-            }
-        } else {
-            return INCHI_PARITY_NONE;
-        }
-    }
-    memset(num_iso_eH, 0, sizeof(num_iso_eH));
-    for ( j = 0; j < at[cur_at].num_bonds; j ++ ) {
-        next = at[cur_at].neighbor[j];
-        switch( pStereo->cAtType[next] ) {
-        case AtType_TermH:
-            if ( 0 <= at[next].isotopic_mass && at[next].isotopic_mass <= NUM_H_ISOTOPES ) {
-                num_iso_eH[at[next].isotopic_mass] ++;
-            } else {
-                num_iso_eH[0] ++;
-            }
-            num_eH ++;
-            break;
-        case AtType_TermD:
-            num_iso_eH[2] ++;
-            num_eH ++;
-            break;
-        case AtType_TermT:
-            num_iso_eH[3] ++;
-            num_eH ++;
-            break;
-        }
-    }
-
-
-    num_H  = inchi_NUMH2(at,cur_at) + num_eH;
-    if ( num_H > NUM_H_ISOTOPES )
-        return 0; /*  at least 2 H atoms are isotopically identical */
-
-    for ( j = 0, num_nH = num_H; j < NUM_H_ISOTOPES; j ++ ) {
-        if ( (k = (int)at[cur_at].num_iso_H[j+1]+(int)num_iso_eH[j+1]) > 1 ) {
-            return INCHI_PARITY_NONE;  /*  two or more identical isotopic H atoms */
-        }
-        num_nH -= k;
-    }
-    /*  at this point num_nH = number of non-isotopic H atoms */
-    if ( num_nH > 1 )
-        return INCHI_PARITY_NONE; /*  two or more identical non-isotopic H atoms */
-    if ( num_nH < 0 )
-        return CT_ISO_H_ERR;  /*  program error */ /*   <BRKPT> */
-
-    /********************************************************************
-     * Note. At this point all (implicit and explicit) isotopic
-     * terminal H neighbors are either different or not present.
-     ********************************************************************/
-
-    /*  store neighbors coordinates */
-    num_z = num_either_single = num_either_double = 0;
-    nNumExplictAttachments = 0;
-    for ( j = 0; j < at[cur_at].num_bonds; j ++ ) {
-        next = at[cur_at].neighbor[j];
-        if ( *bOnlyNonMetal && IS_METAL(pStereo->cAtType[next]) )
-            continue;
-        at_coord[nNumExplictAttachments][0] = at[next].x - at[cur_at].x;
-        at_coord[nNumExplictAttachments][1] = at[next].y - at[cur_at].y;
-        nSbNeighOrigAtNumb[nNumExplictAttachments] = next;
-
-        z = e_get_z_coord( at, cur_at, j /*neighbor #*/, &nType, bPointedEdgeStereo );
-        switch ( nType ) {
-        case ZTYPE_EITHER:
-            num_either_single ++; /*  bond in "Either" direction. */
-            break;
-        case ZTYPE_UP:
-        case ZTYPE_DOWN:
-            z = e_len2( at_coord[nNumExplictAttachments] );
-            /*
-            z = sqrt( at_coord[nNumExplictAttachments][0]*at_coord[nNumExplictAttachments][0]
-                    + at_coord[nNumExplictAttachments][1]*at_coord[nNumExplictAttachments][1] );
-            */
-            if ( nType == ZTYPE_DOWN )
-                z = -z;
-            /*  no break; here */
-        case ZTYPE_3D:
-            num_z ++;
-        }
-        at_coord[nNumExplictAttachments][2] = z;
-        nNumExplictAttachments ++;
-    }
-
-    if ( num_either_single ) {
-        bond_parity =  INCHI_PARITY_UNKNOWN;  /*  single bond is 'unknown' */
-        goto exit_function;
-    }
-
-    /* nNumExplictAttachments is a total number of attachments */
-    if ( nNumExplictAttachments == 2 ) {
-        /*  create coordinates of the implicit hydrogen (or a fictitious atom in case of ==N-X ), */
-        /*  coord[2][], attached to the cur_at. */
-        for ( j = 0; j < 3; j ++ ) {
-            at_coord[2][j] = - ( at_coord[0][j] + at_coord[1][j] );
-        }
-        nSbNeighOrigAtNumb[nNumExplictAttachments] = -1; /* implicit H or lone pair */
-    }
-    for ( j = 0; j < 3; j ++ ) {
-        tmp[j] = e_len3( at_coord[j] );
-    }
-    min_tmp = inchi_min( tmp[0], inchi_min(tmp[1], tmp[2]) );
-    max_tmp = inchi_max( tmp[0], inchi_max(tmp[1], tmp[2]) );
-    if ( min_tmp < MIN_BOND_LEN || min_tmp < MIN_SINE*max_tmp ) {
-        /*  all bonds or some of bonds are too short */
-        goto exit_function; 
-    }
-    /*  normalize lengths to 1 */
-    for ( j = 0; j < 3; j ++ ) {
-        e_mult3( at_coord[j], 1.0/tmp[j], at_coord[j] );
-    }
-
-    /*  find projections of at_coord vector differences on the plane containing their arrowhead ends */
-    for ( j = 0; j < 3; j ++ ) {
-        /*  pnt[0..2] = {0-1, 1-2, 2-0} */
-        tmp[j] = e_len3(e_diff3( at_coord[j], at_coord[(j+1)%3], pnt[j] ));
-        if ( tmp[j] < MIN_SINE ) {
-            goto exit_function; /*  angle #i-cur_at-#j is too small */
-        }
-        e_mult3( pnt[j], 1.0/tmp[j], pnt[j] ); /* 2003-10-06 */
-    }
-    /*  find pnt[p2], a vector perpendicular to the plane, and its length tmp[p2] */
-    /*  replace previous pnt[p2], tmp[p2] with new values; the old values do not have any additional */
-    /*  information because pnt[p0]+pnt[p1]+pnt[p2]=0 */
-    /*  10-6-2003: a cross-product of one pair pnt[j], pnt[(j+1)%3] can be very small. Find the larges one */
-    tmp1 = e_len3( e_cross_prod3( pnt[0], pnt[1], temp ) );
-    for (j = 1, k = 0; j < 3; j ++ ) {
-        tmp2 = e_len3( e_cross_prod3( pnt[j], pnt[(j+1)%3], temp ) );
-        if ( tmp2 > tmp1 ) {
-            tmp1 = tmp2;
-            k     = j;
-        }
-    }
-    /* previously p0=0, p1=1, p2=2 */
-    p0 = k;
-    p1 = (k+1)%3;
-    p2 = (k+2)%3;
-    tmp[p2] = e_len3( e_cross_prod3( pnt[p0], pnt[p1], pnt[p2] ) );
-    if ( tmp[p2] < MIN_SINE*tmp[p0]*tmp[p1]  ) {
-        goto exit_function; /*  pnt[p0] is almost colinear to pnt[p1] */
-    }
-    /*  new basis: pnt[p0], pnt[p1], pnt[p2]; set z-coord sign and make abs(pnt[p2]) = 1 */
-    e_mult3( pnt[p2], (pnt[p2][2]>0.0? 1.0:-1.0)/tmp[p2], pnt[p2] ); /*  unit vector in the new z-axis direction */
-
-    min_tmp = e_dot_prod3( at_coord[0], pnt[p2] ); /*  non-planarity measure (sine): hight of at_coord[] pyramid */
-    e_mult3( pnt[p2], min_tmp, pnt[p0] ); /*  vector height of the pyramid, ideally 0 */
-    /*  find new pnt[p0] = projection of at_coord[p0] on plane orthogonal to pnt[p2] */
-    tmp[p0] = e_len3(e_diff3( at_coord[0], pnt[p0], pnt[p0] ));
-    e_mult3( pnt[p0], 1.0/tmp[p0], pnt[p0] );  /*  new x axis basis vector */
-    e_cross_prod3( pnt[p2], pnt[p0], pnt[p1] ); /*  new y axis basis vector */
-    /*  find at_coord in the new basis of {pnt[p0], pnt[p1], pnt[p2]} */
-    for ( j = 0; j < 3; j ++ ) {
-        e_copy3( at_coord[j], temp );
-        for ( k = 0; k < 3; k ++ ) {
-            at_coord[j][k] = e_dot_prod3( temp, pnt[(k+p0)%3] );
-        }
-        /*  new xy plane projection length */
-        tmp[j] = sqrt(at_coord[j][0]*at_coord[j][0] + at_coord[j][1]*at_coord[j][1]);
-        /*  make new xy plane projection length = 1 */
-        e_mult3( at_coord[j], 1.0/tmp[j], at_coord[j] );
-    }
-   
-    s = fabs( at_coord[1][0]*at_coord[2][1] - at_coord[1][1]*at_coord[2][0] ); /*  1-2 sine */
-    c =       at_coord[1][0]*at_coord[2][0] + at_coord[1][1]*at_coord[2][1];   /*  1-2 cosine */
-    if ( s < MIN_SINE && c > 0.5 ) {
-        goto exit_function; /*  bonds to neigh. 1 and 2 have almost same direction; relative angles are undefined */
-    }
-    c = at_coord[0][0]; /*  cosine of the angle between new Ox axis and a bond to the neighbor 0. Should be 1 */
-    s = at_coord[0][1]; /*  sine. Should be 0 */
-    /*  turn vectors so that vector #1 (at_coord[0]) becomes {1, 0} */
-    for ( j = 0; j < MAX_NUM_STEREO_BOND_NEIGH; j ++ ) {
-        tmp1 =  c*at_coord[j][0] + s*at_coord[j][1];
-        tmp2 = -s*at_coord[j][0] + c*at_coord[j][1];
-        at_coord[j][0] = tmp1;
-        at_coord[j][1] = tmp2;
-    }
-    /*  counterclockwise angles from the direction to neigh 0 to to directions to neighbors 1 and 2: */
-    tmp1 = atan2( at_coord[1][1], at_coord[1][0] ); /*  range -pi and +pi */
-    tmp2 = atan2( at_coord[2][1], at_coord[2][0] );
-    if ( tmp1 < 0.0 )
-        tmp1 += two_pi; /*  range 0 to 2*pi */
-    if ( tmp2 < 0.0 )
-        tmp2 += two_pi;
-    /*-----------------------------------
-                        Example
-      1 \               case tmp1 < tmp2
-         \              parity is odd
-          \             (counterclockwise)
-           A------- 0
-          /
-         /
-      2 /
-
-    ------------------------------------*/
-    bond_parity = 2 - ( tmp1 < tmp2 );
-    for ( j = 0; j < 3; j ++ ) {
-        z_dir[j] = (S_CHAR)(pnt[p2][j]>= 0.0?  floor(0.5 + 100.0 * pnt[p2][j]) :
-                                              -floor(0.5 - 100.0 * pnt[p2][j])); /*  abs(z_dir) = 100 */
-    }
-    /*  check for ambiguity */
-    if ( nNumExplictAttachments > 2 ) {
-        min_tmp = inchi_min( tmp1, tmp2 );
-        max_tmp = inchi_max( tmp1, tmp2 );
-        if ( min_tmp > one_pi-MIN_SINE || max_tmp < one_pi+MIN_SINE || max_tmp-min_tmp > one_pi - MIN_SINE ) {
-            bAmbiguousStereo |= AMBIGUOUS_STEREO;
-        } else /* 3D ambiguity 8-28-2002 */
-        if ( fabs(at_coord[0][2]) > MAX_SINE ) { /*  all fabs(at_coord[j][2] (j=0..2) must be equal */
-            bAmbiguousStereo |= AMBIGUOUS_STEREO;
-        }
-    } else
-    if ( nNumExplictAttachments == 2 ) {  /* 10-6-2003: added */
-        min_tmp = fabs(tmp1 - one_pi);
-        if ( min_tmp < MIN_SINE ) {
-            bond_parity = INCHI_PARITY_UNDEFINED; /* consider as undefined 10-6-2003 */
-        } else
-        if ( min_tmp < MIN_ANGLE_DBOND ) {
-            bAmbiguousStereo |= AMBIGUOUS_STEREO;
-        }
-    }
-
-    /*  for 3 neighbors moving implicit H to the index=0 from index=2 position */
-    /*  can be done in 2 transpositions and does not change atom's parity */
-
-exit_function:
-    return bond_parity;
-}
-
-#define MAX_ALLENE_LEN 20
-/*************************************************************/
-int e_set_stereo_bonds_parity( Stereo0D *pStereo, inchi_Atom *at, int at_1, int bPointedEdgeStereo )
-{
-    int j, k, next_at_1, i_next_at_1, i_next_at_2, at_2, next_at_2, num_stereo_bonds, bFound, bAllene;
-    int bond_type, num_2s_1, num_alt_1, bNxtStereobond, bCurStereobond, bNxtCumulene;
-    int num_stored_stereo_bonds, num_stored_isotopic_stereo_bonds;
-    int chain_length, num_chains, cur_chain_length;
-    int all_at_2[MAX_NUM_STEREO_BONDS];
-    int all_pos_1[MAX_NUM_STEREO_BONDS], all_pos_2[MAX_NUM_STEREO_BONDS];
-    S_CHAR all_unkn[MAX_NUM_STEREO_BONDS], all_chain_len[MAX_NUM_STEREO_BONDS];
-    int    all_middle_at[MAX_NUM_STEREO_BONDS];
-    AT_NUM chain_atoms[MAX_ALLENE_LEN], at_middle;
-    int    nUnknown;
-    int    bOnlyNM1, bOnlyNM2;
-    
-    bCurStereobond = e_bCanAtomHaveAStereoBond( at, at_1, pStereo->cAtType );
-    if ( !bCurStereobond )
-        return 0;
-
-    /*  count bonds and find the second atom on the stereo bond */
-    num_2s_1 = num_alt_1 = 0;
-    chain_length      = 0;
-    num_chains        = 0;
-    for ( i_next_at_1 = 0, num_stereo_bonds = 0; i_next_at_1 < at[at_1].num_bonds; i_next_at_1 ++ ) {
-        
-        at_2 = next_at_1 = at[at_1].neighbor[i_next_at_1];
-        bond_type        = at[at_1].bond_type[i_next_at_1];
-        nUnknown = (at[at_1].bond_stereo[i_next_at_1] == INCHI_PARITY_UNKNOWN);
-        next_at_2 = at_1;
-
-        bNxtStereobond = e_bCanAtomHaveAStereoBond( at, at_2, pStereo->cAtType );
-        bNxtCumulene = 0;
-        cur_chain_length = 0;
-        
-        if ( bNxtStereobond + bCurStereobond > 3 ) {
-            /* this includes single (ring) bonds in -NH-CH=N(+)< that may be deprotonated to -N=C-N< */
-            if ( bond_type == INCHI_BOND_TYPE_TRIPLE ) {
-                continue;
-            }
-            /* possibly stereogenic bond */
-        } else {
-            bNxtCumulene =
-                e_bCanAtomBeMiddleAllene(at_2, pStereo->cAtType ) &&
-                e_bCanAtomBeTerminalAllene( at_1, pStereo->cAtType );
-            if ( !bNxtCumulene ) {
-                continue;
-            }
-            if ( bond_type != INCHI_BOND_TYPE_DOUBLE ) {
-                continue;
-            }
-            /* possibly allene or cumulenr */
-            chain_atoms[cur_chain_length]   = at_1;
-            chain_atoms[cur_chain_length+1] = at_2;
-            
-            /*
-             * Example of cumulene
-             * chain length = 2:     >X=C=C=Y<
-             *                        | | | |
-             *  1st cumulene atom= at_1 | | at_2 =last cumlene chain atom
-             *  next to at_1=   next_at_1 next_at_2  =previous to at_2
-             *
-             *  chain length odd:  stereocenter on the middle atom ( 1=> allene )
-             *  chain length even: "long stereogenic bond"
-             */
-            while ( cur_chain_length < MAX_ALLENE_LEN-3 &&
-                    (bAllene = 
-                    e_bCanAtomBeMiddleAllene( at_2, pStereo->cAtType ))) {
-                k = ((int)at[at_2].neighbor[0]==next_at_2); /*  opposite neighbor position */
-                next_at_2 = at_2;
-                nUnknown += (at[at_2].bond_stereo[k] == INCHI_BOND_STEREO_DOUBLE_EITHER);
-                at_2 = (int)at[at_2].neighbor[k];
-                cur_chain_length ++;  /*  count =C= atoms */
-                chain_atoms[cur_chain_length+1] = at_2;
-            }
-            if ( cur_chain_length ) {
-                if ( bAllene /* at the end of the chain atom Y is =Y=, not =Y< or =Y- */ ||
-                     !e_bCanAtomBeTerminalAllene( at_2, pStereo->cAtType)) {
-                    cur_chain_length = 0;
-                    continue; /*  ignore: does not fit cumulene description; go to check next at_1 neighbor */
-                }
-            }
-            if ( !cur_chain_length &&
-                 !e_bCanAtomHaveAStereoBond( at, at_2, pStereo->cAtType ) ) {
-                    continue; /*  reject non-stereogenic bond to neighbor #i_next_at_1 */
-            }
-        } 
-
-        /*  check atom at the opposite end of possibly stereogenic bond */
-
-        bFound   = ( at_1 > at_2 ); /*  i_next_at_1 = at_1 stereogenic bond neighbor attachment number */
-
-        if ( bFound ) {
-            i_next_at_2 = -1;  /*  unassigned mark */
-            for ( j = 0; j < at[at_2].num_bonds; j ++ ) {
-                if ( (int)at[at_2].neighbor[j] == next_at_2 ) {
-                    i_next_at_2 = j; /*  assigned */
-                    break;
-                }
-            }
-            if ( i_next_at_2 < 0 ) {
-                continue;
-            }
-            /* store the results */
-            all_pos_1[num_stereo_bonds]     = i_next_at_1; /* neighbor to at_1 position */
-            all_pos_2[num_stereo_bonds]     = i_next_at_2; /* neighbor to at_2 position */
-            all_at_2[num_stereo_bonds]      = at_2;        /* at_2 */
-            all_unkn[num_stereo_bonds]      = nUnknown;    /* stereogenic bond has Unknown configuration */
-            /* allene/cumulene stuff */
-            all_chain_len[num_stereo_bonds] = cur_chain_length;
-            all_middle_at[num_stereo_bonds] = (cur_chain_length%2)? chain_atoms[(cur_chain_length+1)/2] : -1; 
-            num_stereo_bonds ++;
-        }
-    }
-    if ( !num_stereo_bonds || num_stereo_bonds > 3 /*|| num_chains > 1*/ ) {
-        return 0; /*  At the end, we cannot be more than 1 cumulene chain. */
-    }
-
-    /* ================== calculate parities ====================== */
-    /*  find possibly stereo bonds and save them */
-    num_stored_isotopic_stereo_bonds = 0;
-    num_stored_stereo_bonds          = 0;
-    for ( k = 0; k < num_stereo_bonds; k ++ ) {
-        /* NM stands for non-metal */
-        int parity_at_1, parity_at_2, parity_at_1NM=0, parity_at_2NM=0, bOnlyNM;
-        S_CHAR z_dir1[3], z_dir2[3], z_dir1NM[3], z_dir2NM[3]; /*  3D vectors for half stereo bond parity direction */
-        int  i_ord_LastMetal1, i_ord_LastMetal2, bAnomaly1NM, bAnomaly2NM;
-        
-        at_2             = all_at_2[k];
-        i_next_at_1      = all_pos_1[k];
-        i_next_at_2      = all_pos_2[k];
-        nUnknown         = all_unkn[k];
-        at_middle        = all_middle_at[k];
-        cur_chain_length = all_chain_len[k];
-        memset(z_dir1, 0, sizeof(z_dir1));
-        memset(z_dir2, 0, sizeof(z_dir2));
-        memset(z_dir1NM, 0, sizeof(z_dir1NM));
-        memset(z_dir2NM, 0, sizeof(z_dir2NM));
-        bOnlyNM1 = bOnlyNM2 = 0;
-        bAnomaly1NM = bAnomaly2NM = 0;
-        i_ord_LastMetal1 = i_ord_LastMetal2 = -1;
-        
-        if ( nUnknown ) {
-            parity_at_1 = parity_at_2 = parity_at_1NM = parity_at_2NM = INCHI_PARITY_UNKNOWN;
-        } else {
-            /***********************************************************************
-             *
-             * Obtain each atom parity from the geometry
-             *
-             * Warning: case when dot-product
-             *          (z_dir1,z_dir1NM) < 0 or (z_dir2,z_dir2NM) < 0
-             *          is not treated proprly.
-             *          This case may happen especially when z_dir?[3] << 100
-             *
-             ***********************************************************************/
-
-            parity_at_1 =  e_half_stereo_bond_parity( at, at_1, z_dir1, &bOnlyNM1, bPointedEdgeStereo, pStereo );
-            parity_at_2 =  e_half_stereo_bond_parity( at, at_2, z_dir2, &bOnlyNM2, bPointedEdgeStereo, pStereo );
-
-            if ( RETURNED_ERROR(parity_at_1) || RETURNED_ERROR(parity_at_2) ) {
-                return CT_CALC_STEREO_ERR;
-            }
-            parity_at_1   = abs(parity_at_1);
-            parity_at_2   = abs(parity_at_2);
-            /* bond parities for the disconnected structure */
-            if ( bOnlyNM1 ) {
-                parity_at_1NM = parity_at_1;
-                memcpy( z_dir1NM, z_dir1, sizeof(z_dir1NM) );
-                parity_at_1    = INCHI_PARITY_NONE;
-            } else
-            if ( at[at_1].num_bonds == e_nNumNonMetalNeigh( at, at_1, pStereo, &i_ord_LastMetal1 ) ) {
-                parity_at_1NM = parity_at_1; /* no metal bond present */
-                memcpy( z_dir1NM, z_dir1, sizeof(z_dir1NM) );
-            } else {
-                bOnlyNM = 1; /* at_1 has a metal neighbor; in adjacency list
-                                it is located in (zero-based) position i_ord_LastMetal1 */
-                parity_at_1NM = e_half_stereo_bond_parity( at, at_1, z_dir1NM, &bOnlyNM,
-                                                           bPointedEdgeStereo, pStereo );
-                if ( RETURNED_ERROR(parity_at_1NM) ) {
-                    return CT_CALC_STEREO_ERR;
-                }
-                parity_at_1NM = abs(parity_at_1NM);
-                /*
-                if ( ATOM_PARITY_WELL_DEF(parity_at_1NM) && !ATOM_PARITY_WELL_DEF(parity_at_1) ) {
-                    memcpy( z_dir1, z_dir1NM, sizeof(z_dir1) );
-                }
-                */
-                if ( ATOM_PARITY_WELL_DEF(parity_at_1NM) && ATOM_PARITY_WELL_DEF(parity_at_1) &&
-                     0 <= i_ord_LastMetal1 ) {
-                    if ( 1 == i_ord_LastMetal1 % 2 && parity_at_1NM == parity_at_1 ||
-                         0 == i_ord_LastMetal1 % 2 && parity_at_1NM != parity_at_1 ) {
-                        /* abnormal geometry: all bonds in a sector < 180 degrees */
-                        /*parity_at_1NM = 3 - parity_at_1;*/
-                        bAnomaly1NM = 1;
-                    } else {
-                        parity_at_1 = parity_at_1NM;
-                        bOnlyNM1 = 1;
-                    }
-                } else
-                if ( ATOM_PARITY_WELL_DEF(parity_at_1NM) && !ATOM_PARITY_WELL_DEF(parity_at_1) &&
-                     0 <= i_ord_LastMetal1 ) {
-                    bAnomaly1NM = 1; /* 2005-02-01 force atom parity from non-metal neighbors */
-                }
-
-            }
-        
-            if ( bOnlyNM2 ) {
-                parity_at_2NM = parity_at_2;
-                memcpy( z_dir2NM, z_dir2, sizeof(z_dir2NM) );
-                parity_at_2    = INCHI_PARITY_NONE;
-            } else
-            if ( at[at_2].num_bonds == e_nNumNonMetalNeigh( at, at_2, pStereo, &i_ord_LastMetal2 ) ) {
-                memcpy( z_dir2NM, z_dir2, sizeof(z_dir2NM) );
-                parity_at_2NM = parity_at_2; /* no metal bond present */
-            } else {
-                bOnlyNM = 1;
-                parity_at_2NM = e_half_stereo_bond_parity( at, at_2, z_dir2NM, &bOnlyNM,
-                                                           bPointedEdgeStereo, pStereo );
-                if ( RETURNED_ERROR(parity_at_2NM) ) {
-                    return CT_CALC_STEREO_ERR;
-                }
-                parity_at_2NM = abs(parity_at_2NM);
-                if ( ATOM_PARITY_WELL_DEF(parity_at_2NM) && ATOM_PARITY_WELL_DEF(parity_at_2) &&
-                     0 <= i_ord_LastMetal2 ) {
-                    if ( 1 == i_ord_LastMetal2 % 2 && parity_at_2NM == parity_at_2 ||
-                         0 == i_ord_LastMetal2 % 2 && parity_at_2NM != parity_at_2 ) {
-                        /* abnormal geometry: all bonds in a sector < 180 degrees */
-                        /*parity_at_2NM = 3 - parity_at_2;*/
-                        bAnomaly2NM = 1;
-                    } else {
-                        parity_at_2 = parity_at_2NM;
-                        bOnlyNM2 = 1;
-                    }
-                } else
-                if ( ATOM_PARITY_WELL_DEF(parity_at_2NM) && !ATOM_PARITY_WELL_DEF(parity_at_2) &&
-                     0 <= i_ord_LastMetal2 ) {
-                    bAnomaly2NM = 1; /* 2005-02-01 force atom parity from non-metal neighbors */
-                }
-            }
-            /* make both atoms have non-metal neighbors only */
-            if ( (bOnlyNM1 || bAnomaly1NM) && ATOM_PARITY_WELL_DEF(parity_at_1NM) &&
-                !(bOnlyNM2 || bAnomaly2NM) && ATOM_PARITY_WELL_DEF(parity_at_2NM) &&
-                0 <= i_ord_LastMetal2 ) {
-                
-                bAnomaly2NM = 1;
-                parity_at_2NM = 2 - (parity_at_2NM + i_ord_LastMetal2) % 2;
-            } else
-            if ( !(bOnlyNM1 || bAnomaly1NM) && ATOM_PARITY_WELL_DEF(parity_at_1NM) &&
-                  (bOnlyNM2 || bAnomaly2NM) && ATOM_PARITY_WELL_DEF(parity_at_2NM) &&
-                0 <= i_ord_LastMetal1 ) {
-                
-                bAnomaly1NM = 1;
-                parity_at_1NM = 2 - (parity_at_1NM + i_ord_LastMetal1) % 2;
-            }
-
-            /* consistency */
-            if ( parity_at_1 == INCHI_PARITY_NONE || parity_at_2 == INCHI_PARITY_NONE ) {
-                parity_at_1 = parity_at_2 = INCHI_PARITY_NONE; /* =zero */
-            } else {
-                switch( !ATOM_PARITY_WELL_DEF( parity_at_1 ) + 2*!ATOM_PARITY_WELL_DEF( parity_at_2 ) ) {
-                case 1:
-                    parity_at_2 = parity_at_1; /* set both to not-well-def */
-                    break;
-                case 2:
-                    parity_at_1 = parity_at_2; /* set both to not-well-def */
-                    break;
-                case 3:
-                    parity_at_1 = parity_at_2 = inchi_min(parity_at_1, parity_at_2);
-                    break;
-                }
-            }
-
-            if ( parity_at_1NM == INCHI_PARITY_NONE || parity_at_2NM == INCHI_PARITY_NONE ) {
-                parity_at_1NM = parity_at_2NM = INCHI_PARITY_NONE; /* =zero */
-            } else {
-                switch( !ATOM_PARITY_WELL_DEF( parity_at_1NM ) + 2*!ATOM_PARITY_WELL_DEF( parity_at_2NM ) ) {
-                case 1:
-                    parity_at_2NM = parity_at_1NM; /* set both to not-well-def */
-                    break;
-                case 2:
-                    parity_at_1NM = parity_at_2NM; /* set both to not-well-def */
-                    break;
-                case 3:
-                    parity_at_1NM = parity_at_2NM = inchi_min(parity_at_1NM, parity_at_2NM);
-                    break;
-                }
-            }
-            if ( parity_at_1 != INCHI_PARITY_NONE && parity_at_1NM == INCHI_PARITY_NONE ) {
-                parity_at_1NM = parity_at_2NM = INCHI_PARITY_UNDEFINED;
-            } else
-            if ( parity_at_1 == INCHI_PARITY_NONE && parity_at_1NM != INCHI_PARITY_NONE ) {
-                parity_at_1 = parity_at_2 = INCHI_PARITY_UNDEFINED;
-            }
-
-
-        
-            if ( (parity_at_1   == INCHI_PARITY_UNDEFINED || parity_at_1   == INCHI_PARITY_NONE) &&
-                 (parity_at_1NM == INCHI_PARITY_UNDEFINED || parity_at_1NM == INCHI_PARITY_NONE) ) {
-                continue;
-            }
-        }
-        parity_at_1 = e_FixSb0DParities( at, pStereo, cur_chain_length, at_middle,
-                                      at_1, i_next_at_1, z_dir1, z_dir1NM, bOnlyNM1, bAnomaly1NM, parity_at_1, parity_at_1NM,
-                                      at_2, i_next_at_2, z_dir2, z_dir2NM, bOnlyNM2, bAnomaly2NM, parity_at_2, parity_at_2NM);
-        num_stored_stereo_bonds += (parity_at_1 != 0);
-
-    }
-    return num_stored_stereo_bonds;
-}
-
-
-/***************************************************************
- * Get stereo atom parity for the current order of attachments
- * The result in at[cur_at].parity is valid for previously removed
- * explicit hydrogen atoms, including isotopic ones, that are located in at_removed_H[]
- * The return value is a calculated parity.
- */
-#define ADD_EXPLICIT_HYDROGEN_NEIGH  1
-#define ADD_EXPLICIT_LONE_PAIR_NEIGH 2
-int e_set_stereo_atom_parity( Stereo0D *pStereo, inchi_Atom *at, int cur_at, int bPointedEdgeStereo )
-{
-    int    j, k, next_at, num_z, j1, nType, num_eH, num_iH, tot_num_iso_H, nMustHaveNumNeigh, bAmbiguousStereo;
-    double z, sum_xyz[3], min_sine, triple_product;
-    double at_coord[MAX_NUM_STEREO_ATOM_NEIGH][3];
-    double bond_len_xy[4], rmax, rmin;
-    double at_coord_center[3];
-    int    parity, out_parity, out_stereo_atom_parity, bAmbiguous = 0, bAddExplicitNeighbor = 0;
-    int    b2D = 0, n2DTetrahedralAmbiguity = 0;
-    AT_NUM nSbNeighOrigAtNumb[MAX_NUM_STEREO_ATOM_NEIGH];
-    S_CHAR num_iso_eH[NUM_H_ISOTOPES+1]; /* count explicit H */
-    
-    out_parity  = out_stereo_atom_parity = INCHI_PARITY_NONE;
-    parity                               = INCHI_PARITY_NONE;
-    bAmbiguousStereo                     = 0;
-    memset(num_iso_eH, 0, sizeof(num_iso_eH));
-    num_eH = 0; /* number of explicit H -- will be found later */
-    num_iH = inchi_NUMH2(at,cur_at); /* implicit H */
-
-    if ( !(nMustHaveNumNeigh = e_bCanInpAtomBeAStereoCenter( cur_at, pStereo->cAtType ) ) ||
-         num_iH > NUM_H_ISOTOPES
-       ) {
-        goto exit_function;
-    }
-    /* find explicit terminal H */
-    memset(num_iso_eH, 0, sizeof(num_iso_eH));
-    for ( j = 0; j < at[cur_at].num_bonds; j ++ ) {
-        next_at = at[cur_at].neighbor[j];
-        switch(pStereo->cAtType[next_at] ) {
-        case AtType_TermH:
-            if ( 0 <= at[next_at].isotopic_mass && at[next_at].isotopic_mass <= NUM_H_ISOTOPES ) {
-                num_iso_eH[at[next_at].isotopic_mass] ++;
-            } else {
-                num_iso_eH[0] ++;
-            }
-            num_eH ++;
-            break;
-        case AtType_TermD:
-            num_iso_eH[2] ++;
-            num_eH ++;
-            break;
-        case AtType_TermT:
-            num_iso_eH[3] ++;
-            num_eH ++;
-            break;
-        }
-    }
-
-    /*  numbers of isotopic H atoms */
-    for ( j = 0, tot_num_iso_H = 0; j < NUM_H_ISOTOPES; j ++ ) {
-        if ( at[cur_at].num_iso_H[j+1] + num_iso_eH[j+1] > 1 ) {
-            goto exit_function; /*  two or more identical hydrogen isotopic neighbors */
-        }
-        tot_num_iso_H += at[cur_at].num_iso_H[j+1] + num_iso_eH[j+1];
-    }
-   
-    /*  number of non-isotopic H atoms */
-    if ( inchi_NUMH2(at,cur_at) + num_eH - tot_num_iso_H > 1 ) {
-        goto exit_function; /*  two or more identical hydrogen non-isotopic neighbors */
-    }
-    
-    /*  coordinates initialization */
-    num_z = 0;
-    sum_xyz[0] = sum_xyz[1] = sum_xyz[2] = 0.0;
-
-    at_coord_center[0] =
-    at_coord_center[1] =
-    at_coord_center[2] = 0.0;
-
-    /*  fill out stereo center neighbors coordinates */
-    /*  and obtain the parity from the geometry */
-
-    /*  add all coordinates of other neighboring atoms */
-    for ( j = j1 = 0; j < at[cur_at].num_bonds; j ++, j1 ++ ) {
-        next_at = at[cur_at].neighbor[j];
-        z = e_get_z_coord( at, cur_at, j, &nType, bPointedEdgeStereo );
-        switch ( nType ) {
-        case ZTYPE_EITHER:
-            parity = INCHI_PARITY_UNKNOWN; /*  unknown parity: bond in "Either" direction. */
-            goto exit_function;
-        case ZTYPE_UP:
-        case ZTYPE_DOWN:
-            b2D ++;
-        case ZTYPE_3D:
-            num_z ++;
-        }
-
-        nSbNeighOrigAtNumb[j1] = next_at+1;
-        at_coord[j1][0] = at[next_at].x-at[cur_at].x;
-        at_coord[j1][1] = at[next_at].y-at[cur_at].y;
-        bond_len_xy[j1] = e_len2(at_coord[j1]);
-        at_coord[j1][2] = (nType==ZTYPE_3D?    z :
-                           nType==ZTYPE_UP?    bond_len_xy[j1] :
-                           nType==ZTYPE_DOWN? -bond_len_xy[j1] : 0.0 );
-    }
-    /* j1 is the number of explicit neighbors (that is, all neighbors except implicit H) */
-
-    b2D = (b2D == num_z && num_z);  /*  1 => two-dimensional */
-
-    if ( MAX_NUM_STEREO_ATOM_NEIGH   != at[cur_at].num_bonds+num_iH &&
-         MAX_NUM_STEREO_ATOM_NEIGH-1 != at[cur_at].num_bonds+num_iH ) {
-        /*  not enough geometry data to find the central atom parity */
-        goto exit_function;
-    }
-    /*  make all vector lengths equal to 1; exit if too short. 9-10-2002 */
-    for ( j = 0; j < j1; j ++ ) {
-        z = e_len3( at_coord[j] );
-        if ( z < MIN_BOND_LEN ) {
-            parity = INCHI_PARITY_UNDEFINED;
-            goto exit_function;
-        }
-#if( STEREO_CENTER_BONDS_NORM == 1 )
-        else {
-            e_mult3( at_coord[j], 1.0/z, at_coord[j] );
-        }
-#endif
-        rmax = j? inchi_max( rmax, z) : z;
-        rmin = j? inchi_min( rmin, z) : z;
-    }
-    if ( rmin / rmax < MIN_SINE ) {
-        /* bond ratio is too small */
-        parity = INCHI_PARITY_UNDEFINED;
-        goto exit_function;
-    }
-    for ( j = 0; j < j1; j ++ ) {
-        e_add3( sum_xyz, at_coord[j], sum_xyz );
-    }
-
-
-
-    /*  here j1 is a number of neighbors including explicit terminal isotopic H */
-    /*  num_iso_eH[0] = number of explicit non-isotopic hydrogen atom neighbors */
-    j = j1;
-    /*  Add Explicit Neighbor */
-    if ( j1 == MAX_NUM_STEREO_ATOM_NEIGH-1 ) {
-        /*  add an explicit neighbor if possible */
-        if ( nMustHaveNumNeigh == MAX_NUM_STEREO_ATOM_NEIGH-1 ) {
-            bAddExplicitNeighbor = ADD_EXPLICIT_LONE_PAIR_NEIGH;
-        } else
-        if ( nMustHaveNumNeigh == MAX_NUM_STEREO_ATOM_NEIGH ) {
-            /*  check whether an explicit non-isotopic hydrogen can be added */
-            /*  to an atom that is a stereogenic atom */
-            bAddExplicitNeighbor = ADD_EXPLICIT_HYDROGEN_NEIGH;
-        }
-    }
-
-    if ( bAddExplicitNeighbor ) {
-        /***********************************************************
-         * May happen only if (j1 == MAX_NUM_STEREO_ATOM_NEIGH-1)
-         * 3 neighbors only, no H-neighbors. Create and add coordinates of an implicit H
-         * or a fake 4th neighbor, that is, a lone pair 
-         */
-        if ( parity == INCHI_PARITY_UNKNOWN ) {
-            goto exit_function;  /*  the user insists the parity is unknown and the isotopic */
-                                 /*  composition of the neighbors does not contradict */
-        } else
-        if ( num_z == 0 || are_3_vect_in_one_plane(at_coord, MIN_SINE) ) {
-            /*  "hydrogen down" rule is needed to resolve an ambiguity */
-            if ( num_z > 0 ) {
-                bAmbiguous |= AMBIGUOUS_STEREO;
-            }
-#if( APPLY_IMPLICIT_H_DOWN_RULE == 1 )  /* { */
-            /*  Although H should be at the top of the list, add it to the bottom. */
-            /*  This will be taken care of later by inverting parity 1<->2 */
-            at_coord[j][0] = 0.0;
-            at_coord[j][1] = 0.0;
-#if( STEREO_CENTER_BONDS_NORM == 1 )
-            at_coord[j][2] = -1.0;
-#else
-            at_coord[j][2] = -(bond_len_xy[0]+bond_len_xy[1]+bond_len_xy[2])/3.0;
-#endif
-#else /* } APPLY_IMPLICIT_H_DOWN_RULE { */
-#if (ALWAYS_SET_STEREO_PARITY == 1)
-            parity =  INCHI_PARITY_EVEN; /*  suppose atoms are pre-sorted (testing) */
-#else
-                parity = INCHI_PARITY_UNDEFINED;
-#endif
-            goto exit_function;
-#endif /* } APPLY_IMPLICIT_H_DOWN_RULE */
-        } else {
-            /*  we have enough information to find implicit hydrogen coordinates */
-            e_copy3( sum_xyz, at_coord[j] );
-            e_change_sign3( at_coord[j], at_coord[j] );
-            z = e_len3( at_coord[j] );
-            rmax = inchi_max( rmax, z );
-            rmin = inchi_min( rmin, z );
-            if ( z < MIN_BOND_LEN || rmin/rmax < MIN_SINE ) {
-                /* the new 4th bond is too short */
-                parity = INCHI_PARITY_UNDEFINED;
-                goto exit_function;
-            }
-#if( STEREO_CENTER_BOND4_NORM == 1 )
-            else {
-                e_mult3( at_coord[j], 1.0/z, at_coord[j] );
-            }
-#endif
-        }
-    } else
-    if ( j1 != MAX_NUM_STEREO_ATOM_NEIGH ) {
-        if ( parity == INCHI_PARITY_UNKNOWN ) {
-            parity = -INCHI_PARITY_UNDEFINED; /*  isotopic composition of H-neighbors contradicts 'unknown' */
-        }
-        goto exit_function;
-    } else /*  j1 == MAX_NUM_STEREO_ATOM_NEIGH */
-    if ( num_z == 0 || e_are_4at_in_one_plane(at_coord, MIN_SINE) ) {
-        /*  all four neighours in xy plane: undefined geometry. */
-        if ( num_z > 0 ) {
-            bAmbiguous |= AMBIGUOUS_STEREO;
-        }
-        if ( parity != INCHI_PARITY_UNKNOWN ) {
-#if (ALWAYS_SET_STEREO_PARITY == 1)
-            parity =  INCHI_PARITY_EVEN; /*  suppose atoms are pre-sorted (testing) */
-#else
-            /* all 4 bonds are in one plain */
-            parity = INCHI_PARITY_UNDEFINED;
-#endif
-        }
-        goto exit_function;
-    }
-    /***********************************************************
-     * At this point we have 4 neighboring atoms.
-     * check for tetrahedral ambiguity in 2D case
-     */
-    if ( b2D ) {
-        if ( 0 < (n2DTetrahedralAmbiguity = e_Get2DTetrahedralAmbiguity( at_coord, bAddExplicitNeighbor )) ) {
-            if ( T2D_WARN & n2DTetrahedralAmbiguity ) {
-                bAmbiguous |= AMBIGUOUS_STEREO;
-            }
-            if ( T2D_UNDF & n2DTetrahedralAmbiguity ) {
-                if ( parity != INCHI_PARITY_UNKNOWN ) {
-#if (ALWAYS_SET_STEREO_PARITY == 1)
-                    parity =  INCHI_PARITY_EVEN; /*  suppose atoms are pre-sorted (testing) */
-#else
-                    parity =  INCHI_PARITY_UNDEFINED; /*  no parity */
-#endif
-                }
-                goto exit_function;
-            }
-        } else
-        if ( n2DTetrahedralAmbiguity < 0 ) {
-            bAmbiguous |= AMBIGUOUS_STEREO_ERROR; /*  error */
-            parity = INCHI_PARITY_UNDEFINED;
-            goto exit_function;
-        }
-    }
-
-    /************************************************************/
-    /*  Move coordinates origin to the neighbor #0 */
-    for ( j = 1; j < MAX_NUM_STEREO_ATOM_NEIGH; j ++ ) {
-        e_diff3(at_coord[j], at_coord[0], at_coord[j]);
-    }
-    e_diff3(at_coord_center, at_coord[0], at_coord_center);
-
-    /********************************************************
-     * find the central (cur_at) atom's parity
-     * (orientation of atoms #1-3 when looking from #0)
-     ********************************************************/
-    triple_product = e_triple_prod_and_min_abs_sine2(&at_coord[1], at_coord_center, bAddExplicitNeighbor, &min_sine, &bAmbiguous);
-    if ( fabs(triple_product) > ZERO_FLOAT && (min_sine > MIN_SINE || fabs(min_sine) > ZERO_FLOAT && (n2DTetrahedralAmbiguity & T2D_OKAY ) ) ) {
-         /* Even => sorted in correct order, Odd=>transposed */
-        parity = triple_product > 0.0? INCHI_PARITY_EVEN : INCHI_PARITY_ODD;
-
-        /*  for 4 attached atoms, moving the implicit H from index=3 to index=0 */
-        /*  can be done in odd number (3) transpositions: (23)(12)(01), which inverts the parity */
-        if ( j1 == MAX_NUM_STEREO_ATOM_NEIGH-1 ) {
-            parity = 3 - parity;
-        }
-    } else {
-#if (ALWAYS_SET_STEREO_PARITY == 1)
-        parity =  AT_PARITY_EVEN; /*  suppose atoms are pre-sorted (testing) */
-#else
-        if ( num_z > 0 ) {
-            bAmbiguous |= AMBIGUOUS_STEREO;
-        }
-        parity =  INCHI_PARITY_UNDEFINED; /*  no parity: 4 bonds are in one plane. */
-#endif
-    }
-exit_function:
-
-    if ( parity ) {
-        bAmbiguousStereo |= bAmbiguous;
-    }
-    /*  isotopic parity => parity */
-    if ( parity < 0 )
-        parity = -parity;
-
-    if ( 0 < parity && parity < INCHI_PARITY_UNDEFINED ) {
-        inchi_Stereo0D *stereo0D;
-        if ( stereo0D = e_GetNewStereo( pStereo ) ) {
-            stereo0D->central_atom = cur_at;
-            stereo0D->parity       = parity;
-            stereo0D->type         = INCHI_StereoType_Tetrahedral;
-            k = 0;
-            if ( at[cur_at].num_bonds == 3 ) {
-                stereo0D->neighbor[k++] = cur_at;
-            }
-            for ( j = 0; j < at[cur_at].num_bonds; j ++ ) {
-                stereo0D->neighbor[k++] = at[cur_at].neighbor[j];
-            }
-        }
-    }
-    return parity;
-
-}
-#undef ADD_EXPLICIT_HYDROGEN_NEIGH
-#undef ADD_EXPLICIT_LONE_PAIR_NEIGH
-
-/*************************************************************/
-inchi_Stereo0D *e_GetNewStereo( Stereo0D *pStereo )
-{
-#define DEFAULT_0D_STEREO_DELTA 64
-    int delta = pStereo->delta_num_stereo0D > 0? pStereo->delta_num_stereo0D : DEFAULT_0D_STEREO_DELTA;
-    if ( pStereo->num_stereo0D >= pStereo->max_num_Stereo0D ) {
-        /*inchi_Stereo0D *pNew = (inchi_Stereo0D *)e_inchi_calloc( pStereo->max_num_Stereo0D + delta, sizeof(pNew[0]) );*/
-        inchi_Stereo0D *pNew = e_CreateInchi_Stereo0D( pStereo->max_num_Stereo0D + delta );
-        if ( pNew ) {
-            if ( pStereo->num_stereo0D > 0 ) {
-                memcpy( pNew, pStereo->stereo0D, pStereo->num_stereo0D * sizeof(pNew[0]) );
-            }
-            /*e_inchi_free(pStereo->stereo0D);*/
-            e_FreeInchi_Stereo0D( &pStereo->stereo0D );
-            pStereo->stereo0D = pNew;
-            pStereo->max_num_Stereo0D += delta;
-        }
-    }
-    return pStereo->stereo0D + pStereo->num_stereo0D ++;
-#undef DEFAULT_0D_STEREO_DELTA
-}
-
-/*************************************************************/
-int set_0D_stereo_parities( inchi_Input *pInp, int bPointedEdgeStereo )
-{
-    int num_3D_stereo_atoms=0, num_stereo_bonds=0;
-
-    int i, is_stereo, num_stereo;
-    inchi_Atom* at      = pInp->atom;
-    int         num_at  = pInp->num_atoms;
-    Stereo0D              stereo;
-    Stereo0D             *pStereo = &stereo;
-
-    /**********************************************************
-     *
-     * Note: this parity reflects only relative positions of
-     *       the atoms-neighbors and their ordering in the
-     *       lists of neighbors.
-     *
-     *       To obtain the actual parity, the parity of a number 
-     *       of neighbors transpositions (to obtain a sorted
-     *       list of numbers assigned to the atoms) should be
-     *       added.
-     *
-     **********************************************************/
-
-    /*********************************************************************************
-
-     An example of parity=1 for stereogenic center, tetrahedral asymmetric atom
-                   
-                       
-                    
-                  (1)
-                   |
-                   |
-               [C] |
-                   |
-         (2)------(0)
-                  /
-                /
-              /
-            /
-         (3)
-         
-
-     Notation: (n) is a tetrahedral atom neighbor; n is an index of a neighbor in
-     the central_at->neighbor[] array : neighbor atom number is central_at->neighbor[n].
-
-     (0)-(1), (0)-(2), (0)-(3) are lines connecting atom [C] neighbors to neighbor (0)
-     (0), (1) and (2) are in the plane
-     (0)-(3) is directed from the plain to the viewer
-     [C] is somewhere between (0), (1), (2), (3)
-     Since (1)-(2)-(3)  are in a clockwise order when looking from (0), parity is 2, or even;
-     otherwise parity would be 1, or odd.
-
-    **********************************************************************************
-    
-      Examples of a stereogenic bond.
-    
-      Notation:   [atom number], (index of a neighbor):
-                  [1] and [2] are atoms connected by the stereogenic bond
-                  numbers in () are indexes of neighbors of [1] or [2].
-                  (12 x 16)z = z-component of [1]-[2] and [1]-[6] cross-product
-
-                                     atom [1]                     atom [2]                   
-     [8]                    [4]      prod01 = (12 x 16)z < 0      prod01 = (21 x 24)z < 0    
-       \                    /        prod02 = (12 x 18)z > 0      prod02 = (21 x 25)z > 0    
-        (2)               (1)        0 transpositions because     0 transpositions because   
-          \              /           double bond is in 0 posit.   double bond is in 0 position
-          [1]==(0)(0)==[2]           0 = (prod01 > prod02)        0 = (prod01 > prod02)
-          /              \                                                                   
-        (1)               (2)        result: parity = 2, even     result: parity=2, even                                
-       /                    \                                                                
-     [6]                    [5]                                                              
-                                                                                             
-                                                                                             
-                                                                                             
-                                     atom [1]                     atom [2]                   
-     [8]                    [5]      prod01 = (12 x 18)z > 0      prod01 = (21 x 24)z > 0    
-       \                    /        prod02 = (12 x 16)z < 0      prod02 = (21 x 25)z < 0    
-        (0)               (2)        2 transpositions to move     1 transposition to move    
-          \              /           at [2] from 2 to 0 pos.      at [1] from 1 to 0 position
-          [1]==(2)(1)==[2]           1 = (prod01 > prod02)        1 = (prod01 > prod02)      
-          /              \                                                                   
-        (1)               (0)        result: parity = (1+2)       result: parity=(1+1)           
-       /                    \        2-(1+2)%2 = 1, odd           2-(1+1)%2 = 2, even
-     [6]                    [4]           
-                                          
-
-    ***********************************************************************************
-    Note: atoms' numbers [1], [2], [4],... are not used to calculate parity at this
-          point. They will be used for each numbering in the canonicalization.
-    Note: parity=3 for a stereo atom means entered undefined bond direction
-          parity=4 for an atom means parity cannot be determined from the given geometry
-    ***********************************************************************************/
-    
-    if ( !at ) {
-        return -1;
-    }
-
-    /*  clear stereo descriptors */
-    memset( pStereo, 0, sizeof(*pStereo) );
-    pStereo->delta_num_stereo0D = num_at;
-    pStereo->cAtType = (S_CHAR *)e_inchi_calloc( num_at, sizeof(pStereo->cAtType[0]) );
-    if (!pStereo->cAtType ) {
-        return -1;
-    }
-    /* atom stereo types */
-    for ( i = 0; i < num_at; i ++ ) {
-        pStereo->cAtType[i] = e_GetElType( at, i );
-    }
-
-        
-
-    /*  calculate stereo descriptors */
-    /* main cycle: set stereo parities */
-    for( i = 0, num_stereo = 0; i < num_at; i ++ ) {
-    
-        if ( is_stereo = e_set_stereo_atom_parity( pStereo, at, i, bPointedEdgeStereo ) ) {
-            num_3D_stereo_atoms += ATOM_PARITY_WELL_DEF( is_stereo );
-            num_stereo          += ATOM_PARITY_WELL_DEF( is_stereo );
-        } else {
-            is_stereo = e_set_stereo_bonds_parity( pStereo, at, i, bPointedEdgeStereo );
-            if ( RETURNED_ERROR( is_stereo ) ) {
-                num_3D_stereo_atoms = is_stereo;
-                is_stereo = 0;
-                break;
-            } else {
-                num_stereo_bonds += is_stereo;
-                num_stereo += is_stereo;
-            }
-        }
-    }
-    /*
-    if ( (nMode & REQ_MODE_SC_IGN_ALL_UU ) 
-    REQ_MODE_SC_IGN_ALL_UU
-    REQ_MODE_SB_IGN_ALL_UU
-    */
-    if ( pStereo->cAtType ) {
-        e_inchi_free( pStereo->cAtType );
-    }
-    if ( pInp->stereo0D ) {
-    }
-
-    pInp->stereo0D     = pStereo->stereo0D;
-    pInp->num_stereo0D = pStereo->num_stereo0D;
-    
-    return RETURNED_ERROR( num_3D_stereo_atoms )? num_3D_stereo_atoms : num_stereo;
-}
-/*****************************************************************/
-int Clear3D2Dstereo(inchi_Input *pInp)
-{
-    int i;
-    if ( !pInp->atom || !pInp->num_atoms )
-        return 0;
-    for ( i = 0; i < pInp->num_atoms; i ++ ) {
-        pInp->atom[i].x =
-        pInp->atom[i].y =
-        pInp->atom[i].z = 0.0;
-        memset( pInp->atom[i].bond_stereo, 0, sizeof(pInp->atom[i].bond_stereo) );
-    }
-    return 1;
-}
-