rino 0.1.0 → 0.2.0

data/ext/src/ichi_bns.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
  */
 
@@ -11,7 +11,7 @@
 #define __INCHI_BNS_H___
 
 #define BN_MAX_ALTP  16
-#define MAX_VERTEX 1024 /* including s; if vert[] has num_vert then MAX_VERTEX has (2*num_vert+2+FIRST_INDX) elements */
+/*#define MAX_VERTEX 1024*/ /* including s; if vert[] has num_vert then MAX_VERTEX has (2*num_vert+2+FIRST_INDX) elements */
 
 /* forward declarations */
 
@@ -34,6 +34,118 @@ typedef S_SHORT VertexFlow;
 
 #define BNS_EDGE_FORBIDDEN_MASK  1
 #define BNS_EDGE_FORBIDDEN_TEMP  2
+#define BNS_EDGE_FORBIDDEN_TEST  4
+
+/* BNS vertex types */
+
+#define BNS_VERT_TYPE_ATOM          0x0001
+#define BNS_VERT_TYPE_ENDPOINT      0x0002  /* attribute */
+#define BNS_VERT_TYPE_TGROUP        0x0004
+#define BNS_VERT_TYPE_C_POINT       0x0008
+#define BNS_VERT_TYPE_C_GROUP       0x0010
+#define BNS_VERT_TYPE_SUPER_TGROUP  0x0020
+#define BNS_VERT_TYPE_TEMP          0x0040
+
+#define BNS_VERT_TYPE__AUX          0x0080  /* vertex added to build charge substructures */
+#define BNS_VERT_TYPE_C_NEGATIVE    0x0100  /* negative charge group; attribute, should be used with BNS_VERT_TYPE_C_GROUP */
+#define BNS_VERT_TYPE_ACID          0x0200  /* only for this type are allowed paths: t_group-atom-c_group_neg (path_TACN) */
+#define BNS_VERT_TYPE_CARBON_GR     0x0400  /* charge of carbon atom; should be used with BNS_VT_C_POS, BNS_VT_C_NEG */
+#define BNS_VERT_TYPE_METAL_GR      0x0800  /* metal atom group; may be used alone or with BNS_VT_M_POS, BNS_VT_M_NEG */
+
+#define BNS_VERT_TYPE_ANY_GROUP    (BNS_VERT_TYPE_TGROUP | BNS_VERT_TYPE_C_GROUP | BNS_VERT_TYPE_SUPER_TGROUP)
+
+/* InChI->Structure */
+
+#define BNS_VT_C_POS     BNS_VERT_TYPE_C_GROUP                               /* positive charge group, heteroat */
+#define BNS_VT_C_NEG     (BNS_VERT_TYPE_C_GROUP | BNS_VERT_TYPE_C_NEGATIVE)  /* negative charge group, heteroat */
+#define BNS_VT_C_POS_C   (BNS_VT_C_POS | BNS_VERT_TYPE_CARBON_GR)            /* positive charge group, C, Si, Ge, Sn */
+#define BNS_VT_C_NEG_C   (BNS_VT_C_NEG | BNS_VERT_TYPE_CARBON_GR)            /* negative charge group, C, Si, Ge, Sn */
+#define BNS_VT_C_POS_M   (BNS_VT_C_POS | BNS_VERT_TYPE_METAL_GR)             /* positive charge group, metal */
+#define BNS_VT_C_NEG_M   (BNS_VT_C_NEG | BNS_VERT_TYPE_METAL_GR)             /* negative charge group, metal */
+#define BNS_VT_M_GROUP   BNS_VERT_TYPE_METAL_GR                              /* metal-group, flower vertex */
+
+#define BNS_VT_C_POS_ALL  (BNS_VERT_TYPE_SUPER_TGROUP | BNS_VERT_TYPE_C_GROUP)    /* supergroup (+) */
+#define BNS_VT_C_NEG_ALL  (BNS_VT_C_POS_ALL | BNS_VERT_TYPE_C_NEGATIVE) /* supergroup (-) */
+
+#define BNS_VT_CHRG_STRUCT  (BNS_VERT_TYPE__AUX | BNS_VERT_TYPE_TEMP)          /* ChargeStruct vertex */
+#define BNS_VT_YVCONNECTOR  BNS_VERT_TYPE__AUX                                 /* group connection */
+
+#define IS_BNS_VT_C_OR_CSUPER_GR(X) ((X) & BNS_VT_C_POS)
+#define IS_BNS_VT_C_GR(X)           (((X) & BNS_VT_C_POS_ALL) == BNS_VERT_TYPE_C_GROUP)
+#define IS_BNS_VT_CM_GR(X)          (((X) & BNS_VT_C_POS_M) == BNS_VT_C_POS_M) /* metal charge group */
+#define IS_BNS_VT_M_GR(X)           ((X) == BNS_VERT_TYPE_METAL_GR )  /* metal flower base or vertices */
+#define IS_BNS_VT_YVCONNECTOR(X)    (((X) & BNS_VERT_TYPE__AUX) && !((X) & BNS_VERT_TYPE_TEMP))
+#define IS_BNS_VT_CHRG_STRUCT(X)    (((X) & BNS_VERT_TYPE__AUX) &&  ((X) & BNS_VERT_TYPE_TEMP))
+#define IS_BNS_VT_ATOM(X)           ((X) & BNS_VERT_TYPE_ATOM)
+
+#define BNS_ADD_SUPER_TGROUP 1  /* reserve one more edge for a t-group to connect to a single super-t-group */
+#define NUM_KINDS_OF_GROUPS  2  /* 1 accounts for t-group kind, one more 1 accounts for c-group kind */
+
+#define BNS_ADD_ATOMS        2  /* max. number of fictitious atoms to add (except t-gtoups) */
+#define BNS_ADD_EDGES        1  /* max. number of edges to add to each atom (except edges to a t-group or c-group) */
+
+typedef enum tagAltPathConst {
+        iALTP_MAX_LEN,    /* 0 */
+        iALTP_FLOW,       /* 1 */
+        iALTP_PATH_LEN,   /* 2 */
+        iALTP_START_ATOM, /* 3 */
+        iALTP_END_ATOM,   /* 4 */
+        iALTP_NEIGHBOR,   /* 5 */
+        iALTP_HDR_LEN = iALTP_NEIGHBOR
+} ALT_CONST;
+
+#define ALTP_PATH_LEN(altp)             (altp)[iALTP_PATH_LEN].number  /* number of bonds = number of atoms-1*/
+#define ALTP_END_ATOM(altp)             (altp)[iALTP_END_ATOM].number
+#define ALTP_START_ATOM(altp)           (altp)[iALTP_START_ATOM].number
+#define ALTP_THIS_ATOM_NEIGHBOR(altp,X) (altp)[iALTP_NEIGHBOR+(X)].ineigh[0]  /* 0 <= X < path_len */
+#define ALTP_NEXT_ATOM_NEIGHBOR(altp,X) (altp)[iALTP_NEIGHBOR+(X)].ineigh[1]
+#define ALTP_CUR_THIS_ATOM_NEIGHBOR(altp) (altp)[iALTP_NEIGHBOR+ALTP_PATH_LEN(altp)].ineigh[0]  /* 0 <= X < path_len */
+#define ALTP_CUR_NEXT_ATOM_NEIGHBOR(altp) (altp)[iALTP_NEIGHBOR+ALTP_PATH_LEN(altp)].ineigh[1]
+#define ALTP_NEXT(altp)                 (++ALTP_PATH_LEN(altp))
+#define ALTP_PREV(altp)                 (--ALTP_PATH_LEN(altp))
+#define ALTP_MAY_ADD(altp)              (iALTP_NEIGHBOR + (altp)[iALTP_PATH_LEN].number < (altp)[iALTP_MAX_LEN].number)
+#define ALTP_ALLOCATED_LEN(altp)        (altp)[iALTP_MAX_LEN].number
+#define ALTP_DELTA(altp)                 (altp)[iALTP_FLOW].flow[0]
+#define ALTP_OVERFLOW(altp)             (altp)[iALTP_FLOW].flow[1]
+
+#define Vertex_s 0
+#define Vertex_t 1
+
+#define NO_VERTEX    -2
+#define BLOSSOM_BASE -1
+
+#define ADD_CAPACITY_RADICAL        1   /* add capacity to radical */
+
+#define MAX_BOND_EDGE_CAP           2  /* triple bond */
+#define AROM_BOND_EDGE_CAP          1
+#define MAX_TGROUP_EDGE_CAP         2  /* -NH2 provides max. capacity */
+
+/* edge to s or t */
+#define EDGE_FLOW_ST_MASK       0x3fff  /* mask for flow */
+#define EDGE_FLOW_ST_PATH       0x4000  /* mark: the edge belongs to the augmenting path */
+
+/* edges between other vertices */
+/* EdgeFlow defined as S_SHORT; change from S_CHAR made 9-23-2005 */
+#define EDGE_FLOW_MASK          0x3fff  /* mask for flow */
+#define EDGE_FLOW_PATH          0x4000  /* mark: the edge belongs to the augmenting path */
+
+/*********************************************************************************/
+#if( ADD_CAPACITY_RADICAL == 1 )  /* { */
+/*  -- do not treat triplets as moving dots -- 2004-02-18 --
+#define MAX_AT_FLOW(X) (((X).chem_bonds_valence - (X).valence)+\
+                       ((is_centerpoint_elem((X).el_number)||get_endpoint_valence((X).el_number))?\
+                           (((X).radical==RADICAL_DOUBLET)+2*((X).radical==RADICAL_TRIPLET)):0))
+*/
+#define MAX_AT_FLOW(X) (((X).chem_bonds_valence - (X).valence)+\
+                       ((is_centerpoint_elem((X).el_number)||get_endpoint_valence((X).el_number))?\
+                           (((X).radical==RADICAL_DOUBLET)/*+2*((X).radical==RADICAL_TRIPLET)*/):0))
+
+
+#else /* } ADD_CAPACITY_RADICAL { */
+
+#define MAX_AT_FLOW(X) (((X).chem_bonds_valence - (X).valence)
+
+#endif  /* } ADD_CAPACITY_RADICAL */
 
 /**************************** BNS_EDGE ************************************/
 typedef struct BnsEdge {
@@ -91,6 +203,7 @@ typedef struct BalancedNetworkStructure {
     /*int len_vertices; */    /* allocation size for BNS_VERTEX data */
     int num_bonds;        /* number of real bonds/2 = number of edges between real atoms */
     int num_edges;        /* number of currently in effect */
+    int num_iedges;       /* added 9-16-2005; used only in InChI Reversing */
     int num_added_edges;  /* number of added edges (not including edges to t-groups) */
     int nMaxAddEdges;     /* max. number edges of add to each atom (not including edges to t-groups) */
 
@@ -125,6 +238,10 @@ typedef struct BalancedNetworkStructure {
 } BN_STRUCT;
 
 /********************* BN_DATA *******************************************/
+typedef enum tagBnsRadSrchMode {
+    RAD_SRCH_NORM      = 0,   /* normal search for normalization */
+    RAD_SRCH_FROM_FICT = 1    /* search from fict. vertices to atoms */
+} BRS_MODE;
 typedef struct BalancedNetworkData {
     Vertex          *BasePtr;    /*[MAX_VERTEX];  pointer toward the base of C(v) */
     Edge            *SwitchEdge; /*[MAX_VERTEX];  a pair of vertices and an edge, implemented here as [*][2] array */
@@ -135,7 +252,14 @@ typedef struct BalancedNetworkData {
     Vertex          *Pv;         /*[MAX_VERTEX/2+1] */
     int             max_num_vertices; /* allocation size of all except Pu, Pv */
     int             max_len_Pu_Pv;    /* allocation size of Pu and Pv */
-
+#if( BNS_RAD_SEARCH == 1 )
+    Vertex         *RadEndpoints; /*[MAX_VERTEX*/
+    int             nNumRadEndpoints;
+    EdgeIndex      *RadEdges;
+    int             nNumRadEdges;
+    int             nNumRadicals;
+    BRS_MODE        bRadSrchMode; /* 1 => connect fict. vertices-radicals to the accessible atoms */
+#endif
 } BN_DATA;
 
 /* internal array size */
@@ -187,6 +311,16 @@ typedef struct tagBNS_FLOW_CHANGES {
 #define ALT_PATH_MODE_ADD2H_TST  8   /* test-add 2 H along alt. path A=-=B => AH-=-BH; restore changed bonds */
 #define ALT_PATH_MODE_REM_PROTON 9   /* remove proton, adjust bonds, charges, H-counts 2004-03-05 */
 
+typedef U_SHORT  bitWord;
+#define BIT_WORD_MASK  ((bitWord)~0)
+
+typedef struct tagNodeSet {
+    bitWord **bitword;
+    int num_set; /* number of sets */
+    int len_set; /* number of bitWords in each set */
+} NodeSet;
+
+
 #ifndef INCHI_ALL_CPP
 #ifdef __cplusplus
 extern "C" {
@@ -194,6 +328,47 @@ extern "C" {
 #endif
 
 
+/*********************************************************************************
+  bChangeFlow:
+      1 => change flow inside the BNS search
+      3 => change flow inside the BNS search and undo the flow change in the BNS structure here
+      4 => change bonds in the structure according to the flow
+      8 => make altern. bonds in the structure
+
+  Note: (bChangeFlow & 1) == 1 is needed for multiple runs
+**********************************************************************************/
+    
+/* "EF" = "Edge Flow" */
+#define BNS_EF_CHNG_FLOW      1  /* change Balanced Network (BN) flow inside the BNS search */
+#define BNS_EF_RSTR_FLOW      2  /* undo BN flow changes after BNS */
+#define BNS_EF_CHNG_RSTR      (BNS_EF_CHNG_FLOW | BNS_EF_RSTR_FLOW)
+#define BNS_EF_CHNG_BONDS     4  /* change bonds in the structure according to the BN flow */
+#define BNS_EF_ALTR_BONDS     8  /* make altern. bonds in the structure if the flow has changed */
+#define BNS_EF_UPD_RAD_ORI   16  /* update BN flow0 & Atom radical values:
+                                    flow0 := flow, radical:=st_cap - st_flow */
+#define BNS_EF_SET_NOSTEREO  32  /* in combination with BNS_EF_ALTR_BONDS only:
+                                    ALT12 bond cannot be stereogenic */
+#define BNS_EF_UPD_H_CHARGE  64  /* update charges and H-counts according to change flow to c- and t-group vertices */
+
+#define BNS_EF_SAVE_ALL     (BNS_EF_CHNG_FLOW | BNS_EF_CHNG_BONDS | BNS_EF_UPD_RAD_ORI)
+#define BNS_EF_ALTR_NS      (BNS_EF_ALTR_BONDS | BNS_EF_SET_NOSTEREO)
+
+#define BNS_EF_RAD_SRCH     128  /* search for rafical paths closures */
+
+
+
+int  SetBitCreate( void );
+int  NodeSetCreate( NodeSet *pSet, int n, int L );
+void NodeSetFree( NodeSet *pSet );
+
+int  IsNodeSetEmpty( NodeSet *cur_nodes, int k);
+int  DoNodeSetsIntersect( NodeSet *cur_nodes, int k1, int k2);
+void AddNodeSet2ToNodeSet1( NodeSet *cur_nodes, int k1, int k2);
+void NodeSetFromRadEndpoints( NodeSet *cur_nodes, int k, /*Node *v*/ Vertex RadEndpoints[], int num_v);
+void RemoveFromNodeSet( NodeSet *cur_nodes, int k, Vertex v[], int num_v);
+int  AddNodesToRadEndpoints( NodeSet *cur_nodes, int k, Vertex RadEndpoints[], Vertex vRad, int nStart, int nLen );
+
+
 int nExists2AtMoveAltPath( struct BalancedNetworkStructure *pBNS, struct BalancedNetworkData *pBD,
                            struct BN_AtomsAtTautGroup *pAATG, inp_ATOM *at, int num_atoms,
                            int jj2, int jj1, struct tagSaltChargeCandidate *s_candidate, int nNumCandidates,
@@ -221,6 +396,32 @@ int ReconnectTestAtomToTGroup( struct BalancedNetworkStructure *pBNS, int v1, in
 
 int bIsHardRemHCandidate(  inp_ATOM *at, int i, int *cSubType );
 
+/* moved from ichi_bns.c 2005-08-23 */
+int RunBalancedNetworkSearch( BN_STRUCT *pBNS, BN_DATA *pBD, int bChangeFlow );
+BN_STRUCT* AllocateAndInitBnStruct( inp_ATOM *at, int num_atoms, int nMaxAddAtoms, int nMaxAddEdges, int max_altp, int *num_changed_bonds );
+BN_STRUCT* DeAllocateBnStruct( BN_STRUCT *pBNS );
+int ReInitBnStructAltPaths( BN_STRUCT *pBNS );
+int ReInitBnStructForMoveableAltBondTest( BN_STRUCT *pBNS, inp_ATOM *at, int num_atoms );
+void ClearAllBnDataVertices( Vertex *v, Vertex value, int size );
+void ClearAllBnDataEdges( Edge *e, Vertex value, int size );
+BN_DATA *DeAllocateBnData( BN_DATA *pBD );
+BN_DATA *AllocateAndInitBnData( int max_num_vertices );
+int ReInitBnData( BN_DATA *pBD );
+int SetForbiddenEdges( BN_STRUCT *pBNS, inp_ATOM *at, int num_atoms, int edge_forbidden_mask );
+/* main function: find augmenting path */
+int BalancedNetworkSearch ( BN_STRUCT* pBNS, BN_DATA *pBD, int bChangeFlow );
+
+int SetRadEndpoints( BN_STRUCT *pBNS, BN_DATA *pBD, BRS_MODE bRadSrchMode );
+int SetRadEndpoints2( BN_STRUCT *pBNS, BN_DATA *pBD, BRS_MODE bRadSrchMode );
+
+int RemoveRadEndpoints( BN_STRUCT *pBNS, BN_DATA *pBD, inp_ATOM *at );
+
+int AddRemoveProtonsRestr( inp_ATOM *at, int num_atoms, int *num_protons_to_add,
+                           int nNumProtAddedByRestr, INCHI_MODE bNormalizationFlags,
+                           int num_tg, int nChargeRevrs, int nChargeInChI );
+int AddRemoveIsoProtonsRestr( inp_ATOM *at, int num_atoms, NUM_H num_protons_to_add[], int num_tg );
+
+
 #ifndef INCHI_ALL_CPP
 #ifdef __cplusplus
 }

data/ext/src/ichican2.c

@@ -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
  */
 
@@ -13,6 +13,7 @@
 #include <ctype.h>
 #include <limits.h>
 
+/* #define CHECK_WIN32_VC_HEAP */
 #include "mode.h"
 
 #include "ichi.h"
@@ -43,25 +44,6 @@
 /* #define INCHI_CANON_USE_HASH */
 #define INCHI_CANON_MIN
 
-#if ( defined(_DEBUG) && 0 )
-#include <malloc.h>
-#define HEAPCHK \
-do {\
-   int heapstatus = _heapchk(); \
-   switch( heapstatus ) \
-   { \
-   case _HEAPBADBEGIN: \
-      printf( "ERROR - bad start of heap %d\n", __LINE__ ); \
-      break; \
-   case _HEAPBADNODE: \
-      printf( "ERROR - bad node in heap %d\n", __LINE__ ); \
-      break; \
-   } \
-} while(0);
-#else
-#define HEAPCHK
-#endif
-
 /****************************************************************/
 #ifdef INCHI_CANON_USE_HASH
 typedef unsigned long  U_INT_32;
@@ -70,8 +52,10 @@ typedef U_INT_32       CtHash;
 CtHash hash_mark_bit;
 #endif
 
+/* -- moved to ichi_bns.h --
 typedef U_SHORT  bitWord;
 #define BIT_WORD_MASK  ((bitWord)~0)
+*/
 
 static bitWord *bBit = NULL;
 static int    num_bit = 0;     
@@ -100,12 +84,13 @@ typedef struct tagCell {
     int       prev;   /* position of the previously returned cell element */
 } Cell;
 
+#ifdef NEVER /* moved to ichi_bns.h */
 typedef struct tagNodeSet {
     bitWord **bitword;
     int num_set; /* number of sets */
     int len_set; /* number of bitWords in each set */
 } NodeSet;
-
+#endif
 
 typedef struct tagTransposition {
     AT_NUMB *nAtNumb;
@@ -178,7 +163,6 @@ int CanonGraph( int n, int n_tg, int n_max, int bDigraph, Graph *G, Partition pi
                 AT_RANK *nSymmRank,  AT_RANK *nCanonRank, AT_NUMB *nAtomNumberCanon,
                 CANON_DATA *pCD, CANON_COUNTS *pCC,
                 ConTable **pp_zb_rho_inp, ConTable **pp_zb_rho_out  );
-int SetBitCreate( void );
 
 void CtPartFill( Graph *G, CANON_DATA *pCD, Partition *p,
                  ConTable *Ct, int k, int n, int n_tg );
@@ -194,7 +178,7 @@ int CtFullCompareLayers( kLeast *kLeastForLayer );
 int CtCompareLayersGetFirstDiff( kLeast *kLeast_rho, int nOneAdditionalLayer,
                                  int *L_rho, int *I_rho, int *k_rho );
 int CtPartCompareLayers( kLeast *kLeast_rho, int L_rho_fix_prev, int nOneAdditionalLayer );
-void UpdateCompareLayers( kLeast kLeastForLayer[], int hz );
+void UpdateCompareLayers( kLeast kLeastForLayer[], int hzz );
 int GetOneAdditionalLayer( CANON_DATA *pCD, ConTable *pzb_rho_fix );
 
 void CleanNumH( NUM_H *NumH, int len );
@@ -227,8 +211,6 @@ void UnorderedPartitionFree( UnorderedPartition *p );
 int  UnorderedPartitionCreate( UnorderedPartition *p, int n );
 void CTableFree( ConTable *Ct );
 int  CTableCreate( ConTable *Ct, int n, CANON_DATA *pCD );
-int  NodeSetCreate( NodeSet *pSet, int n, int L );
-void NodeSetFree( NodeSet *pSet );
 void TranspositionFree( Transposition *p );
 int  TranspositionCreate( Transposition *p, int n );
 void TranspositionGetMcrAndFixSetAndUnorderedPartition( Transposition *gamma, NodeSet *McrSet, NodeSet *FixSet, int n, int l, UnorderedPartition *p );
@@ -484,6 +466,7 @@ void NodeSetFree( NodeSet *pSet )
             inchi_free( pSet->bitword[0] );
         }
         inchi_free( pSet->bitword );
+        pSet->bitword = NULL;
     }
 }
 /****************************************************************/
@@ -605,7 +588,7 @@ void UnorderedPartitionMakeDiscrete( UnorderedPartition *p, int n)
         p->equ2[i] = (AT_NUMB)i;
         /* p->next[i] = INFINITY; */
     }
-    HEAPCHK
+    INCHI_HEAPCHK
 }
 /****************************************************************/
 int PartitionCreate( Partition *p, int n)
@@ -638,11 +621,11 @@ int PartitionIsDiscrete( Partition *p, int n)
     AT_RANK r;
     for ( i = 0, r = 1; i < n; i ++, r ++ ) {
         if ( r != (rank_mask_bit & p->Rank[p->AtNumber[i]]) ) {
-            HEAPCHK
+            INCHI_HEAPCHK
             return 0;
         }
     }
-    HEAPCHK
+    INCHI_HEAPCHK
     return 1;
 }
 /****************************************************************/
@@ -665,12 +648,12 @@ int PartitionGetFirstCell( Partition *p, Cell *baseW, int k, int n )
                    i ++ )
             ;
         W->next = i;
-        HEAPCHK
+        INCHI_HEAPCHK
         return (W->next - W->first);
     }
     W->first = INFINITY;
     W->next  = 0;
-    HEAPCHK
+    INCHI_HEAPCHK
     return 0;
 }
 /****************************************************************/
@@ -680,7 +663,7 @@ void CellMakeEmpty( Cell *baseW, int k )
     baseW[k].first = INFINITY;
     baseW[k].next  = 0;
     baseW[k].prev  = -1;
-    HEAPCHK
+    INCHI_HEAPCHK
 }
 /****************************************************************/
 void NodeSetFromVertices( NodeSet *cur_nodes, int l, Node *v, int num_v)
@@ -695,7 +678,7 @@ void NodeSetFromVertices( NodeSet *cur_nodes, int l, Node *v, int num_v)
         j = (int)v[i]-1;
         Bits[ j / num_bit ] |= bBit[ j % num_bit ];
     }
-    HEAPCHK
+    INCHI_HEAPCHK
 }
 /****************************************************************/
 int AllNodesAreInSet(  NodeSet *cur_nodes, int lcur_nodes, NodeSet *set, int lset )
@@ -707,11 +690,11 @@ int AllNodesAreInSet(  NodeSet *cur_nodes, int lcur_nodes, NodeSet *set, int lse
     /* find any BitsNode[i] bit not in BitsSet[i] */
     for ( i = 0; i < n; i ++ ) {
         if ( BitsNode[i] & ~BitsSet[i] ) {
-            HEAPCHK
+            INCHI_HEAPCHK
             return 0;
         }
     }
-    HEAPCHK
+    INCHI_HEAPCHK
     return 1;
 }
 /****************************************************************/
@@ -738,7 +721,108 @@ void PartitionGetMcrAndFixSet( Partition *p, NodeSet *Mcr, NodeSet *Fix, int n,
             McrBits[j1 / num_bit] |= bBit[j1 % num_bit];
         }
     }
-    HEAPCHK
+    INCHI_HEAPCHK
+}
+/************* used in ichi_bns.c ********************************/
+void NodeSetFromRadEndpoints( NodeSet *cur_nodes, int k, /*Node *v*/ Vertex RadEndpoints[], int num_v)
+{
+    bitWord *Bits = cur_nodes->bitword[k];
+    int      len  = cur_nodes->len_set*sizeof(bitWord);
+    int      i, j;
+
+    memset( Bits, 0, len );
+
+    for ( i = 1; i < num_v; i += 2 ) {
+        j = (int)RadEndpoints[i];
+        Bits[ j / num_bit ] |= bBit[ j % num_bit ];
+    }
+}
+/************* used in ichi_bns.c ********************************/
+void RemoveFromNodeSet( NodeSet *cur_nodes, int k, Vertex v[], int num_v)
+{
+    if ( cur_nodes->bitword ) {
+        bitWord *Bits = cur_nodes->bitword[k];
+        /*int      len  = cur_nodes->len_set*sizeof(bitWord);*/
+        int      i, j;
+
+        for ( i = 0; i < num_v; i ++ ) {
+            j = (int) v[i];
+            Bits[ j / num_bit ] &= ~bBit[ j % num_bit ];
+        }
+    }
+}
+/************* used in ichi_bns.c ********************************/
+int DoNodeSetsIntersect( NodeSet *cur_nodes, int k1, int k2)
+{
+    if ( cur_nodes->bitword ) {
+        bitWord *Bits1 = cur_nodes->bitword[k1];
+        bitWord *Bits2 = cur_nodes->bitword[k2];
+        int      len  = cur_nodes->len_set;
+        int      i;
+
+        for ( i = 0; i < len; i ++ ) {
+            if ( Bits1[i] & Bits2[i] )
+                return 1;
+        }
+    }
+    return 0;
+}
+/************* used in ichi_bns.c ********************************/
+int IsNodeSetEmpty( NodeSet *cur_nodes, int k)
+{
+    if ( cur_nodes->bitword ) {
+        bitWord *Bits = cur_nodes->bitword[k];
+        int      len  = cur_nodes->len_set;
+        int      i;
+
+        for ( i = 0; i < len; i ++ ) {
+            if ( Bits[i] )
+                return 0;
+        }
+    }
+    return 1;
+}
+/************* used in ichi_bns.c ********************************/
+void AddNodeSet2ToNodeSet1( NodeSet *cur_nodes, int k1, int k2)
+{
+    if ( cur_nodes->bitword ) {
+        bitWord *Bits1 = cur_nodes->bitword[k1];
+        bitWord *Bits2 = cur_nodes->bitword[k2];
+        int      len  = cur_nodes->len_set;
+        int      i;
+
+        for ( i = 0; i < len; i ++ ) {
+            Bits1[i] |= Bits2[i];
+        }
+    }
+}
+/************* used in ichi_bns.c ********************************/
+int AddNodesToRadEndpoints( NodeSet *cur_nodes, int k, Vertex RadEndpoints[], Vertex vRad, int nStart, int nLen )
+{
+    int n = nStart;
+    if ( cur_nodes->bitword ) {
+        bitWord *Bits = cur_nodes->bitword[k];
+        int      len  = cur_nodes->len_set;
+        int      i, j;
+        Vertex   v;
+
+        for ( i = 0, v = 0; i < len; i ++ ) {
+            if ( Bits[i] ) {
+                for ( j = 0; j < num_bit; j ++, v ++ ) {
+                    if ( Bits[i] & bBit[j] ) {
+                        if ( n >= nLen ) {
+                            return -1; /* overflow */
+                        }
+                        RadEndpoints[n ++] = vRad;
+                        RadEndpoints[n ++] = v;
+                    }
+                }
+            } else {
+                v += num_bit;
+            }
+        }
+    }
+    return n;
 }
 /****************************************************************/
 void PartitionGetTransposition( Partition *pFrom, Partition *pTo, int n, Transposition *gamma )
@@ -747,7 +831,7 @@ void PartitionGetTransposition( Partition *pFrom, Partition *pTo, int n, Transpo
     for ( i = 0; i < n; i ++ ) {
         gamma->nAtNumb[(int)pFrom->AtNumber[i]] =pTo->AtNumber[i];
     }
-    HEAPCHK
+    INCHI_HEAPCHK
 }
 /**************************************************************************************/
 /*  Get minimal set (class) representative and partially compress the partitioning */
@@ -755,7 +839,7 @@ void PartitionGetTransposition( Partition *pFrom, Partition *pTo, int n, Transpo
 AT_RANK nGetMcr2( AT_RANK *nEqArray, AT_RANK n )
 {
     AT_RANK n1, n2, mcr; /*  recursive version is much shorter. */
-    HEAPCHK
+    INCHI_HEAPCHK
     n1=nEqArray[(int)n];
     if ( n == n1 ) {
         return n;
@@ -771,7 +855,7 @@ AT_RANK nGetMcr2( AT_RANK *nEqArray, AT_RANK n )
         nEqArray[(int)n1]=mcr;
         n1 = n2;
     }
-    HEAPCHK
+    INCHI_HEAPCHK
     return ( mcr );
 }
 /**************************************************************************************/
@@ -782,22 +866,22 @@ int nJoin2Mcrs2( AT_RANK *nEqArray, AT_RANK n1, AT_RANK n2 )
     n2 = nGetMcr2( nEqArray, n2 );
     if ( n1 < n2 ) {
         nEqArray[n2] = n1;
-        HEAPCHK
+        INCHI_HEAPCHK
         return 1; /*  a change has been made */
     }
     if ( n2 < n1 ) {
         nEqArray[n1] = n2;
-        HEAPCHK
+        INCHI_HEAPCHK
         return 1; /*  a change has been made */
     }
-    HEAPCHK
+    INCHI_HEAPCHK
     return 0; /*  no changes */
 }
 /****************************************************************/
 Node GetUnorderedPartitionMcrNode( UnorderedPartition *p1, Node v )
 {
     Node ret = (Node)(1+ nGetMcr2( p1->equ2, (AT_RANK)(v-1) ));
-    HEAPCHK
+    INCHI_HEAPCHK
     return ret;
 }
 /****************************************************************/
@@ -812,7 +896,7 @@ int UnorderedPartitionJoin( UnorderedPartition *p1, UnorderedPartition *p2, int
         }
         nNumChanges += nJoin2Mcrs2(p2->equ2, (AT_NUMB)i, (AT_NUMB)j );
     }
-    HEAPCHK
+    INCHI_HEAPCHK
     return nNumChanges;
 }
 /****************************************************************/
@@ -851,10 +935,10 @@ void PartitionCopy( Partition *To, Partition *From, int n )
     for ( i = 0; i < n; i ++ ) {
         To->Rank[i] &= rank_mask_bit;
     }
-    HEAPCHK
+    INCHI_HEAPCHK
 }
 /****************************************************************/
-/* makes new equitable partition (p+1) out of p */
+/* makes new equitable partition (p+1) out of p; first reduce the rank of vertex v */
 int PartitionColorVertex( Graph *G, Partition *p, Node v, int n, int n_tg, int n_max, int bDigraph, int nNumPrevRanks )
 {
     int     nNumNewRanks, i, j;
@@ -869,29 +953,31 @@ int PartitionColorVertex( Graph *G, Partition *p, Node v, int n, int n_tg, int n
             p[i].Rank = (AT_RANK *)inchi_malloc(n_max*sizeof(p[0].Rank[0]));
         }
         if ( !p[i].AtNumber || !p[i].Rank ) {
-            HEAPCHK
+            INCHI_HEAPCHK
             return CT_OUT_OF_RAM;
         }
     }
     PartitionCopy( p+1, p, n_tg );
     sv  = v-1;          /* atom number we are looking for */
     if ( sv >= (AT_NUMB) n_tg ) {
-        HEAPCHK
+        INCHI_HEAPCHK
         return CT_CANON_ERR; /* !!! severe program error: sv not found !!! */
     }
     rv = p[1].Rank[(int)sv];  /* rank of this atom */
-    /* locate sv */
+    /* second, locate sv among all vertices that have same rank as v */
+    s = n_max + 1; /* always greater than sv; this initialization is needed only to keep the compiler happy */
     for ( j = (int)rv-1;  0 <= j && rv == (r = p[1].Rank[(int)(s=p[1].AtNumber[j])]) && s != sv; j -- )
         ;
     if ( s != sv ) {
-        HEAPCHK
+        INCHI_HEAPCHK
         return CT_CANON_ERR; /* !!! severe program error: sv not found !!! */
     }
     /* shift preceding atom numbers to the right to fill the gap after removing sv */
+    r = rv-1; /* initialization only to keep compiler happy */
     for ( i = j--;  0 <= j && rv == (r = p[1].Rank[(int)(s=p[1].AtNumber[j])]); i = j, j -- ) {
         p[1].AtNumber[i] = s;
     }
-    r = (i > 0)? r+1:1;
+    r = (i > 0)? (r+1):1;  /* new reduced rank = (next lower rank)+1 or 1 */
     /* insert sv and adjust its rank */
     p[1].AtNumber[i] = sv;
     p[1].Rank[(int)sv] = r;
@@ -920,7 +1006,7 @@ int PartitionColorVertex( Graph *G, Partition *p, Node v, int n, int n_tg, int n
                                          nNumPrevRanks+1, p[1].Rank, p[2].Rank /* temp array */,
                                          p[1].AtNumber, &lNumNeighListIter );
     }
-    HEAPCHK
+    INCHI_HEAPCHK
 
     return nNumNewRanks;
 }
@@ -1048,7 +1134,7 @@ Node CellGetMinNode( Partition *p, Cell *W, Node v, CANON_DATA *pCD )
         }
     }
     if ( uMinAtNumb != INFINITY ) uMinAtNumb ++;
-    HEAPCHK
+    INCHI_HEAPCHK
     return uMinAtNumb;
 }
 /****************************************************************/
@@ -1062,7 +1148,7 @@ int CellGetNumberOfNodes( Partition *p, Cell *W )
             num++;
         }
     }
-    HEAPCHK
+    INCHI_HEAPCHK
     return num;
 }
 /****************************************************************/
@@ -1077,12 +1163,12 @@ int CellIntersectWithSet( Partition *p, Cell *W, NodeSet *Mcr, int l )
     }
     for ( i = first, k = 0; i < next; i ++ ) {
         j = (int)p->AtNumber[i];
-        if ( !(McrBits[ j / num_bit ] & bBit[ j % num_bit ]) ) {
+        if ( !(McrBits[ j / num_bit ] & bBit[ j % num_bit ]) ) { /* BC: reading uninit memory ???-not examined yet */
             k += !(p->Rank[j] & rank_mark_bit); /* for testing only */
             p->Rank[j] |= rank_mark_bit;
         }
     }
-    HEAPCHK
+    INCHI_HEAPCHK
     return k;
 }
 /****************************************************************/
@@ -1099,7 +1185,7 @@ void CtPartClear( ConTable *Ct, int k )
     Ct->lenCt = start;
     Ct->lenPos = k;
 
-    HEAPCHK
+    INCHI_HEAPCHK
 }
 /**********************************************************************************/
 /*  Sort neighbors according to ranks in ascending order */
@@ -1120,7 +1206,7 @@ void insertions_sort_NeighList_AT_NUMBERS2( NEIGH_LIST base, AT_RANK *nRank, AT_
          }
      }
   }
-  HEAPCHK
+  INCHI_HEAPCHK
 }
 /****************************************************************/
 /* may need previous Lambda */
@@ -1139,7 +1225,7 @@ void CtPartFill( Graph *G, CANON_DATA *pCD, Partition *p,
         count ++;
 
 
-    HEAPCHK
+    INCHI_HEAPCHK
     
     k --;
     if ( k ) {
@@ -1174,7 +1260,7 @@ void CtPartFill( Graph *G, CANON_DATA *pCD, Partition *p,
         }
     }
     
-    HEAPCHK
+    INCHI_HEAPCHK
 
     /****************** well-defined part of base hydrogen atoms *******************/
     if ( pCD->NumH && Ct->NumH ) {
@@ -1193,7 +1279,7 @@ void CtPartFill( Graph *G, CANON_DATA *pCD, Partition *p,
         Ct->lenNumH = 0;
     }
 
-    HEAPCHK
+    INCHI_HEAPCHK
 
     /****************** well-defined part of fixed hydrogen atoms *******************/
     if ( pCD->NumHfixed && Ct->NumHfixed ) {
@@ -1201,7 +1287,7 @@ void CtPartFill( Graph *G, CANON_DATA *pCD, Partition *p,
         for ( j = startAtOrd; j < nn; j ++ ) {
             Ct->NumHfixed[j] = pCD->NumHfixed[p->AtNumber[j]];
 
-    HEAPCHK
+    INCHI_HEAPCHK
 
         }
         /* Ct->lenNumHfixed = nn; */
@@ -1209,7 +1295,7 @@ void CtPartFill( Graph *G, CANON_DATA *pCD, Partition *p,
         ;/* Ct->lenNumHfixed = 0; */
     }
 
-    HEAPCHK
+    INCHI_HEAPCHK
 
     /****************** well-defined part of isotopic keys ***************************/
     if ( pCD->iso_sort_key && Ct->iso_sort_key ) {
@@ -1221,7 +1307,7 @@ void CtPartFill( Graph *G, CANON_DATA *pCD, Partition *p,
         Ct->len_iso_sort_key = 0;
     }
 
-    HEAPCHK
+    INCHI_HEAPCHK
 
     /****************** well-defined part of isotopic iso_exchg_atnos ***************************/
     if ( pCD->iso_exchg_atnos && Ct->iso_exchg_atnos ) {
@@ -1233,7 +1319,7 @@ void CtPartFill( Graph *G, CANON_DATA *pCD, Partition *p,
         Ct->len_iso_exchg_atnos = 0;
     }
 
-    HEAPCHK
+    INCHI_HEAPCHK
     /******** well-defined part of isotopic keys for fixed hydrogen atoms ************/
 #if ( USE_ISO_SORT_KEY_HFIXED == 1 )
     if ( pCD->iso_sort_key_Hfixed && Ct->iso_sort_key_Hfixed ) {
@@ -1247,7 +1333,7 @@ void CtPartFill( Graph *G, CANON_DATA *pCD, Partition *p,
     }
 #endif
 
-    HEAPCHK
+    INCHI_HEAPCHK
 
     Ct->lenCt          = startCtbl; /* not aways increases */
     Ct->nextCtblPos[k] = startCtbl;
@@ -1270,7 +1356,7 @@ void CtPartFill( Graph *G, CANON_DATA *pCD, Partition *p,
     Ct->hash[k] = hash;
 #endif        
 
-    HEAPCHK
+    INCHI_HEAPCHK
 }
 /****************************************************************/
 void CtPartInfinity( ConTable *Ct, S_CHAR *cmp, int k )
@@ -1291,7 +1377,7 @@ void CtPartInfinity( ConTable *Ct, S_CHAR *cmp, int k )
     if ( !startCtbl || Ct->Ctbl[startCtbl-1] != EMPTY_CT ) {
         Ct->Ctbl[startCtbl] = EMPTY_CT;
     }
-    HEAPCHK
+    INCHI_HEAPCHK
 }
 /****************************************************************/
 /* Return value:
@@ -1328,7 +1414,7 @@ int CtPartCompare( ConTable *Ct1, ConTable *Ct2, S_CHAR *cmp,
 {
     int     startCt1, endCt1, startCt2, endCt2; /*endCt,*/
     int     startAt1, endAt1, startAt2, endAt2; /*endCt,*/
-    int     midCt /* end of atoms only Ct */, midNumH /* end of atoms only NumH */, maxVert;
+    int     midCt /* end of atoms only Ct */, midNumH=0 /* end of atoms only NumH */, maxVert;
     int     diff, i, k1, k2, lenNumH, len_iso_sort_key, /*mid_iso_sort_key,*/ midAt;
     int     nLayer = 0;
 
@@ -1348,7 +1434,7 @@ int CtPartCompare( ConTable *Ct1, ConTable *Ct2, S_CHAR *cmp,
 
         meaning:
         ========
-        abs(kLeastForLayer[nLayer]) is the greatest level k at which
+        abs(kLeastForLayer[nLayer].k) is the greatest level k at which
         difference at layer nLayer are zeroes of hidden by differences in smaller nLayer.
         
         "Hidden by difference in smaller level" means that nLayer of comparison
@@ -1716,7 +1802,7 @@ int CtFullCompare( ConTable *Ct1, ConTable *Ct2, int bOnlyCommon, int bSplitTaut
     int     startCt1, endCt1, startCt2, endCt2; /*endCt,*/
     int     startAt1, endAt1, startAt2, endAt2; /*endCt,*/
     int     midCt   /* end of atoms only in Ctbl */,
-            midNumH /* end of atoms only NumH */,
+            midNumH = 0 /* end of atoms only NumH */,
             midAt   /* end of atoms only */;
     int     diff, i, k1, k2, lenNumH1, lenNumH2, lenNumH, maxVert /* min num atoms */;
     int     len_iso_sort_key1, len_iso_sort_key2, len_iso_sort_key /*, mid_iso_sort_key*/;
@@ -1941,12 +2027,12 @@ int CtPartCompareLayers( kLeast *kLeast_rho, int L_rho_fix_prev, int nOneAdditio
     return 0;
 }
 /****************************************************************/
-void UpdateCompareLayers( kLeast kLeastForLayer[], int hz )
+void UpdateCompareLayers( kLeast kLeastForLayer[], int hzz )
 {
     int i;
     if ( kLeastForLayer ) {
         for ( i = 0; i < MAX_LAYERS; i ++ ) {
-            if ( abs(kLeastForLayer[i].k) >= hz ) {
+            if ( abs(kLeastForLayer[i].k) >= hzz ) {
                 kLeastForLayer[i].k = 0;
                 kLeastForLayer[i].i = 0;
             }
@@ -2061,7 +2147,7 @@ void CtPartCopy( ConTable *Ct1 /* to */, ConTable *Ct2 /* from */, int k )
     Ct1->hash[k]        = Ct2->hash[k];
 #endif
     Ct1->lenPos         = k+1;
-    HEAPCHK
+    INCHI_HEAPCHK
 }
 /****************************************************************/
 void CtFullCopy( ConTable *Ct1, ConTable *Ct2 )
@@ -2128,7 +2214,7 @@ void TranspositionGetMcrAndFixSetAndUnorderedPartition( Transposition *gamma, No
     for ( i = 0; i < n; i ++ ) {
         gamma->nAtNumb[i] &= rank_mask_bit;
     }
-    HEAPCHK
+    INCHI_HEAPCHK
 }
 /****************************************************************/
 int SetBitCreate( void )
@@ -2141,7 +2227,7 @@ int SetBitCreate( void )
     int    i;
 
     if ( bBit ) {
-        HEAPCHK
+        INCHI_HEAPCHK
         return 0; /* already created */
     }
 
@@ -2151,7 +2237,7 @@ int SetBitCreate( void )
         ;
     bBit = (bitWord*)inchi_calloc( num_bit, sizeof(bitWord));
     if ( !bBit ) {
-        HEAPCHK
+        INCHI_HEAPCHK
         return -1; /* failed */
     }
     for ( i = 0, b1=1; i < num_bit; i++, b1 <<= 1 ) {
@@ -2168,7 +2254,7 @@ int SetBitCreate( void )
         ;
     hash_mark_bit = h1;
 #endif
-    HEAPCHK
+    INCHI_HEAPCHK
     return 1;
 }
 /****************************************************************/
@@ -2177,10 +2263,10 @@ int SetBitFree( void )
     if ( bBit ) {
         inchi_free( bBit );
         bBit = NULL;
-        HEAPCHK
+        INCHI_HEAPCHK
         return 1; /* success */
     }
-    HEAPCHK
+    INCHI_HEAPCHK
     return 0; /* already destroyed */
 }
 #ifdef NEVER  /* { how to renumber a graph */
@@ -2568,7 +2654,7 @@ int CanonGraph( int n, int n_tg, int n_max, int bDigraph, Graph *G, Partition pi
     Cell *W;  /* W[i] is the first non-trivial cell of pi[i+1] */ 
     Node *v;  /* v[i] is in W[i] to create T(G,pi,nu[i+1]) */
     Node tvc, tvh;
-    S_CHAR *e, *qzb=NULL;
+    S_CHAR *e, *qzb=NULL;   /* qzb = NULL always */
     /* current node CT */
     ConTable Lambda;
     /* first leaf CT */
@@ -2629,8 +2715,13 @@ int CanonGraph( int n, int n_tg, int n_max, int bDigraph, Graph *G, Partition pi
     ok &= UnorderedPartitionCreate( &theta_from_gamma, n_tg );
 
     ok &= (NULL != (W   = (Cell*)inchi_calloc(n_tg, sizeof(W[0]))));
+    ok &= (NULL != (v   = (Node*)inchi_calloc(n_tg, sizeof(v[0]))));
+    ok &= (NULL != (e   = (S_CHAR*)inchi_calloc(n_tg, sizeof(e[0]))));
+
+/*
     ok &= (NULL != (v   = (Node*)inchi_calloc(n_tg, sizeof(W[0]))));
     ok &= (NULL != (e   = (S_CHAR*)inchi_calloc(n_tg, sizeof(W[0]))));
+*/
 
     /*    ok &= (NULL != (qzb = (S_CHAR*)calloc(n_tg, sizeof(W[0])))); */
     ok &= CTableCreate( &Lambda, n, pCD );
@@ -2646,7 +2737,7 @@ int CanonGraph( int n, int n_tg, int n_max, int bDigraph, Graph *G, Partition pi
     ok &= PartitionCreate( &rho, n_tg);
     ok &= TranspositionCreate( &gamma, n_tg );
 
-    HEAPCHK
+    INCHI_HEAPCHK
 
     
 /*L1:*/
@@ -2692,7 +2783,7 @@ int CanonGraph( int n, int n_tg, int n_max, int bDigraph, Graph *G, Partition pi
     e[k-1] = 0;
     */
     CtPartClear( &Lambda, 1 ); 
-    HEAPCHK
+    INCHI_HEAPCHK
 
 /* L2: reach the first leaf and save it in zeta and rho */
     while( k ) {
@@ -2810,6 +2901,17 @@ L2:
         qzb_rho_fix = CtPartCompare( &Lambda, pzb_rho_fix, qzb, kLeast_rho_fix, k-1, 1, bSplitTautCompare );
         if ( !qzb_rho_fix && bRhoIsDiscrete ) {
             qzb_rho_fix = CtPartCompareLayers( kLeast_rho_fix, L_rho_fix_prev, nOneAdditionalLayer );
+
+#if( FIX_ChCh_CONSTIT_CANON_BUG == 1 )
+            if ( qzb_rho_fix ) {
+                int L_rho_fix_diff = abs(qzb_rho_fix)-1;
+                if ( L_rho_fix_diff < L_rho_fix_prev ||
+                     L_rho_fix_diff == L_rho_fix_prev && kLeast_rho_fix[L_rho_fix_diff].i < I_rho_fix_prev ) {
+                    qzb_rho_fix = L_rho_fix_diff+1; /* positive difference will be rejected */
+                }
+            }
+#endif
+
 #if( bRELEASE_VERSION != 1 && defined(_DEBUG) )
             if ( qzb_rho_fix ) {
                 int stop = 1; /* debug only */
@@ -2839,6 +2941,15 @@ L2:
             /* new code */
             if ( !qzb_rho && bRhoIsDiscrete ) {
                 qzb_rho = CtPartCompareLayers( kLeast_rho, L_rho_fix_prev, 0 );
+#if( FIX_ChCh_CONSTIT_CANON_BUG == 1 )
+                if ( qzb_rho ) {
+                    int L_rho_diff = abs(qzb_rho)-1;
+                    if ( L_rho_diff < L_rho_fix_prev ||
+                         L_rho_diff == L_rho_fix_prev && kLeast_rho[L_rho_diff].i < I_rho_fix_prev ) {
+                        qzb_rho = -(L_rho_diff+1); /* negative difference will be rejected */
+                    }
+                }
+#endif
             }
             /* compare old results to new */
 #if( bRELEASE_VERSION != 1 && defined(_DEBUG) )
@@ -3207,7 +3318,7 @@ exit_function:
     }
     
 exit_error:
-    HEAPCHK
+    INCHI_HEAPCHK
 
     UnorderedPartitionFree( &theta );
     UnorderedPartitionFree( &theta_from_gamma );
@@ -3786,7 +3897,7 @@ int GetBaseCanonRanking( int num_atoms, int num_at_tg, sp_ATOM* at[],
         if ( !(NeighList[TAUT_NON] = CreateNeighList( num_atoms, num_atoms, at_base, 0, NULL )) )
             goto exit_error_alloc;
         NeighList[TAUT_YES] = NULL;
-        HEAPCHK
+        INCHI_HEAPCHK
     }
 
     /* avoid memory leaks in case of error */
@@ -4062,7 +4173,7 @@ int GetBaseCanonRanking( int num_atoms, int num_at_tg, sp_ATOM* at[],
             for ( i = 0; i < num_atoms; i ++ ) {
                 if ( iso_sort_key_NoTautH[i] != iso_sort_key_NoTautH[nTempRank[nSymmRankNoTautH[i]-1]] ) {
                     pCD[iOther].nCanonFlags |= CANON_FLAG_ISO_ONLY_NON_TAUT_DIFF;
-                    break; /* atoms so far found to be equivalent have different number of H; the canonicalization is needed */
+                    break; /* atoms so far found to be equivalent differ in isotopes; the canonicalization is needed */
                 }
             }
         } else {