rino 0.1.0 → 0.2.0

data/ext/src/ichirvrs.h

@@ -0,0 +1,882 @@
+/*
+ * International Union of Pure and Applied Chemistry (IUPAC)
+ * International Chemical Identifier (InChI)
+ * Version 1
+ * Software version 1.01
+ * July 21, 2006
+ * Developed at NIST
+ */
+
+#ifndef __ICHIRVRS_H__
+#define __ICHIRVRS_H__
+
+#define ICHICONST      const
+
+#define RI_ERR_ALLOC   (-1)
+#define RI_ERR_SYNTAX  (-2)
+#define RI_ERR_PROGR   (-3)
+#define RI_ERR_EOL     (-4)
+#define RI_ERR_EOF     (0)
+
+
+#define NO_VALUE_INT    9999
+#define NOT_READ_INT    9998 /* has not been read yet */
+
+#define VALUE_OCTET    8     /* number of electrons in a full shell */
+
+#define INC_EDGE_LIST_DEFAULT  64
+
+typedef struct tagXYZCoord {
+    double xyz[3];
+} XYZ_COORD;
+
+typedef struct tagStructRestoreMode {
+    int bMetalAddFlower;       /* 1 => allow adjustable metal valence and charge; 0=> use std charge/valence */
+    /* the following three apply only if bMetalAddFlower = 1 */
+    int nMetalMinBondOrder;    /* edge_flow=f means bond order=cMetalMinBondOrder+f */
+    int nMetalInitEdgeFlow;    /* one bond contribution to metal's (st-cap - st-flow) = */
+                               /*   (nMetalInitBondOrder-nMetalMinBondOrder) - nMetalInitEdgeFlow */
+    int nMetalInitBondOrder;   /* >= nMetalMinBondOrder + nMetalInitEdgeFlow */
+    /* same for metal-endpoint bonds */
+    int nMetal2EndpointMinBondOrder;
+    int nMetal2EndpointInitBondOrder;
+    int nMetal2EndpointInitEdgeFlow;
+    int nMetalFlowerParam_D;      /* additional edge capacity for canceling radicals */
+    int nMetalMaxCharge_D;        /* cap and/or flow for metal charge group */
+    int bStereoRemovesMetalFlag;  /* 1=> treat stereogenic atoms and atoms connected by a stereo bond as non-metals */
+
+    int bFixStereoBonds;       /* 1=> forbid stereogenic double bonds from changing */
+} SRM;
+
+typedef struct tagReversedInChI {
+    PINChI2     *pINChI[INCHI_NUM];
+    PINChI_Aux2 *pINChI_Aux[INCHI_NUM];
+    int          num_components[INCHI_NUM];
+    int          nRetVal;
+} REV_INCHI;
+
+/**************************************/
+#define BFS_Q_CLEAR  (-1)
+#define BFS_Q_FREE   (-2)
+typedef struct tagBfsQueue {
+    QUEUE   *q;
+    AT_RANK *nAtomLevel;
+    S_CHAR  *cSource;
+    int      num_at;
+    AT_RANK  min_ring_size;  /* 8 => detect 7-member and smaller rings */
+} BFS_Q;
+/**************************************/
+
+#define EXTRACT_STRUCT_NUMBER 1
+
+/* additional Mobile-H parities to be added to Fixed-H parities  */
+/* This allows to set parities that exist in Mobile-H layer only */
+typedef struct tagInpAtomAddParities {
+    /* cml 0D parities */
+    S_CHAR        bUsed0DParity;          /* bit=1 => stereobond; bit=2 => stereocenter */
+    /* cml tetrahedral parity */
+    S_CHAR        p_parity;
+    AT_NUMB       p_orig_at_num[MAX_NUM_STEREO_ATOM_NEIGH];
+    /* cml bond parities */
+    S_CHAR        sb_ord[MAX_NUM_STEREO_BONDS];  /* stereo bond/neighbor ordering number, starts from 0 */
+    /* neighbors on both sides of stereobond have same sign=> trans/T/E, diff. signs => cis/C/Z */
+    S_CHAR        sn_ord[MAX_NUM_STEREO_BONDS]; /* ord. num. of the neighbor adjacent to the SB; starts from 0;
+                                                   -1 means removed explicit H */
+    /* neighbors on both sides of stereobond have same parity => trans/T/E/2, diff. parities => cis/C/Z/1 */
+    S_CHAR        sb_parity[MAX_NUM_STEREO_BONDS];
+    AT_NUMB       sn_orig_at_num[MAX_NUM_STEREO_BONDS]; /* orig. at number of sn_ord[] neighbors */
+} inp_ATOM_STEREO;
+
+#define FIX_STEREO_BOND_ORDER  0   /* 1=> fix stereobonds; treat metal as non-metal if it is stereogenic or has a stereobond */
+
+#define METAL_FREE_CHARGE_VAL  1  /* 1=> allow free changing charges/valences of metals; initial bond order=0 or 1 */
+#define ALLOW_METAL_BOND_ZERO  1  /* 1=> allow zero flow (bobd order) to metals */
+
+#if ( ALLOW_METAL_BOND_ZERO == 1 )
+/* INIT_METAL_BOND_ZERO=1 => INIT_METAL_BOND_FLOW=0 */
+#define INIT_METAL_BOND_ZERO   0  /* 1=> initialize zero order bond to metals */
+#define INIT_METAL_BOND_FLOW   1  /* 1=> init flow=1, 0 => init. flow = 0 */
+#else
+#define INIT_METAL_BOND_ZERO   0
+#define INIT_METAL_BOND_FLOW   0  /* always 0 */
+#endif
+
+#define I2A_FLAG_FIXEDH  0x0001
+#define I2A_FLAG_RECMET  0x0002
+
+#define EL_NUMBER_H  1
+
+
+#define ATYPE_H   1
+#define ATYPE_Na  2
+#define ATYPE_Mg  3
+#define ATYPE_B   4
+#define ATYPE_C   5
+#define ATYPE_N   6
+#define ATYPE_O   7
+#define ATYPE_Cl  8
+
+
+/* first  bonds valence for charge = c is cValence[0][c+VAL_BASE]; VAL_MIN_CHARGE <= c <= VAL_MAX_CHARGE */
+/* second bonds valence for charge = c is cValence[1][c+VAL_BASE]; VAL_MIN_CHARGE <= c <= VAL_MAX_CHARGE */
+/* total number of valences is 2 = VAL_NUMBER */
+/* neutral bond valence orders are cValence[0][VAL_NEUTR_ORDER], cValence[1][VAL_NEUTR_ORDER] */
+#define VAL_BASE         ( 1)
+#define VAL_MIN_CHARGE   (-1)
+#define VAL_MAX_CHARGE   ( 1)
+#define VAL_NUMBER       ( 2)
+#define VAL_NEUTR_ORDER  (VAL_MAX_CHARGE-VAL_MIN_CHARGE+1)
+#define VAL_LENGTH       (VAL_NEUTR_ORDER+1)      
+#define VAL_NEGAT_CHARGE    0
+#define VAL_NEUTR_CHARGE    1
+#define VAL_POSIT_CHARGE    2
+
+typedef struct tagAtomIonPrperies {
+    /* char cValence[VAL_NUMBER][VAL_LENGTH]; */ /* ordering numbers of minimal valence, 0-based */
+    char   cDoNotAddH;         /* InChI does not add H to this element */
+    char   cMetal;             /* the element is a metal */
+    char   cNumBondsToMetal;   /* number of bonds to metal */
+    char   cInitFlowToMetal;    /* sum of init flow to metal atoms */
+    char   cInitValenceToMetal; /* sum of init adjusted bond orders to metal atoms */
+    char   cInitOrigValenceToMetal; /* sum of init bond orders to metal atoms */
+    char   cMaxFlowToMetal;    /* max total edge flow to metal atoms */
+    char   cInitFreeValences;  /* number of 'dots' to connect; charges are marked separately */
+    S_CHAR cInitCharge;        /* initial charge on the atom (not included in ChargeStruct */
+    char   cNumValenceElectrons;
+    char   cPeriodicRowNumber;
+    char   cMinRingSize;       /* min ring size for atoms that have 2 bonds only */
+    U_CHAR cPeriodicNumber;  /* number in Periodic Table of elements */
+    S_CHAR cnListIndex;        /* (index in the cnList) + 1; 0 => none */
+    int    nCMinusGroupEdge;   /* (index of the edge to the atom's (-) group) + 1 */
+    int    nCPlusGroupEdge;    /* (index of the edge to the atom's (+) group) + 1 */
+    int    nMetalGroupEdge;    /* index of the edge to the atom's M-group + 1 */
+    int    nTautGroupEdge;     /* index of the edge from the atom to the t-group + 1 */
+} VAL_AT;
+
+
+/******************************************************************************************************/
+#define INI_NUM_TCGROUPS 16
+#define INC_NUM_TCGROUPS 16
+
+typedef enum tagTgRestoreFlags {
+    TGRF_MINUS_FIRST = 1
+} TGRF;
+typedef struct tagTCGroup {
+    int type;    /* group type */
+    int ord_num; /* ordering number within the type, typically t-group number */
+    int num_edges;
+    /* charge group specific */
+    int st_cap;
+    int st_flow;
+    int edges_cap;
+    int edges_flow;
+    int nVertexNumber; /* group vertex number; 0 = unassigned */
+    int nForwardEdge;  /* edge index: from c-group to central Y-connecting vertex
+                          or from supergroup to (+/-) vertex; 0 => unassigned */
+    int nBackwardEdge; /* edge index: from central Y-connecting vertex
+                          to supergroup; 0 => unassigned */
+    /* tautomeric group specific */
+    short tg_num_H;      /* number of H in a tautomeric group */
+    short tg_num_Minus;  /* negative charge on t-group */
+    Vertex tg_set_Minus;  /* the vertex+1 that has to have (-) */
+    short tg_RestoreFlags; /* Set (-) to first memberst of a t-group (usually, N) */ 
+} TC_GROUP;
+
+typedef enum tagTCGroupTypes {
+    TCG_None = -1, /* so far only ord=0 is used */
+                   /* group type      ord */
+    TCG_Plus0 = 0, /* BNS_VT_C_POS      0 */
+    TCG_Plus1,     /* BNS_VT_C_POS      1 */
+    TCG_Minus0,    /* BNS_VT_C_NEG      0 */
+    TCG_Minus1,    /* BNS_VT_C_NEG      1 */
+    TCG_Plus_C0,   /* BNS_VT_C_POS_C    0 */
+    TCG_Plus_C1,   /* BNS_VT_C_POS_C    1 */
+    TCG_Minus_C0,  /* BNS_VT_C_NEG_C    0 */
+    TCG_Minus_C1,  /* BNS_VT_C_NEG_C    1 */
+    TCG_Plus_M0,   /* BNS_VT_C_POS_M    0 */
+    TCG_Plus_M1,   /* BNS_VT_C_POS_M    1 */
+    TCG_Minus_M0,  /* BNS_VT_C_NEG_M    0 */
+    TCG_Minus_M1,  /* BNS_VT_C_NEG_M    1 */
+    TCG_MeFlower0, /* BNS_VT_M_GROUP    0 */  /* base */
+    TCG_MeFlower1, /* BNS_VT_M_GROUP    1 */
+    TCG_MeFlower2, /* BNS_VT_M_GROUP    2 */
+    TCG_MeFlower3, /* BNS_VT_M_GROUP    3 */
+
+    TCG_Plus,      /* BNS_VT_C_POS_ALL  0 */
+    TCG_Minus,     /* BNS_VT_C_NEG_ALL  0 */
+
+    NUM_TCGROUP_TYPES /* number of group types */
+}TCGR_TYPE;
+
+typedef struct tagAllTCGroups {
+    TC_GROUP *pTCG;
+    int      num_tc_groups; /* number of charge groups and metal-flower vertices */
+    int      max_tc_groups; /* number of allocated of pTCG[] elements */
+    int      nGroup[NUM_TCGROUP_TYPES];  /* tagTCGroupTypes */
+    int      nVertices;  /* total number of vertices */
+    int      nEdges;     /* total number of edges */
+    int      nAddIedges; /* additional increase of number of iedges for edge switching to another group */
+    int      num_atoms;  /* number of atoms */
+    int      num_bonds;  /* number of bonds */
+    int      num_tgroups;       /* number t-groups */
+    int      num_tgroup_edges;  /* number of edges to t-groups */
+    /* charges */
+    int      tgroup_charge;     /* total charge of all t-groups */
+    int      charge_on_atoms;   /* charge permanently sitting on atoms */
+    int      added_charge;      /* charge added to the c-groups */
+    int      total_charge;      /* total charge of the component */
+    int      total_electrons;   /* total number of electrons on all atoms */
+    int      total_electrons_metals; /* total number of electrons on unbonded metals */
+
+    int      num_metal_atoms;   /* number of metal atoms */
+    int      num_metal_bonds;   /* number of atom-metal bonds */
+    /* excess_charge = total_charge - added_charge - tgroup_charge: add to metals etc. */
+
+    int      nEdge4charge;      /* edge used to add charges; neighbor1=supercharge, another = (+/-) vertex */
+    int      nEdgePlus;         /* edge to (+) supergroup; 0 means none */
+    int      nEdgeMinus;        /* edge to (-) supergroup; 0 means none */ 
+    int      iComponent;        /* component number */
+    int      iAtNoOffset;       /* first atom number -- always 0 for now */
+} ALL_TC_GROUPS;
+
+/**************************************/
+#define EDGE_LIST_CLEAR  (-1)
+#define EDGE_LIST_FREE   (-2)
+
+typedef struct tagEdgeList {
+    int num_alloc;
+    int num_edges;
+    EdgeIndex *pnEdges;
+} EDGE_LIST;
+/**************************************/
+
+#define BOND_MARK_STEREO 0x10
+#define BOND_TYPE_STEREO (BOND_TYPE_SINGLE | BOND_MARK_STEREO)
+
+/* local */
+#define RESET_EDGE_FORBIDDEN_MASK 0
+
+#define TREAT_ATOM_AS_METAL 99
+
+
+/************************************************************************************/
+typedef struct tagChargeValence {
+    int nValence;
+    int nCharge;
+    int nValenceOrderingNumber;
+} CHARGE_VAL;
+
+#define MY_CONST  const
+/*************************************************************************************/
+typedef struct tagChargeChangeCandidate {
+    Vertex iat;
+    char   num_bonds;
+    char   chem_valence;
+    char   cMetal;
+    char   cNumBondsToMetal;
+    char   cNumValenceElectrons;
+    char   cPeriodicRowNumber;
+    char   cNumChargeStates;
+    U_CHAR el_number;
+} CC_CAND;
+
+typedef struct tagOneComponentRemovedAndExchangeableH {
+    NUM_H   nNumRemovedProtons;
+    NUM_H   nNumRemovedIsotopicH[NUM_H_ISOTOPES]; /* isotopic H that may be exchanged and considered
+                                                     randomly distributed, including removed protons */
+} COMPONENT_REM_PROTONS;
+
+typedef struct tagRemovedAndExchangeableH {
+    /* totals for Mobile-H layer */
+    NUM_H   nNumRemovedProtons;
+    NUM_H   nNumRemovedIsotopicH[NUM_H_ISOTOPES]; /* isotopic H that may be exchanged and considered
+                                                     randomly distributed, including removed protons */
+    /* for individual components from comparing Fixed-H vs Mobile-H formulas; NULL if not available */
+    COMPONENT_REM_PROTONS *pNumProtons;
+} REM_PROTONS;
+
+typedef struct tagInputInChI {
+    INChI      *pInpInChI[INCHI_NUM][TAUT_NUM];
+    int         nNumComponents[INCHI_NUM][TAUT_NUM];
+    REM_PROTONS nNumProtons[INCHI_NUM][TAUT_NUM];
+    int         s[INCHI_NUM][TAUT_NUM][2];  /* s[0=non-iso, 1=iso] = 0,1,2,3 <= regular /s; -1=> "/s" (empty) */
+    long        num_inp;
+    inp_ATOM   *atom;      /* the whole restored structure made out of all components */
+    int         num_atoms; /* number of atoms including explicit H */
+    int         num_explicit_H; /* number of explicit H in the atom */
+    INCHI_MODE  CompareInchiFlags[INCHI_NUM][TAUT_NUM];
+} InpInChI;
+
+typedef struct tagStructFromInChI {
+    /* InChI component -> Structure result */
+    inp_ATOM        *at;  /* length = num_atoms + num_deleted_H, zero pint struct for BNS->struct conversion */
+    inp_ATOM_STEREO *st;  /* additional stereo that exists only in Mobile-H layer */
+    inp_ATOM        *at2; /* length = num_atoms + num_deleted_H, the conversion result */
+    
+    /* information from InChI only */
+    T_GROUP_INFO  ti; /* from original InChI[0] if Mobile-H from the beginning or later from InChI[1] if Fixed-H  */
+    AT_NUMB      *endpoint; /* from original InChI[1] in case of Fixed-H only */
+    S_CHAR       *fixed_H;  /* from original InChI[0] in case of Fixed-H only */
+    XYZ_COORD    *pXYZ;
+    int           num_atoms;
+    int           num_deleted_H; /* if requested and Fixed-H InChI is available */
+    int           nNumRemovedProtonsMobHInChI; /* number of protons removed from Mobile-H struct in original InChI */
+    S_CHAR        charge;
+    char          bIsotopic;
+    
+    /* InChI -> Structure conversion parms and intermediate data */
+    BN_STRUCT *pBNS;
+    BN_DATA   *pBD;
+    ICHICONST SRM       *pSrm;
+    
+    /* InChI layer to reverse */
+    char        bMobileH;
+    char        iINCHI;
+    char        bFixedHExists; /* fixed-H InChI exists or not */
+    
+    /* InChI -> Struct component -> Full InChI result (both disconnected and connected if exist) */
+    REV_INCHI  RevInChI;
+    int        nRemovedProtonsByNormFromRevrs; /* number of H(+) removed by normalization after
+                                                 Struct Restore and before Add/Remove Protons */
+    int        nNumRemovedProtonsByRevrs;       /* number of H(+) removed by the reconstruction,
+                                                   before Add/Remove Protons, only from TAUT_YES */
+    
+    int        bExtract; /* for debugging */
+
+    /* single component InChI calculation */
+    INChI         *pOneINChI[TAUT_NUM];       /* InChI of restored structure */
+    INChI_Aux     *pOneINChI_Aux[TAUT_NUM];
+    INP_ATOM_DATA *pOne_norm_data[TAUT_NUM];  /* normalized restored structure */
+    S_CHAR        *pOne_fixed_H;              /* !!! from normalized restored structure in case of Fixed-H only */
+    T_GROUP_INFO   One_ti;                    /* t-groups of normalized canonicalized restored structure */
+    int            nOneINChI_bMobileH;        /* type of restored structure InChI */
+    int            nNumRemovedProtons;        /* =0 for Fixed-H, = num. removed protons in case of Mobile-H InChI */
+                                              /* in case of Fixed-H processing see pStruct->One_ti.tni.nNumRemovedProtons */
+    AT_NUMB       *nAtno2Canon[TAUT_NUM];     /* nAtno2Canon[restored_at_no][*] = (atom canon number in restored struct)-1*/
+    AT_NUMB       *nCanon2Atno[TAUT_NUM];     /* nCanon2Atno[(atom canon number in restored struct)-1][*] = restored_at_no; */
+
+    int            nError;
+    /* other parms */
+    char        iInchiRec; /* index in the original InChI array */
+    char        iMobileH;  /* index in the original InChI array */
+    char        bDeleted;  /* InChI component marked as Deleted, means a proton in Mobile-H layer */
+    /* struct. ordering number "Structure: nnn" if present */
+    long        num_inp_actual;
+
+    /* utility data */
+    BFS_Q   *pbfsq;
+    VAL_AT  *pVA;
+
+    int   nLink; /* same as in INChI */
+    int   bPostProcessed; /* recalculate after add/remove protons */
+
+    /* TAUT_YES layer charges */
+    int nChargeRevrs;  /* component charge of the reconstructed structure, TAUT_YES layer */
+    int nChargeInChI;  /* component charge from the original InChI, TAUT_YES layer */
+} StrFromINChI;
+
+
+#define EL_TYPE_O     0x0001
+#define EL_TYPE_S     0x0002
+#define EL_TYPE_N     0x0004
+#define EL_TYPE_P     0x0008
+#define EL_TYPE_C     0x0010
+#define EL_TYPE_X     0x0020 /* any not metal */
+#define EL_TYPE_MASK  0x003f
+#define EL_TYPE_OSt   0x0100 /* terminal -OH, -O(-), -SH, -S(-), ... from fix_special_bonds(...) */
+#define EL_TYPE_PT    0x0200 /* may be a tautomeric endpoint */
+
+/* the atom to which the node is attached has number 1; added atoms have numbers 2,3,... */
+#define MAX_CN_VAL 3
+typedef struct tagVertCapFlow {
+    S_SHORT type;
+    S_CHAR  cap;
+    S_CHAR  flow;
+    S_CHAR  valence;
+} VCF;
+typedef struct tagEdgeCapFlow {
+    S_SHORT neigh;
+    S_CHAR  cap;
+    S_CHAR  bForbiddenEdge;
+    S_CHAR  flow;
+} ECF;
+typedef struct tagChargeNodes {
+    VCF v;
+    ECF e[MAX_CN_VAL];
+} C_NODE;
+
+
+#define cn_bits_N  1  /* Neutral: charge =  0 */
+#define cn_bits_P  2  /* Plus 1:  charge = +1 */
+#define cn_bits_M  4  /* Minus 1: charge = -1 */
+#define cn_bits_shift 3
+#define MAX_NUM_CN_BITS 4
+#define MAKE_CN_BITS(A, B, C, D ) (( (( ((D) << cn_bits_shift | (C)) << cn_bits_shift ) | (B)) << cn_bits_shift ) | (A))
+
+#define cn_bits_PNPN MAKE_CN_BITS(cn_bits_P, cn_bits_N, cn_bits_P, cn_bits_N)
+#define cn_bits_NPNP MAKE_CN_BITS(cn_bits_N, cn_bits_P, cn_bits_N, cn_bits_P)
+#define cn_bits_NPN MAKE_CN_BITS(cn_bits_N, cn_bits_P, cn_bits_N, 0)
+#define cn_bits_PNP MAKE_CN_BITS(cn_bits_P, cn_bits_N, cn_bits_P, 0)
+#define cn_bits_MNP  MAKE_CN_BITS(cn_bits_M, cn_bits_N, cn_bits_P, 0)
+#define cn_bits_PNM  MAKE_CN_BITS(cn_bits_P, cn_bits_N, cn_bits_M, 0)
+#define cn_bits_EN  MAKE_CN_BITS(cn_bits_P | cn_bits_M, cn_bits_N, 0, 0)
+#define cn_bits_NMN  MAKE_CN_BITS(cn_bits_N, cn_bits_M, cn_bits_N, 0)
+#define cn_bits_NE  MAKE_CN_BITS(cn_bits_N, cn_bits_P | cn_bits_M, 0, 0)
+#define cn_bits_NEN  MAKE_CN_BITS(cn_bits_N, cn_bits_M | cn_bits_N, cn_bits_N, 0)
+#define cn_bits_NP  MAKE_CN_BITS(cn_bits_N, cn_bits_P, 0, 0)
+#define cn_bits_PN  MAKE_CN_BITS(cn_bits_P, cn_bits_N, 0, 0)
+#define cn_bits_NM  MAKE_CN_BITS(cn_bits_N, cn_bits_M, 0, 0)
+#define cn_bits_MN  MAKE_CN_BITS(cn_bits_M, cn_bits_N, 0, 0)
+#define cn_bits_P_  MAKE_CN_BITS(cn_bits_P, 0, 0, 0)
+#define cn_bits_M_  MAKE_CN_BITS(cn_bits_M, 0, 0, 0)
+#define cn_bits_N_  MAKE_CN_BITS(cn_bits_N, 0, 0, 0)
+#define cn_bits_Me (-1)
+
+#define cnListIndexMe (17)  /* index of {cnMe, cn_bits_Me,... } element of cnList[] */
+
+extern int cnListNumEl;  /* number of elements in cnList[] */
+
+typedef struct tagChargeNodeList {
+    MY_CONST C_NODE *pCN;
+             int     bits;
+             int     nInitialCharge;
+             int     len;
+} CN_LIST;
+
+extern MY_CONST CN_LIST cnList[];
+
+/************************ fixed H comparison ******************************************************/
+#define MAX_DIFF_FIXH 256
+#define MAX_DIFF_MOBH 256
+typedef struct tagAtomsCmpTwoFixedH {
+    AT_NUMB endptInChI;
+    AT_NUMB endptRevrs;
+    AT_NUMB atomNumber;
+    U_CHAR nValElectr;
+    U_CHAR nPeriodNum;
+    S_CHAR nFixHInChI;
+    S_CHAR nFixHRevrs;
+    S_CHAR nMobHInChI;
+    S_CHAR nMobHRevrs;
+    S_CHAR nNumHRevrs;
+    S_CHAR nAtChargeRevrs;
+    S_CHAR nValue; /* flag(s) */
+} CMP2FHATOMS;
+
+typedef struct tagStructCmpTwoFixedH {
+    CMP2FHATOMS c2at[MAX_DIFF_FIXH];
+    short  len_c2at;
+    short  nNumRemHInChI;
+    short  nNumRemHRevrs;
+    short  nNumTgInChI;
+    short  nNumTgRevrs;
+    short  nNumEndpInChI;
+    short  nNumEndpRevrs;
+    short  nNumTgDiffMinus; /* number of would-be-identical t-groups that have different number of (-) */
+    short  nNumTgDiffH;     /* number of would-be-identical t-groups that have different number of H */
+    short  nNumTgMInChI;    /* number of (-) in orig. InChI t-groups */
+    short  nNumTgHInChI;    /* number of H in orig. InChI t-groups */
+    short  nNumTgMRevrs;    /* number of (-) in reversed structure t-groups */
+    short  nNumTgHRevrs;    /* number of H in reversed structure t-groups */
+    S_CHAR nChargeFixHInChI;
+    S_CHAR nChargeMobHInChI;
+    S_CHAR nChargeFixHRevrs;
+    S_CHAR nChargeMobHRevrs;
+    S_CHAR nChargeFixHRevrsNonMetal; /* charge does not include charges on metals */
+    S_CHAR nChargeMobHRevrsNonMetal; /* charge does not include charges on metals */
+    char   bFixedHLayerExistsRevrs;
+    char   bHasDifference;
+    U_CHAR nNumDiffMobH;
+
+} CMP2FHINCHI;
+
+/************************ Mobile H comparison *********************************************/
+typedef struct tagAtomsCmpTwoMobileH {
+    AT_NUMB endptInChI;
+    AT_NUMB endptRevrs;
+    AT_NUMB atomNumber;
+    U_CHAR nValElectr;
+    U_CHAR nPeriodNum;
+    S_CHAR nMobHInChI; /* number of H on the atom in the orig. InChI */
+    S_CHAR nMobHRevrs; /* number of H on the atom in InChI from the reconstructed structure */
+    S_CHAR nNumHRevrs; /* number of H on the atom in the being reconstructed structure */
+    S_CHAR nAtChargeRevrs;
+    S_CHAR nValue;         /* flag(s) */
+} CMP2MHATOMS;
+
+typedef struct tagStructCmpTwoMobileH {
+    CMP2MHATOMS c2at[MAX_DIFF_FIXH];
+    short len_c2at;
+    short nNumRemHInChI;
+    short nNumRemHRevrs;
+    short nNumTgInChI;
+    short nNumTgRevrs;
+    short nNumEndpInChI;
+    short nNumEndpRevrs;
+    short nNumTgDiffMinus;   /* number of would-be-identical t-groups that have different number of (-) */
+    short nNumTgDiffH;       /* number of would-be-identical t-groups that have different number of H */
+    
+    short nNumTgMInChI;      /* number of (-) in orig. InChI t-groups */
+    short nNumTgHInChI;      /* number of H in orig. InChI t-groups */
+    short nNumTgOInChI;      /* number of tautomeric O,S,Se in orig. InChI t-groups */
+    short nNumTgNInChI;      /* number of tautomeric N in orig. InChI t-groups */
+
+    short nNumTgMRevrs;      /* number of (-) in reversed structure t-groups */
+    short nNumTgHRevrs;      /* number of H in reversed structure t-groups */
+    short nNumTgORevrs;      /* number of tautomeric O,S,Se in reversed structure t-groups */
+    short nNumTgNRevrs;       /* number of tautomeric N in reversed structure t-groups */
+    
+    short nNumTgOMinusRevrs;   /* number of -O(-)  on endpoints found in restored structure */
+    short nNumTgOHRevrs;       /* number of -OH    on endpoints found in restored structure */
+    short nNumTgDBORevrs;      /* number of =O     on endpoints found in restored structure */
+    short nNumTgNMinusRevrs;   /* number of -N(-)- on endpoints found in restored structure */
+    short nNumTgNHMinusRevrs;  /* number of -NH(-) on endpoints found in restored structure */
+    short nNumTgNHRevrs;       /* number of -NH-   on endpoints found in restored structure */
+    short nNumTgNH2Revrs;      /* number of -NH2   on endpoints found in restored structure */
+    short nNumTgDBNHRevrs;     /* number of =NH    on endpoints found in restored structure */
+    short nNumTgDBNMinusRevrs; /* number of =N(-)  on endpoints found in restored structure */
+    short nNumTgDBNRevrs;      /* number of =N-    on endpoints found in restored structure */
+
+    short nNumTgOMinusInChI;   /* number of -O(-)  on endpoints according to original InChI */
+    short nNumTgOHInChI;       /* number of -OH    on endpoints according to original InChI */
+    short nNumTgDBOInChI;      /* number of =O     on endpoints according to original InChI */
+    short nNumTgNMinusInChI;   /* number of -N(-)- on endpoints according to original InChI */
+    short nNumTgNHMinusInChI;  /* number of -NH(-) on endpoints according to original InChI */
+    short nNumTgNHInChI;       /* number of -NH-   on endpoints according to original InChI */
+    short nNumTgNH2InChI;      /* number of -NH2   on endpoints according to original InChI */
+    short nNumTgDBNHInChI;     /* number of =NH    on endpoints according to original InChI */
+    short nNumTgDBNMinusInChI; /* number of =N(-)  on endpoints according to original InChI */
+    short nNumTgDBNInChI;      /* number of =N-    on endpoints according to original InChI */
+
+    S_CHAR nChargeMobHInChI;
+    S_CHAR nChargeMobHRevrs;
+    S_CHAR nChargeMobHRevrsNonMetal; /* charge does not include charges on metals; later add ion pairs rejection */
+    char   bFixedHLayerExistsRevrs;
+    char   bHasDifference;
+    U_CHAR nNumDiffMobH;
+} CMP2MHINCHI;
+
+
+#ifndef INCHI_ALL_CPP
+#ifdef __cplusplus
+extern "C" {
+#endif
+#endif
+
+int OneInChI2Atom( ICHICONST INPUT_PARMS *ip, STRUCT_DATA *sd, const char *szCurHdr, long num_inp,
+                   StrFromINChI *pStruct, int iComponent, int iAtNoOffset, int bHasSomeFixedH, INChI *pInChI[]);
+int get_sp_element_type( int nPeriodicNumber, int *nRow );
+int get_bonds_valences( int nPeriodicNum, int bonds_valence, int num_H, VAL_AT *pVA );
+
+
+/* local prototypes */
+int AddExplicitDeletedH( inp_ATOM *at, int jv, int num_at, int *iDeletedH, int *iH, int nNumDeletedH, int bTwoStereo );
+int bFindCumuleneChain( inp_ATOM *at, AT_NUMB i1, AT_NUMB i2, AT_NUMB nCumulene[], int nMaxLen );
+int set_bond_type( inp_ATOM *at, AT_NUMB i1, AT_NUMB i2, int bType );
+int set_cumulene_0D_parity( inp_ATOM *at, inp_ATOM_STEREO *st, int num_at, int idelH1, int i1, int i2, int idelH2, int parity, int len );
+int set_atom_0D_parity( inp_ATOM *at, inp_ATOM_STEREO *st, int num_at, int num_deleted_H, int i1, int parity );
+int GetTgroupInfoFromInChI( T_GROUP_INFO *ti, inp_ATOM *at, AT_NUMB *endpoint, INChI *pInChI );
+int FillOutpStructEndpointFromInChI( INChI *pInChI, AT_NUMB **pEndpoint );
+int SetStereoBondTypeFor0DParity( inp_ATOM *at, int i1, int m1 );
+int SetStereoBondTypesFrom0DStereo( StrFromINChI *pStruct, INChI *pInChI);
+void CopyAt2St( inp_ATOM *at, inp_ATOM_STEREO * st, int num_atoms );
+void CopySt2At( inp_ATOM *at, inp_ATOM_STEREO * st, int num_atoms );
+int RestoreAtomConnectionsSetStereo( StrFromINChI *pStruct, int iComponent, int iAtNoOffset, INChI *pInChI, INChI *pInChIMobH);
+int RestoreAtomMakeBNS( ICHICONST INPUT_PARMS *ip, STRUCT_DATA *sd, StrFromINChI *pStruct, int iComponent,
+                        int iAtNoOffset, INChI *pInChI[], const char *szCurHdr, long num_inp, int bHasSomeFixedH );
+int nAddSuperCGroups( ALL_TC_GROUPS *pTCGroups );
+
+int AddCGroups2TCGBnStruct( BN_STRUCT *pBNS, StrFromINChI *pStruct, VAL_AT *pVA,
+                            ALL_TC_GROUPS *pTCGroups, int nMaxAddEdges );
+int AddTGroups2TCGBnStruct( BN_STRUCT *pBNS, StrFromINChI *pStruct, VAL_AT *pVA,
+                            ALL_TC_GROUPS *pTCGroups, int nMaxAddEdges );
+BN_STRUCT* AllocateAndInitTCGBnStruct( StrFromINChI *pStruct, VAL_AT *pVA,
+                                       ALL_TC_GROUPS *pTCGroups,
+                                       int nMaxAddAtoms, int nMaxAddEdges,
+                                       int max_altp, int *pNum_changed_bonds );
+int nCountBnsSizes( inp_ATOM *at, int num_at, int nAddEdges2eachAtom, int nAddVertices,
+                    T_GROUP_INFO *ti, VAL_AT *pVA, ICHICONST SRM *pSrm, ALL_TC_GROUPS *pTCGroups );
+int GetAtomRestoreInfo( inp_ATOM *atom, int iat, VAL_AT *pVArray, ICHICONST SRM *pSrm, int bMobileH, AT_NUMB *endpoint );
+int AddEdgeFlow( int edge_cap, int edge_flow, BNS_EDGE *e01, BNS_VERTEX *pv0 /*src*/,
+                  BNS_VERTEX *pv1/*dest*/, int *tot_st_cap, int *tot_st_flow );
+void SetEdgeCapFlow( BNS_EDGE *e, int edge_cap, int edge_flow );
+
+void AddStCapFlow( BNS_VERTEX *vert_ficpoint, int *tot_st_flow, int *tot_st_cap, int cap, int flow );
+void SetStCapFlow( BNS_VERTEX *vert_ficpoint, int *tot_st_flow, int *tot_st_cap, int cap, int flow );
+
+int ConnectSuperCGroup( int nTCG_Plus, int nAddGroups[], int num_add,
+                   int *pcur_num_vertices, int *pcur_num_edges,
+                   int *tot_st_cap, int *tot_st_flow,
+                   BN_STRUCT *pBNS, ALL_TC_GROUPS *pTCGroups );
+int ConnectTwoVertices( BNS_VERTEX *p1, BNS_VERTEX *p2, BNS_EDGE *e, BN_STRUCT *pBNS, int bClearEdge );
+
+int nTautEndpointEdgeCap( inp_ATOM *at, VAL_AT *pVA, int i );
+
+/*
+int GetAtomBondFlow( inp_ATOM *atom, VAL_AT *pVA, ICHICONST SRM *pSrm, int iat, int ineigh );
+void GetAtomStCapFlow( inp_ATOM *atom, VAL_AT *pVA, ICHICONST SRM *pSrm, int iat, int *pCap, int *pFlow );
+int GetAtomToMCGroupInitEdgeCapFlow( EdgeFlow *nEdgeCap, EdgeFlow *nEdgeFlow, ICHICONST SRM *pSrm, inp_ATOM *at, VAL_AT *pVA, int iat );
+void GetAtomToMetalInitEdgeCapFlow( EdgeFlow *nEdgeCap, EdgeFlow *nEdgeFlow );
+*/
+int AtomStcapStflow( inp_ATOM *atom, VAL_AT *pVA, ICHICONST SRM *pSrm, int iat, int *pnStcap, int *pnStflow,
+                     EdgeFlow *pnMGroupEdgeCap, EdgeFlow *pnMGroupEdgeFlow );
+int BondFlowMaxcapMinorder( inp_ATOM *atom, VAL_AT *pVA, ICHICONST SRM *pSrm, int iat, int ineigh,
+                            int *pnMaxcap, int *pnMinorder, int *pbNeedsFlower );
+
+
+
+int clean_charge_val( CHARGE_VAL *pChargeVal, int len, inp_ATOM *atom, VAL_AT *pVA, int iat, int bIsMetal, int bMobileH, AT_NUMB *endpoint );
+int ReallocTCGroups( ALL_TC_GROUPS *pTCGroups, int nAdd );
+int RegisterTCGroup( ALL_TC_GROUPS *pTCGroups, int nGroupType, int nGroupOrdNum,
+                     int nVertexCap, int nVertexFlow, int nEdgeCap, int nEdgeFlow, int nNumEdges);
+int CopyBnsToAtom( StrFromINChI *pStruct, BN_STRUCT  *pBNS, VAL_AT *pVA, ALL_TC_GROUPS *pTCGroups, int bAllowZeroBondOrder );
+int CheckBnsConsistency( StrFromINChI *pStruct, BN_STRUCT  *pBNS, VAL_AT *pVA, ALL_TC_GROUPS *pTCGroups, int bNoRad );
+
+int RunBnsRestore1( ICHICONST INPUT_PARMS *ip, STRUCT_DATA *sd, BN_STRUCT *pBNS, BN_DATA *pBD, StrFromINChI *pStruct,
+                    VAL_AT *pVA, ALL_TC_GROUPS *pTCGroups, INChI *pInChI[], long num_inp, int bHasSomeFixedH);
+int RunBnsRestoreOnce( BN_STRUCT *pBNS, BN_DATA *pBD, VAL_AT *pVA, ALL_TC_GROUPS *pTCGroups );
+int nNumEdgesToCnVertex( MY_CONST C_NODE *pCN, int len, int v );
+int ConnectMetalFlower( int *pcur_num_vertices, int *pcur_num_edges,
+                        int *tot_st_cap, int *tot_st_flow, ICHICONST SRM *pSrm,
+                        BN_STRUCT *pBNS, ALL_TC_GROUPS *pTCGroups );
+int AddRadicalToMetal( int *tot_st_cap, int *tot_st_flow, ICHICONST SRM *pSrm, BN_STRUCT *pBNS, ALL_TC_GROUPS *pTCGroups );
+int bMayBeACationInMobileHLayer( inp_ATOM *at, VAL_AT *pVA, int iat, int bMobileH );
+
+int MakeOneInChIOutOfStrFromINChI( ICHICONST INPUT_PARMS *ip, STRUCT_DATA *sd, StrFromINChI *pStruct, inp_ATOM *at2, inp_ATOM *at3, ALL_TC_GROUPS *pTCGroups );
+void IncrZeroBondsAndClearEndpts(inp_ATOM *at, int num_at, int iComponent);
+void IncrZeroBonds(inp_ATOM *at, int num_at, int iComponent );
+void ClearEndpts(inp_ATOM *at, int num_at );
+int DisplayRestoredComponent( StrFromINChI *pStruct, int iComponent, int iAtNoOffset, INChI *pInChI, const char *szCurHdr );
+int cmp_charge_val( const void *a1, const void *a2 );
+
+int EvaluateChargeChanges( BN_STRUCT *pBNS, VAL_AT *pVA, int *pnDeltaH, int *pnDeltaCharge, int *pnNumVisitedAtoms );
+int RunBnsTestOnce( BN_STRUCT *pBNS, BN_DATA *pBD, VAL_AT *pVA, Vertex *pvFirst, Vertex *pvLast,
+                    int *pPathLen, int *pnDeltaH, int *pnDeltaCharge, int *pnNumVisitedAtoms  );
+int comp_cc_cand( const void *a1, const void *a2 );
+int MoveRadToAtomsAddCharges( BN_STRUCT *pBNS, BN_DATA *pBD, StrFromINChI *pStruct,
+                    inp_ATOM *at, inp_ATOM *at2, VAL_AT *pVA, ALL_TC_GROUPS *pTCGroups, int forbidden_mask );
+void RemoveForbiddenBondFlowBits( BN_STRUCT *pBNS, int forbidden_edge_mask_int );
+int PlusFromDB_N_DB_O_to_Metal(BN_STRUCT *pBNS, BN_DATA *pBD, StrFromINChI *pStruct,
+                     inp_ATOM *at, inp_ATOM *at2, VAL_AT *pVA, ALL_TC_GROUPS *pTCGroups,
+                     int *pnNumRunBNS, int *pnTotalDelta, int forbidden_edge_mask);
+int AdjustTgroupsToForbiddenEdges2( BN_STRUCT *pBNS, inp_ATOM *at, VAL_AT *pVA, int num_atoms, int forbidden_mask );
+int AllocEdgeList( EDGE_LIST *pEdges, int nLen );
+int AddToEdgeList( EDGE_LIST *pEdges, int iedge, int nAddLen );
+int RemoveFromEdgeListByIndex( EDGE_LIST *pEdges, int index );
+int RemoveFromEdgeListByValue( EDGE_LIST *pEdges, int iedge );
+int FindInEdgeList( EDGE_LIST *pEdges, int iedge );
+int AllocBfsQueue( BFS_Q *pQ, int num_at, int min_ring_size );
+void RemoveForbiddenEdgeMask( BN_STRUCT *pBNS, EDGE_LIST *pEdges, int forbidden_edge_mask );
+void SetForbiddenEdgeMask( BN_STRUCT *pBNS, EDGE_LIST *pEdges, int forbidden_edge_mask );
+int ForbidCarbonChargeEdges( BN_STRUCT *pBNS, ALL_TC_GROUPS *pTCGroups, EDGE_LIST *pCarbonChargeEdges, int forbidden_edge_mask );
+int ForbidMetalCarbonEdges( BN_STRUCT *pBNS, inp_ATOM *at, int num_at, VAL_AT *pVA,
+                           ALL_TC_GROUPS *pTCGroups, EDGE_LIST *pMetalCarbonEdges, int forbidden_edge_mask );
+int ForbidNintrogenPlus2BondsInSmallRings( BN_STRUCT *pBNS, inp_ATOM *at, int num_at,
+                                           VAL_AT *pVA, int min_ring_size, ALL_TC_GROUPS *pTCGroups,
+                                           EDGE_LIST *pNplus2BondsEdges, int forbidden_edge_mask );
+int RearrangePlusMinusEdgesFlow( BN_STRUCT *pBNS, BN_DATA *pBD, VAL_AT *pVA,
+                                 ALL_TC_GROUPS *pTCGroups, int forbidden_edge_mask );
+int IncrementZeroOrderBondsToHeteroat( BN_STRUCT *pBNS, BN_DATA *pBD, StrFromINChI *pStruct,
+                                            inp_ATOM *at, inp_ATOM *at2,
+                                            VAL_AT *pVA, ALL_TC_GROUPS *pTCGroups,
+                                            int *pnNumRunBNS, int *pnTotalDelta,
+                                            int forbidden_edge_mask);
+int MoveChargeFromHeteroatomsToMetals( BN_STRUCT *pBNS, BN_DATA *pBD, StrFromINChI *pStruct,
+                                       inp_ATOM *at, inp_ATOM *at2,
+                                       VAL_AT *pVA, ALL_TC_GROUPS *pTCGroups,
+                                       int *pnNumRunBNS, int *pnTotalDelta,
+                                       int forbidden_edge_mask);
+int EliminateChargeSeparationOnHeteroatoms( BN_STRUCT *pBNS, BN_DATA *pBD, StrFromINChI *pStruct,
+                                            inp_ATOM *at, inp_ATOM *at2,
+                                            VAL_AT *pVA, ALL_TC_GROUPS *pTCGroups,
+                                            int *pnNumRunBNS, int *pnTotalDelta,
+                                            int forbidden_edge_mask, int forbidden_stereo_edge_mask);
+int MovePlusFromS2DiaminoCarbon( BN_STRUCT *pBNS, BN_DATA *pBD, StrFromINChI *pStruct,
+                    inp_ATOM *at, inp_ATOM *at2,
+                    VAL_AT *pVA, ALL_TC_GROUPS *pTCGroups,
+                    int *pnNumRunBNS, int *pnTotalDelta, int forbidden_edge_mask);
+int RestoreCyanoGroup( BN_STRUCT *pBNS, BN_DATA *pBD, StrFromINChI *pStruct,
+                     inp_ATOM *at, inp_ATOM *at2, VAL_AT *pVA, ALL_TC_GROUPS *pTCGroups,
+                     int *pnNumRunBNS, int *pnTotalDelta, int forbidden_edge_mask);
+int RestoreIsoCyanoGroup( BN_STRUCT *pBNS, BN_DATA *pBD, StrFromINChI *pStruct,
+                     inp_ATOM *at, inp_ATOM *at2, VAL_AT *pVA, ALL_TC_GROUPS *pTCGroups,
+                     int *pnNumRunBNS, int *pnTotalDelta, int forbidden_edge_mask);
+int RestoreNNNgroup( BN_STRUCT *pBNS, BN_DATA *pBD, StrFromINChI *pStruct,
+                     inp_ATOM *at, inp_ATOM *at2, VAL_AT *pVA, ALL_TC_GROUPS *pTCGroups,
+                     int *pnNumRunBNS, int *pnTotalDelta, int forbidden_edge_mask);
+int FixMetal_Nminus_Ominus( BN_STRUCT *pBNS, BN_DATA *pBD, StrFromINChI *pStruct,
+                     inp_ATOM *at, inp_ATOM *at2, VAL_AT *pVA, ALL_TC_GROUPS *pTCGroups,
+                     int *pnNumRunBNS, int *pnTotalDelta, int forbidden_edge_mask);
+int EliminateNitrogen5Val3Bonds(BN_STRUCT *pBNS, BN_DATA *pBD, StrFromINChI *pStruct,
+                     inp_ATOM *at, inp_ATOM *at2, VAL_AT *pVA, ALL_TC_GROUPS *pTCGroups,
+                     int *pnNumRunBNS, int *pnTotalDelta, int forbidden_edge_mask);
+int Convert_SIV_to_SVI(BN_STRUCT *pBNS, BN_DATA *pBD, StrFromINChI *pStruct,
+                     inp_ATOM *at, inp_ATOM *at2, VAL_AT *pVA, ALL_TC_GROUPS *pTCGroups,
+                     int *pnNumRunBNS, int *pnTotalDelta, int forbidden_edge_mask);
+int MoveMobileHToAvoidFixedBonds(BN_STRUCT *pBNS, BN_DATA *pBD, StrFromINChI *pStruct,
+                              inp_ATOM *at, inp_ATOM *at2, VAL_AT *pVA, ALL_TC_GROUPS *pTCGroups,
+                              int *pnNumRunBNS, int *pnTotalDelta, int forbidden_edge_mask);
+int RemoveRadFromMobileHEndpoint(BN_STRUCT *pBNS, BN_DATA *pBD, StrFromINChI *pStruct,
+                              inp_ATOM *at, inp_ATOM *at2, VAL_AT *pVA, ALL_TC_GROUPS *pTCGroups,
+                              int *pnNumRunBNS, int *pnTotalDelta, int forbidden_edge_mask);
+int RemoveRadFromMobileHEndpointFixH(BN_STRUCT *pBNS, BN_DATA *pBD, StrFromINChI *pStruct,
+                              inp_ATOM *at, inp_ATOM *at2, VAL_AT *pVA, ALL_TC_GROUPS *pTCGroups,
+                              int *pnNumRunBNS, int *pnTotalDelta, int forbidden_edge_mask);
+int MoveChargeToMakeCenerpoints(BN_STRUCT *pBNS, BN_DATA *pBD, StrFromINChI *pStruct,
+                              inp_ATOM *at, inp_ATOM *at2, VAL_AT *pVA, ALL_TC_GROUPS *pTCGroups,
+                              int *pnNumRunBNS, int *pnTotalDelta, int forbidden_edge_mask);
+int CheckAndRefixStereobonds(BN_STRUCT *pBNS, BN_DATA *pBD, StrFromINChI *pStruct,
+                              inp_ATOM *at, inp_ATOM *at2, VAL_AT *pVA, ALL_TC_GROUPS *pTCGroups,
+                              int *pnNumRunBNS, int *pnTotalDelta, int forbidden_edge_mask);
+int MoveChargeToRemoveCenerpoints(BN_STRUCT *pBNS, BN_DATA *pBD, StrFromINChI *pStruct,
+                              inp_ATOM *at, inp_ATOM *at2, VAL_AT *pVA, ALL_TC_GROUPS *pTCGroups,
+                              int *pnNumRunBNS, int *pnTotalDelta, int forbidden_edge_mask);
+int MakeSingleBondsMetal2ChargedHeteroat(BN_STRUCT *pBNS, BN_DATA *pBD, StrFromINChI *pStruct,
+                              inp_ATOM *at, inp_ATOM *at2, VAL_AT *pVA, ALL_TC_GROUPS *pTCGroups,
+                              int *pnNumRunBNS, int *pnTotalDelta, int forbidden_edge_mask);
+int SaltBondsToCoordBonds(BN_STRUCT *pBNS, BN_DATA *pBD, StrFromINChI *pStruct,
+                          inp_ATOM *at, inp_ATOM *at2, VAL_AT *pVA, ALL_TC_GROUPS *pTCGroups,
+                          int *pnNumRunBNS, int *pnTotalDelta, int forbidden_edge_mask);
+int FixLessHydrogenInFormula( BN_STRUCT *pBNS, BN_DATA *pBD, StrFromINChI *pStruct, inp_ATOM *at,
+                              inp_ATOM *at2, inp_ATOM *atf, VAL_AT *pVA, ALL_TC_GROUPS *pTCGroups,
+                              int *pnNumRunBNS, int *pnTotalDelta, int forbidden_edge_mask );
+int FixMoreHydrogenInFormula( BN_STRUCT *pBNS, BN_DATA *pBD, StrFromINChI *pStruct, inp_ATOM *at,
+                              inp_ATOM *at2, inp_ATOM *atf, VAL_AT *pVA, ALL_TC_GROUPS *pTCGroups,
+                              int *pnNumRunBNS, int *pnTotalDelta, int forbidden_edge_mask );
+int FixAddProtonForADP( BN_STRUCT *pBNS, BN_DATA *pBD, StrFromINChI *pStruct, inp_ATOM *at,
+                              inp_ATOM *at2, inp_ATOM *atf, VAL_AT *pVA, ALL_TC_GROUPS *pTCGroups, ICR *picr,
+                              int *pnNumRunBNS, int *pnTotalDelta, int forbidden_edge_mask );
+int ConnectDisconnectedH( inp_ATOM *at, int num_atoms, int num_deleted_H );
+int DisconnectedConnectedH( inp_ATOM *at, int num_atoms, int num_deleted_H );
+int MakeInChIOutOfStrFromINChI2( ICHICONST INPUT_PARMS *ip_inp, STRUCT_DATA *sd_inp, StrFromINChI *pStruct,
+                                 int iComponent, int iAtNoOffset, long num_inp );
+int GetChargeFlowerUpperEdge( BN_STRUCT *pBNS, VAL_AT *pVA, int nChargeEdge );
+int get_pVA_atom_type( VAL_AT *pVA, inp_ATOM *at, int iat, int bond_type );
+
+int NormalizeAndCompare(ICHICONST INPUT_PARMS *ip, STRUCT_DATA *sd, BN_STRUCT *pBNS, BN_DATA *pBD,
+                        StrFromINChI *pStruct, inp_ATOM *at, inp_ATOM *at2, inp_ATOM *at3, VAL_AT *pVA,
+                        ALL_TC_GROUPS *pTCGroups, INChI *pInChI[], long num_inp, int bHasSomeFixedH,
+                        int *pnNumRunBNS, int *pnTotalDelta, int forbidden_edge_mask, int forbidden_stereo_edge_mask);
+/* call InChI normalization only */
+int NormalizeStructure( ICHICONST INPUT_PARMS *ip, STRUCT_DATA *sd, BN_STRUCT *pBNS, 
+                        StrFromINChI *pStruct, inp_ATOM *at, inp_ATOM *at2,
+                        VAL_AT *pVA, ALL_TC_GROUPS *pTCGroups,
+                        inp_ATOM *at_norm, inp_ATOM *at_fixed_bonds_out, T_GROUP_INFO *t_group_info );
+/* create one InChI */
+int MakeOneInChIOutOfStrFromINChI2( ICHICONST INPUT_PARMS *ip, STRUCT_DATA *sd, BN_STRUCT *pBNS, StrFromINChI *pStruct,
+                                    inp_ATOM *at, inp_ATOM *at2, inp_ATOM *at3, VAL_AT *pVA, ALL_TC_GROUPS *pTCGroups,
+                                    T_GROUP_INFO **t_group_info, inp_ATOM **at_norm, inp_ATOM **at_prep );
+/* fixed-H */
+int  FillOutExtraFixedHDataRestr( StrFromINChI *pStruct );
+int  FillOutExtraFixedHDataInChI( StrFromINChI *pStruct, INChI *pInChI[] );
+int FixFixedHRestoredStructure(ICHICONST INPUT_PARMS *ip, STRUCT_DATA *sd, BN_STRUCT *pBNS, BN_DATA *pBD,
+                        StrFromINChI *pStruct, inp_ATOM *at, inp_ATOM *at2, inp_ATOM *at3, VAL_AT *pVA,
+                        ALL_TC_GROUPS *pTCGroups, T_GROUP_INFO **ti, inp_ATOM **at_norm, inp_ATOM **at_prep,
+                        INChI *pInChI[], long num_inp, int bHasSomeFixedH, int *pnNumRunBNS, int *pnTotalDelta,
+                        int forbidden_edge_mask, int forbidden_stereo_edge_mask);
+int FixRemoveExtraTautEndpoints( BN_STRUCT *pBNS, BN_DATA *pBD, StrFromINChI *pStruct, inp_ATOM *at,
+                              inp_ATOM *at2, inp_ATOM *atf, inp_ATOM *atn, VAL_AT *pVA, ALL_TC_GROUPS *pTCGroups, ICR *picr,
+                              int *pnNumRunBNS, int *pnTotalDelta, int forbidden_edge_mask );
+int FillOutCMP2FHINCHI( StrFromINChI *pStruct, inp_ATOM *at2, VAL_AT *pVA, INChI *pInChI[], CMP2FHINCHI *pc2i );
+int FillOutCMP2MHINCHI( StrFromINChI *pStruct, ALL_TC_GROUPS *pTCGroups, inp_ATOM *at2,
+                        VAL_AT *pVA, INChI *pInChI[], CMP2MHINCHI *pc2i );
+
+int bHas_N_V( inp_ATOM *at2, int num_atoms );
+
+int GetPlusMinusVertex( BN_STRUCT *pBNS, ALL_TC_GROUPS *pTCGroups, int bCheckForbiddenPlus, int bCheckForbiddenMinus );
+int FixMobileHRestoredStructure(ICHICONST INPUT_PARMS *ip, STRUCT_DATA *sd, BN_STRUCT *pBNS, BN_DATA *pBD,
+                        StrFromINChI *pStruct, inp_ATOM *at, inp_ATOM *at2, inp_ATOM *at3, VAL_AT *pVA,
+                        ALL_TC_GROUPS *pTCGroups, T_GROUP_INFO **ppt_group_info, inp_ATOM **ppat_norm,
+                        inp_ATOM **ppat_prep, INChI *pInChI[], long num_inp, int bHasSomeFixedH,
+                        int *pnNumRunBNS, int *pnTotalDelta, int forbidden_edge_mask, int forbidden_stereo_edge_mask);
+
+int FixRestoredStructureStereo( INCHI_MODE cmpInChI, ICR *icr, INCHI_MODE cmpInChI2, ICR *icr2,
+                        ICHICONST INPUT_PARMS *ip, STRUCT_DATA *sd, BN_STRUCT *pBNS, BN_DATA *pBD,
+                        StrFromINChI *pStruct, inp_ATOM *at, inp_ATOM *at2, inp_ATOM *at3, VAL_AT *pVA,
+                        ALL_TC_GROUPS *pTCGroups, T_GROUP_INFO **ppt_group_info, inp_ATOM **ppat_norm,
+                        inp_ATOM **ppat_prep, INChI *pInChI[], long num_inp,
+                        int *pnNumRunBNS, int *pnTotalDelta, int forbidden_edge_mask, int forbidden_stereo_edge_mask);
+
+int AddRemProtonsInRestrStruct( ICHICONST INPUT_PARMS *ip,  STRUCT_DATA *sd, long num_inp,
+                                int bHasSomeFixedH,
+                                StrFromINChI *pStruct, int num_components,
+                                StrFromINChI *pStructR, int num_componentsR,
+                                NUM_H *pProtonBalance, int *recmet_change_balance );
+int AllInchiToStructure( ICHICONST INPUT_PARMS *ip, STRUCT_DATA *sd, long num_inp, char *szCurHdr,
+                         ICHICONST SRM *pSrm, int bReqNonTaut, StrFromINChI *pStruct[INCHI_NUM][TAUT_NUM],
+                         InpInChI *pOneInput );
+int AddProtonAndIsoHBalanceToMobHStruct( ICHICONST INPUT_PARMS *ip, STRUCT_DATA *sd,
+                                        long num_inp, int bHasSomeFixedH, char *szCurHdr,
+                             StrFromINChI *pStruct[INCHI_NUM][TAUT_NUM], InpInChI *pOneInput);
+int InChI2Atom( ICHICONST INPUT_PARMS *ip,  STRUCT_DATA *sd, const char *szCurHdr, long num_inp,
+                StrFromINChI *pStruct, int iComponent, int iAtNoOffset, int  bI2A_Flag, int bHasSomeFixedH, InpInChI *pOneInput);
+
+int MarkDisconectedIdenticalToReconnected ( InpInChI *pOneInput );
+void RemoveFixHInChIIdentical2MobH( InpInChI *pOneInput );
+void SetUpSrm( SRM *pSrm );
+void FreeInpInChI( InpInChI *pOneInput );
+void FreeStrFromINChI( StrFromINChI *pStruct[INCHI_NUM][TAUT_NUM], int nNumComponents[INCHI_NUM][TAUT_NUM] );
+int OldPrintCompareOneOrigInchiToRevInChI(StrFromINChI *pStruct, INChI *pInChI[TAUT_NUM], int bMobileH,
+                                          int iComponent, long num_inp, char *szCurHdr);
+int CompareOneOrigInchiToRevInChI(StrFromINChI *pStruct, INChI *pInChI[TAUT_NUM], int bMobileH, int iComponent,
+                                  long num_inp, char *szCurHdr,
+                                  COMPONENT_REM_PROTONS *nCurRemovedProtons, INCHI_MODE CompareInchiFlags[]);
+int CompareTwoPairsOfInChI( INChI *pInChI1[TAUT_NUM], INChI *pInChI2[TAUT_NUM],
+                            int bMobileH, INCHI_MODE CompareInchiFlags[] );
+INCHI_MODE CompareReversedINChI3( INChI *i1 /* InChI from reversed struct */, INChI *i2 /* input InChI */,
+                                  INChI_Aux *a1, INChI_Aux *a2, int *err );
+INCHI_MODE CompareReversedStereoINChI3( INChI_Stereo *s1/* InChI from reversed struct */, INChI_Stereo *s2 /* input InChI */, ICR *picr);
+int CompareAllOrigInchiToRevInChI(StrFromINChI *pStruct[INCHI_NUM][TAUT_NUM], InpInChI *pOneInput, int bReqNonTaut,
+                                  long num_inp, char *szCurHdr);
+int CompareAllDisconnectedOrigInchiToRevInChI(StrFromINChI *pStruct[INCHI_NUM][TAUT_NUM],
+                                              InpInChI *pOneInput, int bHasSomeFixedH,
+                                              long num_inp, char *szCurHdr);
+int insertions_sort_AT_NUMB( AT_NUMB *base, int num );
+
+int AddRemIsoProtonsInRestrStruct( ICHICONST INPUT_PARMS *ip,  STRUCT_DATA *sd, long num_inp, int bHasSomeFixedH,
+                                StrFromINChI *pStruct, int num_components,
+                                StrFromINChI *pStructR, int num_componentsR,
+                                NUM_H pProtonBalance[], NUM_H recmet_change_balance[] );
+int OutputInChIOutOfStrFromINChI( ICHICONST INPUT_PARMS *ip_inp, STRUCT_DATA *sd_inp, long num_inp,
+                                  INCHI_FILE *pout, INCHI_FILE *plog, InpInChI *pOneInput, int bHasSomeFixedH );
+
+int MergeStructureComponents( ICHICONST INPUT_PARMS *ip, STRUCT_DATA *sd, long num_inp, char *szCurHdr,
+                         ICHICONST SRM *pSrm, int bReqNonTaut, StrFromINChI *pStruct[INCHI_NUM][TAUT_NUM],
+                         InpInChI *pOneInput );
+int AddOneMsg( char *szMsg, int used_len, int tot_len, const char *szAddMsg, const char *szDelim );
+int FillOutCompareMessage( char *szMsg, int nLenMsg, INCHI_MODE bits[] );
+void clear_t_group_info( T_GROUP_INFO *ti );
+int bInpInchiComponentExists( InpInChI *pOneInput, int iINCHI, int bMobileH, int k );
+int bInpInchiComponentDeleted( InpInChI *pOneInput, int iInChI, int bMobileH, int k );
+int bRevInchiComponentExists( StrFromINChI *pStruct, int iInChI, int bMobileH, int k );
+int bRevInchiComponentDeleted( StrFromINChI *pStruct, int iInChI, int bMobileH, int k );
+int DetectInpInchiCreationOptions ( InpInChI *pOneInput, int *bHasReconnected, int *bHasMetal,
+                                    int *bHasFixedH, int *sFlag, int *bTautFlag );
+int DisplayStructureComponents( ICHICONST INPUT_PARMS *ip, STRUCT_DATA *sd, long num_inp, char *szCurHdr,
+                         ICHICONST SRM *pSrm, int bReqNonTaut, StrFromINChI *pStruct[INCHI_NUM][TAUT_NUM],
+                         InpInChI *pOneInput );
+int DisplayOneRestoredComponent( StrFromINChI *pStruct, inp_ATOM *at,
+                                 int iComponent, int nNumComponents, int bMobileH,
+                                 const char *szCurHdr );
+int DisplayAllRestoredComponents( inp_ATOM *at, int num_at, const char *szCurHdr );
+int CountStereoTypes( INChI *pInChI, int *num_known_SB, int *num_known_SC,
+                                     int *num_unk_und_SB, int *num_unk_und_SC,
+                                     int *num_SC_PIII, int *num_SC_AsIII);
+int GetNumNeighborsFromInchi( INChI *pInChI, AT_NUMB nAtNumber );
+int bIsUnsatCarbonInASmallRing( inp_ATOM *at, VAL_AT *pVA, int iat, BFS_Q *pbfsq, int min_ring_size );
+
+int MakeProtonComponent( StrFromINChI *pStruct, int iComponent, int num_prot );
+
+/* extra configurarion */
+#define KEEP_METAL_EDGE_FLOW                 0  /* counterexample: mdb0-1738.sdf.txt */
+#define MOVE_CHARGES_FROM_HETEREO_TO_METAL   0  /* disabled */
+#define FIX_ADD_PROTON_FOR_ADP               0  /* not used */
+
+#ifndef INCHI_ALL_CPP
+#ifdef __cplusplus
+}
+#endif
+#endif
+
+
+#endif